From xen-devel-bounces@lists.xen.org Thu Nov 01 20:34:26 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 01 Nov 2012 20:34:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TU1Su-00051h-2J; Thu, 01 Nov 2012 20:34:12 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TU1Sr-000519-2g for xen-devel@lists.xen.org; Thu, 01 Nov 2012 20:34:09 +0000 Received: from [85.158.138.51:41257] by server-15.bemta-3.messagelabs.com id 27/F9-09445-FBCD2905; Thu, 01 Nov 2012 20:34:07 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-8.tower-174.messagelabs.com!1351802041!28289883!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.0 required=7.0 tests=UNPARSEABLE_RELAY X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 24016 invoked from network); 1 Nov 2012 20:34:03 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-8.tower-174.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 1 Nov 2012 20:34:03 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.148030871; Thu, 01 Nov 2012 16:33:38 -0400 From: Matthew Fioravante To: Ian.Campbell@citrix.com, xen-devel@lists.xen.org, samuel.thibault@ens-lyon.org Date: Thu, 1 Nov 2012 16:33:26 -0400 Message-Id: <1351802007-19178-3-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1351802007-19178-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1351802007-19178-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM 3/9] add tpmfront, tpm_tis, and tpmback drivers to mini-os 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 patch adds 3 new drivers to mini-os. tpmfront - paravirtualized tpm frontend driver tpmback - paravirtualized tpm backend driver tpm_tis - hardware tpm driver Unfortunately these drivers were derived from GPL licensed linux kernel drivers so they must carry the GPL license. However, since mini-os now supports conditional compilation, hopefully these drivers can be included into the xen tree and conditionally removed from non-gpl projects. By default they are disabled in the makefile. Signed-off-by: Matthew Fioravante diff --git a/extras/mini-os/Makefile b/extras/mini-os/Makefile index 2422db3..2302a23 100644 --- a/extras/mini-os/Makefile +++ b/extras/mini-os/Makefile @@ -22,6 +22,9 @@ CONFIG_QEMU_XS_ARGS ?= n CONFIG_TEST ?= n CONFIG_PCIFRONT ?= n CONFIG_BLKFRONT ?= y +CONFIG_TPMFRONT ?= n +CONFIG_TPM_TIS ?= n +CONFIG_TPMBACK ?= n CONFIG_NETFRONT ?= y CONFIG_FBFRONT ?= y CONFIG_KBDFRONT ?= y @@ -36,6 +39,9 @@ flags-$(CONFIG_SPARSE_BSS) += -DCONFIG_SPARSE_BSS flags-$(CONFIG_QEMU_XS_ARGS) += -DCONFIG_QEMU_XS_ARGS flags-$(CONFIG_PCIFRONT) += -DCONFIG_PCIFRONT flags-$(CONFIG_BLKFRONT) += -DCONFIG_BLKFRONT +flags-$(CONFIG_TPMFRONT) += -DCONFIG_TPMFRONT +flags-$(CONFIG_TPM_TIS) += -DCONFIG_TPM_TIS +flags-$(CONFIG_TPMBACK) += -DCONFIG_TPMBACK flags-$(CONFIG_NETFRONT) += -DCONFIG_NETFRONT flags-$(CONFIG_KBDFRONT) += -DCONFIG_KBDFRONT flags-$(CONFIG_FBFRONT) += -DCONFIG_FBFRONT @@ -67,6 +73,9 @@ TARGET := mini-os SUBDIRS := lib xenbus console src-$(CONFIG_BLKFRONT) += blkfront.c +src-$(CONFIG_TPMFRONT) += tpmfront.c +src-$(CONFIG_TPM_TIS) += tpm_tis.c +src-$(CONFIG_TPMBACK) += tpmback.c src-y += daytime.c src-y += events.c src-$(CONFIG_FBFRONT) += fbfront.c diff --git a/extras/mini-os/include/lib.h b/extras/mini-os/include/lib.h index d4641b6..935bede 100644 --- a/extras/mini-os/include/lib.h +++ b/extras/mini-os/include/lib.h @@ -142,6 +142,8 @@ enum fd_type { FTYPE_FB, FTYPE_MEM, FTYPE_SAVEFILE, + FTYPE_TPMFRONT, + FTYPE_TPM_TIS, }; LIST_HEAD(evtchn_port_list, evtchn_port_info); @@ -185,6 +187,20 @@ extern struct file { struct { struct consfront_dev *dev; } cons; +#ifdef CONFIG_TPMFRONT + struct { + struct tpmfront_dev *dev; + int respgot; + off_t offset; + } tpmfront; +#endif +#ifdef CONFIG_TPM_TIS + struct { + struct tpm_chip *dev; + int respgot; + off_t offset; + } tpm_tis; +#endif #ifdef CONFIG_XENBUS struct { /* To each xenbus FD is associated a queue of watch events for this diff --git a/extras/mini-os/include/tpm_tis.h b/extras/mini-os/include/tpm_tis.h new file mode 100644 index 0000000..1faca0d --- /dev/null +++ b/extras/mini-os/include/tpm_tis.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm.c + * from the linux kernel + * + * Copyright (C) 2004 IBM Corporation + * + * This code has also been derived from drivers/char/tpm/tpm_tis.c + * from the linux kernel + * + * Copyright (C) 2005, 2006 IBM Corporation + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#ifndef TPM_TIS_H +#define TPM_TIS_H + +#include +#include + +#define TPM_TIS_EN_LOCL0 1 +#define TPM_TIS_EN_LOCL1 (1 << 1) +#define TPM_TIS_EN_LOCL2 (1 << 2) +#define TPM_TIS_EN_LOCL3 (1 << 3) +#define TPM_TIS_EN_LOCL4 (1 << 4) +#define TPM_TIS_EN_LOCLALL (TPM_TIS_EN_LOCL0 | TPM_TIS_EN_LOCL1 | TPM_TIS_EN_LOCL2 | TPM_TIS_EN_LOCL3 | TPM_TIS_EN_LOCL4) +#define TPM_TIS_LOCL_INT_TO_FLAG(x) (1 << x) +#define TPM_BASEADDR 0xFED40000 +#define TPM_PROBE_IRQ 0xFFFF + +struct tpm_chip; + +struct tpm_chip* init_tpm_tis(unsigned long baseaddr, int localities, unsigned int irq); +void shutdown_tpm_tis(struct tpm_chip* tpm); + +int tpm_tis_request_locality(struct tpm_chip* tpm, int locality); +int tpm_tis_cmd(struct tpm_chip* tpm, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen); + +#ifdef HAVE_LIBC +#include +#include +/* POSIX IO functions: + * use tpm_tis_open() to get a file descriptor to the tpm device + * use write() on the fd to send a command to the backend. You must + * include the entire command in a single call to write(). + * use read() on the fd to read the response. You can use + * fstat() to get the size of the response and lseek() to seek on it. + */ +int tpm_tis_open(struct tpm_chip* tpm); +int tpm_tis_posix_read(int fd, uint8_t* buf, size_t count); +int tpm_tis_posix_write(int fd, const uint8_t* buf, size_t count); +int tpm_tis_posix_fstat(int fd, struct stat* buf); +#endif + +#endif diff --git a/extras/mini-os/include/tpmback.h b/extras/mini-os/include/tpmback.h new file mode 100644 index 0000000..ff86732 --- /dev/null +++ b/extras/mini-os/include/tpmback.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/xen/tpmback/tpmback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netback/netback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This code has also been derived from drivers/xen/tpmback/xenbus.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2005 IBM Corporation + * Copyright (C) 2005 Rusty Russell + * + * This code has also been derived from drivers/xen/tpmback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself also derived from drvivers/xen/netback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2004, Keir Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ + +#include +#include +#include +#include +#ifndef TPMBACK_H +#define TPMBACK_H + +struct tpmcmd { + domid_t domid; /* Domid of the frontend */ + unsigned int handle; /* Handle of the frontend */ + unsigned char uuid[16]; /* uuid of the tpm interface */ + + unsigned int req_len; /* Size of the command in buf - set by tpmback driver */ + uint8_t* req; /* tpm command bits, allocated by driver, DON'T FREE IT */ + unsigned int resp_len; /* Size of the outgoing command, + you set this before passing the cmd object to tpmback_resp */ + uint8_t* resp; /* Buffer for response - YOU MUST ALLOCATE IT, YOU MUST ALSO FREE IT */ +}; +typedef struct tpmcmd tpmcmd_t; + +/* Initialize the tpm backend driver */ +void init_tpmback(void); + +/* Shutdown tpm backend driver */ +void shutdown_tpmback(void); + +/* Blocks until a tpm command is sent from any front end. + * Returns a pointer to the tpm command to handle. + * Do not try to free this pointer or the req buffer + * This function will return NULL if the tpm backend driver + * is shutdown or any other error occurs */ +tpmcmd_t* tpmback_req_any(void); + +/* Blocks until a tpm command from the frontend at domid/handle + * is sent. + * Returns NULL if domid/handle is not connected, tpmback is + * shutdown or shutting down, or if there is an error + */ +tpmcmd_t* tpmback_req(domid_t domid, unsigned int handle); + +/* Send the response to the tpm command back to the frontend + * This function will free the tpmcmd object, but you must free the resp + * buffer yourself */ +void tpmback_resp(tpmcmd_t* tpmcmd); + +/* Waits for the first frontend to connect and then sets domid and handle appropriately. + * If one or more frontends are already connected, this will set domid and handle to one + * of them arbitrarily. The main use for this function is to wait until a single + * frontend connection has occured. + * returns 0 on success, non-zero on failure */ +int tpmback_wait_for_frontend_connect(domid_t *domid, unsigned int *handle); + +/* returns the number of frontends connected */ +int tpmback_num_frontends(void); + +/* Returns the uuid of the specified frontend, NULL on error. + * The return value is internally allocated, so don't free it */ +unsigned char* tpmback_get_uuid(domid_t domid, unsigned int handle); + +/* Specify a function to call when a new tpm device connects */ +void tpmback_set_open_callback(void (*cb)(domid_t, unsigned int)); + +/* Specify a function to call when a tpm device disconnects */ +void tpmback_set_close_callback(void (*cb)(domid_t, unsigned int)); + +//Not Implemented +void tpmback_set_suspend_callback(void (*cb)(domid_t, unsigned int)); +void tpmback_set_resume_callback(void (*cb)(domid_t, unsigned int)); + +#endif diff --git a/extras/mini-os/include/tpmfront.h b/extras/mini-os/include/tpmfront.h new file mode 100644 index 0000000..fd2cb17 --- /dev/null +++ b/extras/mini-os/include/tpmfront.h @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm_vtpm.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2006 IBM Corporation + * + * This code has also been derived from drivers/char/tpm_xen.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netfront/netfront.c + * from the linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, version 2 of the + * License. + */ +#ifndef TPMFRONT_H +#define TPMFRONT_H + +#include +#include +#include +#include +#include +#include +#include + +struct tpmfront_dev { + grant_ref_t ring_ref; + evtchn_port_t evtchn; + + tpmif_tx_interface_t* tx; + + void** pages; + + domid_t bedomid; + char* nodename; + char* bepath; + + XenbusState state; + + uint8_t waiting; + struct wait_queue_head waitq; + + uint8_t* respbuf; + size_t resplen; + +#ifdef HAVE_LIBC + int fd; +#endif + +}; + + +/*Initialize frontend */ +struct tpmfront_dev* init_tpmfront(const char* nodename); +/*Shutdown frontend */ +void shutdown_tpmfront(struct tpmfront_dev* dev); + +/* Send a tpm command to the backend and wait for the response + * + * @dev - frontend device + * @req - request buffer + * @reqlen - length of request buffer + * @resp - *resp will be set to internal response buffer, don't free it! Value is undefined on error + * @resplen - *resplen will be set to the length of the response. Value is undefined on error + * + * returns 0 on success, non zero on failure. + * */ +int tpmfront_cmd(struct tpmfront_dev* dev, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen); + +#ifdef HAVE_LIBC +#include +/* POSIX IO functions: + * use tpmfront_open() to get a file descriptor to the tpm device + * use write() on the fd to send a command to the backend. You must + * include the entire command in a single call to write(). + * use read() on the fd to read the response. You can use + * fstat() to get the size of the response and lseek() to seek on it. + */ +int tpmfront_open(struct tpmfront_dev* dev); +int tpmfront_posix_read(int fd, uint8_t* buf, size_t count); +int tpmfront_posix_write(int fd, const uint8_t* buf, size_t count); +int tpmfront_posix_fstat(int fd, struct stat* buf); +#endif + + +#endif diff --git a/extras/mini-os/lib/sys.c b/extras/mini-os/lib/sys.c index 6cb97b1..d212969 100644 --- a/extras/mini-os/lib/sys.c +++ b/extras/mini-os/lib/sys.c @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include #include @@ -294,6 +296,16 @@ int read(int fd, void *buf, size_t nbytes) return blkfront_posix_read(fd, buf, nbytes); } #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: { + return tpmfront_posix_read(fd, buf, nbytes); + } +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: { + return tpm_tis_posix_read(fd, buf, nbytes); + } +#endif default: break; } @@ -330,6 +342,14 @@ int write(int fd, const void *buf, size_t nbytes) case FTYPE_BLK: return blkfront_posix_write(fd, buf, nbytes); #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + return tpmfront_posix_write(fd, buf, nbytes); +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + return tpm_tis_posix_write(fd, buf, nbytes); +#endif default: break; } @@ -341,8 +361,16 @@ int write(int fd, const void *buf, size_t nbytes) off_t lseek(int fd, off_t offset, int whence) { switch(files[fd].type) { +#if defined(CONFIG_BLKFRONT) || defined(CONFIG_TPMFRONT) || defined(CONFIG_TPM_TIS) #ifdef CONFIG_BLKFRONT case FTYPE_BLK: +#endif +#ifdef CONFIG_TPMFRNT + case FTYPE_TPMFRONT: +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: +#endif switch (whence) { case SEEK_SET: files[fd].file.offset = offset; @@ -420,6 +448,18 @@ int close(int fd) files[fd].type = FTYPE_NONE; return 0; #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + shutdown_tpmfront(files[fd].tpmfront.dev); + files[fd].type = FTYPE_NONE; + return 0; +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + shutdown_tpm_tis(files[fd].tpm_tis.dev); + files[fd].type = FTYPE_NONE; + return 0; +#endif #ifdef CONFIG_KBDFRONT case FTYPE_KBD: shutdown_kbdfront(files[fd].kbd.dev); @@ -489,6 +529,14 @@ int fstat(int fd, struct stat *buf) case FTYPE_BLK: return blkfront_posix_fstat(fd, buf); #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + return tpmfront_posix_fstat(fd, buf); +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + return tpm_tis_posix_fstat(fd, buf); +#endif default: break; } diff --git a/extras/mini-os/tpm_tis.c b/extras/mini-os/tpm_tis.c new file mode 100644 index 0000000..e8ca69f --- /dev/null +++ b/extras/mini-os/tpm_tis.c @@ -0,0 +1,1354 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm.c + * from the linux kernel + * + * Copyright (C) 2004 IBM Corporation + * + * This code has also been derived from drivers/char/tpm/tpm_tis.c + * from the linux kernel + * + * Copyright (C) 2005, 2006 IBM Corporation + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef min + #define min( a, b ) ( ((a) < (b)) ? (a) : (b) ) +#endif + +#define TPM_HEADER_SIZE 10 + +#define TPM_BUFSIZE 2048 + +struct tpm_input_header { + uint16_t tag; + uint32_t length; + uint32_t ordinal; +}__attribute__((packed)); + +struct tpm_output_header { + uint16_t tag; + uint32_t length; + uint32_t return_code; +}__attribute__((packed)); + +struct stclear_flags_t { + uint16_t tag; + uint8_t deactivated; + uint8_t disableForceClear; + uint8_t physicalPresence; + uint8_t physicalPresenceLock; + uint8_t bGlobalLock; +}__attribute__((packed)); + +struct tpm_version_t { + uint8_t Major; + uint8_t Minor; + uint8_t revMajor; + uint8_t revMinor; +}__attribute__((packed)); + +struct tpm_version_1_2_t { + uint16_t tag; + uint8_t Major; + uint8_t Minor; + uint8_t revMajor; + uint8_t revMinor; +}__attribute__((packed)); + +struct timeout_t { + uint32_t a; + uint32_t b; + uint32_t c; + uint32_t d; +}__attribute__((packed)); + +struct duration_t { + uint32_t tpm_short; + uint32_t tpm_medium; + uint32_t tpm_long; +}__attribute__((packed)); + +struct permanent_flags_t { + uint16_t tag; + uint8_t disable; + uint8_t ownership; + uint8_t deactivated; + uint8_t readPubek; + uint8_t disableOwnerClear; + uint8_t allowMaintenance; + uint8_t physicalPresenceLifetimeLock; + uint8_t physicalPresenceHWEnable; + uint8_t physicalPresenceCMDEnable; + uint8_t CEKPUsed; + uint8_t TPMpost; + uint8_t TPMpostLock; + uint8_t FIPS; + uint8_t operator; + uint8_t enableRevokeEK; + uint8_t nvLocked; + uint8_t readSRKPub; + uint8_t tpmEstablished; + uint8_t maintenanceDone; + uint8_t disableFullDALogicInfo; +}__attribute__((packed)); + +typedef union { + struct permanent_flags_t perm_flags; + struct stclear_flags_t stclear_flags; + bool owned; + uint32_t num_pcrs; + struct tpm_version_t tpm_version; + struct tpm_version_1_2_t tpm_version_1_2; + uint32_t manufacturer_id; + struct timeout_t timeout; + struct duration_t duration; +} cap_t; + +struct tpm_getcap_params_in { + uint32_t cap; + uint32_t subcap_size; + uint32_t subcap; +}__attribute__((packed)); + +struct tpm_getcap_params_out { + uint32_t cap_size; + cap_t cap; +}__attribute__((packed)); + +struct tpm_readpubek_params_out { + uint8_t algorithm[4]; + uint8_t encscheme[2]; + uint8_t sigscheme[2]; + uint32_t paramsize; + uint8_t parameters[12]; /*assuming RSA*/ + uint32_t keysize; + uint8_t modulus[256]; + uint8_t checksum[20]; +}__attribute__((packed)); + +typedef union { + struct tpm_input_header in; + struct tpm_output_header out; +} tpm_cmd_header; + +#define TPM_DIGEST_SIZE 20 +struct tpm_pcrread_out { + uint8_t pcr_result[TPM_DIGEST_SIZE]; +}__attribute__((packed)); + +struct tpm_pcrread_in { + uint32_t pcr_idx; +}__attribute__((packed)); + +struct tpm_pcrextend_in { + uint32_t pcr_idx; + uint8_t hash[TPM_DIGEST_SIZE]; +}__attribute__((packed)); + +typedef union { + struct tpm_getcap_params_out getcap_out; + struct tpm_readpubek_params_out readpubek_out; + uint8_t readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; + struct tpm_getcap_params_in getcap_in; + struct tpm_pcrread_in pcrread_in; + struct tpm_pcrread_out pcrread_out; + struct tpm_pcrextend_in pcrextend_in; +} tpm_cmd_params; + +struct tpm_cmd_t { + tpm_cmd_header header; + tpm_cmd_params params; +}__attribute__((packed)); + + +enum tpm_duration { + TPM_SHORT = 0, + TPM_MEDIUM = 1, + TPM_LONG = 2, + TPM_UNDEFINED, +}; + +#define TPM_MAX_ORDINAL 243 +#define TPM_MAX_PROTECTED_ORDINAL 12 +#define TPM_PROTECTED_ORDINAL_MASK 0xFF + +extern const uint8_t tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL]; +extern const uint8_t tpm_ordinal_duration[TPM_MAX_ORDINAL]; + +#define TPM_DIGEST_SIZE 20 +#define TPM_ERROR_SIZE 10 +#define TPM_RET_CODE_IDX 6 + +/* tpm_capabilities */ +#define TPM_CAP_FLAG cpu_to_be32(4) +#define TPM_CAP_PROP cpu_to_be32(5) +#define CAP_VERSION_1_1 cpu_to_be32(0x06) +#define CAP_VERSION_1_2 cpu_to_be32(0x1A) + +/* tpm_sub_capabilities */ +#define TPM_CAP_PROP_PCR cpu_to_be32(0x101) +#define TPM_CAP_PROP_MANUFACTURER cpu_to_be32(0x103) +#define TPM_CAP_FLAG_PERM cpu_to_be32(0x108) +#define TPM_CAP_FLAG_VOL cpu_to_be32(0x109) +#define TPM_CAP_PROP_OWNER cpu_to_be32(0x111) +#define TPM_CAP_PROP_TIS_TIMEOUT cpu_to_be32(0x115) +#define TPM_CAP_PROP_TIS_DURATION cpu_to_be32(0x120) + + +#define TPM_INTERNAL_RESULT_SIZE 200 +#define TPM_TAG_RQU_COMMAND cpu_to_be16(193) +#define TPM_ORD_GET_CAP cpu_to_be32(101) + +extern const struct tpm_input_header tpm_getcap_header; + + + +const uint8_t tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL] = { + TPM_UNDEFINED, /* 0 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 5 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 10 */ + TPM_SHORT, +}; + +const uint8_t tpm_ordinal_duration[TPM_MAX_ORDINAL] = { + TPM_UNDEFINED, /* 0 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 5 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 10 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_LONG, + TPM_LONG, + TPM_MEDIUM, /* 15 */ + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, + TPM_LONG, + TPM_SHORT, /* 20 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, /* 25 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 30 */ + TPM_LONG, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 35 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 40 */ + TPM_LONG, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 45 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_LONG, + TPM_MEDIUM, /* 50 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 55 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 60 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 65 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 70 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 75 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 80 */ + TPM_UNDEFINED, + TPM_MEDIUM, + TPM_LONG, + TPM_SHORT, + TPM_UNDEFINED, /* 85 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 90 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 95 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 100 */ + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 105 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 110 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 115 */ + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 120 */ + TPM_LONG, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 125 */ + TPM_SHORT, + TPM_LONG, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 130 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_SHORT, + TPM_MEDIUM, + TPM_UNDEFINED, /* 135 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 140 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 145 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 150 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 155 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 160 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 165 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 170 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 175 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 180 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, /* 185 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 190 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 195 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 200 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 205 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 210 */ + TPM_UNDEFINED, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_UNDEFINED, /* 215 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 220 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 225 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 230 */ + TPM_LONG, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 235 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 240 */ + TPM_UNDEFINED, + TPM_MEDIUM, +}; + +const struct tpm_input_header tpm_getcap_header = { + .tag = TPM_TAG_RQU_COMMAND, + .length = cpu_to_be32(22), + .ordinal = TPM_ORD_GET_CAP +}; + + +enum tis_access { + TPM_ACCESS_VALID = 0x80, + TPM_ACCESS_ACTIVE_LOCALITY = 0x20, /* (R) */ + TPM_ACCESS_RELINQUISH_LOCALITY = 0x20,/* (W) */ + TPM_ACCESS_REQUEST_PENDING = 0x04, /* (W) */ + TPM_ACCESS_REQUEST_USE = 0x02, /* (W) */ +}; + +enum tis_status { + TPM_STS_VALID = 0x80, /* (R) */ + TPM_STS_COMMAND_READY = 0x40, /* (R) */ + TPM_STS_DATA_AVAIL = 0x10, /* (R) */ + TPM_STS_DATA_EXPECT = 0x08, /* (R) */ + TPM_STS_GO = 0x20, /* (W) */ +}; + +enum tis_int_flags { + TPM_GLOBAL_INT_ENABLE = 0x80000000, + TPM_INTF_BURST_COUNT_STATIC = 0x100, + TPM_INTF_CMD_READY_INT = 0x080, + TPM_INTF_INT_EDGE_FALLING = 0x040, + TPM_INTF_INT_EDGE_RISING = 0x020, + TPM_INTF_INT_LEVEL_LOW = 0x010, + TPM_INTF_INT_LEVEL_HIGH = 0x008, + TPM_INTF_LOCALITY_CHANGE_INT = 0x004, + TPM_INTF_STS_VALID_INT = 0x002, + TPM_INTF_DATA_AVAIL_INT = 0x001, +}; + +enum tis_defaults { + TIS_MEM_BASE = 0xFED40000, + TIS_MEM_LEN = 0x5000, + TIS_SHORT_TIMEOUT = 750, /*ms*/ + TIS_LONG_TIMEOUT = 2000, /*2 sec */ +}; + +#define TPM_TIMEOUT 5 + +#define TPM_ACCESS(t, l) (((uint8_t*)t->pages[l]) + 0x0000) +#define TPM_INT_ENABLE(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0008)) +#define TPM_INT_VECTOR(t, l) (((uint8_t*)t->pages[l]) + 0x000C) +#define TPM_INT_STATUS(t, l) (((uint8_t*)t->pages[l]) + 0x0010) +#define TPM_INTF_CAPS(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0014)) +#define TPM_STS(t, l) ((uint8_t*)(((uint8_t*)t->pages[l]) + 0x0018)) +#define TPM_DATA_FIFO(t, l) (((uint8_t*)t->pages[l]) + 0x0024) + +#define TPM_DID_VID(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0F00)) +#define TPM_RID(t, l) (((uint8_t*)t->pages[l]) + 0x0F04) + +struct tpm_chip { + int enabled_localities; + int locality; + unsigned long baseaddr; + uint8_t* pages[5]; + int did, vid, rid; + + uint8_t data_buffer[TPM_BUFSIZE]; + int data_len; + + s_time_t timeout_a, timeout_b, timeout_c, timeout_d; + s_time_t duration[3]; + +#ifdef HAVE_LIBC + int fd; +#endif + + unsigned int irq; + struct wait_queue_head read_queue; + struct wait_queue_head int_queue; +}; + + +static void __init_tpm_chip(struct tpm_chip* tpm) { + tpm->enabled_localities = TPM_TIS_EN_LOCLALL; + tpm->locality = -1; + tpm->baseaddr = 0; + tpm->pages[0] = tpm->pages[1] = tpm->pages[2] = tpm->pages[3] = tpm->pages[4] = NULL; + tpm->vid = 0; + tpm->did = 0; + tpm->irq = 0; + init_waitqueue_head(&tpm->read_queue); + init_waitqueue_head(&tpm->int_queue); + + tpm->data_len = -1; + +#ifdef HAVE_LIBC + tpm->fd = -1; +#endif +} + +/* + * Returns max number of nsecs to wait + */ +s_time_t tpm_calc_ordinal_duration(struct tpm_chip *chip, + uint32_t ordinal) +{ + int duration_idx = TPM_UNDEFINED; + s_time_t duration = 0; + + if (ordinal < TPM_MAX_ORDINAL) + duration_idx = tpm_ordinal_duration[ordinal]; + else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) < + TPM_MAX_PROTECTED_ORDINAL) + duration_idx = + tpm_protected_ordinal_duration[ordinal & + TPM_PROTECTED_ORDINAL_MASK]; + + if (duration_idx != TPM_UNDEFINED) { + duration = chip->duration[duration_idx]; + } + + if (duration <= 0) { + return SECONDS(120); + } + else + { + return duration; + } +} + + +static int locality_enabled(struct tpm_chip* tpm, int l) { + return tpm->enabled_localities & (1 << l); +} + +static int check_locality(struct tpm_chip* tpm, int l) { + if(locality_enabled(tpm, l) && (ioread8(TPM_ACCESS(tpm, l)) & + (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) == + (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) { + return l; + } + return -1; +} + +void release_locality(struct tpm_chip* tpm, int l, int force) +{ + if (locality_enabled(tpm, l) && (force || (ioread8(TPM_ACCESS(tpm, l)) & + (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) == + (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))) { + iowrite8(TPM_ACCESS(tpm, l), TPM_ACCESS_RELINQUISH_LOCALITY); + } +} + +int tpm_tis_request_locality(struct tpm_chip* tpm, int l) { + + s_time_t stop; + /*Make sure locality is valid */ + if(!locality_enabled(tpm, l)) { + printk("tpm_tis_change_locality() Tried to change to locality %d, but it is disabled or invalid!\n", l); + return -1; + } + /* Check if we already have the current locality */ + if(check_locality(tpm, l) >= 0) { + return tpm->locality = l; + } + /* Set the new locality*/ + iowrite8(TPM_ACCESS(tpm, l), TPM_ACCESS_REQUEST_USE); + + if(tpm->irq) { + /* Wait for interrupt */ + wait_event_deadline(tpm->int_queue, (check_locality(tpm, l) >= 0), NOW() + tpm->timeout_a); + + /* FIXME: Handle timeout event, should return error in that case */ + return l; + } else { + /* Wait for burstcount */ + stop = NOW() + tpm->timeout_a; + do { + if(check_locality(tpm, l) >= 0) { + return tpm->locality = l; + } + msleep(TPM_TIMEOUT); + } while(NOW() < stop); + } + + printk("REQ LOCALITY FAILURE\n"); + return -1; +} + +static uint8_t tpm_tis_status(struct tpm_chip* tpm) { + return ioread8(TPM_STS(tpm, tpm->locality)); +} + +/* This causes the current command to be aborted */ +static void tpm_tis_ready(struct tpm_chip* tpm) { + iowrite8(TPM_STS(tpm, tpm->locality), TPM_STS_COMMAND_READY); +} +#define tpm_tis_cancel_cmd(v) tpm_tis_ready(v) + +static int get_burstcount(struct tpm_chip* tpm) { + s_time_t stop; + int burstcnt; + + stop = NOW() + tpm->timeout_d; + do { + burstcnt = ioread8((TPM_STS(tpm, tpm->locality) + 1)); + burstcnt += ioread8(TPM_STS(tpm, tpm->locality) + 2) << 8; + + if (burstcnt) { + return burstcnt; + } + msleep(TPM_TIMEOUT); + } while(NOW() < stop); + return -EBUSY; +} + +static int wait_for_stat(struct tpm_chip* tpm, uint8_t mask, + unsigned long timeout, struct wait_queue_head* queue) { + s_time_t stop; + uint8_t status; + + status = tpm_tis_status(tpm); + if((status & mask) == mask) { + return 0; + } + + if(tpm->irq) { + wait_event_deadline(*queue, ((tpm_tis_status(tpm) & mask) == mask), timeout); + /* FIXME: Check for timeout and return -ETIME */ + return 0; + } else { + stop = NOW() + timeout; + do { + msleep(TPM_TIMEOUT); + status = tpm_tis_status(tpm); + if((status & mask) == mask) + return 0; + } while( NOW() < stop); + } + return -ETIME; +} + +static int recv_data(struct tpm_chip* tpm, uint8_t* buf, size_t count) { + int size = 0; + int burstcnt; + while( size < count && + wait_for_stat(tpm, + TPM_STS_DATA_AVAIL | TPM_STS_VALID, + tpm->timeout_c, + &tpm->read_queue) + == 0) { + burstcnt = get_burstcount(tpm); + for(; burstcnt > 0 && size < count; --burstcnt) + { + buf[size++] = ioread8(TPM_DATA_FIFO(tpm, tpm->locality)); + } + } + return size; +} + +int tpm_tis_recv(struct tpm_chip* tpm, uint8_t* buf, size_t count) { + int size = 0; + int expected, status; + + if (count < TPM_HEADER_SIZE) { + size = -EIO; + goto out; + } + + /* read first 10 bytes, including tag, paramsize, and result */ + if((size = + recv_data(tpm, buf, TPM_HEADER_SIZE)) < TPM_HEADER_SIZE) { + printk("Error reading tpm cmd header\n"); + goto out; + } + + expected = be32_to_cpu(*((uint32_t*)(buf + 2))); + if(expected > count) { + size = -EIO; + goto out; + } + + if((size += recv_data(tpm, & buf[TPM_HEADER_SIZE], + expected - TPM_HEADER_SIZE)) < expected) { + printk("Unable to read rest of tpm command size=%d expected=%d\n", size, expected); + size = -ETIME; + goto out; + } + + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->int_queue); + status = tpm_tis_status(tpm); + if(status & TPM_STS_DATA_AVAIL) { + printk("Error: left over data\n"); + size = -EIO; + goto out; + } + +out: + tpm_tis_ready(tpm); + release_locality(tpm, tpm->locality, 0); + return size; +} +int tpm_tis_send(struct tpm_chip* tpm, uint8_t* buf, size_t len) { + int rc; + int status, burstcnt = 0; + int count = 0; + uint32_t ordinal; + + if(tpm_tis_request_locality(tpm, tpm->locality) < 0) { + return -EBUSY; + } + + status = tpm_tis_status(tpm); + if((status & TPM_STS_COMMAND_READY) == 0) { + tpm_tis_ready(tpm); + if(wait_for_stat(tpm, TPM_STS_COMMAND_READY, tpm->timeout_b, &tpm->int_queue) < 0) { + rc = -ETIME; + goto out_err; + } + } + + while(count < len - 1) { + burstcnt = get_burstcount(tpm); + for(;burstcnt > 0 && count < len -1; --burstcnt) { + iowrite8(TPM_DATA_FIFO(tpm, tpm->locality), buf[count++]); + } + + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->int_queue); + status = tpm_tis_status(tpm); + if((status & TPM_STS_DATA_EXPECT) == 0) { + rc = -EIO; + goto out_err; + } + } + + /*Write last byte*/ + iowrite8(TPM_DATA_FIFO(tpm, tpm->locality), buf[count]); + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->read_queue); + status = tpm_tis_status(tpm); + if((status & TPM_STS_DATA_EXPECT) != 0) { + rc = -EIO; + goto out_err; + } + + /*go and do it*/ + iowrite8(TPM_STS(tpm, tpm->locality), TPM_STS_GO); + + if(tpm->irq) { + /*Wait for interrupt */ + ordinal = be32_to_cpu(*(buf + 6)); + if(wait_for_stat(tpm, + TPM_STS_DATA_AVAIL | TPM_STS_VALID, + tpm_calc_ordinal_duration(tpm, ordinal), + &tpm->read_queue) < 0) { + rc = -ETIME; + goto out_err; + } + } +#ifdef HAVE_LIBC + if(tpm->fd >= 0) { + files[tpm->fd].read = 0; + files[tpm->fd].tpm_tis.respgot = 0; + files[tpm->fd].tpm_tis.offset = 0; + } +#endif + return len; + +out_err: + tpm_tis_ready(tpm); + release_locality(tpm, tpm->locality, 0); + return rc; +} + +static void tpm_tis_irq_handler(evtchn_port_t port, struct pt_regs *regs, void* data) +{ + struct tpm_chip* tpm = data; + uint32_t interrupt; + int i; + + interrupt = ioread32(TPM_INT_STATUS(tpm, tpm->locality)); + if(interrupt == 0) { + return; + } + + if(interrupt & TPM_INTF_DATA_AVAIL_INT) { + wake_up(&tpm->read_queue); + } + if(interrupt & TPM_INTF_LOCALITY_CHANGE_INT) { + for(i = 0; i < 5; ++i) { + if(check_locality(tpm, i) >= 0) { + break; + } + } + } + if(interrupt & (TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT | + TPM_INTF_CMD_READY_INT)) { + wake_up(&tpm->int_queue); + } + + /* Clear interrupts handled with TPM_EOI */ + iowrite32(TPM_INT_STATUS(tpm, tpm->locality), interrupt); + ioread32(TPM_INT_STATUS(tpm, tpm->locality)); + return; +} + +/* + * Internal kernel interface to transmit TPM commands + */ +static ssize_t tpm_transmit(struct tpm_chip *chip, const uint8_t *buf, + size_t bufsiz) +{ + ssize_t rc; + uint32_t count, ordinal; + s_time_t stop; + + count = be32_to_cpu(*((uint32_t *) (buf + 2))); + ordinal = be32_to_cpu(*((uint32_t *) (buf + 6))); + if (count == 0) + return -ENODATA; + if (count > bufsiz) { + printk("Error: invalid count value %x %zx \n", count, bufsiz); + return -E2BIG; + } + + //down(&chip->tpm_mutex); + + if ((rc = tpm_tis_send(chip, (uint8_t *) buf, count)) < 0) { + printk("tpm_transmit: tpm_send: error %ld\n", rc); + goto out; + } + + if (chip->irq) + goto out_recv; + + stop = NOW() + tpm_calc_ordinal_duration(chip, ordinal); + do { + uint8_t status = tpm_tis_status(chip); + if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) == + (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) + goto out_recv; + + if ((status == TPM_STS_COMMAND_READY)) { + printk("TPM Error: Operation Canceled\n"); + rc = -ECANCELED; + goto out; + } + + msleep(TPM_TIMEOUT); /* CHECK */ + rmb(); + } while (NOW() < stop); + + /* Cancel the command */ + tpm_tis_cancel_cmd(chip); + printk("TPM Operation Timed out\n"); + rc = -ETIME; + goto out; + +out_recv: + if((rc = tpm_tis_recv(chip, (uint8_t *) buf, bufsiz)) < 0) { + printk("tpm_transmit: tpm_recv: error %d\n", rc); + } +out: + //up(&chip->tpm_mutex); + return rc; +} + +static ssize_t transmit_cmd(struct tpm_chip *chip, struct tpm_cmd_t *cmd, + int len, const char *desc) +{ + int err; + + len = tpm_transmit(chip,(uint8_t *) cmd, len); + if (len < 0) + return len; + if (len == TPM_ERROR_SIZE) { + err = be32_to_cpu(cmd->header.out.return_code); + printk("A TPM error (%d) occurred %s\n", err, desc); + return err; + } + return 0; +} + +int tpm_get_timeouts(struct tpm_chip *chip) +{ + struct tpm_cmd_t tpm_cmd; + struct timeout_t *timeout_cap; + struct duration_t *duration_cap; + ssize_t rc; + uint32_t timeout; + unsigned int scale = 1; + + tpm_cmd.header.in = tpm_getcap_header; + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT; + + if((rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, + "attempting to determine the timeouts")) != 0) { + printk("transmit failed %d\n", rc); + goto duration; + } + + if(be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || + be32_to_cpu(tpm_cmd.header.out.length) != + sizeof(tpm_cmd.header.out) + sizeof(uint32_t) + 4 * sizeof(uint32_t)) { + return -EINVAL; + } + + timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout; + /* Don't overwrite default if value is 0 */ + timeout = be32_to_cpu(timeout_cap->a); + if(timeout && timeout < 1000) { + /* timeouts in msc rather usec */ + scale = 1000; + } + if (timeout) + chip->timeout_a = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->b); + if (timeout) + chip->timeout_b = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->c); + if (timeout) + chip->timeout_c = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->d); + if (timeout) + chip->timeout_d = MICROSECS(timeout * scale); /*Convert to msec */ + +duration: + tpm_cmd.header.in = tpm_getcap_header; + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION; + + if((rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, + "attempting to determine the durations")) < 0) { + return rc; + } + + if(be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || + be32_to_cpu(tpm_cmd.header.out.length) != + sizeof(tpm_cmd.header.out) + sizeof(uint32_t) + 3 * sizeof(uint32_t)) { + return -EINVAL; + } + + duration_cap = &tpm_cmd.params.getcap_out.cap.duration; + chip->duration[TPM_SHORT] = MICROSECS(be32_to_cpu(duration_cap->tpm_short)); + chip->duration[TPM_MEDIUM] = MICROSECS(be32_to_cpu(duration_cap->tpm_medium)); + chip->duration[TPM_LONG] = MICROSECS(be32_to_cpu(duration_cap->tpm_long)); + + /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above + * value wrong and apparently reports msecs rather than usecs. So we + * fix up the resulting too-small TPM_SHORT value to make things work. + */ + if (chip->duration[TPM_SHORT] < MILLISECS(10)) { + chip->duration[TPM_SHORT] = SECONDS(1); + chip->duration[TPM_MEDIUM] *= 1000; + chip->duration[TPM_LONG] *= 1000; + printk("Adjusting TPM timeout parameters\n"); + } + + return 0; +} + + + +void tpm_continue_selftest(struct tpm_chip* chip) { + uint8_t data[] = { + 0, 193, /* TPM_TAG_RQU_COMMAND */ + 0, 0, 0, 10, /* length */ + 0, 0, 0, 83, /* TPM_ORD_GetCapability */ + }; + + tpm_transmit(chip, data, sizeof(data)); +} + +ssize_t tpm_getcap(struct tpm_chip *chip, uint32_t subcap_id, cap_t *cap, + const char *desc) +{ + struct tpm_cmd_t tpm_cmd; + int rc; + + tpm_cmd.header.in = tpm_getcap_header; + if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) { + tpm_cmd.params.getcap_in.cap = subcap_id; + /*subcap field not necessary */ + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0); + tpm_cmd.header.in.length -= cpu_to_be32(sizeof(uint32_t)); + } else { + if (subcap_id == TPM_CAP_FLAG_PERM || + subcap_id == TPM_CAP_FLAG_VOL) + tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG; + else + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = subcap_id; + } + rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc); + if (!rc) + *cap = tpm_cmd.params.getcap_out.cap; + return rc; +} + + +struct tpm_chip* init_tpm_tis(unsigned long baseaddr, int localities, unsigned int irq) +{ + int i; + unsigned long addr; + struct tpm_chip* tpm = NULL; + uint32_t didvid; + uint32_t intfcaps; + uint32_t intmask; + + printk("============= Init TPM TIS Driver ==============\n"); + + /*Sanity check the localities input */ + if(localities & ~TPM_TIS_EN_LOCLALL) { + printk("init_tpm_tis() Invalid locality specification! %X\n", localities); + goto abort_egress; + } + + printk("IOMEM Machine Base Address: %lX\n", baseaddr); + + /* Create the tpm data structure */ + tpm = malloc(sizeof(struct tpm_chip)); + __init_tpm_chip(tpm); + + /* Set the enabled localities - if 0 we leave default as all enabled */ + if(localities != 0) { + tpm->enabled_localities = localities; + } + printk("Enabled Localities: "); + for(i = 0; i < 5; ++i) { + if(locality_enabled(tpm, i)) { + printk("%d ", i); + } + } + printk("\n"); + + /* Set the base machine address */ + tpm->baseaddr = baseaddr; + + /* Set default timeouts */ + tpm->timeout_a = MILLISECS(TIS_SHORT_TIMEOUT); + tpm->timeout_b = MILLISECS(TIS_LONG_TIMEOUT); + tpm->timeout_c = MILLISECS(TIS_SHORT_TIMEOUT); + tpm->timeout_d = MILLISECS(TIS_SHORT_TIMEOUT); + + /*Map the mmio pages */ + addr = tpm->baseaddr; + for(i = 0; i < 5; ++i) { + if(locality_enabled(tpm, i)) { + /* Map the page in now */ + if((tpm->pages[i] = ioremap_nocache(addr, PAGE_SIZE)) == NULL) { + printk("Unable to map iomem page a address %p\n", addr); + goto abort_egress; + } + + /* Set default locality to the first enabled one */ + if (tpm->locality < 0) { + if(tpm_tis_request_locality(tpm, i) < 0) { + printk("Unable to request locality %d??\n", i); + goto abort_egress; + } + } + } + addr += PAGE_SIZE; + } + + + /* Get the vendor and device ids */ + didvid = ioread32(TPM_DID_VID(tpm, tpm->locality)); + tpm->did = didvid >> 16; + tpm->vid = didvid & 0xFFFF; + + + /* Get the revision id */ + tpm->rid = ioread8(TPM_RID(tpm, tpm->locality)); + + printk("1.2 TPM (device-id=0x%X vendor-id = %X rev-id = %X)\n", tpm->did, tpm->vid, tpm->rid); + + intfcaps = ioread32(TPM_INTF_CAPS(tpm, tpm->locality)); + printk("TPM interface capabilities (0x%x):\n", intfcaps); + if (intfcaps & TPM_INTF_BURST_COUNT_STATIC) + printk("\tBurst Count Static\n"); + if (intfcaps & TPM_INTF_CMD_READY_INT) + printk("\tCommand Ready Int Support\n"); + if (intfcaps & TPM_INTF_INT_EDGE_FALLING) + printk("\tInterrupt Edge Falling\n"); + if (intfcaps & TPM_INTF_INT_EDGE_RISING) + printk("\tInterrupt Edge Rising\n"); + if (intfcaps & TPM_INTF_INT_LEVEL_LOW) + printk("\tInterrupt Level Low\n"); + if (intfcaps & TPM_INTF_INT_LEVEL_HIGH) + printk("\tInterrupt Level High\n"); + if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT) + printk("\tLocality Change Int Support\n"); + if (intfcaps & TPM_INTF_STS_VALID_INT) + printk("\tSts Valid Int Support\n"); + if (intfcaps & TPM_INTF_DATA_AVAIL_INT) + printk("\tData Avail Int Support\n"); + + /*Interupt setup */ + intmask = ioread32(TPM_INT_ENABLE(tpm, tpm->locality)); + + intmask |= TPM_INTF_CMD_READY_INT + | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT + | TPM_INTF_STS_VALID_INT; + + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), intmask); + + /*If interupts are enabled, handle it */ + if(irq) { + if(irq != TPM_PROBE_IRQ) { + tpm->irq = irq; + } else { + /*FIXME add irq probing feature later */ + printk("IRQ probing not implemented\n"); + } + } + + if(tpm->irq) { + iowrite8(TPM_INT_VECTOR(tpm, tpm->locality), tpm->irq); + + if(bind_pirq(tpm->irq, 1, tpm_tis_irq_handler, tpm) != 0) { + printk("Unabled to request irq: %u for use\n", tpm->irq); + printk("Will use polling mode\n"); + tpm->irq = 0; + } else { + /* Clear all existing */ + iowrite32(TPM_INT_STATUS(tpm, tpm->locality), ioread32(TPM_INT_STATUS(tpm, tpm->locality))); + + /* Turn on interrupts */ + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), intmask | TPM_GLOBAL_INT_ENABLE); + } + } + + if(tpm_get_timeouts(tpm)) { + printk("Could not get TPM timeouts and durations\n"); + goto abort_egress; + } + tpm_continue_selftest(tpm); + + + return tpm; +abort_egress: + if(tpm != NULL) { + shutdown_tpm_tis(tpm); + } + return NULL; +} + +void shutdown_tpm_tis(struct tpm_chip* tpm){ + int i; + + printk("Shutting down tpm_tis device\n"); + + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), ~TPM_GLOBAL_INT_ENABLE); + + /*Unmap all of the mmio pages */ + for(i = 0; i < 5; ++i) { + if(tpm->pages[i] != NULL) { + iounmap(tpm->pages[i], PAGE_SIZE); + tpm->pages[i] = NULL; + } + } + free(tpm); + return; +} + + +int tpm_tis_cmd(struct tpm_chip* tpm, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen) +{ + if(tpm->locality < 0) { + printk("tpm_tis_cmd() failed! locality not set!\n"); + return -1; + } + if(reqlen > TPM_BUFSIZE) { + reqlen = TPM_BUFSIZE; + } + memcpy(tpm->data_buffer, req, reqlen); + *resplen = tpm_transmit(tpm, tpm->data_buffer, TPM_BUFSIZE); + + *resp = malloc(*resplen); + memcpy(*resp, tpm->data_buffer, *resplen); + return 0; +} + +#ifdef HAVE_LIBC +int tpm_tis_open(struct tpm_chip* tpm) +{ + /* Silently prevent multiple opens */ + if(tpm->fd != -1) { + return tpm->fd; + } + + tpm->fd = alloc_fd(FTYPE_TPM_TIS); + printk("tpm_tis_open() -> %d\n", tpm->fd); + files[tpm->fd].tpm_tis.dev = tpm; + files[tpm->fd].tpm_tis.offset = 0; + files[tpm->fd].tpm_tis.respgot = 0; + return tpm->fd; +} + +int tpm_tis_posix_write(int fd, const uint8_t* buf, size_t count) +{ + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + if(tpm->locality < 0) { + printk("tpm_tis_posix_write() failed! locality not set!\n"); + errno = EINPROGRESS; + return -1; + } + if(count == 0) { + return 0; + } + + /* Return an error if we are already processing a command */ + if(count > TPM_BUFSIZE) { + count = TPM_BUFSIZE; + } + /* Send the command now */ + memcpy(tpm->data_buffer, buf, count); + if((tpm->data_len = tpm_transmit(tpm, tpm->data_buffer, TPM_BUFSIZE)) < 0) { + errno = EIO; + return -1; + } + return count; +} + +int tpm_tis_posix_read(int fd, uint8_t* buf, size_t count) +{ + int rc; + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + if(count == 0) { + return 0; + } + + /* If there is no tpm resp to read, return EIO */ + if(tpm->data_len < 0) { + errno = EIO; + return -1; + } + + + /* Handle EOF case */ + if(files[fd].tpm_tis.offset >= tpm->data_len) { + rc = 0; + } else { + rc = min(tpm->data_len - files[fd].tpm_tis.offset, count); + memcpy(buf, tpm->data_buffer + files[fd].tpm_tis.offset, rc); + } + files[fd].tpm_tis.offset += rc; + /* Reset the data pending flag */ + return rc; +} +int tpm_tis_posix_fstat(int fd, struct stat* buf) +{ + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + buf->st_mode = O_RDWR; + buf->st_uid = 0; + buf->st_gid = 0; + buf->st_size = be32_to_cpu(*((uint32_t*)(tpm->data_buffer + 2))); + buf->st_atime = buf->st_mtime = buf->st_ctime = time(NULL); + return 0; +} + + +#endif diff --git a/extras/mini-os/tpmback.c b/extras/mini-os/tpmback.c new file mode 100644 index 0000000..658fed1 --- /dev/null +++ b/extras/mini-os/tpmback.c @@ -0,0 +1,1102 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/xen/tpmback/tpmback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netback/netback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This code has also been derived from drivers/xen/tpmback/xenbus.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2005 IBM Corporation + * Copyright (C) 2005 Rusty Russell + * + * This code has also been derived from drivers/xen/tpmback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself also derived from drvivers/xen/netback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2004, Keir Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#ifndef HAVE_LIBC +#define strtoul simple_strtoul +#endif + +//#define TPMBACK_PRINT_DEBUG +#ifdef TPMBACK_PRINT_DEBUG +#define TPMBACK_DEBUG(fmt,...) printk("Tpmback:Debug("__FILE__":%d) " fmt, __LINE__, ##__VA_ARGS__) +#define TPMBACK_DEBUG_MORE(fmt,...) printk(fmt, ##__VA_ARGS__) +#else +#define TPMBACK_DEBUG(fmt,...) +#endif +#define TPMBACK_ERR(fmt,...) printk("Tpmback:Error " fmt, ##__VA_ARGS__) +#define TPMBACK_LOG(fmt,...) printk("Tpmback:Info " fmt, ##__VA_ARGS__) + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +/* Default size of the tpmif array at initialization */ +#define DEF_ARRAY_SIZE 1 + +/* tpmif and tpmdev flags */ +#define TPMIF_CLOSED 1 +#define TPMIF_REQ_READY 2 + +struct tpmif { + domid_t domid; + unsigned int handle; + + char* fe_path; + char* fe_state_path; + + /* Locally bound event channel*/ + evtchn_port_t evtchn; + + /* Shared page */ + tpmif_tx_interface_t* tx; + + /* pointer to TPMIF_RX_RING_SIZE pages */ + void** pages; + + enum xenbus_state state; + enum { DISCONNECTED, DISCONNECTING, CONNECTED } status; + + unsigned char uuid[16]; + + /* state flags */ + int flags; +}; +typedef struct tpmif tpmif_t; + +struct tpmback_dev { + + tpmif_t** tpmlist; + unsigned long num_tpms; + unsigned long num_alloc; + + struct gntmap map; + + /* True if at least one tpmif has a request to be handled */ + int flags; + + xenbus_event_queue events; + + /* Callbacks */ + void (*open_callback)(domid_t, unsigned int); + void (*close_callback)(domid_t, unsigned int); + void (*suspend_callback)(domid_t, unsigned int); + void (*resume_callback)(domid_t, unsigned int); +}; +typedef struct tpmback_dev tpmback_dev_t; + +enum { EV_NONE, EV_NEWFE, EV_STCHNG } tpm_ev_enum; + +/* Global objects */ +static struct thread* eventthread = NULL; +static tpmback_dev_t gtpmdev = { + .tpmlist = NULL, + .num_tpms = 0, + .num_alloc = 0, + .flags = TPMIF_CLOSED, + .events = NULL, + .open_callback = NULL, + .close_callback = NULL, + .suspend_callback = NULL, + .resume_callback = NULL, +}; +struct wait_queue_head waitq; +int globalinit = 0; + +/************************************ + * TPMIF SORTED ARRAY FUNCTIONS + * tpmback_dev_t.tpmlist is a sorted array, sorted by domid and then handle number + * Duplicates are not allowed + * **********************************/ + +inline void tpmif_req_ready(tpmif_t* tpmif) { + tpmif->flags |= TPMIF_REQ_READY; + gtpmdev.flags |= TPMIF_REQ_READY; +} + +inline void tpmdev_check_req(void) { + int i; + int flags; + local_irq_save(flags); + for(i = 0; i < gtpmdev.num_tpms; ++i) { + if(gtpmdev.tpmlist[i]->flags & TPMIF_REQ_READY) { + gtpmdev.flags |= TPMIF_REQ_READY; + local_irq_restore(flags); + return; + } + } + gtpmdev.flags &= ~TPMIF_REQ_READY; + local_irq_restore(flags); +} + +inline void tpmif_req_finished(tpmif_t* tpmif) { + tpmif->flags &= ~TPMIF_REQ_READY; + tpmdev_check_req(); +} + +int __get_tpmif_index(int st, int n, domid_t domid, unsigned int handle) +{ + int i = st + n /2; + tpmif_t* tmp; + + if( n <= 0 ) + return -1; + + tmp = gtpmdev.tpmlist[i]; + if(domid == tmp->domid && tmp->handle == handle) { + return i; + } else if ( (domid < tmp->domid) || + (domid == tmp->domid && handle < tmp->handle)) { + return __get_tpmif_index(st, n/2, domid, handle); + } else { + return __get_tpmif_index(i + 1, n/2 - ((n +1) % 2), domid, handle); + } +} + +/* Returns the array index of the tpmif domid/handle. Returns -1 if no such tpmif exists */ +int get_tpmif_index(domid_t domid, unsigned int handle) +{ + int flags; + int index; + local_irq_save(flags); + index = __get_tpmif_index(0, gtpmdev.num_tpms, domid, handle); + local_irq_restore(flags); + return index; +} + +/* Returns the tpmif domid/handle or NULL if none exists */ +tpmif_t* get_tpmif(domid_t domid, unsigned int handle) +{ + int flags; + int i; + tpmif_t* ret; + local_irq_save(flags); + i = get_tpmif_index(domid, handle); + if (i < 0) { + ret = NULL; + } else { + ret = gtpmdev.tpmlist[i]; + } + local_irq_restore(flags); + return ret; +} + +/* Remove the given tpmif. Returns 0 if it was removed, -1 if it was not removed */ +int remove_tpmif(tpmif_t* tpmif) +{ + int i, j; + char* err; + int flags; + local_irq_save(flags); + + /* Find the index in the array if it exists */ + i = get_tpmif_index(tpmif->domid, tpmif->handle); + if (i < 0) { + goto error; + } + + /* Remove the interface from the list */ + for(j = i; j < gtpmdev.num_tpms - 1; ++j) { + gtpmdev.tpmlist[j] = gtpmdev.tpmlist[j+1]; + } + gtpmdev.tpmlist[j] = NULL; + --gtpmdev.num_tpms; + + /* If removed tpm was the only ready tpm, then we need to check and turn off the ready flag */ + tpmdev_check_req(); + + local_irq_restore(flags); + + /* Stop listening for events on this tpm interface */ + if((err = xenbus_unwatch_path_token(XBT_NIL, tpmif->fe_state_path, tpmif->fe_state_path))) { + TPMBACK_ERR("Unable to unwatch path token `%s' Error was %s Ignoring..\n", tpmif->fe_state_path, err); + free(err); + } + + return 0; +error: + local_irq_restore(flags); + return -1; +} + +/* Insert tpmif into dev->tpmlist. Returns 0 on success and non zero on error. + * It is an error to insert a tpmif with the same domid and handle + * number + * as something already in the list */ +int insert_tpmif(tpmif_t* tpmif) +{ + int flags; + unsigned int i, j; + tpmif_t* tmp; + char* err; + + local_irq_save(flags); + + /*Check if we need to allocate more space */ + if (gtpmdev.num_tpms == gtpmdev.num_alloc) { + gtpmdev.num_alloc *= 2; + gtpmdev.tpmlist = realloc(gtpmdev.tpmlist, gtpmdev.num_alloc); + } + + /*Find where to put the new interface */ + for(i = 0; i < gtpmdev.num_tpms; ++i) + { + tmp = gtpmdev.tpmlist[i]; + if(tpmif->domid == tmp->domid && tpmif->handle == tmp->handle) { + TPMBACK_ERR("Tried to insert duplicate tpm interface %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + if((tpmif->domid < tmp->domid) || + (tpmif->domid == tmp->domid && tpmif->handle < tmp->handle)) { + break; + } + } + + /*Shift all the tpm pointers past i down one */ + for(j = gtpmdev.num_tpms; j > i; --j) { + gtpmdev.tpmlist[j] = gtpmdev.tpmlist[j-1]; + } + + /*Add the new interface */ + gtpmdev.tpmlist[i] = tpmif; + ++gtpmdev.num_tpms; + + /*Should not be needed, anything inserted with ready flag is probably an error */ + tpmdev_check_req(); + + local_irq_restore(flags); + + /*Listen for state changes on the new interface */ + if((err = xenbus_watch_path_token(XBT_NIL, tpmif->fe_state_path, tpmif->fe_state_path, >pmdev.events))) + { + /* if we got an error here we should carefully remove the interface and then return */ + TPMBACK_ERR("Unable to watch path token `%s' Error was %s\n", tpmif->fe_state_path, err); + free(err); + remove_tpmif(tpmif); + goto error_post_irq; + } + + return 0; +error: + local_irq_restore(flags); +error_post_irq: + return -1; +} + + +/***************** + * CHANGE BACKEND STATE + * *****************/ +/*Attempts to change the backend state in xenstore + * returns 0 on success and non-zero on error */ +int tpmif_change_state(tpmif_t* tpmif, enum xenbus_state state) +{ + char path[512]; + char *value; + char *err; + enum xenbus_state readst; + TPMBACK_DEBUG("Backend state change %u/%u from=%d to=%d\n", (unsigned int) tpmif->domid, tpmif->handle, tpmif->state, state); + if (tpmif->state == state) + return 0; + + snprintf(path, 512, "backend/vtpm/%u/%u/state", (unsigned int) tpmif->domid, tpmif->handle); + + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Unable to read backend state %s, error was %s\n", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &readst) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + /* It's possible that the backend state got updated by hotplug or something else behind our back */ + if(readst != tpmif->state) { + TPMBACK_DEBUG("tpm interface state was %d but xenstore state was %d!\n", tpmif->state, readst); + tpmif->state = readst; + } + + /*If if the state isnt changing, then we dont update xenstore b/c we dont want to fire extraneous events */ + if(tpmif->state == state) { + return 0; + } + + /*update xenstore*/ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_printf(XBT_NIL, path, "state", "%u", state))) { + TPMBACK_ERR("Error writing to xenstore %s, error was %s new state=%d\n", path, err, state); + free(err); + return -1; + } + + tpmif->state = state; + + return 0; +} +/********************************** + * TPMIF CREATION AND DELETION + * *******************************/ +inline tpmif_t* __init_tpmif(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + tpmif = malloc(sizeof(*tpmif)); + tpmif->domid = domid; + tpmif->handle = handle; + tpmif->fe_path = NULL; + tpmif->fe_state_path = NULL; + tpmif->state = XenbusStateInitialising; + tpmif->status = DISCONNECTED; + tpmif->tx = NULL; + tpmif->pages = NULL; + tpmif->flags = 0; + memset(tpmif->uuid, 0, sizeof(tpmif->uuid)); + return tpmif; +} + +void __free_tpmif(tpmif_t* tpmif) +{ + if(tpmif->pages) { + free(tpmif->pages); + } + if(tpmif->fe_path) { + free(tpmif->fe_path); + } + if(tpmif->fe_state_path) { + free(tpmif->fe_state_path); + } + free(tpmif); +} +/* Creates a new tpm interface, adds it to the sorted array and returns it. + * returns NULL on error + * If the tpm interface already exists, it is returned*/ +tpmif_t* new_tpmif(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + char* err; + char path[512]; + + /* Make sure we haven't already created this tpm + * Double events can occur */ + if((tpmif = get_tpmif(domid, handle)) != NULL) { + return tpmif; + } + + tpmif = __init_tpmif(domid, handle); + + /* Get the uuid from xenstore */ + snprintf(path, 512, "backend/vtpm/%u/%u/uuid", (unsigned int) domid, handle); + if((!xenbus_read_uuid(path, tpmif->uuid))) { + TPMBACK_ERR("Error reading %s\n", path); + goto error; + } + + /* allocate pages to be used for shared mapping */ + if((tpmif->pages = malloc(sizeof(void*) * TPMIF_TX_RING_SIZE)) == NULL) { + goto error; + } + memset(tpmif->pages, 0, sizeof(void*) * TPMIF_TX_RING_SIZE); + + if(tpmif_change_state(tpmif, XenbusStateInitWait)) { + goto error; + } + + snprintf(path, 512, "backend/vtpm/%u/%u/frontend", (unsigned int) domid, handle); + if((err = xenbus_read(XBT_NIL, path, &tpmif->fe_path))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s), Error = %s", path, err); + free(err); + goto error; + } + + /*Set the state path */ + tpmif->fe_state_path = malloc(strlen(tpmif->fe_path) + 7); + strcpy(tpmif->fe_state_path, tpmif->fe_path); + strcat(tpmif->fe_state_path, "/state"); + + if(insert_tpmif(tpmif)) { + goto error; + } + TPMBACK_DEBUG("New tpmif %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + /* Do the callback now */ + if(gtpmdev.open_callback) { + gtpmdev.open_callback(tpmif->domid, tpmif->handle); + } + return tpmif; +error: + __free_tpmif(tpmif); + return NULL; + +} + +/* Removes tpmif from dev->tpmlist and frees it's memory usage */ +void free_tpmif(tpmif_t* tpmif) +{ + char* err; + char path[512]; + TPMBACK_DEBUG("Free tpmif %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + if(tpmif->flags & TPMIF_CLOSED) { + TPMBACK_ERR("Tried to free an instance twice! Theres a bug somewhere!\n"); + BUG(); + } + tpmif->flags = TPMIF_CLOSED; + + tpmif_change_state(tpmif, XenbusStateClosing); + + /* Unmap share page and unbind event channel */ + if(tpmif->status == CONNECTED) { + tpmif->status = DISCONNECTING; + mask_evtchn(tpmif->evtchn); + + if(gntmap_munmap(>pmdev.map, (unsigned long)tpmif->tx, 1)) { + TPMBACK_ERR("%u/%u Error occured while trying to unmap shared page\n", (unsigned int) tpmif->domid, tpmif->handle); + } + + unbind_evtchn(tpmif->evtchn); + } + tpmif->status = DISCONNECTED; + tpmif_change_state(tpmif, XenbusStateClosed); + + /* Do the callback now */ + if(gtpmdev.close_callback) { + gtpmdev.close_callback(tpmif->domid, tpmif->handle); + } + + /* remove from array */ + remove_tpmif(tpmif); + + /* Wake up anyone possibly waiting on this interface and let them exit */ + wake_up(&waitq); + schedule(); + + /* Remove the old xenbus entries */ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_rm(XBT_NIL, path))) { + TPMBACK_ERR("Error cleaning up xenbus entries path=%s error=%s\n", path, err); + free(err); + } + + TPMBACK_LOG("Frontend %u/%u disconnected\n", (unsigned int) tpmif->domid, tpmif->handle); + + /* free memory */ + __free_tpmif(tpmif); + +} + +/********************** + * REMAINING TPMBACK FUNCTIONS + * ********************/ + +/*Event channel handler */ +void tpmback_handler(evtchn_port_t port, struct pt_regs *regs, void *data) +{ + tpmif_t* tpmif = (tpmif_t*) data; + tpmif_tx_request_t* tx = &tpmif->tx->ring[0].req; + /* Throw away 0 size events, these can trigger from event channel unmasking */ + if(tx->size == 0) + return; + + TPMBACK_DEBUG("EVENT CHANNEL FIRE %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + tpmif_req_ready(tpmif); + wake_up(&waitq); + +} + +/* Connect to frontend */ +int connect_fe(tpmif_t* tpmif) +{ + char path[512]; + char* err, *value; + uint32_t domid; + grant_ref_t ringref; + evtchn_port_t evtchn; + + /* If already connected then quit */ + if (tpmif->status == CONNECTED) { + TPMBACK_DEBUG("%u/%u tried to connect while it was already connected?\n", (unsigned int) tpmif->domid, tpmif->handle); + return 0; + } + + /* Fetch the grant reference */ + snprintf(path, 512, "%s/ring-ref", tpmif->fe_path); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s) Error = %s", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &ringref) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + + /* Fetch the event channel*/ + snprintf(path, 512, "%s/event-channel", tpmif->fe_path); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s) Error = %s", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &evtchn) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + domid = tpmif->domid; + if((tpmif->tx = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &ringref, PROT_READ | PROT_WRITE)) == NULL) { + TPMBACK_ERR("Failed to map grant reference %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + return -1; + } + memset(tpmif->tx, 0, PAGE_SIZE); + + /*Bind the event channel */ + if((evtchn_bind_interdomain(tpmif->domid, evtchn, tpmback_handler, tpmif, &tpmif->evtchn))) + { + TPMBACK_ERR("%u/%u Unable to bind to interdomain event channel!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error_post_map; + } + unmask_evtchn(tpmif->evtchn); + + /* Write the ready flag and change status to connected */ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_printf(XBT_NIL, path, "ready", "%u", 1))) { + TPMBACK_ERR("%u/%u Unable to write ready flag on connect_fe()\n", (unsigned int) tpmif->domid, tpmif->handle); + free(err); + goto error_post_evtchn; + } + tpmif->status = CONNECTED; + if((tpmif_change_state(tpmif, XenbusStateConnected))){ + goto error_post_evtchn; + } + + TPMBACK_LOG("Frontend %u/%u connected\n", (unsigned int) tpmif->domid, tpmif->handle); + + return 0; +error_post_evtchn: + mask_evtchn(tpmif->evtchn); + unbind_evtchn(tpmif->evtchn); +error_post_map: + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->tx, 1); + return -1; +} + +static int frontend_changed(tpmif_t* tpmif) +{ + int state = xenbus_read_integer(tpmif->fe_state_path); + if(state < 0) { + state = XenbusStateUnknown; + } + + TPMBACK_DEBUG("Frontend %u/%u state changed to %d\n", (unsigned int) tpmif->domid, tpmif->handle, state); + + switch (state) { + case XenbusStateInitialising: + case XenbusStateInitialised: + break; + + case XenbusStateConnected: + if(connect_fe(tpmif)) { + TPMBACK_ERR("Failed to connect to front end %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + tpmif_change_state(tpmif, XenbusStateClosed); + return -1; + } + break; + + case XenbusStateClosing: + tpmif_change_state(tpmif, XenbusStateClosing); + break; + + case XenbusStateUnknown: /* keep it here */ + case XenbusStateClosed: + free_tpmif(tpmif); + break; + + default: + TPMBACK_DEBUG("BAD STATE CHANGE %u/%u state = %d for tpmif\n", (unsigned int) tpmif->domid, tpmif->handle, state); + return -1; + } + return 0; +} + + +/* parses the string that comes out of xenbus_watch_wait_return. */ +static int parse_eventstr(const char* evstr, domid_t* domid, unsigned int* handle) +{ + int ret; + char cmd[40]; + char* err; + char* value; + unsigned int udomid = 0; + tpmif_t* tpmif; + /* First check for new frontends, this occurs when /backend/vtpm// gets created. Note we what the sscanf to fail on the last %s */ + if (sscanf(evstr, "backend/vtpm/%u/%u/%40s", &udomid, handle, cmd) == 2) { + *domid = udomid; + /* Make sure the entry exists, if this event triggers because the entry dissapeared then ignore it */ + if((err = xenbus_read(XBT_NIL, evstr, &value))) { + free(err); + return EV_NONE; + } + free(value); + /* Make sure the tpmif entry does not already exist, this should not happen */ + if((tpmif = get_tpmif(*domid, *handle)) != NULL) { + TPMBACK_DEBUG("Duplicate tpm entries! %u %u\n", tpmif->domid, tpmif->handle); + return EV_NONE; + } + return EV_NEWFE; + } else if((ret = sscanf(evstr, "/local/domain/%u/device/vtpm/%u/%40s", &udomid, handle, cmd)) == 3) { + *domid = udomid; + if (!strcmp(cmd, "state")) + return EV_STCHNG; + } + return EV_NONE; +} + +void handle_backend_event(char* evstr) { + tpmif_t* tpmif; + domid_t domid; + unsigned int handle; + int event; + + TPMBACK_DEBUG("Xenbus Event: %s\n", evstr); + + event = parse_eventstr(evstr, &domid, &handle); + + switch(event) { + case EV_NEWFE: + if(new_tpmif(domid, handle) == NULL) { + TPMBACK_ERR("Failed to create new tpm instance %u/%u\n", (unsigned int) domid, handle); + } + wake_up(&waitq); + break; + case EV_STCHNG: + if((tpmif = get_tpmif(domid, handle))) { + frontend_changed(tpmif); + } else { + TPMBACK_DEBUG("Event Received for non-existant tpm! instance=%u/%u xenbus_event=%s\n", (unsigned int) domid, handle, evstr); + } + break; + } +} + +/* Runs through the given path and creates events recursively + * for all of its children. + * @path - xenstore path to scan */ +static void generate_backend_events(const char* path) +{ + char* err; + int i, len; + char **dirs; + char *entry; + + if((err = xenbus_ls(XBT_NIL, path, &dirs)) != NULL) { + free(err); + return; + } + + for(i = 0; dirs[i] != NULL; ++i) { + len = strlen(path) + strlen(dirs[i]) + 2; + entry = malloc(len); + snprintf(entry, len, "%s/%s", path, dirs[i]); + + /* Generate and handle event for the entry itself */ + handle_backend_event(entry); + + /* Do children */ + generate_backend_events(entry); + + /* Cleanup */ + free(entry); + free(dirs[i]); + } + free(dirs); + return; +} + +unsigned char* tpmback_get_uuid(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + if((tpmif = get_tpmif(domid, handle)) == NULL) { + TPMBACK_DEBUG("get_uuid() failed, %u/%u is an invalid frontend\n", (unsigned int) domid, handle); + return NULL; + } + + return tpmif->uuid; +} + +void tpmback_set_open_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.open_callback = cb; +} +void tpmback_set_close_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.close_callback = cb; +} +void tpmback_set_suspend_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.suspend_callback = cb; +} +void tpmback_set_resume_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.resume_callback = cb; +} + +static void event_listener(void) +{ + const char* bepath = "backend/vtpm"; + char **path; + char* err; + + /* Setup the backend device watch */ + if((err = xenbus_watch_path_token(XBT_NIL, bepath, bepath, >pmdev.events)) != NULL) { + TPMBACK_ERR("xenbus_watch_path_token(%s) failed with error %s!\n", bepath, err); + free(err); + goto egress; + } + + /* Check for any frontends that connected before we set the watch. + * This is almost guaranteed to happen if both domains are started + * immediatly one after the other. + * We do this by manually generating events on everything in the backend + * path */ + generate_backend_events(bepath); + + /* Wait and listen for changes in frontend connections */ + while(1) { + path = xenbus_wait_for_watch_return(>pmdev.events); + + /*If quit flag was set then exit */ + if(gtpmdev.flags & TPMIF_CLOSED) { + TPMBACK_DEBUG("listener thread got quit event. Exiting..\n"); + free(path); + break; + } + handle_backend_event(*path); + free(path); + + } + + if((err = xenbus_unwatch_path_token(XBT_NIL, bepath, bepath)) != NULL) { + free(err); + } +egress: + return; +} + +void event_thread(void* p) { + event_listener(); +} + +void init_tpmback(void) +{ + if(!globalinit) { + init_waitqueue_head(&waitq); + globalinit = 1; + } + printk("============= Init TPM BACK ================\n"); + gtpmdev.tpmlist = malloc(sizeof(tpmif_t*) * DEF_ARRAY_SIZE); + gtpmdev.num_alloc = DEF_ARRAY_SIZE; + gtpmdev.num_tpms = 0; + gtpmdev.flags = 0; + + gtpmdev.open_callback = gtpmdev.close_callback = NULL; + gtpmdev.suspend_callback = gtpmdev.resume_callback = NULL; + + eventthread = create_thread("tpmback-listener", event_thread, NULL); + +} + +void shutdown_tpmback(void) +{ + /* Disable callbacks */ + gtpmdev.open_callback = gtpmdev.close_callback = NULL; + gtpmdev.suspend_callback = gtpmdev.resume_callback = NULL; + + TPMBACK_LOG("Shutting down tpm backend\n"); + /* Set the quit flag */ + gtpmdev.flags = TPMIF_CLOSED; + + //printk("num tpms is %d\n", gtpmdev.num_tpms); + /*Free all backend instances */ + while(gtpmdev.num_tpms) { + free_tpmif(gtpmdev.tpmlist[0]); + } + free(gtpmdev.tpmlist); + gtpmdev.tpmlist = NULL; + gtpmdev.num_alloc = 0; + + /* Wake up anyone possibly waiting on the device and let them exit */ + wake_up(&waitq); + schedule(); +} + +inline void init_tpmcmd(tpmcmd_t* tpmcmd, domid_t domid, unsigned int handle, unsigned char uuid[16]) +{ + tpmcmd->domid = domid; + tpmcmd->handle = handle; + memcpy(tpmcmd->uuid, uuid, sizeof(tpmcmd->uuid)); + tpmcmd->req = NULL; + tpmcmd->req_len = 0; + tpmcmd->resp = NULL; + tpmcmd->resp_len = 0; +} + +tpmcmd_t* get_request(tpmif_t* tpmif) { + tpmcmd_t* cmd; + tpmif_tx_request_t* tx; + int offset; + int tocopy; + int i; + uint32_t domid; + int flags; + + local_irq_save(flags); + + /* Allocate the cmd object to hold the data */ + if((cmd = malloc(sizeof(*cmd))) == NULL) { + goto error; + } + init_tpmcmd(cmd, tpmif->domid, tpmif->handle, tpmif->uuid); + + tx = &tpmif->tx->ring[0].req; + cmd->req_len = tx->size; + /* Allocate the buffer */ + if(cmd->req_len) { + if((cmd->req = malloc(cmd->req_len)) == NULL) { + goto error; + } + } + /* Copy the bits from the shared pages */ + offset = 0; + for(i = 0; i < TPMIF_TX_RING_SIZE && offset < cmd->req_len; ++i) { + tx = &tpmif->tx->ring[i].req; + + /* Map the page with the data */ + domid = (uint32_t)tpmif->domid; + if((tpmif->pages[i] = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &tx->ref, PROT_READ)) == NULL) { + TPMBACK_ERR("%u/%u Unable to map shared page during read!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + + /* do the copy now */ + tocopy = min(cmd->req_len - offset, PAGE_SIZE); + memcpy(&cmd->req[offset], tpmif->pages[i], tocopy); + offset += tocopy; + + /* release the page */ + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->pages[i], 1); + + } + +#ifdef TPMBACK_PRINT_DEBUG + TPMBACK_DEBUG("Received Tpm Command from %u/%u of size %u", (unsigned int) tpmif->domid, tpmif->handle, cmd->req_len); + for(i = 0; i < cmd->req_len; ++i) { + if (!(i % 30)) { + TPMBACK_DEBUG_MORE("\n"); + } + TPMBACK_DEBUG_MORE("%02hhX ", cmd->req[i]); + } + TPMBACK_DEBUG_MORE("\n\n"); +#endif + + local_irq_restore(flags); + return cmd; +error: + if(cmd != NULL) { + if (cmd->req != NULL) { + free(cmd->req); + cmd->req = NULL; + } + free(cmd); + cmd = NULL; + } + local_irq_restore(flags); + return NULL; + +} + +void send_response(tpmcmd_t* cmd, tpmif_t* tpmif) +{ + tpmif_tx_request_t* tx; + int offset; + int i; + uint32_t domid; + int tocopy; + int flags; + + local_irq_save(flags); + + tx = &tpmif->tx->ring[0].req; + tx->size = cmd->resp_len; + + offset = 0; + for(i = 0; i < TPMIF_TX_RING_SIZE && offset < cmd->resp_len; ++i) { + tx = &tpmif->tx->ring[i].req; + + /* Map the page with the data */ + domid = (uint32_t)tpmif->domid; + if((tpmif->pages[i] = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &tx->ref, PROT_WRITE)) == NULL) { + TPMBACK_ERR("%u/%u Unable to map shared page during write!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + + /* do the copy now */ + tocopy = min(cmd->resp_len - offset, PAGE_SIZE); + memcpy(tpmif->pages[i], &cmd->resp[offset], tocopy); + offset += tocopy; + + /* release the page */ + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->pages[i], 1); + + } + +#ifdef TPMBACK_PRINT_DEBUG + TPMBACK_DEBUG("Sent response to %u/%u of size %u", (unsigned int) tpmif->domid, tpmif->handle, cmd->resp_len); + for(i = 0; i < cmd->resp_len; ++i) { + if (!(i % 30)) { + TPMBACK_DEBUG_MORE("\n"); + } + TPMBACK_DEBUG_MORE("%02hhX ", cmd->resp[i]); + } + TPMBACK_DEBUG_MORE("\n\n"); +#endif + /* clear the ready flag and send the event channel notice to the frontend */ + tpmif_req_finished(tpmif); + notify_remote_via_evtchn(tpmif->evtchn); +error: + local_irq_restore(flags); + return; +} + +tpmcmd_t* tpmback_req_any(void) +{ + int i; + /* Block until something has a request */ + wait_event(waitq, (gtpmdev.flags & (TPMIF_REQ_READY | TPMIF_CLOSED))); + + /* Check if were shutting down */ + if(gtpmdev.flags & TPMIF_CLOSED) { + /* if something was waiting for us to give up the queue so it can shutdown, let it finish */ + schedule(); + return NULL; + } + + for(i = 0; i < gtpmdev.num_tpms; ++i) { + if(gtpmdev.tpmlist[i]->flags & TPMIF_REQ_READY) { + return get_request(gtpmdev.tpmlist[i]); + } + } + + TPMBACK_ERR("backend request ready flag was set but no interfaces were actually ready\n"); + return NULL; +} + +tpmcmd_t* tpmback_req(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + tpmif = get_tpmif(domid, handle); + if(tpmif == NULL) { + return NULL; + } + + wait_event(waitq, (tpmif->flags & (TPMIF_REQ_READY | TPMIF_CLOSED) || gtpmdev.flags & TPMIF_CLOSED)); + + /* Check if were shutting down */ + if(tpmif->flags & TPMIF_CLOSED || gtpmdev.flags & TPMIF_CLOSED) { + /* if something was waiting for us to give up the queue so it can free this instance, let it finish */ + schedule(); + return NULL; + } + + return get_request(tpmif); +} + +void tpmback_resp(tpmcmd_t* tpmcmd) +{ + tpmif_t* tpmif; + + /* Get the associated interface, if it doesnt exist then just quit */ + tpmif = get_tpmif(tpmcmd->domid, tpmcmd->handle); + if(tpmif == NULL) { + TPMBACK_ERR("Tried to send a reponse to non existant frontend %u/%u\n", (unsigned int) tpmcmd->domid, tpmcmd->handle); + goto end; + } + + if(!(tpmif->flags & TPMIF_REQ_READY)) { + TPMBACK_ERR("Tried to send response to a frontend that was not waiting for one %u/%u\n", (unsigned int) tpmcmd->domid, tpmcmd->handle); + goto end; + } + + /* Send response to frontend */ + send_response(tpmcmd, tpmif); + +end: + if(tpmcmd->req != NULL) { + free(tpmcmd->req); + } + free(tpmcmd); + return; +} + +int tpmback_wait_for_frontend_connect(domid_t *domid, unsigned int *handle) +{ + tpmif_t* tpmif; + int flags; + wait_event(waitq, ((gtpmdev.num_tpms > 0) || gtpmdev.flags & TPMIF_CLOSED)); + if(gtpmdev.flags & TPMIF_CLOSED) { + return -1; + } + local_irq_save(flags); + tpmif = gtpmdev.tpmlist[0]; + *domid = tpmif->domid; + *handle = tpmif->handle; + local_irq_restore(flags); + + return 0; +} + +int tpmback_num_frontends(void) +{ + return gtpmdev.num_tpms; +} diff --git a/extras/mini-os/tpmfront.c b/extras/mini-os/tpmfront.c new file mode 100644 index 0000000..0218d7f --- /dev/null +++ b/extras/mini-os/tpmfront.c @@ -0,0 +1,608 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm_vtpm.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2006 IBM Corporation + * + * This code has also been derived from drivers/char/tpm_xen.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netfront/netfront.c + * from the linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, version 2 of the + * License. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define TPMFRONT_PRINT_DEBUG +#ifdef TPMFRONT_PRINT_DEBUG +#define TPMFRONT_DEBUG(fmt,...) printk("Tpmfront:Debug("__FILE__":%d) " fmt, __LINE__, ##__VA_ARGS__) +#define TPMFRONT_DEBUG_MORE(fmt,...) printk(fmt, ##__VA_ARGS__) +#else +#define TPMFRONT_DEBUG(fmt,...) +#endif +#define TPMFRONT_ERR(fmt,...) printk("Tpmfront:Error " fmt, ##__VA_ARGS__) +#define TPMFRONT_LOG(fmt,...) printk("Tpmfront:Info " fmt, ##__VA_ARGS__) + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +void tpmfront_handler(evtchn_port_t port, struct pt_regs *regs, void *data) { + struct tpmfront_dev* dev = (struct tpmfront_dev*) data; + /*If we get a response when we didnt make a request, just ignore it */ + if(!dev->waiting) { + return; + } + + dev->waiting = 0; +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].read = 1; + } +#endif + wake_up(&dev->waitq); +} + +static int publish_xenbus(struct tpmfront_dev* dev) { + xenbus_transaction_t xbt; + int retry; + char* err; + /* Write the grant reference and event channel to xenstore */ +again: + if((err = xenbus_transaction_start(&xbt))) { + TPMFRONT_ERR("Unable to start xenbus transaction, error was %s\n", err); + free(err); + return -1; + } + + if((err = xenbus_printf(xbt, dev->nodename, "ring-ref", "%u", (unsigned int) dev->ring_ref))) { + TPMFRONT_ERR("Unable to write %s/ring-ref, error was %s\n", dev->nodename, err); + free(err); + goto abort_transaction; + } + + if((err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u", (unsigned int) dev->evtchn))) { + TPMFRONT_ERR("Unable to write %s/event-channel, error was %s\n", dev->nodename, err); + free(err); + goto abort_transaction; + } + + if((err = xenbus_transaction_end(xbt, 0, &retry))) { + TPMFRONT_ERR("Unable to complete xenbus transaction, error was %s\n", err); + free(err); + return -1; + } + if(retry) { + goto again; + } + + return 0; +abort_transaction: + if((err = xenbus_transaction_end(xbt, 1, &retry))) { + free(err); + } + return -1; +} + +static int wait_for_backend_connect(xenbus_event_queue* events, char* path) +{ + int state; + + TPMFRONT_LOG("Waiting for backend connection..\n"); + /* Wait for the backend to connect */ + while(1) { + state = xenbus_read_integer(path); + if ( state < 0) + state = XenbusStateUnknown; + switch(state) { + /* Bad states, we quit with error */ + case XenbusStateUnknown: + case XenbusStateClosing: + case XenbusStateClosed: + TPMFRONT_ERR("Unable to connect to backend\n"); + return -1; + /* If backend is connected then break out of loop */ + case XenbusStateConnected: + TPMFRONT_LOG("Backend Connected\n"); + return 0; + default: + xenbus_wait_for_watch(events); + } + } + +} + +static int wait_for_backend_closed(xenbus_event_queue* events, char* path) +{ + int state; + + TPMFRONT_LOG("Waiting for backend to close..\n"); + while(1) { + state = xenbus_read_integer(path); + if ( state < 0) + state = XenbusStateUnknown; + switch(state) { + case XenbusStateUnknown: + TPMFRONT_ERR("Backend Unknown state, forcing shutdown\n"); + return -1; + case XenbusStateClosed: + TPMFRONT_LOG("Backend Closed\n"); + return 0; + default: + xenbus_wait_for_watch(events); + } + } + +} + +static int wait_for_backend_state_changed(struct tpmfront_dev* dev, XenbusState state) { + char* err; + int ret = 0; + xenbus_event_queue events = NULL; + char path[512]; + + snprintf(path, 512, "%s/state", dev->bepath); + /*Setup the watch to wait for the backend */ + if((err = xenbus_watch_path_token(XBT_NIL, path, path, &events))) { + TPMFRONT_ERR("Could not set a watch on %s, error was %s\n", path, err); + free(err); + return -1; + } + + /* Do the actual wait loop now */ + switch(state) { + case XenbusStateConnected: + ret = wait_for_backend_connect(&events, path); + break; + case XenbusStateClosed: + ret = wait_for_backend_closed(&events, path); + break; + default: + break; + } + + if((err = xenbus_unwatch_path_token(XBT_NIL, path, path))) { + TPMFRONT_ERR("Unable to unwatch %s, error was %s, ignoring..\n", path, err); + free(err); + } + return ret; +} + +static int tpmfront_connect(struct tpmfront_dev* dev) +{ + char* err; + /* Create shared page */ + dev->tx = (tpmif_tx_interface_t*) alloc_page(); + if(dev->tx == NULL) { + TPMFRONT_ERR("Unable to allocate page for shared memory\n"); + goto error; + } + memset(dev->tx, 0, PAGE_SIZE); + dev->ring_ref = gnttab_grant_access(dev->bedomid, virt_to_mfn(dev->tx), 0); + TPMFRONT_DEBUG("grant ref is %lu\n", (unsigned long) dev->ring_ref); + + /*Create event channel */ + if(evtchn_alloc_unbound(dev->bedomid, tpmfront_handler, dev, &dev->evtchn)) { + TPMFRONT_ERR("Unable to allocate event channel\n"); + goto error_postmap; + } + unmask_evtchn(dev->evtchn); + TPMFRONT_DEBUG("event channel is %lu\n", (unsigned long) dev->evtchn); + + /* Write the entries to xenstore */ + if(publish_xenbus(dev)) { + goto error_postevtchn; + } + + /* Change state to connected */ + dev->state = XenbusStateConnected; + + /* Tell the backend that we are ready */ + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", dev->state))) { + TPMFRONT_ERR("Unable to write to xenstore %s/state, value=%u", dev->nodename, XenbusStateConnected); + free(err); + goto error; + } + + return 0; +error_postevtchn: + mask_evtchn(dev->evtchn); + unbind_evtchn(dev->evtchn); +error_postmap: + gnttab_end_access(dev->ring_ref); + free_page(dev->tx); +error: + return -1; +} + +struct tpmfront_dev* init_tpmfront(const char* _nodename) +{ + struct tpmfront_dev* dev; + const char* nodename; + char path[512]; + char* value, *err; + unsigned long long ival; + int i; + + printk("============= Init TPM Front ================\n"); + + dev = malloc(sizeof(struct tpmfront_dev)); + memset(dev, 0, sizeof(struct tpmfront_dev)); + +#ifdef HAVE_LIBC + dev->fd = -1; +#endif + + nodename = _nodename ? _nodename : "device/vtpm/0"; + dev->nodename = strdup(nodename); + + init_waitqueue_head(&dev->waitq); + + /* Get backend domid */ + snprintf(path, 512, "%s/backend-id", dev->nodename); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMFRONT_ERR("Unable to read %s during tpmfront initialization! error = %s\n", path, err); + free(err); + goto error; + } + if(sscanf(value, "%llu", &ival) != 1) { + TPMFRONT_ERR("%s has non-integer value (%s)\n", path, value); + free(value); + goto error; + } + free(value); + dev->bedomid = ival; + + /* Get backend xenstore path */ + snprintf(path, 512, "%s/backend", dev->nodename); + if((err = xenbus_read(XBT_NIL, path, &dev->bepath))) { + TPMFRONT_ERR("Unable to read %s during tpmfront initialization! error = %s\n", path, err); + free(err); + goto error; + } + + /* Create and publish grant reference and event channel */ + if (tpmfront_connect(dev)) { + goto error; + } + + /* Wait for backend to connect */ + if( wait_for_backend_state_changed(dev, XenbusStateConnected)) { + goto error; + } + + /* Allocate pages that will contain the messages */ + dev->pages = malloc(sizeof(void*) * TPMIF_TX_RING_SIZE); + if(dev->pages == NULL) { + goto error; + } + memset(dev->pages, 0, sizeof(void*) * TPMIF_TX_RING_SIZE); + for(i = 0; i < TPMIF_TX_RING_SIZE; ++i) { + dev->pages[i] = (void*)alloc_page(); + if(dev->pages[i] == NULL) { + goto error; + } + } + + TPMFRONT_LOG("Initialization Completed successfully\n"); + + return dev; + +error: + shutdown_tpmfront(dev); + return NULL; +} +void shutdown_tpmfront(struct tpmfront_dev* dev) +{ + char* err; + char path[512]; + int i; + tpmif_tx_request_t* tx; + if(dev == NULL) { + return; + } + TPMFRONT_LOG("Shutting down tpmfront\n"); + /* disconnect */ + if(dev->state == XenbusStateConnected) { + dev->state = XenbusStateClosing; + //FIXME: Transaction for this? + /* Tell backend we are closing */ + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", (unsigned int) dev->state))) { + free(err); + } + + /* Clean up xenstore entries */ + snprintf(path, 512, "%s/event-channel", dev->nodename); + if((err = xenbus_rm(XBT_NIL, path))) { + free(err); + } + snprintf(path, 512, "%s/ring-ref", dev->nodename); + if((err = xenbus_rm(XBT_NIL, path))) { + free(err); + } + + /* Tell backend we are closed */ + dev->state = XenbusStateClosed; + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", (unsigned int) dev->state))) { + TPMFRONT_ERR("Unable to write to %s, error was %s", dev->nodename, err); + free(err); + } + + /* Wait for the backend to close and unmap shared pages, ignore any errors */ + wait_for_backend_state_changed(dev, XenbusStateClosed); + + /* Cleanup any shared pages */ + if(dev->pages) { + for(i = 0; i < TPMIF_TX_RING_SIZE; ++i) { + if(dev->pages[i]) { + tx = &dev->tx->ring[i].req; + if(tx->ref != 0) { + gnttab_end_access(tx->ref); + } + free_page(dev->pages[i]); + } + } + free(dev->pages); + } + + /* Close event channel and unmap shared page */ + mask_evtchn(dev->evtchn); + unbind_evtchn(dev->evtchn); + gnttab_end_access(dev->ring_ref); + + free_page(dev->tx); + + } + + /* Cleanup memory usage */ + if(dev->respbuf) { + free(dev->respbuf); + } + if(dev->bepath) { + free(dev->bepath); + } + if(dev->nodename) { + free(dev->nodename); + } + free(dev); +} + +int tpmfront_send(struct tpmfront_dev* dev, const uint8_t* msg, size_t length) +{ + int i; + tpmif_tx_request_t* tx = NULL; + /* Error Checking */ + if(dev == NULL || dev->state != XenbusStateConnected) { + TPMFRONT_ERR("Tried to send message through disconnected frontend\n"); + return -1; + } + +#ifdef TPMFRONT_PRINT_DEBUG + TPMFRONT_DEBUG("Sending Msg to backend size=%u", (unsigned int) length); + for(i = 0; i < length; ++i) { + if(!(i % 30)) { + TPMFRONT_DEBUG_MORE("\n"); + } + TPMFRONT_DEBUG_MORE("%02X ", msg[i]); + } + TPMFRONT_DEBUG_MORE("\n"); +#endif + + /* Copy to shared pages now */ + for(i = 0; length > 0 && i < TPMIF_TX_RING_SIZE; ++i) { + /* Share the page */ + tx = &dev->tx->ring[i].req; + tx->unused = 0; + tx->addr = virt_to_mach(dev->pages[i]); + tx->ref = gnttab_grant_access(dev->bedomid, virt_to_mfn(dev->pages[i]), 0); + /* Copy the bits to the page */ + tx->size = length > PAGE_SIZE ? PAGE_SIZE : length; + memcpy(dev->pages[i], &msg[i * PAGE_SIZE], tx->size); + + /* Update counters */ + length -= tx->size; + } + dev->waiting = 1; + dev->resplen = 0; +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].read = 0; + files[dev->fd].tpmfront.respgot = 0; + files[dev->fd].tpmfront.offset = 0; + } +#endif + notify_remote_via_evtchn(dev->evtchn); + return 0; +} +int tpmfront_recv(struct tpmfront_dev* dev, uint8_t** msg, size_t *length) +{ + tpmif_tx_request_t* tx; + int i; + if(dev == NULL || dev->state != XenbusStateConnected) { + TPMFRONT_ERR("Tried to receive message from disconnected frontend\n"); + return -1; + } + /*Wait for the response */ + wait_event(dev->waitq, (!dev->waiting)); + + /* Initialize */ + *msg = NULL; + *length = 0; + + /* special case, just quit */ + tx = &dev->tx->ring[0].req; + if(tx->size == 0 ) { + goto quit; + } + /* Get the total size */ + tx = &dev->tx->ring[0].req; + for(i = 0; i < TPMIF_TX_RING_SIZE && tx->size > 0; ++i) { + tx = &dev->tx->ring[i].req; + *length += tx->size; + } + /* Alloc the buffer */ + if(dev->respbuf) { + free(dev->respbuf); + } + *msg = dev->respbuf = malloc(*length); + dev->resplen = *length; + /* Copy the bits */ + tx = &dev->tx->ring[0].req; + for(i = 0; i < TPMIF_TX_RING_SIZE && tx->size > 0; ++i) { + tx = &dev->tx->ring[i].req; + memcpy(&(*msg)[i * PAGE_SIZE], dev->pages[i], tx->size); + gnttab_end_access(tx->ref); + tx->ref = 0; + } +#ifdef TPMFRONT_PRINT_DEBUG + TPMFRONT_DEBUG("Received response from backend size=%u", (unsigned int) *length); + for(i = 0; i < *length; ++i) { + if(!(i % 30)) { + TPMFRONT_DEBUG_MORE("\n"); + } + TPMFRONT_DEBUG_MORE("%02X ", (*msg)[i]); + } + TPMFRONT_DEBUG_MORE("\n"); +#endif +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].tpmfront.respgot = 1; + } +#endif +quit: + return 0; +} + +int tpmfront_cmd(struct tpmfront_dev* dev, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen) +{ + int rc; + if((rc = tpmfront_send(dev, req, reqlen))) { + return rc; + } + if((rc = tpmfront_recv(dev, resp, resplen))) { + return rc; + } + + return 0; +} + +#ifdef HAVE_LIBC +#include +int tpmfront_open(struct tpmfront_dev* dev) +{ + /* Silently prevent multiple opens */ + if(dev->fd != -1) { + return dev->fd; + } + + dev->fd = alloc_fd(FTYPE_TPMFRONT); + printk("tpmfront_open(%s) -> %d\n", dev->nodename, dev->fd); + files[dev->fd].tpmfront.dev = dev; + files[dev->fd].tpmfront.offset = 0; + files[dev->fd].tpmfront.respgot = 0; + return dev->fd; +} + +int tpmfront_posix_write(int fd, const uint8_t* buf, size_t count) +{ + int rc; + struct tpmfront_dev* dev; + dev = files[fd].tpmfront.dev; + + if(count == 0) { + return 0; + } + + /* Return an error if we are already processing a command */ + if(dev->waiting) { + errno = EINPROGRESS; + return -1; + } + /* Send the command now */ + if((rc = tpmfront_send(dev, buf, count)) != 0) { + errno = EIO; + return -1; + } + return count; +} + +int tpmfront_posix_read(int fd, uint8_t* buf, size_t count) +{ + int rc; + uint8_t* dummybuf; + size_t dummysz; + struct tpmfront_dev* dev; + + dev = files[fd].tpmfront.dev; + + if(count == 0) { + return 0; + } + + /* get the response if we haven't already */ + if(files[dev->fd].tpmfront.respgot == 0) { + if ((rc = tpmfront_recv(dev, &dummybuf, &dummysz)) != 0) { + errno = EIO; + return -1; + } + } + + /* handle EOF case */ + if(files[dev->fd].tpmfront.offset >= dev->resplen) { + return 0; + } + + /* Compute the number of bytes and do the copy operation */ + if((rc = min(count, dev->resplen - files[dev->fd].tpmfront.offset)) != 0) { + memcpy(buf, dev->respbuf + files[dev->fd].tpmfront.offset, rc); + files[dev->fd].tpmfront.offset += rc; + } + + return rc; +} + +int tpmfront_posix_fstat(int fd, struct stat* buf) +{ + uint8_t* dummybuf; + size_t dummysz; + int rc; + struct tpmfront_dev* dev = files[fd].tpmfront.dev; + + /* If we have a response waiting, then read it now from the backend + * so we can get its length*/ + if(dev->waiting || (files[dev->fd].read == 1 && !files[dev->fd].tpmfront.respgot)) { + if ((rc = tpmfront_recv(dev, &dummybuf, &dummysz)) != 0) { + errno = EIO; + return -1; + } + } + + buf->st_mode = O_RDWR; + buf->st_uid = 0; + buf->st_gid = 0; + buf->st_size = dev->resplen; + buf->st_atime = buf->st_mtime = buf->st_ctime = time(NULL); + + return 0; +} + + +#endif -- 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 Thu Nov 01 20:36:26 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 01 Nov 2012 20:36:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TU1Uv-0005V2-Sk; Thu, 01 Nov 2012 20:36:17 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TU1Ut-0005U8-IG for xen-devel@lists.xen.org; Thu, 01 Nov 2012 20:36:16 +0000 Received: from [85.158.138.51:33023] by server-1.bemta-3.messagelabs.com id 36/15-12169-E3DD2905; Thu, 01 Nov 2012 20:36:14 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-14.tower-174.messagelabs.com!1351802165!21991508!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UNPARSEABLE_RELAY,UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 28940 invoked from network); 1 Nov 2012 20:36:06 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-14.tower-174.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 1 Nov 2012 20:36:06 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.148031189; Thu, 01 Nov 2012 16:35:56 -0400 From: Matthew Fioravante To: Ian.Campbell@citrix.com, xen-devel@lists.xen.org, stefano.stabellini@eu.citrix.com Date: Thu, 1 Nov 2012 16:35:49 -0400 Message-Id: <1351802150-19258-3-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM 8/9] add stubdom/vtpmmgr code 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 Add the code base for vtpmmgrdom. Makefile changes next patch. Signed-off-by: Matthew Fioravante diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile new file mode 100644 index 0000000..88c83c3 --- /dev/null +++ b/stubdom/vtpmmgr/Makefile @@ -0,0 +1,32 @@ +# 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. +# + +XEN_ROOT=../.. + +PSSL_DIR=../polarssl-$(XEN_TARGET_ARCH)/library +PSSL_OBJS=aes.o sha1.o entropy.o ctr_drbg.o bignum.o sha4.o havege.o timing.o entropy_poll.o + +TARGET=vtpmmgr.a +OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o + +CFLAGS+=-Werror -Iutil -Icrypto -Itcs +CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label + +build: $(TARGET) +$(TARGET): $(OBJS) + ar -rcs $@ $^ $(foreach obj,$(PSSL_OBJS),$(PSSL_DIR)/$(obj)) + +clean: + rm -f $(TARGET) $(OBJS) + +distclean: clean + +.PHONY: clean distclean diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c new file mode 100644 index 0000000..a158020 --- /dev/null +++ b/stubdom/vtpmmgr/init.c @@ -0,0 +1,553 @@ +/* + * 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. +*/ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_storage.h" +#include "tpm.h" +#include "marshal.h" + +struct Opts { + enum { + TPMDRV_TPM_TIS, + TPMDRV_TPMFRONT, + } tpmdriver; + unsigned long tpmiomem; + unsigned int tpmirq; + unsigned int tpmlocality; + int gen_owner_auth; +}; + +// --------------------------- Well Known Auths -------------------------- +const TPM_AUTHDATA WELLKNOWN_SRK_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 } +}; + +static int tpm_entropy_source(void* dummy, unsigned char* data, size_t len, size_t* olen) { + UINT32 sz = len; + TPM_RESULT rc = TPM_GetRandom(&sz, data); + *olen = sz; + return rc == TPM_SUCCESS ? 0 : POLARSSL_ERR_ENTROPY_SOURCE_FAILED; +} + +static TPM_RESULT check_tpm_version(void) { + TPM_RESULT status; + UINT32 rsize; + BYTE* res = NULL; + TPM_CAP_VERSION_INFO vinfo; + + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_VERSION_VAL, + 0, + NULL, + &rsize, + &res)); + if(rsize < 4) { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid size returned by GetCapability!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + unpack_TPM_CAP_VERSION_INFO(res, &vinfo, UNPACK_ALIAS); + + vtpmloginfo(VTPM_LOG_VTPM, "Hardware TPM:\n"); + vtpmloginfo(VTPM_LOG_VTPM, " version: %hhd %hhd %hhd %hhd\n", + vinfo.version.major, vinfo.version.minor, vinfo.version.revMajor, vinfo.version.revMinor); + vtpmloginfo(VTPM_LOG_VTPM, " specLevel: %hd\n", vinfo.specLevel); + vtpmloginfo(VTPM_LOG_VTPM, " errataRev: %hhd\n", vinfo.errataRev); + vtpmloginfo(VTPM_LOG_VTPM, " vendorID: %c%c%c%c\n", + vinfo.tpmVendorID[0], vinfo.tpmVendorID[1], + vinfo.tpmVendorID[2], vinfo.tpmVendorID[3]); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecificSize: %hd\n", vinfo.vendorSpecificSize); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecific: "); + for(int i = 0; i < vinfo.vendorSpecificSize; ++i) { + vtpmloginfomore(VTPM_LOG_VTPM, "%02hhx", vinfo.vendorSpecific[i]); + } + vtpmloginfomore(VTPM_LOG_VTPM, "\n"); + +abort_egress: + free(res); + return status; +} + +static TPM_RESULT flush_tpm(void) { + TPM_RESULT status = TPM_SUCCESS; + const TPM_RESOURCE_TYPE reslist[] = { TPM_RT_KEY, TPM_RT_AUTH, TPM_RT_TRANS, TPM_RT_COUNTER, TPM_RT_DAA_TPM, TPM_RT_CONTEXT }; + BYTE* keylist = NULL; + UINT32 keylistSize; + BYTE* ptr; + + //Iterate through each resource type and flush all handles + for(int i = 0; i < sizeof(reslist) / sizeof(TPM_RESOURCE_TYPE); ++i) { + TPM_RESOURCE_TYPE beres = cpu_to_be32(reslist[i]); + UINT16 size; + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_HANDLE, + sizeof(TPM_RESOURCE_TYPE), + (BYTE*)(&beres), + &keylistSize, + &keylist)); + + ptr = keylist; + ptr = unpack_UINT16(ptr, &size); + + //Flush each handle + if(size) { + vtpmloginfo(VTPM_LOG_VTPM, "Flushing %u handle(s) of type %lu\n", size, (unsigned long) reslist[i]); + for(int j = 0; j < size; ++j) { + TPM_HANDLE h; + ptr = unpack_TPM_HANDLE(ptr, &h); + TPMTRYRETURN(TPM_FlushSpecific(h, reslist[i])); + } + } + + free(keylist); + keylist = NULL; + } + + goto egress; +abort_egress: + free(keylist); +egress: + return status; +} + + +static TPM_RESULT try_take_ownership(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_PUBKEY pubEK = TPM_PUBKEY_INIT; + + // If we can read PubEK then there is no owner and we should take it. + status = TPM_ReadPubek(&pubEK); + + switch(status) { + case TPM_DISABLED_CMD: + //Cannot read ek? TPM has owner + vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); + status = TPM_SUCCESS; + break; + case TPM_NO_ENDORSEMENT: + { + //If theres no ek, we have to create one + TPM_KEY_PARMS keyInfo = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }; + TPMTRYRETURN(TPM_CreateEndorsementKeyPair(&keyInfo, &pubEK)); + } + //fall through to take ownership + case TPM_SUCCESS: + { + //Construct the Srk + TPM_KEY srk = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_STORAGE, + .keyFlags = 0x00, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey = { + .keyLength = 0, + .key = NULL, + }, + .encDataSize = 0, + }; + + TPMTRYRETURN(TPM_TakeOwnership( + &pubEK, + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &srk, + NULL, + &vtpm_globals.oiap)); + + TPMTRYRETURN(TPM_DisablePubekRead( + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + &vtpm_globals.oiap)); + } + break; + default: + break; + } +abort_egress: + free_TPM_PUBKEY(&pubEK); + 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) { + 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; + } + /* owner auth is a raw hash */ + else if(!strncmp(authstr, "hash:", 5)) { + authstr += 5; + if((rc = strlen(authstr)) != 40) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth hex string `%s' must be exactly 40 characters (20 bytes) long, length=%d\n", authstr, rc); + return -1; + } + for(int j = 0; j < 20; ++j) { + if(sscanf(authstr, "%hhX", target + j) != 1) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth string `%s' is not a valid hex string\n", authstr); + return -1; + } + authstr += 2; + } + } + /* owner auth is a string that will be hashed */ + else if(!strncmp(authstr, "text:", 5)) { + authstr += 5; + sha1((const unsigned char*)authstr, strlen(authstr), target); + } + else { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid auth string %s\n", authstr); + return -1; + } + + return 0; +} + +int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) +{ + int rc; + 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)); + + 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) { + goto err_invalid; + } + if(rc == 1) { + opts->gen_owner_auth = 1; + } + } + 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) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmdriver=", 10)) { + if(!strcmp(argv[i] + 10, "tpm_tis")) { + opts->tpmdriver = TPMDRV_TPM_TIS; + } else if(!strcmp(argv[i] + 10, "tpmfront")) { + opts->tpmdriver = TPMDRV_TPMFRONT; + } else { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmiomem=",9)) { + if(sscanf(argv[i] + 9, "0x%lX", &opts->tpmiomem) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmirq=",7)) { + if(!strcmp(argv[i] + 7, "probe")) { + opts->tpmirq = TPM_PROBE_IRQ; + } else if( sscanf(argv[i] + 7, "%u", &opts->tpmirq) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmlocality=",12)) { + if(sscanf(argv[i] + 12, "%u", &opts->tpmlocality) != 1 || opts->tpmlocality > 4) { + goto err_invalid; + } + } + } + + switch(opts->tpmdriver) { + case TPMDRV_TPM_TIS: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpm_tis driver\n"); + break; + case TPMDRV_TPMFRONT: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpmfront driver\n"); + break; + } + + return 0; +err_invalid: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid Option %s\n", argv[i]); + return -1; +} + + + +static TPM_RESULT vtpmmgr_create(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + + // Take ownership if TPM is unowned + 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, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &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()); + + goto egress; +abort_egress: +egress: + vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager\n"); + + //End the OSAP session + if(osap.AuthHandle) { + TPM_TerminateHandle(osap.AuthHandle); + } + + return status; +} + +TPM_RESULT vtpmmgr_init(int argc, char** argv) { + TPM_RESULT status = TPM_SUCCESS; + + /* Default commandline options */ + struct Opts opts = { + .tpmdriver = TPMDRV_TPM_TIS, + .tpmiomem = TPM_BASEADDR, + .tpmirq = 0, + .tpmlocality = 0, + .gen_owner_auth = 0, + }; + + if(parse_cmdline_opts(argc, argv, &opts) != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Command line parsing failed! exiting..\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + //Setup storage system + if(vtpm_storage_init() != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize storage subsystem!\n"); + status = TPM_IOERROR; + goto abort_egress; + } + + //Setup tpmback device + init_tpmback(); + + //Setup tpm access + switch(opts.tpmdriver) { + case TPMDRV_TPM_TIS: + { + struct tpm_chip* tpm; + if((tpm = init_tpm_tis(opts.tpmiomem, TPM_TIS_LOCL_INT_TO_FLAG(opts.tpmlocality), opts.tpmirq)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpm_tis_open(tpm); + tpm_tis_request_locality(tpm, opts.tpmlocality); + } + break; + case TPMDRV_TPMFRONT: + { + struct tpmfront_dev* tpmfront_dev; + if((tpmfront_dev = init_tpmfront(NULL)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpmfront_open(tpmfront_dev); + } + break; + } + + //Get the version of the tpm + TPMTRYRETURN(check_tpm_version()); + + // Blow away all stale handles left in the tpm + if(flush_tpm() != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_FlushResources failed, continuing anyway..\n"); + } + + /* Initialize the rng */ + entropy_init(&vtpm_globals.entropy); + entropy_add_source(&vtpm_globals.entropy, tpm_entropy_source, NULL, 0); + entropy_gather(&vtpm_globals.entropy); + ctr_drbg_init(&vtpm_globals.ctr_drbg, entropy_func, &vtpm_globals.entropy, NULL, 0); + ctr_drbg_set_prediction_resistance( &vtpm_globals.ctr_drbg, CTR_DRBG_PR_OFF ); + + // Generate Auth for Owner + if(opts.gen_owner_auth) { + vtpmmgr_rand(vtpm_globals.owner_auth, sizeof(TPM_AUTHDATA)); + } + + // Create OIAP session for service's authorized commands + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); + + /* Load the Manager data, if it fails create a new manager */ + if (vtpm_storage_load_header() != TPM_SUCCESS) { + /* 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) ); + } + vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); + TPMTRYRETURN( vtpmmgr_create() ); + } + + goto egress; +abort_egress: + vtpmmgr_shutdown(); +egress: + return status; +} + +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); + + vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); +} diff --git a/stubdom/vtpmmgr/log.c b/stubdom/vtpmmgr/log.c new file mode 100644 index 0000000..a82c913 --- /dev/null +++ b/stubdom/vtpmmgr/log.c @@ -0,0 +1,151 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "tcg.h" + +char *module_names[] = { "", + "TPM", + "TPM", + "VTPM", + "VTPM", + "TXDATA", + }; +// Helper code for the consts, eg. to produce messages for error codes. + +typedef struct error_code_entry_t { + TPM_RESULT code; + char * code_name; + char * msg; +} error_code_entry_t; + +static const error_code_entry_t error_msgs [] = { + { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, + { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, + { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, + { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, + { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, + { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, + { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, + { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, + { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, + { TPM_FAIL, "TPM_FAIL", "The operation failed" }, + { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, + { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, + { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, + { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, + { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, + { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, + { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, + { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, + { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, + { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, + { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, + { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, + { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, + { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, + { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, + { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, + { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, + { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, + { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, + { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, + { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, + { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, + { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, + { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, + { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, + { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, + { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, + { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, + { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, + { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, + { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, + + { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, + { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, + { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, + { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, + { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, + { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, + { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, + { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, + { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, + { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, + { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, + { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, + { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, + { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, + { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, + { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, + { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, + { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, + { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, + { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, + { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, + { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, + { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, + { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, + { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, + { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, + { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, + { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, + { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, + { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, + { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, + { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, + { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, + { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, + { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, + { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, + { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, + { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, +}; + + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code) { + // just do a linear scan for now + unsigned i; + for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) + if (code == error_msgs[i].code) + return error_msgs[i].code_name; + + return("Unknown Error Code"); +} diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h new file mode 100644 index 0000000..5c7abf5 --- /dev/null +++ b/stubdom/vtpmmgr/log.h @@ -0,0 +1,85 @@ +/* + * 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_LOG_H__ +#define __VTPM_LOG_H__ + +#include // for uint32_t +#include // for pointer NULL +#include +#include "tcg.h" + +// =========================== LOGGING ============================== + +// the logging module numbers +#define VTPM_LOG_TPM 1 +#define VTPM_LOG_TPM_DEEP 2 +#define VTPM_LOG_VTPM 3 +#define VTPM_LOG_VTPM_DEEP 4 +#define VTPM_LOG_TXDATA 5 + +extern char *module_names[]; + +// Default to standard logging +#ifndef LOGGING_MODULES +#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)|BITMASK(VTPM_LOG_TPM)) +#endif + +// bit-access macros +#define BITMASK(idx) ( 1U << (idx) ) +#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) +#define SETBIT(num,idx) (num) |= BITMASK(idx) +#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) + +#define vtpmloginfo(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + } + +#define vtpmloginfomore(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, fmt,##args); \ + } + +#define vtpmlogerror(module, fmt, args...) \ + fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + +//typedef UINT32 tpm_size_t; + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code); + +#endif // _VTPM_LOG_H_ diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h new file mode 100644 index 0000000..77d32f0 --- /dev/null +++ b/stubdom/vtpmmgr/marshal.h @@ -0,0 +1,528 @@ +/* + * 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 MARSHAL_H +#define MARSHAL_H + +#include +#include +#include +#include "tcg.h" + +typedef enum UnpackPtr { + UNPACK_ALIAS, + UNPACK_ALLOC +} UnpackPtr; + +inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { + ptr[0] = t; + return ++ptr; +} + +inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { + t[0] = ptr[0]; + return ++ptr; +} + +#define pack_BOOL(p, t) pack_BYTE(p, t) +#define unpack_BOOL(p, t) unpack_BYTE(p, t) + +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* 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); +} + +#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) +#define pack_TPM_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TPM_AUTHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HASHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HMACHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENCHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_KEY_HANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENTITYHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_RESOURCE_TYPE(p, t) pack_UINT32(p, t) +#define pack_TPM_COMMAND_CODE(p, t) pack_UINT32(p, t) +#define pack_TPM_PROTOCOL_ID(p, t) pack_UINT16(p, t) +#define pack_TPM_AUTH_DATA_USAGE(p, t) pack_BYTE(p, t) +#define pack_TPM_ENTITY_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_ALGORITHM_ID(p, t) pack_UINT32(p, t) +#define pack_TPM_KEY_USAGE(p, t) pack_UINT16(p, t) +#define pack_TPM_STARTUP_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_CAPABILITY_AREA(p, t) pack_UINT32(p, t) +#define pack_TPM_ENC_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_SIG_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t) +#define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t) + +#define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_DIRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_AUTHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HASHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HMACHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENCHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_KEY_HANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENTITYHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_RESOURCE_TYPE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_COMMAND_CODE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PROTOCOL_ID(p, t) unpack_UINT16(p, t) +#define unpack_TPM_AUTH_DATA_USAGE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_ENTITY_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_ALGORITHM_ID(p, t) unpack_UINT32(p, t) +#define unpack_TPM_KEY_USAGE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STARTUP_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_CAPABILITY_AREA(p, t) unpack_UINT32(p, t) +#define unpack_TPM_ENC_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_SIG_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, 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 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; +} + +inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { + memcpy(buf, ptr, size); + return ptr + size; +} + +inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 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; +} + +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); + } +} + +inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { + 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); +} + +#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) +#define pack_TPM_TAG(p, t) pack_UINT16(p, t) +#define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) + +#define unpack_TPM_SECRET(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, 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; +} + +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; +} + +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; +} + +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; +} + +inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { + 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); +} + +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_PCRVALUE(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 pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_DIRVALUE(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); +} + +inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { + return unpack_BUFFER(ptr, 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); +} + +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 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); +} + +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 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; +} + +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; +} + +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 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); +} + +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 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; +} + +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; +} + +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; +} + +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 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; +} + +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 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); +} + +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); +} + +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); +} + +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; +} + +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; +} + +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; +} + +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; +} + +#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); + +#endif diff --git a/stubdom/vtpmmgr/minios.cfg b/stubdom/vtpmmgr/minios.cfg new file mode 100644 index 0000000..3fb383d --- /dev/null +++ b/stubdom/vtpmmgr/minios.cfg @@ -0,0 +1,14 @@ +CONFIG_TPMFRONT=y +CONFIG_TPM_TIS=y +CONFIG_TPMBACK=y +CONFIG_START_NETWORK=n +CONFIG_TEST=n +CONFIG_PCIFRONT=n +CONFIG_BLKFRONT=y +CONFIG_NETFRONT=n +CONFIG_FBFRONT=n +CONFIG_KBDFRONT=n +CONFIG_CONSFRONT=n +CONFIG_XENBUS=y +CONFIG_LWIP=n +CONFIG_XC=n diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h new file mode 100644 index 0000000..7687eae --- /dev/null +++ b/stubdom/vtpmmgr/tcg.h @@ -0,0 +1,707 @@ +/* + * 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 __TCG_H__ +#define __TCG_H__ + +#include +#include + +// **************************** CONSTANTS ********************************* + +// BOOL values +#define TRUE 0x01 +#define FALSE 0x00 + +#define TCPA_MAX_BUFFER_LENGTH 0x2000 + +// +// TPM_COMMAND_CODE values +#define TPM_PROTECTED_ORDINAL 0x00000000UL +#define TPM_UNPROTECTED_ORDINAL 0x80000000UL +#define TPM_CONNECTION_ORDINAL 0x40000000UL +#define TPM_VENDOR_ORDINAL 0x20000000UL + +#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveContext (184UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadContext (185UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FlushSpecific (186UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PCR_Reset (200UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_DefineSpace (204UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValue (205UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValueAuth (206UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValue (207UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValueAuth (208UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_UpdateVerification (209UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_Manage (210UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateKeyDelegation (212UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateOwnerDelegation (213UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_VerifyDelegation (214UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_LoadOwnerDelegation (216UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadAuth (217UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadTable (219UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateCounter (220UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_IncrementCounter (221UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadCounter (222UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounter (223UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounterOwner (224UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EstablishTransport (230UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ExecuteTransport (231UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseTransportSigned (232UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTicks (241UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TickStampBlob (242UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MAX (256UL + TPM_PROTECTED_ORDINAL) + +#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) + + + +// +// TPM_RESULT values +// +// just put in the whole table from spec 1.2 + +#define TPM_BASE 0x0 // The start of TPM return codes +#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands +#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. + +#define TPM_SUCCESS TPM_BASE // Successful completion of the operation +#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed +#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect +#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad +#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. +#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access +#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated +#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled +#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled +#define TPM_FAIL TPM_BASE + 9 // The operation failed +#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent +#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled +#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid +#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found +#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme +#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed +#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted +#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. +#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set +#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM +#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner +#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. +#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short +#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. +#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. +#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value +#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. +#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. +#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. +#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization +#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid +#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM +#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. +#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. +#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. +#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed +#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed +#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed +#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup +#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information +#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM + +#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. +#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. +#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key +#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. +#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value +#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability +#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions +#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also +#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success +#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute +#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport +#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed +#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource +#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode +#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID +#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available +#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command +#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key +#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization +#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable +#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation +#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to +#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area +#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match +#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to +#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict +#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent +#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. +#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect +#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area +#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large +#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded +#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set +#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded +#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked +#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family +#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled +#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session + +// TPM_STARTUP_TYPE values +#define TPM_ST_CLEAR 0x0001 +#define TPM_ST_STATE 0x0002 +#define TPM_ST_DEACTIVATED 0x003 + +// TPM_TAG values +#define TPM_TAG_RQU_COMMAND 0x00c1 +#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 +#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 +#define TPM_TAG_RSP_COMMAND 0x00c4 +#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 +#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 + +// TPM_PAYLOAD_TYPE values +#define TPM_PT_ASYM 0x01 +#define TPM_PT_BIND 0x02 +#define TPM_PT_MIGRATE 0x03 +#define TPM_PT_MAINT 0x04 +#define TPM_PT_SEAL 0x05 + +// TPM_ENTITY_TYPE values +#define TPM_ET_KEYHANDLE 0x0001 +#define TPM_ET_OWNER 0x0002 +#define TPM_ET_DATA 0x0003 +#define TPM_ET_SRK 0x0004 +#define TPM_ET_KEY 0x0005 + +/// TPM_ResourceTypes +#define TPM_RT_KEY 0x00000001 +#define TPM_RT_AUTH 0x00000002 +#define TPM_RT_HASH 0x00000003 +#define TPM_RT_TRANS 0x00000004 +#define TPM_RT_CONTEXT 0x00000005 +#define TPM_RT_COUNTER 0x00000006 +#define TPM_RT_DELEGATE 0x00000007 +#define TPM_RT_DAA_TPM 0x00000008 +#define TPM_RT_DAA_V0 0x00000009 +#define TPM_RT_DAA_V1 0x0000000A + + + +// TPM_PROTOCOL_ID values +#define TPM_PID_OIAP 0x0001 +#define TPM_PID_OSAP 0x0002 +#define TPM_PID_ADIP 0x0003 +#define TPM_PID_ADCP 0x0004 +#define TPM_PID_OWNER 0x0005 + +// TPM_ALGORITHM_ID values +#define TPM_ALG_RSA 0x00000001 +#define TPM_ALG_SHA 0x00000004 +#define TPM_ALG_HMAC 0x00000005 +#define TPM_ALG_AES128 0x00000006 +#define TPM_ALG_MFG1 0x00000007 +#define TPM_ALG_AES192 0x00000008 +#define TPM_ALG_AES256 0x00000009 +#define TPM_ALG_XOR 0x0000000A + +// TPM_ENC_SCHEME values +#define TPM_ES_NONE 0x0001 +#define TPM_ES_RSAESPKCSv15 0x0002 +#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 + +// TPM_SIG_SCHEME values +#define TPM_SS_NONE 0x0001 +#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 +#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 + +/* + * TPM_CAPABILITY_AREA Values for TPM_GetCapability ([TPM_Part2], Section 21.1) + */ +#define TPM_CAP_ORD 0x00000001 +#define TPM_CAP_ALG 0x00000002 +#define TPM_CAP_PID 0x00000003 +#define TPM_CAP_FLAG 0x00000004 +#define TPM_CAP_PROPERTY 0x00000005 +#define TPM_CAP_VERSION 0x00000006 +#define TPM_CAP_KEY_HANDLE 0x00000007 +#define TPM_CAP_CHECK_LOADED 0x00000008 +#define TPM_CAP_SYM_MODE 0x00000009 +#define TPM_CAP_KEY_STATUS 0x0000000C +#define TPM_CAP_NV_LIST 0x0000000D +#define TPM_CAP_MFR 0x00000010 +#define TPM_CAP_NV_INDEX 0x00000011 +#define TPM_CAP_TRANS_ALG 0x00000012 +#define TPM_CAP_HANDLE 0x00000014 +#define TPM_CAP_TRANS_ES 0x00000015 +#define TPM_CAP_AUTH_ENCRYPT 0x00000017 +#define TPM_CAP_SELECT_SIZE 0x00000018 +#define TPM_CAP_DA_LOGIC 0x00000019 +#define TPM_CAP_VERSION_VAL 0x0000001A + +/* subCap definitions ([TPM_Part2], Section 21.2) */ +#define TPM_CAP_PROP_PCR 0x00000101 +#define TPM_CAP_PROP_DIR 0x00000102 +#define TPM_CAP_PROP_MANUFACTURER 0x00000103 +#define TPM_CAP_PROP_KEYS 0x00000104 +#define TPM_CAP_PROP_MIN_COUNTER 0x00000107 +#define TPM_CAP_FLAG_PERMANENT 0x00000108 +#define TPM_CAP_FLAG_VOLATILE 0x00000109 +#define TPM_CAP_PROP_AUTHSESS 0x0000010A +#define TPM_CAP_PROP_TRANSESS 0x0000010B +#define TPM_CAP_PROP_COUNTERS 0x0000010C +#define TPM_CAP_PROP_MAX_AUTHSESS 0x0000010D +#define TPM_CAP_PROP_MAX_TRANSESS 0x0000010E +#define TPM_CAP_PROP_MAX_COUNTERS 0x0000010F +#define TPM_CAP_PROP_MAX_KEYS 0x00000110 +#define TPM_CAP_PROP_OWNER 0x00000111 +#define TPM_CAP_PROP_CONTEXT 0x00000112 +#define TPM_CAP_PROP_MAX_CONTEXT 0x00000113 +#define TPM_CAP_PROP_FAMILYROWS 0x00000114 +#define TPM_CAP_PROP_TIS_TIMEOUT 0x00000115 +#define TPM_CAP_PROP_STARTUP_EFFECT 0x00000116 +#define TPM_CAP_PROP_DELEGATE_ROW 0x00000117 +#define TPM_CAP_PROP_MAX_DAASESS 0x00000119 +#define TPM_CAP_PROP_DAASESS 0x0000011A +#define TPM_CAP_PROP_CONTEXT_DIST 0x0000011B +#define TPM_CAP_PROP_DAA_INTERRUPT 0x0000011C +#define TPM_CAP_PROP_SESSIONS 0x0000011D +#define TPM_CAP_PROP_MAX_SESSIONS 0x0000011E +#define TPM_CAP_PROP_CMK_RESTRICTION 0x0000011F +#define TPM_CAP_PROP_DURATION 0x00000120 +#define TPM_CAP_PROP_ACTIVE_COUNTER 0x00000122 +#define TPM_CAP_PROP_MAX_NV_AVAILABLE 0x00000123 +#define TPM_CAP_PROP_INPUT_BUFFER 0x00000124 + +// TPM_KEY_USAGE values +#define TPM_KEY_EK 0x0000 +#define TPM_KEY_SIGNING 0x0010 +#define TPM_KEY_STORAGE 0x0011 +#define TPM_KEY_IDENTITY 0x0012 +#define TPM_KEY_AUTHCHANGE 0X0013 +#define TPM_KEY_BIND 0x0014 +#define TPM_KEY_LEGACY 0x0015 + +// TPM_AUTH_DATA_USAGE values +#define TPM_AUTH_NEVER 0x00 +#define TPM_AUTH_ALWAYS 0x01 + +// Key Handle of owner and srk +#define TPM_OWNER_KEYHANDLE 0x40000001 +#define TPM_SRK_KEYHANDLE 0x40000000 + + + +// *************************** TYPEDEFS ********************************* +typedef unsigned char BYTE; +typedef unsigned char BOOL; +typedef uint16_t UINT16; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef UINT32 TPM_RESULT; +typedef UINT32 TPM_PCRINDEX; +typedef UINT32 TPM_DIRINDEX; +typedef UINT32 TPM_HANDLE; +typedef TPM_HANDLE TPM_AUTHHANDLE; +typedef TPM_HANDLE TCPA_HASHHANDLE; +typedef TPM_HANDLE TCPA_HMACHANDLE; +typedef TPM_HANDLE TCPA_ENCHANDLE; +typedef TPM_HANDLE TPM_KEY_HANDLE; +typedef TPM_HANDLE TCPA_ENTITYHANDLE; +typedef UINT32 TPM_RESOURCE_TYPE; +typedef UINT32 TPM_COMMAND_CODE; +typedef UINT16 TPM_PROTOCOL_ID; +typedef BYTE TPM_AUTH_DATA_USAGE; +typedef UINT16 TPM_ENTITY_TYPE; +typedef UINT32 TPM_ALGORITHM_ID; +typedef UINT16 TPM_KEY_USAGE; +typedef UINT16 TPM_STARTUP_TYPE; +typedef UINT32 TPM_CAPABILITY_AREA; +typedef UINT16 TPM_ENC_SCHEME; +typedef UINT16 TPM_SIG_SCHEME; +typedef UINT16 TPM_MIGRATE_SCHEME; +typedef UINT16 TPM_PHYSICAL_PRESENCE; +typedef UINT32 TPM_KEY_FLAGS; + +#define TPM_DIGEST_SIZE 20 // Don't change this +typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; +typedef TPM_AUTHDATA TPM_SECRET; +typedef TPM_AUTHDATA TPM_ENCAUTH; +typedef BYTE TPM_PAYLOAD_TYPE; +typedef UINT16 TPM_TAG; +typedef UINT16 TPM_STRUCTURE_TAG; + +// Data Types of the TCS +typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session +typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle +typedef UINT32 TCS_KEY_HANDLE; // Basic key handle + +// ************************* STRUCTURES ********************************** + +typedef struct TPM_VERSION { + BYTE major; + BYTE minor; + BYTE revMajor; + BYTE revMinor; +} TPM_VERSION; + +static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; + +typedef struct TPM_CAP_VERSION_INFO { + TPM_STRUCTURE_TAG tag; + TPM_VERSION version; + UINT16 specLevel; + BYTE errataRev; + BYTE tpmVendorID[4]; + UINT16 vendorSpecificSize; + BYTE* vendorSpecific; +} TPM_CAP_VERSION_INFO; + +inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { + free(v->vendorSpecific); + v->vendorSpecific = NULL; +} + +typedef struct TPM_DIGEST { + BYTE digest[TPM_DIGEST_SIZE]; +} TPM_DIGEST; + +typedef TPM_DIGEST TPM_PCRVALUE; +typedef TPM_DIGEST TPM_COMPOSITE_HASH; +typedef TPM_DIGEST TPM_DIRVALUE; +typedef TPM_DIGEST TPM_HMAC; +typedef TPM_DIGEST TPM_CHOSENID_HASH; + +typedef struct TPM_NONCE { + BYTE nonce[TPM_DIGEST_SIZE]; +} TPM_NONCE; + +typedef struct TPM_SYMMETRIC_KEY_PARMS { + UINT32 keyLength; + UINT32 blockSize; + UINT32 ivSize; + BYTE* IV; +} TPM_SYMMETRIC_KEY_PARMS; + +inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { + free(p->IV); + p->IV = NULL; +} + +#define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } + +typedef struct TPM_RSA_KEY_PARMS { + UINT32 keyLength; + UINT32 numPrimes; + UINT32 exponentSize; + BYTE* exponent; +} TPM_RSA_KEY_PARMS; + +#define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } + +inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { + free(p->exponent); + p->exponent = NULL; +} + +typedef struct TPM_KEY_PARMS { + TPM_ALGORITHM_ID algorithmID; + TPM_ENC_SCHEME encScheme; + TPM_SIG_SCHEME sigScheme; + UINT32 parmSize; + union { + TPM_SYMMETRIC_KEY_PARMS sym; + TPM_RSA_KEY_PARMS rsa; + } parms; +} TPM_KEY_PARMS; + +#define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } + +inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { + if(p->parmSize) { + switch(p->algorithmID) { + case TPM_ALG_RSA: + free_TPM_RSA_KEY_PARMS(&p->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); + break; + } + } +} + +typedef struct TPM_STORE_PUBKEY { + UINT32 keyLength; + BYTE* key; +} TPM_STORE_PUBKEY; + +#define TPM_STORE_PUBKEY_INIT { 0, NULL } + +inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { + free(p->key); + p->key = NULL; +} + +typedef struct TPM_PUBKEY { + TPM_KEY_PARMS algorithmParms; + TPM_STORE_PUBKEY pubKey; +} TPM_PUBKEY; + +#define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } + +inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { + free_TPM_KEY_PARMS(&k->algorithmParms); + free_TPM_STORE_PUBKEY(&k->pubKey); +} + +typedef struct TPM_PCR_SELECTION { + UINT16 sizeOfSelect; + BYTE* pcrSelect; +} TPM_PCR_SELECTION; + +#define TPM_PCR_SELECTION_INIT { 0, NULL } + +inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { + free(p->pcrSelect); + p->pcrSelect = NULL; +} + +typedef struct TPM_PCR_INFO { + TPM_PCR_SELECTION pcrSelection; + TPM_COMPOSITE_HASH digestAtRelease; + TPM_COMPOSITE_HASH digestAtCreation; +} TPM_PCR_INFO; + +#define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } + +inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { + free_TPM_PCR_SELECTION(&p->pcrSelection); +} + +typedef struct TPM_PCR_COMPOSITE { + TPM_PCR_SELECTION select; + UINT32 valueSize; + TPM_PCRVALUE* pcrValue; +} TPM_PCR_COMPOSITE; + +#define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } + +inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { + free_TPM_PCR_SELECTION(&p->select); + free(p->pcrValue); + p->pcrValue = NULL; +} + +typedef struct TPM_KEY { + TPM_VERSION ver; + TPM_KEY_USAGE keyUsage; + TPM_KEY_FLAGS keyFlags; + TPM_AUTH_DATA_USAGE authDataUsage; + TPM_KEY_PARMS algorithmParms; + UINT32 PCRInfoSize; + TPM_PCR_INFO PCRInfo; + TPM_STORE_PUBKEY pubKey; + UINT32 encDataSize; + BYTE* encData; +} TPM_KEY; + +#define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\ + .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \ + .pubKey = TPM_STORE_PUBKEY_INIT, \ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_KEY(TPM_KEY* k) { + if(k->PCRInfoSize) { + free_TPM_PCR_INFO(&k->PCRInfo); + } + free_TPM_STORE_PUBKEY(&k->pubKey); + free(k->encData); + k->encData = NULL; +} + +typedef struct TPM_BOUND_DATA { + TPM_VERSION ver; + TPM_PAYLOAD_TYPE payload; + BYTE* payloadData; +} TPM_BOUND_DATA; + +#define TPM_BOUND_DATA_INIT { .payloadData = NULL } + +inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { + free(d->payloadData); + d->payloadData = NULL; +} + +typedef struct TPM_STORED_DATA { + TPM_VERSION ver; + UINT32 sealInfoSize; + TPM_PCR_INFO sealInfo; + UINT32 encDataSize; + BYTE* encData; +} TPM_STORED_DATA; + +#define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { + if(d->sealInfoSize) { + free_TPM_PCR_INFO(&d->sealInfo); + } + free(d->encData); + d->encData = NULL; +} + +typedef struct TPM_AUTH_SESSION { + TPM_AUTHHANDLE AuthHandle; + TPM_NONCE NonceOdd; // system + TPM_NONCE NonceEven; // TPM + BOOL fContinueAuthSession; + TPM_AUTHDATA HMAC; +} TPM_AUTH_SESSION; + +#define TPM_AUTH_SESSION_INIT { .AuthHandle = 0, .fContinueAuthSession = FALSE } + +// ---------------------- Functions for checking TPM_RESULTs ----------------- + +#include + +// FIXME: Review use of these and delete unneeded ones. + +// these are really badly dependent on local structure: +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +#define ERRORDIE(s) do { status = s; \ + fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ + goto abort_egress; } \ + while (0) + +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +// Try command c. If it fails, set status to s and goto abort. +#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ + status = s; \ + printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } else {\ + status = c; \ + } + +// Try command c. If it fails, print error message, set status to actual return code. Goto abort +#define TPMTRYRETURN(c) do { status = c; \ + if (status != TPM_SUCCESS) { \ + fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } \ + } while(0) + + +#endif //__TCPA_H__ diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c new file mode 100644 index 0000000..123a27c --- /dev/null +++ b/stubdom/vtpmmgr/tpm.c @@ -0,0 +1,938 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include + +#include + +#include "tcg.h" +#include "tpm.h" +#include "log.h" +#include "marshal.h" +#include "tpmrsa.h" +#include "vtpmmgr.h" + +#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_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;\ + }\ +} 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]; + } + } + +} + +static void generateAuth(const TPM_DIGEST* paramDigest, + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) +{ + //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; + + 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); +} + +static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, + /*[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; + } +} + + + +// ------------------------------------------------------------------ +// Authorization Commands +// ------------------------------------------------------------------ + +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; + + ptr = unpack_UINT32(ptr, &auth->AuthHandle); + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + +abort_egress: + 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) +{ + BYTE* nonceOddOSAP; + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + + ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); + ptr = pack_UINT32(ptr, entityValue); + + //nonce Odd OSAP + nonceOddOSAP = ptr; + vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); + ptr += TPM_DIGEST_SIZE; + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + 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, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); + + 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); + +abort_egress: + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(outSrk); + } +egress: + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_DisablePubekRead ( + 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_AUTH1_GEN(ownerAuth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + TPM_AUTH1_VERIFY(ownerAuth, auth); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in +{ + if(handle == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + + ptr = pack_TPM_AUTHHANDLE(ptr, handle); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + +abort_egress: + return status; +} + +TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in + TPM_DIGEST inDigest, // in + TPM_PCRVALUE* outDigest) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + + ptr = pack_TPM_PCRINDEX(ptr, pcrNum); + ptr = pack_TPM_DIGEST(ptr, &inDigest); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + +abort_egress: + 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 + ) +{ + 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); + + ptr = pack_UINT32(ptr, pcrInfoSize); + ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); + + ptr = pack_UINT32(ptr, inDataSize); + ptr = pack_BUFFER(ptr, inData, inDataSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(osapSharedSecret, pubAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); + dataAlloced = 1; + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + + goto egress; +abort_egress: + if(dataAlloced) { + free_TPM_STORED_DATA(sealedData); + } +egress: + TPM_AUTH_ERR_CHECK(pubAuth); + 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_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_TPM_STORED_DATA(ptr, sealedData); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(key_usage_auth, keyAuth); + TPM_AUTH2_GEN(data_usage_auth, dataAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_UINT32(ptr, outSize); + ptr = unpack_ALLOC(ptr, out, *outSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); + TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + +abort_egress: + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; +} + +TPM_RESULT TPM_Bind( + const TPM_KEY* key, + const BYTE* in, + UINT32 ilen, + BYTE* 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)); + +abort_egress: + tpmrsa_free(&rsa); + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_UINT32(ptr, ilen); + ptr = pack_BUFFER(ptr, in, ilen); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(usage_auth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + 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); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(usage_auth, auth); + +abort_egress: +egress: + TPM_AUTH_ERR_CHECK(auth); + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(key); + } +egress: + TPM_AUTH_ERR_CHECK(pAuth); + 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_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); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + +TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +{ + if(hKey == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + + ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + +abort_egress: + 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(); + +abort_egress: + return status; +} + +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + + // check input params + if (bytesRequested == NULL || randomBytes == NULL){ + return TPM_BAD_PARAMETER; + } + + ptr = pack_UINT32(ptr, *bytesRequested); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, bytesRequested); + ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + +abort_egress: + return status; +} + + +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; +abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } +egress: + return status; +} + + +TPM_RESULT TPM_SaveState(void) +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + +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); + + ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); + ptr = pack_UINT32(ptr, subCapSize); + ptr = pack_BUFFER(ptr, subCap, subCapSize); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, respSize); + ptr = unpack_ALLOC(ptr, resp, *respSize); + +abort_egress: + return status; +} + +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(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + + ptr = pack_TPM_NONCE(ptr, &antiReplay); + ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + sha1_starts(&ctx); + + kptr = ptr; + ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); + + /* Hash the pub key blob */ + sha1_update(&ctx, kptr, ptr - kptr); + ptr = unpack_TPM_DIGEST(ptr, &checksum); + + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + + 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; + } + + goto egress; +abort_egress: + if(kptr) { + free_TPM_PUBKEY(pubEK); + } +egress: + 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; + +abort_egress: +egress: + return status; +} diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h new file mode 100644 index 0000000..304e145 --- /dev/null +++ b/stubdom/vtpmmgr/tpm.h @@ -0,0 +1,218 @@ +/* + * 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/2006, 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 __TPM_H__ +#define __TPM_H__ + +#include "tcg.h" + +// ------------------------------------------------------------------ +// Exposed API +// ------------------------------------------------------------------ + +// TPM v1.1B Command Set + +// Authorzation +TPM_RESULT TPM_OIAP( + TPM_AUTH_SESSION* auth //out + ); + +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); + +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 + ); + +TPM_RESULT TPM_DisablePubekRead ( + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth + ); + +TPM_RESULT TPM_TerminateHandle ( TPM_AUTHHANDLE handle // in + ); + +TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in + TPM_RESOURCE_TYPE resourceType //in + ); + +// TPM Mandatory +TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // 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_Seal( + TCS_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* sealDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ); + +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_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 + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + 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 + ); + +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp); + +TPM_RESULT TPM_SaveState(void); + +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK); + +TPM_RESULT TPM_TransmitData( + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize); + +#endif //TPM_H diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c new file mode 100644 index 0000000..56094e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -0,0 +1,175 @@ +/* + * The RSA public-key cryptosystem + * + * Copyright (C) 2006-2011, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +/* + * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman. + * + * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf + * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf + */ + +#include "tcg.h" +#include "polarssl/sha1.h" + +#include +#include + +#include "tpmrsa.h" + +#define HASH_LEN 20 + +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen) { + + tpmrsa_free(ctx); + + if(explen == 0) { //Default e= 2^16+1 + mpi_lset(&ctx->E, 65537); + } else { + mpi_read_binary(&ctx->E, exponent, explen); + } + mpi_read_binary(&ctx->N, key, keylen); + + ctx->len = ( mpi_msb(&ctx->N) + 7) >> 3; +} + +static TPM_RESULT tpmrsa_public( tpmrsa_context *ctx, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + size_t olen; + mpi T; + + mpi_init( &T ); + + MPI_CHK( mpi_read_binary( &T, input, ctx->len ) ); + + if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 ) + { + mpi_free( &T ); + return TPM_ENCRYPT_ERROR; + } + + olen = ctx->len; + MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) ); + MPI_CHK( mpi_write_binary( &T, output, olen ) ); + +cleanup: + + mpi_free( &T ); + + if( ret != 0 ) + return TPM_ENCRYPT_ERROR; + + return TPM_SUCCESS; +} + +static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) +{ + unsigned char mask[HASH_LEN]; + unsigned char counter[4] = {0, 0, 0, 0}; + int i; + sha1_context mctx; + + //We always hash the src with the counter, so save the partial hash + sha1_starts(&mctx); + sha1_update(&mctx, src, slen); + + // Generate and apply dbMask + while(dlen > 0) { + //Copy the sha1 context + sha1_context ctx = mctx; + + //compute hash for input || counter + sha1_update(&ctx, counter, sizeof(counter)); + sha1_finish(&ctx, mask); + + //Apply the mask + for(i = 0; i < (dlen < HASH_LEN ? dlen : HASH_LEN); ++i) { + *(dst++) ^= mask[i]; + } + + //Increment counter + ++counter[3]; + + dlen -= HASH_LEN; + } +} + +/* + * Add the message padding, then do an RSA operation + */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + int olen; + unsigned char* seed = output + 1; + unsigned char* db = output + HASH_LEN +1; + + olen = ctx->len-1; + + if( f_rng == NULL ) + return TPM_ENCRYPT_ERROR; + + if( ilen > olen - 2 * HASH_LEN - 1) + return TPM_ENCRYPT_ERROR; + + output[0] = 0; + + //Encoding parameter p + sha1((unsigned char*)"TCPA", 4, db); + + //PS + memset(db + HASH_LEN, 0, + olen - ilen - 2 * HASH_LEN - 1); + + //constant 1 byte + db[olen - ilen - HASH_LEN -1] = 0x01; + + //input string + memcpy(db + olen - ilen - HASH_LEN, + input, ilen); + + //Generate random seed + if( ( ret = f_rng( p_rng, seed, HASH_LEN ) ) != 0 ) + return TPM_ENCRYPT_ERROR; + + // maskedDB: Apply dbMask to DB + mgf_mask( db, olen - HASH_LEN, seed, HASH_LEN); + + // maskedSeed: Apply seedMask to seed + mgf_mask( seed, HASH_LEN, db, olen - HASH_LEN); + + // Do the crypto op + return tpmrsa_public(ctx, output, output); +} diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h new file mode 100644 index 0000000..59579e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -0,0 +1,67 @@ +/** + * \file rsa.h + * + * \brief The RSA public-key cryptosystem + * + * Copyright (C) 2006-2010, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef TPMRSA_H +#define TPMRSA_H + +#include "tcg.h" +#include + +/* tpm software key */ +typedef struct +{ + size_t len; /*!< size(N) in chars */ + + mpi N; /*!< public modulus */ + mpi E; /*!< public exponent */ + + mpi RN; /*!< cached R^2 mod N */ +} +tpmrsa_context; + +#define TPMRSA_CTX_INIT { 0, {0, 0, NULL}, {0, 0, NULL}, {0, 0, NULL}} + +/* Setup the rsa context using tpm public key data */ +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen); + +/* Do rsa public crypto */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ); + +/* free tpmrsa key */ +inline void tpmrsa_free( tpmrsa_context *ctx ) { + mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); +} + +#endif /* tpmrsa.h */ diff --git a/stubdom/vtpmmgr/uuid.h b/stubdom/vtpmmgr/uuid.h new file mode 100644 index 0000000..4737645 --- /dev/null +++ b/stubdom/vtpmmgr/uuid.h @@ -0,0 +1,50 @@ +/* + * 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 VTPMMGR_UUID_H +#define VTPMMGR_UUID_H + +#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx" +#define UUID_FMTLEN ((2*16)+4) /* 16 hex bytes plus 4 hypens */ +#define UUID_BYTES(uuid) uuid[0], uuid[1], uuid[2], uuid[3], \ + uuid[4], uuid[5], uuid[6], uuid[7], \ + uuid[8], uuid[9], uuid[10], uuid[11], \ + uuid[12], uuid[13], uuid[14], uuid[15] + + +typedef uint8_t uuid_t[16]; + +#endif diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c new file mode 100644 index 0000000..f82a2a9 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -0,0 +1,152 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "marshal.h" +#include "log.h" +#include "vtpm_storage.h" +#include "vtpmmgr.h" +#include "tpm.h" +#include "tcg.h" + +static TPM_RESULT vtpmmgr_SaveHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + + 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; + } + + /* Do the command */ + TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + return status; +} + +static TPM_RESULT vtpmmgr_LoadHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) { + TPM_RESULT status = TPM_SUCCESS; + + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + + tpmcmd->resp_len += HASHKEYSZ; + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + + +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; + } + +abort_egress: + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, + tag + 3, tpmcmd->resp_len, status); + + return status; +} diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h new file mode 100644 index 0000000..a2bbcca --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -0,0 +1,64 @@ +/* + * 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_MANAGER_H +#define VTPM_MANAGER_H + +#define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_RSP 0x01c4 +#define COMMAND_BUFFER_SIZE 4096 + +// Header size +#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) + +//************************ 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) + +// 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 +#define VTPM_FAIL 1 +#define VTPM_UNSUPPORTED 2 +#define VTPM_FORBIDDEN 3 +#define VTPM_RESTORE_CONTEXT_FAILED 4 +#define VTPM_INVALID_REQUEST 5 + +#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c new file mode 100644 index 0000000..3862fdb --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.c @@ -0,0 +1,783 @@ +/* + * 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 Boot Key + * BYTEARRAY storage_key TPM boot key + * + * ************************************************************* + * Section 2: Key Data Table (starts at offset 4096) + * + * This is a list of blocks, each is RSA_CIPHER_SIZE long + * and is encrypted with the storage key. + * + * The first block always exists and it contains: + * uint32_t num_vtpms Number of vtpms (number of remaining blocks) + * + * The rest of the blocks look like this: + * 16 bytes uuid uuid of the owner of this key and hash + * 20 bytes hash Sha1 hash of vTPM's data, supplied by vTPM + * 32 bytes key AES-256 Encryption Key, supplied by vTPM + * + * ************************************************************* + */ +#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 (%ld)\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 new file mode 100644 index 0000000..a5a5fd7 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.h @@ -0,0 +1,68 @@ +/* + * 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.c b/stubdom/vtpmmgr/vtpmmgr.c new file mode 100644 index 0000000..563f4e8 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.c @@ -0,0 +1,93 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include +#include +#include "log.h" + +#include "vtpmmgr.h" +#include "tcg.h" + + +void main_loop(void) { + tpmcmd_t* tpmcmd; + uint8_t respbuf[TCPA_MAX_BUFFER_LENGTH]; + + while(1) { + /* Wait for requests from a vtpm */ + vtpmloginfo(VTPM_LOG_VTPM, "Waiting for commands from vTPM's:\n"); + if((tpmcmd = tpmback_req_any()) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "NULL tpmcmd\n"); + continue; + } + + tpmcmd->resp = respbuf; + + /* Process the command */ + vtpmmgr_handle_cmd(tpmcmd->uuid, tpmcmd); + + /* Send response */ + tpmback_resp(tpmcmd); + } +} + +int main(int argc, char** argv) +{ + int rc = 0; + sleep(2); + vtpmloginfo(VTPM_LOG_VTPM, "Starting vTPM manager domain\n"); + + /* Initialize the vtpm manager */ + if(vtpmmgr_init(argc, argv) != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize vtpmmgr domain!\n"); + rc = -1; + goto exit; + } + + main_loop(); + + vtpmloginfo(VTPM_LOG_VTPM, "vTPM Manager shutting down...\n"); + + vtpmmgr_shutdown(); + +exit: + return rc; + +} diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h new file mode 100644 index 0000000..50a1992 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -0,0 +1,77 @@ +/* + * 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 VTPMMGR_H +#define VTPMMGR_H + +#include +#include +#include + +#include "uuid.h" +#include "tcg.h" +#include "vtpm_manager.h" + +#define RSA_KEY_SIZE 0x0800 +#define RSA_CIPHER_SIZE (RSA_KEY_SIZE / 8) + +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; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; +}; + +// --------------------------- 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); + +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; +} + +#endif -- 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 Thu Nov 01 20:40:29 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 01 Nov 2012 20:40: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 1TU1Yp-0006KW-H7; Thu, 01 Nov 2012 20:40:19 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TU1Uv-0005Uu-Ke for xen-devel@lists.xen.org; Thu, 01 Nov 2012 20:36:18 +0000 Received: from [193.109.254.147:12184] by server-13.bemta-14.messagelabs.com id F9/98-11239-04DD2905; Thu, 01 Nov 2012 20:36:16 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-12.tower-27.messagelabs.com!1351802168!8576896!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.0 required=7.0 tests=Mail larger than max spam size X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 22623 invoked from network); 1 Nov 2012 20:36:10 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-12.tower-27.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 1 Nov 2012 20:36:10 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.148031182; Thu, 01 Nov 2012 16:35:56 -0400 From: Matthew Fioravante To: Ian.Campbell@citrix.com, xen-devel@lists.xen.org, stefano.stabellini@eu.citrix.com Date: Thu, 1 Nov 2012 16:35:47 -0400 Message-Id: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 X-Mailman-Approved-At: Thu, 01 Nov 2012 20:40:18 +0000 Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM 6/9] Remove the vtpm process model 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 Remove the old vtpm process model. It doesn't work very well and is no longer supported. Signed-off-by: Matthew Fioravante diff --git a/tools/Makefile b/tools/Makefile index d8c8cc0..2ca43b9 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -18,8 +18,6 @@ SUBDIRS-$(CONFIG_XCUTILS) += xcutils SUBDIRS-$(CONFIG_X86) += firmware SUBDIRS-y += console SUBDIRS-y += xenmon -SUBDIRS-$(VTPM_TOOLS) += vtpm_manager -SUBDIRS-$(VTPM_TOOLS) += vtpm SUBDIRS-y += xenstat SUBDIRS-$(CONFIG_Linux) += $(SUBDIRS-libaio) SUBDIRS-$(CONFIG_Linux) += memshr diff --git a/tools/blktap2/drivers/hashtable.c b/tools/blktap2/drivers/hashtable.c index 631306b..90a6b85 100644 --- a/tools/blktap2/drivers/hashtable.c +++ b/tools/blktap2/drivers/hashtable.c @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable.c - * - tools/vtpm_manager/util/hashtable.c */ #include "hashtable.h" diff --git a/tools/blktap2/drivers/hashtable.h b/tools/blktap2/drivers/hashtable.h index 89aa3dc..56ca053 100644 --- a/tools/blktap2/drivers/hashtable.h +++ b/tools/blktap2/drivers/hashtable.h @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable.h - * - tools/vtpm_manager/util/hashtable.h */ #ifndef __HASHTABLE_CWC22_H__ diff --git a/tools/blktap2/drivers/hashtable_itr.c b/tools/blktap2/drivers/hashtable_itr.c index 402e06b..731917c 100644 --- a/tools/blktap2/drivers/hashtable_itr.c +++ b/tools/blktap2/drivers/hashtable_itr.c @@ -1,10 +1,5 @@ /* Copyright (C) 2002, 2004 Christopher Clark */ -/* - * There are duplicates of this code in: - * - tools/vtpm_manager/util/hashtable_itr.c - */ - #include "hashtable.h" #include "hashtable_private.h" #include "hashtable_itr.h" diff --git a/tools/blktap2/drivers/hashtable_itr.h b/tools/blktap2/drivers/hashtable_itr.h index 3d80638..81da838 100644 --- a/tools/blktap2/drivers/hashtable_itr.h +++ b/tools/blktap2/drivers/hashtable_itr.h @@ -1,10 +1,5 @@ /* Copyright (C) 2002, 2004 Christopher Clark */ -/* - * There are duplicates of this code in: - * - tools/vtpm_manager/util/hashtable_itr.h - */ - #ifndef __HASHTABLE_ITR_CWC22__ #define __HASHTABLE_ITR_CWC22__ #include "hashtable.h" diff --git a/tools/blktap2/drivers/hashtable_private.h b/tools/blktap2/drivers/hashtable_private.h index 5a13a65..954ecc3 100644 --- a/tools/blktap2/drivers/hashtable_private.h +++ b/tools/blktap2/drivers/hashtable_private.h @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable_private.h - * - tools/vtpm_manager/util/hashtable_private.h */ #ifndef __HASHTABLE_PRIVATE_CWC22_H__ diff --git a/tools/configure.ac b/tools/configure.ac index e708f01..586313d 100644 --- a/tools/configure.ac +++ b/tools/configure.ac @@ -40,7 +40,6 @@ m4_include([m4/fetcher.m4]) # Enable/disable options AX_ARG_DEFAULT_DISABLE([githttp], [Download GIT repositories via HTTP]) AX_ARG_DEFAULT_ENABLE([monitors], [Disable xenstat and xentop monitoring tools]) -AX_ARG_DEFAULT_DISABLE([vtpm], [Enable Virtual Trusted Platform Module]) AX_ARG_DEFAULT_DISABLE([xenapi], [Enable Xen API Bindings]) AX_ARG_DEFAULT_ENABLE([ocamltools], [Disable Ocaml tools]) AX_ARG_DEFAULT_DISABLE([miniterm], [Enable miniterm]) diff --git a/tools/examples/README b/tools/examples/README index 5b0314e..2225d5c 100644 --- a/tools/examples/README +++ b/tools/examples/README @@ -25,13 +25,7 @@ vif-bridge - virtual network start/stop script in bridged mode vif-common.sh - sourced by vif-bridge vif-nat - xen virtual network start/stop script in NAT mode vif-route - xen virtual network start/stop script in routed mode -vtpm - called by xen-backend.agent to bind/unbind vTPM devices -vtpm-common.sh - common code for vTPM handling -vtpm-delete - remove an entry from the vTPM table given the - domain's name -vtpm-hotplug-common.sh - sourced by vtpm -vtpm-migration.sh - sourced by external-device-migrate -xen-backend.agent - calls block, vif-*, vtpm scripts to add, remove, hotplug +xen-backend.agent - calls block, vif-* scripts to add, remove, hotplug devices xen-backend.rules - hotplug script rules xend-config.sxp - default xend configuration file diff --git a/tools/examples/xmexample.pv-grub b/tools/examples/xmexample.pv-grub index 85f847c..e04e6c1 100644 --- a/tools/examples/xmexample.pv-grub +++ b/tools/examples/xmexample.pv-grub @@ -105,20 +105,6 @@ disk = [ 'phy:hda1,hda1,w' ] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = [ 'instance=1,backend=0' ] - -#---------------------------------------------------------------------------- # Configure the behaviour when a domain exits. There are three 'reasons' # for a domain to stop: poweroff, reboot, and crash. For each of these you # may specify: diff --git a/tools/examples/xmexample1 b/tools/examples/xmexample1 index 330aaf0..c951200 100644 --- a/tools/examples/xmexample1 +++ b/tools/examples/xmexample1 @@ -101,20 +101,6 @@ disk = [ 'phy:hda1,hda1,w' ] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = [ 'instance=1,backend=0' ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff --git a/tools/examples/xmexample2 b/tools/examples/xmexample2 index 4e5eb3d..8c5137e 100644 --- a/tools/examples/xmexample2 +++ b/tools/examples/xmexample2 @@ -137,20 +137,6 @@ disk = [ 'phy:sda%d,sda1,w' % (7+vmid), # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = ['instance=%d,backend=0' % (vmid) ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff --git a/tools/examples/xmexample3 b/tools/examples/xmexample3 index dc22ce1..ae799f9 100644 --- a/tools/examples/xmexample3 +++ b/tools/examples/xmexample3 @@ -122,20 +122,6 @@ disk = [ 'phy:hda%d,hda1,w' % (vmid)] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = ['instance=%d,backend=0' % (vmid) ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff --git a/tools/hotplug/Linux/Makefile b/tools/hotplug/Linux/Makefile index 0166790..0605559 100644 --- a/tools/hotplug/Linux/Makefile +++ b/tools/hotplug/Linux/Makefile @@ -18,14 +18,12 @@ XEN_SCRIPTS += vif-setup XEN_SCRIPTS += block XEN_SCRIPTS += block-enbd block-nbd XEN_SCRIPTS += blktap -XEN_SCRIPTS += vtpm vtpm-delete XEN_SCRIPTS += xen-hotplug-cleanup XEN_SCRIPTS += external-device-migrate XEN_SCRIPTS += vscsi XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh -XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh vtpm-hotplug-common.sh -XEN_SCRIPT_DATA += vtpm-migration.sh vtpm-impl +XEN_SCRIPT_DATA += block-common.sh UDEV_RULES_DIR = $(CONFIG_DIR)/udev UDEV_RULES = xen-backend.rules xend.rules diff --git a/tools/hotplug/Linux/vtpm b/tools/hotplug/Linux/vtpm deleted file mode 100644 index 38a4532..0000000 --- a/tools/hotplug/Linux/vtpm +++ /dev/null @@ -1,22 +0,0 @@ -#!/bin/bash - -dir=$(dirname "$0") -. "$dir/vtpm-hotplug-common.sh" - -vtpm_fatal_error=0 - -case "$command" in - add) - vtpm_create_instance - ;; - remove) - vtpm_remove_instance - ;; -esac - -if [ $vtpm_fatal_error -eq 0 ]; then - log debug "Successful vTPM operation '$command'." - success -else - fatal "Error while executing vTPM operation '$command'." -fi diff --git a/tools/hotplug/Linux/vtpm-common.sh b/tools/hotplug/Linux/vtpm-common.sh deleted file mode 100644 index d0d7935..0000000 --- a/tools/hotplug/Linux/vtpm-common.sh +++ /dev/null @@ -1,448 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# Copyright (c) 2005 XenSource Ltd. -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/logging.sh" -. "$dir/locking.sh" - -VTPMDB="/var/vtpm/vtpm.db" - -#In the vtpm-impl file some commands should be defined: -# vtpm_create, vtpm_setup, vtpm_start, etc. (see below) -if [ -r "$dir/vtpm-impl.alt" ]; then - . "$dir/vtpm-impl.alt" -elif [ -r "$dir/vtpm-impl" ]; then - . "$dir/vtpm-impl" -else - function vtpm_create () { - true - } - function vtpm_setup() { - true - } - function vtpm_start() { - true - } - function vtpm_suspend() { - true - } - function vtpm_resume() { - true - } - function vtpm_delete() { - true - } - function vtpm_migrate() { - echo "Error: vTPM migration accross machines not implemented." - } - function vtpm_migrate_local() { - echo "Error: local vTPM migration not supported" - } - function vtpm_migrate_recover() { - true - } -fi - - -#Find the instance number for the vtpm given the name of the domain -# Parameters -# - vmname : the name of the vm -# Return value -# Returns '0' if instance number could not be found, otherwise -# it returns the instance number in the variable 'instance' -function vtpmdb_find_instance () { - local vmname ret instance - vmname=$1 - ret=0 - - instance=$(cat $VTPMDB | \ - awk -vvmname=$vmname \ - '{ \ - if ( 1 != index($1,"#")) { \ - if ( $1 == vmname ) { \ - print $2; \ - exit; \ - } \ - } \ - }') - if [ "$instance" != "" ]; then - ret=$instance - fi - echo "$ret" -} - - -# Check whether a particular instance number is still available -# returns "0" if it is not available, "1" otherwise. -function vtpmdb_is_free_instancenum () { - local instance instances avail i - instance=$1 - avail=1 - #Allowed instance number range: 1-255 - if [ $instance -eq 0 -o $instance -gt 255 ]; then - avail=0 - else - instances=$(cat $VTPMDB | \ - awk \ - '{ \ - if (1 != index($1,"#")) { \ - printf("%s ",$2); \ - } \ - }') - for i in $instances; do - if [ $i -eq $instance ]; then - avail=0 - break - fi - done - fi - echo "$avail" -} - - -# Get an available instance number given the database -# Returns an unused instance number -function vtpmdb_get_free_instancenum () { - local ctr instances don found - instances=$(cat $VTPMDB | \ - awk \ - '{ \ - if (1 != index($1,"#")) { \ - printf("%s ",$2); \ - } \ - }') - ctr=1 - don=0 - while [ $don -eq 0 ]; do - found=0 - for i in $instances; do - if [ $i -eq $ctr ]; then - found=1; - break; - fi - done - - if [ $found -eq 0 ]; then - don=1 - break - fi - let ctr=ctr+1 - done - echo "$ctr" -} - - -# Add a domain name and instance number to the DB file -function vtpmdb_add_instance () { - local res vmname inst - vmname=$1 - inst=$2 - - if [ ! -f $VTPMDB ]; then - echo "#Database for VM to vTPM association" > $VTPMDB - echo "#1st column: domain name" >> $VTPMDB - echo "#2nd column: TPM instance number" >> $VTPMDB - fi - res=$(vtpmdb_validate_entry $vmname $inst) - if [ $res -eq 0 ]; then - echo "$vmname $inst" >> $VTPMDB - fi -} - - -#Validate whether an entry is the same as passed to this -#function -function vtpmdb_validate_entry () { - local res rc vmname inst - rc=0 - vmname=$1 - inst=$2 - - res=$(cat $VTPMDB | \ - awk -vvmname=$vmname \ - -vinst=$inst \ - '{ \ - if ( 1 == index($1,"#")) {\ - } else \ - if ( $1 == vmname && \ - $2 == inst) { \ - printf("1"); \ - exit; \ - } else \ - if ( $1 == vmname || \ - $2 == inst) { \ - printf("2"); \ - exit; \ - } \ - }') - - if [ "$res" == "1" ]; then - rc=1 - elif [ "$res" == "2" ]; then - rc=2 - fi - echo "$rc" -} - - -#Remove an entry from the vTPM database given its domain name -#and instance number -function vtpmdb_remove_entry () { - local vmname instance VTPMDB_TMP - vmname=$1 - instance=$2 - VTPMDB_TMP="$VTPMDB".tmp - - $(cat $VTPMDB | \ - awk -vvmname=$vmname \ - '{ \ - if ( $1 != vmname ) { \ - print $0; \ - } \ - '} > $VTPMDB_TMP) - if [ -e $VTPMDB_TMP ]; then - mv -f $VTPMDB_TMP $VTPMDB - vtpm_delete $instance - else - log err "Error creating temporary file '$VTPMDB_TMP'." - fi -} - - -# Find the reason for the creation of this device: -# Returns 'resume' or 'create' -function vtpm_get_create_reason () { - local resume - resume=$(xenstore_read $XENBUS_PATH/resume) - if [ "$resume" == "True" ]; then - echo "resume" - else - echo "create" - fi -} - - -#Create a vTPM instance -# If no entry in the TPM database is found, the instance is -# created and an entry added to the database. -function vtpm_create_instance () { - local res instance domname reason uuid - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) - reason=$(vtpm_get_create_reason) - - claim_lock vtpmdb - - instance="0" - - if [ "$uuid" != "" ]; then - instance=$(vtpmdb_find_instance $uuid) - fi - if [ "$instance" == "0" ]; then - domname=$(xenstore_read "$XENBUS_PATH"/domain) - instance=$(vtpmdb_find_instance $domname) - fi - - if [ "$instance" == "0" -a "$reason" != "create" ]; then - release_lock vtpmdb - return - fi - - if [ "$instance" == "0" ]; then - #Try to give the preferred instance to the domain - instance=$(xenstore_read "$XENBUS_PATH"/pref_instance) - if [ "$instance" != "" ]; then - res=$(vtpmdb_is_free_instancenum $instance) - if [ $res -eq 0 ]; then - instance=$(vtpmdb_get_free_instancenum) - fi - else - instance=$(vtpmdb_get_free_instancenum) - fi - - vtpm_create $instance - - if [ $vtpm_fatal_error -eq 0 ]; then - if [ "$uuid" != "" ]; then - vtpmdb_add_instance $uuid $instance - else - vtpmdb_add_instance $domname $instance - fi - fi - else - if [ "$reason" == "resume" ]; then - vtpm_resume $instance - else - vtpm_start $instance - fi - fi - - release_lock vtpmdb - - xenstore_write $XENBUS_PATH/instance $instance -} - - -#Remove an instance when a VM is terminating or suspending. -#Since it is assumed that the VM will appear again, the -#entry is kept in the VTPMDB file. -function vtpm_remove_instance () { - local instance reason domname uuid - #Stop script execution quietly if path does not exist (anymore) - xenstore-exists "$XENBUS_PATH"/domain - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) - - claim_lock vtpmdb - - instance="0" - - if [ "$uuid" != "" ]; then - instance=$(vtpmdb_find_instance $uuid) - fi - - if [ "$instance" == "0" ]; then - domname=$(xenstore_read "$XENBUS_PATH"/domain) - instance=$(vtpmdb_find_instance $domname) - fi - - if [ "$instance" != "0" ]; then - vtpm_suspend $instance - fi - - release_lock vtpmdb -} - - -#Remove an entry in the VTPMDB file given the domain's name -#1st parameter: The name of the domain -function vtpm_delete_instance () { - local instance - - claim_lock vtpmdb - - instance=$(vtpmdb_find_instance $1) - if [ "$instance" != "0" ]; then - vtpmdb_remove_entry $1 $instance - fi - - release_lock vtpmdb -} - -# Determine whether the given address is local to this machine -# Return values: -# "-1" : the given machine name is invalid -# "0" : this is not an address of this machine -# "1" : this is an address local to this machine -function vtpm_isLocalAddress() { - local addr res - addr=$(ping $1 -c 1 | \ - awk '{ print substr($3,2,length($3)-2); exit }') - if [ "$addr" == "" ]; then - echo "-1" - return - fi - res=$(ifconfig | grep "inet addr" | \ - awk -vaddr=$addr \ - '{ \ - if ( addr == substr($2, 6)) {\ - print "1"; \ - } \ - }' \ - ) - if [ "$res" == "" ]; then - echo "0" - return - fi - echo "1" -} - -# Perform a migration step. This function differentiates between migration -# to the local host or to a remote machine. -# Parameters: -# 1st: destination host to migrate to -# 2nd: name of the domain to migrate -# 3rd: the migration step to perform -function vtpm_migration_step() { - local res=$(vtpm_isLocalAddress $1) - if [ "$res" == "0" ]; then - vtpm_migrate $1 $2 $3 - else - vtpm_migrate_local - fi -} - -# Recover from migration due to an error. This function differentiates -# between migration to the local host or to a remote machine. -# Parameters: -# 1st: destination host the migration was going to -# 2nd: name of the domain that was to be migrated -# 3rd: the last successful migration step that was done -function vtpm_recover() { - local res - res=$(vtpm_isLocalAddress $1) - if [ "$res" == "0" ]; then - vtpm_migrate_recover $1 $2 $3 - fi -} - - -#Determine the domain id given a domain's name. -#1st parameter: name of the domain -#return value: domain id or -1 if domain id could not be determined -function vtpm_domid_from_name () { - local id name ids - ids=$(xenstore-list /local/domain) - for id in $ids; do - name=$(xenstore-read /local/domain/$id/name) - if [ "$name" == "$1" ]; then - echo "$id" - return - fi - done - echo "-1" -} - -#Determine the virtual TPM's instance number using the domain ID. -#1st parm: domain ID -function vtpm_uuid_by_domid() { - echo $(xenstore-read /local/domain/0/backend/vtpm/$1/0/uuid) -} - - -# Determine the vTPM's UUID by the name of the VM -function vtpm_uuid_from_vmname() { - local domid=$(vtpm_domid_from_name $1) - if [ "$domid" != "-1" ]; then - echo $(vtpm_uuid_by_domid $domid) - return - fi - echo "" -} - -#Add a virtual TPM instance number and its associated domain name -#to the VTPMDB file and activate usage of this virtual TPM instance -#by writing the instance number into the xenstore -#1st parm: name of virtual machine -#2nd parm: instance of associated virtual TPM -function vtpm_add_and_activate() { - local domid=$(vtpm_domid_from_name $1) - local vtpm_uuid=$(vtpm_uuid_from_vmname $1) - if [ "$vtpm_uuid" != "" -a "$domid" != "-1" ]; then - vtpmdb_add_instance $vtpm_uuid $2 - xenstore-write backend/vtpm/$domid/0/instance $2 - fi -} diff --git a/tools/hotplug/Linux/vtpm-delete b/tools/hotplug/Linux/vtpm-delete deleted file mode 100644 index b75b95b..0000000 --- a/tools/hotplug/Linux/vtpm-delete +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash - -# This scripts must be called the following way: -# vtpm-delete -# or -# vtpm-delete --vmname - -dir=$(dirname "$0") -. "$dir/vtpm-common.sh" - -if [ "$1" == "--vmname" ]; then - vtpm_uuid=$(vtpm_uuid_from_vmname $2) - if [ "$vtpm_uuid" != "" ];then - vtpm_delete_instance $vtpm_uuid - fi -else - vtpm_delete_instance $1 -fi diff --git a/tools/hotplug/Linux/vtpm-hotplug-common.sh b/tools/hotplug/Linux/vtpm-hotplug-common.sh deleted file mode 100644 index 9fd35e7..0000000 --- a/tools/hotplug/Linux/vtpm-hotplug-common.sh +++ /dev/null @@ -1,35 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# Copyright (c) 2005 XenSource Ltd. -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/xen-hotplug-common.sh" - -findCommand "$@" -if [ "$command" != "online" ] && - [ "$command" != "offline" ] && - [ "$command" != "add" ] && - [ "$command" != "remove" ] -then - log err "Invalid command: $command" - exit 1 -fi - - -XENBUS_PATH="${XENBUS_PATH:?}" - -. "$dir/vtpm-common.sh" diff --git a/tools/hotplug/Linux/vtpm-impl b/tools/hotplug/Linux/vtpm-impl deleted file mode 100644 index 4f9a1fd..0000000 --- a/tools/hotplug/Linux/vtpm-impl +++ /dev/null @@ -1,208 +0,0 @@ -#!/bin/bash -# =================================================================== -# -# 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. -# =================================================================== - -# | SRC | TAG | CMD SIZE | ORD |mtype|strt -TPM_CMD_OPEN=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x01 -TPM_CMD_RESM=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x02 -TPM_CMD_CLOS=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x02 -TPM_CMD_DELE=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x03 - -TPM_TYPE_PVM=\\x01 -TPM_TYPE_HVM=\\x02 - -TPM_SUCCESS=00000000 - -TX_VTPM_MANAGER=/var/vtpm/fifos/from_console.fifo -RX_VTPM_MANAGER=/var/vtpm/fifos/to_console.fifo - -VTPM_MIG=/usr/bin/vtpm_migrator - -# -------------------- Helpers for binary streams ----------- - -function str_to_hex32() { - printf "%0.8x" $1 -} - -function hex32_to_bin() { - local inst=$(str_to_hex32 $1); - - local n1=`echo $inst | sed 's/\(..\)....../\\\\x\1/'` - local n2=`echo $inst | sed 's/..\(..\)..../\\\\x\1/'` - local n3=`echo $inst | sed 's/....\(..\)../\\\\x\1/'` - local n4=`echo $inst | sed 's/......\(..\)/\\\\x\1/'` - - echo "$n1$n2$n3$n4" -} - -function vtpm_manager_cmd() { - local cmd=$1; - local inst=$2; - local inst_bin=$(hex32_to_bin $inst); - - claim_lock vtpm_mgr - - #send cmd to vtpm_manager - printf "$cmd$inst_bin" > $TX_VTPM_MANAGER - - #recv response - set +e - local resp_hex=`dd skip=10 bs=1 count=4 if=$RX_VTPM_MANAGER 2> /dev/null | xxd -ps` - set -e - - release_lock vtpm_mgr - - #return whether the command was successful - if [ $resp_hex -ne $TPM_SUCCESS ]; then - vtpm_fatal_error=1 - false - else - true - fi -} - -# Helper to get vm type to pass to vtpm_manager open/resume -function vtpm_get_type() { - local inst=$(xenstore_read $XENBUS_PATH/frontend-id) - local vm=$(xenstore_read /local/domain/$inst/vm) - if [ "$vm" != "" ]; then - local ostype=$(xenstore-read $vm/image/ostype) - if [ "$ostype" == "hvm" ]; then - echo $TPM_TYPE_HVM; - else - echo $TPM_TYPE_PVM; - fi - fi -} - -# ------------------ Command handlers ----------------- - -# Create new vtpm instance & set it up for use -function vtpm_create () { - # Creation is handled implicitly by the manager on first setup - # so just set it up for use - $(vtpm_start $1) -} - -# Setup vtpm instance for use. -function vtpm_start() { - local vmtype=$(vtpm_get_type); - $(vtpm_manager_cmd $TPM_CMD_OPEN$vmtype $1) -} - -function vtpm_resume() { - local vmtype=$(vtpm_get_type); - $(vtpm_manager_cmd $TPM_CMD_RESM$vmtype $1) -} - -# Reset the vtpm AKA clear PCRs -function vtpm_reset() { - #not used by current implemenation - true -} - -# Shutdown the vtpm while the vm is down -# This could be a suspend of shutdown -# we cannot distinquish, so save the state -# and decide on startup if we should keep is -function vtpm_suspend() { - $(vtpm_manager_cmd $TPM_CMD_CLOS $1) -} - - -function vtpm_delete() { - local inst=$1 - if $(vtpm_manager_cmd $TPM_CMD_DELE $inst); then - rm -f /var/vtpm/vtpm_dm_$1.data - true - else - vtpm_fatal_error=1 - false - fi -} - -# Perform a migration step. This function differentiates between migration -# to the local host or to a remote machine. -# Parameters: -# 1st: destination host to migrate to -# 2nd: name of the domain to migrate -# 3rd: the migration step to perform -function vtpm_migrate() { - local instance res - - instance=$(vtpmdb_find_instance $2) - if [ "$instance" == "" ]; then - log err "VTPM Migratoin failed. Unable to translation of domain name" - echo "Error: VTPM Migration failed while looking up instance number" - fi - - case "$3" in - 0) - #Incicate migration supported - echo "0" - ;; - - 1) - # Get Public Key from Destination - # Call vtpm_manager's migration part 1 - claim_lock vtpm_mgr - $VTPM_MIG $1 $2 $instance $3 - release_lock vtpm_mgr - ;; - - 2) - # Call manager's migration step 2 and send result to destination - # If successful remove from db - claim_lock vtpm_mgr - $VTPM_MIG $1 $2 $instance $3 - release_lock vtpm_mgr - ;; - - 3) - if `ps x | grep "$VTPM_MIG $1"`; then - log err "VTPM Migration failed to complete." - echo "Error: VTPM Migration failed to complete." - fi - ;; - esac - -} - - -function vtpm_migrate_recover() { - echo "Error: Recovery not supported yet" -} - -function vtpm_migrate_local() { - echo "Error: local vTPM migration not supported" -} diff --git a/tools/hotplug/Linux/vtpm-migration.sh b/tools/hotplug/Linux/vtpm-migration.sh deleted file mode 100644 index 7e38ae2..0000000 --- a/tools/hotplug/Linux/vtpm-migration.sh +++ /dev/null @@ -1,19 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/vtpm-common.sh" diff --git a/tools/hotplug/Linux/xen-backend.rules b/tools/hotplug/Linux/xen-backend.rules index c591a3f..a0d409e 100644 --- a/tools/hotplug/Linux/xen-backend.rules +++ b/tools/hotplug/Linux/xen-backend.rules @@ -1,6 +1,5 @@ SUBSYSTEM=="xen-backend", KERNEL=="tap*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/blktap $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vbd*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/block $env{ACTION}" -SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vif2-*", RUN+="/etc/xen/scripts/vif2 $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="online", RUN+="/etc/xen/scripts/vif-setup online type_if=vif" SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="offline", RUN+="/etc/xen/scripts/vif-setup offline type_if=vif" diff --git a/tools/vtpm/Makefile b/tools/vtpm/Makefile deleted file mode 100644 index 7b3efa5..0000000 --- a/tools/vtpm/Makefile +++ /dev/null @@ -1,74 +0,0 @@ -XEN_ROOT = $(CURDIR)/../.. - -# Base definitions and rules -include $(XEN_ROOT)/tools/vtpm/Rules.mk - -# Dir name for emulator (as dom0 tpm driver) -TPM_EMULATOR_DIR = tpm_emulator -# Dir name for vtpm instance -VTPM_DIR = vtpm -ORIG_DIR = orig - -# Emulator tarball name -TPM_EMULATOR_NAME = tpm_emulator-0.5.1 -TPM_EMULATOR_TARFILE = $(TPM_EMULATOR_NAME).tar.gz - -GMP_HEADER = /usr/include/gmp.h - -.PHONY: all -all: build - -.PHONY: build -build: build_sub - -.PHONY: install -install: build - $(MAKE) -C $(VTPM_DIR) install-recursive - -.PHONY: clean -clean: - @if [ -d $(TPM_EMULATOR_DIR) ]; \ - then $(MAKE) -C $(TPM_EMULATOR_DIR) clean; \ - fi - @if [ -d $(VTPM_DIR) ]; \ - then $(MAKE) -C $(VTPM_DIR) clean; \ - fi - -.PHONY: mrproper -mrproper: - rm -f $(TPM_EMULATOR_TARFILE) tpm_emulator.patch.old vtpm.patch.old - rm -rf $(TPM_EMULATOR_DIR) $(VTPM_DIR) $(ORIG_DIR) - -# Download Swiss emulator -$(TPM_EMULATOR_TARFILE): - wget http://download.berlios.de/tpm-emulator/$(TPM_EMULATOR_TARFILE) - -# Create vtpm dirs -$(VTPM_DIR)/tpmd/tpmd: $(TPM_EMULATOR_TARFILE) vtpm-0.5.1.patch - rm -rf $(VTPM_DIR) - tar -xzf $(TPM_EMULATOR_TARFILE) - mv $(TPM_EMULATOR_NAME) $(VTPM_DIR) - - set -e; cd $(VTPM_DIR); \ - patch -p1 < ../vtpm-0.5.1.patch; \ - patch -p1 < ../vtpm-0.5.1-LDLIBS.patch - -orig: $(TPM_EMULATOR_TARFILE) - mkdir $(ORIG_DIR); - set -e; cd $(ORIG_DIR); \ - tar -xzf ../$(TPM_EMULATOR_TARFILE); - -updatepatches: clean orig - find $(VTPM_DIR) -name "*.orig" -print | xargs rm -f; - mv vtpm.patch vtpm.patch.old; - diff -uprN $(TPM_EMULATOR_DIR) $(VTPM_DIR) > vtpm.patch || true; - -.PHONY: build_sub -build_sub: $(VTPM_DIR)/tpmd/tpmd - set -e; if [ -e $(GMP_HEADER) ]; then \ - $(MAKE) -C $(VTPM_DIR) version; \ - $(MAKE) -C $(VTPM_DIR) all-recursive; \ - else \ - echo "=== Unable to build VTPMs. libgmp could not be found."; \ - fi - diff --git a/tools/vtpm/README b/tools/vtpm/README deleted file mode 100644 index 2008cbd..0000000 --- a/tools/vtpm/README +++ /dev/null @@ -1,45 +0,0 @@ - -Directory Structure -=================== -tools/vtpm/tpm_emulator-0.2b.tar.gz -> TPM Emulator downloaded at build time that will - be patched and used for our vtpms -tools/vtpm/vtpm.patch -> patch applied to tpm_emulator to make vtpm -tools/vtpm/vtpm/ -> (created on build) tpm_emulator moved to ring 3, - listens on a pair of fifos for TPM commands, - persistent state is sent via named fifo to vtpm - manager, which encrypts it and protects it. -tools/vtpm/tpm_emulator.patch -> To allow for debugging and testing on non-TPM - platforms, this patches the emulator to allow - it to be inserted into the dom0 kernel -tools/vtpm/tpm_emulator-0.2 -> (created on build) directory containing patched emulator - -Compile Flags -=================== -VTPM_MULTI_VM -> Defined (not finished): VTPMs run in their own VMs - Not Defined (default): VTPMs are processes - -Requirements -============ -- xen-unstable -- IBM frontend/backend vtpm driver patch -- vtpm_managerd -- GNU MP Big number library (GMP) - -vtpmd Flow (for vtpm_manager. vtpmd never run by default) -============================ -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. -- VTPM Manager listens to TPM BE. -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. -- When the manager receives the open message from the BE, it launches a vtpm -- Xend allows the VM to continue booting. -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. -- The fifo listener begins listening for the reply from vtpm for the request. -- Vtpm processes request and replies to manager over shared named fifo. -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. - -tpm_emulator flow -================== -Read documentation in tpm_emulator-0.2 directory diff --git a/tools/vtpm/Rules.mk b/tools/vtpm/Rules.mk deleted file mode 100644 index 548cff0..0000000 --- a/tools/vtpm/Rules.mk +++ /dev/null @@ -1,26 +0,0 @@ -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) -include $(XEN_ROOT)/tools/Rules.mk - -# -# Tool definitions -# - -# General compiler flags -CFLAGS = -Werror -g3 - -# Generic project files -HDRS = $(wildcard *.h) -SRCS = $(wildcard *.c) -OBJS = $(patsubst %.c,%.o,$(SRCS)) - -# Generic (non-header) dependencies -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm/Rules.mk - -$(OBJS): $(SRCS) - --include $(DEPS) - -BUILD_EMULATOR = y - -# Make sure these are just rules -.PHONY : all build install clean diff --git a/tools/vtpm/tpm_emulator.patch b/tools/vtpm/tpm_emulator.patch deleted file mode 100644 index c34c665..0000000 --- a/tools/vtpm/tpm_emulator.patch +++ /dev/null @@ -1,1919 +0,0 @@ -diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS ---- orig/tpm_emulator-0.4/AUTHORS 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/AUTHORS 2006-07-24 14:35:35.000000000 -0700 -@@ -1,2 +1,3 @@ - Mario Strasser - Heiko Stamer [DAA] -+INTEL Corp <> [Dropped to Ring3] -diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog ---- orig/tpm_emulator-0.4/ChangeLog 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/ChangeLog 2006-07-24 14:35:35.000000000 -0700 -@@ -1,3 +1,6 @@ -+????-??-?? Intel Corp -+ * Moved module out of kernel to run as a ring 3 app -+ - 2006-06-23 Mario Strasser - * tpm_startup.c: behaviour of ST_CLEAR and storage of - persistent data adapted -diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c ---- orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/crypto/gmp_kernel_wrapper.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -24,15 +25,10 @@ int __gmp_junk; - void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename, - int linenum, const char *expr) - { -- panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n", -+ error("%s:%d: GNU MP assertion failed: %s\n", - filename, linenum, expr); - } - --void __attribute__ ((regparm(0))) abort(void) --{ -- panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n"); --} -- - /* overwrite GNU MP random functions (used by mpz/millerrabin.c) */ - - void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate, -@@ -77,20 +73,19 @@ void __attribute__ ((regparm(0))) mpz_ur - - void __attribute__ ((regparm(0))) *kernel_allocate(size_t size) - { -- void *ret = (void*)kmalloc(size, GFP_KERNEL); -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME -- "GMP: cannot allocate memory (size=%u)\n", size); -+ void *ret = (void*)malloc(size); -+ if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size); - return ret; - } - - void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr, - size_t old_size, size_t new_size) - { -- void *ret = (void*)kmalloc(new_size, GFP_KERNEL); -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory " -- "(old_size=%u new_size=%u)\n", old_size, new_size); -+ void *ret = (void*)malloc(new_size); -+ if (!ret) error("GMP: Cannot reallocate memory " -+ "(old_size=%Zu new_size=%Zu)\n", old_size, new_size); - memcpy(ret, oldptr, old_size); -- kfree(oldptr); -+ free(oldptr); - return ret; - } - -@@ -99,7 +94,7 @@ void __attribute__ ((regparm(0))) kernel - /* overwrite used memory */ - if (blk_ptr != NULL) { - memset(blk_ptr, 0, blk_size); -- kfree(blk_ptr); -+ free(blk_ptr); - } - } - -diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c ---- orig/tpm_emulator-0.4/crypto/rsa.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/crypto/rsa.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -381,7 +382,7 @@ static int encode_message(int type, uint - msg[0] = 0x00; - get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH); - sha1_init(&ctx); -- sha1_update(&ctx, "TCPA", 4); -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); - sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]); - memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00, - msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2); -@@ -429,7 +430,7 @@ static int decode_message(int type, uint - mask_generation(&msg[1], SHA1_DIGEST_LENGTH, - &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1); - sha1_init(&ctx); -- sha1_update(&ctx, "TCPA", 4); -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); - sha1_final(&ctx, &msg[1]); - if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH], - SHA1_DIGEST_LENGTH) != 0) return -1; -diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c ---- orig/tpm_emulator-0.4/linux_module.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/linux_module.c 1969-12-31 16:00:00.000000000 -0800 -@@ -1,195 +0,0 @@ --/* Software-Based Trusted Platform Module (TPM) Emulator for Linux -- * Copyright (C) 2004 Mario Strasser , -- * -- * This module is free software; you can redistribute it and/or modify -- * it under the terms of the GNU General Public License as published -- * by the Free Software Foundation; either version 2 of the License, -- * or (at your option) any later version. -- * -- * This module is distributed in the hope that it will be useful, -- * but WITHOUT ANY WARRANTY; without even the implied warranty of -- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -- * GNU General Public License for more details. -- * -- * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $ -- */ -- --#include --#include --#include --#include --#include --#include "linux_module.h" --#include "tpm/tpm_emulator.h" -- --MODULE_LICENSE("GPL"); --MODULE_AUTHOR("Mario Strasser "); --MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator"); --MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME); -- --/* module startup parameters */ --char *startup = "save"; --module_param(startup, charp, 0444); --MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. " -- "Possible values are 'clear', 'save' (default) and 'deactivated."); --char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2"; --module_param(storage_file, charp, 0644); --MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage " -- "file of the TPM."); -- --/* TPM lock */ --static struct semaphore tpm_mutex; -- --/* TPM command response */ --static struct { -- uint8_t *data; -- uint32_t size; --} tpm_response; -- --/* module state */ --#define STATE_IS_OPEN 0 --static uint32_t module_state; --static struct timespec old_time; -- --static int tpm_open(struct inode *inode, struct file *file) --{ -- debug("%s()", __FUNCTION__); -- if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY; -- return 0; --} -- --static int tpm_release(struct inode *inode, struct file *file) --{ -- debug("%s()", __FUNCTION__); -- clear_bit(STATE_IS_OPEN, (void*)&module_state); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) { -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return 0; --} -- --static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos) --{ -- debug("%s(%d)", __FUNCTION__, count); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) { -- count = min(count, (size_t)tpm_response.size - (size_t)*ppos); -- count -= copy_to_user(buf, &tpm_response.data[*ppos], count); -- *ppos += count; -- if ((size_t)tpm_response.size == (size_t)*ppos) { -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } -- } else { -- count = 0; -- } -- up(&tpm_mutex); -- return count; --} -- --static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos) --{ -- debug("%s(%d)", __FUNCTION__, count); -- down(&tpm_mutex); -- *ppos = 0; -- if (tpm_response.data != NULL) kfree(tpm_response.data); -- if (tpm_handle_command(buf, count, &tpm_response.data, -- &tpm_response.size) != 0) { -- count = -EILSEQ; -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return count; --} -- --#define TPMIOC_CANCEL _IO('T', 0x00) --#define TPMIOC_TRANSMIT _IO('T', 0x01) -- --static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) --{ -- debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg); -- if (cmd == TPMIOC_TRANSMIT) { -- uint32_t count = ntohl(*(uint32_t*)(arg + 2)); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) kfree(tpm_response.data); -- if (tpm_handle_command((char*)arg, count, &tpm_response.data, -- &tpm_response.size) == 0) { -- tpm_response.size -= copy_to_user((char*)arg, tpm_response.data, -- tpm_response.size); -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } else { -- tpm_response.size = 0; -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return tpm_response.size; -- } -- return -1; --} -- --struct file_operations fops = { -- .owner = THIS_MODULE, -- .open = tpm_open, -- .release = tpm_release, -- .read = tpm_read, -- .write = tpm_write, -- .ioctl = tpm_ioctl, --}; -- --static struct miscdevice tpm_dev = { -- .minor = TPM_DEVICE_MINOR, -- .name = TPM_DEVICE_NAME, -- .fops = &fops, --}; -- --int __init init_tpm_module(void) --{ -- int res = misc_register(&tpm_dev); -- if (res != 0) { -- error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR); -- return res; -- } -- /* initialize variables */ -- sema_init(&tpm_mutex, 1); -- module_state = 0; -- tpm_response.data = NULL; -- old_time = current_kernel_time(); -- /* initialize TPM emulator */ -- if (!strcmp(startup, "clear")) { -- tpm_emulator_init(1); -- } else if (!strcmp(startup, "save")) { -- tpm_emulator_init(2); -- } else if (!strcmp(startup, "deactivated")) { -- tpm_emulator_init(3); -- } else { -- error("invalid startup mode '%s'; must be 'clear', " -- "'save' (default) or 'deactivated", startup); -- misc_deregister(&tpm_dev); -- return -EINVAL; -- } -- return 0; --} -- --void __exit cleanup_tpm_module(void) --{ -- tpm_emulator_shutdown(); -- misc_deregister(&tpm_dev); -- if (tpm_response.data != NULL) kfree(tpm_response.data); --} -- --module_init(init_tpm_module); --module_exit(cleanup_tpm_module); -- --uint64_t tpm_get_ticks(void) --{ -- struct timespec new_time = current_kernel_time(); -- uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000 -- + (new_time.tv_nsec - old_time.tv_nsec) / 1000; -- old_time = new_time; -- return (ticks > 0) ? ticks : 1; --} -- -diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h ---- orig/tpm_emulator-0.4/linux_module.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/linux_module.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -17,54 +18,62 @@ - #ifndef _LINUX_MODULE_H_ - #define _LINUX_MODULE_H_ - --#include --#include --#include -+#include -+#include -+#include -+#include - #include --#include --#include --#include --#include - --/* module settings */ -+#include -+#define __BYTEORDER_HAS_U64__ -+#ifdef LITTLE_ENDIAN -+ #include -+#else -+ #include -+#endif - -+/* module settings */ -+#define min(A,B) ((A)<(B)?(A):(B)) -+#ifndef STR - #define STR(s) __STR__(s) - #define __STR__(s) #s -+#endif - #include "tpm_version.h" - - #define TPM_DEVICE_MINOR 224 - #define TPM_DEVICE_NAME "tpm" - #define TPM_MODULE_NAME "tpm_emulator" - --/* debug and log output functions */ -- - #ifdef DEBUG --#define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) - #else - #define debug(fmt, ...) - #endif --#define info(fmt, ...) printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) - - /* memory allocation */ - - static inline void *tpm_malloc(size_t size) - { -- return kmalloc(size, GFP_KERNEL); -+ return malloc(size); - } - - static inline void tpm_free(const void *ptr) - { -- if (ptr != NULL) kfree(ptr); -+ if (ptr != NULL) free( (void *) ptr); - } - - /* random numbers */ - -+//FIXME; -+void get_random_bytes(void *buf, int nbytes); -+ - static inline void tpm_get_random_bytes(void *buf, int nbytes) - { - get_random_bytes(buf, nbytes); -@@ -84,9 +93,9 @@ uint64_t tpm_get_ticks(void); - #define CPU_TO_LE16(x) __cpu_to_le16(x) - - #define BE64_TO_CPU(x) __be64_to_cpu(x) --#define LE64_TO_CPU(x) __be64_to_cpu(x) -+#define LE64_TO_CPU(x) __le64_to_cpu(x) - #define BE32_TO_CPU(x) __be32_to_cpu(x) --#define LE32_TO_CPU(x) __be32_to_cpu(x) -+#define LE32_TO_CPU(x) __le32_to_cpu(x) - #define BE16_TO_CPU(x) __be16_to_cpu(x) - #define LE16_TO_CPU(x) __le16_to_cpu(x) - -diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile ---- orig/tpm_emulator-0.4/Makefile 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/Makefile 2006-07-24 14:35:35.000000000 -0700 -@@ -1,24 +1,40 @@ - # Software-Based Trusted Platform Module (TPM) Emulator for Linux - # Copyright (C) 2004 Mario Strasser -+# Copyright (C) 2006 INTEL Corp. - # - # $Id: Makefile 115 2006-06-23 10:36:44Z mast $ - --# kernel settings --KERNEL_RELEASE := $(shell uname -r) --KERNEL_BUILD := /lib/modules/$(KERNEL_RELEASE)/build --MOD_SUBDIR := misc -+COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) - - # module settings --MODULE_NAME := tpm_emulator -+BIN := tpm_emulator - VERSION_MAJOR := 0 - VERSION_MINOR := 4 - VERSION_BUILD := $(shell date +"%s") - --# enable/disable DEBUG messages --EXTRA_CFLAGS += -Wall -DDEBUG -g -+# Installation program and options -+INSTALL = install -+INSTALL_PROG = $(INSTALL) -m0755 -+INSTALL_DIR = $(INSTALL) -d -m0755 -+ -+# Xen tools installation directory -+TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin -+ -+CC := gcc -+CFLAGS += -g -Wall $(INCLUDE) -DDEBUG -+CFLAGS += -I. -Itpm -+ -+# Is the simulator running in it's own vm? -+#CFLAGS += -DVTPM_MULTI_VM -+ -+ifeq ($(COMPILE_ARCH),x86_64) -+LIBDIR = lib64 -+else -+LIBDIR = lib -+endif - - # GNU MP configuration --GMP_LIB := /usr/lib/libgmp.a -+GMP_LIB := /usr/$(LIBDIR)/libgmp.a - GMP_HEADER := /usr/include/gmp.h - - # sources and objects -@@ -27,38 +43,32 @@ DIRS := . crypto tpm - SRCS := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c)) - OBJS := $(patsubst %.c, %.o, $(SRCS)) - SRCS += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h)) --DISTSRC := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS) --DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR) - --obj-m := $(MODULE_NAME).o --$(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a -+obj-m := $(BIN) -+$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a - - EXTRA_CFLAGS += -I$(src) -I$(src)/crypto -I$(src)/tpm - - # do not print "Entering directory ..." - MAKEFLAGS += --no-print-directory - --all: $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules -+all: $(BIN) - --install: -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install -- test -d /var/tpm || mkdir /var/tpm -- test -c /dev/tpm || mknod /dev/tpm c 10 224 -- chmod 666 /dev/tpm -- depmod -a -+$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS) -+ $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN) -+ -+%.o: %.c -+ $(CC) $(CFLAGS) -c $< -o $@ -+ -+install: $(BIN) -+ $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) -+ @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi - - clean: -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean -- rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a -+ rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) - --dist: $(DISTSRC) -- rm -rf $(DISTDIR) -- mkdir $(DISTDIR) -- cp --parents $(DISTSRC) $(DISTDIR)/ -- rm -f $(DISTDIR)/crypto/gmp.h -- tar -chzf $(DISTDIR).tar.gz $(DISTDIR) -- rm -rf $(DISTDIR) -+mrproper: clean -+ rm -f $(BIN) tpm_version.h - - $(src)/crypto/libgmp.a: - test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a -@@ -88,4 +98,3 @@ version: - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h - - .PHONY: all install clean dist gmp version -- -diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README ---- orig/tpm_emulator-0.4/README 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/README 2006-07-24 14:35:35.000000000 -0700 -@@ -13,7 +13,8 @@ $Id: README 113 2006-06-18 12:38:13Z hst - Copyright - -------------------------------------------------------------------------- - Copyright (C) 2004 Mario Strasser and Swiss Federal --Institute of Technology (ETH) Zurich. -+ Institute of Technology (ETH) Zurich. -+Copyright (C) 2005 INTEL Corp - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by -@@ -43,6 +44,12 @@ Example: - GMP_LIB := /usr/lib/libgmp.a - GMP_HEADER := /usr/include/gmp.h - -+GNU MP Library on 64 bit Systems -+-------------------------------------------------------------------------- -+Some 64-bit kernels have problems with importing the user-space gmp -+library (/usr/lib*/libgmp.a) into kernel space. These kernels will require -+that the gmp library be recompiled for kernel space with -mcmodel=kernel. -+ - Installation - -------------------------------------------------------------------------- - The compilation and installation process uses the build environment for -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_capability.c tpm_emulator/tpm/tpm_capability.c ---- orig/tpm_emulator-0.4/tpm/tpm_capability.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_capability.c 2007-12-28 22:50:19.000000000 +0900 -@@ -701,7 +701,10 @@ TPM_RESULT TPM_GetCapabilityOwner(TPM_VE - TPM_RESULT res; - - info("TPM_GetCapabilityOwner()"); -- -+ -+ if (!tpmData.permanent.flags.owned) { -+ return TPM_NOSRK; -+ } - /* Verify owner authorization */ - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); - if (res != TPM_SUCCESS) return res; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c tpm_emulator/tpm/tpm_cmd_handler.c ---- orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_cmd_handler.c 2007-09-12 20:23:00.000000000 +0900 -@@ -565,7 +565,7 @@ static TPM_RESULT execute_TPM_Seal(TPM_R - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) -+ || (pcrInfoSize >0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) - || len != 0) return TPM_BAD_PARAMETER; -@@ -798,7 +798,7 @@ static TPM_RESULT execute_TPM_Sealx(TPM_ - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) -+ || (pcrInfoSize > 0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) - || len != 0) return TPM_BAD_PARAMETER; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c ---- orig/tpm_emulator-0.4/tpm/tpm_credentials.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_credentials.c 2007-09-12 20:23:30.000000000 +0900 -@@ -47,20 +47,20 @@ int tpm_compute_pubkey_checksum(TPM_NONC - - TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey) - { -- UINT32 key_length; -+ size_t key_length; - if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT; - /* setup TPM_PUBKEY structure */ -- key_length = tpmData.permanent.data.endorsementKey.size; -- pubEndorsementKey->pubKey.keyLength = key_length >> 3; -+ pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3; - pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength); - if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL; - rsa_export_modulus(&tpmData.permanent.data.endorsementKey, -- pubEndorsementKey->pubKey.key, -- &pubEndorsementKey->pubKey.keyLength); -+ pubEndorsementKey->pubKey.key, -+ &key_length); -+ pubEndorsementKey->pubKey.keyLength = key_length; - pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA; - pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE; -- pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length; -+ pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length << 3; - pubEndorsementKey->algorithmParms.parms.rsa.numPrimes = 2; - pubEndorsementKey->algorithmParms.parms.rsa.exponentSize = 0; - pubEndorsementKey->algorithmParms.parms.rsa.exponent = NULL; -@@ -175,6 +175,7 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ - { - TPM_RESULT res; - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; -+ size_t key_length; - info("TPM_OwnerReadInternalPub()"); - /* verify authorization */ - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); -@@ -186,7 +187,8 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ - publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength); - if (publicPortion->pubKey.key == NULL) return TPM_FAIL; - rsa_export_modulus(&srk->key, publicPortion->pubKey.key, -- &publicPortion->pubKey.keyLength); -+ &key_length); -+ publicPortion->pubKey.keyLength = key_length; - publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA; - publicPortion->algorithmParms.encScheme = srk->encScheme; - publicPortion->algorithmParms.sigScheme = srk->sigScheme; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c ---- orig/tpm_emulator-0.4/tpm/tpm_crypto.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_crypto.c 2006-07-24 14:35:35.000000000 -0700 -@@ -182,7 +182,8 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE - TPM_KEY_DATA *cert, *key; - sha1_ctx_t sha1_ctx; - BYTE *buf, *p; -- UINT32 length; -+ UINT32 length32; -+ size_t length; - info("TPM_CertifyKey()"); - /* get keys */ - cert = tpm_get_key(certHandle); -@@ -264,14 +265,15 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - p = buf = tpm_malloc(length); -+ length32=(UINT32) length; - if (buf == NULL -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); - return TPM_FAIL; - } - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - sha1_init(&sha1_ctx); -- sha1_update(&sha1_ctx, buf, length); -+ sha1_update(&sha1_ctx, buf, (size_t) length); - sha1_final(&sha1_ctx, buf); - res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize); - tpm_free(buf); -@@ -292,7 +294,8 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL - TPM_KEY_DATA *cert, *key; - sha1_ctx_t sha1_ctx; - BYTE *buf, *p; -- UINT32 length; -+ size_t length; -+ UINT32 length32; - info("TPM_CertifyKey2()"); - /* get keys */ - cert = tpm_get_key(certHandle); -@@ -362,8 +365,9 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - p = buf = tpm_malloc(length); -+ length32 = (UINT32) length; - if (buf == NULL -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); - return TPM_FAIL; - } -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c ---- orig/tpm_emulator-0.4/tpm/tpm_daa.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_daa.c 2006-07-24 14:35:35.000000000 -0700 -@@ -716,14 +716,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -805,14 +805,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1489,14 +1489,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1712,14 +1712,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1793,14 +1793,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -2918,14 +2918,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -3143,7 +3143,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, - sizeof(session->DAA_session.DAA_digest)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_update(&sha1, inputData1, inputSize1); - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); - } -@@ -3172,7 +3172,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, - sizeof(session->DAA_session.DAA_digest)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE*) "\x00", 1); - rsa_export_modulus(&aikData->key, scratch, &size); - sha1_update(&sha1, scratch, size); - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); -@@ -3229,14 +3229,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -3309,14 +3309,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c ---- orig/tpm_emulator-0.4/tpm/tpm_data.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_data.c 2006-07-24 14:35:35.000000000 -0700 -@@ -40,6 +40,7 @@ static inline void init_pcr_attr(int pcr - void tpm_init_data(void) - { - /* endorsement key */ -+#ifndef TPM_GENERATE_EK - uint8_t ek_n[] = "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7" - "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93" - "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a" -@@ -77,6 +78,8 @@ void tpm_init_data(void) - "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b" - "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47" - "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f"; -+#endif -+ - int i; - /* reset all data to NULL, FALSE or 0 */ - memset(&tpmData, 0, sizeof(tpmData)); -@@ -152,44 +155,43 @@ void tpm_release_data(void) - - #ifdef TPM_STORE_TO_FILE - --#include --#include --#include -+#include -+#include -+#include -+#include - - #define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) - - static int write_to_file(uint8_t *data, size_t data_length) - { - int res; -- struct file *fp; -- mm_segment_t old_fs = get_fs(); -- fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- if (IS_ERR(fp)) return -1; -- set_fs(get_ds()); -- res = fp->f_op->write(fp, data, data_length, &fp->f_pos); -- set_fs(old_fs); -- filp_close(fp, NULL); -+ int fp; -+ fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -+ res = write(fp, data, data_length); -+ close(fp); - return (res == data_length) ? 0 : -1; - } - - static int read_from_file(uint8_t **data, size_t *data_length) - { - int res; -- struct file *fp; -- mm_segment_t old_fs = get_fs(); -- fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0); -- if (IS_ERR(fp)) return -1; -- *data_length = (size_t)fp->f_dentry->d_inode->i_size; -- /* *data_length = i_size_read(fp->f_dentry->d_inode); */ -+ int fp, file_status; -+ struct stat file_info; -+ fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); -+ file_status = fstat(fp, &file_info); -+ if (file_status < 0) { -+ close(fp); -+ return -1; -+ } -+ -+ *data_length = file_info.st_size; - *data = tpm_malloc(*data_length); - if (*data == NULL) { -- filp_close(fp, NULL); -+ close(fp); - return -1; - } -- set_fs(get_ds()); -- res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos); -- set_fs(old_fs); -- filp_close(fp, NULL); -+ res = read(fp, *data, *data_length); -+ close(fp); - if (res != *data_length) { - tpm_free(*data); - return -1; -@@ -216,23 +218,30 @@ static int read_from_file(uint8_t **data - int tpm_store_permanent_data(void) - { - uint8_t *buf, *ptr; -- size_t buf_length, len; -+ UINT32 buf_length, len; - - /* marshal data */ -- buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) -- + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2 -- + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data); -+ buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) -+ + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) -+ + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2 -+ + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data) -+ + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data) -+ + sizeof_TPM_STANY_DATA(tpmData.stany.data); - buf = ptr = tpm_malloc(buf_length); - if (buf == NULL - || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version) - || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) - || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) -+ || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded) - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned) -- || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { -+ || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) -+ || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) -+ || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { - tpm_free(buf); - return -1; - } -+ - if (write_to_file(buf, buf_length - len)) { - tpm_free(buf); - return -1; -@@ -244,31 +253,36 @@ int tpm_store_permanent_data(void) - int tpm_restore_permanent_data(void) - { - uint8_t *buf, *ptr; -- size_t buf_length, len; -+ size_t buf_length; -+ UINT32 len; - TPM_VERSION ver; - - /* read data */ - if (read_from_file(&buf, &buf_length)) return -1; - ptr = buf; -- len = buf_length; -+ len = (uint32_t) buf_length; - /* unmarshal data */ - if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver) - || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION)) - || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) - || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) -+ || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded) - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned) -- || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { -+ || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) -+ || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) -+ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { - tpm_free(buf); - return -1; - } -+ - tpm_free(buf); - return 0; - } - - int tpm_erase_permanent_data(void) - { -- int res = write_to_file("", 0); -+ int res = write_to_file((uint8_t *) "", 0); - return res; - } - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c ---- orig/tpm_emulator-0.4/tpm/tpm_deprecated.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_deprecated.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -50,7 +51,7 @@ TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA - BYTE *ptr; - UINT32 len; - info("TPM_SaveKeyContext()"); -- res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..", -+ res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..", - keyContextSize, &contextBlob); - if (res != TPM_SUCCESS) return res; - len = *keyContextSize; -@@ -82,7 +83,7 @@ TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH - BYTE *ptr; - UINT32 len; - info("TPM_SaveAuthContext()"); -- res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.", -+ res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.", - authContextSize, &contextBlob); - if (res != TPM_SUCCESS) return res; - len = *authContextSize; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h ---- orig/tpm_emulator-0.4/tpm/tpm_emulator.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_emulator.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -22,7 +23,8 @@ - /* TPM configuration */ - #define TPM_STORE_TO_FILE 1 - #undef TPM_STRONG_PERSISTENCE --#undef TPM_GENERATE_EK -+//#undef TPM_GENERATE_EK -+#define TPM_GENERATE_EK - #undef TPM_GENERATE_SEED_DAA - - #define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */ -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_marshalling.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1312,7 +1312,7 @@ int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * - - int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v) - { -- UINT32 m_len, e_len, q_len; -+ size_t m_len, e_len, q_len; - if (*length < sizeof_RSA((*v))) return -1; - if (v->size > 0) { - rsa_export_modulus(v, &(*ptr)[6], &m_len); -@@ -1460,6 +1460,66 @@ int tpm_unmarshal_TPM_PERMANENT_DATA(BYT - return 0; - } - -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) -+{ -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) -+ || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1; -+ -+ return 0; -+} -+ -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) -+{ -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) -+ || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1; -+ -+ return 0; -+} -+ -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) -+{ -+ UINT32 i; -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) -+ || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) -+ || tpm_marshal_BOOL(ptr, length, v->auditSession) -+ || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) -+ || tpm_marshal_UINT32(ptr, length, v->contextCount) -+ || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { -+ if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; -+ } -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { -+ if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; -+ } -+ if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; -+ -+ return 0; -+} -+ -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) -+{ -+ UINT32 i; -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) -+ || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) -+ || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) -+ || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) -+ || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) -+ || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { -+ if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; -+ } -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { -+ if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; -+ } -+ if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; -+ -+ return 0; -+} -+ - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) - { - if (tpm_marshal_BYTE(ptr, length, v->type) -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_marshalling.h 2006-07-24 14:35:35.000000000 -0700 -@@ -432,6 +432,12 @@ int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt - int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); - int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); - -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); -+ -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); -+ - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); - int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c ---- orig/tpm_emulator-0.4/tpm/tpm_owner.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_owner.c 2006-07-24 14:35:35.000000000 -0700 -@@ -108,7 +108,7 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO - TPM_RESULT res; - rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey; - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; -- UINT32 buf_size = ek->size >> 3; -+ size_t buf_size = ek->size >> 3, key_length; - BYTE buf[buf_size]; - - info("TPM_TakeOwnership()"); -@@ -173,7 +173,8 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO - return TPM_FAIL; - } - rsa_export_modulus(&srk->key, srkPub->pubKey.key, -- &srkPub->pubKey.keyLength); -+ &key_length); -+ srkPub->pubKey.keyLength = (UINT32) key_length; - /* setup tpmProof and set state to owned */ - tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce, - sizeof(tpmData.permanent.data.tpmProof.nonce)); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c ---- orig/tpm_emulator-0.4/tpm/tpm_startup.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_startup.c 2006-07-24 14:35:35.000000000 -0700 -@@ -41,26 +41,29 @@ void TPM_Init(TPM_STARTUP_TYPE startupTy - TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType) - { - int i; -+ int restore_fail; - info("TPM_Startup(%d)", startupType); - if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT; -- /* reset STANY_FLAGS */ -- SET_TO_ZERO(&tpmData.stany.flags); -- tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; -- /* reset STANY_DATA (invalidates ALL sessions) */ -- SET_TO_ZERO(&tpmData.stany.data); -- tpmData.stany.data.tag = TPM_TAG_STANY_DATA; -- /* init session-context nonce */ -- SET_TO_RAND(&tpmData.stany.data.contextNonceSession); -+ -+ /* try and restore state to get EK, SRK, etc */ -+ restore_fail = tpm_restore_permanent_data(); -+ - /* set data and flags according to the given startup type */ - if (startupType == TPM_ST_CLEAR) { -- /* if available, restore permanent data */ -- tpm_restore_permanent_data(); -+ /* reset STANY_FLAGS */ -+ SET_TO_ZERO(&tpmData.stany.flags); -+ tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; -+ /* reset STANY_DATA (invalidates ALL sessions) */ -+ SET_TO_ZERO(&tpmData.stany.data); -+ tpmData.stany.data.tag = TPM_TAG_STANY_DATA; -+ /* init session-context nonce */ -+ SET_TO_RAND(&tpmData.stany.data.contextNonceSession); - /* reset PCR values */ - for (i = 0; i < TPM_NUM_PCR; i++) { -- if (tpmData.permanent.data.pcrAttrib[i].pcrReset) -- SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest); -+ if (!tpmData.permanent.data.pcrAttrib[i].pcrReset) -+ SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest); - else -- SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest); -+ SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest); - } - /* reset STCLEAR_FLAGS */ - SET_TO_ZERO(&tpmData.stclear.flags); -@@ -79,7 +82,8 @@ TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE - /* init key-context nonce */ - SET_TO_RAND(&tpmData.stclear.data.contextNonceKey); - } else if (startupType == TPM_ST_STATE) { -- if (tpm_restore_permanent_data()) { -+ /* restore must have been successful for TPM_ST_STATE */ -+ if (restore_fail) { - error("restoring permanent data failed"); - tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed"; - tpmData.permanent.flags.selfTestSucceeded = FALSE; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c ---- orig/tpm_emulator-0.4/tpm/tpm_storage.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_storage.c 2006-07-24 14:35:35.000000000 -0700 -@@ -58,6 +58,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - BYTE *enc, UINT32 *enc_size) - { - UINT32 len; -+ size_t enc_size32 = *enc_size; - BYTE *buf, *ptr; - rsa_public_key_t pub_key; - int scheme; -@@ -72,7 +73,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - if (buf == NULL - || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal) - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)), -- enc, enc_size)) { -+ enc, &enc_size32)) { - tpm_free(buf); - rsa_release_public_key(&pub_key); - return -1; -@@ -85,7 +86,8 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, - TPM_SEALED_DATA *seal, BYTE **buf) - { -- UINT32 len; -+ size_t len; -+ UINT32 len32; - BYTE *ptr; - int scheme; - switch (key->encScheme) { -@@ -96,8 +98,12 @@ int decrypt_sealed_data(TPM_KEY_DATA *ke - len = enc_size; - *buf = ptr = tpm_malloc(len); - if (*buf == NULL -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) -- || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) { -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){ -+ tpm_free(*buf); -+ return -1; -+ } -+ len32 = len; -+ if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) { - tpm_free(*buf); - return -1; - } -@@ -240,11 +246,12 @@ TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par - - TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize, - BYTE *inData, TPM_AUTH *auth1, -- UINT32 *outDataSize, BYTE **outData) -+ UINT32 *outDataSize32, BYTE **outData) - { - TPM_RESULT res; - TPM_KEY_DATA *key; - int scheme; -+ size_t outDataSize; - - info("TPM_UnBind()"); - /* get key */ -@@ -262,8 +269,8 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key - /* the size of the input data muss be greater than zero */ - if (inDataSize == 0) return TPM_BAD_PARAMETER; - /* decrypt data */ -- *outDataSize = inDataSize; -- *outData = tpm_malloc(*outDataSize); -+ outDataSize = inDataSize; -+ *outData = tpm_malloc(outDataSize); - if (*outData == NULL) return TPM_NOSPACE; - switch (key->encScheme) { - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; -@@ -271,20 +278,21 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key - default: tpm_free(*outData); return TPM_DECRYPT_ERROR; - } - if (rsa_decrypt(&key->key, scheme, inData, inDataSize, -- *outData, outDataSize)) { -+ *outData, &outDataSize)) { - tpm_free(*outData); - return TPM_DECRYPT_ERROR; - } - /* verify data if it is of type TPM_BOUND_DATA */ - if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1 - || key->keyUsage != TPM_KEY_LEGACY) { -- if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { -+ if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { - tpm_free(*outData); - return TPM_DECRYPT_ERROR; - } -- *outDataSize -= 5; -- memmove(*outData, &(*outData)[5], *outDataSize); -+ outDataSize -= 5; -+ memmove(*outData, &(*outData)[5], outDataSize); - } -+ *outDataSize32 = (UINT32) outDataSize; - return TPM_SUCCESS; - } - -@@ -334,12 +342,13 @@ int compute_pubkey_digest(TPM_PUBKEY *ke - } - - int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store, -- BYTE *enc, UINT32 *enc_size) -+ BYTE *enc, UINT32 *enc_size32) - { - UINT32 len; - BYTE *buf, *ptr; - rsa_public_key_t pub_key; - int scheme; -+ size_t enc_size; - switch (key->encScheme) { - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; - case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break; -@@ -351,11 +360,12 @@ int encrypt_private_key(TPM_KEY_DATA *ke - if (buf == NULL - || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store) - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)), -- enc, enc_size)) { -+ enc, &enc_size)) { - tpm_free(buf); - rsa_release_public_key(&pub_key); - return -1; - } -+ *enc_size32 = (UINT32) enc_size; - tpm_free(buf); - rsa_release_public_key(&pub_key); - return 0; -@@ -364,7 +374,8 @@ int encrypt_private_key(TPM_KEY_DATA *ke - int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, - TPM_STORE_ASYMKEY *store, BYTE **buf) - { -- UINT32 len; -+ UINT32 len32; -+ size_t len; - BYTE *ptr; - int scheme; - switch (key->encScheme) { -@@ -375,8 +386,12 @@ int decrypt_private_key(TPM_KEY_DATA *ke - len = enc_size; - *buf = ptr = tpm_malloc(len); - if (*buf == NULL -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) -- || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) { -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) { -+ tpm_free(*buf); -+ return -1; -+ } -+ len32 = (UINT32) len; -+ if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { - tpm_free(*buf); - return -1; - } -@@ -394,7 +409,7 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - TPM_SESSION_DATA *session; - TPM_STORE_ASYMKEY store; - rsa_private_key_t rsa; -- UINT32 key_length; -+ size_t key_length; - - info("TPM_CreateWrapKey()"); - /* get parent key */ -@@ -450,11 +465,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - } - } - /* generate key and store it */ -- key_length = keyInfo->algorithmParms.parms.rsa.keyLength; -- if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL; -- wrappedKey->pubKey.keyLength = key_length >> 3; -+ if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength)) -+ return TPM_FAIL; -+ wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3; - wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength); -- store.privKey.keyLength = key_length >> 4; -+ store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4; - store.privKey.key = tpm_malloc(store.privKey.keyLength); - wrappedKey->encDataSize = parent->key.size >> 3; - wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize); -@@ -466,9 +481,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - tpm_free(wrappedKey->encData); - return TPM_NOSPACE; - } -- rsa_export_modulus(&rsa, wrappedKey->pubKey.key, -- &wrappedKey->pubKey.keyLength); -- rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength); -+ rsa_export_modulus(&rsa, wrappedKey->pubKey.key, -+ &key_length); -+ wrappedKey->pubKey.keyLength = (UINT32) key_length; -+ rsa_export_prime1(&rsa, store.privKey.key, &key_length); -+ store.privKey.keyLength = (UINT32) key_length; - rsa_release_private_key(&rsa); - /* compute the digest of the wrapped key (without encData) */ - if (compute_key_digest(wrappedKey, &store.pubDataDigest)) { -@@ -602,6 +619,7 @@ TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p - - int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms) - { -+ size_t key_length; - parms->algorithmID = TPM_ALG_RSA; - parms->encScheme = key->encScheme; - parms->sigScheme = key->sigScheme; -@@ -611,7 +629,8 @@ int tpm_setup_key_parms(TPM_KEY_DATA *ke - parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize); - if (parms->parms.rsa.exponent == NULL) return -1; - rsa_export_exponent(&key->key, parms->parms.rsa.exponent, -- &parms->parms.rsa.exponentSize); -+ &key_length); -+ parms->parms.rsa.exponentSize = (UINT32) key_length; - parms->parmSize = 12 + parms->parms.rsa.exponentSize; - return 0; - } -@@ -622,6 +641,7 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE - TPM_RESULT res; - TPM_KEY_DATA *key; - TPM_DIGEST digest; -+ size_t key_length; - info("TPM_GetPubKey()"); - /* get key */ - if (keyHandle == TPM_KH_SRK -@@ -650,8 +670,8 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE - pubKey->pubKey.keyLength = key->key.size >> 3; - pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength); - if (pubKey->pubKey.key == NULL) return TPM_NOSPACE; -- rsa_export_modulus(&key->key, pubKey->pubKey.key, -- &pubKey->pubKey.keyLength); -+ rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length); -+ pubKey->pubKey.keyLength = (UINT32) key_length; - if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) { - error("TPM_GetPubKey(): tpm_setup_key_parms() failed."); - tpm_free(pubKey->pubKey.key); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h ---- orig/tpm_emulator-0.4/tpm/tpm_structures.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_structures.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1958,6 +1958,7 @@ typedef struct tdTPM_DAA_ISSUER { - TPM_DIGEST DAA_digest_gamma; - BYTE DAA_generic_q[26]; - } TPM_DAA_ISSUER; -+#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 ) - - /* - * TPM_DAA_TPM ([TPM_Part2], Section 22.4) -@@ -1973,6 +1974,7 @@ typedef struct tdTPM_DAA_TPM { - TPM_DIGEST DAA_rekey; - UINT32 DAA_count; - } TPM_DAA_TPM; -+#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4) - - /* - * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5) -@@ -1987,6 +1989,7 @@ typedef struct tdTPM_DAA_CONTEXT { - BYTE DAA_scratch[256]; - BYTE DAA_stage; - } TPM_DAA_CONTEXT; -+#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1) - - /* - * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6) -@@ -1998,6 +2001,7 @@ typedef struct tdTPM_DAA_JOINDATA { - BYTE DAA_join_u1[138]; - TPM_DIGEST DAA_digest_n0; - } TPM_DAA_JOINDATA; -+#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20) - - /* - * TPM_DAA_BLOB ([TPM_Part2], Section 22.8) -@@ -2202,6 +2206,7 @@ typedef struct tdTPM_STCLEAR_DATA { - //UINT32 ownerReference; - //BOOL disableResetLock; - } TPM_STCLEAR_DATA; -+#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4) - - /* - * TPM_SESSION_DATA -@@ -2238,6 +2243,11 @@ typedef struct tdTPM_DAA_SESSION_DATA { - TPM_DAA_JOINDATA DAA_joinSession; - TPM_HANDLE handle; - } TPM_DAA_SESSION_DATA; -+#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \ -+ + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \ -+ + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \ -+ + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \ -+ + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4) - - /* - * TPM_STANY_DATA ([TPM_Part2], Section 7.6) -@@ -2262,6 +2272,11 @@ typedef struct tdTPM_STANY_DATA { - TPM_DAAHANDLE currentDAA; - TPM_TRANSHANDLE transExclusive; - } TPM_STANY_DATA; -+#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \ -+ + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \ -+ + 4 + (4 * TPM_MAX_SESSION_LIST) \ -+ + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \ -+ + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4) - - /* - * TPM_DATA -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c ---- orig/tpm_emulator-0.4/tpm/tpm_testing.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_testing.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -95,24 +96,24 @@ static int tpm_test_sha1(void) - struct { - uint8_t *data; uint32_t repetitions; uint8_t *digest; - } test_cases[] = {{ -- "abc", 1, -- "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" -+ (uint8_t*)"abc", 1, -+ (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" - }, { -- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, -- "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" -+ (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, -+ (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" - }, { -- "a", 1000000, -- "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" -+ (uint8_t*)"a", 1000000, -+ (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" - }, { -- "0123456701234567012345670123456701234567012345670123456701234567", 10, -- "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" -+ (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10, -+ (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" - }}; - - debug("tpm_test_sha1()"); - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { - sha1_init(&ctx); - for (j = 0; j < test_cases[i].repetitions; j++) -- sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); -+ sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); - sha1_final(&ctx, digest); - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; - } -@@ -128,41 +129,41 @@ static int tpm_test_hmac(void) - struct { - uint8_t *key, key_len, *data, data_len, *digest; - } test_cases[] = {{ -- "\x0b", 20, "Hi There", 8, -- "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" -+ (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8, -+ (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" - }, { -- "Jefe", 4, "what do ya want for nothing?", 28, -- "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" -+ (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28, -+ (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" - }, { -- "\xaa", 20, "\xdd", 50, -- "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" -+ (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50, -+ (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" - }, { -- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" -- "\x15\x16\x17\x18\x19", 25, "\xcd", 50, -- "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" -+ (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" -+ "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50, -+ (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" - }, { -- "\x0c", 20, "Test With Truncation", 20, -- "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" -+ (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20, -+ (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" - }, { -- "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54, -- "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" -+ (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54, -+ (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" - }, { -- "\xaa", 80, -- "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, -- "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" -+ (uint8_t*)"\xaa", 80, -+ (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, -+ (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" - }}; - - debug("tpm_test_hmac()"); - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { -- if (strlen(test_cases[i].key) < test_cases[i].key_len) { -+ if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) { - uint8_t key[test_cases[i].key_len]; - memset(key, test_cases[i].key[0], test_cases[i].key_len); - hmac_init(&ctx, key, test_cases[i].key_len); - } else { - hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len); - } -- for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) { -- hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); -+ for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) { -+ hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); - } - hmac_final(&ctx, digest); - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; -@@ -173,9 +174,9 @@ static int tpm_test_hmac(void) - static int tpm_test_rsa_EK(void) - { - int res = 0; -- char *data = "RSA PKCS #1 v1.5 Test-String"; -+ uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String"; - uint8_t buf[256]; -- size_t buf_len, data_len = strlen(data); -+ size_t buf_len, data_len = strlen((char*)data); - rsa_private_key_t priv_key; - rsa_public_key_t pub_key; - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c ---- orig/tpm_emulator-0.4/tpm/tpm_ticks.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_ticks.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -39,9 +40,7 @@ TPM_RESULT TPM_SetTickType(TPM_TICKTYPE - TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime) - { - info("TPM_GetTicks()"); -- memcpy(currentTime, &tpmData.stany.data.currentTicks, -- sizeof(TPM_CURRENT_TICKS)); -- return TPM_SUCCESS; -+ return TPM_DISABLED_CMD; - } - - TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay, -@@ -49,64 +48,11 @@ TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN - TPM_CURRENT_TICKS *currentTicks, - UINT32 *sigSize, BYTE **sig) - { -- TPM_RESULT res; -- TPM_KEY_DATA *key; -- BYTE *info, *p; -- UINT32 info_length, length; - info("TPM_TickStampBlob()"); -- /* get key */ -- key = tpm_get_key(keyHandle); -- if (key == NULL) return TPM_INVALID_KEYHANDLE; -- /* verify authorization */ -- res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); -- if (res != TPM_SUCCESS) return res; -- if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY -- && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE; -- /* get current ticks */ -- TPM_GetTicks(currentTicks); -- /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */ -- *sigSize = key->key.size >> 3; -- *sig = tpm_malloc(*sigSize); -- if (*sig == NULL) return TPM_FAIL; -- /* setup TPM_SIGN_INFO structure */ -- info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks); -- info = tpm_malloc(info_length); -- if (info == NULL) { -- tpm_free(*sig); -- return TPM_FAIL; -- } -- memcpy(&info[0], "\x05\x00TSTP", 6); -- memcpy(&info[6], antiReplay->nonce, 20); -- *(UINT32*)&info[26] = CPU_TO_BE32(20 -- + sizeof_TPM_CURRENT_TICKS(currentTicks)); -- memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST)); -- p = &info[30 + sizeof(TPM_DIGEST)]; -- length = sizeof_TPM_CURRENT_TICKS(currentTicks); -- if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks) -- || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) { -- tpm_free(*sig); -- tpm_free(info); -- return TPM_FAIL; -- } -- return TPM_SUCCESS; -+ return TPM_DISABLED_CMD; - } - - void tpm_update_ticks(void) - { -- if (tpmData.stany.data.currentTicks.tag == 0) { -- tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS; -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); --/* removed since v1.2 rev 94 -- tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType; --*/ -- tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce, -- sizeof(TPM_NONCE)); -- tpmData.stany.data.currentTicks.tickRate = 1; --/* removed since v1.2 rev 94 -- tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK; --*/ -- } else { -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); -- } - } - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c ---- orig/tpm_emulator-0.4/tpm/tpm_transport.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_transport.c 2006-07-24 14:35:35.000000000 -0700 -@@ -189,7 +189,7 @@ static void decrypt_wrapped_command(BYTE - sha1_init(&sha1); - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); -- sha1_update(&sha1, "in", 2); -+ sha1_update(&sha1, (BYTE*)"in", 2); - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); - j = CPU_TO_BE32(i); - sha1_update(&sha1, (BYTE*)&j, 4); -@@ -211,7 +211,7 @@ static void encrypt_wrapped_command(BYTE - sha1_init(&sha1); - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); -- sha1_update(&sha1, "out", 3); -+ sha1_update(&sha1, (BYTE*)"out", 3); - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); - j = CPU_TO_BE32(i); - sha1_update(&sha1, (BYTE*)&j, 4); -diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c ---- orig/tpm_emulator-0.4/tpmd.c 1969-12-31 16:00:00.000000000 -0800 -+++ tpm_emulator/tpmd.c 2006-07-24 14:35:35.000000000 -0700 -@@ -0,0 +1,156 @@ -+/* Software-Based Trusted Platform Module (TPM) Emulator for Linux -+ * Copyright (C) 2005 INTEL Corp -+ * -+ * This module is free software; you can redistribute it and/or modify -+ * it under the terms of the GNU General Public License as published -+ * by the Free Software Foundation; either version 2 of the License, -+ * or (at your option) any later version. -+ * -+ * This module is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -+ * GNU General Public License for more details. -+ * -+ */ -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#include "tpm_emulator.h" -+ -+#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" -+#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" -+ -+#define BUFFER_SIZE 2048 -+ -+static int devurandom=0; -+ -+void get_random_bytes(void *buf, int nbytes) { -+ -+ if (devurandom == 0) { -+ devurandom = open("/dev/urandom", O_RDONLY); -+ } -+ -+ if (read(devurandom, buf, nbytes) != nbytes) { -+ printf("Can't get random number.\n"); -+ exit(-1); -+ } -+} -+ -+uint64_t tpm_get_ticks(void) -+{ -+ //struct timeval tv; -+ //int gettimeofday(&tv, struct timezone *tz); -+ return 0; -+} -+ -+int main(int argc, char **argv) -+{ -+ uint8_t in[BUFFER_SIZE], *out; -+ uint32_t out_size; -+ int in_size, written; -+ int i; -+ struct stat file_info; -+ -+ int tpm_tx_fh=-1, tpm_rx_fh=-1; -+ if (argc < 2) { -+ printf("Usage: tpmd clear|save|deactivated\n" ); -+ return -1; -+ } -+ -+ /* initialize TPM emulator */ -+ if (!strcmp(argv[1], "clear")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(1); -+ } else if (!strcmp(argv[1], "save")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(2); -+ } else if (!strcmp(argv[1], "deactivated")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(3); -+ } else { -+ printf("invalid startup mode '%s'; must be 'clear', " -+ "'save' (default) or 'deactivated", argv[1]); -+ return -1; -+ } -+ -+ if ( stat(TPM_RX_FNAME, &file_info) == -1) { -+ if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { -+ printf("Failed to create fifo %s.\n", TPM_RX_FNAME); -+ return -1; -+ } -+ } -+ -+ if ( stat(TPM_TX_FNAME, &file_info) == -1) { -+ if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { -+ printf("Failed to create fifo %s.\n", TPM_TX_FNAME); -+ return -1; -+ } -+ } -+ -+ while (1) { -+abort_command: -+ if (tpm_rx_fh < 0) { -+ tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); -+ } -+ -+ if (tpm_rx_fh < 0) { -+ printf("ERROR: failed to open devices to listen to guest.\n"); -+ return -1; -+ } -+ -+ if (tpm_tx_fh < 0) { -+ tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); -+ } -+ -+ if (tpm_tx_fh < 0) { -+ printf("ERROR: failed to open devices to respond to guest.\n"); -+ return -1; -+ } -+ -+ in_size = read(tpm_rx_fh, in, BUFFER_SIZE); -+ if (in_size < 6) { // Magic size of minium TPM command -+ printf("Recv[%d] to small: 0x", in_size); -+ if (in_size <= 0) { -+ close(tpm_rx_fh); -+ tpm_rx_fh = -1; -+ goto abort_command; -+ } -+ } else { -+ printf("Recv[%d]: 0x", in_size); -+ for (i=0; i< in_size; i++) -+ printf("%x ", in[i]); -+ printf("\n"); -+ } -+ -+ -+ if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { -+ printf("ERROR: Handler Failed.\n"); -+ } -+ -+ written = write(tpm_tx_fh, out, out_size); -+ -+ if (written != out_size ) { -+ printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); -+ } else { -+ printf("Sent[%Zu]: ", out_size); -+ } -+ for (i=0; i< out_size; i++) -+ printf("%x ", out[i]); -+ printf("\n"); -+ tpm_free(out); -+ -+ } // loop -+ -+ tpm_emulator_shutdown(); -+ -+ close(tpm_tx_fh); -+ close(tpm_rx_fh); -+ -+} -Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ -diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h ---- orig/tpm_emulator-0.4/tpm_version.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm_version.h 2006-07-24 14:35:41.000000000 -0700 -@@ -2,5 +2,5 @@ - #define _TPM_VERSION_H_ - #define VERSION_MAJOR 0 - #define VERSION_MINOR 4 --#define VERSION_BUILD 1151058734 -+#define VERSION_BUILD 1153776940 - #endif /* _TPM_VERSION_H_ */ diff --git a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch b/tools/vtpm/vtpm-0.5.1-LDLIBS.patch deleted file mode 100644 index 95586c1..0000000 --- a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm_emulator-0.5.1/tpmd/Makefile ---- tpm_emulator-0.5.1/tpmd/Makefile -+++ tpm_emulator-0.5.1/tpmd/Makefile -@@ -8,7 +8,7 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing - CFLAGS += -I../../../../tools/vtpm_manager/manager --LDFLAGS += -lgmp -+LDLIBS += -lgmp - - BINDIR := /usr/bin/ - diff --git a/tools/vtpm/vtpm-0.5.1.patch b/tools/vtpm/vtpm-0.5.1.patch deleted file mode 100644 index 2aeb745..0000000 --- a/tools/vtpm/vtpm-0.5.1.patch +++ /dev/null @@ -1,766 +0,0 @@ -diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile ---- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 -@@ -10,7 +10,7 @@ VERSION_MINOR := 5 - VERSION_BUILD := $(shell date +"%s") - VERSION_SUFFIX := .1 - --SUBDIRS := tpmd tpmd_dev tddl -+SUBDIRS := tpmd - - all: version all-recursive - -@@ -48,12 +48,12 @@ user_install: user - modules_install: modules - @$(MAKE) -C tpmd_dev install || exit -1 - --DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd -+DIRS := . tpm crypto tpmd - DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) - DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) --DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd -+DIRS := . tpmd - DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) --DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in -+DISTSRC += ./README ./AUTHORS ./ChangeLog - DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) - - dist: $(DISTSRC) -diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c ---- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 -@@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_TIS_TIMEOUT: - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ -+ UINT32 len = *respSize = 16; -+ BYTE *ptr = *resp = tpm_malloc(*respSize); -+ if (ptr == NULL || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { -+ tpm_free(*resp); -+ return TPM_FAIL; -+ } -+ return TPM_SUCCESS; -+ - - case TPM_CAP_PROP_STARTUP_EFFECT: - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); -@@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_DURATION: - debug("[TPM_CAP_PROP_DURATION]"); -- /* TODO: TPM_CAP_PROP_DURATION */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; -+ *respSize = 16; -+ *resp = tpm_malloc(*respSize); -+ memcpy(*resp,dur,16); -+ - - case TPM_CAP_PROP_ACTIVE_COUNTER: - debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile ---- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 -@@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a - -Wwrite-strings -Wsign-compare -Wno-multichar - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing -+CFLAGS += -I../../../../tools/vtpm_manager/manager - LDFLAGS += -lgmp - --BINDIR := /usr/sbin/ -+BINDIR := /usr/bin/ - - TPMD := tpmd - DIRS := ../tpm ../crypto -@@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil - OBJS := $(patsubst %.c, %.o, $(SRCS)) - OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) - -+VTPM_BIN := vtpmd -+ - vpath %.c $(strip $(DIRS)) - - all: $(TPMD) -@@ -32,10 +35,8 @@ TPMD_GROUP ?= tss - INSTALL ?= install - - install: $(TPMD) -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm - $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) -- $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) -+ $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) - - .PHONY: all clean install - -diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c ---- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 -@@ -32,6 +32,9 @@ - #include - #include "tpm_emulator_config.h" - #include "tpm/tpm_emulator.h" -+#include "tpm/tpm_structures.h" -+#include "tpm/tpm_marshalling.h" -+#include "vtpm_manager.h" - - #define TPM_DAEMON_NAME "tpmd" - #define TPM_CMD_BUF_SIZE 4096 -@@ -39,6 +42,24 @@ - #define TPM_RANDOM_DEVICE "/dev/urandom" - #undef TPM_MKDIRS - -+#ifdef VTPM_MULTI_VM -+ #define DEV_BE "/dev/vtpm" -+ #define DEV_FE "/dev/tpm" -+#else -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" -+ -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -+ -+ static char *vtpm_rx_name=NULL; -+#endif -+ -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#define BUFFER_SIZE 2048 -+ - static volatile int stopflag = 0; - static int is_daemon = 0; - static int opt_debug = 0; -@@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ - static uid_t opt_uid = 0; - static gid_t opt_gid = 0; - static int tpm_startup = 2; -+static int vtpm_type = VTPM_TYPE_PVM; -+int dmi_id = 0; - static int rand_fh; - - void tpm_log(int priority, const char *fmt, ...) -@@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) - - int tpm_write_to_file(uint8_t *data, size_t data_length) - { -- int fh; -- ssize_t res; -- fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- if (fh < 0) return -1; -- while (data_length > 0) { -- res = write(fh, data, data_length); -- if (res < 0) { -- close(fh); -- return -1; -- } -- data_length -= res; -- data += res; -+ int res, out_data_size, in_header_size; -+ BYTE *ptr, *out_data, *in_header; -+ UINT32 result, len, in_rsp_size; -+ UINT16 tag = VTPM_TAG_REQ; -+ -+ printf("Saving NVM\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; -+#endif -+ -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { -+ free(out_data); -+ return -1; -+ } -+ -+ printf("\tSending SaveNVM Command.\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); - } -- close(fh); -- return 0; -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading SaveNVM header.\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_tx_fh); close(vtpm_rx_fh); -+#endif -+ -+ printf("\tFinishing up SaveNVM\n"); -+ return (0); - } - - int tpm_read_from_file(uint8_t **data, size_t *data_length) - { -- int fh; -- ssize_t res; -- size_t total_length; -- fh = open(opt_storage_file, O_RDONLY); -- if (fh < 0) return -1; -- total_length = lseek(fh, 0, SEEK_END); -- lseek(fh, 0, SEEK_SET); -- *data = tpm_malloc(total_length); -- if (*data == NULL) { -- close(fh); -- return -1; -- } -- *data_length = 0; -- while (total_length > 0) { -- res = read(fh, &(*data)[*data_length], total_length); -- if (res < 0) { -- close(fh); -- tpm_free(*data); -- return -1; -- } -- *data_length += res; -- total_length -= res; -+ int res, out_data_size, in_header_size; -+ uint8_t *ptr, *out_data, *in_header; -+ UINT16 tag = VTPM_TAG_REQ; -+ UINT32 len, in_rsp_size, result; -+#ifdef VTPM_MUTLI_VM -+ int vtpm_rx_fh, vtpm_tx_fh; -+#endif -+ -+ printf("Loading NVM.\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ printf("Error in read_from_file:301\n"); -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { -+ free(out_data); -+ printf("Error in read_from_file:325\n"); -+ -+ return -1; -+ } -+ -+ printf("\tSending LoadNVM command\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) -+ { -+ printf("Error in read_from_file:335\n"); -+ return -1; -+ } -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); - } -- close(fh); -- return 0; -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ printf("Error in read_from_file:352\n"); -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading LoadNVM header\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ printf("Error in read_from_file:375\n"); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ printf("Error in read_from_file:381\n"); -+ return -1; -+ } -+ -+ // Read Encrypted data from VTPM Manager -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; -+ *data = (uint8_t *) malloc(*data_length); -+ -+ printf("\tReading clear data from LoadNVM.\n"); -+ res = read(vtpm_rx_fh, *data, *data_length); -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_rx_fh);close(vtpm_tx_fh); -+#endif -+ -+ printf("\tReturing from loading NVM\n"); -+ if (res != (int)*data_length) { -+ free(*data); -+ printf("Error in read_from_file:398\n"); -+ return -1; -+ } else { -+ return 0; -+ } -+ -+ -+ - } - - static void print_usage(char *name) - { - printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " -- "[-o user name] [-g group name] [-h] [startup mode]\n", name); -+ "[-o user name] [-g group name] [-h]" -+#ifdef VTPM_MULTI_VM -+ "clear|save|deactivated\n", name); -+#else -+ "clear|save|deactivated pvm|hvm vtpmid\n", name); -+#endif - printf(" d : enable debug mode\n"); - printf(" f : forces the application to run in the foreground\n"); - printf(" s : storage file to use (default: %s)\n", opt_storage_file); -@@ -205,7 +413,13 @@ static void parse_options(int argc, char - exit(EXIT_SUCCESS); - } - } -- if (optind < argc) { -+ /*Make sure we have all required options*/ -+#ifdef VTPM_MULTI_VM -+#define EXTRA_OPTS 0 -+#else -+#define EXTRA_OPTS 2 -+#endif -+ if (optind < argc - EXTRA_OPTS ) { - debug("startup mode = '%s'", argv[optind]); - if (!strcmp(argv[optind], "clear")) { - tpm_startup = 1; -@@ -219,6 +433,25 @@ static void parse_options(int argc, char - print_usage(argv[0]); - exit(EXIT_SUCCESS); - } -+#ifndef VTPM_MULTI_VM -+ ++optind; -+ if(!strcmp(argv[optind], "pvm")) { -+ vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo -+ } else if (!strcmp(argv[optind], "hvm")) { -+ vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket -+ } else { -+ error("Invalid vm mode '%s'; must be 'pvm', " -+ "or 'hvm' ", argv[optind]); -+ print_usage(argv[0]); -+ exit(EXIT_SUCCESS); -+ } -+ ++optind; -+ dmi_id = atoi(argv[optind]); -+#endif -+ } else { -+ error("Invalid number of arguments"); -+ print_usage(argv[0]); -+ exit(EXIT_SUCCESS); - } - } - -@@ -348,93 +581,180 @@ static int init_socket(const char *name) - - static void main_loop(void) - { -- int sock, fh, res; -- int32_t in_len; -+ int32_t in_len, written; - uint32_t out_len; -- uint8_t in[TPM_CMD_BUF_SIZE], *out; -+ uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; -+ int guest_id=-1; -+ int i; -+ char *vtpm_rx_file=NULL; -+ int res; -+ -+#ifndef VTPM_MULTI_VM -+ int sockfd = -1; - struct sockaddr_un addr; -- socklen_t addr_len; -- fd_set rfds; -- struct timeval tv; -+ struct sockaddr_un client_addr; -+ unsigned int client_length; -+#endif -+ -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#ifndef VTPM_MULTI_VM -+ if (vtpm_type == VTPM_TYPE_PVM) { -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); -+ } else { -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); -+ -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { -+ error("Unable to create socket. errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&addr, 0, sizeof(addr)); -+ addr.sun_family = AF_UNIX; -+ strcpy(addr.sun_path,vtpm_rx_file ); -+ unlink(addr.sun_path); -+ } -+#endif - - info("staring main loop"); -- /* open UNIX socket */ -- sock = init_socket(opt_socket_name); -- if (sock < 0) exit(EXIT_FAILURE); - /* init tpm emulator */ -- debug("initializing TPM emulator: %d", tpm_startup); -+#ifdef VTPM_MULTI_VM -+ debug("initializing TPM emulator: state=%d", tpm_startup); -+#else -+ debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); -+#endif - tpm_emulator_init(tpm_startup); - /* start command processing */ - while (!stopflag) { - /* wait for incomming connections */ - debug("waiting for connections..."); -- FD_ZERO(&rfds); -- FD_SET(sock, &rfds); -- tv.tv_sec = 10; -- tv.tv_usec = 0; -- res = select(sock + 1, &rfds, NULL, NULL, &tv); -- if (res < 0) { -- error("select(sock) failed: %s", strerror(errno)); -- break; -- } else if (res == 0) { -- continue; -- } -- addr_len = sizeof(addr); -- fh = accept(sock, (struct sockaddr*)&addr, &addr_len); -- if (fh < 0) { -- error("accept() failed: %s", strerror(errno)); -- continue; -- } -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); -+#else -+ if (vtpm_type == VTPM_TYPE_PVM) -+ { -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); -+ } else { -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { -+ error("Unable to bind(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ if (listen(sockfd, 10) <0) { -+ error("Unable to listen(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&client_addr, 0, sizeof(client_addr)); -+ client_length = sizeof(client_addr); -+ -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); -+ } -+#endif -+ } -+ -+ /*Error Checking*/ -+ if (vtpm_rx_fh < 0) { -+ error("Failed to open devices to listen to guest.\n"); -+ exit(-1); -+ } -+ - /* receive and handle commands */ - in_len = 0; - do { - debug("waiting for commands..."); -- FD_ZERO(&rfds); -- FD_SET(fh, &rfds); -- tv.tv_sec = TPM_COMMAND_TIMEOUT; -- tv.tv_usec = 0; -- res = select(fh + 1, &rfds, NULL, NULL, &tv); -- if (res < 0) { -- error("select(fh) failed: %s", strerror(errno)); -- close(fh); -- break; -- } else if (res == 0) { --#ifdef TPMD_DISCONNECT_IDLE_CLIENTS -- info("connection closed due to inactivity"); -- close(fh); -- break; --#else -- continue; --#endif -- } -- in_len = read(fh, in, sizeof(in)); -- if (in_len > 0) { -+ -+ in_len = read(vtpm_rx_fh, in, sizeof(in)); -+ /*Magic size of minimum TPM command is 6*/ -+ //FIXME Magic size check may not be required anymore -+ if (in_len < 6) { -+ info("Recv incomplete command of %d bytes.", in_len); -+ if (in_len <= 0) { -+ close(vtpm_rx_fh); -+ vtpm_rx_fh = -1; -+ continue; -+ } -+ } else { -+ /*Debug Printouts*/ - debug("received %d bytes", in_len); -+ debug_nostop("Recv[%d]: 0x", in_len); -+ for (i=0; i< in_len; i++) -+ debug_more("%x ", in[i]); -+ debug_more("\n"); -+ /*Multiple Guest check*/ -+ if (guest_id == -1) { -+ guest_id = *((int32_t *) in); -+ } else { -+ if (guest_id != *((int32_t *) in) ) { -+ error("WARNING: More than one guest attached\n"); -+ } -+ } -+ -+ /*Open tx handle now*/ -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_type == VTPM_TYPE_PVM) { -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); -+ } // No need to open the other direction for HVM -+#endif -+ } -+ if (vtpm_tx_fh < 0) { -+ error("Failed to open devices to respond to guest.\n"); -+ exit(-1); -+ } -+ -+ /*Handle the TPM command now*/ - out = NULL; -- res = tpm_handle_command(in, in_len, &out, &out_len); -+ res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); - if (res < 0) { - error("tpm_handle_command() failed"); - } else { - debug("sending %d bytes", out_len); -+ //FIXME this prepending may or may not be needed -+ /*Prepend the first 4 bytes of the in buffer.. why?*/ -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); -+ *(uint32_t *) addressed_out = *(uint32_t *) in; -+ memcpy(addressed_out + sizeof(uint32_t), out, out_len); -+ out_len += sizeof(uint32_t); -+ /*End Prepend*/ -+ -+ /*Perform write operation now*/ - while (out_len > 0) { -- res = write(fh, out, out_len); -+ res = write(vtpm_tx_fh, addressed_out, out_len); -+ - if (res < 0) { - error("write(%d) failed: %s", out_len, strerror(errno)); - break; -- } -+ } else { -+ debug_nostop("Sent[%Zu]: ", out_len); -+ for (i=0; (unsigned int)i< out_len; i++) -+ debug_more("%x ", addressed_out[i]); -+ debug_more("\n"); -+ } - out_len -= res; - } - tpm_free(out); -+ tpm_free(addressed_out); - } - } - } while (in_len > 0); -- close(fh); -+ //close(fh); - } -+ - /* shutdown tpm emulator */ - tpm_emulator_shutdown(); -- /* close socket */ -- close(sock); -- unlink(opt_socket_name); -+ /* Close handles */ -+ close(vtpm_tx_fh); -+#ifndef VTPM_MULTI_VM -+ close(vtpm_rx_fh); -+ free(vtpm_rx_file); -+#endif - info("main loop stopped"); - } - -@@ -450,12 +770,13 @@ int main(int argc, char **argv) - /* open random device */ - init_random(); - /* init signal handlers */ -- init_signal_handler(); -+ //init_signal_handler(); - /* unless requested otherwiese, fork and daemonize process */ -- if (!opt_foreground) daemonize(); -+ //if (!opt_foreground) daemonize(); - /* start main processing loop */ - main_loop(); - info("stopping TPM Emulator daemon"); - closelog(); - return 0; - } -+ -diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h ---- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 -@@ -29,23 +29,28 @@ - - /* TPM emulator configuration */ - --#undef TPM_STRONG_PERSISTENCE --#undef TPM_GENERATE_EK -+#define TPM_STRONG_PERSISTENCE -+#define TPM_GENERATE_EK - #undef TPM_GENERATE_SEED_DAA - #undef TPM_MEMORY_ALIGNMENT_MANDATORY - -+extern int dmi_id; -+ - /* log macros */ - - void tpm_log(int priority, const char *fmt, ...); - --#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) - - /* min/max macros that also do strict type-checking */ - diff --git a/tools/vtpm/vtpm.patch b/tools/vtpm/vtpm.patch deleted file mode 100644 index e896b25..0000000 --- a/tools/vtpm/vtpm.patch +++ /dev/null @@ -1,716 +0,0 @@ -diff -uprN tpm_emulator/AUTHORS vtpm/AUTHORS ---- tpm_emulator/AUTHORS 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/AUTHORS 2006-12-13 16:38:52.000000000 -0800 -@@ -1,3 +1,3 @@ - Mario Strasser - Heiko Stamer [DAA] --INTEL Corp <> [Dropped to Ring3] -+INTEL Corp <> [VTPM Extensions] -diff -uprN tpm_emulator/ChangeLog vtpm/ChangeLog ---- tpm_emulator/ChangeLog 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/ChangeLog 2006-12-13 16:38:52.000000000 -0800 -@@ -1,5 +1,6 @@ - ????-??-?? Intel Corp - * Moved module out of kernel to run as a ring 3 app -+ * Modified save_to_file and load_from_file to call xen VTPM manager - - 2006-06-23 Mario Strasser - * tpm_startup.c: behaviour of ST_CLEAR and storage of -diff -uprN tpm_emulator/linux_module.h vtpm/linux_module.h ---- tpm_emulator/linux_module.h 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/linux_module.h 2007-01-09 14:49:06.000000000 -0800 -@@ -44,18 +44,26 @@ - #define TPM_DEVICE_NAME "tpm" - #define TPM_MODULE_NAME "tpm_emulator" - -+/* debug and log output functions */ -+extern int dmi_id; -+ - #ifdef DEBUG --#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_nostop(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt, \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_more(fmt, ...) printf( fmt, ## __VA_ARGS__ ) - #else - #define debug(fmt, ...) -+#define debug_nostop(fmt, ...) -+#define debug_more(fmt, ...) - #endif --#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) printf("TPMD[%d]: %s:%d: Info: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) printf("TPMD[%d]: %s:%d: Error: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) printf("TPMD[%d]: %s:%d: Alert: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) - - /* memory allocation */ - -diff -uprN tpm_emulator/Makefile vtpm/Makefile ---- tpm_emulator/Makefile 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/Makefile 2006-12-13 16:38:52.000000000 -0800 -@@ -7,7 +7,7 @@ - COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) - - # module settings --BIN := tpm_emulator -+BIN := vtpmd - VERSION_MAJOR := 0 - VERSION_MINOR := 4 - VERSION_BUILD := $(shell date +"%s") -@@ -22,7 +22,7 @@ TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin - - CC := gcc - CFLAGS += -g -Wall $(INCLUDE) -DDEBUG --CFLAGS += -I. -Itpm -+CFLAGS += -I. -Itpm -I../../vtpm_manager/manager - - # Is the simulator running in it's own vm? - #CFLAGS += -DVTPM_MULTI_VM -@@ -62,7 +62,6 @@ $(BIN): $(src)/crypto/gmp.h $(src)/crypt - - install: $(BIN) - $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) -- @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi - - clean: - rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) -@@ -98,3 +97,4 @@ version: - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h - - .PHONY: all install clean dist gmp version -+ -diff -uprN tpm_emulator/tpm/tpm_capability.c vtpm/tpm/tpm_capability.c ---- tpm_emulator/tpm/tpm_capability.c 2006-06-23 03:37:07.000000000 -0700 -+++ vtpm/tpm/tpm_capability.c 2007-01-10 10:00:49.000000000 -0800 -@@ -136,8 +136,18 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_TIS_TIMEOUT: - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ -+ UINT32 len = *respSize = 16; -+ BYTE *ptr = *resp = tpm_malloc(*respSize); -+ if (ptr == NULL || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { -+ tpm_free(*resp); -+ return TPM_FAIL; -+ } -+ return TPM_SUCCESS; - - case TPM_CAP_PROP_STARTUP_EFFECT: - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); -@@ -190,7 +200,11 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_DURATION: - debug("[TPM_CAP_PROP_DURATION]"); -- /* TODO: TPM_CAP_PROP_DURATION */ -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; -+ *respSize = 16; -+ *resp = tpm_malloc(*respSize); -+ memcpy(*resp,dur,16); - return TPM_FAIL; - - case TPM_CAP_PROP_ACTIVE_COUNTER: -diff -uprN tpm_emulator/tpm/tpm_cmd_handler.c vtpm/tpm/tpm_cmd_handler.c ---- tpm_emulator/tpm/tpm_cmd_handler.c 2008-02-27 16:35:41.000000000 -0500 -+++ vtpm/tpm/tpm_cmd_handler.c 2008-02-28 14:43:28.000000000 -0500 -@@ -94,12 +94,18 @@ void tpm_compute_out_param_digest(TPM_CO - sha1_ctx_t sha1; - UINT32 res = CPU_TO_BE32(rsp->result); - UINT32 ord = CPU_TO_BE32(ordinal); -+ UINT32 offset = 0; - - /* compute SHA1 hash */ - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*)&res, 4); - sha1_update(&sha1, (BYTE*)&ord, 4); -- sha1_update(&sha1, rsp->param, rsp->paramSize); -+ if (ordinal == TPM_ORD_LoadKey2) { -+ offset = 4; -+ } -+ if (rsp->paramSize - offset > 0) { -+ sha1_update(&sha1, rsp->param + offset, rsp->paramSize - offset); -+ } - sha1_final(&sha1, rsp->auth1->digest); - if (rsp->auth2 != NULL) memcpy(rsp->auth2->digest, - rsp->auth1->digest, sizeof(rsp->auth1->digest)); -diff -uprN tpm_emulator/tpm/tpm_data.c vtpm/tpm/tpm_data.c ---- tpm_emulator/tpm/tpm_data.c 2008-02-27 16:35:41.000000000 -0500 -+++ vtpm/tpm/tpm_data.c 2008-02-27 16:35:40.000000000 -0500 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -15,10 +16,15 @@ - * $Id: tpm_data.c 98 2006-05-07 14:16:29Z hstamer $ - */ - -+#include -+#include -+#include -+#include -+ - #include "tpm_emulator.h" - #include "tpm_structures.h" - #include "tpm_marshalling.h" --#include "linux_module.h" -+#include "vtpm_manager.h" - - TPM_DATA tpmData; - -@@ -158,45 +164,232 @@ void tpm_release_data(void) - #include - #include - #include --#include - --#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#ifdef VTPM_MUTLI_VM -+ #define DEV_FE "/dev/tpm" -+#else -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -+ -+ extern int dmi_id; -+ static char *vtpm_rx_name=NULL; -+#endif - - static int write_to_file(uint8_t *data, size_t data_length) - { -- int res; -- int fp; -- fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- res = write(fp, data, data_length); -- close(fp); -- return (res == data_length) ? 0 : -1; -+ int res, out_data_size, in_header_size; -+ BYTE *ptr, *out_data, *in_header; -+ UINT32 result, len, in_rsp_size; -+ UINT16 tag = VTPM_TAG_REQ; -+ -+ printf("Saving NVM\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; -+#endif -+ -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { -+ free(out_data); -+ return -1; -+ } -+ -+ printf("\tSending SaveNVM Command.\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); -+ } -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading SaveNVM header.\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_tx_fh); close(vtpm_rx_fh); -+#endif -+ -+ printf("\tFinishing up SaveNVM\n"); -+ return (0); - } - - static int read_from_file(uint8_t **data, size_t *data_length) - { -- int res; -- int fp, file_status; -- struct stat file_info; -- fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); -- file_status = fstat(fp, &file_info); -- if (file_status < 0) { -- close(fp); -- return -1; -- } -+ int res, out_data_size, in_header_size; -+ uint8_t *ptr, *out_data, *in_header; -+ UINT16 tag = VTPM_TAG_REQ; -+ UINT32 len, in_rsp_size, result; -+#ifdef VTPM_MUTLI_VM -+ int vtpm_rx_fh, vtpm_tx_fh; -+#endif -+ -+ printf("Loading NVM.\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } - -- *data_length = file_info.st_size; -- *data = tpm_malloc(*data_length); -- if (*data == NULL) { -- close(fp); -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { -+ free(out_data); - return -1; - } -- res = read(fp, *data, *data_length); -- close(fp); -+ -+ printf("\tSending LoadNVM command\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); -+ } -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading LoadNVM header\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+ // Read Encrypted data from VTPM Manager -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; -+ *data = (uint8_t *) malloc(*data_length); -+ -+ printf("\tReading clear data from LoadNVM.\n"); -+ res = read(vtpm_rx_fh, *data, *data_length); -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_rx_fh);close(vtpm_tx_fh); -+#endif -+ -+ printf("\tReturing from loading NVM\n"); - if (res != *data_length) { -- tpm_free(*data); -- return -1; -+ free(*data); -+ return -1; -+ } else { -+ return 0; - } -- return 0; -+ - } - - #else -diff -uprN tpm_emulator/tpmd.c vtpm/tpmd.c ---- tpm_emulator/tpmd.c 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/tpmd.c 2007-01-09 14:48:56.000000000 -0800 -@@ -21,12 +21,24 @@ - #include - #include - #include -+#include -+#include -+#include - - #include "tpm_emulator.h" -+#include "vtpm_manager.h" - --#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" --#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" -+#ifdef VTPM_MULTI_VM -+ #define DEV_BE "/dev/vtpm" -+#else -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" - -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" -+#endif -+ -+ int dmi_id; -+ - #define BUFFER_SIZE 2048 - - static int devurandom=0; -@@ -38,7 +50,7 @@ void get_random_bytes(void *buf, int nby - } - - if (read(devurandom, buf, nbytes) != nbytes) { -- printf("Can't get random number.\n"); -+ error("Can't get random number.\n"); - exit(-1); - } - } -@@ -52,105 +64,182 @@ uint64_t tpm_get_ticks(void) - - int main(int argc, char **argv) - { -- uint8_t in[BUFFER_SIZE], *out; -+ uint8_t type, in[BUFFER_SIZE], *out, *addressed_out; -+ char *vtpm_rx_file=NULL; - uint32_t out_size; - int in_size, written; -- int i; -- struct stat file_info; -+ int i, guest_id=-1; - -- int tpm_tx_fh=-1, tpm_rx_fh=-1; -+#ifndef VTPM_MULTI_VM -+ int sockfd = -1; -+ struct sockaddr_un addr; -+ struct sockaddr_un client_addr; -+ unsigned int client_length; -+ -+#endif -+ -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+#ifdef VTPM_MULTI_VM - if (argc < 2) { -- printf("Usage: tpmd clear|save|deactivated\n" ); -+ error("Usage: tpmd clear|save|deactivated\n" ); -+#else -+ if (argc < 4) { -+ error("Usage: tpmd clear|save|deactivated pvm|hvm vtpmid\n" ); -+#endif - return -1; - } - -+#ifndef VTPM_MULTI_VM -+ /* setup type of vm */ -+ if (!strcmp(argv[2], "pvm")) { -+ type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo -+ } else if (!strcmp(argv[2], "hvm")) { -+ type = VTPM_TYPE_HVM; // Get commands from qemu via socket -+ } else { -+ error("invalid vTPM type '%s'.\n", argv[2]); -+ } -+ -+ dmi_id = atoi(argv[3]); -+ -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); -+ } else { -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); -+ -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { -+ error("Unable to create socket. errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&addr, 0, sizeof(addr)); -+ addr.sun_family = AF_UNIX; -+ strcpy(addr.sun_path,vtpm_rx_file ); -+ unlink(addr.sun_path); -+ } -+#endif -+ -+#ifdef VTPM_MULTI_VM -+ info("Initializing tpm state: %s\n", argv[1]); -+#else -+ info("Initializing tpm state: %s, type: %s, id: %d\n", argv[1], argv[2], dmi_id); -+#endif -+ - /* initialize TPM emulator */ - if (!strcmp(argv[1], "clear")) { -- printf("Initializing tpm: %s\n", argv[1]); - tpm_emulator_init(1); -- } else if (!strcmp(argv[1], "save")) { -- printf("Initializing tpm: %s\n", argv[1]); -+ } else if (!strcmp(argv[1], "save")) { - tpm_emulator_init(2); - } else if (!strcmp(argv[1], "deactivated")) { -- printf("Initializing tpm: %s\n", argv[1]); - tpm_emulator_init(3); - } else { -- printf("invalid startup mode '%s'; must be 'clear', " -+ error("invalid startup mode '%s'; must be 'clear', " - "'save' (default) or 'deactivated", argv[1]); - return -1; - } -- -- if ( stat(TPM_RX_FNAME, &file_info) == -1) { -- if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { -- printf("Failed to create fifo %s.\n", TPM_RX_FNAME); -- return -1; -- } -- } -- -- if ( stat(TPM_TX_FNAME, &file_info) == -1) { -- if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { -- printf("Failed to create fifo %s.\n", TPM_TX_FNAME); -- return -1; -- } -- } -- -+ - while (1) { - abort_command: -- if (tpm_rx_fh < 0) { -- tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); -+#else -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); -+ } else { -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { -+ error("Unable to bind(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ if (listen(sockfd, 10) <0) { -+ error("Unable to listen(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&client_addr, 0, sizeof(client_addr)); -+ client_length = sizeof(client_addr); -+ -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); -+ } -+#endif - } - -- if (tpm_rx_fh < 0) { -- printf("ERROR: failed to open devices to listen to guest.\n"); -+ if (vtpm_rx_fh < 0) { -+ error("Failed to open devices to listen to guest.\n"); - return -1; - } - -- if (tpm_tx_fh < 0) { -- tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); -- } -- -- if (tpm_tx_fh < 0) { -- printf("ERROR: failed to open devices to respond to guest.\n"); -- return -1; -- } -- -- in_size = read(tpm_rx_fh, in, BUFFER_SIZE); -+ in_size = read(vtpm_rx_fh, in, BUFFER_SIZE); - if (in_size < 6) { // Magic size of minium TPM command -- printf("Recv[%d] to small: 0x", in_size); -+ info("Recv incomplete command of %d bytes.", in_size); - if (in_size <= 0) { -- close(tpm_rx_fh); -- tpm_rx_fh = -1; -+ close(vtpm_rx_fh); -+ vtpm_rx_fh = -1; - goto abort_command; - } - } else { -- printf("Recv[%d]: 0x", in_size); -+ debug_nostop("Recv[%d]: 0x", in_size); - for (i=0; i< in_size; i++) -- printf("%x ", in[i]); -- printf("\n"); -+ debug_more("%x ", in[i]); -+ debug_more("\n"); - } - -- -- if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { -- printf("ERROR: Handler Failed.\n"); -+ if (guest_id == -1) { -+ guest_id = *((uint32_t *) in); -+ } else { -+ if (guest_id != *((uint32_t *) in) ) { -+ error("WARNING: More than one guest attached\n"); -+ } -+ } -+ -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); -+ } // No need to open the other direction for HVM -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ error("Failed to open devices to respond to guest.\n"); -+ return -1; -+ } -+ -+ // Handle the command, but skip the domain id header -+ if (tpm_handle_command(in + sizeof(uint32_t), in_size - sizeof(uint32_t), &out, &out_size) != 0) { -+ error("Handler Failed.\n"); - } - -- written = write(tpm_tx_fh, out, out_size); -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_size); -+ *(uint32_t *) addressed_out = *(uint32_t *) in; -+ memcpy(addressed_out + sizeof(uint32_t), out, out_size); -+ -+ written = write(vtpm_tx_fh, addressed_out, out_size + sizeof(uint32_t)); - -- if (written != out_size ) { -- printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); -+ if (written != out_size + sizeof(uint32_t)) { -+ error("Part of response not written %d/%d.\n", written, out_size); - } else { -- printf("Sent[%Zu]: ", out_size); -+ debug_nostop("Sent[%Zu]: ", out_size + sizeof(uint32_t)); -+ for (i=0; i< out_size+ sizeof(uint32_t); i++) -+ debug_more("%x ", addressed_out[i]); -+ debug_more("\n"); - } -- for (i=0; i< out_size; i++) -- printf("%x ", out[i]); -- printf("\n"); - tpm_free(out); -+ tpm_free(addressed_out); - - } // loop - - tpm_emulator_shutdown(); - -- close(tpm_tx_fh); -- close(tpm_rx_fh); -+ close(vtpm_tx_fh); -+#ifndef VTPM_MUTLI_VM -+ close(vtpm_rx_fh); -+ free (vtpm_rx_file); -+#endif - - } diff --git a/tools/vtpm_manager/COPYING b/tools/vtpm_manager/COPYING deleted file mode 100644 index c4b86b7..0000000 --- a/tools/vtpm_manager/COPYING +++ /dev/null @@ -1,32 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== diff --git a/tools/vtpm_manager/Makefile b/tools/vtpm_manager/Makefile deleted file mode 100644 index 632f41b..0000000 --- a/tools/vtpm_manager/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -XEN_ROOT = $(CURDIR)/../.. - -# Base definitions and rules -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -SUBDIRS = crypto tcs util manager migration -OPENSSL_HEADER = /usr/include/openssl/crypto.h - -.PHONY: all clean install -all clean install: %: subdirs-% - -.PHONY: mrproper -mrproper: - @set -e; for subdir in $(SUBDIRS); do \ - $(MAKE) -C $$subdir $@; \ - done - - diff --git a/tools/vtpm_manager/README b/tools/vtpm_manager/README deleted file mode 100644 index f0d1e98..0000000 --- a/tools/vtpm_manager/README +++ /dev/null @@ -1,94 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -Directory Structure -=================== -tools/vtpm_manager/crypto -> crypto files -tools/vtpm_manager/TCS -> TCS implementation -tools/vtpm_manager/util -> Utility Library. Include disk-io and buffers. -tools/vtpm_manager/manager -> VTPM Manager - -Compile Flags -=================== -LOGGING_MODULES -> How extensive logging happens - see util/log.h for more info - -VTPM_MULTI_VM -> Defined: VTPMs run in their own VMs - Not Defined (default): VTPMs are processes - -# Debugging flags that may disappear without notice in the future - -DUMMY_BACKEND -> vtpm_manager listens on /tmp/in.fifo and - /tmp/out.fifo rather than backend - -MANUAL_DM_LAUNCH -> Must manually launch & kill VTPMs - -WELL_KNOWN_OWNER_AUTH -> Rather than randomly generating the password for the owner, - use a well known value. This is useful for debugging and for - poor bios which do not support clearing TPM if OwnerAuth is - lost. However this has no protection from malicious app - issuing a TPM_OwnerClear to wipe the TPM - -Requirements -============ -- xen-unstable -- vtpm frontend/backend driver patch -- OpenSSL Library - -Single-VM Flow -============================ -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. -- VTPM Manager listens to TPM BE. -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. -- When the manager receives the open message from the BE, it launches a vtpm -- Xend allows the VM to continue booting. -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. -- The fifo listener begins listening for the reply from vtpm for the request. -- Vtpm processes request and replies to manager over shared named fifo. -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. - -NOTES: -* SaveService SHOULD seal it's table before saving it to disk. However, - the current Xen infrastructure does not provide a mechanism for this to be - unsealed later. Specifically, the auth and wrapped key must be available ONLY - to the service, or it's not even worth encrypting - - In the future the vtpm manager will be protected by an early boot mechanism - that will allow for better protection of it's data. - -TODO: -- Timeout on crashed vtpms -- create lock for shared fifo for talking to vtpms. diff --git a/tools/vtpm_manager/Rules.mk b/tools/vtpm_manager/Rules.mk deleted file mode 100644 index 651772b..0000000 --- a/tools/vtpm_manager/Rules.mk +++ /dev/null @@ -1,59 +0,0 @@ -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) -include $(XEN_ROOT)/tools/Rules.mk - -# -# Tool definitions -# - -# General compiler flags -CFLAGS = -Werror -g3 - -# Generic project files -HDRS = $(wildcard *.h) -SRCS = $(wildcard *.c) -OBJS = $(patsubst %.c,%.o,$(SRCS)) - -# Generic (non-header) dependencies -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -$(OBJS): $(SRCS) - --include $(FILES) - -# Make sure these are just rules -.PHONY : all build install clean - -# -# Project-specific definitions -# - -# Need UNIX98 spec for pthread rwlocks -CFLAGS += -D_GNU_SOURCE - -# Logging Level. See utils/tools.h for usage -CFLAGS += -DLOGGING_MODULES="(BITMASK(VTPM_LOG_TCS)|BITMASK(VTPM_LOG_VTSP)|BITMASK(VTPM_LOG_VTPM))" - -# Silent Mode -#CFLAGS += -DLOGGING_MODULES=0x0 -#CFLAGS += -DLOGGING_MODULES=0xff - -# Use frontend/backend pairs between manager & DMs? -#CFLAGS += -DVTPM_MULTI_VM - -# vtpm_manager listens on fifo's rather than backend -#CFLAGS += -DDUMMY_BACKEND - -# TCS talks to fifo's rather than /dev/tpm. TPM Emulator assumed on fifos -#CFLAGS += -DDUMMY_TPM - -# Do not have manager launch DMs. -#CFLAGS += -DMANUAL_DM_LAUNCH - -# Fixed OwnerAuth -#CFLAGS += -DWELL_KNOWN_OWNER_AUTH - -# Include -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/crypto -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/util -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/tcs -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/manager diff --git a/tools/vtpm_manager/crypto/Makefile b/tools/vtpm_manager/crypto/Makefile deleted file mode 100644 index 13b61c9..0000000 --- a/tools/vtpm_manager/crypto/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = libtcpaCrypto.a - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - -.PHONY: clean -clean: - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(AR) rcs $(BIN) $(OBJS) diff --git a/tools/vtpm_manager/crypto/crypto.c b/tools/vtpm_manager/crypto/crypto.c deleted file mode 100644 index 7dae655..0000000 --- a/tools/vtpm_manager/crypto/crypto.c +++ /dev/null @@ -1,88 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// crypto.c -// -// This file will handle all the TPM Crypto functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include "crypto.h" -#include "log.h" - -/** - * Initialize cryptography library - * @rand: random seed - * @size: size of @rand - */ -void Crypto_Init(const BYTE* rand, int size) { - ERR_load_crypto_strings(); - CRYPTO_malloc_init(); - OpenSSL_add_all_algorithms(); - SYM_CIPHER = EVP_aes_128_cbc(); - RAND_poll(); - if (rand == NULL) - return; - - RAND_add(rand, size, size); -} - -/** - * Shutdown cryptography library - */ -void Crypto_Exit() { - ERR_free_strings(); - ERR_remove_state(0); - EVP_cleanup(); -} - - -/** - * Get random data - * @data: (OUT) Random data - * @size: Size of @data - */ -void Crypto_GetRandom(void* data, int size) { - int result; - - result = RAND_pseudo_bytes((BYTE*) data, size); - - if (result <= 0) - vtpmlogerror (VTPM_LOG_CRYPTO, "RAND_pseudo_bytes failed: %s\n", - ERR_error_string (ERR_get_error(), NULL)); -} diff --git a/tools/vtpm_manager/crypto/crypto.h b/tools/vtpm_manager/crypto/crypto.h deleted file mode 100644 index 488d4d6..0000000 --- a/tools/vtpm_manager/crypto/crypto.h +++ /dev/null @@ -1,175 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// crypto.h -// -// This file defines the TPM Crypto API -// -// ================================================================== - -#ifndef __CRYPTO_H__ -#define __CRYPTO_H__ - -#include -#include -#include - -#include "tcg.h" -#include "sym_crypto.h" - -#define CRYPTO_MAX_SIG_SIZE (2048 / 8) -#define CRYPTO_MAX_RSA_KEY_SIZE (4096 / 8) //in bytes - -#define OAEP_P "TCPA" -#define OAEP_P_SIZE 4 - -// Algorithms supported by crypto. Stored in CRYPTO_INFO.algorithmID -#define CRYPTO_ALGORITH_RSA 0x01 - -// Supported Encryption Schemes CRYPTO_INFO.encScheme -#define CRYPTO_ES_NONE 0x0001 -#define CRYPTO_ES_RSAESPKCSv15 0x0002 -#define CRYPTO_ES_RSAESOAEP_SHA1_MGF1 0x0003 - -// Supported Signature schemes CRYPTO_INFO.sigScheme -#define CRYPTO_SS_NONE 0x0001 -#define CRYPTO_SS_RSASSAPKCS1v15_SHA1 0x0002 -#define CRYPTO_SS_RSASSAPKCS1v15_DER 0x0003 - -typedef struct CRYPTO_INFO { - void *keyInfo; - UINT32 algorithmID; - UINT32 encScheme; - UINT32 sigScheme; -} CRYPTO_INFO; - - -void Crypto_Init(const BYTE* rand, int size); - -void Crypto_Exit(); - -void Crypto_GetRandom(void* data, int size); - -void Crypto_HMAC( const BYTE* text, - int text_len, - const BYTE* key, - int key_len, - BYTE* digest); - -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, - const buffer_t * key, - BYTE * o_digest); /* presumably of 20 bytes */ - -void Crypto_SHA1Full( const BYTE* text, - UINT32 size, - BYTE* hash); //Complete 3part SHA1 - -// o_hash needs to be large enough to hold the digest, ie 20 bytes -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, - BYTE * o_hash); - -void Crypto_SHA1Start(UINT32* maxNumBytes); -void Crypto_SHA1Update(int numBytes, const BYTE* hashData); -void Crypto_SHA1Complete( int hashDataSize, - const BYTE* hashData, - BYTE* hashValue); - -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, - /*in*/ UINT32 pubExpSize, - /*in*/ BYTE *pubExp, - /*out*/ UINT32 *privExpSize, - /*out*/ BYTE *privExp, - /*out*/ UINT32 *modulusSize, - /*out*/ BYTE *modulus, - /*out*/ CRYPTO_INFO *keys); - -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 privExpSize, - /*[IN]*/ BYTE *privExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - /*[OUT]*/ CRYPTO_INFO* cryptoInfo); - -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo); - -// -// symmetric pack and unpack operations -// -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, - BYTE ** io_buf, UINT32 * io_buflen); - -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, - BYTE * in, UINT32 len, - UINT32 * o_lenread); - - -// return 0 on success, -1 on error -int Crypto_RSAEnc( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData); - -// return 0 on success, -1 on error -int Crypto_RSADec( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData); - -// return 0 on success, -1 on error -int Crypto_RSASign( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *sigSize, - /*out*/ BYTE *sig); - -bool Crypto_RSAVerify( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - UINT32 sigSize, - BYTE *sig); - -//private: -int RSA_verify_DER(int dtype, unsigned char *m, unsigned int m_len, - unsigned char *sigbuf, unsigned int siglen, CRYPTO_INFO *key); - -int RSA_sign_DER(int type, unsigned char *m, unsigned int m_len, - unsigned char *sigret, unsigned int *siglen, CRYPTO_INFO *key); - -#endif // __CRYPTO_H__ diff --git a/tools/vtpm_manager/crypto/hash.c b/tools/vtpm_manager/crypto/hash.c deleted file mode 100644 index c73114a..0000000 --- a/tools/vtpm_manager/crypto/hash.c +++ /dev/null @@ -1,153 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// hash.c -// -// This file will handle all the TPM Hash functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "tcg.h" // for TPM_SUCCESS -#include "crypto.h" - -static SHA_CTX g_shaContext; - -void Crypto_HMAC( const BYTE* text, - int text_len, - const BYTE* key, - int key_len, - BYTE* digest) { - if (text == NULL || key == NULL || text_len == 0 || key_len == 0) - return; - - HMAC(EVP_sha1(), key, key_len, text, text_len, digest, NULL); -} - -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, - const buffer_t * key, - BYTE * o_digest) { /* presumably of 20 bytes */ - - Crypto_HMAC (text->bytes, text->size, - key->bytes, key->size, - o_digest); - - return TPM_SUCCESS; -} - - -/* - * SHA1 - * (OUT) Create a SHA1 hash of text. Calls all three SHA1 steps internally - */ -void Crypto_SHA1Full( const BYTE* text, - uint32_t size, - BYTE* hash) { - - if (text == NULL || size == 0) - return; - - // Run SHA1Start + SHAUpdate (if necessary) + SHAComplete - uint32_t maxBytes; // Not used for anything - Crypto_SHA1Start(&maxBytes); - - while (size > 64){ - Crypto_SHA1Update(64, text); - size -= 64; - text += 64; - } - - Crypto_SHA1Complete(size, text, hash); -} - -// same thing using buffer_t -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, - BYTE * o_digest) { - - if (buf->bytes == NULL || buf->size == 0) - return TPM_BAD_PARAMETER; - - Crypto_SHA1Full (buf->bytes, buf->size, o_digest); - - return TPM_SUCCESS; -} - - -/* - * Initialize SHA1 - * (OUT) Maximum number of bytes that can be sent to SHA1Update. - * Must be a multiple of 64 bytes. - */ -void Crypto_SHA1Start(uint32_t* maxNumBytes) { - int max = SHA_CBLOCK; - // Initialize the crypto library - SHA1_Init(&g_shaContext); - *maxNumBytes = max; -} - -/* - * Process SHA1 - * @numBytes: (IN) The number of bytes in hashData. - * Must be a multiple of 64 bytes. - * @hashData: (IN) Bytes to be hashed. - */ -void Crypto_SHA1Update(int numBytes, const BYTE* hashData) { - - if (hashData == NULL || numBytes == 0 || numBytes%64 != 0) - return; - - SHA1_Update(&g_shaContext, hashData, numBytes); -} - -/* - * Complete the SHA1 process - * @hashDataSize: (IN) Number of bytes in hashData. - * Must be a multiple of 64 bytes. - * @hashData: (IN) Final bytes to be hashed. - * @hashValue: (OUT) The output of the SHA-1 hash. - */ -void Crypto_SHA1Complete(int hashDataSize, - const BYTE* hashData, - BYTE* hashValue) { - SHA1_Update(&g_shaContext, hashData, hashDataSize); - SHA1_Final(hashValue, &g_shaContext); -} diff --git a/tools/vtpm_manager/crypto/rsa.c b/tools/vtpm_manager/crypto/rsa.c deleted file mode 100644 index 7737dc6..0000000 --- a/tools/vtpm_manager/crypto/rsa.c +++ /dev/null @@ -1,434 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// rsa.c -// -// This file will handle all the TPM RSA crypto functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include "tcg.h" -#include "buffer.h" -#include "crypto.h" -#include "log.h" - -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, - /*in*/ UINT32 pubExpSize, - /*in*/ BYTE *pubExp, - /*out*/ UINT32 *privExpSize, - /*out*/ BYTE *privExp, - /*out*/ UINT32 *modulusSize, - /*out*/ BYTE *modulus, - /*out*/ CRYPTO_INFO *keys) { - unsigned long e_value; - - if (pubExpSize == 0) // Default e = 2^16+1 - e_value = (0x01 << 16) + 1; - else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - e_value = (0x01 << 16) + 1; - } - - RSA *rsa = RSA_generate_key(keySize, e_value, NULL, NULL); - - if (keys) { - keys->keyInfo = rsa; - keys->algorithmID = CRYPTO_ALGORITH_RSA; - } - - if (modulus) *modulusSize = BN_bn2bin(rsa->n, modulus); - if (privExp) *privExpSize = BN_bn2bin(rsa->d, privExp); -} - -// Create a CRYPTO_INFO struct from the BYTE * key parts. -// If pubExp info is NULL, use TCG default. -// If there is a remainder while calculating the privExp, return FALSE. - -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 privExpSize, - /*[IN]*/ BYTE *privExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo) { - cryptoInfo->keyInfo = RSA_new(); - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - rsa->e = BN_new(); - - if (pubExpSize == 0) { // Default e = 2^16+1 - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } - - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); - rsa->d = BN_bin2bn(privExp, privExpSize, NULL); -} - -// Create a CRYPTO_INFO struct from the BYTE * key parts. -// If pubExp info is NULL, use TCG default. -// If there is a remainder while calculating the privExp, return FALSE. - -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo) { - cryptoInfo->keyInfo = RSA_new(); - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - rsa->e = BN_new(); - - if (pubExpSize == 0) { // Default e = 2^16+1 - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } - - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); - -} - -int Crypto_RSAEnc( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData) { - RSA *rsa = (RSA *) key->keyInfo; - UINT32 paddedDataSize = RSA_size (rsa); - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); - int rc; - - if (paddedData == NULL) - return -1; - - *outDataSize = 0; - - switch (key->encScheme) { - case CRYPTO_ES_RSAESPKCSv15: - if (RSA_padding_add_PKCS1_type_2(paddedData, paddedDataSize, inData, inDataSize) <= 0) { - rc = -1; - goto abort_egress; - } - break; - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: - if (RSA_padding_add_PKCS1_OAEP(paddedData,paddedDataSize,inData,inDataSize, (BYTE *) OAEP_P,OAEP_P_SIZE) <= 0 ) { - rc = -1; - goto abort_egress; - } - break; - default: - rc = -1; - goto abort_egress; - } - - rc = RSA_public_encrypt(paddedDataSize, paddedData, outData, rsa, RSA_NO_PADDING); - if (rc == -1) - goto abort_egress; - - *outDataSize = rc; - - if (rc > 0) rc = 0; - - goto egress; - - abort_egress: - egress: - - if (paddedData) - free (paddedData); - return rc; - -} - -int Crypto_RSADec( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData) { - - RSA *rsa = (RSA *) key->keyInfo; - UINT32 paddedDataSize = RSA_size (rsa); - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); - int rc; - - if (paddedData == NULL) - goto abort_egress; - - rc = RSA_private_decrypt(inDataSize, inData, paddedData, rsa, RSA_NO_PADDING); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_private_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - - paddedDataSize = rc; - - switch (key->encScheme) { - case CRYPTO_ES_RSAESPKCSv15: - rc = RSA_padding_check_PKCS1_type_2 (outData, paddedDataSize, - paddedData + 1, paddedDataSize - 1, - RSA_size(rsa)); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_type_2: %s\n", - ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - *outDataSize = rc; - break; - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: - rc = RSA_padding_check_PKCS1_OAEP(outData, paddedDataSize, - paddedData + 1, paddedDataSize - 1, - RSA_size(rsa), - (BYTE *) OAEP_P, OAEP_P_SIZE); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_OAEP: %s\n", - ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - *outDataSize = rc; - break; - default: - *outDataSize = 0; - } - - free(paddedData); paddedData = NULL; - goto egress; - - abort_egress: - - if (paddedData) - free (paddedData); - return -1; - - egress: - return 0; -} - -// Signs either a SHA1 digest of a message or a DER encoding of a message -// Textual messages MUST be encoded or Hashed before sending into this function -// It will NOT SHA the message. -int Crypto_RSASign( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *sigSize, - /*out*/ BYTE *sig) { - int status; - unsigned int intSigSize; - - switch(key->sigScheme) { - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: - status = RSA_sign(NID_sha1, inData, inDataSize, sig, &intSigSize, (RSA *) key->keyInfo); - break; - case CRYPTO_SS_RSASSAPKCS1v15_DER: - // status = Crypto_RSA_sign_DER(NID_md5_sha1, inData, inDataSize, sig, &intSigSize, key); - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); - status = 0; - break; - default: - status = 0; - } - - if (status == 0) { - *sigSize = 0; - vtpmlogerror(VTPM_LOG_CRYPTO, "%s\n", ERR_error_string(ERR_get_error(), NULL)); - return -1; - } - - *sigSize = (UINT32) intSigSize; - return 0; -} - -bool Crypto_RSAVerify( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - UINT32 sigSize, - BYTE *sig) { - int status; - - switch(key->sigScheme){ - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: - status = RSA_verify(NID_sha1, inData, inDataSize, sig, sigSize, (RSA *) key->keyInfo); - break; - case CRYPTO_SS_RSASSAPKCS1v15_DER: - //status = Crypto_RSA_verify_DER(NID_md5_sha1, inData, inDataSize, sig, sigSize, key); - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); - status = 0; - break; - default: - status = 0; - } - - if (status) - return(1); - else { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA verify: %s\n", ERR_error_string(ERR_get_error(), NULL)); - return(0); - } - -} - -// helper which packs everything into a BIO! - -// packs the parameters first, then the private key, then the public key -// if *io_buf is NULL, allocate it here as needed. otherwise its size is in -// *io_buflen -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, - BYTE ** io_buf, UINT32 * io_buflen) { - TPM_RESULT status = TPM_SUCCESS; - BYTE * buf; - long len, outlen = *io_buflen; - - const long PARAMSLEN = 3*sizeof(UINT32); - - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - BIO *mem = BIO_new(BIO_s_mem()); - - - // write the openssl keys to the BIO - if ( i2d_RSAPrivateKey_bio (mem, rsa) == 0 ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_SIZE); - } - if ( i2d_RSAPublicKey_bio (mem, rsa) == 0 ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_SIZE); - } - - // get the buffer out - len = BIO_get_mem_data (mem, &buf); - - // see if we need to allocate a return buffer - if (*io_buf == NULL) { - *io_buf = (BYTE*) malloc (PARAMSLEN + len); - if (*io_buf == NULL) - ERRORDIE (TPM_SIZE); - } else { // *io_buf is already allocated - if (outlen < len + PARAMSLEN) - ERRORDIE (TPM_SIZE); // but not large enough! - } - - // copy over the parameters (three UINT32's starting at algorithmID) - memcpy (*io_buf, &cryptoInfo->algorithmID, PARAMSLEN); - - // copy over the DER keys - memcpy (*io_buf + PARAMSLEN, buf, len); - - *io_buflen = len + PARAMSLEN; - - goto egress; - - - abort_egress: - egress: - - BIO_free (mem); - - return status; -} - - - -// sets up ci, and returns the number of bytes read in o_lenread -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, - BYTE * in, UINT32 len, - UINT32 * o_lenread) { - - TPM_RESULT status = TPM_SUCCESS; - long l; - BIO *mem; - RSA *rsa; - - // first load up the params - l = 3 * sizeof(UINT32); - memcpy (&ci->algorithmID, in, l); - len -= l; - in += l; - - // and now the openssl keys, private first - mem = BIO_new_mem_buf (in, len); - - if ( (rsa = d2i_RSAPrivateKey_bio (mem, NULL)) == NULL ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_BAD_PARAMETER); - } - // now use the same RSA object and fill in the private key - if ( d2i_RSAPublicKey_bio (mem, &rsa) == NULL ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_BAD_PARAMETER); - } - - ci->keyInfo = rsa; // needs to be freed somehow later - - // FIXME: havent figured out yet how to tell how many bytes were read in the - // above oprations! so o_lenread is not set - - goto egress; - - abort_egress: - egress: - - BIO_free (mem); - - return status; -} diff --git a/tools/vtpm_manager/crypto/sym_crypto.c b/tools/vtpm_manager/crypto/sym_crypto.c deleted file mode 100644 index 3d86e19..0000000 --- a/tools/vtpm_manager/crypto/sym_crypto.c +++ /dev/null @@ -1,237 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// sym_crypto.c -// -// Symmetric crypto portion of crypto -// -// ================================================================== - -#include -#include - -#include "tcg.h" -#include "sym_crypto.h" - -typedef enum crypt_op_type_t { - CRYPT_ENCRYPT, - CRYPT_DECRYPT -} crypt_op_type_t; - -TPM_RESULT ossl_symcrypto_op (symkey_t* key, - const buffer_t* in, - const buffer_t* iv, - buffer_t * out, - crypt_op_type_t optype); - - -// this is initialized in Crypto_Init() -const EVP_CIPHER * SYM_CIPHER = NULL; - -const BYTE ZERO_IV[EVP_MAX_IV_LENGTH] = {0}; - - -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits) { - TPM_RESULT status = TPM_SUCCESS; - - EVP_CIPHER_CTX_init (&key->context); - - key->cipher = SYM_CIPHER; - - TPMTRYRETURN( buffer_init_copy (&key->key, keybits)); - - goto egress; - - abort_egress: - EVP_CIPHER_CTX_cleanup (&key->context); - - egress: - - return status; -} - - - -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key) { - int res; - TPM_RESULT status = TPM_SUCCESS; - - // hmm, EVP_CIPHER_CTX_init does not return a value - EVP_CIPHER_CTX_init (&key->context); - - key->cipher = SYM_CIPHER; - - TPMTRYRETURN( buffer_init (&key->key, EVP_CIPHER_key_length(key->cipher), NULL)) ; - - // and generate the key material - res = RAND_pseudo_bytes (key->key.bytes, key->key.size); - if (res < 0) - ERRORDIE (TPM_SHORTRANDOM); - - - goto egress; - - abort_egress: - EVP_CIPHER_CTX_cleanup (&key->context); - buffer_free (&key->key); - - egress: - return status; -} - - -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, - const buffer_t* clear, - buffer_t* o_cipher) { - TPM_RESULT status = TPM_SUCCESS; - - buffer_t iv, cipher_alias; - - buffer_init_const (&iv, EVP_MAX_IV_LENGTH, ZERO_IV); - - buffer_init (o_cipher, - clear->size + - EVP_CIPHER_iv_length(key->cipher) + - EVP_CIPHER_block_size (key->cipher), - 0); - - // copy the IV into the front - buffer_copy (o_cipher, &iv); - - // make an alias into which we'll put the ciphertext - buffer_init_alias (&cipher_alias, o_cipher, EVP_CIPHER_iv_length(key->cipher), 0); - - TPMTRYRETURN( ossl_symcrypto_op (key, clear, &iv, &cipher_alias, CRYPT_ENCRYPT) ); - - // set the output size correctly - o_cipher->size += cipher_alias.size; - - goto egress; - - abort_egress: - - egress: - - return status; - -} - - - -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, - const buffer_t* cipher, - buffer_t* o_clear) { - TPM_RESULT status = TPM_SUCCESS; - - buffer_t iv, cipher_alias; - - // alias for the IV - buffer_init_alias (&iv, cipher, 0, EVP_CIPHER_iv_length(key->cipher)); - - // make an alias to where the ciphertext is, after the IV - buffer_init_alias (&cipher_alias, cipher, EVP_CIPHER_iv_length(key->cipher), 0); - - // prepare the output buffer - TPMTRYRETURN( buffer_init (o_clear, - cipher->size - - EVP_CIPHER_iv_length(key->cipher) - + EVP_CIPHER_block_size(key->cipher), - 0) ); - - // and decrypt - TPMTRYRETURN ( ossl_symcrypto_op (key, &cipher_alias, &iv, o_clear, CRYPT_DECRYPT) ); - - goto egress; - - abort_egress: - buffer_free (o_clear); - - egress: - - return status; -} - - - -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key) { - buffer_memset (&key->key, 0); - buffer_free (&key->key); - - EVP_CIPHER_CTX_cleanup (&key->context); - - return TPM_SUCCESS; -} - - -TPM_RESULT ossl_symcrypto_op (symkey_t* key, - const buffer_t* in, - const buffer_t* iv, - buffer_t * out, - crypt_op_type_t optype) { - TPM_RESULT status = TPM_SUCCESS; - - int inlen, outlen; - tpm_size_t running; - - if ( ! EVP_CipherInit_ex (&key->context, - key->cipher, NULL, key->key.bytes, iv->bytes, - optype == CRYPT_ENCRYPT ? 1 : 0) ) - ERRORDIE (TPM_FAIL); - - - - inlen = in->size; - - outlen = 0; - running = 0; - - - if ( ! EVP_CipherUpdate (&key->context, out->bytes, &outlen, in->bytes, inlen) ) - ERRORDIE (TPM_FAIL); - - running += outlen; - - if ( ! EVP_CipherFinal_ex (&key->context, out->bytes + running, &outlen) ) - ERRORDIE (TPM_FAIL); - - running += outlen; - - out->size = running; - - goto egress; - - abort_egress: - egress: - - return status; -} diff --git a/tools/vtpm_manager/crypto/sym_crypto.h b/tools/vtpm_manager/crypto/sym_crypto.h deleted file mode 100644 index 7fb59a8..0000000 --- a/tools/vtpm_manager/crypto/sym_crypto.h +++ /dev/null @@ -1,72 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// sym_crypto.h -// -// Symmetric Crypto -// -// ================================================================== - -#ifndef _SYM_CRYPTO_H -#define _SYM_CRYPTO_H - -#include -#include "buffer.h" - -typedef struct symkey_t { - buffer_t key; - - EVP_CIPHER_CTX context; - const EVP_CIPHER * cipher; -} symkey_t; - -extern const EVP_CIPHER * SYM_CIPHER; - -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key); - -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits); - - -// these functions will allocate their output buffers -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, - const buffer_t* clear, - buffer_t* o_cipher); - -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, - const buffer_t* cipher, - buffer_t* o_clear); - -// only free the internal parts, not the 'key' ptr -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key); - -#endif /* _SYM_CRYPTO_H */ diff --git a/tools/vtpm_manager/manager/Makefile b/tools/vtpm_manager/manager/Makefile deleted file mode 100644 index a33c18a..0000000 --- a/tools/vtpm_manager/manager/Makefile +++ /dev/null @@ -1,38 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = vtpm_managerd - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - if [ ! -d "$(DESTDIR)/var/vtpm/fifos" ]; \ - then mkdir -p $(DESTDIR)/var/vtpm/fifos; \ - fi - if [ ! -d "$(DESTDIR)/var/vtpm/socks" ]; \ - then mkdir -p $(DESTDIR)/var/vtpm/socks; \ - fi - $(INSTALL_PROG) $(BIN) $(DESTDIR)$(BINDIR) - -.PHONY: clean -clean: - rm -f $(BIN) - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ - -# libraries -LIBS += ../tcs/libTCS.a ../util/libTCGUtils.a ../crypto/libtcpaCrypto.a -LIBS += -lcrypto $(PTHREAD_LIBS) -lm -CFLAGS += $(PTHREAD_CFLAGS) -LDFLAGS += $(PTHREAD_LDFLAGS) diff --git a/tools/vtpm_manager/manager/dmictl.c b/tools/vtpm_manager/manager/dmictl.c deleted file mode 100644 index 5c3cf7e..0000000 --- a/tools/vtpm_manager/manager/dmictl.c +++ /dev/null @@ -1,266 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// dmictl.c -// -// Functions for creating and destroying DMIs -// -// ================================================================== - -#include -#include -#include - -#include "vtpmpriv.h" -#include "bsg.h" -#include "buffer.h" -#include "log.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "vtpm_ipc.h" - -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" - -// if dmi_res is non-null, then return a pointer to new object. -// Also, this does not fill in the measurements. They should be filled by -// design dependent code or saveNVM -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE dmi_type, VTPM_DMI_RESOURCE **dmi_res) { - - TPM_RESULT status=TPM_SUCCESS; - VTPM_DMI_RESOURCE *new_dmi=NULL; - UINT32 *dmi_id_key=NULL; - - if ((new_dmi = (VTPM_DMI_RESOURCE *) malloc (sizeof(VTPM_DMI_RESOURCE))) == NULL) { - status = TPM_RESOURCES; - goto abort_egress; - } - memset(new_dmi, 0, sizeof(VTPM_DMI_RESOURCE)); - new_dmi->dmi_id = dmi_id; - new_dmi->dmi_type = dmi_type; - new_dmi->connected = FALSE; - new_dmi->TCSContext = 0; - - new_dmi->NVMLocation = (char *) malloc(11 + strlen(DMI_NVM_FILE)); - sprintf(new_dmi->NVMLocation, DMI_NVM_FILE, (uint32_t) new_dmi->dmi_id); - - if ((dmi_id_key = (UINT32 *) malloc (sizeof(UINT32))) == NULL) { - status = TPM_RESOURCES; - goto abort_egress; - } - *dmi_id_key = new_dmi->dmi_id; - - // install into map - if (!hashtable_insert(vtpm_globals->dmi_map, dmi_id_key, new_dmi)){ - vtpmlogerror(VTPM_LOG_VTPM, "Failed to insert instance into table. Aborting.\n", dmi_id); - status = TPM_FAIL; - goto abort_egress; - } - - if (dmi_res) - *dmi_res = new_dmi; - - goto egress; - - abort_egress: - if (new_dmi) { - free(new_dmi->NVMLocation); - free(new_dmi); - } - free(dmi_id_key); - - egress: - return status; -} - -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res) { - if (dmi_res == NULL) - return TPM_SUCCESS; - - if (dmi_res->dmi_id == VTPM_CTL_DM) - return(TPM_BAD_PARAMETER); - - TCS_CloseContext(dmi_res->TCSContext); - dmi_res->connected = FALSE; - - vtpm_globals->connected_dmis--; - - return (VTPM_Close_DMI_Extra(dmi_res) ); -} - -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf) { - - VTPM_DMI_RESOURCE *new_dmi=NULL; - TPM_RESULT status=TPM_FAIL; - BYTE dmi_type, vm_type, startup_mode; - UINT32 dmi_id; - - if (param_buf == NULL) { // Assume creation of Dom 0 control - dmi_type = VTPM_TYPE_NON_MIGRATABLE; - dmi_id = VTPM_CTL_DM; - } else if (buffer_len(param_buf) != sizeof(BYTE) * 3 + sizeof(UINT32)) { - vtpmloginfo(VTPM_LOG_VTPM, "New DMI command wrong length: %d.\n", buffer_len(param_buf)); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } else { - vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0 - BSG_UnpackList( param_buf->bytes, 4, - BSG_TYPE_BYTE, &dmi_type, - BSG_TYPE_BYTE, &startup_mode, - BSG_TYPE_BYTE, &vm_type, - BSG_TYPE_UINT32, &dmi_id); - } - - if ((dmi_type != VTPM_TYPE_NON_MIGRATABLE) && (dmi_type != VTPM_TYPE_MIGRATABLE)) { - vtpmlogerror(VTPM_LOG_VTPM, "Creation of VTPM with illegal type.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - new_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (new_dmi == NULL) { - vtpmloginfo(VTPM_LOG_VTPM, "Creating new DMI instance %d attached.\n", dmi_id ); - // Brand New DMI. Initialize the persistent pieces - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &new_dmi) ); - } else - vtpmloginfo(VTPM_LOG_VTPM, "Re-attaching DMI instance %d.\n", dmi_id); - - if (new_dmi->connected) { - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach, currently attached instance %d. Ignoring\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (new_dmi->dmi_type == VTPM_TYPE_MIGRATED) { - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach previously migrated instance %d without recovering first. Ignoring\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Initialize the Non-persistent pieces - TPMTRYRETURN( TCS_OpenContext(&new_dmi->TCSContext) ); - - new_dmi->connected = TRUE; - - // Design specific new DMI code. - // Includes: create IPCs, Measuring DMI, and maybe launching DMI - TPMTRYRETURN(VTPM_New_DMI_Extra(new_dmi, vm_type, startup_mode) ); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create DMI id=%d due to status=%s. Cleaning.\n", dmi_id, tpm_get_error_name(status)); - close_dmi(new_dmi ); - - egress: - return status; -} - -TPM_RESULT VTPM_Handle_Close_DMI( const buffer_t *param_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *dmi_res=NULL; - UINT32 dmi_id; - - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size."); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - BSG_UnpackList( param_buf->bytes, 1, - BSG_TYPE_UINT32, &dmi_id); - - vtpmloginfo(VTPM_LOG_VTPM, "Closing DMI %d.\n", dmi_id); - - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (dmi_res == NULL ) { - vtpmlogerror(VTPM_LOG_VTPM, "Trying to close nonexistent DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (!dmi_res->connected) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-connected DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Close Dmi - TPMTRYRETURN(close_dmi( dmi_res )); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} - -TPM_RESULT VTPM_Handle_Delete_DMI( const buffer_t *param_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *dmi_res=NULL; - UINT32 dmi_id; - - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - BSG_UnpackList( param_buf->bytes, 1, - BSG_TYPE_UINT32, &dmi_id); - - vtpmloginfo(VTPM_LOG_VTPM, "Deleting DMI %d.\n", dmi_id); - - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_remove(vtpm_globals->dmi_map, &dmi_id); - if (dmi_res == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-existent DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - //vtpm scripts delete file dmi_res->NVMLocation for us - - // Close DMI first - TPMTRYRETURN(close_dmi( dmi_res )); - free ( dmi_res ); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} diff --git a/tools/vtpm_manager/manager/migration.c b/tools/vtpm_manager/manager/migration.c deleted file mode 100644 index 54da708..0000000 --- a/tools/vtpm_manager/manager/migration.c +++ /dev/null @@ -1,307 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// dmictl.c -// -// Functions for creating and destroying DMIs -// -// ================================================================== - -#include -#include -#include - -#include "vtpmpriv.h" -#include "bsg.h" -#include "buffer.h" -#include "log.h" -#include "hashtable.h" - -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *mig_dmi=NULL; - UINT32 dmi_id; - buffer_t dmi_state_abuf = NULL_BUF, enc_dmi_abuf = NULL_BUF, clear_dmi_blob = NULL_BUF; - - if (param_buf == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - struct pack_buf_t enc_dmi_state_pack; - - BSG_UnpackList(param_buf->bytes, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TPM_SIZE32_DATA, &enc_dmi_state_pack) ; - - vtpmloginfo(VTPM_LOG_VTPM, "Migrating VTPM in dmi %d.\n", dmi_id); - - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (mig_dmi) { - vtpmlogerror(VTPM_LOG_VTPM, "Incoming VTPM claims unavailable id: %d.\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** UnBind Blob **/ - TPMTRYRETURN( buffer_init_alias_convert( &enc_dmi_abuf, - enc_dmi_state_pack.size, - enc_dmi_state_pack.data) ); - - TPMTRYRETURN( envelope_decrypt( &enc_dmi_abuf, - vtpm_globals->manager_tcs_handle, - vtpm_globals->storageKeyHandle, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - &clear_dmi_blob) ); - - // Create new dmi - TPMTRYRETURN( init_dmi(dmi_id, VTPM_TYPE_MIGRATABLE, &mig_dmi ) ); - - /** Open Blob **/ - struct pack_buf_t dmi_state_pack; - - BSG_UnpackList(clear_dmi_blob.bytes, 2, - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, - BSG_TPM_SIZE32_DATA, &dmi_state_pack); - - TPMTRYRETURN( buffer_init_alias_convert(&dmi_state_abuf, - dmi_state_pack.size, - dmi_state_pack.data) ); - - TPMTRYRETURN( VTPM_Handle_Save_NVM(mig_dmi, &dmi_state_abuf, NULL ) ); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration IN of instance %d failed because of %s.\n", dmi_id, tpm_get_error_name(status) ); - - egress: - buffer_free(&clear_dmi_blob); - buffer_free(&dmi_state_abuf); - - return status; -} - -TPM_RESULT VTPM_Handle_Migrate_Out( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *mig_dmi; - UINT32 dmi_id; - VTPM_MIGKEY_LIST *last_mig, *mig_key; - buffer_t dmi_state=NULL_BUF, clear_dmi_blob=NULL_BUF; - - if (param_buf == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - struct pack_buf_t name_pack; - - BSG_UnpackList( param_buf->bytes, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TPM_SIZE32_DATA, &name_pack); - - vtpmloginfo(VTPM_LOG_VTPM, "Migrating out dmi %d.\n", dmi_id); - - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (mig_dmi == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Non-existent VTPM instance (%d) in migration.\n", dmi_id ); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (mig_dmi->dmi_type != VTPM_TYPE_MIGRATABLE) { - vtpmlogerror(VTPM_LOG_VTPM, "Bad VTPM type (%d) in migration of instance (%d).\n", mig_dmi->dmi_type, dmi_id ); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** Find migration key for dest **/ - last_mig = NULL; - mig_key = vtpm_globals->mig_keys; - while (mig_key != NULL) { - if (mig_key->name_size == name_pack.size) - if (memcmp(mig_key->name, name_pack.data, name_pack.size) == 0) { - break; - } - - last_mig = mig_key; - mig_key = mig_key->next; - } - - if (!mig_key) { - vtpmlogerror(VTPM_LOG_VTPM, "Unknown Migration target host.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** Mark vtpm as migrated **/ - mig_dmi->dmi_type = VTPM_TYPE_MIGRATED; - - /** Build Blob **/ - TPMTRYRETURN( VTPM_Handle_Load_NVM(mig_dmi, NULL, &dmi_state) ); - - TPMTRYRETURN( buffer_init(&clear_dmi_blob, sizeof(TPM_DIGEST) + sizeof(UINT32) + buffer_len(&dmi_state), NULL ) ); - - struct pack_constbuf_t dmi_state_pack; - - dmi_state_pack.size = buffer_len(&dmi_state); - dmi_state_pack.data = dmi_state.bytes; - - BSG_PackList(clear_dmi_blob.bytes, 2, - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, - BSG_TPM_SIZE32_DATA, &dmi_state_pack); - - /** Bind Blob **/ - TPMTRYRETURN( envelope_encrypt( &clear_dmi_blob, - &mig_key->key, - result_buf) ); - - if (last_mig) - last_mig->next = mig_key->next; - else - vtpm_globals->mig_keys = mig_key->next; - - free(mig_key->name); - free(mig_key); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration OUT of instance %d failed because of %s. Migratoin recovery may be needed.\n", dmi_id, tpm_get_error_name(status) ); - - //TODO: Create and implement a policy for what happens to mig_key on failed migrations. - - egress: - - buffer_free(&clear_dmi_blob); - buffer_free(&dmi_state); - - return status; -} - - -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - - vtpmloginfo(VTPM_LOG_VTPM, "Getting Migration Public Key.\n"); - - struct pack_buf_t pubkey_exp_pack, pubkey_mod_pack; - TPM_KEY mig_key; - - // Unpack/return key structure - BSG_Unpack(BSG_TPM_KEY, vtpm_globals->storageKeyWrap.bytes , &mig_key); - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - mig_key.algorithmParms.parms, - &rsaKeyParms); - - pubkey_exp_pack.size = rsaKeyParms.exponentSize; - pubkey_exp_pack.data = rsaKeyParms.exponent; - pubkey_mod_pack.size = mig_key.pubKey.keyLength; - pubkey_mod_pack.data = mig_key.pubKey.key; - - TPMTRYRETURN( buffer_init( result_buf, 2*sizeof(UINT32) + - pubkey_exp_pack.size + - pubkey_mod_pack.size, NULL ) ); - - BSG_PackList( result_buf->bytes, 2, - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); - - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Get Migration Key failed because of %s.\n", tpm_get_error_name(status) ); - egress: - - return status; -} - -TPM_RESULT VTPM_Handle_Load_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_MIGKEY_LIST *mig_key; - - vtpmloginfo(VTPM_LOG_VTPM, "Loading Migration Public Key.\n"); - - //FIXME: Review all uses of unpacking pack_buf_t and ensure free. - //FIXME: Review all declarations/initializations of buffer_t that could have a goto that skips them and then tries to free them - - struct pack_buf_t name_pack, pubkey_exp_pack, pubkey_mod_pack; - - //FIXME: scan list and verify name is not already in the list - - BSG_UnpackList( param_buf->bytes, 3, - BSG_TPM_SIZE32_DATA, &name_pack, - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); - - //TODO: Maintain a persistent list for pub_keys. - //TODO: Verify pub_key is trusted - - mig_key = (VTPM_MIGKEY_LIST *) malloc(sizeof(VTPM_MIGKEY_LIST)); - memset(mig_key, 0, sizeof(VTPM_MIGKEY_LIST) ); - mig_key->name_size = name_pack.size; - mig_key->name = name_pack.data; - - mig_key->key.encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - Crypto_RSABuildCryptoInfoPublic( pubkey_exp_pack.size, - pubkey_exp_pack.data, - pubkey_mod_pack.size, - pubkey_mod_pack.data, - &mig_key->key); - - - mig_key->next = vtpm_globals->mig_keys; - vtpm_globals->mig_keys = mig_key; - - // free(name_pack.data); Do not free. data is now part of mig_key. - free(pubkey_exp_pack.data); - free(pubkey_mod_pack.data); - - return TPM_SUCCESS; -} diff --git a/tools/vtpm_manager/manager/securestorage.c b/tools/vtpm_manager/manager/securestorage.c deleted file mode 100644 index d5e6ffd..0000000 --- a/tools/vtpm_manager/manager/securestorage.c +++ /dev/null @@ -1,512 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// securestorage.c -// -// Functions regarding securely storing DMI secrets. -// -// ================================================================== - -#include -#include -#include -#include -#include - -#include "tcg.h" -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "crypto.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "buffer.h" -#include "log.h" - -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, - CRYPTO_INFO *asymkey, - buffer_t *sealed_data) { - TPM_RESULT status = TPM_SUCCESS; - symkey_t symkey; - buffer_t data_cipher = NULL_BUF, - symkey_cipher = NULL_BUF; - - UINT32 i; - struct pack_constbuf_t symkey_cipher32, data_cipher32; - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Input[%d]: 0x", buffer_len(inbuf)); - for (i=0; i< buffer_len(inbuf); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", inbuf->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - // Generate a sym key and encrypt state with it - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_genkey (&symkey) ); - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_encrypt (&symkey, inbuf, &data_cipher) ); - - // Encrypt symmetric key - TPMTRYRETURN( VTSP_Bind( asymkey, - &symkey.key, - &symkey_cipher) ); - - // Create output blob: symkey_size + symkey_cipher + state_cipher_size + state_cipher - - symkey_cipher32.size = buffer_len(&symkey_cipher); - symkey_cipher32.data = symkey_cipher.bytes; - - data_cipher32.size = buffer_len(&data_cipher); - data_cipher32.data = data_cipher.bytes; - - TPMTRYRETURN( buffer_init(sealed_data, 2 * sizeof(UINT32) + symkey_cipher32.size + data_cipher32.size, NULL)); - - BSG_PackList(sealed_data->bytes, 2, - BSG_TPM_SIZE32_DATA, &symkey_cipher32, - BSG_TPM_SIZE32_DATA, &data_cipher32); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved %d bytes of E(symkey) + %d bytes of E(data)\n", buffer_len(&symkey_cipher), buffer_len(&data_cipher)); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Output[%d]: 0x", buffer_len(sealed_data)); - for (i=0; i< buffer_len(sealed_data); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", sealed_data->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope encrypt\n."); - - egress: - - buffer_free ( &data_cipher); - buffer_free ( &symkey_cipher); - Crypto_symcrypto_freekey (&symkey); - - return status; -} - -TPM_RESULT envelope_decrypt(const buffer_t *cipher, - TCS_CONTEXT_HANDLE TCSContext, - TPM_HANDLE keyHandle, - const TPM_AUTHDATA *key_usage_auth, - buffer_t *unsealed_data) { - - TPM_RESULT status = TPM_SUCCESS; - symkey_t symkey; - buffer_t data_cipher = NULL_BUF, - symkey_clear = NULL_BUF, - symkey_cipher = NULL_BUF; - struct pack_buf_t symkey_cipher32, data_cipher32; - int i; - - memset(&symkey, 0, sizeof(symkey_t)); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypt Input[%d]: 0x", buffer_len(cipher) ); - for (i=0; i< buffer_len(cipher); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cipher->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - BSG_UnpackList(cipher->bytes, 2, - BSG_TPM_SIZE32_DATA, &symkey_cipher32, - BSG_TPM_SIZE32_DATA, &data_cipher32); - - TPMTRYRETURN( buffer_init_alias_convert (&symkey_cipher, - symkey_cipher32.size, - symkey_cipher32.data) ); - - TPMTRYRETURN( buffer_init_alias_convert (&data_cipher, - data_cipher32.size, - data_cipher32.data) ); - - // Decrypt Symmetric Key - TPMTRYRETURN( VTSP_Unbind( TCSContext, - keyHandle, - &symkey_cipher, - key_usage_auth, - &symkey_clear, - &(vtpm_globals->keyAuth) ) ); - - // create symmetric key using saved bits - Crypto_symcrypto_initkey (&symkey, &symkey_clear); - - // Decrypt State - TPMTRY(TPM_DECRYPT_ERROR, Crypto_symcrypto_decrypt (&symkey, &data_cipher, unsealed_data) ); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypte Output[%d]: 0x", buffer_len(unsealed_data)); - for (i=0; i< buffer_len(unsealed_data); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", unsealed_data->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope decrypt data\n."); - - egress: - buffer_free ( &data_cipher); - buffer_free ( &symkey_clear); - buffer_free ( &symkey_cipher); - Crypto_symcrypto_freekey (&symkey); - - return status; -} - -TPM_RESULT VTPM_Handle_Save_NVM(VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - int fh; - long bytes_written; - buffer_t sealed_NVM = NULL_BUF; - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Saving %d bytes of NVM.\n", buffer_len(inbuf)); - - TPMTRYRETURN( envelope_encrypt(inbuf, - &vtpm_globals->storageKey, - &sealed_NVM) ); - - // Write sealed blob off disk from NVMLocation - // TODO: How to properly return from these. Do we care if we return failure - // after writing the file? We can't get the old one back. - // TODO: Backup old file and try and recover that way. - fh = open(myDMI->NVMLocation, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); - if ( (bytes_written = write(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM) ) != (long) buffer_len(&sealed_NVM))) { - vtpmlogerror(VTPM_LOG_VTPM, "We just overwrote a DMI_NVM and failed to finish. %ld/%ld bytes.\n", bytes_written, (long)buffer_len(&sealed_NVM)); - status = TPM_IOERROR; - goto abort_egress; - } - close(fh); - - Crypto_SHA1Full (sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &myDMI->NVM_measurement); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save NVM\n."); - - egress: - buffer_free(&sealed_NVM); - return status; -} - - -/* Expected Params: inbuf = null, outbuf = sealed blob size, sealed blob.*/ -TPM_RESULT VTPM_Handle_Load_NVM(VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - - buffer_t sealed_NVM = NULL_BUF; - long fh_size; - int fh, stat_ret, i; - struct stat file_stat; - TPM_DIGEST sealedNVMHash; - - if (myDMI->NVMLocation == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to load NVM because the file name NULL.\n"); - status = TPM_AUTHFAIL; - goto abort_egress; - } - - //Read sealed blob off disk from NVMLocation - fh = open(myDMI->NVMLocation, O_RDONLY); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - fh_size = file_stat.st_size; - else { - status = TPM_IOERROR; - goto abort_egress; - } - - TPMTRYRETURN( buffer_init( &sealed_NVM, fh_size, NULL) ); - if (read(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM)) != fh_size) { - status = TPM_IOERROR; - goto abort_egress; - } - close(fh); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Load_NVMing[%d],\n", buffer_len(&sealed_NVM)); - - Crypto_SHA1Full(sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &sealedNVMHash); - - // Verify measurement of sealed blob. - if (memcmp(&sealedNVMHash, &myDMI->NVM_measurement, sizeof(TPM_DIGEST)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM LoadNVM NVM measurement check failed.\n"); - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Correct hash: "); - for (i=0; i< sizeof(TPM_DIGEST); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&myDMI->NVM_measurement)[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Measured hash: "); - for (i=0; i< sizeof(TPM_DIGEST); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&sealedNVMHash)[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - status = TPM_AUTHFAIL; - goto abort_egress; - } - - TPMTRYRETURN( envelope_decrypt(&sealed_NVM, - myDMI->TCSContext, - vtpm_globals->storageKeyHandle, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - outbuf) ); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load NVM\n."); - - egress: - buffer_free( &sealed_NVM ); - - return status; -} - - -TPM_RESULT VTPM_SaveManagerData(void) { - TPM_RESULT status=TPM_SUCCESS; - int fh, dmis=-1; - - BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL; - buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF; - UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap); - UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap); - struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes}; - struct pack_buf_t boot_key_pack = {bootKeySize, vtpm_globals->bootKeyWrap.bytes}; - BYTE vtpm_manager_gen = VTPM_MANAGER_GEN; - - struct hashtable_itr *dmi_itr; - VTPM_DMI_RESOURCE *dmi_res; - - UINT32 boot_key_size = 0, flat_dmis_size = 0; - - // Initially fill these with buffer sizes for each data type. Later fill - // in actual size, once flattened. - boot_key_size = sizeof(UINT32) + // bootkeysize - bootKeySize; // boot key - - TPMTRYRETURN(buffer_init(&clear_flat_global,sizeof(BYTE) + // manager version - 3*sizeof(TPM_DIGEST) + // Auths - sizeof(UINT32) +// storagekeysize - storageKeySize, NULL) ); // storage key - - - flat_boot_key = (BYTE *) malloc( boot_key_size ); - flat_enc = (BYTE *) malloc( sizeof(UINT32) ); - - boot_key_size = BSG_PackList(flat_boot_key, 1, - BSG_TPM_SIZE32_DATA, &boot_key_pack); - - BSG_PackList(clear_flat_global.bytes, 4, - BSG_TYPE_BYTE, &vtpm_manager_gen, - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, - BSG_TPM_SIZE32_DATA, &storage_key_pack); - - TPMTRYRETURN(envelope_encrypt(&clear_flat_global, - &vtpm_globals->bootKey, - &enc_flat_global) ); - - BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc); - - // Per DMI values to be saved (if any exit) - if (hashtable_count(vtpm_globals->dmi_map) > 1) { - - flat_dmis = (BYTE *) malloc( - (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0) - (sizeof(UINT32) +sizeof(BYTE) + 2*sizeof(TPM_DIGEST)) ); // Per DMI info - - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); - do { - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); - dmis++; - - // No need to save dmi0. - if (dmi_res->dmi_id == 0) - continue; - - - flat_dmis_size += BSG_PackList( flat_dmis + flat_dmis_size, 4, - BSG_TYPE_UINT32, &dmi_res->dmi_id, - BSG_TYPE_BYTE, &dmi_res->dmi_type, - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); - - } while (hashtable_iterator_advance(dmi_itr)); - } - - fh = open(STATE_FILE, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE); - if (fh == -1) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to open %s file for write.\n", STATE_FILE); - status = TPM_IOERROR; - goto abort_egress; - } - - if ( ( write(fh, flat_boot_key, boot_key_size) != boot_key_size ) || - ( write(fh, flat_enc, sizeof(UINT32)) != sizeof(UINT32) ) || - ( write(fh, enc_flat_global.bytes, buffer_len(&enc_flat_global)) != buffer_len(&enc_flat_global) ) || - ( write(fh, flat_dmis, flat_dmis_size) != flat_dmis_size ) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to completely write service data.\n"); - status = TPM_IOERROR; - goto abort_egress; - } - - goto egress; - - abort_egress: - egress: - - free(flat_boot_key); - free(flat_enc); - buffer_free(&enc_flat_global); - free(flat_dmis); - close(fh); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved VTPM Manager state (status = %d, dmis = %d)\n", (int) status, dmis); - return status; -} - -TPM_RESULT VTPM_LoadManagerData(void) { - - TPM_RESULT status=TPM_SUCCESS; - int fh, stat_ret, dmis=0; - long fh_size = 0, step_size; - BYTE *flat_table=NULL; - buffer_t unsealed_data, enc_table_abuf; - struct pack_buf_t storage_key_pack, boot_key_pack; - UINT32 *dmi_id_key, enc_size; - BYTE vtpm_manager_gen; - - VTPM_DMI_RESOURCE *dmi_res; - UINT32 dmi_id; - BYTE dmi_type; - struct stat file_stat; - - TPM_HANDLE boot_key_handle; - TPM_AUTHDATA boot_usage_auth; - memset(&boot_usage_auth, 0, sizeof(TPM_AUTHDATA)); - - fh = open(STATE_FILE, O_RDONLY ); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - fh_size = file_stat.st_size; - else { - status = TPM_IOERROR; - goto abort_egress; - } - - flat_table = (BYTE *) malloc(fh_size); - - if ((long) read(fh, flat_table, fh_size) != fh_size ) { - status = TPM_IOERROR; - goto abort_egress; - } - - // Read Boot Key - step_size = BSG_UnpackList( flat_table, 2, - BSG_TPM_SIZE32_DATA, &boot_key_pack, - BSG_TYPE_UINT32, &enc_size); - - TPMTRYRETURN(buffer_init(&vtpm_globals->bootKeyWrap, 0, 0) ); - TPMTRYRETURN(buffer_init_alias_convert(&enc_table_abuf, enc_size, flat_table + step_size) ); - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->bootKeyWrap, boot_key_pack.size, boot_key_pack.data) ); - - //Load Boot Key - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->bootKeyWrap, - &SRK_AUTH, - &boot_key_handle, - &vtpm_globals->keyAuth, - &vtpm_globals->bootKey, - FALSE) ); - - TPMTRYRETURN( envelope_decrypt(&enc_table_abuf, - vtpm_globals->manager_tcs_handle, - boot_key_handle, - (const TPM_AUTHDATA*) &boot_usage_auth, - &unsealed_data) ); - step_size += enc_size; - - if (*unsealed_data.bytes != VTPM_MANAGER_GEN) { - // Once there is more than one gen, this will include some compatability stuff - vtpmlogerror(VTPM_LOG_VTPM, "Warning: Manager Data file is gen %d, which this manager is gen %d.\n", vtpm_manager_gen, VTPM_MANAGER_GEN); - } - - // Global Values needing to be saved - BSG_UnpackList( unsealed_data.bytes, 4, - BSG_TYPE_BYTE, &vtpm_manager_gen, - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, - BSG_TPM_SIZE32_DATA, &storage_key_pack); - - TPMTRYRETURN(buffer_init(&vtpm_globals->storageKeyWrap, 0, 0) ); - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->storageKeyWrap, storage_key_pack.size, storage_key_pack.data) ); - - // Per DMI values to be saved - while ( step_size < fh_size ){ - if (fh_size - step_size < (long) (sizeof(UINT32) + sizeof(BYTE) + 2*sizeof(TPM_DIGEST))) { - vtpmlogerror(VTPM_LOG_VTPM, "Encountered %ld extra bytes at end of manager state.\n", fh_size-step_size); - step_size = fh_size; - } else { - step_size += BSG_UnpackList(flat_table + step_size, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TYPE_BYTE, &dmi_type); - - //TODO: Try and gracefully recover from problems. - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &dmi_res) ); - dmis++; - - step_size += BSG_UnpackList(flat_table + step_size, 2, - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); - } - - } - - vtpmloginfo(VTPM_LOG_VTPM, "Loaded saved state (dmis = %d).\n", dmis); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load service data with error = %s\n", tpm_get_error_name(status)); - egress: - - free(flat_table); - close(fh); - - // TODO: Could be nice and evict BootKey. (Need to add EvictKey to VTSP. - - return status; -} - diff --git a/tools/vtpm_manager/manager/tpmpassthrough.c b/tools/vtpm_manager/manager/tpmpassthrough.c deleted file mode 100644 index 9b1e5f8..0000000 --- a/tools/vtpm_manager/manager/tpmpassthrough.c +++ /dev/null @@ -1,110 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tpmpassthrough.c -// -// Functions regarding passing DMI requests to HWTPM -// -// ================================================================== - -#include "tcg.h" -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "log.h" - -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, - buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE *ord; - - ord = (TPM_COMMAND_CODE *) (inbuf->bytes + sizeof(TPM_TAG) + sizeof(UINT32)); - - switch (*ord) { - - // Forbidden for DMI use - case TPM_ORD_TakeOwnership: - case TPM_ORD_ChangeAuthOwner: - case TPM_ORD_DirWriteAuth: - case TPM_ORD_DirRead: - case TPM_ORD_AuthorizeMigrationKey: - case TPM_ORD_CreateMaintenanceArchive: - case TPM_ORD_LoadMaintenanceArchive: - case TPM_ORD_KillMaintenanceFeature: - case TPM_ORD_LoadManuMaintPub: - case TPM_ORD_ReadManuMaintPub: - case TPM_ORD_SelfTestFull: - case TPM_ORD_SelfTestStartup: - case TPM_ORD_CertifySelfTest: - case TPM_ORD_ContinueSelfTest: - case TPM_ORD_GetTestResult: - case TPM_ORD_Reset: - case TPM_ORD_OwnerClear: - case TPM_ORD_DisableOwnerClear: - case TPM_ORD_ForceClear: - case TPM_ORD_DisableForceClear: - case TPM_ORD_GetCapabilityOwner: - case TPM_ORD_OwnerSetDisable: - case TPM_ORD_PhysicalEnable: - case TPM_ORD_PhysicalDisable: - case TPM_ORD_SetOwnerInstall: - case TPM_ORD_PhysicalSetDeactivated: - case TPM_ORD_SetTempDeactivated: - case TPM_ORD_CreateEndorsementKeyPair: - case TPM_ORD_GetAuditEvent: - case TPM_ORD_GetAuditEventSigned: - case TPM_ORD_GetOrdinalAuditStatus: - case TPM_ORD_SetOrdinalAuditStatus: - case TPM_ORD_SetRedirection: - case TPM_ORD_FieldUpgrade: - case TSC_ORD_PhysicalPresence: - status = TPM_DISABLED_CMD; - goto abort_egress; - break; - - } // End ORD Switch - - // Call TCS with command - - TPMTRY(TPM_IOERROR, VTSP_RawTransmit( dmi->TCSContext,inbuf, outbuf) ); - - goto egress; - - abort_egress: - vtpmloginfo(VTPM_LOG_VTPM, "TPM Command Failed in tpmpassthrough.\n"); - egress: - - return status; -} diff --git a/tools/vtpm_manager/manager/vtpm_ipc.c b/tools/vtpm_manager/manager/vtpm_ipc.c deleted file mode 100644 index 319dc83..0000000 --- a/tools/vtpm_manager/manager/vtpm_ipc.c +++ /dev/null @@ -1,141 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_ipc.c Implements ipc routines using file io. This file can -// be replaced with other ipc types. -// -// =================================================================== - -#include -#include "vtpm_ipc.h" -#include "vtpmpriv.h" -#include "log.h" - -int vtpm_ipc_init(vtpm_ipc_handle_t *ipc_h, char* name, int flags, BOOL create) { - ipc_h->name = name; - ipc_h->flags = flags; - ipc_h->fh = VTPM_IPC_CLOSED; - - if (create) - return(vtpm_ipc_create(ipc_h)); - else - return 0; -} - -// Create the file that needs opening. Used only for FIFOs -// FYI: This may cause problems in other file IO schemes. We'll see. -int vtpm_ipc_create(vtpm_ipc_handle_t *ipc_h) { - int fh; - struct stat file_info; - - if ((!ipc_h) || (!ipc_h->name)) - return -1; - - if ( stat(ipc_h->name, &file_info) == -1) { - if ( mkfifo(ipc_h->name, S_IWUSR | S_IRUSR ) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create fifo %s.\n", ipc_h->name); - return -1; - } - } - - ipc_h->fh = VTPM_IPC_CLOSED; - - return 0; -} - - -// Read size bytes. If FH isn't open, open it. -int vtpm_ipc_read(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size){ - vtpm_ipc_handle_t *my_ipc_h; - int result; - - if (ipc_h) { - my_ipc_h = ipc_h; - } else { - my_ipc_h = alt_ipc_h; - } - - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); - } - - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for reading.\n", my_ipc_h->name); - return -1; - } - - result = read(my_ipc_h->fh, bytes, size); - if (result < 0) { - my_ipc_h->fh = VTPM_IPC_CLOSED; - } - - return (result); -} - -// Write size bytes. If FH isn't open, open it. -int vtpm_ipc_write(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size) { - vtpm_ipc_handle_t *my_ipc_h; - int result; - - if (ipc_h) { - my_ipc_h = ipc_h; - } else { - my_ipc_h = alt_ipc_h; - } - - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); - } - - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for writing.\n", my_ipc_h->name); - return -1; - } - - result = write(my_ipc_h->fh, bytes, size); - if (result < 0) { - my_ipc_h->fh = VTPM_IPC_CLOSED; - } - - return (result); -} - -// Mark file as closed and try and close it. Errors not reported. -void vtpm_ipc_close(vtpm_ipc_handle_t *ipc_h) { - - if (ipc_h) { - close(ipc_h->fh); - ipc_h->fh = VTPM_IPC_CLOSED; - } - -} diff --git a/tools/vtpm_manager/manager/vtpm_ipc.h b/tools/vtpm_manager/manager/vtpm_ipc.h deleted file mode 100644 index 529c4a2..0000000 --- a/tools/vtpm_manager/manager/vtpm_ipc.h +++ /dev/null @@ -1,71 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_ipc.h Header for interprocess communication between VTPM manager -// and Guests or VTPMs -// -// =================================================================== - -#ifndef __VTPM_IO_H__ -#define __VTPM_IO_H__ - -#include "tcg.h" - -#define VTPM_IPC_CLOSED -1 - -// Represents an (somewhat) abstracted io handle. -typedef struct vtpm_ipc_handle_t { - int fh; // IO handle. - int flags; // Flags for opening. This may need to become - // a void *, but for now files use an int. - char *name; // Names for debugging as well as filenames - // for file-based io. -} vtpm_ipc_handle_t; - - -int vtpm_ipc_init(vtpm_ipc_handle_t *ioh, char* name, int flags, BOOL create); - -// Create the file that needs opening. Used only for FIFOs -// FYI: This may cause problems in other file IO schemes. We'll see. -int vtpm_ipc_create(vtpm_ipc_handle_t *ioh); - -// Read size bytes. If FH isn't open, open it. -int vtpm_ipc_read(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); - -// Write size bytes. If FH isn't open, open it. -int vtpm_ipc_write(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); - -// Mark file as closed and try and close it. Errors not reported. -void vtpm_ipc_close(vtpm_ipc_handle_t *ioh); - -#endif diff --git a/tools/vtpm_manager/manager/vtpm_lock.c b/tools/vtpm_manager/manager/vtpm_lock.c deleted file mode 100644 index e737d60..0000000 --- a/tools/vtpm_manager/manager/vtpm_lock.c +++ /dev/null @@ -1,63 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_lock.c Provided controlled sync around access to vtpm structures -// -// =================================================================== - -#include -#include "vtpm_lock.h" - -static pthread_rwlock_t vtpm_lock; - -void vtpm_lock_init() { - - pthread_rwlock_init( &vtpm_lock, NULL); -} - -void vtpm_lock_destroy(){ - pthread_rwlock_destroy(&vtpm_lock); -} - -void vtpm_lock_rdlock(){ - pthread_rwlock_rdlock(&vtpm_lock); -} - -void vtpm_lock_wrlock(){ - pthread_rwlock_wrlock(&vtpm_lock); -} - -void vtpm_lock_unlock(){ - pthread_rwlock_unlock(&vtpm_lock); -} - diff --git a/tools/vtpm_manager/manager/vtpm_lock.h b/tools/vtpm_manager/manager/vtpm_lock.h deleted file mode 100644 index 53a339d..0000000 --- a/tools/vtpm_manager/manager/vtpm_lock.h +++ /dev/null @@ -1,48 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_lock.h Provided controlled sync around access to vtpm structures -// -// =================================================================== - -#ifndef __VTPM_LOCK_H__ -#define __VTPM_LOCK_H__ - -void vtpm_lock_init(); -void vtpm_lock_destroy(); - -void vtpm_lock_rdlock(); -void vtpm_lock_wrlock(); -void vtpm_lock_unlock(); - -#endif diff --git a/tools/vtpm_manager/manager/vtpm_manager.c b/tools/vtpm_manager/manager/vtpm_manager.c deleted file mode 100644 index e089f78..0000000 --- a/tools/vtpm_manager/manager/vtpm_manager.c +++ /dev/null @@ -1,285 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager.c -// -// This file will house the main logic of the VTPM Manager -// -// ================================================================== - -#include -#include -#include - -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "hashtable.h" -#include "hashtable_itr.h" - -#include "log.h" -#include "buffer.h" - -VTPM_GLOBALS *vtpm_globals=NULL; - -// --------------------------- Well Known Auths -------------------------- -const TPM_AUTHDATA SRK_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; - -#ifdef WELL_KNOWN_OWNER_AUTH -static BYTE FIXED_OWNER_AUTH[20] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; -#endif - - -// -------------------------- Hash table functions -------------------- - -static unsigned int hashfunc32(void *ky) { - return (* (UINT32 *) ky); -} - -static int equals32(void *k1, void *k2) { - return (*(UINT32 *) k1 == *(UINT32 *) k2); -} - -// --------------------------- Functions ------------------------------ - -TPM_RESULT VTPM_Create_Manager(){ - - TPM_RESULT status = TPM_SUCCESS; - - // Generate Auth for Owner -#ifdef WELL_KNOWN_OWNER_AUTH - memcpy(vtpm_globals->owner_usage_auth, FIXED_OWNER_AUTH, sizeof(TPM_AUTHDATA)); -#else - Crypto_GetRandom(vtpm_globals->owner_usage_auth, sizeof(TPM_AUTHDATA) ); -#endif - - // Take Owership of TPM - CRYPTO_INFO ek_cryptoInfo; - - status = VTSP_ReadPubek(vtpm_globals->manager_tcs_handle, &ek_cryptoInfo); - - // If we can read PubEK then there is no owner and we should take it. - // We use the abilty to read the pubEK to flag that the TPM is owned. - // FIXME: Change to just trying to take ownership and react to the status - if (status == TPM_SUCCESS) { - TPMTRYRETURN(VTSP_TakeOwnership(vtpm_globals->manager_tcs_handle, - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, - &SRK_AUTH, - &ek_cryptoInfo, - &vtpm_globals->keyAuth)); - - TPMTRYRETURN(VTSP_DisablePubekRead(vtpm_globals->manager_tcs_handle, - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, - &vtpm_globals->keyAuth)); - } else { - vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); - } - - // Generate storage key's auth - Crypto_GetRandom( &vtpm_globals->storage_key_usage_auth, - sizeof(TPM_AUTHDATA) ); - - TCS_AUTH osap; - TPM_AUTHDATA sharedsecret; - - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, - TPM_ET_KEYHANDLE, - TPM_SRK_KEYHANDLE, - &SRK_AUTH, - &sharedsecret, - &osap) ); - - osap.fContinueAuthSession = FALSE; - - - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, - TPM_KEY_BIND, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - &vtpm_globals->storageKeyWrap, - &osap) ); - - // Generate boot key's auth - TPM_AUTHDATA bootKeyWrapAuth; - memset(&bootKeyWrapAuth, 0, sizeof(bootKeyWrapAuth)); - - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, - TPM_ET_KEYHANDLE, - TPM_SRK_KEYHANDLE, - &SRK_AUTH, - &sharedsecret, - &osap) ); - - osap.fContinueAuthSession = FALSE; - - // FIXME: This key protects the global secrets on disk. It should use TPM - // PCR bindings to limit its use to legit configurations. - // Current binds are open, implying a Trusted VM contains this code. - // If this VM is not Trusted, use measurement and PCR bindings. - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, - TPM_KEY_BIND, - (const TPM_AUTHDATA*)&bootKeyWrapAuth, - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - &vtpm_globals->bootKeyWrap, - &osap) ); - - // Populate CRYPTO_INFO vtpm_globals->bootKey. This does not load it into the TPM - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->bootKeyWrap, - NULL, - NULL, - NULL, - &vtpm_globals->bootKey, - TRUE ) ); - - TPMTRYRETURN( VTSP_SaveState(vtpm_globals->manager_tcs_handle) ); - goto egress; - - abort_egress: - exit(1); - - egress: - vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager (Status = %d).\n", status); - return status; - -} - -/////////////////////////////////////////////////////////////////////////////// -TPM_RESULT VTPM_Init_Manager() { - TPM_RESULT status = TPM_FAIL, serviceStatus; - BYTE *randomsead; - UINT32 randomsize=256; - - if ((vtpm_globals = (VTPM_GLOBALS *) malloc(sizeof(VTPM_GLOBALS))) == NULL){ - status = TPM_FAIL; - goto abort_egress; - } - memset(vtpm_globals, 0, sizeof(VTPM_GLOBALS)); - - vtpm_globals->connected_dmis = 0; - - if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){ - status = TPM_FAIL; - goto abort_egress; - } - - // Create new TCS Object - vtpm_globals->manager_tcs_handle = 0; - - TPMTRYRETURN(TCS_create()); - - // Create TCS Context for service - TPMTRYRETURN( TCS_OpenContext(&vtpm_globals->manager_tcs_handle ) ); - - TPMTRYRETURN( TCSP_GetRandom(vtpm_globals->manager_tcs_handle, - &randomsize, - &randomsead)); - - Crypto_Init(randomsead, randomsize); - TPMTRYRETURN( TCS_FreeMemory (vtpm_globals->manager_tcs_handle, randomsead)); - - // Create OIAP session for service's authorized commands - TPMTRYRETURN( VTSP_OIAP( vtpm_globals->manager_tcs_handle, - &vtpm_globals->keyAuth) ); - vtpm_globals->keyAuth.fContinueAuthSession = TRUE; - - vtpm_globals->mig_keys = NULL; - - // If fails, create new Manager. - serviceStatus = VTPM_LoadManagerData(); - if (serviceStatus == TPM_IOERROR) { - vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); - TPMTRYRETURN( VTPM_Create_Manager() ); - TPMTRYRETURN( VTPM_SaveManagerData() ); - } else if (serviceStatus != TPM_SUCCESS) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to read existing manager file"); - exit(1); - } - - //Load Storage Key - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->storageKeyWrap, - &SRK_AUTH, - &vtpm_globals->storageKeyHandle, - &vtpm_globals->keyAuth, - &vtpm_globals->storageKey, - FALSE ) ); - - // Create entry for Dom0 for control messages - TPMTRYRETURN( VTPM_Handle_New_DMI(NULL) ); - - goto egress; - - abort_egress: - egress: - - return(status); -} - -/////////////////////////////////////////////////////////////////////////////// -void VTPM_Stop_Manager() { - VTPM_DMI_RESOURCE *dmi_res; - struct hashtable_itr *dmi_itr; - - // Close all the TCS contexts. TCS should evict keys based on this - if (hashtable_count(vtpm_globals->dmi_map) > 0) { - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); - do { - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); - if (dmi_res->connected) - close_dmi( dmi_res ); // Not really interested in return code - - } while (hashtable_iterator_advance(dmi_itr)); - free (dmi_itr); - } - - if ( VTPM_SaveManagerData() != TPM_SUCCESS ) - vtpmlogerror(VTPM_LOG_VTPM, "Unable to save manager data.\n"); - - TCS_CloseContext(vtpm_globals->manager_tcs_handle); - TCS_destroy(); - - hashtable_destroy(vtpm_globals->dmi_map, 1); - free(vtpm_globals); - - Crypto_Exit(); - - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); -} diff --git a/tools/vtpm_manager/manager/vtpm_manager.h b/tools/vtpm_manager/manager/vtpm_manager.h deleted file mode 100644 index a324a8f..0000000 --- a/tools/vtpm_manager/manager/vtpm_manager.h +++ /dev/null @@ -1,150 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager.h -// -// Public Interface header for VTPM Manager -// -// ================================================================== - -#ifndef __VTPM_MANAGER_H__ -#define __VTPM_MANAGER_H__ - -#define VTPM_TAG_REQ 0x01c1 -#define VTPM_TAG_RSP 0x01c4 -#define COMMAND_BUFFER_SIZE 4096 - -// Header sizes. Note Header MAY include the DMI -#define VTPM_COMMAND_HEADER_SIZE_CLT ( 2 + 4 + 4) -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) -#define VTPM_COMMAND_HEADER_SIZE_SRV ( 4 + VTPM_COMMAND_HEADER_SIZE_CLT ) -// sizeof( UINT32 + VTPM_COMMAND_HEADER_SIZE_CLT) - -//************************ 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) - -// Non-priviledged VTPM Commands (From DMI's) -#define VTPM_ORD_SAVENVM (VTPM_ORD_BASE + 1) // DMI Saves Secrets -#define VTPM_ORD_LOADNVM (VTPM_ORD_BASE + 2) // DMI Loads Secrets -#define VTPM_ORD_TPMCOMMAND (VTPM_ORD_BASE + 3) // DMI issues HW TPM Command -#define VTPM_ORD_GET_MIG_KEY (VTPM_ORD_BASE + 4) // Get manager's migration key -#define VTPM_ORD_LOAD_MIG_KEY (VTPM_ORD_BASE + 5) // load dest migration key - -// Priviledged VTPM Commands (From management console) -#define VTPM_ORD_OPEN (VTPM_PRIV_BASE + 1) // Creates/reopens DMI -#define VTPM_ORD_CLOSE (VTPM_PRIV_BASE + 2) // Closes a DMI -#define VTPM_ORD_DELETE (VTPM_PRIV_BASE + 3) // Permemently Deletes DMI -#define VTPM_ORD_MIGRATE_IN (VTPM_PRIV_BASE + 4) // Load migrated VTPM -#define VTPM_ORD_MIGRATE_OUT (VTPM_PRIV_BASE + 5) // migrate VTPM to dest - -//************************ Return Codes **************************** -#define VTPM_TYPE_PVM 1 // Paravirtualized Domain -#define VTPM_TYPE_HVM 2 // HVM Domain - -//************************ Return Codes **************************** -#define VTPM_SUCCESS 0 -#define VTPM_FAIL 1 -#define VTPM_UNSUPPORTED 2 -#define VTPM_FORBIDDEN 3 -#define VTPM_RESTORE_CONTEXT_FAILED 4 -#define VTPM_INVALID_REQUEST 5 - -//*********************** Parameter Values ************************* -#define VTPM_TYPE_NON_MIGRATABLE 0x00 -#define VTPM_TYPE_MIGRATABLE 0x01 -#define VTPM_TYPE_MIGRATED 0xFF // VTPM has been migrated. - // VTPM can be recovered or deleted only - -/******************* Command Parameter API ************************* - -VTPM Command Format - dmi: 4 bytes // Source of message. - // WARNING: This is prepended by the channel. - // Thus it is received by VTPM Manager, - // but not sent by DMI - tpm tag: 2 bytes - command size: 4 bytes // Size of command including header but not DMI - ord: 4 bytes // Command ordinal above - parameters: size - 10 bytes // Command Parameter - -VTPM Response Format - tpm tag: 2 bytes - response_size: 4 bytes - status: 4 bytes - parameters: size - 10 bytes - - -VTPM_Open: - Input Parameters: - mig_type: 1 byte - startup_mode: 1 byte // Cold Boot = 1, resume = 2, deactive = 3 - domain type: 1 byte - instance_id: 4 bytes - Output Parameters: - None - -VTPM_Close - Input Parameters: - instance_id: 4 bytes - Output Parameters: - None - -VTPM_Delete - Input Parameters: - instance_id: 4 bytes - Output Parameters: - None - -VTPM_SaveNVM - Input Parameters: - data: n bytes (Header indicates size of data) - Output Parameters: - None - -VTPM_LoadNVM - Input Parameters: - None - Output Parameters: - data: n bytes (Header indicates size of data) - -VTPM_TPMCommand - Input Parameters: - TPM Command Byte Stream: n bytes - Output Parameters: - TPM Reponse Byte Stream: n bytes - -*********************************************************************/ - -#endif //_VTPM_MANAGER_H_ diff --git a/tools/vtpm_manager/manager/vtpm_manager_handler.c b/tools/vtpm_manager/manager/vtpm_manager_handler.c deleted file mode 100644 index 2001074..0000000 --- a/tools/vtpm_manager/manager/vtpm_manager_handler.c +++ /dev/null @@ -1,488 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager_handler.c -// -// This file will house the main logic of the VTPM Manager -// -// ================================================================== - -#include -#include -#include -#include - -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "log.h" -#include "buffer.h" - -#define vtpmhandlerloginfo(module,fmt,args...) vtpmloginfo (module, "[%s]: " fmt, thread_name, ##args ); -#define vtpmhandlerloginfomore(module,fmt,args...) vtpmloginfomore (module, fmt, ##args ); -#define vtpmhandlerlogerror(module,fmt,args...) vtpmlogerror (module, "[%s]: " fmt, thread_name, ##args ); - -// ---------------------- Prototypes ------------------- -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, - TPM_COMMAND_CODE ord, - buffer_t *command_buf, - buffer_t *result_buf, - BOOL is_priv, - char *thread_name); - -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - VTPM_DMI_RESOURCE *dmi_res, - BYTE *cmd_header, - buffer_t *param_buf, - buffer_t *result_buf, - char *thread_name); - -TPM_RESULT VTPM_Manager_Handler( vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - BOOL fw_tpm, // Forward TPM cmds? - vtpm_ipc_handle_t *fw_tx_ipc_h, - vtpm_ipc_handle_t *fw_rx_ipc_h, - BOOL is_priv, - char *thread_name) { - TPM_RESULT status = TPM_FAIL; // Should never return - UINT32 dmi, in_param_size, cmd_size, out_param_size, out_message_size, reply_size; - BYTE *cmd_header=NULL, *in_param=NULL, *out_message=NULL, *reply; - buffer_t *command_buf=NULL, *result_buf=NULL; - TPM_TAG tag; - TPM_COMMAND_CODE ord; - VTPM_DMI_RESOURCE *dmi_res; - int size_read, size_write, i; - BOOL add_header=TRUE; // This indicates to prepend a header on result_buf before sending - - cmd_header = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV); - command_buf = (buffer_t *) malloc(sizeof(buffer_t)); - result_buf = (buffer_t *) malloc(sizeof(buffer_t)); - - // ------------------------ Main Loop -------------------------------- - while(1) { - - vtpmhandlerloginfo(VTPM_LOG_VTPM, "%s waiting for messages.\n", thread_name); - - // --------------------- Read Cmd from Sender ---------------- - - // Read command header - size_read = vtpm_ipc_read(rx_ipc_h, NULL, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - if (size_read > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV[%d]: 0x", size_read); - for (i=0; i 0) { - in_param = (BYTE *) malloc(cmd_size); - size_read = vtpm_ipc_read( rx_ipc_h, NULL, in_param, cmd_size); - if (size_read > 0) { - for (i=0; idmi_map, &dmi)) || - (!dmi_res->connected) ) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempted access to non-existent or disconnected DMI %d. Aborting...\n", dmi); - status = TPM_BAD_PARAMETER; - // We have no one to reply to, they don't exist. - goto abort_command; - } - - if (tag == VTPM_TAG_REQ) { - - status = vtpm_manager_handle_vtpm_cmd(dmi_res, ord, command_buf, result_buf, is_priv, thread_name); - - } else { // This is not a VTPM Command at all. - if (fw_tpm) { - status = vtpm_manager_handle_tpm_cmd(fw_tx_ipc_h, fw_rx_ipc_h, dmi_res, cmd_header, command_buf, result_buf, thread_name); - - // This means calling the DMI failed, not that the cmd failed in the DMI - // Since the return will be interpretted by a TPM app, all errors are IO_ERRORs to the app - if (status != TPM_SUCCESS) { - status = TPM_IOERROR; - goto abort_with_error; - } - // Unlike all other commands, forwarded commands yield a result_buf that includes the DMI's status. This - // should be forwarded to the caller VM - add_header = FALSE; - } else { - // We are not supposed to forward TPM commands at all. - int i; - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempt to use unsupported direct access to TPM.\n"); - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "Bad Command. dmi:%d, tag:%d, size:%d, ord:%d, Params: ", dmi, tag, in_param_size, ord); - for (i=0; i 0) - memcpy(out_message + VTPM_COMMAND_HEADER_SIZE_SRV, result_buf->bytes, out_param_size); - //Note: Send message + dmi_id - } else { - reply = result_buf->bytes; - reply_size = buffer_len(result_buf); - } - size_write = vtpm_ipc_write(tx_ipc_h, (dmi_res ? dmi_res->tx_vtpm_ipc_h : NULL), reply, reply_size ); - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); - for (i=0; i < reply_size; i++) - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", reply[i]); - - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - } else { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name); - goto abort_command; - } - free(out_message); out_message=NULL; - - if (size_write < (int)reply_size) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size); - goto abort_command; - } - - // On certain failures an error message cannot be sent. - // This marks the beginning of cleanup in preperation for the next command. - abort_command: - //free buffers - bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - //free(in_param); // This was converted to command_buf. No need to free - buffer_free(result_buf); - buffer_free(command_buf); - - // If we have a write lock, save the manager table - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) && - (VTPM_SaveManagerData() != TPM_SUCCESS) ) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n"); - } - - vtpm_lock_unlock(); - add_header = TRUE; // Reset to the default - } // End while(1) - -} - -///////////////////////////////////////////////////////////////////////// -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, - TPM_COMMAND_CODE ord, - buffer_t *command_buf, - buffer_t *result_buf, - BOOL is_priv, - char *thread_name) { - - TPM_RESULT status = TPM_FAIL; - - switch (ord) { - case VTPM_ORD_SAVENVM: - status= VTPM_Handle_Save_NVM(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_LOADNVM: - status= VTPM_Handle_Load_NVM(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_TPMCOMMAND: - status= VTPM_Handle_TPM_Command(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_GET_MIG_KEY: - status = VTPM_Handle_Get_Migration_key(command_buf, - result_buf); - break; - - case VTPM_ORD_LOAD_MIG_KEY: - status = VTPM_Handle_Load_Migration_key(command_buf, - result_buf); - break; - - default: - // Privileged handlers can do maintanance - if (is_priv) { - switch (ord) { - case VTPM_ORD_OPEN: - status = VTPM_Handle_New_DMI(command_buf); - break; - - case VTPM_ORD_CLOSE: - status = VTPM_Handle_Close_DMI(command_buf); - break; - - case VTPM_ORD_DELETE: - status = VTPM_Handle_Delete_DMI(command_buf); - break; - - case VTPM_ORD_MIGRATE_IN: - status = VTPM_Handle_Migrate_In(command_buf, result_buf); - break; - - case VTPM_ORD_MIGRATE_OUT: - status = VTPM_Handle_Migrate_Out(command_buf, result_buf); - break; - - default: - status = TPM_BAD_ORDINAL; - } // switch - } else { // is priv command - - status = TPM_BAD_ORDINAL; - } // inner switch - } // outer switch - - return(status); -} - -///////////////////////////////////////////////////////////////////// -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - VTPM_DMI_RESOURCE *dmi_res, - BYTE *cmd_header, - buffer_t *param_buf, - buffer_t *result_buf, - char *thread_name) { - - TPM_RESULT status = TPM_FAIL; - UINT32 dmi_dst; - TPM_COMMAND_CODE ord; - TPM_TAG tag_out; - UINT32 dmi_cmd_size, in_param_size, adj_param_size; - BYTE *dmi_cmd, *in_param; - int size_read, size_write, i; - - //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness - if (dmi_res->dmi_id == VTPM_CTL_DM) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n"); - status = TPM_FAIL; - goto abort_with_error; - } - - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n"); - - //Forward TPM CMD stamped with dmi_id to DMI for handling - if (buffer_len(param_buf)) { - dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf)); - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); - memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf)); - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size); - - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); - for (i=0; itx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV ); - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); - for (i=0; irx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - if (size_read > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x"); - for (i=0; i 0) { - in_param = (BYTE *) malloc(adj_param_size); - size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size); - if (size_read > 0) { - for (i=0; i -#include -#include -#include -#include -#include -#include -#include -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "tcg.h" -#include "log.h" -#include "vtpm_ipc.h" - -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" - -#define VTPM_BE_FNAME "/dev/vtpm" -#define VTPM_DUMMY_TX_BE_FNAME "/var/vtpm/fifos/dummy_out.fifo" -#define VTPM_DUMMY_RX_BE_FNAME "/var/vtpm/fifos/dummy_in.fifo" -#define VTPM_TX_TPM_FNAME "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -#define VTPM_RX_TPM_FNAME "/var/vtpm/fifos/tpm_rsp_from_all.fifo" -#define VTPM_TX_VTPM_FNAME "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -#define VTPM_RX_VTPM_FNAME "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" - -#define VTPM_TYPE_PVM_STRING "pvm" -#define VTPM_TYPE_HVM_STRING "hvm" - -struct vtpm_thread_params_s { - vtpm_ipc_handle_t *tx_ipc_h; - vtpm_ipc_handle_t *rx_ipc_h; - BOOL fw_tpm; - vtpm_ipc_handle_t *fw_tx_ipc_h; - vtpm_ipc_handle_t *fw_rx_ipc_h; - BOOL is_priv; - char *thread_name; -}; - -// This is needed to all extra_close_dmi to close this to prevent a -// broken pipe when no DMIs are left. -static vtpm_ipc_handle_t *g_rx_tpm_ipc_h; - -void *vtpm_manager_thread(void *arg_void) { - TPM_RESULT *status = (TPM_RESULT *) malloc(sizeof(TPM_RESULT) ); - struct vtpm_thread_params_s *arg = (struct vtpm_thread_params_s *) arg_void; - - *status = VTPM_Manager_Handler(arg->tx_ipc_h, arg->rx_ipc_h, - arg->fw_tpm, arg->fw_tx_ipc_h, arg->fw_rx_ipc_h, - arg->is_priv, arg->thread_name); - - return (status); -} - - -void signal_handler(int reason) { - if (pthread_equal(pthread_self(), vtpm_globals->master_pid)) { - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager shutting down for signal %d.\n", reason); - } else { - // For old Linux Thread machines, signals are delivered to each thread. Deal with them. - vtpmloginfo(VTPM_LOG_VTPM, "Child shutting down\n"); - pthread_exit(NULL); - } - - VTPM_Stop_Manager(); - exit(-1); -} - -struct sigaction ctl_c_handler; - -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode) { - - TPM_RESULT status = TPM_SUCCESS; - int fh; - char dmi_id_str[11]; // UINT32s are up to 10 digits + NULL - char *tx_vtpm_name, *tx_tpm_name, *vm_type_string; - struct stat file_info; - - if (dmi_res->dmi_id == VTPM_CTL_DM) { - dmi_res->tx_tpm_ipc_h = NULL; - dmi_res->rx_tpm_ipc_h = NULL; - dmi_res->tx_vtpm_ipc_h = NULL; - dmi_res->rx_vtpm_ipc_h = NULL; - } else { - // Create a pair of fifo pipes - dmi_res->rx_tpm_ipc_h = NULL; - dmi_res->rx_vtpm_ipc_h = NULL; - - if ( ((dmi_res->tx_tpm_ipc_h = (vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || - ((dmi_res->tx_vtpm_ipc_h =(vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || - ((tx_tpm_name = (char *) malloc(11 + strlen(VTPM_TX_TPM_FNAME))) == NULL ) || - ((tx_vtpm_name =(char *) malloc(11 + strlen(VTPM_TX_VTPM_FNAME))) == NULL) ) { - status =TPM_RESOURCES; - goto abort_egress; - } - - sprintf(tx_tpm_name, VTPM_TX_TPM_FNAME, (uint32_t) dmi_res->dmi_id); - sprintf(tx_vtpm_name, VTPM_TX_VTPM_FNAME, (uint32_t) dmi_res->dmi_id); - - if ( (vtpm_ipc_init(dmi_res->tx_tpm_ipc_h, tx_tpm_name, O_WRONLY | O_NONBLOCK, TRUE) != 0) || - (vtpm_ipc_init(dmi_res->tx_vtpm_ipc_h, tx_vtpm_name, O_WRONLY, TRUE) != 0) ) { //FIXME: O_NONBLOCK? - status = TPM_IOERROR; - goto abort_egress; - } - - // Measure DMI - // FIXME: This will measure DMI. Until then use a fixed DMI_Measurement value - // Also, this mechanism is specific to 1 VM architecture. - /* - fh = open(TPM_EMULATOR_PATH, O_RDONLY); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - dmi_size = file_stat.st_size; - else { - vtpmlogerror(VTPM_LOG_VTPM, "Could not open vtpmd!!\n"); - status = TPM_IOERROR; - goto abort_egress; - } - dmi_buffer - */ - memset(&dmi_res->DMI_measurement, 0xcc, sizeof(TPM_DIGEST)); - - if (vm_type == VTPM_TYPE_PVM) - vm_type_string = (BYTE *)&VTPM_TYPE_PVM_STRING; - else - vm_type_string = (BYTE *)&VTPM_TYPE_HVM_STRING; - - // Launch DMI - sprintf(dmi_id_str, "%d", (int) dmi_res->dmi_id); -#ifdef MANUAL_DM_LAUNCH - vtpmlogerror(VTPM_LOG_VTPM, "Manually start VTPM with dmi=%s now.\n", dmi_id_str); - dmi_res->dmi_pid = 0; -#else - pid_t pid = fork(); - - if (pid == -1) { - vtpmlogerror(VTPM_LOG_VTPM, "Could not fork to launch vtpm\n"); - status = TPM_RESOURCES; - goto abort_egress; - } else if (pid == 0) { - switch (startup_mode) { - case TPM_ST_CLEAR: - execl (TPM_EMULATOR_PATH, "vtpmd", "clear", vm_type_string, dmi_id_str, NULL); - break; - case TPM_ST_STATE: - execl (TPM_EMULATOR_PATH, "vtpmd", "save", vm_type_string, dmi_id_str, NULL); - break; - case TPM_ST_DEACTIVATED: - execl (TPM_EMULATOR_PATH, "vtpmd", "deactivated", vm_type_string, dmi_id_str, NULL); - break; - default: - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Returning from these at all is an error. - vtpmlogerror(VTPM_LOG_VTPM, "Could not exec to launch vtpm\n"); - } else { - dmi_res->dmi_pid = pid; - vtpmloginfo(VTPM_LOG_VTPM, "Launching DMI on PID = %d\n", pid); - } -#endif // MANUAL_DM_LAUNCH - - } // If DMI = VTPM_CTL_DM - status = TPM_SUCCESS; - -abort_egress: - return (status); -} - -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res) { - TPM_RESULT status = TPM_SUCCESS; - - if (vtpm_globals->connected_dmis == 0) { - // No more DMI's connected. Close fifo to prevent a broken pipe. - // This is hackish. Need to think of another way. - vtpm_ipc_close(g_rx_tpm_ipc_h); - } - - - if (dmi_res->dmi_id != VTPM_CTL_DM) { - vtpm_ipc_close(dmi_res->tx_tpm_ipc_h); - vtpm_ipc_close(dmi_res->tx_vtpm_ipc_h); - - free(dmi_res->tx_tpm_ipc_h->name); - free(dmi_res->tx_vtpm_ipc_h->name); - -#ifndef MANUAL_DM_LAUNCH - if (dmi_res->dmi_id != VTPM_CTL_DM) { - if (dmi_res->dmi_pid != 0) { - vtpmloginfo(VTPM_LOG_VTPM, "Killing dmi on pid %d.\n", dmi_res->dmi_pid); - if (kill(dmi_res->dmi_pid, SIGKILL) !=0) { - vtpmloginfo(VTPM_LOG_VTPM, "DMI on pid %d is already dead.\n", dmi_res->dmi_pid); - } else if (waitpid(dmi_res->dmi_pid, NULL, 0) != dmi_res->dmi_pid) { - vtpmlogerror(VTPM_LOG_VTPM, "DMI on pid %d failed to stop.\n", dmi_res->dmi_pid); - status = TPM_FAIL; - } - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Could not kill dmi because it's pid was 0.\n"); - status = TPM_FAIL; - } - } -#endif - - } //endif ! dom0 - return status; -} - - -int main(int argc, char **argv) { - vtpm_ipc_handle_t *tx_be_ipc_h, *rx_be_ipc_h, rx_tpm_ipc_h, rx_vtpm_ipc_h, tx_hp_ipc_h, rx_hp_ipc_h; - struct vtpm_thread_params_s be_thread_params, dmi_thread_params, hp_thread_params; - pthread_t be_thread, dmi_thread, hp_thread; - -#ifdef DUMMY_BACKEND - vtpm_ipc_handle_t tx_dummy_ipc_h, rx_dummy_ipc_h; -#else - vtpm_ipc_handle_t real_be_ipc_h; -#endif - - vtpmloginfo(VTPM_LOG_VTPM, "Starting VTPM.\n"); - - // -------------------- Initialize Manager ----------------- - if (VTPM_Init_Manager() != TPM_SUCCESS) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing vtpmd due to error during startup.\n"); - return -1; - } - - // -------------------- Setup Ctrl+C Handlers -------------- - ctl_c_handler.sa_handler = signal_handler; - sigemptyset(&ctl_c_handler.sa_mask); - ctl_c_handler.sa_flags = 0; - - if (sigaction(SIGINT, &ctl_c_handler, NULL) == -1) - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGINT handler. Ctl+break will not stop manager gently.\n"); - - // For easier debuggin with gdb - if (sigaction(SIGHUP, &ctl_c_handler, NULL) == -1) - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGHUP handler. Ctl+break will not stop manager gently.\n"); - - sigset_t sig_mask; - sigemptyset(&sig_mask); - sigaddset(&sig_mask, SIGPIPE); - sigprocmask(SIG_BLOCK, &sig_mask, NULL); - - // ------------------- Set up file ipc structures ---------- -#ifdef DUMMY_BACKEND - if ( (vtpm_ipc_init(&tx_dummy_ipc_h, VTPM_DUMMY_TX_BE_FNAME, O_RDWR, TRUE) != 0) || - (vtpm_ipc_init(&rx_dummy_ipc_h, VTPM_DUMMY_RX_BE_FNAME, O_RDWR, TRUE) != 0) ) { - - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create Dummy BE FIFOs.\n"); - exit(-1); - } - - tx_be_ipc_h = &tx_dummy_ipc_h; - rx_be_ipc_h = &rx_dummy_ipc_h; -#else - vtpm_ipc_init(&real_be_ipc_h, VTPM_BE_FNAME, O_RDWR, FALSE); - - tx_be_ipc_h = &real_be_ipc_h; - rx_be_ipc_h = &real_be_ipc_h; -#endif - - if ( (vtpm_ipc_init(&rx_tpm_ipc_h, VTPM_RX_TPM_FNAME, O_RDONLY, TRUE) != 0) || - (vtpm_ipc_init(&rx_vtpm_ipc_h, VTPM_RX_VTPM_FNAME, O_RDWR, TRUE) != 0) || //FIXME: O_RDONLY? - (vtpm_ipc_init(&tx_hp_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || - (vtpm_ipc_init(&rx_hp_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create initial FIFOs.\n"); - exit(-1); - } - - g_rx_tpm_ipc_h = &rx_tpm_ipc_h; - - // -------------------- Set up thread params ------------- - - be_thread_params.tx_ipc_h = tx_be_ipc_h; - be_thread_params.rx_ipc_h = rx_be_ipc_h; - be_thread_params.fw_tpm = TRUE; - be_thread_params.fw_tx_ipc_h = NULL; - be_thread_params.fw_rx_ipc_h = &rx_tpm_ipc_h; - be_thread_params.is_priv = FALSE; - be_thread_params.thread_name = "Backend Listener"; - - dmi_thread_params.tx_ipc_h = NULL; - dmi_thread_params.rx_ipc_h = &rx_vtpm_ipc_h; - dmi_thread_params.fw_tpm = FALSE; - dmi_thread_params.fw_tx_ipc_h = NULL; - dmi_thread_params.fw_rx_ipc_h = NULL; - dmi_thread_params.is_priv = FALSE; - dmi_thread_params.thread_name = "VTPM Listener"; - - hp_thread_params.tx_ipc_h = &tx_hp_ipc_h; - hp_thread_params.rx_ipc_h = &rx_hp_ipc_h; - hp_thread_params.fw_tpm = FALSE; - hp_thread_params.fw_tx_ipc_h = NULL; - hp_thread_params.fw_rx_ipc_h = NULL; - hp_thread_params.is_priv = TRUE; - hp_thread_params.thread_name = "Hotplug Listener"; - - // --------------------- Launch Threads ----------------- - - vtpm_lock_init(); - - vtpm_globals->master_pid = pthread_self(); - - if (pthread_create(&be_thread, NULL, vtpm_manager_thread, &be_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch BE Thread.\n"); - exit(-1); - } - - if (pthread_create(&dmi_thread, NULL, vtpm_manager_thread, &dmi_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch DMI Thread.\n"); - exit(-1); - } - - - if (pthread_create(&hp_thread, NULL, vtpm_manager_thread, &hp_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch HP Thread.\n"); - exit(-1); - } - - //Join the other threads until exit time. - pthread_join(be_thread, NULL); - pthread_join(dmi_thread, NULL); - pthread_join(hp_thread, NULL); - - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Manager shut down unexpectedly.\n"); - - VTPM_Stop_Manager(); - vtpm_lock_destroy(); - return 0; -} diff --git a/tools/vtpm_manager/manager/vtpmpriv.h b/tools/vtpm_manager/manager/vtpmpriv.h deleted file mode 100644 index 41e8d2d..0000000 --- a/tools/vtpm_manager/manager/vtpmpriv.h +++ /dev/null @@ -1,186 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpmpriv.h -// -// Structures and functions private to the manager -// -// ================================================================== - -#ifndef __VTPMPRIV_H__ -#define __VTPMPRIV_H__ - -#include "vtpm_manager.h" -#include "tcg.h" -#include "tcs.h" -#include "buffer.h" -#include "crypto.h" -#include "vtpm_ipc.h" - -#define VTPM_MANAGER_GEN 2 // This is incremented when the manager's table - // is changed. It's used for backwards compatability - -#define STATE_FILE "/var/vtpm/VTPM" -#define DMI_NVM_FILE "/var/vtpm/vtpm_dm_%d.data" -#define VTPM_CTL_DM 0 - -// ------------------------ Private Structures ----------------------- -typedef struct VTPM_DMI_RESOURCE_T { - // I/O info for Manager to talk to DMI's and controllers - vtpm_ipc_handle_t *tx_vtpm_ipc_h; // TX VTPM Results to DMI - vtpm_ipc_handle_t *rx_vtpm_ipc_h; // RX VTPM Commands from DMI - vtpm_ipc_handle_t *tx_tpm_ipc_h; // TX TPM Commands to DMI - vtpm_ipc_handle_t *rx_tpm_ipc_h; // RX TPM Results from DMI - -#ifndef VTPM_MULTI_VM - pid_t dmi_pid; -#endif - - // Non-persistent Information - bool connected; - UINT32 dmi_domain_id; - TCS_CONTEXT_HANDLE TCSContext; // TCS Handle - char *NVMLocation; // NULL term string indicating location - // of NVM. - // Persistent Information about DMI - UINT32 dmi_id; - BYTE dmi_type; - TPM_DIGEST NVM_measurement; // Equal to the SHA1 of the blob - TPM_DIGEST DMI_measurement; // Correct measurement of the owning DMI -} VTPM_DMI_RESOURCE; - -typedef struct tdVTPM_MIGKEY_LIST { - UINT32 name_size; - BYTE *name; // Name of destination (IP addr, domain name, etc) - CRYPTO_INFO key; - struct tdVTPM_MIGKEY_LIST *next; -} VTPM_MIGKEY_LIST; - - -typedef struct tdVTPM_GLOBALS { - // Non-persistent data -#ifndef VTPM_MULTI_VM - pid_t master_pid; -#endif - - int connected_dmis; // To close guest_rx when no dmis are connected - - struct hashtable *dmi_map; // Table of all DMI's known indexed by persistent instance # - VTPM_MIGKEY_LIST *mig_keys; // Table of migration keys - // Currently keys are loaded at migration time, - // TODO: Make VTPM man store a keys persistently - // and update script to check if key is needed - // before fetching it. - - TCS_CONTEXT_HANDLE manager_tcs_handle; // TCS Handle used by manager - TPM_HANDLE storageKeyHandle; // Key used by persistent store - CRYPTO_INFO storageKey; // For software encryption - CRYPTO_INFO bootKey; // For saving table - TCS_AUTH keyAuth; // OIAP session for storageKey - - // Persistent Data - TPM_AUTHDATA owner_usage_auth; // OwnerAuth of real TPM - buffer_t storageKeyWrap; // Wrapped copy of storageKey - TPM_AUTHDATA srk_usage_auth; - TPM_AUTHDATA storage_key_usage_auth; - - buffer_t bootKeyWrap; // Wrapped copy of boot key - -}VTPM_GLOBALS; - -// --------------------------- Global Values -------------------------- -extern VTPM_GLOBALS *vtpm_globals; // Key info and DMI states -extern const TPM_AUTHDATA SRK_AUTH; // SRK Well Known Auth Value - -// ********************** VTPM Functions ************************* -TPM_RESULT VTPM_Init_Manager(); // Start VTPM Service -void VTPM_Stop_Manager(); // Stop VTPM Service -TPM_RESULT VTPM_Manager_Handler(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - BOOL fw_tpm, // Should forward TPM cmds - vtpm_ipc_handle_t *fw_tx_ipc_h, - vtpm_ipc_handle_t *fw_rx_ipc_h, - BOOL is_priv, - char *client_name); - -// ********************** Command Handler Prototypes *********************** - -TPM_RESULT VTPM_Handle_Load_NVM( VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_Save_NVM( VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, - buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Close_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Delete_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_Handle_Migrate_Out ( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_SaveManagerData(void); -TPM_RESULT VTPM_LoadManagerData(void); - -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode); - -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res); - -// Helper functions -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res); -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE type, VTPM_DMI_RESOURCE **dmi_res); - -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, - CRYPTO_INFO *asymkey, - buffer_t *sealed_data); - -TPM_RESULT envelope_decrypt(const buffer_t *cipher, - TCS_CONTEXT_HANDLE TCSContext, - TPM_HANDLE keyHandle, - const TPM_AUTHDATA *key_usage_auth, - buffer_t *unsealed_data); - -#endif // __VTPMPRIV_H__ diff --git a/tools/vtpm_manager/manager/vtsp.c b/tools/vtpm_manager/manager/vtsp.c deleted file mode 100644 index fc8a66f..0000000 --- a/tools/vtpm_manager/manager/vtsp.c +++ /dev/null @@ -1,1042 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtsp.c -// -// Higher level interface to TCS for use in service. -// -// ================================================================== - -#include -#include "tcg.h" -#include "tcs.h" -#include "bsg.h" -#include "log.h" -#include "crypto.h" -#include "vtsp.h" -#include "buffer.h" - -#define RSA_KEY_SIZE 0x0800 - -/*********************************************************************************** - * GenerateAuth: Generate authorization info to be sent back to application - * - * Parameters: outParamDigestText The concatenation of output parameters to be SHA1ed - * outParamDigestTextSize Size of inParamDigestText - * HMACkey Key to be used for HMACing - * For OIAP use key.authUsage or PersistStore.ownerAuth - * For OSAP use shared secret - * pAuth Authorization information from the application - * - * Return: TPM_SUCCESS Authorization data created - * TPM_AUTHFAIL Invalid (NULL) HMACkey presented for OSAP - *************************************************************************************/ -TPM_RESULT GenerateAuth( /*[IN]*/ const BYTE *inParamDigestText, - /*[IN]*/ UINT32 inParamDigestTextSize, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TCS_AUTH *auth) { - - if (inParamDigestText == NULL || auth == NULL) - return (TPM_AUTHFAIL); - else { - - //Generate new OddNonce - Crypto_GetRandom(auth->NonceOdd.nonce, sizeof(TPM_NONCE)); - - // Create SHA1 inParamDigest - TPM_DIGEST inParamDigest; - Crypto_SHA1Full(inParamDigestText, inParamDigestTextSize, (BYTE *) &inParamDigest); - - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - - BSG_PackList( hmacText, 4, - BSG_TPM_DIGEST, &inParamDigest, - BSG_TPM_NONCE, &(auth->NonceEven), - BSG_TPM_NONCE, &(auth->NonceOdd), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); - - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &(auth->HMAC)); - - return(TPM_SUCCESS); - - } -} - -/*********************************************************************************** - * VerifyAuth: Verify the authdata for a command requiring authorization - * - * Parameters: inParamDigestText The concatenation of parameters to be SHA1ed - * inParamDigestTextSize Size of inParamDigestText - * authDataUsage AuthDataUsage for the Entity being used - * Key->authDataUsage or TPM_AUTH_OWNER - * HMACkey Key to be used for HMACing - * For OIAP use key.authUsage or PersistStore.ownerAuth - * For OSAP use NULL (It will be aquired from the Auth Session) - * If unknown (default), assume OIAP - * sessionAuth A TCS_AUTH info for the session - * pAuth Authorization information from the application - * hContext If specified, on failed Auth, VerifyAuth will - * generate a new OIAP session in place of themselves - * destroyed session. - * - * Return: TPM_SUCCESS Authorization Verified - * TPM_AUTHFAIL Authorization Failed - * TPM_FAIL Failure during SHA1 routines - *************************************************************************************/ -TPM_RESULT VerifyAuth( /*[IN]*/ const BYTE *outParamDigestText, - /*[IN]*/ UINT32 outParamDigestTextSize, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TCS_AUTH *auth, - /*[IN]*/ TCS_CONTEXT_HANDLE hContext) { - if (outParamDigestText == NULL || auth == NULL) - return (TPM_AUTHFAIL); - - - // Create SHA1 inParamDigest - TPM_DIGEST outParamDigest; - Crypto_SHA1Full(outParamDigestText, outParamDigestTextSize, (BYTE *) &outParamDigest); - - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - TPM_DIGEST hm; - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - - BSG_PackList( hmacText, 4, - BSG_TPM_DIGEST, &outParamDigest, - BSG_TPM_NONCE, &(auth->NonceEven), - BSG_TPM_NONCE, &(auth->NonceOdd), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); - - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), - (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &hm); - - // Compare correct HMAC with provided one. - if (memcmp (&hm, &(auth->HMAC), sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality - if (!auth->fContinueAuthSession) - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM by fContinue=0.\n", auth->AuthHandle); - - return (TPM_SUCCESS); - } else { - // If specified, reconnect the OIAP session. - // NOTE: This only works for TCS's that never have a 0 context. - if (hContext) { - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM due to failure.\n", auth->AuthHandle); - VTSP_OIAP( hContext, auth); - } - return (TPM_AUTHFAIL); - } -} - -TPM_RESULT VTSP_OIAP(const TCS_CONTEXT_HANDLE hContext, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "OIAP.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPMTRYRETURN( TCSP_OIAP(hContext, - &auth->AuthHandle, - &auth->NonceEven) ); - - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); - goto egress; - - abort_egress: - - egress: - - return status; -} - -TPM_RESULT VTSP_OSAP(const TCS_CONTEXT_HANDLE hContext, - const TPM_ENTITY_TYPE entityType, - const UINT32 entityValue, - const TPM_AUTHDATA *usageAuth, - TPM_SECRET *sharedSecret, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "OSAP.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPM_NONCE nonceEvenOSAP, nonceOddOSAP; - - Crypto_GetRandom((BYTE *) &nonceOddOSAP, sizeof(TPM_NONCE) ); - - TPMTRYRETURN( TCSP_OSAP( hContext, - entityType, - entityValue, - nonceOddOSAP, - &auth->AuthHandle, - &auth->NonceEven, - &nonceEvenOSAP) ); - - // Calculating Session Secret - BYTE sharedSecretText[TPM_DIGEST_SIZE * 2]; - - BSG_PackList( sharedSecretText, 2, - BSG_TPM_NONCE, &nonceEvenOSAP, - BSG_TPM_NONCE, &nonceOddOSAP); - - Crypto_HMAC(sharedSecretText, sizeof(sharedSecretText), (BYTE *) usageAuth, TPM_DIGEST_SIZE, (BYTE *) sharedSecret); - - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); - - goto egress; - - abort_egress: - - egress: - - return status; -} - - -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, - const TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Terminate Handle.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPMTRYRETURN( TCSP_TerminateHandle(hContext, auth->AuthHandle) ); - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM_TerminateHandle.\n", auth->AuthHandle); - goto egress; - - abort_egress: - - egress: - - return status; -} - - -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, - CRYPTO_INFO *crypto_info) { - - TPM_RESULT status; - TPM_NONCE antiReplay; - TPM_DIGEST checksum; - BYTE *pubEKtext; - UINT32 pubEKtextsize; - - vtpmloginfo(VTPM_LOG_VTSP, "Reading Public EK.\n"); - - // GenerateAuth new nonceOdd - Crypto_GetRandom(&antiReplay, sizeof(TPM_NONCE) ); - - - TPMTRYRETURN( TCSP_ReadPubek( hContext, - antiReplay, - &pubEKtextsize, - &pubEKtext, - &checksum) ); - - - // Extract the remaining output parameters - TPM_PUBKEY pubEK; - - BSG_Unpack(BSG_TPM_PUBKEY, pubEKtext, (BYTE *) &pubEK); - - // Build CryptoInfo for the bindingKey - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - pubEK.algorithmParms.parms, - &rsaKeyParms); - - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, - rsaKeyParms.exponent, - pubEK.pubKey.keyLength, - pubEK.pubKey.key, - crypto_info); - - // Destroy rsaKeyParms - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); - - // Set encryption scheme - crypto_info->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - //crypto_info->encScheme = pubEK.algorithmParms.encScheme; - crypto_info->algorithmID = pubEK.algorithmParms.algorithmID; - - goto egress; - - abort_egress: - - egress: - - return status; -} - -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - const TPM_AUTHDATA *srkAuth, - CRYPTO_INFO *ek_cryptoInfo, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Taking Ownership of TPM.\n"); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_TakeOwnership; - TPM_PROTOCOL_ID proto_id = TPM_PID_OWNER; - BYTE *new_srk; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // vars for srkpubkey parameter - TPM_KEY srkPub; - TPM_KEY_PARMS srkKeyInfo = {TPM_ALG_RSA, TPM_ES_RSAESOAEP_SHA1_MGF1, TPM_SS_NONE, 12, 0}; - BYTE srkRSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; - srkKeyInfo.parms = (BYTE *) &srkRSAkeyInfo; - - struct pack_buf_t srkText; - - //These values are accurate for an enc(AuthData). - struct pack_buf_t encOwnerAuth, encSrkAuth; - - encOwnerAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); - encSrkAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); - - if (encOwnerAuth.data == NULL || encSrkAuth.data == NULL) { - vtpmloginfo(VTPM_LOG_VTSP, "Could not malloc encrypted auths.\n"); - status = TPM_RESOURCES; - goto abort_egress; - } - - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) ownerAuth, &encOwnerAuth.size, encOwnerAuth.data); - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) srkAuth, &encSrkAuth.size, encSrkAuth.data); - - - // Build srk public key struct - srkPub.ver = TPM_STRUCT_VER_1_1; - srkPub.keyUsage = TPM_KEY_STORAGE; - srkPub.keyFlags = 0x00; - srkPub.authDataUsage = TPM_AUTH_ALWAYS; - memcpy(&srkPub.algorithmParms, &srkKeyInfo, sizeof(TPM_KEY_PARMS)); - srkPub.PCRInfoSize = 0; - srkPub.PCRInfo = 0; - srkPub.pubKey.keyLength= 0; - srkPub.encDataSize = 0; - - srkText.data = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - srkText.size = BSG_Pack(BSG_TPM_KEY, (BYTE *) &srkPub, srkText.data); - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 5, - BSG_TPM_COMMAND_CODE,&command, - BSG_TPM_PROTOCOL_ID, &proto_id, - BSG_TPM_SIZE32_DATA, &encOwnerAuth, - BSG_TPM_SIZE32_DATA, &encSrkAuth, - BSG_TPM_KEY, &srkPub); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, ownerAuth, auth) ); - - new_srk = srkText.data; - TPMTRYRETURN( TCSP_TakeOwnership ( hContext, - proto_id, - encOwnerAuth.size, - encOwnerAuth.data, - encSrkAuth.size, - encSrkAuth.data, - &srkText.size, - &new_srk, - auth ) ); - - - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - memcpy(paramText + paramTextSize, new_srk, srkText.size); - paramTextSize += srkText.size; - - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - ownerAuth, auth, - hContext) ); - - goto egress; - - abort_egress: - - egress: - - free(srkText.data); - free(encSrkAuth.data); - free(encOwnerAuth.data); - free(paramText); - - TCS_FreeMemory(hContext, new_srk); - - return status; -} - -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Disabling Pubek Read.\n"); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_DisablePubekRead; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 1, - BSG_TPM_COMMAND_CODE, &command); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - ownerAuth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_DisablePubekRead ( hContext, // in - auth) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - ownerAuth, auth, - hContext) ); - goto egress; - - abort_egress: - egress: - free(paramText); - return status; -} - -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_USAGE usage, - const TPM_AUTHDATA *newKeyAuth, - const TCS_KEY_HANDLE parentHandle, - const TPM_AUTHDATA *osapSharedSecret, - buffer_t *pubKeyBuf, - TCS_AUTH *auth) { - - int i; - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_CreateWrapKey; - - vtpmloginfo(VTPM_LOG_VTSP, "Creating new key of type %d.\n", usage); - - // vars for Calculate encUsageAuth - BYTE *paramText; - UINT32 paramTextSize; - - // vars for Calculate encUsageAuth - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - TPM_DIGEST XORKey1; - UINT32 XORbufferSize; - TPM_SECRET encUsageAuth, encMigrationAuth; - - // vars for Flatten newKey prototype - BYTE *flatKey = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - UINT32 flatKeySize = TCPA_MAX_BUFFER_LENGTH; - struct pack_buf_t newKeyText; - - // Fill in newKey - TPM_KEY newKey; - - BYTE RSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; - newKey.algorithmParms.algorithmID = TPM_ALG_RSA; - newKey.algorithmParms.parms = (BYTE *) &RSAkeyInfo; - newKey.algorithmParms.parmSize = 12; - - switch (usage) { - case TPM_KEY_SIGNING: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Signing Key...\n"); - newKey.keyUsage = TPM_KEY_SIGNING; - newKey.algorithmParms.encScheme = TPM_ES_NONE; - newKey.algorithmParms.sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1; - break; - case TPM_KEY_STORAGE: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Storage Key...\n"); - newKey.keyUsage = TPM_KEY_STORAGE; - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - newKey.algorithmParms.sigScheme = TPM_SS_NONE; - break; - case TPM_KEY_BIND: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Binding Key...\n"); - newKey.keyUsage = TPM_KEY_BIND; - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - newKey.algorithmParms.sigScheme = TPM_SS_NONE; - break; - default: - vtpmloginfo(VTPM_LOG_VTSP, "Cannot create key. Invalid Key Type.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - - newKey.ver = TPM_STRUCT_VER_1_1; - - newKey.keyFlags = 0; - newKey.authDataUsage = TPM_AUTH_ALWAYS; - newKey.pubKey.keyLength= 0; - newKey.encDataSize = 0; - newKey.encData = NULL; - - // FIXME: Support PCR bindings - newKey.PCRInfoSize = 0; - newKey.PCRInfo = NULL; - - // Calculate encUsageAuth - XORbufferSize = BSG_PackList( XORbuffer, 2, - BSG_TPM_SECRET, osapSharedSecret, - BSG_TPM_NONCE, &auth->NonceEven); - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey1); - - // FIXME: No support for migratable keys. - for (i=0; i < TPM_DIGEST_SIZE; i++) - ((BYTE *) &encUsageAuth)[i] = ((BYTE *) &XORKey1)[i] ^ ((BYTE *) newKeyAuth)[i]; - - // Flatten newKey prototype - flatKeySize = BSG_Pack(BSG_TPM_KEY, (BYTE *) &newKey, flatKey); - newKeyText.data = flatKey; - newKeyText.size = flatKeySize; - - // Generate HMAC - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_AUTHDATA, &encUsageAuth, - BSG_TPM_AUTHDATA, &encMigrationAuth); - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); - paramTextSize += newKeyText.size; - - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - osapSharedSecret, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_CreateWrapKey( hContext, - parentHandle, - encUsageAuth, - encMigrationAuth, - &newKeyText.size, - &newKeyText.data, - auth) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); - paramTextSize += newKeyText.size; - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - osapSharedSecret, auth, 0) ); - - // Unpack/return key structure - TPMTRYRETURN(buffer_init(pubKeyBuf, 0, 0) ); - TPMTRYRETURN(buffer_append_raw(pubKeyBuf, newKeyText.size, newKeyText.data) ); - - goto egress; - - abort_egress: - - egress: - - free(flatKey); - free(paramText); - TCS_FreeMemory(hContext, newKeyText.data); - - return status; -} - -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, - const TCS_KEY_HANDLE hUnwrappingKey, - const buffer_t *rgbWrappedKeyBlob, - const TPM_AUTHDATA *parentAuth, - TPM_HANDLE *newKeyHandle, - TCS_AUTH *auth, - CRYPTO_INFO *cryptoinfo, - const BOOL skipTPMLoad) { - - - vtpmloginfo(VTPM_LOG_VTSP, "Loading Key %s.\n", (!skipTPMLoad ? "into TPM" : "only into memory")); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_LoadKey; - - BYTE *paramText=NULL; // Digest to make Auth. - UINT32 paramTextSize; - - // SkipTPMLoad stops key from being loaded into TPM, but still generates CRYPTO_INFO for it - if (! skipTPMLoad) { - - if ((rgbWrappedKeyBlob == NULL) || (parentAuth == NULL) || - (newKeyHandle==NULL) || (auth==NULL)) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Generate Extra TCS Parameters - TPM_HANDLE phKeyHMAC; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 1, - BSG_TPM_COMMAND_CODE, &command); - - memcpy(paramText + paramTextSize, rgbWrappedKeyBlob->bytes, buffer_len(rgbWrappedKeyBlob)); - paramTextSize += buffer_len(rgbWrappedKeyBlob); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - parentAuth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_LoadKeyByBlob( hContext, - hUnwrappingKey, - buffer_len(rgbWrappedKeyBlob), - rgbWrappedKeyBlob->bytes, - auth, - newKeyHandle, - &phKeyHMAC) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_HANDLE, newKeyHandle); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - parentAuth, auth, - hContext) ); - } - - // Build cryptoinfo structure for software crypto function. - if (cryptoinfo != NULL) { - TPM_KEY newKey; - - // Unpack/return key structure - BSG_Unpack(BSG_TPM_KEY, rgbWrappedKeyBlob->bytes , &newKey); - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - newKey.algorithmParms.parms, - &rsaKeyParms); - - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, - rsaKeyParms.exponent, - newKey.pubKey.keyLength, - newKey.pubKey.key, - cryptoinfo); - - // Destroy rsaKeyParms - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); - - // Set encryption scheme - cryptoinfo->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - } - - goto egress; - - abort_egress: - - egress: - - free(paramText); - return status; -} - -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE key_handle, - const buffer_t *bound_data, - const TPM_AUTHDATA *usage_auth, - buffer_t *clear_data, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Unbinding %d bytes of data.\n", buffer_len(bound_data)); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_UnBind; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // Generate Extra TCS Parameters - struct pack_buf_t clear_data32; - BYTE *clear_data_text; - UINT32 clear_data_size; - - struct pack_buf_t bound_data32 = {bound_data->size, bound_data->bytes}; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_SIZE32_DATA, &bound_data32); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - usage_auth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_UnBind( hContext, - key_handle, - buffer_len(bound_data), - bound_data->bytes, - auth, - &clear_data_size, - &clear_data_text) ); - - - // Verify Auth - clear_data32.size = clear_data_size; - clear_data32.data = clear_data_text; - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_SIZE32_DATA, &clear_data32); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - usage_auth, auth, - hContext) ); - - // Unpack/return key structure - TPMTRYRETURN(buffer_init(clear_data, 0, 0)); - TPMTRYRETURN(buffer_append_raw (clear_data, clear_data_size, clear_data_text) ); - - goto egress; - - abort_egress: - - egress: - - free(paramText); - TCS_FreeMemory(hContext, clear_data_text); - - return status; -} - -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, - const buffer_t *inData, - buffer_t *outData) -{ - vtpmloginfo(VTPM_LOG_VTSP, "Binding %d bytes of data.\n", buffer_len(inData)); - TPM_RESULT status = TPM_SUCCESS; - TPM_BOUND_DATA boundData; - UINT32 i; - - // Fill boundData's accessory information - boundData.ver = TPM_STRUCT_VER_1_1; - boundData.payload = TPM_PT_BIND; - boundData.payloadData = inData->bytes; - - // Pack boundData before encryption - BYTE* flatBoundData = (BYTE *)malloc(sizeof(BYTE) * - (sizeof(TPM_VERSION) + - sizeof(TPM_PAYLOAD_TYPE) + - buffer_len(inData))); - if (flatBoundData == NULL) { - return TPM_NOSPACE; - } - UINT32 flatBoundDataSize = 0; - flatBoundDataSize = BSG_PackList( flatBoundData, 2, - BSG_TPM_VERSION, &boundData.ver, - BSG_TYPE_BYTE, &boundData.payload); - - memcpy(flatBoundData+flatBoundDataSize, inData->bytes, buffer_len(inData)); - flatBoundDataSize += buffer_len(inData); - - BYTE out_tmp[RSA_KEY_SIZE/8]; // RSAEnc does not do blocking, So this is what will come out. - UINT32 out_tmp_size; - - // Encrypt flatBoundData - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_RSAEnc( cryptoInfo, - flatBoundDataSize, - flatBoundData, - &out_tmp_size, - out_tmp) ); - - if (out_tmp_size > RSA_KEY_SIZE/8) { - // The result of RSAEnc should be a fixed size based on key size. - vtpmlogerror(VTPM_LOG_VTSP, "Enc buffer just overflowed.\n"); - } - - buffer_init(outData, 0, NULL); - buffer_append_raw(outData, out_tmp_size, out_tmp); - - vtpmloginfo(VTPM_LOG_TXDATA, "Bind Generated[%d] = 0x", out_tmp_size); - for(i = 0 ; i < out_tmp_size ; i++) { - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out_tmp[i]); - } - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - goto egress; - abort_egress: - egress: - - // Free flatBoundData - free(flatBoundData); - - return TPM_SUCCESS; -} - -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE keyHandle, - const TPM_AUTHDATA *sealDataAuth, - const TPM_PCR_COMPOSITE *pcrComp, - const buffer_t *inData, - TPM_STORED_DATA *sealedData, - const TPM_SECRET *osapSharedSecret, - TCS_AUTH *auth) { - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_Seal; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // Generate PCR_Info Struct from Comp - TPM_PCR_INFO pcrInfo; - UINT32 pcrInfoSize, flatpcrSize; - BYTE flatpcr[3 + // PCR_Select = 3 1 byte banks - sizeof(UINT16) + // 2 byte UINT16 - sizeof(UINT32) + // PCR_Comp = 4 byte UINT32 - 24 * sizeof(TPM_PCRVALUE) ]; // up to 24 PCRs - - if (pcrComp != NULL) { - //printf("\n\tBinding to PCRs: "); - //for(int i = 0 ; i < pcrComp->select.sizeOfSelect ; i++) - //printf("%2.2x", pcrComp->select.pcrSelect[i]); - - memcpy(&pcrInfo.pcrSelection, &pcrComp->select, sizeof(TPM_PCR_SELECTION)); - - flatpcrSize = BSG_Pack(BSG_TPM_PCR_COMPOSITE, (BYTE *) pcrComp, flatpcr); - Crypto_SHA1Full((BYTE *) flatpcr, flatpcrSize, (BYTE *) &(pcrInfo.digestAtRelease)); - memset(&(pcrInfo.digestAtCreation), 0, sizeof(TPM_DIGEST)); - pcrInfoSize = BSG_Pack(BSG_TPM_PCR_INFO, (BYTE *) &pcrInfo, flatpcr); - } else { - //printf("\n\tBinding to no PCRS."); - pcrInfoSize = 0; - } - - // Calculate encUsageAuth - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - UINT32 XORbufferSize = sizeof(XORbuffer); - TPM_DIGEST XORKey; - TPM_ENCAUTH encAuth; - - BSG_PackList( XORbuffer, 2, - BSG_TPM_SECRET, osapSharedSecret, - BSG_TPM_NONCE, &auth->NonceEven ); - - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey); - - int i; - for (i=0; i < TPM_DIGEST_SIZE; i++) - ((BYTE *) &encAuth)[i] = ((BYTE *) &XORKey)[i] ^ ((BYTE *) sealDataAuth)[i]; - - // Generate Extra TCS Parameters - UINT32 inDataSize = buffer_len(inData); - struct pack_buf_t inData_pack = {inDataSize, inData->bytes}; - struct pack_buf_t pcrInfo_pack = {pcrInfoSize, flatpcr}; - - UINT32 sealedDataSize; - BYTE *flatSealedData=NULL; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 4, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_ENCAUTH, &encAuth, - BSG_TPM_SIZE32_DATA, &pcrInfo_pack, - BSG_TPM_SIZE32_DATA, &inData_pack); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - osapSharedSecret, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_Seal( hContext, - keyHandle, - encAuth, - pcrInfoSize, - flatpcr, - inDataSize, - inData->bytes, - auth, - &sealedDataSize, - &flatSealedData) ); - - // Unpack/return key structure - BSG_Unpack( BSG_TPM_STORED_DATA, flatSealedData, sealedData ); - - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_STORED_DATA, sealedData); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - osapSharedSecret, auth, - 0) ); - - - goto egress; - - abort_egress: - egress: - - if (flatSealedData) - TCS_FreeMemory( hContext, flatSealedData); - - free(paramText); - return status; -} - - -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE keyHandle, - const TPM_STORED_DATA *sealedData, - const TPM_AUTHDATA *key_usage_auth, - const TPM_AUTHDATA *data_usage_auth, - buffer_t *outData, - TCS_AUTH *auth, - TCS_AUTH *dataAuth) { - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_Unseal; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // Generate Extra TCS Parameters - UINT32 sealDataSize, clearDataSize; - BYTE *flatSealedData= (BYTE *) malloc(sizeof(TPM_VERSION) + - 2 * sizeof(UINT32) + - sealedData->sealInfoSize + - sealedData->encDataSize), - *clearData=NULL; - - sealDataSize = BSG_Pack(BSG_TPM_STORED_DATA, sealedData, flatSealedData ); - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_STORED_DATA, sealedData); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - key_usage_auth, auth) ); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - data_usage_auth, dataAuth) ); - // Call TCS - TPMTRYRETURN( TCSP_Unseal( hContext, - keyHandle, - sealDataSize, - flatSealedData, - auth, - dataAuth, - &clearDataSize, - &clearData) ); - - // Verify Auth - struct pack_buf_t clearData_pack = {clearDataSize, clearData}; - - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_SIZE32_DATA, &clearData_pack); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - key_usage_auth, auth, - hContext) ); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - data_usage_auth, dataAuth, - hContext) ); - - // Unpack/return key structure - TPMTRYRETURN( buffer_init(outData, clearDataSize, clearData) ); - - goto egress; - - abort_egress: - egress: - - if (flatSealedData) - TCS_FreeMemory( hContext, clearData); - - free(paramText); - return status; -} - -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext) { - - vtpmloginfo(VTPM_LOG_VTSP, "Calling TPM_SaveState.\n"); - - TPM_RESULT status = TPM_SUCCESS; - - // Call TCS - return ( TCSP_SaveState ( hContext ) ); - -} - - -// Function Reaches into unsupported TCS command, beware. -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, - const buffer_t *inbuf, - buffer_t *outbuf ) { - - vtpmloginfo(VTPM_LOG_VTSP, "Passthrough in use.\n"); - TPM_RESULT status = TPM_SUCCESS; - - // Generate Extra TCS Parameters - BYTE *resultText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - UINT32 resultTextSize = TCPA_MAX_BUFFER_LENGTH; - - // Call TCS - TPMTRYRETURN( TCSP_RawTransmitData(buffer_len(inbuf), inbuf->bytes, - &resultTextSize, resultText) ); - - // Unpack/return key structure - TPMTRYRETURN(buffer_init (outbuf, resultTextSize, resultText) ); - goto egress; - - abort_egress: - - egress: - TCS_FreeMemory(hContext, resultText); - free(resultText); - return status; -} diff --git a/tools/vtpm_manager/manager/vtsp.h b/tools/vtpm_manager/manager/vtsp.h deleted file mode 100644 index 2fb0440..0000000 --- a/tools/vtpm_manager/manager/vtsp.h +++ /dev/null @@ -1,126 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtsp.h -// -// Higher level interface to TCS. -// -// ================================================================== - -#ifndef __VTSP_H__ -#define __VTSP_H__ - -#include "tcg.h" -#include "tcs.h" - -#define KEY_BUFFER_SIZE 2048 - -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, - const buffer_t *inbuf, - buffer_t *outbuf ); - -TPM_RESULT VTSP_OIAP( const TCS_CONTEXT_HANDLE hContext, - TCS_AUTH *auth); - -TPM_RESULT VTSP_OSAP( const TCS_CONTEXT_HANDLE hContext, - const TPM_ENTITY_TYPE entityType, - const UINT32 entityValue, - const TPM_AUTHDATA *usageAuth, - TPM_SECRET *sharedsecret, - TCS_AUTH *auth); - -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, - const TCS_AUTH *auth); - -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, - CRYPTO_INFO *cypto_info); - -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - const TPM_AUTHDATA *srkAuth, - CRYPTO_INFO *ek_cryptoInfo, - TCS_AUTH *auth); - -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - TCS_AUTH *auth); - -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_USAGE usage, - const TPM_AUTHDATA *newKeyAuth, - const TCS_KEY_HANDLE parentHandle, - const TPM_AUTHDATA *osapSharedSecret, - buffer_t *pubKeyBuf, - TCS_AUTH *auth); - -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, - const TCS_KEY_HANDLE hUnwrappingKey, - const buffer_t *rgbWrappedKeyBlob, - const TPM_AUTHDATA *parentAuth, - TPM_HANDLE *newKeyHandle, - TCS_AUTH *pAuth, - CRYPTO_INFO *cryptoinfo, - const BOOL skipTPMLoad); - -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE key_handle, - const buffer_t *bound_data, - const TPM_AUTHDATA *usage_auth, - buffer_t *clear_data, - TCS_AUTH *auth); - -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, - const buffer_t *inData, - buffer_t *outData); - -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE keyHandle, - const TPM_AUTHDATA *sealDataAuth, - const TPM_PCR_COMPOSITE *pcrComp, - const buffer_t *inData, - TPM_STORED_DATA *sealedData, - const TPM_SECRET *osapSharedSecret, - TCS_AUTH *auth); - -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE keyHandle, - const TPM_STORED_DATA *sealedData, - const TPM_AUTHDATA *key_usage_auth, - const TPM_AUTHDATA *data_usage_auth, - buffer_t *outData, - TCS_AUTH *auth, - TCS_AUTH *dataAuth); - -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext); - -#endif //_VTSP_H_ diff --git a/tools/vtpm_manager/migration/Makefile b/tools/vtpm_manager/migration/Makefile deleted file mode 100644 index e33ae95..0000000 --- a/tools/vtpm_manager/migration/Makefile +++ /dev/null @@ -1,42 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -VPATH = ../manager - -BIND = vtpm_migratord -BINC = vtpm_migrator - -SRCSD = vtpm_manager_if.c vtpm_migratord.c vtpm_migratord_handler.c vtpm_ipc.c -SRCSC = vtpm_manager_if.c vtpm_migrator_if.c vtpm_migratorc.c vtpm_ipc.c - -OBJSD = $(patsubst %.c,%.o,$(SRCSD)) -OBJSC = $(patsubst %.c,%.o,$(SRCSC)) - -.PHONY: all -all: build - -.PHONY: build -build: $(BIND) $(BINC) - -.PHONY: install -install: build - $(INSTALL_PROG) $(BIND) $(DESTDIR)$(BINDIR) - $(INSTALL_PROG) $(BINC) $(DESTDIR)$(BINDIR) - -.PHONY: clean -clean: - rm -f $(BINC) $(BIND) - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIND): $(OBJSD) - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ - -$(BINC): $(OBJSC) - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ - -# libraries -LIBS += ../util/libTCGUtils.a diff --git a/tools/vtpm_manager/migration/vtpm_manager_if.c b/tools/vtpm_manager/migration/vtpm_manager_if.c deleted file mode 100644 index 08986f4..0000000 --- a/tools/vtpm_manager/migration/vtpm_manager_if.c +++ /dev/null @@ -1,186 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager_if.c -// -// Provides functions to call local vtpm manager interface (Hotplug) -// -// ================================================================== - -#include -#include -#include -#include - -#include "tcg.h" -#include "buffer.h" -#include "log.h" -#include "vtpm_ipc.h" -#include "bsg.h" -#include "vtpm_migrator.h" -#include "vtpm_manager.h" - -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" - -static vtpm_ipc_handle_t tx_ipc_h, rx_ipc_h; - -TPM_RESULT vtpm_manager_open(){ - - if ( (vtpm_ipc_init(&tx_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || //FIXME: wronly - (vtpm_ipc_init(&rx_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { //FIXME: rdonly - vtpmlogerror(VTPM_LOG_VTPM, "Unable to connect to vtpm_manager.\n"); - return TPM_IOERROR; - } - - return TPM_SUCCESS; -} - -void vtpm_manager_close() { - - vtpm_ipc_close(&tx_ipc_h); - vtpm_ipc_close(&rx_ipc_h); -} - - -TPM_RESULT vtpm_manager_command(TPM_COMMAND_CODE ord, - buffer_t *command_param_buf, - TPM_RESULT *cmd_status, /* out */ - buffer_t *result_param_buf) { - - TPM_RESULT status = TPM_FAIL; - int size_read, size_write, i; - BYTE *adj_command, response_header[VTPM_COMMAND_HEADER_SIZE_SRV]; - UINT32 dmi_id=0, adj_command_size, out_param_size, adj_param_size; - TPM_TAG tag=VTPM_TAG_REQ; - - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - adj_command_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(command_param_buf); - adj_command = (BYTE *) malloc( adj_command_size ); - if (!adj_command) { - status = TPM_RESOURCES; - goto abort_egress; - } - - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); - BSG_PackList(adj_command, 4, - BSG_TYPE_UINT32, &dmi_id, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, &out_param_size, - BSG_TPM_COMMAND_CODE, &ord ); - - memcpy(adj_command + VTPM_COMMAND_HEADER_SIZE_SRV, command_param_buf->bytes, buffer_len(command_param_buf)); - - size_write = vtpm_ipc_write(&tx_ipc_h, NULL, adj_command, adj_command_size); - - if (size_write > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MGR): 0x"); - for (i=0; i< adj_command_size; i++) { - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", adj_command[i]); - } - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error writing VTPM Manager console.\n"); - status = TPM_IOERROR; - goto abort_egress; - } - - if (size_write != (int) adj_command_size ) - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to mgr (%d/%d)\n", size_write, adj_command_size); - - // Read header for response to manager command - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, response_header, VTPM_COMMAND_HEADER_SIZE_SRV); - if (size_read > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MGR): 0x"); - for (i=0; i 0) { - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, result_param_buf->bytes, adj_param_size); - if (size_read > 0) { - for (i=0; i< size_read; i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); - - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); - goto abort_egress; - } - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - - if (size_read < (int)adj_param_size) { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); - status = TPM_IOERROR; - goto abort_egress; - } - } else { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - } - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} - - diff --git a/tools/vtpm_manager/migration/vtpm_migrator.h b/tools/vtpm_manager/migration/vtpm_migrator.h deleted file mode 100644 index 8d52e66..0000000 --- a/tools/vtpm_manager/migration/vtpm_migrator.h +++ /dev/null @@ -1,104 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_migrator.h -// -// Public Interface header for VTPM Migrator -// -// ================================================================== - -#ifndef __VTPM_MIGRATOR_H__ -#define __VTPM_MIGRATOR_H__ - -#define VTPM_MTAG_REQ 0x02c1 -#define VTPM_MTAG_RSP 0x02c4 - -// Header sizes. -#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) - -//*********************** Connection Info ************************** -#define VTPM_MIG_PORT 48879 - -//************************ Command Codes *************************** -#define VTPM_MORD_MIG_STEP1 0x00 -#define VTPM_MORD_MIG_STEP2 0x01 -#define VTPM_MORD_MIG_STEP3 0x02 -#define VTPM_MORD_MIG_STEP4 0x03 - -//************************ Return Codes **************************** -#define VTPM_SUCCESS 0 -#define VTPM_FAIL 1 - -/******************* Command Parameter API ************************* - -VTPM Command Format - tpm tag: 2 bytes - command size: 4 bytes // Size of command including header but not DMI - ord: 4 bytes // Command ordinal above - parameters: size - 10 bytes // Command Parameter - -VTPM Response Format - tpm tag: 2 bytes - response_size: 4 bytes - status: 4 bytes - parameters: size - 10 bytes - - -VTPM_Mig_Phase1: - Unsupported: (Handled by scripts) - -VTPM_Mig_Phase2 - Input Parameters: - domain_name_size: 4 bytes - domain_name : domain_name_size bytes - Output Parameters: - pub_exp_size: 4 bytes - pub_exp: pub_exp_size bytes - pub_mod_size: 4 bytes - pub_mod: pub_mod_size bytes - -VTPM_Mig_Phase3 - Input Parameters: - vtpm_state_size: 4 bytes - vtpm_state: vtpm_state_size bytes - Output Parameters: - none - -VTPM_Mig_Phase4 - Unsupported: (Handled by scripts) - - -*********************************************************************/ - -#endif //_VTPM_MANAGER_H_ diff --git a/tools/vtpm_manager/migration/vtpm_migrator_if.c b/tools/vtpm_manager/migration/vtpm_migrator_if.c deleted file mode 100644 index de48b2d..0000000 --- a/tools/vtpm_manager/migration/vtpm_migrator_if.c +++ /dev/null @@ -1,219 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_migrator_if.c -// -// Provides functions to call open network connection & call -// a function on the vtpm_migratord on the destination -// -// ================================================================== - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "tcg.h" -#include "buffer.h" -#include "log.h" -#include "bsg.h" -#include "vtpm_migrator.h" - -static int sock_desc; - - -TPM_RESULT vtpm_migratord_open(char *server_address){ - - TPM_RESULT status = TPM_FAIL; - - /* network variables */ - struct in_addr ip_addr; - struct sockaddr_in server_addr; - int addr_len; - struct hostent *dns_info=NULL; - - /* set up connection to server*/ - dns_info = gethostbyname(server_address); - ip_addr.s_addr = *((unsigned long *) dns_info->h_addr_list[0]); - - if(ip_addr.s_addr < 0) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /* set up server variable */ - memset((char *)&server_addr, 0, sizeof(server_addr)); - server_addr.sin_family = AF_INET; - server_addr.sin_port = htons(VTPM_MIG_PORT); - server_addr.sin_addr.s_addr = ip_addr.s_addr; - - /* open socket, make connection */ - sock_desc = socket(AF_INET, SOCK_STREAM, 0); - - if (sock_desc < 0 ) { - status = TPM_IOERROR; - goto abort_egress; - } - - if (connect(sock_desc, - (struct sockaddr *)&server_addr, - sizeof(server_addr)) < 0 ) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - status = TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} - -void vtpm_migratord_close() { - close(sock_desc); -} - - -TPM_RESULT vtpm_migratord_command(TPM_COMMAND_CODE ord, - buffer_t *command_param_buf, - TPM_RESULT *cmd_status, /* out */ - buffer_t *result_param_buf) { - - TPM_RESULT status = TPM_FAIL; - int size_read, size_write, i; - BYTE *command, response_header[VTPM_COMMAND_HEADER_SIZE]; - UINT32 dmi_id=0, command_size, out_param_size, adj_param_size; - TPM_TAG tag=VTPM_MTAG_REQ; - - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - command_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); - command = (BYTE *) malloc( command_size ); - if (!command) { - status = TPM_RESOURCES; - goto abort_egress; - } - - BSG_PackList(command, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, &command_size, - BSG_TPM_COMMAND_CODE, &ord ); - - memcpy(command + VTPM_COMMAND_HEADER_SIZE, command_param_buf->bytes, buffer_len(command_param_buf)); - - size_write = write(sock_desc, command, command_size); - - if (size_write > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MIGd): 0x"); - for (i=0; i< command_size; i++) { - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", command[i]); - } - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error writing to migration server via network.\n"); - status = TPM_IOERROR; - goto abort_egress; - } - - if (size_write != (int) command_size ) - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to migration server (%d/%d)\n", size_write, command_size); - - // Read header for response - size_read = read(sock_desc, response_header, VTPM_COMMAND_HEADER_SIZE); - if (size_read > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MIGd): 0x"); - for (i=0; i 0) { - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); - size_read = read(sock_desc, result_param_buf->bytes, adj_param_size); - if (size_read > 0) { - for (i=0; i< size_read; i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); - - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from migration server.\n"); - goto abort_egress; - } - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - - if (size_read < (int)adj_param_size) { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); - status = TPM_IOERROR; - goto abort_egress; - } - } else { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - } - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} - - diff --git a/tools/vtpm_manager/migration/vtpm_migratorc.c b/tools/vtpm_manager/migration/vtpm_migratorc.c deleted file mode 100644 index 18b3bdb..0000000 --- a/tools/vtpm_manager/migration/vtpm_migratorc.c +++ /dev/null @@ -1,211 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -#include -#include - -#include "tcg.h" -#include "log.h" -#include "bsg.h" -#include "buffer.h" -#include "vtpm_migrator.h" -#include "vtpm_manager.h" - -TPM_RESULT handle_vtpm_mig_step2(char *server_addr, - char *name, - UINT32 instance) { - TPM_RESULT status, cmd_status; - buffer_t out_param_buf=NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; - UINT32 offset; - struct pack_buf_t addr_data32; - - //===== Get Destination's Public Migration Key ====== - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); - - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP2, - &out_param_buf, - &cmd_status, - &mig_key_buf) ); - vtpm_migratord_close(); - - TPMTRYRETURN(cmd_status); - - //===== Load migration key into vtpm_manager ======== - - addr_data32.data = (BYTE *)server_addr; - addr_data32.size = strlen(server_addr) + 1; // Include the null - - TPMTRYRETURN ( buffer_init ( &out_param_buf, - sizeof(UINT32) + addr_data32.size +buffer_len(&mig_key_buf), - NULL ) ) ; - - offset = BSG_PackList(out_param_buf.bytes, 1, - BSG_TPM_SIZE32_DATA, &addr_data32); - - memcpy(out_param_buf.bytes + offset , mig_key_buf.bytes, buffer_len(&mig_key_buf) ); - - TPMTRYRETURN ( vtpm_manager_open() ); - - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_LOAD_MIG_KEY, - &out_param_buf, - &cmd_status, - &empty_buf) ); - - vtpm_manager_close(); - - TPMTRYRETURN(cmd_status); - - goto egress; - - abort_egress: - egress: - - buffer_free(&mig_key_buf); - buffer_free(&out_param_buf); - - return status; -} - - -TPM_RESULT handle_vtpm_mig_step3(char *server_addr, - char *name, - UINT32 instance) { - TPM_RESULT status, cmd_status; - buffer_t out_param_buf=NULL_BUF, state_buf=NULL_BUF, empty_buf=NULL_BUF; - struct pack_buf_t addr_data32, name_data32, state_data32; - - //===== Get vtpm state from vtpm_manager ======== - addr_data32.data = (BYTE *)server_addr; - addr_data32.size = strlen(server_addr) + 1; // Include the null - - TPMTRYRETURN ( buffer_init ( &out_param_buf, - (2 * sizeof(UINT32)) + addr_data32.size, - NULL ) ) ; - - BSG_PackList(out_param_buf.bytes, 2, - BSG_TYPE_UINT32, &instance, - BSG_TPM_SIZE32_DATA, &addr_data32); - - TPMTRYRETURN ( vtpm_manager_open() ); - - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_MIGRATE_OUT, - &out_param_buf, - &cmd_status, - &state_buf) ); - - vtpm_manager_close(); - - TPMTRYRETURN(cmd_status); - - TPMTRYRETURN( buffer_free( &out_param_buf ) ); - - //===== Send vtpm state to destination ====== - name_data32.data = (BYTE *)name; - name_data32.size = strlen(name) + 1; // Include the null - state_data32.data = state_buf.bytes; - state_data32.size = buffer_len(&state_buf); - - TPMTRYRETURN( buffer_init( &out_param_buf, - 2 * sizeof(UINT32) + name_data32.size + state_data32.size, - NULL ) ) ; - - BSG_PackList(out_param_buf.bytes, 2, - BSG_TPM_SIZE32_DATA, &name_data32, - BSG_TPM_SIZE32_DATA, &state_data32); - - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); - - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP3, - &out_param_buf, - &cmd_status, - &empty_buf) ); - vtpm_migratord_close(); - - TPMTRYRETURN(cmd_status); - - goto egress; - - abort_egress: - egress: - - buffer_free( &out_param_buf); - buffer_free( &state_buf); - buffer_free( &empty_buf); - - return status; -} - - -// Usage vtpm_migrator addr domain_name instance step - -int main(int argc, char **argv) { - - /* variables for processing of command */ - TPM_RESULT status = TPM_FAIL; - char *server_addr, *name; - UINT32 instance, step; - - if (argc != 5) { - vtpmlogerror(VTPM_LOG_VTPM, "Usage: vtpm_migrator addr vm_name instance step\n"); - vtpmlogerror(VTPM_LOG_VTPM, " params given %d\n", argc); - status= TPM_BAD_PARAMETER; - goto abort_egress; - } - - server_addr = argv[1]; - name = argv[2]; - instance = atoi( argv[3] ); - step = atoi( argv[4] ); - - switch (step) { - case VTPM_MORD_MIG_STEP2: - status = handle_vtpm_mig_step2(server_addr, name, instance); - break; - - case VTPM_MORD_MIG_STEP3: - status = handle_vtpm_mig_step3(server_addr, name, instance); - break; - - default: - status = TPM_BAD_PARAMETER; - goto abort_egress; - break; - } - - goto egress; - abort_egress: - egress: - - return status; -} - diff --git a/tools/vtpm_manager/migration/vtpm_migratord.c b/tools/vtpm_manager/migration/vtpm_migratord.c deleted file mode 100644 index ea18c8c..0000000 --- a/tools/vtpm_manager/migration/vtpm_migratord.c +++ /dev/null @@ -1,202 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -#include -#include -#include -#include -#include -#include - -#include "tcg.h" -#include "log.h" -#include "bsg.h" -#include "buffer.h" -#include "vtpm_migrator.h" - -void build_error_msg( buffer_t *buf, TPM_RESULT status) { - TPM_TAG tag = VTPM_MTAG_RSP; - UINT32 out_param_size = VTPM_COMMAND_HEADER_SIZE; - - buffer_init(buf, out_param_size, NULL); - - BSG_PackList(buf->bytes, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, &out_param_size, - BSG_TPM_RESULT, &status ); -} - -int main() { - - /* network variables */ - int sock_descr, client_sock=-1, len; - struct sockaddr_in addr; - struct sockaddr_in client_addr; - unsigned int client_length; - int bytes; - - /* variables for processing of command */ - TPM_RESULT status = TPM_FAIL; - BYTE cmd_header[VTPM_COMMAND_HEADER_SIZE]; - TPM_TAG tag; - TPM_COMMAND_CODE ord; - UINT32 in_param_size, adj_param_size; - int i, size_read, size_write; - buffer_t in_param_buf=NULL_BUF, result_buf=NULL_BUF; - - - /* setup socket */ - sock_descr = socket(AF_INET, SOCK_STREAM, 0); - - memset(&addr, 0, sizeof(addr)); - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = htonl(INADDR_ANY); - addr.sin_port = htons(VTPM_MIG_PORT); - - if (bind(sock_descr, (struct sockaddr *)&addr, sizeof(addr)) == -1 ) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to bind to port %d.\n", VTPM_MIG_PORT); - return 1; - } - - listen(sock_descr, 10); - - for(;;) { - // ============ clear client info and wait for connection ========== - memset(&client_addr, 0, sizeof(client_addr)); - client_length = sizeof(client_addr); - - vtpmloginfo(VTPM_LOG_VTPM, "Waiting for incoming migrations...\n"); - client_sock=accept(sock_descr, &client_addr, &client_length); - if (client_sock == -1) { - vtpmlogerror(VTPM_LOG_VTPM, "Incoming connectionn failed.\n"); - goto abort_command; - } else { - vtpmloginfo(VTPM_LOG_VTPM, "Incoming connection accepted.\n"); - } - - // =================== Read incoming command ====================== - size_read = read( client_sock, cmd_header, VTPM_COMMAND_HEADER_SIZE); - if (size_read > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV: 0x"); - for (i=0; i 0) { - buffer_init( &in_param_buf, adj_param_size, NULL); - size_read = read(client_sock, in_param_buf.bytes, adj_param_size); - if (size_read > 0) { - for (i=0; i< size_read; i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param_buf.bytes[i]); - - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); - build_error_msg(&result_buf, TPM_IOERROR); - goto abort_command_with_error; - } - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - - if (size_read < (int)adj_param_size) { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); - build_error_msg(&result_buf, TPM_BAD_PARAMETER); - goto abort_command_with_error; - } - } else { - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); - } - - /* Handle Command */ - switch (ord) { - case VTPM_MORD_MIG_STEP2: - handle_vtpm_mig_step2(&in_param_buf, &result_buf); - break; - - case VTPM_MORD_MIG_STEP3: - handle_vtpm_mig_step3(&in_param_buf, &result_buf); - break; - - default: - build_error_msg(&result_buf, TPM_BAD_PARAMETER); - goto abort_command_with_error; - } - - abort_command_with_error: - /* Write Response */ - size_write = write(client_sock, result_buf.bytes, buffer_len(&result_buf)); - - if (size_write > 0) { - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); - for (i=0; i< buffer_len(&result_buf); i++) { - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_buf.bytes[i]); - } - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Error writing response to client.\n"); - goto abort_command; - } - - if (size_write != (int) buffer_len(&result_buf) ) - vtpmlogerror(VTPM_LOG_VTPM, "Could not send entire response to client(%d/%d)\n", size_write, buffer_len(&result_buf)); - - abort_command: - close(client_sock); - buffer_free(&in_param_buf); - buffer_free(&result_buf); - - } // For (;;) - - return 0; -} - diff --git a/tools/vtpm_manager/migration/vtpm_migratord_handler.c b/tools/vtpm_manager/migration/vtpm_migratord_handler.c deleted file mode 100644 index 0a8a2d5..0000000 --- a/tools/vtpm_manager/migration/vtpm_migratord_handler.c +++ /dev/null @@ -1,177 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -#include -#include - -#include "tcg.h" -#include "bsg.h" -#include "log.h" -#include "vtpm_migrator.h" -#include "vtpm_manager.h" - -#define VTPM_SH_CMD_HDR "bash -c \"cd /etc/xen/scripts; source /etc/xen/scripts/vtpm-common.sh;" -#define VTPM_SH_CMD_FTR "\"" -#define VTPM_SH_GETINST "vtpmdb_get_free_instancenum" -#define VTPM_SH_ADD "vtpm_add_and_activate" -#define VTPM_SH_RESUME "vtpm_resume" - -// This must be updated to the longest command name. Currently GETINST -#define VTPM_SH_CMD_SIZE (strlen(VTPM_SH_CMD_HDR) + strlen(VTPM_SH_CMD_FTR) + 1 + strlen(VTPM_SH_GETINST) + 2) - -void handle_vtpm_mig_step2(buffer_t *in_param_buf, buffer_t *result_buf) -{ - TPM_TAG tag = VTPM_TAG_RSP; - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF; - TPM_RESULT status=TPM_SUCCESS, cmd_status; - UINT32 out_param_size; - - if ( (!in_param_buf) || (!result_buf) ) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // ================= Call manager and get mig key =============== - TPMTRYRETURN( vtpm_manager_open() ); - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_GET_MIG_KEY, - &out_param_buf, // Empty - &cmd_status, - &mig_key_buf) ); - - vtpm_manager_close(); - - TPMTRYRETURN(cmd_status); - - // ==================== return the mig key ===================== - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(&mig_key_buf); - - TPMTRYRETURN( buffer_init(result_buf, - out_param_size, - NULL) ); - - BSG_PackList( result_buf->bytes, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, &out_param_size, - BSG_TPM_RESULT, &status); - - memcpy(result_buf->bytes + VTPM_COMMAND_HEADER_SIZE, - mig_key_buf.bytes, buffer_len(&mig_key_buf)); - - goto egress; - - abort_egress: - buffer_free(result_buf); - build_error_msg(result_buf, status); - - egress: - return; -} - -void handle_vtpm_mig_step3(buffer_t *in_param_buf, buffer_t *result_buf) -{ - TPM_TAG tag = VTPM_TAG_RSP; - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; - TPM_RESULT status=TPM_SUCCESS, cmd_status; - UINT32 out_param_size, instance; - char *shell_cmd_str=NULL; - size_t shell_cmd_strlen; - FILE *shell_f=NULL; - - if ( (!in_param_buf) || (!result_buf) ) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // ================= Read Parameters =============== - struct pack_buf_t name_data32, state_data32; - - BSG_UnpackList(in_param_buf->bytes, 2, - BSG_TPM_SIZE32_DATA, &name_data32, - BSG_TPM_SIZE32_DATA, &state_data32); - - // Before using this string, protect us from a non-null term array. - if (name_data32.data[name_data32.size -1] != 0x00) { - name_data32.data[name_data32.size -1] = 0x00; - } - - // ====== Call hotplug-script and get an instance ====== - shell_cmd_strlen = VTPM_SH_CMD_SIZE + name_data32.size + 10; - shell_cmd_str = (char *) malloc(shell_cmd_strlen); // 10 is just padding for the UINT32 - - snprintf(shell_cmd_str, shell_cmd_strlen, - VTPM_SH_CMD_HDR VTPM_SH_GETINST VTPM_SH_CMD_FTR); - - shell_f = popen(shell_cmd_str, "r"); - fscanf(shell_f, "%d", &instance); - pclose(shell_f); - - // ====== Call hotplug-script and add instance ====== - snprintf(shell_cmd_str, shell_cmd_strlen, - VTPM_SH_CMD_HDR VTPM_SH_ADD " %s %d" VTPM_SH_CMD_FTR, - name_data32.data, instance); - system(shell_cmd_str); - - // ========= Call vtpm_manager and load VTPM ======= - TPMTRYRETURN( buffer_init( &out_param_buf, - 2*sizeof(UINT32) + state_data32.size, - NULL) ); - - BSG_PackList(out_param_buf.bytes, 2, - BSG_TYPE_UINT32, &instance, - BSG_TPM_SIZE32_DATA, &state_data32); - - TPMTRYRETURN( vtpm_manager_open() ); - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_MIGRATE_IN, - &out_param_buf, - &cmd_status, - &empty_buf) ); - - vtpm_manager_close(); - - TPMTRYRETURN(cmd_status); - - // ====== Call hotplug-script and resume instance ====== - snprintf(shell_cmd_str, shell_cmd_strlen, - VTPM_SH_CMD_HDR VTPM_SH_RESUME " %d" VTPM_SH_CMD_FTR, instance); - system(shell_cmd_str); - - goto egress; - abort_egress: - egress: - free(shell_cmd_str); - - // In this case no params come back, so reuse build_error_msg even for succes. - build_error_msg(result_buf, status); - return; -} - diff --git a/tools/vtpm_manager/tcs/Makefile b/tools/vtpm_manager/tcs/Makefile deleted file mode 100644 index 11af91e..0000000 --- a/tools/vtpm_manager/tcs/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = libTCS.a - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - -.PHONY: clean -clean: - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(AR) rcs $(BIN) $(OBJS) diff --git a/tools/vtpm_manager/tcs/contextmgr.c b/tools/vtpm_manager/tcs/contextmgr.c deleted file mode 100644 index cf3803c..0000000 --- a/tools/vtpm_manager/tcs/contextmgr.c +++ /dev/null @@ -1,224 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// contextmgr.c -// -// This file contains the context management functions for TCS. -// -// ================================================================== - -#include -#include -#include -#include "tcs.h" -#include "contextmgr.h" -#include "log.h" -#include "hashtable.h" - -BYTE* AddMemBlock(CONTEXT_HANDLE* pContextHandle, // in - int BlockSize) { // in - - BLOCK* pCurrentBlock = NULL; - BLOCK* pBlock = NULL; - - // check incoming params - if (pContextHandle == NULL || BlockSize == 0) - return NULL; - - // Create New Block - pBlock = (BLOCK *)malloc(sizeof(BLOCK)); - if (pBlock == NULL) - return (0); - - pBlock->aMemory = (BYTE *)malloc(sizeof(BYTE) * BlockSize); - if (pBlock->aMemory == NULL) - return (0); - - memset(pBlock->aMemory, 0, BlockSize); - pBlock->nBlockSize = BlockSize; - pBlock->pNextBlock = NULL; - - // search for the last block created where to add the - // newly created block - if(pContextHandle->pTopBlock != NULL) { - pCurrentBlock = pContextHandle->pTopBlock; - while(pCurrentBlock->pNextBlock != NULL) - pCurrentBlock = pCurrentBlock->pNextBlock; - - - pCurrentBlock->pNextBlock= pBlock; - } else - pContextHandle->pTopBlock = pBlock; - - - pContextHandle->nBlockCount++; - - return pBlock->aMemory; -} - - -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in - BYTE* pTCPA_BYTEs) { // in - BLOCK* pCurrentBlock = NULL; - BLOCK* pParentBlock = NULL; - BOOL bFound = FALSE; - - if (pContextHandle == NULL) - return FALSE; - - - // Search for the Block in the context by aMemory pointer - pParentBlock = NULL; - pCurrentBlock = pContextHandle->pTopBlock; - - while(pCurrentBlock != NULL) { - // If aMemory block is found, delete it - if(pCurrentBlock->aMemory == pTCPA_BYTEs || pTCPA_BYTEs == NULL) { - // if it is the top Block, remove it from the top, - // otherwise remove it from the ParentBlock and stitch - // the NextBlock to the ParentBlock - if(pParentBlock == NULL) - pContextHandle->pTopBlock = pContextHandle->pTopBlock->pNextBlock; - else - pParentBlock->pNextBlock = pCurrentBlock->pNextBlock; - - // delete memory Block associated with pointer pTCPA_BYTEs - free(pCurrentBlock->aMemory); - pCurrentBlock->aMemory = NULL; - - free(pCurrentBlock); - pCurrentBlock = pParentBlock; - - pContextHandle->nBlockCount--; - bFound = TRUE; - } - - if(pCurrentBlock != NULL) { - pParentBlock = pCurrentBlock; - pCurrentBlock = pCurrentBlock->pNextBlock; - } - } - - return bFound; -} - -BOOL AddHandleToList(TCS_CONTEXT_HANDLE hContext, // in - TPM_RESOURCE_TYPE type, // in - TPM_HANDLE handle) { // in - HANDLE_LIST* pNewHandle = NULL; - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Adding Handle to list\n"); - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); - - if (pContextHandle == NULL) - return 0; - - pNewHandle = (HANDLE_LIST *)malloc(sizeof(HANDLE_LIST)); - - if (pNewHandle == NULL) - return (0); - - pNewHandle->handle = handle; - pNewHandle->type = type; - pNewHandle->pNextHandle = pContextHandle->pHandleList; - - pContextHandle->pHandleList = pNewHandle; - - return 1; -} - -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in - TPM_HANDLE handle) { // in - - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); - - HANDLE_LIST *pCurrentHandle = pContextHandle->pHandleList, - *pLastHandle = pCurrentHandle; - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Deleting Handle from list\n"); - - if (pContextHandle == NULL) - return 0; - - while (1) { - - if (pCurrentHandle->handle == handle) { // Found element - if (pCurrentHandle == pLastHandle) { // First element in list - pContextHandle->pHandleList = pCurrentHandle->pNextHandle; - free(pCurrentHandle); - } else { // Ordinary element - pLastHandle->pNextHandle = pCurrentHandle->pNextHandle; - free(pCurrentHandle); - } - - return 1; - - } else { // Not found yet; - pLastHandle = pCurrentHandle; - pCurrentHandle = pCurrentHandle->pNextHandle; - if (pCurrentHandle == NULL) // Found end of list - return 0; - } - - } -} - -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle) { // in - HANDLE_LIST* pCurrentHandle; - BOOL returncode = TRUE; - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Freeing all handles for context\n"); - - if (pContextHandle == NULL) - return 1; - - pCurrentHandle = pContextHandle->pHandleList; - while (pCurrentHandle != NULL) { - - switch (pCurrentHandle->type) { - case TPM_RT_KEY: - returncode = returncode && !TCSP_EvictKey(pContextHandle->handle, pCurrentHandle->handle); - break; - case TPM_RT_AUTH: - returncode = returncode && !TCSP_TerminateHandle(pContextHandle->handle, pCurrentHandle->handle); - break; - default: - returncode = FALSE; - } - - pCurrentHandle = pCurrentHandle->pNextHandle; - - } - - return 1; -} diff --git a/tools/vtpm_manager/tcs/contextmgr.h b/tools/vtpm_manager/tcs/contextmgr.h deleted file mode 100644 index e3fdf0f..0000000 --- a/tools/vtpm_manager/tcs/contextmgr.h +++ /dev/null @@ -1,82 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// contextmgr.c -// -// This file contains the context management functions for TCS. -// -// ================================================================== - -#ifndef __CONTEXTMGR_H__ -#define __CONTEXTMGR_H__ - -#include "tcg.h" - -#define BLOCK_SIZE 300 - -typedef struct block { - int nBlockSize; - BYTE* aMemory; - struct block* pNextBlock; -} BLOCK; - -typedef struct handle_List { - TPM_HANDLE handle; - TPM_RESOURCE_TYPE type; - struct handle_List* pNextHandle; -} HANDLE_LIST; - -typedef struct context_handle { - TCS_CONTEXT_HANDLE handle; - int nBlockCount; - BLOCK* pTopBlock; - HANDLE_LIST* pHandleList; -} CONTEXT_HANDLE; - -BYTE* AddMemBlock( CONTEXT_HANDLE* pContextHandle, // in - int BlockSize); // in - -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in - BYTE* pTCPA_BYTEs); // in - - -BOOL AddHandleToList( TCS_CONTEXT_HANDLE hContext, // in - TPM_RESOURCE_TYPE type, // in - TPM_HANDLE handle); // in - -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in - TPM_HANDLE handle); // in - -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle); // in - -#endif //_CONTEXTMGR_H_ diff --git a/tools/vtpm_manager/tcs/tcs.c b/tools/vtpm_manager/tcs/tcs.c deleted file mode 100644 index 7c1378c..0000000 --- a/tools/vtpm_manager/tcs/tcs.c +++ /dev/null @@ -1,1192 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tcs.c -// -// This file contains the functions that implement a TCS. -// -// ================================================================== - -#include -#include -#include - -#include "tcg.h" -#include "bsg.h" -#include "tcs.h" -#include "contextmgr.h" -#include "tpmddl.h" -#include "log.h" -#include "hashtable.h" -#include "hashtable_itr.h" - -// Static Global Vars for the TCS -static int TCS_m_nCount = 0; - -#define TCPA_MAX_BUFFER_LENGTH 0x2000 - -static BYTE InBuf [TCPA_MAX_BUFFER_LENGTH]; -static BYTE OutBuf[TCPA_MAX_BUFFER_LENGTH]; - -struct hashtable *context_ht; - -// -------------------------- Hash table functions -------------------- - -static unsigned int hashfunc32(void *ky) { - return (* (UINT32 *) ky); -} - -static int equals32(void *k1, void *k2) { - return (*(UINT32 *) k1 == *(UINT32 *) k2); -} - -CONTEXT_HANDLE *LookupContext( TCS_CONTEXT_HANDLE hContext) { - return( (CONTEXT_HANDLE *) hashtable_search(context_ht, &hContext) ); -} - -// --------------------------------------------------------------------------------- -// Initialization/Uninitialization SubComponent API -// --------------------------------------------------------------------------------- -TPM_RESULT TCS_create() { - TDDL_RESULT hRes = TDDL_E_FAIL; - TPM_RESULT result = TPM_FAIL; - - if (TCS_m_nCount == 0) { - vtpmloginfo(VTPM_LOG_TCS, "Constructing new TCS:\n"); - hRes = TDDL_Open(); - - context_ht = create_hashtable(10, hashfunc32, equals32); - - if ((hRes == TDDL_SUCCESS) && (context_ht != NULL)) { - result = TPM_SUCCESS; - TCS_m_nCount++; - } else { - result = TPM_IOERROR; - hashtable_destroy(context_ht, 1); - } - } else - TCS_m_nCount++; - - return(result); -} - - -void TCS_destroy() -{ - TCS_m_nCount--; - - if (TCS_m_nCount == 0) { - vtpmloginfo(VTPM_LOG_TCS, "Destructing TCS:\n"); - TDDL_Close(); - - struct hashtable_itr *context_itr; - TCS_CONTEXT_HANDLE *hContext; - - // Close all the TCS contexts. TCS should evict keys based on this - if (hashtable_count(context_ht) > 0) { - context_itr = hashtable_iterator(context_ht); - do { - hContext = (TCS_CONTEXT_HANDLE *) hashtable_iterator_key(context_itr); - if (TCS_CloseContext(*hContext) != TPM_SUCCESS) - vtpmlogerror(VTPM_LOG_TCS, "Failed to close context %d properly.\n", *hContext); - - } while (hashtable_iterator_advance(context_itr)); - free(context_itr); - } - hashtable_destroy(context_ht, 1); - } - -} - -TPM_RESULT TCS_Malloc( TCS_CONTEXT_HANDLE hContext, // in - UINT32 MemSize, // in - BYTE** ppMemPtr) {// out - - TPM_RESULT returnCode = TPM_FAIL; - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); - - if (pContextHandle != NULL && ppMemPtr != NULL) { - *ppMemPtr = (BYTE *)AddMemBlock(pContextHandle, MemSize); - returnCode = TPM_SUCCESS; - } - - return returnCode; -} - -TPM_RESULT TCS_FreeMemory( TCS_CONTEXT_HANDLE hContext, // in - BYTE* pMemory) { // in - TPM_RESULT returnCode = TPM_FAIL; - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); - - if ( (pContextHandle != NULL && pMemory != NULL) && - (DeleteMemBlock(pContextHandle, pMemory) == TRUE) ) - returnCode = TPM_SUCCESS; - - - return returnCode; -} - -TPM_RESULT TCS_OpenContext(TCS_CONTEXT_HANDLE* hContext) { // out - TPM_RESULT returnCode = TPM_FAIL; - TCS_CONTEXT_HANDLE *newContext; - - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_OpenContext:\n"); - - if (hContext) { - CONTEXT_HANDLE* pContextHandle = (CONTEXT_HANDLE *) malloc(sizeof(CONTEXT_HANDLE)); - if (pContextHandle == NULL) - return TPM_SIZE; - - // initialize to 0 - pContextHandle->nBlockCount = 0; - pContextHandle->pTopBlock = NULL; - pContextHandle->pHandleList = NULL; - - // Create New Block - AddMemBlock(pContextHandle, BLOCK_SIZE); - - newContext = (TCS_CONTEXT_HANDLE *) malloc(sizeof(TCS_CONTEXT_HANDLE)); - *newContext = (TCS_CONTEXT_HANDLE) (((uintptr_t) pContextHandle >> 2) & 0xffffffff); - - if (hashtable_search(context_ht, &newContext) !=NULL) - *newContext += 1; - - pContextHandle->handle = *newContext; - if (!hashtable_insert(context_ht, newContext, pContextHandle)) { - free(newContext); - free(pContextHandle); - returnCode = TPM_FAIL; - } else { - *hContext = *newContext; - returnCode = TPM_SUCCESS; - } - } - - return(returnCode); -} - -TPM_RESULT TCS_CloseContext(TCS_CONTEXT_HANDLE hContext) {// in - //FIXME: TCS SHOULD Track failed auths and make sure - //we don't try and re-free them here. - TPM_RESULT returnCode = TPM_FAIL; - - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); - - if(pContextHandle != NULL) { - // Print test info - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_CloseContext.\n"); - - // free memory for all the blocks - DeleteMemBlock(pContextHandle, NULL ); - pContextHandle->pTopBlock = NULL; - - FreeHandleList(pContextHandle); - if (pContextHandle->pHandleList != NULL) - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); - - // Release the TPM's resources - if (hashtable_remove(context_ht, &hContext) == NULL) - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); - - free(pContextHandle); - returnCode = TPM_SUCCESS; - } - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Finished closing context\n"); - return(returnCode); -} - -// ------------------------------------------------------------------ -// Internal Functions -// ------------------------------------------------------------------ -int packAuth(BYTE* dst, TCS_AUTH* auth) { - // CHECK: according to the command specs, the outgoing auth params are: - // nonceEven - // nonceOdd - // continueAuthSession - // auth digest for return params - // - // this is a bit different than this code... - - return BSG_PackList(dst, 4, - BSG_TYPE_UINT32, &(auth->AuthHandle), - BSG_TPM_NONCE, &(auth->NonceOdd), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), - BSG_TPM_AUTHDATA, &(auth->HMAC)); -} - -int unpackAuth(TCS_AUTH* auth, BYTE* src) { - return BSG_UnpackList(src, 3, - BSG_TPM_NONCE, &(auth->NonceEven), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), - BSG_TPM_AUTHDATA, &(auth->HMAC)); -} - -// ------------------------------------------------------------------ -// Authorization Commands -// ------------------------------------------------------------------ - -TPM_RESULT TCSP_OIAP(TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTHHANDLE* authHandle, // out - TPM_NONCE* nonce0) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - TPM_COMMAND_CODE ordinal = TPM_ORD_OIAP; - UINT32 paramSize = 0; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (authHandle == NULL || nonce0 == NULL) - return TPM_BAD_PARAMETER; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal); - - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS) { - - // unpack to get the tag, paramSize, & returnCode - int i = BSG_UnpackList( OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - // Extract the remaining output parameters - BSG_UnpackList(OutBuf+i, 2, - BSG_TYPE_UINT32, authHandle, - BSG_TPM_NONCE, nonce0); - - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); - - } - - return(returnCode); -} - -TPM_RESULT TCSP_OSAP(TCS_CONTEXT_HANDLE hContext, // in - TPM_ENTITY_TYPE entityType, // in - UINT32 entityValue, // in - TPM_NONCE nonceOddOSAP, // in - TCS_AUTHHANDLE* authHandle, // out - TPM_NONCE* nonceEven, // out - TPM_NONCE* nonceEvenOSAP) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_OSAP; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (authHandle == NULL || nonceEven == NULL || nonceEvenOSAP == NULL) - return TPM_BAD_PARAMETER; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 6, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT16, &entityType, - BSG_TYPE_UINT32, &entityValue, - BSG_TPM_NONCE, &nonceOddOSAP); - - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS) { - - // unpack to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - // Extract the remaining output parameters - BSG_UnpackList(OutBuf+i, 3, - BSG_TYPE_UINT32, authHandle, - BSG_TPM_NONCE, nonceEven, - BSG_TPM_NONCE, nonceEvenOSAP); - - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) { - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); - } - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); - - } - - return(returnCode); -} - -TPM_RESULT TCSP_TakeOwnership(TCS_CONTEXT_HANDLE hContext, // in - UINT16 protocolID, // in - UINT32 encOwnerAuthSize, // in - BYTE* encOwnerAuth, // in - UINT32 encSrkAuthSize, // in - BYTE* encSrkAuth, // in - UINT32* SrkSize, // in, out - BYTE** Srk, // in, out - TCS_AUTH* ownerAuth) // in, out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_TakeOwnership; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (encOwnerAuth == NULL || encSrkAuth == NULL || SrkSize == NULL || *Srk == NULL) - return TPM_BAD_PARAMETER; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 5, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT16, &protocolID, - BSG_TYPE_UINT32, &encOwnerAuthSize); - - memcpy(InBuf+InLength, encOwnerAuth, encOwnerAuthSize); - InLength += encOwnerAuthSize; - InLength += BSG_Pack( BSG_TYPE_UINT32, - &encSrkAuthSize, - InBuf+InLength); - memcpy(InBuf+InLength, encSrkAuth, encSrkAuthSize); - InLength += encSrkAuthSize; - memcpy(InBuf+InLength, *Srk, *SrkSize); - InLength += *SrkSize; - InLength += packAuth(InBuf+InLength, ownerAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, - &InLength, - InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS){ - - // unpack to get the tag, paramSize, & returnCode - int i = BSG_UnpackList( OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - TPM_KEY srkPub; - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &srkPub); - unpackAuth(ownerAuth, OutBuf+i); - - // fill output params - BYTE tempBuf[1024]; - *SrkSize = BSG_Pack(BSG_TPM_KEY, &srkPub, tempBuf); - if (TCS_Malloc(hContext, *SrkSize, Srk) == TPM_FAIL) { - return(TPM_SIZE); - } - memcpy(*Srk, tempBuf, *SrkSize); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TakeOwnership Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - - -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTH* ownerAuth) { // in, out - - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_DisablePubekRead; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal); - - InLength += packAuth(InBuf+InLength, ownerAuth); - - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS){ - - // unpack to get the tag, paramSize, & returnCode - int i = BSG_UnpackList( OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - unpackAuth(ownerAuth, OutBuf+i); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_DisablePubekRead Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - - -TPM_RESULT TCSP_TerminateHandle(TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTHHANDLE handle) // in -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_Terminate_Handle; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &handle); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS) { - - // unpack to get the tag, paramSize, & returnCode - BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (!DeleteHandleFromList(hContext, handle)) - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); - - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - // Print debug info - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TerminateHandle Failed with return code %s\n", tpm_get_error_name(returnCode)); - - } - - return(returnCode); -} - -// TPM Mandatory -TPM_RESULT TCSP_Extend( TCS_CONTEXT_HANDLE hContext, // in - TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in - TPM_PCRVALUE* outDigest) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_Extend; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 5, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &pcrNum, - BSG_TPM_DIGEST, &inDigest); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS) { - - // unpack to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND){ - // Extract the remaining output parameters - BSG_Unpack(BSG_TPM_PCRVALUE, OutBuf+i, outDigest); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Extend Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_Seal( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - TPM_ENCAUTH encAuth, // in - UINT32 pcrInfoSize, // in - BYTE* PcrInfo, // in - UINT32 inDataSize, // in - BYTE* inData, // in - TCS_AUTH* pubAuth, // in, out - UINT32* SealedDataSize, // out - BYTE** SealedData) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_Seal; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (inData == NULL || pubAuth == NULL || SealedDataSize == NULL || SealedData == NULL) - return TPM_BAD_PARAMETER; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 6, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &keyHandle, - BSG_TPM_ENCAUTH, encAuth, - BSG_TYPE_UINT32, &pcrInfoSize); - memcpy(InBuf+InLength, PcrInfo, pcrInfoSize); - InLength += pcrInfoSize; - InLength += BSG_Pack(BSG_TYPE_UINT32, &inDataSize, InBuf+InLength); - memcpy(InBuf+InLength, inData, inDataSize); - InLength += inDataSize; - InLength += packAuth(InBuf+InLength, pubAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) - == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - TPM_STORED_DATA sealedData; - - i += BSG_Unpack(BSG_TPM_STORED_DATA, OutBuf+i, &sealedData); - unpackAuth(pubAuth, OutBuf+i); - - // fill SealedData - BYTE tempBuf[1024]; - *SealedDataSize = BSG_Pack(BSG_TPM_STORED_DATA, &sealedData, tempBuf); - if (TCS_Malloc(hContext, *SealedDataSize, SealedData) == TPM_FAIL) { - return TPM_SIZE; - } - memcpy(*SealedData, tempBuf, *SealedDataSize); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Seal Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_Unseal(TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE parentHandle, // in - UINT32 SealedDataSize, // in - BYTE* SealedData, // in - TCS_AUTH* parentAuth, // in, out - TCS_AUTH* dataAuth, // in, out - UINT32* DataSize, // out - BYTE** Data) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH2_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_Unseal; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (SealedData == NULL || parentAuth == NULL || dataAuth == NULL || - DataSize == NULL || Data == NULL) - return TPM_BAD_PARAMETER; - - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &parentHandle); - memcpy(InBuf+InLength, SealedData, SealedDataSize); - InLength += SealedDataSize; - InLength += packAuth(InBuf+InLength, parentAuth); - InLength += packAuth(InBuf+InLength, dataAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList( OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH2_COMMAND) { - // Extract the remaining output parameters - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, DataSize); - if (TCS_Malloc(hContext, *DataSize, Data) == TPM_FAIL) { - return TPM_SIZE; - } - memcpy(*Data, OutBuf+i, *DataSize); - i += *DataSize; - i += unpackAuth(parentAuth, OutBuf+i); - unpackAuth(dataAuth, OutBuf+i); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Unseal Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_UnBind(TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - UINT32 inDataSize, // in - BYTE* inData, // in - TCS_AUTH* privAuth, // in, out - UINT32* outDataSize, // out - BYTE** outData) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_UnBind; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (inData == NULL || privAuth == NULL || outDataSize == NULL || outData == NULL) - return TPM_BAD_PARAMETER; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 5, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &keyHandle, - BSG_TYPE_UINT32, &inDataSize); - memcpy(InBuf+InLength, inData, inDataSize); - InLength += inDataSize; - InLength += packAuth(InBuf+InLength, privAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "\n\tSending paramSize = %d", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, outDataSize); - if (TCS_Malloc(hContext, *outDataSize, outData) == TPM_FAIL) - return TPM_SIZE; - - memcpy(*outData, OutBuf+i, *outDataSize); - i += *outDataSize; - unpackAuth(privAuth, OutBuf+i); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_UnBind Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_CreateWrapKey(TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hWrappingKey, // in - TPM_ENCAUTH KeyUsageAuth, // in - TPM_ENCAUTH KeyMigrationAuth, // in - UINT32* pcKeySize, // in, out - BYTE** prgbKey, // in, out - TCS_AUTH* pAuth) // in, out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_CreateWrapKey; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (pcKeySize == NULL || *prgbKey == NULL || pAuth == NULL) - return TPM_BAD_PARAMETER; - - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 6, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &hWrappingKey, - BSG_TPM_ENCAUTH, KeyUsageAuth, - BSG_TPM_ENCAUTH, KeyMigrationAuth); - memcpy(InBuf+InLength, *prgbKey, *pcKeySize); - InLength += *pcKeySize; - InLength += packAuth(InBuf+InLength, pAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_RESULT, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - TPM_KEY wrappedKey; - - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &wrappedKey); - unpackAuth(pAuth, OutBuf+i); - - // Fill prgbKey - BYTE tempBuf[1024]; - *pcKeySize = BSG_Pack(BSG_TPM_KEY, &wrappedKey, tempBuf); - if (TCS_Malloc(hContext, *pcKeySize, prgbKey) == TPM_FAIL) - return TPM_SIZE; - - memcpy(*prgbKey, tempBuf, *pcKeySize); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_CreateWrapKey Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_LoadKeyByBlob(TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hUnwrappingKey, // in - UINT32 cWrappedKeyBlobSize, // in - BYTE* rgbWrappedKeyBlob, // in - TCS_AUTH* pAuth, // in, out - TCS_KEY_HANDLE* phKeyTCSI, // out - TCS_KEY_HANDLE* phKeyHMAC) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_LoadKey; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (rgbWrappedKeyBlob == NULL || pAuth == NULL || phKeyTCSI == NULL || phKeyHMAC == NULL) - return TPM_BAD_PARAMETER; - - *phKeyHMAC = hUnwrappingKey; // the parent key is the one that the TPM use to make the HMAC calc - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &hUnwrappingKey); - memcpy(InBuf+InLength, rgbWrappedKeyBlob, cWrappedKeyBlobSize); - InLength += cWrappedKeyBlobSize; - InLength += packAuth(InBuf+InLength, pAuth); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { - // Extract the remaining output parameters - i += BSG_Unpack(BSG_TYPE_UINT32, - OutBuf+i, - phKeyTCSI); - unpackAuth(pAuth, OutBuf+i); - - if (!AddHandleToList(hContext, TPM_RT_KEY, *phKeyTCSI)) { - vtpmlogerror(VTPM_LOG_TCS, "New KeyHandle not recorded\n"); - } - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else - vtpmlogerror(VTPM_LOG_TCS, "TCSP_LoadKeyByBlob Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - - return(returnCode); -} - -TPM_RESULT TCSP_EvictKey(TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hKey) // in -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_EvictKey; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, &hKey); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (!DeleteHandleFromList(hContext, hKey)) { - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); - } - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else { - vtpmlogerror(VTPM_LOG_TCS, "TCSP_EvictKey Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - } - - return(returnCode); -} - -TPM_RESULT TCSP_GetRandom(TCS_CONTEXT_HANDLE hContext, // in - UINT32* bytesRequested, // in, out - BYTE** randomBytes) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_GetRandom; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (bytesRequested == NULL || *randomBytes == NULL){ - return TPM_BAD_PARAMETER; - } - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TYPE_UINT32, bytesRequested); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - // Extract the remaining output parameters - BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, bytesRequested); - if (TCS_Malloc(hContext, *bytesRequested, randomBytes) == TPM_FAIL) { - return TPM_SIZE; - } - memcpy(*randomBytes, OutBuf+i+sizeof(UINT32), *bytesRequested); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else { - vtpmlogerror(VTPM_LOG_TCS, "TCSP_GetRandom Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - } - - return(returnCode); -} - - -TPM_RESULT TCSP_ReadPubek(TCS_CONTEXT_HANDLE hContext, // in - TPM_NONCE antiReplay, // in - UINT32* pubEndorsementKeySize, // out - BYTE** pubEndorsementKey, // out - TPM_DIGEST* checksum) // out -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_ReadPubek; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // check input params - if (pubEndorsementKeySize == NULL || pubEndorsementKey == NULL || checksum == NULL) { - return TPM_BAD_PARAMETER; - } - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 4, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal, - BSG_TPM_NONCE, &antiReplay); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - int i = BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - // Extract the remaining output parameters - TPM_PUBKEY pubEK; - i += BSG_UnpackList(OutBuf+i, 2, - BSG_TPM_PUBKEY, &pubEK, - BSG_TPM_DIGEST, checksum); - - // fill EndorsementKey - BYTE tempBuf[1024]; - *pubEndorsementKeySize = BSG_Pack(BSG_TPM_PUBKEY, &pubEK, tempBuf); - if (TCS_Malloc(hContext, *pubEndorsementKeySize, pubEndorsementKey) == TPM_FAIL) { - return TPM_SIZE; - } - memcpy(*pubEndorsementKey, tempBuf, *pubEndorsementKeySize); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else { - vtpmlogerror(VTPM_LOG_TCS, "TCSP_ReadPubek Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - } - - return(returnCode); -} - - -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext) // in -{ - // setup input/output parameters block - TPM_TAG tag = TPM_TAG_RQU_COMMAND; - UINT32 paramSize = 0; - TPM_COMMAND_CODE ordinal = TPM_ORD_SaveState; - TPM_RESULT returnCode = TPM_SUCCESS; - - // setup the TPM driver input and output buffers - TDDL_RESULT hRes = TDDL_E_FAIL; - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; - - // Convert Byte Input parameter in the input byte stream InBuf - InLength = BSG_PackList(InBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &ordinal); - // fill paramSize again as we now have the correct size - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); - - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); - - // call the TPM driver - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { - // unpack OutBuf to get the tag, paramSize, & returnCode - BSG_UnpackList(OutBuf, 3, - BSG_TPM_TAG, &tag, - BSG_TYPE_UINT32, ¶mSize, - BSG_TPM_COMMAND_CODE, &returnCode); - - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); - } else { - vtpmlogerror(VTPM_LOG_TCS, "TCSP_SaveState Failed with return code %s\n", tpm_get_error_name(returnCode)); - } - } - - return(returnCode); -} - - -TPM_RESULT TCSP_RawTransmitData( UINT32 inDataSize, // in - BYTE *inData, // in - UINT32 *outDataSize,// in/out - BYTE *outData) { // out - - TDDL_RESULT hRes; - - vtpmloginfo(VTPM_LOG_TCS, "Calling TransmitData directly.\n"); - //FIXME: Add Context Management - hRes = TDDL_TransmitData( inData, - inDataSize, - outData, - outDataSize); - - if (hRes == TDDL_SUCCESS) { - return TPM_SUCCESS; - } else { - vtpmlogerror(VTPM_LOG_TCS, "TCSP_RawTransmitData Failed with return code %s\n", tpm_get_error_name(TPM_IOERROR)); - return TPM_IOERROR; - } - -} diff --git a/tools/vtpm_manager/tcs/tcs.h b/tools/vtpm_manager/tcs/tcs.h deleted file mode 100644 index 83b9cd0..0000000 --- a/tools/vtpm_manager/tcs/tcs.h +++ /dev/null @@ -1,245 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tcs.h -// -// This file declares the TCS API -// -// ================================================================== - -#ifndef __TCS_H__ -#define __TCS_H__ - -#include "tcg.h" -#include "contextmgr.h" -#include "buffer.h" - -#define HANDLE_NULL 0 - -// ------------------------------------------------------------------ -// Exposed API -// ------------------------------------------------------------------ - -TPM_RESULT TCS_create(); -void TCS_destroy(); - -TPM_RESULT TCS_OpenContext( /* OUT */ TCS_CONTEXT_HANDLE* hContext ); - -TPM_RESULT TCS_CloseContext ( /* IN */ TCS_CONTEXT_HANDLE hContext ); - -TPM_RESULT TCS_Malloc ( TCS_CONTEXT_HANDLE hContext, // in - UINT32 MemSize, // in - BYTE** ppMemPtr ); //out - -TPM_RESULT TCS_FreeMemory ( TCS_CONTEXT_HANDLE hContext, // in - BYTE* pMemory); // in - -// ------------------------------------------------------------------ -// Exposed API -// ------------------------------------------------------------------ - -// TPM v1.1B Command Set - -// Authorzation -TPM_RESULT TCSP_OIAP( TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTHHANDLE* authHandle, // out - TPM_NONCE* nonce0 // out - ); - -TPM_RESULT TCSP_OSAP ( TCS_CONTEXT_HANDLE hContext, // in - TPM_ENTITY_TYPE entityType, // in - UINT32 entityValue, // in - TPM_NONCE nonceOddOSAP, // in - TCS_AUTHHANDLE* authHandle, // out - TPM_NONCE* nonceEven, // out - TPM_NONCE* nonceEvenOSAP // out - ); - -TPM_RESULT TCSP_TakeOwnership ( TCS_CONTEXT_HANDLE hContext, // in - UINT16 protocolID, // in - UINT32 encOwnerAuthSize, // in - BYTE* encOwnerAuth, // in - UINT32 encSrkAuthSize, // in - BYTE* encSrkAuth, // in - UINT32* SrkSize, // in, out - BYTE** Srk, // in, out - TCS_AUTH* ownerAuth // in, out - ); - -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTH* ownerAuth // in, out - ); - -TPM_RESULT TCSP_TerminateHandle ( TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTHHANDLE handle // in - ); - -TPM_RESULT TCSP_FlushSpecific ( TCS_CONTEXT_HANDLE hContext, // in - TCS_AUTHHANDLE handle, // in - TPM_RESOURCE_TYPE resourceType //in - ); - -// TPM Mandatory -TPM_RESULT TCSP_Extend ( TCS_CONTEXT_HANDLE hContext, // in - TPM_PCRINDEX pcrNum, // in - TPM_DIGEST inDigest, // in - TPM_PCRVALUE* outDigest // out - ); - -TPM_RESULT TCSP_PcrRead ( TCS_CONTEXT_HANDLE hContext, // in - TPM_PCRINDEX pcrNum, // in - TPM_PCRVALUE* outDigest // out - ); - -TPM_RESULT TCSP_Quote ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - TPM_NONCE antiReplay, // in - UINT32* PcrDataSize, // in, out - BYTE** PcrData, // in, out - TCS_AUTH* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); - -TPM_RESULT TCSP_Seal ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - TPM_ENCAUTH encAuth, // in - UINT32 pcrInfoSize, // in - BYTE* PcrInfo, // in - UINT32 inDataSize, // in - BYTE* inData, // in - TCS_AUTH* pubAuth, // in, out - UINT32* SealedDataSize, // out - BYTE** SealedData // out - ); - -TPM_RESULT TCSP_Unseal ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE parentHandle, // in - UINT32 SealedDataSize, // in - BYTE* SealedData, // in - TCS_AUTH* parentAuth, // in, out - TCS_AUTH* dataAuth, // in, out - UINT32* DataSize, // out - BYTE** Data // out - ); - -TPM_RESULT TCSP_DirWriteAuth ( TCS_CONTEXT_HANDLE hContext, // in - TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE newContents, // in - TCS_AUTH* ownerAuth // in, out - ); - -TPM_RESULT TCSP_DirRead ( TCS_CONTEXT_HANDLE hContext, // in - TPM_DIRINDEX dirIndex, // in - TPM_DIRVALUE* dirValue // out - ); - -TPM_RESULT TCSP_UnBind ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - UINT32 inDataSize, // in - BYTE* inData, // in - TCS_AUTH* privAuth, // in, out - UINT32* outDataSize, // out - BYTE** outData // out - ); - -TPM_RESULT TCSP_CreateWrapKey ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hWrappingKey, // in - TPM_ENCAUTH KeyUsageAuth, // in - TPM_ENCAUTH KeyMigrationAuth, // in - UINT32* pcKeySize, // in, out - BYTE** prgbKey, // in, out - TCS_AUTH* pAuth // in, out - ); - -TPM_RESULT TCSP_LoadKeyByBlob ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hUnwrappingKey, // in - UINT32 cWrappedKeyBlobSize, // in - BYTE* rgbWrappedKeyBlob, // in - TCS_AUTH* pAuth, // in, out - TCS_KEY_HANDLE* phKeyTCSI, // out - TCS_KEY_HANDLE* phKeyHMAC // out - ); - -TPM_RESULT TCSP_GetPubKey ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hKey, // in - TCS_AUTH* pAuth, // in, out - UINT32* pcPubKeySize, // out - BYTE** prgbPubKey // out - ); - -TPM_RESULT TCSP_EvictKey ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE hKey // in - ); - -TPM_RESULT TCSP_Sign ( TCS_CONTEXT_HANDLE hContext, // in - TCS_KEY_HANDLE keyHandle, // in - UINT32 areaToSignSize, // in - BYTE* areaToSign, // in - TCS_AUTH* privAuth, // in, out - UINT32* sigSize, // out - BYTE** sig // out - ); - -TPM_RESULT TCSP_GetRandom ( TCS_CONTEXT_HANDLE hContext, // in - UINT32* bytesRequested, // in, out - BYTE** randomBytes // out - ); - -TPM_RESULT TCSP_StirRandom ( TCS_CONTEXT_HANDLE hContext, // in - UINT32 inDataSize, // in - BYTE* inData // in - ); - -TPM_RESULT TCSP_ReadPubek ( TCS_CONTEXT_HANDLE hContext, // in - TPM_NONCE antiReplay, // in - UINT32* pubEndorsementKeySize, // out - BYTE** pubEndorsementKey, // out - TPM_DIGEST* checksum // out - ); - - -// Non-Standard TCSP calls -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext); // in - -//Give direct access to TransmitData. -// Key and Auth Management is done before transfering command to TDDL. -TPM_RESULT TCSP_RawTransmitData(UINT32 inDataSize, // in - BYTE *inData, // in - UINT32 *outDataSize,// in/out - BYTE *outData); // out - -///////////// Private Functions //////////////////// -CONTEXT_HANDLE* LookupContext( TCS_CONTEXT_HANDLE hContext); - -#endif //TCS_H diff --git a/tools/vtpm_manager/tcs/tpmddl.h b/tools/vtpm_manager/tcs/tpmddl.h deleted file mode 100644 index e7e54f1..0000000 --- a/tools/vtpm_manager/tcs/tpmddl.h +++ /dev/null @@ -1,69 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tpmddl.c -// -// This file defines the TDDLI API -// -// ================================================================== - -#ifndef __TPMDDL_H__ -#define __TPMDDL_H__ - -#define TDDL_CAP_PROP_MANUFACTURER 0x0001 - -#define TDDL_E_FAIL 1 -#define TDDL_E_SUCCESS 0 -#define TDDL_SUCCESS 0 - -typedef unsigned int TDDL_UINT32; -typedef TDDL_UINT32 TDDL_RESULT; -typedef unsigned char TDDL_BYTE; - -TDDL_RESULT TDDL_Open(); -void TDDL_Close(); -TDDL_RESULT TDDL_TransmitData( TDDL_BYTE* in, - TDDL_UINT32 insize, - TDDL_BYTE* out, - TDDL_UINT32* outsize); -TDDL_RESULT TDDL_GetStatus(); -TDDL_RESULT TDDL_GetCapability( TDDL_UINT32 cap, - TDDL_UINT32 sub, - TDDL_BYTE* buffer, - TDDL_UINT32* size); -TDDL_RESULT TDDL_SetCapability( TDDL_UINT32 cap, - TDDL_UINT32 sub, - TDDL_BYTE* buffer, - TDDL_UINT32* size); - -#endif // __TPMDDL_H__ diff --git a/tools/vtpm_manager/tcs/transmit.c b/tools/vtpm_manager/tcs/transmit.c deleted file mode 100644 index 74bbdca..0000000 --- a/tools/vtpm_manager/tcs/transmit.c +++ /dev/null @@ -1,147 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -#include -#include -#include -#include - -#include "tcg.h" -#include "buffer.h" -#include "log.h" -#include "tpmddl.h" - -// flag to track whether TDDL has been opened -static int g_TDDL_open = 0; -static int g_tx_fd = -1; // the fd to the TPM - -#ifndef DUMMY_TPM - #define TPM_TX_FNAME "/dev/tpm0" - static int *g_rx_fdp = &g_tx_fd; -#else - #define TPM_TX_FNAME "/var/tpm/tpm_in.fifo" - #define TPM_RX_FNAME "/var/tpm/tpm_out.fifo" - static int g_rx_fd = -1; - static int *g_rx_fdp = &g_rx_fd; // the fd to the TPM -#endif - -TPM_RESULT -TDDL_TransmitData( TDDL_BYTE* in, - TDDL_UINT32 insize, - TDDL_BYTE* out, - TDDL_UINT32* outsize) { - TPM_RESULT status = TPM_SUCCESS; - TDDL_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 (g_tx_fd, in, insize); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed"); - ERRORDIE (TPM_IOERROR); - } - else if ((TDDL_UINT32) size < insize) { - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); - // ... ? - } - - // read the response - size = read (*g_rx_fdp, out, TCPA_MAX_BUFFER_LENGTH); - if (size < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed"); - 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; - // close connection - goto egress; - - abort_egress: - egress: - return status; -} - -TPM_RESULT TDDL_Open() { - - TDDL_RESULT status = TDDL_SUCCESS; - - if (g_TDDL_open) - return TPM_FAIL; - -#ifdef DUMMY_TPM - *g_rx_fdp = open (TPM_RX_FNAME, O_RDWR); -#endif - - g_tx_fd = open (TPM_TX_FNAME, O_RDWR); - if (g_tx_fd < 0) { - vtpmlogerror(VTPM_LOG_TXDATA, "TPM open failed"); - return TPM_IOERROR; - } - - g_TDDL_open = 1; - - return status; -} - -void TDDL_Close() { - if (! g_TDDL_open) - return; - - if (g_tx_fd>= 0) { - if (close(g_tx_fd) < 0) - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); - g_tx_fd = -1; - } - - if (*g_rx_fdp>= 0) { - if (close(*g_rx_fdp) < 0) - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); - *g_rx_fdp = -1; - } - - g_TDDL_open = 0; - -} diff --git a/tools/vtpm_manager/util/Makefile b/tools/vtpm_manager/util/Makefile deleted file mode 100644 index 36bc38f..0000000 --- a/tools/vtpm_manager/util/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = libTCGUtils.a - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - -.PHONY: clean -clean: - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(AR) rcs $(BIN) $(OBJS) diff --git a/tools/vtpm_manager/util/bsg.c b/tools/vtpm_manager/util/bsg.c deleted file mode 100644 index fa36ce7..0000000 --- a/tools/vtpm_manager/util/bsg.c +++ /dev/null @@ -1,829 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// bsg.cpp -// -// This file will handle all the TPM Byte Stream functions -// -// ================================================================== - -#include -#include -#include -#include -#include "tcg.h" -#include "crypto.h" -#include "bsg.h" -#include "log.h" - -static int g_log_recursion_level = 0; - -// a largest buffer size. if we get a buf size bigger than this when unpacking, -// will complain! -#define BSG_MAX_BUF_SIZE (1<<18) - -#define bsglog(fmt, ...) do { \ - int __i; \ - for (__i=0; __i < g_log_recursion_level; __i++) { \ - vtpmloginfomore (VTPM_LOG_BSG, "%s", " "); \ - } \ - vtpmloginfomore (VTPM_LOG_BSG, fmt, __VA_ARGS__); \ - } while (0) - - -// FIXME: trigger the selfcheck--need to use glibc hook to do this -//BOOL dummy1 = BSG_static_selfcheck(); - - -// Interpretting Types -// ------------------- -// -// Incoming Types are composed of two parts {format, info} squished into a -// BSG_UINT32. The first 4 bits is a format spec indicating what type of -// data it is. If the first 4 bits are zero the info corresponds to a value in -// BSG_s_fmt[]. This is a structure whose composition is described in -// BSG_s_fmt[]. If the value is non-zero, info corresponds to the size of the -// data (in bytes) being passed in. For example a UINT32 being passed in would -// have a format of (__FMT_CONST | 4). If both, the format and info are zero, -// this is interpretted as the end of the structure, and the result is returned. - -// these flags are mutually exclusive, so I'll just make them -// format values which indicate the semantics of the 'info' part and the source -// data. The above description has been accordingly adjusted. - -// format values for determining what type of data the incoming type is -// it's a 4 bit value, occupying the high 4 bits -#define __FMT_CONST (1UL << 28) // Constant sized value -#define __FMT_DATA (2UL << 28) // Believed to be raw data NOT {size,data} -#define __FMT_SIZE (3UL << 28) // A size. Used in FMT_SIZE??_DATA. -#define __FMT_HSIZE (4UL << 28) // A number of handles -#define __FMT_PACKED (5UL << 28) // 'info' is unused; the source data consists - // of {size32, data} but we're to pack only the - // data as that is already packed, and so - // can/must be unpacked without - // explicitly reading it size - -#define __FMT_MASK 0x0FFFFFFFUL // this masks out the 4-bit format -#define __FMT_MASK_SIZE(type) ((type) & __FMT_MASK) -#define __FMT_MASK_FORMAT(type) ((type) & (~__FMT_MASK)) - -// constant (8/16/32-bits) -#define FMT_U8 (__FMT_CONST | 1UL) -#define FMT_U16 (__FMT_CONST | 2UL) -#define FMT_U32 (__FMT_CONST | 4UL) - -// const with a compiler-computed size -#define FMT_SIZEOF(type) (__FMT_CONST | sizeof(type)) - -// other data (size bytes) -// Used primarily for DIGESTS -> FMT_DATA(20) -#define FMT_DATA(size) (__FMT_DATA | ((BSG_UINT32) (size) & __FMT_MASK)) - -// 16/32-bit size followed by N bytes of data -#define FMT_SIZE16_DATA (__FMT_SIZE | 2UL) -#define FMT_SIZE32_DATA (__FMT_SIZE | 4UL) - -// 16-bit size followed by N key handles -#define FMT_SIZE16_HANDLES (__FMT_HSIZE | 2UL) - -#define DIGEST_SIZE 20 -typedef BSG_UINT32 BSG_HANDLE; - -// TCPA_AUTH has 11 fields! -#define MAX_FIELDS 11 -typedef struct BSG_Format -{ - BSG_Type type; - const char* name; - BSG_UINT32 fields[MAX_FIELDS + 1]; -} BSG_Format; - -/* - * TCPA structure data formats - */ -// this has to be manually kept in sync with the -// Type enum!! the static_selfcheck() function should be used regularly! -static BSG_Format s_fmt[] = -{ - {BSG_TYPE_UINT32, "BSG_TYPE_UINT32", {FMT_U32, 0}}, - {BSG_TYPE_UINT16, "BSG_TYPE_UINT16", {FMT_U16, 0}}, - {BSG_TYPE_BYTE, "BSG_TYPE_BYTE", {FMT_U8, 0}}, - {BSG_TYPE_BOOL, "BSG_TYPE_BOOL", {FMT_U8, 0}}, - {BSG_TPM_SIZE32_DATA, "BSG_TPM_SIZE32_DATA", {FMT_SIZE32_DATA, 0}}, - {BSG_TPM_TAG, "BSG_TPM_TAG", {FMT_SIZEOF(TPM_TAG), 0}}, - {BSG_TPM_HANDLE, "BSG_TPM_HANDLE", {FMT_SIZEOF(TPM_HANDLE), 0}}, - {BSG_TPM_RESULT, "BSG_TPM_RESULT", {FMT_SIZEOF(TPM_RESULT), 0}}, - {BSG_TPM_RESOURCE_TYPE, "BSG_TPM_RESOURCE_TYPE", {FMT_SIZEOF(TPM_RESOURCE_TYPE), 0}}, - {BSG_TPM_COMMAND_CODE, "BSG_TPM_COMMAND_CODE", {FMT_U32, 0}}, - {BSG_TPM_AUTH_DATA_USAGE, "BSG_TPM_AUTH_DATA_USAGE", {FMT_U8, 0}}, - {BSG_TPM_ALGORITHM_ID, "BSG_TPM_ALGORITHM_ID", {FMT_U32, 0}}, - {BSG_TPM_PROTOCOL_ID, "BSG_TPM_PROTOCOL_ID", {FMT_SIZEOF(TPM_PROTOCOL_ID), 0}}, - {BSG_TPM_KEY_USAGE, "BSG_TPM_KEY_USAGE", {FMT_U16, 0}}, - {BSG_TPM_ENC_SCHEME, "BSG_TPM_ENC_SCHEME", {FMT_U16, 0}}, - {BSG_TPM_SIG_SCHEME, "BSG_TPM_SIG_SCHEME", {FMT_U16, 0}}, - {BSG_TPM_MIGRATE_SCHEME, "BSG_TPM_MIGRATE_SCHEME", {FMT_U16, 0}}, - {BSG_TPM_KEY_FLAGS, "BSG_TPM_KEY_FLAGS", {FMT_U32, 0}}, - - {BSG_TPM_AUTHDATA, "BSG_TPM_AUTHDATA", {FMT_DATA(DIGEST_SIZE), 0}}, - {BSG_TPM_SECRET, "BSG_TPM_SECRET", {BSG_TPM_AUTHDATA, 0}}, - {BSG_TPM_ENCAUTH, "BSG_TPM_ENCAUTH", {BSG_TPM_AUTHDATA, 0}}, - {BSG_TPM_PAYLOAD_TYPE, "BSG_TPM_PAYLOAD_TYPE", {FMT_SIZEOF(TPM_PAYLOAD_TYPE), 0}}, - - {BSG_TPM_VERSION, "BSG_TPM_VERSION", {FMT_DATA(4), 0}}, // vers 1.2 - {BSG_TPM_DIGEST, "BSG_TPM_DIGEST", {FMT_DATA(DIGEST_SIZE), 0}}, - {BSG_TPM_COMPOSITE_HASH, "BSG_TPM_COMPOSITE_HASH", {BSG_TPM_DIGEST, 0}}, - {BSG_TPM_CHOSENID_HASH, "BSG_TPM_CHOSENID_HASH", {BSG_TPM_DIGEST, 0}}, - - {BSG_TPM_NONCE, "BSG_TPM_NONCE", {FMT_DATA(DIGEST_SIZE), 0}}, - {BSG_TPM_KEY_HANDLE, "BSG_TPM_KEY_HANDLE", {FMT_SIZEOF(TPM_KEY_HANDLE), 0}}, - {BSG_TPM_KEY_HANDLE_LIST, "BSG_TPM_KEY_HANDLE_LIST", - {FMT_SIZE16_HANDLES, 0}}, - - {BSG_TPM_KEY_PARMS, "BSG_TPM_KEY_PARMS", { - BSG_TPM_ALGORITHM_ID, - BSG_TPM_ENC_SCHEME, - BSG_TPM_SIG_SCHEME, - FMT_SIZE32_DATA, - 0}}, - {BSG_TPM_RSA_KEY_PARMS, "BSG_TPM_RSA_KEY_PARMS", { - FMT_U32, FMT_U32, FMT_SIZE32_DATA, 0}}, - {BSG_TPM_STORE_PUBKEY, "BSG_TPM_STORE_PUBKEY", {FMT_SIZE32_DATA, 0}}, - {BSG_TPM_PUBKEY, "BSG_TPM_PUBKEY", {BSG_TPM_KEY_PARMS, BSG_TPM_STORE_PUBKEY, 0}}, - {BSG_TPM_KEY, "BSG_TPM_KEY", { - BSG_TPM_VERSION, - BSG_TPM_KEY_USAGE, - BSG_TPM_KEY_FLAGS, - BSG_TPM_AUTH_DATA_USAGE, - BSG_TPM_KEY_PARMS, - FMT_SIZE32_DATA, // the PCR_INFO - BSG_TPM_STORE_PUBKEY, - FMT_SIZE32_DATA, // the encrypted part - 0}}, - - {BSG_TPM_MIGRATIONKEYAUTH, "BSG_TPM_MIGRATIONKEYAUTH", { - BSG_TPM_PUBKEY, - BSG_TPM_MIGRATE_SCHEME, - BSG_TPM_DIGEST, 0}}, - - {BSG_TCPA_AUDIT_EVENT, "TCPA_AUDIT_EVENT", { - BSG_TPM_COMMAND_CODE, - BSG_TPM_RESULT, 0 }}, - - {BSG_TCPA_EVENT_CERT, "TCPA_EVENT_CERT", { - BSG_TPM_DIGEST, - BSG_TPM_DIGEST, - FMT_DATA(2), - FMT_SIZE32_DATA, 0}}, - - {BSG_TPM_PCR_SELECTION, "BSG_TPM_PCR_SELECTION", {FMT_SIZE16_DATA, 0} }, - {BSG_TPM_PCR_COMPOSITE, "BSG_TPM_PCR_COMPOSITE", { BSG_TPM_PCR_SELECTION, - FMT_SIZE32_DATA, - 0} }, - - {BSG_TPM_PCR_INFO, "BSG_TPM_PCR_INFO", { BSG_TPM_PCR_SELECTION, - BSG_TPM_COMPOSITE_HASH, - BSG_TPM_COMPOSITE_HASH, - 0} }, - - - {BSG_TPM_STORED_DATA, "BSG_TPM_STORED_DATA", { - BSG_TPM_VERSION, - FMT_SIZE32_DATA, - FMT_SIZE32_DATA, - 0}}, - {BSG_TPM_SYMMETRIC_KEY, "BSG_TPM_SYMMETRIC_KEY", { - BSG_TPM_ALGORITHM_ID, - BSG_TPM_ENC_SCHEME, - FMT_SIZE16_DATA, - 0}}, - {BSG_TPM_STORE_PRIVKEY, "BSG_TPM_STORE_PRIVKEY", {FMT_SIZE32_DATA, 0}}, - {BSG_TPM_STORE_ASYMKEY, "BSG_TPM_STORE_ASYMKEY", { - BSG_TPM_PAYLOAD_TYPE, - BSG_TPM_SECRET, - BSG_TPM_SECRET, - BSG_TPM_DIGEST, - BSG_TPM_STORE_PRIVKEY, - 0}}, - {BSG_TPM_MIGRATE_ASYMKEY, "BSG_TPM_MIGRATE_ASYMKEY", { - BSG_TPM_PAYLOAD_TYPE, - BSG_TPM_SECRET, - BSG_TPM_DIGEST, - FMT_U32, - BSG_TPM_STORE_PRIVKEY, - 0}}, - - {BSG_TPM_QUOTE_INFO, "BSG_TPM_QUOTE_INFO", { - BSG_TPM_VERSION, - FMT_DATA(4), - BSG_TPM_COMPOSITE_HASH, - BSG_TPM_NONCE, - 0}}, - - {BSG_TPM_IDENTITY_CONTENTS, "BSG_TPM_IDENTITY_CONTENTS", { - BSG_TPM_VERSION, - FMT_U32, - BSG_TPM_CHOSENID_HASH, - BSG_TPM_PUBKEY, - 0}}, - - {BSG_TPM_PCRVALUE, "BSG_TPM_PCRVALUE", {FMT_DATA(DIGEST_SIZE), 0}}, - - {BSG_TCPA_PCR_FLAGS, "TCPA_PCR_FLAGS", { - FMT_U8, - FMT_U8, - 0}}, - - {BSG_TCS_AUTH, "TCS_AUTH", { - BSG_TYPE_UINT32, - BSG_TPM_NONCE, - BSG_TPM_NONCE, - BSG_TYPE_BOOL, - BSG_TPM_AUTHDATA, - 0}}, - - {BSG_TPM_KEY_NONSENSITIVE, "BSG_TPM_KEY_NONSENSITIVE", { - BSG_TPM_VERSION, - BSG_TPM_KEY_USAGE, - BSG_TPM_KEY_FLAGS, - BSG_TPM_AUTH_DATA_USAGE, - BSG_TPM_KEY_PARMS, - FMT_SIZE32_DATA, - BSG_TPM_STORE_PUBKEY, - 0}}, - - {BSG_PACKED, "BSG_PACKED", { - __FMT_PACKED, - 0 }}, - - {BSG_TYPE_MAX, "", {0}}, -}; - - -static const BSG_Format* find_format (BSG_Type t) { - BSG_Format * f = s_fmt; - - if (t >= BSG_TYPE_MAX) { - return NULL; - } - - // WARNING: this depends on the enum and s_fmt[] array being in sync! make - // sure to run the static_selfcheck() to make sure - f = s_fmt + (t - BSG_TYPE_FIRST); - - return f; -} - -// -// a consistency-checking routine which can be run at compile time -// (ie. immediately after compilation) -// -// tasks: -// - verify that s_fmt has one entry per Type t, and that entry is at s_fmt[t] -// -// conditions: -// - need that s_fmt[0] is the first type listed in the Type enum! ie the first -// Type has value 0, not 1 -// -// FIXME: should have a function be passed in here which is called if the test -// fails. Then the caller can decide what to do: abort, notify, whatever -// -BOOL BSG_static_selfcheck () -{ - int i; - - for (i=BSG_TYPE_FIRST; i <= BSG_TYPE_MAX; i++) { - if (s_fmt[i - BSG_TYPE_FIRST].type != i) { - bsglog ("%s\n", "BSG: static_selfcheck failed!\n"); - bsglog ("failure at %i, allegedly %s\n", - i, s_fmt[i - BSG_TYPE_FIRST].name); - abort(); - return FALSE; - } - } - - bsglog ("%s\n", "BSG: static_selfcheck success!"); - return TRUE; -} - - -/** - * Flatten a TCPA structure into a buffer in big-endian format - * @type: TCPA structure type - * @src: (IN) TCPA structure (OUT) end of TCPA structure - * @dst: (OUT) flattened data - * Returns: Flattened size or -1 for unknown types - */ -// make it so that it can just run through the whole process and return -// the packed size, without packing anything. this will be done if dst is NULL. -static int BSG_Pack_private(BSG_Type type, const BSG_BYTE** src, BSG_BYTE* dst) -{ - // check incoming parameters - if (*src == NULL) - return 0; - - const BSG_BYTE* s = *src; - BSG_BYTE* d = dst; - - BSG_UINT32 size = __FMT_MASK_SIZE(type); - BSG_UINT32 format = __FMT_MASK_FORMAT(type); - - if (format == __FMT_CONST) // We are dealing with a fixed length value eg. UINT32 - { - BSG_UINT32 val = 0; - switch (size) { - case 1: val = * (BYTE*) s; break; - case 2: val = * (unsigned short*) s; break; - case 4: val = * (BSG_UINT32*) s; break; - } - if (dst) - BSG_PackConst(val, size, d); - - s += size; - d += size; - } else if (format == __FMT_DATA) { // We are dealing with raw data. Not sure when - // this is used. - - if (dst) { - bsglog ("BSG: __FMT_DATA size %d, src %p, dst %p\n", size, s, d); - memcpy(d, s, size); - } - - s += size; - d += size; - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) { // It's a size, followed by that much data or handles - - BSG_UINT32 psize = 0; - switch (size) { - case 1: psize = * (BYTE*) s; break; - case 2: psize = * (unsigned short*) s; break; - case 4: psize = * (BSG_UINT32*) s; break; - } - - if (dst) - BSG_PackConst(psize, size, d); - - s += size; - d += size; - - // now 's' points to an address, so cast it to BSG_BYTE** - const BSG_BYTE* pdata = * ((BSG_BYTE**) s); - s += sizeof(BSG_BYTE*); - - if (format == __FMT_HSIZE) {// This is a list of psize Handles - if (dst) { - BSG_HANDLE* d2 = (BSG_HANDLE*) d; - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; - BSG_UINT32 i; - for (i = 0; i < psize; i++) - d2[i] = BSG_UnpackConst((BSG_BYTE*)(p2 + i), 4); - - } - d += psize * sizeof(BSG_HANDLE); - } else {// If it's not psize handles, it's psize data. - if (psize > 0) { - if (dst) { - bsglog ("BSG: __FMT_SIZE, size=%d, src=%p, dst=%p\n", - psize, pdata, d); - memcpy(d, pdata, psize); - } - } - d += psize; - } - } else if (format == __FMT_PACKED) { - // the source buffer is a pack_constbuf_t, which has a size and a - // pointer. just copy the buffer value, the size is not included in the - // output stream. - pack_constbuf_t * buf = (pack_constbuf_t*) s; - - if (dst) { - bsglog ("BSG: __FMT_PACKED, size=%d, src=%p, dst=%p\n", - buf->size, buf->data, d); - memcpy(d, buf->data, buf->size); - } - - s += buf->size; - d += buf->size; - } else if (format == 0) {// No flags are set. This is a structure & it should - // be looked up in the bsg_s_fmt[] - - const BSG_Format* x = find_format (type); - if (x == NULL) { - vtpmloginfo(VTPM_LOG_BSG, "BSG_Pack: cannot find type %d\n", type); - return -1; - } - - if (dst) - bsglog ("BSG_Pack type %s\n", x->name); - - - // iterate through the fields - const BSG_UINT32* f = x->fields; - for (; *f; f++) { - int fsize; - - g_log_recursion_level++; - fsize = BSG_Pack_private((BSG_Type) *f, &s, dst ? d : NULL); - g_log_recursion_level--; - - if (fsize <= 0) - return fsize; - - d += fsize; - } - } else { - vtpmlogerror(VTPM_LOG_BSG, "BSG_Pack(): Unknown format %d\n", format); - return -1; - } - - *src = s; - return (d - dst); -} - -/** - * Unflatten a TCPA structure from a buffer in big-endian format - * @type: TCPA structure type - * @src: flattened data - * @dst: (IN) TCPA structure (OUT) end of TCPA structure - * Returns: Flattened size - * Note: Returns flattened size NOT the unpacked structure size - */ -static int BSG_Unpack_private(BSG_Type type, const BSG_BYTE* src, BSG_BYTE** dst) { - // check incoming parameters - if (src == NULL) - return 0; - - - const BSG_BYTE* s = src; - BSG_BYTE* d = dst ? *dst:NULL; - if (dst && !d) - dst = NULL; - - BSG_UINT32 size = __FMT_MASK_SIZE(type); - BSG_UINT32 format = __FMT_MASK_FORMAT(type); - - if (format == __FMT_CONST) {// We are dealing with a fixed length value ie. UINT32 - - BSG_UINT32 val = BSG_UnpackConst(s, size); - - if (dst) { - switch (size) { - case 1: *(BYTE *) d = (BSG_BYTE) val; break; - case 2: *(unsigned short*) d = (unsigned short) val; break; - case 4: *(BSG_UINT32*) d = (BSG_UINT32) val; break; - } - } - - s += size; - d += size; - } else if (format == __FMT_DATA) {// We are dealing with raw data. Not sure when this is used. - if (dst) - memcpy(d, s, size); - - d += size; - s += size; - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) {// It's a size, followed by that much data or handles - - BSG_UINT32 psize = BSG_UnpackConst(s, size); - - if (psize > BSG_MAX_BUF_SIZE) { - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack runs into var-sized data bigger than %u bytes!!\n", - BSG_MAX_BUF_SIZE); - return -1; - } - - if (dst) { - switch (size) { - case 1: *(BYTE *) d = (BSG_BYTE) psize; break; - case 2: *(unsigned short*) d = (unsigned short) psize; break; - case 4: *(BSG_UINT32*) d = (BSG_UINT32) psize; break; - } - } - - s += size; - d += size; - - BSG_BYTE* pdata = NULL; - - if (psize) { - if (format == __FMT_HSIZE) { // This is a list of psize Handles - if (dst) { - BSG_HANDLE* s2 = (BSG_HANDLE*) s; - pdata = (BSG_BYTE *)malloc(psize * sizeof(BSG_HANDLE)); - if (!pdata) - return -1; - - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; - BSG_UINT32 i; - for (i = 0; i < psize; i++) { - BSG_PackConst(s2[i], 4, (BSG_BYTE*)(p2 + i)); - } - } - s += psize * sizeof(BSG_HANDLE); - } else { // If it's not psize handles, it's psize data. - if (dst) { - pdata = (BSG_BYTE *)malloc(sizeof(BSG_BYTE) * psize); - if (!pdata) - return -1; - memcpy(pdata, s, psize); - } - s += psize; - } - } - if (dst) - *(void**) d = pdata; - - d += sizeof(void*); - } else if (format == __FMT_PACKED) { - - // this doesn't make sense for unpacking! - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack() called with format __FMT_PACKED. " - "This does not make sense\n"); - - return -1; - } else if (format == 0) {// No flags are set. This is a structure & it should - // be looked up in the bsg_s_fmt[] - - const BSG_Format* x = find_format (type); - if (x == NULL) { - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack: cannot find type %d\n", type); - return -1; - } - - const BSG_UINT32* f = x->fields; - for (; *f; f++) { - int fsize = BSG_Unpack_private((BSG_Type) *f, s, dst ? &d:NULL); - if (fsize <= 0) - return fsize; - s += fsize; - } - } - - if (dst) - *dst = d; - return (s - src); -} - -/** - * Free memory associated with unpacked TCPA structure - * @type: TCPA structure type - * @src: (IN) TCPA structure (OUT) end of TCPA structure - * Note: Destroy should be called on all structures created with Unpack - * to ensure that any allocated memory is freed - */ -static void BSG_Destroy_private(BSG_Type type, BSG_BYTE** src) { - BSG_BYTE* s = *src; - - BSG_UINT32 size = __FMT_MASK_SIZE(type); - BSG_UINT32 format = __FMT_MASK_FORMAT(type); - - if ((src == NULL) || (*src == NULL)) { - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with NULL src\n"); - return; - } - - if (format == __FMT_CONST || format == __FMT_DATA) - s += size; - else if (format == __FMT_SIZE || format == __FMT_HSIZE) { - s += size; - BSG_BYTE* ptr = *(BSG_BYTE**) s; - free(ptr); - s += sizeof(void*); - } else if (format == __FMT_PACKED) { - - // this doesn't make sense for unpacking, hence also for Destroy() - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with format __FMT_PACKED. " - "This does not make sense\n"); - - return; - } else if (format == 0) { - const BSG_Format* x = find_format (type); - if (x == NULL) { - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy: cannot find type %d\n", type); - return; - } - - const BSG_UINT32* f = x->fields; - for (; *f; f++) - BSG_Destroy_private((BSG_Type) *f, &s); - } - - *src = s; -} - -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst) -{ - const BSG_BYTE* src2 = (const BSG_BYTE*) src; - return BSG_Pack_private(type, &src2, dst); -} - -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst) -{ - BSG_BYTE* dst2 = (BSG_BYTE*) dst; - return BSG_Unpack_private(type, src, dst ? &dst2:NULL); -} - -void BSG_Destroy(BSG_Type type, void* src) -{ - BSG_BYTE* src2 = (BSG_BYTE*) src; - BSG_Destroy_private(type, &src2); -} - -/** - * Pack a 8/16/32-bit constant into a buffer in big-endian format - * @val: constant value - * @size: constant size in bytes (1, 2, or 4) - * @dst: (OUT) buffer - */ -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst) { - bsglog ("BSG: PackConst on %d of size %i into address %p\n", val, size, dst); - - switch (size) { - case 4: - dst[0] = (BSG_BYTE)((val >> 24) & 0xff); - dst[1] = (BSG_BYTE)((val >> 16) & 0xff); - dst[2] = (BSG_BYTE)((val >> 8) & 0xff); - dst[3] = (BSG_BYTE)(val & 0xff); - break; - case 2: - dst[0] = (BSG_BYTE)((val >> 8) & 0xff); - dst[1] = (BSG_BYTE)(val & 0xff); - break; - case 1: - dst[0] = (BSG_BYTE)(val & 0xff); - break; - } -} - -/** - * Unpack a 8/16/32-bit constant from a buffer in big-endian format - * @src: buffer - * @size: constant size in bytes (1, 2, or 4) - */ -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size) { - BSG_UINT32 val = 0; - - if (src == NULL) - return 0; - - switch (size) { - case 4: - val = (((BSG_UINT32) src[0]) << 24 - | ((BSG_UINT32) src[1]) << 16 - | ((BSG_UINT32) src[2]) << 8 - | (BSG_UINT32) src[3]); - break; - case 2: - val = (((BSG_UINT32) src[0]) << 8 | (BSG_UINT32) src[1]); - break; - case 1: - val = (BSG_UINT32) src[0]; - break; - } - return val; -} - -// Pack a list of parameters. Beware not to send values, but rather you must -// send a pointer to your values Instead. This includes UINT32's. -int BSG_PackList( BSG_BYTE* dst, int ParamCount, ... ) { - int ParamNumber; - BSG_Type format; - BSG_BYTE* val = NULL; - int size=0; - - va_list paramList; - va_start( paramList, ParamCount ); - - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { - //Strangeness with int is because gcc wanted an int rather than a enum of ints. - format = (BSG_Type) va_arg( paramList, int ); - val = va_arg( paramList, BSG_BYTE* ); - size += BSG_Pack(format, val, dst == NULL ? NULL : dst + size); - } - - va_end (paramList); - - return size; -} - -// Unpack a list of parameters. -int BSG_UnpackList( const BSG_BYTE* src, int ParamCount, ... ) { - int ParamNumber = 0; - BSG_Type format; - BSG_BYTE* val = NULL; - int size = 0; - - va_list paramList; - va_start( paramList, ParamCount ); - - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { - format = (BSG_Type) va_arg( paramList, int ); - val = va_arg( paramList, BSG_BYTE* ); - - size += BSG_Unpack(format, src + size, val); - } - - va_end( paramList ); - - return size; -} - -// Destroy any memory allocated by calls to unpack -void BSG_DestroyList(int ParamCount, ... ) { - int ParamNumber = 0; - BSG_Type argType; - BSG_BYTE* paramValue = NULL; - - va_list paramList; - va_start( paramList, ParamCount ); - - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { - argType = (BSG_Type) va_arg( paramList, int ); - paramValue = va_arg( paramList, BSG_BYTE* ); - - BSG_Destroy(argType, paramValue); - } - - va_end( paramList ); - - return; -} - - -// and a tuple version -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]) { - int i; - - for (i = 0; i < numParams; i++) - BSG_Destroy (params[i].type, params[i].addr); - - return TPM_SUCCESS; -} - - -// -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed -// by the caller later -// - -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst) { - int size = BSG_Pack (type, src, NULL); - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); - if (dest == NULL) - return -1; - - size = BSG_Pack(type, src, dest); - *o_dst = dest; - return size; -} - - - -int BSG_PackListMalloc(BSG_BYTE** outBuffer, int ParamCount, ... ) { - va_list args; - int size; - - va_start (args, ParamCount); - size = BSG_PackList (NULL, ParamCount, args); - va_end (args); - - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); - if (dest == NULL) - return -1; - - va_start (args, ParamCount); - size = BSG_PackList (dest, ParamCount, args); - va_end (args); - - *outBuffer = dest; - return size; -} diff --git a/tools/vtpm_manager/util/bsg.h b/tools/vtpm_manager/util/bsg.h deleted file mode 100644 index 0896812..0000000 --- a/tools/vtpm_manager/util/bsg.h +++ /dev/null @@ -1,166 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// bsg.h -// -// This file contains API's for the TPM Byte Stream functions -// -// ================================================================== - -#ifndef __BSG_H__ -#define __BSG_H__ - -#include -#include "buffer.h" - -typedef unsigned int BSG_UINT32; -typedef unsigned char BSG_BYTE; - -// forward decl -struct pack_const_tuple_t; - -struct pack_tuple_t; - - -/** - * Byte stream generator - */ -// this has to be manually kept in sync with the -// s_fmt array!! -// but now we have a self-check function which can make sure things are well -// (if used!) -typedef enum BSG_Type -{ - BSG_TYPE_FIRST = 1, - BSG_TYPE_UINT32 = 1, // start at 1 so that Type 0 only serves as an - // unused/special value - BSG_TYPE_UINT16, - BSG_TYPE_BYTE, - BSG_TYPE_BOOL, - BSG_TPM_SIZE32_DATA, // a 32 bit unsigned size, followed by - // a pointer to that much data. can pass a - // struct pack_buf_t as the param - BSG_TPM_TAG, - BSG_TPM_HANDLE, - BSG_TPM_RESULT, - BSG_TPM_RESOURCE_TYPE, - BSG_TPM_COMMAND_CODE, - BSG_TPM_AUTH_DATA_USAGE, - BSG_TPM_ALGORITHM_ID, - BSG_TPM_PROTOCOL_ID, - BSG_TPM_KEY_USAGE, - BSG_TPM_ENC_SCHEME, - BSG_TPM_SIG_SCHEME, - BSG_TPM_MIGRATE_SCHEME, - BSG_TPM_KEY_FLAGS, - BSG_TPM_AUTHDATA, - BSG_TPM_SECRET, - BSG_TPM_ENCAUTH, - BSG_TPM_PAYLOAD_TYPE, - - BSG_TPM_VERSION, - BSG_TPM_DIGEST, - BSG_TPM_COMPOSITE_HASH, - BSG_TPM_CHOSENID_HASH, - BSG_TPM_NONCE, - BSG_TPM_KEY_HANDLE, - BSG_TPM_KEY_HANDLE_LIST, - BSG_TPM_KEY_PARMS, - BSG_TPM_RSA_KEY_PARMS, - BSG_TPM_STORE_PUBKEY, - BSG_TPM_PUBKEY, - BSG_TPM_KEY, - - BSG_TPM_MIGRATIONKEYAUTH, - BSG_TCPA_AUDIT_EVENT, - BSG_TCPA_EVENT_CERT, - BSG_TPM_PCR_SELECTION, - BSG_TPM_PCR_COMPOSITE, - BSG_TPM_PCR_INFO, - BSG_TPM_STORED_DATA, - BSG_TPM_SYMMETRIC_KEY, - BSG_TPM_STORE_PRIVKEY, - BSG_TPM_STORE_ASYMKEY, - BSG_TPM_MIGRATE_ASYMKEY, - BSG_TPM_QUOTE_INFO, - BSG_TPM_IDENTITY_CONTENTS, - BSG_TPM_PCRVALUE, - BSG_TCPA_PCR_FLAGS, - BSG_TCS_AUTH, - - // this is the BSG_TPM_KEY struct without the encData field - BSG_TPM_KEY_NONSENSITIVE, - - BSG_PACKED, - - BSG_TYPE_MAX -} BSG_Type; - -struct pack_const_tuple_t { - BSG_Type type; - const void * addr; -}; - - -typedef struct pack_tuple_t { - BSG_Type type; - void * addr; -} pack_tuple_t; - -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst); -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst); -void BSG_Destroy(BSG_Type type, void* src); - -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed -// by the caller later. returns size of allocated buffer, or -1 in case -// allocation failed -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst); -int BSG_PackListMalloc (BSG_BYTE** outBuffer, int ParamCount, ... ); - -// a va_list version of PackList -int BSG_PackList(BSG_BYTE* outBuffer, int ParamCount, ... ); -int BSG_UnpackList(const BSG_BYTE* inBuffer, int ParamCount, ... ); -void BSG_DestroyList(int ParamCount, ... ); - -// wrapper of PackList which uses a buffer_t -TPM_RESULT BSG_PackListBuf (buffer_t * o_buf, int ParamCount, ...); - -// and a tuple version -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]); - -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst); -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size); - -BOOL BSG_static_selfcheck (); - -#endif diff --git a/tools/vtpm_manager/util/buffer.c b/tools/vtpm_manager/util/buffer.c deleted file mode 100644 index df48bc2..0000000 --- a/tools/vtpm_manager/util/buffer.c +++ /dev/null @@ -1,226 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - - -#include -#include -#include -#include -#include - -#include "tcg.h" -#include "bsg.h" -#include "buffer.h" - -static TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize); - -// -// buffer functions! -// - -TPM_RESULT buffer_init (buffer_t * buf, tpm_size_t initsize, const BYTE* initval) { - if (initsize == 0) { - memset(buf, 0, sizeof(*buf)); - return TPM_SUCCESS; - } - - - buf->bytes = (BYTE*) malloc (initsize); - if (buf->bytes == NULL) - return TPM_RESOURCES; - - buf->size = initsize; - buf->alloc_size = initsize; - - if (initval) - memcpy (buf->bytes, initval, initsize); - - buf->is_owner = TRUE; - - return TPM_SUCCESS; -} - -TPM_RESULT buffer_init_convert (buffer_t * buf, tpm_size_t initsize, BYTE* initval) { - - buf->size = initsize; - buf->alloc_size = initsize; - buf->bytes = initval; - - buf->is_owner = TRUE; - - return TPM_SUCCESS; -} - -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src) { - TPM_RESULT status = buffer_init (buf, src->size, src->bytes); - buf->is_owner = TRUE; - - return status; -} - - - -// make an alias to a constant array -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val) { - // TODO: try to enforce the const things somehow! - buf->bytes = (BYTE*) val; - buf->size = size; - buf->alloc_size = 0; // this field is now unneeded - - buf->is_owner = FALSE; - - return TPM_SUCCESS; -} - -// make an alias into buf, with given offset and length -// if len = 0, make the alias go to the end of buf -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, - tpm_size_t offset, tpm_size_t len) { - if (offset + len > b->size) { - return TPM_NOSPACE; - } - - buf->bytes = b->bytes + offset; - buf->size = len > 0 ? len : b->size - offset; - - //VS/ buf->alloc_size = 0; - if (len ==0) - buf->alloc_size = b->alloc_size - offset; - else - buf->alloc_size = MIN(b->alloc_size - offset, len); - - - buf->is_owner = FALSE; - - return TPM_SUCCESS; -} - -// make an alias buffer_t into bytestream, with given length -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, tpm_size_t size, BYTE* val) { - - buf->size = size; - buf->alloc_size = size; - buf->bytes = val; - - buf->is_owner = FALSE; - - return TPM_SUCCESS; -} - - - -// copy into the start of dest -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src) -{ - TPM_RESULT status = TPM_SUCCESS; - - if (dest->alloc_size < src->size) { - TPMTRYRETURN( buffer_priv_realloc (dest, src->size) ); - } - - memcpy (dest->bytes, src->bytes, src->size); - dest->size = src->size; - - //VS/ dest->is_owner = TRUE; - - abort_egress: - - return status; -} - - - -BOOL buffer_eq (const buffer_t * a, const buffer_t * b) { - return (a->size == b->size && memcmp (a->bytes, b->bytes, a->size) == 0); -} - - -void buffer_memset (buffer_t * buf, BYTE b) { - memset (buf->bytes, b, buf->size); -} - - -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes) { - TPM_RESULT status = TPM_SUCCESS; - - if (buf->alloc_size < buf->size + len) { - TPMTRYRETURN( buffer_priv_realloc (buf, buf->size + len) ); - } - - memcpy (buf->bytes + buf->size, bytes, len); - - buf->size += len; - - goto egress; - - abort_egress: - - egress: - - return status; -} - -tpm_size_t buffer_len (const buffer_t* buf) { - return buf->size; -} - -TPM_RESULT buffer_free (buffer_t * buf) { - if (buf && buf->is_owner && buf->bytes != NULL) { - free (buf->bytes); - buf->bytes = NULL; - buf->size = buf->alloc_size = 0; - - } - - return TPM_SUCCESS; -} - -TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize) { - - // we want to realloc to twice the size, or the new size, whichever - // bigger - - BYTE * tmpbuf = NULL; - - newsize = MAX (buf->alloc_size * 2, newsize); - - tmpbuf = (BYTE*) realloc (buf->bytes, newsize); - if (tmpbuf == NULL) - return TPM_SIZE; - - - buf->bytes = tmpbuf; - buf->alloc_size = newsize; - - return TPM_SUCCESS; -} diff --git a/tools/vtpm_manager/util/buffer.h b/tools/vtpm_manager/util/buffer.h deleted file mode 100644 index d8a9abc..0000000 --- a/tools/vtpm_manager/util/buffer.h +++ /dev/null @@ -1,95 +0,0 @@ -// =================================================================== -// -// 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_BUFFER_H__ -#define __VTPM_BUFFER_H__ - -#include // for pointer NULL -#include "tcg.h" - -typedef UINT32 tpm_size_t; - -// first version, probably will be expanded... - -#define NULL_BUF {0,0,0,0} - -typedef struct { - // private!! - tpm_size_t size, alloc_size; - BYTE * bytes; - - BOOL is_owner; // do we own this buffer, and need to free it? -} buffer_t; - -// allocate the buffer if initsize > 0, copying over initval if provided -TPM_RESULT buffer_init (buffer_t * buf, - tpm_size_t initsize, - const BYTE* initval); - -// Create a new buffer from a BYTE *. Use buffer_free to destroy original BYTE * -TPM_RESULT buffer_init_convert (buffer_t * buf, - tpm_size_t initsize, - BYTE* initval); - -// make an alias to a constant array, no copying -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val); - -// make an alias into buf, with given offset and length -// if len = 0, make the alias go to the end of buf -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, - tpm_size_t offset, tpm_size_t); - -// make an alias buffer into a bytestream -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, - tpm_size_t size, BYTE* val); - -// "copy constructor" -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src); - - -// copy into the start of a -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src); - -// are they equal? -BOOL buffer_eq (const buffer_t * a, const buffer_t * b); - -// set the buffer to a constant byte -void buffer_memset (buffer_t * buf, BYTE b); - -tpm_size_t buffer_len (const buffer_t* buf); - -TPM_RESULT buffer_free (buffer_t * buf); - -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes); - -#endif // _TOOLS_H_ diff --git a/tools/vtpm_manager/util/hashtable.c b/tools/vtpm_manager/util/hashtable.c deleted file mode 100644 index aff0e2b..0000000 --- a/tools/vtpm_manager/util/hashtable.c +++ /dev/null @@ -1,316 +0,0 @@ -/* - * Copyright (c) 2005, Intel Corp - * Copyright (c) 2002, Christopher Clark - * 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 the original author; nor the names of any 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. -*/ - -/* - * There are duplicates of this code in: - * - tools/xenstore/hashtable.c - * - tools/blktap2/drivers/hashtable.c - */ - -#include "hashtable.h" -#include "hashtable_private.h" -#include -#include -#include -#include - -/* -Credit for primes table: Aaron Krowne - http://br.endernet.org/~akrowne/ - http://planetmath.org/encyclopedia/GoodHashTablePrimes.html -*/ -static const unsigned int primes[] = { -53, 97, 193, 389, -769, 1543, 3079, 6151, -12289, 24593, 49157, 98317, -196613, 393241, 786433, 1572869, -3145739, 6291469, 12582917, 25165843, -50331653, 100663319, 201326611, 402653189, -805306457, 1610612741 -}; -const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]); -const float max_load_factor = 0.65; - -/*****************************************************************************/ -struct hashtable * -create_hashtable(unsigned int minsize, - unsigned int (*hashf) (void*), - int (*eqf) (void*,void*)) -{ - struct hashtable *h; - unsigned int pindex, size = primes[0]; - /* Check requested hashtable isn't too large */ - if (minsize > (1u << 30)) return NULL; - /* Enforce size as prime */ - for (pindex=0; pindex < prime_table_length; pindex++) { - if (primes[pindex] > minsize) { size = primes[pindex]; break; } - } - h = (struct hashtable *)malloc(sizeof(struct hashtable)); - if (NULL == h) return NULL; /*oom*/ - h->table = (struct entry **)malloc(sizeof(struct entry*) * size); - if (NULL == h->table) { free(h); return NULL; } /*oom*/ - memset(h->table, 0, size * sizeof(struct entry *)); - h->tablelength = size; - h->primeindex = pindex; - h->entrycount = 0; - h->hashfn = hashf; - h->eqfn = eqf; - h->loadlimit = (unsigned int) ceil(size * max_load_factor); -#ifdef HASHTABLE_THREADED - pthread_mutex_init(&h->mutex, NULL); -#endif - return h; -} - -/*****************************************************************************/ -unsigned int -hash(struct hashtable *h, void *k) -{ - unsigned int i = h->hashfn(k); - i += ~(i << 9); - i ^= ((i >> 14) | (i << 18)); /* >>> */ - i += (i << 4); - i ^= ((i >> 10) | (i << 22)); /* >>> */ - return i; -} - -/*****************************************************************************/ -static int -hashtable_expand(struct hashtable *h) -{ - /* Double the size of the table to accomodate more entries */ - struct entry **newtable; - struct entry *e; - struct entry **pE; - unsigned int newsize, i, index; - /* Check we're not hitting max capacity */ - if (h->primeindex == (prime_table_length - 1)) return 0; - newsize = primes[++(h->primeindex)]; - - newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize); - if (NULL != newtable) - { - memset(newtable, 0, newsize * sizeof(struct entry *)); - /* This algorithm is not 'stable'. ie. it reverses the list - * when it transfers entries between the tables */ - for (i = 0; i < h->tablelength; i++) { - while (NULL != (e = h->table[i])) { - h->table[i] = e->next; - index = indexFor(newsize,e->h); - e->next = newtable[index]; - newtable[index] = e; - } - } - free(h->table); - h->table = newtable; - } - /* Plan B: realloc instead */ - else - { - newtable = (struct entry **) - realloc(h->table, newsize * sizeof(struct entry *)); - if (NULL == newtable) { (h->primeindex)--; return 0; } - h->table = newtable; - memset(newtable[h->tablelength], 0, newsize - h->tablelength); - for (i = 0; i < h->tablelength; i++) { - for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) { - index = indexFor(newsize,e->h); - if (index == i) - { - pE = &(e->next); - } - else - { - *pE = e->next; - e->next = newtable[index]; - newtable[index] = e; - } - } - } - } - h->tablelength = newsize; - h->loadlimit = (unsigned int) ceil(newsize * max_load_factor); - return -1; -} - -/*****************************************************************************/ -unsigned int -hashtable_count(struct hashtable *h) -{ - unsigned int count; -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - count = h->entrycount; -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return count; -} - -/*****************************************************************************/ -int -hashtable_insert(struct hashtable *h, void *k, void *v) -{ - /* This method allows duplicate keys - but they shouldn't be used */ - unsigned int index; - struct entry *e; -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - if (++(h->entrycount) > h->loadlimit) - { - /* Ignore the return value. If expand fails, we should - * still try cramming just this value into the existing table - * -- we may not have memory for a larger table, but one more - * element may be ok. Next time we insert, we'll try expanding again.*/ - hashtable_expand(h); - } - e = (struct entry *)malloc(sizeof(struct entry)); - if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ - e->h = hash(h,k); - index = indexFor(h->tablelength,e->h); - e->k = k; - e->v = v; - e->next = h->table[index]; - h->table[index] = e; -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return -1; -} - -/*****************************************************************************/ -void * /* returns value associated with key */ -hashtable_search(struct hashtable *h, void *k) -{ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - struct entry *e; - unsigned int hashvalue, index; - hashvalue = hash(h,k); - index = indexFor(h->tablelength,hashvalue); - e = h->table[index]; - while (NULL != e) - { - /* Check hash value to short circuit heavier comparison */ - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) { -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return e->v; - } - e = e->next; - } -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return NULL; -} - -/*****************************************************************************/ -void * /* returns value associated with key */ -hashtable_remove(struct hashtable *h, void *k) -{ - /* TODO: consider compacting the table when the load factor drops enough, - * or provide a 'compact' method. */ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - struct entry *e; - struct entry **pE; - void *v; - unsigned int hashvalue, index; - - hashvalue = hash(h,k); - index = indexFor(h->tablelength,hash(h,k)); - pE = &(h->table[index]); - e = *pE; - while (NULL != e) - { - /* Check hash value to short circuit heavier comparison */ - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) - { - *pE = e->next; - h->entrycount--; - v = e->v; - freekey(e->k); - free(e); - return v; - } - pE = &(e->next); - e = e->next; - } -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return NULL; -} - -/*****************************************************************************/ -/* destroy */ -void -hashtable_destroy(struct hashtable *h, int free_values) -{ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - unsigned int i; - struct entry *e, *f; - struct entry **table = h->table; - if (free_values) - { - for (i = 0; i < h->tablelength; i++) - { - e = table[i]; - while (NULL != e) - { f = e; e = e->next; freekey(f->k); free(f->v); free(f); } - } - } - else - { - for (i = 0; i < h->tablelength; i++) - { - e = table[i]; - while (NULL != e) - { f = e; e = e->next; freekey(f->k); free(f); } - } - } - free(h->table); -#ifdef HASHTABLE_THREADED - pthread_mutex_destroy(&h->mutex); -#endif - free(h); -} diff --git a/tools/vtpm_manager/util/hashtable.h b/tools/vtpm_manager/util/hashtable.h deleted file mode 100644 index dedc60a..0000000 --- a/tools/vtpm_manager/util/hashtable.h +++ /dev/null @@ -1,204 +0,0 @@ -/* - * Copyright (c) 2005, Intel Corp - * Copyright (c) 2002, Christopher Clark - * 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 the original author; nor the names of any 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. -*/ - -/* - * There are duplicates of this code in: - * - tools/xenstore/hashtable.h - * - tools/blktap2/drivers/hashtable.h - */ - -#ifndef __HASHTABLE_CWC22_H__ -#define __HASHTABLE_CWC22_H__ - -struct hashtable; - -/* Example of use: - * - * struct hashtable *h; - * struct some_key *k; - * struct some_value *v; - * - * static unsigned int hash_from_key_fn( void *k ); - * static int keys_equal_fn ( void *key1, void *key2 ); - * - * h = create_hashtable(16, hash_from_key_fn, keys_equal_fn); - * k = (struct some_key *) malloc(sizeof(struct some_key)); - * v = (struct some_value *) malloc(sizeof(struct some_value)); - * - * (initialise k and v to suitable values) - * - * if (! hashtable_insert(h,k,v) ) - * { exit(-1); } - * - * if (NULL == (found = hashtable_search(h,k) )) - * { printf("not found!"); } - * - * if (NULL == (found = hashtable_remove(h,k) )) - * { printf("Not found\n"); } - * - */ - -/* Macros may be used to define type-safe(r) hashtable access functions, with - * methods specialized to take known key and value types as parameters. - * - * Example: - * - * Insert this at the start of your file: - * - * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value); - * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value); - * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value); - * - * This defines the functions 'insert_some', 'search_some' and 'remove_some'. - * These operate just like hashtable_insert etc., with the same parameters, - * but their function signatures have 'struct some_key *' rather than - * 'void *', and hence can generate compile time errors if your program is - * supplying incorrect data as a key (and similarly for value). - * - * Note that the hash and key equality functions passed to create_hashtable - * still take 'void *' parameters instead of 'some key *'. This shouldn't be - * a difficult issue as they're only defined and passed once, and the other - * functions will ensure that only valid keys are supplied to them. - * - * The cost for this checking is increased code size and runtime overhead - * - if performance is important, it may be worth switching back to the - * unsafe methods once your program has been debugged with the safe methods. - * This just requires switching to some simple alternative defines - eg: - * #define insert_some hashtable_insert - * - */ - -/***************************************************************************** - * create_hashtable - - * @name create_hashtable - * @param minsize minimum initial size of hashtable - * @param hashfunction function for hashing keys - * @param key_eq_fn function for determining key equality - * @return newly created hashtable or NULL on failure - */ - -struct hashtable * -create_hashtable(unsigned int minsize, - unsigned int (*hashfunction) (void*), - int (*key_eq_fn) (void*,void*)); - -/***************************************************************************** - * hashtable_insert - - * @name hashtable_insert - * @param h the hashtable to insert into - * @param k the key - hashtable claims ownership and will free on removal - * @param v the value - does not claim ownership - * @return non-zero for successful insertion - * - * This function will cause the table to expand if the insertion would take - * the ratio of entries to table size over the maximum load factor. - * - * This function does not check for repeated insertions with a duplicate key. - * The value returned when using a duplicate key is undefined -- when - * the hashtable changes size, the order of retrieval of duplicate key - * entries is reversed. - * If in doubt, remove before insert. - */ - -int -hashtable_insert(struct hashtable *h, void *k, void *v); - -#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \ -int fnname (struct hashtable *h, keytype *k, valuetype *v) \ -{ \ - return hashtable_insert(h,k,v); \ -} - -/***************************************************************************** - * hashtable_search - - * @name hashtable_search - * @param h the hashtable to search - * @param k the key to search for - does not claim ownership - * @return the value associated with the key, or NULL if none found - */ - -void * -hashtable_search(struct hashtable *h, void *k); - -#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \ -valuetype * fnname (struct hashtable *h, keytype *k) \ -{ \ - return (valuetype *) (hashtable_search(h,k)); \ -} - -/***************************************************************************** - * hashtable_remove - - * @name hashtable_remove - * @param h the hashtable to remove the item from - * @param k the key to search for - does not claim ownership - * @return the value associated with the key, or NULL if none found - */ - -void * /* returns value */ -hashtable_remove(struct hashtable *h, void *k); - -#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \ -valuetype * fnname (struct hashtable *h, keytype *k) \ -{ \ - return (valuetype *) (hashtable_remove(h,k)); \ -} - - -/***************************************************************************** - * hashtable_count - - * @name hashtable_count - * @param h the hashtable - * @return the number of items stored in the hashtable - */ -unsigned int -hashtable_count(struct hashtable *h); - - -/***************************************************************************** - * hashtable_destroy - - * @name hashtable_destroy - * @param h the hashtable - * @param free_values whether to call 'free' on the remaining values - */ - -void -hashtable_destroy(struct hashtable *h, int free_values); - -#endif /* __HASHTABLE_CWC22_H__ */ diff --git a/tools/vtpm_manager/util/hashtable_itr.c b/tools/vtpm_manager/util/hashtable_itr.c deleted file mode 100644 index dcf42c8..0000000 --- a/tools/vtpm_manager/util/hashtable_itr.c +++ /dev/null @@ -1,236 +0,0 @@ -/* - * Copyright (c) 2005, Intel Corp - * Copyright (c) 2002, Christopher Clark - * 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 the original author; nor the names of any 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. -*/ - -/* - * There are duplicates of this code in: - * - tools/blktap2/drivers/hashtable_itr.c - */ - -#include "hashtable.h" -#include "hashtable_private.h" -#include "hashtable_itr.h" -#include /* defines NULL */ - -/*****************************************************************************/ -/* hashtable_iterator - iterator constructor */ - -struct hashtable_itr * -hashtable_iterator(struct hashtable *h) -{ - unsigned int i, tablelength; - struct hashtable_itr *itr = (struct hashtable_itr *) - malloc(sizeof(struct hashtable_itr)); - if (NULL == itr) return NULL; -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - itr->h = h; - itr->e = NULL; - itr->parent = NULL; - tablelength = h->tablelength; - itr->index = tablelength; - if (0 == h->entrycount) { -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return itr; - } - - for (i = 0; i < tablelength; i++) - { - if (NULL != h->table[i]) - { - itr->e = h->table[i]; - itr->index = i; - break; - } - } -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return itr; -} - -/*****************************************************************************/ -/* key - return the key of the (key,value) pair at the current position */ -/* value - return the value of the (key,value) pair at the current position */ - -void * -hashtable_iterator_key(struct hashtable_itr *i) -{ return i->e->k; } - -void * -hashtable_iterator_value(struct hashtable_itr *i) -{ return i->e->v; } - -/*****************************************************************************/ -/* advance - advance the iterator to the next element - * returns zero if advanced to end of table */ - -int -hashtable_iterator_advance(struct hashtable_itr *itr) -{ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&itr->h->mutex); -#endif - unsigned int j,tablelength; - struct entry **table; - struct entry *next; - int ret; - if (NULL == itr->e) { /* stupidity check */ - ret = 0; - goto egress; - } - - next = itr->e->next; - if (NULL != next) - { - itr->parent = itr->e; - itr->e = next; - ret = -1; - goto egress; - } - - tablelength = itr->h->tablelength; - itr->parent = NULL; - if (tablelength <= (j = ++(itr->index))) - { - itr->e = NULL; - ret = 0; - goto egress; - } - table = itr->h->table; - while (NULL == (next = table[j])) - { - if (++j >= tablelength) - { - itr->index = tablelength; - itr->e = NULL; - ret = 0; - goto egress; - } - } - itr->index = j; - itr->e = next; - ret = -1; - - egress: -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&itr->h->mutex); -#endif - return ret; -} - -/*****************************************************************************/ -/* remove - remove the entry at the current iterator position - * and advance the iterator, if there is a successive - * element. - * If you want the value, read it before you remove: - * beware memory leaks if you don't. - * Returns zero if end of iteration. */ - -int -hashtable_iterator_remove(struct hashtable_itr *itr) -{ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&itr->h->mutex); -#endif - struct entry *remember_e, *remember_parent; - int ret; - - /* Do the removal */ - if (NULL == (itr->parent)) - { - /* element is head of a chain */ - itr->h->table[itr->index] = itr->e->next; - } else { - /* element is mid-chain */ - itr->parent->next = itr->e->next; - } - /* itr->e is now outside the hashtable */ - remember_e = itr->e; - itr->h->entrycount--; - freekey(remember_e->k); - - /* Advance the iterator, correcting the parent */ - remember_parent = itr->parent; - ret = hashtable_iterator_advance(itr); - if (itr->parent == remember_e) { itr->parent = remember_parent; } - free(remember_e); -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&itr->h->mutex); -#endif - return ret; -} - -/*****************************************************************************/ -int /* returns zero if not found */ -hashtable_iterator_search(struct hashtable_itr *itr, - struct hashtable *h, void *k) -{ -#ifdef HASHTABLE_THREADED - pthread_mutex_lock(&h->mutex); -#endif - struct entry *e, *parent; - unsigned int hashvalue, index; - int ret; - - hashvalue = hash(h,k); - index = indexFor(h->tablelength,hashvalue); - - e = h->table[index]; - parent = NULL; - while (NULL != e) - { - /* Check hash value to short circuit heavier comparison */ - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) - { - itr->index = index; - itr->e = e; - itr->parent = parent; - itr->h = h; - ret= -1; - goto egress; - } - parent = e; - e = e->next; - } - ret = 0; - -egress: -#ifdef HASHTABLE_THREADED - pthread_mutex_unlock(&h->mutex); -#endif - return ret; -} diff --git a/tools/vtpm_manager/util/hashtable_itr.h b/tools/vtpm_manager/util/hashtable_itr.h deleted file mode 100644 index 35654e0..0000000 --- a/tools/vtpm_manager/util/hashtable_itr.h +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright (c) 2005, Intel Corp - * Copyright (c) 2002, Christopher Clark - * 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 the original author; nor the names of any 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. -*/ - -/* - * There are duplicates of this code in: - * - tools/blktap2/drivers/hashtable_itr.h - */ - - -#ifndef __HASHTABLE_ITR_CWC22__ -#define __HASHTABLE_ITR_CWC22__ -#include "hashtable.h" -#include "hashtable_private.h" /* needed to enable inlining */ - -/*****************************************************************************/ -/* This struct is only concrete here to allow the inlining of two of the - * accessor functions. */ -struct hashtable_itr -{ - struct hashtable *h; - struct entry *e; - struct entry *parent; - unsigned int index; -}; - - -/*****************************************************************************/ -/* hashtable_iterator - */ - -struct hashtable_itr * -hashtable_iterator(struct hashtable *h); - -/*****************************************************************************/ -/* hashtable_iterator_key - * - return the value of the (key,value) pair at the current position */ - -void *hashtable_iterator_key(struct hashtable_itr *i); - -/*****************************************************************************/ -/* value - return the value of the (key,value) pair at the current position */ - -void *hashtable_iterator_value(struct hashtable_itr *i); - -/*****************************************************************************/ -/* advance - advance the iterator to the next element - * returns zero if advanced to end of table */ - -int -hashtable_iterator_advance(struct hashtable_itr *itr); - -/*****************************************************************************/ -/* remove - remove current element and advance the iterator to the next element - * NB: if you need the value to free it, read it before - * removing. ie: beware memory leaks! - * returns zero if advanced to end of table */ - -int -hashtable_iterator_remove(struct hashtable_itr *itr); - -/*****************************************************************************/ -/* search - overwrite the supplied iterator, to point to the entry - * matching the supplied key. - h points to the hashtable to be searched. - * returns zero if not found. */ -int -hashtable_iterator_search(struct hashtable_itr *itr, - struct hashtable *h, void *k); - -#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \ -int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \ -{ \ - return (hashtable_iterator_search(i,h,k)); \ -} - - - -#endif /* __HASHTABLE_ITR_CWC22__*/ diff --git a/tools/vtpm_manager/util/hashtable_private.h b/tools/vtpm_manager/util/hashtable_private.h deleted file mode 100644 index d87a7f9..0000000 --- a/tools/vtpm_manager/util/hashtable_private.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (c) 2005, Intel Corp - * Copyright (c) 2002, Christopher Clark - * 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 the original author; nor the names of any 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. -*/ - -/* - * There are duplicates of this code in: - * - tools/xenstore/hashtable_private.h - * - tools/blktap2/drivers/hashtable_private.h - */ - -#ifndef __HASHTABLE_PRIVATE_CWC22_H__ -#define __HASHTABLE_PRIVATE_CWC22_H__ - -#include "hashtable.h" -#ifdef HASHTABLE_THREADED -#include -#endif - -/*****************************************************************************/ -struct entry -{ - void *k, *v; - unsigned int h; - struct entry *next; -}; - -struct hashtable { - unsigned int tablelength; - struct entry **table; - unsigned int entrycount; - unsigned int loadlimit; - unsigned int primeindex; - unsigned int (*hashfn) (void *k); - int (*eqfn) (void *k1, void *k2); -#ifdef HASHTABLE_THREADED - pthread_mutex_t mutex; -#endif -}; - -/*****************************************************************************/ -unsigned int -hash(struct hashtable *h, void *k); - -/*****************************************************************************/ -/* indexFor */ -static inline unsigned int -indexFor(unsigned int tablelength, unsigned int hashvalue) { - return (hashvalue % tablelength); -}; - -/* Only works if tablelength == 2^N */ -/*static inline unsigned int -indexFor(unsigned int tablelength, unsigned int hashvalue) -{ - return (hashvalue & (tablelength - 1u)); -} -*/ - -/*****************************************************************************/ -#define freekey(X) free(X) -/*define freekey(X) ; */ - - -/*****************************************************************************/ - -#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/ diff --git a/tools/vtpm_manager/util/log.c b/tools/vtpm_manager/util/log.c deleted file mode 100644 index 75fe91a..0000000 --- a/tools/vtpm_manager/util/log.c +++ /dev/null @@ -1,142 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -#include -#include -#include - -#include "buffer.h" -#include "tcg.h" - -// Helper code for the consts, eg. to produce messages for error codes. - -typedef struct error_code_entry_t { - TPM_RESULT code; - char * code_name; - char * msg; -} error_code_entry_t; - -static const error_code_entry_t error_msgs [] = { - { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, - { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, - { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, - { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, - { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, - { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, - { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, - { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, - { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, - { TPM_FAIL, "TPM_FAIL", "The operation failed" }, - { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, - { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, - { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, - { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, - { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, - { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, - { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, - { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, - { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, - { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, - { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, - { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, - { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, - { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, - { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, - { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, - { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, - { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, - { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, - { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, - { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, - { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, - { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, - { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, - { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, - { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, - { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, - { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, - { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, - { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, - { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, - - { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, - { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, - { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, - { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, - { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, - { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, - { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, - { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, - { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, - { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, - { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, - { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, - { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, - { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, - { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, - { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, - { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, - { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, - { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, - { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, - { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, - { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, - { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, - { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, - { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, - { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, - { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, - { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, - { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, - { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, - { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, - { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, - { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, - { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, - { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, - { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, - { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, - { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, -}; - - -// helper function for the error codes: -const char* tpm_get_error_name (TPM_RESULT code) { - // just do a linear scan for now - unsigned i; - for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) - if (code == error_msgs[i].code) - return error_msgs[i].code_name; - - return("Unknown Error Code"); -} diff --git a/tools/vtpm_manager/util/log.h b/tools/vtpm_manager/util/log.h deleted file mode 100644 index 1f15f5b..0000000 --- a/tools/vtpm_manager/util/log.h +++ /dev/null @@ -1,94 +0,0 @@ -// =================================================================== -// -// 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_LOG_H__ -#define __VTPM_LOG_H__ - -#include // for uint32_t -#include // for pointer NULL - -// =========================== LOGGING ============================== - -// the logging module numbers -#define VTPM_LOG_CRYPTO 1 -#define VTPM_LOG_BSG 2 -#define VTPM_LOG_TXDATA 3 -#define VTPM_LOG_TCS 4 -#define VTPM_LOG_TCS_DEEP 5 -#define VTPM_LOG_VTSP 6 -#define VTPM_LOG_VTPM 7 -#define VTPM_LOG_VTPM_DEEP 8 -#define VTPM_LOG_VTSP_DEEP 9 - -static char *module_names[] = { "", - "CRYPTO", - "BSG", - "TXDATA", - "TCS", - "TCS", - "VTSP", - "VTPM", - "VTPM", - "VTSP" - }; - -// Default to standard logging -#ifndef LOGGING_MODULES -#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)) -#endif - -// bit-access macros -#define BITMASK(idx) ( 1U << (idx) ) -#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) -#define SETBIT(num,idx) (num) |= BITMASK(idx) -#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) - -#define vtpmloginfo(module, fmt, args...) \ - if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ - } - -#define vtpmloginfomore(module, fmt, args...) \ - if (GETBIT (LOGGING_MODULES, module) == 1) { \ - fprintf (stdout, fmt,##args); \ - } - -#define vtpmlogerror(module, fmt, args...) \ - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); - -//typedef UINT32 tpm_size_t; - -// helper function for the error codes: -const char* tpm_get_error_name (TPM_RESULT code); - -#endif // _VTPM_LOG_H_ diff --git a/tools/vtpm_manager/util/tcg.h b/tools/vtpm_manager/util/tcg.h deleted file mode 100644 index 5c42913..0000000 --- a/tools/vtpm_manager/util/tcg.h +++ /dev/null @@ -1,503 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tcg.h -// -// This file contains all the structure and type definitions -// -// ================================================================== - -#ifndef __TCG_H__ -#define __TCG_H__ - -// This pragma is used to disallow structure padding -#pragma pack(push, 1) - -// *************************** TYPEDEFS ********************************* -typedef unsigned char BYTE; -typedef unsigned char BOOL; -typedef unsigned short UINT16; -typedef unsigned int UINT32; -typedef unsigned long long UINT64; - -typedef UINT32 TPM_RESULT; -typedef UINT32 TPM_PCRINDEX; -typedef UINT32 TPM_DIRINDEX; -typedef UINT32 TPM_HANDLE; -typedef TPM_HANDLE TPM_AUTHHANDLE; -typedef TPM_HANDLE TCPA_HASHHANDLE; -typedef TPM_HANDLE TCPA_HMACHANDLE; -typedef TPM_HANDLE TCPA_ENCHANDLE; -typedef TPM_HANDLE TPM_KEY_HANDLE; -typedef TPM_HANDLE TCPA_ENTITYHANDLE; -typedef UINT32 TPM_RESOURCE_TYPE; -typedef UINT32 TPM_COMMAND_CODE; -typedef UINT16 TPM_PROTOCOL_ID; -typedef BYTE TPM_AUTH_DATA_USAGE; -typedef UINT16 TPM_ENTITY_TYPE; -typedef UINT32 TPM_ALGORITHM_ID; -typedef UINT16 TPM_KEY_USAGE; -typedef UINT16 TPM_STARTUP_TYPE; -typedef UINT32 TPM_CAPABILITY_AREA; -typedef UINT16 TPM_ENC_SCHEME; -typedef UINT16 TPM_SIG_SCHEME; -typedef UINT16 TPM_MIGRATE_SCHEME; -typedef UINT16 TPM_PHYSICAL_PRESENCE; -typedef UINT32 TPM_KEY_FLAGS; - -#define TPM_DIGEST_SIZE 20 // Don't change this -typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; -typedef TPM_AUTHDATA TPM_SECRET; -typedef TPM_AUTHDATA TPM_ENCAUTH; -typedef BYTE TPM_PAYLOAD_TYPE; -typedef UINT16 TPM_TAG; - -// Data Types of the TCS -typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session -typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle -typedef UINT32 TCS_KEY_HANDLE; // Basic key handle - -// ************************* STRUCTURES ********************************** - -typedef struct TPM_VERSION { - BYTE major; - BYTE minor; - BYTE revMajor; - BYTE revMinor; -} TPM_VERSION; - -static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; - -typedef struct TPM_DIGEST { - BYTE digest[TPM_DIGEST_SIZE]; -} TPM_DIGEST; - -typedef TPM_DIGEST TPM_PCRVALUE; -typedef TPM_DIGEST TPM_COMPOSITE_HASH; -typedef TPM_DIGEST TPM_DIRVALUE; -typedef TPM_DIGEST TPM_HMAC; -typedef TPM_DIGEST TPM_CHOSENID_HASH; - -typedef struct TPM_NONCE { - BYTE nonce[TPM_DIGEST_SIZE]; -} TPM_NONCE; - -typedef struct TPM_KEY_PARMS { - TPM_ALGORITHM_ID algorithmID; - TPM_ENC_SCHEME encScheme; - TPM_SIG_SCHEME sigScheme; - UINT32 parmSize; - BYTE* parms; -} TPM_KEY_PARMS; - -typedef struct TPM_RSA_KEY_PARMS { - UINT32 keyLength; - UINT32 numPrimes; - UINT32 exponentSize; - BYTE* exponent; -} TPM_RSA_KEY_PARMS; - -typedef struct TPM_STORE_PUBKEY { - UINT32 keyLength; - BYTE* key; -} TPM_STORE_PUBKEY; - -typedef struct TPM_PUBKEY { - TPM_KEY_PARMS algorithmParms; - TPM_STORE_PUBKEY pubKey; -} TPM_PUBKEY; - -typedef struct TPM_KEY { - TPM_VERSION ver; - TPM_KEY_USAGE keyUsage; - TPM_KEY_FLAGS keyFlags; - TPM_AUTH_DATA_USAGE authDataUsage; - TPM_KEY_PARMS algorithmParms; - UINT32 PCRInfoSize; - BYTE* PCRInfo; // this should be a TPM_PCR_INFO, or NULL - TPM_STORE_PUBKEY pubKey; - UINT32 encDataSize; - BYTE* encData; -} TPM_KEY; - -typedef struct TPM_PCR_SELECTION { - UINT16 sizeOfSelect; /// in bytes - BYTE* pcrSelect; -} TPM_PCR_SELECTION; - -typedef struct TPM_PCR_COMPOSITE { - TPM_PCR_SELECTION select; - UINT32 valueSize; - TPM_PCRVALUE* pcrValue; -} TPM_PCR_COMPOSITE; - - -typedef struct TPM_PCR_INFO { - TPM_PCR_SELECTION pcrSelection; - TPM_COMPOSITE_HASH digestAtRelease; - TPM_COMPOSITE_HASH digestAtCreation; -} TPM_PCR_INFO; - - -typedef struct TPM_BOUND_DATA { - TPM_VERSION ver; - TPM_PAYLOAD_TYPE payload; - BYTE* payloadData; -} TPM_BOUND_DATA; - -typedef struct TPM_STORED_DATA { - TPM_VERSION ver; - UINT32 sealInfoSize; - BYTE* sealInfo; - UINT32 encDataSize; - BYTE* encData; -} TPM_STORED_DATA; - -typedef struct TCS_AUTH { - TCS_AUTHHANDLE AuthHandle; - TPM_NONCE NonceOdd; // system - TPM_NONCE NonceEven; // TPM - BOOL fContinueAuthSession; - TPM_AUTHDATA HMAC; -} TCS_AUTH; - -// structures for dealing with sizes followed by buffers in all the -// TCG structure. -typedef struct pack_buf_t { - UINT32 size; - BYTE * data; -} pack_buf_t; - -typedef struct pack_constbuf_t { - UINT32 size; - const BYTE* data; -} pack_constbuf_t; - - - -// **************************** CONSTANTS ********************************* - -// BOOL values -#define TRUE 0x01 -#define FALSE 0x00 - -#define TCPA_MAX_BUFFER_LENGTH 0x2000 - -// -// TPM_COMMAND_CODE values -#define TPM_PROTECTED_ORDINAL 0x00000000UL -#define TPM_UNPROTECTED_ORDINAL 0x80000000UL -#define TPM_CONNECTION_ORDINAL 0x40000000UL -#define TPM_VENDOR_ORDINAL 0x20000000UL - -#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) -#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) -#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) - - - -// -// TPM_RESULT values -// -// just put in the whole table from spec 1.2 - -#define TPM_BASE 0x0 // The start of TPM return codes -#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands -#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. - -#define TPM_SUCCESS TPM_BASE // Successful completion of the operation -#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed -#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect -#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad -#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. -#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access -#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated -#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled -#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled -#define TPM_FAIL TPM_BASE + 9 // The operation failed -#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent -#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled -#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid -#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found -#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme -#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed -#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted -#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. -#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set -#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM -#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner -#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. -#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short -#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. -#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. -#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value -#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. -#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. -#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. -#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization -#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid -#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM -#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. -#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. -#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. -#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed -#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed -#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed -#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup -#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information -#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM - -#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. -#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. -#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key -#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. -#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value -#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability -#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions -#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also -#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success -#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute -#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport -#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed -#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource -#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode -#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID -#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available -#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command -#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key -#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization -#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable -#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation -#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to -#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area -#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match -#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to -#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict -#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent -#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. -#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect -#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area -#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large -#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded -#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set -#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded -#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked -#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family -#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled -#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session - -// TPM_STARTUP_TYPE values -#define TPM_ST_CLEAR 0x0001 -#define TPM_ST_STATE 0x0002 -#define TPM_ST_DEACTIVATED 0x003 - -// TPM_TAG values -#define TPM_TAG_RQU_COMMAND 0x00c1 -#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 -#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 -#define TPM_TAG_RSP_COMMAND 0x00c4 -#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 -#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 - -// TPM_PAYLOAD_TYPE values -#define TPM_PT_ASYM 0x01 -#define TPM_PT_BIND 0x02 -#define TPM_PT_MIGRATE 0x03 -#define TPM_PT_MAINT 0x04 -#define TPM_PT_SEAL 0x05 - -// TPM_ENTITY_TYPE values -#define TPM_ET_KEYHANDLE 0x0001 -#define TPM_ET_OWNER 0x0002 -#define TPM_ET_DATA 0x0003 -#define TPM_ET_SRK 0x0004 -#define TPM_ET_KEY 0x0005 - -/// TPM_ResourceTypes -#define TPM_RT_KEY 0x00000001 -#define TPM_RT_AUTH 0x00000002 -#define TPM_RT_TRANS 0x00000004 -#define TPM_RT_CONTEXT 0x00000005 - -// TPM_PROTOCOL_ID values -#define TPM_PID_OIAP 0x0001 -#define TPM_PID_OSAP 0x0002 -#define TPM_PID_ADIP 0x0003 -#define TPM_PID_ADCP 0x0004 -#define TPM_PID_OWNER 0x0005 - -// TPM_ALGORITHM_ID values -#define TPM_ALG_RSA 0x00000001 -#define TPM_ALG_DES 0x00000002 -#define TPM_ALG_3DES 0X00000003 -#define TPM_ALG_SHA 0x00000004 -#define TPM_ALG_HMAC 0x00000005 -#define TCPA_ALG_AES 0x00000006 - -// TPM_ENC_SCHEME values -#define TPM_ES_NONE 0x0001 -#define TPM_ES_RSAESPKCSv15 0x0002 -#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 - -// TPM_SIG_SCHEME values -#define TPM_SS_NONE 0x0001 -#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 -#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 - -// TPM_KEY_USAGE values -#define TPM_KEY_EK 0x0000 -#define TPM_KEY_SIGNING 0x0010 -#define TPM_KEY_STORAGE 0x0011 -#define TPM_KEY_IDENTITY 0x0012 -#define TPM_KEY_AUTHCHANGE 0X0013 -#define TPM_KEY_BIND 0x0014 -#define TPM_KEY_LEGACY 0x0015 - -// TPM_AUTH_DATA_USAGE values -#define TPM_AUTH_NEVER 0x00 -#define TPM_AUTH_ALWAYS 0x01 - -// Key Handle of owner and srk -#define TPM_OWNER_KEYHANDLE 0x40000001 -#define TPM_SRK_KEYHANDLE 0x40000000 - -// ---------------------- Functions for checking TPM_RESULTs ----------------- - -#include - -// FIXME: Review use of these and delete unneeded ones. - -// these are really badly dependent on local structure: -// DEPENDS: local var 'status' of type TPM_RESULT -// DEPENDS: label 'abort_egress' which cleans up and returns the status -#define ERRORDIE(s) do { status = s; \ - fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ - goto abort_egress; } \ - while (0) - -// DEPENDS: local var 'status' of type TPM_RESULT -// DEPENDS: label 'abort_egress' which cleans up and returns the status -// Try command c. If it fails, set status to s and goto abort. -#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ - status = s; \ - printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ - goto abort_egress; \ - } else {\ - status = c; \ - } - -// Try command c. If it fails, print error message, set status to actual return code. Goto abort -#define TPMTRYRETURN(c) do { status = c; \ - if (status != TPM_SUCCESS) { \ - fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ - goto abort_egress; \ - } \ - } while(0) - - -#pragma pack(pop) - -#endif //__TCPA_H__ diff --git a/tools/xenstore/hashtable.c b/tools/xenstore/hashtable.c index 3b89223..0ba1d55 100644 --- a/tools/xenstore/hashtable.c +++ b/tools/xenstore/hashtable.c @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/blktap2/drivers/hashtable.c - * - tools/vtpm_manager/util/hashtable.c */ #include "hashtable.h" diff --git a/tools/xenstore/hashtable.h b/tools/xenstore/hashtable.h index 8e6bb5b..4d68223 100644 --- a/tools/xenstore/hashtable.h +++ b/tools/xenstore/hashtable.h @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/blktap2/drivers/hashtable.h - * - tools/vtpm_manager/util/hashtable.h */ #ifndef __HASHTABLE_CWC22_H__ diff --git a/tools/xenstore/hashtable_private.h b/tools/xenstore/hashtable_private.h index cabaffe..a08559d 100644 --- a/tools/xenstore/hashtable_private.h +++ b/tools/xenstore/hashtable_private.h @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/blktap2/drivers/hashtable_private.h - * - tools/vtpm_manager/util/hashtable_private.h */ #ifndef __HASHTABLE_PRIVATE_CWC22_H__ diff --git a/tools/xm-test/configure.ac b/tools/xm-test/configure.ac index ad1eb78..c142140 100644 --- a/tools/xm-test/configure.ac +++ b/tools/xm-test/configure.ac @@ -143,7 +143,6 @@ AC_CONFIG_FILES([ tests/unpause/Makefile tests/vcpu-pin/Makefile tests/vcpu-disable/Makefile - tests/vtpm/Makefile tests/xapi/Makefile tests/enforce_dom0_cpus/Makefile tests/cpupool/Makefile diff --git a/tools/xm-test/grouptest/default b/tools/xm-test/grouptest/default index f0516b2..e04591b 100644 --- a/tools/xm-test/grouptest/default +++ b/tools/xm-test/grouptest/default @@ -27,5 +27,4 @@ sysrq unpause vcpu-disable vcpu-pin -vtpm xapi diff --git a/tools/xm-test/grouptest/medium b/tools/xm-test/grouptest/medium index bafc988..5c3e1b1 100644 --- a/tools/xm-test/grouptest/medium +++ b/tools/xm-test/grouptest/medium @@ -22,4 +22,3 @@ sysrq 01_sysrq_basic_neg.test 02_sysrq_sync_pos.test unpause vcpu-disable vcpu-pin -vtpm diff --git a/tools/xm-test/grouptest/xapi b/tools/xm-test/grouptest/xapi index 3b04921..7a08b77 100644 --- a/tools/xm-test/grouptest/xapi +++ b/tools/xm-test/grouptest/xapi @@ -1,2 +1 @@ xapi -vtpm 09_vtpm-xapi.test diff --git a/tools/xm-test/lib/XmTestLib/XenDomain.py b/tools/xm-test/lib/XmTestLib/XenDomain.py index ae8c550..3ba7433 100644 --- a/tools/xm-test/lib/XmTestLib/XenDomain.py +++ b/tools/xm-test/lib/XmTestLib/XenDomain.py @@ -59,7 +59,6 @@ class XenConfig: # These options need to be lists self.defaultOpts["disk"] = [] self.defaultOpts["vif"] = [] - self.defaultOpts["vtpm"] = [] self.opts = self.defaultOpts diff --git a/tools/xm-test/tests/Makefile.am b/tools/xm-test/tests/Makefile.am index 8d673ed..455f50c 100644 --- a/tools/xm-test/tests/Makefile.am +++ b/tools/xm-test/tests/Makefile.am @@ -25,7 +25,6 @@ SUBDIRS = \ unpause \ vcpu-disable \ vcpu-pin \ - vtpm \ enforce_dom0_cpus \ save restore migrate \ cpupool diff --git a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py b/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py deleted file mode 100644 index dfd1227..0000000 --- a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# verify list - - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) - -try: - domain.start(noConsole=True) -except DomainError, e: - if verbose: - print e.extra - vtpm_cleanup(domain.getName()) - FAIL("Unable to create domain") - - -domName = domain.getName() - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -status, output = traceCommand("xm vtpm-list %s" % domain.getId()) -eyecatcher = "/local/domain/0/backend/vtpm" -where = output.find(eyecatcher) -if status != 0: - FAIL("xm vtpm-list returned bad status, expected 0, status is %i" % status) -elif where < 0: - FAIL("Fail to list virtual TPM device") - -domain.stop() diff --git a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py b/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py deleted file mode 100644 index a18cbab..0000000 --- a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# check list of pcrs - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -domain.closeConsole() - -domain.stop() - -if not re.search("PCR-00:",run["output"]): - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") diff --git a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py b/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py deleted file mode 100644 index b863f27..0000000 --- a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# check list of pcrs; suspend and resume the domain and -# check list of pcrs again - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -consoleHistory = console.getHistory() -domain.closeConsole() - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm save %s %s.save" % - (domName, domName), - timeout=30) - - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm save did not succeed") - - try: - status, ouptut = traceCommand("xm restore %s.save" % - (domName), - timeout=30) - except TimeoutError, e: - os.remove("%s.save" % domName) - saveLog(consoleHistory) - FAIL(str(e)) - - os.remove("%s.save" % domName) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm restore did not succeed") - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - loop += 1 - -domain.closeConsole() - -domain.stop() - diff --git a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py deleted file mode 100644 index ccc8b73..0000000 --- a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py +++ /dev/null @@ -1,93 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# check list of pcrs; locally migrate the domain and -# check list of pcrs again -# This test does local live migration. - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -consoleHistory = console.getHistory() -domain.closeConsole() - -old_domid = domid(domName) - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm migrate -l %s localhost" % - domName, - timeout=90) - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm migrate did not succeed. External device migration activated?") - - - domName = domain.getName() - new_domid = domid(domName) - - if (old_domid == new_domid): - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % - (old_domid,loop)) - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - loop += 1 - -domain.closeConsole() - -domain.stop() diff --git a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py deleted file mode 100644 index 57b87df..0000000 --- a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py +++ /dev/null @@ -1,93 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# check list of pcrs; locally migrate the domain and -# check list of pcrs again -# This test does local (non-live) migration. - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -consoleHistory = console.getHistory() -domain.closeConsole() - -old_domid = domid(domName) - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm migrate %s localhost" % - domName, - timeout=90) - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm migrate did not succeed. External device migration activated?") - - - domName = domain.getName() - new_domid = domid(domName) - - if (old_domid == new_domid): - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % - (old_domid,loop)) - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - loop += 1 - -domain.closeConsole() - -domain.stop() diff --git a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py b/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py deleted file mode 100644 index c70691d..0000000 --- a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py +++ /dev/null @@ -1,125 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# extend a pcr -# check list of pcrs; suspend and resume the domain and -# check list of pcrs again and validate extended pcr - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("mknod /dev/tpm0 c 10 224") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while creating /dev/tpm0") - -try: - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while extending PCR 0") - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) - -if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) - -consoleHistory = console.getHistory() -domain.closeConsole() - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm save %s %s.save" % - (domName, domName), - timeout=30) - - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm save did not succeed") - - try: - status, ouptut = traceCommand("xm restore %s.save" % - (domName), - timeout=30) - except TimeoutError, e: - os.remove("%s.save" % domName) - saveLog(consoleHistory) - FAIL(str(e)) - - os.remove("%s.save" % domName) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm restore did not succeed") - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) - - loop += 1 - -domain.closeConsole() - -domain.stop() - diff --git a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py deleted file mode 100644 index 4ff3360..0000000 --- a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# extend a pcr -# check list of pcrs; locally migrate the domain and -# check list of pcrs again and validate extended pcr -# This test does local live migration. - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("mknod /dev/tpm0 c 10 224") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while creating /dev/tpm0") - -try: - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while extending PCR 0") - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) - -if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) - -consoleHistory = console.getHistory() -domain.closeConsole() - -old_domid = domid(domName) - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm migrate -l %s localhost" % - domName, - timeout=90) - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm migrate did not succeed. External device migration activated?") - - - domName = domain.getName() - new_domid = domid(domName) - - if (old_domid == new_domid): - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % - (old_domid,loop)) - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) - - loop += 1 - -domain.closeConsole() - -domain.stop() diff --git a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py deleted file mode 100644 index 27125fc..0000000 --- a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Positive Test: create domain with virtual TPM attached at build time, -# extend a pcr -# check list of pcrs; locally migrate the domain and -# check list of pcrs again and validate extended pcr -# This test does local (non-live) migration. - -from XmTestLib import * -from vtpm_utils import * -import commands -import os -import os.path -import atexit - -config = {"vtpm":"instance=1,backend=0"} -domain = XmTestDomain(extraConfig=config) -domName = domain.getName() -consoleHistory = "" - -try: - console = domain.start() -except DomainError, e: - if verbose: - print e.extra - FAIL("Unable to create domain (%s)" % domName) - -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("mknod /dev/tpm0 c 10 224") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while creating /dev/tpm0") - -try: - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("Error while extending PCR 0") - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) - -if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) - -consoleHistory = console.getHistory() -domain.closeConsole() - -old_domid = domid(domName) - -loop = 0 -while loop < 3: - try: - status, ouptut = traceCommand("xm migrate %s localhost" % - domName, - timeout=90) - except TimeoutError, e: - saveLog(consoleHistory) - FAIL(str(e)) - - if status != 0: - saveLog(consoleHistory) - FAIL("xm migrate did not succeed. External device migration activated?") - - - domName = domain.getName() - new_domid = domid(domName) - - if (old_domid == new_domid): - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % - (old_domid,loop)) - - try: - console = domain.getConsole() - except ConsoleError, e: - FAIL(str(e)) - - try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") - except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("No result from dumping the PCRs") - - if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") - - if not re.search("PCR-00: 1E A7 BD",run["output"]): - saveLog(console.getHistory()) - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) - - loop += 1 - -domain.closeConsole() - -domain.stop() diff --git a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py b/tools/xm-test/tests/vtpm/09_vtpm-xapi.py deleted file mode 100644 index a1aa8b3..0000000 --- a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py +++ /dev/null @@ -1,158 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -# Test to test the vtpm class through the Xen-API -# -# Tested methods: -# VTPM: get_uuid, get_backend, get_by_uuid, get_record -# create, destroy, get_VM -# VM: get_VTPMS - -from XmTestLib import xapi -from XmTestLib.XenAPIDomain import XmTestAPIDomain -from XmTestLib import * -from vtpm_utils import * -import commands -import os - -VTPM_RECORD_KEYS = [ 'backend', 'VM', 'uuid', 'other_config' ] - -try: - # XmTestAPIDomain tries to establish a connection to XenD - domain = XmTestAPIDomain() -except Exception, e: - SKIP("Skipping test. Error: %s" % str(e)) -vm_uuid = domain.get_uuid() - -vtpmcfg = {} -vtpmcfg['backend'] = DOM0_UUID -vtpmcfg['VM'] = vm_uuid - -session = xapi.connect() - -vtpm_uuid = session.xenapi.VTPM.create(vtpmcfg) - -vtpm_be = session.xenapi.VTPM.get_backend(vtpm_uuid) -if vtpm_be != vtpmcfg['backend']: - FAIL("vTPM's backend is in '%s', expected: '%s'" % - (vtpm_be, vtpmcfg['backend'])) - -vtpm_rec = session.xenapi.VTPM.get_record(vtpm_uuid) - -miss_keys = [] -for k in VTPM_RECORD_KEYS: - if k not in vtpm_rec.keys(): - miss_keys.append(k) -if len(miss_keys) > 0: - FAIL("vTPM record is missing key(s): %s" % miss_keys) - -if vtpm_rec['uuid'] != vtpm_uuid: - FAIL("vTPM record shows vtpm uuid '%s', expected: '%s'" % - (vtpm_rec['uuid'], vtpm_uuid)) -if vtpm_rec['VM'] != vm_uuid: - FAIL("vTPM record shows VM uuid '%s', expected: '%s'" % - (vtpm_rec['VM'], vm_uuid)) -if vtpm_rec['backend'] != vtpmcfg['backend']: - FAIL("vTPM record shows VM bakcned '%s', expected: '%s'" % - (vtpm_rev['backend'], vtpmcfg['backend'])) - -badkeys = [] -keys = vtpm_rec.keys() -for k in keys: - if k not in VTPM_RECORD_KEYS: - badkeys.append(k) -if len(badkeys) > 0: - FAIL("Unexpected attributes in result: %s" % badkeys) - -if vm_uuid != session.xenapi.VTPM.get_VM(vtpm_uuid): - FAIL("VM uuid from VTPM.get_VM different (%s) than expected (%s)." % - (vm_ref, vm_uuid)) - -uuid = session.xenapi.VTPM.get_uuid(vtpm_uuid) -if uuid != vtpm_uuid: - FAIL("vTPM from VTPM.get_uuid different (%s) than expected (%s)." % - (uuid, vtpm_uuid)) - -vtpm_ref = session.xenapi.VTPM.get_by_uuid(vtpm_uuid) -if vtpm_ref != vtpm_uuid: - FAIL("vTPM from VTPM.get_by_uuid different (%s) than expected (%s)." % - (vtpm_ref, vtpm_uuid)) - -vm_vtpms = session.xenapi.VM.get_VTPMs(vm_uuid) -if len(vm_vtpms) != 1: - FAIL("Number of vTPMs from get_VTPMs is (%d) not what was expected (%d)" % - (len(vm_vtpms), 1)) -if vtpm_uuid not in vm_vtpms: - FAIL("Other vTPM uuid (%s) returned from VM.get_VTPMs than expected (%s)" % - (vm_vtpms[0], vtpm_uuid)) - -try: - console = domain.start() -except DomainError, e: - FAIL("Unable to create domain.") - -try: - console.sendInput("input") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("1. No result from dumping the PCRs") - -if re.search("No such file",run["output"]): - FAIL("TPM frontend support not compiled into (domU?) kernel") - -if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("1. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) - -try: - session.xenapi.VTPM.destroy(vtpm_uuid) - #Should never get here - FAIL("Could destroy vTPM while VM is running") -except: - pass - -rc = session.xenapi.VM.suspend(vm_uuid) -if rc: - FAIL("Could not suspend VM") - -try: - session.xenapi.VTPM.destroy(vtpm_uuid) - #May not throw an exception in 'suspend' state -except: - pass - -rc = session.xenapi.VM.resume(vm_uuid, False) -if rc: - FAIL("Could not resume VM") - -try: - console = domain.getConsole() -except ConsoleError, e: - FAIL(str(e)) - -try: - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") -except ConsoleError, e: - saveLog(console.getHistory()) - FAIL("2. No result from dumping the PCRs. vTPM has been removed?") - -if not re.search("PCR-00:",run["output"]): - saveLog(console.getHistory()) - FAIL("2. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) - -domain.stop() - -try: - session.xenapi.VTPM.destroy(vtpm_uuid) -except: - FAIL("Could NOT destroy vTPM while domain is halted.") - -domain.destroy() diff --git a/tools/xm-test/tests/vtpm/Makefile.am b/tools/xm-test/tests/vtpm/Makefile.am deleted file mode 100644 index dd67e45..0000000 --- a/tools/xm-test/tests/vtpm/Makefile.am +++ /dev/null @@ -1,27 +0,0 @@ -SUBDIRS = - -TESTS = 01_vtpm-list_pos.test \ - 02_vtpm-cat_pcrs.test \ - 03_vtpm-susp_res.test \ - 04_vtpm-loc_migr.test \ - 05_vtpm-loc_migr.test \ - 06_vtpm-susp_res_pcrs.test \ - 07_vtpm-mig_pcrs.test \ - 08_vtpm-mig_pcrs.test \ - 09_vtpm-xapi.test - -XFAIL_TESTS = - -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS) vtpm_utils.py -TESTS_ENVIRONMENT=@TENV@ - -%.test: %.py - cp $< $@ - chmod +x $@ - -clean-local: am_config_clean-local - -am_config_clean-local: - rm -f *test - rm -f *log - rm -f *~ diff --git a/tools/xm-test/tests/vtpm/vtpm_utils.py b/tools/xm-test/tests/vtpm/vtpm_utils.py deleted file mode 100644 index 4e5b281..0000000 --- a/tools/xm-test/tests/vtpm/vtpm_utils.py +++ /dev/null @@ -1,30 +0,0 @@ -#!/usr/bin/python - -# Copyright (C) International Business Machines Corp., 2006 -# Author: Stefan Berger - -from XmTestLib import * - -if ENABLE_HVM_SUPPORT: - SKIP("vtpm tests not supported for HVM domains") - -status, output = traceCommand("COLUMNS=200 ; " - "ps aux | grep vtpm_manager | grep -v grep") -if output == "": - SKIP("virtual TPM manager must be started to run this test; might " - "need /dev/tpm0") - -def vtpm_cleanup(domName): - traceCommand("/etc/xen/scripts/vtpm-delete " - "`xenstore-read /local/domain/0/backend/vtpm/%s/0/uuid`" % - str(domid(domName))) - -def vtpm_cleanup(uuid): - from xen.xm import main - if main.serverType != main.SERVER_XEN_API: - traceCommand("/etc/xen/scripts/vtpm-delete %s" % uuid) - -def vtpm_get_uuid(domainid): - s, o = traceCommand("xenstore-read " - "/local/domain/0/backend/vtpm/%s/0/uuid" % domainid) - return o -- 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 Wed Nov 07 20:37:25 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 07 Nov 2012 20:37:25 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TWCMu-0000VV-9n; Wed, 07 Nov 2012 20:37:00 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TWCMs-0000VD-KL for xen-devel@lists.xen.org; Wed, 07 Nov 2012 20:36:59 +0000 Received: from [85.158.139.83:61379] by server-15.bemta-5.messagelabs.com id 98/04-26920-966CA905; Wed, 07 Nov 2012 20:36:57 +0000 X-Env-Sender: robert.phillips@citrix.com X-Msg-Ref: server-12.tower-182.messagelabs.com!1352320602!29243370!2 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAxODIwMzA=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 16827 invoked from network); 7 Nov 2012 20:36:55 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-12.tower-182.messagelabs.com with RC4-SHA encrypted SMTP; 7 Nov 2012 20:36:55 -0000 X-SBRS: -2.2 X-MesageID: 43849546 X-Ironport-Server: ftlpip01.citrite.net X-Remote-IP: 75.150.106.249 X-Policy: $Relay X-IronPort-AV: E=Sophos;i="4.80,732,1344211200"; d="scan'208";a="43849546" Received: from 75-150-106-249-newengland.hfc.comcastbusiness.net (HELO paine.oldroadcomputing.net) ([75.150.106.249]) by SMTP.CITRIX.COM with ESMTP; 07 Nov 2012 20:36:28 +0000 From: Robert Phillips To: xen-devel@lists.xen.org Date: Wed, 7 Nov 2012 15:36:08 -0500 Message-Id: <1352320568-653-1-git-send-email-robert.phillips@citrix.com> X-Mailer: git-send-email 1.7.9.5 Cc: Robert Phillips Subject: [Xen-devel] [PATCH] Provide support for multiple frame buffers in Xen 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 Support is provided for both shadow and hardware assisted paging (HAP) modes. This code bookkeeps the set of video frame buffers (vram), detects when the guest has modified any of those buffers and, upon request, returns a bitmap of the modified pages. This lets other software components re-paint the portions of the monitor (or monitors) that have changed. Each monitor has a frame buffer of some size at some position in guest physical memory. The set of frame buffers being tracked can change over time as monitors are plugged and unplugged. (Version 2 of this patch.) Signed-Off-By: Robert Phillips --- tools/libxc/xenctrl.h | 17 +- xen/arch/x86/hvm/Makefile | 2 +- xen/arch/x86/hvm/hvm.c | 4 +- xen/arch/x86/mm/Makefile | 1 + xen/arch/x86/mm/dirty_vram.c | 951 ++++++++++++++++++++++++++++++++++++++ xen/arch/x86/mm/hap/hap.c | 140 +----- xen/arch/x86/mm/paging.c | 236 ++++------ xen/arch/x86/mm/shadow/common.c | 335 ++++++++------ xen/arch/x86/mm/shadow/multi.c | 174 ++++--- xen/arch/x86/mm/shadow/multi.h | 7 +- xen/arch/x86/mm/shadow/types.h | 1 + xen/include/asm-x86/dirty_vram.h | 196 ++++++++ xen/include/asm-x86/hap.h | 4 - xen/include/asm-x86/hvm/domain.h | 2 +- xen/include/asm-x86/paging.h | 22 +- xen/include/asm-x86/shadow.h | 6 - 16 files changed, 1535 insertions(+), 563 deletions(-) create mode 100644 xen/arch/x86/mm/dirty_vram.c create mode 100644 xen/include/asm-x86/dirty_vram.h diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h index 7eb5743..693d7fe 100644 --- a/tools/libxc/xenctrl.h +++ b/tools/libxc/xenctrl.h @@ -1552,15 +1552,20 @@ int xc_hvm_inject_msi( xc_interface *xch, domid_t dom, uint64_t addr, uint32_t data); /* - * Track dirty bit changes in the VRAM area + * Track dirty bit changes in a VRAM region defined by + * [ first_pfn : first_pfn + nr - 1 ] * * All of this is done atomically: - * - get the dirty bitmap since the last call - * - set up dirty tracking area for period up to the next call - * - clear the dirty tracking area. + * - gets the dirty bitmap since the last call, all zeroes for + * the first call with some new region + * - sets up a dirty tracking region for period up to the next call + * - clears the specified dirty tracking region. * - * Returns -ENODATA and does not fill bitmap if the area has changed since the - * last call. + * Creating a new region causes any existing regions that it overlaps + * to be discarded. + * + * Specifying nr == 0 causes all regions to be discarded and + * disables dirty bit tracking. */ int xc_hvm_track_dirty_vram( xc_interface *xch, domid_t dom, diff --git a/xen/arch/x86/hvm/Makefile b/xen/arch/x86/hvm/Makefile index eea5555..e374aac 100644 --- a/xen/arch/x86/hvm/Makefile +++ b/xen/arch/x86/hvm/Makefile @@ -22,4 +22,4 @@ obj-y += vlapic.o obj-y += vmsi.o obj-y += vpic.o obj-y += vpt.o -obj-y += vpmu.o \ No newline at end of file +obj-y += vpmu.o diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 34da2f5..b12e3b6 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -57,6 +57,7 @@ #include #include #include +#include #include #include #include @@ -1433,8 +1434,7 @@ int hvm_hap_nested_page_fault(paddr_t gpa, */ if ( access_w ) { - paging_mark_dirty(v->domain, mfn_x(mfn)); - p2m_change_type(v->domain, gfn, p2m_ram_logdirty, p2m_ram_rw); + paging_mark_dirty_hap(v->domain, gfn, mfn_x(mfn)); } rc = 1; goto out_put_gfn; diff --git a/xen/arch/x86/mm/Makefile b/xen/arch/x86/mm/Makefile index 73dcdf4..becd0c9 100644 --- a/xen/arch/x86/mm/Makefile +++ b/xen/arch/x86/mm/Makefile @@ -5,6 +5,7 @@ obj-y += paging.o obj-y += p2m.o p2m-pt.o p2m-ept.o p2m-pod.o obj-y += guest_walk_2.o obj-y += guest_walk_3.o +obj-y += dirty_vram.o obj-$(x86_64) += guest_walk_4.o obj-$(x86_64) += mem_event.o obj-$(x86_64) += mem_paging.o diff --git a/xen/arch/x86/mm/dirty_vram.c b/xen/arch/x86/mm/dirty_vram.c new file mode 100644 index 0000000..72bcf4e --- /dev/null +++ b/xen/arch/x86/mm/dirty_vram.c @@ -0,0 +1,951 @@ +/* + * arch/x86/mm/dirty_vram.c: Bookkeep/query dirty VRAM pages + * with support for multiple frame buffers. + * + * Copyright (c) 2012, Citrix Systems, Inc. (Robert Phillips) + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple + * Place - Suite 330, Boston, MA 02111-1307 USA. + */ + + +#include +#include +#include +#include +#include +#include "mm-locks.h" + +#define DEBUG_stop_tracking_all_vram 1 +#define DEBUG_allocating_dirty_vram_range 1 +#define DEBUG_high_water_mark_for_vram_ranges 1 +#define DEBUG_freeing_dirty_vram_range 1 +#define DEBUG_allocate_paddr_links_page 0 +#define DEBUG_update_vram_mapping 0 + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram; + ASSERT( paging_locked_by_me(d) ); + dirty_vram = d->arch.hvm_domain.dirty_vram = xzalloc(dv_dirty_vram_t); + if ( dirty_vram ) + { + INIT_LIST_HEAD(&dirty_vram->range_head); + INIT_LIST_HEAD(&dirty_vram->ext_head); + } + return dirty_vram; +} + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( !dirty_vram ) + dirty_vram = dirty_vram_alloc(d); + return dirty_vram; +} + + +/* Free domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr, *next; + /* Free all the ranges */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); +#if DEBUG_stop_tracking_all_vram + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] stop tracking all vram\n", + range->begin_pfn, range->end_pfn); +#endif + xfree(range->pl_tab); + xfree(range); + } + /* Free all the extension pages */ + list_for_each_safe(curr, next, &dirty_vram->ext_head) + { + struct dv_paddr_link_ext *ext = + container_of( + curr, struct dv_paddr_link_ext, ext_link); + struct page_info *pg = __virt_to_page(ext); + d->arch.paging.free_page(d, pg); + } + + xfree(dirty_vram); + d->arch.hvm_domain.dirty_vram = NULL; + } +} + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn) +{ + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( gfn >= range->begin_pfn && + gfn < range->end_pfn ) + return range; + } + } + return NULL; +} + +/* + * Returns pointer to dirty vram range matching [begin_pfn .. end_pfn ), + * NULL if none. + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( begin_pfn == range->begin_pfn && + end_pfn == range->end_pfn ) + return range; + } + } + return NULL; +} + +/* Allocate specified dirty_vram range */ +static dv_range_t * +_dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range = NULL; + unsigned long end_pfn = begin_pfn + nr; + dv_paddr_link_t *pl_tab = NULL; + int i; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + +#if DEBUG_allocating_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Allocating dirty vram range hap:%d\n", + begin_pfn, end_pfn, + d->arch.hvm_domain.hap_enabled); +#endif + + range = xzalloc(dv_range_t); + if ( range == NULL ) + goto err_out; + + INIT_LIST_HEAD(&range->range_link); + + range->begin_pfn = begin_pfn; + range->end_pfn = end_pfn; + + if ( !hap_enabled(d) ) + { + if ( (pl_tab = xzalloc_array(dv_paddr_link_t, nr)) == NULL ) + goto err_out; + + for ( i = 0; i != nr; i++ ) + { + pl_tab[i].sl1ma = INVALID_PADDR; + } + } + + range->pl_tab = pl_tab; + range->mappings_hwm = 1; + + list_add(&range->range_link, &dirty_vram->range_head); + if ( ++dirty_vram->nr_ranges > dirty_vram->ranges_hwm ) + { + dirty_vram->ranges_hwm = dirty_vram->nr_ranges; +#if DEBUG_high_water_mark_for_vram_ranges + gdprintk(XENLOG_DEBUG, + "High water mark for number of vram ranges is now:%d\n", + dirty_vram->ranges_hwm); +#endif + } + return range; + + err_out: + xfree(pl_tab); + xfree(range); + return NULL; +} + + +/* Frees specified dirty_vram range */ +void dirty_vram_range_free(struct domain *d, + dv_range_t *range) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + int i, nr = range->end_pfn - range->begin_pfn; + +#if DEBUG_freeing_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Freeing dirty vram range\n", + range->begin_pfn, range->end_pfn); +#endif + + if ( range->pl_tab ) + { + for ( i = 0; i != nr; i++ ) + { + dv_paddr_link_t *plx; + plx = range->pl_tab[i].pl_next; + /* Does current FB page have multiple mappings? */ + if ( plx ) /* yes */ + { + /* Find the last element in singly-linked list */ + while ( plx->pl_next != NULL ) + plx = plx->pl_next; + + /* Prepend whole list to the free list */ + plx->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = range->pl_tab[i].pl_next; + } + } + xfree(range->pl_tab); + range->pl_tab = NULL; + } + + /* Remove range from the linked list, free it, and adjust count*/ + list_del(&range->range_link); + xfree(range); + dirty_vram->nr_ranges--; + } +} + +/* + * dirty_vram_range_alloc() + * This function ensures that the new range does not overlap any existing + * ranges -- deleting them if necessary -- and then calls + * _dirty_vram_range_alloc to actually allocate the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + struct list_head *curr, *next; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + + /* + * Ranges cannot overlap so + * free any range that overlaps [ begin_pfn .. end_pfn ) + */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *rng = list_entry(curr, dv_range_t, range_link); + if ( ( ( rng->begin_pfn <= begin_pfn ) && + ( begin_pfn < rng->end_pfn ) + ) || + ( ( begin_pfn <= rng->begin_pfn ) && + ( rng->begin_pfn < end_pfn ) + ) ) + { + /* Different tracking, tear the previous down. */ + dirty_vram_range_free(d, rng); + } + } + + range = _dirty_vram_range_alloc(d, begin_pfn, nr); + if ( !range ) + goto out; + + out: + return range; +} + +/* + * dirty_vram_range_find_or_alloc() + * Find the range for [begin_pfn:begin_pfn+nr). + * If it doesn't exists, create it. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_range_t *range; + ASSERT( paging_locked_by_me(d) ); + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + range = dirty_vram_range_alloc(d, begin_pfn, nr); + + return range; +} + + + +/* Allocate a dv_paddr_link struct */ +static dv_paddr_link_t * +alloc_paddr_link(struct domain *d) +{ + dv_paddr_link_t * pl = NULL; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + + ASSERT( paging_locked_by_me(d) ); + BUILD_BUG_ON(sizeof(dv_paddr_link_ext_t) > PAGE_SIZE); + /* Is the list of free pl's empty? */ + if ( dirty_vram->pl_free == NULL ) /* yes */ + { + /* + * Allocate another page of pl's. + * Link them all together and point the free list head at them + */ + int i; + struct page_info *pg = d->arch.paging.alloc_page(d); + dv_paddr_link_ext_t *ext = __page_to_virt(pg); + if ( ext == NULL ) + goto out; + +#if DEBUG_allocate_paddr_links_page + gdprintk(XENLOG_DEBUG, "Allocated another page of paddr_links\n"); +#endif + list_add(&ext->ext_link, &dirty_vram->ext_head); + + /* initialize and link together the new pl entries */ + for ( i = 0; i != ARRAY_SIZE(ext->entries); i++ ) + { + ext->entries[i].sl1ma = INVALID_PADDR; + ext->entries[i].pl_next = &ext->entries[i+1]; + } + ext->entries[ARRAY_SIZE(ext->entries) - 1].pl_next = NULL; + dirty_vram->pl_free = &ext->entries[0]; + } + pl = dirty_vram->pl_free; + dirty_vram->pl_free = pl->pl_next; + + pl->sl1ma = INVALID_PADDR; + pl->pl_next = NULL; + out: + return pl; +} + + +/* + * Free a paddr_link struct. + * + * The caller has walked the singly-linked list of elements + * that have, as their head, an element in a pl_tab cell. + * The list walks has reached the element to be freed. + * (Each element is a dv_paddr_link_t struct.) + * + * @pl points to the element to be freed. + * @ppl points to its predecessor element's next member. + * + * After linking the precessor to the element's successor, + * we can free @pl by prepending it to the list of free + * elements. + * + * As a boundary case (which happens to be the common case), + * @pl points to a cell in the pl_tab rather than to some + * extension element danging from that cell. + * We recognize this case because @ppl is NULL. + * In that case we promote the first extension element by + * copying it into the pl_tab cell and free it. + */ + +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_paddr_link_t *npl; /* next pl */ + + ASSERT( paging_locked_by_me(d) ); + /* extension mapping? */ + if ( ppl ) /* yes. free it */ + { + ASSERT(pl == (*ppl)); + (*ppl) = npl = pl->pl_next; + } + else /* main table */ + { + /* + * move 2nd mapping to main table. + * and free 2nd mapping + */ + dv_paddr_link_t * spl; + spl = pl->pl_next; + if ( spl == NULL ) + { + pl->sl1ma = INVALID_PADDR; + return pl; + } + pl->sl1ma = spl->sl1ma; + pl->pl_next = spl->pl_next; + npl = pl; /* reprocess main table entry again */ + pl = spl; + } + pl->sl1ma = INVALID_PADDR; + pl->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = pl; + return npl; +} + + +/* + * dirty_vram_range_update() + * + * This is called whenever a level 1 page table entry is modified. + * If the L1PTE is being cleared, the function removes any paddr_links + * that refer to it. + * If the L1PTE is being set to a frame buffer page, a paddr_link is + * created for that page's entry in pl_tab. + * Returns 1 iff entry found and set or cleared. + */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set) +{ + int effective = 0; + dv_range_t *range; + unsigned long i; + dv_paddr_link_t *pl; + dv_paddr_link_t **ppl; + int len = 0; + + ASSERT(paging_locked_by_me(d)); + range = dirty_vram_range_find_gfn(d, gfn); + if ( !range ) + return effective; + + + i = gfn - range->begin_pfn; + pl = &range->pl_tab[ i ]; + ppl = NULL; + + /* + * find matching entry (pl), if any, and its predecessor + * in linked list (ppl) + */ + while ( pl != NULL ) + { + if ( pl->sl1ma == sl1ma || pl->sl1ma == INVALID_PADDR ) + break; + + ppl = &pl->pl_next; + pl = *ppl; + len++; + } + + if ( set ) + { + /* Did we find sl1ma in either the main table or the linked list? */ + if ( pl == NULL ) /* no, so we'll need to alloc a link */ + { + ASSERT(ppl != NULL); + /* + * Have we reached the limit of mappings we're willing + * to bookkeep? + */ + if (len > DV_ADDR_LINK_LIST_LIMIT) /* yes */ + /* + * The side effect of failing to record this mapping + * is that we will not detect any changes to the frame + * buffer made through the mapping so + * areas of a monitor may not get refreshed. + * In practice this should never happen. + */ + goto out; + + /* alloc link and append it to list */ + (*ppl) = pl = alloc_paddr_link(d); + if ( pl == NULL ) + goto out; + } + if ( pl->sl1ma != sl1ma ) + { + ASSERT(pl->sl1ma == INVALID_PADDR); + pl->sl1ma = sl1ma; + range->nr_mappings++; + } + effective = 1; + if ( len > range->mappings_hwm ) + { + range->mappings_hwm = len; +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] set sl1ma:%lx hwm:%d mappings:%d freepages:%d\n", + gfn, sl1ma, + range->mappings_hwm, + range->nr_mappings, + d->arch.paging.shadow.free_pages); +#endif + } + } + else /* clear */ + { + if ( pl && pl->sl1ma == sl1ma ) + { +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] clear sl1ma:%lx mappings:%d\n", + gfn, sl1ma, + range->nr_mappings - 1); +#endif + free_paddr_link(d, ppl, pl); + if ( --range->nr_mappings == 0 ) + { + dirty_vram_range_free(d, range); + } + effective = 1; + } + } + out: + return effective; +} + + +/* + * shadow_scan_dirty_flags() + * This produces a dirty bitmap for the range by examining every + * L1PTE referenced by some dv_paddr_link in the range's pl_tab table. + * It tests and clears each such L1PTE's dirty flag. + */ +static int shadow_scan_dirty_flags(struct domain *d, + dv_range_t *range, + uint8_t *dirty_bitmap) +{ + int flush_tlb = 0; + unsigned long i; + unsigned long nr = range->end_pfn - range->begin_pfn; + + ASSERT( paging_locked_by_me(d) ); + /* Iterate over VRAM to track dirty bits. */ + for ( i = 0; i < nr; i++ ) + { + int dirty = 0, len = 1; + dv_paddr_link_t *pl; + for ( pl = &range->pl_tab[i]; pl; pl = pl->pl_next, len++ ) + { + l1_pgentry_t *sl1e; + paddr_t sl1ma = pl->sl1ma; + if (sl1ma == INVALID_PADDR) /* FB page is unmapped */ + continue; + sl1e = maddr_to_virt(sl1ma); + if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) + { + dirty = 1; + /* Clear dirty so we can detect if page gets re-dirtied. + * Note: this is atomic, so we may clear a + * _PAGE_ACCESSED set by another processor. + */ + l1e_remove_flags(*sl1e, _PAGE_DIRTY); + flush_tlb = 1; + } + } /* for */ + + if ( dirty ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + + } + + return flush_tlb; +} + + +/* + * shadow_track_dirty_vram() + * This is the API called by the guest to determine which pages in the range + * from [begin_pfn:begin_pfn+nr) have been dirtied since the last call. + * It creates the domain's dv_dirty_vram on demand. + * It creates ranges on demand when some [begin_pfn:nr) is first encountered. + * To collect the dirty bitmask it calls shadow_scan_dirty_flags(). + * It copies the dirty bitmask into guest storage. + */ +int shadow_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + int rc = 0; + unsigned long end_pfn = begin_pfn + nr; + int flush_tlb = 0; + dv_range_t *range; + struct p2m_domain *p2m = p2m_get_hostp2m(d); + + /* + * This range test is tricky. + * + * The range [begin_pfn..end_pfn) is an open interval, so end_pfn is a pfn + * beyond the end of the range. + * + * p2m->max_mapped_pfn is a valid PFN so p2m->max_mapped_pfn + 1 is an + * invalid PFN. + * + * If end_pfn is beyond *that* then the range is invalid. + */ + if ( end_pfn < begin_pfn + || begin_pfn > p2m->max_mapped_pfn + || end_pfn > p2m->max_mapped_pfn + 1 ) + return -EINVAL; + + paging_lock(d); + + if (!nr) + { + dirty_vram_free(d); + goto out; + } + + if ( guest_handle_is_null(guest_dirty_bitmap) ) + goto out; + + if ( !dirty_vram_find_or_alloc(d) ) + { + rc = -ENOMEM; + goto out; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + range = dirty_vram_range_alloc(d, begin_pfn, nr); + if ( range ) + sh_find_all_vram_mappings(d->vcpu[0], range); + } + if ( range ) + { + int size = (nr + BITS_PER_LONG - 1) / BITS_PER_LONG; + unsigned long dirty_bitmap[size]; + + memset(dirty_bitmap, 0x00, size * BYTES_PER_LONG); + + flush_tlb |= shadow_scan_dirty_flags(d, range, (uint8_t*)dirty_bitmap); + + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + (uint8_t*)dirty_bitmap, + size * BYTES_PER_LONG) == 0 ) + rc = 0; + } + + if ( flush_tlb ) + flush_tlb_mask(d->domain_dirty_cpumask); + +out: + paging_unlock(d); + return rc; +} + + +/************************************************/ +/* HAP VRAM TRACKING SUPPORT */ +/************************************************/ + +/* + * hap_enable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-only. + */ +static int hap_enable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + /* turn on PG_log_dirty bit in paging mode */ + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + + /* + * dirty_vram != NULL iff we're tracking dirty vram. + * If we start tracking dirty pages for all memory then + * the dirty_vram structure is freed. + */ + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table to be read-only. */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] enable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_rw, p2m_ram_logdirty); + } + + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_disable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-write. + */ +static int hap_disable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table with normal mode */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] disable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_logdirty, p2m_ram_rw); + } + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_clean_vram_tracking_range() + * For all the pages in the range specified by [begin_pfn,nr), + * note in the dirty bitmap any page that has been marked as read-write, + * which signifies that the page has been dirtied, and reset the page + * to ram_logdirty. + */ +void hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) +{ + int i; + unsigned long pfn; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + + ASSERT(p2m_locked_by_me(p2m_get_hostp2m(d))); + ASSERT(paging_locked_by_me(d)); + + if ( !dirty_vram ) + { + gdprintk(XENLOG_DEBUG, + "Should only be called while tracking dirty vram.\n"); + return; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + return; + + /* set l1e entries of P2M table to be read-only. */ + /* + * On first write, it page faults, its entry is changed to read-write, + * its bit in the dirty bitmap is set, and on retry the write succeeds. + */ + for ( i = 0, pfn = range->begin_pfn; pfn < range->end_pfn; i++, pfn++ ) + { + p2m_type_t pt; + pt = p2m_change_type(d, pfn, p2m_ram_rw, p2m_ram_logdirty); + if ( pt == p2m_ram_rw ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + } + flush_tlb_mask(d->domain_dirty_cpumask); +} + +static void hap_vram_tracking_init(struct domain *d) +{ + paging_log_dirty_init(d, hap_enable_vram_tracking, + hap_disable_vram_tracking, + NULL); +} + +/* + * hap_track_dirty_vram() + * Create the domain's dv_dirty_vram struct on demand. + * Create a dirty vram range on demand when some [begin_pfn:begin_pfn+nr] is + * first encountered. + * Collect the guest_dirty bitmask, a bit mask of the dirty vram pages, by + * calling paging_log_dirty_range(). + */ +int hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + long rc = 0; + dv_dirty_vram_t *dirty_vram; + + paging_lock(d); + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( nr ) + { + dv_range_t *range = NULL; + int size = ( nr + BITS_PER_LONG - 1 ) & ~( BITS_PER_LONG - 1 ); + uint8_t dirty_bitmap[size]; + + /* Already tracking dirty vram? */ + if ( paging_mode_log_dirty(d) && dirty_vram ) /* yes */ + { + /* Handle the addition of another range */ + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + rc = -ENOMEM; + if ( !(range = dirty_vram_range_alloc(d, begin_pfn, nr)) ) + goto param_fail; + } + } + /* Just starting to track dirty vram? */ + else if ( !paging_mode_log_dirty(d) && !dirty_vram ) /* yes */ + { + rc = -ENOMEM; + if ( !(dirty_vram = dirty_vram_alloc(d)) ) + goto param_fail; + + if ( !(range = dirty_vram_range_find_or_alloc(d, begin_pfn, nr)) ) + goto param_fail; + + /* Initialize callbacks for vram tracking */ + hap_vram_tracking_init(d); + + /* Enable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_enable(d); + paging_lock(d); + + if ( rc != 0 ) + goto param_fail; + } + else + { + /* Test for invalid combination */ + if ( !paging_mode_log_dirty(d) && dirty_vram ) + rc = -EINVAL; + else /* logging dirty of all memory, not tracking dirty vram */ + rc = -ENODATA; + goto param_fail; + } + + paging_unlock(d); + memset(dirty_bitmap, 0x00, size); + paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + dirty_bitmap, + size) == 0 ) + { + rc = 0; + } + } + else + { + /* + * If zero pages specified while already tracking dirty vram + * then stop tracking + */ + if ( paging_mode_log_dirty(d) && dirty_vram ) + { + /* Disable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_disable(d); + paging_lock(d); + + dirty_vram_free(d); + } + else /* benign no-op */ + { + rc = 0; + } + paging_unlock(d); + } + + return rc; + +param_fail: + dirty_vram_free(d); + paging_unlock(d); + return rc; +} + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/arch/x86/mm/hap/hap.c b/xen/arch/x86/mm/hap/hap.c index fd99cde..09cdba2 100644 --- a/xen/arch/x86/mm/hap/hap.c +++ b/xen/arch/x86/mm/hap/hap.c @@ -41,6 +41,7 @@ #include #include #include +#include #include "private.h" @@ -53,139 +54,6 @@ #define page_to_mfn(_pg) _mfn(__page_to_mfn(_pg)) /************************************************/ -/* HAP VRAM TRACKING SUPPORT */ -/************************************************/ - -static int hap_enable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - /* turn on PG_log_dirty bit in paging mode */ - paging_lock(d); - d->arch.paging.mode |= PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static int hap_disable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - paging_lock(d); - d->arch.paging.mode &= ~PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table with normal mode */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_logdirty, p2m_ram_rw); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static void hap_clean_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return; - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); -} - -static void hap_vram_tracking_init(struct domain *d) -{ - paging_log_dirty_init(d, hap_enable_vram_tracking, - hap_disable_vram_tracking, - hap_clean_vram_tracking); -} - -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - long rc = 0; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( nr ) - { - if ( paging_mode_log_dirty(d) && dirty_vram ) - { - if ( begin_pfn != dirty_vram->begin_pfn || - begin_pfn + nr != dirty_vram->end_pfn ) - { - paging_log_dirty_disable(d); - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - } - else if ( !paging_mode_log_dirty(d) && !dirty_vram ) - { - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto param_fail; - - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - d->arch.hvm_domain.dirty_vram = dirty_vram; - hap_vram_tracking_init(d); - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - else - { - if ( !paging_mode_log_dirty(d) && dirty_vram ) - rc = -EINVAL; - else - rc = -ENODATA; - goto param_fail; - } - /* get the bitmap */ - rc = paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); - } - else - { - if ( paging_mode_log_dirty(d) && dirty_vram ) { - rc = paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } else - rc = 0; - } - - return rc; - -param_fail: - if ( dirty_vram ) - { - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } - return rc; -} - -/************************************************/ /* HAP LOG DIRTY SUPPORT */ /************************************************/ @@ -223,14 +91,12 @@ static void hap_clean_dirty_bitmap(struct domain *d) void hap_logdirty_init(struct domain *d) { - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; if ( paging_mode_log_dirty(d) && dirty_vram ) { paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; + dirty_vram_free(d); } - /* Reinitialize logdirty mechanism */ paging_log_dirty_init(d, hap_enable_log_dirty, hap_disable_log_dirty, diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..5e76609 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include @@ -278,6 +279,46 @@ out: } +/* paging_mark_dirty_hap() + * Make a hap page writeable and mark it as dirty. + * This done atomically under the p2m and paging locks to avoid leaving + * a window where the page might be modified without being counted as dirty. + */ +void paging_mark_dirty_hap(struct domain *d, + unsigned long pfn, + unsigned long guest_mfn) +{ + mfn_t gmfn; + p2m_type_t pt; + struct p2m_domain *p2m = p2m_get_hostp2m(d); + + if ( !paging_mode_log_dirty(d) ) + return; + + gmfn = _mfn(guest_mfn); + + ASSERT( mfn_valid(gmfn) && + page_get_owner(mfn_to_page(gmfn)) == d ); + + p2m_lock(p2m); + pt = p2m_change_type(d, pfn, p2m_ram_logdirty, p2m_ram_rw); + paging_lock(d); + if ( pt == p2m_ram_logdirty ) + { + dv_range_t *range; + PAGING_DEBUG(LOGDIRTY, + "marked mfn %" PRI_mfn " (pfn=%lx), dom %d\n", + mfn_x(gmfn), pfn, d->domain_id); + d->arch.paging.log_dirty.dirty_count++; + range = dirty_vram_range_find_gfn(d, pfn); + if ( range ) + range->dirty_count++; + } + paging_mark_dirty(d, guest_mfn); + paging_unlock(d); + p2m_unlock(p2m); +} + /* Is this guest page dirty? */ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn) { @@ -333,8 +374,11 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) mfn_t *l4, *l3, *l2; unsigned long *l1; int i4, i3, i2; + struct p2m_domain *p2m = p2m_get_hostp2m(d); domain_pause(d); + /* Locking hierarchy requires p2m lock to be taken first */ + p2m_lock(p2m); paging_lock(d); clean = (sc->op == XEN_DOMCTL_SHADOW_OP_CLEAN); @@ -345,6 +389,14 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) d->arch.paging.log_dirty.fault_count, d->arch.paging.log_dirty.dirty_count); + if ( hap_enabled(d) && d->arch.hvm_domain.dirty_vram ) + { + /* If we're cleaning/peeking all guest memory, we should not be tracking + * dirty vram. */ + rv = -EINVAL; + goto out; + } + sc->stats.fault_count = d->arch.paging.log_dirty.fault_count; sc->stats.dirty_count = d->arch.paging.log_dirty.dirty_count; @@ -424,170 +476,64 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) if ( clean ) { - /* We need to further call clean_dirty_bitmap() functions of specific - * paging modes (shadow or hap). Safe because the domain is paused. */ - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + /* Is null if tracking dirty vram */ + if ( d->arch.paging.log_dirty.clean_dirty_bitmap ) + { + /* + * We need to call clean_dirty_bitmap() functions of specific + * paging modes (shadow or hap). + * Safe because the domain is paused. + */ + d->arch.paging.log_dirty.clean_dirty_bitmap(d); + } } domain_unpause(d); return rv; out: paging_unlock(d); + p2m_unlock(p2m); domain_unpause(d); return rv; } -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) { - int rv = 0; - unsigned long pages = 0; - mfn_t *l4, *l3, *l2; - unsigned long *l1; - int b1, b2, b3, b4; - int i2, i3, i4; - - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + struct p2m_domain *p2m = p2m_get_hostp2m(d); + dv_range_t *range; + unsigned int range_dirty_count = 0; + + p2m_lock(p2m); paging_lock(d); - PAGING_DEBUG(LOGDIRTY, "log-dirty-range: dom %u faults=%u dirty=%u\n", - d->domain_id, - d->arch.paging.log_dirty.fault_count, - d->arch.paging.log_dirty.dirty_count); - - if ( unlikely(d->arch.paging.log_dirty.failed_allocs) ) { - printk("%s: %d failed page allocs while logging dirty pages\n", - __FUNCTION__, d->arch.paging.log_dirty.failed_allocs); - rv = -ENOMEM; - goto out; - } - - if ( !d->arch.paging.log_dirty.fault_count && - !d->arch.paging.log_dirty.dirty_count ) { - unsigned int size = BITS_TO_LONGS(nr); - - if ( clear_guest(dirty_bitmap, size * BYTES_PER_LONG) != 0 ) - rv = -EFAULT; - goto out; - } - d->arch.paging.log_dirty.fault_count = 0; - d->arch.paging.log_dirty.dirty_count = 0; - - b1 = L1_LOGDIRTY_IDX(begin_pfn); - b2 = L2_LOGDIRTY_IDX(begin_pfn); - b3 = L3_LOGDIRTY_IDX(begin_pfn); - b4 = L4_LOGDIRTY_IDX(begin_pfn); - l4 = paging_map_log_dirty_bitmap(d); - - for ( i4 = b4; - (pages < nr) && (i4 < LOGDIRTY_NODE_ENTRIES); - i4++ ) + /* Only called when tracking dirty vram in HAP mode */ + ASSERT(hap_enabled(d) && d->arch.hvm_domain.dirty_vram); + + range = dirty_vram_range_find_gfn(d, begin_pfn); + if ( range ) { - l3 = (l4 && mfn_valid(l4[i4])) ? map_domain_page(mfn_x(l4[i4])) : NULL; - for ( i3 = b3; - (pages < nr) && (i3 < LOGDIRTY_NODE_ENTRIES); - i3++ ) - { - l2 = ((l3 && mfn_valid(l3[i3])) ? - map_domain_page(mfn_x(l3[i3])) : NULL); - for ( i2 = b2; - (pages < nr) && (i2 < LOGDIRTY_NODE_ENTRIES); - i2++ ) - { - unsigned int bytes = PAGE_SIZE; - uint8_t *s; - l1 = ((l2 && mfn_valid(l2[i2])) ? - map_domain_page(mfn_x(l2[i2])) : NULL); - - s = ((uint8_t*)l1) + (b1 >> 3); - bytes -= b1 >> 3; - - if ( likely(((nr - pages + 7) >> 3) < bytes) ) - bytes = (unsigned int)((nr - pages + 7) >> 3); - - if ( !l1 ) - { - if ( clear_guest_offset(dirty_bitmap, pages >> 3, - bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - /* begin_pfn is not 32K aligned, hence we have to bit - * shift the bitmap */ - else if ( b1 & 0x7 ) - { - int i, j; - uint32_t *l = (uint32_t*) s; - int bits = b1 & 0x7; - int bitmask = (1 << bits) - 1; - int size = (bytes + BYTES_PER_LONG - 1) / BYTES_PER_LONG; - unsigned long bitmap[size]; - static unsigned long printed = 0; - - if ( printed != begin_pfn ) - { - dprintk(XENLOG_DEBUG, "%s: begin_pfn %lx is not 32K aligned!\n", - __FUNCTION__, begin_pfn); - printed = begin_pfn; - } - - for ( i = 0; i < size - 1; i++, l++ ) { - bitmap[i] = ((*l) >> bits) | - (((*((uint8_t*)(l + 1))) & bitmask) << (sizeof(*l) * 8 - bits)); - } - s = (uint8_t*) l; - size = BYTES_PER_LONG - ((b1 >> 3) & 0x3); - bitmap[i] = 0; - for ( j = 0; j < size; j++, s++ ) - bitmap[i] |= (*s) << (j * 8); - bitmap[i] = (bitmap[i] >> bits) | (bitmask << (size * 8 - bits)); - if ( copy_to_guest_offset(dirty_bitmap, (pages >> 3), - (uint8_t*) bitmap, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - else - { - if ( copy_to_guest_offset(dirty_bitmap, pages >> 3, - s, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - - pages += bytes << 3; - if ( l1 ) - { - clear_page(l1); - unmap_domain_page(l1); - } - b1 = b1 & 0x7; - } - b2 = 0; - if ( l2 ) - unmap_domain_page(l2); - } - b3 = 0; - if ( l3 ) - unmap_domain_page(l3); + range_dirty_count = range->dirty_count; + range->dirty_count = 0; } - if ( l4 ) - unmap_domain_page(l4); - - paging_unlock(d); + + if ( !range_dirty_count) + goto out; - return rv; + PAGING_DEBUG(LOGDIRTY, + "log-dirty-range: dom %u [%05lx:%05lx] range_dirty=%u\n", + d->domain_id, + begin_pfn, + range->end_pfn, + range_dirty_count); + hap_clean_vram_tracking_range(d, begin_pfn, nr, dirty_bitmap); out: paging_unlock(d); - return rv; + p2m_unlock(p2m); + return; } /* Note that this function takes three function pointers. Callers must supply diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c index ce79131..4e40f43 100644 --- a/xen/arch/x86/mm/shadow/common.c +++ b/xen/arch/x86/mm/shadow/common.c @@ -36,6 +36,7 @@ #include #include #include +#include #include #include "private.h" @@ -3121,12 +3122,7 @@ void shadow_teardown(struct domain *d) * calls now that we've torn down the bitmap */ d->arch.paging.mode &= ~PG_log_dirty; - if (d->arch.hvm_domain.dirty_vram) { - xfree(d->arch.hvm_domain.dirty_vram->sl1ma); - xfree(d->arch.hvm_domain.dirty_vram->dirty_bitmap); - xfree(d->arch.hvm_domain.dirty_vram); - d->arch.hvm_domain.dirty_vram = NULL; - } + dirty_vram_free(d); paging_unlock(d); @@ -3463,179 +3459,212 @@ void shadow_clean_dirty_bitmap(struct domain *d) /**************************************************************************/ -/* VRAM dirty tracking support */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - int rc; - unsigned long end_pfn = begin_pfn + nr; - unsigned long dirty_size = (nr + 7) / 8; - int flush_tlb = 0; - unsigned long i; - p2m_type_t t; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - struct p2m_domain *p2m = p2m_get_hostp2m(d); - - if (end_pfn < begin_pfn - || begin_pfn > p2m->max_mapped_pfn - || end_pfn >= p2m->max_mapped_pfn) - return -EINVAL; - - /* We perform p2m lookups, so lock the p2m upfront to avoid deadlock */ - p2m_lock(p2m_get_hostp2m(d)); - paging_lock(d); +/* Support functions for shadow-based dirty VRAM code */ - if ( dirty_vram && (!nr || - ( begin_pfn != dirty_vram->begin_pfn - || end_pfn != dirty_vram->end_pfn )) ) - { - /* Different tracking, tear the previous down. */ - gdprintk(XENLOG_INFO, "stopping tracking VRAM %lx - %lx\n", dirty_vram->begin_pfn, dirty_vram->end_pfn); - xfree(dirty_vram->sl1ma); - xfree(dirty_vram->dirty_bitmap); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } +#define DEBUG_unshadow_sl1ma 0 +#define DEBUG_unshadow_sl1ma_detail 0 +#define DEBUG_count_initial_mappings 1 - if ( !nr ) +/* smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn) +{ + static unsigned int l1_shadow_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; + struct domain *d = v->domain; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr, *next; + + ASSERT(paging_locked_by_me(d)); + /* Ignore all but level 1 shadows */ + + if ( (l1_shadow_mask & (1 << shadow_type)) == 0 ) { - rc = 0; goto out; } - /* This should happen seldomly (Video mode change), - * no need to be careful. */ + dirty_vram = d->arch.hvm_domain.dirty_vram; if ( !dirty_vram ) { - /* Throw away all the shadows rather than walking through them - * up to nr times getting rid of mappings of each pfn */ - shadow_blow_tables(d); - - gdprintk(XENLOG_INFO, "tracking VRAM %lx - %lx\n", begin_pfn, end_pfn); - - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto out; - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = end_pfn; - d->arch.hvm_domain.dirty_vram = dirty_vram; - - if ( (dirty_vram->sl1ma = xmalloc_array(paddr_t, nr)) == NULL ) - goto out_dirty_vram; - memset(dirty_vram->sl1ma, ~0, sizeof(paddr_t) * nr); - - if ( (dirty_vram->dirty_bitmap = xzalloc_array(uint8_t, dirty_size)) == NULL ) - goto out_sl1ma; - - dirty_vram->last_dirty = NOW(); - - /* Tell the caller that this time we could not track dirty bits. */ - rc = -ENODATA; - } - else if (dirty_vram->last_dirty == -1) - { - /* still completely clean, just copy our empty bitmap */ - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) - rc = 0; + goto out; } - else + + list_for_each_safe(curr, next, &dirty_vram->range_head) { - /* Iterate over VRAM to track dirty bits. */ - for ( i = 0; i < nr; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, begin_pfn + i, &t); - struct page_info *page; - int dirty = 0; - paddr_t sl1ma = dirty_vram->sl1ma[i]; - - if (mfn_x(mfn) == INVALID_MFN) - { - dirty = 1; - } - else + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + unsigned long i; + int max_mappings = 1, mappings = 0; + int unshadowed = 0; + for ( i = 0; i != range->end_pfn - range->begin_pfn; i++ ) + { + dv_paddr_link_t *pl = &range->pl_tab[ i ]; + dv_paddr_link_t **ppl = NULL; + mappings = 0; + + while ( pl != NULL ) { - page = mfn_to_page(mfn); - switch (page->u.inuse.type_info & PGT_count_mask) - { - case 0: - /* No guest reference, nothing to track. */ - break; - case 1: - /* One guest reference. */ - if ( sl1ma == INVALID_PADDR ) - { - /* We don't know which sl1e points to this, too bad. */ - dirty = 1; - /* TODO: Heuristics for finding the single mapping of - * this gmfn */ - flush_tlb |= sh_remove_all_mappings(d->vcpu[0], mfn); - } - else - { - /* Hopefully the most common case: only one mapping, - * whose dirty bit we can use. */ - l1_pgentry_t *sl1e = maddr_to_virt(sl1ma); - - if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) - { - dirty = 1; - /* Note: this is atomic, so we may clear a - * _PAGE_ACCESSED set by another processor. */ - l1e_remove_flags(*sl1e, _PAGE_DIRTY); - flush_tlb = 1; - } - } - break; - default: - /* More than one guest reference, - * we don't afford tracking that. */ - dirty = 1; + paddr_t sl1ma = pl->sl1ma; + unsigned long sl1mn; + + if ( sl1ma == INVALID_PADDR ) break; + + sl1mn = sl1ma >> PAGE_SHIFT; + if ( sl1mn == mfn_x(smfn) ) { +#if DEBUG_unshadow_sl1ma_detail + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%lx] unshadow sl1ma:%lx\n", + mfn_x(smfn), + range->begin_pfn + i, + sl1ma); +#endif + unshadowed++; + pl = free_paddr_link(d, ppl, pl); + --range->nr_mappings; + } + else + { + ppl = &pl->pl_next; + pl = *ppl; + mappings++; } } - - if ( dirty ) + } + if ( mappings > max_mappings ) + max_mappings = mappings; + + if ( unshadowed ) { +#if DEBUG_unshadow_sl1ma + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%05lx:%05lx] unshadowed:%d mappings:0x%x max_mappings:%d\n", + mfn_x(smfn), + range->begin_pfn, range->end_pfn, + unshadowed, range->nr_mappings, max_mappings); +#endif + if ( range->nr_mappings == 0 ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + dirty_vram_range_free(d, range); } } + } + out: + return; +} + + +typedef int (*hash_pfn_callback_t)(struct vcpu *v, + mfn_t smfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); + +static int hash_pfn_foreach(struct vcpu *v, + unsigned int callback_mask, + hash_pfn_callback_t callbacks[], + unsigned long begin_pfn, + unsigned long end_pfn) +/* Walk the hash table looking at the types of the entries and + * calling the appropriate callback function for each entry. + * The mask determines which shadow types we call back for, and the array + * of callbacks tells us which function to call. + * Any callback may return non-zero to let us skip the rest of the scan. + * + * WARNING: Callbacks MUST NOT add or remove hash entries unless they + * then return non-zero to terminate the scan. */ +{ + int i, done = 0, removed = 0; + struct domain *d = v->domain; + struct page_info *x; + + /* Say we're here, to stop hash-lookups reordering the chains */ + ASSERT(paging_locked_by_me(d)); + ASSERT(d->arch.paging.shadow.hash_walking == 0); + d->arch.paging.shadow.hash_walking = 1; - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) { - memset(dirty_vram->dirty_bitmap, 0, dirty_size); - if (dirty_vram->last_dirty + SECONDS(2) < NOW()) + for ( i = 0; i < SHADOW_HASH_BUCKETS; i++ ) + { + /* WARNING: This is not safe against changes to the hash table. + * The callback *must* return non-zero if it has inserted or + * deleted anything from the hash (lookups are OK, though). */ + for ( x = d->arch.paging.shadow.hash_table[i]; x; x = next_shadow(x) ) + { + if ( callback_mask & (1 << x->u.sh.type) ) { - /* was clean for more than two seconds, try to disable guest - * write access */ - for ( i = begin_pfn; i < end_pfn; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, i, &t); - if (mfn_x(mfn) != INVALID_MFN) - flush_tlb |= sh_remove_write_access(d->vcpu[0], mfn, 1, 0); - } - dirty_vram->last_dirty = -1; + ASSERT(x->u.sh.type <= 15); + ASSERT(callbacks[x->u.sh.type] != NULL); + done = callbacks[x->u.sh.type](v, page_to_mfn(x), + begin_pfn, end_pfn, + &removed); + if ( done ) break; } - rc = 0; } + if ( done ) break; } - if ( flush_tlb ) - flush_tlb_mask(d->domain_dirty_cpumask); - goto out; + d->arch.paging.shadow.hash_walking = 0; + return removed; +} -out_sl1ma: - xfree(dirty_vram->sl1ma); -out_dirty_vram: - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range) +{ + /* Dispatch table for getting per-type functions */ + static hash_pfn_callback_t callbacks[SH_type_unused] = { + NULL, /* none */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* l1_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* fl1_32 */ + NULL, /* l2_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* l1_pae */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* fl1_pae */ + NULL, /* l2_pae */ + NULL, /* l2h_pae */ +#if CONFIG_PAGING_LEVELS >= 4 + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* l1_64 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* fl1_64 */ +#else + NULL, /* l1_64 */ + NULL, /* fl1_64 */ +#endif + NULL, /* l2_64 */ + NULL, /* l2h_64 */ + NULL, /* l3_64 */ + NULL, /* l4_64 */ + NULL, /* p2m */ + NULL /* unused */ + }; -out: - paging_unlock(d); - p2m_unlock(p2m_get_hostp2m(d)); - return rc; + static unsigned int callback_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; + + perfc_incr(shadow_mappings); + + hash_pfn_foreach(v, callback_mask, callbacks, + range->begin_pfn, + range->end_pfn); + +#if DEBUG_count_initial_mappings + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] count of initial mappings:%d\n", + range->begin_pfn, range->end_pfn, + range->nr_mappings); +#endif } + /**************************************************************************/ /* Shadow-control XEN_DOMCTL dispatcher */ diff --git a/xen/arch/x86/mm/shadow/multi.c b/xen/arch/x86/mm/shadow/multi.c index b0e6d72..9c00574 100644 --- a/xen/arch/x86/mm/shadow/multi.c +++ b/xen/arch/x86/mm/shadow/multi.c @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -149,6 +150,10 @@ delete_fl1_shadow_status(struct vcpu *v, gfn_t gfn, mfn_t smfn) SHADOW_PRINTK("gfn=%"SH_PRI_gfn", type=%08x, smfn=%05lx\n", gfn_x(gfn), SH_type_fl1_shadow, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); + shadow_hash_delete(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); } @@ -160,6 +165,10 @@ delete_shadow_status(struct vcpu *v, mfn_t gmfn, u32 shadow_type, mfn_t smfn) v->domain->domain_id, v->vcpu_id, mfn_x(gmfn), shadow_type, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, mfn_x(gmfn), shadow_type, smfn); + shadow_hash_delete(v, mfn_x(gmfn), shadow_type, smfn); /* 32-on-64 PV guests don't own their l4 pages; see set_shadow_status */ if ( !is_pv_32on64_vcpu(v) || shadow_type != SH_type_l4_64_shadow ) @@ -516,7 +525,6 @@ _sh_propagate(struct vcpu *v, guest_l1e_t guest_entry = { guest_intpte }; shadow_l1e_t *sp = shadow_entry_ptr; struct domain *d = v->domain; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; gfn_t target_gfn = guest_l1e_get_gfn(guest_entry); u32 pass_thru_flags; u32 gflags, sflags; @@ -663,17 +671,6 @@ _sh_propagate(struct vcpu *v, } } - if ( unlikely((level == 1) && dirty_vram - && dirty_vram->last_dirty == -1 - && gfn_x(target_gfn) >= dirty_vram->begin_pfn - && gfn_x(target_gfn) < dirty_vram->end_pfn) ) - { - if ( ft & FETCH_TYPE_WRITE ) - dirty_vram->last_dirty = NOW(); - else - sflags &= ~_PAGE_RW; - } - /* Read-only memory */ if ( p2m_is_readonly(p2mt) || (p2mt == p2m_mmio_direct && @@ -1072,101 +1069,60 @@ static int shadow_set_l2e(struct vcpu *v, return flags; } -static inline void shadow_vram_get_l1e(shadow_l1e_t new_sl1e, +/* shadow_vram_fix_l1e() + * + * Tests L1PTEs as they are modified, looking for when they start to + * (or cease to) point to frame buffer pages. If the old and new gfns differ, + * calls dirty_vram_range_update() to updates the dirty_vram structures. + */ +static inline void shadow_vram_fix_l1e(shadow_l1e_t old_sl1e, + shadow_l1e_t new_sl1e, shadow_l1e_t *sl1e, mfn_t sl1mfn, struct domain *d) { - mfn_t mfn = shadow_l1e_get_mfn(new_sl1e); - int flags = shadow_l1e_get_flags(new_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + mfn_t new_mfn, old_mfn; + unsigned long new_gfn = INVALID_M2P_ENTRY, old_gfn = INVALID_M2P_ENTRY; + paddr_t sl1ma; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ + if ( !dirty_vram ) return; - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); + sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) | ((unsigned long)sl1e & ~PAGE_MASK); - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + old_mfn = shadow_l1e_get_mfn(old_sl1e); + + if ( !sh_l1e_is_magic(old_sl1e) && + (l1e_get_flags(old_sl1e) & _PAGE_PRESENT) && + mfn_valid(old_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - /* Initial guest reference, record it */ - dirty_vram->sl1ma[i] = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + old_gfn = mfn_to_gfn(d, old_mfn); } -} - -static inline void shadow_vram_put_l1e(shadow_l1e_t old_sl1e, - shadow_l1e_t *sl1e, - mfn_t sl1mfn, - struct domain *d) -{ - mfn_t mfn = shadow_l1e_get_mfn(old_sl1e); - int flags = shadow_l1e_get_flags(old_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ - return; - - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); - - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + + new_mfn = shadow_l1e_get_mfn(new_sl1e); + if ( !sh_l1e_is_magic(new_sl1e) && + (l1e_get_flags(new_sl1e) & _PAGE_PRESENT) && + mfn_valid(new_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - int dirty = 0; - paddr_t sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + new_gfn = mfn_to_gfn(d, new_mfn); + } - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - { - /* Last reference */ - if ( dirty_vram->sl1ma[i] == INVALID_PADDR ) { - /* We didn't know it was that one, let's say it is dirty */ - dirty = 1; - } - else - { - ASSERT(dirty_vram->sl1ma[i] == sl1ma); - dirty_vram->sl1ma[i] = INVALID_PADDR; - if ( flags & _PAGE_DIRTY ) - dirty = 1; - } - } - else + if ( old_gfn == new_gfn ) return; + + if ( VALID_M2P(old_gfn) ) + if ( dirty_vram_range_update(d, old_gfn, sl1ma, 0/*clear*/) ) { - /* We had more than one reference, just consider the page dirty. */ - dirty = 1; - /* Check that it's not the one we recorded. */ - if ( dirty_vram->sl1ma[i] == sl1ma ) - { - /* Too bad, we remembered the wrong one... */ - dirty_vram->sl1ma[i] = INVALID_PADDR; - } - else - { - /* Ok, our recorded sl1e is still pointing to this page, let's - * just hope it will remain. */ - } + SHADOW_PRINTK("gfn %lx (mfn %lx) cleared vram pte\n", + old_gfn, mfn_x(old_mfn)); } - if ( dirty ) + + if ( VALID_M2P(new_gfn) ) + if ( dirty_vram_range_update(d, new_gfn, sl1ma, 1/*set*/) ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + SHADOW_PRINTK("gfn %lx (mfn %lx) set vram pte\n", + new_gfn, mfn_x(new_mfn)); } - } } static int shadow_set_l1e(struct vcpu *v, @@ -1211,12 +1167,13 @@ static int shadow_set_l1e(struct vcpu *v, shadow_l1e_remove_flags(new_sl1e, _PAGE_RW); /* fall through */ case 0: - shadow_vram_get_l1e(new_sl1e, sl1e, sl1mfn, d); break; } } } + shadow_vram_fix_l1e(old_sl1e, new_sl1e, sl1e, sl1mfn, d); + /* Write the new entry */ shadow_write_entries(sl1e, &new_sl1e, 1, sl1mfn); flags |= SHADOW_SET_CHANGED; @@ -1231,7 +1188,6 @@ static int shadow_set_l1e(struct vcpu *v, * trigger a flush later. */ if ( shadow_mode_refcounts(d) ) { - shadow_vram_put_l1e(old_sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(old_sl1e, d); TRACE_SHADOW_PATH_FLAG(TRCE_SFLAG_SHADOW_L1_PUT_REF); } @@ -2018,7 +1974,6 @@ void sh_destroy_l1_shadow(struct vcpu *v, mfn_t smfn) SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, 0, { if ( (shadow_l1e_get_flags(*sl1e) & _PAGE_PRESENT) && !sh_l1e_is_magic(*sl1e) ) { - shadow_vram_put_l1e(*sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(*sl1e, d); } }); @@ -4336,6 +4291,37 @@ int sh_rm_mappings_from_l1(struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn) return done; } + +int sh_find_vram_mappings_in_l1(struct vcpu *v, + mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed) +/* Find all VRAM mappings in this shadow l1 table */ +{ + struct domain *d = v->domain; + shadow_l1e_t *sl1e; + int done = 0; + + /* only returns _PAGE_PRESENT entries */ + SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, done, + { + unsigned long gfn; + mfn_t gmfn = shadow_l1e_get_mfn(*sl1e); + if ( !mfn_valid(gmfn) ) + continue; + gfn = mfn_to_gfn(d, gmfn); + if ( VALID_M2P(gfn) && (begin_pfn <= gfn) && (gfn < end_pfn) ) + { + paddr_t sl1ma = + pfn_to_paddr(mfn_x(sl1mfn)) | + ( (unsigned long)sl1e & ~PAGE_MASK ); + dirty_vram_range_update(v->domain, gfn, sl1ma, 1/*set*/); + } + }); + return 0; +} + /**************************************************************************/ /* Functions to excise all pointers to shadows from higher-level shadows. */ diff --git a/xen/arch/x86/mm/shadow/multi.h b/xen/arch/x86/mm/shadow/multi.h index 835121e..436a4ac 100644 --- a/xen/arch/x86/mm/shadow/multi.h +++ b/xen/arch/x86/mm/shadow/multi.h @@ -66,7 +66,12 @@ SHADOW_INTERNAL_NAME(sh_rm_write_access_from_l1, GUEST_LEVELS) extern int SHADOW_INTERNAL_NAME(sh_rm_mappings_from_l1, GUEST_LEVELS) (struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn); - +extern int +SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, GUEST_LEVELS) + (struct vcpu *v, mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); extern void SHADOW_INTERNAL_NAME(sh_clear_shadow_entry, GUEST_LEVELS) (struct vcpu *v, void *ep, mfn_t smfn); diff --git a/xen/arch/x86/mm/shadow/types.h b/xen/arch/x86/mm/shadow/types.h index 43ce1db..5b0f9f7 100644 --- a/xen/arch/x86/mm/shadow/types.h +++ b/xen/arch/x86/mm/shadow/types.h @@ -229,6 +229,7 @@ static inline shadow_l4e_t shadow_l4e_from_mfn(mfn_t mfn, u32 flags) #define sh_update_cr3 INTERNAL_NAME(sh_update_cr3) #define sh_rm_write_access_from_l1 INTERNAL_NAME(sh_rm_write_access_from_l1) #define sh_rm_mappings_from_l1 INTERNAL_NAME(sh_rm_mappings_from_l1) +#define sh_find_vram_mappings_in_l1 INTERNAL_NAME(sh_find_vram_mappings_in_l1) #define sh_remove_l1_shadow INTERNAL_NAME(sh_remove_l1_shadow) #define sh_remove_l2_shadow INTERNAL_NAME(sh_remove_l2_shadow) #define sh_remove_l3_shadow INTERNAL_NAME(sh_remove_l3_shadow) diff --git a/xen/include/asm-x86/dirty_vram.h b/xen/include/asm-x86/dirty_vram.h new file mode 100644 index 0000000..7f3ccf9 --- /dev/null +++ b/xen/include/asm-x86/dirty_vram.h @@ -0,0 +1,196 @@ +/****************************************************************************** + * include/asm-x86/dirty_vram.h + * + * Interface for tracking dirty VRAM pages + * + * Copyright (c) 2012 Citrix Systems, Inc. (Robert Phillips) + * Parts of this code are Copyright (c) 2006 by XenSource Inc. + * Parts of this code are Copyright (c) 2006 by Michael A Fetterman + * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _DIRTY_VRAM_H +#define _DIRTY_VRAM_H + +/* + * In shadow mode we need to bookkeep all the L1 page table entries that + * map a frame buffer page. Struct dv_paddr_link does this + * by recording the address of a L1 page table entry for some frame buffer page. + * Also has a link to additional pl entries if the frame buffer page + * has multiple mappings. + * In practice very few pages have multiple mappings. + * But to rule out some pathological situation, we limit the number of + * mappings we're willing to bookkeep. + */ + +#define DV_ADDR_LINK_LIST_LIMIT 20 + +typedef struct dv_paddr_link { + paddr_t sl1ma; + struct dv_paddr_link *pl_next; +} dv_paddr_link_t; + +/* + * This defines an extension page of pl entries for FB pages with multiple + * mappings. All such pages (of a domain) are linked together. + */ +typedef struct dv_paddr_link_ext { + struct list_head ext_link; + dv_paddr_link_t entries[ ( PAGE_SIZE - sizeof( struct list_head ) ) / + sizeof( dv_paddr_link_t ) ]; +} dv_paddr_link_ext_t; + +/* + * This defines a single frame buffer range. It bookkeeps all the level 1 PTEs + * that map guest pages within that range. + * All such ranges (of a domain) are linked together. + */ +typedef struct dv_range { + struct list_head range_link; /* the several ranges form a linked list */ + unsigned long begin_pfn; + unsigned long end_pfn; + dv_paddr_link_t *pl_tab; /* table has 1 pl entry per pfn in range */ + int nr_mappings; /* total number of mappings in this range */ + int mappings_hwm; /* high water mark of max mapping count */ + unsigned int dirty_count; +} dv_range_t; + +/* + * This contains all the data structures required by a domain to + * bookkeep the dirty pages within its frame buffers. + */ +typedef struct dv_dirty_vram { + struct list_head range_head; /* head of the linked list of ranges */ + struct list_head ext_head; /* head of list of extension pages */ + dv_paddr_link_t *pl_free; /* free list of pl's within extension pages */ + int nr_ranges; /* bookkeeps number of ranges */ + int ranges_hwm; /* high water mark of max number of ranges */ +} dv_dirty_vram_t; + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d); + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d); + +/* Frees domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d); + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * NULL if none + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Allocate dirty vram range containing [ begin_pfn .. begin_pfn+nr ), + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * creating a range if none already exists and + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +void dirty_vram_range_free(struct domain *d, + dv_range_t *range); + +/* Bookkeep PTE address of a frame buffer page */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set); + +/* + * smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. + */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn); + + +/* + * Scan all the L1 tables looking for VRAM mappings. + * Record them in the domain's dv_dirty_vram structure + */ +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range); + +/* + * Free a paddr_link struct, given address of its + * predecessor in singly-linked list + */ +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl); + + +/* Enable VRAM dirty tracking. */ +int +shadow_track_dirty_vram(struct domain *d, + unsigned long first_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +int +hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +void +hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); + +#endif /* _DIRTY_VRAM_H */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/include/asm-x86/hap.h b/xen/include/asm-x86/hap.h index 916a35b..3e3a1f5 100644 --- a/xen/include/asm-x86/hap.h +++ b/xen/include/asm-x86/hap.h @@ -57,10 +57,6 @@ void hap_final_teardown(struct domain *d); void hap_teardown(struct domain *d); void hap_vcpu_init(struct vcpu *v); void hap_logdirty_init(struct domain *d); -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); extern const struct paging_mode *hap_paging_get_mode(struct vcpu *); diff --git a/xen/include/asm-x86/hvm/domain.h b/xen/include/asm-x86/hvm/domain.h index 27b3de5..6146542 100644 --- a/xen/include/asm-x86/hvm/domain.h +++ b/xen/include/asm-x86/hvm/domain.h @@ -74,7 +74,7 @@ struct hvm_domain { struct list_head pinned_cacheattr_ranges; /* VRAM dirty support. */ - struct sh_dirty_vram *dirty_vram; + struct dv_dirty_vram * dirty_vram; /* If one of vcpus of this domain is in no_fill_mode or * mtrr/pat between vcpus is not the same, set is_in_uc_mode diff --git a/xen/include/asm-x86/paging.h b/xen/include/asm-x86/paging.h index 9a40f2c..f804104 100644 --- a/xen/include/asm-x86/paging.h +++ b/xen/include/asm-x86/paging.h @@ -137,10 +137,10 @@ struct paging_mode { void paging_free_log_dirty_bitmap(struct domain *d); /* get the dirty bitmap for a specific range of pfns */ -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); /* enable log dirty */ int paging_log_dirty_enable(struct domain *d); @@ -161,6 +161,11 @@ void paging_mark_dirty(struct domain *d, unsigned long guest_mfn); * This is called from inside paging code, with the paging lock held. */ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn); +/* mark a page as dirty, from hap page fault handler */ +void paging_mark_dirty_hap(struct domain *d, + unsigned long pfn, + unsigned long guest_mfn); + /* * Log-dirty radix tree indexing: * All tree nodes are PAGE_SIZE bytes, mapped on-demand. @@ -183,15 +188,6 @@ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn); #define L4_LOGDIRTY_IDX(pfn) 0 #endif -/* VRAM dirty tracking support */ -struct sh_dirty_vram { - unsigned long begin_pfn; - unsigned long end_pfn; - paddr_t *sl1ma; - uint8_t *dirty_bitmap; - s_time_t last_dirty; -}; - /***************************************************************************** * Entry points into the paging-assistance code */ diff --git a/xen/include/asm-x86/shadow.h b/xen/include/asm-x86/shadow.h index 2eb6efc..940d7fd 100644 --- a/xen/include/asm-x86/shadow.h +++ b/xen/include/asm-x86/shadow.h @@ -62,12 +62,6 @@ void shadow_vcpu_init(struct vcpu *v); /* Enable an arbitrary shadow mode. Call once at domain creation. */ int shadow_enable(struct domain *d, u32 mode); -/* Enable VRAM dirty bit tracking. */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long first_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); - /* Handler for shadow control ops: operations from user-space to enable * and disable ephemeral shadow modes (test mode and log-dirty mode) and * manipulate the log-dirty bitmap. */ -- 1.7.9.5 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-users-bounces@lists.xen.org Thu Nov 08 12:45:59 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 08 Nov 2012 12:45:59 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TWRTE-0006N1-3l; Thu, 08 Nov 2012 12:44:32 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TWMwX-0001mS-0a for xen-users@lists.xen.org; Thu, 08 Nov 2012 07:54:30 +0000 Received: from [85.158.143.99:57008] by server-3.bemta-4.messagelabs.com id 0A/D7-06841-4356B905; Thu, 08 Nov 2012 07:54:28 +0000 X-Env-Sender: jerry.gao@ericsson.com X-Msg-Ref: server-5.tower-216.messagelabs.com!1352361265!28756917!1 X-Originating-IP: [193.180.251.37] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogMTkzLjE4MC4yNTEuMzcgPT4gMTY1NzEy\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 13012 invoked from network); 8 Nov 2012 07:54:26 -0000 Received: from mailgw2.ericsson.se (HELO mailgw2.ericsson.se) (193.180.251.37) by server-5.tower-216.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 8 Nov 2012 07:54:26 -0000 X-AuditID: c1b4fb25-b7f926d00000661f-f8-509b652f800b Received: from esgscmw0008.eapac.ericsson.se (Unknown_Domain [153.88.253.124]) by mailgw2.ericsson.se (Symantec Mail Security) with SMTP id A5.9F.26143.F256B905; Thu, 8 Nov 2012 08:54:24 +0100 (CET) Received: from ESGSCCMS0002.eapac.ericsson.se ([169.254.1.205]) by esgscmw0008.eapac.ericsson.se ([146.11.115.33]) with mapi; Thu, 8 Nov 2012 15:54:06 +0800 From: Jerry Gao To: Alexandre Kouznetsov Date: Thu, 8 Nov 2012 15:53:55 +0800 Thread-Topic: RE: [Xen-users] How to change VM from para-virtualization to full-virtualization? Thread-Index: Ac29eD+X08Swlv9SS2SDPTz2j5SVWAADb+eA Message-ID: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: yes X-MS-TNEF-Correlator: acceptlanguage: en-US Content-Type: multipart/mixed; boundary="_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_" MIME-Version: 1.0 X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFvrDKsWRmVeSWpSXmKPExsUyM+Jvja5B6uwAgym3TCyW3XrJbrHq6gFW ByaPo7t/M3n03dvMHsAUxWWTkpqTWZZapG+XwJVxa1UrS8GNVyoVi16vZ21g/HNVuYuRk0NC wERi8t+PzBC2mMSFe+vZuhi5OIQETjJKtP5Zyw7hLGCU2L9wK1gVm4CGxL4bX1hAbBEBTYlr x+4ygdjMArESq+4dZAOxWQRUJP7cmg5Uw8EhLJAgMWlRJER5osSBXfuZIGwjiWsLJ4GN4RUI l3j4fz9YKyPQEd9PrYEaKS5x68l8JojjRCQeXjzNBmGLSrx8/I8Vol5U4k77ekaI+kyJwxsf Qc0UlDg58wnLBEbhWUhGzUJSNgtJ2SygS5kF8iV29ftAlOhJ3Jg6hQ3C1pZYtvA1M4StKzHj 3yEWTHEniZ5TP9khbDOJo2eeAcW5gOz1jBIr3n6EShhJzHrZA9WsKDGl+yE7TPO+U29ZYJq/ /ljGBNfccOUbO8RxRhJ7W0Kw6e2c/IIVpvfbnn2McL3P37cxwix+9GQrEzbNF++uglu88dZp KBuo+f9eE5je14sXMGLTu+zpb7jeXx/mssEtftnWwgLT3HNrBtsCRoNVjOy5iZk56eVGmxiB Kfjglt+qOxjvnBM5xCjNwaIkzmu9dY+/kEB6YklqdmpqQWpRfFFpTmrxIUYmDk6pBsaeP9VO Lw64Tctpf2Qb7fw830+R2WKx1UmJtzOcT7B+YUzctT+Me1bEAVfzh97bDq78f22f8qqr6+9f WFJQy3W/TXtB6erU6Z+40lfv2lhplVJcXmr8/G3WgmUa6eKb9sUt4ldmr22P3GBbevdhsdex hoLKuT+Cuy2mvbreov3jTHHchEVXTcKVWIozEg21mIuKEwHgo90SjwMAAA== X-Mailman-Approved-At: Thu, 08 Nov 2012 12:44:31 +0000 Cc: "xen-users@lists.xen.org" , Jing Chen Subject: [Xen-users] FW: RE: How to change VM from para-virtualization to full-virtualization? 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 --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: multipart/alternative; boundary="_000_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_" --_000_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Forwarding to Alexandre.... Regards, Jerry ECN: (887) 17175 Phone: +86 10 6439 4175 This Communication is Confidential. We only send and receive email on the b= asis of the terms set out at www.ericsson.com/email_disclaimer ______________________________________________ From: Jing Chen Sent: Thursday, November 08, 2012 2:14 PM To: xen-users-bounces@lists.xen.org Cc: Jerry Gao Subject: RE: [Xen-users] How to change VM from para-virtualization = to full-virtualization? Hello Alexandre. This is Jing and I work with Jerry for this issue. I saw your email an= d do some test following your instruction. As our case, I met lots of issue= s since there are lots of track as you said. I list them here and need your= help to check. Seems it is a little bit longger. But your help is grateful. I create a PV for DomU and install the SUSE linux 11 SP2. my configurations= are as below. 1) partition. 2) /etc/fstab file 3) /boot/grub/menu.lst in PV, grub has been installed. The option 0 is the one work normally i= n PV. I add the second option for HVM. 4) the conf file in Dom0 is as below. To chagne PV to HVM. I do the following modification. 5) change conf file in Dom0 6) change /etc/fstab as below 7) change /etc/mtab as below Then. I start up the HVM using xm create command. And the error is as below= . I try to change root parameter in menu.lst, such as "root=3D/dev/hda2". B= ut it still can not startup saying can not mount /dev/hda2 to root. Please give your advise what can I do. Thanks very much. Jing Chen CBC/XIB/K No.5 Lize East Street, Chaoyang District 100102, Beijing, China Phone +86 10 84767586 Mobile +86 13801223973 jing.chen@ericsson.com www.ericsson.com This Communication is Confidential. We only send and receive email on the b= asis of the terms set out at www.ericsson.com/email_disclaimer -----Original Message----- From: Jerry Gao Sent: Monday, November 05, 2012 4:28 PM To: Jing Chen Subject: FW: [Xen-users] How to change VM from para-virtualization to full-= virtualization? Regards, Jerry ECN: (887) 17175 Phone: +86 10 6439 4175 This Communication is Confidential. We only send and receive email on the b= asis of the terms set out at www.ericsson.com/email_disclaimer -----Original Message----- From: xen-users-bounces@lists.xen.org [mailto:xen-users-bounces@lists.xen.o= rg] On Behalf Of Alexandre Kouznetsov Sent: Friday, November 02, 2012 1:22 AM To: xen-users@lists.xen.org Subject: Re: [Xen-users] How to change VM from para-virtualization to full-= virtualization? Hello. El 31/10/12 18:54, Jerry Gao escribi=F3: > "3. Re-write your .cfg file within Dom0 to make it start the DomU as HVM.= " > Which .cfg file are you referring to? Is there an example of it? Thanks. HVM and PV guests needs different options in the config file. They share so= me basic variables, such as "name", "memory", etc, but, for example, "root"= option has nothing to do in a config for HVM, and "builder" is not suitabl= e for PV mode. The PV configs I use are generated by Debian's xen-tools, and my HVM regula= r config has been copied from one place to another multiple times with mino= r changes, since I build it years ago. As command reference, i have used this link back then: http://wiki.prgmr.com/mediawiki/index.php/Appendix_B:_The_Structure_of_the_= Xen_Config_File A quick look around suggests this link as a good start to create own's HVM = config: http://www.virtuatopia.com/index.php/Configuring_and_Installating_a_Xen_Har= dware_Virtual_Machine_%28HVM%29_domainU_Guest (it is one of many, pick whatever you like) > About the 4th step: > "4. Install the boot loader into you DomU storage's MBR, watch the kernel= command line for root=3D parameter. I would recommend doing this booting t= he HVM DomU with a LiveCD, Knoppix or systemrescuecd should do fine." > Are you talking about to change the menu.list file of grub? Would you ple= ase help to give me more details about this step. A common PV DomU have no grub or menu.lst at all. The bootloader's function= (obtain and execute kernel, unpack initrd in DomU's memory) is handled by = the hypervisor and controlled from scripts within Dom0. In some cases it's = desirable to allow DomU to control what kernel it shall boot, so a special = tool "pygrub" is used: it is executed in Dom0, finds the DomU's disk image = and extracts from it a minimalistic menu.lst file. That menu.lst mentions a kernel and initrd images that are usually stored i= n the same disk image, so pygrub extracts them as well. If that is your cas= e, you already have a menu.lst but need to make it usable by a normal Grub. Recently I had to do something similar, I has do change the paths to the ke= rnel and initrd files, and add parameters "root=3D/dev/hda2 ro" to the kern= el line. Note that menu.lst config is used by legacy Grub, while Grub2 (most commonly encountered this days) uses a completely different for= mat and config filename. In case of HVM, the boot loading process is more "normal", compared to a ba= re metal computer. Treat it as any other grub-enabled system. In case of De= bian[-based] you might just use update-grub script and it will generate a n= ice config for you. I mention Grub because it is the most common. Strictly speaking, lilo or sy= slinux would work well here as well, but you will find less reference about= them, specially related to Xen. > About the 5th step: > "5. Modify your /etc/fstab to reflect the change of the block devices nam= ing (from /dev/xvdaN to /dev/hda or whatever)." > My previous VM is created on a virtual hard disk like /dev/drbd00. Then d= o I still need to change the storage device name? Definitely yes. Even if you pass /dev/drbd00 as is to HVM DomU, it will see it as /dev/hda = or whatever you specified in your config file. Boot your DomU with a LiveCD= and verify the correct device names. Also take in account that the common baremetal installations does not put a= FS directly on a block device. The block device are partitioned first. For= sake of simplicity, Xen PV use to put FS directly on the device: for example, /dev/xvda1 is not the first partition of xvda, instead= it's whole device named xvda1, which shares nothing with xvda2. If you use this approach within a HVM, you might confuse it, because it wil= l expect to access FS on partitioned devices. Another trick is, that legacy Grub can't read ext4 filesystem. Even better,= it can't read ext3 filesystem if formatted with inode size of 256 bytes, which is the default for a modern mkfs.ext3. In my case, i had t= o use "mkfs.ext -I 128" in order to make it work with legacy Grub. Grub2 does not have this problem. > -----Original Message----- > From: xen-users-bounces@lists.xen.org > [mailto:xen-users-bounces@lists.xen.org] On Behalf Of Alexandre > Kouznetsov > Sent: Wednesday, October 31, 2012 1:30 PM > To: xen-users@lists.xen.org > Subject: Re: [Xen-users] How to change VM from para-virtualization to ful= l-virtualization? > > Hi. > > El 31/10/12 10:27, Jerry Gao escribi=F3: >> I've created a domU in para-virtualization. But now I need to change >> it to full-virtualization. >> Is it possible to upgrade/change the VM virtualization mode without >> impact the OS+App in the VM? And How? > > Yes, it is possible. Can be a bit tricky because there are many details t= o take care of, even if each of this details is trivial by itself. > From DomU's point of view, the change will affect the kernel used in th= e DomU, the boot loader and the storage devices naming. > > This is a small overview of what need to be done: > 1. Make sure your DomU system has a regular kernel and a boot loader inst= alled. > 2. Make sure the storage is presented to the DomU as a partitioned block = device(s). > 3. Re-write your .cfg file within Dom0 to make it start the DomU as HVM. > 4. Install the boot loader into you DomU storage's MBR, watch the kernel = command line for root=3D parameter. I would recommend doing this booting th= e HVM DomU with a LiveCD, Knoppix or systemrescuecd should do fine. > 5. Modify your /etc/fstab to reflect the change of the block devices nami= ng (from /dev/xvdaN to /dev/hda or whatever). > > Word of advice, in many cases it's preferable to re-install the guest sys= tem, then move data and configs. This way you get a more predictable result= . > > -- > Alexandre Kouznetsov > > > _______________________________________________ > Xen-users mailing list > Xen-users@lists.xen.org > http://lists.xen.org/xen-users > > _______________________________________________ > Xen-users mailing list > Xen-users@lists.xen.org > http://lists.xen.org/xen-users > -- Alexandre Kouznetsov _______________________________________________ Xen-users mailing list Xen-users@lists.xen.org http://lists.xen.org/xen-users --_000_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: text/html; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable
Forwarding to Alexandre....
 
Regards,
Jerry
ECN: (887) 17175
Phone: +86 10 6439 4175

This Communication is Confidential. We o= nly send and receive email on the basis of the terms set out at www.ericsson.com/email_disclaimer =
 
 
_________________________= _____________________
From:    Jing Chen 
Sent:   Thursday, November 08, 2= 012 2:14 PM
To:     xen-users-boun= ces@lists.xen.org
Cc:     Jerry Gao
Subject:      &n= bsp; RE: [Xen-users] How to change VM from para-virtualization &nb= sp;     to      full-virtualiz= ation?
 
Hello Alexandre.
     This is Jing and I work with Jerry for this i= ssue. I saw your email and do some test following your instruction. As our = case, I met lots of issues since there are lots of track as you said. I lis= t them here and need your help to check.
Seems it is a little bit longger. But your help is grateful.
 
I create a PV for DomU and install the SUSE linux 11 SP2. my configura= tions are as below.
 
1) partition.
 
2) /etc/fstab file
    
 
3) /boot/grub/menu.lst
   
    in PV, grub has been installed. The option 0 is the= one work normally in PV. I add the second option for HVM.
4) the conf file in Dom0 is as below.
 
To chagne PV to HVM. I do the following modification.
5) change conf file in Dom0
 
 
6) change /etc/fstab as below
 
7) change /etc/mtab as below
 
 
Then. I start up the HVM using xm create command. And the error is as = below.
 
 
  I try to change root parameter in menu.lst, such as "root= =3D/dev/hda2". But it still can not startup saying can not mount /dev/= hda2 to root.
 
Please give your advise what can I do.
 
Thanks very much.
 
Jing Chen
 
CBC/XIB/K
No.5 Lize East Street, Chaoyang District
100102, Beijing, China
Phone +86 10 84767586
Mobile +86 13801223973
jing.chen@ericsson.com
 
 
 
 
This Communication is Confidential. We only send and receive email on = the basis of the terms set out at www.ericsson.com/email_disclaimer 
 
-----Original Message-----
From: Jerry Gao
Sent: Monday, November 05, 2012 4:28 PM
To: Jing Chen
Subject: FW: [Xen-users] How to change VM from para-virtualization to = full-virtualization?
 
 
 
 
Regards,
Jerry
ECN: (887) 17175
Phone: +86 10 6439 4175
 
This Communication is Confidential. We only send and receive email on = the basis of the terms set out at www.ericsson.com/email_disclaimer 
 
-----Original Message-----
From: xen-users-bounces@lists.xen.org [mailto:xen-users-bounces@lis= ts.xen.org] On Behalf Of Alexandre Kouznetsov
Sent: Friday, November 02, 2012 1:22 AM
To: xen-users@lists.xen.org
Subject: Re: [Xen-users] How to change VM from para-virtualization to = full-virtualization?
 
Hello.
 
El 31/10/12 18:54, Jerry Gao escribi=F3:
> "3. Re-write your .cfg file within Dom0 to make it start the= DomU as HVM."
> Which .cfg file are you referring to? Is there an example of it? = Thanks.
HVM and PV guests needs different options in the config file. They sha= re some basic variables, such as "name", "memory", etc,= but, for example, "root" option has nothing to do in a config fo= r HVM, and "builder" is not suitable for PV mode.
 
The PV configs I use are generated by Debian's xen-tools, and my HVM r= egular config has been copied from one place to another multiple times with= minor changes, since I build it years ago.
As command reference, i have used this link back then:
 
A quick look around suggests this link as a good start to create own's= HVM config:
(it is one of many, pick whatever you like)
 
> About the 4th step:
> "4. Install the boot loader into you DomU storage's MBR, wat= ch the kernel command line for root=3D parameter. I would recommend doing t= his booting the HVM DomU with a LiveCD, Knoppix or systemrescuecd should do= fine."
> Are you talking about to change the menu.list file of grub? Would= you please help to give me more details about this step.
A common PV DomU have no grub or menu.lst at all. The bootloader's fun= ction (obtain and execute kernel, unpack initrd in DomU's memory) is handle= d by the hypervisor and controlled from scripts within Dom0. In some cases = it's desirable to allow DomU to control what kernel it shall boot, so a special tool "pygrub" is = used: it is executed in Dom0, finds the DomU's disk image and extracts from= it a minimalistic menu.lst file.
That menu.lst mentions a kernel and initrd images that are usually sto= red in the same disk image, so pygrub extracts them as well. If that is you= r case, you already have a menu.lst but need to make it usable by a normal = Grub.
 
Recently I had to do something similar, I has do change the paths to t= he kernel and initrd files, and add parameters "root=3D/dev/hda2 ro&qu= ot; to the kernel line. Note that menu.lst config is used by legacy Grub, w= hile
Grub2 (most commonly encountered this days) uses a completely differen= t format and config filename.
 
In case of HVM, the boot loading process is more "normal", c= ompared to a bare metal computer. Treat it as any other grub-enabled system= . In case of Debian[-based] you might just use update-grub script and it wi= ll generate a nice config for you.
I mention Grub because it is the most common. Strictly speaking, lilo = or syslinux would work well here as well, but you will find less reference = about them, specially related to Xen.
 
> About the 5th step:
> "5. Modify your /etc/fstab to reflect the change of the bloc= k devices naming (from /dev/xvdaN to /dev/hda or whatever)."
> My previous VM is created on a virtual hard disk like /dev/drbd00= . Then do I still need to change the storage device name?
Definitely yes.
Even if you pass /dev/drbd00 as is to HVM DomU, it will see it as /dev= /hda or whatever you specified in your config file. Boot your DomU with a L= iveCD and verify the correct device names.
 
Also take in account that the common baremetal installations does not = put a FS directly on a block device. The block device are partitioned first= . For sake of simplicity, Xen PV use to put FS directly on the
device: for example, /dev/xvda1 is not the first partition of xvda, in= stead it's whole device named xvda1, which shares nothing with xvda2.
If you use this approach within a HVM, you might confuse it, because i= t will expect to access FS on partitioned devices.
 
Another trick is, that legacy Grub can't read ext4 filesystem. Even be= tter, it can't read ext3 filesystem if formatted with inode size of
256 bytes, which is the default for a modern mkfs.ext3. In my case, i = had to use "mkfs.ext -I 128" in order to make it work with legacy= Grub.
Grub2 does not have this problem.
 
 
> -----Original Message-----
> From: xen-users-bounces@lists.xen.org
> Kouznetsov
> Sent: Wednesday, October 31, 2012 1:30 PM
> To: xen-users@lists.xen.org
> Subject: Re: [Xen-users] How to change VM from para-virtualizatio= n to full-virtualization?
>
> Hi.
>
> El 31/10/12 10:27, Jerry Gao escribi=F3:
>> I've created a domU in para-virtualization. But now I need to= change
>> it to full-virtualization.
>> Is it possible to upgrade/change the VM virtualization mode w= ithout
>> impact the OS+App in the VM? And How?
>
> Yes, it is possible. Can be a bit tricky because there are many d= etails to take care of, even if each of this details is trivial by itself.<= /div>
>   From DomU's point of view, the change will affect the= kernel used in the DomU, the boot loader and the storage devices naming.
>
> This is a small overview of what need to be done:
> 1. Make sure your DomU system has a regular kernel and a boot loa= der installed.
> 2. Make sure the storage is presented to the DomU as a partitione= d block device(s).
> 3. Re-write your .cfg file within Dom0 to make it start the DomU = as HVM.
> 4. Install the boot loader into you DomU storage's MBR, watch the= kernel command line for root=3D parameter. I would recommend doing this bo= oting the HVM DomU with a LiveCD, Knoppix or systemrescuecd should do fine.=
> 5. Modify your /etc/fstab to reflect the change of the block devi= ces naming (from /dev/xvdaN to /dev/hda or whatever).
>
> Word of advice, in many cases it's preferable to re-install the g= uest system, then move data and configs. This way you get a more predictabl= e result.
>
> --
> Alexandre Kouznetsov
>
>
> _______________________________________________
> Xen-users mailing list
> Xen-users@lists.xen.org
>
> _______________________________________________
> Xen-users mailing list
> Xen-users@lists.xen.org
>
 
 
--
Alexandre Kouznetsov
 
 
_______________________________________________
Xen-users mailing list
Xen-users@lists.xen.org
 
 --_000_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_-- --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 1.jpg" Content-Description: Picture (Enhanced Metafile) 1.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 1.jpg"; creation-date="Thu, 08 Nov 2012 06:14:03 GMT"; modification-date="Thu, 08 Nov 2012 06:14:03 GMT" Content-ID: Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAHYAzwDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCnLOA+ ZXYsVLZIJ4GO/wCI/wAg0Ws/2m1W4SGcRkKctCwwGXcM8dMd+nvVO5ia7kj8qZ42ADhZICUK55B6 cnjIznHYdaiSyvo0SA6jktAIdxtSSwUcMzA/e4Xk/wB0e+fabqqXuq6PMhCnbXc16dUUSukKLI/m OFAZ8Y3H1xUtbmDCiiigQUUmfY/lRn2P5UroYuKMe/6UmfY/lS/gaNA1Dp3P5CjcPf8A75pd3sfy oz/st+VZXj0a/r5idxNw9/8AvmjcPf8A75pc/wCy35UZ9m/Ki67oWo4DI6/oKNp9f0FAYejflS7h 6N/3zR7nf8TTUAp/vH8hTwP9o/kKZu9m/wC+acJB6P8A98GmuT+mJ3FKn+8fyFJtP98/kP8ACjzB 6P8A98GjzB6P/wB8Gn7nf8RXYu0/3z+Q/wAKWm+YPR/++DTqqPL0Fr1CiiiqAcOlFA6UVIgp9Mp9 A4hRRRSKClFJSigBaWkpacRBRRRVCCiiigBRTh1popw61LF1FZguNzqgJALsGKr7naCcfQH8uala 2njuYIJ0Fs1xOtvC9wrhJXbpsZVbcMc7h8o7kZGYWXdjO/bkFgjhGI9AxVsfkfw6h95NdX1vHBLO QkXFv5aon2dcY2L8uSvQ/MScqDnqDnLmvodEOS3vA8csdvezyIY0ssefvDZVi20KMA5Yn6DAJJAq 7Jo2oReIIdDKQm8lG4MrOYgNpbl9nHTGMdWX1FR6tqM2r2f2do1ty7+bcujBvtMnlhAxG0bQME7Q ep68c2jr9y3iUa01uh2zeclt5vCfuTEwD7c4b5WPHVFA7k5N1rXsValtcoNaXMelJqcsXlWrp5i+ YrhivY8KVGe2WBPbNLeWlzpzotyiBmkWJ0QktCzRtIu/gAZVT0J54qyNavf7G/sx2Lr9j+x7/M+T Z6+XjG/HG7PTtSXurXeo2NrZzNJ5dvIJAXlDk4RlAHyggfMTyWPA5pxdW+qBqlbQpkOLI3hGYBM0 BwG3K4UNgjGOQcggnPI4PFFzHcWtzPbNbyyTW5gEqQQyuUMpARchMbuRkZ9gSeKtadftp80pe3W7 t5fLZrd5Nih0bcrg7Sc9QR0I+nK2GqXNk15JIou5bueC4kkd9h3RymXGAp4OdvsB3pt1E3YUVSsr jDp98NPvb5rO4S3sgrTeZDIrkHrtXb820ct0wPWqvmP9omgNreiWBo0lU2ko2GQgID8vGcjFWLm7 kuodajkj41ZleQiTmIrIXXBKncBnbjAyB1FWr3V5L3+0WazjSXUHtnmcXDYzCwIwAAQGAx14znJ6 UKVVdP60/wCCCjSe7Kf2e6FxbwSWd1A9zIsURubeSJSzEADcy++fXAPHFI8NwLz7GixG5+1C1wXI Tf5nlk5xnGcnp+VXZdYeSK2iSwhhjt9RTUEVJAOVH+rOEGc/3zk/XFU3uZRqP29IUMn20XflGQgf 63zCu7H1GcfgKqMqrvddBNU1azHW9rcXaag0SKBp8TSz+ZuXIXOdnHzHjPYYKnPIqGYTQWwuXs73 7Odu2VbSRkbcQFwQuDkkAY9amtL27tbaWB3E6yWEllzhMb8DzDgckKqJjuEHOckvTUZ7a1jitbWB ZUWJTMzAlikqSBz8uf4cbN23ntilzVk9h2pPqR/ZroS28UlndQNcypDEbm3kiUuxwASy/j64B4qO +gvbBxHNY3CubkWyloJAjsX25Q7MsOpGByKnmvPN1NL9bZo5BeLeOhuS6uwbdgDaNo9/mI6dOKdL qt0wBFujsNZGq/PORj/pl908AdG/QUnKrfYFGl3KtktxqFpHdWtjfyQSZ2utpJjg4PO3sQahNyoi aUQ3LRAFvMS2kZSAMkghcHA5OOnetLTNVn0tdEVIVkXSvPwPNKifzc9eDt25/wBrPtUCXc8Xh1NH VVPlxyxxXK7A6CQEMPmjbjk9CpxxmjmqX2Fy0+5B3oo70VsZBRRRQAUHpRQelADKQ9aWkPWqRCEo oopjCiiigApKWkqZDEPWkpT1pKQwooooAQ9KbTj0ptMmQUhpaQ00JCUUUUxhRRRQAUUUUAIabTjT aTKQU1qdTWqRPYSiiimSFIelLSHpQAlFFFUMKKKYiJsXzPthfHzFLmMAn2BhOB+JpNjSH05I5JA5 RU2ptDNJMkYBbOBlmGT8p/Ko0BC4JJ5ONxBOM8ZIABOPYU7IME0LrLiRo3V4ZlRlKhx/Ejgghz2p O9tBxSvqNlLQywxuqkTK7I8csci/IU3DKscH51oPbpyQOSAPxJ4A9zxTHj/eWoRZNkImLPNMru7S eVj7qIAAIvTvSyKWUAMy/MCSpAJGeQCQQMjjOD1qlexTSvoOuIbu2neOewu4gnDSSRFUzkDCseHP U/LngE9BSJNLGMJI6jrhWIqTUr25v3gQhY7eBQsCI3MCgr8gyDvDKvJPOQCCBkGCp1t7xErX0PXR 8PPDA6WE3/gbP/8AF0v/AAr3wx/z4Tf+Bs//AMXXT15nofhi+0X4eT3cWn6SuovoDIsNvovl3ZlM QISRmdvMO4YZSg3N27V4Ptan8z+89n2cOyOl/wCFe+Gf+fGb/wADZ/8A4uj/AIV74Z/58Zv/AANn /wDi6x9bl13TX1mbS4rqM3Gtxl5IoWZjD9hiG5cQynHmIFyI25yOOSOw0Rrt9A05r+Uy3jWsRnkM Zj3ybRuO0qpXJzwVUj0HSj2s/wCZj9nDsjH/AOFe+Gf+fGb/AMDZ/wD4uj/hX3hn/nxm/wDA2f8A +Lrp64e2gurgDwc9veR2kE8vnzm3YQvZZ3RQpIV2nKukZAOcRv04NHtZ/wAzF7OHZGj/AMK+8M/8 +M3/AIGz/wDxdH/CvvDP/PjN/wCBs/8A8XVWyTXLm8trTz7vTrZ31R5ZILWNeVu1EH3kKglGZgcf Ny3PWsDSdX1rRvBQslh1prmPw7CLFW0mRmjvFEysh2xYG0iEDfwVAPOSxPaz/mYezh/Kjqf+FfeG f+fGb/wNn/8Ai6P+FfeGf+fGb/wNn/8Ai6yNc1jXofGCW2nLrH2Zby1jlBtN1u0bNH5hRhbtkBS2 SZVwc+gBtz2N2fhn4ltBazm5m/tbyoRGd775pym1ep3BgRjrkY60e1n/ADP7w9nD+VF3/hX/AIa/ 58Z//A2f/wCLo/4V/wCGv+fKf/wNn/8Ai657xNYazf8AhXVfDQGoyJZ2txILlYsm8QR5giBC/MxZ gG2/MfK5+/zZtdY16Xx5BbIusf2Yb2eKZbq0xGEWOQhlYW6gJvCbWMxJBHBySD2s/wCZ/eHs4fyo 2P8AhX/hr/nyn/8AA2f/AOLo/wCFfeGv+fKf/wADZ/8A4uufafUtV8Ga1BdXOu3GqzaJOJbCbSzF CsxjwVicQLvO4kAB2yCTg9RsW41qLWYbe4kur2CHWyiXFxbR5FubAtnKooA81iu4AH+HPJFHtKnd h7Kn/KvuLH/CvvDX/PlP/wCBs/8A8XR/wr/w1/z5T/8AgdP/APF1j203i230e1umu9Qu7y58PT3L wT2sSiG9VYSiALGpBJeQbWJzt9jWz4JudWutLupNXnnlk+1ERefA8brHsTg7oId3zbjkJjnGTg0e 1n/M/vD2cOyE/wCFf+Gv+fKf/wADp/8A4uj/AIV/4b/58p//AAOn/wDi66auR1O4v9B1bUVsba6u X1nZJbPHbPKkFyFSE+YVBCJtEb5YgfJJz0FHtZ/zMPZQ7Isf8K/8N/8APlP/AOB0/wD8XR/wr/w3 /wA+U/8A4HT/APxdZWo2+r6BbarDo0c8jR2dkY7n7OGklke5mNw24RsWba24gK20tkLzg59jqXjJ 4jG1xeyfbpfs0ErWLZsyGjzI++3hzlWlIJTb+7UZyTk9rU/mf3h7OH8qOl/4V/4b/wCfKf8A8Dp/ /i6P+Ff+Gv8Anyn/APA6f/4upPCd7q+pwT3eqxT22BFClvLD5eHVB5rjIBILswHbCAjqc9FR7Wf8 zD2cOyOZ/wCFf+Gv+fKf/wADp/8A4uj/AIV/4a/58p//AAOn/wDi6yfE+n2qaxNfPHJfTMVK291o k15HHhQMRSxRlos9erDJPGc0y61XxG3ifRo7NL+006a1s5JIZreSRVLSP5qSOIJDvCBR80kYBwTn Jo9rP+Z/eHs4dkbP/CAeG/8AnzuP/A6f/wCLo/4QDw3/AM+dx/4HT/8AxdVrI+If7R0+6nvb94Z9 WvIJ7R7aIRR26/aPKbIjDgfJDhi2DuHXcKq+BW1O51e/vdUbUpLiXTbFJmvbL7OqTBrgyRR/u0DK pYc/N94fMaPaT7sPZw7I0/8AhAPDf/Pncf8AgdP/APF0v/CAeG/+fO4/8Dp//i6ybrTtRGs69eTG 7k0ZtRRp7CGE7rmP7LApdSAWkAZcFF+9tYfMflLtW1DXo/Gem2umNdQaQ8Nqdv2N/K5lcSA4t32n YF4aSILwTnmj2k+7D2cOyNT/AIQDw3/z53H/AIHT/wDxdH/CAeG/+fO4/wDA6f8A+LqrY6tqlxrU fh15rkXljO015dm2AWW26xYbbs3PkKdvP7uTGMCuvo9pPux+zh2RzX/CAeG/+fO4/wDA6f8A+Lo/ 4QHw5/z53H/gdP8A/F10tFHtJ92Hs4dkc1/wgPhz/nzuP/A6f/4uj/hAfDn/AD6XH/gdP/8AF10t FHtZ92Hs4dkc1/wgPhz/AJ9Lj/wOn/8Ai6P+EB8Of8+lx/4HT/8AxddLRR7Wfdh7OHZHNf8ACA+H P+fS4/8AA6f/AOLo/wCEB8Of8+lx/wCB0/8A8XXS0Ue1n3Yezh2RzX/CA+HP+fS4/wDA6f8A+Lo/ 4QLw5/z6XP8A4HT/APxddLRR7Wfdh7OHZHN/8IF4d/59Ln/wOn/+Lo/4QLw7/wA+lz/4HT//ABdd JRR7Sfdh7OHZHN/8IF4d/wCfS5/8Dp//AIuj/hAvDv8Az6XP/gdP/wDF10lFHtJ92Hs4dkc3/wAI F4d/59Ln/wADp/8A4uj/AIQLw7/z63P/AIHT/wDxddJRR7Sfdh7OHZHN/wDCB+Hf+fW5/wDA+f8A +Lo/4QPw7/z63P8A4Hz/APxddJRR7Sfdh7OHZHN/8IH4d/59bn/wPn/+Lo/4QPw7/wA+tz/4Hz// ABddJRR7Wfdh7OHZHN/8IH4d/wCfW5/8D5//AIuj/hA/Dv8Az63P/gfP/wDF10lFHtZ92Hs4dkc3 /wAIH4d/59bn/wAD5/8A4uj/AIQPw7/z63P/AIHz/wDxddJRR7Wfdh7OHZHN/wDCB+Hf+fW5/wDA +f8A+Lo/4QPw7/z63P8A4Hz/APxddJRR7Wfdh7OHZHN/8IH4d/59bn/wPn/+Lo/4QPw7/wA+tz/4 Hz//ABddJRR7Sfdh7OHZHN/8IF4d/wCfW5/8Dp//AIuj/hAvDv8Az6XP/gdP/wDF10lFHtJ92Hs4 dkc3/wAIF4d/59Ln/wADp/8A4uj/AIQLw7/z6XP/AIHT/wDxddJRR7Sfdh7OHZHN/wDCBeHf+fS5 /wDA6f8A+Lo/4QLw7/z6XP8A4HT/APxddJRR7Sfdh7OHZHNf8IF4c/59Lj/wOn/+Lo/4QHw5/wA+ lx/4HT//ABddLRR7Wfdh7OHZHNf8ID4c/wCfS4/8Dp//AIuj/hAfDn/Ppcf+B0//AMXXS0Ue1n3Y ezh2RzX/AAgPhz/n0uP/AAOn/wDi6P8AhAfDn/Ppcf8AgdP/APF10tFHtZ92Hs4dkc1/wgPhz/n0 uP8AwOn/APi6P+EB8Of8+dx/4HT/APxddLRR7Wfdh7OHZHNf8IB4c/587j/wOn/+Lo/4QDw3/wA+ dx/4HT//ABddLRR7Sfdh7OHZHNf8IB4b/wCfO4/8Dp//AIuj/hAPDf8Az53H/gdP/wDF10tFHtJ9 2Hs4dkc1/wAIB4b/AOfO4/8AA6f/AOLpP+EA8N/8+dx/4HT/APxddNRR7Wfdh7OHZHM/8IB4b/58 7j/wOn/+Lo/4V/4b/wCfKf8A8Dp//i66aij2s+7D2cOyOZ/4V/4a/wCfKf8A8Dp//i6P+Ff+Gv8A nyn/APA6f/4uumoo9rPuw9nDsjmf+Ff+Gv8Anyn/APA6f/4uj/hX/hr/AJ8p/wDwOn/+LrpqKPaz 7sPZw7I5n/hX/hr/AJ8p/wDwOn/+Lo/4V/4a/wCfKf8A8Dp//i66aij2s+7D2cOyOZ/4V/4a/wCf Kf8A8Dp//i6P+Ff+Gv8Anyn/APA2f/4uumoo9rPuw9nDsjmf+Ff+Gv8Anyn/APA2f/4uk/4V94a/ 58p//A2f/wCLrp6KPaT7sPZw7I5j/hX3hn/nxn/8DZ//AIuj/hX3hn/nxn/8DZ//AIuunoo9rPuw 9nDsjmP+FfeGf+fGf/wNn/8Ai6P+FfeGf+fGf/wNn/8Ai66eij2s+7D2cOyOY/4V74Z/58Zv/A2f /wCLo/4V74Z/58Zv/A2f/wCLrp6KPaz7sPZw7I5j/hXvhn/nxm/8DZ//AIuj/hXvhn/nxm/8DZ// AIuunoo9rPuw9nDsjmP+Fe+Gf+fGb/wNn/8Ai6P+Fe+Gf+fGb/wNn/8Ai66eij2s+7D2cOyOY/4V 74Z/58Zv/A2f/wCLo/4V74Z/58Zv/A2f/wCLrp6KPaz/AJmHs4dkcx/wrzwx/wA+E3/gbP8A/F0n /CvPDH/PhN/4Gz//ABddRRR7Wfdh7OHZENxd29oFNxPHECcAuwGfzqt/bWl99Qtv+/oqu4ZtdnUk kCCMqMZxkvn88D8qzJ/Ffh+1cJcajFE+0MFkjKkggEHkehFYXbbsXZLc2/7b0v8A6CNr/wB/RR/b el/9BC1/7+isD/hN/Cw66vbfr/hWhputaXrHOn3CXC84ZFbbxjPOMZ+Zfzo98ehuJIkqB42DI3IZ TkGnVQ0vhr5F4RLj5VHQZjQn9ST+NJq+t2Gh2wnv5WUMcKkcbSOx9lUE/jjitIJysktSZNLc0MjP 0oGCK49vHLPIwh0uQxqxBMkm1hg44AUjt61r6H4ksNailW3M0c8JbzIZkIcAMRkdmHHUE9R61o6U 4q7RmqkG7Jm1RSdqajby4xja2P0B/rWRoPopMVE1xEknls2G+h9+/wCBoAmopARx70uaACiio3ni jxvdVz0ycZ/zmgCSiozPEEDmRdpOAfXtTkkSQEowYA4JFADqKKp3t21uypEivMylwGJUbQQCcgE9 WH50AXOvSisv7XqS9bW1/wDAqT/41SJqNzHIpuYI0jZlUNHMz8sQo4KL1LCgRq0UDPc5NGecUDCi jNFABSN909enbrSO210GM7jt/wA/lTj0oAo2Gm2mmLItusgMr75JJZGkd26csxLHAwBk8ACr1YOu +KrDw8A16lyU+T540BX5t20dRk/I35e4qxFrUlxGjx6XflXAYcRA4PqC+R+NVyu17E8yva5rUlc/ pHjCw1q9e1tortXSTyn82IKFbDHB5z/A3btXQUmmtyk09gooopDCiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAxrgj+3ZwTgfZ4uwOfmkrxzUE1uW7aaxg1UwywW7KYLQyKcQRjhthz0x1r1+7/5Dlxz j/R4uf8AgT1z13omrW8MEWjazPDHGQDHKyBQo6AfuyailV5KjbHKDcVY8yltfFcwJXS9XA7E2TjH 5rXa/DaG9sLdbW9huLeQG4ZEnjKELi3GQCBxwf1q/wD2b4v2kf283TH+tTj/AMg1q6Tpl3bxW9xq N/Lc6gIAkrZUorHaXCYQHGRxnmrqVouPKiIUmndnQ6UcyX55P+kjr/1yjrz7xtLcv4luA806RRqk aKFGNhUMcZB+8cg/7vtXfaL0vuc/6T1/7Zx1n+KvDTa2qTW0phukXbuAUhx1AbI6A5xjBGT9K2wV SMJKUtjPE03OLUdzm9Kmjbw5qcplkzAsW4YBDZOPTOePWsjRbm4HiOxkgml3C624Rcgq7YYHgnG0 56j7vtxfTQdetLa4s0sLjyrnb5ojaNlbacjk4I59BWz4N8LXunTm+1MATBpPKiyCsaliARgZLbcA knucDrn0Klamoyd73OOFKblHS1jtxwKji+/N/v8A/sq1JTEUhpCR958j8gP6V5LPSsSZquFzdTA8 gonv/eqeomhYzFxKy5UAgAds+v1piInRYW+SZ0zyEC7gfwxn8qnhd3iBdNrelKkaxg7RyepPJP1N OpAB5Fc5rNjb33iK0S6ginjFjOwSWJZFDB4QDggjOCfzro6oX2mfbLmG5jvbi1miR4w0IjOVYqSC HVh1RaYM5f8As60eLTbeS1he2GrXq+SYVZMBbjaNpBHG0flW14btILGbWIraFIYftiMsUaBFXNvD nAHAqY6Cn2O2hW/u0lguHuVuAIy5d9+7IKbcHzG/h9Kt6fp4sFnzczXMk8vmySTBASdqqOFVQBhR 2oAu5rNvOdXth/06zf8AocVaNVLuzknmjnhmEU0aMg3JvUhipORkH+EdCPxoA848b+GZ/FPiiFRr V1YW9vZglIpygdizc8ccV0eh+Z/whmj+bLJJIqWQcyHLbt8Wc55qxqehX98y+bBpF1tOVMsDgj/x 41ftdMvDDHFdz26RI6P5dvERkqwYfMzHjIHb8abYrGzmqepxX02nTpptzHbXhX9zLJHvVW9x3Hb2 q3RUjOHt/EXijWLiLSLfQrnSb2Fx9tvruENbKo6+Sf8AlqW7dMZ5ruBwMdfc0UUBYZIf3sP+/wD+ ytTzyDTHUl4iBwrEn/vkj+tPoGc9q1lpl9qk6aqY/JWCJlEj7RnE+efZdx/DParNklp/Ywa2uZWt AhCy45Cjrg46D9PwGKXirwofEiBPtfkrmMkbMnKb8YOf+mh7dhVu3g121tobdJdPZIkVAfs5XgDH RWAH0AA9q1vHlWupnZ83kULHTtGtLvTJdIkjy8wMjRsrNIvlTgbuOPm3dMHK46AiuprkvDng2TQ7 +W5a8WQSyiZlEQT5grqMY4A/eNwB2GMV1tKo1zaO6HC9tUFFFFZlhRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAeK3fx78GXbiT7F4gikA2744YMkehzIRVb/hePg/08T/8Afi1/+Kr53oodOL6C5mfR H/C8fB/p4n/78Wv/AMVXR+CvHmg+OtZm0zS5ddhnitzcM11FbqpUMq4G3cc5YdvWvlSvXv2c/wDk oV//ANgqT/0bFS9nHsHMz6XtraO0h8uPJySzMxyWPqamorjL74seCdOv7mxu9a8u5tpWhlT7LMdr qSCMhMHkHpTSGdnRWF4c8ZaB4t+0/wBh3/2v7Ls879zJHt3Z2/fUZztPT0rdoAKKKKACiisnxD4m 0jwrYR32tXf2W2klEKv5bvlyCQMKCein8qANaiiuHj+MPgKWRUXX1BJwN1rMo/MpgUAdxRUFne2u o2kd3ZXMNzbSjMc0Lh0YexHBqegAoqhrOs6f4f0mfVNUuPs9lBt8yTYz7dzBRwoJ6kDpWbF4z0qf XdK0mAXMsmqWf222nWEiIxYJGScEEgdMemcZFAHQ0Vy4+IPh6bwnfeJbG4mvdOsn8uUwQMH3fLwF cL/fU56e/FdDY3cd/YW15ErrHcRLKgkXawDAEZHY89KAJ6KKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAqnq2pQ6Po19qlwrtBZ28lxIsYBYqiliBkgZwPUVcrA8df8k98S/9gq6/ 9FNQBwH/AA0Z4Q/6B2uf9+Iv/jtH/DRnhD/oHa5/34i/+O18xUVVibn07/w0Z4Q/6B2uf9+Iv/jt db4K+JWi+O49Rk02C9t008I0zXiIgw+7BG1m6bDnOO1fGte4fs//APIE8b/9e0H/AKDPSeiGndnv q38zoHj027eNhlWzGMj1wXB/MVFLrlvbtsuYLiF8Z2lA3H1UkfrUWt6frl5d20umazDYQQfM0TWv m+e2cYf5h8uOwwcnOeKtR+aIY/PKGbaN5QEKW74z2zUSutmNWZ8JUUUVqQFevfs5/wDJQr//ALBU n/o2KvIa9e/Zz/5KFf8A/YKk/wDRsVJgj6dr578OzXMPj3x19n8cWXhfOqPu+1QQyfaP3s3TzGGN vt/eGe1fQlFIo8zvZPD+o+AdUtPFnjbTdeiSTf8AbIBDG8BK/IqrGxy+Vcju2SMECuO+G19BrPi6 ym8ZajcyX1rbJ/YcWoRiJZY2JCyLk/M5wMdc4zlsZHvtFFwsfKnhm28Jy/DPXLnVtTMOt20rPYQ/ aWQhti7WRM4YswIJ5wAOmK1vEmoeJNS0bwPba3dwRafd2pZ5NQkljgmk3tt85kO45jEXPqxPc17T 8PfBX/CCaBPpf9ofbvNumuPM8nysZVFxjc39zOc966yi4WPnh47yy+Dfi/TJ/EGk6tb20lo0C6dc PMLfdMuV3MB8vAwATj5s1R8ZeC9J0X4M+HdZtoHfUbl4JLi6d2J2yxM23GdoAIRRx2Hqc/StFFws ZHhi00Wx8O2lv4daFtJUMYDDMZV5YlsMSSfmLd+OleO/CbRNX8QfDDWNNs9XtbCzuryWGbfYmaU7 oow2G8xQAQcfdJ68+nvNFAHiXj7TdN8F+EPCvhqRJb/95LGjTXTW1uSWUs8u05xl+BuGBnn15K0l +z/Df4iaVFc2EtrBNYzRLYSvJAGeVQ2xn+ZhhUGTnp6Yr6aooCx4Jr/gXSLf4Gpr7RTXWsNY2c4u pZXJjUlBtC52hVRiOnQZ61jeF9I8OXHxG8HWWnrDNa3+hMNSSK4Z90z28yygndlDjHAxjtivpSii 4WPlfQrLRl+Dviy5YxDxCkyQMhmPmC3863P+rzjG8fexnPGa6C1NjqnifQNK8a3pt/Dsfh61kso5 J2hhkfyY8lmBHO7zOc/wgV9EUUXCx84w3l7cfBzxxbi5nutDtb2CPTJpslin2hcgE9sbDjsSasRa RH4S1b4X6ppdzdJda0IVvneUsJFbyRtx02hZCoHYAelfQ1FFwsfNPiyHVNd+JHiC01bV9J0+W2c/ Ym1W6lgWKLd8jQlfl3bcZznJYkD0uLZT+JfiP4KstS1lLt59IeOa+0+RsTIjXIIDMAfmVdrHHdsV 9FUUXCxS0jSbHQtLg0zTYBBZwAiOMMWxkknkkk8k9au0UUhhRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFYHjr/AJJ74l/7BV1/6Kat+sDx1/yT3xL/ANgq6/8ARTUwPiOiiiqICvdP2eQDpfjMEZBh t8j/AIDPXhde6fs8f8gzxn/1xt//AEGapn8LHHc9mXTLDaP9Btv+/S/4U7+zNP8A+fG2/wC/S/4V ZX7opa5EanwzRRRXaYhXr37Of/JQr/8A7BUn/o2KvIa9e/Zz/wCShX//AGCpP/RsVJgj6doorO1n W7TQ7aKa7PM0ohhQMqmSQgkKC5Cg4U9SPTqRUlmjRWbaazFMqC7gm06aRxHHFeFAZGIJAVlZlY4B 4Uk8Ul14j0OxYrd6zp1uwcxkS3SIQ4xleT1G5eP9oetAGnRWHF4v0GbWZNLXVLP7QltHcg/aI8Oj h2+X5snCJvPHCsp6Gpz4m0AaeuoHXNN+xNJ5K3P2uPyy+M7Q2cbsA8daANWisqy8T+H9SultbHXd MurlshYYLuN3OBk4AOeBzVi31O3uNTu9PG5Lm22syPgF0YZDrzyucrn1U/iAXaKyrXxDYXk8qRyA RR+d+/eRAjiLYHZfmyVBfaWxgFTkj5cvs/EOiaiM2WsafcjDn9xco/CBS3Q9gy59Nw9RQBpUVVg1 OwujALe+tpjcRmaERyq3mICAWXB5UFhyOOR61aoAKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAorK1W8uYry0tbSWGOWbczNIhfai4yQoYZ5Kj8a4fxP4g1i01R7KfVLdIVtPNH2aN4TISx XJbzCQBhfukH5+vFKb5Vdm2Hoyrz5I7nptFeNp4o1LQ5Sf7TEzKm9ree5d/N9l3sSMngEEfjXqeo apbaXplxqF7MI7e3iaSVicYA5x16noKUJcyuPEUfY9bo0aK47wn8SdA8X2t9c2kz2qWK7p/thSPa mMl/vHCgA8nFdF/bmkf2V/av9qWP9nf8/f2hPJ67fv5x1469eKs5y/RWZc+JdBs44pLrW9NgjmQS RNLdRqHU9GBJ5HuKpaz4mh0xdFmh8q6g1PUI7JZY5lCjeGwwPRsFcYHJz7UAdBRXG+F/HkfiDW/E unzWsdlHodz5DTvcBhL88i7sYAX7nqetdDZ+INF1Od7fT9Y0+6nUfNHBcpIy/UAk0AaNFcH4L+J+ meKNEbUb9rLR3+1G3jhuL1SZSFVsqSF/vYwAelbWq+Jjpvivw7oqwLMur/aD54kx5Yij3524O7OR 3FAHRUVQk1zSYNQFhPqtjHetyts9wqyHPopOas3d1BZWslzczJDBEpeSSQ4VVAJJJ7YAoAmorz+L 4t6RdGSSw0jXr6zRihvLXTzJDkdTnOT+VWdS+KXhvTZdDWeeTZrODC2AnkpuC75g7AouSecfwt6U AdvRWffa7pOlMialqljZvJ9xbm4WMt9AxFTz6jY2sdvJcXtvClxIsUDSSqoldvuqpJ5J7AdaQyzR WaPEWhmze8Gs6ebVHMbTi6TYrjqpbOM8jj3qew1XTtVgafTr+1vIVOGkt5lkUH3Kk0AW6Kxm8W+G kjd38Q6SqI/lsxvYwFbn5T83B4PHsavX2q6dpgjOoX9raea22P7RMse8+gyRk0AW6KOoyKo3us6X ps8UF9qVnayynEcc86oz9uATzQBeoqne6vpumy28V9qFpayXLbYEnmVDKeOFBPzHkdPUU2w1rStV kkj07U7K8eL/AFi286yFPqFJxQBeoqpLqunQahDp81/ax3sw3RWzzKJJBzyqk5PQ9PQ1Xv8AxHoe lXH2fUdZ06zn2h/LuLpI22ngHDEHHvQBp0VU1DVdO0mBZ9Sv7WzhZtiyXMyxqWxnALEDOAfyqq/i fQIhcmTXNMQWsgiuC13GPJckgK/PynKtwfQ+lAGrRVIavph1L+zRqNp9vxu+y+evm4xnOzOentXM a78S9F0fVpdLhg1HVLuBGe4j0y38/wAgDrvO4YI7+nfFAjtKK5nxR460jwpPa2l2t1dX91/qbKyi 82ZxnGduRxnj3wcZwateF/Fuj+MNM+3aRc+YqnEkT8SRHsGXt7Hoe1AG5RRRQMKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArA8df8AJPfEv/YK uv8A0U1b9YHjr/knviX/ALBV1/6KamB8R0UUVRAV7f8AAN2i0DxzIhwy2sLA+hCz14hXtvwG/wCR c8ef9ekX/oE9NK7B7Hos19q8JYLqsmOQuYY+Pr8vNRw6rq5Q+ZqkhOf4YYx/7KaW76t9TVWL7p+t er7Clb4V9yPMdWd78z+8+WqKKK8k9MK9e/Zz/wCShX//AGCpP/RsVeQ16/8As5f8lBv/APsFyf8A o2GkwR9OVi+JL/7LZLCA+6fI/wCQTPfoVHUMsXTqOpGeevbbNcx4u1a90iO2ezlVDIWDBlDelEYu T5UOUlFXZzVrDGmlanZxtfeZOI5LKCz8OXdrDbzoSyuqyEqCW2ZG5V+XtkmthfCOpXGg2MU97Ywa msk9xPcR282UkmkMjLEyTKygEkckhsLwMYrCbxprYkAF3bgDOQYhk/rSp401ojP2iI8npGK6PqlW +xzfXKZ0tx4Uv7tbuOfWI5EvtHTTLx2tD5jsolHmqQ4C5MxJXB6dRS6T4Rk08WTTXySzW+otfO6p MTKTbtAATLNI2QGBzuxhQMDrXPx+LNclnSGKZXlkJCJsQZwCT19gajufFPiJWli+1W9s8RAd5Y1k AJAbG1SMnBB6jGR1rOpRnT+K33m1Gftnammzr7fw2IP7P/0rP2PVLrUP9Xjf53n/ACdeMef177eg zw/X9FvdSaC40vUY9Ov4lki+0PbmYGN1wy7Q687gjA54K9Dk15+PHutW02251axmDDIEduImAHU4 LNkD8MY71e/4TDXGZ9t1BgHGPJBI478+4P8AnNFOjOp8Nh15+wtzrc6rUPCNveWsdpBOba2j0m50 tECZIWYRDdnPVRF0756jHOY3gKd9FezbVUS6e5eV7pIpnLo8Pkuh82Z2yU6HdgbV+XjnJPi/XecX MPt+5Hv7/T8j68A8X67nm5gxn/ngOnHv9a0+p1+34mH1yn2Z1ug+GRomoX1x9qEscxK20Qi2C3jM jyFAcnPzSHnjgKMcVv15mPF+u8ZuYPf9wPb3+v5j05T/AIS/Xuf9Kg6cfuB6fX1/z3o+p1u34h9c p9mem0V5mfF+u84uYfb9wPf3+n5H14QeL9dyc3MOM/8APAdOPf60fU63b8Q+uQ7M9NorzMeL9d4z cw+/7ge3v9fzHpyn/CXa9z/pUHt+4Hp9fX/Pej6nW7fiH1yHZnptFeZnxfrvOLmH2/cD39/p+R9e EHi/XcnNzDjP/PAdOPf60fU63b8Q+uQ7M9NorzMeL9d4zcw+/wC4Ht7/AF/MenKf8Jdr3P8ApUHT j9wPT6+v+e9H1Ot2/EPrkOzPTaK8zPi/XecXMPt+4Hv7/T8j68J/wl+u7v8Aj5h2+nkD1+vp/ntR 9TrdvxD65Dsz02ivMx4v13jNzD7/ALge3v8AX8x6cp/wl2vc/wClQdOP3A9Pr6/570fU63b8Q+uQ 7M9NorzM+L9d5xcw+37ge/v9PyPrwn/CX67u/wCPmHb6eQPX6+n+e1H1Ot2/EPrkOzPTaK8zHi/X eM3MPv8AuB7e/wBfzHpzb0nxTq9zq9nb3FzEY5ZVQhYgpPTp+R/yKmeFqwi5SWi8xxxUJNRS3NrW NTi07Xp5J57eIrYoYvOcJklpCQCTzkolYd3rOmawsY1H+z/lU+WxuF3R5xnawORnAzg/w16H6e1A 46cVhurM6U5J8yep5czeHbCyuntbiye6WItE73LSOJMMV27nJJyq8DH3qd8XJrzUW0LwfYfI2uXB SaQDdsjjKE5GRx82eoztxXp55680HB6gGhaDbctzxDVtOu/h7430PWbm4sbnTNRiTSbxbe0aGNYh tUZBkfJwAc/7PvWQ3hHWD4rT4aLc58NPcHVvNwS/kYxszu5GSF/3vm6V9DDAJIAyepoIBIJAJHSg Vjwvxjf2Fl8SLzSbnQNHitpLSMR3V1ps13LOQoCrEqOACPug/LypJPNYPg+4kl8BeF4nlL+V45tk VSSdq+WDgfiSfxr6SHAwBxRgZzgZ9aAPn3S5vK/4W7KLCPUSuoKfszbsPi4m5O1gcD7xwR061F4R 1Cx1L4ieCL21ttJtt0dyJl07TXtY1byGwhdmIlIO4ZAGM9TnI+h8A9hRgZJwMnr70BY+UvC934Vi +G+uW+q6e1xrlzK6WMxtWZi2xdgRxnBVssRkZHrXo2jW2o2Oq/CW31Rv9MWHUQ4c8qpiygOe4UgY PPFez9etGB6CgD5cbT4IDrWleLb1NN1uW9M6Xh0mW4uJTnIMMiSKMHngr0PrwPoW0An8JW5vt14k mnqLhTARJMGj+bKZyCeeM9zW8QCMEA0YHoKAPma8XQND86bwj4r8Q6VqGCU0eSxkZpG7JxhcZJ67 vb33PGdvfzw/DnWvFdhAswuRHq8gtgVMfmoUWQY6FQxK46k4HavfTz1o4xjAx6UAeA3raNonxA8W zePrKS6S9XGlyNbl1aPnCoecNjYAexDdKitNF1A/C3whpmupPHHdeKLdYonJR0gdWGPVcneR9RX0 GMAcACk2rgjaMHrx1oCx5J8Ul0vwnY+Ho7Pwzo7WX2l1aW6tGkgtchASUQjczDnnJOzua8908Xl5 r/jay8PBUN1o/mRQ2lo9qkoDwltkLMzDKGTAzzu4Azivp4YHQAVR1jSrfW9Kn066aVYJwAxhcoww QQQR0OQKAsfMXie88JTfDPQ7bStPMOuW8qJfzG2ZSG2PuVpMYYlsEDJwB2xXXfE7TW/4WTc3PiGT ydEu7EQWd49m9ylu2BnAR1w+7cQefvDg9R6HB8KtFGo215qOo61rBtm3wRaleedHGfYYHp3rujg9 Rmi4WOa8AL5fgXSYxd3F2qRFEmuIDC7IGIXKEkjAAA55AB714x4rgtbDxR43TxVp9xc3+opjQ5fK ZwcsdgQ9iBs/75Yd8H6MzR16igD578SaTdvY/CfSfEKO80tw8FxHISG8tpYQEPcEIQD9K6C402w8 PftFeH7XSbaGwtrjTXaaK3UIjfLP1A4/gU/hmvZMD0HNHGMYFAWPMfi/LYXVtpmk28Etx4omnV9L Fs+2WEg8yFuycfjjPGMjB8LaTHc33izwx4oOzxjqcEii+nxIk0TL8rRcDhSAdo/ujptwvtYAAwAM UFVPVR+VAHgvhSPXPiD4n0zR9fjWOz8JcXIAJ8+ZW2qG564T/wAdb+9xU0zRdN1S++L13e20c81k 1y9uX5EbZuDuA/vAoMHqOfU19DYHHA4o49B6UXCx8+ahpNlpN78I72zhEV3fyQy3U+fnmZmgJ3N1 P+sYc9jiszxZo1hovirxmviKK8+0Xxa60WSIPsklZyVHy9SN2OTxtbg5FfSuB6ClwMdBRcLHjfi4 waP4m8La/rOuPpeu2emqssraY91bzPhgy/Iy4OWk49CORWj8F9J1OGPxBr+oiRV1i7EsIkh8pnAL kybcnaGL8D26kYr1OigLBRRRSGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAVgeOv8AknviX/sFXX/opq36wPHX/JPfEv8A2Crr/wBFNTA+I6KK KogK9t+A3/IuePP+vSL/ANAnrxKvbfgN/wAi548/69Iv/QJ6a3QnsehXfVvqaqxfdP1q1d9W+pqr F90/WvaWx5LPlqiiivEPXCvX/wBnL/koN/8A9guT/wBGw15BXr/7OX/JQb//ALBcn/o2GkwPp09a 434gf8e1j/vv/IV2R61y3jLT7vU0tIbKMSSqXcqWA4wB3PvVUWlUTZFVXpux5ZqVvqMxiexvzb7G zJEI0Pmj03MG2nGQDg9TkerNKgvYllku7yWVJHYwwSKm6FNxwCyAAtjbnHGc4rrD4S105xY/+RU/ +KoXwhrpHFj3/wCeqf8AxVevz03Pm5vxPLtU5eXl/AZ4d2m8nuHdVWKIDDAnqck+2AtW9RsUvpTN Z6jbxFx+8DwGZWIGAcZGDwM9eAOnWorfwv4ntC5t7Ux7wA37yI56+pPqamGg+LR0g/WCuWrGM5PV fed1CrOilyp39DMvNCl+yzyS6pBIqoztHHasm/AzjO4+hqhbsJbgRswALAEjHy9OuT+Pb+tdBL4f 8VyxvHJBlHBVhuhGQff86oHwrrSI8j2qKi8kmaMBR3z83qDV0OSkrOS+8yrOdSySenkKmnRS3s9p HexgphkmbGx0H3j17D5uvRW/CvFHBPHeyJ5gWCPzFyRlgZFUA8ejD8vfijtgLBf7R0vJ6f8AEwg5 /wDH61ofCus3EayRWivG3KOs8ZDDGcghulbKvTf20Zyw9WPxQa+8mcQ6dAnktHJcSshYSwrKURo0 ccE46sR0529RUcBtmS/SW4tBGGkKbUJLMB8pR+ykgADJz6c5p3/CG69/z4/+Rk/+KoHg3XyT/wAS /GP+m0fP/j1JVKf8wnTnf4TH8z2o8z2rZ/4QzX/+fD/yMn/xVIPBuvkn/iX4wf8AntHz/wCPVft6 fdE+yn2MfzPajzPatn/hDNf/AOfD/wAjJ/8AFUg8G6+Sf+JfjH/TaPn/AMeo9tT/AJkHsp9jH8z2 o8z2rZ/4QzX/APnw/wDIyf8AxVIPBuvkn/iX4wf+e0fP/j1Ht6fdB7KfYx/M9qPM9q2f+EM1/wD5 8P8AyMn/AMVSf8Ibr+4j+z+MdfOj/wDiqPbU/wCZB7KfYx/M9qPM9q2f+EM1/wD58P8AyMn/AMVS f8Ibr+4j+z+PXzo//iqPb0+6D2U+xj+Z7UeZ7Vs/8IZr/wDz4f8AkZP/AIqk/wCEN1/cR/Z/GOvn R/8AxVHtqf8AMg9lPsY/me1Hme1bP/CGa/8A8+H/AJGT/wCKpP8AhDdf3Ef2fx6+dH/8VR7en3Qe yn2MfzPatHQJM+ItOGQMzrwe/wBKsf8ACGa//wA+H/kZP/iqtaV4a1nT9Zsrm5s/LgSZd7+YjYyQ B0bPUjsayxFam6UkmtmXSpTU4trqj0K/Zk065ZWKsInIIOCDg0n2GH+9cf8AgTJ/8VRqJA0y7ycf uX6/Q1yfixvDv/CXaL/wkp0z7H9gvdn9o7PL8zzLbGN/G7G7HfrXj2TZ6t9DrPsMP964/wDAmT/4 qj7DD/euP/AmT/4quBl1LUtN8MyPo1zHbabJqmy3ubyQxrb2Zjzu3ujhV80FVLIQAyjA4Ifaaz4o utU8OW6atp0lvqMUktzJDAXCR28o3MjkLnzFeNCSuAcsoxT5V2FzHd/YYf71x/4Eyf8AxVH2GH+9 cf8AgTJ/8VXBWWvXQ0nQRea5Ho1vJotpPC6W0f8ApNwwO+PaRjCgJ8iBW+Y4IArSXW9YPxLbTXvL CPTAMR2rMfOmTygxlUBD0kyud4UAEbc4NHKuwXOr+ww/3rj/AMCZP/iqPsMP964/8CZP/iqsAgjI NLS5V2HcrfYYf71x/wCBMn/xVH2GH+9cf+BMn/xVWaKOVdguVvsMP964/wDAmT/4qkazhVSxa4wB n/j4k/8AiqtUyU/un/3TRyrsFyL7DD/euP8AwJk/+KpPsMP964/8CZP/AIqqniOJZ9DuY2ujajKt 5vlGUfKwbDICCynGGGRkEjIrg7e/srNxBpR0O5WS6s911o1uEgBN3CrI8e508wgsVYEsNp+6cEvl XYXMej/YYf71x/4Eyf8AxVH2GH+9cf8AgTJ/8VXE+Gtdi1PxKv2fx6l9ZjfHFYStaNNdMAcuPLRW VRyQBydueBwX+CNe1zU9Uki1fUNNkY25kmtIJd8lrLvACFREuwD5gQzuxIBBxmjlXYLnZ/YYf71x /wCBMn/xVH2GH+9cf+BMn/xVWaKXKuw7lb7DD/euP/AmT/4qj7DD/euP/AmT/wCKqzQSAMmjlXYL lZbKFlDBrjBGf+PiT/4qj7DD/euP/AmT/wCKrI8ZkD4eeIMn/mFXI/8AILVD4d8MDRb+S5EHh5N0 Rj3abo/2WTkg8v5rZXjpjrg54o5V2Fc3RZQnPzXHBx/x8Sf/ABVH2GH+9cf+BMn/AMVUykAyZOPm /oK8s0OPQjr8rz6j4OS/Gt3R8m5sEe+3fbHCgSecCHPG07OMrwcciiuwcx6b9hh/vXH/AIEyf/FU jWcCqWLXGAM/8fEn/wAVXI6dqmsHU9NuZ9WM1te6xfWBtGgQKkcZuTGQwAbcPIUcnBB6Z5M/hjWJ dRUm915LjUGtS93pixIos5OMrkDcuMkfOSTwRgUOK7DudT9hh/vXH/gTJ/8AFUn2GH+9cf8AgTJ/ 8VTNS07TNWgEGp2VpeQI+8R3USyKrDIzhgQDgnn3rzbSrn/hDvBek6tpttp8cWoaJDGyraBWa+EJ eJndcFw5JQg87iuCCxycq7CuemfYYf71x/4Eyf8AxVH2GH+9cf8AgTJ/8VXCJr2qW3iKfTpPEK3N 1baha2q2bW0a/aYmigM8nAz8u+R+D8vQ5BUCxpWva5P44ls7y/01Lf7TcJ9g83Mywpu8twgiypOE Ys0hUhiAAeA+Vdh3Z2f2GH+9cf8AgTJ/8VR9hh/vXH/gTJ/8VVmilyrsFyt9hh/vXH/gTJ/8VR9h h/vXH/gTJ/8AFVZoo5V2C5W+ww/3rj/wJk/+Ko+ww/3rj/wJk/8Aiqs0Ucq7BcrfYYf71x/4Eyf/ ABVH2GH+9cf+BMn/AMVVmgnFHKuwXKq2cLKGDXGCM/8AHxJ/8VS/YYf71x/4Eyf/ABVYHjiAXPhF LYiA+de2EeLiLzIzm6hHzpkbl55GRkZ5FVB4aXSdC1KMyaNYiYxN5ul6OYF+Rt2JVWRjIh6EZXgs M88CirbCudV9hh/vXH/gTJ/8VR9hh/vXH/gTJ/8AFVzfgm4tGS8t7JdNe2j2Mt1pSmO1lznOxNzB SMc7SQcjnIIFHXfCeh3vjG1hXS9LiuLzTL+QzvYxSZm8y22yMrDDsC7Hn1PqaOVdgudl9hh/vXH/ AIEyf/FUfYYf71x/4Eyf/FVwFx4r1y40WfU/tkOnx2dzBp02y2DiS4+1RxzuMkkoBuCqOfmY54BE l34g1pPDsstjqttPbrqn2ddXnKRKbXytxkLhGjGJMx79hX1A60+Vdg5jums4VUsWuMAZ/wCPiT/4 qnfYYf71x/4Eyf8AxVZvh29ur/wxBc3txbXFwyuGmtiTG4DMFIJVc/KBkhQCckDGKr+NrmC18Ppc XE0cMMWo2DySSMFVFF3CSST0A9aXKuwXNn7DD/euP/AmT/4qj7DD/euP/AmT/wCKrkPFfidjb6Y+ ha3bRw3fmlLtJovJkKEAKJCkgJySAqqS21sEbTWC/iK/kmTVotTS01O68O6dPFbCBSt5cM1wwh+b kAkkYUhucg4U5fKuwc3mem/YYf71x/4Eyf8AxVH2GH+9cf8AgTJ/8VXGaVr2uTeN5bO81DTUt/tM 8f2Ay/vlhUN5biMRZBbapLNIVIJAAOAN/wAE8eBPDqnhhplsCD1B8paOVdg5jTWzhYZDXHUj/j4k /wDiqX7DD/euP/AmT/4qsfxkw/4V/wCI+R/yDbr/ANFvXJ+Kp7q78Ja74dd28vT9PmnkucHM0Sx7 oBnP3mYMG9fKbjDCkorsFz0T7DD/AHrj/wACZP8A4qj7DD/euP8AwJk/+KrlIddv2+IFzp66issC XflPYmNf3Nv9kSQTbgN2TK2zkkHOAMqayD41vZvD0TW+oq2oweGby6vNsSkx3sSwAbhjAZWZ8r0+ YZGCtPlXYOY9C+ww/wB64/8AAmT/AOKo+ww/3rj/AMCZP/iq8+v5L6XUoDf+JbiGDTdeMRvVjt41 jR9PDAkshUDfKUGc8SYOTtI3fG1iNXfw9ZKtjJv1Rsre232mHi2uPvR7lzyMDkYOPTFHKuwXOk+w w/3rj/wJk/8AiqPsMP8AeuP/AAJk/wDiq4ySxn8HaT5a6pY2Frfamr3NzZ2a28VlEYNvyI7Oq5eJ ck5GZGOO9VLzxFqkWirfm4j+0poerzw3PkKC/lSRCGXBBwGQq5A+U7hxwMHKuwcx332GH+9cf+BM n/xVH2GH+9cf+BMn/wAVXn2ovfvqkK6h4kuIYtM14xNdrHbxiJH08MCd0ZUfvJSgzniTBydpHpWR 60uVdguVlsoWUMGuMEZ/4+JP/iqPsMP964/8CZP/AIqsHxtCt14UjtmkaMS3tghdDhlzdQjI9x1r n9Xv7zW47VLseV/Y+rWC3G1SomuDdxrx/s+WwfHP+tXutCiuwcx332GH+9cf+BMn/wAVUVzbpBGk kbzhhLGOZ3IwXAPBOOhriJfEevNc+JooLwPcWtjeyR2q265tJI3K2xGeX81Mvhsj5RjAyDs2niO3 1rXL6Kyvo7jT4oNPkiKY2+Y88wbDY54RBjPBUjg5ocVZ2Q09TrKwPHX/ACT3xL/2Crr/ANFNW/WB 46/5J74l/wCwVdf+imqgPiOiiiqICvbfgN/yLnjz/r0i/wDQJ68Sr234Df8AIuePP+vSL/0Cemt0 J7HoV31b6mqsX3T9atXfVvqaqxfdP1r2lseSz5aooorxD1wr1/8AZy/5KDf/APYLk/8ARsNeQV69 +zmf+Lg3/wD2CpP/AEbDSYH08etVWA/tWA4GfJk5x/tJVnNV2ydVg9PJk/8AQkqSi0BwKcKAMUVV iSG6ma3tpZkt5bhkUsIotu98dhuIGfqRXH6d8SrTU76zsrbRNSa4umIEQltWkiUEhmkQTFkUEEHc ByMdcA9tUMNpb28s0kNvFHJO++VkQAyNgDLEdTgAZPpTAr6veNYaReXa7Q8cbFA3QtjCj8TiuO1b w4kWlWbWttazz2rK8zrAPNnCoRkN1zna3fO3Heuu1u3nudLZLZPMlWWKUIGALbJFcgE8Zwp61znk eJBMWEd+Yy2dhEGQPTPnUmrqxdOfs5qa6HA3V7E6mIajm7OQU8oBs/7m4t+HWvQvh7FeR+H5Vu5M sLp9iFSDEOAVOSec7j2xux25nH9sf9A/Uv8Av7D7f9Nfr+daGiW91BHdy3cbRyXE/mBJGDMAI0QE 7SRklCeCeorOnS5Op1YnGOsuVJ283f7tEYd38S9CstE1W7nv9Oj1Cxa7Qae98iyStC7oox1BfYCB gkbu/feXxNpT662jC4b7crbNpicIzbFk2q5G1m2MG2g5xzjAqhL4a8zwnq2hi8wdQ+24m8vhPtEk jnjdzjzMdRnHbPFE+Cx/wnH/AAkgu7QMt2bkILQCX/j28gxmXdnb/GABjJbg5BGpxGpF420Gays7 yK8d4bwZgK28pLqApZgu3O0Bly2NozgkGon8VSt4K07X7exjea+Wz8u2e4KqrXDxoAX2E4BkHO3n HSoIfC89lpmiRWGpLHd6XZfYBO8G8SRFUDYXeNjExIQckAjoQTUh8MynwRpug2+oRLNYLZ+VdSQb 1Y27xuCUDjhvL6BuN3WgBzeKp7GK/TWbGCxubaykvk2XLSwyRRj5zvEYYbSQG+Q43DG7OKuxeKNK n1uTR4p3a9jO0r5Emzd5YkwJNuwnYwbAbODWXeeFbvU7DVF1bVopru80+WwjlhtDHFbpIPmIjLsS T8ucvzsHSpF8NTP4vGuPdWyBDlY4bQRzNmPYUklDfOgOXwV645wAKAH6R450fVdIt7w3UEUr2KXt xCJN4tVaMOfMYDC455bGcHArV0fXdP163mn0+SV0hl8qQSwPEyttVx8rqDgq6kHGCCKxtH8Kf2Hp dpa6ZexwbLFbWdlgG2Z1UKs20nCyZ5JO7cOGztUi34V8Pt4fg1FHmtZHvLv7SwtbT7NGh8qOPATc 3J8vcTnkseBQBv0UUUAFFFFABRRRQAUUUUAFVdQ/49l/67Rf+jFq1VXUP+PVf+u0X/oxamXwsa3I 9TGdKvB6wP8AyNcsfH0AkA+xtnn/AJadP8e9dTqZI0u8xj/Uv/I14+v727SNZog74SMH+J2ZQF6j rn88etdWFoQqOXN5HPiK0qduXqdwfHcHa0lHX/loKP8AhOoMgizkGOnziuV/s+Ui38q7t5/OeRdy A7QEVST17bifoPeqzWl0l7BG15aGGVSyyBWAYf3skjA+V85Hb256VhaDOb61WR2f/CdW5+9ZyH1G 8Yo/4Tq3J+aycj3cVxrRFjbxxXtv9okDN5DAlnA6KuD94jnGOn1o8pvPaJb2ycor+Ztk+4wVSAee 5YKPU/hlvCUA+tVTsx48twP+POQn18wUv/Ce2/8Az5Sf9/BXJy2LRQvm9thMkqROhJ/dlg3Dc8YK /ofSoLiE28MUy3dvPFISqyR7gMjGRz35H51KwlBj+s1Ts/8AhPbf/nyk/wC/go/4T23/AOfKT/v4 K4YS5AIdeRnrS+Z/tL+dV9SpE/W6h3H/AAntv/z5Sf8AfwUh8eWxGPsUn/fwVxHmf7S/nR5n+0v5 0fUqQ/rdQ7j/AIT22HP2OT/v4Kb/AMJ7anH+iSf9/RzXDrPGGAnuBEuOWVNxH4bhU90iWclx595G sMF0bd5AvAH7z5vvDHCetH1SgtGL63VOw/4Tu0AH+huAM/8ALQd6X/hO7fjNnISO+9c1yps1jvre xk1CD7RPK8SgLkbldkA+9nJKN9MGqQZmilkEsYEIV34z8pcJxz1+YUvqlBjeJrJHc/8ACe2//PlJ /wB/BR/wntv/AM+Un/fwVyRsv381v9uTzFgMsbCHKt+6MgJ+cEcAfn2qkkvmNEpmjTeyqXPIXJxn GefpnmhYSg9mH1qqldndf8J7b/8APlJ/38FIfHlsf+XKT/v4K4cvuikZLhfkGcmM46gZJ3fL1H54 qa9he1nuoPPTfbSYLMvDLvCnjdwSCcdeo60fVKF7B9aqnZf8J5b4A+xSf9/BR/wnltz/AKFJ/wB/ BXDrIT/Gp4H8vrS+Z/tL+dP6lSD63VO2/wCE9tdxxaSA5z/rBSf8J5agH/Q3A65Eij/PauK8z/aX 86PM/wBpfzqvqVEX1qodr/wndu3W0kPP/PQe/wDjQ3ji1YYNlIfcyDNcV5n+0v50eZ/tL+dT9SpD +t1Ttj49two3WjDJALGQDr71lSeONAvNVS5ZFmvLbPlxC7L7GGct5eSu4BiN2MgHGayNKT7Tq0Cb +EJdiOcADP8AMitbxNbX13aPPZzRSCO3ljELEjJYDkHPGNoGAP4qwrUIQ0ijqw03VmlOViWw8e6M s93LZ2jB7mVZZ2LMAzhVQE7unyoo4x92tD/hPbYq3+iMQvfzBxXCm1vrmFlht5DKqfM8kDKgbHcN jI9gfxpsTeXaxp5u4ogG4k8/rU4ahTqbl4ycab/dv79Tv/8AhPbf/nyk/wC/go/4T23/AOfKT/v4 K4fzP9pfzo8z/aX866fqVI4vrVQ7j/hPbf8A58pP+/go/wCE9t/+fKT/AL+CuH8z/aX86PM/2l/O j6lSD61UO4/4T23/AOfKT/v4KP8AhPbf/nyk/wC/grh/M/2l/OjzP9pfzo+pUg+tVDuP+E9t/wDn yk/7+Cj/AIT22/58pP8Av4K4fzP9pfzo8z/aX86PqVIPrVQ7f/hPLfj/AEKTj/poKP8AhPLbobJy P98VxHmf7S/nR5n+0v50fUqQfW6h248eW4ABs5D/ANtBUc3jizuIZYntZgrqVYpPtYZHYggg+4PF cZ5n+0v50eZ/tL+dNYKiH1uodIniDRk02PTxprmCOZZwvnnJlWTzQ5bduY+ZhjknJ69a0h49tjyL STp/z0FcT5n+0v50eZ/tL+dDwVEPrdQ7X/hOrXZhrOUjByTIvNB8eWpH/Ho5X3kBrivM/wBpfzo8 z/aX86FgqIfW6h2o8eW27/j0fqcjzBzSf8J3bkg/ZZPfEg5P+T/KuL8z/aX86PM/2l/On9Toi+tV DtR49tRz9kck9zIKcPHluMf6HJ/38FcR5n+0v50eZ/tL+dJ4KiP63UO2/wCE7t8ECyk/7+Cj/hOr fGBZyD/toOK4nzP9pfzo8z/aX86FgqIfW6p23/CdQDOLN/b5x6UDx1bgACykwO28VxPmf7S/nR5n +0v50/qdEPrdU7b/AITq3z/x5yAegcUDx3bgAfY5MDH8YrifM/2l/OjzP9pfzpfUqQfW6p2w8dW4 JP2KTk8/OKG8dW7HP2OUH2kFcT5n+0v50eZ/tL+dH1KiH1uqdp/wnFvuJFm/tl144x/n8af/AMJ5 b4A+xSf9/BXEeZ/tL+dHmf7S/nS+pUg+t1Ttf+E9tSOLV8Yx/rBQPHdtuJ+ySfTzBx/nH+ea4rzP 9pfzo8z/AGl/Oq+p0RfWqh2jePLXfgWjq3++vrT4PFkGp3dtaLEytLPGMl8jhg3Q/Q/5FcP5mf41 x9a0dAfPiCxyQf3y9B71lWwdKMG0XTxM5SSPWKwPHX/JPfEv/YKuv/RTVv1geOv+Se+Jf+wVdf8A opq849A+I6KKKokK9t+A3/IuePP+vSL/ANAnrxKvbfgN/wAi548/69Iv/QJ6a3QnsehXfVvqaqxf dP1q1d9W+pqrF90/WvaWx5LPlqiiivEPXCvXv2c/+ShX/wD2CpP/AEbFXkNevfs5/wDJQr//ALBU n/o2KkwR9O1XP/IUg/64yf8AoSVYquf+QpB/1xk/9CSoZZcooorQgKKKKACuWufiL4ZtLvUbWW8u vO00n7aF064YQD1YiMgLxkNnBHIOK6ms7UNC0zVbq0ur6zjnmtH3wu38J9/UZAODkZAPUA0ASaRq 1lrmmQ6lp8jyWk43RSPE8e4eoDAHHocc1Hda1pNpJIlzqtjA6FgyyXCKVKoJGyCeMIVY+gIPQ1o1 zsfhh4/Ft5rn2uF0vI/ImtntQcxBFCgNu+9uDEkg5UquPlBoAv3et6Pp+83msWFsECM3nXCJtDbi pOSOu1sf7p9DWda+N/DE9slxJrmn2yyPKka3N1EhkEcrxl1+blGMbEHuB9az7DwNd6ZYWot9ZSTU LW8FzFc3NqXUotu1ukbIJAThG67hlsnuaoal8OtZ1HSpdNPilY7adLrzo47SVFMk80sjOAk65GJA u196/L05IoA9C2jj0owPQUozgZ60UAFJtGMYGKWigBMD0paKKACiiigAooooAKKKKACiiigAqrqJ xarn/ntF/wCjFq1VXUP+PZf+u0X/AKMWpl8LGtyLU2C6XeEkDEL856cGvGReyI8PkSRJLEXdHIyQ eBzyMgFR3GPUV7RqHOm3QyR+6fp9DTpLu1gnghluIo5JyViRmCmQgEkL6kAEkDsM1vQrezb03MKt Lnt5HkL6xNmHYtrEIWdtkaHBLABhyxyOPWmNqbrOxjW1gDwmFlRTwCQT/Ef7uOexI717KJ4GuHgE 0ZmRFd49/wAyqxIUkdQCVYA99p9KXzYhnMgGOuTWyxSX2TH6q+54q2q3AupJ1nt1uZUYcofkGAMq NwIAGBweAe1Ry6heyTFmuLdRKP36rFjeQQQR8xA5GehBz2wK9rW7tXuZLZbmJp41VnjEgLKpzgkd QDg4Psak3J/e9+tP62v5R/Vn3PGn1q+MYCmxScSRzGUxsd0qZG4jf05PFQXWpzXqIjm2SJJWZBCj A5IAO4liT93Ne1GeBbhLczIJ5EZ0jL/MyqVDEDuAWXJ7bh61X1LVtM0a3W41TULWyhZgiyXMwjUs QSBliOcA8ex9KPrSWqiDwze7PGN4yfmHXjHpRvH94V7mACMg5H1pdtV9e/uk/VPM8L8wf3hR5g/v CvdNtG2j67/dD6p5nhfmAfxCrJ1OVr6S5cW8jtMZypjyquc4YDPbJ7nrjBr1rUtc0fRhGdU1WysR LnyzdXCxB8dcbiM4qJ/E3h+NbZn1zTlW6JFuTdJibBwdhz83PHFJ4y/2RrCtdTy1dauYiheS2Z1L eXNIPmUsezbuuc8EE5IxVUXbQldscUmGUOmOHG8Hn5h0IB/CvXF8TeH3vzYJrmmterJ5ZtxdoZA+ 7btK5znPGMdeKn1DWNK0mNJNR1K0s0c4RridYwx9ASRk1P1pfy/iN4a+7PIjqU/2qS58yIzMrJ8y naFKlcdfQ8daqmRkVGieMSRsrIXUkZB4yM88/nXsNx4k0G0vI7O51vToLqTbsglu0V23fdwpOTnt 61fmuLe2jEk88cSFlTdI20bmYKo57kkADuTiqWMt9kX1W/U8cfVGeCWNILSHzgFlaJTkgEHHLYAy B0ApLzUvtZlZreyjmmbfJLErkkk5ONzEDn05x3r2GW/sre8t7Oa7giubnd5ELyBXl2jLbFJy2Byc dKzLfxj4Wu7iK3tvEmkTTSsEjjivo2Z2PAAAbJPtUfWVvyj+rPueT+YOzCjzB/eFe5gAjIOfxpdt afXvIn6o+54X5g/vCjzB/eFe6baNtH13+6H1TzPC/MH94UeYP7wr3TbRto+u/wB0PqnmeI2N+9he i4URSJtKsmSD1U9foCKnTV7mPIG1h6NITXsFzcRWkYeRgNx2qM9T6Vn/ANpzFS58pFxnkE4+vNZP EKT1iaxpSikk/wADzdPETqMmCNiOp83Gf0rIDKIgpYcLivYV1TymH2oxBM8yKcBPc5PT3rQnmhtb aW5uJkhgiQvJLI21UUDJJJ4AA5zVRxKhtEmdCU/idzxDzB/eFHmD+8K9ukubeIAyTxoCwQFnxliQ APqSQAO+RTyyDqw/Or+u/wB0j6o+54d5g/vCjzB/eFe5ZX+8PzoyvHzdfej67/dD6o+54b5g/vCj zB/eFe4704+Yc9OaZLc28EYkmnSNC6oGdsAszBVHPcsQB6kgCj67/dD6o+54j5g/vCjzB/eFe3xz wTJuimjdclcq+RkEgj6ggj8DT8r/AHh1x170fXf7ofVH3PDfMH94UeYP7wr2fUdW0zR7dLjU9Rtb KB3CLLczLGpYgnALEDOAT+FRabr2jaz5n9latY33lY8z7LcLLsznGdpOM4P5UfXf7ofVH3PHfMH9 4UeYP7wr2m41GwtBm5vbeECFpz5soXEa43PyfujIyegyM9ar6f4h0PVpTFpusWF5IASVtrlJCAMZ JCk46j8x60fXv7ofVH3PHvMH94UeYP7wr3MYYZB4pdtH13+6H1TzPC/MH94UeYP7wr3TbRto+u/3 Q+qeZ4X5g/vCjzB/eFe6baNtH13+6H1TzPC/MH94UeYP7wr3TbRto+u/3Q+qeZ4X5g/vCjzB/eFe 4yPHDG0krqiKMszNgAepNQWmoWOoRtJZ3kFyikAtDKHAJUMBwe6sp+hB70fXf7ofVH3PFfMH94Ue YP7wr3Hcn94fnTJrm3toxJPPHFGWVAzvgbmYKoye5JAHqSBR9d/uh9Ufc8R8wf3hR5g/vCvclww4 NO20fXf7ofVPM8L8wf3hR5g/vCvdNtG2j67/AHQ+qeZ4X5g/vCjzB/eFe6baNtH13+6H1TzPC/MH 94UeYP7wr26a5t7eSGOaeON5n8uJXfBdtpbA9TtVj9Aait9RsLwzC1vbecwuY5RFKH8tgcFWweCD 1B6UfXf7ofVH3PFRICfvD861PD0sf/CR6evmLkzLxur17ehJUOu4ds1VviogjIIyZogOP+mi1FTG c0WrFQwrUk0y3WB46/5J74l/7BV1/wCimrfrA8df8k98S/8AYKuv/RTVxHafEZooNFUSFe2/Ab/k XPHn/XpF/wCgT14lXtvwG/5Fzx5/16Rf+gT01uhPY9Cu+rfU1Vi+6frVq76t9TVWL7p+te0tjyWf LVFFFeIeuFevfs5/8lCv/wDsFSf+jYq8hr179nP/AJKFf/8AYKk/9GxUmCPp2q5/5CkH/XGT/wBC SrGKrtkapB/1wl/9CSpZRcoozRVkhRRRQAUUUUAFFFFABWZq+vWWh+S2oM8UEofE+MoGVd2w99xA bAxztI6kA6dZWs+HtP8AEAhj1ONp7eLcRbsRsLkYDnjO5Rnac8E56gEAFdfFNp8yS2t3DcrcW9v9 mkVfM3TBSp4YjADNk548t8ZwM0tO8bxapcamttpOoPBZ29vcQOqKXvFmaQK0a5+78gO5iOpyF25N 8eFdObXtO1ufzJ9RsbY2yTy7cuD/ABtgDLD58EYA8x+OeMofDjSDZanZSXN7La30dvCIZWjdLaOB 2eJIwUxtBbo+4Hoc85AJ77xdPF4Z1XV7TSW87SfMN7ZX04heMJF5pAZBIrEqUIwcYbrxiuprmNP8 CaVpvhvWNCt5J1tNW8z7QQI0KmSJY2KBUCrkLnGMZJ4xxXT0AFFFFABRRRQAUUUUAFFFFABRRRQA VV1D/j2X/rtF/wCjFq1VXUP+PZf+u0X/AKMWpl8LGtxmo86Zd9P9S/8AI1ha/pOsajqc8th5du0W j3NvbXLScm4mK7cADK7PKHzf7fAODW7qP/IMu/8Ari//AKCau0luNnmf/CMawLXX/wCyNDi0gXVr Yxw28sqMspjmledSqNgbkfBGQG39QScU4PCXimUWkTWNpbWU8k9pPbxlbYWlpKbdn2Rq8gw3kSDA fgy54GcesUVZJw82ha3c+HjL9khg8QXl4bzzBOCli+0qmTj5wsarGQB8249iTVWHwpqj6poLfZVt rNY2/tZXuBIZJIZPMgIOPn3SvJJkgcHnDYFehUUAea6R4a1W1vYZpdARLiPRrq2u5/tigX10zQkN uUlwH2N85G7HDAbVzW03wx4gXQfF1s+iWtimo6SIrOzt9katN5cykMBK43nMYL5AYYJwc49TooAQ AgDPWjmlopWATmjmloosBgeIdQ12wigGj6C2pySFldhPGggxjDEOy7+c8AjOOq1yFz4a137DqENh o7N/a+mNZtJe3UaS21wZZ3eWQIWG1jOX/dsSCqjaOo9OopgcXq1lr2ra9ZJ9juo7O2u4pXSSeA2c qJJuD8Dz/MHBUcLuVc9ybWuW2rNqthqllpIvBBBdWr20twkZJd49kgPI24iOe4V/uk5WuqooA8yi 8L+JNN8L6n4dSwgvH1C0ggjvlugEhZbWKBi4YBhtaNnXaGzkZCnJrrPGGj3eteG20+0LJLJdWjF4 3CtGi3EbOwJxyqqzevHFdDRQBwttpHiG/wBY0bWdXsreC8t75leOCcSJFAttcJvBOOXkkBIHOCmf unGPoeg+KE03w7p1zBrIjsDameC+msfsgEe3O0w5lYqRuTdxlRmvUqKAGqCBil5paKAE5o5paKVg E5o5paKLAY/iCK7a0imtYRK8Ll2j3YLDaQQOOvNc+2p2eoWlzbx3IjMkbI27IdCR3HUY967isq+t dDuJSb2zs55BwS8AkI/Q07tCavoeOaXaazqOtvZxkzyI7KXSVzFH6tkgE9+1eu+JrC61DwVrOn20 Xm3Vxp08MUYYDe7RkAZPAyT1PFaNjHYxQhLGKCONf4IkCgfgOlWq0q1HUd2TCmobHKaj/amu6asH 9hXtm8OoWM3+lSwHzES5jd2GyRsbVQnBIz2yeK5vUvAd7Nos/wBj0+OPVby71VbibzgC0E63flAn J+Qs8B287SckZBNen0VmWcLJp+sapc61d3OhS25urGzht4mu4g4ljlmYvuUkIUMisCM5AGOeK2/C +n39jp8ianEv9otMz3N0rhhcuQvzjjIXGFCkDaEAHABO/RQB5zofg670Sx0k22kok/8Awj0ltqMY uQnnXIEHlo7gknGJgGGdo4GBgHKtfBOrXNhqcd94b06O2aTT7m2sI4olQvDMxmG0ySKHaPC7twDK QDj5set0UAeX2/g7WYdPhtLLTILSz1Ca5tdRtnmRfItGu5JYyoTKn91JKm0HgyL2U4uaVoHiSDx0 17c21otuby4kkvY4lMs0DB/KiaUyliFzH8vlqBsGDjOfRKKAOT8Yafql1Do0unQ3ry2l+ZpDYtbi ZE8iZMr5/wC7PLqMHoCcdKhit9WvvDl/ZXmn6zNcFlaF9Rms0fdkBWRrclRsID5ZcgjjOAB2VFAH nMPhO6tJvD2pz+HbS/1Gxs57echoy/2lpEdbje/O3csrZ5dTNnaSSK1dEsdam8WTarqFrdx2/wBm eGNb6SAvCWdW2ReTkGMgDJclsovqa7GigBqghRnrS80tFACc0c0tFKwCc0c0tFFgE5o5paKLAY3i S1vtQ05NOs4UeO8lWG7laXZ5VucmRhjksQNoA7uD0BrlZfDWo/8ACV3l3b6MiSS6pa3MGp+ei+VA kUCzJtHzDfskTAGDuycADPodFMDzq38OeJF1LxE8MMdnNdW97GmofaM/apJHBtW2jJXyYwU5HH8O RzVeTwdPfaXfRjwva2VmLiwmg0uR4pN8kMu6eQYOwF4zsBJBbB3YBr02igCtYQpBYQRRWwtY1jUJ bgKBCABhMLxx0449Ksc0tFACc0c0tFKwCc0c0tFFgOb8V6BNrz6NAjzxQx3ryXEtvKI3jjNtOmQe vLOo45+b0qjqGl+IJ/Bt3pFva2cN3B5KW7RkCC4iVlLLsG0ruUMpTIXkYbBOOyopgeceGfCurLrd ldavp8EVnbLdNb26QxxR2xY2vlqsSySAcxytwxAPPBIp/h/wpP4fTw5MtgttIulRwamyyglrgSW2 wMcneR+/APIAyAQCK9EqrqH/AB7L/wBdov8A0YtTLYa3JqwPHX/JPfEv/YKuv/RTVv1geOv+Se+J f+wVdf8AopqCj4jNFFFUQFe2/Ab/AJFzx5/16Rf+gT14lXtvwG/5Fzx5/wBekX/oE9NboT2PQrvq 31NVYvun61au+rfU1Vi+6frXtLY8lny1RRRXiHrhXr37Of8AyUK//wCwVJ/6NiryGvXv2c/+ShX/ AP2CpP8A0bFSYI+narn/AJCkH/XGT/0JKsVXP/IUg/64yf8AoSVDLLlFFFaEBRRRQAUUVRudS8i6 NtHaT3Eiosj+WUAUMWA++y9drdPSgC9RWb/as3/QJvP+/kH/AMcqxZXq3qy/upIXify5I5NuVO0M OVJHRgeD3oAtVgeKfEcnhm0gu/scdxBJJ5LZuBGyyMPkwCMFSfvHI2j5sEA436q3Wm2N9Ikl3ZW1 w8auiNLErlVcYcAkcBhwR3HWgDCk8VXNvrcWi3GnQjUZpIBGiXRZGjdXaRwxQH5PKkGMc4Tld/GR pvjXU7pdQ1K5t7G3tRpen3tpbyXbbQJ3mBLuIdwchVGwK3KgA/Ma7OPStOhmt5o7C1SW2i8mB1hU NFH/AHFOPlXgcDjiqi+F/D6W91bpoWmLBdlTcxi0jCzbTld4xhsHkZ6UAc9beIrrX9Lu7qe+l8PJ p90bafyIvMkmYxxOm3z4VYZ8zG3y8scY6jPS6C+oyaJbPqyBb0hi4wAdu47NwHAbbt3AcBs44qq3 gvwq8CQN4Z0ZoUZnWM2ERVWYAEgbeCQqgn/ZHpWpY2FnplnHZ2FpBaWsedkMEYjRckk4UcDJJP40 AWKKKKACiiigAooooAKKKKACiiigAqrqH/Hsv/XaL/0YtWqq6h/x7L/12i/9GLUy+FjW4zUf+QZd /wDXF/8A0E1jeJ9eudGuo3hXdb2thealdIpG6VYVULFyDjcZN2ev7vHOTWzqP/IMu/8Ari//AKCa mextJJZpZLWB5JohDK7Rgl4xnCse6/M3B45PrSjuxvY4278W6zpF7rcmpWFuwtbXTzb2drO8wLz3 E0W4sIQ+ThMqFb7vGSaYnxDvFWOO50B4LqcyR20cjyxLPIGt1RV82FH2sbg5bZx5T8MOa6eDwxoF rbXNtb6HpkVvdAC4ijtI1WUAkjcAMNgk9fU0tr4a0GySJLTRNNgSGUzxLFaooSQjaXGBw2ABkc4F WSYtz4mvrKz1TX3hSbSLecQJCJAr7I2ZZZV+X52LnaqZAIQEHLYK/wDCX30eoaHYzaPD52sIJIDD eGRFAO6TLCPHyxlWGOGJKg8bj0X9lad9ntbf7Ba+TaMr20fkrthZeFKDGFI7EdKS30jTLQ25ttOt ITbBxB5cCr5Qc5cLgfLuIBOOuOaAOSsfFur3t5p15Pa2Nlp13odzqUUbXhYMVNuUMrGIGLaJGB27 hyTzgVDF4ru9e+1wyXj+H0sPIuJLi2jaVrmOXzkWNBcQLyXRTlUbd90HJOOqg8MeH7V7h7fQ9Mia 4jaKdo7SNTKjY3K2B8wOBkHg4qAeC/Cot2gHhrRhC7K7R/YItrMoIUkbcZAZsem4+tAFrQX1GTRL Z9WQLekMXGADt3HZuA4Dbdu4DgNnHFaVV7Gws9Ms47OwtILS1jzshgjEaLkknCjgZJJ/GrFABRRR QAVzXjC91Syt7V9PkuoY9zmSS1tRcMWCEojKQcRk53NkYwoyAxI6WqGpaHpGsmE6ppVjfGHPlG6t 0l8vOM7dwOM4HT0FAHD6p4t1yDQIfEIhu4c2EN5BYwWvnQz5jDyLLJtzGQSVHK9ARvJ2jovGt/qV jp1jHpLyrc3V6kG23VGndNrMwiEg8vdhCSXwAoY9QK0ZvDOg3F+L+bRNNkvQVYXD2kZkBUAA7iM5 AUAemB6VNe6LpWpwSQ3+mWV3FJIJXSeBZFZwoUMQRyQABnrgYoA5Eax4hm8I6Hqn9oQQTDUoLa/j FtueQNeJAUJOAjAFg+FPzZ2kAAnpvEmp3Gk6HLd2kcTz+ZFChlJCIZJFj3tjnau7cR3Cnkdatw6X p9vYxWMNhaxWcTK8dukKrGjK29SFAwCGAYehGetTzwRXMEkE8SSwyKUeORQysp4IIPBFAHMJPqmi +JdMsr3UdSv7fUGaISy29sIFlEckm1dhWRTiMnlXHQZzyOW0PX/FJ07w1qV1LrLRX7WguZr9LEWh Eu0Ep5A81SSwCbgBkqGxzXe2XhTw5pt5HeWHh/SrW6jzsngs40dcjBwwGRwSPoajtvBvhezuY7m1 8N6PBcRMHjlisYlZGHQghcg0AbdFFFABRRRQAUUUUAZWuXPkQW8ZOEml2OxOMDaSPzIA/GsueU21 rK624lkjUssRONxAyB0NdBf6faanaPa3tvHPA4wySKGB/A1zb+ELqHKWGqeXD/DHPF5m36EEE/jm hbgzkE8d3c1wCuiQRRxthZhdklT2AHljJPpnpmvQvFGoXOn+Cda1K0k8q6t9OnnhfaG2OsbMpweD ggdaxtK+HGkWV899exx3ly7+Yd8Y2Bs5BC+3brjtXXz28FzbSW08MctvKhjkikUMrqRgqQeCCOMV rVlCUvcVkRTU0vfd2UNe1BtM0+KdQ5L3tpB8jAHEtxHGeoPHz88ZI6EHkcvqPj7UNNsJtSl0S1aw W4v7eJlv281mtUuGyyeVhQ32ZhwxxuHWunsvDWg6akiWGiabapI8busFqiBmRtyE4HJVuQex5FWJ dJ02e3+zzafaSQb5JPLeFSu6QMHOCMZYSPk997Z6msizO1DX57W81a1trOKaTT7GC9zLc+Usgdpg VztO3AhJyeDuwduM1P4c1l/EGjpqf2ZYIJ2Y26+bvcx5wC4wNjdcrk47nOQCDwv4ftbae2t9C0yK C42+dFHaRqsm05XcAMHBJIz0Jq/b2drZmY21tDAZpDLL5SBfMc9WbHUnA5PNAHM2WqaxP8PND12N /tN4LGC8u4gig3SmIGRRgcNzuGMcqBwCar+JvEd7Jper3Og3aRwabpUt890qq++RoXaJAGBHA2yH /gA5DGuh03w1oOjXDXGl6JptjOyFGktbVImK5BwSoBxkA49hU1vomk2mnzafbaZZQ2U+7zreO3VY 5Nww25QMHI4OetAHHX/izVZrHQ1sHijuFubMauxAPl77lbd4QpB5L+bzngRnHUGu/qoNL09TMRYW oM0qzykQr+8kUgq7ccsCoIJ5BA9Kt0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFVdQ/49l/67Rf+jFq1VXUP+PZf+u0X/oxamXwsa3JqwPHX/JPfEv/AGCr r/0U1b9YHjr/AJJ74l/7BV1/6Kago+I6KKKogK9t+A3/ACLnjz/r0i/9AnrxKvbfgN/yLnjz/r0i /wDQJ6a3QnsehXfVvqaqxfdP1q1d9W+pqrF90/WvaWx5LPlqiiivEPXCvXv2c/8AkoV//wBgqT/0 bFXkNevfs5/8lCv/APsFSf8Ao2KkwR9O1XP/ACFIP+uMn/oSVYquf+QpB/1xk/8AQkqGWXKKKK0I CiiigCnqd5JY2XnQwpNIZYolR3KDLuqZJAPTdnp2rIL6t/aE90bOx/exRxbDdPxsLnOfL/2/0rR1 1JW0smGNpHjmhl2qpYkLKrHgcngHgVkrrVyFIOnS9f8AnwuDxn/doAfJqd3bXcMNxp8JEqOwMVwz kbWQcjYOPnznParnh+c3L6nMYzHuul+Q9R+4irAvrbUPEF1bCPTIGWBHLC8jliQbjH0Locn5WHA6 c8dK3fDOlXOk2NxFdR2sbyTeYEtmLKB5aL3VcElScY70Acn/AMJrrr3FyIDbTSjULm0trE6NdIJj HM6Kv2veYgxVMk7cA5GODWjqvj+20vxU+nzXmlxW1tNFbXEM1yFumeUIyuiE8oodc8c5bkbTnpjo mmNpk2myWUUtlPJJLLBMPMV2kkMjkhs9XYn27YwKbZaBpVhptxp8Fmhtblna4SYmUzl+GMhckvkc fMTwAOgAoAwb7xDrEmryaZYPYwSHWxp6TT27yhY/sAuiSokXLbsjOQMdia1/D+o3162p2uoi3N1p 12LZpbdWVJQYY5QwViSvEoGMnp15qJvBuhtaJbLb3ESRzpcI0N7NHIsiwiAMHVw3+qAXrz3ySTWj pmk2Wj27wWMRRXcySM8jSPI5AG5nYlmOABkknAHpQBdooooAKKKKACiiigAooooAKKKKACiiigAq rqH/AB7L/wBdov8A0YtWqq6h/wAey/8AXaL/ANGLUy+FjW4zUf8AkGXf/XF//QTS3WpQ2l9ZWbK7 TXbOECAfKqqWZ2yeFHA78svrSaj/AMgy7/64v/6CazNb8OvrtxfCeVI4JdKm0+Fl5dTOf3rEemEi xz2alHdjexZs/E+kX91eRWt7BLFaW8dzLdJKjQhXaVfvg9QYWznpx74sR63pM1qt1Fqlk9u0LzrK twhQxoQHcHONq5GT0GRmuRuvBmpawmtHUotNtjfW9jHHFZyyBS1tLJJ8zhVYBsoMryo4H3QTX/4V zJcmyaeK0hjN7JLqFu13NeC4hbyW2mSYbmYvbQ5yANuR9bJO1h1mzuNbuNJjkzcwRLKwyMEHqBzk lQUJ4wPMTnmmSeI9DieFH1iwV5oDcRJ9pTdJEFLF1Gcsu0E5HGAa5fVfh+2o+HbeFWtIdYa5knu7 tU+/9oBS5VWxnBjYhc/3I84wMY2reFZb3xv/AGLbaSIdGn82Wa7W3KeShsDaCONgNm3lflyDkH5c DNAHaweKopIJLifStUtLYRiSGWeFcTgkKqqFYsGJZQFYKTnp1q7pWsx6o9xCbW5s7u3K+dbXIUOg YZU5UspBweQT0I6giuYtPBs1vb3G3R/Dtu/2cQC2t4itvdHerGSUBBtI2fLjdsLE5NanhXw3Jo11 qGoXKRx3V8I0aOO6luQqR7tuZZcM5y7ckDAwAOKAOlooooAKKKKACsvWdch0YQB7W6upJdzeVaoH dY1GXkIJHyjgcZOWUAHNalc34t0C411LRba2sJWjLgyXMssbRBlxlTHy6/3ozhW4yRigCW48XafA RIkVzcWSqjz3sCq0MAcAqXOQ33WVjtBwCCcCrus6zHo1vA7W1zdz3Mwgt7a2VTJK5BbA3EKMKrMS SBhTXI6j8P2urWPRorWxXTPs8Nq90LmWOZo0RU+eJRslbC/KzH5eODjnb8W6Dc+IbG3i+x6ddLa3 yXC2t65MNygQqQ5CHaQXJGAwyi54JAAF/wCE0sXgje1stQu3MbyzQwxLvt1R2Ri4ZhyHR1wuSSpw DitebVrGDR/7We4X7D5QmEqgncpGQQByc5GAOTkVyul+FNY8OxI2ktpxlmtjbzRyF0jgHnSyoY8K SwTznXacbgAcitqTw1F/wh9roEM5QWcNulvMy7trwFWjYr3+ZFJGeelAE1hrkt7dLBNomq2SuCY5 biOMo2OedjsU/wCBhfTrxWdp/jaO9tdPvZdD1az0/UPJ+z3c/kMh83AjyI5WZdxZRyo5IzioRoWq 6l4o0nV9T07RbebTndvtdtI0s8ymKRBHlo1KJmUtjc3I/GsLRfh5Pa2uh20/h/w3Y3GmtbPJqllI XuJmiKknHkp9/ackscbj1PNAHpdFFFABRRRQAUUUUAYPiFEvLix06ZImt5Ga4mWU8MI9uBjofndD z6VyvjPw/Z3GhN9g0qwk8tmeeGFUV5Y9jDC4HJ3FW299uK6XxAty2t6YLSSKOXyZsGVC6n54ewI7 4P4Vy1v50ijbBZx98NZuOhz/AM9PWlJXVjSlU9nNTSvY4qHw5fT6pANK0mGJxtZJ3ie3aB8ffDsg 6N0A5I7dRXts+uQWnhWTX50c28Nkb2RIuWKhN5C5xk46Zx+Fcwi6kWQCeyXJGCLd+On/AE0+la0m my6z8MX0u2ZEmvdGNvEZSdoZ4do3EDOMnnApQioxUUXXxFSvLmm7mzcajDbalZ2UquHuw4ikwNhZ Ru2ZzncV3EcdEb05zfEHi7TvDfmG9S4dYo45JmhUMIlklWJC2SOrMTxnhG9ADFd6dqniDSrm21ax 06yuIystjNbXbXJimXJWT5ok2lTt6ZyCRx3ozeD5r/w9PBfpZSalqF/bXeouMlHSOeN/LBxkqsab FyBnqcZNUYGzq3iWy0fVNO06eO5lub/zTEsEe/HlxtIcjOeQpAABJP40abr4vr8WNxpt9p1y8TTx R3YjzLGpUMy7HYDBdMg4PzDisC38JavaiwvmubS91a1u3lM07MokiS1mghQsFJ6yK7cYBeQjPAN/ w3pmsW+pTX2uafphvpYdj38F480h5BEaq0KbIxycBjyMncSWoA6AX9myxlbuAiWVoYyJB88i7tyj 1YbHyOo2n0NZs3izRhama0vodRbesaQ2MqTO7MWCgAHHJR+SQPkbJGDjnNU8AQzan4gvisZtLuxu Ps8EEQMkVzPGEnkUcDcyxpg5ySz5xnnIs/D994tv73Ur/QrGFYRZeRa3drIsFw8S3CurLJGrY2zj DbCAQMbtuSAdrL4qjit4nOkao0xiM09ssSebbRgkbnG7B5VsBSxbBKgitu3uIru2iuYJFkhlQSRu vRlIyCPwrh5/B2oHTLS1js9JaT7OY5ZftM0JgLOzmNdgHmwLvwsTFRgc9eOx0rT4tI0ey02Akw2d vHbxlupVFCjP4CgC3RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABVXUP+PZf+u0X/oxatVV1D/j2X/rtF/6MWpl8LGtyasDx1/yT3xL/wBgq6/9FNW/WB46/wCS e+Jf+wVdf+imoKPiOiiiqICvbfgN/wAi548/69Iv/QJ68Sr234Df8i548/69Iv8A0Cemt0J7HoV3 1b6mqsX3T9atXfVvqaqxfdP1r2lseSz5aooorxD1wr179nP/AJKFf/8AYKk/9GxV5DXr37Of/JQr /wD7BUn/AKNipMEfTtVz/wAhSD/rjJ/6ElWKrn/kKQf9cZP/AEJKhllyiiitCArN0bXLPXIrp7V/ mtbua0mjJG5HjkZDkDpnbuHsRWlXMeGfCEOiajqOq3Plzald3FwVmAz5Vu87yrGpwD/HluvzdyAK ANjWrqez0e5mtVVrnaEgDttBkYhVycHHzEdjXMazoEUXh2ZbTTYZrtFQNJ9nVpnXcN7AkcuV3EHq TW74pMw0P/R0R5jdWwRXYqpPnx9SAf5Vw6LBLPK4061eTzG3ZumPzZ5/5ZetJq6KhLlkna9ji7lb bYkcFnpTu7mN49qrOvAx/Dv3dRjO4EdOa9i8D3N/N4Wto9UR0vbb91IrnLgYDJu4HzbGXPGSeaxg 97x/oFt1H/L23qv/AEy9/wCdbXhNpzHqYuIo42+2KFEchcY8iLHJUc/hUUoKMbde+v8Awx04vFzx EtdF0Wmnztc2bXULS906PUIJla1kj8xZGBUBcZyQcEY7g8jvUUmsWMWhPrUkxXT0tjdNK0bAiILu LbcbunOMZ9qwLvwxeS6jPZwi0Hh6+uEu7uJmIk3jl41TbtKSMsZbLDrJwd1Y8vgLUH/4SERx6ZDJ qFlqVslwjt5lwbmQPEZvkGBGMoMFuDx6Voch6LRXGX3h/XJtT1GOCLTjYXusWWomd7p1lRYfs25f LERBJ+znHzj7wqvZ/DjTv7cjv9T0rR7sM+pPOZLdZGkae6WWEncvJWMMuT0zgZBzQB3dU77VLLTZ LNLycQteXAtrfIPzylWYLx0yFbr6Y6kV5rqfwz1W8s9IhJspzaaNbae+Z44zHJGGDPG8lrMwzuGG XYflHtjuPE3h1PEn9lwTrE9pb3Ty3CP1Km3miG3j7waRSOmMZ6gUAaN1q1jZajYafcXAS71BnW1i 2kmQopdugwMKM84q7XG2nhbVJdX0nWNVlsptStLoGWWPP+oW2miCrlRy0kpcjgDOMnaM4Wk/DvVU g1WLUrbQo4r6bTma2s1AgK29yZJBsEKcMh2gNvJxgtjGAD0+iuA1TwNcLpmpWOkadoX2a61VLuK2 niURxRfZo422KYnRZC6MfuEbWPc1xOs6E/h7Rb3Tr620K81G50ueGzjlnxLE0k9yw+zgQAMxE6KQ ojAKDgAigD3WivPdS8C3954+bXcWslu15b3CuZo0liWNYwVGbZ3wSjHCyoCGI4ySZ7P4cad/bkd/ qelaPdhn1J5zJbrI0jT3Sywk7l5KxhlyemcDIOaAO7orynU/hnqt5Z6RCTZTm00a2098zxxmOSMM GeN5LWZhncMMuw/KPbHRz+B4rrxVLrFxaadN52pmaRpIw0j2psPs5iJK8gyfNtJ24568UAdXYX1v qenW1/ZyeZa3USTQvtI3IwBU4PIyCOtWK5zwNoMvhrwraaXPYadaTwoiStYMWW4dUVTKxKId7bec g9uTXR0AFVdQ/wCPZf8ArtF/6MWrVVdQ/wCPZf8ArtF/6MWpl8LGtxmo/wDIMu/+uL/+gmrtUtR/ 5Bl3/wBcX/8AQTWD4jnum1nfYwfaptJ025vkgPQ3LDZAOOuQLgfjSjuxvY6uivLYtavI7nxPf6Pr CazOmnacqXkiqioDPcB2JRCuEDM2QpxtwQSDlY/E/iZrXT4be/s757+S4sILu1kWeMSnynSVpPJR WKRi5PyptO0A85xZJ6jRXnN1rGraWD4wgthd2+pv9litQ3zeWQBaNnbkbpC2R2Fx3K1R1nXvE9nr dvoses51UwywR2a26YvCLB5BcbtuR/pA24XA+Xp1oA9UoryfThZQ6VePaf2Qp+yI15f2pliKZljz Bcn5mLsu8GU/MoySo7v0xpb9rrSrG00630LVbuC0QafdtNbEBJZLgxkxoPmjjRCFGMsTnOaAPVaK 898Py6jp95p7JqLPY3+v6paNZGFAiASXcoYNjdu3ReuMN0yM1nR+KtdntYRb6wGu7g2ovU8iM/2V PJeQRGDAUZyskow5Lfu8gjIoA9Torz433iCyur15NfluYdO1uz08RyW0INxHObfcZCqj5h9o427f ucg5qTSdf1y48ezWN3eaelv9oniGnm4zOkSbvLkEYhBG4BTuaUqQ3ABwKAO9ooooAKK8z+IbaT51 2tlbaXL4jaP5JLi4dL2Ntq+X9lXYxZj/ALJVQ3XPzY3/ABxNp8tlYJqUkL6PFqkKaoHYFEXYTGJP QeaYCc8YIzxQB1tFeVW39n7Yx4r3/wBnfYpP7J+1bt3/AB8TbduefO8n7Nt/j64711d1/bX/AAri 183z/wC1Pslt9t8nPm4+Tz9mOd+3zMY5zjHNAHVUV59pd74Yt/F+mW/hmw0iUXAdLi4sborcQkRu xM8Sp8y/Kq5kbO5xxkZrjPC0tg+l+Ek0nTvCseoq9j582mX+/UGTKeYZI1hGON3mBmIA3ck4NAHu lFFFABRRRQAUUUUAU7/TtNvgkmo2VrcCEEo1xEr7M9cZHGcD8qxmsNBJPk+HtPcerWyLn/x01b8S zG3soJmXdCkwMvsuCM/gSD+FUHknezlNm0bTGM+WxOQGxxnvjNHWwm7K5Zg0rw5OwifQtOR24Cta xkN+OK3Yoo4IUhhjWOKNQqIgwqgcAADoK8Zn8SeJJLyKyljs2mkcK1uDlg2evCnGDk5ODwPqPR/G 5J+HHiMt1/si5z/35atKtJ03ZsmE1PY6KiuS1HWNO1JE1zw7qFjqlzpG5riKzuVkLwODvT5c4J2B lHdowPWrWgS/27qE3iM7TaNGbbTsHOYQ2Xl6ceYVXHX5UQ9zWZZ0dFFFABRRRQAUUUUAFFcP8Sns 47fw81/BpU9qNVO+PVphFbN/otxjexVgOcY+U84HHWq2l6ho9r4W1e88Px+GLC/iKEpoE8d0spz+ 6R9saHLtuQDGeTtOTwAeg0V5lJM95qHhzV9Z165toZtMvIbpYVjRPOMsLNbDMe/J2umAQ/7kbSG3 E2fCLWDeN5joVtpEOlCylV20i4Miu/mR7DONiqsu3dgZY/fyTxQB6JRRRQAUUUUAFFFFABRRRQAU Vj+Jbu5g0sWunkDUb9/stqxOAjsCS/Q/dUM/vtx3rjraG78PX+ryaXfNBYWuu6fY/YfKRkkSSGyh JZiNwIVwRgjlec54APSaK82u/FWtxL4vMd3+8sLG/mWLyV/0B4uLfnHzeamZcNnpxxxUutXfiTSj 4i2eI5ZBpOlJqqbrSEeY58/MR+XiP9x2+f5/vccgHolFcPaa9q0nxPvtKe/szYRyiNbN5MTBPsyS eYqCLON7MN7SbeoC5HPcUAFFFFABRRRQAUVynjUX7XXhpdLa3W+OpyCFrgExqfsdzyQOTxmqUl7c 6V4Q1SWwgCeIIZI1vmuZd7BmZQZi+z5kCFnUhMALjaMFQAdxVXUP+PZf+u0X/oxa4fw3rWt6prGl WkutWlxbGO8lkmsnScXCxPa7AZPJRScyupKKBg/3hkN8PanrU8XhttS1Vr5dX0mO/kRoI4xFIslr 93YAcETnOc8jjA4qZfCxrc9ArA8df8k98S/9gq6/9FNW/WB46/5J74l/7BV1/wCimoKPiOiiiqIC vbfgN/yLnjz/AK9Iv/QJ68Sr234Df8i548/69Iv/AECemt0J7HoV31b6mqsX3T9atXfVvqaqxfdP 1r2lseSz5aooorxD1wr179nP/koV/wD9gqT/ANGxV5DXr37Of/JQr/8A7BUn/o2KkwR9O1XP/IUg /wCuMn/oSVYquf8AkKQf9cZP/QkqGWXKKKK0ICiiigCtfWFrqVs1vdxCWJirbT2KsGUgjkEEAg9i KwdS0LRtL068vzbXLC3heZh9umGdoJxnd7V0rE5464rl4La41rQo3vL66Md/bjzo18oLtdeV/wBX nGCR1qZJtabgZw04OCTo0eQMn/icXJ6d+E6cCuh8NQ266U0lvaLau9xL5yiUylpEYxFi55bhBjPY Adq5mbSb/Th5FtE4sGniUbp02liyqMgR7uuBke5rstG06PSdJgso+RGCWOfvOxLMfxYk/jWFGGIU r1Z3Lk4taIu59qXqK4e2WPVJtXv9R1i8tLizvpYljivWhjtY0bCbkyFbcgWQlw33+PSpn8Tatb+I r1Zksf7EttQj0922us0TPDDIrk5wyl5SmMLjKnJwQekg7KmGQ88Dg+tcK/ivXbq7sVtTpFnb6hBd 3dtJd72PkRGHYW5XlhI7nH3VIPO0hpvBWq6prV5ql/O0UVrLJA62LKxkgZ7S3fh84KZZhgIOcnPJ FAHa7jnHH50iybmIx075/wA/5BrzybTtV1PxL4jMED3MEF4kSBvEV5ZCMfZoGKiOFWX7zE5yCdx4 p0/iK7svF+svDE88On2d9IlrHMwE7JDYSDIJIBzIyjaMDceCScgHolFcLYeJfFE2jalJeWFhbX0S QvameaNI38wkEFUlk6Y+Ull3lsfLgmtvwnq99qtjdjU1jS9tLk28yJF5exgqtgrvcZwwOQzAgjnq AAbxAIwelJsGMceoyO9OooAKKKKACiiigAooooAKq6h/x7L/ANdov/Ri1aqrqH/Hsv8A12i/9GLU y+FjW4zUf+QZd/8AXF//AEE1dqlqP/IMu/8Ari//AKCaq6tr0Wk31vDMiiFra4u7iZnwIYYQu5sY O45kTjjjJzxgqO7G9jXormIfGcZuNRju9KvbP7Fb20oSbb5srTySIiKqkryUXB3dXwdpBpZPG+n2 6yrc2l7BcwwTSy2zKhkRozEPL+VipdvPi24JB3dRVknTVlnw9pTa8uttaBtQQELKXYhcrtLBc7Q2 0bd2M44ziqaeK7ca7dWE8BhtoQ4S8ZwUd40V5Fx2wHHPOdj9NvOdd/EfTbNInk0/UvLe3aZ5fLQJ C62zXPlOd2Q/lrnABHI5oA7GiuKs/G1/c6fdXkmmWCpEiFFW9mDMXdVVm326Yi5JMi7gApxmrI8X 3UUl/ZXOn2h1W2a2VLe2vjKkhnZlQFzGpUjYzH5ThRnmgDrKKxLbxPa3OriwFtdKjzSW8V2yr5Ms 0YJeNTu3ZXa/VQDsbBOKw5fiTCdMsby00HVJjffZnto5PKiMsUsiRlxl8fK0iLg4yXX+ElwAdvRU cEjTW8UrwyQO6BmikKlkJH3TtJGR04JHoTUlABRRXN+KfEl7oE9kttpa3MM6StNczPMkVvtKYDtH DJtzuY5baAEPNAHSUVxU/ji8GtSaXbafp7z2/lJcvLezLEkjorgB1t2Xb84AZym49BXS61eXmn6c 91ZwWcpiy8v2y6a3RIwCWbcsbnjA4x0zzxyAaFFchH4q1qS2t2OiWFtcNYi9njvNSaJY0LMAFbyT uICgtkLtLKOc5rTk8SRf8Ija6/BbtILyK3e3gLbSzzlFjUntlnUE4OKANyiudtNev11630nVY9Bt LidDIkEOsNLcOoB5WJoULD5Wyc8YPpXPaN8TX1caUY4NCkk1BoQLS01oz3UQcruLReSMbFLM2W42 kZoA9DooooAKKKKACiiigBskaSoUkRXRhgqwyDWFL4M0F3Lx2K27Hr9mYxZ4x/AR2wPwrQ1S7e1i iSLG+Z9gYn7vylsj34/WsaWWCC2muZ13LGhdzjcSAMn60eQN21NGw8L6JpkwntdNt1nGcTGMNJz1 +Y89h3rXrz1PG+mw3GLMy+bydhQhWx1z6fWux1vVRo/hvUdYEPnCzs5bryt23fsQttzg4zjGcGql CUNJKxMZRl8LNGis7UtUbTbzT1kgBtbqbyHn34MTsP3eVxyGPy5yMErwc8EOqNc69dafDAGhtIkM 9xv+7K3IjC45O3DE5GNy8HPElGjRRRQAUUUUAFFFFABRXP8AizxL/wAIza2Eu2x/0u7+zeZf3v2W GL91JJuaTY2P9XtAxyWFQaZ4ra60a91a4XS57O2YAyaNqP24Du5b92mNqkMQMkjPHQEA6eiuVfxj czalp1ppvh+8ul1C0muoJ3miiQBHRAWBbcEIkViQCwDLhWO4LJoviifU/EFxpEsGmtJbxu08mn6g bkQOrqojkzGm1zl+OT8hoA6aiiigAooooAKKKKACiiigAoqnquoR6TpN1fyqXS3iZ9i9XIHCj3Jw B7msseKo4r6OyurGdJA8UF1PEVeC3uJApWIsSGJO5cEJj5lzjNAHQUVxt18Q7aLTtduINI1CSbSk uXWOUJGt0Ld9krRtuPyq2MkjODwpPFdVY3Et3ZxzzWU9lI2cwTlC6YJHJRmXnrwT19eKALFFFFAB RRRQAUUUUAFFYniTxLa+GI7Ce8Qm3ubloHdckx4hlkBCgEsSYwuOPve2KVNcnt9Hl1PU7KO3hJT7 PHBcefJIHIVFPyhQ5ZlGAzDJ+9jmgDaqrqH/AB7L/wBdov8A0YtZFv4utrjU7XTP7Pvkv5zKJIGE ebcx+Vu8whyv3ZkYbScj3wDUsPGFr4gis0isNQtBeQw3tq11GiiaLzIwxG1iQQZEznH3gRkc1Mvh Y1udRWB46/5J74l/7BV1/wCimrfrA8df8k98S/8AYKuv/RTUFHxHRRRVEBXtvwG/5Fzx5/16Rf8A oE9eJV7b8Bv+Rc8ef9ekX/oE9NboT2PQrvq31NVYvun61au+rfU1Vi+6frXtLY8lny1RRRXiHrhX r37Of/JQr/8A7BUn/o2KvIa9e/Zz/wCShX//AGCpP/RsVJgj6dquf+QpB/1xk/8AQkqxVc/8hSD/ AK4yf+hJUMsuUUUVoQFFFFADHXPb8a4vTtG8VafaxWkf9miCCMRRKl5IgCLwvy+VxwBx2966+8u0 srcyujvyqqiYyxZgoAyQOSR3rMOvqJ/s8ljNFdsSY7WS4txJIoJG4DzDxx/+qgTdjLXR9cu5Y01E 2ZgWeGZtty0mdkiuODGOhTjnvmuuX7orgtQmkuJL+3uprosdXshChl2eWm613AFe+ZjwD2yCDzXe R/cHQfSm1YSdyncaLpV3fxX9zpllNeRf6u4kgVpE+jEZFUtU8O2urGSKZXW1mk33VvGEWO8O1QPN 43HAVRwRkKAcgAVlf8JZqS293qc+i240e2up4JJ4b4vMqxTNE0hjMYAHyFjhzgep4rXm8U6Pa3F7 bz3Lo9ihe4YwSbFwgkID7drNsIbaCTjnFIoL3w7pmp3tpcXtnDcJbQSwJBLGrx4domyVIxkGJcHt WiLG0W8N4trALox+UZxGN+zOdu7rjPOKzptes49XtNNSWNriaRFKktwGjldSCFKkkQvxkcZOfuhn ReJtInhvJorotHZnErCJ8HkgbOPnBIIBXIJBA54oA044IIXmkjijjaZt8rKoBdtoXLHudqqMnsAO 1RDT7Fbt7pbS3Fy+4PKI13tuCA5OMnIjjB9Qi+gqOw1S21S1+0WjSFCSuJYmiZW9GRwGU+xA4weh FYdj4tivNG1i/wDsjIdOv57LytwJmkjfYu04HLkjjsWx70AbEGhaNbWtxa2+lWEVvckmeGO3RUlJ 67gBhvxqxY6fZaZara6fZ29pbr92K3jEaD6AACuftPG+lDRdL1C+8yzN9YxXrRpDJMsCOoILui4V e25to4/LUj8RaZJrkujLM4vYjtKtC6qW2K5VXI2swV1YgEkA5xwaANWisTS/F2h6zE0tle7ohALn fJE8atER98FgMgdCR0PBxTB4y0TyElNxOoknFuiPayrIzlS6gIV3EFVYg4wccGgDeooooAKKKKAC iiigAqrqH/Hsv/XaL/0YtWqq6h/x7L/12i/9GLUy+FjW4zUf+QZd/wDXF/8A0E1Dd6DYahd3VxeR mf7TZmxZHxtWJiS4HGRuyN3POxfSptR/5Bl3/wBcX/8AQTVmSeGF4kllRGmfZGrMAXbBbA9ThScD sD6Uo7sb2OcbwNp9zb6lDqV3e6l/aMEMEzXbRthYWd4yAEAyC/cEHAyCck17L4beHrJdP2wl3sbx r2N/Kij3SFQvKxoq4+SNsAD5o1PbnqxPC1w9ussZnRFd4ww3KrEhSR1AJVgD32n0qSrJOcvfBGi6 h4dtNDuoWktbaZJwx273cNlmY4wS+XD8ch26ZrL1Pwbdal43t794rddGEjvdwG7LC5LWrQZMPlYD YYLnzMbV6ZPHZieFrh7cSoZ0RXaMMNyqSQCR1AJVsH2PpUlAGBH4UhS3ljfVNSlkMIghnkkQyW8e QdqELyCVXO7cWwASRUOkeBtI0Z7eW3DmeG4+0eaY4kLt5ckYBVEVVUCVyAoXlie5zrW2uaTeS3MV rqllPJbZM6RXCMYsddwB+X8afBq2m3OnPqNvqFpLYorM1zHMrRqF+8SwOAB39KAM+28LWdtrA1Bb i6ZEmluYbRmXyYZpARJIo27tzbn6sR87YAzWPovgCK08P2FpqV9dT3ltYwW8brIpW1aMxuTCSgOP MiRvnDfcUYwMV2mcjIooAZCjRwxxvK8rKoBkcAM5A6nAAyfYAe1PqOOeGZ5kiljd4X2SqrAlG2hs N6HaynB7EHvUlABWdquknVPJxqN/ZiPcGFpIFEqsMFWyD+BGGHYjJrRooAwJfCGnPK/kST2trMiR 3NnAVENwqKFUOCpIG0BTtK5UAHIGKvano0GsWUtneySSW8k8MxjIXAEbo4T7vKEpyDkkMwyBjDrj XNItNQi0+51SyhvZceXbSXCLI+emFJyasXt9aabaPd311Ba2yY3zTyBEXJAGWPAySB9TQBj+IPCd p4kmhe8urpY4wP3KeWUOCTkb0Yo3P3kKt78CtG40bTrnRv7IltI/7PEaxLAo2qirjbtx90rgEEcg gEdKddatptkkD3eoWlulwQsLSzKgkJ6Bcnn8KuE4GTQBg23hjy9QtLu71nU7/wCxu0ltFctFtjYo yZ+RFZjtdh8xPX1qnYeB4LS2020uNZ1O/sdNMRtbW5EARDFjyzlIlY7cDq3OOc1tWOu6PqlxLb6f qtjdzRf6yO3uEkZPqASRUFj4q8O6pdLa6fr+l3dw3KxW95HI5+gBJoA16KKKACiiigAooooAo6tp iarZGBmKMDujcdUYdCK5uXTfEsdu0QtNKvOSCZLh4wy+pAjbn25+tdbcXCW0JkfOOgA6k+lZ51O4 k/1ccScfxEt/hQBw2lfDW6k1dL3VodNt4ImzFb2eWwBnALFF4GT/APWr0HU9Lg1XQ7zSJi6W93bP bOYiAyo6lTtyCAcHjiok1Qo6rPGFUnBdT0/D0q9PPDa28txcSxwwRIXklkYKqKBkkk8AAc5q5zlN 3kxKKjsZI8Oi40290/VtUvNXtrtAjJeRwDYOeV8uNOc4OTnBUEYq1oujW2h6eLS2LyFnaWWeXBkn kY5Z3IAyxPt6DoBVwzwrcJbtKgndWdYyw3MoIBIHUgFlyfcetDTwrcJbtKgmdWdIyw3Mq4BIHUgb lyfcetQMkooooAKKKKACiiigDL1rRRrIsmW/u7GeyuPtEM9qIywby3jIIkRlIKyN29KgHh+aXT7u xv8AXdTv4bkKrecIEKqD8ygxxJww4OcnHQg81f1LVtN0a3W41TULSxgZwiyXUyxKWwTgFiBnAJx7 Go9M13R9b83+ydVsb/yceZ9kuEl2ZzjO0nGcHr6GgCgPCdpFa2EFteXtt9hikt4JIXUOIHK5hyVO FGxACMMNg+bOSZdN8ORWGpnUp7+81C98k26TXfl5jjJDFRsRQclVOTk8DmtWS6t4plhkniSVkaRU ZwGKLgM2PQblye24etVtO1rStX83+zNTs73yjiT7NOsmw+h2k4oAvUUUUAFFFFABRRRQAUUUUAU9 Q0y31NrT7TuZLa4W4WPja7qDt3AjnBIYdPmVT2rPuPC1nc6wdQa4ulR5o7ma0Vl8maaMARyMNu7c u1OjAfIuQcVuVHBPDdW8dxbypNDKoeOSNgyup5BBHBB9aAOV0jwNbwJqx1SaW8bUZL5PKMmY4YLi ZnZE4BG4bC2SfmHBxXT2dvJa2kcEt3NdugwZpwu9+e+1VHtwB0qeigAooooAKKKKACiiigCne6bD fXWnXErSB7C4NxEFIwWMUkWG46bZGPGOQPoc2bwfo8+j3+jmALpl4wc2iqvlRMCG3IuMDLAMRyMj OOTnaknhheFJZY0eZ9kSswBdtpbC+p2qxwOwJ7UkdzBNNLDHNG8sJAlRXBZCRkBh2yOeaAMDw/4I 0rw3cRT2JkEkazqf3cUav5phLErGiqCPIQDAHfOc5py+G7PS7bRfIknb+yrVNPg3sDujMkGS2AMt +5XkYHJ46Y6Kquof8ey/9dov/Ri1MvhY1uTVgeOv+Se+Jf8AsFXX/opq36wPHX/JPfEv/YKuv/RT UFHxHRRRVEBXtvwG/wCRc8ef9ekX/oE9eJV7b8Bv+Rc8ef8AXpF/6BPTW6E9j0K76t9TVWL7p+tW rvq31NVYvun617S2PJZ8tUUUV4h64V69+zn/AMlCv/8AsFSf+jYq8hr179nP/koV/wD9gqT/ANGx UmCPp2q5/wCQpB/1xk/9CSrFVz/yFIP+uMn/AKElQyy5RRRWhAUUUUAZHiQumlLJHGrst3asQzYG BOhJzjsMn/DrXJXehaDquvrrt1obS3SfI24/I+OASCDnjtnGB0rsdem8jQtQlEcchjtpJAkgBBKq SAQR0NeWwX8z5mt9Ft7nyZ5ECyx2qo5RypHEYYcqefx5xzcFN6xJk4r4jstL03Rv7bto4fD+n2oS GSXK2kakOGjwwwowcs345rsl+6K830nxTc2dyA3gu0sYX3b3s7yNnPGeF2KCM46sPxxXe6XqEWqa el3ArqjMy7XxkFWKkHBI6g0ShNfEhRlF7HODwhqDwXWm3GsW76Nc3U9xJbx2JWV1lmeVo2kMhBUl ypwgyoxx1qePwbEvjC6112sJBO/mEPp6tOD5KwlfOJJCbVJwFByx+bBIPS7+cAZI60NJt7frUFnJ aL4AtdDWwFvdbmtNQe7LNEN0ieTJBHFnORsR1APOdnQZ4l/4QsS+Gp/D93ex3OnKIlsontVxCsTB kDjP73lVBzgELjGSSeo384x696fQBieHPD0egae9uq2Cs8xlYWFitrECQBwgJ7KOSST9OKybD4e2 FprP9oSSJMGup7yWHyAFknaZ5IpDyfmjWVlB6nCnjaBXY0UAeeal8L/7R0Sz0t9TgeO30mPTd1xY iXYVUjzogXAjckjJwThVAIxmtSw8MXjeLtS1O8kjSzTUBd2cKR/M7/ZIoS5YMcL/AKxdmAe5JBFd fRQBwmgeBrh/DNlZ+ILnzCuijTPIjjCNAkiIJVZwxDkFFCsAMYz8x5qzpXgKPTb60ug+lxG3u1uC mn6WlqsgWGaIBtrEk/vs56fLgAZNdlRQAUUUUAFFFFABRRRQAVV1D/j2X/rtF/6MWrVVdQ/49l/6 7Rf+jFqZfCxrcZqP/IMu/wDri/8A6CawfEWi6nq2ryz2cUEL22j3UFjeSSfMt1PtAIABKBBGMt38 zAHBre1H/kGXf/XF/wD0E1dpR3Y3seZnwxqzW3iD+x9Bi0Zbq0sY4LaaVHSUxTStMpWNsDcjYxkB t+SQS2KkHhLxRLHaxtY2cFncSXFpcWybbYWlnKbZm2Rq8q8+RKu0P1mB4Gcer0VZJ51deG/EMVqP EOl2FjF4qvZJFu1acARwyoERTIF+bytkLEY52Pt5YZwPEPhlz4ntNFs7e3MsizWdhfm5Utaxf2ZJ GIXQfMvz/vMgEfMO5xXslVhp1iNROoiyt/txj8v7T5S+bs/u7sZxwOPagDgbfwzfjSZbX+wpkt47 VE+z3F7HM7TLJG4MLHKrENhOxtisQo2KM02x8La5qOrXF5rdhai01O6tTeW4ijQ+XbrM6s6Kzgky GBfvuSF5IGAPSaKAPP5PC11Do/zaOl75muXV3f2Rkj3Xds01wY1yx2tgyRybGIHBzgkiqWqeGPEk /h/SLeKwikmhF4IYjeYGnSyPm1l3Y+byY8oduTzwCOa9NooA5fQ/D8Gk+LtevV0W3ja/mFxFqEUc YOwxxK8THh8mRHkPBU7s53EiuooooAKKKKAOG8Z6Rqms/aNPsdJlEU5UySq9uLa74Xi53DzgBtI/ d8479ANPxXZXd9/Zdzb6QL/+zNUS5a1keNTOnlOm+Pcdu5GlDAMV5jOP4SemooA820nwpf6DLNNJ 4YsL+O8s5LUWsMse21V7m4m8o7wo8orMinbn/V/dIxW7N4ZvG+G+n+HiLWe6tbezjlSViIZ/JaMu hO0na4Qr908N07V1lFAHHQw6ze+J9IuF0m50yys96zxTm0eEr5bgeUU3ShtzJ3QbVPHPPN6J4c8S NYeGLC+tdXK6Y9q00WovY/ZE8oAHyzBmUlcZTd1IG7vXqtFABRRRQAUUUUAFFFFAGN4jiu2s4ZrS Bbh4JPMaJm27xtIIBweeeK53+0bTUbO4gW4WJnRoznO9MjHIxkEV3dZV9a6HcSk3tnZzyDgl4BIR +ho2dxNXPGtLsdX1HXXs4V85kdkaRZWMaDPXlRnv+nXt7B4osLnUfBGs6dax+bd3GmzwRJuA3O0b KBk4AySOtaFjHYxQhLGKCONf4IkCgfgOlWq1q1XVd2RTpqCsjmL2O91+BLpdDudN1PTZVnspL54D vPIdAYpH2hlyjZx94EZxxa0HT7hru61zVLRINTvAqCLcrtbQKPli3Dg/NuY44y3fArdorI0Ciiig AooooAKKKKAOX8aWOpXaaLNpkd88lpqBmkNg1uJkQ280eV8/92eXUHPYnHNQRwapf+GtQsb2w1qe 4ZkML6lLZRvuJGGRrckKIyA+Su703dB19FAHnQ8IMr6Be33hey1O6tLK4tLlZBExedpI3Wcs+fkL LK2eXXzvuklq0vD+l6mfGE+sXtjc28H2RreJb17cvDmRW8uIQcGPA6ud3yr712dFABRRRQAUUUUA FFFFABRRRQBjeJrO81TSxpdtAjw30ggvHeTaI7Yg+YQMZYlRsAHd89BWtDDHbwxwwxpHFGoRERQF VRwAAOgFPooAKKKKACiiigAooooAKKKKAOc8WaFPr76LBHJcRQxXzyXE1vKI5I4zbTpkHryzqvHP zfiMy50XWV8D32h2GnabZ3MTx+SbcBbe7jEis+YxtKM6hgyZAy2N+CSO2ooA868L+FtUTW9Pu9W0 6CG0tlvGgt44o4o7YsbTy1EaySAfNFK4wxAPPBwKXw94Tl8PReG5EsFtXXSY7fVGV1Je4ElrsDYJ 3EYmAIyAOM4xXolVdQ/49l/67Rf+jFqZfCxrcmrA8df8k98S/wDYKuv/AEU1b9YHjr/knviX/sFX X/opqCj4joooqiAr234Df8i548/69Iv/AECevEq9t+A3/IuePP8Ar0i/9AnprdCex6Fd9W+pqrF9 0/WrV31b6mqsX3T9a9pbHks+WqKKK8Q9cK9e/Zz/AOShX/8A2CpP/RsVeQ169+zn/wAlCv8A/sFS f+jYqTBH07Vc/wDIUg/64yf+hJViq5/5CkH/AFxk/wDQkqGWXKKKK0ICk70tFAGP4pVn8K6uiruZ 7KZQMc5KEV5NaX9nbLcRiS12/aZ5PlkUgK0zkdBxwRxXs+oTR21jcXEu8RxRs7lGwQoBJwfwrzDU bHRNQuUll1HWrdUlDqJ72KW3U7hjfGsm4rntW1Cr7K+lzGrTc7WZm/2nas7I5tvLPDAvyePTHfp1 r07weGHhezLqVZy8hBPPzOzc/nXJaR4S0O4vneHxZNLeMxYw6beJFHjOT+6Ut3r0O0t1trZYlLEL 3Zsk/U06tf2itYKVHkd73PMdQ0XV7Lwd4ol0/T5Z21JtUS4swGEjs88wjmjXHPyFcj+JQpGSBu1b XwxLeeOda1drTRgE1KF43vdJMs7Kttb5MU29dozkA7ThgTzyK74IoOQME0BFAwAAPbisDY8y1HTo dN1+eaw8Ox6heSTvILe90liXMhyxS8VSqISScPkjO35RgV6fSBVAwBge1LQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAVV1D/j2X/rtF/wCjFq1VXUP+PZf+u0X/AKMWpl8LGtxmo/8AIMu/+uL/APoJ rG8T69c6NdRvCu63tbC81K6RSN0qwqoWLkHG4ybs9f3eOcmtnUf+QZd/9cX/APQTT3060kubi4kg V5LiFYJd+SGjBYhcHjHztn1zz0FKO7G9jkLvxbrOkXutyalYW7C1tdPNvZ2s7zAvPcTRbiwhD5OE yoVvu8ZJpifEO8VY47nQHgupzJHbRyPLEs8ga3VFXzYUfaxuDltnHlPww5robbwjolpFdxx2jsLy JIp2luJJGdULFBuZiRtLtgg5HGOgw+Hwto8H2Ui1eR7W4a6hkmnklcSlChYu7FmO045J6D0GLJMG 68ZT6ZdXOp3sS/2E7TW1syv83mwK7McbefMKOo+b/lmmAS/EOqePtT0xblpdBt8W/mQyAXzFxOti bzaF8rBTA2bsg55211Uvh/Sp9JttLls0eytmiaKJiTtMbBkOc5OCo6nnnOcmse58FRXfjqDxJPdh kgRglqIiAWaMxksd21htLdV3cj5sACgDNsLvxZbiaO+ujNqFxaG4t7dRE6AB0DshVVwyh/8AVszg kriTqahtvE+rSz32h2813LdSSQRWF9f2gt5AZVlZ2ZNgB2LA7DKDdwMY+Y9RF4T0WG0ntUtZPJmV UYNcSMUVTlVQlsxqDyAuAD0qaz8O6ZYeUYIJN8UxuBJJPJI7SFDHuZ2Ys52sR8xOB9BQBi/8JVrC 63PpkmhQQuDMLTz7uRWu9isV2EQGPLAAld+VBJx8uDUtfiMt/rljp9nphlivyi21wZ8Bm8tJZQRt ONkcgPXkgjjBro4fDelQasdTjgk+072kXdcSNGjsCGZYy2xWIJBIAPJ9aS18L6LZNatbWCRm0uZb qAqzfJLKGDnrzkOwweBxgDAwAcunxHmC6g0ul28iWulXWoxy21zM0Uwg2ZVXeBFIO/7yFsY56iul 0jV7+71a+03UbC2tZ7aCGcG3umnV0kMijkxpggxHjB6jms+68A6M+lX9rYxvazXWnz6fHM00kogi lUAqqM+AoKqQowBjjGTW3pmi2Gjib7FCyGZgzl5GkJwMAAsSQoHAUcDsBQBfooooA858TeIPEdpq 2sS6fJP9j0zyvmiSE2seUV3+0lx5vAbd+5zhSp65FdR4nur6NdKsrC6NnLqF+tu10qKzQoEeVsBg VJYRbBkcb89qmvvC2j6jfNeXNq7SybfNVZ5Ejm29PMjVgsmOnzA8VY1HRbHVrWW2vY5ZIpJkn4nk VkdCpUoysCmCoPykd/U5AOS0zWNd8QTTWa6lHp8lhbu7zxRKwuZFuJ4QSHBxHi33ELg/vBhhjnXm 8R3h8AWOvQ20SXd5BasI5WPlwtOyKWbuVTfuPTIU8jrV258KaJdQW0D2QSO3jMMawyPF+7PVG2kb lOOVbIPcVqSWtvNaNaSQRvbOhjaFlBQrjG0jpjHGKAOZSfVNF8S6ZZXuo6lf2+oM0Qllt7YQLKI5 JNq7CsinEZPKuOgznkctoev+KTp3hrUrqXWWiv2tBczX6WItCJdoJTyB5qklgE3ADJUNjmu6svCm kWF7Ddww3DzQZMPn3k0yw5BU7FdyqcEj5QOCRUWn+C9E002ot4rxo7Xb9nhuNQuJ4otv3dscjsox gY44xxQBv0UUUAFFFFABRRRQBla5c+RBbxk4SaXY7E4wNpI/MgD8ay55TbWsrrbiWSNSyxE43EDI HQ1v6hp9tqdm9rdIWifrtYqR7gggg+4rnZPCV9Cvl2OtTCEcKlzulK/RtwJ/EmjqD2OPTx3dzXAK 6JBFHG2FmF2SVPYAeWMk+mema9C8Uahc6f4J1rUrSTyrq306eeF9obY6xsynB4OCB1rH074eafBe re389xe3CSGRA0rhEJz0XPTnocjp6CuqvrG21LTbnT7uPzLW5haCWPcRuRgVIyORwT0rWrKEn7is iKaml77uZ2vX11pLWupK4bTon8u9jOBtRyoEoOM/IeSMgbSx6gUWF9danrt48ThNMsy1sAMEzzfK WbOOAnKcHkl89BUtp4esLO2urdTe3EN0myVLy+nuQVwQQPNdtuQTnGM9+gq1p2nWuk6fDY2UXlW8 IIRSxY8nJJJJJJJJJJJJNZFlqiiigAooooAKKKKAMnxANYNgg0XZ53mDzsyKknl4OfLLKy787fvD GM8jg1iWXiK402HZqEl5K0dzBFcrqCxRT2ySkokhMQ8uRC4ABXGMNknGK6e/0+21O28i6jZkB3KU dkZD6qykMp5PIIPNZ48KaL/Zd7pz2rzW98my5M9xJLJKMYAMjMX47c8dsUAc9pnxG/tbRBqNvYW0 Wy0W4uBc3bosTtMYljyIixJ2OR8uThRj5siWy8c6hfwRJDosK30mqnTRFNcywoCLU3O/LwBwMDbg xjPUHGK3R4U0Nba+t0sFSK+kSW4COylnQKEYEHKkbFI24wRnrzVG48C6TILSOASwwxX5v5x50rPN J9neEHzC+5WwytuBzlPU5oA1NB1STWNKF3NbrbzCaaCSJJPMUNFK8ZwxC5BKEg4HBrTqvZWVtp1l FZ2kQigiXaigk/mTyT3JPJNWKACiiigAooooAKKKKAKGtXt5p+kT3Vhp51C5j2lbYSbC4LAMc4PQ EnABJxgcmuZ/4T57fTPt9/YW8cYaeN1huJC0cscPmiN1khjZWYB+o7LjO7jrL+xttTspLO7jLwSY 3AMVPByCCCCCCAcg54rO/wCET0Q6b/Z8lmZrc3KXTedNJI7yqQVdnZizH5VHJPAx04oA5+Dx/d3G m3Vz/ZNtBNa3YsZYZ7yTJuAGLxp5cLs5GEIwvIYnjbzPY+M9S1WLTVsNFtvtN2l67x3V5JCsYtp1 hPJhLZYvnDKpGMEZrbuPC2j3KXCvauhnu/trvDPJE/n7BHvVlYFSUG07SMgnPU5z5fAejyXFiEje KytIbqNbeOWRSWnkjkZg4YMBlGBXoQ5HTggG1oupDWdB07VFiMS3ttHcCMnJTeobGfbNXqZFFHBC kMSKkaKFRFGAoHAAHpT6ACiiigAooooA53xVqup6XLog0q3+1TXN+0L2xdUEyi2ncLvYHb8yKcjn 5cd8Go3iS60/wfL4gn/02aWWJFs4kZVgd5Fi8v5UaQlWb5vlLEg4Ufdrpbixt7ue0mnj3yWkpmgO 4jY5RoyeOvyuw59fXFQS6Np8yXqSWwKXpBuF3EB2AADYzw3A+YYPA54FAHPaN4w1LVdStbCTQTay y+e7NNJNEPLiMGWQSwo7Z8/HKqMoRnByItM8V6hrC6Ot7pVraQ6rZJqNu8N60zBRJb/K6mJMHE69 CehrodP8O6ZplxHcW0MvnxrIglluJJXIkKF8s7EsT5UfJyRtwMVDJomnWFtpv2a38v8As+KOytfn Y+XCZIsryef9UnJyfl68nMy+FjW5rVgeOv8AknviX/sFXX/opq36wPHX/JPfEv8A2Crr/wBFNQUf EdFFFUQFe2/Ab/kXPHn/AF6Rf+gT14lXtvwG/wCRc8ef9ekX/oE9NboT2PQrvq31NVYvun61au+r fU1Vi+6frXtLY8lny1RRRXiHrhXr37Of/JQr/wD7BUn/AKNiryGvXv2c/wDkoV//ANgqT/0bFSYI +narn/kKQf8AXGT/ANCSrFVz/wAhSD/rjJ/6ElQyy5RRRWhAUhpaKAMfxQSvhXWHwzbbGY4U4J+R q8ns9PiuhcyzzXvmG8uQdt9LgATOB91wBwBXsep2iX2nXFpIrMk8TRMFfaSGGDg9jXk+o+HfEVlI y2+k6nJA8xMlzFdQSBQzklhGArHr7munDVIwvzMwrRlK3KMGmwRMkkb6hvT5lcX8wZSQRwfMz3Pc da9K8HSyzeGLeSZp2ZpZiDPJ5j7fNfaC2Tn5cd68xtvDuv3t27Lo2sS2u4qk7XMVoxXJGfLYlhxz 1/LpXreiWhstIt7Yhl8sbcM+8j6nvVYirGcbRYUqc4u8jgrvx1rMAvbnEckdvfz262o0i5jVkjne Mf6YX8kEquSxAUEnPQitq38WTx6zqVhcaPeFk1QafaeW0ZMn+i+fuO6U9lY5OBhk4yGA0JvA+izC 6RhqAhu3keeBdTuVicyMWf8AdiTbglmJGMHJ4q8vhzTl1RtQELC4a4FyD5z7VlEJh3Bc7QfLYr05 4PUCuQ3OQt/iJc25mudW0K/htpLmeC1O62RVMUpjZXla4C7iV6YUcMAXxuPfWc/2q1jnMTxGRFYx uykrkA4JUkE84yCR6E1lS+FtPlgEBN5HCJJpfLt7+eEFpXMjltjjdliTzwMnAFadhYW+m2VvZ2qG O3t4liiTcTtRQABkkk8Ack0AWaKKKACiiigAooooAKKKKACiiigAooooAKq6h/x7L/12i/8ARi1a qrqH/Hsv/XaL/wBGLUy+FjW4zUf+QZd/9cX/APQTS3WpQ2l9ZWbK7TXbOECAfKqqWZ2yeFHA78sv rSaj/wAgy7/64v8A+gms3WfD8utXd6ZLgQxSaXNYQPGTvRpiPMYj22RY5/vdKUd2N7Fiz8T6Rf3V 5Fa3sEsVpbx3Mt0kqNCFdpV++D1BhbOenHvixHrekzWq3UWqWT27QvOsq3CFDGhAdwc42rkZPQZG a5OfwfquqDWnv10+0a+trKJI7KaQAtbyyPhnCqwDBlXK8gZH8IJg/wCFf3Vx9haVorVPtUpvoVv7 i5M1u4iYp5svzEs9vEDwo2lh65sk7KHWbO41u40mOTNzBEsrDIwQeoHOSVBQnjA8xOeaZJ4j0OJ4 UfWLBXmgNxEn2lN0kQUsXUZyy7QTkcYBrnNR8E3l5oduIL/7Nrb3DTXd2kr4YTAJOqnrgJgJwMGO PpjIwNW8L3F742j0O30yRNGlEry3vlMDbxmwa1CI5+Ur8ynbnduyduBuoA7aDxVFJBJcT6VqlpbC MSQyzwricEhVVQrFgxLKArBSc9OtOHiq1XT7+4ubS8tp7EKZbOVV84lvuBdrFW3ngYbGeCQQaw7T wdewWVwgtNMgbyFiWC3uJliuZA6t58hADJJ8nysNzKSTubil03wVdR6lFqF5JhnvIZp7c6jcXSiO FJfLUPL8z4lkD4wqjaOMjkA1tM8deGdUspbuHWrBIoppIX8y6jGCrOAeGPDCJ3U91GfXF9fEmhOS F1rTiVgNyQLpOIQMmTr9zHO7pWLD4YvVu9PjmWzksrHWrjU0cuxd1mW5OChXAZZJ1x8xyFzweKw/ Engq6j8D3kVnb273MU+rXhS3Ql5Unhu1jRQFyz/vohj/AGcAnAyAeg2eoWWoJI9ldwXKxSGOQwyB wjjqpweCPSrFYGg6ReWWo319epZwtPFBbxw2ZYxhIt+H5Awx34xzgKoycZrfoAKKKKAMLVvE6aPL ObjSdSeytlD3F9HGnkxLjJY5cMwA5JVWxz6Grms6xFotpHM9vcXMk0yQQ29sFMkrseg3EDgZYkkY Ck9qwfFvh3VvEpkscWy2LKVjnW/uIXhyBktCg2TEEZG8gD06509f0/Ur5bS4sVtReaffJc2yzysE lXYY3DkKSp2ySAYDchT3IABC/jKxMMMlpaX16XhNxJHbxDfBGGKkuGIwQysNoyxKtgHFas2rWMGj /wBrPcL9h8oTCVQTuUjIIA5OcjAHJyK5qz8M6zokjXOmT2M11dwNHdm4LoiyNNLN5iABsgNPINpx kbfmGK1ZPDUf/CH2ugQ3DILOG3S3mZclXhKtGxGeRuRSRnnkUATWGuS3t0sE2iarZK4JjluI4yjY 552OxT/gYX068Vnaf42jvbXT72XQ9Ws9P1Dyfs93P5DIfNwI8iOVmXcWUcqOSM4psWl+IbzxJp2o 37W1nFabhKtnqVxIl0pR1CtCVWNfmcNuO5vkAzXO6L4A1W3tdCtL1IohpjWzm4j168uQ5i2k7bd1 WNA20juFDcDgUAemUUUUAFFFFABRRRQBWvbsWcIbaWZ22oo7nBP8gaymuZpQXkuGVcZO1toAqzr1 lcXlkptD/pELiSME4DEcYP1BI/GuZuLxzBLa6houpwrIhRwkfmqwK88oxx1Io66g720NpdejtW+e 5jnjzyokXcB6jnn6Vq6rqcOj6LfarcK7wWdvJcyLGAWKopYgZIGcD1FeQ2PgfUNQ1OBYtOvYLJW5 u57ja5UY42hgefcHvzg8+qeIdLm1bwjquk27os93YTW0bSEhQzxlQSQCcZPoa0qRhF+47kQcn8Ss WrjUYbbUrOylVw92HEUmBsLKN2zOc7iu4jjojenIdRh/tgaYqu0/kfaHZQNsa7tq7jnOWO7HH8Dd Mc5NzYavrul3NvqdrZafcoVksZ7O9knMcozhzmKPGDjjncCwPHW14f0u4sLee51F45NUvJDLdPG7 Mg67UQtg7FXAHAzycZJrMs2KKKKACiiigAooooAy9a1oaMLJVsLu+nvbj7PDBamMMW8t5CSZHVQA sbd/Siy1iSeOSTUNLu9IRWRFa+lgxIzHACmOR+c4HOMlhjNZ/jDRL3WodLNisbvZ3v2h0a+lsyy+ TLHhZYlLqcyA8DkAg9arQaJq0nhrU9JmtLaD7UNiPLq9xqBAb5XYtMgYbQAVUHBP93qQC7feNdA0 /VrfTZtQgN1cQyyxIkqMWKOsflgZyZGYsFUAklHHUYqfTfEK32o/YLjTL/TrpoWniju1j/exqVDM pR2HBZcg4PzDisq18O6tpkWiPZGwa402yn0/EruEaN2iKy9CS37lSVOMlm+fjJfofh7UIPE82uag sUErwPCYotQnuw5d1fcPNAEQG0gIgx8x9BQB1dFFFABRRRQAUUUUAFFFFAEdxcRWttLcTuI4YkLy O3RVAySfwrntI8eeHtXN1GuoQWs9qyLNBdTxrIhZYzyAxxhpVjP+2CvXro67pkmsWkNiWUWckw+2 LuKs8QBOwY/vMFBHHylqxtS8M3t5PqkKizkstQ1Ky1BjK7bgYWtw8ZTaQQUgJBz1bBGOaANuy8Ra Jqc6wWGsafdTOhkWOC6SRioOCwAOcZ4zU1jq+maoXGn6jaXZRVZ/s86ybQwypOCcAjkeorAXwtcJ 4k/tJDarH/bRv8DIbyjYfZyvT7xk+bGcY5zniqHw/wBA1Kz03QbrULe3sxaaMlqkMQZZHL+W7GVS o2spTGMnlnPGcUAd1RRRQAUUUUAFFFFAFK+1S3064sIZw+b2doI2GMKwiklJYk8DbE3ryR9Qyz1m 1vbSe9TdHYxZK3UuEjkUDJdSTnb/ALRAB6jI5qj4m8OReJDpMNykclnbXjT3MTsy70ME0eBj/akX jI4B+hq6h4avL7w3e6HJdmSDzI3tJZJ5BKVV1fy5HHzdV27wdxU88jLAGzFrmkTR20kWq2MiXWfs 7JcIRNhgp2HPzfMyjjuwHeqx1rStUhMenanZXjpJA7rbzrIVVnUqSFJwCOQe9YugeErnT9btNSuI beLyo7vdGL6e7cSSm3Ct5k3LfLC+fugZGAeTUem+FZ9FtvDBb7KDpulrYXPk5/eStLbHcvAyuYpD k4PzDjk4mXwsa3OyrA8df8k98S/9gq6/9FNW/WB46/5J74l/7BV1/wCimoKPiOiiiqICvbfgN/yL njz/AK9Iv/QJ68Sr234Df8i548/69Iv/AECemt0J7HY6/eG0aIAzjeW/1Twr0x18wj17fj2qeL7p +tWrvq31NVYvun617S2PJZ8tUUUV4h64V69+zn/yUK//AOwVJ/6NiryGvXv2c/8AkoV//wBgqT/0 bFSYI+narn/kKQf9cZP/AEJKsVXb/kKQf9cJf/QkqWWXKKQUoqyAo70UnegDM8QTyW/h/U5onKSR 2kro6ttKsFJBzXl1rqGsTNNPBeXygXEsY36lI2NkjL02lf4fevT/ABJDNceG9Ut4IzJLNaSxom8L uYqQBkkAcnvXj0WpTWPmxPYXDvJdTMirdW8jkvKzYCrKSeveujDwjP4jGrKSdkdPZ+JPEtreLJcS i7h5JhldFB4PRliBBBx68A9677RdUbVtKS7aA27GSSNoy+7aUcoee/3c14/FqcjXbWkljcwSqRG8 dxPEjDrjKtKD+hNeqeEbbyfDNkksLJIAxZXkDkFiSfmBIPX1q8RTpxXu7ipOo37xo2OpRajbtPak PGskkOeh3xuUcc9cMrDPfHpg1a3kNg4zXnFr4GggubWyPhy3jtY9anurmVBEsdxA6XRiUgEMwXzU Tay8AkDK5NZepeFZtC8O6/drp5gifSNainZZtwKb1+yDG7oIVIHHyjjg8VyG56lfalb6davc3Mmy FccqhcsSQoCquSxJIAABJJA71Nb3AuI1kUMFZQwDIVYAjPIPIPI4IyK87n8HtqMN4reH4oraW90+ QWM8kcys8c+bifJJGWjYqSfmZV+YZbFaPhbw5No3jPVJ7bS2stMkR1BeVGVmymzygp3BNoOVcfLw qYXigDuaKKKACiiigAooooAKKKKACiiigAooooAKq6h/x7L/ANdov/Ri1aqrqH/Hsv8A12i/9GLU y+FjW4zUf+QZd/8AXF//AEE1dqlqP/IMu/8Ari//AKCawvEN9qCayw02Oad9O0q5vDAjlVknbCwI wBG7O2bjpkA9cUo7sb2OqorzCPxJfQ/8JJdabrVxrqW1hYNHKix/u9804mZVG2MsqgnJx9wBidpq G28Z6/dx2kdkbqaG9muNOtbuQW0jGXbA6TOYiY8Iv2o/LwfLGRmrJPVaK88uvEGrabCPFaQ3l5Ya hIbeCwVlOFYKttIAThd7g5xzidcj5BjN1rX/ABPZ61Bo0WrltV8mWGKyW3jH20iweUXAbbkf6QNu AQPl6daAPVaK8r0+dU0e/lXWZpyLeN57mPUrwpbgyJugk8yRjHIwyPMUKVG4kJgZfo+pXWqTz2en NqMGkahdW1tb3E2pm5cFVmluCkvmMcFI0UbHIBbOQQwAB6jRXC2PiyabV9L0lr8NfnXL23u4Ng3L bqt00Ibj5cqkJB4LAdT81c/Z+MdauI3t49Yml1Ay2qTOsVs9vAz3kETKu3EiZWRgElXdgEggrQB6 1RTIkaOFEeV5WVQDI4AZyO5wAMn2AFPoAKKKKACivM9dluz4y1Fb+9lSJHhGn2EV9c28t6hjXcIv KlRSwffnIY9M7Fwa6LxnfwQ22ntNfSW+nR6lHFqc1vctC0KNG2wM6MGQGRoM8jhueDQB1VFeW2d2 qFT4l1DV7Swa0c6Y5vp4Xm/0mfAJVwzymH7MQrZY5PfNdPdPra/DazaRLo6qbW1+2iA/vwCU+0FM H74XzCMc5AxzigDq6K8/0vU9Gj8XaZa6HdyanFPvWZz4guriS2IjdiZLdyyhflVcswIZxgcc8l4X 1aW8tvDAi1Nbm8ne0N0bXxPc3tzjKs5ktWwiAkYfk7VLYBoA9tooooAKKKKACiiigBHdY0LuQqgZ JPaqP9qQsTiGVh2OBz+Zqr4kn+zWkEzh/ISbMxU9F2kAn2BIP4ZrOklnaxmaz2vN5beVyCN2OM/j ihb2B6I34dQhllEeGjY/dDgfN9MVbrxZ/FHiCXUo7CeHa8p27E2b1bnAOGypBA5/L29K8XXNxbfD /XrqGSSC5j0u4kSRGKsjiJiCCOhB7itKtJ03ZsiE1PVG/RXJ6jr1lfwprHh3VIdVbSnD3drp94sv mQsCGBUNgsAC655JQgHk1b8P3cmu31zrqvOunOogsEMhCSxg5afaDg7m4UnnaoIxuNZlnQ0UUUAF FFFABRRRQAUVxfxGvTZ2mhlruO2gl1PZM0uqSafGy/Z52AeeP5lG5VIHcgDvVLS9VtYfC2r3mmav aSX8JQhLXXpdYUnP7tD5vKmRtyYUAnjByBgA9BorzZr+5u7jw/qGqeJNRsbK60+6W8hhMcS/aBJE fs/ClhJgyoNp8weV8pDFi1nwlepdeM7lLC8e50yO1kKvDq81/GzGRNvmmU/upNo4Rc8F8ngZAPQK KKKACiiigAooooAKKKKACisfxLe3FtpYtrHd/aF+/wBltSuPkdgSX57IoZz/ALuOprmbrxLJo91e 6L/aLi7i1fTrezjm/eStaSG1V2JIJYEtOC7ZO44znFAHfUV5lceLtWil8axC/la406xvZ7fZDC0N v5YHlc/fD4OSsikNhip2jB9GtIpobVEuLhriYcvIVAySc8AADA6DvgDOTzQBPRRRQAUUUUAFFFFA BRXMeMZtVjm8PxaNPHDdz6i8Y84t5bD7JcNhwv3gCobHqorOk1S40rwfqlzZxaodXgeP7ZBd3Amm i3MoaRAzeUF2FnXbtTjBAwQADuKq6h/x7L/12i/9GLXCeF/Emra9ren2y3862AW8cyyC2eS6WI2m 0lot0fWaRDsIyB2bkL4e1PWp4vDbalqrXy6vpMd/IjQRxiKRZLX7uwA4InOc55HGBxUy+FjW56BW B46/5J74l/7BV1/6Kat+sDx1/wAk98S/9gq6/wDRTUFHxHRRRVEBXtvwG/5Fzx5/16Rf+gT14lXt vwG/5Fzx5/16Rf8AoE9NboT2PQrvq31NVYvun61au+rfU1Vi+6frXtLY8lny1RRRXiHrhXr37Of/ ACUK/wD+wVJ/6NiryGvXv2c/+ShX/wD2CpP/AEbFSYI+narP/wAhOD/rhL/NKs1Wf/kJwf8AXCX+ aVLKLgoFApRVkhRRRQA1huBHPPocVzureHdGeKW8v1vBHD++Zo76ddu3ncArjBGM8VratPLBYBoZ DG7zQxbwASoeRUJGQRnDHqK4vxdf3FrF/ZxvdSkWZR9oYiDasLblPIUHOQBxnAOaunBzkoomcuWL ZlQyaPp93HLa+G9WVbhv9ZNqs5dn2/dzvZCeDwXHT3r0fR763vtPWW3EiqrGMrJyylTgg8n09TXl emWN1q1+ILSG5llRXdJhOBAQdocg5zkZToDtBI5zXqOh6SNI0xbdpPMlZjJK+TgseuPYcAfSt8RT pw+HcxozqS32NOiuEutUuI/hx4oJvpV1KKXU4IT5pEqSNNL9nVTnIO1otgHYrjtV1PEWqjxm9g62 baYdS/s1FWNhMrfYhdby24qR95cbR2OTXKdB11FcRZ+NLy703SJo47GW6u/Ds2qzQiTywsyCDau4 thELSSAlum3rwapx+MvEg0aYSaZG+rHVUsIkSKMBVa3Wfcym4KNwSBiUZyvQ8UAeh0VyC+JNXntN KTybKxvLiG5nuGumEkSiBlVkBjkIVm3Z+820K2QxFUvtNzdfCTw3LLeXfn3aaQk86XDpK4kmgWT9 4pDZYMwJBzyaAO8orinvT4X1bUobKe91GzttJlvpraa5a4eGVCNih3Jb94N/BJ/1fGMnNKPxzrWm aeuoa/psX2YzSQFbURmQOYo5IQQs0gG8l0HOSWjOFBoA9CoriLbxDrKJcWs8dpFqcmqQ2Jkbe8EL tZRTMxUv03FlCqygkr3JJi1Txb4hsb2K0tbGz1A29v8AabyeBo0icea6bVMs6eWR5Zyf3m0kAjuQ DvKK43UfEutWXiv7KbW2TR1u7e1MxCyMzShcZKy7ozubABiIPB3AHI7KgAooooAKKKKACquof8ey /wDXaL/0YtWqq6h/x7L/ANdov/Ri1MvhY1uM1H/kGXf/AFxf/wBBNXapaj/yDLv/AK4v/wCgmqes eIItHv7W3lgZopILi7uLguFW3ghVSzkdWO50AAHcnPGCo7sb2NmiuYh8Zxm41GO70q9s/sVvbShJ tvmytPJIiIqqSvJRcHd1fB2kGlk8b6fbrKtzaXsFzDBNLLbMqGRGjMQ8v5WKl28+LbgkHd1FWSdN WZJ4f0+bWodXlF093C5eINeTGKNihjJWLdsB2kjIXuT1JNZ6eLrf/hIrvTZ7SaC1gRtt+7L5UsiK HlQAHI2qy8nqQ4/h5o3XxG0yzETy6fqYheBpZJREm2BltjcmJ/nyH8pc4AI5HNAHY0VxVj48nurK 6vZdGMcEUaSRqs58whnCqXDogC85LqXQBWO7jmaTxtPAmp2s2jmTWLIwKlna3aSJcNOWEYWQ7SvK sW3KCoBOCMZAOvorn4/F9nPbW0ltZ31xJPaG68iGMNIgDqmxhnhtzEenyPkgCiDxbbzNbQnTr+K6 m1D+zntpBHvhk8kzEuQ5Xb5Y3ZUt1GATQB0FFFFABRRWTrupahpkCzWWnwXMSq8lxLcXYt0hRRnO drEk9hgDg5I7gGtRXGTeO7gWV9qUHh66fTtNhjlvmlmSOZN0KTMqR5IYojqW3MvcLuNbfiDWbjSI rFLKwN9e312trBCZhEudrOzM5BwqojtwCTgADmgDYorj7Xxre6oxh0rw5PLdQQtLdw3F1HF5RWaW Hy1ILB3LwSY6LgAlhnFaz+JrUeFbTxBHb3EsF3HbvBAoUSuZiqxrywUEl1HLYHrQBtUVzlp4kuhr 1vpGq2um2dzcxmSGGLVFln2gE5aJlQ4+VuU3jg9gTWBonxOGrPpA+z6PIdSMYFtYawLm6g3jOZIj GuAo+983GD1oA9CooooAKKKKACiiigBskaSxlJFDKwwQe9YE3grRZUKKl3Cm7cFgvZowPoFYYHsO K09Uu2tYY1jz5kz+WpHbgkn8gaxbieKO1lnuTJIkUbO2SWOAM96LX0Bu2rLek+D9D0W4a4s7RvPY kmWaZ5WyevLsa3a8+j8d6dHcolu90SOdhX5cd8812Gt6qNH8N6jrAh84WdnLdeVu279iFtucHGcY zg1c4zi/fRMZRkvdNGis3UdWbTb/AE+KW1ZrS7kMLXSuMQyHHlhlPOGOVyOjbRjnIItWa48QT6ZB as8VrEGuLreAqSNgrEB1LbfmPQAFeu7iCjSooooAKKKKACiiigAorn/FniX/AIRm1sJdtj/pd39m 8y/vfssMX7qSTc0mxsf6vaBjksKg0zxW11o17q1wulz2dswBk0bUftwHdy37tMbVIYgZJGeOgIB0 9FcrJ4znfUdOtrDw7qN5Ff2k13FKskMfyo6KDtdwdpEitnqAy4BO4K/QPFcura7d6RPaWaz20ZeV 7G+F0kLBtvlynapSTOflwfutzxQB09FFFABRRRQAUUUUAFFFFABRVPVdRi0jSrrUJ0d47eMyFIwC 74HCqCQCxOABnqRWRZeLop7G0a50+6gv5ZJoZrFNsrwSRIzOCVPzDgAEdd6cc8AHR0VzKeNLcoiv pOpxXT3/APZ4tXWLzBKYPPGcSFQCmOp4J5A5I6agAooooAKKKKACiiigAorE8SeJbXwxHYT3iE29 zctA7rkmPEMsgIUAliTGFxx972xSpr7x6PLql/p0tpBlBBEZUkllLEKowhKAszADDnORkigDaqrq H/Hsv/XaL/0YtZFv4utrjU7XTP7Pvkv5zKJIGEebcx+Vu8whyv3ZkYbScj3wDUsPGFr4gis0isNQ tBeQw3tq11GiiaLzIwxG1iQQZEznH3gRkc1MvhY1udRWB46/5J74l/7BV1/6Kat+sDx1/wAk98S/ 9gq6/wDRTUFHxHRRRVEBXtvwG/5Fzx5/16Rf+gT14lXtvwG/5Fzx5/16Rf8AoE9NboT2PQrvq31N VYvun61au+rfU1Vi+6frXtLY8lny1RRRXiHrhXr37Of/ACUK/wD+wVJ/6NiryGvXv2c/+ShX/wD2 CpP/AEbFSYI+narP/wAhOD/rhL/NKs1Wf/kJwf8AXCX+aVLKLgpRSClFWSFRXN1b2cJmup4oIl6v K4VR+JrJ1nN1qVlZCS4jRQ88phmaLIHyqpKkHqxOP9muE8U213YXc08keoSQpIHtLh7lnRF2ICpZ n+Ult55wCOOcAVnUnyRvY68FhliKqpuVju728tNd0uRNIvba8kjlikxbTox+SRWPIOAfl4zWO1jq srI0+m3krRvvjLNASnPb95x9a88+1XN7eGXS3u3uI1HlXMMoKRsSB8zBvlHPPYj16V7VqepQ6Vap cTrIyPcQW4CAE7pZViU8kcbnBPtnr0p05tq/9a/qLE0I00nG+t9GrNW/z6GRo1pqQ1VLi8inRI4H jBmZCSWMfQKzf3CecdRXR1i2nizRb7VP7Ot7tmuTLLCAYJFUyREiRA5UKWG0nAOcDPTmqdx490KH TjfRPeXUIuIbf/RrKVyTKwVHA2/Mh7MMg4wuWIBs5TZk0fTJtSj1KXTrR7+MYS6aBTKo9A+Mj86l +wWfn+f9kg87zfP8zyxu8zZ5e/P97Z8ueu3jpWafFejrewWbzzxzTeWFElpMqq0gBRHYrhHOR8rE NzjGahtvGWlTtqO4XEKWH+ud48g/6RNbgKFJJJe3fAxyGXuSAAaNvoekWcskttpdjBJJv3vFbopb fgvkgc7tq59doz0psXh/RYdNm02LR9PjsZmLy2y2yCJ245ZcYJ4HUdhWXceO9FgWyZV1GYXdy9qF h06d3ikSMyESJs3qdo4GMkHONoYif/hMdFXaJbiSItNNDgwuwTy5mhZnKghE3qQGYgGgDQfRtLls 7e0k02ze2t2DwQtApSJh0KrjAI7Yp02k6bc6WNLn0+0l08IqC0eFWiCrjaNhGMDAwMcYFUZfFmiw 6u2lSXbC7SdLdx5EmxJHVWRWfbtBYOuMnknA5BFO1rxDHo1zZ2xsrm6muw/lLC0SAldvy7pHQbju yBnJCt6UAXdP0rTtItzb6bYWtlATuMdtCsak+uFAFMt9E0m0tWtrbTLKG3aYTmKO3VUMgIIfAGNw Kqc9cgelNj1aMfY1vLeeymvJjBBDNtZmcRtIRmNmUfKj9T/D7jObP458OW00sUt+waLcZSLaVhGF lkiZmIXCqHicFjgDGc4IJANifTLC5guYLixtpYrpg1xHJErLMQAoLgj5jhVHPZR6VBJoGjTQ2sMm kWDxWZzbI1shEB/2Bj5fwqkvjTQGsrm7N8yQWzxJKz28iEeawWMgFQSrE8MAVPPPBpNP8aaBqeqr pdreSfbiD+4ltpYmBAJ2neow2FLbTzgZxjmgDSk0fS5tTj1KXTbN7+MYS6aBTKo9A+Mj86u1gx+M 9BlivJReSLHaW73UrPbSoDCn3nTKjzFHqmeo9RViPxLpMlje3ouWEFl/ry8LqV+UMCFK5YEEYKgh u2aANaijqKKACiiigAqrqH/Hsv8A12i/9GLVqquof8ey/wDXaL/0YtTL4WNbjNR/5Bl3/wBcX/8A QTVa/wDDlhql3dz3ommFzYtp7RGVgixOSX2gYwzfLluvyL0xVnUf+QZd/wDXF/8A0E1ZM8K3CW7S xid0Z0jLDcyqQGIHUgFlBPbcPWlHdjexzUvgTTry21KHU7y/1IahDBDM126EgQu7x4CqBwz8ggg4 GQctmvafDPQLMWGwXAazumu1MRSBZWOw4dIlRCu6KFsbRzGvuD2NFWScze+BNH1Dw3a6Hctetb28 vneaLpxNKzbvMLuDlvMDyBvUOcY4xkat4Rl1bx1FI9lcro7mSW9zdr9nuN1q1v8A6sfOsm1guQdu 1PU12tpfWl+kj2d1BcLHIYpDDIHCOOqnHQj0qxQBzyeEYRG/matqs03kfZoZ5ZwZII9ysVU7cNko uS4YnGCSM1DpHgPR9Fnt7i3MxuIpxOZPkQORHLGAURVQKBNIcKq8nJya6eigDmD4E0kQ63HFNfQn WHDzOlySYsMX2xhshVLvIxXBBMjA5HANF8CaVoQgFnJcAQ6g2ohcRqpla3MDfKqABSrE4AHze3Fd PRQAUUUUAFYniHw4PEH2QNquoWS20hk2WvlFJW4xvWRHDbcZAxgHnqARt0UAc3deC7O8+0rPqGpN Feoi6hEsyqt6VQJucBRtJVQD5ewEDBGKvaxoMesxRrLfXkEsF0l1bT27qj27qu3C/KQVILghw2Q7 e2NKaeG3QPPLHErOqBnYKCzEKo57kkADuSKZe31ppto93fXUFrbJjfNPIERckAZY8DJIH1NAGCng mwtwpsL3UrGQxGGaWC5Ja4Qu8h3lw3O+SRtwww3nBArTk0HTZNBi0QwMunwxxxxRpK6sgjwUw4O4 FSqkHOcjrVqW/s7eKGWa7gjjndY4meQASMxwoUnqSSMAdasE4GTQBg23hjy9QtLu71nU7/7G7SW0 Vy0W2NijJn5EVmO12HzE9fWqdj4GhtLbTbSfWtVvbHTTEbW1n8hVQxY8s7o4lc4wOrc981tWOu6P qlxLb6fqtjdzRf6yO3uEkZPqASRUFj4q8O6pdLa6fr+l3dw3KxW95HI5+gBJoA16KKKACiiigAoo ooAz9Y0qPVrPyWkkidTvjkjcqyN2PFc09n4gtt8UulpfKRjzIplAYe6swx+tdhc3Edpay3EpIjiQ uxAycAZ6d68y8b6prGv3w0nRG1Sye0s5Li5FvcJE/mMVEILJIOwlO3cOgJ4pPTULC6J8NrltTa61 AG2tC5ZbVZ2diMggMdx44Hc+2MmvRNU0uDVtEvdJnaRLe7tntnaMgMFdSpIJBGcH0Nct4I8eweIr CxtrqK4j1IIILlnVAhuFTLgYYkZwWHAGK7KeeG1t5bi4ljhgiQvJJIwVUUDJJJ4AA5zVznKbvJkx jGKtFGUnh9pLC6s9T1e/1SG4CgfaVhQxEHIKGKNMHODk5wVGMd7WkaTDo1j9milmmZmMks87bpJn PVmOACeB0AAAAAAFVbXxd4avXZLTxFpNwygFhFexuQCwQZw3dmVR7sB3rTuLu2tFja5uIoVkkWJD I4Xc7HCqM9STwB3qSiaisix8VeHdUultdP1/S7u4YErFb3kcjnHoASaT/hLPDf8AaP8AZ3/CQaV9 u83yPs322PzPMzt2bc53Z4x1zQBsUVQi13SLjUn06HVbGS+TO62S4QyrjrlQcj8qv0AFFFFAGXrW ijWRZMt/d2M9lcfaIZ7URlg3lvGQRIjKQVkbt6VFHoVz9juLW78QareLPs+aTyI2QA5IUxRJjcOC euOhU81Z1PXdH0Tyv7W1WxsPOz5f2u4SLfjGcbiM4yOnqKk03VtN1m3a40vULS+gVyjSWsyyqGwD glSRnBBx7igDLHhG0jt9Phtr2+tvsEUltA8MihhbuVJhyVPyjZGARhhsGGzkmbTfDkdhqZ1KfUb7 ULzyTbpLdMg2RkhioEaKDyo5YE8deTW1VPUtW03RrdbjVNQtLGBnCLJdTLEpbBOAWIGcAnHsaALl FZreIdEXSk1RtY08adISEuzcp5TEEggPnB5BHXsauWt1b3tslzaXEVxBIMpLE4dWHsRwaAJqKKKA CiiigAooooAo6lpVvqptBcvN5dtcpciNJCqyMudofH3lDYbHqqntWc/hDTG1zUtXDXaXWoWxtpNl y6qgZVVnjAPyOwSIFh/zzXGOc79VxfWZtIrsXcBtptgim8wbH3kBMN0O4sAMdSRjrQBz+ieBNN0J Ldbe5upDBfnUAZBEu6Q25tzkIijGw54GS3JJ5z1FFRzTw20YknlSJCyoGdgo3MQqjJ7kkADuSKAJ KKjmnhtkDzyxxIXVAzsFBZmCqOe5YgAdyQKkoAKKKKACiiigCne6bDfXWnXErSB7C4NxEFIwWMUk WG46bZGPGOQPocu48G6TdaLfaNMJ3027dX+zPKXSFlYMPLDZ2ruVTs5QYwFwSDuSTwwvCkssaPM+ yJWYAu20thfU7VY4HYE9qSO5gmmlhjmjeWEgSorgshIyAw7ZHPNAGB4f8EaV4buIp7EyCSNZ1P7u KNX80wliVjRVBHkIBgDvnOc05fDdnpdtovkSTt/ZVqmnwb2B3RmSDJbAGW/cryMDk8dMdFVXUP8A j2X/AK7Rf+jFqZfCxrcmrA8df8k98S/9gq6/9FNW/WB46/5J74l/7BV1/wCimoKPiOiiiqICvbfg N/yLnjz/AK9Iv/QJ68Sr234Df8i548/69Iv/AECemt0J7HoV31b6mqsX3T9atXfVvqaqxfdP1r2l seSz5aooorxD1wr179nP/koV/wD9gqT/ANGxV5DXr37Of/JQr/8A7BUn/o2KkwR9O1XYZ1SD/rhJ /wChJViq5/5CkH/XGT/0JKlllzFFFJVkHOazBqP9qzzWlnPOslokaNDIg2uDJ1DMvHzKffFZdvF4 gEf73Tb9m5HM0A/HiWuk1LVbayu7e0mcpJcq/lsy5jG0qPm5GOWA6jOaydN1zUlCHUI4nia6a0Z4 F2+W4coD945UtgdiM9D1qlFtXJc0nYpXcGtz2dzAmk3oeWJkUtcQ4BIIBOJCcAkc47V0+saZ/a9j Hbed5Wy7trndt3Z8mZJdvUddmM9s556VdVQwyeppcnqOfapKMG38MfZ/7N/0zd9i1W71L/VY3+f9 o+Trxt+0dec7Ogzxm2HgSWz06+tDq7OJZrea1QRFYbZoJBKhEW8jlgNwTYCAAAvWuvD8E9vrSFiG AzznHSgDj9S8D3+p63HqE/iK4Ea3NrdNbL53lb4WQlVTztgRimcFSwZs7jjFOHgWaOHWFt9amt5d QIKywq0bREXdxc4yjhiD9o2HBUkKeRu463ec98cipaAON03wPdabAXTWTNfDU/7SjnuIpJVVzbi3 ZGDSl2XZuxl8jI5OOWy+ApGS9ih1YRw6kJ4r9Tb5MkMlxNMFQ7xsYefIu75sg5wCBjtKKAOfuPDH 2j+0v9M2/bdVtNS/1WdnkfZ/k687vs/XjG/occ3Nd0ufVrPyIZrRVOQ8V7Zi5hkH+0m5Tx2ww6nO a1KKAORg8GXNnpdnFaavsvbS/N9DI8DPBGTG0RjSIvlY9jthQ/BOfaobfwE8Wk6/Zy6sZpNYspbV pjbgFC811KXwGwf+PrGBj7nbOB2lFAHP6n4Y/tHU7i9+1+X539n/ACeVnH2W5afrn+Ldt9sZ56Uf 8Ix/xPP7S+1/8xX+0vL8r/py+y7M5/4HnHtjvXQUUAefRfDW7EV6l14lurs3Gk3Wlq9x5spVZtn7 w+ZK3zDZzt2huOFxWleeHZ9T8dpdyRTw6VDDC0q71VLmWJmaHAVslVMrkhgAWSPGQK6+igAooooA KKKKACquof8AHsv/AF2i/wDRi1aqrqH/AB7L/wBdov8A0YtTL4WNbjNR/wCQZd/9cX/9BNcr400L VL3V11HSYr1rpdE1C0ilgvTEsU7rGYSVLqOSH5APIQn7qleq1H/kGXf/AFxf/wBBNXaUd2N7HAax 4Pv8+IDpl1rf/IKT+zP+J5c/8fn7/d96X/rh975f1pI7bUtT8f6minVvsUGomK4mTUGjgWBtPj/d rGJAQ/myK4ZV45O4GvQKjjghheZ4oo0eZ98rKoBdtoXLep2qoyewA7VZJ5SvhPXtH0TRYrC01+4u YtNgS6tBrDLbiYLh1VhdI0ZzxlVZANuBwa9aoooAKKKKACiiigAooooAKKKKAOC8X6H4m1TVo7i2 sbG8trW8s5rJH1KSEx7JkeR2j8sqScMN24kL91SSQ214mtru8bTJodMnvI7DUlnktleMGdBE4DLu cKdrujYYg5jyB0J6OigDhU8LTS+E9Ljk0qIaha6rHdQJJ5bSWcBv1mZFfJA2xAAhTg7MDPFdD4q0 +41Tw5c2lsjSOzRu0IfZ56LIrPFnIxvVWTk4+bnitmigDjFGr3nirRJ4ND1LTrG2Z0njuVsDCkfl SYKlHeUPvMY+UhcA8dc81pGgeJF03wvYXtlr7/2bJZmSG7k08Wkfl7QxVoWExCgErndnADA5NesU UAFFFFABRRRQAUUUUAc34rvvKazstrZk33O7zFRSYtu1SSw/jdGx0IRgeuDzOY9Ie/vNIsTe3F2u 6ZTfw75ZAMK25pMAAcY6AAYHHPa654c07xFCkWoJMyoCAYbh4jgkEjKEZGVX8q8+8S+H/BnhCS2j l03xFcvPFLMq2WpTEhYygbO6ZecyLgDPesalHnkpczVu23zLjKytYgtbDStGubm7swtvfTnzZXkv FYGYfdIG84AYkn2JHtXqem3q6lpdpfpG8aXMKTKkmNyhlBwcEjIz2NcXpvw88HazpdnqlvDqLQ3c KTxtJqNxu2sAwz8/XBruLO0hsLG3s7dWWC3jWKMMxYhVGBkkkngdTzTo0vZR5bt+opy5ne1jkLrw 3d3vgqbSLi03mbXGuJIvMA3W51Lzicg/88juxnPbrxVS88Pa5qqWKX8Mkv8AY97aG0drgH7QEukL 3DDdywgX+LnLSYHIz6BRWpJxfhnwbdQeHNAt9a1XUZmsre2c2DmARQzRqpADRxhiFYd3IOOd3exo Hh3VbQSyz63qVqjand3AsUW2aIxvcyOoyYi+GVgT8+RuPToOsooA4Oy07UtPu7K103R9XXTYJYx9 n1Ka1ngjQMAWjfzWmVlGWA5Hy4wM8d5RRQAVzfiHxPdaHrWn2sOkXGoQTWtxc3H2YqZYliMQ3KpI 3/6zkD5vQHpXSVxvibVrTQ/Gmk399MIraPSr7e5/662mAB1JJwABySQKANPxAp8R/D/VU0nFydR0 uYWm1gBKZIjs5OAM5HWjWNHn1bxDp3mS3yaZHaXPnfZb6S2zMXh8vPlurN8olx1A59RXG+GtZmi8 QpB4X0PV20RxGbm1uZYhHbpIu+OaANKWVCDygAA7AMpU+o0AeWPpmv6H4XBvJtYd57fRI5l/tR5J WujdbblEdpPkLBkXIKqc8Hg40ofD+uXn2LDatpsMWttcxNcXcVzc2tv9ieP70jSqcys3GWID9scd 7NBDcoEnijlQOrhXUMAysGU89wwBB7EA1JQBy2s6RMlvYSj+3tS1G1Eqx31nPbxTKHIJDKxjiYHa oAKH7vryb3hhdRSwnGp2n2eUzkozrEskylFO+QRMUD5ypwedoPGcVt0UAFFFFABRRRQAUUUUAZPi G3vL7TRYWiyD7XIsM8yOEMMJOZGzkHJUFRtyQWB6AmuT1bQNSk1gxQ6bqctumqWEtnJFfhLSC2ia 3Lq0JlGSDHKR+7PUYNehUUAebQ6F4ul1bxA8t1qMQkW5exYTnyWfzg9vz9oYjCqFKiKMEFgxbjOv pGl6zf31rca5BPCiyy6g8MlyJFSYtthiAViMRxjJ42l2DDJBx2VFAHmdl4d1y40W/wBNu7TWDG19 p0kU9/qe6d4kuEeX7s7hGRVJ3IULZGBlRWr/AMI3qn2z7F5+qf2V/bXnbv7Vm8z7L9hxjzPM8zb9 o/hz15xjmu3ooA4zw1oGraVrcM082ovbMuopMLrUpLhcfakNrhXdsHyQ3IGeu7k12dFFABRRRQBz virRLjXJdEihluYIob9pZ57aYRyRIbadMqevLOo45+b8RmXema3F4HutI060kt7+CSILcQSgfa18 1TI6nzVcMyBt250O4nDn71drRQBwHhbRPEKalaPqsuqpZxfaXMc10Vw5Nr5QIFzMzr8k5+Zz1YYA IBdo2g6tpa+H5rubUXY6aqaoLnUZLhftfmWxHys7AHiflBjr6iu9qrqH/Hsv/XaL/wBGLUy+FjW5 NWB46/5J74l/7BV1/wCimrfrA8df8k98S/8AYKuv/RTUFHxHRRRVEBXtvwG/5Fzx5/16Rf8AoE9e JV7b8Bv+Rc8ef9ekX/oE9NboT2PQrvq31NVYvun61au+rfU1Vi+6frXtLY8lny1RRRXiHrhXr37O f/JQr/8A7BUn/o2KvIa9e/Zz/wCShX//AGCpP/RsVJgj6dquf+QpB/1xk/8AQkqxVc/8hSD/AK4y f+hJUMsuUhpaQ9a0IMTX9ATWVjdZGjuIlZEYklGVsblZQRkHaOT0xxXMX+kahbWltDPAYLZJA4+y XJwCrb1zlVxyoIPuQevPY6rrEGkorTxyMCpYlCoCqMAkliB1I7965eXxr4b1CF1mLGPcykC+g7HH 8M3t/jjkUqyqzouEJW8x0+SE1KSubGi64bgxWtyH8187JOMHjODz1xn8s1b1+2N5odzCy3e1hz9l IMmAQcgHhvUrg7hkYOcHN0R9JuLuI2drPG2xpInedXVgCAcbXb1xXTg4UcH8K5sJCvCny13dmteV OU+amrJnnGjRX9rZ6zHoWiqk62MrWtxFpr6aklxj5EeGUgMxODvHy9QcZ5zbOwv9RtbC61Wy16K3 stadmSO8vmljhaz2lgxCSP8AvmHKrwC4Uld1et0V1GJ5roeiS6ZqGnW6W+reZDr93LcGd55YxE0d 4Y3VnZk5EkeSpyWYB/mqtpSeJ7Pw3Mkz65PI+maXPMZnYzI7OwuxGWwQ6xqPl5IbBxubn1Oql7p8 Go2ktrdK7RSYztkZCMHIIKkEEEdQc0Aeb/aL6fSNYFjNrrW1vraIIpXuTP5H2SI7CyEzopdg2Qpf n5hyxrvPC7zSeG7NriC9gkKtmO9cvKo3HG5jyeMYLANjGQDkVPpejWejW32eyiZELlyzyNI7E9Sz uSzHgDJNaFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVXUP+PZf+u0X/oxatVV1D/j2X/rtF/6M Wpl8LGtxmo/8gy7/AOuL/wDoJrnPFPiTVNA1xZIraCfTINEv7+aMz7HkeHyiMfuzjG4AfNz5jEj5 FDdHqP8AyDLv/ri//oJqHVfD+ma04a/geUi2ntflmdAYpgBIpCkZBCr16EAjBpR3Y3sc7f8AjTWN NOp/aPDcf/EstF1C5K6gDi2bfjb8nMn7qT5fu/L9/kVck8W3X/CSXOkRaQGVLlrKC5a5CrJP9lW5 VWAUsqlSwLANgheDkgbN5omnX/8AaH2m38z+0LQWV187DzIRvwvB4/1r8jB+brwMU7LwvZWviTUd dcCW8upvMjYgjyl8mKIrjOCf3RO7GQHI9c2ScjpnjXxHY+HNN1PV9JW6hvoEvWvFuf3USOqkINsA CYyT+8O0Aj963OPSqwZfBuhTW1pbPaSCC1t0tI4luZVVoV4WNwGxIo9Hz39a3qACiiigAooooAKK KKACiiigDgfF/wAQbbSdYh0m11CytZre7s/t0tzcRLiKSaMMiozbifLfcW27VXPOenQ+J7q9jTS7 Kwu2s5tQvltzdKiuYkCPK2AwK5YRlBkHG/Nat7Y2+oQLDdR+ZGsscwG4jDxusiHj0ZVPvjniq+o6 LY6tay217HLJFJMk/E8isjoVKlGVgUwVB+Ujv6nIBy8+s67N4c0rUYr+CBo9WjsrwLbBjcr9tW2J Uk4QMNzdCfmGCMc9H4j1KbSdDmu7dEabfHFGZPuI0kioHbp8q7tx9ganbRtPOmwad9lRbS3eKSKJ CVCtG6uh49GVT745zzVqeCG6t5Le4iSWGVSjxuoZWU8EEHqKAOYSfVNF8S6ZZXuo6lf2+oM0Qllt 7YQLKI5JNq7CsinEZPKuOgznkctoniHxOuk+HNUu312Vb97NZ5LyKw+yMJiisV8nEq/f+XI67QRz XdWXhTSLC9hu4Ybh5oMmHz7yaZYcgqdiu5VOCR8oHBIqLT/BeiaabUW8V40drt+zw3GoXE8UW37u 2OR2UYwMccY4oA36KKKACiiigAooooAyfEN6bXTfLXzA1wTHuibayIFLOwORghFbB9cVwKaX5msa pea+1yLYwNDZxT3zuI4cAygneRudlXIz0AHODnrPF1hqV29s+nQTTFYZY2WN0AyzRkbgzLkfIeOa 4+fw1r1/bm31HQ57uEkfu5Wtyn12+dj8etc9aNWTSja3U0hypa7md4Sh1vw3fTT3D37aVbSbrKA3 xdTbYbcCgkK8JhxkZyCB2Few3JMtpIsczwtIhVZYtpZCRgMu4EEjqMgj1FeWSeH/ABeGk8jT7tEc bcedDnbxxkynjtXpWj2s9poVhaz7vOito45CXychQDz68VdJVEv3j1Jny3904r7V4jt/ClxqcPiO 7ub06t/Z0Md1BbiIAaiLcMdkSnJQYPOPmJABxi9rPi67uI9LGjboWF9aDUTIqsYo3ult2hOc/OW3 jI6CNuRkV1H9iad9h+xfZ/8AR/tf23Zvb/Xed5+7Oc/6z5sdO2McUw+HtKP2r/Q0BuruK9mKsRvm jZGRuD2MaHHQ4OQcnOpJxHhbUfF9/pmh6gw125N3HbS3DXg05bQxvtMjr5REowpYqCM5wCOtWtGv vEOoapJNJJ4jktV1W5hBgXTRaCKO5eMA7v320KoDfxHBx2ruLCxt9M062sLOPy7W1iSGFNxO1FAC jJ5OAB1os7G30+BobWPy42lkmI3E5eR2kc8+rMx9s8cUAcjY6jrltf2r64+q2fmyJDIJYrWSxaRi F2xmM+aoZjhTIe4yM8V21Y0XhXR4r2O6W3mLRuHjie6laGNh0KxFtikdsKMdq2aACsvUvDmk6xqN hf6hZrPc2Bc2zMxwhbbnjOD91eo7VqUUAec614Lh8JaJq2v6BrOr2NzYaVKIY/PWePZGpdIyJlf5 VIOMYIDEZrduL/V9DvrTSLUTa9d3cNxdCa+uIrfy1iMK7f3cIBBMvB2k568fd6G/sbfU9OubC8j8 y1uonhmTcRuRgQwyORkE9KHsbaTUIb9483UMUkMb7jwjlGYY6cmNPy9zQBx1r8Qbm40lr1tBYSOm nz20KXQPnQ3kojjO4qNrg7sr04HzYORFrXibWbiKytLa3vLK+TWDYXkenS28ruBavOPKedQhBHlk 7gp4YY6Z2r7wVpVzpaWFvELeNVsYTks+6C1mEiR8t/vru6/Nk5wBWhbeHtLtEtVit3za3DXMTyTO 7+ayshdmYksSrsPmJ6+woAw7mbxEmj2KxR62SVm+0OGsPtqsGGzOT5G3bvztBP3P9o1seG7573T5 BLcTyzwS+VItzCsU0Z2q22QL8u7DA5UAEMMeptajo9lqiItykoZM7JIZ3hkTOM4dCGGcDODzin6d plppVu0FnEURnMjlnZ2dj1ZmYkseBySTQBbooooAKKKKACiiigDN17VH0fR5ruG3a5ucrHb26kAy yuwVFySAAWIyc8DJ7VzWoeItZtI47KGMSmy1DTrC91F3RWkkkkgL7YtuNrJLjIIILcDjI7C4s7e6 ltpJo97W0nmxckbX2sucd+GPX1z1rPvfDGkajqCX11as86SRSgiaRVLxsGRygYKWBUckZxx04oA5 5viHN5utmLw1qUtrpbSZnCFVlSKURzEMyhCw+dlVWYsEOdp4ro9C1r+3YLu6itmitI7qSC3lZ1b7 SqHaZAB0UuHAz1Cg96fBoGmW+o3d9HbYnuwVmzIzIQcbsITtXOATgDJGTk1Y07TrTSNNttOsIRDa W0YiijBJ2qBgDJ5P1PNAFqiiigAooooAKKKKAOe8Uatf6TPoZsLaa7a5v2hltoTGGmX7NO+AZCAM MitnIOF75wan/CSzad4Qm8RXfm30kjoq2VtF/qZGkEQiAxvJDthiQTkHCjha6S4sbe7ntJp498lp KZoDuI2OUaMnjr8rsOfX1xUEujafMl6klsCl6QbhdxAdgAA2M8NwPmGDwOeBQBgaR4xvtV1CxsTo E9tNOJ2la5MkKqsRgBdBJGrupE+ASq/MpHT5hDpXi281uPSlvNIWxj1Ozi1G1ZLoTEqJIQysNq7T ++QjGcjrg8V0Gn+HdM0y4juLaGXz41kQSy3EkrkSFC+WdiWJ8qPk5I24GKhk0TTrC2037Nb+X/Z8 Udla/Ox8uEyRZXk8/wCqTk5Py9eTmZfCxrc1qwPHX/JPfEv/AGCrr/0U1b9YHjr/AJJ74l/7BV1/ 6Kago+I6KKKogK9t+A3/ACLnjz/r0i/9AnrxKvbfgN/yLnjz/r0i/wDQJ6a3QnsehXfVvqaqxfdP 1q1d9W+pqrF90/WvaWx5LPlqiiivEPXCvXv2c/8AkoV//wBgqT/0bFXkNevfs5/8lCv/APsFSf8A o2KkwR9O1XP/ACFIP+uMn/oSVYquf+QpB/1xk/8AQkqGWXKKKK0IOF+JEM1xZRpb2k9zIIHfZAMs ds0BIAzzkAn046iuI8MeFH1yzvDdHUdPljlVtjoxcgk4wrPx05x19O1ekeLIpLxo7VY7qNRGSbq2 SYyKGyCqmNTg8evpWZoUElj9u+1f2vOsqxqpljuJSQrSEgZAx94c/wCGBpGrKMbIXKr3F0rRZvDO nFra5llFnbzsPtFuwLBmEjDO/g5XAOOK6LX7+XTNOiniVGd760gIccbZbmOMng9cOxHvisy5kifT 75IrS7EklvIiAWkoySp74/w61vajpVprGntZ3qSNCzI58uZ4mDI4dWDIQwIZQcg9qzbbd2Mh1TWh pi2g+xXNzNdzGCCGApudxG8hGXZV+7GxyTWG3xCtBaXlwukam6WNvJcXgHkhoAjyoQQZPmbdBKML u6e9ax8K6W1ilo5v5I0mM6PJqVw0qOUKErIZN6/KWGAccn1Nct4i8CNfRTWWlRJBb3Fs9tLM2pXU ciBnd2YohKzj945w5GSxycHFAHodFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVV1D/j 2X/rtF/6MWrVVdQ/49l/67Rf+jFqZfCxrcZqP/IMu/8Ari//AKCau1S1H/kGXf8A1xf/ANBNXaUd 2N7BRRRVkhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFVdQ/wCPZf8ArtF/6MWrVVdQ/wCPZf8ArtF/6MWpl8LGtyasDx1/yT3xL/2Crr/0 U1b9YHjr/knviX/sFXX/AKKago+I6KKKogK9t+A3/IuePP8Ar0i/9AnrxKvbfgN/yLnjz/r0i/8A QJ6a3QnsehXfVvqaqxfdP1q1d9W+pqrF90/WvaWx5LPlqiiivEPXCvXv2c/+ShX/AP2CpP8A0bFX kNevfs5/8lCv/wDsFSf+jYqTBH07Vc/8hSD/AK4yf+hJViq5/wCQpB/1xk/9CSoZZcooorQgMUYH pRRQAYooooAKTA9BS0UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVV1D/AI9l/wCu 0X/oxatVV1D/AI9l/wCu0X/oxamXwsa3Gaj/AMgy7/64v/6Cau1UvY2lsbiNBl3iZVHqSKPtkv8A z4XP/fUf/wAVSTsxtXLdFVPtkv8Az4XP/fUf/wAVR9sl/wCfC5/76j/+Kp8yFZluiqn2yX/nwuf+ +o//AIqj7ZL/AM+Fz/31H/8AFUcyCzLdFVPtkv8Az4XP/fUf/wAVR9sl/wCfC5/76j/+Ko5kFmW6 KqfbJf8Anwuf++o//iqPtkv/AD4XP/fUf/xVHMgsy3RVT7ZL/wA+Fz/31H/8VR9sl/58Ln/vqP8A +Ko5kFmW6KqfbJf+fC5/76j/APiqPtkv/Phc/wDfUf8A8VRzILMt0VU+2S/8+Fz/AN9R/wDxVH2y X/nwuf8AvqP/AOKo5kFmW6KqfbJf+fC5/wC+o/8A4qj7ZL/z4XP/AH1H/wDFUcyCzLdFVPtkv/Ph c/8AfUf/AMVR9sl/58Ln/vqP/wCKo5kFmW6KqfbJf+fC5/76j/8AiqPtkv8Az4XP/fUf/wAVRzIL Mt0VU+2S/wDPhc/99R//ABVH2yX/AJ8Ln/vqP/4qjmQWZboqp9sl/wCfC5/76j/+Ko+2S/8APhc/ 99R//FUcyCzLdFVPtkv/AD4XP/fUf/xVH2yX/nwuf++o/wD4qjmQWZboqp9sl/58Ln/vqP8A+Ko+ 2S/8+Fz/AN9R/wDxVHMgsy3RVT7ZL/z4XP8A31H/APFUfbJf+fC5/wC+o/8A4qjmQWZboqp9sl/5 8Ln/AL6j/wDiqPtkv/Phc/8AfUf/AMVRzILMt0VU+2S/8+Fz/wB9R/8AxVH2yX/nwuf++o//AIqj mQWZboqp9sl/58Ln/vqP/wCKo+2S/wDPhc/99R//ABVHMgsy3RVT7ZL/AM+Fz/31H/8AFUfbJf8A nwuf++o//iqOZBZluiqn2yX/AJ8Ln/vqP/4qj7ZL/wA+Fz/31H/8VRzILMt0VU+2S/8APhc/99R/ /FUfbJf+fC5/76j/APiqOZBZluiqn2yX/nwuf++o/wD4qj7ZL/z4XP8A31H/APFUcyCzLdFVPtkv /Phc/wDfUf8A8VR9sl/58Ln/AL6j/wDiqOZBZluiqn2yX/nwuf8AvqP/AOKo+2S/8+Fz/wB9R/8A xVHMgsy3RVT7ZL/z4XP/AH1H/wDFUfbJf+fC5/76j/8AiqOZBZluiqn2yX/nwuf++o//AIqj7ZL/ AM+Fz/31H/8AFUcyCzLdFVPtkv8Az4XP/fUf/wAVR9sl/wCfC5/76j/+Ko5kFmW6KqfbJf8Anwuf ++o//iqPtkv/AD4XP/fUf/xVHMgsy3RVT7ZL/wA+Fz/31H/8VR9sl/58Ln/vqP8A+Ko5kFmW6Kqf bJf+fC5/76j/APiqPtkv/Phc/wDfUf8A8VRzILMt1V1D/j2X/rtF/wCjFpPtkv8Az4XP/fUf/wAV UVxLNcIkYs5k/exsWZkwAHBPRvQUpSTTGlqXKwPHX/JPfEv/AGCrr/0U1b9YHjr/AJJ74l/7BV1/ 6KamM+I6KKKogK9t+A3/ACLnjz/r0i/9AnrxKvbfgN/yLnjz/r0i/wDQJ6a3QnsehXfVvqaqxfdP 1q1d9W+pqrF90/WvaWx5LPlqiiivEPXCvXv2c/8AkoV//wBgqT/0bFXkNevfs5/8lCv/APsFSf8A o2KkwR9O1XP/ACFIP+uMn/oSVYquf+QpB/1xk/8AQkqGWXKKKK0ICiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKq6h/x7L/ANdov/Ri1aqrqH/Hsv8A12i/9GLUy+Fj W5Fqcrw6TeSxMUkSB2Vh2IU4NVZrDS7doIRp9u7yNgyyxBvqWYjknt61oXMC3VrNbuSElRkYr1AI xxVH7DqW3adRhceslrkn64YDP4ColfoWjB8V2OnwS2fl2dsilZCQIVAJymM8e5/Oud8qy/59bb/v yv8AhXYat4cvtWWMSapFG0YIBS1PfGer+wrK/wCEBu/+g9/5KD/4qvRwtanGFpuzODE06jneKuvl /mYnlWX/AD623/flf8KPKsv+fW2/78r/AIVt/wDCA3f/AEHv/JQf/FUf8IDd/wDQe/8AJQf/ABVd P1ih/N+f+Rh7Kt/K/vX+ZieVZf8APrbf9+V/wo8qy/59bb/vyv8AhW3/AMIDd/8AQe/8lB/8VR/w gN3/ANB7/wAlB/8AFUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/35X/AAo8qy/59bb/AL8r/hW3/wAI Dd/9B7/yUH/xVH/CA3f/AEHv/JQf/FUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/wB+V/wo8qy/59bb /vyv+Fbf/CA3f/Qe/wDJQf8AxVH/AAgN3/0Hv/JQf/FUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/35 X/CjyrL/AJ9bb/vyv+Fbf/CA3f8A0Hv/ACUH/wAVR/wgN3/0Hv8AyUH/AMVR9Yofzfn/AJB7Kt/K /vX+ZieVZf8APrbf9+V/wo8qy/59bb/vyv8AhW3/AMIDd/8AQe/8lB/8VR/wgN3/ANB7/wAlB/8A FUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/35X/AAo8qy/59bb/AL8r/hW3/wAIDd/9B7/yUH/xVH/C A3f/AEHv/JQf/FUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/wB+V/wo8qy/59bb/vyv+Fbf/CA3f/Qe /wDJQf8AxVH/AAgN3/0Hv/JQf/FUfWKH835/5B7Kt/K/vX+ZieVZf8+tt/35X/CjyrL/AJ9bb/vy v+Fbf/CA3f8A0Hv/ACUH/wAVR/wgN3/0Hv8AyUH/AMVR9Yofzfn/AJB7Kt/K/vX+ZieVZf8APrbf 9+V/wo8qy/59bb/vyv8AhW3/AMIDd/8AQe/8lB/8VR/wgN3/ANB7/wAlB/8AFUfWKH835/5B7Kt/ K/vX+ZieVZf8+tt/35X/AAo8qy/59bb/AL8r/hW3/wAIDd/9B7/yUH/xVH/CA3f/AEHv/JQf/FUf WKH835/5B7Kt/K/vX+ZyyXlm8aP/AGfbDckL42Lx5jYx07frV7yrL/n1tv8Avyv+Fbf/AAgN3/0H v/JQf/FUf8IDd/8AQe/8lB/8VS+sUf5vwf8AkHsq38r+9f5mJ5Vl/wA+tt/35X/CjyrL/n1tv+/K /wCFbf8AwgN3/wBB7/yUH/xVH/CA3f8A0Hv/ACUH/wAVT+sUP5vz/wAg9lW/lf3r/MxPKsv+fW2/ 78r/AIUeVZf8+tt/35X/AArb/wCEBu/+g9/5KD/4qj/hAbv/AKD3/koP/iqPrFD+b8/8g9lW/lf3 r/MxPKsv+fW2/wC/K/4UeVZf8+tt/wB+V/wrb/4QG7/6D3/koP8A4qj/AIQG7/6D3/koP/iqPrFD +b8/8g9lW/lf3r/MxPKsv+fW2/78r/hR5Vl/z623/flf8K2/+EBu/wDoPf8AkoP/AIqj/hAbv/oP f+Sg/wDiqPrFD+b8/wDIPZVv5X96/wAzE8qy/wCfW2/78r/hR5Vl/wA+tt/35X/Ctv8A4QG7/wCg 9/5KD/4qj/hAbv8A6D3/AJKD/wCKo+sUP5vz/wAg9lW/lf3r/MxPKsv+fW2/78r/AIUeVZf8+tt/ 35X/AArb/wCEBu/+g9/5KD/4qj/hAbv/AKD3/koP/iqPrFD+b8/8g9lW/lf3r/MxPKsv+fW2/wC/ K/4UeVZf8+tt/wB+V/wrb/4QG7/6D3/koP8A4qj/AIQG7/6D3/koP/iqPrFD+b8/8g9lW/lf3r/M xPKsv+fW2/78r/hR5Vl/z623/flf8K2/+EBu/wDoPf8AkoP/AIqj/hAbv/oPf+Sg/wDiqPrFD+b8 /wDIPZVv5X96/wAzE8qy/wCfW2/78r/hR5Vl/wA+tt/35X/Ctv8A4QG7/wCg9/5KD/4qj/hAbv8A 6D3/AJKD/wCKo+sUP5vz/wAg9lW/lf3r/MxPKsv+fW2/78r/AIUeVZf8+tt/35X/AArb/wCEBu/+ g9/5KD/4qj/hAbv/AKD3/koP/iqPrFD+b8/8g9lW/lf3r/MxPKsv+fW2/wC/K/4UeVZf8+tt/wB+ V/wrb/4QG7/6D3/koP8A4qj/AIQG7/6D3/koP/iqPrFD+b8/8g9lW/lf3r/Mp6Jb2j60oW3hA+zy ZCxgfxR+3ua6f7Da/wDPvF/3wKp6V4SudMu/POqJMdjIA1tjqVPZ/wDZ/Wtj7Bdf8/UP/fg//FV5 GMtUq80dUejh1KNO0tGU/sNr/wA+8X/fAo+w2v8Az7xf98Crn2C6/wCfqH/vwf8A4qj7Bdf8/UP/ AH4P/wAVXL7N9jfm8yn9htf+feL/AL4FH2G1/wCfeL/vgVc+wXX/AD9Q/wDfg/8AxVH2C6/5+of+ /B/+Ko9m+wc3mU/sNr/z7xf98Cj7Da/8+8X/AHwKufYLr/n6h/78H/4qj7Bdf8/UP/fg/wDxVHs3 2Dm8yn9htf8An3i/74FH2G1/594v++BVz7Bdf8/UP/fg/wDxVH2C6/5+of8Avwf/AIqj2b7BzeZT +w2v/PvF/wB8Cj7Da/8APvF/3wKufYLr/n6h/wC/B/8AiqPsF1/z9Q/9+D/8VR7N9g5vMwb5rPSf CdzqgsNPmkt5pGZbiMAyKJWGxWx94jhevOBWmEsX06y1OxsmsZJJISFaDyZAruoZXUj0JGDTxo92 IliN1aOiymVRJaFtrFi2fv8AUE8Gpjp13NJH9qv1aJHWTZFBs3FSCMkluMjtitltaxPW9zTrA8df 8k98S/8AYKuv/RTVv1geOv8AknviX/sFXX/opq0EfEdFFFUQFe2/Ab/kXPHn/XpF/wCgT14lXtvw G/5Fzx5/16Rf+gT01uhPY9Cu+rfU1Vi+6frVq76t9TVWL7p+te0tjyWfLVFFFeIeuFevfs5/8lCv /wDsFSf+jYq8hr179nP/AJKFf/8AYKk/9GxUmCPp2q5/5CkH/XGT/wBCSrFVz/yFIP8ArjJ/6ElQ yy5RRRWhAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVXUP+PZf +u0X/oxatVV1D/j1X/rtF/6MWpl8LGtxL24+yWM9wBu8qNnx64GaiGn3TAF9VugxHIjSILn2yhP6 0ms/8gW+/wCuD/yNU/GF3JbeCdfnt5ZIp4tNuHjkjJVkYRsQQRyCCOoqdG7Mr0Lv9nXH/QXvf++Y f/jdH9nXH/QXvf8AvmH/AON1yOnrfaT4ksRem4sLaQlSRqtzqMVw5BAiYzKBEwO1geCxwozkisOx 8ea1e2d7te6guVthNcC6jgxZSebGpjQJuZfld8ecOCoJ43YfKhXZ6V/Z1x/0F73/AL5h/wDjdH9n XH/QXvf++Yf/AI3XH23iqSbwzb3Caxci3lvzBPqc8MJNtF5ZbduQGFhuCrvA2jfgjINUvFnjKbRd F065sdeu7yV7e6lhMNrAVvTGybS5bHygHB8oZOSwwFxRaIXZ3v8AZ1x/0F73/vmH/wCN0f2dcf8A QXvf++Yf/jdcrc6xq39q6jdw6o/2S01mzsks/Ij2tFMtsHy2N2QZmYYIxg5yOBd8a39nb/2Et/qM 2n2EuolLiVbt7XK/Zp2UF1ZSBvVeM8kDrRaIXZu/2dcf9Be9/wC+Yf8A43R/Z1x/0F73/vmH/wCN 1ws3iW/0zw9PLFdarPYHVfIhv5Io1mjtPJDFw0wVColygkfgg5yxxl9n4s1q4uPD8bNLHBq8jRLM 0UZEfkSOzEsuU3TRKBgEgEErRaIXZ2/9nXH/AEF73/vmH/43R/Z1x/0F73/vmH/43XDWXiW4OkaC l/r0ulB9GtLhbqSFX+2XDr86Eup3EYUlVIY+ZweKuTeK74fEqDRybqG188xrFsi8ueL7M0hcA/vS wkwuVGwbSCcnFFohdnW/2dcf9Be9/wC+Yf8A43TdtxZXVur3ctxHO5jxKqAqdpYEFVH90/nXLeCf ElzqmozW17qk11cLCWliWKIwo+4D5GQB06/clG49exrrL1w11pwGf+Pg/wDoqSk0ugJst0UUUxhR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFQXtx9ksZ7gDd5UbPj1wM1PVHWf+QJff9cH/kaT2Bbjhp90wBfVboMRyI0iC59s oT+tH9nXH/QXvf8AvmH/AON03Xrm8g8PanLpqM1/HaStbKq7iZQhKgDvzjiuf8O3uhy38H2LxFqV 9fshM8M9w7k8c+bCRiE57BU549qdoiuzov7OuP8AoL3v/fMP/wAbo/s64/6C97/3zD/8brgtP8Wa 1f6NeOt+y3JudNVpGtVH2OWedUmtsEDcUUjr837zr0qa+/tbUbyHRJvEmqQomttZPc2nlQzSxfYv tK5ITAIYbflABUnIJwQWiF2dv/Z1x/0F73/vmH/43R/Z1x/0F73/AL5h/wDjdeb6Z4t1JtN0bztb lhu2OkxLaPCrm7imFv5sxZlLcmSRNwOBtx94g1v2Xi2SfVdN0tr3N8dbvbe6g8oBhbqty0QPHAKr CQeCwGcn5qOWIXZ1P9nXH/QXvf8AvmH/AON0f2dcf9Be9/75h/8AjdeZS+NtesNK0ea5ubyee60q C+iaOO1jjuZ3BzCd+0kABTiPL/OT02ivVWv7Vd+6eMeXIsT5cfK7Y2qfQncuB33D1o5Yhdlf+zrj /oL3v/fMP/xuj+zrj/oL3v8A3zD/APG6tpcwyPIqOrNG21wpBKNgHB9Dgg/QineYPei0Quyl/Z1x /wBBe9/75h/+N0yWK4sfLlN9NcIZUjZJVTozBcgqo7kGsi5/4Sk67LYW86LpcxWcaiyp5luMndAq Ywx4GHYcAnO4itvU3BtYxz/x8Qf+jUpNJLQauW6wPHX/ACT3xL/2Crr/ANFNW/WB46/5J74l/wCw Vdf+imqgPiOiiiqICvbfgN/yLnjz/r0i/wDQJ68Sr234Df8AIuePP+vSL/0Cemt0J7HoV31b6mqs X3T9atXfVvqaqxfdP1r2lseSz5aooorxD1wr179nP/koV/8A9gqT/wBGxUUUmCPp2qs0ghv4JWWQ p5UikpGz4JKY6A+hoorObsrlrUk/tCD+7cf+A0n/AMTR/aEH924/8BpP/iaKKj20h8iD+0IP7tx/ 4DSf/E0f2hB/duP/AAGk/wDiaKKPbSDkQf2hB/duP/AaT/4mj+0IP7tx/wCA0n/xNFFHtpByIP7Q g/u3H/gNJ/8AE0f2hB/duP8AwGk/+Jooo9tIORB/aEH924/8BpP/AImj+0IP7tx/4DSf/E0UUe2k HIg/tCD+7cf+A0n/AMTR/aEH924/8BpP/iaKKPbSDkQf2hB/duP/AAGk/wDiaP7Qg/u3H/gNJ/8A E0UUe2kHIg/tCD+7cf8AgNJ/8TR/aEH924/8BpP/AImiij20g5EH9oQf3bj/AMBpP/iaP7Qg/u3H /gNJ/wDE0UUe2kHIg/tCD+7cf+A0n/xNH9oQf3bj/wABpP8A4miij20g5EH9oQf3bj/wGk/+Jo/t CD+7cf8AgNJ/8TRRR7aQciD+0IP7tx/4DSf/ABNH9oQf3bj/AMBpP/iaKKPbSDkQf2hB/duP/AaT /wCJqC6ukuIkjjScsZYzzA4GA6k8kY6Ciij2reg+VIk1GFrjTrmBPvSRso+pGKp/b843290pIwwN s5wfbAINFFVNakkc115sMiI1/CzIVWSOzbKHswBQjI6jII46Yqjp8M9nO0lxq+uX6lCnl3VigUc9 fkhUk9epI56cDBRSGaP21MsTHeEnr/okn/xNBvI2YEx3mOhH2STken3entRRSsApvkOcx3nUHm0k P/sv0/Kj7anGI7wY7/ZJM/8AoNFFFgEF4gfcI7zrkj7G+D/47R9tXj5b049bWT/4miiiwC/bkyP3 d5/4CSdPT7v+cU03cZIPl3hxjrZyHp/wGiiiwCi9jGf3d5z1/wBEk5+vy80scpvL212JMEhcuzSR Mn8LLjkD+8PyNFFNaMTNWiiitACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKrahA11p1zAmN0kTIM+pFFFDVwM28uHurR4 Vk1GymbH72C1Luhzk43IyH06Hr+NZsFpeRTxyP4i8QzIjBmiksIQrgH7p224OD04IPuKKKxuy7I2 f7Qj/wCeN1/4CS//ABNH9oR/88br/wABJf8A4miilzMOVGPeadBfakl1Nd6yYFljn+xeQ/kmSMgq eY9wwQDgMASMkVsf2hH/AM8br/wEl/8AiaKKOZhyoP7Qj/543X/gJL/8TR/aEf8Azxuv/ASX/wCJ ooo5mHKg/tCP/njdf+Akv/xNH9oR/wDPG6/8BJf/AImiijmYcqD+0I/+eN1/4CS//E0x5TetFFFD OMTRuzSQsgAVgx5YD0x+NFFNO7sJqxr1geOv+Se+Jf8AsFXX/opqKK3JPiOiiiqICvbfgN/yLnjz /r0i/wDQJ6KKa3QnsehXfVvqaqxfdP1oor2lseSz/9k= --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 2.jpg" Content-Description: Picture (Enhanced Metafile) 2.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 2.jpg"; creation-date="Thu, 08 Nov 2012 06:14:04 GMT"; modification-date="Thu, 08 Nov 2012 06:14:04 GMT" Content-ID: Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAFNAnMDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDgfBEm o2Mt9PaWql5bbbG9wHSPluDkKd3KnjIyAeeK9FSTxE4VktXZTjDJZSkfmG9hXG+C2B0O4wACHQHA 6/6z/wCtVzxPqWjWfinWYdR02Ce4227wyPbrLkG3iG1sspC5HUHIycCt58sKcZWu2crlOc2k7WNy TU9Yh2+fbTwqSFDS6ZcIuSQBycAdqk/tHU/+e1t/36b/AOLrza7vYLvUdPSw02zgmW7Rw1rCuTye DyPb0H0r0KIu0KFxhyo3DGMH8z/M1vhIwrxbcbCxMpU7crIdVW91jTpbK4uIVikGCY4mB/VjXMf8 IFb/APP7L/3yK7Ciuv6tT7HL7ep3OP8A+ECt/wDn9l/75FH/AAgVv/z+y/8AfIrsKKPqtPsHt6nc 4/8A4QGD/n9k/wC+RR/wgMH/AD+yf98iuxHSil9Wp9hfWKnc47/hAYP+f2T/AL5FKPAEBH/H9J/3 yK7Cnij6tT7DVep3ON/4V/B/z/Sf98ilHw+tz/y/S/8AfArsqVaaw1PsN16nc43/AIV7b/8AP/L/ AN8Cj/hXtv8A8/8AL/3wK7Sin9Wpdhe3qdzi/wDhXtv/AM/8v/fAo/4V7b/8/wDL/wB8Cu0pKPq1 LsHt6nc4z/hXtv8A8/8AL/3wKP8AhXkH/P8Ayf8AfArtB1paPq9LsL6xU7nFj4eQE/8AH/J/3wKX /hXUH/P/ACf98Cu0HWnUvq9LsNV6nc4n/hXUH/P/ACf98Ck/4V1B/wA/8n/fArt6KX1el2H7efc4 n/hXEH/QQl/74FH/AAra3P8AzEJf++BXcUtNUKfYXt6nc4b/AIVtb/8AQQl/74FKPhxAP+YhJ/3w K7iin9Xpdg9vU7nD/wDCuIP+ghJ/3wKP+FcQ/wDP/J/3wK7inDpR9Xpdg+sVO5w4+G0JH/IQk/74 FH/Ctof+ghJ/3wK7odKWp+r0uw/bz7nCf8K2h/6CEn/fAo/4VtD/ANBCT/vgV3dSWQgi1W2lmitW jeaFJ2uII5B5W/nJdTtADMcgj9KUqFNK/KVGtNuzZwA+GsJ/5iEn/fApf+Faw/8AQQk/74Fd+y6d P4muXnks4raN5BaxQQRQiWHzcNtkDxZO0RbdxYck7W7Rlrc+G7mdVJ1P7a8cCSSfOLcR5VzGjYOS OvI3HHI4rPkpfymjlU3UjhP+Faw/9BCT/vgU7/hW0X/QQf8A74FelXTaBH4hmtbcRSWaXVqgYXzk GGRW8yTcG6KVxnOASc9gKi2OjCRZmaBrga4IDN5gDNY4x5nB+6R/y0H54pJUesP6+8P3n8xwH/Ct ov8AoIP/AN8CmN8MoGOTqUv/AHwK9Bc2M+riC1nt4bVb6eCVnnZlEShTG5bOVDBjg9CF+rVpW8Gg DWtBlkktJLUtObyO4dWjiZUZUYhnfaG3cZY54xjOKb9il8AL2l/iPK/+FX2//QRl/wC+BSp8M4Y2 yupS/wDfArt7NPLsbePbs2xqNuMYwOmKmNbvD0rfCY+3n3OH/wCFdx/8/wC3/fFH/Cu4/wDn/b/v iu4o7VPsKfYXtp9zhv8AhXkf/P8At/3xR/wryP8A5/2/74rt6KfsKfYftp9ziP8AhXkf/P8At/3x R/wryP8A5/2/74rt6KPYU+we2n3OH/4V9H/z/t/3xR/wr+L/AJ/3/wC+BXanrTe9NYen2J9vPucZ /wAK/i/5/wB/++BR/wAK/i/5/wB/++BXZ0U/q9LsP28+5xn/AAr+L/n/AH/74FJ/wgEX/P8Av/3w K7SkpOhT7B7afc4w+AYh/wAvz/8AfApP+EBi/wCf5/8AvgV2Z60lL2FPsP20+5xv/CAxf8/z/wDf AoPgKIf8vz/98CuypG6Uewp9hOtPucb/AMIHF/z/AD/98Cj/AIQOL/n+f/vgV2FIelP2FPsT7ep3 OP8A+EEh/wCf5/8AvgUf8IJD/wA/z/8AfArr6Kf1el2H7afc5D/hBIf+f5/++BR/wgkP/P8AP/3w K6+ij6vS7B7afc5D/hBIf+f5/wDvgU3/AIQaL/n9f/vgV2PamUnh6fYarT7nI/8ACDRf8/r/APfA pP8AhB4v+fx/++RXX0w9an6vT7A68+5yf/CERf8AP4//AHyKP+EIi/5/H/75FdZRR9Xp9ifb1O5y X/CEQ/8AP6//AHwKP+EJh/5/H/74FdX3pitI4JRIyuSMtdwIeDjozgj8RTeHpLcpVqj2Zy//AAhM P/P6/wD3wKP+EJh/5/H/AO+BXUo29c4xyQRuDcg46gkH6g4pGWLMshsdNvLhID5EWorG0eTJGGxv ZRnZuI+YdKHh6VrjjUnKVmzmP+EJh/5/H/74FIfBUI/5fH/74FdUVgaK0lOnaRZ3n75ZF06OJcp+ 727vLd++7+LtUVyAYgDBFP8AOmI5lVo2O4Y3hiAVz1yRxnmksPSetipVJqXLc5k+C4h/y+P/AN8i qOpeFpbS2ae2lMyxqWdSpLY4+6ADnuTnGAK9E1OLR/7Nu0trWzmuERd0cqKbfG3D/ZAxGGB+7uPT 7oI4OdJ/x7XP/XvL/wCgGp9hTlFtIHVnFrW55XRRRXmnadz8LdPfWXfTY51gNxdBfMaPeF2xSP0y M/dx1716jcfB6O7lMtzf6dNKcAvJpKsxwMDJMmTxXBfBOGSPXbRpI2VZLkuhYYDDyJxkeoyCPwNe y+NFvJjoVrZFy9xqJR41vpbMSKLadsGWIFgMqDgA5KiqqVJJRXSwQpxbb6nIr8FLaOVZY76wjkRg ytHpm0gj6SVf/wCFX3X/AEHYP/AA/wDx2neJZdT8PeDJE2Pa3EzXe101e5u2TFjO6sskm1gd0Y+X BUdR83Iual411Oy8dpoa6an2YzwQqXZA86yBd0qEyBtqZOQsbg7Tll7RGvOOzt8kU6MJbr8yj/wr C7/6D0P/AIAH/wCO0f8ACsLv/oPQ/wDgAf8A47Xo9c149uXtPCU0yXH2fF1aK0humtgEa5jVg0q/ MilSQWHQE1X1qt/ML6tS7HO/8Kwu/wDoPQ/+AB/+O0f8Kwu/+g9D/wCAB/8AjtGna5a2Nnf3lje6 fdXsaRhY4fEtxqiJG0iq8siPjaqZDEgZxkZXvNpGu6je3cgjv7a5e411rWK4QSmBVGm+YrIm8ZQs u7buKncSDnD0/rVb+YPq9LsRf8Kwu/8AoOwf+AB/+O0f8Kxu/wDoOwf+AB/+O10PgO7vLvwfp7X9 /FeXaQxxzFUZZInCLujl3OxMoOdxO3JP3RXS0vrVX+YPq1Lsec/8Kwu/+g7B/wCAB/8AjtH/AArG 7/6DsB/7cD/8dq7Ff6rMZvCKPIb+G4EUl55z7xYkBhNv258wqTGOfvqzZ4qpq3jXUtH0u1kgtIys 1/qEUlzK26OMQ3DoikySoNzgcfPxtO1SMAL6zVfUPq9JdBv/AArG6/6Dlv8A+AB/+O04fDO8HTXY P/AA/wDx2q6/ErWITEL/AERIPs2LvVComcQWUhTy3QhMM48w7gP+feXHUY7rw/eX2o6Fa3uo2yWt zcKZfIXd+7RiSituAO4IV3cD5s0LEVVsw+r0uxxv/CtLz/oOwf8AgAf/AI7R/wAK0vP+g7B/4AH/ AOO16BPCtxbyQuXCSKUYxuyMARjhlIIPuCCK89uWfw5a+KtXtDqd7PpV4kVtDcalcSxojW8BZmR5 NrKpldzu7D7y4BD+tVv5g+r0uw7/AIVpef8AQdg/8AD/APHaP+FaXn/Qdg/8AD/8drV0bxNqusy6 Cot7W2F7bXVxcbxvO2GWJAU2tj5w5PVgMjlsfNjt4x8Uw6DZ6m8WjyC50WTWPLVJU2JEsbOmdxyW 80YPG3nO7ufWq38wfV6XYf8A8K0vP+g7B/4AH/47S/8ACtb3/oO2/wD4AH/47Wpc63qi6xPY2AtV kl1oWIe4EjqqfYBOW2hhzuHQYB9iS1Y2v/EHVtD8OWN8bS1lu2uLyC4jRGKyfZ5HRihLDbnYW5LM B0VgCQfWq38wvq9LsS/8K2vR/wAx23/8AD/8dpf+Fb3v/Qdt/wDwAb/47XUaHcSz6r4jV5XkSLUU SIMxIRTa27YX0GWY4Hck962qPrNX+Yf1el2PPf8AhW97/wBB23/8AG/+O0f8K3vf+g7b/wDgA3/x 2ta0vvEJ17xFFY2dleW0V+iIbvUJIjH/AKLAxVVETjblieo5Y8dzz2l+NtVtJvCWltEl2t7pWnyy vK486Rpdyu+5pATtChjhHJyclcgk+s1f5g+r0uxc/wCFcX3/AEHbf/wAb/47R/wri+/6Dtv/AOAD f/HaY/iu/wBMjt4Df2MKT3Gru11qIkkCeTebY0G0jjD7QCf7uM4Ct3Ol3ct/pFleXFs9rNcQJLJb v96JmUEqeByCcdO1H1mr/MH1el2OJ/4Vzff9By3/APABv/jtH/Cub7/oOW//AIAN/wDHa9Boo+tV v5g+rUux59/wrm+/6Dlv/wCADf8Ax2l/4Vzff9By3/8AABv/AI7XoFFH1qt/MH1al2OA/wCFd34/ 5jlt/wCADf8Ax2j/AIV3f/8AQctv/ABv/jtd/RR9aq9w+r0uxwH/AAru/wD+g5bf+ADf/HaP+Fd3 /wD0HLb/AMAG/wDjtd/RR9Zq9w+r0uxwH/CvL/8A6Dlt/wCADf8Ax2l/4V5f/wDQctv/AAAb/wCO 131FH1mr3D6vS7HA/wDCvL//AKDlt/4AN/8AHaP+Fe3/AP0HLb/wAb/47XfUUfWqv8wfVqXY4H/h Xt//ANBy2/8AABv/AI7R/wAK9v8A/oOW3/gA3/x2u+oo+tVv5g+rUuxwP/Cvb/8A6Dlt/wCADf8A x2j/AIV7f/8AQctv/ABv/jtd9RR9arfzB9Wpdjgf+FeX/wD0HLb/AMAG/wDjtH/CvL//AKDlt/4A N/8AHa76ij6zV7h9XpdjgP8AhXd//wBBy2/8AG/+O0f8K7v/APoOW3/gA3/x2u/oo+s1e4fV6XY4 D/hXd/8A9By2/wDABv8A47R/wru//wCg5bf+ADf/AB2u/oo+s1e4fV6XY8//AOFdX3/Qct//AAAb /wCO0n/Cub7/AKDlv/4AN/8AHa9Boo+tVv5g+rUux59/wrm+/wCg5b/+ADf/AB2j/hXN9/0HLf8A 8AG/+O16DRR9arfzB9Wpdjz7/hXN9/0HLf8A8AG/+O0f8K4vv+g7b/8AgA3/AMdr0Gij61W/mD6t S7Hnv/Ct73/oO2//AIAN/wDHaP8AhW97/wBB23/8AG/+O16FRR9Zq9w+r0ux57/wre9/6Dtv/wCA Df8Ax2g/Da9P/Mdt/wDwAb/47XoVFH1qr3D6vS7Hnn/Ctb3/AKDtv/4AH/47R/wrW9/6DsH/AIAH /wCO16HRR9arfzB9Wpdjzv8A4Vpef9B2D/wAP/x2j/hWl5/0HYP/AAAP/wAdr0Sij61W/mD6tS7H nf8AwrS8/wCg7B/4AH/47R/wrS8/6DsH/gAf/jteiUUfWq38wfVqXY87/wCFaXn/AEHYP/AA/wDx 2k/4Vlef9B2D/wAAD/8AHa9Foo+tVv5g+r0ux51/wrK8/wCg7B/4AH/47Sf8Kxu/+g7B/wCAB/8A jtejUUfWqvcPq1Lsec/8Kxu/+g7B/wCAB/8AjtH/AArG7/6DsH/gAf8A47Xo1FH1qr/MH1al2POP +FYXf/Qeh/8AAA//AB2j/hWF3/0Hof8AwAP/AMdr0eij61W/mD6tS7HnH/CsLv8A6D0P/gAf/jtH /CsLv/oPQ/8AgAf/AI7Xo9FH1qt/MH1al2POP+FYXf8A0Hof/AA//HaP+FX3Z/5j0P8A4AH/AOO1 6PRR9arfzB9Wpdjzc/C66P8AzHof/AA//HawvFXg+fw1pX2p9Sjulm8yEotsYyMwyNnO8/3fTvXs tcN8VP8AkWIf+u7/APpPNV08TVlJJsipQpqLaR8vUUUVmUerfB29l1HxJayShQYpEhVVztCpayKM Ak4zjJ9yTxmvobaa+bfglLFb6wJ55EihinZ3kkYKqKLeXJJPQAd69jtBqepaZq/imzWRr+7s3XRb abYBFGFzGfYyPhzuPTYDjaaKi29Cqb39TqzLEtwlu00YndGdIyw3MqkBiB1IBZQT23D1qTaa8qvb jxK+rDUdFXxDf3MOmTKBqVjFbCJmuLUuiN5Sgt5aueQ4O35d3IrV0O68ZalouvBprqK5S3Q6bLcR AO043llPmW0A2nEa/c7khs9MrGlz0DaaNprjrLxPfx6Tf67qVne263VylvpWk3KRxTM20KFxwdzy bz8x4UA8DNTTafq/h/wks9pPcXuqx3CXt/5UaM97lh5yKCP7mQgGD8iDJ7lgudXtNG015/NqviCO 10u71K51jT7XUZbp2FrZwy3Ftlla2hMfluT+7EhbCsQ3UgdMmSTU/FHh3RJ7+81SfRzcagt5Lb2c c8rlLgpb74kUqw2KwOEdc4JHRgWC56ttNG014xDpktlO5m8KNqen5ZLG2vtOljQjIPnCOKJ1icn5 SGSPIRWG0swrqbOTWH8Oab4VnlltdavBK87RujSWVkJTg8ludhWNTljuOcnaTRYLnfbTRtNea67N 4n0vxC9npMurDS0EMdraWVpGqogRQQkjW0qnnP8ArHj9OgBNzWvEHjPStWvLGw0C71O2DyNHeBIx gSIBAqfMAQsu9XyMqgDHrklgud9tNG015peat4wh8UW1taprEltHe21vcGSFPLeLeiSS8WuCGGW+ WfK5zhQpUTadrOvXmoSeRea3PP8A21Nb/Z2sIRZLax3bIzed5YPEasMF9xYdCDmiwXPRdpo2mnUU WC43aaNpp1FFguN2mjaadRRYLjdpo2mqWrNdJaq1rJIjBxuMce8lcHtg+3QGs8Xerx20ckVtcXEj F0CSBQM/KQx+VCBgP1A5P0rmqYiNOTi0/krlxg2r3N3aaNprHnur8WMcix3SvPIzgBBmJf4VICOe Rz0POeRVa2vb9n2Xcl7G6xBtsUCuSfMkA3fJ3CrzgDvxUPGU1JRsx+zla9zZewge/hvmjzcwxPDG +48I5QsMdOTGn5e5qxtNR2pmNnAbhds5jXzBxw2OenvU1da1VzNuw3aaNpp1FOwXG7TRtNOoosFx u00bTTqKLBcbtNG006iiwXG7TRtNOoosFxu00bTTqKLBcbtNG006iiwXG7TRtNc1qtxrEOryC3kv Xt2K+XFDCo4wM4YxODzn7zL+XNOvtR12yvZra30+4vItzFbjanyhx+7A5GQr5ByOFAJznNYOvFXu noR7TyOj2mjaa5Wa81tNUhhiW/eKOeKKVnRdrpuVWk4hxgjJ4cEZzgAYqS3vtRnuSY5tQkkF+8fl fZ4xAIVmKk79vZQf4t2R0NL6xG9rMSqo6baaNpp1FdFjS43aaNpp1FFguN2mjaadRRYLjdppisjs 6o6syHa4ByVOAcH0OCD+IqlrMl3FBbm2NwqGYCd7aNXkSPa3IVgc/Nt6AnBPFc40utQSTyWi35gl u2aSeSJUkYCKIISoic4OG6J25xyDhUrKDtZkSqWOwldIImllkSONBlndsAD1JojZJoklidXjcBld TkMD0IPcVz1xbalqPh2zNzNcR3H2mMukcaEsvnrhmDJ1VQG6KOuRjiptbudSt2t7ayF67CPmdAuJ G6YJ8pwDxnoq8/kOqlq07WX4g6ltTe2moFurZ7t7RLmFrlBueESAuo45K9QOR+YrLs9Sv4hbtf29 04msYGAjtycT/N5gOB8p5T72Bx25pkVxcxNot/fQXLMbB0uDHAzMsreU3KKMj7rduPaj2qaTX9f1 uHtDe2mjaawNXguItctrz7ZqKQGGWMm1t0l8okxkDHlscNtJyc8gcjoYVuNYTXjE8l7Lbm4OFWFU VY88cmIgrj/poGx2zxQ6yjJpp7g6lnZnS7TRtNOorexdxu00bTTqKLBcbtNG006iiwXG7TRtNOoo sFxu00bTTqKLBcbtNG006iiwXG7TRtNOrg/ElnJPc639o026uLuSPbpUwtjMqfuQAEZc+UwlLEs2 OMdukzfKrm+Hpe1lyt2/r+vkd1tNG006uDls5G1EtNpt02sf2qrpdNbFx9nFwpG2YZVEEIIKkgkk 8Z6knyhQpe1vd2/r8u7O62mo55Ft7eSeQ4jjQux9gMmpqz9dkSLw9qUkjqkaWsrMzHAUBDkk1TWh gmIt9cMgb+ybwAjPLRA/+h1w/wATNQ83Q4bWS0uIHZpZFMhQghYJAfusf7wrsrnU9JuOP7btkAGd sdyg59fWvP8A4k31ldW9lFBfQXMixXTHZIrNjy8ZwPqKKcrVI2FUtyM+eKKKK1Mj1D4GIy67GWUg G4JGR1HkyivdW8RWyanqcDIVtNLg829u2DBI2I37BxhiE+Y4PGV/vceTfDi90+/1XSY9C/cm2s1g YzRswE+y4JJGQWGWB4PTjIr1my8OWkHhqXRbtmu47mJ0vZXYhrlpARIxOcjdk8A8DAHAFKTuovyK h19TLk8dWK+IILTbcxWf2OaeZ7jT7iJy4lgjjEe5BvyZWGFDHO3pnnRHi7RvsV5dyS3UMVlGstws 9jPE8aMSAxRkDbcq3OMfKT0FZF54D0jUZhaa1q+o6m8tnJBHb3dwmfKEkLlgFVSxV44ssc5yA27I q7ongTRdDstStYYvNj1GMRXOYYYd6AMAuIUQdHbnGeetQWbdvqVpdX17ZwyM01kUW4BRgqFlDAbi ME7SDgE4yM4yKzbHxTZ3emQalMktvZXl2LaykaNyZgx2o5G3KKzZ2k8EFTn5gKqReDI7Pw22iWep XnlXFwJL25uZGluLhDgMu8FdpKqqbh0UdM81sapo1pq2iy6VKHit3RVUwNsaIqQUZCOhUgEe4FAG Vqeu+GdQt3s7+BtRi86WI239my3O54WCuQgRtwVmA3AEZOM1UvvHWladpenf2Ray3bXZlitLVLeW LAhbZJlAhdQrYXAQn2wCQah4OmtdJ0uPw7czQ3+nb0S4luirypId0u9ikiks4VySh5HG3qH6V4Ka 00Wwin1S6j1W1e5kF9aP8w8+UyyLiQMrjO0ZZSTtB4NAFbTvHGoavcGzsNIsmvYozLOs2oNFGq5K 4GYvM3ZByrRrt4zwwzrx+LbB/CR8Q7JGhBaMRRDzXeUSGLy0253EyDaCODwelef+KD8OtIvBaa94 ouzdXDNczGSBbzznDGIsSYXWNgYihEewjYBjgV1/hvT9F1iy0XU9DvDN4etVlktICkoMlwZGDSuz nLYO/AZerFsnjABqXHimysLiOyvorwah9njuJrezsp7sRBiwGWjjIxuRwM4zt6U6+8V6Rp1xcw3M tyDa/wDHw8dnNJHD8gf53VCq/KwPJHWr0emwxazc6orSefcW8Nu6kjaFjaRlI4znMrZ57Dp3yNS8 GWep3N+73+owW2pbft9nBMBFdYQJ82QWXKKqnYy5AGc0AWf+Er0j7X9m825z5/2bzfsc3k+b5nl7 PN2bM7/lxu61RtPFemxeJrrw/Dp19D5WyTzI9NuAjSyyyhycR7VXcm7zSdrbmOflJqX/AIQyzF75 n2/UfsX237f/AGf5w8jz9/mb+m/HmfPt3bc9qu3OhCbXk1eDUb20n8uOGeOHyylxGjMyq4dGI5d+ VKnDHnpgA1qKKKACiiigAooooACcDJ6VmaFq413TjqEUDx2kkjfZncEGaIcCTaQCoY5I9Vwe9Lrm mS6xppsUuzbQyuouCqne8WfmRWDAoWHG7nAJwM4IuI9tbyQ2SPFG5jLRQAgEou0EhfQblHtuHrQB NTQihy4UbyAC2OSBnA/U/nTqKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAz7nWrG0 mlilabMIBlZLeR0TjPzMFIHHPJ6UtzrNjaXX2WaSRZzjaggdi+f7uB82O+M474qnf+FNM1C+lu5o z5k2PN+VG34AA5ZSV4A+6RVm70S3vL5bySe6WePHkskxURY67VHBz3yDkcdKwvW10Xl6Ee+NXXIG 1eXT/IugyBMP9mlIJZmXn5cBfl+9nByeeDVW81xdInaJ7W2jQsWWFLgefLuY/MsQX5snJ65PPetG XTg+oi9jup4ZNqpIse0rIqkkAhlP95uRg89ahutFW88yOe9u2tpG3Nb7l2nnOM7dwH0YYpSVWztv /X9f5g+axp0UUV0FhRRRQAUUUUAV7u9gsY0ecvh22KEjZ2Y4JwFUEngE/hWbb+Ird5rlZVnAWcxw olrKZCojjYlkClhgv1IA6fjoX1hHfpEGklikhk82KSJsMjYIz6HhiMEEc9Ky5/CdhdZe4knnn81p RLLscgsqKflKlcYReq8dsVhU9rf3CJc3Qfquvpa6THdWaNK8sqxIWglKqTIEYsAuQRk/KcEkYFWz qa29pBLcLIxkUEmK3kJzgc7MEqPY9Khax0+x06100zJDGJkeJWZVLMJA/AGBy2OAO9RanoNrq8qS ztJ8q7QpRXGOeRuU4PuMHinee/Ufvbl+21O2u5fLhYufJjmyFOCj7tpBIwfunjqOM4yKp2uqS3Wo 2pjeN7G8tGuYR5LJIuPLxkk99542gioYfD0FosC2t5ew+Vax2vyvu3xpnbncDzy3zDB/SnDQ4ljs BBeXUEllD5EMqMCShCghgQQ33FOSM+hGafvtK43cfeeIoLLVUsHt7pnaJ5d0dtK4+UoONqHP3+3T 8ali16znumtovOaRXMZxBIVDA4ILbccHvnFJfaWLqeK4S7uLa4hR0SSIjBDlSQVIKn7o5Iz6YzUD eH7Z9QF4005fzBKB8vUHON23fjttzjHGKGqi2F7xuUUUZrUoKKTcPUUuR60AFFJkeopQQelABRRR QAUUUUAFFFFABWPfaxc2OsWFqbSFrW8lMImM5Dq4jd/ubMEYj67u/Stiuf1rRH1K9trldWvrRrdi 8a24iwG2su/5kYk7XIxyOnGRmkyoct9TfzWQNYuV8SR6XNaQrDNBJNDMs5LNsMYYMhQAf6z+8ela 3asG40R5tfg1QarfxtENogQReWELIWXlC3zGMZOcjnBXNFmEOW+vY3881neID/xTeqf9ekv/AKAa 0KzvEP8AyLeqf9ekv/oBqo7ozlszhLnq31/rXG+I/wDj8h/68rv/ANBWuyuerfX/ABrjvEX/AB9x f9eV3/6Clez9k8z7R5BRRRXknoHp3wOlit9UlnnkSKGKUvJI7BVVRDJkknoAO9ev2g1PUtM1fxTZ rI1/d2brottNsAijC5jPsZHw53HpsBxtNeSfAf8A5DTf9dv/AGlJXubeIrZNT1OBkK2mlwebe3bB gkbEb9g4wxCfMcHjK/3uCp09CodfU4G9uPEr6sNR0VfEN/cw6ZMoGpWMVsIma4tS6I3lKC3lq55D g7fl3citXQ7rxlqWi68GmuorlLdDpstxEA7TjeWU+ZbQDacRr9zuSGz01ZPHViviCC023MVn9jmn me40+4icuJYI4xHuQb8mVhhQxzt6Z50R4u0b7FeXckt1DFZRrLcLPYzxPGjEgMUZA23KtzjHyk9B WZZkWXie/j0m/wBd1Kzvbdbq5S30rSblI4pmbaFC44O55N5+Y8KAeBmnXllq/h/waRYT3t54gml8 15LeCN/tNy3UOGAVYhwM5UhVABz16a31K0ur69s4ZGaayKLcAowVCyhgNxGCdpBwCcZGcZFZtj4p s7vTINSmSW3sry7FtZSNG5MwY7UcjblFZs7SeCCpz8wFAHPrq/iax8Padq9za6xd3NvcOmqaatrF vYMhA8oKPmRZNhUqxyrNuJxxNeTeI7HTtBTUL3VVD20h1K602zinljuDsKLsEb/JzKuVQ9Fyec1t y+LtGiLKJbqVxLLDsgsp5XLRELJhUQkhSwBYcZOM1nap4/061sLGbToLi/nv3mS3gEEqN+5bZKWX YZBtbggIW9sAkAHgvjDQIb3VIJNcvruxkgtZpilzFbpPMHv7xtxR5oRkjBxHn7wwAMV6Rp9lo1l8 OtBhtLKfU/sOtu2n3dvYveOkEep5dxJGjbcxrnjG4DjPSl1Oz0X4i6yj3vhOyvdWt7bEjTaxPbxp EHbCjCBywYvkNGpXjJwVz1+galoHh/4dQXek2kkOl25kjitYmadzKZmQxocsXJlJAIJByMcUAdXB MtzbxToJAkiB1EkbIwBGeVYAqfYgEd6krj4/HUFlPrUeuQXFsNOlQO1rY3FxHGhtopWLyohXhnfn 5flAJAzk6194r0jTri5huZbkG1/4+Hjs5pI4fkD/ADuqFV+VgeSOtAG1RXMXPxB8OWklwk1xej7O JjI66bcsgEL7JWDCMgqjcEgkCrp8WaQLz7N5tznz/s3m/YpvJ83f5ezzdmzO/wCXG7rQBtUUUUAF FFFABRRRQBm67rEWh6abl0MszusNtbqwDTzMcIi5IGSfyAJPANcPfaRf6Jq2gzSXutGZrW9fUdR0 yxS4dppHtjhl8pwFOzaoC5AQdgxr0onAyelcbH47STUdOY2dyNLv4LuW3eKznnmlWJ4FSTYiFlRh JIeQcgIcjdigCpJqHiRNP0iS/fWrW3l+1/aZ7KyimuU/ej7NvjCPjdFu3bUOGwDiqyap4mTyn1Vv EFrA8DPbtY6fDNJK4nmwkyiN/LYxeQeirktlgQa6keMNGa0t7lJLuRbgyiOOOwneU+U/lyZjCFxt YgHIFQTePPD0LorXN25bZ/qtPuJNpaVoVDbUO0mRGQBsHIoAw9dstclsPCWqX19q1tc2zxtqMOm2 0M5gkNtMryKoidmO9whA3LtJIXI3DuLBt+nWzebPLmJD5lxH5cj8Dl12rtY9xtXB4wOlY8fjXRJ0 jaCS+mL5ykWm3DumJHjO9BGWT543HzAfdNbVpdwX9lBeWsglt7iNZYnHRlYZB/EGgCaiiigAoooo AKKKKACiiigAooooAKKKKACiiigDktZvdfj1S5itBMsQKi38sKwb5QTn90/8WerL/WrN/c6r/aiC 1e8+xHb57xwxts9PLyMtn+LhsDpg5rUudZsbSaWOV5sxAGVkt5HROM/MwUgcc8npS3OsWNpdfZZp JVnONqCB2L5/u4HzY74zjviuZxV2+fr3/Az06sx9t3B4oklkutS8qaGHY0dujRsQ8mYyQhKgAjk4 OGPzHHFLWoi8s72VjL9qzn5LUmdzuPMc5OxcjoDwO/HFdAmuQNq8un+Rdbo1TD/ZpSCWZl5+XAX5 fvZwcnng1X1DxA2nXJSeCADPyRC5zcSDOAUiCndnHHOamSpcur0+8T5bbm5RRRXWahRRRQAUhpaK GBR1O4mt7MtCsjOTjMYyV4zno3p6HrWXBeamw2ztcpEJGHnJGpfG1SvBQZGS38OeBWzeXcFlGjzl 8O4VVSNpGY8nAVQSeAT+FZtt4gt2lullFxhZzHEi2spkIEaMSUC7hgvjJHp61yVYpzu528h+0Udx 95I8mlowW4mMcsTkMgEhAkUk7QBzgHjHNTy6rBD9lUhy9zJ5cabcN7kg4OB3P09aralrkVvpcdzb CWRppFiQ/Z5GCnzAjbgFyCCT8pwSRgc1ca+jtbSCScXEjSIDmKzlYk4GcqASvXoefyqlyqTtLsLn VyKW7kg1B1kSZoXjXy9ke4bwX3dORxt6/wCNZCXOpg25eS7bdFGSixIpLYG7koR1J6lcY+mehtr2 2uyBBLvJhSccEfI+dp59dp/KqMN7NcarbCOeGSwu7VriHEJVwFMeMknkHzCegxUVKXNrzvXt6jU4 rUp38+ppfyJCsnl/8sioBDfL3xG2MHPVlq/DFcyXtzJJczLEkgCRBU2ldqk9snkkdabc61BZ6oli 8N026N3Lx20r4wUwBtU7h8/JHTGDyafHrFjPcvbRG4eRJDE+21kKBs4ILbduM984pRhBSfNO+vcH UjsjRrEsp79r5lnFz9m+byWZU+b/AH8cj/Z6cdea0Bo+nhw4srcMCCG8pcgjoc4q5traUJza1tb8 RppHOx3F/PfpGFnihkZlbcg/dDYSMZjA67e7VJpkUyieCW5vRIWlA82JcHLnDg7cZwemcc9K3sUY qYYdppt31ByObtkure0vUWa9NyizlFlhTDHeSrA7cEnI4zjnpW1aQSQAiS4lnJ7yBRj/AL5A/wAi rWKXFVCjytNsHIKKKK3JCiiigAooooAQk9q47xG1nB4k0i5OnXEk9vMZJbiCwklZYjFMuN6qeN5H y5JHUjHNdjis291C5tNY062+zRPa3khh87ziHRxHJJ9zbgjEeM7geenFKVrGlK/M7Lo/y1NFTlQf auDulsZ/E0dva6Df29zHfJJJq02nO27EgJWNwpO1sFckqoUkjtXekZ71jXer6hZXCNPpsCWTXMdu sjXf71i7hFYIEIxkg/eBxUz23NMN8T0v21t/w5sgYrO8QD/im9U/69Jf/QDWlWd4g/5FvVP+vOX/ ANANaR3RzPY4K56t9f61x/iEf6Un/Xjd/wAkrsLnq31/rXIa/wD8fI/68Lr+SV7P2Ty18R49RRRX knoHqHwMWVtSuBA6JMXOx3Qsqt5UmCQCMjPbI+or3Wy8OWkHhqXRbtmu47mJ0vZXYhrlpARIxOcj dk8A8DAHAFeGfAuaK31G6nnlSKGJi7yOwVVUROSST0AHevW7QanqWmav4ps1ka/u7N10W2m2ARRh cxn2Mj4c7j02A42mip09CodRt54D0jUZhaa1q+o6m8tnJBHb3dwmfKEkLlgFVSxV44ssc5yA27Iq 7ongTRdDstStYYvNj1GMRXOYYYd6AMAuIUQdHbnGeetcde3HiV9WGo6KviG/uYdMmUDUrGK2ETNc WpdEbylBby1c8hwdvy7uRWrod14y1LRdeDTXUVyluh02W4iAdpxvLKfMtoBtOI1+53JDZ6Zlm1F4 Mjs/DbaJZ6leeVcXAkvbm5kaW4uEOAy7wV2kqqpuHRR0zzWxqmjWmraLLpUoeK3dFVTA2xoipBRk I6FSAR7gVzll4nv49Jv9d1Kzvbdbq5S30rSblI4pmbaFC44O55N5+Y8KAeBmpptP1fw/4SWe0nuL 3VY7hL2/8qNGe9yw85FBH9zIQDB+RBk9wBmoeDprXSdLj8O3M0N/p29EuJboq8qSHdLvYpIpLOFc koeRxt6h+leCmtNFsIp9Uuo9VtXuZBfWj/MPPlMsi4kDK4ztGWUk7QeDWVNqviCO10u71K51jT7X UZbp2FrZwy3Ftlla2hMfluT+7EhbCsQ3UgdMmSTU/FHh3RJ7+81SfRzcagt5Lb2cc8rlLgpb74kU qw2KwOEdc4JHRgAdLd/DXSr4Mbm+v53llM1w9wIJzNIQBuxJGwQ7VVf3YThR6Vp23hS2tLrTUgkK 6ZpyvJDZkuxa4diTK7ljvxlsAjqxOc4x5tDpktlO5m8KNqen5ZLG2vtOljQjIPnCOKJ1icn5SGSP IRWG0swrqbOTWH8Oab4VnlltdavBK87RujSWVkJTg8ludhWNTljuOcnaTQB1F14bs7uw1+zkknEe t7vtJVhlN0CQHZxx8qA855z24qpqXgyz1O5v3e/1GC21Lb9vs4JgIrrCBPmyCy5RVU7GXIAzmsDW LnXtNuNSsdMGsQNAiJoltZ2MUlrMvkoAJJCjbNsgfO5k+XBGai1bWdebXPEtvp95rbXNrMkOm2tt YQvau5tonxJKYyV+dySWdeCMZ6UAdHceCtNubW4t3nuwk9vqFuxDrkLeSiWUj5eoYYX0HXPWqX/C s/Dq+IjrSQlZzd/bWTyomzPu37vMZDKPm52hwvtjiq0lle6f8R5rqfVte+y3sFqsRgsY5oWKzTEw yMsBKIokXDEqcO2XOBjuqACiiigAooooAKKKKAM3XNMl1jTTYpdm2hldRcFVO94s/MisGBQsON3O ATgZwRJ/ZNsNUs79NyPaW0trFGuAgSRoyeMdR5K457n8I9d1iLQ9NNy6GWZ3WG2t1YBp5mOERckD JP5AEngGuVubTV/D8Gmwve6q0dyJ5tV1DTbOO4lN0TGU/d+W5CYEijahwFQE96ANqTwfa4gktdQ1 CyuoJrqWO5gkTeBcSmWVCrKUZS2MZUkbV5zyWW/gfS7VGWOa8+drV3Z5dzO8Fy9yGJIJJaSRi3sc DbXOXGs68kmgQX95rdiLmG/nm+xWEM1wUSaIQGRBG+P3cgyEXIZhnGDg1K21+6sPDmr319rtube/ laaO1s4JZYoilykUxjWJzvKvErKAQAx+UEZABp6j8LvD2pzi5mWT7TumJmeOGYlZJpJiu2WNlADy vggBscZNdbYWUGm6da2Fquy3tokhiX0VQAB+QosG36dbN5s8uYkPmXEflyPwOXXau1j3G1cHjA6V YoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMS/8KaZqF9LdzRnzJseb8qNvwAByykrwB90i rN3olveXy3kk90s8ePJZJioix12qODnvkHI46VjavdeIY9UuktEnWLC/ZdoBR/lGc4icj5s/eZen HrVrVJ9VTWEW0+3/AGH5PtDxwxN5fPHl7hlv9rhsDpzXJeleXu9ddPx/X8TK8ddDUl04PqIvY7qe GTaqSLHtKyKpJAIZT/ebkYPPWobrRVvPMjnvbtraRtzW+5dp5zjO3cB9GGKotBcW3iiSWS81HyZ4 4Qhjt0dCQ8hMbERkqoDDkkH5j83HFHWrQy3Ev2GzkW6L/eFkxmY7uqXBJRBjpnp+gJzXK/d67X/r ft1G3psdfRRRXWaBRRRQAUUUUAVb6wjv0iDSSxSQyebFJE2GRsEZ9DwxGCCOelZMvhfTL1pDNPLc XCTF2kkKSFHZEBBUqV5VUOCvGeMA1e1mS7igtzbG4VDMBO9tGryJHtbkKwOfm29ATgniucaXWoJJ 5LRb8wS3bNJPJEqSMBFEEJUROcHDdE7c45B5a8oJ+9G/9f1qZTceqOj/ALMsbLR47Qv5NrbyLNvJ VACsgkyeMAbhzwPwqHUNDsNdeG6llaSMxgKF2OjqecjcDjOfvLg+/SqNxbalqPh2zNzNcR3H2mMu kcaEsvnrhmDJ1VQG6KOuRjiptbudSt2t7ayF67CPmdAuJG6YJ8pwDxnoq8/kpShy6x92yBtW1Whb TQYYVgFvd3cPlW6WzGN1zJGmdobI4PJ5XB5qJbGx8y0sLXU3hvNPg8pRFKhlEZCg7lIIwcIc49Md aZZ6lfxC3a/t7pxNYwMBHbk4n+bzAcD5Tyn3sDjtzTIri5ibRb++guWY2DpcGOBmZZW8puUUZH3W 7ce1F6dtF/V193cd10NO804Xc8Nwl1PbTxKyLJDtztbBIIZSD91e3aqr+HrR9UW/aSUyLJ5gGE4P +9t349t2O2MVV1eC4i1y2vPtmopAYZYybW3SXyiTGQMeWxw20nJzyByOhhW41hNeMTyXstubg4VY VRVjzxyYiCuP+mgbHbPFOc4czUovf+uom1fVHT0UUV1GoUUUUAFFFFABRRRQAUUUUAFFFFABWVqm ivqd5a3A1W9tDatviSBYSofaylvnjYk7XYYzj2zzWrXMeIWs7fxHol4dPuJLmCZmluYNPlmZYTDM oXeiHjey/LnvnHepna2pvh1Jz93ez6X6frsdPXPf8Iop17+131nVJJRIXSGV4nijBPKorIdgxxlS Gx3roa4S7axufEyW9t4fvre5S+R5dVn0+Rg22QMVjcKx2tgrklVCkkZGKmpbS5phFNuSi7aa6J6f 12O7rO8Qf8i3qn/XnL/6Aa0azvEH/It6p/15y/8AoBraPxI43scFc9W+v9a5LXv+Pj/uH3X/ALTr rbnq31/rXJ67/r2/7B11/wC069j7J5a3PG6KKK8k9A9W+Af/ACF5/wDrp/7Tevcv7etv7XvrTdEt vp9uJry6eUBYWOSEPp8gLHJGAV/vV4X8CFla/vRA6JMSdjuhZVby2wSARkZ7ZH1Fe42Xhy0g8NS6 Lds13HcxOl7K7ENctICJGJzkbsngHgYA4AoqdPQqHUyT4/0k61BCLtIdO+wT3c811BJCRtkgSMrv A3K3msAQDuIAB7HTTxhoTWN1ePemGK0ZBci4gkheHecIXR1DKpJ4YjHBOcA1kXngPSNRmFprWr6j qby2ckEdvd3CZ8oSQuWAVVLFXjiyxznIDbsiruieBNF0Oy1K1hi82PUYxFc5hhh3oAwC4hRB0duc Z561mWbcGp2VzqF5YQ3Cvc2YQ3CDP7veCVyemSBnHXGD3FZ1l4psLmzgvJpEgtby9NpYyl9wuTyF YEDADFW284I24PzAVTi8GR2fhttEs9SvPKuLgSXtzcyNLcXCHAZd4K7SVVU3Doo6Z5rY1TRrTVtF l0qUPFbuiqpgbY0RUgoyEdCpAI9wKAMrVdf8K3tvLZ6iYNQQXL25tPsjXReWMAuBGFYtt3DJAIUn BINVL/x7oOmaTpsmnz2JivHlhtPPnWzgAhO1yWccKpGOFJORgEc0ah4OmtdJ0uPw7czQ3+nb0S4l uirypId0u9ikiks4VySh5HG3qH6V4Ka00Wwin1S6j1W1e5kF9aP8w8+UyyLiQMrjO0ZZSTtB4NAF ex8cXmq3p0/TbHSLq8jhFxK0esBoPKJIUo6xlmOQ2QUXGBk8jOvH4s09/CTeIiwFuquCiurFpFYp 5akHDEuNox1JGOtZV38NdKvgxub6/neWUzXD3AgnM0hAG7EkbBDtVV/dhOFHpWnbeFLa0utNSCQr pmnK8kNmS7Frh2JMruWO/GWwCOrE5zjABXuvGsGn65aaTe6dqCzy2jzzG3sri4WN18r5EKRESD96 cuvClQDgsBUl14u8N6Rql5ZySvHeecBcCGxmcyS+UjAZRCHfy9hwCTtX0U4vatoQ1O8tb2LUb3T7 y1SSNJ7XyySkhUspEiOpBMaHpnjrTf8AhG7P+1f7R8yfzv7Q/tDbuG3zPsv2bHT7uznHXd3xxQBU 0/x54a1V4BZal5qTymCKbyJFheTJGwSFQm4kcLnJ4xnIro64Xwt8OItB0i00241XUJ7OzvHuIbPz 1MR2ztJCzYQNkDYSoITcCcHqe6oAKKKKACiiigAooooACcDJ6VyN348tbTR4tT+xXM9tc3y21q9v DLMssZmSIy5jRgvLMVU/fAG0ktgbmuaZLrGmmxS7NtDK6i4Kqd7xZ+ZFYMChYcbucAnAzghdU0a2 1TSP7NZpLeING8bW5CtE0bq6FcgjhlU8gjjpQBm33izw7YfY9QvzNbySwzGF59PmWVIlZBKWBTdG ufLJ3YBAB6DNRL8RPDDzzQJfXDTwKHniFjOXiU5+Z12ZVeM5OBgg9CM2L3wnBqdmYNQ1G+upG0+6 09538pXaO4KFiQqBdw8tQCAB6gnms1vAsh8Z65rkGs6hZJqsFssi2sqhi0aujAhkIA2+XhgdwO/B ANAHXQTw3VvFcW8qSwyoHjkjYMrqRkEEdQR3qSq9jZW+m6fbWFpH5dtbRLDCmSdqKAFGTyeAOtWK ACiiigAooooAKKKKACiiigAooooAKKKKACivHYfCOi3XxoneW0YyR3tzdq4mcN5iw2MgOc5wGlkO 3p82MY4r2KgDPudb060nkhnulVoseaQpKxZ5G9gMJxz8xFLc61ptndfZbi7jjuPl2xNne+44G0dW 59M1Tv8AwppmoX0t3NGfMmx5vyo2/AAHLKSvAH3SKs3eiW95fLeST3Szx48lkmKiLHXao4Oe+Qcj jpWF62ui8vT+v66ke+NXXIG1eXT/ACLoMgTD/ZpSCWZl5+XAX5fvZwcnng1X1HxCNLncXSWkSLyE e8UTOucZWPHOccDOT068Vfl04PqIvY7qeGTaqSLHtKyKpJAIZT/ebkYPPWobrRVvPMjnvbtraRtz W+5dp5zjO3cB9GGKUlVs7b/1/X+YPmsadFFFdBYUUUUAFFFFAFe8vrawiWS5lCBmCIMEs7Hoqgck 8HgelZtv4jtHkuhLLgLcGKBEicyuBGjN8mC2QXIPHHGa0L6wjv0iDSSxSQyebFJE2GRsEZ9DwxGC COelZMvhfTL1pDNPLcXCTF2kkKSFHZEBBUqV5VUOCvGeMA1hUdW/uWIlzdCfUteht9LjurMmfz3W OJ0heRAS4Q7to4IJPynBJGBzVt9ShtbWCS6dy0ibvkt5MngZOzBZRz36d6j/ALMsbLR47Qv5Nrby LNvJVACsgkyeMAbhzwPwqHUNDsNdeG6llaSMxgKF2OjqecjcDjOfvLg+/Sk3V3Vr2Wn5h7xow3lv cSFIZVkPlJNleQUfO0g9DnafyqlBqEs+q2wjlhksLu1e4hIiZXGDHjJJ5B3k/dGOKRNBhhWAW93d w+VbpbMY3XMkaZ2hsjg8nlcHmolsbHzLSwtdTeG80+DylEUqGURkKDuUgjBwhzj0x1pt1NLr+v8A hrg2ya61yC01VLF4Lpi0buXjtpXAwUwBtU7h8/JB4xg8mpV1qwa7NsszNIr+WSInKB842l8bc54x mnXmnC7nhuEup7aeJWRZIdudrYJBDKQfur27VVfw9aPqi37SSmRZPMAwnB/3tu/Htux2xihusnpa 1/w+8Hz30NeiiitywooooAKKKKACiiigAooooAKKKKACs291G5s9X062+yxPa3khh87ziHRxHJJ9 zbgjEfXdnJ6cVpVlapor6neWtwNVvbQ2rb4kgWEqH2spb542JO12GM49s81Mr20NaXJze/tZ997a beZq1iXmsahZXCNPp0Edk9zHbLI13+8Yu4RWCBCMZIP3gcdq2657/hFFOvf2u+s6pJKJC6QyvE8U YJ5VFZDsGOMqQ2O9Er9CqHs7v2n6/p/wToazvEH/ACLeqf8AXnL/AOgGtGs7xB/yLeqf9ecv/oBr SPxI53scFc9W+v8AWuU1z/XP/wBg66/9p11dz1b6/wBa5XWv9bL/ANg26/nFXsP4Ty18R4zRRRXk noHqvwHmit76/nnlSKGLLvI7BVVQjEkk9AB3r1uyfU9RsdT8VWlsr3k9kyaNaTDGIwCyFzu6yttJ 5GFCA4INeU/s/wD/ACFLz6j/ANBNe3f29bf2vfWm6JbfT7cTXl08oCwsckIfT5AWOSMAr/epT6eh UOp55dXfi06gNQ0ePVdSvoNJnRTqmmC1WKV57Xei4ChsIrMo+bleGk5A19BvfG+oaJriu5S5hWN9 Nlubdg8kgyXjcPDACp2quQgwHJ3EjjTPj/STrUEIu0h077BPdzzXUEkJG2SBIyu8DcreawBAO4gA HsdNPGGhNY3V496YYrRkFyLiCSF4d5whdHUMqknhiMcE5wDUFmRZ+KdRTTL7XNSsrm1iuZo7bStJ uI1iuHfG3nJ+87k8HACoG6ZNTT2etaB4ZW7tH+2aml0L3UY4IATeKx/exoCcghSNnOf3ajnJrooN TsrnULywhuFe5swhuEGf3e8Erk9MkDOOuMHuKzrLxTYXNnBeTSJBa3l6bSxlL7hcnkKwIGAGKtt5 wRtwfmAoA5m41nxIlrpt1qE19ptnqU88jC1sElurVcL9ng2YcklBIznYxB4+UcjJku9c8SeG9EvL mQ3enm5vxeM2mNcq5SdkgD28Misy7Q3TeMgZz96uz1XX/Ct7by2eomDUEFy9ubT7I10XljALgRhW LbdwyQCFJwSDVS/8e6Dpmk6bJp89iYrx5YbTz51s4AITtclnHCqRjhSTkYBHNAHDJY3MF481z4Pt 72wK7LKyk0q4hgzxumSJRMIWY8bXCcIrAjcwrq7KfWT4c07wtM32fXL2OZpiGDNZWfmMA5+cndsK IvzN83PIVqs2Pji81W9On6bY6RdXkcIuJWj1gNB5RJClHWMsxyGyCi4wMnkZ14/Fmnv4SbxEWAt1 VwUV1YtIrFPLUg4YlxtGOpIx1oAwtV1jVdC07xJptjpupNcQwn+whaWBljVBbIFAYArlZRIdrnJG AA2QKq+KdT8X2vieWPS2vWtAIxBBBZZVyQNxMhidW5PRpIenX+I9W3ijTLW0vZNRuobWbTkiN/Fu LeQ0igqAcAvknAIHJ468VLqniTStFmWLULh4SVDs/kSNHEpJAaR1UrGuQeWIHBoAzra31+88R6rK +rXFrYWt7ElrbfZI9k0XkxM+WK7mBZpACpGGByWxtHTViv4r0aPWZdJNzIbyKVIZVW3kZY3cKUDO F2ruDrgkgEnHUEVtUAFFFFABRRRQAUUUUAZuu6xFoemm5dDLM7rDbW6sA08zHCIuSBkn8gCTwDXP wtqPha605rxLq8t7tLqXUpbGzabN2zRGM7VDOECiRB1AAXd2NdkTgZPSsPS/FNhqUluvmJGL6WZd PO/d9qjixudTjHPJAycqNw4zgA5TVNX8XP4fsbm3GoWcsl7e+cv2AvKsQmcQKdkUu35NvPlsGAzu HVtCyfxVqo0CGa9vdMEtndS30q2kTPvWSIRAlkKqxVnPKjIDfIp+70H/AAk2ktpEOqxXLz2c8hjh e3gklaVgWB2Kilm+6xyARgZ6c1BN4z0CGKxk+2vKL5JHtlt7eWZ5PLIWQBUUtlSwBXGRzxwcAGzb JNHawpcTCaZUUSShNodsctt7ZPOKlqK2uIby1hubdxJDMiyRuOjKRkH8qloAKKKKACiiigAooooA KKKKACiiigAooooA4OT4f6g3iI6rHr0cbfb2vA4t5hPtZo90RYThCpSKOPBjICqOM5J7yiigDlNY vfEkWq3CWcIEC7fsv7sssvyjdv2o3fI+9H/WrWqXWtRawsdkszWHyfaJBbKzRZP/ACzywLcdflbH bJ4Gjc63p1pPJDPdKrRY80hSVizyN7AYTjn5iKW51rTbO6+y3F3HHcfLtibO99xwNo6tz6ZrmcVr efXvt5f1/wAEystfeM1oLi28USSyXmo+TPHCEMdujoSHkJjYiMlVAYckg/Mfm44o63bPJNMdOstt 4WIDPYyNIW3H5kn3BVGOgPA7+lba65A2ry6f5F0GQJh/s0pBLMy8/LgL8v3s4OTzwar6j4hGlzuL pLSJF5CPeKJnXOMrHjnOOBnJ6deKiapuL97S/rYHy23Nyiiiuw1CiiigAooooAzdamvYbeA2gkCt MFuJIohI8ceD8yqepztHRuCeDXNmfXoGne1juDBNds0txJBslKiKIIQoRuuGzhD0/h6V115fW1hE slzKEDMEQYJZ2PRVA5J4PA9KzbfxHaPJdCWXAW4MUCJE5lcCNGb5MFsguQeOOM1y1oxctZ2M5pX3 Kdxb6pqXh2zN3LLFdfaYvMjgiXDL564Yh1JBCgN0AznIxxUuuXWq2zW9tYLcyMI8mcIP3jdACRGw B7nIUc8EVY1LXobfS47qzJn891jidIXkQEuEO7aOCCT8pwSRgc1bfUobW1gkunctIm75LeTJ4GTs wWUc9+nehqOqUtbLW/8AW4rLoyja6pfI0El9aXOJ7KFwkNuSFm+bzFPdeqfeIHHXrUcVxcxNot/f QXLMbB0uDHAzMsreU3KKMj7rduPatmG8t7iQpDKsh8pJsryCj52kHoc7T+VUoNQln1W2EcsMlhd2 r3EJETK4wY8ZJPIO8n7oxxTasl71/wDh1+ug2vMpavBcRa5bXn2zUUgMMsZNrbpL5RJjIGPLY4ba Tk55A5HQxG71oa+I/wB+9uZ9uwQbUWPPXJTB47+YD/s9q0rrXILTVUsXgumLRu5eO2lcDBTAG1Tu Hz8kHjGDyalXWrBrs2yzM0iv5ZIicoHzjaXxtznjGaTUHJ2nbXv/AMETSvuX6KKK6jUKKKKACiii gAooooAKKKKACiiigArmPELWdv4j0S8On3ElzBMzS3MGnyzMsJhmULvRDxvZflz3zjvXT1m3uo3N nq+nW32WJ7W8kMPnecQ6OI5JPubcEYj67s5PTipnsb4dtSdl0fW2ltfwNKuEu2sbnxMlva+H723u UvkeXVp9PlcNtkDFY3Ck7WwVySqhSSMjFd3WJeaxqFlcI0+nQR2T3MdssjXf7xi7hFYIEIxkg/eB x2pTSa1LwspRk+VXfrb/AIf0Nus7xB/yLeqf9ecv/oBrRrO8Qf8AIt6p/wBecv8A6Aa1j8SOR7HB XPVvr/WuW1n/AFk//YMuv5xV1Nz1b6/1rmNY+/c/9gu6/wDQoa9h/CeWviPFqKKK8k9A9W+A3ni6 1M2yxtcBCYhISFLbTjcQCQM+gr2+x8OWsPhmTRbzddJdROl7I7NuuGkBEjE5yM5PQ8DAGABXhHwW nltLTxBcwNsmhtXkRsA4YRsQcH3r3TSbnUJdRKSNdS2vkFpHubUQmOXIwq4xkY3f3sYHzHNOcbpM lVUp8ljMu/h5p2pqyaxqOqapGbVrVUu5lwqGSOQfdVcsGhQ5OSejbuMWdE8CaLodlqVrDF5seoxi K5zDDDvQBgFxCiDo7c4zz1p8f9vReHYrw3Us97JBGZIGtkBjJK7iq/KdwXdwTyQOB0KJd619kvza rcXKp5X2eS5tRHI2W/e/JlM7VwRkLk8c1PJ5i+sLrF7X/rUiTwctj4cOiWN7dPFdXIe/urq5ZriW M43gMAOSqrHxjC89Rzs6po1pq2iy6VKHit3RVUwNsaIqQUZCOhUgEe4FN0mWSXzt9xezKNuGurYQ kHnIHyrkdO34ntpVLVnY2hLmV0cjfeEJLPSdMj8Pyzpf6eJI47mW/Mbskh3Sl2MUquXdVYgp15BG ME0rwY9vo9kk9/dW2qWst3JHd2k+9lWeYyspMilZP4Mlk6rkYrrqKRRxl38NdKvgxub6/neWUzXD 3AgnM0hAG7EkbBDtVV/dhOFHpWjbeFoLS+02KABNJ01HlhgMzsz3DsSZHz97ALEZJ5cngqDXRUUA Yep+FNP1XX7HWLiS6We02/uo5isU21i0fmL/ABbGJZenJ5zWT4l+GuieKr25udRluSbiPYyhYm2Y XAKM8bOmODhWCk8kHJz2VFAFOy02GxutRuImkL39wLiUMRgMIo4sLx02xqec8k/QXKKKACiiigAo oooAKKKKAMvXtOuNW04WEMvlQzyKt04dkfyc5dVI5ywG3qMBic5AqPXfDdlr+kR6dLLc2iQsrwTW UnlSQkAr8p7fKWXp0JqxrWqLo+lyXfkvcS7ljhgQgNLIzBUQZ45JHJ6DJ7VxV+2q6BqGj2DalfRv fw3t7qc+maeLh2mDwbSqFXYKu/YMBvlxkfxKAdDrfgnS9b07T7CQywW1gnlwxIscqbcAAFJUdTgK MEjcOcEZOZNC8HaZ4dXT0sGnEdhFdQwo7AgLPKsrA4A6FAB7dcnmsxZ/FV7onh5GmmsLy5v5I7yZ LRCy2wjnKMyHcsbNthJ7Bmxj+E19ZuPEem3sdpJqOrNapab4b2w0qO4e4uN7/JKoUhQE8vkKgYlj uXGAAd3RXCXupeJxNpw1P7fpls+mxSTy6RYLduLw58yI8SlUHy4IQg5PzjHPZ2DSvp9s8+/zmiUy b0CNuwM5UE4Oe2TigCxRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBiX/hTTNQvpbuaM+ZNjzf lRt+AAOWUleAPukVZu9Et7y+W8knulnjx5LJMVEWOu1Rwc98g5HHSsi+1DVRf6olnLdPLBIq2kCW qvE5MSMVd+MDLd2XGep6DUuI9RuNXmjhvJLa2S3jZCIVYNIWfPJHTAXIHPI5HflXs23aPX8dTP3d bIsS6cH1EXsd1PDJtVJFj2lZFUkgEMp/vNyMHnrUN1oq3nmRz3t21tI25rfcu085xnbuA+jDFZv2 vWf7Q24ufN+2bPI+yjyPs+/G/wAzP3tnzfeznjbU8NzqLai63T3kTC5KxwxWgaFot2AxfnkryfmX B/h7FuUHo0/6+f4fgHMn0N6iiiuk0CiiigAooooAq31hHfpEGklikhk82KSJsMjYIz6HhiMEEc9K yZfC+mXrSGaeW4uEmLtJIUkKOyICCpUryqocFeM8YBq9rU17DbwG0EgVpgtxJFEJHjjwfmVT1Odo 6NwTwa5sz69A072sdwYJrtmluJINkpURRBCFCN1w2cIen8PSuWvKCdpRv/X9amU3HqjpP7MsbLR4 7Qv5NrbyLNvJVACsgkyeMAbhzwPwqHUNDsNdeG6llaSMxgKF2OjqecjcDjOfvLg+/SqNxb6pqXh2 zN3LLFdfaYvMjgiXDL564Yh1JBCgN0AznIxxUuuXWq2zW9tYLcyMI8mcIP3jdACRGwB7nIUc8EUp Shy6x92yBtW1WhcTQYYVgFvd3cPlW6WzGN1zJGmdobI4PJ5XB5qJbGx8y0sLXU3hvNPg8pRFKhlE ZCg7lIIwcIc49Mdaba6pfI0El9aXOJ7KFwkNuSFm+bzFPdeqfeIHHXrUcVxcxNot/fQXLMbB0uDH AzMsreU3KKMj7rduPai9O2i/q6+7uPToad5pwu54bhLqe2niVkWSHbna2CQQykH7q9u1VX8PWj6o t+0kpkWTzAMJwf8Ae278e27HbGKq6vBcRa5bXn2zUUgMMsZNrbpL5RJjIGPLY4baTk55A5HQxG71 oa+I/wB+9uZ9uwQbUWPPXJTB47+YD/s9qc5w5mpR6/11FJq+qOmooorqNQooooAKKKKACiiigAoo ooAKKKKACsrVNFfU7y1uBqt7aG1bfEkCwlQ+1lLfPGxJ2uwxnHtnmtWuE8S2clxca0LjTLm4u3j2 6VMtsZlX9zxsZc+UwlJJZscAfURUdkdOEg5VLJ2+V/Lr/Vju657/AIRRTr39rvrOqSSiQukMrxPF GCeVRWQ7BjjKkNjvXQ1wk1nI+pFptMuTq/8Aaiul0bYuPs4uFIKzDKonkggqSCSTx6qdtLorCqTb 5ZW+V/6Xdnd1neIP+Rb1T/rzl/8AQDWjWd4g/wCRb1T/AK85f/QDW0fiRxvY4K56t9f61zOr/euv +wVdf+hQ101z1b6/1rmtV63n/YKuf/Q4a9h/CeXH4jxSiiivJO89Y+AnkCbVzdbDbiMmXzMbdu05 znjGM17tb63YXSSPFJLtSMyndA65UdSuVG4fTNeG/s/xia61aNiwDR7SVOCMjHB7V7Xpui2WlXzP HMWuJYzhWEaEqCMnCKu7BI5OSM9eeXK1lcm9RS921upPNrmmQBTJexDdB9oGDnMeQA3HYlgB6npS xaxZzW8s0f2hlixuT7NJv5OAQm3cR7gdjWfZ6HFa2l79skELXkijCTlliXPyRqWAGNzHjGDuxg1e 0rRrfSFlEDOxlILEqijj/ZRVUdeuMnv0FS1FCjKs2rpWKmm+IEk0OLUtQkEQnZdiLbyKRuUEIAcm Q9fmUYPYcVq2l5DexGSBmKg7SHRkYH0IYAjqKqSaLbyaPb6Z5kohgRERvlJIUYGQQVP4jFS6bptv pFm0ELN5e4uxbaBnvgKAqjjoABQ+V7Dp+1TSla1vxLtFR29xBdwLNbTRzRNna8bBlODg4I96kqDd NNXQUUUUDCiiigAooooAKKKKACiiigAooooAjlghmMbzRRuYm8yMuoOxsEbhnocEjPua5keMdD2W +p3YVTPLNb6a8MTXE1zEpXeyLGpbYSgPGQQEbPIxra9p1xq2nCwhl8qGeRVunDsj+TnLqpHOWA29 RgMTnIFVtf8ACtj4gs7e1mkkgitwQiRxxOmMAYKSo6HpwduRzgjJoAtwa/pdw1isd0N1/wCYLYMj KXKffXkDDDn5Tg8Hjg4zf+E+8NMIDBqLXXnh2jFpbS3BZUcxs+I1PyblYbuhxwTVXWfCDnwVb+Ht FOwxOvlXM100UltyT5iFFPzDOAo2rg4yAMU/Vvh/pGrWtlaM88FrZ2620UISKZRGowB++R8HH8S4 Y4GTwKAOnt54rq2iuIHEkMqB0dejKRkEfhUlQ2ltHZWcFrEXMcMaxoXcs2AMDJPJPHU06OeGZ5ki ljd4X2SqrAlG2hsN6HaynB7EHvQBJRRRQAUUUUAFFU9N1bTdZt2uNL1C0voFco0lrMsqhsA4JUkZ wQce4q5QAUVGZ4VuEt2ljE7ozpGWG5lUgMQOpALKCe24etE08NsgeeWOJC6oGdgoLMwVRz3LEADu SBQBJRRRQAUUUUAFFFFAGdLq2m2d5NAz7Zsh5jHCzBTgYLsowOAOp6YqWfVbG2F0ZrlI/sqhpt2f lB6H3z0GOp461S1TQrG8ma8u53jRBucnYAoUdQxXcnT+Ej1qS/0o32sWVy4Cw253sVlYGQjJVWUD BAbawyeo6Vg3VV9F5EXlcmXWrB7s2yzM0gfyyRE5QPnG0vjbnPGM9arpq7z+Ijp8SukUUYaQvay5 diXGA2AqgbM7jkNnA6U0aFY3GpDUVneR0lLDbsOHBII3hd+AQQV3Y4xjtWktqiX0t2C3mSxpEw7Y UsRj3+c/pQvay3tv+H3guZ7le11qwvZlit5mcsSFbynCPjk7WI2n8DV+si08PWlnqIvlklaVchdw QdeuSFDN/wACJ9etaQuYDdG2E8f2gLvMW8b9vTOOuPerpudv3m44t/aJaKKK0KCiiigCteX9tYLG 1zIUEr+WmFLFmwTgAA84Bqt/b+m7FYXDFmZkEQicy5UAsPLxu4BBPHGR61bntUuJraVywa3kMqY6 ElGTn2w5/Sqc2iQyXj3kdzcwXLOX8yJxwCiKVwQQQRGp5BORxispe0+zYl83Qn/tWyNlHeJN5sEh 2oYkaQsecgBQTkYORjjBp1rqNpfMRbTCQhFc4B4BLKPxyjDHUY5qhceGrK4soLVpJ9kLO+WKyb2c 5YsHDAkkk9OM8YpLXw1bWKIlndXduoUxsI3X50Ls4U5HGC7YIwcHrU81bm2VhJzvqiS58QWsB08p HcTR3mGR47eRgEKMwIwpyflHy9QDnoKkl1/TIGKy3JTaFaQtGwEO4ZHmHGIzgjhsUraPF/Z9jaRz zxfYgvkSoV3gqhTJyCD8pI5GOahn8Pw3Hnh7y98u5AF0iyACchQuTgZUkAA7NuaL1vL+vn3D3zXo oorcsKKKKACiiigAooooAKKKKACiiigAooooAK57VfEstg980FlHNb6em65kkuPLOQnmFY12ncwT 5sEjr1roaxL/AMM21/LeMLy9t475dt5DDINk42hOQwO35QBlNpOKmfNb3TfDukpfvdv67eV/mbdc 9L4llW6yllG1iLsWhma4xIzmVYiVj2nKq7BSSw+nr0NYh8M232gsl5epbNci7a0EgMTSh/M3cgsB vG7AYDPaiXN0Cg6V37T+vu69uht1neIP+Rb1T/rzl/8AQDWjWd4g/wCRb1T/AK85f/QDWkfiRzvY 4K56t9f61zeqf8v3/YJuf/Q4K6S56t9f61zmp9L/AP7BFz/6Mgr2H8J5kfiPEuB2FFL+VFeSdx6v 8B2uUGuvZxrJdLbkwo3Rnx8oPI4zjuK9ahk1R9Q+0Qi8uZo9OuPL+12ghUTExkJ/CCCV9ex+Y9vK /wBnySOG41maV1jjjiDO7HAUDGST2Fe0R+ILWfUo4o5VW2+yy3EskqNHtClAGBbA24ZuenHWqu7L ToZVFFvWVtf1Ode58R3VpIk8UrhTBJgQMzpKs8ZwoMaArjccZbp96taO81Zbe7kj+13EEUkDRSTW wjmdd/75QuBkBOnyg8nGeDWiPEGllHc3WxUUOTJGyZQkDeMgZXJHzDgZ61NcavYWouDNcKotigmO CdhcgKDgd8j6Agnik5PblIjTive9pfTv6/18jIu9T1Oa6kNnDeRWIEIaQ2n7xQfN3sisMk5EYwQc Dnaeprym/wBV8N69Cbm7Z4mkjiH2dEklTyFIRl2nqWPQBue3QaV9rekSaXdPcRvcwwjM1ubVmccF huRh8o+XhmwOOtSw3+k6dp3mRRGztjLsWP7I8RZyM/Km0En6DsfShXXQGoybTqaWd9e9/wACprB1 OxtLSOzurh8FvMlEAZz/AHR8kbBfwQ9Oo76ekyXUulwPeK63BB3BwAepx0x2x2H0HQTWl5DexGSB mKg7SHRkYH0IYAjqKnqG9LWOiEPe51K67BRRRUmwUUUUAFFFFABRRRQAUUUUAFFFFAGfrWqLo+ly XfkvcS7ljhgQgNLIzBUQZ45JHJ6DJ7VxuuQeJNA0exWwu5jd3M8txqVxaWTSGSRsYC4jmKKPuj92 3yoASMc99LBDMY3mijcxN5kZdQdjYI3DPQ4JGfc1hR+NNHayiu3adYriaSO0CRGZ7tUODJEkW5mj /wBrA4wehBIBky63r2leD9O8QX8U7/Zg7alZGJBLJGSQrL93DLhTjC5BOVU4Ax9Wv/HtlaaWZbm4 +0yWxmuY7KwyBMzlvKDrFOAEXCchc4zvOTjch8S6DrOhWl5rkVpdeZf3X2CFbRrh38ieSNJI4gGc sECksBxu7ZxW1b+K9BulZodUt2VbQ3rMTgCFWKs5J/uspDDqp6gUAZ+pXmpXul6bokW+DVtSts3M u0A2kYVRK5AbhsttUAn5jnkKaxoItf0TxFqa2Fg0Xh7+0oQ5toN9xsFpbICitgGIFCrFQ7cEAAjN dXdavpNlozeJGCmF7ZHWVY8SSoeY0GcEklsKp7tjqaqy+NtDtrmW2vLiW1uLcot0skDlbVnRXAlk UGNeHHJbbnOCcGgDlfFesePrXxNeRaTaYs4xH/Z4WJ3juTtBcS7YZMfNuXmSHgA89a6W2t9fvPEe qyvq1xa2FrexJa232SPZNF5MTPliu5gWaQAqRhgclsbRNqPjHTdM1xNInttVe4aJ5d0GmXEyYXZn BRDu/wBYvK5A6MQSAZE8YaHJqr6bHdyPcRz/AGd2S2laJJc42GULsDZIGC2c8UAYsZ8VLANTbULp 2Gstb/2cbJAhtDeGIMcLvyIjvDggbQCQeScrwprHj668S2kOuWnkwuZPt0Jify4AFYoYn8kL94KP 9dLkE9Oo9LooA5jS7r+zfFOv2t3bXcYvbxbq3uPsztA0YtYUJMoBRCGicYYg9MZyKgs31TULLU/F NpbK95PZMmjWkw24jALIXO7rK20nkYUIDgg11c0MVxBJDNGksUilHR1DKykYIIPUEU5VCqFUAKBg AdqAPJ7q78WnUBqGjx6rqV9BpM6KdU0wWqxSvPa70XAUNhFZlHzcrw0nIDjd+MNS8K6ot7BdTGC9 06WycWjtcErco0mUaGAMFCqw+QDGcseo9XooA8/tta8RW13HORrF9ocN3GJJ59M8u6dGhmDjylRW ZFk+zkFY1PLfeAJqa51vxFc2l/cW1vqVrZ/2ukQk+wBriGy+zITJHERlyZc9VZgGb5crtHdVBeWV pqNo9pfWsN1bSY3wzxh0bByMg8HkA/hQBz3grUr/AFGPWlvrm5uBa6h5Fu91bLBL5XkQuNyADBJd jyAeei/dHUVWsNOsdLtvs2n2VvaQA58q3iWNc9M4AA7D8qs0AFFFFAHKeIZNUli1e2AvAjQlLWK3 tRIk6mP5tzckHcWGMr0GA3c1i98SRarcJZwgQLt+y/uyyy/KN2/ajd8j70f9a09Y8QWum2t95cqv dW8LPs2Myq23KhyOFzxwSM5qxc63p1pPJDPdKrRY80hSVizyN7AYTjn5iK5JRi3L37f09DJpa+9/ WpiWcmqW9wYoBebjqMuYHtQIfJaZiz7zjnaSR83p8p6m62pX6xm3Nvdm7F8FLi3ynkGcYO7G3Hln HqOp6E1pf2rY9PtKZ+0fZdvOfN/u465xz9OenNRLrumtceSLnDeaYNzRsqeYDt2biNu7I4GcnjHW qUVFW5xpJdTHstQ1U3+lx3kl0ks8jLdwPaqkSERuwVH5yMjqGbOOo6G3YWV5Zz61MLq5lkaT915s UeJD5MeG4Vc4IK8EDj1yafp91o9zqkxttOkiu1kKtM2nvGSSoYkuV4yG/iIJ/EZuWutWF7MsVvMz liQreU4R8cnaxG0/gamCi7XnfXTXysJJdzN0G51Wa8kS9M7wiPO+SLYN2RwMxoemf7w9x36Giiui nBwjZu5pFWVgoooqxlDU/tjPYxWcrxCS4KzSLGH2p5bnuMD5gvPrjr0ORNcaxBcm3lmu/scczq13 DaK8rDZGycAEYy0gJCH7oHFb9zdw2iI0zMA7bVCoWJOCcYAJ6A1XXWtPYgLOWYjKosbFmHqFxkj3 HFc1R01KznZ+v/BF7OUtVcybjUNaTRbQtbzrdSSOHkSLBVATsyqrJtZhtP3SByOKdpeq6ooVtVs7 rLw4RYoC37xZJAckDjK+WcnCnqMVsHU7MQxSiYOsufLEal2bHXAAJ47+neq9vrVs8AeWUbi0hCxo zHYHZQxAyQMDqeOtQ5RU1+86f5bgqU99TLuotQmsNCvp7i/jkQI1ysECM0bGFwX2bCc7mCkYIAPT vTbu91lGuPszXrOqIbFPsQK3GUBJlPGw7twIJjxjoa35NSsIghkvbZN6h03SqNynoRzyPes648SI l1LBaabeXwiKq0lu8IUsU8wKN8iljsIbgHg1XLHZT/HyHHDznpE26K5W48f6PDOkUWZ2aKOXi5t4 uHUMoxLIhJ2kHgEc1f1LxH/ZCTzXmlXsdrDn/SDJBtf02jzdxJ7DGTnpW/tInQ8LWTSas3tsbdFY MniqFLkRjTr14DdC1+0qYdhfzViJAMm8gOwUkLW9VKSexnOlKFuZBRVFdXsnZVSVn352FY2IfAJO 0gYbgHpmpoLuKW0a5Mq+UC+XZTHtCkg5DcjGMHPp2qI1YSdotP5kuLW6LFFZv9s2xvETzVSHyXkd 5VKYwyBSC2ODuPPeotS8S6ZpunS3huI7hYygZIJoy3zOqA5ZgAMsMkkAVKr0ntJFRpTk1FLVmvRW PoXiO11/7R9mTb5G3d/pEEv3s4/1Uj46d8e2ecbFappq6FUpypy5ZbhRRRTICiiigArhPEtnJcXG tC40y5uLt49ulTLbGZV/c8bGXPlMJSSWbHAH1Hd1g6p4qh0x73/iXXtzFZDM8sJhCqRH5hUB5FLE J82ADxWdRJrU68HKcal4K7+7qv8AhjerhJrOR9SLTaZcnV/7UV0ujbFx9nFwpBWYZVE8kEFSQSSe PXu6wZPFUKXIjGnXrwG6Fr9pUw7C/mrESAZN5AdgpIWiaT3DCynFvkV/w+Xnft1N6s7xB/yLeqf9 ecv/AKAa0azvEH/It6p/15y/+gGto/EjjexwVz1b6/1rndS+7qP/AGB7n/0ZBXRXPVvr/Wuf1D7m p/8AYHuf/RtvXsP4TzI/EeI0UmKK8g7T1v4AW8V4+uW067oZoPLdckZU8EZHI4Ne2DQIWdmuru7u w1tJalZpBjy325HygHPyjnOfUnjHi37PW/7VrOzG/wAobd3TPHWvdYft4lCzfZnj6l03KT7bTn88 /hTd7KzHyRk/eRnWHhXTdPaYxx7hLC0BBjRfkOMjKKCeg5JJofw8keif2dbXE7FriKZ55pSZG2yI xO712rgfQVt0VPPK9w+r00uVL+mZq6JAYb1Lie4uXvYvJmklcbimCAoCgBcbm6DvRLpH2nTzaXN9 czjfuEkgjLDjGCNm1h/vA/yrSopczK9lC1rFLTNMg0q1NvblipYudwA5PoFAUDjoAB+dXaKKG76l xioqy2CiiikMKKKKACiiigAooooAKKKKACiiigDL17TrjVtOFhDL5UM8irdOHZH8nOXVSOcsBt6j AYnOQKj1Lw9Bfy2U8F3dadc2SPFBPZsoKxtt3IVZWQqdidVONoxitiigDjrz4aaFf6ZZWdy1xM9l LcTQXM/lzuDPIZJMrIjI2SerKSMDnOSZZ/h3oc+j6bpebqG3sGcqLeQReakjbpI3CgDY5wSoA6DG K6yigDJvNKlv9fsrq4dTY2SNJFCHOXnPAZh0IVc468uTgFQax5vBRv8AUtekvtTvEsNUuEaSytpg sc0QgijKvldyklHzsYZUgEnoOuooAydW0IaneWt7FqN7p95apJGk9r5ZJSQqWUiRHUgmND0zx1rM k8B6ZL4kTW5Li5a4jn+0IpWL5Xzn/WbPN2/7O/bjjGOK6migAooooAKKKKACiiigAooooAKKKKAC iiigDJvdAhvTeD7XdwJeDFxHFINrnaFzyDjgAcYBxyDUV/4U0zUL6W7mjPmTY835UbfgADllJXgD 7pFbdFZSo05bolwi+hnf2Na/23/au6fztuPL80+Xuxjft6btvy59KrWug7c/abud0+1yXQgSTEe4 yl0PQNx8pIzjI6Gtqim6UL3sHIilHpwi1GW7iup0EzB5YBtKOwUKDyuRwB0I6VVtPD1pZ6iL5ZJW lXIXcEHXrkhQzf8AAifXrWvRT9nF62DlQUUUVZQUUUUARSwLNJA7EgwuXXHc7SvP4MapLosMckMs U9xFLDAtujqwzsXPUEYOfp2GMVpUVnKjCTu0UpNbFEaVEkcIhmniki37ZVfLHectndkHJ55H0xVZ /DljIFLGRnUMN7hXJBYtj5gR1Y84z71r0VEsNSlvH+v6Q1UkupUOm25SJA06rGgjURzugwOnCkCq M3hyJ7mea31DUbT7QFFwsM+RLhQoJLBip2gDKlScdc1s0VoqUFshxqzi7pnPy+ELI2s1pa3V7Z2k 8KwTwQyKyyoEEYB3qxB2KFypBOOuajl8I+brD6n/AG9q4nLM0aM0MkcGe0avGwXjjI5x1JrpKKOS JosVWXX8jEPhm3+0FlvL1bZrkXbWnmAxNKH8zdyCw+cbsBgM9q0LW3niurueaZn85xsjDErGoGBg HoT1NW6KPZxun2M5VZy+JmNHpVwlxCqytHa27N5I87eVBRlGAU7ZHUt0q5BpqRWs9tJPNPDNu3LJ tH3iS2CoB5LH+mKu0VnDDwht/X9WE5tlAaUhlEkt1dykRmMZl24UlTwVwc/KOc5PfNLJpUTQyJHc 3sTOABIty7MvIORuJHb06ZHQ1eoqlRprVIXPK97mdp+kixuZ7qS9uby5nRI2luNgO1CxUAIqjq7d s81o0UVolYJSc3dhRRRTJCiiigArEv8AwzbX8t4wvL23jvl23kMMg2TjaE5DA7flAGU2k4rbopNJ 7l06kqbvF2CsQ+Gbb7QWS8vUtmuRdtaCQGJpQ/mbuQWA3jdgMBntW3RQ0nuEKkofCwrO8Qf8i3qn /XnL/wCgGtGs7xB/yLeqf9ecv/oBq4/EjN7HmetXj2jIEeNd5bO/bzjHq6/1/Csu6cyWt+5IJbRL g5HT/WW/uf5mujuerfX+tc/qH3NT/wCwNc/+jbevXfwnmR3PEMUUYoryTtPX/wBnghbzWCxAAjBJ PbkV7zFdW86hoZ4pFJwCjggn04rwb9nhQ13rCsAQYwCD35Fe8/ZoPP8AP8mPzsY8zaN2PTNErWXo aRvqS0UUVBYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWd4g/5FvVP+vOX/wBANaNZ3iD/AJFv VP8Arzl/9ANVH4kJ7HBXPVvr/Wuf1D7mp/8AYGuf/RtvXQXPVvr/AFrn9Q+5qf8A2Brn/wBG29ew /hPMj8R4h+P60UuKK8g7T2D9n9St5rAiA3eSNu7pnI617lD9vEoWb7M8fUum5Sfbac/nn8K8Q/Z/ IW/1diQAIgST25Fe6RXVvOoaGeKRScAo4IJ9OKctloXElooorM0CiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKzvEH/ACLeqf8AXnL/AOgGtGs7xB/yLeqf9ecv/oBqo/EhPY4K56t9f61z+ofc1P8A 7A1z/wCjbeuguerfX+tc/qH3NT/7A1z/AOjbevYfwnmR+I8RoooryDtPY/2f1DX+rqwBBiAIPfkV 7p9mg8/z/Jj87GPM2jdj0zXhH7P5c3us7Npfyhtz0zkYzXuUP28ShZvszx9S6blJ9tpz+efwpy6e hcS1RRRWZoFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVneIP8AkW9U/wCvOX/0A1o1neIP+Rb1 T/rzl/8AQDVR+JCexwVz1b6/1rn9Q+5qf/YGuf8A0bb10Fz1b6/1rn9Q+5qf/YGuf/RtvXsP4TzI /EeD/aT/AHB+dFQ0V5Gp6Vke4/s+sFvtXZiABECSe3Ir3aK6t51DQzxSKTgFHBBPpxXhP7Pqhr3V 1YAqYgCD0PIr3b7NB5/n+TH52MeZtG7HpmnO2hMLktFFFZmgUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABWd4g/5FvVP+vOX/0A1o1neIP+Rb1T/rzl/wDQDVR+JCexwVz1b6/1rn9Q+5qf/YGuf/Rt vXQXPVvr/Wuf1D7mp/8AYGuf/RtvXsP4TzI/EeA0UUV5B6R7h+z9v+2axsxv8obd3TOR1r3KH7eJ Qs32Z4+pdNyk+205/PP4V4d+z4Qt7q7MQAIgST25Fe7RXVvOoaGeKRScAo4IJ9OKqZMCWiiisjQK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigArO8Qf8i3qn/XnL/wCgGtGs7xB/yLeqf9ecv/oBqo/E hPY4K56t9f61z+ofc1P/ALA1z/6Nt66C56t9f61z+ofc1P8A7A1z/wCjbevYfwnmR+I8ByPf8qKf gelFePZno3Pbf2fAHvdXVgCpiAIPQ8ivd/s0Hn+f5MfnYx5m0bsema8I/Z8z9t1jaAW8oYBOB1Fe 6RPeGRRNBAiY5KTFiD9Cg/nVTuKFixRRRWZoFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVneIP +Rb1T/rzl/8AQDWjWd4g/wCRb1T/AK85f/QDVR+JCexwVz1b6/1rn9Q+5qf/AGBrn/0bb10Fz1b6 /wBa5/UPuan/ANga5/8ARtvXsP4TzI/EeC0U3f7UV5Nz0LM9v/Z7/wCP/V/+ua/zFe914J+z6oe9 1hWAKmIAgjg8ivc4rCzgkV4bSCN1GAyRgED8BRO2gQLFFFFZmgUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABWd4g/5FvVP+vOX/ANANaNZ3iD/kW9U/685f/QDVR+JCexwVz1b6/wBa5/UPuan/ANga 5/8ARtvXQXPVvr/Wuf1D7mp/9ga5/wDRtvXsP4TzI/EeA0UUV5B6R7j+z7kXur7QC3lDAJxzkV7n E94ZFE0ECJjkpMWIP0KD+deG/s+Ai/1bPXyl/mK9e0TxVY69pE+p2sN2sECRuytFuch4I5xtVNxY 7ZVGBk5BAzxlz6CgjcorkdB8ZJqNpq2p30jW2n21y0MKyafPC6hZXiGWfiRmZR8iKCpO0jccVrQ+ J9NntLm5jF+RbbfNhOnXAmAY4UiIpvIPPIUjg+hrMs2KK5/S/GWlatoY1eNNQgtfKilP2mwmjJEn 3QmVxIckD92WHIwTkZraj41sbaPSLqCQtaXOoNZXIe2lE0ZEEsgUR4DhyyIMFSSG6cg0AdTRXOaj 430fT9FTVf8ASJ7dmmQrHFtkRooZZnVkfaVO2Fhg4OSOgOR0dABRWXrGtDRjZtJYXc8FxcR27Twm PbA0kiRoXDOGILOPuhsYOcU7UdTu7KdI7fQtQ1BWXJltnt1VTnofMlQ578A9aANKisXw54mtPE0N /JaQ3EX2K8ezlWcKCZFVSSNrEFfmGDnn6YNbVABRRXMz+M0ht7q8GiapJp1pJNHPeq1uI08p2SRs NKHIBRui5IHANAHTUVhSeK7NfEkOipbXUrSTfZ2uownkxzeU8vlsSwbdsjJ4UgZXJGay3+IlnDpM Or3Oj6nb6XNsK3cjW5UbiByiylxtySw25AVvSgDsaKxtP1u9vrmGN/DerWkMg3faLh7bYgxkZCzM /PT7vU84rZoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoornW8VSW0kC6h4e1SxSeeO3jkmktWBd3 CgYSZmPJycDgAntQB0VFVdT1CHSdJvNSud3kWkDzybBk7UUscD1wKzYPEcj6la2d5omo2H2p2jgm uHt2SRwjPtHlyswO1WPIA4oA3KKKKACiiigAooooAKKKKACiiigAorDuvFNra+KbfQWtbppZgmbl Qnkxs6ysqMS27cRC/RSOV55o02/1JvFWraXey2ksEFvb3Vs0MDRsqyvOux8uwYgRD5gFzk8UAblZ 3iD/AJFvVP8Arzl/9ANVPDt/qV1LrFpqktpNPp96LdZbWBoVdTBDLkqzuQcykdewq7ri7/D+pJnG 61lGf+AGmnZ3Ymro4C56t9f61z+ofc1P/sDXP/o23rt5PCmsOzEyWO08gB3yP/Ha5rXdAvNLsNTn vJoGJ0qdFWEHvJCSST9BXpfWaTXKnr6M4fYVIu9tNex830UUV552nt/wFuILW91V55o4U8tVBdgo znpzXuP9r6Z/0EbT/v8Ar/jXxW00scL7JHXgn5WI7Un2m4/57y/99mrlyvchNrY+u5LHQn0K40ka tAIZ7mS6Z2eCUh3nM5wHVkxuYgZUkDHORmq/hfRtA8KPeGy1qORbrZujZraKNCueVSFEUE7uTjJw PSvkz7Tcf895f++zR9puP+e8v/fZqbQDmkfUr+FtFl8P2+hzeLrqawtvKEEcklowRI0ZAhHlYdcE Ehw3KKfXKWfhHw7p1hHbWPiN7V49ROopPA1pGVlMPkkBBEIwuwnjZnJzmvlv7Tcf895f++zR9puP +e8v/fZotAOaR9h6ONJ0hLrGtJdTXc/nzzzzRbnfYqZwgVR8qKOAOlaX9r6Z/wBBG0/7/r/jXxV9 puP+e8v/AH2aPtNx/wA95f8Avs0WgHNI+vfEEGna/BBCfEz2McUqTYtJbc73R1kQnzEf7rIDxjPO ciqWu6Pp3iG2t7a78Y3aW8SIJIopbXZcMv8AFKrRENnuv3OB8or5P+03H/PeX/vs0n2q4/57y/8A fZotAfNI+qdO8P2OkrOun+Ob22SZ1d0j+wBcrGkYwvkYUBI0GBgcfWtUXUo1qwf/AISa1Ol21sVm RniMt3MeAzkKAoAGfk25J6ADB+QftNx/z3l/77NJ9quP+e8v/fZp8sA5pH2v/a+mf9BG0/7/AK/4 1xOpeCPCer6jPd3+rW8wmlMjxmCwGQW3FfMEPmY7Z37vfPNfL32q4/57y/8AfZo+1XH/AD3l/wC+ zRyxDmkfVdn4Q8GadNp0lhqE9slhcm6ihTWZmiLlWByjSEc7yTjGehyCwOWPhv4KMSQy6rFLCqxq VZLJXcKV4aVYRIc7cN8+SCfWvmj7Vcf895f++zR9quP+e8v/AH2aOWIc0j6+0+OGxuIXfxrdXcMY x9nuJLTYwxgZKxK/HX73Uc55FbP9r6Z/0EbT/v8Ar/jXxR9quP8AnvL/AN9mj7Vcf895f++zRyxD mkfa/wDa+mf9BG0/7/r/AI0f2vpn/QRtP+/6/wCNfFH2q4/57y/99mj7Vcf895f++zRyxDmkfa/9 r6Z/0EbT/v8Ar/jR/a+mf9BG0/7/AK/418Ufarj/AJ7y/wDfZo+1XH/PeX/vs0csQ5pH2v8A2vpn /QRtP+/6/wCNH9r6Z/0EbT/v+v8AjXxR9quP+e8v/fZo+1XH/PeX/vs0csQ5pH2v/a+mf9BG0/7/ AK/40f2vpn/QRtP+/wCv+NfFH2q4/wCe8v8A32aPtVx/z3l/77NHLEOaR9r/ANr6Z/0EbT/v+v8A jR/a+mf9BG0/7/r/AI18Ufarj/nvL/32aX7Vcf8APeX/AL7NHLEOaR9rf2vpn/QRtP8Av+v+NH9r 6Z/0EbT/AL/r/jXxT9puP+e8v/fZpftNx/z3l/77NK0Bc0j7V/tfTP8AoI2n/f8AX/Gj+19M/wCg jaf9/wBf8a+KvtNx/wA95f8Avs0fabj/AJ7y/wDfZotAOaR9q/2vpn/QRtP+/wCv+NH9r6Z/0EbT /v8Ar/jXxV9puP8AnvL/AN9mj7Tcf895f++zRaAc0j7V/tfTP+gjaf8Af9f8aP7X0z/oI2n/AH/X /Gvio3VwMfv5eoH3zQ13PuKiaUbT13nninyxHzSPtX+19M/6CNp/3/X/ABo/tfTP+gjaf9/1/wAa +KPtVx/z3l/77NH2q4/57y/99mjliHNI+1/7X0z/AKCNp/3/AF/xo/tfTP8AoI2n/f8AX/Gvij7V cf8APeX/AL7NH2q4/wCe8v8A32aOWIc0j7X/ALX0z/oI2n/f9f8AGj+19M/6CNp/3/X/ABr4o+1X H/PeX/vs0farj/nvL/32aOWIc0j7X/tfTP8AoI2n/f8AX/Gj+19M/wCgjaf9/wBf8a+KPtVx/wA9 5f8Avs0farj/AJ7y/wDfZo5YhzSPtf8AtfTP+gjaf9/1/wAaP7X0z/oI2n/f9f8AGvij7Vcf895f ++zR9quP+e8v/fZo5YhzSPtf+19M/wCgjaf9/wBf8aP7X0z/AKCNp/3/AF/xr4oN3cDH7+Xk/wB8 003lx/z3l4/2zUvkQXkfbP8Aa+mf9BG0/wC/6/40f2vpn/QRtP8Av+v+NfEn2y4/57y/9/DS/a7n /n4l/wC+zTtEd5H21/a+mf8AQRtP+/6/40f2vpn/AEEbT/v+v+NfEv2u5/5+Jf8Avs0fa7n/AJ+J f++zRaAXkfbX9r6Z/wBBG0/7/r/jR/a+mf8AQRtP+/6/418S/a7n/n4l/wC+zR9ruf8An4l/77NF oBeR9tf2vpn/AEEbT/v+v+NH9r6Z/wBBG0/7/r/jXxL9ruf+fiX/AL7NH2u5/wCfiX/vs0WgF5H2 1/a+mf8AQRtP+/6/40f2vpn/AEEbT/v+v+NfEv2u5/5+Jf8Avs0C7uOvny/99mi0AvI+2v7X0z/o I2n/AH/X/GuP/wCEU8PS6xHqt54hW7vkmim8+SOxSVmjZWXMkcKvj5ApG77vFfLH2q4/57y/99ml +1XH/PeX/vs0WgLmkfXkEpuP7aTVPEVk8F6zR2sETQlbaHbtB+ZfnZs7iH3KOABjOcrRvCPhXRdb h1ZNUtZrqHeY2MVlDtZhgtmGJCTgkckjk8V8sG7uFUt50hwM43mphcz/APPaT/vo0+WIc0j7Q/tf TP8AoI2n/f8AX/Gj+19M/wCgjaf9/wBf8a+LGuZ94HnS/dJ++fam/abj/nvL/wB9mhxiHNI+1f7X 0z/oI2n/AH/X/Gj+19M/6CNp/wB/1/xr4q+03H/PeX/vs0hurj/nvL/32aVohzSPtb+19M/6CNp/ 3/X/ABo/tfTP+gjaf9/1/wAa+KPtVx/z3l/77NH2q4/57y/99mnyxDmkfa/9r6Z/0EbT/v8Ar/jR /a+mf9BG0/7/AK/418Ufarj/AJ7y/wDfZo+1XH/PeX/vs0csQ5pH2v8A2vpn/QRtP+/6/wCNH9r6 Z/0EbT/v+v8AjXxR9quP+e8v/fZpr3dwFJ8+Xj/bNJqCQc0j6rvPCPhW+vby+l1y5F9c3kd556al t8uSPb5eIwfLO0KANyMcdSa1biDTpfEQ1mDxM9pI0UUM0EMtuY5kjd2UNvRmH+scHay8H15r4+N5 cA48+X/vs0fa7nP/AB8S9f75pe4O8j7Bt4NOtNfu9Ug8TOkd3KJp7Lzbcwu4iWIHJTzBwinh+o9M ir2p6jYXGlXkMV/aNJJA6KPPQZJUgd6+MPtdz/z8S/8AfZo+13P/AD8S/wDfZptQfcLyPsOfxDol yqs93LbzAYOxG3Ad1JUEEfQn2rm/F2o2F5oGoLZSKY49PmTGNvJaMgAHBPCsenavmD7Xc/8APxL/ AN9mj7Xc/wDPxL/32alQgpKQ3KTi4kNFFFMD/9k= --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 3.jpg" Content-Description: Picture (Enhanced Metafile) 3.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 3.jpg"; creation-date="Thu, 08 Nov 2012 06:14:05 GMT"; modification-date="Thu, 08 Nov 2012 06:14:05 GMT" Content-ID: <428b4712-c267-496e-87b9-eb459823e57c> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAIvAu0DASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD0P/hV 2lf9BTVf++of/jdL/wAKv0v/AKCmq/8AfUP/AMbrS8YahcWCaOkN7e2cdzfmGaSxtRcTbPImcBUM b5+ZFzhTxnpzWNfeIbqw0bUPsmo6tcTrpOoXkVxqNmtuyPCsO392YE3AGTIOMfeB3cbb9vV/mZPs af8AKT/8Kw0v/oKar/31D/8AG6P+FY6Z/wBBTVf++of/AI3WsnigS+MZNBj067eOEbJbxYZDGkvl iQKW2bANpHJfOSBt5zXQ0fWKv8zD2NPscR/wrHTP+gpqv/fUP/xuj/hWOmf9BTVf++of/jddBqN/ NYa7pnmOV064WWByEyPPZo/KycfKCBKPQlgOpFc/P4wuILvUNSVJJtMTTLu7tIsiNZhbeVufJQt8 5kIBzjagODuyD29X+Zh7Gn/KH/CsdM/6Cmq/99Q//G6P+FY6Z/0FNV/76h/+N1K3iXWbTxHeR3tj brZLFpwjiS5JdGuLl4dx/djnHJGSB5YwTvJWTV/Gsun3l1aW+mC5mgujbqnmuWkAhilJCRxu/wDy 2C8KQMZJGRR7er/Mw9jT7Fb/AIVjpn/QU1X/AL6h/wDjdH/CsdM/6Cmq/wDfUP8A8brV0LXX1rVp JI2ZbGbSbG9giZRlDM0+cnrnCIOuOOOprFtPF96EvtNuGd9Vur66h0phbEoyLcSRDJA2ny9m5s/w 7SeTR7er/Mw9jT/lJv8AhWOmf9BXVf8AvqH/AON0f8Kx0z/oK6r/AN9Q/wDxuorLxzNbWHhSO8tj dTanaWb3NwjYKPNhQxRVIALnqSg5wuSMVc1rxLqn9ga7fabZJHa2dveLHeNMPMWaFXBbyiuCu9CA dxzwduOaPb1f5mL2NP8AlIP+FY6Z/wBBXVf++of/AI3R/wAKy03/AKCuq/8AfUP/AMbq6nia8/4S K00i90/7JPJOnEVyJFaJ4bl1LZTrm3YFR3wdxGQaEfxBni0q11C/0RoUvbBLyzSCczvJueJNhVUy DunjxgMSCeARij29X+Zh7Gn2Hf8ACs9N/wCgrqv/AH1D/wDG6P8AhWWm/wDQV1X/AL6h/wDjddD4 f1iXWtPa4nsJ7KVJDG8csUiAkAHcvmIjFcEclRyCO1atHt6n8zH7Gn2OK/4Vpp3/AEFdV/76h/8A jdH/AArTTv8AoK6r/wB9Q/8AxurJ1u/Gnf2QZWGvfaVsfNMQ6EMwuMY24MSO/TbuUr2xUNz43Onw WgGm319NcXl7GUgjeV1ignaNmAjjP+wACAOeWyMk9vV/mYexp/yjP+Faad/0FdV/76h/+N0f8K00 7/oK6r/31D/8bqa88f2WnX8Vne27Qy/abmK4BYnyY4Y2kEn3fm3r5eB/t8E7Tnp7Cea60+2uLi3N tNLEryQE5MbEAlc4GcHjp2o9vV/mYexp9jkv+Faad/0FdV/76h/+N0f8K007/oK6r/31D/8AG66f WHvo9LlfTo/MuQVwoxuK7hv2543bd23PGcZ4rmB4pj0a0upbi91e+lWMMlpe6a0UzM0ixgIUiUOA zqDtVyNwPcAnt6v8zD2NP+UP+Faad/0FdV/76h/+N0v/AArXTv8AoLar/wB9Q/8AxurC+LtQm06x e30JxfXV61mLe6eW2TKwvLuVpIgzKQmASg5J9Kqal4zuri30dtItSEvG024uZpHAMMFzOFUBSpDl grqeRtyCKPb1f5mL2NP+Uf8A8K107/oLar/31D/8bo/4Vtp//QW1X84f/jdaHjDXLzQk0iazhkuP OvjDLDHGXLp9nmboFZsBlVjtBbCnAPQw6l4iuNC0PTbpQdam1C4CI0KMFwY3kyixI7FcIQOCeRls ZNHt6v8AMx+xp/ylX/hW2n/9BbVfzh/+N0f8K20//oLar+cP/wAbq9L4xjhDxPp9wl7LHFJYWsqs r3IkUYB+X5CrZDjnYBuPBrpqPb1f5mHsafY4v/hW2n/9BbVfzh/+N0v/AArbT/8AoLar+cP/AMbr s6KPb1P5mHsafY4z/hW9h/0FtV/OH/43R/wrew/6C2q/nD/8brs6KPb1f5mHsafY4z/hW9h/0FtV /OH/AON0f8K3sP8AoLar+cP/AMbrs6KPrFX+Zh7Gn2OM/wCFb2H/AEFtV/OH/wCN0f8ACt7D/oLa r+cP/wAbrs6KPrFX+Zh7Gn2ON/4VxYf9BfVfzh/+N0f8K5sR/wAxfVfzh/8AjVdlRR7er/Mw9hT/ AJTjf+Fc2P8A0F9V/OH/AONUf8K5sf8AoL6r+cP/AMarsqKPb1f5mHsafY43/hXNj/0F9V/OH/41 R/wrmx/6C+q/nD/8arsqKPb1f5mHsafY43/hXVj/ANBfVfzh/wDjVL/wrqy/6C+q/nD/APGq7Gij 29T+Zh7Gn2OO/wCFdWX/AEF9V/OH/wCNUf8ACurL/oL6r+cP/wAarsaKPb1P5mHsafY47/hXdl/0 F9V/OD/41R/wruy/6C+q/nB/8arsaKPrFX+Zh7Gn2OO/4V3Zf9BfVfzg/wDjVH/Cu7L/AKC+q/nB /wDGq7Gij6xV/mYexp9jjv8AhXdl/wBBfVfzg/8AjVH/AAruy/6C+q/nB/8AGq7Gij29X+Zh7Gn2 OO/4V1Zf9BfVfzh/+NUf8K6sv+gvqv5w/wDxquxoo9vU/mYexp9jjv8AhXVl/wBBfVfzh/8AjVJ/ wrmx/wCgvqv5w/8Axquyoo9vU/mYexp9jjf+Fc2P/QX1X84f/jVH/CubH/oL6r+cP/xquyoo9vV/ mYexp9jjf+Fc2P8A0F9V/OH/AONUf8K5sf8AoL6r+cP/AMarsqKPb1f5mHsafY43/hXFj/0F9V/O H/41Sf8ACuLD/oLar+cP/wAbrs6KPb1f5mHsKf8AKcZ/wrew/wCgtqv5w/8Axuj/AIVvYf8AQW1X 84f/AI3XZ0UfWKv8zD2NPscZ/wAK3sP+gtqv5w//ABuj/hW9h/0FtV/OH/43XZ0UfWKv8zD2NPsc Z/wrew/6C2q/nD/8bo/4VvYf9BbVfzh/+N12dFHt6v8AMw9jT7HF/wDCttP/AOgtqv5w/wDxuj/h W2n/APQW1X84f/jddpRR7er/ADMPY0+xxf8AwrbT/wDoLar+cP8A8bo/4Vtp/wD0FtV/OH/43XaU Ue3q/wAzD2NPscX/AMK10/8A6C2q/wDfUP8A8bo/4Vrp3/QW1X/vqH/43XaUUe3q/wAzD2FP+U4v /hWunf8AQW1X/vqH/wCN0n/CtNO/6Cuq/wDfUP8A8brtaKPb1f5mHsKf8pxX/CtNO/6Cuq/99Q// ABuj/hWmnf8AQV1X/vqH/wCN12tFH1ir/Mw9jT7HFf8ACtNO/wCgrqv/AH1D/wDG6P8AhWmnf9BX Vf8AvqH/AON12tFH1ir/ADMPY0+xxX/CtNO/6Cuq/wDfUP8A8bo/4Vnp3/QV1X/vqH/43Xa0UfWK v8zD2NPscT/wrPTf+grqv/fUP/xuj/hWem/9BXVf++of/jddtRR7er/Mw9jT7HE/8Ky0z/oK6r/3 1D/8bo/4Vjpn/QV1X/vqH/43XbUUe3q/zMPYU/5Tif8AhWOmf9BXVf8AvqH/AON0f8Kx0z/oK6r/ AN9Q/wDxuu2oo9vV/mYewp/ynEf8Kx0z/oKar/31D/8AG6P+FY6Z/wBBTVf++of/AI3Xb0UfWKv8 zD2NPscR/wAKx0z/AKCmq/8AfUP/AMbo/wCFY6Z/0FNV/wC+of8A43Xb0UfWKv8AMw9jT7HEf8Kx 0z/oKar/AN9Q/wDxuj/hWOmf9BTVf++of/jddvRR9Yq/zMPY0+xXuLO3up7WWZN0lpKZoTuI2uUZ CevPyuw59fpUGoaPp+q7/tsAl32s1m37wrmKXb5i8Eddi89RjgioBdX107vbSQxRB2QCSIsTg4Jy GHel/wCJv/z9Wn/gO3/xdc3Oa2ZM2j2DauuqmH/TFXaHEjBTxjJXO0tjjcRkDjOKv5561lf8Tj/n 5tf/AAHb/wCLpRcahbSxtcvDJCzKjBIirAsQAeWPHNNTCxb1DT7XVLCWyvI/Mt5Rhl3FTwcggggg ggEEHIIqtc+H9Ku7dbea0UxLZy2CorMoEEgUOgwR1CLz1GOCK0z0pD9QKoRnahoOm6q8jXluZGkh ELkSMm5QwdfukcqwyrdVJOCMnNIeC9BXO20kDGRpWcXUoZ2ZUVtzbssGEabgchiuSCea3QTv247U 6mIoafoun6Vt+xQeVstorRfnZsRRbvLXknpvbnqc89BTY9D02KS2kS2Ae2uJrmFtzEpJKXMh69/M fjpzwOBjRopDMGTwZoMraaWsm/4lqwpa7biRQoiOY9wDfPtOcbs4yfU1LdeFdGvZrmS4tnb7UjpL GLiRY2DqUc7A20MVJBYANz1rZooAoS6Lp82rR6pJBuvYtmyTewxtWVV4zjgTyjp/F7DEH/CNaR9l tbU2YMNpaGygUu3yQnZ8uc5z+6jIbqNvB61rUUAU9O0y10q3aC1Eu1nLs0szyuzHAyWclicAdT2q 5iiigCjLpFhNq8GqyW4a9gjMccuTwpz2zg9TgkZG446nNa48MaRdW8cEtqTHHPLcKFmdTvkZnkyQ clWZiSp+XpxwMa9FAGPfeFtE1K9kvLywjluJfK3uWYZ8ptydD2J/EcHI4rYxTSSB0/Gl3D/JoC5F dWsN5bPb3EYkicfMp/MH2IPOe1ZkXhbSIo51ME0xnTy3e5uZZ325zhWdiyjIB4I5APYVsBge/PpS 0AZlt4f060W3EcUrNb3BuY3lnkkfzSjRlizMSx2Mw5J/QVWl8IaHMulq9kduliIWgWaRdgiwYwcN 84Ujjdnv6mtyigCvcWVvdTWs00e6S1lM0JyRtcoyE8dfldhz6/SqN14b0u7tlt5IJVjW4a5TybiS IpIwYMVKsCuQzZAwDuPHJrWooA52bQjceIdJuXt7aG00YObNkctIxeMxkEEAKoUnu2SF6Y56LFMI 9MZz+VPoATFFL27/AJUlABRRRQMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAObSTyrRwmFdr1kyoBIDXG0n8j6GuQTxxdPBH MsTbJFDLuu0BwfX/AEc4ror2Qx6axBwFvyxyTji5/wDr156PhzrBVIY9U0wKi7V33b5IGB6H+dKg k1qKrdPQ17j4jS2/+sifH+zeRk/l9nrvC5ns4zIQzLeqmcddlwq5/wDHR+VeTSfCrV2kBfVdMbr9 24kP/stek6dhtMiYFiDqJYEuTkG7yDyenWnXjFJWJpuTvc6u7uorOzmuZ22xRIXc4zgAZNeY3WoX XiLWYxcuqRlWCQbj5cfK5Bxwx6ZJ9eMc13vim1a88N3sSeZkKsmI2KswRgxXI55C4/GvM9DY2uv2 UILukky9ycqXHH4A134SEeWUn0OXEyaaSZpQ3N34d1WJ7WQtGodWtwx8uXlTwOgbggH3Nek2V1Fe 2kV1A26GZBInGOCM8+9eS664k8RXMQLpsll4y2Au4D6DqP1r0nwraNZeHLOJ/MyVZ8SMWZQzFgMn ngECli4RUIy6hh5S5muhqn/j5j/3G/mtSVGf+PmP/cb+a1JXD1OsguHkV4VjKgs+DkdsE0q3AMgj cGOQn7p7/Q96bOMzQHn757/7BpJQkhESruKn8F/w/CmMs80hzjjqe9MhQxxqhcse5PNSEZpAZepa vJZX0FpBYz3csyNJtidF2qpUH75A6sPeqb+JXdNP+y6bc3El5AbhUV41KoMA53OM8uvSpL2PPivT HxwLScnJx/y0hPrWTpERE/hZvTSXyxbnrAcc0wOo069TUtOt72NWWOdBIobrg8j9KtVk+GECeFtK AXB+yRE/XYK1qAMSS2gvtQuvtUMMwin2IJY1bavlI2BkerE/jXJaT408F69r8ei6fahrqR3VS2nK qHapYjJX0U12KcXWokAki6GAP+uMVcHoegaVYahpAtNPuYNSguZJbmSVXAyYpEbDMSOSw4H4U1YR 32mxrb6hcW8aqkSwxOEVQAGLSgn8lH5Vq1m2ihdZuh6W0P8A6HNWieRjt3pMA3Anjt15oBB47jqK 5LxL4TvdQv4dR0TWrnSr+SRY7qRJWdJYdpUgRk7Q/IIYDIxW5omj22iWH2S1ad03bmeed5ndj1Ys xJycdOgpAXrj/j2k/wB0n9KkAwAB6VHcf8e0v+438jUlAzm/GM2oW+mWx0yNpbl7pY1iV3UPlW6l CCAMZ69qi0SM32lQzXn2mK56Tp9pnTYef4S5Pb17fUC54l1C20mGwvrssII7sB2HONyOv8zUmj33 9q2Ed8lvJBFMxaMSkBmXsxA6dP8A9fWtIp8mxH2jmrS71V9elzBOmmLMi29y0s2WxNGpVg0hByGY dO31x3tcm3iK0vbttJ8i4hvoLiJpY5EwFCzRAHPQ53jGOoGfTPWUT32HDYKKKKzLCiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gDmoY4pYp0lRXVppQVYZBHmE8j61zmreAtO1a9Wc317aqoOIbQQxp2yT+7yencnvjGa89m/aDtLi VpH8HOGbrs1d0z+AjFRD4+WQ/wCZQn/8Hcv/AMRWPs5p6Fc66no+k+BNN0q8837ZdXyMjDybxIZE 7cj5Ac/jXRyRIn2VIVCKs8WEUAAfvFPT8T+deLf8L9sv+hRn/wDB3L/8RWx4X+NljqXiTTbJvDbW ourhYfPl1R5RFuIGdrJj07ih05vcOeKR7s2dpwce9cZeeBn+3fatM1aa0f5iFKAqhP8Adxgj6Z+n epL/AMYalDr2raLp+hRXV/ZLDNDFLfrB9pgdTukUsuAEbCkc9eo6VSt/inpjQeFbm9gWyttfS4zN NOAts8RAwTjDAsSA3HY9+OqM5R2MJxhPcktfh/MdRW91LW7i6cDlAiqrcj72QSemOtduoIGNxOPX rXjfiL4+x6H4hv8AS4vDou0tZjGs4v8AaJAP4gPLPH4mtJfjZZ3Xgz+2tO0r7Vfwyql3phutskKE 4EgO0l13FFzgcsOlKdSU/iYoRhDSJ6gVLSq2SNqsPzx/hUleCn9pMg4PhL/yo/8A2qmn9pbH/Mpf +VL/AO1VBfMme8yRLJtLE5U5HOOcYpwVVUKAAB0AFeBf8NMf9Sj/AOVL/wC1Uf8ADTH/AFKP/lS/ +1U7DPfqPSvAf+GmP+pR/wDKl/8AaqP+GmP+pR/8qX/2qiwXPdLzTLDUfL+22Ntc+Ucx+fEr7D7Z HHQUyfR9MuooIrjTrSaO3GIUkgVhGOOFBHHQdPQV4d/w0x/1KP8A5Uv/ALVR/wANMf8AUo/+VL/7 VRYD3uKKOCJIoo1jjRQqogwFA6ADsKfXgP8Aw0x/1KP/AJUv/tVH/DTH/Uo/+VL/AO1UWC57hNYl 5mliuprcscuIgh3HGM/Mp5wAO3AqIabdiTJ1e7I9PKh/+N14p/w0x/1KP/lS/wDtVH/DTH/Upf8A lS/+1UNBc91trX7OxYyvK7YDSSBdxAyQOAOOT27mrNeBf8NL/wDUpf8AlS/+1Uf8NL/9Sl/5Uv8A 7VRYLo99orwL/hpf/qUv/Kl/9qo/4aX4/wCRS/8AKl/9qoC6PepV3xsvqP6Gn14F/wANL/8AUpf+ VL/7VR/w0v8A9Sl/5Uv/ALVRYLo9s1XSoNXijgufuI+/GxHGcEDKuGB6k9OoFQwaNLawLBa6nPBC vSOOCBQPoBHivGf+Gl/+pS/8qX/2ql/4aV/6lL/yo/8A2qhaC909eg8NWsV2brzW85pBJIy28KFy HD/MyoGOWAJyetbteCf8NK/9Sl/5Uf8A7VR/w0r/ANSl/wCVH/7VQ3cE4rY97orwT/hpX/qUv/Kj /wDaqP8AhpX/AKlL/wAqP/2qkPmR73RXgn/DSv8A1KX/AJUf/tVH/DSv/Upf+VH/AO1UBzI97orw T/hpX/qUv/Kj/wDaqP8AhpX/AKlL/wAqP/2qgOZHvdFeCf8ADSv/AFKX/lR/+1Uf8NK/9Sl/5Uf/ ALVQHMj3uivAv+Gl/wDqUv8Aypf/AGqpf+Gkf+pU/wDKj/8AaqHoDkke8UV4R/w0h/1Kn/lR/wDt VJ/w0j/1Kf8A5Uf/ALVSuhc8T3iivBv+Gkv+pT/8qP8A9qo/4aS/6lP/AMqP/wBqp3Dnie80V4N/ w0n/ANSn/wCVH/7VSf8ADSf/AFKf/lR/+1UD50e9UV4L/wANJ/8AUp/+VH/7VSf8NKf9Sn/5Uf8A 7VQHMj3uivBP+Glf+pS/8qP/ANqpD+0tj/mUv/Kj/wDaqA5ke+UV4H/w0t/1KX/lR/8AtVIf2l8f 8yl/5Uv/ALVTsO6PfaK8B/4aY/6lH/ypf/aqP+GmP+pR/wDKl/8AaqLBc9+orwH/AIaY/wCpR/8A Kl/9qo/4aY/6lH/ypf8A2qiwXPfqK8B/4aY/6lH/AMqX/wBqo/4aY/6lH/ypf/aqLBc9+orwH/hp j/qUf/Kl/wDaqP8Ahpj/AKlH/wAqX/2qiwXPfqK8CH7S+f8AmUf/ACpf/aqd/wANK/8AUpf+VH/7 VQF0e90V4J/w0r/1KX/lS/8AtVJ/w0t/1KX/AJUv/tVAuZHvlFeBH9pf/qUv/Kl/9qpP+GmP+pR/ 8qX/ANqosO6PfqK8B/4aY/6lH/ypf/aqP+GmP+pR/wDKl/8AaqLBc9+orwH/AIaY/wCpR/8AKl/9 qo/4aY/6lH/ypf8A2qiwXPfqK8B/4aY/6lH/AMqX/wBqo/4aY/6lH/ypf/aqLBc9+orwH/hpj/qU f/Kl/wDaqP8Ahpj/AKlH/wAqX/2qiwXPfqK8B/4aY/6lH/ypf/aqP+GmP+pR/wDKl/8AaqLBc9+o rwL/AIaY/wCpR/8AKl/9qoH7S/8A1KX/AJUv/tVFguj32ivAv+Gl/wDqUv8Aypf/AGqj/hpb/qUv /Kl/9qosF0e+0V4F/wANMf8AUo/+VL/7VSf8NMf9Sj/5Uv8A7VRYLnv1FeA/8NMf9Sj/AOVL/wC1 Uf8ADTH/AFKP/lS/+1UWC579RXgP/DTH/Uo/+VL/AO1Uf8NMf9Sj/wCVL/7VRYLnv1FeBf8ADTH/ AFKP/lS/+1Uf8NL/APUo/wDlS/8AtVFguj32ivAv+Gl/+pR/8qX/ANqo/wCGl/8AqUf/ACpf/aqL BdHvtFeBf8NL/wDUo/8AlS/+1Uf8NMf9Sl/5Uv8A7VRYLo99orwL/hpj/qUf/Kl/9qpP+GmP+pR/ 8qX/ANqosFzwKiiiqJCrERKqrKSCDkEdqr1s+Gri1tNf024vbaG5tY7hGlhnbCOoPRjgjH1GPXip lsTLY75fi3bappVna+L/AArbeILi0BWK7e5MD4PXdhTknAz0zjpmud8ceOZfGVxYomnQabpunxmO 0soDkRg4zzgZztHYDgVreJ003UrpksbrTWnksSFDi1t2VhNGwDyRP5LNs3AEbTgYI6VZvNU8OXsn iRLWDTraLEvkzSW0LiXEKKqouQ6ZdGZWjzy/zrjoiTzSnRySRMWjdkJBBKnHHpXfePp7K8t9Mg0i XT/si28TOIhaJiQQpn5k/e/e3538Z6dq5iOyW88MwGB7NbiG6naYS3MUTlCkW3AdgWGQ+AM859aV hWMU8mo2Ga9O1rT/AATcvq1yL8faBNcPA0M0aqyI0AQCNVwd6vKRjH3OnXFOTw74OhvSlxqqLaPq 08Ylhu45WSyHl+S+0HqxJB7gEkr8ppopKx5zRVnUEjj1G5SKNY4xKwRFlEoUZ4G8cN9RwarVZYUU UUAFFFFABRRRQAUUUUAOFFIM0tIkKOtFFABRRRQAUoOBSUYPpQA7dQDTaKLAPopu6jd7UrAOopu6 l3UWAWik3Um6iwDqRvu0An0prdKEAg6irQ6VVX7w+tW6UyZjTnrRnig8mkqSQpM0tNPWmCCiikJp lATSUUhPpQMC3tTSaKQnNVYYZpKKKZQUUUUAFFFFABRS4oxQAlFLinAc5NK4riqMUE4paYTzSEBN JmgmkpjSCiiimMKKKKACiiigAooooAKKKKACiiigAoHWiigApc8UlFABRRRQAUUUUAFFFFABRRRQ AUUUUALSd6KKACiiigAooooAK6TwNbWV54z0W21FI2spLtFmWU4UrnnJ9K5upU+4KTJkejahp+gX +vWdvdRvY2ZTAe005rRmdpY058123BQxbI/rkWF8I+FZ/wCzLRr2eF1julvLqEmTe8dwI1baAcAI d+AOVxkjk15nRUknfQ+E/Dohti99qV7I2nfbplsURv8Al4WEKoPOcEuQRkAD14lbwnoNhp2oSpq8 F64tb3Y+AV/dXEcaOmDnLKWPfpxnOa8/SWSNZFSRlWRdrhTgMMg4PqMgH6gUygND0iTwL4ZXW4bc azeCxkgkfzzF83yyIofZtDhdrlsFQPl4YjJGB4Og0WbXHstQS3naSQLBLcLJ9nKgNu3lCGQEYIfD bcZI7jlqaetA0d3pfgvw7fWekSz65Kr3hla4aJcpCqpMwXLAAvmJOCQSHHA4JqWnhTQNUm0y6tNa e20y5na3n+17fOhkG9gMDAIKKnIyNz47VxjU2rRSOx8ReF9E0rSr68stUmuJI7m3higddjJ5kbu4 cEA5UpjIA+8OB0rjqKKBhRRRQAUUUUAFFFFABS5pKKAHUUgo7UhWFopAaXPNABRmiigQUUUUAFLj 3pKKAFx70lFFABRRmkzQAuaQmjNGeKBip99frVqq0Yy4qzUTInuJjFNp56UykiBCcCkpW+7+IpKZ SCm0p6UlMpCHpSE5pe/tRtpjGHpSU/FGKY7jKKfg0baLhcZilxTwtLj2ouK4wClANPxRilcLjNtG KfigCi4rjQuTmlNOpp60guFMPNOJxTTTQ0NoooqigooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKWkFOUUCG0UHqaKBhRRRQAVKn3BUVSp9wUpEy2HV13 gHTrfUNQuRcabLeInkcgAomZ485BU9sk9PlVx3yORq1p/wBva7WPTftJuX+6ttu3ttIbgLycFQ3t tB7VKJRd8U20dp4q1SCK2a2jS5fZEwxgZ4IGBhT1Ax0I5PU+keDLu2g07wfbyWKzXFwt8sNwXwYA GLNgY5LYAzwQM+pryW5+0fa5vtfm/ad7eb5ud+/PO7POc5zmrVndau3l/Yp74/YkeRPJd/8AR0P3 2GPug55PHXmhMaZ0n/CI2H2DZ51z9s/sT+1/N3L5fX/V7NuenG7d15x2qPX9Nj0Lw9d6MJp5bi2v LV7li37rzHimP7tcZA27QWPJx0GK5X7TP5fl+fJ5ezy9u842bt+3Hpu+bHrzUckskzBpXZ2ChQWO TgAAD6AAAewpgjpNchi/4RHwnI9xci2k+0AxsEfysSKHKYCk5OThiewz3q/8RdQWLxJNo7L5mn28 kMiRBFRoB5Sho4m5wjDaTxjcBxxluUvotThsrNb2O8S0Ks1oJgwTBwSUzxg5BOPUVXvZbye6aa/k nkuHVWLzkl2BUFTk8kbcY9sVSKR2fiLSbe48fa2NT1CVobSCOaSaUhGkyIkAJjjIHLjoh6Y77gzR bDSrPxZp1/pOpTz2iXNrCQhZXWaUsChYqu5AEYk7RkELgZLDkv8AiYazqH/L1fXsv+9LI+B+JOAP yFQ3P2gXDJdeaJo8RMsudy7RtCnPIwABjtjFAzQ8Uf8AI26z/wBf0/8A6Mauu8P6ZJ4j+HcOkmdl lfV3W2Z3+SMrbtJgjB+U/N0xgtnnGD5/LLJPM800jSSuxZ3c5LE8kknqaljv7yG2NtFdzpAWLGJZ CFyVKk46ZKkqfY4oA6C+8N2dteaZCkk5W60Q6i5ZhkSCKR8Dj7uUHHXGea5etUarbwWiLa290LsQ Nb+bPciRERwQ4RAg253N1JxubvhhlUAel6vbL4pNhd2qSmXxJdxS/ZmKoIVto3jkHmc5zuJB29B0 zxWZ/Z9h4dutD1rTpby4tb2K6WQW0hMkQVWR5I3KIchWLcqMFDzjkceL+8VbZRdzhbVi1uBIcQkn JKf3TkZ470xLq4jQJHPKiLvwquQBvXa35gAH1HFAHfRXmpR6/wCDbwXa3lvLL5dvqEkZFxKrSBZY 5dzNyu5lGOMHIPpDqut3954y1GW7v57KxsZXtpbqzASYxrJIUiDZGWbO3A4+UMwOwkcOt1cI8DrP Kr2+PJYOQY8MW+X05JPHc5okuribzfMnlfzpPNl3OTvfn5m9T8zcn1PrQBb1zVP7a1u71L7NFbfa JN/lRdB/iT1J7kk96z6sS395PdPdTXc8lw6lXleQl2BXaQSeSNvH04qvQB2euy3l18P/AAnCHnmB W7ZkBLcRtgEj0VM/QZ7VX1jw3Y6Rpo+0SSxX8E9vFeRpL53liSN3J2+Wgz8vADsOoJ71zn2+8EMU P2ufyoVdY08w4QPw4A7BsnPr3qKSWSZg0sjOwUKCxycAAAfQAAD2FAHUaxpOi6dCl5b299dae84S K5hvo2SVdhba37vMUgyh2sD/ABemaf8AEhbOHxldQWtu0LRLGrYceXjyk2hFCjaAOOp/DpXLSXVx N5vmTyv50nmy7nJ3vz8zep+ZuT6n1oluridESaeWRE+6ruSF+ULxnpwqj6KB2oA2vCuj2et389te SzxKIl8t4QCRI8scSkg9VBkyQCDgda3L/wAIaRY2d5qyzX0+nx2NrdwwFkjlPnuVwz7WHG0nhe+M 8ZPDpLJGsipIyrIu1wpwGGQcH1GQD9QKlkv7yZQst3O6iIQANISPLBBCf7oIBA6ZFAHodl4Ut/DP isXbXlzJFDqsFjaLCwRy8iq58w4+4EYqQB83+yK4rSwraTrnzSrItojDaV2svnxAqwIJ6lSCCMbe 4NURf3gmaYXc4laUTs4kOTIMkOT/AHhk89eT61EkskayKkjKsi7XCnAYZBwfUZAP1AoA7C3eG1+E 800MjLPPqnky/uFIkHlnCEk8qASwOMhugH3qNO07+0/Aun2yXU8K3GvJbOh2NGHZMeYBtDZAIGN2 OCe/HI/arj7J9k8+X7N5nm+TvOzfjG7b0zjjNH2q4+yfZPPl+zeZ5vk7zs34xu29M44zQB0dxpWh tr8mi20eopdpqC2kbSzo0cw8wo2SEBjPQg4f6VoJ4f0iz1fwpeQO13Y6nclGiZ9wykgX7zRruU5G VKDoRnkEceL+8EzTC7nErSidnEhyZBkhyf7wyeevJ9aiMshhWEyMYlYsqE8AnAJA9TgfkPSgDqrw QzfFQJaie3Y6vteQyK53+fyy5UADpgEN7k1JcaLazXni7UtQlurhNNu9uyN0jeZnmK7i20gdCcBe c9q5Z7+8kuY7l7udp423JK0hLKdxbIPUHcS31JND3Fw7zu08rNPnzmLkmTLBju9eQDz3GaBM72Hw LpketarZST3brYXlrGGV1XfHcEAD7pwylgSejAYwucjkdTs/7O1S8st/mfZ53h34xu2sRnHbpUdr qN/EZ5EvblHmkEkrLKwMjg7gzc8kHnJ7802WSSaV5ZXaSR2LO7HJYnqSe5rKT1MptNnR3fh+wtob G23XLXl1pZ1Hz96iNcI77Nm3J4TGd3U5x2pdY0DTLKweWAXfmPpsGoxF5lIQSSIhRgEG4jcx3Ajs McZPMu7SCMOxYRrtQMc7RknA9Bkk/UmpZb27lQLJdTuoiEIDSEjywQQn+6CAQOmRRdBdFjw5/wAj To//AF/Qf+jFrsx4ba38EwadftJbxtqIu3aSNkIUWRlZehIwQyZwcEHg4xXn0cjwypLE7JIjBkdT gqRyCD2NSXN5d3iqtzdTTqjMyiWQttLHLEZ6Enk+pppjTNufTtGikivtK1Od1tIjcXSRM2+MiRVT y5GjTkl152/Lgn5uAXfEcf8AFe6n/wBsv/RSVzjvJIsaO7Msa7UBOQoyTgegySfxNEjvKwaR2dgo UFjk4AAA+gAAHsKdx8x6L4IntIfCNnHeQNIs3iGNI2TG6KTajKwyOmV2nGDtY/SqOt+HbBtXhkuG uXuda1W6hjeORVS3xPsBKlSX5Oeq+nvXGRXt5DEkUV1PHGkonREkICyDo4HZvfrTZp7i4z500smX aQ73Jy7Y3Nz3OBk98CjmHzG9feHLS2u9NiSScrc6KdQclhkSCKR8Dj7uUHvjPNcxg1ZWe4W3MCzy CFs5jDkKclSeOnVF/wC+R6Co9lK4uYW1uJrO7hurd9k0LrJG2AcMDkHB46ius8T3t3ZaDD4c1S6n vNTW5F5cPLIXEGY8LEGOdxwdxI4BOBnk1yQQDoP0qe4nnvJ2uLmaSeZ8bpJXLMcDAyTz0FHMLmNr wdaxSz6vO6ZltNKnuLdgSDHKoAVx7jJwexweoFb+pQ6JHqNnq2pSWyXk+lW92IZ4n8m5uH3bnkEa nAGASoA3E/XPBbQeop8rvPI8srtJJIxZ3Y5LE8kknqaOYOc19eiRfGWtDyftg865bEZYbSQx3dM/ IeT2O0845rS8E3AGn+JLQW0G5tJuJDOVJk4AG0HOAvJPTJOMngVysrPPI8krtJI7FnZzksSckk9z mlhuJ7bzPImkiMsZik2MV3oeqnHUH0oUhKWp39zcfZ7LTLP7Xc22/wAOyyfYoBm3kzDMd7HcPmP3 j8h5HU9a4ho0/wCEeLDTJPM+1Y/tDc2zGz/VYxtz/FnrVcTTLsxNINiNGvzH5UbO5R6A7myO+4+t QsB1xRe4+a521/qN7qdtquvaXr2pGGyuop2tLpdqIHkJQKN7K21gvBAHH4VV8U393ZaDD4c1S6nv NTW5F5cPLIXEGY8LECc7jg7iRwCcDPJrlJbqeXzfMmkfzn82Tc5O9+fmb1PzNz7n1pLq5nvZ2uLq eWedsbpJXLMcDAyTz0Aqikbvg63inuNYndMy2elXFzbvkgxyqAFce4ySPQ4I5Arc8JazqV5c6tcX 088J/sGU/aYlIklEbYWU8je65ZQ2QflxnOTXn+2rC3t5G0jpdzq0kXkOVkILR4A2HnlcADHTAFO5 SZ1ujeLtdXXdRmkZYbm8s2mlcwgFjFauY2APAB+VumDxjAODx9/eSajqNzezBVluJXmcIMAFiScZ 7c0st9eT3T3Ut3PJcOpV5XkJdgV2kE9SNvH04qtTGdnDqF/pXhtZNUvp0S4s3t9P0uEiNXjdWUzS KBjb8xIJG525zgZrpdVtrU3/AIj0HerafYaW8ttYeXgW7RxxukobqWZpZc85OPmyCK8ve/vJGjZ7 udmji8hC0hJWPBGwei4JGOmCaY11cPbrbtPKYVxiMudowWI46cF3/wC+j6mgDsNdmmufCHglre1i 84faI44ooQwdlkRR8hyGLEZIxySeOaz/ABDrf2jSbTSHuZdRuIJDPPe3EnmMsjKAYomyf3YxyckM wyOMZwhf3irbKLucLasWtwJDiEk5JT+6cjPHemfarj7J9k8+X7N5nm+TvOzfjG7b0zjjNAEVFFFA BRRRQAUUYoxQAUvajFJ2oAKKKKACiiigAooooAKKKKACiiigAooooAKKKcBQAAZp4GBQKUCpbJbI j1NJSt94/WkqigooooAKlT7oqKpF+6KTFIfXSeEbaJ76G8Kb5ba+tWbk4ih3FpJTjoF2KCx+UBzn kgjmc1e07S7nVWuRbBcW1tJcylmwAiDJ+p6Ae59MmpIOxvdGhuddvi2hX2o3h1i48yKCcxBYiUaP zPlOFbc2GyvGeeOM2KW4s/DutXWn2LWqx6nF5dxBNIxgG2UYWRW2kAMFz3EnOcrjnbGy+2m4/wBK trfyIGm/fybfM24+RfVjngVVNMZ10/hyyg8P+fBDc3dzLpS3y3Cv+6RvORZECgclFJ3EscckgcYd 4t0Cy0+TU5tPtGW0Ets9nIrMyNC0R8xlYk7l3mME84LKOM88dRQM63xHa3Efw+8Ju8Eqov2nLMhA G9wy8+4BI9RzS/EiynbxPdauFU2F00a28wkXE2IUJKDOWXn7wGM8ZzXHtVrV9KutE1KTT70KtxGq F1VshSyhsZ9RnBxxn1qkNGh4WCveXcQtWu55LbEVuhKvKA6NIisOVLRLKOOSCRznBt+OpY31WxjM iyX0Gnww37A7ibhQQ4Zh95hwCcnpjtXP2dqt1MUe5gtkVdzSzk4A6dFBYnJHABPfoCRqy+FLyC+h hmurOK2miimS9kkKwlJPuHJG4EkEYK5G1iflBIBmFRVi+sbrTb6ayvYWhuIW2vG3UH+o7gjgjmq9 ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAqjJqXFJEmRkiptvNRJmcp aj40IjGMetP2/SnhcLRisbmDlcjK0mKlxSFaLhcixRipCmehI+lN8s/32/T/AAp3HcZijFShPlxk /Wk8s/32/Si4cwzFG2pQuBS7aOYXMQ7aXZmpglO2UuYXOQ7KUJUuz3pdlLmFzEO0UhHBx+VTbaaR RcaZCRSY9akxk00javJz7mquVcYajcHB55qUikI4qkykyHFGKkI9KYRxVJlpjKQjIp9IRTKTI8UE U+kxTuMZikp+KAM07juMpcU7bRj35ouFxuKMU/bSYHrRcVxv5UtFLigBKKdgUmPpRcBKbTqTFA0J RS4oxTHcSilxRigVxKKUUcUDEopeKSgAooooAKKKUCgAAp4GKAKcKlslsAKWiikSQt94/WkpW+8f rSVZoFFFFABUi/dFR1Iv3RSYmLXSeDtbTR7jUo5byW0S8sZIY5VLbUlx8jttyeOQCASM/WubrV0P QLvX5pIrSW2Ro9mfPmCZ3OEGB1PLDp9OpAKEa+iX+m2Wsa+s2rNJDeafPbxXk8LgyyOV+ZgNzAE5 OTzjrzxWv4e8WaZYWHhuxubmIW0aXkepI9tv+RySi52kkE4yF9BnpWHZeBNUvtSubGK408SW9z9m cm5BBbazZAGSRhT2znPHytti0Twq2rzxo14sMayzJdTIokS2VEDB2YNjax3AHIHynBNAG5P4n05v Csdlbz20cY0oW0lpJBM7tPu5YKGEQ5+fzOWHoelPvvFGm/23/aEd802mBrVrXTURwbUxtEzEKwEa naki/Kx+/wChJriP7OuTYfbVETwj72yZGdBnGWQHcozgZIA5HqM3dV0CbTYUuRMs9hLEjw3aI3lz McZRTjhgd/DbThDwDgUAbuueI7SLS76LStTc3cutPqEUtuJIysbo64yQpDDjPbDDBPOKfjnV7LXr /wDtC11aedZGXyrJ42Atl8tA2STgMWB4UEHGd1U9d0Cy0vR9P1G01OW8jvpJVi3WvlDbG20t98nk 4wMdDzjpXPVRRp6F9kTURNdzWaCFfMjS9ikkhlfIG1hHzjBJ6EHbg8Gt2TULCW9uILzXIr46h5c9 xfy2khSKQJLGyhMBjhZNyMAACqDAGSvH1bstNu9Q3/ZYd+zAOWC5Y9FXJG5zg4UZY4OAcUAXfFOs x+IPEt7qcMTRRTMuxHOThVCgnHc4zjtnqetY9bcfhLWpLiaBbaIPFOtsxa5iVTMRkRqxbDP6qCSO 9Mg8La3dQiSGwZxukTaHXeHj5ZCuch8ZOzG4gEgEA0AY9Fab+H9Tjso7t4FVJIvPRGmQStHz84jz vK4BOcYwCenNOvvDWr6bafa7q0225wVkWRHDKQp3DaTlPnUbh8uWAznigDKorbPhm/e30draGWeb VN/konllTtI6Mrk8A/NuC7cH0OKl7ol/YWiXc0cTWzyGITQTxzIHAztLIxAODnBoAz6Ku6ZpF/rM 00OnWzXEsMTTOiEZ2DAJAPU8jgZJrTj8Hav/AGldabcQfZ76GBZo4pHQCXdIiABywX+P1PI29aAO forVsvDWr6hvFvaZaOcW8ivIiNHIegYMQVyRgE4Bb5RzxWbLFJBM8M0bRyoxV0cYKkcEEHoaAGUU UUAFFFFABRRRQAUUUUAFFFFABRRToxmRR7igGW402oBUioSw+tOx0FSxpk5rmcjklLqLtpNtS7aN tZ3MeYi20bBU2yjZS5g5iHZRsFTbKXZRzBzEOyjZU+z2pQho5hc5CI6XZUzIwHygE+hOKRVlLDci Aeocn+lLmFzEeyl2VPsprKwU7QCewJxU8xPMRFBSMvHFTFaaVppjUiAimFTVgpTSvFUmWpEBXFNI qYio2FWmWmRMKYRU2KaRVJlpkRFNIqQrikIqrlpkRFNwc+1TYppWqTKTI6TFPK0hB7U7jTGYNGKd g9sfnS4NMdxlFOooC42inYpMUDuJRS4oxQFxKQ896WimA3bSdKdijHvRcY2il2mjaaYCUUUUAFJi looATFGKWigdxMUUtKBmgLiYpwFAFOApNibAClooHNIkKUcUYoxSEQN94/WkpW+8frSVoaoKKKKA CpF+6KjpwOBSYmPrf8Ka7aaFeyzXdp56v5WCM7l2zI5x8wHRSec8qvbOee3e1aGmaTcapu8lokxI kKeYSPMlfOyMYB5ba3JwoxyRxSEddpHjbS7DxDf38umsI7jUDco0YJcLslXkGTG7Lg+nzP6LjmLG 9sY7bWFnEkL3cHlwRwR70U+YsmCWfIHyAfxHnPbm3aWFrpWp6zFqNvBqQ02IFkSSREZ/OiRgGG05 AZhnGM84IqoujRXrXF1Y3Srp8TM0klwr5tk37Y/NKoQWbIwE3d+gBwwNa68UWd1oKaaGvLeMaYtq 1vGoMXnpKriXG4cvg5OMjP8AFVLUNR0T7PejS4LmFLyONRZyqDHbupUl1kLkueHUZVeJG6dCkvhC /jgSRJraV203+0zEjMGWDI5OVAzyTgE/dPtmHUfDculXBtrzULGO6j8szwbn3QhgDknbhsbhkIWP UgEAkAyXV9W0+88K6Hptu119p0/zfMMkSqjeY244IYngjHTnrx0rDtrq4srhbi1nlgmTO2SJyrLk YOCOehNdMngHUpNUOmC8sReLOIJIyz/ISjyKSdmCGWMkYJPIyAc4xLvR7iy0fTtTkeIw6h5vlKpO 5fLbad3GOp4wTTGRXuqahqWz7dfXV15ednnzM+3PXGTx0H5Vu+Cri2/tGK2uplt4kvLa9855I1A8 osNp3svB8wnIJI28Ke2f4W0aPxB4lstMmlaKKZm3ugycKpYgZ7nGM9s9D0qW2TT9T/tuRLGCyiWK OW3JklcWw86NDk5JYbXJOQTkcAdKAN7/AIS+xX+1LMXup2kM2syXyXWn8PLE2QU5ZSuRtIJz7jij w3420/SYoRdRX0jrqst8zZWRijQNGMsSu58sCTgZ5PtTPDngeYeMhYa3bK1nDK0MhDsFlcxM6qjL znaN/bAGDgkAmheFLC/07RYZtxutca52XGT/AKKIQ2AFBwxZgMk9uAAfmoAqaj4rjvtGsrdL7VbZ rfT1s3s4WxDKVBXeW3dCCCV2HONue4q+Jtbs9SXTl02W8C2+nx2MwmjEYkCHIPyu2QTzg9Co69uc rs/Efh+w0tdQ023gXz9Miile9MxMlwSYw4MecIv79MHH/LMjLZOACXTPF+l6XD4XKx3k0uktP56m NVDCbO4qdx5XPAIG71WuXvV0eO0RbGW+nuTIS8k8aRIExwAoZiTnPO4fQ9a0LvTbSfwVa63BD9nm ju/sE8asWWY7N4k5OVOOCOh6jHSooPDkrHyLq6isr75nNrcI4ZIljd2d8KSvCDC43HOcAYJAGeHd Zj0S7muXiaVisWxFOASk8UuCewIjIzg8kcVq3niLS9Rjhgm+2QxDRINOd0hVyJI5VckKXGVO3Gcg 89KpXXg/ULERSXU1rDbtHI8k5ZisJSQRurAKWJDsq/KCDuyCRkivF4fefVUsIdQs5mliEsUkHmTC QEZ27UQuGAzkMoIwfbIBq694os9Wn1a9t2vLW7uLy3ntgqjCiFGQEuGBVjuLcA4IAyc5HKyyyTzP NNI0krsWd3OSxPJJJ6mtLT9DOo/bWiv7VY7TlnKStuTnLhVQsEGOSQMblzyabBolzcacLsOqF1ke KKRJFMyRjc7I23YQoBz82eCMZxkAzKK25/DF1a6fHdz3NrGXtBe+SS5dYWO1GOF2/M20AAkjcMgD JDNW8OzaK0kN1eWf2yFUaa0V28yMMAepUKxG4ZCsx79ASADHooooAKKKKACiiigAooooAKt2ceSX x9KqdTgVrRR+XGq+lZ1JWRlVlaNhdtTxrhelRgEnrVgVyyZxSYm2jbSkgdTjtRuUvsKsT7qcevXp Uakahil20+jFK5NyJQzLnYVOejEf0zUgSnhacFNJyE5EZQEcgGnbfapQlOCe1S5EOZDsPpS7Kn2U u2p5iecgKUmypytMPQ8c0XGpERWo3DbG243Y4z0zU7DvTCKtMtMhK0w9KmIphFUmWmQkUwipiKay 5Bq0zRMgK00ipiMU0rVplpkOKaV445qUrTSKpMpMiwfpSEVKRTSDg459qpMtMjxSYz2p/GCeRj1o xTuO5HtpNtSUYp3Hcj2mkwfSpMUYouO5Hj2pMVJim7fencdxuKSnkYpp9aY7jcUYpe3ekz9fypju JRTqMUDuNopcUlACYFIR6U6imA3BoAx1FOoouMbkelJTiM0m00AAGadjigClAobFcAKXFKKXFSS2 IBxQBilooEFFFFICu33j9aSlb7x+tJWpsgooooAKcOlNpR0oEx2PrXReEdQtLDUIze3EEdulzDcM s8cjLlCfmUx87wGOAQVOTnoM85XX/D/TbfUNRuRc6ZLeonkcgAombiPOQVPbJPT5Vcd8hCRl3eux vqWuzQ2kckWqO/M+4PGhk3jG1gM5CnnP3fTOWWHiGbT7L7HFZ2j27q63KSIxFyGxjf8AN1XAKldp U59Tn0LQNA0+TxZqqTeH5TDHqpRTKitEieVMehjxtyVOM/xxenzc14Y1S30i4muJra5ifRHuLpbZ 8Fn80RweW7HG0qduTtOcngYwQZlf8JfqH/PG2/5BX9k/db/U/wB7733vfp7VW1fxFNrLSTXVnZi8 mVFmu1Rt8gUADgsVUnaMlVU9uhIN258Nw23hsXc0nlX/ANkS+EXml/MheUIp2iMBfvA/fY8fdGfl v+INSuNT0+8Dx3VrcQQQrc6TcRFYbUAqolgBI2f8s12lc4lbBIyQwM8+OdW/tybV0S1juZZ4p2Co duY42jC4JPBV2z39CKz9R12XUdMttPa0tYbe1kZ7cRb8xBsblBZjkEjdzk56EDiuo8aa9f6z4K8O z3ci5u5bmaREQAZR9qY74CsR1575PNcPbQpPcLHJcRW6NnMsoYqvHfaCfbgUDH2N9dabfQ3tlM0N xC25JF6g/wBR2IPBHFW5dZLnU/KsLO3GoKqusKuBEA6uQgLEAFlB5zjoMCq97aQWuzydRtbzdnPk LINn13ovX2z0rS8LaNa6vqKJfs0do0sdv5iS7D5sh+UD5HySFfqAOOWHGQDQ/wCFi619vlvPKs97 3KXSr5bYjdY/LOPm6MnynOeuRg81m2/inULS0NtbiKJUkd7VxuL2e8EOImJyAQcEHPYjDc1pN4b0 vS9Ovb3VJLy4it9XbTcWrLEQFBLSfMGyTjhePr6Uol0ceFtQcWl1LMl3FGlwZUQncsxU7djFRhRu XcckDkYoAzEvo00ObTxC3mzXMczSmTgBFdQoXHX94TnPpxVu/wDEl5qVl5FzHAZ2VEmvApE06Jna rtnDDkdsnYmSdopkKqfCV6ytKHW+tw67l2MDHNt425BGG74O7pxmtjVvCUNt4n1jR7Bp5WtYoTbB 3XLvI8K4Y4Ax+9Pp2oAzbfxRfWiWEdtFaxRWO544xHlWmKkec4JO6QZBBPAwMADis+31G4gvZbst 5s0scqO0pLFvMRkYk5yThic+tdRrXhrSNK0sairzzLBqD2Fzbx3OTvCE8SNCuCCOflYEHgirvinT tJu/iRcWDxS20MUBaZklCptjtg6hQIyUAC4PDew7UAc/P4w1C7tobe8htbmJPO8xXVl8/wA2QStu 2sMYdVI27emORkVXXxAVvVuBpenKqLGIoo43jEZT7rB0YSbuSSSxyTznC4NdtdEt1tH0e/a4Z1bz 4m3MIyDwQ7RpuBB6beCDyc1j0AdHb+MryDVZ9SNhpz3Ulz9pV/JMZjfBBAZGUlSDyrEg9Tkkkwxe K7xba2gmtbOdLZrjyw0ZQBJlKyJhCo2ncSMDIPQgcVhUUAdbe65aT+GFhkuYLm7bT47JSIJI5ogk yvtbkxsgC8MPmOVyOtZWreIptaaSa6s7P7ZMqLNdqjeZIFAHQsVUnaMlVU9uhIOPRQAUUUUAFFFF ABRRRQAUUUUAS26F5lx2Oa1F6VWtk2RD1NWhjtXNUldnJVldkiDmnmRFYKXUMegJ5NCDC1IOlc7Z yt6iFMgckcg8U/FJ3p4qWyGxAtPC0qingVDZDYgUU8LSgU8CobM3IQLS4Axk+1Owe1LipuQ2NwKC OKVh6Uh6UANPSmNTz0qNqpFIYaYR1FSHrTG61aNEMIqN87CVXcwHAzjNSkU01SZomREU0ipHIVCz HAUZJppq0UmRkZppH51LimkVSZaZERTStSkU0iqTKTIiKbipSM00rTuWmMxSEU/FJiquO5GV9Kax VfvED6mpcUlNMpMjxSVIFAUAdBSbadx3GUYp2KbTHcaRSYp+KQincdyPFGMdqfRincZHj0pDTyKS mO42inU0DAA60DuFJinY4FJTHcbRTqTFA7iUYpcU4Ci4mxAPSnYpQKXHFTclsTH0pKfiii4hvXtR j2NOopXAbtpdtLRRcCo332+tJSv99vrSVsjdBRRRQAUo6UlFADqkt7ue0cvbTywucfNG5U8MGHT0 Kg/UA9qhpelArFuLVdQguHuIb66jneTzWkSVgzPgjcSDknDNz/tH1qsk0kayKjsqyLtcAkBhkHB9 RkA/UCmUUDJftVx5XlefL5fl+Vt3nGzdv249N3zY9eetNklkmYNLIzsFCgscnAAAH0AAA9hTKKAJ ZLq4lt4beSeV4Yd3lRs5Kx5OTtHQZPXFRUUUAFFFFAFgX94JmmF3OJWlE7OJDkyDJDk/3hk89eT6 1FHLJCxaKRkYqVJU4OCCCPoQSD7GmUUAPEsghaESMImYMyA8EjIBI9Rk/mfWnNdXD2627TymFcYj LnaMFiOOnBd/++j6moqKAJZLq4m83zJ5X86TzZdzk735+ZvU/M3J9T608394QoN3OQqlVBkPAKBC B7FAF+gA6Cq9FAD3lkkWNXkZljXagY5CjJOB6DJJ+pNMoooAKKKKACiiigAooooAKKKKACiiigAp 8S75FHvzTKtQJtGe5qZOyJk7Isr6elTRjJFQIMevJ9asxjAFc0jjmTA07OOxNMBpwNYswaJO9PFM FPXrUMzZIBUi0wdakHFZsyY4Dmn4zTKUN61LM2PzRmm7vakLUrBYUnFNJpCaYWppFJCk00nAzSE0 hNWkWkFNJoJppNMpIDTT0pabmqRSCmnrTqZ3J5596opCGmkZpxpKZSG00jFOPWiqKGYppFPIpKY0 xmBSEdqeRSU7lXI8cUlSYzTSOadxpjMUYp2KSmVcYRxTeCM0+mlFIA5GPQ4qkykNIpKftwOKaCCA R0NO47iUmKcRSUxjaKdSEelA7jCtJT8UmBTuMYQD2pcU4ikIAp3HcZilAp23NKBTuFxoWnAYpQKd ipuK4mKMUtFIVxMUYpaKBCYoxS0UAJijFLRQBTf/AFjfU02nP/rG+pptbo6FsFFFFAwooooAKt2G m3eqTmGzh82QbcjcF+86oOpH8TqPx9KqV0vgvXE0TUJnmvZbaGTyN2wthttxEzZC/wDTMSfgSO+C AZ9r4a1e91Caxt7Tfcwz/Z3TzEGJMOcZJx0jfnpx7iorPRNRv7SW6tbfzIYo5ZHbeowsYUucE54D p9c8d67jQvGdpa+KtSubvVpxYz6oZkz5jBovLnUHaB05hGMdl/u8UvDvi8WWg3kF5q90ty8F95YL SMfNcQmM5HQ7hKc9iSeM8gGDL4Tvl0K31eGWC5hmieby4d5kREIV2IKgYVmAOCeuRkAkYVd7F4m0 zTvBVnZx3K3V4NPu7R4UV12Gd1YEllAIUKc4zzgDjJEXiLxFaXU15c2GqMbWSKAafYoJFNlInlnc AQEQgI65Qk/NxwSaAOKiiknmSGGNpJXYKiIMlieAAB1NauraC1h4ok0OyuVvpRKkKSKAod2A+XqQ CGO05PUdq2/GHiCy1STVobK8aW0kvLea1i2sqAeVJ5rBSBtJdgT0JJzz1rnNC1H+ydesNQLSqlvO jv5RwxQH5gOR1GRjvmgCvf2cmnajc2UxVpbeV4XKHIJUkHGe3FV66Dxfd22oa1JeQavLqPnSSMAy OFgjLsURS/J4OSMADPGai0O9FtaXcUOpf2ZeSSRsl3mRf3ahwybowW5LIcYwdnPIFAGetgz6TJqK zRFI50geL5t4LKzK3TGDsYdc8dKqV3Fl4htbHVZ7v+11mafV7WSSYWfku8KB/Mk2qCFDb8cHcwLZ HzEGU6v4eFteWlrcrHBeXN75qTCcRIGVvs7xxp8m0EJncpYHBAGAQAcFRXZnxBZSeG9HspbxnlSz vIbyNlYhjtb7MrcYYKxBXqFPPFbHiDUrZbmW8kMv9nxX2nqdMkhdHtofLZniMbgKAxjU7VJU7FJ6 CgDzSpbW2mvbuG1t03zTSLHGuQNzE4AyeOprsPGPiCLVbS6jh1O1uInvhNDFH9qZwmJME+adiYDA bUHOewWua0LUf7J16w1AtKqW86O/lHDFAfmA5HUZGO+aAHjRJv7Vv9NaeBZ7JZy2S2JDECWCkDrh WIzgcVX02x/tLUIrT7Va2vmZ/fXUmyNcAnlu3TH1Irqr/VrA+K7nVl137bugvDGs0EjIm9ZFihXe Dn74JBUIORk1btPEukJ438O6tNd/JDpqR305jcsZ/LdTu4yx5UZ5+vFAHn9Fdb4b1OLTbae2XxEu nkXiyGWO3fMiqrAMGCkuuSCYnUAjupLVy906yXc0iNuRpGKnyljyCf7i8L9BwOgoAiorsNU1q2ut E0+Ky1f7NbQ6atvPpvlOfMmG7LbceWckhtxbcPvY3ACtW68T6XJ4iS9XU92lGS0NtYbJP9CKPEWb Zt2LhUkX5CT82BwTQB51RXqtr4+0yXxAkt1d7LaG+aUSfZ8bxsuUD/KuT8jW6/Nzx04JqrB41068 sLSS6uYodQgnkKM8DJs32jK7bohkBpyWO07uQeMDAB5pUtvbTXcpjgTe6xvIRkD5UUsx59ApNdnq HiaGW6snbUIJJYbO6RpraOfhyrGFTJKxdyJAjDIAQ4IPGQXPiqIavp1xaanPGZdIW3vpkLqTc+W6 B5O7lSyncMnA4yRigDh6Kt6n5P8AadyYL2W9jMhP2mVCjSnuxBJPJz1OfXB4qW21G1gt1ik0axuH GcyyvOGbnvtkA9uBQBRUZauguvD93YwJLLJAVawjvwFY58t3VAOn3ssM9sd6wUGK7aDWLGbwVBZ3 9+r3QuUjkVISZxZBgfKWQpjIYbgN2MADPaolqRKzOe0+0kv7+2tIioknlWJS3QFiAM+3NbDaDILW 3u4r6zmtJrkWpnDOiRuQD829QQMHOQCODW9rGtaXqNmltHqixywais0F0PtEjpAfl4aTLb1wrEAh TgYyay9XudPv7O2aW8tZdWa4YTXNtA8cRiPO6QbAS+4nlV5A5ycVjJI55JDtT8KXOjzRx3moaeob cGdZGYRlQvBG3dk714AJwc8DmqGpaZPpc8KStG6zQrPFJGTtdG6EZAI79QDxWxrl3pupeMp9Sg1G 1MBEUsfnwSNG7LsUxuAueQCehGMDvxl606Tah541P+0ZZkDzTeWyAP3UbsZAAGDgDHYYrOaXQymo q9ivbxee+3zI48IzZkbAO1ScfU4wPUkVPZWjXkkqJJGjJE8oD5+YIpYgYB5wD1wOOtT6DPHBdz+b drbRyW00TFt5DbkKgEKCepB/D1xWtp+qWNvoMNvFci2lkE8d6hRszF1KRtkA/Iu7JGR0JAJxnNRT 3MlFPdnPCng1013rlnJoNtbQtB5aWQhktnWXd5vOWCgiI8kNuPI68kAVHquvrNaBbW/m8xrC237S 6lrlZYyzE922r970GM0vZx7k+yj/ADGReWM9gtsZwo+0QidADn5SSBn8s/jTnsJBcWkEM0FxLdKj IsLg7SxwFbPRvUdq09c1eDVdLs3/ALTnaWK3ija0ZWO6Ubg0jEnb0xgjJOecVJqmrWUuuaBdi/Fw tslulzIFkyGR8sx3AEg5z6nB49V7ON9+wvZRvv2M+90aayuoIJLq1ZZZWh85ZDsR1bawbIBGMg9O hBGazrhPIuJYfMjk2OV3xnKtg4yD3FaVzqNsfGgvzLHJa/bkm8xIyoCbwc4wDkDrxkkHr1Ola63Y W2o6+8dzEJLuQPbXLCVV2l9zKSgEi8EdOCV9MZfs4sfsot6OxypanRRTT+Z5MTyeWhkfYpO1R1Jx 0HvXVP4ltoE1i6hu4nuXuoJrSNIXjBZSA74ydoYZB+bLDORziuXF6WubuZZns/PV8pbR/KwY58vG 4YT88YHBodNLqN04q2pAWrZn8NXcDXURuLZru0g+0T2ylt6JgE8ldpwGHRj7ZrB3V2N7remyarrm qLexyRX+nm3itRE4lV2VF+YkbMDBzgn2zVQhF7lU4RadzkSanu7X7J5H+kQTebCsv7l92zP8LejD uK3/ABT4kS8uby1spbe406fy3j/dMphYElioIGGZixJwchutO1PUra81XTJ4b77VJDprQSTKkhaO VUf96cqDgFg24ZI2k4yBl8i2uP2a1VzlGbarNgnAzgdTUlzH9nnmhWSOQxsyCSM7kbBxkHuK6PxZ JIl1oSR3u3FhFKJwzhRIzEtL03ZJwxONx+tLb6zZ22t+IpRe5gu4ZntmRXw0pYNGcYyGU5wSOD0P ejkSdrj9mk7XOVye5zV/TtKl1OK9eGaFWtIGuHRywLIvXGARnp1I6/Wurm13QV1bUryCbcs1xE7x MJUjnhCfOAi4DOW3f6z5Tn3NYGg3dnpw1rz7uP8Ae2EttDtRz5rN0I+XgcfxY6j3w+RJ7j5EnuYV BpM12s3iKwnimjlvGkSbQxHIrq5D3gxhmGOW4Hz+w54pRjfcUYp7s4miu9u9f0md7UNexubTVI7m KU+fIxt84K7pMtuGASBhTxjJ4qJ/FNheadatdGM3kNwWQPBt2FrfDPlACAZzvO07u4GQKvkXcvkX c4ekkjeGV4pUZJEJVkYYKkdQR2Nb3ibVY9RisUFxb3E0SOHkijl4BbIUvKxd+55AA3YGe2HcP5tz LJ5sk25y3mSDDPk9TyeT9T9aTViWrEtnZtevKiSxo0cMk2Hz8wRSxAwDzgE84HHWktLL7X5/+k28 HkwtL++fbvx/Cvqx7CrOitAl7Kbi5jt0NtPGHkViCzxsgHygnq2foD9KveG9Rt9PtdaW5u/KW5sJ IY4cMfMkI+XoMccjJx97600kVFLQ56iutXxBANC0y2+2yCZbO8gul+b5gVcQKx/iALcdQue1XNY1 3Sr+LxC8V6obVIrd4kaNwUMW3KP8uNx5xgkcHJHGXyruVyrucHWjP4f1S2mtYpbba91M8EI8xTud X2MOvGG4yeK29T1y0l0fytOumtLyOWN7l1Vgb91VR5ofGQQwZsNjO7d97IrS1TxZbT6hoUsOpzGO 31GeW4PzjERm+TPHI8skYGcAke1Uku5SjHuclH4f1SW+s7JLXNxeQie3TzF+dCCQc5wOFPB5rPuL aW2kEcqbWKJIBkH5WUMp49QQa7y38W2w8UeH7ubU5ja2+nCK7ZvMP70q27IxliWCZPOcD0rk9d1F tTv4p2uZLjbbQR7pGJIYRqHHP+3u+pJPem0ktBtJLQyqbtxnk4/lTyKSpFcYM4GetGKcQTjBxTQD 3IzVDG4opRhgCOhoxTGJRiiigBuKMZp1FA7iAUoFLilA4zRcTYmKMUtLikK43FJin4pMUXC42inU uDRcLjKKcRRjNFwuNxRinEUUBcov/rG+pptOk/1jfU02uhHStgooooGFFFFABWxoHh6fxA175M8E K2ls9w5lkVScA4AyRwTgFjwoOSegOPW34a1i30i4v1uklMN7Yy2bPEAzR7wMMFJAbkDjI69aAK+n 6PLfTahENxaytpJ3MGyQYTGeS4G3nqu4+gNEOhXc+jS6oktmII2ClWuo1k5DH7pOc/IcA8nsDzjS 0XWNH0rU9ZCpfJp95Yy2cJISSVd+35mGVHYnA+mT1rP0u90+OxurLUo7poZZEnX7Myhi6LIqqS3C gmTJbBxtxg5yACrHZeZpNxfeZjyZ4odm3rvWQ5z7eX+vtVi98P6np0LSXUCxlFVpI/ORpIw2MF4w dyDlR8wHJA6kUQXVmnhu8s3ecXctzFMirEDHhFcctuyCfMP8J+6PXja8U+K49ea5nivtVRblY86e zYt4iAuTncd4ypwNq8nOeMEA53TLa3vNTtra6uvssMsgRp9oYR54BIJAxnGTngZPtW7qngi90lra 0muIH1O4aVltkkUKsMYJMjOzDaDgkAjoDkgjFY+hz6fa63aXGqRSy2UUm+SOJVYvjkDDcEE4yPTN dQ/jiHU5LW+1QTw6tA1zEtzZRKNsMkTBerAlkduORxnkk5oA5yTw3qkbwqYIis0bSRSJcRtG6q2G IcNtO3q3PygEnABNVdQ0270u4WC8h8t3jWVCGDK6MMhlZSQwPqCa2rjX7drmB2v9Y1DZaXUTyXrg /PLG6LsTc20DK5O459Bjmr4j1i31f+yfs6Sr9j02G0k8wAZdM5IwTxz/APWoAxKKu2es6pp0Jhst SvLaItuKQTsgJ6ZwD14H5VNH4j1yFSsWs6iilixC3TgZJJJ69SSSfc0AZldbcaLq1zNpenz6xPca Pctbpa3OZJICzYTag6Bky42ttOEPAyBXJV1ceu6Jpt8b3S7S6VHkt5fsEuPLheNkcsshZix+V1BK jiRvoQConhqH+07y1n1OK2itdSSxa4ljIXDeb85weP8AVdOnzckAZqxpngya61q10i/uW0+/mlkR oJLdiQioWEinhWUlWXg9gRkdLEuueHH1C8mngvr62vtSW7nt5IxDsTEwwGWQliDKD/Dnb1Gat6F4 u0fQl0qDF9ex2d3NP50kCI8aPEU8tF3twWO48jp0JoA5TUtM/sxIYp3lj1A5NxayRbTCCqshzk53 BunBBBBFRWll9qtr+bzNv2SATY2535kRMe338/hVrVptJktLNbGS+nuk3C4uLtQu5QFEaqodsBQp HX9MAGj3OnwW2pQ3011H9qgWFDBAsmMSI5Jy6/3APx9uQCrYWL38syIf9VBJO2CuSEUtwGYZ6c4y cZIBxirVn4a1fULSO6s7Tz4pN4QpIhJZBllxnO/HIXG4gEgECrcN7oNt4huJrYX0Gmm0kgiBjWSU s8PllmG8DqzNwfbAzxq+EfGGn6Bp9nb3UN07w6k92xiVSCht2jAGWHOSPw79qAOauNE1G0iEk9vs RrRL0Hep/cuwVW4PcsBjr7UXmiajp/mG6t/LRI0k8zepRlf7hVgcPnnG0n7rf3Tjbv8AxHp+oaXD Gy3UdyNKj010Easg8txIrhtwJyUUEYGNxOTjBZqviSzufC8Hh20jnFpZss0E8qjzJZMtv3KDhV/e HGCxG0A53ZUAwtLsv7S1aysfM8v7TOkO/bnbuYDOO/Wti/8ACN1ZXsunJ58uo+a/2e28jBuIF8zM qncef3Z+UjJBBGc1maFd29hr1he3RlENtOkzeUgZjtO4AAkDkgDrxnPPSuts/FXh2y8Srrf/ABNb if7ZLKBJGiiGF1l/doPMOTvkBJ474xzkA5+08J6hPqlhaTmCGK9YeXcC4ieNl3hG2MGw7An7gO72 qrBoGoXM11HCkDLaqrTTC6i8lA2AuZN2zJJxjOevoa1YfElnHZ+EoTHPu0e5kmuCFGGDSq42c8nA 745qXS/EOl6Pa6pYWE+q20V5FBi+Tb5yyI2WIQMu1WyRjeSMdTngAzY/COuSXE0AscSwzrbyo8qK Udhlc5bgN0VujEgAkkVFH4b1aSBZxaYQyPFhpEVvMU4Me0nPmc8JjcewNa//AAk9nDpviCO3uNVe 7v5bc201w4eRBCwIZpAQdx5wAOMDk9a0dI1G3t/BMV5e3qyXkOtjURAJo3mmwoHzAuGALZycEjrt I5oA5s+HNWXTV1H7JutGQSLKkiMGB3Zxg5JARiwHKgEkAVPDodw+hw6kiSSeddC2jSMIwLYJA4bc G4+6V6YOeRVi/wBYtJ/DOi6fZyXi3VgsyysYwisJTlgCHJx/DyOQTnHSpodV00eDU0iUXbXAvxds FRVUjbsKB8kg7ec7TzxjvWcrGUrEbeGNXRygt45GWZYHWK4jkMcjHaofax25Ixk4GahudIvbK2S6 lSNrd3MYlhmSVNwGdpKEgHBzg1vSeItIe6tLqT7bd3NveRTR3MtvHHKIlIyrsrHzThVwSFOcnOOK zdU1RLuxigGqavfSCUuxvG2xqMYGE3NluTzkccY5rKSRjJRsZ9rbSXchihKmXGUjJwZD/dX1b0Hf GBkkA6Q0S5llkW2ZZBBGjXLSfuRA54KOZMAMGyOvOPqBQsjabpEvBIEdMLJGNzRtkHIXIDZAK4JH 3s9q61vF9qy3cMb31uZ7W3hN/GB5zvEeXYbhywJH3icAdc8QknuZpRe5jJ4d1dp5Ils/3kUywSq0 qKUZvu5yeh7Hoc4BJwDG+kX8P2PzLZkN5KYYAxALOGCEEZyvzEDnFaX/AAkFtFYaykE2ovc3kkJg lncM6iNgQzOCDu64AHGByetRJ4hjl0+xF2k0l7p1wZ7Zw2VlLNvPmE88MAcjqMjj71TywJ5Yf16/ 5FN9Jvo7RLl4QqPH5qIZF8xk5+YJncV4JzjGAT05qW60LUrK0a6uIFSBQG3+ahDA7QCuD8wy6jIy Mmrl94kS70u1hS71GBobNbV7WJsRSEZG4tu7gjI284xnuK2v6va362K2MlyFhsktJRKgQOEOQeGO cnnB6YHXsuSNiXCFjLTa8iKzqgZgC7ZwvucAn8hWhq+lDSprCL7ZFKLq3jn83ayogYkehYgYznAJ 9KyEaMyoJGZUJG5lXcQO5AyMn2yK2td1PS9T/s3yJrxfsttFavvt1GVXOXGHPPP3f1ojFWCMFZlf X9MOi6zcad5/m+Tt/ebNucqG6ZPriobGxfUI7kQvuuI0DRW6qWeYlgCFAHYEse+B0xkiz4p1Wy1j WpdRs2uB52N0c0SrswqqMEMc5wewx71V0u706CO4W8FxHcHY1td2/LQMrZPy7lByO+eMVXKubyK5 FzeRraX4YXWJb5bO/E0dtNAiyRwMfMWR8FsHBXaOSPY845rKj02Wa7ltYHSV4DIZpUy0SRpjMm4c levb0xknFa+oeJtOu7bxEIbeaGTU5YTEgRdqhCCWYg/ebkkAHnuc5qrb6po/9gWunSyX1sTIZL77 PCjfacN8g3FwQFHQYIyc4zVcsS+SPQw9wo3VDvrQk1/V5onil1W+eNwVZGuHIYHqCM8io5SOVFTf WtPpF9pWmQalOXs5zcmNIZFaOUbQGEi5wSMnGexx68Y8boJUMqs0YI3KrBSR3AODg++DWzd6pYp4 ZTR7NribN4bp5poljx8m0KAGbPc5yKaihqKs7kNta3uuzXs5uPMmt7ZrmV7iQksqYBGecnGMZpuq 6Y+ly24aRZI7mBbmFgMHy2zt3Ds3HIBI9zVi11ax0zVL0WC3Dadd2z2rG4CmVVdRlsAgEhhkDuOO M5DNV1e01XVbPfHNHp1rFHaoAQZjCh6ntvIJ9un1p2VvMfKreZX0+yS++0A3UcTRQySqjKxaTYjP gYGP4e5HXjPSiy06fUcC2jc7XxNKyHyoFOMO7jOB97ORwFzz2XRrmxtp5pbyW5TdDJEohhV8742Q k5dcY3A98+1T2F1pFjPbXge/Nzaz+aFMaFJwrAp/FmMnGD9/1HpQooFFdTK3V0Nx4Tu4Lm+tTMpn soGnlbYREwUBmCN1LAPHwQPvHpgFsj+2tUNr9l/tK8+z7PL8rz227cY24zjGOMV0F34ugnS+vEju P7Rvrb7NLCxH2eLcArunOclUTAPTnJbAppR6jjGPU5TJrRn0o2mmW15eTeVJc72jt9uZCgX5Hxnh WbI5wcDIDUyF9KQ6a8iXUjLKTfISNrJuGBHgg525zkjnpU+rXVhepJci81C61OWbdJLPEkabMdAA zHOcY7Y4xxSSQklYjv8ASvsGl6ZdvN++vUeQ25XDRqGwrdeQw5BwOnes0nAq7rN9/aetXt6GkKzT M6eYfmC5+UH6DA/CqNJ2voJpX0FzSUUUAFHekJptFgFJppNGaSqGkFFFFBQUhFLSGmCEpCM0tFAy NtwPAB+ppecc04jJpD6VQxpFJTuc9OPWjB9KB3EApdp7CnAY69aXFK4riAcc9aUDAwOlLijFK4ri UUuKMUAJRilxRigLiYHpRgelLijFAXG4FGKdijFAXG496Q788BSPc0/FGKLhczZM+Y2euTTadL/r X/3jTa6Vsda2CiiimMKKKKACiiigAooooAK3brwpeW01tCt1Zzz3axSW0SSFTNHJgK67woxuOMEh hgnG0ZrCrb1HxPdX93pl0lta2k2mxpHbtAHOFQ5QEOzA4P555zQBaTwVe3GoGxtL6xurlLsWkqRm RfKfDkklkAIAjfpnpwDmjT/CYurjTZjqNrNpt1fLZSTweYCjkA7cOgOSDwcEZ6kUJ41vbfUDfWlj Y2ty92LuV4xI3mvhwQQzkAESP0x14IxVV/E90lpa2tjbWthDbXYvUWAO2ZgAAxMjMeAOnTnkGgCH xLYW2m+Ir61tJopIY55FVY9/7oByAhLAEkADkZHuaboFva3OroL2JpreKKad4lfYZBHG0m3dg4B2 4JHODRrWtSa3cieSzs7Ztzu32aLaXd2LMzMSWJye5wB0AqvpuoTaXqEV5AsTumQUlQOjqQVZWB6g gkH60AaumabBrdjLHFDa2t1JqUMMMrNJtUSLL+76txlFAOCeeTjpLp3hyW3N4dWt4owILxIUlL7n lhjYsYynynawAJY7TkgZI4z7PXZbDb9mtLWPbfR3w++cNHu2Jy33Bub/AGueTV6XxnfXDIbm1s5w ktzIgZXAC3AYSJ8rD5TuJH8QPfHFAF278O2Ntpthaqm66uNNOpPdmXDAmN5FiEeeUxEwLddzKcgf K3NaXZf2lq1lY+Z5f2mdId+3O3cwGcd+tWpPEN9LpkNlJ5TNDG0Md0V/fLCesW7+519wCVztJBeN fkh8N22kWsbQtFeG9a4EnzeYF2rswBtAHuTnnI6UAafiTTdMtrS9Wysfs8lhfLaiQXPmGdCJFLSL /C+6EnA28P0xgmpr+m2kWj6NrNnD9mTUY5A9qGLrG8bBSVZjnDdcHOPU9q+q+I7rVrYwy21nCZJR PcSQQ7WuJQu0O5z15Y4XAyzHGTVfVNYuNV+zo6RQW1tH5dvbQAiOId8AkkknkkkknqelAGfRRRQA UUUUAFFFFABRRRQAUUAUp5oAQcmpVFNVamValsiTHgYp69aaKdnBAGMk9KyZiyUU9aYOlPHas2ZM kFPyKjpc1BDRJu96QtUZPvSFveiwuUkL00tUZemF/eqUSlElL00vURf0pC9UolqJJuozUJOaN1Pl Hyku6jNRZNGaLD5SXNGaizRuosHKS5ozUe6jdRYLEufejPvUe73o3cds0rCsSZ96M1HuPtS7gBmi wWJM0ZpmaXNKwrD8+9G73pmaXNFhWH7jRmmUUWCw/JpM+9NoosFhcigmkooCwUUUUDCiikyKAFpD RmkpggooooGFNI6mnUlMYgwfpjNOA4wB0op1JsTYmKWiikIKKKUZoEJRS80tAXG0U7FFAXG0U6kx QFxKKXFGKAuJRS4oxQFzMl/1z/7xplPl/wBc/wDvGmV1LY7VsFFFFMYUUUUAFFFFABRRRQAV6X4k 0T+2rfw1e3N9ma7tLCy+9ukV5C7GVweSMAgDIycnI24PmlWJL+8mULLdzuoiEADSEjywQQn+6CAQ OmRQB1tzoHhiPXodKiurqSZtSWzdEuCWCEspYloFUENs4BbPIz3p9t4U0C/1+PQ7bUrxL5Lma1mE iA79kRPmrgYVfMUjYWJIxyK48X94JmmF3OJWlE7OJDkyDJDk/wB4ZPPXk+tEd/eQ3pvYrudLssWM 6yESZOcnd1ycnP1oA6tfDGkSaZYaybie2sZ7aaaSGeXcVKTJEP3iRng+YD/qz0x3yLXhK30q2+Ju kLo9611btE7MWDZjfyn3Lkqu4cZB2jg9OK4eS6uJbeG3knleGHd5UbOSseTk7R0GT1xT4r+8guku obueO4RQqSpIQ6gLtABHIG3j6cUAV61dJsoVQ6rqVtLJpcEmxlRinnylSViDY46ZY9lz3Kg5VPeW SRY1eRmWNdqBjkKMk4HoMkn6k0AdLfeG7O2vNMhSScrdaIdRcswyJBFI+Bx93KDjrjPNafirwbo+ j29+1jd3xmtMZSdUZWwYt3zDB6XEWOP4X9RjhzLIYVhMjGJWLKhPAJwCQPU4H5D0qWa/vLmaaae7 nllnULK7yFjIBggMT1A2r19B6UAdL4ilkm8BeEGlkZ2C3agscnAkUAfQAAD2Fad7oUWueKPDWmNd 3Sw3ejI8TSbGaABJGRflVQwBA6jJ55HbhJLq4lt4beSeV4Yd3lRs5Kx5OTtHQZPXFTLqmoJcQXC3 10s1vGIoZBMwaNACNqnOQME8D1oA6C98OaePDMOt2rXUaT2kkqwSyK5V0uI4jlgq5BEhOMDBHU1a u/DWg6d4v1DSLqS++y23lv8AaPNVRFF5e52ciNsnJVVUAZLAZyRnj5Lq4lt4beSeV4Yd3lRs5Kx5 OTtHQZPXFD3VxIhSSeV0bZlWckHYu1fyBIHoOKANBrLS7u4nktdTisrYSFYo77zHlK4HzExxleee O3Tnqem8BX0z65DopvPOtl88RWiRBbe7JjfPmtwxHC43IxxxgVxNzdXF7cNcXU8s8z43SSuWZsDA yTz0AoS6uI0CRzyoi78KrkAb12t+YAB9RxQBFXovjGOGF9a0eGfFlp0ET21iqELAQ0AEm7+It58w Ocnuc/Ljz0SyCFoRIwiZgzIDwSMgEj1GT+Z9ac11cPbrbtPKYVxiMudowWI46cF3/wC+j6mgBsTr HMjtGsqqwJjfOGHocEHB9iDXceL9Umh1vw7qMEn2F5NGgJa0jH7lX3hhGpIxgMQORjjkda4p7q4m t4beSeV4Id3lRs5Kx5OTtHQZPXFPe/vJGjZ7qdmji8hC0hJWPBGwei4JGOmCaAOw8RxxaloHhueX U12vFcj7ffq/nTFZfuMEEhAGePmI5PTvFoVrFpWg6/qtlewT39ktqbe7gDjyi0pDDDqvJCgHgjBI 6EiuQLySLGruzLGu1AxyFGScD0GST9SakhkkglSWJ2jkRgyOhwVIPBB7Gk2S2dB45sbbTvGeo21n AsMCsjLGnAXciscegyTx0HarWmXWpaf4dju57rydNSRvs1n9wX8hI3BwBl4wPvFsjA2AjPHMQySQ sWidkYqVJU4JBGCPoQSD7GrC3l0FtgLmbFqxa3HmH9ySckr/AHTkA8VDZDep01nqest4dm1C81CQ 6bBCdMgtg5VZWaMqBtUY+VW3bm67QM9xkNY2VuglOq2l0qsN0MAmV3GeQC0e0HHc/r0qgLmf7J9l 86T7Pv8AM8redm/GN2OmccZpB0rNszbOzuPCmm2kmlbp7qWPWLiL7JjapihbYWMnBy/zgADjjP8A s1U/svw/cz2FvZahI1xcXIt2iVmcKrcLJuaJOjdVxyOhFc8L67ErSi5mEjSiZn8w5Mgzhyf7wyee vJpI7maLyvLmkTyn8yPaxGxuPmHoflHPsPSlddiW12NfV9NtbXSNK1OzMyR36y5hmcOUKPtzuAXI ORxjj3qDSrexuLfUJL0XP+jQrMnkso3fvFQqQR33jntjOG6VnSXU8sEUEk0jQw58uNnJVMnJwO2T 6VGszxq6o7Ksi7XAOAwyDg+oyAfwFHUVlc7K38OaJMBcRXl1eWdxqsdhbtGREVDKGLNuU7iM4xhc 4z34juPC9jYHTraea5muNQvZrSOWNlRItkoiDFSCW5O7G5fT3rkY7qeDHlTSR4dZBsYjDrna31GT g9s1E0jNEsRYmNWLKhPAJABIHqcD8h6VSt2NFbsdbJ9h/wCFYmWG1kSZtUSNnaRSSwizn7o+XBbC 9ic5PQ5VzZWsejC4WDExRDv/ALVgk5OM/uQu/v0zkd+hrF85xE0QdvLZgzIDwSM4JHqMn8zSRzyQ ypLE7RyIwZHQ4Kkcgg9jVWHY6WLQba2+y6dqDMur6jLFHHEP+XJGdfnkHdyDwnYHJ5wK29VgstX0 bwrFHPcx2IS+YPcvukEUXzYJVTjhMcA7Rjhsc+exzPBKksTtHJGwZHU4KkHIIPY0hkdoVhLsYlYs qZ+UE4yQPU7R+Q9KasUrHS3+m6GbGe40u/knkhtvMki+ZgjedGg+do03ArIeNowR1NGpeH4La60i OKaRILnTob26nkwwgDEhmwMcDjA6kkAZJArmnkeRER3ZljXaik5CjJOB6DJJ+pNPkup5fN8yeR/N k82Tc5O9+fmPqfmbn3PrRZBZHXQ6Fo+qWdrfWi3cEE+sxacqPIpPlFFy54++Tk+gzjHFS6h4V0zT kTe93K00t+yESKoSO2LfKflOWYKRu4AyDtOMHiEleNZFR2USLtcKcbhkHB9RkA/gK2LHWbO104QN p8jXKR3CJKlyVQ+dHsJZCCMgd1K5wM5xmnZDsjptXt7ddG0vSre9ubRJNH/tB7aKEGKeQI0jM7bw ST5YAyCBgYq9a61aeIBr7Qy3a240Z2XTZYx9ntyioAUO7GQwyPkXr2rzcXM42YmkGxGjXDH5UbO5 R6A7myO+4+tMEjrE0QdhG7BmTPBIyASPUbj+Z9aAOgudOs9D08LqqSS6pOEYWkcmw20eQxLnBw7D gLg7QcnnAq7d6LoUdzNaW97dm6spJ1uIpFAMyxRF2dCBhAWRlAJY4IPbB5HPGO1PlleeV5ZnaSSR izu5yWJOSST1NKyFodta+FdNvNOttVR7uO1ewurt7YyKzkwsFwJNoAB3A/dOMHrnhh0jSdN1KESQ XNxDeaO99EjTIDFmCQlSdhDHK5VsLg4ODiuOW5mXZtmkGxGjXDH5UbO5R6A7myO+4+tJJK8rZkZn IULljngAAD6AAAewo0DQklMZlcxKyxljsVm3EDsCcDJ98CujsdH0iXwsmrXs93CxuzZMU2sgYgMJ CMZ2qu7KjJYgYK1zUkrzSvLK7PI7FmdjksSckk9zUn2qf7L9l86T7Pv8zytx2b8Y3Y6ZxxmpIOpv NC0TTNKtXu76T7Zc6d9rRQ5HzsrFFCiJhjIAJLjueOKivdI0iPRJb6ya9uIlgQ/aY5Y28uY8bZYc BowSGAO5h93BbOK5sXEw2YmkGxGjX5j8qNnco9AdzZHfcfWg3Ezb8zSHeixtlj8yLjap9QNq4Hba PSjQeh2H/CK2P/PW4/5GD+y/vL/qvXp9736e1TzeEdIeytry2vbtYTK3nfaFA+Q25uFwVBwQmFJw 3JJA4weLF7dLM0wuZhK0omZxIcmQZw5P94ZPPXk+tJ9pmNp9kM0n2bf5nk7js34xu29M44zRp2Fp 2N65sND+2WK6fdNdLIr/AGiE3AiCEfdImkjVcEdivYjuKgn0cz6iLexh2IsJmlY3aXKxoM7nZ4xg AAdME+mcgViuzSpGkjF1jXagbkKMk4HoMkn6k0pkkMLw+YwicgsgPBIBAOPUZP5mp0J0O48P2Vgu p2+u232uC0/tGGxtIVkHmM5C7nkbGNpXJKjqWI4AzVG20HSI/D2n3+o6g0El+0u05YCMI23IVY23 nvgsnUD3rlhLIsJhV2ETEMUB4JGQDj2yfzNBmkMSxF2MasWVMnAJxkgepwPyFO47rsdJeaBa291p 8SSTFbnRzfvkjIkEUj4HH3coPfrzVaPTbfT9JN9qoYzXMR+xWinazAjAmf0QdQP4iPTJOOLu4WBo FmkETZzGHIU5Kk8fVV/75HoKbJNJNK8srtJI7FmdjksT1JPc0hadjrbPwra3l1rtuLiZGsr6G1gY 4Iw8xjJYYGSBzwRV3QPD+kTah4duWgmkj1GW4fyZ5A6osSnAOFG4lhnsMcEHrXFfbZnaLz2a4jiY ERSuxXACjHBBAwqjgjgD0FaOoa99otNMtLKGS1h07e0LGbfJuZtxO4BehAxgcetNWGmuxtwzR6LL Brlxe3d7Hq1pcQxXTpi5t5F+TeAWOSOAMODgnpjl3iXS5dX1jR0tDvabSYZ57qfCfKM5llOTjgDJ JPYc8VxrSvIqK7syxrtQE5CjJOB6DJJ/E01Z38gxq7iNyHKZ4JAOCR6jJ/M0rhzaHSabp+jaq1wk ImN0rRJb2puUtzMMBWYM4Yby3OzjGTgtirNv4UtLu00S5gnmMd5K/nl8KfLFwkIKgA4b94CQSR/X kxM4iaIOwjZgzJngkZwSPUZP5mp7fU760RUtry4hVXMirHKygMRtLDB644z6UIE11R0tr4UtpdFl kuZWg1Aac2oxoJd4aMHjK7AACP8AbJHBx2Dj4VsfsrqJbgXB0ZdVWQsuwcDMZXGTk7sNkYyODjJ5 MXVwuzE0g2I0a4Y/KrZyo9AdzZHufWtPV9e/tOCwRIZLdreySzlImysyoQQcYGOecEnt6cvQLoy4 xGZUErMsZYbmVdxA7kDIyfbIrpv7E0tr/SIjDfpFf3AjWRbhJI5YyQodJNgIYN1RlzjGdprll+6M DA9PStDStQ/s/UbO4lWSaG1mE6wiTaN3B9DjJVc8cgVKEmluXL/To9P0jRNXs5po5LtZCQW5jkjf G5WAGAeCB1GOprRn0qK+8R+Iru7+WxtLmQyyecY9rNKQvRHJzz0X8R35qaXzXAUyeSmViSR9xRck 4zgdyTwByScc0Nczu8ztNIWnz5pLHMmSG+b15APPcUXQro6Kz0HT2vNR0+WaS41C3ufJhgE6WwmU MVJVmDAtnHy8cdCeg1dKgtNQ8G2tjczXT2ra6sEO3CsAyYHUkKPmLYGeeO+4cOJHETRB2EbMGZM8 EjOCR6jJ/M1LHe3UMSRRXMyRpKJlRZCAsg6OB2b360KSQlJI1dP06znsY5Jbfe7Zy39sW8GeT/A6 lh+PXr3qebSNMGhm+gF1Kot4y08M6SCKY8FJItqsi5DANkj7uM5xXOVKbmdt+ZpDvRY2yx+ZRjCn 1A2rgew9KV0K6N7W4wvhHw3IksxjdbjEUhUhCHAYqQoOCcnBJx0rXvdJTW/EHhXTpZWjjl0iDcyj JwquxA9zjGe2e9cU9xPLBFA80jww58uNnJVMnJwO2TUhvLp5YJHuZjJAqrC5kOYwv3Qp7AdsdKOZ D5kdHZaDoOqazY2FjfzO11FKH2ksIJFBZWy0ab1IH3cAj1qz4Ss9OXxbpDi3mZbqJp4FllVhCV81 Tu+T5zmPII24464rlIry6t5YpYbmaOSFSsTo5BQHOQpHQfMenqfWmLcTI8LrNIGg/wBUwY5j5LfL 6cknjuaFJdhKaWtiOTYZXMSMsZY7VZtxA7AnAyffAroNF0jTNQsUYi6ub0SkTW0EyRSLGBndGrKf NOA2QCDnAx3rn6kS4mi8vy5pE8p/Mj2sRsbj5h6H5Rz7D0qU+5Kdtzu7fSLLWtE8L6a89wvnfblg kCKMYYsGYZP90fKD3PzDHOHa6BY3MN7b7rhbu200X/nb1MbZRH2bNuRw+M7uozjtWLFqN7B5HlXl xH9n3eTslYeXu+9t54z3x1qBZHRXVHZRINrgHG4ZBwfUZAP4Cqcl2Kck+h0154VgtNP126aWQ/Y3 X7MAw5UzyRHfx1/dk8f/AFq5baKsPeXUtuIJLmZ4QwYRs5K5C7QcdMhQB9BioKlvsJtPYyJv9fJ/ vH+dMp83+vk/3j/OmV1rY7VsFFFFMYUUUUAFaunaY2paTeC0tZbnUEnh2RwqzuIism87R2yI8nHG R685VFAHodx4W0yfxbe2em2DT2ltqljC6wu8gjiZH84Egkgbl5J6EY4rHbTVvU8Qado4ikjTUkli AmXaLeNbjL72ONgBX5icfMOckVzK3MyWklqr4hkkSR1wOWUMFOevAdvzqKgDrToav4aXUk0dYnjs y8k0kxa2lXcFEiOH+WcEkGI5BweAcKeSoq39h/4lP9ofarX/AF/k/Z/M/ffd3b9v9ztn1oAqUUVo SaRMLuwtbee1u5r2ONo1t5Q21nOAjk4CuD1HbNAGfRVi/s5NO1G5spirS28rwuUOQSpIOM9uKfpl g2qanbWEc0UUlxII0eXdt3HgA7QTycDp39KAKlFWL+zk07UbmymKtLbyvC5Q5BKkg4z24qKKKSeZ IYY2kldgqIgyWJ4AAHU0AMoqVYN1pJcebENkiJ5Zb523BjkDuBt5PbcvrUVABRVu4sfI0+zu/tVr J9p3/uY5MyRbTj51/hz1HqKdq2lXWialJp96FW4jVC6q2QpZQ2M+ozg44z60AUqKfEiyTIjSLErM AZHzhR6nAJwPYE1d1vR7jQNYn0y6eJ5odu5oiSpyoYYyAehHagDPorV0jQm1fYF1CxtnknS3ijnk bfI7dMKqsQOnzEAc9az7q2msrua1uE2TQyNHIuQdrA4IyOOooAiorVk8PX0WmQ3snlK00bTR2pb9 80I6y7f7nX3IBbG0EjKFAC0oHNdBdeDtT0/+yhfNbWh1LcUFxL5fkhcZMhPC8EHHJ7YzxVe80KS1 0lNUhu7a8smnNuZIN42ybd2CHVTyOcgEcUmJmUBTsZqeztJLyUohVERd8krnCRr3Zj6cgcZJJAAJ IBsanpdzpF6bW5CklQ8ckbbklQ/ddG7qfX+tSQyoOlPrS0nRG1XYFv7K3aSdYIkmkO+R26YVQxA6 fMQBz1q3H4Ykaa3t5tU06C8mna3Fq8jtIsgfZhtisFyehJwRzUWIabMMU/PHemZozU2IsPyKQtTc 0hNFgsKWNITTSaYzHFUkUkOLY700tTSaaTVJFpDt1Nz700tTSaqxSQ/PNGRUeTRk07FWJNwo3VHm jNFgsSbqMjFR5NLmiwWH5pc1Hml3UrCsPzS5qPNOzRYVh/Wkxx3/ADpKXNIVh4NKDTKMmlYViUGl BqMGl3VNibD80tNozSFYdRTaXPFAWFzS5pKKBDs0ZptFArDqOoptGaQWDYPVv++jR5agYG7/AL6N Lmj86eo9RNg9/wDvo0BQDnn8zS5oBoFqLSqOKSlTO0Z645pMQ8UtIKWpJYUCigdaQh1FFFIQUUUU AOXpS0i0tJiCiiigAoopcUAJRinUUhXE2ilxRRQIxpv9fJ/vH+dMqSf/AF8n+8f51HXatj0Y7BRR RTGFFFFABRRWrofh+78QTyxWktqjR7N3nzBM7nVBgdTyw6fTqVBAMqiuosvAeq3+pXNjFcacJbe5 +zOWulILbWbIAySMIe2c54+VtsWn+CtT1Kylu4bjTlSJZmIa8TP7rbu6EjHzDBJxjkkAqSAc5XUH WYovh7aafHqLHUItU+1RRpvBgQIQMNgAHd83yn+LPXNMh8G3F14ftdUt7uI+baXV3JFIpXYkDhSA RncTuz0H1rPuPDeqWmBcQRRP8m+NriMPEHxtMi7sxj5l5YADIzjNAG94w8QWWqSatDZXjS2kl5bz WsW1lQDypPNYKQNpLsCehJOeetS6x4itF8SeGtVg1RrxrG2ghu3hEgkYoxMnLhdwYMR155zjvzl3 4d1HTsm/SK1RJ1glLyqxiY5wWRSWAIViDjkDIzkZfJplnqXigaboM7NbTSiK3lvHCFuACScDgnOB jJGBjPFAHRzaxZ/8JjNqkfiXzRJHcsjTwStHDksYEAKkttYo+NoVSvGSKqaZ4qSXU4NS1B4oL61+ zA3CIxe4hj3eYpPJMrjYNxwCFIJAJB5/W9KfRdWuLF5opfKkZVeN1bIDEZIUnaePunkd6istNub/ AHmARBI8bpJpkiQE9BucgZODgZycH0NAFjxFNBc+JNSubWdZ4J7mSaORVYAhmLDhgDkZweOo79ad aXsOkW8V1YXMp1SSNgXClBagllO05+Z2XvwFDcZbBWxB4S1Wdry3+zsl9a3MVu9u+1RmQOQS5IAG VUDsxdcHkZz10m9aG4k8pQ1uzLLC0qiZSvLfuyd5AGSSBgYOehwAW4LiL/hELy0kv1WU3kU0Vqwc khVdWYfLtBO9e4JCH0GdvXvEFlqVgIheNMzaRbiQOrfNerIgdzkcv5YI39xxntXPv4f1NLKO8MCm CSLzo2WZGLoM7ioBySuDuA5UctinXHhrV7TAmtNsh2DyhIjSBnxsUoDuDnOQpG4gMcYU4ANjVdbT /hF/DSWWssdT09Zlk8syrJGHI2gMVAwqjacH2GRW9ceJdDvfHNnrN1rEs2nvvU2Utu7Jbxtb7WDA 8ZZ+CFDA9Sa4fUNA1DS4ZJbpIAsUohkEd1FIUc7sKwRiQflbr6Gq+mafNqup21hA0Sy3EgjVpXCq CfUn+XU9ACeKAOiHim5vbz/Tb+BL63imitdWVJAcu4JLEDdt2GRUAT5d44HUN8Ua7pt/4ou9TgtL W/hu44nVbjzkaEhApU7WUZyOeWHTB61Rl8MTx+JbjRVmWaWNZ2jaArIZPLVyBtVjtZtmNp5GelNt PDN/L4gttIuIZUluI/NjMPlyb02FgyEuqMCB13evcYoAu+HL3TINZi1SS6s9OaK5iLWr2jzRmIEF jGx8xg+V74xnhuwx76S0vtS1S6SaWKNpHlt0lBd5MyDCs2Tg7SSSSc7fU0/TfD+p6tD51nArReas CvJMkQaRuQilyNzewyenrWfLFJBM8M0bRyoxV0cYKkcEEHoaAOwuvEthcaRZTAKLyDT/AOzmt2iJ fiOSMOsnQIRMSVxncijodw5gW9oNJ+0fbf8ATfP2fZPKP+r258zf068Y696sN4f1KOxju3gVUki8 9EaZBK0fPziPO8rgE5xjAJ6c1O/hbWI5ooXtUE8jRr5HnxmRC+Au9N25ASyjLAAFgD1oEzYv5dGu fD/hzS31uI/Y3nW4lgt5W2CRtysAyrkDGDznngGlv9ZsV8N21nJJY6jdJfNOY7aB7e38sxhfnVVi y2eQQCcDrg4NJ/AviWOeOF9MZXkl8lA0qAM2wvwd2CNoPPTII68VHP4O1+1aJbjTmhErSKrSSIq5 QEtlicKMKxBJAIGRkVOoncfp+s2cdyynTLG1jlRUYgSyRkiWOQeYrOxK5jwQvOGJwxABl17UbHV9 X023inZLKzt4bE3bRnLIpwZdnUDkkLnOB6nAov4d1ON4g0MZEyGSKRbiNo3VWwxDhtp29W5+UAk4 AJqaHwvqb3r2zrbQyLB9oBmuo1WSPaXDIc4cYU8jIHcjk1LuRqTaJHpqWpuZtXisr/z1RPMgkfyY 8ZaRNoIMmeFzjGCcg7SpZtpdjBq8yXrPfQsi6bIIyA/z4aTGDtYKMjJBGcjkAjEljaKV42KlkYqS jBhkehHBHuOKbU3JND+0Lb7J5P8AZFlv2bfP3zb84xux5m3Pfpj2rrJfEejfZooriT7beR/ZTd3n 2YH7fGkgZovmwRgbfmbBfy8Htngs10F74YkttJXU4p2ntTYR3RmWL5BI0ixmHdkjcuST346CmrjV zqbrxZYyXzPLqNpNbHUoJ4lWK5keNFl3FsyHbGQvGEU5zjAFYWv63p9/4fubaO482aPV5Hs1KN+7 tCuFCEjCrkL8vHQccVjjw/dpNZtdyQRWVxcLbm8jnjmjjORncUYgEA5wSOAajvdGbStkeqPLa3Xn lJLYwMXEXH71DwrjIYfeHQckHIrUrUzCaaTW94l8PRaHq40u1vZb69EgjeIWxQ5KoybcM27O8jHX K9ORWbrWm/2Pf/YmuYppUjUzCM58qQj5oyehKnI4JH0OQHYaRRJphNWrCxk1CWZE/wCWUEk7YK5I RS3AZhnpzjJxkgHGKtaVoF3qlrc3ir5dnbxyFpmIALrE0gRQSCxIXnGcA5PFOxSRlUVpv4f1OOyj u3gVUki89EaZBK0fPziPO8rgE5xjAJ6c1LN4X1aBWaWGBFVUfLXcWCjlQrj5uUJdRvHyg554OGMx 6K29d8NXOg29jLPcWsv2qBZtsUyMV3FsAAHLDAHzAbcnAJ6ku/Ddzbatpem7sTahHEyNIU2ZkbaC GRnBTPfgn0oAxKK273w/9k8RJo4nlkuDdm2ZDBsf7+FZQzBSGUgjLDvnAwxhHh6/lvtRt4IvksJC k8s8kcSx/NtG5i20EntuPfGcZoAyqK24/COuSXE0AscSwzrbyo8qKUdhlc5bgN0VujEgAkkVRttM knmvIZp4LOW1ieR0un8ssV4Magjl/RfY0AUqKK6W48G3FvrGsaYbuIzaZY/bHbadr4VGZR34DnBx zgcDPABzVKDWvqHhbW9LtZLm9sGiijYLJ86kplmUEqCSFJUgMRg9icijUfDt3Y3tlZhGea5tluBu Me3Bzlgyuy7AFJ3EjgEkAUAZWadVy60W/sXtUuo4ojdcw7p48Mu7buzuwEJ6McKRyCRzU6+H76W+ 1G2tYt5sXKzeZIiMihtu4jcRgH7xBKr1JxzSsTYzM04HNaB0HUlvrmyeBY7u3YK8EkyLIxPQIpOX J7bc5yMdRl+iaN/bH9o/6R5P2KxlvPubt+zHy9RjOevP0qbCsZlLnjJpoNbE3hjV4IppHtVKwxCd gk0bkxHH7xQGJZOR8wyOvPBwWFYyqXJrSfw9qi/ZisEUy3M4t4nguI5UMpxhCysQp5HUj9Klu/Ce u2AhN1p0kSyu8aszLtBXO7JzhRgE5OBgE5wM0rCszJBzS1Zv9KvNMSGS5iURzqWikikWRHAODhlJ BIPUZyKguYPs13NB5scvlOyeZE25HwcZU9wexpWFYTNGansLX7bO8W/ZsgmmzjP+rjZ8fjtx+NWd K0mXVIr6RN220t2nYJsJwPUM6nb6kbiOOORSsKxn5pc5rSHh7UzaJdeTF5LwNcI32iP50UEttG75 ioU5UcjuBkUXXh3VbL7f9otdn9n+X9p/eKfL8z7nQ85z2z70WCxm0Vof2HqQhlmaFUhjlSEyySoi Fn5XaxOGBBDZGRtIbpzWpc+CNUtLixgkn08veXD28ZW5GAyttJOe3HbJ6AgMQKLMXKzmsilro4/B GpyalYWAn0/zr23+0xkXQKhcZwcZJP8Augg8kEgEjH1HTZtKuEguHgZ3iSUGGVZFwygjkHrz/UZB BI0xuLRUoooFIkdTh0ptKhyoPqM1LJHCnU2lBpCYtFFFIQvXilptLmgQtFIDS0hCg4p1MpwNDELR RRSAO9OptOzmkJhRRRQIKcKRadSEzEn/AOPiX/fP86jqSf8A4+Jf98/zqOu5bHpR2QUUUUxhRRRQ AV0HhPXbTQb2aa7tPPV/K2kZ3Lsmjc4+YDopPOfmVe27PP10fhLRLLWW1Y3s6xi00+WeMMWA3AYD naD8q5yQOSccEZFAG1pHjjSrDxFf6hLpjCK41A3SNGGMgXy5V5BkxuzID6fM/ouKuh+L9M0zRrqz m0pd8sV2gEe8qfNEe1TmTO35CDjnCrg5LE5Og6ZFeTayhhgvFtdPnmSQzPEFK4xIuFyx54VgAc84 qK30i0m8N3OpPqUCTxSxoISJM8rIdpwhG47BjBxjOSOKANtfF9nZ+ErTTLKOeS7SzuLSUzRhYwJ3 VmIIYkkbdoyBnOeMbTX8QeI9P1W71TUbdbpbnU4IoZIJI1CQ7TGxIcMS/MWPur97PbBx4oYH8MXU 5gX7RDeQoswZslHSUlSM4xmMHpnrzUureHZtFaSG6vLP7ZCqNNaK7eZGGAPUqFYjcMhWY9+gJABo eKfElnrd5q81tHOi3lzazRiRQCBHE6NnBPOWGPb0rC0u9/s3VrK+8vzPs06TbN2N21gcZ7dKl0P+ zP7btP7Z83+zvM/feV1x26c4zjOOcZxziugjsNLvtP8AO/sny5F+17bi0aQ2sipbyMuS7llkDpuC nblTkjBFAGP4jvNL1DVJbzTRebriWWaZrkKoyzkhVVc4AB6ljk9hUWn3Vn/Z11p9688UU0sUwlgi EhBQOu3aWXg+YTnPG3oc8bUlho9j4V0LUprVWubqK7J8x5PLldJFChwpBA27gNuPm254zVhdP0s3 twg0aKAmxglxfyyLAkpmSJnjdJMtCQ5IYlumQccEAz7DWNH0y4VrVL7yV1W2ulSUIzeTEHzlgQN5 Ln5cYGPvGtafxpp9wjwp9utIZZ783CwopFwlwrbHcbwC6EqMHPA4btXI6tPYXOpSTaZaNaWjKm2B nLlDtG4biSSN27B9Ow6VrPYWTfDqPUxaql8uqfZTMrtl08svyCcZyewHAHvkAlXxJZjQ9GsvLn82 xtr+GQ7RgmdWCY56DIz09s1t61rlo0g8RxspnuNQsLtrIzxEqIonBAKOzYzjllUjI49OMjtEPh24 vMRNIl3FFnewdAUkP3cbSG29c5Gzpg1pv4Mvhc20CXVnI9wsMsW1nAMMrKiy8qMLvcKR97PO3HNA DvE2u2+sfaXj1TWLjzbszRW10AsMKHdwB5jZIyoGAOM+tYul3v8AZurWV95fmfZp0m2bsbtrA4z2 6VpTeFrm2tp7m6vbOCCDUH06SRjIQJFUsThUJ2nGAcZyeg61V1TQrzRVVdRC29yzHFq2fMKAkb8g bduVIHOT1AwQaANW81fQ21291K1Go7rmK8LeaiYMkwdVUKG+VVD8tliSPuirtp4w0+DxR4d1Nobo w6bpqWkyhV3M4R1yvzYIyw6kfSuf8PR20uoyrdWkV1GLS4kCSM6gMkTOD8jA9VA69Ce+CL2oWGn6 heSDT/sdgllEFvGEsssLMHZTLG2GYoSYwB1+ccEAtQAaDqOh6e1wl8t5PA8uDGYEeOeLDDlCwMcg zkOrHGSPXPPyGNpnMSMkRYlFdtxA7AnAyffA+ldH/wAImLSfWLXVNRtrW6sIwwU+Yw5eMByVQ5Qi TgD5skZAGaq23hm4m0y1vpb2xtVu/N+ypcylDN5f3sNjavPA3MuTQBZ1fVtL1iy06SUXkd1Zaelm IVRfLcpuAfzN2QOQSNnbGedw1p/FumSeJpNdVLzzLprbzrcxriIRvE7FX3fOf3WACq/ezkYwefl8 PzQaVa6g95Z+TdRNJACzKZCpIdRlQAy47kA5AUseKnvPC9xZKry3tmUaKO4DKZMeQ5VRL93O3cwU j72f4cc1JJ0Vh46sIddF7LbXIhS6aVdgUsyE3TcjIAOblRjJ+6ee1QWXjK0j0iG1kW7t50lz5sAD FALL7OGX5lO7dhscYHesDV/D02htNFdXlo11DKI5LaNmLgEEq3KgFSADwSRuAIBOKv6r4fQarpFj b/ZLc3VhHMJlmlkSYkMd+Cm4M23AQKeSAOTRdiuxJ9dt2uIHN/q9/stbmJpL1wfnkjZF2JubaOVy dxz6DHL73xFaXN9pUqRziO20kafMSoyCY3RmUZ5A35AJGcY461nzaDLb6hNaSXcCC3iEtxK8cyCE EgDcrIHySydFP3gemcUtQtBYTrGLq2uVeNZFltn3KQR34BUjoQwBHpS1J1EvWtDey/YFnW13fuhO wZ8erYAGe+B06c9asW+u6tZwLBa6pewQpnbHFcOqjJycAHHU1oaC2h/YsXlo15qDXkSi3IkzJAeG EWwj95k/xHHTHOaZd+G2iiF01zFZW9xPNHZw3xZZnCNtw2FKockA7ioyD0HNKwWZgk10tjrumWnh W20+aKe4uItTW/eJ4l8qQABTGWLE4K852+2O9Z8/h+aDSrbUGvLPyrqJpIAXYGQqSHUZUAMuO5AO QFLHipLnwpqNvrd5pG6CW7tVjJCOcOZGjVQpIHOZV64HWmkUkbuqeLtK1W3e0u31K6tjqq3wEqDI iJIaAfvPlAU8EHkkjC9ax7zVtMbw7Z6LFJeTrFeNObqaBVaGMqAURd7ZBOWI3KMgfURyeFpftzWM Wq6ZNdJdpaSQrI6srs2zOHQbgG67d2OvSqGpaNJpsO6S8s5JFlaCaCOX95DIvUMpAyOo3LuXIPPT NFG9q3iHR9S8W32ro99AJ4EEEn2dGkt5hsXcF8wA/KrYbIILAgZUGub1MaWJoRpTXjxiJfNa6VVJ k5yVCk4XpgEk9eam8O2trfeJNNtL3cbea5jjcKMlgWAx1GAehIOQDnnGK1bTTNIPxFl0u9ScWA1B 7eKKHkt+82qpYkEL6kZOB6nIYzK0K6s7O/klvXnSJraaEGCIOcyRsnQsvA3E9e2O+RsW3iPTzoOl 2Vyt1HNYR3cH7uNXWRLgFS2SwIKhiduDuwBlc5HKV0didBOladD9ja61Ca5aK7T94ZghICmAKQhO M8Pk7j0IoAtaj4rjvtGsrdL7VbZrfT1s3s4WxDKVBXeW3dCCCV2HONue4i1XxJZ31nHDFHOGXRIN OJZRjzElRyev3cKcHrntVi7stFh8I6HdS2MUE1/Bd+ZcI8pbzIuI8DcVG5sBuMcnG3qKl5Hpq6Pc PJo8WnO8EZsPNlme4mO5NznkJsK7znaoJOFzg4AG63rOl6xpWnkxXi6jaWcNmqgqIQELZcnksSCP lwuOeTVrUPEWly654avbb7Y0WlRW8MwkhVCwibO5cOeTk8HGMDk545KigDdk1ezHjoa1EJ2tP7QF 2VZAsmN4cjG4jI5A559q1oPFlnb3niUQXGo2sWrSpNFdQIBNCQ5crtDjg7mGQ3bpzgcpZzwW8xkn tFugF+WN3ZUz6ttIJGM8AjnHOAQdXxTY2Vldae9lC0C3WnwXMkXzbFd1yQhbJK9O55yM8YABof8A CT2cOm+II7e41V7u/ltzbTXDh5EELAhmkBB3HnAA4wOT1rn7a9gE15NqNq19LPE4R3nZSkrciUkf eI54PXNdB4c0GwutGivr2Np2vNUi0uNQ5QQbgGaUY+82DgA8A8kN0rndUsv7N1a9sfM8z7NO8O/b jdtYjOO3SgCpXcXvi/S59S1vV4o7z7Xqmnm0Ns0aiOIsqKT5m4lgNpI+QZ9qz9N0zSLnwFrd+Unk 1S0aD5n+WOMPJtAXB+YkA5LDuMDjJfp0ei6xb6vGuj/ZUtNNa4hlSWWWYyKUGW52kEk5wgAB7YzQ BX8W+IY9Z12+vNNnvI7S+WPzoJPkBKAAAhWIYDGQT0J6dzdvte02+1TRvshuikOm/wBlymdEiwCj R+YDvI/5aE4JA+X73ORzWl2X9patZWPmeX9pnSHftzt3MBnHfrW7rOmWE/hiLXrK0WwIvDaPbRzm ZGBTzEbcSSGCkKw9R0U5FAD/ABncafPqej20F550NpptvbTSxBXKlc5xhtrEAjgMRnjNLD4j0+DX vEt6q3Lw6paXMUOY1DK8pDfMNxGAcjIJ9cdqwNLeBLp2n05r8CJysIkZQCFJ3Nt5KqASQCvTqBmt u7uPD0V1NHpmjLqLvbRNu82dYYpFUmYouQ7Jjn5iCME9KAN+5+IGnyajeXdrHfWzvfQXatGFDXCR xBDBIQ3CkgnPzfePy+vOaBq2n6R/be9rmT7VYy2dviJRnf0Z/m+XoOBu6nnjml4kOk/2/df2F/yD fk8n7/8AdG77/wA33s9ayx+tJiHV2n/CX2H/ADxuf+Rd/sr7q/63+9977vv19q4vIFFIR39142sL l0Ek2pTpFrEepxGWNSVQE5hA3nAUcgjqSRhetVbbxnBFosNr5dzBcrOp82Ig7EFn9m3qcg7gfnA4 9Nw61xYOKWlcV2a+t6lHfrapHqGq3rRK2+W/cYyT0RMttGAMnccnsMVnXUsMt1NJBD5ELOzRxbi2 xSeFyeTgcZqGg9DQSaei3Npa3ssl686RtbTQgwxBzmSNk6Fl4G4nr2x3yLfh3VrTSYtXNwJ2lu7C S0iWNARl+7EkYAwOgPU+nOFmlpBsdKPEVp/YekWXlz+ZZ21/DIdowTOrBMc9BkZ/TNaOq+LdM1KL XCI7uOTV4oCymNSIZItuFB3fMrc/NgEccHPHE0UXC51WreJLLV9KsbSW3k36XsjtMj5LiPaqsJQG ypOwEbSeuO26tLUfGmmXd9o08enNtsr+a5k3A52vLuG3D8t/Ec8bgAPlyDwdKPrRdiuzurfxppkX iHQ9QOmssVhYC2k2BiyttI+TL4KjOBu5wzZycY5jWdQg1K8imgtkt0S2hiKLu6pGqnqx44wOegGe cms3PFKPek22DbYopwpAMCipIY6lXCgAdAMUlFIkcp3KCOhGaWmg4Ge3XpTs5pALmjNJRSFYdRSZ paQgpQaSigB2aKbSigVh4PrS0ynA0iRaM4oopAKDmlptOHSkJijrTqZTgaRLMWf/AI+Jf98/zqOp J/8Aj4l/3z/Oo67lselHZBRRRTGFFFFABWhpGsXGjXE0kCRSJcQPbzRSglZI2HIOCCOxyCDxWfRQ Bt2fia4stT1C9jsrEi+ge3ltxEUiWNsZChCpHAAznPfk81U03V5tMSaNILW4jlw2y5iEiq4VlVwD wSA7YByOckEgYz6KALsWpGLRrjTfssDLPKkxmbf5ilQQMYbbjDN1B+8fQYt6t4im1ppJrqzs/tky os12qN5kgUAdCxVSdoyVVT26Eg49dne+F9FW50izgu7yC61SK3uIvOCyKiysibOANzDMjbvlGFAx k5ABzOkardaJqtvqVmVE8DZXeuQQQQQR6EEj154xWnF4snt7WOzt9OsYbJZJZHtl80rKzxGIlizl h8pIGCOtbdj4R0fVfEE+l25vrf7NqX2SSWSdJPMQJMxIARdpPk46nG7ocVDoui6Pcpo2sR290IX1 lLCW1nmSUPlQwbOwDGeCpByO4oAx5fFNzLBb2n2KzXT4InhFkok8tgziQ5YvvzuVTww+6OxIL5fF k9w8n2jTrGaJrSKySFvNCxQowYKpVwx+YAkkk8dccVF4va3bxbqv2eKWPF3MJPMkD7n8xskYUYHt zj1NM8MSNBrYuEC+bBbXM0RZQwV0gdlbB4yGAI9xQBU1bU5NY1KS9lgggZ1RRFbptjQKoUBRk4GF Fa2keMLnRtOt7KHTdOmSC5+1o06SMfNwVDcOBkDgccYB681a8OrHrGnT2eqXN5JFc6vaD5H5Mkgm VmJbOD3JwSdoHGcjQtvD8fhuO7eW6nlnvItStoBCdkZjhjkVzIOSSWCkKOBjOT0oA4+LUjFo1xpv 2WBlnlSYzNv8xSoIGMNtxhm6g/ePoMaD+LdSMltKiwRy29nDZxOqEkLFIsitySC25BntjtXTahbW sWmaXpauqW0miG+NoI8+bMYJnaYv1DK0UY69GIHy7geR0HTGvdW0w3FrK+nzX0VtJJtYIxLDKbh3 wemc0AXp/GFzcMwl03Tmga8+3vbskhjefDAscvkg7hlc4+Ucdc0dV8Q32t28aaj5VxcRyMy3TLiX axJKZHBTJJAI4zgYHFdH4uumubLVIGuVmSy1RYoIhCEFov79PKQ4+6UhiPHGffJNLxP/AKX4X8Na tP8AvNQuo547ic/elEbhU3epA4z1PcmgDB0vUjpd084tYLktE8OyffgB1Kt91lOdpI69/XBFu98R TXkbRLZ2dtCbNbIRwIwCosolzyxO4sOSc5ye/NY9FAG/P4qvLrxBc6xcW1nK90qLNbvGTC4XaVBG c4zGh684weCRRH4quhZQ209jp9yLdpmt2mt8iEy8ttQEIRnkBlIHbjArCo6c0hGve65LfaJp+lva W0cVju8qSPfv+bls5Yg5PPT6YHFbviTXbJrXSoNPks7wR6fDaXThJlLiNgxQ7to2FgpyoDcHkDg8 dRSEaeua1N4g1R9RuYIIp5FUP5IYBiBgHDE84AHHHH1q3e+Jnv7qymn0vTytnbG1SLbIUaPaQAcu Tlckggg55zwKwaM0hG9ceKLi5MKSWdobWK2+y/Z8OQ0e8OAXLeZgMFIG7AxgcEg5uoX32+dZBa21 siIsaxW0e1QAO/UsT1JYkn1qnRQBt6T4mutJtEtVt7a5hjulvIlnDfu5lGAwKspPGODkcdKWbxVe XVrHFf21nePDLLNDLNGcxtI25vlUhWG7nDKR26cVhE00mmM1r/Xpb/RbDS2tLaOKx3eTJHv3ndy2 csQcnnp24wOKsv4x1NokIW2F6PKD3/lZnlEbbkDE5BwQuTjJ2LknFc/mkqhnQP4slN8b6LSdMhun u0u5JljdmZ1bfjLudoJ67duemcVlanftqmp3N/JDFFJcSGR0i3bdx5JG4k8nJ69/SqlFAy3pl+2l 6nbX8cMUslvIJESXdt3DkE7SDwcHr29K0P8AhIz/AMJF/bf9l2P2nzPO25l2ebv3+ZjzM5z2zt9q xKKAJbmZJ7hpI7eK3RsYiiLFV47biT78mta28T3Vvp9laG2tZjp8jyWU0gffbsxDZG1grfMAfmDf lxWJRQBq3+uy3+iafpT2lrHFYbvJkj37zu5bOWIOTz07cYHFWNZ8Tvrc13cXOlact3dKqvcosm8B duNoZyoOFAyBnGfU1hUUAFFFFAFizultZi720FyjLtaKcHBHXqpDA5A5BB7dCQbt7r9xf6nZXk9v alLKOKKG22ExCOPohBJLA85ySTk81lUUAauleIb7SLeSCHypImkWZEmXcIZlIKyp6OMY9COCCKr2 2pyQTXk00EF5LdRPG73SeYVLcmRSTw/o3uapUUAbFn4gey0K80mPT7NorxVE8reZ5jFSWQ/fwCpP GBg45zUo8UzRw3YttO061nu7b7LPcQRMpZDgN8m7y1LbecKOpxisKigB8UskEyTQyNHKjBkdDgqR yCCOhrS1XX7jVLeO1Fva2VmkjS/ZrRCkZkYnLkEkk44HOABgACsqigDdt/FM1tqt/fQ6dpyLfWxt ZbZImSEIQoO0KwIJ2+vc1Xm11pL2O5g0+xtNlo9p5dvGyqVZGQscsSXw55J7DOayqKAAU4HvTaKB WH5yOaUHNNpSaQh1GaQHNLUiHUU0UoNArC0uaSikIUmjdjqaSigBdwzjNLTc0vegVhwpwpop1SxD qKKKRIZpQaSlFAC0Dpz19qTNLSEKG9aUMD0NNoHFKwh9FNyacDkZoAUGlptFIVh1GaTNLSEKDS5p tGaBWHZp4OajBpaVhD6M0gPFLSEOFFNoyaQrGTP/AMfEn+8f51HT5v8AXyf7x/nTK7VsehHYKKKK YwooooAKKKKACiiigAq7qcWqQTQw6rHeRypEqxJdBgVjGQAobovXGOOtUq9Q13TdMmi8NQ38MqXt vaaf9sEzeWkdpuZHzyMHeyhs8jjHRqAPNxf3gmaYXc4laUTs4kOTIMkOT/eGTz15PrURlkMKwmRj ErFlQngE4BIHqcD8h6V3Vx4XgXxJHZxeG9RitG1dIDPNMxV4tz5Ea7VO0qpYtlsBRzzkv07SdFuP H7+HbnQvKUX02H8+VcwLE2xdpOeSFfdnnPHFAHCXF1cXbh7meWZxn5pHLHlix6+pYn6knvT7GK8m voV0+Od7sNuiFuCZMjnK45yMZ49K7G20DS5PCmlXTadPc311bXLCO3mKyzOlxGo2jDDIQuSAp4BP bIteGbWOz+JuiQJpTaYy2zF4ZLnzpGJic7n6bGIIyuBj0GaAOBhuri3x5E8sWJFlGxyuHXO1uO4y cHtk09r+8ZmZrucszSMxMhyS4w5Puw4PqOtRSxSQTPDNG0cqMVdHGCpHBBB6GtWGzj03SodWuTBJ POxFnasd2QCQZXXptDDAU/eOScqpDAFK5tdQtbS2+1QXUVtLmW381GVHyFyy54ORt5Ht7USaldya ZDprTYs4pGlWJVCguerNgZY44BOcDgcV2U9it38P/DrzQsbaK21FmnGQIXDbo8noCzKEweu4gc4I ffeGtItPFt00lp5WgN9l+yzvI4hffJDv2yE/N8hlPU4AJ7cAHCS3VxOiJNPLIifdV3JC/KF4z04V R9FA7UXH2jzR9p83zPLTHm5zs2jZ17bduPbGOK6PxB4eOlQ6zM+nz20SaosNm8iuA0R84kKT94fK nPPb1rV8baO1/wCNpb+e6gtNKu2Ty72RwVdVgVmZFBy4xwCOCxAzk0AcFRXRqlhrNzeWOk6ay7LY mwjOWmmkVkLs5HVjGsh2/dHRRk5O7PpXh3T4pVks7aW4tbSGK6ElxJtS78i4dlyrgEl441wCR1Aw aAOGgtbi68z7PBLL5UZkk8tC2xB1Y46AetNWKSRHZI2ZY13OVXO0ZAyfQZIH1Irtr3Q0sviLqum6 RZSmCGxn2xRhpCu60Prk8s4H1IFc7o1lNd6ZrsscE8iwWasTHu2g+dGfmxwRtDnB4+Un+HIVhWMk HFLkV1q6Jpx8PaDdG3/fXVpqUkzb2+ZokYxnGcDBA6de+at6/wCGba31S6Gk6Z5sL3dn9hBdzHNE 6Hfh93KGRogWzwWUZGaLBY4fIqW2t7i8uFt7W3lnmfO2OJCzHAycAc9BXUa/oltoaIs+jXTRRz4u rtHeBXkZWIig3hsxrtPzkMWx1AIzlWv2e8vYotD0y+a8O4mOS8EgljCMXTCIjcrkcNkjIHJosFjO vLK80+UQ3tpPbSsu4JNGUJHrg9uD+VR21tcXlwtvawSTzPnbHEhZmwMnAHJ4Brr/ABLaXFxo3hPT 0tfsl7J56DTeV8otNhTiQlxvPdmxxxjmofDttNDY+ItHjTZ4gaS3jtUQjzN0cwMgVxwMEKxwei56 KSCwWOQzTkikkWRkjZljXc5UZCjIGT6DJA+pFdF4v+z6v431R9I8qaE5l3RYCtsj3SMOgPKuc9+o zmm+HrDVLvRNdW0tLyaCW2RcQxsyvIs8RA44LBSx9QCaYzH/ALL1D+z/AO0PsN19i/5+PJby+u37 2MdePrVSutsbfVEsBc39qzWzafN5GqNK0gij8p1WENuMagtlNpG4FyBg4xn6fdeHU1Syd7C8jiW5 iaVri6SaMIHBbcgiBYbc8Z/PpQBlXFheWkME1zaTwxTruheSMqJBwcqT1HI6eoqKKKSeZIYY2kld gqIgyWJ4AAHU16R4ml8rQ/Eh1BdovbuN9OeSbzRckSM3mxjJ2gQNEmRxhQM54rkdN0G/TWrC2njn iF3bG5At3BkltyjFgmM/MyKyhT1JweDQBS/sHWPtf2T+yb77T5fm+T9nffszjdtxnGeM1XvLC806 YQ3tpPbSldwSeMoSOmcHtwfyrqLqx1afVdGsr6zutJ0e+n+zW1mJTlIjKpcYbLZ3ENlhyQCBgADM v9ds9XvvO1Cwn8iGJLezgtrkRiCJc4UsyMXPPU45z7AAGPbWtxe3C29rBLPM+dscSFmbAycAc9Aa iru/DOn6ZLb2mq2VrK1wuu2sJWWbzGtoSVO87Qo+Z8rlhjsOeaZDoFgnh3R7ttCvL27Es6agIrkw rEUkGFnyrCMbT6pgZJPcAHGR2txLbzXEcErww7fNkVCVjycDcegyemairuIzcw/B8yRWbJnVDmdf MB2GMqXznGDkxn+HBxjPNaaeEvD1gLuO6jlljiksWjv57jbFcRPIgmeMKANgDgE7mxkcg9QDzSrF 5YXmnTCG9tJ7aUruCTxlCR0zg9uD+Vdb4h8NW2naDqk8dhLFc2+stGhbflbMhhG2CfuFhgOepGM1 e1uKSw8T+BpryNraKKzslkeYbAhR8uCT0K5GfTPNAHn8sUkEzwzRtHKjFXRxgqRwQQehpldB4y02 7sfEt/PdQ+Ul1dzywhmG5k8xhu25yAexIGe2ar6Lp5u7DWrk2LXQtbPepAfEbmRBuO0jkJ5jc8fK SQQDQBj0V3umaNo/iGzt7vT9GaNjrcMM9tHPJMYrUoNxY9QpYMdxAxyM8U+88NaRLLo1xptp52nn UrmPUJoZHkjjgWcbd7AkIPLOc5HHOe9AHBCKQwtMI2MSsFZwOATkgE+pwfyPpTK7CztptQ+F08Fo nmy2+qm5mRSMxxC3J3t6D5SAe5GBzXP+To/2Td9uvvtPl58v7Emzfjpu83OM99v4dqAM+rFxYXlp DBNc2k8MU67oXkjKiQcHKk9RyOnqK3Wg0SC+sdEjlim8ydI9Q1TcNoBZdyw7uFRcf6wjLc9FOD0F 1YJPoPhm3v8ATpUSL+0UktELRtHMwMkMQLZIdvl2hsk5HDZ5APOqK7iLSNKRRaX2gz6fdS6fctZr c3bPNcT5Hl5RQu08OFBUB+nJqvqvh/TILhSssVvDp1jCNTCzbme8IbMKH5hvYjGRlVwxPTBAOPor qILC113wxdT2drANYhvFZ4438sRWmwKDhjgqGxuY5I6seSa1bvw/o91p1vqGk2bS2m3VGnljaRhG IwzW+/J+Q42EA4J4znNAHFpY3kli96lpO1pG215xGTGp44LYwDyPzFTSaPqkNkL2XTbxLQqGE7QM I8HGDuxjByMfWu51K1S+0jR449IW406HQXm+2R+bsgnEcjNyrCMNvVd2QSTwe1NstUvJrHXNa1zT YrQ3WlNbpfskiNdSOqqgVS21shckouBjPAoFY88GMc0uecVt6jFYWqR6PpUa396zbLi9QFxI5IxH CP7oIA343Mc4wpwdO8s9LTxDqOiHRfInSe4+zv50mWUQuIUCMTks4Rgc/MWAAwQKVhHJUV6DZeFt NGi2sF3YsmtS6ZfTfZ3d1laVXHk4jznO0PgY5weuKpXOm2mma7p1pbReVczaG4uISxL/AGmSCQbS pOQxJUBfcYHNKwWOLpc1PfWU+nXstncqqzwttkVXVwp7jKkjI7+h4rpLPSrWDwEmt3OkNcv/AGmq M5aRAbcAE4IOACwKbsHkkdcYQrHK5ortb/QrBNMsLqw0O8u1k0jz5rqK5IgSUI+8tlT8ykZ2hhyA MerL7w4i6bdalHpf2VorVGkhnZmtjux+9t5w+GPKkIxP3iBuxiiwWONpR0zXfr4X011VlsWKt4gS JSHfBsXOEYc/cY8B+56Gruk6F4Z1K30y4ksbaOOa9jt5DHcy7WLWnmFMlzg+accc8Adc5LCsebCl re1XT7O0TTornSrzSVdZGkkkmE9xIM4UmM7NoBBA4XI55xTLHSdMuJZbpr+ddKtVU3EskSpKzNnb HGm9ss2085wMEnpzNibGVbW095OsFtBJPM2dscaFmOBk4A56VHXaeHLS1ubSDWRbRm6h1e3WURFg lnbKA3mYB4HykF3znBJOcmks/DtrJoWiSroN9f37TSxXkcFw0YR1kACS5VtnBH9zjJz3ByhynGUV 29joOjT3Gkak0KtoS2G7UpvNYBbhVIYHncG3NHhR1zwCM1gTf2bp2lRRw+Xe6lcoJJJusdsjL9xR 0Z8Hkn7p4HzDIVhONjHpRXb2+haNbSXdxqcCw2d1f240tpZWUPbtIGcjnO3ymXLN0JxkNVvw/olr pWoeDZr2zNtd3L3X2gXOQS6/6r5W4ByVxgDnHtT5Q5Dhv7Ov/t/2H7Fc/bP+ffym8zpn7uM9OfpT Li2ntJ2guYJIJlxujlQqwyMjIPPSuvmhm0aLS5dO0nytS1K1uILzS9kjbo92AdhJkXIBOQR93jvl +twWOq3llPczraWOmabbw3qR53pL8xECKxyX6jnO3B3HIIpconE4j6jIowoHCgfQV0uk6bDr9pcN Lp0qDzkRLnTkMrW/GNrwhtxTaCd/3sg5LEmtvS/CWnatp+lXKW8Ika4kjukhu8qzCdf3Yy5ziHzG G05IUHJ4ycoKLexwAOABycd6UHNdvpvhXTm0xXNvc3k1zpD3ME4kIj+04OIVVRlnUKeNx6H5fR7+ GdOhsheSWTpanw6tyJ2dwn2s9Pmzjccj5ehz0pcgcjOGop9rlrqFdkb5cDbK+xG56McjA9TkfUV1 Q8OxW9xoqzWbLBfXyRyJdK8Vwg3AGPGQHTBB3qo5PO3pU2JSucrFHJNKkUSNJI7BVRRksT0AHc0s kbwyvFKjJIjFWRhgqR1BHY1u6voyWWjaDGtpJHq1z53nwsG8xv3m2P5D0yMgYHPvWjPoSX2v+J5b iG7lntbgyRWVudssweX7wyrHaAQeFP3hyO5yhynH1O1ldx2aXjW0y2sjbUmMZCMeeA3Qng/ka6eP QLW7utUtksLkW6Xu23vLMGd4o2OV3RbstGU+YOBnjq2cVp22miLw7Dp19Zx+XN4mEBVS4Tb91ihJ yR8rLk579+Q1EFBnn4NLmtrUrLRbbV763a6vYPKuZY1jjtVkVVDkABjKCeAOoqzHoiPoEupx22Gj tgZFnDCBsnHmRSh8Fx8uUb+IsAONonlI5DCeCeKCKd4ZEhmz5cjKQr4ODg98Go91b+rWhTwV4du0 ExV2uFkYuzIp38AAnCkgHpjOD1xXNlsUnEHEzpv9fJ/vH+dMp0nMrn/aNNrqWx2LYKKKKYwooooA K09B0SbxDqsem208EM8isU88sAxAyRlQecAnnjj6VmV0fgW/stK8W2moahdLb28CyFmZGYsShUAB QefmzzgYBoA5yiuz8L63baPCII7+zt5Y7wvLcyC5xLH8gXasRXeBtc7ZAB8wxjLVY0HxNp0Wq2Bv bny7AXd/5sHksI1t5UTanljcNpcH5ASAfzoA4lraZLSO6ZMQySPGjZHLKFLDHXgOv51EBk4FdTBf y6h4V/s681m8h+zs7LAd0gnUiIRoBkAKpRjz0yNoJJxT0hLSy1O0nuY/OhjmR5EKhtyg5IweDkZq JVEjOVSMTKjtHYAsCo/WnmBU79a9GfW1PiBLtvE/mWf9pLcLDtmPlxDfnqnHynbtXIO7ngVDL4jS XXDA9zbmwgmlls7lVljMKmIrHGNmGVPuAhQMkE5NRz36mbnfqeeNHjtU0GnNdWd7cJLGv2RFkaNt 25lLhMrgY4LLnJHXjNdvq+q2l3q1pf2WowWtybH7PNN5cuRKuRv3/wCsGVxtYFmIAVxgtVW61WOK 51O6h1j7TctZRQQyvBiRm8xG4baNxRU/1jBWJAIHAxSku5amu5x4sHbSZNQE0WyOdIHi+beCysyt 0xg7GHXPHSqlel3mvaNF4g1K9s5bZku76B4XNu+bciF1a42lcMVeTODkkg8A4aix8TabYaVBapqM EjRS3f2t7q3nc328na/lqwVyy8HzTx+HNpo0TR5pRXZ6j4hjj8GaRY29/BdXCxSQ30LxOSynd5QL FRkR7zgZwGwQDjItXXifSri4sXup2vIE0+0a5heNm8y6SaPzCQwwz+UrLuPUcZ7UxnBVp61ok2iT WqTTwTrdWyXUUkBbBRs4+8AQePSui8Y+IItVtLqOHU7W4ie+E0MUf2pnCYkwT5p2JgMBtQc57Baq +J9XgNxodxo+q75rPTY7R5LfzI2R0BBILKpwQ3GPfIHcA5yztVupij3MFsiruaWcnAHTooLE5I4A J79ASNi48Jz2aGa71GxgtjHDJFO3mssqyq5QqFQsP9W2dwHSmafqkt/qMc2s6os4tVMkCaoZp4Xf KjaQuSBjnpg7QDwa0JtQX7bcsPE9ndy3ixz3E15pxeIyjeNo3RsQVB+UhACCR8uACAYp0ZxbXN2L uBrGFhGt0FkEcspXcI0ymd2AeoAGOSMjOrpXgHWtYstOvbTyDb3zSKJCzYiKbvv4BwDtIBGRnAOM iujXxH4YJubK0a1tdP8A7ZS7Md1ZmSOWDywsgRdr7SSCRwuAwAI5AdpXjHR7C58OxW19Paadby3x ubciQhEdmMIcDO88j+9g0AeZVL9luPsn2vyJfs3meV52w7N+M7d3TOOcVb/tG1+yeT/Y1j5nl7PP 3z784xux5m3Pfpj2xxUX2j/iU/Zvtl1/r/M+y4/c/dxvzu+/2+7079qANW78Hanp/wDZQvntbRtS 3FBcS+X5IXGTITwvBBxye2M8UReE57i1jvLfUbGayaSWN7lfNCxMkRlIYMgY/KCRgHpWrcP4fvNH 8M6Vda7EIrKS4F3JBBMSFdt427kGegX2LA4IBp6alYi4tLiTXdOUW8U9rb2VvZzG2gR4HAc70JYl yN2QxOckkcAAyl8FapcQJPYNBfQy20lzE1uWzII3COqqyhtwLA4xyOmTxVHX/D194bu4LXUPKE0s Cz7Y23bASRtJ6ZBU9Mj3rqLjxXBZaVbLY6kv9qW1nIgmtIWihLtdRuFVNqgHYrbvlAbgEt0rF8X6 vBrM2jzQ3LXEsOlww3DuGz5o3FgS3U89ec0Ac5Wm+iTL4bj1wTwPbtc/ZTGpbzEfaW5BGMYGeCeo 98bHhjWBYaZNbprkWlyvdxSGRraRmCrnJVo87/QxyDbzkEEmtDTPEGmWWg21o97Exm10XNxH9k27 bUja+VClVyByqE/KxXkEigDhKK7W716wl0mwjh1DZaQ6UbWbS9sg33G1wJNoHln52V9xbPGfvACt bVPEHhO51K71hbiWaa6+ztLavbH54xJAWj5O0lRC5PQHzAMnFAHmlS2ttNe3cNrbpvmmkWONcgbm JwBk8dTXpdp4gs7nWLiGXWP7TN7rNrJp8WJW+yqJyxP7xQE+Uhflz1x0qvq3iCy0e+htzeNcXFjr zzILdWBtbQfKYFLBcA4xtXK4HXpQB5/f2cmnajc2UxVpbeV4XKHIJUkHGe3FV67PU9Wt5fE9xf2v iRpJLhZhHPJDMEtVZyURX/1ikKSflXAOF+ZWasTxLeR3uqiWPUGvwIkQzvFtJwOhbAMhAwN7KpOO gGKAMeiut8Oa9YWujRWN7I0DWeqRapGwQuJ9oCtEMfdbAyCeCeCV61vDVxqOkwXMDS6c8n9qXkkD JIouZNrSRujhdrmMhfmJBUoMdqAPNKfFFJPMkMMbSSuwVEQZLE8AADqa7CTWNLXwaNLtb5gJbMLJ FO85ZLgSiRsKMxBCFwpA3ZYZwCxGJp/ibVLO5sjLfXk9payxSC1a5by2EbBguOQB8oxxxQA/UvC9 9plpLcNLa3At5BFdpbSb2tXIBCycY6kjIyNwIzmsm2g+03CxebFEDkmSVsKoAySe/QdBknoASQK7 648T6VB9sNjfqsuqXkM3nLaMrWarMZi8oORI4ZyuFyCsY57Vn63rWkaotkNLmXS7KO5kdrB7beok JJWdgAVZSNqlTkoAQqsOCAZP/CJ3z3Okx2ssF1FqjMttPDv2kq218gqGAXqTtxjnnmqsehXk3iQ6 FEFe7FybYlclchiC3TO0YJJx0Ga6WXWtMkv/AAmsmoQFtOlaW7nggeO3A83eAkYQYbA5IQZJGScZ DLfxFZ6X4zvLiN7G80/UL5J5bgxS74IxP5mBwpBGFYgBgdq9elAHJX9nJp2o3NlMVaW3leFyhyCV JBxntxVetXxNc2174m1G6s3ie3mnaRGiDgMCc5w/Oeee2c44xWVQAUUUUAFFFFABRRRQAVbi1K5h SNYjEnlxyxhlhQMVkUqwZsZbgkDJOM8YqpRQAUUUUAOzRSdTRmkIWiiigQ7I9aXIplKBjk0rAOpR Sd6cKQmKKWm0oPFIli07Pam0oNIQ6ikyfY0tIQopc02igViSKRopUkUKWRgwDKGGR6g8EexqebUL u4sLSxmmL29pv8hNoGzcctyBk5PrVXNGaQai0UUUCCiiigAFWrzUbvUPs/2uYy/Z4Vt4vlA2xrnA 4Az16nmqtFADs1JbXE1peRXUEpSaFxIhwDhgcg4I9ahpc0hCgkdTmnA0zNLmiwh2RRkUzNGaVgsS bvem7qYXxUZcnpTURqJKXxnmoy5NMJ7k1GZT0AxVqJooDG++frSUUVqbBRRRQAUUUoBJwBQAlFSC FyeRinGMLS5kTzIjVCfapolVee9MpQcVL1E9S2snNbCaVM+iQ6kD8k1z9nUl4wgOCfmbflTx0KgY 5zzXPB8VuvrdkvgqPSEEzXf2/wC1uSgCKNhTAO7JPQ9B1PpznyXMvZ3Jb3RtQ06J5LuFYxHKInXz ULIxyRlQcgEKSCRgjkcEVam8PXMeq6fpysqzXsSOjSugT5iRwyswK8cHqew6Zj8SeKrLWLvVJbeK 4Vbu4t5Y/MUAgRxOjZwTzlhj2p+p+KbB9U0G8sFuZf7NhhidJ41j3+U2QQQzYzz9Pel7In2Ilz4e vE1yXSrby7mdXKoI5UJcBtvQMcHuVPIGSeATTLfw5eza1babNH5LTbH83KsgjcgBwwO1hyAMHk4A 5OKfPrWhS+ILi/jfU0S4S6MrNEhO6UOoCpuGAofJO45I6CoNI8R/Z/L+3SXM32eeCeDnf/qd+2Lk /Kp3nkZxj7pzwezSD2SRT1KxFhqd3Zb/ADPs8zxb8Y3bWIzjt0qOx0yXU72O1haJXfJLyvsRFAJZ mPYAAk/SpdZv7e+1u9u7YymG4maVRIoVhuOSCASOCcdecfhUrajax6MllbQstxK266nZuXwTtjUD +Doxz1bH90UtUxapheeGZYPDen6wkgkS68zzIwOYQr7QeuSCSOcAAkDuKq3XhfVbXaJLX96dmYEk V5V3Y27owSy5yo5A5YDqRXQLr9h/wj2m2u24+12UN3Ft2L5b+eCM7t2RgHP3eTxx1qzd+KLF9em1 yCK4a4uPI8y2dVVE8tonOJASW5ix90fez2wbUrGimkcrP4W1S2YrMLNSsvkvm+gxG+GO1jv+U/I3 XHTHWm+I/D0/hvUjZTzwTMFXLRSKSCVUkFc7lGWwCwGQMgVsa5e6bdxaibOS7aS+v1uys0CoEAEv GQ7ZP7wdh0qXWtc0nUNdXXF02ae7kYPLbXTKIF2xBVHy5LjeNxztBAxjnItTRopowoPDl7JNpUco WNtSYmGIuokKcYfazKMNkhckbipx2JibQ7ttRvbSELm0laOQzyxxbMEjLZbAGRjOSMlRnLDNqy1N 28WWutatPPMyXKXErqoZ2KkEAAkADgD0A6DjFLqGq2kup+IZ4BOYtTU+VvQKVLTRykMAx4G1hkE5 44GeKTTKTTKg0O9TUruwuYWhuLSKSWWNioYBFLcAsNw6H5cnbkgHFEOhXc+jS6oktmII2ClWuo1k 5DH7pOc/IcA8nsDzja1HxFpep+NtQ1h/tkNpcWzwoFhV5AWg8rkbwMDJPXsB34x9LvdPjsbqy1KO 6aGWRJ1+zMoYuiyKqktwoJkyWwcbcYOchjBvDWrrpi6l9k3WbRiRZUkRgwO7OMHJICMWA5UAkgCi fQLu00FdVul8lJJIhDGxG50cSHfjOVH7vjI+bOR0q9qWt2c3hfRNPspbxLuwWdZWaMIriY5YAhyc D7vI5BPTpVrxD4os9VnvL20a8t7u6ltrnG0AQyQoUAVw2SDvZt2AQVAxzlQDlYhGZkEzMkRYb2Rd xA7kAkZPtkfWtW+8OXmm6HDqN6rWssly0AtbiMxyEBQ29Qeq8kE9jjrnhi61cX9xBFruoaneaeJA 0kYuSWHBG5d+RkZ/HpkZzVu91bT4/CSaFYtdT5vjePNPEsWP3ewKFDNnuc5H0NAGVZadcagLj7Mu 94Y1fywCWfMiRgKAOTlxxVjWtGk0aa1DSrLFd2yXcDAYPlvnbuHZuOQCQPU1Yj1HT9P1a6GmNfJp 08axrLIVFxFhkfeNpAyHQHHGRxkE5DtZ1mz1nWbHfFPHpdnFFaIFIMxgQ9T/AA7yCT6Dgc9SAUtK 0xNSNyrXkUDwwSTLGyMzS7I2chcDA+7zkjrxnpRp2kXGqbRapKdsmLiVoz5Nuhxh3cZ2j7xOQMBc 884l0G50+zuZpr6a6TMEsKCCBZM+ZG6EnLrjG4Hvn2qxpt1oen3NpfK+om7s7nzlUxIY7gKwZM/M DETjB+/6jPSgDCroNW8KXGkPfwzTbprGNHlKxnymyyAhHPJIEsJwQPvN6Ddn/wBvax9k+yf2tffZ vL8ryftD7NmMbducYxxit3WvFVnq9rfXJS8XUb+KOKaHcPs0RVkLOnJJLCGIYIGOeWwKAOXtZPJu 4ZPOlh2SK3mxDLpg/eXkcjqOR9RWtqOn3AsbbVdXv5TdXu5kilzJM8YUeXIcn7hI25ODgZAYdIbO fR7WfR7h4rqWSKffqEcio0boHBAQd8rnIbv7VoTalosup2+p3VxqepXpvo5ro3NvGkbwj7yhN7ZP AAGQuOMDFAGfqWi/2bo+k3slxma/jeU2zJtaJA2Fbrkhhkg4HTvUWiaTNrerW9jEdgkkVXlOMRqW C7jkgdSABnkkAckVY1HxBeTeJNQ1Wxvby3a5lcq6ylJPLLZVSQegAUYzjgelaug+NJLKO+/tWS8v ZZWtpYpHl3kGCXzAh3HhWyRkZx1waAM9vCWpyaje21nGs0VteNZLNJIkIlkBICrvYZY4ztBJGRU2 n6Rq0vh3V3lvZ7HTrSWNJ4ZfMEbStIqncoHVeCeCRheOeNgeMdPKajbR3esWUNzqp1AT2iqsrI64 aIjeAuDjDZbOM4HSse312zi8O+IbRzePd6pLEyGTDhQkm/LyZBZjk5+XqM9+ADJTSbuTTZNQTyGg jXc4W4jMijcEyY924DcQOncVYu/DWr2P9ofaLTZ/Z3l/av3iHy/M+50POc9s471sXfiizuvDsWnI 15bqNPS0e1RQYfMSTzPOHzDLMVAPygjcxy2MGxrfjDT9St9eaGG6WbWI7YsjqoWB4ivAYNlwRu5w uMDg54AMK60FrfRdF1BblWbVGlURuAgjKOF5cnGDnOTgCjxH4en8N6kbKeeCZgq5aKRSQSqkgrnc oy2AWAyBkCrGratp954U0PTbdrr7Tp/m+YZIlVG8xtxwQxPBGOnPXjpT/Fus6Xr9++p20V5HfXDI ZkkKiOMLGq7VxkscgncdvGPl70Ac5RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUdaKKAHUU3 NOpCClBOabmngUMQoGKdTadnNSJhRRRSEKDSg5GabQDgAUCsOFLn0pKKQh/1opueKM0rCHUUm72p Qc0AFKDSUUAOoptApCsOopMiloEFFJmjNAC0Zpheml/SnYaQ8timl80w9M00yAdqpRLURxzjP86Y ZMcAUwsT1NJVJFqIpJJyaSiiqKCiiigAooooAKtw48teOTnn8aqVchbECj6/zqJ7GdTYeaibmpDk 0wioRmiI0xs1MVppWrTNEyA570VKVBFMK1Vy0xtGaMUUxjtxpweo6KVhWJw9PElVaUMaTiS4IurK PWniXmqQenB/eocCHTLwkUnHP5UpwapiSniUcc/rUOBm6didkB9qieEYzTxIKdvXHWlqhJtFR4DU LRsOx/KtL5WweD3FNaMH0q1U7lqq1uZuCO1FXHhGM1A0XGV5HtWikmaqaZFRSlSKSqLCiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AoooFADlFPpoz2p1SyWFKKSikIdRSCloEFAGABmiikAueKB0pOPWigQ6iiigQUUUoGaQBupQRTaK LAPopoNKTilYQtJkU0tmkJp2HYcXAppam5A7imGT0qkilEeT6nFNLgdBmo+tFVYrlFJJpKKKZQUU UUAFFFFABRRRQAUUUUAFXIf9StU6uQ/6pB6g/wA6iexnU2HVJFcTQHMM0kZznKMRzgjPHsT+ZptT 29ncXZYQRGQqMkD6E4HqcA8Dng+lTTU3JKG/kY3K7s0js7sWdjksTkk+tMIqee3e2neGUASIcMAw bB+oqLFJ3TaluNMjK00rUuBQRRcpMgK0wrVgqKYVqlItSICKSpioppSruUpEdFKVIpKZQUUUUAKC RSh6bRRYViUP71IJDValBqXETiXFkqQSVRDU9Wx0qHAzdMvBgaCAaqB+xqVZORzUOLRm4ND2iBqF 4BxU4kGelSDFJSaFzOJnNER0qMqR1rU8pTnCjnrxUbwA9RVqqaKt3M6irb2/HFQNERWikmaqaZHR SkEdaSqKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gApQcUlFADh1p2QKbSg0iR1FN5HNOzmkIKUGkopAOopAaWgQUUUUgCnDpTR90fSlHSgTFpR9aSkz QIWl/CmFqZvA6fpRYaiSE0haoi5ptVylKJIXHbmmFie9JRTsUkgooopjCiiigAooooAKKKKACiii gAooooAKKKKACrkH+pX8ap1cg/1K1E9jOpsSUUVPbRQylhNciAY+UlC2Tg9cdBx15PI464iMXJ2X +X5mBBRipJ1ijndYZDLGDhXK7d3viox9c0mrOwCYpMU6ikO42kIp2KMUx3IytNKVLSYp3GmQlaaU 9qnKimlBVKRakQFPSm4qxsppXNUpFKRBRUhTmmlfSncq42ilwRSUxhRmiigBwanBqjozSsKxOHI7 1KJeRyaqBiKcG96lxIcC8stTBwazg/viniQ9zWbgZSpl8qrDoDTGhVqgWY5+9U4lB6kVFmjPlkiJ 7cY6VA9vjtWhuzSlAaFUaGqrRkNGRTMEVqvbgjgmoXthjoa1VVM2jWTKFFWGt8dM1CUYdq0UkzRS TG0UUUygooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACnZptFAh1K KSjNIQ+ikHSlqRBSjpQAKNw7GgBaOKaXFNLmiwWZITSFqi3H1pKfKPlJDJTS5NNop2HZBk+tFFFM YUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVcgB8lap1et/wDUL+P86ipsZ1dh 3Sin0q7QW3IzDaQAH24bsTwcjrxWS1ZgR0VJL5bOTGjIvYM24j8cD+VM2mh6MBP4h6YoPbA+tLg5 owaAEooooAKTFLRQMbQRmnUmKYXG4pCtPIpKLjuRlaaVOfapqTFO5SkQFaYUqyVzTStUpFKRXKkU 2rBWmlapSLUiGinlKaVIp3HcSiiimMXNKGNNooCxIHqQSGq9KCRUuJLii4szdsZ96nWas0PinrJU OmZypXNVZBT8KRWYsxFWEuOR6Vk6bRhKk1sWGhB//VUL23HFSrMDUoYGovJEc0ombJbY/P0qBoCK 2SgPpUbwZHGK0jWNI131MYqR1pK0pLY9gOtVntselaqomdEaqZWop7RMtMxitLlp3CiiigYUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFLigBKUCjijNAh200vApmaSlYLEm4Um/0plFFgsO3G m0UUxhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV et/9Qv4/zqjV63/1C/j/ADrOpsZ1diWiipre4FuzEwQy7hgiUE8e3PHbnrx165zik3ZuxzkNFSTz Ged5SkabjnbGoVR7ACo6TsnoAUUUUgDFJtFLRQMTaKTaadRTuBHkhsbSPfignBA9TUlFFwuNIGOK Sn4pMUXAZijFKSAec/gCaMgjIz+NMYmKQinUYoC4wikK0/FJTuVciKU0rz0qcikIqkxqRXKUwoRV krTStUpFqRX2kUlTlaYVzTuUpEdFOKEUmD6VRVxKKKKAFyRThIRTKKLCsTrcEVOlz0qjQCRUOCZL ppmslyCOh61YWVTWIJCKmS4x3xWUqPYwlQ7Gv8rCmtCCOlU0u1z96rKXKnvWLhKJg4SiRvbccCq0 lsR/D+PFaQdW70pUMKaqNDjVlHcxHgZe1RFSOoraeAEdKrSW554raNW50Rr33M2irMkGAeO9QmMj sfyrZSTNlJMZRRjFFMoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArQtv8Aj3X8 f51n1oW3/Huv4/zrOpsZVvhJaaSoIBIGenNOqSKeaA5ileM5zlGI5wR/In8zWUbX1OciGCMg5FGK czM7s7sWZjkknJJpKT8guNxiinUUBcbRTqTAoHcSiiigAooooAKKKKACkIB60tFAxNvIpGwoyenf Jp1FO4EQdScBgT9aXcpONwz6ZqSkI9KdwG0mKdg0lAxtJin4pMUx3GEUhWpCKSi40yIrTStT4pCK rmGpFcqKYUNWStNK+1UpFqRXIIpKnK8U0oKdylIiopxT0pMGquVcSiiigAyRUiysOvNR0UrCaTLa XWOtWkvF4yayqASOlQ6aZnKjFm6twp4yKcWVs8isRZWHvViO6PrWLo22MJUGti+8asO1VpIwAacJ 8jrSlsikrolKUSlJGBUDLirkvQ9/aqrqa6Is6oMZRS0lWaBRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAVoW3/Hun4/zrPrRth/o6fj/Os6uxlW+Ekqa3tJ7tmWCMuVGSB+eB6ng8deD6VDRW UXG/vLT+vU5ySeGS3meGUAOhwwDA4P1FR0v4UmKTtfTYQUUUUhhRRRQAUUUUAJijFLRTATFJjFOo oC42inUhFA7iUUYNFABRRRQAUhUEYIBFLRQMbg9qTbtGAMCn0U7gMoIp20ce3vSEUXAbijFKTiim MbSYp+KTFMdxpFNKg1JikouNMiK00rU+Kbt9qq41IgKCmlKsFRjpSFKakUpFYqaSrBX2ppT2qlIp SIaKkKU0pTuVcbRSkEUlMY5GwRV1F8wYxnNVoYS7DjjIqee4WMGOLr0LVnLV2RjPV2RJM6RLjgt6 VQZyxpCSxySSfekqoxsXCHKFFFFUWFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABWja/8 eyfj/Os6tO0H+jJ07/zrKrsY1vhJKmt4oZWYTXAhGPlJUtk9s46D39xwecREGjPqKyjJJ3av/Xkc w+dYkmdYZDJGDgOV27vfFR0UUm7u6VgEIpKdRQO43tRSkZpMUAFFH40UDCiiigAooooAKKKKACkw KWigBMUYpaKYDaKdSYoHcSigjFFABRRRQAhAIwaCvI5IpaKYxpGB3NJ060+ii4DKKVlY9CuPQjNB BzTAbijFKaXGBkmgdxlFOoxTC4zFIVp+KMUXHcj2UhSpKMZp3HchKU5ItxH+cVIE3EAetRzzBQ0U eDnq1NNvRDTb0Qk0wUGOI5HdvWq1FFaJWNkrBRRRTGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAVp2n/Hqn4/zrMrTtP8Aj1T8f51lW+Exr/CT0AqN25C3ynbhtuG7HocjrxRRWCdn c5Qk2GT92rIp6KzbiPxwP5U3Bp1FDld3AZRTyM03BouMSijFFABRRRigBMUhGKdRTHcbRS4oxigL iUUppKBhRRRQAUUUUAFFFFABRRRQAmKMUtFMLjaKcRTcUDCiiigAooooACMikI4paKBjCCO2eaPq Pyp9FO4DD046+9IN3cAfQ0/AowKLhcbQFYkAAc+ppW9Mdx1+tE0gt4yP+WhHHtT32HvoiO4lEStE nLHq2elUqUkk5PWkraMbI6Ix5UFFFFUUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFadp/wAeqfj/ADrMrTtP+PVPx/nWVb4TGv8ACT1NbziBmJhil3DBEgJ4/Pjtz1469cw0 hZVIBYAnpk9axhJxd47nKSzSmeZ5CiJuOdqKFUewFR0gIYZBBHqKWlJttt7gFFFFIApCMmlooAZi lzTqTbTuA2ilxgUlAwooooAKTFLRTAQ0lOpMUDEooooGFFFFABRRRQAUUUUAFFFFAAaaRinUhpgh KKKMUDCiiigAooooACQOtJnAyeKUgHrSggcsQAO5oAR2EUZkPXsKzncyOWbqaluZjK+B90dKgreE bK7OinCyu9woooqzQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACt S0/49E/H+dZdalp/x6J+P86yrfCY1/hJqkinlhOYpXjOc5ViOeR/U/nUdTW9rPdMywRlyBk4/PA9 TweOvB9KypqbklC9/Lc5SJmZ3LMxZmOSSckmkqSaF7eZ4pAA6HDAMDg/UVHUyTTaluAUUUUgCiii gAooooAOtNIp1FADKKfimHrTGL2pKKKACiiigAoxRRQAh6UlOptMaCiiigYUUUUAFFFFABRRRQAU UUUAJikp1FMLjaKMUuKBgBUN3LtTyh1PWpJX8qIsOo6VnEliSepq4Ru7mlON3cSiiitzoCiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK1LT/j0T8f51l1p2n/Hq n4/zrKt8JjX+EnooornOUKKKKACiiigAooooAKKKKACiiigAoxRRQA0jBpKdikPWmMSlNJRQAUUp xSUAFGKKKAG0U6mmmMXikoooAKKCMUUDCiiigAooooAKKKKACgetFR3LlISQcE8Cmld2BK7sVbmX e5AJ2jjGagoorpSsrHYlZWCiiimMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKK1bvw9fWl3pdr+6lm1KCKe3WNu0hwqknABz+HvQBlU VLcwpBcNHHcRXCLjEsQYK3HbcAfbkVb0jR7jWbiaOB4o0t4HuJpZSQscajknAJPYYAJ5oAz6Ku6R pV1req2+m2YUzzthd7YAABJJPoACfXjjNUqACiiigAooooAKKKKACiitPTNBv9XstRvLSNWh0+Lz pyzgHHPT1OAx+invgEAzKK07XRJrzQr/AFaKeDyrFkE0TFhJhyFUjjBGc988H2yPoky+G49cE8D2 7XP2UxqW8xH2luQRjGBngnqPfABmUUUUAFFFFAH/2Q== --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 4.jpg" Content-Description: Picture (Enhanced Metafile) 4.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 4.jpg"; creation-date="Thu, 08 Nov 2012 06:14:06 GMT"; modification-date="Thu, 08 Nov 2012 06:14:06 GMT" Content-ID: <725e34a5-5804-4b29-93e0-aeba3992a382> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAGcAtgDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwC1f+JN ev7qY3Or3yCBJJXS23QxxBVDPgoAWX03Fjxwc5qg+t6tGQDeeJ29cJejt7io5cpB4ijE9xJu027Z QYht2+W3ooGcdiTXPT+NLC9tD5GqJYyQxgutxAc3D4JKxhI2CcjHzMBznjBFdOJqOlJKEUzkpxcl eTZ0cHiG/uCAmra3k563NwOQSCDkjaQQRz6Vc/tHU/8AoM6r/wCB83/xVcz4auDcWEMxkc7hK+Av ynM0hyfQ89M9z1xxvdK7aMYzpqUomFZyjOyZY/tHU/8AoMar/wCB83/xVH9o6n/0GNV/8D5v/iqr 0Vt7Gn2MfaT7lj+0dT/6DGq/+B83/wAVR/aOp/8AQY1X/wAD5v8A4qq9FP2NPsHtJ9yx/aOp/wDQ Y1X/AMD5v/iqP7Q1P/oM6t/4Hy//ABVV6Wp9lDsJ1J9yf+0NT/6DOrf+B8v/AMVQNQ1P/oM6t/4H y/8AxVQUDrR7KHYPaT7lkX+p5/5DOrf+B8v/AMVVVInjnE8d3eLMrtIJFupAwdhhmznOSOp71IOt LR7KHYpVJdxsYmiYtHfXyMZjOSt3IP3hGC/3vvEEjPXmgQt/z9Xn+v8AtP8Ax9Sf63/np9773+11 p1PHSnGlDsHPLuR+W/kzQ/a73yp3MkqfapNsjnqzDdyTjqaZFaLBEkUU11HGkonREuXAWQcBwM8N 79anoqvZw7IXtJdxtx5106PcX1/M8YZUaS8kYqGGGAy3GRwfWkiSS3lEsN3exyBDGHS7kBCE7iuQ 3TJzj15p9FHs4dkHtJdyp/Ztv+95m/ejbJ+/f5xkHB555AP1Aq5M1zdeX5+o6jL5Uglj33srbHHR hluCPWkpR0pOnDsg9pLuReQ3/P1ef6/7T/x9Sf63/np1+9/tdaPIP/P1ef6/7T/x9Sf63/np1+9/ tdamopOnDsvuF7SfchjskhvTexTXSXZYsZ1uXD5OcndnOTk5+tS3CTXTo9xfX8zxhlRpLyRioYYY DLcZHB9akopezh2RSqS7kUUL28olhvL6OQIYw6XcgIQncVyG6ZOcevNVxpVtmTmf96Nsn79/nGQc HnnkA/UCrtKOtHJDsh88u4zZKJLiT7df77gATN9slzKAMDcd3OBxzUCaZBHBNAj3Cwz7fNjW4cLJ g5G4Z5wematd6d2pqnDshOpLuQS2vn/aPOuryT7Tt8/fdSHzdv3d2T82O2elMj0+OGFIYprpIklE yoty4VZBwHAzw3v1q1RVezh2QvaS7j/tOof9BjVv/BhN/wDFUfadQ/6DGrf+DCb/AOKplFHsodkH tJ9yT7Rf/wDQY1b/AMGE3/xVO8+//wCgxq3/AIMJv/iqjFP7CodOHZBGpPuL59//ANBjVv8AwYTf /FUeff8A/QY1b/wYTf8AxVJRR7OHZFe0l3FM9+Bn+2NX/wDBhN/8VTWur9WVV1PXZXY4VIbq4kdv XCqSTxz0paTzGhIlSSWN0yweJiHX1wRz09KThGztFDVSV9WNku9ShKefd+JoAzbQ07Xkak4J6tgZ 46VJ9pvQQDrGsc9MX83/AMVT7nVob+90Rb25v5baKxiWcPbyMqz+VKN7K0bAtuKc7W7Z4yCqXmnW t9dNJAJ4Rpb+TF9neVHuQRtbAiTazYPAAHXB9MG+VawNt3pKxELm9I/5C2s5H/T7P/8AFcUk11ex W7S/2vrOAD0u7h+cZ6K2fc+wNWtNv9HjXRo7y08yMyXX2+STTjuwWJiPyr0OByvQADgcVnTahZXO m6ZKbSSK4a1vhdJHp7qu7awgzhME5wQfX3qlNf8APv8AAFCT+0WvtF6P+YtrPt/p03PuPmxim/ar wKGOr6yAfW9m/wDiqlOo6U0CxC0KH+xM+YunuJPto7btn3vfv3zxUsNzow0J2fzHvHsWKFdPkWRZ sZC58rLc9y4Bx93mnzq1/Z/gLllf4irHdX0gydT1yM4BCzXVxGSp6MAxBIPPI4p/m33/AEF9W/8A BhN/8VTpbuG6GmiBpD5Gk2sEm6FkAkXfuAyBk8j9KbWsIxlG7il8jKpKUZWTDzb7/oMat/4MJv8A 4qk86+/6DGrf+DCb/wCKoNFHs4dkT7SfcPOvv+gxq3/gwm/+KpPPv/8AoMat/wCDCb/4qlpuaPZw 7IftJdxfPv8A/oMat/4MJv8A4qmSm7nQJLqmpyKGVwHvpSAykFT97qCAR6EU7NGaPZw7IPaS7jXN 3I8byapqbNE2+MtfSko2CMj5uDgkfQmn+ff/APQY1b/wYTf/ABVJmjNHs4dkHtJdylf2C6ps/tC4 u7vy87PtFy8m3OM4yTjOB+VWzc6gP+Yxq3/gwm/+KpCeaaafs4dkT7Sfcp3umw6jOJr6S4upQu0P PcO7AemSenJqv/wjumf8+5/77b/GtTNGafsqf8q+4ltvVmV/wjumf8+5/wC+2/xo/wCEd0z/AJ9z /wB9t/jWrmjNHsqf8q+4DK/4R3TP+fc/99t/jSHw9puf+Pc/99t/jWrmmk81Hs4fyr7gMv8A4R7T f+eB/wC+2/xo/wCEe03/AJ4H/vtv8a1M0Zp+zh/KvuGZf/CPab/z7n/vtv8AGmnw/puf9Qf++2/x rVpp60ezh/KvuEzM/sDTf+eB/wC+2/xoOgab/wA+/wD4+3+NaeaQ9Kfsofyr7hGZ/YOnf8+//j7f 40f2Dp3/AD7/APj7f41pZozT9lT/AJV9wGb/AGDp3/Pv/wCPt/jR/YOnf8+//j7f41pZozR7Kn/K vuAzf7B07/n3/wDH2/xo/sHTv+ff/wAfb/GtLNIelHsqf8q+4Zl/2Fp//PA/99n/ABo/sLT/APni f++z/jWlRmo9jTvsMzDodh/zxP8A32f8aT+xLD/nif8Avs/41pMabT9jT7Esz/7EsP8Anif++z/j R/Ylh/zxP/fZ/wAa0KKPY0+wrmd/Yth/zw/8fb/Gj+xbD/nh/wCPt/jWhRmj2NP+UZn/ANi2H/PD /wAfb/Gj+xbD/nh/4+3+NXVkjIO+4jjbcRsaGdiBnjlYyPyNKrhi20hlDYDhWUEY9GUH9KSo07/C O2hivBpMZYSWtwpDEf6uQg4OMgjOR3/EVN9g0ovsCbm4xtZjnJxx/ngVpWd1Losc0lvcTpOYWWOS OFXbcZY2PG0jO0PyR+tTNrt7qtmLe9uruZ0njdDPbhDtCSBuVUDGSnvzQ6UOkTRqHQypNJ0+NGcw NhQScFifyHJqoYdK+bFtccDPEcnPOMY656cehB6Vtt3wcGrtpqVmtmVkvrmPU1tlit71rAssKZbE ZHl4LY3Zbbj5upOKbpU0tI3FFRe5zX9l6fclAn2iJchiyAgleP7wI5BHv+RorSTBRSNwBBIDDBHo MeworOeHpyd+Uzai+h1ug+CdX1a2Grw6/bWhkmmVYxp7MVCyMv3vOGc7c9O9X5vhnrdwQZvFVs5z nJ0tuv8A3/rqfA/HhO3/AOu9z/6Pkqj/AMJFqUni+905Z0itba8itwi6Lc3BdWiickzo/locyEfM PlABORXmVKknJq57FOnBRTsc+vwp1NSSPElnn/sFt/8AH6f/AMKt1X/oZLP/AMFbf/H6308YPC7T XkcaWkMGqzzFFJYLaXKxLjnupJPvjGKveGfFNv4ie6hjexaa2WN3+xXguowr7tuXAGG+Rsrjjjk5 o+sVe4/Y0+xyX/CrdV/6GSz/APBW3/x+j/hVuq/9DJZ/+Ctv/j9em1x+u+ItStPE0um2s6Qwx2cN xuGi3N+zM7yqQfJcBABGMZHOT6U/rNX+YPY0+xhf8Kt1X/oZLP8A8Fbf/H6P+FW6r/0Mln/4K2/+ P11h1q/t4tNtRDDf6jdwyXJ+R7JfJQrk7H3srjzIxtYjnOStYQ8aa1LpNjcWtlp8txPZ6RcOssjx qGu5XjcDAY4BVQPTJJ3Y2k+s1f5g9jT7FD/hV2q/9DJZ/wDgrb/4/S/8Kv1X/oY7P/wVt/8AH69I gMrW8bXCJHMVBkSNy6q2OQGIBIz3wM+gqDVHvo9MuJNNSJ7xE3RJKCVcjnbwRjIyAexOcHGCfWav 8wexp9jz/wD4Vfqv/Qx2f/grb/4/Sf8ACr9V/wChjs//AAVt/wDH66qPxRb6tcaTBod1azveL9pl 3HeYrdSQxKgghi/yDPQ7uDtIrJs/iFG02h297FZxS6jYWVy2brZIZLksqrHEQS6hl+Y7uAwPPNH1 mt/ML2FPsZf/AAq/Vu3iSy/8Fbf/AB+k/wCFX6v/ANDJZf8Agqf/AOP1uR/EPThdWcN1Gtv5lq8t 0xmBFrKu79yeBknyp8Hj/V9OeOpsLiW7061uZ4DbzSxJI8Jbd5bEAlc4GcHjNH1mt/MHsKfY86/4 Vfq+R/xUlj/4Km/+P0//AIVlq2Mf8JHZf+Ctv/j9eh3qXb2jrYzwQXJxsknhMqDnnKhlJ4z/ABD+ lcYnizVNN0wahrF9opjmvrjT4EMbWaCSOWRd7zNJIFUrC5xtJyQMnufWav8AMHsKfYzv+FY6v/0M dj/4Kn/+P0f8Kx1f/oY7H/wVP/8AH66Ww8W/2rPpEdhaxTpfxXMjzLcZSPyJUjfaQp3glzg8ZwOm cjJbx/qaaNBqT+HIwlxpT6rEv9oDiGNUaTcfL4P7xNoAOc87ecH1mt/MHsKfYof8Kx1f/oY7H/wV P/8AH6P+FY6v/wBDHY/+Cp//AI/XSXPia9h1Geyt9PiuZv7VGnwqZvKGPsYuNzHDd9w4HT1Iwa91 43+zaTaXUkOm21xNJcRPFf6oluivC5jcKxUl/mBxhQMYzjNH1mt/MHsKfYw/+FY6v/0Mdj/4Kn/+ P0f8Ky1gf8zJY/8Agqf/AOP11uh+ITrd8fLjCWkml2d/FkfP+/M2Q3OOBGv5nr23qPrVb+YPYU+x 5r/wrPWP+hksf/BU/wD8fpR8NNXH/Mx2P/gqf/4/XUXfiePT/E11pt1BdPClnBcRta2M9w253mVg 3lqwAxGuMgfxde2S3xAig0y0nn+wwz3dzerEL64NknlQTmPkuCRJjZ8pA5J+7jg+s1v5g9hSXQzv +Fa6v/0MVl/4K2/+P0f8K11f/oY7L/wVt/8AH61pPGs8mq2Nvp1hHdw6jbWktr5kvlEGaO6ky5w3 ygW68AZG4nngV0ejamNX0xLsReU++SKSPdu2SRu0bgHuAysM96HiavcfsafY4b/hWur/APQx2X/g rb/4/R/wrXV/+hjsv/BW3/x+vSKKX1mr3D2NPsecf8K31f8A6GKx/wDBW/8A8fpf+Fb6v/0MVj/4 K3/+P16NRTWJqrqHsafY85/4Vvq//QxWP/grf/4/R/wrfV/+hisf/BW//wAfr0aij61W/mD2NPse c/8ACt9X/wChisf/AAVv/wDH6P8AhW+r/wDQxWP/AIK3/wDj9ejUUfWq38wexp9jzr/hXOsf9DFY /wDgrf8A+P0f8K51j/oYrH/wVv8A/H69Foo+tVu4exp9jzr/AIVzrH/QxWP/AIK3/wDj9H/CudY/ 6GKx/wDBW/8A8fr0Wij61W7h7Gn2POv+Fc6x/wBDFY/+Ct//AI/S/wDCudY/6GKx/wDBW/8A8fr0 Sij61W7h7Gn2PO/+Fdav/wBDDY/+Cx//AI/S/wDCu9Y/6GGx/wDBY/8A8fr0Oij6zV7h7Cn2PPP+ Fd6x/wBDDY/+Cx//AI/R/wAK71f/AKGCx/8ABY//AMfr0Oij61V7h7Gn2PPP+Fd6v/0MFj/4LH/+ P0f8K71f/oYLH/wWP/8AH69Doo+tVu4exp9jzz/hXer/APQwWP8A4LH/APj9H/Cu9X/6GCx/8Fj/ APx+vQ6KPrVbuHsKfY88/wCFd6x/0MNj/wCCx/8A4/R/wrvV/wDoYbH/AMFj/wDx+vQ6KPrVXuHs KfY88/4V3q//AEMNj/4LH/8Aj9J/wrnV/wDoYbL/AMFj/wDx+vRKKPrVXuHsafY87/4Vzq//AEMN l/4LH/8Aj9H/AArnV/8AoYbL/wAFj/8Ax+vRKKPrVXuHsafY87/4Vzq//Qw2X/gsf/4/R/wrnV/+ hhsv/BY//wAfr0Sij61V7h7Gn2POv+Fcat/0MNl/4LH/APj9NPw31fP/ACMVj/4K3/8Aj9ej0UfW q38wvYU/5Tzj/hW2r/8AQxWP/grf/wCP0f8ACttX/wChisf/AAVv/wDH69Hop/W638w/YU+x5x/w rbV/+hisf/BW/wD8fo/4Vtq//QxWP/grf/4/Xo9FH1ut/MHsKfY84/4Vtq//AEMVj/4K3/8Aj9J/ wrXV/wDoYrL/AMFb/wDx+vSKKX1qr3D2NPseb/8ACtdW/wChisv/AAVv/wDH6P8AhWurf9DFZf8A grf/AOP16RRR9ardw9jT7Hm//CtdW/6GKy/8Fb//AB+kPwz1cn/kY7H/AMFb/wDx+vSaKPrVbuJ0 Kb6Hmv8AwrPV/wDoY7H/AMFb/wDx+j/hWWr/APQx2P8A4K3/APj9elUU/rdbv+QfV6XY81/4Vlq3 /Qx2X/grf/4/R/wrLVv+hjsv/BW//wAfr0qij63W/mD6vS7Hmv8AwrLVv+hjsv8AwVv/APH6P+FZ at/0Mdl/4K3/APj9elUUfW638wfV6XY81/4Vlq3/AEMdl/4K3/8Aj9H/AArLVv8AoY7L/wAFb/8A x+vSqKPrdb+YPq9LseZ/8Kw1b/oY7L/wVv8A/H6P+FYat/0Mdl/4K3/+P16ZRS+s1f5g9hT7HmZ+ F+rH/mZLL/wVv/8AH6T/AIVdq3/QyWX/AIK3/wDj9em0UfWav8wfV6XY8y/4Vdq3/QyWX/grf/4/ R/wq7Vv+hksv/BW//wAfr02ij6zV/mF9XpdjzH/hVurf9DJZf+Cp/wD4/R/wq3Vv+hlsv/BU/wD8 fr06ij61W/mH9Xp9jzH/AIVbq3/Qy2X/AIKn/wDj9H/CrdW/6GWy/wDBU/8A8fr06ij61W/mD6vT 7HmP/CrdW/6GWy/8FT//AB+j/hVurf8AQy2X/gqf/wCP16dRR9arfzB9Xp9jzD/hVmrf9DLZf+Cp /wD4/Sf8Kr1Y/wDMy2X/AIKn/wDj9eoUUfWq38wewp9jyPVfhvqumaPfah/wkNnJ9lt5Jtn9mMu7 apbGfPOM4or0bxTz4Q1of9OE/wD6Lait6NapJO7MKtKEXoip4IBHhS3z/wA97j/0fJW1b2VvazXU 0Me2S6lE0xyTucIqA89PlRRx6fWuR8PeIE0rRNL09NOvr67u/ts0UdqqdI7jDZLsoX/WDGTjg85w Doaj490nTPD1rrNxHOsNxO9v5TvFE8cibw4bzHVcqY2BAJJOAM5rkqL32dMH7qNSLQtMikEi2q5C 3C4ZmYETyCSUEE4O5wD7dBgcU7TNGsdIEv2NJQZcbmlnklOBnABdiQBk4A4GayLzx7p1tJAILHUL 2Ga3tblJ7aNCm25dkhHzODlmXHTjcM8ZxT1D4peH9Mhtzc+dHcSrI720kkMckIjkaN92+QKSHRxh CxO04BqbFXOyrJv/AA3p2o35vpjex3LRLCz2t/Pb7kUsVBEbqDgu3X1NE3ivS4orWZV1C4huoEuI ZbTTLm4RkblTujjYA45wTnpxyKqvreqv4nsbW20+RtJuEgdriS1kVkDx3TNnONpDRW4wwyPMweWX BYLluXw7ps9nb2syXMqW5YxvJdytJhvvBpC25lPQqxIIAGMAUkfhnSIrQ2qWm2L7LBaACV8iKEsY gDnIKliQw+bODngVl+I/F0/h3V00+WO3kl1JFTSASV3z7grJJz0G9W3DHG4dQNxqHjFNAl1yDWLi yWXT9Pjv4Qp8szIwKEYLHnzV2j/fQcnklgudPFGsMKRKWKooUF3LNgepOST7nmn15TP8UdasfD+q xXdvpf8AwkdvLcG0hQOIpYIWmEjld+7j7NN0PUp61t3XjuZ7+9Nve2FlZWdy9qz3dlcSIzo2xvMn QiOD5gQN244wcc4osFzrrLSLDTrm8ubS3EUt5J5k7Ak7m59TxyScDAySepNU4vCujQzWUsVtIhso IreFRcSBQkWfLDLuw+3JILAkZNczf/EE2L6jdz6voFtDZTzJ/Zc74vJkidkLA7xgttJVdhyCOeeO j0jVdYu/F/iPTr2w8nTLH7N9gufJdftG+MtJ8xO1trYHy4x3osFyWbwtolx9q82wjb7VdR3c2Wb5 5Uxtbrx90cDg85Byc69SUUWC5HWdJoWnS6e1kYGWBp3uPkldHWR3Z2ZXBDKSzMeCMZwOOK1aKLBc zLXRrCyktZIISr20UkMTNIzELIys+SSdxLIpycnjryagfwzpD2ENi1pm2hsH06NPMfi3cIGTOc8i NOevHXk1tUUWC5mf2Np/237Z9n/f/avtm/e3+t8nyN2M4/1fy46d8Z5qvP4Y0i4SNXtnAjkmlXZP IhJlffICQwJVmOSpyvA44FbdFFguZmn6Np+lbfsVv5Wy2itF+dmxFFu8teSem9uepzz0FX6koosF yollbpfzXyx4uZokhkfJ5RC5UY6cGR/z9hVGfw3pdxarbtBIiLNLOrQ3Ekbh5HLyYdWDYZmJIzjt jAFbNFFguc3qXg/TdQurCba0P2Vowwjd1LxxxTJGqkMChUzswYc8fQjZs7O30+zitLWMRwRDCqCT +ZPJPck8mrdFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdF SUUWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdFS UUWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdFSU UWC5HRUlFFguR0VJRRYLkdFSUUWC5HRUlFFguR0VJRRYLkdVp9RsraXyp7y3ikxnbJKqnHrgmrtZ VlI0VrM8URkuJbmf8cSMBk9gAAKl6DTKXiG/s7rwrrUdvd28r/YJ+EkDH/Vt2Boqn41fzfB+oSFW SRIyOeqk8H8CCR+NFdGGloznxEbtDvB2mwyabpuqM0gnt0vbdFBG0rJcBmJ4znMS457nr2sy+DbJ zbPFfX9tLBPdSrLDIoYi5lMkqElThSxGCMMABhuucTR9T1GDTNE0rTWsoJLw3spubxGkVfLm+4EV l3M28n7wwEY81kWPifX7Dw/pUOi2FpfXOoX+rTyyrIpjwl1Idqb5IwdxbIO7IVWO1ucRP4maQ+FH Y2/grTba1t7dJ7spBb6fbqS65K2cpliJ+XqWOG9R0x1pw8IQQM0thqeo2E7yTPLNbtGWkEkzzFGD oy4VpX2kDIBPPWsnVvEnicW9hcaXYaeVksEvLuISx3MsRYZwB50SlODiQM2cHA9bEXiPVtXvLC10 yTS7RbjS4dR+03SSS+b5hOUjjBQ4XAJYtkb1+WpKNi68KaBqPkNqej2OozQxLCs99bpPJtHQFnBJ 5JP1JPetSCCG1t4re3ijhgiQJHHGoVUUDAAA4AA4xXM6pqviB7/SNP0Z9I8+80+4u5JpxJJFujMI XZtIJUmU8+mD2wbT3F5H4+tbab7DLaz6fcy27C2Kzw7HtwymQuQysXyQFX7i9cZoAnvvDNhqU2oy 3hlla+t1tjlgPJRckeXgfKdx3Z5OQPQYbqXhez1a50m5u7i6ebTWDIwZR52CjYk+XBG+NG4xyo+l YGq+K9as7rxNNbvpLWuhyxj7JIr+fchoI5NoYNhCWdlU7WyeMDGTZ1hvEX/Cfadb2OsWFvbTWF08 cM1lJIMq9sDuAmUO3zEqcDaNwwc5ABsv4bs5PDmo6GZJ/suofavNcMN6/aHd32nGODI2Mg9BnNVr 3wjb3rXMTalqEWn3Tl7nT43QQyljlwSULgMc5CsAcn1NLplxef8ACZazZ3n2GTZaW00M0FsYpPLe S4CxyMXbft2EgjaMu3AzWT/wlOsfafte3TPsP9sf2X9i+f7T/rvK8zfnGcfvNmz7n8VAGzc+GEvb lzd6tqU9k8vmmweRPJJzuwSEDlc/wlivbGOK3a4mPxF4h8gapINLOnDWW0026xyCVk+2G2WTfuwC DgldpBweRnAm/wCEu1X/AISH+zv7C/0f7X5H2jZffd37d+fsfl9Of9Zt/wBrHNAHYUVz+gaVrFhq moz6jf8A2m3nz5EfnO/l/wCk3Mg4YYH7uWFeP+eeOijPMWX9o6dJpWoatdvc/abiGE31hrskqTSO wHFsyLGIyxx8uSF57ZoA9HorzoajqcvgLwXNa6p5V9LBie6uJSUEg0+clpjzkLKFLbs8rzzWdr0t /oGj37zT3sNzc6deG1ubbXpbsSOlvI4ZkdV8vG3cGjGAwUZ55APVqK4/RNC1Wz1iC4ubHyoU3bn/ AOEpvrzGVIH7qVAjcnueOo5ArU8aTzWvgXxDcW8skM8WmXLxyRsVZGETEEEcgg85oA3KKr3yXkln IthPBBdHGySeEyovIzlQyk8Z/iHrz0rl4tdvIPhnoWq6faWMV1dRaciW+wpbx+e8SFVA5VQJDjrj A69KAOworjLnxJrOkT31pqTadNJbSac4uIYniTybm5ML7lZ2wVCOd27HIJHBBdqHi28i07xFeWIs J/7J1JLWOJ2YfaB5ULNGGXOJS8rKPlIyACOpoA7GisXwrqt3regQ6jepbRSzs58iAsfIAYjy2LAE upBDcDByMcZOb44W9mPh+0sTIXudTKPEuoS2QkUW074aWIFwMqGwAclQD60AdZRXn9knibTPEMGk 20FjafbbSa4aa71a81Xb5TxKMLLs2/67kA88En5QGXVtX8QX3g+zv4L2y0+4i1eOzuyIZHV2S/WD cpEiFUO1iynOVYrkdaAO/orjfEGueJtHbSNNtLS21HUL0TNLcxQrGiBCuAsMk67iQ/8Az1z8rHBH AUeINfutG8PFILCw1PUr6S0nWX/So4tkc7kjy5AMnyRxuO3cQckUAdjRXHXuua8mvT6ZFdaHaNa6 VBfzNcrI4Z2aVXCkMuEHlj5iCRnoc8POv65qcvhyLTIrGyfVNMlv5xexvMYCvkYUBWTcczEHOOme 2CAddRXNahcanb634YF0NNkiuZzDLH9nZpIpxbTuZIpSwwMJswUzhm55xWV4o8UeItG1C9ntbawk 0eyVGmkGJZFyMt5g81Gj4IxtSQkHOO1AHdUVwGu+MPE9pr2qW+laFBPZ6Z5e95Z4k84MiuSXeZDE o3EBtkgJU+hA7+gAorzjVv7RshqOtX929xaW08pNxp+uyRvBGHYKgttgiZ1UAEMSS2fpViHxh4nu PEEiR6FANJj1Q6e7vPEpCiTZ5u8zBgT94R+VkgjDHINAHf0VzNtqHiC/8R6rBbtpiadp17FblZI5 DNKrQxSOdwbCkeYccHPAO37xZZa9rNx4vl0OW0tFS2eWaeZWbm2IHkFR2dmZgc8fuXx1GADqaK4D wv4w8T61qGnS32hQWumahvwfPiDQEKWABEzNK3y4K+WhXknoa2dA1DxBqtxLdztpi6al9d2oiSOQ TbIppI1fcWK5ygBXb3JyPu0AdNRRXN+FIja3niOyW4u5oLXU1SH7VcyTsim1t3IDSMzY3OxxnuaA Okorm/CkRtbzxHZLcXc0FrqapD9quZJ2RTa27kBpGZsbnY4z3NafiAzDw3qhtruGznFpL5dzPJsj hbYcOzfwqDyT2AoA0aK80n1m/wDCAvB9huJtRNqJYbU65JeQODNFGXZ5grRlfMB/hUjdyMZGlD4p 8SW3hzxNd6rpltb3el2LXdsWaMeb+7dgHijmkKgFOu/5gTjGDQB3NFc5cT+KrHQ9QupE0q7vIo1m t4YEkQNg5kjJJOTtGFfjJPKgDnHvfEWo6r8ONa1+1XSWtYxdyQw3EDXMdzaxK67XAdQGcoT3ABwQ TmgDu6KxPEur3elQWC2SWvm3t4tr5125WKDKs29gOW5UKFyuWYDIrJ1vX9f0TSIFjhsNU1KfUFsw 9sPKSMGMvuZJJAN3GAhkGdy884oA7GisLwrqeranp9wdasYrS8t7loSsciNvUKrBiqO4jPzY2l2P Gc8isjxcZpfFWi2i2us3kD2V5I9tpd+bViyvbBXY+bECAGYYyfvdO4AO0orz9dU8R6Hp0enrbSy6 jeXMsljb3Ei3UsNoipu8xjJGrMHbp5nRh8zEGnWHjHW9asvDy2semWFzqL3izzXRM0am3cpsjVHA ZnwW+/gKj8vjNAHfUV53qGvajpni25ure0tZkn0rThdX3mk29opluv3mB8zrk9sDAJLKOa9DGcDJ BPqKAForkPGf2UYT7Xq02pywMljpmnXz27SuM/OSmMDJGWfKAAcdj0umx3kWl2keoSpNepCi3EsY wryBRuIHYE5NAFqivP8AVn1nUvEusIxiXTdO8sIv9uTWDKpjV2lIijJYZYqCzbfkPHUnD8T+LNSv fCc0cEeuaZbQ6MLz7altcNLNMbfei+bHHsRVJBdyy8qVwBk0AeuUVHBMtzbxToJAkiB1EkbIwBGe VYAqfYgEd6890PWdU023keOXTJ7F/Ed1ZG1AcXAMl7IC2/OMrv3bNvKrncKAPRqK5/TLi8/4TLWb O8+wybLS2mhmgtjFJ5byXAWORi7b9uwkEbRl24Gap2B14/EbVIp9TtZNOjsraUW62kikK0lyFCky kBxtG5tvzAKMLjNAHWUVz+gaVrFhqmoz6jf/AGm3nz5EfnO/l/6TcyDhhgfu5YV4/wCeeOijPQUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAVwo8QarYvdQxmzZFu 7jbuhbOPOfGfn613VeaXf/Hzef8AX1cf+jXrow9OM5NSMK85Qj7pU8S+ItTvtBvLZxaKjqAxWJs4 3DOPn60Vmavzp1z/ALo/9CFFbzpRpu0EYwnKavI9B8OaZYar4NtbbUbG2vIPOmbyrmJZFz5r4OGB Ga159A0a5sY7G40iwltI5TMkElsjRrISSWCkYDZZjnr8x9a5HSYtRto9B1ey0yTUIoYL+1migljS RTLPGysPMZVIHkkHnPIwDRpuneIdLn0zUjoomnD6sk1sl2g8r7TdrNG+48FMJg4+Ybh8p5A4p/Ez rh8KOr1LRdJ1B7Nb7Q7S/CNsRpbeNxbjaTn5uQMgD5cnLDjGSJ9Q0fS9Whjh1HTbO8ijOUS4gWRV PqAwOK4SHRr/AEy38CyjwnPd6lpFpCl3dQNah1UWssRhDvKpOHdWwPl7gk8Vq+JtGuL3xB9puNBG t2Js1itkE6IbSfc5aTDkY3Ax/OmWXYcDmpKOi0i4sdX0vTNZtbUIk9msluXjUSRxSKrbOM46JkA4 yo9BVS50nwrL4gS4utP0Z9aLxukksMRuCwDFCCRuziJyD6RnH3Tjm7bwzrSeHvD9r/Z+6a00q2t5 x/wkl3Y7JETDLsgVkbB/izk9OgFdRbeH7Lz7HULm0xqVvFEof7VJNtKJKgG9sF8CeYbmGW3ZPIGA Chc2fhDS/EMl3qk+lLqt7cLcwm+eISowjjiHlbsMBiJemec/QXPEbeFzDDH4nOjmItmFdT8raW/2 RJ3+lc3rek+IItf1dtE02J4dWEf2iW4ihkjbEapyxkDpwMYMco4yByRWTa+B9R0VpvM0/UNRuXtL aC3utM1JbYRmO3jiIk3MhK70ZhkSDDfdBzkA9AtvDvh+LURq9ro2mJfOzS/bIrWMSsXB3NvAyScn Jzzk1XvJPCmn6/Fc3r6NbazKAscsxiS4cHjAJ+Y+lef6R4S8ZWmr2D6haaW13FeRSyanaW4yIAw3 RCQzKyrsBTYIduPf5quXPhHVrZ9YS00y7l1K+vZ54b5NQVbPY8hZBPESC4VSFIMb5AwGAxgA7qS+ 8ORXq6LJdaUl00onWxaSMOZC/mBxH13b/nzjOeetWpdY0yDUotNm1G0jv5V3R2rzqJXHqEJyRwe3 avO9Y8MeJLuDW9A0ywgg07UrmaZ7i5ihYAyMWLiQOXzk5AMOR0DjAYT2vhPVrHxFLLBYSmafWDey 3zXim1a3Mxfa0PUyqp2g7eCFIfAwADvr3UobG6063lWQvf3Bt4ioGAwikly3PTbGw4zyR9RDb+Ht EtdQbULfR9PhvWJJuY7ZFkOevzAZrhtF8Majb614bnuPDohvrG4kfVNWW5jYXZNvKm8YO98uwPzK Cu7ABGSIvCfhnxTp/iTT59TtLKN4TKb+/t4QGvQyMBukM5eT5yrYaJMY4wOCAd+nh/RYtRk1CPSL BL6TO+5W2QSNng5bGTnNZ+i6d4OvbW6n0Kz0K4t5w1vcyWMULpJkDcjlBg5BGQfWtWzj1JLi6a9u 7SaBnzbJDbNE0a5PDsZGDnGOQF6HjnjkEsdY1iw8aafLol3px1pZGtpruWAoC1pFAFbypHYHcjHo RjvnigDV0TTfAw1NpNBsvDv9oWhIZrCKDzYcgqclBleCR+Na1rf6P4j06f7Hd2OqWL7oJvJkSeNs j5kbGQeCMg9j71zNrpmoX2u6DM/hyPS4dJleRpJJYSEQ27xeVbiMElCzBjv2Hjp0Aijt9d1Cx8aW y6JfabPqyyS2U9xPBhXNrFCqkxysVbchOcYwOueKAN+PwX4VhSZIvDWjIkybJVWwiAddwbDfLyNy qcHuAe1XLPQtH0+zNnZaVY21qZVnMMNuiIZFIKvtAxuBVSD1G0elZfh/T1tLa+GneHE8PPIgCCQR uryAN85jhfBAJHO4M3Q4wDVrUrfxC/hae3s7uxfW3XatwI2t4hluSBmQqQmcZ3DcAcY4oAtf8SfU by/tf9BubpY0hvYfkdwh3FFkHXb8zkBuOWx1NU9Is9BD32n6do9pappt8odI7aNE87yY3Eihe+yR Ru4PBHTFcdH4V8QWw1e3tND02ytZrCyiVLbUmY3HlXEjyoWMStueORwXYdSvLZbbWj8J62nhzU4N L8P2+mQT699sOk3LpKs1r5CKRtjkCHMi7thdV4wTjqAeow20Ft5nkQRxea5kk2IF3uerHHU8DmoN S0nTdZt1t9U0+0voFcOsd1CsqhsEZAYEZwSM+5rg7Pw7r6eF1tp9Oge3/tX7RJpEbLbK1p5WPKVR JIg/e/PsL7TyMgHFdRpNjNb6FPDpGlQeHpHl3QwXEazIn3ckxxSBRnB4V/c8kigAstM8N6D4hgs9 N0Kxsr67tJpRNaWkcX7uN4gyllAPJkQ46fKfQVPq174a0iz+x6zc6TZWt2ZG8i8kjjSYltzna2A2 WbJ92yetYXifRLq+1rQbu90JNftrWzuYruKMxxqZHMG0iOV8MMo52ljjGckgZgXQLuDRdJN9o2oX l1bC5RRpmrNDLbQyShki3eZGJAFWNTlusYwDnNAHSWem+GdV8PQ2tjZaReaISTFFBFHJbEhjkqAC v3t2cd81BFrHhu30m3u7hrHTbO1vJrW2N2Y4VjlieSFvLycDO2TGOdpPTJFc3Jouu3C2T6zo7axp cM0+3TJrqOWdVYR+U0hfbHIykTDljgOpyxBqivhfXrTSNAa3025t57O71FpBZXEElzDHNLIyBWn/ AHbIQV3E/NwuB1wAdvL4d0PWNSbWLm1tdRM0EMcfnRpNGqxtIyumQcE+a3OegH46dz9jts6hdeRF 9nicG5lwvlRnBb5j0X5VJ7fKPSuf8NaRrel+HdIs1k0+yMLO15CYGmMgaQt8rCRQjkEljhl3NwMD lniTSdZ1LXLKWKw0vUNKtU8xbW8u3hzcZOHYCGQMFXG3pgknqFIANO60Lw34j8jUbzStK1TfEvk3 M1vHPujPzLtYg5XkkY4596raxDon/CQ6YLjQIdQ1Wfc0Uwt4meCNCoaQu5BCqXT7pJ54BrkLfw1q 6aHo0Gu+FodZgttEhs1sI71Cbe4QMGch9qfMvl/OpJQqQu4fMeovvClhdePtO1t9FsZfLtJzNdPB GX88Pb+SxJG4sFSTDfw4xkZ5ANq80XStRuobm+0yzuriD/VSzwK7x9/lJGR+FMvfEGi6bdpaX2r2 FrcyY2Qz3KI7Z9ATk1wHi3wz4p1DxHqNxZ2llcJOIxp140IklsSqAHDNPGYvnDNlEfOec/drX8TS +IX1K807S/CTmwulVbnVoJbVpZQVAIWKR1yQMKGc8Y+6RjIBt2Fh4e1q4bW00WyN5HczQ/aZbWPz t8MrREhsE43ISDnpjp0pJpvCB8TRmeTQzr4wqb2i+1D0Az89cR4c8IXmmx2cNr4TbTLqLVWuE1CW 6hYxWZuGfyjsZmyYiU2DKZbcWzmtLW013U7u70dvBE0Xh952aea1mtHkvhuyfleRPLDHJLHc2D/C eQAdI/izwhYXl1E/iDQ7a6Mp+0obyJHMigId4zncAoXnn5QO1aN3d2mn6lYh4P8ASdSm+yLKiDPy RyygMeu0BJMdeW6ck1nahpl1rmvW8V9axjRLIicK7hjdT4+XK9kTJPPJbBxhQTzlv4c1RfHFhfz6 OGkh1W6uJtVW6UiS3eGZYU2EhsoHRMYwvUZDNgA637J4esNejl+z6Xbaxfbtj7I0uLjAy2D95sDk 9ah0vxL4VurhbDSdb0aaeV3dbe0uomZ2JLuQqnJJO5ifqTXKWnh3xRFr+kale6To814NTa4vr+HU HL+WYJowoVoQQihwFUE8gZ+8zixpuj6pYXGnW+j6Rqulx28saTG71j7TafZ1wGSNGkdvujC/ImDj JAyCAddbaul3rV5p0NrcMLPCzXXyCJZCquI/vbi211b7uMHrniqmhaT4Vtne98Pafo0TlAjT6fDE pKsqyAFkHQqUbHcFT6VT8MeFLDQda167ttFsbLz7tRayQQRofI8iAFRtGVXzEc7eOecc5rY0jRNO 0G1a20238iFtmV3s33IkiXlieiRoPwz1JNAEem+GtB0a4a40vRNNsZ2Qo0lrapExXIOCVAOMgHHs K0J4Ibq3lt7iJJoJUKSRyKGV1IwQQeCCO1SUUAZ9joOj6XBNBp+k2NpFMMSx29ukauP9oADPU9aL bQdHsrGextdJsYLS4BE0EVuixyAjBDKBg5HHNaFFABWZN4c0O40yLTZ9G06WwhffHavao0SNzyEI wD8zc47n1rTooApRaPpkGl/2XDp1pHp+Cv2RIFEWCckbAMckk9OppsWiaTBpjaZFpdlHp7Z3WqW6 CI565TGP0q/RQBXsdPstMtVtbC0t7S3X7sUEYjQfQAYqQwQtcJcNFGZ0RkSQqNyqxBYA9QCVUkd9 o9KkooAp6jpOm6vEkWp6faXsaNuVLmFZAp9QGBwaiuNA0a7sUsbnSbCa0SUzLBJbI0ayEklwpGAx LMc9fmPrWjRQBALK0VnYWsIMkSwuRGPmjXO1D6qNzYHQbj61LFFHDEkUSLHGihURRgKB0AHYU6ig DL1Lw1oOs3C3GqaJpt9OqBFkurVJWC5JwCwJxkk49zWhb28NpbRW9tDHDBEoSOKNQqooGAABwAB2 qSigChf6HpGqzRTajpdjeSw/6t7i3SRk+hYHFW57eG6tpLa4hjmglQxyRSKGV1IwVIPBBHGKkooA Kz4tB0eDUP7Qh0qxjvcsftKW6CT5iS3zAZ5JJPqSfWtCigDLh8NaDbaodUg0TTYtQLs5u0tUWUs2 dx3gZycnJzzk1Yk0rTptTh1OXT7V9QhUpFdNCpljU5yFfGQPmbgHufWrlFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXml3/wAfN5/19XH/AKNevS680u/+ Pm8/6+rj/wBGvXXhPiZzYn4UYWq/8eFx9B/6EKKNT5sZx7D/ANCFFb4jdGNHY7XSfE2keHvDenpq dy0JlFzKu2CSQBElw7MVU7VG9ck4HPsa038baBHZLdNdyhGmaDZ9km8wOq72zHs3ABcMWIxgg5wR WJaeGP8AhIPDMf8Apf2fzdM1HTv9Vvx9okX5+o+75XTvnqMcza34Ak1TU5tRttYls7qS8acFPNQe W1vDE0Z8qWNjzAjg7sdiDXnz+JnbD4UbGoeMtB0u5S3ur1vMeKOZTFbySqUkLLGdyKR8xUgDOScA dRlsvjTQYraC4N3KyTI0gEdrM7IqsVZnVVLRgMCCWAwQR2qkngiKKKGGG9KxQ2+l26Bo9x22U7Sj Jzzv3bfbGeelMj8HX9jPcXGla1Hbz3RnWdpbPzQUkuJZ12jeNrKZ3GTkHuvapKNXVvFmiaIts19e lRcwvPD5ULzeZGm0sw2KeAHU/TJ6A4s3Gu6bapqLz3Owacge6yjZRSu4EDHzZHTbnJBHUYqtZ+HI NPvdGlt5mEGladJp8UbjcWVjDhi2eoEOOnO7tjnJ1/w5Lq3jfSblLe7SzjjzqEqzKIbhEYvFGybt xZZMNnbjDMMnOKANi98W+G9Nu3tL/wAQaVaXMeN8NxeRxuuQCMqxBGQQfxrOm8V3Vxc3o0axsby0 skR5bibURCJFeNZA0eEYMu1h8xKgnIzwa0b7w1YaheSXU1xqqSPjIg1a6hQYAHCJIFHTsOevWue1 n4cxanfzXC3FnMksKQj+1LNr2WBVUKPJkaQFCcbiTuJYljyaANfTfElxqGsafbnT44rHUdOa/tZj OTLhfJyskRQBTmYdGb7vbNV5fFl6kV9qSaTEdEsZpYp7lrvbNiJikjrFswVUq3VwSBwOmXp4c1iD XdMvYtbt3tdPtTZrHc2byzyxt5JkLy+cAXJhBDbcDcchqzdR+HS6tqV015qX/EtupTJPaQpJGZQT yrYl8s+m7yw/fdu+agDV1TxBrGkxXl/caHCNKtNzPJ9uHnsgP3liCFTkcgFwT0xniukri73wjr97 rct/N4hsriETiW1tLrT5mjtwpOwbUuEVyM53MpOQCMYAHaduaACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAK80u/8Aj5vP+vq4/wDRr16XXml3/wAfN5/19XH/AKNeuvCfEzmx PwoxNR/49Jv+A/8AoQoo1Dm1lHuv/oQorbEfEjKjsdKPFVx4b8OWQt9MS9VbK+v5y1z5RSKCRd20 bTuYiXgcdOvORZvfHt3Y28sUmiB9VivWtXsoZpJsqIUmMimOJmIxJGp+QAM3JA5q/ouiadq3hqD7 db+bvtbqzb52XMMz/vF4I67F56jHBHNX7zwnot/dPc3FmzTyTGZ3WeRCzFEjIO1hlSsUYKfdO0Eg muCfxM7IfCjF1X4grp2l6Jqcej3Fza61BG1ptuIkcTSKGSNw7AKCDy4LAYOR0zNrPi7UtK1M2UWi w3Jjismmf7bs2yXMzwoqjyzuAdBluODnHGDrDwron2WG1axV4IbH+zo45HZgtvgAoMnuFXJ6nAye Klk8P6ZNIZJbdncrbKWaZySLeQyw5OeSrknPU55yKko5C6+Jl3EBBa+GL27voo5XuYoBLKiFJpYd iPHE+WLQvjeEUjGSOQNK+8X6pDr82mWWhQXKrfCwilkv/L3y/ZRc8jyztXZuGcnkDjnjTu/B2h3s BhltJFVmmZjDcyxM/mu0kisyMCyszMdpOOelXf7E077d9t+z/wCkfa/tu/e3+u8nyN2M4/1fy46d 8Z5oA5Jvixo8cVs0lqytPbQ3IVtRsIyokjWQArJcIwIDDqo9RkYNVbjxHrerX99Npo1oWdukLRDS 4rKZAHhjl/eNIxLt8/SI427SCc139hY2+madbWFnH5draxJDCm4naigBRk8nAA61nX/hXSNSvJbq 4huFlmAWY293NAJgBgb1jYB+OPmB44oAx9D1TUrzW9Bnn1F5LfVtEkvZLRUj8mKVfsoBjYKHwfNf 7zN17YrJ1nxHrmk/2rf3MmrxzWc0jW+nxaar2k0Cn5CZ9p5ZcH/WKQTgKcYPWHwlpH9q2+pKl5Hc WyiOBYr+eOKNBt+RYlcIEPlplduG2jINOPhXR21D7a9vK8nm+eI3uZWhEmc7xEW2Bs85C5zz1oAw tfu9X0++ePT9cub3V5SZLXSIbWHygmeDKSN6p2Llxk9AT8tdtXOf8INoYvry9jGpQXF5KZrhrfVr qISOe5CSAewGMAcDiuj6CgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvN Lv8A4+bz/r6uP/Rr16XXml3/AMfN5/19XH/o1668J8TObE/CjFvv+PeT6r/6EKKW8/1Lf7y/+hii tcT8SMqHwnUm61DSfDei6xY2l9fR2skyXVlZjc8sblgCEz8xVxH7gFveotQh1S0sfDEGsHXZbZll k1KXS3leRbkruRHMJ8zystKBtyAVjB4re0bU7DSfCdpc6lfW1lBll825lWNclmwMsQM1o3niDRdO jt5L7V7C1juV3QNPcoglHHKkn5h8y9PUetcM/iZ2R+FHD6pOW8USW11N4pMCaJaPDHYmUus7PON0 giOA5Cj73yHad3Ra1bLVdZ0vUYZdbsdTme60ezHl2kDTxreKZTMvyZVCd8fzHCkAfNxXVx2dqt/L qMaD7RPDHC8gYnciF2QYzjgyPyOufYVBfa7o+mTrBf6rY2kzbSI57hI2O4kLwT3Ktj12n0qSjzPV H8RxeH9DeaDXruU6HAHggmu4JftWw7yZIVc+YeBiYBQQOeWx1mt/29/bE/2L/hK/s/y7PsH9l+T9 0Z2+f+865zu75xxiuj1DWNL0nyv7R1Kzs/OO2L7TOse8+g3EZ/CrEVxBPG0kM0ciIzIzIwIDKSGB I7gggjsRQB5l4klsJLwWcvhDVrzV5IIhJq99pb3MdsTGMkNArDzB3EQVN2fmHJr0bSkSPR7JI5bm VFgRVkugwmcBRy4YBtx75AOc5qN9d0eOa0ifVbFZbxQ1qjXCAzqehQZ+YH2zS3muaRp1wtvfapZW s7bdsc9wiMdxIXAJzyVYD1wfSgC/RVL+2NL/ALU/sv8AtKz/ALQ27vsnnr5uMZzsznGPasdPGen3 XjNfDlld6bPLGha4JvlEiv8AOPLSMAl3HlksCV2gg85xQB0tFc0njPT7rxmvhyyu9NnljQtcE3yi RX+ceWkYBLuPLJYErtBB5ziuloAKKz7DW9O1S6uLazuPNmts+auxl24lki6kDPzwyjj+7noQTTuP FOmprVhpVrdWl1dXF21tNFFcqXt8Qyy5ZRk/8stuDj73tggG5RVKHWdLuL6eyg1Kzlu7cZmgSdWk iHqyg5H41DbeJNCvYrmW11rTp47VS9w8V0jCFRyS5B+UDB5NAGnRWPo/ivw/4gleLSNasb2ZN5aK GdWcBW2ltuc7c4w2MHIIJBBM1r4h0S9ExtNY0+4EMQml8q5R/LjIyHbB4XHOTxQBpUVQttb0m8sT fWuqWU9oHEfnxXCNHuJAC7gcZyQMepFPvdVsNOt7ye6uo0SytzdXAB3NHEAx3lRk4+Rscc7TjpQB coqvZ31vqEDTWsnmRrLJCTtIw8btG459GVh7444qxQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFZeueIdM8OW9tPqk8kSXNwtrCI4JJWklYE qgVFJJO09qANSisfw34p0bxdp0l/od59rtY5TCz+U8eHABIw4B6MPzrYoAKKKKACiiigAooooAK8 0u/+Pm8/6+rj/wBGvXpdeaXf/Hzef9fVx/6NeuvCfEzmxPwox7r/AFZ/3k/9DFFLc8r/AMDT/wBD FFaYr4kRh/hZ1trpeoT2OharpsdpPPZJcR/ZryRo0YSMPmDKrFWGzA+U5DMOM1NpPg57O70aS8Fp cJZWt8jps4SS4ljfEYI+4qiROcHBAxycSWGux6Vo+lWiWV5fXt1HK8VtaIpYojDexZ2VVALoOWGS wxmnS+OrTbp32PSdWv5b5LhhDbwKHh8hlSUSB2XBDNt75IwM5GeKfxM6o/Chuk6rb+GND0zQ9Qj1 Ka8sLKC3mktNKu54mZY1BKyLEQw/ycHIrNnh1PV/Ft/qWk6ZbS21zo9va79WgmtiP3tzuADR5OPl JQgZDIcgEZ7TT7631TTbXULRy9tdQpPExBG5GAZTg8jgis/V/EK6VqNnp6abf393dxSyxx2iIcLG UDbi7KF/1i4JOO3XAMlHPal4N1RLD7Lp01rdGbRF0eSW8laN4goYechVGyx35KnGSq88Uus+Dtdu 9UvJdL157KwuG3/ZlOATKBHOWG05wqh06/OzZwKseIPiVoPhp4Ir/wC0Lcy2gvTbtsikjiOeSJGX LZBGxdz5H3aG8YyaZqviRdQstQn0/TrtA11BChjtYTbQud3IZsMzsdoYgHnAxQBmeIPAWsXl9qKa TqawadqUUUckRaNTAEQINuYHZgAoYAOmCSQcnNdT/YMc3irUNUuobaaC506CyVXXc2FeZpAQRjaw kTvztORwM19T8ZWemXN8j2Ooz22nY+33kEIaK1ygf5ssGbCMrHYrYB5o1PxlZ6Zc3yPY6jPbadj7 feQQhorXKB/mywZsIysditgHmgDO/wCEW1T7Z9l/0D+z/wC1/wC1Ptm5vtOfM8zy9m3b/sbt33OM V0EGmzReKtQ1Rmj8i4sra3RQTuDRvOzE8YxiVcc9j075cPifUpPGV7ox8O3xtYYoGWdXt/lDyTKZ WzNnyyIwQAu/hsryoq5P4s062uJYHttZLxuUYx6LeOpIOOGWIhh7gkHtQBYg02aLxVqGqM0fkXFl bW6KCdwaN52YnjGMSrjnsenfD/4V1pX/AAkP9ted/pH2v7Xt/s6x+9v343/Z/M6/xb93fdnmtC01 XWJfF91p01hs0yPzvLufJcbtsdoyfMTtOWmuB7+Xx91s0Z/FrXXiXR7DT4LxbWTU57Se6eACGYxQ Tl41J+bKyIvOADtOCQGoA6a3sLO0lkltrSCGSX/WPHGFL/Mz8kdfmd2+rsepNcbpvhPWLS+8NRSp pZstDmlIuUdzcXCtDJHkrsAViXUsNx3HJyMYNjQ/if4a8Q6zb6ZYXDNJdb/szloz5uwFj8gYyJwC f3irnHFT6L8QNL13W/7Kt7a8iny4HneWp+XOSYw5kQcdXRR09RQBztp8O9bTybC81WO60y1iuY4f MZAZRLE8eHVIUcffyx81skZ64I3vC+g+IdP1Y3OrX8UltHbG3hgDpOwJZTkSeRG6jC/dJYHOc8Cp 9B8T6lqutanZXPh2+tYba7EKzO9viIeRHJiTbMxLEucbARhlzghsO0zxraaho7axLpup2OmCyN+L q6hUI0QUM3CszZAOcEDcASu4c0AWPD9hqulTXdncRWbae1zc3UNxHO3mkyzNLtaMpgY3sNwc9Bxz xStPCP2b4cReHlS1jv10drAzxDAEjRhXYNjOC4DHjnAJFW7XxUlxPJbS6Pqtrdi1e7gt54U33Eak A7NrEBssg2sVb5hkVVvfGUU+nXY0G3uL7UBo8mpwKLZ2ToRGj4wd7MGAQfN8jdOMgDBoE09t4iu9 eihhXUrVIZLfTS8xRI1f51OwM0p38YTPyIBkik8F6Xdz+HZ7rxFuvL7U8rci5txHvhUFEVoyBgFP mKkdZG+lb2jXV5eWMkt9b+RMt3cxKmwrmNJnSNsH+8iq2ehzkcEVoUARwwQ2yFIIo4kLs5VFCgsz FmPHcsSSe5JNSUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABXP+Mv+QHbf9hXTf8A0throKx/EHh2DxDFYrLdT20ljdreQSwpExWRVZQcSI68 byRxkEAggigCv4E/5J54a/7BVr/6KWugrD8L+FrLwnZXNrYySOlzcG4fdFFGA2xEwqxIiAYQdF65 J61uUAFFFFABRRRQAUUUUAFeaXf/AB83n/X1cf8Ao169LrzS7/4+bz/r6uP/AEa9deE+JnNifhRk z9v+uif+hiill+8v/XSP/wBDWitMV8SIw/ws7ex0NNU0TSrhL27sby2RxFc2pTeFc/MpDqykHap5 HVQe1aOn+G7HTbiwmgecvZ288C733eZ5zpJI7nGSxaMHPH3m46Y5q41drGx0Gyl1uPQ7Oe3nmmvm MQIKNGFjBlBQFvMJ5BOEOKjtdS1/X7jQrW215rISW+ovPcW9tE/2nyJ44Y3AdWCht2/jqDj0I4p/ Ezqj8KN22tte0OytdJ0fTNNutPsreK3gmu9UeKV1RAuWVbdgDx2PPXjoNC2sJrm9stW1GKO31C3t 57fybecyxBZHjYncyKSf3SdhjLDng0eGtRl1jwrpGpzqqzXllDcSBegZ0DHHtk1h+ItdS28Rf2de eJYfD1olok6Tu0KtcOzupVTMCuFCAkAZ+ccjvJRr6t4eTU7hrmHUr/Tbl4fIkmsnRWkjySFO9WAw WYggBhuODzVS78GWt5f6jcPqWorBqUqSXtmkieTNtjSMKcpuAKoM7WBOSCSMAU9Sm1fUdU0PT9K8 RLbxXWl3NzJeW9vFKJmQ24R1DZGMyk8HBBI9CMPx58QE0PUL6Gy1SaO606AO1qGtEjkk27wr+c4l cFSv+qGRnueAAdZqXhG01K8upWvb6G3vdv220hdBFdbQF+fKlhlQFO1lyAAc1He+GdO1i/v2XU7p Ip3RNSsreVPLmYIuBICpZSUKAhSuV25yK5jxZ4xm0PxFeJdeIFs7WEp5UVpNZuyDYpbzoZSJWOST iM5Klcc1NqD6rYN491qw1aS2XTrn7StssMbJOyWNuxDllLYIAHylSOTk9gDr7nQhNrqavBqN5aT+ XHDNHD5ZS4jRmZVcOjEcu/KlThjz0qGfwX4VuriW4uPDWjTTyuXkkksImZ2JySSVySTzmsO/8Q6x BqNzFFqGyNJXVV/4Q/UJsAEgDzEkCv8A7yjB6jiugt9HvIfEc+pvq08lrJ5m2yOdibkt1GPmx8pg kI4/5bN053AGpNPDbIHnljiQuqBnYKCzMFUc9yxAA7kgVhL4Qs01231RLy+UW9zJdxWgkXyFlkR0 kbG3PzeYx68HkYy2eO1rXTf3EUdx4lt4rn/hIraBdDPlBjFHfIqsBjzNx2CTOduDjHerukeMdQvv iC+lvOix/a7m2ezea1Xy44w+yRFEnnlmKAnKbdr5GAMkA6vTvDi6XcRGDVNRNlACILBpE8mIYIAG FDkAHgMxA4wOBUdt4Wjh1O0vbjVdSvvsbM1rFdOjLCWUoSGCB2O1iPnZuvrXJeFvGM154mstOvvE C3V3ch8w201nPauQhb935R85BgZBkBBAx1IrQ8O3Bt/Gmr6bfeNLu4uor0LBp11Jahp0NpC+4IIw wALMfk2j5SSCdxIB0sOhC21641S31G8iW6cSXFmPLMMriMRhjlC4O1U+6wHyjPfMlpoVla+GYPD5 Vp7CKzWyIlOWeMJs+YjHJHXGK5e3v9fj0LWvEb6s9ytlNqXlad9mjCOkMkyRruAD7sovOcEcYyd1 P0bVbi71d9KtfFcWsCewmke6iWBjZTo0agAIAMHzCQrgn5OSaAN3SvDkemXv2yXUb/ULhYfs8T3j oTFHkEqu1VzkquS2WO0ZNV/CXh19Dh1Ce5WJbzULuS5ljhkZ44QxJEaMwBIGSeg5ZuBVPwr4ivPE WoYZ1RNPtfI1CJQCPtu8q656jZ5Z9MiUH0xreHNHvNFsHt73Vp9TkbysSzZyNkEcbdWb7zRtIees h6nkgGxRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeaXf8Ax83n/X1cf+jXr0uvNLv/AI+bz/r6 uP8A0a9deE+JnNifhRlv/rE/66x/+hrRSt/ro/8ArtH/AOjFoq8X8SJw3ws7e31oaLoOjmWwu54L iSO3aeAx7YGklWNC4ZwxBZx90NjBziunrlLqyur7wJZpZQia4hmtbpYtwXzPKnSUqCeASEIGeMmq finTr3X49Ju5fDc95bxi4WXS554UeKVhiKYkOUO3DDhiw80EDIxXHL4mdUdkb99o1/d3kk8PibVb KNsYggjtSiYAHBeFm568k9fTitCxt5bSzjgmvZ72Rc5nnCB3ySeQiqvHTgDp681xl74fvt+mNrWk jxPDDp0Vu8IaP5Llc75tsrKrb+Oc7l28feNQeKtH13UDp1pa6Bpt1YxWaqiXcf2n7PMeG3Fp4+AA mHVXb73TPMjOuvdaFjrenabLYXZS/cxxXamPyhIEkk2MN+/O2NjkKRyOfTQM8K3CW7Sxid0Z0jLD cyqQGIHUgFlBPbcPWuSNjrcXhvwhcTWct5qelmGW9t1mTzJGNrJC+GZgpYNJnlsHB5qLxP4WsZ/F FlrTeEbXWlNvPDdosNuZXdjD5bnzSobasbr1yA3HGaAOyMjC4SIQyFGRmMoK7VIIwp5zk5JGAR8p yRxmSuPuLOa3+JVvqlp4XnMbWktrd6jD9mXzS7W5RmzIJGVBG4OVyP4QQaz77wQmpeLJr+90iCeG fWA8ryFTvtP7PEeCM5K+eq/L1yAcYGaAPQKK8c8OeEPGNlcaMdRtLVr2KW3lm1PylaZYht3wmb7R nhQ0e1Yip65yc11d/wCCdYu9RubmLxF5UcsryLH5moDYCSQPkvVXj/ZVR6ADigDoZ/FXh221A6fP r2lxXocIbaS8jWTceg2k5ycjj3rXrgL7R9eOlaz4dhsGkj1Ga6MeoCSIQxpcSF97qW8zfHuIUKMH AyR27+gAooooAKKKKAM/R9Ji0e0eFJ57iSWVppricqZJXY8s20AdMAAAAAAVoUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAV5pd/wDHzef9fVx/6NevS680u/8Aj5vP+vq4/wDRr114T4mc2J+F Gb1uIv8ArtF/6MWilXm6g/67xf8AoxaKrGfEicL8LOug8RQaKdFtr+5tLWwm02eeSe4cJtdJIFQA kgc+c3HUnGPfW1HxRo+k29pNfXLxfbATBH9nkaVgF3M3lhSwCjliQAuRnGayl8K2Wv22j3WoBJY7 ewmgWMp8ytK0REivnKMvlHBHPzZyMcmueC21230pru40+7vbASIZdQ01bmOVHABzGWAD5VDuB6g8 YbFckviZ1R2Rt/8ACQ6QH2nUbcA2f28SF8Rm37yB/ulR1JB4BBPBFZ03jvw5Atsz30m25t4bqJkt JmBjlJEZJCHBYqQAcEnAxkjNDxJ4Wl1Ky8P6RaxMsFu4jubqMRxotsI9kkRQY4kHyhVXAxnjAB0t T8Mf2jqdxefa/L87+z/k8rOPsty0/XP8W7b7Yzz0qRj5/GWhW+lQ6nJdy/ZJRIwdLWVyojOJC6hS yBTwxYDaeuKS78ZaDY6hc2VzetHLausdyxt5PLgLKrL5kgXYgIZcEkDqM5Bxzes/DA6tb3UP9o2b C4W6X/TNP+0CDzp5Zd8I8xdkg83bu5zsU4FXpvC2r6jqPiaGW/S10jVbpBJCYBI80P2aGNyjhxsL FXQ7lPC5AHUgG5feLPDemXklnf8AiDSrS6jxvhnvY43XIBGVJyMgg/jVN/F0P/CT2Ok28MdxBeJA 8d3HOCpWWO6kBAAIIxa9c8+ZntzcvvDVhqF5JdTXGqpI+MiDVrqFBgAcIkgUdOw569a1IIVtreKB DIUjQIpkkZ2IAxyzElj7kknvQBk/8JboX9p/2f8AbwZvP+zbxG5iE2ceUZcbBJnjZu3Z4xmo4/Ge gy3wtFvX8w3LWe820ojE6uUMZkK7A24YAJycjGcjOWnw/s4fEJ1KGLSNjXhvWeXSY5LoSF95Czk8 DdnGVLDPBGBjS/4Rj/iR/wBm/bP+Yr/aXmeV/wBPv2rZjP8AwDOffHagDoKz49b06X7NsuM/abuW yi+Rvmmi8zevTjHkycng7eCcjMkek6bDqk2qRafaJqEybJbtYVErrxwz4yR8q8E9h6Vg2/hG6g1q 0uf7XDafaajcahFafZhu3zLMHBk3cgNMxHAwMg54IAL2meMND1i7W3sLuSZnLLHJ9mlWKUrnISQq EfGD90noaj0DxP8A25qmo2X2PyPsefn83dvxc3MHTAx/x7bv+B47ZNHTvBclr4jt9YnurBpYC5D2 unLbzT7lK4mkDEOOc4Cr8wB7V11ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5 pd/8fN5/19XH/o169LrzS7/4+bz/AK+rj/0a9deE+JnNifhRnx83lv8A9d4v/Ri0URDN9bAf8/EX /oxaKeM+JBhF7rN95dRh8QeFTplpa3M7aPeBkubpoFC77QkhlRyT04x3PPFbWk+KDqV7ZWslmsL3 EV8zkTbgjW06QsB8o3Bi5IPHA6c8Rx6f4f1a10aw1fTrG+ujZtPbpdWqy7UXyxIQWBA5eP68dcca Vz4Z0C9gt4LrRNNnhtgwgjltI2WIN97aCMLnAzjrXLL4mdEdkY9t4im1E+Eb2XR7Q2mroksUrXJa W1ma2ll+VfLwRsVl3BgfnPGOsniKws/+Es8J6j9kg+2/2g8H2nyx5nl/ZLptm7rtzzjpmtC68J+G 77yPtnh/SrjyIlgh86yjfy41+6i5HCjJwBwKualpOm6zbrb6pp9pfQK4dY7qFZVDYIyAwIzgkZ9z UjOS+IWr3p0DxPpNlY28qw6HJcXM09yYyqSLMvyKEbcw8pjglRyORT9Z8eXmnavqNjZeH7m/WwYJ IYo7lmkYxLIFTy4HTOHA+Z198DmtHU7LwlJqWm6LqWiWc0skYiskm0syQqqq7CNZNhjUhUchMg4H TkVfv/C/h/Vbo3Wo6Fpl5cEBTNcWkcj4HQZYE0AVb3WdY/4SKfSdK0uxufs9pDcyS3V+8H+seVQo CxPn/VE5yOtZ+t+Nf7I1iex+1+FI/K2/Lf6/9mmGVB+aPyW29eOTkYPfFdYIIVuHuFijE7oqPIFG 5lUkqCepALMQO24+tR399b6Zp1zf3knl2trE80z7SdqKCWOBycAHpQBj6R/bt1qa6jPfWMmkXETS RQ2sglA3R2+zbJsG5Qy3J3dxInHZa+k2FnYfEPxB9jtILf7Rp9lPN5MYTzJGlu9ztjqxwMk8muor PutC0e+1GDUbzSrG4voNvk3M1ujyR7TuXaxGRgkkY6GgCnpt/NN4q1ayutNtLeeC3t5EuYZjI08L vOED5RSpBRztywG84PXOfZeK9SudUs45dItY9Pu9TutOinW+Zpd0Hn/MY/KAAP2dv4zjI61sQ+Gt BttUOqQaJpsWoF2c3aWqLKWbO47wM5OTk55yauLYWaeXttIF8qV548RgbJH3bnHox3vk9Tub1NAG PZeJxeaZ4WvPsmw69s+Tzc+RutpJ+uPmx5e3t1z7VX0bxVdar4lv9EfTreGXTsfa5Fvd4+YZTyxs Bb/azt2n1rRsvCnhzTLqO6sNA0q0uI8lJoLOON1yMHBAyMgkfSrFvoek2j2722l2UL22/wAho7dF MW/723A+XPfHWgCtpFvrsN/evqt7BPavn7MkYAKfv52GflH/ACya3XqeUb6tsUUUAFFRzzLbW8s7 iQpGhdhHGzsQBnhVBLH2AJPaq+l6paazYLe2TyNAzun7yJ4mDI5RgVcBgQykYIHSgC5RVOXVLSCw gvZnkigneFE8yJ1bdK6ogKkblJZ1GCBjPOMGrlABRRRQAUUUUAFFV3vrePUYbBpMXU0Uk0abT8yI UDHPTgyJ+fsasUAFFFFABRRRQAUVXsL631PTra/s5PMtbqJJoX2kbkYAqcHkZBHWrFABRRWemtWT 642jbp1vliMwV7aRUdBsDFZCux8GRAdpOM80AaFFFFABRVe9vrfT4FmupPLjaWOEHaTl5HWNBx6s yj2zzxVigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK80u/+Pm8 /wCvq4/9GvXpdeaXf/Hzef8AX1cf+jXrrwnxM5sT8KKMHOoWv/XzD/6MWiltudStB/08w/8Ao1aK Mb8SDCfCzV1i33aj4VuLiLWTYJpdyk8mlrNuUsbYqrGH5wCVJwvJ2+gNMvv7b/sTQv7R/t77P/pX mf2fv+1b8n7L5vl8/wCrzuz8u/bu4roE8S2OirotnqM9va29xpzzm6uJ1jRDGYVC/Nxz53r/AA98 8bN1rGmWNrDdXeo2dvbzsqwyyzqiSEjICknBJAJGK5pfEzojsji9T/tf/Qf7dGtj/iVRbf7F83/j +583f5Xb7m3f8n3s0/xBpE9zZ+FNU1mPVZLu2kjGpLplxc/Jm2mVmWOFgc+Y6gso3bSRnbkV2N/r Gl6V5X9o6lZ2fnNti+0TrHvPou4jJ+lUNa8YaD4ev7Ky1TU7S2nu3wqy3CJ5a7HYSPuYEITGVB/v EDvUjKWtEQW3hfULe3v57OxvFmkHkyy3CxNazRBmQgyswMiZyC3UnkGsfxJ/a/8Aa+qeUNb/ALQ/ d/2J9k837L9xc+dt/d/6zfu8z+HG2uxuNd0ezs7e8utVsYLW5AME0twipKCMjaxOGyDkYpbzXNI0 64W3vtUsrWdtu2Oe4RGO4kLgE55KsB64PpQBwPjvU/EaajfrpejapJPawBrGW2u7lUkIXeX8uOEx uQxKlJHydowBu5Tx9Bf3Vt4mt5ItfmnltDHpUWnLM0DoYcOHCfIWL7wQ/O3bt5rvr7XdI0udYdQ1 WxtJWQyKlxcJGxQZJYAkcDByfai717R7C9jsrzVrG2u5ceXBNcIjvnphScmgDgpJ/Fa+NNjWd5v/ ALUXZOt3cm3NkXA/1Qh8gHy85LOH3c+gro7HR7q88T63fXd9q0SQ6hF9iiW5dIfLFvAWwn3XVmLq cggENjDZNdVWPb+JLO58Rz6Gkc4uofM3OVGw7Et3ODnPS6jxx2b0GQDn7/TPHcmo3L2ep7LVpXMK /wBowLtTJ2jB09iOMcFm+p610GneG7PTPEeta5DJO11q/kfaEdgUXykKLtAGRkHnJP4VsUUAc3pk Y13xFNrksUZtbLzLTTieTu3FZpRxxkqEGOyk5w+KxdG1PVpovBumzWusrd2kgj1aaaCVUYraTKd0 hGJA0m0hgSM7ckEiuusNQ0b7Q+k6fd2HnWi4ezt5E3QgcYKA5UfhSWev6NqNz9msdXsLq48sS+VB co7bCAQ2Ac4IIOfegDhfCcmur4js4by01aZvn+2Xk9zdRp9xsFoZEMPLbcCF+Ce4BroPBOk3Fh4c 0vUdS1DVXv5dOjN4l/cuwDlVY5R/uMuCOMHk7snmrek+N/Det6nPp1hrNjNdRS+UkaXUbGf92sha MBiWUBiCfVG9Ktprnh/VLe6iTVNMu4Eg8y5RbiORVhIzucZI2kdzxigCj4bhOo3Nx4nuYVWW+RUs 8jLR2g5QHI4LklyPdQc7aq6FOlrp+r6Rf2upxSR3N/cO0VrOA8MlxJIpilReXKyDCod+c4GRXTrc WyyQ26zRB5Iy8UYYZZFwCVHcDcvI6ZHrT5po7eGSaaRI4o1Lu7sAqqOSST0AoA88nlv9V+EGmxm3 1l9TgOmrdK1rKl15sc0DSMokUFiMMd/K5BOeDWrol/8A2XDrd+51UaDbxJLAdT84z7wGMoUTfvCv +rwD1bdjjFdQ+o2MTypJeW6NCyLKGlUFC5wgbngsSAM9c8U25l0+VZ4LqS1dYFWaaOVlIjGSyuwP QZQkE/3fagDmxptxaeFdX1C8guV1nUQZ5hpxJnVukMSMACdg2rz8udxPBNYzt4tTwIhnhup9UGqS /wBppHNNCWh3vjyGVXcJjyseWCdu7GGzXW6b4n0/VtVvbaxubW4tbW1huTeQXCyI3mPMpXI4G3yc 5z/F2xzb/teC40k6jpS/2vHnCLYTRN5hDbTtZnVOOc5YdD34oA4fS4df1Kw0u3ujqtnatrcg/d3F wZRafZJDiSSREk2mXgF1BHy4OQDW3a3d14c0/XI5FvLtINQSDTEu5XZ5/MihKqJGyzL5ruu45wAf 7tbthrNnfeHrbXN/2exntEvN9wQnlxsgfLnOBgHnnA9asJ9j1GG2uk8i5i4nt5Rh15Xh0PurHBHY +9AHnuoaCNI1XQDdR6rJGbW+k1K60iOYNJcSPbsSxh/eYZlOAOcIB91TVqX+1v7J0P8Atka19g/0 j7T9i837V97/AEbzPJ/ef6vO7b/HjPGa25PG2lwapHb3MsVpZst1/pt1MsUZaCSGMhcnkFpWGSRz GeDnNbF3rGmWFil9eajZ21o+NlxNOqRtnkYYnBzQBxcn9r/2RoX9sjW/sH+k/afsXm/avv8A+jeZ 5P7z/V53bf4sZ4zUV/p15daF4WvdZi1p/sd/M032WWcXK27RzpEzrAQxfBhDEAkZcdC2e5u9Y0uw sUvrzUrO2s5MbLiadUjbPIwxODmqOr+LdD0M6YdQ1G2gj1KRkgmedFTAjZy5JI+XgDIzy6DvQBR1 dhqGn6d4csPP2ajADM9w0gljs12iQtv+fewYJ82GyxJ5U1T8Qwy22qxQGLWItLjsVSwj0ZZFC3AZ gQ4i4AC+Xt3/ALv72a6Wa90y3sJdeLwNbi181ruPDb4QC4ww+8vJI7c8damgv4JlUMwhn8lZ3t5W USRK2cbgCccgjPTIPPFAHmUkGsWvg/SLeSHXIWi8NwJYxWKzrsvxGQVnEXzDH7sDf8v3881r32ka nf8AiyZnutcitJtYFuwgupo4xa/2eH3LtICjz1A3DHzEjPJB6y48S6DaGMXOt6bD5sQnj8y7Rd8Z BIcZPKkKxz04PpUKazcnxVDpb2lsbK5s5bq2u4rkuziMwqwZNgAyZuCGbIXtmgDmPCeqX2i6fNLr unas99qK2t3mKxllLv8AY7eN1YqpCOHjfIfb2qWxt7nwzF4Olv7O7dLHQ5NPuTaW73JjmItiMrGG Yj9y4yBjp611iaxZy642kw3ljJdRRGS4txcgzxfc25iHO0hsliRj5eDu4SfX9GtbxbO41ewhumkE QgkuUVy5AIXaTnOGU49GHrQBx/8AxN/+Eg6a3/a39q/9NfsH2HzP+/WfJ/4H5ntVPUdT8RyeL42t 9G1SIpqcMLSLd3LQi181UZ/K8kQMGQlj85ddxOQFIr0X7fZ+R5/2uDyfN8jzPMG3zN/l7M/3t/y4 67uOtZ//AAlnhv8AtH+zv+Eg0r7d5vkfZvtsfmeZnbs25zuzxjrmgDidXgv7nUUS4i1+XURr1s+2 JZmshaLdIyHj91wgUk/fDA5+UGrmnS+KR8Rmjura5W0NzP5kv2iVoGtdrGHanliJWyEyQ5fO7IwR j0KqqalYSTiBL22aZneMRrKpYuoyy4z1A6jtQBz/AIZ0e682fU76+1b7V/aN7tgmuX8ryfPlWNfL Py7du1lOM9MHbxW1aar9r1jUdO+wX0P2Hyv9Jmh2w3G9d37ps/Nt6N0wakg1fTLq/msLfUbSa8g/ 11vHOrSR/wC8oOR+NRWev6NqNz9msdXsLq48sS+VBco7bCAQ2Ac4IIOfegDz3wWb/VNM8P8Al3Pi Nprqw/4m1xeSzCMo0J2PE7fLv3lCDHzjcW5roPB15req6hcNq4MJ0hDpsixzFkup/lZ5sYHBUR7c 8je4+vXwQQ2tvFb28UcMESBI441CqigYAAHAAHGK5691TS/CWmapb6XpUUa6Zp0movb20awxAAMQ pwOGco3Y/dJPbIBd8OeG7PwxYPZ2Uk8kbeVkzMCf3cEcC9AP4YVJ9ye3A2Kp2OrabqZmFhqFpdmB tkogmWTy29GweD9ajtNd0i/iuJbPVbG4jts+e8NwjiLHJ3EH5eh6+lAGhRWaviLRH0qTVF1nT206 Ntr3YukMSnIGC+cA5IHXuKh8O+KNH8U6dHeaTfQT7oo5ZIVlRpIN4yFkVSdrcEYPcH0oA2KKy5PE OmwPqJuriO1t9PaNLi6uHWOFXcAhdxPUBkzn++vU9HrrNlFpNpf319YW8dxGrrILpWhYlC52SHbv G0MQcDIBOBQBo0Vj3nifR7fRP7UTV9K+zSZS3nmvkjglkwSF8zkdj0BIweDipPEPiHTfDGjT6pql zHDBEjFVZ1VpWCltibiAzkKcDPNAGpRWVH4n8PzWP26LXdMe08wxeet3GY94XeV3ZxkKC2OuOall 13R7fTY9Sm1WxjsJceXdPcIInz0w5OD+dAGhRWboerpremtexoqILm4gXa+8MIpniDA4/i2bvbOO etW7i+tLRkW5uoIWdWZRJIFLBRliM9QByfSgCeiqF3rek2EFvPeapZW0VzjyJJrhEWXPI2kn5uo6 Ul/r2j6W+zUNWsbR8KdtxcJGcMSF6kddrY9dp9KANCisbVvEtlo97Y2s6TSPeAGJogpUZnghGSSP 4rhDxngN3wDs0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFeaXf/AB83n/X1cf8Ao169LrzDUZGjmuykLyn7XcDahUEfvX55IrrwnxM5 sT8KK1oM6pZj/p6h/wDRq0UlgxfUrFmjZCbqH5WxkfvV9CRRSx3xIeE+FnUT6RqlxdeGtY02DTrg 2OnzRNFeSNHkyiHBVlRsYEbZOO+O+RWk8HanbafpItBpl1cWq3cc0F3vWBRcncxQAMfkOFUEDKFh kZq7f+MdN8KaRo0d9kyXVtuiXz4YQQgTd800iL/GvGc9eOKc/j/TBo2l6rDaXtzbaldPZwG3Eb/v gzKFJD4wzIwDAlemSAc1zy+Jm8dkVpPC2p6f9n/s4WGoY0iLSpf7Sd1wE3fvBhW3bt3zKcZ2r83F XrrQL+20fw5DpskN1c6JIjD7ZI0YuALeSA5YKxUkSbs4PIpNd8S6jpWoaJb23h+9uUv5tku14Mj9 zK/lrulX5wYwSTldu7BJwKt3/iOSyudOtE0TUrq9vbeS4FtA0AaFUMYYOXlVcgyqPlLd6kZzvjTw nrvieJ/L+ygzaY9r5J1GeBLaZwd7Bo0zMp+QbXCg7BxyRXR/2DHN4q1DVLqG2mgudOgslV13NhXm aQEEY2sJE787TkcDNLxN44sfCenW15qdnOvnRNK0P2i2SSPaASu15V3tyRiPfkj3GdC+1m/tLySC Hwzqt7GuMTwSWoR8gHgPMrcdOQOnpzQBxHjvT9WB8Q6bp2kjUf8AhILddkjQyMYpAnlhAwUoANob LsgUsSN3StXxJ4O1DVNQ1B7FLaFb4qzXX9o3MZRgipl7cZimwEHDbRjgjqTvG91+TW7NY9Mjj0uR IWnaZl82IlLgyKdrkZVlthxkfO2Ceq7lAHD3/wALtH1DUbm9lnxJcSvKw/svT3wWJJ+Z7YsevViS e5JrsEsLOO8a8S0gW6fO6YRgO2QgOW68iOMH/cX0FZ9vca63iOeCeygTSF8zypwRvbCW5TI3d2a5 B4/5Zr06tsUAU49Mgi1SbUVkuzPKmxka7laIDj7sRbYp+UchQevqcyQ2UUF5c3SPOZLjbvDzu6Da MDahJVPfaBnqcmrFFAHBeG/As2h6rYO8UUkVh5nl3b6pdyvJvUgnyGPloxzliCwJzgDjGjpXhOXT dI8G2qi0SXRdv2po8gP/AKLJE+w45zI6tzjOM9eK6yigDBsbDVdP8S6nKkVnLpmo3C3LymdlmhYQ RxbQmwqwJiU53LjceDjlfDPh2DRfC2k6ZPbWrXFpYpbSvGmVY7V8zBIBIZlyc9eM1u0UAcB4O8PT XWn6udQS8S1kWTTdM+2RfvFsedpMcu7kliP3i5IjTcMU+P4Yafp6XE+nywPeG3miiW40yxSMs8bJ 85it0fb83IDDI45BIrvKKAOS0fwYLDw/qnh+7uDdWN0xMd07n7S25QCZGxyykDawPQKONvMFt4R1 ObwleW+qXVtNrl7NHcXEylmhcxOpjjOcHYVQBhj+Juua7SigDhZvDGv3r+IrqUaZZXGq21pAsdtM 7AiJ5DIruUU/Oj7dwXIB6fKCbXhbQ9a8N6Pq4FvYy3d1fm5t7dtRnkjVCkaENNIjOT8jH7pBJHQH jsKKAOX0bSdYs/h4mh3lrpT31tp4soUaV57afbEEUygopCsc7lAPHc5qxd2+rw+D7TTrO2gh1CSG K1kawIjhs8qFeSMMQdqDO0DJ4UY6kdBRQByV/wCGru01TQbrQrTT5INKtLi2WC9mdT+8MWCHCuc4 jbLEEnPuSIYfC2p6Zb6NPZCwuruw+1b7ed3ih/fuHPlsFYrsI2r8p+UkcZrs6KAOLg8Lanpdto09 mLC6vLD7Vvt53eKD9++8+WwViuzG1flPykjjNSp4Z1Ow0TQ47JrKa+02+lvTFI7RQt5izK0asFYq q+edvynhQMV19FAHPalY32tX2l2l7aGKwiAu7wxT5jkmXGyEfdZlDZckqAdijuQIPFvhq81ua0m0 65S2kbNpeszspe0cgyKu3+PgbScYyeRmuoooA5DWPB76hqU8sSWYtmTS4445AflW2unlkGMHgowA 9TwcDmm2nh/W9JsfDElmLC6vdK0s6dcRT3DxRyblh3MrhGPDQDGV5BPSuxooA5u8s9ek8a2OpQWe mtp9tby2pZ711lZZWgZn2CEjK+UQF3fNkcrVfUfCct5pvjOJBafadc3fZpGz8n+ixxJvOMjEiM3G cZB68V1lFAHEy+HfEHknS4jpv9nDWV1ITtK/msn2wXLR7NmAQdwDbjnAGBnIuCx8RTeIGuL6w0y5 s0uQbc/2lKvkxAkB/J8na0mCTy3XABAGa6qigCnHpkEWqTaisl2Z5U2MjXcrRAcfdiLbFPyjkKD1 9TnEstAv7fxrd664sfKulaFo0zvRAE2ODjl2KkOOOBGMnZz09FAHBeG/As2h6rYO8UUkVh5nl3b6 pdyvJvUgnyGPloxzliCwJzgDjGjpXhOXTdI8G2qi0SXRdv2po8gP/oskT7DjnMjq3OM4z14rrKKA MSwvNffUdce/02OPT4HVdMjjZfPuAF+dmO8qAzY252nH3sVm/wDCNXl34G1u0m2prWt2s5uGllLL HLJGVVMjOEQFVG3jCk4yTnraKAONXwtqOoG6F/8AYdPB0mXSof7Odmyr4/eHKrt27RtUZxub5uah k8K6vqVvfC8TTbGVtGm0qBbCRyrbwMOxKDaF2jaoDY3Nyc13FFAGDoWl38Gq6lqupR2kE96sMf2e zkaRFEYbDFmVcsd+D8o4VRziqej2/iHw/wCDxpzadaXdxp1nHbWP2a6JNyVXYGcOqCPopOGb+LHQ A9VRQBjWGmXOgeHVtdOSO9vl+d3u7hoxcSscyOzhXIJJY9D2HA6ZOneF71dA8G2OoJZGTQ5ENwqS NIjiO2lhRkJQc7mRsEDHPJwM9fRQBx2seHNWk0TxZY6bHYM2uTP5fnTvEsMb2scTMdsbZbejNt6E HO4HitjUtPvte8H6jpl6lvZ3l9aTWzCGVpo4y6soIYqhPBB+6PT3rZooA5ufStU1qTRJtXtNOifT 9RN1JHDcPMjqLeVFYbo1w2+RTjHAXO4nin6vot1/aOnalpFvYvLZ+ev2W5cxRt5xUs4ZVbD5U87T kO/TOa6GigDl9C8KG28KQ6RqcjI8d1cXH/EsuprZR5k0jqAUZWwFcDaTjI74BpPG/hm78U2lhbW8 0EKW1w1yzSkkOwidUQqB8yMX+YE/dBGDnjqaKAOK8R+ELrWNUi1MQRTyvZC0mtjqtzaJGMlmKtCP nB3YIZRkKvI5rR0rwwtlqz3NxFayRf2Raacijc5HltMXHz5O0h06sSdpz0yekooAxND0CKz8OaJY 6lBa3V5p9lDbmUoHwyCMkqWGcb40btyqnqBW3RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5Zq1ol5JdRyHAF5O33Fb/lq/8AeBHe vU680u/+Pm8/6+rj/wBGvXXhPiZzYn4UZ+mQrb31hEpyq3UOPlA/5ar2AA/SipLP/kK2X/X1B/6N WiljfiQ8J8LO5TQrHWNJ0qS6FyssFsBHLbXctu4DKu4bo2UkHavBOOB6U3UPDOg3Vrp1hqXnTJFK /wBkW51CZnaQqxJDM+53C7yCSSoBK4xWdrGvTeFvD2ja1IJZNKgiWO/iiRSwV0ARxnB4cKuAejk8 4qveeILrQl8IS+INcgsJry4lF/BO8KIUMEkmCSMjy3ESBlIzuGclhXPL4mbx2Rva9ZaGNJt21q7N raWUivFcyahJbtG+1owfODq2SrsOW5yc5q/HpdpFcWlwEkae0t2toZJJXdhGxQsCWJLEmNDubJ46 8nPN+MNOubzX/C5i1m+s0fUGjEcCQFVYWty28b42O7jbySuOQAcGrHiS+8VW2oxpodj59qYgWb7H FLh8nIy93CemONp+p6CRh4q0bwpMW1DxJdLZpPELJ5ZNTktElT5z5bbZFVs7n4OcjPpWhfeE/Dep 3kl5f+H9Ku7qTG+aeyjkdsAAZYjJwAB+FY80uozyeDJNWi8q+Oqy+YnlLHj/AES7x8qyygcY6O34 dB2FAEcEENrbxW9vFHDBEgSOONQqooGAABwABxipKpyWcz6zbXq3ciwQ280T2wztkZ2jKuecZURs Bwfvnkd+Lvr3XrnxZNaW2vT2lrJrA05I47eFvLT+zxc7gWQktvBHORhjx0wAegUV47pPxNvdSfQr gTX63F1LZwT2bR2ghAkZEeRlDmcAliyNgKcqMc5rrLfXJZvEUsF94j/s67S+MEOjmGP99CHwrcqZ H3r825WCrnkfKaAO2orh7/U/Hceo3KWemb7VZXELf2dA25MnacnUFJ4xyVX6DpWSLuU+IHhN3qX/ AAkQ1oAWgv5thtPtByxg3eWIvs2CHxy+Rww5APTqK8q0q8R4tGSPUdSk8VG5thfWb6pO7I3mf6V5 luXKJGE3lWxg/LjtntdI1D7R4v8AEdl/bn2z7L9m/wCJf9k8v7DujJ/1mP3m/wC9/s4xQB0FFeXe HvFmq634gttLvjfpJeedFqFkz20YsgEYgxmKT7QhBAUM/XdkFTgVueGNLjutdl1m0udXXSoVaC0S 51S4nS6fJDzbXkYFOMJkc8tj7poA7WiuPs9Tvrzw74tfS9ZOsaha3d5DaqLQQfZpVT5Lfn/WbWI+ fvn2rj7fUptOWW60zVxrd+lhczLbwX97K1pIkLMvnRyTMrZYBcFEO5gQvHAB7BRXP+GL63vRdfZv E/8Ab0abMybYv3THOV3RKqnoPlI3DueRWVpviYQfC9NdOsza98rgajDYrAzkylA3lMVVVQnnJAwh OaAO1orzrwz4x1TUYdfSxgvdZlsoIJrRbiS0V5nkMikCSFvKMYMYOc5HzDkgZTwzf6rbeHvGY1a8 1Kxns5nlN/fCO4+zM1pHIxSNHcbUYlxGONrqBk7gAD0aiufW60648DWd3q2t7rGW0gkk1PzmsPNy FIk3KymPcSPlBH3tvtXJx6jb678L/DN0fFyWbQpbi9vPtErBpfs53RzvFLGyncwY7nHKrnrQB6ZR XmUetjT/AATrrReJRZ29pJCyeIohPqERLsoKqkzyE4wFIVmUeYDnOQNjx5fw6bd6XcX1zcLp5SeO W3t9SNi0jkxlWEnmRqSuGG0uCd5Izg0AdrRXlN5qGz4XeIL++vL/AEqISTyaI1xq0qTsRb/IPML7 pCZBIQhLA4GNyhTXfzeKdDgtNOu/7SglttRuls7Sa3JmSWZiQFDJkdVYZPAxyaANMTwtcPbrLGZ0 RXeMMNyqxIUkdQCVYA99p9KkrzrxFqSaf4/1EyeJP7FDaNasjeVG/nuJbnavzqc9T8q4Zux4Nakt 3r2qaj4btBfS6M95pU93fRxQxu6yKbcBQZFYAgysOh4z3wQAdbJPDC8KSyxo8z7IlZgC7bS2F9Tt VjgdgT2onnhtbeW4uJY4YIkLySSMFVFAySSeAAOc1x2veIIvDviDw5FqHiy3gMreVfWszwRRunkT HzyGG9MyIg4fb26nnC+IutTrp3iuyudc/s7y7F47Ow8qM/bo2hy78gueS6/IRt2ZORQB6lRXm3jb xRf6X/wkTJr/APZNzY22/TbTyI3+2Dytxk+dSzYbcvykBdmWBBqPxh4z1jR/EN9bRfa4Wt1jbT4E +yCK+yoJ3ea4lb5spiIZGM85xQB6bUcM8NyheCWOVA7IWRgwDKxVhx3DAgjsQRXF3+p+O49RuUs9 M32qyuIW/s6BtyZO05OoKTxjkqv0HSsbQtantb57a01zzrpvEN3CdF8qP/UNeSb5c43/ACgs+7dt +XbjNAHqNFcrY/21qXifW2GtyQWWn6hFDFaLbxsrp9ngkcMxG7kyNggggnnIwK5sXcp8QPCbvUv+ EiGtAC0F/NsNp9oOWMG7yxF9mwQ+OXyOGHIB6dRVOys5ra61GaW7knS6uBLFG2cQKIo02LyeNyM/ GOXPHcx2et6ff6tqOl21x5l7pxjF1HsYeX5i7k5IwcjngnHfFAGhVPTdW03WbdrjS9QtL6BXKNJa zLKobAOCVJGcEHHuKuVz/h7/AJDniz/sKx/+kVrQB0FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAV5pd/8AHzef9fVx/wCjXr0uvNLv/j5vP+vq4/8ARr114T4mc2J+FFOz/wCQrZf9 fUH/AKNWiiz/AOQrZf8AX1B/6NWijG/Eh4T4WelaR/yBbH/r3j/9BFRaxrMejxW2bW5u57qf7Pb2 9sF3yPtZyMuyqMKjHJI6VgaxZao3h3SNV0GET6vYRL5MJdVEyOoV0JbgD7r/AFQUy98D2c1v4Vsr nT7bU4tPu5Hu5LqJH3K8E29iGHO6Zo2IA64OPlyOaXxM3jsjqI9Shl1m50tVk8+3t4bh2IG0rI0i qBznOYmzx3HXtcrgvEvh+W98X3d/N4X/ALatZdMgt4G8+JfKmWSck4dhjAdfnHzDPyg5OLN74Q1u +ttNDeIPLnt7KKC4ffeDzZVB3P8AubmJeSe6k+/QCRmp4sk0z7LYWupaB/bn2q78q3tPJhk/eCKR 9375lUYRH5znnHeugri9QtbjQbTwqbtru/Fjqcj3E1rb3NwwVre5UEqWllxl0XJY9R0GAO0oArvf W8eow2DSYupopJo02n5kQoGOenBkT8/Y0PfW8eow2DSYupopJo02n5kQoGOenBkT8/Y0PY28mow3 7R5uoYpIY33H5UcoWGOnJjT8vc1yPifwtYz+KLLWm8I2utKbeeG7RYbcyu7GHy3PmlQ21Y3XrkBu OM0AdtRXn32Vrj4jT6DbXBk0lHTWLuNBkQXAbKxMcYG9tkwUndlWPQ1n6Fos11fPc2mhmG6XxDdz HWvNj/1C3km+LGd/zAMm3bt+bdnNAHqNFebL4P1FPG51OddVnnOo/aEvYpbNYVg3cRFmTzwoT5Sg JVsZyM8bP/CI6r/wkP8AaP8Abv8Ao/2vz/s++++7v3bMfbPL6cf6vb/s44oA7CiuL0Dw9qVp4iMV 4pGjaRv/ALJbep8zzc5yByPLUmMZxkN3qt4e8GHRLLwbPBpsdvqVtGkWrTKy7yn2WQFXbPzgS+Xg AnGBjgUAd7RXE+GdDk06/tvt3hwtqkW/7RrvnRn7QSCN2Q3mHdkfIyhV7fdFbGkX03inR9RXUtGn sLWSea1ijuNwe4t/uiQoyqybsn5SMj8aAN6ivOR4a8Q3nhrxJHqUZm1AaXPpGmgyJ+/j2HEpI4Vp G2ZBxjYOlXtW8Hvby3i+HLSOz+2aJe20s0bhN9y3leQznOWb/W/PyeuTyKAO4orhW0R20K7TSPCY 0iVLqzuVtjLCn2loJ1lYARsyAkLgMSCSecACodS0fWPEV5qc9xo01pb3P9kRpHJcx+YUhvHkmJKO QpCNngnIxg54AB6BRXCX/hSeym1VNC0yGGyP9m3cFtCyxJLPBctJKAOisyJEMkAE454NVLnRNV1n TdYm1HQ76D7VrIuksorm1aR4VtY4VLB90T/MudjHGQDk4GQD0aivM18H6u3gp9NEVzbwf2n9oNnE bVJpbbYB5bKFNuDv+baAEIUA8kmrNt4XvbfwpDZDT764tI9S+0y6VeTW2+aDYR5YEQWFVDkOEzg7 eTzgAHb2WpQ311qNvEsgewuBbylgMFjFHLleem2RRzjkH6mPWdastA057/UWnS1TJd4baSbYACSz CNWKqADljwPWuF07wVqs0WofZx/wj0EmovPBa+fO37poIFH/AB7XMYGDG42ksB0XA5bS1PQ9YsPh 5rOjxLPrd9qEU8EZhlceX5kRUFjdXDnaCOdrfxcL1JAOwvb630+BZrqTy42ljhB2k5eR1jQcerMo 9s88UXNhbXk1pLcRCR7Sbz4CSfkfYyZ9/ldhz6+oFVxEmt6ZD/aGnT2371Jvs07rvR45A6EmN2X7 yK3DH0PcVoUAZesa0NGNm0lhdzwXFxHbtPCY9sDSSJGhcM4Ygs4+6Gxg5xWpXN+MZS1np9lHb3c0 8+p2Tr5NtJIqrHdQu5dlUqgCgnLEZwcdK6SgAooooAytV8PafrTk332t0aMxNCl7NHE6nOQ0aOFb OTnIOfwFatFFABRRRQAUUUUAFVLHTLPTWuWtIBG11M1xO2STJIepJP0AA6AAAcVbooAKp6bpOm6N btb6Xp9pYwM5do7WFYlLYAyQoAzgAZ9hVyigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACvNLv/j5vP+vq4/8ARr16XXml3/x83n/X1cf+jXrrwnxM5sT8KKdn/wAhWy/6+oP/AEat FFn/AMhWy/6+oP8A0atFGN+JDwnws7mPXLHSNJ0uO6Nw0s1sGjit7WW4dgoUMdsascDcvOO4qj4f 8SJqNppr3d7dJNfalfx2q/ZGQSpFLOFjkyn7siNQ2DtYmPvhgbSaJ/aVjpF5DqN5YXdvZmJJrURk 7HEZYESI46xp27VCfBSrZabbwa9q0MlhdT3iToLcvJNMZCzPuiK/8tZAAAB83QkAjml8TN47Iu6n 4s0jSdUXTLl7tr1ohOIbawnuDsJKgny0bHKn8qot4qgtfE11DdTzLaPp9lNa24tXMzSSPc7sRhfM J2xrlcfKFJIHNT+JfB9r4oZftl5MkSptES2trKAecsDLC5BOR0I+6PfMbeBtLdopnmu3vYLO3tIL 1mUzxCEuVkViv3yXO7OVbABGMgyM0tR8QWWlzpDcQ6k7MgcG20y5uFwSRy0cbAHjoTnpxyK8R1/x Nrcvi547TW9VtrRpLiURB3jO0SJtUq4ynDEYwCPbFe2Xvh201F4pLq61QyxxiPdBqU9sGxnkrE6L uOTzj9ABXi2u+EtbPieaeysL9oIZpo1aS3lmMkbODneTknCj5iWznJzXRh7XdzyM2clGPL5/ke36 DI83h3TJZXZ5HtImZ2OSxKDJJ7mpJLyZNZtrJbSRoJreaV7kZ2xsjRhUPGMsJGI5H3Dwe0egxvD4 d0yKVGSRLSJWRhgqQgyCOxrQrCW7PTpX9nG/ZGFH4x0WW7a2WW7ytybQytYTrD5wk8vYJSmwnf8A L97rWbo3jS18qSHVJL37R/a1zZJL/Z03k/8AH28UK+asfl9Ni5z16nOabpHhG6MMv9panqCw/wBr XF8mngweSMXjzRNkJv5+Rsb+pxx0Gz/wjdn/AGV/Z3mT+T/aH9obtw3eZ9q+046fd38Y67e+eaRo OHiTSi0q+fIHivhp7IbeQN55AIUDbkjDBtw+XHOcc1pCZWuHgAk3oiuSY2C4YkDDYwT8pyAcjjOM jPMroEtx8RZdZkhnhs7e3QIGdClxcYZfNVRlgVjdkJbGc8DABPTCNhcPKZpCjIqiIhdqkE5YcZyc gHJI+UYA5yAUJdYUeIoNGggeWUwm4uH5CwR8hCTjBZmBAXIOFY9ucSXxjbX2t+HbXSpbsxXt24kk ewlSKaEW0zjbI6BT8yoflOTj0zWvoOlXGnx3VzfzifUL6YzXDL91OAFjTgfIqgAZGSck8k1RsPBs dhcaSRrOpzWukn/Q7OXyPKj/AHTRDJWMOcI7Yy1AE8PjLRbgp5ct2VlUtDIbC4CTAIz/ALtimJDt ViApJOOKu2Wu6dqNxDBaXBlkmtEvUxE+DC5wjFiMDODgE54PHBrn9B+G2jeHNUtr6xkO63DLGjWV mCAVK/6xYRKeD135PcnJzp6R4Zh8OW18dLkkmnmUCFbtxsjVQfLiBVciNST2JGT1oAkl8S2sN/qs bo4s9Jt/Ovrsq22Ntu/YoC/OQnzHByMqMHdxHaeMdGvbS4u4mvktreBrmSefTriGMRqMkhnjAJxz gEn2qfStEfTtAawa+mkupg7z3u1N7zPktIAV29TwCpAAAwQKxLX4caXbPqZN7duupWUtlPGsVtAp R+rYiiTLgZALZxk+tAFrS/E66j4i1pU+3CwsbC2mEMunzRSB2a43lUZBI+VRMYByRgc5rQtPFGk3 kd64mntxZRCa4F5aS2xjjO7DYlVSV+RuRx8prPl8Ex3UOprea7q1zLqMUEMk7+QrJHE7OqqEiC4J dgwYHIOKrab8NdC0+11K2Yzzw6isCzoqxWo/dMzoR9mSLBy3J6nAHSgDR0HxNJrmr6haHTZrSC3h hnt5ZiVeeORpVDGMqCnMLEA5JBB46Vqanqlpo9mbu+keK3UgNIImcJ7ttB2qO7HAHc1lWnhS30a+ vtU0ua+lv57RbdEvtRnniypdlzvZj1frzgZ2gbm3Sf2Bd33haDSdY1m6uZmQLe3EKxxG5BzuTAXC oc4+XDYA5zkkAmj8TaTLY296k8htbm4S2hl+zyBXdzhcHb90kgB/unI55pJPFGkx27zmaZkW7eyA jtZXZ5kBLKiqpL42tyoI+U88Go08L2y+G30Jru8ktOPIZ2UyW4UgoEbb/AVBBbceOSab/wAIpbJp OnWMF7eQSWEzTw3aGMy+ayurO25CpLea+flxlulAFHSfF0U/9uXdwNRktIdTW1to00ucyxr9mhch olj8wDeznLDuOcEV0Om6la6vYJe2Tu8Ds6gvG0bBlYqwKsAykMpBBAPFcrefDay1AOb3WdTuZJLh 7mVp47WRZHaOKMbo2hMfyrCoHy5GW55q9F4YvNG8LWuheHNRNmEuS8l1JFGXSNpGkkCIE8vJLFQN oAB9hkA2bnWNPs7p7a6ukt3SETsZsomwttzvPy/eIGM55HqKgOtpLd20Nlby3SPfPZ3MqoyrblYn csSVww3KqZBxufGcjFVvEvhLTvFUUMWoPOI4wyMkTACRGKsVbIPG5EbjHKjtkHR0nTY9I02Oyill mClnaWYgvI7MWZmwAMlmJ4A60AXaKzNTttWub/TfsF8lpZxTGW9witJMoHyxjcpAUk/MeCAOOuRp 0AeI/EnXNa0/xZcCx1q/tYY57ZPJhmIRg/lg8dup6Y6169oMjzeHdMlldnke0iZnY5LEoMknua8k +InhzWtV8X3MlpZXL2vmwSF0tHk37BGcKw4HKkHrXregxvD4d0yKVGSRLSJWRhgqQgyCOxroq25I 2PJwLl9YqKXd/noaFFFFc56wUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAV5pd/wDHzef9fVx/6NevS680u/8Aj5vP+vq4/wDRr114T4mc2J+FFOz/AOQr Zf8AX1B/6NWiiz/5Ctl/19Qf+jVooxvxIeE+FnolhcNBoun7beabNumfLA4G0dckf41egnW4QuqS KM4/eIUJ/A81X0j/AJAtj/17x/8AoIq7XNK12bR2CiiipKCiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvNLv/AI+bz/r6uP8A0a9el15pd/8AHzef 9fVx/wCjXrrwnxM5sT8KKdn/AMhWy/6+oP8A0atFFn/yFbL/AK+oP/Rq0UY34kPCfCz0XTluG0XT /IliTECbt8ZbI2jphhj9avQrMseJ5I3fPVEKjH0JP86raR/yBbH/AK94/wD0EVdrmk9WjaK0QUUU VJQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV 5pd/8fN5/wBfVx/6NevS680u/wDj5vP+vq4/9GvXXhPiZzYn4UU7P/kK2X/X1B/6NWiiz/5Ctl/1 9Qf+jVooxvxIeE+FnolhZ293oun/AGiFJNtum3cM4+Ucj396vQW8dshSMNgnJLOWJP1JJqjYXcNr oun+aX+a3TG1GbooyTgHA96vQXMN0heCVZEBxuU5GfrXPLm17GsbfMloooqCwooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArzS7/4+bz/r6uP/AEa9 el15pd/8fN5/19XH/o1668J8TObE/CinZ/8AIVsv+vqD/wBGrRRZ/wDIVsv+vqD/ANGrRRjfiQ8J 8LPStI/5Atj/ANe8f/oIq7WbpzXC6Lp/kRRPmBN2+QrgbR0wpz+lXoWmaPM8caPnojlhj6kD+Vc0 lq2bReiJKKKKkoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAK80u/+Pm8/6+rj/wBGvXpdeaXf/Hzef9fVx/6NeuvCfEzmxPwop2f/ACFbL/r6g/8A Rq0UWf8AyFbL/r6g/wDRq0UY34kPCfCz0rSP+QLY/wDXvH/6CKu1mWFstzoun7pJk226Y8uQpztH XHX+VXoIWhQq00kxJzukxn9ABXNK12bR2JaKKKkoKKKKACiiigAooooAKKKKACiiigAooooAKKKK ACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAo oooAKKKKACiiigAooooAKKKKACiiigAooooAK80u/wDj5vP+vq4/9GvXpdeaXf8Ax83n/X1cf+jX rrwnxM5sT8KKdn/yFbL/AK+oP/Rq0UWf/IVsv+vqD/0atFGN+JDwnws9G065gt9F0/z5o4t0EYXe wXJ2jpmtBWVs7WBwcHB6VS0pEfRbHcit/oyDkZ4KjIq1DBDbx+XBEkSZztRQo/IVzStdm0b2JKKK KkoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK 80u/+Pm8/wCvq4/9GvXpdeaXf/Hzef8AX1cf+jXrrwnxM5sT8KKdn/yFbL/r6g/9GrRRZ/8AIVsv +vqD/wBGrRRjfiQ8J8LPRdOleLRdP2W8s2YEB2FRt+UcncR+lXoZHlj3PBJCc42uVJ/8dJFVtI/5 Atj/ANe8f/oIq7XNJ6s2jsgoooqSgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooqOeeG1t5bi4ljhgiQvJJI wVUUDJJJ4AA5zQBJRVS31TT7zThqNtf2s9iQzC5imVosAkE7gcYBBB57Uafqmn6tbm402+tryAMV MltMsi5HUZUkZoAt0VBeXtpp1s1ze3UNtAn3pZpAij6k8VVTxBosmmnUk1ewawU4N0LlDED6b84/ WgDRoqrYalY6rbC5069try3JwJbeVZFz6ZUkVaoAKKKKACiiigAooooAKKKgnvbS1lgiuLmGGS4f ZCkkgUyNjOFB6nAJwKAJ6Kz7LWrLUNRvbCBpxdWW0zJNbSRYDFgrKXUB1JjfDLkHHWiy1qy1DUb2 wgacXVltMyTW0kWAxYKyl1AdSY3wy5Bx1oA0K80u/wDj5vP+vq4/9GvXpdeazxXE1xeGKzvHX7Xc AMtrIQf3zjg7eR7104WcYyfM7HPiIuUdEUrP/kK2X/X1B/6NWipIba6g1GyklsrxE+1wAs1s4AzK o5OOPrRSxc4yknF3HhYtRd0ejaR/yBbH/r3j/wDQRV2vPbfxfqFrbRW6RWxSJAikq2cAY9al/wCE 21L/AJ42v/fDf/FVMqTuylUVjvaK4L/hNtS/542v/fDf/FUf8JtqX/PG1/74b/4ql7KQ/aI72iuC /wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf8 8bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hN tS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/P G1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE 21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/ AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/5 42v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/7 4b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/ AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b /wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/ AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4 qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42 v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCK o9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3 /wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2U g9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fD f/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lI PaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAV R/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9oj vaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI72iuC/wCE21L/AJ42v/fDf/FU f8JtqX/PG1/74b/4qj2Ug9ojvaK4L/hNtS/542v/AHw3/wAVR/wm2pf88bX/AL4b/wCKo9lIPaI7 2iuC/wCE21L/AJ42v/fDf/FUf8JtqX/PG1/74b/4qj2Ug9ojvajnmW2t5Z3EhSNC7CONnYgDPCqC WPsASe1cN/wm2pf88bX/AL4b/wCKo/4TbUv+eNr/AN8N/wDFUeykHtEVFE+rfD/VbK2sdSS5TVZb rZPp8sTGJtQaZWRZVUSHy/m2c9lIGcVPot6dBbxH4ivm1W6shBbrHNd2C29xO6mQeWsQRMnLooYq MlgM4XNSf8JtqX/PG1/74b/4qj/hNtS/542v/fDf/FUeykHtEdBqN9BdeHrS/n07UU85FkQJZCW5 smZDhzGQ2HXOCArYJxgjNcfb3Eujzavrk+l61ryStapZNcaV5c7SqJssY0iUqqh/9aUBIbaAcDOh /wAJtqX/ADxtf++G/wDiqP8AhNtS/wCeNr/3w3/xVHspB7RGl4OUXF3qWpzy3b6jdCIXCyabNZwo F37VjEqKXxuOWJJPGdo2gdXXBf8ACbal/wA8bX/vhv8A4qj/AITbUv8Anja/98N/8VR7KQe0R3tF cF/wm2pf88bX/vhv/iqP+E21L/nja/8AfDf/ABVHspB7RHe0VwX/AAm2pf8APG1/74b/AOKo/wCE 21L/AJ42v/fDf/FUeykHtEd7RXBf8JtqX/PG1/74b/4qj/hNtS/542v/AHw3/wAVR7KQe0R3teb+ M9F8Sa/r13caXboE0y1RbGSefydlzvWYyRjyX8z7kScsB99e5It/8JtqX/PG1/74b/4qj/hNtS/5 42v/AHw3/wAVR7KQe0Ro21+0HjD7fcWGoRwarpllFCVs5ZPLkWScsku1T5eBMnL4HXng1PJO2m+P biae1vGg1CxtLeGaC1klQSJLOWDlFOwYmQ7mwOvPFY//AAm2pf8APG1/74b/AOKo/wCE21L/AJ42 v/fDf/FUeykHtEd7WXZNMli7woJNtzcbo+hYea/Q+tct/wAJtqX/ADxtf++G/wDiqonxJqazSPbz LbiRtzJGgK7u5+bOCaiVJopVEdlf+Z9miMuA5uYDheg/erx70Vxi+ItRMqPPIlx5bBlWRAAGHQ/L jNFKNGQ3Vif/2Q== --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 5.jpg" Content-Description: Picture (Enhanced Metafile) 5.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 5.jpg"; creation-date="Thu, 08 Nov 2012 06:14:07 GMT"; modification-date="Thu, 08 Nov 2012 06:14:07 GMT" Content-ID: <03d15fae-b059-49d7-908d-00d6e755814d> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAGcAssDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCm7g6N eag007SQmIEtAWzvmVGZlAB6EkAEfyrLeRrFY7NtWkgkRVQIdFl6Y45L9Mc59OauvNDqOjarp0Or adDLMsTQNK2VUxyK7bjls8Ke3+Nc9Mt4+mi3luPDc9xtCm++1zmbAPoTs6fL93px712Yn6wqj5Ln NRp6JWOg02Z7uxhuGlkzIiTYwDt3KrbQcdPmx649+a0OgFZehlUsYoFuIJTFFFG3ltuwVQKec99v HH/1tQEAda76fOorn3OOsrTdhaKTIoyK2uZC0UmRRkUgFFLSZHcgUoIPQj86RL3ClHSk/EUblHVh +dADx0paaHX+8Pzo3r/eH50MpMeOtOqNWUn7w/Onb1/vD86aBsdRTd6+o/OjevqPzpiuOopu9fUf nRvX1H50Bcd3p1R71H8Q/Ol86L/non/fQqW0gH05aiEsZOBIn/fQqQEYzuGPrU8y7gkOopMg9CPz paV0UFONNpcj1H50NpbgKOlLSDGOo/Olq01YQUUUU7gFL/EPpSUuOQfahtEyTZJ2opMjFGRUFi0h 6d/woyKMigBmU3R+bdSW8OTvmW3aYpxx+7XlsnA49c1Z1S1j0+TT1g1Nr57mIXAijs2jxAUdt5kL FVxt6N78VAxJU7WAbsSMjNLHd6lHe6dcpc2oext0tkxA43KqOvOJAR98ngjoKzqRm5XizSLjazJL a2u7ibyYLeeSbyRc+WdoPlZHzgnhhz/Cee1Njtbua3hniilaGVnEbh4/m2cOR83Yg+2BnpinS3d+ 9zczJPAGubF7J/MEsu1XOSQXkJ47DOPYVXmk1KS0tIEurUfZVulRvs56Thg2fm6jcMEY6HIOazUq vYtKl3LEltdRvNE0cySR2ZvHChGJhH8YIbBB9snjgGor1bmxtY7ueC5S3ljSQOqI+1G4Vtq5bBJA zjqRkDNOFzqYH/HxZn/iVf2UP9FYfu/73+s61XuxqV3FGjXdquywjscrbuCURw4b/WfeJUD6E1al Wv0Hy0u5Ndi4s7KW6kglMUYAYxhJCpboSqElc5H3to561bvLR9O1K6sJJRM9s6q0gTaGJRXzjn+9 6mm6lqOo6jpFzpxawhhuEjVlitpAo2kH5VMpVenYZpLm6uL7ULq9umiMtw4YiJCqqAqqByTn7tOE qnN72xE1Dl93cZSUZoyPWtWzEKRulFB6UgEopKKYxaKSigAPSm4px6UwnimiWN70tJRVALRSUUAL ikIozSZqHuMSikooGLSHoaKQ9KAYxDmNSepAp1IBgADoKKFsQJgCikBJAoqxhRRRQAtFJRQA3vRQ etJUsoCKZTmPFNoJYUUUUCENFB60lMYtFRr5iNJ8ltKGbI80S5XgDHySKMcZ6d6Vd2WLBF3NnbHu 2jjtuZj+velrcfQj8tp3nRL3yQgDu7Lny+UG0BUY5JcdQetSFRFHvFyk6+asbbEkBUsGI+9GuRhf y5PrSSef5ciwSIhkTYxZN3G5W45HOUH60yBbpFZJriORGdXOItpyocDnPT5z29KTTKurWHSsUQkB icgAKpY5Jx0HNL/ZN48P2gXcotPKMhutq+SFPQ5KZLA/LtwCCOQRyR9xU7G2v/C2M4PY1e/tvURZ iz22H2PZ5f2Y27bNvXOd+7dnvux7Z5py5tOUcWle5h6fK1zqxtpGnMTxLuR49ow7MGGdoPTgfQ9S Ca5cdOprtbOPbexSMcysUV2xjOCT07csfzrix0rzM1s+VnPiWmlY+i/DXhjQJvCujyy6Hpkkj2UL O72kZLEoMknHJpLJfh3qN2lpYr4XurmTOyGAW7u2Bk4UcngE/hWv4X48I6L/ANeEH/otayfBVj4h tPDmhR315ZLbRWEKPaHT5I50xEAFZzKQGBxn5OcHgduNyd9z31FW2L0Hh/wlcsFg0jRJSY0mxHbR N8j52twPuna2D0OD6VN/wifhz/oX9K/8A4/8K4+2tvEZ0OWaEXcWpSeH9Jjknmid5N4eYzjGVZpA rE4BDZI5BIrsfC4ul8N2S3k888wUjzJ4GhkZdx27kdmYHbj7xLHqeSRS5pdx8q7Cf8In4c/6F/Sv /AOP/CsaeT4a21xJb3D+E4pomKSRyG2VkYHBBB5BB7V2Nee6Tqup6VPc200s8VsuqXchgHhq9ndo 2uZH+WZG2HcrZBCkDI4OOTml3DlXY6ebw14Wt0DzaJo8SFlQM9rEoLMQqjkdSSAB3JApkPh/wlcS yRQaRokskYy6JbRMV+Zl5AHHzI4+qsOxrA8RQX9xrjJJHqkrDVNPe1W3WQ24tllhZy+Pk3BxIST8 wAX+EGjw1pdxB4zvtR1FdW825aZbd3muDFhLq7GGXOwL5TxFAw285Xkk0c0u4cq7HS/8In4c/wCh f0r/AMA4/wDCmDw14Xad4BomjmZFDtGLWLcqkkAkYzglWwfY+lbdYWvR3FlcW+u2UUk0lsPKuIIo y7zQMw3bQOSykbh1/iA+9RzS7hyrsI2geEluhatpGiC4bGIjbRbzkMRxjPIR/wDvlvQ1P/winhz/ AKAGlf8AgHH/AIVkW1nqkVzot9OJRd3+ombUEiBCxR/ZJgkbY/hVhGOeC/PBIrD0k+KrTRbq/uri /vL2xuEuZbP7HLGJT86zxRlpG8xcNlNoCZVNo5IBzS7hyrsdn/winhz/AKF/Sv8AwDj/AMKP+EU8 Of8AQv6V/wCAcf8AhXPeG4fFC6vBY6vPO8FtuvpLnawWZplwIM55VGaXjsBF0ruKOaXcOVdjldQt fAGkXC2+pQeGrKZl3rHcpBGxXJGQGwcZB59jVuy0HwjqNol3Y6Tol1bSZ2TQW8To2Dg4YDB5BH4V L4ogluNJgSGJ5XGo2LlUUsQq3UTMeOwAJJ7AE1iWi6wPiTfM91fLYmUBIGtJmhaL7OnIlLiJf3u7 gIXznJweDml3DlXY3v8AhFPDn/Qv6V/4Bx/4UyXwz4YhUNLoekRqWVQWtIgCzEADp1JIA9zXN6Ro 2p3lp4Yt9QvdcQSaPLLfP9qmjb7QfswVXbOVYfPgcHhuuWzBpaeI49MhNxLq0s08Wi3MxlDbkle4 xcoMAbVCKu5egGSepyc0u4cq7HXf8Ip4c/6F/Sv/AADj/wAKjm8NeFrdA82iaPEhZUDPaxKCzEKo 5HUkgAdyQKxdNs9Ug1LTr559Vd59Yv4biKaWRolts3JiOw8KuUi2tjowAOCBXP6N/wAJDeQ6jDfw aqyC/wBKnjjuoZSY2F0pmCs/DhVVSWQKnBIGOSc0u4cq7Hff8Ip4c/6F/Sv/AADj/wAKjm8N+F7d A82i6PEhZUDPaxKCzEKo5HUkgAdyQK26wvF9vd3WgpFYrm5+32ToTEZAu26iYsygglVAJPI4B5HW jml3DlXYcfDfhdbhLdtF0cTOrOkZtYtzKpAYgYyQCy5PbcPWiTw34XieJJNF0dGmbZGrWsQLtgtg ccnCscDsCe1Y19Z+KU10T/abO6uV0a/S0lt7F4UjnLW5QOWkcHJXIHHCt17ZuhWurHUtINxcaheQ Q6iJGa4sLiHyibS5VzmaR2ILFBxhASAuc0c0u4cq7HX/APCKeHP+gBpX/gHH/hR/winhz/oAaV/4 Bx/4VzHw+mv7q30u4abVZYpdJje9kvy7K85EZjMRbgjb5mdvXK7vmzXfUc0u4cq7GR/winhz/oAa V/4Bx/4Uf8Ip4c/6AGlf+Acf+Fa9FHNLuHKuxkf8Ip4c/wCgBpX/AIBx/wCFH/CKeHP+gBpX/gHH /hWvRRzS7hyrsZH/AAinhz/oAaV/4Bx/4Uf8Ip4c/wCgBpX/AIBx/wCFa9FHNLuHKuxkf8Ip4c/6 AGlf+Acf+FH/AAinh3/oAaX/AOAcf+Fa9FHNLuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gH H/hWvRRzS7hyrsZH/CKeHP8AoAaV/wCAcf8AhR/winhz/oAaV/4Bx/4Vr0Uc0u4cq7GR/wAIp4c/ 6AGlf+Acf+FH/CKeHP8AoAaV/wCAcf8AhWvRRzS7hyrsZH/CKeHP+gBpX/gHH/hR/wAIp4c/6AGl f+Acf+Fa9FHNLuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzS7hyrsZH/CKeHP8A oAaV/wCAcf8AhR/winhz/oAaV/4Bx/4Vr0Uc0u4cq7GR/wAIp4c/6AGlf+Acf+FH/CKeHP8AoAaV /wCAcf8AhWvRRzS7hyrsZH/CKeHP+gBpX/gHH/hR/wAIp4c/6AGlf+Acf+Fa9FLmfcfKuxkf8Ip4 c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gH H/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+ Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRz PuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/C KeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf 8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBp X/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6A Glf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hW vRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+ FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHK uxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP +gBpX/gHH/hWvRRzPuHKuxkf8Ip4c/6AGlf+Acf+FH/CKeHP+gBpX/gHH/hWvRRzPuHKuxxfi/w/ otl4cluLTSLC3nSe32yxWyIy5nQHBAyOCRXz5nivpbxx/wAipcf9d7f/ANHx181DoKVXWkvU8fM0 k0fUXhhMeEtGAwB9hg/9FrWttNcHow1jUpbbTbTW5tOtbbQNPnUQ28TsZX85SSXVvlxGuR7DBHOe a1X4i62dJg1K1vLO0mg0uC9ks5plRrt2hEzlIzE7vHhtuVZMFWyeMi2tT1k9D2HaaNprgb691658 WTWltr09payawNOSOO3hby0/s8XO4FkJLbwRzkYY8dMYPhbxp4p1i60e5vtS0m2a7eHdpj3GJXhc D51iEBckg7wwk2DODjBwrDueubTRtNcTf6n47j1G5Sz0zfarK4hb+zoG3Jk7Tk6gpPGOSq/QdK2N A8Mf2Hqmo3v2zz/tmfk8rbszc3M/XJz/AMfO3/gGe+AWC5vbTRtNeaaTu/4SSzeVV/4RE3839kfN 0uexYYx5W4TeVz1I/wBjGPdia98PeJNO8pVsfDWmarEu5juErtMsKgYxhbdQc5/5ajjrRYLnse00 bTXk2r6B4i0m80WRZLeSXT2urPQ1hlZ2INpeMpkDKAGwluvBb7hOeaq2S2osr23s5NGaNraOW+1K 1eeIp/pEe+C6c7mZ3XeDIcMuGyqg0WC57HtNG015fo9gviCTWNL0my0bTdIu9IntZ7jRrhri3aaT Co3+rjUsq+YTtyTkZI4r0LRtM/sixktvO83fd3Nzu27cedM8u3GT034z3xnjpRYLl7aaNpp1FFgu N2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC5DBbRW1vHb28UcUMShI4 41CqigYAAHAAHapNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnU UWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaN pp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN 2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2mjaadRR YLjdpo2mnUUWC43aaNpp1FFguN2mjaadRRYLjdpo2mnUUWC43aaNpp1FFguN2ms6G7vbqJZ7a0gM DjMbSzsjMvY4CHGfrWnWZp0LT6Bp0YkKIbaPft4YjaOAe1S12Gmc/wCM7ycaBJb3dtHH5s0HlvHK XBYTIcHKjHAyPoa+eB0FfQXjtHTQ7VXffi9hwx64z396+fQOOgqZt+yV+/6I8nNd4n1P4b/5FbSP +vKH/wBAFT6TqUOs6NY6pbrIsF7bx3EayABgrqGAOCRnB9TXDPoct5BpN5NoR1u2bR7eC3iM6ILS YAkyYdht3BkG9MuPLGBXPp8PNX+yWIvYtYkuRYWcUJsrq0UWDxwIjKHlVni+dWbdCTnd0452e56a 2PZaK818Y+ELnVdfuL6y0i7kvnVBb3Zmt3t1IA+8JP3sXOc+TyeucmtK08Pta+IJpb3w4+o3cmoN cQ6y1yjGGJpNyrlm8xAinaERSpC8/eNIZ3FRxyM7zK0MkYR9qsxXEg2g7lwScZJHODlTxjBPM2Xh Kzl8Ta3q+o6dG9xJqEU1lcM2WVEt4FyuD8nzo4PQsBg5GKd4Zt7qx17xHE+hz2Vpeag15DcboPLk /dQxsdqOWDM6O/KjIOSQxxQB1FV7O+t9Qgaa1k8yNZZISdpGHjdo3HPoysPfHHFea/DzQ5Tp/hK+ ttCOm+TZJLd34nQ/bkaDCoQrFmGWV8OAF2ALxWx4c8N2eiLq9o/guAFjeEXMENrtu4JJmdLcZYN9 1lXa4CfJ1xigDtoZGlQs8MkJDsu1ypJAYgN8pIwQMjvgjIByBJXE+H9M1MeCNX0KLS7nQZmN79ic vCFjE0szx7PJdtuwOmemD0zis2LwjeT6XfQR6M2mWlzc6Z/xLluw2PJuFeeYFWwCy9wQzeWCfmOK APSKr3t9b6fAs11J5cbSxwg7ScvI6xoOPVmUe2eeK5U+EHt73W7TRo49JsLy1tDCYS6RidZJTKQk MkbKSnlAkMueM7sEVa0XwnNZwXEOr3/9oxySwTRjzLr5HifzFP764l/iCn5dudvO4dADVbxDpaaL a6ubr/QrtEe3cRsWlDjKhUA3Ekc4xn2qLTPFGk6veG0tJp/tI8zdDPaywuuwRFsrIqkYE8R567uM 4OKur6JbQaDp1lZ6RcXcGnMi28NrfNbzQqsbRgpJvUkhWK8sOCTnNYem2Guadqsesf2TqU9vCbm3 hsbi+jlukilW2Od7ylWw8EnBkzhx6UAdPd+J9IspZoZbl2nhm8hoYYJJZC/lpJhURSzYSRCSoIG7 1qkvjvQXuHt4n1GaeNFeWKDSrqR4gxIXeqxkoTtbhsHjNYsui3cl1d6veeHtQlmvbp5FisdUFvc2 0Zit49pZZEVtxtwxAfjAHPNZNpoOtxeItQvdU0bxJd2c1vBFYrZ60sc0CI0pZJmFxH5jZfIOXwGx uyDkA9Msb2LULOO6hSdI3zgTwPC4wSOUcBh07jnr0ot763u57uGCTfJaSiGcbSNjlFkA56/K6nj1 9c1X0SPytHgT7LfWuN37m/uftEy/MfvSb3z6j5jgEDjGBhwT6ro2u6+y+G9SvoL29S4hntZbYKVF tBGQRJMrAho27elAHUGRhcJEIZCjIzGUFdqkEYU85yckjAI+U5I4zJXFmC5X4g2WsweEbuES2Ulv eXim0VmaQ25UuRLuYRiN1PBxj5dwOahvfCUk2sapq8emx/2k2uWU9rdqyrL9mVbVZhuzkLtScFT1 54ORkA7qiuBl07XksjoseiyPENeW/N79oiEZgN+Lk4G7fuAJBBUD5Tgk4BuadoNxb/EC71htJ8u0 m3pE32ksInwu6fy921TLypKjd8ik/fbAB2VYeleLdK1p7dbBdSdLlN8Uz6XcxxMu3cD5jxhMEdDn njHUVuV5PZ+GdRXwG2jf8I74ji1P+xJLPfPrKvaGY2zJgR/amXaW4X5MDIOFxkAHrFV7O+t9Qgaa 1k8yNZZISdpGHjdo3HPoysPfHHFc7F4RsbHxNC9lpcCaZc6dc2+oLwVuHLw+X5qk/vCV875iCcEg nnnEh8GTQ+FPEGiadpQ0i4nvHlS8smih+1wG5aVY1ZclcRny8Ou0bsDIzQB6LRXm1h4RvLXwd4ts bOy1KF9RsHht7W8ltFUymORfkjtwI0yWXLE5bAzjHM3irwxpOmv4fh0/QY7hJ9VHn2iOF+0hbW5O W3EBmwTksfmwAxxQB6HUc0jRIGSGSYl1XahUEAsAW+YgYAOT3wDgE4B4b/hFrq48JXenf2c1tb3e sWtxFpvnj/RbZZoC6gq21eI5JNqHALYXmpPEvhizs7LT4tD8JC6lg1GC8ja1WBBa7JoXk2eY67C6 RkYTgkfNjOSAdzRXGeM9E/4SOx0x59F1C4CbpGggmti8LMo4eOYmGTHPOTgj5c5zXPaj4L1S70Tw /bXtjdzpaQ3aSQ2LWhdGkkQxEicGMEIrAmPBUnCfLxQB6pWVqfiPTNIu4rW7lmNxIhlEVvbSzsEB ALMI1bauTjJwKs6Rby2ei2NtO8zyw28cbtNL5rswUAlnwNxz1bAyecCud8TaZLLq4u7XRtVuLiS2 WIXmnar9m2lWYqsiGRVZRvJBw/Vhj1AOqgniureK4gkWSGVA6OpyGUjII/CpK8o1bwNrd/qTXepS arfXs0NuI7nT57WNLWRI1V9rTIZIQXVnzF13dMjnr5vC1rf/ABAm1y+sEl8iwtYrK4LfNHIsszvt wcjrFk9wSOQWFAHUUVxP/CM33/CZeT5T/wDCO/af7X3ef/y99PL25zt3fvv7u6qOm+ELyz+II1W6 h1K6c3txcLema2MMcTpIEjOV8/ChlURg7MgN2xQB6JRXK+GvCVnp8s2pXWnRx6q2o3s63G7L+XJP KUGQfulGU7emTkjdXVUAZ+k61Za3FPJZNP8A6PL5MyT20kDo+1XwUkVW+66np3o0nWrLW4p5LJp/ 9Hl8mZJ7aSB0far4KSKrfddT071j+GH1L+2tekvdCvrCG+u1uoZJ5bdhgQQRbSI5WIbMbHpjHfPF Hhh9S/trXpL3Qr6whvrtbqGSeW3YYEEEW0iOViGzGx6Yx3zxQB0N7e22nWcl3eTJDbxDLu54Hb88 8Y71S03xDp2q3LW9s1yk6oX8u5tJbdmUEAsokVdwyRyM9RTtftBfaPLCbE3pDxyLAs5hZmR1cFXB GGBUEcjkAZHWvPtW8L69rAijtYNesdHiYSXVhd6nFczXbDgBDI8qbRkkrI21sLwMZoA9Torz228I XA8DS6OLXUBHPq1rP9mvLiEPHAs8LSBRDtjjUKjkKh9SDk4Gn4j8Miy8MMnhbSkW+tr2G+tLaCUQ J5isobGTtAKbwR0OW7nNAHVzSNEgZIZJiXVdqFQQCwBb5iBgA5PfAOATgGSuC1vwz9g8PaDY2OgT axeafdQXC3YaEyRFbiKWZt8zqwaTa/3c5PBwMVf8T6VPq8mkX0+izajZwo/2jR5J0Ul32FXZS/lS NHtYYLEfMSpJAyAddRXm/irwdd6re2Nw9rqU1nHp8dsljZz20n2aUFiX/wBJUgnBUeYpDjZ3zx3m kW8tnotjbTvM8sNvHG7TS+a7MFAJZ8Dcc9WwMnnAoAzrzxho1he3VrPJeb7RgtxJHp9xJFESivhp FQoPlZT14zzW1FLHPEksTrJG6hkdTkMDyCD3FcpH4Y1G51rxDPJrOp6faXl6jxw2jQBZUFtAhbcY 2kU7kZeGX7oIHOTgax4R1FvEemrZ6bcNYaZPYR6e8TW5jhtonjMm9pT5wfAk/wBX94BQSeRQB6bV PTNSh1W1e4gWRUS4ntyHAB3RStEx4J43ISPbHTpXJ2nh9rXxBNLe+HH1G7k1BriHWWuUYwxNJuVc s3mIEU7QiKVIXn7xpmieF9S0zWk1ScT3SSX96TZyzgpapJcSvHPEuduSrfNnLYfgjBUgHd1h2vi/ RLy5ihiuZv3zhIppLWVIZWPQJKyhGJ7YJz2rcrgoX1/W9Zhl1/w1q0FnDco9tawXVt5KFWBWaZhP ukIIDbQuBjoxANAHeEgAknAHUmsix8U6RqV3HbWk80jS58qX7LKsMuASdkpUI/AJ+UngVZ1zT31b QNS02OUwvd2ssCyD+AupUH8M5riovDmr3Kx2Wnw63oKiCWKe6uNYe6T5oXjQQp5zH5XZXBIQ/IPX gA7Ox13TdT1K/wBPs7kS3VgVFyoRgE3FgMMRhuUYHBOCpBwal1PUodKtUuJ1kZHuILcBACd0sqxK eSONzgn2z16VzXhbw5q2heIrs3Etg+m/2bbW8JtrV4tzJJOxHzzSNkeYSzHO4uOQVbdb+IGlXGte DbqxttO/tKR5rZ2s/NWPz0SeN3XcSAMqrc5oA6KeRobeWVIZJ3RCyxRlQzkD7o3EDJ6ckD1IqO/v rfTNOub+8k8u1tYnmmfaTtRQSxwOTgA9K8+1PwxcTfD7W9OHhgztfTTPpumF4HGnFoNiMC7hEw4Z v3ZO3zDgHmuk8SaQPGHge/s7nSFju5raYW0F+sTtBNsZUfKl1B5yCpyAexyKANXV9b07QbVbnUrj yIW34bYzfcieVuFB6JG5/DHUgVoVz0Ph7SdW8N2tjeeHhp1sgl26cCkYhLpJG/8AqW2/MssnQ/x5 4bp0NABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeSWtnapplo FtoVCwJgCMDHyivW68qg/wCQbbf9cE/9BFdmEim3dHLiW0lYxtUt4f8ARW8qPcl1GVO0ZB5HH4E1 5kAMfcz+Vepal92D/r5T+teXAAgcn86yzBJJJHl4p+4j6c8NalDLZ2mlhZBPbaXaXDsQNpWQOqgc 5zmJs8dx17Q2XjXTb7wvqPiCKC7FpYW4uJUZF3lTbR3OFG7GdkijkjkHtyaumeHnvbPT9WtNa1PT pp9KtreRLdIdrqgZlJEsTEEGVuhHbioV+HNtDpF3pFtr+s2+n3dulvPAn2ch1WBIM7mhLAlI1zgg ZyQBWL3PeRuf2sT4tj0mS2voc2ks0Uh8kwXAVogxGGMgZTIAMhQdzdcAjG1vxhInlw6daXwT+1rW xa/ESGAsbmNJY+W3fdLru24zwDnFatz4dkufEsGtjW9SieBGjS2RYPKEbGMunMRfDGJSTuyOcEVW l8GxySKo1nU47Jb8agbFfI8oyifz+SYy+DJzjdSAsz+LNOtriWB7bWS8blGMei3jqSDjhliIYe4J B7VJpGsXmo397b3Okz2Udvny5ZM4mxPPHxlR/DCknU8Sr2wTHP4T065uJZ3udZDyOXYR61eIoJOe FWUBR7AADtW5QBxlp45uJrXTtSuNJig0rUriO2t3F8rXAaRwi74toA5IyFdivORwcVtC+JcGtSC4 exFnpbxzTR3M8kiuYowSX2tGEYYGTsdyM8gYOLtv8PdPj1hNTuL64u7hZlmYyWtpGZHU7lLvFAjn DANjd1AzTz4Bs5bKHT7rVNSudOt43it7N/JVIUaF4cArGGOEkYDcx7E5oAsL4ytI7a8mvdP1GwFv ZSX6rcxoGmgQZZkCseRlcq20jcMisa2+JLS2V7dTaM0SwqrwxfaMSOHlWNC29VUKSwJdGkQAH5um bulfDjR9LF8iOZY720ks5VFlZwExvjd80MKN26Eke2QMW28IvK7S3HiHVbi4+zvaxzSx2pMcbtGz gKIQhz5aj5lPBOMdaAKN748OhSTQa9p0cNwtsLmNLG8WdXUyxxAEuIyp3Sp1G3Gfm4NP03x39qtJ pLrS5Y7kTpBDZwOWmldgzBSsqxlDtUtk/LgEhjg0ln8N9JsoplS5uPMdVEcqW9tCYCJFkDKsUSoW 3xxnLK33B2q03gxJLoX02uapLqKtGY71hAHTYsyqAoiCdLiQcqeo9KAK2m+L3YazNeWt7vTVVsbO w8pBPu+zQuYxg7T8xkbcWxjnOAK6DSNWi1e3ldIJ7eaCUwz29wAJInABwdpIPDKQQSCCOawbv4fW GoadPa6hqF7eyTX41Bri5it5G80QiEfIYvLI2DGCh5564xa03wNodjozaVcWVpqFobg3IjurC2VQ +0LnZHEiZwOu3PJGcYFAFzxRq15oPh681azsoLz7HE9xNFNcmH92iMzbSEfLcAAEAc9RVfVPEF5b 6y2labpsVzPFBFPNLdXYt4VEjukaghWYuzI2Btx055xVzxDoo8Q6NPpb393ZwXCNHM1qI90kbKVZ DvRgAQeoAPAwRVJ/C87XCXcfiTV4b3yRBNcoltunQOzKHBhK/LvYDaq8HnNAFdvFl0+kafqkGkqI Jr9bC7juLrZLbyG5FsdoVXWTDlj95eAPXAvXniRLfUJrO20zUNQe22/aXtEQrBkbgDuZSx2kHagY 4I45FVbnwbHPo1npcWs6nbQ28/2lni8gvPMJhMHcvEwyJBuwoUHJBBHFSf8ACLzx3M1xa+JNWtZL go9wYktiJpFjWPzCHhbDFUXO3A44AoA6GuZ1nxcdO1NLKz0570R3Vrb3s/miOO28+RUUdyz/ADq2 0D7pBJGRnak0nTZtUh1SXT7R9QhTZFdtCplReeFfGQPmbgHufWsfVvA+j6xcT3Ez6lBLcXENzMbX UZ4ld4im0lFfZnEaDIGRgEEEAgApa34wkTy4dOtL4J/a1rYtfiJDAWNzGksfLbvul13bcZ4Bzita 38UWVxrX9mpDdANLJbxXTRgQyzRgl41Oc7lCt1AHysASQaqy+DY5JFUazqcdkt+NQNivkeUZRP5/ JMZfBk5xuqOw8BaVpvid9et3IuHmlnKNa2x+aTdu/e+V53Vj/H7dOKAL2m+JE1W4j+zaZqBsZs+T qDIghkwCcj5t4BxwxUA8YPIy/wAWX1xpng3XL+zk8u6tdPuJoX2g7XWNipweDggdai0fw3Lov2WG 313U5LC2TyorGVbcxqgGFXcIhJhRjHzZ4Gc1LdeF9HuNO1izisYLP+14pIr2a0iSOSXeGBYtj5m+ djk55JoApN4uJtL8x6LqK30FjJe2tnOiq94ijomwsQSSowQGG4fLzVTTPHQlh1BtVs1s5bRInW3j FyZZRIxRcLNBETlgFG3cMnnHGdO28NyQ3ZvJ9d1O7u1tpbaGeZYA0CyFCxUJEqk5jQ/MG6VVn8GJ e3H2jUNb1S8mRQsDyCBTBiWOUFdkSgnfDGfm3fd9zQBQbxneQX/iCafS7+OHTrCzlFjMsYdXkknD vvVmBTaqEkMcBG4zkVoeFfFn/CSXV9ABpji1SJ/O03URdxtvL/KTsXaw2ZIx/EOaR/BUVwt+b7Wd TvJr0WyvLMIAUWCRpEVVWILgszZDA5BxVi28J2oa+Oq3c+trexQxSR6lFA0YWJnZQESNV6uTkgng elAGnqmp22j6bNfXbMIoh0QZZ2JwqqO7EkADuSK56z8ayyvdW11oV3HqUV41vFYQSxyyyKIopd7E lUTAmQH5iASAGORWxqPhzStT0+0sZ7d47azdJLZLWZ7bySqlV2mNlIABIA6flWPD8P7Gy1KbUdO1 fWrO9mZi032v7SQrJGpX9+JBg+Uhyfm4AzgKAAHijxHqVn4bt7nT9J1KO4uriK3LBYA9qXnSLkSP tLHcdpG5c4JIXmr1zr7aRb6dbS6dqt9ez2rTPGiwmZVjCB2kwyoWBkXITOSTtBFW5dFF1pMFhe39 3dGK4huPtEgjWR2imWVQdiKuMoBwo49+az/FHgvT/FdxZT3sro9msiRgW9vMpDlCcrNHIM/uxggA 8n1oAsXOs6jNDb3OiadaXljNbrcC7ub37PGVYZGMI7E4weQByOeuObtPiIX1l5bjT9QXSn0uC7Lp HG8dqDNOjyuwbJRgqFSu75VLYHNbGreCY9W06y05tb1K2sbWKOIWtslssUuzgF0MJBHT5MBOBhRT bnwOl4Z/tGv6s4urIWN2uLdRcQhpCA2IRtwJXGU28Y780AW9a1rVtL+1XEek2jadap5klzdagISw AydihGHHT5ivI9Oaz9T8U69ajT5LLw7a3C6iY1trefUGhucsm9t6eSyrsG7Pznp6kCrWt+Dzrupw 3k2v6rCkDiSG1iW3aGNgAN214m3HIyCxJBJxitOPRwuqWmoTXtxcT2to1qvmrGA24oWkO1Adx8tc 4IX/AGaAMDW/GEieXDp1pfBP7WtbFr8RIYCxuY0lj5bd90uu7bjPAOcVo3XiuGHxTY6FBaSztNP5 E9yrAR27+TJMqnuzlY84A4DAkjIBil8GxySKo1nU47Jb8agbFfI8oyifz+SYy+DJzjdQ3gXRf7Xt 9SibUYZ4b5r/AGR6jP5TzMGDExlyoB3nIUDPQ/KSpAM7QPHGo6nfWUGp6LDpIuR925lukkDlchAJ LZEds8EB/UjOObPhzWdW1jxTrIu7LUrKzs2W3jgm+ymNW8uKT5ijs5kPmEjB2bcZ+bgXJPC89zLA b7xHq15BDPFP9nlS2VGeNg65KQq33lB4I6enFatlpsNjdajcRNIXv7gXEoYjAYRRxYXjptjU855J +gAKfhzWLzWrB7i90mfTJF8rEU2cnfBHI3VV+60jRnjrGeh4GxRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFeVQf8g22/wCuCf8AoIr1WvKoP+Qbbf8AXBP/AEEV24PdnLitkZmo9IP+ vhP615cBkDr+deo6iwUQEg/8fCDgE+teXgcCs8x6HlYr4Ee6zeItcsEsrTTf7OFvDY6UG+0wuzl7 qZ4Mgq4AC7VbGOeRkZyM8fE/UW01L02yKbfT7W7uYE0y6m+0GWFZW2SplIl+YqC+7lTnAGa7zSLC zm0WwkltIJJGtbbc7xgk+X88eT/ssSw9CcjmpZfD2iTm0Muj6fIbNQlsXtkPkKOgTj5QOwFc73Pe WxzN94h8Rt4mm0+wbSo7c6mNNiM9vI7q32IXW9sSAEfeXAA6g545peH/AB5qus6Ppevumnx2F7dx WZsAjm5VnIXfv3Y6nft2fc53V3v2Cz8/z/skHneb5/meWN3mbPL35/vbPlz128dKrQeH9FtbyK8t 9IsIbqKMRRzR2yK6IBtChgMgAcY6YpDMq21HxBf+JNVgtzpiadp17FblZI5DLKrQxSP8wbCkeYcf Kc8Dj7xh0zxZcan4g/sWOFVvLW6uRqCtC6+VbqzCEgnjdIGiYHkEb8DjjqI4IYXmeKKNHmffKyqA XbaFy3qdqqMnsAO1UNO0SLT9U1HUftM9xc37LvaYINiLu2RrtVflXccZyeeSaAOasPG2sXeo21tL 4d8qOWVI2k8vUBsBIBPz2Srx/tMo9SBzWP4S8SazfaloC3mp6lLFfGYmW5hthb3YjRx+5EcYlTJA f97twF28k8+oVg6T/wAIn/bV7/Y/9i/2rub7X9j8rz85+bzNvzZz1z3oAzbW61iDR/GFuuqPd3mn TPHZXN4sKbSbSGVd+xVTAeQ8kdOtZWneIZbnVrqzfX9ahs0sHuLu61C1t4GsXEke1RmEDDAycsGB C/KTgmuk8Pad4NdJr7w1Z6CyMGt5bjTYoSCOCUZkH+6SD7UlrD4MudDvLW0j0GXSEfN1DEsLQKwO fnA+UHIB57igCt4budRu9VZ49R1S90hLc5n1K0jgMsrFSvlhYoyVVQ2SRglxgnBx1dc74csvBvmy 3nhi20HzFHlyTaZHDkA87S0fbgce1dFQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFeVQf8g22/64J/6CK9VryqD/kG23/XBP8A0EV24PdnLitkZ191g/67r/I15aOgr1O8+9D/ANdh /Jq8sBG0fSssy6HlYr4Ee332n6rdy20lvPrEUEdlo8cYtJ5UjIe5dLg4U4JERBJ6qNp4wDWDfXHj FtAs3Q6zBqVlpFs0EQs7uZrqYQq7s7K6oG3lkKyhz8uQpJwfUdM1Gxt9LtIJry3jmjsEuHjeVQyx BQC5BPC5B56Uy68W+GrFo1u/EOk27SRrIglvY0LIwyrDLcgjoe9c7PfRz3iIa5/wkzGw/tL+xh9n /tIRb97fPx9mxzwMeZt6r0+bNYmoaZ4g8nULuG58Q/aPs+s3EUaXE+3zorkfZFVQcYKM21Bw47EA V6Bc+J9As9QbT7rXNMgvVwGtpbuNZBkAjKk55BB/Grv2+z8jz/tcHk+b5HmeYNvmb/L2Z/vb/lx1 3cdaAPPlg8SjxuZrnVNQQ/2j8lvFp1xJA1puwB5gmEA+TkkpvDZxnAzXtLLxCusX9482unZqcDwx vNMYij6nPHJhCcFBbLEcdFUhhjOa7n/hLPDn9o/2d/wkGlfbvN8j7N9sj8zzM42bc53Z4x1zR/wl nhv+0f7O/wCEg0r7d5vkfZvtsfmeZnbs25zuzxjrmgDn7DTPHceo2z3mp77VZUMy/wBowNuTI3DA 09SeM8Bl+o61heELHWhf+GLS6gcJpJlE0baTJbfZ8xSJ/wAfDOVn+ZgBsHzA7zyK7RfFsaz24u9H 1SxtrmZIIbq5jjVGdzhAVDmRcnAG5R15xXQ0AcFZzprMPjeyS21e3/tFnkgkfTZ4S0Zs4IiUMiqN 29WAUkE4z05qlbPeR3V1rF9pLXmkWVh9njtLbQZLeW4fzUKKIXdmfZs4bCgbyRxkj0qigDivC91L rHiI6rfQz212LNoYrUaTc26xRl1Yh5pVUSt8q4wFx82Ack12tFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAV5VB/yDbb/AK4J/wCgivVa8qg/5Btt/wBcE/8AQRXbg92cuK2RQu/v Q/8AXYfyavKx90fSvVbr78P/AF1/9lavKx90fSssy6HlYr4EfQes+GbvXtH0U2M8MJ+zi0vTISN9 nKq+aq4B+b5FxnjrzWg2m61pur6hcaRHp01vqEiSuLqV42gdY1jyoVW3rtRTtyvOeeeIhrmoQJa6 bpOlR39xBp8N1cebdeSFRtyoF+VtzExvwcDjkjNUR4+ubjT9S1ax0VZtI09I5priS72SNE1vHcEo mw5YLJypYDgYJzgc7PfRDc6NrupX3jDToYLSLTdVulie4nLrIqG0gR3jUKRJ0IHzLhlPXoJ5fDvi DyTpcR03+zhrK6kJ2lfzWT7YLlo9mzAIO4BtxzgDAzkdtXJW3i++kkNxPoyRaV/ab6b9pF3uk3ic wK/l7ANhcKPvZBPQgZIBXbwvqq+Ixd2a2lhCb0XElxbX06mZN+5ke2x5RZhkF93UlgM1u/2Nf/2j 9p/4SbVfJ83zPsnl2vl7c52Z8nftxx97djvnms//AISy5+1ed/Za/wBj/wBof2d9r+0/vPN83yc+ Vtxs835c7s98Ypth45s9REVtbxq+qrdx2l3ZCQ5tnbeWy235tqxyHgc7e2aAKen6X4tk16PU9cst Hu3STEHlalKEtIzwTHEYMNJtJyzNk9AVBIrtq4jQfiRp+u6xZWcLaeYr8uLUQaiktwNql/3sIGY8 qpPVsHAOCa0LXxVdNZarqd9paW+k2BvMXEV15jsLeVkbchVdpbYxGC3TkjjIB09Fc7Z69qst62n3 2jwWl9NZvdWaC9LpIEKqyu3lgoQZI84DD5uCcYql4TuNbl8N6jdNbW82ovqt4Eim1KV4iFuGjwHa MlFUKQFVMHaDhSxAAOvorjvBV3qieALPVLuzuL69u4orvy4b4zyTeYiEsPOKLF1J8sHaoHBJNao1 XWLq1Zrfw/d2c6XFuu2+kgIeJpVErL5crcrHuPOOcYDdKANyiufl1rU7HQdGa70+J9dv/KhNosuy Nbgxl5AX+bCqEkORu6cZrl4/Hc+kahq1vqq2dtfT6myQw3+qCG2hSO1ti22VlPBaQMFCZO8kgc0A ekUVxM/xDh/sTS9Stre18u+Myme6vfKtYmibYwMyo4OWztOMMFJyKlu/E+vsfD8mm6XpE0OpzNEW k1JiCRFNJ8jJGw2kRBg/JOdpQZ3AA7Giue1LXNWtNR0vTLXSLe5vr21muJA16UihMZiDDf5ZLAmX AO0HgcDJxTvPF99apfXI0QGz0tEbU3e7AkhYxrK6ooUiTYjqSdy57ZoA62iue1TxT/Zk2qW8lnuu LWKGS1j83H2sytsQA4+U+YNp64yp74qzbXGut4jnhuLKBNIHmeVOrDe2Etymfm7s1yPuj/Vr0zlg DYooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAryqD/kG23/AFwT/wBBFeq15VB/yDbb/rgn/oIrtwe7OXFbIo3H +sh/66f+ytXla/dH0r1Wf/Wxf9dD/wCgtXlS52j6VlmXQ8rFfAj6WbwvpGs2djc3tqxnFokJlhnk hZ48Z2MUYFkzk7WyOTxzV0eHNIXTdQ05LJI7PUE2XMMZKqy+UsOAAflHloq4XGMevNctrWtzWE9r az6//YVoumJNbzeVG32qbJBj+dTnaAh2rhm38HiqR1nxPP4f8R67LqUlhLpMSTrpwt4iu4WUM8kU hZSxG52HBBGTyeAOc9866e68VLcSrb6No0kAciN5NWlRmXPBKi2IBx2yceprN8P+CrW1QXmrWkTa k19cXzJFdSywJI8zyIwVtqs6qyjeUB+XjoK66uVsf7a1LxPrbDW5ILLT9QihitFt42V0+zwSOGYj dyZGwQQQTzkYFAF//hENCGp/2gLAed5/2rZ5r+T53/PXys7PMzzv27s85zUWneFfC8OqnW9P02yN +Jrgtdx4ZzI7nzctnlg25eeV+ZRgEiuSk8Z6wnjT+z3+1xzf2otqtg32QRNbFwvmgF/tBOw+ZuA2 9sYBNS+E9Vli1/8As+01b7YJdW1QXmnbYz9hQXE7LJlQGXc20YcnPmcYAoA6+w8K6Npl5Hc2Vq8J iyYolnk8mHIIOyItsTgkfKo6mrsWlWMWnz2C2yNaXDzPNDJ86uZXZ5Mhs5DM7cdOcdK4rw54k1C+ 1fS45NX+13d35n9p6V5Ua/2ZhGI+6A64cLH85O7dkU7whr2qa5dSWs2rSTPNZyyXYjgjVtJufMCi AfLgkAtw4Y/usnIYCgDqNK8MaRotwbixtnWYxiFZJZ5JmSPOdiF2OxMgfKuBwOOKv2djb6fA0NrH 5cbSyTEbicvI7SOefVmY+2eOK4nwteXSQ6xa/wDCUXWpa3bSXwTTLo27OoWd/Kk2ARuQV2Yy6ph8 DaNu21ZN4w1q31LT9USTTEuLKWOG8js44milYBVYFLyUkjJOML0+8OhAOkGh6X/YcOiSWEE2mQxJ ClrOnmpsTG0ENnONo656ZqPSNJ0HSnu00XT9Ns3DqlytlCkZ3Bdyh9oHO1wQD2bPeqGqtqPh/wAJ 3ssN3Jc3IuXk+0PGXMEUtwWJ25ORFG5wO4jHA6Vwun+I7uy0HxDqGn6rPq8MniMQzarBHbh0hFtC N43bYuCqpuPy87sGgD1DVNIsdatVt7+DzURxLGQxR43HRkZSGVhk8gg8mstPA/h6OJljspEkMzT/ AGhLqYTiRlVGYSht43BEzhucZOTXJL4w1WXwa9+t68UMeqfZ/tsrWollt/L3bg6lrcNvO3cSFIU9 GIFJNq9/q/gk6rD4g1qzhs9UgjkuCloDJCZoN7l4w6OiKXO5NqnDBlYA5AO2m8LaTNZ21qYZ40tt 3lPBdyxSLuOW/eIwc7jycnk9aWXwvo8uk22mfZWjtbaTzYPJmkjeN/my4kVg4Y7myc5O456msa9v bqbT/DUGi+J2uo7/AFF4JNTVYJjLGIbhyBtQR5BjABC8Fec8g09b1S+0e9Sw1HxW2nRRWZmgvXto Q17KXceWQVKkqojyqBSxfIx0AB2Mel2kVxaXASRp7S3a2hkkld2EbFCwJYksSY0O5snjryc0L/wh oWp30t5d2AeWbb56iV1juNv3fNjBCyYGAN4PAxWFqninWdFstH1O606eRdRs0hazjVf9Hv2AMakk g7WJZCckAqvTJNbEGh6r/aWnX1zr08nkRQLcQKu1J3SOdXYgEKNzTI2Nv/LFfbaAJqvh0ax4r0fU Lq1s3tNLDzRO+WlaY8AbSuAq/eByTuA4G3J6GiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAryqD/kG23/X BP8A0EV6rXlUH/INtv8Argn/AKCK7cHuzlxWyKcv+ui/3z/6A9eVL90fSvVpOZ4v95v/AEB68pX7 o+lZZl0PJxfwI+rdP/5Btrxj9ynB7cCrNcHrehSXl9BeT+Hzr1q+mxwQQGdFFrMCxMmHZQu4Mg3r lx5YxWf/AMIBct4b8RfbbUX2vmFBp968uZGmSxgjEiOTlGMyNljgnAzxiuc+gOwn8J6dc3Es73Os h5HLsI9avEUEnPCrKAo9gAB2rYghW2t4oEMhSNAimSRnYgDHLMSWPuSSe9Y8/jTwra3EtvceJdGh nicpJHJfxKyMDgggtkEHjFc/pmjx/wBsG9k0EavJc3pvLXXVu43VIHfegVmfeqqpChUBRgB/eNAH eUVytl4Ss5fE2t6vqOnRvcSahFNZXDNllRLeBcrg/J86OD0LAYORiud0rwvrdv8AECDWHtbyNf7S vGup2e1WOW2cTeSBsHmuB+54kb5T0XjKgHplU9J1KHWdGsdUt1kWC9t47iNZAAwV1DAHBIzg+prg fDnhC50zxda31vpF3Zxq0pvJLua3lEgZWxslT99J8xH+t4xnjIFTeGfA02h2OkQWlmunSy+H5bbU pI5T/wAfZ8jYz7HVmIPn4ZWBA4DL8tAHolZ+ia3p3iPR4NW0m4+0WM+7y5djJu2sVPDAEcgjkVz+ ieEdV0vWILy5137VDHu3Q7747sqQP9beSJ1OeUPTjBwRYvvCkFh4Fbw94etzBbRMrJbC4dfMTzhJ JH5hJYBxvXJP8XpQBuR6lDLrNzparJ59vbw3DsQNpWRpFUDnOcxNnjuOva5XmX/CI391D4lj03Rp fDtvfWtikEUNxEjt5UsrSqPLLLHuVgvdTvyc5YU+Dwa0fgaXS5NJ1eWB9RNyLN7y1WVFx/CiAQbS wJ8o/L8xY88AA9Cv7630zTrm/vJPLtbWJ5pn2k7UUEscDk4APSrFedW3giW7+HOtaHd6ZB5kxnfT YruOEtAzRbUZhGPLRwxbmMAAHPUmrj+GbTVLXRLZPCKaTYQaq1xeWRECKy/ZZU3kQuQwLsi4PJA5 G2gDuaK43XvDEEbaSltoI1PRrNZ1fSUdAm6QqySBJGVGCYcBSflEnyjjFc7qum3+h6VodrbXEkGt 6k82mmCO4eSSO1ld2BUjJP2cOmH6KAeRkUAdtrsuhLqeljVppRcJIJbSMPKEZ/NiiBZV+ViJJYgN wON2RjBNb1Y//CLaMYNNhNn+702JIbQea/7tEeKRR15+aCI5Ofu+hOdigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAK8qg/5Btt/wBcE/8AQRXqteVQf8g22/64J/6CK7cHuzlxWyKr/wCvi4z8zf8AoD15 Qv3R9K9YP/HxH9X/APRb15QoOwdelZZl0PJxf8OPqfR97Le2mseFng1GdLW7mNrPZ7IzG4FtPIGy U3htyL0bGB061cvvFekadcXMNzLcg2v/AB8PHZzSRw/IH+d1QqvysDyR1pdQ0QaxZaYVv7uxnspB cQz2ojLBvKeMgiRGUgrI3b0qldeDEu4r6GTW9UEOortvo1EGLk+UsJZv3WVJVBnYVHoBXOfQF288 U6ZZX01m4v5p4SBKLTTri4CEgMAWjRgDgg4znBHrTrvxLptjqS2NyL2ORpY4RIbCcwl3ICDzgnl8 lgPvdTjrUNx4blbUbu8sdd1PTjduss8VstuyO4RU3fvInIO1FHBxxWRN8NNKuNeGrzXt3JcC9W9G +G2Zg6yCRVEph80ICAMB/u8UAammS3sfjLWbCfUZ7u1W0trqFJkjHkmSS4DKpRFJXEaY3bjx15o0 zxZa6lr2paQLS+jms7s2yyGzn8t8RJIWMhQInLEAFvmAUjIdasXGgmXxENZg1W+tJGiihmghEJjm SN3ZQ2+NmH+scHay8H15pbfQTa69danBql8kd3KJp7LERhdxEsQOTHvHCKeHHI+ooAfourWmri9m tLi7kEdx5ckV1avbtA3lo2wK6K2CGD5OfvnnGAMq0+Inhi9RZIr24ETBiJZbC4jj+WHzz87IFH7r 5xzyvIzV3RfDsmjX97dtrepXxvX8yaO6WAKZNiIHHlxKQQsarjOOpxnms6L4d6NHo6aWZryS2VgS Gdct/oX2LBIUceVz/vc9OKANS38UaZdSSxx/blljhefy5dPuI3dExuKKyAvjcvC5JyMdaqXPjTT4 rKeeOz1Z3jCBI5dMuLfzXd1jRFaVFXJd1HXuT0BqvoXw/wBL0G4uZbeaQm4t2t38u1tbVgrEEkSW 8Mbg8f3vfqARbl8Gaa9rNCt3q6mQLh5NTnuDGyurq6rM7qGDIpB29sdCRQA7StfurnVv7L1Kxhtb l4Xnha2uTcRSKjhJBu2Lh1ZlBGP4uCcHG/WNp3h9rPVP7RutX1DUrlYWgja7EKiJGZWYKIo06lVz nP3RWzQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeVQf8AINtv+uCf+givVa8q g/5Btt/1wT/0EV24PdnLitkVx/x8x/V//Rb15OoO0YPavWV/4+o/+2n/AKKkrydfuDp0rHMuh5OL /hx9T3LUvEA0Hxndj5Ijc6Xp8f2u4Ui2th5l388rDGByABkbiQMjkg8QfEG50vWNWtrZFdNHWM3E I065nafciyHEsY2Q8MAN+ckHOBzXY276dLfT2gjia+FpCbgGLloWMgjBbHIysvGeMngZ5W40HRru S2kudJsJpLUBbdpLZGMIHQISPlx7VgfQGFr3iyfRL+809/sq3dwkI0cSZAnkkbyyjDPzFXKscY+V h6E1h3vjPxNbJe3KjSTbQRapcqht5N5jsrjyipPmY3OGHOMAg8HOB2F5pv2vxXpt3PNmOzhlkt4V tm4lOEZ2lztHyvgJgE5Y5OPlZaSaBql7qGmR2MZntUdLmKewaMFJ3bfjegDpI0bElchiuTmgDC1T xy1h4jt7aK4t5rSTUItP8pbG4JMjuEb/AEj/AFQZWJynJwp5B4qfS/E+py6zaRX0mnva3+o31jbw wxsk0X2d5QGYlyHBWE5IC4LL61s32meHbK4/tW80ywW4lnhjN0bRWkaRpUWLLBc58wpg9iAeMZpN C8M2GhPdTxW9s17dXNxPLdrbqkjiWZ5ArN1IXcF5P8PQdKAMGw8ffbNRtrX7Z4NbzpUjxb+JPNkO SB8ieQNzc8LkZPGRWnDdaz4e0PxJqniG5hvY7ae6vLNIAFKWiruSM/KPmGG5569TXS0UAebwfEHU TpmqTlIbiSLRbjVLaQabdW0amMD5CZceaCWHzKRwDwOK6bTNY1KPUdVstaS3Z7O1hvVaxikb93IZ Rs2/MzsphblR82RhQeKI4vCFno+q6jbW2kDTzA0moS2sEbrJGYxId4QHeCjBsc5DDrkVvCCFbh7h YoxO6KjyBRuZVJKgnqQCzEDtuPrQBi6r4iW18PQatbKyRSXltA322CSAqklykTko4VlwGYgkeh5H XI1HxffRrqYsFtZfs+sLpySLG0xRfsySsfLVg0rh2ZdqkED/AHTnsZ7eG6t5Le4hjmhkUq8cihlY HqCDwRWW+heHLHSnsX0rSrfTppV325t40heRiqLlcYLE7VHc8D0oAoaTqep69obSWl/aG8hv4o5Z FtZLfEayRtKjRShmRzGXABz1UgjORt6THfQ6NYxapNHPqCW8a3UsYwryhRvYcDgtk9B9BRpcGnQa bAukxWsdgyB4RaKoiKtyCu3jBznIq5QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUVHOJmt5Vt5I45yhEbyIXVWxwSoIJGe2Rn1FAElFeb/AAyuvFWp 6jr02ueJv7RtdN1C40tbf7BFDueMoRNuTkZBI289etekUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABXlUH/INtv+uCf+givVa8qg/5Btt/1wT/ANBFduD3Zy4rZEMf/H2n0k/9FSV5Mv3F69K9 ai/4+0+kv/omSvJU+4v0rHMuh5OM/hx9T3DX7cr4xu7ieLxCLd9Hto4JNJWbDTrJcEBjH1IDDhvk G75uoqG71LxJYeGPEllfWurz65dWYks3sYJHRXNnGjeW6/LGRMsjbcg5OQCTXeXerabpa266hqFp aGchIhcTLH5jei5IyfpVHS/FWmX2laLc3V3aWV1q1rFcQ2ctyu871DbVBwWxnGQKwPoDLuL1LP4l W/lprjQzWksNziC7ltBMWt/JI4MS/KJcsuAPm3EGrck7ab49uJp7W8aDULG0t4ZoLWSVBIks5YOU U7BiZDubA688VuyahZRJcvJd26La/wDHwzSACHgN8/Py8EHnsQar2WsWeo6je2tneWNz9j2pMILk SSRSZYMsiD7mNoxk5J3DA28gHA6vb39xqKJcRa/LqI162k2xJMbIWi3SMhwP3XCBST98MCT8uate H4teXxvNJd6hqXlNd3YktZLG4MPkb38kiZ5PJHyiPHlpu5w3c120utaVBqUemy6nZx38n3LV51Er fRM5P5U6DV9Mur+awt9RtJryD/XW8c6tJH/vKDkfjQBg+GdHuvNn1O+vtW+1f2je7YJrl/K8nz5V jXyz8u3btZTjPTB28VDomn+MoNYgk1bUPNsRu8xPt0MmflOPlWxiJ5x0dfx6HsKzLLxHoepTJDYa zp11LIpdEgukdmUcEgA8getAHPaj4Uh0P4beI9L0oXd08+mSIiNh3dktFgQKFAySsScY5JOOwDv7 H1aO413TLPUtR2NZ21zaXVzK7gXW+beA2fu/u4tyAgANjADYrpbDWNM1Xzf7O1KzvPJbbL9nnWTY fRtpOD9apWHiaw1LVtQtbW4tpraytYbh7uK4V0y7zKynHA2+Tzz/ABdscgHMq2va34an1OePVLCf UNQso0sozJFLbW63MayHAOVLAyszcfJjPApvhjRNQuLjVdO1WbV2so7mG6tnu5Xclob+4KBWkzwY 4LYkDqGB6tmuwXVo9S0uS78PT6fqbhtqYvMRE5GQZEV8EA56Ht0zmnaFqf8Abfh7TNW8nyft1pFc +Vu3bN6BtucDOM4zgUASaTpsOjaNY6XbtI0Flbx28bSEFiqKFBOABnA9BVyqep6lDpVqlxOsjI9x BbgIATullWJTyRxucE+2evSjStTg1fRbLVYA6W95bx3MYlADKrqGG7BIBweeaALlFUNN1i01S1tZ 4WKfa42mgjlIDyRAgeYFz935kOfR1zgnFR3fiPQ7BUa81nTrdZHaNDNdIgZlYqyjJ5IYEEdiMUAa dFUL7W9J0yOOS/1SytEkUujXFwkYZQQCQSeR8y8/7Q9aXUNVttO0z7e+6aMlFjWHDNKzsFRV5AJJ YAc45oAvUVj/ANrXkfi2PR5rKBbWe0lube5S5LO3ltErK0ZQBeZuCGb7vbNXINQhuNUvLKKe0ke1 SMypHOGljZ9xw6Y+QFQpUk/Nk8DGSAXKKw9H8U6bqsz2purSHUFubmEWZuVaUrDM8W/bwcHZu6cZ 6nGa0J9Shg1S004rI9xcrI6hAMIiAZZueBllXvyw9yAC5RVWLUrCf7P5N7bSfad3kbJVPm7fvbcH 5sd8dKjGtaUzXqjU7MmwXdeATr/o4wTmTn5BgHrjofSgC9RVKy1jTNSmnhsdRtLqW3O2ZIJ1doz6 MAePxrO1jxRbaTPPA0LO9u1j5rMwRAtzcGEHdzyu1mIIHGOeeADeorNXxFoj6XJqi6xp506Ntr3Y uU8pTkDBfOAckDr3FKus2UWk2l/fX1hbx3EausgulaFiULnZIdu8bQxBwMgE4FAGjRVeyv7PU7VL qwu4Lq2fO2aCQSI30I4NUR4l0pbOe9uruKztIrl7YXF3IsUcjqcHaSeRuDL25U9uaANaiqE2u6Rb 6d/aM2q2MdjvMf2l7hBHuBKkbicZBBGPUGkude0eyW2a71WxgW5UvAZbhFEqgAkrk/MACDkeooA0 KKq2mpWOoAGyvbe5BjWUGGVXyjEhW4PQlWAPQ7T6VNBPDdW8VxbyxzQSoHjkjYMrqRkEEcEEc5oA korD8S+KdN8N6beT3F1aG8htJbmGykuVjkn2KWwoPPOMZANWbnxJoVnemyuta06C7DBTBLdIsgJw QNpOcncv/fQ9aANOise38SWdz4jn0NI5xdQ+ZucqNh2JbucHOel1Hjjs3oM7FABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVPVrybTtG vr23tJLye3t5JY7aPO6ZlUkIMAnJIx0PXoauUUAeZ/DOTVLLWdbsrvTJFg1O9utX+0iC6jWFnaMC E+fBGGOCSCCfungV6ZRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeVQf8g22/wCuCf8A oIr1WvKoP+Qbbf8AXBP/AEEV24PdnLitkRwf8fif7sv/AKJkryVPuL9K9bt/+P1P9yb/ANEyV5Ig +RfpWOZdDycZ/Dj6n0Zq2h6g+uS6np1vplybuxWxmS/LDy1VnYMuFbcD5h3IdoO1eRiuSi+Fk8Vg trLb2d6bmytbe8L6nd26K0MKRf6uLCzL8mRu2Hk89MdHfeJo9I8e3VhKbi5lubCzFnYxOuXcyXW9 l3sqD5VXJJGcKOTgU3XPiboWgand2F5v82zAM/8ApFshXKBxhHlV34YfdU5PHWsD6Am1zwhJqnia 1vIvso0648v+1oZF+a48lt8GBjDYY4Of4QBzVmzs9ej8a32pT2emrp9zbxWoZL12lVYmnZX2GEDL eaAV3fLg8tVi/wDEclrrUmlWuialqM8VvHcSNatAqors6qCZJU5zE3TNVP8AhNE3eZ/YWq/Yv7Q/ s77bm38vzPtH2fOPN37fM4ztzjnFADNP0HUdIvrm3tbPSJtOutQe/kuJSyzhnk8w5QIQ7AnCsWGA F4O3nM0/whJpPiF9ZvLaKWG0ur2+jnS9uppAJjIxVLUDYrYfB27i2OBk8Wz8TNCGu/2TljN9s+w7 vtFvnzfN8rHleb5uN3fZ056VpeHC66r4ohaeeSOLVQIxNM0nlhrW3kKruJwu52IUcDPAAoAkg8Wa dc3EUCW2sh5HCKZNFvEUEnHLNEAo9yQB3rjbH4YXUfh2HSriWyjJkHnSwZJCHSvsbbcqMnzSW5xk c9eK7KDXdRmuIon8J6zAjuFaWSWzKoCfvHbOTgdeAT6A1JoFxrtx/an9uWUFr5eoSx2PkkHzbUY8 t2+ZvmPOenToKAML/hEr/VjcnVotMsd2jzaTH/ZxZtyS7cscqu0DYNqDOMtzVKXwJf6tba5FqkWk 26X9tYwxxWJcITbSO/zkBSA2UHynKjgH5QTv3HidrebXbtrZzpGi2zvPKoBeaVV8xlj+boq8HOMs 2M/Kam1jxTbaP/aIezvbmSwt4LmRLZFYsksjoNuWA4MbFs4AHOeuACr4T8OSaLdajeT2kNvPeCJX KajcXruE3YLSTYP8XAAGOeTxipB4Mkv/AAXp/h3W2tlTTSkcEsEUVx5scabEZlnhZUYgnIAOMcNg kVZ0/wAd2GoeH9V1pbS4S00yF5pcT20zOFUsyr5UrgMAvRivUe+Nqx1GS5sZLq80+50wRk5S8eIn aADuzG7gDr1IPB4oAyvD/gnS/DyXKQrHcJcPE7K9laxANGxZD+5iTJDEEFs4IBGOcza3pUt5Y2Wh WVpFFpUhEd2VIRI7dMfulQdd4+TAwAu72BxdevLzWfhhrGszLd6dIlpcXtgsFxJbzRqsTGJpDG/J P3tp45AIytdBr+qJpq2Qnsb6a3nu4ImntZFQQO0qLHv+dWKl2UEKGyMhhg4IBBq2maimr6ZqejRW TvaW89q1tcytChjkMTZVlRsEGFeMYIJ6VzD+B9WNqpltdLuL5mui91Ff3FlIgluZZgA0akuuJB8h wAQeTmt7XNUvdP8AGejR21lfX8cun3pe2tJI15WS2w7CR0U4ywznPz8dTVi48Uxjw02q2tlcSztM 1pDZttWR7gSmLYfm2jDqcnOAAT2oAjtPDUkOpeHbi4a2uBpWmTWjOYwpMr+QA6KBhRiKQHBGNwA4 JqX+yZLrxFbvNZww6VpUYFjGNpDylQN4UfdCLlF7/M3AABKat4mHh1LCPU7O6nmutkKS2camOS4b pGoL7lJIJBb5cdWrK1j4n6Hod9c2d9HLHNaqrXCNc2qNGTGsmNjTB3OGH3AwJ4BNAGxrNhqh1rT9 X0qOznmtoJ7Z4LqdoVZJTE24OqPggwjjbyCelMhstYi8c3uo/ZrE6Zc2kFt5n2p/OXyjM+7y/L2n LTbcb+Auec7RBqnjRNMOsuNC1W6ttH/4+7mA24RcQrMcB5VY4R16D6ZrQ1HVbiLWtO0qxgEs9wTN PI2CkEC43MeQdzEhVxnkk9FNAHOW3hLVt5srmHSRY/23Jq32qNmM/wDx8tMi7SgG77ql93C5XB6n f0zT7lvEmq6zeW6QtLHHZ26hgzGGJpG3kjpuaRjj0Vc85AxdC8UXFvbTJf6bqb2/9s3VomoM8TRZ a9eKNQPM8zALKn3cDHHArXtvFdvc6lDaixvUinu5rOG6cR+VJLF5m9Rhywx5L8lQOKAMrw/4Nn0b xXd+IDFpouNT8z7asMYXyvmynlNtBOQPnzjc2G7YrFsPhjLpuj6tp9rDZq8ujXGmWt297cSM/mdC 0bZSIZAJCBskkjA4PV6d4vh1F9MP9l6hb22qY+xXM3lbJcxNKOFkLD5EY8qKb4d8RahrOraxaXei XdjHZXAjjklaE4/cwvsfZKxLkyFgQNu3AzuyKAJrnR2tdes9WsLSAx2WmXNqLeLCO5Z4WjReAoUe U45IA3D3xlXnhO9vPCNxblbE6zfXsF9dtMC8TMk6SeWTjLKqIIxkcgDOMmjxNrl9NofjD7CrwWum aZcKLxW2u1z5Rb92Q2QEGMnH3jgH5TV1/GSW9vq0l5omqWsmmWsV5NDJ5DO0TlxuXZKw48pyQSDx wDkUAJYaZrNpd6trTWWljU71IIVtIrl1h2xFvmaXytxYiRv4OiqPeqeleGNTGh+ErDVYNOzoU8Zc RTNMsqR2skSuN0a4be6tjsBncTxWpd+LbW1j1J0sry5Wxube0zD5eJpZjGFVCzgceamS20DPU4Nc 3rniaDxJ4O8T+Rb6xpd7pFjNdI32nyGEifaIxhoJTuAkgkBUnBwDg8UAbM+j6rZxa9HpiwpJrGoL Iksb7fssbW8UbykY5cGNyAM5LLnHOJL7w49pc6NdaFZ6eTpcEttFaXLGOMRybMlWVWKsPLH8JyGY d61dX1dNJW1H2W4upruYwQQW+zc7hHkxl2VR8sbHk1j3njqysNNnu7qyuIHt7oWk1vPcWsLxuY1k +88yxkbXXoxPPTrQBzdl4JvLzRdKnktI1v8ATLzU1W3FzPYIVluXO5Hi+dRhVK8EFW+hq6/gCf7L oMFvFYQQ6eWaSHzZZAC19bXJ2s4LN8sMgJJGSw4APGxaeOLTUrGwuNN02+vpL5Lh4oIGgLBYZBHI SxlEZG5hghiDnIrEsfiBbaJo1o2sR3Qnvr7UiguLq3jMKxXbrsZpZVXKh1UKpbhTjgUAXdM8N6/o Oo3dzp39mSC9MqOJpXTyFN3czRsoCHedtxgr8vK8N3ra0DQTpug+H7W7lkN3pVlHbnyLiRYmYRqj EqCA4443qcdRg1C/i6F49HbT9K1DUW1Wza9gS38lSsQ8vJbzJFA/1ycAnvU11e6+db0BbPTI10u4 SZtUadl821IQGJRtfBJbION446jrQBg+JvCWrX8HiW102HSZI9ejHmTXjMrwuIljAACNuHyAg5G0 knB6VFrXgS91PVPEd2j2WNSsr2CDzC25Xlt7SNC3y8ANbyE4zgMMZyQO/ooArpYWcd414lpAt0+d 0wjAdshAct15EcYP+4voKsUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFeVQf8g22/64J/6CK9VryCeW5h0e0a1gaZzGgKqqkgbOvzOo9O/wCFduD3Zy4rZFi1/wCP5f8A cm/9ESV5Gn3F+leraW80ksTzxmOUxz7lIAI/cy+jMP1NeUoPkX6VhmXQ8nGfw4+p9O3ekaNqd5eR 3Ecct1NbwLOomIkWNHkaJhg5TDmQqwwcg8/LxDP4S0q4uXuC+pRSuF8w2+qXMPmFVChmCSAM21VG 45JwMmuW8QajHp/j/UPM8SjRA2jWjIxhR/OcS3OF+dTnqfkXDNng8Gqd14z1X7PcXNzfyaVqkFtb y2mhtagtfu8KSMoDKXb52aL5CNpTLVifQHpKWNvHqM1+seLqaKOGR9x+ZELlRjpwZH/P2FV/7E07 7D9i+z/6P9r+27N7f67zvP3Zzn/WfNjp2xjiuM8SeKL2w1XWFTV3s7ux8v8As7SfsysdTzGrHGVL vuYtH+7I2lcmrMkslh8R5re/8Y31rBcQWslnaTtbJHO5mmDQoGiycDyx8p8whhlj8uADoU8LaZFq BvYm1CKQzGcxxalcJCXLbiTEJAnLEkjbg5OQcmoNSsNJ0BtU8VyJfCSGJ7u5SG8l2S7ItpPk7xGW 2IAMjsDnIzWPf+IdYg1G5ii1DZGkrqq/8IfqE2ACQB5iSBX/AN5Rg9RxR4k0e807wX4yuLnVp72O 40q78uKTOIcm5k4yx/hmSPoOIl7YAAOL8O/EL4Zapr1lb6V4FkiuzcRBLhdItlFuzSKiOzKxKgOy DPqRjnFe0XCyvbSpbyrFMyERyMm4I2OCRkZwe2RXzf4O062sPEM6WWgS29is9lHaas3m4voxqVqC /wAx2HdgMNgGBwc9a980DR7zSP7U+2atPqP2zUJbuHzs/wCjRvjbCuWPyrg4xgc9BQA618Oafb+G W0B1kns5YZIpzLKxebzM+YzNnduYsxJznJqK28J6VaLd+SdQ33axJNM+p3LylY2LIBIZCygFm4BG ckHINbdFAGFB4P0W3t9Tg8m6mTVIBb3hub6edpYwGAXc7kgYduhHWrWu6QNd08afLO8dpJIv2lEy DNEOTHuBBAY4B9VyO9adFAFe+sbbUtOudPu4/MtbmJoJY8ldyMCrDIwRwT0rHn8GaRdWcdpO+qyQ xy+cobWLsneCpBLebk4KKVyflIyMEnPQUUAY974Y0zUDZNP9uEllE0ME0WoTxSBG27gzo4Z87EyW JJIzUcHhi0t9SsZ43cWtgsjW1tvcgTSFjJKxLHexDEDPTc5z83G5RQBk6r4b0nW5kl1K2a4ZEKRg zOFjzzuVQwCv6OAGHY1DN4R0qa4affqcUjhQ5t9VuofMKqFDMEkG5tqqNxyTgZNblFAGfNomnXFr qltLb7odV3fbV3sPNzEsR5z8vyIo4x0z15plho62es6tqbztNNfyR7d2f3MSRhVjGSRjd5j8AcyH 61p0UAYUfg/RYrtrhYrvLXJuzE1/O0PnGTzC4iL7Ad/zfd61PB4Z0q21Fb+KCUTrM86A3MrRpI+7 e6xltgJ3vkgfxGtaigDFsfCekadcW01tFcg2v/HvHJeTSRw/IU+RGcqvysRwBwam/sO3gvtQ1Gxe W31C9Qh3aaR4t+1VVzCW2bgEQZABIGM81qUUAZNr4c0+38MvoDrJPZywyRXBllYvN5mfMZmzu3MW Yk5zk1bbTLN7u6ungDTXUCW0xJJDxoXKrjp1kf659hVuigDItfDOkWWkppkFqwtEnS5CNM7HzEkW RWLEljhlU8nGAB04pB4W0YQalCLP93qUTw3Y81/3iO8sjDrxlp5Txj73oBjYooAxv+EW0w2KWjm/ kjjmM8byajcPLG5QplZC5dflJGAQOT6mqz+CNCdo3MV6s0bO4nTUblJSXVFYmQSBmyIkHJP3a6Ki gDCHg/Rls7e2jju41tzKY5Ir+dJR5r75Myhw53Nyck0z/hCtEFvaQRx30ItPO8p4dSuY5P3ziSTc 6yBm3MATuJ5FdBRQBTj0u0iubS5CO09pbvbRSSSu7CNihYEsSWJMaHc2Tx15OblFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeTrBFcaXarNEkiiFCA6gjO 0c816xXlUH/INtv+uCf+giu3B7s5cVsiOxjSK7RI0VECT4VRgD9xLXkyfcX6CvW7X/j+X/cn/wDR EteSJ9xfoKwzLoeTjP4cfU+sh0FFA6CisT6AKKKKACqerabDrOjX2l3DSLBe28lvI0ZAYK6lSRkE ZwfQ1cooA8r0n4BeFdG1mx1S31DWWnsriO4jWSaIqWRgwBxGDjI9RXqlFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlUH/INtv+uCf+givVa8qg/5Btt/1wT/ANBF duD3Zy4rZDbX/j+X/cn/APREteSJ9xfoK9btf+P5f9yf/wBES15In3F+lYZl0PJxn8OPqfUU+t6b aXk1ncXkUM8FobyRZDt2wgkF8njAI59OM9RVWy8R2Opaxb2drcSfvbM3SpLYzIJkPlkOkrAIQBIA yjJy4+7tIMHifwuviUWGbs232eX99iPd58DY8yE8jAbavPPTpS3ejaxP4ttdYi1SxjtbaJ7dbZ7B 2cxyNE0mZPOA3ZhGDtwM8hqxPoCpq3iie38aaZoNoJIxKryXEkmlXMwYBoQFR1woBErZkyyoQN2M 4q/P408K2txLb3HiXRoZ4nKSRyX8SsjA4IILZBB4xVybTPN8Q2Wredj7NaT23lbfvea8Lbs54x5O MY53dsc05/CenXNxLO9zrIeRy7CPWrxFBJzwqygKPYAAdqABb/UpvGs+mxS2iafa2UFxKrQM0sjS tOuFfeAoHlKeVbOT0rcrH/sm8j8WyaxDewLaz2kVtcWz2xZ28tpWVlkDgLzNyCrfd7ZrYoAz9O1P 7ffatbeT5f8AZ92ttu3Z8zMMUu7GOP8AW4xz93PfAzNH8d+HNfnt4dNv2me4yIt1tLGGIXftyygb tvzAdSvIGOa6OuGs/h0bTRrfThrEoMUiyefFDscY077F8vzHaf8AloDzjp70AdBaeK9EvHnVL4R+ RC1w7XETwKYV6yqXADIOMsuQMjnmktvFug3VhPfrqMcNnBtMlxdK0Ee1jhWDSBQVY8BhkHsTXP6b 8Nra1vJ5rl9N8u406fTp4tP00WvmpKY8szb2ZmwhGST97gDnPQWujX8mnz2Ws6vJeo+1Ue2V7ORV U5yXjfcWPGSCoOPugE5AK0/jnw99inm0/VrDU54lXbbWV3HJI7M6xoMBuMu6Lk8ZYVVXxnOvmWU2 lx/20LhIIrSG7DxyF/MIbzdowAIZt3y5BjYYPGbU/gyweznhiu9VWSRV2STalcXIjdXV0cLK7LkM inOO2OhNVz4Ru5mkv7nWFfW/Oiliu47XbHEIw6qgjLHK7ZZQfmyd5wRxgAs2PiqM2mpy6tFFZNpt ut3O0ExuImt2VmWVGCgsCEf+EHKng8VZm8V6LBp+n3pu2eLUYhNZpFBJJLOhUNuWJVLkAMCfl4yM 4qG20LUYYdVuZNXQ6zfwiJbyO1Cx2+1WEe2JmbIVnZsMxySe1VNZ8G/25ZaSb+awvtS0+ExmfUNO SeGYsF8xjDkbSSgI2sMcjoTQBfm1m6u9Nt9R8PR6Zf2ciuzzXN89uqBTjjET8ghgQdu0rj1xQ0zx rBJo9lqGtRwaeuoagLCw8iV7hLlmJCMreWpAYqxBIAwAc81Y/wCEWX/hFoNAE8ENrv8A9JS2tFhS WMuWeNUU4RWzg9TgnOSc1papZ6hdCxGm6n/Z4huo5bgC3WXz4RndDz9zdx8w5GKAMbxL42s9A1OH TPO01b2SHzz/AGhqC2kSpnaCWIYkkg4AU9DnHGXWvjrRpIlW4uY/tSjNxHY7rxIBk4Z5IlIRSBkF 9vHXFXdR0i+fVDqWk38FndSQrbzfaLUzpIiszLwHQggu/OcfNyDxWVpng/UNBFwNI1xYhfTNc3xu LMSl52PzyR4ZQhPHBDAYHHXIBv3et6dY6xp2k3NxsvtS837JFsY+Z5a7n5AwMA55Iz2qK48SaVaa qmnT3Dx3DSLEC0EnleY2NqGTbsDHIwpOTkcc1Ld2mozaxp1zbap9nsYPN+12f2dX+1blwnznlNp5 469DXMal8PI9Q8UTaybiwVnv7W+V205XuUMPlDyxMWyEIi6AAgseSMggGjrXjGHTdVg06zt1v5xc 28V9smCizSaVIkLcH5iXBCcZAY5GOd5L63k1GawWTN1DFHNIm0/Kjlwpz05Mb/l7iua1P4e6TfpL 5E+o2jzX0d7L5eo3IRnEyyviMShVLbSAQPlJBHIFdKkNwuozTNdbrV4o0jt/LA8twXLPu6ncGQY7 bPc0AZ+n6teXHiHU9JvLKCD7JFDcQyw3Jl82OR5VXcCi7G/ckkAsPm68VjeD/HK+KTbl30KIz2yz rb2usfaLlCQDteLyl2kAnPJwRj3GjaaNrEHi261iXVLGS1uYkt2tksHVxHG0rR4k84jdmY5O3Bxw Fot9B1OTVbO71bWI72KwZpLWOO0ELb2RkLSNuIY7XYYUKOc46YAJl8V6RLpOtalb3DTwaNJPFebY 2BSSFdzqAwGSB3HB9apaX4nvr69exm0+whvJbD7dYpFqPnLMmdp3kR/JyU5AcHccE7SK07Kw1SG2 1KO81k3UlxcSyWkgtkjNpEwGyPAyH28/M3JzzWNongw6PqV9qqNpCalPbfZ4pLPS/s8aclizqJCZ CTsz8w4XjGSaANnw/qs2s6T9ruLaO2nW4uLeSKOUyqGimeIkMVUkEpnoOtV/EfiBfD8ujtLgW95f G2mPltI4HkSuuxV5LF40GMHOSMZqLQ9I1rRNKvreS/sL2aSWe4ttto9uqyyySSsHPmOSu58DABAH 8Rqs3hvXbnRtDS88RJLrOm3TXT3xsl2zExyoFMasoAAlAyCCQvYnIANBvFmhpokusPfBLKGVYJna Nw0UhZVCOhG5Tll4IGMgnjmoJfF2mNDbNDPcxGe7jtQ02mXBCOXjGxxtHllhIoVnwMsD8wBFMXwt I+mTQ3OoCW8udSt9RubhYNqs8UkTBVTcdo2wonUkdeaseJtH1LWrW3t7DUbSzSO4iuHM9m05ZopU lQDEiYG5MHrkHjHWgC3quu6doxgW9mcSzkiGGGF5pZMcsVRAWIGRkgYGRmsXTPHOnTaRDe30+0XN zeLAbe3lkBhhuGjEjbQ20bdhZmwMt26Voaho+oXUunX9tqNvb6raQvC0zWpeGRZNhkHl7wQC0aEf PkY6muavPDviHQrbTm0aVtQvI/t6zXHkxhsXM6zE7WkQKQQBuG7GPuHOAAdFN4z0CG2tJzfM63ds t5EsNvJI/kMMiVkVSyJ/tMAOD6GprrxZ4bsfI+2eINKt/tESzw+deRp5kbfddcnlTg4I4Nc0fhvD JpujLKNJnvbLTINPlbUNNW8jZYxwUBZShyW5zg5GQcCuhfwrYTW1pFLPqCfZrdLdRZ389nHtUcfu 4XVB+A6YHQCgDNtvH2kjUtVgvLyJbe3uYlguYoneHyZIIZFeSUAooLSMAxKggD3Na134o0ex16HR Li5ddQmjSVYxBIyhXcopZwpVcsNoyRzj1FY8/gq8dtWtYtbK6TqrILm2lgaWXyxBHCyrMz5yyx8s wY8+uSegh0zyvEN7q3nZ+02kFt5W37vlPM27Oec+djGONvfPABhXfjOa3a8u002KTSLKWRJ7g3YW YrEwWaRItp3IjZBJYHg4B4zuw6n5viG90nycfZrSC583d97zXmXbjHGPJznPO7tjnFuvCV3Ol7p8 erLHol9M8txaG13S/O26RFl3ABXJYnKk/McEcY6qgAorI0q11uLVNVudU1GGa0nkX7DZxQgC2jXI JL9WZuCQeFIwDitegDD8O3+pXUusWmqS2k0+n3ot1ltYGhV1MEMuSrO5BzKR17CtysfQdJvNMbU5 7+9gu7q/uxcu0FsYEXEUcQUKXc9Igc571sUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABXlUH/INtv+uCf+givVa8qg/wCQbbf9cE/9BFduD3Zy4rZDbX/j+X/cn/8AREteSJ9xfpXrdr/x /L/uT/8AoiWvJE+4v0rDMuh5OM/hx9T6N8QeJpPD15J58SPatp0txb4B3vPGRmPOcHcHXaMfwt+G Tf2Gs3/jvw5HqNxpMsUVnNeeQ2nu4SWNrYMyky435dtj4+QE8MTmuyutPstQEP22zt7nyZBLF50S v5bjoy5HBHqOags73TtT/s/UbZPO+02hmtbnyG/1LbGI3EfLu+Q7Tgnb0O04xPoDjpdS1jR9R8ba pamxbT7G9S4nhlRjLMFsrcuFYMAh2jjIbJOOKs3/AI++x6jc2v2zwavkyvHi48SeVIMEj508g7W4 5XJweMmujufDOgXmoNqF1oemz3rEFrmW0jaQ4AAyxGegA+gq7Z31vqEDTWsnmRrLJCTtIw8btG45 9GVh7444oA5+Gws7j4naheTWkEl1a6VZfZ5njBeLdJdhtrHlcjg4611FZ76LZPri6ztnW+WIQlku ZFR0G8qGjDbHwZHI3A4zxRb61ZXesXelwNO91aYE5+zSCNCVVgvmFdhba6naGzg9OtAEllHfJdai 13NHJA9wGs1UcxxeVGCrcDnzBIe/DDnsOe8Lz+KL3S724vdU025dZ723gVbB4iskdxJGhYiUgp8n 3cBsYyxIJPW1QtdC0iy1GbUbTSrG3vp93m3MVuiSSbjuO5gMnJAJz3oA5WbxxdzaHqGo2NvADp+h y31ykqk+XdANtiOCPumKUMOv3eR3luvFmqaPZasmo29rPfWiWkkX2NJCjC5kMSKVG5mKspzt5YYI AJxT7rw1aaT4E8Tw315BC2ow3dxqF9DabVUujbnEYJJCr23EnB5ya3oPDmh2tjPY2+jadFZzjE1v Haoscg/2lAwfxoA56x8W6gum6rPfJaILIQtHeX9vcaTbSCRipUmZWIK46jcDuUcZ4SDxtNc2bXiS +H57e3ureO6/szVDelIpWKFm+RNmCVOTuyA/TFdLpmhaPonm/wBk6VY2Hm48z7LbpFvxnGdoGcZP 5mrlxbw3VvJb3EMc0MilXjkUMrA9QQeCKAOSfxJrF1Dp76fHYqNR1iayt3nRyBBHFM3mEBhkloSw 6AqQOD81Mt/EWvXGqyeHlOmrqsU8qSXhhfyDGkcEm4Rb924/aUG3f/Cxz2rq49PsoYrWKKzt0jtO bZFiAEPylfkGPl+VmXjsSO9Z8um+Hdelvre50ywvXt7kC5W4tFfExijIJ3LyfLaMZGeMDPGAAaNi LwWcYv2ga6GQ7QKVRuTggEkjIxxk49T1rD8Q+JpPD17J58SPatp8txb4B3vPGRmPOcHcHXaMfwt+ FnUPCWjaho1vozWccGlQzLMbK3RY4ZNrFgrKBjaW+YgYyRz3zpXen2WoeT9ts7e58mQSxedEr+W4 6MuRwR6jmgDnX1DxRca1LpVpJpEMttptrdTSTQSOGmkaZWVQHGF/dcHJI9GzxX0XxHrniq2W80ld Os4Y4bd5I7uN5WkeWCObaCrLsUCRRuw3OeOOevEEK3D3CxRid0VHkCjcyqSVBPUgFmIHbcfWsLV/ D3hGDT5dQ1XQdJa2sLYlpJbBJPKhjXOANpOFUcAfgKAINR8S3dno/jO8SO3MmieZ9mDA4fbaRTDf zz8zkcY4x35qtdeIdat9Z1B1Ng2l2erWumtCYXEzCZbf5xJv28NcdNnIHXNbV74U8OaldyXd9oGl XVzLgSTT2cbu+AAMsRk4AA/AVfaws38zdaQN5sqTyZjB3yJt2ufVhsTB6javoKAOf/4SW7/4R3+0 PLt/O/tv+ztuDt8v+0Ps2eud2zn0zzjHFRWXiLVX8XNpmoRwWcLzSpbwyWsoaZFDFXSfJjckKGMe AVBPXFa3/CKeHPt5v/7A0r7aZvP+0fY4/M8zO7fuxndnnPXNR6bpXhq4vG1nT9K04XizzxteJZqk vmq7pL820NncHBPfnqDQBgeGvGmp65qOnO1lKbHUVZlUaXdRfZV2F0Z53HlyAgBflxywxuHNUbDX NVvfEum67enS47Kbw7eXtnGztD5SmS2bE8hLADbsJYKMfNwcc9UuieFtG1ezuYtG0y11G6naK3ni skWRpDG7t86rkZRXJJIz071dstA0bTb2S9sdIsLW6kUo88FsiOykg4LAZIyBx7CgDA0Txr/a+sQW P2vwpJ5u75bDX/tMxwpPyx+Su7pzyMDJ7YrQ8MS3v2nXrK91Ge/+w6gsMM06Rq+w20EmD5aKp+aR u1dBWfpmhaPonm/2TpVjYedjzPslukW/GcZ2gZxk9fU0ASaTHfQ6NYxapNHPqCW8a3UsYwryhRvY cDgtk9B9BUl9YWep2clnf2kF3ayY3wzxiRGwQRlTwcEA/hViq99ZRahZyWszzpG+MmCd4XGCDw6E MOnY89OlAGP4E/5J54a/7BVr/wCilroKr2Fjb6Zp1tYWcfl2trEkMKbidqKAFGTycADrSahqFtpd jJeXkhjgjxuYKWOSQAAACSSSAAASSaALNFVxexGzhugk/ly7NoMDhxvIA3JjcvUZyBt5JwAcR3Wq Wlnf2NlO8iz3zulviJ2VmVC5BYDap2qxAYjODjODQBcooooAKKKKACiiigAooqvYX1vqenW1/Zye Za3USTQvtI3IwBU4PIyCOtAFiiiqc+pwW1hLevHdmKNyjLHaSvISH2cRqpdhnuAQR8w45oAuUVXs L631PTra/s5PMtbqJJoX2kbkYAqcHkZBHWhL63k1GawWTN1DFHNIm0/Kjlwpz05Mb/l7igCxRRRQ AUUUUAFFFFABRRRQAUUUUAFFFRxzLK8yKJAYn2NujZQTtDfKSMMMMORkZyOoIABJRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXlUH/INt v+uCf+givVa8qg/5Btt/1wT/ANBFduD3Zy4rZDbX/j+X/cn/APREteSJ9xfpXrdr/wAfy/7k/wD6 IlryRPuLx2FYZn0PJxn8OPqfQHib7V/bY+0f239g+xj7H/ZPm5+07m3eZ5ft5e3f8n3s1i+E5X0m /wDC1vLb+IIydCjtr2N7a8e3juNlqIhgqYkIAlBYYAO7cQa9MHQVnprFnLrjaTDeWMl1FEZLi3Fy DPF9zbmIc7SGyWJGPl4O7jE+gOE8VSa7D4mvDa2mrXwby/sUdvc3VsifIuQGjR4W+bJzNjqR0ANX fDsWv2eq5v7SRdHOpX/2cW7uJFd7qZhJNHtGYyCNpDEDIYg5BXrrvXtHsL2OyvNWsba7lx5cE1wi O+emFJyaf/bGl/2p/Zf9pWf9obd32Tz183GM52ZzjHtQByl/pnjuTUbl7PU9lq0rmFf7RgXamTtG Dp7EcY4LN9T1rQ8PX9n/AMJZ4s077XB9u/tCOf7N5g8zy/slqu/b1254z0zXUViaH4p07W5bm1S6 tUv7e5uIZLNbhXlVYpnjDleoDbQ3Tjd1PWgDbrl/ENr/AGB8OvEn2C4njkW0v7xJQ+HSSTzJSVIx jDOcdxgc55q5ceKdNTWrDSrW6tLq6uLtraaKK5Uvb4hllyyjJ/5ZbcHH3vbBtx6jo2ste6ZHeWF8 0YaG7tVlSUqOVZZEycdwQR7UAcHewX91oXiK206HX5reXQbpJ49SWZne7K4RYg/XI35EfyZ2Yrc/ sbVo7jXtLs9S1Ha9lb3Fnd3UzsFui824B/7v7uIsg4AYgABsV1Nrf2d95/2O7guPIlaCbyZA/lyL 95Gx0YZGQeRVYajourWN6gvLC9tIw8V2BKkkajBDLJyQOM5BoAx/Bmoahr0F1rt/C9otwwghsjMX WIRFlc9AMmQvzjlVT6CDQ9T/ALI+HlrdLFrk0xZooIdebbeyyvKVRZDzjLEYOOEwe1XdI8RaG015 ZaZLpyaRptjDci5tpk8hEZplK/L8qhRDknP8XbHOjLqeiT2P9oy32nyWlpKT9paVDHDIMqfmzhWG SOueSKAOdvdIutG8M2NvGbl/NvBPrU2nKwnm3hjI6bPn5k2D5fmCDA6CuT8vXbUX0tnYa1LpE2rS PIJ57q3uXT7NbrExaON52TKyDgZyF3HIIr0+XxBosOnRajLq9hHYzHbFctcoInOCcK2cHhWPHofS rFlqNjqUcklheW90kbmN2glVwrgAlSQeDgg49xQBw/23xRpvg/SNcayvL6+s5JUuNOWSQyTwO7LG fuAs6gRNlkBxvyBk1fubfUH0TTfCtxcGfUNQiZ9RnMhOyHcDPtJ55L+Wg4wGz/DiupvtRsdMhWa/ vbe0iYlVeeVYwSAWwCT1wrH6AntVJtV0sXOmXUHlXLarJ9lgurfa4YLHLKMuDyuEfGM8n3JoA5Px imoWOqWsdjaX8unR2axw2llJd28aOGbo9qrH7u0bXUKABg8nGP4nh1i88OaxBqFr4jOozaWiWFvZ tJNGc24EiSmMCNn8wyA7wMjbsGTivWqKAPMvHep+I01G/XS9G1SSe1gDWMttd3KpIQu8v5ccJjch iVKSPk7RgDdzP4y0LxBd62NTTTNP1KK3vbH+zt1zIslqonhaQ7BCwBZgdzhuIx04IbrtR1a8sNe0 mz+xQSWOoStb/aPtJEkcgill/wBXswVxFjO8HLdOOdigDJTxBbS+LJvDqQXDXMNmt5JOFBhQM5VU LZyHOCQMdBnNcvoml6lp2o2F4j6mBda5qSXNu7P5KW7PdSI2zouXWMh+p8wDJBAruY7aCKaaaOGN JZiDK6oA0hAwCx74AA57CpaAPMdMgv5vEXheS7i199Shu5ZNVadZjaRv9mnUFC37sLubCmPjBAbk irXhDVNfvvG8/wBv0nU7G1mspJZ1uJ55YknEibEQvEiKQrOP3ZYMADklc16JRQBzA1h/FnhzV30R bq3uLS6lt7eSU+Ws8sLA5VlJzEzDaT3G4EdqreFr/wARavrt3ea1YPp1qlqjWUALgMkrMf3oPHmq I1BH8O/tnnq7e2gs7dLe2hjggjGEjiQKqj0AHAqWgCjptjbaDoVnp8UjfZbC2SBZJWGdiKFBYgAZ wOeBUPhzXYPEvh+z1m2trq3gu1Lxx3SBZNuSASASMHGRzyCK0ZoYriCSCeNJYZFKPG6hlZSMEEHq CKVEWNFRFCoowqqMAD0FAFXVtNh1nRr7S7hpFgvbeS3kaMgMFdSpIyCM4Poaw/HOirrGlWYC3zyR ahZ/La3M0fyG6h3sRGwztUFtx+5gsCDzXUUUAcf4x2adY6P9m/tx7i2u7by/sX2ufMKzRed53l7g /wC7Df6zJPzYySat+IZ2b/hHNXitbyW1tb77RMsdrI0qRvbTRg+UF35DSLlcZHPHFdLRQB554yu9 bl1G0ntLPUJtJmsg0Jtri7tZI5yST5iQwu+duzAcBQd24Z6asbXz6j4LfUxrY1BrWU3IshiyEvkr v+1fjnZ/tZrrqKAOb1qMa/rMGgGKOSxg2Xeo7+Qy5PlRYxg7nXcc/wAKYwd1V76011vG1vBBLONH uSl5NKJWHlNCNpiHYCQtCcZGQkvBzXURwQxSyyxxRpJMQ0jKoBcgAAk9zgAfQVJQB5lqOp+I5PF8 bW+japEU1OGFpFu7loRa+aqM/leSIGDISx+cuu4nICkV0um6Vdz+LtY1K7vdVSK3vlFnbmd1t3jN pEGwnRl3s59mTjB3Z6iigDm9MjGu+IptclijNrZeZaacTyd24rNKOOMlQgx2UnOHxXBaPZa6vg2w sNITxFb6sNGlhvFvTNFFG32ZhEIt+EVxJ5ePLwQN27mvXYIIbWBILeKOGGMbUjjUKqj0AHAFSUAc adYfWNfhcWeu2+kppN59qLWtxATIXg2qoADmQKJNpUZ5Owk5q14FvWn0Wa1lTVRJb3dxtOpQXCOY WnkMPzzAF/3ezuSOAcGuoooA4LTJ9RT4ZW+lWdrqNvqmm2drbXKm2eN8LtWXyXZQsjbFcqVJ529M iq2k3n9jav4g1K1tNZltpLWwt7FdU85XnmMk48tWmG/G51zuyRuJ+7ivRqjlghmaJpYo5GiffGXU Eo2CMj0OCRn3NAHE6v4ZhtPCVpb3Eck9yt2bu7lgsPtSTTujiR5IesiHeRgZI+TH3eMTT0/s280y 8XwxHaWVtqis93pehzW73Cm0uky1sFaQBWdRuOR8/bBr1WigDzPxdJbeINZ0W8XTZJrOG3vInOp+ F7u8VZC1sV/c4RlJAbD9OGHXpVn0ayfSbSVNNgCxTzL5UPg+ZLVtwiJ8y1YmQsdi4lXgYI7c+rUU AY3hVHj8M2avo9vpDYY/YrdQqR/McEKANu77xHUFiDkjNZHj5LI22lyy6XPeX0GoWs1vLBp0ly8C JcwtKQyI2zKKe43YwM9K2L7wn4b1O8kvL/w/pV3dSY3zT2UcjtgADLEZOAAPwrQsbCz0yzjs7C0g tLWPOyGCMRouSScKOBkkn8aAOT8Vvp9r4u8Oag2lXc15a3DNNd2ulTTslube4QKZI4248x1+TOeQ cY5rtKKw5/BfhW6uJbi48NaNNPK5eSSSwiZnYnJJJXJJPOaAOF1TSILfWL0w+G4NZnkupHW11Pw+ 0jPvkLELegGNUyxI3gkAgcYxUkPgm61W01SJvDehWsl3qF//AMTecE3qo9zLh1XyhztI2HzMY2np xXqVFAHldmNI1LXrQWng59Ct0vUf7QNBnjuZijqyZZYAkaFxksXPyjBAycXLe9uf+Eb8bWOlp4j8 7yp5tLa7gvfM2/ZYgBHJMN27zt+FzuzkgY5r0iigDzafTfEWnaneNpFxq80q38tvai7uJZYTEdOM is24lSv2nA3noflz2pNM1aLSfEaXDz+Ik0+DQ7u6vE1UzYMkbwFmVZOpALfd+Tn5epr0qsq28M6B ZRzx2uh6bAlxGYplitI1EqEYKsAOQR1BoAwLjQHl8J6lc6lbyjU9SmjurkWcazSJsdTFHggeYqKq gr/F8+BlsVy0dn9mgke08L2whhnsZn1Cw8PS2M5CXsDtH5JUvINqs5K8fJ05GPXaKAPO/Gd5beI7 TSBBp93NBa6mHuF1Dw5dzxhTb3CgmAqrSDcVGV+6SpPbOaui2EukT7NOgiEdzFIRYeD5rVW+SVf3 0MpJuEw7DCcqSD3yPVqKAON8MDU7Tw039meGNJspTdHEWH06OdNo/feWI3ZGJAXYwzhc56CpviRa 2l54F1S3uNMk1CeS3lWzjjsXuWW4MThGAVWKEE438AZ6jNdZRQBxfjd9PutO0a8bSru6u0vbS5tZ E0qaaWCNbiF5TxGWiOwHKnaTgjBIxXSS3d/L9hl06zgltZ8NO13NJbyRIcEERmMktgn5WKYIAPU4 0KKAPNPFWlWy+Ir66OkpqEsxWQQ3/h57+ORhGq4imT/VAhQCH4yCcc5MVl4XvL2/1aZvA/htHeW3 8mTUeTbYs7cbIwISHjRgwBVlGQwwMV6hRQB49c6dpEaNoKeFJYvs0aWdzrr6DPJcXAC7ZJIjHC2S 2OHLjliwBwM+qxS6k2qSxyWlqunBAYp1uWMrNxw0ZjAUfe53noOOeLlFAHmOn6PDJeqtn4deDXU1 +4uJ9TksTBtt/tkjn98yjzA8J2AKWHzjOAOL2m6Pdr4htfD8mmbNH0i+m1KCcofKcPkwxrxjKNLJ wDx5SHvXoFFAHmPgjR4YovCjab4dfTLqztFGr3ctibRpT5BQxHcoaUmUq2eR8hOckZ7yCW/k0u5b WLSK2cBhs0+5knJTb1DeWjBuvCjPAwcnjSooA8zWz1q98B6vBf2ep3epiS2kjhuzkGNTG8ZAwVZl C5kQDLOrDoy1jJ4evroaiNM0m2hi+xKhktNEfTFYGeJpojDIczM0cZAO4DjbxuzXstFAHF+AtNj0 6TVBaad5Fk7R+Vcy6WljPMw3blZFRMquRtYqPvN1xk2vHum3Gp6RZRorvaR3qyXscduLhmhCOOIi CHIco2CD93OGxg7Wp6Fo+t+V/a2lWN/5OfL+126S7M4zjcDjOB09BRpmhaPonm/2TpVjYedjzPsl ukW/GcZ2gZxk9fU0AcFZaFqsvh250nQrG2XSZb8mcXsJ0uW5g8qPK7I7cY3NvUtsB2rgdcrs+EoN e0rwi1tb6FpsE8ep3gjtHu3hiSE3ErAqRATjJwo24KbWyM7R2lFAHGeIrCzbxQLzXtDOraS1kkUG LI3n2aYO5cmIKzfODH8wB/1eDjjPLWHhbW9Ru5LmxtLXQ7uOxjtonismtYTA1xeq+2P5ijlGhm2k 8PtzjNeuUUAcj4NstS0jT4tNh0u3g0qO8vvmkndJo1+1TGPbF5ZDKV2EHeOGzg4Gca90/RX8Q+Jz qnhGTVb+4u0a0c6S0gkj+ywKAtwybFG8OOWGDk16PRQB5lFoetRzweGtRtDeQak1leahfYZoswxR pMjErjLNbxAA9RIx7VWbRrG50zVrS28LufFM2oXxgv5NLaLyma5kaKb7SyAEKpRhtYkgAAdq9Woo A5OykgtfibrAWxu4ze2VmhuFsJRFLLGZy26UJsJCNEMlvRRyMDloP+Qbbf8AXBP/AEEV6rXlUH/I Ntv+uCf+giu3B7s5cVshtr/x/L/uT/8AoiWvI4gxjUsAD7HPHavXLX/j+X/cn/8AREteOiV4QEjs pWXruQoASeT1Yd6xzJXseVi1enH1PqnVP7YxY/2R9h/4+o/tn2vf/wAe/O/y9v8Ay06Yzx1zWXeW evSeNbHUoLPTW0+2t5bUs966yssrQMz7BCRlfKIC7vmyOVrbnvre1YJM5XjJOwlVHqSBgfjU0M0d xBHNE4eORQ6MOhBGQaxs7XPeur2OI8SeDtQ1TUNQexS2hW+Ks11/aNzGUYIqZe3GYpsBBw20Y4I6 kzf8Itqf2z7Liw/s7+1/7V+2b3+058zzPL27cdfk3b/ucba7SikMx4bnXZPFtxA9lBFoEVouy4cg yzXBbJ24Y4QLwdyg7umRWbaeGLm3k0mRmtt9nrN9fSMCcmKf7SVUHHX99HkdPlPJwM9VRQBwum+E 9XtL7w1FLHpf2LQ5pStykjm4uFaGSPJBTCsS6lvmO45ORjB0/Cei6nolvFYXkGmG2s0kiguoHZp5 laTcGcFQFYjBfBbc/ORXT0UAc5aaHeS6R4hsLyLTbD+0bm58mXSkZGMci4WWTOMz9SSOOBVNvDup 3vhu4026t9HtZVWBYDaBikohfeBICowjYxsG7AZuTmuvooA4abwtrWoQ+L5LqLS7W41vSksoY7eV 3VXVZ13SMUUn/WryFzgYxwCdnWfD3m2tidItrKOWxvEu0t5B5cUxWMxhWKgkYUgg4OCi8cV0FFAH H2nhW9+0Wd1eCyD/ANsyanc28TM0aBrWSAKhKjccsrEkLklj7HO0rQvE/g3wdLZ6Pa2N7q001oke X/cRhLa3hkeTJRiMwyEbck7l46geg0UAY+t6OdWvtDlKwvDYX5u5Ul5yBBKi7RjqHkQ846E9cVoi ytB5WLWEeTI00eIx8kjbgzD0Y73yep3H1NT0UAY+t3OuxXekw6LZQTRy3Y+3zzkbIbcD5sDcGLng LgMOuccVsUUUAc/rMV7d+JfDyQadO9raXb3U95vjEaA288YXBfeW3OvRcYPXrXQUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFeVQf8g22/wCuCf8AoIr1WvKoP+Qbbf8AXBP/AEEV24PdnLitkNtf+P5f9yf/ ANES14qY8kn7Lfn3W5wD9B5gwK9qtf8Aj+X/AHJ//REteKmPJJ+y3ze63OAfoPMGB+FRj3Zr+v1R 5td2gv6/VH2COgoqtPLcxsPJtRKgGWPmBW+gBGD+JFTQu8kEbyRmJ2UFoyQSpxyMjg4rmtpc9u+o +iiikMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAryq D/kG23/XBP8A0EV6rXlUH/INtv8Argn/AKCK7cHuzlxWyG2v/H8v+5P/AOiJa8jiBESgsW9zivXL X/j+X/cn/wDREteGyX0yyMobABwOKxzJXseZiKbnTSXc+yR0FFVp4biRg0N2YsDhdgZSffPP5EVN CsiQRrLIJJAoDuF2hjjk47fSsbaHuX1H0UUUhhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFeVQf8g22/64J/6CK9VryqD/AJBtt/1wT/0EV24PdnLitkNt f+P5f9yf/wBES14JMR5z8/xGve7X/j+X/cn/APREteCyn98/I+8f51lmO6OOXwI+zHuYIpEiknjS R/uozgFvoO9SKyuoZSGUjIIOQRTHhilQrJGjhhhgyg5HoadHGkMSRRIqRoAqqowFA6ADsKw0serr cdRRRSGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5 VB/yDbb/AK4J/wCgivVa8qg/5Btt/wBcE/8AQRXbg92cuK2Q21/4/l/3J/8A0RLXg0uPOfkfeP8A OvebX/j+X/cn/wDREteDy/65/wDeNZZhujin8CPsae6MDAfZp5FxlnjUEL+Gcn8AamhlE0EcoV0D qG2uu1hkdCD0PtTx0FFYaWPW6hRRRSGFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAV5VB/yDbb/AK4J/wCgivVa8qg/5Btt/wBcE/8AQRXbg92cuK2Q21/4 /l/3J/8A0RLXg8ufNfp9417xa/8AH8v+5P8A+iJa8Jk/1r/U1nmG6OGfwI+xJxebgbcwbAOVkByx +oPH5GpofNMEfnhBNtG8ISVDY5wT2zWVq3iSz0W+srO5jneS7x5ZjUEDM8EHOSP4rhD9A3fALdQ8 T6fpdxfQXgmie1gW4AKg/aFY7R5WD8x3YXHByy/3gTz30PXtqbVFZKeILX/iZfaI5rVtOhSe4WYL kIyb9wwSCBhlPuh7YJ59fijoh8L6jrslpqMUenzmCW1eJPPZgSCVUNgjh+c/wN6UhnbUVhT+J0W7 nhs9J1LUI7Z/LuJ7WNCkbDqPmdWcjuEDc8deKbD4qhlvfKbTr6K0N09ol84jMLyq5jK/K5cfOCoL KBnjvQBv0Vj6R4ks9av72zto50ktM+YZFABxPPBxgn+K3c/Qr3yBsUAFFYlj4lt7mw1W7vLS600a VIyXaXfllkxEkpbMbuCNjqeDnrVdPGNsqJ9r03UrKSSSFYormNA0iyzJCHGGIwGkTcCQwB6cgEA6 OiiigAorL1rWhowslWwu76e9uPs8MFqYwxby3kJJkdVACxt39Krt4gu0t0dvDOsi4d2VbYfZ2bAA +YuJTGo+bABYE4PHFAG5RWPD4lsH0q91C482zSxYpdxXC4eFgobaQCQSQykbSc7hjOao2vjW3vrO CSz0nU57yYzA2CpGJohFK0TFyzhF+ZSBlue3Q4AOmoqvY3ZvrOO4NtPbF85huF2uhBIIIBI7dQSD 1BIqxQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUA FFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRWXYa0 L3WdQ0t7C7tZ7JI5N0xjKzRu0iq6bHY4Jibhgp6cVT0PxPNr0VlcxeHdVt7G8iWaO7ne22bGXcpI WZn5GP4e/OOaAOgoqOeRobeWVIZJ3RCyxRlQzkD7o3EDJ6ckD1IrCtfFMs2u2uk3Ph7VbKa4jklV 5mtmRUTGS3lzMQMlQOOpHvQB0NFFFABRRRQAUUUUAFFFFABRRWPrHiSx0TUNMsrpZmk1CXy4zGoK p8yrufJGF3SIueeXFAGxRWXa6rNN4l1LSZbaNEtbe3uIpllLGRZTIuGXaNpDRN0LZBB46VHp+rXl x4h1PSbyygg+yRQ3EMsNyZfNjkeVV3Aouxv3JJALD5uvFAGxXlUH/INtv+uCf+givVa86s9D1OXT LUpZSMphTDB48EbRzy2a6sNUjBvmZz4iEpJcqM21/wCP5f8Acn/9ES14VKP3r8N1PQ19B/2RfWVy stxbmNNk3JZTz5EnHBNeAOBvb6ms8bUjOzizgrxlCKUkfYE9hZ3ckUtzaQTSRY8t5IwxT5lfgnp8 yI31RT1ArmvEPhK48Q6r9vluEhl09FbRyjtiKfIZpJAMBgSqLt5G0Mep4v8A/CP6l/0N+t/9+rP/ AOR6P+Ef1L/ob9b/AO/Vn/8AI9T7KR7XIzK8S+D7zxBf2dwJkt0ubdLPWIkuZVE0AkWTam3GTkSJ khTtlb6VWvPh1b3mh6r5iRHWrhdQS2n+0SiJRPJcmPeo+UlVuWBJUkbmxmt7/hH9S/6G/W/+/Vn/ API9H/CP6l/0N+t/9+rP/wCR6PZSDkZzWofD+aWa/itLLSwbu5kuI9YeeRb2zMjl28sBTyGLEYdR 6g85sjwVd3OuLNcCO0sYtRN9tt9UupBORKZUzAxEUZ3bWbG7JBxjORuf8I/qX/Q363/36s//AJHo /wCEf1L/AKG/W/8Av1Z//I9HspByM1rews7SWSW2tIIZJf8AWPHGFL/Mz8kdfmd2+rsepNWKwf8A hH9S/wChv1v/AL9Wf/yPR/wj+pf9Dfrf/fqz/wDkej2Ug5GZ9ho+uTf8JJDq1hpK2+sFpAsV7LMA xgih2MDEmVIjJJDA84x3rJk8D6vKz6kWhGoRvb/ZrWXVbq4hCpdRTvmSUMVLeSoAVMDHft03/CP6 l/0N+t/9+rP/AOR6P+Ef1L/ob9b/AO/Vn/8AI9HspByMlt77XYkuJtV0mxigihaQfYb2S5ldhztC GFM5GehJzgY54f4Zn1m68OWVx4ggt7fVZE3zw24ISMkkheSTkLjPJ5zVf/hH9S/6G/W/+/Vn/wDI 9H/CP6l/0N+t/wDfqz/+R6PZSDkZN4k0s6tp0cI0zStS2SiT7PqaZjPBGQdrbW567Txkd6wbbw5r VlpF3a2tnpsMN3dGZrC21Ge2S3XZGAsU8aBlGY2YgIAS56DOdj/hH9S/6G/W/wDv1Z//ACPR/wAI /qX/AEN+t/8Afqz/APkej2Ug5GYFl8Ona2iNzq99YyJfPfLBZXHnxhysaje1wjmUqY9wZgMMxwBg Yk0Xwpr3hqae9tL2DU7q4lnE0V9J5StGbiWWMq8cXyt+9csNhBZyAQqqK2/+Ef1L/ob9b/79Wf8A 8j0f8I/qX/Q363/36s//AJHo9lIORmtY/bDZxnUBALo5LrbklBycAE8nAxzgZ64HSrFYP/CP6l/0 N+t/9+rP/wCR6P8AhH9S/wChv1v/AL9Wf/yPR7KQcjN6isH/AIR/Uv8Aob9b/wC/Vn/8j0f8I/qX /Q363/36s/8A5Ho9lIORm9RWD/wj+pf9Dfrf/fqz/wDkej/hH9S/6G/W/wDv1Z//ACPR7KQcjN6i sH/hH9S/6G/W/wDv1Z//ACPR/wAI/qX/AEN+t/8Afqz/APkej2Ug5Gb1FYP/AAj+pf8AQ363/wB+ rP8A+R6P+Ef1L/ob9b/79Wf/AMj0eykHIzeorB/4R/Uv+hv1v/v1Z/8AyPR/wj+pf9Dfrf8A36s/ /kej2Ug5Gb1FYP8Awj+pf9Dfrf8A36s//kej/hH9S/6G/W/+/Vn/API9HspByM3qKwf+Ef1L/ob9 b/79Wf8A8j0f8I/qX/Q363/36s//AJHo9lIORm9RWD/wj+pf9Dfrf/fqz/8Akej/AIR/Uv8Aob9b /wC/Vn/8j0eykHIzeorB/wCEf1L/AKG/W/8Av1Z//I9H/CP6l/0N+t/9+rP/AOR6PZSDkZvUVg/8 I/qX/Q363/36s/8A5Ho/4R/Uv+hv1v8A79Wf/wAj0eykHIzeorB/4R/Uv+hv1v8A79Wf/wAj0f8A CP6l/wBDfrf/AH6s/wD5Ho9lIORm9RWD/wAI/qX/AEN+t/8Afqz/APkej/hH9S/6G/W/+/Vn/wDI 9HspByM3qKwf+Ef1L/ob9b/79Wf/AMj0f8I/qX/Q363/AN+rP/5Ho9lIORm9RWD/AMI/qX/Q363/ AN+rP/5Ho/4R/Uv+hv1v/v1Z/wDyPR7KQcjN6isH/hH9S/6G/W/+/Vn/API9H/CP6l/0N+t/9+rP /wCR6PZSDkZvUVg/8I/qX/Q363/36s//AJHo/wCEf1L/AKG/W/8Av1Z//I9HspByM3qKwf8AhH9S /wChv1v/AL9Wf/yPR/wj+pf9Dfrf/fqz/wDkej2Ug5Gb1FYP/CP6l/0N+t/9+rP/AOR6P+Ef1L/o b9b/AO/Vn/8AI9HspByM3qKwf+Ef1L/ob9b/AO/Vn/8AI9H/AAj+pf8AQ363/wB+rP8A+R6PZSDk ZvUVz0uhamkTMPF2tZAJ5is//kevAf8AhafjjH/IwSf+Alv/APG6Tg0RP3dz6for5h/4Wn44/wCh hk/8Bbf/AON0v/C0vHH/AEMMn/gLb/8Axulysj2iPp2ivmP/AIWj43/6GGT/AMBbf/43S/8AC0PG +f8AkYZP/AW3/wDjdHKxe0R9N0V8y/8ACz/G/wD0MMn/AIC2/wD8bpf+Fn+N/wDoYZf/AAFt/wD4 3RysPaxPpmivmYfE7xt/0MMv/gLb/wDxunf8LM8bf9DDL/4C2/8A8bo5WHtYn0vRXzT/AMLM8bf9 DDL/AOAtv/8AG6P+FmeNv+hhl/8AAW3/APjdHKxe1ifS1FfNP/CzPG3/AEMMv/gLb/8Axuk/4Wb4 2/6GGX/wFt//AI3RysPaxPc7Oz16PxrfalPZ6aun3NvFahkvXaVViadlfYYQMt5oBXd8uDy1Y9r4 LuU1CyeLR9A0YW1wkr3mkO8Us6qc7DGqKArYwQzOME8Zwa8iX4n+Nyuf+Ehl6n/l1t/X/rnSr8Tf GxYD/hIZeT/z62//AMbo5WP2sT6A8PXesXkOoSavbwwbdQuIrRY0ZSbdHKozhifmbaWyOCCpFJom jy2c93qOoOsuqXjfvXV2ZI4wT5cSZxhVB7AZYknrXgZ+JfjXP/Iwy/8AgLb/APxumn4m+Nh/zMMv /gLb/wDxujlYvaxPpeivmf8A4Wb42/6GGX/wFt//AI3R/wALN8bf9DDL/wCAtv8A/G6OVh7WJ9MU V8yr8T/G5Un/AISGTqR/x62/r/1zoPxQ8bj/AJmGT/wFt/8A43RyMftYn01RXzF/wtLxxn/kYZP/ AAFt/wD43Sf8LT8cY/5GCT/wEt//AI3RyMftEfT1FfMH/C1PHHP/ABUEnH/Tpb//ABuk/wCFqeOf +hgk/wDAS3/+N0cjDnR9QVxfiDwPdeJNU1K7n1u7skktktbWO0ZCAoIcs2+MlW8zByhBwi856eJ/ 8LV8c/8AQwP/AOAlv/8AG6T/AIWr45/6GB//AAEt/wD43RyMOdHvsOn67ba/Dqgj0+c3VlbWt+rX Dx+U0bSMXixGd/8Arn4O3oORnieaw1S38WtqljHZz211bQWtys87RPEI5JGDphGDnEzfKdvQc818 9f8AC1vHOT/xUD/+Alv/APG6X/ha3jn/AKGB/wDwEt//AI3RyMOdH1DWVpiNPoNj5MzRyxQqnsGA AIZfqK+cv+Fr+Oc/8jA//gJB/wDG6qS/ETxVPIZJtShkc9WfT7Yk/iY6TptlKaPojXFCQRxb3kk2 zSMTyceS4J9hkgfjXylL/rpOv3j/ADrpV+IniuOOWOLVI41mXZJ5djbpuX0JEfua5d2LOzHqTmsp rkhZ9zjxklJpo//Z --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 6.jpg" Content-Description: Picture (Enhanced Metafile) 6.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 6.jpg"; creation-date="Thu, 08 Nov 2012 06:14:08 GMT"; modification-date="Thu, 08 Nov 2012 06:14:08 GMT" Content-ID: <8dc2b670-b450-4628-ad84-4a26f81f7450> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAF6AoYDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDF0DSW sdOhtTcm5SSVyEIHlZ3ben8X3Qec9sAd9O4GjW00sMlxa+ZE7RPt0qZlDqSGG5YiDggjg9qh0J/M stLf+9z/AORGrGvfGSafrmsaRdSC3gXUrtvtEcbPLHmVzwokQMDxwTxyR1OeqvUnShBU+q7HFTiq jk5GwZtMMvlxfYpG67TZPG2MgZAkiXPLL0z1FSqloxYLb2ZKnDYgTg9eeK5TS9VTUPEr+RevdwJB hJJIvLc5kizuXe4HQ9G5xmuwHTnrXTgqk6kH7TcyxEVBrlGeRbf8+tp/34T/AAo8i3/59LT/AL8J /hT8+9GRXZZdjnuxnkW//Ppaf9+E/wAKPIt/+fS0/wC/Cf4U/IoyKVl2C7Gi3t/+fS0/78J/hS/Z 7b/n0tP+/Cf4U4UtHKuwrvuM+z23/Ppaf9+E/wAKBb2ve0tP+/Cf4U+lFHKhpvuN+zW3/Pna/wDf hP8ACgW1rn/jztf+/Cf4VJketKCM0KKKuxn2W0/587T/AL8J/hR9ltf+fO1/78J/hU2R60Z96LLs TdkP2W1/587X/vwn+FH2W1/587X/AL8J/hU2fejPvTsuwXZD9ltf+fO1/wC/Cf4UotLU/wDLna/9 +E/wqXPvSilZdgu+5F9jtf8Anztf+/Cf4ULaWZz/AKHacf8ATBP8KmpQDg8Ucq7Am+5F9itP+fK1 /wC/Cf4UfYrT/nytf+/Cf4VP+Bo/A0rLsVdkH2Kz/wCfO0/78J/hS/YrP/nztP8Avyn+FT4PoaMH 0NHKuwXZD9isv+fK0/78J/hR9hsv+fK0/wC/Cf4VYx7UY9qvlXYm7K/2Gy/58rT/AL8J/hR9hsv+ fK0/78J/hVjn0NH4Ucq7BdkAsbLH/Hlaf9+U/wAKcLCxI/48rT/vyn+FTjp0NOWpcV2BN33K/wDZ 1l/z42v/AH5T/Cj+zrL/AJ8bT/vyn+FWsH0owaVl2KuyqunWbukcenQSSPnakdsHZsdcADJp8+kw 2sLz3WjfZ4UGXlnsDGij3ZlAFSSRCWMxsispPKuuc1eW6tW1fQrueMXENhZwQzqYCCHUPkDJ5wSp 49OprKo5ReiuXBJ7swwuiNA06rprRKcNIFjKg8dT+I/Oml9BVN7f2YF4+YiPHOQP5H8jXUQ6jBD4 k0m9l1E3dta+aJbk2To5DK4AbOS2CwAIAwCc560mmeILqxsI1lZFu5NSjmnH2csqW3lqrFew6bcD nA6HqY9q/wCQ19nD+Y5knQwJSV03EWBJ8sfyemfSkMmgDhhpqkKHIZYwQDjBOenUfnXV3Otx3jWh lKgWmtrcQ7Ldl22QOc8DrnnH3j6U+z8QJYfaPIfmfX2u3LQFv9EbgsMjg44x97k8U1Vlb4P6+4Xs 4X+I5SVdEt5VimTTo5GwVR1jBOTgYFTmwsAqubC2CMWCubdQrbThsHGDgkA4rf0LU7Oy1nU/tV0U 0y4uZGFsunFxJA24JufqMH+ADjPI5JGf56voWiWhZjcWiXIuAVPBeRWXnocgE8Zx3xVqd5JcpMoJ K/MUBYacelnaH6Qp/hR/Z9j/AM+Nr/34X/CrVJWsorsY3ZW/s+x/58bX/vwv+FB0+x/58bX/AL8L /hVmkPSpsguyt/Z9j/z42n/flP8ACj+z7H/nxtP+/Kf4VYop8qHdlf8As+x/58bT/vyn+FH9n2P/ AD5Wn/flP8KsUUWQXZV+w2P/AD5Wn/flP8Kb9iss/wDHnaf9+U/wqyetN71SiuxN2QfYrL/nytP+ /Cf4UfYrL/nytP8Avwn+FT0U+VdguyD7DZf8+Vp/34T/AApPsNl/z52v/flP8Ks49qQg+hqZRVth qTK/2Ky/587X/vyn+FILOyOf9DtTj0hT/CrBB9DSYI7Gp5V2HdkP2Ky/58rb/vwn+FNNjaEHFnbD /tgn+FWPwNHbvRyrsHM+5U+w2uP+Pa3/AO/Ef/xNL9itf+fW2/78R/4VPRQoRXQnmfcrGztc/wDH rbf9+I//AImk+x2v/Ptb/wDgPH/8TVg9etGfen7OPYfO+5X+x2v/AD7W/wD4Dx//ABNH2O1/59rf /vxH/wDE1Yz70ZHrR7OPYOZ9yv8AY7X/AJ9rf/wHj/8AiaDaWv8Az623/fiP/CrGfemsRihQj2BS fcr/AGS2/wCfW2/78R/4Un2a15/0e1/78R/4VPketJUumug+ZkP2W2PS2tv+/Ef+FH2W2/59bb/v xH/hUlFP2cSeZ9yP7Nbf8+tt/wB+I/8ACm/Zrb/n2tv+/Ef+FTU0e5FHs49hqTIhFZsWAgsyVOGA gj4Pvx7ij7NbD/l3tf8AvxH/APE1ds7e0eANd6qLeUucRLp8rFVzxkg4PAH51WcYuZRFdJPCrHbL 5LpvGFxwzEjncOn5Ukot2sU00r3IJG05Dh0sFOcYMceegPp6EfnUTPpsjIimxVywxhIsn2xjv0q/ BKYLqOQXHkYWULMFY+WWiZQRjJHJA6Gq9w1/LNaG51b7YqSEmNVnIBKt837xcDHA655J+jsr7FLV XuQ3dvbKgdmt7dV6kQQgH67lNQgWXksvn2zE8+aYoAQOO2zGOR271pE9Oce47Vr6friWmm2du0yT TJGQLo22TYFkC7UUklwpznBHy8DP3acrKKSQ4ybVmcpM2mrKGlms1V1BWJ44QB2yCFB7HvRV0iZr iUm4SaLe+HaJlaQliQ5JOckYJBGc9z2KOSL1aIc7af1+Rc+HvhmXxRoUEcd9HarbWsZ+a3Mm7e8v +0uMbP1rr5fhXcSxNHLrdvJGRhlewJBH0MtVPgiP+JPN/wBelv8A+hz11Hiu+1WLXdKsdOfU/Lmt bqaWPTvsvmMY3gC5Nxxtw7Z288ivJqVpp8qemh6MKMGuZrU5yL4QiBNsOp2EaBt2E03ADDnPEnXg VOfhdcyoVfWrZlOQQ2nk5H4yVe1bWNR0vw9KhOpJfDRNQu0kvTbtIskXl7CwiBRv9ZxggYHIJ6aG meMn1HxBLpyaNfLapPNALswybd8bEMWOzYFJUgEOSe4XtP1mr3KdCn2Ofi+FEkGfJ1azjz12abjP 5SU8/DG5Gf8Aie23HP8Ax4H/AOO16SOR0/WsDxneXlh4dM1g9wlw11axA24jMhEk8aMFEnybirED dxnGaHiaz+0Do027tHK/8Kwu/wDoN2//AILz/wDHKP8AhWNz/wBBy3/DTz/8drZsru/02w1LVdUb xE0NnZvKYL0WRMmBuOz7Pzu+Ugbjj5uPau/iHVo9WvUv7b7MsQ0xUhgnVwDPdSRO28pk5AUFcfwn aRndS+sVe4vq9LsZw+GF0w51u2z/ANg8/wDxyj/hV9znH9tW3t/xLzz/AORK6Pwhqetahp9xJq1p bIVvLmKNobnzD8k8ibCPLUAKFCggksFydpJFdHjd1BGcd+1L29TuH1en2POf+FX3P/Qatv8AwXn/ AOOUf8KxuRwdatu3/MPP/wAcrojrz6M+q2+qxzSPbL9otWQLuuombhEGR8wdvLwcdU5O6s//AISS 80OC9fVbee4u4bS0naGIqwEtxPLGsahFz8pCqWG4kLwpI5Pb1O4fV6fYzh8L7kgH+2rX/wAF5/8A jlL/AMKvuf8AoNWv/gvP/wAcrTXx9JBZJd6joN5axfv0dn3R5ljjEqqglVGZWUPhiowyFSOQTf8A D3iuTXrqO2OlTWs0du0l4ryo32eUStGI+D82fLlIPAwo/vCj29TuH1en2Oe/4Vlcj/mNWv8A4Lz/ APHKQ/DO5B/5DNrjHX+zz/8AHK9HAyORzXM+JYtQ/trQks9bvrGK9umtpY4EgYYEE0u4eZGxBzGo 64xnjPNHt6ncfsKfYwP+FZ3P/Qatv/Bef/jlH/Cs7n/oNW3/AILz/wDHK19H8WzXWtf2T/ZeoSW8 Ustp/aMsL/O8OQzuRGsQVirAFW6kDaucCO18YatfW2jNa6BC0+qWL3yRyX+0RRqIT8zbDyfO4wOy 5xk7T29XuHsKfYyz8M7nOP7Ztf8AwXn/AOOUv/Cs7r/oNWv/AILz/wDHKtz+N7uXQp72bSJbSCfR p9Us5FulZykaqfm4wjfvEI+915HGK0LnxXd2+qXUCaPusbW/gsJLj7QA2+VYSpCbezToCCw45G7o D29TuL2FPsYf/CtLrP8AyGbX/wAF5/8AjlOHw1u/+g1a/wDgA3/x2taPxk83iuPRjpriGaeW3ju4 pGcLIisxD/IEXIRuA7NkcqMHGx4Wu5tQ8IaLe3LF7i4sIJZWIAyzRqScDjqe1CxFVbMPq9N9Dkf+ Fa3n/Qbtf/ABv/jtJ/wre85/4nVrx1/0Bv8A47Xo2BXnlj4r1q58JeH7iTSNRjluTp3nX7NbGJxJ NCJG2rIWAYMw4QEbui44f1mr/MP2FPsJ/wAK2vP+g3a/+ADf/HaT/hW95/0GrUf9uLZ/9G1sad4z k1HxI+mR6JfC1E81uLvyZNoeIsCWOwRhSUZQQ5OSuVGSBlWHjfUIPD9pdSaa18tvodpql9cCdY22 yK+7amMZ/dk9QDyOCBk+s1f5g9hT7Df+FbXf/Qatf/ABv/jtH/Ctrv8A6DVr/wCADf8Ax2vQ8CjA p/Wav8wvq9L+U88/4Vtd/wDQatf/AAAb/wCO0f8ACtrv/oNWv/gA3/x2vQ8CjAo+s1v5g+r0v5Tz z/hW95j/AJDVr/4AN/8AHacPhxeDn+2bTP8A14N/8dr0LFGKX1mr/ML6tS7Hn3/Cur3/AKDVr/4A N/8AHaP+FdXv/Qatf/ABv/jteg4FGBR9Yq9x/V6fY89/4V1ff9Bq0/8AABv/AI7Sn4dXx/5jdr/4 AMf/AGrXoGBS4FH1mr3D6vT7Hnx+HV6T/wAhm0/Gwb/47R/wru+yD/bVoD7WDf8Ax2vQcCkwKPrN X+YfsKfY4AfD2/8A+g3a/wDgA3/x2l/4V7f/APQctv8AwAb/AOO132KKaxVZfaD6vS7HA/8ACvb/ AP6Dlt/4AN/8do/4V7f/APQctv8AwAb/AOO131FH1qt/MH1al2OB/wCFe3//AEHLb/wAb/47R/wr y/8A+g5bf+ADf/Ha76ij61V/mD6tS7HA/wDCvL//AKDlt/4AN/8AHaP+FeX/AP0HLb/wAb/47XfU UfWavcPq9LscB/wru/8A+g5bf+ADf/HaP+Fd3/8A0HLb/wAAG/8Ajtd/RR9Zq9w+r0uxwH/Cu7// AKDlt/4AN/8AHaP+Fd3/AP0HLb/wAb/47Xf0UfWavcPq9Lsef/8ACur7/oOW/wD4AN/8dpP+Fc33 /Qct/wDwAb/47XoNFH1qt/MH1al2PPv+Fc33/Qct/wDwAb/47R/wrm+/6Dlv/wCADf8Ax2vQaKPr Vb+YPq1Lseef8K2u/wDoNWv/AIAN/wDHaP8AhW13/wBBq1/8AG/+O16HgUYFH1mr/ML6tS7Hnf8A wrW8/wCg1a/+ADf/AB2j/hWt5/0GrX/wAb/47XouBSYFL6zV/mD6tTXQ87/4Vref9Bu1/wDABv8A 47QPhpd4/wCQ1a/+ADf/AB2vRcCjFH1mr/MDw9N7o85/4Vndf9Bq1/8ABef/AI7R/wAKzuv+g1a/ +C8//HK9GxRil7ep3D6vT7HnP/Csrr/oNWv/AILz/wDHKP8AhWVz/wBBq1/8F5/+OV6NijFHt6nc PYU+x5z/AMKzuf8AoNW3/gvP/wAco/4Vnc/9Bq1/8F5/+OV6NgUYFL29XuP2FPsec/8ACs7n/oNW 3/gvP/xymn4YXXX+2rX/AMF5/wDjlekYFGBT9vU7h9Xp9jzf/hWF1/0G7b/wXn/45R/wrC5/6Ddt /wCC8/8AxyvSMCkwKPb1O4ewp9jzf/hV9z/0G7b/AMF5/wDjtH/Crrn/AKDdt/4Lz/8AHK9IwKXF Ht6ncX1en2PNv+FXXP8A0G7b/wAF5/8AjlH/AAq+5/6Ddt/4Lz/8cr0nFJgUe3qdw+r0+x5kvwne ORpE1azSRurrpxBP4+ZTY/hF5Ugkj1OxRx0ZdMwR/wCRK9QwKMCq+tVv5ivYwPL5PhF5shkk1Oxd z1ZtMyT/AORKkf4VTyZ36zatwV508ng9R/rehr0zApMUvrNX+YPYwPMpvhM9wAJtVspMdN+m5x+c lMf4Q+YF8zU7F9o2qW0zOB6D950r1HAowKaxVZbSBUYLY8wi+Ej2+7yNYtYt3XZpuM/+RKK9PwKK Hiqz3kJ0Kb1aPLPgu5k027YlGbyIctHHsQnzJzlRgADnoAMdK9Maygkvob1oz9ohieFH3EYRyhYY 6HJjT8vc15n8D/8AkBy/9esH/oc1dnD4pha01TVXKPpNvOttavAN73EgIRtvODmRhGo9VPPIxNVe 9935Dpv3TQ1HQ9O1Uub2280vbTWjfOwzFLt8xeCOuxeevHHU02Pw/p0WqnUo4JFuCzPxNJ5YZvvM I92wMe7AZOTk81gL42W01LX7nWIrrTNP02wtJWgukjDLJJJOCQyMwbdtiA+YjIxwc1d0zx5o+q6R BqcBkFvJffYJDvjcQynhdzI5XBJTBUt99ffGdjS50mMdqqanplrq9i1nexu8LMj/ACSNGwZWDKwZ SGUhlBBBB4pthrVnqFveXETFba1nkheaQgIxT77A5+6DkEnHKn61m2fidW0q21S8QJZX94IbOSMc LEx2xO5J6OQCCP8Anogx1NFguWbXw3p9o0pU386yxmJ0u9QuLhCpxn5ZHYZ464z19TUdv4R0W18w x2khaRoGdpLiV2YwOZIslmJ+Vjx7YHQAUkniyxW0knhhubk/bWsII4VUtczKCWEeWAwNr5LEAbG7 DNZd/wCPoYtMlkhsp7a8XUV0zyr1PuzGISniMsWAQnAX7xGBwQaLBc6W10y1spriW3jdDcP5ki+Y xTcckkKTtUkkk4AyTk5NWguOgrg28bXcFmVk1TRzO11HA09xaTWa2QaOSQtPDK24AiPCncoYntit HR/GtlLBqzX2s6RdxaZFHPLf6e+ISj7wARvbawMbcbjnK+uKLBc3b3RrDUbq0uru2Es1o/mQMWI2 Nx6HkZVTg8ZAPUCi50awu5rmWe2DyXMMcMrFjyiMzJjnghnYgjBzg54GMS+8ax+H9I02fXoPLvr2 Npfs8ckUQjUFchnmkVAV3op+bk5wPS3aeNdGuIY5p5xZQSWou1mu5ESMp5nlnDbiDhtvIODvTBOa LBcm/wCEW0c6eLF7R5YBOlyfOnkkdpVIIZnZizH5R1J446cVcs9JsrC5vLi1txHNeSia4YEku4AU Hk+gHA+vUmsrUvG+laXYXF5NvMUV41kCZYoxJIoy21pHVQAdyksR8ykemYo/Hen3lvpUumWN/qR1 OGeWBLURnAhZUkDMzhRgvjOcHBweRksFzpse1QXFjBdT2k00e6S0lM0ByRscoyE8dfldhz6/Sm6X qdvrGnRX1rv8uTcCrrtZGVirKw7EMCCPUGrlFguZUfh/TYtWOppA63JYv/rn8vcRgsI87AxH8WM+ 9Ps9FsLAWItbcxiwtjaWw3sdkR2ZXk8/6tOTk8deTnSoosFzGfwxpD2MNk1nm3hsH06NfMfi3cKG TOcnIReevHXk1PJoeny+fvtt32i6ivJfnb5po/L2N14x5UfA4O3nqc6VFFguYieFdHj1NNQS0cXK TNOh8+TYjsGDlU3bV3b2yAACTk5PNaNjY2+m6fbWFpH5dtbRLDCmSdqKAFGTyeAOtWqoXurW9jcL BIGLsAcAqMAkgdSM9DwMmonONNc0nZDSb0RcwfSqA0SwGk2ul/Zz9jtTCYYy7Hb5LK0fOcnBRTye cc5yamOp2a+YJJ0iZGdSjsA3yDJIGfTB+hFQ3OuWloYhPuTegchmUFAfUE5P4ZqJVqUVdyHyyfQY nh/To9UOorBILglmx50hjDMMMwj3bAxBIJxnmsseCNK/tBZ2ikNvDZW1nDB5jgKkJkwGOf3ikOMq 2QdgzmtuTVI4pp0ME5S3YCWUAbUyobPXOMHsOKvVcZxk2ovYTTW4zB9KMH0p9FXYVxmD6UYPpT6K LBcZg+lGD6U+iiwXGYPpRg+lPoosFxmD6UYPpT6KLBcZg+lGD6U+iiwXGYPpRg+lPoosFxmD6UYP pT6juJ47W2luJjtiiQu5xnAAyaTSWrC4uD6UYPpWPB4osZ0ncJIqwANId8b7VyASdrnbjOSDg4B9 Kv8A9q2bXSW8U6SyM7owjcN5ZQZbdzxjKg+7CojUhJXTJ9pHuWcH0owfSsaHxXps6XbIWJtoGuGV WRmZF6kBWOD04bB5q9aamlzc/Z2t57eUp5iLMAPMQEAsME9MjIOCMjiiNSEtmCmnsW8H0owfSn0V pYq4zB9KMH0p9FFguMwfSjB9KfRRYLjMH0owfSor28SxtTO6O43IiomMszMFUDJA5JHU1kL4jitY dQub8vDGl4tvDFLtVgTEh25zjqWOScY74rOc4wdpMTmlubmD6UYPpWJceI0m8OXmpaZG07wrIpCs jCJlUnLfNggcfdJPPFXFvf7O0UXV+Z9yfe88xByS2Bnadg7d+nXvSVSLena9xc6L+D6UYPpWdZa/ ZX8cDwFm864a3wCrbXCFzkqSCML1BPUVFrF7I2k6rJZ3E1tPp4YllVCGYRBwPmB+X5h6Hih1IcvM nf8Aq4c6tc1sH0owfSqWt382m6Rc3cFu08kUbsAMYXCk7myw+XjnHPoKivdeg06CB7uCWGSYMRFJ JEpAUgEli+zuP4u9OU4xbT6A5pbmlg+lGD6VHZXcd9Zx3MQYJIMjdj+mR+I4qerVmrodxmD6UYPp T6Kdh3GYPpRg+lPoosFxmD6UYPpT6KLBcZg+lGD6U+iiwXGYPpRg+lPoosFxmD6UYPpT6KLBcZg+ lGD6Vh3OpapPqF7BprWMa2bLFtuVYtPKYxJtUhht+Vhzhu/HFa2nXqalplpfRAiO5hSZQeoDKCP5 1KabsazpShFSf9X1RNg+lGD6Vh3OpapPqF7BprWMa2bLFtuVYtPKYxJtUhht+Vhzhu/HFa2nXqal plpfRAiO5hSZQeoDKCP50JpuwTpShFSf9X1RNg+lV57+ztX2XF3BE/XbJIFP6mrdZlg4htJ5hGzy yXUwwOSxEjKOewAA+mKb0M0SLq2mscLqFoT7TL/jRSCRpwVni2SKfmU8j6g96KjmY7Hlvwngvbnw VewafMkF1LZwxpMxI8vLzAsMA8gEkDuQOleoT6FYz6CmihGis440SIRNtaLYQUKnsVKqQfUVwnwi t30rS7+2u18l7WNI5Q7D5CskwbJBxxj1xW2uuX1v4cv/ABO8Ui/bZYRZW1y+EghZljR3AJC5LmRu +0gHla6KnxGNP4S/D4NtQ+oy3mo6jfT38cEck1xIgZPJZ3jZNiqFIZ88DqoPXJNpvDsc+gXmk3uo X96t2GD3E7r5q5GAV2qFXbgEYXqM8nOeQl13VNE1rxXe3AstSv7XT9NiRbQeSjF5rgLvDudmPMyc tjaM5GeNS18T65D4bfUtVsIIZLK+8q+VGQn7OcHzAqSuEKh1JBZjhWOORUFmpc+G8eGLTw9ZyYsl 8uG5eZsvJAOXHAwWfGD04dj6CtTVdMg1fSbrTbgusNxGYy0ZwyZ6Mp7EHBB9QKytP8Seb4bvfEF7 GI7BWklthGuXkgXhW68s5BIxjhlHWqrX2raF4bj1e/QtJJdC41CGR95tYHONqYbA8tdmcZB2uRyc 0AWL7wysfhaz0zTC/wBo08o1nM9x5TrIvBcv5bjcVZ85Qg7iCOeKei+EbqLT79dVu5FvbrUBfx3F vceZJC4hjjyHMagk7G42BcNjGOKQ+KdRuNHtLy2itYRqmo/ZrCadSUSHaxWWQBhu3bDtAK53oOOa ybzxJr13YXVkHtGnj11dLe4sZPIXy/s6yE7nLbCXOw4yV3YGWAJAOmj8K+Ws8o1zVf7QnZC9/vi8 0qgYKm3y/L2jexxs6sT15qL/AIRTbdWv+kyXMRuRdX090+6a4eMfuVwFChVbDYAABQcfMa5jzdQS WfRo49USWK6gN7Db639oaWJo5mCwTTMjq5ZF3KSpCjI4Oat6R4km05dcSOw1WSG1a3htLW9u47iZ 7qQsDEJBI/H+qJ3PldzE4FAHY6ppcuo+U0OqX+nyRZw9oyfMDjIZXVlPTrjI5wRk1lv4G0abT9Ps ZkmlgspJZMO4PnGQsX38cgu2/Ax8yrjgYqG9m1vRNN8O6da3Fvc6je3f2e4ubwO658maV3ADA8NH wucY+Xjgh99qeu29xpOkibTItRvFnd7t4XaDbGVwFj3htzBwcb+Nr8tjkAf/AMIbax2mlRWmo39r PpsbxRXUbRtK4fBkL70ZSWKgk7Qc9MZql/wgzQX+lmw1a+tYLKK+zOsqtOZLiaOXnejKy8SD5hn7 vU8hsHinVNUttGgsxYWt5f8A2rfcTq0sH7hwh8tQylt+dy/N90E84qpq2ta3qfgvTtUsb2009zqM EFw3lPIsmL2OLcjCRMRnBJBzuRsZXrQB2Wl6bb6Rp0VlbbzHHuO6RtzOzEszMe5LEk+5q5VexS8j s41v54J7oZ3yQQmJG5OMKWYjjH8R9eOlWKACiiigAooooAKqXlgt6CrzzLGw2vGhG1x6HIOPqMGr dYPiq6nWzs9Ps2mF3qF5DADC21li3hpm3ZG3ESvyOclcckVM4Ka5ZbDTa1RoXGk21zcNNJv3tt6H gYPP5jg+wpLnSY7k3GbieNLhcSohUBuNuckZ6Y74q/RWboU3e63/AK/UfPLuZx0sy3N28s8ginkD GJCNrqEVcNkZHIPQ9K0aKKuFOMLtdROTe4UUUVYgooooAKKKKACiiigAooooAKKKKACiiigApsiC SJ4yWUMCMqcEZ9D2NOqC8uPsljcXPltJ5MbSbF6tgZwPc0m0lqBVi0iNZnluLme7domhBm2/KjYJ HyqOuB1yait/D1jbxTRjzXE1v5Em5uWBzubj+JuMn2FQaVqWq3crR3lrFCHg82KTKEA5AxhZGLDk fN8v4ZFO0jV7rVxOAsMBjiAUspbe5ziQcjMZxx3PPIxXOnSdtNXfczXK7aCXXh8y2dyFvJ5rh7Ka 1iM5UIocDsqjuo5xn68VftNNW1uPPa4uLiQJ5aGZgdiZBIGAPQcnJ4HNZ+jtfPY3T3uowmJZblCy xFXjIlYZ3M7AAAcDHAxyccwxSyWuvWVvFFfpDM8ivLcXQlSUBGIKrvYjkA5wPQ9RSi4q0uXewKys 7HR0UUV1GgUUUUAFFFFAFe9tFvbYwM7x/Mrh0xuVlYMCMgjqB1FVI9EhjilX7TctLJP9o89mG9ZN gTI4x0HTGOSOnFT6pczWlj5kATzWliiUuMgb5FTJGRnG7PXtWBHqd7ZpqTRxRXN3LqawZiwEB8iP 5sMw/u4xu6nGa56soKS5l/WpEmlubz6asumXNlPc3Ey3KMjyORuwwwcYAA49Bin31il/HEGkkieK QSRyR4yrYIzyCDwT1FYeoXWpXnhHVTMkVrPFHMkgZQ+9BGTwFkOwnI6k4x0ORV+aR9F0iGCGK3a5 eTyoY7eDy4yxJbhN2BwCeWGSOozRzxd9NLf0u4rrsOGhRLG4F3dec1wLkTllLq+wJkfLjG0YxjHJ 9sTQ6RBFa3tvJJNOt4xaYysCWygQ9AMcLWfYa7cz+QlxFHHJ9va0mJx/zyLgjDMAc7Rjce/fpHq8 kWq6H4gjlhgmWz8xYTtDYYQK2ef4gzMMip5qfLzRX9WC8bXRrrp4bTprK5uZ7qOZWRml2htpGCMq o/M889aa2nSm3hj/ALTvRJECPOBTc4P94bdp/LP61B4hkuR4dvZrK4SJ1t5H37SxKhCflIYYPTB5 x6Go7271W3itorcW9zPIrs7ogAIBGNqNKueD13cY9xVycYtqz0X9eY20jRsrOKwtVt4txRSTljkk kkkn6kk1YqlpN49/psVzIFDsWVgowAVYqe59PU/U9au1rBpxXLsUrW0CiiiqGFFFFABRRRQAUUUU AFFFFABRRRQBk3ugR3dzNPHfXtp9oULcJbuoWYAYGcqSDjjKkHGOeBWnDDHbwRwwoEijUIijoABg CsfVozHr+hXEc1wrS3TQSIs7iN0+zzNgx52k7gDnGeBzW3Uxtdm1Vy5Ypu6t/wAD9DJvdAju7mae O+vbT7QoW4S3dQswAwM5UkHHGVIOMc8CtOGGO3gjhhQJFGoRFHQADAFY+rRmPX9CuI5rhWlumgkR Z3Ebp9nmbBjztJ3AHOM8DmtuiNrsKrlyxTd1b/gfoFcOfEOpWc1xDbx2hhW6nAMisW/1r56HFdxX mtz/AMfV3/19z/8Ao166sPTjOT5kcdapKCuiabxhrG84t7Ej1Icf1orFl+9RXZ9Uo/y/i/8AM4/b 1n9r8F/kX/h2tv4q0jWXvYnNvqWJJYlkZMq8szFcqQcc4I7jIPBr0hmtLgzWLGGUqgEsBw2EbIG5 fQ4PXrg15T8JdTtdG8C3WpXsojt7e1jd2J/2pcAepJwAO5IFdZNpusWvg68uUkuBrV9LFdXpt9pk RdyCSKLjGViVkXvkZ6nNedU+I76fwm1p9hoFjd3eladp9jbSi3je4hgtVjBidpAmcAAjKy8dufXm 3b6Rptppz6dbadaQ2Lhla2jhVY2DfeBUDBzk59a86FpqsjeKJfDja7beZZWCW1zqMUry4WaYzCMT 4diEY4DEHLcEAqav6dba7B4KnuYtT1e8urG/N5bpNaywSTwrgvBslZ5HUgyBd5zkrjhVqCztLjR7 C6tLW0ktwLa1kjkhhjYxopjOUG1SAVBAIU5HA44FJdX+lysthcywTfa5msjCR5gZ/KaRo2HIH7tW OG7fUZ5+21O+0fwe+p38kr6rqcxe1s7ptpSWU4htwvVQo27h1GHY96i1Hwy8cHhjT0uL6XZqkk95 eQnZIxa2uS7syj5AzsFyMY3AAg4oA6LU9DstT0F9GeMQ2bIsapEiYRVIKgKQVwMDggjHGMVm+HtB 0Gx07U9GtUF3Gtztv0uI1IaUxRkAqFCY8sxYCKFAxxnNYlza6tZ2t7Z+frb6VbayoZo3kkuXszao xCScyOBO/JUlsKwB4rOh/tS00LXfsEGtRQ3utoFubqCeS4jtvs0I8zYuJXGU2cEOAeSCpoA7W80r wvpWgSwX1ho9noysGljnhijtwxIAJBAXOSBz7VNa6Tos0OmXVjBB9mtQZrL7K22Ab1xvVUOxsqxw cHG4461z/g291HTdB1WTW21O4htr7bas9hOZWgaOIjbGTJKw3u/JLEYOcYIGj4BlLeBdFt3t7u3n tLKC2mjuraSBlkSJQwAdQSM8bhkHnB4oA6CSCGZ4Xlijd4X3xMyglG2lcr6HazDI7EjvXlPxX+Ju n+FdZt9B1Lwpba5BLbJd/wCkzKFUl3UDa0bDI29fevWq+YP2jv8Akoen/wDYKj/9Gy0AexeA/EOl /E/wfJPeeHLOCztrs2yWc224jGxEYMAUAH38Yxxiu1ksLOaxNjLaQPZlPLNu0YMZX+7t6Y9q8n/Z x/5J5qH/AGFZP/RUVewUAV7Gws9Ms47OwtILS1jzshgjEaLkknCjgZJJ/GrFFFABRRRQAUUUUAFU bm10+3vv7aumEcsFu0XnSzEJHGSGbgnaMlRlsZ4HOBV6uc8RSJqWpab4ejkUyyzJe3KgjKQQur5I 9GkVE56gv6GgDbt763u57uGCTfJaSiGcbSNjlFkA56/K6nj19c1YrzHVba/j13xUbNPEMOqT3cb6 VJbLKLVn+ywLufA8sqGXDeZkYUheQat+JE1c6prAil14ai3l/wBhtZ+Z9lT92o/ebR5f+t3lvNz8 pG2gD0OozPCtwlu0sYndGdIyw3MqkBiB1IBZQT23D1rgPEiaudU1gRS68NRby/7Daz8z7Kn7tR+8 2jy/9bvLebn5SNtWfFGkWkfjDT9Xu0157V7S5hmfTri8by5C0GwBIGyikI+doAJALZODQB3VFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRVe+W4bT7lbN9l0YmELccPg7Tzx1x1pN2VwEi06xg8 3ybO3j80Yk2RKN/1wOalWCFHV1iRXVNgYKAQvp9Pauc0WK8jnmNze300P2dhLG9rLH8+RyGZ2O7G eI+OfpU2h2+obriPVJr6TzYh5Jd8BIzn5SUC4kHc9emD1rCFROyUbXM1LyNaK10/zpbyKC2819yS TIi7mwcMC3sRyPaoNOGiefJ/Zg0/zv8Alp9m2bvx21n6PawWa3tvJb38kwe4JjlMrxyRmQkY3nyy SCO+Tk5702KOS516ymhkv3ghaRniuLURJECjABW2KTyQMZPqelSp/C7K4X20OkooorqNAooooAKK KKAGTQxXELQzxJLEwwyOoYH6g1EthZpbvbpaQLA/34xGArcAcjGDwAPwFRaq0y6c5g37yyDKKzEK WAY4Xk4GenNZsAv/ALEyySXRjS65KoVkaHYDxuJb7x9d3B+lc1WsoT5XG+hap3VzSnXT9O0543tk js8EPHHAWTBBzlVB4xnOeKsXFtBdQmK4hjmiPVJFDA/gaoyRefol7Dbi4PmRuqC43biSuP4ucZ9a nk1O3h0+a9kEkcUQJYSIUP0AbGfQds01UWvNa1v87+qFydEP/s6x+ztb/YrfyHILReUu1iAAMjGO gA/AVJDa29vG0cEEUSNyVRAoPAHQewA+gFVbmeQxWN0kc4j3h5Y1UlgpRhgqOuCV456e1VJWnuIL ti17ChuRsKxsW2eWv8Iw20nPTnP40pVox2Wv/Av93QFTNO3srS0haG2tYYYnJLJHGFVieCSBUZ0r TmtEtDYWptkOUhMK7F78DGBWXs1BtLCpNOgW4+ZzG5ZotvZSd4+b3zwfpU0cFy9hpsL3F2374iWT BjcptfG7kkD7o5OeneojXUtOTp5d/wCtdhumktzXjjSKNY40VEUYVVGAB7CnUyGIQxCMO7gZwXbc fz71S1Vbp44lsXlS5LHay/cAxzuyCPp3z+NdE58kOa3yRKV3Y0Ka7qgy7BRkDJOOScAfnWPdNObC 0jj+1IjAmSRkkeQEdmCENySeQQOPQ1G1vPc6FC10Ll54pgSFLoxQSjnaDydoyOp7g55rB4l6qMdU r/l/n+Zah3ZuO6oMuwUZAyTjknAH506si+torjSomiF4yxyIwUvKHKiQFsgncTgHGeR2p3kC4ns0 je9S1EUpbLyIxbcmAxb5v72P8Kp1pKVrJ6Lr3du2yFyqxq0U1F2Rqm5m2gDc3U+5p1dKICiiigAo oooAKKKKAMfUbTw3fatDbanb6Tcak8f7qK5SN5mQZPyhvmI4Y8cda2K57xDepb6togNveyCC6aeV oLKaZVQwTIDlFIzuZRjrznGOa6Gpja7N6qkoQbvZrr69PwMPV4/Cst9GutJoz3hUKgvREZCuTgDd zjJP51uVyeuamU1K40230+6gWVQbrUF0uScOCB8qbUYO2MDLcD0bpXRaZDDb6TZwW5mMMcCJH5yl X2hQBuBAIOOuQDSi/eZdaDjSi3f+vy9C1Xmtz/x9Xf8A19z/APo169KrzW5/4+rv/r7n/wDRr13Y T4meZifhRly/eool+9RXonCXfgj/AMiwf+uMX/oUtehRavay3WoQ5KJYFRPO5AjDFd5Gc9QpUnPA 3D3x5n8JZb2DwJPJp1slzeeREIYnkCKWLyDLHsozk4ycA4BPFdpc+EkbwZ/YkLQtOHiuHlmjytxO kiys0gHUO6/N7E141T4j1KfwljTfE9pqmuajDaXtjcaba2Nvci5glDjc7zq+WBK4AiX6ZOfbTt9W 028tre5ttQtJ4LlzHBLFMrLKwzlVIOGPytwP7p9K4688F6jrw8QNq0WmWw1OCyRIbSWRhut5Xk/e PtRiGyg3DBA4H3QTPbeCpI/Cd/ZLa2drqMt5/aFuwuproJcrt8t2ll+cnKDJAHBIweSYLOyiuIZ2 lWGaORon8uQIwJRsA7TjocEHHuKp2etWd4GZX8tPtT2kTSkKJ5EzuCc84KuPX5G4wM1iQ6Lqml+D 00yxWL+1L12N7eRsFEckpLTTjIyxBJ2jGfug4AJF3V/DVvceFl0nTIbe3e0CSaflcJDNGQ0Z4GQM gZI5wT60Aac2qafb29zcT31tFDattuJHmVVibAOGJOFOGU8+o9apz+JtJj043tveR3sZkWFFsmEz SSMAVRQp6kMD9Dk4HNc7e+HLjSvCemzpbQXmqafejU7iNImdLm4cOsp4UsceazAhSw2LgHGKz9O8 MXWv6Tf3moaRp6yTa2dTt7G7gYQSD7OsJDqyBhn5zuZM5wxXnFAHUyeKvs9uGutE1W3uXlWGC1dI mkuGYMwCFXKcBGJywwBk44q9pmsJqJnjktLmxurfaZba6Ch1Vs7WyrMpBweQT0I7VySeCbhYLuVd E0GBpXgMWnWs0kMMPl+YfMSZI1ZJSZT8wTouO+aLfwZfRNcQywxbNXeNdScXUkwS2iyREXly8rSF 2UsQAFJHGBkA1z4zs1vdKmnngstJvrC5uvPvHER+SSBYyCWwFYSk88/d6ciqPizwt8P/ABF9n1/x MLKSPylhhvJdQaGNkyzKAVcKeWY1u3GiLN4o0nUhFb/Z7CzuYFQr8yPI0O0oMYACxuDyOoHc1hw+ FNQ0xtPvLGDTJ7myuNRMdvO7RxiK5uDKCrBGKuoCDhSOWGe9AF7RbPwf4E0yKy065sdNs72Q3ESy 3uRMxCKWUyMSeNg4OOR61qt4i0RdN/tJtZ08WG/y/tRuk8rd/d35xn2zXI3PgC7k0H7BG9j5h0nV LbG0rGk93Iki7Bg4RSHGeoGOPQ1XwBNda5Pq8McEki3kk1tAt7PZ4R7e3iY+ZCNytugPGGBDc89A DvYpY54UmhkSSJ1DI6HKsD0II6in1keGdHXQfD1tpqQQwCIu3lwyySKpZ2c4aQlm5bknqc8DoNeg AooooAKKKKACqeqalDpOnveTrI6qyIqRgFnd2CIq5IGSzADJHWrlYuqWV3qms6fA8KjS7VxdyyFx mWVSfLQL1wrYkJOOVTGecAEFt4psl1rVNO1K/sLWSC+W1tI5JljeYG3hk6MfmO6Ujjtj8dS51jS7 O+gsbrUrOC8n/wBTbyzqsknb5VJyfwrn9S8JSX2meNIAlmbjXQwt5HH3R9ljiTeduRh0ZhjOM5HP FVtc8I39/Nr9rbxaY9lr2z7TPcFhNb4jWM7FCkPgIGXLLtYk80AdFd+JdBsLmW3vNb023nhGZYpr pEZBgH5gTkcMp5/vD1qabWtKt7m2tp9Tsori6ANvE86q0wPTYCct+FYL+FJpfEh1KQWjxHWft5DZ LGL7B9m29Ovmc4zjHOc8Vy8XwsnisFtZbezvTc2Vrb3hfU7u3RWhhSL/AFcWFmX5MjdsPJ56YAPV KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiq99aLf6fc2bnCXETRMcZwGBH9aTvbQAiv7Od ZWhu4JFi/wBYUkBCfXB4pzXlsqlmuIQBH5pJccJ/e+nv0rG0vRHsLo3H2aBZY7cwRt9rmlyMg4+f hF+UcDP+Mmg6F/Ykk+xbbZcASSGOMIRJ3AAH3OeB259axjOo7XRCcuqLNlr2nahHK1rcxyvHvJij cO5CsV3BVJJBwCPUEetPh1PfcRQzWdzbGUkRGYLhyATj5WODgE846VHY21/aC5g223lNJNLDLvYt udy4DJgcDceQ3aqtvornWYNRksNOtJYi7PLbEs8xYEHcdq45Oe5yKSlUtHv10C8tDdoooroLCiii gAooooAZNNFbwtNPKkUSjLO7BQPqTVG01WGcX8zzwC1t5giTBxtKmNGyWzjq5/SpNVtZLyx8qIRm RZYpVEhIUlJFfBIBx93rg1jyeHZ7q3na4S2EpvxexxxSOi58sJjeoDA9TuHfnHJFYVJTUvdX9akS cr6GpqGs2djo0uoi5t3jCMYj5o2ysASFU9ycdqltLxG0xbqa9tJkwS1xCdsRwT0yx6dOvb8Kzo9E ePw/qdlHFDDPerKT+/klG5kC5Z35PQc4/CrusWdxfWiRQMvEqu6NI0fmKM8b1BK84OR6UJ1Pifb8 f68gvLctR3ltNHFJFcQukp2xsrghzgnAPfgE/gap6xeT22lXtzYzW/m2iM8iyIXHypu2kBhgkFTn 0PTms600O9s4zLH5BnW/+1pG88jKQYfLKl2BbPLHOD24HQW00u6nsNYhu3hV9QZsGIkhAYlj7gZx tP19ulLnqSjZqz/4H+YXk1sXdS1K10mxku7uVUjQEgFgC5AJ2rkjLHBwKG1TT1tEu2v7UWznCzGZ djHpwc4PQ1DPb3mo6LeWl2kEE08TxAxSF1wy4zyoI5J45+tQX1jd31vayTWlm1zHu3KtzIm3OPuS KoYdORj09OalKerj27MG30Lz2un6gEuHgtrkFflkZFfI9j6VLBbQWqFLeGOFCclY0CjPrxUGlWkl jpsVvK4d1LEkc9WJxk8nGcZPJ6nrVyqhCPxtWZak2tQooorQAooooAKKKKACiiigAooooAKKKKAK F1qgtNVsrKS0uCt2xSO5XZ5YcI77T827O1Cc7cdOav1ia1bavcajps1hbWUkVnMZyZ7p42ZjHJHt wI24/eA5z2xjvW3Upu7NakUoxa6rX7/8rGZd6vJbXMkUek6jcpGAXlhRNo4zxuYFv+Ag+nWr1rcw 3lpDdW7h4ZkWSNx/EpGQfyNc9rWn67qWotH5Gn3GjKBi2e8eFpmxz5mImyuf4QcHvnoOhtUaO0hR oYoWVFBiiOUTjopwMgduB9BSTd2XVhBU4tb+T/Pz+X3ktea3P/H1d/8AX3P/AOjXr0qvNbn/AI+r v/r7n/8ARr13YT4medifhRly/eool+9RXonCaHwS/wCRTH/XKP8A9CkrqofFDGzv9UltJP7NS7Sz shGFMty5kEW8fNja0jBVzjgFuhFcV8JbW4vfh/LbWt49nLLDGouEQMyDc+SoPG7GcE5wcHBxivR5 9CsZ9BTRQjRWccaJEIm2tFsIKFT2KlVIPqK8ap8R6lP4TmP+EvbTtb1+/wBYs7/TrO0sdPAtrqWH 70k1wm8bZGRQx2AksPu88AVoad490zU9J/tK3guGgXUI9PlKSQyiJ32bWLRyMhXMiAlWJGenBw63 8K6ebvVI7rVr2/vruC288zzRiSJY3kaF1EarsO4tg4wSnqDm83h2OfQLzSb3UL+9W7DB7id181cj AK7VCrtwCML1GeTnMFljTtZt9Ss7q7VJIba3nmhMs20K/lsVZ1wT8uVYZODweMYrNtPE0w0O21fU bCaG3vruOK3jVV3wxSMEieXLYGSQTjkbwCOCamm8MRN4atfD8F1LFYxhI59wDPcRAfMjHsXP3jjk FsYzkaOq6ZBq+k3Wm3BdYbiMxlozhkz0ZT2IOCD6gUAZZ8W25tUmg0++naW/lsLeKMRhriSMOWZS zhdv7qTliPu9OlZ2oeOJ009xZ6HfDVf7RGmpZ3AjJEphE+4mN2BXyzn7w54JUZYXdQ8L7fCtppel StHdaeY3s7iSTa6uvBYttI3MpcElSPmOVI4qrovg+4h0q7XVL+Y6jdX5v/tMEoZ4JPLWMbXKKD8q c/IF+YjbjigDN/4TDXbWzuI9Rjs7W8jnhSSS5tWjS0ikDkSyKssgZMptDLIBuPO3Gav6T42hkt9Z a7u7TUF0uCO4N3psZEVwr7wFQFmy+Y2HDEEkc5yBox+FfLWeUa5qv9oTshe/3xeaVQMFTb5fl7Rv Y42dWJ680xfCMQuIJH1C5nUXC3N2Z9rPdSJjytxAAVEI3BVUDOD65AHDxBfWkGnQXukXFxq95BJc GzsjF+6VGQEFnkCkr5qAkNgnJHFRnxlHI1lHZ6Nqd5cXX2r9xD5CtF9nlWKTeXkVeHYAYJzWjq2i Jqk1tcpe3djeW28RXNqU3hWxuUh1ZSDtU8jqoPasabwWy6ho7WGpXVlBYWt3GZopFM7yzSROWO9G Vs7JC2R1IIHoAGr+Mri30G01LTNGvLnzr9LOVSYgYWF0sDowMq/MSXVSpK7gCxA5rpbG4lu7OOea ynspGzmCcoXTBI5KMy89eCevrxWa/hmybw4uiJJcRwq6yrMrgyiVZBKJMkEFvMG7kYJ7VpWNvLaW ccE17PeyLnM84QO+STyEVV46cAdPXmgCxRRRQAUUUUAFFFFABWXr+pTaZpiyWqxvdTTw20CyAld8 kipkgEEhQSxAPRTWpWbcaUbvXLTUJrlmhtEYwWwQYErAqZCepO0lQOMbm65GADP1HxfDpz6mf7L1 C4ttLz9tuYfK2Q4iWU8NIGPyOp4U0y/8ZR2FxqwOjanNaaScXl5F5PlJ+6WU4DSBzhHXOFqXUvCN pqV5dSte30Nve7fttpC6CK62gL8+VLDKgKdrLkAA5qm/gxrzVtcuLzUrpbLUrpJHs4JF8uaJYIo9 smUyMsj52MMqQCT0ABJqfifUrHxbbaTB4dvry3ktJ5vMhe3BkKNCAU3zLhR5rBtwBJK7cjJrqKyd W0IaneWt7DqN5p95bJJGk9r5ZJRypZSJEdSCUQ9M8VrUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABUV1cR2lpNcykiOFGkfHoBk1LTJoo54ZIZVDRyKVZT3BGCKTvbQDJ03xLaapO0EETmYRGU IJoXJAIGPkdgDlh1xU1jrK6gtwYbG7BgBDhwg/eDrGPm+8OOfu8/eqaDT3g3Z1C7lyhRPMZTsHqM KMn3bNJY6Tbac5a2LqGQK6k5Dkfxn1bnk9+/aso+10uQlLS5X0vVLzULeYtp8kLq8yo8jIEJWRlC nazNnjk4xkHHaoLbVrsazFYThJfMLhmW2kgCbR2LnEg7fL656Vfg0wW73AS7ufJmLt5OVCoznLMp A3A5J796SLS9lzFPPe3V00JJiWUoAhIIz8qjJwSOc9alRqWiFpaF+iiiugsKKKKACiiigCtfXi2F qZ2ikl+dECR43MzMFAGSB1I6msVdfWwXULm+injBvlhjhkkjBT9xG2Ml9gH3j97v6mtu9tFvbYwM 7x/Mrh0xuVlYMCMgjqB1FUYdItglxGl5PJObkTPNvUyRy7FXsMD5ccEYw3TBFYVFUcly/wBbkSv0 Kl14iFz4a1C+0+GV3gWRCUeJvLYJu3ZDlSBkdCT7VoLcppujCeWK4jWPqlzcI0nLd3Z9vv8Ae6ce 1Pk05JNLurO4up5UuEdZJZGXcAy4OMAAce2KJ4bXWbWCWG6yqSeZDPbsrYYZXIyCp6kcg0kp3u3r by/rsFnuV7DxBaagsRiSQeZcm2HzI4DCMyZyjEEbR2J54qLXJ0udE1jynuIpbBHIeOVozvEQcEFS MjDjg8ZHSphoUSxuBd3XnNcC5E5ZS6vsCZHy4xtGMYxyfbCSWunaZY3iX97iG+c+bJdSqu5igUgH gdF6fXHFJqo4NTF71rMm1u/m03SLm7gt2nkijdgBjC4Unc2WHy8c459BUF9ryadBbyXNhdJ527IL RDy8f3mL7RnORyatrp4bTprK5uZ7qOZWRml2htpGCMqo/M889aa2nSm3hj/tO9EkQI84FNzg/wB4 bdp/LP61clUd2tPuG+boT2dyt5aR3CoUWQZALK3H1UkH8DU9V7KzisLVbeLcUUk5Y5JJJJJ+pJNW K0jeyvuUttQoooqhhRRRQAUUUUAFFFFABRRRQAUUUUAZWoXd9aa1pUcclubK7maCSNom8wMIpZNw fdjHyAY2+vNatZWqaK+p3lrcDVb20Nq2+JIFhKh9rKW+eNiTtdhjOPbPNatSr3ZrU5XGNt7a/eYW t32p6cst0t1p0FomBHHLDJJJMxH3RtYYJPAADH+Va9rLLNZwSzwGCZ41Z4SwYxsRyuRwcHjNZF54 a+162dVXWNQgnC7I0QQukQxg7A8bbSe56n6cVtQo0UEcbyvKyqAZHADOfU4AGT7AClG93cuq4ezi o2v/AF/Vx9ea3P8Ax9Xf/X3P/wCjXr0qvNbn/j6u/wDr7n/9GvXdhPiZ52J+FGXL96iiX71FeicJ d+DU8Np4Ga5uJUhgihDySSMFVFBckkngADvW6usalbeGbrxNJPHm/uIPsscysIrW1eVUR2Xd12OZ GOV9OiisD4Q2NvqPgH7Ldx+ZBIse9NxAbDscHHbjkdCODxXp6zwvPJAssbTRhWeMMCyg5wSOoBwc fQ141T4j1KfwnmCeK7i0vvFGs2+q6PrclvZaZEJtPQJCitcXCtu3TEZUOWJLqMYzt5Na2l+MtVu/ CU+tyNpskdpqCRzvAUdWtf3fmNiKeVUdQ7Hl24TOBuGOxj1KGXWbnS1WTz7e3huHYgbSsjSKoHOc 5ibPHcde1yoLOasfFCr4TuvEmqSQR2O+WW2MalS0G4rF1Y7ncYIxjO8AD1ge51vw/wCFY9Uv54Zr s3MdxqSsrFIYWYCRYhu+URoc55B2McZbjpLqxt70wfaI/M8iVZowWIAcZwSB1xnPPfB6gVJFPDM0 qxSxyNE+yQIwJRsA4PocEHHuKAONk8WX/wDYFjqjXOmWlvqOoSxw3dxExigtQsrRyP8AvBkt5a87 lH7wenOPeeLtT1DQrgRa/oyQLrS2Ems22YrdIPsyzFsmRsHewjyG5zgFSQw9GvrU3tnJbrcz2zNg ia3YB0IIIIyCO3Qgg9CCKqadp9toNlcPJdySGSQ3F1d3TqGkbABZiAFGFVRwAAFFAHmo1hbPT7yA eKILuyintnlurfWTGtxG4mBiilmlYxy7owxHm4Kjjbk1o6J4vaK01hrB2ltSbeDSUvNQW8aS7l3g xGVXbIGI2IDsVUscjovcw+ItDuLCa/g1nTpbOA4luEukaOM/7TA4H4062fSdba11WzuLe+EG8QTw TCRFLABsbTtJxxnqMn1NAHM+Kk1nQvB9g0PiCCJre7tPtt5dQuTIWuYtzZEq7I+W3KSQU+XKjmq2 t+LdYs9HhudJ1TQ7/bpWoalJdx2rvDP9naMBECz/AC/6wgnc3K9O1d5BPDcxebBLHLHkrujYMMgk EZHcEEH3FSUAecXXjPV7HxDJo+oa34d05Yp50N9d2rpG4SK0kVQpnGG/0l8ncchBgDmuw8NapNrG hx3s/klzNNGHhBCSKkrorqCTwwUMOT1q3JpsMus22qM0nn29vNbooI2lZGjZieM5zEuOe569rlAB RRRQAUUUUAFFFFABWB4ovWWKx0m2uTFfancpFGI5NsnkqwadgRyMRhhuHRmX1Fb9U54bG1uZNXuD HFIkHlvPLJhUjB3HqcAZ5J74GegoA5DxRqup6R4104yeJ9H0rTprK6MYv7dvL3K1vwx89A78sVPG 0bhg5yJLzXvET+KJLCxudKhtTqv9mp59lJK6/wCg/at5YTKDzlcYHHOa7eigDyi1+JOpXGlXd9Lq 3h22uoLOCeLSpIW+0XTPaRTkIfOBwXkZR8rdO9er1TstNhsbrUbiJpC9/cC4lDEYDCKOLC8dNsan nPJP0FygAooooAKKKKACiiigAooooAKKKKACiiigAooooAKr39w9pp11cxp5jxRPIqf3iASBViik 1daAc1o+vXd/cSxzTWWxLdpDIpjGxgR1VZ3JXkk9OnXmpdE1m61VrmNrmyWRI/3ISNv3g7TgFuY2 7Aen3q6Ciso05K15XI5Xpqc3ot/JLFew3etWbNE9zvVBtlhCysNxLO2FA6AjgY5OOYbG7xr9tFbX 0Utu7OreXftdNJ8rFdytjy+mcjI4x3zXTpLHIhdJFZQSCwOQCDgj8CCD9Kht9Qsrt2S2vLeZ0+8s UqsR9cGo9lblXNt+P4i5dlcs0UUV0mgUUUUAFFFFAFDWb19P01riOSGNhJGnmTDKIGkVSx5HABJ6 jpXPLrM9pa391BcWly0upLG1xGo8oD7OhyA0gH8IHL9T+FdhUEF0lxNcxIGDW8gifPQkor8e2HH6 1hUpuUk1K39MmSv1OcuNQvtT8HarOJbVWjjlUsiq4dBHk8JKwVsn+8emcc1qalqL6PpCPc3EAuGc Ro6xbYyeTja0gA+UHq4/pWjczx2trLcSnEcSF3PoAMmi3laeBZHgkgZv+Wcu3cPrtJH60Km1dc2t hW89TnbHxO7wRzXstpHD9vNs8xKooXyTIDkSMoO7A+8fwPSa+1FdS8PeIzFJFLDDHLFG8RyGHkKx 5zgnLEfhXQ1U1K/Gm2Ml21vNPHEC0gi25VQCS3zMOOO3PtScJKDUpaenkHK0tWZ2s6gLrwxqF3pO o2xEUEhaaNvMxhCSAysNrdCDzj0qvqOt3NrY2U9vqOkzJLv3y5UCTBGPLDSgcdD8x5xXRSSJDE8s rqkaAszscBQOpJ7CnVUqblf3rP8ArzBxb6lHR74alpUF2JUk8zd8yJtGQxHTc3pjqQetXqKK1imk kylsFFFFMYUUUUAFFFFABRRRQAUUUUAFFFFAHMeIdT07TPEeiSXGrJaStMyzRSXxjQw+TNhmjLbc bwo3EdQBmunqs+o2Md/HYSXlut7Ku+O3aVRI688hc5I4P5GrNTFas2qyvGKs1ZffqcX4o1XR7K/e GTWpRqkmFitxqZt44DtHzPghQOQ3zBic8A9K6vT3Mmm2rtdR3bNChNxGAFlOB84xxg9ePWo7rWNM srhbe71Gzt53+7HLOqM30BOau0orVu5dWd6cY8rXm+vppov6YV5rc/8AH1d/9fc//o169KrzW5/4 +rv/AK+5/wD0a9d2E+Jnm4n4UZcv3qKJfvUV6Jwlj4UajDpHw2kv51d0hjUiOMAvI25gqKCQCzEg DkckV0sug6h/whk6fZy2rajcRXOoxxSKrSAyoZYg+QDiINGpz0A5rH+Cn/IkRfQfzau0/wCEi09R qckjvHbacwSe5dcRl8ZKqerEcA4HU4GTkDxqnxHqQ+E4Z/DmpCDxK2h+HZtEju7axihtmeD955c0 rTBVim2qDG+Mb0ySeRkmrmk+HdWtvCUqrYG3vrXVFv7KyEMUCIBt3xxqs8qqrgyjlxzI3AGK27Hx nZXeq6wrSiHTtOs7ed3uIJIZEeRpgwZXAI4jQgbcnd3yK0bXxLpN5a29xDct5c9ybRBJC6MJhn5G VlBQ/KfvAdvUZgsxoJ77w74Vmu5bJpNd1O6eRLQOpLTyk7Iy2cYRAoYg/djJGamvPDb2PhW0ttMT z9Q0+eO8RuFa4mDZlJJwN0gMgJP9+uhtL+2vmuFtpN5t5jBL8pADgAkZPXGRyOM5HUGqNr4j0+6h jnDSxwTXZtLeWSMhZ3APKn+6SGAY4BI4zkZAOXu9IvE8OWkuo6eZ/tWqNe6rY+dEDIrhxHESzhG2 t9nXG7B2d6wrfQBqun6jHa6HeRWNt4lE76bDNAJdi2UabUbzPLGJCDw/yhcDDKMehajrGhyabei/ aOe0jm+yTRPbtKJJOP3YTaTIeRwoPf0OM2Pxf4V0jQHmsyILG1uPsYt4bRotk2zzDHsKrtIU5OcA c5IwcAHPTaDqbeZcQ6Hq4WCe2uLCK8ltruZJlWZXLl5/miCsuAZNwZyVx2S3h8QRX+pNc28lvqni AQWkYjihiaGOPeZbghJZAAqygDLsxYKOhGOhtfH+n3mnpdQ2N9I0s621vDAYZzcSFWbCPHI0fCox O5htA5xkZ1dP8Q214byO4t7nT7myjWW5gvFUGONt219ylkKnY3IY42nOKAMy9sZ9F17Q59J0Ke60 +z0+5szDZvCnk73tynEjoCMRN0z+tc5feHdUu9CsTNodxNcC91C4axmitbqFVmuWkTzUedFLbWGC rHHzjuK7qx16zvksDieB79Hktop4ijOq4ySP4cghgDg4PTggJJ4i0xNLj1ETSyW0sjRRmG3kkeRg WBCoqlm+6x4HQZ6c0AcxH4cudW0DwraapokdtHa6hJNeWQkBSOMRXCrxvYbWZ4/kDMAG28gGuysN PtNLso7OxgWC2jzsiT7qZJOAOwyeAOAOBgVn3PirRbTTLPUJbw/Zr2Xybdkhd2kkwx2BVUtu+Rhg jORjrxWhYX9vqdlHd2rs0L5A3xsjAgkEFWAKkEEEEAgigCzRRRQAUUUUAFFFFABXN+Iz/aupad4e jhMitNFfXj8bYYoZA6ZyeS8iKoGDwHPGK6SqWrapBo+nPe3CSuoeONY4l3O7u4RFA9SzKOcDnkgU AcZrtprf2Lxvptr4evbv+2d/2W4imt1jO6zih+bfKrDDI2fl6dM1U8WaBqcviK81Cx8ONq7uUKG7 ityq4RRiGY3CSQj3CnDbjg5Fd1ca7ptql+09zsGn7ftPyMSm4ArgYy2cjG3PPHUYpmpeItM0i5SC 9nkjZlDFlgkdI1JwGd1UqgJB5YgcGgDJvfCVnrHjK+v9V0+O4tTp1tBbu7Z2yLJOzlQDlWAePDcE ZOD1rqqxdS8V6NpGoNYXlzItysK3DpHbySbImLAOxVSFXKNkngd8ZFbVABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAVXv0nk066S1bbcNE4ibOMPg4P54qxSMyopZiFUDJJOABSaurAzmdG066t rmZp7ARwm3ZGiSCNBM2Rjd++fc2MjJA6nJqbQ9PuI2uU1GycrLGFjMsiSBIe0J56jueQeOTitS21 azu9/kyOxRN+DE6ll9VBHzD3GaWPVLOcEwymXEInPlozHYenQdTg4HU46Vzwp0o2szNRjpZmVpGm xWC3kZ0ARvuuMSqkOJozIxVBhs8qV4YAcc4ohs7ubXLS6ktrsQwu+1bnyAsIZWGU8s59F+bPDVfs tbtb+OV4YrweXvyHtZFzsYqcEjBOR0zn2BBAWLV1a7htp7S5tpJ8+V5oUh8DJ+6xxwO+KShTtGz0 BKNlqaNFFFdRoFFFFABRRRQBn63byXOltFHAbg+bEzQjb86CRSw+YgcqD1NYTaVeiwuUtdPMEUt+ Jfssmx90QiVcFRIFxvH3dw4H4V09zcxWdu087FY1IHCliSSAAAOSSSBxWfa65BMl9PI4WCC5EMeI 23tmNGxt6ltzEYxnjpXPVhTlL3n/AFqRJRb1M4aNNceFtRs7iyRpn8xrWB4kRYmMeF2De4XnJzuG MnoK0dUtXg0lLTTdNikjZwrQoqqiLyxO3coPOOMjOade65bW2jT6jEJZVjV/lEL5DAE4YYynTksA BU1te7dLS6u3yf4iLaSIk7sACNst6D3/ABpRhTV4p9PLYVo7Iw7Oz1K1igkfT2YQagZUt4BHHtiM BT5VMhUDex43ep9qtvaXl1pPiBTaPDLe7/JjkdMnMCIMkEgcqe9akWp2k4iKSnMsphVWRlbeFLFS CMqcKTzj9aratqEsOmahcWEsPnWIZpVliZgcR79vBXkgrzz16UvZwjDR3Xy7f5ByxS3ItVt31vw7 exS6W63Bik8iG58tm8zYdrAhioOTjORVTUdPM9lZC20d40j3/wChmGB40yR95PMVc9wVJ6nPWtnU tRh0qxku50maOMEkRRFzwCe3QcdTgeppj6taRwxSN5483OyP7NJ5hwcE7Nu7HTnHcetVOFNtqT1t 5dwaj1YmjJNHpMCXFqLWUbgYQQQvzHGME4yMHGTjOO1X6it7iK6gWaFtyNnBII6HB4PI5qWtoJKK SLWwUUUVQwooooAKKKKACiiigAooooAKKKKAMHXWvv7T0l7XSbu7jtbg3EjwvCowYZY9o3yKc5dT 0xjvnit6qF1qgtNVsrKS0uCt2xSO5XZ5YcI77T827O1Cc7cdOav1K3ZrUbcYpq2n36vz73OY199T aea007QJmiuOLq+jNuWZdoHyq8gycfLlumOjCt7T4Ut9NtYIrd7eOOFEWFyC0YAACkgkZHTgn61U vdZeznlRdK1C4jiGZJokQIoxnjcwLcf3QfTrV+1uYry0huoGLQzIsiMVIypGRweRwe9JJcz1NKkp ulFOKS/P11f6eRLXmtz/AMfV3/19z/8Ao169KrzW5/4+rv8A6+5//Rr13YT4mebifhRly/eool+9 RXonCWfhW1+nwwc6XGsl8yBYAxAVWJIDHPZc7iOpAIHNdvP4Xhk8LLokN5PEyOk63ZCs5mWUTeYw IwxMgywxg5I4rivhRetp/wANobhIDO/mRRrGG25LyBOv/Aq7yTWJraz1J7q0VLixt/tBjSXcrrhi MNtHUow6cY71484ts9BVYRVn/W/+RiXXgi71ZNXOra4zT6jDaRrJY2/2byDbyvIhX52PLOM854OC Mja+08Dtb+GL/TH1aV726ulvRfYdzFMmzy2Ald2IXyk4LHPI4B43H1K7t7OWe7sBGQUWJEmDF2dt oU8DackZ6jnqajXWZfIKPZgXwuTa+QsuVL7d4O/A42fNnGe2KnlZTrQW/wCTKH9h6hpvhSHRtPvJ pbueYi61HCI6+Y5eaYDoCcsFABwWXqATV7U/D0F74bGjWkpsVhWL7JLGobyHiKtGwB6gFV47jitG 1kuZIibqBIZA2MRyb1I9QcA/mB0qepNE7q5x954ck0rwtYCK/upb/Tbo332pLQTNNM+8Ss0K4LKf OkO1SGHGCSOc/SfDV5rNneX17cPFdtrQ1OzlnsPLDFbdIQXgf5gvD4BIbG05zzXoFFAzjLnwReXq 31xdatbPqF3JC5dLIxwp5QcLtVZBIG+c5cSbuFGQBg1bfwHNZyNbG9uLpNUZP7WuXbhoYgxWEb2Z zvL4JZmO0MMj5a72igDF8S6FPrljAtlqT6Zf2s3nW12kSyGNtrI2VPUFXYdR1B7VR1PwlcTaNpel 6TrE+n29hEIduZB5qhQAWMUkT7hjs2OTkHjHUUUAcvpHg46Xp2iWjalJcnS9QuL0yzIWefzROMMS xOR5+d3OdvQZ46iiigAooooAKKKKACiiigArF1LT7rVNcsY5Qy6VaYunwVxPOGHlqR1whBftk7Oe CK2qyfEeo3Om6ZG9l5P2ue6t7aLzULqPMlVGbaCCdqlmxkfdoAoav4S/tXxFaamupS29uvlfbLRY 1ZbryXMkOWPK7XYk9cjA4rO8WeBdQ8US3qjxJdWlpdQGIQJ5o8v5ccBJVRlJ5IdGJyRkDGLN94vv rO71t10ZJNM0WVVu7o3e1ynkxysyR7DkqsnILDgcEk4FvUNf1SLxFcaTpmix3pt7OK7kle8EPDvK uxRtOW/dEjJAOTkrjkA0odLEXiK81bzcm5tILby9v3fKeZs5zznzsYxxt7540K5fVfFlzYT6pJBp a3GnaRt/tC4a52OnyLI3lptO/ajqxyy9cDNWbjXNSl1S8tNJ0mK8SxZUuZJrvyTvKK+yMbG3NtZT 8xUfMOeuADfooooAKKKKACiiigAooooAKKKKACiiigAooooAKgvLVL2xuLSRnVJ42jZkxuAYYyM9 +anqtqN39g0y7vNnmfZ4Xl2Zxu2gnGe3SlK1nfYT21M3TtBlsLlrhr955RC0MRkMjbQSDkhpGyfl HTbU2j6K2kPOVvZJ0nPmSCSNATKerAqBgH056cY5zNa39w94La7tFt3eMyxbZd+VBAIPAwRuXjkc 9arWWtXE2lf2ndWIt7Q2v2kMs29gAM4IwO3I69OcVzxVKLVul+/z/pkLlRPaWF1afaIlvE+zyNLJ GPJ/eRu7Fid2cEAseNvpz61rTQmg1Vb95bZZBu3fZbUQmXd18w7ju557c1Kury25kGo2gtttu9yp SXzMomNwPAwRuHHI561ZtJ72Z/8ASbJIIyu5Ss29h7MMDB+hI461SVNtLt66D91lyiiitywooooA KKKKAKmpWbX1n5Mc3lOJI5VcruAKOrjIyMjK4PIrMm8Oy3EEvnajILh7sXYlhUxgMIxHtwGztwD0 YH3651NQu2srQzJGJHMkcaoW2gs7hBk4OBlh2NYya3JYpqMt8qRyG/WCOOW4AjQ+TGfvkcLwzdO/ TJrnreyv7/6+ZEuW+pbh0Ix6LqFg10zyXoffMdzYLIEz8zMTgAdWq5qdnPfWoigu3tm3Biy5+Yf3 Tgg4+hB4rKuddnuvDWoXmnrbNNbLIrslxuRSE3bkYKd3VeCB3zjFX1lfS9FDziNZI+olvCy8t3lc A989OOgHSlF07NR2t5/13EuXZFO38PTWsPyaizXK3f2pJZUMgB8ryypDMSRjOPmyOOeObSaOzWOp 291dGU6gWLukYTaDGseAMnpt4/r1Mdlr8d59nCJE5kumtXaGYSICIjJlWA+YYAHbqfSotZuDdaNr e0zQyWAfy5Ip2QlhCHB+Ujj5+hyOKS9koc0f17f5B7trovPY3F3pNzY310kjTxvEZYYvLwrLjoWb nqfT2qte6Rc39vbedeQ/aodwMqwsgOcdArhl6Do2D6dMWNbvLqw0i5u7SKGSSGN5CJXKgAKTngHJ 4HHGfUVBf6vPp0Nv9ot7aOWXduZ7giFMY4MmzOSDx8vY+lXP2aupdvPuN8uzL9jbPaWUUElxJcOg wZZOrc/5HOT6k9asVBZXBu7OOcqi7xn5JA6/UMOoPWp62jaytsUttAooopjCiiigAooooAKKKKAC iiigAooooAx9X0zUr6+sbizv7S3SzkMypNaNKWco6HJEi8bZDxjOR17VsVz8t7rN3qV/DYXFjbxW sqwKJ7OSYu5iWQkssihVw4HI6jryBWppN7/aejWN+U2G5t45tv8Ad3KDj9aiLV3Y6KsZ8keZqy/X Xtr+Jj61oGsatfsy65AmmHH/ABL5bIujYHO9lkVmBPbIHYg10ECyJBGszI0oUB2jTYpOOSAScD2y frWHLe6zd6lfw2FxY28VrKsCiezkmLuYlkJLLIoVcOByOo68gVqaTe/2no1jflNhubeObb/d3KDj 9aI2u7FVvaezipNWVtlbdddFe/z8y5Xmtz/x9Xf/AF9z/wDo169KrzW5/wCPq7/6+5//AEa9d2E+ JnmYn4UZcv3qKJfvUV6Jwln4WWH9p/DKC1whVp4mcOSAVWUMw/EA16NHo1hHb3UAgLLdJsnZ5GZ5 FwRguSWxgnHPGeK86+F089r8KhPbsqSKRhmHQbufxxnk8Dvxmuu0zUrzUbHUBZz3Es0Kq0Mk3kMr tydoeM7SDgA5AIz+XkyT6PQ7Oamp2cbtr/M6C6tYL22e3uYllhf7yMMg85H4g4Oaqf2HpiWZtzbL 5XmGcs7Ev5n9/eTu3Y43Zzjiswazd3uj3uqW263h+RIUmUArhsSMeuDyV54BTPTJqrJdzap4J1aY Xt2PKScCVlhJlUIeNyAqy5JGVweMcEHMqMu4TrU3ry3dm+mx0empZraB7GUTQuxbzRMZd56H5iST 0x17VbrE1ia50rSIPLvHOJQsk8nlq+zBPB2iMHoMkAY96l8P376hYSSs87hZSivOI8sMA5BjJVhk nkY9McVLi7cxpCrFSVO2tjWoooqTcKKKKACiiigAooooAKKKKACiiigAooooAKzZ9IS51+11Od1k W0hZLeEp/q5HPzSZz12gKOOAW5+atKuf8UzSzRWOkWjzrd311ESYJTGy28ciNOxYEFRsymRzmRR3 yACqvgjT7vW9a1DVIFuBfXccqRieQI8aQRIFljBCPh0cgMGGD7kV0SWNvHqM1+seLqaKOGR9x+ZE LlRjpwZH/P2FeeeKvF1/pHia8tjqN3Gsfl/ZLWxW1Z5copO6KfbJKdxP+qbpgdQa1/EWuaxpmuto 9uszvrKIml3KxoVtpRxMGz12p+9GQc4YdgKANm/8IaFqd9LeXdgHlm2+eoldY7jb93zYwQsmBgDe DwMU698KaLf38l9NaMlzMFE7wTyQ+eAMAShGAkAHGGzxxXGeKfFuoaR4lvLZtRu0WPy/slrYras8 uUUndFNtklJYn/VN0wOoNemUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVTVbV77SL20iK iSeCSJS3QFlIGfbmrdQXskkVhcSQlRKsTMm4EjcBxkDkj6VMknF3E9iG00myspjNBDiXZsDu7OVT rtUsTtXgcDA4FTJZWyWC2IhU2qxCHyn+YFMY2nPUY45rA0XVJ9QuZrZbu5dvIZjK3kOkb5AGDH0P JO1hzj2qWz1bUL2G7cRGCSyt2jlWRQVa568bckqAAeOocd+mMKtOysv66kKUexowaHpsHmbbUPvi MLeczS/uz1QbicKf7o4osLXTbe5lSzkBlhAR4/tDP5QPIG0k7AcdAB0rK0TVJtQuprX7XdP+4LGX /R3WNsgDaydDyThl7e2Kl0mO4tNE1CZLuSaXzrop5yqQrLLIM/IoJzgE9fYDpUxnB2cY6a9gTT2R 0FFc5oGrSXt+8DT3E4ERdmbyHjVsgYDRnIPJ4YduvFdHW9OoqkeZFxlzK6CiiirGFFFFAEN3aQX1 u0Fwm+MlWwGKkFSGBBHIIIBBHpVRdD01YHh+zZVpfPJZ2LCTaF3hichsDqDnr6ml1qWeHTwbeYwy PcQR+YFBIDSorYBBHQms2W/u7aGeCW9YJDfLBJesiAxxmJZNxGNvVgucY5zisKkoKXvL+tSJNX1R rrploLGaz8tmhnDLKHkZmcMMHLE56cdafeWNvfxLHcoWCMHUqxVlYdwQQQeT09aw21qSDR5Znnlm j+1eRDeRrGNyYB3ksVQDO5c9MgcHNRWOvyyW8U80zpaxX5glmnEYJjMJZSxXKgb2XkcEY9TU+2pf DbcXNHY2BoenCBoRAwVpROWEr7/M2hdwbOQcDGQfX1NSwaXZW9vcW8cA8q4JaZXYv5hKhTnJOcgD PrWPdXlxqej69JZXsy/Z3cW7W4XLAQI20EgnBZicjnpg1JLqCppkUltrJuIHuRHNenym+zrtz/Co UchRyDjfzQp009I/kHNHsasWm2sVlJZhXkt5AVZJpWkyCMEfMTxjt0pjaRZtbwwET7YQRG/2mTeA eo37txH49h6VHot1JdW0xeb7RGkxSG4wB5yYB3ccdSRkcHbmtKtYqEoppFJJoitraGzt1gt4xHEu cKPc5J+pJJqWiitEraIrYKKKKACiiigAooooAKKKKACiiigAooooAy7zw5pV/cyXE9qfNlAWYxyv GJgBgCQKQHGOMNnjitGGGK3hjhhjSOKNQiIigKqgYAAHQCuO1S4so9a1JdZvr22IZPsiR380G+Ly h/q0RgJH8zcCOvT2z0+jm7OiWBvwReG2j88HqJNo3frms4tNuyOqtCcacXKTa0/Lp6bPsQXnhzSr +5kuJ7U+bKAsxjleMTADAEgUgOMcYbPHFaMMMVvDHDDGkcUahERFAVVAwAAOgFcdqlxZR61qS6zf XtsQyfZEjv5oN8XlD/VojASP5m4Edentnp9HN2dEsDfgi8NtH54PUSbRu/XNEWm3ZBWhONOLlJta fl09Nn2Ltea3P/H1d/8AX3P/AOjXr0qvNbn/AI+rv/r7n/8ARr134T4meZifhRly/eool+9RXonC bXwW/wCSe23+8a7trhZrq4sUaSOZIUkMigfKHLgEZzyCh6jHTrXm/wALbee6+E8UVvzI0gJXdt3q GBZc9ty5GfeulGkXjJq32CwXTVnhgWGNmXDbWcupCN8uQccH+LOc5ryJJN3b/rQ7ZVJxsoxv/TN4 eRo2nQxgSNGrxwg9WLO4XJ/4E2T+NXq45NH1JtLvojYxRpJLbNHaxKsC/JKGc4EjgZAHIIPHTPW3 bafeW1vBPDp5jSHUHuI7FXQMkZjZCAc7clmL4zjnFJxXcUK07pcllb7tWu3b5+R01RXVzFZ2k11M SIoY2kcgZwoGTx+Fc3dw3C2t7d31vHFbPfpPLbyzIBLF5SIFLE7QdwBwTglcdwarWlhb6t4c1+K2 soHWSaRrSPckiq/kIF2tkqCDkcHA5GeKFBbthLESvaMdde/n5HW20zT26SvBJAzf8s5du5frtJH6 1LWLrOlBtJhtbC0QRxSh/s8aIEIw2QUJCsMnOMjnnPFSeH7a6tbCRLq2gtyZS0ccCbAFwOqhmAOQ eFOPxzUtK1zWM5c/I18/6RrUUUVJsFFFFABRRRQAUUUUAFFFFABRRRQAVn339nabJLrV38jxwiFp fmYhN2QqqM8liOgyTgc4FaFc7rwfVdW07Q4WUKssWo3T4yUSGVXjUc8F5FHPPCP3xQB0VZ82kxXG uW2qSzzu1tEyQwEr5aM33pOm4sR8vJwB0AySeE8VeGdau/E15d2GjWl80/l+RcX0UcqQEIq/K/nR ywjIJ+QPzk9TgWvE9tNL40i0Wyu7XyPEEKjU7UnM0ccecygBvuyIDCSR1C+hFAHoNV76+t9Ns5Lu 7k8uCMDc20seTgAAckkkAAckmvO/FPhnWbvxLeXVho1pfGfy/InvoY5Ugwir8riaOWEZBPyB+cnq cDqrwNrfieGwDD7DpTJc3PGfNnOTFHnPG3iQ+5j96ANay1KG+utRt4lkD2FwLeUsBgsYo5crz02y KOccg/U3K4Wbw/ro8U6nqgENxph1KO4TTHUZuMW9unmh94AZGRtquMZXPBKsMzxh4Y8S3/iG+ubG 2tLlZ1j+wXb24eXT2VQDtdp0MfzAvlEcndgggYoA9NorlbHwlZyeJ9b1fUdPje4k1CKaynZssqJb wLlcHK/Ojg9NwGDkYrMi8GGGyF9HpsY1wa810txuXzFt2vy7YbPCmBmJTPOTxuNAHe1l2GtC91nU NLewu7WeySOTdMYys0btIqumx2OCYm4YKenFcNJ4Y8Sjxp9r+zWkgOqLcrqi2481bbeCYTKZwwGz KbREVPXqc11ksV/Y+NZb6LTZ7uzvrO2tWkhkjH2do5JiWcOykribPy7j8p46UAbN3fW9iIftEmzz 5VhjAUks7dAAPxPsASeBUep6lDpVqlxOsjI9xBbgIATullWJTyRxucE+2evSsm1Da34olvmYfYNJ Z7e2XH+suCAJJM5/hBMY46mT2rl9R8L382qq58P/AGm+GtwXn9sefGP9FW5RwnLb/kQBdmNvybgc 4FAHpVU9J1KHWdGsdUt1kWC9t47iNZAAwV1DAHBIzg+prg9D8Oa/Z+OzeyWVtb2ovryaa7SFRJcw yGQxo0gmLPgtGcNEu3ZgHjlPBPhe/wBK/wCEdVvD/wDZNzY22zUrzz43+2DytojyjFmw5VvmAC7M LkGgD0miuB0bTteii8G6XcaLJDDocgS5u2uIikgS0mhVkAYsQSw6gEZHB5I5/RUs4/GXhuxFrZtr Vlezrqd9BeRSPcv9mnUuyqxflv8AnoF2E7RnJoA9eooooAKKKgvYpprC4it5fKneJljk/usQcH8D SeiAGukS+itCG8yWN5VPbClQc+/zj9arhYdE0u6uHeaYRq9xM7YLyEDJPGBnAwOg4FY1vpNyL1pL PTv7MP2CaDzS6t+9YptbCk56E5PJxzjiqsGjaoLPUYjaQwebp8sPlxIIxNKR8pJ8xt3f5m2nnn25 XVnvymTk+x2VFcyNHnmgvorexXT0msZLd1Z1PnSsMB/lJ6c8nk7varEsep6heiVbV7ErYzwpJJIr FZXMeDhSePlJz7duM6e1l/L/AF9xXM+xvVV0++XUbRbqOGWOKTmMyAAupAIYAE4Bz3wfauX0qLTN Q1uOKLT7UQCykWeMSRzK7b4iCwUkdsgnk49q0oNGa38HQ2ENssNyYYjMkW1d0gC7snoxOMHPXpnv UxrSlqlpr+nkJSb6HQUVh+HrO7tDcmezt7WJtnlpFEIySM5LKrsvccjB9e1blbQk5Ru1YtO6uFFF FWMKKz9as2v9PFuIhKDcQM6HGCiyozZz7A8d6zZdJmjhngis1exW+WVbRWUCSHylBUAnA/eZbBwD j3rKc5RdkrkttPY6Kiubax1GPR5YbayiWOW63CzkAfy4cD5QA6qTuGcbsYYjmorGw1S2t4pZbJM2 9+Z47aDag8owlMKCxCnc5ON2Mg46io9tK6XKxcz7HS3FxFaW0tzO22KJDI7YJwoGScD2qSudm0mb U9M1uO7sY1lupGe2SUq+0+QiK2RnBBB+n606Ww8zTIo7fRRbQrciSexAiXz124/hbaedp5Izswaf tZX+HT5/5BzPsdBRWbotrLa20yvB9njeYvDb5B8lMAbeCR1BOBwN2K0q1i21dlJ3QUUUVQwooooA KKKKACiiigAooooAKKKKACiiigDNvtf03TpzBczuHVQ77IXkEanozlQQg4PLY6VoqwZQykFSMgg8 EVzk8OqWGp6k9tp7XsV86yxlZI1VSIhGUk3HOzKhsqCeTx67Gk2T6do1jYyS+a9tbxwtJjG4qoBP 44qItt6nRVp04wTi9dOvlr6W89yG+1/TdOnMFzO4dVDvsheQRqejOVBCDg8tjpWirBlDKQVIyCDw RXOTw6pYanqT22ntexXzrLGVkjVVIiEZSTcc7MqGyoJ5PHrsaTZPp2jWNjJL5r21vHC0mMbiqgE/ jiiLbeoVadOME4vXTr5a+lvPcuV5rc/8fV3/ANfc/wD6NevSq81uf+Pq7/6+5/8A0a9d2E+JnnYn 4UZcv3qKJfvUV6Jwmv8AB6eK1+GVvPO4SJGYsx7dK7C3123nvL0F9lrawRSM0kbRsrMZAQQwB6Ku OO/fIri/hNZrf/Cy2ty5QmXergZ2srKynHfBArr5PD73gvjqF1HcG6jhTC24VFMbMy/KS2RlhkH0 Prx5D5b6ndJ1brkWn/D+fexeTV7KS3kn811SJlWQSROjKSQBlSAQOeuMUT6xY2y7pJiB532cbY2Y mTbu2gAcnAPTvx14qtYaFBawXcUkVltuVCOtraLApUZ68kk8nqfpiqv9iXlvY6VbQXSyTW9280ly 0QA5SXkrnnlwDg55zU2j3E510l7v9X9e35al29122tdFn1KJZZ1jV/kWJ87lBO1htJTpyWAA71Md XtBa/aH89EL+WqyW0iuzYzhUK7jx6DsfQ1EujhtN1C1nn3yX+/z5UTaMsgTgZOMKAOp6U250y5vr AQXk1lPKkm9Wey3RkYxgozHnk8gj+eT3Sr1t7dPx+/8AruXrW7hvYjJCWIVtrB0ZGU+hVgCOoqeq GkaYNKtXhDod8hk2xR+XGmQBhVydo4zjPUmr9S7X0NYOTiubcKKKKRYUUUUAFFFFABRRRQAUUUUA FFFFABWfrWp/2RpjXYh86QyxQRR7toeSSRY0BODgbnGTg4FaFYupabLqviDThcQK2m2ObsFsESXH 3Y+OvyDc3I6lCOV4AKPi3xpY+HNK1UpLv1G0s3nRDbySRK+wmMSMo2puIAALKTnitG/8T6Rpt8LO 6umSYbS5WF3SIMcL5jqpWPPbcRWTr/g681WLW7ex1iOytdaj23avZ+c+/wAsR7kbeuAVVQQQenBU nNRa18P7PVdautRWLSGe8Km4a+0mO6kBVQgMbsRt+VV4YMMjOOTkA6G413TbVL9p7nYNP2/afkYl NwBXAxls5GNueeOoxS6zqf8AZViJkh8+eWVIIId23zJHYADODgdycHABPaszV/CUOq+JdO1ZrgRx 2+PtVv5QYXWw7odxzxsclhwevarP9my3viz+0byBfIsIfLsN2GJd+ZZB6cbUHQ/f7NQA248X6Ha6 nPp81263FvIkU+LeUpCzqrLvcLtUEOuCSB26g1X1LxnZ6X4lh0eaz1Jy9vLM0sGn3EoBUxYC7IyH BEpyynClQDywrOn8KarqOpeJ4pb6O20jVbpBJCbcSPNCLaGNijhxsJKup3KemQB1O3q+j313qllq emX8Fpd2sM0H+kWpnjdJDGzAqHQg5iXBz68UAKPFWkHUfsQnmaTzvs5kFrKYRLnbs83b5e7dxjdn PHWtmuOl8CLN4hj1Iy6bGsd4LtZIdMWO7zvLlDOrcqSSD8mSCckkk12NABRRRQAUUUUAFFFFABRR RQAUUUUAFIzKiM7sFVRkknAApahuraO8s57WUExTRtG4HoRg/wA6TvbQDPh1yC51SK3gf9ybaWZ2 kjZCNrIFI3AZUhm56cdasQ6xYzpK8cr4ij81t0TqSn95QR8w9xmqn9iTXMzNqF6txGbSW0KJD5eV crkk5PPy/TnoO7tL0KPTbhpQliD5ZjBt7JYWIyD8xBOenbA9qwi619Vp/XmQua5cm1OzgRnkmAVY DckhScRjq3A/+uabBq1nciUxPIxjTeV8lwzL6qCMsP8Adzmsx9Aa10TV7eB/PmuYJI4FIC7E2kJG DnoCTzx1rQtdPnjvVuru6WeSOIwxbYtmFJBOeTknavoOOlNSqt2a/r7wTkQWfiG0ureWaRJ4Fjd1 JkgkCkLIUGCVALHj5RyCcdQavWl9Be7xCZAyY3LJE0bDPThgD2NUhpE4hubb7TA1rLI8qJJbbirt J5nJLYYZJ4wD054p+kaQNLadw0AM23MdtB5Ma4zyFyeTnk55wKIOrdKS06/1cE5XVzTooorcsKKK KAIrm5itIDNMxCAgZCljkkAcDk8kVXTVbJ4mkWYlRt/gbLZ6YGMtnB6Z6VPdW/2mFY923EkcmcZ+ 64bH44xVBNHaJYClwBLBFFGjGPIygcZIz0Ic8dvWuarKup+4k1b+uv8AXcuKhbXcuf2hbfZvP8w7 N23Gw7t3ptxnPtjNQQapFIt1K7YiimESfI24/Ipxt65ySMYoGmv5e7zx9p87z/M8v5d23b93PTbx 1/Go20fzYZRcSxzSPP54LwgoG2BcFSeRgHv3/GolLE6WX9ff+H4jSh3Lf9o2YtxO9xHHGW2ZlOzD ehDYwfaqd5rlvFDH9hMV9cTSrDFFHMMFiCfmIztAVWOcHgHg1PBpkcdqYG2qC+8/ZQYBnGP4Tn8y f5VBe6Is8MZtrmaG5hlWaGWR2mCMAV6M3QqzAgEcHrWkXXdm7eff/IqHsub3tv6+ZSm8UGxinj1C 0SC+idFES3AMbhwxVhIwXC4R8kgY2Hg8Znt9W1S8sIZ7TTbOdpCfnTUA0G0YwRIEJOckfd/hPtmu fCxlUz3F1A9+skTwyLagRRCMMEURlj8oDv8AxZy2QRgYgn8Kag1m8FtrEMBublrm+22ZCXDEKu0B ZFKLhRnDEnueua9/+rHVbCvZr583b8u3W/lqWl8RXM0gsoNOVtTErxPC1xiJQiozN5gUkr+8Qfdz k4wMGtLS9QbUIZvNgNvcW8phni3bgrAA8HjIKspBwOD0FZSeGriO1t1in02Ce38xIxb6fsgMUmN6 NF5hzkqDkMOg982o9NvbKwmS2ufMv7u4Es90UCgE4BIU54CqFA5PTnvQ5TinJq/9f15GdVUHG0N/ n38+lvmadxdQ2oXzWbLHCqqFmP0ABNQNqVu0MMkcp2SybFfyXZc7wpBI6ZPAJ/Wk1CKbdFc2ys08 eVACqwKtjOQWX0Heq0en3jabFB5yROJ2mbzIt5J83evRgB79evasqlStzyjGOltPw63Xmc6UbJtm jcXUNqFMrNljhVVCzH6AAmqdtrNm8AkuLu2iLPJtDSBcqHZQcE+gqea1mkaCZJkS5iUqWMeVYHGf lzkcgd/zqGDSY44FSWed3DOSyTPEDuYt0VgP4utOTrup7qVvP5efr0BcltTK1Lxalrq32K3k0gob eOZZrzU/IEm5nXCYRt2PL557iuigd5LeJ5BGHZAWEb71BxzhsDI98DPpWfdWGo/Kun6hFFDs2tHd QNcZ5JyG3qc845JHA4qbR9Lh0bS4rGA5SMs2doXLMxZiAOAMseBwK2hz/aNansXTXJo/n/w33XL1 FFFaHMFFFFABRRRQBi3WsXovLuHTtMW7SzA89muPLO4qG2INp3NtKnkqORzWpaXUV9ZQXcDboZ41 lQ+qsMj9DWTeaHdSX1xcWGoR2ouiGlD23mMrhNm+M7htbZgchhx061rWdrFY2UFpAu2GCNYo19FU YA/IVEea+p0VfZci5N/n21vfTfaxl3WsXovLuHTtMW7SzA89muPLO4qG2INp3NtKnkqORzWpaXUV 9ZQXcDboZ41lQ+qsMj9DWTeaHdSX1xcWGoR2ouiGlD23mMrhNm+M7htbZgchhx061rWdrFY2UFpA u2GCNYo19FUYA/IUR5r6hV9lyLk3+fbW99N9rE1ea3P/AB9Xf/X3P/6NevSq8w1KVoWvZETewu58 Lzz++b+6Cf0ruwnxM87E/CihL96ioYpnnQu8flkHGPm9v7yg/pRXonEdB8G5Fi+GlrIwYhXbIVSx 7dhya72G6jncqizAgZ+eF0H5sBXCfBb/AJJxaf8AXRv6V6FXjTtc9OGwUUUVBYUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeY6jAlzJexOZArXc+THIyN/rmPDKQR+denV5rc/8fV3/ ANfc/wD6NeuvB/EzmxPwoxY7aO1Ty42lZc5zLK0h/NiTRU0v3qK9FnEbPwcEp+GdqISgk8xsFwSB 07DrXewfbN5FwICgHDRk5Y/Q9PzNcL8Fv+ScWn/XRv6V6FXjTetj04LQKKKKgsKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiig AooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKACvNbn/j6u/wDr7n/9GvXpVea3P/H1d/8AX3P/AOjXrrwn xM5sT8KMuX71FEv3qK9E4Ta+D0Qm+G1vGWdQZWyUYqe3cdK7yC0MDlvtE8i4wqSPuC/jjJ/EmuE+ DsiQ/Di3kkdURZHJZjgDp3rv454ZlVopUcMMqVYHI9RXjzvc9OFrIkooorM0CiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigArzW5/4+rv/AK+5/wD0a9elV5rc/wDH1d/9fc//AKNeuvCf EzmxPwoy5fvUUS/eor0ThN34NqG+HVsGAI81jgj6V3iW8EcryxwxpI/3nVQC31PeuA+D0hj+G1u4 jeQiRvkTBJ6dM4rvILsTuU8ieNgMt5keAPbPQ/gTXjzTuz1IWsixRRRWZYUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFea3P/H1d/wDX3P8A+jXr0qvNbn/j6u/+vuf/ANGvXXhPiZzY n4UZcv3qKJfvUV6Jwm78GP8AknVr/wBdH/pXoNed/B4Sn4a2whKCTzGwXBIHTsK7yD7ZvIuBAUA4 aMnLH6Hp+Zrx5rVnqQeiLFFFFZlhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5r c/8AH1d/9fc//o169KrzW5/4+rv/AK+5/wD0a9deE+JnNifhRly/eool+9RXonCbvwY/5J1a/wDX R/6V6DXnfweiE3w1toyzqDI2SjFT27jpXeQWhgct9onkXGFSR9wX8cZP4k1487XZ6kNkWKKKKzLC iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKK KKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooo oAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArzW5/4+rv8A6+5//Rr16VXmtz/x9Xf/ AF9z/wDo1668J8TObE/CjLl+9RRL96ivROE2/g5IkPw2tpJHVEWRyWY4A6d67+OeGZVaKVHDDKlW ByPUVwPwZUN8ObUMAR5rHBH0rvUt4I5XljhjSR/vOqgFvqe9ePO12epC9kS0UUVmWFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXmtz/AMfV3/19z/8Ao169KrzW5/4+rv8A6+5//Rr1 14T4mc2J+FGXL96iiX71FeicJtfB2QxfDW2cRvIRI2FTGT09a7yC7E7lPInjYDLeZHgD2z0P4E1w 3wX/AOSc2v8A10b+leg1482rnqQ2QUUUVmWFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABXmtz/x9Xf8A19z/APo169KrzW5/4+rv/r7n/wDRr114T4mc2J+FGXL96iiX71FeicJtfB3z T8NbYQlBJ5jYLgkDp2HWu8g+2byLgQFAOGjJyx+h6fma4b4Mf8k6tf8Aro/9K9Brx5vVnqQWiCii isywooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooo AKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK81uf8Aj6u/+vuf/wBGvXpVea3P /H1d/wDX3P8A+jXrrwnxM5sT8KMuX71FEv3qK9E4Tb+Dsay/Da3jYsA0j52sVPbuORXeQ2scDlka YkjHzzO4/Jia4b4M/wDJO7b/AK6v/SvQK8abd2j1IJWQUUUVBYUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFY/iG8vLCzW5g1DStOtU/4+LvUg SkeSAowGQck4yWHbg54ANiisDwl4g/4SKwu5vOtLkW101sLqzJ8qfCq29QSSB82MZPKnBIINP8X3 +paT4V1HVNLltEnsbeS6ZbqBpVkVEZtg2uhUkgfNk454NAG5RWZrDassaNptzp1rGoZp7i9jaQIB jGFVkz3ySwxjvnit4W1qTXNPuJnktZ1huGgS7syTBcgBTvTJOBklSMnlDyaANyiiigAooooAKKKK ACiiigAoork/FPiybQtXsbaBbZrdFFzqbyk5gtzIkQccjHLM2TkYiegDrKK595b238fWtt/aM8lj eafczG0dI9kTxPbqpUhA/IkfO5j14xih5b238fWtt/aM8ljeafczG0dI9kTxPbqpUhA/IkfO5j14 xigDoK81uf8Aj6u/+vuf/wBGvXpVcnb+GrW5WaefUbtGlvLjABjAyZnwBlP/AK9bUa0abuzKrTdR WRxsv3qK7B/CGnGRkF7eMy/eAePI+vyUV0fX6fZ/h/mc/wBUn5Gb8Gv+SeW3/XV/6V6BketfDzgN kkZOOpqHA9BWMqfM73O2EbRR9z5HrRketfDGB6CjA9BU+x8yuU+58j1oyPWvhjA9BRgego9j5hyn 3PketGR618MYHoKMD0FHsfMOU+58j1oyPWvhjA44pMD0p+x8w5T7oyPWjI9a+F8D0owPSj2PmHKf dGR60ZHrXwvgelGB6Uex8w5T7oyPWjI9a+F8D0owPSj2PmHKfdGR60ZHrXwvgelGB6Uex8w5T7oy PWjI9a+F8D0owPSj2PmHKfdGR60ZHrXwvgelGB6Uex8w5T7oyPWjI9a+F8D0owPSj2PmHKfdGR60 ZHrXwvgelGB6Uex8w5T7oyPWjI9a+F8D0owPSj2PmHKfdGR60ZHrXwvgelGB6Uex8w5T7oyPWjI9 a+F8DHSlwPQUvY+Ycp9z5HrRketfDGB6CjA9BR7HzDlPufI9aMj1r4YwPQUYHoKPY+Ycp9z5HrRk etfDaKCTwKYwG48U/Y+Ycp9z5HrRketfC+B6UYHpR7HzDlPujI9aMj1r4XwPSjA9KPY+Ycp90ZHr RketfC+B6UYHpR7HzDlPujI9aMj1r4XwPSjA9KPY+Ycp90ZHrRketfC+B6UYHpR7HzDlPujI9aMj 1r4XwPSkwKXsfMOU+6cj1oyPWvhQ9aSj2PmPlPuzI9aMj1r4Too9j5hyH3ZketGR618J0Uex8w5D 7syPWjI9a+E6KPY+Ych92ZHrRketfCdFHsfMOQ+7Mj1rO1PTZNQ8podVvtPlizh7Rk5BxkMrqynp 1IyOcdTXxRgUYHpR7HzFyn1/f+EZptBn0zT9dvbKe8ukuLzUAxNzLjbkKylQhKoi5AwFGNvNaviH Rl8Q6NPpb6hdWcFwjRzNa+XukjZSrId6MACD1AB4GCK+LABjoKkRVI6D8qPY+Ycp9e6x4Q/tywsb S98QaqwtXaRmAt/9JOcr5qGLYwXsNoHc5PNbOm2c1hbNFcandagxbcJblYlZRgDaPLRBjjPTPJ56 Y+K9i/3R+VRso3dBT9j5hyn3LketGR618MYHoKMD0FL2PmHKfc+R60ZHrXwuQM9KMD0o9j5hyn3R ketGR618L4HpRgelP2PmHKfdGR60ZHrXwvgelGB6Uex8w5T7oyPWuev/AAV4e1a+vbzVNOtr+e6V U33UKSGFQuAsZIyozlvXJPtj43Pb60h6n6UvY+Y+U+zrrw2k8emtDqt/a3enwmCO8hMTSOjBQwcO jIdxRCfl6jjFWr/R477UrDUFu7i2ubIsFaAr+8jYqXjcMpyrbFzjB+UYIr4loo9j5hyH3ZketZEM 0drFcWl5bzlTNIwMcDyK6s5YcqDjrj8K+KqKToX6jUT7TS7toUEcFvebR/06yjPuSVor4soqfq3m Ox//2Q== --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 7.jpg" Content-Description: Picture (Enhanced Metafile) 7.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 7.jpg"; creation-date="Thu, 08 Nov 2012 06:14:09 GMT"; modification-date="Thu, 08 Nov 2012 06:14:09 GMT" Content-ID: <3169cd5a-1015-47f2-94eb-7ada9b42ed19> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAFsAm8DASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDm9F0G Py7G0JuZ7iSNR5ao2ws+XG0hQTx7/wBKnitrCeJZYLLUZ43AKPFZXJVgehB281v+H+dY0VdkhGyE 7lbCgiMfeGRke3P6V5rF4msl0TTbMLeQ3VojLLMbyQ+Z8xKgKHAUAYHTv7V2Ymq6VlFdDipwU/eZ 1drBpt1NJEttdI8ZwwmjljweDj5sc8j8xVpNKsXQMIXwRkZZgfyJrG8NXn9oW81yVmkP2l2AWTBJ EcQGTu5+7jk/XvjqR0x6V1YZ+0pqUlqY11ySsmZsmg6bNjzbUPjpuYnH61H/AMI3o/8Az4RfrWtR W/sodjHnl3Mn/hG9H/58Iv1o/wCEb0f/AJ8I/wBa1qKTpQ7D55dzK/4RrR/+fGP8qP8AhGdH/wCf GOtail7KHYn2k+5k/wDCM6P/AM+MdO/4RjRv+fGOtTvTu9DpQ7FKcu5knwxowH/HjH+tPHhfRSP+ QfH+tap6U5fu0404dhucu5kf8Ivov/QPi/Wj/hF9F/6B8X61sUVXs4dkLnl3Mf8A4RfRf+gfF+tH /CL6L/0D4v1rYoo9nDsg55dzHHhfRT/y4R/rS/8ACLaL/wA+Ef61sClpezh2QueXcxx4V0Un/jwj /Wl/4RTRP+fCP9a2F606lyR7IpTl3MX/AIRTRP8Anwj/AFo/4RTRM/8AHhH+tbVA+9S5I9kHPLuY /wDwieh/9A+P9aP+ES0P/oHx/rWzTu1NQj2QvaS7mJ/wiWh/9A+P9aP+ET0P/oHx/rW3RVezh2Qc 8u5if8Inon/QPj/Wl/4RLQ/+fBP1rapw6Gj2cOyF7SXcxR4R0Ij/AI8E/Wj/AIRDQ/8AnwT9a3F+ 6PpS1Ps49kWpy7mF/wAIhof/AED0/WkXwjo0gJh0eefaAWFvbySlQc4JCg4HB61vYzjOcZ5wcU6z lax1C0uI7i4iCTxNL5Vw6B0DfMGUHDjbng59utRKKSukvuKjNt+8znpfCmiW8pjuNInhf5tqy20q F9uN20EDdjI+7nqPWnHwloIx/wAS9ckhcYPX0roXvLO88Q3Mmpx3dyzSvcWP2mWRkEQkO5MbZDGC vknARfu8kc5qgWw8PXkEFjIl/Nfu8RkYu8VsUAULKx6bgABnPfAPIyU1ZXgaSTtdSMf/AIRbw+CR 9gUY9QwpzeFNCUjOmttLbd4jcrnGcbumcds9x6iuturnQ5bvUFGnwpYi6s3syLPG5FdTPwR6A9QM /wAOTzUEb6YsSjyDxrgmzJEzMbD+6SQSV/6Z5z/s04zTXwfgK3945k+E9BUEnTwAMZ4bvTD4U8Pk pt0tpXkGUSKF5Hfvwqgk8c8DoCe1dDrR0280ydY7URyDU3ZBbW7JmyKnG5Rt3gHnYTuxwAK1rS90 e11/QdQiRoBbC4F6Y4mC8qRG21UVSTk8quRnBqnNWvyfgCjr8ZxUfhHw9KgdNPjKnocEU4eD9BBy NPjB9s1sWyNHawowwyooI98VIa2cI22X3GHtJdzF/wCES0T/AJ8V/M0n/CJaL/z4r+Zrbo7VPJHs Pnl3MP8A4RPRf+fJfzNH/CJ6L/z5L+Zraop8keyHzy7mL/wiei/8+S/maP8AhE9F/wCfJfzNbVFH JHsg55dzDPhTRc/8eS/maT/hFdG/58V/M1tnrTT1pqEeyI9pLuY3/CLaN/z4p+Zo/wCEW0b/AJ8U /M1sUU/Zw7IfPLuY/wDwi2jf8+KfmaibwjpH/PFv0repDQ4R7EuUn1Zg/wDCI6T/AM8W/Sj/AIRH SP8Ank36VumkqOSPYFfu/vZhHwjpP/PJv0oPhLSf+eLfpW7SetHJHsDT7v72YI8KaV2hP6Uf8Ipp X/PI/pW4OlB6U/Zx7E69397MP/hFdK/54n9KP+EV0r/nj/Ktqiq9nHsPXu/vZi/8IrpX/PH+VH/C K6V/zx/lW1RR7OPYNe7+9mL/AMIrpX/PH+VNbwtpYPEJ/Stymt94Uezj2DXu/vZif8Ivpn/PE/pS f8IzpQ/5YE+xHWtumGp9nHsVr3f3syf+Ec0n/nzT9f8AGkbw1pLDAtgvuP8A69a1FHsodhOcrbmN /wAIxpg/5Y/oKX/hGdM/55foK1zTS37wKXRAVJ3OHxnjj5VY5P07UOEErtBG76v72ZP/AAjOmf8A PL9KZJ4f0mLG+JuSB8qE49zgcD3PFajzeXI6x7Ljbu3eUWGwgAgNvVcZz2zTbxW8uUxxTSOVMe1H 6A5wdu4Dr3HNCjBrYai72bf3mQNI0QuqAfMw3YKkYGM88cdO/Tj1qdfDmltGrCE4YAjK44Psela1 3rM0utXgM2oG0kju9iNM5RlIIjATPunpjPPskYxGF2OgX5QrnJwOBz9KIwi+g5Rtrd/ezBOk6OLr 7N5Mhl44ELEc4xyBjvUcWmaOJRII7mXeOEaBiB+Sgj6V1djd2Nqsw1GG5ubdpYytogBDtuA8wFmV QMfIQDls4IIqlPLI+omTfcXTvI3+kliu/wCUclWIPtgDA7HFOCg204lLTW7+86Hwj4TuvEem/bId TSzFv5UKj7P5hP7mNs7hIMfex07VtTfCu8uFIl8SSHJySIJQSfqJvetD4VoF8Lz4LHNwh5Yn/l3h qK5u9fuvEWtRW8niB7W0ulijGmmwEar5EUhB88by25zz0wVx3rx6tafM4t7eR6FOjCyl1KMHwlmt mZk14MW6mS1kf/0KY4qf/hWF3/0HIf8AwAP/AMdrcl1q8bxHBZRuyRDWjZShiGDp/Z5nAHyggbiD 1JyOuDhW+DvFV34oSWWXSJrO2EMMtvKzSkTCTfkZeJASoUE7Sy/MPmzSWJqJWTKlRhJ3a1MX/hWN 3/0HIf8AwBP/AMco/wCFY3f/AEHIf/AE/wDxyvRl5UHA6VyPiq71aPxFpVnp0upiGW1uZpY9OFrv JR4ACTcDG0CRuBzyKFiqv8wvq9PsY/8AwrG7/wCg7D/4An/45R/wrG7/AOg5F/4An/45XQ/2hqdj LpWmRwveXU9vLczSajcpC6KjJuU+VGULDzQMDAwvXvXOL4o15/D+mPbeVNfSWeizzyTzCNH+0zFH wFibBYrtJ6AMSoBX5n9Zq9w+r0+w7/hWN3/0HIv/AABP/wAdo/4Vjd/9B2L/AMAT/wDHK9Hx7VR1 OK+k0+UafIsV0CGjL9CQc7T14OMZ9DS+s1e4vq1PscN/wrG7/wCg7F/4An/47S/8Kzu/+g7B/wCA J/8AjtXrvxVdX2jTatpoaO1s9LOozqHAdmaFnSIEoyggFWJOcfJwcmp7jxfexeK5NLg0aa4gguIr aWePzztMioxbiEx4UOCd0ikDPHTK+s1e4/q9NdDK/wCFZ3h/5jsH/gCf/jtKPhpegf8AIdt//AFv /jtT2vxFluZry3Olql3Cxt0T7SSrXQaONovujChpkO7qRk4GK7wctxn3o+sVO4fV6fY88/4Vpef9 ByD/AMAW/wDjtH/CtLz/AKDsH/gC3/x2u51OyuL62WK21K709w4Yy2qxFiMH5T5iOMc54GeBz1rg 7TxNq+maNoU8z3mtXmtWIvCkisqW+FjLBBbWzvgmUD5gQMdQeCKvU7h7Cn2H/wDCtLz/AKDsH/gC 3/x2j/hWl5/0HYP/AABb/wCO1pXfjG/jMHkaICzwWEsiT3bQtEbqV4gpXyycqVGc474wRyHxTrsV xci40WwWG01C3sJni1N3bdKYdrKpgAIAnTOSD8rD0yfWJ9w9hT7Gb/wrS8/6DsH/AIAt/wDHqX/h Wt7/ANB2D/wBb/47Vq/8Z39hp881tpsd2Yk1S5c3F6YyI7Sby8LtjOS2RgcYA5YnmrWr+LrjTdcj 0+O1guY2ube3aVJpmeEyuqguqwlF+9nDSDI6dRT+sVO4vq1PsZY+Gt6Dn+3YP/AFv/j1H/Ct73/o Owf+ALf/AB2ut8NXlzf6VNNdvvkW/vYgeOES5lRBx6Kqj1455rVPU9u3WpdefcfsKa6Hnv8Awre9 /wCg7B/4At/8dpR8Nr7r/btv/wCALf8Ax2i88Wa5b+ENeuY9K1CWa1bURDqCNbiJBFLKqMVaTcQg VcjYSdp4PfaTxRcy+Mp9CXSpmt4X8qS8TzSqN5IlyT5flgYYLzJnJHy4OaPbz7h7Cn2Mb/hXF8P+ Y5b/APgC3/x2j/hXV9/0HLf/AMAD/wDHafaeMNUTw7b3bWMF5LbaHaapeTPdmIyCVZCwVFjILZiJ A4HzY4A578dOlP6zVXUPq9Pseff8K6v/APoOW/8A4AH/AOO0n/Cur/8A6Dlv/wCAB/8AjtehfhR+ FP61V/mD6vT7Hn3/AArq+/6Dlv8A+AB/+O0v/Cur7/oOW3/gC3/x2vQPwoo+tVf5hfVqfY8//wCF d34H/Ictv/ABv/jtH/CvL/8A6Dtt/wCADf8Ax2vQaKX1mr3H9Xp9jz7/AIV5f/8AQdtv/ABv/jtB +Hd+Rj+3bcfSxYf+1q9Boo+s1O4ewp9jzkfDO7Egf+3YMhSuDaPg5x287BPHX/GpD8Ob1gQdct+T n/jyf/49XoP4UfhR9aq/zC+rU9rHnjfDa8cknXIMk54tHH/tapf+Fe6h/wBBy2/8AGP/ALVrvvwo prFVVsxrDUuxwP8Awr2//wCg5bf+ADf/AB2j/hXt/wD9By2/8AG/+O131FP61W/mH9Wpdjgf+Fe3 /wD0HLb/AMAG/wDjtH/Cvb//AKDlt/4AN/8AHa76ij61W/mD6tS7HA/8K8v/APoOW3/gA3/x2j/h Xl//ANBy2/8AABv/AI7XfUUfWavcPq9LscB/wru//wCg5bf+ADf/AB2j/hXd/wD9By2/8AG/+O13 9FH1mr3D6vS7HAf8K7v/APoOW3/gA3/x2j/hXd//ANBy2/8AABv/AI7Xf0UfWavcPq9Lsef/APCu r4/8xy2/8AG/+O0n/Cub7/oOW/8A4AN/8dr0Gij61W/mD6tS7Hn3/Cub7/oOW/8A4AN/8do/4Vzf f9By3/8AABv/AI7XoNFH1qt/MH1al2PPv+FdX3/Qct//AAAP/wAdpP8AhXN9/wBBy3/8AD/8dr0L 8KPwpfWqvcX1en2PPD8OL4/8xy3H/bi3/wAdpP8AhW97/wBB2D/wBb/47XolFT7efcPYU+x53/wr a+/6DsH/AIAt/wDHaD8Nr0/8x2D/AMAW/wDjteiUUvbz7h9Xpvoedf8ACtb3/oOwf+ALf/HqP+Fa Xv8A0HYP/AJv/j1ei0U/rFTuL6tT7HnX/CtLz/oOQf8AgC3/AMdo/wCFaXn/AEHIP/AFv/jtei0U fWKncf1en2POv+FaXn/Qcg/8AW/+O0f8K0vP+g5B/wCALf8Ax2vRaKPrFTuH1en2POv+FaXv/Qct /wDwBb/47SH4ZXh5OvW//gC3/wAdr0aij6xU7h9Xp9jzn/hWV5/0HoP/AABP/wAdoPwyuz/zHYPw sT/8dr0ekprE1Fsw+r0+x5x/wrG7/wCg7F/4An/45R/wrG7/AOg7F/4An/45Xo+PajHtT+tVe4vq 1Psecf8ACsbv/oOxf+AJ/wDjlNk+FtzIMNrqDr92zdeox2l969Jx7UY9qX1qr3GsPTWyPMY/hNNF s26+TsJI3W8jdRjnM3NO/wCFU3BUKdeUgADm1c9Dkf8ALX/9fevTMe1GPan9aq/zDdCD3PMz8Kbg kH+3+hBAFtIBwc9PN6c9OnT0FPX4W3SIFXXY8AY5smJ/My16Tj2o/Cj61V/mE6EHujy6b4QPcFzL risHxlTayY4IIwPNwOnb39TUo+FFx5iv/b43KSR/or9+uf3vP49O1emfhRjmn9brbcw/Yw2OH+Fg J8LS9DmZOfX/AEeGuxjto4GneO3jR538yUqoHmNtCgn1O1VH0A9K434YywWfg24uJ5EhhjdXkkdg qqot4iSSegA71pQ+JNSuLLS0j0yCbUdTWe5hhlmMCJbK42s52uQ+ySIEAH5mPQCoqr32Om/dRuDT rJ5jcfY4PNMxmMmwbjIE8vfnH3tny59OOlR6foemaVPPNp+m2lpJPt85oIVQybc43YAzjJ/OuNsv HP8AZWgWZvmtI7+/v9R2LqWoLbxRJFdSAqZSGztBRQFBz9BmtGH4j6WdPiv7kRQWs1lNcRS/aFYS yQyFJYkI4Y527SCdwPA4qLGlzsAuAABwOBWfqWg6VrMkTanpVjfeUGEZuoFkKZxnbuBxnA6elQ6n rUum6DBdSWqDUrny4oLIy/euHxiPdjkA5JOOFUnHFY+peLdW07xHZ6BDo9vfXc1vEzT/AGswR+c6 ztt2lWIXFtIc5J6DHeiwXNhvDOjG2trb+xNNNvbMXgiNum2Ik5JQFSASck4x1zUkvh/SpbX7M2l2 LQeVHD5ZgUqY4zlFxjBCnlQeB261zF/8UNNs9PtL9X0vyZLKK8nhn1SOK5RXQPsSLBLuFIOCVzkY JzWnP4svItavrZdKiNhZahbWMt092VZmnEO0rGEOcGYAgkeoJ5ALILnT4PpRg+lcpbeMLySUzz6P HDpf9qPpn2kXe6QyCcwK3l7B8pYKPvZGehAyax+JGn/8JD/ZwbTzEL/+ziDqKfa/N3+XkW+M7N/G d2cfNjHNFgudDa6BplnYS2FvpVjBZTBhLbxQqI5Mjady4wcgAcjoMdKSfw9pdxqKahNpWny3iFWW 4kt1aRSv3SGIyMcY9KqaNr2qaveSn+xY4tOjvLm0+0/bAzkxSOm/y9o+UlMfeyCehA3Va/tWa58T nS7JYHgtIhJfysSSjOD5cagfxHG456Lt4+YEFguSjQtLWfzhpdl5ona5WTyE3CUgAyZx94gfe61f CkHpxXLWPjq2uYb6Wa18pNMspbnUtsu82zo7qY8YGT+6kOeOAvHzVFceM9R01rgaroUduI9JudVQ w3vm7lh8v92fkGGPmc4yBgYLZOCyC51zBiBtx1Gc+nesy48N6NeWdtZ3Wj2E9taqFt4ZrdHWIAAA KCDjgAcdhXIHxl4qtvPkvNHgh32jXFvC8TLgCWJGcssjOyIspZgYo24HHJxo6J4zSfWZLC71fRdQ tlsZb19QsMxRQiNkDK+53XpJnO/gA5AyDRYLnRDRNPRVRNPtFQCJQohUbVibdEBx0Q8qP4T0xUp0 21YyFrO3JllSaTKA75F27XPHLLsTB/2F9Koar4mt7Xw2us6UIdXiknhghFtcLtlMk6w8OMjgt+Yx xUVzruqWVlbrdaPCup3V2LS2t0vd0Uh2GTcZNgKgKr5+TOV4ByCSwXNCTRrCSORH060ZXSWNlMS4 ZZW3SA8dHPLDoT1zVebwxok+oDUJdD02W+DKwuZLZDJuXG07tucjC49Me1UP+Etn+yeV/Zif2x/a H9m/ZPtP7rzvL87Pm7c7PL+bO3PbGag1HxXqp8N2Oq6Rplm7S3sdncR3l0yeVIblbdlXYjBvmLjd kYwGw33aLBc6i3torWMxwRJEhdn2ooA3MSzHjuSSSepJJqQgk9BUdi95JZxtfwQQXRzvjgmMqLyc YYqpPGP4R6c9aqa9qw0fTfNjRJruaRYLSBn2+dMxwq5547kgHCgntRYLkp021aymszZ2/wBmnEnm w7RsfzCS+RjncWYn1yfWon0TTn1Mam2m2bX6423JiXzRwRw+MjgkfQ4q9biYW0QuWja42DzTGCFL Y5wCSQM9MmsjVvEkOk3zW8otwscKzOZLkI7KxYfIpHzkbTxkdR1qJyjBXkxOSWrKj+C9Jl1j7dca Xp1wiWtvawQS2yFbcRNIcpkHGRIowMY2D8OkAIAGKzL3WfsWpR2Bt900+37N+8wH5+bPHy46989u eKdPe6hHr1vZx21q1tJG8hdp2D4UxgnG3GRvPGefVe6dSC/IXOjRwfSjB9KwtX1e+0pnkbyCg5SM wSBSucDdP9xPfI4roKcZRk2l0BTTdhmD6UYPpWXBqd9cieSLTVMMck0St9o+ZmjZlBxt4BK465BP Qjmlj8QWNy0MdpKk80jRjyw2CA67s++FBP4dqSqQ7h7RGng+lGD6VW1a+/svRr7UPL8z7LbyT7N2 3dtUtjODjOPSsmDVNWt9S0+C/NhNFfSNEPs6uhiYRNLwWJEq4XG4beT+FU2k7G8KUpxcl5/hq/wN /B9KMH0qjrmoyaVpT3UMcckvmRRIsshRN0kioCxAOAC2Tx2qpY6jqKa2mmagbSbzbeWdJYI3iK+W 6IVKMWyDvBDZ5weO9DaTsEaUpQ515/hqzZwfSjB9KfRVWMrjMH0owfSn0UWC5Hg+lGD6VJRRYLke D6UYPpUlFFguR4PpRg+lSUUWC5Hg+lGD6VJRRYLkeD6UYPpUlFFguR4PpRg+lSUUWC5Hg+lGD6VJ RRYLjMH0owfSn0UWC4zB9KMH0p9FFguMwfSjB9KfRRYLjMH0owfSn0UWC4zB9KMH0p9FFguMwfSj B9KfRRYLjMH0owfSn0UWC4zB9KMH0p9FFguMwfSjB9KfRRYLjMH0owfSn0UWC4zB9KMH0p9FFguM wfSjB9KfRRYLla4u7e0XdczxQrnGZHCj9agXVtOf7t/bMfRZVP8AI0wqo1q6k8rzXS2hKDuCWkHG enQU9hJIWjubaIDqNrblP5gc1DdhpHEeBNL/ALX8FJavNst/tkMk6bc+aiwxNs68AkLnrkZHeu41 TRbHWEiF5HIWhYtFJDO8MiEjBw6EMMjqM81wHg28ksvCFjtvPscc18kcs2wNhPsoPcYHKjnt34yK 6qK9vrqw0xYtQw1xfTQm5WNGMkSiYqRxtyQinIGO+McV1VIvmbOOFeK922q9PL/Msr4R0RNLg06K 0eG3t5Hlh8i4kjkiZ2LOVkVg4yWPAOOcdKfN4X0a4s7C0mshJDYXC3VuGkclZQSdxOcsckk7ick8 5qLUZ7mxayguNW+zW7CTzb1o0DFgRsXJGxcgtk4528YzVKLVLxxD/aOqJYWzRFo7gQqhnIkcDJfK rlBG2MZO446YqFBtXKliIxfK1+X+ZtS6Z5+vQalLNuS2gaOGHbwruRucnPJwAo44Bb+9wS6Jp0+s RatJb7r6LZsl3sMbFlVeM44E8o6fxewxbt2320Tl/MLIDv27d3HXHb6Vg+ImOp6rp3htXRYrpHu7 vIyWgieMGMc8b2kUEn+EOOvSDdO6uNl8AeGprQ2jWEotTbpbPAt3MsciKgjXcofDMFAAYgsMDngU +Pwdp/8Ab1/rFw0ss91dx3Sqk0kar5cUaKrKrbZMNGWG4cFvxPL6z4n1C21rxJDB4jEN9Y3EaaZp LW0bC7Y28L7Dkb3BdyPlIK5yTjAHRXDaxfeObizttYezsbOzs7loFt4384vNOHBZhkApFt45BwQR ghgZJpXgrTNOuXu5BJcXRvbi9DGWQRh5JXcHytxTcocLvxn5e3Srr+GdJfU/7QMEom8wTFVuJFia QYw5iDbC3AOSueK5P/hItT/t3yf7bT+0v7X+zf2F9nTH2Tzdvm9PMz5P7zfu2Z421btNauJfEE0G p+Jksb1NQaGDR1t4wJYPMwhwwMjlkwxdWCqTyPlNAHYWdjb6fA0NrH5cbSyTEbicvI7SOefVmY+2 eOKr6Npn9lWJhebz55ZXnnm27fMkdiScZOBzgDJwAB2rQrldC1W6vP7KYaoLySePdeQGJR5I2Ehh twV+baOcg54ArOdRRkovr/X6kuVnY34tMsoXvmS2jBvn8y5BGRK2xU5B4+6qjHTj3Nc14f8AA50j WBqFzdwXG20ktEijimCiN2jbb+9mk+UeXwowBuPFaNrJqv2DU75bw3Mge6W2tnhXahR2VBlcE/d5 yec9scw2+o3rm4Gn6gmqbbJ5fmiUbJxjYvy4wD82VPIx1qfbrS63Fz+RPF4N0SJZFWC5KvH5QVr6 dhGu5WxGC/7vlVI2YxtHpV3TND0/R2le0ik82bAkmnneaVwM4BeQliBk4GcDJqHSbtLiYhdY+2uY 9zxeWq+WcjsBlfoxJ/I1a1m4ltND1C5gbbLFbSSI2AcMFJBwfeqVROPMVzaXJb2xt9QgWG6j8yNZ Y5gNxGHjdZEPHoyqffHPFR6lpdnq9p9mvYjJGGDqVdkZGHRlZSGUj1BBrO1CTUtKtknF412TIFKP EoBYq4VRtHCmQx+49TmrOiXd3fxzXNzhFysaxBcbWUYk56n59w+iikqqcuS2oubWxH/wi+j/ANk/ 2Z9lb7P5vn7vPk83zc58zzd2/f8A7W7PvUz6BpcmhjRjaKNPVVCxIzLjaQwIYHcGDAHdnOec5ql4 uCnTrYXDKun/AGkfbC6koI9jY3gEZTf5e7nGM54p3hbZ9jvPsuf7O+1t9i648rauduf4d+/HbGMc VfN71jp9j+69pf8Ar17+XbU1bGyi0+zjtYXneNM4M87zOcknl3JY9e546dKry6Z5+vQalLNuS2ga OGHbwruRucnPJwAo44Bb+9xleKBam808ao0K6Vsm3m5XMImwvl+YMgFceZ14zjvirfhTZ/YC+Vjy PtNz5GPu+V58nl7f9nbtx7YpKXvcoSoWoqrff/g9fkbVU7rS7S8m86ZHL7Qh2ysoZQSQGAIDDk8H PU1coqnFS0aMLXKk2m2k7yvLFueXZubcc/Kcrg54weeMc0+4sYLmeCaVX82Bt0bJIyEZxkHBGQcD IPBxViilyx7CsihJotjLKzvFIQzb2j85/LY5zkpnaefar9FFCjFbIEkiOC3itozHCu1S7SEZJ+Zm LMefUkmq8GlWNtOk0NuqSJv2sCeN7bm/X8ugwKuUUcsewWQjKrqVYAqRggjgis6x0DTdNnE1tA4d VKJvmeQRqeqoGJCDgcLjpWlRTaTLU5RTSejIrm2hvLaS3uI1lhkUq6MMhgarWGj2WmvJJbRyeZIA rSTTPK5A6Dc5JAGTx0q9RRZXuCnJRcU9GFFFFMkKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDj/ABFf 31nrsgsrnyCbaEt+7Vt3zS+orDuPEOub/l1EY/2oEP8AQVq+Kf8AkPv/ANesP/octc1P94/WvRo0 acoJtHBWqz5nFM3vh19kj8IQ3N48ca286yJJI+1VY26LnOcdGI59a7eG9tblY2guYZVlBMZSQMHA ODjHXB61wPgmwmvvBEAtyomiuElQs5TB8hBwcHB57gj271v3tnqNt4fgPmltWhneSF4It4ZmZjtb agGCpwWwvPPWuSaTk9epoqkoLbS1/wCvM3ZtRsreHzp7y3ii3FN7yqq7gcEZJ6gg8e1UNT8RWVgl uEurJ5rgjyxLdLGu3DHeW5wvykZwecCobvRLhLewGnyATWqsvmNLsZt2CxzsYckZOV/LvNbaXdx2 +lLPPHLLa3DzSuFC7gySDACqATlxzgZwT1qEo7jlOs3ypW21+6/6/caF1qFlZFBd3dvbl/u+bIE3 fTJp6wwGc3Sxx+c6BDKFG5lBJAz3GST+JrI1fS7+4vxdafKkTtCInbzNpwCSMgo4YfMeMD6+mrZw vbWNvBI4keONUZ1QKGIGCQBwPoKTStc1jOTm01oVLmTTfD8V5qMoaIXVwjzMivI0kpCQrhRkkkKi 4Udvqafc65pNlfw2F1qllBezkCK3luEWSQk4AVScnJ9KoTW0+q+KozMkqafpYWSMMuFnuGUjdyOV RTxjjc57pWTqPhnW38WPqGnXFtFZXN1bT3StLneI9gOY2icFtqYDK8eDtPUZMmp1n9oWQhM32u38 pZfIL+YMCTds2Zz97cQuOueOtVzr2jjVBpZ1axGoHpaG4Tzf++M5/SuWGj3E/wASZkjkuxoybdQu IXtisRvAoRNkhUBwVw5Ck4eMZwSRTV8J6/D4gL2t9bwaS+o/bpI96yh8yeYw8p4SVYn+JZRgnIA4 FAHd1SsrnTYwmnWd1bk26CMQpMGZFUYAIznj3q7XPabo2pWd5bB7mNbK23bYgwcHKkDGU3J1/vn0 rObakrIlt3RuJc27hCk8bCRS6YcHcoxkj1HI59xUMWqafOkrxX1tIsILSMkykIB1J54/Gsiw0rzZ dbVjKYXZ7a3SeMqqoyhn28AlS7Nzk8KMGp9J07Ura9868uVaFYjGkW5ZCOQc7vLVgOOmT19qhVJt rQSk30JtN1y21IXcsc1r9nt3K71uAxwCQWYYwoO3IOTkc8Vetry1vUL2lzDOgOC0UgYA/hWe+kyv olxZExmR7iSZTuIAzMZF56g8j159R1do9lqFtJcS39yspkCBFyrFQM9XCITnPQjjHXmiEqiaUgTl omaUs0UEZkmkSNAQNzsAMk4HJ9yBUcF7aXQU291DKGzt8uQNnGM4x6ZH51DqtkdQshbgIQZoXYP0 KrIrMPxANQ6ppkl1GjWUotrgSZMijBKsNrduu3BHuq9quUppuy0G21saIkQyNGHUuoBZQeQDnBI/ A/lVTUNWtNMMS3JmLzE+WkFvJM7Y6naik4GRzjHIqPSbCeyilN1P588j8yHqUUbVzx1wMn3Y1Dq+ nXk95a31g0TTQRywtDLI0ayRybScOoJVgUUggev1pqUnG9tTWgoyklPRf1Yu2Go22pwNNas5VHKM skTRsrDqCrAEHkdR3qG+1qy0+5W2m+0vMyb9lvayzkLnGT5anAznr6Gm6PYXFml3NeSRtdXlwZ5V i+4h2qgVSQCQFReT1OTx0qvf6fqKau2o6d9nlMsEcMsM8zRD5HZkYMqsersCuMEY/Ebla5qoUnUc b6ev62/Q07K8g1C0jurZy8MgO0lSp4OCCCAQQQRg8ip6oaNYPpumJbyyiWYvJLK4GAXkdnbA7DLH Htir9Ur21MqiiptR26BRRRTICiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA CiiigDiPFP8AyH3/AOvWH/0OWuan+8frXS+Kf+Q+/wD16w/+hy1zU/3j9a9bD/w0ebW/iM5LU9Mu 9W8K6OtvFgW0VzcSlmAwiRW+T79hjrzWTL4Yur6a5bSrORorS0tJJguXbdLEh4UZYksWPTj8hXTL 4f8AEOp+EdKbw/byzMEliuQbhVykkMK4IdgCpCn8QDWf/wAIL4/aOVTp84SZEidDdQgMqABAV344 AGK+dxdPmrSfKz7zKcX7LCRh7WKtffzd+/rYwR4V1Q39/YCFTeWSqzwq4LOGKgFe2PnXOcHnp1At ad4ZjfUNfsb6UmXS7GedXt5AUaSPGASR93JwenTrWvpngfx/pN8t9Y6a8E4XYCLiAjb6Fd+Pf8Kr P4M8b6WLm6ltGtxPG0VxO97ABIr/AHlbdIBz/SuVUXp7rPTnmCcX+/itFba9+v8AXmZVt4T1C60l NSRoBC9rcXYQud3lwsFfoMZ+YEc857VJL4K1aLVv7MAge6aWaKNFlH7xo4klOM9AVcYz75xW+nhD 4ixWH9npYOLXyJoNgmg4jlYM6535ySBznI7Vbn8NfEOaCOT+z7kagZ5pZLgXMAwrxxR4Qh+DhGHA HrnJ4v2Kt8LMXmVVS/iwt8vO3/BOR0rSre58LeIdRlhkM9kLcQ/OMKXk2scZ54H61UGgai/h/wDt uO3MlkHZXKHc0YHdgPuj6+npiulh8AeOraxurOHSpFt7vYJo/tMJ3hDuXkvkEH0qrJ8PvGNjGXOm /Z0kKxM7XkKgl22heXGSSwAHfIHeoVJ21izpeOgnKUa8dX1fSy0+8968IFj4L0Pcu0/2fBxnOP3a +lLqWr3EOs2Ol2NuJZ5szTu+NkMC9SeQcsSFXrySeQpFP8OW1xZeGNKtLlDHPDZxRyIWB2sEAIyO Dz6Umm6StjqOoX8s7z3d7ICzO3EcS52Iq5wAMk8dWYk9a9WOyPgqrvUk/NmIni661G98NtaaffWt hqF0f9ImEJS5iNrNIuNrsy5KI3IBwPqKbovxM0XXdUs7C03eZeE+STPbsWGxpMmNJWkUbVP3lHOP WtG08IaPZ3lldwR3geyObaOS+neKI7CnyxNIVHylh04zU2n+F9N0ueOWz+3oIhhIW1G4eFRjAAia QoAOwAwOMYxTIE0bxRBrd41tb2lzHJHGXn81VHkkSNHsbDH5t0cnTIwuc8itTUr+HS9Lu9QuCRBa wvPIQMkKqlj+gqnpFnpsT3Go6csZXUnW4eaOTesuVGGByRgjnjruJ7mtC8tYb6yuLS5jEkE8bRSI c/MrDBHHPQ0AcZqfjmbStYtpdR06+06wFlPI8Vx5BMsnnW0cZDLIQMGVgcso+bnpkWLH4jaXqGna newQyyJpsST3KQzQTlUYtzmKVl4CMxG7OB05GbZ8F6LJcNNLHfzO8Zj3TajcSFAXST5C0h2HdGhB XBG0c1oWWhWdjDPFGbuaOddrreXs1zkc5A812wDnnGM/hQBk+IPGE+n6Lr11pmmTXk2lwsWkBTyV fyTLk5dSyqNm7bz84xnBxaufFE9pBatceHtTS4u7o20FpvtzI5ETSls+bsChUYctnI6cg1Na+GdJ s9An0OG1Y2E8bpNE8rs0gdSrbmJ3ZIOM57U6DQLCzWBibyT7LObqJ7m9lmZHMbRk7nYnGxm4zj5i evNAGJafEa3vRbLFoerefdpDJbQkQbpUljmkRs+bhQVgfhiCOOOc0eIPFV6/hiK70ex1ESTX0do0 sH2cvARdJDIuJH2lid6qcMuRkkDmkvPBukakuiy6cuLOyaOJnt7yVHNvDDcRxojo2chpueQSMgk4 xW+uh6fHpkWni3b7PHcJcBWlZiZFl80OWJLE+YNxyTnp3oAy9X8YJ4YsNN/tCx1GZriI7pZWtk2M qqT5rmRIgxyfunGVbHAFb2kakmr6XBfxxNEkwJVWdH4yQDlGZSD1GD35weKg1PRbTV/KNzJep5Wd ptr6a3zkjr5Tru6cZzjnGMmpdG0qz0XTUsLCJ47eNnYB5GkJLMWYlmJY5LE5JNACX2qNZ3kFsllc 3LzRu48nYAApUEHcw5O8fkarv4itIbk21wHgn8rzljfBLKFLEjBI4ww6/wAJq7NZwyX8d4Q3nxxP Ep3EAKxUnI6E5RcHtz6mqt3otje3fnzwF5NqrnzCDgEkAYPuc+o45rKXP9kTv0L8MzSwRyNGUZlD FCQSpI6VQutcS1llU2s7rE5RnTZgkR+YcZYHp7VYe0Zr2GfzWEcSbUjBIG48En14xxUF1YWkiHzk O2VvmHmFSSU8v17g4+pqKntWvd01LVuoo1fL4NrMI/O8nzTs2k7tucbs43cdP0qK41aUp+5t5VAu Y4vMOzBHmhW43Zx1Gce9WTplqJA+1xht+0TOE3bt2ducZzzTW0u1dw+2TiUS7RO4Xfu3Z2g4PPNZ 8uIaV3/X3DvEgtfENrdzpFGM787CHQ54J6BiRwO4HWrS385ZQdOuUB7s0eB9cP8Ayoh0+3hcNGJf lHygzMVXjHAJwOKI9L0+FlaOxtUZTkFYlBFVGNZK0mDcexzum+ItZu7fTZ54rWNNUi/cYgYfZ5DE ZVD5f5xgEEjHIx3yGvq3isX95a2yWF6ba2d2ZLUxL5xXMcWTOeTwTwAARyM1q2HhrS9Oe3e3S5zb JshWW8lkSMbdvyqzEDjjOM4J9TVm20q0tbOW0txKElZmkfzmMjFvvNvzuz2BzkYGMYFbqMramzqw TbUfwOdi8Q+JzbXcD2Mf9rAxtb2z2qx749yiRwRcsr4DdNykcZ61qaDq+p3F09prMawXTR+ZFD9n EZKgkMdwlkVsZXoeMjPXiSPwtYRvK4k1FpJBtMj6jOzKMqcKS+UyVXOMZxzViw0K0sLsXEbXUkwQ oHuLuWYhSQSBvY4yQOnoKEpXCVSm4tJfh/Wgut6lcWCWcVpEj3N5ceRG0n3EOxnLNyCRhDwOScDj ORDo2q3lzd3NlfpH58KRzCSKMoro+7HyliQcowIz6etXtR0+31KBYrhXIRw6NHI0bKw7hlII7jr0 JHeotM0i00xpWt1n8ybb5jz3DzMccAbnYnA54HHJ9ap3uZKUfZ2tqVtf1a70+2tY7KNGu7u4WGMy IWRBguxIBBPyI2ADycVPoeo3F/DdR3caJdWk/kTeXnYx2K4K5J4Iccdjkc9al1PTLfU7VYbkSkK4 dGimeJ1YdwykEdx15BI707TNNttLtmhtlkAdy7tLK0jsxAGSzEknAA5PQCizvcfND2fLbUu0UUUz IKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigA ooooAKKKKACiiigAooooA4jxT/yH3/69Yf8A0OWuan+8frXS+Kf+Q+//AF6w/wDoctc1P94/WvWw /wDDR5tb+IzT8MwXFx8L7gW91PbSLEWRrdwrP/o68bsZXnupB4GCK1NR1C/hsoW0q/8AtKJYXVwZ iynzJI2TapITGOWBxg+oNO+GqufBlv0Byvv/AMs0rpbCf7fbNKYhGVmlhwTnOyRkz077c49681uz 1OhQckrOza/yOUl1K+h1k2N5qv2WyVpk+1Eou75IGT7ybRzJIPwHU9LEyahqMmiXBu5ot106/IqA FVjmxKAyMcsNvBOMHjmunksIJLyK8MS/aI0aNHOchWKlh+OxfyFTeUOOBnOc0nJFRotPVnM69e39 pdKkN7bW0flhgHmCNI3Ixlo3DdBwCD156Vv6bJJLYQySgiRkUtnrnAz+uafNJFFJAkjhWmk2RjBO 5tpbHtwpPPpU6jaMZzSb0LhBqTdzm9eeXU9Vt9AtpXiV0FzfSxTNE8cIYbUUrggyMCuQR8qvznFc 34p1OWTX/sN1q32QxappgtNN+QfbUM8LNLll3kBi4whAHl5OQSK7+PT7WC8uLuG3hjuLkqZpUQBp NowpYjlsAYGeg4pl/cwWECT3EgjjaWKAEhmBd5FRBgerMBnHfJIAqTU8/XxF4hPjJraXUdLgiS+N uNLluD5z2+7aHEQhLlmXDhvM2DOD3xrf21q//CXnwyZj5/n/AG4XAVR/oXXbjbjdvzH67fmzmuk1 i/8A7H0+KcQiUNd21sBu2486ZIt3Q9PMzjvjHFaAiAbIA/L8aAObsXl1nxHNerM66fprPbQrHMwW ebAErsowCE+4Ac4bfwCBXM+G/EWtXPibT7W71izvxcb/ALRb2k6uLdhGW+aPyEeJc4GXdz0GOSR6 FZada6baR2llbw29tGMJFCgRF74Cjgc8/nSTXVvBd21rJIFnuS3kptJJ2jLHjoOnJ4yQOpFAHlul 6preg+BLIJqfmCTwjNf2y+Ug+zSQQwhMcfMP3mTuzyvpwNvTr/WrfxfHbXOtSX0C6u2mlJIo1yps ftO75VGGDDb6bcggnmu/EYz91cf59qgsbu3v4WntpA8aTSwkhSPnjdo3HIHRlI/DjIoAlu4nmtmj jnkgYkYkj27hyP7wI56dO/brXI2F7c/8IzamHVDPqObSO4RpEcwF5FDjhM9CwBYdu3Jrs2BIwMfj TPL4AwDjmsqkOZ3FY4SfVdUtL/Skl1N0tri5uY7iUog2JEWVSTt/i+UnPH1HBvai13qPg/WFjunk jihlSCeJlX7SnldyFIAySMqB93Ix0O8yQXeri3ltlL2Kx3UMhY5VnEqdPoGHvuq/5Q2kYXBGMdvp URpvXW6FyvdMxNVN3YaTGEvUD7yr3FwyoduCeoQqpzgZK4x6mruh3NxdabFLc8yEHLZ68npwOMY5 q+UyMdKZNNFaoJJn2qzogOM/MzBVHHuQKtRs+ZjtYztbe887TYbSbyVnuSkzgAlU8qRuAQRnKjrx 9ehz7jUL3SLjyZlN7GT5vmE7THFkhzhV+Yj5TjvuOOmK6Vl3FTgHBzz2pDGCeQv4iicHLZ2YNXKF teNb2Fq9+22e4cKAAWwzZIXgdhxn2qrfTXba7HbxXDRRMqA7VB5IlOckf7ArWktopZI5JIo2eM5R mXJU9Mj04p+zJzgelTKlKWl9LoqLsc2mpXDW4ma5CT+VG8MBAHnllBPUZ+8ccYxjmnalNO96sD3A RVu4AkOM+apYEknGeCD0P8Iz1rofL5B4yP1pGiBYHAz61m8PNpJy/rUrmRgi61AalseeFU83b5TS /MUBIzt2Z5HPXFWnm1b7SFW3/c+Zjd5S/dz1z5vp3xn27VrbAGBAAqK6nNtCr7N2ZEj64+8wXP60 Ki4JuU3YTd9kcnpOp6cPGeqWMOprI0sURWBr8y4mDT+aqqzHaQAuVAGMDgUlrpEd14kV7eXUEsrF sSO+qXLmabjC7S2Ngzyf4jxjGc9h5RyenPt0pBDjPT1zXVyov2zTbS6dzjtF0iO7v7i7WW/j05Ua CBX1W5dpjyHkbc3y9wuP97g4xNoGmCXWn1KKS9SxiJjtkl1G4l85uQzurtgDjCrz3PXGNqw1rTb+ VYLac7ihdC8ToJEGMshYAOOnK5HNMh1/SZWwlwwQIzCZoJFicKMkrIV2twCeCelSuXuav22q5Ht5 h4nNwNAuDbtIpDRmRomZXWLevmEFeQQm4jHNY/h54ZNeH9l3ktzZrbuLktfy3SK+8eXhnJw23fkD kcZzxW3H4g0u5inb7T5SwJ5r/aIniOwfxAOoyvbIyKk03UrDUJHjtmYSxKC0csDxOAeh2uAcHB56 UOze5KjOFNpwf9d/0KHisuLOz3yyxWX2ofa5IZniZY9rYO5MMBv2A4I4J7VX8KOst7evaXMtxp/l whXa7e5TzsN5gR3JJXGzpxnPGc10zxlxg7cfSk2GNWaNFZ+wzjP402tbmaqJU+WxLRSAnHI/WobW 4+0wtJs24kdMZz91iuf0p8yvYzsT0VQ1DWbPTJoYbj7Q0sys6JBayzMVUqGOEU4A3L19auQyrPDH KgcK6hgHQowBGeVIBB9iMii6vYpwkkpNaMfRVG/1iy02SOO5kk8yQFljhheVyB1O1ASAMjnpVm2u Ybu2juLeRZYZFDI6nIYHvRdXsDhJRUmtGS0Vm32v6bp05guZ3Dqod9kLyCNT0ZyoIQcHlsdK0VYM oZSCpGQQeCKLpg4Sik2tGLRRRTJCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAC iiigAooooAKKKKACiiigAooooAKKKKAOI8U/8h9/+vWH/wBDlrmp/vH610vin/kPv/16w/8Aoctc 1P8AeP1r1sP/AA0ebW/iM2/B2ntqHgfTVWG3uFilWR4Lg4SQeTtweD3YHoelac/he7lsLKER2YEM ly7W4ZfLUSSb1274nHyjj7o68HsW/DuSOHwPbyyuqRogZnY4CgIuST2FWLPxc0ml2M7WM15dahJc SWdvZKoaS2WQ7Jf3jhQPLMRJLDlxgc4rzpzam/U6Pq8Jxu+q/wAv8ixHolzbaXYi2WBb+zkkaMyP uXDlty7lRcDBBwFA+UDtmqC6HHHqxs49L069SCwt1Juzt2kvMSw+RsljknpzVK3+Itjpvhy2v9Zm f7Re397FbQyNFA5jiuJFAJkZEXagQHJznHUmtez8eaFe2aXiXBS1exe+WZyoVkRisgBzyyEAHt8w wTU87G8LB28v8rf5fcPu/Dvm2WkbrOwvbqzCJKbngSqI2XG7axxuYNgjtVfWfDk99Pa3FtYacssV ssWJZA0a4OdgQwtlRzggqee1aWpa/Fp/hxdUaFklmjT7PazELJJM4GyLrjcWIHBPevn74peF21nx k/8ApNlFrd1etbneZFW6dLOyKxxjDBTukfG4jO7BY8UKbCWFpyTXc+ma527s5tb8VW6XNmv9l6UR cI0oP767I+QqCMFY1JO7P3mGMFK5C18YPpXwjhXTbS9lurDw9Cz3cEaNHazG1Vo9wZsk8oxwrAAg nArrtZ8a6Voeu2Oj3O9rq7eJFCSRDaZH2L8rOGbnrsVsDk4FQdJz9z4HvJdQjk/sfQZZV1hb/wDt aSVvtaxi787YB5J5CfIPnxiqy/D7VR4tOpSfZZYTqZuxOLiJJhH53mhP+PRpMAYXb52CBjKg4HYN f6lD41g02WW0fT7qynuIlWBlljaJoFwz7yGB81jwq4wOtblAHIaH4Rn0zX1mmFmdMsPtH9lxx53x +fJvfI2gLtA2Lgn5SelXdAs5rvU73xFqFmsF1cj7PaI4PmRWinKhsgFWdsuV7fKDkrVt9XaXxPHp FmYXEMJnvieTEDxGvB4ZjuPPZD6g1i+DvGD6ro2gLqVpexXWoWcbJdzxosd1MIg0m0K2QeHYZVQQ CRkUAYvw58L/APEj0W9n0jSLWxn0MQTR253m+81YW3zKY1GcIwIJb755rQ0fwQumWutWP/CN6AsN 2l6kdzbzGKaaOaVmSF9sIKIFYLkM2NgwDxjYsvG2lXiTysLi2to7V72K4uEAS4t0OGlTBJ2jI6gH DKcYINS2Pihb2WS3OkalbXf2ZrqC2uFjV7mMYBKYcqDllGHKkbhnFAHP+CfBd74Z12edrDSLexe2 aNTAY3n3blIG9baI7MA5DFuQtdjq1m99pz28YjZi6NskOFcK4YqeDwQCOh61keFPEWoa9FM15ol3 ZBLi5jE7tD5Z8ud4wmFlZt4C8nG3Ktg4xnbv7630yxlvLqQRwxDLMfrgD8SQKmduV82wntqc1ceF 7i4aVo7PTrONjCfs8DAo+zzck7oiv/LRT90/d7cGrlr4flg0d4NkK3KXK3MHzKUR1C4xtjQKDgg4 X+I9c1YtfFGn3dvNNGWKwMonCsj+UrdHJViNvBzgnGDnpTr7W2j0C51KytZZgiSNGTtCkKCQ5ywJ TjtyR0FcihRS5k+jM7Q3M++0sxW2mQSWlndXFxqDzTxynEcjtFKTk7TkAYA4/hFTT+HjNoMNs9pY y3MM/mxpJ/q0UzBzGG2kgbRt6c+laUt3dvYPMkK2DITua9KkIgGS3yMQR9WHf8W6LqY1S2mkWWCY RTGLzoD8kmADkdcdcdTyKtU6d+V9V/X5DtHbuZuo6Ab2yso10ywjeDfiNJgI4txH3QYWBzjJyowf WtbR7Wey0qC3uEt0lTdkW4AT7xIxhVGcYzwOc8U6/wBQTTxBuhmmaeXyo0iAJLbWbuRxhTzUUGtW kjtHOTZzCRYxFclUZmbO0Dk5yQwGOu04zVRjTjUvfXYPdi73EvtJh1DU7We6ggnghhlQpKgb5mMZ BAIx0VvzrNvtAvf7SeXS5ILW0e3WJ4VJQOcMmSAuPlTZt/3ccAVu2d3HfWqXMOfKfOwnHzDOARjs eo9jVa+1i006dYp2wSoYncowCcZwSCeh6A0qqoqPPN2T6lKmp7EqE209vY21oFtki5cfKsYHCqox z9OMAVm6loAvmuX8u2aSSRmV3XJC+RsAzj+9g/r1rSkvwk7xRwTTGPHmGMDCZGeckZOOcDJppaVN ZjTz3aKWGR/LIXClSgGDjP8AEepNTVhTqR5Z6q/3dP63Notx20KZ0qUzq32e0LC4837SWPmhfM3b QNvp8vWmyaTK0yn7LZswuRN9pZj5gXzN+ANvpx1rbqr9ui+z+ftfb53kYwM7vM8v8s/pRLDUlv8A 0v667+Y1UkZem6JPZ3cMj+WRHnc6uoLnaRkgRAnr3b86sQ6N5U8cnlaWNjBspYbW4PY7+D71Laa1 a3twsMIYlhlTuQ5GM9AxYfiBSWuu2N5di3hkBZs7DuU7sdeAcj8QKxpwwiSSd9dNeun/AABt1Hdn NL4W1e70Ox0m9SxgjtLV4RPFdSSs7G2aAYVo1CLhtxAJ5H41bs9Cv7O+trq10jSrB4d5kNveOxug Y2AWQ+UM/PsO47iMdK6Cy1AXyJIlvPHHIm9HkUAMOPQn179e2atsSqkhSxAzgdTXVBQkuaLN54yq 7xa/Prv1/wCG6WOPk0LXdQkvbjUbfTDcu8T2zJdSOsaxyRyLFtMYwrFMswySccYAA07Wz1H+2Bql /bW0It7WWJEtrl7h33urnJZFxjYMAZ69q0YNUt7i3nnTeI4OHLDGDjJH1GefemWurw3sUzW0byyR Y3RI6E89OQ23179qlVKWlpavbzsTKvUatZL79Lq3fsQ3wkudMt57q3gTY4klgmfKYwRgnaemQemM j8apx2JvtKv4oLSyKzTExfN+7T92q70O3kgg9h35q0NXuv7BN99hkEggEmcpsJ2k7sb87f156Vdk v/Is2uJ7WeMB1TYdrMckAEbSR1Prmudxp1HzSbta7uvK172/AyvKOiIb21nvba38y3tndJd7wPIT GwwR12+4PTqPxqvHo7/YIYHi08GN5G2SW/nKoZywC8rjA46VqQTGZCzQywkHBWQDP6Eg/nWdq+o3 Nvd2tlZvbRSzRyzPPcqWSKOPbuOAVycuvcdz2rodCnL35a3Vvy/yCHNJ8kSnqGgia1jhOh6HqGC5 xOnkKmdv3Rsk5OOTx0X8NLRLS6stJht7x1eZC/3ZC4VSxKqGYAttUhckZOKTR76e8S6hu1iF1Zzm CUxZ2MdquGAPIyrrxk4OeTVbUNQvm1Y6fYS2cBihSaWa6RnHzsyooUMvJKNzn04Oa0jGMF7po/aS XsXstb6/116LUbfWGox65JqNhb2lwJreKF1nungZPLd2GCqNkHecjjoOtW9CsJdN0pLefyhKZZZn WIkorSSM5CkgZA3Y6DpT9Hv21LTI7iSNY5Q7xSopyA6OUbB7jcpxV6rSXxIipUnb2clt+mhz02n6 ta6lqM1jaWFxFeSLNm4u3iKsIlj2lVjYMuFzyep6d61dJsf7M0axsN+/7Lbxw7vXaoGf0q5RQopO 5M60pxUX5fhogoooqjIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooAKKKKACiiigAooooA4jxT/AMh9/wDr1h/9Dlrmp/vH610vin/kPv8A9esP/octc1P94/Wv Ww/8NHm1v4jN7wppcms/DmzsBcLDBMYxcgx7jLDtXfGORt3D5SeeCeO46rVdETU5baeO8urG7tty xXNqU3hWxuXDqykHavBHVQRjFc54N1K30f4bwX9zvMUUa/LGpZnYhQqqByWJIAHckVFe3+oaLZ6J Z6trkmlLeC4uL3UmCOIpSwdbcPIrIq/vHC7h92IAc15lT42d9P4Uatj4V09NLtodM1a9SS0nufLv 4Zo5JQ0kzNMjFlZW+fghlJBQZ5Gan1DwhZarZ6bb3t3ezGxuRcCZpQXmOSSjnGChzyoAHAAwBXBQ eKL3SfCmklbi8W0vL/VHudStYoIyrC7kKgm5Ijj37mPzc/LgDqRpDxxq9hodhqd7HNJ/aNrPb2ka wBt94kpWDJj3DMqnPDFfl44qCzubnS3u9esr+a4U21mjmK28vnzmG3zC2eyFlAx/ExyeMeM/EDwj 4+v/AIjrq2h6FBdWNjqEeoWkr3Ea+ZJ5NurBgZAdoNuBjAPXnkY9X1i7vbXTbDRoLt31m+VYRcrG MqF2+dOQBtG0HIyMbmUd65/WLrW4vHenaBp+u3FpYtb28Lfuo5pCzR3jmTfIpJb/AEVBzkHcTjPN AEunfD5bnwZZ6bfX2o6e9xpcFrqVrayx7ZHWFYySSrcgKBlSAQozkVs3vg61vdWkvhqF/As1zb3c 9tEY/LmkgKFCxZCwH7tAQrAHHrzXB6v8Srq20Gxvo7u8XUF0mC9ktYYrYRyyNEJGLCRhK0eDyYh8 uG5JBA2r3xNdw+MdSs28QGJ4NWsrW10sRRDzopVt/MO5lLPjzHb5SCuOeCKAOpufDslz4lg1sa3q UTwI0aWyLB5QjYxl05iL4YxKSd2RzgityvNbDxVevqZH/CQm6vv7cmsv7GW2TP2YXTR7+F3/ACJ8 2/O3CYPzZNQnxtq3/CZGxYXscw1UWi2Ei2qRPbeZs80Bn+0N8v7zeBt7YxzQB32i6W+mW9wbi4W5 vLqd7i4nWPyw7HgALk4CqFUcnhRWbongy10T+zkXUtRvINNi8uzhupEZYfl2FhtQEnaSOSQAxAAF Q+Gf7a1CWfUrrW5Ht01G9gWy+zxhPKjnljQbgN24bV5zggYIJ+arVpcTaz4mmnhuJ00zTS0AVcqt xcciTPHzKgwo7bi3dRgAbZeC9Ls0nid7m6t5LV7KO3uJAUt7dzlokwAdpwOpJwoGcACrGleHI9Mv ftkuo3+oXCw/Z4nvHQmKPIJVdqrnJVclssdoya53Tdf8QtDrpeGa5n0OzliMRttv226DOyEYUZzG sTYXj997Cs1PEupNc3UOjeJTr0v9g3t2saWseUu0MIRQEQH+Mjyzlhn5s5FAHcaZoQ0m9uZYNRvG tZ5JZvsUnlmKOSR97sp2b+WLHBYj5jx0xoXVtHd27Qy52tg5U4IIOQQfUEA/hXkCaheR/amt/GIv Lh9Paa4eG5kH2bE8AZZA7MkTsrOqsIo9vzEgAcb3hLXJrvX5zpFvq9xo8dhK8iXF+t4JLkMmwRzG R0BKlxjzcdCQvBKaurMDsprCAIltfalPL9plVVSaRF80qC/lgAAHhWJAGSFOeAasJpdumnT6f85t pQ67Cfuq2cqvoOTj0rnPELXupSeEyiXGkXUuquMTLFJJEBaXWfus6ZIBxyQMjI6iqF3rup6ba3dl davIkVtrSWM2rvbpugga2ScO4C+Wp3OI9xXaNwJFT7OPYVkdj/Z8ptPJbU70uG3LNlA68Yxwu0j6 g/yqWzskso5ArySPI/mSSSHLO2AMnGB0AHAHSvM9c8Wa3D4QnudM1l38m+uorfUxbRn7ZDHYTXAY ArsI8xNhZQAdhx1p+seK9Z0S6m026v7+S1gv5IZdUhitY3QC3t5URml2wpkzPgkZITABOTTUEncL I9LntUuJraVywa3kMqY6ElGTn2w5/SquoaLa6lL5sxkVxEYwUbGM9GHH3l5wfc1U8H6nd6x4Ws76 9UrPIZFJIUF1WRlVztJX5lAb5SRzwcUviO/njit9L0+V49S1F/LhdE3GGMEeZL0IG1TxngsVHeiU IyVmgaTLcsKS3NtZ296sP2TZLJbxn5ynIQHB4UlW6g52n0NOvNLjvHmZp54xNEIZFjKgMo3Y6jP8 R71y7aVfTeN9QtrDWrqwEOjWCmVUSaSQiS6C7jIGyODnjJz1HfEu/GuoNYWd9/av2W9k0Ky1C102 OJHGoTy+YXiVSpkP3UHyEbd4JqJUYSvdb/8ADFqTWx6PLYh52ljuJoS+PMEZGHxxzkHBxxkYNPmt RNPDMJHjkizgpj5lOMqcg8HA9+K4a+vdeufFk1pba9PaWsmsDTkjjt4W8tP7PFzuBZCS28Ec5GGP HTGJYeP9dvNY0GOVLmI3SWBEIigWG7SaJGmkBdhK2wu3+rBA8v5upxXs466bi5meopazDU5Lp7lj EYxGkABCrzkseeT74HFRNpUbP/x8TiPzhMIgRtDht2emeT2z3q/XJ/29eHWzb4uFcXnkC3ZYlQxb tu8AnzDx82QMfhzWNVUoJcy3f5/1sJ1HE6CPTws8cr3E83lEmNZCCFJGOoGTwT1Jp0FiLd12XE/l J9yEkbV/TJHsSax9K1a4u9Ya1kuGNvHv8mUwFRd884YqB8vT5fvdRwKXTXaHXby1udbuJJVmHlW0 5iHmp5KHIAQHAO77uB8vPfMxdLRxXX+uvl+HoL2tzZSFrSwjgtlEhiRUQSvtyBgckA9vamI1+7bZ YIIkIILxzlmXjsCgFc5pF3v1izjtL57i2ZXLst29y0g2/KZVZR5J78d+K66rpNVFeLslp0t+QRnz a2KCaRbR201ujSBJWVzyMhlx83Tr8oJznpUttZC3nkmM8s0kiqrNIR0UnGAAAPvGsW0vL+28O2mr 3l+06MkM86iAfKhHz42jOACG9flPY4FnRdYm1md5Dbz2qQx7ZYJoypEhOQMkDooB4/viog6PNGys +n4/Lq/xD2rej6l+LTkjs5LRppZLd4/LCPt+RcYwCAD09c9Kd9i3W4hmuJpsSJIGfbkbWDAcAcZH 1561meKLh7e3sN11c2tm92EvJrcHKReW55YAlFLhAWGMZ6iq/hi5E2oX8drez3empFAYneVpo1lP meYsczDMgACdzjPbpWnJBPlt5f15HV7GTpOrf+r237/odLVHUdLTUGgkFxPa3EBJingK7lyMEYYE EHjgg9B6VleMrk21hYGS7ntLN71EupopGiwm1ioaRQTGjSCNSwxgN15qbwvcPPb3+26ubqzS7K2c 1wDl4vLQ8MQC6hy4DHOcdTWjkm+UI0pRp+2T/rb+l2NLTtOi023aKN5JGdzJJLK2Xkc9WJGB6DgA AAAVBf6Ot5dJdRXl1ZXKp5ZltiuXTOdpDKwPOcHGRk4PNaVFVZWsYqpJS5r6lexsodOsorS3BEUY wNxySepJPckkkn3qxRRTJbbd2FFFFAgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACii igAooooAKKKKACiiigAooooAKKKKACiiigAooooA4jxT/wAh9/8Ar1h/9Dlrmp/vH610vin/AJD7 /wDXrD/6HLXNT/eP1r1sP/DR5tb+IzqvAljb3vgnSDcR+Z5DJNGCxADhRgkDrjOee+D1ArqrO+t9 Qgaa1k8yNZZISdpGHjdo3HPoysPfHHFcV4aur62+GdgumQSS39wiwQMqblidl/1j54Cr94564wMk gVZ1bwwLe30a3XTJNd0yzWYXFlI0W6eV9pE7ByqMwPmEgkcyEgcCvMqfGz0IfCjqNM1KHVbV7iBZ FRLie3IcAHdFK0THgnjchI9sdOlXK8sk8F6rN4W0m0ubO7EFtd30s+m2sttMzeZO7RMftAaOQKpP DYPz56jFXZPDOvWWj6Uukfa1upYm028NzcRPLDbM7MspYAKWjBICqP48fNjNQUd1NBZW1zLq84VJ I7co8zscJECWPHQepPfAz0FWLeeO6toriIsY5UDoWUqcEZGQcEfQ81zuqaa92dO8MWsE8Okxxq13 IqjY0CDatuCepYgbsdEB5G4VkeIPBp1z4iWepXWmR3WnLDBBK0jKQYwl6XUqTkje9senXB/hOADv ap2Wmw2N1qNxE0he/uBcShiMBhFHFheOm2NTznkn6DyfU/CXiy/0a3WaxvH1W00q3isZoJbTbFMk Klt7ybpFfzd3MeARtyw6jYfSJL/xxrs0OiGeePW7J01LdEfsypDavIuHYMu5MjKAk5wcYFAHoGma bDpVq9vA0jI9xPcEuQTullaVhwBxucge2OvWrleXaFos11fPc2mhmG6XxDdzHWvNj/1C3km+LGd/ zAMm3bt+bdnNWF8H6injc6nOuqzznUftCXsUtmsKwbuIizJ54UJ8pQEq2M5GeAD0ms+3/s7RhZaT D+6Mu8QRfM5bHzMSeT3yWY8kjnJGcXwz4Ss9Pln1K60+NNVbUb2dbjdl/LknlKDIP3SjKdvTJyRu FWtCt7m+1O61++jnhaUeRZW06hWgtxjJI6hpGG4gnIAQYBBoA6CsfTtAj06+a/m1G+vpliMMT3jq fJjJBKrtUZyVXJbLHaOawdO8JalZx63HFdtA6W0lho0pYHyInHmBhgZGHZU57Qqe/PK6FZ2PiLV7 q20PSk0lD4fu7K5limR9txK0QUtsJw3yMcvhzt+YDAoA9Cj8aaBKJWW9cRRQtP57W8qxOgKqSkhX a/LKPlJzkVc0zXtP1eSSO1edZYwGaK4tpIH2no22RVJHHUDFcSugarKvl/2drsUMNurSxzapFKJr hJ4JI2hDOyJt8t+CkanIBA7amiaNrtxrM2pajf6tBGtlJaWy3htGnRpGRmkAhTyxjy1xuL55yAOo B2lFcv4h0W9uNDsLZjPrcdvdiW8gnMSPexYf5DgJGcMyNggA7MHqTXK6jos9vY6JbT6GWtZ/ELzW +i+bH+6g+xzZiznZyVd9m7b823OKAPSr++t9M065v7yTy7W1ieaZ9pO1FBLHA5OAD0qxXAXHhGTU Ph9r+mTaNAhuPtEuladN5b/YmMO1ApyURt+5htOF34BwK6/RIYLfR4IrbSP7IhXdtsdkS+V8xzxE zJyfm4J6885oA0Kz7H+ztRlXWrT968kRgSb5gCgY52g8YJGcgfMAOSAKqeJDf3NvBpWnfaYpb59k t5CoxbQjBdsngMR8q8E5OcYU4wfEPhvdfxBfDo1nTY9PW1s7VZY0FnIpb5xvYYypQblyy+XwOaAO 5qu99bx6jDYNJi6mikmjTafmRCgY56cGRPz9jXmt3os8viV7XUdDPiO7t/D1jDJL5sa7Z99yPN+c rjJBO9csvYcmtTVPCxa78PX2qeHoPE01ppj2V6THA0jyExFZP3xUEApL3yPMOByaAO+oorm7zRrm XxNHfsbqRVljaFo3iCQqBhlO5S/PzZ2nndg4xmonJxSsrkybWx0lRrcRNcyWwbMsaLIy4PCsWAOf qrflWH/Zl1/bv2vyf9C+0bvs24fe248/rjOf4f8AgXWnPpFvB4ja8GiwzpMseJkjizFKHcs53EHJ 3KcjJ+X6VHtJ/wAvX+uguZ9i/FrNjNKkaSv852o7QuqOewDkbT+Bq/XO3NtqeoX1uWS8gjjuI5Xj aSEwYUgnGB5jdMjOOcHtiuip05Sle/5WHFt7hRXPWHhyGHw7DB5K29+bVEeVSCwkAUgk8g4ZRjrj HHFSaba6tLfpcao2UjDTRINn7tnGNnA52AEZ77+pxSVSWl47i5npobFzcw2dtJcXEqxQxqWd2OAo FVrDWLLUnkjtpJPMjAZo5oXicA9DtcAkHB56UzXbKa/0iSG3CmZZI5UVzgOUkV9pPYHbj8ap2EV9 d64uo3VnLZxw28kKpO8bPIXdWP8AqyRtUIAOcnJz722+ax1wpwdJyb19fu03d/wNW9vrbTrY3F1L 5cYIXOCSSTgAAckk9hzTLDU7TU43e1kY+W2yRJI2jdDjOGVgGHBB5FVdctbmZbG5tYvPks7kT+Ru C+YNjIQCeMgPkZxyo5FRaNb3jahe6jdwSW5nihhSKVkaQiPed77MqCS54B6KPpRd81gVOHsnK+vr 57W321ubVFFFWc4UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRR RQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcR4p/wCQ+/8A16w/+hy1zU/3j9a6XxT/AMh9 /wDr1h/9Dlrmp/vH6162H/ho82t/EZ2nw8wPA2mk/wDPIfyFSReLkl06xuI9Mu7ie/aZrW1tijPJ AjkCbLlVClTG3J48wDk1keG9OuNW+GulWEMvlQzhFunDsj+T1dVI5ywG3qMBic5Aro9S8PQX8tlP Bd3WnXNkjxQT2bKCsbbdyFWVkKnYnVTjaMYrzKnxs9CHwox9G8XyTaJbzy2t7fX13e3y29pDEiS+ VFcSINwYqqhV2KSSDkjqTWjB4w0ueN5G8+FEs5LxmlQLtWNykqnnO5GGGHTkcms28+GmhX+mWVnc tcTPZS3E0FzP5c7gzyGSTKyIyNknqykjA5zkmWf4d6HPo+m6Xm6ht7BnKi3kEXmpI26SNwoA2OcE qAOgxioKNi81uKz8Prq0ltON8aMlsQBKzvgJHjONxZgvXGT1rK1Dxsml6va6PPo2oz6lPbxzeXZi N0DuJD5YdmXJxBKckAEL68Vp3mlS3+v2V1cOpsbJGkihDnLzngMw6EKucdeXJwCoNNuPDdnc+I4N ceScXUPl7UDDYdiXCDIxnpdSZ57L6HIBWufF9rBpltqiWGoT6bNapePeRRr5cELDIZtzAnA5IUMQ OSKSXxfbxazc6cNO1B1tbuG0nugsYhjklEZTkuGOfNUcAkHqMYJw7/4R+HtSs4rW5nvXhis47Nd4 hdlWOMIrK7RlkOADhCqk5JXk5vxeEpbvxFrN7eXl7Bazapb3cVtHJGYpxDDblGYFSykSRt0Kk7Rn IxQBatvGlpcXZj/s7UYrUXz6f9tkjQQ+eshj28OWwWGA23GSASDwJj4stBqHkfY702n2r7GdQCL5 An3bdn3t/wB/5M7du7jNZmjeDpNskmp3uoCP+1rm/XT/ADk8gt9qeSF+Bu6bH27tueSuc0v/AArP w6viI60kJWc3f21k8qJsz7t+7zGQyj5udocL7Y4oA09M8UR6rfyW8GlamsCXM9qbx4kEPmRMysOG LYJQ4bbjoMg8Vck1UjxBDpMFs0reSZ7mXeAsCHITPclmUgD0VjngAzaZpsOlWr28DSMj3E9wS5BO 6WVpWHAHG5yB7Y69aq6FpUunQ3E946yajeTNNcyK5ZQSflRSf4VXCjgdCcZJoArWnjDTLuNpMTQx xWb3lw0qgC3VHZGV8E4bcknAyPkbnpmqfHNpC04vdK1Sx8rT59SzcRJ88EWzcRtc/N84+U4IxyBx m7D4R0eFdbTyZJI9a3C7jeViCrAhkXn5VJeRuO8jH0xz2k+Gb+/1eSTXI9TeyGmT6c8eoXcUpkWV o8hDDg7QIyN74dtwz0oAbH8SpSk80uhSxwLCJYN0rK8hMsca5LxrHtzKCXSR1ABPpnf03xDdTa8N E1Sxt7a+e1a7j+y3guEMasqnJKoynLrj5cHnB4qE+DY5HZrjW9WuCLZ7WEyvETDGzIzAERgvkxID v3ZAIOcnKaJ4B0LRDcMluLl7iJ4JfOijVGjfG5fKjRY8NtGflycDJOKAL/ijXJfDnh681aLTZ9Q+ zRPK0UMiJtVUZizFyMLxg7Qzc8KarXXimSytLWW58P6tHcXV0bWC0Bt3lciJ5d3yylQuEYctnI6Y 5rQk0HTG8P3GhRWcNtps8MkDW9sgiUI4IbaFwBncTx3NV4PD5X+z2vNVv7+WwumuYZLjyg2TC8W0 7EUFcSMfXPUkcUAY8XxG0+4jtTDpWrPJeND9lhEUe+ZJY5ZI3Hz4CkQyD5iCCOQBzXS6XqVvq+nR XttvEcm4bZF2sjKSrKw7EMCD7iuSvvAaxXHh1dMu7+JbL7PbSXEcqB4obe3uljcZXBYvOAwwQQfu 4zXWaTpdvo2mx2NqZWjRncvK5d3d2LuzE9SWZifrQBNe3kGn2Nxe3Ugjt7eNpZHP8KqMk/kK5u78 XalZHRlk8KajJJqchTZHcW+YjslkCHc65fbGCRwoycMSADq6zpUurzWEDuo06ObzrqPeQ0xUfImB 1Xd8xyedgGCCak1nRk1iO1zd3NpPaT/aILi2K7432MhOHVlIKuwwQetAGVqXjWDSrtLWfR9UeYw2 0sgiWJvJM7tHGjHzPvF0K/LkZI5xkiBfiDYszk6ZqYhgiEt5MUi22Y82WIiQb8na8EmdoYADOcVp T+F7a6mM9zd3cs7pYq8hKAubWZpkYgKBlmY7sADHQLWEfAYm1/VY5Lu/j0a8tUEsUcsai6Z7m6ml jchd4UeeANpXIbBLc0AdzWfNq8MN8tqYpmG9Y5JlUbI3YfKGOc5OR0B+8M4zWhWPP4a0641gaoyE XG9JGOFO5lACnJBK4wPukZxzms6nPZchMr9Cx/bEH2/7D5cv2rft8vaM7cZ8zr9z39eOvFRrq87a vLYf2VdbYwjGbfFjDMw3Eb87fkz3PXgcZd/Ylv8A2n/aXn3X2rd9/wA442f889v3dvtjOec55qWX Tg+oi9jup4ZNqpIse0rIqkkAhlP95uRg89am1Tr3/AXvFA6+8eoxWc1vB5skip5EV0HnTPO5kxgA DknJ49a3KzP7FV5YWnvbueOGQSRxSMuFYdDuChj+JPvmtOnT59eYcb9TIt9fiuLJbz7FeR2zxrIs kiKAVJAzw3GM556gEjNXjfwfaYoEYSO7sh2EHYVGTu9Ow+pFNi06CLSU0w7nt1gFv8x5ZAu3kjHO PSqml+HbLSLh57d7l5HTDmadn3MSCz8/xNhcn/ZHSkvaq34h72hZ1bURpWntdGCSdt8caRRkBnd3 VFGSQB8zDnNVLDWLmbU10++sY4JZIpJo5ILgTRsEZVdScKQwLjjGPer2o6fBqli9pc+Z5blWzG5R lZWDKQw5BBAP4VWsdFS0vvt017eXt0IjCklw6/IhIJAVAq8lV5xngc1b5r6bHVB0vZvmXva9/l5b 73H6tqT6clqkNq11c3U/kQxhwg3bWclmPRQqMeAT7GotJ1eW/ubi0ubRYLiGOObdFMJYpI5N21kb AJ+43VR+NWNT0uHVIolkkmikglE0M0EhV43AIyOx4YjBBBzyKZp2kR6fPcXJubm6urgKss9w4JIX O0BVAVQNzfdA680e9zeQJ0vZNW9759/utb53NCiiirOcKKKKACiiigAooooAKKKKACiiigAooooA KKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOI8U/8A Iff/AK9Yf/Q5a5qf7x+tdL4p/wCQ+/8A16w/+hy1zU/3j9a9bD/w0ebW/iM6zwhfw6V8MrO/uSfJ t7QyNtGSQB0A7k9AO5psV54hsV0jSWls4dR1E3d3LPeM86QfvA4gUAoXIEu0fMoCxHjtT/BmnWmo +A9BW8gWZYQk8asTgOpO0kdDg8jPcA9QK6G5tNK16zMV1b2Wo2okYFJUWZA6MVIwcjcrAg9wQRXm VPjfqehD4UeeaZ4l1yz0HS7bSLC3vLrUr/VZZJ42V402XchwivJEH3byR84OFJwecab+ONY0/TbS 81XS7WJru2mjhhiuA5N8khVYiyllxIMEAElSrA5ro7K10LXNEe3GkWracl1cRG1mtkMfmRzOjts5 HLqzZ6nOTyTWgdK0429tbmwtTDauslvGYV2wuv3WQYwpGTgjpUFGVrN9qdvotnZRGD+3dQAt0aPI ijk2EySDOTtUBmAPU7RkZzWNquua9p/i+w8N6S9h9ne3gjE98kk0okZLptxIcbhttCDnkl857V1k 1np8N82s3CRpPFbmM3EjYEcWdzdThRxknjOBnoMOjttOvJYdTjhtZ5GVXhulVWJXDbSr+mJHwQej t/eNAHnWofEvV10GPWtO0yKa2ttPt7vUFbaFWSSJZfLDtKhHyMuCqSEk4xmtu48S6yuv6pDA2mmz 0/U7OyaAxO1w6TiDL53gLgysQcHO0jAxk9BL4X8PzNG0uhaZIY4fs6F7SM7Ysbdg44XHGOmOKZH4 X0ddXudVlsYLi9nuBcrNPEjtCwjjj/dtjKjESnr1J/AA5228V607/bHfSZbP+25NK+yRq4nwLkxB 924jcFw5XbyoJ3DOBFD4w8T3HiCRI9CgGkx6odPd3niUhRJs83eZgwJ+8I/KyQRhjkGun03wvo+l 3LXcNjA9600832uSJDMPNkeRlDgA7cuQB6Y61ak0XSpdTXU5NMs31BBhbpoFMqj2fGf1oAx9A1Dx BqtxLdztpi6al9d2oiSOQTbIppI1fcWK5ygBXb3JyPu1YhuLnVfFUnkyMmm6WGifbIR59wyqcEDg qit6nLN0BStqGCG2QpBFHEhdnKooUFmYsx47liST3JJqnZxaVocdrpVu0Fr5pcwQGT55T95yMnLn ksTyecmgDmbPxbrhttZmu9MtWbRLOU3UcDtme6UsVSPIO1TGqtzk/vV9DmGbxRr9nPNA8uj6hI+h 3WqQLYxuDvjMYjXl23Kd5+bjdjouOe5jhiieV44kRpW3yMqgF2wFyfU4VRn0AHaue8P+CtJ8M3s1 7aF2ldGjDSJGvloSCw+RF3ElVyzbmO0ZNAHIhfEEEQX7X/p17YGVLtNfkmhmAmgDgK8SxxSMrkRs gxkn2Na2gX97a+Jrqwg0/VhbR6e9xLa3uopdTecGUIFJkcJvBfAaQA7ei4yb9nc/Dx2vvsU3hdml jJvPJe3JdCwBMmOq7io54yRWj4dvPCzxy2fhm50Zo4/mkh0x4iFzxkqnTpQAl1rtzA+gGWyayGoX zW08V2ULxL5MzrzG7LktGmOTw2OvTLvfE+rTRawmipps9xa6slhAJZMbl8iOR8AuoeQMzjbuThev Bz1N7YWep2r2t/aQXds+N0M8YkRseoPBqsdA0Y2ElgdIsDZyENJb/Zk8tyFCglcYOFVR9AB2oA5V fFevSeEL24SGyj1u31ODTtlxEyxK8ksKZdUkftLn5XbtznKjsrAXosoxqLW73QyHa3VlRuTggMSR kYJGTg5GT1pkOladbWUdlBp9rFaRurpAkKrGrKwZSFAwCGAIPYgGrlAGdrepnSdLe4jhE9wzLFbw ltvmyuQqLnBwMkZODgZPasrSL+fTNQuNG1S9jk+x6Zb3kl1K53PI7ziY5J4QbFwP4Q2OmMblxp1p dXtreTwLJPaFjAzE/uywwSB0zjjPUAkDqc1ms9C8Qpa37W2namsTE29wUSYIQcEo3ODkdu4oA5GX xX4pudE0XUNNs9OlFzpUN/eKoDyIzqCcRtNHhOuG3MeCMcc37bX/ABBrd/HHpDaTHB/ZFpqBa4jl Yu8xl+QYK7VIjHzEEj+62cDfufDmh3kNtDdaLp08VqoS3SW1RhCoGAEBHygY6CryW0Ec7TpDGszI sbSKoDFVJKqT6As2B23H1oAlrn7jWdUXXzaQWMRs4poo5JHlUFlcDLDLAjBPACtuwRkHp0FQyWlt LcR3ElvE80X+rkZAWT6HqKipGUkuV2Jkm9mZH9r33/CR/wBmeXa+Ruz9o3NnG3Pl7cY345+905x2 p0R1M+JrqL7db+QsMLiIwN9wvLwP3mA2Bgtjn5eBjnW+y2+MeRF9/wAz7g+//e+vvUUttY3V2hmg t5rmDDoXRWePJOCM8jlTg+3tWfs5dX1/pC5X3MK5+1Wd3Zz20xlt5rmJPtDag7l1YgH91t2dyPlP HXtiunrItZvDpvfMtJdLN2xxuiaPeSfcc81r06Ktd3CKMG1v9Zl0FNTdbJzJarcLCiup6BiM5Ocr ntwcdafp+uvqeoCC3gVYkaQu7NktGMBGXH94nv2U1sxxxxRLFGipGihVRRgKB0AHpTIraCDHkwxx 4RYxsUD5RnC8dhk4HvSVOat73qOz01M/xJczWmhTywymFt0aNMOsSNIqu/P91Sx/CqWmq1j4jFhD dTzW8lo80iS3LzmNg6hGDNyN6luOnycetbt1LbwWsst3JFHbqpMjSkBAvfJPGKzdEn8OsJYtBl0s gENKlg0fGehYJ/WtGve3OynO1Frlf6dN/Tp/V2+IppEisIBcPbQXN2sM80b7GVCrEAN23MFXI5+b jmotCaSHVNRsBPJNbwJC48ydpjFIwbfHvb5iAAjc8/PWnqU2nw2Eh1SS1js2wshumURnPY7uKh0a bRpLMpoclg1rG2CtiyFFbr/BwDRb3twU/wBw1yv9N9/XoaNFFFWcoUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAcR4p/5D7/9esP/AKHLXNT/AHj9a6XxT/yH3/69Yf8A0OWuan+8frXrYf8Aho82t/EZ0nh/UptN +GWjm0VHvrhEt7RHBKmViQCQOSqjLH2U0/VPDDW9poludMbXtPs0lF1ZsYw08z7SJysjBGO7zCQT 1kyORXFXsmpyeHfAen6dq0+nC5jdZXiuvJ3AtGOm4b2G44Xqea5TU9T8UWl5rXkeIdUey0y4aKSU 6kWKqZCiZw3JOMEAcHOcV4levyVJK19T6bBZWq9GM3UUdL69NbHoMnhPxAnhbSLddLtZo7a7vpLj SrlVu1YSzu8TYaaNXKqf4m/jzjI4s/8ACN+LbPQ9LNgYRqM8UunX24D/AEe2eVmjkX94eYVJAXc/ 3upxmvNGvPGyXl3aSa3qUc1mFNxv1TakQYcbnL7ecjvUVnq3jDUJZEtdfv5PLZIy39q4Uu+dqhi+ GJwcAZzWH1v+6zt/sHS/tonueq2iXLaf4RswsdkIVkvBjO21QhVi68eYRt/3VfvisrxB4NOufESz 1K60yO605YYIJWkZSDGEvS6lSckb3tj064P8Jx4/baz4uu0lePX9SRImCO02pGIBjnC5dwN3B4zn g1Pp+peKL+1vZx4ruohbJn95q23c29Ex80gwPn4boSMdSKaxV9ohPIeRNyrLTyZ2mqeHfG91olrb jRbCfULbSoIra7kRXlhlWFd+JTcL5cnm78MsbA/Lk4zjWfSZL7xxrs0Oh/aJ49bsmTUt0Z+zKkNq 8i4Zgy7kyMoCTnB6CvPjqetjwN/bZ8S60Ln+0vsgU3z7Nnlb84znOfevYPhtf3F/4C024u7iW4nb zd0szl2b964GSeegArSnXU3axxY3LHhafPzp62Ob0LRZ7q+e5tND8m6XxDdzHWvNT/ULeSb4sbt/ zAMm3G35t2c1JJ4Y8Sjxp9r+zWkgOqLcrqi2481bbeCYTKZwwGzKbREVPXqc13Wo6zHY32n2SIst 1eylUi8zaQijLv0PCjH4kDvVNPGWiS6m+nx3TyTJMbdnSCRollBA2GQLsDZOMZznjrW55ZU8M+Er PT5Z9SutPjTVW1G9nW43Zfy5J5SgyD90oynb0yckbhVjQQ2ralc+IpGBhkU22nqB92BWO6TOefMY Bv8AdVPerFv4r0W7Gm+Tfxs2pO8dqnIaRkUs4weRtAO7OMHAPJAMemeMtD1m6W3sLp5i5Ijl8iQR S4znZIV2vjB6E9D6UAYumeE9Ws01yNbtIWS2lsNElA/1ET5kDHBPRmRO3EAPeuW0e107X9ansdBs 7TTDN4evrOWW1u4rgCZ2gAdvKdue+5sO2DkDAr0o6/D/AGtfWaRmSOwtxLdSRZdkZslYwiglmKjd gc8rwdwrJ8M+LH1a21fUL+VILK0mnCiSwmtvKjjlkXc0khw52oCcBdhyCM9ADDbQdYmgeKLTdagE VurMtxqUc6yXMc0MkTQqZCqhfLc4KRg5A+Xtq6LYeK73WpNX1eWC0eGyltbSF7dQN0jI3mOiTPwD GOBJzk/cxk7ejeKdK15ylhLMx8vzV822kiDpx8yF1G5eRyPUetNi8S20h1OURySWdjMLczWyPO0k nG9VjjUsdpIBxnkNnG00AV9c0zWLvw0jJNa3Gu2Mou7Z4oTFHJIhJCbWclQyEoSX/iJ46VjXOkeI I/BSothaXmp6hd/atVt5EDrhgTsVfNRW2YiTBkwVU9c4q/4Q8Vvq+gaXe6pLGtzqbqsEaWM1uoYw mUoN5O8BVciQEK2MDnrqX/irRtNS4a6vAhguks3QRuzmZkV1RVAJclXU/KD+hwAcbZ+E9XvfBGpa JqumW8cVzrNrJHZ2+2KJbQSW7SBVEjBMbZiVDHnO3ORn0Kw0+00uyjs7GBYLaPOyJPupkk4A7DJ4 A4A4GBWU/jHRI9LGoyXflQNKIFWWJ0kaUjIjEZXeWI5AAyavW2uaZd6MdXhvoG08I0jXG/CKq53Z J6Ywcg9CDnpQBS8S3Fy8Fvo9hL5N7qbNEJgMmCILmSUD1AwB/tOvasfxNoGrwNYnwokMPmWw0m5D AYgtj92ZcsMmP5sDnO/pWsviyxh0qwvNRzay36l7e0RWmmkXr8saKWY7SpIAOM802fxvoFskTSXj lpI2l8tLaV5I0DFS0iBS0ahgwJcAAgg8g0AYHi3QdXnksNO0zQ9MvdKtrRYrcXVuJhDJypLAzx7Q FCYZVdh82Md36R4NbUbq2ufFOnrczJoNhbM80gcrcoZjMQQeHBZMOPU7T1rdu/Gug2Umx7t5SbZL tfssElxmFywWQeWpG07Tz06ZxkZLvxtoFlOkc16djwxTieOGSSFY5CwR2lVSiqdrcswHBPSgDoK5 m/0vU5fEsV0iRSQiaJ45tnzwIBh1yXGA3zdFOd3PSp77xnoOm3slpd6giSwhTOVV2S33fdMrhSsY IIILEVYm8T6PBqq6Y14GuyyKyRoziMvjYJGUER7sjG4jORjNZ1KaqJJkyipblb+zLv8At37X5P8A oX2jd9m3D723Hn9cdf4f+Bdac+kW8HiNrwaLDOkyx4mSOLMUodyzncQcncpyMn5fpVePxpZv4qud C+x6hvhSHEwsZyrM7yKcny9qoNgIkJ2tk4+6av2Ou299rGoWccr7rRI98ElpLE6lmdd4ZwA6EoQC oIBQ8nIxPsI/jcXIipcQarfahbloriKJJ0kkileJoMKQflK4kJyMjdxnqMcV0VYNh4y0HU72O0s7 8SSS7vIYxusdxt+95UhAWTABJ2E4xzTdM8a6DrE9rDZ3jM13H5tuzwSRpMMZIR3UBiBnKg5GDkDB q4Q5bu97lJWEsPDsUHh2GFYEg1D7KiPJ1IkAUjdg/NhlGPTHFS6fb6vPfxz6p5YjjUyxqoGUdxjZ wedg3DPff7UuieLNI8QlRp00zboxKnm20sO9CAdy71G4cjkeo9a1ridLW2luJA5SNS7CNGdiAM8K oJY+gAJPaoVCKtbp/WpPIilr1lcX+kSQ2uwzrJFMiyfdcxyK+0+gbbjPvVSwiv7vXU1G6s5bOKG2 khVJ3jaSQu6t/wAsyQFUJgZ5O4596fh7xamo6Td6jft5MI1WSxgBs5YWA8/yYwwfliSVywAAJKkA o1amo+I9J0kXhvryOAWUEc85cEBEkZlQ5xzlkYYGT045GdHG7udMazjDkS7/AI6MTXLW6mWwubSI TyWV0JzASB5q7HQgEkAEb9wzxlR9aj0a3vW1G91G8ge3E0UMKRSshkPl7yXcoSuSXxgdlH0Ff/hO NBFq1xJdyQASLEI7i3lilZ2ztVY2XexOGwACTg1KvjHQTppvzqEawib7OVdWWQTdfL8sjfvxztxn Hajl1uCrP2fJb/Pe/wCZu0VzWp+NbCw0RdTigu50N7DZtF9kmSRGkdFJZNm8YV9wBUbvlA5YUatr t6mnabqmmNHHayXtvbzwXtlKsrrLcRw5XLIYyNzH5lbPHA70YnS0UgORmqN7rNlp9xFbzykTyqzR xqjOzBdueFB/vL+dJtLcC/RVKLVbOZmVJ49y7RhmxywyvX1H8jU9rdQ3lus8Dh4mJ2sOhwcf0oTT 2FcmorAu/EU6X9xa2NhHdfZiFm3XPlsXK79iDadzbSp6gfMOa2LO7ivrGC8gbdDPGsqN6qwyD+Ro TTNJQlFJvqT0VzM/ix42uZ47KOTT7Z3WWb7Rh8IdsjBNvKqcgnP8JwDxnpqE09glCUUmwooopkBR RRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcP4 rYJrkrHOBaRE4BJ+/L2HWuXM6Ts2wSDB/jjZP5gV03i9DJrE8a7NzWUQG9dy8tL1GRke2RXI21pL aGQSm0O4jH2a2MXr1+Zs162H/ho82t/EZkeJ7qSw8K+Ar2IAyW8ckqBgSCytERnHbiuO/t68ePV1 Jj8vV5TLOoQ4VhJvBXPI5yMeh/L0DV7PTrvwh4POqXM0FvFYXMm6JGYswMQCkhW2gk/eII/OuT0/ w9ayDW7q+W6W309EkFtDIplkWRhtO4rggKQSdvORwK+ZxfN7eVu/6H6Lk/sHgIOounbvLT8behSu /FOqTa3LrSXD2txMULi3LKp2gADGTkcd6H8UasLy+u4717ea+dJJTATHkruAAx2wx/8A11pweHdN kuNcuBd3V3YabEksaxIY5p1fGD8y/KBnk7enPSoNK0K11S6UIt7HG+oWdtsYjesUocsSdvJG0YOA MHOOeOf949LnptYTlb5dEl09Pn1RlS6zdS2FxYzSCS3nuPtJEgLMJCMFgx56cc5/Pmq8d5JbC5jj A23MflupBOF3o+B36oOtdTH4c0qKPxZNdvevDo1ykUKRSKpkBlZPmJU88DkD14PSsqzFlLpmvG3W 7jZIQ6F5UKtF58QCMuzO7kHcCOmMYzle8nq+5adGSkqcdLx9NbP8mikmqXK6I+kFg1kbhbogryrh SuQQO4P6V6v4B8feG9D8GWVhqWptDdxGQujQSNjMrEcquMYIrhtCsdEuvB+uX97YXU11Y+Qd6Xez O+Qj5RsIXjGd27PbbVODRbK48JnV0e5aS2aRbtARtViVEJHHAJbnJOcHGKunKULNa6HJjcNh8UpU 5JxtK3TVtJ+e+nzZ6pp3j3wrFrF/ql7rrPcXB8qFFs5dkMCFsLny85JJZsnqQBworMutZ8AXniCD WJvFF99phuFnQppyIeGyEMgt/M2Y+UjfyvBzXLwXFla/Cqae3hvIpZ9Q+zSul0FLt5GecJzHn+Dr /tVnNoOmyaN5lk17d3kVkLq6wfLEGRn7jIC68j5lY8c4roeJn0seVHJcN73M5LW3T8T2PwtYR3Gv 6j4kRbiOyvQPsEUxXBRwjSSoo5USFEbDfN8uSFzirNh4Es9P8RQa5/aN5LdxbsnybaPztylT5hih Vn65wxIyAe1anhFQPBmh8f8AMPgP/kNajhvbjUvFUsNrO6adp0ZS5xGNs879E3EZwi8naRy4BPBF dqd1c+ZqQ5Kkorox+gadc2VrcS31wbi7u5zPNgfIhICqicD5VRVGTyepJJqS00mOy0u5sILq4QTy 3EvnDaXRppHkJAKkcM5xkEcDOa5vw14t1PXbmezlNlDey2T3EFu1nMFQgqo/e5Mc6ZcZZCvsO4ls PG02r2l3dWNkmNO06SW9huAYTHeDOINzYC7dj7ic8Mhzg8sgSHwN/Yk19f6NqM0eo3UBgUtBbxxJ udT5hWKFA7rg7S+fToTXTadp8Gk6Xb2Ftv8AJgjWNCwyxxxuPHJJ5J9cmud8N+Krm/1R7PU7mAP9 ka62HTLizZFVlBO6Qski/N1DD6EdKWr6hdXXhSbXLhrhrOfV9Pks7QQfMsC3cIBChd7NJgtg54ZQ ADnIBtP4Wg/sfQ9Ot7++tRpBQWs8flmUbYXhGQ6Mp+Vm7ehFRjwdG+n31nNq99O17dfabiaaK2dp D5SxhSph8vbhEP3c5Xr1znXPjidPDcWpCAQzXd+tmsMllPI9kSpYCaJRvZ8DooAy6gEj5isXi/U5 /Ct5d29vA2o22qW+nKZ7Wa2jlMksK7vLf50+WbHOcFc8jqAP/wCFbaQdBGjPc3UkK3hvUMkNuwjc oUIWMw+UFwW+XZ1JI55q3/wiwg07SdFt7gDSbaVprlRDEjTbX3rHtjjVApc5bCgnaAfvNldRvvEu nppVoZNJlvr/AFFrYTiCRY1j+zyy7tm8ncGjxjcQQOq5+XLu/G9/FY6XE0UUN9d3F5byzx2FxeRh raUxttii+cliNwyRgA5JxyAdJquirf3Vrdx6le2N3bxyRJLbCMsUcoWGJEYHlE5xniqq+GpTdC7X xDqyXjRJDNNst90yI8jKGHk7RgysMqBxjvknD1K7tfEXgvSNfvbCBLu31W0VZZICrQ7b+OORl3gO isEJwcHBweldN4j1Cax09LXTzjU75xb2mE3bHPWQjGNqDLnPHGOpFACaR4estHdTatKwWwtrBVcg jyofM2HGOp8xs9uBgDmqEfgvTI9GutM866MFxo8OkMxdCwgjWQKwO3AfErc9OBx1zV8Q+IdT0bUo tPglTyYrNZpLyXTpL13OWU7o4CpjHy53bdpyQANprN1j4g3ViYri2SGa2XSbbU3WLT7mc3AlMmVW RQBCMR8GRed3IGDQBpax8ONI1rVrnU7iRo57llaXNnaTZKoqAgzQOwGFXgHHGccnOv8A2AyazPqN tq2oWqXEyTz20YhMcrKqpzvjLAFUUHaw6cYPNVLrWdUuNa1O10+40uzh0wIZvtyOzTbkD7gQyhE5 278NyrccVFfeLJbOfUoCbVZYNbsdOgR85eOcW5Y4zy2JZsEcfJ0ODkA0JtDaTxB/a0OqX1rI0UUE 0MKRGOZI3kZQdyFh/rXGVK1Hb6BLB4juNa/tvUpZJlSOS2dYPKMas5RPliD4UyOfvZP8RIqK21Dx Bf8AiPVYLc6YmnadexW5WSKQyyq0MUj/ADBsKR5hx8pzwOPvGbTJrv8A4TLWbO8FhJ5drbTwzQWx ik8t5LgLHIxdt+3y8gjaMs3AzQBDp3hKHTm0sDVtQubfTMfY7aYRBI8RNEOVjDH5Hbqas23hyytb HQLWOScpouz7MWKkuFgeEbuOfkck4xyB2rP8OT+JLjX9Yg1HVtMuLaxvFhaGLTmicqbaJxtbzjtG 5z94MThuQCArdH8V3Wp6zBopgjXUrWWYasvkuqxouQjJn/noWjZeT8u7uOACXw94IsvDmsSajb3l 1JNNCYXRobeJGGQ25lhiTcwxwzZIBPrXUt908Z9qqardyafo99ewxJLLb28kqRvII1YqpIBY8KDj qelcfpvjW8xff2gVuJYNNlv1tI9KuLWQhMZCmQskgO4DKkc44PYA2p/DVtJocmlC6uo0e+N8Jk2b 1kNz9p43KVxv4AIOR+dRxeFSsmoPPrepXNxfRQwvPPHb7ljjZ2ChRCEIPmODuU8HtxjD03x9dz6P q91cQQTSWqW0kMotZ7WLbO2wbvNG4qhUs0gGCuDgYNbN3q+raNp0k99d6TcuLqyXdbwvEEimnWNy yl26KWIbOCQcjjkAy1+FmjC2ltnurmRZZ47gK1vaiNHRXTIiEAi5WRgSUJOFPUA1o2ngmx0zS4bS 0vbqF4Lw3kU8FvbRMkhjMZ+VIVjOVLDLKTz14GItd8VX1pqGqWWmLYzTWg0xYxLuIElzcvEwcg8Y UIRxxnJyOKk8SS6/Y+BtYurqTRbie1gmmdZLGR4bmBYixjaMy5Uk5GdzDA6c4ABcufD8t5oZsLvW tRuGNxFOl08cCzRtHIjoFCxhMbkB+ZSeufaW90NtQ0FNMutVvnYSxzC82xLNvjlWRDgIEGCqj7vb 8ai8Z3mp2GiQ3GlXlvaTG/tInknt/NXy5J0jYY3Lj7/Jz0BAwSGWPVdcu/C9rpt3rU9rLZNK0N/d wWsiLEWz5b7dz7VyAhJJ5YHIGRQBs2UUtpZJFNeT3boCWnuFRXbnIyEVVHHHAHT1pJbVHvortmfd HE8YGOMMVJP/AI5+tcb4kk1rWPA1hPusrOO9vLaOa2ns3ctDLdRrGjDzFx8jAOpB3ZIGyr3ibxJq Ok6wtnaCGC2S1Wdpzp8t6eWYbTHCwaNQFB3EEHJ/umk0nuDVzY1DQoNRukneWaNogNoQLgMDlH5B 5XLY7fMcg9tO2hS3tYoIwQkahFHoBxUOk3iano9jfqY2W5t45g0YYKQyhsjcAcc9wD6gVWnudRfV 5rOz+yLHFbxykzIxLFmcbeCMD5OvOPQ1m1GDulqyXoV7vQGlvLm4ttWv7P7SQZY4FiZSwXbu+eNi DgKOuPlHHXOrZ2sVlYwWkA2wwxrHGM5woGB+grKuPEcVhNcW91G5njZ9vlxkqVxuTPu2Qo9WBFbM Hmm3j88L520b9nTdjnHtmnCcZNpFe1cla+xz9x4XSZbmEapfpZXLu8looi8s7zl1BMZYAnP8WfmO McY6SuJvNS1BdN1bU01i7imtJ50SzWKHy9yPtijIKGQmQbSMH+Lgjiu2pwaex0Vqc4Jczvv+gUVx NnqeoNpuk6m2sXcs13PAj2bRQiPc77ZYwAgkBjG4nJ/h5J5rtqcZKRNag6Ts3f8A4AUUUVRiFFFF ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHEeKf8AkPv/ ANesP/octc1P94/Wul8U/wDIff8A69Yf/Q5a5qf7x+teth/4aPNrfxGc34turiz8FeB57WeWCVYL jEkTlWHMfcVw8Wp38N695FfXMd05JadJWDtnrls5Nel6nLpsXg3wr/aMBlLaXei2+QuEmxHtZh3A wexx17ZHOwHQrfxBPZaxFFDZXGn2oMqwkmGURRMSNo3Akhgccktz3r5jGRvXk79T9IySso4CEXBv R9N1zdO/oYGkDWtR1yNdMnuW1OcttdJ9jtwSfnJHYHqahi1jVLeeaWHUruOWZg0rpOwMhHQkg84r oPD2u6ZafElNYlCWWmiWZlVIuI0KMqjao9x0FZfh+60WMy2utWjyQzvHi5ifElvjdkgbTuByMj2F cyS016s9dzleV6d0ox6a6t3XZ2snb/gHV+CvAt54z0O/vj4hntFmujHcRGMyCcqFcM53jccueoPP NbLfDvUtBvLLSdP8WaoJL1nk8qyg8tUVSivK+Z1GBvQHGWORgGtP4TRXjeHZzpV5bxWSatL5q3Vo Xklj2RYClZFCNjPJDjJHHHPW6l4fN9460nVm+1iC1srhHaK9kjUSebA0YKK4DAhZMjBDbQGzha76 NCDgpNa+rPksxzTFU8TOlCXup7WX6o4uz+Dd9p0jSWPjC4tXYYZoLZkJHuRJUsPwfubfSLrTIvEi rBdOjzH7B8z7M7RnzOgJzW3rUnieO38W2VjpOqXMl7u/sy7gu4ESHdaxoMbpVdMSh24XuSOTVfWd J1//AITmK/0+PWZrVru2MqSXpW1SMFBIyKl0hAC7jtaJ9zA8EGtPq1JdPxZxvOca959ukem3ToYn /ClLj7H9k/4SuX7N5nm+T9kOzfjG7b5mM44zUv8Awp7UfsP2L/hMrr7J/wA8Ps7eX/3z5uKtLpPj D/hLTLK2pfZf7TMgmik3R/ZvO3BcG9VceXhT+4yBnAY8n0COPUhqk0kt3aNp5TEUC2zLKrcctJ5h DD73AQdRzxyfVqXb8WN51jnvP/yWP+RTtXh8O2GgaNK0kzybbCKRUABZIHfcwzwCsTdM8kfWrml6 bDpNgtpC0jgMztJIQXkdmLMzEADJYk9O9cJpOiax/bHhea90zW/tdlIZNQvbrVBLbO32WWMskXnN gl3GMIuAT71Holl4xk8ZafqF7YX9lavPLJeRNetJCitFJhRm7kVgHKYCwpjHGAMHZK2h5cpOTcnu zv7PSdN06aeay0+0tpZzumeGFUaQ+rEDn8ar6NoUGj2t1F5813JdztPcTXITdK7AKSQiqvRQOAOl ef6Vo3jlNL1eO7l1IXz6PcQwt5wCSXZVQjo5u5NpBBwRHEPmJO04FXdR8LeIbeS/fRrrVQ/2udbQ zavLIogbTiqkq8hBxdEYyNwPIwvNMR1r+E9EGnXljaadbWEN4NtwbKFIjKueVYgcgjIPfBOMda1Z beCeJYpoY5I1ZXVXUEBlYMpwe4IBB7EA1wF3o2uXdwken2uv2Fo5jW6F1rBd5P8ASrcs0bLOxQCJ Z+hU4OAMmul0fR59K8RakY5b59MltbbyftV9JcYmDzeZt8x2K/KYvQHj0NAGrPptjdJcJcWVtMty oWcSRKwlA6Bsj5gPeobPT9GjtDYWNpYLbW8y5t4I0CRSKVcfKBhWB2sO44PpUXiHVZdJ0ppbW3Nz fTMILO3BA82ZvugkkAAcsT2VSe1Zd34cuLTwdBo+mz3bzm6tmublLlo5pVNwjXDmTcGBK+YeD0OB 2FAHSyQQzPC8sUbvC++JmUEo20rlfQ7WYZHYkd6rXOjaXeWTWV1ptnPaNI0rQSwKyF2YszFSMZLE knuST3rC1jRJ7PT7K30savdWwvDLeRJqkpnkj8l12rLLKCBv8s4DgcE+tZrabrotNNF7a6zdW6fb fOtrTUxFON06tb7pPOTdtiDA/OfxoA6+a20y20wWc8FpFp7bYBA6KsR3EKqbTxySAB3JAqva6Bpm mXcV1aQR2sVtbvBDbxIscMKs29yqgDBYgZP+yPfPLap4b1LUvBdtHdw6nPf22oidLePUmSQwC9WQ KzCVVd1hUYLNlSMgg81aukbUrLT/AArFZ6pax3IabUBdXvmTQWwc/K8oldiZWG0YY/IX6bcUAdFd 6Tomvx29zeafp+ooFDwSzQpMADyCpIPB65FPu9E0m/uILi80uyuJrf8A1Mk1ujtH/ukjI/CpriZ7 RLdILGa4VpFiIgMaiFT/ABncy/KPRcn0Brz/AOIz38B1m4hGrOsekKbR9P1T7OLafdNl3jEyFsny gPlfO0gc8UAd3e6LpWpTwz3+mWd1NAcxSTwK7Rnr8pIyPwqhqVtoUniXTEu9GtrvVJleSG5a2jd4 Ei2neXbkAMyAYydzDjqRm65peuTa80VjJef2bqX2f7TNHeFPsnlOWfYNwZfMTanyDqMnrmrc/h8t 8QdP1xPtZjSyuUlY3snlrIxgCARF9oBVZCQFwSoJ+YKaAOgjghheZ4oo0eZ98rKoBdtoXLep2qoy ewA7Vnw+GtBttUOqQaJpsWoF2c3aWqLKWbO47wM5OTk55ya4ltH8RW/jNbq3tteurF9R8x/tOolI o4zJyVCXeCijkIYTlcKRnNelUAZC2mlXXiN7v+yIH1C0XZ/aDQR70JUfIH+/na/bjB69qk07RItP 1TUdR+0z3Fzfsu9pgg2Iu7ZGu1V+VdxxnJ55Jpmk6SLC+1GbNxiSYeV5ly8gZPLjBJDMedysMnnA x0xVawbVni0aCezu4mtyBdzSTRkSYiZf4XJbLlTyPesVUkviW/8AmQm+pvMqupVlDKwwQRkEVR07 RNJ0gynTNLsrIynMhtrdI9599oGawtMsdat4buArelzZusNzdXGW83gLlfOcZPXIC4x71a0Gz1K3 v2a7N0sPkldsrFgzZXByZ5DnAPQDqfalGtJtJxYKTfQ1rTSNNsI547PTrS2juGLTLDCqCQkYJYAc nHrUVtoGjWVnPZ2uk2EFrcZ86GK2RUkz13KBg/jWf4gm1C68PXxgtrqyeC5j3FriOJpYElRpHR1f Chow4BYqR3ArmtMtLzUrrxVpdm2uab/xL7X7ML3VGneKcmc71dZpNoOIsruGQORg87lnWzad4f8A D+kXV1/Zdja2dtEJ5RDbIoCwkyKcAfwtlh6E5HNSPZ2PiXSYf7Z0JGjLeYLPUoYpTGwyASAWUHBP Q5w3bkVy2o+H9Y8ReDfErajBfQalfxSfZNPTUWVYisBjRPkk2EMxZiCdp3DcOONLxRoVwfDVtYaT LrheG48xTa3zNKww5IkkknjdkyenmZzt7DgA34tH0uHSv7Li02zj07BX7IsCiLBOSNmMckk9O9ZW u6BpZ8Lf2THG9jpYdVa00+KJBMGbHlbWUgBmYZxtOe45qn4UtPEMPhm6t7iNrDURcnyZdQkkvA6Y T5ihuXK5+ZdolwCN3fFbWuaadStYVXzi6TxNiOdoxtEiFicEAkKCR3HbmoqOSi3HcTvbQvNFFeW8 YubZSMpJ5Uyq2xlIZfUZVgCCOhAINVtQ0PSdXeJ9S0uyvWi/1ZubdJCn03A4qG8N3ZXlm9ra3V3b x28kbxxzLndmPYW8xxuOFYZyTz71j3Vhq5tdPYDUZLmOzjSZUuP3ZkA5ziZCWz1PI6VnOrKOii2S 5NdDrAAqhVAAAwAO1II0ErShFEjAKz45IGcAn0GT+Zrl9Qs9ZnktZI47lEFpGrRRzsxSTndkiePd /CMndnB6d9a1g1dJLEte25tEt1W4iltSZ5JNpywkEu1ecZG1uh55yKhUcpWcbDTu9h+s3NlpWk3+ r3dsJYrS3a4l2orOyxAuAM4yRgkZPX0rRrzjxnomsanB4ktl0zW757yNo9Oa01QQW8amBF2yRmZA w8zeTlWyDU/iG18WXnja1lsLK7i0+3ubQCeK7IjlhEitMWX7SqjguuDC5IHXkY1sUdq+l6fLfJfS WNq94n3bhoVMi/RsZq3Xma6T4w/4S0yytqX2X+0zIJopN0f2bztwXBvVXHl4U/uMgZwGPJkm8NeJ P7Wsr6K41Xd/aFxNcL/a0nl+X/aMJiHl+Zt2/ZfO+UDGOCN2BRYbk3uzvY9L0+K+e+jsbVLt/vTr Cokb6tjJq3XB+H9N12C70M3NrrMVxDj+1bm61MTQXH7h1OyPzmx+9KH7i9Kl0Xw1qmn2/hK5kuNV e/j2/wBsCfVZpkObWQNlGkKN++KfdB7EcCi1gcnLdnb0UVg22jzroKB570akbVQ5a9kbEoAb+9j7 w7dRkdCaiUmnoiW2tjeorB0X+1RGbzXA8MsVuFI8wbCSSzNtUkZA2rnr8rY4PNu8M+paPE1ulxC0 ssLFd/lyCPzFLcg8fJnvn8eKlVbq9tbXt1BNuPNY06K5+TT72ATRxi9ltvtu8It43mNF5AGFZnBH 7znGRUU9jfyaZKirqcZ+1B4Y0uQ0ip5YBDt5oyN244D56VLqyX2f6+4nmfY6WmyMUUFY2c5AwuM8 nGeSOB1/DjJ4rm9O/ti0lgkm0+9kjXzkZBcKxbPlFHIeZsfdcYDHHtmnTxambC1k+yX73a3jy7Y7 pV2Refu2v+8CtmPgDkDpxS9s2vhf4+XkHPpsdJUFndJfWNvdxBhHPGsqhuoDDIz781m6pHdXElnI LW+eDy38yC3uRE6udm3cQ6ggYYHBI571Jpztpuk6RYzwubkwRxMiYOwqg3EnOMD1FU6lpa7f8MUr t2Rq0Vlz6c95q07zyXS2v2eNYxDdPEN+6TfwjDnBTmsdLLWP7PZJ4tQe+MCCGWO92pG/koDvHmDd 84Y5w1Eqso/Z/r7vuJcmuh0t5dJY2NxdyhjHBG0rBepCjJx78VPXL63YXt2uqxC0v52nQrbNDdhI lBjAwymRc/NuJ+U8GmrYa1/bJkd7ryjd796uSnl78gYM4GNvB/d+vBPJl1pKTXK7BzO+x1VFYn2O /wD7W8ndP9g+0favN885+7/quudu/wCbH3ccdOK261jJyvdWKTuVE1TT5b57GO+tnu05aBZlMi/V c5FW64mz0zUF03SdMbR7uKa0ngd7xpYfL3I+6WQEOZCZBuByP4uQOa6nWLae80O/tbZzHcTW0kcT g4KsVIBz25NEZNq7R1VaMIyUYy0+T+en5DrXVNPvppYbS+triWLiRIpldk+oB4q3XLWtrdT6ppDJ ol1p0VkzEtK8G1YzEU8pfLckgsVbkfw/QV1NOLb3Ir04waUXf7n+QUUUVRiFFFFABRRRQAUUUUAc R4p/5D7/APXrD/6HLXNT/eP1rpfFP/Iff/r1h/8AQ5a5qf7x+teth/4aPNrfxGdH4X8OaXrvgrw7 NqFu8ktpCTA8c8kTRljzgow/uircvwy8ITzPNNpTySuxZ3e7mLMT1JJfk1N4Gt4bnwBo8c8McqeQ DtkUMM5PY10kNvDbIUghjiUksVRQoJPU8d68qrTg5Nta37Hr0MXiKcIxhNpW6No5P/hVngz/AKA3 /k1N/wDF0f8ACrPBn/QG/wDJqb/4uuworL2VP+Vfcbf2hi/+fsv/AAJ/5mbomgaZ4csns9Ktvs8D yGVk8xnyxABOWJPQCtKiirSSVkc05ynJym7t9wooopkhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAVTudJ029vILu60+0nubc5gmlhVniP8AssRkfhVyigAooooAKKKKACiiigAooooAa6LIjI6h kYYZWGQR6Gq+n6ZYaTbm306xtrOAsWMdtEsa5PU4UAZq1RQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAc549ubiz8F6hPazywTJ5e2SJyrDMig4I56GvJvD3iHWp/EulRS6xqEkb3kKuj3LkMC4 BBGeRXrPj22uLzwXqEFrBLPM/l7Y4kLMcSKTgDnoK8m8PeHtag8S6VLLo+oRxpeQs7vbOAoDgkk4 4FelheX2Mr+f5HDiOb2ise+UUUV5p3BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFAHEeKf+Q+//AF6w/wDoctc1P94/Wul8U/8AIff/AK9Yf/Q5a5qf7x+teth/ 4aPNrfxGdn4HmaHwBozLDJMTCAFjxnv6kD9a6O2uBcxlxHLHhiuJUKnj2Pb3rB8Af8iJo/8A1wH8 zXSV5lS3M/U74X5V6BRRRUFhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ AUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHEeKf+Q+//XrD /wChy1zU/wB4/Wul8U/8h9/+vWH/ANDlrmp/vH6162H/AIaPNrfxGdp4GWZvAGjiCSNH8gcyIXGM nsCP510kKzKhE8kbtk4KIVGOwwSea5/wB/yImj/9cB/M10leZUfvNeZ3wXup+QUUUVBYUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFFABRRRQAUUUUAFFFFABRRRQBxHin/kPv/wBesP8A6HLXNT/eP1rpfFP/ACH3/wCvWH/0 OWuan+8frXrYf+Gjza38RnZ+B7aG68AaMk8SyIIQdrjIzz2ro7a1itIzHCpClixyxbn6k/p2rnPA 8zQ+ANGZYZJiYQAseM9/UgfrXR21wLmMuI5Y8MVxKhU8ex7e9ebO932ud0LWXexNRRRWZoFFFFAB RRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFF FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUU UAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcR4p/5D7/9esP/AKHLXNT/AHj9a6XxT/yH3/69Yf8A 0OWuan+8frXrYf8Aho82t/EZ3HgD/kRNH/64D+ZrpK5bwOJz4A0YW7Rq/kjLSKWAHPYEfzro7Y3J jP2oRB9xwIiSMduvf+Xv1rzKi95vzO+D91LyJqKKKgsKKKKACiiigAooooAKKKKACiiigAooooAK KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo ooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiii gAooooA4jxT/AMh9/wDr1h/9Dlrmp/vH610vin/kPv8A9esP/octc1P94/WvWw/8NHm1v4jO48Af 8iJo/wD1wH8zXSVy3ge2huvAGjJPEsiCEHa4yM89q6O2tYrSMxwqQpYscsW5+pP6dq8ypbmfqd8L 8q9CaiiioLCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACi iigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKK KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOI8U/8h9/+vWH/ANDlrmp/vH61 0vin/kPv/wBesP8A6HLXNT/eP1r1sP8Aw0ebW/iM7PwPcR23gDRnk3YMIACIWJPPYAmujtrqC7jM lvIJEDFSR6jqKwfAH/IiaP8A9cB/M10leZUtzP1O+F+VegUUUVBYUUUUAFFFFABRRRQAUUUUAFFF FABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUU AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA UUUUAFFFU7zVtN0+4tbe91C0tp7t9ltHNMqNM2QMICcscsBgeo9aALlFV5r+zt7y2s5ruCO6ut32 eF5AHl2jLbVPLYHJx0qxQBxHin/kPv8A9esP/octc1P94/Wuh8WXMEfiOSN5o1f7HC21mAON8vOP wNc3NPCWOJUP/AhXqUJxVNJs86tF870O78Af8iJo/wD1wH8zXSVzPgE48CaP/wBe4/ma6Tca82p8 b9Tvh8KHUU3caNxqLl2HUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFh1FN3GjcaLhY dRTdxo3Gi4WHUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFh1FN3GjcaLhYdRTdxo3G i4WHUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3c aNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFh1 FN3GjcaLhYdRTdxo3Gi4WHVxPi7wxpmvaklhHoFi99fKWu9Vm01ZDDCF25WQjBlPyqozkD5sYAB7 TcaNxouFjNS/0rSb3TfD0TeVPJA32W2jiZgsUYAJJAIRRwAWIyeBk15tqtrfPf6zdX1hHqOorcXD WkE3h68mYIpbyUiulfy48qFO5QMFjnnNerCCEXRuhBF9oKCMy7BvKgkhc9cZJOPepdxouKw6im7j RuNFx2HUU3caNxouFh1FN3GjcaLhYdRTdxo3Gi4WHUU3caNxouFjk/H63l7p1jo9rpt3fQ310ovU t4gT9mT53XezoiliFT5m6M2ASKyoZtVf4Z2UWp2F/wDb9N1GzjnQWjmWSOC8iPmBEL78xqGJQsM7 sHivQdxo3Gi4rHK67qUc3/CMavFaak9pDqbvKF06cyov2a4jy0WzzANzKMle4PQ11EEy3NvFOgkC SIHUSRsjAEZ5VgCp9iAR3p240bjRcLFHLrrF4Y1DOLaHCk4z80tKtw87FvJkiQcfvBhifp6e9LPZ GW6+0xXU9vIUEbeVtIYAkjIZT0yfzqNtPnY5Oq3n/fMX/wARWcn0NEj/2Q== --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ Content-Type: image/jpeg; name="Picture (Enhanced Metafile) 8.jpg" Content-Description: Picture (Enhanced Metafile) 8.jpg Content-Disposition: inline; filename="Picture (Enhanced Metafile) 8.jpg"; creation-date="Thu, 08 Nov 2012 06:14:10 GMT"; modification-date="Thu, 08 Nov 2012 06:14:10 GMT" Content-ID: <3a857d48-7816-4308-87f7-408453ce07a7> Content-Transfer-Encoding: base64 /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAJWA3sDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwCBi0nI ACqMBR0UdgB2FTx2N26h0t5GQgkMFyCB1/kaz7oMYwVR3KsCVjIDEd8E8UPfTRoFttPv/wDR8GAM 8WCCPnU/Px0Hr1NevUq1YStCN0eZSp05RvJ6lsggkHqKB0qtbSyyPN5kE8ah8o0xQs4PPO1jznNW R0rpi24psymrOyFooopkBRRRQAUUUUAFOptOpMTCiiikAUq0lKtALcdRRRSLHLS0i0tWJhRRRQIK KKKACiiigBw6UUDpRUiCnjpTKeOlA4hRRRSKCiiigB1AooFC3ELRRRViCiiigApR1pKUdaAFpxOA TgnHYU2ldiqMyoXIBIUYyfbnipCJZTTdQcwII7dmniMscqSt5GwdWZyoKhf4srkHjB4zGba7ijtG lWB/tgzbm2kZ1f5tuPmVSG3EDGO4q7bapFHoj6W9vc/Z7gGSdgw3rLwRtXdtKDaAQSN2SeKTSNbi s7OMX2mXUs1pO1zaCMxkbipBQ5cYG4B/xH0rn56mrsdfLTehC+l6jBbXd1MtmYLO4+yztDOzkScd AUGVG4ZPBznjAzSRabqM9naXkNvG9veTfZ4F8wiUyfMeVK4C/Ked34Y5ot9XNtpRsLixu7oS6iZ7 lo2jAkiaDY5GWB3biSOnIq9Y+L5kNtNc6RcrImp/aDHGYtqxGAxnHz9cknFJyrLZD5KT12KY0jUz cC2VtLlmKu5eK+3QxqmN5kfZlcZH8J6/XEV1b3FhI0N0ieaqB/3L71dSMgq3GQfXArUk8RrJqFtc eTctJFbSwTzy2sJFyrsCqNGsgG0AHuOce9VtX1CPVNRW4hhMMUdvHAiFVXhcnopIHLEYB6CiEqjl aS0JqKnyvl3IF0++N7b2Gy3a8uVV4fLlYxOrAlW3FQcYBydvGDwarRLcu0Y8jzPOLCH7OsknmlTh tvyDcB1+XPH3tp4rTg1mO305ENndNqNtDJa21wuzYEcjDHLZygLAcevWotN1pbC68N7tPu2j0x7z zShjwRITs25cZ6j0o5qnb+tQ5Kb+f4bEf9nakLJb82UgtGlEKna/mMxGQQm3lDkKGzyxAA71XO5V ZmjkVVcxszRkBXHJQkjhgP4evtV211+8XSbSG7F/JOmqQ3sgDqVMY2lozl+zZbAyMgYp19qVs8Cx WsGoZl1o6lK7LEpiUgghfnOWHGO2etNVKqdmhOFNq6ZTMFz50EH2eSKa4dY4RcRtErFmCg5I6ZIy QDj3qOcvaidZ1USW7OkojO4bkJDYJAyMg4JA+grY1PxDFPFpiRWuoz/Z9VjvGaUqWWJc5GWlbJ78 YHsKxdQle8XUZkgkU3Es8iRMV3YZ2Kjg4yQR3q6c6kn7ysTOEEtHcvy6NqkGqxaTLFa/2hKAUCTM YiCCclygI+6c/L+dVxBc+dNB9nllmgdo5RbxvKqsrFTyB0yDgkDjsKv3vidpvEEl7HpN4U+1wPHI WiDLCPLMoxv65iGPYt60/SddjtLy8uZItSj87UpLpYkK7DGWJ+YLKvzHpzuUYHB5rNVKyV2i5U6V 9GZcaySo0kUM0sacu8cTOq/UgYH4077LeC1gvPI32twJDE0O52Ajba5cBcKM9Dk8dcdK0x4iEkSx RLq2niO7uJj5CxETLJIWXP7zqAccgj9MQaN4ln0uLQLU2d6ttaNdfbI4mj2SByxjwC/IGe9OVSr/ ACiVOnezZnRrcSPGFt3dZt3kCJHdpNv3sDbg4/2S2O+3pSsGTaJI5ULAFQ8bKWB6EZHIPtVjRNaN h/wi3n6bef8AEs+1/aNpiP8ArM7cfPz1qSz8R3Jk8O3Wo2V7cXGnfaGuS7Rs0m9hs2nfyQOecY20 c9S/w/1qDpw7lSRJI3McsUsUgAJSWMowHrggGmVav71bv7NHFC0cFsjqm6Pa2GYNgkyyFuc9xjJ9 eKtawbauzKSSdkFFFFUSFFFFABTKfTKZMhD1pKU9aSqAKKKKACiiigBDRQaKh7jG0UUUDCiiigAP SmU89KZTJkFB6UUHpQIbRRRVDCiiigAooooAKRqWkagaG0UUVAxrUlK1JTIe4UUUUAFNp1NpoEFF FFMYUU1iQV4fbn5tiBmAx2BZQecd6RnXA8v7UWyP9ZbxquM88iVj09jSuOw+rVnpmoahG8lnZvMi PsZg6LzgHHLA9CKq1BdSv5EcK2Tz7JZJCcoFwyxgdTnPyHt3FKV+g426ly7tLmxuPs93A0MuwOFL KcgkjPyk+hqFVaSRI41LPI6oiggZYnAHPuabHK0kECtA8JiiMZVip58yR+ME8Ycenekf7vKlgSAQ oBOM88EgHjtkZpxvbXcbtfQnayvA90n2WTfaIXuF4HlKOcnJx05GM5HIyKrVuar4ki1DSBYC01FR EFMUjyRs0pUYxKNw6nkEE8gE4IwcOoi5Ne8hVFFP3TsdK+HV1qej2V//AG1DF9qt45tn2Itt3KDj PmDOM1cHwtuh/wAx6H/wAP8A8drsfCv/ACKGif8AXhB/6LWuf07xNq19qrxvcpHCuozWvlJ4fu5A USdox/pAfywSFyWxhSTkcGvIeKrJ/EeosPStsZ//AAq66/6D0P8A4AH/AOO0f8Kvu/8AoPQ/+AB/ +O10C+LEju1edkSwS31Oa4laIhk+yzpHwAzZGGf3OAcL92rPhrxfpfipbn+z3O+32GRC8b4V87Tm NmXna3GdwxyBxS+tVv5h/V6XY5b/AIVhd/8AQeh/8AD/APHaP+FYXf8A0Hof/AA//Ha9HrL1XVH0 q7095UBsJ5TbzSBGYxO2PLYkcBCQVJI6svIGaPrVb+YPq1LscZ/wrC7/AOg9D/4AH/47R/wrC7/6 D0P/AIAH/wCO10l74kaLVJoYF/0S1ltra4lMLNmeaaNFRTlR8qtljzjevUgqal54zuBd6emnaHf3 UM2oz2MrfuV3GJZtwj3Srzuizk8bQw+9gUfWq38wfV6XYxv+FYXf/Qeh/wDAA/8Ax2j/AIVhd/8A Qeh/8AD/APHa7GHxDaTfY9sc4+1389hHlRxJD524nn7p8h8d+RwOcYFz8RLKSy1yOxhdNR0/Tri9 jiudhDCMfxKjll+Yr8rbW549j61W/mD6vS7Gb/wrC7/6D0P/AIAH/wCO0v8AwrG7/wCg7B/4AH/4 7XXeKNUu9H0NrywgjnuftFvCkUmcN5kyRkcHg4c4Prjr0rO1jxaYYtKbSUS4N3dWyzeYjDyoJJli JI4w+5sAHuG4+Uij61W/mD6tS7GF/wAKxu/+g7B/4AH/AOO0f8Kxu/8AoOwf+AB/+O10kfjPTZPF K+HmjmjvHd0jLmPDsqlj8oYuBgEhmUKexORVuz1+O/1F7a2sL57dZZIDe+WBD5kZIdeTu4KsN23b kYBo+s1u4vq1Lsch/wAKxu/+g7B/4AH/AOO0o+GV2P8AmOwf+AB/+O1oaf48+0eGFvb2xubS7Oit qgcwAxShEUyGMb8kBnXhipIIwcc1qz+LbW31WayewvykF5FZS3SxqYUllWMoCd27BMqDIBwTzgYJ PrNbuP6tS7HNf8KyvP8AoOwf+AB/+O0f8KyvP+g7B/4AH/47XQWfjvQ77xM+gQzk3ayyQD5k+aSM Euu0NvGNrfMyhTjgnjPS0fWavcPq9Lsedj4Z3g/5jsH/AIAH/wCO0f8ACtLz/oOwf+AB/wDjtdjr upS6PYpfiPzLaGVTdhY2d1hOQWULz8pIY8H5VbjOKztd8THT3nW0AdLOxl1C8l8kyLHGqNsA+ZQX ZhkDcPlRumQaPrVb+YPq9Lsc/wD8K0vP+g7B/wCAB/8AjtH/AArS8/6DsH/gAf8A47W9eeO9DsfE w0CaYi88yOFvmQbZJMFF2lg7Z3LyqlRnkjnDh430kw6LIyXqHVpDFEjWzBoWDBGEo/gxIyxnP8TD tkg+tVv5g+r0uxz/APwrS8/6DsH/AIAH/wCO0f8ACtLz/oOwf+AB/wDjtdtpGq2+taZFqFqsy28x byzLGULqGKhgDztbG4HuCD3q9R9arfzB9Wpdjzv/AIVpef8AQdg/8AD/APHaP+FaXn/Qdg/8AD/8 drWm8SahFqjxzPDZRJO0Qiu9OuAjjcQjC6B8sbhg/dOM46irN3470Oy8TroE05F4ZI4W+ZBtkkxs XaW3tncvKqVGeSOcH1qt/MH1el2MH/hWt7/0Hbf/AMAD/wDHaP8AhWt7/wBB23/8AD/8dro7Txba 3epxWYsL+JJrqeziuZI18p5oS+9QQxPSJyCRg4xnPFRaZ4rOr69Y21tZzxWF1Yz3cc88e3zlV4Qj Jhj8pEjEhgG+7wM8n1qt/MH1al2MH/hWt7/0Hbf/AMAD/wDHaX/hW97/ANB23/8AABv/AI7W3qni t9L8RXGmG1aX/RbaS3KxuE8yWSVD5suCqL8iYzycnAY8CTW/F1l4UtrFNamja7uQ20QlIVbbjcQZ XAAG5eN2TngGj6zW7h9XpdjA/wCFb3v/AEHbf/wAb/47R/wre9/6Dtv/AOADf/Ha6TSfF2lay8At XlCT27XEUrp+7cI5SRQ4JUsjDnnGCCCRzWlpWpQ6xpsN/bxzJBNkx+dGUZlyQG2nkBgNwzzgjgdK PrNXuH1el2OJ/wCFb3v/AEHbf/wAb/47R/wre9/6Dtv/AOADf/Ha9Coo+s1e4fV6XY8+/wCFcX3/ AEHbf/wAb/47R/wri+/6Dtv/AOADf/Ha9Boo+s1e4fV6XY8+/wCFc33/AEHLf/wAb/47R/wrm+/6 Dlv/AOADf/Ha9Boo+tVv5g+rUux59/wrm+/6Dlv/AOADf/HaP+Fc33/Qct//AAAb/wCO16DRR9ar fzB9Wpdjz7/hXN9/0HLf/wAAG/8AjtL/AMK5vv8AoOW//gA3/wAdr0Cij61W/mD6tS7Hn/8Awrq+ /wCg5b/+ADf/AB2l/wCFd3//AEHLb/wAb/47Xf0UfWqv8wfVqXY4D/hXd/8A9By2/wDABv8A47R/ wru//wCg5bf+ADf/AB2u/oo+s1e4fV6XY4D/AIV3f/8AQctv/ABv/jtH/Cu7/wD6Dlt/4AN/8drv 6KPrNXuH1el2OA/4V3f/APQctv8AwAb/AOO0v/CvL/8A6Dlt/wCADf8Ax2u+oo+s1e4fV6XY4H/h Xl//ANBy2/8AABv/AI7R/wAK8v8A/oOW3/gA3/x2u+oo+s1e4fV6XY4H/hXt/wD9By2/8AG/+O0f 8K9v/wDoOW3/AIAN/wDHa76ij61W/mD6tS7HA/8ACvb/AP6Dlt/4AN/8do/4V7f/APQctv8AwAb/ AOO131FH1qt/MH1al2OB/wCFe3//AEHLb/wAb/47R/wr2/8A+g5bf+ADf/Ha76ij61W/mD6tS7HA /wDCvb//AKDlt/4AN/8AHaP+Fe3/AP0HLb/wAb/47XfUUfWq38wfVqXY4H/hXl//ANBy2/8AABv/ AI7R/wAK8v8A/oOW3/gA3/x2u+oo+s1e4fV6XY4H/hXl/wD9By2/8AG/+O0n/Cu7/wD6Dlt/4AN/ 8drv6KPrNXuH1el2OA/4V3f/APQctv8AwAb/AOO0f8K7v/8AoOW3/gA3/wAdrv6KPrNXuH1el2OA /wCFd3//AEHLb/wAb/47R/wru/8A+g5bf+ADf/Ha7+ij6zV7h9XpdjgP+Fd3/wD0HLb/AMAG/wDj tJ/wrq+/6Dlv/wCADf8Ax2vQKKPrVX+YPq1Lsef/APCub7/oOW//AIAN/wDHaT/hXN9/0HLf/wAA G/8Ajteg0UfWq38wfVqXY8+/4Vzff9By3/8AABv/AI7R/wAK5vv+g5b/APgA3/x2vQaKPrVb+YPq 1Lseff8ACub7/oOW/wD4AN/8do/4Vzff9By3/wDABv8A47XoNFH1qt/MH1al2PPv+FcX3/Qdt/8A wAb/AOO0f8K4vv8AoO2//gA3/wAdr0Gij6zV7h9Xpdjz3/hW97/0Hbf/AMAG/wDjtH/Ct73/AKDt v/4AN/8AHa9Coo+s1e4fV6XY89/4Vve/9B23/wDABv8A47R/wre9/wCg7b/+ADf/AB2vQqKPrNXu H1el2PPf+Fb3v/Qdt/8AwAb/AOO0n/Ctb3/oO2//AIAH/wCO16HRR9aq/wAwfVqXY88/4Vre/wDQ dt//AAAP/wAdo/4Vre/9B23/APAA/wDx2vQ6KPrVb+YPq1Lsed/8K0vP+g7B/wCAB/8AjtH/AArS 8/6DsH/gAf8A47XolFH1qt/MH1al2PO/+FaXn/Qdg/8AAA//AB2j/hWl5/0HYP8AwAP/AMdr0Sij 61W/mD6tS7Hnf/CtLz/oOwf+AB/+O0f8K0vP+g7B/wCAB/8AjteiUUfWq38wfVqXY87/AOFaXn/Q dg/8AD/8doPwzvD/AMx2D/wAP/x2vRKKPrVb+YPq9Lsedf8ACsrz/oOwf+AB/wDjtH/Csrz/AKDs H/gAf/jtei0UfWavcPq9LsedH4ZXZ/5jsH/gAf8A47Sf8Kxu/wDoOwf+AB/+O16NRR9aq/zB9Wpd jzn/AIVjd/8AQdg/8AD/APHaP+FY3f8A0HYP/AA//Ha9Goo+tVf5g+rUux5z/wAKxu/+g7B/4AH/ AOO0n/CsLv8A6D0P/gAf/jtej0UfWq38wfVqXY84/wCFYXf/AEHof/AA/wDx2j/hWF3/ANB6H/wA P/x2vR6KPrVb+YPq1Lsecf8ACsLv/oPQ/wDgAf8A47R/wrC7/wCg9D/4AH/47Xo9FH1qt/MH1al2 POP+FYXf/Qeh/wDAA/8Ax2j/AIVhd/8AQeh/8AD/APHa9Hoo+tVv5g+rUux5x/wq+7/6D0P/AIAH /wCO0f8ACrrr/oPQ/wDgAf8A47Xo9FH1qt/MH1el2PNz8Lbo/wDMeh/8AD/8dpP+FWXX/Qeh/wDA A/8Ax2vSaKPrVb+YPq1LsZPhb/kUdF/68IP/AEWtW9O0+HTLZ7eBnZXnmuCXIJ3SyNIw4A4y5x7Y 61k6Jdvb+FtChhjWSZ7CEqGbaMCNcknBq79s1PtZWv8A4EH/AOIrnlLVm0U7Irp4U04MfM86WNo7 2J43I2st1KJZQcAHquB6AnOTzV3TNMk04S+ZqV9fF8AG6ZTsAzgAKqjv1IJPcmovtmqf8+Nr/wCB B/8AiKBeapn/AI8rX/wIP/xFTzjsamR61BfWUOo2FxZXK7oJ42jkGcZBGDVWO/ukkT7VbRRxO4QP HKX5JwONo71pVSdxMxo/DlpHosOmGa4dI7mO6aZ2BkllSYTbmOMHLrzgDgnGOMIfDdsLOKCK5uYX hvZr6GdCheOSV5GfGVKkYldcEHg+vNbXOOlNJxj+lAjBh8JWsGqw3y318Vgu5byG1Mi+SkkqyB8D bkgmVm5JwemASDTi8AadHaSWpv8AUHgbT59ORGePEUMu3cFwg5GwYY5J7lq6ztRTGU9R06LU7VLe ZnVEnhuAUIB3RSLIo5B4ygz7Z6Vn/wDCKacDeFDMpur2G9chx8rRyLKFXI4UupYj1d+RnjcopAc9 D4QtINWjv0vb391dy3sdvuTy1lkV1c/d3HPmMfmJx0GBxVu20JLTUmuoL68SBpHlNkHXyfMfO5vu 7uSScbsZOcZrWooA52Twbp8ukW2mtNdeTb6TLpCMGXcYZFjVmPy434iXBxjk8elubw9aTfbN0kw+ 138F/JhhxJD5O0Dj7p8hM9+TyOMa9FMDJttCSz1JrqG/vFgaR5fsQZRCJHyWb7u45JJwWIyc4rVx S0UgEKhlKsAQRgg96wbfwhp9t4d1DREluTb38bxSyM4MgRk8sBTjGFQBRkHoM5Oc79FAGTJoSHVm v4b+8txJIss9vCyiOd1AALZUt0VQQGAIAyDWXL4B0qa51mc3F8G1RcMolGLclgxaLj5SXAYk55Ar qqTPsc0ARWttFZ2kNrAgSGGNY41HZQMAfkKlxS/56UA9e2PWgLmJf+G11Fpo59V1H7DPkTWIdDHI D1UsULhT6BgMcdKlk0JDqzX8N/eW4kkWWe3hZRHO6gAFsqW6KoIDAEAZBrWooAyIfD1pD9j2yTH7 Jfz38eWHMk3nbgePujz3x34HJ5zDpnha20vUYLyK8vJBbW8lrbwSupjhiZkbYoCg8eWoBJJxwScD G7RQBnvo9pLf3t3MplN5ax2s0T4KFEMhHGO/mtn8PxrXHh5ZoLRY9Sv4Lm0Ro47tGRpfLbG5SWUg g7V5Iz8oOc81s0UAclrmgTanBp+jZvZUjl82bUpZkyUO4SJxyS6sy4ChQGyD8oFdWoAQBQAAMADt 7UpHX0pR05oATFFLkZ6ikoAKKKKBhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFA BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAF FFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUActo4H2Dw4do/5BQ7dtsVV9Y8Rrpl2YRHuJdlVI4A5wqxsSS0iAf6wVNpmP7M8OZUMP7LBwR7Q 1yHjHQb/AF7UXNhp6XYt53DAlcDfHCQfm/3SKUEnVd9hNtQRrP46CDLW04/7dIv/AJIp1n47iur0 W6RukvlySASWyKCEQueVmYjhT2NcA3w98VsoEWiqijoBPCAP/Hql0nwZrui30moX2nJDBFbz72Es bHmJ1HQ56n9a3dOFmZ88rns1+MwQAgcXEGOOceamD9a1ycAk9qwrsgpCQPvXEDZ9/NXitLVYZLnR 76CE4lkt5EQ+jFSBXNSV7mktji9X8VXN5dPBp8pgtlyFdMb5cHk57LjOO5AyCKqtc6xpzLKb24DM A4EkhlU/UHOB9MH3rmIlgtbkSxQRIhA8shQMJ2HtySMV0XiC6gjh0/bGiJLYRyMEUKPm74H0xXt+ xhHliup5rqyldvodroGuDWbYllWO6hIWZAc8HkMPUH9CD6VsivOvANqf7ZnuPLVWFvtlIHUlhtBP fGHr0WvNrwUKlkdlGbnC7I4OYuTnDMP1IqSo4P8AVH/fb/0I1JWKNiAzSfaDGsYZQoJOfXP+FPSZ JMhThh1VhyPwqNR/pUxHGUQ/+hUkyQNhXjWRuy7cn8PSmBZ9f0oqKBXjQh2HX5V9BUtICC7u4rGz mu522wxKXZsfwgZqjbeILW5ufs4ivIpSjOFntJIshcZxuUZ6im+KEDeFNXUjObOX/wBANQzRZ8R2 o8v71tdnGOvMIpgPtPE9jeSW6Il4ouT+5eW0ljR8jIwzKAeAT16VtVx2mxo2leEt8a7f3GCV4/49 JO/f0rsaACsZYfty+bNJLzNNHiOZ4wAjlR90jsBWzWVZ4FixPa5uf/Rz0IDn38Q+FItYGkPryi/M oh8j7dNuDk4wfn65rcjjNpfWgjeRlmm8tg8zyDHlu2RuJ7qP1rz6Tw/4dOqz3zLD/bTauk20jL7R OpJAI6bM9Oua9DkH+l6aSAGN0c8Y/wCWUtVZCNeiiqeqabDq+mz2Nx5ginTYxjcow7ggjkVAFzPT r+VFcDb+HfFV/ejTNf1KKXRLJ1aKS1BjuL7H3RKwOF24GduM13q/dHTp26UAMnJEYwcfMo/UD+tS d6juP9WP99f/AEIVJ3oApanJLDabon8tjLEm/AyAzqpxkHnn0rl/DOt3viBJ/NmvbR48FYy0LOyk A7sGIYHI9evuM9Lq+BZKT0+0wdB/01SqOnavperXjpp4WZoY1LSJHhUyOF3euD0H6840gvdehL+J amT4n1q88PxQGKe8vWk3M8aGJWVVGS3+pPof85x0+lyyzWO6Zy7rLKm4gAkLIyjIAHOAO1UNS1fS dGukOoyR2rSRsyyvHwwHJAIHXHbqeAOoq3osaR2EixoEBurlsAYyTM5J+pJJz3zRJe6tBr4nqaFF FFZlhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUU UUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRR QAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAcnp6gab4d5Ixpgxhj/djq LUtBtb9ZXSSaC5fH71JpB0wOQHUHgYrgV+NnhKxsbXTLqy1sXVhGLdpYIoSMqArY3PyCV7ioz8cf CGfu+J/+/Fr/APFVlUhPmbiOElZJnUr4MulTH9uXDEDGS847eom5q/YeFYrZZFvb26vQx4DzzADP sXINcP8A8Lx8IcfL4n4/6YWv/wAVR/wvLwhz8vifJ/6YWv8A8VStUGnFanqFwi5gCliftMDH5j18 xa6Q9D16dq8i8P8Axb8K6vr9hp0MWuNcXMyQxm6hgEYYkYJ2tnrjsa72bxZbJe65ZQ6fqFzd6QsL SwQRqzzLIMgxjd82Oc5x0PWqpQcb3IlNS2MjWfAwubtruxkRWcktA7tsbJJyPTr0qg3grWbxkW5k hCqoRWe5kl2r/sjC4/WtOb4l6Pb+FpPEE9nqUVvDe/YbmB4VE1vJnnepbGBkdCTyOKZ4x+KGg+Cb y0tr+G9uGuofPjazRHXbnAOSw6+2a61iKiW5zujTd2zf0DQ4tCsvs8TMxY7mZ2LMxxjJJ5/CtbNc F4U+L3hnxfrA0q1F5aXTrmIXiIolI7KVZue+DiqGs/HHw3oWtXmlXum6z9otJmhfbDFtJBxkZkHB 6j2NZSbk7s1jypaHpMSFExk/eY/rUleR/wDDRHhH/oHa3/34i/8AjlIf2ivCI/5h2uf9+Iv/AI7S KTR6w1urSGT58kAEBiAQKekaoMKMZ6nufxryP/hozwh1/s3XP+/EX/x2j/hozwh/0Dtc/wC/EX/x 2gZ69iivIf8Ahozwh/0Dtc/78Rf/AB2j/hozwh/0Dtc/78Rf/HaLAes3FvFd201tOu+KZDG65Iyp GCOPY1UtNFsrO6+0x/aXmCFA011LLhTtyAHY4+6v5V5j/wANGeEP+gdrn/fiL/47R/w0Z4Q/6B2u f9+Iv/jtAHpNn4d02xlgeBLkfZ/9Sr3cronBXhWYgcMR0rVryH/hozwh/wBA3XP+/EX/AMdo/wCG jPCH/QN1z/vxF/8AHaLCPXqzm0vAP2e8ubdWZn2rtYAsSTw6k9ST+NeZf8NF+EP+gdrn/fiL/wCO 0f8ADRfhAH/kG63/AN+Iv/jtAHfSaHqD3HmHVyQe5tYs4/KtCDTfKeKSa6muXiO5NwVQpwVyAoHZ j+deY/8ADRnhD/oHa5/34i/+O0v/AA0X4R/6B2uf9+Iv/jtGoXPXe1GOa8i/4aK8If8AQO1z/vxF /wDHaP8Ahorwj/0Dtc/78Rf/AB2kF0eubRzwOeaWvIv+GivCP/QO1v8A78Rf/HaP+GivCP8A0Dtb /wC/EX/x2gLo9ZlTzFxk/eU9fepK8i/4aK8I/wDQO1v/AL8Rf/HaP+GivCP/AEDtb/78Rf8Ax2gL o9UvbYXcBiLyIN6sGjPIKkMDyMdQKwdL8IDQo5YtL1G4gjkbcyHa4/Jga4n/AIaK8If9A7W/+/EX /wAdo/4aJ8I/9A7W/wDvxF/8dpptC0O01TwkdcSOLVNUupo4iXCqVRcnjkKBk479sn1NdBZWq2dq IUdn+ZnLMQSSzFieAO5NeV/8NE+Ef+gdrf8A34i/+O0f8NE+Ef8AoHa3/wB+Iv8A47Q22C5UeuUV 5H/w0T4R/wCgdrf/AH4i/wDjtH/DRPhH/oHa3/34i/8AjtIrmR65RXkf/DRPhH/oHa3/AN+Iv/jt H/DRPhH/AKB2t/8AfiL/AOO0C5keuUV5H/w0R4R/6B2t/wDfiL/47R/w0T4R/wCgdrf/AH4i/wDj tAcyPXKK8j/4aJ8I/wDQO1v/AL8Rf/HaP+GifCP/AEDtb/78Rf8Ax2gfMj1yivI/+GifCP8A0Dtb /wC/EX/x2g/tE+ER/wAw7W/+/EX/AMdoC6PXKK8iH7RXhEkD+ztc5/6YRf8Ax2pP+GhfCX/QP1r/ AL8xf/HKHoJySPWaK8m/4aF8J/8AQO1v/vxF/wDHKP8AhoXwn/0Dtb/78Rf/AByi4cyPWaK8l/4a F8Jf9A/Wv+/MX/xyj/hobwl/0Dtb/wC/MX/xyi4cyPWqK8l/4aG8JD/mHa3/AN+Iv/jlJ/w0P4S/ 6B2t/wDfiL/45QHMj1uivJP+Gh/CX/QO1v8A78Rf/HKP+Gh/CQ/5h2t/9+Iv/jlAcyPW6K8k/wCG iPCP/QO1v/vxF/8AHKT/AIaI8I/9A7W/+/EX/wAcoHzI9coryP8A4aJ8I/8AQO1v/vxF/wDHaP8A honwj/0Dtb/78Rf/AB2gLo9coryL/horwj/0Dtc/78Rf/HaP+Gi/CP8A0Dtc/wC/EX/x2mF0eu0V 5F/w0X4R/wCgdrn/AH4i/wDjtH/DRfhD/oHa5/34i/8AjtFgueu0V5F/w0X4Q/6B2uf9+Iv/AI7R /wANF+EP+gdrn/fiL/47RYLnrtFeRf8ADRfhD/oHa5/34i/+O0f8NF+Ef+gdrn/fiL/47RYLnrtF eRf8NF+Ef+gdrn/fiL/47R/w0X4Q/wCgdrn/AH4i/wDjtFgueu0V5D/w0X4R/wCgbrn/AH4i/wDj tL/w0X4R/wCgbrn/AH4i/wDjtFguj12ivJP+GiPCP/QO1v8A78Rf/HKT/honwj/0Dtb/AO/EX/x2 kF0euUV5H/w0T4R/6B2t/wDfiL/47Sf8NFeEf+gdrn/fiL/47TC6PXaK8i/4aL8I/wDQO1z/AL8R f/HaP+Gi/CP/AEDtc/78Rf8Ax2iwXPXaK8i/4aL8If8AQO1z/vxF/wDHaT/hovwj/wBA3XP+/EX/ AMdosFz16ivIv+Gi/CH/AEDtc/78Rf8Ax2j/AIaL8If9A7XP+/EX/wAdosFz12ivIv8Ahovwh/0D tc/78Rf/AB2k/wCGi/CH/QO1z/vxF/8AHaLBc9eoryH/AIaL8I/9A3XP+/EX/wAdpf8Ahovwh/0D tc/78Rf/AB2iwXPXaK8i/wCGi/CH/QO1z/vxF/8AHaT/AIaL8I/9A3XP+/EX/wAdosFz16ivIv8A hovwj/0Dtc/78Rf/AB2j/hovwh/0Dtc/78Rf/HaAueu0V5F/w0X4R/6B2uf9+Iv/AI7R/wANF+EP +gdrn/fiL/47QF0eu0V5F/w0V4R/6B2uf9+Iv/jtH/DRXhH/AKB2t/8AfiL/AOO0BdHrtFeQ/wDD RfhD/oHa5/34i/8AjtH/AA0X4Q/6B2uf9+Iv/jtFguj16ivIv+Gi/CH/AEDtb/78Rf8Ax2j/AIaL 8I/9A7XP+/EX/wAdosFz12ivIv8Ahovwj/0Dtc/78Rf/AB2j/hovwj/0Dtc/78Rf/HaAueu0V5F/ w0X4R/6B2uf9+Iv/AI7R/wANF+Ef+gdrn/fiL/47QFz12ivIv+Gi/CP/AEDtc/78Rf8Ax2j/AIaL 8I/9A7XP+/EX/wAdoC567RXkX/DRfhH/AKB2uf8AfiL/AOO0f8NF+Ef+gdrn/fiL/wCO0Bc9dory H/hovwh/0Dtc/wC/EX/x2j/hozwh/wBA7XP+/EX/AMdosF0evUV5D/w0Z4Q/6B2uf9+Iv/jtH/DR nhD/AKB2uf8AfiL/AOO0WC569RXkP/DRnhD/AKB2uf8AfiL/AOO11vgr4k6L47j1GTTYL23TTwjT NeIijD7sEbWbpsOc47UAdjRVJb+Z0Dx6bdvGRlWzGMj1wXB/MUn9oTDrpl3/AN9Rf/F1N0Ox8P6z /wAhzUP+vmT/ANCNUqva1/yHdR/6+ZP/AEI1RrV7ma2CiiikMvQzSW88c8MjJLGwdHU4KkHIIr0y D4rQap9nn8TafePqtuhjTV9Ju/slwyZztYKNpH8uw5NcF4egguvEenW9zAk8ElwivC83kiQZHyl/ 4c9M+9ehXvhLS5L54fsdrBf3mkzm108I8EiXKOm0kNNICWXdt+YA46Z6yjJXOf8AFHjsaroyaBo9 i9ho4mNxMJpvOnupicmSRyM59h+vGOPknmkjjjkld0iGI1ZiQgJycDtzXqWn+GtIj1VbFtGhvbmD TrT7XEjmVoZmyZT5YlTecbQSG+T0qeDwjYW+hTfYdHstauk1G7gaeOOSRNibPLx/pKbRy3Pz5x14 5AszyNWKMGVirA5BB5FWb7VL/U3WS/u5bmQADfK25jgADJPJ4AHPYAdq6Hwl4fin8c6XpmqJDNBc oXKCT5SDGzKCQRg5xxmtTQ/h9cSxTWWtxpp88t7ZRRySDc6xyNIrFcOB/CM5B7dKASPPD9aY44ru LXwImo6Gt3Y3xlvZLJ7mKzIUFilyIWGSemzL+3uOat6v8N7eysdcmg1Rnn0+aVbaBlXdexxld8i/ NwEDcjDZwcdDgRSPOTRQaOaosKKOaOaACijmjmgAoo5o5oAM0tIaMEUALQKOtGKQhfxox70c0ZNA hRRik59vypefakAUUc+1FABS0n40YoAWikooAdmkpKXNAC0UmaM0CFopM80ZosAtFJmjNAC01jS0 xs5oQ0Oj5cVY/Gq8WTIKsVMtyZ7hRR1pOgqSAJpCaDmg9KYxDzSY9zS8+opDkdx+VMYH60hoJpOa Yw/GkzQT70hpjAmkz70ZptMoWiko5pjCilo5oASilo5oASil5owcUgEpaOaXFAhKeFxQFxzS0mxX DOKafrSn600k0Ag/Gko5z0o5qh2E/GijmjmgYUUc0c0AFFHNHNABRRzRzQAUUc0c0AFFHNLzQAlF BooELQRSUtIAoo5pOaY7BRQM0vNACUUc0c0ALRSYNHNAhe1FJg0UALRSUuaQBRSZozQAuKQ0uaQ0 wEooooGFe4fs/wD/ACBPG/8A17Qf+gz14fXuf7Pah9J8aKejQQA/98z1MtmOO57hrttr99LHb6Tq EOmQKnmSXRiE0jtniMI3AXuTnPYY61PZPePZxNqEUUV3jEqwuWTPqpIBwevPTNVh9tZedTuef9iL /wCIppiuj/zErn/viL/4isnUTLUbHxfrf/If1H/r6l/9CNUKv65/yMGpf9fUv/oZqhXQ9zJbBRRR SGdJ4O0u31vxlpGmXgY211dJFJsbB2k9jW/qfhKKZrhotLuNGhsrOS7kabzpDMqyRoQvmRx8jzM9 x9K4eKWaGVZImKSKcqysQQfUGrE2p6jcjE17cSjaV+eZm4OCRz24H5CpMzuV+GMkixWcd6Pt7am9 o0pB8kRi3WZTgDdvIJGM4zx71nXfw/uLOINLqERZ7u2s0UQuvzzIzqTuAIA29cHggjNcob69JP8A pMx3MrnMrcsOh+o7GpI9Tv47pLoXUrTLMs4Z3LZkXoxznJHvSDQ6+9+Gt3YtcNPeGKG2S6aTzrcp IwtygZo1zhlO9drEjPOcY5mi+G1xqxgGnSRxSNp9rOsb7iJpJYi+A5ARSSBwxHU4zjni7zVtRv7u W6uruWSeXcHYuRkE5IwOAMnoOKjTUb6IMI7udQ6CNgsrDKDop9vagNDodY8D3Wj+GLXWpb2CRJ44 ZPLSN8ASgsAH27SQByMjkHGcGtVPBlrd+DluoLGW2uls47p7y8uHSNt0gUlcRtGVwwABdXzng4we Ea5uHt0t3mkMCElIy5KqT1IHQUG8ujaC1NxL9mB3CHedmfXHTNNDR3N38J7y01GSzk1WENHDLI7G 3kUZjljjIGQAwJkBBB7HIHGcu18Btf6Lbava6pbixurhLOJ7hdjC4aXYEYAkDCfvCQTxXMPqF6zB mu7gsEEYJlbhBjC/TgcVF50vkeT5j+Vu37Nx27sYzj1xVFo7PVfhzcaNBfz3mop5dlb+e4S3cMf3 4hwAwUHls5B7EVxFWJb68nLma6nkLqEbfIx3KOQDnsMdPaq/NABRRzRzQAUUc0c0AFFHNLz/AJzQ AlLmk5owaAFpaQGikKwufaikzRnpQAufajNIOaUE0AGf85pcmkJo5oELzRSZNGTSAWik5oyaLAOw aKbk+lGT6UWCwveikyaMmmFhaMmkGaTNFgsOyfamnrRmj3oGh8A+fPoKsVDAOtTc1EtzOT1EpKdT e1SSIaQ+wpTSHINUMQ59B+dJz3pTn0H50hzTKEpDS0lMYhNIadikwaYxtFLijafSi47jcUYp4Bpc UXC5HilwaeBS4ouK4zBo208ClxSuK4zFGKfg0lFwuNxTguOaXB64pTnvj86VwuNoNKaaaYIQ02lN NJplIM0UGjmmMKKOaOaACijmjmgAoo5o5oAKKM0c0AFFHNLQAlFFFABRRS0hCdKKWk5pjDvRS80U AJRS80nNABRRzRzQAUUc0c0AHaijnFHNABRRzRzQAUUvNHNACUMc0uCaHGMUhDaKKKYwr3T9nj/k GeM/+uNv/wCgzV4XXuX7P0gh0bxtKwJVLeBjjrgLPSkrqyGtz3NfuilrE/4SONFw1hdjHvF/8XTP +Erth/y5Xf5x/wDxdZLDVv5Q9tT7nyPr3/Iw6n/19y/+hms+tHX/APkY9U/6+5f/AEM1nVu9yVsF FFFIZZyfTvRk+lJnnnP5UZ9j+VZmVjS8PIk/iXSoZYg8b3kKujgFWBcAgjuKk8US58TajCsMMUcF zJDGkMKRqFVyBwoGT7nmqFjLcw6hbS2Qc3SSq0IVNx3gjbgc5OccVa1uTVJNQMur2rwXbrvIe0EB cEn5iAq5JOeeppjM3cf7ppc+360ZA9fyoz9aAErofCFjbXV7qFzcwrONP0+W9jik5R3TG0OO689M jOPTIPPVa025vbTUrefTXlW8Vx5JiGWLHjAHfOcY75xQho2fFNla/wBjaJq0SQLPerPHMbZNkUhi cIHVMDaWHJ4H0HNYGm339m6hFd/ZbW68vP7m6j3xtkEcrxnrn6gVY1u51O4vyNWWVLmJFjEUkXle UgA2qEAAUY5wAOue9NmuNT164tLcrLdzwwLbQRxRZYRoCQAFGTgZ561ZaOi1MWyWcOha4lnp+rre CWe6hs4wIIDGcIfKUbmOQwAyPmGWBBxtw6JoGtS+DYbawaCxumvBJkjzphH0MjAdTt5A6biARwa4 rXodfnun1TXLO8jlmZVaaa2MSsQuAOgGcL+lW7fVfFDQ6RFaRz7YGZtOMFkoJK537Sq5cddw5B/i zQMZJJdyJD4ol03THs1u2txbLCscQcLvAZFwWGG4JJztw3GM7FikuqeHdPvotCs77Uhq7QRhbaOO Nl8oNsdY9m4Z+bJGAFOSAcHPmvPGFm9kTZ3liI7ndbrFYC3VpmGPuqoDsQMYIPGR0JptxrPirRpb SSaKXTfLkeWBPsCQIXK7WbaECsdpxkg4z70CNfRodJ1/V9J0K+t4Jrz7TJJcXNnFHAmwRkiEGMAS DcvL4GOdpIIas/WYbXUfBsWui3s4btdQNqfsUXlRsjR+YAVwPmUkrkdQOrcGqGp6r4gtoYrC9jew VJRdxxJZJakOMgSDaqnPUZ9vaofEF7rt1cxJriTxSIrPHFLb+SAGYlmCgAZLZy2MnHJ4oA0vEaxS +EPDN99mtYrm5+1ec8ECRb9sgC5CADgVzEUhhmSVQhZGDAOqsMg9wRgj2PFbGvT689vZ2+sWkttD D5n2aNrJbdRkgvtAVQecZ+vvWL+dAHb+OvD0Ca1rN3pcaRwWDQC5gWJYkiEiDaUwfmBIOeBgsOvJ FHWVih8IeE76K2tUuX+0eY6wIPM2SKF3jGGwB3znnOcmqF54k1zXN9rNN5z3cieYsNuiPOy8IGKK C+M8A57e1MvtV1iKK00u/jWNdPYNDbzWUatGeDyCuSDwSDkNwTmgDoPiB4eg07V7+/ijWC1eVIbe G1iUxhhHGWD4I8sncSBglsE4AwTD4hOm6dpuj6cdOgWK70y1uWuY4wZo5GYl3zkFwVyNrHH3cYxW Xe6t4iurK8vbv7QbTVWjWec2wVJjH9wBgMAjafu46HNVL7X9Q1Oa0lu2gka0UJCBaxqFUEEKQFAK j+6cjk8cmgDV1Dwlb2Wsvoq6sraotzFCsUkDLHIJCNrK4LcgMpIIGMnBbHK3Xhazhg1aaHUp5F0i 5SC8D2oQkM5TdHiQ7iCOh28d6xtQ1vUdU1NdSurjN6u3E0caxtleh+QDkcc9eB6CrFxr+sasslmz q5vJVaRLe1jja4fPG7YoLnJzg55OetAGtqfguPTF1UvqTu2lSwi6At+DHKflZPn+ZsYJU7Rkkbjj JZ4x07StPt9EFgZVkl02GUqYQokDFiZGbeTuJ/hwQB0OBis/U9b143Gp2+pySxz33lfbI5YFjZtg BTI2grgY6YzRcal4gk8OQw3Buv7JbbEkrQ4WQIWKp5mMsFO7CkkDHA44AKv2W3/4R77X5F99p+1+ V52wfZtmzO3d18zPOPSs+pftc/2T7J58v2bzPM8nedm/GN23pnHGaPs1x9k+1+RL9m3+X52w7N+M 7d3TOOcUhHca7oEOqLbzW3kWtxF4ei1GRIrdUjmILeYTtxhuRj5SD04ph0OLSvBviW0vYon1Oz+y O2bdCYDIwOElBLNlcAjgA5xnOTzsvinWJpnka6UM9mbAhII1HkH+AALgD3HNWNS1rxHb+ba6oJYn uYBHKtzaKrzIOFZyVy5G3hzkjBwRk0xkt94Sey0zUpmnlS80zyPtltNEoA83psdXYNzjqBwfXisr 7Nb/APCPfa/IvvtP2vyvO2D7Ns2Z27uvmZ5x6VoSa14jvNMurlxLNZPGLe5uDaKyvjaF8x9vzMPl wzHcM8EZ5xDdXH2T7J58v2bzPM8nedm/GN23pnHGaBEVd14l0OLULewuLCKKO8j0OK/uYYrdIo3T J3uCpA3ZP3do4HBzgVyUmj6pFZC9l028S0KhhO0DCPB6HdjGDkY+tW5fFGsS2QtGulEQthablgjV /JHSPeF3beORnnnOaANA+EcPqNm1zPDqmn2Zu57eaBBHgBSwEiyNk4bj5ee+KhPh6wi0rTb+61dr eLUIpDCWtSwWSMkMr7WJC52gMAxOTlRjmv8A8JbrXm+abmNpTH5TytaxM8qbdu2RiuZBjsxPIB6g Gql1rd/e6Za6dO8bWtp/qEWBFKevzAA89TzyeTzQOxpnw7YRaVpt/c6u1vFqEUhhL2pYLJGSGV9r Ehc7QGAYnJyoxyaVZxzeCvEF0PIMsDW+4S2wZ1DPgGOTd8pPO4bTkAc+mZd63f3umWunXEkbWtp/ qEWBFKevzAA89TzyeTzRaa3fWWmXWnW8ka2t1jz0aBGL46fMQTx1HPB5GDQBpz+HbCwisF1HV2t7 i9sxeR4tS8KBt2wMwbdk4GcIcZ79aD4dsItK02/udXa3j1CKQwlrUsqyRkhlfaxIXO0BgGJycqMc 1bbxRrEEMMcd0oaCIwQzGCMzRocjashXeowxAweM8VDd6zfXumWunTyRta2v+oRYEUp6/MFB56nJ 5PJyaQrlWAfJmuutfB0dxc6bYNqDJqGo2n2qFBADEAVZlDPuBBwvOFOM965SIYQDn1rYh8S6tBFD HHcqGhiMMUphQyxocjashG8Dk4weM8YrO6vqY3V9SwfD9jFpmnX1zqrQR38UhiLWpYLIhIZX2sSF ztAYBicnIGOeerRutYvrzTrXT53jNra/6lFgRSnryADz1PPJ5PNUMUrhc6Xw2kFv4d1/VWs7a5uL P7MIhcxiRMNLhhtPHIGM9R2IpfDK2l7L4m/0GAW/9mXFxBFIokMJH3drkZyAxGRjPBPQVj22s3tl pt1p8Dxra3X+uRoEYv6fMQTx1HPB5HNJpmsX2kfaPsTxp9oTy5d8CSbk7r8yng9x3wM9KpMq5raX 4O/tP+wP9O8v+1/tH/LHPleVn/a+bOPbHvVHRdCt9Xt3Iu5/tas3+i28MbuVC7sqGkQsT83Chj8v PUVHZ+IdW0+CCG2uti27mSAmNWaIkgttYglQccgHB5yDk5dB4l1W1WNY5YdsUrTQh7WJxCzHJMe5 TsGQDhcDNO6GmjZ0vTLXVfBVhDMsUE0uti0W6jt0aQK0ZIBPBYbm7ngfQCsKHSY4dQ1ayvYbueSy imANioYLIhxufI4j65PB6Uq+ItWWCCAXWVhuvtikxqWM2Sd7NjLHn+In9KqvqN691dXX2mVZrvf5 7RnZ5gY5YEDAwT26UXDmKOK6zwvpaW15o97qBXyNTufIgia0juBKquofdvPyDJABALfe6cZ5fbWl b65qVtZR2kc6+VEzNDviR2hLYyY2YFkOQD8pHPPXmhMFI3tJ023ufijd2Kx2yILq5WGKa1E0PG75 Sm5cAAHGOhA4rD0HR7fWJXgkvGhuNyLDCiRky5yDgvIgyDtGMkndwODSweINUttak1iGaNL+TO6U W8fU9SBtwCe5Aycn1NMt9b1C2imhjeEwTS+c0MltG8YfpuVGUqpwccAcYHYUXQcyLmneGPtcv+ky Xdtbvfrp8UptkJ809pEMgKEDBON3cZ450tM0u1g8OeLLTU0j36fPDGLiG3SSRG8wq2wsVODtAwSO M8cnOOfEuss1wz3ryNcSiZzIisVkAwHTI+RgOAVwQAMdBhyeI9VWW+k82FjfMrXKvaxMkpXkEqVx nJz05PPWlzIOZGv4V0V9O+I8Wi6pa202PMSVJEWVGHll1IyDjOFOeD2OORWNZ6JA/h99ZvbuWG3F 0LVEggErl9m4kgsoAxjufpRB4g1W31mTV0us38md07xq5544DAgcccYwOOlNt9bv7aKaGNoTDNL5 zQyW0bxh+m5UZSqnBxwBxgdhRzIXMjX0DQoI9atr1riO70r+0Y7KKUWwcXDvztaOTG0bep5wSNu7 qMPxDEkPiXVYoo1jiS8lVEUABQHIAA7CrJ8S6yzXDPevI1xKJnMiKxWQDAdMj5GA4BXBGBjoMZ99 eT6hey3dyytPK252WMICfXCgDPr6nmldC5kVD0oC55p4XPY0Gi4XGnrTScnpTmOPWmE00NCE0wtT jSEGqRaGUYp+Kb+dMdxKKXFJzTGFFH50c+9ABRS/nR+dACUUZozQACj8KXNJQAZ9qKXFFAhKWiik AUGjNITQAUUZozTGFFGaKACiiigAooooAKKKKBBRRRQMKKKKACl69qXr0p2MUribADFNftT6ZJ2p LcS3GUUUVRQV7b8Bv+Rc8ef9ekX/AKBPXiVe2/Ab/kXPHn/XpF/6BPTW6E9j0S56t9f61mt96tK5 6t9f61mt96vaWx5T3PnHxB/yMmqf9fcv/oZrOrS8Q/8AIy6r/wBfk3/oZrNrxXuesgooopATiiii szM1fDP/ACNWj/8AX9D/AOhrUvi22uLbxXqn2iCSLzbqWSPzEK70LthhnqDjrWVa28t5dw2tuu+a Z1jjXIGWJwBk8dTUuoadc6Xdta3YiWZfvLHMkm0g4IJUkA5B4PNMCtmkopKQBXSeDLmG31DUcvsu 5NOnjsmAO/zyBtCEchiNwGOTnA5PPOelSW9vNeXCwQJukbOBkAAAZJJPAAAJJPAAJNUNHS+MJLVd J0OzUTreWy3CSJdLi4jh8z9ysnodvIHYHjgjPNr/AGhpNxDcL9psp2TzYZBujYowIDKeDgjPI60l 9ZT2MwjnVQWXcrI6ujjplWUkMMgjg9QR1BqK3t3u7hYI2iV2zgyyrGvAzyzEAfiaZSOzv303w49p 4T1WOe5tLa5F7qDw4BeVovlSPkfIAVBJIJ5xt4rQ8Z3tyfC/hnV7aW8t5FacQyR232YRo33QNrHY NoAUZO5cnPrysPg/W7oQm2t4LhZpTCjQ3kMgLhC5XKuQDtBPP9aoz6NeQeWM20zyyCNI7a7indmO cAKjE/p/OmUdbNaajp15ZeBtHmZdSW5+1z3YkMYWVouQhHIRYyck8sc4A6HT0RG03xJomjnTrmDR IbtpPtV/bNH9qujEwVxuGF5ACKOeATk9OCh0HULnVYdMtkguLuZSyJDdRSAgAk/MrFQcA8E5/Pl6 +HdSluILeBba4mnk8uOO2vIZmJwTyEckDAOSeB3NAHZaPpum6Zq+k6/qyXmnyyahJFJBqzh2c+WW WbJRSAHIySCASDkYrK16RYfBUFnfC8XU/wC0DMkd+h84I0Q81hkZCNKWI9cdyDjn7jQNSt4YZvIW aKeXyI3tZknDSddmY2bDHIwOp7VUvLOWxmEUzwMxXdmG4SUY57oxGfbrQB1Hie1uLLwR4Ut7qCWC ZPtm6OVCrDMgIyCMjgiuP4rQ1HRb7S7e2uLqOIQ3W/yZIp0lV9pw2CjEcEiqFAh0UTzzJDEjSSuw VERclieAAO5r1LxVo2maxrfiN5x9kuLSewBvGkyAJdqNlThQgXB9cgndg4HlVFAHpWu6THF4Tm0e 1tPsEdvriIXuHbmMoYxcSEjhWYH5gAvGBnHNDxX4asLHQZrm1s5ILyzvvImAheNWhIIWTa8kh2Fl IV8gHJGMiuEqZ7d47eGdmiKS52hZVZhg4O5Qcr7ZAz2oGWruZ30fTY2t7CNI/M2ywlfOkywz5uCT x0XIHHTNUoonnmSGJGkldgqIi5LE8AAdzVu70m9sIVluI1VdwRgsquY2/uuASUbg/K2D8p44OKNA j1XxVo2maxrfiN5/9EuLSewU3jSZAEu1GypwoQLg+uQTuwcCprukpF4Tm0e1tPsEdvriIXuHbmMo YxcyEjhWYH5gAvGBkg581ooGegan4TsLfwzf7IN+o2cEE8VxbRuI7lCB5jIWdhIqhgSyqmDjscUy 6h1e8+Elus1nOVt9QDxBbbaFtxCTv4UZXLElz1J5NcEasy2N1DZW97LCyW9wzrDI3Acrjdj2G4DP TOR2NAitmvUNX0m0vreG0vrSVLyz8KpciQuVaN4zwu3GOpYNnPbG0gk+X0UAem3ukQaT4S8R6ZY2 zSL9mtJkvAWY3wDh5JEH3diBwPlzgdSc1S1PwnYW/hm/2Qb9Rs4IJ4ri2jcR3KEDzGQs7CRVDAll VMHHY4rz+pvs7/ZPtO6Ly/M8vHmrvzjP3M7se+Mds0DO31Gw1zw/p16z2moXur31sU1C+eN5I7eA gExhyCGbAG58kKBgdyOC4qb7O/2T7Tui8vzPLx5q784z9zO7HvjHbNQ0CDjNHFHeigA4oopRyQKA HqML0pwHI4/SpAvFOjX5xWbkZORKBgAYpCO9S4FJisrmFyEkA9/yNBPbn8qlxRii47kXbNHUVJij FO47kePakxUu2jbRcOYixRipdvvS7fpRzBzEOPajj0Pr0qfbS7aXMLmIOB2P/fNKFz2qYDFOx70u YTkQ7KULUmB6j86XHvRzC5iLbSEYFS7abii40yEke/HsaO+OakxmkbAHJqrlXGEjFMPNPyPUfnQR TKRCaQ1KQKaRVXKTIzSGn0jYHcUykMpDT8570GqGRmkqSkIouO4zikp+KMUx3G0U/FH40CuMop+K OPWi4XGfhRTuPWjIoASincetHFADaQ084ppNACUlLS0xiUUGikAUUtJQAUUoooASiiigApKWigBK KXtRQAlOx2o9hTgAKBXAClpaARjqKkQZGP8A61Ml7VJn3FRy9RQtwW5HRRRVlhXtvwG/5Fzx5/16 Rf8AoE9eJV7b8Bv+Rc8ef9ekX/oE9NboT2PRLnq31/rWa33q0rnq31/rWa33q9pbHlPc+c/EX/Iz 6t/1+Tf+hmsytPxHx4o1b/r9m/8AQzWZXiM9ZBRRRQBNRRilqCDR8PSxweJtKlldY40vIWd3OAoD gkk9hUviiMDxNqMqywSxz3Ms0bwzJICrOxHKk4PseapaZZf2jqtnY+Z5f2mdId+3O3cwGcd+tTa1 YW+matcWMFxLcfZ3aKR5IRH86sQcAM2Rx14+lMDPpaSikAV0PhC+trW91C2uZlgGoWEtlHLJwiO+ Npc9l4684z6ZNc9Wjomjya1evCJUgggia4uZ2BIiiX7zbRyx9AOpPbqGho1vF2o282l6PpyNbG5t fPmnFmQYIzM4cRoQcHaODjIHTJ5rnr+x+w/Zv9Ktrjz4Fn/0eTf5e7PyPxwwxyO1W9Y0X+zbeyvY J/tNhfRl7eYpsYlSA6smTgqeOCQex9Kmm29ndahFDfXv2K2bO+48oybOCR8o5OTgfjVFHW3+pNpn im00jw7q1nZ6fZsPs90zB43lePDSSsAwZjuK5xhRx8ozWr4evdM0240e61ibSodSXUJVElp5OFga Ar85h+UDeRy3I57ZrE0fwRZ69BaT2WrTrFPeNaHzrMKVKwtLnAkOR8oHUdfbnHtNFtNY1C20/Rrq 5nvJ5NoW5tlhRVAJLbhIx4AzjH68EA6OG4+yWGnSi+0Ww8Rf2g6w3MIh2JAYsHzPJUoAWOAWGRkn gZIgnuWstGsLhJ9Mg8SJqR8iSxe3ULAUAO8xfIBu/v8AbPbNc8LHRn1tLUaxIth8we9ksyMEbsEI GJIOF64PPIGK1bTwamsabbXWjXsk7z332IR3NusO0iMyFyQ7cAD6/wBQDqfD/iC00o6LZard6elw dQkuXNmsQihQwvEu9ogE3FjnvgckiuX1oW3/AAicH2z+zP7a+3Nt+w+T/wAe/ljO7yfl+9jG7nrj jNYN5a2Y1EW2m3jXUZbYJpoxApOSM8scL0OWI68gYq94m8PDw5d2lv8AbYrv7RaJc+ZEPk+YsMKc /MPl4PGc9KANDxIYofCHhmx+0W0tzbfavOSCdJdm6QFclCRyK5q2O27hO+KPEgO+VN6LyOWXacj1 GD9D0rV1jQ7fT9H0vU7W8kuIdQ87assAiZPLYKc4dgck+vasTigD0vU9SjneK51PVLYw/wBpQNdW Ru0voJkBG6SAfM8Q++SpxlWAz/DWZr95qct5qTza/p8mnSagHt4Z7hLvjexVlRQ5RVXrwMg4w2cV yl5o2p6dCs17pt5bRFtoeeBkBPXGSOvB/Ki80bU9OhWa9028toi20PPAyAnrjJHXg/lQM7HxXfS3 mj3ck2qweY9ym+zW9S8ilIH+st+rwjO4lTgYYDP8NMudSjttD8D3U93FcPp07PcRR3CSSonmKyDb uyPkXGO2ADjpXI3mjanp0KzXum3ltEW2h54GQE9cZI68H8qmv9I+waVpt27TiS8V2MUls8YQAjaV c8OCCDx0zQB1uuanZQaN4hVbmxmOrzxtafYzudkEzTF5h1U4kCYPPy4xgZrz+t3XPDR0TStJvGvY Llr9ZCVgIdIyhUY3gkMfmwccAg9etYXFAjQu2Q6Ppqrqktw6+Zus2Rgtr8wxtJ4O7qcfjVewS2k1 C1S9kaO0aVBM6DJVMjcRweQM9jT59Nu7XT7O+mh2215v8h9wO/YQG4ByMH1xVTigD0vWbrTH8M6v pdreW09skFtLpjzXvmSOEA8z5XciNwCQFCoSMgA44zNS1SfWvAWmo2vL5tstwb6K4um8yZvMUxrt 5LnHQ42jByRiuSn0u/tbSO7uLC5htpceXNJEyo+QSMMeDkc1pal4S1PS9CtNUubadVnaQSRmBgbc KQqlyehYk4HoByc4AM67WbrTH8M6vpdreW09skFtLpjzXvmSOEA8z5XciNwCQFCoSMgA4480q3Pp d/a2kd3cWFzDbS48uaSJlR8gkYY8HI5qpQB6rqV0sOmNNqN3F9mvPDEZMUsys012cBZDHnczfKvz 4429eOOYeYSfCqO2e8gaaPUzMlu1yhkWLYVyEzkDeScY7k9OaxL6w1swtNf2moGKzVYC88b4gHBV Mn7o+YYH+0PWh9I8vw3HqztOrSXPkpG1s4Rk2k7xL90nII29eCaANt5hJ8Ko7Z7yBpo9TMyW7XKG RYthXITOQN5JxjuT05rV1PUIZPC81vHqVm3iMWyDULpZVzcwDd+6WXo7gGPdg5YLjLYxXHvpHl+G 49Wdp1aS58lI2tnCMm0neJfuk5BG3rwTVdtLv0uJ7drC5Wa3jMs0ZiYNGgGdzDqBgjk+ooAqd6KO M0cUCCprdMvnsKhq7bRDygSASeambsiJuyHYqWFeSTSbBnOOcYzViNMKK55S0OWUtBu2k21LsB60 eWvpWdzPmIttGypfLX0FGwelPmDmIdtG2pvLX0pdopcwcxDto21PtHpS7KOYXOQbPal2e1T7Pal8 v2pcwnMg2U7ZU4T2o2ClzE85CEo2+1TbFznHPrSbaXMHMRbRTSKlKj0pCvtTuNMhIqMjtVgoO9NK D0FWmXzEJXFNxUxFMKimmWmREcU0ipSKYyAkEgHHSrTLTIzSEU/aBwABSYqrlJkZFNIqTA9KQrTu UmRkUhFSECmladx3GEUYp2xfQflRtHoKdyrjcUnFOwPQUYFO4XG4FGKdgUYouFxtGKXFGKLhcTFG KXFJigdwxRS4pKAENGKXFJimMSjFLikxRcBKCKXFGPagBMUYpcewoxQAmKMUuB6UY9qYDcUYNLgU YFACUdKXAoxQAdqXHajbx05p2MUrg2IBinCgCl2juBSuS2GKWk2jsB+VLj2FIQcVHN2p+B6Co5Rj FNbjjuR0UUVZoFe2/Ab/AJFzx5/16Rf+gT14lXtvwG/5Fzx5/wBekX/oE9NboT2PRLnq31/rWa33 q0rnq31/rWa33q9pbHlPc+dPEv8AyNOr/wDX7N/6Gay61PE3/I16x/1/Tf8AoZrLrxD1gooooAmo /CkzRmoIL2j3cen63YXsqs0dvcxyuEGSQrAnHvxUuv3Nnfa3d3tk87R3MrzETRBChZidvDNkDI54 +lR6FbxXniHTbW4TfDNdRRyLkjKlwCMjnoam8SJbQeIb61tLSK2htp5IFWNnbcFcgElmJzj0wOOl MZl0U2igBc1r+HdZj0e9nNxC0tpeWz2lwIyA4jfGSmeNwwDzwenfNY9bnhbSrXU728lvA8lvYWcl 68KttMwTHybv4Qc8nGev1AgQniHXY9TtdPsLfz5LeyWQ+fc486aSRt8jNgkAbugyT6k5rMvv7P8A 9G/s/wC0/wCoX7R9o2/67ndsx/D0xnmtrxVokOnWWmX8dv8AY5Lvzop7MOXWKWF9jFWJJIJ5wScc 8kdMXTZ7O11CKa+svttsud9v5pj38ED5hyMHB/CqKNXWdU0fVfFX2lba5h0X5US3hCRvEm35tg5U fMWbHfJ6E5GtoninR/Dq6bHbwXV79nvpLmSeWFIXVHi8sqoDNn+91GdoHuLmkaZ4bmg0h9d0+z06 a8uXfZ9plQPaiFtrndIdoMmMHIzjjIzVLTvDLa1qmnWk2mWNjZ3M7I15p9w1xyiFzHnzXVSR0yM9 +QCCAZF9qOlr4Yi0iyWeeRbxro3NxAsRQFAuxQGbIOATyPujg9tJfFen2vxCg1yzs5U0yDCRWoVU MaFCrbVHyj5mZsZ5J7ZJqXTvDsOo+KtOa50qK20a4naELYXRuVLKpcK7qzkEjbn7vAJGME1X1XSd Pj8MWuoS2sFncNqBt3OnTG5jMWwMST5jDeD0XeuRnjuAClc6ho48PW+j2/2qXF81zJdy2yI8aFAp VVDnOcZ+8v3R9Q/xRqml6tFphspLzzbOzisys9uqBggb58hzgnI+XH41f13wxa3PiHQ9N8OwMi6h p8U6/aJOSTvJdzkgHauSF444FL4x8NWWi6Fo1xY2t4pkaaO4nuY2jaRlI2kofuA4YqOu3rkg0DMz XNV0+60DRdLsWupP7P8AP3yzwrHu8xgwwAzdMHv/APWwojGJkMqM0YYb1RtpIzyAcHB98H6V0XiC ysE8MeH9TtbGK0mvftPnLE7sp2OFXG9mI49+9c1xQI7CbxDosb291DBdXl7bX0dzDNNbx28hQEFl ldC3mk4HzFQcknJzg5+r3fh+8vr6/jOpzz3V35wjZI4FjRmLMN2XLHBAHAx156E1TwhfaRaW95dS xLazT+QZWjmj8tsZyyuisRjJyoPQ9+Kl8VaDYaNb6Q1pdxSPcWMU0i/vC0jMWJkGVACdABweBkdT QMXWtV0W90ySKFLq4vfP3w3U1tHDIEP3hKyMfOJwOSAcknPODDq2q6feeFdD023a6Nzp/m+Z5kKq jeYwY4IYngjHTnrx0pms+E9Q0TTor+co9vJL5O7y5Yyr4yAVkVSQRnkAjg1b8R6Zo9p4a8PXulJP m7WfzpZ+HkKMq52hiFGd2AO2MknmgBusano934Y0rTLWa+abTvN2tLaoqy+Y4Y5xISuB7HPtXM1b nt7OPT7OaG9825l3+fb+UV8jBAX5icNuHPHSq8TLHKjtGkiqwJRycMPQ4IOD7EGgRYnntJNPs4Yb HyrmLf59x5pbz8kFflIwuBxx1plhPHaaha3MtutxHFKkjwv0kAIJU8Hg9Oh616B4i8L6JFfX+l2s NnZ3ZubWHTdt2zySGTG/zVLMVUZznavbk55zNf8AB0Nlo95c2tvfW7aVIsM8t3GVS9DNt8yP0w2R jkbdpznOQY298SaHNY65BaWk9ouqwwHyY4EEdvJFghRhhuVjuy2FI/unPGfNrGl3nhKw027hvBd6 cs4g8oqI5DI4YMzHkAYb5QOePmHbXMPhX/hAf7T/ALEl+0+Z9h877Q+fP8jd5m3djG/jHpz/ALNP 1DwEtrp17arBeLfadbG7lv3Qi1uBgFokPqoxg9Sd+QBjABVvfEmhzWOuQWlpPaLqsMB8mOBBHbyR YIUYYblY7sthSP7pzxhf8I7e/wDPbTP/AAZ23/xdZPFdbqHw71bTob2RrnTpjaRGaRIrjLkDBfCk A5VWRjnHDrjJOKAOg1+9j8P2Nm9zb3n2u78NJpyxNDtjUn7xLk53L3Xb3HIzxyX9q6f/AMIH/Yu6 6+2/bvtmfJXy/u7Nu7dnpznHXjHemXHhPUIPD51rKNaqsbOPLlQqH+6QXVVYZwPlLdR25ouPCl3b WUt/Jc2f9nrEskV2JCY7gtnEacbi+QwKkDbtOcDBIA/+1dP/AOED/sXddfbft32zPkr5f3dm3duz 05zjrxjvVu917R7jw7/YMdvdLBbRq9tdlE82WYFyRIucCPMr4AJK9fmyQOU4r1jVfBvhG2m14W0r Nd22nySpY73/AHDqgbfnqQd8eASRkt16KAeT96K9K/4Qiz/4WR9n/s7/AIkHn/Z9vnn/AFn2bzcf e3++enaq+l+HdH1bSvDls1gsF3q8V0pu45ZCY3hPyttLFSCAQwwOvBXFAjz+JPMkC+tagUAYxwK9 G0Xwd4Vmk0N53Zbu50+OR7Pe2JmZC2/PUfdfIBxwvTo1Cx8Frc2NpbmG6a8vrcXUV4qH7PBwSsbn 1YZyex24B5zlUTb0MKqbehxapk4xVgL7V0OjW+lz2Rub3TFh0+CIxz3bTuZZZiCQIgCFzyOCpAAy TXP8Zzzn61zSOSelhAvtRt9q128NuEtmuL60t5ri38+KGWZ0LIc4+bGwE4OMsO3Sr1v4G1CSC3kh ntGaeATRxtcHedy7lXB7kBsdvlbkUuVsOWT2Oa20oWur0bQI20y+uNQhh3NYS3NsjO4lG0cSYHG0 k/xdcccZrmMVLTS1Ikmkmxmz2pdtddpWh2badpstxatdHUZGV3EpT7MgcRAqP4judTzkcYx1NUj4 WupLiaO2ngmjhuJIJnLbPICk/PID91SATkZHGOvFNxkNwlY5/YCOQD35pBbRKCBEgB64X6//AF66 bQtM0y6ttYW4Lz3NvayywlcrGAo4bOQxOSMAjGOvs7QtMtJNI1PU7q3juRa+WEiafywQW+bOCCDj p2JPQnipSfRkpS0s9/0Ob207bXYWWhaa1vZyi1luYtQmdQ7y7Ht4hIIlIA4ZtzqT1HGMd6529sxZ X9za79/kytHuxjOCRnHbpUyTirkTTik2UdvtRsrag0N5LS2uZru1tY7pmWHzmb5tpAJyqkAZOOcV q6D4fsbvTtWnu5onlt4W2hXYrE3zfMxUYb7uRtLDGeOlEYyk7BGMpOxyGykKV0PhqwtLzxJDY3Ua XMEm9chnUHCkhhjB7d+x6emFtA//AF0tbXFra5ERURij8zfsXf8A3sc10+laZbDQ5NUntPtzfaDC LcyGMKqp5jtkHJO0EAdvfpRqHhKePVr2z06RbpreRAIScS7HAIbHQgFgCQeOpAFaKMrXRqoStdHL kU3HtW9DbWsMtxZC3sb+4RwftEl4Y4do6heUycnrk5A4GOa1k8N6f/wlGuW8cW62sbd5ooriYoC+ 0EAkkNsBJ5yBgLk4PNKLexcYtnEEUzFdjBpWmz6Xd6xa2kbo9ytvDa3l0IkiOwOx3blL85VRkHHJ z25m8sp7G7ktbqJop4ztdG7f/W9+9U00NpopFR6U0iuk8M6dZal/asV5FH+6sJJ45mZx5TLjBwp5 HOSMHoPxWDwXqdxJeRq9qpt1jZGaXC3AkyEMbYwQxGBkjkgetUk3sWk2ro5gimNGpPKA/hXTyeE7 2z1ArO1m9rFCt0900rG3aM/d+Zfm+YgqAOT29a0NW8Ftc+ItXt9I+zwW9l5IEU0xBZpEGFUnPJbj kjkiqSZaUjiCtNIro5PCN9Hq32AywuzW4uY5YFkmSSMnAI8tWbGe5AHHuM5eraVcaRqU+n3YUTQt g7GyCCMgg+hBB/8Ar09R6meR7UhFdL4a0SG/tdRvngN3JbeVFDaGQosskr7F3MCMAHnAIz6gdZ9V 8KrJeRnSWUG5sY7+KxdyZNrZ3Ihx85XBPYkdASDVa2Ks7XOT289KbtroT4VuY3vBNeWUcdiiG7kL sywu5wIztUktnrtBAx1qKKxtrC6t2dbbWVuUZYIradx+8ztAdcCTrzj5d3GD1oDUw9tJiu8Gg6NL f+XLAqXOnWM13qNpaysYmZCCsQdixDYOHIJAxgc5IkHhGxJh1G4tmt447S6nudPSUkGS3YIyrISS FYnPcjnB5BDsyrM8+2j0o2j0rpvEuiQ6faadex2/2SS682Ka0Dl1ikifY21iSSCecEnHPJ7c/HGr yojSLGrMAXbJCj1OATgewNAr2INo9KTYP7o/Kus1PwzJceM7vRrGC2tZlQNFbCd5FYiMMVV2UHJG T82B2z0qFvBd/vRo7qyltGgmnN5HIxiVIjtf+HccHHQHO4YyM4epWpzW0egpMD2rU1XRZdIW0M00 EhuovPjEZYnyycKxyBw2CQOoHUA8VnxrGZUErMkRYBmRdxA7kDIyfbI+ooC5ERRiux1vwza3Ov6J p3h+F0W/sIp1+0SckneSznJAO0ZIXjjgUeL/AA3ZaPoej3FlbXimRpo7ie4jeNnYEbSUP3AcMVHB 29ckGnYZx1JTsDFBHWi4XG0UuKMUAJQRRRigdxNo9KMe1LijFMBMe1GB3FLijFFxjcL6UYHpS4ox /nNACYFKBilxSheaLiuJinAUbRS4/wA5qbktiYA7ClIB9KXFGKBXEAx2pcUuKKVxCYqKb+H8amxU U/8AD+NOO5UdyGiiitDUK9t+A3/IuePP+vSL/wBAnrxKvbfgN/yLnjz/AK9Iv/QJ6a3QnseiXPVv r/Ws1vvVpXPVvr/Ws1vvV7S2PKe586+J+PFms/8AX9P/AOjDWVWt4o/5G3Wv+v6f/wBGNWTXiHrI KKKKAJPxpcfWko/GpJLNhdyafqFtexBWlt5UlQOOCVIIzjtxSX93JqGoXN7KFEtxK0rhBgAscnGe 3NWfDsUc/ifSYpkWSN7yFXRwCGBcAgjuKm8UvnxPqMKxwRRwXMsMaQwpGAqucDCgZPueaYGRR+Jp PxpPxoAWrmmardaVLK9sV2zxGCeN1yskTY3Ie4BwOQQfQiqVb/hPT7e+uNUmnXcbHTZ7uJSAVMiA bdwIwQCc4PBxzkZBBozLzVbq9sbOykKra2asIIlXhd2Cxz1JYjJycAnjA4qCeVJfL2W8cOyMI3ll jvIz8x3E8n2wPYV0XinT7OLSNH1S2kWR71rlHkjhEKSiKTajiMABCVIyPb1yTzltcPaXCzRiJnXO BLEki9COVYEH8RTGXtX1qfWtdk1a8ggaSRkLxLuEbBQFx1zgheec9elWNJ8VanosNrDZtGsdvdtd gMm7e5TYQ3ttyOMfePOcY6eXUNM8O3en2HiHS7O7voZTcXv2exhQRq0RCQ4AAc5YOT0BwBnFP0XQ 7bxLNpc0k8U2mSXz280a6bDZy71haQDdFklSAQeR7diAZyuk+KtT0WG1hs2jWO3u2uwGTdvcpsIb 225HGPvHnOMUm1W6OhrpGVFoLlrojHzM5ULyfQAH8znPGO00DQ7bWtX0jVgYL2ya9a0lt5bKO0GV iMoO2LcrDGeuMkAHg5ET2uh6p4csL28nSG1GqNBPfJYJbyKnlbtgji3BgSPvHlSehGaAOT1XWLjV /sX2hI1+x2iWkflgjKJnBOSeeaS81e4vNH07TJEjENh5vlMoO5vMbcd3ODyOMAV1us6PBNovhU6D b2ct3NNOqLDEzm42uMM5kQbguPm3ADk4G3pieJbyxMNvp1utnc3NuzNcahbW6Qo7EYKRhAoZBj7z AknJGB1AM281e4vdH07TJEjENh5vlMoO5vMbcd3ODyOMAVVtbmazu4bq3cpNDIJI2xnDAgg4Ix1F dJ4jWKXwh4Zvvs1rFc3P2rzngt0i37ZAFyEAHArm7W2lvLuG1t13zTSLHGuQMsTgDJ46mgRoXviG +1C0u7WbyxDdXxv2VVI2ykEHaeuCG6HPQe+SbxBfTvp0reX9p0+OKO2nC/MqxsxUY+6fvDqP4V98 7Wu+GdM0vSV1CCaSTyNSNjdQLPv5C7jhzEmCMEfdYcg56ijxPpenh/DtlpGnyx3V7Y28i5nUhzIz cNlRlySPmyBjjAHQGYt74hvtQtLu1m8sQ3V8b9lVSNspBB2nrghuhz0HvmK71i4vdH03TJEjENh5 nlMoO4+YwY7ucdemAK39d8J2lnpK3WmyyS3KakdOlt1czZk25wD5cZzkEYAIORg9RUPiCeCy0z+y bmGxn1cyB7iW3tooltMf8sgYwN7c/NnKjoBkZABzb3EktvDAwjCRZ2lYlVjk5O5gMt7ZJx2qL86t T2/l6fZzfY7mLzd/7+Q5jmwQPkG0Yx0PLc+nSq8UjQypKuwsjBgHQMMj1B4I9jxQI1bzxHeX3ihf EEscAu1limCKreXlAoHGc4+UZ5ofxHeSQa1EY4NusSrNcEK2VKuXGzngZPfPFdr4li0FvFE3hsWK LLcXlpHE1vaRQC1Vtu8q6/NIWDdGGAfXArK1bw7piaRr8sNxA0mjSxwwrbq4bDSbD5xZQGbgnKnq SM7QoAM5f+17j/hHv7E2R/Zvtf2vfg79+zZjOcYx7VoT+L9Qn1fVdTaG2E2pWjWkyhW2qhVVyozk HCjqT34rV+2Rf8K2+3f2Zpn2j7d9g3/Y03eX9n67sZ37vn3Zzu9uK0NR8I6RBea3pcdzERpli95E FDfad4QN+8YpsKHcBgHgBcYJckA86/OumufHGrXV5qNxIlt/p0EkDxhDtQOiIzLznOIk6kjg8c1z Nekav4C0O1GrRWl5qAuLO2kmQShGQmJI3fJGCQVmQDgYIYnPAoA5K88Vanf/ANp/aGjb+0o4UucJ jcYsbWHofl57fMeOmIp/EF9caJHo8nl/YIcNDEFP7t+cuD1JOWyCSPnOAMDG7qXg+1sfD+ozvM0W qaatubmDzvNGZex/dqFPIPDP0I9DUN94b0u18Lp4jSW8NpdqIbW3JTzEnywbe+MFBsYjABbIHy4y QDkvzroJ/F+oT6vquptDbCbUrRrSZQrbVQqq5UZyDhR1J78Vz9etarZ+HBrniixg0SKO8ttKkl34 XylxGhVkTHyuS/J7bARyzUAcr/wsrXvN8zbY+Z5eN32Zc+bt2edn/npt+X+7jjbWbZ+K9StLfS4L VYI5NOEq20wQl1MrAsTklScZHIxhj3wR6P8A8IPb/wDCe/2l9hi/s77V5H2P7GPK2fZd3memN/HT 73fNZWh6bZ6ppXhO1ntLVRfx3aXEsdtGsreXnYd4XIIwOe/fOTQ9EJuyMG28T3tvqOmXyxW5l061 W1iBU7WUKVy3PX5j0I7VJB4ovotU03UFitzLYWwtolKttZQpXLc5z8x6Yrr9NtdBOr+HLObSI5Lq 40yOTfx5bZRiWdMfMwKcHvvJP3RWfY+F9NmudJ097lFGoWaXUmQ32gOVJ/dts2BRtPB65bOSFI52 pdzlcZdznJdWkufsCz28D29nD5SW43KjdcscMDuJOSQRkgVn7Cx4dl+mP8P84rpLMrpOjLNqcNvL 58bC0s3t497q2f3jvt3hRztwQT2IAzXP1zyOWbaLNzf3F6LX7Swk+zWwtk4x8o3bScdxu47fKMg8 51IPFWpQXdlOiwYtIUhWModrbFdVLc5ziRuhA56U+603StNjsEuzevJdWa3JmiZMIWztGwjnGBn5 hnnpWzaeENKuUsIzc3qXF1axv0QoHdHZT2OB5T5HU5Xkc1SU29Ckqjej1OaGt6juQ+ePlsWsCNg+ aI5xnjqMjBH90ZzznPCmuz0zSLSz0y6juEWe6uNJkvgzIpSJcYTbkbt3JJOQOnB61yAHNZz5klcy qcyS5mXYtUu44bSPepFmxe2JUfumOSSPX5iG+bPKjtkGW31q/tzdFZgftjlroFB++B6qeOBy33cH 5zzwMbGnabax2OjO0i51GZllWSJX3gSomxSRlPlLnIOck8/dwtt4csp21ALPcqmmTOLkttYyRDdg pgABvlIOeOc+1O09LP8Ar/hh2qaWf9W/yMDT7ufTvtPkvn7TavbPvAOA3Vh/tcfT2qS2vJ7XTryy Qgx3Yj8xmHzDYxIx257/AKYrU0CG2mbWt1uroLCWSLzQGaIjpg4Azz1x24xzldB8zbJcXH2c6dZ7 Xn32sTscnhAdu4ljxknA9qzV3bUyXM7a9/8Agmcmp3aRWsfmAi0Yvb5UfumOSSPX5iG5zyo7ZBrz yyXM8k8rbpJGLu2MZJOTXUxWlnIunXAVIl1O5kLwtErjb5yKI0OMoApY5GD/AOO45zULZbPUbu1R 3ZIZXjVmxkgEjJ461M1JJXZNSMkld3/4b/IbLeTzW1nbSPvgtJHdIyAAQxBKkjnGQe4PzHnph9hq l3pttd28Dgx3cJhlDqCeQRuHoRk+3PIPGLwsNPtNK069vftUv2xpM+S6p5aqwXoVO49T1HpWl4cs 9Ln0rWppLV5mt4GxJIy5IIcgqMEI2FHOW9ve4KTktdf+B/kXCM3JK+tv0/yOc0/UZtM1WPULdE3x szLGwJQBgRjrnAB45zwMk98/aQoG4k46966LwokFx4qgheBJLeXzAY5lWTjaSOo68DkAfrXPNyMZ qXflTFryp+b/AELEeoTx2P2Jtslp5om8pxxvGOcjB5UFevRj3wRNH4h1WHUJ79Lsi9nVUefy0ztA xjGNvOFPT+Ee+btjaQweGpNUMwSdrowBpYEmUARMwAVlIyzbRntgds50pPCdld+I9Q0izlmgmhZZ kaQh08ohdy4wDkbuOTkDB55raMZ2VmbxjOyszjJSJBJsUR733DZn5Bz8oznjkdcn5Rz1zpN4hvnv 9RvXMbzX8D28mV4VGwPlx3AAAzn3zRb3Nnb6jOYXlismGIxNaQ3L8dCd2AM89D6DnrW3eWEyeMNS srSOxtbOEG4lL20cyxR7VLMNybu4+QcAnA45pxvbRjje2jOV+3XA0ltMLg2xuBcDKjIcKV6+mCPy HvlNT1C41bUZr66IM0zZO0YAGAAAPQAAf411Vx/ZU9hea9BGbJZb0W0Ua2kU6ogjz/q2woJPJPOM ADqc83rOlPour3GnySiVomGHAxkEBhx24I/xPWnJNLcqSaW+hFp+pT6YLvyQjfarZ7Z94JwrYyRj HPFXl8V6pHbNChiA8u3ijbZzGIDuTHYnOScg9ewqz4Uit5v7YS6t454k06WXBRdwZcYKsQdp5PP0 4OBWlbeDNPlNw8l1dCCWO2ks2ULuUTsVXzB0ODjOCOPyFRUmtCoqbWjOduvEl/dWDWTiFYGtIbVl VTysTblbJP3uo9OenpIfFuqGS9mzD5941u0kuzkNDgqwHTJIyeMewrXuPDVhYu+qpNcSabDZwXix OqGVmkJCKcgrjIyTg8cYPWtC/wDDGl3/AIj11H8y1SB7WKBbVFCq0oCglccjcQTgjvVJSLSn3/rU 5K68S391p7WLCFYGtIbRgqnJWJtyNkn73JHpz06Yz9U1G51fUHvrsqZ5FUOyjAYqoXOPU47cfSun ufCthBO12ss50n7FDdF55RG8fmNtVTtR93Q9F/HjnE8R6THouv3enRStJHERtZgAcFQwB9xnHvjt Q7rcHzJalK11K4tLO7s4yrW12oE0bDhtuSpz1BBOeD1HORxVseJNRj1GG+jaNJ7aHyLUhMiBBnAU HrgErltxwfXBF/w7YWkmmapqNw6o9obdUkkiEqRiSTazFCCGIXOB7+uCL83hqxv9VsbOIyQ3mpab HdxMu0RLMVYsCoHCkKfu/dJ4BGAGr20GuaxzkmuXjx6nGfL26lsNyAv3nVg28ehJySBx8xwBxiPT dXm0mZprWGFZmt3gEpDblLf8tFOflcDgEYGO3Wt19A0qEa3MWvZYdI8uF13ojTSs5RmB2naoIOBg npz2qjZ2kN9qNt/YkUiSKjNcC/EcsUKjq5YrgrtPOVGD0ySKeo9bmfZatNpygWsUSF4nhuDyTcRs QSr5PA4xlNp9881PD4l1K3ghto3jFrFC9v5BQFWjcqZAT975iuSQQRk7doxW/CulaxqN4be3jZdL 0yadJxAkQuZVxhmjA2hQW4XGSANxPStC00fTWhh1bZDcb7G+keUW6qn7pwqSrBgKWwR8pwO/Uc0r lK/RnB3epXN3Z2lnIyi2tFIhjVfu7sFjnqSSM8nGTxgcVSx2zXU+KLe2fRtCv7ZEH2hJg8yQJA0p WTHzRLlVxnggknPOMCuaiVBKhl3vGCNwVgrEd8HBwffB+lJiZs/8JXf/APCWf8JH5Vv9s/ubW8v7 mzpnPT361nadqVzpjXBtmXFzbvbShlzuRxg/Q9CMdx6cHq7rw1aXXxHuNCaSRUdMRSosabH8kOCV VQpHB4AXOevXNS00Tw/qbyz2V3emG2sri6ntZMCUeWcIN+3aNwIPAbGCOc8VqVqU/Fl3ZXn9j/Yr 2O5+zadFay7EdcOmcn5lGQc8fQ8Cucx15re8RaVaaUumfZjMWu7RbtjI4IUOTtQYA5AHJ79cL0rD x70m9Qb1Lmqarcat9j+0LGv2S1S0TYCMomcE5J559vpSXeq3F5pOn6bIsYhsPN8oqDuO9tx3c+o4 wBXW6hNo+k+I/Dt7daXB9hfSo5ZraGFWVmZXGcMfmOcckk8dSay9Xg+0+G49Ut7iCS1+1m3Zf7Nh tZA+zcCDHnK4J6kc44PaijlyKQg+tPNIRSuK4wj3NBB9TTsUYp3C43HHrRilo6j0oHcbiilwf7x/ Sjb70xjaMUuKMUXASlxilx70Ac9aLhcQCnAH1NOC0uMVNybiBaMY70tGKLiEpaKXFIBKMUYpcUAJ ioZxjb+NT4/zioLj+H8aqO5UdyGiiitDUK9t+A3/ACLnjz/r0i/9AnrxKvbfgN/yLnjz/r0i/wDQ J6a3QnseiXPVvr/Ws1vvVpXPVvr/AFrNb71e0tjynufO3in/AJG/Wv8Ar/n/APRjVk1r+K/+Rw1v /r/n/wDRjVkV4h6wUUUUAPz70c0lFIRYsJbqHUbaSyDG7SVGgCLuO8EbcDuc44q3rj6rJqPm6xat b3ci7yHtRAXBJ+YgKMknPzdT68U7wx/yNmjf9f0H/oa1N4utri18Wap9ogli827lkj8xCu9DI2GG eoPrTAxKKTNLQAnNW9Mub6z1O2n015VvVceSYgSxY8AAd85xjvnFVK6fwLLGmq30YdY76fT5obBi Qp+0MAECt/Cx5AOR1x3oGZGs3Gp3F+RqyypcxRrEIpIvK8pABtUIAAoxzgAdc96bc3uoaxLZwys1 xJDElpbokfOwZCqAByefcmt/xeY4tF8P2UqNHqNvDL50UzB5oomcGFHbA5CdF4xnoM1S0htT8KeI 9JvjYebNKiz28G4MZo5AVGNuSCQTjvnHHagBuo3viWy12PW9QS8tNRdgyTywGIsVAXgYAIxgEYwQ eetE2v8AiCyeyLO1iI2+126xWq26sWGPM2qoDggEZIIIyOhNbmpIuneC7HTIbC5tdRn1UXUNjdlZ 5XUIU3FNi8FuArLzg4yKm8ci4Gp6Bqmtadc3EH9mwC6BzCHm+dmQttwpzyQBnGcY6gGc+uteJB/Z sluJbdDO0lmLW0WFJZfuEhUUCQ/w9+uO5FN1VvEcsNrp9/Yz28UkpaC2SxFuJZDhchVVdzdB3PPv XoVldXt3ceA9Ruo4rTdJdpkw7IkVhiONRkY3IAE554Pzd8F7S/tfCVhZaXBeaTfTauxht7u4Ec8h 8nbuRyI8Lztxg5LAZ5wQDDm1nxVoiaak8UliLPf9j82wSMrlSHwSmTkNznOSQTzzVHU9V1mXT4tP vY0t7R2F3HElmkAckECQbVGQRkZ6H8K6PULaay8D2Vrb6dc2c8ms747G+USzTMIwAygooK5O0rsO SRz2LPiPDqM02i6he284Z9MgSeV4toEx3llPGA3U4/SgDC16fX3t7O31i1ltoYfM+zRtZC3UZIL7 QFUHnGfr71jxSywTJLE7RyIwZHQkFSDkEHsc11vie1uLLwR4Ut7qCWCZPtm6OVCrLmQEZB56EGuV tYPtV3Db+bFF5sip5krbUTJxlj2A7mgRoXviTVdQt54LmaJoriQSyItvGoMgOd/yqMMckFhyRwSR inSeINdTTbWze7njtgqNCwXazKjNsw4G5lVt2BkgEcYxXQa/4ft9P0ee8/slIbqw1PyJIkEqxzWx HyysrOzBWZSAwYA5IyTVjxXZtq+n+H7m2tbGCzNjawtfNOVSJiWXygWc5CkEnAZlxycUDOafxbrU jl2uYsmdLk7baMDzVbcJMBcbsnlupHByMCrerX/iqPT7pNTs5bW2vZF89201IPOcHcMsEBJyCevr W1qHhUpbqbKz/s/VbfWVtEeIyophY4jnIdnZQXGAwOOo5IqpqlhrelaBq1oNOufKM6NqmpXJ/wCP lg3yiMN1TeSdwyWyCdoO2gDkHurmW3ht5J5Xhhz5UbOSseTk7R0GT1xUr2t9p32W6mtJYkkxJA08 B2SgYOQGGGHI9Rz71d06xawvNE1PU4EGl3NyGDvh1dEcCTKjJwPQjn3rvbqa3s21efXjusrzVbaa zNxIJ0nQS7mkiUA4TyCik8/3c/wgEcLqeo6++p2euaikkd02yW3uXtRGJNuCrDCgPjK888Y7Yqo2 t6i8WoxtcZTUpFkuxsX94wbcD045JPGK7jxGzQaL4nfUWYrf3sUumtLMJVmIcsZIsfdXyWjXPTtn +EcZf/8AIA0j/kGf8tv+Pf8A4+Pvj/X/APsvtQMi/tq//sT+x/Mi+w+Z5nl+Qmd/97dt3Z7Zz046 cVYm1/W5Lq81SWdjJqETWk8xhULKm1QyjjAONnTkZHrWPXqWpxRtrXifw6Y1/snTtIM9pbYG2GRE Vg4PXdmR8nOWzzkUAee/2FrH2T7X/ZV99m8vzPO+zvs2Yzu3YxjHOatz+JNflkur6a7lP26OS3lc xjY4KoHAGNoO1Y8kYPC10p1LW/8AhU32jzbnb9u+z7tvy/ZfI8rHTGzPGf73P3ua0tTijbWvE/h0 xr/ZOnaQZ7S2wNsMiIrBweu7Mj5OctnnIoA5W/u/GEdlcvqFpdpbyQiG4lnsABIvAUyMU+ZhgYZi WB6EZNV5tR8Tz2FzfSpctp9xAtvI5tf9H8tThQo27F2t0IwQScck11HibUZPD9lpyNp04u7zw7HY NLK+1EB++uzbkuP97jcMj1x/stx/wqLzfIl8v+2fN3bDjZ5Wzdn03fLn14oA4/mtaXxJq8uoX189 3m5voDb3D+WvzxkAEYxgcKORg8Un/Mp/8wz/AI/v+3z7n/or/wBmrKoEdWL/AMblhquzU+bH7P8A bPsp/wCPf72d+38d+c981ct5PF0miw2MNleGx8jy4zDYbcxtgkB1XJDYBPPzd812ceh3D/EiXxWH g/spDzKXwNn2UfvATwUycZB9ewNZtlYapJ4X8LLp9lcDUB57Q3W4olsDKrb3G05DJkDJwQTw2RUS 1M56nMwX/iFdU02WJLj7bFbKlmBbAsYdpxtXb8wwW5wfrxU9ve6+mpadLGs5vIrZUtALcFjDg42r j5hgtzg/Xiu80jWpINS8NaQLaFln0uJ/PI+dB5bFlHsTGn5Hrxihp8cj+IfDGoqjGxg0lVmuQP3U ZVJAwZugIPByaycezMZQ2szkovE+rwGBop4RJbxCKGRrWJmRQMABiucYJ79zVU6ZqMVp9rksblbY gMJWhYJg4wd3TnP61RBr0jR43tdI8OXN2jR6fFBeG8aQYTy3PyhgfvBiVwOc9gaxinLRnPGLno2c xBqGvxta20SSmbyMWx+ygzeUQfuPt34xuwQeB0qRbzxHbLa6htu44reJEhlMGIwgBVe208OQCc/e rasb+1+1aRr5uI1tdNsRa3EZP73zQrAKq9927IPTCtnGKuaRG9tpPh25ukaOwiguzdtIMJ5bn5Qw /i3Ergc57U1Fvr/Wn9fIpQb6/wBaf18jkodd1KKOKNbhSscZiXdEjExnPyEkEsvP3TkdOOBUdvpW o3MKzQWF1LE33XSFmB7dQKzd0+TtiiI7ZkI/9lrutBVY/DumtPBIwk1uMxEPsGcAbuVOQMHjjkdR WMYuTs2c8YubtJmLpUuux2rrpkd08LOcmKEuFfaQSpwdrYbqMHmmwXesW8Nits0sUYlZ7bZFgSP0 OMD5z25z1x7V08sN5dzaC5hEs1vqM/2s2wLJE3ngnJxkDuM44rQOtfZG0qOKKCeO8v7gJITnbmcj cp/3XYfj+BtU+7t/SNFStvJq3/AOIh1TUNOkuEj8mJ5Cyyq1qmeeqkEcDgfL046VAt/dLBdQpIix XRBlRYwAcEkYx0wfTFX72wmv9e1ryWQfZ2nnfeSMqrHOMDrzWNurnlzI5Jc666Gnp95rEFtOtg0v kpl5CkW4RHaw3Z/gOM8jHT8sw7s9Rj0xXYaQ7S6dobWWdtrcu98ySiMRfNnfJ6jywwzx6Z7Hnbi3 bUdT1F9OiV7eMyzjbhAsQbqAcdiOOtXKD5Vrc0lTfKtbj7LU9UjiWO1/epbbplzbrKYRxlgWBKjO D2GaNMuda8y6fTluJzMMXG2Lzg4OfvAgg555Pv71qeFPt0mn6zBFC7W0llLgrFndLgALuAyTgnC5 79KRYLm58P6bbafbXEl1bXEq3EcEnlPDOW/du42nOACM8YxjcMVcYNpO7NIU5NJ3f9djEj1vUIdT fUkuM3j5zK6Kx59MggcccduOlQRWl7qLyva2sszA5fyISQufZRgdDx7Vqa3CNZ8Y3UWkLHOJn+Ty yFDEICxBOB1DHPf8aj0vTr240sXfkXF7YJc7TYwO2XkwDkgA4G0n5uvQcZyFytytuHI3Ll3WpRs9 R1DR55VhkMLkgSRvGD8ynIyrAjII4OMio11W+jhkiS5dRLKJpGXh3ccglupweevXnrWldWGra14u ks7wRQ6jMcsGI2LhNwGVz/CB6+/esDNDuhPmXoaR17UWaYtJC4nkEsiSW8bIXxjcFK4B9SBk96hO s6h9ru7o3LGe7jaKd2UHcjYyORx0HTGMcVt6NZaR/wAIw9/qNp5sgu3jVvPMfCxeYF9PmK7emfm4 5xVy48OWtnrd2I7WC5sI72CKRJJJN9vEyb3kJUjCjOAWz0OSMHOihNq9zZU5tJ3OVtdUvLO3a3ie NoHcOYpoUlXcBjIDAgHB6iqt7dXd/eSXVxP5k0pyzMuSeOO/6enHFdXbeH7AXepWuprJZ2tvdiOK /kfazZYARkHg5U7twHy9TwcVzWsxzW+rXEP9npZ7Hx9nMjHYMDHJzn1z0PUcHFFpJaicZJajtMud TsFurqzBMfl+VO/kB0CMfutuBHJH41oi58U3IlWKK9YTRwsRDbEYRCTEV2r8q5BI24B5qTQI5bnw v4itIYzJcyC3aOGP5ndRJyQo54yM+ma6VbeeSaWFIZGli8LiCRFUlklPIQjsx9OtXGLtuaQi2lqc d/auvLHNu8xoraFLWZJLZWREVvkV1K4yGzgkZzmkl1XxAXEMj3Cy3qQ4Ih2yTBDmJg2NzHPRs5OB ycV3B1RNOsdUuDFDd3NtZWUN/G53CSTc6yKzchm2nGefxxiodbupJNMuddVVj1FdJszHKnHlebI4 fbnOMjjPUetVy+ZfJpucMPEOqqoQ3CvGLdLby5IUdDGhyoKkEEg9CRn3qpdXV7q93G05a4uWCxKQ g3vjgZwMs3bJyTxXTeINLS6ltdTkkhto5NPt7m8l7ySybs7EHV22k4GBwSSOtQeH7yWXxXpraRp/ kRxeXFIFQTP5ZYb3divU7iNwAwCBwKVnezZNnezZh6c2q2WpNDYpN9sYPC8Ah3lhj5lZCDkcHII7 e1T/AG7XLnUL6EG4kvr3MdwqxZlYDqnTco45UYGBg8Cuo8iSO/8AFlo1vML+7k8y3jH7uWeASsZB GxHIKjoM5x0OKtXUsE8d/YRnztaOm2sU6QuBNKyMTOgkwdzbcAjnOMYOMVSj5lqOm5xkuvaxFdTi 4mzKyLBOk8CNv2HjzFZfmYEdWBb3pE8TavG6slxGqiFoBELeMRhGOWGzbt5OMnGTV3xjIj6lZxll e8hsYor1g2T56ghtzfxMOATk9Mdq52pbae5LbT3NJ/EWrNLZSLcrE1kWa3EEKRiPdjdwoAIPcHrz 60z+39U+3fbPtX73yfs+3y18vysY2bMbdvtjGeetZ+KTFHMxczLN9qd5qKwpcyKY4FKxRxxrGiAn JwqgAEnqcc/lVWNmilSRQpZGDAMoYZHqDwR7HijFJRcdzVPijWP7Y/tYXMf2/Zs877PHnH024zjj PXHGccVQtdTvrK8luraZI5ZVZZAIl2MrdVKY2lfbGOPpVfFJVczL5maeva0+uS2UjQLC1tZx2xCY wxXPzAAAKDn7o6VlxyNFKki7SyEMA6hhx6g8Eex4pcUzD5+6MfX/AOtTvcLtmxL4p1iWe1nNxGk1 ptEEkdvGjIACAoKqPlwT8vT2qpeaxfX1olrM8S26OZBFDAkSbyMbiEABOBjJ/wAapc9wPzop3Hdj SDSYNOoouO4wijFONJimFxpFGKUiincY3FJin4pMUXGMwaUA+o/KnbaUDNFwuNx3pwFKBTgMUriu NwaMH1p1ApXFcSilooEJijFLRQAmKMYpf89aP89aAE/GoLn+H8asf561Xuf4fxqo7lw3IKKKK1Ng r234Df8AIuePP+vSL/0CevEq9t+A3/IuePP+vSL/ANAnprdCex6Jc9W+v9azW+9Wlc9W+v8AWs1v vV7S2PKe588eLP8Akcdc/wCwhP8A+jGrHrY8W/8AI567/wBhC4/9GNWPXiHrBRRRQA7n9aMn0pKK ALNhaS6hqFtZQlFkuJUiQuSACxAGcdual1XTTpOoy2TXUFxLCxSQwh8K4JBX5lGSMdsjnrTtBuYb PxDpl1cPshhu4pJGxnaocEnA56Ua7cw3viLU7q3ffBNdyyRtjG5S5IODz0NAFCjmkooAOavaVpV1 rF6LW1CghS8kkjbUiQfed27KPX+uKo1u+F9VtdMm1NLosq32ny2aOBkIz7cM3faMHOAT6A0AUtU0 e40sW7u8U9tcx+ZBcwEmOUcZwSAQQeCCAQeo6U3SNKutb1W302zCmediF3tgAAEkk+gAJ9eO9ani HXLXU9F0izhjRJrU3EkohTZCplcOFQHnC8qeO3BI5rKguZtHvrW90++T7QiiVZIdwMbHOUO5Rk9j jKkHGTQBbuPDtymnQ39pcQahbzXP2RTaiTd5uMhdrqpJIPGAauyeB9Wi8R2OhSvax3t5B565kYqg wxIYgHn5D0yPei/8QxXnguLSpBF9sN99qP2e2SGNE2FNpChQXzzkA8Ec54FjU/EKrqvh270i/SGe z0yC1kneMkQuAyvkFTkAN2B9s0DM208ONqWoW1jp2qWN5c3EmwJGJl2jBJYl41GAAemT6A08eFL+ 4tra402WDUo7i5Nqptt4Il27sEOqnG3Jz0GDkitrw/4k0W3k0q71SJI7+DUHZ5rO3WHZAYsDd5YX cN5zjBOAw6HBseG/GWn2cWlHUjsmh1KWVxa26xxpE0Hl7mRAqsdzdcFgFb1AII5eHw9PeeIIdGsL yzvJ5WK+ZC7eWpGd3zMoyAATkZBHTNNvdCltdJTVIbu2vLJpzbmSDzBtkC7sEOqnkHqARxV//hIY o9GtLmARW/iCC+Z457W2SELBsAw2wBWy2eCDwGBwDgl/4hivPBcWlSCL7Yb77Ufs9skMaJsKbSFC gvnnIB4I5zwAChqmhS6Xp9hffa7a5tr7zPJeDzP4CA2Q6qRyf0rK5/zmt/V9StLrwh4dsYZd1zZ/ afPTaRs3yAryRg5HpWLa/Z/tcP2vzPs3mL5vlY37M87c8ZxnGaAIeavahpV1pa2RuQoN3bLdRhWy QjEhc+525+hHfgdP4h8U2eo6TJBbPILy01Uy2VwZJXc2+0gMHkZmU5VCR8o6EDIOK+v+IYNdTRBc ahdvaQW1vHe2+4+Y0gLiSRc5Uttx8xOfnH+1gGcrFG00yRKVDOwUF2CjJx1JwAPc8VsXPhuWLT72 9ttQsb6KxkRLn7M0nybiVUgsqhgSMZUnqD05rd13xDpOu6edOknaMxavmG6k82Yi0IKlsyMzZ4Ul flzxgZzjH1rULa6t5NP02eK30mxk/wBGgO/fdsTgzMduC5HPzbdoOAOuQDCiilnlSKJGkkdgqIgJ LE4AAA6mtu98J6lZwl0aC8eKVYLiG0cyPbytjajgDqSduVyNwIzniqmlTQaZqmk6lJOkqxXKSywx A+ZGEcHnICkkDjBPviutt/GOmWlxqczJvW7voLiMW8WH2JcGcmXdgF8SFBgn7mOmGII5rUvC99pl pJcNLbXAt5BFdpbSF2tXIBCycY65GRkZBGc8VlPa3MVvDcSQSpDNnypGQhZMHB2nocHriut1HxLY S6Z4igjCF9UlRoPKjKkATNMTMTj5v3mzjP8Aq8dMMeXnuPM0+zh+2XMvlb/3EgxHDkg/IdxznqeF 59etAFTmjmiut8R+KZL7UtQXS79o9Hltoo47KVMoBtQFFQgqjKQTkYxtODyMgHJc0c13t94vsLnU deQTTto9xpYhsbIqfLjl2xhQE+6pUhjkehxnjM0/inTLmGeGe+aWKfw6IpUdHYSX4wAzAjl/lX5z 6DnigZy8Phe+m0RdU821RJY5pYYXkIkmSLHmMoxjjJOCQSFJANZ/2E/2T/aH2q2/1/k/Z/M/ffd3 b9v93tn1ra1rWre98G+HtOjkia4tPP8AtCLAFKZb5Pm2jqMk4PJ5OTTX1eCT4dR6Q9yzXcepmZIT khYvLIyDjAG4nj1JPegRznNOQEtmvTtY1BrnTPGUkC3NrFBBYw20EqGJraN9okjCn7gOACBw2B1G Kzda8U6bqH/CVeQ0v/Ezjs3t9yY5j271PoRz7fKeemUwZzOmateaTLLJZSKjTRGGQPGrhkJGVIYE YOBVZd2RgDrXZah45uIW0xbCeO6h+wx/boZ4iVmuNhjfzDwz/Lt7kcDripR4xjtbTTLbT4bfyotP EU8dz5vlmTDBwY0bY27rkg8tyRjjN2MJJdzB0rSZtThvWgmhRrS3a4dJCwLIvXbgEenUjr+VNTyK 6208S6da6eLC3aSK1l0eWKSMJwbxurN65CgA84BA45xyA61hJIwmkbemeH7vU7M3MUlvGjTfZ4hK +0yy7S2xeMA4HfAyQM1mAnjA4zzzW2urQ/8ACCjS96faft/mbPJGfL2fe3Y67uM5zjjpWrZ+J7SC +0dd8y6ZBp5iu7UD5Hk2uCCmdrFiVOT6jOOcLli+pLjF21OUHWnr2ro4/FT2mh6PHblZZ0SWO8hn TcGTJEaOf4lCu2ACQO9c2DWU0lsYTilszpbbwZrFy1mYkhMNzCJ1m3nagIBw3GQeRwPX2OKUejXL xaZIHixqMjRw8n5SGC/Nxxye2a6Gy8VQW+q6Kn9oOunw2UaXKhW2iRUcYxjJ5I6cHA9OItH1jRv7 L0qK9uGhnspGHMBcDMqy7wR0GE2euWPGOt8lN7f1saOnTez/AK0/4JQTwvdvG7Ld2e5bl7QIXYFp Vz8oJXHIHGTjkDrxS2/hTV7qC1mihUrPI0ZBJBhKkg7wRx0Pr0x1IBsJ4hsWtzKxkR/7bN/5TJ83 lBc9sjJPy4z1PYc1al8WQiTSza3ksMRvJpLuPBBEbThxnHXjPTPcd+VyU+olSpdTJh0bVmXULe3y Y4pDFKqSELO6Enao/jIALY9B6kZrWelm9W3xfWcUlxJ5cUTuxcnOOQqnbknjdj8q37vxHpTXWlMo inEN9PLJI6yAwo024MMEZyOcEHp0rMvNWsrW6nutNn331/dTbrllZRaRFzgrxnLA53DJA4ABNL2c e4vZQ7mJcxyW1xLBKu2WJijrnOCDgjioS5zzTZcJI6q6yKCQHXOG9xkA/mKjLVnymXKSlqTcai3C mvJtGQjPz0XH9aaiNRJdxpNxqLzT/wA82P5f4/5z9aPMOcbDj14/z/8Ar+tPlK5SzFczQb/JlePz EKPsYjcp6g46j2qLJqMvgE4z7CjdTsFh+aQkgHABPbJxTN1Jmiw7AHlwcogPbDn/AA+lGX5+Ue3P +fajNJmmMceKQ5pufajPtRYdhSTSZPpRn2oqhhzRRSZoAQ0lKaSmMSkwc9BS0mfb+VCGhDmg9KKP wpjGmk5pxptMaE5pKWimUNNJTqSmO407scDn6035sngY+tPoPAOKdx3GdugzRSn/AHSabkn+Aj8R TGHNGKXtSUDuGKTml/CimA0g0YNOxRRcdxAKUUuD6ZoGe6kflRcVxMUtL/wE0dvumkISjFL6fKaM k/wn9KAEx7UlKSR/yzb9KASc/If0oASinHP90n8qQk8fI36UAHSjmky3/PNv0/xoJb/nm35j/GgB Tmq9z/D+NTgk/wADD8qguc/JkEdetVHcuHxFeiiitjcK9t+A3/IuePP+vSL/ANAnrxKvbfgN/wAi 548/69Iv/QJ6a3QnseiXPVvr/Ws1vvVpXPVvr/Ws1vvV7S2PKe588+Lv+R013/sI3H/oxqxq2vF/ /I669/2Ebj/0Y1YteIesFFFFAC8579aOfejijigC3pdn/aWrWVj5hj+0zpDv2527mAzjPPWpdasL fS9WuLG3uJbj7PI0UjyQiP51Yg4AZsjjrx16UzRryPT9c0+9mDGO3uY5XCDJIVgTj34qbX7qyv8A XLu9snnaK5leYieIIULMTt4ZsgZHPH0oAzPzo/OjijigA/OtPQ9Hk1q9eESrBBBE1xczsCRFEuNz bRyx6YA6kjp1GZxWx4c1mPR724+0RNJaXls9pciM4dY3xkpnjcMZ54PT3oANd0GTR0tZ1keW0u1b ynkjMTqyHbIjoSSrK3HcHsfSDQ9L/trW7TTftMdt9ok2ebL0Xr+ZPQDuSBVzxBrsep2mn2FuZ5Le yWQi4uf9dNJIweRmwSAN3QZJ9Sc1n3I0szWYtXu0iMSfamlVWIk53lACMr0wCQfUigDW1nwrJpeh x6qGvEja5Ns0N7aG3kB27gwG5sr1Gcjkd6L/AMN2emarplteayqWl7ZpdtdpbOwjDBsALncwyo5w DzyBimXeraeNBtdBs2uWs/tZu7m5miUSFyNmEQMRgL6tye6in+KNV0vVotMNlJeebZ2cVmVmt1QM EDfPkOcE5Hy4/GgZoaV4JtNZj0+S21aeJb65kgjW5swjEJGzs6gSHcoIC59T+eZd6BaWdxax3dxq dgk0hDS6hpjRKqAZYrtdix5AxjvyRT9e1nS9a8W/a3iu10cLHEkEZVJIo1QDCDlQAckDoc9s5Ghp niDw7p9hY6XcQXeoWMeoNfTmWBIyT5RRFCByGG7BOSBgYwc0CKS+E/tsmmwabdStc38jBLe9t/s7 +WF3ecMMwMeM85ydpwG5xX1nw6NP06PUrO7e7sHlMBkkgMDq+Ny/ISSVZCHDDsecHrfh8SWGna1D r8NxqGpawLkvK13EkMbxFCpACsxDc8dgMccVV1nXbOXQ4tF003ctqLk3Tz3uPMyF8tEAUkBVQKM9 z0CgYoGV9Y0S30/R9L1O1vJbiHUPO2rLAImTy2CnOHYcknv2rHijknmSKKN5JHYKiIpJYk8ADua3 dc1bT7rQNF0uwa5k/s/z98s8Sx7vMYMMAM3Tnv8A/WwojEJkMqs8YYb1RgpIzyAcHBx3wfpQIsR6 ZqErypHY3TvDIsUqrCxMbk7QrehJ4APfiiPTNQleVI7G6d4ZFilVYWJjcnaFb0JPAB78V0914n0g y214EvL+/tbyKeC4uIY4JPKTHySupbzThVAJUEHJzj5Tm6vd+H7y+vr+M6nNPdXZmEbJHAsaMxZh uy5Y4IA4GOvPQgzINheKtwxtLgLasFuCY2xCScAN/dORjnvU93pyW2kabfLNK73fmbo2t2RU2MAN rnh898dOhrY17WtI1PTnUG8u78SqYLu4t44pFiAxtldWbzjgLgkA5yc44NfVtW0+88K6Hptu1z9p 0/zfM8yJVRvMYMcEMTwRjpz146UAc/8AnWxqehjTtC0fU1vFnGorIdixkCMoQCMnqefQDI4yMGsf iul1jVNHu/DGlaZaz3zTad5u1pbVFWXzHDHOJCVwM9jn2oEYsOnXNw9mkIjkkvJPLhRZkLFtwXDD OVySMbsZ69K29W8Ivp+n3Vzb3n2o2Mix3imFowhJ2boyx/eLvV0zwcr0xzWZBqlvZnSp7SwSO9sp fNkneRmE5DhkyvG0DGODzW1q/iqzuNN1OCxS7L6tKktwt0wK24VjJsix1BkdzkgcdskmgZzH2eT7 J9pzH5fmeXjzV35xn7md2PfGO2c10t54IuLW0uV+07tSs4PtFza+UQioAC4WXO1nVXjLD/b4LVz/ ANos/wCyfs/2L/TfP3/a/NP+r248vZjHXnPXtXVX3ja3uU1C+SO5/tPUbQ2s0DkfZotyhZJE53Es sceAcY5yWwBQByH2eT7J9pzH5fmeXjzV35xn7md2PfGO2c10t54IuLW0uV+07tSs4PtFza+UQioA C4WXO1nVXjLD/b4LVz/2iz/sn7P9i/03z9/2vzT/AKvbjy9mMdec9e1dVfeNre5TUL5Irn+09RtD azQOR9mi3KFkkTncSyxx4BxjnJbAFAHIG3f7J9p3R+X5nl481d+cZ+5ndj3xjtnNQ5+tWjcWn9k/ Z/sX+m+fv+1+af8AV7ceXs6ded3XtVWgR1msWMtla/2Tq3iO6+22sCyiwkR5II2x8sYcMcNsPULt 5xu71Ne+DI4bPzbHUXuZxYJqRglt/KP2ds5Ibcw3LxleODwT0qvqutaNrd1caveQXh1Ke2CNbKFE AmC7BIHzu2gANsx1GCxFal54r0wWf/EvS8kuv7JTSc3ESogjGd78MSWPAA4A5JJ6VLsS2jjV4wTn H0rs7DwZHf6TYX0d/Oq3cUr73tMQwGMHPmSb/lUkEA4/AdKwv+El10f8xrUv/AqT/Guh0vxVptlF oEDpdywWUVzHeIY1AlEoztALYZQfXHQHHas9Opjo9yG18JJPc6bYtqDJf6hafaoUEGYgCrFQz7gQ cLzhTjPer1l4Alu304jU7dIbu2Wdiw+eNmUsFCZ+bOGweOEb05is/FOmxahpGqSJdfatOsRa/Z1j UpIQrqD5m4EA7gfunHvRa+KbGHxDoOoNFcGKwsFtZQFG4sEdcrz0yw64qbR6k+51OXU8U9ajU08G udnMyRXG7bznGehx+dPBqIGl3VNiGiXdRu471FvpN4xS5RcpMXqIXCscAOPqjD+lNLimlx61SiNR Ji9NL1CZB/kUnmZp8pXISl/rRvqDf70bvenyj5TpbPQIZrXSpbq9kibVJmigWKASAYYLliWXHJ7A 8VYj8J7tPnuGnvJZbe8e0lhs7PziGXncPnBK9OSByelSaFr2hNBo9tq5uIW015HilRdy7jIsgY45 /hK42n72cjtBL4i0270uaGSa+tLmXVH1EPDCriMnICg71JI4O7j6d61UYmyhCw+LwnHfWE15p2sQ TRR3Pkq06GAMoQOzfMeNoJJGOikj0qLXvC/9iWlxP9t87ybxbXb5W3OYhJu6n1xioNT1nSX8PyaV pkN0kf21bhDMB90QhDkgn5i2Txxz26Voa34o0rXY723k+2W8Ut5HdRyLCrscQiMqV3jHIzkE/hQ4 xsDjC3mYmvaZ/YmtXGnef53k7f3mzbnKhumT61nbver/AIj1ePW9fu9QijaOOVhtVjk4ChQT7nGf 8ay9wqGlfQiUdXYl3Um6o9wozSsLlJM/Wta10mB9DfVry7khtxci2VYYRIxbbuJILKAMY7msXNdH omq6QdHGjawtwtubz7R5sIz1jKc85G0kNkBs4xj1cUr6jjFX1L7eB3h1e706e9YyRWhu4vs8BkMq BiuMFhh+mAMjnrUFv4Ti1GO9/s/Ut8tqkWYriAwN5rsw8o7jwwwB3BJx71fvvGOm32uancTJcJDL YPp8LQoH3KWJ8w7ipHGPl/UVlz61pMei6nZWgvpJr2KDfPcAZklWRndm+Y4BBAGM9OfU6NQNHGBL qfhD+zdOurv+0Y5/Itref92mVfzXZcBs9BtznHOegrJ1fSzpX2H995v2uzjuvubdm7Py9TnGOtbU /ijTrvSW02VLqOOTTrW2aZY1YrJCxY4XcMqc9cg8dKxtf1aDU57IWySCK0s4rVWkADPtB+YgE45P TJ6VMlHoKSj0HaHpMOrfbvOu5IPsls1ydkIk3Kv3h94c8jHrz0727vwtJa2Go3hu1eG3igngZU/4 +I5WIVuTlTx0I/xNfw7qdjpv9pfbDcD7VZvap5MSvjf1Y5YdMDjvntV2XxXBPdNaSW0jaK9tFZmP OJjHGSUkz03gknH3ex9aEo21BKNtR0fhOBsedqMif8SpdTOy3DfLzuXlxyOMevPTvjaxpj6TdrEZ RNDNGs9vMoIEkTZ2tg8g9eD/APXO1aeKLWS7v5b1JoYZdPOnWsNvGJBDGemSzAkjH45PTAFUdT8T XU13GdMnurO2gt47WILKVd40ztL7cAtyenAz+JbUbA1G2gvhbw/H4lv5rQ3bW0kcfmg+TvBAIB/i GDyPXv8AjaPg/DI7XkkUQs5ryWOe32XEaxnHMe7ucYJYZ59OXeFvFSaXrE2o6xPfXcht/IT/AJaH BYN1ZhgDHT3PTu6y8UWMWl2lpcRXDSiwubGecKGYK7Ax7cn5goGMEjGeKa5bDioWG2fg1NRhhubf VFS2ntJrhJLiLyypicKQ+GIVfmB3ZPfis/XPDkuhWWnzT3Mckt15geOPBETIQCu4Hk5OD6EEc1qQ +KNNtNJXTYkupI49OurZZWjVS0kzhhldxwox1yT7Vi6hqsF34d0bT41kE1l53mFgNp3uGGOfT1FD UbA1G2hkk02jNFQQHak/OlzSZFMpGho+kyavePEJFhhhiae4mYEiOJfvNgcsfYdc/iLeseGp9L06 DUkl86yncxBnjMciOMgq6HoQVYcEj5fcVDoOrR6TeTGeJpLW6t3tbgIcOI3xkrnjcMd+O3vV3W/E sd9oVpotskzwQSmZ7m5P72aQ5JJAyAMu/dieOeuaVrFLlsc2a6C58JzrrGl6ZZXMd1LqFslwj7Si KG3E9ecAKTnAPtnisy5GmmW1Fs10sZiT7S0iqxEnO8oARlemASDXRT+KbC21XRdT08XEs2nW0doY riFUWRArAsGDnBIbgYOPfpTVuo0l1MnVtAFjYR6jaXTXVk8phLyQmFlfG5flJOVZCGBHY84rP0m1 i1LWLWwkleEXEoiEixbtpY4HBI4zjv8An0rV1bWrSTRo9I0/7XJbC4Ny015jzMhdiIACRtVAB7no FAxWdo1zBY63ZXlyZBDbzLK3lqGY7TkAAkDkgDrx79KNLj0udE/gFzqFraR3zo015Ja/6VbGJiEX cZEXcd6YB545x65rEvNGgTQU1myu5Zrc3RtXWeAROH27gQAzAjGe4/Grlr4js9P8etrkcdxLatcS SlCgVwJA2ehIyNx7847Z4m1nVNF/4RCy0zRzO5e4+03HnKVZHWMR9ORhuW4Y46dwBWlirKxzU0D2 /l7zGfMQONkivgH12k4PscEelTaVplxrGqQafaAGadiF3HCgAEkk+gAJ/DjNJeT2lwYBa2ZtfLhV Jf3hfzZBnL89M+g4FWdC1V9C1q21KKJZWhY5RjgMCCpGexwTz+h6VOl9SNL6l/VPCzWNjc3EF2bk 2TrHdqYGjCEnZuQn/WLvV0zwcr0xzWDDE88qRRI7yOwVUVSSxPQAdzXUap4ktJ9P1GCyS6L6nKsk 4uSCtuAxk2R46jzGc5IHHbJJrD0m6jsNZsbyUMY4LiOVgo5IVgTj34obV9Ala+hpJ4Wmku7e3S4W RhcR2195cbH7HI7lQGzgMOOoOMjGehNy98Dz2FvqdxPexi3tHjWKcIWjmDSFGJIyVKEfMuCQfwJu 2vjeMXOqNeS300M99BcWyM24RRpNvK4LYU7cDA44qmviez8rxBDPBcT2+o3sdzFAW2rtEu9wxB+U lcDIz09qfule6UNX0K10yCR0vblmD4h8+zMaXK5wXicMwYfdPOMgjHpUWoaNBZaBpeppdySvf78R NCFCbDhvm3HPOMccjnjpV251bSIdF1PT7BbuWO8uElgjuIwq2oUkkqd7EsRhc8ZHU9qg1PVLG68N aPp8DXH2ix8zfviUI3mHccEMTwRjpz146UtCXYxngeOCKZjGVlztCyKzDBxyoOV9sgZ7VLp1n/aG qWllv8v7RMkW/Gdu5gM479aWee1extYorPyriPf50/mFvOycr8vRcDjjrUEZjEqGVWaMMNyq20kd wDg4Pvg1JNzoNV8MR6Ut2ZP7XKwMyiZtM2wsQcA7/M+6TjnHfpXN49q6Wz1LRtIXVXsZL6dru0kt Y454ETYHI5LhzkgD+6Mn0rnMCm7DbXQbj2op2BRgUhXG0fiadikxRcLiVWvP4Pxq1iqt5/B+NXB+ 8XTfvFWiiitzpCvbfgN/yLnjz/r0i/8AQJ68Sr234Df8i548/wCvSL/0Cemt0J7Holz1b6/1rNb7 1aVz1b6/1rNb71e0tjynufPXjD/kd9f/AOwjcf8Aoxqxa2/GX/I8eIP+wlcf+jGrErxD1gooooAX /Gij/GigDQ0G2hvfEOmWtwu+Ga7ijkXJGVLgEZBz0qbxIltB4hvrW0tIraG2nkgVY2dtwVyAxLMT nGOmBx0qjYXcmn6ja3sSq0tvKkqBwcEqQRnHbiptV1E6tqMt61rBbyzMXkEG/DuTkt8xbBOe3HtQ Mo0UUUCCt7wrpVrqd7eS3gZ7ews5L14VbaZgmPk3fwg55Pp+YwavaVqt1o96Lq1KklSkkci7klQ/ eR17qfT+uDQBq+JNJtbXTNJ1S1jW3F8sqSW0cvmxo8TBGKPk5VuoGTj1Ixil4ag0y58R2UOsy+Vp 7yYlbdtHQ4BPYE4BPGATyOtQ6pq9xqgt0dIoLa2j8u3toARHEOM4BJJJPJJJJPfpTbnUFuprN2sL NFtokiMcUZQTBc/M+Dkse5BB+lAHT3el6Za+GrXW7zS7bempG3kt9Pv98c0fl7gGffJtOR2IOCfU GprLw/pOsXukaVPFFp+q3E8jTxWUjuIoFQnbJvZtspKngH5QfmGcCse08ZX2nXVjJY2tnbQWTO8d rGr+WzsrKXfLFmbBwCW4AwMc0y08Vy6bLbS6bpOmWctvP5wljjdnb5SpQs7MdhBPAx6jBoGP1Czj tL2DVJ9EgXRzKY/Jsr/zVcjLBGlDPhsEZ6ZAOAOtdBp/hKw1u30xZYILG4n1CSB20+c3EbRLD5hy 29wr5GByOCTtOK5oeKJo7a2tLfTdPhs4Lk3RtjE0scrldvziRmONuRwR1z1wRLa+Mr7ThaJptrZ2 UNtctdCKNXZZHKbDuLsxxtyOCOp74IAItZ01kljvv7PgsdLklMIeyuRdhSOcFvMIL7SOMqDjgDmr HjTTdM0270v+yYpY7a502K4/evl2LFuW5wDgDIHHpVG48QPNp0OnR6fZwWEdz9qa3j8wrK+NvzFn LYwMfKR1PfGDWvED63DapLp9nA1rEkEUkPmZES5wnzOQRz1xn3oAveILOxTwx4f1O1sorWa9+0+c sTyMp2OFXG9mI4z371zsSrJMiNKsSswBkfOFGepxk4HsCa0tV12XVNPsLH7HbWttY+Z5KQb/AOM5 bJdmJ5H+e2bEyxzI7RLKqsCY3zhhnocYOD7EGgRuXHg/U7XaJXtg006QWYEuftpbGGiPQrhlJY4H IHXgRXvh0WLzxvrOmPJbTiC4RXkDRnO0thkBcAjnZuI9KluPGGp3W0ypbFoZ0nsyIsfYiuMLEOgX CqCpyOAevJr6lr51JbonS9Ogmu5fOmnijdpGOSTguzbAScnbjPA6cUDLGpeENQ0u3v5JZraR9PkR LqKNm3Rhz8jcgAhuDwSRuGQOcY9haSahqNrZRMqy3EqRIXJwCxAGcdua27vxdeanNqovI4I4tXa3 +1NDESUEWMFAW68dCefUVXtZdH027hvrS/vpLm2kWaJJbBAjOpBUMRNkAkDOKANC8+H+s2kUjpLY 3RSeOApb3ALZdtgbBxgeYCnODuU8YGaqv4UlF8bGLVtMmuku0tJIVkdWV2bZnDqNwB67d2OuMU4e NdXAvdpgVrqVJgwj5hKTNMNntvdj827jimP4rlN8b6LSdMhunu0u5JljdmZ1bfjLsdoJPO3bnpnF AE2reCNT0jT7q9kuLGeK1kVJRbz7mAJ27sccbwyc87lPGBmsSeC0j0+zmhvvNuZd/n2/lFfIwQF+ YnDZHPHStO58Wald2mp2sywGLUGUvhCDGBK0uE56b5G65ODWZPqV3dafZ2M0u62s9/kJtA2byC3I GTk+uaAKldN9jsf+Fcf2l9ii+3f2l9k8/fJnZs35xu257dOnbPNczWqddl/4Rn+wvsdr9n8/7R5v z+Z5nTd97b935cYxj35oEXp/Bt9FFM6XVnM0dmL9URnDS25x+8XcoGBk8EhvlPB4zC+mRL4Fj1MQ wPI2oeSZ1mfzE+QnyyhXbjjduBJ5A9cP/wCEv1A/8sbb/kFf2T91v9T/AHuv3vfp7VW/tyQeGP7C +yW3kef9o835/M8zGM/e2/d+XGMY9+aANHWfD+n6f4S0jUIL+CW4uWnLsvm4mCuqgICgwF5J3YyS cZ4FVW0uJfA0epiGB5W1DyTOsz+Yg2E+WUK7ccbtwJPIHriJPEV1/YSaTJbWc0USyLBLLDukhWQh nC84ySvUgsMnBHZV1uX/AIRr+w/slt5Hn/aPN+fzPMxjP3tv3flxjGPfmk2JsefDtwNIm1GO4glS 3WFriJRIrxCUZQkOoBB4+6T1B6c1fNjZt8P49SW2Vb1dS+zGUO2WTyy3IJxnJ7AdB75S68X319De pcW1ozX0SR3ThXBlZMbHOGwGXHYAHJyDxir/AG3J/wAI5/Yn2W28jz/tHm/P5nmdM/ex935cYxj3 5rNtGcmjVtNHhfwBe6sbW2lkjmC/aftEiyQ/Mg2+Xt2t1znPRvUYqnDoDS2lvOdT06NriNnjjeUj JAztL7fLVsY4LAjcucZpbXxLcWvhufQls7RrWdi8jsH3lsjDZ3YyNq9sccg85dZeI5rGJRDYWAmF u1sZ/LYF0OfvqGCOef4lOcDOcVLaM24jtO0+Ofwzq98YoZJLdoQGMrq8O5sZCgbWDdOTxg+1WLTw reXkdk8Fzas17Ez2ybnBlKZ3oPlwGGO5AORgnnFCx1mSy0i901bW3kivdvmu+/f8vK4wwHB56fXI 4q5Y+KL2w/sryorc/wBmed5O9WO7zPvbueevGMfjUe71I93qTQeFruSKJ2ubWIyWhvWR2YmODn5z hSMHA4BJ5HHXGJn3rr7XxBYxaNIbi6hmuDpLWKAQSJOpJwEPJjKDru4YjHGeDxmamSXQicV0Oul0 CO+8NaRdafFCl9LHO0kId99wI2AygOQSBkkAjPOBxgZFtos15YSXMFxCzx27XLQEOr+WrbWYEqFI Bz0bse/FS2fiu8sbSyhitrXzLFZRbTsrb4/MzuON20nnuDSReLLyOKJGtrWVktTZM7q+ZIOfkOGA xyOQA3A565dosdosk021tLjwnrd1LApuLRoDFMHYEB3wQRnBGB6dz7YTw5a2l/FrCXNushg06W4i cswKOvTGCARz3B6D3zn2etyWWkX2mra28kd5t81337/l5XGGA4PPT65HFJpGtyaOLvy7W3n+1QmC Tzt/3D94Daw68c9eOMU0loNJXRbtPD093b2Mz3lrbC/laK1WYuTKQQp+6rADJxyR+VPTwteZtlur m1tJbq4e2gjmZyXdG2NyisB8xxyR+XNVrPxNPaW1jC9pa3IsJWltWmDgxEsGP3WUEZGeQfyqSPxd eZtmura1vJbW4e5gkmV1KO7b24RlBG4Z5B/LimoxKUYkkHhW9mWMvc2sBe7axIkZyUnBwIztU8nq CMrxyQeDiXMMtpdTW067JoXaN1yDhgSCMj3rRj8VahHEiMsMjLqI1IuyHLS++CBt9gB9ay728kv7 +5vJQoknlaVgoIALEk4z25puK6DcV0Oq8G+Ho9R1C1l1OGE2NyzxRJK7q8zKpYmPbjIXGCTxzjrW bY+HZr7TE1H+0LC3tWlMLPcSMuyTIwp+XqQ27IyAASSMU3T/ABZf6bBYxxxW7tYO7W0situjDn51 4IBB5HIJGTgjjFeXXnfQn0hbG0jt2uDchl8zcr9OCXIxt+XkHj35p2Vh2jYuaJpiXX9sCWO3ne0s pZArTsNpX/lopQFXx6EgHcKo3WmT2mlafqMjxmG+8zywpO4bG2nPHqeME0aPrkujfa/Ltbef7VCb eTzt/wBw/eA2sOvHPXjjFOs9fmtbOK0ntLW+ghl82BLtGYRN3C4I+U8ZU5Bx0pWQWVjRvfCV3ppu TfXtnbw28yQGZjIyvIyB8KFUnhSOSAKih8MzzJfSLqOnCGxcLPL5xZFUglXBAO4EjAAy2cAgVAfF F7Pb3EGoxQ6hHPcC5YXG8ESbduQUZTjGBjoMDAFA8TTfY9TtRp9gseosplCRsgTb9wIFYABTz0Oe +adkFolG8tzZXkts00MxjbHmQSB0b3BHUf5ODUAb3qXTr7+z76K6+zW9zsz+6uU3xtkY5Hfrn64q tuqbE8pJu96M+9R7hSg0rCsSA+9GajBpc0WCw/dS7vcVHmlzSsKw/d9KN9MzS5osKw/d70u6o80Z pWCw/PvRn3ptFFhWHZ96TcKTvSZ96dh2F3UUn40ZoCwv0oz70lGaBhn3ozSdKXigAzRSUUwA0lBo oGJS9qSloGNYgAkkAUDkZHSlpcUwCloxS0ibiUopaKQriZ96PxpaOaAuIKM06igLjfxop2KKAuN7 UU6igLiUhOKdijFAXG5zRxTsUmKAuISKqXpzs/GrmDVS+48v8aun8RdJ+8inRRRXQdYV7b8Bv+Rc 8ef9ekX/AKBPXiVe2/Ab/kXPHn/XpF/6BPTW6E9j0S56t9f61mt96tK56t9f61mt96vaWx5T3Pnz xn/yPXiD/sJXP/o1qw63PGnHjvxD/wBhO5/9GtWHXiHrBRRRQAvFHFH+NFAGn4dijn8T6TFLGkkb 3kKujgEMC6ggjuKPEUUUHifVoYo0jiS8mVEQABQHIAA7CqVr9o+1w/ZPN+0+YvleVnfvyMbcc5zj GKl1C11C2u2/tOC5iuZf3jfaUZXfJ+8dwycnPP1oAqcUcUUUAHFdL4Mtbee41ieeCKZ7TSri4hEq B1WRQACVPBxk8EEVzVTWv2j7XD9k837T5i+V5Wd+/IxtxznOMYoA6TxRY2MHhvw9dWgikeX7VC1z HF5XnpHLtRivrg9Tye5OKyPD9/Z6Zrtrd6hZJeWkbHzYGUMGBBGcHgkZyAe46jrVS+ivILlor+Oe O4jVVKTqQ6gKAoweQNuMe2KVpbzUJoIWee5lCrBAhJcgdFRR6c8AUAdS8WnWPw/j1HTlS4nXVzH5 93YxbsGE5TaS4K9+T15xxmprXTUk8JWj6BaJf3cmrtCJbqzjEmfJzs2kupTGWJLAAjOO45e7tdY0 t7V7yC+s3jz9maZHjK4O75MgYwWzx3Oe9Njl1TT4rW6ie8toy0jW0qlkBP3XKH14AOPQA0Adl4dt dDk8SaT4bWC11FUnknu70oCJZFibEcZ6mIEDrwx5wB1PC3hnT9U1nTdW837ZYzX0sE0E9qsH7wRN KuERmUpx04HGMEGuQT+2Lb7LaJ9ui82RLm2hXeu9zwkiL3J6Bh+FJc2usaR9n+1QX1ltkaW381Hj w/GWXIHPC8j0HtQB2HhXw9aX2s6brELRX9nPfS209vd2qQgN5LSZCKXUgDJA45AHA5GTe2enx/Dx LmxTz86qY3up4FimH7rIQAM2V6n7w57HrWA/9oWH2bf9qt8YubfduTG7GJE+u0fMP7o9KL211Cw2 Wl9Bc2+MypDOjJjdwWCkd9oGf9n2oA2tatbeLwR4XuI4Ikmm+1+bIqANJtkAG49TgdM1zsRiEyGZ GeIMN6owUkZ5APODjvg/jV3UbXWLO3trfUoL6CFN/wBnjuUdVXJy2wMMdSCce1UKAO/ufAenm+1P T7a5uY57C7tIjNIVdZEuGAHyAAgqGHO47sHgZ4zNb0jwtppvYob+dru0uRGLfzWYzKH2uCTCqxsB znLjgjniudl1PUJ/tHnX11J9p2+fvlY+btxt3Z+9jtnpT7uLVIoVlvY7xIr1hOHmVgJz/fyfvH5z zz973oGb/jWDS7eHQxZWLW8s2mQTFhIuCDu+8Ag3P0y+Rn0qx4r/ALM0yLR4La0ieC80q2eb/Ro4 pCA2RIrjcVkYBg3UY67uMcgbq4e3W3aeUwLjEZclRgkjjp1d/wDvo+ponuri68r7RPLL5UYjj8xy 2xB0UZ6AelAjstU8KaBa63JoMOo3cepLc28SNMgdJRK3IAUDBRWQklhuO4ADjFe88PaOttr81ul8 n9iXccUgkuEb7QjSFDjCDYeM5+b6VytzdXF7cNcXU8s8z43SSsWZsAAZJ56YokuribzfNnlfzpBL Lucne/PzH1PzNyfU+tAzstY8IaXpq67se8dtHmti5aVcTxzH7o+X5GAIG75gSCdozgVPGsGl28Oh iysWt5ZtMgmLCRcEHd94BBufpl8jPpWLcS65JZSXty+otaXrKsk8hcpOV+6Cx4YjacdcYNUXurhr dbdp5TAuMRlztGNxHHTq7/8AfR9TQItlI/8AhHt/9ly+Z9rx/aO9tmNn+px93P8AFnOfwrPxmgCp /ss4s/tf2eX7N5nledsOzfjO3PTOOcUAzoPsluPhl9r8iL7T/bHl+dsG/Z5Odu7rjPOK0pvCGltF MIHu0kOijWImeRWVBxmJgFG4/e+YEdR8pxzxv2m4Np9kM8v2bf5vk7zs34xu29M44zVgalqH/P8A XP8AqPs3+tb/AFP/ADz6/d/2elK4rmudPtj8PI9QQMs41PyHysZDfuy2Q20OBjA27iMgnHPGhrsG kR+C9BntdPkhmuPtG2QyoW+WQA+YQgL8dOmPeuW+0T/ZPsnnSfZt/meTuOzfjG7b0zjjNWrmHUtN X7Hdx3dqrqW8iVWTcCRztPUEov8A3wPSpbIbNVrC2PgCPUEUical5D7ljOf3ZbIbbvA6DbuIyCcc 8aOoeEray0LUJmlaLUtOW3NxB5vmD952P7tQp5B4Z+hHvXKC4n+y/ZfOk+z7/M8rcdm/GN2OmccZ p3nzNvzLId8YifLH5kGMKfUDauB/sj0qG0Q2jr9MsbNvhXq921rAbmO7VUmMY3qMxcBuoHJ/M1na XZW9x4Q1y6IYT2zQYJVCCGfGBldykYPKsM5GenNC2i1iTSZ1tY79tNDFphEHMORgktj5cjAPPtUc EeojTLiWFLoWDMqzugbyiQRgMRxkEjGfWpbJbNuz0fSLjSI7pDeXDpC73ZgljEluw7+SRl05X5g/ TOduMVFplnbz+EdcuiGE9s0GCVRgQz4wMruUjB5DDORnpWGtzOoTE8g2I0a/MflRs5Uex3Nkd8n1 oS6niglgjmkSGbHmRqxCvg5GR3wfWloTodfpnhjTtQi0QF7pJNVimCt5ikRSRZyxG35lbj5cgjnk 54SLwxpwiiEz3TyDSDqsrJIqhhziMAqdp6fMSeh4545WLUr6DyPKvLiP7Pu8nZKw8rd97b6Z7461 p23iSCz0+SKDT2W6ksWsWkNwzR7GbLMEIJDH2bbkk45xTVilymIWrrbbwtYz+I9B05pbgQ6hp63U rBl3KxR2wvHA+UdQe9cY2CMEZHpT1uZkgaBZnWFs5jDHaclSePcop/4CPQUJIIpG9plpb3Hg/Xbo hhPatBg7UYEM+MDK7lIweVYZyAelS6bpGiS+HINW1SS9RDe/YpBEy4yQG8z7pIATdkYYk45Fc/Cb 77Bd+QLj7H8n2ny93l9fk34469M9+lQG7n+y/ZfOk+z7/N8rcdm/GN2OmccZqkikjsNLttDHhbxI 7Wsl59leELch1RnUysA0eUJjyMZB3Z9qNG8KWGo/8Iz5s1yv9q/avO2Mo2+VnbtyOOnOc/hXI20t 3CZJrR50MahneIkbQHUgkjoN2zHvjvio0uZovK8qaRPJk8yLaxGx+PmX0PyryPQelVYqyOv8N+E7 bVrezF9K1vJqDTCzdZclhGvJ2eWQQG9XXPb3peEra3uv7d+0QRS+VpFxLH5iBtjjbhhnoR61zsdz NF5XlTSJ5L+ZFtYjY/HzL6H5V5HoPSiG6ntvM8iaSLzYzFJ5bldyHqpx1B9KLILITd9K62x0HQot C0vUdXvpIvt7y8K7LsRGCnAET7j1PJXqB6muWtLK71CVobK0nuZApYpDGXIHTOAOnIpkd1NF5Xlz SJ5Mhlj2sRsfj5h6H5V59h6UJAkdjpdvoY8LeJJGtZLz7K8Krch1RnUysFaPKEx5GMg7s+1V7S10 v/hXhvLyJhIurbBJDEpkceVny95+6p55+bB52muWgup7V99vNJC3HzRsVPBDDp6FVP1APal+1T/Z PsnnyfZvM8zydx2b8Y3Y6ZxxmmM7q/8ABukaOuoTXt/IYYb1bWHc5j4MQk5KxyZOGA+6B8pPcCqM Wi+HpLXW72K6vbmz0142jePCGZJAQq4ZflIfGW5yM4UcVytxfXV20jXN1NO0rK0hkkLFyowpOepA JA9ATQb67K3Cm6m23LBpwXOJSDkFv7xySee9LQWh040bQnstbvra4u7u106WEoysIjNHJ8u35kJV lbq2CDjoM5rSv/BukaOuoTXt/IYYb1baHc5j4MQk5KxyZOGA+6BwT3ArhY7q4iglt455Ehm2+bGr EK+Dkbh0OD0zTri+urtpGurmadpWVpDLIWLlRhSc9SASB6AmjQNDs9Ds/D327xDDCkmo20GnzTQz yYX5AFOArJlXBJG//wAdrjJGjMrmJGWMsdqs24gdgTgZPvgU37VMZ3nM0hmk3b5N53NuBDZPU5BO fXJpJJXnleWV2kkdizu5yWJOSST1OaTEzqvC2i2cyWuqaiGlgfUobKG3XGGkJDEvkEbAvYDJ6cda nl0TR5Z/E97cxTxppd6QsVsUVXV3ZEUAr8mGC888cYrjhI4iaLefLZgzJngkZwSPUZP5n1qf7ddM twpuZitywacGQ4lIOQW/vHJJ570C0Ruxafoq+MNOtbC9kvrGaZFD+UEZCzEBSHUhscE/Lg5IwKmu tEtmh8V3JeQPpl0qQhQqqwaVlOQAB0HbA9q5iKV4ZUlidkkQhkdTgqRyCD2NPNzMZ5JzNIZpN2+Q sdzbgQ2T1OQTn1yaWgtDtR4R0qLT/t9zdzJCmm2t04Z9o8yZmH3lRiFG3gbScnqKrWeh+Hr6/vUt 766ltbexF6zxdU2EeZH8yrvJB+VsLjIyDXKNcTO87tNIWnz5zFjmTJ3Hd68gHnuM05b66QyMlzMp ki8lyJCN0eANh9VwAMdMAUaBddi3qkenRzwtpk8ksMkKO6SD5opCPmQnA3YPcADmqOabFI0EqSws Y5I2DI6HBUjoQR0NOkleaV5ZXZ5HYszscliTkknuahohoXikJpuaM0WFYdmlyKbnNGaLBYdmjNNz RmlYLC5pabmjNAWFoopM0BYWkozRmgApaTNGaYBRRS4wOlIYYp2MUmKdj2pEiYFLRQKBMMUUtGKQ gxRilopAGKKMUoHtTATFGKXj0o49KQhMUYxS0UAJS4oxRigAxRgUuKMe1ACYFUr8Y8v8f6Ve2+1U dQGPL/H+lXT+JGlL40UqKKK6jsCvbfgN/wAi548/69Iv/QJ68Sr234Df8i548/69Iv8A0Cemt0J7 Holz1b6/1rNb71aVz1b6/wBazW+9XtLY8p7nz741/wCR88Rf9hO5/wDRrVhVu+Nv+R98R/8AYUuf /RrVhV4h6wUUUUALxRxR+fWj86ANXwx/yNmjf9f0H/oxam8XWs9r4t1T7RBJF5t3LLH5iFd6GRsM M9QeeazLCzk1DULWyiZVkuJUiQuSACxAGeOnNTarpp0nUZbJrqG4lhYpIYN+FcEgr8yjJGO2R05o Ao8UcUfnR+dABxXUeBZY01W+jDpHfT6fNDYMSFb7QwAUK38LHkA5HXGea5f86vaVpV1rF6LW1Cgh S8kkjbUiQfed27KPX+ZxQB0XjSSEaVoVq8H2e/hjmMts7l5LeFn3Qxsx54Q8A8gdhmsqxXWPDOt6 XeQW+LyaNJ7VMCTzUkyoGASfmGRjg89jiqmqaPcaULd3eOe2uY/MguYCTHKOM4JAIIPBBAIPUdMt 0jSrrW9Vt9NswpnnYhd7YAABJJPoACfXjigDsrq6stK8H2VrrGhRQySak1z/AGWsssTSRCJk8xiz MyfP0zjO3gdTR4uSXUPBvhaWOwvhJLJMsSuQ20Mw2JhUUfMANgAACjAB6jlb3QpbXSU1SG8tryya c25kg3jbIF3YIdVPI7gEcGrV34L1uz/spJLYm51Pd5NspPmLtx98EYXhgevAznGDQM6PxXZa/Lq3 hqe2W8ivn0yCD7Q8hiPnkPuQyMRhzzwTk596qara3A8BWto+mNpt1Lq58rT0SQNP+6A3hZCzkgkL wcc9CcVyWo2SWF21ul9bXm3IaS2LFM5IxllGenUZBz1q7rPhnUtBsbC51BFiN6rskJJ8xAuPvjHB O4cZz64PFAHoTWtx/wAJ34Ou9Ugl8v8As6GKSa6Q4+0bJCFLN/y03YOOucd65LX9NQeGI9VvtNbT dXl1B4zE7Shp49gYyESszEhjjcDjnnPFUrvwXrdn/ZSSWxNzqe7ybZSfMXbj74IwvDA9eBnOMGsr UbJLC7a3S+trzbkNJbFimckYyyjPTqMg560AdL4ntbiy8EeFLe6glgmT7ZujlQqy5kBGQeemK5ex t4rvULa2lnS3imlWN5n6RgsAWPI4A56ir2qaFLpen2F99strq2vvM8l4N/8AAQGyHVSOT+hrMiQS TIjSCNWYAu+cKM9TgE4+gJoEdr4j8M6fpnhy9ktdPvIru01PyWkuJCzNb7SFkwFUBGYYBweQRuPS pbmxU+GfAQ1GFksTcyrcNJlFCPMpGW4wCmSDnoCRXJa3o9xoOsT6ZdPG80O3c0RJU5UMMZAPQjtW f+dAzvdS8JWUNldqbdrKRde8jz5d2IbJsqkhBONm4HDnqQRmovEfhnT9M8OXslrp95Fd2mp+S0lx IWZrfaQsmAqgIzDAODyCNx6Vw/50fnQBoXcLpo+myNcWEiSeZtihC+dHhhnzcAHnquSeOmKi0uC3 utWsre7l8q2lnRJZNwXYhYBjk8DAzyaqfnU0lrcQ28NxJBKkM2fKkZSFkwcHacYOD1xQI9KvNKtr fSZNOnsvsunw+J42kiYuoW1K+WJCzHIVsH584znGOgzL3RNK0zUL37X4bvLfTk1COI3l1eEKsfm8 +Um1WcMgboWIHOe54LFabaLOvhyPW1uIGt2ufspjUt5iPtLcgjGMAHgnqPfAB1d9oGiW91rOqJbq ugPp+dMm85irXDKAoHO4tuWTKn7uOQBis0aZL/wq77d5V1/yFc53P5fl+Xt3bc7fvfLuxnPGe1cq BmnAUribOy8ReG/sOs6pNpekq+ipbK8NxLI4iUMifOkhYB23HgZbOehq9r2gaZY3mqSWHh65lsFt Q8N418Vtl3IuHQlfnOTwu855wPTixY/8Sr7f9qtv9f5P2fzP333d2/b/AHe2fWq4HuTUtktigV6b qWl2139ngv7PE1l4U89dxdHWReACM4+U54x3Oc8Y80FOA471NyL2O7v/AApptjo+si3t7m4ubeCC a2u2kJSdDtMrxqoA2qG5OWxkcjuo8O6UOlqf+RZ+3/61/wDX/wB/r+nT2rltY0ebRpbZJZoZlubd bmN4S2CjZx94Ag8elZxpN+Qm/I9Kg0VNO1rWodPtJfsMuiyQWk43MLt2RX+VujMfm4XsvA4NYeg2 88ngTxQ6QyMh+zYYISDtcs35A5PoK5HnpuP1rR0rR5tWivnhnhVrO3a5dJCwLIvXbgEccdSOo96L 6ivc6s6JpyppNzbaBcahDJp6zXEq3vlW+8Bt+9yCFIIOfmUdBj1pT2FhpXhrw/qV3oj3AuTMbotL JEXGT5YyDhQQd3AyQvpmsG20ia70S+1SOeHy7JkEsRLB/nICkcYIznv2+mczNA/kKOO5/E11s+nW GkeGvD2p3miPci5aY3RaWWMvyfLGQcKCDuHHIX0zXH5ppNCQJHenQtNVNIurbw/dajDJp6TXEqXx itvMAbfvcghSCuT86jgDHqqeGNNmszex2Tvaf8I4bozq7lPtY6/NnG4YOV6cHivPiT6mr0OtX1t5 nkSRxebamzk8uBF3xHqDheSf733vetEaI29E06S58D+JrpYrpvL+z7DG7hGw+XyAdrbVweQduc8V LoPh1Na02zP9nyrMZ2WO7jDTQS4/5Z3ARt0PO0Bhj5WzjjdXH5qxY2f24XP+l20HkQNN/pEmzzNv 8C8csc8DvzQhpHWeH7Wa/wDD/izTLSGJr2d7byraCQMCBMc7Tk5Vcj5skAYJPepbTw9ZS6Jos0Gi XOq3rzzRXf2O7xGGWQBVkYBgAVI5BXjnJ4NcHn3q9a6XdXmm6hqEQX7PYqhmZmwcu21QB3PU+mAf bLsOx1LaXY2/hKfW5ND3gawY9ondlW2GPlWRTtI3ApvwevHOKsQ6NpeoaTpF9p3h28vZLi5nE0Nr eELEBINkcrFWwNpHOU45J7jgD+NFFgsep+FtOsLbVNC1SztFQS3l4t1Ks5mS14KRQ7wduDuXBPLE jBwcV5jLHJBM8UsbRyoxV0cEFSOCCOxqLmtLQdFn8QaqmnW1xBDPIrFPOLAMQMkZVTzgE88cUWCx RzSZpmTS5osKw/NFMBNANKwWJOvej/PWm596M0rCsOH+eadxTM8UufrQKw/NKDTB9TSjPqaVibD8 0opmTS5pWFYfS0yjn1NKwrD6WmZPrS/iaVgsOopvPrS8+9FhWDbn1596MD3/ADNLnB60lABj6/ma No9W/wC+jS8+tAzQAm0erf8AfR/xpw49fzpPwopCF4znn86TA9/zoo/GgBcD/JpMD3/Oj8aKAFwP f86MD3/OkpQOc5NADgMf/rp1J3palksWij86PxpCFNFJTqCQpcUgNLSAKKKKQhRRQKKBhRRRigQU tGPc0Y9zQAbRRtHv+dLj8aWkK43aP8mlwP8AJpaKAuJjP/1qpal/yy/H+lXsVR1IY8r8f6VdL4ka UfjRQooorrO0K9t+A3/IuePP+vSL/wBAnrxKvbfgN/yLnjz/AK9Iv/QJ6a3QnseiXPVvr/Ws1vvV pXPVvr/Ws1vvV7S2PKe58/eOP+R/8R/9hS5/9GtWDW/45/5KB4k/7Cl1/wCjWrArxD1gooooAWij n9aOaANDQbmGz8Q6ZdXD7IYbuKSRsZ2qHBJwOegqXxI9tP4ivrq0vIrmG5nknVo1ddoZyQpDKDnG OmR71V0uyOpatZWPmeX9pnSHfjO3cwGcd+tGp2R03Vryx8zzPs07w79uN21sZx26UAVKKOaOaACt 3wrqtrpl7eRXjMlvf2clk8yruMIfHz7f4gMcjrj8qwua1tB0U61cXStceRDaWkl3M4Te2xAOFXIB OSOpFAFzxJq1rdaZpOl2sqXAsVleS5ji8qN3lYOyomBhV6ZwM+gFUopE0nU9OudK1jE3lpI8/ksg t5DkMhGCWAHUgEEHGD0p+saBJpWmabetIxW9WQNFJGY5IpI22upGTwD0PB9QKi8P6Umt67a6bLdr aLcMVEzLkA4JAwSMkkADnqaAN++8Uix0OxsbG5s7m+ivTfG4trJIoYiFKKoQou5v4txUY4xnGRp6 Z4m0uy/4RK5u9T+0TWMl0b0BJGdTPk7iSoDYJ+bBJ9N1Zuj/AA9vNRgtHvZZ9OlubxrURTWrAgCF pN/JGQdpX+vasrTPCeqX2u2Wl3VtPYNdswWS5hdRhQWYgEDJA7epHIzQMv3msWdlpdnNaz6dca7B eNLHc2disaRxbAAGVo0DNu5B2nGOop+o6+kegeHJbPVIp9WsJJ5Zt8TOweVt4bMi7WI7nJ+bBGet GkeBjrC2UkV9LDFc3cls3n2211xEZUYLuOQyYPUYzxuHNc7caTf2MsKajaz2KzNhZLqF0XHc9MkD IzgE0AdvpnibS7L/AIRK5u9T+0TWMl0b0BJGdTPk7iSoDYJ+bBJ9N1c/rV3pkvh6CHzbC61YXbP5 9jaeQiwbANrDYmTu5HBxg8jPNmbwbbJ4o0rSU1lWt9StluI7toCgAYPtG0t1O0Acg5bpWZe+HLjT fDyalfGW1uZLswJZzwlHZAm4yDJyRkgdO/WgC14gvLBvDHh/TLW+iu5rL7T5zRI6qN7hlxvVSeM9 u1c7EiyTIjSpErMAZHBwoz1OATgewNad/opsdA0jVPtG/wDtHzv3WzHl+W23rnnOc9BisyKKWeZI okaSR2CoiAksScAAdzmgR6F4h8W6df8A/CSfZ77cXks5dMZYmQiRMeY4OAVcDjccEgAA4AFW/G11 bRXHiDRvO+03N5PamxsYo3Y28mN0jAEBQX3H7hJJfnqa41fC+vWtyrQwp58NzHCTb3cbtDKzYQNs YlDuGMnHNT6z4b8Xf8ferWl9cMkiW4kkkMzZbBUDBJIJbGRxuOOvFAylF4f1q0lS5udI1CGCFhJJ I9gXCKOSSrAKQB2PB711E3iW2icXN34ik1Nk1K3uFhiidlaNDksFlUeS55PyOQd23AXkcre+G9V0 +3nnnhiMdtII5/JuI5TCxOAHCMSvII5xzxVS4svs+n2d39qtZPtO/wDcxyZki2kD51/hz1HqKBHa 65rPhtdG8Qx6ZeyXF1qs8bMPIZASJml35Y9AHCY4OUzjBzXH3d1by6RptvHPfPPB5nmxzODDHuYE eUOoyPvZ71n89a6O78HX9joEV/cBlu5bxLVbJVDSfNHvUnBJDHgbCAeR60AYlg1tHqFq97G0tosq GeNOCyZG4DkckZ7iu+1PxLpNxaC3mvory3t9ZivIYEgcIbQDYIVVlABVRyDhTnqSTXKv4S1pHKC2 ikdZ0t3WG5ikMcjHaofax2ZIxlsDPFVm0TUUj1GRrfCaa6x3Z3r+7YttA688gjjNIVzqte162vpd Rlstf8rTJ7VI4NK+zu+0hUGzYwEceCCdysSMcZzUl94m0uW61jXIp2a61XT/ALH9g8sgwMyhWYv9 0qAgIxyd2CFxmuVfR5Y/DsesHd5b3PkDbsKg4J5IfcG4PBXGMHPIqaXwxrFvDM8lqgaGITSxCZDL GhwdzRht4HzDORxnnFK4m2aD6hayfDiPTH1FWvI7/wC0JblZCVj2ldoO3aDklsZxye/Famua7b30 moS2eveVpk1qkcOlfZ3faQqDZsYCNMEE7lJIxxmudm8MavBFM8lqoaCITSwiZDLGhwdzRht6jDAn I4zzisrtUtkNs7fXdct76XUJbPXzFps1qkcOlfZ2faQqDZsZfLTBBO5WJGOM1xdb2oeEb+zsra7g 3XUElhHeyMqBdgbqAMksFyMkdAwzjNZ76NfJpp1AJFJart3vDMkhj3Z271ViVz0+YDnjrSd2KV2d lc+I9KMDWLXsU1svh8Wg2wNte6U/L1UE4xlSeBk4wSaq32qaRJoep6fDqks8EsFu2nxXXmO1u0YG 9TlcKzZYDb8vUZUYrn5vDWrwRTSPbIViiE7BJkcmI4/eKAxLJ8w+YZHXng4mj8L3n/CN3ms3LiBI Y4pIoSAWlSRyobG7KjjIJHzdqeo9TpLfxXZf8JFoz3GoyNpx09Y9TVg5SWby2VvMXHzn7gzg9Bzx TLDxBpNvpKWUN+trbT6VJay25jfi7cfNM5Cncp2gAgkjIG0DOOdtfDhuvB194h+2BRaziH7P5Wd2 SnO7PH3/AE7VXi8NaxcQwvHbIWmiM0UJmQSyIMncsZbeRhTjA5xxmjUepe0e9sYPCGv2c97HFdXn k+TEyOS3ltuPIUgZzgZPXrgc1pNrtu9rpYs9f/s61t9O8i5svs7SeZKA+4+Xt8p9+RyzDrk4IrAg 8Ka5c2kd1b2YlhlTfGySofM4Y7VG7LMNjZUZYY5FYhNNaAro7O78TtaeE9Gt9O1aN7yON4r2Mwli 6Hd5aMXTDKqsw25wCeAcZHF5rZg8J63dWkd1BZebDLH5kbJKh8zhjtUbsswCNlBlhjkVHD4Y1m4i heO1QtPEZ4YTPGJpEGTuWMtvYfKSMDnHGadrlWN678UNaeEtGt9O1aJ72NHivYzCWLod3loxdNrK quy7ckAngHGQ9tftntNKFn4g/s21t9N8i5svs7y+ZKA+4+Vjyn35HLMOuTgiudh8L6zcRQypaqFm iM6iSdEIiGf3jAsCqfKfmOB055GYbTR5brQr/VRu8u0aNTs2EAsQPmBcMo5GCFYE56YNUUehaddh 9NDW80tr9k8MSSR2jxyRskwyDcpxs+bccOG3HcfeuS8HajaWMOuRXupLax3mnyWyI6yMHkbhWIRT wvPJ5+bjPNRQaV4ouNKhs45JzaTxGaGxN4oMiAltywFtzDKkjC84yM0zSvCs+qeH7/VEu7WP7N5e yJ54xv3MVO4lx5eMZG4fN2oA0/DesxWllYRSeI2sIYrlpJ4Y43ikA9QyK6yg8ZEgyNgUYByXaB4l SLTtZ0ubXLmwS4eNrS5EbKsKiUtJtjjJ2Fgc7V47ZHFYFl4b1XULeCeCGIR3Mhjg864jiMzA4IQO wLckDjPPFS2nhLXb6ISQWOU3tExeVE2SBgpRtzDa2WACnBOeAaAN2x1u0h0XSLTTfELaO9pczNdO 8MgM4ZwUcpGGVyFGNrHtjpzRD4nXT/B7Jp+somqLqDzRL9nKOtuSCUAClEBdVcorbccc9Dz9v4X1 m5WNhapEZZWhjW4nSFpHU4ZVV2BYgnHA68dc1b8OeD9Q1/UhbyBrOBZWglnlXlJArNsCsQWb5eQO QOTQM1bHxBEdF0eK015NEube5mkvtkLgTFnVlYJGpRwFGNrYHGOlXfDfifRtJ/s6WO9+zBbud9RQ WxR7oNlYmAQFQqhiSm4AYOATjPnXNHNAh0qCOV0WRJVViA6A4YeoyAcH3ANNo5o5/WgA/Gijmjmg BaUfWk5oFIVh4paYCaUfhSsKw4Uv44poNOpCsL+NHfrSZoGfUflSJsPzS5pnOOo/Kl9elFhWHZpa bzilyaVgF/Gl/Gm0uaQrDgaKQcUCiwrDs0flTcmgZpBYd+VGaTJozQAtH40lFAhfxo/GkyfWlGaA F696ApzncfpxRzSgN6j8qQh/elFNpakli0uPekpeaQg/GlpOaOaBC0tNpc0AOFFJQDSEOFFJSg0h BRRRzQAuPc0uMd803n1H5Uoz3P6UAxe1LSUvWkSFLSU6kAVQ1P8A5Zfj/StCs/U/+WX4/wBK0pfE jSj8aM+iiius7gr234Df8i548/69Iv8A0CevEq9t+A3/ACLnjz/r0i/9AnprdCex6Jc9W+v9azW+ 9Wlc9W+v9azW+9XtLY8p7nz/AOOv+Sg+Jf8AsK3X/o1qwK3/AB1/yULxL/2Fbr/0a1YFeIesFFFF AC0Uc/rRzQBb0u9/s3VrK+8vzPs06TbN2N21gcZ7dKNUvf7S1a8vvL8v7TO82zdnbubOM4561LoN tFeeIdMtbhN8M13FHIuSMqXAIyPY1N4kjt4PEN9a2lpFbQ208kCrGztuCuQGJZic4x0wOOlAGTRR zRzQAVq6DrX9i3F2zW/nw3dpJaTIH2NscDlWwQDkDqD3rK5re8K6Vbane3kl4Ge3sLOS9eFWKmYJ j5N38IORkjJx09QAQ6vr8mq6Zplk0bBbJZC0skvmSSySNudicDgnoOvXJNZk7W7eX9nikjxGBJ5k gfc/OSMKMD25x6mug8U6NaWNlpmo2flIl550bxQyNJEHicIXjduSjfeAOcep7Zeh/wBmf23af2z5 v9neZ+/8rOcc+nOM4zjnGcc0AWotctx4et9EmspHtlu2u52ScK7vs2KFOwhQB1yGz7Vd8P8AjKTw /YWttFZJM0GoG8LtJgMDEYymAODgkg569jW3Z6V4WOmWOr6kLQWg1B7W4Nk115bKYGZch/n3BgOV 4wec9smfQk1GztprQ6DbWkty0DXyT3KJG6xl9j+ceAR0IU8jGR3AKUniK3m0WHSJbS5ks1u2uZGa 7BlbCeXGqtswoVQAeDnHG0cVU/tr/ik/7C+z/wDL99s87f8A9M9m3bj8c5/CuwHgjTbz/hF4IH8o Xslyl1OtykryhMkFQrFRkKw+XIXcASx658Gl6KdUtNYvI7FfDTTyW0otJLltjhGZQ28ByeV5UY46 DuDKtv4z+z+INE1T+z939l2K2fledjzcI67s7ePvZxg9OtZP9tf8Un/YX2f/AJfvtnnb/wDpns27 cfjnP4V0dnYaMJLHUdSttKOhG5eC4uLJ7zcHETMqEOd2CSDlR25I75Ws2CDQ49RtLbSjaG5MDXFk 9zuDhd2wiY9CDnIHbqO4Io3+tfbtA0jS/s+z+zvO/e78+Z5jbumOMY9TmqumXv8AZurWV95fmfZp 0m2bsbtrA4zjjpW34gsrFPDHh/U7WxitZ737T5yxPIynY4Vcb2YjjPfvXNc/5zQB058aXkury31z LqEsRvEuobT7cfJQLIH2FSp3DgAYxjGcHpV2P4gbJLhv7Lz508U2PtHTZdSXGPu9/M2/hn2rNvPB 15Zahc6eb/TpL6BoU+zrMyvI0pAVU3KNxGVJ7AEc+l3UfDkNp4TYJBFPq0Gs/wBntNbGVvN/d7to Vup3HbwoztGM9SDOf1C/t9RvtSvZLaRZrqdpotsw2xbmLEMNuW4OBgr689KinntJLCzhhsvJuYt/ n3HmlvPycr8p4XaOOOtbDeCtViit3lezRptQXTtguBIySn+9syAB3Gcj06VlXemmyuL+2nuoFns5 jEYxvJlIYqdp24wMZ+YjjpQIZpd7/ZurWV95fmfZp0m2Zxu2sDjPbOK6AeM8/wDLh/zHP7Y/13/k P7v/AI9+lc06QC3haKWVpznzUaMBU542tuJbI65Ax7061tpry7htYE3zTSLHGuQMsSABk8dTSEdB L4y1CbUbi9ee+fN2tzb2z3jGCPEm8KyY+YDAAwVxjNNvPE8c1rrkNtYtEdYuUmlaSYPsCsX2qAo5 3E8ntgYzzWlP4WhHh+O3RLY6quuDTDdRvJsbKZwQ3oxxkKPu8Z6nO/4Q69W8ltJL/SknS5S2WP7Y rPIzPsyFXLAAnJyAQO3GKWoncpf2z/xSn9h/Z/8Al++1+dv/ANjZt24/HOfwqbXNbg17Xr7VJ7KS Pz4wI445x8jhQoJJT5hx0wOvWpJvCOoQavqmmtLbGbTrVruZgzbWQKrYX5ck4YdQKj+wL/whX9o/ ZYvM/tHyPtHntvx5e7Zsxtx33Zz2xSFqXdY8ZXmsalfTvLfwWlxFsS0hviEQ7QvI24ZTgkrgZz1r nM1panoc2j6veabe3Vqk1sgfcC7LISoYKuF6kHvgcHmrt/4QvdMuryC7v9KjNtEZDm8XdJ8obaqf f3HPGQAfXplO7JabLH/CYn/nwH/IF/sn/Xf+RPu/+O/rT9T8bSahZ6tZCzMVpeiBYIBcZS1WPGQq 7cfNgdMfjXKEmuy1rwxFcfZJtKW2tv8AiSDUrmAvIcY5Ygtu65wBn+E5x3eo1dlX/hMT/wA+A/5A v9k/67/yJ93/AMd/Wk1XxkdSGv8A+gCP+1vs/wDy2z5XlY/2fmzj2x71Sm8KarbaXe390sEC2axN LC0wMoEhwuUGSp5Bw20/XmnHwlqH/Pa2/wCQV/av3m/1Xp9373t096NR6ha+Jvsvgy+8PfZA32qc Tef5uNuChxtxz9z171PP4zvJm02NJdQtbS0s47Z4bS+MRlKgjfnaQCeOx6dfS7p/hyG0l1rS9VtL aW9tNKkvRJHJJvhk2qVQ4IU4zngEc9T0rM0qxs7rwX4gu5bZTd2TW5hn3sCA77SCM7SMD0zyfbDs OxBN4juDpGjWdqJLWbTPP23MUxDN5jZOMYK4GR1Oc1h7q6H/AIQ6+VrHzr/SreK8tkuUkuL1Ywis MgMp+bPGOARnv1xDb+F55rLS7uXUtOtY9SaQQm5lZAojzuLHbgDIAHOSWHvh2HYZN4kuG0jRrO1E trNpnn7bmKYhm8xsnGACuBkdTnNXZ/Gt5M2mRpLqFraWdnHbPDaXxi80qCN+dpAJ44weB1rl+a3b fwtPNZaXdyajp9rHqTSCE3ErIFEedxY7cAZAA5ySw98MZ1EGrW7afJe3F1YxxDwwdNjWO6DyNLnA UxkBwc+xUDncRXH2GtfYfD+r6X9n3/2j5P7zfjy/Lbd0xznPqMVeHg29VrAzahpVvHeWyXKSXF6s YRWGQGU/NnjHAIz364YPCGocfvrb/kFf2t95v9T/AHen3/bp70DGW/iCGOxi065smu9OWJl8qaVS 8UrYJeGTZmMZAO35gec5zUWl63HYaLqmmTWrTRagYN7pKEZBG5YgZU8npnt79Kfpmnpc+GNcvWtY pHtfs+2ZpnVotz4O1QMPnockY6jNQ22gXV5pa6hbyRS26uUufLDs1oOTvkULkJgE7hkcEdeKANBv F9xHpWmabYtfWVtZSSlzBelXmR33AEhQAQMjOD1zgdKry+JZDob6dEk6SnUzqKXT3G6QHbtAJAGW 77uOewp+naPaT+G/El87+dNYeQsDoWCHfLgtggE8DjPqcjPRsPhS9n03TtQN3p0NvfM4Rri7WIoF baSwbGR3+XccUATt4z1A6XplilxfQfZZJXuJoLxke58x95yccEc8nd1zVu08c/ZLvRZ/sMk39lyX T5lutzzecSfmbb1GeTjn2rNTwvO1lJeNqOnpbrqH9niRpW2u/HzBguNmCW3EjgH6GV/Bt6kFrcHU NK+z3MssSTNeqigI5Qt82Ny9xtycducUAc5RXceF/CMba7p6astnd2N9NcQRCOaQmQRBiZUZcDbu XAyckHp3HD80CCijmjn9aACijmjmgAoo5oxQAoNKDTetLQKw4HNOBpgNKOakQ6lpKM5pCsLmlyfQ fnTaXNArDsn0FH0pMml59BSFYM+1LmkpOaLCsPzzRSZoBpAOFFNBpc0CFpc02lFIBcn2/OjNJzQM 0AOGaWgUUiWLn2oBbuF/P/61HeglucAH8aQh2TnoMU7NM+Y9QPzp3I+lKwhaXNJnNFIQtLmm0uaB C/560c/5NIKXJ7UgClpOtGaBWHA0o5plKM0hWH0UgNKKQgoyfQfnRRQA6im5NLk+g/OkKw6lzxSU dKBDqoan/wAsvx/pV/NUNT/5Zfj/AEq6Xxo0o/GjPooorrO4K9t+A3/IuePP+vSL/wBAnrxKvbfg N/yLnjz/AK9Iv/QJ6a3QnseiXPVvr/Ws1vvVpXPVvr/Ws1vvV7S2PKe58/8Ajr/koXiX/sK3X/o1 qwK3/HX/ACULxL/2Fbr/ANGtWBXiHrBRRRQAtFH59aPzoAsWF5Jp+o2t7EqNLbypKgfoSpBGfbip dW1I6tqMt61rBbyzMXkEJbDuSSW+ZmwTntx7Vt+BYo31W+kEayXsGnzTWCldxNwoBTap+8w5IGD0 z2qxpEF94v1DS9O1o3RSaO4W01Bl+diBuwzMP3qKynjII3nkdKAOPors9N8P+G9YuWks7+8jtoLO 4urmCf8A1iCNgEy4QgBgQx2qxGCOcjB/wi2m3M1lPp8txLYm2nuLsyO6JGkXBZJWhG8cqCFjJBGO +QAcZV3StVudHvRdWpQkqUkjkAZJUP3kde6nuP6jNdR/YWlaT400GAiW9stQjtp41LjCl3AwxZPn Xg8bUJBA4xWb4tgji8V3ly1heR2kt5NuZ34nKykOY22AAdsYbB6k0DMzVNYuNVFvG6RQW1tH5dvb QAiOId8AkkknkkkknqaZc6it1NZu1hZottEkRjiQoJgufmfByWPcgg/Su2v9DttX+Ldzo+o3N5Os ygfaFZEfIhVgThNpGBjAA7HPqyy8B6fqFzBCl1dReXqsum3BYq3m+XGzl04GzO0jB3YyOTjkEc03 ia4H2OKGysYbK1kMoshEXhkc5y0gcsXOOMk8Dpiob3XZbrSU0uGztbOyWc3Big3ndIV25JdmPA4w CBz9Kt6xpWn2nhzS9UtVulfUZJiqSyq4iSMhSDhRuJJJzxgcYPWqXh/R5PEGu2ulxyrC07EGRgSF ABYnHc4BwPXuOtAGhb+Mr6zh0dLa1s4m0pmMEgDksHz5gbLEENnnABHbFQjxRNHbW1pb6bp0NnDc m6Nt5bSxyuV2/OJGY425HBHXPXBHYT6bZ+J7XwTp8U15HZSteqjzuHmEaNwCcAA4XA6heOuOc3T/ AAv4b1O607yr+6WGe7e2lKl2TPllk2yvCihtwA2YJO4YoAwR4omjtra0t9N06GzhuTdG28tpY5XK 7fnEjMcbcjgjrnrgive67LdaSmlw2drZ2Szm4MUG87pCu3JLsx4HGAQOfpVm50OOz8ILqVyLiDUH 1B7ZYJflDRqnzMFIySH+UnOAeOtdFe6FHrfivwvpr3d0La60qFwZNjPFGFkbywVVQeFxkgnnJz0o Gcpquuy6pp9hY/Y7W1trHzPJSDefvkFsl2YnkVmxOscyO0SSqrAmNycMM9Dgg4PsRXV6H4f0vxHf 6fDbQatZxTXLxTSy7ZoyFjL4WQKuH4IwQeDntgxX2kaE2hXl7pt3cPPbNH8q+bMhDNghmMEYQ9wS TnBHWgDO1TxJeap4gTXDFBbXysj7oVOC6Y2thi3PA9uOnXNu48ZX06yiO0s4C94t+pjDkpcA5Mg3 MeTnBByuBwAcmufiMYmjMqO8QYb1RtpI4yAcHB98H6V3tz4D0/7dqen211dRzWF3aRedIVdZEuGA HygAgqGXncc4PC54BGFceMr6dJRHa2duXvFv1MauSlwDkyDcx5OcEHK4HAByTV1HXzqS3X/Er0+C W7l86aeON2kY5JOC7NsBJyduM9OnFbjeErC/bWbfTDdQXOm30NorXMyyJN5kpiz8qKU5AP8AF6e9 a17plvJ4TttAtbm5McXiNbAzT4bD7MOyqPupuLELk+ucngA4CfUru6sLOxml3W1nv8hNqjZvOW5A ycn1zTLW5ms7uC6gbZNC6yRtgHDAgg88da67UvDGhoL+Kwub6S5s7pICkUb3BYGTYQR5SKreg3kE ggHoaoavpOlQQag2nQ6m32ScR+cxDpjOCJVKI8JyQBkEEhgM4zSZI2fxjfTLII7WzgL3i34MauSl wDkyDcx5PQg5XA4AOTUF74jlunnmi0+xtLqecXElzArmXeCWyrOzbOTn5cdB24qlo9pHqGt2FlKX WO4uY4nKHBAZgDj35rp9S8Ef2XpWu31wLlFtJE+xFhgOhnaM78qMnChuOzKe9INTIuPFeo3NlJC6 wC4miWCe9VCJ54xnCO2eR0BIALBQCTioP7dk/wCEb/sP7HbeR5/2jzfn8zzOmfvY+78uMYx781ov GD8MkmSadVGrbHhYoULeUTvHy7gcYGNxHBPfi/rNrZz+BNCbT9MvNxW7nysgcxhZFDvLiMbhgAZ+ XAxnNAjHv/FE2pNcTXOnWD3txEsUt20bM5AAGQCxRWwuMqoI5xikv/FE2pNcTXOnWD3txEsUt20b M5AAG4AsUVsKBlVBHOMV1mu6Zb67b2stxc3P2+DwzHe+YcFW2Ek7s8sW3HnjGM/NnA82oAcT7V0E vjG+kld1tbONW0w6WERXwsPtlidw9ST9K0da8JWGnf8ACUeTNct/ZP2TyN7Kd3m43bsDnrxjH41p XOmx6F4M8U6MJp5bi2Wze5Yt+68x3B/drjIG3aCx5OOgxQkNI5u88Y319DfJcWtozX8SR3T7XBlZ MbHOGwGXH8ICnJyDxiM+MNQ/5423/IK/sr7rf6r+99773v09q2tX8JaHp0mp2CX1zJqFlaedlFeT cwVWO5BFhEOfveYcZGe9Q3nhGwt9Y11BNdf2ZZ6b9rtbpmXbK7Kuwb9u1gzFgMdduB0NOw7FBvGt 5Jez3kljYvdXMBt7uUiQG4jKBSGAfAzhTlApyPTIOdY69LYaJqGlpaWskV/t86STfv8Al5XGGAGD z0785HFZOaBTGbp8UzSQ2gudN066ntLb7LBcTxsxVBkL8m7y2K7uMqegzmq9/rsl/omn6U9naxxW G7yZI9+87uWzliDk89OO2BxWUPxo/OgArVvtdlv9E0/Sns7WOKw3eTJHv3ndy2csQcnnp9MDisr8 6PzoA3f+EomkhtBc6bp11PaW32WC4njZmVBnb8m7yyRu4yp6DOa1rTxhaxWUtvdQtcSnRH06O4EO yRSfuoR5hUoP720McDjrnjPzo/OgDVsNdlsNE1DSks7WSK/2+dJJv3/LyuMMAMHnp35yOKl0jxJL o4tXi06xkuLV2eG4ZXSQZ6glGXeOvDZ4JHQ4rF/Ojt3oA2NM8R3OmG9UW1ncwXrI09vPF+7Zkfep 2rtwAc/KPlwcY6VLH4om+y2tvd6bp17HaSyS24njZRGXYMy7UZVK5GcEEdunFYX50fnQBsS+Ippv Dz6M1lZiF7k3RlRWV/MPGQAwUDb8uAuMds80+28SSw6fZWVzp1hfRWMjvbfaVc7NxDMMKyhgSM4Y Hr6cVifnR+dAHR2XjTUbFLPZBZvLYyyS20jR7TEJDl0CqQu1uR0yATgjjHPyuskzusSRKzEiNCcK PQZJOB7kmmfnR+dABRR+dH59aACij86PzoAKKPzo/OgAoFH50D8aAFpQabk0tIQ7d7UvSm54pQaQ h2aKbmnUCDNLnFJS0hBn2pSfY0lLmkAA5PQ0ufY0hYUZ+v5UCsGT6UoPsaQHPr+VGf8AOKAHA+1G aQH60DrQIcMmnCkHSlFSJi96WkFLmkSLRSUZpCF3H+6aNx/un9P8aKCeaAF3H+435j/Gl3H+6abu x68+1G4eh/I0WAfS1HvB7N/3yaXeMkfN+RpWFYfS5pgbPr+VOpCsLS5puaUGgLC5ozSZ9KUUhWFp c00H0pc0CsOzS0zPFLmlYVh1FJmlzSELu9jS59qaTS5oCw7NUdS/5Zfj/Srm4e/5VS1A58vr3/pV 017yLpL30UaKKK6jtCvbfgN/yLnjz/r0i/8AQJ68Sr234Df8i548/wCvSL/0Cemt0J7Holz1b6/1 rNb71aVz1b6/1rNb71e0tjynufP/AI6/5KF4l/7Ct1/6NasCt/x1/wAlC8S/9hW6/wDRrVgV4h6w UUUUALxRxR/jRQBLa+f9rg+yeZ9p8xfK8rO/fkY245znpir0us63BqLzTalqEd9Gpgd3ncSKAclC ScgZ7etHh2WODxNpMssixxpeQs7u2AoDqSSewo8RSxz+J9WmikWSJ7yZkdGyGBckEHuKAKkd/dw3 pvYrudLssWM6yESZPU7uuTk5+pqV9Z1OS9jvX1K8a7jXak7TsZFHPAbOQOT+ZqlRQBYuL+7vFRbq 7nnVGZlEshYKWOWIz0JPJ9TVhbrV9W1OB1nvr3UFx5LB3klG35vl6njk8dOTWfXS+DLq3guNYgnn ihe70q4t4TK4RWkYAgFjwM4PJIFAGbdX+uQ3tve3d3qCXZhDQTyyOJPLOcFWPO05bpxyal0jUdQk 1W3UR3mpA3JujaJNJmWTBy42HIfHO4cjHORxWl4ovrGfw34etbQxRvF9qla2jl83yEkl3Ipb1wOh 5HcCsjT7298OatZ6lbPB56KJUw6ygqwIKsFJwSCQQcMM9uKANXV9R1TxTY6bBbadqE8Fq0kUc0jN cyyyN87AuFAJCgYGMgD8ufsYrua+iXT0ne7DbohbqTJkc5XHORjPHpXd6V4gFh4Z09tNg0q21H+1 JJ4rU3B2bPIZC7l5DsPOACy5wMA9+cvk0i58JpfwwW1nqS3xhNvBM53Q7M7yrsx4bjIwOaAK8Uvi PUwk0Mmq3Qa5DI6GR8zqmQQR/GEH1AHoKZJ/b+vpC8n9p6igkaKJm8yYB9u4qvXnAyQOwzW9f6+f Cl9aaX4fuIJ7bT5Rctc5Ei3UzR4Zjg4VdrFNqnjk5J5EOoalZS/DqC0jis7W4l1MzrbW8jOdgjKl 23OxU5OMEjOMgd6AMV4tb11kuXTUNRYt5CSlXmJIBbYDzyBlsemTRcX+t3cMOo3N3qE0UEu2G5kk dhHJ97CsejcA8c8CtPxNdW9hAnhrS54rjT7ZxcSXKOH+0zsgy+QcKADtCj0OSTR4murewgTw1pc8 Vxp9s4uJLlHD/aZ2QZfIOFAB2hR6HJJoGZl5f63Mtne3t3qDqGZrSeaRyMgjJjY9wQM47gVFeazq eowrDe6ld3MQbcEmnZwD64PfBP51sa3dW8vgjwvbxzxPPD9r82NXBaPMgI3DORkdM1laEbf/AISH TPtflfZvtcXm+bjZs3jO7PGMZzmgRncVoTXWrz2lxdzT30ltcusU8zu5SV1GVVmPDEDkA9K6u6g8 P3NpNb+bYxeb4nKeZE0auloRjKntGOx+7V27vdGu9Li0wvp8VlF4lSMQwuqA2qps8wkHJBHWQnqe vTABwt3rOqahCIr3Ury5jDbgk87OAemcE9eT+dLcazql2si3OpXcyyqqyCSdmDhTlQcnkAkkehJr sbnV9Al1W5iOkWP2K21KI/avMtwFiWXB2RpGrSoy5yMvgYPvVK/j0m2sPFxJ04vNexrpvktHIQvm Fzs252rsIyeB/D1GKAsc5d6zqeoRLFe6jeXMYbcEmnZwD0zgnryfzpbzWNT1CJYr3Uby5jDbgk0z OAemcE9eTUt/LdtoGkJNf2s1snneRbRsDJb5cbt4AyNx5GSePSqFr813CuyKTMijZK+xG5HDNkYH qcjHqKRIwGtC/u9XdFTUp75kn23Krcs5EmRtWT5uvAwG9Biug1q/sriyubnT49KRorlC1pJbQLLb kf8APJ0wtxGTuByDwFJH8VWPEU8evPoEC32mR2y2Not1MvkK0LsxVhgENhc5KDhepA60WHY5L+1L /wCwfYPt1z9j/wCffzW8vrn7vTrz9aYt/eR2Ulkl1OtpI254FkIRjxyV6E8D8hXZ6vH4fi8P6zp8 U1nc3Vgtr9lu1MKmcnG8psUFgASCGZ+x6jNVtc1fSLe0treLTNMuftmlJJPJbhEeK7YAbsqPl27P uLtB3NnrRYLHP3Ooa2VW9urrUCt1E0CzySPiWMH5kDH7y5PI6Zqj9nn+yfa/Il+zeZ5fnbDs34zt 3dM45xXXazqbap4I0S3im0wzIl1JdRhbeJowJAV2jAKkjnC4Lc8Gsx5bF/h1Gp+x/wBopqZUYVBM YfLJ5I+YruJ5PsOwosFjLbWdTMSxHUrwxrEYFTz2wIzgFAM/dOBx04HpSHWdTMSxHUrwxrEYFQzt tEZwCgGfunC8dOBXazy6DcRTRONKCzeHRdMUWJCL4Y4Urgq3A/dggHnjk5l1iLSfsXi19Nt9Pkt9 PhtIbKWKKNwqybRId+Dubj7xJYHOCMmmOxwsus6nNZfYpdSvHtAoUQNOxjwOg25xgYGPpUL395JY pZPdztaRtuSBpCY1PPIXoDyfzNV69Avv+EfGv+JL2P8Asz+zZdK/0FU8s4mdVC7Yxyr7g2eAV6nG ckA8/wCM0cV6NqWqeHrXxJLpljo9je2SxiND9pto4nHljJ80x7wQc8+ZncOvas9dX0fT/DmgyyaX pl/NPHNFfxhUWXapZY+QDsOH3bgAzbRzxQM4nipY7WeW3muI4JHhh2+bIqErHk4G44wMnpmuwsLm wfTLSz8jR7e9W0cmO5SGSG7B6bpw3mQy4LcFgMqv3M4rN0mSxPgrxBFciz+1q1u1oZFTzsl/n2E/ MRgDIHA/E0COc4o4r0Owl0FdZ8PabINK/sufSw1+7rEWEzI5bdKfmRt23jcMcAYo0OXQZYfDEV8N KC3UNzDqRdYlKqm7yix6xtz94YZuMk4FAHnnFWEsLuSye9S0na0jba84jJjU8cFsYB5H5iq9dXpG qf8AFAeIrC4vv+fX7LbyTf8ATUl9ik/icfjQBzlvYXd3DNNbWk80UC7pnjjLCMdcsQOBwevoaBYX jJbMLScrdMVtyIziYg4ITj5jkgcd67vw34m0s6Pe6ZJbtZQRaRMrILxVW6lIUM2CmfMboMltoGAK 5zw0bKyivdbuJYnutO8t7O0eTZ50pbAbrkhMbio68cgdQZhSxPBM8MqNHKjFXR1wVI4II7GmcVNd XM17dzXVw++aaRpJGwBliSScDjqahoEHFHFFFABxRxRRQAcUcUUf40AHFHFFFABxRxRRQAcUcUUZ oAOKM0A0dxQAtKDSGlzSEGadxTc0uRQIUGlzSZozSCwtFJn3pTSFYWikpc0CFFGeKbRQA7I9/wAq cOKQfrSikSOHal7UgNLn3qRADmlpAaMiiwrDu1GaTvRSELmlzSdqKAF4oPWkpc8UhWDOKXePf8jS GigBfMUdc/8AfJpPMX0b/vk0A0uaNA0ASAkDDf8AfJpwOf8A64pu5e5Ao8xBxvUfjRYLD80uaarZ 6HP40Z5xnmpFYdSg03NGaBDqM0meOtGfekKw7NLmmk0ZosKw/NG4UzNG6lYLD8iqd+c+X+P9KsFw OMjPpVS9YMU/GtKa940pL3kVaKKK6DqCvbfgN/yLnjz/AK9Iv/QJ68Sr234Df8i548/69Iv/AECe mt0J7Hd6nexWZHmpcNvJx5VvJL0PfaDjr3qoHEiq4DAMARuUg/iDyKtapDJKw8tN2Cc/6Q8X/oI5 /GqqgqigjBAAI3Fv1PJ+te0tjymeA+Ov+SheJf8AsK3X/o1qwK3/AB1/yULxL/2Fbr/0a1YFeIes FFFFAC/40UcUcUAFTWttNe3cNrbpvmmkWONcgZYkADJ46mtXwxcaXbahcNqaxfNaSpbSTReZHFOR 8jOuDkdf4W5I47jV1XW9MbxD4e1aCSKT7HHAt4tvB5ZZ4X5YDCrhlA29MAAELjFAHL39nJp2o3Nl MUaW3laJynIJU4OMjpxVeu1N14bTxVqN9JfRXf2yO6kgkktGMNtM7ExFgwJfjOfkIBI69RW8QIni S7059FhF5cR2KQ3SWlqynfGdpk2hQNpBXb6AAELwKAOTq5qGntYajLZrc212Y8fvbV/MjbIB4bHP XH1BrR/4Rq9s/LfUrS4tYncJ5k8LogJ9TjPqcAE8V2d5q2jTeMtT1AXETx3dmVtrkwt+4mCKFY5X cCCnBUEjI98Q6iM5VUjitU8OTaPLbLPcQzLcW63EbwbsFGzj7wBB49Ku3/hWTTNaj0mS/sPtJbEj GRkSEYDAszqBjBzxnpjrgVoeJbu0vl0o2s6ym3sktZAFYEMhI3cgfKc5Hf1APFaGrzaBqvjoX91f rLpc7Ay+WkgZQsYADfLnBYY+XPHpWfPcy9pd7nOHwnez29vPp0kGoxz3BtVNtvBEm3dgh1U4xk56 DByRWTqViljdtbpe213tyDJbFigOSMAsoz06jI5HNdzpt/pun+JLLW7rVbeVkmaP7NZWrrHBEyNy u5VwAzcqASck8kmssXNhouh26WE1ncaul+bhbmK23eXGEwFJkQHO7kDBAIzwcVSki1NGJrXhnUdB srC51BFi+2q7JESd6BcffGOD8w4zn1weKj1XQpdL0+wvvtdrdW195nkvBv8A4CA2Q6qRyf0rofEW p22oeEdEtEubR7q3aRp4obXy9u85XbhAoAHDAHBODzjNU/EE9k3hjQNMtb2K6msvtHnNEjhRvcMu N6rnj27VakjRSRzU9rcWvl/aIJYfNjEsfmIV3oc4YZHIPrVvRNHuNe1eDTLV4kmn3bWlJCjCljnA J6D0pl+lgPs32D7T/qF+0eft/wBbzu24/h6YzzWn4J1G00fxfY39/L5NtF5m99pbGY2A4GT1Iqrl XItN8MXWqWNteR3FtFFcXwsE80tnzSu4Zwp4PAz6nsOafq3hS80q1luRc2d5FBMYbn7K5Y27hioE ilQVBIIBxg49xnU8O6zpltoGm2d1eLBNBryX0gaNyBEsY5yoPJIwB6n05p+s6vpFvp3iCOxv/t82 uXYlYJC8a2yLKzjJYAsSCBgAY556ZAMWTwzdLp+k3UVxaznVX8u2hjLBywIUg7lCjDEDr34yOaff eFrmztdQnjvLO6GnSrDdpCZAYiWKj76KCNwx8pP5c1qHWNMttI8HFbxJ5tKuWluYI0cMA0qycFgF JAGDz1PGRzU17qGnG08UW9nepf3GuXsTWsNtFLuAErP825V55AwuTk/jQM4qKKSeVIoY3kldgqIg JLE8AADqa2rnwtPaLP5mo6cZbVoxdxJIzNbBiBlsLhgrEK2wsQTRYaTrejaja6pNoWoeVZypcPvt 3QYQhjliOBx17Vt6lqehXlprSfarOSXUJkns5XsSktrulDyLI4QknDnkFhhD0yAQRlap4PudJXUB LqWnyT6esbT28TybwHKgEbkAYfMucHjIz1qxrHgLUNF0ua/n1DTJo4s5jgmZnbDrG2AVH3WYA+lX fGV/o+tXWp30WtpMu5JLG0SCRSXKxJIXZkAA2x8DP5cg5+qz2l94S8NabZXSXN/bNMslvHHJuzK4 ZQMqASOhwep4yOaAOXyfSti58PvaaVpmoy39p5GosRHjzCyBThyw2dFPBxkntmopfDmtwQvNNo2o RxIpZ3e1cBQOSSSOBWrqtzp134S8NafFqUBuLRphcKUlAjErhgSdvIXGDjJz0zQBFf8Ag2/srL7V HdWd2BbJeGO3Z/MEDZxJtZVyoxzjkZGQBzTrjwZPbpk6tpjSNYnUI4g0oaWEAtlcxgZwD8uc8egr ev8AxDo9rZebbX6XtwdBTRxDFFIo3HO+Qs6j5RgYHJJPbrVfW7zRdSsbaA+IIvJtdKiiMEVvLumu YlkCYLIAFzIec8+g4IAMy98A61p97d21wIFFvZve+cGby5UTG4Idv3hkcHH5EEvPgLUP7C/tb+0N M8ryPO8rzm8z/Vebsxt+9s5xnpz05rdvPGVlJr3isR6izaXqGnstupjbDz+UiDAIyp4YZ4BwM9BX OfbLD/hXH9m/bovt39pfa/s+x87NmzGdu3Pfr09+KBlD+wpf+EZ/t37XbeR5/wBn8r5/M8zGcfdx 935s5xj34rqr3RvE1/4YkvbnW9Me2lgSaWMMFnm2Q+YqSEIC7BOcMx9fesT7ZYf8K4/s37dF9u/t L7X9n2PnZs2Yzt2579envxR9ssP+Fcf2b9ui+3f2l9r+z7Hzs2bMZ27c9+vT34oAi/4Q/UOf31r/ AMgr+1vvN/qf7v3fv+3T3rn66X7ZYf8ACvvsn26L+1Pte7y9j7/s/wDzy3bcY3/vNucd/vcVzXFA jo7DwXqOoaPb6ms9nDFdStBaxzSlWmcbsKOMAkqwG4jJHuM85Xa6lqulTfC/TNGi1GJ7+2n894RH IOCX+UErjI3jPOODgnjNix1fw5HpS2iyWcEVzpDWkySWhaRbvJbzXcISUyFxhiQdvyjHABxtvY+f p93d/araP7Ns/cySYkl3HHyLj5sdT6CrFpok15oV/q0U8HlWLRiaJt3mYcgKR8uCM5754PtnS0W8 sIPBniGynvoorq98jyYmRyW8ttx5CkDOcDnr1wOaNFvLCDwZ4hsp76KK6vfI8mJkclvLbceQpAzn A569cDmgZzVaek6JNrEV+8E8CNZWzXTxybgXRR823CkZHHBI6j3rqDrunvZ6UbXU7CwjttN+zzxP pazTmQB94XKbSH3d3A+Yk8k1LZa5oaWkax3kVok2hvp8kHkuNlyw+aZgqkENsUFgSx+XI4OAR5/W 3pPhe91ixN3DLaxRtP8AZoRPJtM020sEXjAJA43EAkgZrE4rpftlh/wrj+zft0X27+0vtf2fY+dm zZjO3bnv16e/FAHNUdq72x1jw+mo6DqUtxAlvY6WbW5sWgcySvtkDYAXYQxfPLDOTnFZlnq1tYeB oo7XUYo9Yi1EXaoI33CMBRtyV2n5kR8E4+UdwBQByta1pov2jw7qWryT+Slq8ccSMnFw7E5VWyOV HzEAHj0rMlkM0zysEDOxYhFCjJ9AOAPYcUzigArW0bw/da1rf9kI8VteHeAlyGX5lySvCkggA9cd D34qW21Cx0rSFayXzdXuMl7iROLNQxwI8/8ALQ4B3/wggDnJrovDGv6JpsXh+eSdLaWxmn+3RiJt 8+/KxvlQQwQO33iCBuwDkAgHBUV3Fjq+nwaLpFna6tp1jcWNzM1xcTaeZi+XBWWLMbHO0DqUPygH oKLPXdIuYNGN3eNbNol5LcKotebtGfzAEVPljbKhdpO0bsg8YoGcPT5YpIJniljaORGKujrgqQcE EdjXRXeu2MYutQs4c6xqM8kzySDIsVMhIWMnrIcA+ZxgYAwcmsrSLPTr27ePU9U/s6EIWWX7O025 sj5cKcjjJz7UCG6bpV1qrXItlXFtbSXUpY4ARBk/U9APc+mTVGug8J6lZ6fcanHeTeSl7ps1okpU sqOwGC23JxxjgHr+Wxaa9pWjeFrnTLTUJ7hxqEskbLCYy6m3KpJjOABLsYc7htDYBHAM4eivS759 I1y38b3VnPax2byWMsVxJC4VHyQzYClgSSwyBzuPYk1zniLxLDP4l1G50mCzNnPKHUz2ELljtUM3 zqSASCe3XJAJNAGVaaJNeaFf6tFPB5Vi0Ymibd5mHICkfLgjOe+eD7ZNB0SbxBqsenW08EU8isU8 7cAxAyRlVPOATzxx9M7Wh61bnRdfgudQg0++vGtWt5EhaNAY33EgRIdpGB0A5P1q9p+taBB8Um1i CSKx0iLd5YEDKG/dbPlRAcZJLcgcZzzxQI4QUtdJbS6XL4TudHe/tbe8XUlnFzJFJsmiEZUAFULc Ek4YD73rmtjxBrHh/XYNVt7O4gsXm1RLpZpoHUTIIdh+4rHO/c3zAffz1JoA5XSdEn1iG/eCeBGs rZrp0kLAui9duARnp1I6j3xm12mgarpGiatrd4dT+3+bYyxRm8tX/wBKmZs8qC2VO0ZLFSd3TrWb rGr20WqveaTJBNHeRRySQ3NpHL9lfBHkqZE+6vABUAYwOcUAZWn6cL1Z5JL6zs4oVBZ7lyCxJwAq qCzHvwMADnFTalod5pt7bWpC3DXcUc1s1vlhMj/dKggNknjBAOR9KdG1vrDzPf31rYTIgEO2yCRS fNyG8pcg4OQdpzjBI4q9r97pF5qukrGzSWttZ29teTW6bTKUGHZNwBJ24ALAfdHbFIRQsNDvL6W7 VgtpFZqWuprnKJBjIw3BO4ngKAST2640LLwjdTeJBpN5MttD5TXDXqDzIhCFLCUNkAocAZyOvrxU mi6tptrBrmliRre1vmR7a5uYhKEMTl0EqAHIbgEgEA9iKq+KdUtdTvbOOzLPb2FnHZJMy7TMEz8+ 3+EHPAOTj8qAMOl4pKKQh2aKTFHagBacBTQKUAegpEjhSim4HoKXikSOpfSminCkIUUCkopAOopu BS0CFo6UlLSAXNHFJRQIWlpO1HFAC0UnFAxSAXtQKKOKBC5pc00gHtxSbV7gflQA+lzUWxP7i/lT sKP4R+VFgsSUZqPAxjaMfT2pCqnqqn8KLBYlzRmoiF7gUhKjsKLBykpbFNZ6hZqTjqccVSiUoj2f moJznb+NDS9lH41EeuauMbamsY2Eoooqywr234Df8i548/69Iv8A0CevEq9t+A3/ACLnjz/r0i/9 AnprdCex6Jc9W+v9azW+9Wlc9W+v9azW+9XtLY8p7nz/AOOv+SheJf8AsK3X/o1qwK3/AB1/yULx L/2Fbr/0a1YFeIesFFFFAC0fhShSxwBmpFtz/FxSbSE2kRUoUn6VMY1UdPzpKXMLmFjRQQSM1OhA 6AfhVelBwOtS1chq5cVxUiuOMYqiJMd6XzgDnJ/Os3BmbptmgG4pc1Q+1DHFJ9qftxU+zZHspGgQ DycU1ivTiqHmsSSWJ/GnCTnOT+dHs2g9k0W9oNNMS84AqISe9SCSizQuVoa0I9KiaAelWdwNLhTQ pNDU2jPaH2qMxGtJo1I/+vTDEPStFUNFVM7BHUUlXWgHpULQe1WppmqqJkAopxjIpuMdqstMKKOK OKACijijigAoo4o4oAKKOKOKACijijigAoo4o4oAO9FHGaOKACijijigAoo4o4oAKKOKOKACjtRx R2oAKKOKOKACijijigAoo4o4oAKP8aOKOKACijijigAoo4o4oAKKOKOKACijijigAoxRxRxQAvSi k4ooAXFH4UlLSELxRgelFJQA6lAzzSKBTqQhaUD2pKAB/k0iRQAOwowPQUYHqfzpcf5zSEA4paQA f5NFADhS5FMopCH0tNBpc0AGKMewoopCFo70lGOaAHZopP8APWj/AD1oFYdSZpKUUgFzQOaSgUCF xS0nFJmgLDqTNNLAUwtTsOxKTxTS1RkkjvSHCjk07FKI4tmkI7nFRNJ6cUwknqSatRLUSUyADCio zk5zSUU7WKSsGKDRxQaYxKKKKACvbfgN/wAi548/69Iv/QJ68Sr234Df8i548/69Iv8A0Cemt0J7 Holz1b6/1rNb71aVz1b6/wBazW+9XtLY8p7nz/46/wCSheJf+wrdf+jWrArf8df8lC8S/wDYVuv/ AEa1YFeIesFFFFAGiUAGB8v0pCKVjxgHHvTTyOtc6OVamt4d0OHXbu7jnvvscNravdSS+UZMKpXP AIPQ5/Cta4+H7W8iu2qxvbJa3FxO8cJLI0BCyIqnG75iACSueT2Geas7+70/7R9kmMf2iFreX5VO 6NsZXkcdOo5q9J4p1uSOSN74lZEnjYeUnKzMGkH3e5GfbtitE0axaL0fgxLnTRqNtqTG1fT7m8j8 y3CyEwsFZCoYgA5GDk/SoofBhuNX0vTV1AibUtNW8hYw/KrlWYI3zcDCn5hnt8tZ8PiDVrfT0sYr wi3SCW3VPLQ4jlILjOM8kDnqO2KSPxDq0N/ZXyXeLmxgFvbv5aHZGAQBjGDwx5OTzVJopSRft/C2 ntdaDLJqN01hq7mOIrbKsodZQhVhvIUc5DAt/u1l+JbSysPEN9a6e8vkxTyJtkTbsIcjaDuYsAAP mOCfSmjWdQSPTY1uMLprmS0Gxf3bFgxPTnkA85qC/v7nUZDJcmJpC7yM6wojMzncxYqAW56Z6dBg U7lJoZqX9n/b5f7L+1fYuPL+1bfM6DOdvHXP4YqTSNLutb1W302zCmediF3thQACSSfQAE+vHFM1 PUbzV9Qlvr+XzbmXG99oXOAAOAAOgFJpupXmkahFf2M3lXMWdj7Q2Mgg8EEdCaYzspPCOn6hF4Yt dIuSX1CS7WW9ljZfMWNvvbMnHAbA4zxnHaCz8FWt/f2Ntba9AWuZXidD5TyIBGzhgscrgqdpHJBB xwc1z9p4k1ay/s/7Pd7P7O8z7L+7Q+X5md/Uc59847VXsdWvdNeJ7KVIZYZfOSVYk3hsYxuxkrjq udp9KLBY2tH8NpqemWd9JfvCtzqa6cFWEPgsm4N94cZIBHpk89KlvPDkGn2JvZtQlMMN8+n3Wy3B ZJVXOUBcB1yCMkqfbtVDS/EUsWo6d9umZdPtL37YYbWBF3PndnaNoJ4Cgk/KOnHFN1zXnv7i/gtZ 5TplxfPfLFLEqsJGBznBJ4Bx1wcZwKTSE4o2/EGiaVY+Mk0a3v3tYg0aSy3KfJHlFO7cD8xOSTkK AT2HIoa1pMejEI11dC5DlXtru18p9o6SKQWVlJDDO7twCORn3PiTUry8a7untp7hn8xpJbOFixCb BnK9MAcdM84zzVZ9Uu5dNi06SXdawu0kSMoJQnrtbGQD1IBxnnGalxRDgi7pttLqWo29nCkryTOF xEoZsdyASBwMnkgcckda3db8LjStCtNXhvluIJ5TEVwuVPOMFHdT91uh4498cvpuqXek38d7YzeV cRZ2PtDYyCDwQR0JqeTXNRm0a30mS5LWMDmSOLYvDZPOcZ/ibv3qeRWI9mrG7f6dYweG/D12EaOS 7M/2iRMsSFkABCkgZA7cZq1feDIba8k0+PWLeTUI5oojDIhjDCRsLtOSWIBVmAGAG6nHPLTapd3N ja2U05a3td/kJtUbNxBbnGTk+tWJdcv7nWBq01yXvldJBLsUfMuNpwBjjA7VPKLlSNnVPB8FlFcr b6rHc3UMywi2PliSUltvyKkjMTnHBAPPtio9U8Dy2trBNa3BneW8+wmF/LV1lIyBlHdR3ByQRxxz WbHrd4l5LeCSP7TLMJ2laFCwcNuyCR8vPUDAPQ8VOPEOpn/l6/5fPt/+rX/X/wB/p+nT2o5rBzWN efwZpyaNb28dx5moNraafNdBGCx5T5lVSfmCt/EQCcelYUvhcxW3iOb7YT/Y06QgeX/rt0hTPX5e me9WI9e1BpEEt4yxm+F+zLCjETd3A4yf9nIFWrvWLVdJ1O1tZLi5uNVmWW7nuIViACtuG1VY8lic nOMcAd6pVEUqqOX0uyOo6tZWHmGP7TOkO/Gdu5gM474zXW3fw7MaTfYdaguZI7mKEo8Lx4DymHcT zyJVcYGeFznkCuYgMtndw3Vu5SaGRZI2wDhgcg4PuK0P+Em1xDKy32DJIsjfuk5ZZWmU9O0jsfxx 04q1NMtVEy5d+C47e61TT11J31HTbP7XOht8QkBVZgr7iScPxlRnHam6t4M/sz/hIf8AiYGT+x/s 3/LHHnebj/a+XGffPtWZN4g1iS/vr97vNzfQG3uH8tPnjIAIxjA4UcjB4pl34k1e9/tH7Td7/wC0 fL+1fu0HmeX9zoOMY7Yz3qrotNGxP4LjWGcwak8ko0warEr2+1Xg4yGIY7X+9wARwPmGeItZ0bRr LwlpOoWlzePcXjTkNJAFEgV1XBAc7AOSMbiSTnHGMz/hJNW/5+/+XH+zv9Wn/Hv/AHOn69feojrV 82nwWDyRSW1ukkcKSQRtsEhy2CRkEkDnqOxFAzoNV8EQaVHeRT65bLe2sAlMTtEqyNtDFF/eGTOC cZjGcdsipZ/CdppfhjXjeuZdYso7V2RQQtsZHPy7gcOSuM8YHYnmuavNavr+/ub67kinubmPy5Xk gjORgDgYwpwByMH3qW78Satff2h9ou9/9o+X9q/doPM8v7nQcYx2x70AZX511134Ljt7rVNPXUnf UdNs/tc6G3xCQFVmCvuJJw3GVGcdq5GtWXxJq0t/fXz3ebm+gNvcP5afPGQARjGBwo5GDxQI25fB 2mQtaRy+JI4J76Bbi1We3KL5bIWUyuW2p8ylcAseh5zgcf8AnVu+1K71I232ubzPs0C28XyqNsa5 2jjr1PJ5qpQBsaNo0d3DJqOozPbaRbsFlmUZeR+oijB+85/JRyeOu7o/hO0TTLufVHMl5Jo02oW1 soOI0GPLkZwQMk5wuDx1weK5W61K7vbe1t55t0NpH5cEaqqqgJyeBgZJ6k8nuatf8JJq3/P3/wAu P9nf6tP+Pf8AudP16+9AG3F4IgFnYvd65bWs15aC5QStEsahgSgYtIH5wASEIBPfFRW3gz7Rr+ia X/aBX+1LFbzzfJz5WVZtuN3P3MZyOvSsSXWr6ee0mnkime0gW3hEsEbqsYBABUjBxk8kE1LD4k1a D7OY7vEltA1vDKY0MkcbdQrkbhjkA5yoJAxk0AP0bRo7uGTUdRme20i3YLLMoy8j9RFGD95z+Sjk 8ddbTvBcepQ6SYtSdZdVhla2VrfgSRZ3q53cLwMMASc8qMc85dald3tva28826G0j8uCNVVVQE5P AwMk9SeT3NdBJ4oitNE8Px6TPcxalpXnZkkgTYfN5bGWPTpyOc546UAMGjaMPATav9pvDdm8W3B8 gYVhEW2Ab/ukkfP14GF65i0rw3a3+jDUZdQuAiylLhbW0882q4yHlG5SFIDHKhhhTznisy21q+tL FbGOSJrVZ/tAhlgjkXzCuzcQwOeD0PHfrTLTVr2xltJrSVIJrRi0UkcSK+T13MBlx2w2Rg46cUDK sqCOV0WRZFViA6Zww55GQDg+4BrrdG8Oafq3hCOaSU22oz6r9jgnKs6sTFlUYA/KC38QBI+mcclL I00rytsDOxYhECjJ9AOAPYcVdtdb1GytIbW3uNkMF2L2NdinbMBgNkjPQdOntQI6C08BzT3ei2tx emCbUZLqORfKD+Q0BIIyGw2SPb8apaV4btb/AEcajLqFwEWUpcLa2nnm1XGQ8o3KwUgMcqGHynnP FVx4t1wXdrdC+/fWsk0kLeVH8rSkmQ4xg5JPXp2xVK11a9sZrSa0lSCa0ZmikjiRXyeu5gMuO2Gy MHHTigDV/wCEWBj8PuuoK66xcyQBkiOIwsoj3DOCwOc4IU1j6pZf2bq17Y+YZPs07w78Y3bWIzjt 0rd0/X7RDplxqN1dzNpsslxBZQWkUcYcvvwJA2QpYKT8nAyAOlc/f3kmoajdXsoRZbiV5XCDgFiS cc9OaAK/50fn1oooAPzo/OiigA/Oj86KKAD86PzoooAPzo/OiigA/PpR+dFFAB+NL+dJiigAxRRR QAU4DNJjJpw+tIQo/GlpBSikSFLSUUhDuvc0AH1NJS/jSAMH1NL+JpPx/lQM+poEKBSd+tLjpzSY 9zQA6im0tAh1FJS/jSAKXNFJSELmikooAWl/GkFJmgBaM+9NLU3JJ607DSHlsUm89qjLAdTTDIex qlEpRJRkdW/OmFx2JNMJJ6mkqrFKI/zGxjNMPejtRTKsGPrR+dFFAB+dH50UUAH50Gig0AJRRRQA V7b8Bv8AkXPHn/XpF/6BPXiVe2/Ab/kXPHn/AF6Rf+gT01uhPY9EuerfX+tZrferSuerfX+tZrfe r2lseU9z5/8AHX/JQvEv/YVuv/RrVgVv+Ov+SheJf+wrdf8Ao1qwK8Q9YKKKKANDDdyPyoxSnd/C AfqcU35/7q/99f8A1q5zlNzw3pVrqkuom8M/l2ljLdBYXCFim3jJBwDk9q27nwNaxQvKl5Ntis72 R1Kgl5Ld9mQeysSDjkgAjJzkc1o1pqt/ePaaUT9omiZWRZxEZE/iXkjcO5HPQ+lS3Ka1o62LyXM8 UYV2tJILoOi5OH2MjEA56gHvz1qk9C09NjW0/wAI2t1oEWpS3E26TTbu6CJgASQuFHOOVIYcdcjr zwkXhC1uNf0LTUuJ0XUdNW6eRsMUkKO3AwPlyo464zz3rAbVtSkvEvH1C7a6jXak5mYuo54DZyBy fzNOi1HVprq38q9vXuFdvI2SsXDufm298sTzjrmndApI1LDQYYZfCN6zeampXW2aGRAV+SYKfqCC OD6H1wM7xVaXEfiPU7iSGRIZr248qRkIV8SEHB6HB64qte/bYX/s67kk/wBDd4xC0m5Ymz8wHOBy OcdaSe4vdVuozdXclxMcRq9zNnAzwCzHgZJ6nA5o5h8wmt2NxYatPbXVlFZTJt3W8Tl1TKgjBLN1 yD1PWl0HRJNf1y10yOVYWnY5kYEhQAWJx3OAcD17im6jpl3pV9JZXsXlXEWN6bg2MgEcjI6EVWje SCVJYXaORGDI6HDKRyCD2NUpFc2p1dj4LsNQu/DYt9QuTbar5/mNJCqOvlEk4AYgZHHU4xnnOBk+ F/Dv9v6pYWssdzDbTTvHLdquUOE37F4wHwrdSeoOODmnLq2qSsGk1G7dhKJ8vOxIkAwH6/eAAAPX Aptzq2qXcsM1zqN3NLA26F5J2YxnjlSTweB09BVcxSkXvC/h7/hINUsLaSO5itpp3jlu1GUOE37B xgPhW6k9QccHM2keGrfUdJ02+knlX7RrKadIi4+4yqdynsR83XPUdMc09Wk1+Gawm1O9u2kMS3Vo 8lyXZVbkMpydp+X2PAqtJrmsS3ENxLqt880O7ypGuXLR5GDtOcjI64607lXNq08MafqPif8A4R6G 7uYbxLuaB5XjV42SND8w5BBLI3y84DDkkHdL4nm8/wAEeFHBlKf6YqCV97KgkAVScDOFAHQdOgrl 5b68mvhey3c73YYMJ2lJkBHQ7uuRgY+gp9zqmoXsbJdX1zOjuJWWWZmBcLtDHJ64AGfTigDqNY07 7VrnhGxubqeWK70+zQk7AY1diNq4UcDPGcn1JqLT/B6XtxrNsb1kl0/UILRZPLyHEkxiJK54PQ9e xHfI5641nVLuaGa51K8mlgbdC8k7MYzwcqSeDwOnoKmupNU0u+nttQ88PM0c13bTSsBNnDjzACCT 82eTkZPQ0Aamr+HYNO0nUr6OeVvs+svp0SMB9xVY7mPcn5emOh65GOcD10Ou+LX1jSV01IblYPtZ ui13eG5dTt2hFYgEKATwcnnr1zzWaVhNI73WtHl1C78L29tC0VvJplkks0cJKRNK7Dc2MDJYk8kZ NZ8+gQx2/ieaOeQDR7tIowwB8xGkZOenPCnI9+ORjDvG1a2sLO0vJLlLOSMXNvBJIdm0lgHC5wMn dzjnOeh5bd61qmoRLFe6jd3MQbcEmnZwD0zgnryfzpNITii3o8K3+s2FnKzLHcXEcTFeCAzAHHvz XUat4XsbTTNVuraW4DWTqVErBgymaSDBwBzmPdn0bGONx5FLDUbXTINcjGy288RxzxzLuWUcgYB3 KeM8gdj3FQ/2jeFbhTdTlblg04MhxKQcgt/eOcnmp5URyI7XXdJnvpfDsFlb7UfTLRHkCERo0jsA WIHGWJ+pzVbVPD8Gk6Y+oWV/cPcWmptZuxjEeHVdwZcMSMEHn3HAxzyx1O8ezjs3uZmtY23JCZCU U88hegPJ/M1Zl1vUrtZFuNQuplkCrIJJmbcFOQDk8gEkj0zUtENHa6/pX9vC0kluJFubfw7FeGVv n8zbu3KQecksPmzxg8HPHDto91/Zf9peX/onneR5mR9/buxjOen4VK2talNafY5b65e1ACiFp2KY HQbenGB+VObUrmXTorAyYtYnMixqoUFj/EcD5jjjJzgcCk5MTk0ZLW57Gu/utJOg+F/GOircyzpb fYmLNwrO77iyr/DxtB5Oduc9hzUOl3VxptxqEUatbWzBZW8xcpkgD5c5wSeuPX0NI2o6k0Sxf2hd GNYjCqec2BGcAoBn7pwOOnApqpbcaqtbl3W/DGmaTqOpadFcatdXdpbLIfKs1ManarF2bfkJye3y 5HLY5nvPCFhb6xrqCa6/syz037XaXTMu2V2Vdg37drBmLAY64wDwaxp9Q1SayFk+oXUlqFC+Q87F ABjA29MDA/IVUlmvZLFLJ7qZrSNtyQGUmNW55C9AeT+Z9atTTNFUTN9vB1v8+27lGfD66umVBw/G 5D6g/Ng8YyOuDluq2Ms3gLwy1paO7Bb2ecxRkkASKC7Y7AADJ7AUeJdXv9Q0XS1it72x0wQfZUje 73x3Aix820KoyCRk4wSBjG01hONWtNEjDSXMWmXjttj8wiOZk27jtzg4O3nHUe3F3RpdGr/wjCTS +VaSStfJaeZLpdwrQ3IkC/NtypVx0cAHcV4xnmuZ5rQ/t7WPsn2T+1b77N5fleT9pfZsxjbtzjGO MUyDSL+40q51SK2ZrG2ZVlmJAALEAAZ6nkdM4yM9aANnRIpH8EeKJFuJUWP7JuiULtkzIcbsgnjq MEe+aZa+GxeWNuYPPOotbSTNYSqY3mX+CSAlSHXGCV+8djY6jFHTW1uTTL5LC5uY9PhjMl0q3Hlx YbC/NkgEt0A5J6AHFV49Z1SGyNlFqV4loVKmBZ2EeD1G3OMHJz9TQMpc12EHgy3OnyNcX8ovTox1 aOOOEGMJkYUsWySQOgUYJ6nGDzlhpN7qcN3LaRJItpEZpgZUUqg6sASCQMds9R60QazqltDDDBqV 5FFAxaJEnZRGTkEqAeCdzdPU+poEdBoUsh+HfiyIuxjVrRlQk4BMmCQPU4H5Cqr6NpdnoWiajey3 m3UVn3+SFYxGMsoIU43Akx8ZGArcncNuPBqmoWtpJaW99cxW0ufMhjmKo+QAcqDg5HFE+qahdWkV pcX1zNbRY8uGSYsiYGBhScDA4oGdHL4Z0u1bSYZbjVZ7u+09bsQ2dmspy4YjHzg4XAyMHIB5GeHe H/BlvqkekteX8sL6t9oFskMIYL5Snl2LDHPYA5A6jPHOR6zqkNkbKLUrxLQqVMCzsI8HqNucYOTn 6mm2+qahaW/2e2vrmGEuJfLjmZV3gghsA9QVHPsKBHdeAtL/ALN1jw3qK3MrPqv2pWjU7VVI1cFW /v5O1h0xt6HqMKHw3aSWnhOUyT7tYuZIbgBhhQsoQbOODgnrnmsRNZ1SNZFTUrxVkl89ws7ANJkH eeeWyAc9cgVsaN4sfR/34/tKa6MjzOG1ErBLKc4Z4wuW7Z+b5sc8HFAGRrNmmn65qFlCWaK3uZIk LnJIViBnHfiuq0nwjpl7o+iXc8l55t8z+aEkUAAXCQALlTg/vVbJz90jHzZHGXVzLe3c11cNvmmk aSRsAZYkknA46mtDT4NZ1G3ZrKaV49Kja5VftIUwLnczopIPUAkqOuPUUAbd34Ot7G90O3ku5Zf7 Q1Ke0lZVCbUjmEWR15PzHn1AxwSdCDwHp/8Aa2h2M11dN9tnvoZ3Qqv+oZgpUEHGcc5zXHwa9rFr 5v2fVb6HzZDLJ5dyy73PVjg8k+tS6a2tvp92NNubkW1ri5mihuNu3BGJNgOTghSWAOMAnHFAGjpH hu31HSdNvpZ5V+0aymnSouPuMqncp7EZbrnqOmDnovCmnR6fp/j62O2WW0tpLdZimCQBKDjrgHaD jPYelcF/amof8/1z/r/tP+uP+u/56dfv/wC11og1TULW8ku7e+uYbmXPmTRzFXfJycsDk5PNAzbi 8NW9t4bm1PWZb6ymS+W0EC2oZl/d78srMp5BGOeMd88a+kaDHpeq2erQSajABrUNjFb3MfkzIGCO TJgnIKllwMZyD0+WuX0y712S4u5NMu74StG1zdPDOykqoLM7nPPU8nucdTzVTVNQj+07L65X7Xn7 RtmI87Oc7+fm6nr6mgC34nz/AMJbrP8A1/T/APow05dGj/4Q1tcMrGX+0FtFjA4A8suST3PQe2D1 zw/TtF17xbcXNxaxy380ezzpJZ13cjC5LnJ4U/lVhdL8UeHotRlhknsltGjW8EF4qlS2Nm4K2SDu 4PI5PoaALus+DrfTf+El8q7lb+yZLYxblHzpL2PuMryOuDxyMY/inRk0DxLe6ZDK0sULLsdxg4ZV YA47jOM98dB0rPN/eMtypupyt0wa4BkOJiDkF/7xzk896Zc3Vxe3DXF1PJPM+N0krlmbAAGSeego A0dL0U3lpPqF5cfY9Nt/le4Kbi8hGVjjXI3MfTIAHJI4zv8AhrT4ln03xDbNLbq2sw2EVujnKghS WZ/4ty7gQAoJbPA+WuaXTdTl0E6isMr6ZBOYy4YFY5GC5+XqMjYM4x0GafdJq/h26u9Lllns5WUL cwxz8OCuQG2nDDDe/U+9AjoL3RLS/wBT8Y6lfXU8MVheHAgiEhJkmZc4LDIGDxkdc54wa7eHNPl0 jVrq1Op+dbWlvc28VzCI2lRmIkkCgsWjAGQwIxnnOMnE/t7WPtf2v+1b77T5fled9pbfsznbuznG ecVF/amof2h/aH265+2/8/HnHzOm372c9OPpQM6O98Hxx31rClw1tBHp8N1qk9zyLR3zlSoAO7pt T7xJ/EUdN0my1p9VW3MsEdhpslzG7ctMyMCS4zgZBIwD8vy8sQS2JJdXE3m+ZPI/nSebLucne/Pz H1PzNz7n1rpfBN1c2L6rc21jJNutDBJcLeparbq7Abt7DAbIG3kdDwewBreG9Ct9N8f+GV3efHeW KX22VQdjmJzj3wy5B6jjuMnl9P0UyLO2ppeWUH2YSxXRtnaJSx+QvgZ2NhlBHfHXBqLVE1ex1VJ9 RlnF8ypPHcGfezjHyOsgJ3DgYIPb2p+nXeu3+tqdPu76TU7r935kc7CRx6Fs5wAo6nAA9qBEWs6Z NpGoG2ljwDGrpIJBIkykf6xGAAKMckenQ8g1Q5/yK1G07WdU1u7tphLcahDv+0vNMDsEfDF5GOAB jGScdPaqV9ZXWm3s1neQNDcRNteNux/qO4I4I5FIRF3oBq9p2jX+qW9zcWscXkW23zpJZ0iVNxIX JcgckVHe6fPY7POe2bfnHkXUc3THXYxx170hFairmpaTf6PNDDqFs1vJLEsyI5GdpyASOx4PB5FV oo5J5UihjaSR2CoijJYnoAO5oEMpc1oyaBqkWuDRWs2OolgvkKwY5IDDkHGMHOc4A69DVK5t3tbh oZGiZ1xkxSrIvTPDKSD+BpBYjzS8+1WdP0671SdobSLzHRGkclgqoijJZmYgKB6k1bPhzVhd2dsl p50l7n7OYZEkSTBwcOpK8Y5546nAoEZXzeo/Kl59R+VXbrSb+yvYrOa2bz5lRoVQhxKG+6UK5DA+ 2alk0DVYtc/sVrNjqBZV8lWDHJXd1BxjByTngdaQGbg+35UHPrWheaNfWNql3NHE1s7mMTQTpMm8 DO0lCQDg5wazzmgQ6ikpc4pCFoppb0pNx74/OnYLDyRSFvpURk600yHsKaiUokuWz1H5U1mx3qMs TSU7FKI/zD7Um5jTaKqw7BRRRQMOaKKKADtRzR2ooAOaOaKKADmjmiigA5oNFBoASiiigAr234Df 8i548/69Iv8A0CevEq9t+A3/ACLnjz/r0i/9AnprdCex6Jc9W+v9azW+9Wlc9W+v9azW+9XtLY8p 7nz/AOOv+SheJf8AsK3X/o1qwK3/AB1/yULxL/2Fbr/0a1YFeIesFFFFAGjznoOvrRz6D86MnP3T 1oyf7prmOQ6TwHLFb+MLO5uZ4IIIlkZ5JZlQDKFR1xk5YcD/APVvpcaU1pp1rcPpy3cGn3hgtfOW W3hnZ8xkuxZSWG44diBgcAkZ4OygF5dLC80VspVmMs7YRQFJ5xk5OMAAHJIFamr+Gb3SLp7YyQ3c 0Ss06Wu9zCoCtufKjC4cc9OD6VabSLTaR0cP9jeXZ/axpP8AbP8AZ939wxeR5279zu2/us7d3X2z ztqs1/ZaZeeG7lzpy3yuf7Ra3hikRY/OBU4QFA20Hlfm6e1ctLpepwyvFLpl6kiRGZ0aEgrGOrEH ovv0qH7HeFLdhZXBW5YrARGf3pBAIX+8cnHHei7C7NnxgPM1ye5F1YTrNLK0a2m0lU3naXKDaWI5 6lsdccVgxxtLKkalQzsFG9wo59SeAPc1cu9KvLW/uLRbead7dPMkMcLjamASxDKGAGRyQKa+kakl 6lm+nXa3Ui7khMLB2HPIXGSOD+RpMTvc74y6Bc/FO8udTnsJ7Ga3DW8jyq8RcIi/NyVBwH4b29RV PTRou3Sv+Eh/sn7V/aD5+z+Vs8nyuN/k/LjzNv3vftmuIuLG7tEVrm1mhV2ZVMiFQSpwwGe4PB9D UulPqEWpwS6UJjfIxaIQqWbIBzwOoxnI9M5quYrm1O2itdMtv+EVl1mDTVju57h7ySNIjGzL8sfz R/KFHy5A+XOSw61i+J7UW3hfQ5Wgslurt7iS4ktkiIcqQq4aPgAL2XjOSRnNVJb/AMRx3unTFLi3 mhdo7JI7YRKH3YdVRVCk7jhhjnofSodRXXr66tbC8srkTIh+z2iWvlYUkklY1UdSCSQOce1Fx8xt amunw+KPDM4/sgwtBBHfCLyGi8zcRLvVcqOG64x6Hji9ZL4WkuYft403yrbW5YItu0ZthGfLL7fv rvCfO2e+TgmuKGj6kzW6jTrstcqWgAhbMoAySvHzDHPHalsV1TT7qyvrKK5imkf/AEWREP7xgdpC /wB7k4I564PWnzDUjZ8UWa23hbQpWgsVuruS4kuZbVIiHKEKuGj4AC9l4zkkZyawfD6wL4gsTcrZ vCJQWW9ZlhPsxAOB7kEeoxmrOtTaw729vqsMlv5KHybdrcQKikkkqgAHJzk45x7VBqmj3Gk/Y/Pa Nvtdql0nlknCPnAOQOeO2frT5h8xqazO9ra21wF0M3AnkKRxRQSyopBGH8oeU6428sobdnAwM1p+ M5bfWtalvP7V0qPSpJbfy5ERHuWDIAzEIPMwvzEhyvQAc4FcZb2lxeXC29rbyzzNnbHEhZjgZOAO egqSfSb+2tI7uexuYraXHlzPEyo+RkYJGDkc1XMVzHY+IY9JfTMaedM/tK11JfKfzrXEtu3CsQio hBZQSrAlRknCmq/i7U9JstRvLHTtM0qSDdFPY3VsY38tsln34B3gkldjEKAq4XpXLXmi6np8Ilvd Nu7aMttDzQMgJ64yR14NLPoGsW3l/aNKvovNcRx+Zbuu9z0UZHJPpTuVc7DWr2w1eLw7d3N9pn9n QwWkV3CqKs5YMwlVVRd6qq5OPlXkbcnFTay2gyi7hnt9MgtGvolhuLW6gaVYvMO5o0gizjZnIkJx 8vU9eE/svUP+fC5/1/2b/Ut/rf8Ann0+9/s9aLnTNQskZ7qwuYESQRM0sLKA5UMFOR1xzj0OaAO1 8TXFm3hO8061k0yNbbVRLBDazRndbbDGj5BJdiRlsksM5IAxXF6WbX+1rP7f/wAeXnp9o+9/q9w3 dOemenNLeaNqmnQrNe6beW0RbaHngZAT1xkjrwapUAd/q8thDY67LKNFLpeRto4tVt2JUSNncI8k rsxkScdO9SeIW0FoPE8FodN2W8lrJpxg8sMS5zLtZeXHzHjJC8YAwMclceHr62itS/lGe6giuIbd WzJIkjFVwMYJyB8oJOGHHDYqT6ZqFpbi4ubG5hgMhiEkkTKu8EgrkjGQVPHsfSgGiMORW8b230KK 8s7UwXl9Iphe+Q7o0Q5DLECOcjguexIAx8xyZNI1SGyF7Lpt4loVDCdoGEeD0O7GMHIx9aW40nVL RZGudNvIFiVWkMkDKEDEhScjgEggepFTykOJ6BfXOl2/h/W9N024sPsr29s9kwljEtwFYPKZDndv y3CtjphV4NP1e40IW9+tnbaY1j9kX7NIbqEPu2rgqixmbfnqHbB+bOBXmIerVna3V80otYWlMUTz SY6IijLMT2H9cDqRUtEtHe3k2hfaNV1eMWJsrux8qztEVfNimYAcx/wFSrEt05GCc1itcW2jRXdp beTdXkitC96p3RohyGWIEckjguexIA/iObbaLqE+g3es+V5dnbbPnkDDzdzbfkOMNg9eeKY2nanD ZC9l068S1KhhO0LBMHod2MYORWcovoZyi+h1WpXa6t4K0+MXemRSWyzm4jaKNH3F1KLGqrkEjuoA 4O49aj1O6XV/BOnRrdaZFJbCc3MbRRxvkupRY1Vcgkd1AHB3Gub+x3yzzQPZXKzQJ5ksZiO6NcZ3 MMcDBHPvS2ttPetIttC0piiaaTb0VFGSSew/+sO4pc0kTzyR2Vnomm6h8TYru1h0ubRpV3JAskOD +4/5453A7ucbeDzWNoq3EvgLWtPl1G2H2jyPsVvPfxrjbKWfCsw2evOM+9Rtea4Z5tMS18m4mTy5 IYLBIpWU4YqdqBsEAEjuPas2PRtQuIopYdPupY5iVjZIWIcjOQDjnofyPpVKqWqxJazw3PgC60kT RR3lvffb9szhBLH5ewhCeCwPO3gkdMniqtldW3hxkuo/IvtTaJZIHB3RWbMAQSCPnkGTx91SB948 Kt9o1xYRWz3KqrXMQmjTOT5Z+6xxxzzxnPByBxmVfCWozXthZIkf2i+tjcwoXHK4YgE9ASE4+ozj nGinc0jUudLo82k2Wjm2s7jT1S+0SaOSaWWNZmvHHMbFiGRAEwOinI5JINFpL4fTTtLEdnpU1r/Z /wDpjXF3DERLht4IMbT7s9Ch/u4GK4S00q61C9is7OFpbiVtqIvUn+g7k9qVNE1WWyN5Hpt29oFL GdYWKYHU7sYwMHP0qk0y1JM6+wk8PNdaNrco08WFlp/k31m6r50s6qVyIv4yxdSG6fKckEVgWV1b eHWS6i8i+1NolkgcEtFaMwBBII+eQZPH3VIH3jwuYul6g9xBbrYXLTToJIYxC26RMZ3KMZIwDyPQ 0f2ZqH9n/wBofYLn7F/z8eU3l9dv3sY68fWmM7A/Y/self2b/wAI99h/s0fbft/l7/Pw/mZ/5b5z jbs9scUaF/Z39leHvI/sfP2uT+1/tvkb9m9duPN5xsz9z375rkRo+qGFpRpt4YliE7OIGwIzkhyc fdO089OD6VS7UAegWVxoEdvbvCumFB4gNunnxIW+wMQ2WDjOOPvtyORkciiFLGJ2g01fDwhTUrge ddSxSZiB+RZBN8xQ8YeJj8u7gt18/ooA9A0z+y/s2ifY/wCw9v26X+1ftHlf6vzF27PtHz7PLzjb z6/Nmqnhw2Cat4r+y3NtDZTWN1b2fn3Cxb97fuwPMIJ4HU9O+M1xVFAHoGgSaNHoGkeXa6ZPdmeT 7f8Aa7i3ix8w27vORmKbf+eeO/U1meFruw0zxhca20sEGnWLSusSylncMGVEjDAM55HJAwBlsVyV FABzXceGTpFnpVjcXL2d1vuWa9jmNsrW6KV/hlRpJAVycIR6D5smuHooA77RL610fxD4j02CbTkt pra5Sxd/KkR2ODGplbI2lR91m254IzXGanCYNTuI/tFtcFZDmW1GImPfbwBjPHAx6cYqpRQB1fw7 ultPF9pJcXcVvZx75JTNOI0z5bKp+YgE5fA78ntmrGi3v9n+EvE32uezmuWa1igimnWUuY3xwu75 lUFSOqkDHIBFcZRQB6bqUfhYXcy2R0ryrfW4LqXDIQbUxKXCE/fXdu/drnnjb0rhfEMcMXiTUltj Abc3LtD9nZWj2FsrtK8YwRx26dqzKKBnd+HvEy+H/AmIzbXEkmqlbiylIJmt2hAbI6gZA5xjPqMg 6viW6068u9YuNJn0efU3vof3ly8DK1uLdR8hl+T74OdvPTPavL6KAPRda/4RG5uda03RfsMc1zBG 0E8nyxLMkjtIqyNwm5doGMIcYyK5jxVJpxvbO204QMLSzjt7ia3XEc0y53up43A5+8euPTmsGigA 5rq/CtxAuh+ILOSS2ee4jgMVpdzCKKbbJkkvlSCo5ADjOTwcccpRQI6bxrdQXOoactvPFJ5GmwQy RwuHjgcA5jRhncBnqWbknnjAr+D57i38T2U0V4tpEkqNcO9yIQYg6lgSxG4f7POcdKwaKAPQ0urF NT8Vafcy2cq6pcpdW/8ApiCGZI5mcxmVSRGzLkDOPfHGcfxFqsTa9oq2F9F5ml2lvatdgFohLGSS 68EsoJ645xwCOvKUUAdXpWpXco1+AzaRd/bZElnF7K8AuCshO6NsoBy27BKnHQcEVca80Xw9Npeo Jp9rLqTQS+db2l35kdtJvxFKrHzAW254JIBwcDjPE0UhHafEC4t7ubRZYZ1nlXT0imcXsdwQ6nJV iv8AEMnLdGzwBg1kXF9qd94ma7j1aKW/fGL2KX7MpwgHDME28DHIGffPOID7UUCPUru+sU8d6/d/ a9Pmt9R0ySC2P2tCkriOP5WKt8gO0jLFc9jXHeIrbTYLPTHtVtor+RJDeW9pcGaJMPhCG3NyR1G4 9BwM84AopXBs0tE02HU7147i6gt4oomlPmzLEZSOkas3AZiQMngDJ5xg9lb6gsN20F3eaba2l9p1 xp9la210ssdiWK4MrLkDceS/JJ5OAOPPKNwFAjtNZvh5ehaZo1xFbXdn9okLQ3oEcAlbeIxOSASF 4JzgnjJNS+KdOh1vx5LOmq6bFYXTxqLo3cTBQIhklQ2R90gZwCcDIzXCeYKTfQFmzq9e81dEt4oZ dPtrCGXalhBfJcSu5XmaQpwxOCM8Y4AAHXl9x7/zqMuaaST1osPlJS4ppk9qZRTsPlQ4ufpTeaP8 9aKYw5o5oooAOaOaKKADmjmiigA5o5oooAOaOaKKADnFHNHaigA5o5oooAOaOaKKADmg0UGgBKKK KACvbfgN/wAi548/69Iv/QJ68Sr234Df8i548/69Iv8A0Cemt0J7Holz1b6/1rNb71aVz1b6/wBa zW+9XtLY8p7nz/46/wCSheJf+wrdf+jWrArf8df8lC8S/wDYVuv/AEa1YFeIesFFFFAGl07fpSZ6 cHn2p9JXNc5AiCySojSCNWYAuwbCg45OATjnsK7z+3dH/wCFo/25/aKfYNm7f5Muc+V5e3GzOc8+ mO+eK4uzs7jULlba0haaZlZlRepCgscepwDx3q5H4e1aZ41gsZJvMSSRGhw6usZKsQwyDgjHvkYz uGaTKWmxueHNXvLy4vtLnnnvI2sbqCCWK3eQK0rKS7YXeVLY5IJGRwOag8RrBbaN4d0Z7qP7Tbec ZyY5FEQkkBUsGQMOOcbc45xgjOS3h3WEnt4H064Sa4R3ijdCGcICWwD3AB469OORmC10q8vVka2j WQRW7XMmJFysanBJGeD7dehxg0X6Bd2tY65vEGkL8Uo9bF6GsGXJlEUmVPk7MEFc5zjoD1+uHaHr VjNoen6PG8r3cmn39qypBI/ltIyspIUEkYU/dBx3745iPw3q0sqRrbKGe0F6C0yKPIP8ZJbAH15o /wCEZ1oyxRrp0zvJE8qhBu+VOGBx0YHgqeQSBjJALu+w+Z9jR8chYLvSLYyB5LfSoIpAoIKsM8EE AqcEHBAOCOKp+DtStNK8V2V7eyGK3i8ze+xmxlGA4AJ6ms6/0y/0tYGv7O4txOpaPzIyCQDg8dj7 HnkHoRmC2imvLhbe2gmmmfO2OONmY8Z4AHpS1vcWt72O8t/Fmj32n6fFrUtxcLHfxPLFMjOdq2wQ sexXzcsRnJycg5IqpPrlhIvhgve27Ppl6WuDBbNGhRnV96KEUYABBGAcjoetZ174cB0/Qm06Kea+ 1Fpo3iEiyLujYKSrKANp5OSSAO+BmqcXhbXZZbeMaXco9w7RxCVPLyyruI+bGOASM9cHGcHFXfYq 8ux1umeLNHsrp5ZLhira/PdfLE2fJeJ0D9OmWGR19qzrfUtASDw1a39xHdwabPOtwqxSFXEh3K4B UZUHAYHng8MOvKfYLn+yv7T8o/Y/O8jzMj7+3djHXp3xitG90KT7bpVnYWl21xe2kcwSUod7NnLL t4CcZ+bBGDnFK7DmZb8R6na3/h/SbWO7t5bmxeZZRBbmJHDkMGQbFAAxg5AOexHNReLLuyvP7I+x Xsdz9m0+K1l2I64dM5PzKODnj6HOO+RaafdX88EFpEZpp3MccaMCxIxnI6gc9TgcHng4kvNG1Owt UubzT7m3hdzGrTRFMsBnGDz0PHrg46HBdiu2LoEsNt4h064uZlhgguEld2VjgKdx4UE5OMdO9a83 iWS18X3tzFevc6dc38VxLsQkyRxyB0UbwCCo4xwOMdMVzNXho98IElktpYhNtFurxsGuCxGBGMfN wc5HHTnJUETY1JnQ6vriPJqT22vwpBdXiyLFYadtlKiQuGdysZ3LwR8xJJ6jk1JPrWlwXCX51ES3 Y1CGWb+z4pY1vY0YHdLG4VFcFd2VJBLHj+Ksyfw6ieFo7wQ3I1P+0BZPAGDgkpvAChchuQpXJIII ODwKj+E9djcpJpVymJ0t9zptUux2rhjwQTxuBxyOeRmrsq7OkfXdGVyo1KNwPESasGWGXBiJwV5Q fMo5I6YPBJ4q03jrT3GoedeXUqpdQSQRsrHzFS8eUlM8D92Yx8237oHYVw76JfpFqMjW+F05xHdH ev7tixUDrzyCOM0220a8uo4XWLaLh1itvM+X7Q5bbtTPBwc5PQdCQSAXzMakzb8Q6ylxBrIttbtJ IL65DJa2unbGkXeWBlkKIcrx3Ykn6muM6etbI8P6pJ9uCWjO1jKsNwqMGKuzbFUAHLEsMfLmiLw5 qUt2Ldrfy/8ATl09pHPyLMSRtyM5xg5xnHHqM1cpSNTxhqlvrM2hpFrK3SwWcdvPI4mwkoPzyHcu SDxyASdvI6Voa54zUeNnvLLUXutHnltJZY0jOdsLBtoDgEHcGbg4O7k9cYmpaLYw6tLZ2q3y2tjO IL+/kTeiHcFL7FHyjIbALEnjvVm80HR5dL1+60x7of2TPGivJOkyXKM7JkbUXb0Bzlv607lXNe/8 Q6PJrXiHWo79XXU9LNrDaiKQTK7Ii/NldgAKnOGPTjNaGqeOtNu7vXYF1CdrSazuUt9yv5bu8UCo oXqCGSXqABuPPJrziDTria0lvCvl2keQZ5AQhcDIQHHLnI4Hrk4AJBcabd2mPtMPlboEuE3sBvjf G0r/AHuo4GSMHPQ4AKv51u6rq1tBZHRdFL/YAwa4uWXbJeuOjMP4UH8Kdup56QzeFtagury2ksWW Wziaaf51wqKqsxDZwSA6HAJPzCq8mharHph1KTTrmOyGz988RVSGztIJ6g+o45HqKAsdprPiLR76 y1+O3v1SO/trUWduYpALcQ4JiI24UklsbcrkHJHduveKLe+vNUv7HWbaCG7tRGtuunA3L5RVaN3K AAZzkhzjAwDxXGnQ9TXfmyl+S0W9OBn9wcYceo+YZx05zjBxn596AsehXvinS5LnV9cinZrrVLD7 J9g8sgwMVCsxfG0qAgIxyd2CFwaxdS1m1htTo+js/wBhDAz3DLte8cfxMOyD+FO3U89Mg6Jqa782 cvyWi3pwM/uDjDj1HzDOOnOcYOFfRtTiuLq3ezlE1rALmePHzRxkKckdejrkdRznGDiXG5Djc7ge JtK/4Sj/AISv7X+88jd/Z3lv5nm7PL278bdv8W7Oe23NatpcRXeiyaoGaK3j8OtYnzYnUGQHHDkb CCeAA2eenXHE3Xh+3tfAFh4h8+Vrm6ujF5fARUG8fUnKZznvjHeueWXnrUuJLiz1Cz8TWHm6TNLq bCxttPFvc6cyyEyuEZfugbGzlep+uKzPDetHRjFdzavJJDCjlNMRpfnY5AB42KMndnJ+maytI0zS 5PDh1bU7m5ijkvvsStCoIiPllt7AglxnHAwcZ5PSqUOm6hJcWtutpKZrqA3EEePmeMBjkD6I2B1P bORnNqS1MmprU0JL63sNK+xaXu865iH226K4ZgQCYU9EHc/xEemK0bS8sTp1sLvViJre1dYLiOOW O8tm7RqVykidgGYcOeV6VkroupcZtv8Aly+3/fX/AFH9/r+nX2psOl31x9l8q1lf7UjvBtXPmBM7 se42njr09RmFKa6GalNPY6vT/EPh23bR9RuLiVbuxso4jELUs2Y0kQoGz/GZQR2/djODjGZp+raH a6aLeCW2tEutGkspla1YyrctkmR3CFjGcDgMcZHyjHEGk6Al3bXz30VxCyWMl3bkMF3BQOSpBJU7 hgjAODjPOOdaEHtVqq1uaKu0ldHcaXJHoXh/wbrOos8MFkt6TGYXLyGTdsC4XaCRyNxUEcjvXlnI rq4NDtx4cudYumlK+d9lt4oSATLt3bnJB+UDsOSe461U0nR4r8ah5sNzJ9nspLhfIKDay4wW3dV5 5A59K0VRM1VVM5/86M1qQ+H9SuzZ/Z7OV/trtHb8Y8wrjdj2GRknjg88HENvo2oXcVvLBau8Vxcf ZY34AMvGFJPQ/MOuM8+hxaZomUfzo/OtD+w9TD2iNZSxvdztbwLIAheRSFI5xjBYDJ4zkdjh8Hh/ VLhQyWbANc/ZB5jKh87Kjy8NjDfOOPQE9FbDGZn50fnWxpGkC7m1WG6trzzbKzmm2RFEMbpgfOHx 8ozyB83pVW20i/vIreWC2Z4rm5+yROCADLwQpPYncMZx39DgAo/nR+fWtOPw9q8s1rCunz+bdyyQ woy7Szpw/B6Bc8k8DB9DiXw7Z6XqOorYai15HJcssVtLb7SEkZsDerDleQeCDx78AGP+dH51Yv7N 9O1G5spmRpbeVoXKcglTg4yOnFV+KAD86Pzo4o4oAPzo/OjijigA/Oj86OKOKAD8+lH50cUcUAH5 0fnRxRmgA/OjNGaMUAGaM0uKMgUBcOc96UCjdSbvekIeKNwFR596PxosFiTeBSbz2FMo4osFkLuN J+dFFMYfhR+dFFAB+dH50cUcUAH50fnRxRxQAfnR+dHFHFAB+dH50cUcUAH50fnRxRxQAfnR+dHF HFAB+dH50cUcUAH50fnRxRxQAdu9H50cYo4oAPzo/OjijigA/Oj86OKOKAD86DRxQaAEooooAK9t +A3/ACLnjz/r0i/9AnrxKvbfgN/yLnjz/r0i/wDQJ6a3QnseiXPVvr/Ws1vvVpXPVvr/AFrNb71e 0tjynufP/jr/AJKF4l/7Ct1/6NasCt/x1/yULxL/ANhW6/8ARrVgV4h6wUUUUAadLS4oxXKcZqeH NYj0HWotSe2a4aJW2IJdgyRjJODkYJ447fSjSNXj0m8vGS2aS1u7eS2eMygOI39HxjcMDnbjrx6V tLvY9O1CO6ktIbtUVsQzruRiVIBI7gEg49u3Wu08Q6baax4zPh2ztLTT5IVcxSwQACUmJHCyYxgD D/MM9Rx1JpbFq9tDlotT0u3uoHh0mRY4kYFzeN5xcnKuHACqV4x8uOuc8Y0G8XobxpTp7Osti9jc yST5nmVujFwoXcAFAJUkgck8YRPC9ndRzzWOtR3EMVlPdf6rbJmJgMMm4lQwIIJ5x2rOudHjtNI0 jUZblvL1BpdyrFkxBHCkjn5ic5xxRqg95GmfF8e07dPYN/Zb6WCZ8gRk/I33fvAdex6jb0qX/hOX khSKewVleK7iuNku0uLhw52ZB2kEDrup2peHft/j+60ZZbe3mZAYvs9t5cJYRBsFdx2gjOSN3Pbm oIfCEdzbQX0OoN9gktJ7pneDEqiE7WAQMQSSVx8w7+nL94fvGFfXFjMsKWVi1sqKd7yTmV5CT1Jw FAAwAAo989pdC1Z9D1q21KOJZWhY5RjgMCCpGexwTz/Opda0ePSFsdty0zXduLkAxbQsbE7O5+Yg cjoOgJ60zw/pH9u65b6b5/kedu/ebN2MKW6ZHp60tbk63Na08XR2DaT9l09tulyymESzhi0cg+dW wo+bJOGGAOAQepoW2t22lXNrdaPYNBdQSmQzXM/nFlK7dmAqqFwTnjPPBFaNz4KZYbKWxvvt63F0 sBWGAh1DJ5iMAxAP7shjkgDpngkRXHhSOC90ZP7Q3W2qO0aSpGjsjBtvIVypGSvIb14yMF+8V7xR 1PWornTk02ws/sVgszXDRNKZWaQ5AO4gYAXCgfiSTWg3i+OLW9H1K109kbTbcW2yWff5kYBUchRh sM3PI6ccc2LPwN9tuIYk1Hb/AKbLY3BMH3JUjLkr83zKdpGTtPTisxPDcs1poc0LyTPqryr5UcQL RhG2kjLAHjJ52gY5Pej3g94XTtfsNE1CzvdP0tllglZ3e5uTIzqVKlBhVVRgsc4JzjsMHOvbrTWt khs7CSGTeWaae58xyMYCgBVUDqehPv2q9rugDSLaxuorpbiC8V9hG3KlDgg7GZSORyGPfOMVZ8YR Qxy6PJFBDC0+lQTSiGJYwztuy2FAGaNeotbamHp9zFZX8dxNax3ax5YQyk7WbB27gOoBwSO+Md6e daujriavPMs14k6zlpTwWUggEDHHAGBjjpS6VZJqOrWtlJM0K3EqxCRU3lSxwOMjjJHf/Cth/C9s 1xLZW+sQvqEFxFbSRSp5as7ttPlnJZwrdflHHP1FcFcWfxnC6yC2sTGx1JdUQyXAcLNn5gcKMoRj A4IxnJ6Cnea9YyXs+oWenvBqMt0LlZ5brzBC24sdihVHX+9u4H41d1TwtZ6fHc7dbtzLbzLEyTGM FgW2llVJHbjgkFQcZ7jFLc+EraC/t7MajMHuLiKKF5bTEdwjkDfE6uysAGU4JXg+vFPUrUhufFMM yzomlrGl9cJPqS+ex+0bSDtXjMaltx7n5uuBisu61u+u9Xi1JpFjngZDAsaAJCFOVVF6BR6fnnJr Y/4RD/p+/wCYz/ZX+p/8idf/AB39at3XgApHL9i1eG4kjuI4SjwtHw8hi3E88iRWGBnhc55Ao1D3 ip/wlx+0F7KzgsZbu7iur2WSRpEd0YMMLjKpv3MQMtzgHAxWrrmr21jpQktntjfHXjqIiS8W5RsL 97KBdqkkAK2G6/hj6x4XtdLtbx49XhlntZRGYHMStIN20lQsjNkHGQwXg+2K5rFO7W4+Zrc3r/xL BNZ6xDaWEkL6tOs1w01wJAu1y+EARccnuTwPxqCPXLK0sG0+z0yRbS4njkvVnud7zohBWMMFUIM5 OQM89cDFbfiOHTNM0/StPW3tHjubGCY3MMR85H3EtICQC6spYBGPYcLgZr33gqK1vZdOi1q2k1GO eGIwSIYwwlbClTkliAUZgBgBupxy9R3Zz2s6tJqssarEttZW6lLW0jOUhX+rHqzHkn8BWhN4ls20 W50yPTJBFKihIZbwyQW8g6yRKV3qSS38ZHzHO4cVeu/BscFzqVguoM+oadafa5kNviIgKrMFfdkn DcZUZx2q3qfw8Syj1Dydajmms4GmMRt2QtsCs4zkgYWSMjrktjjBNNNjTZXv/iEby2vgNGgju7y2 aGScTOQC6qkjBemCscYA/hK5y2TVPUfGkepQ6uJdNZZdViiFyy3HyiSLGxkG3heDlSSTkYYY55sr Wpa6LGNIl1XUZWt7ZldLRFHz3MoGBtB/gU43N+A5PDUilI6XX9dttKsbJLUQXV3PoKaZLLFexyRx f3wUTJ3Ds27HPQ4Nee5r0CTw/BpPgvxBa3Ygl1O2W1kkH2dc2rSP91ZerEqBnHyjPBOTVDVPA8Gl R3kc2t2y3ttAJTE7RKsjYDFF/eGTOCcZQZx2yKoq5CfGf/Th/wAwP+x/9d/5E6f+O/rTrvxpHcXW qagumsmo6lZfY53NwDCAVVWKptBBwnGWOM96bc+C/s+v63pf2/d/Zli155vk483CK23G7j72M5PT pWZaaNGNHl1bU5Wt7ZldLNFA8y5lAx8oP8CnBZvwHJ4ANC38W2//AAiltoN/pK3cVrK80LfaGjBJ DY3gDJALk8MucAeueXzXVf8ACGf8V/8A8It/aH/bz5P/AEy8z7u78Ov+FPg8FRtDCZ9SZJW0w6rK sduGCQc4CksNz/d4IA5PzHHIBmjXbceD/wCwvscvmfavtf2jzxjfjbjZt6bf9rrz7VqWnjaO3udM v305n1HTrP7JC4uAImAVlUsm0knDc4YZx2q9deHFl07RtH0l9PW7vtPW9dJ4ibid2BchZNhVFATA G5e+c5ybfhlNC1jUtE06FdP+zvZNHe2k1oTcSTBXLMJdhwOhGHGAOAOlAWMm38bxLFAJ9PZ5F006 XKyXG0NDzgqCp2v93kkjg8DPDtK8arp40LNmJP7L8/8A5bY83zfw+XGffPtWHo2jR3cUuo6jK9tp FuwWWZRl5H6iKMH7zn8lHJ463ofDNodEttSk1SURSoxeaKzMkFvIOkcrBt6EkrzsI+YY3DmpcSXE 1oPGsKxQ+fZFnGnnTZGW4ChoecFQVO1+nOSODxzxgLMpAO4fnWtZ+B57nVNItVvcQX9pFcPP5Q/c tIkjqm3dluIm54/xZY+FprnQ5L5p2guEs3vRBMqAPEp6jDl8EAkEoATxnkE5TpNmM6LY611ZV0a4 0ueITW8j+dFtfa0UuMBs4ORjgg/gQak0TVINKF95trJP9rtmtjsmEe1W+8eVOTwMfj1qXTPC6ahF pLRagyyapFK1urQcCSLO9XO7heBhgCTk5AxzziXIPesnCUdTBwnHU7/wtqdnHDo0t5cWgj043JV1 uwrxh1yd0RGXzngoe/PI55qw1s6dplpZC08z7Nqaahv8zG7aoGzGOOnX9KzFlBp+QaPaSQvayRsT eK4Lq6sri70yR2sb6a7thDdBB+8kEm18o27BHUY47Vl6h4ji1Hw/dadJZMLi41B9QeZJxtEjZBAT bnbtP97Oec9qhZAajeEHtVqt3NI4h9RPD2t2+if2j59nJc/bLR7Q+XOI9iP948q2TwMenPBqXTPE /wDZuk2Vj9j8z7Nqqalv83G7aoGzGOOnX9KpSW/tVd4PatVUTN1VTPR9C8SWd3e6dquovZwQ2lzf TLtvQskAlyxV4mXdKSThTGe/IyMVweharaaPdteT6d9suY8NalpyiRSA5DlRy2CBxkDr65Ga0RFM II7Vpc0TTJbq6mvbua6uH3zTSGSRsAZYnJOBx1qGiigYUUUUAFFH4UCgAooxRxQAZ/lRk0Z9qU0A FJxRiigAzQfrRRQAUfjRRQAvekpe9JQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABR RRQAUUUUAFFFFABRRRQAdqKO1FABRRRQAUUUUAFBooNACUUUUAFe2/Ab/kXPHn/XpF/6BPXiVe2/ Ab/kXPHn/XpF/wCgT01uhPY9EuerfX+tZrferSuerfX+tZrfer2lseU9z5/8df8AJQvEv/YVuv8A 0a1YFb/jr/koXiX/ALCt1/6NasCvEPWCiiigDVopaWuQ4gjkMUqSKFLIwYBlDDI9QeCPY1q/8JPq /wDbH9rfaI/t+zZ532ePOOn93GccZ644zipvCOnWureIoNPvIt8Nwki7gxDIQhYMuO4I75HPStXS rbw5rNxNOunzWwtLG4uJ4A7PGSrDZglgzHa3PK5IGMDNUk+hST6MwNL1D7LqM1y91Ja+ajq/kW0c iuG6qYyVXaeeOgwOPS3rniBL9dNt7WJRBp6ko8lvGhkdiGYmNRsC5HC8+5Oa0Y7XQbi6sbhNI1EW jQzGaTyJBDwcCXaHZiq5+YBx0H0M8Oh2M63UkmmwrGukT3UE9rcSNBK6kYZQ3zBlyVZWJ57Du7PY dnaxzz+I9VfWk1g3K/2gi7RMIUBPBXkAYJwSMkenoKn0nxBNbeRb3dzcLaQQzRRCCONtvmckMrDE ik4ypI9QRiuhttC0aK6hkn0/zoV8OjUHi8513yg8nIPGRx6e1XJfCmgxyLcfZ5lht7S9aSNpC4ka 3kCBzgqcnJJAKjgDjnLSkNRl3OP8S6xDrN5aPBGyx21pHbBmRUL7cktsXhRkngE9PwGfp+oXWlX0 d7ZS+VcR52PtDYyCDwcjoTWjrqaY1tY3GnWV1brKrh3kiKRSkHgpl3ORnB+bsOlR+G9Jj1zxBaad LI0UczHcyjJwFLED3OMZ7e/Sp1uTrcjtvEOrWkMMUF9IiwzCdOhIcJsHJ5xt+Xb0xxih9f1J/s2Z owLaYTwBII1ET8fdAXgEgEqOCeSCea7SKysNfj8HWzWn2exme9b7PHIxwqtuC7jyc45PHU4xxijp Nj4a1W/01f7OuEhkuXhklZHhgfMbFUyZXO/cFwARkHpVWfcrlfc5uPxJq8TFo71kY3ZvSVVQfOII LdOhBIx056UDxJqqtbtHcrGbaUyweVCiCNiMEKABhT3UcHqQSatXGlQWngxbq5t2h1J9RaJfMJVm iVPmwp7B+CccHit99HstU8W+GbSaORba50yKZ4hM7AfK7bVLElV4AwDwOnPNFmCT7nH3mr3t9apb TvGYI3LxokKIIyRg7doG0HGSBwTzjPNJqWr3ureR9seN/ITy4tkKR7V7L8oHA7DtzjrXQeHtPsfE GqafDNojW0DXDrJPbySeVIBGXEZ3lsN8vZhwTx0Io6sujzaNHc6dYXUUi3BjafyGSFhtztO6ST5x jPBHBPFKzsKzte5jWV5Np95Fd2zKs8TbkZkVwD64YEZ/l1p9xqF1dai2oSS7bpnEhkjURnd/eG3G DnnI789abZ2VxqF5FaWkLSzyttRF7n+g9+1b4s9HSaDQ7N/tV/dzR289+y7oosuM+SOCeeCx6hTj hqSTBXMe/wBXu9T3G6Fszs/mM6WsUbs3cllUE9T1NLNrV7NEsYaCELKs4NvbRwneudrZRQcjccfW u1urCym0OPSIIGt7VPEi2bESFnfCbGck8bjyeAAOOPWncWXho6ncWi6dcItrqEcUk6I6wxx+btYS u0rcEZwQFOR+FVZ9yrPuc6/ifVpHLNPFkzpc8W8YHmqciTAXAbJ5bqRwcjiov+Eg1XF0BeOPtTrJ KQADuWQyAqcfLh2ZvlxyTW9c+HreG38T5sZEmgvYrfTgd+WLSH5VH8ZKbT3OCD3zUENnpek3drpV 8sNxeT3ES30rP+7tI96lo1YH7/HzNnAGQO5o1Fr3MK/1S51PcbpbVnZzI0iWsUbsxzkllUE5yepq jtA7V3dv4XsHu9cgvLWSBU1O3tbNmZlIV5uQueGPlkHnPGDUy6LpCXCzR6XApXxCmmqpZ2URq2Sc MxyzcA5yMDgA807PqPlb3OPvtbv9RltZLp4ZGtVCwgW0ahVHRSAoBUehyOvqaZfaxf6lqK6hdT5v F24mjRY2yvQ/KByPXrwPQV0+p2FhJc69qkEEizaNexjybh1lhlTzCgQKFXao2qAMngY96d5lnrHh nxJdw6bLHPe3cBjEsgl8yZpCSsWEU7gGbjk4b8y3mFvM5ybxLq08UySXKlpohDLKIUEsiDHytIF3 kYUZyecc5ol8S6xNdXdxJes0l3E0M3yLhlZVVsDGASEQZAB+UVbfT7Xw9YSC+gSXV7mIhLVhxaIw ++4/56EH5V/h6nnArRvdL086ddfY9HxNb2qNPBJJLHeWz95GDZSROMnao4ccL1o1DXucZtFSXM0l 1O00zBnbHQAAADAAA4AAAAA4AAAr0bUfBNja3+uTiykWxhsp2tlO/akiRxMG35+bJd+Dx8p644zt V8N6dZaFq8TRr/aelLamSWFXVWMmMjLO24c5yFTkenFOzQ+Vo5qfxJq1zDNFNcpIs8QimLwxkyqM YLnblmG0YY5YdiMnMN7rd/qMTJeNBMzKqtM1tH5rBcAZk27ycAc5ye9dhN4f0iWKZEsFiZ9AGqq6 SPmOXj5FyxGw4PUE/MeemOCK+1F2httE0up3ktl9keRfL2hSwjUOyjorPjcyjC4UkgbV9BirdTS3 dw007b5GwM4AAAGAABwAAAABwAABxXoE/h/SJYpkSxWJn0AaqrpI5McvHyrliNhweCCfmPPTCX3h 7SE1fX9GjsERdO003MVyJHMrOqI3zZbYQdxzhR7YqtStTiTrF99k+z+ZFt2eX5nkJ5uzGNvm4342 /LjP3fl6cV0Nr4stbTQpbcteT3D6W9gI5oYiELHqJxh9gHIjIIB4zwCN68hS6+FelrZaJA8t1ePi CBZWIcCUbxhizMAv8RI9sAY812+1O9h81jQh8UaxbxQxx3ShoIjBDMYIzNGhyNqyFd6jDEDB4zxi qkerXUNj9ki8hEKlS620Ylweo8zbvwckHnocdOK6q2khs/hl9rt4WS8/tYIZcqQx8o8MCvzJsZl2 Hg7ic4JWr1j4c0eTWfD+jSaerrqWmC5mujLIJVdkdvlw2zAKjGVPvmncpM8/muZbnyhK+4RRiNFA ACqOwA46kk+pJJ5JNW7bWry0tDbQC1RGjeMv9kiMm1wQw8wru5DEdehxXY/8IzpH/Pp/zKv9of6x /wDj4/v9f06e1O0Tw7o+oxeGEnsFDavFcxzyLJIDG0Iba6fNjceM5BXgYA5yxnKQ+Kdat4YY4r5l EERhibYpdEwQAGxnIDMFOcqGYAgE0Q+KNYghhiS6QrDEYFLwRuTEc/u2LAlk+Y/KcgcccDHZ6Ppt po+m3lvHD5l1d+GJr6W6ZjkB8ARqvQAYySckk9hxXmmKAOtl8WJa+F9HsNJmnivrNZlkle1jziUk t5cmSyEZIyMEg54xiuTDFa6eCKM/DK5mgjU3S6mq3DxgbxAYwVDkc7C4GM8bgO9Hg2KKeDxCkiNu TSJ5VkSV0IK4+U7SAynPIYEcD3oCxziTbOwH4VYS6Ga7Pw74a0m8t/C8d1aea+rSXTTymRwyCE/K q4IAB24OQTycEcYr6Hpmk32j6dfz6VAXuNbGnugklC+W4DZHz53LyoOcY6gnmpcEyJU0znkugamW VTnGMnk1003h7SNJu9EtDYLeDUNUuLWWS4lkDIiTiIbdjKM455B59uKY+n6Do+lXF5eaa10LTW5N Nz5zhmiBDbyAQC4UMoxtHOSDisnQXQyeHXQ54lSOcGo2jUjgCtrww1ncTeJUgWfyI9NuJYHaVkkC qeA2whTkEZBBGQKvaDY6ddaHpt3cWMcskurLp8mZJAGRwG3cMMMOQMcYPIJ5qPZNGfsWjjnhUcBQ PoKgaIDoBXptv4W0hNR0nT5LdplvLu8R5XkYOqwOQqjaQuCF5yCeTgjjHJ+GkuLrxVbLZ28ghlnU XMMAZk8guu5W65TGAd2R61aTW5pFNbnLsgHao8CtbX0g/wCEg1I2oi+zfapfK8rGzbuONuOMYxjF ZW3HWtkzaLG0oFLx2FFMoTAo44oooAOKOKKKADijij/CigA4o4oooAOKOKKKADijiipI4JpUmeOF 3SFN8rKpIRdwXLccDcyjJ7kDvQBHxmjil70lABxRxRRQAcUcUUUAHFHFFFABxRRRQAcUcUUUAHFH FFFABxRxRRQAcUcUUUAHFHFFFABxRxRRQAcUcUUUAHFHFFFABxijijtRQAcUcUUUAHFHFFFABxQa KDQAlFFFABXtvwG/5Fzx5/16Rf8AoE9eJV7b8Bv+Rc8ef9ekX/oE9NboT2PRLnq31/rWa33q0rnq 31/rWa33q9pbHlPc+f8Ax1/yULxL/wBhW6/9GtWBW/46/wCSheJf+wrdf+jWrArxD1gooooA18Ck xS45o5rkOEv6THqhluZdKlmikgt2lmeGbyyIlwW5yMjpxQ8eqWS2usGWaJrtpGhuVm+dyDhzkHIO SevXNa3gqW0XUb+2vbyO0S8sJbZZpPuqzbevQdAepHp3reu30Ca20u0tL+EGC0u7i1jk8sqkkjBo 4pC+5MgbgcnOVByCRVpXRaV1e5wzarqL3iXj39011Gu1JjMxdRzwGzkDk/mauXx1+019Ybue8OrR bY0InLyDcMhVYE9Q3QHvV3X47U32lXGnmx82S3jW4EbReWLhTtfcv3VXpzgKRyMjJq7qV3YaV8RE urJrEacZYW3QJHKioNm4gAHa2VbphvTryrBbzOeur3Vra4ntLm9uhJG0kMqGckZZv3i9cEEjn1p9 2dX0S+SynuLi2uLPPlok/wDqd4BO0qcDIPOPWtDxKGfxKbmK702Zprh2iWHyyqr5h2GQgbCT1O4k 4+9iteSPRR8SnjY6b/YtzEVO1o/KC+V2I+429eowfz5dh2OMu7y6vpBLeXU1xIF2h5pC5A9Mk9OT UUckkMqSxOySIwZXVsFSOhB7GvQdAk8N3Emi3Wrf2aLiS3uVmUqiIHEg2b0XCg7C+CRzx1IFY3iS 3Fv4a0WRobNbm6ed7iS2WIhypCrhk4AC9l4zkkZocdLicdL3MCTVtSlYNJqF07CUTAtMx/eAYD9f vAADPXir2tWniCO3gn1lrqSPdtQzz+YY2KhtpGSUYgg4OD+VZEcbSypGpAZyFBZgoyfUngD3Nd3q Nzpk/wATxJe3VvNpE7xyMRMHiZli2qW2nHDZHPYnPBpLVAldHEXd7dX8olvLma4kC7Q80hcgemT2 5NSz6rqN1LDLcahdyyQtuieSZmMZ45Uk8HgdPQV1tqLPytK/tH+xv7Q/tP5/L+z+X9l2Dfv2fJ1z jd82fu1geILiIXk9hBb2PkQXDm3uLdV3GL+FSynDjABy2WznJ6ihoGrK9yjPquo3UsMtxqF1NJC2 6J5JmYxnjlSTweB09BVnVk1l7Oxu9UuJriC4VmtnkuRKMDG7HzHaegIOOntTfD8Gn3Gv2cWrSeXY s+JG3bR0OAT2BOATxgE8jrXXxXGm3H/CLx6xNpzJazXCXccbRiNWb5o/lj+UqflyR8uchj1ppXGl dbnn6O8TFo3ZGKlSVOOCCCPoQSPxpuBXY2N1bWd7p0+vRaJLCtw4dbWOJ5NhTGWWL5CgYg8/NkHF VJbOx0bw5qMN1c6feX128a2ptpFmaII5LMWx8gYYxzk55HBwrCsZ19LrbafDd3t3dSWt+pVGkuC4 lEbdCM5wGJxn1JFVbrVdRv4hFeahd3EYbcEmmZwD0zgnrya6K5j0w6R4WkuTYfLKV1AQMnmeWXXb vCfMTsB56g9eTTtSit31Z5Lu40ZNHTUF2RWoh8ySEuenkjdgJ13EdupxTsO3mcy+o30n2bfe3DfZ ceRulY+VjGNvPy9B09BVXFdX4gx5ep4/sL7L9q/0T7P5XnbdzY2+T229fM9sc1zNtB9ouoYPNji8 x1TzJW2ouSBlj2A7mkxNCz3t3dRQxXF1NNHCu2JJJCwjHHCg9BwOnpW/rGp61qvhq3nuIo10v7Uc Mtw0rGXaeDvdnXAB44HOe4qubnTIL0abaTSDTJnjjvLx0HmSoGUsVGCUUFchRyf4s8AdHey6WNJ/ s+aex+xwa2k3lwSoSbMgoDlDl2x16v0J7GqSKS31OKu9W1K/iEV5qF1cRhtwSaZnAPrgnryaJ9W1 K6lhluNQuppIW3RPJMzGM8cqSeDwOnpXU301vbahcT3MehS6bHqCPBHbrC0zRBycKIuoKdRJx070 y7ttJjh1eNLjTHfVbuIac8ZBFtHv3Fn4zEuGCkdeDxgZoswscdKzzSvLLI7yOxZ3ZiSxOckn15qz LqeozWf2OTUbx7UAKIWuHKYHQbc4wOPyFaF3La6MzWumTLc3BiaK6vMBkO4EMsQI4XBwX6nHG0E5 3b2TQhc6vrEYsTZXlj5VnaIq+bFOygZMf8BUqxLdPmGCc0lfuC9Tj3vr2S3a3e9umhZEjMbTuVKo SVXGegJOB2q/cjXLTTraW5vLqO3lh8uGN7w7jC3GBHu3BDsHbacD2rrdUttNOj+IL3T4NOe0ggtk sXjWNnRX2iTcPvBuOr/MOcEc1V8QQ6Vqmt65qs97btaS2SvZvHcp5hmCxhR5edw6MCCvAz06irPu VZ9yprbeJL7TUtZbWO1t7K1XzLO3uiWEQ2lTJCZGb5cg5IyO/QY4/FdjaahPGmtazrF9byz6hp7W saRSxtI7uAFJRPuhQvO7H4nisi7ktdEL2mm3AurlomiubwqrIdwIZYQRwuDgueTjjaCcj7ifczv7 Rvv+f25/1P2f/Wt/qv8Ann1+77dKdJq2pS2X2OTULt7UKFEDTsUwOg25xgYH5V0fiW4tbSK2jtrf SJlu7BBcmERMY7kY3MpjOUIwvA+Q5bg5NaF+NF83WCp0r+xv7PH9niPyfO87am3p++zu3Z3e+eKL BbzOJh1G+trWS1gvbmK3kz5kSSsqPkYOQDg5HFRiwuDYNf8Akt9lWUQmU9N5BO0epwCfbjPUV34G kf8ACS/8wb/hGPJ/6Yebt8n/AL/bt/8AwLNZ2n3yX/gSTTDeaZbXEd3uf7RFGgEPkkbh8pLPkYyo L8j1osOxyZ1G++wfYPttz9j/AOffzW8vrn7ucdefrVmO41uPQ3aK7vU0oP8AZyonZYizAsU25wcj JP156is/Fdnp9+t/4Ek0z7ZpltcR3e5/tEUaAQ+SRuA2ks+RjKgvkihME7nJQ6pqdvDDDBqN3FHC xaJEnZRGTkEqAeD8zdPU+tMi1C/g+z+TfXMf2bd5GyZh5W7723n5c98da7uwGi+Zo+/+yf7G/s8/ 2h5nlef52193X99ndtxt9scV5/tp3sO9iaLVdTt4YYoNRu4o4GLRJHOyiMnOSoB4J3N09T61Q2Cv QLK00ZtMFubmwlguNJYoZzAksd9ktt3YWRVG04LHacgZOQKuaVaaYujeHr3UYNNSznguo795EiV3 VNwj2j7xbJ6p8x4yTxVIpM82hnuLXzPs88sXmxmKTy3K70PVTjqD6VJZalqGm7/sN9c2vmY3+RMy bsZxnB5xk/nXomlWmljRvDt7qUGmpZzwXUd+8iRK7qm4R7R98tz1T5jxknisrTVthoOijTv7E+1e fL/aP9peT/eXZnzPm27f+efv3qrlXMLRPFmo+HrZ4rEIGZmYO0kmFJXbnYHEZIxkblPOPQVlRX93 BCkMN3PHFHKJ0RJCAsg4DgA8N79a7zQ7fQF+wGefTXsp57mPUYpRGPKz8sXlFwJgpypyCcckkYaq EH2fTPBsdyYtGn1O21BkMcvkSs9vxkFcksN44b7wXOCFNFx3Oag13V7Xzfs+q30PmyGWTy7h13ue rHB5J45qL+07/wDs/wDs/wC3XP2L/n385vL67vu5x15+tX9JuhBNqrpfrpiz2c0YjSAyiUNj9yM5 Kg/3icjHWsbYadx3RtaFBrzW97caNdS2sMOz7TIt6tuoySE3EsoPOQPr71n2+oXkESRRXc6RpKJk RJCAsg4DgZ4b3610Hhvy5fCHiaw+0W0Vzc/ZfJSedIt+2QlsFyBwK563t93zMcAc1MmkiZSSWp0e ieKtU0tJvs7F5pXeRppZZWO5hgsV37GPfLKefwrMGozafDLDBdTRpMu2VI5CokHPDAdRyevrVCa6 K/JCcL3OOtVSSWyTzUKLerM4wctXsPklLt6CrOlaRf63fCz062a4nKltoIAAHUkkgAfXuQO9Uh+N dh8OLuSy8TxTyahHaWC5+0iW7WJX+RgmVJG/BPYHGe1apWNUktjj+K0LLRL6/tHu4Y4ltkkERmnn jhQuRnaGdgCcDOBRbaRJPrCabJeWNu56zy3KmFfl3cyLke3HfitPRtLtJNDk1Fbi0l1JbkRQ2lzd RRIq7cmVg5G8ZIAXgZHO4ZFAyivhrVjd3ls9p5Ullj7SZ5EiSPJAGXYhec8c89Rmm2egahfacdQi SBbQS+SZZrmKIb8BtvzsOcHNdVqZl1Dw1faZNrOn32qjV1upJReIiSI0AAKO5UEA/LgdMYxjFUJN N8NnxTriQXanTrS2knsw0+FmlUKRFuPLKSWA2nJAGD3oGYknh/VItdGiNZsdRLKvkKwY5IDdQcYw ck5wB1xinWnhrVr2+urKC03TWknlT7pEVUctsC7iQuS3AGee1begeKtRn8TQy3E9tHPd3cLXl85W JzCm3KbshVXC8gAFsAEnpWnfTWep22taMl5p6ztrcl9G9xchYXikUoGWRTgsu4Ntz26NgrQBx9p4 f1K9S8aK3RFsiq3JuJkhERJIAbewwcgj60XWgahZXtvaXKQRS3EQmiZrmIIyHOG37tuDg45/mM9b rmpaF41+INkJbqW20wQNBJcSMsWSvmMGBbIAJK9QDz0FcldXl74gvrdJHgUxRCCBWdYo4o1yVTcx HA5ALEk+pNAFfUtNu9I1CWxvofJuYsb03BsZGRyCR0IqG1tpb27htbdN800ixxrkDLE4AyTjriuh +IF1b3njfUbi1njnhfy9skThlOI1BwRx1BFZ/hny/wDhJtO8/wCzfZ/PXzvtWzy/Lz8+d/y/dz75 6c4oEZ11bS2V3Na3CbJoZGjkXIO1gSCMg46iouK7a1/suDxD4rjm/s02wgnuLEnynTzFfdEIzyOh +4ODyCDjFatpa6XqF3P9lg02SR/DiXkmEiCR3iEcn+GPtuXhT/EDQM804r1v9nm3huvHeqW9xFHN BLo8ySRyKGV1MsQIIPBBHGKx9Qj0G603UrS2OlDVpNPsmLB4o4xOrHztj8RqdpXIUgHnqQakg1i1 0r4mzTaPq6aTpOp2oga5sPLUpG8Y4Hynym8xBk4Vl68daAND4v8Aw98PeGLxrvw7qdiiJsS60h71 WuICQMOqs29lOQSDkjORlT8vlHFb/ia7e4OmwXL2c17aWiW8lxZOCrxqB5auVUBpEX5C4LAqEHVS TW8SXX27X7m4/tM6lv2f6X5Hk+ZhVH3McYxj3xmgRmRRmaVIlKBnYKC7hRk+pJAA9zxVrVdIvNFv TZ6hEkVwFDNGJVcqD0ztJwe+Dzgg96qxRtNMkSlQzsFBdwoycdSeAPc8V6Rqd1pb+O/El9JPptxE +lNJZvI8UyGUJGFwDkb8q3HX2waAOB0rSbzWr0WenxJLcMpZYzKqFgOuNxGT3wOcA+lP1DRL7S7e 2uLqOIQ3W7yZIp45VfaQGwUYjgmvQ9Kl8PReJPDuoWNxp9vFEb5ZnMqxEQhmSDeCQdxVhyRuI5Oc Zrn7SxSG601r/UdGFo6t9rtUmjkSGFFiVmGC376QL/B8xIyCOdoM5nStJvNavRZ6fEktwylljMqo WA643EZPfA5wD6VbHhbWDLEi2qOssTzLMk8bQ7E4djIG2AA8HJ4yPUV1ugvpdp430a7sryxi0WOB 3RppYo5oyY9jiYnDFi5yByMH5eAcYWiahqDTf2Y+twWa2NtcpbK6xPDKzctEzH5CrkdWJXgY7UCM S/0i80xYHuokEVwpaKWOVZI3AODhlJBIPUZyKisbG51O9isrOFpriZtqRr1J/oO5J4FdRPp2lGz0 iK/1oxrbwSzXdtBci4WMB1VVgwSvmSfeI3YHLEAACqWlTW2talbaLcTwaXozyiR2IjDDYjYLykAs xywyeAW4UDC0AZl7ol9YWiXc0cTWzyGITQTxzIHAztLIxAODnBqlFE88yQwxtJK7BURBksTwAAOp roNZiu4tDij+2afFYR3JEWn295HNJkr/AK1ymdx4xuJ4JwAqkCovBuq22ieLbDUL0utvEzB2VdxU MjLnHoM5Pfr1oAqal4f1LSYfOu7dFi81oC8cyShZF5KMUY7W9jg9fSsziu70DS9C025tV1rU7aY/ 2kFlhjulktpIvLk8uQ7f+mgIO48BvmADc14JDFfaM2qjw4QdQCv5Kws3knAfzBGPK2YPBb5gckYG aBnGcUcV6XZf8IrJcwfb/wCzRFba5LbxbdozbCNvLL7fvpvCfO+e+Tgmsqz3f2ho/wDaf/CNf8f3 7zy/I3eTgb9+z91txnG758/doA4nird9pt3pv2b7XD5f2mBbiL5gd0bZ2ng8dOh5rT8S3UIvbnTY LbT/ALPb3Lm2ubYKWMJ+6pdDhxjBy2WznJ6iulnj0EeMPDMt8dK+xNZot6Ld4vL+0ANneI+ANxTk /KR7A4APPOKfFGZpUiUoGdgoLuFGT6kkAD3PFdR4ohZ3v5EudDSxjuz9kitBB5siEttx5SlsBeTv I7dTiuXijaaZIlKhnYKC7hRk46k8Ae54oEbF94S1nTbe6murWJEtNn2gLcxO0W8gLuVWJGc8cVic V6L4uUX2t6nqFlqmkCISQmALcxO92W8ldjgtjy1Me75xgcnBByM3W10m204y6NcafJeQyoNRDJGw kfCYa3DLzHvD5C4+9yCmMAzjOKu3ek3ljZWd5cRItveqWgkWVXDhcZ+6TgjOCDg5+ld34ysdJ06H xDatDp8LLNbNpkcPl+crN80uQvzhcE4D/KPl2/w1mXRsD4b8FxXtzbSQW88v22KO4VnSOSVW5VDu Hyg9OR04OBQBxXFHFegal9h+za1v/sPzft0X9jfZ/s33fMbO7Z/Bsxnzfl6Z5qv4gutGt/FZ09bb SpNCkuYJhPbAM8aZBlAeI7sElxtbOBjaBhaAOH4xRxXbaxu83Wsf8I1/Zv7z7Nt8jzNu8bPL8n95 uxj73GM7uKZ4ourWyitYrW20a4W809BdGARMYroAb2UxnKEYXgfIctwcmgDjOK25vCOvW9xeQy6b Kj2cH2ickrtWPBOd2cHoeASflPoaxPzr1vVfFxutc8Uac2rWz6T/AGVJ9lAaPa0pjThXHLHJfjJ7 +lAHknFHFejaj/Yfma1s/sj+xP7NH9neX5Pn+ftTb0/fZ3bs7vfdxTNcj0GWHxPLYnSgt1DbTaaE eJSqpt80KOsbc/dOGbnAODQB55xQaPzoNAhKKKKACvbfgN/yLnjz/r0i/wDQJ68Sr234Df8AIueP P+vSL/0Cemt0J7Holz1b6/1rNb71aVz1b6/1rNb71e0tjynufP8A46/5KF4l/wCwrdf+jWrArf8A HX/JQvEv/YVuv/RrVgV4h6wUUUUAbOKTFO59aMVxHAPt7ae7nWC2hkmlbO2ONCzHAzwB7VM2k6il 2lo+n3S3LruSEwsHYc8hcZI4P5Gp9F1BtM1JJzKyRFSkoEQlEiEcoyFgGU8AjI9eoFbVl4ksNPv3 WD7UbGSxlthGyBlgdzkskTuwKnauQW5JPbAqlbqUkupzV1ZXVjKIru2mt5Cu4JNGUJHrg9uD+VMt 7ae7nWC2hkmmbO2ONSzHAycAe1aOsao1+ttbrdNNbW6t5am0jt9hY5YBUJGOAfz/ABbod5Y2V88l 9b+cjQukbbFk8pyPlfY3yvj0PHOewo0uLS5U/s6++3fYvsdx9r/54eU3mdM/dxnpz9KbdWV3YyiK 8tpreQruCTRlCR0zg9uDXTXXieCbVdNu4ZJolgtPsdwhtUZJYwTj92GClWBGV4C9icA1i6xd2ty8 Edi9wLWJDiKXISNiTnYpd8AjaT8xyc+wptIbSWxX03VL3R7sXdhcPBOFK7gAQQeoIPBH19AanvZ9 U1LT47u4B+xW7+RHsjWONGbLEKqgDJxkkD0z2qpa/ZVlLXizPGFyEhYKWPHG4g7R1OcHpjvkbNh4 lMWvabeXlrG1jY/LFaQrhIxg5ZQxOWz82SckjqOMC9QXZsi1Xw1PptjpU3+kNcX+9fs0luUkRlIG MZJOSeOBkY45qi+iarFPFBJpt6s02fLjaBgz4GTgY5wPSumtPFtjZz6LIftly2mzTl3kRVaZZgSz H5jhgSeOc9cjOKrQ+LZNNu7KSzm+028EzTPbtYRWqlipTI8snJ2swyenHBp2iVaJzH2af7L9q8mT 7Pv8vzdh2bsZ256Zxzir2paPJYXVnaoLiS4uIUcxPatE6uxI2AHluRjI4NTXmpwLoSaNZtJLb/aT dPNNEI33bdoUKGYYAyc55z2xzs/8JRp1t4g0LUbdLqWPT7RbSVZI1QsArLuXDHn5icHHTrzwKwJI 5qfSdRtZYoriwuopJm2xJJAymQ+igjk8jp6iifSdRtZYYriwuopJm2xJJCymQ+igjk8jp6itfRta tdA1exnt7q+u7OKVpJYJIxEAShTcoDsC2CeuOmM88EviOaFrOOx1OaOGK489vL06G3KNjbuARsOd pYEEgHofYsgsjFvNNvtP2fbbO4tt+dnnRFN2OuM9eo/Oi1068vY5pLa2kmWLbvKDOCzBVHuSTgAc nn0Na2p6jpd00SQG6jtjI81xbwx+VEWx8pRDI4VjyC3QDGFOCDVvdZ1DWIrXTkRUtYmC29nbIQoY 8cDksxOeSScsfWiyBpFKfTr62gE9xZXEUJcx+ZJEyruBIK5I6gg8exq5qOjx2Wi6VqUdy0q36yZR otpjKEKRnJyMk88dK63xvfw6ffa9ZbLhrjU/szZeMJGixgcq2SXyRjoMHPJxXP3WrabNoeg2fl3E zae7meN0EaSq7BmUMGJHTGcc5zx0ptJaDcUroyZ9J1K1lhiuNPuopJm2xJJCymQ8cKCOTyOnrVzW fDl9okFnLcxSbbiFZGbymCxsxbEZJ/iAGSO34ZrT1rxBpt/otxp1rHJGpvBdwBbSOJQCCvlkIewI IfknoQMA1na3qdrq1npjIJo7q0tI7R4ygKEJu+YPnOTkcbfXn1TSE0h1/wCH4tP0qC4l1GP7XLbR 3YtihAaN2IG1s8sOCRgcE4JwaozaJqtv5fn6ZexeY4jTfAy7mPRRkck+lbmr+J4LvVNCvIJby4/s 1Ig6XICeY6MCXBDNy2OfoOtF1rulNb63FA1639sXMcrl4FXyFEhc4w53nnGPl+tNpDaRgNpOpRqj PYXSrJL5KEwsA0mSNg45bIIx14NNuNNvrRGe5s7iFVcRs0sRUBiNwU5HXBzj0rqNR8ZifxT9utpr r+zZpbZ54JY13ARMGCryeMgtwRyxz60+/wDGcGqafqtjcm8EVy6CBjh9ii4eQkqWGDsZVAB/gHIG MFl3C0e5yNrZXF60q20TSGKJppMdFRRkknsP/rDqRVl9LMfh9NTdplaS48pENuwRlwfmEn3Scgjb 14qS41TbpzaZYr5Vmz75XIxJcEdDIcngHJCjgZ/iPzVZ/tOx/wCEK/sjdcfa/tv2rPlL5f3dm3O7 PTnOOvGO9LQSsb2qWGozDVdIm1ppbyztEurtfsiIswjVSAZQd7kBuNw5I7dax7nwlJbxXUIvFfVL O3FzdWfl4CR9TiTOGZQVJGMfNwTitG98W2Nwmosv21obqyFvFprov2e2fCDcp3EfLtJGEH4VBd+M WuBfXQDG6vrdoJLcxARRF1jR3V925iREuFIGM9Tj5rfKW+UoJ4VuR4XutbuJlhESxvFbkZeRHbaH PPyqecHvg9sEkegWNzZ38tnqrStZW4mkke2McDHj5Fctu3EkhcqNxFX4/F32rQtYt9UkaS+vlRVk Syhxhem48Ek9AcHbjI5qrq2o6NdWEdlYXF/b2cClorZrVD5kuOXkcScsemccDgD1VkL3ehhWtlcX rSrbQtIYommkx0VFGSx9B/8AWHUipJdI1KKyF5JYXcdqVDCdoWCYPQ7iMYORj8KsXGq7dObS7FPK s2ffI5GJLgjoZDnoDkhRwM/xH5q0bzXba60xma5um1VrdYXuEi8oyrkZWVhKRIu3IyUBOFyeCCtB KxkHQ9W+zfav7Ovvs+zzPN+zts24zuzjGMc5qMaNqZiaUWV4Y1iEzP5BwIzkhycfdODz04NdZqHj GK51KTVbK4ks7tkBRP7MgkKtsCkecTuIPPOOh6dqpv4o+yaFolvpV1dxXmntIzF4l8tjJnJHzHJX cVGR0YnjpT0K0MS20kz6Jfai8lwgtyix4tmZJCThgXA2oQCDz1yKij0fUpbM3kdhdvahS3nLAxQA ZydwGMDB/KtPTNTsrXwxrOnTNcC5vvK8spEGRfLbcMncDyTjpx156Vq2finT4dR0bVZFuvtOm2At fsyxKUlIV1B8zdlQdwP3Tj3oVgSTMa28OtP4WvtbN5CotmQC3UhnIZguWwfkHpnk4PQYJy7OxudR vIrS0haa4lbaiL1J/oO+e1bek6jplr4b1PTrqe7E+oeVlorVWWLy3Ld5AWyMemPeqS6obLTZbLTl EbXKBbm5Zf3jjvGuD8qZxnu2Mng7QaC00I7XSvP0S+1F2nRbdkVALZmSQkgMDIPlQgEHnrkVZuTr 99pNvaTWU7WNnEJo9tkFEcbA/PuCg7TgnJODjJzin6VqVnaeGNZ06d5/tN95XlmOEFF8s7hklweS cdOOvPStTR/FVlp//CNebFcN/Zf2rz9iD5vNzt2/Nz1Gc4pqw1buY9ydfvtIgtJrKdrGziE0e2yC iONgfn3BQdpwTknBxk5xWbFpd9P9n8myuZPtG7ydkTHzdv3tvHOO+OlegWt2nh/w34U1a7guy1st 35caxfK5kJ2hnJG0Ecg4bIz6VkaJ4rsdPg0E3EVz52kvONsaqVlSU8nJI2lQTxg5wORnhj06sx9N 8Kalqmj3mpQ287RwKvlKsLMbgl9pCYHIGGJIzjA49MWOB5pUiiRpJHYKqIMlieAAO5rf0vU7G00z WdKna4FvfeX5dwkSs6+W+4ZQsByD/e496q2GqnSIGaxXF9KjI1y4+aEE4xFzwSM5Y8/NgYwSyuF0 NtPD8ssuqR3Pnwtp8UhkMdu0w8xc4RivCg4b5jxxVSDRNSu1ja30+7mWVWaMxwMwcKQGIwOQCQD6 ZrX8NanY6X/an203I+12UlonkxK+N/Vjlh0wOO+eo72NJ16007QrG2nSbdbaxHfsVUEMiqBgc/ey Pp707ofMjEs9C1C6RJIbC7mR1ZkMcDNvAOCRgc4JAPpmq/2PUrv7OtvZXTpc7vs4SFj5u3723A+b HfHSvQo9Qgl8Mtr9xDex2SeJTfx+VbB2ZB0zlgACcqWycNxzWZbePNP+3aZqFza3Mc9hd3cvkxhX WRLhiT85IIKhm42nOByueLUerLjDqznNM8Japqui3upwW07RQKnlKsDMbgl9pCYHIXDEkZxgcc5F vwf4NPiyadf7SgtFiXIXh5GORyE3A7RkfMeMkAZ5xX0nVrCz0vXNJuGuvs2oeV5dzHEGdfLcsMxl gOQT/Fx71e8CeItM8L6jPf332ySWSJoBFBCpGCynduLjn5SMY/GqLOR/GiprlYEuGW1lllhGNryx +Wx4GcqGYDn3NQ80AFFHNHNABRRzRzQAUUc0c0AFFHP6Uc0AFFHNHNABWhpmtX2jfaPsMkSfaI/K l3wRybk7r8wPB7jvxnoKz+aOaACijmjmgA70UvOf/wBdJzQAUUc0c0AFFHNHNABRRzRzQAUUc0c0 AFFHNHNABRRzRzQAUUc0c0AFFHNHNABRRzRzQAU+KRoZUlXYWRgwDoGGR6g8Eex4pnNHNAF3VdWv dbvTeahKktwVCtIIkQsB0ztAye2TzgAdqpUc0c0AFFHNHNAB2oo5xRzQAUUc0c0AFFHNHNABQaOa DQAlFFFABXtvwG/5Fzx5/wBekX/oE9eJV7b8Bv8AkXPHn/XpF/6BPTW6E9j0S56t9f61mt96tK56 t9f61mt96vaWx5T3Pn/x1/yULxL/ANhW6/8ARrVgVv8Ajr/koXiX/sK3X/o1qwK8Q9YKKKKANqil xSVxHnlvSrVL7WLK0lLCOe4jiYqeQGYA49+al1u2tbPWLq0tEmWO3laImaQOWKsRnhRgHA45+tQa dd/YNTtLzZ5n2eZJdmcbtrA4z26VLq17DqGpz3kEEkHnu0jo8of5mYk4IVcDnpz9aelitLFHFGDR RSJE/CnRhDKglLLGWG5lXcQO5AyMn2yKTHtUluYVnU3MckkX8SxuEY8cYJU459qBmj4n0qDRfEV1 p9s0jQxbNrSEFuUVucAdzVTS9MuNX1KCwtQpmmbC7jgDAJJJ9AAT+FXPEerw67qj6hHaSW80uPMV pg6nChRj5Rjge/4VRvJrabyPs1n9m2Qqkv70v5jjOX56Z9BwKp2uN2vodWPBEKy6DHK98ovpZY7l zbkbSv3QqkZUMAcFu3zEAAgVW8JpfWtk2mhkuri7a38trqO4jwE3ljJGAFIGflOSRyOlMs/FqWEW iCCwYyaW0h3PPkSiTO8YCjB54OTjvms+71eF9CTSLK0khtxcm5dpphI5bbtABCqAMZ7GqvEu8C1r /hoaNo2mXai6Mk7SpOZYiiqyn5cAgEAjcRu5IGcDoINe0qx0i60zyHuJre5s4rl95VHO4nIGAQvA /wBrHvSXmsWt3o2lac1lMq2DNlxcDMgc5cY2fKc9DzjvmptQ17T9Qn06STSZGWzhS2Mcl2SskSg9 dqqQ3PXOOOhodhPl6F1fDmkNDp9zcXUljBNeG3lP2iO6QLs3A+ZGAqEnjDeu7oDVTVtBtrbw7Hqt vujb7WbZovtcdyCNm4MHjAAPBGDnseO9afWLVtHi0m3spo7MXf2qXzLgPIx27cKwQBRjPUHk+2Ki vtWSXSodKsrZreySUzuJJPMeSUjG4ttAAC8AAD3zRdDbiT6xpllbaHpGpWS3CfbvO3xzSq+3YwUY IVevPasWPYJUMqlo9w3KrbSR3AODg++DWrqusQX2labp1taSQRWPm7TJMJGfewY5wq9CPSsqNkEq GVWaMMNyq20kZ5AODg++DSe+hLtfQ7XXvBVpYpcpZm485bmG2tTJPHILl3GShAUeWQCDljgj61j6 n4O1LS7G5u5WjkitnCS7UkTGTgEF0UMM4GVJ6jtzV2XxvI99ql3FYKkl7LayqGl3CMwkEZ4G4HHt isrVNT0+/e8ni0uSO6upvNaWW63iPJJIRQq9Sf4t3A/Gqbj0Lly9Cxruh2miWVgrSSSXdzbLceYk sbR5J5TaOQAOj5IYg4HUiteaOlrpWj3fmxBb/fmXzGZV2sAcr5YK4zg4LZwce667q8GsfYPJtJLf 7JbLajfMJNyr908KuDyc+vHSk1DWIL3QdM0xLSSNrHfiUzhg+85b5doxzjHPA4560nbUTtqWp/B2 pwvcRI1tNcW00cM0MbkMpkOIzlgFIbjocjcMgc4W/wDBOrWFtNNhZxDKsTrHHKCSx2jbvRQ4zgfK T1HarU3jeRr/AFS7isFSS9ltZVDSlhGYSCM8DcDj2qlPr1kdRk1K10plvnu1uhJPcmRUIbcQqqq8 E4HJPA455p+6P3CbVfDUGl+GFvHm36gl6LWdI5Q8aHYXK/dHzDgHBYZzz2HM10WqeI4dQ0+8s0sJ IluLz7cGa43FZTkN/AMrgjA4IPOT0rnsUpW6ClbodJ/Zmh/8Il/a+3UfN877LjzUx5vk792Nv3d/ GM5xz14ou9H0hNHe9sze3EKwoftKSxt5cp42yw4DRgkMAdzDpgtnFUv7Yh/4RT+xfskm/wC0/avP 84Y3Y2427em3368+1XD4ltY21Ce00lba6vbQ2sgSUCBAQoYrGEBBO3+8eT3p6D0K+saZY6JdzaXc rcPfQopa4jlUx7igYAIVBxztzu/2sfw1h1v3viC31Bpby70xZdUlt/Je4aX92Wxt8zy8cPt464B5 xmsCk/ImVuhs33hubT2uIbi/sEvLeISyWpkZXAIBwCVCM2GHAY5wcZobS7U+DE1dPOF0L77K6lwU I2F8gYyD0HU9D68S6tr1lq9zdX1xpTG/uIlQubk+UjAKu9UCg5wOAWI55zUP9sQf8In/AGL9kk3/ AGn7V5/nDG7G3G3b02+/XnpxT0K0uTXHhK9t2vITc2jXlnb/AGm4tVZ96JhSeSuwkBh0Y+2aivvD c2ntcQ3F/YJeW8QlktTIyuAQDgEqEZsMOAxzzjNX7rxck9zqV8unsl/qFp9lmcz5iAIVWKptBBwv GWOM96q6tr1lq9zdX1xpTG/uIlQubk+UjBQu9UCg5wvALEc85pvlG+XoW9T8I7fsdzY+ZBp8unpe TXN4+Y4i2fk3KoyfugAAkk9Kzl8NzfY7S4lv7CE3cTSwJLIwD7c5G/b5YbjoWGMgHBrSl8Z+ZcWs LWUj6TFZC0ksJLjcsoGcOTtG1gdpyBn5eoqrY+I7Wy05rUabI6yQtHNCbom3mY9JGjKkhuFOVZfu 8Yo90PduMt/CV7cNaQi5tFvLy3+029qzPvdMMRyF2AkKerD3xTf+EVvv+etv/wAgz+1PvN/qvTp9 726e9XLXxckFzpt82ns9/p9p9lhcT4iIAZVLJtJJw3OGGcdqIfFyLFCJtPZ5Bpx0yVkn2hoecFQV O1/u8kkcHjng90PdILTwffX1raTwXVk32xGa2jMjB5WUMWQArwV28k4XkcnNVz4bmSK2Nxf2FtPd W/2mGCeRlLIc7fm27ATt4yw6jOKbqGswXugaZpiWkkbWG/ErTBg+85b5doxzjHPA4561PPr9lexW TX+lNPPZ2gtUxclImC52llC7sjIzhxnHaloHuk1r4F1i7treaMRbriHz4oyshyuCQC4QxqSBwCw6 jOM1zOW7gfnXQT69ZXsVk1/pTTz2doLVMXJSJgudpZQu7IyM4cZx2rAodugnbobH/CNzpFam4vtP tp7q3+0wwTSspZDnHzbdgJwcZYds4zSaN4Y1HXrZ5bIRllZlCMsmGIXdjeEKAngfMw/lmxPr1jfR WRv9Ka4ns7QWqYuSkTBc7Syhd2RkZw4zjtU+leLf7Nt9KDWPmzaW8pgcS7VZJD84YbTk43YIIxkZ Bxy1yle7coeHtKttVi1YXIlWS1sJLqFo5ABuTswKnIOR0I6e/EeiaQdUj1J2MebS0e4CecUY7e4+ RgQOPlypORg9an0bWbXSJNSP2GaZLy3e2VftAUpG3XJ2HLcDnAHXj0NA1eDRl1B7i1edbq1a2O2Y R7Ub7x5U5PAx6c9aLoV1pcuad4Zg1PwvFewTeVqDXptVjnmAjmOwsFX5eGPAGTgkdeQKoW/hTUNW t47j7TZ2sZuTZmO4Z0aOfcoERXbksd2eMgAHJGKdpni+Cy023s59NlnFtqK6hE0dyI/mVQApBRsj g+lVr/xPHqHh+606WxYXFxqD6g86T4QSNkEBCudu09N2c857VpGPVm0IJavcXTfBWrao11FCqLcW 8skDxMkhBdBkr5gUxg9hlhz9RRpHhu01Hw7qeqTatBA1osf7spIRGXk2guQh4IBwFzyRkjGDY0fx n/Zdvo6vYedPpLym3cTbVZJT84ddpJON2CCMZGQcHNLSNettNg1Oym05rnTr5oy0JuCkgEb7lBcL yOoOACe2Kssh0PR11aHVH3Jus7OS5CeaUJC/xD5GDAcfLlScjB60R+H3/sq11K7v7Oygu2cW/n+Y xkCEBjhEbAycc46elTaHr1tpEuqPLpzSrf20lrshuDGIkc/NjcrEngYye3OaBrtpc6Fp+l6lYTyr YNKYZLa5ERIkYMQwZGycg8jHHagCWbwbfWraiLq6s4Bp0qR3RZnIRXGUf5VOVbgDGWBPIAyaz77R ZtL12XSdQngtpYmw8rFmjAxkH5VJwRjHGeecc1q6j4yk1JfEPm2Sq2sNAQVkOIRERgdPmJAAJ455 9qr6l4nN/wCL5df/ALNtm34/0W6HnR8RhOememfrigZz9bHh3TodVvWtZLSeY7d5kS6WCOBB955G ZG+Ucc8fiSKx+a3tP120t/Dc+j3NhO6z3InkmtrkQs4CgKjZRtyg5bHqaBF1fDmnva3uq2rXN/pk d29vbosiwSsFiMrOxZWGAqnAxls5wuNpsXfgdtH+3y3ha+jtrk26R20ohZgITOXJZWAAQfd5JJPP HzUk8S6fsubB9Ezosk6XMVkt2waKVVCk+ZgkhhkEEd+CCM05vGUmoteJrtkt/bXNyl35UUhgMcig KMMAflKDaQcnuCDyQZbu/A7aP9vlvC19HbXJt0jtpRCzAQmcuSysAAg+7ySSeePm5/xBo0nh/Xbr S5ZUmaBgBIowGBAYHB6HBGR69z1rVbxlJqLXia7ZLf21zcpd+VFIYDHIoCjDAH5Sg2kHJ7gg8nPl 1wal4lfV9as1vllYmW3R2hDDbtUAjkAfL6k4560AS+HvD7axBeXRVpY7Uwx/Z45BHJM8r7EAYghR nkkg9AO+RrJ4HbLXYLT2jW1rcQ2yShJnNw+xELldoIOctjBwOBn5cLSNaOm297ZXFv8AadPvowlx CH2NlclGV8HBU89CD0IPbSl8ZSXM13Bc2StpM9sloLJJCrRRx5MW2QgncpJOSCDk5GMYALaeB2y1 2C09o1ta3ENskoSZzcPsRC5XaCDnLYwcDgZ+XB17R/7IuLQq+6G9tI7yEE5ZEcH5WOACQQRkdcA4 GcDTl8ZSXM13Bc2StpM9sloLJJCrRRx5MW2QgncpJOSCDk5GMYytc1mXWr1JjEsEEES29tApJEUS 52ruPLHrknqT26AA0vDXh2x1vSNYubu++xSWnkiGVyPK3SMyjfxkDIAz2zk5Arb1HwJpsWl3dxp9 9LO8djaXMMs8scMchld1YneBtGFBAJzk4ya5Ww1o2Ogavpf2ff8A2j5P73fjy/Lct0xznOOorVvf GZvNAm0v+z9nmWNpZ+b52ceQzNuxt/i3YxnjHU0AS6l4Lht3so4NTtYZJbG3ndLiXzGlllLLthES sXGQOmeo5Nc/rWlNompyWEl1a3MsXEjWzFlRucqSQOR3x06dcgdBF41gXyZH0uUXMGmxafFcw3QS SILu3OhKEKWBxnGQM4PNYVzeaW+o2cttpLRWkKoJ7d7pnM5BO4l8DaWHHAwOooAzO9FTXMkUt5NJ bw+RC8jNHFvLeWpJwuTycDjNQ80CCijmjmgAoo5o5oAKKOaOaACijmjmgAoo5o5oAKKOaOaACijm jmgAoo5o5oAKKOaOaACijmjmgAoo5o5oAKKOaOaADtRRzijmgAoo5o5oAKKOaOaACg0c0GgBKKKK ACvbfgN/yLnjz/r0i/8AQJ68Sr234Df8i548/wCvSL/0Cemt0J7Holz1b6/1rNb71aVz1b6/1rNb 71e0tjynufP/AI6/5KF4l/7Ct1/6NasCt/x1/wAlC8S/9hW6/wDRrVgV4h6wUUUUAbefb+VJ+H60 u76/kaM/X8q4jzy/oUaTeIdMiljV43u4lZWAIYFxkEdxUniNwfEN/EscMccFxJFGkMSxgKrnHCgZ PueaoW9zJaXUVxAxWWFxIjbc4YEEHnjtUt9qFxqVy1xc7Gmb7zJCse45ySdoGTk9etPpYq+lirRR +FFIkM1PZyW8V3FJd27XECtl4lk2F/bdg4H+eOtQVJb3D206zRrGWXOBJEsi9McqwIP5UDRueNre C08X30FtDHDEvl7Y41CqMxqeAPesazhhnvIori5W2hZvnmZSwQeuF5J9v5dam1PV7zWJxPfPHJKO siwojN0HJUDPQdelR3moXV/5H2mXzPs8KwRfKBtRc4HHXqeTzTbV7jbTbZ3dtYaNd3XhE2ulZtZ3 uQyPtMkoQ4DSHjPI3EcjGQAehw/Lt9T8LW11erb2j/2k0D3sdsqLHH5YbaUjALEnpweh5GazE8R6 rHFZRx3KxrYtutykKKUPfkDJB7g5z3zUF3q15e2qW0rxrbo5kEUMKRJuIxuIQAE4GMmq5kW5I3PE UekjQvD1zY2LRW8jXAflRNKquoyzYPzHk9CBnA4FP8Rz2emavo17ZaVZrE+mxS/ZZY98ZLbx83Tc QMcnnIBrCl1m+ntLS0kaFoLNt0CG3jwp7/w8g9wc575pNR1q91SOKO7eF1iULGVt40KqM4UFVB2j J46UOSE5I6Q3un6U9tZeI9LhkvoLvz51trWJcR+WdqErtDHcVbHIwRk5yBn3ax3vgVNRlt7dbtNS MAkhgSL5DFuwQgAPI6kZrGvNTu7/AFJtQupFluWKszNGuDtAAyuMEYA4xzRfand6gsKXEimOAFYo 441jRMnJwqgAEnqcc0cwORsa+scvhbw9efZ7eO4n+0+a8MCRb9rgDIUAcCsGyAN/bhrZrpTKuYFJ BlGR8oI5yenHrVm+1e81GC3guXj8m33eVHHCkapuOWwFA64qnHI8MqSxOySIwZXUkFSDkEH1pN3Z Labudi1uuuSajbQ6bCkBvoYklNtHbzWAaTbhkUDzAdxXG4/cyQOKy7nwtLa2esXMlxhdPdRH8g/f qZmi3dfl5Q8c/wBaqT+I9VuFkBuFjMkqzSNBCkLO4OQWZACSCc89+etO1DxRrWqWslte38ksEjh3 TaFBIAA6AccA46Z5xnmqvFluUWWNTs4IvDvh2ctGIZ/O3yR2oWXh1Dbjvw+Dnb93j68XNe0aw8/w /Z6azJPd2kGA8QVX8xm/eOwYndkjjBwOh4xWDc6ve3mn21hM8bW1t/qVEKKUz15Azz1PPJ5PNSHx BqxsYrMXsiwxbNm3CuAhJQbwNxCkkgE4HboKLoXMh2p2lnpN/JBbXc1xdWtwY2E1oixkqSCfvtkZ HQjkdfSt7xdoEH9pa9eWXlwJp724e2WIKm2RFAKkd92cjA9c9qwp/Eep3KyLJLDtllWWUJbRqJWB yN+FG8ZJOGyKZc+INTvPt3n3O/7f5f2n92o37Mbeg4x7Youh3Re1Ozgh8O+HZy0YhuPO3yR2oWXh 1Dbjuw+Dnb93j68W7jwQ6XF7awXyyXVncQQyCSLYhEzYQhgSSeVyCBjJwTjnCutXvbzTrawneM21 t/qVEKKU9eQAeep55PJ5qwfEuqS3NzNPdSN9reJrkxBY3fyyCu1gvykYGCB+dF4heJo3/hGPT4tU Ml+zSaZFEbhVgGDJJjYqHdyvJyxAIwMA545f8K6zUPFNrcaFf2cZu55r1YFLXEUYaMR8ndKvzSnI ABYDj9eTz9aJW6BK3Q6fWtP0m28I6Nc2rzedO07B2gVTMQ6r8/znaABwBkH2yaLnwikFzqNiuoM9 /p9p9qmQwYiIAVmCvuJJw3GVGcdqyYtd1KDTG06O6dbVgy7doyFYgsob7wUkDIBwe/epJvEmqzxT JJcAmaIQyyiFBLIgxw0gG4jgZyecc07od4mTW1rmjWuh3M1jLezS38SpuRbcCLLAMQH35wAeu3nH asY/Q1qzeI9WnilSS4UtNEIZZRCglkQY+VpANxGFGcnnHNSrEq3UutFC/wAOEuDBD56ap5IlESh9 nlFsFgMkZPf29BUtz4RjgudSsV1Bnv8AT7T7VMhgAiICqzBX3ZJw3GVGcdqxf7Xvf7H/ALK3x/Yt /meX5KZ3f3t2N2e2c9OOnFaM2p+I59MlupI5jazRCGW8FooMiAhcNMFyRkAHLc9DVXRV0M1jRbHR Luawub+4e+hRSyx2qmMsVDYDGQHHOM7fwrXn0WPUPB2i33lxwiGG4e6kt4EMrqsiop2ArvwOpJ4G STk84n/CUav5nm/aI/tGzy/tP2ePzsbdv+s27844znPvTIfEmq27WDQ3KobBWW22woAgYYbjHJPq c+vWi6C8SS10S3utFkvYrqaWaKJpJYIoUYx4OOcyBtvKksFIGfY1etvCMc9zpti2oMmoahafaoUE GYgCrMoZ9wIOF5wpxnvVS31fxBHpy3EIkNvaobdbv7KrNCp42ibbuX72B8wxkYostW8QPa7rMSSr ZwmP7QlqryQRkHjzdpZBgtjkYHShWBcpZ/4RH/p+/wCYN/av+q/8h/e/8e/Sq50Cxi0zT7651VoI 7+KQxFrYkLIhIZX2sSFztAYAk5OQMc14vEmqwRQxpcqViiMKl4UcmM5/dkkEsnJ+U5HTjgYr3OsX t5p1tYTvG1tbf6lVhRSnryADz1PPJ5PNGgXiXL/RbTS7O0a7vZvtV1aLdRxxW4ZAGztBYuCDxz8p xnvUk+gWNlFZLf6q0E95aC6TFsXiUNnaGYNuycDOEOM96rQ+JNVgiiSO5UNDEYYpTChljQ5+VZCN wHJxg8Z4xT4PEGsw2sbRTfLbp9nS48hDJErBsKJSu5eN2MHpnHSjQLxMaup0TT9In8J63d3TzefC sClxbqxh3SfwZcbicAEnaRzjOTnl61tBu9Zt7iRNGWaSRlVpI44PNBCsCrFSCMg4wccH60luKLJd F0O31a3dvtU32lWb/RoIUdyoXOQGkUsT83Cgn5eeoqvdaXZxaHp+o39/PDFfNKIY7e2EpxGQpLFn XHJ4AzwOvanReItcC+XZM901qXui8lstw0HILOGZWKjOCTxzz1rPt/FOsWyxqLpZTFK00TXEEczR uxyWVnUlSSM8Hrz1rWEVubU4L4mY9FW4LbUNXu5Ps8F1e3LZkk8tGkc5PLHGT1PX3qp+daGoUUfn Vi0sbzUJmisrS4uZQu4pDGzkDpnA7cj86AK9FH50fn1oAKKPzo/OgAoo/OrFnY3moSmKytLi5kC7 ikMbOQOOcDtyPzoAr0VbstM1DUd/2Gxurry8b/IhZ9uemcdOh/Kq8sUkEzwyxvHLGxV0dSCpHBBH Y0AMoo/Oj86ACij8+lPiiknmSGKN5JZGCoiKSWJ4AA7mgBlFH50fnQAUUfnR+dABRR+dH50AHeil 796T86ACij86PzoAKKPzo/OgAoo/Oj86ACij86PzoAKKPzo/OgAoo/Oj86ACij86PzoAKKPzo/Og Aoo/Oj86ACij86PzoAKKPzo/OgAoo/Oj86ADtRR270fnQAUUfnR+dABRR+dH50AFBo/Og0AJRRRQ AV7b8Bv+Rc8ef9ekX/oE9eJV7b8Bv+Rc8ef9ekX/AKBPTW6E9j0S56t9f61mt96tK56t9f61mt96 vaWx5T3Pn/x1/wAlC8S/9hW6/wDRrVgVv+Ov+SheJf8AsK3X/o1qwK8Q9YKKKKANykyP8ilpCQOp ArhPOQZH+RUlxbzWk7Q3MMkMq43RyIVYZGeQR6VLZ2Nzf+f9lj8z7PC08vzAbUXGTyaJrG5t7K1v JY9tvdb/ACX3A7tpw3GcjB9aqxViK4gmtJ2guYZIZVxujkQqwyM8gj0ouLea0naC5hkhlXG6ORCr DIzyCPSo8j1H506JHmlSKJWeR2CqijJYnoAPWgBbi3ntJ2guYZIZVxujkUqwyM8g+1Fxbz2k7QXM MkMq43RyKVYZGeQfaluIJLW6ltpl2zQuY3XIOGBwRke4qKkIkuLee0naC5hkhlXG6ORSrDIzyD7U TW89v5fnwyReYgkTepXcp6MM9QfWo6KAJZree38vz4ZIvMQSJvQruU9GGeoPrRNbz2/l+fDJF5iC RN6Fdynowz1B9aiqe7s7iwuTb3UTRTKqsyN1G4Bhn0OCOO1ADZrea38vz4ZIvMQSJvQruU9GGeoP rRNbzW4j86GSLzEEib0K7lPRhnqD61FRQMkmtp7fy/Ohki8xBIm9Su5T0YZ6g+tE1vPb+X58MkXm IJE3oV3KejDPUH1q1faRfacitdweXnbld6lkLDcA4ByhI5AbBOD6GqPamDViSa3nt/L8+GSLzEEi b0K7lPRhnqD606ezuraKGS4tZoo5huieSMqHHHKk9RyOnrUuoaZd6XLFHeRqjSxCaMrIrhkOcEFS Rg4NSalomoaTFbS3sKpHcgtC6yo4cDHIKk8cj86LBZlR7aeOCKd4ZFilz5cjIQr4ODg98Hrike2m iginkhkSGXPlyMhCvjg4PfB602NDLKkalQzsFBZgo59SeAPc1PqFhc6XfSWd5H5VxHjem4HGQCOR x0IoAhkt54oIp5IZEhlz5cjIQr4ODg98HrQ9tPFBFPJDIkM2fLkZSFfBwcHvg+lMpY0MsqRqVDMQ oLMFGT6knAHuaAHSW08cEU8kMiQzZ8uRlIV8cHB74PWh7aeKCKeSGRIZs+XIykK+Dg4PfBqXUNPu tLvZLO8i8q4jxvTcGxkAjkHHQiq1MNiR7eeKCKeSGRIZs+XIyEK+Dg4PfBoe3niginkhkSGbPlyM hCvg4OD3wetOubO4tFga4haMTxCaLd1ZCSAfocH+fQ1BQMk+zT/ZftXkyfZ9/l+bsO3djO3PTOOc UG2n+y/avJk+z7/L83Ydm7Gduemcc4qPNGaAH/Zp/sv2ryZPs+/y/N2HZuxnbnpnHOKPs8/2X7V5 Mn2ff5fm7Ds3Yztz0zjnFWYtMu7jTLnUYo1a1tmCzN5i5Qk4GVznBJ649fQ1SOB3oGSfZ5/sv2ry ZPs+/wAvzdh2bsZ25xjOOcUv2eb7L9q8mT7Pv8vzdh2bsZ25xjOOcVFn3oz70ASfZpvsv2ryZPs+ /wAvzdp2bsZ25xjOOcV1niWS/l1u71LSBMNIe0EMc6qVg8kxgNGCflAzkbeu7gDdXN6jpl3pcsUd 5GqNNEJoysiuGQ5wwKkjBwaItMu7jTLnUYo1a1tmCzMJFyhY4GVznBJ649fQ1S7FLsdr/wAI3p// AAkn2D+yP+JJ5O7+1t0vTyd3meZu8v73tj2qCHw3p9xFFLDZNJHNoJlidHch70ZyqkHl/lPyD0PH FchqOmXelyxR3kao00QmjKyK4ZCThgVJGDg1JZ6JfX8Qe0WGZmVmWJbmPzTtyTiPduJ4PGKd/Id/ I2tBtp5PAvid0hkZT9mwwQkHa5ZvyBBPoK2tE0uGy0qVbW3a4l1DRJn+1gsQ8rD/AI90A43KEYkc scHoBiuQh8N6rPFE8dspaaIzRRGZBLIgzysZO4jg4wOccVlUXt0BSt0Cu60fQdKv4vDqS2ShtUiu EmdZHBRot2HT5sbjxnII44A5zxkFnNcRTSxqvlwrl3d1QDrgAkjLHBwo5ODgcVctfD+qXn2DyLXf 9v8AM+zfvFG/Z97qeMY74pR9BR9DqbDw7ps0mkRNp3madc6eZ7vU98n7mTa5YbgfLXaVAwR9c1Ug mS6+Gs0VvpsMskN9mVI/MYxr5P8Ar2Abg8Hk/LweK46gdafMPm8gAya7DQBJB4D8S3ENvdmVDAyy wsRgq24EHacFPvNz0x93rXKm3lFhJeIFaOM4YB1LL05K5yFyQN2MZIGc1ju5diWOaqnHW5VKLbud j4Rhudcl8TTywTz3Munzy+dA0iMZW5CYQgEMSTtIOdvA4NO8PaVpd1oOl3lzp0U0s2srpsm6SQB4 3Abdwww45AxgYPIJ5riqK2Og9Y8MaDYaD4gs7iGNrotqF3bPdO5xZBN0aI23C75Cy8t6gBcnNeVS xPBM8MqNHKjFXR1wVI4II7GmUUAbGlWenwqNQ1lm+zBS8FomRJdkHGAcfImern0IXJB29x4JtLOP UNJ10WkTy6hd3AlkiykOn8MqxAA4BcuoG49CABk5ry+igD0DSfD+lRaBp1zc6NfajdSTzJexwW8k rwlGA8shJE8s45+YMefQAVj3uj2Wo6Lp8vhqyu7qdZrhbsKjSSKu8eTvAyASh6jgkHrg45ej/GgD q9U0vQD4nvJYLn7N4dhkCJJFukaZlRSyRZzuJOfmJ2jcCTyoJLb2Gv6FcT6TpOzVlvlC2lqHkaO0 EWAcfxfMvzNjO4843AHlKKBnpR8N+Hb+5uv7FtPtsTarDZHypJH+zQGMb5Vwf7+7DNuX5eBjqS2V p/wj2u6fYaVczeXrhhe102UiXyUQhC5KuxXcrHkY3ZxjGK4vSNdbSdhWwsbl450uIpJ4zvjdemGV lJHT5SSOOnWs+6upr27murh9800hkkbAGWJyTgcdaAO1u7P7IdU8J2um32s2FrfLcrNZNiSNzHtK uQjg45HQcqfoIfEw0zWPG+oancX+zRhIqefEu5p2SNQUiGME5GN33RkEnlQ3FUUAdxp1pp2raHr2 uN4cTy7FozawwvKEK7dhVyD8wUbZGIwxOSSAaE0zR7zSL/U9A0afUn/tBYo7OcyO8EJj3bisTA43 5AJJ4Ud854eigD0rUvCmgWd7ra6RD/atzbQRPDYec0m12mZZBiMhzsULwTxu5zxT9Fg0zQ/iLokK WsFvLdWcckySSPm0naJ8xqC3BbK/K+4/MMYyK8y/wooAu31tcHVWtv7MazuGZVWzRJMgkDACuS2T kHr34qrLE8Ezwyo0cqMVdHXBUjggjsaZRQIOKOKKKADijiiigA4zRxS96SgA4o4oooAOKOKKKADi jiiigA4ooooAOKOKKKADijiiigA4o4oooAOKOKKKADijiiigA4o4oooAOKOKKKADijiiigA4xRxR 2ooAOKOKKKADijiiigA4oNFBoASiiigAr234Df8AIuePP+vSL/0CevEq9t+A3/IuePP+vSL/ANAn prdCex6Jc9W+v9azW+9Wlc9W+v8AWs1vvV7S2PKe58/+Ov8AkoXiX/sK3X/o1qwK3/HX/JQvEv8A 2Fbr/wBGtWBXiHrBRRRQBuUUmB6CjC+griPOOk8GS2i6hf215dx2iXlhLbLLJ90M23r0HQHqR6d6 6S4vNDd9MW1vo1eG2vLq2jWXyFSSUhkidlYBMAsCNw+6PXB83wPQUmB6CrU7Kxop2Vj0WO/spPGO jXctzZrbz2Bt7/8Afqys6qwZZCSSwzsALEhsDBNZ664IoPCl7JqLG5WSRb6QSlpfKEykLJj5iuMk A/hXFYHoKWjnY/aM3vFm+XWprh9RhvFmkkMSxz+aYot52gkZAyOQoPHcCpfBuoLplzqtz9ojglGm zeQzkDMmVKgA9TkdK5vA9KKnm1uTza3PWNP1vQ5NX0y7lurFSsV5DE5VUMaCVfKB4GweXuxnHU9z zx3iDUby60eCK9fTSwuCyLDdPczD5cE7y7hUPHGRkjOOCa5iiqc21Yp1G1Ylt7ie0nWe2mkhlXO2 SNirDIxwR7V6Dc6hZTePrHVbnVrWbTGlH2eJpS/lZhHzleRGN+OuDkZxxmvOaKlSsTGVjqdWunbw hDb6jfR3ep/b2eM/aVuGWHywD8yltoLY4yM46cVzdvv+0xeX5e/eNvm7duc8bt3y49c8etRUUN3E 3dnc6vNp178TYZrq9hGnloytxbSqOi8ZdOQd4xknIHcAAij4qukv9G0qV3tWvoWliuRFceawyQyf MWZmXBPOSASRweK5Sim5XuU53v5nS+LzG39jeXPby+VpsUEnkzpJtdc7gdpPqOeh7dKv+NJYJvD3 h2OG6tZntYPKmWG4RyjbEHQE8fKeRx+Yri6Wjm3Dm38xtek+IrvS9Qn1IajqNvLZtc2psXhnWR4w QonKhckDaCcEYzg4JrzekoUrCjKyseiapf6fPBEt3PZyrZ6wkgzdfaWazJxnLOxOcDcg9ASo61k6 /NqN3NqSPrNnNZTXn+jwSXccpILttKcnygAeSSowcc9K5Gj8KbncpzuegeNNRsdQh1NdOvLeIxzR PchZVb7eCihSpBydhByvT+LrXAxyPDKksTskiEMrqcFSOhB7Gm0hpOV3cUpczudzqWoQ6h/wj97c 6vDLYQRWouraWVnZ5QxEhMeCSQM5ZgMg8E5o1q+8zS/Ei3uow3Sz3cbaagulnKgSMSVAJ2DYcduu PauGoqucfOJW9eXlvo9nLpelzLLNKuy9vk6SDvFGe0fqf4/pgVgmjFTclOx6Hq19ZNo2uWFle2v2 B7e2bTYFnQDahDScZyHyc4b5m98cGv6yZRqSWMukHSHtFSISXLMSNq4VIA5COD0+QY25JHNeeUcV XOX7Q76/1SwOoa5ry3kLQalp32aCBXBnEjKFIZP4QuwknpgjBOa568vLfRrOXStLlWWaVdl7fJ0k HeKM9o/U/wAePTArCwKMUOVxOVz0W41G08hrCa8s3hTw0IygljZTcKeFyD8zAjKjJxkkdTTdWvrJ tG1ywsr21+wPb2zabAs6AbUIaT5c5D5bOG+ZvfHHnZA9KMU+crnPSY76CWfR0utRtX0IaQkV9btd IRvCMf8AV53bwQnKjORWPDYLBpVtZ6XqOmRPf24e+vZ7yNGXIz5G3O5V6ZwDuJGcAYrjuKMCjmDn ubmk3X2bw5rqo1uk0yQxhmm2TbS/zKgx8wIxuGRx61hUvFGKm5LZ0FtcwXXge50sTRx3UF79t2ys EEibNhCE9WB529SOmelXtB1GaDwhqv8AptvHc2+P7P8AMljEsW4/vvL3HcMrjp1Occ5rkKKfMNSN +K8t9AsENhKs2rXMQL3KdLRGH3EP/PQg/M38PQc5NdNoWq2qxeFo7rUIRG0V1DfLLMMGMbvLSUE/ dGTtDcc8V52BVe8kwmwYyetOLbdkODbdkb2gX9vp9hrl9czxhJ7GSwggVwZXkfHO3soA5Y4HYZPF cp2oFHat0raHUlZWQUUcUcUwCijijigAoo4o4oAKP8aOKOKACijijigAoo4o4oAKKOKOKACijiji gA/woo4o4oAKKOKOKACijijigAoo4o4oAXvSUcZo4oAKKOKOKACijijigAoo4o4oAKKOKKACijij igAoo4o4oAKKOKOKACijijigAoo4o4oAKKOKOKACijijigAoo4o4oAO1FHGKOKACijijigAoo4o4 oAKDRxQaAEooooAK9t+A3/IuePP+vSL/ANAnrxKvbfgN/wAi548/69Iv/QJ6a3QnseiXPVvr/Ws1 vvVpXPVvr/Ws1vvV7S2PKe58/wDjr/koXiX/ALCt1/6NasCt/wAdf8lC8S/9hW6/9GtWBXiHrBRR RQBt4HpRgelJgf5NGB/k1xHni4HpRgelJgUUALj2pOPSiigAooooAKKKKACiiigAooooAKKKKBi0 UlFABikpaSgQUUUUAAowKKKACkpcUmKYwpKWigBKKKKACiiigYYpCPalopgJiijHNGKADHtS4pKO KBhigDmjApQABQJiMwRSx6AVmMdzE46nNWbyTkRjtyaqVvTjZXOmlGyuAo7UcUdq0NQoo4o4oAKK OKOKACijijigAo/xo4o4oAKKOKOKACijijigAoo4o4oAKKOKOKAD/CijijigAoo4o4oAKKOKOKAC ijijigBe9JRxmjigAoo4o4oAKKOKOKACijijigAoo4ooAKKOKOKACijijigAoo4o4oAKKOKOKACi jijigAoo4o4oAKKOKOKACijijigA7UUcYo4oAKKOKOKACijijigAoNHFBoASiiigAr274CqW8PeO 1HJNpCB/3xPXiNe4fs//APIE8b/9e0H/AKDPSbtqNK+h6RNY3b7iLO75/wCnaT/4mqR0q/J/48rr /wAB3/wr0y5e4jw0MYlUjBTOCD659KiUMABIQz9yvAroeNqLSy/r5mH1WnvqfMurWHgXWNZvtUuL fxGs95cSXEix3UAUM7FiBmMnGT6mqf8Awj3w/wD+ePib/wAC4P8A41RRXT7Cn2Of20+4f8I98P8A /nj4m/8AAuD/AONUf8I98P8A/nj4m/8AAuD/AONUUUewp9g9tPuWv7N8Cf8APDxJ/wCBUH/xuj+z fAn/ADw8Sf8AgVB/8booqfqtH+UjmYf2b4E/59/Ef/gVB/8AG6P7N8Cf8+/iP/wKg/8AjdFFH1Wj /KHMw/s3wJ/z7+I//AqD/wCN0f2b4E/59/Ef/gVB/wDG6KKPqtH+UOZh/ZvgT/n38R/+BUH/AMbo /s3wJ/z7+I//AAKg/wDjdFFH1Wj/AChzMP7N8Cf8+/iP/wACoP8A43R/ZvgT/n38R/8AgVB/8boo o+q0f5Q5mH9m+BP+ffxH/wCBUH/xuj+zfAn/AD7+I/8AwKg/+N0UUfVaP8oczD+zfAn/AD7+I/8A wKg/+N0f2b4E/wCffxH/AOBUH/xuiij6rR/lDmYf2b4E/wCeHiP/AMCoP/jdH9m+BP8Anh4j/wDA qD/43RRR9Vo/yhzsP7N8Cf8APDxH/wCBUH/xuj+zfAn/AD7+I/8AwKg/+N0UUfVaP8oczD+zfAn/ ADw8R/8AgVB/8bpP7M8Cf8+/iP8A8CoP/jdFFH1Wj/KHMw/szwJ/z7+I/wDwKg/+N0f2Z4E/59/E f/gVB/8AG6KKPqtH+UOZh/ZngT/n38R/+BUH/wAbo/szwJ/z7+I//AqD/wCN0UUfVaP8oczD+zPA n/Pv4j/8CoP/AI3R/ZngT/nh4k/8CoP/AI3RRR9Vo/yhzsP7M8Cf88PEn/gVB/8AG6P7M8Cf88PE n/gVB/8AG6KKPqtHsHOw/szwH/zw8Sf+BUH/AMbo/svwH/zw8Sf+BUH/AMbooo+q0ewc7E/svwH/ AM8PEn/gVB/8bo/svwH/AM8PEn/gVB/8booo+q0ewc7D+y/An/PDxJ/4FQf/ABuj+y/An/PDxJ/4 FQf/ABuiij6rR7BzsP7L8Cf88PEn/gVB/wDG6P7K8B/88PEn/gVB/wDG6KKPqtLsHOw/srwH/wA8 PEn/AIFQf/G6P7L8B/8APDxJ/wCBUH/xuiij6rS7BzsP7L8B/wDPDxJ/4FQf/G6X+zPAn/PDxJ/4 FQf/ABuiij6rS7BzsrtoPgBmJMXibJ/6e4P/AI1Sf8I/4A/55eJv/AuD/wCNUUVXsKfYv20+4f8A CP8AgD/nl4m/8C4P/jVH/CP/AA//AOeXib/wLg/+NUUUewp9g9tPuH/CP+AP+eXib/wLg/8AjVH/ AAj/AIA/55eJv/AuD/41RRR7Cn2D20+4f8I/4A/55eJv/AuD/wCNUf8ACP8AgD/nl4m/8C4P/jVF FHsKfYPbT7h/wj/gD/nl4m/8C4P/AI1R/wAI/wCAP+eXib/wLg/+NUUUewp9g9tPuH/CP+AP+eXi b/wLg/8AjVH/AAj/AIA/55eJv/AuD/41RRR7Cn2D20+4f8I/4A/55eJv/AuD/wCNUf8ACP8AgD/n l4m/8C4P/jVFFHsKfYPbT7h/wj/gD/nl4m/8C4P/AI1R/wAI/wCAP+eXib/wLg/+NUUUewp9g9tP uH/CP+AP+eXib/wLg/8AjVH/AAj/AIA/55eJv/AuD/41RRR7Cn2D20+4f8I/4A/55eJv/AuD/wCN Uf8ACP8AgD/nl4m/8C4P/jVFFHsKfYPbT7h/wj/gD/nl4m/8C4P/AI1R/wAI/wCAP+eXib/wLg/+ NUUUewp9g9tPuH/CP+AP+eXib/wLg/8AjVH/AAj/AIA/55eJv/AuD/41RRR7Cn2D20+4f8I/4A/5 5eJv/AuD/wCNUf8ACP8AgD/nl4m/8C4P/jVFFHsKfYPbT7h/wj/gD/nl4m/8C4P/AI1R/wAI/wCA P+eXib/wLg/+NUUUewp9g9tPuH/CP+AP+eXif/wLg/8AjVH/AAj/AIA/55eJv/AuD/41RRR7Cn2D 20+4f8I/4A/55eJv/AuD/wCNUf8ACP8AgD/nl4m/8C4P/jVFFHsKfYPbT7h/wj/gD/nl4m/8C4P/ AI1R/wAI/wCAP+eXib/wLg/+NUUUewp9g9tPuH/CP+AP+eXib/wLg/8AjVH/AAj/AIA/55eJv/Au D/41RRR7Cn2D20+4f8I/4A/55eJv/AuD/wCNUf8ACP8Aw/8A+eXib/wLg/8AjVFFHsKfYPbT7h/w j/gD/nl4m/8AAuD/AONUf8I/4A/55eJv/AuD/wCNUUUewp9g9tPuH/CP+AP+eXib/wAC4P8A41R/ wj/gD/nl4m/8C4P/AI1RRR7Cn2D20+4f8I/4A/55eJv/AALg/wDjVH/CP+AP+eXib/wLg/8AjVFF HsKfYPbT7h/wj/gD/nl4m/8AAuD/AONUf8I/4A/55eJv/AuD/wCNUUUewp9g9tPuH/CP+AP+eXib /wAC4P8A41R/wj/gD/nl4m/8C4P/AI1RRR7Cn2D20+4f8I/4A/55eJv/AALg/wDjVH/CP+AP+eXi b/wLg/8AjVFFHsKfYPbT7h/wj/gD/nl4m/8AAuD/AONUf8I/4A/55eJv/AuD/wCNUUUewp9g9tPu H/CP+AP+eXib/wAC4P8A41R/wj/gD/nl4m/8C4P/AI1RRR7Cn2D20+4f8I/4A/55eJv/AALg/wDj VH/CP+AP+eXib/wLg/8AjVFFHsKfYPbT7h/wj/gD/nl4m/8AAuD/AONUf8I/4A/55eJv/AuD/wCN UUUewp9g9tPuH/CP+AP+eXib/wAC4P8A41R/wj/gD/nl4m/8C4P/AI1RRR7Cn2D20+4f8I/4A/55 eJv/AALg/wDjVH/CP/D/AP54+Jv/AALg/wDjVFFHsKfYPbT7h/wj3w//AOePib/wLg/+NUf8I98P /wDnj4m/8C4P/jVFFHsKfYPbT7h/wj3w/wD+ePib/wAC4P8A41XV+DfEHhPwRBqcOnafrE8eoqiT i6uImwFDAbdqrj75/Siij6vT7B7ep3OmHxetgoUJq2AMfegP/slNPxatD/Bq3/fUH/xuiip+rUn0 /Fj9vU7n/9k= --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_ 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 --_011_D9531A0CC2204F43B26D57506BAD73F23728532390ESGSCCMS0002e_-- From xen-devel-bounces@lists.xen.org Sun Nov 11 13:14:31 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Sun, 11 Nov 2012 13:14: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 1TXXLx-00081X-LS; Sun, 11 Nov 2012 13:13:33 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TXXLu-00081S-P7 for xen-devel@lists.xen.org; Sun, 11 Nov 2012 13:13:31 +0000 Received: from [85.158.143.35:24101] by server-2.bemta-4.messagelabs.com id 83/02-28922-A74AF905; Sun, 11 Nov 2012 13:13:30 +0000 X-Env-Sender: abb@gremwell.com X-Msg-Ref: server-15.tower-21.messagelabs.com!1352639607!14434111!1 X-Originating-IP: [209.85.220.173] X-SpamReason: No, hits=1.2 required=7.0 tests=HTML_10_20,HTML_MESSAGE, RCVD_BY_IP X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 4998 invoked from network); 11 Nov 2012 13:13:28 -0000 Received: from mail-vc0-f173.google.com (HELO mail-vc0-f173.google.com) (209.85.220.173) by server-15.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 11 Nov 2012 13:13:28 -0000 Received: by mail-vc0-f173.google.com with SMTP id fl15so6470853vcb.32 for ; Sun, 11 Nov 2012 05:13:26 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=mime-version:date:message-id:subject:from:to:cc:content-type :x-gm-message-state; bh=9ASChrrsuQA65GbCQNfdRXZZLHT415mwWX9EJmWP2OM=; b=cDNamct+nAMC+CftP7GXsD0iN/33GYUa7zOhNExCw4ZSnLpvLYZdoscZqxKLPn9w4q jU6bILxsR9sFoY5gLVLbB11l7v4HhGXt3RYYVsdRcqdo8c7SeK/Z6SdbSN1ek4FGQNpy 8Ty1qU+e7ze3QEM645IYB+saCansOwThNlOrH3cQTPBMzvYpuJgi4uUKqWa9+zOYRMO5 z5UBFEM7uFs68r9kemD9fITJwRE3lhF3iZPCytqdd6dI73pWPb2v+AUeQ/4ilPC/dGR5 WutV0b7QSOYqzKxOpqP3XNC45Ow66TTYdPSTJPfcXR+h8oVearHUTR4SybBA+dHT9eyr l26A== MIME-Version: 1.0 Received: by 10.220.208.141 with SMTP id gc13mr19788270vcb.55.1352639606631; Sun, 11 Nov 2012 05:13:26 -0800 (PST) Received: by 10.58.155.226 with HTTP; Sun, 11 Nov 2012 05:13:26 -0800 (PST) Date: Sun, 11 Nov 2012 14:13:26 +0100 Message-ID: From: Alexandre Bezroutchko To: xen-devel@lists.xen.org Content-Type: multipart/mixed; boundary=bcaec517a674432cc304ce37f3ed X-Gm-Message-State: ALoCoQkEytLqGO4nHjMmkbL2ydf8F2g4GKFJXDD1/zvwScvIRU01dEjWsTN2+TPOTFejcKRDrAui Cc: Marek Marczykowski Subject: [Xen-devel] [xen-devel] kernel 3.4.12 crashes if built debugging 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 --bcaec517a674432cc304ce37f3ed Content-Type: multipart/alternative; boundary=bcaec517a674432cbf04ce37f3eb --bcaec517a674432cbf04ce37f3eb Content-Type: text/plain; charset=ISO-8859-1 Hi, Kernel 3.4.12 built with debugging options crashes during bootstrap. The issue is easily reproducible and also seems to affect 3.4.18. The "offending" debug option is 'page allocation', if I switch it off but leave other debugging options the kernel does not crash. +CONFIG_DEBUG_PAGEALLOC=y +CONFIG_WANT_PAGE_DEBUG_FLAGS=y +CONFIG_PAGE_GUARD=y The kernel is actually built from devel-3.4 branch of marmarek repo of Qubes, but all the patches are disabled, so it supposed to be equivalent to vanilla kernel. Partial error messages are below. The kernel config file and full log are attached. ---------------------------------------------------------------------------- [ 0.575221] debug: unmapping init memory ffffffff81879000..ffffffff81913000 [ 0.575474] Write protecting the kernel read-only data: 8192k [ 0.579226] debug: unmapping init memory ffff880001469000..ffff880001600000 [ 0.579825] debug: unmapping init memory ffff8800017fc000..ffff880001800000 [ 0.601666] BUG: unable to handle kernel paging request at ffff88000f66d000 [ 0.601678] IP: [] __tlb_remove_page+0x84/0xb0 [ 0.601689] PGD 180c067 PUD 1810067 PMD 861067 PTE 801000000f66d064 [ 0.601698] Oops: 0002 [#1] SMP DEBUG_PAGEALLOC [ 0.601705] CPU 5 [ 0.601708] Modules linked in: [ 0.601713] [ 0.601717] Pid: 60, comm: init Not tainted 3.4.12-1alldebugnopvusb.pvops.qubes.x86_64 #1 [ 0.601726] RIP: e030:[] [] __tlb_remove_page+0x84/0xb0 [ 0.601736] RSP: e02b:ffff88000f645a78 EFLAGS: 00010286 [ 0.601741] RAX: ffff88000f66d000 RBX: ffff88000f645c30 RCX: 0000000000000000 [ 0.601747] RDX: ffff88000f66d000 RSI: 0000000000000010 RDI: 0000000000000200 [ 0.601754] RBP: ffff88000f645a88 R08: 0000000000000000 R09: ffff880000000000 [ 0.601760] R10: 0000000000000001 R11: 00000000581c6204 R12: ffff88000f62ec68 [ 0.601766] R13: 0000000193e49125 R14: ffff88000f5e3150 R15: 000000000042a000 [ 0.601777] FS: 00007fda48c7b740(0000) GS:ffff880018d40000(0000) knlGS:0000000000000000 [ 0.601784] CS: e033 DS: 0000 ES: 0000 CR0: 000000008005003b [ 0.605188] CR2: ffff88000f66d000 CR3: 000000000f665000 CR4: 0000000000002660 [ 0.605188] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 0.605188] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400 [ 0.605188] Process init (pid: 60, threadinfo ffff88000f644000, task ffff88000f6427c0) [ 0.605188] Stack: [ 0.605188] ffffea00003d78c0 ffffea000048a680 ffff88000f645b78 ffffffff8110b1d8 [ 0.605188] 000000009658ccc5 0000000000000100 0000000000000000 00000000000001ff [ 0.605188] 00000000004d9fff 00000000004da000 00000000004d9fff ffff88000f62f000 [ 0.605188] Call Trace: [ 0.605188] [] unmap_page_range+0x4a8/0x730 [ 0.605188] [] unmap_single_vma+0x63/0xb0 [ 0.605188] [] ? put_pages_list+0x30/0x30 [ 0.605188] [] unmap_vmas+0x5e/0xb0 [ 0.605188] [] exit_mmap+0x97/0x140 [ 0.605188] [] mmput+0x73/0xf0 [ 0.605188] [] flush_old_exec+0x3ed/0x720 [ 0.605188] [] load_elf_binary+0x31e/0x1840 [ 0.605188] [] ? load_elf_library+0x200/0x200 [ 0.605188] [] search_binary_handler+0xe7/0x2f0 [ 0.605188] [] do_execve_common.isra.32+0x3e3/0x4b0 [ 0.605188] [] do_execve+0x16/0x20 [ 0.605188] [] sys_execve+0x42/0x70 [ 0.605188] [] stub_execve+0x6c/0xc0 [ 0.605188] Code: 8b 47 10 48 8b 10 48 85 d2 74 0c 48 89 53 10 8b 42 0c 8b 52 08 eb bd 31 f6 bf 00 02 00 00 e8 d4 87 fe ff 48 85 c0 48 89 c2 74 1e <48> c7 00 00 00 00 00 c7 40 08 00 00 00 00 c7 40 0c fe 01 00 00 [ 0.605188] RIP [] __tlb_remove_page+0x84/0xb0 [ 0.605188] RSP [ 0.605188] CR2: ffff88000f66d000 [ 0.605188] ---[ end trace 555e8456cfdd3999 ]--- [ 0.634427] ------------[ cut here ]------------ [ 0.634435] kernel BUG at /rw/home/user/qubes/qubes-builder/qubes-src/kernel/kernel-3.4.12/linux-3.4.12/arch/x86/kernel/paravirt.c:244! [ 0.634445] invalid opcode: 0000 [#2] SMP DEBUG_PAGEALLOC [ 0.634451] CPU 5 [ 0.634453] Modules linked in: [ 0.634458] [ 0.634462] Pid: 60, comm: init Tainted: G D 3.4.12-1alldebugnopvusb.pvops.qubes.x86_64 #1 [ 0.634472] RIP: e030:[] [] enter_lazy.part.4+0x4/0x6 [ 0.634483] RSP: e02b:ffff88000f645488 EFLAGS: 00010202 [ 0.634489] RAX: 0000000000000001 RBX: ffff88000f664c68 RCX: 00003ffffffff000 [ 0.634496] RDX: 0000000000000006 RSI: ffffea00003d9a80 RDI: ffffea00003d9ab0 [ 0.634502] RBP: ffff88000f645488 R08: 0000000000000000 R09: 0000000000000000 [ 0.634508] R10: ffffffff81871d00 R11: 0000000000000001 R12: ffff88000f669ff8 [ 0.634514] R13: ffff88000f664c68 R14: ffff88000f66afe8 R15: 00007fffffffd000 [ 0.634524] FS: 00007fda48c7b740(0000) GS:ffff880018d40000(0000) knlGS:0000000000000000 [ 0.634532] CS: e033 DS: 0000 ES: 0000 CR0: 000000008005003b [ 0.634537] CR2: ffff88000f66d000 CR3: 000000000180b000 CR4: 0000000000002660 [ 0.634544] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 0.634550] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400 [ 0.634557] Process init (pid: 60, threadinfo ffff88000f644000, task ffff88000f6427c0) [ 0.634564] Stack: [ 0.634567] ffff88000f645498 ffffffff81039bf2 ffff88000f645588 ffffffff8110b002 [ 0.634577] 0000000000000011 0000000000000100 0000000000000000 00000000000001ff [ 0.634586] 00007fffffffefff 00007ffffffff000 00007fffffffefff ffff88000f6657f8 [ 0.634596] Call Trace: [ 0.634602] [] paravirt_enter_lazy_mmu+0x22/0x30 [ 0.634609] [] unmap_page_range+0x2d2/0x730 [ 0.634617] [] ? release_pages+0x148/0x1c0 [ 0.634624] [] unmap_single_vma+0x63/0xb0 [ 0.634631] [] ? put_pages_list+0x30/0x30 [ 0.634637] [] unmap_vmas+0x5e/0xb0 [ 0.634644] [] exit_mmap+0x97/0x140 [ 0.634650] [] mmput+0x73/0xf0 [ 0.634657] [] exit_mm+0xfd/0x120 [ 0.634664] [] ? xen_irq_enable_direct_reloc+0x4/0x4 [ 0.634672] [] do_exit+0x164/0x8a0 [ 0.634680] [] ? _raw_spin_unlock_irqrestore+0x12/0x20 [ 0.634687] [] ? kmsg_dump+0x5a/0x100 [ 0.634694] [] oops_end+0x99/0xe0 [ 0.634700] [] no_context+0x24e/0x279 [ 0.634707] [] ? xen_pmd_val+0x9/0x10 [ 0.634713] [] __bad_area_nosemaphore+0x1ba/0x1d9 [ 0.634721] [] ? restore_args+0x30/0x30 [ 0.634727] [] bad_area_nosemaphore+0xe/0x10 [ 0.634734] [] do_page_fault+0x32b/0x4f0 [ 0.634741] [] ? pte_mfn_to_pfn+0x6a/0x100 [ 0.634748] [] ? __alloc_pages_nodemask+0x193/0x850 [ 0.634756] [] ? __d_lookup+0x7a/0x160 [ 0.634763] [] page_fault+0x25/0x30 [ 0.634769] [] ? __tlb_remove_page+0x84/0xb0 [ 0.634776] [] ? __tlb_remove_page+0x7c/0xb0 [ 0.634782] [] unmap_page_range+0x4a8/0x730 [ 0.634790] [] unmap_single_vma+0x63/0xb0 [ 0.634797] [] ? put_pages_list+0x30/0x30 [ 0.634803] [] unmap_vmas+0x5e/0xb0 [ 0.634809] [] exit_mmap+0x97/0x140 [ 0.634816] [] mmput+0x73/0xf0 [ 0.634822] [] flush_old_exec+0x3ed/0x720 [ 0.634830] [] load_elf_binary+0x31e/0x1840 [ 0.634838] [] ? load_elf_library+0x200/0x200 [ 0.634845] [] search_binary_handler+0xe7/0x2f0 [ 0.634852] [] do_execve_common.isra.32+0x3e3/0x4b0 [ 0.634858] [] do_execve+0x16/0x20 [ 0.634864] [] sys_execve+0x42/0x70 [ 0.634871] [] stub_execve+0x6c/0xc0 [ 0.634876] Code: fa 44 89 e6 48 c7 c7 a8 e3 75 81 31 c0 e8 0b 0f 00 00 48 83 c4 18 5b 41 5c 41 5d 41 5e 41 5f 5d c3 55 48 89 e5 0f 0b 55 48 89 e5 <0f> 0b 55 48 89 e5 0f 0b 55 48 89 e5 41 55 41 54 53 31 db 48 85 [ 0.634932] RIP [] enter_lazy.part.4+0x4/0x6 [ 0.634938] RSP [ 0.634941] ---[ end trace 555e8456cfdd399a ]--- [ 0.634944] Fixing recursive fault but reboot is needed! ---------------------------------------------------------------------------- Regards, Alex --bcaec517a674432cbf04ce37f3eb Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Hi,

Kernel 3.4.12 built with debugging options crashes during bootst= rap. The issue is easily reproducible and also seems to affect 3.4.18. The = "offending" debug option is 'page allocation', if I switc= h it off but leave other debugging options the kernel does not crash.

+CONFIG_DEBUG_PAGEALLOC=3Dy
+CONFIG_WANT_PAGE_DEBUG_FLAGS=3Dy
+CO= NFIG_PAGE_GUARD=3Dy

The kernel is actually built from devel-3.4 bran= ch of marmarek repo of Qubes, but all the patches are disabled, so it suppo= sed to be equivalent to vanilla kernel.

Partial error messages are below. The kernel config file and full log a= re attached.

-------------------------------------------------------= ---------------------
[=A0=A0=A0 0.575221] debug: unmapping init memory = ffffffff81879000..ffffffff81913000
[=A0=A0=A0 0.575474] Write protecting the kernel read-only data: 8192k
[= =A0=A0=A0 0.579226] debug: unmapping init memory ffff880001469000..ffff8800= 01600000
[=A0=A0=A0 0.579825] debug: unmapping init memory ffff8800017fc= 000..ffff880001800000
[=A0=A0=A0 0.601666] BUG: unable to handle kernel paging request at ffff880= 00f66d000
[=A0=A0=A0 0.601678] IP: [<ffffffff81109c64>] __tlb_remo= ve_page+0x84/0xb0
[=A0=A0=A0 0.601689] PGD 180c067 PUD 1810067 PMD 86106= 7 PTE 801000000f66d064
[=A0=A0=A0 0.601698] Oops: 0002 [#1] SMP DEBUG_PAGEALLOC
[=A0=A0=A0 0.60= 1705] CPU 5
[=A0=A0=A0 0.601708] Modules linked in:
[=A0=A0=A0 0.601= 713]
[=A0=A0=A0 0.601717] Pid: 60, comm: init Not tainted 3.4.12-1allde= bugnopvusb.pvops.qubes.x86_64 #1=A0
[=A0=A0=A0 0.601726] RIP: e030:[<ffffffff81109c64>]=A0 [<ffffffff8= 1109c64>] __tlb_remove_page+0x84/0xb0
[=A0=A0=A0 0.601736] RSP: e02b:= ffff88000f645a78=A0 EFLAGS: 00010286
[=A0=A0=A0 0.601741] RAX: ffff88000= f66d000 RBX: ffff88000f645c30 RCX: 0000000000000000
[=A0=A0=A0 0.601747] RDX: ffff88000f66d000 RSI: 0000000000000010 RDI: 00000= 00000000200
[=A0=A0=A0 0.601754] RBP: ffff88000f645a88 R08: 000000000000= 0000 R09: ffff880000000000
[=A0=A0=A0 0.601760] R10: 0000000000000001 R1= 1: 00000000581c6204 R12: ffff88000f62ec68
[=A0=A0=A0 0.601766] R13: 0000000193e49125 R14: ffff88000f5e3150 R15: 00000= 0000042a000
[=A0=A0=A0 0.601777] FS:=A0 00007fda48c7b740(0000) GS:ffff88= 0018d40000(0000) knlGS:0000000000000000
[=A0=A0=A0 0.601784] CS:=A0 e033= DS: 0000 ES: 0000 CR0: 000000008005003b
[=A0=A0=A0 0.605188] CR2: ffff88000f66d000 CR3: 000000000f665000 CR4: 00000= 00000002660
[=A0=A0=A0 0.605188] DR0: 0000000000000000 DR1: 000000000000= 0000 DR2: 0000000000000000
[=A0=A0=A0 0.605188] DR3: 0000000000000000 DR= 6: 00000000ffff0ff0 DR7: 0000000000000400
[=A0=A0=A0 0.605188] Process init (pid: 60, threadinfo ffff88000f644000, ta= sk ffff88000f6427c0)
[=A0=A0=A0 0.605188] Stack:
[=A0=A0=A0 0.605188]= =A0 ffffea00003d78c0 ffffea000048a680 ffff88000f645b78 ffffffff8110b1d8
= [=A0=A0=A0 0.605188]=A0 000000009658ccc5 0000000000000100 0000000000000000 = 00000000000001ff
[=A0=A0=A0 0.605188]=A0 00000000004d9fff 00000000004da000 00000000004d9fff = ffff88000f62f000
[=A0=A0=A0 0.605188] Call Trace:
[=A0=A0=A0 0.605188= ]=A0 [<ffffffff8110b1d8>] unmap_page_range+0x4a8/0x730
[=A0=A0=A0 = 0.605188]=A0 [<ffffffff8110b4c3>] unmap_single_vma+0x63/0xb0
[=A0=A0=A0 0.605188]=A0 [<ffffffff810f52b0>] ? put_pages_list+0x30/0x= 30
[=A0=A0=A0 0.605188]=A0 [<ffffffff8110bcde>] unmap_vmas+0x5e/0x= b0
[=A0=A0=A0 0.605188]=A0 [<ffffffff811131c7>] exit_mmap+0x97/0x1= 40
[=A0=A0=A0 0.605188]=A0 [<ffffffff810445c3>] mmput+0x73/0xf0 [=A0=A0=A0 0.605188]=A0 [<ffffffff811396ad>] flush_old_exec+0x3ed/0x7= 20
[=A0=A0=A0 0.605188]=A0 [<ffffffff8117f8be>] load_elf_binary+0x= 31e/0x1840
[=A0=A0=A0 0.605188]=A0 [<ffffffff8117f5a0>] ? load_elf= _library+0x200/0x200
[=A0=A0=A0 0.605188]=A0 [<ffffffff81138dc7>] search_binary_handler+0x= e7/0x2f0
[=A0=A0=A0 0.605188]=A0 [<ffffffff8113a293>] do_execve_co= mmon.isra.32+0x3e3/0x4b0
[=A0=A0=A0 0.605188]=A0 [<ffffffff8113a376&g= t;] do_execve+0x16/0x20
[=A0=A0=A0 0.605188]=A0 [<ffffffff8101ad52>] sys_execve+0x42/0x70
= [=A0=A0=A0 0.605188]=A0 [<ffffffff81460c3c>] stub_execve+0x6c/0xc0[=A0=A0=A0 0.605188] Code: 8b 47 10 48 8b 10 48 85 d2 74 0c 48 89 53 10 8b= 42 0c 8b 52 08 eb bd 31 f6 bf 00 02 00 00 e8 d4 87 fe ff 48 85 c0 48 89 c2= 74 1e <48> c7 00 00 00 00 00 c7 40 08 00 00 00 00 c7 40 0c fe 01 00 = 00
[=A0=A0=A0 0.605188] RIP=A0 [<ffffffff81109c64>] __tlb_remove_page+0x= 84/0xb0
[=A0=A0=A0 0.605188]=A0 RSP <ffff88000f645a78>
[=A0=A0= =A0 0.605188] CR2: ffff88000f66d000
[=A0=A0=A0 0.605188] ---[ end trace = 555e8456cfdd3999 ]---
[=A0=A0=A0 0.634427] ------------[ cut here ]------------
[=A0=A0=A0 0.6= 34435] kernel BUG at /rw/home/user/qubes/qubes-builder/qubes-src/kernel/ker= nel-3.4.12/linux-3.4.12/arch/x86/kernel/paravirt.c:244!
[=A0=A0=A0 0.634= 445] invalid opcode: 0000 [#2] SMP DEBUG_PAGEALLOC
[=A0=A0=A0 0.634451] CPU 5
[=A0=A0=A0 0.634453] Modules linked in:
[= =A0=A0=A0 0.634458]
[=A0=A0=A0 0.634462] Pid: 60, comm: init Tainted: G= =A0=A0=A0=A0=A0 D=A0=A0=A0=A0=A0 3.4.12-1alldebugnopvusb.pvops.qubes.x86_64= #1=A0
[=A0=A0=A0 0.634472] RIP: e030:[<ffffffff8144f3b7>]=A0 [&l= t;ffffffff8144f3b7>] enter_lazy.part.4+0x4/0x6
[=A0=A0=A0 0.634483] RSP: e02b:ffff88000f645488=A0 EFLAGS: 00010202
[=A0= =A0=A0 0.634489] RAX: 0000000000000001 RBX: ffff88000f664c68 RCX: 00003ffff= ffff000
[=A0=A0=A0 0.634496] RDX: 0000000000000006 RSI: ffffea00003d9a80= RDI: ffffea00003d9ab0
[=A0=A0=A0 0.634502] RBP: ffff88000f645488 R08: 0000000000000000 R09: 00000= 00000000000
[=A0=A0=A0 0.634508] R10: ffffffff81871d00 R11: 000000000000= 0001 R12: ffff88000f669ff8
[=A0=A0=A0 0.634514] R13: ffff88000f664c68 R1= 4: ffff88000f66afe8 R15: 00007fffffffd000
[=A0=A0=A0 0.634524] FS:=A0 00007fda48c7b740(0000) GS:ffff880018d40000(0000= ) knlGS:0000000000000000
[=A0=A0=A0 0.634532] CS:=A0 e033 DS: 0000 ES: 0= 000 CR0: 000000008005003b
[=A0=A0=A0 0.634537] CR2: ffff88000f66d000 CR3= : 000000000180b000 CR4: 0000000000002660
[=A0=A0=A0 0.634544] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 00000= 00000000000
[=A0=A0=A0 0.634550] DR3: 0000000000000000 DR6: 00000000ffff= 0ff0 DR7: 0000000000000400
[=A0=A0=A0 0.634557] Process init (pid: 60, t= hreadinfo ffff88000f644000, task ffff88000f6427c0)
[=A0=A0=A0 0.634564] Stack:
[=A0=A0=A0 0.634567]=A0 ffff88000f645498 fff= fffff81039bf2 ffff88000f645588 ffffffff8110b002
[=A0=A0=A0 0.634577]=A0 = 0000000000000011 0000000000000100 0000000000000000 00000000000001ff
[=A0= =A0=A0 0.634586]=A0 00007fffffffefff 00007ffffffff000 00007fffffffefff ffff= 88000f6657f8
[=A0=A0=A0 0.634596] Call Trace:
[=A0=A0=A0 0.634602]=A0 [<ffffffff81= 039bf2>] paravirt_enter_lazy_mmu+0x22/0x30
[=A0=A0=A0 0.634609]=A0 [&= lt;ffffffff8110b002>] unmap_page_range+0x2d2/0x730
[=A0=A0=A0 0.63461= 7]=A0 [<ffffffff810f5098>] ? release_pages+0x148/0x1c0
[=A0=A0=A0 0.634624]=A0 [<ffffffff8110b4c3>] unmap_single_vma+0x63/0x= b0
[=A0=A0=A0 0.634631]=A0 [<ffffffff810f52b0>] ? put_pages_list+0= x30/0x30
[=A0=A0=A0 0.634637]=A0 [<ffffffff8110bcde>] unmap_vmas+0= x5e/0xb0
[=A0=A0=A0 0.634644]=A0 [<ffffffff811131c7>] exit_mmap+0x= 97/0x140
[=A0=A0=A0 0.634650]=A0 [<ffffffff810445c3>] mmput+0x73/0xf0
[=A0= =A0=A0 0.634657]=A0 [<ffffffff81049afd>] exit_mm+0xfd/0x120
[=A0= =A0=A0 0.634664]=A0 [<ffffffff81009dc9>] ? xen_irq_enable_direct_relo= c+0x4/0x4
[=A0=A0=A0 0.634672]=A0 [<ffffffff8104b244>] do_exit+0x1= 64/0x8a0
[=A0=A0=A0 0.634680]=A0 [<ffffffff81458c42>] ? _raw_spin_unlock_irqre= store+0x12/0x20
[=A0=A0=A0 0.634687]=A0 [<ffffffff810490fa>] ? kms= g_dump+0x5a/0x100
[=A0=A0=A0 0.634694]=A0 [<ffffffff81459eb9>] oop= s_end+0x99/0xe0
[=A0=A0=A0 0.634700]=A0 [<ffffffff8144fc9f>] no_co= ntext+0x24e/0x279
[=A0=A0=A0 0.634707]=A0 [<ffffffff81007339>] ? xen_pmd_val+0x9/0x10[=A0=A0=A0 0.634713]=A0 [<ffffffff8144fe84>] __bad_area_nosemaphore= +0x1ba/0x1d9
[=A0=A0=A0 0.634721]=A0 [<ffffffff81459169>] ? restor= e_args+0x30/0x30
[=A0=A0=A0 0.634727]=A0 [<ffffffff8144feb1>] bad_area_nosemaphore+0xe= /0x10
[=A0=A0=A0 0.634734]=A0 [<ffffffff8145c69b>] do_page_fault+0= x32b/0x4f0
[=A0=A0=A0 0.634741]=A0 [<ffffffff8100728a>] ? pte_mfn_= to_pfn+0x6a/0x100
[=A0=A0=A0 0.634748]=A0 [<ffffffff810f1cf3>] ? __alloc_pages_nodemask= +0x193/0x850
[=A0=A0=A0 0.634756]=A0 [<ffffffff8114997a>] ? __d_lo= okup+0x7a/0x160
[=A0=A0=A0 0.634763]=A0 [<ffffffff814593a5>] page_= fault+0x25/0x30
[=A0=A0=A0 0.634769]=A0 [<ffffffff81109c64>] ? __t= lb_remove_page+0x84/0xb0
[=A0=A0=A0 0.634776]=A0 [<ffffffff81109c5c>] ? __tlb_remove_page+0x7c= /0xb0
[=A0=A0=A0 0.634782]=A0 [<ffffffff8110b1d8>] unmap_page_rang= e+0x4a8/0x730
[=A0=A0=A0 0.634790]=A0 [<ffffffff8110b4c3>] unmap_s= ingle_vma+0x63/0xb0
[=A0=A0=A0 0.634797]=A0 [<ffffffff810f52b0>] ? put_pages_list+0x30/0x= 30
[=A0=A0=A0 0.634803]=A0 [<ffffffff8110bcde>] unmap_vmas+0x5e/0x= b0
[=A0=A0=A0 0.634809]=A0 [<ffffffff811131c7>] exit_mmap+0x97/0x1= 40
[=A0=A0=A0 0.634816]=A0 [<ffffffff810445c3>] mmput+0x73/0xf0 [=A0=A0=A0 0.634822]=A0 [<ffffffff811396ad>] flush_old_exec+0x3ed/0x7= 20
[=A0=A0=A0 0.634830]=A0 [<ffffffff8117f8be>] load_elf_binary+0x= 31e/0x1840
[=A0=A0=A0 0.634838]=A0 [<ffffffff8117f5a0>] ? load_elf= _library+0x200/0x200
[=A0=A0=A0 0.634845]=A0 [<ffffffff81138dc7>] search_binary_handler+0x= e7/0x2f0
[=A0=A0=A0 0.634852]=A0 [<ffffffff8113a293>] do_execve_co= mmon.isra.32+0x3e3/0x4b0
[=A0=A0=A0 0.634858]=A0 [<ffffffff8113a376&g= t;] do_execve+0x16/0x20
[=A0=A0=A0 0.634864]=A0 [<ffffffff8101ad52>] sys_execve+0x42/0x70
= [=A0=A0=A0 0.634871]=A0 [<ffffffff81460c3c>] stub_execve+0x6c/0xc0[=A0=A0=A0 0.634876] Code: fa 44 89 e6 48 c7 c7 a8 e3 75 81 31 c0 e8 0b 0f= 00 00 48 83 c4 18 5b 41 5c 41 5d 41 5e 41 5f 5d c3 55 48 89 e5 0f 0b 55 48= 89 e5 <0f> 0b 55 48 89 e5 0f 0b 55 48 89 e5 41 55 41 54 53 31 db 48 = 85
[=A0=A0=A0 0.634932] RIP=A0 [<ffffffff8144f3b7>] enter_lazy.part.4+0x= 4/0x6
[=A0=A0=A0 0.634938]=A0 RSP <ffff88000f645488>
[=A0=A0=A0= 0.634941] ---[ end trace 555e8456cfdd399a ]---
[=A0=A0=A0 0.634944] Fix= ing recursive fault but reboot is needed!
---------------------------------------------------------------------------= -

Regards,
Alex

--bcaec517a674432cbf04ce37f3eb-- --bcaec517a674432cc304ce37f3ed Content-Type: application/octet-stream; name="guest-work.log" Content-Disposition: attachment; filename="guest-work.log" Content-Transfer-Encoding: base64 X-Attachment-Id: f_h9e6j5ne0 WyAgICAwLjAwMDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgY3B1c2V0DQpbICAgIDAu MDAwMDAwXSBJbml0aWFsaXppbmcgY2dyb3VwIHN1YnN5cyBjcHUNClsgICAgMC4wMDAwMDBdIExp bnV4IHZlcnNpb24gMy40LjEyLTFhbGxkZWJ1Z25vcHZ1c2IucHZvcHMucXViZXMueDg2XzY0ICh1 c2VyQHFkdnApIChnY2MgdmVyc2lvbiA0LjcuMiAyMDEyMDkyMSAoUmVkIEhhdCA0LjcuMi0yKSAo R0NDKSApICMxIFNNUCBTdW4gTm92IDExIDExOjU0OjEwIENFVCAyMDEyDQpbICAgIDAuMDAwMDAw XSBDb21tYW5kIGxpbmU6IHJvb3Q9L2Rldi9tYXBwZXIvZG1yb290IHJvIG5vbW9kZXNldCBjb25z b2xlPWh2YzAgcmRfTk9fUExZTU9VVEggMyANClsgICAgMC4wMDAwMDBdIEFDUEkgaW4gdW5wcml2 aWxlZ2VkIGRvbWFpbiBkaXNhYmxlZA0KWyAgICAwLjAwMDAwMF0gUmVsZWFzZWQgMCBwYWdlcyBv ZiB1bnVzZWQgbWVtb3J5DQpbICAgIDAuMDAwMDAwXSBTZXQgMCBwYWdlKHMpIHRvIDEtMSBtYXBw aW5nDQpbICAgIDAuMDAwMDAwXSBCSU9TLXByb3ZpZGVkIHBoeXNpY2FsIFJBTSBtYXA6DQpbICAg IDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMDAwMDAwMDAwIC0gMDAwMDAwMDAwMDBhMDAwMCAodXNh YmxlKQ0KWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDAwMDBhMDAwMCAtIDAwMDAwMDAwMDAx MDAwMDAgKHJlc2VydmVkKQ0KWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDAwMDEwMDAwMCAt IDAwMDAwMDAwZmU2MDAwMDAgKHVzYWJsZSkNClsgICAgMC4wMDAwMDBdIE5YIChFeGVjdXRlIERp c2FibGUpIHByb3RlY3Rpb246IGFjdGl2ZQ0KWyAgICAwLjAwMDAwMF0gRE1JIG5vdCBwcmVzZW50 IG9yIGludmFsaWQuDQpbICAgIDAuMDAwMDAwXSBObyBBR1AgYnJpZGdlIGZvdW5kDQpbICAgIDAu MDAwMDAwXSBsYXN0X3BmbiA9IDB4ZmU2MDAgbWF4X2FyY2hfcGZuID0gMHg0MDAwMDAwMDANClsg ICAgMC4wMDAwMDBdIGluaXRfbWVtb3J5X21hcHBpbmc6IDAwMDAwMDAwMDAwMDAwMDAtMDAwMDAw MDBmZTYwMDAwMA0KWyAgICAwLjAwMDAwMF0gUkFNRElTSzogMDFlMjMwMDAgLSAwMzk1MDAwMA0K WyAgICAwLjAwMDAwMF0gWm9uZSBQRk4gcmFuZ2VzOg0KWyAgICAwLjAwMDAwMF0gICBETUEgICAg ICAweDAwMDAwMDEwIC0+IDB4MDAwMDEwMDANClsgICAgMC4wMDAwMDBdICAgRE1BMzIgICAgMHgw MDAwMTAwMCAtPiAweDAwMTAwMDAwDQpbICAgIDAuMDAwMDAwXSAgIE5vcm1hbCAgIGVtcHR5DQpb ICAgIDAuMDAwMDAwXSBNb3ZhYmxlIHpvbmUgc3RhcnQgUEZOIGZvciBlYWNoIG5vZGUNClsgICAg MC4wMDAwMDBdIEVhcmx5IG1lbW9yeSBQRk4gcmFuZ2VzDQpbICAgIDAuMDAwMDAwXSAgICAgMDog MHgwMDAwMDAxMCAtPiAweDAwMDAwMGEwDQpbICAgIDAuMDAwMDAwXSAgICAgMDogMHgwMDAwMDEw MCAtPiAweDAwMGZlNjAwDQpbICAgIDAuMDAwMDAwXSBTRkk6IFNpbXBsZSBGaXJtd2FyZSBJbnRl cmZhY2UgdjAuODEgaHR0cDovL3NpbXBsZWZpcm13YXJlLm9yZw0KWyAgICAwLjAwMDAwMF0gU01Q OiBBbGxvd2luZyA4IENQVXMsIDAgaG90cGx1ZyBDUFVzDQpbICAgIDAuMDAwMDAwXSBObyBsb2Nh bCBBUElDIHByZXNlbnQNClsgICAgMC4wMDAwMDBdIEFQSUM6IGRpc2FibGUgYXBpYyBmYWNpbGl0 eQ0KWyAgICAwLjAwMDAwMF0gQVBJQzogc3dpdGNoZWQgdG8gYXBpYyBOT09QDQpbICAgIDAuMDAw MDAwXSBBbGxvY2F0aW5nIFBDSSByZXNvdXJjZXMgc3RhcnRpbmcgYXQgZmU2MDAwMDAgKGdhcDog ZmU2MDAwMDA6MWEwMDAwMCkNClsgICAgMC4wMDAwMDBdIEJvb3RpbmcgcGFyYXZpcnR1YWxpemVk IGtlcm5lbCBvbiBYZW4NClsgICAgMC4wMDAwMDBdIFhlbiB2ZXJzaW9uOiA0LjEuMiAocHJlc2Vy dmUtQUQpDQpbICAgIDAuMDAwMDAwXSBzZXR1cF9wZXJjcHU6IE5SX0NQVVM6NTEyIG5yX2NwdW1h c2tfYml0czo1MTIgbnJfY3B1X2lkczo4IG5yX25vZGVfaWRzOjENClsgICAgMC4wMDAwMDBdIFBF UkNQVTogRW1iZWRkZWQgMjggcGFnZXMvY3B1IEBmZmZmODgwMDE4YzAwMDAwIHM4MjMwNCByODE5 MiBkMjQxOTIgdTI2MjE0NA0KWyAgICAwLjAwMDAwMF0gQnVpbHQgMSB6b25lbGlzdHMgaW4gWm9u ZSBvcmRlciwgbW9iaWxpdHkgZ3JvdXBpbmcgb24uICBUb3RhbCBwYWdlczogMTAyMzUxOQ0KWyAg ICAwLjAwMDAwMF0gS2VybmVsIGNvbW1hbmQgbGluZTogcm9vdD0vZGV2L21hcHBlci9kbXJvb3Qg cm8gbm9tb2Rlc2V0IGNvbnNvbGU9aHZjMCByZF9OT19QTFlNT1VUSCAzIA0KWyAgICAwLjAwMDAw MF0gUElEIGhhc2ggdGFibGUgZW50cmllczogNDA5NiAob3JkZXI6IDMsIDMyNzY4IGJ5dGVzKQ0K WyAgICAwLjAwMDAwMF0gRGVudHJ5IGNhY2hlIGhhc2ggdGFibGUgZW50cmllczogNTI0Mjg4IChv cmRlcjogMTAsIDQxOTQzMDQgYnl0ZXMpDQpbICAgIDAuMDAwMDAwXSBJbm9kZS1jYWNoZSBoYXNo IHRhYmxlIGVudHJpZXM6IDI2MjE0NCAob3JkZXI6IDksIDIwOTcxNTIgYnl0ZXMpDQpbICAgIDAu MDAwMDAwXSBDaGVja2luZyBhcGVydHVyZS4uLg0KWyAgICAwLjAwMDAwMF0gTm8gQUdQIGJyaWRn ZSBmb3VuZA0KWyAgICAwLjAwMDAwMF0gTWVtb3J5OiAyODkwNDhrLzQxNjc2ODBrIGF2YWlsYWJs ZSAoNDQ5N2sga2VybmVsIGNvZGUsIDQ0OGsgYWJzZW50LCAzODc4MTg0ayByZXNlcnZlZCwgNDE3 MmsgZGF0YSwgNjE2ayBpbml0KQ0KWyAgICAwLjAwMDAwMF0gSGllcmFyY2hpY2FsIFJDVSBpbXBs ZW1lbnRhdGlvbi4NClsgICAgMC4wMDAwMDBdIAlSQ1UgZHludGljay1pZGxlIGdyYWNlLXBlcmlv ZCBhY2NlbGVyYXRpb24gaXMgZW5hYmxlZC4NClsgICAgMC4wMDAwMDBdIE5SX0lSUVM6MzMwMjQg bnJfaXJxczozMzYgMTYNClsgICAgMC4wMDAwMDBdIGttZW1sZWFrOiBLZXJuZWwgbWVtb3J5IGxl YWsgZGV0ZWN0b3IgZGlzYWJsZWQNClsgICAgMC4wMDAwMDBdIENvbnNvbGU6IGNvbG91ciBkdW1t eSBkZXZpY2UgODB4MjUNClsgICAgMC4wMDAwMDBdIGNvbnNvbGUgW3R0eTBdIGVuYWJsZWQNClsg ICAgMC4wMDAwMDBdIGNvbnNvbGUgW2h2YzBdIGVuYWJsZWQNClsgICAgMC4wMDAwMDBdIGttZW1s ZWFrOiBFYXJseSBsb2cgYnVmZmVyIGV4Y2VlZGVkICg2NTYpLCBwbGVhc2UgaW5jcmVhc2UgREVC VUdfS01FTUxFQUtfRUFSTFlfTE9HX1NJWkUNClsgICAgMC4wMDAwMDBdIGluc3RhbGxpbmcgWGVu IHRpbWVyIGZvciBDUFUgMA0KWyAgICAwLjAwMDAwMF0gRGV0ZWN0ZWQgMTcyOS4wNTQgTUh6IHBy b2Nlc3Nvci4NClsgICAgMC4wMDQwMDBdIENhbGlicmF0aW5nIGRlbGF5IGxvb3AgKHNraXBwZWQp LCB2YWx1ZSBjYWxjdWxhdGVkIHVzaW5nIHRpbWVyIGZyZXF1ZW5jeS4uIDM0NTguMTAgQm9nb01J UFMgKGxwaj02OTE2MjE2KQ0KWyAgICAwLjAwNDAwMF0gcGlkX21heDogZGVmYXVsdDogMzI3Njgg bWluaW11bTogMzAxDQpbICAgIDAuMDA0MDAwXSBNb3VudC1jYWNoZSBoYXNoIHRhYmxlIGVudHJp ZXM6IDI1Ng0KWyAgICAwLjAwNDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgY3B1YWNj dA0KWyAgICAwLjAwNDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgZGV2aWNlcw0KWyAg ICAwLjAwNDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgZnJlZXplcg0KWyAgICAwLjAw NDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgbmV0X2Nscw0KWyAgICAwLjAwNDAwMF0g SW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgYmxraW8NClsgICAgMC4wMDQwMDBdIENQVTogUGh5 c2ljYWwgUHJvY2Vzc29yIElEOiAwDQpbICAgIDAuMDA0MDAwXSBDUFU6IFByb2Nlc3NvciBDb3Jl IElEOiAwDQpbICAgIDAuMDA0MDAwXSBTTVAgYWx0ZXJuYXRpdmVzOiBzd2l0Y2hpbmcgdG8gVVAg Y29kZQ0KWyAgICAwLjA1MjgxN10gUGVyZm9ybWFuY2UgRXZlbnRzOiB1bnN1cHBvcnRlZCBwNiBD UFUgbW9kZWwgMzAgbm8gUE1VIGRyaXZlciwgc29mdHdhcmUgZXZlbnRzIG9ubHkuDQpbICAgIDAu MDU0NTAwXSBOTUkgd2F0Y2hkb2c6IGRpc2FibGVkIChjcHUwKTogaGFyZHdhcmUgZXZlbnRzIG5v dCBlbmFibGVkDQpbICAgIDAuMDU2OTI2XSBpbnN0YWxsaW5nIFhlbiB0aW1lciBmb3IgQ1BVIDEN ClsgICAgMC4wNTcwNDldIFNNUCBhbHRlcm5hdGl2ZXM6IHN3aXRjaGluZyB0byBTTVAgY29kZQ0K WyAgICAwLjEyMDg0MF0gTk1JIHdhdGNoZG9nOiBkaXNhYmxlZCAoY3B1MSk6IGhhcmR3YXJlIGV2 ZW50cyBub3QgZW5hYmxlZA0KWyAgICAwLjEyNDIyN10gaW5zdGFsbGluZyBYZW4gdGltZXIgZm9y IENQVSAyDQpbICAgIDAuMTI0NzI5XSBOTUkgd2F0Y2hkb2c6IGRpc2FibGVkIChjcHUyKTogaGFy ZHdhcmUgZXZlbnRzIG5vdCBlbmFibGVkDQpbICAgIDAuMTI3OTEwXSBpbnN0YWxsaW5nIFhlbiB0 aW1lciBmb3IgQ1BVIDMNClsgICAgMC4xMjg0NzddIE5NSSB3YXRjaGRvZzogZGlzYWJsZWQgKGNw dTMpOiBoYXJkd2FyZSBldmVudHMgbm90IGVuYWJsZWQNClsgICAgMC4xMzA5NTldIGluc3RhbGxp bmcgWGVuIHRpbWVyIGZvciBDUFUgNA0KWyAgICAwLjEzMTMwOV0gTk1JIHdhdGNoZG9nOiBkaXNh YmxlZCAoY3B1NCk6IGhhcmR3YXJlIGV2ZW50cyBub3QgZW5hYmxlZA0KWyAgICAwLjEzNDUwMl0g aW5zdGFsbGluZyBYZW4gdGltZXIgZm9yIENQVSA1DQpbICAgIDAuMTM1MTE1XSBOTUkgd2F0Y2hk b2c6IGRpc2FibGVkIChjcHU1KTogaGFyZHdhcmUgZXZlbnRzIG5vdCBlbmFibGVkDQpbICAgIDAu MTM4MDQ3XSBpbnN0YWxsaW5nIFhlbiB0aW1lciBmb3IgQ1BVIDYNClsgICAgMC4xMzg1OTJdIE5N SSB3YXRjaGRvZzogZGlzYWJsZWQgKGNwdTYpOiBoYXJkd2FyZSBldmVudHMgbm90IGVuYWJsZWQN ClsgICAgMC4xNDExMjddIGluc3RhbGxpbmcgWGVuIHRpbWVyIGZvciBDUFUgNw0KWyAgICAwLjE0 MTczNl0gTk1JIHdhdGNoZG9nOiBkaXNhYmxlZCAoY3B1Nyk6IGhhcmR3YXJlIGV2ZW50cyBub3Qg ZW5hYmxlZA0KWyAgICAwLjE0MTk0MF0gQnJvdWdodCB1cCA4IENQVXMNClsgICAgMC4xNDQ1NDVd IGRldnRtcGZzOiBpbml0aWFsaXplZA0KWyAgICAwLjE1NDExMl0gR3JhbnQgdGFibGVzIHVzaW5n IHZlcnNpb24gMiBsYXlvdXQuDQpbICAgIDAuMTU0MTEyXSBHcmFudCB0YWJsZSBpbml0aWFsaXpl ZA0KWyAgICAwLjE1NDExMl0gZHVtbXk6IA0KWyAgICAwLjE3NDgzOV0gUlRDIHRpbWU6IDE2NTox NjU6MTY1LCBkYXRlOiAxNjUvMTY1LzY1DQpbICAgIDAuMTc1NjYzXSBORVQ6IFJlZ2lzdGVyZWQg cHJvdG9jb2wgZmFtaWx5IDE2DQpbICAgIDAuMTc2NTgwXSBQQ0k6IHNldHRpbmcgdXAgWGVuIFBD SSBmcm9udGVuZCBzdHViDQpbICAgIDAuMTgxMzQ5XSBiaW86IGNyZWF0ZSBzbGFiIDxiaW8tMD4g YXQgMA0KWyAgICAwLjE4NDA2N10gQUNQSTogSW50ZXJwcmV0ZXIgZGlzYWJsZWQuDQpbICAgIDAu MTg0MDkzXSB4ZW4vYmFsbG9vbjogSW5pdGlhbGlzaW5nIGJhbGxvb24gZHJpdmVyLg0KWyAgICAw LjIwMTEwN10geGVuLWJhbGxvb246IEluaXRpYWxpc2luZyBiYWxsb29uIGRyaXZlci4NClsgICAg MC4yMDQwNjddIHZnYWFyYjogbG9hZGVkDQpbICAgIDAuMjA0NTE3XSBQQ0k6IFN5c3RlbSBkb2Vz IG5vdCBzdXBwb3J0IFBDSQ0KWyAgICAwLjIwNDUxN10gUENJOiBTeXN0ZW0gZG9lcyBub3Qgc3Vw cG9ydCBQQ0kNClsgICAgMC4yMDQ2MTFdIFN3aXRjaGluZyB0byBjbG9ja3NvdXJjZSB4ZW4NClsg ICAgMC4yNTIxMzVdIHBucDogUG5QIEFDUEk6IGRpc2FibGVkDQpbICAgIDAuMjczMTY2XSBORVQ6 IFJlZ2lzdGVyZWQgcHJvdG9jb2wgZmFtaWx5IDINClsgICAgMC4yNzQwNzhdIElQIHJvdXRlIGNh Y2hlIGhhc2ggdGFibGUgZW50cmllczogMzI3NjggKG9yZGVyOiA2LCAyNjIxNDQgYnl0ZXMpDQpb ICAgIDAuMjc4MDMzXSBUQ1AgZXN0YWJsaXNoZWQgaGFzaCB0YWJsZSBlbnRyaWVzOiAxMzEwNzIg KG9yZGVyOiA5LCAyMDk3MTUyIGJ5dGVzKQ0KWyAgICAwLjI4MDQ5M10gVENQIGJpbmQgaGFzaCB0 YWJsZSBlbnRyaWVzOiA2NTUzNiAob3JkZXI6IDgsIDEwNDg1NzYgYnl0ZXMpDQpbICAgIDAuMjgx MzEyXSBUQ1A6IEhhc2ggdGFibGVzIGNvbmZpZ3VyZWQgKGVzdGFibGlzaGVkIDEzMTA3MiBiaW5k IDY1NTM2KQ0KWyAgICAwLjI4MTMyOF0gVENQOiByZW5vIHJlZ2lzdGVyZWQNClsgICAgMC4yODEz ODddIFVEUCBoYXNoIHRhYmxlIGVudHJpZXM6IDIwNDggKG9yZGVyOiA0LCA2NTUzNiBieXRlcykN ClsgICAgMC4yODE1MTVdIFVEUC1MaXRlIGhhc2ggdGFibGUgZW50cmllczogMjA0OCAob3JkZXI6 IDQsIDY1NTM2IGJ5dGVzKQ0KWyAgICAwLjI4Mzk0MF0gTkVUOiBSZWdpc3RlcmVkIHByb3RvY29s IGZhbWlseSAxDQpbICAgIDAuMjg0NzIzXSBVbnBhY2tpbmcgaW5pdHJhbWZzLi4uDQpbICAgIDAu NDMzOTgwXSBkZWJ1ZzogdW5tYXBwaW5nIGluaXQgbWVtb3J5IGZmZmY4ODAwMDFlMjMwMDAuLmZm ZmY4ODAwMDM5NTAwMDANClsgICAgMC40NDAxMTVdIHBsYXRmb3JtIHJ0Y19jbW9zOiByZWdpc3Rl cmVkIHBsYXRmb3JtIFJUQyBkZXZpY2UgKG5vIFBOUCBkZXZpY2UgZm91bmQpDQpbICAgIDAuNDQ4 NTYzXSBhdWRpdDogaW5pdGlhbGl6aW5nIG5ldGxpbmsgc29ja2V0IChkaXNhYmxlZCkNClsgICAg MC40NDg2ODhdIHR5cGU9MjAwMCBhdWRpdCgxMzUyNjM3NDI0LjM5NToxKTogaW5pdGlhbGl6ZWQN ClsgICAgMC40OTAxOTNdIFZGUzogRGlzayBxdW90YXMgZHF1b3RfNi41LjINClsgICAgMC40OTA0 NzldIERxdW90LWNhY2hlIGhhc2ggdGFibGUgZW50cmllczogNTEyIChvcmRlciAwLCA0MDk2IGJ5 dGVzKQ0KWyAgICAwLjQ5MjA4N10gbXNnbW5pIGhhcyBiZWVuIHNldCB0byA1NjQNClsgICAgMC40 OTMwMDldIEJsb2NrIGxheWVyIFNDU0kgZ2VuZXJpYyAoYnNnKSBkcml2ZXIgdmVyc2lvbiAwLjQg bG9hZGVkIChtYWpvciAyNTMpDQpbICAgIDAuNDkzMDIxXSBpbyBzY2hlZHVsZXIgbm9vcCByZWdp c3RlcmVkDQpbICAgIDAuNDkzMDI1XSBpbyBzY2hlZHVsZXIgZGVhZGxpbmUgcmVnaXN0ZXJlZA0K WyAgICAwLjQ5MzI2Ml0gaW8gc2NoZWR1bGVyIGNmcSByZWdpc3RlcmVkIChkZWZhdWx0KQ0KWyAg ICAwLjUwMDQ0OF0gcGNpZnJvbnQgcGNpLTA6IEluc3RhbGxpbmcgUENJIGZyb250ZW5kDQpbICAg IDAuNTAwODIxXSBwY2lmcm9udCBwY2ktMDogQ3JlYXRpbmcgUENJIEZyb250ZW5kIEJ1cyAwMDAw OjAwDQpbICAgIDAuNTAxMTA2XSBwY2lmcm9udCBwY2ktMDogUENJIGhvc3QgYnJpZGdlIHRvIGJ1 cyAwMDAwOjAwDQpbICAgIDAuNTAxMTI2XSBwY2lfYnVzIDAwMDA6MDA6IHJvb3QgYnVzIHJlc291 cmNlIFtpbyAgMHgwMDAwLTB4ZmZmZl0NClsgICAgMC41MDExMzldIHBjaV9idXMgMDAwMDowMDog cm9vdCBidXMgcmVzb3VyY2UgW21lbSAweDAwMDAwMDAwLTB4ZmZmZmZmZmZmXQ0KWyAgICAwLjUw MTk3MV0gTm9uLXZvbGF0aWxlIG1lbW9yeSBkcml2ZXIgdjEuMw0KWyAgICAwLjUwMjA5NF0gcmFt b29wczogcGxhdGZvcm0gZGV2aWNlIG5vdCBmb3VuZCwgdXNpbmcgbW9kdWxlIHBhcmFtZXRlcnMN ClsgICAgMC41MDIzMTddIHJhbW9vcHM6IFRoZSBtZW1vcnkgc2l6ZSBhbmQgdGhlIHJlY29yZCBz aXplIG11c3QgYmUgbm9uLXplcm8NClsgICAgMC41MDIzNDVdIHJhbW9vcHM6IHByb2JlIG9mIHJh bW9vcHMgZmFpbGVkIHdpdGggZXJyb3IgLTIyDQpbICAgIDAuNTA2ODQwXSBsb29wOiBtb2R1bGUg bG9hZGVkDQpbICAgIDAuNTA2OTcxXSBGaXhlZCBNRElPIEJ1czogcHJvYmVkDQpbICAgIDAuNTA3 MDg1XSBpODA0MjogUE5QOiBObyBQUy8yIGNvbnRyb2xsZXIgZm91bmQuIFByb2JpbmcgcG9ydHMg ZGlyZWN0bHkuDQpbICAgIDAuNTA3OTEwXSBpODA0MjogTm8gY29udHJvbGxlciBmb3VuZA0KWyAg ICAwLjUwODE4NV0gbW91c2VkZXY6IFBTLzIgbW91c2UgZGV2aWNlIGNvbW1vbiBmb3IgYWxsIG1p Y2UNClsgICAgMC41Njg0NTZdIHJ0Y19jbW9zIHJ0Y19jbW9zOiBydGMgY29yZTogcmVnaXN0ZXJl ZCBydGNfY21vcyBhcyBydGMwDQpbICAgIDAuNTY4NjIzXSBydGNfY21vczogcHJvYmUgb2YgcnRj X2Ntb3MgZmFpbGVkIHdpdGggZXJyb3IgLTM4DQpbICAgIDAuNTY5NzQxXSBkZXZpY2UtbWFwcGVy OiB1ZXZlbnQ6IHZlcnNpb24gMS4wLjMNClsgICAgMC41NzAzNzRdIGRldmljZS1tYXBwZXI6IGlv Y3RsOiA0LjIyLjAtaW9jdGwgKDIwMTEtMTAtMTkpIGluaXRpYWxpc2VkOiBkbS1kZXZlbEByZWRo YXQuY29tDQpbICAgIDAuNTcwNzg3XSBUQ1A6IGN1YmljIHJlZ2lzdGVyZWQNClsgICAgMC41NzE3 OTldIE5FVDogUmVnaXN0ZXJlZCBwcm90b2NvbCBmYW1pbHkgMTANClsgICAgMC41NzMzNjBdIFJl Z2lzdGVyaW5nIHRoZSBkbnNfcmVzb2x2ZXIga2V5IHR5cGUNClsgICAgMC41NzQxODVdIHJlZ2lz dGVyZWQgdGFza3N0YXRzIHZlcnNpb24gMQ0KWyAgICAwLjU3NDIyN10gWEVOQlVTOiBEZXZpY2Ug d2l0aCBubyBkcml2ZXI6IGRldmljZS92YmQvNTE3MTINClsgICAgMC41NzQyMzNdIFhFTkJVUzog RGV2aWNlIHdpdGggbm8gZHJpdmVyOiBkZXZpY2UvdmJkLzUxNzI4DQpbICAgIDAuNTc0MjM4XSBY RU5CVVM6IERldmljZSB3aXRoIG5vIGRyaXZlcjogZGV2aWNlL3ZiZC81MTc0NA0KWyAgICAwLjU3 NDI0M10gWEVOQlVTOiBEZXZpY2Ugd2l0aCBubyBkcml2ZXI6IGRldmljZS92YmQvNTE3NjANClsg ICAgMC41NzQyNDddIFhFTkJVUzogRGV2aWNlIHdpdGggbm8gZHJpdmVyOiBkZXZpY2UvdmlmLzAN ClsgICAgMC41NzQ1NDFdICAgTWFnaWMgbnVtYmVyOiAxOjI1MjozMTQxDQpbICAgIDAuNTc0NjA0 XSAvcncvaG9tZS91c2VyL3F1YmVzL3F1YmVzLWJ1aWxkZXIvcXViZXMtc3JjL2tlcm5lbC9rZXJu ZWwtMy40LjEyL2xpbnV4LTMuNC4xMi9kcml2ZXJzL3J0Yy9oY3Rvc3lzLmM6IHVuYWJsZSB0byBv cGVuIHJ0YyBkZXZpY2UgKHJ0YzApDQpbICAgIDAuNTc1MjIxXSBkZWJ1ZzogdW5tYXBwaW5nIGlu aXQgbWVtb3J5IGZmZmZmZmZmODE4NzkwMDAuLmZmZmZmZmZmODE5MTMwMDANClsgICAgMC41NzU0 NzRdIFdyaXRlIHByb3RlY3RpbmcgdGhlIGtlcm5lbCByZWFkLW9ubHkgZGF0YTogODE5MmsNClsg ICAgMC41NzkyMjZdIGRlYnVnOiB1bm1hcHBpbmcgaW5pdCBtZW1vcnkgZmZmZjg4MDAwMTQ2OTAw MC4uZmZmZjg4MDAwMTYwMDAwMA0KWyAgICAwLjU3OTgyNV0gZGVidWc6IHVubWFwcGluZyBpbml0 IG1lbW9yeSBmZmZmODgwMDAxN2ZjMDAwLi5mZmZmODgwMDAxODAwMDAwDQpbICAgIDAuNjAxNjY2 XSBCVUc6IHVuYWJsZSB0byBoYW5kbGUga2VybmVsIHBhZ2luZyByZXF1ZXN0IGF0IGZmZmY4ODAw MGY2NmQwMDANClsgICAgMC42MDE2NzhdIElQOiBbPGZmZmZmZmZmODExMDljNjQ+XSBfX3RsYl9y ZW1vdmVfcGFnZSsweDg0LzB4YjANClsgICAgMC42MDE2ODldIFBHRCAxODBjMDY3IFBVRCAxODEw MDY3IFBNRCA4NjEwNjcgUFRFIDgwMTAwMDAwMGY2NmQwNjQNClsgICAgMC42MDE2OThdIE9vcHM6 IDAwMDIgWyMxXSBTTVAgREVCVUdfUEFHRUFMTE9DDQpbICAgIDAuNjAxNzA1XSBDUFUgNSANClsg ICAgMC42MDE3MDhdIE1vZHVsZXMgbGlua2VkIGluOg0KWyAgICAwLjYwMTcxM10gDQpbICAgIDAu NjAxNzE3XSBQaWQ6IDYwLCBjb21tOiBpbml0IE5vdCB0YWludGVkIDMuNC4xMi0xYWxsZGVidWdu b3B2dXNiLnB2b3BzLnF1YmVzLng4Nl82NCAjMSAgDQpbICAgIDAuNjAxNzI2XSBSSVA6IGUwMzA6 WzxmZmZmZmZmZjgxMTA5YzY0Pl0gIFs8ZmZmZmZmZmY4MTEwOWM2ND5dIF9fdGxiX3JlbW92ZV9w YWdlKzB4ODQvMHhiMA0KWyAgICAwLjYwMTczNl0gUlNQOiBlMDJiOmZmZmY4ODAwMGY2NDVhNzgg IEVGTEFHUzogMDAwMTAyODYNClsgICAgMC42MDE3NDFdIFJBWDogZmZmZjg4MDAwZjY2ZDAwMCBS Qlg6IGZmZmY4ODAwMGY2NDVjMzAgUkNYOiAwMDAwMDAwMDAwMDAwMDAwDQpbICAgIDAuNjAxNzQ3 XSBSRFg6IGZmZmY4ODAwMGY2NmQwMDAgUlNJOiAwMDAwMDAwMDAwMDAwMDEwIFJESTogMDAwMDAw MDAwMDAwMDIwMA0KWyAgICAwLjYwMTc1NF0gUkJQOiBmZmZmODgwMDBmNjQ1YTg4IFIwODogMDAw MDAwMDAwMDAwMDAwMCBSMDk6IGZmZmY4ODAwMDAwMDAwMDANClsgICAgMC42MDE3NjBdIFIxMDog MDAwMDAwMDAwMDAwMDAwMSBSMTE6IDAwMDAwMDAwNTgxYzYyMDQgUjEyOiBmZmZmODgwMDBmNjJl YzY4DQpbICAgIDAuNjAxNzY2XSBSMTM6IDAwMDAwMDAxOTNlNDkxMjUgUjE0OiBmZmZmODgwMDBm NWUzMTUwIFIxNTogMDAwMDAwMDAwMDQyYTAwMA0KWyAgICAwLjYwMTc3N10gRlM6ICAwMDAwN2Zk YTQ4YzdiNzQwKDAwMDApIEdTOmZmZmY4ODAwMThkNDAwMDAoMDAwMCkga25sR1M6MDAwMDAwMDAw MDAwMDAwMA0KWyAgICAwLjYwMTc4NF0gQ1M6ICBlMDMzIERTOiAwMDAwIEVTOiAwMDAwIENSMDog MDAwMDAwMDA4MDA1MDAzYg0KWyAgICAwLjYwNTE4OF0gQ1IyOiBmZmZmODgwMDBmNjZkMDAwIENS MzogMDAwMDAwMDAwZjY2NTAwMCBDUjQ6IDAwMDAwMDAwMDAwMDI2NjANClsgICAgMC42MDUxODhd IERSMDogMDAwMDAwMDAwMDAwMDAwMCBEUjE6IDAwMDAwMDAwMDAwMDAwMDAgRFIyOiAwMDAwMDAw MDAwMDAwMDAwDQpbICAgIDAuNjA1MTg4XSBEUjM6IDAwMDAwMDAwMDAwMDAwMDAgRFI2OiAwMDAw MDAwMGZmZmYwZmYwIERSNzogMDAwMDAwMDAwMDAwMDQwMA0KWyAgICAwLjYwNTE4OF0gUHJvY2Vz cyBpbml0IChwaWQ6IDYwLCB0aHJlYWRpbmZvIGZmZmY4ODAwMGY2NDQwMDAsIHRhc2sgZmZmZjg4 MDAwZjY0MjdjMCkNClsgICAgMC42MDUxODhdIFN0YWNrOg0KWyAgICAwLjYwNTE4OF0gIGZmZmZl YTAwMDAzZDc4YzAgZmZmZmVhMDAwMDQ4YTY4MCBmZmZmODgwMDBmNjQ1Yjc4IGZmZmZmZmZmODEx MGIxZDgNClsgICAgMC42MDUxODhdICAwMDAwMDAwMDk2NThjY2M1IDAwMDAwMDAwMDAwMDAxMDAg MDAwMDAwMDAwMDAwMDAwMCAwMDAwMDAwMDAwMDAwMWZmDQpbICAgIDAuNjA1MTg4XSAgMDAwMDAw MDAwMDRkOWZmZiAwMDAwMDAwMDAwNGRhMDAwIDAwMDAwMDAwMDA0ZDlmZmYgZmZmZjg4MDAwZjYy ZjAwMA0KWyAgICAwLjYwNTE4OF0gQ2FsbCBUcmFjZToNClsgICAgMC42MDUxODhdICBbPGZmZmZm ZmZmODExMGIxZDg+XSB1bm1hcF9wYWdlX3JhbmdlKzB4NGE4LzB4NzMwDQpbICAgIDAuNjA1MTg4 XSAgWzxmZmZmZmZmZjgxMTBiNGMzPl0gdW5tYXBfc2luZ2xlX3ZtYSsweDYzLzB4YjANClsgICAg MC42MDUxODhdICBbPGZmZmZmZmZmODEwZjUyYjA+XSA/IHB1dF9wYWdlc19saXN0KzB4MzAvMHgz MA0KWyAgICAwLjYwNTE4OF0gIFs8ZmZmZmZmZmY4MTEwYmNkZT5dIHVubWFwX3ZtYXMrMHg1ZS8w eGIwDQpbICAgIDAuNjA1MTg4XSAgWzxmZmZmZmZmZjgxMTEzMWM3Pl0gZXhpdF9tbWFwKzB4OTcv MHgxNDANClsgICAgMC42MDUxODhdICBbPGZmZmZmZmZmODEwNDQ1YzM+XSBtbXB1dCsweDczLzB4 ZjANClsgICAgMC42MDUxODhdICBbPGZmZmZmZmZmODExMzk2YWQ+XSBmbHVzaF9vbGRfZXhlYysw eDNlZC8weDcyMA0KWyAgICAwLjYwNTE4OF0gIFs8ZmZmZmZmZmY4MTE3ZjhiZT5dIGxvYWRfZWxm X2JpbmFyeSsweDMxZS8weDE4NDANClsgICAgMC42MDUxODhdICBbPGZmZmZmZmZmODExN2Y1YTA+ XSA/IGxvYWRfZWxmX2xpYnJhcnkrMHgyMDAvMHgyMDANClsgICAgMC42MDUxODhdICBbPGZmZmZm ZmZmODExMzhkYzc+XSBzZWFyY2hfYmluYXJ5X2hhbmRsZXIrMHhlNy8weDJmMA0KWyAgICAwLjYw NTE4OF0gIFs8ZmZmZmZmZmY4MTEzYTI5Mz5dIGRvX2V4ZWN2ZV9jb21tb24uaXNyYS4zMisweDNl My8weDRiMA0KWyAgICAwLjYwNTE4OF0gIFs8ZmZmZmZmZmY4MTEzYTM3Nj5dIGRvX2V4ZWN2ZSsw eDE2LzB4MjANClsgICAgMC42MDUxODhdICBbPGZmZmZmZmZmODEwMWFkNTI+XSBzeXNfZXhlY3Zl KzB4NDIvMHg3MA0KWyAgICAwLjYwNTE4OF0gIFs8ZmZmZmZmZmY4MTQ2MGMzYz5dIHN0dWJfZXhl Y3ZlKzB4NmMvMHhjMA0KWyAgICAwLjYwNTE4OF0gQ29kZTogOGIgNDcgMTAgNDggOGIgMTAgNDgg ODUgZDIgNzQgMGMgNDggODkgNTMgMTAgOGIgNDIgMGMgOGIgNTIgMDggZWIgYmQgMzEgZjYgYmYg MDAgMDIgMDAgMDAgZTggZDQgODcgZmUgZmYgNDggODUgYzAgNDggODkgYzIgNzQgMWUgPDQ4PiBj NyAwMCAwMCAwMCAwMCAwMCBjNyA0MCAwOCAwMCAwMCAwMCAwMCBjNyA0MCAwYyBmZSAwMSAwMCAw MCANClsgICAgMC42MDUxODhdIFJJUCAgWzxmZmZmZmZmZjgxMTA5YzY0Pl0gX190bGJfcmVtb3Zl X3BhZ2UrMHg4NC8weGIwDQpbICAgIDAuNjA1MTg4XSAgUlNQIDxmZmZmODgwMDBmNjQ1YTc4Pg0K WyAgICAwLjYwNTE4OF0gQ1IyOiBmZmZmODgwMDBmNjZkMDAwDQpbICAgIDAuNjA1MTg4XSAtLS1b IGVuZCB0cmFjZSA1NTVlODQ1NmNmZGQzOTk5IF0tLS0NClsgICAgMC42MzQ0MjddIC0tLS0tLS0t LS0tLVsgY3V0IGhlcmUgXS0tLS0tLS0tLS0tLQ0KWyAgICAwLjYzNDQzNV0ga2VybmVsIEJVRyBh dCAvcncvaG9tZS91c2VyL3F1YmVzL3F1YmVzLWJ1aWxkZXIvcXViZXMtc3JjL2tlcm5lbC9rZXJu ZWwtMy40LjEyL2xpbnV4LTMuNC4xMi9hcmNoL3g4Ni9rZXJuZWwvcGFyYXZpcnQuYzoyNDQhDQpb ICAgIDAuNjM0NDQ1XSBpbnZhbGlkIG9wY29kZTogMDAwMCBbIzJdIFNNUCBERUJVR19QQUdFQUxM T0MNClsgICAgMC42MzQ0NTFdIENQVSA1IA0KWyAgICAwLjYzNDQ1M10gTW9kdWxlcyBsaW5rZWQg aW46DQpbICAgIDAuNjM0NDU4XSANClsgICAgMC42MzQ0NjJdIFBpZDogNjAsIGNvbW06IGluaXQg VGFpbnRlZDogRyAgICAgIEQgICAgICAzLjQuMTItMWFsbGRlYnVnbm9wdnVzYi5wdm9wcy5xdWJl cy54ODZfNjQgIzEgIA0KWyAgICAwLjYzNDQ3Ml0gUklQOiBlMDMwOls8ZmZmZmZmZmY4MTQ0ZjNi Nz5dICBbPGZmZmZmZmZmODE0NGYzYjc+XSBlbnRlcl9sYXp5LnBhcnQuNCsweDQvMHg2DQpbICAg IDAuNjM0NDgzXSBSU1A6IGUwMmI6ZmZmZjg4MDAwZjY0NTQ4OCAgRUZMQUdTOiAwMDAxMDIwMg0K WyAgICAwLjYzNDQ4OV0gUkFYOiAwMDAwMDAwMDAwMDAwMDAxIFJCWDogZmZmZjg4MDAwZjY2NGM2 OCBSQ1g6IDAwMDAzZmZmZmZmZmYwMDANClsgICAgMC42MzQ0OTZdIFJEWDogMDAwMDAwMDAwMDAw MDAwNiBSU0k6IGZmZmZlYTAwMDAzZDlhODAgUkRJOiBmZmZmZWEwMDAwM2Q5YWIwDQpbICAgIDAu NjM0NTAyXSBSQlA6IGZmZmY4ODAwMGY2NDU0ODggUjA4OiAwMDAwMDAwMDAwMDAwMDAwIFIwOTog MDAwMDAwMDAwMDAwMDAwMA0KWyAgICAwLjYzNDUwOF0gUjEwOiBmZmZmZmZmZjgxODcxZDAwIFIx MTogMDAwMDAwMDAwMDAwMDAwMSBSMTI6IGZmZmY4ODAwMGY2NjlmZjgNClsgICAgMC42MzQ1MTRd IFIxMzogZmZmZjg4MDAwZjY2NGM2OCBSMTQ6IGZmZmY4ODAwMGY2NmFmZTggUjE1OiAwMDAwN2Zm ZmZmZmZkMDAwDQpbICAgIDAuNjM0NTI0XSBGUzogIDAwMDA3ZmRhNDhjN2I3NDAoMDAwMCkgR1M6 ZmZmZjg4MDAxOGQ0MDAwMCgwMDAwKSBrbmxHUzowMDAwMDAwMDAwMDAwMDAwDQpbICAgIDAuNjM0 NTMyXSBDUzogIGUwMzMgRFM6IDAwMDAgRVM6IDAwMDAgQ1IwOiAwMDAwMDAwMDgwMDUwMDNiDQpb ICAgIDAuNjM0NTM3XSBDUjI6IGZmZmY4ODAwMGY2NmQwMDAgQ1IzOiAwMDAwMDAwMDAxODBiMDAw IENSNDogMDAwMDAwMDAwMDAwMjY2MA0KWyAgICAwLjYzNDU0NF0gRFIwOiAwMDAwMDAwMDAwMDAw MDAwIERSMTogMDAwMDAwMDAwMDAwMDAwMCBEUjI6IDAwMDAwMDAwMDAwMDAwMDANClsgICAgMC42 MzQ1NTBdIERSMzogMDAwMDAwMDAwMDAwMDAwMCBEUjY6IDAwMDAwMDAwZmZmZjBmZjAgRFI3OiAw MDAwMDAwMDAwMDAwNDAwDQpbICAgIDAuNjM0NTU3XSBQcm9jZXNzIGluaXQgKHBpZDogNjAsIHRo cmVhZGluZm8gZmZmZjg4MDAwZjY0NDAwMCwgdGFzayBmZmZmODgwMDBmNjQyN2MwKQ0KWyAgICAw LjYzNDU2NF0gU3RhY2s6DQpbICAgIDAuNjM0NTY3XSAgZmZmZjg4MDAwZjY0NTQ5OCBmZmZmZmZm ZjgxMDM5YmYyIGZmZmY4ODAwMGY2NDU1ODggZmZmZmZmZmY4MTEwYjAwMg0KWyAgICAwLjYzNDU3 N10gIDAwMDAwMDAwMDAwMDAwMTEgMDAwMDAwMDAwMDAwMDEwMCAwMDAwMDAwMDAwMDAwMDAwIDAw MDAwMDAwMDAwMDAxZmYNClsgICAgMC42MzQ1ODZdICAwMDAwN2ZmZmZmZmZlZmZmIDAwMDA3ZmZm ZmZmZmYwMDAgMDAwMDdmZmZmZmZmZWZmZiBmZmZmODgwMDBmNjY1N2Y4DQpbICAgIDAuNjM0NTk2 XSBDYWxsIFRyYWNlOg0KWyAgICAwLjYzNDYwMl0gIFs8ZmZmZmZmZmY4MTAzOWJmMj5dIHBhcmF2 aXJ0X2VudGVyX2xhenlfbW11KzB4MjIvMHgzMA0KWyAgICAwLjYzNDYwOV0gIFs8ZmZmZmZmZmY4 MTEwYjAwMj5dIHVubWFwX3BhZ2VfcmFuZ2UrMHgyZDIvMHg3MzANClsgICAgMC42MzQ2MTddICBb PGZmZmZmZmZmODEwZjUwOTg+XSA/IHJlbGVhc2VfcGFnZXMrMHgxNDgvMHgxYzANClsgICAgMC42 MzQ2MjRdICBbPGZmZmZmZmZmODExMGI0YzM+XSB1bm1hcF9zaW5nbGVfdm1hKzB4NjMvMHhiMA0K WyAgICAwLjYzNDYzMV0gIFs8ZmZmZmZmZmY4MTBmNTJiMD5dID8gcHV0X3BhZ2VzX2xpc3QrMHgz MC8weDMwDQpbICAgIDAuNjM0NjM3XSAgWzxmZmZmZmZmZjgxMTBiY2RlPl0gdW5tYXBfdm1hcysw eDVlLzB4YjANClsgICAgMC42MzQ2NDRdICBbPGZmZmZmZmZmODExMTMxYzc+XSBleGl0X21tYXAr MHg5Ny8weDE0MA0KWyAgICAwLjYzNDY1MF0gIFs8ZmZmZmZmZmY4MTA0NDVjMz5dIG1tcHV0KzB4 NzMvMHhmMA0KWyAgICAwLjYzNDY1N10gIFs8ZmZmZmZmZmY4MTA0OWFmZD5dIGV4aXRfbW0rMHhm ZC8weDEyMA0KWyAgICAwLjYzNDY2NF0gIFs8ZmZmZmZmZmY4MTAwOWRjOT5dID8geGVuX2lycV9l bmFibGVfZGlyZWN0X3JlbG9jKzB4NC8weDQNClsgICAgMC42MzQ2NzJdICBbPGZmZmZmZmZmODEw NGIyNDQ+XSBkb19leGl0KzB4MTY0LzB4OGEwDQpbICAgIDAuNjM0NjgwXSAgWzxmZmZmZmZmZjgx NDU4YzQyPl0gPyBfcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUrMHgxMi8weDIwDQpbICAgIDAu NjM0Njg3XSAgWzxmZmZmZmZmZjgxMDQ5MGZhPl0gPyBrbXNnX2R1bXArMHg1YS8weDEwMA0KWyAg ICAwLjYzNDY5NF0gIFs8ZmZmZmZmZmY4MTQ1OWViOT5dIG9vcHNfZW5kKzB4OTkvMHhlMA0KWyAg ICAwLjYzNDcwMF0gIFs8ZmZmZmZmZmY4MTQ0ZmM5Zj5dIG5vX2NvbnRleHQrMHgyNGUvMHgyNzkN ClsgICAgMC42MzQ3MDddICBbPGZmZmZmZmZmODEwMDczMzk+XSA/IHhlbl9wbWRfdmFsKzB4OS8w eDEwDQpbICAgIDAuNjM0NzEzXSAgWzxmZmZmZmZmZjgxNDRmZTg0Pl0gX19iYWRfYXJlYV9ub3Nl bWFwaG9yZSsweDFiYS8weDFkOQ0KWyAgICAwLjYzNDcyMV0gIFs8ZmZmZmZmZmY4MTQ1OTE2OT5d ID8gcmVzdG9yZV9hcmdzKzB4MzAvMHgzMA0KWyAgICAwLjYzNDcyN10gIFs8ZmZmZmZmZmY4MTQ0 ZmViMT5dIGJhZF9hcmVhX25vc2VtYXBob3JlKzB4ZS8weDEwDQpbICAgIDAuNjM0NzM0XSAgWzxm ZmZmZmZmZjgxNDVjNjliPl0gZG9fcGFnZV9mYXVsdCsweDMyYi8weDRmMA0KWyAgICAwLjYzNDc0 MV0gIFs8ZmZmZmZmZmY4MTAwNzI4YT5dID8gcHRlX21mbl90b19wZm4rMHg2YS8weDEwMA0KWyAg ICAwLjYzNDc0OF0gIFs8ZmZmZmZmZmY4MTBmMWNmMz5dID8gX19hbGxvY19wYWdlc19ub2RlbWFz aysweDE5My8weDg1MA0KWyAgICAwLjYzNDc1Nl0gIFs8ZmZmZmZmZmY4MTE0OTk3YT5dID8gX19k X2xvb2t1cCsweDdhLzB4MTYwDQpbICAgIDAuNjM0NzYzXSAgWzxmZmZmZmZmZjgxNDU5M2E1Pl0g cGFnZV9mYXVsdCsweDI1LzB4MzANClsgICAgMC42MzQ3NjldICBbPGZmZmZmZmZmODExMDljNjQ+ XSA/IF9fdGxiX3JlbW92ZV9wYWdlKzB4ODQvMHhiMA0KWyAgICAwLjYzNDc3Nl0gIFs8ZmZmZmZm ZmY4MTEwOWM1Yz5dID8gX190bGJfcmVtb3ZlX3BhZ2UrMHg3Yy8weGIwDQpbICAgIDAuNjM0Nzgy XSAgWzxmZmZmZmZmZjgxMTBiMWQ4Pl0gdW5tYXBfcGFnZV9yYW5nZSsweDRhOC8weDczMA0KWyAg ICAwLjYzNDc5MF0gIFs8ZmZmZmZmZmY4MTEwYjRjMz5dIHVubWFwX3NpbmdsZV92bWErMHg2My8w eGIwDQpbICAgIDAuNjM0Nzk3XSAgWzxmZmZmZmZmZjgxMGY1MmIwPl0gPyBwdXRfcGFnZXNfbGlz dCsweDMwLzB4MzANClsgICAgMC42MzQ4MDNdICBbPGZmZmZmZmZmODExMGJjZGU+XSB1bm1hcF92 bWFzKzB4NWUvMHhiMA0KWyAgICAwLjYzNDgwOV0gIFs8ZmZmZmZmZmY4MTExMzFjNz5dIGV4aXRf bW1hcCsweDk3LzB4MTQwDQpbICAgIDAuNjM0ODE2XSAgWzxmZmZmZmZmZjgxMDQ0NWMzPl0gbW1w dXQrMHg3My8weGYwDQpbICAgIDAuNjM0ODIyXSAgWzxmZmZmZmZmZjgxMTM5NmFkPl0gZmx1c2hf b2xkX2V4ZWMrMHgzZWQvMHg3MjANClsgICAgMC42MzQ4MzBdICBbPGZmZmZmZmZmODExN2Y4YmU+ XSBsb2FkX2VsZl9iaW5hcnkrMHgzMWUvMHgxODQwDQpbICAgIDAuNjM0ODM4XSAgWzxmZmZmZmZm ZjgxMTdmNWEwPl0gPyBsb2FkX2VsZl9saWJyYXJ5KzB4MjAwLzB4MjAwDQpbICAgIDAuNjM0ODQ1 XSAgWzxmZmZmZmZmZjgxMTM4ZGM3Pl0gc2VhcmNoX2JpbmFyeV9oYW5kbGVyKzB4ZTcvMHgyZjAN ClsgICAgMC42MzQ4NTJdICBbPGZmZmZmZmZmODExM2EyOTM+XSBkb19leGVjdmVfY29tbW9uLmlz cmEuMzIrMHgzZTMvMHg0YjANClsgICAgMC42MzQ4NThdICBbPGZmZmZmZmZmODExM2EzNzY+XSBk b19leGVjdmUrMHgxNi8weDIwDQpbICAgIDAuNjM0ODY0XSAgWzxmZmZmZmZmZjgxMDFhZDUyPl0g c3lzX2V4ZWN2ZSsweDQyLzB4NzANClsgICAgMC42MzQ4NzFdICBbPGZmZmZmZmZmODE0NjBjM2M+ XSBzdHViX2V4ZWN2ZSsweDZjLzB4YzANClsgICAgMC42MzQ4NzZdIENvZGU6IGZhIDQ0IDg5IGU2 IDQ4IGM3IGM3IGE4IGUzIDc1IDgxIDMxIGMwIGU4IDBiIDBmIDAwIDAwIDQ4IDgzIGM0IDE4IDVi IDQxIDVjIDQxIDVkIDQxIDVlIDQxIDVmIDVkIGMzIDU1IDQ4IDg5IGU1IDBmIDBiIDU1IDQ4IDg5 IGU1IDwwZj4gMGIgNTUgNDggODkgZTUgMGYgMGIgNTUgNDggODkgZTUgNDEgNTUgNDEgNTQgNTMg MzEgZGIgNDggODUgDQpbICAgIDAuNjM0OTMyXSBSSVAgIFs8ZmZmZmZmZmY4MTQ0ZjNiNz5dIGVu dGVyX2xhenkucGFydC40KzB4NC8weDYNClsgICAgMC42MzQ5MzhdICBSU1AgPGZmZmY4ODAwMGY2 NDU0ODg+DQpbICAgIDAuNjM0OTQxXSAtLS1bIGVuZCB0cmFjZSA1NTVlODQ1NmNmZGQzOTlhIF0t LS0NClsgICAgMC42MzQ5NDRdIEZpeGluZyByZWN1cnNpdmUgZmF1bHQgYnV0IHJlYm9vdCBpcyBu ZWVkZWQhDQo= --bcaec517a674432cc304ce37f3ed Content-Type: application/octet-stream; name=config-pvops Content-Disposition: attachment; filename=config-pvops Content-Transfer-Encoding: base64 X-Attachment-Id: f_h9e6jk3w1 IwojIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZpbGU7IERPIE5PVCBFRElULgojIExpbnV4L3g4 Nl82NCAzLjQuMTggS2VybmVsIENvbmZpZ3VyYXRpb24KIwpDT05GSUdfNjRCSVQ9eQojIENPTkZJ R19YODZfMzIgaXMgbm90IHNldApDT05GSUdfWDg2XzY0PXkKQ09ORklHX1g4Nj15CkNPTkZJR19J TlNUUlVDVElPTl9ERUNPREVSPXkKQ09ORklHX09VVFBVVF9GT1JNQVQ9ImVsZjY0LXg4Ni02NCIK Q09ORklHX0FSQ0hfREVGQ09ORklHPSJhcmNoL3g4Ni9jb25maWdzL3g4Nl82NF9kZWZjb25maWci CkNPTkZJR19HRU5FUklDX0NNT1NfVVBEQVRFPXkKQ09ORklHX0NMT0NLU09VUkNFX1dBVENIRE9H PXkKQ09ORklHX0dFTkVSSUNfQ0xPQ0tFVkVOVFM9eQpDT05GSUdfQVJDSF9DTE9DS1NPVVJDRV9E QVRBPXkKQ09ORklHX0dFTkVSSUNfQ0xPQ0tFVkVOVFNfQlJPQURDQVNUPXkKQ09ORklHX0xPQ0tE RVBfU1VQUE9SVD15CkNPTkZJR19TVEFDS1RSQUNFX1NVUFBPUlQ9eQpDT05GSUdfSEFWRV9MQVRF TkNZVE9QX1NVUFBPUlQ9eQpDT05GSUdfTU1VPXkKQ09ORklHX05FRURfRE1BX01BUF9TVEFURT15 CkNPTkZJR19ORUVEX1NHX0RNQV9MRU5HVEg9eQpDT05GSUdfR0VORVJJQ19JU0FfRE1BPXkKQ09O RklHX0dFTkVSSUNfQlVHPXkKQ09ORklHX0dFTkVSSUNfQlVHX1JFTEFUSVZFX1BPSU5URVJTPXkK Q09ORklHX0dFTkVSSUNfSFdFSUdIVD15CkNPTkZJR19HRU5FUklDX0dQSU89eQpDT05GSUdfQVJD SF9NQVlfSEFWRV9QQ19GREM9eQojIENPTkZJR19SV1NFTV9HRU5FUklDX1NQSU5MT0NLIGlzIG5v dCBzZXQKQ09ORklHX1JXU0VNX1hDSEdBRERfQUxHT1JJVEhNPXkKQ09ORklHX0FSQ0hfSEFTX0NQ VV9JRExFX1dBSVQ9eQpDT05GSUdfR0VORVJJQ19DQUxJQlJBVEVfREVMQVk9eQpDT05GSUdfR0VO RVJJQ19USU1FX1ZTWVNDQUxMPXkKQ09ORklHX0FSQ0hfSEFTX0NQVV9SRUxBWD15CkNPTkZJR19B UkNIX0hBU19ERUZBVUxUX0lETEU9eQpDT05GSUdfQVJDSF9IQVNfQ0FDSEVfTElORV9TSVpFPXkK Q09ORklHX0FSQ0hfSEFTX0NQVV9BVVRPUFJPQkU9eQpDT05GSUdfSEFWRV9TRVRVUF9QRVJfQ1BV X0FSRUE9eQpDT05GSUdfTkVFRF9QRVJfQ1BVX0VNQkVEX0ZJUlNUX0NIVU5LPXkKQ09ORklHX05F RURfUEVSX0NQVV9QQUdFX0ZJUlNUX0NIVU5LPXkKQ09ORklHX0FSQ0hfSElCRVJOQVRJT05fUE9T U0lCTEU9eQpDT05GSUdfQVJDSF9TVVNQRU5EX1BPU1NJQkxFPXkKQ09ORklHX1pPTkVfRE1BMzI9 eQpDT05GSUdfQVVESVRfQVJDSD15CkNPTkZJR19BUkNIX1NVUFBPUlRTX09QVElNSVpFRF9JTkxJ TklORz15CkNPTkZJR19BUkNIX1NVUFBPUlRTX0RFQlVHX1BBR0VBTExPQz15CkNPTkZJR19IQVZF X0lOVEVMX1RYVD15CkNPTkZJR19YODZfNjRfU01QPXkKQ09ORklHX1g4Nl9IVD15CkNPTkZJR19B UkNIX0hXRUlHSFRfQ0ZMQUdTPSItZmNhbGwtc2F2ZWQtcmRpIC1mY2FsbC1zYXZlZC1yc2kgLWZj YWxsLXNhdmVkLXJkeCAtZmNhbGwtc2F2ZWQtcmN4IC1mY2FsbC1zYXZlZC1yOCAtZmNhbGwtc2F2 ZWQtcjkgLWZjYWxsLXNhdmVkLXIxMCAtZmNhbGwtc2F2ZWQtcjExIgojIENPTkZJR19LVElNRV9T Q0FMQVIgaXMgbm90IHNldApDT05GSUdfQVJDSF9DUFVfUFJPQkVfUkVMRUFTRT15CkNPTkZJR19E RUZDT05GSUdfTElTVD0iL2xpYi9tb2R1bGVzLyRVTkFNRV9SRUxFQVNFLy5jb25maWciCkNPTkZJ R19IQVZFX0lSUV9XT1JLPXkKQ09ORklHX0lSUV9XT1JLPXkKCiMKIyBHZW5lcmFsIHNldHVwCiMK Q09ORklHX0VYUEVSSU1FTlRBTD15CkNPTkZJR19JTklUX0VOVl9BUkdfTElNSVQ9MzIKQ09ORklH X0NST1NTX0NPTVBJTEU9IiIKQ09ORklHX0xPQ0FMVkVSU0lPTj0iLTEucHZvcHMucXViZXMueDg2 XzY0IgojIENPTkZJR19MT0NBTFZFUlNJT05fQVVUTyBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0tF Uk5FTF9HWklQPXkKQ09ORklHX0hBVkVfS0VSTkVMX0JaSVAyPXkKQ09ORklHX0hBVkVfS0VSTkVM X0xaTUE9eQpDT05GSUdfSEFWRV9LRVJORUxfWFo9eQpDT05GSUdfSEFWRV9LRVJORUxfTFpPPXkK Q09ORklHX0tFUk5FTF9HWklQPXkKIyBDT05GSUdfS0VSTkVMX0JaSVAyIGlzIG5vdCBzZXQKIyBD T05GSUdfS0VSTkVMX0xaTUEgaXMgbm90IHNldAojIENPTkZJR19LRVJORUxfWFogaXMgbm90IHNl dAojIENPTkZJR19LRVJORUxfTFpPIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfSE9TVE5BTUU9 Iihub25lKSIKQ09ORklHX1NXQVA9eQpDT05GSUdfU1lTVklQQz15CkNPTkZJR19TWVNWSVBDX1NZ U0NUTD15CkNPTkZJR19QT1NJWF9NUVVFVUU9eQpDT05GSUdfUE9TSVhfTVFVRVVFX1NZU0NUTD15 CkNPTkZJR19CU0RfUFJPQ0VTU19BQ0NUPXkKQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1RfVjM9eQoj IENPTkZJR19GSEFORExFIGlzIG5vdCBzZXQKQ09ORklHX1RBU0tTVEFUUz15CkNPTkZJR19UQVNL X0RFTEFZX0FDQ1Q9eQpDT05GSUdfVEFTS19YQUNDVD15CkNPTkZJR19UQVNLX0lPX0FDQ09VTlRJ Tkc9eQpDT05GSUdfQVVESVQ9eQpDT05GSUdfQVVESVRTWVNDQUxMPXkKQ09ORklHX0FVRElUX1dB VENIPXkKQ09ORklHX0FVRElUX1RSRUU9eQpDT05GSUdfQVVESVRfTE9HSU5VSURfSU1NVVRBQkxF PXkKQ09ORklHX0hBVkVfR0VORVJJQ19IQVJESVJRUz15CgojCiMgSVJRIHN1YnN5c3RlbQojCkNP TkZJR19HRU5FUklDX0hBUkRJUlFTPXkKQ09ORklHX0dFTkVSSUNfSVJRX1BST0JFPXkKQ09ORklH X0dFTkVSSUNfSVJRX1NIT1c9eQpDT05GSUdfR0VORVJJQ19QRU5ESU5HX0lSUT15CkNPTkZJR19H RU5FUklDX0lSUV9DSElQPXkKQ09ORklHX0lSUV9GT1JDRURfVEhSRUFESU5HPXkKQ09ORklHX1NQ QVJTRV9JUlE9eQoKIwojIFJDVSBTdWJzeXN0ZW0KIwpDT05GSUdfVFJFRV9SQ1U9eQojIENPTkZJ R19QUkVFTVBUX1JDVSBpcyBub3Qgc2V0CkNPTkZJR19SQ1VfRkFOT1VUPTY0CiMgQ09ORklHX1JD VV9GQU5PVVRfRVhBQ1QgaXMgbm90IHNldApDT05GSUdfUkNVX0ZBU1RfTk9fSFo9eQojIENPTkZJ R19UUkVFX1JDVV9UUkFDRSBpcyBub3Qgc2V0CkNPTkZJR19JS0NPTkZJRz15CkNPTkZJR19JS0NP TkZJR19QUk9DPXkKQ09ORklHX0xPR19CVUZfU0hJRlQ9MTgKQ09ORklHX0hBVkVfVU5TVEFCTEVf U0NIRURfQ0xPQ0s9eQpDT05GSUdfQ0dST1VQUz15CiMgQ09ORklHX0NHUk9VUF9ERUJVRyBpcyBu b3Qgc2V0CkNPTkZJR19DR1JPVVBfRlJFRVpFUj15CkNPTkZJR19DR1JPVVBfREVWSUNFPXkKQ09O RklHX0NQVVNFVFM9eQpDT05GSUdfUFJPQ19QSURfQ1BVU0VUPXkKQ09ORklHX0NHUk9VUF9DUFVB Q0NUPXkKQ09ORklHX1JFU09VUkNFX0NPVU5URVJTPXkKIyBDT05GSUdfQ0dST1VQX01FTV9SRVNf Q1RMUiBpcyBub3Qgc2V0CiMgQ09ORklHX0NHUk9VUF9QRVJGIGlzIG5vdCBzZXQKQ09ORklHX0NH Uk9VUF9TQ0hFRD15CkNPTkZJR19GQUlSX0dST1VQX1NDSEVEPXkKQ09ORklHX0NGU19CQU5EV0lE VEg9eQpDT05GSUdfUlRfR1JPVVBfU0NIRUQ9eQpDT05GSUdfQkxLX0NHUk9VUD15CiMgQ09ORklH X0RFQlVHX0JMS19DR1JPVVAgaXMgbm90IHNldAojIENPTkZJR19DSEVDS1BPSU5UX1JFU1RPUkUg aXMgbm90IHNldApDT05GSUdfTkFNRVNQQUNFUz15CkNPTkZJR19VVFNfTlM9eQpDT05GSUdfSVBD X05TPXkKQ09ORklHX1VTRVJfTlM9eQpDT05GSUdfUElEX05TPXkKQ09ORklHX05FVF9OUz15CiMg Q09ORklHX1NDSEVEX0FVVE9HUk9VUCBpcyBub3Qgc2V0CiMgQ09ORklHX1NZU0ZTX0RFUFJFQ0FU RUQgaXMgbm90IHNldApDT05GSUdfUkVMQVk9eQpDT05GSUdfQkxLX0RFVl9JTklUUkQ9eQpDT05G SUdfSU5JVFJBTUZTX1NPVVJDRT0iIgpDT05GSUdfUkRfR1pJUD15CkNPTkZJR19SRF9CWklQMj15 CkNPTkZJR19SRF9MWk1BPXkKQ09ORklHX1JEX1haPXkKQ09ORklHX1JEX0xaTz15CiMgQ09ORklH X0NDX09QVElNSVpFX0ZPUl9TSVpFIGlzIG5vdCBzZXQKQ09ORklHX1NZU0NUTD15CkNPTkZJR19B Tk9OX0lOT0RFUz15CiMgQ09ORklHX0VYUEVSVCBpcyBub3Qgc2V0CkNPTkZJR19VSUQxNj15CiMg Q09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKQ09ORklHX0tBTExTWU1TPXkKQ09ORklH X0tBTExTWU1TX0FMTD15CkNPTkZJR19IT1RQTFVHPXkKQ09ORklHX1BSSU5USz15CkNPTkZJR19C VUc9eQpDT05GSUdfRUxGX0NPUkU9eQpDT05GSUdfUENTUEtSX1BMQVRGT1JNPXkKQ09ORklHX0hB VkVfUENTUEtSX1BMQVRGT1JNPXkKQ09ORklHX0JBU0VfRlVMTD15CkNPTkZJR19GVVRFWD15CkNP TkZJR19FUE9MTD15CkNPTkZJR19TSUdOQUxGRD15CkNPTkZJR19USU1FUkZEPXkKQ09ORklHX0VW RU5URkQ9eQpDT05GSUdfU0hNRU09eQpDT05GSUdfQUlPPXkKIyBDT05GSUdfRU1CRURERUQgaXMg bm90IHNldApDT05GSUdfSEFWRV9QRVJGX0VWRU5UUz15CgojCiMgS2VybmVsIFBlcmZvcm1hbmNl IEV2ZW50cyBBbmQgQ291bnRlcnMKIwpDT05GSUdfUEVSRl9FVkVOVFM9eQojIENPTkZJR19QRVJG X0NPVU5URVJTIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfUEVSRl9VU0VfVk1BTExPQyBpcyBu b3Qgc2V0CkNPTkZJR19WTV9FVkVOVF9DT1VOVEVSUz15CkNPTkZJR19QQ0lfUVVJUktTPXkKIyBD T05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CkNPTkZJR19TTEFCPXkKIyBDT05GSUdfU0xVQiBp cyBub3Qgc2V0CkNPTkZJR19QUk9GSUxJTkc9eQpDT05GSUdfVFJBQ0VQT0lOVFM9eQpDT05GSUdf T1BST0ZJTEU9bQojIENPTkZJR19PUFJPRklMRV9FVkVOVF9NVUxUSVBMRVggaXMgbm90IHNldApD T05GSUdfSEFWRV9PUFJPRklMRT15CkNPTkZJR19PUFJPRklMRV9OTUlfVElNRVI9eQpDT05GSUdf S1BST0JFUz15CiMgQ09ORklHX0pVTVBfTEFCRUwgaXMgbm90IHNldApDT05GSUdfT1BUUFJPQkVT PXkKQ09ORklHX0hBVkVfRUZGSUNJRU5UX1VOQUxJR05FRF9BQ0NFU1M9eQpDT05GSUdfS1JFVFBS T0JFUz15CkNPTkZJR19IQVZFX0lPUkVNQVBfUFJPVD15CkNPTkZJR19IQVZFX0tQUk9CRVM9eQpD T05GSUdfSEFWRV9LUkVUUFJPQkVTPXkKQ09ORklHX0hBVkVfT1BUUFJPQkVTPXkKQ09ORklHX0hB VkVfQVJDSF9UUkFDRUhPT0s9eQpDT05GSUdfSEFWRV9ETUFfQVRUUlM9eQpDT05GSUdfVVNFX0dF TkVSSUNfU01QX0hFTFBFUlM9eQpDT05GSUdfSEFWRV9SRUdTX0FORF9TVEFDS19BQ0NFU1NfQVBJ PXkKQ09ORklHX0hBVkVfRE1BX0FQSV9ERUJVRz15CkNPTkZJR19IQVZFX0hXX0JSRUFLUE9JTlQ9 eQpDT05GSUdfSEFWRV9NSVhFRF9CUkVBS1BPSU5UU19SRUdTPXkKQ09ORklHX0hBVkVfVVNFUl9S RVRVUk5fTk9USUZJRVI9eQpDT05GSUdfSEFWRV9QRVJGX0VWRU5UU19OTUk9eQpDT05GSUdfSEFW RV9BUkNIX0pVTVBfTEFCRUw9eQpDT05GSUdfQVJDSF9IQVZFX05NSV9TQUZFX0NNUFhDSEc9eQpD T05GSUdfSEFWRV9DTVBYQ0hHX0xPQ0FMPXkKQ09ORklHX0hBVkVfQ01QWENIR19ET1VCTEU9eQpD T05GSUdfQVJDSF9XQU5UX09MRF9DT01QQVRfSVBDPXkKCiMKIyBHQ09WLWJhc2VkIGtlcm5lbCBw cm9maWxpbmcKIwojIENPTkZJR19HQ09WX0tFUk5FTCBpcyBub3Qgc2V0CiMgQ09ORklHX0hBVkVf R0VORVJJQ19ETUFfQ09IRVJFTlQgaXMgbm90IHNldApDT05GSUdfU0xBQklORk89eQpDT05GSUdf UlRfTVVURVhFUz15CkNPTkZJR19CQVNFX1NNQUxMPTAKQ09ORklHX01PRFVMRVM9eQpDT05GSUdf TU9EVUxFX0ZPUkNFX0xPQUQ9eQpDT05GSUdfTU9EVUxFX1VOTE9BRD15CkNPTkZJR19NT0RVTEVf Rk9SQ0VfVU5MT0FEPXkKQ09ORklHX01PRFZFUlNJT05TPXkKQ09ORklHX01PRFVMRV9TUkNWRVJT SU9OX0FMTD15CkNPTkZJR19TVE9QX01BQ0hJTkU9eQpDT05GSUdfQkxPQ0s9eQpDT05GSUdfQkxL X0RFVl9CU0c9eQpDT05GSUdfQkxLX0RFVl9CU0dMSUI9eQpDT05GSUdfQkxLX0RFVl9JTlRFR1JJ VFk9eQojIENPTkZJR19CTEtfREVWX1RIUk9UVExJTkcgaXMgbm90IHNldAoKIwojIFBhcnRpdGlv biBUeXBlcwojCkNPTkZJR19QQVJUSVRJT05fQURWQU5DRUQ9eQojIENPTkZJR19BQ09STl9QQVJU SVRJT04gaXMgbm90IHNldApDT05GSUdfT1NGX1BBUlRJVElPTj15CiMgQ09ORklHX0FNSUdBX1BB UlRJVElPTiBpcyBub3Qgc2V0CkNPTkZJR19BVEFSSV9QQVJUSVRJT049eQpDT05GSUdfTUFDX1BB UlRJVElPTj15CkNPTkZJR19NU0RPU19QQVJUSVRJT049eQpDT05GSUdfQlNEX0RJU0tMQUJFTD15 CiMgQ09ORklHX01JTklYX1NVQlBBUlRJVElPTiBpcyBub3Qgc2V0CkNPTkZJR19TT0xBUklTX1g4 Nl9QQVJUSVRJT049eQpDT05GSUdfVU5JWFdBUkVfRElTS0xBQkVMPXkKQ09ORklHX0xETV9QQVJU SVRJT049eQojIENPTkZJR19MRE1fREVCVUcgaXMgbm90IHNldApDT05GSUdfU0dJX1BBUlRJVElP Tj15CkNPTkZJR19VTFRSSVhfUEFSVElUSU9OPXkKQ09ORklHX1NVTl9QQVJUSVRJT049eQpDT05G SUdfS0FSTUFfUEFSVElUSU9OPXkKQ09ORklHX0VGSV9QQVJUSVRJT049eQpDT05GSUdfU1lTVjY4 X1BBUlRJVElPTj15CkNPTkZJR19CTE9DS19DT01QQVQ9eQoKIwojIElPIFNjaGVkdWxlcnMKIwpD T05GSUdfSU9TQ0hFRF9OT09QPXkKQ09ORklHX0lPU0NIRURfREVBRExJTkU9eQpDT05GSUdfSU9T Q0hFRF9DRlE9eQpDT05GSUdfQ0ZRX0dST1VQX0lPU0NIRUQ9eQojIENPTkZJR19ERUZBVUxUX0RF QURMSU5FIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfQ0ZRPXkKIyBDT05GSUdfREVGQVVMVF9O T09QIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfSU9TQ0hFRD0iY2ZxIgpDT05GSUdfUEFEQVRB PXkKIyBDT05GSUdfSU5MSU5FX1NQSU5fVFJZTE9DSyBpcyBub3Qgc2V0CiMgQ09ORklHX0lOTElO RV9TUElOX1RSWUxPQ0tfQkggaXMgbm90IHNldAojIENPTkZJR19JTkxJTkVfU1BJTl9MT0NLIGlz IG5vdCBzZXQKIyBDT05GSUdfSU5MSU5FX1NQSU5fTE9DS19CSCBpcyBub3Qgc2V0CiMgQ09ORklH X0lOTElORV9TUElOX0xPQ0tfSVJRIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5MSU5FX1NQSU5fTE9D S19JUlFTQVZFIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5MSU5FX1NQSU5fVU5MT0NLX0JIIGlzIG5v dCBzZXQKQ09ORklHX0lOTElORV9TUElOX1VOTE9DS19JUlE9eQojIENPTkZJR19JTkxJTkVfU1BJ Tl9VTkxPQ0tfSVJRUkVTVE9SRSBpcyBub3Qgc2V0CiMgQ09ORklHX0lOTElORV9SRUFEX1RSWUxP Q0sgaXMgbm90IHNldAojIENPTkZJR19JTkxJTkVfUkVBRF9MT0NLIGlzIG5vdCBzZXQKIyBDT05G SUdfSU5MSU5FX1JFQURfTE9DS19CSCBpcyBub3Qgc2V0CiMgQ09ORklHX0lOTElORV9SRUFEX0xP Q0tfSVJRIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5MSU5FX1JFQURfTE9DS19JUlFTQVZFIGlzIG5v dCBzZXQKQ09ORklHX0lOTElORV9SRUFEX1VOTE9DSz15CiMgQ09ORklHX0lOTElORV9SRUFEX1VO TE9DS19CSCBpcyBub3Qgc2V0CkNPTkZJR19JTkxJTkVfUkVBRF9VTkxPQ0tfSVJRPXkKIyBDT05G SUdfSU5MSU5FX1JFQURfVU5MT0NLX0lSUVJFU1RPUkUgaXMgbm90IHNldAojIENPTkZJR19JTkxJ TkVfV1JJVEVfVFJZTE9DSyBpcyBub3Qgc2V0CiMgQ09ORklHX0lOTElORV9XUklURV9MT0NLIGlz IG5vdCBzZXQKIyBDT05GSUdfSU5MSU5FX1dSSVRFX0xPQ0tfQkggaXMgbm90IHNldAojIENPTkZJ R19JTkxJTkVfV1JJVEVfTE9DS19JUlEgaXMgbm90IHNldAojIENPTkZJR19JTkxJTkVfV1JJVEVf TE9DS19JUlFTQVZFIGlzIG5vdCBzZXQKQ09ORklHX0lOTElORV9XUklURV9VTkxPQ0s9eQojIENP TkZJR19JTkxJTkVfV1JJVEVfVU5MT0NLX0JIIGlzIG5vdCBzZXQKQ09ORklHX0lOTElORV9XUklU RV9VTkxPQ0tfSVJRPXkKIyBDT05GSUdfSU5MSU5FX1dSSVRFX1VOTE9DS19JUlFSRVNUT1JFIGlz IG5vdCBzZXQKQ09ORklHX01VVEVYX1NQSU5fT05fT1dORVI9eQpDT05GSUdfRlJFRVpFUj15Cgoj CiMgUHJvY2Vzc29yIHR5cGUgYW5kIGZlYXR1cmVzCiMKQ09ORklHX1pPTkVfRE1BPXkKQ09ORklH X1RJQ0tfT05FU0hPVD15CkNPTkZJR19OT19IWj15CkNPTkZJR19ISUdIX1JFU19USU1FUlM9eQpD T05GSUdfR0VORVJJQ19DTE9DS0VWRU5UU19CVUlMRD15CkNPTkZJR19HRU5FUklDX0NMT0NLRVZF TlRTX01JTl9BREpVU1Q9eQpDT05GSUdfU01QPXkKQ09ORklHX1g4Nl9YMkFQSUM9eQpDT05GSUdf WDg2X01QUEFSU0U9eQpDT05GSUdfWDg2X0VYVEVOREVEX1BMQVRGT1JNPXkKIyBDT05GSUdfWDg2 X1ZTTVAgaXMgbm90IHNldApDT05GSUdfWDg2X1NVUFBPUlRTX01FTU9SWV9GQUlMVVJFPXkKQ09O RklHX1NDSEVEX09NSVRfRlJBTUVfUE9JTlRFUj15CkNPTkZJR19QQVJBVklSVF9HVUVTVD15CiMg Q09ORklHX1BBUkFWSVJUX1RJTUVfQUNDT1VOVElORyBpcyBub3Qgc2V0CkNPTkZJR19YRU49eQpD T05GSUdfWEVOX0RPTTA9eQpDT05GSUdfWEVOX1BSSVZJTEVHRURfR1VFU1Q9eQpDT05GSUdfWEVO X1BWSFZNPXkKQ09ORklHX1hFTl9NQVhfRE9NQUlOX01FTU9SWT01MDAKQ09ORklHX1hFTl9TQVZF X1JFU1RPUkU9eQojIENPTkZJR19YRU5fREVCVUdfRlMgaXMgbm90IHNldAojIENPTkZJR19LVk1f Q0xPQ0sgaXMgbm90IHNldAojIENPTkZJR19LVk1fR1VFU1QgaXMgbm90IHNldApDT05GSUdfUEFS QVZJUlQ9eQojIENPTkZJR19QQVJBVklSVF9TUElOTE9DS1MgaXMgbm90IHNldApDT05GSUdfUEFS QVZJUlRfQ0xPQ0s9eQojIENPTkZJR19QQVJBVklSVF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19O T19CT09UTUVNPXkKIyBDT05GSUdfTUVNVEVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX01LOCBpcyBu b3Qgc2V0CiMgQ09ORklHX01QU0MgaXMgbm90IHNldAojIENPTkZJR19NQ09SRTIgaXMgbm90IHNl dAojIENPTkZJR19NQVRPTSBpcyBub3Qgc2V0CkNPTkZJR19HRU5FUklDX0NQVT15CkNPTkZJR19Y ODZfSU5URVJOT0RFX0NBQ0hFX1NISUZUPTYKQ09ORklHX1g4Nl9DTVBYQ0hHPXkKQ09ORklHX1g4 Nl9MMV9DQUNIRV9TSElGVD02CkNPTkZJR19YODZfWEFERD15CkNPTkZJR19YODZfV1BfV09SS1Nf T0s9eQpDT05GSUdfWDg2X1RTQz15CkNPTkZJR19YODZfQ01QWENIRzY0PXkKQ09ORklHX1g4Nl9D TU9WPXkKQ09ORklHX1g4Nl9NSU5JTVVNX0NQVV9GQU1JTFk9NjQKQ09ORklHX1g4Nl9ERUJVR0NU TE1TUj15CkNPTkZJR19DUFVfU1VQX0lOVEVMPXkKQ09ORklHX0NQVV9TVVBfQU1EPXkKQ09ORklH X0NQVV9TVVBfQ0VOVEFVUj15CkNPTkZJR19IUEVUX1RJTUVSPXkKQ09ORklHX0hQRVRfRU1VTEFU RV9SVEM9eQpDT05GSUdfRE1JPXkKQ09ORklHX0dBUlRfSU9NTVU9eQojIENPTkZJR19DQUxHQVJZ X0lPTU1VIGlzIG5vdCBzZXQKQ09ORklHX1NXSU9UTEI9eQpDT05GSUdfSU9NTVVfSEVMUEVSPXkK IyBDT05GSUdfTUFYU01QIGlzIG5vdCBzZXQKQ09ORklHX05SX0NQVVM9NTEyCiMgQ09ORklHX1ND SEVEX1NNVCBpcyBub3Qgc2V0CkNPTkZJR19TQ0hFRF9NQz15CiMgQ09ORklHX0lSUV9USU1FX0FD Q09VTlRJTkcgaXMgbm90IHNldAojIENPTkZJR19QUkVFTVBUX05PTkUgaXMgbm90IHNldApDT05G SUdfUFJFRU1QVF9WT0xVTlRBUlk9eQojIENPTkZJR19QUkVFTVBUIGlzIG5vdCBzZXQKQ09ORklH X1g4Nl9MT0NBTF9BUElDPXkKQ09ORklHX1g4Nl9JT19BUElDPXkKIyBDT05GSUdfWDg2X1JFUk9V VEVfRk9SX0JST0tFTl9CT09UX0lSUVMgaXMgbm90IHNldApDT05GSUdfWDg2X01DRT15CkNPTkZJ R19YODZfTUNFX0lOVEVMPXkKQ09ORklHX1g4Nl9NQ0VfQU1EPXkKQ09ORklHX1g4Nl9NQ0VfVEhS RVNIT0xEPXkKQ09ORklHX1g4Nl9NQ0VfSU5KRUNUPW0KQ09ORklHX1g4Nl9USEVSTUFMX1ZFQ1RP Uj15CkNPTkZJR19JOEs9bQpDT05GSUdfTUlDUk9DT0RFPW0KQ09ORklHX01JQ1JPQ09ERV9JTlRF TD15CkNPTkZJR19NSUNST0NPREVfQU1EPXkKQ09ORklHX01JQ1JPQ09ERV9PTERfSU5URVJGQUNF PXkKQ09ORklHX1g4Nl9NU1I9eQpDT05GSUdfWDg2X0NQVUlEPW0KQ09ORklHX0FSQ0hfUEhZU19B RERSX1RfNjRCSVQ9eQpDT05GSUdfQVJDSF9ETUFfQUREUl9UXzY0QklUPXkKQ09ORklHX0RJUkVD VF9HQlBBR0VTPXkKIyBDT05GSUdfTlVNQSBpcyBub3Qgc2V0CkNPTkZJR19BUkNIX1NQQVJTRU1F TV9FTkFCTEU9eQpDT05GSUdfQVJDSF9TUEFSU0VNRU1fREVGQVVMVD15CkNPTkZJR19BUkNIX1NF TEVDVF9NRU1PUllfTU9ERUw9eQpDT05GSUdfQVJDSF9NRU1PUllfUFJPQkU9eQpDT05GSUdfQVJD SF9QUk9DX0tDT1JFX1RFWFQ9eQpDT05GSUdfSUxMRUdBTF9QT0lOVEVSX1ZBTFVFPTB4ZGVhZDAw MDAwMDAwMDAwMApDT05GSUdfU0VMRUNUX01FTU9SWV9NT0RFTD15CkNPTkZJR19TUEFSU0VNRU1f TUFOVUFMPXkKQ09ORklHX1NQQVJTRU1FTT15CkNPTkZJR19IQVZFX01FTU9SWV9QUkVTRU5UPXkK Q09ORklHX1NQQVJTRU1FTV9FWFRSRU1FPXkKQ09ORklHX1NQQVJTRU1FTV9WTUVNTUFQX0VOQUJM RT15CkNPTkZJR19TUEFSU0VNRU1fQUxMT0NfTUVNX01BUF9UT0dFVEhFUj15CkNPTkZJR19TUEFS U0VNRU1fVk1FTU1BUD15CkNPTkZJR19IQVZFX01FTUJMT0NLPXkKQ09ORklHX0hBVkVfTUVNQkxP Q0tfTk9ERV9NQVA9eQpDT05GSUdfQVJDSF9ESVNDQVJEX01FTUJMT0NLPXkKQ09ORklHX01FTU9S WV9IT1RQTFVHPXkKQ09ORklHX01FTU9SWV9IT1RQTFVHX1NQQVJTRT15CkNPTkZJR19NRU1PUllf SE9UUkVNT1ZFPXkKQ09ORklHX1BBR0VGTEFHU19FWFRFTkRFRD15CkNPTkZJR19TUExJVF9QVExP Q0tfQ1BVUz00CkNPTkZJR19DT01QQUNUSU9OPXkKQ09ORklHX01JR1JBVElPTj15CkNPTkZJR19Q SFlTX0FERFJfVF82NEJJVD15CkNPTkZJR19aT05FX0RNQV9GTEFHPTEKQ09ORklHX0JPVU5DRT15 CkNPTkZJR19WSVJUX1RPX0JVUz15CkNPTkZJR19NTVVfTk9USUZJRVI9eQpDT05GSUdfS1NNPXkK Q09ORklHX0RFRkFVTFRfTU1BUF9NSU5fQUREUj02NTUzNgpDT05GSUdfQVJDSF9TVVBQT1JUU19N RU1PUllfRkFJTFVSRT15CkNPTkZJR19NRU1PUllfRkFJTFVSRT15CkNPTkZJR19IV1BPSVNPTl9J TkpFQ1Q9bQpDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0U9eQpDT05GSUdfVFJBTlNQQVJFTlRf SFVHRVBBR0VfQUxXQVlTPXkKIyBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0VfTUFEVklTRSBp cyBub3Qgc2V0CkNPTkZJR19DTEVBTkNBQ0hFPXkKIyBDT05GSUdfWDg2X0NIRUNLX0JJT1NfQ09S UlVQVElPTiBpcyBub3Qgc2V0CkNPTkZJR19YODZfUkVTRVJWRV9MT1c9NjQKQ09ORklHX01UUlI9 eQpDT05GSUdfTVRSUl9TQU5JVElaRVI9eQpDT05GSUdfTVRSUl9TQU5JVElaRVJfRU5BQkxFX0RF RkFVTFQ9MApDT05GSUdfTVRSUl9TQU5JVElaRVJfU1BBUkVfUkVHX05SX0RFRkFVTFQ9MQpDT05G SUdfWDg2X1BBVD15CkNPTkZJR19BUkNIX1VTRVNfUEdfVU5DQUNIRUQ9eQpDT05GSUdfQVJDSF9S QU5ET009eQojIENPTkZJR19FRkkgaXMgbm90IHNldApDT05GSUdfU0VDQ09NUD15CiMgQ09ORklH X0NDX1NUQUNLUFJPVEVDVE9SIGlzIG5vdCBzZXQKIyBDT05GSUdfSFpfMTAwIGlzIG5vdCBzZXQK Q09ORklHX0haXzI1MD15CiMgQ09ORklHX0haXzMwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0haXzEw MDAgaXMgbm90IHNldApDT05GSUdfSFo9MjUwCkNPTkZJR19TQ0hFRF9IUlRJQ0s9eQpDT05GSUdf S0VYRUM9eQojIENPTkZJR19DUkFTSF9EVU1QIGlzIG5vdCBzZXQKQ09ORklHX1BIWVNJQ0FMX1NU QVJUPTB4MTAwMDAwMApDT05GSUdfUkVMT0NBVEFCTEU9eQpDT05GSUdfUEhZU0lDQUxfQUxJR049 MHgxMDAwMDAwCkNPTkZJR19IT1RQTFVHX0NQVT15CkNPTkZJR19DT01QQVRfVkRTTz15CiMgQ09O RklHX0NNRExJTkVfQk9PTCBpcyBub3Qgc2V0CkNPTkZJR19BUkNIX0VOQUJMRV9NRU1PUllfSE9U UExVRz15CkNPTkZJR19BUkNIX0VOQUJMRV9NRU1PUllfSE9UUkVNT1ZFPXkKCiMKIyBQb3dlciBt YW5hZ2VtZW50IGFuZCBBQ1BJIG9wdGlvbnMKIwpDT05GSUdfU1VTUEVORD15CkNPTkZJR19TVVNQ RU5EX0ZSRUVaRVI9eQpDT05GSUdfSElCRVJOQVRFX0NBTExCQUNLUz15CiMgQ09ORklHX0hJQkVS TkFUSU9OIGlzIG5vdCBzZXQKQ09ORklHX1BNX1NMRUVQPXkKQ09ORklHX1BNX1NMRUVQX1NNUD15 CkNPTkZJR19QTV9SVU5USU1FPXkKQ09ORklHX1BNPXkKQ09ORklHX1BNX0RFQlVHPXkKQ09ORklH X1BNX0FEVkFOQ0VEX0RFQlVHPXkKIyBDT05GSUdfUE1fVEVTVF9TVVNQRU5EIGlzIG5vdCBzZXQK Q09ORklHX0NBTl9QTV9UUkFDRT15CkNPTkZJR19QTV9UUkFDRT15CkNPTkZJR19QTV9UUkFDRV9S VEM9eQpDT05GSUdfQUNQST15CkNPTkZJR19BQ1BJX1NMRUVQPXkKQ09ORklHX0FDUElfUFJPQ0ZT PXkKQ09ORklHX0FDUElfUFJPQ0ZTX1BPV0VSPXkKIyBDT05GSUdfQUNQSV9FQ19ERUJVR0ZTIGlz IG5vdCBzZXQKQ09ORklHX0FDUElfUFJPQ19FVkVOVD15CkNPTkZJR19BQ1BJX0FDPW0KQ09ORklH X0FDUElfQkFUVEVSWT1tCkNPTkZJR19BQ1BJX0JVVFRPTj1tCkNPTkZJR19BQ1BJX1ZJREVPPW0K Q09ORklHX0FDUElfRkFOPW0KQ09ORklHX0FDUElfRE9DSz15CkNPTkZJR19BQ1BJX1BST0NFU1NP Uj15CkNPTkZJR19BQ1BJX0lQTUk9bQpDT05GSUdfQUNQSV9IT1RQTFVHX0NQVT15CkNPTkZJR19B Q1BJX1BST0NFU1NPUl9BR0dSRUdBVE9SPW0KQ09ORklHX0FDUElfVEhFUk1BTD1tCkNPTkZJR19B Q1BJX0NVU1RPTV9EU0RUX0ZJTEU9IiIKIyBDT05GSUdfQUNQSV9DVVNUT01fRFNEVCBpcyBub3Qg c2V0CkNPTkZJR19BQ1BJX0JMQUNLTElTVF9ZRUFSPTAKQ09ORklHX0FDUElfREVCVUc9eQojIENP TkZJR19BQ1BJX0RFQlVHX0ZVTkNfVFJBQ0UgaXMgbm90IHNldApDT05GSUdfQUNQSV9QQ0lfU0xP VD1tCkNPTkZJR19YODZfUE1fVElNRVI9eQpDT05GSUdfQUNQSV9DT05UQUlORVI9eQpDT05GSUdf QUNQSV9IT1RQTFVHX01FTU9SWT1tCkNPTkZJR19BQ1BJX1NCUz1tCiMgQ09ORklHX0FDUElfSEVE IGlzIG5vdCBzZXQKIyBDT05GSUdfQUNQSV9DVVNUT01fTUVUSE9EIGlzIG5vdCBzZXQKQ09ORklH X0FDUElfQkdSVD1tCiMgQ09ORklHX0FDUElfQVBFSSBpcyBub3Qgc2V0CkNPTkZJR19TRkk9eQoK IwojIENQVSBGcmVxdWVuY3kgc2NhbGluZwojCkNPTkZJR19DUFVfRlJFUT15CkNPTkZJR19DUFVf RlJFUV9UQUJMRT15CkNPTkZJR19DUFVfRlJFUV9TVEFUPXkKIyBDT05GSUdfQ1BVX0ZSRVFfU1RB VF9ERVRBSUxTIGlzIG5vdCBzZXQKQ09ORklHX0NQVV9GUkVRX0RFRkFVTFRfR09WX1BFUkZPUk1B TkNFPXkKIyBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfVVNFUlNQQUNFIGlzIG5vdCBzZXQK IyBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQgaXMgbm90IHNldAojIENPTkZJ R19DUFVfRlJFUV9ERUZBVUxUX0dPVl9DT05TRVJWQVRJVkUgaXMgbm90IHNldApDT05GSUdfQ1BV X0ZSRVFfR09WX1BFUkZPUk1BTkNFPXkKQ09ORklHX0NQVV9GUkVRX0dPVl9QT1dFUlNBVkU9bQpD T05GSUdfQ1BVX0ZSRVFfR09WX1VTRVJTUEFDRT1tCkNPTkZJR19DUFVfRlJFUV9HT1ZfT05ERU1B TkQ9bQpDT05GSUdfQ1BVX0ZSRVFfR09WX0NPTlNFUlZBVElWRT1tCgojCiMgeDg2IENQVSBmcmVx dWVuY3kgc2NhbGluZyBkcml2ZXJzCiMKQ09ORklHX1g4Nl9QQ0NfQ1BVRlJFUT1tCkNPTkZJR19Y ODZfQUNQSV9DUFVGUkVRPW0KQ09ORklHX1g4Nl9QT1dFUk5PV19LOD1tCkNPTkZJR19YODZfU1BF RURTVEVQX0NFTlRSSU5PPW0KQ09ORklHX1g4Nl9QNF9DTE9DS01PRD1tCgojCiMgc2hhcmVkIG9w dGlvbnMKIwpDT05GSUdfWDg2X1NQRUVEU1RFUF9MSUI9bQpDT05GSUdfQ1BVX0lETEU9eQpDT05G SUdfQ1BVX0lETEVfR09WX0xBRERFUj15CkNPTkZJR19DUFVfSURMRV9HT1ZfTUVOVT15CkNPTkZJ R19JTlRFTF9JRExFPXkKCiMKIyBNZW1vcnkgcG93ZXIgc2F2aW5ncwojCkNPTkZJR19JNzMwMF9J RExFX0lPQVRfQ0hBTk5FTD15CkNPTkZJR19JNzMwMF9JRExFPW0KCiMKIyBCdXMgb3B0aW9ucyAo UENJIGV0Yy4pCiMKQ09ORklHX1BDST15CkNPTkZJR19QQ0lfRElSRUNUPXkKQ09ORklHX1BDSV9N TUNPTkZJRz15CkNPTkZJR19QQ0lfWEVOPXkKQ09ORklHX1BDSV9ET01BSU5TPXkKIyBDT05GSUdf UENJX0NOQjIwTEVfUVVJUksgaXMgbm90IHNldApDT05GSUdfUENJRVBPUlRCVVM9eQpDT05GSUdf SE9UUExVR19QQ0lfUENJRT1tCkNPTkZJR19QQ0lFQUVSPXkKIyBDT05GSUdfUENJRV9FQ1JDIGlz IG5vdCBzZXQKQ09ORklHX1BDSUVBRVJfSU5KRUNUPW0KQ09ORklHX1BDSUVBU1BNPXkKIyBDT05G SUdfUENJRUFTUE1fREVCVUcgaXMgbm90IHNldApDT05GSUdfUENJRUFTUE1fREVGQVVMVD15CiMg Q09ORklHX1BDSUVBU1BNX1BPV0VSU0FWRSBpcyBub3Qgc2V0CiMgQ09ORklHX1BDSUVBU1BNX1BF UkZPUk1BTkNFIGlzIG5vdCBzZXQKQ09ORklHX1BDSUVfUE1FPXkKQ09ORklHX0FSQ0hfU1VQUE9S VFNfTVNJPXkKQ09ORklHX1BDSV9NU0k9eQojIENPTkZJR19QQ0lfREVCVUcgaXMgbm90IHNldAoj IENPTkZJR19QQ0lfUkVBTExPQ19FTkFCTEVfQVVUTyBpcyBub3Qgc2V0CkNPTkZJR19QQ0lfU1RV Qj15CkNPTkZJR19YRU5fUENJREVWX0ZST05URU5EPXkKQ09ORklHX0hUX0lSUT15CkNPTkZJR19Q Q0lfQVRTPXkKQ09ORklHX1BDSV9JT1Y9eQpDT05GSUdfUENJX1BSST15CkNPTkZJR19QQ0lfUEFT SUQ9eQpDT05GSUdfUENJX0lPQVBJQz15CkNPTkZJR19QQ0lfTEFCRUw9eQpDT05GSUdfSVNBX0RN QV9BUEk9eQpDT05GSUdfQU1EX05CPXkKQ09ORklHX1BDQ0FSRD1tCkNPTkZJR19QQ01DSUE9bQpD T05GSUdfUENNQ0lBX0xPQURfQ0lTPXkKQ09ORklHX0NBUkRCVVM9eQoKIwojIFBDLWNhcmQgYnJp ZGdlcwojCkNPTkZJR19ZRU5UQT1tCkNPTkZJR19ZRU5UQV9PMj15CkNPTkZJR19ZRU5UQV9SSUNP SD15CkNPTkZJR19ZRU5UQV9UST15CkNPTkZJR19ZRU5UQV9FTkVfVFVORT15CkNPTkZJR19ZRU5U QV9UT1NISUJBPXkKQ09ORklHX1BENjcyOT1tCkNPTkZJR19JODIwOTI9bQpDT05GSUdfUENDQVJE X05PTlNUQVRJQz15CkNPTkZJR19IT1RQTFVHX1BDST1tCkNPTkZJR19IT1RQTFVHX1BDSV9GQUtF PW0KQ09ORklHX0hPVFBMVUdfUENJX0FDUEk9bQpDT05GSUdfSE9UUExVR19QQ0lfQUNQSV9JQk09 bQpDT05GSUdfSE9UUExVR19QQ0lfQ1BDST15CkNPTkZJR19IT1RQTFVHX1BDSV9DUENJX1pUNTU1 MD1tCkNPTkZJR19IT1RQTFVHX1BDSV9DUENJX0dFTkVSSUM9bQpDT05GSUdfSE9UUExVR19QQ0lf U0hQQz1tCiMgQ09ORklHX1JBUElESU8gaXMgbm90IHNldAoKIwojIEV4ZWN1dGFibGUgZmlsZSBm b3JtYXRzIC8gRW11bGF0aW9ucwojCkNPTkZJR19CSU5GTVRfRUxGPXkKQ09ORklHX0NPTVBBVF9C SU5GTVRfRUxGPXkKQ09ORklHX0FSQ0hfQklORk1UX0VMRl9SQU5ET01JWkVfUElFPXkKQ09ORklH X0NPUkVfRFVNUF9ERUZBVUxUX0VMRl9IRUFERVJTPXkKIyBDT05GSUdfSEFWRV9BT1VUIGlzIG5v dCBzZXQKQ09ORklHX0JJTkZNVF9NSVNDPW0KQ09ORklHX0lBMzJfRU1VTEFUSU9OPXkKQ09ORklH X0lBMzJfQU9VVD1tCiMgQ09ORklHX1g4Nl9YMzIgaXMgbm90IHNldApDT05GSUdfQ09NUEFUPXkK Q09ORklHX0NPTVBBVF9GT1JfVTY0X0FMSUdOTUVOVD15CkNPTkZJR19TWVNWSVBDX0NPTVBBVD15 CkNPTkZJR19LRVlTX0NPTVBBVD15CkNPTkZJR19IQVZFX1RFWFRfUE9LRV9TTVA9eQpDT05GSUdf TkVUPXkKQ09ORklHX0NPTVBBVF9ORVRMSU5LX01FU1NBR0VTPXkKCiMKIyBOZXR3b3JraW5nIG9w dGlvbnMKIwpDT05GSUdfUEFDS0VUPW0KQ09ORklHX1VOSVg9eQpDT05GSUdfVU5JWF9ESUFHPW0K Q09ORklHX1hGUk09eQpDT05GSUdfWEZSTV9VU0VSPW0KQ09ORklHX1hGUk1fU1VCX1BPTElDWT15 CkNPTkZJR19YRlJNX01JR1JBVEU9eQojIENPTkZJR19YRlJNX1NUQVRJU1RJQ1MgaXMgbm90IHNl dApDT05GSUdfWEZSTV9JUENPTVA9bQpDT05GSUdfTkVUX0tFWT1tCkNPTkZJR19ORVRfS0VZX01J R1JBVEU9eQpDT05GSUdfSU5FVD15CkNPTkZJR19JUF9NVUxUSUNBU1Q9eQpDT05GSUdfSVBfQURW QU5DRURfUk9VVEVSPXkKIyBDT05GSUdfSVBfRklCX1RSSUVfU1RBVFMgaXMgbm90IHNldApDT05G SUdfSVBfTVVMVElQTEVfVEFCTEVTPXkKQ09ORklHX0lQX1JPVVRFX01VTFRJUEFUSD15CkNPTkZJ R19JUF9ST1VURV9WRVJCT1NFPXkKQ09ORklHX0lQX1JPVVRFX0NMQVNTSUQ9eQpDT05GSUdfSVBf UE5QPXkKQ09ORklHX0lQX1BOUF9ESENQPXkKQ09ORklHX0lQX1BOUF9CT09UUD15CkNPTkZJR19J UF9QTlBfUkFSUD15CkNPTkZJR19ORVRfSVBJUD1tCiMgQ09ORklHX05FVF9JUEdSRV9ERU1VWCBp cyBub3Qgc2V0CkNPTkZJR19JUF9NUk9VVEU9eQojIENPTkZJR19JUF9NUk9VVEVfTVVMVElQTEVf VEFCTEVTIGlzIG5vdCBzZXQKQ09ORklHX0lQX1BJTVNNX1YxPXkKQ09ORklHX0lQX1BJTVNNX1Yy PXkKIyBDT05GSUdfQVJQRCBpcyBub3Qgc2V0CkNPTkZJR19TWU5fQ09PS0lFUz15CkNPTkZJR19J TkVUX0FIPW0KQ09ORklHX0lORVRfRVNQPW0KQ09ORklHX0lORVRfSVBDT01QPW0KQ09ORklHX0lO RVRfWEZSTV9UVU5ORUw9bQpDT05GSUdfSU5FVF9UVU5ORUw9bQpDT05GSUdfSU5FVF9YRlJNX01P REVfVFJBTlNQT1JUPW0KQ09ORklHX0lORVRfWEZSTV9NT0RFX1RVTk5FTD1tCkNPTkZJR19JTkVU X1hGUk1fTU9ERV9CRUVUPW0KQ09ORklHX0lORVRfTFJPPXkKQ09ORklHX0lORVRfRElBRz1tCkNP TkZJR19JTkVUX1RDUF9ESUFHPW0KQ09ORklHX0lORVRfVURQX0RJQUc9bQpDT05GSUdfVENQX0NP TkdfQURWQU5DRUQ9eQpDT05GSUdfVENQX0NPTkdfQklDPW0KQ09ORklHX1RDUF9DT05HX0NVQklD PXkKQ09ORklHX1RDUF9DT05HX1dFU1RXT09EPW0KQ09ORklHX1RDUF9DT05HX0hUQ1A9bQpDT05G SUdfVENQX0NPTkdfSFNUQ1A9bQpDT05GSUdfVENQX0NPTkdfSFlCTEE9bQpDT05GSUdfVENQX0NP TkdfVkVHQVM9bQpDT05GSUdfVENQX0NPTkdfU0NBTEFCTEU9bQpDT05GSUdfVENQX0NPTkdfTFA9 bQpDT05GSUdfVENQX0NPTkdfVkVOTz1tCkNPTkZJR19UQ1BfQ09OR19ZRUFIPW0KQ09ORklHX1RD UF9DT05HX0lMTElOT0lTPW0KQ09ORklHX0RFRkFVTFRfQ1VCSUM9eQojIENPTkZJR19ERUZBVUxU X1JFTk8gaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9UQ1BfQ09ORz0iY3ViaWMiCiMgQ09ORklH X1RDUF9NRDVTSUcgaXMgbm90IHNldApDT05GSUdfSVBWNj15CkNPTkZJR19JUFY2X1BSSVZBQ1k9 eQpDT05GSUdfSVBWNl9ST1VURVJfUFJFRj15CkNPTkZJR19JUFY2X1JPVVRFX0lORk89eQojIENP TkZJR19JUFY2X09QVElNSVNUSUNfREFEIGlzIG5vdCBzZXQKQ09ORklHX0lORVQ2X0FIPW0KQ09O RklHX0lORVQ2X0VTUD1tCkNPTkZJR19JTkVUNl9JUENPTVA9bQpDT05GSUdfSVBWNl9NSVA2PW0K Q09ORklHX0lORVQ2X1hGUk1fVFVOTkVMPW0KQ09ORklHX0lORVQ2X1RVTk5FTD1tCkNPTkZJR19J TkVUNl9YRlJNX01PREVfVFJBTlNQT1JUPW0KQ09ORklHX0lORVQ2X1hGUk1fTU9ERV9UVU5ORUw9 bQpDT05GSUdfSU5FVDZfWEZSTV9NT0RFX0JFRVQ9bQpDT05GSUdfSU5FVDZfWEZSTV9NT0RFX1JP VVRFT1BUSU1JWkFUSU9OPW0KQ09ORklHX0lQVjZfU0lUPW0KIyBDT05GSUdfSVBWNl9TSVRfNlJE IGlzIG5vdCBzZXQKQ09ORklHX0lQVjZfTkRJU0NfTk9ERVRZUEU9eQpDT05GSUdfSVBWNl9UVU5O RUw9bQpDT05GSUdfSVBWNl9NVUxUSVBMRV9UQUJMRVM9eQpDT05GSUdfSVBWNl9TVUJUUkVFUz15 CiMgQ09ORklHX0lQVjZfTVJPVVRFIGlzIG5vdCBzZXQKQ09ORklHX05FVFdPUktfU0VDTUFSSz15 CiMgQ09ORklHX05FVFdPUktfUEhZX1RJTUVTVEFNUElORyBpcyBub3Qgc2V0CkNPTkZJR19ORVRG SUxURVI9eQojIENPTkZJR19ORVRGSUxURVJfREVCVUcgaXMgbm90IHNldApDT05GSUdfTkVURklM VEVSX0FEVkFOQ0VEPXkKQ09ORklHX0JSSURHRV9ORVRGSUxURVI9eQoKIwojIENvcmUgTmV0Zmls dGVyIENvbmZpZ3VyYXRpb24KIwpDT05GSUdfTkVURklMVEVSX05FVExJTks9bQpDT05GSUdfTkVU RklMVEVSX05FVExJTktfQUNDVD1tCkNPTkZJR19ORVRGSUxURVJfTkVUTElOS19RVUVVRT1tCkNP TkZJR19ORVRGSUxURVJfTkVUTElOS19MT0c9bQpDT05GSUdfTkZfQ09OTlRSQUNLPW0KQ09ORklH X05GX0NPTk5UUkFDS19NQVJLPXkKQ09ORklHX05GX0NPTk5UUkFDS19TRUNNQVJLPXkKQ09ORklH X05GX0NPTk5UUkFDS19aT05FUz15CkNPTkZJR19ORl9DT05OVFJBQ0tfUFJPQ0ZTPXkKQ09ORklH X05GX0NPTk5UUkFDS19FVkVOVFM9eQpDT05GSUdfTkZfQ09OTlRSQUNLX1RJTUVPVVQ9eQojIENP TkZJR19ORl9DT05OVFJBQ0tfVElNRVNUQU1QIGlzIG5vdCBzZXQKQ09ORklHX05GX0NUX1BST1RP X0RDQ1A9bQpDT05GSUdfTkZfQ1RfUFJPVE9fR1JFPW0KQ09ORklHX05GX0NUX1BST1RPX1NDVFA9 bQpDT05GSUdfTkZfQ1RfUFJPVE9fVURQTElURT1tCkNPTkZJR19ORl9DT05OVFJBQ0tfQU1BTkRB PW0KQ09ORklHX05GX0NPTk5UUkFDS19GVFA9bQpDT05GSUdfTkZfQ09OTlRSQUNLX0gzMjM9bQpD T05GSUdfTkZfQ09OTlRSQUNLX0lSQz1tCkNPTkZJR19ORl9DT05OVFJBQ0tfQlJPQURDQVNUPW0K Q09ORklHX05GX0NPTk5UUkFDS19ORVRCSU9TX05TPW0KQ09ORklHX05GX0NPTk5UUkFDS19TTk1Q PW0KQ09ORklHX05GX0NPTk5UUkFDS19QUFRQPW0KQ09ORklHX05GX0NPTk5UUkFDS19TQU5FPW0K Q09ORklHX05GX0NPTk5UUkFDS19TSVA9bQpDT05GSUdfTkZfQ09OTlRSQUNLX1RGVFA9bQpDT05G SUdfTkZfQ1RfTkVUTElOSz1tCkNPTkZJR19ORl9DVF9ORVRMSU5LX1RJTUVPVVQ9bQpDT05GSUdf TkVURklMVEVSX1RQUk9YWT1tCkNPTkZJR19ORVRGSUxURVJfWFRBQkxFUz1tCgojCiMgWHRhYmxl cyBjb21iaW5lZCBtb2R1bGVzCiMKQ09ORklHX05FVEZJTFRFUl9YVF9NQVJLPW0KQ09ORklHX05F VEZJTFRFUl9YVF9DT05OTUFSSz1tCkNPTkZJR19ORVRGSUxURVJfWFRfU0VUPW0KCiMKIyBYdGFi bGVzIHRhcmdldHMKIwojIENPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX0FVRElUIGlzIG5vdCBz ZXQKIyBDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9DSEVDS1NVTSBpcyBub3Qgc2V0CkNPTkZJ R19ORVRGSUxURVJfWFRfVEFSR0VUX0NMQVNTSUZZPW0KQ09ORklHX05FVEZJTFRFUl9YVF9UQVJH RVRfQ09OTk1BUks9bQpDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9DT05OU0VDTUFSSz1tCkNP TkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX0NUPW0KQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRf RFNDUD1tCkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX0hMPW0KIyBDT05GSUdfTkVURklMVEVS X1hUX1RBUkdFVF9JRExFVElNRVIgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX1RBUkdF VF9MRUQ9bQpDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9MT0c9bQpDT05GSUdfTkVURklMVEVS X1hUX1RBUkdFVF9NQVJLPW0KQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfTkZMT0c9bQpDT05G SUdfTkVURklMVEVSX1hUX1RBUkdFVF9ORlFVRVVFPW0KQ09ORklHX05FVEZJTFRFUl9YVF9UQVJH RVRfTk9UUkFDSz1tCkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1JBVEVFU1Q9bQojIENPTkZJ R19ORVRGSUxURVJfWFRfVEFSR0VUX1RFRSBpcyBub3Qgc2V0CkNPTkZJR19ORVRGSUxURVJfWFRf VEFSR0VUX1RQUk9YWT1tCkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1RSQUNFPW0KQ09ORklH X05FVEZJTFRFUl9YVF9UQVJHRVRfU0VDTUFSSz1tCkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VU X1RDUE1TUz1tCkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1RDUE9QVFNUUklQPW0KCiMKIyBY dGFibGVzIG1hdGNoZXMKIwpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0FERFJUWVBFPW0KQ09O RklHX05FVEZJTFRFUl9YVF9NQVRDSF9DTFVTVEVSPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRD SF9DT01NRU5UPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9DT05OQllURVM9bQpDT05GSUdf TkVURklMVEVSX1hUX01BVENIX0NPTk5MSU1JVD1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hf Q09OTk1BUks9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0NPTk5UUkFDSz1tCiMgQ09ORklH X05FVEZJTFRFUl9YVF9NQVRDSF9DUFUgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX01B VENIX0RDQ1A9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0RFVkdST1VQPW0KQ09ORklHX05F VEZJTFRFUl9YVF9NQVRDSF9EU0NQPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9FQ049bQpD T05GSUdfTkVURklMVEVSX1hUX01BVENIX0VTUD1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hf SEFTSExJTUlUPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9IRUxQRVI9bQpDT05GSUdfTkVU RklMVEVSX1hUX01BVENIX0hMPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9JUFJBTkdFPW0K IyBDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0lQVlMgaXMgbm90IHNldApDT05GSUdfTkVURklM VEVSX1hUX01BVENIX0xFTkdUSD1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfTElNSVQ9bQpD T05GSUdfTkVURklMVEVSX1hUX01BVENIX01BQz1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hf TUFSSz1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfTVVMVElQT1JUPW0KQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9ORkFDQ1Q9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX09TRj1tCkNP TkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfT1dORVI9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENI X1BPTElDWT1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfUEhZU0RFVj1tCkNPTkZJR19ORVRG SUxURVJfWFRfTUFUQ0hfUEtUVFlQRT1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfUVVPVEE9 bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1JBVEVFU1Q9bQpDT05GSUdfTkVURklMVEVSX1hU X01BVENIX1JFQUxNPW0KQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9SRUNFTlQ9bQpDT05GSUdf TkVURklMVEVSX1hUX01BVENIX1NDVFA9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1NPQ0tF VD1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfU1RBVEU9bQpDT05GSUdfTkVURklMVEVSX1hU X01BVENIX1NUQVRJU1RJQz1tCkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfU1RSSU5HPW0KQ09O RklHX05FVEZJTFRFUl9YVF9NQVRDSF9UQ1BNU1M9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENI X1RJTUU9bQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1UzMj1tCkNPTkZJR19JUF9TRVQ9bQpD T05GSUdfSVBfU0VUX01BWD0yNTYKQ09ORklHX0lQX1NFVF9CSVRNQVBfSVA9bQpDT05GSUdfSVBf U0VUX0JJVE1BUF9JUE1BQz1tCkNPTkZJR19JUF9TRVRfQklUTUFQX1BPUlQ9bQpDT05GSUdfSVBf U0VUX0hBU0hfSVA9bQpDT05GSUdfSVBfU0VUX0hBU0hfSVBQT1JUPW0KQ09ORklHX0lQX1NFVF9I QVNIX0lQUE9SVElQPW0KQ09ORklHX0lQX1NFVF9IQVNIX0lQUE9SVE5FVD1tCkNPTkZJR19JUF9T RVRfSEFTSF9ORVQ9bQpDT05GSUdfSVBfU0VUX0hBU0hfTkVUUE9SVD1tCkNPTkZJR19JUF9TRVRf SEFTSF9ORVRJRkFDRT1tCkNPTkZJR19JUF9TRVRfTElTVF9TRVQ9bQpDT05GSUdfSVBfVlM9bQpD T05GSUdfSVBfVlNfSVBWNj15CiMgQ09ORklHX0lQX1ZTX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklH X0lQX1ZTX1RBQl9CSVRTPTEyCgojCiMgSVBWUyB0cmFuc3BvcnQgcHJvdG9jb2wgbG9hZCBiYWxh bmNpbmcgc3VwcG9ydAojCkNPTkZJR19JUF9WU19QUk9UT19UQ1A9eQpDT05GSUdfSVBfVlNfUFJP VE9fVURQPXkKQ09ORklHX0lQX1ZTX1BST1RPX0FIX0VTUD15CkNPTkZJR19JUF9WU19QUk9UT19F U1A9eQpDT05GSUdfSVBfVlNfUFJPVE9fQUg9eQpDT05GSUdfSVBfVlNfUFJPVE9fU0NUUD15Cgoj CiMgSVBWUyBzY2hlZHVsZXIKIwpDT05GSUdfSVBfVlNfUlI9bQpDT05GSUdfSVBfVlNfV1JSPW0K Q09ORklHX0lQX1ZTX0xDPW0KQ09ORklHX0lQX1ZTX1dMQz1tCkNPTkZJR19JUF9WU19MQkxDPW0K Q09ORklHX0lQX1ZTX0xCTENSPW0KQ09ORklHX0lQX1ZTX0RIPW0KQ09ORklHX0lQX1ZTX1NIPW0K Q09ORklHX0lQX1ZTX1NFRD1tCkNPTkZJR19JUF9WU19OUT1tCgojCiMgSVBWUyBTSCBzY2hlZHVs ZXIKIwpDT05GSUdfSVBfVlNfU0hfVEFCX0JJVFM9OAoKIwojIElQVlMgYXBwbGljYXRpb24gaGVs cGVyCiMKQ09ORklHX0lQX1ZTX0ZUUD1tCkNPTkZJR19JUF9WU19ORkNUPXkKIyBDT05GSUdfSVBf VlNfUEVfU0lQIGlzIG5vdCBzZXQKCiMKIyBJUDogTmV0ZmlsdGVyIENvbmZpZ3VyYXRpb24KIwpD T05GSUdfTkZfREVGUkFHX0lQVjQ9bQpDT05GSUdfTkZfQ09OTlRSQUNLX0lQVjQ9bQojIENPTkZJ R19ORl9DT05OVFJBQ0tfUFJPQ19DT01QQVQgaXMgbm90IHNldApDT05GSUdfSVBfTkZfUVVFVUU9 bQpDT05GSUdfSVBfTkZfSVBUQUJMRVM9bQpDT05GSUdfSVBfTkZfTUFUQ0hfQUg9bQpDT05GSUdf SVBfTkZfTUFUQ0hfRUNOPW0KQ09ORklHX0lQX05GX01BVENIX1JQRklMVEVSPW0KQ09ORklHX0lQ X05GX01BVENIX1RUTD1tCkNPTkZJR19JUF9ORl9GSUxURVI9bQpDT05GSUdfSVBfTkZfVEFSR0VU X1JFSkVDVD1tCkNPTkZJR19JUF9ORl9UQVJHRVRfVUxPRz1tCkNPTkZJR19ORl9OQVQ9bQpDT05G SUdfTkZfTkFUX05FRURFRD15CkNPTkZJR19JUF9ORl9UQVJHRVRfTUFTUVVFUkFERT1tCkNPTkZJ R19JUF9ORl9UQVJHRVRfTkVUTUFQPW0KQ09ORklHX0lQX05GX1RBUkdFVF9SRURJUkVDVD1tCkNP TkZJR19ORl9OQVRfU05NUF9CQVNJQz1tCkNPTkZJR19ORl9OQVRfUFJPVE9fRENDUD1tCkNPTkZJ R19ORl9OQVRfUFJPVE9fR1JFPW0KQ09ORklHX05GX05BVF9QUk9UT19VRFBMSVRFPW0KQ09ORklH X05GX05BVF9QUk9UT19TQ1RQPW0KQ09ORklHX05GX05BVF9GVFA9bQpDT05GSUdfTkZfTkFUX0lS Qz1tCkNPTkZJR19ORl9OQVRfVEZUUD1tCkNPTkZJR19ORl9OQVRfQU1BTkRBPW0KQ09ORklHX05G X05BVF9QUFRQPW0KQ09ORklHX05GX05BVF9IMzIzPW0KQ09ORklHX05GX05BVF9TSVA9bQpDT05G SUdfSVBfTkZfTUFOR0xFPW0KQ09ORklHX0lQX05GX1RBUkdFVF9DTFVTVEVSSVA9bQpDT05GSUdf SVBfTkZfVEFSR0VUX0VDTj1tCkNPTkZJR19JUF9ORl9UQVJHRVRfVFRMPW0KQ09ORklHX0lQX05G X1JBVz1tCkNPTkZJR19JUF9ORl9BUlBUQUJMRVM9bQpDT05GSUdfSVBfTkZfQVJQRklMVEVSPW0K Q09ORklHX0lQX05GX0FSUF9NQU5HTEU9bQoKIwojIElQdjY6IE5ldGZpbHRlciBDb25maWd1cmF0 aW9uCiMKQ09ORklHX05GX0RFRlJBR19JUFY2PW0KQ09ORklHX05GX0NPTk5UUkFDS19JUFY2PW0K Q09ORklHX0lQNl9ORl9RVUVVRT1tCkNPTkZJR19JUDZfTkZfSVBUQUJMRVM9bQpDT05GSUdfSVA2 X05GX01BVENIX0FIPW0KQ09ORklHX0lQNl9ORl9NQVRDSF9FVUk2ND1tCkNPTkZJR19JUDZfTkZf TUFUQ0hfRlJBRz1tCkNPTkZJR19JUDZfTkZfTUFUQ0hfT1BUUz1tCkNPTkZJR19JUDZfTkZfTUFU Q0hfSEw9bQpDT05GSUdfSVA2X05GX01BVENIX0lQVjZIRUFERVI9bQpDT05GSUdfSVA2X05GX01B VENIX01IPW0KQ09ORklHX0lQNl9ORl9NQVRDSF9SUEZJTFRFUj1tCkNPTkZJR19JUDZfTkZfTUFU Q0hfUlQ9bQpDT05GSUdfSVA2X05GX1RBUkdFVF9ITD1tCkNPTkZJR19JUDZfTkZfRklMVEVSPW0K Q09ORklHX0lQNl9ORl9UQVJHRVRfUkVKRUNUPW0KQ09ORklHX0lQNl9ORl9NQU5HTEU9bQpDT05G SUdfSVA2X05GX1JBVz1tCgojCiMgREVDbmV0OiBOZXRmaWx0ZXIgQ29uZmlndXJhdGlvbgojCiMg Q09ORklHX0RFQ05FVF9ORl9HUkFCVUxBVE9SIGlzIG5vdCBzZXQKQ09ORklHX0JSSURHRV9ORl9F QlRBQkxFUz1tCkNPTkZJR19CUklER0VfRUJUX0JST1VURT1tCkNPTkZJR19CUklER0VfRUJUX1Rf RklMVEVSPW0KQ09ORklHX0JSSURHRV9FQlRfVF9OQVQ9bQpDT05GSUdfQlJJREdFX0VCVF84MDJf Mz1tCkNPTkZJR19CUklER0VfRUJUX0FNT05HPW0KQ09ORklHX0JSSURHRV9FQlRfQVJQPW0KQ09O RklHX0JSSURHRV9FQlRfSVA9bQpDT05GSUdfQlJJREdFX0VCVF9JUDY9bQpDT05GSUdfQlJJREdF X0VCVF9MSU1JVD1tCkNPTkZJR19CUklER0VfRUJUX01BUks9bQpDT05GSUdfQlJJREdFX0VCVF9Q S1RUWVBFPW0KQ09ORklHX0JSSURHRV9FQlRfU1RQPW0KQ09ORklHX0JSSURHRV9FQlRfVkxBTj1t CkNPTkZJR19CUklER0VfRUJUX0FSUFJFUExZPW0KQ09ORklHX0JSSURHRV9FQlRfRE5BVD1tCkNP TkZJR19CUklER0VfRUJUX01BUktfVD1tCkNPTkZJR19CUklER0VfRUJUX1JFRElSRUNUPW0KQ09O RklHX0JSSURHRV9FQlRfU05BVD1tCkNPTkZJR19CUklER0VfRUJUX0xPRz1tCkNPTkZJR19CUklE R0VfRUJUX1VMT0c9bQpDT05GSUdfQlJJREdFX0VCVF9ORkxPRz1tCkNPTkZJR19JUF9EQ0NQPW0K Q09ORklHX0lORVRfRENDUF9ESUFHPW0KCiMKIyBEQ0NQIENDSURzIENvbmZpZ3VyYXRpb24gKEVY UEVSSU1FTlRBTCkKIwojIENPTkZJR19JUF9EQ0NQX0NDSUQyX0RFQlVHIGlzIG5vdCBzZXQKQ09O RklHX0lQX0RDQ1BfQ0NJRDM9eQojIENPTkZJR19JUF9EQ0NQX0NDSUQzX0RFQlVHIGlzIG5vdCBz ZXQKQ09ORklHX0lQX0RDQ1BfVEZSQ19MSUI9eQoKIwojIERDQ1AgS2VybmVsIEhhY2tpbmcKIwoj IENPTkZJR19JUF9EQ0NQX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0RDQ1BQUk9CRSBp cyBub3Qgc2V0CkNPTkZJR19JUF9TQ1RQPW0KIyBDT05GSUdfTkVUX1NDVFBQUk9CRSBpcyBub3Qg c2V0CiMgQ09ORklHX1NDVFBfREJHX01TRyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDVFBfREJHX09C SkNOVCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDVFBfSE1BQ19OT05FIGlzIG5vdCBzZXQKIyBDT05G SUdfU0NUUF9ITUFDX1NIQTEgaXMgbm90IHNldApDT05GSUdfU0NUUF9ITUFDX01ENT15CkNPTkZJ R19SRFM9bQpDT05GSUdfUkRTX1JETUE9bQpDT05GSUdfUkRTX1RDUD1tCiMgQ09ORklHX1JEU19E RUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX1RJUEMgaXMgbm90IHNldApDT05GSUdfQVRNPW0KQ09O RklHX0FUTV9DTElQPW0KIyBDT05GSUdfQVRNX0NMSVBfTk9fSUNNUCBpcyBub3Qgc2V0CkNPTkZJ R19BVE1fTEFORT1tCkNPTkZJR19BVE1fTVBPQT1tCkNPTkZJR19BVE1fQlIyNjg0PW0KIyBDT05G SUdfQVRNX0JSMjY4NF9JUEZJTFRFUiBpcyBub3Qgc2V0CiMgQ09ORklHX0wyVFAgaXMgbm90IHNl dApDT05GSUdfU1RQPW0KQ09ORklHX0dBUlA9bQpDT05GSUdfQlJJREdFPW0KQ09ORklHX0JSSURH RV9JR01QX1NOT09QSU5HPXkKQ09ORklHX05FVF9EU0E9eQpDT05GSUdfTkVUX0RTQV9UQUdfRFNB PXkKQ09ORklHX05FVF9EU0FfVEFHX0VEU0E9eQpDT05GSUdfTkVUX0RTQV9UQUdfVFJBSUxFUj15 CkNPTkZJR19WTEFOXzgwMjFRPW0KQ09ORklHX1ZMQU5fODAyMVFfR1ZSUD15CkNPTkZJR19ERUNO RVQ9bQojIENPTkZJR19ERUNORVRfUk9VVEVSIGlzIG5vdCBzZXQKQ09ORklHX0xMQz1tCkNPTkZJ R19MTEMyPW0KQ09ORklHX0lQWD1tCkNPTkZJR19JUFhfSU5URVJOPXkKQ09ORklHX0FUQUxLPW0K Q09ORklHX0RFVl9BUFBMRVRBTEs9bQpDT05GSUdfSVBERFA9bQpDT05GSUdfSVBERFBfRU5DQVA9 eQpDT05GSUdfSVBERFBfREVDQVA9eQpDT05GSUdfWDI1PW0KQ09ORklHX0xBUEI9bQojIENPTkZJ R19FQ09ORVQgaXMgbm90IHNldApDT05GSUdfV0FOX1JPVVRFUj1tCkNPTkZJR19QSE9ORVQ9bQpD T05GSUdfSUVFRTgwMjE1ND1tCkNPTkZJR19JRUVFODAyMTU0XzZMT1dQQU49bQpDT05GSUdfTkVU X1NDSEVEPXkKCiMKIyBRdWV1ZWluZy9TY2hlZHVsaW5nCiMKQ09ORklHX05FVF9TQ0hfQ0JRPW0K Q09ORklHX05FVF9TQ0hfSFRCPW0KQ09ORklHX05FVF9TQ0hfSEZTQz1tCkNPTkZJR19ORVRfU0NI X0FUTT1tCkNPTkZJR19ORVRfU0NIX1BSSU89bQpDT05GSUdfTkVUX1NDSF9NVUxUSVE9bQpDT05G SUdfTkVUX1NDSF9SRUQ9bQpDT05GSUdfTkVUX1NDSF9TRkI9bQpDT05GSUdfTkVUX1NDSF9TRlE9 bQpDT05GSUdfTkVUX1NDSF9URVFMPW0KQ09ORklHX05FVF9TQ0hfVEJGPW0KQ09ORklHX05FVF9T Q0hfR1JFRD1tCkNPTkZJR19ORVRfU0NIX0RTTUFSSz1tCkNPTkZJR19ORVRfU0NIX05FVEVNPW0K Q09ORklHX05FVF9TQ0hfRFJSPW0KQ09ORklHX05FVF9TQ0hfTVFQUklPPW0KQ09ORklHX05FVF9T Q0hfQ0hPS0U9bQpDT05GSUdfTkVUX1NDSF9RRlE9bQpDT05GSUdfTkVUX1NDSF9JTkdSRVNTPW0K Q09ORklHX05FVF9TQ0hfUExVRz1tCgojCiMgQ2xhc3NpZmljYXRpb24KIwpDT05GSUdfTkVUX0NM Uz15CkNPTkZJR19ORVRfQ0xTX0JBU0lDPW0KQ09ORklHX05FVF9DTFNfVENJTkRFWD1tCkNPTkZJ R19ORVRfQ0xTX1JPVVRFND1tCkNPTkZJR19ORVRfQ0xTX0ZXPW0KQ09ORklHX05FVF9DTFNfVTMy PW0KQ09ORklHX0NMU19VMzJfUEVSRj15CkNPTkZJR19DTFNfVTMyX01BUks9eQpDT05GSUdfTkVU X0NMU19SU1ZQPW0KQ09ORklHX05FVF9DTFNfUlNWUDY9bQpDT05GSUdfTkVUX0NMU19GTE9XPW0K Q09ORklHX05FVF9DTFNfQ0dST1VQPXkKQ09ORklHX05FVF9FTUFUQ0g9eQpDT05GSUdfTkVUX0VN QVRDSF9TVEFDSz0zMgpDT05GSUdfTkVUX0VNQVRDSF9DTVA9bQpDT05GSUdfTkVUX0VNQVRDSF9O QllURT1tCkNPTkZJR19ORVRfRU1BVENIX1UzMj1tCkNPTkZJR19ORVRfRU1BVENIX01FVEE9bQpD T05GSUdfTkVUX0VNQVRDSF9URVhUPW0KQ09ORklHX05FVF9DTFNfQUNUPXkKQ09ORklHX05FVF9B Q1RfUE9MSUNFPW0KQ09ORklHX05FVF9BQ1RfR0FDVD1tCkNPTkZJR19HQUNUX1BST0I9eQpDT05G SUdfTkVUX0FDVF9NSVJSRUQ9bQpDT05GSUdfTkVUX0FDVF9JUFQ9bQpDT05GSUdfTkVUX0FDVF9O QVQ9bQpDT05GSUdfTkVUX0FDVF9QRURJVD1tCkNPTkZJR19ORVRfQUNUX1NJTVA9bQpDT05GSUdf TkVUX0FDVF9TS0JFRElUPW0KIyBDT05GSUdfTkVUX0FDVF9DU1VNIGlzIG5vdCBzZXQKQ09ORklH X05FVF9DTFNfSU5EPXkKQ09ORklHX05FVF9TQ0hfRklGTz15CkNPTkZJR19EQ0I9eQpDT05GSUdf RE5TX1JFU09MVkVSPXkKQ09ORklHX0JBVE1BTl9BRFY9bQpDT05GSUdfQkFUTUFOX0FEVl9ERUJV Rz15CkNPTkZJR19PUEVOVlNXSVRDSD1tCkNPTkZJR19SUFM9eQpDT05GSUdfUkZTX0FDQ0VMPXkK Q09ORklHX1hQUz15CkNPTkZJR19ORVRQUklPX0NHUk9VUD1tCkNPTkZJR19CUUw9eQpDT05GSUdf SEFWRV9CUEZfSklUPXkKQ09ORklHX0JQRl9KSVQ9eQoKIwojIE5ldHdvcmsgdGVzdGluZwojCkNP TkZJR19ORVRfUEtUR0VOPW0KQ09ORklHX05FVF9UQ1BQUk9CRT1tCiMgQ09ORklHX05FVF9EUk9Q X01PTklUT1IgaXMgbm90IHNldApDT05GSUdfSEFNUkFESU89eQoKIwojIFBhY2tldCBSYWRpbyBw cm90b2NvbHMKIwpDT05GSUdfQVgyNT1tCkNPTkZJR19BWDI1X0RBTUFfU0xBVkU9eQpDT05GSUdf TkVUUk9NPW0KQ09ORklHX1JPU0U9bQoKIwojIEFYLjI1IG5ldHdvcmsgZGV2aWNlIGRyaXZlcnMK IwpDT05GSUdfTUtJU1M9bQpDT05GSUdfNlBBQ0s9bQpDT05GSUdfQlBRRVRIRVI9bQpDT05GSUdf QkFZQ09NX1NFUl9GRFg9bQpDT05GSUdfQkFZQ09NX1NFUl9IRFg9bQpDT05GSUdfQkFZQ09NX1BB Uj1tCkNPTkZJR19ZQU09bQpDT05GSUdfQ0FOPW0KQ09ORklHX0NBTl9SQVc9bQpDT05GSUdfQ0FO X0JDTT1tCkNPTkZJR19DQU5fR1c9bQoKIwojIENBTiBEZXZpY2UgRHJpdmVycwojCkNPTkZJR19D QU5fVkNBTj1tCiMgQ09ORklHX0NBTl9TTENBTiBpcyBub3Qgc2V0CkNPTkZJR19DQU5fREVWPW0K Q09ORklHX0NBTl9DQUxDX0JJVFRJTUlORz15CkNPTkZJR19DQU5fTUNQMjUxWD1tCkNPTkZJR19D QU5fSkFOWl9JQ0FOMz1tCiMgQ09ORklHX1BDSF9DQU4gaXMgbm90IHNldApDT05GSUdfQ0FOX1NK QTEwMDA9bQpDT05GSUdfQ0FOX1NKQTEwMDBfSVNBPW0KQ09ORklHX0NBTl9TSkExMDAwX1BMQVRG T1JNPW0KQ09ORklHX0NBTl9FTVNfUENNQ0lBPW0KQ09ORklHX0NBTl9FTVNfUENJPW0KQ09ORklH X0NBTl9QRUFLX1BDTUNJQT1tCkNPTkZJR19DQU5fUEVBS19QQ0k9bQpDT05GSUdfQ0FOX1BFQUtf UENJRUM9eQpDT05GSUdfQ0FOX0tWQVNFUl9QQ0k9bQpDT05GSUdfQ0FOX1BMWF9QQ0k9bQojIENP TkZJR19DQU5fQ19DQU4gaXMgbm90IHNldApDT05GSUdfQ0FOX0NDNzcwPW0KQ09ORklHX0NBTl9D Qzc3MF9JU0E9bQpDT05GSUdfQ0FOX0NDNzcwX1BMQVRGT1JNPW0KCiMKIyBDQU4gVVNCIGludGVy ZmFjZXMKIwpDT05GSUdfQ0FOX0VNU19VU0I9bQojIENPTkZJR19DQU5fRVNEX1VTQjIgaXMgbm90 IHNldApDT05GSUdfQ0FOX1BFQUtfVVNCPW0KIyBDT05GSUdfQ0FOX1NPRlRJTkcgaXMgbm90IHNl dAojIENPTkZJR19DQU5fREVCVUdfREVWSUNFUyBpcyBub3Qgc2V0CkNPTkZJR19JUkRBPW0KCiMK IyBJckRBIHByb3RvY29scwojCkNPTkZJR19JUkxBTj1tCkNPTkZJR19JUk5FVD1tCkNPTkZJR19J UkNPTU09bQpDT05GSUdfSVJEQV9VTFRSQT15CgojCiMgSXJEQSBvcHRpb25zCiMKQ09ORklHX0lS REFfQ0FDSEVfTEFTVF9MU0FQPXkKIyBDT05GSUdfSVJEQV9GQVNUX1JSIGlzIG5vdCBzZXQKIyBD T05GSUdfSVJEQV9ERUJVRyBpcyBub3Qgc2V0CgojCiMgSW5mcmFyZWQtcG9ydCBkZXZpY2UgZHJp dmVycwojCgojCiMgU0lSIGRldmljZSBkcml2ZXJzCiMKQ09ORklHX0lSVFRZX1NJUj1tCgojCiMg RG9uZ2xlIHN1cHBvcnQKIwpDT05GSUdfRE9OR0xFPXkKQ09ORklHX0VTSV9ET05HTEU9bQpDT05G SUdfQUNUSVNZU19ET05HTEU9bQpDT05GSUdfVEVLUkFNX0RPTkdMRT1tCkNPTkZJR19UT0lNMzIz Ml9ET05HTEU9bQpDT05GSUdfTElURUxJTktfRE9OR0xFPW0KQ09ORklHX01BNjAwX0RPTkdMRT1t CkNPTkZJR19HSVJCSUxfRE9OR0xFPW0KQ09ORklHX01DUDIxMjBfRE9OR0xFPW0KQ09ORklHX09M RF9CRUxLSU5fRE9OR0xFPW0KQ09ORklHX0FDVDIwMExfRE9OR0xFPW0KQ09ORklHX0tJTkdTVU5f RE9OR0xFPW0KQ09ORklHX0tTREFaWkxFX0RPTkdMRT1tCkNPTkZJR19LUzk1OV9ET05HTEU9bQoK IwojIEZJUiBkZXZpY2UgZHJpdmVycwojCkNPTkZJR19VU0JfSVJEQT1tCkNPTkZJR19TSUdNQVRF TF9GSVI9bQpDT05GSUdfTlNDX0ZJUj1tCkNPTkZJR19XSU5CT05EX0ZJUj1tCkNPTkZJR19TTUNf SVJDQ19GSVI9bQpDT05GSUdfQUxJX0ZJUj1tCkNPTkZJR19WTFNJX0ZJUj1tCkNPTkZJR19WSUFf RklSPW0KQ09ORklHX01DU19GSVI9bQpDT05GSUdfQlQ9bQpDT05GSUdfQlRfUkZDT01NPW0KQ09O RklHX0JUX1JGQ09NTV9UVFk9eQpDT05GSUdfQlRfQk5FUD1tCkNPTkZJR19CVF9CTkVQX01DX0ZJ TFRFUj15CkNPTkZJR19CVF9CTkVQX1BST1RPX0ZJTFRFUj15CkNPTkZJR19CVF9DTVRQPW0KQ09O RklHX0JUX0hJRFA9bQoKIwojIEJsdWV0b290aCBkZXZpY2UgZHJpdmVycwojCkNPTkZJR19CVF9I Q0lCVFVTQj1tCkNPTkZJR19CVF9IQ0lCVFNESU89bQpDT05GSUdfQlRfSENJVUFSVD1tCkNPTkZJ R19CVF9IQ0lVQVJUX0g0PXkKQ09ORklHX0JUX0hDSVVBUlRfQkNTUD15CiMgQ09ORklHX0JUX0hD SVVBUlRfQVRIM0sgaXMgbm90IHNldApDT05GSUdfQlRfSENJVUFSVF9MTD15CkNPTkZJR19CVF9I Q0lCQ00yMDNYPW0KQ09ORklHX0JUX0hDSUJQQTEwWD1tCkNPTkZJR19CVF9IQ0lCRlVTQj1tCkNP TkZJR19CVF9IQ0lEVEwxPW0KQ09ORklHX0JUX0hDSUJUM0M9bQpDT05GSUdfQlRfSENJQkxVRUNB UkQ9bQpDT05GSUdfQlRfSENJQlRVQVJUPW0KQ09ORklHX0JUX0hDSVZIQ0k9bQpDT05GSUdfQlRf TVJWTD1tCkNPTkZJR19CVF9NUlZMX1NESU89bQpDT05GSUdfQlRfQVRIM0s9bQpDT05GSUdfQlRf V0lMSU5LPW0KQ09ORklHX0FGX1JYUlBDPW0KIyBDT05GSUdfQUZfUlhSUENfREVCVUcgaXMgbm90 IHNldApDT05GSUdfUlhLQUQ9bQpDT05GSUdfRklCX1JVTEVTPXkKQ09ORklHX1dJUkVMRVNTPXkK Q09ORklHX1dJUkVMRVNTX0VYVD15CkNPTkZJR19XRVhUX0NPUkU9eQpDT05GSUdfV0VYVF9QUk9D PXkKQ09ORklHX1dFWFRfU1BZPXkKQ09ORklHX1dFWFRfUFJJVj15CkNPTkZJR19DRkc4MDIxMT1t CkNPTkZJR19OTDgwMjExX1RFU1RNT0RFPXkKIyBDT05GSUdfQ0ZHODAyMTFfREVWRUxPUEVSX1dB Uk5JTkdTIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0ZHODAyMTFfUkVHX0RFQlVHIGlzIG5vdCBzZXQK Q09ORklHX0NGRzgwMjExX0RFRkFVTFRfUFM9eQojIENPTkZJR19DRkc4MDIxMV9ERUJVR0ZTIGlz IG5vdCBzZXQKIyBDT05GSUdfQ0ZHODAyMTFfSU5URVJOQUxfUkVHREIgaXMgbm90IHNldApDT05G SUdfQ0ZHODAyMTFfV0VYVD15CkNPTkZJR19XSVJFTEVTU19FWFRfU1lTRlM9eQpDT05GSUdfTElC ODAyMTE9bQpDT05GSUdfTElCODAyMTFfQ1JZUFRfV0VQPW0KQ09ORklHX0xJQjgwMjExX0NSWVBU X0NDTVA9bQpDT05GSUdfTElCODAyMTFfQ1JZUFRfVEtJUD1tCiMgQ09ORklHX0xJQjgwMjExX0RF QlVHIGlzIG5vdCBzZXQKQ09ORklHX01BQzgwMjExPW0KQ09ORklHX01BQzgwMjExX0hBU19SQz15 CkNPTkZJR19NQUM4MDIxMV9SQ19NSU5TVFJFTD15CkNPTkZJR19NQUM4MDIxMV9SQ19NSU5TVFJF TF9IVD15CkNPTkZJR19NQUM4MDIxMV9SQ19ERUZBVUxUX01JTlNUUkVMPXkKQ09ORklHX01BQzgw MjExX1JDX0RFRkFVTFQ9Im1pbnN0cmVsX2h0IgpDT05GSUdfTUFDODAyMTFfTUVTSD15CkNPTkZJ R19NQUM4MDIxMV9MRURTPXkKQ09ORklHX01BQzgwMjExX0RFQlVHRlM9eQojIENPTkZJR19NQUM4 MDIxMV9ERUJVR19NRU5VIGlzIG5vdCBzZXQKQ09ORklHX1dJTUFYPW0KQ09ORklHX1dJTUFYX0RF QlVHX0xFVkVMPTgKQ09ORklHX1JGS0lMTD1tCkNPTkZJR19SRktJTExfTEVEUz15CkNPTkZJR19S RktJTExfSU5QVVQ9eQpDT05GSUdfUkZLSUxMX1JFR1VMQVRPUj1tCkNPTkZJR19ORVRfOVA9bQpD T05GSUdfTkVUXzlQX1ZJUlRJTz1tCkNPTkZJR19ORVRfOVBfUkRNQT1tCiMgQ09ORklHX05FVF85 UF9ERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX0NBSUYgaXMgbm90IHNldApDT05GSUdfQ0VQSF9M SUI9bQojIENPTkZJR19DRVBIX0xJQl9QUkVUVFlERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX0NF UEhfTElCX1VTRV9ETlNfUkVTT0xWRVIgaXMgbm90IHNldApDT05GSUdfTkZDPW0KQ09ORklHX05G Q19OQ0k9bQojIENPTkZJR19ORkNfTExDUCBpcyBub3Qgc2V0CgojCiMgTmVhciBGaWVsZCBDb21t dW5pY2F0aW9uIChORkMpIGRldmljZXMKIwpDT05GSUdfUE41NDRfTkZDPW0KQ09ORklHX05GQ19Q TjUzMz1tCkNPTkZJR19ORkNfV0lMSU5LPW0KCiMKIyBEZXZpY2UgRHJpdmVycwojCgojCiMgR2Vu ZXJpYyBEcml2ZXIgT3B0aW9ucwojCkNPTkZJR19VRVZFTlRfSEVMUEVSX1BBVEg9IiIKQ09ORklH X0RFVlRNUEZTPXkKQ09ORklHX0RFVlRNUEZTX01PVU5UPXkKIyBDT05GSUdfU1RBTkRBTE9ORSBp cyBub3Qgc2V0CkNPTkZJR19QUkVWRU5UX0ZJUk1XQVJFX0JVSUxEPXkKQ09ORklHX0ZXX0xPQURF Uj15CiMgQ09ORklHX0ZJUk1XQVJFX0lOX0tFUk5FTCBpcyBub3Qgc2V0CkNPTkZJR19FWFRSQV9G SVJNV0FSRT0iIgojIENPTkZJR19ERUJVR19EUklWRVIgaXMgbm90IHNldAojIENPTkZJR19ERUJV R19ERVZSRVMgaXMgbm90IHNldApDT05GSUdfU1lTX0hZUEVSVklTT1I9eQojIENPTkZJR19HRU5F UklDX0NQVV9ERVZJQ0VTIGlzIG5vdCBzZXQKQ09ORklHX1JFR01BUD15CkNPTkZJR19SRUdNQVBf STJDPW0KQ09ORklHX1JFR01BUF9TUEk9eQpDT05GSUdfUkVHTUFQX0lSUT15CkNPTkZJR19ETUFf U0hBUkVEX0JVRkZFUj15CkNPTkZJR19DT05ORUNUT1I9eQpDT05GSUdfUFJPQ19FVkVOVFM9eQpD T05GSUdfTVREPW0KQ09ORklHX01URF9URVNUUz1tCkNPTkZJR19NVERfUkVEQk9PVF9QQVJUUz1t CkNPTkZJR19NVERfUkVEQk9PVF9ESVJFQ1RPUllfQkxPQ0s9LTEKIyBDT05GSUdfTVREX1JFREJP T1RfUEFSVFNfVU5BTExPQ0FURUQgaXMgbm90IHNldAojIENPTkZJR19NVERfUkVEQk9PVF9QQVJU U19SRUFET05MWSBpcyBub3Qgc2V0CkNPTkZJR19NVERfQVI3X1BBUlRTPW0KCiMKIyBVc2VyIE1v ZHVsZXMgQW5kIFRyYW5zbGF0aW9uIExheWVycwojCkNPTkZJR19NVERfQ0hBUj1tCkNPTkZJR19I QVZFX01URF9PVFA9eQpDT05GSUdfTVREX0JMS0RFVlM9bQpDT05GSUdfTVREX0JMT0NLPW0KQ09O RklHX01URF9CTE9DS19STz1tCkNPTkZJR19GVEw9bQpDT05GSUdfTkZUTD1tCkNPTkZJR19ORlRM X1JXPXkKQ09ORklHX0lORlRMPW0KQ09ORklHX1JGRF9GVEw9bQpDT05GSUdfU1NGREM9bQojIENP TkZJR19TTV9GVEwgaXMgbm90IHNldApDT05GSUdfTVREX09PUFM9bQpDT05GSUdfTVREX1NXQVA9 bQoKIwojIFJBTS9ST00vRmxhc2ggY2hpcCBkcml2ZXJzCiMKQ09ORklHX01URF9DRkk9bQpDT05G SUdfTVREX0pFREVDUFJPQkU9bQpDT05GSUdfTVREX0dFTl9QUk9CRT1tCkNPTkZJR19NVERfQ0ZJ X0FEVl9PUFRJT05TPXkKQ09ORklHX01URF9DRklfTk9TV0FQPXkKIyBDT05GSUdfTVREX0NGSV9C RV9CWVRFX1NXQVAgaXMgbm90IHNldAojIENPTkZJR19NVERfQ0ZJX0xFX0JZVEVfU1dBUCBpcyBu b3Qgc2V0CkNPTkZJR19NVERfQ0ZJX0dFT01FVFJZPXkKQ09ORklHX01URF9NQVBfQkFOS19XSURU SF8xPXkKQ09ORklHX01URF9NQVBfQkFOS19XSURUSF8yPXkKQ09ORklHX01URF9NQVBfQkFOS19X SURUSF80PXkKQ09ORklHX01URF9NQVBfQkFOS19XSURUSF84PXkKQ09ORklHX01URF9NQVBfQkFO S19XSURUSF8xNj15CkNPTkZJR19NVERfTUFQX0JBTktfV0lEVEhfMzI9eQpDT05GSUdfTVREX0NG SV9JMT15CkNPTkZJR19NVERfQ0ZJX0kyPXkKQ09ORklHX01URF9DRklfSTQ9eQpDT05GSUdfTVRE X0NGSV9JOD15CkNPTkZJR19NVERfT1RQPXkKQ09ORklHX01URF9DRklfSU5URUxFWFQ9bQpDT05G SUdfTVREX0NGSV9BTURTVEQ9bQpDT05GSUdfTVREX0NGSV9TVEFBPW0KQ09ORklHX01URF9DRklf VVRJTD1tCkNPTkZJR19NVERfUkFNPW0KQ09ORklHX01URF9ST009bQpDT05GSUdfTVREX0FCU0VO VD1tCgojCiMgTWFwcGluZyBkcml2ZXJzIGZvciBjaGlwIGFjY2VzcwojCkNPTkZJR19NVERfQ09N UExFWF9NQVBQSU5HUz15CkNPTkZJR19NVERfUEhZU01BUD1tCkNPTkZJR19NVERfUEhZU01BUF9D T01QQVQ9eQpDT05GSUdfTVREX1BIWVNNQVBfU1RBUlQ9MHg4MDAwMDAwCkNPTkZJR19NVERfUEhZ U01BUF9MRU49MApDT05GSUdfTVREX1BIWVNNQVBfQkFOS1dJRFRIPTIKQ09ORklHX01URF9TQzUy MENEUD1tCkNPTkZJR19NVERfTkVUU0M1MjA9bQpDT05GSUdfTVREX1RTNTUwMD1tCkNPTkZJR19N VERfU0JDX0dYWD1tCkNPTkZJR19NVERfQU1ENzZYUk9NPW0KQ09ORklHX01URF9JQ0hYUk9NPW0K Q09ORklHX01URF9FU0IyUk9NPW0KQ09ORklHX01URF9DSzgwNFhST009bQpDT05GSUdfTVREX1ND QjJfRkxBU0g9bQpDT05GSUdfTVREX05FVHRlbD1tCkNPTkZJR19NVERfTDQ0MEdYPW0KQ09ORklH X01URF9QQ0k9bQojIENPTkZJR19NVERfUENNQ0lBIGlzIG5vdCBzZXQKQ09ORklHX01URF9HUElP X0FERFI9bQpDT05GSUdfTVREX0lOVEVMX1ZSX05PUj1tCkNPTkZJR19NVERfUExBVFJBTT1tCkNP TkZJR19NVERfTEFUQ0hfQUREUj1tCgojCiMgU2VsZi1jb250YWluZWQgTVREIGRldmljZSBkcml2 ZXJzCiMKQ09ORklHX01URF9QTUM1NTE9bQpDT05GSUdfTVREX1BNQzU1MV9CVUdGSVg9eQojIENP TkZJR19NVERfUE1DNTUxX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX01URF9EQVRBRkxBU0g9bQpD T05GSUdfTVREX0RBVEFGTEFTSF9XUklURV9WRVJJRlk9eQpDT05GSUdfTVREX0RBVEFGTEFTSF9P VFA9eQpDT05GSUdfTVREX00yNVA4MD1tCkNPTkZJR19NMjVQWFhfVVNFX0ZBU1RfUkVBRD15CkNP TkZJR19NVERfU1NUMjVMPW0KQ09ORklHX01URF9TTFJBTT1tCkNPTkZJR19NVERfUEhSQU09bQpD T05GSUdfTVREX01URFJBTT1tCkNPTkZJR19NVERSQU1fVE9UQUxfU0laRT00MDk2CkNPTkZJR19N VERSQU1fRVJBU0VfU0laRT0xMjgKQ09ORklHX01URF9CTE9DSzJNVEQ9bQoKIwojIERpc2stT24t Q2hpcCBEZXZpY2UgRHJpdmVycwojCkNPTkZJR19NVERfRE9DMjAwMD1tCkNPTkZJR19NVERfRE9D MjAwMT1tCkNPTkZJR19NVERfRE9DMjAwMVBMVVM9bQpDT05GSUdfTVREX0RPQ0czPW0KQ09ORklH X0JDSF9DT05TVF9NPTE0CkNPTkZJR19CQ0hfQ09OU1RfVD00CkNPTkZJR19NVERfRE9DUFJPQkU9 bQpDT05GSUdfTVREX0RPQ0VDQz1tCkNPTkZJR19NVERfRE9DUFJPQkVfQURWQU5DRUQ9eQpDT05G SUdfTVREX0RPQ1BST0JFX0FERFJFU1M9MHgwMDAwCkNPTkZJR19NVERfRE9DUFJPQkVfSElHSD15 CkNPTkZJR19NVERfRE9DUFJPQkVfNTVBQT15CkNPTkZJR19NVERfTkFORF9FQ0M9bQpDT05GSUdf TVREX05BTkRfRUNDX1NNQz15CkNPTkZJR19NVERfTkFORD1tCkNPTkZJR19NVERfTkFORF9WRVJJ RllfV1JJVEU9eQojIENPTkZJR19NVERfTkFORF9FQ0NfQkNIIGlzIG5vdCBzZXQKIyBDT05GSUdf TVREX1NNX0NPTU1PTiBpcyBub3Qgc2V0CkNPTkZJR19NVERfTkFORF9NVVNFVU1fSURTPXkKIyBD T05GSUdfTVREX05BTkRfREVOQUxJIGlzIG5vdCBzZXQKQ09ORklHX01URF9OQU5EX0lEUz1tCiMg Q09ORklHX01URF9OQU5EX1JJQ09IIGlzIG5vdCBzZXQKQ09ORklHX01URF9OQU5EX0RJU0tPTkNI SVA9bQpDT05GSUdfTVREX05BTkRfRElTS09OQ0hJUF9QUk9CRV9BRFZBTkNFRD15CkNPTkZJR19N VERfTkFORF9ESVNLT05DSElQX1BST0JFX0FERFJFU1M9MApDT05GSUdfTVREX05BTkRfRElTS09O Q0hJUF9QUk9CRV9ISUdIPXkKQ09ORklHX01URF9OQU5EX0RJU0tPTkNISVBfQkJUV1JJVEU9eQpD T05GSUdfTVREX05BTkRfRE9DRzQ9bQpDT05GSUdfTVREX05BTkRfQ0FGRT1tCkNPTkZJR19NVERf TkFORF9OQU5EU0lNPW0KQ09ORklHX01URF9OQU5EX1BMQVRGT1JNPW0KQ09ORklHX01URF9BTEFV REE9bQpDT05GSUdfTVREX09ORU5BTkQ9bQpDT05GSUdfTVREX09ORU5BTkRfVkVSSUZZX1dSSVRF PXkKQ09ORklHX01URF9PTkVOQU5EX0dFTkVSSUM9bQpDT05GSUdfTVREX09ORU5BTkRfT1RQPXkK Q09ORklHX01URF9PTkVOQU5EXzJYX1BST0dSQU09eQpDT05GSUdfTVREX09ORU5BTkRfU0lNPW0K CiMKIyBMUEREUiBmbGFzaCBtZW1vcnkgZHJpdmVycwojCkNPTkZJR19NVERfTFBERFI9bQpDT05G SUdfTVREX1FJTkZPX1BST0JFPW0KQ09ORklHX01URF9VQkk9bQpDT05GSUdfTVREX1VCSV9XTF9U SFJFU0hPTEQ9NDA5NgpDT05GSUdfTVREX1VCSV9CRUJfUkVTRVJWRT0xCkNPTkZJR19NVERfVUJJ X0dMVUVCST1tCiMgQ09ORklHX01URF9VQklfREVCVUcgaXMgbm90IHNldApDT05GSUdfUEFSUE9S VD1tCkNPTkZJR19QQVJQT1JUX1BDPW0KQ09ORklHX1BBUlBPUlRfU0VSSUFMPW0KQ09ORklHX1BB UlBPUlRfUENfRklGTz15CkNPTkZJR19QQVJQT1JUX1BDX1NVUEVSSU89eQpDT05GSUdfUEFSUE9S VF9QQ19QQ01DSUE9bQojIENPTkZJR19QQVJQT1JUX0dTQyBpcyBub3Qgc2V0CkNPTkZJR19QQVJQ T1JUX0FYODg3OTY9bQpDT05GSUdfUEFSUE9SVF8xMjg0PXkKQ09ORklHX1BBUlBPUlRfTk9UX1BD PXkKQ09ORklHX1BOUD15CiMgQ09ORklHX1BOUF9ERUJVR19NRVNTQUdFUyBpcyBub3Qgc2V0Cgoj CiMgUHJvdG9jb2xzCiMKQ09ORklHX1BOUEFDUEk9eQpDT05GSUdfQkxLX0RFVj15CkNPTkZJR19C TEtfREVWX0ZEPW0KQ09ORklHX1BBUklERT1tCgojCiMgUGFyYWxsZWwgSURFIGhpZ2gtbGV2ZWwg ZHJpdmVycwojCkNPTkZJR19QQVJJREVfUEQ9bQpDT05GSUdfUEFSSURFX1BDRD1tCkNPTkZJR19Q QVJJREVfUEY9bQpDT05GSUdfUEFSSURFX1BUPW0KQ09ORklHX1BBUklERV9QRz1tCgojCiMgUGFy YWxsZWwgSURFIHByb3RvY29sIG1vZHVsZXMKIwpDT05GSUdfUEFSSURFX0FURU49bQpDT05GSUdf UEFSSURFX0JQQ0s9bQpDT05GSUdfUEFSSURFX0NPTU09bQpDT05GSUdfUEFSSURFX0RTVFI9bQpD T05GSUdfUEFSSURFX0ZJVDI9bQpDT05GSUdfUEFSSURFX0ZJVDM9bQpDT05GSUdfUEFSSURFX0VQ QVQ9bQpDT05GSUdfUEFSSURFX0VQQVRDOD15CkNPTkZJR19QQVJJREVfRVBJQT1tCkNPTkZJR19Q QVJJREVfRlJJUT1tCkNPTkZJR19QQVJJREVfRlJQVz1tCkNPTkZJR19QQVJJREVfS0JJQz1tCkNP TkZJR19QQVJJREVfS1RUST1tCkNPTkZJR19QQVJJREVfT04yMD1tCkNPTkZJR19QQVJJREVfT04y Nj1tCkNPTkZJR19CTEtfREVWX1BDSUVTU0RfTVRJUDMyWFg9bQpDT05GSUdfQkxLX0NQUV9EQT1t CkNPTkZJR19CTEtfQ1BRX0NJU1NfREE9bQpDT05GSUdfQ0lTU19TQ1NJX1RBUEU9eQpDT05GSUdf QkxLX0RFVl9EQUM5NjA9bQpDT05GSUdfQkxLX0RFVl9VTUVNPW0KIyBDT05GSUdfQkxLX0RFVl9D T1dfQ09NTU9OIGlzIG5vdCBzZXQKQ09ORklHX0JMS19ERVZfTE9PUD15CkNPTkZJR19CTEtfREVW X0xPT1BfTUlOX0NPVU5UPTgKQ09ORklHX0JMS19ERVZfQ1JZUFRPTE9PUD1tCkNPTkZJR19CTEtf REVWX0RSQkQ9bQojIENPTkZJR19EUkJEX0ZBVUxUX0lOSkVDVElPTiBpcyBub3Qgc2V0CkNPTkZJ R19CTEtfREVWX05CRD1tCkNPTkZJR19CTEtfREVWX05WTUU9bQpDT05GSUdfQkxLX0RFVl9PU0Q9 bQpDT05GSUdfQkxLX0RFVl9TWDg9bQojIENPTkZJR19CTEtfREVWX1VCIGlzIG5vdCBzZXQKQ09O RklHX0JMS19ERVZfUkFNPW0KQ09ORklHX0JMS19ERVZfUkFNX0NPVU5UPTE2CkNPTkZJR19CTEtf REVWX1JBTV9TSVpFPTEzMTA3MgpDT05GSUdfQkxLX0RFVl9YSVA9eQpDT05GSUdfQ0RST01fUEtU Q0RWRD1tCkNPTkZJR19DRFJPTV9QS1RDRFZEX0JVRkZFUlM9OApDT05GSUdfQ0RST01fUEtUQ0RW RF9XQ0FDSEU9eQpDT05GSUdfQVRBX09WRVJfRVRIPW0KQ09ORklHX1hFTl9CTEtERVZfRlJPTlRF TkQ9bQpDT05GSUdfWEVOX0JMS0RFVl9CQUNLRU5EPW0KQ09ORklHX1ZJUlRJT19CTEs9bQojIENP TkZJR19CTEtfREVWX0hEIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9SQkQgaXMgbm90IHNl dAoKIwojIE1pc2MgZGV2aWNlcwojCkNPTkZJR19TRU5TT1JTX0xJUzNMVjAyRD1tCkNPTkZJR19B RDUyNVhfRFBPVD1tCiMgQ09ORklHX0FENTI1WF9EUE9UX0kyQyBpcyBub3Qgc2V0CiMgQ09ORklH X0FENTI1WF9EUE9UX1NQSSBpcyBub3Qgc2V0CkNPTkZJR19JQk1fQVNNPW0KQ09ORklHX1BIQU5U T009bQojIENPTkZJR19JTlRFTF9NSURfUFRJIGlzIG5vdCBzZXQKQ09ORklHX1NHSV9JT0M0PW0K Q09ORklHX1RJRk1fQ09SRT1tCkNPTkZJR19USUZNXzdYWDE9bQpDT05GSUdfSUNTOTMyUzQwMT1t CkNPTkZJR19FTkNMT1NVUkVfU0VSVklDRVM9bQpDT05GSUdfQ1M1NTM1X01GR1BUPW0KQ09ORklH X0NTNTUzNV9NRkdQVF9ERUZBVUxUX0lSUT03CkNPTkZJR19DUzU1MzVfQ0xPQ0tfRVZFTlRfU1JD PW0KQ09ORklHX0hQX0lMTz1tCkNPTkZJR19BUERTOTgwMkFMUz1tCiMgQ09ORklHX0lTTDI5MDAz IGlzIG5vdCBzZXQKQ09ORklHX0lTTDI5MDIwPW0KQ09ORklHX1NFTlNPUlNfVFNMMjU1MD1tCkNP TkZJR19TRU5TT1JTX0JIMTc4MD1tCkNPTkZJR19TRU5TT1JTX0JIMTc3MD1tCkNPTkZJR19TRU5T T1JTX0FQRFM5OTBYPW0KQ09ORklHX0hNQzYzNTI9bQpDT05GSUdfRFMxNjgyPW0KQ09ORklHX1RJ X0RBQzc1MTI9bQojIENPTkZJR19WTVdBUkVfQkFMTE9PTiBpcyBub3Qgc2V0CkNPTkZJR19CTVAw ODU9bQpDT05GSUdfUENIX1BIVUI9bQpDT05GSUdfVVNCX1NXSVRDSF9GU0E5NDgwPW0KQ09ORklH X0MyUE9SVD1tCkNPTkZJR19DMlBPUlRfRFVSQU1BUl8yMTUwPW0KCiMKIyBFRVBST00gc3VwcG9y dAojCkNPTkZJR19FRVBST01fQVQyND1tCkNPTkZJR19FRVBST01fQVQyNT1tCkNPTkZJR19FRVBS T01fTEVHQUNZPW0KQ09ORklHX0VFUFJPTV9NQVg2ODc1PW0KQ09ORklHX0VFUFJPTV85M0NYNj1t CkNPTkZJR19FRVBST01fOTNYWDQ2PW0KQ09ORklHX0NCNzEwX0NPUkU9bQojIENPTkZJR19DQjcx MF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19DQjcxMF9ERUJVR19BU1NVTVBUSU9OUz15CkNPTkZJ R19JV01DMzIwMFRPUD1tCiMgQ09ORklHX0lXTUMzMjAwVE9QX0RFQlVHIGlzIG5vdCBzZXQKIyBD T05GSUdfSVdNQzMyMDBUT1BfREVCVUdGUyBpcyBub3Qgc2V0CgojCiMgVGV4YXMgSW5zdHJ1bWVu dHMgc2hhcmVkIHRyYW5zcG9ydCBsaW5lIGRpc2NpcGxpbmUKIwpDT05GSUdfVElfU1Q9bQpDT05G SUdfU0VOU09SU19MSVMzX0kyQz1tCgojCiMgQWx0ZXJhIEZQR0EgZmlybXdhcmUgZG93bmxvYWQg bW9kdWxlCiMKQ09ORklHX0FMVEVSQV9TVEFQTD1tCkNPTkZJR19IQVZFX0lERT15CiMgQ09ORklH X0lERSBpcyBub3Qgc2V0CgojCiMgU0NTSSBkZXZpY2Ugc3VwcG9ydAojCkNPTkZJR19TQ1NJX01P RD1tCkNPTkZJR19SQUlEX0FUVFJTPW0KQ09ORklHX1NDU0k9bQpDT05GSUdfU0NTSV9ETUE9eQpD T05GSUdfU0NTSV9UR1Q9bQpDT05GSUdfU0NTSV9ORVRMSU5LPXkKQ09ORklHX1NDU0lfUFJPQ19G Uz15CgojCiMgU0NTSSBzdXBwb3J0IHR5cGUgKGRpc2ssIHRhcGUsIENELVJPTSkKIwpDT05GSUdf QkxLX0RFVl9TRD1tCkNPTkZJR19DSFJfREVWX1NUPW0KQ09ORklHX0NIUl9ERVZfT1NTVD1tCkNP TkZJR19CTEtfREVWX1NSPW0KIyBDT05GSUdfQkxLX0RFVl9TUl9WRU5ET1IgaXMgbm90IHNldApD T05GSUdfQ0hSX0RFVl9TRz1tCkNPTkZJR19DSFJfREVWX1NDSD1tCkNPTkZJR19TQ1NJX0VOQ0xP U1VSRT1tCkNPTkZJR19TQ1NJX01VTFRJX0xVTj15CkNPTkZJR19TQ1NJX0NPTlNUQU5UUz15CkNP TkZJR19TQ1NJX0xPR0dJTkc9eQojIENPTkZJR19TQ1NJX1NDQU5fQVNZTkMgaXMgbm90IHNldApD T05GSUdfU0NTSV9XQUlUX1NDQU49bQoKIwojIFNDU0kgVHJhbnNwb3J0cwojCkNPTkZJR19TQ1NJ X1NQSV9BVFRSUz1tCkNPTkZJR19TQ1NJX0ZDX0FUVFJTPW0KQ09ORklHX1NDU0lfRkNfVEdUX0FU VFJTPXkKQ09ORklHX1NDU0lfSVNDU0lfQVRUUlM9bQpDT05GSUdfU0NTSV9TQVNfQVRUUlM9bQpD T05GSUdfU0NTSV9TQVNfTElCU0FTPW0KQ09ORklHX1NDU0lfU0FTX0FUQT15CkNPTkZJR19TQ1NJ X1NBU19IT1NUX1NNUD15CkNPTkZJR19TQ1NJX1NSUF9BVFRSUz1tCkNPTkZJR19TQ1NJX1NSUF9U R1RfQVRUUlM9eQpDT05GSUdfU0NTSV9MT1dMRVZFTD15CkNPTkZJR19JU0NTSV9UQ1A9bQpDT05G SUdfSVNDU0lfQk9PVF9TWVNGUz1tCkNPTkZJR19TQ1NJX0NYR0IzX0lTQ1NJPW0KQ09ORklHX1ND U0lfQ1hHQjRfSVNDU0k9bQpDT05GSUdfU0NTSV9CTlgyX0lTQ1NJPW0KQ09ORklHX1NDU0lfQk5Y MlhfRkNPRT1tCkNPTkZJR19CRTJJU0NTST1tCkNPTkZJR19CTEtfREVWXzNXX1hYWFhfUkFJRD1t CkNPTkZJR19TQ1NJX0hQU0E9bQpDT05GSUdfU0NTSV8zV185WFhYPW0KQ09ORklHX1NDU0lfM1df U0FTPW0KQ09ORklHX1NDU0lfQUNBUkQ9bQpDT05GSUdfU0NTSV9BQUNSQUlEPW0KQ09ORklHX1ND U0lfQUlDN1hYWD1tCkNPTkZJR19BSUM3WFhYX0NNRFNfUEVSX0RFVklDRT0zMgpDT05GSUdfQUlD N1hYWF9SRVNFVF9ERUxBWV9NUz0xNTAwMAojIENPTkZJR19BSUM3WFhYX0RFQlVHX0VOQUJMRSBp cyBub3Qgc2V0CkNPTkZJR19BSUM3WFhYX0RFQlVHX01BU0s9MApDT05GSUdfQUlDN1hYWF9SRUdf UFJFVFRZX1BSSU5UPXkKQ09ORklHX1NDU0lfQUlDN1hYWF9PTEQ9bQpDT05GSUdfU0NTSV9BSUM3 OVhYPW0KQ09ORklHX0FJQzc5WFhfQ01EU19QRVJfREVWSUNFPTMyCkNPTkZJR19BSUM3OVhYX1JF U0VUX0RFTEFZX01TPTUwMDAKIyBDT05GSUdfQUlDNzlYWF9ERUJVR19FTkFCTEUgaXMgbm90IHNl dApDT05GSUdfQUlDNzlYWF9ERUJVR19NQVNLPTAKQ09ORklHX0FJQzc5WFhfUkVHX1BSRVRUWV9Q UklOVD15CkNPTkZJR19TQ1NJX0FJQzk0WFg9bQojIENPTkZJR19BSUM5NFhYX0RFQlVHIGlzIG5v dCBzZXQKQ09ORklHX1NDU0lfTVZTQVM9bQojIENPTkZJR19TQ1NJX01WU0FTX0RFQlVHIGlzIG5v dCBzZXQKQ09ORklHX1NDU0lfTVZTQVNfVEFTS0xFVD15CkNPTkZJR19TQ1NJX01WVU1JPW0KQ09O RklHX1NDU0lfRFBUX0kyTz1tCkNPTkZJR19TQ1NJX0FEVkFOU1lTPW0KQ09ORklHX1NDU0lfQVJD TVNSPW0KQ09ORklHX01FR0FSQUlEX05FV0dFTj15CkNPTkZJR19NRUdBUkFJRF9NTT1tCkNPTkZJ R19NRUdBUkFJRF9NQUlMQk9YPW0KQ09ORklHX01FR0FSQUlEX0xFR0FDWT1tCkNPTkZJR19NRUdB UkFJRF9TQVM9bQpDT05GSUdfU0NTSV9NUFQyU0FTPW0KQ09ORklHX1NDU0lfTVBUMlNBU19NQVhf U0dFPTEyOAojIENPTkZJR19TQ1NJX01QVDJTQVNfTE9HR0lORyBpcyBub3Qgc2V0CkNPTkZJR19T Q1NJX1VGU0hDRD1tCkNPTkZJR19TQ1NJX0hQVElPUD1tCkNPTkZJR19TQ1NJX0JVU0xPR0lDPW0K IyBDT05GSUdfVk1XQVJFX1BWU0NTSSBpcyBub3Qgc2V0CkNPTkZJR19MSUJGQz1tCkNPTkZJR19M SUJGQ09FPW0KQ09ORklHX0ZDT0U9bQpDT05GSUdfRkNPRV9GTklDPW0KQ09ORklHX1NDU0lfRE1Y MzE5MUQ9bQpDT05GSUdfU0NTSV9FQVRBPW0KQ09ORklHX1NDU0lfRUFUQV9UQUdHRURfUVVFVUU9 eQpDT05GSUdfU0NTSV9FQVRBX0xJTktFRF9DT01NQU5EUz15CkNPTkZJR19TQ1NJX0VBVEFfTUFY X1RBR1M9MTYKQ09ORklHX1NDU0lfRlVUVVJFX0RPTUFJTj1tCkNPTkZJR19TQ1NJX0dEVEg9bQpD T05GSUdfU0NTSV9JU0NJPW0KQ09ORklHX1NDU0lfSVBTPW0KQ09ORklHX1NDU0lfSU5JVElPPW0K Q09ORklHX1NDU0lfSU5JQTEwMD1tCkNPTkZJR19TQ1NJX1BQQT1tCkNPTkZJR19TQ1NJX0lNTT1t CiMgQ09ORklHX1NDU0lfSVpJUF9FUFAxNiBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfSVpJUF9T TE9XX0NUUiBpcyBub3Qgc2V0CkNPTkZJR19TQ1NJX1NURVg9bQpDT05GSUdfU0NTSV9TWU01M0M4 WFhfMj1tCkNPTkZJR19TQ1NJX1NZTTUzQzhYWF9ETUFfQUREUkVTU0lOR19NT0RFPTEKQ09ORklH X1NDU0lfU1lNNTNDOFhYX0RFRkFVTFRfVEFHUz0xNgpDT05GSUdfU0NTSV9TWU01M0M4WFhfTUFY X1RBR1M9NjQKQ09ORklHX1NDU0lfU1lNNTNDOFhYX01NSU89eQpDT05GSUdfU0NTSV9JUFI9bQpD T05GSUdfU0NTSV9JUFJfVFJBQ0U9eQpDT05GSUdfU0NTSV9JUFJfRFVNUD15CkNPTkZJR19TQ1NJ X1FMT0dJQ18xMjgwPW0KQ09ORklHX1NDU0lfUUxBX0ZDPW0KQ09ORklHX1NDU0lfUUxBX0lTQ1NJ PW0KQ09ORklHX1NDU0lfTFBGQz1tCiMgQ09ORklHX1NDU0lfTFBGQ19ERUJVR19GUyBpcyBub3Qg c2V0CkNPTkZJR19TQ1NJX0RDMzk1eD1tCkNPTkZJR19TQ1NJX0RDMzkwVD1tCkNPTkZJR19TQ1NJ X0RFQlVHPW0KQ09ORklHX1NDU0lfUE1DUkFJRD1tCkNPTkZJR19TQ1NJX1BNODAwMT1tCkNPTkZJ R19TQ1NJX1NSUD1tCkNPTkZJR19TQ1NJX0JGQV9GQz1tCkNPTkZJR19TQ1NJX1ZJUlRJTz1tCkNP TkZJR19TQ1NJX0xPV0xFVkVMX1BDTUNJQT15CkNPTkZJR19QQ01DSUFfQUhBMTUyWD1tCkNPTkZJ R19QQ01DSUFfRkRPTUFJTj1tCkNPTkZJR19QQ01DSUFfUUxPR0lDPW0KQ09ORklHX1BDTUNJQV9T WU01M0M1MDA9bQpDT05GSUdfU0NTSV9ESD1tCkNPTkZJR19TQ1NJX0RIX1JEQUM9bQpDT05GSUdf U0NTSV9ESF9IUF9TVz1tCkNPTkZJR19TQ1NJX0RIX0VNQz1tCkNPTkZJR19TQ1NJX0RIX0FMVUE9 bQpDT05GSUdfU0NTSV9PU0RfSU5JVElBVE9SPW0KQ09ORklHX1NDU0lfT1NEX1VMRD1tCkNPTkZJ R19TQ1NJX09TRF9EUFJJTlRfU0VOU0U9MQojIENPTkZJR19TQ1NJX09TRF9ERUJVRyBpcyBub3Qg c2V0CkNPTkZJR19BVEE9bQojIENPTkZJR19BVEFfTk9OU1RBTkRBUkQgaXMgbm90IHNldApDT05G SUdfQVRBX1ZFUkJPU0VfRVJST1I9eQpDT05GSUdfQVRBX0FDUEk9eQpDT05GSUdfU0FUQV9QTVA9 eQoKIwojIENvbnRyb2xsZXJzIHdpdGggbm9uLVNGRiBuYXRpdmUgaW50ZXJmYWNlCiMKQ09ORklH X1NBVEFfQUhDST1tCkNPTkZJR19TQVRBX0FIQ0lfUExBVEZPUk09bQpDT05GSUdfU0FUQV9JTklD MTYyWD1tCkNPTkZJR19TQVRBX0FDQVJEX0FIQ0k9bQpDT05GSUdfU0FUQV9TSUwyND1tCkNPTkZJ R19BVEFfU0ZGPXkKCiMKIyBTRkYgY29udHJvbGxlcnMgd2l0aCBjdXN0b20gRE1BIGludGVyZmFj ZQojCkNPTkZJR19QRENfQURNQT1tCkNPTkZJR19TQVRBX1FTVE9SPW0KQ09ORklHX1NBVEFfU1g0 PW0KQ09ORklHX0FUQV9CTURNQT15CgojCiMgU0FUQSBTRkYgY29udHJvbGxlcnMgd2l0aCBCTURN QQojCkNPTkZJR19BVEFfUElJWD1tCkNPTkZJR19TQVRBX01WPW0KQ09ORklHX1NBVEFfTlY9bQpD T05GSUdfU0FUQV9QUk9NSVNFPW0KQ09ORklHX1NBVEFfU0lMPW0KQ09ORklHX1NBVEFfU0lTPW0K Q09ORklHX1NBVEFfU1ZXPW0KQ09ORklHX1NBVEFfVUxJPW0KQ09ORklHX1NBVEFfVklBPW0KQ09O RklHX1NBVEFfVklURVNTRT1tCgojCiMgUEFUQSBTRkYgY29udHJvbGxlcnMgd2l0aCBCTURNQQoj CkNPTkZJR19QQVRBX0FMST1tCkNPTkZJR19QQVRBX0FNRD1tCkNPTkZJR19QQVRBX0FSQVNBTl9D Rj1tCkNPTkZJR19QQVRBX0FSVE9QPW0KQ09ORklHX1BBVEFfQVRJSVhQPW0KQ09ORklHX1BBVEFf QVRQODY3WD1tCkNPTkZJR19QQVRBX0NNRDY0WD1tCkNPTkZJR19QQVRBX0NTNTUyMD1tCkNPTkZJ R19QQVRBX0NTNTUzMD1tCkNPTkZJR19QQVRBX0NTNTUzNj1tCkNPTkZJR19QQVRBX0NZUFJFU1M9 bQpDT05GSUdfUEFUQV9FRkFSPW0KQ09ORklHX1BBVEFfSFBUMzY2PW0KQ09ORklHX1BBVEFfSFBU MzdYPW0KQ09ORklHX1BBVEFfSFBUM1gyTj1tCkNPTkZJR19QQVRBX0hQVDNYMz1tCiMgQ09ORklH X1BBVEFfSFBUM1gzX0RNQSBpcyBub3Qgc2V0CkNPTkZJR19QQVRBX0lUODIxMz1tCkNPTkZJR19Q QVRBX0lUODIxWD1tCkNPTkZJR19QQVRBX0pNSUNST049bQpDT05GSUdfUEFUQV9NQVJWRUxMPW0K Q09ORklHX1BBVEFfTkVUQ0VMTD1tCkNPTkZJR19QQVRBX05JTkpBMzI9bQpDT05GSUdfUEFUQV9O Uzg3NDE1PW0KQ09ORklHX1BBVEFfT0xEUElJWD1tCkNPTkZJR19QQVRBX09QVElETUE9bQpDT05G SUdfUEFUQV9QREMyMDI3WD1tCkNPTkZJR19QQVRBX1BEQ19PTEQ9bQpDT05GSUdfUEFUQV9SQURJ U1lTPW0KQ09ORklHX1BBVEFfUkRDPW0KQ09ORklHX1BBVEFfU0MxMjAwPW0KQ09ORklHX1BBVEFf U0NIPW0KQ09ORklHX1BBVEFfU0VSVkVSV09SS1M9bQpDT05GSUdfUEFUQV9TSUw2ODA9bQpDT05G SUdfUEFUQV9TSVM9bQpDT05GSUdfUEFUQV9UT1NISUJBPW0KQ09ORklHX1BBVEFfVFJJRkxFWD1t CkNPTkZJR19QQVRBX1ZJQT1tCkNPTkZJR19QQVRBX1dJTkJPTkQ9bQoKIwojIFBJTy1vbmx5IFNG RiBjb250cm9sbGVycwojCkNPTkZJR19QQVRBX0NNRDY0MF9QQ0k9bQpDT05GSUdfUEFUQV9NUElJ WD1tCkNPTkZJR19QQVRBX05TODc0MTA9bQpDT05GSUdfUEFUQV9PUFRJPW0KQ09ORklHX1BBVEFf UENNQ0lBPW0KQ09ORklHX1BBVEFfUloxMDAwPW0KCiMKIyBHZW5lcmljIGZhbGxiYWNrIC8gbGVn YWN5IGRyaXZlcnMKIwpDT05GSUdfUEFUQV9BQ1BJPW0KQ09ORklHX0FUQV9HRU5FUklDPW0KIyBD T05GSUdfUEFUQV9MRUdBQ1kgaXMgbm90IHNldApDT05GSUdfTUQ9eQpDT05GSUdfQkxLX0RFVl9N RD15CkNPTkZJR19NRF9BVVRPREVURUNUPXkKQ09ORklHX01EX0xJTkVBUj1tCkNPTkZJR19NRF9S QUlEMD1tCkNPTkZJR19NRF9SQUlEMT1tCkNPTkZJR19NRF9SQUlEMTA9bQpDT05GSUdfTURfUkFJ RDQ1Nj1tCiMgQ09ORklHX01VTFRJQ09SRV9SQUlENDU2IGlzIG5vdCBzZXQKQ09ORklHX01EX01V TFRJUEFUSD1tCkNPTkZJR19NRF9GQVVMVFk9bQpDT05GSUdfQkxLX0RFVl9ETT15CiMgQ09ORklH X0RNX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0RNX0JVRklPPW0KQ09ORklHX0RNX1BFUlNJU1RF TlRfREFUQT1tCkNPTkZJR19ETV9DUllQVD1tCkNPTkZJR19ETV9TTkFQU0hPVD1tCkNPTkZJR19E TV9USElOX1BST1ZJU0lPTklORz1tCiMgQ09ORklHX0RNX0RFQlVHX0JMT0NLX1NUQUNLX1RSQUNJ TkcgaXMgbm90IHNldAojIENPTkZJR19ETV9ERUJVR19TUEFDRV9NQVBTIGlzIG5vdCBzZXQKQ09O RklHX0RNX01JUlJPUj1tCkNPTkZJR19ETV9SQUlEPW0KQ09ORklHX0RNX0xPR19VU0VSU1BBQ0U9 bQpDT05GSUdfRE1fWkVSTz1tCkNPTkZJR19ETV9NVUxUSVBBVEg9bQpDT05GSUdfRE1fTVVMVElQ QVRIX1FMPW0KQ09ORklHX0RNX01VTFRJUEFUSF9TVD1tCkNPTkZJR19ETV9ERUxBWT1tCkNPTkZJ R19ETV9VRVZFTlQ9eQpDT05GSUdfRE1fRkxBS0VZPW0KQ09ORklHX0RNX1ZFUklUWT1tCiMgQ09O RklHX1RBUkdFVF9DT1JFIGlzIG5vdCBzZXQKQ09ORklHX0ZVU0lPTj15CkNPTkZJR19GVVNJT05f U1BJPW0KQ09ORklHX0ZVU0lPTl9GQz1tCkNPTkZJR19GVVNJT05fU0FTPW0KQ09ORklHX0ZVU0lP Tl9NQVhfU0dFPTEyOApDT05GSUdfRlVTSU9OX0NUTD1tCkNPTkZJR19GVVNJT05fTEFOPW0KIyBD T05GSUdfRlVTSU9OX0xPR0dJTkcgaXMgbm90IHNldAoKIwojIElFRUUgMTM5NCAoRmlyZVdpcmUp IHN1cHBvcnQKIwpDT05GSUdfRklSRVdJUkU9bQpDT05GSUdfRklSRVdJUkVfT0hDST1tCkNPTkZJ R19GSVJFV0lSRV9TQlAyPW0KQ09ORklHX0ZJUkVXSVJFX05FVD1tCiMgQ09ORklHX0ZJUkVXSVJF X05PU1kgaXMgbm90IHNldApDT05GSUdfSTJPPW0KQ09ORklHX0kyT19MQ1RfTk9USUZZX09OX0NI QU5HRVM9eQpDT05GSUdfSTJPX0VYVF9BREFQVEVDPXkKQ09ORklHX0kyT19FWFRfQURBUFRFQ19E TUE2ND15CkNPTkZJR19JMk9fQ09ORklHPW0KQ09ORklHX0kyT19DT05GSUdfT0xEX0lPQ1RMPXkK Q09ORklHX0kyT19CVVM9bQpDT05GSUdfSTJPX0JMT0NLPW0KQ09ORklHX0kyT19TQ1NJPW0KQ09O RklHX0kyT19QUk9DPW0KQ09ORklHX01BQ0lOVE9TSF9EUklWRVJTPXkKQ09ORklHX01BQ19FTVVN T1VTRUJUTj1tCkNPTkZJR19ORVRERVZJQ0VTPXkKQ09ORklHX05FVF9DT1JFPXkKQ09ORklHX0JP TkRJTkc9bQpDT05GSUdfRFVNTVk9bQpDT05GSUdfRVFVQUxJWkVSPW0KQ09ORklHX05FVF9GQz15 CkNPTkZJR19NSUk9eQpDT05GSUdfSUVFRTgwMjE1NF9EUklWRVJTPW0KQ09ORklHX0lFRUU4MDIx NTRfRkFLRUhBUkQ9bQpDT05GSUdfSUZCPW0KQ09ORklHX05FVF9URUFNPW0KQ09ORklHX05FVF9U RUFNX01PREVfUk9VTkRST0JJTj1tCkNPTkZJR19ORVRfVEVBTV9NT0RFX0FDVElWRUJBQ0tVUD1t CkNPTkZJR19NQUNWTEFOPW0KQ09ORklHX01BQ1ZUQVA9bQpDT05GSUdfTkVUQ09OU09MRT1tCkNP TkZJR19ORVRDT05TT0xFX0RZTkFNSUM9eQpDT05GSUdfTkVUUE9MTD15CkNPTkZJR19ORVRQT0xM X1RSQVA9eQpDT05GSUdfTkVUX1BPTExfQ09OVFJPTExFUj15CkNPTkZJR19UVU49bQpDT05GSUdf VkVUSD1tCkNPTkZJR19WSVJUSU9fTkVUPW0KQ09ORklHX1NVTkdFTV9QSFk9bQpDT05GSUdfQVJD TkVUPW0KQ09ORklHX0FSQ05FVF8xMjAxPW0KQ09ORklHX0FSQ05FVF8xMDUxPW0KQ09ORklHX0FS Q05FVF9SQVc9bQpDT05GSUdfQVJDTkVUX0NBUD1tCkNPTkZJR19BUkNORVRfQ09NOTB4eD1tCkNP TkZJR19BUkNORVRfQ09NOTB4eElPPW0KQ09ORklHX0FSQ05FVF9SSU1fST1tCiMgQ09ORklHX0FS Q05FVF9DT00yMDAyMCBpcyBub3Qgc2V0CkNPTkZJR19BVE1fRFJJVkVSUz15CkNPTkZJR19BVE1f RFVNTVk9bQpDT05GSUdfQVRNX1RDUD1tCkNPTkZJR19BVE1fTEFOQUk9bQpDT05GSUdfQVRNX0VO ST1tCiMgQ09ORklHX0FUTV9FTklfREVCVUcgaXMgbm90IHNldApDT05GSUdfQVRNX0VOSV9UVU5F X0JVUlNUPXkKQ09ORklHX0FUTV9FTklfQlVSU1RfVFhfMTZXPXkKQ09ORklHX0FUTV9FTklfQlVS U1RfVFhfOFc9eQpDT05GSUdfQVRNX0VOSV9CVVJTVF9UWF80Vz15CkNPTkZJR19BVE1fRU5JX0JV UlNUX1RYXzJXPXkKQ09ORklHX0FUTV9FTklfQlVSU1RfUlhfMTZXPXkKQ09ORklHX0FUTV9FTklf QlVSU1RfUlhfOFc9eQpDT05GSUdfQVRNX0VOSV9CVVJTVF9SWF80Vz15CkNPTkZJR19BVE1fRU5J X0JVUlNUX1JYXzJXPXkKQ09ORklHX0FUTV9GSVJFU1RSRUFNPW0KQ09ORklHX0FUTV9aQVRNPW0K IyBDT05GSUdfQVRNX1pBVE1fREVCVUcgaXMgbm90IHNldApDT05GSUdfQVRNX05JQ1NUQVI9bQoj IENPTkZJR19BVE1fTklDU1RBUl9VU0VfU1VOSSBpcyBub3Qgc2V0CiMgQ09ORklHX0FUTV9OSUNT VEFSX1VTRV9JRFQ3NzEwNSBpcyBub3Qgc2V0CkNPTkZJR19BVE1fSURUNzcyNTI9bQojIENPTkZJ R19BVE1fSURUNzcyNTJfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19BVE1fSURUNzcyNTJfUkNW X0FMTCBpcyBub3Qgc2V0CkNPTkZJR19BVE1fSURUNzcyNTJfVVNFX1NVTkk9eQpDT05GSUdfQVRN X0FNQkFTU0FET1I9bQojIENPTkZJR19BVE1fQU1CQVNTQURPUl9ERUJVRyBpcyBub3Qgc2V0CkNP TkZJR19BVE1fSE9SSVpPTj1tCiMgQ09ORklHX0FUTV9IT1JJWk9OX0RFQlVHIGlzIG5vdCBzZXQK Q09ORklHX0FUTV9JQT1tCiMgQ09ORklHX0FUTV9JQV9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19B VE1fRk9SRTIwMEU9bQpDT05GSUdfQVRNX0ZPUkUyMDBFX1VTRV9UQVNLTEVUPXkKQ09ORklHX0FU TV9GT1JFMjAwRV9UWF9SRVRSWT0xNgpDT05GSUdfQVRNX0ZPUkUyMDBFX0RFQlVHPTAKQ09ORklH X0FUTV9IRT1tCkNPTkZJR19BVE1fSEVfVVNFX1NVTkk9eQpDT05GSUdfQVRNX1NPTE9TPW0KCiMK IyBDQUlGIHRyYW5zcG9ydCBkcml2ZXJzCiMKCiMKIyBEaXN0cmlidXRlZCBTd2l0Y2ggQXJjaGl0 ZWN0dXJlIGRyaXZlcnMKIwpDT05GSUdfTkVUX0RTQV9NVjg4RTZYWFg9eQpDT05GSUdfTkVUX0RT QV9NVjg4RTYwNjA9eQpDT05GSUdfTkVUX0RTQV9NVjg4RTZYWFhfTkVFRF9QUFU9eQpDT05GSUdf TkVUX0RTQV9NVjg4RTYxMzE9eQpDT05GSUdfTkVUX0RTQV9NVjg4RTYxMjNfNjFfNjU9eQpDT05G SUdfRVRIRVJORVQ9eQpDT05GSUdfTURJTz1tCkNPTkZJR19ORVRfVkVORE9SXzNDT009eQpDT05G SUdfUENNQ0lBXzNDNTc0PW0KQ09ORklHX1BDTUNJQV8zQzU4OT1tCkNPTkZJR19WT1JURVg9bQpD T05GSUdfVFlQSE9PTj1tCkNPTkZJR19ORVRfVkVORE9SX0FEQVBURUM9eQpDT05GSUdfQURBUFRF Q19TVEFSRklSRT1tCkNPTkZJR19ORVRfVkVORE9SX0FMVEVPTj15CkNPTkZJR19BQ0VOSUM9bQoj IENPTkZJR19BQ0VOSUNfT01JVF9USUdPTl9JIGlzIG5vdCBzZXQKQ09ORklHX05FVF9WRU5ET1Jf QU1EPXkKQ09ORklHX0FNRDgxMTFfRVRIPW0KQ09ORklHX1BDTkVUMzI9bQpDT05GSUdfUENNQ0lB X05NQ0xBTj1tCkNPTkZJR19ORVRfVkVORE9SX0FUSEVST1M9eQpDT05GSUdfQVRMMj1tCkNPTkZJ R19BVEwxPW0KQ09ORklHX0FUTDFFPW0KQ09ORklHX0FUTDFDPW0KQ09ORklHX05FVF9WRU5ET1Jf QlJPQURDT009eQpDT05GSUdfQjQ0PW0KQ09ORklHX0I0NF9QQ0lfQVVUT1NFTEVDVD15CkNPTkZJ R19CNDRfUENJQ09SRV9BVVRPU0VMRUNUPXkKQ09ORklHX0I0NF9QQ0k9eQpDT05GSUdfQk5YMj1t CkNPTkZJR19DTklDPW0KQ09ORklHX1RJR09OMz1tCkNPTkZJR19CTlgyWD1tCkNPTkZJR19ORVRf VkVORE9SX0JST0NBREU9eQpDT05GSUdfQk5BPW0KQ09ORklHX05FVF9DQUxYRURBX1hHTUFDPW0K Q09ORklHX05FVF9WRU5ET1JfQ0hFTFNJTz15CkNPTkZJR19DSEVMU0lPX1QxPW0KQ09ORklHX0NI RUxTSU9fVDFfMUc9eQpDT05GSUdfQ0hFTFNJT19UMz1tCkNPTkZJR19DSEVMU0lPX1Q0PW0KQ09O RklHX0NIRUxTSU9fVDRWRj1tCkNPTkZJR19ORVRfVkVORE9SX0NJU0NPPXkKQ09ORklHX0VOSUM9 bQpDT05GSUdfRE5FVD1tCkNPTkZJR19ORVRfVkVORE9SX0RFQz15CkNPTkZJR19ORVRfVFVMSVA9 eQpDT05GSUdfREUyMTA0WD1tCkNPTkZJR19ERTIxMDRYX0RTTD0wCkNPTkZJR19UVUxJUD1tCiMg Q09ORklHX1RVTElQX01XSSBpcyBub3Qgc2V0CiMgQ09ORklHX1RVTElQX01NSU8gaXMgbm90IHNl dApDT05GSUdfVFVMSVBfTkFQST15CkNPTkZJR19UVUxJUF9OQVBJX0hXX01JVElHQVRJT049eQpD T05GSUdfREU0WDU9bQpDT05GSUdfV0lOQk9ORF84NDA9bQpDT05GSUdfRE05MTAyPW0KQ09ORklH X1VMSTUyNlg9bQpDT05GSUdfUENNQ0lBX1hJUkNPTT1tCkNPTkZJR19ORVRfVkVORE9SX0RMSU5L PXkKQ09ORklHX0RFNjAwPW0KQ09ORklHX0RFNjIwPW0KQ09ORklHX0RMMks9bQpDT05GSUdfU1VO REFOQ0U9bQojIENPTkZJR19TVU5EQU5DRV9NTUlPIGlzIG5vdCBzZXQKQ09ORklHX05FVF9WRU5E T1JfRU1VTEVYPXkKQ09ORklHX0JFMk5FVD1tCkNPTkZJR19ORVRfVkVORE9SX0VYQVI9eQpDT05G SUdfUzJJTz1tCkNPTkZJR19WWEdFPW0KIyBDT05GSUdfVlhHRV9ERUJVR19UUkFDRV9BTEwgaXMg bm90IHNldApDT05GSUdfTkVUX1ZFTkRPUl9GVUpJVFNVPXkKQ09ORklHX1BDTUNJQV9GTVZKMThY PW0KQ09ORklHX05FVF9WRU5ET1JfSFA9eQpDT05GSUdfSFAxMDA9bQpDT05GSUdfTkVUX1ZFTkRP Ul9JTlRFTD15CkNPTkZJR19FMTAwPW0KQ09ORklHX0UxMDAwPW0KQ09ORklHX0UxMDAwRT1tCkNP TkZJR19JR0I9bQpDT05GSUdfSUdCX0RDQT15CkNPTkZJR19JR0JWRj1tCkNPTkZJR19JWEdCPW0K Q09ORklHX0lYR0JFPW0KQ09ORklHX0lYR0JFX0RDQT15CkNPTkZJR19JWEdCRV9EQ0I9eQpDT05G SUdfSVhHQkVWRj1tCkNPTkZJR19ORVRfVkVORE9SX0k4MjVYWD15CkNPTkZJR19aTkVUPW0KQ09O RklHX0lQMTAwMD1tCkNPTkZJR19KTUU9bQpDT05GSUdfTkVUX1ZFTkRPUl9NQVJWRUxMPXkKQ09O RklHX1NLR0U9bQojIENPTkZJR19TS0dFX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1NLR0VfR0VO RVNJUz15CkNPTkZJR19TS1kyPW0KIyBDT05GSUdfU0tZMl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJ R19ORVRfVkVORE9SX01FTExBTk9YPXkKQ09ORklHX01MWDRfRU49bQpDT05GSUdfTUxYNF9DT1JF PW0KQ09ORklHX01MWDRfREVCVUc9eQpDT05GSUdfTkVUX1ZFTkRPUl9NSUNSRUw9eQpDT05GSUdf S1M4ODQyPW0KQ09ORklHX0tTODg1MT1tCkNPTkZJR19LUzg4NTFfTUxMPW0KQ09ORklHX0tTWjg4 NFhfUENJPW0KQ09ORklHX05FVF9WRU5ET1JfTUlDUk9DSElQPXkKQ09ORklHX0VOQzI4SjYwPW0K IyBDT05GSUdfRU5DMjhKNjBfV1JJVEVWRVJJRlkgaXMgbm90IHNldApDT05GSUdfTkVUX1ZFTkRP Ul9NWVJJPXkKQ09ORklHX01ZUkkxMEdFPW0KQ09ORklHX01ZUkkxMEdFX0RDQT15CkNPTkZJR19G RUFMTlg9bQpDT05GSUdfTkVUX1ZFTkRPUl9OQVRTRU1JPXkKQ09ORklHX05BVFNFTUk9bQpDT05G SUdfTlM4MzgyMD1tCkNPTkZJR19ORVRfVkVORE9SXzgzOTA9eQpDT05GSUdfUENNQ0lBX0FYTkVU PW0KQ09ORklHX05FMktfUENJPW0KQ09ORklHX1BDTUNJQV9QQ05FVD1tCkNPTkZJR19ORVRfVkVO RE9SX05WSURJQT15CkNPTkZJR19GT1JDRURFVEg9bQpDT05GSUdfTkVUX1ZFTkRPUl9PS0k9eQpD T05GSUdfUENIX0dCRT1tCkNPTkZJR19FVEhPQz1tCiMgQ09ORklHX05FVF9QQUNLRVRfRU5HSU5F IGlzIG5vdCBzZXQKQ09ORklHX05FVF9WRU5ET1JfUUxPR0lDPXkKQ09ORklHX1FMQTNYWFg9bQpD T05GSUdfUUxDTklDPW0KQ09ORklHX1FMR0U9bQpDT05GSUdfTkVUWEVOX05JQz1tCkNPTkZJR19O RVRfVkVORE9SX1JFQUxURUs9eQpDT05GSUdfQVRQPW0KQ09ORklHXzgxMzlDUD1tCkNPTkZJR184 MTM5VE9PPW0KIyBDT05GSUdfODEzOVRPT19QSU8gaXMgbm90IHNldAojIENPTkZJR184MTM5VE9P X1RVTkVfVFdJU1RFUiBpcyBub3Qgc2V0CkNPTkZJR184MTM5VE9PXzgxMjk9eQojIENPTkZJR184 MTM5X09MRF9SWF9SRVNFVCBpcyBub3Qgc2V0CkNPTkZJR19SODE2OT1tCkNPTkZJR19ORVRfVkVO RE9SX1JEQz15CkNPTkZJR19SNjA0MD1tCkNPTkZJR19ORVRfVkVORE9SX1NFRVE9eQpDT05GSUdf U0VFUTgwMDU9bQpDT05GSUdfTkVUX1ZFTkRPUl9TSUxBTj15CkNPTkZJR19TQzkyMDMxPW0KQ09O RklHX05FVF9WRU5ET1JfU0lTPXkKQ09ORklHX1NJUzkwMD1tCkNPTkZJR19TSVMxOTA9bQpDT05G SUdfU0ZDPW0KQ09ORklHX1NGQ19NVEQ9eQpDT05GSUdfU0ZDX01DRElfTU9OPXkKQ09ORklHX1NG Q19TUklPVj15CkNPTkZJR19ORVRfVkVORE9SX1NNU0M9eQpDT05GSUdfUENNQ0lBX1NNQzkxQzky PW0KQ09ORklHX0VQSUMxMDA9bQpDT05GSUdfU01TQzk0MjA9bQpDT05GSUdfTkVUX1ZFTkRPUl9T VE1JQ1JPPXkKQ09ORklHX1NUTU1BQ19FVEg9bQpDT05GSUdfU1RNTUFDX1BMQVRGT1JNPW0KQ09O RklHX1NUTU1BQ19QQ0k9bQojIENPTkZJR19TVE1NQUNfREVCVUdfRlMgaXMgbm90IHNldAojIENP TkZJR19TVE1NQUNfREEgaXMgbm90IHNldApDT05GSUdfU1RNTUFDX1JJTkc9eQojIENPTkZJR19T VE1NQUNfQ0hBSU5FRCBpcyBub3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX1NVTj15CkNPTkZJR19I QVBQWU1FQUw9bQpDT05GSUdfU1VOR0VNPW0KQ09ORklHX0NBU1NJTkk9bQpDT05GSUdfTklVPW0K Q09ORklHX05FVF9WRU5ET1JfVEVIVVRJPXkKQ09ORklHX1RFSFVUST1tCkNPTkZJR19ORVRfVkVO RE9SX1RJPXkKQ09ORklHX1RMQU49bQpDT05GSUdfTkVUX1ZFTkRPUl9WSUE9eQpDT05GSUdfVklB X1JISU5FPW0KQ09ORklHX1ZJQV9SSElORV9NTUlPPXkKQ09ORklHX1ZJQV9WRUxPQ0lUWT1tCkNP TkZJR19ORVRfVkVORE9SX1hJUkNPTT15CkNPTkZJR19QQ01DSUFfWElSQzJQUz1tCkNPTkZJR19G RERJPW0KQ09ORklHX0RFRlhYPW0KQ09ORklHX0RFRlhYX01NSU89eQpDT05GSUdfU0tGUD1tCkNP TkZJR19ISVBQST15CkNPTkZJR19ST0FEUlVOTkVSPW0KQ09ORklHX1JPQURSVU5ORVJfTEFSR0Vf UklOR1M9eQojIENPTkZJR19ORVRfU0IxMDAwIGlzIG5vdCBzZXQKQ09ORklHX1BIWUxJQj15Cgoj CiMgTUlJIFBIWSBkZXZpY2UgZHJpdmVycwojCkNPTkZJR19BTURfUEhZPW0KQ09ORklHX01BUlZF TExfUEhZPW0KQ09ORklHX0RBVklDT01fUEhZPW0KQ09ORklHX1FTRU1JX1BIWT1tCkNPTkZJR19M WFRfUEhZPW0KQ09ORklHX0NJQ0FEQV9QSFk9bQpDT05GSUdfVklURVNTRV9QSFk9bQpDT05GSUdf U01TQ19QSFk9bQpDT05GSUdfQlJPQURDT01fUEhZPW0KQ09ORklHX0lDUExVU19QSFk9bQpDT05G SUdfUkVBTFRFS19QSFk9bQpDT05GSUdfTkFUSU9OQUxfUEhZPW0KQ09ORklHX1NURTEwWFA9bQpD T05GSUdfTFNJX0VUMTAxMUNfUEhZPW0KQ09ORklHX01JQ1JFTF9QSFk9bQpDT05GSUdfRklYRURf UEhZPXkKQ09ORklHX01ESU9fQklUQkFORz1tCkNPTkZJR19NRElPX0dQSU89bQpDT05GSUdfTUlD UkVMX0tTODk5NU1BPW0KQ09ORklHX1BMSVA9bQpDT05GSUdfUFBQPW0KQ09ORklHX1BQUF9CU0RD T01QPW0KQ09ORklHX1BQUF9ERUZMQVRFPW0KQ09ORklHX1BQUF9GSUxURVI9eQpDT05GSUdfUFBQ X01QUEU9bQpDT05GSUdfUFBQX01VTFRJTElOSz15CkNPTkZJR19QUFBPQVRNPW0KQ09ORklHX1BQ UE9FPW0KQ09ORklHX1BQUF9BU1lOQz1tCkNPTkZJR19QUFBfU1lOQ19UVFk9bQpDT05GSUdfU0xJ UD1tCkNPTkZJR19TTEhDPW0KQ09ORklHX1NMSVBfQ09NUFJFU1NFRD15CkNPTkZJR19TTElQX1NN QVJUPXkKQ09ORklHX1NMSVBfTU9ERV9TTElQNj15CiMgQ09ORklHX1RSIGlzIG5vdCBzZXQKCiMK IyBVU0IgTmV0d29yayBBZGFwdGVycwojCkNPTkZJR19VU0JfQ0FUQz1tCkNPTkZJR19VU0JfS0FX RVRIPW0KQ09ORklHX1VTQl9QRUdBU1VTPW0KQ09ORklHX1VTQl9SVEw4MTUwPW0KQ09ORklHX1VT Ql9VU0JORVQ9bQpDT05GSUdfVVNCX05FVF9BWDg4MTdYPW0KQ09ORklHX1VTQl9ORVRfQ0RDRVRI RVI9bQpDT05GSUdfVVNCX05FVF9DRENfRUVNPW0KQ09ORklHX1VTQl9ORVRfQ0RDX05DTT1tCkNP TkZJR19VU0JfTkVUX0RNOTYwMT1tCkNPTkZJR19VU0JfTkVUX1NNU0M3NVhYPW0KQ09ORklHX1VT Ql9ORVRfU01TQzk1WFg9bQpDT05GSUdfVVNCX05FVF9HTDYyMEE9bQpDT05GSUdfVVNCX05FVF9O RVQxMDgwPW0KQ09ORklHX1VTQl9ORVRfUExVU0I9bQpDT05GSUdfVVNCX05FVF9NQ1M3ODMwPW0K Q09ORklHX1VTQl9ORVRfUk5ESVNfSE9TVD1tCkNPTkZJR19VU0JfTkVUX0NEQ19TVUJTRVQ9bQpD T05GSUdfVVNCX0FMSV9NNTYzMj15CkNPTkZJR19VU0JfQU4yNzIwPXkKQ09ORklHX1VTQl9CRUxL SU49eQpDT05GSUdfVVNCX0FSTUxJTlVYPXkKQ09ORklHX1VTQl9FUFNPTjI4ODg9eQpDT05GSUdf VVNCX0tDMjE5MD15CkNPTkZJR19VU0JfTkVUX1pBVVJVUz1tCkNPTkZJR19VU0JfTkVUX0NYODIz MTBfRVRIPW0KQ09ORklHX1VTQl9ORVRfS0FMTUlBPW0KQ09ORklHX1VTQl9ORVRfUU1JX1dXQU49 bQpDT05GSUdfVVNCX0hTTz1tCkNPTkZJR19VU0JfTkVUX0lOVDUxWDE9bQpDT05GSUdfVVNCX0NE Q19QSE9ORVQ9bQpDT05GSUdfVVNCX0lQSEVUSD1tCkNPTkZJR19VU0JfU0lFUlJBX05FVD1tCkNP TkZJR19VU0JfVkw2MDA9bQpDT05GSUdfV0xBTj15CkNPTkZJR19QQ01DSUFfUkFZQ1M9bQpDT05G SUdfTElCRVJUQVNfVEhJTkZJUk09bQojIENPTkZJR19MSUJFUlRBU19USElORklSTV9ERUJVRyBp cyBub3Qgc2V0CkNPTkZJR19MSUJFUlRBU19USElORklSTV9VU0I9bQpDT05GSUdfQUlSTz1tCkNP TkZJR19BVE1FTD1tCkNPTkZJR19QQ0lfQVRNRUw9bQpDT05GSUdfUENNQ0lBX0FUTUVMPW0KQ09O RklHX0FUNzZDNTBYX1VTQj1tCkNPTkZJR19BSVJPX0NTPW0KQ09ORklHX1BDTUNJQV9XTDM1MDE9 bQpDT05GSUdfUFJJU001ND1tCkNPTkZJR19VU0JfWkQxMjAxPW0KQ09ORklHX1VTQl9ORVRfUk5E SVNfV0xBTj1tCkNPTkZJR19SVEw4MTgwPW0KQ09ORklHX1JUTDgxODc9bQpDT05GSUdfUlRMODE4 N19MRURTPXkKQ09ORklHX0FETTgyMTE9bQpDT05GSUdfTUFDODAyMTFfSFdTSU09bQpDT05GSUdf TVdMOEs9bQpDT05GSUdfQVRIX0NPTU1PTj1tCiMgQ09ORklHX0FUSF9ERUJVRyBpcyBub3Qgc2V0 CkNPTkZJR19BVEg1Sz1tCiMgQ09ORklHX0FUSDVLX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdf QVRINUtfVFJBQ0VSIGlzIG5vdCBzZXQKQ09ORklHX0FUSDVLX1BDST15CkNPTkZJR19BVEg5S19I Vz1tCkNPTkZJR19BVEg5S19DT01NT049bQpDT05GSUdfQVRIOUtfQlRDT0VYX1NVUFBPUlQ9eQpD T05GSUdfQVRIOUs9bQpDT05GSUdfQVRIOUtfUENJPXkKQ09ORklHX0FUSDlLX0FIQj15CiMgQ09O RklHX0FUSDlLX0RFQlVHRlMgaXMgbm90IHNldApDT05GSUdfQVRIOUtfUkFURV9DT05UUk9MPXkK Q09ORklHX0FUSDlLX0hUQz1tCiMgQ09ORklHX0FUSDlLX0hUQ19ERUJVR0ZTIGlzIG5vdCBzZXQK Q09ORklHX0NBUkw5MTcwPW0KQ09ORklHX0NBUkw5MTcwX0xFRFM9eQojIENPTkZJR19DQVJMOTE3 MF9ERUJVR0ZTIGlzIG5vdCBzZXQKQ09ORklHX0NBUkw5MTcwX1dQQz15CkNPTkZJR19DQVJMOTE3 MF9IV1JORz15CkNPTkZJR19BVEg2S0w9bQpDT05GSUdfQVRINktMX1NESU89bQpDT05GSUdfQVRI NktMX1VTQj1tCiMgQ09ORklHX0FUSDZLTF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19CNDM9bQpD T05GSUdfQjQzX1NTQj15CkNPTkZJR19CNDNfUENJX0FVVE9TRUxFQ1Q9eQpDT05GSUdfQjQzX1BD SUNPUkVfQVVUT1NFTEVDVD15CkNPTkZJR19CNDNfUENNQ0lBPXkKQ09ORklHX0I0M19TRElPPXkK Q09ORklHX0I0M19QSU89eQpDT05GSUdfQjQzX1BIWV9OPXkKQ09ORklHX0I0M19QSFlfTFA9eQpD T05GSUdfQjQzX1BIWV9IVD15CkNPTkZJR19CNDNfTEVEUz15CkNPTkZJR19CNDNfSFdSTkc9eQoj IENPTkZJR19CNDNfREVCVUcgaXMgbm90IHNldApDT05GSUdfQjQzTEVHQUNZPW0KQ09ORklHX0I0 M0xFR0FDWV9QQ0lfQVVUT1NFTEVDVD15CkNPTkZJR19CNDNMRUdBQ1lfUENJQ09SRV9BVVRPU0VM RUNUPXkKQ09ORklHX0I0M0xFR0FDWV9MRURTPXkKQ09ORklHX0I0M0xFR0FDWV9IV1JORz15CiMg Q09ORklHX0I0M0xFR0FDWV9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19CNDNMRUdBQ1lfRE1BPXkK Q09ORklHX0I0M0xFR0FDWV9QSU89eQpDT05GSUdfQjQzTEVHQUNZX0RNQV9BTkRfUElPX01PREU9 eQojIENPTkZJR19CNDNMRUdBQ1lfRE1BX01PREUgaXMgbm90IHNldAojIENPTkZJR19CNDNMRUdB Q1lfUElPX01PREUgaXMgbm90IHNldAojIENPTkZJR19CUkNNRk1BQyBpcyBub3Qgc2V0CkNPTkZJ R19IT1NUQVA9bQpDT05GSUdfSE9TVEFQX0ZJUk1XQVJFPXkKQ09ORklHX0hPU1RBUF9GSVJNV0FS RV9OVlJBTT15CkNPTkZJR19IT1NUQVBfUExYPW0KQ09ORklHX0hPU1RBUF9QQ0k9bQpDT05GSUdf SE9TVEFQX0NTPW0KQ09ORklHX0lQVzIxMDA9bQpDT05GSUdfSVBXMjEwMF9NT05JVE9SPXkKIyBD T05GSUdfSVBXMjEwMF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19JUFcyMjAwPW0KQ09ORklHX0lQ VzIyMDBfTU9OSVRPUj15CkNPTkZJR19JUFcyMjAwX1JBRElPVEFQPXkKQ09ORklHX0lQVzIyMDBf UFJPTUlTQ1VPVVM9eQpDT05GSUdfSVBXMjIwMF9RT1M9eQojIENPTkZJR19JUFcyMjAwX0RFQlVH IGlzIG5vdCBzZXQKQ09ORklHX0xJQklQVz1tCiMgQ09ORklHX0xJQklQV19ERUJVRyBpcyBub3Qg c2V0CkNPTkZJR19JV0xXSUZJPW0KCiMKIyBEZWJ1Z2dpbmcgT3B0aW9ucwojCiMgQ09ORklHX0lX TFdJRklfREVCVUcgaXMgbm90IHNldApDT05GSUdfSVdMV0lGSV9ERUJVR0ZTPXkKIyBDT05GSUdf SVdMV0lGSV9ERVZJQ0VfVFJBQ0lORyBpcyBub3Qgc2V0CkNPTkZJR19JV0xXSUZJX0RFVklDRV9U RVNUTU9ERT15CiMgQ09ORklHX0lXTFdJRklfUDJQIGlzIG5vdCBzZXQKIyBDT05GSUdfSVdMV0lG SV9FWFBFUklNRU5UQUxfTUZQIGlzIG5vdCBzZXQKQ09ORklHX0lXTEVHQUNZPW0KQ09ORklHX0lX TDQ5NjU9bQpDT05GSUdfSVdMMzk0NT1tCgojCiMgaXdsMzk0NSAvIGl3bDQ5NjUgRGVidWdnaW5n IE9wdGlvbnMKIwojIENPTkZJR19JV0xFR0FDWV9ERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX0lX TEVHQUNZX0RFQlVHRlMgaXMgbm90IHNldApDT05GSUdfSVdNPW0KIyBDT05GSUdfSVdNX0RFQlVH IGlzIG5vdCBzZXQKIyBDT05GSUdfSVdNX1RSQUNJTkcgaXMgbm90IHNldApDT05GSUdfTElCRVJU QVM9bQpDT05GSUdfTElCRVJUQVNfVVNCPW0KQ09ORklHX0xJQkVSVEFTX0NTPW0KQ09ORklHX0xJ QkVSVEFTX1NESU89bQpDT05GSUdfTElCRVJUQVNfU1BJPW0KIyBDT05GSUdfTElCRVJUQVNfREVC VUcgaXMgbm90IHNldApDT05GSUdfTElCRVJUQVNfTUVTSD15CkNPTkZJR19IRVJNRVM9bQojIENP TkZJR19IRVJNRVNfUFJJU00gaXMgbm90IHNldApDT05GSUdfSEVSTUVTX0NBQ0hFX0ZXX09OX0lO SVQ9eQpDT05GSUdfUExYX0hFUk1FUz1tCkNPTkZJR19UTURfSEVSTUVTPW0KQ09ORklHX05PUlRF TF9IRVJNRVM9bQpDT05GSUdfUENNQ0lBX0hFUk1FUz1tCkNPTkZJR19QQ01DSUFfU1BFQ1RSVU09 bQpDT05GSUdfT1JJTk9DT19VU0I9bQpDT05GSUdfUDU0X0NPTU1PTj1tCkNPTkZJR19QNTRfVVNC PW0KQ09ORklHX1A1NF9QQ0k9bQpDT05GSUdfUDU0X1NQST1tCiMgQ09ORklHX1A1NF9TUElfREVG QVVMVF9FRVBST00gaXMgbm90IHNldApDT05GSUdfUDU0X0xFRFM9eQpDT05GSUdfUlQyWDAwPW0K Q09ORklHX1JUMjQwMFBDST1tCkNPTkZJR19SVDI1MDBQQ0k9bQpDT05GSUdfUlQ2MVBDST1tCiMg Q09ORklHX1JUMjgwMFBDSSBpcyBub3Qgc2V0CkNPTkZJR19SVDI1MDBVU0I9bQpDT05GSUdfUlQ3 M1VTQj1tCkNPTkZJR19SVDI4MDBVU0I9bQpDT05GSUdfUlQyODAwVVNCX1JUMzNYWD15CiMgQ09O RklHX1JUMjgwMFVTQl9SVDM1WFggaXMgbm90IHNldApDT05GSUdfUlQyODAwVVNCX1JUNTNYWD15 CiMgQ09ORklHX1JUMjgwMFVTQl9VTktOT1dOIGlzIG5vdCBzZXQKQ09ORklHX1JUMjgwMF9MSUI9 bQpDT05GSUdfUlQyWDAwX0xJQl9QQ0k9bQpDT05GSUdfUlQyWDAwX0xJQl9VU0I9bQpDT05GSUdf UlQyWDAwX0xJQj1tCkNPTkZJR19SVDJYMDBfTElCX0ZJUk1XQVJFPXkKQ09ORklHX1JUMlgwMF9M SUJfQ1JZUFRPPXkKQ09ORklHX1JUMlgwMF9MSUJfTEVEUz15CiMgQ09ORklHX1JUMlgwMF9MSUJf REVCVUdGUyBpcyBub3Qgc2V0CiMgQ09ORklHX1JUMlgwMF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJ R19SVEw4MTkyQ0U9bQpDT05GSUdfUlRMODE5MlNFPW0KQ09ORklHX1JUTDgxOTJERT1tCkNPTkZJ R19SVEw4MTkyQ1U9bQpDT05GSUdfUlRMV0lGST1tCiMgQ09ORklHX1JUTFdJRklfREVCVUcgaXMg bm90IHNldApDT05GSUdfUlRMODE5MkNfQ09NTU9OPW0KQ09ORklHX1dMMTI1MT1tCkNPTkZJR19X TDEyNTFfU1BJPW0KQ09ORklHX1dMMTI1MV9TRElPPW0KQ09ORklHX1dMMTJYWF9NRU5VPW0KQ09O RklHX1dMMTJYWD1tCiMgQ09ORklHX1dMMTJYWF9TUEkgaXMgbm90IHNldAojIENPTkZJR19XTDEy WFhfU0RJTyBpcyBub3Qgc2V0CkNPTkZJR19XTDEyWFhfUExBVEZPUk1fREFUQT15CkNPTkZJR19a RDEyMTFSVz1tCiMgQ09ORklHX1pEMTIxMVJXX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX01XSUZJ RVg9bQpDT05GSUdfTVdJRklFWF9TRElPPW0KQ09ORklHX01XSUZJRVhfUENJRT1tCgojCiMgV2lN QVggV2lyZWxlc3MgQnJvYWRiYW5kIGRldmljZXMKIwpDT05GSUdfV0lNQVhfSTI0MDBNPW0KQ09O RklHX1dJTUFYX0kyNDAwTV9VU0I9bQpDT05GSUdfV0lNQVhfSTI0MDBNX1NESU89bQpDT05GSUdf V0lNQVhfSVdNQzMyMDBfU0RJTz15CkNPTkZJR19XSU1BWF9JMjQwME1fREVCVUdfTEVWRUw9OApD T05GSUdfV0FOPXkKQ09ORklHX0xBTk1FRElBPW0KQ09ORklHX0hETEM9bQpDT05GSUdfSERMQ19S QVc9bQpDT05GSUdfSERMQ19SQVdfRVRIPW0KQ09ORklHX0hETENfQ0lTQ089bQpDT05GSUdfSERM Q19GUj1tCkNPTkZJR19IRExDX1BQUD1tCkNPTkZJR19IRExDX1gyNT1tCkNPTkZJR19QQ0kyMDBT WU49bQpDT05GSUdfV0FOWEw9bQpDT05GSUdfUEMzMDBUT089bQpDT05GSUdfRkFSU1lOQz1tCkNP TkZJR19EU0NDND1tCkNPTkZJR19EU0NDNF9QQ0lTWU5DPXkKQ09ORklHX0RTQ0M0X1BDSV9SU1Q9 eQpDT05GSUdfRExDST1tCkNPTkZJR19ETENJX01BWD04CiMgQ09ORklHX1dBTl9ST1VURVJfRFJJ VkVSUyBpcyBub3Qgc2V0CkNPTkZJR19MQVBCRVRIRVI9bQpDT05GSUdfWDI1X0FTWT1tCkNPTkZJ R19TQk5JPW0KQ09ORklHX1NCTklfTVVMVElMSU5FPXkKQ09ORklHX1hFTl9ORVRERVZfRlJPTlRF TkQ9bQpDT05GSUdfWEVOX05FVERFVl9CQUNLRU5EPW0KIyBDT05GSUdfVk1YTkVUMyBpcyBub3Qg c2V0CkNPTkZJR19JU0ROPXkKQ09ORklHX0lTRE5fSTRMPW0KQ09ORklHX0lTRE5fUFBQPXkKQ09O RklHX0lTRE5fUFBQX1ZKPXkKQ09ORklHX0lTRE5fTVBQPXkKQ09ORklHX0lQUFBfRklMVEVSPXkK Q09ORklHX0lTRE5fUFBQX0JTRENPTVA9bQpDT05GSUdfSVNETl9BVURJTz15CkNPTkZJR19JU0RO X1RUWV9GQVg9eQpDT05GSUdfSVNETl9YMjU9eQoKIwojIElTRE4gZmVhdHVyZSBzdWJtb2R1bGVz CiMKQ09ORklHX0lTRE5fRElWRVJTSU9OPW0KCiMKIyBJU0RONExpbnV4IGhhcmR3YXJlIGRyaXZl cnMKIwoKIwojIFBhc3NpdmUgY2FyZHMKIwpDT05GSUdfSVNETl9EUlZfSElTQVg9bQoKIwojIEQt Y2hhbm5lbCBwcm90b2NvbCBmZWF0dXJlcwojCkNPTkZJR19ISVNBWF9FVVJPPXkKQ09ORklHX0RF X0FPQz15CiMgQ09ORklHX0hJU0FYX05PX1NFTkRDT01QTEVURSBpcyBub3Qgc2V0CiMgQ09ORklH X0hJU0FYX05PX0xMQyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJU0FYX05PX0tFWVBBRCBpcyBub3Qg c2V0CkNPTkZJR19ISVNBWF8xVFI2PXkKQ09ORklHX0hJU0FYX05JMT15CkNPTkZJR19ISVNBWF9N QVhfQ0FSRFM9OAoKIwojIEhpU2F4IHN1cHBvcnRlZCBjYXJkcwojCkNPTkZJR19ISVNBWF8xNl8z PXkKQ09ORklHX0hJU0FYX1RFTEVTUENJPXkKQ09ORklHX0hJU0FYX1MwQk9YPXkKQ09ORklHX0hJ U0FYX0ZSSVRaUENJPXkKQ09ORklHX0hJU0FYX0FWTV9BMV9QQ01DSUE9eQpDT05GSUdfSElTQVhf RUxTQT15CkNPTkZJR19ISVNBWF9ESUVITERJVkE9eQpDT05GSUdfSElTQVhfU0VETEJBVUVSPXkK Q09ORklHX0hJU0FYX05FVEpFVD15CkNPTkZJR19ISVNBWF9ORVRKRVRfVT15CkNPTkZJR19ISVNB WF9OSUNDWT15CkNPTkZJR19ISVNBWF9CS01fQTRUPXkKQ09ORklHX0hJU0FYX1NDVF9RVUFEUk89 eQpDT05GSUdfSElTQVhfR0FaRUw9eQpDT05GSUdfSElTQVhfSEZDX1BDST15CkNPTkZJR19ISVNB WF9XNjY5Mj15CkNPTkZJR19ISVNBWF9IRkNfU1g9eQpDT05GSUdfSElTQVhfRU5URVJOT1dfUENJ PXkKIyBDT05GSUdfSElTQVhfREVCVUcgaXMgbm90IHNldAoKIwojIEhpU2F4IFBDTUNJQSBjYXJk IHNlcnZpY2UgbW9kdWxlcwojCkNPTkZJR19ISVNBWF9TRURMQkFVRVJfQ1M9bQpDT05GSUdfSElT QVhfRUxTQV9DUz1tCkNPTkZJR19ISVNBWF9BVk1fQTFfQ1M9bQpDT05GSUdfSElTQVhfVEVMRVNf Q1M9bQoKIwojIEhpU2F4IHN1YiBkcml2ZXIgbW9kdWxlcwojCkNPTkZJR19ISVNBWF9TVDU0ODE9 bQpDT05GSUdfSElTQVhfSEZDVVNCPW0KQ09ORklHX0hJU0FYX0hGQzRTOFM9bQpDT05GSUdfSElT QVhfRlJJVFpfUENJUE5QPW0KCiMKIyBBY3RpdmUgY2FyZHMKIwpDT05GSUdfSVNETl9DQVBJPW0K Q09ORklHX0lTRE5fRFJWX0FWTUIxX1ZFUkJPU0VfUkVBU09OPXkKQ09ORklHX0NBUElfVFJBQ0U9 eQpDT05GSUdfSVNETl9DQVBJX01JRERMRVdBUkU9eQpDT05GSUdfSVNETl9DQVBJX0NBUEkyMD1t CkNPTkZJR19JU0ROX0NBUElfQ0FQSURSVj1tCgojCiMgQ0FQSSBoYXJkd2FyZSBkcml2ZXJzCiMK Q09ORklHX0NBUElfQVZNPXkKQ09ORklHX0lTRE5fRFJWX0FWTUIxX0IxUENJPW0KQ09ORklHX0lT RE5fRFJWX0FWTUIxX0IxUENJVjQ9eQpDT05GSUdfSVNETl9EUlZfQVZNQjFfQjFQQ01DSUE9bQpD T05GSUdfSVNETl9EUlZfQVZNQjFfQVZNX0NTPW0KQ09ORklHX0lTRE5fRFJWX0FWTUIxX1QxUENJ PW0KQ09ORklHX0lTRE5fRFJWX0FWTUIxX0M0PW0KQ09ORklHX0NBUElfRUlDT049eQpDT05GSUdf SVNETl9ESVZBUz1tCkNPTkZJR19JU0ROX0RJVkFTX0JSSVBDST15CkNPTkZJR19JU0ROX0RJVkFT X1BSSVBDST15CkNPTkZJR19JU0ROX0RJVkFTX0RJVkFDQVBJPW0KQ09ORklHX0lTRE5fRElWQVNf VVNFUklEST1tCkNPTkZJR19JU0ROX0RJVkFTX01BSU5UPW0KQ09ORklHX0lTRE5fRFJWX0dJR0FT RVQ9bQojIENPTkZJR19HSUdBU0VUX0NBUEkgaXMgbm90IHNldApDT05GSUdfR0lHQVNFVF9JNEw9 eQojIENPTkZJR19HSUdBU0VUX0RVTU1ZTEwgaXMgbm90IHNldApDT05GSUdfR0lHQVNFVF9CQVNF PW0KQ09ORklHX0dJR0FTRVRfTTEwNT1tCkNPTkZJR19HSUdBU0VUX00xMDE9bQojIENPTkZJR19H SUdBU0VUX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0hZU0ROPW0KQ09ORklHX0hZU0ROX0NBUEk9 eQpDT05GSUdfTUlTRE49bQpDT05GSUdfTUlTRE5fRFNQPW0KQ09ORklHX01JU0ROX0wxT0lQPW0K CiMKIyBtSVNETiBoYXJkd2FyZSBkcml2ZXJzCiMKQ09ORklHX01JU0ROX0hGQ1BDST1tCkNPTkZJ R19NSVNETl9IRkNNVUxUST1tCkNPTkZJR19NSVNETl9IRkNVU0I9bQpDT05GSUdfTUlTRE5fQVZN RlJJVFo9bQpDT05GSUdfTUlTRE5fU1BFRURGQVg9bQpDT05GSUdfTUlTRE5fSU5GSU5FT049bQpD T05GSUdfTUlTRE5fVzY2OTI9bQpDT05GSUdfTUlTRE5fTkVUSkVUPW0KQ09ORklHX01JU0ROX0lQ QUM9bQpDT05GSUdfTUlTRE5fSVNBUj1tCkNPTkZJR19JU0ROX0hETEM9bQoKIwojIElucHV0IGRl dmljZSBzdXBwb3J0CiMKQ09ORklHX0lOUFVUPXkKQ09ORklHX0lOUFVUX0ZGX01FTUxFU1M9bQpD T05GSUdfSU5QVVRfUE9MTERFVj1tCkNPTkZJR19JTlBVVF9TUEFSU0VLTUFQPW0KCiMKIyBVc2Vy bGFuZCBpbnRlcmZhY2VzCiMKQ09ORklHX0lOUFVUX01PVVNFREVWPXkKQ09ORklHX0lOUFVUX01P VVNFREVWX1BTQVVYPXkKQ09ORklHX0lOUFVUX01PVVNFREVWX1NDUkVFTl9YPTEwMjQKQ09ORklH X0lOUFVUX01PVVNFREVWX1NDUkVFTl9ZPTc2OApDT05GSUdfSU5QVVRfSk9ZREVWPW0KQ09ORklH X0lOUFVUX0VWREVWPXkKIyBDT05GSUdfSU5QVVRfRVZCVUcgaXMgbm90IHNldAoKIwojIElucHV0 IERldmljZSBEcml2ZXJzCiMKQ09ORklHX0lOUFVUX0tFWUJPQVJEPXkKQ09ORklHX0tFWUJPQVJE X0FEUDU1ODg9bQpDT05GSUdfS0VZQk9BUkRfQURQNTU4OT1tCkNPTkZJR19LRVlCT0FSRF9BVEtC RD15CkNPTkZJR19LRVlCT0FSRF9RVDEwNzA9bQpDT05GSUdfS0VZQk9BUkRfUVQyMTYwPW0KIyBD T05GSUdfS0VZQk9BUkRfTEtLQkQgaXMgbm90IHNldApDT05GSUdfS0VZQk9BUkRfR1BJTz1tCkNP TkZJR19LRVlCT0FSRF9HUElPX1BPTExFRD1tCkNPTkZJR19LRVlCT0FSRF9UQ0E2NDE2PW0KQ09O RklHX0tFWUJPQVJEX1RDQTg0MTg9bQpDT05GSUdfS0VZQk9BUkRfTUFUUklYPW0KQ09ORklHX0tF WUJPQVJEX0xNODMyMz1tCkNPTkZJR19LRVlCT0FSRF9NQVg3MzU5PW0KQ09ORklHX0tFWUJPQVJE X01DUz1tCkNPTkZJR19LRVlCT0FSRF9NUFIxMjE9bQpDT05GSUdfS0VZQk9BUkRfTkVXVE9OPW0K Q09ORklHX0tFWUJPQVJEX09QRU5DT1JFUz1tCiMgQ09ORklHX0tFWUJPQVJEX1NUT1dBV0FZIGlz IG5vdCBzZXQKQ09ORklHX0tFWUJPQVJEX1NVTktCRD1tCkNPTkZJR19LRVlCT0FSRF9TVE1QRT1t CkNPTkZJR19LRVlCT0FSRF9PTUFQND1tCkNPTkZJR19LRVlCT0FSRF9YVEtCRD1tCkNPTkZJR19J TlBVVF9NT1VTRT15CkNPTkZJR19NT1VTRV9QUzI9eQpDT05GSUdfTU9VU0VfUFMyX0FMUFM9eQpD T05GSUdfTU9VU0VfUFMyX0xPR0lQUzJQUD15CkNPTkZJR19NT1VTRV9QUzJfU1lOQVBUSUNTPXkK Q09ORklHX01PVVNFX1BTMl9MSUZFQk9PSz15CkNPTkZJR19NT1VTRV9QUzJfVFJBQ0tQT0lOVD15 CkNPTkZJR19NT1VTRV9QUzJfRUxBTlRFQ0g9eQpDT05GSUdfTU9VU0VfUFMyX1NFTlRFTElDPXkK Q09ORklHX01PVVNFX1BTMl9UT1VDSEtJVD15CkNPTkZJR19NT1VTRV9TRVJJQUw9bQpDT05GSUdf TU9VU0VfQVBQTEVUT1VDSD1tCkNPTkZJR19NT1VTRV9CQ001OTc0PW0KQ09ORklHX01PVVNFX1ZT WFhYQUE9bQpDT05GSUdfTU9VU0VfR1BJTz1tCkNPTkZJR19NT1VTRV9TWU5BUFRJQ1NfSTJDPW0K Q09ORklHX01PVVNFX1NZTkFQVElDU19VU0I9bQpDT05GSUdfSU5QVVRfSk9ZU1RJQ0s9eQpDT05G SUdfSk9ZU1RJQ0tfQU5BTE9HPW0KQ09ORklHX0pPWVNUSUNLX0EzRD1tCkNPTkZJR19KT1lTVElD S19BREk9bQpDT05GSUdfSk9ZU1RJQ0tfQ09CUkE9bQpDT05GSUdfSk9ZU1RJQ0tfR0YySz1tCkNP TkZJR19KT1lTVElDS19HUklQPW0KQ09ORklHX0pPWVNUSUNLX0dSSVBfTVA9bQpDT05GSUdfSk9Z U1RJQ0tfR1VJTExFTU9UPW0KQ09ORklHX0pPWVNUSUNLX0lOVEVSQUNUPW0KQ09ORklHX0pPWVNU SUNLX1NJREVXSU5ERVI9bQpDT05GSUdfSk9ZU1RJQ0tfVE1EQz1tCkNPTkZJR19KT1lTVElDS19J Rk9SQ0U9bQpDT05GSUdfSk9ZU1RJQ0tfSUZPUkNFX1VTQj15CkNPTkZJR19KT1lTVElDS19JRk9S Q0VfMjMyPXkKQ09ORklHX0pPWVNUSUNLX1dBUlJJT1I9bQpDT05GSUdfSk9ZU1RJQ0tfTUFHRUxM QU49bQpDT05GSUdfSk9ZU1RJQ0tfU1BBQ0VPUkI9bQpDT05GSUdfSk9ZU1RJQ0tfU1BBQ0VCQUxM PW0KQ09ORklHX0pPWVNUSUNLX1NUSU5HRVI9bQpDT05GSUdfSk9ZU1RJQ0tfVFdJREpPWT1tCkNP TkZJR19KT1lTVElDS19aSEVOSFVBPW0KQ09ORklHX0pPWVNUSUNLX0RCOT1tCkNPTkZJR19KT1lT VElDS19HQU1FQ09OPW0KQ09ORklHX0pPWVNUSUNLX1RVUkJPR1JBRlg9bQpDT05GSUdfSk9ZU1RJ Q0tfQVM1MDExPW0KQ09ORklHX0pPWVNUSUNLX0pPWURVTVA9bQpDT05GSUdfSk9ZU1RJQ0tfWFBB RD1tCkNPTkZJR19KT1lTVElDS19YUEFEX0ZGPXkKQ09ORklHX0pPWVNUSUNLX1hQQURfTEVEUz15 CkNPTkZJR19KT1lTVElDS19XQUxLRVJBMDcwMT1tCkNPTkZJR19JTlBVVF9UQUJMRVQ9eQpDT05G SUdfVEFCTEVUX1VTQl9BQ0VDQUQ9bQpDT05GSUdfVEFCTEVUX1VTQl9BSVBURUs9bQpDT05GSUdf VEFCTEVUX1VTQl9HVENPPW0KQ09ORklHX1RBQkxFVF9VU0JfSEFOV0FORz1tCkNPTkZJR19UQUJM RVRfVVNCX0tCVEFCPW0KQ09ORklHX1RBQkxFVF9VU0JfV0FDT009bQpDT05GSUdfSU5QVVRfVE9V Q0hTQ1JFRU49eQpDT05GSUdfVE9VQ0hTQ1JFRU5fQURTNzg0Nj1tCkNPTkZJR19UT1VDSFNDUkVF Tl9BRDc4Nzc9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fQUQ3ODc5PW0KQ09ORklHX1RPVUNIU0NSRUVO X0FENzg3OV9JMkM9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fQUQ3ODc5X1NQST1tCkNPTkZJR19UT1VD SFNDUkVFTl9BVE1FTF9NWFQ9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fQVVPX1BJWENJUj1tCkNPTkZJ R19UT1VDSFNDUkVFTl9CVTIxMDEzPW0KQ09ORklHX1RPVUNIU0NSRUVOX0NZOENUTUcxMTA9bQpD T05GSUdfVE9VQ0hTQ1JFRU5fQ1lUVFNQX0NPUkU9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fQ1lUVFNQ X0kyQz1tCkNPTkZJR19UT1VDSFNDUkVFTl9DWVRUU1BfU1BJPW0KQ09ORklHX1RPVUNIU0NSRUVO X0RZTkFQUk89bQpDT05GSUdfVE9VQ0hTQ1JFRU5fSEFNUFNISVJFPW0KQ09ORklHX1RPVUNIU0NS RUVOX0VFVEk9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fRUdBTEFYPW0KQ09ORklHX1RPVUNIU0NSRUVO X0ZVSklUU1U9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fSUxJMjEwWD1tCkNPTkZJR19UT1VDSFNDUkVF Tl9HVU5aRT1tCkNPTkZJR19UT1VDSFNDUkVFTl9FTE89bQpDT05GSUdfVE9VQ0hTQ1JFRU5fV0FD T01fVzgwMDE9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fTUFYMTE4MDE9bQpDT05GSUdfVE9VQ0hTQ1JF RU5fTUNTNTAwMD1tCkNPTkZJR19UT1VDSFNDUkVFTl9NVE9VQ0g9bQpDT05GSUdfVE9VQ0hTQ1JF RU5fSU5FWElPPW0KQ09ORklHX1RPVUNIU0NSRUVOX01LNzEyPW0KQ09ORklHX1RPVUNIU0NSRUVO X1BFTk1PVU5UPW0KQ09ORklHX1RPVUNIU0NSRUVOX1RPVUNIUklHSFQ9bQpDT05GSUdfVE9VQ0hT Q1JFRU5fVE9VQ0hXSU49bQpDT05GSUdfVE9VQ0hTQ1JFRU5fVUNCMTQwMD1tCkNPTkZJR19UT1VD SFNDUkVFTl9QSVhDSVI9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fV005N1hYPW0KQ09ORklHX1RPVUNI U0NSRUVOX1dNOTcwNT15CkNPTkZJR19UT1VDSFNDUkVFTl9XTTk3MTI9eQpDT05GSUdfVE9VQ0hT Q1JFRU5fV005NzEzPXkKQ09ORklHX1RPVUNIU0NSRUVOX1VTQl9DT01QT1NJVEU9bQpDT05GSUdf VE9VQ0hTQ1JFRU5fTUMxMzc4Mz1tCkNPTkZJR19UT1VDSFNDUkVFTl9VU0JfRUdBTEFYPXkKQ09O RklHX1RPVUNIU0NSRUVOX1VTQl9QQU5KSVQ9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCXzNNPXkK Q09ORklHX1RPVUNIU0NSRUVOX1VTQl9JVE09eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCX0VUVVJC Tz15CkNPTkZJR19UT1VDSFNDUkVFTl9VU0JfR1VOWkU9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNC X0RNQ19UU0MxMD15CkNPTkZJR19UT1VDSFNDUkVFTl9VU0JfSVJUT1VDSD15CkNPTkZJR19UT1VD SFNDUkVFTl9VU0JfSURFQUxURUs9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCX0dFTkVSQUxfVE9V Q0g9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCX0dPVE9QPXkKQ09ORklHX1RPVUNIU0NSRUVOX1VT Ql9KQVNURUM9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCX0VMTz15CkNPTkZJR19UT1VDSFNDUkVF Tl9VU0JfRTJJPXkKQ09ORklHX1RPVUNIU0NSRUVOX1VTQl9aWVRST05JQz15CkNPTkZJR19UT1VD SFNDUkVFTl9VU0JfRVRUX1RDNDVVU0I9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVVNCX05FWElPPXkK Q09ORklHX1RPVUNIU0NSRUVOX1VTQl9FQVNZVE9VQ0g9eQpDT05GSUdfVE9VQ0hTQ1JFRU5fVE9V Q0hJVDIxMz1tCkNPTkZJR19UT1VDSFNDUkVFTl9UU0NfU0VSSU89bQpDT05GSUdfVE9VQ0hTQ1JF RU5fVFNDMjAwNT1tCkNPTkZJR19UT1VDSFNDUkVFTl9UU0MyMDA3PW0KQ09ORklHX1RPVUNIU0NS RUVOX1BDQVA9bQpDT05GSUdfVE9VQ0hTQ1JFRU5fU1QxMjMyPW0KQ09ORklHX1RPVUNIU0NSRUVO X1NUTVBFPW0KQ09ORklHX1RPVUNIU0NSRUVOX1RQUzY1MDdYPW0KQ09ORklHX0lOUFVUX01JU0M9 eQpDT05GSUdfSU5QVVRfQUQ3MTRYPW0KQ09ORklHX0lOUFVUX0FENzE0WF9JMkM9bQpDT05GSUdf SU5QVVRfQUQ3MTRYX1NQST1tCkNPTkZJR19JTlBVVF9CTUExNTA9bQpDT05GSUdfSU5QVVRfUENT UEtSPW0KQ09ORklHX0lOUFVUX01DMTM3ODNfUFdSQlVUVE9OPW0KQ09ORklHX0lOUFVUX01NQTg0 NTA9bQpDT05GSUdfSU5QVVRfTVBVMzA1MD1tCkNPTkZJR19JTlBVVF9BUEFORUw9bQpDT05GSUdf SU5QVVRfR1AyQT1tCkNPTkZJR19JTlBVVF9HUElPX1RJTFRfUE9MTEVEPW0KQ09ORklHX0lOUFVU X0FUTEFTX0JUTlM9bQpDT05GSUdfSU5QVVRfQVRJX1JFTU9URTI9bQpDT05GSUdfSU5QVVRfS0VZ U1BBTl9SRU1PVEU9bQpDT05GSUdfSU5QVVRfS1hUSjk9bQojIENPTkZJR19JTlBVVF9LWFRKOV9Q T0xMRURfTU9ERSBpcyBub3Qgc2V0CkNPTkZJR19JTlBVVF9QT1dFUk1BVEU9bQpDT05GSUdfSU5Q VVRfWUVBTElOSz1tCkNPTkZJR19JTlBVVF9DTTEwOT1tCkNPTkZJR19JTlBVVF9VSU5QVVQ9bQpD T05GSUdfSU5QVVRfUENGODU3ND1tCkNPTkZJR19JTlBVVF9HUElPX1JPVEFSWV9FTkNPREVSPW0K Q09ORklHX0lOUFVUX0RBOTA1Ml9PTktFWT1tCkNPTkZJR19JTlBVVF9QQ0FQPW0KQ09ORklHX0lO UFVUX0FEWEwzNFg9bQpDT05GSUdfSU5QVVRfQURYTDM0WF9JMkM9bQpDT05GSUdfSU5QVVRfQURY TDM0WF9TUEk9bQpDT05GSUdfSU5QVVRfQ01BMzAwMD1tCkNPTkZJR19JTlBVVF9DTUEzMDAwX0ky Qz1tCkNPTkZJR19JTlBVVF9YRU5fS0JEREVWX0ZST05URU5EPXkKCiMKIyBIYXJkd2FyZSBJL08g cG9ydHMKIwpDT05GSUdfU0VSSU89eQpDT05GSUdfU0VSSU9fSTgwNDI9eQpDT05GSUdfU0VSSU9f U0VSUE9SVD1tCkNPTkZJR19TRVJJT19DVDgyQzcxMD1tCkNPTkZJR19TRVJJT19QQVJLQkQ9bQpD T05GSUdfU0VSSU9fUENJUFMyPW0KQ09ORklHX1NFUklPX0xJQlBTMj15CkNPTkZJR19TRVJJT19S QVc9bQpDT05GSUdfU0VSSU9fQUxURVJBX1BTMj1tCkNPTkZJR19TRVJJT19QUzJNVUxUPW0KQ09O RklHX0dBTUVQT1JUPW0KQ09ORklHX0dBTUVQT1JUX05TNTU4PW0KQ09ORklHX0dBTUVQT1JUX0w0 PW0KQ09ORklHX0dBTUVQT1JUX0VNVTEwSzE9bQpDT05GSUdfR0FNRVBPUlRfRk04MDE9bQoKIwoj IENoYXJhY3RlciBkZXZpY2VzCiMKQ09ORklHX1ZUPXkKQ09ORklHX0NPTlNPTEVfVFJBTlNMQVRJ T05TPXkKQ09ORklHX1ZUX0NPTlNPTEU9eQpDT05GSUdfVlRfQ09OU09MRV9TTEVFUD15CkNPTkZJ R19IV19DT05TT0xFPXkKQ09ORklHX1ZUX0hXX0NPTlNPTEVfQklORElORz15CkNPTkZJR19VTklY OThfUFRZUz15CkNPTkZJR19ERVZQVFNfTVVMVElQTEVfSU5TVEFOQ0VTPXkKQ09ORklHX0xFR0FD WV9QVFlTPXkKQ09ORklHX0xFR0FDWV9QVFlfQ09VTlQ9MApDT05GSUdfU0VSSUFMX05PTlNUQU5E QVJEPXkKQ09ORklHX1JPQ0tFVFBPUlQ9bQpDT05GSUdfQ1lDTEFERVM9bQojIENPTkZJR19DWVpf SU5UUiBpcyBub3Qgc2V0CkNPTkZJR19NT1hBX0lOVEVMTElPPW0KQ09ORklHX01PWEFfU01BUlRJ Tz1tCkNPTkZJR19TWU5DTElOSz1tCkNPTkZJR19TWU5DTElOS01QPW0KQ09ORklHX1NZTkNMSU5L X0dUPW0KQ09ORklHX05PWk9NST1tCkNPTkZJR19JU0k9bQpDT05GSUdfTl9IRExDPW0KQ09ORklH X05fR1NNPW0KIyBDT05GSUdfVFJBQ0VfU0lOSyBpcyBub3Qgc2V0CkNPTkZJR19ERVZLTUVNPXkK Q09ORklHX1NUQUxEUlY9eQoKIwojIFNlcmlhbCBkcml2ZXJzCiMKQ09ORklHX1NFUklBTF84MjUw PW0KQ09ORklHX0ZJWF9FQVJMWUNPTl9NRU09eQpDT05GSUdfU0VSSUFMXzgyNTBfUENJPW0KQ09O RklHX1NFUklBTF84MjUwX1BOUD1tCkNPTkZJR19TRVJJQUxfODI1MF9DUz1tCkNPTkZJR19TRVJJ QUxfODI1MF9OUl9VQVJUUz0xNgpDT05GSUdfU0VSSUFMXzgyNTBfUlVOVElNRV9VQVJUUz04CiMg Q09ORklHX1NFUklBTF84MjUwX0VYVEVOREVEIGlzIG5vdCBzZXQKCiMKIyBOb24tODI1MCBzZXJp YWwgcG9ydCBzdXBwb3J0CiMKIyBDT05GSUdfU0VSSUFMX01BWDMxMDAgaXMgbm90IHNldAojIENP TkZJR19TRVJJQUxfTUFYMzEwNyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFUklBTF9NUlNUX01BWDMx MTAgaXMgbm90IHNldAojIENPTkZJR19TRVJJQUxfTUZEX0hTVSBpcyBub3Qgc2V0CkNPTkZJR19T RVJJQUxfVUFSVExJVEU9bQpDT05GSUdfU0VSSUFMX0NPUkU9bQpDT05GSUdfU0VSSUFMX0pTTT1t CkNPTkZJR19TRVJJQUxfVElNQkVSREFMRT1tCkNPTkZJR19TRVJJQUxfQUxURVJBX0pUQUdVQVJU PW0KQ09ORklHX1NFUklBTF9BTFRFUkFfVUFSVD1tCkNPTkZJR19TRVJJQUxfQUxURVJBX1VBUlRf TUFYUE9SVFM9NApDT05GSUdfU0VSSUFMX0FMVEVSQV9VQVJUX0JBVURSQVRFPTExNTIwMApDT05G SUdfU0VSSUFMX0lGWDZYNjA9bQpDT05GSUdfU0VSSUFMX1BDSF9VQVJUPW0KQ09ORklHX1NFUklB TF9YSUxJTlhfUFNfVUFSVD1tCkNPTkZJR19QUklOVEVSPW0KIyBDT05GSUdfTFBfQ09OU09MRSBp cyBub3Qgc2V0CkNPTkZJR19QUERFVj1tCkNPTkZJR19IVkNfRFJJVkVSPXkKQ09ORklHX0hWQ19J UlE9eQpDT05GSUdfSFZDX1hFTj15CkNPTkZJR19IVkNfWEVOX0ZST05URU5EPXkKQ09ORklHX1ZJ UlRJT19DT05TT0xFPW0KQ09ORklHX0lQTUlfSEFORExFUj1tCkNPTkZJR19JUE1JX1BBTklDX0VW RU5UPXkKIyBDT05GSUdfSVBNSV9QQU5JQ19TVFJJTkcgaXMgbm90IHNldApDT05GSUdfSVBNSV9E RVZJQ0VfSU5URVJGQUNFPW0KQ09ORklHX0lQTUlfU0k9bQpDT05GSUdfSVBNSV9XQVRDSERPRz1t CkNPTkZJR19JUE1JX1BPV0VST0ZGPW0KQ09ORklHX0hXX1JBTkRPTT15CkNPTkZJR19IV19SQU5E T01fVElNRVJJT01FTT1tCkNPTkZJR19IV19SQU5ET01fSU5URUw9bQpDT05GSUdfSFdfUkFORE9N X0FNRD1tCkNPTkZJR19IV19SQU5ET01fVklBPW0KQ09ORklHX0hXX1JBTkRPTV9WSVJUSU89bQpD T05GSUdfTlZSQU09eQpDT05GSUdfUjM5NjQ9bQpDT05GSUdfQVBQTElDT009bQoKIwojIFBDTUNJ QSBjaGFyYWN0ZXIgZGV2aWNlcwojCkNPTkZJR19TWU5DTElOS19DUz1tCkNPTkZJR19DQVJETUFO XzQwMDA9bQpDT05GSUdfQ0FSRE1BTl80MDQwPW0KQ09ORklHX0lQV0lSRUxFU1M9bQpDT05GSUdf TVdBVkU9bQpDT05GSUdfUkFXX0RSSVZFUj1tCkNPTkZJR19NQVhfUkFXX0RFVlM9NDA5NgojIENP TkZJR19IUEVUIGlzIG5vdCBzZXQKQ09ORklHX0hBTkdDSEVDS19USU1FUj1tCkNPTkZJR19UQ0df VFBNPW0KQ09ORklHX1RDR19USVM9bQpDT05GSUdfVENHX05TQz1tCkNPTkZJR19UQ0dfQVRNRUw9 bQpDT05GSUdfVENHX0lORklORU9OPW0KQ09ORklHX1RFTENMT0NLPW0KQ09ORklHX0RFVlBPUlQ9 eQpDT05GSUdfUkFNT09QUz15CkNPTkZJR19JMkM9bQpDT05GSUdfSTJDX0JPQVJESU5GTz15CkNP TkZJR19JMkNfQ09NUEFUPXkKQ09ORklHX0kyQ19DSEFSREVWPW0KQ09ORklHX0kyQ19NVVg9bQoK IwojIE11bHRpcGxleGVyIEkyQyBDaGlwIHN1cHBvcnQKIwpDT05GSUdfSTJDX01VWF9HUElPPW0K Q09ORklHX0kyQ19NVVhfUENBOTU0MT1tCkNPTkZJR19JMkNfTVVYX1BDQTk1NHg9bQpDT05GSUdf STJDX0hFTFBFUl9BVVRPPXkKQ09ORklHX0kyQ19TTUJVUz1tCkNPTkZJR19JMkNfQUxHT0JJVD1t CkNPTkZJR19JMkNfQUxHT1BDQT1tCgojCiMgSTJDIEhhcmR3YXJlIEJ1cyBzdXBwb3J0CiMKCiMK IyBQQyBTTUJ1cyBob3N0IGNvbnRyb2xsZXIgZHJpdmVycwojCkNPTkZJR19JMkNfQUxJMTUzNT1t CkNPTkZJR19JMkNfQUxJMTU2Mz1tCkNPTkZJR19JMkNfQUxJMTVYMz1tCkNPTkZJR19JMkNfQU1E NzU2PW0KQ09ORklHX0kyQ19BTUQ3NTZfUzQ4ODI9bQpDT05GSUdfSTJDX0FNRDgxMTE9bQpDT05G SUdfSTJDX0k4MDE9bQpDT05GSUdfSTJDX0lTQ0g9bQpDT05GSUdfSTJDX1BJSVg0PW0KQ09ORklH X0kyQ19ORk9SQ0UyPW0KQ09ORklHX0kyQ19ORk9SQ0UyX1M0OTg1PW0KQ09ORklHX0kyQ19TSVM1 NTk1PW0KQ09ORklHX0kyQ19TSVM2MzA9bQpDT05GSUdfSTJDX1NJUzk2WD1tCkNPTkZJR19JMkNf VklBPW0KQ09ORklHX0kyQ19WSUFQUk89bQoKIwojIEFDUEkgZHJpdmVycwojCkNPTkZJR19JMkNf U0NNST1tCgojCiMgSTJDIHN5c3RlbSBidXMgZHJpdmVycyAobW9zdGx5IGVtYmVkZGVkIC8gc3lz dGVtLW9uLWNoaXApCiMKQ09ORklHX0kyQ19ERVNJR05XQVJFX0NPUkU9bQpDT05GSUdfSTJDX0RF U0lHTldBUkVfUENJPW0KQ09ORklHX0kyQ19FRzIwVD1tCkNPTkZJR19JMkNfR1BJTz1tCkNPTkZJ R19JMkNfSU5URUxfTUlEPW0KQ09ORklHX0kyQ19PQ09SRVM9bQpDT05GSUdfSTJDX1BDQV9QTEFU Rk9STT1tCiMgQ09ORklHX0kyQ19QWEFfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX1NJTVRF QyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19YSUxJTlggaXMgbm90IHNldAoKIwojIEV4dGVybmFs IEkyQy9TTUJ1cyBhZGFwdGVyIGRyaXZlcnMKIwpDT05GSUdfSTJDX0RJT0xBTl9VMkM9bQpDT05G SUdfSTJDX1BBUlBPUlQ9bQpDT05GSUdfSTJDX1BBUlBPUlRfTElHSFQ9bQpDT05GSUdfSTJDX1RB T1NfRVZNPW0KQ09ORklHX0kyQ19USU5ZX1VTQj1tCgojCiMgT3RoZXIgSTJDL1NNQnVzIGJ1cyBk cml2ZXJzCiMKQ09ORklHX0kyQ19TVFVCPW0KIyBDT05GSUdfSTJDX0RFQlVHX0NPUkUgaXMgbm90 IHNldAojIENPTkZJR19JMkNfREVCVUdfQUxHTyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19ERUJV R19CVVMgaXMgbm90IHNldApDT05GSUdfU1BJPXkKIyBDT05GSUdfU1BJX0RFQlVHIGlzIG5vdCBz ZXQKQ09ORklHX1NQSV9NQVNURVI9eQoKIwojIFNQSSBNYXN0ZXIgQ29udHJvbGxlciBEcml2ZXJz CiMKQ09ORklHX1NQSV9BTFRFUkE9bQpDT05GSUdfU1BJX0JJVEJBTkc9bQpDT05GSUdfU1BJX0JV VFRFUkZMWT1tCkNPTkZJR19TUElfR1BJTz1tCkNPTkZJR19TUElfTE03MF9MTFA9bQpDT05GSUdf U1BJX09DX1RJTlk9bQojIENPTkZJR19TUElfUFhBMlhYX1BDSSBpcyBub3Qgc2V0CkNPTkZJR19T UElfVE9QQ0xJRkZfUENIPW0KQ09ORklHX1NQSV9YSUxJTlg9bQpDT05GSUdfU1BJX0RFU0lHTldB UkU9eQpDT05GSUdfU1BJX0RXX1BDST1tCiMgQ09ORklHX1NQSV9EV19NSURfRE1BIGlzIG5vdCBz ZXQKCiMKIyBTUEkgUHJvdG9jb2wgTWFzdGVycwojCkNPTkZJR19TUElfU1BJREVWPW0KQ09ORklH X1NQSV9UTEU2MlgwPW0KQ09ORklHX0hTST1tCkNPTkZJR19IU0lfQk9BUkRJTkZPPXkKCiMKIyBI U0kgY2xpZW50cwojCkNPTkZJR19IU0lfQ0hBUj1tCgojCiMgUFBTIHN1cHBvcnQKIwpDT05GSUdf UFBTPW0KIyBDT05GSUdfUFBTX0RFQlVHIGlzIG5vdCBzZXQKCiMKIyBQUFMgY2xpZW50cyBzdXBw b3J0CiMKIyBDT05GSUdfUFBTX0NMSUVOVF9LVElNRVIgaXMgbm90IHNldApDT05GSUdfUFBTX0NM SUVOVF9MRElTQz1tCkNPTkZJR19QUFNfQ0xJRU5UX1BBUlBPUlQ9bQpDT05GSUdfUFBTX0NMSUVO VF9HUElPPW0KCiMKIyBQUFMgZ2VuZXJhdG9ycyBzdXBwb3J0CiMKCiMKIyBQVFAgY2xvY2sgc3Vw cG9ydAojCiMgQ09ORklHX1BUUF8xNTg4X0NMT0NLIGlzIG5vdCBzZXQKQ09ORklHX0FSQ0hfV0FO VF9PUFRJT05BTF9HUElPTElCPXkKQ09ORklHX0dQSU9MSUI9eQojIENPTkZJR19ERUJVR19HUElP IGlzIG5vdCBzZXQKQ09ORklHX0dQSU9fU1lTRlM9eQpDT05GSUdfR1BJT19HRU5FUklDPW0KQ09O RklHX0dQSU9fTUFYNzMwWD1tCgojCiMgTWVtb3J5IG1hcHBlZCBHUElPIGRyaXZlcnM6CiMKQ09O RklHX0dQSU9fR0VORVJJQ19QTEFURk9STT1tCkNPTkZJR19HUElPX0lUODc2MUU9bQpDT05GSUdf R1BJT19TQ0g9bQpDT05GSUdfR1BJT19WWDg1NT1tCgojCiMgSTJDIEdQSU8gZXhwYW5kZXJzOgoj CkNPTkZJR19HUElPX01BWDczMDA9bQpDT05GSUdfR1BJT19NQVg3MzJYPW0KQ09ORklHX0dQSU9f UENBOTUzWD1tCkNPTkZJR19HUElPX1BDRjg1N1g9bQpDT05GSUdfR1BJT19TVE1QRT15CkNPTkZJ R19HUElPX1RQUzY1OTEyPW0KQ09ORklHX0dQSU9fQURQNTU4OD1tCgojCiMgUENJIEdQSU8gZXhw YW5kZXJzOgojCkNPTkZJR19HUElPX0NTNTUzNT1tCkNPTkZJR19HUElPX0xBTkdXRUxMPXkKQ09O RklHX0dQSU9fUENIPW0KQ09ORklHX0dQSU9fTUxfSU9IPW0KIyBDT05GSUdfR1BJT19USU1CRVJE QUxFIGlzIG5vdCBzZXQKQ09ORklHX0dQSU9fUkRDMzIxWD1tCgojCiMgU1BJIEdQSU8gZXhwYW5k ZXJzOgojCkNPTkZJR19HUElPX01BWDczMDE9bQpDT05GSUdfR1BJT19NQ1AyM1MwOD1tCkNPTkZJ R19HUElPX01DMzM4ODA9bQpDT05GSUdfR1BJT183NFgxNjQ9bQoKIwojIEFDOTcgR1BJTyBleHBh bmRlcnM6CiMKQ09ORklHX0dQSU9fVUNCMTQwMD15CgojCiMgTU9EVUxidXMgR1BJTyBleHBhbmRl cnM6CiMKQ09ORklHX0dQSU9fSkFOWl9UVEw9bQpDT05GSUdfVzE9bQpDT05GSUdfVzFfQ09OPXkK CiMKIyAxLXdpcmUgQnVzIE1hc3RlcnMKIwpDT05GSUdfVzFfTUFTVEVSX01BVFJPWD1tCkNPTkZJ R19XMV9NQVNURVJfRFMyNDkwPW0KQ09ORklHX1cxX01BU1RFUl9EUzI0ODI9bQojIENPTkZJR19X MV9NQVNURVJfRFMxV00gaXMgbm90IHNldApDT05GSUdfVzFfTUFTVEVSX0dQSU89bQoKIwojIDEt d2lyZSBTbGF2ZXMKIwpDT05GSUdfVzFfU0xBVkVfVEhFUk09bQpDT05GSUdfVzFfU0xBVkVfU01F TT1tCiMgQ09ORklHX1cxX1NMQVZFX0RTMjQwOCBpcyBub3Qgc2V0CkNPTkZJR19XMV9TTEFWRV9E UzI0MjM9bQpDT05GSUdfVzFfU0xBVkVfRFMyNDMxPW0KQ09ORklHX1cxX1NMQVZFX0RTMjQzMz1t CkNPTkZJR19XMV9TTEFWRV9EUzI0MzNfQ1JDPXkKQ09ORklHX1cxX1NMQVZFX0RTMjc2MD1tCiMg Q09ORklHX1cxX1NMQVZFX0RTMjc4MCBpcyBub3Qgc2V0CkNPTkZJR19XMV9TTEFWRV9EUzI3ODE9 bQpDT05GSUdfVzFfU0xBVkVfQlEyNzAwMD1tCkNPTkZJR19QT1dFUl9TVVBQTFk9eQojIENPTkZJ R19QT1dFUl9TVVBQTFlfREVCVUcgaXMgbm90IHNldApDT05GSUdfUERBX1BPV0VSPW0KIyBDT05G SUdfVEVTVF9QT1dFUiBpcyBub3Qgc2V0CkNPTkZJR19CQVRURVJZX0RTMjc2MD1tCiMgQ09ORklH X0JBVFRFUllfRFMyNzgwIGlzIG5vdCBzZXQKQ09ORklHX0JBVFRFUllfRFMyNzgxPW0KQ09ORklH X0JBVFRFUllfRFMyNzgyPW0KQ09ORklHX0JBVFRFUllfU0JTPW0KQ09ORklHX0JBVFRFUllfQlEy N3gwMD1tCkNPTkZJR19CQVRURVJZX0JRMjdYMDBfSTJDPXkKQ09ORklHX0JBVFRFUllfQlEyN1gw MF9QTEFURk9STT15CkNPTkZJR19CQVRURVJZX01BWDE3MDQwPW0KQ09ORklHX0JBVFRFUllfTUFY MTcwNDI9bQpDT05GSUdfQ0hBUkdFUl9NQVg4OTAzPW0KQ09ORklHX0NIQVJHRVJfTFA4NzI3PW0K Q09ORklHX0NIQVJHRVJfR1BJTz1tCkNPTkZJR19DSEFSR0VSX01BTkFHRVI9eQpDT05GSUdfQ0hB UkdFUl9TTUIzNDc9bQpDT05GSUdfSFdNT049bQpDT05GSUdfSFdNT05fVklEPW0KIyBDT05GSUdf SFdNT05fREVCVUdfQ0hJUCBpcyBub3Qgc2V0CgojCiMgTmF0aXZlIGRyaXZlcnMKIwpDT05GSUdf U0VOU09SU19BQklUVUdVUlU9bQpDT05GSUdfU0VOU09SU19BQklUVUdVUlUzPW0KQ09ORklHX1NF TlNPUlNfQUQ3MzE0PW0KQ09ORklHX1NFTlNPUlNfQUQ3NDE0PW0KQ09ORklHX1NFTlNPUlNfQUQ3 NDE4PW0KQ09ORklHX1NFTlNPUlNfQURDWFg9bQpDT05GSUdfU0VOU09SU19BRE0xMDIxPW0KQ09O RklHX1NFTlNPUlNfQURNMTAyNT1tCkNPTkZJR19TRU5TT1JTX0FETTEwMjY9bQpDT05GSUdfU0VO U09SU19BRE0xMDI5PW0KQ09ORklHX1NFTlNPUlNfQURNMTAzMT1tCkNPTkZJR19TRU5TT1JTX0FE TTkyNDA9bQpDT05GSUdfU0VOU09SU19BRFQ3NDExPW0KQ09ORklHX1NFTlNPUlNfQURUNzQ2Mj1t CkNPTkZJR19TRU5TT1JTX0FEVDc0NzA9bQpDT05GSUdfU0VOU09SU19BRFQ3NDc1PW0KQ09ORklH X1NFTlNPUlNfQVNDNzYyMT1tCkNPTkZJR19TRU5TT1JTX0s4VEVNUD1tCkNPTkZJR19TRU5TT1JT X0sxMFRFTVA9bQpDT05GSUdfU0VOU09SU19GQU0xNUhfUE9XRVI9bQpDT05GSUdfU0VOU09SU19B U0IxMDA9bQpDT05GSUdfU0VOU09SU19BVFhQMT1tCkNPTkZJR19TRU5TT1JTX0RTNjIwPW0KQ09O RklHX1NFTlNPUlNfRFMxNjIxPW0KQ09ORklHX1NFTlNPUlNfSTVLX0FNQj1tCkNPTkZJR19TRU5T T1JTX0Y3MTgwNUY9bQpDT05GSUdfU0VOU09SU19GNzE4ODJGRz1tCkNPTkZJR19TRU5TT1JTX0Y3 NTM3NVM9bQpDT05GSUdfU0VOU09SU19GU0NITUQ9bQpDT05GSUdfU0VOU09SU19HNzYwQT1tCkNP TkZJR19TRU5TT1JTX0dMNTE4U009bQpDT05GSUdfU0VOU09SU19HTDUyMFNNPW0KQ09ORklHX1NF TlNPUlNfR1BJT19GQU49bQpDT05GSUdfU0VOU09SU19DT1JFVEVNUD1tCkNPTkZJR19TRU5TT1JT X0lCTUFFTT1tCkNPTkZJR19TRU5TT1JTX0lCTVBFWD1tCkNPTkZJR19TRU5TT1JTX0lUODc9bQpD T05GSUdfU0VOU09SU19KQzQyPW0KQ09ORklHX1NFTlNPUlNfTElORUFHRT1tCkNPTkZJR19TRU5T T1JTX0xNNjM9bQpDT05GSUdfU0VOU09SU19MTTcwPW0KQ09ORklHX1NFTlNPUlNfTE03Mz1tCkNP TkZJR19TRU5TT1JTX0xNNzU9bQpDT05GSUdfU0VOU09SU19MTTc3PW0KQ09ORklHX1NFTlNPUlNf TE03OD1tCkNPTkZJR19TRU5TT1JTX0xNODA9bQpDT05GSUdfU0VOU09SU19MTTgzPW0KQ09ORklH X1NFTlNPUlNfTE04NT1tCkNPTkZJR19TRU5TT1JTX0xNODc9bQpDT05GSUdfU0VOU09SU19MTTkw PW0KQ09ORklHX1NFTlNPUlNfTE05Mj1tCkNPTkZJR19TRU5TT1JTX0xNOTM9bQpDT05GSUdfU0VO U09SU19MVEM0MTUxPW0KQ09ORklHX1NFTlNPUlNfTFRDNDIxNT1tCkNPTkZJR19TRU5TT1JTX0xU QzQyNDU9bQpDT05GSUdfU0VOU09SU19MVEM0MjYxPW0KQ09ORklHX1NFTlNPUlNfTE05NTI0MT1t CkNPTkZJR19TRU5TT1JTX0xNOTUyNDU9bQpDT05GSUdfU0VOU09SU19NQVgxMTExPW0KQ09ORklH X1NFTlNPUlNfTUFYMTYwNjU9bQpDT05GSUdfU0VOU09SU19NQVgxNjE5PW0KQ09ORklHX1NFTlNP UlNfTUFYMTY2OD1tCkNPTkZJR19TRU5TT1JTX01BWDY2Mzk9bQpDT05GSUdfU0VOU09SU19NQVg2 NjQyPW0KQ09ORklHX1NFTlNPUlNfTUFYNjY1MD1tCkNPTkZJR19TRU5TT1JTX01DUDMwMjE9bQpD T05GSUdfU0VOU09SU19OVENfVEhFUk1JU1RPUj1tCkNPTkZJR19TRU5TT1JTX1BDODczNjA9bQpD T05GSUdfU0VOU09SU19QQzg3NDI3PW0KQ09ORklHX1NFTlNPUlNfUENGODU5MT1tCkNPTkZJR19Q TUJVUz1tCkNPTkZJR19TRU5TT1JTX1BNQlVTPW0KQ09ORklHX1NFTlNPUlNfQURNMTI3NT1tCkNP TkZJR19TRU5TT1JTX0xNMjUwNjY9bQpDT05GSUdfU0VOU09SU19MVEMyOTc4PW0KQ09ORklHX1NF TlNPUlNfTUFYMTYwNjQ9bQpDT05GSUdfU0VOU09SU19NQVgzNDQ0MD1tCkNPTkZJR19TRU5TT1JT X01BWDg2ODg9bQpDT05GSUdfU0VOU09SU19VQ0Q5MDAwPW0KQ09ORklHX1NFTlNPUlNfVUNEOTIw MD1tCkNPTkZJR19TRU5TT1JTX1pMNjEwMD1tCkNPTkZJR19TRU5TT1JTX1NIVDE1PW0KQ09ORklH X1NFTlNPUlNfU0hUMjE9bQpDT05GSUdfU0VOU09SU19TSVM1NTk1PW0KQ09ORklHX1NFTlNPUlNf U01NNjY1PW0KQ09ORklHX1NFTlNPUlNfRE1FMTczNz1tCkNPTkZJR19TRU5TT1JTX0VNQzE0MDM9 bQpDT05GSUdfU0VOU09SU19FTUMyMTAzPW0KQ09ORklHX1NFTlNPUlNfRU1DNlcyMDE9bQpDT05G SUdfU0VOU09SU19TTVNDNDdNMT1tCkNPTkZJR19TRU5TT1JTX1NNU0M0N00xOTI9bQpDT05GSUdf U0VOU09SU19TTVNDNDdCMzk3PW0KQ09ORklHX1NFTlNPUlNfU0NINTZYWF9DT01NT049bQpDT05G SUdfU0VOU09SU19TQ0g1NjI3PW0KQ09ORklHX1NFTlNPUlNfU0NINTYzNj1tCkNPTkZJR19TRU5T T1JTX0FEUzEwMTU9bQpDT05GSUdfU0VOU09SU19BRFM3ODI4PW0KQ09ORklHX1NFTlNPUlNfQURT Nzg3MT1tCkNPTkZJR19TRU5TT1JTX0FNQzY4MjE9bQpDT05GSUdfU0VOU09SU19USE1DNTA9bQpD T05GSUdfU0VOU09SU19UTVAxMDI9bQpDT05GSUdfU0VOU09SU19UTVA0MDE9bQpDT05GSUdfU0VO U09SU19UTVA0MjE9bQpDT05GSUdfU0VOU09SU19WSUFfQ1BVVEVNUD1tCkNPTkZJR19TRU5TT1JT X1ZJQTY4NkE9bQpDT05GSUdfU0VOU09SU19WVDEyMTE9bQpDT05GSUdfU0VOU09SU19WVDgyMzE9 bQpDT05GSUdfU0VOU09SU19XODM3ODFEPW0KQ09ORklHX1NFTlNPUlNfVzgzNzkxRD1tCkNPTkZJ R19TRU5TT1JTX1c4Mzc5MkQ9bQpDT05GSUdfU0VOU09SU19XODM3OTM9bQpDT05GSUdfU0VOU09S U19XODM3OTU9bQpDT05GSUdfU0VOU09SU19XODM3OTVfRkFOQ1RSTD15CkNPTkZJR19TRU5TT1JT X1c4M0w3ODVUUz1tCkNPTkZJR19TRU5TT1JTX1c4M0w3ODZORz1tCkNPTkZJR19TRU5TT1JTX1c4 MzYyN0hGPW0KQ09ORklHX1NFTlNPUlNfVzgzNjI3RUhGPW0KQ09ORklHX1NFTlNPUlNfQVBQTEVT TUM9bQpDT05GSUdfU0VOU09SU19NQzEzNzgzX0FEQz1tCgojCiMgQUNQSSBkcml2ZXJzCiMKQ09O RklHX1NFTlNPUlNfQUNQSV9QT1dFUj1tCkNPTkZJR19TRU5TT1JTX0FUSzAxMTA9bQpDT05GSUdf VEhFUk1BTD15CkNPTkZJR19XQVRDSERPRz15CkNPTkZJR19XQVRDSERPR19DT1JFPXkKIyBDT05G SUdfV0FUQ0hET0dfTk9XQVlPVVQgaXMgbm90IHNldAoKIwojIFdhdGNoZG9nIERldmljZSBEcml2 ZXJzCiMKQ09ORklHX1NPRlRfV0FUQ0hET0c9bQpDT05GSUdfQUNRVUlSRV9XRFQ9bQpDT05GSUdf QURWQU5URUNIX1dEVD1tCkNPTkZJR19BTElNMTUzNV9XRFQ9bQpDT05GSUdfQUxJTTcxMDFfV0RU PW0KQ09ORklHX0Y3MTgwOEVfV0RUPW0KQ09ORklHX1NQNTEwMF9UQ089bQpDT05GSUdfR0VPREVf V0RUPW0KQ09ORklHX1NDNTIwX1dEVD1tCkNPTkZJR19TQkNfRklUUEMyX1dBVENIRE9HPW0KQ09O RklHX0VVUk9URUNIX1dEVD1tCkNPTkZJR19JQjcwMF9XRFQ9bQpDT05GSUdfSUJNQVNSPW0KQ09O RklHX1dBRkVSX1dEVD1tCkNPTkZJR19JNjMwMEVTQl9XRFQ9bQpDT05GSUdfSVRDT19XRFQ9bQpD T05GSUdfSVRDT19WRU5ET1JfU1VQUE9SVD15CkNPTkZJR19JVDg3MTJGX1dEVD1tCkNPTkZJR19J VDg3X1dEVD1tCkNPTkZJR19IUF9XQVRDSERPRz1tCiMgQ09ORklHX0hQV0RUX05NSV9ERUNPRElO RyBpcyBub3Qgc2V0CkNPTkZJR19TQzEyMDBfV0RUPW0KQ09ORklHX1BDODc0MTNfV0RUPW0KQ09O RklHX05WX1RDTz1tCkNPTkZJR182MFhYX1dEVD1tCkNPTkZJR19TQkM4MzYwX1dEVD1tCkNPTkZJ R19DUFU1X1dEVD1tCkNPTkZJR19TTVNDX1NDSDMxMVhfV0RUPW0KQ09ORklHX1NNU0MzN0I3ODdf V0RUPW0KQ09ORklHX1ZJQV9XRFQ9bQpDT05GSUdfVzgzNjI3SEZfV0RUPW0KQ09ORklHX1c4MzY5 N0hGX1dEVD1tCkNPTkZJR19XODM2OTdVR19XRFQ9bQpDT05GSUdfVzgzODc3Rl9XRFQ9bQpDT05G SUdfVzgzOTc3Rl9XRFQ9bQpDT05GSUdfTUFDSFpfV0RUPW0KQ09ORklHX1NCQ19FUFhfQzNfV0FU Q0hET0c9bQpDT05GSUdfWEVOX1dEVD1tCgojCiMgUENJLWJhc2VkIFdhdGNoZG9nIENhcmRzCiMK Q09ORklHX1BDSVBDV0FUQ0hET0c9bQpDT05GSUdfV0RUUENJPW0KCiMKIyBVU0ItYmFzZWQgV2F0 Y2hkb2cgQ2FyZHMKIwpDT05GSUdfVVNCUENXQVRDSERPRz1tCkNPTkZJR19TU0JfUE9TU0lCTEU9 eQoKIwojIFNvbmljcyBTaWxpY29uIEJhY2twbGFuZQojCkNPTkZJR19TU0I9bQpDT05GSUdfU1NC X1NQUk9NPXkKQ09ORklHX1NTQl9CTE9DS0lPPXkKQ09ORklHX1NTQl9QQ0lIT1NUX1BPU1NJQkxF PXkKQ09ORklHX1NTQl9QQ0lIT1NUPXkKQ09ORklHX1NTQl9CNDNfUENJX0JSSURHRT15CkNPTkZJ R19TU0JfUENNQ0lBSE9TVF9QT1NTSUJMRT15CkNPTkZJR19TU0JfUENNQ0lBSE9TVD15CkNPTkZJ R19TU0JfU0RJT0hPU1RfUE9TU0lCTEU9eQpDT05GSUdfU1NCX1NESU9IT1NUPXkKIyBDT05GSUdf U1NCX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1NTQl9EUklWRVJfUENJQ09SRV9QT1NTSUJMRT15 CkNPTkZJR19TU0JfRFJJVkVSX1BDSUNPUkU9eQpDT05GSUdfQkNNQV9QT1NTSUJMRT15CgojCiMg QnJvYWRjb20gc3BlY2lmaWMgQU1CQQojCiMgQ09ORklHX0JDTUEgaXMgbm90IHNldAoKIwojIE11 bHRpZnVuY3Rpb24gZGV2aWNlIGRyaXZlcnMKIwpDT05GSUdfTUZEX0NPUkU9eQpDT05GSUdfTUZE X1NNNTAxPW0KQ09ORklHX01GRF9TTTUwMV9HUElPPXkKQ09ORklHX0hUQ19QQVNJQzM9bQpDT05G SUdfVUNCMTQwMF9DT1JFPW0KQ09ORklHX1RQUzYxMDVYPW0KQ09ORklHX1RQUzY1MDEwPW0KQ09O RklHX1RQUzY1MDdYPW0KQ09ORklHX01GRF9UUFM2NTIxNz1tCkNPTkZJR19NRkRfVFBTNjU5MTI9 eQpDT05GSUdfTUZEX1RQUzY1OTEyX1NQST15CkNPTkZJR19NRkRfU1RNUEU9eQoKIwojIFNUTVBF IEludGVyZmFjZSBEcml2ZXJzCiMKQ09ORklHX1NUTVBFX1NQST15CiMgQ09ORklHX01GRF9UTUlP IGlzIG5vdCBzZXQKQ09ORklHX1BNSUNfREE5MDUyPXkKQ09ORklHX01GRF9EQTkwNTJfU1BJPXkK Q09ORklHX01GRF9XTTg0MDA9bQojIENPTkZJR19NRkRfV004MzFYX1NQSSBpcyBub3Qgc2V0CiMg Q09ORklHX01GRF9QQ0Y1MDYzMyBpcyBub3Qgc2V0CkNPTkZJR19NRkRfTUMxMzc4Mz1tCkNPTkZJ R19NRkRfTUMxM1hYWD1tCiMgQ09ORklHX0FCWDUwMF9DT1JFIGlzIG5vdCBzZXQKQ09ORklHX0Va WF9QQ0FQPXkKQ09ORklHX01GRF9DUzU1MzU9bQpDT05GSUdfTUZEX1RJTUJFUkRBTEU9bQpDT05G SUdfTFBDX1NDSD1tCkNPTkZJR19NRkRfUkRDMzIxWD1tCkNPTkZJR19NRkRfSkFOWl9DTU9ESU89 bQpDT05GSUdfTUZEX1ZYODU1PW0KQ09ORklHX01GRF9XTDEyNzNfQ09SRT1tCkNPTkZJR19SRUdV TEFUT1I9eQojIENPTkZJR19SRUdVTEFUT1JfREVCVUcgaXMgbm90IHNldApDT05GSUdfUkVHVUxB VE9SX0RVTU1ZPXkKQ09ORklHX1JFR1VMQVRPUl9GSVhFRF9WT0xUQUdFPW0KQ09ORklHX1JFR1VM QVRPUl9WSVJUVUFMX0NPTlNVTUVSPW0KQ09ORklHX1JFR1VMQVRPUl9VU0VSU1BBQ0VfQ09OU1VN RVI9bQpDT05GSUdfUkVHVUxBVE9SX0dQSU89bQpDT05GSUdfUkVHVUxBVE9SX0FENTM5OD1tCkNP TkZJR19SRUdVTEFUT1JfREE5MDUyPW0KQ09ORklHX1JFR1VMQVRPUl9NQzEzWFhYX0NPUkU9bQpD T05GSUdfUkVHVUxBVE9SX01DMTM3ODM9bQpDT05GSUdfUkVHVUxBVE9SX01DMTM4OTI9bQpDT05G SUdfUkVHVUxBVE9SX0lTTDYyNzFBPW0KQ09ORklHX1JFR1VMQVRPUl9NQVgxNTg2PW0KQ09ORklH X1JFR1VMQVRPUl9NQVg4NjQ5PW0KQ09ORklHX1JFR1VMQVRPUl9NQVg4NjYwPW0KQ09ORklHX1JF R1VMQVRPUl9NQVg4OTUyPW0KQ09ORklHX1JFR1VMQVRPUl9QQ0FQPW0KQ09ORklHX1JFR1VMQVRP Ul9MUDM5NzE9bQpDT05GSUdfUkVHVUxBVE9SX0xQMzk3Mj1tCkNPTkZJR19SRUdVTEFUT1JfVFBT NjEwNVg9bQpDT05GSUdfUkVHVUxBVE9SX1RQUzYyMzYwPW0KQ09ORklHX1JFR1VMQVRPUl9UUFM2 NTAyMz1tCkNPTkZJR19SRUdVTEFUT1JfVFBTNjUwN1g9bQpDT05GSUdfUkVHVUxBVE9SX1RQUzY1 MjE3PW0KQ09ORklHX1JFR1VMQVRPUl9UUFM2NTI0WD1tCkNPTkZJR19SRUdVTEFUT1JfVFBTNjU5 MTI9bQpDT05GSUdfUkVHVUxBVE9SX1dNODQwMD1tCkNPTkZJR19NRURJQV9TVVBQT1JUPW0KCiMK IyBNdWx0aW1lZGlhIGNvcmUgc3VwcG9ydAojCiMgQ09ORklHX01FRElBX0NPTlRST0xMRVIgaXMg bm90IHNldApDT05GSUdfVklERU9fREVWPW0KQ09ORklHX1ZJREVPX1Y0TDJfQ09NTU9OPW0KQ09O RklHX0RWQl9DT1JFPW0KQ09ORklHX0RWQl9ORVQ9eQpDT05GSUdfVklERU9fTUVESUE9bQoKIwoj IE11bHRpbWVkaWEgZHJpdmVycwojCkNPTkZJR19WSURFT19TQUE3MTQ2PW0KQ09ORklHX1ZJREVP X1NBQTcxNDZfVlY9bQpDT05GSUdfUkNfQ09SRT1tCkNPTkZJR19MSVJDPW0KQ09ORklHX1JDX01B UD1tCkNPTkZJR19JUl9ORUNfREVDT0RFUj1tCkNPTkZJR19JUl9SQzVfREVDT0RFUj1tCkNPTkZJ R19JUl9SQzZfREVDT0RFUj1tCkNPTkZJR19JUl9KVkNfREVDT0RFUj1tCkNPTkZJR19JUl9TT05Z X0RFQ09ERVI9bQpDT05GSUdfSVJfUkM1X1NaX0RFQ09ERVI9bQpDT05GSUdfSVJfU0FOWU9fREVD T0RFUj1tCkNPTkZJR19JUl9NQ0VfS0JEX0RFQ09ERVI9bQpDT05GSUdfSVJfTElSQ19DT0RFQz1t CkNPTkZJR19SQ19BVElfUkVNT1RFPW0KIyBDT05GSUdfSVJfRU5FIGlzIG5vdCBzZXQKQ09ORklH X0lSX0lNT049bQpDT05GSUdfSVJfTUNFVVNCPW0KQ09ORklHX0lSX0lURV9DSVI9bQpDT05GSUdf SVJfRklOVEVLPW0KQ09ORklHX0lSX05VVk9UT049bQpDT05GSUdfSVJfUkVEUkFUMz1tCkNPTkZJ R19JUl9TVFJFQU1aQVA9bQpDT05GSUdfSVJfV0lOQk9ORF9DSVI9bQpDT05GSUdfUkNfTE9PUEJB Q0s9bQpDT05GSUdfSVJfR1BJT19DSVI9bQpDT05GSUdfTUVESUFfQVRUQUNIPXkKQ09ORklHX01F RElBX1RVTkVSPW0KIyBDT05GSUdfTUVESUFfVFVORVJfQ1VTVE9NSVNFIGlzIG5vdCBzZXQKQ09O RklHX01FRElBX1RVTkVSX1NJTVBMRT1tCkNPTkZJR19NRURJQV9UVU5FUl9UREE4MjkwPW0KQ09O RklHX01FRElBX1RVTkVSX1REQTgyN1g9bQpDT05GSUdfTUVESUFfVFVORVJfVERBMTgyNzE9bQpD T05GSUdfTUVESUFfVFVORVJfVERBOTg4Nz1tCkNPTkZJR19NRURJQV9UVU5FUl9URUE1NzYxPW0K Q09ORklHX01FRElBX1RVTkVSX1RFQTU3Njc9bQpDT05GSUdfTUVESUFfVFVORVJfTVQyMFhYPW0K Q09ORklHX01FRElBX1RVTkVSX01UMjA2MD1tCkNPTkZJR19NRURJQV9UVU5FUl9NVDIwNjM9bQpD T05GSUdfTUVESUFfVFVORVJfTVQyMjY2PW0KQ09ORklHX01FRElBX1RVTkVSX01UMjEzMT1tCkNP TkZJR19NRURJQV9UVU5FUl9RVDEwMTA9bQpDT05GSUdfTUVESUFfVFVORVJfWEMyMDI4PW0KQ09O RklHX01FRElBX1RVTkVSX1hDNTAwMD1tCkNPTkZJR19NRURJQV9UVU5FUl9YQzQwMDA9bQpDT05G SUdfTUVESUFfVFVORVJfTVhMNTAwNVM9bQpDT05GSUdfTUVESUFfVFVORVJfTVhMNTAwN1Q9bQpD T05GSUdfTUVESUFfVFVORVJfTUM0NFM4MDM9bQpDT05GSUdfTUVESUFfVFVORVJfTUFYMjE2NT1t CkNPTkZJR19NRURJQV9UVU5FUl9UREExODIxOD1tCkNPTkZJR19NRURJQV9UVU5FUl9UREExODIx Mj1tCkNPTkZJR19WSURFT19WNEwyPW0KQ09ORklHX1ZJREVPQlVGX0dFTj1tCkNPTkZJR19WSURF T0JVRl9ETUFfU0c9bQpDT05GSUdfVklERU9CVUZfVk1BTExPQz1tCkNPTkZJR19WSURFT0JVRl9E VkI9bQpDT05GSUdfVklERU9fQlRDWD1tCkNPTkZJR19WSURFT19UVkVFUFJPTT1tCkNPTkZJR19W SURFT19UVU5FUj1tCkNPTkZJR19WSURFT0JVRjJfQ09SRT1tCkNPTkZJR19WSURFT0JVRjJfTUVN T1BTPW0KQ09ORklHX1ZJREVPQlVGMl9ETUFfQ09OVElHPW0KQ09ORklHX1ZJREVPQlVGMl9WTUFM TE9DPW0KQ09ORklHX1ZJREVPX0NBUFRVUkVfRFJJVkVSUz15CiMgQ09ORklHX1ZJREVPX0FEVl9E RUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVPX0ZJWEVEX01JTk9SX1JBTkdFUyBpcyBub3Qg c2V0CkNPTkZJR19WSURFT19IRUxQRVJfQ0hJUFNfQVVUTz15CkNPTkZJR19WSURFT19JUl9JMkM9 bQoKIwojIEF1ZGlvIGRlY29kZXJzLCBwcm9jZXNzb3JzIGFuZCBtaXhlcnMKIwpDT05GSUdfVklE RU9fVFZBVURJTz1tCkNPTkZJR19WSURFT19UREE3NDMyPW0KQ09ORklHX1ZJREVPX1REQTk4NDA9 bQpDT05GSUdfVklERU9fVEVBNjQxNUM9bQpDT05GSUdfVklERU9fVEVBNjQyMD1tCkNPTkZJR19W SURFT19NU1AzNDAwPW0KQ09ORklHX1ZJREVPX0NTNTM0NT1tCkNPTkZJR19WSURFT19DUzUzTDMy QT1tCkNPTkZJR19WSURFT19XTTg3NzU9bQpDT05GSUdfVklERU9fV004NzM5PW0KQ09ORklHX1ZJ REVPX1ZQMjdTTVBYPW0KCiMKIyBSRFMgZGVjb2RlcnMKIwpDT05GSUdfVklERU9fU0FBNjU4OD1t CgojCiMgVmlkZW8gZGVjb2RlcnMKIwpDT05GSUdfVklERU9fQlQ4MTk9bQpDT05GSUdfVklERU9f QlQ4NTY9bQpDT05GSUdfVklERU9fQlQ4NjY9bQpDT05GSUdfVklERU9fS1MwMTI3PW0KQ09ORklH X1ZJREVPX1NBQTcxMTA9bQpDT05GSUdfVklERU9fU0FBNzExWD1tCkNPTkZJR19WSURFT19UVlA1 MTUwPW0KQ09ORklHX1ZJREVPX1ZQWDMyMjA9bQoKIwojIFZpZGVvIGFuZCBhdWRpbyBkZWNvZGVy cwojCkNPTkZJR19WSURFT19TQUE3MTdYPW0KQ09ORklHX1ZJREVPX0NYMjU4NDA9bQoKIwojIE1Q RUcgdmlkZW8gZW5jb2RlcnMKIwpDT05GSUdfVklERU9fQ1gyMzQxWD1tCgojCiMgVmlkZW8gZW5j b2RlcnMKIwpDT05GSUdfVklERU9fU0FBNzEyNz1tCkNPTkZJR19WSURFT19TQUE3MTg1PW0KQ09O RklHX1ZJREVPX0FEVjcxNzA9bQpDT05GSUdfVklERU9fQURWNzE3NT1tCgojCiMgQ2FtZXJhIHNl bnNvciBkZXZpY2VzCiMKQ09ORklHX1ZJREVPX01UOVYwMTE9bQoKIwojIEZsYXNoIGRldmljZXMK IwoKIwojIFZpZGVvIGltcHJvdmVtZW50IGNoaXBzCiMKQ09ORklHX1ZJREVPX1VQRDY0MDMxQT1t CkNPTkZJR19WSURFT19VUEQ2NDA4Mz1tCgojCiMgTWlzY2VsYW5lb3VzIGhlbHBlciBjaGlwcwoj CkNPTkZJR19WSURFT19NNTI3OTA9bQpDT05GSUdfVklERU9fVklWST1tCkNPTkZJR19WNExfVVNC X0RSSVZFUlM9eQpDT05GSUdfVVNCX1ZJREVPX0NMQVNTPW0KQ09ORklHX1VTQl9WSURFT19DTEFT U19JTlBVVF9FVkRFVj15CkNPTkZJR19VU0JfR1NQQ0E9bQpDT05GSUdfVVNCX001NjAyPW0KQ09O RklHX1VTQl9TVFYwNlhYPW0KQ09ORklHX1VTQl9HTDg2MD1tCkNPTkZJR19VU0JfR1NQQ0FfQkVO UT1tCkNPTkZJR19VU0JfR1NQQ0FfQ09ORVg9bQpDT05GSUdfVVNCX0dTUENBX0NQSUExPW0KQ09O RklHX1VTQl9HU1BDQV9FVE9NUz1tCkNPTkZJR19VU0JfR1NQQ0FfRklORVBJWD1tCkNPTkZJR19V U0JfR1NQQ0FfSkVJTElOSj1tCkNPTkZJR19VU0JfR1NQQ0FfSkwyMDA1QkNEPW0KQ09ORklHX1VT Ql9HU1BDQV9LSU5FQ1Q9bQpDT05GSUdfVVNCX0dTUENBX0tPTklDQT1tCkNPTkZJR19VU0JfR1NQ Q0FfTUFSUz1tCkNPTkZJR19VU0JfR1NQQ0FfTVI5NzMxMEE9bQpDT05GSUdfVVNCX0dTUENBX05X ODBYPW0KQ09ORklHX1VTQl9HU1BDQV9PVjUxOT1tCkNPTkZJR19VU0JfR1NQQ0FfT1Y1MzQ9bQpD T05GSUdfVVNCX0dTUENBX09WNTM0Xzk9bQpDT05GSUdfVVNCX0dTUENBX1BBQzIwNz1tCkNPTkZJ R19VU0JfR1NQQ0FfUEFDNzMwMj1tCkNPTkZJR19VU0JfR1NQQ0FfUEFDNzMxMT1tCkNPTkZJR19V U0JfR1NQQ0FfU0U0MDE9bQpDT05GSUdfVVNCX0dTUENBX1NOOUMyMDI4PW0KQ09ORklHX1VTQl9H U1BDQV9TTjlDMjBYPW0KQ09ORklHX1VTQl9HU1BDQV9TT05JWEI9bQpDT05GSUdfVVNCX0dTUENB X1NPTklYSj1tCkNPTkZJR19VU0JfR1NQQ0FfU1BDQTUwMD1tCkNPTkZJR19VU0JfR1NQQ0FfU1BD QTUwMT1tCkNPTkZJR19VU0JfR1NQQ0FfU1BDQTUwNT1tCkNPTkZJR19VU0JfR1NQQ0FfU1BDQTUw Nj1tCkNPTkZJR19VU0JfR1NQQ0FfU1BDQTUwOD1tCkNPTkZJR19VU0JfR1NQQ0FfU1BDQTU2MT1t CkNPTkZJR19VU0JfR1NQQ0FfU1BDQTE1Mjg9bQpDT05GSUdfVVNCX0dTUENBX1NROTA1PW0KQ09O RklHX1VTQl9HU1BDQV9TUTkwNUM9bQpDT05GSUdfVVNCX0dTUENBX1NROTMwWD1tCkNPTkZJR19V U0JfR1NQQ0FfU1RLMDE0PW0KQ09ORklHX1VTQl9HU1BDQV9TVFYwNjgwPW0KQ09ORklHX1VTQl9H U1BDQV9TVU5QTFVTPW0KQ09ORklHX1VTQl9HU1BDQV9UNjEzPW0KQ09ORklHX1VTQl9HU1BDQV9U T1BSTz1tCkNPTkZJR19VU0JfR1NQQ0FfVFY4NTMyPW0KQ09ORklHX1VTQl9HU1BDQV9WQzAzMlg9 bQpDT05GSUdfVVNCX0dTUENBX1ZJQ0FNPW0KQ09ORklHX1VTQl9HU1BDQV9YSVJMSU5LX0NJVD1t CkNPTkZJR19VU0JfR1NQQ0FfWkMzWFg9bQpDT05GSUdfVklERU9fUFZSVVNCMj1tCkNPTkZJR19W SURFT19QVlJVU0IyX1NZU0ZTPXkKQ09ORklHX1ZJREVPX1BWUlVTQjJfRFZCPXkKIyBDT05GSUdf VklERU9fUFZSVVNCMl9ERUJVR0lGQyBpcyBub3Qgc2V0CkNPTkZJR19WSURFT19IRFBWUj1tCkNP TkZJR19WSURFT19FTTI4WFg9bQpDT05GSUdfVklERU9fRU0yOFhYX0FMU0E9bQpDT05GSUdfVklE RU9fRU0yOFhYX0RWQj1tCkNPTkZJR19WSURFT19FTTI4WFhfUkM9eQpDT05GSUdfVklERU9fVExH MjMwMD1tCkNPTkZJR19WSURFT19DWDIzMVhYPW0KQ09ORklHX1ZJREVPX0NYMjMxWFhfUkM9eQpD T05GSUdfVklERU9fQ1gyMzFYWF9BTFNBPW0KQ09ORklHX1ZJREVPX0NYMjMxWFhfRFZCPW0KQ09O RklHX1ZJREVPX1RNNjAwMD1tCkNPTkZJR19WSURFT19UTTYwMDBfQUxTQT1tCkNPTkZJR19WSURF T19UTTYwMDBfRFZCPW0KQ09ORklHX1ZJREVPX1VTQlZJU0lPTj1tCkNPTkZJR19VU0JfRVQ2MVgy NTE9bQpDT05GSUdfVVNCX1NOOUMxMDI9bQpDT05GSUdfVVNCX1BXQz1tCiMgQ09ORklHX1VTQl9Q V0NfREVCVUcgaXMgbm90IHNldApDT05GSUdfVVNCX1BXQ19JTlBVVF9FVkRFVj15CkNPTkZJR19W SURFT19DUElBMj1tCkNPTkZJR19VU0JfWlIzNjRYWD1tCkNPTkZJR19VU0JfU1RLV0VCQ0FNPW0K Q09ORklHX1VTQl9TMjI1NT1tCkNPTkZJR19WNExfUENJX0RSSVZFUlM9eQpDT05GSUdfVklERU9f QVUwODI4PW0KQ09ORklHX1ZJREVPX0JUODQ4PW0KQ09ORklHX1ZJREVPX0JUODQ4X0RWQj15CkNP TkZJR19WSURFT19DWDE4PW0KQ09ORklHX1ZJREVPX0NYMThfQUxTQT1tCkNPTkZJR19WSURFT19D WDIzODg1PW0KQ09ORklHX01FRElBX0FMVEVSQV9DST1tCkNPTkZJR19WSURFT19DWDI1ODIxPW0K Q09ORklHX1ZJREVPX0NYMjU4MjFfQUxTQT1tCkNPTkZJR19WSURFT19DWDg4PW0KQ09ORklHX1ZJ REVPX0NYODhfQUxTQT1tCkNPTkZJR19WSURFT19DWDg4X0JMQUNLQklSRD1tCkNPTkZJR19WSURF T19DWDg4X0RWQj1tCkNPTkZJR19WSURFT19DWDg4X1ZQMzA1ND1tCkNPTkZJR19WSURFT19DWDg4 X01QRUc9bQpDT05GSUdfVklERU9fSEVYSVVNX0dFTUlOST1tCkNPTkZJR19WSURFT19IRVhJVU1f T1JJT049bQpDT05GSUdfVklERU9fSVZUVj1tCkNPTkZJR19WSURFT19GQl9JVlRWPW0KQ09ORklH X1ZJREVPX01FWUU9bQpDT05GSUdfVklERU9fTVhCPW0KQ09ORklHX1ZJREVPX1NBQTcxMzQ9bQpD T05GSUdfVklERU9fU0FBNzEzNF9BTFNBPW0KQ09ORklHX1ZJREVPX1NBQTcxMzRfUkM9eQpDT05G SUdfVklERU9fU0FBNzEzNF9EVkI9bQpDT05GSUdfVklERU9fU0FBNzE2ND1tCkNPTkZJR19WSURF T19aT1JBTj1tCkNPTkZJR19WSURFT19aT1JBTl9EQzMwPW0KQ09ORklHX1ZJREVPX1pPUkFOX1pS MzYwNjA9bQpDT05GSUdfVklERU9fWk9SQU5fQlVaPW0KQ09ORklHX1ZJREVPX1pPUkFOX0RDMTA9 bQpDT05GSUdfVklERU9fWk9SQU5fTE1MMzM9bQpDT05GSUdfVklERU9fWk9SQU5fTE1MMzNSMTA9 bQpDT05GSUdfVklERU9fWk9SQU5fQVZTNkVZRVM9bQojIENPTkZJR19WNExfSVNBX1BBUlBPUlRf RFJJVkVSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1Y0TF9QTEFURk9STV9EUklWRVJTIGlzIG5vdCBz ZXQKIyBDT05GSUdfVjRMX01FTTJNRU1fRFJJVkVSUyBpcyBub3Qgc2V0CkNPTkZJR19SQURJT19B REFQVEVSUz15CkNPTkZJR19SQURJT19TSTQ3MFg9eQpDT05GSUdfVVNCX1NJNDcwWD1tCkNPTkZJ R19JMkNfU0k0NzBYPW0KQ09ORklHX1VTQl9NUjgwMD1tCkNPTkZJR19VU0JfRFNCUj1tCkNPTkZJ R19SQURJT19NQVhJUkFESU89bQpDT05GSUdfSTJDX1NJNDcxMz1tCkNPTkZJR19SQURJT19TSTQ3 MTM9bQpDT05GSUdfVVNCX0tFRU5FPW0KQ09ORklHX1JBRElPX1RFQTU3NjQ9bQpDT05GSUdfUkFE SU9fU0FBNzcwNkg9bQpDT05GSUdfUkFESU9fVEVGNjg2Mj1tCkNPTkZJR19SQURJT19USU1CRVJE QUxFPW0KQ09ORklHX1JBRElPX1dMMTI3Mz1tCgojCiMgVGV4YXMgSW5zdHJ1bWVudHMgV0wxMjh4 IEZNIGRyaXZlciAoU1QgYmFzZWQpCiMKQ09ORklHX1JBRElPX1dMMTI4WD1tCkNPTkZJR19EVkJf TUFYX0FEQVBURVJTPTgKQ09ORklHX0RWQl9EWU5BTUlDX01JTk9SUz15CkNPTkZJR19EVkJfQ0FQ VFVSRV9EUklWRVJTPXkKCiMKIyBTdXBwb3J0ZWQgU0FBNzE0NiBiYXNlZCBQQ0kgQWRhcHRlcnMK IwpDT05GSUdfVFRQQ0lfRUVQUk9NPW0KQ09ORklHX0RWQl9BVjcxMTA9bQpDT05GSUdfRFZCX0FW NzExMF9PU0Q9eQpDT05GSUdfRFZCX0JVREdFVF9DT1JFPW0KQ09ORklHX0RWQl9CVURHRVQ9bQpD T05GSUdfRFZCX0JVREdFVF9DST1tCkNPTkZJR19EVkJfQlVER0VUX0FWPW0KQ09ORklHX0RWQl9C VURHRVRfUEFUQ0g9bQoKIwojIFN1cHBvcnRlZCBVU0IgQWRhcHRlcnMKIwpDT05GSUdfRFZCX1VT Qj1tCiMgQ09ORklHX0RWQl9VU0JfREVCVUcgaXMgbm90IHNldApDT05GSUdfRFZCX1VTQl9BODAw PW0KQ09ORklHX0RWQl9VU0JfRElCVVNCX01CPW0KIyBDT05GSUdfRFZCX1VTQl9ESUJVU0JfTUJf RkFVTFRZIGlzIG5vdCBzZXQKQ09ORklHX0RWQl9VU0JfRElCVVNCX01DPW0KQ09ORklHX0RWQl9V U0JfRElCMDcwMD1tCkNPTkZJR19EVkJfVVNCX1VNVF8wMTA9bQpDT05GSUdfRFZCX1VTQl9DWFVT Qj1tCkNPTkZJR19EVkJfVVNCX005MjBYPW0KQ09ORklHX0RWQl9VU0JfR0w4NjE9bQpDT05GSUdf RFZCX1VTQl9BVTY2MTA9bQpDT05GSUdfRFZCX1VTQl9ESUdJVFY9bQpDT05GSUdfRFZCX1VTQl9W UDcwNDU9bQpDT05GSUdfRFZCX1VTQl9WUDcwMlg9bQpDT05GSUdfRFZCX1VTQl9HUDhQU0s9bQpD T05GSUdfRFZCX1VTQl9OT1ZBX1RfVVNCMj1tCkNPTkZJR19EVkJfVVNCX1RUVVNCMj1tCkNPTkZJ R19EVkJfVVNCX0RUVDIwMFU9bQpDT05GSUdfRFZCX1VTQl9PUEVSQTE9bQpDT05GSUdfRFZCX1VT Ql9BRjkwMDU9bQpDT05GSUdfRFZCX1VTQl9BRjkwMDVfUkVNT1RFPW0KQ09ORklHX0RWQl9VU0Jf UENUVjQ1MkU9bQpDT05GSUdfRFZCX1VTQl9EVzIxMDI9bQpDT05GSUdfRFZCX1VTQl9DSU5FUkdZ X1QyPW0KQ09ORklHX0RWQl9VU0JfQU5ZU0VFPW0KQ09ORklHX0RWQl9VU0JfRFRWNTEwMD1tCkNP TkZJR19EVkJfVVNCX0FGOTAxNT1tCkNPTkZJR19EVkJfVVNCX0NFNjIzMD1tCkNPTkZJR19EVkJf VVNCX0ZSSUlPPW0KQ09ORklHX0RWQl9VU0JfRUMxNjg9bQpDT05GSUdfRFZCX1VTQl9BWjYwMDc9 bQpDT05GSUdfRFZCX1VTQl9BWjYwMjc9bQpDT05GSUdfRFZCX1VTQl9MTUUyNTEwPW0KQ09ORklH X0RWQl9VU0JfVEVDSE5JU0FUX1VTQjI9bQpDT05GSUdfRFZCX1VTQl9JVDkxM1g9bQpDT05GSUdf RFZCX1VTQl9NWEwxMTFTRj1tCkNPTkZJR19EVkJfVVNCX1JUTDI4WFhVPW0KQ09ORklHX0RWQl9U VFVTQl9CVURHRVQ9bQpDT05GSUdfRFZCX1RUVVNCX0RFQz1tCkNPTkZJR19TTVNfU0lBTk9fTURU Vj1tCgojCiMgU2lhbm8gbW9kdWxlIGNvbXBvbmVudHMKIwpDT05GSUdfU01TX1VTQl9EUlY9bQpD T05GSUdfU01TX1NESU9fRFJWPW0KCiMKIyBTdXBwb3J0ZWQgRmxleENvcElJIChCMkMyKSBBZGFw dGVycwojCkNPTkZJR19EVkJfQjJDMl9GTEVYQ09QPW0KQ09ORklHX0RWQl9CMkMyX0ZMRVhDT1Bf UENJPW0KQ09ORklHX0RWQl9CMkMyX0ZMRVhDT1BfVVNCPW0KIyBDT05GSUdfRFZCX0IyQzJfRkxF WENPUF9ERUJVRyBpcyBub3Qgc2V0CgojCiMgU3VwcG9ydGVkIEJUODc4IEFkYXB0ZXJzCiMKQ09O RklHX0RWQl9CVDhYWD1tCgojCiMgU3VwcG9ydGVkIFBsdXRvMiBBZGFwdGVycwojCkNPTkZJR19E VkJfUExVVE8yPW0KCiMKIyBTdXBwb3J0ZWQgU0RNQyBETTExMDUgQWRhcHRlcnMKIwpDT05GSUdf RFZCX0RNMTEwNT1tCgojCiMgU3VwcG9ydGVkIEZpcmVXaXJlIChJRUVFIDEzOTQpIEFkYXB0ZXJz CiMKQ09ORklHX0RWQl9GSVJFRFRWPW0KQ09ORklHX0RWQl9GSVJFRFRWX0lOUFVUPXkKCiMKIyBT dXBwb3J0ZWQgRWFydGhzb2Z0IFBUMSBBZGFwdGVycwojCkNPTkZJR19EVkJfUFQxPW0KCiMKIyBT dXBwb3J0ZWQgTWFudGlzIEFkYXB0ZXJzCiMKQ09ORklHX01BTlRJU19DT1JFPW0KQ09ORklHX0RW Ql9NQU5USVM9bQpDT05GSUdfRFZCX0hPUFBFUj1tCgojCiMgU3VwcG9ydGVkIG5HZW5lIEFkYXB0 ZXJzCiMKQ09ORklHX0RWQl9OR0VORT1tCgojCiMgU3VwcG9ydGVkIGRkYnJpZGdlICgnT2N0b3B1 cycpIEFkYXB0ZXJzCiMKQ09ORklHX0RWQl9EREJSSURHRT1tCgojCiMgU3VwcG9ydGVkIERWQiBG cm9udGVuZHMKIwojIENPTkZJR19EVkJfRkVfQ1VTVE9NSVNFIGlzIG5vdCBzZXQKCiMKIyBNdWx0 aXN0YW5kYXJkIChzYXRlbGxpdGUpIGZyb250ZW5kcwojCkNPTkZJR19EVkJfU1RCMDg5OT1tCkNP TkZJR19EVkJfU1RCNjEwMD1tCkNPTkZJR19EVkJfU1RWMDkweD1tCkNPTkZJR19EVkJfU1RWNjEx MHg9bQoKIwojIE11bHRpc3RhbmRhcmQgKGNhYmxlICsgdGVycmVzdHJpYWwpIGZyb250ZW5kcwoj CkNPTkZJR19EVkJfRFJYSz1tCkNPTkZJR19EVkJfVERBMTgyNzFDMkREPW0KCiMKIyBEVkItUyAo c2F0ZWxsaXRlKSBmcm9udGVuZHMKIwpDT05GSUdfRFZCX0NYMjQxMTA9bQpDT05GSUdfRFZCX0NY MjQxMjM9bQpDT05GSUdfRFZCX01UMzEyPW0KQ09ORklHX0RWQl9aTDEwMDM2PW0KQ09ORklHX0RW Ql9aTDEwMDM5PW0KQ09ORklHX0RWQl9TNUgxNDIwPW0KQ09ORklHX0RWQl9TVFYwMjg4PW0KQ09O RklHX0RWQl9TVEI2MDAwPW0KQ09ORklHX0RWQl9TVFYwMjk5PW0KQ09ORklHX0RWQl9TVFY2MTEw PW0KQ09ORklHX0RWQl9TVFYwOTAwPW0KQ09ORklHX0RWQl9UREE4MDgzPW0KQ09ORklHX0RWQl9U REExMDA4Nj1tCkNPTkZJR19EVkJfVERBODI2MT1tCkNPTkZJR19EVkJfVkVTMVg5Mz1tCkNPTkZJ R19EVkJfVFVORVJfSVREMTAwMD1tCkNPTkZJR19EVkJfVFVORVJfQ1gyNDExMz1tCkNPTkZJR19E VkJfVERBODI2WD1tCkNPTkZJR19EVkJfVFVBNjEwMD1tCkNPTkZJR19EVkJfQ1gyNDExNj1tCkNP TkZJR19EVkJfU0kyMVhYPW0KQ09ORklHX0RWQl9EUzMwMDA9bQpDT05GSUdfRFZCX01CODZBMTY9 bQpDT05GSUdfRFZCX1REQTEwMDcxPW0KCiMKIyBEVkItVCAodGVycmVzdHJpYWwpIGZyb250ZW5k cwojCkNPTkZJR19EVkJfU1A4ODcwPW0KQ09ORklHX0RWQl9TUDg4N1g9bQpDT05GSUdfRFZCX0NY MjI3MDA9bQpDT05GSUdfRFZCX0NYMjI3MDI9bQpDT05GSUdfRFZCX0RSWEQ9bQpDT05GSUdfRFZC X0w2NDc4MT1tCkNPTkZJR19EVkJfVERBMTAwNFg9bQpDT05GSUdfRFZCX05YVDYwMDA9bQpDT05G SUdfRFZCX01UMzUyPW0KQ09ORklHX0RWQl9aTDEwMzUzPW0KQ09ORklHX0RWQl9ESUIzMDAwTUI9 bQpDT05GSUdfRFZCX0RJQjMwMDBNQz1tCkNPTkZJR19EVkJfRElCNzAwME09bQpDT05GSUdfRFZC X0RJQjcwMDBQPW0KQ09ORklHX0RWQl9UREExMDA0OD1tCkNPTkZJR19EVkJfQUY5MDEzPW0KQ09O RklHX0RWQl9FQzEwMD1tCkNPTkZJR19EVkJfU1RWMDM2Nz1tCkNPTkZJR19EVkJfQ1hEMjgyMFI9 bQpDT05GSUdfRFZCX1JUTDI4MzA9bQoKIwojIERWQi1DIChjYWJsZSkgZnJvbnRlbmRzCiMKQ09O RklHX0RWQl9WRVMxODIwPW0KQ09ORklHX0RWQl9UREExMDAyMT1tCkNPTkZJR19EVkJfVERBMTAw MjM9bQpDT05GSUdfRFZCX1NUVjAyOTc9bQoKIwojIEFUU0MgKE5vcnRoIEFtZXJpY2FuL0tvcmVh biBUZXJyZXN0cmlhbC9DYWJsZSBEVFYpIGZyb250ZW5kcwojCkNPTkZJR19EVkJfTlhUMjAwWD1t CkNPTkZJR19EVkJfT1I1MTIxMT1tCkNPTkZJR19EVkJfT1I1MTEzMj1tCkNPTkZJR19EVkJfQkNN MzUxMD1tCkNPTkZJR19EVkJfTEdEVDMzMFg9bQpDT05GSUdfRFZCX0xHRFQzMzA1PW0KQ09ORklH X0RWQl9TNUgxNDA5PW0KQ09ORklHX0RWQl9BVTg1MjI9bQpDT05GSUdfRFZCX1M1SDE0MTE9bQoK IwojIElTREItVCAodGVycmVzdHJpYWwpIGZyb250ZW5kcwojCkNPTkZJR19EVkJfUzkyMT1tCkNP TkZJR19EVkJfRElCODAwMD1tCkNPTkZJR19EVkJfTUI4NkEyMFM9bQoKIwojIERpZ2l0YWwgdGVy cmVzdHJpYWwgb25seSB0dW5lcnMvUExMCiMKQ09ORklHX0RWQl9QTEw9bQpDT05GSUdfRFZCX1RV TkVSX0RJQjAwNzA9bQpDT05GSUdfRFZCX1RVTkVSX0RJQjAwOTA9bQoKIwojIFNFQyBjb250cm9s IGRldmljZXMgZm9yIERWQi1TCiMKQ09ORklHX0RWQl9MTkJQMjE9bQpDT05GSUdfRFZCX0xOQlAy Mj1tCkNPTkZJR19EVkJfSVNMNjQwNT1tCkNPTkZJR19EVkJfSVNMNjQyMT1tCkNPTkZJR19EVkJf SVNMNjQyMz1tCkNPTkZJR19EVkJfQTgyOTM9bQpDT05GSUdfRFZCX0xHUzhHWFg9bQpDT05GSUdf RFZCX0FUQk04ODMwPW0KQ09ORklHX0RWQl9UREE2NjV4PW0KQ09ORklHX0RWQl9JWDI1MDVWPW0K Q09ORklHX0RWQl9JVDkxM1hfRkU9bQpDT05GSUdfRFZCX004OFJTMjAwMD1tCgojCiMgVG9vbHMg dG8gZGV2ZWxvcCBuZXcgZnJvbnRlbmRzCiMKIyBDT05GSUdfRFZCX0RVTU1ZX0ZFIGlzIG5vdCBz ZXQKCiMKIyBHcmFwaGljcyBzdXBwb3J0CiMKQ09ORklHX0FHUD1tCkNPTkZJR19BR1BfQU1ENjQ9 bQpDT05GSUdfQUdQX0lOVEVMPW0KQ09ORklHX0FHUF9TSVM9bQpDT05GSUdfQUdQX1ZJQT1tCkNP TkZJR19WR0FfQVJCPXkKQ09ORklHX1ZHQV9BUkJfTUFYX0dQVVM9MTYKQ09ORklHX1ZHQV9TV0lU Q0hFUk9PPXkKQ09ORklHX0RSTT1tCkNPTkZJR19EUk1fVVNCPW0KQ09ORklHX0RSTV9LTVNfSEVM UEVSPW0KIyBDT05GSUdfRFJNX0xPQURfRURJRF9GSVJNV0FSRSBpcyBub3Qgc2V0CkNPTkZJR19E Uk1fVFRNPW0KQ09ORklHX0RSTV9UREZYPW0KQ09ORklHX0RSTV9SMTI4PW0KQ09ORklHX0RSTV9S QURFT049bQpDT05GSUdfRFJNX1JBREVPTl9LTVM9eQpDT05GSUdfRFJNX05PVVZFQVU9bQpDT05G SUdfRFJNX05PVVZFQVVfQkFDS0xJR0hUPXkKIyBDT05GSUdfRFJNX05PVVZFQVVfREVCVUcgaXMg bm90IHNldAoKIwojIEkyQyBlbmNvZGVyIG9yIGhlbHBlciBjaGlwcwojCkNPTkZJR19EUk1fSTJD X0NINzAwNj1tCkNPTkZJR19EUk1fSTJDX1NJTDE2ND1tCkNPTkZJR19EUk1fSTgxMD1tCkNPTkZJ R19EUk1fSTkxNT1tCkNPTkZJR19EUk1fSTkxNV9LTVM9eQpDT05GSUdfRFJNX01HQT1tCkNPTkZJ R19EUk1fU0lTPW0KQ09ORklHX0RSTV9WSUE9bQpDT05GSUdfRFJNX1NBVkFHRT1tCiMgQ09ORklH X0RSTV9WTVdHRlggaXMgbm90IHNldApDT05GSUdfRFJNX0dNQTUwMD1tCkNPTkZJR19EUk1fR01B NjAwPXkKQ09ORklHX0RSTV9HTUEzNjAwPXkKQ09ORklHX0RSTV9VREw9bQpDT05GSUdfU1RVQl9Q T1VMU0JPPW0KQ09ORklHX1ZHQVNUQVRFPW0KQ09ORklHX1ZJREVPX09VVFBVVF9DT05UUk9MPW0K Q09ORklHX0ZCPXkKQ09ORklHX0ZJUk1XQVJFX0VESUQ9eQpDT05GSUdfRkJfRERDPW0KQ09ORklH X0ZCX0JPT1RfVkVTQV9TVVBQT1JUPXkKQ09ORklHX0ZCX0NGQl9GSUxMUkVDVD15CkNPTkZJR19G Ql9DRkJfQ09QWUFSRUE9eQpDT05GSUdfRkJfQ0ZCX0lNQUdFQkxJVD15CiMgQ09ORklHX0ZCX0NG Ql9SRVZfUElYRUxTX0lOX0JZVEUgaXMgbm90IHNldApDT05GSUdfRkJfU1lTX0ZJTExSRUNUPXkK Q09ORklHX0ZCX1NZU19DT1BZQVJFQT15CkNPTkZJR19GQl9TWVNfSU1BR0VCTElUPXkKIyBDT05G SUdfRkJfRk9SRUlHTl9FTkRJQU4gaXMgbm90IHNldApDT05GSUdfRkJfU1lTX0ZPUFM9eQojIENP TkZJR19GQl9XTVRfR0VfUk9QUyBpcyBub3Qgc2V0CkNPTkZJR19GQl9ERUZFUlJFRF9JTz15CkNP TkZJR19GQl9IRUNVQkE9bQpDT05GSUdfRkJfU1ZHQUxJQj1tCiMgQ09ORklHX0ZCX01BQ01PREVT IGlzIG5vdCBzZXQKQ09ORklHX0ZCX0JBQ0tMSUdIVD15CkNPTkZJR19GQl9NT0RFX0hFTFBFUlM9 eQpDT05GSUdfRkJfVElMRUJMSVRUSU5HPXkKCiMKIyBGcmFtZSBidWZmZXIgaGFyZHdhcmUgZHJp dmVycwojCkNPTkZJR19GQl9DSVJSVVM9bQpDT05GSUdfRkJfUE0yPW0KQ09ORklHX0ZCX1BNMl9G SUZPX0RJU0NPTk5FQ1Q9eQpDT05GSUdfRkJfQ1lCRVIyMDAwPW0KQ09ORklHX0ZCX0NZQkVSMjAw MF9EREM9eQpDT05GSUdfRkJfQVJDPW0KIyBDT05GSUdfRkJfQVNJTElBTlQgaXMgbm90IHNldAoj IENPTkZJR19GQl9JTVNUVCBpcyBub3Qgc2V0CkNPTkZJR19GQl9WR0ExNj1tCkNPTkZJR19GQl9V VkVTQT1tCkNPTkZJR19GQl9WRVNBPXkKQ09ORklHX0ZCX040MTE9bQpDT05GSUdfRkJfSEdBPW0K Q09ORklHX0ZCX1MxRDEzWFhYPW0KQ09ORklHX0ZCX05WSURJQT1tCkNPTkZJR19GQl9OVklESUFf STJDPXkKIyBDT05GSUdfRkJfTlZJRElBX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0ZCX05WSURJ QV9CQUNLTElHSFQ9eQpDT05GSUdfRkJfUklWQT1tCkNPTkZJR19GQl9SSVZBX0kyQz15CiMgQ09O RklHX0ZCX1JJVkFfREVCVUcgaXMgbm90IHNldApDT05GSUdfRkJfUklWQV9CQUNLTElHSFQ9eQpD T05GSUdfRkJfSTc0MD1tCkNPTkZJR19GQl9MRTgwNTc4PW0KQ09ORklHX0ZCX0NBUklMTE9fUkFO Q0g9bQpDT05GSUdfRkJfTUFUUk9YPW0KQ09ORklHX0ZCX01BVFJPWF9NSUxMRU5JVU09eQpDT05G SUdfRkJfTUFUUk9YX01ZU1RJUVVFPXkKQ09ORklHX0ZCX01BVFJPWF9HPXkKQ09ORklHX0ZCX01B VFJPWF9JMkM9bQpDT05GSUdfRkJfTUFUUk9YX01BVkVOPW0KQ09ORklHX0ZCX1JBREVPTj1tCkNP TkZJR19GQl9SQURFT05fSTJDPXkKQ09ORklHX0ZCX1JBREVPTl9CQUNLTElHSFQ9eQojIENPTkZJ R19GQl9SQURFT05fREVCVUcgaXMgbm90IHNldApDT05GSUdfRkJfQVRZMTI4PW0KQ09ORklHX0ZC X0FUWTEyOF9CQUNLTElHSFQ9eQpDT05GSUdfRkJfQVRZPW0KQ09ORklHX0ZCX0FUWV9DVD15CkNP TkZJR19GQl9BVFlfR0VORVJJQ19MQ0Q9eQpDT05GSUdfRkJfQVRZX0dYPXkKQ09ORklHX0ZCX0FU WV9CQUNLTElHSFQ9eQpDT05GSUdfRkJfUzM9bQpDT05GSUdfRkJfUzNfRERDPXkKQ09ORklHX0ZC X1NBVkFHRT1tCkNPTkZJR19GQl9TQVZBR0VfSTJDPXkKQ09ORklHX0ZCX1NBVkFHRV9BQ0NFTD15 CkNPTkZJR19GQl9TSVM9bQpDT05GSUdfRkJfU0lTXzMwMD15CkNPTkZJR19GQl9TSVNfMzE1PXkK Q09ORklHX0ZCX1ZJQT1tCiMgQ09ORklHX0ZCX1ZJQV9ESVJFQ1RfUFJPQ0ZTIGlzIG5vdCBzZXQK IyBDT05GSUdfRkJfVklBX1hfQ09NUEFUSUJJTElUWSBpcyBub3Qgc2V0CkNPTkZJR19GQl9ORU9N QUdJQz1tCkNPTkZJR19GQl9LWVJPPW0KQ09ORklHX0ZCXzNERlg9bQpDT05GSUdfRkJfM0RGWF9B Q0NFTD15CkNPTkZJR19GQl8zREZYX0kyQz15CkNPTkZJR19GQl9WT09ET08xPW0KQ09ORklHX0ZC X1ZUODYyMz1tCkNPTkZJR19GQl9UUklERU5UPW0KQ09ORklHX0ZCX0FSSz1tCkNPTkZJR19GQl9Q TTM9bQpDT05GSUdfRkJfQ0FSTUlORT1tCkNPTkZJR19GQl9DQVJNSU5FX0RSQU1fRVZBTD15CiMg Q09ORklHX0NBUk1JTkVfRFJBTV9DVVNUT00gaXMgbm90IHNldApDT05GSUdfRkJfR0VPREU9eQpD T05GSUdfRkJfR0VPREVfTFg9bQpDT05GSUdfRkJfR0VPREVfR1g9bQpDT05GSUdfRkJfR0VPREVf R1gxPW0KQ09ORklHX0ZCX1RNSU89bQpDT05GSUdfRkJfVE1JT19BQ0NFTEw9eQpDT05GSUdfRkJf U001MDE9bQpDT05GSUdfRkJfU01TQ1VGWD1tCkNPTkZJR19GQl9VREw9bQpDT05GSUdfRkJfVklS VFVBTD1tCkNPTkZJR19YRU5fRkJERVZfRlJPTlRFTkQ9eQpDT05GSUdfRkJfTUVUUk9OT01FPW0K Q09ORklHX0ZCX01CODYyWFg9bQpDT05GSUdfRkJfTUI4NjJYWF9QQ0lfR0RDPXkKQ09ORklHX0ZC X01CODYyWFhfSTJDPXkKQ09ORklHX0ZCX0JST0FEU0hFRVQ9bQojIENPTkZJR19FWFlOT1NfVklE RU8gaXMgbm90IHNldApDT05GSUdfQkFDS0xJR0hUX0xDRF9TVVBQT1JUPXkKQ09ORklHX0xDRF9D TEFTU19ERVZJQ0U9bQpDT05GSUdfTENEX0w0RjAwMjQyVDAzPW0KQ09ORklHX0xDRF9MTVMyODNH RjA1PW0KQ09ORklHX0xDRF9MVFYzNTBRVj1tCkNPTkZJR19MQ0RfSUxJOTMyMD1tCkNPTkZJR19M Q0RfVERPMjRNPW0KQ09ORklHX0xDRF9WR0cyNDMyQTQ9bQpDT05GSUdfTENEX1BMQVRGT1JNPW0K Q09ORklHX0xDRF9TNkU2M00wPW0KQ09ORklHX0xDRF9MRDkwNDA9bQpDT05GSUdfTENEX0FNUzM2 OUZHMDY9bQpDT05GSUdfQkFDS0xJR0hUX0NMQVNTX0RFVklDRT15CkNPTkZJR19CQUNLTElHSFRf R0VORVJJQz1tCkNPTkZJR19CQUNLTElHSFRfUFJPR0VBUj1tCkNPTkZJR19CQUNLTElHSFRfQ0FS SUxMT19SQU5DSD1tCkNPTkZJR19CQUNLTElHSFRfREE5MDUyPW0KQ09ORklHX0JBQ0tMSUdIVF9B UFBMRT1tCkNPTkZJR19CQUNLTElHSFRfU0FIQVJBPW0KQ09ORklHX0JBQ0tMSUdIVF9BRFA4ODYw PW0KQ09ORklHX0JBQ0tMSUdIVF9BRFA4ODcwPW0KQ09ORklHX0JBQ0tMSUdIVF9MUDg1NVg9bQpD T05GSUdfQkFDS0xJR0hUX09UMjAwPW0KCiMKIyBDb25zb2xlIGRpc3BsYXkgZHJpdmVyIHN1cHBv cnQKIwpDT05GSUdfVkdBX0NPTlNPTEU9eQpDT05GSUdfVkdBQ09OX1NPRlRfU0NST0xMQkFDSz15 CkNPTkZJR19WR0FDT05fU09GVF9TQ1JPTExCQUNLX1NJWkU9NjQKQ09ORklHX0RVTU1ZX0NPTlNP TEU9eQpDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRT15CkNPTkZJR19GUkFNRUJVRkZFUl9DT05T T0xFX0RFVEVDVF9QUklNQVJZPXkKIyBDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRV9ST1RBVElP TiBpcyBub3Qgc2V0CiMgQ09ORklHX0ZPTlRTIGlzIG5vdCBzZXQKQ09ORklHX0ZPTlRfOHg4PXkK Q09ORklHX0ZPTlRfOHgxNj15CiMgQ09ORklHX0xPR08gaXMgbm90IHNldApDT05GSUdfU09VTkQ9 bQpDT05GSUdfU09VTkRfT1NTX0NPUkU9eQojIENPTkZJR19TT1VORF9PU1NfQ09SRV9QUkVDTEFJ TSBpcyBub3Qgc2V0CkNPTkZJR19TTkQ9bQpDT05GSUdfU05EX1RJTUVSPW0KQ09ORklHX1NORF9Q Q009bQpDT05GSUdfU05EX0hXREVQPW0KQ09ORklHX1NORF9SQVdNSURJPW0KQ09ORklHX1NORF9K QUNLPXkKQ09ORklHX1NORF9TRVFVRU5DRVI9bQpDT05GSUdfU05EX1NFUV9EVU1NWT1tCkNPTkZJ R19TTkRfT1NTRU1VTD15CkNPTkZJR19TTkRfTUlYRVJfT1NTPW0KQ09ORklHX1NORF9QQ01fT1NT PW0KQ09ORklHX1NORF9QQ01fT1NTX1BMVUdJTlM9eQpDT05GSUdfU05EX1NFUVVFTkNFUl9PU1M9 eQpDT05GSUdfU05EX0hSVElNRVI9bQpDT05GSUdfU05EX1NFUV9IUlRJTUVSX0RFRkFVTFQ9eQpD T05GSUdfU05EX0RZTkFNSUNfTUlOT1JTPXkKQ09ORklHX1NORF9TVVBQT1JUX09MRF9BUEk9eQpD T05GSUdfU05EX1ZFUkJPU0VfUFJPQ0ZTPXkKQ09ORklHX1NORF9WRVJCT1NFX1BSSU5USz15CkNP TkZJR19TTkRfREVCVUc9eQojIENPTkZJR19TTkRfREVCVUdfVkVSQk9TRSBpcyBub3Qgc2V0CkNP TkZJR19TTkRfUENNX1hSVU5fREVCVUc9eQpDT05GSUdfU05EX1ZNQVNURVI9eQpDT05GSUdfU05E X0tDVExfSkFDSz15CkNPTkZJR19TTkRfRE1BX1NHQlVGPXkKQ09ORklHX1NORF9SQVdNSURJX1NF UT1tCkNPTkZJR19TTkRfT1BMM19MSUJfU0VRPW0KIyBDT05GSUdfU05EX09QTDRfTElCX1NFUSBp cyBub3Qgc2V0CiMgQ09ORklHX1NORF9TQkFXRV9TRVEgaXMgbm90IHNldApDT05GSUdfU05EX0VN VTEwSzFfU0VRPW0KQ09ORklHX1NORF9NUFU0MDFfVUFSVD1tCkNPTkZJR19TTkRfT1BMM19MSUI9 bQpDT05GSUdfU05EX1ZYX0xJQj1tCkNPTkZJR19TTkRfQUM5N19DT0RFQz1tCkNPTkZJR19TTkRf RFJJVkVSUz15CiMgQ09ORklHX1NORF9QQ1NQIGlzIG5vdCBzZXQKQ09ORklHX1NORF9EVU1NWT1t CkNPTkZJR19TTkRfQUxPT1A9bQpDT05GSUdfU05EX1ZJUk1JREk9bQpDT05GSUdfU05EX01UUEFW PW0KQ09ORklHX1NORF9NVFM2ND1tCkNPTkZJR19TTkRfU0VSSUFMX1UxNjU1MD1tCkNPTkZJR19T TkRfTVBVNDAxPW0KQ09ORklHX1NORF9QT1JUTUFOMlg0PW0KQ09ORklHX1NORF9BQzk3X1BPV0VS X1NBVkU9eQpDT05GSUdfU05EX0FDOTdfUE9XRVJfU0FWRV9ERUZBVUxUPTAKQ09ORklHX1NORF9T Ql9DT01NT049bQpDT05GSUdfU05EX1NCMTZfRFNQPW0KQ09ORklHX1NORF9URUE1NzVYPW0KQ09O RklHX1NORF9QQ0k9eQpDT05GSUdfU05EX0FEMTg4OT1tCkNPTkZJR19TTkRfQUxTMzAwPW0KQ09O RklHX1NORF9BTFM0MDAwPW0KQ09ORklHX1NORF9BTEk1NDUxPW0KQ09ORklHX1NORF9BU0lIUEk9 bQpDT05GSUdfU05EX0FUSUlYUD1tCkNPTkZJR19TTkRfQVRJSVhQX01PREVNPW0KQ09ORklHX1NO RF9BVTg4MTA9bQpDT05GSUdfU05EX0FVODgyMD1tCkNPTkZJR19TTkRfQVU4ODMwPW0KQ09ORklH X1NORF9BVzI9bQpDT05GSUdfU05EX0FaVDMzMjg9bQpDT05GSUdfU05EX0JUODdYPW0KIyBDT05G SUdfU05EX0JUODdYX09WRVJDTE9DSyBpcyBub3Qgc2V0CkNPTkZJR19TTkRfQ0EwMTA2PW0KQ09O RklHX1NORF9DTUlQQ0k9bQpDT05GSUdfU05EX09YWUdFTl9MSUI9bQpDT05GSUdfU05EX09YWUdF Tj1tCkNPTkZJR19TTkRfQ1M0MjgxPW0KQ09ORklHX1NORF9DUzQ2WFg9bQpDT05GSUdfU05EX0NT NDZYWF9ORVdfRFNQPXkKQ09ORklHX1NORF9DUzU1MzA9bQpDT05GSUdfU05EX0NTNTUzNUFVRElP PW0KQ09ORklHX1NORF9DVFhGST1tCkNPTkZJR19TTkRfREFSTEEyMD1tCkNPTkZJR19TTkRfR0lO QTIwPW0KQ09ORklHX1NORF9MQVlMQTIwPW0KQ09ORklHX1NORF9EQVJMQTI0PW0KQ09ORklHX1NO RF9HSU5BMjQ9bQpDT05GSUdfU05EX0xBWUxBMjQ9bQpDT05GSUdfU05EX01PTkE9bQpDT05GSUdf U05EX01JQT1tCkNPTkZJR19TTkRfRUNITzNHPW0KQ09ORklHX1NORF9JTkRJR089bQpDT05GSUdf U05EX0lORElHT0lPPW0KQ09ORklHX1NORF9JTkRJR09ESj1tCkNPTkZJR19TTkRfSU5ESUdPSU9Y PW0KQ09ORklHX1NORF9JTkRJR09ESlg9bQpDT05GSUdfU05EX0VNVTEwSzE9bQpDT05GSUdfU05E X0VNVTEwSzFYPW0KQ09ORklHX1NORF9FTlMxMzcwPW0KQ09ORklHX1NORF9FTlMxMzcxPW0KQ09O RklHX1NORF9FUzE5Mzg9bQpDT05GSUdfU05EX0VTMTk2OD1tCkNPTkZJR19TTkRfRVMxOTY4X0lO UFVUPXkKQ09ORklHX1NORF9FUzE5NjhfUkFESU89eQpDT05GSUdfU05EX0ZNODAxPW0KQ09ORklH X1NORF9GTTgwMV9URUE1NzVYX0JPT0w9eQpDT05GSUdfU05EX0hEQV9JTlRFTD1tCkNPTkZJR19T TkRfSERBX1BSRUFMTE9DX1NJWkU9NjQKQ09ORklHX1NORF9IREFfSFdERVA9eQpDT05GSUdfU05E X0hEQV9SRUNPTkZJRz15CkNPTkZJR19TTkRfSERBX0lOUFVUX0JFRVA9eQpDT05GSUdfU05EX0hE QV9JTlBVVF9CRUVQX01PREU9MgpDT05GSUdfU05EX0hEQV9JTlBVVF9KQUNLPXkKQ09ORklHX1NO RF9IREFfUEFUQ0hfTE9BREVSPXkKQ09ORklHX1NORF9IREFfQ09ERUNfUkVBTFRFSz15CkNPTkZJ R19TTkRfSERBX0VOQUJMRV9SRUFMVEVLX1FVSVJLUz15CkNPTkZJR19TTkRfSERBX0NPREVDX0FO QUxPRz15CkNPTkZJR19TTkRfSERBX0NPREVDX1NJR01BVEVMPXkKQ09ORklHX1NORF9IREFfQ09E RUNfVklBPXkKQ09ORklHX1NORF9IREFfQ09ERUNfSERNST15CkNPTkZJR19TTkRfSERBX0NPREVD X0NJUlJVUz15CkNPTkZJR19TTkRfSERBX0NPREVDX0NPTkVYQU5UPXkKQ09ORklHX1NORF9IREFf Q09ERUNfQ0EwMTEwPXkKQ09ORklHX1NORF9IREFfQ09ERUNfQ0EwMTMyPXkKQ09ORklHX1NORF9I REFfQ09ERUNfQ01FRElBPXkKQ09ORklHX1NORF9IREFfQ09ERUNfU0kzMDU0PXkKQ09ORklHX1NO RF9IREFfR0VORVJJQz15CkNPTkZJR19TTkRfSERBX1BPV0VSX1NBVkU9eQpDT05GSUdfU05EX0hE QV9QT1dFUl9TQVZFX0RFRkFVTFQ9MApDT05GSUdfU05EX0hEU1A9bQpDT05GSUdfU05EX0hEU1BN PW0KQ09ORklHX1NORF9JQ0UxNzEyPW0KQ09ORklHX1NORF9JQ0UxNzI0PW0KQ09ORklHX1NORF9J TlRFTDhYMD1tCkNPTkZJR19TTkRfSU5URUw4WDBNPW0KQ09ORklHX1NORF9LT1JHMTIxMj1tCkNP TkZJR19TTkRfTE9MQT1tCkNPTkZJR19TTkRfTFg2NDY0RVM9bQpDT05GSUdfU05EX01BRVNUUk8z PW0KQ09ORklHX1NORF9NQUVTVFJPM19JTlBVVD15CkNPTkZJR19TTkRfTUlYQVJUPW0KQ09ORklH X1NORF9OTTI1Nj1tCkNPTkZJR19TTkRfUENYSFI9bQpDT05GSUdfU05EX1JJUFRJREU9bQpDT05G SUdfU05EX1JNRTMyPW0KQ09ORklHX1NORF9STUU5Nj1tCkNPTkZJR19TTkRfUk1FOTY1Mj1tCkNP TkZJR19TTkRfU09OSUNWSUJFUz1tCkNPTkZJR19TTkRfVFJJREVOVD1tCkNPTkZJR19TTkRfVklB ODJYWD1tCkNPTkZJR19TTkRfVklBODJYWF9NT0RFTT1tCkNPTkZJR19TTkRfVklSVFVPU089bQpD T05GSUdfU05EX1ZYMjIyPW0KQ09ORklHX1NORF9ZTUZQQ0k9bQpDT05GSUdfU05EX1NQST15CkNP TkZJR19TTkRfVVNCPXkKQ09ORklHX1NORF9VU0JfQVVESU89bQpDT05GSUdfU05EX1VTQl9VQTEw MT1tCkNPTkZJR19TTkRfVVNCX1VTWDJZPW0KQ09ORklHX1NORF9VU0JfQ0FJQVE9bQpDT05GSUdf U05EX1VTQl9DQUlBUV9JTlBVVD15CkNPTkZJR19TTkRfVVNCX1VTMTIyTD1tCkNPTkZJR19TTkRf VVNCXzZGSVJFPW0KQ09ORklHX1NORF9GSVJFV0lSRT15CkNPTkZJR19TTkRfRklSRVdJUkVfTElC PW0KQ09ORklHX1NORF9GSVJFV0lSRV9TUEVBS0VSUz1tCkNPTkZJR19TTkRfSVNJR0hUPW0KQ09O RklHX1NORF9QQ01DSUE9eQpDT05GSUdfU05EX1ZYUE9DS0VUPW0KQ09ORklHX1NORF9QREFVRElP Q0Y9bQojIENPTkZJR19TTkRfU09DIGlzIG5vdCBzZXQKQ09ORklHX1NPVU5EX1BSSU1FPW0KQ09O RklHX1NPVU5EX09TUz1tCkNPTkZJR19TT1VORF9UUkFDRUlOSVQ9eQpDT05GSUdfU09VTkRfRE1B UD15CkNPTkZJR19TT1VORF9WTUlEST1tCkNPTkZJR19TT1VORF9UUklYPW0KQ09ORklHX1NPVU5E X01TUz1tCkNPTkZJR19TT1VORF9NUFU0MDE9bQpDT05GSUdfU09VTkRfUEFTPW0KQ09ORklHX1NP VU5EX1BTUz1tCkNPTkZJR19QU1NfTUlYRVI9eQojIENPTkZJR19QU1NfSEFWRV9CT09UIGlzIG5v dCBzZXQKIyBDT05GSUdfU09VTkRfU0IgaXMgbm90IHNldApDT05GSUdfU09VTkRfWU0zODEyPW0K Q09ORklHX1NPVU5EX1VBUlQ2ODUwPW0KQ09ORklHX1NPVU5EX0FFRFNQMTY9bQpDT05GSUdfU0M2 NjAwPXkKQ09ORklHX1NDNjYwMF9KT1k9eQpDT05GSUdfU0M2NjAwX0NEUk9NPTQKQ09ORklHX1ND NjYwMF9DRFJPTUJBU0U9MApDT05GSUdfQUM5N19CVVM9bQpDT05GSUdfSElEX1NVUFBPUlQ9eQpD T05GSUdfSElEPW0KQ09ORklHX0hJRFJBVz15CgojCiMgVVNCIElucHV0IERldmljZXMKIwpDT05G SUdfVVNCX0hJRD1tCkNPTkZJR19ISURfUElEPXkKQ09ORklHX1VTQl9ISURERVY9eQoKIwojIFNw ZWNpYWwgSElEIGRyaXZlcnMKIwpDT05GSUdfSElEX0E0VEVDSD1tCkNPTkZJR19ISURfQUNSVVg9 bQojIENPTkZJR19ISURfQUNSVVhfRkYgaXMgbm90IHNldApDT05GSUdfSElEX0FQUExFPW0KQ09O RklHX0hJRF9CRUxLSU49bQpDT05GSUdfSElEX0NIRVJSWT1tCkNPTkZJR19ISURfQ0hJQ09OWT1t CkNPTkZJR19ISURfUFJPRElLRVlTPW0KQ09ORklHX0hJRF9DWVBSRVNTPW0KQ09ORklHX0hJRF9E UkFHT05SSVNFPW0KQ09ORklHX0RSQUdPTlJJU0VfRkY9eQpDT05GSUdfSElEX0VNU19GRj1tCkNP TkZJR19ISURfRUxFQ09NPW0KQ09ORklHX0hJRF9FWktFWT1tCkNPTkZJR19ISURfSE9MVEVLPW0K IyBDT05GSUdfSE9MVEVLX0ZGIGlzIG5vdCBzZXQKQ09ORklHX0hJRF9LRVlUT1VDSD1tCkNPTkZJ R19ISURfS1lFPW0KQ09ORklHX0hJRF9VQ0xPR0lDPW0KQ09ORklHX0hJRF9XQUxUT1A9bQpDT05G SUdfSElEX0dZUkFUSU9OPW0KQ09ORklHX0hJRF9UV0lOSEFOPW0KQ09ORklHX0hJRF9LRU5TSU5H VE9OPW0KQ09ORklHX0hJRF9MQ1BPV0VSPW0KQ09ORklHX0hJRF9MT0dJVEVDSD1tCkNPTkZJR19I SURfTE9HSVRFQ0hfREo9bQpDT05GSUdfTE9HSVRFQ0hfRkY9eQpDT05GSUdfTE9HSVJVTUJMRVBB RDJfRkY9eQpDT05GSUdfTE9HSUc5NDBfRkY9eQpDT05GSUdfTE9HSVdIRUVMU19GRj15CkNPTkZJ R19ISURfTUFHSUNNT1VTRT1tCkNPTkZJR19ISURfTUlDUk9TT0ZUPW0KQ09ORklHX0hJRF9NT05U RVJFWT1tCkNPTkZJR19ISURfTVVMVElUT1VDSD1tCkNPTkZJR19ISURfTlRSSUc9bQpDT05GSUdf SElEX09SVEVLPW0KQ09ORklHX0hJRF9QQU5USEVSTE9SRD1tCkNPTkZJR19QQU5USEVSTE9SRF9G Rj15CkNPTkZJR19ISURfUEVUQUxZTlg9bQpDT05GSUdfSElEX1BJQ09MQ0Q9bQpDT05GSUdfSElE X1BJQ09MQ0RfRkI9eQpDT05GSUdfSElEX1BJQ09MQ0RfQkFDS0xJR0hUPXkKQ09ORklHX0hJRF9Q SUNPTENEX0xDRD15CkNPTkZJR19ISURfUElDT0xDRF9MRURTPXkKQ09ORklHX0hJRF9QUklNQVg9 bQpDT05GSUdfSElEX1JPQ0NBVD1tCkNPTkZJR19ISURfU0FJVEVLPW0KQ09ORklHX0hJRF9TQU1T VU5HPW0KQ09ORklHX0hJRF9TT05ZPW0KQ09ORklHX0hJRF9TUEVFRExJTks9bQpDT05GSUdfSElE X1NVTlBMVVM9bQpDT05GSUdfSElEX0dSRUVOQVNJQT1tCkNPTkZJR19HUkVFTkFTSUFfRkY9eQpD T05GSUdfSElEX1NNQVJUSk9ZUExVUz1tCkNPTkZJR19TTUFSVEpPWVBMVVNfRkY9eQpDT05GSUdf SElEX1RJVk89bQpDT05GSUdfSElEX1RPUFNFRUQ9bQpDT05GSUdfSElEX1RIUlVTVE1BU1RFUj1t CkNPTkZJR19USFJVU1RNQVNURVJfRkY9eQpDT05GSUdfSElEX1dBQ09NPW0KQ09ORklHX0hJRF9X QUNPTV9QT1dFUl9TVVBQTFk9eQpDT05GSUdfSElEX1dJSU1PVEU9bQpDT05GSUdfSElEX1dJSU1P VEVfRVhUPXkKQ09ORklHX0hJRF9aRVJPUExVUz1tCkNPTkZJR19aRVJPUExVU19GRj15CkNPTkZJ R19ISURfWllEQUNST049bQpDT05GSUdfVVNCX0FSQ0hfSEFTX09IQ0k9eQpDT05GSUdfVVNCX0FS Q0hfSEFTX0VIQ0k9eQpDT05GSUdfVVNCX0FSQ0hfSEFTX1hIQ0k9eQpDT05GSUdfVVNCX1NVUFBP UlQ9eQpDT05GSUdfVVNCX0NPTU1PTj1tCkNPTkZJR19VU0JfQVJDSF9IQVNfSENEPXkKQ09ORklH X1VTQj1tCiMgQ09ORklHX1VTQl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19VU0JfQU5OT1VOQ0Vf TkVXX0RFVklDRVM9eQoKIwojIE1pc2NlbGxhbmVvdXMgVVNCIG9wdGlvbnMKIwpDT05GSUdfVVNC X0RFVklDRUZTPXkKIyBDT05GSUdfVVNCX0RFVklDRV9DTEFTUyBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9EWU5BTUlDX01JTk9SUyBpcyBub3Qgc2V0CkNPTkZJR19VU0JfU1VTUEVORD15CiMgQ09O RklHX1VTQl9PVEcgaXMgbm90IHNldApDT05GSUdfVVNCX01PTj1tCkNPTkZJR19VU0JfV1VTQj1t CkNPTkZJR19VU0JfV1VTQl9DQkFGPW0KIyBDT05GSUdfVVNCX1dVU0JfQ0JBRl9ERUJVRyBpcyBu b3Qgc2V0CgojCiMgVVNCIEhvc3QgQ29udHJvbGxlciBEcml2ZXJzCiMKQ09ORklHX1VTQl9DNjdY MDBfSENEPW0KQ09ORklHX1VTQl9YSENJX0hDRD1tCiMgQ09ORklHX1VTQl9YSENJX0hDRF9ERUJV R0dJTkcgaXMgbm90IHNldApDT05GSUdfVVNCX0VIQ0lfSENEPW0KQ09ORklHX1VTQl9FSENJX1JP T1RfSFVCX1RUPXkKQ09ORklHX1VTQl9FSENJX1RUX05FV1NDSEVEPXkKQ09ORklHX1VTQl9PWFUy MTBIUF9IQ0Q9bQpDT05GSUdfVVNCX0lTUDExNlhfSENEPW0KQ09ORklHX1VTQl9JU1AxNzYwX0hD RD1tCkNPTkZJR19VU0JfSVNQMTM2Ml9IQ0Q9bQpDT05GSUdfVVNCX09IQ0lfSENEPW0KIyBDT05G SUdfVVNCX09IQ0lfSENEX1NTQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9PSENJX0hDRF9QTEFU Rk9STSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9FSENJX0hDRF9QTEFURk9STSBpcyBub3Qgc2V0 CiMgQ09ORklHX1VTQl9PSENJX0JJR19FTkRJQU5fREVTQyBpcyBub3Qgc2V0CiMgQ09ORklHX1VT Ql9PSENJX0JJR19FTkRJQU5fTU1JTyBpcyBub3Qgc2V0CkNPTkZJR19VU0JfT0hDSV9MSVRUTEVf RU5ESUFOPXkKQ09ORklHX1VTQl9VSENJX0hDRD1tCkNPTkZJR19VU0JfVTEzMl9IQ0Q9bQpDT05G SUdfVVNCX1NMODExX0hDRD1tCiMgQ09ORklHX1VTQl9TTDgxMV9IQ0RfSVNPIGlzIG5vdCBzZXQK Q09ORklHX1VTQl9TTDgxMV9DUz1tCkNPTkZJR19VU0JfUjhBNjY1OTdfSENEPW0KQ09ORklHX1VT Ql9XSENJX0hDRD1tCkNPTkZJR19VU0JfSFdBX0hDRD1tCgojCiMgVVNCIERldmljZSBDbGFzcyBk cml2ZXJzCiMKQ09ORklHX1VTQl9BQ009bQpDT05GSUdfVVNCX1BSSU5URVI9bQpDT05GSUdfVVNC X1dETT1tCkNPTkZJR19VU0JfVE1DPW0KCiMKIyBOT1RFOiBVU0JfU1RPUkFHRSBkZXBlbmRzIG9u IFNDU0kgYnV0IEJMS19ERVZfU0QgbWF5CiMKCiMKIyBhbHNvIGJlIG5lZWRlZDsgc2VlIFVTQl9T VE9SQUdFIEhlbHAgZm9yIG1vcmUgaW5mbwojCkNPTkZJR19VU0JfU1RPUkFHRT1tCiMgQ09ORklH X1VTQl9TVE9SQUdFX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9TVE9SQUdFX1JFQUxURUs9 bQpDT05GSUdfUkVBTFRFS19BVVRPUE09eQpDT05GSUdfVVNCX1NUT1JBR0VfREFUQUZBQj1tCkNP TkZJR19VU0JfU1RPUkFHRV9GUkVFQ09NPW0KQ09ORklHX1VTQl9TVE9SQUdFX0lTRDIwMD1tCkNP TkZJR19VU0JfU1RPUkFHRV9VU0JBVD1tCkNPTkZJR19VU0JfU1RPUkFHRV9TRERSMDk9bQpDT05G SUdfVVNCX1NUT1JBR0VfU0REUjU1PW0KQ09ORklHX1VTQl9TVE9SQUdFX0pVTVBTSE9UPW0KQ09O RklHX1VTQl9TVE9SQUdFX0FMQVVEQT1tCkNPTkZJR19VU0JfU1RPUkFHRV9PTkVUT1VDSD1tCkNP TkZJR19VU0JfU1RPUkFHRV9LQVJNQT1tCkNPTkZJR19VU0JfU1RPUkFHRV9DWVBSRVNTX0FUQUNC PW0KQ09ORklHX1VTQl9TVE9SQUdFX0VORV9VQjYyNTA9bQpDT05GSUdfVVNCX1VBUz1tCiMgQ09O RklHX1VTQl9MSUJVU1VBTCBpcyBub3Qgc2V0CgojCiMgVVNCIEltYWdpbmcgZGV2aWNlcwojCkNP TkZJR19VU0JfTURDODAwPW0KQ09ORklHX1VTQl9NSUNST1RFSz1tCgojCiMgVVNCIHBvcnQgZHJp dmVycwojCkNPTkZJR19VU0JfVVNTNzIwPW0KQ09ORklHX1VTQl9TRVJJQUw9bQpDT05GSUdfVVNC X0VaVVNCPXkKQ09ORklHX1VTQl9TRVJJQUxfR0VORVJJQz15CkNPTkZJR19VU0JfU0VSSUFMX0FJ UkNBQkxFPW0KQ09ORklHX1VTQl9TRVJJQUxfQVJLMzExNj1tCkNPTkZJR19VU0JfU0VSSUFMX0JF TEtJTj1tCkNPTkZJR19VU0JfU0VSSUFMX0NIMzQxPW0KQ09ORklHX1VTQl9TRVJJQUxfV0hJVEVI RUFUPW0KQ09ORklHX1VTQl9TRVJJQUxfRElHSV9BQ0NFTEVQT1JUPW0KQ09ORklHX1VTQl9TRVJJ QUxfQ1AyMTBYPW0KQ09ORklHX1VTQl9TRVJJQUxfQ1lQUkVTU19NOD1tCkNPTkZJR19VU0JfU0VS SUFMX0VNUEVHPW0KQ09ORklHX1VTQl9TRVJJQUxfRlRESV9TSU89bQpDT05GSUdfVVNCX1NFUklB TF9GVU5TT0ZUPW0KQ09ORklHX1VTQl9TRVJJQUxfVklTT1I9bQpDT05GSUdfVVNCX1NFUklBTF9J UEFRPW0KQ09ORklHX1VTQl9TRVJJQUxfSVI9bQpDT05GSUdfVVNCX1NFUklBTF9FREdFUE9SVD1t CkNPTkZJR19VU0JfU0VSSUFMX0VER0VQT1JUX1RJPW0KQ09ORklHX1VTQl9TRVJJQUxfRjgxMjMy PW0KQ09ORklHX1VTQl9TRVJJQUxfR0FSTUlOPW0KQ09ORklHX1VTQl9TRVJJQUxfSVBXPW0KQ09O RklHX1VTQl9TRVJJQUxfSVVVPW0KQ09ORklHX1VTQl9TRVJJQUxfS0VZU1BBTl9QREE9bQpDT05G SUdfVVNCX1NFUklBTF9LRVlTUEFOPW0KQ09ORklHX1VTQl9TRVJJQUxfS0xTST1tCkNPTkZJR19V U0JfU0VSSUFMX0tPQklMX1NDVD1tCkNPTkZJR19VU0JfU0VSSUFMX01DVF9VMjMyPW0KQ09ORklH X1VTQl9TRVJJQUxfTUVUUk89bQpDT05GSUdfVVNCX1NFUklBTF9NT1M3NzIwPW0KQ09ORklHX1VT Ql9TRVJJQUxfTU9TNzcxNV9QQVJQT1JUPXkKQ09ORklHX1VTQl9TRVJJQUxfTU9TNzg0MD1tCkNP TkZJR19VU0JfU0VSSUFMX01PVE9ST0xBPW0KQ09ORklHX1VTQl9TRVJJQUxfTkFWTUFOPW0KQ09O RklHX1VTQl9TRVJJQUxfUEwyMzAzPW0KQ09ORklHX1VTQl9TRVJJQUxfT1RJNjg1OD1tCkNPTkZJ R19VU0JfU0VSSUFMX1FDQVVYPW0KQ09ORklHX1VTQl9TRVJJQUxfUVVBTENPTU09bQpDT05GSUdf VVNCX1NFUklBTF9TUENQOFg1PW0KQ09ORklHX1VTQl9TRVJJQUxfSFA0WD1tCkNPTkZJR19VU0Jf U0VSSUFMX1NBRkU9bQpDT05GSUdfVVNCX1NFUklBTF9TQUZFX1BBRERFRD15CkNPTkZJR19VU0Jf U0VSSUFMX1NJRU1FTlNfTVBJPW0KQ09ORklHX1VTQl9TRVJJQUxfU0lFUlJBV0lSRUxFU1M9bQpD T05GSUdfVVNCX1NFUklBTF9TWU1CT0w9bQpDT05GSUdfVVNCX1NFUklBTF9UST1tCkNPTkZJR19V U0JfU0VSSUFMX0NZQkVSSkFDSz1tCkNPTkZJR19VU0JfU0VSSUFMX1hJUkNPTT1tCkNPTkZJR19V U0JfU0VSSUFMX1dXQU49bQpDT05GSUdfVVNCX1NFUklBTF9PUFRJT049bQpDT05GSUdfVVNCX1NF UklBTF9PTU5JTkVUPW0KQ09ORklHX1VTQl9TRVJJQUxfT1BUSUNPTj1tCkNPTkZJR19VU0JfU0VS SUFMX1ZJVk9QQVlfU0VSSUFMPW0KQ09ORklHX1VTQl9TRVJJQUxfWklPPW0KQ09ORklHX1VTQl9T RVJJQUxfU1NVMTAwPW0KQ09ORklHX1VTQl9TRVJJQUxfREVCVUc9bQoKIwojIFVTQiBNaXNjZWxs YW5lb3VzIGRyaXZlcnMKIwpDT05GSUdfVVNCX0VNSTYyPW0KQ09ORklHX1VTQl9FTUkyNj1tCkNP TkZJR19VU0JfQURVVFVYPW0KQ09ORklHX1VTQl9TRVZTRUc9bQpDT05GSUdfVVNCX1JJTzUwMD1t CkNPTkZJR19VU0JfTEVHT1RPV0VSPW0KQ09ORklHX1VTQl9MQ0Q9bQpDT05GSUdfVVNCX0xFRD1t CkNPTkZJR19VU0JfQ1lQUkVTU19DWTdDNjM9bQpDT05GSUdfVVNCX0NZVEhFUk09bQpDT05GSUdf VVNCX0lETU9VU0U9bQpDT05GSUdfVVNCX0ZURElfRUxBTj1tCkNPTkZJR19VU0JfQVBQTEVESVNQ TEFZPW0KQ09ORklHX1VTQl9TSVNVU0JWR0E9bQpDT05GSUdfVVNCX1NJU1VTQlZHQV9DT049eQpD T05GSUdfVVNCX0xEPW0KQ09ORklHX1VTQl9UUkFOQ0VWSUJSQVRPUj1tCkNPTkZJR19VU0JfSU9X QVJSSU9SPW0KIyBDT05GSUdfVVNCX1RFU1QgaXMgbm90IHNldApDT05GSUdfVVNCX0lTSUdIVEZX PW0KQ09ORklHX1VTQl9ZVVJFWD1tCkNPTkZJR19VU0JfQVRNPW0KQ09ORklHX1VTQl9TUEVFRFRP VUNIPW0KQ09ORklHX1VTQl9DWEFDUlU9bQpDT05GSUdfVVNCX1VFQUdMRUFUTT1tCkNPTkZJR19V U0JfWFVTQkFUTT1tCiMgQ09ORklHX1VTQl9HQURHRVQgaXMgbm90IHNldAoKIwojIE9URyBhbmQg cmVsYXRlZCBpbmZyYXN0cnVjdHVyZQojCiMgQ09ORklHX1VTQl9HUElPX1ZCVVMgaXMgbm90IHNl dAojIENPTkZJR19OT1BfVVNCX1hDRUlWIGlzIG5vdCBzZXQKQ09ORklHX1VXQj1tCkNPTkZJR19V V0JfSFdBPW0KQ09ORklHX1VXQl9XSENJPW0KQ09ORklHX1VXQl9JMTQ4MFU9bQpDT05GSUdfTU1D PW0KIyBDT05GSUdfTU1DX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfTU1DX1VOU0FGRV9SRVNV TUUgaXMgbm90IHNldAojIENPTkZJR19NTUNfQ0xLR0FURSBpcyBub3Qgc2V0CgojCiMgTU1DL1NE L1NESU8gQ2FyZCBEcml2ZXJzCiMKQ09ORklHX01NQ19CTE9DSz1tCkNPTkZJR19NTUNfQkxPQ0tf TUlOT1JTPTgKQ09ORklHX01NQ19CTE9DS19CT1VOQ0U9eQpDT05GSUdfU0RJT19VQVJUPW0KQ09O RklHX01NQ19URVNUPW0KCiMKIyBNTUMvU0QvU0RJTyBIb3N0IENvbnRyb2xsZXIgRHJpdmVycwoj CkNPTkZJR19NTUNfU0RIQ0k9bQpDT05GSUdfTU1DX1NESENJX1BDST1tCkNPTkZJR19NTUNfUklD T0hfTU1DPXkKQ09ORklHX01NQ19TREhDSV9QTFRGTT1tCkNPTkZJR19NTUNfV0JTRD1tCkNPTkZJ R19NTUNfVElGTV9TRD1tCkNPTkZJR19NTUNfU1BJPW0KQ09ORklHX01NQ19TRFJJQ09IX0NTPW0K Q09ORklHX01NQ19DQjcxMD1tCkNPTkZJR19NTUNfVklBX1NETU1DPW0KQ09ORklHX01NQ19WVUIz MDA9bQpDT05GSUdfTU1DX1VTSEM9bQpDT05GSUdfTUVNU1RJQ0s9bQojIENPTkZJR19NRU1TVElD S19ERUJVRyBpcyBub3Qgc2V0CgojCiMgTWVtb3J5U3RpY2sgZHJpdmVycwojCiMgQ09ORklHX01F TVNUSUNLX1VOU0FGRV9SRVNVTUUgaXMgbm90IHNldApDT05GSUdfTVNQUk9fQkxPQ0s9bQoKIwoj IE1lbW9yeVN0aWNrIEhvc3QgQ29udHJvbGxlciBEcml2ZXJzCiMKQ09ORklHX01FTVNUSUNLX1RJ Rk1fTVM9bQpDT05GSUdfTUVNU1RJQ0tfSk1JQ1JPTl8zOFg9bQpDT05GSUdfTUVNU1RJQ0tfUjU5 Mj1tCkNPTkZJR19ORVdfTEVEUz15CkNPTkZJR19MRURTX0NMQVNTPXkKCiMKIyBMRUQgZHJpdmVy cwojCkNPTkZJR19MRURTX0xNMzUzMD1tCkNPTkZJR19MRURTX1BDQTk1MzI9bQojIENPTkZJR19M RURTX1BDQTk1MzJfR1BJTyBpcyBub3Qgc2V0CkNPTkZJR19MRURTX0dQSU89bQpDT05GSUdfTEVE U19MUDM5NDQ9bQpDT05GSUdfTEVEU19MUDU1MjE9bQpDT05GSUdfTEVEU19MUDU1MjM9bQpDT05G SUdfTEVEU19DTEVWT19NQUlMPW0KQ09ORklHX0xFRFNfUENBOTU1WD1tCkNPTkZJR19MRURTX1BD QTk2MzM9bQpDT05GSUdfTEVEU19EQUMxMjRTMDg1PW0KQ09ORklHX0xFRFNfUkVHVUxBVE9SPW0K Q09ORklHX0xFRFNfQkQyODAyPW0KQ09ORklHX0xFRFNfSU5URUxfU1M0MjAwPW0KQ09ORklHX0xF RFNfTFQzNTkzPW0KQ09ORklHX0xFRFNfREVMTF9ORVRCT09LUz1tCkNPTkZJR19MRURTX01DMTM3 ODM9bQpDT05GSUdfTEVEU19UQ0E2NTA3PW0KQ09ORklHX0xFRFNfT1QyMDA9bQpDT05GSUdfTEVE U19UUklHR0VSUz15CgojCiMgTEVEIFRyaWdnZXJzCiMKQ09ORklHX0xFRFNfVFJJR0dFUl9USU1F Uj1tCkNPTkZJR19MRURTX1RSSUdHRVJfSEVBUlRCRUFUPW0KQ09ORklHX0xFRFNfVFJJR0dFUl9C QUNLTElHSFQ9bQpDT05GSUdfTEVEU19UUklHR0VSX0dQSU89bQpDT05GSUdfTEVEU19UUklHR0VS X0RFRkFVTFRfT049bQoKIwojIGlwdGFibGVzIHRyaWdnZXIgaXMgdW5kZXIgTmV0ZmlsdGVyIGNv bmZpZyAoTEVEIHRhcmdldCkKIwojIENPTkZJR19BQ0NFU1NJQklMSVRZIGlzIG5vdCBzZXQKQ09O RklHX0lORklOSUJBTkQ9bQpDT05GSUdfSU5GSU5JQkFORF9VU0VSX01BRD1tCkNPTkZJR19JTkZJ TklCQU5EX1VTRVJfQUNDRVNTPW0KQ09ORklHX0lORklOSUJBTkRfVVNFUl9NRU09eQpDT05GSUdf SU5GSU5JQkFORF9BRERSX1RSQU5TPXkKQ09ORklHX0lORklOSUJBTkRfTVRIQ0E9bQpDT05GSUdf SU5GSU5JQkFORF9NVEhDQV9ERUJVRz15CkNPTkZJR19JTkZJTklCQU5EX0lQQVRIPW0KQ09ORklH X0lORklOSUJBTkRfUUlCPW0KQ09ORklHX0lORklOSUJBTkRfQU1TTzExMDA9bQojIENPTkZJR19J TkZJTklCQU5EX0FNU08xMTAwX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0lORklOSUJBTkRfQ1hH QjM9bQojIENPTkZJR19JTkZJTklCQU5EX0NYR0IzX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX0lO RklOSUJBTkRfQ1hHQjQ9bQpDT05GSUdfTUxYNF9JTkZJTklCQU5EPW0KQ09ORklHX0lORklOSUJB TkRfTkVTPW0KIyBDT05GSUdfSU5GSU5JQkFORF9ORVNfREVCVUcgaXMgbm90IHNldApDT05GSUdf SU5GSU5JQkFORF9JUE9JQj1tCkNPTkZJR19JTkZJTklCQU5EX0lQT0lCX0NNPXkKQ09ORklHX0lO RklOSUJBTkRfSVBPSUJfREVCVUc9eQojIENPTkZJR19JTkZJTklCQU5EX0lQT0lCX0RFQlVHX0RB VEEgaXMgbm90IHNldApDT05GSUdfSU5GSU5JQkFORF9TUlA9bQpDT05GSUdfSU5GSU5JQkFORF9J U0VSPW0KQ09ORklHX0VEQUM9eQoKIwojIFJlcG9ydGluZyBzdWJzeXN0ZW1zCiMKIyBDT05GSUdf RURBQ19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19FREFDX0RFQ09ERV9NQ0U9bQojIENPTkZJR19F REFDX01DRV9JTkogaXMgbm90IHNldApDT05GSUdfRURBQ19NTV9FREFDPW0KQ09ORklHX0VEQUNf QU1ENjQ9bQojIENPTkZJR19FREFDX0FNRDY0X0VSUk9SX0lOSkVDVElPTiBpcyBub3Qgc2V0CkNP TkZJR19FREFDX0U3NTJYPW0KQ09ORklHX0VEQUNfSTgyOTc1WD1tCkNPTkZJR19FREFDX0kzMDAw PW0KQ09ORklHX0VEQUNfSTMyMDA9bQpDT05GSUdfRURBQ19YMzg9bQpDT05GSUdfRURBQ19JNTQw MD1tCkNPTkZJR19FREFDX0k3Q09SRT1tCkNPTkZJR19FREFDX0k1MDAwPW0KQ09ORklHX0VEQUNf STUxMDA9bQpDT05GSUdfRURBQ19JNzMwMD1tCkNPTkZJR19FREFDX1NCUklER0U9bQpDT05GSUdf UlRDX0xJQj15CkNPTkZJR19SVENfQ0xBU1M9eQpDT05GSUdfUlRDX0hDVE9TWVM9eQpDT05GSUdf UlRDX0hDVE9TWVNfREVWSUNFPSJydGMwIgojIENPTkZJR19SVENfREVCVUcgaXMgbm90IHNldAoK IwojIFJUQyBpbnRlcmZhY2VzCiMKQ09ORklHX1JUQ19JTlRGX1NZU0ZTPXkKQ09ORklHX1JUQ19J TlRGX1BST0M9eQpDT05GSUdfUlRDX0lOVEZfREVWPXkKQ09ORklHX1JUQ19JTlRGX0RFVl9VSUVf RU1VTD15CkNPTkZJR19SVENfRFJWX1RFU1Q9bQoKIwojIEkyQyBSVEMgZHJpdmVycwojCkNPTkZJ R19SVENfRFJWX0RTMTMwNz1tCkNPTkZJR19SVENfRFJWX0RTMTM3ND1tCkNPTkZJR19SVENfRFJW X0RTMTY3Mj1tCkNPTkZJR19SVENfRFJWX0RTMzIzMj1tCkNPTkZJR19SVENfRFJWX01BWDY5MDA9 bQpDT05GSUdfUlRDX0RSVl9SUzVDMzcyPW0KQ09ORklHX1JUQ19EUlZfSVNMMTIwOD1tCkNPTkZJ R19SVENfRFJWX0lTTDEyMDIyPW0KQ09ORklHX1JUQ19EUlZfWDEyMDU9bQpDT05GSUdfUlRDX0RS Vl9QQ0Y4NTYzPW0KQ09ORklHX1JUQ19EUlZfUENGODU4Mz1tCkNPTkZJR19SVENfRFJWX000MVQ4 MD1tCkNPTkZJR19SVENfRFJWX000MVQ4MF9XRFQ9eQpDT05GSUdfUlRDX0RSVl9CUTMySz1tCkNP TkZJR19SVENfRFJWX1MzNTM5MEE9bQpDT05GSUdfUlRDX0RSVl9GTTMxMzA9bQpDT05GSUdfUlRD X0RSVl9SWDg1ODE9bQpDT05GSUdfUlRDX0RSVl9SWDgwMjU9bQpDT05GSUdfUlRDX0RSVl9FTTMw Mjc9bQpDT05GSUdfUlRDX0RSVl9SVjMwMjlDMj1tCgojCiMgU1BJIFJUQyBkcml2ZXJzCiMKQ09O RklHX1JUQ19EUlZfTTQxVDkzPW0KQ09ORklHX1JUQ19EUlZfTTQxVDk0PW0KQ09ORklHX1JUQ19E UlZfRFMxMzA1PW0KQ09ORklHX1JUQ19EUlZfRFMxMzkwPW0KQ09ORklHX1JUQ19EUlZfTUFYNjkw Mj1tCkNPTkZJR19SVENfRFJWX1I5NzAxPW0KQ09ORklHX1JUQ19EUlZfUlM1QzM0OD1tCkNPTkZJ R19SVENfRFJWX0RTMzIzND1tCkNPTkZJR19SVENfRFJWX1BDRjIxMjM9bQoKIwojIFBsYXRmb3Jt IFJUQyBkcml2ZXJzCiMKQ09ORklHX1JUQ19EUlZfQ01PUz15CkNPTkZJR19SVENfRFJWX0RTMTI4 Nj1tCkNPTkZJR19SVENfRFJWX0RTMTUxMT1tCkNPTkZJR19SVENfRFJWX0RTMTU1Mz1tCkNPTkZJ R19SVENfRFJWX0RTMTc0Mj1tCkNPTkZJR19SVENfRFJWX0RBOTA1Mj1tCkNPTkZJR19SVENfRFJW X1NUSzE3VEE4PW0KQ09ORklHX1JUQ19EUlZfTTQ4VDg2PW0KQ09ORklHX1JUQ19EUlZfTTQ4VDM1 PW0KQ09ORklHX1JUQ19EUlZfTTQ4VDU5PW0KQ09ORklHX1JUQ19EUlZfTVNNNjI0Mj1tCkNPTkZJ R19SVENfRFJWX0JRNDgwMj1tCkNPTkZJR19SVENfRFJWX1JQNUMwMT1tCkNPTkZJR19SVENfRFJW X1YzMDIwPW0KCiMKIyBvbi1DUFUgUlRDIGRyaXZlcnMKIwpDT05GSUdfUlRDX0RSVl9QQ0FQPW0K Q09ORklHX1JUQ19EUlZfTUMxM1hYWD1tCkNPTkZJR19ETUFERVZJQ0VTPXkKIyBDT05GSUdfRE1B REVWSUNFU19ERUJVRyBpcyBub3Qgc2V0CgojCiMgRE1BIERldmljZXMKIwpDT05GSUdfSU5URUxf TUlEX0RNQUM9bQpDT05GSUdfSU5URUxfSU9BVERNQT1tCkNPTkZJR19USU1CX0RNQT1tCkNPTkZJ R19QQ0hfRE1BPW0KQ09ORklHX0RNQV9FTkdJTkU9eQoKIwojIERNQSBDbGllbnRzCiMKQ09ORklH X05FVF9ETUE9eQpDT05GSUdfQVNZTkNfVFhfRE1BPXkKQ09ORklHX0RNQVRFU1Q9bQpDT05GSUdf RENBPW0KQ09ORklHX0FVWERJU1BMQVk9eQpDT05GSUdfS1MwMTA4PW0KQ09ORklHX0tTMDEwOF9Q T1JUPTB4Mzc4CkNPTkZJR19LUzAxMDhfREVMQVk9MgpDT05GSUdfQ0ZBRzEyODY0Qj1tCkNPTkZJ R19DRkFHMTI4NjRCX1JBVEU9MjAKQ09ORklHX1VJTz1tCkNPTkZJR19VSU9fQ0lGPW0KQ09ORklH X1VJT19QRFJWPW0KQ09ORklHX1VJT19QRFJWX0dFTklSUT1tCkNPTkZJR19VSU9fQUVDPW0KQ09O RklHX1VJT19TRVJDT1MzPW0KQ09ORklHX1VJT19QQ0lfR0VORVJJQz1tCkNPTkZJR19VSU9fTkVU WD1tCkNPTkZJR19WSVJUSU89bQpDT05GSUdfVklSVElPX1JJTkc9bQoKIwojIFZpcnRpbyBkcml2 ZXJzCiMKIyBDT05GSUdfVklSVElPX1BDSSBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJUlRJT19CQUxM T09OIGlzIG5vdCBzZXQKQ09ORklHX1ZJUlRJT19NTUlPPW0KCiMKIyBNaWNyb3NvZnQgSHlwZXIt ViBndWVzdCBzdXBwb3J0CiMKIyBDT05GSUdfSFlQRVJWIGlzIG5vdCBzZXQKCiMKIyBYZW4gZHJp dmVyIHN1cHBvcnQKIwpDT05GSUdfWEVOX0JBTExPT049eQpDT05GSUdfWEVOX1NFTEZCQUxMT09O SU5HPXkKQ09ORklHX1hFTl9CQUxMT09OX01FTU9SWV9IT1RQTFVHPXkKQ09ORklHX1hFTl9TQ1JV Ql9QQUdFUz15CkNPTkZJR19YRU5fREVWX0VWVENITj1tCkNPTkZJR19YRU5fQkFDS0VORD15CkNP TkZJR19YRU5GUz15CkNPTkZJR19YRU5fQ09NUEFUX1hFTkZTPXkKQ09ORklHX1hFTl9TWVNfSFlQ RVJWSVNPUj15CkNPTkZJR19YRU5fWEVOQlVTX0ZST05URU5EPXkKQ09ORklHX1hFTl9HTlRERVY9 bQpDT05GSUdfWEVOX0dSQU5UX0RFVl9BTExPQz1tCkNPTkZJR19TV0lPVExCX1hFTj15CkNPTkZJ R19YRU5fVE1FTT15CkNPTkZJR19YRU5fUENJREVWX0JBQ0tFTkQ9bQpDT05GSUdfWEVOX1BSSVZD TUQ9eQpDT05GSUdfWEVOX0FDUElfUFJPQ0VTU09SPXkKQ09ORklHX1NUQUdJTkc9eQpDT05GSUdf RVQxMzFYPW0KQ09ORklHX1NMSUNPU1M9bQpDT05GSUdfVVNCSVBfQ09SRT1tCkNPTkZJR19VU0JJ UF9WSENJX0hDRD1tCkNPTkZJR19VU0JJUF9IT1NUPW0KIyBDT05GSUdfVVNCSVBfREVCVUcgaXMg bm90IHNldApDT05GSUdfVzM1VU5EPW0KQ09ORklHX1BSSVNNMl9VU0I9bQpDT05GSUdfRUNITz1t CiMgQ09ORklHX0NPTUVESSBpcyBub3Qgc2V0CkNPTkZJR19BU1VTX09MRUQ9bQpDT05GSUdfUEFO RUw9bQpDT05GSUdfUEFORUxfUEFSUE9SVD0wCkNPTkZJR19QQU5FTF9QUk9GSUxFPTUKIyBDT05G SUdfUEFORUxfQ0hBTkdFX01FU1NBR0UgaXMgbm90IHNldApDT05GSUdfUjgxODdTRT1tCkNPTkZJ R19SVEw4MTkyVT1tCkNPTkZJR19SVExMSUI9bQpDT05GSUdfUlRMTElCX0NSWVBUT19DQ01QPW0K Q09ORklHX1JUTExJQl9DUllQVE9fVEtJUD1tCkNPTkZJR19SVExMSUJfQ1JZUFRPX1dFUD1tCkNP TkZJR19SVEw4MTkyRT1tCkNPTkZJR19SODcxMlU9bQpDT05GSUdfUlRTX1BTVE9SPW0KIyBDT05G SUdfUlRTX1BTVE9SX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1JUUzUxMzk9bQojIENPTkZJR19S VFM1MTM5X0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX1RSQU5aUE9SVD1tCkNPTkZJR19JREVfUEhJ U09OPW0KQ09ORklHX0xJTkU2X1VTQj1tCiMgQ09ORklHX0xJTkU2X1VTQl9ERUJVRyBpcyBub3Qg c2V0CiMgQ09ORklHX0xJTkU2X1VTQl9EVU1QX0NUUkwgaXMgbm90IHNldAojIENPTkZJR19MSU5F Nl9VU0JfRFVNUF9NSURJIGlzIG5vdCBzZXQKIyBDT05GSUdfTElORTZfVVNCX0RVTVBfUENNIGlz IG5vdCBzZXQKIyBDT05GSUdfTElORTZfVVNCX1JBVyBpcyBub3Qgc2V0CiMgQ09ORklHX0xJTkU2 X1VTQl9JTVBVTFNFX1JFU1BPTlNFIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9TRVJJQUxfUVVBVEVD SDI9bQpDT05GSUdfVVNCX1NFUklBTF9RVUFURUNIX1VTQjI9bQpDT05GSUdfVlQ2NjU1PW0KQ09O RklHX1ZUNjY1Nj1tCkNPTkZJR19WTUVfQlVTPW0KCiMKIyBWTUUgQnJpZGdlIERyaXZlcnMKIwpD T05GSUdfVk1FX0NBOTFDWDQyPW0KQ09ORklHX1ZNRV9UU0kxNDg9bQoKIwojIFZNRSBEZXZpY2Ug RHJpdmVycwojCkNPTkZJR19WTUVfVVNFUj1tCkNPTkZJR19WTUVfUElPMj1tCgojCiMgVk1FIEJv YXJkIERyaXZlcnMKIwpDT05GSUdfVk1JVk1FXzc4MDU9bQpDT05GSUdfRFhfU0VQPW0KQ09ORklH X0lJTz1tCkNPTkZJR19JSU9fU1RfSFdNT049bQpDT05GSUdfSUlPX0JVRkZFUj15CkNPTkZJR19J SU9fU1dfUklORz1tCkNPTkZJR19JSU9fS0ZJRk9fQlVGPW0KQ09ORklHX0lJT19UUklHR0VSPXkK Q09ORklHX0lJT19DT05TVU1FUlNfUEVSX1RSSUdHRVI9MgoKIwojIEFjY2VsZXJvbWV0ZXJzCiMK Q09ORklHX0FESVMxNjIwMT1tCkNPTkZJR19BRElTMTYyMDM9bQpDT05GSUdfQURJUzE2MjA0PW0K Q09ORklHX0FESVMxNjIwOT1tCkNPTkZJR19BRElTMTYyMjA9bQpDT05GSUdfQURJUzE2MjQwPW0K Q09ORklHX0tYU0Q5PW0KQ09ORklHX0xJUzNMMDJEUT1tCkNPTkZJR19MSVMzTDAyRFFfQlVGX0tG SUZPPXkKIyBDT05GSUdfTElTM0wwMkRRX0JVRl9SSU5HX1NXIGlzIG5vdCBzZXQKQ09ORklHX1ND QTMwMDA9bQoKIwojIEFuYWxvZyB0byBkaWdpdGFsIGNvbnZlcnRlcnMKIwpDT05GSUdfQUQ3Mjkx PW0KQ09ORklHX0FENzI5OD1tCkNPTkZJR19BRDc2MDY9bQpDT05GSUdfQUQ3NjA2X0lGQUNFX1BB UkFMTEVMPW0KQ09ORklHX0FENzYwNl9JRkFDRV9TUEk9bQpDT05GSUdfQUQ3OTlYPW0KQ09ORklH X0FENzk5WF9SSU5HX0JVRkZFUj15CkNPTkZJR19BRDc0NzY9bQpDT05GSUdfQUQ3ODg3PW0KQ09O RklHX0FENzc4MD1tCkNPTkZJR19BRDc3OTM9bQpDT05GSUdfQUQ3ODE2PW0KQ09ORklHX0FENzE5 Mj1tCkNPTkZJR19BRFQ3MzEwPW0KQ09ORklHX0FEVDc0MTA9bQpDT05GSUdfQUQ3MjgwPW0KQ09O RklHX01BWDEzNjM9bQpDT05GSUdfTUFYMTM2M19SSU5HX0JVRkZFUj15CgojCiMgQW5hbG9nIGRp Z2l0YWwgYmktZGlyZWN0aW9uIGNvbnZlcnRlcnMKIwpDT05GSUdfQURUNzMxNj1tCkNPTkZJR19B RFQ3MzE2X1NQST1tCkNPTkZJR19BRFQ3MzE2X0kyQz1tCgojCiMgQ2FwYWNpdGFuY2UgdG8gZGln aXRhbCBjb252ZXJ0ZXJzCiMKQ09ORklHX0FENzE1MD1tCkNPTkZJR19BRDcxNTI9bQpDT05GSUdf QUQ3NzQ2PW0KCiMKIyBEaWdpdGFsIHRvIGFuYWxvZyBjb252ZXJ0ZXJzCiMKQ09ORklHX0FENTA2 ND1tCkNPTkZJR19BRDUzNjA9bQpDT05GSUdfQUQ1MzgwPW0KQ09ORklHX0FENTQyMT1tCkNPTkZJ R19BRDU2MjRSX1NQST1tCkNPTkZJR19BRDU0NDY9bQpDT05GSUdfQUQ1NTA0PW0KQ09ORklHX0FE NTc2ND1tCkNPTkZJR19BRDU3OTE9bQpDT05GSUdfQUQ1Njg2PW0KQ09ORklHX01BWDUxNz1tCgoj CiMgRGlyZWN0IERpZ2l0YWwgU3ludGhlc2lzCiMKQ09ORklHX0FENTkzMD1tCkNPTkZJR19BRDk4 MzI9bQpDT05GSUdfQUQ5ODM0PW0KQ09ORklHX0FEOTg1MD1tCkNPTkZJR19BRDk4NTI9bQpDT05G SUdfQUQ5OTEwPW0KQ09ORklHX0FEOTk1MT1tCgojCiMgRGlnaXRhbCBneXJvc2NvcGUgc2Vuc29y cwojCkNPTkZJR19BRElTMTYwNjA9bQpDT05GSUdfQURJUzE2MDgwPW0KQ09ORklHX0FESVMxNjEz MD1tCkNPTkZJR19BRElTMTYyNjA9bQpDT05GSUdfQURYUlM0NTA9bQoKIwojIE5ldHdvcmsgQW5h bHl6ZXIsIEltcGVkYW5jZSBDb252ZXJ0ZXJzCiMKQ09ORklHX0FENTkzMz1tCgojCiMgSW5lcnRp YWwgbWVhc3VyZW1lbnQgdW5pdHMKIwpDT05GSUdfQURJUzE2NDAwPW0KCiMKIyBMaWdodCBzZW5z b3JzCiMKQ09ORklHX1NFTlNPUlNfSVNMMjkwMTg9bQpDT05GSUdfU0VOU09SU19UU0wyNTYzPW0K Q09ORklHX1RTTDI1ODM9bQoKIwojIE1hZ25ldG9tZXRlciBzZW5zb3JzCiMKQ09ORklHX1NFTlNP UlNfQUs4OTc1PW0KQ09ORklHX1NFTlNPUlNfSE1DNTg0Mz1tCgojCiMgQWN0aXZlIGVuZXJneSBt ZXRlcmluZyBJQwojCkNPTkZJR19BREU3NzUzPW0KQ09ORklHX0FERTc3NTQ9bQpDT05GSUdfQURF Nzc1OD1tCkNPTkZJR19BREU3NzU5PW0KQ09ORklHX0FERTc4NTQ9bQpDT05GSUdfQURFNzg1NF9J MkM9bQpDT05GSUdfQURFNzg1NF9TUEk9bQoKIwojIFJlc29sdmVyIHRvIGRpZ2l0YWwgY29udmVy dGVycwojCkNPTkZJR19BRDJTOTA9bQpDT05GSUdfQUQyUzEyMDA9bQpDT05GSUdfQUQyUzEyMTA9 bQoKIwojIFRyaWdnZXJzIC0gc3RhbmRhbG9uZQojCkNPTkZJR19JSU9fUEVSSU9ESUNfUlRDX1RS SUdHRVI9bQpDT05GSUdfSUlPX0dQSU9fVFJJR0dFUj1tCkNPTkZJR19JSU9fU1lTRlNfVFJJR0dF Uj1tCkNPTkZJR19JSU9fU0lNUExFX0RVTU1ZPW0KIyBDT05GSUdfSUlPX1NJTVBMRV9EVU1NWV9F VkVOVFMgaXMgbm90IHNldAojIENPTkZJR19JSU9fU0lNUExFX0RVTU1ZX0JVRkZFUiBpcyBub3Qg c2V0CkNPTkZJR19aUkFNPW0KIyBDT05GSUdfWlJBTV9ERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklH X1pDQUNIRSBpcyBub3Qgc2V0CkNPTkZJR19aU01BTExPQz1tCkNPTkZJR19XTEFHUzQ5X0gyPW0K Q09ORklHX1dMQUdTNDlfSDI1PW0KQ09ORklHX0ZCX1NNN1hYPW0KQ09ORklHX0NSWVNUQUxIRD1t CkNPTkZJR19DWFQxRTE9bQojIENPTkZJR19TQkVfUE1DQzRfTkNPTU0gaXMgbm90IHNldApDT05G SUdfRkJfWEdJPW0KQ09ORklHX0FDUElfUVVJQ0tTVEFSVD1tCkNPTkZJR19TQkVfMlQzRTM9bQpD T05GSUdfVVNCX0VORVNUT1JBR0U9bQpDT05GSUdfQkNNX1dJTUFYPW0KQ09ORklHX0ZUMTAwMD1t CkNPTkZJR19GVDEwMDBfVVNCPW0KQ09ORklHX0ZUMTAwMF9QQ01DSUE9bQoKIwojIFNwZWFrdXAg Y29uc29sZSBzcGVlY2gKIwojIENPTkZJR19TUEVBS1VQIGlzIG5vdCBzZXQKQ09ORklHX1RPVUNI U0NSRUVOX0NMRUFSUEFEX1RNMTIxNz1tCkNPTkZJR19UT1VDSFNDUkVFTl9TWU5BUFRJQ1NfSTJD X1JNSTQ9bQpDT05GSUdfSU5URUxfTUVJPW0KQ09ORklHX1NUQUdJTkdfTUVESUE9eQpDT05GSUdf RFZCX0FTMTAyPW0KQ09ORklHX0RWQl9DWEQyMDk5PW0KQ09ORklHX1ZJREVPX0RUMzE1NT1tCkNP TkZJR19EVDMxNTVfQ0NJUj15CkNPTkZJR19EVDMxNTVfU1RSRUFNSU5HPXkKQ09ORklHX0VBU1lD QVA9bQojIENPTkZJR19FQVNZQ0FQX0RFQlVHIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fR083 MDA3IGlzIG5vdCBzZXQKQ09ORklHX1NPTE82WDEwPW0KQ09ORklHX0xJUkNfU1RBR0lORz15CkNP TkZJR19MSVJDX0JUODI5PW0KQ09ORklHX0xJUkNfSUdPUlBMVUdVU0I9bQpDT05GSUdfTElSQ19J TU9OPW0KQ09ORklHX0xJUkNfUEFSQUxMRUw9bQpDT05GSUdfTElSQ19TQVNFTT1tCkNPTkZJR19M SVJDX1NFUklBTD1tCkNPTkZJR19MSVJDX1NFUklBTF9UUkFOU01JVFRFUj15CkNPTkZJR19MSVJD X1NJUj1tCkNPTkZJR19MSVJDX1RUVVNCSVI9bQpDT05GSUdfTElSQ19aSUxPRz1tCgojCiMgQW5k cm9pZAojCiMgQ09ORklHX0FORFJPSUQgaXMgbm90IHNldApDT05GSUdfUEhPTkU9bQpDT05GSUdf UEhPTkVfSVhKPW0KQ09ORklHX1BIT05FX0lYSl9QQ01DSUE9bQpDT05GSUdfVVNCX1dQQU5fSENE PW0KQ09ORklHX1g4Nl9QTEFURk9STV9ERVZJQ0VTPXkKQ09ORklHX0FDRVJfV01JPW0KQ09ORklH X0FDRVJIREY9bQpDT05GSUdfQVNVU19MQVBUT1A9bQpDT05GSUdfREVMTF9MQVBUT1A9bQpDT05G SUdfREVMTF9XTUk9bQpDT05GSUdfREVMTF9XTUlfQUlPPW0KQ09ORklHX0ZVSklUU1VfTEFQVE9Q PW0KIyBDT05GSUdfRlVKSVRTVV9MQVBUT1BfREVCVUcgaXMgbm90IHNldApDT05GSUdfRlVKSVRT VV9UQUJMRVQ9bQpDT05GSUdfQU1JTE9fUkZLSUxMPW0KQ09ORklHX0hQX0FDQ0VMPW0KQ09ORklH X0hQX1dNST1tCkNPTkZJR19NU0lfTEFQVE9QPW0KQ09ORklHX1BBTkFTT05JQ19MQVBUT1A9bQpD T05GSUdfQ09NUEFMX0xBUFRPUD1tCkNPTkZJR19TT05ZX0xBUFRPUD1tCkNPTkZJR19TT05ZUElf Q09NUEFUPXkKQ09ORklHX0lERUFQQURfTEFQVE9QPW0KQ09ORklHX1RISU5LUEFEX0FDUEk9bQpD T05GSUdfVEhJTktQQURfQUNQSV9BTFNBX1NVUFBPUlQ9eQojIENPTkZJR19USElOS1BBRF9BQ1BJ X0RFQlVHRkFDSUxJVElFUyBpcyBub3Qgc2V0CiMgQ09ORklHX1RISU5LUEFEX0FDUElfREVCVUcg aXMgbm90IHNldAojIENPTkZJR19USElOS1BBRF9BQ1BJX1VOU0FGRV9MRURTIGlzIG5vdCBzZXQK Q09ORklHX1RISU5LUEFEX0FDUElfVklERU89eQpDT05GSUdfVEhJTktQQURfQUNQSV9IT1RLRVlf UE9MTD15CkNPTkZJR19TRU5TT1JTX0hEQVBTPW0KQ09ORklHX0lOVEVMX01FTkxPVz1tCkNPTkZJ R19FRUVQQ19MQVBUT1A9bQpDT05GSUdfQVNVU19XTUk9bQpDT05GSUdfQVNVU19OQl9XTUk9bQpD T05GSUdfRUVFUENfV01JPW0KQ09ORklHX0FDUElfV01JPW0KQ09ORklHX01TSV9XTUk9bQpDT05G SUdfVE9QU1RBUl9MQVBUT1A9bQpDT05GSUdfQUNQSV9UT1NISUJBPW0KQ09ORklHX1RPU0hJQkFf QlRfUkZLSUxMPW0KQ09ORklHX0FDUElfQ01QQz1tCkNPTkZJR19JTlRFTF9JUFM9bQpDT05GSUdf SUJNX1JUTD1tCkNPTkZJR19YTzE1X0VCT09LPW0KQ09ORklHX1NBTVNVTkdfTEFQVE9QPW0KQ09O RklHX01YTV9XTUk9bQpDT05GSUdfSU5URUxfT0FLVFJBSUw9bQpDT05GSUdfU0FNU1VOR19RMTA9 bQpDT05GSUdfQVBQTEVfR01VWD1tCgojCiMgSGFyZHdhcmUgU3BpbmxvY2sgZHJpdmVycwojCkNP TkZJR19DTEtFVlRfSTgyNTM9eQpDT05GSUdfSTgyNTNfTE9DSz15CkNPTkZJR19DTEtCTERfSTgy NTM9eQpDT05GSUdfSU9NTVVfQVBJPXkKQ09ORklHX0lPTU1VX1NVUFBPUlQ9eQpDT05GSUdfQU1E X0lPTU1VPXkKIyBDT05GSUdfQU1EX0lPTU1VX1NUQVRTIGlzIG5vdCBzZXQKQ09ORklHX0FNRF9J T01NVV9WMj1tCkNPTkZJR19ETUFSX1RBQkxFPXkKQ09ORklHX0lOVEVMX0lPTU1VPXkKQ09ORklH X0lOVEVMX0lPTU1VX0RFRkFVTFRfT049eQpDT05GSUdfSU5URUxfSU9NTVVfRkxPUFBZX1dBPXkK Q09ORklHX0lSUV9SRU1BUD15CgojCiMgUmVtb3RlcHJvYyBkcml2ZXJzIChFWFBFUklNRU5UQUwp CiMKCiMKIyBScG1zZyBkcml2ZXJzIChFWFBFUklNRU5UQUwpCiMKQ09ORklHX1ZJUlRfRFJJVkVS Uz15CkNPTkZJR19QTV9ERVZGUkVRPXkKCiMKIyBERVZGUkVRIEdvdmVybm9ycwojCkNPTkZJR19E RVZGUkVRX0dPVl9TSU1QTEVfT05ERU1BTkQ9eQpDT05GSUdfREVWRlJFUV9HT1ZfUEVSRk9STUFO Q0U9eQpDT05GSUdfREVWRlJFUV9HT1ZfUE9XRVJTQVZFPXkKQ09ORklHX0RFVkZSRVFfR09WX1VT RVJTUEFDRT15CgojCiMgREVWRlJFUSBEcml2ZXJzCiMKCiMKIyBGaXJtd2FyZSBEcml2ZXJzCiMK Q09ORklHX0VERD1tCiMgQ09ORklHX0VERF9PRkYgaXMgbm90IHNldApDT05GSUdfRklSTVdBUkVf TUVNTUFQPXkKQ09ORklHX0RFTExfUkJVPW0KQ09ORklHX0RDREJBUz1tCkNPTkZJR19ETUlJRD15 CkNPTkZJR19ETUlfU1lTRlM9bQpDT05GSUdfSVNDU0lfSUJGVF9GSU5EPXkKQ09ORklHX0lTQ1NJ X0lCRlQ9bQojIENPTkZJR19HT09HTEVfRklSTVdBUkUgaXMgbm90IHNldAoKIwojIEZpbGUgc3lz dGVtcwojCkNPTkZJR19EQ0FDSEVfV09SRF9BQ0NFU1M9eQpDT05GSUdfRVhUMl9GUz15CkNPTkZJ R19FWFQyX0ZTX1hBVFRSPXkKQ09ORklHX0VYVDJfRlNfUE9TSVhfQUNMPXkKQ09ORklHX0VYVDJf RlNfU0VDVVJJVFk9eQojIENPTkZJR19FWFQyX0ZTX1hJUCBpcyBub3Qgc2V0CkNPTkZJR19FWFQz X0ZTPXkKQ09ORklHX0VYVDNfREVGQVVMVFNfVE9fT1JERVJFRD15CkNPTkZJR19FWFQzX0ZTX1hB VFRSPXkKQ09ORklHX0VYVDNfRlNfUE9TSVhfQUNMPXkKQ09ORklHX0VYVDNfRlNfU0VDVVJJVFk9 eQpDT05GSUdfRVhUNF9GUz1tCkNPTkZJR19FWFQ0X0ZTX1hBVFRSPXkKQ09ORklHX0VYVDRfRlNf UE9TSVhfQUNMPXkKQ09ORklHX0VYVDRfRlNfU0VDVVJJVFk9eQojIENPTkZJR19FWFQ0X0RFQlVH IGlzIG5vdCBzZXQKQ09ORklHX0pCRD15CiMgQ09ORklHX0pCRF9ERUJVRyBpcyBub3Qgc2V0CkNP TkZJR19KQkQyPW0KIyBDT05GSUdfSkJEMl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19GU19NQkNB Q0hFPXkKQ09ORklHX1JFSVNFUkZTX0ZTPW0KIyBDT05GSUdfUkVJU0VSRlNfQ0hFQ0sgaXMgbm90 IHNldAojIENPTkZJR19SRUlTRVJGU19QUk9DX0lORk8gaXMgbm90IHNldApDT05GSUdfUkVJU0VS RlNfRlNfWEFUVFI9eQpDT05GSUdfUkVJU0VSRlNfRlNfUE9TSVhfQUNMPXkKQ09ORklHX1JFSVNF UkZTX0ZTX1NFQ1VSSVRZPXkKQ09ORklHX0pGU19GUz1tCkNPTkZJR19KRlNfUE9TSVhfQUNMPXkK Q09ORklHX0pGU19TRUNVUklUWT15CiMgQ09ORklHX0pGU19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJ R19KRlNfU1RBVElTVElDUz15CkNPTkZJR19YRlNfRlM9bQpDT05GSUdfWEZTX1FVT1RBPXkKQ09O RklHX1hGU19QT1NJWF9BQ0w9eQpDT05GSUdfWEZTX1JUPXkKIyBDT05GSUdfWEZTX0RFQlVHIGlz IG5vdCBzZXQKQ09ORklHX0dGUzJfRlM9bQojIENPTkZJR19HRlMyX0ZTX0xPQ0tJTkdfRExNIGlz IG5vdCBzZXQKQ09ORklHX09DRlMyX0ZTPW0KQ09ORklHX09DRlMyX0ZTX08yQ0I9bQpDT05GSUdf T0NGUzJfRlNfVVNFUlNQQUNFX0NMVVNURVI9bQpDT05GSUdfT0NGUzJfRlNfU1RBVFM9eQojIENP TkZJR19PQ0ZTMl9ERUJVR19NQVNLTE9HIGlzIG5vdCBzZXQKIyBDT05GSUdfT0NGUzJfREVCVUdf RlMgaXMgbm90IHNldApDT05GSUdfQlRSRlNfRlM9bQpDT05GSUdfQlRSRlNfRlNfUE9TSVhfQUNM PXkKIyBDT05GSUdfQlRSRlNfRlNfQ0hFQ0tfSU5URUdSSVRZIGlzIG5vdCBzZXQKQ09ORklHX05J TEZTMl9GUz1tCkNPTkZJR19GU19QT1NJWF9BQ0w9eQpDT05GSUdfRVhQT1JURlM9bQpDT05GSUdf RklMRV9MT0NLSU5HPXkKQ09ORklHX0ZTTk9USUZZPXkKQ09ORklHX0ROT1RJRlk9eQpDT05GSUdf SU5PVElGWV9VU0VSPXkKQ09ORklHX0ZBTk9USUZZPXkKQ09ORklHX1FVT1RBPXkKQ09ORklHX1FV T1RBX05FVExJTktfSU5URVJGQUNFPXkKQ09ORklHX1BSSU5UX1FVT1RBX1dBUk5JTkc9eQojIENP TkZJR19RVU9UQV9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19RVU9UQV9UUkVFPW0KQ09ORklHX1FG TVRfVjE9bQpDT05GSUdfUUZNVF9WMj1tCkNPTkZJR19RVU9UQUNUTD15CkNPTkZJR19RVU9UQUNU TF9DT01QQVQ9eQpDT05GSUdfQVVUT0ZTNF9GUz1tCkNPTkZJR19GVVNFX0ZTPW0KQ09ORklHX0NV U0U9bQpDT05GSUdfR0VORVJJQ19BQ0w9eQoKIwojIENhY2hlcwojCkNPTkZJR19GU0NBQ0hFPW0K Q09ORklHX0ZTQ0FDSEVfU1RBVFM9eQojIENPTkZJR19GU0NBQ0hFX0hJU1RPR1JBTSBpcyBub3Qg c2V0CiMgQ09ORklHX0ZTQ0FDSEVfREVCVUcgaXMgbm90IHNldApDT05GSUdfRlNDQUNIRV9PQkpF Q1RfTElTVD15CkNPTkZJR19DQUNIRUZJTEVTPW0KIyBDT05GSUdfQ0FDSEVGSUxFU19ERUJVRyBp cyBub3Qgc2V0CiMgQ09ORklHX0NBQ0hFRklMRVNfSElTVE9HUkFNIGlzIG5vdCBzZXQKCiMKIyBD RC1ST00vRFZEIEZpbGVzeXN0ZW1zCiMKQ09ORklHX0lTTzk2NjBfRlM9eQpDT05GSUdfSk9MSUVU PXkKQ09ORklHX1pJU09GUz15CkNPTkZJR19VREZfRlM9bQpDT05GSUdfVURGX05MUz15CgojCiMg RE9TL0ZBVC9OVCBGaWxlc3lzdGVtcwojCkNPTkZJR19GQVRfRlM9bQpDT05GSUdfTVNET1NfRlM9 bQpDT05GSUdfVkZBVF9GUz1tCkNPTkZJR19GQVRfREVGQVVMVF9DT0RFUEFHRT00MzcKQ09ORklH X0ZBVF9ERUZBVUxUX0lPQ0hBUlNFVD0iaXNvODg1OS0xIgojIENPTkZJR19OVEZTX0ZTIGlzIG5v dCBzZXQKCiMKIyBQc2V1ZG8gZmlsZXN5c3RlbXMKIwpDT05GSUdfUFJPQ19GUz15CkNPTkZJR19Q Uk9DX0tDT1JFPXkKQ09ORklHX1BST0NfU1lTQ1RMPXkKQ09ORklHX1BST0NfUEFHRV9NT05JVE9S PXkKQ09ORklHX1NZU0ZTPXkKQ09ORklHX1RNUEZTPXkKQ09ORklHX1RNUEZTX1BPU0lYX0FDTD15 CkNPTkZJR19UTVBGU19YQVRUUj15CiMgQ09ORklHX0hVR0VUTEJGUyBpcyBub3Qgc2V0CiMgQ09O RklHX0hVR0VUTEJfUEFHRSBpcyBub3Qgc2V0CkNPTkZJR19DT05GSUdGU19GUz1tCkNPTkZJR19N SVNDX0ZJTEVTWVNURU1TPXkKQ09ORklHX0FERlNfRlM9bQpDT05GSUdfQURGU19GU19SVz15CkNP TkZJR19BRkZTX0ZTPW0KQ09ORklHX0VDUllQVF9GUz1tCkNPTkZJR19IRlNfRlM9bQpDT05GSUdf SEZTUExVU19GUz1tCkNPTkZJR19CRUZTX0ZTPW0KIyBDT05GSUdfQkVGU19ERUJVRyBpcyBub3Qg c2V0CkNPTkZJR19CRlNfRlM9bQpDT05GSUdfRUZTX0ZTPW0KQ09ORklHX0pGRlMyX0ZTPW0KQ09O RklHX0pGRlMyX0ZTX0RFQlVHPTAKQ09ORklHX0pGRlMyX0ZTX1dSSVRFQlVGRkVSPXkKIyBDT05G SUdfSkZGUzJfRlNfV0JVRl9WRVJJRlkgaXMgbm90IHNldApDT05GSUdfSkZGUzJfU1VNTUFSWT15 CkNPTkZJR19KRkZTMl9GU19YQVRUUj15CkNPTkZJR19KRkZTMl9GU19QT1NJWF9BQ0w9eQpDT05G SUdfSkZGUzJfRlNfU0VDVVJJVFk9eQpDT05GSUdfSkZGUzJfQ09NUFJFU1NJT05fT1BUSU9OUz15 CkNPTkZJR19KRkZTMl9aTElCPXkKIyBDT05GSUdfSkZGUzJfTFpPIGlzIG5vdCBzZXQKQ09ORklH X0pGRlMyX1JUSU1FPXkKIyBDT05GSUdfSkZGUzJfUlVCSU4gaXMgbm90IHNldAojIENPTkZJR19K RkZTMl9DTU9ERV9OT05FIGlzIG5vdCBzZXQKQ09ORklHX0pGRlMyX0NNT0RFX1BSSU9SSVRZPXkK IyBDT05GSUdfSkZGUzJfQ01PREVfU0laRSBpcyBub3Qgc2V0CiMgQ09ORklHX0pGRlMyX0NNT0RF X0ZBVk9VUkxaTyBpcyBub3Qgc2V0CkNPTkZJR19VQklGU19GUz1tCkNPTkZJR19VQklGU19GU19Y QVRUUj15CkNPTkZJR19VQklGU19GU19BRFZBTkNFRF9DT01QUj15CkNPTkZJR19VQklGU19GU19M Wk89eQpDT05GSUdfVUJJRlNfRlNfWkxJQj15CiMgQ09ORklHX1VCSUZTX0ZTX0RFQlVHIGlzIG5v dCBzZXQKQ09ORklHX0xPR0ZTPW0KQ09ORklHX0NSQU1GUz1tCkNPTkZJR19TUVVBU0hGUz1tCkNP TkZJR19TUVVBU0hGU19YQVRUUj15CkNPTkZJR19TUVVBU0hGU19aTElCPXkKQ09ORklHX1NRVUFT SEZTX0xaTz15CkNPTkZJR19TUVVBU0hGU19YWj15CkNPTkZJR19TUVVBU0hGU180S19ERVZCTEtf U0laRT15CiMgQ09ORklHX1NRVUFTSEZTX0VNQkVEREVEIGlzIG5vdCBzZXQKQ09ORklHX1NRVUFT SEZTX0ZSQUdNRU5UX0NBQ0hFX1NJWkU9MwpDT05GSUdfVlhGU19GUz1tCkNPTkZJR19NSU5JWF9G Uz1tCkNPTkZJR19PTUZTX0ZTPW0KQ09ORklHX0hQRlNfRlM9bQpDT05GSUdfUU5YNEZTX0ZTPW0K Q09ORklHX1FOWDZGU19GUz1tCiMgQ09ORklHX1FOWDZGU19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJ R19ST01GU19GUz1tCiMgQ09ORklHX1JPTUZTX0JBQ0tFRF9CWV9CTE9DSyBpcyBub3Qgc2V0CiMg Q09ORklHX1JPTUZTX0JBQ0tFRF9CWV9NVEQgaXMgbm90IHNldApDT05GSUdfUk9NRlNfQkFDS0VE X0JZX0JPVEg9eQpDT05GSUdfUk9NRlNfT05fQkxPQ0s9eQpDT05GSUdfUk9NRlNfT05fTVREPXkK IyBDT05GSUdfUFNUT1JFIGlzIG5vdCBzZXQKQ09ORklHX1NZU1ZfRlM9bQpDT05GSUdfVUZTX0ZT PW0KQ09ORklHX1VGU19GU19XUklURT15CiMgQ09ORklHX1VGU19ERUJVRyBpcyBub3Qgc2V0CkNP TkZJR19FWE9GU19GUz1tCiMgQ09ORklHX0VYT0ZTX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX09S RT1tCkNPTkZJR19ORVRXT1JLX0ZJTEVTWVNURU1TPXkKQ09ORklHX05GU19GUz1tCkNPTkZJR19O RlNfVjM9eQpDT05GSUdfTkZTX1YzX0FDTD15CkNPTkZJR19ORlNfVjQ9eQojIENPTkZJR19ORlNf VjRfMSBpcyBub3Qgc2V0CkNPTkZJR19ORlNfRlNDQUNIRT15CiMgQ09ORklHX05GU19VU0VfTEVH QUNZX0ROUyBpcyBub3Qgc2V0CkNPTkZJR19ORlNfVVNFX0tFUk5FTF9ETlM9eQpDT05GSUdfTkZT RD1tCkNPTkZJR19ORlNEX1YyX0FDTD15CkNPTkZJR19ORlNEX1YzPXkKQ09ORklHX05GU0RfVjNf QUNMPXkKQ09ORklHX05GU0RfVjQ9eQojIENPTkZJR19ORlNEX0ZBVUxUX0lOSkVDVElPTiBpcyBu b3Qgc2V0CkNPTkZJR19MT0NLRD1tCkNPTkZJR19MT0NLRF9WND15CkNPTkZJR19ORlNfQUNMX1NV UFBPUlQ9bQpDT05GSUdfTkZTX0NPTU1PTj15CkNPTkZJR19TVU5SUEM9bQpDT05GSUdfU1VOUlBD X0dTUz1tCkNPTkZJR19TVU5SUENfWFBSVF9SRE1BPW0KQ09ORklHX1JQQ1NFQ19HU1NfS1JCNT1t CiMgQ09ORklHX1NVTlJQQ19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19DRVBIX0ZTPW0KQ09ORklH X0NJRlM9bQpDT05GSUdfQ0lGU19TVEFUUz15CkNPTkZJR19DSUZTX1NUQVRTMj15CkNPTkZJR19D SUZTX1dFQUtfUFdfSEFTSD15CkNPTkZJR19DSUZTX1VQQ0FMTD15CkNPTkZJR19DSUZTX1hBVFRS PXkKQ09ORklHX0NJRlNfUE9TSVg9eQojIENPTkZJR19DSUZTX0RFQlVHMiBpcyBub3Qgc2V0CkNP TkZJR19DSUZTX0RGU19VUENBTEw9eQojIENPTkZJR19DSUZTX0ZTQ0FDSEUgaXMgbm90IHNldApD T05GSUdfQ0lGU19BQ0w9eQpDT05GSUdfTkNQX0ZTPW0KQ09ORklHX05DUEZTX1BBQ0tFVF9TSUdO SU5HPXkKQ09ORklHX05DUEZTX0lPQ1RMX0xPQ0tJTkc9eQpDT05GSUdfTkNQRlNfU1RST05HPXkK Q09ORklHX05DUEZTX05GU19OUz15CkNPTkZJR19OQ1BGU19PUzJfTlM9eQpDT05GSUdfTkNQRlNf U01BTExET1M9eQpDT05GSUdfTkNQRlNfTkxTPXkKQ09ORklHX05DUEZTX0VYVFJBUz15CkNPTkZJ R19DT0RBX0ZTPW0KQ09ORklHX0FGU19GUz1tCiMgQ09ORklHX0FGU19ERUJVRyBpcyBub3Qgc2V0 CkNPTkZJR19BRlNfRlNDQUNIRT15CkNPTkZJR185UF9GUz1tCiMgQ09ORklHXzlQX0ZTQ0FDSEUg aXMgbm90IHNldApDT05GSUdfOVBfRlNfUE9TSVhfQUNMPXkKQ09ORklHX05MUz15CkNPTkZJR19O TFNfREVGQVVMVD0idXRmOCIKQ09ORklHX05MU19DT0RFUEFHRV80Mzc9bQpDT05GSUdfTkxTX0NP REVQQUdFXzczNz1tCkNPTkZJR19OTFNfQ09ERVBBR0VfNzc1PW0KQ09ORklHX05MU19DT0RFUEFH RV84NTA9bQpDT05GSUdfTkxTX0NPREVQQUdFXzg1Mj1tCkNPTkZJR19OTFNfQ09ERVBBR0VfODU1 PW0KQ09ORklHX05MU19DT0RFUEFHRV84NTc9bQpDT05GSUdfTkxTX0NPREVQQUdFXzg2MD1tCkNP TkZJR19OTFNfQ09ERVBBR0VfODYxPW0KQ09ORklHX05MU19DT0RFUEFHRV84NjI9bQpDT05GSUdf TkxTX0NPREVQQUdFXzg2Mz1tCkNPTkZJR19OTFNfQ09ERVBBR0VfODY0PW0KQ09ORklHX05MU19D T0RFUEFHRV84NjU9bQpDT05GSUdfTkxTX0NPREVQQUdFXzg2Nj1tCkNPTkZJR19OTFNfQ09ERVBB R0VfODY5PW0KQ09ORklHX05MU19DT0RFUEFHRV85MzY9bQpDT05GSUdfTkxTX0NPREVQQUdFXzk1 MD1tCkNPTkZJR19OTFNfQ09ERVBBR0VfOTMyPW0KQ09ORklHX05MU19DT0RFUEFHRV85NDk9bQpD T05GSUdfTkxTX0NPREVQQUdFXzg3ND1tCkNPTkZJR19OTFNfSVNPODg1OV84PW0KQ09ORklHX05M U19DT0RFUEFHRV8xMjUwPW0KQ09ORklHX05MU19DT0RFUEFHRV8xMjUxPW0KQ09ORklHX05MU19B U0NJST1tCkNPTkZJR19OTFNfSVNPODg1OV8xPW0KQ09ORklHX05MU19JU084ODU5XzI9bQpDT05G SUdfTkxTX0lTTzg4NTlfMz1tCkNPTkZJR19OTFNfSVNPODg1OV80PW0KQ09ORklHX05MU19JU084 ODU5XzU9bQpDT05GSUdfTkxTX0lTTzg4NTlfNj1tCkNPTkZJR19OTFNfSVNPODg1OV83PW0KQ09O RklHX05MU19JU084ODU5Xzk9bQpDT05GSUdfTkxTX0lTTzg4NTlfMTM9bQpDT05GSUdfTkxTX0lT Tzg4NTlfMTQ9bQpDT05GSUdfTkxTX0lTTzg4NTlfMTU9bQpDT05GSUdfTkxTX0tPSThfUj1tCkNP TkZJR19OTFNfS09JOF9VPW0KQ09ORklHX05MU19VVEY4PW0KQ09ORklHX0RMTT1tCkNPTkZJR19E TE1fREVCVUc9eQoKIwojIEtlcm5lbCBoYWNraW5nCiMKQ09ORklHX1RSQUNFX0lSUUZMQUdTX1NV UFBPUlQ9eQpDT05GSUdfUFJJTlRLX1RJTUU9eQpDT05GSUdfREVGQVVMVF9NRVNTQUdFX0xPR0xF VkVMPTQKQ09ORklHX0VOQUJMRV9XQVJOX0RFUFJFQ0FURUQ9eQpDT05GSUdfRU5BQkxFX01VU1Rf Q0hFQ0s9eQpDT05GSUdfRlJBTUVfV0FSTj0yMDQ4CkNPTkZJR19NQUdJQ19TWVNSUT15CkNPTkZJ R19TVFJJUF9BU01fU1lNUz15CkNPTkZJR19VTlVTRURfU1lNQk9MUz15CkNPTkZJR19ERUJVR19G Uz15CkNPTkZJR19IRUFERVJTX0NIRUNLPXkKIyBDT05GSUdfREVCVUdfU0VDVElPTl9NSVNNQVRD SCBpcyBub3Qgc2V0CkNPTkZJR19ERUJVR19LRVJORUw9eQojIENPTkZJR19ERUJVR19TSElSUSBp cyBub3Qgc2V0CkNPTkZJR19MT0NLVVBfREVURUNUT1I9eQpDT05GSUdfSEFSRExPQ0tVUF9ERVRF Q1RPUj15CiMgQ09ORklHX0JPT1RQQVJBTV9IQVJETE9DS1VQX1BBTklDIGlzIG5vdCBzZXQKQ09O RklHX0JPT1RQQVJBTV9IQVJETE9DS1VQX1BBTklDX1ZBTFVFPTAKIyBDT05GSUdfQk9PVFBBUkFN X1NPRlRMT0NLVVBfUEFOSUMgaXMgbm90IHNldApDT05GSUdfQk9PVFBBUkFNX1NPRlRMT0NLVVBf UEFOSUNfVkFMVUU9MApDT05GSUdfREVURUNUX0hVTkdfVEFTSz15CkNPTkZJR19ERUZBVUxUX0hV TkdfVEFTS19USU1FT1VUPTAKIyBDT05GSUdfQk9PVFBBUkFNX0hVTkdfVEFTS19QQU5JQyBpcyBu b3Qgc2V0CkNPTkZJR19CT09UUEFSQU1fSFVOR19UQVNLX1BBTklDX1ZBTFVFPTAKQ09ORklHX1ND SEVEX0RFQlVHPXkKQ09ORklHX1NDSEVEU1RBVFM9eQpDT05GSUdfVElNRVJfU1RBVFM9eQojIENP TkZJR19ERUJVR19PQkpFQ1RTIGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX1NMQUI9eQpDT05GSUdf REVCVUdfU0xBQl9MRUFLPXkKQ09ORklHX0RFQlVHX0tNRU1MRUFLPXkKQ09ORklHX0RFQlVHX0tN RU1MRUFLX0VBUkxZX0xPR19TSVpFPTQwMAojIENPTkZJR19ERUJVR19LTUVNTEVBS19URVNUIGlz IG5vdCBzZXQKIyBDT05GSUdfREVCVUdfS01FTUxFQUtfREVGQVVMVF9PRkYgaXMgbm90IHNldAoj IENPTkZJR19ERUJVR19SVF9NVVRFWEVTIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRfTVVURVhfVEVT VEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfU1BJTkxPQ0sgaXMgbm90IHNldAojIENPTkZJ R19ERUJVR19NVVRFWEVTIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfTE9DS19BTExPQyBpcyBu b3Qgc2V0CiMgQ09ORklHX1BST1ZFX0xPQ0tJTkcgaXMgbm90IHNldAojIENPTkZJR19TUEFSU0Vf UkNVX1BPSU5URVIgaXMgbm90IHNldAojIENPTkZJR19MT0NLX1NUQVQgaXMgbm90IHNldAojIENP TkZJR19ERUJVR19BVE9NSUNfU0xFRVAgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19MT0NLSU5H X0FQSV9TRUxGVEVTVFMgaXMgbm90IHNldApDT05GSUdfU1RBQ0tUUkFDRT15CiMgQ09ORklHX0RF QlVHX1NUQUNLX1VTQUdFIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfS09CSkVDVCBpcyBub3Qg c2V0CkNPTkZJR19ERUJVR19CVUdWRVJCT1NFPXkKIyBDT05GSUdfREVCVUdfSU5GTyBpcyBub3Qg c2V0CiMgQ09ORklHX0RFQlVHX1ZNIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfVklSVFVBTCBp cyBub3Qgc2V0CiMgQ09ORklHX0RFQlVHX1dSSVRFQ09VTlQgaXMgbm90IHNldApDT05GSUdfREVC VUdfTUVNT1JZX0lOSVQ9eQpDT05GSUdfREVCVUdfTElTVD15CiMgQ09ORklHX1RFU1RfTElTVF9T T1JUIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfU0cgaXMgbm90IHNldAojIENPTkZJR19ERUJV R19OT1RJRklFUlMgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19DUkVERU5USUFMUyBpcyBub3Qg c2V0CkNPTkZJR19BUkNIX1dBTlRfRlJBTUVfUE9JTlRFUlM9eQpDT05GSUdfRlJBTUVfUE9JTlRF Uj15CiMgQ09ORklHX0JPT1RfUFJJTlRLX0RFTEFZIGlzIG5vdCBzZXQKIyBDT05GSUdfUkNVX1RP UlRVUkVfVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19SQ1VfQ1BVX1NUQUxMX1RJTUVPVVQ9NjAKIyBD T05GSUdfUkNVX0NQVV9TVEFMTF9JTkZPIGlzIG5vdCBzZXQKIyBDT05GSUdfUkNVX1RSQUNFIGlz IG5vdCBzZXQKIyBDT05GSUdfS1BST0JFU19TQU5JVFlfVEVTVCBpcyBub3Qgc2V0CiMgQ09ORklH X0JBQ0tUUkFDRV9TRUxGX1RFU1QgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19CTE9DS19FWFRf REVWVCBpcyBub3Qgc2V0CkNPTkZJR19ERUJVR19GT1JDRV9XRUFLX1BFUl9DUFU9eQojIENPTkZJ R19ERUJVR19QRVJfQ1BVX01BUFMgaXMgbm90IHNldApDT05GSUdfTEtEVE09bQojIENPTkZJR19D UFVfTk9USUZJRVJfRVJST1JfSU5KRUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfRkFVTFRfSU5KRUNU SU9OIGlzIG5vdCBzZXQKQ09ORklHX0xBVEVOQ1lUT1A9eQpDT05GSUdfREVCVUdfUEFHRUFMTE9D PXkKQ09ORklHX1dBTlRfUEFHRV9ERUJVR19GTEFHUz15CkNPTkZJR19QQUdFX0dVQVJEPXkKQ09O RklHX1VTRVJfU1RBQ0tUUkFDRV9TVVBQT1JUPXkKQ09ORklHX05PUF9UUkFDRVI9eQpDT05GSUdf SEFWRV9GVU5DVElPTl9UUkFDRVI9eQpDT05GSUdfSEFWRV9GVU5DVElPTl9HUkFQSF9UUkFDRVI9 eQpDT05GSUdfSEFWRV9GVU5DVElPTl9HUkFQSF9GUF9URVNUPXkKQ09ORklHX0hBVkVfRlVOQ1RJ T05fVFJBQ0VfTUNPVU5UX1RFU1Q9eQpDT05GSUdfSEFWRV9EWU5BTUlDX0ZUUkFDRT15CkNPTkZJ R19IQVZFX0ZUUkFDRV9NQ09VTlRfUkVDT1JEPXkKQ09ORklHX0hBVkVfU1lTQ0FMTF9UUkFDRVBP SU5UUz15CkNPTkZJR19IQVZFX0NfUkVDT1JETUNPVU5UPXkKQ09ORklHX1JJTkdfQlVGRkVSPXkK Q09ORklHX0VWRU5UX1RSQUNJTkc9eQpDT05GSUdfRVZFTlRfUE9XRVJfVFJBQ0lOR19ERVBSRUNB VEVEPXkKQ09ORklHX0NPTlRFWFRfU1dJVENIX1RSQUNFUj15CkNPTkZJR19SSU5HX0JVRkZFUl9B TExPV19TV0FQPXkKQ09ORklHX1RSQUNJTkc9eQpDT05GSUdfR0VORVJJQ19UUkFDRVI9eQpDT05G SUdfVFJBQ0lOR19TVVBQT1JUPXkKQ09ORklHX0ZUUkFDRT15CiMgQ09ORklHX0ZVTkNUSU9OX1RS QUNFUiBpcyBub3Qgc2V0CiMgQ09ORklHX0lSUVNPRkZfVFJBQ0VSIGlzIG5vdCBzZXQKIyBDT05G SUdfU0NIRURfVFJBQ0VSIGlzIG5vdCBzZXQKIyBDT05GSUdfRlRSQUNFX1NZU0NBTExTIGlzIG5v dCBzZXQKQ09ORklHX0JSQU5DSF9QUk9GSUxFX05PTkU9eQojIENPTkZJR19QUk9GSUxFX0FOTk9U QVRFRF9CUkFOQ0hFUyBpcyBub3Qgc2V0CiMgQ09ORklHX1BST0ZJTEVfQUxMX0JSQU5DSEVTIGlz IG5vdCBzZXQKIyBDT05GSUdfU1RBQ0tfVFJBQ0VSIGlzIG5vdCBzZXQKQ09ORklHX0JMS19ERVZf SU9fVFJBQ0U9eQpDT05GSUdfS1BST0JFX0VWRU5UPXkKIyBDT05GSUdfRlRSQUNFX1NUQVJUVVBf VEVTVCBpcyBub3Qgc2V0CiMgQ09ORklHX01NSU9UUkFDRSBpcyBub3Qgc2V0CkNPTkZJR19SSU5H X0JVRkZFUl9CRU5DSE1BUks9bQpDT05GSUdfUFJPVklERV9PSENJMTM5NF9ETUFfSU5JVD15CkNP TkZJR19GSVJFV0lSRV9PSENJX1JFTU9URV9ETUE9eQpDT05GSUdfQlVJTERfRE9DU1JDPXkKQ09O RklHX0RZTkFNSUNfREVCVUc9eQojIENPTkZJR19ETUFfQVBJX0RFQlVHIGlzIG5vdCBzZXQKIyBD T05GSUdfQVRPTUlDNjRfU0VMRlRFU1QgaXMgbm90IHNldApDT05GSUdfQVNZTkNfUkFJRDZfVEVT VD1tCiMgQ09ORklHX1NBTVBMRVMgaXMgbm90IHNldApDT05GSUdfSEFWRV9BUkNIX0tHREI9eQoj IENPTkZJR19LR0RCIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfQVJDSF9LTUVNQ0hFQ0s9eQojIENP TkZJR19LTUVNQ0hFQ0sgaXMgbm90IHNldAojIENPTkZJR19URVNUX0tTVFJUT1ggaXMgbm90IHNl dAojIENPTkZJR19TVFJJQ1RfREVWTUVNIGlzIG5vdCBzZXQKQ09ORklHX1g4Nl9WRVJCT1NFX0JP T1RVUD15CkNPTkZJR19FQVJMWV9QUklOVEs9eQpDT05GSUdfRUFSTFlfUFJJTlRLX0RCR1A9eQpD T05GSUdfREVCVUdfU1RBQ0tPVkVSRkxPVz15CiMgQ09ORklHX1g4Nl9QVERVTVAgaXMgbm90IHNl dApDT05GSUdfREVCVUdfUk9EQVRBPXkKIyBDT05GSUdfREVCVUdfUk9EQVRBX1RFU1QgaXMgbm90 IHNldAojIENPTkZJR19ERUJVR19TRVRfTU9EVUxFX1JPTlggaXMgbm90IHNldAojIENPTkZJR19E RUJVR19OWF9URVNUIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9NTVVfREVCVUcgaXMgbm90IHNldAoj IENPTkZJR19JT01NVV9TVFJFU1MgaXMgbm90IHNldApDT05GSUdfSEFWRV9NTUlPVFJBQ0VfU1VQ UE9SVD15CiMgQ09ORklHX1g4Nl9ERUNPREVSX1NFTEZURVNUIGlzIG5vdCBzZXQKQ09ORklHX0lP X0RFTEFZX1RZUEVfMFg4MD0wCkNPTkZJR19JT19ERUxBWV9UWVBFXzBYRUQ9MQpDT05GSUdfSU9f REVMQVlfVFlQRV9VREVMQVk9MgpDT05GSUdfSU9fREVMQVlfVFlQRV9OT05FPTMKQ09ORklHX0lP X0RFTEFZXzBYODA9eQojIENPTkZJR19JT19ERUxBWV8wWEVEIGlzIG5vdCBzZXQKIyBDT05GSUdf SU9fREVMQVlfVURFTEFZIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9fREVMQVlfTk9ORSBpcyBub3Qg c2V0CkNPTkZJR19ERUZBVUxUX0lPX0RFTEFZX1RZUEU9MAojIENPTkZJR19ERUJVR19CT09UX1BB UkFNUyBpcyBub3Qgc2V0CiMgQ09ORklHX0NQQV9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19PUFRJ TUlaRV9JTkxJTklORz15CiMgQ09ORklHX0RFQlVHX1NUUklDVF9VU0VSX0NPUFlfQ0hFQ0tTIGlz IG5vdCBzZXQKIyBDT05GSUdfREVCVUdfTk1JX1NFTEZURVNUIGlzIG5vdCBzZXQKCiMKIyBTZWN1 cml0eSBvcHRpb25zCiMKQ09ORklHX0tFWVM9eQpDT05GSUdfVFJVU1RFRF9LRVlTPW0KQ09ORklH X0VOQ1JZUFRFRF9LRVlTPW0KIyBDT05GSUdfS0VZU19ERUJVR19QUk9DX0tFWVMgaXMgbm90IHNl dAojIENPTkZJR19TRUNVUklUWV9ETUVTR19SRVNUUklDVCBpcyBub3Qgc2V0CiMgQ09ORklHX1NF Q1VSSVRZIGlzIG5vdCBzZXQKQ09ORklHX1NFQ1VSSVRZRlM9eQpDT05GSUdfSU5URUxfVFhUPXkK Q09ORklHX0RFRkFVTFRfU0VDVVJJVFlfREFDPXkKQ09ORklHX0RFRkFVTFRfU0VDVVJJVFk9IiIK Q09ORklHX1hPUl9CTE9DS1M9bQpDT05GSUdfQVNZTkNfQ09SRT1tCkNPTkZJR19BU1lOQ19NRU1D UFk9bQpDT05GSUdfQVNZTkNfWE9SPW0KQ09ORklHX0FTWU5DX1BRPW0KQ09ORklHX0FTWU5DX1JB SUQ2X1JFQ09WPW0KQ09ORklHX0FTWU5DX1RYX0RJU0FCTEVfUFFfVkFMX0RNQT15CkNPTkZJR19B U1lOQ19UWF9ESVNBQkxFX1hPUl9WQUxfRE1BPXkKQ09ORklHX0NSWVBUTz15CgojCiMgQ3J5cHRv IGNvcmUgb3IgaGVscGVyCiMKQ09ORklHX0NSWVBUT19BTEdBUEk9eQpDT05GSUdfQ1JZUFRPX0FM R0FQSTI9eQpDT05GSUdfQ1JZUFRPX0FFQUQ9bQpDT05GSUdfQ1JZUFRPX0FFQUQyPXkKQ09ORklH X0NSWVBUT19CTEtDSVBIRVI9bQpDT05GSUdfQ1JZUFRPX0JMS0NJUEhFUjI9eQpDT05GSUdfQ1JZ UFRPX0hBU0g9eQpDT05GSUdfQ1JZUFRPX0hBU0gyPXkKQ09ORklHX0NSWVBUT19STkc9bQpDT05G SUdfQ1JZUFRPX1JORzI9eQpDT05GSUdfQ1JZUFRPX1BDT01QPW0KQ09ORklHX0NSWVBUT19QQ09N UDI9eQpDT05GSUdfQ1JZUFRPX01BTkFHRVI9eQpDT05GSUdfQ1JZUFRPX01BTkFHRVIyPXkKQ09O RklHX0NSWVBUT19VU0VSPW0KQ09ORklHX0NSWVBUT19NQU5BR0VSX0RJU0FCTEVfVEVTVFM9eQpD T05GSUdfQ1JZUFRPX0dGMTI4TVVMPW0KQ09ORklHX0NSWVBUT19OVUxMPW0KQ09ORklHX0NSWVBU T19QQ1JZUFQ9bQpDT05GSUdfQ1JZUFRPX1dPUktRVUVVRT15CkNPTkZJR19DUllQVE9fQ1JZUFRE PW0KQ09ORklHX0NSWVBUT19BVVRIRU5DPW0KQ09ORklHX0NSWVBUT19URVNUPW0KCiMKIyBBdXRo ZW50aWNhdGVkIEVuY3J5cHRpb24gd2l0aCBBc3NvY2lhdGVkIERhdGEKIwpDT05GSUdfQ1JZUFRP X0NDTT1tCkNPTkZJR19DUllQVE9fR0NNPW0KQ09ORklHX0NSWVBUT19TRVFJVj1tCgojCiMgQmxv Y2sgbW9kZXMKIwpDT05GSUdfQ1JZUFRPX0NCQz1tCkNPTkZJR19DUllQVE9fQ1RSPW0KQ09ORklH X0NSWVBUT19DVFM9bQpDT05GSUdfQ1JZUFRPX0VDQj1tCkNPTkZJR19DUllQVE9fTFJXPW0KQ09O RklHX0NSWVBUT19QQ0JDPW0KQ09ORklHX0NSWVBUT19YVFM9bQoKIwojIEhhc2ggbW9kZXMKIwpD T05GSUdfQ1JZUFRPX0hNQUM9eQpDT05GSUdfQ1JZUFRPX1hDQkM9bQpDT05GSUdfQ1JZUFRPX1ZN QUM9bQoKIwojIERpZ2VzdAojCkNPTkZJR19DUllQVE9fQ1JDMzJDPW0KQ09ORklHX0NSWVBUT19D UkMzMkNfSU5URUw9bQpDT05GSUdfQ1JZUFRPX0dIQVNIPW0KQ09ORklHX0NSWVBUT19NRDQ9bQpD T05GSUdfQ1JZUFRPX01ENT1tCkNPTkZJR19DUllQVE9fTUlDSEFFTF9NSUM9bQpDT05GSUdfQ1JZ UFRPX1JNRDEyOD1tCkNPTkZJR19DUllQVE9fUk1EMTYwPW0KQ09ORklHX0NSWVBUT19STUQyNTY9 bQpDT05GSUdfQ1JZUFRPX1JNRDMyMD1tCkNPTkZJR19DUllQVE9fU0hBMT1tCkNPTkZJR19DUllQ VE9fU0hBMV9TU1NFMz1tCkNPTkZJR19DUllQVE9fU0hBMjU2PW0KQ09ORklHX0NSWVBUT19TSEE1 MTI9bQpDT05GSUdfQ1JZUFRPX1RHUjE5Mj1tCkNPTkZJR19DUllQVE9fV1A1MTI9bQpDT05GSUdf Q1JZUFRPX0dIQVNIX0NMTVVMX05JX0lOVEVMPW0KCiMKIyBDaXBoZXJzCiMKQ09ORklHX0NSWVBU T19BRVM9bQpDT05GSUdfQ1JZUFRPX0FFU19YODZfNjQ9bQpDT05GSUdfQ1JZUFRPX0FFU19OSV9J TlRFTD1tCkNPTkZJR19DUllQVE9fQU5VQklTPW0KQ09ORklHX0NSWVBUT19BUkM0PW0KQ09ORklH X0NSWVBUT19CTE9XRklTSD1tCkNPTkZJR19DUllQVE9fQkxPV0ZJU0hfQ09NTU9OPW0KQ09ORklH X0NSWVBUT19CTE9XRklTSF9YODZfNjQ9bQpDT05GSUdfQ1JZUFRPX0NBTUVMTElBPW0KQ09ORklH X0NSWVBUT19DQU1FTExJQV9YODZfNjQ9bQpDT05GSUdfQ1JZUFRPX0NBU1Q1PW0KQ09ORklHX0NS WVBUT19DQVNUNj1tCkNPTkZJR19DUllQVE9fREVTPW0KQ09ORklHX0NSWVBUT19GQ1JZUFQ9bQpD T05GSUdfQ1JZUFRPX0tIQVpBRD1tCkNPTkZJR19DUllQVE9fU0FMU0EyMD1tCkNPTkZJR19DUllQ VE9fU0FMU0EyMF9YODZfNjQ9bQpDT05GSUdfQ1JZUFRPX1NFRUQ9bQpDT05GSUdfQ1JZUFRPX1NF UlBFTlQ9bQpDT05GSUdfQ1JZUFRPX1NFUlBFTlRfU1NFMl9YODZfNjQ9bQpDT05GSUdfQ1JZUFRP X1RFQT1tCiMgQ09ORklHX0NSWVBUT19UV09GSVNIIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19U V09GSVNIX0NPTU1PTj1tCkNPTkZJR19DUllQVE9fVFdPRklTSF9YODZfNjQ9bQpDT05GSUdfQ1JZ UFRPX1RXT0ZJU0hfWDg2XzY0XzNXQVk9bQoKIwojIENvbXByZXNzaW9uCiMKQ09ORklHX0NSWVBU T19ERUZMQVRFPW0KQ09ORklHX0NSWVBUT19aTElCPW0KQ09ORklHX0NSWVBUT19MWk89bQoKIwoj IFJhbmRvbSBOdW1iZXIgR2VuZXJhdGlvbgojCkNPTkZJR19DUllQVE9fQU5TSV9DUFJORz1tCiMg Q09ORklHX0NSWVBUT19VU0VSX0FQSV9IQVNIIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1VT RVJfQVBJX1NLQ0lQSEVSIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19IVz15CkNPTkZJR19DUllQ VE9fREVWX1BBRExPQ0s9bQpDT05GSUdfQ1JZUFRPX0RFVl9QQURMT0NLX0FFUz1tCkNPTkZJR19D UllQVE9fREVWX1BBRExPQ0tfU0hBPW0KQ09ORklHX0hBVkVfS1ZNPXkKQ09ORklHX1ZJUlRVQUxJ WkFUSU9OPXkKIyBDT05GSUdfS1ZNIGlzIG5vdCBzZXQKIyBDT05GSUdfVkhPU1RfTkVUIGlzIG5v dCBzZXQKQ09ORklHX0JJTkFSWV9QUklOVEY9eQoKIwojIExpYnJhcnkgcm91dGluZXMKIwpDT05G SUdfUkFJRDZfUFE9bQpDT05GSUdfQklUUkVWRVJTRT15CkNPTkZJR19HRU5FUklDX0ZJTkRfRklS U1RfQklUPXkKQ09ORklHX0dFTkVSSUNfUENJX0lPTUFQPXkKQ09ORklHX0dFTkVSSUNfSU9NQVA9 eQpDT05GSUdfR0VORVJJQ19JTz15CkNPTkZJR19DUkNfQ0NJVFQ9bQpDT05GSUdfQ1JDMTY9bQpD T05GSUdfQ1JDX1QxMERJRj15CkNPTkZJR19DUkNfSVRVX1Q9bQpDT05GSUdfQ1JDMzI9eQojIENP TkZJR19DUkMzMl9TRUxGVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19DUkMzMl9TTElDRUJZOD15CiMg Q09ORklHX0NSQzMyX1NMSUNFQlk0IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JDMzJfU0FSV0FURSBp cyBub3Qgc2V0CiMgQ09ORklHX0NSQzMyX0JJVCBpcyBub3Qgc2V0CkNPTkZJR19DUkM3PW0KQ09O RklHX0xJQkNSQzMyQz1tCkNPTkZJR19DUkM4PW0KQ09ORklHX1pMSUJfSU5GTEFURT15CkNPTkZJ R19aTElCX0RFRkxBVEU9bQpDT05GSUdfTFpPX0NPTVBSRVNTPXkKQ09ORklHX0xaT19ERUNPTVBS RVNTPXkKQ09ORklHX1haX0RFQz15CkNPTkZJR19YWl9ERUNfWDg2PXkKQ09ORklHX1haX0RFQ19Q T1dFUlBDPXkKQ09ORklHX1haX0RFQ19JQTY0PXkKQ09ORklHX1haX0RFQ19BUk09eQpDT05GSUdf WFpfREVDX0FSTVRIVU1CPXkKQ09ORklHX1haX0RFQ19TUEFSQz15CkNPTkZJR19YWl9ERUNfQkNK PXkKIyBDT05GSUdfWFpfREVDX1RFU1QgaXMgbm90IHNldApDT05GSUdfREVDT01QUkVTU19HWklQ PXkKQ09ORklHX0RFQ09NUFJFU1NfQlpJUDI9eQpDT05GSUdfREVDT01QUkVTU19MWk1BPXkKQ09O RklHX0RFQ09NUFJFU1NfWFo9eQpDT05GSUdfREVDT01QUkVTU19MWk89eQpDT05GSUdfR0VORVJJ Q19BTExPQ0FUT1I9eQpDT05GSUdfUkVFRF9TT0xPTU9OPW0KQ09ORklHX1JFRURfU09MT01PTl9E RUMxNj15CkNPTkZJR19CQ0g9bQpDT05GSUdfQkNIX0NPTlNUX1BBUkFNUz15CkNPTkZJR19URVhU U0VBUkNIPXkKQ09ORklHX1RFWFRTRUFSQ0hfS01QPW0KQ09ORklHX1RFWFRTRUFSQ0hfQk09bQpD T05GSUdfVEVYVFNFQVJDSF9GU009bQpDT05GSUdfQlRSRUU9eQpDT05GSUdfSEFTX0lPTUVNPXkK Q09ORklHX0hBU19JT1BPUlQ9eQpDT05GSUdfSEFTX0RNQT15CkNPTkZJR19DSEVDS19TSUdOQVRV UkU9eQpDT05GSUdfQ1BVX1JNQVA9eQpDT05GSUdfRFFMPXkKQ09ORklHX05MQVRUUj15CkNPTkZJ R19MUlVfQ0FDSEU9bQpDT05GSUdfQVZFUkFHRT15CkNPTkZJR19DT1JESUM9bQo= --bcaec517a674432cc304ce37f3ed 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 --bcaec517a674432cc304ce37f3ed-- From xen-devel-bounces@lists.xen.org Mon Nov 12 21:32:39 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 12 Nov 2012 21:32:39 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TY1cC-000490-SA; Mon, 12 Nov 2012 21:32:20 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TY1cB-00048L-Bm for xen-devel@lists.xen.org; Mon, 12 Nov 2012 21:32:19 +0000 Received: from [85.158.143.35:25106] by server-2.bemta-4.messagelabs.com id 59/3F-28922-3EA61A05; Mon, 12 Nov 2012 21:32:19 +0000 X-Env-Sender: robert.phillips@citrix.com X-Msg-Ref: server-15.tower-21.messagelabs.com!1352755932!14616307!2 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAxODMwMDc=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 12006 invoked from network); 12 Nov 2012 21:32:15 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-15.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 12 Nov 2012 21:32:15 -0000 X-SBRS: -2.2 X-MesageID: 44332997 X-Ironport-Server: ftlpip01.citrite.net X-Remote-IP: 75.150.106.249 X-Policy: $Relay X-IronPort-AV: E=Sophos;i="4.80,764,1344211200"; d="scan'208";a="44332997" Received: from 75-150-106-249-newengland.hfc.comcastbusiness.net (HELO paine.oldroadcomputing.net) ([75.150.106.249]) by SMTP.CITRIX.COM with ESMTP; 12 Nov 2012 21:32:03 +0000 From: Robert Phillips To: xen-devel@lists.xen.org Date: Mon, 12 Nov 2012 16:31:53 -0500 Message-Id: <1352755913-4229-1-git-send-email-robert.phillips@citrix.com> X-Mailer: git-send-email 1.7.9.5 Cc: Robert Phillips Subject: [Xen-devel] [PATCH] Provide support for multiple frame buffers in Xen 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 Support is provided for both shadow and hardware assisted paging (HAP) modes. This code bookkeeps the set of video frame buffers (vram), detects when the guest has modified any of those buffers and, upon request, returns a bitmap of the modified pages. This lets other software components re-paint the portions of the monitor (or monitors) that have changed. Each monitor has a frame buffer of some size at some position in guest physical memory. The set of frame buffers being tracked can change over time as monitors are plugged and unplugged. (Version 3 of this patch.) Signed-Off-By: Robert Phillips --- tools/libxc/xenctrl.h | 17 +- xen/arch/x86/hvm/Makefile | 2 +- xen/arch/x86/hvm/hvm.c | 16 +- xen/arch/x86/mm/Makefile | 1 + xen/arch/x86/mm/dirty_vram.c | 992 ++++++++++++++++++++++++++++++++++++++ xen/arch/x86/mm/hap/hap.c | 140 +----- xen/arch/x86/mm/paging.c | 196 ++------ xen/arch/x86/mm/shadow/common.c | 335 +++++++------ xen/arch/x86/mm/shadow/multi.c | 174 +++---- xen/arch/x86/mm/shadow/multi.h | 7 +- xen/arch/x86/mm/shadow/types.h | 1 + xen/include/asm-x86/dirty_vram.h | 201 ++++++++ xen/include/asm-x86/hap.h | 4 - xen/include/asm-x86/hvm/domain.h | 2 +- xen/include/asm-x86/paging.h | 17 +- xen/include/asm-x86/shadow.h | 6 - 16 files changed, 1549 insertions(+), 562 deletions(-) create mode 100644 xen/arch/x86/mm/dirty_vram.c create mode 100644 xen/include/asm-x86/dirty_vram.h diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h index 7eb5743..693d7fe 100644 --- a/tools/libxc/xenctrl.h +++ b/tools/libxc/xenctrl.h @@ -1552,15 +1552,20 @@ int xc_hvm_inject_msi( xc_interface *xch, domid_t dom, uint64_t addr, uint32_t data); /* - * Track dirty bit changes in the VRAM area + * Track dirty bit changes in a VRAM region defined by + * [ first_pfn : first_pfn + nr - 1 ] * * All of this is done atomically: - * - get the dirty bitmap since the last call - * - set up dirty tracking area for period up to the next call - * - clear the dirty tracking area. + * - gets the dirty bitmap since the last call, all zeroes for + * the first call with some new region + * - sets up a dirty tracking region for period up to the next call + * - clears the specified dirty tracking region. * - * Returns -ENODATA and does not fill bitmap if the area has changed since the - * last call. + * Creating a new region causes any existing regions that it overlaps + * to be discarded. + * + * Specifying nr == 0 causes all regions to be discarded and + * disables dirty bit tracking. */ int xc_hvm_track_dirty_vram( xc_interface *xch, domid_t dom, diff --git a/xen/arch/x86/hvm/Makefile b/xen/arch/x86/hvm/Makefile index eea5555..e374aac 100644 --- a/xen/arch/x86/hvm/Makefile +++ b/xen/arch/x86/hvm/Makefile @@ -22,4 +22,4 @@ obj-y += vlapic.o obj-y += vmsi.o obj-y += vpic.o obj-y += vpt.o -obj-y += vpmu.o \ No newline at end of file +obj-y += vpmu.o diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 34da2f5..3a3e5e4 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -57,6 +57,7 @@ #include #include #include +#include #include #include #include @@ -66,6 +67,7 @@ #include #include #include +#include "../mm/mm-locks.h" bool_t __read_mostly hvm_enabled; @@ -1433,8 +1435,20 @@ int hvm_hap_nested_page_fault(paddr_t gpa, */ if ( access_w ) { + p2m_type_t pt; + pt = p2m_change_type(v->domain, gfn, p2m_ram_logdirty, p2m_ram_rw); + + paging_lock(v->domain); + if ( pt == p2m_ram_logdirty ) + { + dv_range_t *range; + v->domain->arch.paging.log_dirty.dirty_count++; + range = dirty_vram_range_find_gfn(v->domain, gfn); + if ( range ) + range->dirty_count++; + } paging_mark_dirty(v->domain, mfn_x(mfn)); - p2m_change_type(v->domain, gfn, p2m_ram_logdirty, p2m_ram_rw); + paging_unlock(v->domain); } rc = 1; goto out_put_gfn; diff --git a/xen/arch/x86/mm/Makefile b/xen/arch/x86/mm/Makefile index 73dcdf4..becd0c9 100644 --- a/xen/arch/x86/mm/Makefile +++ b/xen/arch/x86/mm/Makefile @@ -5,6 +5,7 @@ obj-y += paging.o obj-y += p2m.o p2m-pt.o p2m-ept.o p2m-pod.o obj-y += guest_walk_2.o obj-y += guest_walk_3.o +obj-y += dirty_vram.o obj-$(x86_64) += guest_walk_4.o obj-$(x86_64) += mem_event.o obj-$(x86_64) += mem_paging.o diff --git a/xen/arch/x86/mm/dirty_vram.c b/xen/arch/x86/mm/dirty_vram.c new file mode 100644 index 0000000..e3c7c1f --- /dev/null +++ b/xen/arch/x86/mm/dirty_vram.c @@ -0,0 +1,992 @@ +/* + * arch/x86/mm/dirty_vram.c: Bookkeep/query dirty VRAM pages + * with support for multiple frame buffers. + * + * Copyright (c) 2012, Citrix Systems, Inc. (Robert Phillips) + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple + * Place - Suite 330, Boston, MA 02111-1307 USA. + */ + + +#include +#include +#include +#include +#include +#include "mm-locks.h" + +#define DEBUG_stop_tracking_all_vram 0 +#define DEBUG_allocating_dirty_vram_range 0 +#define DEBUG_high_water_mark_for_vram_ranges 0 +#define DEBUG_freeing_dirty_vram_range 0 +#define DEBUG_allocate_paddr_links_page 0 +#define DEBUG_update_vram_mapping 0 +#define DEBUG_alloc_paddr_inject_fault 0 + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram; + ASSERT( paging_locked_by_me(d) ); + dirty_vram = d->arch.hvm_domain.dirty_vram = xzalloc(dv_dirty_vram_t); + if ( dirty_vram ) + { + INIT_LIST_HEAD(&dirty_vram->range_head); + INIT_LIST_HEAD(&dirty_vram->ext_head); + } + return dirty_vram; +} + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( !dirty_vram ) + dirty_vram = dirty_vram_alloc(d); + return dirty_vram; +} + + +/* Free domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr, *next; + /* Free all the ranges */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); +#if DEBUG_stop_tracking_all_vram + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] stop tracking all vram\n", + range->begin_pfn, range->end_pfn); +#endif + xfree(range->pl_tab); + xfree(range); + } + /* Free all the extension pages */ + list_for_each_safe(curr, next, &dirty_vram->ext_head) + { + struct dv_paddr_link_ext *ext = + container_of( + curr, struct dv_paddr_link_ext, ext_link); + struct page_info *pg = __virt_to_page(ext); + d->arch.paging.free_page(d, pg); + } + + xfree(dirty_vram); + d->arch.hvm_domain.dirty_vram = NULL; + } +} + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn) +{ + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( gfn >= range->begin_pfn && + gfn < range->end_pfn ) + return range; + } + } + return NULL; +} + +/* + * Returns pointer to dirty vram range matching [begin_pfn .. end_pfn ), + * NULL if none. + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( begin_pfn == range->begin_pfn && + end_pfn == range->end_pfn ) + return range; + } + } + return NULL; +} + +/* Allocate specified dirty_vram range */ +static dv_range_t * +_dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range = NULL; + unsigned long end_pfn = begin_pfn + nr; + dv_pl_entry_t *pl_tab = NULL; + int i; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + +#if DEBUG_allocating_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Allocating dirty vram range hap:%d\n", + begin_pfn, end_pfn, + d->arch.hvm_domain.hap_enabled); +#endif + + range = xzalloc(dv_range_t); + if ( range == NULL ) + goto err_out; + + INIT_LIST_HEAD(&range->range_link); + + range->begin_pfn = begin_pfn; + range->end_pfn = end_pfn; + + if ( !hap_enabled(d) ) + { + if ( (pl_tab = xzalloc_array(dv_pl_entry_t, nr)) == NULL ) + goto err_out; + + for ( i = 0; i != nr; i++ ) + { + pl_tab[i].mapping.sl1ma = INVALID_PADDR; + } + } + + range->pl_tab = pl_tab; + range->mappings_hwm = 1; + + list_add(&range->range_link, &dirty_vram->range_head); + if ( ++dirty_vram->nr_ranges > dirty_vram->ranges_hwm ) + { + dirty_vram->ranges_hwm = dirty_vram->nr_ranges; +#if DEBUG_high_water_mark_for_vram_ranges + gdprintk(XENLOG_DEBUG, + "High water mark for number of vram ranges is now:%d\n", + dirty_vram->ranges_hwm); +#endif + } + return range; + + err_out: + xfree(pl_tab); + xfree(range); + return NULL; +} + + +/* Frees specified dirty_vram range */ +void dirty_vram_range_free(struct domain *d, + dv_range_t *range) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + int i, nr = range->end_pfn - range->begin_pfn; + +#if DEBUG_freeing_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Freeing dirty vram range\n", + range->begin_pfn, range->end_pfn); +#endif + + if ( range->pl_tab ) + { + for ( i = 0; i != nr; i++ ) + { + dv_paddr_link_t *plx; + plx = range->pl_tab[i].mapping.pl_next; + /* Does current FB page have multiple mappings? */ + if ( plx ) /* yes */ + { + /* Find the last element in singly-linked list */ + while ( plx->pl_next != NULL ) + plx = plx->pl_next; + + /* Prepend whole list to the free list */ + plx->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = range->pl_tab[i].mapping.pl_next; + } + } + xfree(range->pl_tab); + range->pl_tab = NULL; + } + + /* Remove range from the linked list, free it, and adjust count*/ + list_del(&range->range_link); + xfree(range); + dirty_vram->nr_ranges--; + } +} + +/* + * dirty_vram_range_alloc() + * This function ensures that the new range does not overlap any existing + * ranges -- deleting them if necessary -- and then calls + * _dirty_vram_range_alloc to actually allocate the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + struct list_head *curr, *next; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + + /* + * Ranges cannot overlap so + * free any range that overlaps [ begin_pfn .. end_pfn ) + */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *rng = list_entry(curr, dv_range_t, range_link); + if ( ( ( rng->begin_pfn <= begin_pfn ) && + ( begin_pfn < rng->end_pfn ) + ) || + ( ( begin_pfn <= rng->begin_pfn ) && + ( rng->begin_pfn < end_pfn ) + ) ) + { + /* Different tracking, tear the previous down. */ + dirty_vram_range_free(d, rng); + } + } + + range = _dirty_vram_range_alloc(d, begin_pfn, nr); + if ( !range ) + goto out; + + out: + return range; +} + +/* + * dirty_vram_range_find_or_alloc() + * Find the range for [begin_pfn:begin_pfn+nr). + * If it doesn't exists, create it. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_range_t *range; + ASSERT( paging_locked_by_me(d) ); + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + range = dirty_vram_range_alloc(d, begin_pfn, nr); + + return range; +} + + + +/* Allocate a dv_paddr_link struct */ +static dv_paddr_link_t * +alloc_paddr_link(struct domain *d) +{ + dv_paddr_link_t * pl = NULL; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + + ASSERT( paging_locked_by_me(d) ); + BUILD_BUG_ON(sizeof(dv_paddr_link_ext_t) > PAGE_SIZE); + /* Is the list of free pl's empty? */ + if ( dirty_vram->pl_free == NULL ) /* yes */ + { + /* + * Allocate another page of pl's. + * Link them all together and point the free list head at them + */ + int i; + struct page_info *pg = d->arch.paging.alloc_page(d); + dv_paddr_link_ext_t *ext = __page_to_virt(pg); + if ( ext == NULL ) + goto out; + +#if DEBUG_allocate_paddr_links_page + gdprintk(XENLOG_DEBUG, "Allocated another page of paddr_links\n"); +#endif + list_add(&ext->ext_link, &dirty_vram->ext_head); + + /* initialize and link together the new pl entries */ + for ( i = 0; i != ARRAY_SIZE(ext->entries); i++ ) + { + ext->entries[i].sl1ma = INVALID_PADDR; + ext->entries[i].pl_next = &ext->entries[i+1]; + } + ext->entries[ARRAY_SIZE(ext->entries) - 1].pl_next = NULL; + dirty_vram->pl_free = &ext->entries[0]; + } + pl = dirty_vram->pl_free; + dirty_vram->pl_free = pl->pl_next; + + pl->sl1ma = INVALID_PADDR; + pl->pl_next = NULL; + out: + return pl; +} + + +/* + * Free a paddr_link struct. + * + * The caller has walked the singly-linked list of elements + * that have, as their head, an element in a pl_tab cell. + * The list walks has reached the element to be freed. + * (Each element is a dv_paddr_link_t struct.) + * + * @pl points to the element to be freed. + * @ppl points to its predecessor element's next member. + * + * After linking the precessor to the element's successor, + * we can free @pl by prepending it to the list of free + * elements. + * + * As a boundary case (which happens to be the common case), + * @pl points to a cell in the pl_tab rather than to some + * extension element danging from that cell. + * We recognize this case because @ppl is NULL. + * In that case we promote the first extension element by + * copying it into the pl_tab cell and free it. + */ + +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_paddr_link_t *npl; /* next pl */ + + ASSERT( paging_locked_by_me(d) ); + /* extension mapping? */ + if ( ppl ) /* yes. free it */ + { + ASSERT(pl == (*ppl)); + (*ppl) = npl = pl->pl_next; + } + else /* main table */ + { + /* + * move 2nd mapping to main table. + * and free 2nd mapping + */ + dv_paddr_link_t * spl; + spl = pl->pl_next; + if ( spl == NULL ) + { + pl->sl1ma = INVALID_PADDR; + return pl; + } + pl->sl1ma = spl->sl1ma; + pl->pl_next = spl->pl_next; + npl = pl; /* reprocess main table entry again */ + pl = spl; + } + pl->sl1ma = INVALID_PADDR; + pl->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = pl; + return npl; +} + + +/* + * dirty_vram_range_update() + * + * This is called whenever a level 1 page table entry is modified. + * If the L1PTE is being cleared, the function removes any paddr_links + * that refer to it. + * If the L1PTE is being set to a frame buffer page, a paddr_link is + * created for that page's entry in pl_tab. + * Returns 1 iff entry found and set or cleared. + */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set) +{ + int effective = 0; + dv_range_t *range; + unsigned long i; + dv_paddr_link_t *pl; + dv_paddr_link_t **ppl; + int len = 0; + + ASSERT(paging_locked_by_me(d)); + range = dirty_vram_range_find_gfn(d, gfn); + if ( !range ) + return effective; + + + i = gfn - range->begin_pfn; + pl = &range->pl_tab[ i ].mapping; + ppl = NULL; + + /* + * find matching entry (pl), if any, and its predecessor + * in linked list (ppl) + */ + while ( pl != NULL ) + { + if ( pl->sl1ma == sl1ma || pl->sl1ma == INVALID_PADDR ) + break; + + ppl = &pl->pl_next; + pl = *ppl; + len++; + } + + if ( set ) + { + /* Did we find sl1ma in either the main table or the linked list? */ + if ( pl == NULL ) /* no, so we'll need to alloc a link */ + { + ASSERT(ppl != NULL); + +#if DEBUG_alloc_paddr_inject_fault + { + static int counter; + + /* Test stuck_dirty logic for some cases */ + if ( (++counter) % 4 == 0 ) + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + gdprintk(XENLOG_DEBUG, + "[%lx] inject stuck dirty fault\n", + gfn ); + goto out; + } + } +#endif + /* + * Have we reached the limit of mappings we're willing + * to bookkeep? + */ + if (len > DV_ADDR_LINK_LIST_LIMIT) /* yes */ + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + + gdprintk(XENLOG_DEBUG, + "[%lx] link limit exceeded\n", + gfn ); + + goto out; + } + + /* alloc link and append it to list */ + (*ppl) = pl = alloc_paddr_link(d); + /* Were we able to allocate a link? */ + if ( pl == NULL ) /* no */ + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + + gdprintk(XENLOG_DEBUG, + "[%lx] alloc failure\n", + gfn ); + + goto out; + } + } + if ( pl->sl1ma != sl1ma ) + { + ASSERT(pl->sl1ma == INVALID_PADDR); + pl->sl1ma = sl1ma; + range->nr_mappings++; + } + effective = 1; + if ( len > range->mappings_hwm ) + { + range->mappings_hwm = len; +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] set sl1ma:%lx hwm:%d mappings:%d freepages:%d\n", + gfn, sl1ma, + range->mappings_hwm, + range->nr_mappings, + d->arch.paging.shadow.free_pages); +#endif + } + } + else /* clear */ + { + if ( pl && pl->sl1ma == sl1ma ) + { +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] clear sl1ma:%lx mappings:%d\n", + gfn, sl1ma, + range->nr_mappings - 1); +#endif + free_paddr_link(d, ppl, pl); + --range->nr_mappings; + effective = 1; + } + } + out: + return effective; +} + + +/* + * shadow_scan_dirty_flags() + * This produces a dirty bitmap for the range by examining every + * L1PTE referenced by some dv_paddr_link in the range's pl_tab table. + * It tests and clears each such L1PTE's dirty flag. + */ +static int shadow_scan_dirty_flags(struct domain *d, + dv_range_t *range, + uint8_t *dirty_bitmap) +{ + int flush_tlb = 0; + unsigned long i; + unsigned long nr = range->end_pfn - range->begin_pfn; + + ASSERT( paging_locked_by_me(d) ); + /* Iterate over VRAM to track dirty bits. */ + for ( i = 0; i < nr; i++ ) + { + int dirty = 0, len = 1; + dv_paddr_link_t *pl; + /* Does the frame buffer have an incomplete set of mappings? */ + if ( unlikely(range->pl_tab[i].stuck_dirty) ) /* yes */ + dirty = 1; + else /* The frame buffer's set of mappings is complete. Scan it. */ + for ( pl = &range->pl_tab[i].mapping; pl; pl = pl->pl_next, len++ ) + { + l1_pgentry_t *sl1e; + paddr_t sl1ma = pl->sl1ma; + if (sl1ma == INVALID_PADDR) /* FB page is unmapped */ + continue; + sl1e = maddr_to_virt(sl1ma); + if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) + { + dirty = 1; + /* Clear dirty so we can detect if page gets re-dirtied. + * Note: this is atomic, so we may clear a + * _PAGE_ACCESSED set by another processor. + */ + l1e_remove_flags(*sl1e, _PAGE_DIRTY); + flush_tlb = 1; + } + } /* for */ + + if ( dirty ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + + } + + return flush_tlb; +} + + +/* + * shadow_track_dirty_vram() + * This is the API called by the guest to determine which pages in the range + * from [begin_pfn:begin_pfn+nr) have been dirtied since the last call. + * It creates the domain's dv_dirty_vram on demand. + * It creates ranges on demand when some [begin_pfn:nr) is first encountered. + * To collect the dirty bitmask it calls shadow_scan_dirty_flags(). + * It copies the dirty bitmask into guest storage. + */ +int shadow_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + int rc = 0; + unsigned long end_pfn = begin_pfn + nr; + int flush_tlb = 0; + dv_range_t *range; + struct p2m_domain *p2m = p2m_get_hostp2m(d); + + /* + * This range test is tricky. + * + * The range [begin_pfn..end_pfn) is an open interval, so end_pfn is a pfn + * beyond the end of the range. + * + * p2m->max_mapped_pfn is a valid PFN so p2m->max_mapped_pfn + 1 is an + * invalid PFN. + * + * If end_pfn is beyond *that* then the range is invalid. + */ + if ( end_pfn < begin_pfn + || begin_pfn > p2m->max_mapped_pfn + || end_pfn > p2m->max_mapped_pfn + 1 ) + return -EINVAL; + + paging_lock(d); + + if (!nr) + { + dirty_vram_free(d); + goto out; + } + + if ( guest_handle_is_null(guest_dirty_bitmap) ) + goto out; + + if ( !dirty_vram_find_or_alloc(d) ) + { + rc = -ENOMEM; + goto out; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + range = dirty_vram_range_alloc(d, begin_pfn, nr); + if ( range ) + sh_find_all_vram_mappings(d->vcpu[0], range); + } + if ( range ) + { + int size = (nr + BITS_PER_LONG - 1) / BITS_PER_LONG; + unsigned long dirty_bitmap[size]; + + memset(dirty_bitmap, 0x00, size * BYTES_PER_LONG); + + flush_tlb |= shadow_scan_dirty_flags(d, range, (uint8_t*)dirty_bitmap); + + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + (uint8_t*)dirty_bitmap, + size * BYTES_PER_LONG) == 0 ) + rc = 0; + } + + if ( flush_tlb ) + flush_tlb_mask(d->domain_dirty_cpumask); + +out: + paging_unlock(d); + return rc; +} + + +/************************************************/ +/* HAP VRAM TRACKING SUPPORT */ +/************************************************/ + +/* + * hap_enable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-only. + */ +static int hap_enable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + /* turn on PG_log_dirty bit in paging mode */ + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + + /* + * dirty_vram != NULL iff we're tracking dirty vram. + * If we start tracking dirty pages for all memory then + * the dirty_vram structure is freed. + */ + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table to be read-only. */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] enable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_rw, p2m_ram_logdirty); + } + + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_disable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-write. + */ +static int hap_disable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table with normal mode */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] disable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_logdirty, p2m_ram_rw); + } + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_clean_vram_tracking_range() + * For all the pages in the range specified by [begin_pfn,nr), + * note in the dirty bitmap any page that has been marked as read-write, + * which signifies that the page has been dirtied, and reset the page + * to ram_logdirty. + */ +void hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) +{ + int i; + unsigned long pfn; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + + ASSERT(p2m_locked_by_me(p2m_get_hostp2m(d))); + ASSERT(paging_locked_by_me(d)); + + if ( !dirty_vram ) + { + gdprintk(XENLOG_DEBUG, + "Should only be called while tracking dirty vram.\n"); + return; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + return; + + /* set l1e entries of P2M table to be read-only. */ + /* + * On first write, it page faults, its entry is changed to read-write, + * its bit in the dirty bitmap is set, and on retry the write succeeds. + */ + for ( i = 0, pfn = range->begin_pfn; pfn < range->end_pfn; i++, pfn++ ) + { + p2m_type_t pt; + pt = p2m_change_type(d, pfn, p2m_ram_rw, p2m_ram_logdirty); + if ( pt == p2m_ram_rw ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + } + flush_tlb_mask(d->domain_dirty_cpumask); +} + +static void hap_vram_tracking_init(struct domain *d) +{ + paging_log_dirty_init(d, hap_enable_vram_tracking, + hap_disable_vram_tracking, + NULL); +} + +/* + * hap_track_dirty_vram() + * Create the domain's dv_dirty_vram struct on demand. + * Create a dirty vram range on demand when some [begin_pfn:begin_pfn+nr] is + * first encountered. + * Collect the guest_dirty bitmask, a bit mask of the dirty vram pages, by + * calling paging_log_dirty_range(). + */ +int hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + long rc = 0; + dv_dirty_vram_t *dirty_vram; + + paging_lock(d); + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( nr ) + { + dv_range_t *range = NULL; + int size = ( nr + BITS_PER_LONG - 1 ) & ~( BITS_PER_LONG - 1 ); + uint8_t dirty_bitmap[size]; + bool_t new_range = 0; + + /* Already tracking dirty vram? */ + if ( paging_mode_log_dirty(d) && dirty_vram ) /* yes */ + { + /* Handle the addition of another range */ + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + rc = -ENOMEM; + if ( !(range = dirty_vram_range_alloc(d, begin_pfn, nr)) ) + goto param_fail; + new_range = 1; + } + } + /* Just starting to track dirty vram? */ + else if ( !paging_mode_log_dirty(d) && !dirty_vram ) /* yes */ + { + rc = -ENOMEM; + if ( !(dirty_vram = dirty_vram_alloc(d)) ) + goto param_fail; + + if ( !(range = dirty_vram_range_find_or_alloc(d, begin_pfn, nr)) ) + goto param_fail; + + new_range = 1; + + /* Initialize callbacks for vram tracking */ + hap_vram_tracking_init(d); + + /* Enable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_enable(d); + paging_lock(d); + + if ( rc != 0 ) + goto param_fail; + } + else + { + /* Test for invalid combination */ + if ( !paging_mode_log_dirty(d) && dirty_vram ) + rc = -EINVAL; + else /* logging dirty of all memory, not tracking dirty vram */ + rc = -ENODATA; + goto param_fail; + } + + paging_unlock(d); + /* Is this query the very first for this range? */ + if ( new_range ) /* yes */ + memset(dirty_bitmap, 0xff, size); /* consider all pages dirty */ + else + { + memset(dirty_bitmap, 0x00, size); + paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); + } + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + dirty_bitmap, + size) == 0 ) + { + rc = 0; + } + } + else + { + /* + * If zero pages specified while already tracking dirty vram + * then stop tracking + */ + if ( paging_mode_log_dirty(d) && dirty_vram ) + { + /* Disable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_disable(d); + paging_lock(d); + + dirty_vram_free(d); + } + else /* benign no-op */ + { + rc = 0; + } + paging_unlock(d); + } + + return rc; + +param_fail: + dirty_vram_free(d); + paging_unlock(d); + return rc; +} + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/arch/x86/mm/hap/hap.c b/xen/arch/x86/mm/hap/hap.c index fd99cde..09cdba2 100644 --- a/xen/arch/x86/mm/hap/hap.c +++ b/xen/arch/x86/mm/hap/hap.c @@ -41,6 +41,7 @@ #include #include #include +#include #include "private.h" @@ -53,139 +54,6 @@ #define page_to_mfn(_pg) _mfn(__page_to_mfn(_pg)) /************************************************/ -/* HAP VRAM TRACKING SUPPORT */ -/************************************************/ - -static int hap_enable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - /* turn on PG_log_dirty bit in paging mode */ - paging_lock(d); - d->arch.paging.mode |= PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static int hap_disable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - paging_lock(d); - d->arch.paging.mode &= ~PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table with normal mode */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_logdirty, p2m_ram_rw); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static void hap_clean_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return; - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); -} - -static void hap_vram_tracking_init(struct domain *d) -{ - paging_log_dirty_init(d, hap_enable_vram_tracking, - hap_disable_vram_tracking, - hap_clean_vram_tracking); -} - -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - long rc = 0; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( nr ) - { - if ( paging_mode_log_dirty(d) && dirty_vram ) - { - if ( begin_pfn != dirty_vram->begin_pfn || - begin_pfn + nr != dirty_vram->end_pfn ) - { - paging_log_dirty_disable(d); - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - } - else if ( !paging_mode_log_dirty(d) && !dirty_vram ) - { - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto param_fail; - - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - d->arch.hvm_domain.dirty_vram = dirty_vram; - hap_vram_tracking_init(d); - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - else - { - if ( !paging_mode_log_dirty(d) && dirty_vram ) - rc = -EINVAL; - else - rc = -ENODATA; - goto param_fail; - } - /* get the bitmap */ - rc = paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); - } - else - { - if ( paging_mode_log_dirty(d) && dirty_vram ) { - rc = paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } else - rc = 0; - } - - return rc; - -param_fail: - if ( dirty_vram ) - { - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } - return rc; -} - -/************************************************/ /* HAP LOG DIRTY SUPPORT */ /************************************************/ @@ -223,14 +91,12 @@ static void hap_clean_dirty_bitmap(struct domain *d) void hap_logdirty_init(struct domain *d) { - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; if ( paging_mode_log_dirty(d) && dirty_vram ) { paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; + dirty_vram_free(d); } - /* Reinitialize logdirty mechanism */ paging_log_dirty_init(d, hap_enable_log_dirty, hap_disable_log_dirty, diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..55bedde 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include @@ -333,8 +334,11 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) mfn_t *l4, *l3, *l2; unsigned long *l1; int i4, i3, i2; + struct p2m_domain *p2m = p2m_get_hostp2m(d); domain_pause(d); + /* Locking hierarchy requires p2m lock to be taken first */ + p2m_lock(p2m); paging_lock(d); clean = (sc->op == XEN_DOMCTL_SHADOW_OP_CLEAN); @@ -345,6 +349,14 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) d->arch.paging.log_dirty.fault_count, d->arch.paging.log_dirty.dirty_count); + if ( hap_enabled(d) && d->arch.hvm_domain.dirty_vram ) + { + /* If we're cleaning/peeking all guest memory, we should not be tracking + * dirty vram. */ + rv = -EINVAL; + goto out; + } + sc->stats.fault_count = d->arch.paging.log_dirty.fault_count; sc->stats.dirty_count = d->arch.paging.log_dirty.dirty_count; @@ -424,170 +436,64 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) if ( clean ) { - /* We need to further call clean_dirty_bitmap() functions of specific - * paging modes (shadow or hap). Safe because the domain is paused. */ - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + /* Is null if tracking dirty vram */ + if ( d->arch.paging.log_dirty.clean_dirty_bitmap ) + { + /* + * We need to call clean_dirty_bitmap() functions of specific + * paging modes (shadow or hap). + * Safe because the domain is paused. + */ + d->arch.paging.log_dirty.clean_dirty_bitmap(d); + } } domain_unpause(d); return rv; out: paging_unlock(d); + p2m_unlock(p2m); domain_unpause(d); return rv; } -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) { - int rv = 0; - unsigned long pages = 0; - mfn_t *l4, *l3, *l2; - unsigned long *l1; - int b1, b2, b3, b4; - int i2, i3, i4; - - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + struct p2m_domain *p2m = p2m_get_hostp2m(d); + dv_range_t *range; + unsigned int range_dirty_count = 0; + + p2m_lock(p2m); paging_lock(d); - PAGING_DEBUG(LOGDIRTY, "log-dirty-range: dom %u faults=%u dirty=%u\n", - d->domain_id, - d->arch.paging.log_dirty.fault_count, - d->arch.paging.log_dirty.dirty_count); - - if ( unlikely(d->arch.paging.log_dirty.failed_allocs) ) { - printk("%s: %d failed page allocs while logging dirty pages\n", - __FUNCTION__, d->arch.paging.log_dirty.failed_allocs); - rv = -ENOMEM; - goto out; - } - - if ( !d->arch.paging.log_dirty.fault_count && - !d->arch.paging.log_dirty.dirty_count ) { - unsigned int size = BITS_TO_LONGS(nr); - - if ( clear_guest(dirty_bitmap, size * BYTES_PER_LONG) != 0 ) - rv = -EFAULT; - goto out; - } - d->arch.paging.log_dirty.fault_count = 0; - d->arch.paging.log_dirty.dirty_count = 0; - - b1 = L1_LOGDIRTY_IDX(begin_pfn); - b2 = L2_LOGDIRTY_IDX(begin_pfn); - b3 = L3_LOGDIRTY_IDX(begin_pfn); - b4 = L4_LOGDIRTY_IDX(begin_pfn); - l4 = paging_map_log_dirty_bitmap(d); - - for ( i4 = b4; - (pages < nr) && (i4 < LOGDIRTY_NODE_ENTRIES); - i4++ ) + /* Only called when tracking dirty vram in HAP mode */ + ASSERT(hap_enabled(d) && d->arch.hvm_domain.dirty_vram); + + range = dirty_vram_range_find_gfn(d, begin_pfn); + if ( range ) { - l3 = (l4 && mfn_valid(l4[i4])) ? map_domain_page(mfn_x(l4[i4])) : NULL; - for ( i3 = b3; - (pages < nr) && (i3 < LOGDIRTY_NODE_ENTRIES); - i3++ ) - { - l2 = ((l3 && mfn_valid(l3[i3])) ? - map_domain_page(mfn_x(l3[i3])) : NULL); - for ( i2 = b2; - (pages < nr) && (i2 < LOGDIRTY_NODE_ENTRIES); - i2++ ) - { - unsigned int bytes = PAGE_SIZE; - uint8_t *s; - l1 = ((l2 && mfn_valid(l2[i2])) ? - map_domain_page(mfn_x(l2[i2])) : NULL); - - s = ((uint8_t*)l1) + (b1 >> 3); - bytes -= b1 >> 3; - - if ( likely(((nr - pages + 7) >> 3) < bytes) ) - bytes = (unsigned int)((nr - pages + 7) >> 3); - - if ( !l1 ) - { - if ( clear_guest_offset(dirty_bitmap, pages >> 3, - bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - /* begin_pfn is not 32K aligned, hence we have to bit - * shift the bitmap */ - else if ( b1 & 0x7 ) - { - int i, j; - uint32_t *l = (uint32_t*) s; - int bits = b1 & 0x7; - int bitmask = (1 << bits) - 1; - int size = (bytes + BYTES_PER_LONG - 1) / BYTES_PER_LONG; - unsigned long bitmap[size]; - static unsigned long printed = 0; - - if ( printed != begin_pfn ) - { - dprintk(XENLOG_DEBUG, "%s: begin_pfn %lx is not 32K aligned!\n", - __FUNCTION__, begin_pfn); - printed = begin_pfn; - } - - for ( i = 0; i < size - 1; i++, l++ ) { - bitmap[i] = ((*l) >> bits) | - (((*((uint8_t*)(l + 1))) & bitmask) << (sizeof(*l) * 8 - bits)); - } - s = (uint8_t*) l; - size = BYTES_PER_LONG - ((b1 >> 3) & 0x3); - bitmap[i] = 0; - for ( j = 0; j < size; j++, s++ ) - bitmap[i] |= (*s) << (j * 8); - bitmap[i] = (bitmap[i] >> bits) | (bitmask << (size * 8 - bits)); - if ( copy_to_guest_offset(dirty_bitmap, (pages >> 3), - (uint8_t*) bitmap, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - else - { - if ( copy_to_guest_offset(dirty_bitmap, pages >> 3, - s, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - - pages += bytes << 3; - if ( l1 ) - { - clear_page(l1); - unmap_domain_page(l1); - } - b1 = b1 & 0x7; - } - b2 = 0; - if ( l2 ) - unmap_domain_page(l2); - } - b3 = 0; - if ( l3 ) - unmap_domain_page(l3); + range_dirty_count = range->dirty_count; + range->dirty_count = 0; } - if ( l4 ) - unmap_domain_page(l4); - - paging_unlock(d); + + if ( !range_dirty_count) + goto out; - return rv; + PAGING_DEBUG(LOGDIRTY, + "log-dirty-range: dom %u [%05lx:%05lx] range_dirty=%u\n", + d->domain_id, + begin_pfn, + range->end_pfn, + range_dirty_count); + hap_clean_vram_tracking_range(d, begin_pfn, nr, dirty_bitmap); out: paging_unlock(d); - return rv; + p2m_unlock(p2m); + return; } /* Note that this function takes three function pointers. Callers must supply diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c index ce79131..56afd16 100644 --- a/xen/arch/x86/mm/shadow/common.c +++ b/xen/arch/x86/mm/shadow/common.c @@ -36,6 +36,7 @@ #include #include #include +#include #include #include "private.h" @@ -3121,12 +3122,7 @@ void shadow_teardown(struct domain *d) * calls now that we've torn down the bitmap */ d->arch.paging.mode &= ~PG_log_dirty; - if (d->arch.hvm_domain.dirty_vram) { - xfree(d->arch.hvm_domain.dirty_vram->sl1ma); - xfree(d->arch.hvm_domain.dirty_vram->dirty_bitmap); - xfree(d->arch.hvm_domain.dirty_vram); - d->arch.hvm_domain.dirty_vram = NULL; - } + dirty_vram_free(d); paging_unlock(d); @@ -3463,179 +3459,212 @@ void shadow_clean_dirty_bitmap(struct domain *d) /**************************************************************************/ -/* VRAM dirty tracking support */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - int rc; - unsigned long end_pfn = begin_pfn + nr; - unsigned long dirty_size = (nr + 7) / 8; - int flush_tlb = 0; - unsigned long i; - p2m_type_t t; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - struct p2m_domain *p2m = p2m_get_hostp2m(d); - - if (end_pfn < begin_pfn - || begin_pfn > p2m->max_mapped_pfn - || end_pfn >= p2m->max_mapped_pfn) - return -EINVAL; - - /* We perform p2m lookups, so lock the p2m upfront to avoid deadlock */ - p2m_lock(p2m_get_hostp2m(d)); - paging_lock(d); +/* Support functions for shadow-based dirty VRAM code */ - if ( dirty_vram && (!nr || - ( begin_pfn != dirty_vram->begin_pfn - || end_pfn != dirty_vram->end_pfn )) ) - { - /* Different tracking, tear the previous down. */ - gdprintk(XENLOG_INFO, "stopping tracking VRAM %lx - %lx\n", dirty_vram->begin_pfn, dirty_vram->end_pfn); - xfree(dirty_vram->sl1ma); - xfree(dirty_vram->dirty_bitmap); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } +#define DEBUG_unshadow_sl1ma 0 +#define DEBUG_unshadow_sl1ma_detail 0 +#define DEBUG_count_initial_mappings 1 - if ( !nr ) +/* smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn) +{ + static unsigned int l1_shadow_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; + struct domain *d = v->domain; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr, *next; + + ASSERT(paging_locked_by_me(d)); + /* Ignore all but level 1 shadows */ + + if ( (l1_shadow_mask & (1 << shadow_type)) == 0 ) { - rc = 0; goto out; } - /* This should happen seldomly (Video mode change), - * no need to be careful. */ + dirty_vram = d->arch.hvm_domain.dirty_vram; if ( !dirty_vram ) { - /* Throw away all the shadows rather than walking through them - * up to nr times getting rid of mappings of each pfn */ - shadow_blow_tables(d); - - gdprintk(XENLOG_INFO, "tracking VRAM %lx - %lx\n", begin_pfn, end_pfn); - - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto out; - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = end_pfn; - d->arch.hvm_domain.dirty_vram = dirty_vram; - - if ( (dirty_vram->sl1ma = xmalloc_array(paddr_t, nr)) == NULL ) - goto out_dirty_vram; - memset(dirty_vram->sl1ma, ~0, sizeof(paddr_t) * nr); - - if ( (dirty_vram->dirty_bitmap = xzalloc_array(uint8_t, dirty_size)) == NULL ) - goto out_sl1ma; - - dirty_vram->last_dirty = NOW(); - - /* Tell the caller that this time we could not track dirty bits. */ - rc = -ENODATA; - } - else if (dirty_vram->last_dirty == -1) - { - /* still completely clean, just copy our empty bitmap */ - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) - rc = 0; + goto out; } - else + + list_for_each_safe(curr, next, &dirty_vram->range_head) { - /* Iterate over VRAM to track dirty bits. */ - for ( i = 0; i < nr; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, begin_pfn + i, &t); - struct page_info *page; - int dirty = 0; - paddr_t sl1ma = dirty_vram->sl1ma[i]; - - if (mfn_x(mfn) == INVALID_MFN) - { - dirty = 1; - } - else + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + unsigned long i; + int max_mappings = 1, mappings = 0; + int unshadowed = 0; + for ( i = 0; i != range->end_pfn - range->begin_pfn; i++ ) + { + dv_paddr_link_t *pl = &range->pl_tab[ i ].mapping; + dv_paddr_link_t **ppl = NULL; + mappings = 0; + + while ( pl != NULL ) { - page = mfn_to_page(mfn); - switch (page->u.inuse.type_info & PGT_count_mask) - { - case 0: - /* No guest reference, nothing to track. */ - break; - case 1: - /* One guest reference. */ - if ( sl1ma == INVALID_PADDR ) - { - /* We don't know which sl1e points to this, too bad. */ - dirty = 1; - /* TODO: Heuristics for finding the single mapping of - * this gmfn */ - flush_tlb |= sh_remove_all_mappings(d->vcpu[0], mfn); - } - else - { - /* Hopefully the most common case: only one mapping, - * whose dirty bit we can use. */ - l1_pgentry_t *sl1e = maddr_to_virt(sl1ma); - - if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) - { - dirty = 1; - /* Note: this is atomic, so we may clear a - * _PAGE_ACCESSED set by another processor. */ - l1e_remove_flags(*sl1e, _PAGE_DIRTY); - flush_tlb = 1; - } - } - break; - default: - /* More than one guest reference, - * we don't afford tracking that. */ - dirty = 1; + paddr_t sl1ma = pl->sl1ma; + unsigned long sl1mn; + + if ( sl1ma == INVALID_PADDR ) break; + + sl1mn = sl1ma >> PAGE_SHIFT; + if ( sl1mn == mfn_x(smfn) ) { +#if DEBUG_unshadow_sl1ma_detail + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%lx] unshadow sl1ma:%lx\n", + mfn_x(smfn), + range->begin_pfn + i, + sl1ma); +#endif + unshadowed++; + pl = free_paddr_link(d, ppl, pl); + --range->nr_mappings; + } + else + { + ppl = &pl->pl_next; + pl = *ppl; + mappings++; } } - - if ( dirty ) + } + if ( mappings > max_mappings ) + max_mappings = mappings; + + if ( unshadowed ) { +#if DEBUG_unshadow_sl1ma + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%05lx:%05lx] unshadowed:%d mappings:0x%x max_mappings:%d\n", + mfn_x(smfn), + range->begin_pfn, range->end_pfn, + unshadowed, range->nr_mappings, max_mappings); +#endif + if ( range->nr_mappings == 0 ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + dirty_vram_range_free(d, range); } } + } + out: + return; +} + + +typedef int (*hash_pfn_callback_t)(struct vcpu *v, + mfn_t smfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); + +static int hash_pfn_foreach(struct vcpu *v, + unsigned int callback_mask, + hash_pfn_callback_t callbacks[], + unsigned long begin_pfn, + unsigned long end_pfn) +/* Walk the hash table looking at the types of the entries and + * calling the appropriate callback function for each entry. + * The mask determines which shadow types we call back for, and the array + * of callbacks tells us which function to call. + * Any callback may return non-zero to let us skip the rest of the scan. + * + * WARNING: Callbacks MUST NOT add or remove hash entries unless they + * then return non-zero to terminate the scan. */ +{ + int i, done = 0, removed = 0; + struct domain *d = v->domain; + struct page_info *x; + + /* Say we're here, to stop hash-lookups reordering the chains */ + ASSERT(paging_locked_by_me(d)); + ASSERT(d->arch.paging.shadow.hash_walking == 0); + d->arch.paging.shadow.hash_walking = 1; - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) { - memset(dirty_vram->dirty_bitmap, 0, dirty_size); - if (dirty_vram->last_dirty + SECONDS(2) < NOW()) + for ( i = 0; i < SHADOW_HASH_BUCKETS; i++ ) + { + /* WARNING: This is not safe against changes to the hash table. + * The callback *must* return non-zero if it has inserted or + * deleted anything from the hash (lookups are OK, though). */ + for ( x = d->arch.paging.shadow.hash_table[i]; x; x = next_shadow(x) ) + { + if ( callback_mask & (1 << x->u.sh.type) ) { - /* was clean for more than two seconds, try to disable guest - * write access */ - for ( i = begin_pfn; i < end_pfn; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, i, &t); - if (mfn_x(mfn) != INVALID_MFN) - flush_tlb |= sh_remove_write_access(d->vcpu[0], mfn, 1, 0); - } - dirty_vram->last_dirty = -1; + ASSERT(x->u.sh.type <= 15); + ASSERT(callbacks[x->u.sh.type] != NULL); + done = callbacks[x->u.sh.type](v, page_to_mfn(x), + begin_pfn, end_pfn, + &removed); + if ( done ) break; } - rc = 0; } + if ( done ) break; } - if ( flush_tlb ) - flush_tlb_mask(d->domain_dirty_cpumask); - goto out; + d->arch.paging.shadow.hash_walking = 0; + return removed; +} -out_sl1ma: - xfree(dirty_vram->sl1ma); -out_dirty_vram: - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range) +{ + /* Dispatch table for getting per-type functions */ + static hash_pfn_callback_t callbacks[SH_type_unused] = { + NULL, /* none */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* l1_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* fl1_32 */ + NULL, /* l2_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* l1_pae */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* fl1_pae */ + NULL, /* l2_pae */ + NULL, /* l2h_pae */ +#if CONFIG_PAGING_LEVELS >= 4 + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* l1_64 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* fl1_64 */ +#else + NULL, /* l1_64 */ + NULL, /* fl1_64 */ +#endif + NULL, /* l2_64 */ + NULL, /* l2h_64 */ + NULL, /* l3_64 */ + NULL, /* l4_64 */ + NULL, /* p2m */ + NULL /* unused */ + }; -out: - paging_unlock(d); - p2m_unlock(p2m_get_hostp2m(d)); - return rc; + static unsigned int callback_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; + + perfc_incr(shadow_mappings); + + hash_pfn_foreach(v, callback_mask, callbacks, + range->begin_pfn, + range->end_pfn); + +#if DEBUG_count_initial_mappings + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] count of initial mappings:%d\n", + range->begin_pfn, range->end_pfn, + range->nr_mappings); +#endif } + /**************************************************************************/ /* Shadow-control XEN_DOMCTL dispatcher */ diff --git a/xen/arch/x86/mm/shadow/multi.c b/xen/arch/x86/mm/shadow/multi.c index b0e6d72..9c00574 100644 --- a/xen/arch/x86/mm/shadow/multi.c +++ b/xen/arch/x86/mm/shadow/multi.c @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -149,6 +150,10 @@ delete_fl1_shadow_status(struct vcpu *v, gfn_t gfn, mfn_t smfn) SHADOW_PRINTK("gfn=%"SH_PRI_gfn", type=%08x, smfn=%05lx\n", gfn_x(gfn), SH_type_fl1_shadow, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); + shadow_hash_delete(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); } @@ -160,6 +165,10 @@ delete_shadow_status(struct vcpu *v, mfn_t gmfn, u32 shadow_type, mfn_t smfn) v->domain->domain_id, v->vcpu_id, mfn_x(gmfn), shadow_type, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, mfn_x(gmfn), shadow_type, smfn); + shadow_hash_delete(v, mfn_x(gmfn), shadow_type, smfn); /* 32-on-64 PV guests don't own their l4 pages; see set_shadow_status */ if ( !is_pv_32on64_vcpu(v) || shadow_type != SH_type_l4_64_shadow ) @@ -516,7 +525,6 @@ _sh_propagate(struct vcpu *v, guest_l1e_t guest_entry = { guest_intpte }; shadow_l1e_t *sp = shadow_entry_ptr; struct domain *d = v->domain; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; gfn_t target_gfn = guest_l1e_get_gfn(guest_entry); u32 pass_thru_flags; u32 gflags, sflags; @@ -663,17 +671,6 @@ _sh_propagate(struct vcpu *v, } } - if ( unlikely((level == 1) && dirty_vram - && dirty_vram->last_dirty == -1 - && gfn_x(target_gfn) >= dirty_vram->begin_pfn - && gfn_x(target_gfn) < dirty_vram->end_pfn) ) - { - if ( ft & FETCH_TYPE_WRITE ) - dirty_vram->last_dirty = NOW(); - else - sflags &= ~_PAGE_RW; - } - /* Read-only memory */ if ( p2m_is_readonly(p2mt) || (p2mt == p2m_mmio_direct && @@ -1072,101 +1069,60 @@ static int shadow_set_l2e(struct vcpu *v, return flags; } -static inline void shadow_vram_get_l1e(shadow_l1e_t new_sl1e, +/* shadow_vram_fix_l1e() + * + * Tests L1PTEs as they are modified, looking for when they start to + * (or cease to) point to frame buffer pages. If the old and new gfns differ, + * calls dirty_vram_range_update() to updates the dirty_vram structures. + */ +static inline void shadow_vram_fix_l1e(shadow_l1e_t old_sl1e, + shadow_l1e_t new_sl1e, shadow_l1e_t *sl1e, mfn_t sl1mfn, struct domain *d) { - mfn_t mfn = shadow_l1e_get_mfn(new_sl1e); - int flags = shadow_l1e_get_flags(new_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + mfn_t new_mfn, old_mfn; + unsigned long new_gfn = INVALID_M2P_ENTRY, old_gfn = INVALID_M2P_ENTRY; + paddr_t sl1ma; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ + if ( !dirty_vram ) return; - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); + sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) | ((unsigned long)sl1e & ~PAGE_MASK); - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + old_mfn = shadow_l1e_get_mfn(old_sl1e); + + if ( !sh_l1e_is_magic(old_sl1e) && + (l1e_get_flags(old_sl1e) & _PAGE_PRESENT) && + mfn_valid(old_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - /* Initial guest reference, record it */ - dirty_vram->sl1ma[i] = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + old_gfn = mfn_to_gfn(d, old_mfn); } -} - -static inline void shadow_vram_put_l1e(shadow_l1e_t old_sl1e, - shadow_l1e_t *sl1e, - mfn_t sl1mfn, - struct domain *d) -{ - mfn_t mfn = shadow_l1e_get_mfn(old_sl1e); - int flags = shadow_l1e_get_flags(old_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ - return; - - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); - - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + + new_mfn = shadow_l1e_get_mfn(new_sl1e); + if ( !sh_l1e_is_magic(new_sl1e) && + (l1e_get_flags(new_sl1e) & _PAGE_PRESENT) && + mfn_valid(new_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - int dirty = 0; - paddr_t sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + new_gfn = mfn_to_gfn(d, new_mfn); + } - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - { - /* Last reference */ - if ( dirty_vram->sl1ma[i] == INVALID_PADDR ) { - /* We didn't know it was that one, let's say it is dirty */ - dirty = 1; - } - else - { - ASSERT(dirty_vram->sl1ma[i] == sl1ma); - dirty_vram->sl1ma[i] = INVALID_PADDR; - if ( flags & _PAGE_DIRTY ) - dirty = 1; - } - } - else + if ( old_gfn == new_gfn ) return; + + if ( VALID_M2P(old_gfn) ) + if ( dirty_vram_range_update(d, old_gfn, sl1ma, 0/*clear*/) ) { - /* We had more than one reference, just consider the page dirty. */ - dirty = 1; - /* Check that it's not the one we recorded. */ - if ( dirty_vram->sl1ma[i] == sl1ma ) - { - /* Too bad, we remembered the wrong one... */ - dirty_vram->sl1ma[i] = INVALID_PADDR; - } - else - { - /* Ok, our recorded sl1e is still pointing to this page, let's - * just hope it will remain. */ - } + SHADOW_PRINTK("gfn %lx (mfn %lx) cleared vram pte\n", + old_gfn, mfn_x(old_mfn)); } - if ( dirty ) + + if ( VALID_M2P(new_gfn) ) + if ( dirty_vram_range_update(d, new_gfn, sl1ma, 1/*set*/) ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + SHADOW_PRINTK("gfn %lx (mfn %lx) set vram pte\n", + new_gfn, mfn_x(new_mfn)); } - } } static int shadow_set_l1e(struct vcpu *v, @@ -1211,12 +1167,13 @@ static int shadow_set_l1e(struct vcpu *v, shadow_l1e_remove_flags(new_sl1e, _PAGE_RW); /* fall through */ case 0: - shadow_vram_get_l1e(new_sl1e, sl1e, sl1mfn, d); break; } } } + shadow_vram_fix_l1e(old_sl1e, new_sl1e, sl1e, sl1mfn, d); + /* Write the new entry */ shadow_write_entries(sl1e, &new_sl1e, 1, sl1mfn); flags |= SHADOW_SET_CHANGED; @@ -1231,7 +1188,6 @@ static int shadow_set_l1e(struct vcpu *v, * trigger a flush later. */ if ( shadow_mode_refcounts(d) ) { - shadow_vram_put_l1e(old_sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(old_sl1e, d); TRACE_SHADOW_PATH_FLAG(TRCE_SFLAG_SHADOW_L1_PUT_REF); } @@ -2018,7 +1974,6 @@ void sh_destroy_l1_shadow(struct vcpu *v, mfn_t smfn) SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, 0, { if ( (shadow_l1e_get_flags(*sl1e) & _PAGE_PRESENT) && !sh_l1e_is_magic(*sl1e) ) { - shadow_vram_put_l1e(*sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(*sl1e, d); } }); @@ -4336,6 +4291,37 @@ int sh_rm_mappings_from_l1(struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn) return done; } + +int sh_find_vram_mappings_in_l1(struct vcpu *v, + mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed) +/* Find all VRAM mappings in this shadow l1 table */ +{ + struct domain *d = v->domain; + shadow_l1e_t *sl1e; + int done = 0; + + /* only returns _PAGE_PRESENT entries */ + SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, done, + { + unsigned long gfn; + mfn_t gmfn = shadow_l1e_get_mfn(*sl1e); + if ( !mfn_valid(gmfn) ) + continue; + gfn = mfn_to_gfn(d, gmfn); + if ( VALID_M2P(gfn) && (begin_pfn <= gfn) && (gfn < end_pfn) ) + { + paddr_t sl1ma = + pfn_to_paddr(mfn_x(sl1mfn)) | + ( (unsigned long)sl1e & ~PAGE_MASK ); + dirty_vram_range_update(v->domain, gfn, sl1ma, 1/*set*/); + } + }); + return 0; +} + /**************************************************************************/ /* Functions to excise all pointers to shadows from higher-level shadows. */ diff --git a/xen/arch/x86/mm/shadow/multi.h b/xen/arch/x86/mm/shadow/multi.h index 835121e..436a4ac 100644 --- a/xen/arch/x86/mm/shadow/multi.h +++ b/xen/arch/x86/mm/shadow/multi.h @@ -66,7 +66,12 @@ SHADOW_INTERNAL_NAME(sh_rm_write_access_from_l1, GUEST_LEVELS) extern int SHADOW_INTERNAL_NAME(sh_rm_mappings_from_l1, GUEST_LEVELS) (struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn); - +extern int +SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, GUEST_LEVELS) + (struct vcpu *v, mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); extern void SHADOW_INTERNAL_NAME(sh_clear_shadow_entry, GUEST_LEVELS) (struct vcpu *v, void *ep, mfn_t smfn); diff --git a/xen/arch/x86/mm/shadow/types.h b/xen/arch/x86/mm/shadow/types.h index 43ce1db..5b0f9f7 100644 --- a/xen/arch/x86/mm/shadow/types.h +++ b/xen/arch/x86/mm/shadow/types.h @@ -229,6 +229,7 @@ static inline shadow_l4e_t shadow_l4e_from_mfn(mfn_t mfn, u32 flags) #define sh_update_cr3 INTERNAL_NAME(sh_update_cr3) #define sh_rm_write_access_from_l1 INTERNAL_NAME(sh_rm_write_access_from_l1) #define sh_rm_mappings_from_l1 INTERNAL_NAME(sh_rm_mappings_from_l1) +#define sh_find_vram_mappings_in_l1 INTERNAL_NAME(sh_find_vram_mappings_in_l1) #define sh_remove_l1_shadow INTERNAL_NAME(sh_remove_l1_shadow) #define sh_remove_l2_shadow INTERNAL_NAME(sh_remove_l2_shadow) #define sh_remove_l3_shadow INTERNAL_NAME(sh_remove_l3_shadow) diff --git a/xen/include/asm-x86/dirty_vram.h b/xen/include/asm-x86/dirty_vram.h new file mode 100644 index 0000000..95637de --- /dev/null +++ b/xen/include/asm-x86/dirty_vram.h @@ -0,0 +1,201 @@ +/****************************************************************************** + * include/asm-x86/dirty_vram.h + * + * Interface for tracking dirty VRAM pages + * + * Copyright (c) 2012 Citrix Systems, Inc. (Robert Phillips) + * Parts of this code are Copyright (c) 2006 by XenSource Inc. + * Parts of this code are Copyright (c) 2006 by Michael A Fetterman + * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _DIRTY_VRAM_H +#define _DIRTY_VRAM_H + +/* + * In shadow mode we need to bookkeep all the L1 page table entries that + * map a frame buffer page. Struct dv_paddr_link does this + * by recording the address of a L1 page table entry for some frame buffer page. + * Also has a link to additional pl entries if the frame buffer page + * has multiple mappings. + * In practice very few pages have multiple mappings. + * But to rule out some pathological situation, we limit the number of + * mappings we're willing to bookkeep. + */ + +#define DV_ADDR_LINK_LIST_LIMIT 20 + +typedef struct dv_paddr_link { + paddr_t sl1ma; + struct dv_paddr_link *pl_next; +} dv_paddr_link_t; + +typedef struct dv_pl_entry { + dv_paddr_link_t mapping; + bool_t stuck_dirty; +} dv_pl_entry_t; + +/* + * This defines an extension page of pl entries for FB pages with multiple + * mappings. All such pages (of a domain) are linked together. + */ +typedef struct dv_paddr_link_ext { + struct list_head ext_link; + dv_paddr_link_t entries[ ( PAGE_SIZE - sizeof( struct list_head ) ) / + sizeof( dv_paddr_link_t ) ]; +} dv_paddr_link_ext_t; + +/* + * This defines a single frame buffer range. It bookkeeps all the level 1 PTEs + * that map guest pages within that range. + * All such ranges (of a domain) are linked together. + */ +typedef struct dv_range { + struct list_head range_link; /* the several ranges form a linked list */ + unsigned long begin_pfn; + unsigned long end_pfn; + dv_pl_entry_t *pl_tab; /* table has 1 pl entry per pfn in range */ + int nr_mappings; /* total number of mappings in this range */ + int mappings_hwm; /* high water mark of max mapping count */ + unsigned int dirty_count; +} dv_range_t; + +/* + * This contains all the data structures required by a domain to + * bookkeep the dirty pages within its frame buffers. + */ +typedef struct dv_dirty_vram { + struct list_head range_head; /* head of the linked list of ranges */ + struct list_head ext_head; /* head of list of extension pages */ + dv_paddr_link_t *pl_free; /* free list of pl's within extension pages */ + int nr_ranges; /* bookkeeps number of ranges */ + int ranges_hwm; /* high water mark of max number of ranges */ +} dv_dirty_vram_t; + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d); + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d); + +/* Frees domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d); + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * NULL if none + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Allocate dirty vram range containing [ begin_pfn .. begin_pfn+nr ), + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * creating a range if none already exists and + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +void dirty_vram_range_free(struct domain *d, + dv_range_t *range); + +/* Bookkeep PTE address of a frame buffer page */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set); + +/* + * smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. + */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn); + + +/* + * Scan all the L1 tables looking for VRAM mappings. + * Record them in the domain's dv_dirty_vram structure + */ +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range); + +/* + * Free a paddr_link struct, given address of its + * predecessor in singly-linked list + */ +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl); + + +/* Enable VRAM dirty tracking. */ +int +shadow_track_dirty_vram(struct domain *d, + unsigned long first_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +int +hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +void +hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); + +#endif /* _DIRTY_VRAM_H */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/include/asm-x86/hap.h b/xen/include/asm-x86/hap.h index 916a35b..3e3a1f5 100644 --- a/xen/include/asm-x86/hap.h +++ b/xen/include/asm-x86/hap.h @@ -57,10 +57,6 @@ void hap_final_teardown(struct domain *d); void hap_teardown(struct domain *d); void hap_vcpu_init(struct vcpu *v); void hap_logdirty_init(struct domain *d); -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); extern const struct paging_mode *hap_paging_get_mode(struct vcpu *); diff --git a/xen/include/asm-x86/hvm/domain.h b/xen/include/asm-x86/hvm/domain.h index 27b3de5..6146542 100644 --- a/xen/include/asm-x86/hvm/domain.h +++ b/xen/include/asm-x86/hvm/domain.h @@ -74,7 +74,7 @@ struct hvm_domain { struct list_head pinned_cacheattr_ranges; /* VRAM dirty support. */ - struct sh_dirty_vram *dirty_vram; + struct dv_dirty_vram * dirty_vram; /* If one of vcpus of this domain is in no_fill_mode or * mtrr/pat between vcpus is not the same, set is_in_uc_mode diff --git a/xen/include/asm-x86/paging.h b/xen/include/asm-x86/paging.h index 9a40f2c..f96ca3b 100644 --- a/xen/include/asm-x86/paging.h +++ b/xen/include/asm-x86/paging.h @@ -137,10 +137,10 @@ struct paging_mode { void paging_free_log_dirty_bitmap(struct domain *d); /* get the dirty bitmap for a specific range of pfns */ -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); /* enable log dirty */ int paging_log_dirty_enable(struct domain *d); @@ -183,15 +183,6 @@ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn); #define L4_LOGDIRTY_IDX(pfn) 0 #endif -/* VRAM dirty tracking support */ -struct sh_dirty_vram { - unsigned long begin_pfn; - unsigned long end_pfn; - paddr_t *sl1ma; - uint8_t *dirty_bitmap; - s_time_t last_dirty; -}; - /***************************************************************************** * Entry points into the paging-assistance code */ diff --git a/xen/include/asm-x86/shadow.h b/xen/include/asm-x86/shadow.h index 2eb6efc..940d7fd 100644 --- a/xen/include/asm-x86/shadow.h +++ b/xen/include/asm-x86/shadow.h @@ -62,12 +62,6 @@ void shadow_vcpu_init(struct vcpu *v); /* Enable an arbitrary shadow mode. Call once at domain creation. */ int shadow_enable(struct domain *d, u32 mode); -/* Enable VRAM dirty bit tracking. */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long first_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); - /* Handler for shadow control ops: operations from user-space to enable * and disable ephemeral shadow modes (test mode and log-dirty mode) and * manipulate the log-dirty bitmap. */ -- 1.7.9.5 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Nov 13 12:06:35 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 13 Nov 2012 12:06:35 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYFG3-0008I1-Fo; Tue, 13 Nov 2012 12:06:23 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYE3b-0004PX-Fw for xen-devel@lists.xen.org; Tue, 13 Nov 2012 10:49:28 +0000 Received: from [85.158.138.51:7043] by server-15.bemta-3.messagelabs.com id 64/AD-09445-6B522A05; Tue, 13 Nov 2012 10:49:26 +0000 X-Env-Sender: Ian.Campbell@citrix.com X-Msg-Ref: server-15.tower-174.messagelabs.com!1352803762!27912505!1 X-Originating-IP: [62.200.22.115] X-SpamReason: No, hits=0.0 required=7.0 tests=Mail larger than max spam size X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 22352 invoked from network); 13 Nov 2012 10:49:23 -0000 Received: from smtp.eu.citrix.com (HELO SMTP.EU.CITRIX.COM) (62.200.22.115) by server-15.tower-174.messagelabs.com with RC4-SHA encrypted SMTP; 13 Nov 2012 10:49:23 -0000 X-IronPort-AV: E=Sophos;i="4.80,765,1344211200"; d="scan'208";a="15773595" Received: from lonpmailmx01.citrite.net ([10.30.203.162]) by LONPIPO01.EU.CITRIX.COM with ESMTP/TLS/RC4-MD5; 13 Nov 2012 10:49:17 +0000 Received: from [10.80.2.42] (10.80.2.42) by LONPMAILMX01.citrite.net (10.30.203.162) with Microsoft SMTP Server id 8.3.279.1; Tue, 13 Nov 2012 10:49:16 +0000 Message-ID: <1352803755.7491.47.camel@zakaz.uk.xensource.com> From: Ian Campbell To: Matthew Fioravante Date: Tue, 13 Nov 2012 10:49:15 +0000 In-Reply-To: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> Organization: Citrix Systems, Inc. X-Mailer: Evolution 3.4.3-1 MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 13 Nov 2012 12:06:22 +0000 Cc: Stefano Stabellini , "xen-devel@lists.xen.org" Subject: Re: [Xen-devel] [PATCH VTPM 6/9] Remove the vtpm process model 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 Thu, 2012-11-01 at 20:35 +0000, Matthew Fioravante wrote: > Remove the old vtpm process model. It doesn't work very > well and is no longer supported. > > Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell > > diff --git a/tools/Makefile b/tools/Makefile > index d8c8cc0..2ca43b9 100644 > --- a/tools/Makefile > +++ b/tools/Makefile > @@ -18,8 +18,6 @@ SUBDIRS-$(CONFIG_XCUTILS) += xcutils > SUBDIRS-$(CONFIG_X86) += firmware > SUBDIRS-y += console > SUBDIRS-y += xenmon > -SUBDIRS-$(VTPM_TOOLS) += vtpm_manager > -SUBDIRS-$(VTPM_TOOLS) += vtpm > SUBDIRS-y += xenstat > SUBDIRS-$(CONFIG_Linux) += $(SUBDIRS-libaio) > SUBDIRS-$(CONFIG_Linux) += memshr > diff --git a/tools/blktap2/drivers/hashtable.c b/tools/blktap2/drivers/hashtable.c > index 631306b..90a6b85 100644 > --- a/tools/blktap2/drivers/hashtable.c > +++ b/tools/blktap2/drivers/hashtable.c > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable.c > - * - tools/vtpm_manager/util/hashtable.c > */ > > #include "hashtable.h" > diff --git a/tools/blktap2/drivers/hashtable.h b/tools/blktap2/drivers/hashtable.h > index 89aa3dc..56ca053 100644 > --- a/tools/blktap2/drivers/hashtable.h > +++ b/tools/blktap2/drivers/hashtable.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable.h > - * - tools/vtpm_manager/util/hashtable.h > */ > > #ifndef __HASHTABLE_CWC22_H__ > diff --git a/tools/blktap2/drivers/hashtable_itr.c b/tools/blktap2/drivers/hashtable_itr.c > index 402e06b..731917c 100644 > --- a/tools/blktap2/drivers/hashtable_itr.c > +++ b/tools/blktap2/drivers/hashtable_itr.c > @@ -1,10 +1,5 @@ > /* Copyright (C) 2002, 2004 Christopher Clark */ > > -/* > - * There are duplicates of this code in: > - * - tools/vtpm_manager/util/hashtable_itr.c > - */ > - > #include "hashtable.h" > #include "hashtable_private.h" > #include "hashtable_itr.h" > diff --git a/tools/blktap2/drivers/hashtable_itr.h b/tools/blktap2/drivers/hashtable_itr.h > index 3d80638..81da838 100644 > --- a/tools/blktap2/drivers/hashtable_itr.h > +++ b/tools/blktap2/drivers/hashtable_itr.h > @@ -1,10 +1,5 @@ > /* Copyright (C) 2002, 2004 Christopher Clark */ > > -/* > - * There are duplicates of this code in: > - * - tools/vtpm_manager/util/hashtable_itr.h > - */ > - > #ifndef __HASHTABLE_ITR_CWC22__ > #define __HASHTABLE_ITR_CWC22__ > #include "hashtable.h" > diff --git a/tools/blktap2/drivers/hashtable_private.h b/tools/blktap2/drivers/hashtable_private.h > index 5a13a65..954ecc3 100644 > --- a/tools/blktap2/drivers/hashtable_private.h > +++ b/tools/blktap2/drivers/hashtable_private.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable_private.h > - * - tools/vtpm_manager/util/hashtable_private.h > */ > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > diff --git a/tools/configure.ac b/tools/configure.ac > index e708f01..586313d 100644 > --- a/tools/configure.ac > +++ b/tools/configure.ac > @@ -40,7 +40,6 @@ m4_include([m4/fetcher.m4]) > # Enable/disable options > AX_ARG_DEFAULT_DISABLE([githttp], [Download GIT repositories via HTTP]) > AX_ARG_DEFAULT_ENABLE([monitors], [Disable xenstat and xentop monitoring tools]) > -AX_ARG_DEFAULT_DISABLE([vtpm], [Enable Virtual Trusted Platform Module]) > AX_ARG_DEFAULT_DISABLE([xenapi], [Enable Xen API Bindings]) > AX_ARG_DEFAULT_ENABLE([ocamltools], [Disable Ocaml tools]) > AX_ARG_DEFAULT_DISABLE([miniterm], [Enable miniterm]) > diff --git a/tools/examples/README b/tools/examples/README > index 5b0314e..2225d5c 100644 > --- a/tools/examples/README > +++ b/tools/examples/README > @@ -25,13 +25,7 @@ vif-bridge - virtual network start/stop script in bridged mode > vif-common.sh - sourced by vif-bridge > vif-nat - xen virtual network start/stop script in NAT mode > vif-route - xen virtual network start/stop script in routed mode > -vtpm - called by xen-backend.agent to bind/unbind vTPM devices > -vtpm-common.sh - common code for vTPM handling > -vtpm-delete - remove an entry from the vTPM table given the > - domain's name > -vtpm-hotplug-common.sh - sourced by vtpm > -vtpm-migration.sh - sourced by external-device-migrate > -xen-backend.agent - calls block, vif-*, vtpm scripts to add, remove, hotplug > +xen-backend.agent - calls block, vif-* scripts to add, remove, hotplug > devices > xen-backend.rules - hotplug script rules > xend-config.sxp - default xend configuration file > diff --git a/tools/examples/xmexample.pv-grub b/tools/examples/xmexample.pv-grub > index 85f847c..e04e6c1 100644 > --- a/tools/examples/xmexample.pv-grub > +++ b/tools/examples/xmexample.pv-grub > @@ -105,20 +105,6 @@ disk = [ 'phy:hda1,hda1,w' ] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = [ 'instance=1,backend=0' ] > - > -#---------------------------------------------------------------------------- > # Configure the behaviour when a domain exits. There are three 'reasons' > # for a domain to stop: poweroff, reboot, and crash. For each of these you > # may specify: > diff --git a/tools/examples/xmexample1 b/tools/examples/xmexample1 > index 330aaf0..c951200 100644 > --- a/tools/examples/xmexample1 > +++ b/tools/examples/xmexample1 > @@ -101,20 +101,6 @@ disk = [ 'phy:hda1,hda1,w' ] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = [ 'instance=1,backend=0' ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/examples/xmexample2 b/tools/examples/xmexample2 > index 4e5eb3d..8c5137e 100644 > --- a/tools/examples/xmexample2 > +++ b/tools/examples/xmexample2 > @@ -137,20 +137,6 @@ disk = [ 'phy:sda%d,sda1,w' % (7+vmid), > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/examples/xmexample3 b/tools/examples/xmexample3 > index dc22ce1..ae799f9 100644 > --- a/tools/examples/xmexample3 > +++ b/tools/examples/xmexample3 > @@ -122,20 +122,6 @@ disk = [ 'phy:hda%d,hda1,w' % (vmid)] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/hotplug/Linux/Makefile b/tools/hotplug/Linux/Makefile > index 0166790..0605559 100644 > --- a/tools/hotplug/Linux/Makefile > +++ b/tools/hotplug/Linux/Makefile > @@ -18,14 +18,12 @@ XEN_SCRIPTS += vif-setup > XEN_SCRIPTS += block > XEN_SCRIPTS += block-enbd block-nbd > XEN_SCRIPTS += blktap > -XEN_SCRIPTS += vtpm vtpm-delete > XEN_SCRIPTS += xen-hotplug-cleanup > XEN_SCRIPTS += external-device-migrate > XEN_SCRIPTS += vscsi > XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh > XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh > -XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh vtpm-hotplug-common.sh > -XEN_SCRIPT_DATA += vtpm-migration.sh vtpm-impl > +XEN_SCRIPT_DATA += block-common.sh > > UDEV_RULES_DIR = $(CONFIG_DIR)/udev > UDEV_RULES = xen-backend.rules xend.rules > diff --git a/tools/hotplug/Linux/vtpm b/tools/hotplug/Linux/vtpm > deleted file mode 100644 > index 38a4532..0000000 > --- a/tools/hotplug/Linux/vtpm > +++ /dev/null > @@ -1,22 +0,0 @@ > -#!/bin/bash > - > -dir=$(dirname "$0") > -. "$dir/vtpm-hotplug-common.sh" > - > -vtpm_fatal_error=0 > - > -case "$command" in > - add) > - vtpm_create_instance > - ;; > - remove) > - vtpm_remove_instance > - ;; > -esac > - > -if [ $vtpm_fatal_error -eq 0 ]; then > - log debug "Successful vTPM operation '$command'." > - success > -else > - fatal "Error while executing vTPM operation '$command'." > -fi > diff --git a/tools/hotplug/Linux/vtpm-common.sh b/tools/hotplug/Linux/vtpm-common.sh > deleted file mode 100644 > index d0d7935..0000000 > --- a/tools/hotplug/Linux/vtpm-common.sh > +++ /dev/null > @@ -1,448 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# Copyright (c) 2005 XenSource Ltd. > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/logging.sh" > -. "$dir/locking.sh" > - > -VTPMDB="/var/vtpm/vtpm.db" > - > -#In the vtpm-impl file some commands should be defined: > -# vtpm_create, vtpm_setup, vtpm_start, etc. (see below) > -if [ -r "$dir/vtpm-impl.alt" ]; then > - . "$dir/vtpm-impl.alt" > -elif [ -r "$dir/vtpm-impl" ]; then > - . "$dir/vtpm-impl" > -else > - function vtpm_create () { > - true > - } > - function vtpm_setup() { > - true > - } > - function vtpm_start() { > - true > - } > - function vtpm_suspend() { > - true > - } > - function vtpm_resume() { > - true > - } > - function vtpm_delete() { > - true > - } > - function vtpm_migrate() { > - echo "Error: vTPM migration accross machines not implemented." > - } > - function vtpm_migrate_local() { > - echo "Error: local vTPM migration not supported" > - } > - function vtpm_migrate_recover() { > - true > - } > -fi > - > - > -#Find the instance number for the vtpm given the name of the domain > -# Parameters > -# - vmname : the name of the vm > -# Return value > -# Returns '0' if instance number could not be found, otherwise > -# it returns the instance number in the variable 'instance' > -function vtpmdb_find_instance () { > - local vmname ret instance > - vmname=$1 > - ret=0 > - > - instance=$(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - '{ \ > - if ( 1 != index($1,"#")) { \ > - if ( $1 == vmname ) { \ > - print $2; \ > - exit; \ > - } \ > - } \ > - }') > - if [ "$instance" != "" ]; then > - ret=$instance > - fi > - echo "$ret" > -} > - > - > -# Check whether a particular instance number is still available > -# returns "0" if it is not available, "1" otherwise. > -function vtpmdb_is_free_instancenum () { > - local instance instances avail i > - instance=$1 > - avail=1 > - #Allowed instance number range: 1-255 > - if [ $instance -eq 0 -o $instance -gt 255 ]; then > - avail=0 > - else > - instances=$(cat $VTPMDB | \ > - awk \ > - '{ \ > - if (1 != index($1,"#")) { \ > - printf("%s ",$2); \ > - } \ > - }') > - for i in $instances; do > - if [ $i -eq $instance ]; then > - avail=0 > - break > - fi > - done > - fi > - echo "$avail" > -} > - > - > -# Get an available instance number given the database > -# Returns an unused instance number > -function vtpmdb_get_free_instancenum () { > - local ctr instances don found > - instances=$(cat $VTPMDB | \ > - awk \ > - '{ \ > - if (1 != index($1,"#")) { \ > - printf("%s ",$2); \ > - } \ > - }') > - ctr=1 > - don=0 > - while [ $don -eq 0 ]; do > - found=0 > - for i in $instances; do > - if [ $i -eq $ctr ]; then > - found=1; > - break; > - fi > - done > - > - if [ $found -eq 0 ]; then > - don=1 > - break > - fi > - let ctr=ctr+1 > - done > - echo "$ctr" > -} > - > - > -# Add a domain name and instance number to the DB file > -function vtpmdb_add_instance () { > - local res vmname inst > - vmname=$1 > - inst=$2 > - > - if [ ! -f $VTPMDB ]; then > - echo "#Database for VM to vTPM association" > $VTPMDB > - echo "#1st column: domain name" >> $VTPMDB > - echo "#2nd column: TPM instance number" >> $VTPMDB > - fi > - res=$(vtpmdb_validate_entry $vmname $inst) > - if [ $res -eq 0 ]; then > - echo "$vmname $inst" >> $VTPMDB > - fi > -} > - > - > -#Validate whether an entry is the same as passed to this > -#function > -function vtpmdb_validate_entry () { > - local res rc vmname inst > - rc=0 > - vmname=$1 > - inst=$2 > - > - res=$(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - -vinst=$inst \ > - '{ \ > - if ( 1 == index($1,"#")) {\ > - } else \ > - if ( $1 == vmname && \ > - $2 == inst) { \ > - printf("1"); \ > - exit; \ > - } else \ > - if ( $1 == vmname || \ > - $2 == inst) { \ > - printf("2"); \ > - exit; \ > - } \ > - }') > - > - if [ "$res" == "1" ]; then > - rc=1 > - elif [ "$res" == "2" ]; then > - rc=2 > - fi > - echo "$rc" > -} > - > - > -#Remove an entry from the vTPM database given its domain name > -#and instance number > -function vtpmdb_remove_entry () { > - local vmname instance VTPMDB_TMP > - vmname=$1 > - instance=$2 > - VTPMDB_TMP="$VTPMDB".tmp > - > - $(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - '{ \ > - if ( $1 != vmname ) { \ > - print $0; \ > - } \ > - '} > $VTPMDB_TMP) > - if [ -e $VTPMDB_TMP ]; then > - mv -f $VTPMDB_TMP $VTPMDB > - vtpm_delete $instance > - else > - log err "Error creating temporary file '$VTPMDB_TMP'." > - fi > -} > - > - > -# Find the reason for the creation of this device: > -# Returns 'resume' or 'create' > -function vtpm_get_create_reason () { > - local resume > - resume=$(xenstore_read $XENBUS_PATH/resume) > - if [ "$resume" == "True" ]; then > - echo "resume" > - else > - echo "create" > - fi > -} > - > - > -#Create a vTPM instance > -# If no entry in the TPM database is found, the instance is > -# created and an entry added to the database. > -function vtpm_create_instance () { > - local res instance domname reason uuid > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > - reason=$(vtpm_get_create_reason) > - > - claim_lock vtpmdb > - > - instance="0" > - > - if [ "$uuid" != "" ]; then > - instance=$(vtpmdb_find_instance $uuid) > - fi > - if [ "$instance" == "0" ]; then > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > - instance=$(vtpmdb_find_instance $domname) > - fi > - > - if [ "$instance" == "0" -a "$reason" != "create" ]; then > - release_lock vtpmdb > - return > - fi > - > - if [ "$instance" == "0" ]; then > - #Try to give the preferred instance to the domain > - instance=$(xenstore_read "$XENBUS_PATH"/pref_instance) > - if [ "$instance" != "" ]; then > - res=$(vtpmdb_is_free_instancenum $instance) > - if [ $res -eq 0 ]; then > - instance=$(vtpmdb_get_free_instancenum) > - fi > - else > - instance=$(vtpmdb_get_free_instancenum) > - fi > - > - vtpm_create $instance > - > - if [ $vtpm_fatal_error -eq 0 ]; then > - if [ "$uuid" != "" ]; then > - vtpmdb_add_instance $uuid $instance > - else > - vtpmdb_add_instance $domname $instance > - fi > - fi > - else > - if [ "$reason" == "resume" ]; then > - vtpm_resume $instance > - else > - vtpm_start $instance > - fi > - fi > - > - release_lock vtpmdb > - > - xenstore_write $XENBUS_PATH/instance $instance > -} > - > - > -#Remove an instance when a VM is terminating or suspending. > -#Since it is assumed that the VM will appear again, the > -#entry is kept in the VTPMDB file. > -function vtpm_remove_instance () { > - local instance reason domname uuid > - #Stop script execution quietly if path does not exist (anymore) > - xenstore-exists "$XENBUS_PATH"/domain > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > - > - claim_lock vtpmdb > - > - instance="0" > - > - if [ "$uuid" != "" ]; then > - instance=$(vtpmdb_find_instance $uuid) > - fi > - > - if [ "$instance" == "0" ]; then > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > - instance=$(vtpmdb_find_instance $domname) > - fi > - > - if [ "$instance" != "0" ]; then > - vtpm_suspend $instance > - fi > - > - release_lock vtpmdb > -} > - > - > -#Remove an entry in the VTPMDB file given the domain's name > -#1st parameter: The name of the domain > -function vtpm_delete_instance () { > - local instance > - > - claim_lock vtpmdb > - > - instance=$(vtpmdb_find_instance $1) > - if [ "$instance" != "0" ]; then > - vtpmdb_remove_entry $1 $instance > - fi > - > - release_lock vtpmdb > -} > - > -# Determine whether the given address is local to this machine > -# Return values: > -# "-1" : the given machine name is invalid > -# "0" : this is not an address of this machine > -# "1" : this is an address local to this machine > -function vtpm_isLocalAddress() { > - local addr res > - addr=$(ping $1 -c 1 | \ > - awk '{ print substr($3,2,length($3)-2); exit }') > - if [ "$addr" == "" ]; then > - echo "-1" > - return > - fi > - res=$(ifconfig | grep "inet addr" | \ > - awk -vaddr=$addr \ > - '{ \ > - if ( addr == substr($2, 6)) {\ > - print "1"; \ > - } \ > - }' \ > - ) > - if [ "$res" == "" ]; then > - echo "0" > - return > - fi > - echo "1" > -} > - > -# Perform a migration step. This function differentiates between migration > -# to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host to migrate to > -# 2nd: name of the domain to migrate > -# 3rd: the migration step to perform > -function vtpm_migration_step() { > - local res=$(vtpm_isLocalAddress $1) > - if [ "$res" == "0" ]; then > - vtpm_migrate $1 $2 $3 > - else > - vtpm_migrate_local > - fi > -} > - > -# Recover from migration due to an error. This function differentiates > -# between migration to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host the migration was going to > -# 2nd: name of the domain that was to be migrated > -# 3rd: the last successful migration step that was done > -function vtpm_recover() { > - local res > - res=$(vtpm_isLocalAddress $1) > - if [ "$res" == "0" ]; then > - vtpm_migrate_recover $1 $2 $3 > - fi > -} > - > - > -#Determine the domain id given a domain's name. > -#1st parameter: name of the domain > -#return value: domain id or -1 if domain id could not be determined > -function vtpm_domid_from_name () { > - local id name ids > - ids=$(xenstore-list /local/domain) > - for id in $ids; do > - name=$(xenstore-read /local/domain/$id/name) > - if [ "$name" == "$1" ]; then > - echo "$id" > - return > - fi > - done > - echo "-1" > -} > - > -#Determine the virtual TPM's instance number using the domain ID. > -#1st parm: domain ID > -function vtpm_uuid_by_domid() { > - echo $(xenstore-read /local/domain/0/backend/vtpm/$1/0/uuid) > -} > - > - > -# Determine the vTPM's UUID by the name of the VM > -function vtpm_uuid_from_vmname() { > - local domid=$(vtpm_domid_from_name $1) > - if [ "$domid" != "-1" ]; then > - echo $(vtpm_uuid_by_domid $domid) > - return > - fi > - echo "" > -} > - > -#Add a virtual TPM instance number and its associated domain name > -#to the VTPMDB file and activate usage of this virtual TPM instance > -#by writing the instance number into the xenstore > -#1st parm: name of virtual machine > -#2nd parm: instance of associated virtual TPM > -function vtpm_add_and_activate() { > - local domid=$(vtpm_domid_from_name $1) > - local vtpm_uuid=$(vtpm_uuid_from_vmname $1) > - if [ "$vtpm_uuid" != "" -a "$domid" != "-1" ]; then > - vtpmdb_add_instance $vtpm_uuid $2 > - xenstore-write backend/vtpm/$domid/0/instance $2 > - fi > -} > diff --git a/tools/hotplug/Linux/vtpm-delete b/tools/hotplug/Linux/vtpm-delete > deleted file mode 100644 > index b75b95b..0000000 > --- a/tools/hotplug/Linux/vtpm-delete > +++ /dev/null > @@ -1,18 +0,0 @@ > -#!/bin/bash > - > -# This scripts must be called the following way: > -# vtpm-delete > -# or > -# vtpm-delete --vmname > - > -dir=$(dirname "$0") > -. "$dir/vtpm-common.sh" > - > -if [ "$1" == "--vmname" ]; then > - vtpm_uuid=$(vtpm_uuid_from_vmname $2) > - if [ "$vtpm_uuid" != "" ];then > - vtpm_delete_instance $vtpm_uuid > - fi > -else > - vtpm_delete_instance $1 > -fi > diff --git a/tools/hotplug/Linux/vtpm-hotplug-common.sh b/tools/hotplug/Linux/vtpm-hotplug-common.sh > deleted file mode 100644 > index 9fd35e7..0000000 > --- a/tools/hotplug/Linux/vtpm-hotplug-common.sh > +++ /dev/null > @@ -1,35 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# Copyright (c) 2005 XenSource Ltd. > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/xen-hotplug-common.sh" > - > -findCommand "$@" > -if [ "$command" != "online" ] && > - [ "$command" != "offline" ] && > - [ "$command" != "add" ] && > - [ "$command" != "remove" ] > -then > - log err "Invalid command: $command" > - exit 1 > -fi > - > - > -XENBUS_PATH="${XENBUS_PATH:?}" > - > -. "$dir/vtpm-common.sh" > diff --git a/tools/hotplug/Linux/vtpm-impl b/tools/hotplug/Linux/vtpm-impl > deleted file mode 100644 > index 4f9a1fd..0000000 > --- a/tools/hotplug/Linux/vtpm-impl > +++ /dev/null > @@ -1,208 +0,0 @@ > -#!/bin/bash > -# =================================================================== > -# > -# 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. > -# =================================================================== > - > -# | SRC | TAG | CMD SIZE | ORD |mtype|strt > -TPM_CMD_OPEN=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x01 > -TPM_CMD_RESM=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x02 > -TPM_CMD_CLOS=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x02 > -TPM_CMD_DELE=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x03 > - > -TPM_TYPE_PVM=\\x01 > -TPM_TYPE_HVM=\\x02 > - > -TPM_SUCCESS=00000000 > - > -TX_VTPM_MANAGER=/var/vtpm/fifos/from_console.fifo > -RX_VTPM_MANAGER=/var/vtpm/fifos/to_console.fifo > - > -VTPM_MIG=/usr/bin/vtpm_migrator > - > -# -------------------- Helpers for binary streams ----------- > - > -function str_to_hex32() { > - printf "%0.8x" $1 > -} > - > -function hex32_to_bin() { > - local inst=$(str_to_hex32 $1); > - > - local n1=`echo $inst | sed 's/\(..\)....../\\\\x\1/'` > - local n2=`echo $inst | sed 's/..\(..\)..../\\\\x\1/'` > - local n3=`echo $inst | sed 's/....\(..\)../\\\\x\1/'` > - local n4=`echo $inst | sed 's/......\(..\)/\\\\x\1/'` > - > - echo "$n1$n2$n3$n4" > -} > - > -function vtpm_manager_cmd() { > - local cmd=$1; > - local inst=$2; > - local inst_bin=$(hex32_to_bin $inst); > - > - claim_lock vtpm_mgr > - > - #send cmd to vtpm_manager > - printf "$cmd$inst_bin" > $TX_VTPM_MANAGER > - > - #recv response > - set +e > - local resp_hex=`dd skip=10 bs=1 count=4 if=$RX_VTPM_MANAGER 2> /dev/null | xxd -ps` > - set -e > - > - release_lock vtpm_mgr > - > - #return whether the command was successful > - if [ $resp_hex -ne $TPM_SUCCESS ]; then > - vtpm_fatal_error=1 > - false > - else > - true > - fi > -} > - > -# Helper to get vm type to pass to vtpm_manager open/resume > -function vtpm_get_type() { > - local inst=$(xenstore_read $XENBUS_PATH/frontend-id) > - local vm=$(xenstore_read /local/domain/$inst/vm) > - if [ "$vm" != "" ]; then > - local ostype=$(xenstore-read $vm/image/ostype) > - if [ "$ostype" == "hvm" ]; then > - echo $TPM_TYPE_HVM; > - else > - echo $TPM_TYPE_PVM; > - fi > - fi > -} > - > -# ------------------ Command handlers ----------------- > - > -# Create new vtpm instance & set it up for use > -function vtpm_create () { > - # Creation is handled implicitly by the manager on first setup > - # so just set it up for use > - $(vtpm_start $1) > -} > - > -# Setup vtpm instance for use. > -function vtpm_start() { > - local vmtype=$(vtpm_get_type); > - $(vtpm_manager_cmd $TPM_CMD_OPEN$vmtype $1) > -} > - > -function vtpm_resume() { > - local vmtype=$(vtpm_get_type); > - $(vtpm_manager_cmd $TPM_CMD_RESM$vmtype $1) > -} > - > -# Reset the vtpm AKA clear PCRs > -function vtpm_reset() { > - #not used by current implemenation > - true > -} > - > -# Shutdown the vtpm while the vm is down > -# This could be a suspend of shutdown > -# we cannot distinquish, so save the state > -# and decide on startup if we should keep is > -function vtpm_suspend() { > - $(vtpm_manager_cmd $TPM_CMD_CLOS $1) > -} > - > - > -function vtpm_delete() { > - local inst=$1 > - if $(vtpm_manager_cmd $TPM_CMD_DELE $inst); then > - rm -f /var/vtpm/vtpm_dm_$1.data > - true > - else > - vtpm_fatal_error=1 > - false > - fi > -} > - > -# Perform a migration step. This function differentiates between migration > -# to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host to migrate to > -# 2nd: name of the domain to migrate > -# 3rd: the migration step to perform > -function vtpm_migrate() { > - local instance res > - > - instance=$(vtpmdb_find_instance $2) > - if [ "$instance" == "" ]; then > - log err "VTPM Migratoin failed. Unable to translation of domain name" > - echo "Error: VTPM Migration failed while looking up instance number" > - fi > - > - case "$3" in > - 0) > - #Incicate migration supported > - echo "0" > - ;; > - > - 1) > - # Get Public Key from Destination > - # Call vtpm_manager's migration part 1 > - claim_lock vtpm_mgr > - $VTPM_MIG $1 $2 $instance $3 > - release_lock vtpm_mgr > - ;; > - > - 2) > - # Call manager's migration step 2 and send result to destination > - # If successful remove from db > - claim_lock vtpm_mgr > - $VTPM_MIG $1 $2 $instance $3 > - release_lock vtpm_mgr > - ;; > - > - 3) > - if `ps x | grep "$VTPM_MIG $1"`; then > - log err "VTPM Migration failed to complete." > - echo "Error: VTPM Migration failed to complete." > - fi > - ;; > - esac > - > -} > - > - > -function vtpm_migrate_recover() { > - echo "Error: Recovery not supported yet" > -} > - > -function vtpm_migrate_local() { > - echo "Error: local vTPM migration not supported" > -} > diff --git a/tools/hotplug/Linux/vtpm-migration.sh b/tools/hotplug/Linux/vtpm-migration.sh > deleted file mode 100644 > index 7e38ae2..0000000 > --- a/tools/hotplug/Linux/vtpm-migration.sh > +++ /dev/null > @@ -1,19 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/vtpm-common.sh" > diff --git a/tools/hotplug/Linux/xen-backend.rules b/tools/hotplug/Linux/xen-backend.rules > index c591a3f..a0d409e 100644 > --- a/tools/hotplug/Linux/xen-backend.rules > +++ b/tools/hotplug/Linux/xen-backend.rules > @@ -1,6 +1,5 @@ > SUBSYSTEM=="xen-backend", KERNEL=="tap*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/blktap $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vbd*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/block $env{ACTION}" > -SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vif2-*", RUN+="/etc/xen/scripts/vif2 $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="online", RUN+="/etc/xen/scripts/vif-setup online type_if=vif" > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="offline", RUN+="/etc/xen/scripts/vif-setup offline type_if=vif" > diff --git a/tools/vtpm/Makefile b/tools/vtpm/Makefile > deleted file mode 100644 > index 7b3efa5..0000000 > --- a/tools/vtpm/Makefile > +++ /dev/null > @@ -1,74 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../.. > - > -# Base definitions and rules > -include $(XEN_ROOT)/tools/vtpm/Rules.mk > - > -# Dir name for emulator (as dom0 tpm driver) > -TPM_EMULATOR_DIR = tpm_emulator > -# Dir name for vtpm instance > -VTPM_DIR = vtpm > -ORIG_DIR = orig > - > -# Emulator tarball name > -TPM_EMULATOR_NAME = tpm_emulator-0.5.1 > -TPM_EMULATOR_TARFILE = $(TPM_EMULATOR_NAME).tar.gz > - > -GMP_HEADER = /usr/include/gmp.h > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: build_sub > - > -.PHONY: install > -install: build > - $(MAKE) -C $(VTPM_DIR) install-recursive > - > -.PHONY: clean > -clean: > - @if [ -d $(TPM_EMULATOR_DIR) ]; \ > - then $(MAKE) -C $(TPM_EMULATOR_DIR) clean; \ > - fi > - @if [ -d $(VTPM_DIR) ]; \ > - then $(MAKE) -C $(VTPM_DIR) clean; \ > - fi > - > -.PHONY: mrproper > -mrproper: > - rm -f $(TPM_EMULATOR_TARFILE) tpm_emulator.patch.old vtpm.patch.old > - rm -rf $(TPM_EMULATOR_DIR) $(VTPM_DIR) $(ORIG_DIR) > - > -# Download Swiss emulator > -$(TPM_EMULATOR_TARFILE): > - wget http://download.berlios.de/tpm-emulator/$(TPM_EMULATOR_TARFILE) > - > -# Create vtpm dirs > -$(VTPM_DIR)/tpmd/tpmd: $(TPM_EMULATOR_TARFILE) vtpm-0.5.1.patch > - rm -rf $(VTPM_DIR) > - tar -xzf $(TPM_EMULATOR_TARFILE) > - mv $(TPM_EMULATOR_NAME) $(VTPM_DIR) > - > - set -e; cd $(VTPM_DIR); \ > - patch -p1 < ../vtpm-0.5.1.patch; \ > - patch -p1 < ../vtpm-0.5.1-LDLIBS.patch > - > -orig: $(TPM_EMULATOR_TARFILE) > - mkdir $(ORIG_DIR); > - set -e; cd $(ORIG_DIR); \ > - tar -xzf ../$(TPM_EMULATOR_TARFILE); > - > -updatepatches: clean orig > - find $(VTPM_DIR) -name "*.orig" -print | xargs rm -f; > - mv vtpm.patch vtpm.patch.old; > - diff -uprN $(TPM_EMULATOR_DIR) $(VTPM_DIR) > vtpm.patch || true; > - > -.PHONY: build_sub > -build_sub: $(VTPM_DIR)/tpmd/tpmd > - set -e; if [ -e $(GMP_HEADER) ]; then \ > - $(MAKE) -C $(VTPM_DIR) version; \ > - $(MAKE) -C $(VTPM_DIR) all-recursive; \ > - else \ > - echo "=== Unable to build VTPMs. libgmp could not be found."; \ > - fi > - > diff --git a/tools/vtpm/README b/tools/vtpm/README > deleted file mode 100644 > index 2008cbd..0000000 > --- a/tools/vtpm/README > +++ /dev/null > @@ -1,45 +0,0 @@ > - > -Directory Structure > -=================== > -tools/vtpm/tpm_emulator-0.2b.tar.gz -> TPM Emulator downloaded at build time that will > - be patched and used for our vtpms > -tools/vtpm/vtpm.patch -> patch applied to tpm_emulator to make vtpm > -tools/vtpm/vtpm/ -> (created on build) tpm_emulator moved to ring 3, > - listens on a pair of fifos for TPM commands, > - persistent state is sent via named fifo to vtpm > - manager, which encrypts it and protects it. > -tools/vtpm/tpm_emulator.patch -> To allow for debugging and testing on non-TPM > - platforms, this patches the emulator to allow > - it to be inserted into the dom0 kernel > -tools/vtpm/tpm_emulator-0.2 -> (created on build) directory containing patched emulator > - > -Compile Flags > -=================== > -VTPM_MULTI_VM -> Defined (not finished): VTPMs run in their own VMs > - Not Defined (default): VTPMs are processes > - > -Requirements > -============ > -- xen-unstable > -- IBM frontend/backend vtpm driver patch > -- vtpm_managerd > -- GNU MP Big number library (GMP) > - > -vtpmd Flow (for vtpm_manager. vtpmd never run by default) > -============================ > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > -- VTPM Manager listens to TPM BE. > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > -- When the manager receives the open message from the BE, it launches a vtpm > -- Xend allows the VM to continue booting. > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > -- The fifo listener begins listening for the reply from vtpm for the request. > -- Vtpm processes request and replies to manager over shared named fifo. > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > - > -tpm_emulator flow > -================== > -Read documentation in tpm_emulator-0.2 directory > diff --git a/tools/vtpm/Rules.mk b/tools/vtpm/Rules.mk > deleted file mode 100644 > index 548cff0..0000000 > --- a/tools/vtpm/Rules.mk > +++ /dev/null > @@ -1,26 +0,0 @@ > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > -include $(XEN_ROOT)/tools/Rules.mk > - > -# > -# Tool definitions > -# > - > -# General compiler flags > -CFLAGS = -Werror -g3 > - > -# Generic project files > -HDRS = $(wildcard *.h) > -SRCS = $(wildcard *.c) > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > - > -# Generic (non-header) dependencies > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm/Rules.mk > - > -$(OBJS): $(SRCS) > - > --include $(DEPS) > - > -BUILD_EMULATOR = y > - > -# Make sure these are just rules > -.PHONY : all build install clean > diff --git a/tools/vtpm/tpm_emulator.patch b/tools/vtpm/tpm_emulator.patch > deleted file mode 100644 > index c34c665..0000000 > --- a/tools/vtpm/tpm_emulator.patch > +++ /dev/null > @@ -1,1919 +0,0 @@ > -diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS > ---- orig/tpm_emulator-0.4/AUTHORS 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/AUTHORS 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,2 +1,3 @@ > - Mario Strasser > - Heiko Stamer [DAA] > -+INTEL Corp <> [Dropped to Ring3] > -diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog > ---- orig/tpm_emulator-0.4/ChangeLog 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/ChangeLog 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,3 +1,6 @@ > -+????-??-?? Intel Corp > -+ * Moved module out of kernel to run as a ring 3 app > -+ > - 2006-06-23 Mario Strasser > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > - persistent data adapted > -diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c > ---- orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/crypto/gmp_kernel_wrapper.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -24,15 +25,10 @@ int __gmp_junk; > - void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename, > - int linenum, const char *expr) > - { > -- panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n", > -+ error("%s:%d: GNU MP assertion failed: %s\n", > - filename, linenum, expr); > - } > - > --void __attribute__ ((regparm(0))) abort(void) > --{ > -- panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n"); > --} > -- > - /* overwrite GNU MP random functions (used by mpz/millerrabin.c) */ > - > - void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate, > -@@ -77,20 +73,19 @@ void __attribute__ ((regparm(0))) mpz_ur > - > - void __attribute__ ((regparm(0))) *kernel_allocate(size_t size) > - { > -- void *ret = (void*)kmalloc(size, GFP_KERNEL); > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME > -- "GMP: cannot allocate memory (size=%u)\n", size); > -+ void *ret = (void*)malloc(size); > -+ if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size); > - return ret; > - } > - > - void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr, > - size_t old_size, size_t new_size) > - { > -- void *ret = (void*)kmalloc(new_size, GFP_KERNEL); > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory " > -- "(old_size=%u new_size=%u)\n", old_size, new_size); > -+ void *ret = (void*)malloc(new_size); > -+ if (!ret) error("GMP: Cannot reallocate memory " > -+ "(old_size=%Zu new_size=%Zu)\n", old_size, new_size); > - memcpy(ret, oldptr, old_size); > -- kfree(oldptr); > -+ free(oldptr); > - return ret; > - } > - > -@@ -99,7 +94,7 @@ void __attribute__ ((regparm(0))) kernel > - /* overwrite used memory */ > - if (blk_ptr != NULL) { > - memset(blk_ptr, 0, blk_size); > -- kfree(blk_ptr); > -+ free(blk_ptr); > - } > - } > - > -diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c > ---- orig/tpm_emulator-0.4/crypto/rsa.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/crypto/rsa.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -381,7 +382,7 @@ static int encode_message(int type, uint > - msg[0] = 0x00; > - get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH); > - sha1_init(&ctx); > -- sha1_update(&ctx, "TCPA", 4); > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > - sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]); > - memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00, > - msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2); > -@@ -429,7 +430,7 @@ static int decode_message(int type, uint > - mask_generation(&msg[1], SHA1_DIGEST_LENGTH, > - &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1); > - sha1_init(&ctx); > -- sha1_update(&ctx, "TCPA", 4); > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > - sha1_final(&ctx, &msg[1]); > - if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH], > - SHA1_DIGEST_LENGTH) != 0) return -1; > -diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c > ---- orig/tpm_emulator-0.4/linux_module.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/linux_module.c 1969-12-31 16:00:00.000000000 -0800 > -@@ -1,195 +0,0 @@ > --/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > -- * Copyright (C) 2004 Mario Strasser , > -- * > -- * This module is free software; you can redistribute it and/or modify > -- * it under the terms of the GNU General Public License as published > -- * by the Free Software Foundation; either version 2 of the License, > -- * or (at your option) any later version. > -- * > -- * This module is distributed in the hope that it will be useful, > -- * but WITHOUT ANY WARRANTY; without even the implied warranty of > -- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > -- * GNU General Public License for more details. > -- * > -- * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $ > -- */ > -- > --#include > --#include > --#include > --#include > --#include > --#include "linux_module.h" > --#include "tpm/tpm_emulator.h" > -- > --MODULE_LICENSE("GPL"); > --MODULE_AUTHOR("Mario Strasser "); > --MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator"); > --MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME); > -- > --/* module startup parameters */ > --char *startup = "save"; > --module_param(startup, charp, 0444); > --MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. " > -- "Possible values are 'clear', 'save' (default) and 'deactivated."); > --char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2"; > --module_param(storage_file, charp, 0644); > --MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage " > -- "file of the TPM."); > -- > --/* TPM lock */ > --static struct semaphore tpm_mutex; > -- > --/* TPM command response */ > --static struct { > -- uint8_t *data; > -- uint32_t size; > --} tpm_response; > -- > --/* module state */ > --#define STATE_IS_OPEN 0 > --static uint32_t module_state; > --static struct timespec old_time; > -- > --static int tpm_open(struct inode *inode, struct file *file) > --{ > -- debug("%s()", __FUNCTION__); > -- if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY; > -- return 0; > --} > -- > --static int tpm_release(struct inode *inode, struct file *file) > --{ > -- debug("%s()", __FUNCTION__); > -- clear_bit(STATE_IS_OPEN, (void*)&module_state); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) { > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return 0; > --} > -- > --static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos) > --{ > -- debug("%s(%d)", __FUNCTION__, count); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) { > -- count = min(count, (size_t)tpm_response.size - (size_t)*ppos); > -- count -= copy_to_user(buf, &tpm_response.data[*ppos], count); > -- *ppos += count; > -- if ((size_t)tpm_response.size == (size_t)*ppos) { > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } > -- } else { > -- count = 0; > -- } > -- up(&tpm_mutex); > -- return count; > --} > -- > --static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos) > --{ > -- debug("%s(%d)", __FUNCTION__, count); > -- down(&tpm_mutex); > -- *ppos = 0; > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > -- if (tpm_handle_command(buf, count, &tpm_response.data, > -- &tpm_response.size) != 0) { > -- count = -EILSEQ; > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return count; > --} > -- > --#define TPMIOC_CANCEL _IO('T', 0x00) > --#define TPMIOC_TRANSMIT _IO('T', 0x01) > -- > --static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) > --{ > -- debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg); > -- if (cmd == TPMIOC_TRANSMIT) { > -- uint32_t count = ntohl(*(uint32_t*)(arg + 2)); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > -- if (tpm_handle_command((char*)arg, count, &tpm_response.data, > -- &tpm_response.size) == 0) { > -- tpm_response.size -= copy_to_user((char*)arg, tpm_response.data, > -- tpm_response.size); > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } else { > -- tpm_response.size = 0; > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return tpm_response.size; > -- } > -- return -1; > --} > -- > --struct file_operations fops = { > -- .owner = THIS_MODULE, > -- .open = tpm_open, > -- .release = tpm_release, > -- .read = tpm_read, > -- .write = tpm_write, > -- .ioctl = tpm_ioctl, > --}; > -- > --static struct miscdevice tpm_dev = { > -- .minor = TPM_DEVICE_MINOR, > -- .name = TPM_DEVICE_NAME, > -- .fops = &fops, > --}; > -- > --int __init init_tpm_module(void) > --{ > -- int res = misc_register(&tpm_dev); > -- if (res != 0) { > -- error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR); > -- return res; > -- } > -- /* initialize variables */ > -- sema_init(&tpm_mutex, 1); > -- module_state = 0; > -- tpm_response.data = NULL; > -- old_time = current_kernel_time(); > -- /* initialize TPM emulator */ > -- if (!strcmp(startup, "clear")) { > -- tpm_emulator_init(1); > -- } else if (!strcmp(startup, "save")) { > -- tpm_emulator_init(2); > -- } else if (!strcmp(startup, "deactivated")) { > -- tpm_emulator_init(3); > -- } else { > -- error("invalid startup mode '%s'; must be 'clear', " > -- "'save' (default) or 'deactivated", startup); > -- misc_deregister(&tpm_dev); > -- return -EINVAL; > -- } > -- return 0; > --} > -- > --void __exit cleanup_tpm_module(void) > --{ > -- tpm_emulator_shutdown(); > -- misc_deregister(&tpm_dev); > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > --} > -- > --module_init(init_tpm_module); > --module_exit(cleanup_tpm_module); > -- > --uint64_t tpm_get_ticks(void) > --{ > -- struct timespec new_time = current_kernel_time(); > -- uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000 > -- + (new_time.tv_nsec - old_time.tv_nsec) / 1000; > -- old_time = new_time; > -- return (ticks > 0) ? ticks : 1; > --} > -- > -diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h > ---- orig/tpm_emulator-0.4/linux_module.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/linux_module.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -17,54 +18,62 @@ > - #ifndef _LINUX_MODULE_H_ > - #define _LINUX_MODULE_H_ > - > --#include > --#include > --#include > -+#include > -+#include > -+#include > -+#include > - #include > --#include > --#include > --#include > --#include > - > --/* module settings */ > -+#include > -+#define __BYTEORDER_HAS_U64__ > -+#ifdef LITTLE_ENDIAN > -+ #include > -+#else > -+ #include > -+#endif > - > -+/* module settings */ > -+#define min(A,B) ((A)<(B)?(A):(B)) > -+#ifndef STR > - #define STR(s) __STR__(s) > - #define __STR__(s) #s > -+#endif > - #include "tpm_version.h" > - > - #define TPM_DEVICE_MINOR 224 > - #define TPM_DEVICE_NAME "tpm" > - #define TPM_MODULE_NAME "tpm_emulator" > - > --/* debug and log output functions */ > -- > - #ifdef DEBUG > --#define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > - #else > - #define debug(fmt, ...) > - #endif > --#define info(fmt, ...) printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > - > - /* memory allocation */ > - > - static inline void *tpm_malloc(size_t size) > - { > -- return kmalloc(size, GFP_KERNEL); > -+ return malloc(size); > - } > - > - static inline void tpm_free(const void *ptr) > - { > -- if (ptr != NULL) kfree(ptr); > -+ if (ptr != NULL) free( (void *) ptr); > - } > - > - /* random numbers */ > - > -+//FIXME; > -+void get_random_bytes(void *buf, int nbytes); > -+ > - static inline void tpm_get_random_bytes(void *buf, int nbytes) > - { > - get_random_bytes(buf, nbytes); > -@@ -84,9 +93,9 @@ uint64_t tpm_get_ticks(void); > - #define CPU_TO_LE16(x) __cpu_to_le16(x) > - > - #define BE64_TO_CPU(x) __be64_to_cpu(x) > --#define LE64_TO_CPU(x) __be64_to_cpu(x) > -+#define LE64_TO_CPU(x) __le64_to_cpu(x) > - #define BE32_TO_CPU(x) __be32_to_cpu(x) > --#define LE32_TO_CPU(x) __be32_to_cpu(x) > -+#define LE32_TO_CPU(x) __le32_to_cpu(x) > - #define BE16_TO_CPU(x) __be16_to_cpu(x) > - #define LE16_TO_CPU(x) __le16_to_cpu(x) > - > -diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile > ---- orig/tpm_emulator-0.4/Makefile 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/Makefile 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,24 +1,40 @@ > - # Software-Based Trusted Platform Module (TPM) Emulator for Linux > - # Copyright (C) 2004 Mario Strasser > -+# Copyright (C) 2006 INTEL Corp. > - # > - # $Id: Makefile 115 2006-06-23 10:36:44Z mast $ > - > --# kernel settings > --KERNEL_RELEASE := $(shell uname -r) > --KERNEL_BUILD := /lib/modules/$(KERNEL_RELEASE)/build > --MOD_SUBDIR := misc > -+COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > - > - # module settings > --MODULE_NAME := tpm_emulator > -+BIN := tpm_emulator > - VERSION_MAJOR := 0 > - VERSION_MINOR := 4 > - VERSION_BUILD := $(shell date +"%s") > - > --# enable/disable DEBUG messages > --EXTRA_CFLAGS += -Wall -DDEBUG -g > -+# Installation program and options > -+INSTALL = install > -+INSTALL_PROG = $(INSTALL) -m0755 > -+INSTALL_DIR = $(INSTALL) -d -m0755 > -+ > -+# Xen tools installation directory > -+TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > -+ > -+CC := gcc > -+CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > -+CFLAGS += -I. -Itpm > -+ > -+# Is the simulator running in it's own vm? > -+#CFLAGS += -DVTPM_MULTI_VM > -+ > -+ifeq ($(COMPILE_ARCH),x86_64) > -+LIBDIR = lib64 > -+else > -+LIBDIR = lib > -+endif > - > - # GNU MP configuration > --GMP_LIB := /usr/lib/libgmp.a > -+GMP_LIB := /usr/$(LIBDIR)/libgmp.a > - GMP_HEADER := /usr/include/gmp.h > - > - # sources and objects > -@@ -27,38 +43,32 @@ DIRS := . crypto tpm > - SRCS := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c)) > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > - SRCS += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h)) > --DISTSRC := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS) > --DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR) > - > --obj-m := $(MODULE_NAME).o > --$(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > -+obj-m := $(BIN) > -+$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > - > - EXTRA_CFLAGS += -I$(src) -I$(src)/crypto -I$(src)/tpm > - > - # do not print "Entering directory ..." > - MAKEFLAGS += --no-print-directory > - > --all: $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules > -+all: $(BIN) > - > --install: > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install > -- test -d /var/tpm || mkdir /var/tpm > -- test -c /dev/tpm || mknod /dev/tpm c 10 224 > -- chmod 666 /dev/tpm > -- depmod -a > -+$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS) > -+ $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN) > -+ > -+%.o: %.c > -+ $(CC) $(CFLAGS) -c $< -o $@ > -+ > -+install: $(BIN) > -+ $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > -+ @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > - > - clean: > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean > -- rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a > -+ rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > - > --dist: $(DISTSRC) > -- rm -rf $(DISTDIR) > -- mkdir $(DISTDIR) > -- cp --parents $(DISTSRC) $(DISTDIR)/ > -- rm -f $(DISTDIR)/crypto/gmp.h > -- tar -chzf $(DISTDIR).tar.gz $(DISTDIR) > -- rm -rf $(DISTDIR) > -+mrproper: clean > -+ rm -f $(BIN) tpm_version.h > - > - $(src)/crypto/libgmp.a: > - test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a > -@@ -88,4 +98,3 @@ version: > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > - > - .PHONY: all install clean dist gmp version > -- > -diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README > ---- orig/tpm_emulator-0.4/README 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/README 2006-07-24 14:35:35.000000000 -0700 > -@@ -13,7 +13,8 @@ $Id: README 113 2006-06-18 12:38:13Z hst > - Copyright > - -------------------------------------------------------------------------- > - Copyright (C) 2004 Mario Strasser and Swiss Federal > --Institute of Technology (ETH) Zurich. > -+ Institute of Technology (ETH) Zurich. > -+Copyright (C) 2005 INTEL Corp > - > - This program is free software; you can redistribute it and/or modify > - it under the terms of the GNU General Public License as published by > -@@ -43,6 +44,12 @@ Example: > - GMP_LIB := /usr/lib/libgmp.a > - GMP_HEADER := /usr/include/gmp.h > - > -+GNU MP Library on 64 bit Systems > -+-------------------------------------------------------------------------- > -+Some 64-bit kernels have problems with importing the user-space gmp > -+library (/usr/lib*/libgmp.a) into kernel space. These kernels will require > -+that the gmp library be recompiled for kernel space with -mcmodel=kernel. > -+ > - Installation > - -------------------------------------------------------------------------- > - The compilation and installation process uses the build environment for > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_capability.c tpm_emulator/tpm/tpm_capability.c > ---- orig/tpm_emulator-0.4/tpm/tpm_capability.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_capability.c 2007-12-28 22:50:19.000000000 +0900 > -@@ -701,7 +701,10 @@ TPM_RESULT TPM_GetCapabilityOwner(TPM_VE > - TPM_RESULT res; > - > - info("TPM_GetCapabilityOwner()"); > -- > -+ > -+ if (!tpmData.permanent.flags.owned) { > -+ return TPM_NOSRK; > -+ } > - /* Verify owner authorization */ > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > - if (res != TPM_SUCCESS) return res; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c tpm_emulator/tpm/tpm_cmd_handler.c > ---- orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_cmd_handler.c 2007-09-12 20:23:00.000000000 +0900 > -@@ -565,7 +565,7 @@ static TPM_RESULT execute_TPM_Seal(TPM_R > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > -+ || (pcrInfoSize >0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > - || len != 0) return TPM_BAD_PARAMETER; > -@@ -798,7 +798,7 @@ static TPM_RESULT execute_TPM_Sealx(TPM_ > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > -+ || (pcrInfoSize > 0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > - || len != 0) return TPM_BAD_PARAMETER; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c > ---- orig/tpm_emulator-0.4/tpm/tpm_credentials.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_credentials.c 2007-09-12 20:23:30.000000000 +0900 > -@@ -47,20 +47,20 @@ int tpm_compute_pubkey_checksum(TPM_NONC > - > - TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey) > - { > -- UINT32 key_length; > -+ size_t key_length; > - if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT; > - /* setup TPM_PUBKEY structure */ > -- key_length = tpmData.permanent.data.endorsementKey.size; > -- pubEndorsementKey->pubKey.keyLength = key_length >> 3; > -+ pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3; > - pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength); > - if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL; > - rsa_export_modulus(&tpmData.permanent.data.endorsementKey, > -- pubEndorsementKey->pubKey.key, > -- &pubEndorsementKey->pubKey.keyLength); > -+ pubEndorsementKey->pubKey.key, > -+ &key_length); > -+ pubEndorsementKey->pubKey.keyLength = key_length; > - pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA; > - pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE; > -- pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length; > -+ pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length << 3; > - pubEndorsementKey->algorithmParms.parms.rsa.numPrimes = 2; > - pubEndorsementKey->algorithmParms.parms.rsa.exponentSize = 0; > - pubEndorsementKey->algorithmParms.parms.rsa.exponent = NULL; > -@@ -175,6 +175,7 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > - { > - TPM_RESULT res; > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > -+ size_t key_length; > - info("TPM_OwnerReadInternalPub()"); > - /* verify authorization */ > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > -@@ -186,7 +187,8 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > - publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength); > - if (publicPortion->pubKey.key == NULL) return TPM_FAIL; > - rsa_export_modulus(&srk->key, publicPortion->pubKey.key, > -- &publicPortion->pubKey.keyLength); > -+ &key_length); > -+ publicPortion->pubKey.keyLength = key_length; > - publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA; > - publicPortion->algorithmParms.encScheme = srk->encScheme; > - publicPortion->algorithmParms.sigScheme = srk->sigScheme; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c > ---- orig/tpm_emulator-0.4/tpm/tpm_crypto.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_crypto.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -182,7 +182,8 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > - TPM_KEY_DATA *cert, *key; > - sha1_ctx_t sha1_ctx; > - BYTE *buf, *p; > -- UINT32 length; > -+ UINT32 length32; > -+ size_t length; > - info("TPM_CertifyKey()"); > - /* get keys */ > - cert = tpm_get_key(certHandle); > -@@ -264,14 +265,15 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - p = buf = tpm_malloc(length); > -+ length32=(UINT32) length; > - if (buf == NULL > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > - return TPM_FAIL; > - } > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - sha1_init(&sha1_ctx); > -- sha1_update(&sha1_ctx, buf, length); > -+ sha1_update(&sha1_ctx, buf, (size_t) length); > - sha1_final(&sha1_ctx, buf); > - res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize); > - tpm_free(buf); > -@@ -292,7 +294,8 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > - TPM_KEY_DATA *cert, *key; > - sha1_ctx_t sha1_ctx; > - BYTE *buf, *p; > -- UINT32 length; > -+ size_t length; > -+ UINT32 length32; > - info("TPM_CertifyKey2()"); > - /* get keys */ > - cert = tpm_get_key(certHandle); > -@@ -362,8 +365,9 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - p = buf = tpm_malloc(length); > -+ length32 = (UINT32) length; > - if (buf == NULL > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > - return TPM_FAIL; > - } > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c > ---- orig/tpm_emulator-0.4/tpm/tpm_daa.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_daa.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -716,14 +716,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -805,14 +805,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1489,14 +1489,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1712,14 +1712,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1793,14 +1793,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -2918,14 +2918,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -3143,7 +3143,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > - sizeof(session->DAA_session.DAA_digest)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_update(&sha1, inputData1, inputSize1); > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > - } > -@@ -3172,7 +3172,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > - sizeof(session->DAA_session.DAA_digest)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE*) "\x00", 1); > - rsa_export_modulus(&aikData->key, scratch, &size); > - sha1_update(&sha1, scratch, size); > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > -@@ -3229,14 +3229,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -3309,14 +3309,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c > ---- orig/tpm_emulator-0.4/tpm/tpm_data.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_data.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -40,6 +40,7 @@ static inline void init_pcr_attr(int pcr > - void tpm_init_data(void) > - { > - /* endorsement key */ > -+#ifndef TPM_GENERATE_EK > - uint8_t ek_n[] = "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7" > - "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93" > - "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a" > -@@ -77,6 +78,8 @@ void tpm_init_data(void) > - "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b" > - "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47" > - "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f"; > -+#endif > -+ > - int i; > - /* reset all data to NULL, FALSE or 0 */ > - memset(&tpmData, 0, sizeof(tpmData)); > -@@ -152,44 +155,43 @@ void tpm_release_data(void) > - > - #ifdef TPM_STORE_TO_FILE > - > --#include > --#include > --#include > -+#include > -+#include > -+#include > -+#include > - > - #define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > - > - static int write_to_file(uint8_t *data, size_t data_length) > - { > - int res; > -- struct file *fp; > -- mm_segment_t old_fs = get_fs(); > -- fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- if (IS_ERR(fp)) return -1; > -- set_fs(get_ds()); > -- res = fp->f_op->write(fp, data, data_length, &fp->f_pos); > -- set_fs(old_fs); > -- filp_close(fp, NULL); > -+ int fp; > -+ fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -+ res = write(fp, data, data_length); > -+ close(fp); > - return (res == data_length) ? 0 : -1; > - } > - > - static int read_from_file(uint8_t **data, size_t *data_length) > - { > - int res; > -- struct file *fp; > -- mm_segment_t old_fs = get_fs(); > -- fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0); > -- if (IS_ERR(fp)) return -1; > -- *data_length = (size_t)fp->f_dentry->d_inode->i_size; > -- /* *data_length = i_size_read(fp->f_dentry->d_inode); */ > -+ int fp, file_status; > -+ struct stat file_info; > -+ fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > -+ file_status = fstat(fp, &file_info); > -+ if (file_status < 0) { > -+ close(fp); > -+ return -1; > -+ } > -+ > -+ *data_length = file_info.st_size; > - *data = tpm_malloc(*data_length); > - if (*data == NULL) { > -- filp_close(fp, NULL); > -+ close(fp); > - return -1; > - } > -- set_fs(get_ds()); > -- res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos); > -- set_fs(old_fs); > -- filp_close(fp, NULL); > -+ res = read(fp, *data, *data_length); > -+ close(fp); > - if (res != *data_length) { > - tpm_free(*data); > - return -1; > -@@ -216,23 +218,30 @@ static int read_from_file(uint8_t **data > - int tpm_store_permanent_data(void) > - { > - uint8_t *buf, *ptr; > -- size_t buf_length, len; > -+ UINT32 buf_length, len; > - > - /* marshal data */ > -- buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > -- + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2 > -- + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data); > -+ buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > -+ + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) > -+ + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2 > -+ + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data) > -+ + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data) > -+ + sizeof_TPM_STANY_DATA(tpmData.stany.data); > - buf = ptr = tpm_malloc(buf_length); > - if (buf == NULL > - || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version) > - || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > - || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > -+ || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded) > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned) > -- || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > -+ || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > -+ || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > -+ || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > - tpm_free(buf); > - return -1; > - } > -+ > - if (write_to_file(buf, buf_length - len)) { > - tpm_free(buf); > - return -1; > -@@ -244,31 +253,36 @@ int tpm_store_permanent_data(void) > - int tpm_restore_permanent_data(void) > - { > - uint8_t *buf, *ptr; > -- size_t buf_length, len; > -+ size_t buf_length; > -+ UINT32 len; > - TPM_VERSION ver; > - > - /* read data */ > - if (read_from_file(&buf, &buf_length)) return -1; > - ptr = buf; > -- len = buf_length; > -+ len = (uint32_t) buf_length; > - /* unmarshal data */ > - if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver) > - || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION)) > - || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > - || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > -+ || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded) > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned) > -- || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > -+ || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > -+ || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > -+ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > - tpm_free(buf); > - return -1; > - } > -+ > - tpm_free(buf); > - return 0; > - } > - > - int tpm_erase_permanent_data(void) > - { > -- int res = write_to_file("", 0); > -+ int res = write_to_file((uint8_t *) "", 0); > - return res; > - } > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c > ---- orig/tpm_emulator-0.4/tpm/tpm_deprecated.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_deprecated.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -50,7 +51,7 @@ TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA > - BYTE *ptr; > - UINT32 len; > - info("TPM_SaveKeyContext()"); > -- res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..", > -+ res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..", > - keyContextSize, &contextBlob); > - if (res != TPM_SUCCESS) return res; > - len = *keyContextSize; > -@@ -82,7 +83,7 @@ TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH > - BYTE *ptr; > - UINT32 len; > - info("TPM_SaveAuthContext()"); > -- res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.", > -+ res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.", > - authContextSize, &contextBlob); > - if (res != TPM_SUCCESS) return res; > - len = *authContextSize; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h > ---- orig/tpm_emulator-0.4/tpm/tpm_emulator.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_emulator.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -22,7 +23,8 @@ > - /* TPM configuration */ > - #define TPM_STORE_TO_FILE 1 > - #undef TPM_STRONG_PERSISTENCE > --#undef TPM_GENERATE_EK > -+//#undef TPM_GENERATE_EK > -+#define TPM_GENERATE_EK > - #undef TPM_GENERATE_SEED_DAA > - > - #define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */ > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_marshalling.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1312,7 +1312,7 @@ int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * > - > - int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v) > - { > -- UINT32 m_len, e_len, q_len; > -+ size_t m_len, e_len, q_len; > - if (*length < sizeof_RSA((*v))) return -1; > - if (v->size > 0) { > - rsa_export_modulus(v, &(*ptr)[6], &m_len); > -@@ -1460,6 +1460,66 @@ int tpm_unmarshal_TPM_PERMANENT_DATA(BYT > - return 0; > - } > - > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > -+{ > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > -+ || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > -+{ > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > -+ || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > -+{ > -+ UINT32 i; > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > -+ || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) > -+ || tpm_marshal_BOOL(ptr, length, v->auditSession) > -+ || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > -+ || tpm_marshal_UINT32(ptr, length, v->contextCount) > -+ || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > -+ if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > -+ } > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > -+ if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > -+ } > -+ if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > -+{ > -+ UINT32 i; > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > -+ || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) > -+ || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) > -+ || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > -+ || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) > -+ || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > -+ if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > -+ } > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > -+ if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > -+ } > -+ if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; > -+ > -+ return 0; > -+} > -+ > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) > - { > - if (tpm_marshal_BYTE(ptr, length, v->type) > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_marshalling.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -432,6 +432,12 @@ int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt > - int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > - int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > - > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > -+ > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > -+ > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > - int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c > ---- orig/tpm_emulator-0.4/tpm/tpm_owner.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_owner.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -108,7 +108,7 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > - TPM_RESULT res; > - rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey; > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > -- UINT32 buf_size = ek->size >> 3; > -+ size_t buf_size = ek->size >> 3, key_length; > - BYTE buf[buf_size]; > - > - info("TPM_TakeOwnership()"); > -@@ -173,7 +173,8 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > - return TPM_FAIL; > - } > - rsa_export_modulus(&srk->key, srkPub->pubKey.key, > -- &srkPub->pubKey.keyLength); > -+ &key_length); > -+ srkPub->pubKey.keyLength = (UINT32) key_length; > - /* setup tpmProof and set state to owned */ > - tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce, > - sizeof(tpmData.permanent.data.tpmProof.nonce)); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c > ---- orig/tpm_emulator-0.4/tpm/tpm_startup.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_startup.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -41,26 +41,29 @@ void TPM_Init(TPM_STARTUP_TYPE startupTy > - TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType) > - { > - int i; > -+ int restore_fail; > - info("TPM_Startup(%d)", startupType); > - if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT; > -- /* reset STANY_FLAGS */ > -- SET_TO_ZERO(&tpmData.stany.flags); > -- tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > -- /* reset STANY_DATA (invalidates ALL sessions) */ > -- SET_TO_ZERO(&tpmData.stany.data); > -- tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > -- /* init session-context nonce */ > -- SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > -+ > -+ /* try and restore state to get EK, SRK, etc */ > -+ restore_fail = tpm_restore_permanent_data(); > -+ > - /* set data and flags according to the given startup type */ > - if (startupType == TPM_ST_CLEAR) { > -- /* if available, restore permanent data */ > -- tpm_restore_permanent_data(); > -+ /* reset STANY_FLAGS */ > -+ SET_TO_ZERO(&tpmData.stany.flags); > -+ tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > -+ /* reset STANY_DATA (invalidates ALL sessions) */ > -+ SET_TO_ZERO(&tpmData.stany.data); > -+ tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > -+ /* init session-context nonce */ > -+ SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > - /* reset PCR values */ > - for (i = 0; i < TPM_NUM_PCR; i++) { > -- if (tpmData.permanent.data.pcrAttrib[i].pcrReset) > -- SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest); > -+ if (!tpmData.permanent.data.pcrAttrib[i].pcrReset) > -+ SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest); > - else > -- SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest); > -+ SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest); > - } > - /* reset STCLEAR_FLAGS */ > - SET_TO_ZERO(&tpmData.stclear.flags); > -@@ -79,7 +82,8 @@ TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE > - /* init key-context nonce */ > - SET_TO_RAND(&tpmData.stclear.data.contextNonceKey); > - } else if (startupType == TPM_ST_STATE) { > -- if (tpm_restore_permanent_data()) { > -+ /* restore must have been successful for TPM_ST_STATE */ > -+ if (restore_fail) { > - error("restoring permanent data failed"); > - tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed"; > - tpmData.permanent.flags.selfTestSucceeded = FALSE; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c > ---- orig/tpm_emulator-0.4/tpm/tpm_storage.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_storage.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -58,6 +58,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - BYTE *enc, UINT32 *enc_size) > - { > - UINT32 len; > -+ size_t enc_size32 = *enc_size; > - BYTE *buf, *ptr; > - rsa_public_key_t pub_key; > - int scheme; > -@@ -72,7 +73,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - if (buf == NULL > - || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal) > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)), > -- enc, enc_size)) { > -+ enc, &enc_size32)) { > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return -1; > -@@ -85,7 +86,8 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > - TPM_SEALED_DATA *seal, BYTE **buf) > - { > -- UINT32 len; > -+ size_t len; > -+ UINT32 len32; > - BYTE *ptr; > - int scheme; > - switch (key->encScheme) { > -@@ -96,8 +98,12 @@ int decrypt_sealed_data(TPM_KEY_DATA *ke > - len = enc_size; > - *buf = ptr = tpm_malloc(len); > - if (*buf == NULL > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > -- || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) { > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){ > -+ tpm_free(*buf); > -+ return -1; > -+ } > -+ len32 = len; > -+ if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) { > - tpm_free(*buf); > - return -1; > - } > -@@ -240,11 +246,12 @@ TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par > - > - TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize, > - BYTE *inData, TPM_AUTH *auth1, > -- UINT32 *outDataSize, BYTE **outData) > -+ UINT32 *outDataSize32, BYTE **outData) > - { > - TPM_RESULT res; > - TPM_KEY_DATA *key; > - int scheme; > -+ size_t outDataSize; > - > - info("TPM_UnBind()"); > - /* get key */ > -@@ -262,8 +269,8 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > - /* the size of the input data muss be greater than zero */ > - if (inDataSize == 0) return TPM_BAD_PARAMETER; > - /* decrypt data */ > -- *outDataSize = inDataSize; > -- *outData = tpm_malloc(*outDataSize); > -+ outDataSize = inDataSize; > -+ *outData = tpm_malloc(outDataSize); > - if (*outData == NULL) return TPM_NOSPACE; > - switch (key->encScheme) { > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > -@@ -271,20 +278,21 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > - default: tpm_free(*outData); return TPM_DECRYPT_ERROR; > - } > - if (rsa_decrypt(&key->key, scheme, inData, inDataSize, > -- *outData, outDataSize)) { > -+ *outData, &outDataSize)) { > - tpm_free(*outData); > - return TPM_DECRYPT_ERROR; > - } > - /* verify data if it is of type TPM_BOUND_DATA */ > - if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1 > - || key->keyUsage != TPM_KEY_LEGACY) { > -- if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > -+ if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > - tpm_free(*outData); > - return TPM_DECRYPT_ERROR; > - } > -- *outDataSize -= 5; > -- memmove(*outData, &(*outData)[5], *outDataSize); > -+ outDataSize -= 5; > -+ memmove(*outData, &(*outData)[5], outDataSize); > - } > -+ *outDataSize32 = (UINT32) outDataSize; > - return TPM_SUCCESS; > - } > - > -@@ -334,12 +342,13 @@ int compute_pubkey_digest(TPM_PUBKEY *ke > - } > - > - int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store, > -- BYTE *enc, UINT32 *enc_size) > -+ BYTE *enc, UINT32 *enc_size32) > - { > - UINT32 len; > - BYTE *buf, *ptr; > - rsa_public_key_t pub_key; > - int scheme; > -+ size_t enc_size; > - switch (key->encScheme) { > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > - case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break; > -@@ -351,11 +360,12 @@ int encrypt_private_key(TPM_KEY_DATA *ke > - if (buf == NULL > - || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store) > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)), > -- enc, enc_size)) { > -+ enc, &enc_size)) { > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return -1; > - } > -+ *enc_size32 = (UINT32) enc_size; > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return 0; > -@@ -364,7 +374,8 @@ int encrypt_private_key(TPM_KEY_DATA *ke > - int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > - TPM_STORE_ASYMKEY *store, BYTE **buf) > - { > -- UINT32 len; > -+ UINT32 len32; > -+ size_t len; > - BYTE *ptr; > - int scheme; > - switch (key->encScheme) { > -@@ -375,8 +386,12 @@ int decrypt_private_key(TPM_KEY_DATA *ke > - len = enc_size; > - *buf = ptr = tpm_malloc(len); > - if (*buf == NULL > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > -- || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) { > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) { > -+ tpm_free(*buf); > -+ return -1; > -+ } > -+ len32 = (UINT32) len; > -+ if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { > - tpm_free(*buf); > - return -1; > - } > -@@ -394,7 +409,7 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - TPM_SESSION_DATA *session; > - TPM_STORE_ASYMKEY store; > - rsa_private_key_t rsa; > -- UINT32 key_length; > -+ size_t key_length; > - > - info("TPM_CreateWrapKey()"); > - /* get parent key */ > -@@ -450,11 +465,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - } > - } > - /* generate key and store it */ > -- key_length = keyInfo->algorithmParms.parms.rsa.keyLength; > -- if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL; > -- wrappedKey->pubKey.keyLength = key_length >> 3; > -+ if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength)) > -+ return TPM_FAIL; > -+ wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3; > - wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength); > -- store.privKey.keyLength = key_length >> 4; > -+ store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4; > - store.privKey.key = tpm_malloc(store.privKey.keyLength); > - wrappedKey->encDataSize = parent->key.size >> 3; > - wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize); > -@@ -466,9 +481,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - tpm_free(wrappedKey->encData); > - return TPM_NOSPACE; > - } > -- rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > -- &wrappedKey->pubKey.keyLength); > -- rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength); > -+ rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > -+ &key_length); > -+ wrappedKey->pubKey.keyLength = (UINT32) key_length; > -+ rsa_export_prime1(&rsa, store.privKey.key, &key_length); > -+ store.privKey.keyLength = (UINT32) key_length; > - rsa_release_private_key(&rsa); > - /* compute the digest of the wrapped key (without encData) */ > - if (compute_key_digest(wrappedKey, &store.pubDataDigest)) { > -@@ -602,6 +619,7 @@ TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p > - > - int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms) > - { > -+ size_t key_length; > - parms->algorithmID = TPM_ALG_RSA; > - parms->encScheme = key->encScheme; > - parms->sigScheme = key->sigScheme; > -@@ -611,7 +629,8 @@ int tpm_setup_key_parms(TPM_KEY_DATA *ke > - parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize); > - if (parms->parms.rsa.exponent == NULL) return -1; > - rsa_export_exponent(&key->key, parms->parms.rsa.exponent, > -- &parms->parms.rsa.exponentSize); > -+ &key_length); > -+ parms->parms.rsa.exponentSize = (UINT32) key_length; > - parms->parmSize = 12 + parms->parms.rsa.exponentSize; > - return 0; > - } > -@@ -622,6 +641,7 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > - TPM_RESULT res; > - TPM_KEY_DATA *key; > - TPM_DIGEST digest; > -+ size_t key_length; > - info("TPM_GetPubKey()"); > - /* get key */ > - if (keyHandle == TPM_KH_SRK > -@@ -650,8 +670,8 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > - pubKey->pubKey.keyLength = key->key.size >> 3; > - pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength); > - if (pubKey->pubKey.key == NULL) return TPM_NOSPACE; > -- rsa_export_modulus(&key->key, pubKey->pubKey.key, > -- &pubKey->pubKey.keyLength); > -+ rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length); > -+ pubKey->pubKey.keyLength = (UINT32) key_length; > - if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) { > - error("TPM_GetPubKey(): tpm_setup_key_parms() failed."); > - tpm_free(pubKey->pubKey.key); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h > ---- orig/tpm_emulator-0.4/tpm/tpm_structures.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_structures.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1958,6 +1958,7 @@ typedef struct tdTPM_DAA_ISSUER { > - TPM_DIGEST DAA_digest_gamma; > - BYTE DAA_generic_q[26]; > - } TPM_DAA_ISSUER; > -+#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 ) > - > - /* > - * TPM_DAA_TPM ([TPM_Part2], Section 22.4) > -@@ -1973,6 +1974,7 @@ typedef struct tdTPM_DAA_TPM { > - TPM_DIGEST DAA_rekey; > - UINT32 DAA_count; > - } TPM_DAA_TPM; > -+#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4) > - > - /* > - * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5) > -@@ -1987,6 +1989,7 @@ typedef struct tdTPM_DAA_CONTEXT { > - BYTE DAA_scratch[256]; > - BYTE DAA_stage; > - } TPM_DAA_CONTEXT; > -+#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1) > - > - /* > - * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6) > -@@ -1998,6 +2001,7 @@ typedef struct tdTPM_DAA_JOINDATA { > - BYTE DAA_join_u1[138]; > - TPM_DIGEST DAA_digest_n0; > - } TPM_DAA_JOINDATA; > -+#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20) > - > - /* > - * TPM_DAA_BLOB ([TPM_Part2], Section 22.8) > -@@ -2202,6 +2206,7 @@ typedef struct tdTPM_STCLEAR_DATA { > - //UINT32 ownerReference; > - //BOOL disableResetLock; > - } TPM_STCLEAR_DATA; > -+#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4) > - > - /* > - * TPM_SESSION_DATA > -@@ -2238,6 +2243,11 @@ typedef struct tdTPM_DAA_SESSION_DATA { > - TPM_DAA_JOINDATA DAA_joinSession; > - TPM_HANDLE handle; > - } TPM_DAA_SESSION_DATA; > -+#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \ > -+ + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \ > -+ + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \ > -+ + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \ > -+ + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4) > - > - /* > - * TPM_STANY_DATA ([TPM_Part2], Section 7.6) > -@@ -2262,6 +2272,11 @@ typedef struct tdTPM_STANY_DATA { > - TPM_DAAHANDLE currentDAA; > - TPM_TRANSHANDLE transExclusive; > - } TPM_STANY_DATA; > -+#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \ > -+ + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \ > -+ + 4 + (4 * TPM_MAX_SESSION_LIST) \ > -+ + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \ > -+ + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4) > - > - /* > - * TPM_DATA > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c > ---- orig/tpm_emulator-0.4/tpm/tpm_testing.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_testing.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -95,24 +96,24 @@ static int tpm_test_sha1(void) > - struct { > - uint8_t *data; uint32_t repetitions; uint8_t *digest; > - } test_cases[] = {{ > -- "abc", 1, > -- "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > -+ (uint8_t*)"abc", 1, > -+ (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > - }, { > -- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > -- "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > -+ (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > -+ (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > - }, { > -- "a", 1000000, > -- "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > -+ (uint8_t*)"a", 1000000, > -+ (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > - }, { > -- "0123456701234567012345670123456701234567012345670123456701234567", 10, > -- "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > -+ (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10, > -+ (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > - }}; > - > - debug("tpm_test_sha1()"); > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > - sha1_init(&ctx); > - for (j = 0; j < test_cases[i].repetitions; j++) > -- sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > -+ sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > - sha1_final(&ctx, digest); > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > - } > -@@ -128,41 +129,41 @@ static int tpm_test_hmac(void) > - struct { > - uint8_t *key, key_len, *data, data_len, *digest; > - } test_cases[] = {{ > -- "\x0b", 20, "Hi There", 8, > -- "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > -+ (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8, > -+ (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > - }, { > -- "Jefe", 4, "what do ya want for nothing?", 28, > -- "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > -+ (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28, > -+ (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > - }, { > -- "\xaa", 20, "\xdd", 50, > -- "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > -+ (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50, > -+ (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > - }, { > -- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > -- "\x15\x16\x17\x18\x19", 25, "\xcd", 50, > -- "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > -+ (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > -+ "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50, > -+ (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > - }, { > -- "\x0c", 20, "Test With Truncation", 20, > -- "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > -+ (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20, > -+ (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > - }, { > -- "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54, > -- "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > -+ (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54, > -+ (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > - }, { > -- "\xaa", 80, > -- "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > -- "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > -+ (uint8_t*)"\xaa", 80, > -+ (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > -+ (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > - }}; > - > - debug("tpm_test_hmac()"); > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > -- if (strlen(test_cases[i].key) < test_cases[i].key_len) { > -+ if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) { > - uint8_t key[test_cases[i].key_len]; > - memset(key, test_cases[i].key[0], test_cases[i].key_len); > - hmac_init(&ctx, key, test_cases[i].key_len); > - } else { > - hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len); > - } > -- for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) { > -- hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > -+ for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) { > -+ hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > - } > - hmac_final(&ctx, digest); > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > -@@ -173,9 +174,9 @@ static int tpm_test_hmac(void) > - static int tpm_test_rsa_EK(void) > - { > - int res = 0; > -- char *data = "RSA PKCS #1 v1.5 Test-String"; > -+ uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String"; > - uint8_t buf[256]; > -- size_t buf_len, data_len = strlen(data); > -+ size_t buf_len, data_len = strlen((char*)data); > - rsa_private_key_t priv_key; > - rsa_public_key_t pub_key; > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c > ---- orig/tpm_emulator-0.4/tpm/tpm_ticks.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_ticks.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -39,9 +40,7 @@ TPM_RESULT TPM_SetTickType(TPM_TICKTYPE > - TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime) > - { > - info("TPM_GetTicks()"); > -- memcpy(currentTime, &tpmData.stany.data.currentTicks, > -- sizeof(TPM_CURRENT_TICKS)); > -- return TPM_SUCCESS; > -+ return TPM_DISABLED_CMD; > - } > - > - TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay, > -@@ -49,64 +48,11 @@ TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN > - TPM_CURRENT_TICKS *currentTicks, > - UINT32 *sigSize, BYTE **sig) > - { > -- TPM_RESULT res; > -- TPM_KEY_DATA *key; > -- BYTE *info, *p; > -- UINT32 info_length, length; > - info("TPM_TickStampBlob()"); > -- /* get key */ > -- key = tpm_get_key(keyHandle); > -- if (key == NULL) return TPM_INVALID_KEYHANDLE; > -- /* verify authorization */ > -- res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); > -- if (res != TPM_SUCCESS) return res; > -- if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY > -- && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE; > -- /* get current ticks */ > -- TPM_GetTicks(currentTicks); > -- /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */ > -- *sigSize = key->key.size >> 3; > -- *sig = tpm_malloc(*sigSize); > -- if (*sig == NULL) return TPM_FAIL; > -- /* setup TPM_SIGN_INFO structure */ > -- info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks); > -- info = tpm_malloc(info_length); > -- if (info == NULL) { > -- tpm_free(*sig); > -- return TPM_FAIL; > -- } > -- memcpy(&info[0], "\x05\x00TSTP", 6); > -- memcpy(&info[6], antiReplay->nonce, 20); > -- *(UINT32*)&info[26] = CPU_TO_BE32(20 > -- + sizeof_TPM_CURRENT_TICKS(currentTicks)); > -- memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST)); > -- p = &info[30 + sizeof(TPM_DIGEST)]; > -- length = sizeof_TPM_CURRENT_TICKS(currentTicks); > -- if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks) > -- || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) { > -- tpm_free(*sig); > -- tpm_free(info); > -- return TPM_FAIL; > -- } > -- return TPM_SUCCESS; > -+ return TPM_DISABLED_CMD; > - } > - > - void tpm_update_ticks(void) > - { > -- if (tpmData.stany.data.currentTicks.tag == 0) { > -- tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS; > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > --/* removed since v1.2 rev 94 > -- tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType; > --*/ > -- tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce, > -- sizeof(TPM_NONCE)); > -- tpmData.stany.data.currentTicks.tickRate = 1; > --/* removed since v1.2 rev 94 > -- tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK; > --*/ > -- } else { > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > -- } > - } > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c > ---- orig/tpm_emulator-0.4/tpm/tpm_transport.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_transport.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -189,7 +189,7 @@ static void decrypt_wrapped_command(BYTE > - sha1_init(&sha1); > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > -- sha1_update(&sha1, "in", 2); > -+ sha1_update(&sha1, (BYTE*)"in", 2); > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > - j = CPU_TO_BE32(i); > - sha1_update(&sha1, (BYTE*)&j, 4); > -@@ -211,7 +211,7 @@ static void encrypt_wrapped_command(BYTE > - sha1_init(&sha1); > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > -- sha1_update(&sha1, "out", 3); > -+ sha1_update(&sha1, (BYTE*)"out", 3); > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > - j = CPU_TO_BE32(i); > - sha1_update(&sha1, (BYTE*)&j, 4); > -diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c > ---- orig/tpm_emulator-0.4/tpmd.c 1969-12-31 16:00:00.000000000 -0800 > -+++ tpm_emulator/tpmd.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -0,0 +1,156 @@ > -+/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > -+ * Copyright (C) 2005 INTEL Corp > -+ * > -+ * This module is free software; you can redistribute it and/or modify > -+ * it under the terms of the GNU General Public License as published > -+ * by the Free Software Foundation; either version 2 of the License, > -+ * or (at your option) any later version. > -+ * > -+ * This module is distributed in the hope that it will be useful, > -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of > -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > -+ * GNU General Public License for more details. > -+ * > -+ */ > -+ > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+ > -+#include "tpm_emulator.h" > -+ > -+#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > -+#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > -+ > -+#define BUFFER_SIZE 2048 > -+ > -+static int devurandom=0; > -+ > -+void get_random_bytes(void *buf, int nbytes) { > -+ > -+ if (devurandom == 0) { > -+ devurandom = open("/dev/urandom", O_RDONLY); > -+ } > -+ > -+ if (read(devurandom, buf, nbytes) != nbytes) { > -+ printf("Can't get random number.\n"); > -+ exit(-1); > -+ } > -+} > -+ > -+uint64_t tpm_get_ticks(void) > -+{ > -+ //struct timeval tv; > -+ //int gettimeofday(&tv, struct timezone *tz); > -+ return 0; > -+} > -+ > -+int main(int argc, char **argv) > -+{ > -+ uint8_t in[BUFFER_SIZE], *out; > -+ uint32_t out_size; > -+ int in_size, written; > -+ int i; > -+ struct stat file_info; > -+ > -+ int tpm_tx_fh=-1, tpm_rx_fh=-1; > -+ if (argc < 2) { > -+ printf("Usage: tpmd clear|save|deactivated\n" ); > -+ return -1; > -+ } > -+ > -+ /* initialize TPM emulator */ > -+ if (!strcmp(argv[1], "clear")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(1); > -+ } else if (!strcmp(argv[1], "save")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(2); > -+ } else if (!strcmp(argv[1], "deactivated")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(3); > -+ } else { > -+ printf("invalid startup mode '%s'; must be 'clear', " > -+ "'save' (default) or 'deactivated", argv[1]); > -+ return -1; > -+ } > -+ > -+ if ( stat(TPM_RX_FNAME, &file_info) == -1) { > -+ if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > -+ printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > -+ return -1; > -+ } > -+ } > -+ > -+ if ( stat(TPM_TX_FNAME, &file_info) == -1) { > -+ if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > -+ printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > -+ return -1; > -+ } > -+ } > -+ > -+ while (1) { > -+abort_command: > -+ if (tpm_rx_fh < 0) { > -+ tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > -+ } > -+ > -+ if (tpm_rx_fh < 0) { > -+ printf("ERROR: failed to open devices to listen to guest.\n"); > -+ return -1; > -+ } > -+ > -+ if (tpm_tx_fh < 0) { > -+ tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > -+ } > -+ > -+ if (tpm_tx_fh < 0) { > -+ printf("ERROR: failed to open devices to respond to guest.\n"); > -+ return -1; > -+ } > -+ > -+ in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > -+ if (in_size < 6) { // Magic size of minium TPM command > -+ printf("Recv[%d] to small: 0x", in_size); > -+ if (in_size <= 0) { > -+ close(tpm_rx_fh); > -+ tpm_rx_fh = -1; > -+ goto abort_command; > -+ } > -+ } else { > -+ printf("Recv[%d]: 0x", in_size); > -+ for (i=0; i< in_size; i++) > -+ printf("%x ", in[i]); > -+ printf("\n"); > -+ } > -+ > -+ > -+ if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > -+ printf("ERROR: Handler Failed.\n"); > -+ } > -+ > -+ written = write(tpm_tx_fh, out, out_size); > -+ > -+ if (written != out_size ) { > -+ printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > -+ } else { > -+ printf("Sent[%Zu]: ", out_size); > -+ } > -+ for (i=0; i< out_size; i++) > -+ printf("%x ", out[i]); > -+ printf("\n"); > -+ tpm_free(out); > -+ > -+ } // loop > -+ > -+ tpm_emulator_shutdown(); > -+ > -+ close(tpm_tx_fh); > -+ close(tpm_rx_fh); > -+ > -+} > -Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ > -diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h > ---- orig/tpm_emulator-0.4/tpm_version.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm_version.h 2006-07-24 14:35:41.000000000 -0700 > -@@ -2,5 +2,5 @@ > - #define _TPM_VERSION_H_ > - #define VERSION_MAJOR 0 > - #define VERSION_MINOR 4 > --#define VERSION_BUILD 1151058734 > -+#define VERSION_BUILD 1153776940 > - #endif /* _TPM_VERSION_H_ */ > diff --git a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch b/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > deleted file mode 100644 > index 95586c1..0000000 > --- a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > +++ /dev/null > @@ -1,12 +0,0 @@ > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm_emulator-0.5.1/tpmd/Makefile > ---- tpm_emulator-0.5.1/tpmd/Makefile > -+++ tpm_emulator-0.5.1/tpmd/Makefile > -@@ -8,7 +8,7 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > - CFLAGS += -I../../../../tools/vtpm_manager/manager > --LDFLAGS += -lgmp > -+LDLIBS += -lgmp > - > - BINDIR := /usr/bin/ > - > diff --git a/tools/vtpm/vtpm-0.5.1.patch b/tools/vtpm/vtpm-0.5.1.patch > deleted file mode 100644 > index 2aeb745..0000000 > --- a/tools/vtpm/vtpm-0.5.1.patch > +++ /dev/null > @@ -1,766 +0,0 @@ > -diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile > ---- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 > -@@ -10,7 +10,7 @@ VERSION_MINOR := 5 > - VERSION_BUILD := $(shell date +"%s") > - VERSION_SUFFIX := .1 > - > --SUBDIRS := tpmd tpmd_dev tddl > -+SUBDIRS := tpmd > - > - all: version all-recursive > - > -@@ -48,12 +48,12 @@ user_install: user > - modules_install: modules > - @$(MAKE) -C tpmd_dev install || exit -1 > - > --DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd > -+DIRS := . tpm crypto tpmd > - DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) > - DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) > --DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd > -+DIRS := . tpmd > - DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) > --DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in > -+DISTSRC += ./README ./AUTHORS ./ChangeLog > - DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) > - > - dist: $(DISTSRC) > -diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c > ---- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 > -@@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_TIS_TIMEOUT: > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > -+ UINT32 len = *respSize = 16; > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > -+ if (ptr == NULL || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > -+ tpm_free(*resp); > -+ return TPM_FAIL; > -+ } > -+ return TPM_SUCCESS; > -+ > - > - case TPM_CAP_PROP_STARTUP_EFFECT: > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > -@@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_DURATION: > - debug("[TPM_CAP_PROP_DURATION]"); > -- /* TODO: TPM_CAP_PROP_DURATION */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > -+ *respSize = 16; > -+ *resp = tpm_malloc(*respSize); > -+ memcpy(*resp,dur,16); > -+ > - > - case TPM_CAP_PROP_ACTIVE_COUNTER: > - debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile > ---- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 > -@@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > - -Wwrite-strings -Wsign-compare -Wno-multichar > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > -+CFLAGS += -I../../../../tools/vtpm_manager/manager > - LDFLAGS += -lgmp > - > --BINDIR := /usr/sbin/ > -+BINDIR := /usr/bin/ > - > - TPMD := tpmd > - DIRS := ../tpm ../crypto > -@@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > - OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) > - > -+VTPM_BIN := vtpmd > -+ > - vpath %.c $(strip $(DIRS)) > - > - all: $(TPMD) > -@@ -32,10 +35,8 @@ TPMD_GROUP ?= tss > - INSTALL ?= install > - > - install: $(TPMD) > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm > - $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) > -- $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) > -+ $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) > - > - .PHONY: all clean install > - > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c > ---- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 > -@@ -32,6 +32,9 @@ > - #include > - #include "tpm_emulator_config.h" > - #include "tpm/tpm_emulator.h" > -+#include "tpm/tpm_structures.h" > -+#include "tpm/tpm_marshalling.h" > -+#include "vtpm_manager.h" > - > - #define TPM_DAEMON_NAME "tpmd" > - #define TPM_CMD_BUF_SIZE 4096 > -@@ -39,6 +42,24 @@ > - #define TPM_RANDOM_DEVICE "/dev/urandom" > - #undef TPM_MKDIRS > - > -+#ifdef VTPM_MULTI_VM > -+ #define DEV_BE "/dev/vtpm" > -+ #define DEV_FE "/dev/tpm" > -+#else > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > -+ > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -+ > -+ static char *vtpm_rx_name=NULL; > -+#endif > -+ > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#define BUFFER_SIZE 2048 > -+ > - static volatile int stopflag = 0; > - static int is_daemon = 0; > - static int opt_debug = 0; > -@@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ > - static uid_t opt_uid = 0; > - static gid_t opt_gid = 0; > - static int tpm_startup = 2; > -+static int vtpm_type = VTPM_TYPE_PVM; > -+int dmi_id = 0; > - static int rand_fh; > - > - void tpm_log(int priority, const char *fmt, ...) > -@@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) > - > - int tpm_write_to_file(uint8_t *data, size_t data_length) > - { > -- int fh; > -- ssize_t res; > -- fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- if (fh < 0) return -1; > -- while (data_length > 0) { > -- res = write(fh, data, data_length); > -- if (res < 0) { > -- close(fh); > -- return -1; > -- } > -- data_length -= res; > -- data += res; > -+ int res, out_data_size, in_header_size; > -+ BYTE *ptr, *out_data, *in_header; > -+ UINT32 result, len, in_rsp_size; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ > -+ printf("Saving NVM\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > -+#endif > -+ > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > -+ free(out_data); > -+ return -1; > -+ } > -+ > -+ printf("\tSending SaveNVM Command.\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > - } > -- close(fh); > -- return 0; > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading SaveNVM header.\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > -+#endif > -+ > -+ printf("\tFinishing up SaveNVM\n"); > -+ return (0); > - } > - > - int tpm_read_from_file(uint8_t **data, size_t *data_length) > - { > -- int fh; > -- ssize_t res; > -- size_t total_length; > -- fh = open(opt_storage_file, O_RDONLY); > -- if (fh < 0) return -1; > -- total_length = lseek(fh, 0, SEEK_END); > -- lseek(fh, 0, SEEK_SET); > -- *data = tpm_malloc(total_length); > -- if (*data == NULL) { > -- close(fh); > -- return -1; > -- } > -- *data_length = 0; > -- while (total_length > 0) { > -- res = read(fh, &(*data)[*data_length], total_length); > -- if (res < 0) { > -- close(fh); > -- tpm_free(*data); > -- return -1; > -- } > -- *data_length += res; > -- total_length -= res; > -+ int res, out_data_size, in_header_size; > -+ uint8_t *ptr, *out_data, *in_header; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ UINT32 len, in_rsp_size, result; > -+#ifdef VTPM_MUTLI_VM > -+ int vtpm_rx_fh, vtpm_tx_fh; > -+#endif > -+ > -+ printf("Loading NVM.\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ printf("Error in read_from_file:301\n"); > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > -+ free(out_data); > -+ printf("Error in read_from_file:325\n"); > -+ > -+ return -1; > -+ } > -+ > -+ printf("\tSending LoadNVM command\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) > -+ { > -+ printf("Error in read_from_file:335\n"); > -+ return -1; > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > - } > -- close(fh); > -- return 0; > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ printf("Error in read_from_file:352\n"); > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading LoadNVM header\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ printf("Error in read_from_file:375\n"); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ printf("Error in read_from_file:381\n"); > -+ return -1; > -+ } > -+ > -+ // Read Encrypted data from VTPM Manager > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > -+ *data = (uint8_t *) malloc(*data_length); > -+ > -+ printf("\tReading clear data from LoadNVM.\n"); > -+ res = read(vtpm_rx_fh, *data, *data_length); > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > -+#endif > -+ > -+ printf("\tReturing from loading NVM\n"); > -+ if (res != (int)*data_length) { > -+ free(*data); > -+ printf("Error in read_from_file:398\n"); > -+ return -1; > -+ } else { > -+ return 0; > -+ } > -+ > -+ > -+ > - } > - > - static void print_usage(char *name) > - { > - printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " > -- "[-o user name] [-g group name] [-h] [startup mode]\n", name); > -+ "[-o user name] [-g group name] [-h]" > -+#ifdef VTPM_MULTI_VM > -+ "clear|save|deactivated\n", name); > -+#else > -+ "clear|save|deactivated pvm|hvm vtpmid\n", name); > -+#endif > - printf(" d : enable debug mode\n"); > - printf(" f : forces the application to run in the foreground\n"); > - printf(" s : storage file to use (default: %s)\n", opt_storage_file); > -@@ -205,7 +413,13 @@ static void parse_options(int argc, char > - exit(EXIT_SUCCESS); > - } > - } > -- if (optind < argc) { > -+ /*Make sure we have all required options*/ > -+#ifdef VTPM_MULTI_VM > -+#define EXTRA_OPTS 0 > -+#else > -+#define EXTRA_OPTS 2 > -+#endif > -+ if (optind < argc - EXTRA_OPTS ) { > - debug("startup mode = '%s'", argv[optind]); > - if (!strcmp(argv[optind], "clear")) { > - tpm_startup = 1; > -@@ -219,6 +433,25 @@ static void parse_options(int argc, char > - print_usage(argv[0]); > - exit(EXIT_SUCCESS); > - } > -+#ifndef VTPM_MULTI_VM > -+ ++optind; > -+ if(!strcmp(argv[optind], "pvm")) { > -+ vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > -+ } else if (!strcmp(argv[optind], "hvm")) { > -+ vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket > -+ } else { > -+ error("Invalid vm mode '%s'; must be 'pvm', " > -+ "or 'hvm' ", argv[optind]); > -+ print_usage(argv[0]); > -+ exit(EXIT_SUCCESS); > -+ } > -+ ++optind; > -+ dmi_id = atoi(argv[optind]); > -+#endif > -+ } else { > -+ error("Invalid number of arguments"); > -+ print_usage(argv[0]); > -+ exit(EXIT_SUCCESS); > - } > - } > - > -@@ -348,93 +581,180 @@ static int init_socket(const char *name) > - > - static void main_loop(void) > - { > -- int sock, fh, res; > -- int32_t in_len; > -+ int32_t in_len, written; > - uint32_t out_len; > -- uint8_t in[TPM_CMD_BUF_SIZE], *out; > -+ uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; > -+ int guest_id=-1; > -+ int i; > -+ char *vtpm_rx_file=NULL; > -+ int res; > -+ > -+#ifndef VTPM_MULTI_VM > -+ int sockfd = -1; > - struct sockaddr_un addr; > -- socklen_t addr_len; > -- fd_set rfds; > -- struct timeval tv; > -+ struct sockaddr_un client_addr; > -+ unsigned int client_length; > -+#endif > -+ > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#ifndef VTPM_MULTI_VM > -+ if (vtpm_type == VTPM_TYPE_PVM) { > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } else { > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > -+ error("Unable to create socket. errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&addr, 0, sizeof(addr)); > -+ addr.sun_family = AF_UNIX; > -+ strcpy(addr.sun_path,vtpm_rx_file ); > -+ unlink(addr.sun_path); > -+ } > -+#endif > - > - info("staring main loop"); > -- /* open UNIX socket */ > -- sock = init_socket(opt_socket_name); > -- if (sock < 0) exit(EXIT_FAILURE); > - /* init tpm emulator */ > -- debug("initializing TPM emulator: %d", tpm_startup); > -+#ifdef VTPM_MULTI_VM > -+ debug("initializing TPM emulator: state=%d", tpm_startup); > -+#else > -+ debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); > -+#endif > - tpm_emulator_init(tpm_startup); > - /* start command processing */ > - while (!stopflag) { > - /* wait for incomming connections */ > - debug("waiting for connections..."); > -- FD_ZERO(&rfds); > -- FD_SET(sock, &rfds); > -- tv.tv_sec = 10; > -- tv.tv_usec = 0; > -- res = select(sock + 1, &rfds, NULL, NULL, &tv); > -- if (res < 0) { > -- error("select(sock) failed: %s", strerror(errno)); > -- break; > -- } else if (res == 0) { > -- continue; > -- } > -- addr_len = sizeof(addr); > -- fh = accept(sock, (struct sockaddr*)&addr, &addr_len); > -- if (fh < 0) { > -- error("accept() failed: %s", strerror(errno)); > -- continue; > -- } > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > -+#else > -+ if (vtpm_type == VTPM_TYPE_PVM) > -+ { > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > -+ } else { > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > -+ error("Unable to bind(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ if (listen(sockfd, 10) <0) { > -+ error("Unable to listen(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&client_addr, 0, sizeof(client_addr)); > -+ client_length = sizeof(client_addr); > -+ > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > -+ } > -+#endif > -+ } > -+ > -+ /*Error Checking*/ > -+ if (vtpm_rx_fh < 0) { > -+ error("Failed to open devices to listen to guest.\n"); > -+ exit(-1); > -+ } > -+ > - /* receive and handle commands */ > - in_len = 0; > - do { > - debug("waiting for commands..."); > -- FD_ZERO(&rfds); > -- FD_SET(fh, &rfds); > -- tv.tv_sec = TPM_COMMAND_TIMEOUT; > -- tv.tv_usec = 0; > -- res = select(fh + 1, &rfds, NULL, NULL, &tv); > -- if (res < 0) { > -- error("select(fh) failed: %s", strerror(errno)); > -- close(fh); > -- break; > -- } else if (res == 0) { > --#ifdef TPMD_DISCONNECT_IDLE_CLIENTS > -- info("connection closed due to inactivity"); > -- close(fh); > -- break; > --#else > -- continue; > --#endif > -- } > -- in_len = read(fh, in, sizeof(in)); > -- if (in_len > 0) { > -+ > -+ in_len = read(vtpm_rx_fh, in, sizeof(in)); > -+ /*Magic size of minimum TPM command is 6*/ > -+ //FIXME Magic size check may not be required anymore > -+ if (in_len < 6) { > -+ info("Recv incomplete command of %d bytes.", in_len); > -+ if (in_len <= 0) { > -+ close(vtpm_rx_fh); > -+ vtpm_rx_fh = -1; > -+ continue; > -+ } > -+ } else { > -+ /*Debug Printouts*/ > - debug("received %d bytes", in_len); > -+ debug_nostop("Recv[%d]: 0x", in_len); > -+ for (i=0; i< in_len; i++) > -+ debug_more("%x ", in[i]); > -+ debug_more("\n"); > -+ /*Multiple Guest check*/ > -+ if (guest_id == -1) { > -+ guest_id = *((int32_t *) in); > -+ } else { > -+ if (guest_id != *((int32_t *) in) ) { > -+ error("WARNING: More than one guest attached\n"); > -+ } > -+ } > -+ > -+ /*Open tx handle now*/ > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_type == VTPM_TYPE_PVM) { > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > -+ } // No need to open the other direction for HVM > -+#endif > -+ } > -+ if (vtpm_tx_fh < 0) { > -+ error("Failed to open devices to respond to guest.\n"); > -+ exit(-1); > -+ } > -+ > -+ /*Handle the TPM command now*/ > - out = NULL; > -- res = tpm_handle_command(in, in_len, &out, &out_len); > -+ res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); > - if (res < 0) { > - error("tpm_handle_command() failed"); > - } else { > - debug("sending %d bytes", out_len); > -+ //FIXME this prepending may or may not be needed > -+ /*Prepend the first 4 bytes of the in buffer.. why?*/ > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_len); > -+ out_len += sizeof(uint32_t); > -+ /*End Prepend*/ > -+ > -+ /*Perform write operation now*/ > - while (out_len > 0) { > -- res = write(fh, out, out_len); > -+ res = write(vtpm_tx_fh, addressed_out, out_len); > -+ > - if (res < 0) { > - error("write(%d) failed: %s", out_len, strerror(errno)); > - break; > -- } > -+ } else { > -+ debug_nostop("Sent[%Zu]: ", out_len); > -+ for (i=0; (unsigned int)i< out_len; i++) > -+ debug_more("%x ", addressed_out[i]); > -+ debug_more("\n"); > -+ } > - out_len -= res; > - } > - tpm_free(out); > -+ tpm_free(addressed_out); > - } > - } > - } while (in_len > 0); > -- close(fh); > -+ //close(fh); > - } > -+ > - /* shutdown tpm emulator */ > - tpm_emulator_shutdown(); > -- /* close socket */ > -- close(sock); > -- unlink(opt_socket_name); > -+ /* Close handles */ > -+ close(vtpm_tx_fh); > -+#ifndef VTPM_MULTI_VM > -+ close(vtpm_rx_fh); > -+ free(vtpm_rx_file); > -+#endif > - info("main loop stopped"); > - } > - > -@@ -450,12 +770,13 @@ int main(int argc, char **argv) > - /* open random device */ > - init_random(); > - /* init signal handlers */ > -- init_signal_handler(); > -+ //init_signal_handler(); > - /* unless requested otherwiese, fork and daemonize process */ > -- if (!opt_foreground) daemonize(); > -+ //if (!opt_foreground) daemonize(); > - /* start main processing loop */ > - main_loop(); > - info("stopping TPM Emulator daemon"); > - closelog(); > - return 0; > - } > -+ > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h > ---- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 > -@@ -29,23 +29,28 @@ > - > - /* TPM emulator configuration */ > - > --#undef TPM_STRONG_PERSISTENCE > --#undef TPM_GENERATE_EK > -+#define TPM_STRONG_PERSISTENCE > -+#define TPM_GENERATE_EK > - #undef TPM_GENERATE_SEED_DAA > - #undef TPM_MEMORY_ALIGNMENT_MANDATORY > - > -+extern int dmi_id; > -+ > - /* log macros */ > - > - void tpm_log(int priority, const char *fmt, ...); > - > --#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) > - > - /* min/max macros that also do strict type-checking */ > - > diff --git a/tools/vtpm/vtpm.patch b/tools/vtpm/vtpm.patch > deleted file mode 100644 > index e896b25..0000000 > --- a/tools/vtpm/vtpm.patch > +++ /dev/null > @@ -1,716 +0,0 @@ > -diff -uprN tpm_emulator/AUTHORS vtpm/AUTHORS > ---- tpm_emulator/AUTHORS 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/AUTHORS 2006-12-13 16:38:52.000000000 -0800 > -@@ -1,3 +1,3 @@ > - Mario Strasser > - Heiko Stamer [DAA] > --INTEL Corp <> [Dropped to Ring3] > -+INTEL Corp <> [VTPM Extensions] > -diff -uprN tpm_emulator/ChangeLog vtpm/ChangeLog > ---- tpm_emulator/ChangeLog 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/ChangeLog 2006-12-13 16:38:52.000000000 -0800 > -@@ -1,5 +1,6 @@ > - ????-??-?? Intel Corp > - * Moved module out of kernel to run as a ring 3 app > -+ * Modified save_to_file and load_from_file to call xen VTPM manager > - > - 2006-06-23 Mario Strasser > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > -diff -uprN tpm_emulator/linux_module.h vtpm/linux_module.h > ---- tpm_emulator/linux_module.h 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/linux_module.h 2007-01-09 14:49:06.000000000 -0800 > -@@ -44,18 +44,26 @@ > - #define TPM_DEVICE_NAME "tpm" > - #define TPM_MODULE_NAME "tpm_emulator" > - > -+/* debug and log output functions */ > -+extern int dmi_id; > -+ > - #ifdef DEBUG > --#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_nostop(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt, \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_more(fmt, ...) printf( fmt, ## __VA_ARGS__ ) > - #else > - #define debug(fmt, ...) > -+#define debug_nostop(fmt, ...) > -+#define debug_more(fmt, ...) > - #endif > --#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) printf("TPMD[%d]: %s:%d: Info: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) printf("TPMD[%d]: %s:%d: Error: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) printf("TPMD[%d]: %s:%d: Alert: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > - > - /* memory allocation */ > - > -diff -uprN tpm_emulator/Makefile vtpm/Makefile > ---- tpm_emulator/Makefile 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/Makefile 2006-12-13 16:38:52.000000000 -0800 > -@@ -7,7 +7,7 @@ > - COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > - > - # module settings > --BIN := tpm_emulator > -+BIN := vtpmd > - VERSION_MAJOR := 0 > - VERSION_MINOR := 4 > - VERSION_BUILD := $(shell date +"%s") > -@@ -22,7 +22,7 @@ TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > - > - CC := gcc > - CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > --CFLAGS += -I. -Itpm > -+CFLAGS += -I. -Itpm -I../../vtpm_manager/manager > - > - # Is the simulator running in it's own vm? > - #CFLAGS += -DVTPM_MULTI_VM > -@@ -62,7 +62,6 @@ $(BIN): $(src)/crypto/gmp.h $(src)/crypt > - > - install: $(BIN) > - $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > -- @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > - > - clean: > - rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > -@@ -98,3 +97,4 @@ version: > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > - > - .PHONY: all install clean dist gmp version > -+ > -diff -uprN tpm_emulator/tpm/tpm_capability.c vtpm/tpm/tpm_capability.c > ---- tpm_emulator/tpm/tpm_capability.c 2006-06-23 03:37:07.000000000 -0700 > -+++ vtpm/tpm/tpm_capability.c 2007-01-10 10:00:49.000000000 -0800 > -@@ -136,8 +136,18 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_TIS_TIMEOUT: > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > -+ UINT32 len = *respSize = 16; > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > -+ if (ptr == NULL || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > -+ tpm_free(*resp); > -+ return TPM_FAIL; > -+ } > -+ return TPM_SUCCESS; > - > - case TPM_CAP_PROP_STARTUP_EFFECT: > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > -@@ -190,7 +200,11 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_DURATION: > - debug("[TPM_CAP_PROP_DURATION]"); > -- /* TODO: TPM_CAP_PROP_DURATION */ > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > -+ *respSize = 16; > -+ *resp = tpm_malloc(*respSize); > -+ memcpy(*resp,dur,16); > - return TPM_FAIL; > - > - case TPM_CAP_PROP_ACTIVE_COUNTER: > -diff -uprN tpm_emulator/tpm/tpm_cmd_handler.c vtpm/tpm/tpm_cmd_handler.c > ---- tpm_emulator/tpm/tpm_cmd_handler.c 2008-02-27 16:35:41.000000000 -0500 > -+++ vtpm/tpm/tpm_cmd_handler.c 2008-02-28 14:43:28.000000000 -0500 > -@@ -94,12 +94,18 @@ void tpm_compute_out_param_digest(TPM_CO > - sha1_ctx_t sha1; > - UINT32 res = CPU_TO_BE32(rsp->result); > - UINT32 ord = CPU_TO_BE32(ordinal); > -+ UINT32 offset = 0; > - > - /* compute SHA1 hash */ > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*)&res, 4); > - sha1_update(&sha1, (BYTE*)&ord, 4); > -- sha1_update(&sha1, rsp->param, rsp->paramSize); > -+ if (ordinal == TPM_ORD_LoadKey2) { > -+ offset = 4; > -+ } > -+ if (rsp->paramSize - offset > 0) { > -+ sha1_update(&sha1, rsp->param + offset, rsp->paramSize - offset); > -+ } > - sha1_final(&sha1, rsp->auth1->digest); > - if (rsp->auth2 != NULL) memcpy(rsp->auth2->digest, > - rsp->auth1->digest, sizeof(rsp->auth1->digest)); > -diff -uprN tpm_emulator/tpm/tpm_data.c vtpm/tpm/tpm_data.c > ---- tpm_emulator/tpm/tpm_data.c 2008-02-27 16:35:41.000000000 -0500 > -+++ vtpm/tpm/tpm_data.c 2008-02-27 16:35:40.000000000 -0500 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -15,10 +16,15 @@ > - * $Id: tpm_data.c 98 2006-05-07 14:16:29Z hstamer $ > - */ > - > -+#include > -+#include > -+#include > -+#include > -+ > - #include "tpm_emulator.h" > - #include "tpm_structures.h" > - #include "tpm_marshalling.h" > --#include "linux_module.h" > -+#include "vtpm_manager.h" > - > - TPM_DATA tpmData; > - > -@@ -158,45 +164,232 @@ void tpm_release_data(void) > - #include > - #include > - #include > --#include > - > --#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#ifdef VTPM_MUTLI_VM > -+ #define DEV_FE "/dev/tpm" > -+#else > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -+ > -+ extern int dmi_id; > -+ static char *vtpm_rx_name=NULL; > -+#endif > - > - static int write_to_file(uint8_t *data, size_t data_length) > - { > -- int res; > -- int fp; > -- fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- res = write(fp, data, data_length); > -- close(fp); > -- return (res == data_length) ? 0 : -1; > -+ int res, out_data_size, in_header_size; > -+ BYTE *ptr, *out_data, *in_header; > -+ UINT32 result, len, in_rsp_size; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ > -+ printf("Saving NVM\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > -+#endif > -+ > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > -+ free(out_data); > -+ return -1; > -+ } > -+ > -+ printf("\tSending SaveNVM Command.\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading SaveNVM header.\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > -+#endif > -+ > -+ printf("\tFinishing up SaveNVM\n"); > -+ return (0); > - } > - > - static int read_from_file(uint8_t **data, size_t *data_length) > - { > -- int res; > -- int fp, file_status; > -- struct stat file_info; > -- fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > -- file_status = fstat(fp, &file_info); > -- if (file_status < 0) { > -- close(fp); > -- return -1; > -- } > -+ int res, out_data_size, in_header_size; > -+ uint8_t *ptr, *out_data, *in_header; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ UINT32 len, in_rsp_size, result; > -+#ifdef VTPM_MUTLI_VM > -+ int vtpm_rx_fh, vtpm_tx_fh; > -+#endif > -+ > -+ printf("Loading NVM.\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > - > -- *data_length = file_info.st_size; > -- *data = tpm_malloc(*data_length); > -- if (*data == NULL) { > -- close(fp); > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > -+ free(out_data); > - return -1; > - } > -- res = read(fp, *data, *data_length); > -- close(fp); > -+ > -+ printf("\tSending LoadNVM command\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading LoadNVM header\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+ // Read Encrypted data from VTPM Manager > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > -+ *data = (uint8_t *) malloc(*data_length); > -+ > -+ printf("\tReading clear data from LoadNVM.\n"); > -+ res = read(vtpm_rx_fh, *data, *data_length); > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > -+#endif > -+ > -+ printf("\tReturing from loading NVM\n"); > - if (res != *data_length) { > -- tpm_free(*data); > -- return -1; > -+ free(*data); > -+ return -1; > -+ } else { > -+ return 0; > - } > -- return 0; > -+ > - } > - > - #else > -diff -uprN tpm_emulator/tpmd.c vtpm/tpmd.c > ---- tpm_emulator/tpmd.c 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/tpmd.c 2007-01-09 14:48:56.000000000 -0800 > -@@ -21,12 +21,24 @@ > - #include > - #include > - #include > -+#include > -+#include > -+#include > - > - #include "tpm_emulator.h" > -+#include "vtpm_manager.h" > - > --#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > --#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > -+#ifdef VTPM_MULTI_VM > -+ #define DEV_BE "/dev/vtpm" > -+#else > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > - > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > -+#endif > -+ > -+ int dmi_id; > -+ > - #define BUFFER_SIZE 2048 > - > - static int devurandom=0; > -@@ -38,7 +50,7 @@ void get_random_bytes(void *buf, int nby > - } > - > - if (read(devurandom, buf, nbytes) != nbytes) { > -- printf("Can't get random number.\n"); > -+ error("Can't get random number.\n"); > - exit(-1); > - } > - } > -@@ -52,105 +64,182 @@ uint64_t tpm_get_ticks(void) > - > - int main(int argc, char **argv) > - { > -- uint8_t in[BUFFER_SIZE], *out; > -+ uint8_t type, in[BUFFER_SIZE], *out, *addressed_out; > -+ char *vtpm_rx_file=NULL; > - uint32_t out_size; > - int in_size, written; > -- int i; > -- struct stat file_info; > -+ int i, guest_id=-1; > - > -- int tpm_tx_fh=-1, tpm_rx_fh=-1; > -+#ifndef VTPM_MULTI_VM > -+ int sockfd = -1; > -+ struct sockaddr_un addr; > -+ struct sockaddr_un client_addr; > -+ unsigned int client_length; > -+ > -+#endif > -+ > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+#ifdef VTPM_MULTI_VM > - if (argc < 2) { > -- printf("Usage: tpmd clear|save|deactivated\n" ); > -+ error("Usage: tpmd clear|save|deactivated\n" ); > -+#else > -+ if (argc < 4) { > -+ error("Usage: tpmd clear|save|deactivated pvm|hvm vtpmid\n" ); > -+#endif > - return -1; > - } > - > -+#ifndef VTPM_MULTI_VM > -+ /* setup type of vm */ > -+ if (!strcmp(argv[2], "pvm")) { > -+ type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > -+ } else if (!strcmp(argv[2], "hvm")) { > -+ type = VTPM_TYPE_HVM; // Get commands from qemu via socket > -+ } else { > -+ error("invalid vTPM type '%s'.\n", argv[2]); > -+ } > -+ > -+ dmi_id = atoi(argv[3]); > -+ > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } else { > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > -+ error("Unable to create socket. errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&addr, 0, sizeof(addr)); > -+ addr.sun_family = AF_UNIX; > -+ strcpy(addr.sun_path,vtpm_rx_file ); > -+ unlink(addr.sun_path); > -+ } > -+#endif > -+ > -+#ifdef VTPM_MULTI_VM > -+ info("Initializing tpm state: %s\n", argv[1]); > -+#else > -+ info("Initializing tpm state: %s, type: %s, id: %d\n", argv[1], argv[2], dmi_id); > -+#endif > -+ > - /* initialize TPM emulator */ > - if (!strcmp(argv[1], "clear")) { > -- printf("Initializing tpm: %s\n", argv[1]); > - tpm_emulator_init(1); > -- } else if (!strcmp(argv[1], "save")) { > -- printf("Initializing tpm: %s\n", argv[1]); > -+ } else if (!strcmp(argv[1], "save")) { > - tpm_emulator_init(2); > - } else if (!strcmp(argv[1], "deactivated")) { > -- printf("Initializing tpm: %s\n", argv[1]); > - tpm_emulator_init(3); > - } else { > -- printf("invalid startup mode '%s'; must be 'clear', " > -+ error("invalid startup mode '%s'; must be 'clear', " > - "'save' (default) or 'deactivated", argv[1]); > - return -1; > - } > -- > -- if ( stat(TPM_RX_FNAME, &file_info) == -1) { > -- if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > -- printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > -- return -1; > -- } > -- } > -- > -- if ( stat(TPM_TX_FNAME, &file_info) == -1) { > -- if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > -- printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > -- return -1; > -- } > -- } > -- > -+ > - while (1) { > - abort_command: > -- if (tpm_rx_fh < 0) { > -- tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > -+#else > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > -+ } else { > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > -+ error("Unable to bind(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ if (listen(sockfd, 10) <0) { > -+ error("Unable to listen(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&client_addr, 0, sizeof(client_addr)); > -+ client_length = sizeof(client_addr); > -+ > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > -+ } > -+#endif > - } > - > -- if (tpm_rx_fh < 0) { > -- printf("ERROR: failed to open devices to listen to guest.\n"); > -+ if (vtpm_rx_fh < 0) { > -+ error("Failed to open devices to listen to guest.\n"); > - return -1; > - } > - > -- if (tpm_tx_fh < 0) { > -- tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > -- } > -- > -- if (tpm_tx_fh < 0) { > -- printf("ERROR: failed to open devices to respond to guest.\n"); > -- return -1; > -- } > -- > -- in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > -+ in_size = read(vtpm_rx_fh, in, BUFFER_SIZE); > - if (in_size < 6) { // Magic size of minium TPM command > -- printf("Recv[%d] to small: 0x", in_size); > -+ info("Recv incomplete command of %d bytes.", in_size); > - if (in_size <= 0) { > -- close(tpm_rx_fh); > -- tpm_rx_fh = -1; > -+ close(vtpm_rx_fh); > -+ vtpm_rx_fh = -1; > - goto abort_command; > - } > - } else { > -- printf("Recv[%d]: 0x", in_size); > -+ debug_nostop("Recv[%d]: 0x", in_size); > - for (i=0; i< in_size; i++) > -- printf("%x ", in[i]); > -- printf("\n"); > -+ debug_more("%x ", in[i]); > -+ debug_more("\n"); > - } > - > -- > -- if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > -- printf("ERROR: Handler Failed.\n"); > -+ if (guest_id == -1) { > -+ guest_id = *((uint32_t *) in); > -+ } else { > -+ if (guest_id != *((uint32_t *) in) ) { > -+ error("WARNING: More than one guest attached\n"); > -+ } > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > -+ } // No need to open the other direction for HVM > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ error("Failed to open devices to respond to guest.\n"); > -+ return -1; > -+ } > -+ > -+ // Handle the command, but skip the domain id header > -+ if (tpm_handle_command(in + sizeof(uint32_t), in_size - sizeof(uint32_t), &out, &out_size) != 0) { > -+ error("Handler Failed.\n"); > - } > - > -- written = write(tpm_tx_fh, out, out_size); > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_size); > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_size); > -+ > -+ written = write(vtpm_tx_fh, addressed_out, out_size + sizeof(uint32_t)); > - > -- if (written != out_size ) { > -- printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > -+ if (written != out_size + sizeof(uint32_t)) { > -+ error("Part of response not written %d/%d.\n", written, out_size); > - } else { > -- printf("Sent[%Zu]: ", out_size); > -+ debug_nostop("Sent[%Zu]: ", out_size + sizeof(uint32_t)); > -+ for (i=0; i< out_size+ sizeof(uint32_t); i++) > -+ debug_more("%x ", addressed_out[i]); > -+ debug_more("\n"); > - } > -- for (i=0; i< out_size; i++) > -- printf("%x ", out[i]); > -- printf("\n"); > - tpm_free(out); > -+ tpm_free(addressed_out); > - > - } // loop > - > - tpm_emulator_shutdown(); > - > -- close(tpm_tx_fh); > -- close(tpm_rx_fh); > -+ close(vtpm_tx_fh); > -+#ifndef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh); > -+ free (vtpm_rx_file); > -+#endif > - > - } > diff --git a/tools/vtpm_manager/COPYING b/tools/vtpm_manager/COPYING > deleted file mode 100644 > index c4b86b7..0000000 > --- a/tools/vtpm_manager/COPYING > +++ /dev/null > @@ -1,32 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > diff --git a/tools/vtpm_manager/Makefile b/tools/vtpm_manager/Makefile > deleted file mode 100644 > index 632f41b..0000000 > --- a/tools/vtpm_manager/Makefile > +++ /dev/null > @@ -1,18 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../.. > - > -# Base definitions and rules > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -SUBDIRS = crypto tcs util manager migration > -OPENSSL_HEADER = /usr/include/openssl/crypto.h > - > -.PHONY: all clean install > -all clean install: %: subdirs-% > - > -.PHONY: mrproper > -mrproper: > - @set -e; for subdir in $(SUBDIRS); do \ > - $(MAKE) -C $$subdir $@; \ > - done > - > - > diff --git a/tools/vtpm_manager/README b/tools/vtpm_manager/README > deleted file mode 100644 > index f0d1e98..0000000 > --- a/tools/vtpm_manager/README > +++ /dev/null > @@ -1,94 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -Directory Structure > -=================== > -tools/vtpm_manager/crypto -> crypto files > -tools/vtpm_manager/TCS -> TCS implementation > -tools/vtpm_manager/util -> Utility Library. Include disk-io and buffers. > -tools/vtpm_manager/manager -> VTPM Manager > - > -Compile Flags > -=================== > -LOGGING_MODULES -> How extensive logging happens > - see util/log.h for more info > - > -VTPM_MULTI_VM -> Defined: VTPMs run in their own VMs > - Not Defined (default): VTPMs are processes > - > -# Debugging flags that may disappear without notice in the future > - > -DUMMY_BACKEND -> vtpm_manager listens on /tmp/in.fifo and > - /tmp/out.fifo rather than backend > - > -MANUAL_DM_LAUNCH -> Must manually launch & kill VTPMs > - > -WELL_KNOWN_OWNER_AUTH -> Rather than randomly generating the password for the owner, > - use a well known value. This is useful for debugging and for > - poor bios which do not support clearing TPM if OwnerAuth is > - lost. However this has no protection from malicious app > - issuing a TPM_OwnerClear to wipe the TPM > - > -Requirements > -============ > -- xen-unstable > -- vtpm frontend/backend driver patch > -- OpenSSL Library > - > -Single-VM Flow > -============================ > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > -- VTPM Manager listens to TPM BE. > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > -- When the manager receives the open message from the BE, it launches a vtpm > -- Xend allows the VM to continue booting. > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > -- The fifo listener begins listening for the reply from vtpm for the request. > -- Vtpm processes request and replies to manager over shared named fifo. > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > - > -NOTES: > -* SaveService SHOULD seal it's table before saving it to disk. However, > - the current Xen infrastructure does not provide a mechanism for this to be > - unsealed later. Specifically, the auth and wrapped key must be available ONLY > - to the service, or it's not even worth encrypting > - > - In the future the vtpm manager will be protected by an early boot mechanism > - that will allow for better protection of it's data. > - > -TODO: > -- Timeout on crashed vtpms > -- create lock for shared fifo for talking to vtpms. > diff --git a/tools/vtpm_manager/Rules.mk b/tools/vtpm_manager/Rules.mk > deleted file mode 100644 > index 651772b..0000000 > --- a/tools/vtpm_manager/Rules.mk > +++ /dev/null > @@ -1,59 +0,0 @@ > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > -include $(XEN_ROOT)/tools/Rules.mk > - > -# > -# Tool definitions > -# > - > -# General compiler flags > -CFLAGS = -Werror -g3 > - > -# Generic project files > -HDRS = $(wildcard *.h) > -SRCS = $(wildcard *.c) > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > - > -# Generic (non-header) dependencies > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -$(OBJS): $(SRCS) > - > --include $(FILES) > - > -# Make sure these are just rules > -.PHONY : all build install clean > - > -# > -# Project-specific definitions > -# > - > -# Need UNIX98 spec for pthread rwlocks > -CFLAGS += -D_GNU_SOURCE > - > -# Logging Level. See utils/tools.h for usage > -CFLAGS += -DLOGGING_MODULES="(BITMASK(VTPM_LOG_TCS)|BITMASK(VTPM_LOG_VTSP)|BITMASK(VTPM_LOG_VTPM))" > - > -# Silent Mode > -#CFLAGS += -DLOGGING_MODULES=0x0 > -#CFLAGS += -DLOGGING_MODULES=0xff > - > -# Use frontend/backend pairs between manager & DMs? > -#CFLAGS += -DVTPM_MULTI_VM > - > -# vtpm_manager listens on fifo's rather than backend > -#CFLAGS += -DDUMMY_BACKEND > - > -# TCS talks to fifo's rather than /dev/tpm. TPM Emulator assumed on fifos > -#CFLAGS += -DDUMMY_TPM > - > -# Do not have manager launch DMs. > -#CFLAGS += -DMANUAL_DM_LAUNCH > - > -# Fixed OwnerAuth > -#CFLAGS += -DWELL_KNOWN_OWNER_AUTH > - > -# Include > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/crypto > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/util > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/tcs > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/manager > diff --git a/tools/vtpm_manager/crypto/Makefile b/tools/vtpm_manager/crypto/Makefile > deleted file mode 100644 > index 13b61c9..0000000 > --- a/tools/vtpm_manager/crypto/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libtcpaCrypto.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/crypto/crypto.c b/tools/vtpm_manager/crypto/crypto.c > deleted file mode 100644 > index 7dae655..0000000 > --- a/tools/vtpm_manager/crypto/crypto.c > +++ /dev/null > @@ -1,88 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// crypto.c > -// > -// This file will handle all the TPM Crypto functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include "crypto.h" > -#include "log.h" > - > -/** > - * Initialize cryptography library > - * @rand: random seed > - * @size: size of @rand > - */ > -void Crypto_Init(const BYTE* rand, int size) { > - ERR_load_crypto_strings(); > - CRYPTO_malloc_init(); > - OpenSSL_add_all_algorithms(); > - SYM_CIPHER = EVP_aes_128_cbc(); > - RAND_poll(); > - if (rand == NULL) > - return; > - > - RAND_add(rand, size, size); > -} > - > -/** > - * Shutdown cryptography library > - */ > -void Crypto_Exit() { > - ERR_free_strings(); > - ERR_remove_state(0); > - EVP_cleanup(); > -} > - > - > -/** > - * Get random data > - * @data: (OUT) Random data > - * @size: Size of @data > - */ > -void Crypto_GetRandom(void* data, int size) { > - int result; > - > - result = RAND_pseudo_bytes((BYTE*) data, size); > - > - if (result <= 0) > - vtpmlogerror (VTPM_LOG_CRYPTO, "RAND_pseudo_bytes failed: %s\n", > - ERR_error_string (ERR_get_error(), NULL)); > -} > diff --git a/tools/vtpm_manager/crypto/crypto.h b/tools/vtpm_manager/crypto/crypto.h > deleted file mode 100644 > index 488d4d6..0000000 > --- a/tools/vtpm_manager/crypto/crypto.h > +++ /dev/null > @@ -1,175 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// crypto.h > -// > -// This file defines the TPM Crypto API > -// > -// ================================================================== > - > -#ifndef __CRYPTO_H__ > -#define __CRYPTO_H__ > - > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "sym_crypto.h" > - > -#define CRYPTO_MAX_SIG_SIZE (2048 / 8) > -#define CRYPTO_MAX_RSA_KEY_SIZE (4096 / 8) //in bytes > - > -#define OAEP_P "TCPA" > -#define OAEP_P_SIZE 4 > - > -// Algorithms supported by crypto. Stored in CRYPTO_INFO.algorithmID > -#define CRYPTO_ALGORITH_RSA 0x01 > - > -// Supported Encryption Schemes CRYPTO_INFO.encScheme > -#define CRYPTO_ES_NONE 0x0001 > -#define CRYPTO_ES_RSAESPKCSv15 0x0002 > -#define CRYPTO_ES_RSAESOAEP_SHA1_MGF1 0x0003 > - > -// Supported Signature schemes CRYPTO_INFO.sigScheme > -#define CRYPTO_SS_NONE 0x0001 > -#define CRYPTO_SS_RSASSAPKCS1v15_SHA1 0x0002 > -#define CRYPTO_SS_RSASSAPKCS1v15_DER 0x0003 > - > -typedef struct CRYPTO_INFO { > - void *keyInfo; > - UINT32 algorithmID; > - UINT32 encScheme; > - UINT32 sigScheme; > -} CRYPTO_INFO; > - > - > -void Crypto_Init(const BYTE* rand, int size); > - > -void Crypto_Exit(); > - > -void Crypto_GetRandom(void* data, int size); > - > -void Crypto_HMAC( const BYTE* text, > - int text_len, > - const BYTE* key, > - int key_len, > - BYTE* digest); > - > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > - const buffer_t * key, > - BYTE * o_digest); /* presumably of 20 bytes */ > - > -void Crypto_SHA1Full( const BYTE* text, > - UINT32 size, > - BYTE* hash); //Complete 3part SHA1 > - > -// o_hash needs to be large enough to hold the digest, ie 20 bytes > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > - BYTE * o_hash); > - > -void Crypto_SHA1Start(UINT32* maxNumBytes); > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData); > -void Crypto_SHA1Complete( int hashDataSize, > - const BYTE* hashData, > - BYTE* hashValue); > - > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > - /*in*/ UINT32 pubExpSize, > - /*in*/ BYTE *pubExp, > - /*out*/ UINT32 *privExpSize, > - /*out*/ BYTE *privExp, > - /*out*/ UINT32 *modulusSize, > - /*out*/ BYTE *modulus, > - /*out*/ CRYPTO_INFO *keys); > - > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 privExpSize, > - /*[IN]*/ BYTE *privExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - /*[OUT]*/ CRYPTO_INFO* cryptoInfo); > - > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo); > - > -// > -// symmetric pack and unpack operations > -// > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > - BYTE ** io_buf, UINT32 * io_buflen); > - > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > - BYTE * in, UINT32 len, > - UINT32 * o_lenread); > - > - > -// return 0 on success, -1 on error > -int Crypto_RSAEnc( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData); > - > -// return 0 on success, -1 on error > -int Crypto_RSADec( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData); > - > -// return 0 on success, -1 on error > -int Crypto_RSASign( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *sigSize, > - /*out*/ BYTE *sig); > - > -bool Crypto_RSAVerify( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - UINT32 sigSize, > - BYTE *sig); > - > -//private: > -int RSA_verify_DER(int dtype, unsigned char *m, unsigned int m_len, > - unsigned char *sigbuf, unsigned int siglen, CRYPTO_INFO *key); > - > -int RSA_sign_DER(int type, unsigned char *m, unsigned int m_len, > - unsigned char *sigret, unsigned int *siglen, CRYPTO_INFO *key); > - > -#endif // __CRYPTO_H__ > diff --git a/tools/vtpm_manager/crypto/hash.c b/tools/vtpm_manager/crypto/hash.c > deleted file mode 100644 > index c73114a..0000000 > --- a/tools/vtpm_manager/crypto/hash.c > +++ /dev/null > @@ -1,153 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// hash.c > -// > -// This file will handle all the TPM Hash functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" // for TPM_SUCCESS > -#include "crypto.h" > - > -static SHA_CTX g_shaContext; > - > -void Crypto_HMAC( const BYTE* text, > - int text_len, > - const BYTE* key, > - int key_len, > - BYTE* digest) { > - if (text == NULL || key == NULL || text_len == 0 || key_len == 0) > - return; > - > - HMAC(EVP_sha1(), key, key_len, text, text_len, digest, NULL); > -} > - > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > - const buffer_t * key, > - BYTE * o_digest) { /* presumably of 20 bytes */ > - > - Crypto_HMAC (text->bytes, text->size, > - key->bytes, key->size, > - o_digest); > - > - return TPM_SUCCESS; > -} > - > - > -/* > - * SHA1 > - * (OUT) Create a SHA1 hash of text. Calls all three SHA1 steps internally > - */ > -void Crypto_SHA1Full( const BYTE* text, > - uint32_t size, > - BYTE* hash) { > - > - if (text == NULL || size == 0) > - return; > - > - // Run SHA1Start + SHAUpdate (if necessary) + SHAComplete > - uint32_t maxBytes; // Not used for anything > - Crypto_SHA1Start(&maxBytes); > - > - while (size > 64){ > - Crypto_SHA1Update(64, text); > - size -= 64; > - text += 64; > - } > - > - Crypto_SHA1Complete(size, text, hash); > -} > - > -// same thing using buffer_t > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > - BYTE * o_digest) { > - > - if (buf->bytes == NULL || buf->size == 0) > - return TPM_BAD_PARAMETER; > - > - Crypto_SHA1Full (buf->bytes, buf->size, o_digest); > - > - return TPM_SUCCESS; > -} > - > - > -/* > - * Initialize SHA1 > - * (OUT) Maximum number of bytes that can be sent to SHA1Update. > - * Must be a multiple of 64 bytes. > - */ > -void Crypto_SHA1Start(uint32_t* maxNumBytes) { > - int max = SHA_CBLOCK; > - // Initialize the crypto library > - SHA1_Init(&g_shaContext); > - *maxNumBytes = max; > -} > - > -/* > - * Process SHA1 > - * @numBytes: (IN) The number of bytes in hashData. > - * Must be a multiple of 64 bytes. > - * @hashData: (IN) Bytes to be hashed. > - */ > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData) { > - > - if (hashData == NULL || numBytes == 0 || numBytes%64 != 0) > - return; > - > - SHA1_Update(&g_shaContext, hashData, numBytes); > -} > - > -/* > - * Complete the SHA1 process > - * @hashDataSize: (IN) Number of bytes in hashData. > - * Must be a multiple of 64 bytes. > - * @hashData: (IN) Final bytes to be hashed. > - * @hashValue: (OUT) The output of the SHA-1 hash. > - */ > -void Crypto_SHA1Complete(int hashDataSize, > - const BYTE* hashData, > - BYTE* hashValue) { > - SHA1_Update(&g_shaContext, hashData, hashDataSize); > - SHA1_Final(hashValue, &g_shaContext); > -} > diff --git a/tools/vtpm_manager/crypto/rsa.c b/tools/vtpm_manager/crypto/rsa.c > deleted file mode 100644 > index 7737dc6..0000000 > --- a/tools/vtpm_manager/crypto/rsa.c > +++ /dev/null > @@ -1,434 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// rsa.c > -// > -// This file will handle all the TPM RSA crypto functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "crypto.h" > -#include "log.h" > - > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > - /*in*/ UINT32 pubExpSize, > - /*in*/ BYTE *pubExp, > - /*out*/ UINT32 *privExpSize, > - /*out*/ BYTE *privExp, > - /*out*/ UINT32 *modulusSize, > - /*out*/ BYTE *modulus, > - /*out*/ CRYPTO_INFO *keys) { > - unsigned long e_value; > - > - if (pubExpSize == 0) // Default e = 2^16+1 > - e_value = (0x01 << 16) + 1; > - else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - e_value = (0x01 << 16) + 1; > - } > - > - RSA *rsa = RSA_generate_key(keySize, e_value, NULL, NULL); > - > - if (keys) { > - keys->keyInfo = rsa; > - keys->algorithmID = CRYPTO_ALGORITH_RSA; > - } > - > - if (modulus) *modulusSize = BN_bn2bin(rsa->n, modulus); > - if (privExp) *privExpSize = BN_bn2bin(rsa->d, privExp); > -} > - > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > -// If pubExp info is NULL, use TCG default. > -// If there is a remainder while calculating the privExp, return FALSE. > - > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 privExpSize, > - /*[IN]*/ BYTE *privExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo) { > - cryptoInfo->keyInfo = RSA_new(); > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - rsa->e = BN_new(); > - > - if (pubExpSize == 0) { // Default e = 2^16+1 > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } > - > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > - rsa->d = BN_bin2bn(privExp, privExpSize, NULL); > -} > - > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > -// If pubExp info is NULL, use TCG default. > -// If there is a remainder while calculating the privExp, return FALSE. > - > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo) { > - cryptoInfo->keyInfo = RSA_new(); > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - rsa->e = BN_new(); > - > - if (pubExpSize == 0) { // Default e = 2^16+1 > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } > - > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > - > -} > - > -int Crypto_RSAEnc( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData) { > - RSA *rsa = (RSA *) key->keyInfo; > - UINT32 paddedDataSize = RSA_size (rsa); > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > - int rc; > - > - if (paddedData == NULL) > - return -1; > - > - *outDataSize = 0; > - > - switch (key->encScheme) { > - case CRYPTO_ES_RSAESPKCSv15: > - if (RSA_padding_add_PKCS1_type_2(paddedData, paddedDataSize, inData, inDataSize) <= 0) { > - rc = -1; > - goto abort_egress; > - } > - break; > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > - if (RSA_padding_add_PKCS1_OAEP(paddedData,paddedDataSize,inData,inDataSize, (BYTE *) OAEP_P,OAEP_P_SIZE) <= 0 ) { > - rc = -1; > - goto abort_egress; > - } > - break; > - default: > - rc = -1; > - goto abort_egress; > - } > - > - rc = RSA_public_encrypt(paddedDataSize, paddedData, outData, rsa, RSA_NO_PADDING); > - if (rc == -1) > - goto abort_egress; > - > - *outDataSize = rc; > - > - if (rc > 0) rc = 0; > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (paddedData) > - free (paddedData); > - return rc; > - > -} > - > -int Crypto_RSADec( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData) { > - > - RSA *rsa = (RSA *) key->keyInfo; > - UINT32 paddedDataSize = RSA_size (rsa); > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > - int rc; > - > - if (paddedData == NULL) > - goto abort_egress; > - > - rc = RSA_private_decrypt(inDataSize, inData, paddedData, rsa, RSA_NO_PADDING); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_private_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - > - paddedDataSize = rc; > - > - switch (key->encScheme) { > - case CRYPTO_ES_RSAESPKCSv15: > - rc = RSA_padding_check_PKCS1_type_2 (outData, paddedDataSize, > - paddedData + 1, paddedDataSize - 1, > - RSA_size(rsa)); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_type_2: %s\n", > - ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - *outDataSize = rc; > - break; > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > - rc = RSA_padding_check_PKCS1_OAEP(outData, paddedDataSize, > - paddedData + 1, paddedDataSize - 1, > - RSA_size(rsa), > - (BYTE *) OAEP_P, OAEP_P_SIZE); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_OAEP: %s\n", > - ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - *outDataSize = rc; > - break; > - default: > - *outDataSize = 0; > - } > - > - free(paddedData); paddedData = NULL; > - goto egress; > - > - abort_egress: > - > - if (paddedData) > - free (paddedData); > - return -1; > - > - egress: > - return 0; > -} > - > -// Signs either a SHA1 digest of a message or a DER encoding of a message > -// Textual messages MUST be encoded or Hashed before sending into this function > -// It will NOT SHA the message. > -int Crypto_RSASign( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *sigSize, > - /*out*/ BYTE *sig) { > - int status; > - unsigned int intSigSize; > - > - switch(key->sigScheme) { > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > - status = RSA_sign(NID_sha1, inData, inDataSize, sig, &intSigSize, (RSA *) key->keyInfo); > - break; > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > - // status = Crypto_RSA_sign_DER(NID_md5_sha1, inData, inDataSize, sig, &intSigSize, key); > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > - status = 0; > - break; > - default: > - status = 0; > - } > - > - if (status == 0) { > - *sigSize = 0; > - vtpmlogerror(VTPM_LOG_CRYPTO, "%s\n", ERR_error_string(ERR_get_error(), NULL)); > - return -1; > - } > - > - *sigSize = (UINT32) intSigSize; > - return 0; > -} > - > -bool Crypto_RSAVerify( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - UINT32 sigSize, > - BYTE *sig) { > - int status; > - > - switch(key->sigScheme){ > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > - status = RSA_verify(NID_sha1, inData, inDataSize, sig, sigSize, (RSA *) key->keyInfo); > - break; > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > - //status = Crypto_RSA_verify_DER(NID_md5_sha1, inData, inDataSize, sig, sigSize, key); > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > - status = 0; > - break; > - default: > - status = 0; > - } > - > - if (status) > - return(1); > - else { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA verify: %s\n", ERR_error_string(ERR_get_error(), NULL)); > - return(0); > - } > - > -} > - > -// helper which packs everything into a BIO! > - > -// packs the parameters first, then the private key, then the public key > -// if *io_buf is NULL, allocate it here as needed. otherwise its size is in > -// *io_buflen > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > - BYTE ** io_buf, UINT32 * io_buflen) { > - TPM_RESULT status = TPM_SUCCESS; > - BYTE * buf; > - long len, outlen = *io_buflen; > - > - const long PARAMSLEN = 3*sizeof(UINT32); > - > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - BIO *mem = BIO_new(BIO_s_mem()); > - > - > - // write the openssl keys to the BIO > - if ( i2d_RSAPrivateKey_bio (mem, rsa) == 0 ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_SIZE); > - } > - if ( i2d_RSAPublicKey_bio (mem, rsa) == 0 ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_SIZE); > - } > - > - // get the buffer out > - len = BIO_get_mem_data (mem, &buf); > - > - // see if we need to allocate a return buffer > - if (*io_buf == NULL) { > - *io_buf = (BYTE*) malloc (PARAMSLEN + len); > - if (*io_buf == NULL) > - ERRORDIE (TPM_SIZE); > - } else { // *io_buf is already allocated > - if (outlen < len + PARAMSLEN) > - ERRORDIE (TPM_SIZE); // but not large enough! > - } > - > - // copy over the parameters (three UINT32's starting at algorithmID) > - memcpy (*io_buf, &cryptoInfo->algorithmID, PARAMSLEN); > - > - // copy over the DER keys > - memcpy (*io_buf + PARAMSLEN, buf, len); > - > - *io_buflen = len + PARAMSLEN; > - > - goto egress; > - > - > - abort_egress: > - egress: > - > - BIO_free (mem); > - > - return status; > -} > - > - > - > -// sets up ci, and returns the number of bytes read in o_lenread > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > - BYTE * in, UINT32 len, > - UINT32 * o_lenread) { > - > - TPM_RESULT status = TPM_SUCCESS; > - long l; > - BIO *mem; > - RSA *rsa; > - > - // first load up the params > - l = 3 * sizeof(UINT32); > - memcpy (&ci->algorithmID, in, l); > - len -= l; > - in += l; > - > - // and now the openssl keys, private first > - mem = BIO_new_mem_buf (in, len); > - > - if ( (rsa = d2i_RSAPrivateKey_bio (mem, NULL)) == NULL ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_BAD_PARAMETER); > - } > - // now use the same RSA object and fill in the private key > - if ( d2i_RSAPublicKey_bio (mem, &rsa) == NULL ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_BAD_PARAMETER); > - } > - > - ci->keyInfo = rsa; // needs to be freed somehow later > - > - // FIXME: havent figured out yet how to tell how many bytes were read in the > - // above oprations! so o_lenread is not set > - > - goto egress; > - > - abort_egress: > - egress: > - > - BIO_free (mem); > - > - return status; > -} > diff --git a/tools/vtpm_manager/crypto/sym_crypto.c b/tools/vtpm_manager/crypto/sym_crypto.c > deleted file mode 100644 > index 3d86e19..0000000 > --- a/tools/vtpm_manager/crypto/sym_crypto.c > +++ /dev/null > @@ -1,237 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// sym_crypto.c > -// > -// Symmetric crypto portion of crypto > -// > -// ================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "sym_crypto.h" > - > -typedef enum crypt_op_type_t { > - CRYPT_ENCRYPT, > - CRYPT_DECRYPT > -} crypt_op_type_t; > - > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > - const buffer_t* in, > - const buffer_t* iv, > - buffer_t * out, > - crypt_op_type_t optype); > - > - > -// this is initialized in Crypto_Init() > -const EVP_CIPHER * SYM_CIPHER = NULL; > - > -const BYTE ZERO_IV[EVP_MAX_IV_LENGTH] = {0}; > - > - > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits) { > - TPM_RESULT status = TPM_SUCCESS; > - > - EVP_CIPHER_CTX_init (&key->context); > - > - key->cipher = SYM_CIPHER; > - > - TPMTRYRETURN( buffer_init_copy (&key->key, keybits)); > - > - goto egress; > - > - abort_egress: > - EVP_CIPHER_CTX_cleanup (&key->context); > - > - egress: > - > - return status; > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key) { > - int res; > - TPM_RESULT status = TPM_SUCCESS; > - > - // hmm, EVP_CIPHER_CTX_init does not return a value > - EVP_CIPHER_CTX_init (&key->context); > - > - key->cipher = SYM_CIPHER; > - > - TPMTRYRETURN( buffer_init (&key->key, EVP_CIPHER_key_length(key->cipher), NULL)) ; > - > - // and generate the key material > - res = RAND_pseudo_bytes (key->key.bytes, key->key.size); > - if (res < 0) > - ERRORDIE (TPM_SHORTRANDOM); > - > - > - goto egress; > - > - abort_egress: > - EVP_CIPHER_CTX_cleanup (&key->context); > - buffer_free (&key->key); > - > - egress: > - return status; > -} > - > - > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > - const buffer_t* clear, > - buffer_t* o_cipher) { > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t iv, cipher_alias; > - > - buffer_init_const (&iv, EVP_MAX_IV_LENGTH, ZERO_IV); > - > - buffer_init (o_cipher, > - clear->size + > - EVP_CIPHER_iv_length(key->cipher) + > - EVP_CIPHER_block_size (key->cipher), > - 0); > - > - // copy the IV into the front > - buffer_copy (o_cipher, &iv); > - > - // make an alias into which we'll put the ciphertext > - buffer_init_alias (&cipher_alias, o_cipher, EVP_CIPHER_iv_length(key->cipher), 0); > - > - TPMTRYRETURN( ossl_symcrypto_op (key, clear, &iv, &cipher_alias, CRYPT_ENCRYPT) ); > - > - // set the output size correctly > - o_cipher->size += cipher_alias.size; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > - > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > - const buffer_t* cipher, > - buffer_t* o_clear) { > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t iv, cipher_alias; > - > - // alias for the IV > - buffer_init_alias (&iv, cipher, 0, EVP_CIPHER_iv_length(key->cipher)); > - > - // make an alias to where the ciphertext is, after the IV > - buffer_init_alias (&cipher_alias, cipher, EVP_CIPHER_iv_length(key->cipher), 0); > - > - // prepare the output buffer > - TPMTRYRETURN( buffer_init (o_clear, > - cipher->size > - - EVP_CIPHER_iv_length(key->cipher) > - + EVP_CIPHER_block_size(key->cipher), > - 0) ); > - > - // and decrypt > - TPMTRYRETURN ( ossl_symcrypto_op (key, &cipher_alias, &iv, o_clear, CRYPT_DECRYPT) ); > - > - goto egress; > - > - abort_egress: > - buffer_free (o_clear); > - > - egress: > - > - return status; > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key) { > - buffer_memset (&key->key, 0); > - buffer_free (&key->key); > - > - EVP_CIPHER_CTX_cleanup (&key->context); > - > - return TPM_SUCCESS; > -} > - > - > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > - const buffer_t* in, > - const buffer_t* iv, > - buffer_t * out, > - crypt_op_type_t optype) { > - TPM_RESULT status = TPM_SUCCESS; > - > - int inlen, outlen; > - tpm_size_t running; > - > - if ( ! EVP_CipherInit_ex (&key->context, > - key->cipher, NULL, key->key.bytes, iv->bytes, > - optype == CRYPT_ENCRYPT ? 1 : 0) ) > - ERRORDIE (TPM_FAIL); > - > - > - > - inlen = in->size; > - > - outlen = 0; > - running = 0; > - > - > - if ( ! EVP_CipherUpdate (&key->context, out->bytes, &outlen, in->bytes, inlen) ) > - ERRORDIE (TPM_FAIL); > - > - running += outlen; > - > - if ( ! EVP_CipherFinal_ex (&key->context, out->bytes + running, &outlen) ) > - ERRORDIE (TPM_FAIL); > - > - running += outlen; > - > - out->size = running; > - > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/crypto/sym_crypto.h b/tools/vtpm_manager/crypto/sym_crypto.h > deleted file mode 100644 > index 7fb59a8..0000000 > --- a/tools/vtpm_manager/crypto/sym_crypto.h > +++ /dev/null > @@ -1,72 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// sym_crypto.h > -// > -// Symmetric Crypto > -// > -// ================================================================== > - > -#ifndef _SYM_CRYPTO_H > -#define _SYM_CRYPTO_H > - > -#include > -#include "buffer.h" > - > -typedef struct symkey_t { > - buffer_t key; > - > - EVP_CIPHER_CTX context; > - const EVP_CIPHER * cipher; > -} symkey_t; > - > -extern const EVP_CIPHER * SYM_CIPHER; > - > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key); > - > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits); > - > - > -// these functions will allocate their output buffers > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > - const buffer_t* clear, > - buffer_t* o_cipher); > - > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > - const buffer_t* cipher, > - buffer_t* o_clear); > - > -// only free the internal parts, not the 'key' ptr > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key); > - > -#endif /* _SYM_CRYPTO_H */ > diff --git a/tools/vtpm_manager/manager/Makefile b/tools/vtpm_manager/manager/Makefile > deleted file mode 100644 > index a33c18a..0000000 > --- a/tools/vtpm_manager/manager/Makefile > +++ /dev/null > @@ -1,38 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = vtpm_managerd > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - if [ ! -d "$(DESTDIR)/var/vtpm/fifos" ]; \ > - then mkdir -p $(DESTDIR)/var/vtpm/fifos; \ > - fi > - if [ ! -d "$(DESTDIR)/var/vtpm/socks" ]; \ > - then mkdir -p $(DESTDIR)/var/vtpm/socks; \ > - fi > - $(INSTALL_PROG) $(BIN) $(DESTDIR)$(BINDIR) > - > -.PHONY: clean > -clean: > - rm -f $(BIN) > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -# libraries > -LIBS += ../tcs/libTCS.a ../util/libTCGUtils.a ../crypto/libtcpaCrypto.a > -LIBS += -lcrypto $(PTHREAD_LIBS) -lm > -CFLAGS += $(PTHREAD_CFLAGS) > -LDFLAGS += $(PTHREAD_LDFLAGS) > diff --git a/tools/vtpm_manager/manager/dmictl.c b/tools/vtpm_manager/manager/dmictl.c > deleted file mode 100644 > index 5c3cf7e..0000000 > --- a/tools/vtpm_manager/manager/dmictl.c > +++ /dev/null > @@ -1,266 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// dmictl.c > -// > -// Functions for creating and destroying DMIs > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpmpriv.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "log.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "vtpm_ipc.h" > - > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > - > -// if dmi_res is non-null, then return a pointer to new object. > -// Also, this does not fill in the measurements. They should be filled by > -// design dependent code or saveNVM > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE dmi_type, VTPM_DMI_RESOURCE **dmi_res) { > - > - TPM_RESULT status=TPM_SUCCESS; > - VTPM_DMI_RESOURCE *new_dmi=NULL; > - UINT32 *dmi_id_key=NULL; > - > - if ((new_dmi = (VTPM_DMI_RESOURCE *) malloc (sizeof(VTPM_DMI_RESOURCE))) == NULL) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - memset(new_dmi, 0, sizeof(VTPM_DMI_RESOURCE)); > - new_dmi->dmi_id = dmi_id; > - new_dmi->dmi_type = dmi_type; > - new_dmi->connected = FALSE; > - new_dmi->TCSContext = 0; > - > - new_dmi->NVMLocation = (char *) malloc(11 + strlen(DMI_NVM_FILE)); > - sprintf(new_dmi->NVMLocation, DMI_NVM_FILE, (uint32_t) new_dmi->dmi_id); > - > - if ((dmi_id_key = (UINT32 *) malloc (sizeof(UINT32))) == NULL) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - *dmi_id_key = new_dmi->dmi_id; > - > - // install into map > - if (!hashtable_insert(vtpm_globals->dmi_map, dmi_id_key, new_dmi)){ > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to insert instance into table. Aborting.\n", dmi_id); > - status = TPM_FAIL; > - goto abort_egress; > - } > - > - if (dmi_res) > - *dmi_res = new_dmi; > - > - goto egress; > - > - abort_egress: > - if (new_dmi) { > - free(new_dmi->NVMLocation); > - free(new_dmi); > - } > - free(dmi_id_key); > - > - egress: > - return status; > -} > - > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res) { > - if (dmi_res == NULL) > - return TPM_SUCCESS; > - > - if (dmi_res->dmi_id == VTPM_CTL_DM) > - return(TPM_BAD_PARAMETER); > - > - TCS_CloseContext(dmi_res->TCSContext); > - dmi_res->connected = FALSE; > - > - vtpm_globals->connected_dmis--; > - > - return (VTPM_Close_DMI_Extra(dmi_res) ); > -} > - > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf) { > - > - VTPM_DMI_RESOURCE *new_dmi=NULL; > - TPM_RESULT status=TPM_FAIL; > - BYTE dmi_type, vm_type, startup_mode; > - UINT32 dmi_id; > - > - if (param_buf == NULL) { // Assume creation of Dom 0 control > - dmi_type = VTPM_TYPE_NON_MIGRATABLE; > - dmi_id = VTPM_CTL_DM; > - } else if (buffer_len(param_buf) != sizeof(BYTE) * 3 + sizeof(UINT32)) { > - vtpmloginfo(VTPM_LOG_VTPM, "New DMI command wrong length: %d.\n", buffer_len(param_buf)); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } else { > - vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0 > - BSG_UnpackList( param_buf->bytes, 4, > - BSG_TYPE_BYTE, &dmi_type, > - BSG_TYPE_BYTE, &startup_mode, > - BSG_TYPE_BYTE, &vm_type, > - BSG_TYPE_UINT32, &dmi_id); > - } > - > - if ((dmi_type != VTPM_TYPE_NON_MIGRATABLE) && (dmi_type != VTPM_TYPE_MIGRATABLE)) { > - vtpmlogerror(VTPM_LOG_VTPM, "Creation of VTPM with illegal type.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - new_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (new_dmi == NULL) { > - vtpmloginfo(VTPM_LOG_VTPM, "Creating new DMI instance %d attached.\n", dmi_id ); > - // Brand New DMI. Initialize the persistent pieces > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &new_dmi) ); > - } else > - vtpmloginfo(VTPM_LOG_VTPM, "Re-attaching DMI instance %d.\n", dmi_id); > - > - if (new_dmi->connected) { > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach, currently attached instance %d. Ignoring\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (new_dmi->dmi_type == VTPM_TYPE_MIGRATED) { > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach previously migrated instance %d without recovering first. Ignoring\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Initialize the Non-persistent pieces > - TPMTRYRETURN( TCS_OpenContext(&new_dmi->TCSContext) ); > - > - new_dmi->connected = TRUE; > - > - // Design specific new DMI code. > - // Includes: create IPCs, Measuring DMI, and maybe launching DMI > - TPMTRYRETURN(VTPM_New_DMI_Extra(new_dmi, vm_type, startup_mode) ); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create DMI id=%d due to status=%s. Cleaning.\n", dmi_id, tpm_get_error_name(status)); > - close_dmi(new_dmi ); > - > - egress: > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Close_DMI( const buffer_t *param_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *dmi_res=NULL; > - UINT32 dmi_id; > - > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size."); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - BSG_UnpackList( param_buf->bytes, 1, > - BSG_TYPE_UINT32, &dmi_id); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Closing DMI %d.\n", dmi_id); > - > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (dmi_res == NULL ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Trying to close nonexistent DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (!dmi_res->connected) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-connected DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Close Dmi > - TPMTRYRETURN(close_dmi( dmi_res )); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Delete_DMI( const buffer_t *param_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *dmi_res=NULL; > - UINT32 dmi_id; > - > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - BSG_UnpackList( param_buf->bytes, 1, > - BSG_TYPE_UINT32, &dmi_id); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Deleting DMI %d.\n", dmi_id); > - > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_remove(vtpm_globals->dmi_map, &dmi_id); > - if (dmi_res == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-existent DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - //vtpm scripts delete file dmi_res->NVMLocation for us > - > - // Close DMI first > - TPMTRYRETURN(close_dmi( dmi_res )); > - free ( dmi_res ); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/manager/migration.c b/tools/vtpm_manager/manager/migration.c > deleted file mode 100644 > index 54da708..0000000 > --- a/tools/vtpm_manager/manager/migration.c > +++ /dev/null > @@ -1,307 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// dmictl.c > -// > -// Functions for creating and destroying DMIs > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpmpriv.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "log.h" > -#include "hashtable.h" > - > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *mig_dmi=NULL; > - UINT32 dmi_id; > - buffer_t dmi_state_abuf = NULL_BUF, enc_dmi_abuf = NULL_BUF, clear_dmi_blob = NULL_BUF; > - > - if (param_buf == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - struct pack_buf_t enc_dmi_state_pack; > - > - BSG_UnpackList(param_buf->bytes, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_SIZE32_DATA, &enc_dmi_state_pack) ; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating VTPM in dmi %d.\n", dmi_id); > - > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (mig_dmi) { > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming VTPM claims unavailable id: %d.\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** UnBind Blob **/ > - TPMTRYRETURN( buffer_init_alias_convert( &enc_dmi_abuf, > - enc_dmi_state_pack.size, > - enc_dmi_state_pack.data) ); > - > - TPMTRYRETURN( envelope_decrypt( &enc_dmi_abuf, > - vtpm_globals->manager_tcs_handle, > - vtpm_globals->storageKeyHandle, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - &clear_dmi_blob) ); > - > - // Create new dmi > - TPMTRYRETURN( init_dmi(dmi_id, VTPM_TYPE_MIGRATABLE, &mig_dmi ) ); > - > - /** Open Blob **/ > - struct pack_buf_t dmi_state_pack; > - > - BSG_UnpackList(clear_dmi_blob.bytes, 2, > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > - > - TPMTRYRETURN( buffer_init_alias_convert(&dmi_state_abuf, > - dmi_state_pack.size, > - dmi_state_pack.data) ); > - > - TPMTRYRETURN( VTPM_Handle_Save_NVM(mig_dmi, &dmi_state_abuf, NULL ) ); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration IN of instance %d failed because of %s.\n", dmi_id, tpm_get_error_name(status) ); > - > - egress: > - buffer_free(&clear_dmi_blob); > - buffer_free(&dmi_state_abuf); > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Migrate_Out( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *mig_dmi; > - UINT32 dmi_id; > - VTPM_MIGKEY_LIST *last_mig, *mig_key; > - buffer_t dmi_state=NULL_BUF, clear_dmi_blob=NULL_BUF; > - > - if (param_buf == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - struct pack_buf_t name_pack; > - > - BSG_UnpackList( param_buf->bytes, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_SIZE32_DATA, &name_pack); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating out dmi %d.\n", dmi_id); > - > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (mig_dmi == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Non-existent VTPM instance (%d) in migration.\n", dmi_id ); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (mig_dmi->dmi_type != VTPM_TYPE_MIGRATABLE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Bad VTPM type (%d) in migration of instance (%d).\n", mig_dmi->dmi_type, dmi_id ); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** Find migration key for dest **/ > - last_mig = NULL; > - mig_key = vtpm_globals->mig_keys; > - while (mig_key != NULL) { > - if (mig_key->name_size == name_pack.size) > - if (memcmp(mig_key->name, name_pack.data, name_pack.size) == 0) { > - break; > - } > - > - last_mig = mig_key; > - mig_key = mig_key->next; > - } > - > - if (!mig_key) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unknown Migration target host.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** Mark vtpm as migrated **/ > - mig_dmi->dmi_type = VTPM_TYPE_MIGRATED; > - > - /** Build Blob **/ > - TPMTRYRETURN( VTPM_Handle_Load_NVM(mig_dmi, NULL, &dmi_state) ); > - > - TPMTRYRETURN( buffer_init(&clear_dmi_blob, sizeof(TPM_DIGEST) + sizeof(UINT32) + buffer_len(&dmi_state), NULL ) ); > - > - struct pack_constbuf_t dmi_state_pack; > - > - dmi_state_pack.size = buffer_len(&dmi_state); > - dmi_state_pack.data = dmi_state.bytes; > - > - BSG_PackList(clear_dmi_blob.bytes, 2, > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > - > - /** Bind Blob **/ > - TPMTRYRETURN( envelope_encrypt( &clear_dmi_blob, > - &mig_key->key, > - result_buf) ); > - > - if (last_mig) > - last_mig->next = mig_key->next; > - else > - vtpm_globals->mig_keys = mig_key->next; > - > - free(mig_key->name); > - free(mig_key); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration OUT of instance %d failed because of %s. Migratoin recovery may be needed.\n", dmi_id, tpm_get_error_name(status) ); > - > - //TODO: Create and implement a policy for what happens to mig_key on failed migrations. > - > - egress: > - > - buffer_free(&clear_dmi_blob); > - buffer_free(&dmi_state); > - > - return status; > -} > - > - > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Getting Migration Public Key.\n"); > - > - struct pack_buf_t pubkey_exp_pack, pubkey_mod_pack; > - TPM_KEY mig_key; > - > - // Unpack/return key structure > - BSG_Unpack(BSG_TPM_KEY, vtpm_globals->storageKeyWrap.bytes , &mig_key); > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - mig_key.algorithmParms.parms, > - &rsaKeyParms); > - > - pubkey_exp_pack.size = rsaKeyParms.exponentSize; > - pubkey_exp_pack.data = rsaKeyParms.exponent; > - pubkey_mod_pack.size = mig_key.pubKey.keyLength; > - pubkey_mod_pack.data = mig_key.pubKey.key; > - > - TPMTRYRETURN( buffer_init( result_buf, 2*sizeof(UINT32) + > - pubkey_exp_pack.size + > - pubkey_mod_pack.size, NULL ) ); > - > - BSG_PackList( result_buf->bytes, 2, > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > - > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Get Migration Key failed because of %s.\n", tpm_get_error_name(status) ); > - egress: > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Load_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_MIGKEY_LIST *mig_key; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Loading Migration Public Key.\n"); > - > - //FIXME: Review all uses of unpacking pack_buf_t and ensure free. > - //FIXME: Review all declarations/initializations of buffer_t that could have a goto that skips them and then tries to free them > - > - struct pack_buf_t name_pack, pubkey_exp_pack, pubkey_mod_pack; > - > - //FIXME: scan list and verify name is not already in the list > - > - BSG_UnpackList( param_buf->bytes, 3, > - BSG_TPM_SIZE32_DATA, &name_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > - > - //TODO: Maintain a persistent list for pub_keys. > - //TODO: Verify pub_key is trusted > - > - mig_key = (VTPM_MIGKEY_LIST *) malloc(sizeof(VTPM_MIGKEY_LIST)); > - memset(mig_key, 0, sizeof(VTPM_MIGKEY_LIST) ); > - mig_key->name_size = name_pack.size; > - mig_key->name = name_pack.data; > - > - mig_key->key.encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - Crypto_RSABuildCryptoInfoPublic( pubkey_exp_pack.size, > - pubkey_exp_pack.data, > - pubkey_mod_pack.size, > - pubkey_mod_pack.data, > - &mig_key->key); > - > - > - mig_key->next = vtpm_globals->mig_keys; > - vtpm_globals->mig_keys = mig_key; > - > - // free(name_pack.data); Do not free. data is now part of mig_key. > - free(pubkey_exp_pack.data); > - free(pubkey_mod_pack.data); > - > - return TPM_SUCCESS; > -} > diff --git a/tools/vtpm_manager/manager/securestorage.c b/tools/vtpm_manager/manager/securestorage.c > deleted file mode 100644 > index d5e6ffd..0000000 > --- a/tools/vtpm_manager/manager/securestorage.c > +++ /dev/null > @@ -1,512 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// securestorage.c > -// > -// Functions regarding securely storing DMI secrets. > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "crypto.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "buffer.h" > -#include "log.h" > - > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > - CRYPTO_INFO *asymkey, > - buffer_t *sealed_data) { > - TPM_RESULT status = TPM_SUCCESS; > - symkey_t symkey; > - buffer_t data_cipher = NULL_BUF, > - symkey_cipher = NULL_BUF; > - > - UINT32 i; > - struct pack_constbuf_t symkey_cipher32, data_cipher32; > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Input[%d]: 0x", buffer_len(inbuf)); > - for (i=0; i< buffer_len(inbuf); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", inbuf->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - // Generate a sym key and encrypt state with it > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_genkey (&symkey) ); > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_encrypt (&symkey, inbuf, &data_cipher) ); > - > - // Encrypt symmetric key > - TPMTRYRETURN( VTSP_Bind( asymkey, > - &symkey.key, > - &symkey_cipher) ); > - > - // Create output blob: symkey_size + symkey_cipher + state_cipher_size + state_cipher > - > - symkey_cipher32.size = buffer_len(&symkey_cipher); > - symkey_cipher32.data = symkey_cipher.bytes; > - > - data_cipher32.size = buffer_len(&data_cipher); > - data_cipher32.data = data_cipher.bytes; > - > - TPMTRYRETURN( buffer_init(sealed_data, 2 * sizeof(UINT32) + symkey_cipher32.size + data_cipher32.size, NULL)); > - > - BSG_PackList(sealed_data->bytes, 2, > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > - BSG_TPM_SIZE32_DATA, &data_cipher32); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Saved %d bytes of E(symkey) + %d bytes of E(data)\n", buffer_len(&symkey_cipher), buffer_len(&data_cipher)); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Output[%d]: 0x", buffer_len(sealed_data)); > - for (i=0; i< buffer_len(sealed_data); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", sealed_data->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope encrypt\n."); > - > - egress: > - > - buffer_free ( &data_cipher); > - buffer_free ( &symkey_cipher); > - Crypto_symcrypto_freekey (&symkey); > - > - return status; > -} > - > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > - TCS_CONTEXT_HANDLE TCSContext, > - TPM_HANDLE keyHandle, > - const TPM_AUTHDATA *key_usage_auth, > - buffer_t *unsealed_data) { > - > - TPM_RESULT status = TPM_SUCCESS; > - symkey_t symkey; > - buffer_t data_cipher = NULL_BUF, > - symkey_clear = NULL_BUF, > - symkey_cipher = NULL_BUF; > - struct pack_buf_t symkey_cipher32, data_cipher32; > - int i; > - > - memset(&symkey, 0, sizeof(symkey_t)); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypt Input[%d]: 0x", buffer_len(cipher) ); > - for (i=0; i< buffer_len(cipher); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cipher->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - BSG_UnpackList(cipher->bytes, 2, > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > - BSG_TPM_SIZE32_DATA, &data_cipher32); > - > - TPMTRYRETURN( buffer_init_alias_convert (&symkey_cipher, > - symkey_cipher32.size, > - symkey_cipher32.data) ); > - > - TPMTRYRETURN( buffer_init_alias_convert (&data_cipher, > - data_cipher32.size, > - data_cipher32.data) ); > - > - // Decrypt Symmetric Key > - TPMTRYRETURN( VTSP_Unbind( TCSContext, > - keyHandle, > - &symkey_cipher, > - key_usage_auth, > - &symkey_clear, > - &(vtpm_globals->keyAuth) ) ); > - > - // create symmetric key using saved bits > - Crypto_symcrypto_initkey (&symkey, &symkey_clear); > - > - // Decrypt State > - TPMTRY(TPM_DECRYPT_ERROR, Crypto_symcrypto_decrypt (&symkey, &data_cipher, unsealed_data) ); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypte Output[%d]: 0x", buffer_len(unsealed_data)); > - for (i=0; i< buffer_len(unsealed_data); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", unsealed_data->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope decrypt data\n."); > - > - egress: > - buffer_free ( &data_cipher); > - buffer_free ( &symkey_clear); > - buffer_free ( &symkey_cipher); > - Crypto_symcrypto_freekey (&symkey); > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Save_NVM(VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - int fh; > - long bytes_written; > - buffer_t sealed_NVM = NULL_BUF; > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Saving %d bytes of NVM.\n", buffer_len(inbuf)); > - > - TPMTRYRETURN( envelope_encrypt(inbuf, > - &vtpm_globals->storageKey, > - &sealed_NVM) ); > - > - // Write sealed blob off disk from NVMLocation > - // TODO: How to properly return from these. Do we care if we return failure > - // after writing the file? We can't get the old one back. > - // TODO: Backup old file and try and recover that way. > - fh = open(myDMI->NVMLocation, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); > - if ( (bytes_written = write(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM) ) != (long) buffer_len(&sealed_NVM))) { > - vtpmlogerror(VTPM_LOG_VTPM, "We just overwrote a DMI_NVM and failed to finish. %ld/%ld bytes.\n", bytes_written, (long)buffer_len(&sealed_NVM)); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - close(fh); > - > - Crypto_SHA1Full (sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &myDMI->NVM_measurement); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save NVM\n."); > - > - egress: > - buffer_free(&sealed_NVM); > - return status; > -} > - > - > -/* Expected Params: inbuf = null, outbuf = sealed blob size, sealed blob.*/ > -TPM_RESULT VTPM_Handle_Load_NVM(VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t sealed_NVM = NULL_BUF; > - long fh_size; > - int fh, stat_ret, i; > - struct stat file_stat; > - TPM_DIGEST sealedNVMHash; > - > - if (myDMI->NVMLocation == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to load NVM because the file name NULL.\n"); > - status = TPM_AUTHFAIL; > - goto abort_egress; > - } > - > - //Read sealed blob off disk from NVMLocation > - fh = open(myDMI->NVMLocation, O_RDONLY); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - fh_size = file_stat.st_size; > - else { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - TPMTRYRETURN( buffer_init( &sealed_NVM, fh_size, NULL) ); > - if (read(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM)) != fh_size) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - close(fh); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Load_NVMing[%d],\n", buffer_len(&sealed_NVM)); > - > - Crypto_SHA1Full(sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &sealedNVMHash); > - > - // Verify measurement of sealed blob. > - if (memcmp(&sealedNVMHash, &myDMI->NVM_measurement, sizeof(TPM_DIGEST)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM LoadNVM NVM measurement check failed.\n"); > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Correct hash: "); > - for (i=0; i< sizeof(TPM_DIGEST); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&myDMI->NVM_measurement)[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Measured hash: "); > - for (i=0; i< sizeof(TPM_DIGEST); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&sealedNVMHash)[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - status = TPM_AUTHFAIL; > - goto abort_egress; > - } > - > - TPMTRYRETURN( envelope_decrypt(&sealed_NVM, > - myDMI->TCSContext, > - vtpm_globals->storageKeyHandle, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - outbuf) ); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load NVM\n."); > - > - egress: > - buffer_free( &sealed_NVM ); > - > - return status; > -} > - > - > -TPM_RESULT VTPM_SaveManagerData(void) { > - TPM_RESULT status=TPM_SUCCESS; > - int fh, dmis=-1; > - > - BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL; > - buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF; > - UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap); > - UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap); > - struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes}; > - struct pack_buf_t boot_key_pack = {bootKeySize, vtpm_globals->bootKeyWrap.bytes}; > - BYTE vtpm_manager_gen = VTPM_MANAGER_GEN; > - > - struct hashtable_itr *dmi_itr; > - VTPM_DMI_RESOURCE *dmi_res; > - > - UINT32 boot_key_size = 0, flat_dmis_size = 0; > - > - // Initially fill these with buffer sizes for each data type. Later fill > - // in actual size, once flattened. > - boot_key_size = sizeof(UINT32) + // bootkeysize > - bootKeySize; // boot key > - > - TPMTRYRETURN(buffer_init(&clear_flat_global,sizeof(BYTE) + // manager version > - 3*sizeof(TPM_DIGEST) + // Auths > - sizeof(UINT32) +// storagekeysize > - storageKeySize, NULL) ); // storage key > - > - > - flat_boot_key = (BYTE *) malloc( boot_key_size ); > - flat_enc = (BYTE *) malloc( sizeof(UINT32) ); > - > - boot_key_size = BSG_PackList(flat_boot_key, 1, > - BSG_TPM_SIZE32_DATA, &boot_key_pack); > - > - BSG_PackList(clear_flat_global.bytes, 4, > - BSG_TYPE_BYTE, &vtpm_manager_gen, > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > - > - TPMTRYRETURN(envelope_encrypt(&clear_flat_global, > - &vtpm_globals->bootKey, > - &enc_flat_global) ); > - > - BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc); > - > - // Per DMI values to be saved (if any exit) > - if (hashtable_count(vtpm_globals->dmi_map) > 1) { > - > - flat_dmis = (BYTE *) malloc( > - (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0) > - (sizeof(UINT32) +sizeof(BYTE) + 2*sizeof(TPM_DIGEST)) ); // Per DMI info > - > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > - do { > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > - dmis++; > - > - // No need to save dmi0. > - if (dmi_res->dmi_id == 0) > - continue; > - > - > - flat_dmis_size += BSG_PackList( flat_dmis + flat_dmis_size, 4, > - BSG_TYPE_UINT32, &dmi_res->dmi_id, > - BSG_TYPE_BYTE, &dmi_res->dmi_type, > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > - > - } while (hashtable_iterator_advance(dmi_itr)); > - } > - > - fh = open(STATE_FILE, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE); > - if (fh == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to open %s file for write.\n", STATE_FILE); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if ( ( write(fh, flat_boot_key, boot_key_size) != boot_key_size ) || > - ( write(fh, flat_enc, sizeof(UINT32)) != sizeof(UINT32) ) || > - ( write(fh, enc_flat_global.bytes, buffer_len(&enc_flat_global)) != buffer_len(&enc_flat_global) ) || > - ( write(fh, flat_dmis, flat_dmis_size) != flat_dmis_size ) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to completely write service data.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - goto egress; > - > - abort_egress: > - egress: > - > - free(flat_boot_key); > - free(flat_enc); > - buffer_free(&enc_flat_global); > - free(flat_dmis); > - close(fh); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Saved VTPM Manager state (status = %d, dmis = %d)\n", (int) status, dmis); > - return status; > -} > - > -TPM_RESULT VTPM_LoadManagerData(void) { > - > - TPM_RESULT status=TPM_SUCCESS; > - int fh, stat_ret, dmis=0; > - long fh_size = 0, step_size; > - BYTE *flat_table=NULL; > - buffer_t unsealed_data, enc_table_abuf; > - struct pack_buf_t storage_key_pack, boot_key_pack; > - UINT32 *dmi_id_key, enc_size; > - BYTE vtpm_manager_gen; > - > - VTPM_DMI_RESOURCE *dmi_res; > - UINT32 dmi_id; > - BYTE dmi_type; > - struct stat file_stat; > - > - TPM_HANDLE boot_key_handle; > - TPM_AUTHDATA boot_usage_auth; > - memset(&boot_usage_auth, 0, sizeof(TPM_AUTHDATA)); > - > - fh = open(STATE_FILE, O_RDONLY ); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - fh_size = file_stat.st_size; > - else { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - flat_table = (BYTE *) malloc(fh_size); > - > - if ((long) read(fh, flat_table, fh_size) != fh_size ) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Read Boot Key > - step_size = BSG_UnpackList( flat_table, 2, > - BSG_TPM_SIZE32_DATA, &boot_key_pack, > - BSG_TYPE_UINT32, &enc_size); > - > - TPMTRYRETURN(buffer_init(&vtpm_globals->bootKeyWrap, 0, 0) ); > - TPMTRYRETURN(buffer_init_alias_convert(&enc_table_abuf, enc_size, flat_table + step_size) ); > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->bootKeyWrap, boot_key_pack.size, boot_key_pack.data) ); > - > - //Load Boot Key > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->bootKeyWrap, > - &SRK_AUTH, > - &boot_key_handle, > - &vtpm_globals->keyAuth, > - &vtpm_globals->bootKey, > - FALSE) ); > - > - TPMTRYRETURN( envelope_decrypt(&enc_table_abuf, > - vtpm_globals->manager_tcs_handle, > - boot_key_handle, > - (const TPM_AUTHDATA*) &boot_usage_auth, > - &unsealed_data) ); > - step_size += enc_size; > - > - if (*unsealed_data.bytes != VTPM_MANAGER_GEN) { > - // Once there is more than one gen, this will include some compatability stuff > - vtpmlogerror(VTPM_LOG_VTPM, "Warning: Manager Data file is gen %d, which this manager is gen %d.\n", vtpm_manager_gen, VTPM_MANAGER_GEN); > - } > - > - // Global Values needing to be saved > - BSG_UnpackList( unsealed_data.bytes, 4, > - BSG_TYPE_BYTE, &vtpm_manager_gen, > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > - > - TPMTRYRETURN(buffer_init(&vtpm_globals->storageKeyWrap, 0, 0) ); > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->storageKeyWrap, storage_key_pack.size, storage_key_pack.data) ); > - > - // Per DMI values to be saved > - while ( step_size < fh_size ){ > - if (fh_size - step_size < (long) (sizeof(UINT32) + sizeof(BYTE) + 2*sizeof(TPM_DIGEST))) { > - vtpmlogerror(VTPM_LOG_VTPM, "Encountered %ld extra bytes at end of manager state.\n", fh_size-step_size); > - step_size = fh_size; > - } else { > - step_size += BSG_UnpackList(flat_table + step_size, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TYPE_BYTE, &dmi_type); > - > - //TODO: Try and gracefully recover from problems. > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &dmi_res) ); > - dmis++; > - > - step_size += BSG_UnpackList(flat_table + step_size, 2, > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > - } > - > - } > - > - vtpmloginfo(VTPM_LOG_VTPM, "Loaded saved state (dmis = %d).\n", dmis); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load service data with error = %s\n", tpm_get_error_name(status)); > - egress: > - > - free(flat_table); > - close(fh); > - > - // TODO: Could be nice and evict BootKey. (Need to add EvictKey to VTSP. > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/manager/tpmpassthrough.c b/tools/vtpm_manager/manager/tpmpassthrough.c > deleted file mode 100644 > index 9b1e5f8..0000000 > --- a/tools/vtpm_manager/manager/tpmpassthrough.c > +++ /dev/null > @@ -1,110 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tpmpassthrough.c > -// > -// Functions regarding passing DMI requests to HWTPM > -// > -// ================================================================== > - > -#include "tcg.h" > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "log.h" > - > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > - buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE *ord; > - > - ord = (TPM_COMMAND_CODE *) (inbuf->bytes + sizeof(TPM_TAG) + sizeof(UINT32)); > - > - switch (*ord) { > - > - // Forbidden for DMI use > - case TPM_ORD_TakeOwnership: > - case TPM_ORD_ChangeAuthOwner: > - case TPM_ORD_DirWriteAuth: > - case TPM_ORD_DirRead: > - case TPM_ORD_AuthorizeMigrationKey: > - case TPM_ORD_CreateMaintenanceArchive: > - case TPM_ORD_LoadMaintenanceArchive: > - case TPM_ORD_KillMaintenanceFeature: > - case TPM_ORD_LoadManuMaintPub: > - case TPM_ORD_ReadManuMaintPub: > - case TPM_ORD_SelfTestFull: > - case TPM_ORD_SelfTestStartup: > - case TPM_ORD_CertifySelfTest: > - case TPM_ORD_ContinueSelfTest: > - case TPM_ORD_GetTestResult: > - case TPM_ORD_Reset: > - case TPM_ORD_OwnerClear: > - case TPM_ORD_DisableOwnerClear: > - case TPM_ORD_ForceClear: > - case TPM_ORD_DisableForceClear: > - case TPM_ORD_GetCapabilityOwner: > - case TPM_ORD_OwnerSetDisable: > - case TPM_ORD_PhysicalEnable: > - case TPM_ORD_PhysicalDisable: > - case TPM_ORD_SetOwnerInstall: > - case TPM_ORD_PhysicalSetDeactivated: > - case TPM_ORD_SetTempDeactivated: > - case TPM_ORD_CreateEndorsementKeyPair: > - case TPM_ORD_GetAuditEvent: > - case TPM_ORD_GetAuditEventSigned: > - case TPM_ORD_GetOrdinalAuditStatus: > - case TPM_ORD_SetOrdinalAuditStatus: > - case TPM_ORD_SetRedirection: > - case TPM_ORD_FieldUpgrade: > - case TSC_ORD_PhysicalPresence: > - status = TPM_DISABLED_CMD; > - goto abort_egress; > - break; > - > - } // End ORD Switch > - > - // Call TCS with command > - > - TPMTRY(TPM_IOERROR, VTSP_RawTransmit( dmi->TCSContext,inbuf, outbuf) ); > - > - goto egress; > - > - abort_egress: > - vtpmloginfo(VTPM_LOG_VTPM, "TPM Command Failed in tpmpassthrough.\n"); > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.c b/tools/vtpm_manager/manager/vtpm_ipc.c > deleted file mode 100644 > index 319dc83..0000000 > --- a/tools/vtpm_manager/manager/vtpm_ipc.c > +++ /dev/null > @@ -1,141 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_ipc.c Implements ipc routines using file io. This file can > -// be replaced with other ipc types. > -// > -// =================================================================== > - > -#include > -#include "vtpm_ipc.h" > -#include "vtpmpriv.h" > -#include "log.h" > - > -int vtpm_ipc_init(vtpm_ipc_handle_t *ipc_h, char* name, int flags, BOOL create) { > - ipc_h->name = name; > - ipc_h->flags = flags; > - ipc_h->fh = VTPM_IPC_CLOSED; > - > - if (create) > - return(vtpm_ipc_create(ipc_h)); > - else > - return 0; > -} > - > -// Create the file that needs opening. Used only for FIFOs > -// FYI: This may cause problems in other file IO schemes. We'll see. > -int vtpm_ipc_create(vtpm_ipc_handle_t *ipc_h) { > - int fh; > - struct stat file_info; > - > - if ((!ipc_h) || (!ipc_h->name)) > - return -1; > - > - if ( stat(ipc_h->name, &file_info) == -1) { > - if ( mkfifo(ipc_h->name, S_IWUSR | S_IRUSR ) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create fifo %s.\n", ipc_h->name); > - return -1; > - } > - } > - > - ipc_h->fh = VTPM_IPC_CLOSED; > - > - return 0; > -} > - > - > -// Read size bytes. If FH isn't open, open it. > -int vtpm_ipc_read(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size){ > - vtpm_ipc_handle_t *my_ipc_h; > - int result; > - > - if (ipc_h) { > - my_ipc_h = ipc_h; > - } else { > - my_ipc_h = alt_ipc_h; > - } > - > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > - } > - > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for reading.\n", my_ipc_h->name); > - return -1; > - } > - > - result = read(my_ipc_h->fh, bytes, size); > - if (result < 0) { > - my_ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > - return (result); > -} > - > -// Write size bytes. If FH isn't open, open it. > -int vtpm_ipc_write(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size) { > - vtpm_ipc_handle_t *my_ipc_h; > - int result; > - > - if (ipc_h) { > - my_ipc_h = ipc_h; > - } else { > - my_ipc_h = alt_ipc_h; > - } > - > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > - } > - > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for writing.\n", my_ipc_h->name); > - return -1; > - } > - > - result = write(my_ipc_h->fh, bytes, size); > - if (result < 0) { > - my_ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > - return (result); > -} > - > -// Mark file as closed and try and close it. Errors not reported. > -void vtpm_ipc_close(vtpm_ipc_handle_t *ipc_h) { > - > - if (ipc_h) { > - close(ipc_h->fh); > - ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > -} > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.h b/tools/vtpm_manager/manager/vtpm_ipc.h > deleted file mode 100644 > index 529c4a2..0000000 > --- a/tools/vtpm_manager/manager/vtpm_ipc.h > +++ /dev/null > @@ -1,71 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_ipc.h Header for interprocess communication between VTPM manager > -// and Guests or VTPMs > -// > -// =================================================================== > - > -#ifndef __VTPM_IO_H__ > -#define __VTPM_IO_H__ > - > -#include "tcg.h" > - > -#define VTPM_IPC_CLOSED -1 > - > -// Represents an (somewhat) abstracted io handle. > -typedef struct vtpm_ipc_handle_t { > - int fh; // IO handle. > - int flags; // Flags for opening. This may need to become > - // a void *, but for now files use an int. > - char *name; // Names for debugging as well as filenames > - // for file-based io. > -} vtpm_ipc_handle_t; > - > - > -int vtpm_ipc_init(vtpm_ipc_handle_t *ioh, char* name, int flags, BOOL create); > - > -// Create the file that needs opening. Used only for FIFOs > -// FYI: This may cause problems in other file IO schemes. We'll see. > -int vtpm_ipc_create(vtpm_ipc_handle_t *ioh); > - > -// Read size bytes. If FH isn't open, open it. > -int vtpm_ipc_read(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > - > -// Write size bytes. If FH isn't open, open it. > -int vtpm_ipc_write(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > - > -// Mark file as closed and try and close it. Errors not reported. > -void vtpm_ipc_close(vtpm_ipc_handle_t *ioh); > - > -#endif > diff --git a/tools/vtpm_manager/manager/vtpm_lock.c b/tools/vtpm_manager/manager/vtpm_lock.c > deleted file mode 100644 > index e737d60..0000000 > --- a/tools/vtpm_manager/manager/vtpm_lock.c > +++ /dev/null > @@ -1,63 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_lock.c Provided controlled sync around access to vtpm structures > -// > -// =================================================================== > - > -#include > -#include "vtpm_lock.h" > - > -static pthread_rwlock_t vtpm_lock; > - > -void vtpm_lock_init() { > - > - pthread_rwlock_init( &vtpm_lock, NULL); > -} > - > -void vtpm_lock_destroy(){ > - pthread_rwlock_destroy(&vtpm_lock); > -} > - > -void vtpm_lock_rdlock(){ > - pthread_rwlock_rdlock(&vtpm_lock); > -} > - > -void vtpm_lock_wrlock(){ > - pthread_rwlock_wrlock(&vtpm_lock); > -} > - > -void vtpm_lock_unlock(){ > - pthread_rwlock_unlock(&vtpm_lock); > -} > - > diff --git a/tools/vtpm_manager/manager/vtpm_lock.h b/tools/vtpm_manager/manager/vtpm_lock.h > deleted file mode 100644 > index 53a339d..0000000 > --- a/tools/vtpm_manager/manager/vtpm_lock.h > +++ /dev/null > @@ -1,48 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_lock.h Provided controlled sync around access to vtpm structures > -// > -// =================================================================== > - > -#ifndef __VTPM_LOCK_H__ > -#define __VTPM_LOCK_H__ > - > -void vtpm_lock_init(); > -void vtpm_lock_destroy(); > - > -void vtpm_lock_rdlock(); > -void vtpm_lock_wrlock(); > -void vtpm_lock_unlock(); > - > -#endif > diff --git a/tools/vtpm_manager/manager/vtpm_manager.c b/tools/vtpm_manager/manager/vtpm_manager.c > deleted file mode 100644 > index e089f78..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager.c > +++ /dev/null > @@ -1,285 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager.c > -// > -// This file will house the main logic of the VTPM Manager > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > - > -#include "log.h" > -#include "buffer.h" > - > -VTPM_GLOBALS *vtpm_globals=NULL; > - > -// --------------------------- Well Known Auths -------------------------- > -const TPM_AUTHDATA SRK_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > - > -#ifdef WELL_KNOWN_OWNER_AUTH > -static BYTE FIXED_OWNER_AUTH[20] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > -#endif > - > - > -// -------------------------- Hash table functions -------------------- > - > -static unsigned int hashfunc32(void *ky) { > - return (* (UINT32 *) ky); > -} > - > -static int equals32(void *k1, void *k2) { > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > -} > - > -// --------------------------- Functions ------------------------------ > - > -TPM_RESULT VTPM_Create_Manager(){ > - > - TPM_RESULT status = TPM_SUCCESS; > - > - // Generate Auth for Owner > -#ifdef WELL_KNOWN_OWNER_AUTH > - memcpy(vtpm_globals->owner_usage_auth, FIXED_OWNER_AUTH, sizeof(TPM_AUTHDATA)); > -#else > - Crypto_GetRandom(vtpm_globals->owner_usage_auth, sizeof(TPM_AUTHDATA) ); > -#endif > - > - // Take Owership of TPM > - CRYPTO_INFO ek_cryptoInfo; > - > - status = VTSP_ReadPubek(vtpm_globals->manager_tcs_handle, &ek_cryptoInfo); > - > - // If we can read PubEK then there is no owner and we should take it. > - // We use the abilty to read the pubEK to flag that the TPM is owned. > - // FIXME: Change to just trying to take ownership and react to the status > - if (status == TPM_SUCCESS) { > - TPMTRYRETURN(VTSP_TakeOwnership(vtpm_globals->manager_tcs_handle, > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > - &SRK_AUTH, > - &ek_cryptoInfo, > - &vtpm_globals->keyAuth)); > - > - TPMTRYRETURN(VTSP_DisablePubekRead(vtpm_globals->manager_tcs_handle, > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > - &vtpm_globals->keyAuth)); > - } else { > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); > - } > - > - // Generate storage key's auth > - Crypto_GetRandom( &vtpm_globals->storage_key_usage_auth, > - sizeof(TPM_AUTHDATA) ); > - > - TCS_AUTH osap; > - TPM_AUTHDATA sharedsecret; > - > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > - TPM_ET_KEYHANDLE, > - TPM_SRK_KEYHANDLE, > - &SRK_AUTH, > - &sharedsecret, > - &osap) ); > - > - osap.fContinueAuthSession = FALSE; > - > - > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > - TPM_KEY_BIND, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - TPM_SRK_KEYHANDLE, > - (const TPM_AUTHDATA*)&sharedsecret, > - &vtpm_globals->storageKeyWrap, > - &osap) ); > - > - // Generate boot key's auth > - TPM_AUTHDATA bootKeyWrapAuth; > - memset(&bootKeyWrapAuth, 0, sizeof(bootKeyWrapAuth)); > - > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > - TPM_ET_KEYHANDLE, > - TPM_SRK_KEYHANDLE, > - &SRK_AUTH, > - &sharedsecret, > - &osap) ); > - > - osap.fContinueAuthSession = FALSE; > - > - // FIXME: This key protects the global secrets on disk. It should use TPM > - // PCR bindings to limit its use to legit configurations. > - // Current binds are open, implying a Trusted VM contains this code. > - // If this VM is not Trusted, use measurement and PCR bindings. > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > - TPM_KEY_BIND, > - (const TPM_AUTHDATA*)&bootKeyWrapAuth, > - TPM_SRK_KEYHANDLE, > - (const TPM_AUTHDATA*)&sharedsecret, > - &vtpm_globals->bootKeyWrap, > - &osap) ); > - > - // Populate CRYPTO_INFO vtpm_globals->bootKey. This does not load it into the TPM > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->bootKeyWrap, > - NULL, > - NULL, > - NULL, > - &vtpm_globals->bootKey, > - TRUE ) ); > - > - TPMTRYRETURN( VTSP_SaveState(vtpm_globals->manager_tcs_handle) ); > - goto egress; > - > - abort_egress: > - exit(1); > - > - egress: > - vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager (Status = %d).\n", status); > - return status; > - > -} > - > -/////////////////////////////////////////////////////////////////////////////// > -TPM_RESULT VTPM_Init_Manager() { > - TPM_RESULT status = TPM_FAIL, serviceStatus; > - BYTE *randomsead; > - UINT32 randomsize=256; > - > - if ((vtpm_globals = (VTPM_GLOBALS *) malloc(sizeof(VTPM_GLOBALS))) == NULL){ > - status = TPM_FAIL; > - goto abort_egress; > - } > - memset(vtpm_globals, 0, sizeof(VTPM_GLOBALS)); > - > - vtpm_globals->connected_dmis = 0; > - > - if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){ > - status = TPM_FAIL; > - goto abort_egress; > - } > - > - // Create new TCS Object > - vtpm_globals->manager_tcs_handle = 0; > - > - TPMTRYRETURN(TCS_create()); > - > - // Create TCS Context for service > - TPMTRYRETURN( TCS_OpenContext(&vtpm_globals->manager_tcs_handle ) ); > - > - TPMTRYRETURN( TCSP_GetRandom(vtpm_globals->manager_tcs_handle, > - &randomsize, > - &randomsead)); > - > - Crypto_Init(randomsead, randomsize); > - TPMTRYRETURN( TCS_FreeMemory (vtpm_globals->manager_tcs_handle, randomsead)); > - > - // Create OIAP session for service's authorized commands > - TPMTRYRETURN( VTSP_OIAP( vtpm_globals->manager_tcs_handle, > - &vtpm_globals->keyAuth) ); > - vtpm_globals->keyAuth.fContinueAuthSession = TRUE; > - > - vtpm_globals->mig_keys = NULL; > - > - // If fails, create new Manager. > - serviceStatus = VTPM_LoadManagerData(); > - if (serviceStatus == TPM_IOERROR) { > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); > - TPMTRYRETURN( VTPM_Create_Manager() ); > - TPMTRYRETURN( VTPM_SaveManagerData() ); > - } else if (serviceStatus != TPM_SUCCESS) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to read existing manager file"); > - exit(1); > - } > - > - //Load Storage Key > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->storageKeyWrap, > - &SRK_AUTH, > - &vtpm_globals->storageKeyHandle, > - &vtpm_globals->keyAuth, > - &vtpm_globals->storageKey, > - FALSE ) ); > - > - // Create entry for Dom0 for control messages > - TPMTRYRETURN( VTPM_Handle_New_DMI(NULL) ); > - > - goto egress; > - > - abort_egress: > - egress: > - > - return(status); > -} > - > -/////////////////////////////////////////////////////////////////////////////// > -void VTPM_Stop_Manager() { > - VTPM_DMI_RESOURCE *dmi_res; > - struct hashtable_itr *dmi_itr; > - > - // Close all the TCS contexts. TCS should evict keys based on this > - if (hashtable_count(vtpm_globals->dmi_map) > 0) { > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > - do { > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > - if (dmi_res->connected) > - close_dmi( dmi_res ); // Not really interested in return code > - > - } while (hashtable_iterator_advance(dmi_itr)); > - free (dmi_itr); > - } > - > - if ( VTPM_SaveManagerData() != TPM_SUCCESS ) > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to save manager data.\n"); > - > - TCS_CloseContext(vtpm_globals->manager_tcs_handle); > - TCS_destroy(); > - > - hashtable_destroy(vtpm_globals->dmi_map, 1); > - free(vtpm_globals); > - > - Crypto_Exit(); > - > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); > -} > diff --git a/tools/vtpm_manager/manager/vtpm_manager.h b/tools/vtpm_manager/manager/vtpm_manager.h > deleted file mode 100644 > index a324a8f..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager.h > +++ /dev/null > @@ -1,150 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager.h > -// > -// Public Interface header for VTPM Manager > -// > -// ================================================================== > - > -#ifndef __VTPM_MANAGER_H__ > -#define __VTPM_MANAGER_H__ > - > -#define VTPM_TAG_REQ 0x01c1 > -#define VTPM_TAG_RSP 0x01c4 > -#define COMMAND_BUFFER_SIZE 4096 > - > -// Header sizes. Note Header MAY include the DMI > -#define VTPM_COMMAND_HEADER_SIZE_CLT ( 2 + 4 + 4) > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > -#define VTPM_COMMAND_HEADER_SIZE_SRV ( 4 + VTPM_COMMAND_HEADER_SIZE_CLT ) > -// sizeof( UINT32 + VTPM_COMMAND_HEADER_SIZE_CLT) > - > -//************************ 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) > - > -// Non-priviledged VTPM Commands (From DMI's) > -#define VTPM_ORD_SAVENVM (VTPM_ORD_BASE + 1) // DMI Saves Secrets > -#define VTPM_ORD_LOADNVM (VTPM_ORD_BASE + 2) // DMI Loads Secrets > -#define VTPM_ORD_TPMCOMMAND (VTPM_ORD_BASE + 3) // DMI issues HW TPM Command > -#define VTPM_ORD_GET_MIG_KEY (VTPM_ORD_BASE + 4) // Get manager's migration key > -#define VTPM_ORD_LOAD_MIG_KEY (VTPM_ORD_BASE + 5) // load dest migration key > - > -// Priviledged VTPM Commands (From management console) > -#define VTPM_ORD_OPEN (VTPM_PRIV_BASE + 1) // Creates/reopens DMI > -#define VTPM_ORD_CLOSE (VTPM_PRIV_BASE + 2) // Closes a DMI > -#define VTPM_ORD_DELETE (VTPM_PRIV_BASE + 3) // Permemently Deletes DMI > -#define VTPM_ORD_MIGRATE_IN (VTPM_PRIV_BASE + 4) // Load migrated VTPM > -#define VTPM_ORD_MIGRATE_OUT (VTPM_PRIV_BASE + 5) // migrate VTPM to dest > - > -//************************ Return Codes **************************** > -#define VTPM_TYPE_PVM 1 // Paravirtualized Domain > -#define VTPM_TYPE_HVM 2 // HVM Domain > - > -//************************ Return Codes **************************** > -#define VTPM_SUCCESS 0 > -#define VTPM_FAIL 1 > -#define VTPM_UNSUPPORTED 2 > -#define VTPM_FORBIDDEN 3 > -#define VTPM_RESTORE_CONTEXT_FAILED 4 > -#define VTPM_INVALID_REQUEST 5 > - > -//*********************** Parameter Values ************************* > -#define VTPM_TYPE_NON_MIGRATABLE 0x00 > -#define VTPM_TYPE_MIGRATABLE 0x01 > -#define VTPM_TYPE_MIGRATED 0xFF // VTPM has been migrated. > - // VTPM can be recovered or deleted only > - > -/******************* Command Parameter API ************************* > - > -VTPM Command Format > - dmi: 4 bytes // Source of message. > - // WARNING: This is prepended by the channel. > - // Thus it is received by VTPM Manager, > - // but not sent by DMI > - tpm tag: 2 bytes > - command size: 4 bytes // Size of command including header but not DMI > - ord: 4 bytes // Command ordinal above > - parameters: size - 10 bytes // Command Parameter > - > -VTPM Response Format > - tpm tag: 2 bytes > - response_size: 4 bytes > - status: 4 bytes > - parameters: size - 10 bytes > - > - > -VTPM_Open: > - Input Parameters: > - mig_type: 1 byte > - startup_mode: 1 byte // Cold Boot = 1, resume = 2, deactive = 3 > - domain type: 1 byte > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_Close > - Input Parameters: > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_Delete > - Input Parameters: > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_SaveNVM > - Input Parameters: > - data: n bytes (Header indicates size of data) > - Output Parameters: > - None > - > -VTPM_LoadNVM > - Input Parameters: > - None > - Output Parameters: > - data: n bytes (Header indicates size of data) > - > -VTPM_TPMCommand > - Input Parameters: > - TPM Command Byte Stream: n bytes > - Output Parameters: > - TPM Reponse Byte Stream: n bytes > - > -*********************************************************************/ > - > -#endif //_VTPM_MANAGER_H_ > diff --git a/tools/vtpm_manager/manager/vtpm_manager_handler.c b/tools/vtpm_manager/manager/vtpm_manager_handler.c > deleted file mode 100644 > index 2001074..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager_handler.c > +++ /dev/null > @@ -1,488 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager_handler.c > -// > -// This file will house the main logic of the VTPM Manager > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "log.h" > -#include "buffer.h" > - > -#define vtpmhandlerloginfo(module,fmt,args...) vtpmloginfo (module, "[%s]: " fmt, thread_name, ##args ); > -#define vtpmhandlerloginfomore(module,fmt,args...) vtpmloginfomore (module, fmt, ##args ); > -#define vtpmhandlerlogerror(module,fmt,args...) vtpmlogerror (module, "[%s]: " fmt, thread_name, ##args ); > - > -// ---------------------- Prototypes ------------------- > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > - TPM_COMMAND_CODE ord, > - buffer_t *command_buf, > - buffer_t *result_buf, > - BOOL is_priv, > - char *thread_name); > - > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - VTPM_DMI_RESOURCE *dmi_res, > - BYTE *cmd_header, > - buffer_t *param_buf, > - buffer_t *result_buf, > - char *thread_name); > - > -TPM_RESULT VTPM_Manager_Handler( vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - BOOL fw_tpm, // Forward TPM cmds? > - vtpm_ipc_handle_t *fw_tx_ipc_h, > - vtpm_ipc_handle_t *fw_rx_ipc_h, > - BOOL is_priv, > - char *thread_name) { > - TPM_RESULT status = TPM_FAIL; // Should never return > - UINT32 dmi, in_param_size, cmd_size, out_param_size, out_message_size, reply_size; > - BYTE *cmd_header=NULL, *in_param=NULL, *out_message=NULL, *reply; > - buffer_t *command_buf=NULL, *result_buf=NULL; > - TPM_TAG tag; > - TPM_COMMAND_CODE ord; > - VTPM_DMI_RESOURCE *dmi_res; > - int size_read, size_write, i; > - BOOL add_header=TRUE; // This indicates to prepend a header on result_buf before sending > - > - cmd_header = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV); > - command_buf = (buffer_t *) malloc(sizeof(buffer_t)); > - result_buf = (buffer_t *) malloc(sizeof(buffer_t)); > - > - // ------------------------ Main Loop -------------------------------- > - while(1) { > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "%s waiting for messages.\n", thread_name); > - > - // --------------------- Read Cmd from Sender ---------------- > - > - // Read command header > - size_read = vtpm_ipc_read(rx_ipc_h, NULL, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV[%d]: 0x", size_read); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s can't read from ipc. Errono = %d. Aborting... \n", thread_name, errno); > - goto abort_command; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command shorter than normal header (%d bytes). Aborting...\n", size_read); > - goto abort_command; > - } > - > - // Unpack header > - BSG_UnpackList(cmd_header, 4, > - BSG_TYPE_UINT32, &dmi, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - // Using the header info, read the parameters of the command > - // Note that in_param_size is in the client's context > - cmd_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > - if (cmd_size > 0) { > - in_param = (BYTE *) malloc(cmd_size); > - size_read = vtpm_ipc_read( rx_ipc_h, NULL, in_param, cmd_size); > - if (size_read > 0) { > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error reading cmd from ipc. Aborting... \n", thread_name); > - goto abort_command; > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - if (size_read < (int) cmd_size) { > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d). Aborting...\n", size_read, cmd_size); > - goto abort_command; > - } > - } else { > - in_param = NULL; > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } > - > - // Init the buffers used to handle the command and the response > - if ( (buffer_init_convert(command_buf, cmd_size, in_param) != TPM_SUCCESS) || > - (buffer_init(result_buf, 0, 0) != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > - goto abort_command; > - } > - > - // -------------- Dispatch Commands to Handlers ----------- > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK)) { > - vtpm_lock_wrlock(); > - } else { > - vtpm_lock_rdlock(); > - } > - > - if ( !(dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi)) || > - (!dmi_res->connected) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempted access to non-existent or disconnected DMI %d. Aborting...\n", dmi); > - status = TPM_BAD_PARAMETER; > - // We have no one to reply to, they don't exist. > - goto abort_command; > - } > - > - if (tag == VTPM_TAG_REQ) { > - > - status = vtpm_manager_handle_vtpm_cmd(dmi_res, ord, command_buf, result_buf, is_priv, thread_name); > - > - } else { // This is not a VTPM Command at all. > - if (fw_tpm) { > - status = vtpm_manager_handle_tpm_cmd(fw_tx_ipc_h, fw_rx_ipc_h, dmi_res, cmd_header, command_buf, result_buf, thread_name); > - > - // This means calling the DMI failed, not that the cmd failed in the DMI > - // Since the return will be interpretted by a TPM app, all errors are IO_ERRORs to the app > - if (status != TPM_SUCCESS) { > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - // Unlike all other commands, forwarded commands yield a result_buf that includes the DMI's status. This > - // should be forwarded to the caller VM > - add_header = FALSE; > - } else { > - // We are not supposed to forward TPM commands at all. > - int i; > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempt to use unsupported direct access to TPM.\n"); > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "Bad Command. dmi:%d, tag:%d, size:%d, ord:%d, Params: ", dmi, tag, in_param_size, ord); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - } // end else for is VTPM Command > - > - // ------------------- Respond to Sender ------------------ > - > - // Errors while handling responses jump here to reply with error messages > - // NOTE: Currently there are no recoverable errors in multi-VM mode. If one > - // is added to the code, this ifdef should be removed. > - // Also note this is NOT referring to errors in commands, but rather > - // this is about I/O errors and such. > -#ifndef VTPM_MULTI_VM > - abort_with_error: > -#endif > - > - if (add_header) { > - // Prepend VTPM header with destination DM stamped > - out_param_size = buffer_len(result_buf); > - out_message_size = VTPM_COMMAND_HEADER_SIZE_CLT + out_param_size; > - reply_size = VTPM_COMMAND_HEADER_SIZE_SRV + out_param_size; > - out_message = (BYTE *) malloc (reply_size); > - reply = out_message; > - > - BSG_PackList(out_message, 4, > - BSG_TYPE_UINT32, (BYTE *) &dmi, > - BSG_TPM_TAG, (BYTE *) &tag, > - BSG_TYPE_UINT32, (BYTE *) &out_message_size, > - BSG_TPM_RESULT, (BYTE *) &status); > - > - if (buffer_len(result_buf) > 0) > - memcpy(out_message + VTPM_COMMAND_HEADER_SIZE_SRV, result_buf->bytes, out_param_size); > - //Note: Send message + dmi_id > - } else { > - reply = result_buf->bytes; > - reply_size = buffer_len(result_buf); > - } > - size_write = vtpm_ipc_write(tx_ipc_h, (dmi_res ? dmi_res->tx_vtpm_ipc_h : NULL), reply, reply_size ); > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > - for (i=0; i < reply_size; i++) > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", reply[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name); > - goto abort_command; > - } > - free(out_message); out_message=NULL; > - > - if (size_write < (int)reply_size) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size); > - goto abort_command; > - } > - > - // On certain failures an error message cannot be sent. > - // This marks the beginning of cleanup in preperation for the next command. > - abort_command: > - //free buffers > - bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - //free(in_param); // This was converted to command_buf. No need to free > - buffer_free(result_buf); > - buffer_free(command_buf); > - > - // If we have a write lock, save the manager table > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) && > - (VTPM_SaveManagerData() != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n"); > - } > - > - vtpm_lock_unlock(); > - add_header = TRUE; // Reset to the default > - } // End while(1) > - > -} > - > -///////////////////////////////////////////////////////////////////////// > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > - TPM_COMMAND_CODE ord, > - buffer_t *command_buf, > - buffer_t *result_buf, > - BOOL is_priv, > - char *thread_name) { > - > - TPM_RESULT status = TPM_FAIL; > - > - switch (ord) { > - case VTPM_ORD_SAVENVM: > - status= VTPM_Handle_Save_NVM(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_LOADNVM: > - status= VTPM_Handle_Load_NVM(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_TPMCOMMAND: > - status= VTPM_Handle_TPM_Command(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_GET_MIG_KEY: > - status = VTPM_Handle_Get_Migration_key(command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_LOAD_MIG_KEY: > - status = VTPM_Handle_Load_Migration_key(command_buf, > - result_buf); > - break; > - > - default: > - // Privileged handlers can do maintanance > - if (is_priv) { > - switch (ord) { > - case VTPM_ORD_OPEN: > - status = VTPM_Handle_New_DMI(command_buf); > - break; > - > - case VTPM_ORD_CLOSE: > - status = VTPM_Handle_Close_DMI(command_buf); > - break; > - > - case VTPM_ORD_DELETE: > - status = VTPM_Handle_Delete_DMI(command_buf); > - break; > - > - case VTPM_ORD_MIGRATE_IN: > - status = VTPM_Handle_Migrate_In(command_buf, result_buf); > - break; > - > - case VTPM_ORD_MIGRATE_OUT: > - status = VTPM_Handle_Migrate_Out(command_buf, result_buf); > - break; > - > - default: > - status = TPM_BAD_ORDINAL; > - } // switch > - } else { // is priv command > - > - status = TPM_BAD_ORDINAL; > - } // inner switch > - } // outer switch > - > - return(status); > -} > - > -///////////////////////////////////////////////////////////////////// > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - VTPM_DMI_RESOURCE *dmi_res, > - BYTE *cmd_header, > - buffer_t *param_buf, > - buffer_t *result_buf, > - char *thread_name) { > - > - TPM_RESULT status = TPM_FAIL; > - UINT32 dmi_dst; > - TPM_COMMAND_CODE ord; > - TPM_TAG tag_out; > - UINT32 dmi_cmd_size, in_param_size, adj_param_size; > - BYTE *dmi_cmd, *in_param; > - int size_read, size_write, i; > - > - //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n"); > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n"); > - > - //Forward TPM CMD stamped with dmi_id to DMI for handling > - if (buffer_len(param_buf)) { > - dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf)); > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); > - memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf)); > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size); > - > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", dmi_cmd[i]); > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - free(dmi_cmd); > - } else { > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV; > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV ); > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - } > - > - if (size_write != (int) dmi_cmd_size) > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Could not write entire command to DMI (%d/%d)\n", size_write, dmi_cmd_size); > - > - buffer_free(param_buf); > - > - // Read header for response to TPM command from DMI > - size_read = vtpm_ipc_read( rx_ipc_h, dmi_res->rx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command from DMI shorter than normal header. Aborting...\n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(cmd_header, 4, > - BSG_TYPE_UINT32, &dmi_dst, > - BSG_TPM_TAG, &tag_out, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &status ); > - > - // If response has parameters, read them. > - // Note that in_param_size is in the client's context > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > - if (adj_param_size > 0) { > - in_param = (BYTE *) malloc(adj_param_size); > - size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size); > - if (size_read > 0) { > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from BE. Aborting... \n"); > - goto abort_with_error; > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) from DMI is shorter than header indicates(%d). Aborting...\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - } else { > - in_param = NULL; > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - if ( (buffer_init(result_buf, VTPM_COMMAND_HEADER_SIZE_SRV, cmd_header) != TPM_SUCCESS) || > - (buffer_append_raw(result_buf, adj_param_size, in_param) != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Sending DMI's response to guest.\n"); > - > - status = TPM_SUCCESS; > - > - abort_with_error: > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/manager/vtpmd.c b/tools/vtpm_manager/manager/vtpmd.c > deleted file mode 100644 > index cf58ba3..0000000 > --- a/tools/vtpm_manager/manager/vtpmd.c > +++ /dev/null > @@ -1,371 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpmd.c > -// > -// Application > -// > -// =================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "tcg.h" > -#include "log.h" > -#include "vtpm_ipc.h" > - > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > - > -#define VTPM_BE_FNAME "/dev/vtpm" > -#define VTPM_DUMMY_TX_BE_FNAME "/var/vtpm/fifos/dummy_out.fifo" > -#define VTPM_DUMMY_RX_BE_FNAME "/var/vtpm/fifos/dummy_in.fifo" > -#define VTPM_TX_TPM_FNAME "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -#define VTPM_RX_TPM_FNAME "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > -#define VTPM_TX_VTPM_FNAME "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -#define VTPM_RX_VTPM_FNAME "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > - > -#define VTPM_TYPE_PVM_STRING "pvm" > -#define VTPM_TYPE_HVM_STRING "hvm" > - > -struct vtpm_thread_params_s { > - vtpm_ipc_handle_t *tx_ipc_h; > - vtpm_ipc_handle_t *rx_ipc_h; > - BOOL fw_tpm; > - vtpm_ipc_handle_t *fw_tx_ipc_h; > - vtpm_ipc_handle_t *fw_rx_ipc_h; > - BOOL is_priv; > - char *thread_name; > -}; > - > -// This is needed to all extra_close_dmi to close this to prevent a > -// broken pipe when no DMIs are left. > -static vtpm_ipc_handle_t *g_rx_tpm_ipc_h; > - > -void *vtpm_manager_thread(void *arg_void) { > - TPM_RESULT *status = (TPM_RESULT *) malloc(sizeof(TPM_RESULT) ); > - struct vtpm_thread_params_s *arg = (struct vtpm_thread_params_s *) arg_void; > - > - *status = VTPM_Manager_Handler(arg->tx_ipc_h, arg->rx_ipc_h, > - arg->fw_tpm, arg->fw_tx_ipc_h, arg->fw_rx_ipc_h, > - arg->is_priv, arg->thread_name); > - > - return (status); > -} > - > - > -void signal_handler(int reason) { > - if (pthread_equal(pthread_self(), vtpm_globals->master_pid)) { > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager shutting down for signal %d.\n", reason); > - } else { > - // For old Linux Thread machines, signals are delivered to each thread. Deal with them. > - vtpmloginfo(VTPM_LOG_VTPM, "Child shutting down\n"); > - pthread_exit(NULL); > - } > - > - VTPM_Stop_Manager(); > - exit(-1); > -} > - > -struct sigaction ctl_c_handler; > - > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode) { > - > - TPM_RESULT status = TPM_SUCCESS; > - int fh; > - char dmi_id_str[11]; // UINT32s are up to 10 digits + NULL > - char *tx_vtpm_name, *tx_tpm_name, *vm_type_string; > - struct stat file_info; > - > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > - dmi_res->tx_tpm_ipc_h = NULL; > - dmi_res->rx_tpm_ipc_h = NULL; > - dmi_res->tx_vtpm_ipc_h = NULL; > - dmi_res->rx_vtpm_ipc_h = NULL; > - } else { > - // Create a pair of fifo pipes > - dmi_res->rx_tpm_ipc_h = NULL; > - dmi_res->rx_vtpm_ipc_h = NULL; > - > - if ( ((dmi_res->tx_tpm_ipc_h = (vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > - ((dmi_res->tx_vtpm_ipc_h =(vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > - ((tx_tpm_name = (char *) malloc(11 + strlen(VTPM_TX_TPM_FNAME))) == NULL ) || > - ((tx_vtpm_name =(char *) malloc(11 + strlen(VTPM_TX_VTPM_FNAME))) == NULL) ) { > - status =TPM_RESOURCES; > - goto abort_egress; > - } > - > - sprintf(tx_tpm_name, VTPM_TX_TPM_FNAME, (uint32_t) dmi_res->dmi_id); > - sprintf(tx_vtpm_name, VTPM_TX_VTPM_FNAME, (uint32_t) dmi_res->dmi_id); > - > - if ( (vtpm_ipc_init(dmi_res->tx_tpm_ipc_h, tx_tpm_name, O_WRONLY | O_NONBLOCK, TRUE) != 0) || > - (vtpm_ipc_init(dmi_res->tx_vtpm_ipc_h, tx_vtpm_name, O_WRONLY, TRUE) != 0) ) { //FIXME: O_NONBLOCK? > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Measure DMI > - // FIXME: This will measure DMI. Until then use a fixed DMI_Measurement value > - // Also, this mechanism is specific to 1 VM architecture. > - /* > - fh = open(TPM_EMULATOR_PATH, O_RDONLY); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - dmi_size = file_stat.st_size; > - else { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not open vtpmd!!\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - dmi_buffer > - */ > - memset(&dmi_res->DMI_measurement, 0xcc, sizeof(TPM_DIGEST)); > - > - if (vm_type == VTPM_TYPE_PVM) > - vm_type_string = (BYTE *)&VTPM_TYPE_PVM_STRING; > - else > - vm_type_string = (BYTE *)&VTPM_TYPE_HVM_STRING; > - > - // Launch DMI > - sprintf(dmi_id_str, "%d", (int) dmi_res->dmi_id); > -#ifdef MANUAL_DM_LAUNCH > - vtpmlogerror(VTPM_LOG_VTPM, "Manually start VTPM with dmi=%s now.\n", dmi_id_str); > - dmi_res->dmi_pid = 0; > -#else > - pid_t pid = fork(); > - > - if (pid == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not fork to launch vtpm\n"); > - status = TPM_RESOURCES; > - goto abort_egress; > - } else if (pid == 0) { > - switch (startup_mode) { > - case TPM_ST_CLEAR: > - execl (TPM_EMULATOR_PATH, "vtpmd", "clear", vm_type_string, dmi_id_str, NULL); > - break; > - case TPM_ST_STATE: > - execl (TPM_EMULATOR_PATH, "vtpmd", "save", vm_type_string, dmi_id_str, NULL); > - break; > - case TPM_ST_DEACTIVATED: > - execl (TPM_EMULATOR_PATH, "vtpmd", "deactivated", vm_type_string, dmi_id_str, NULL); > - break; > - default: > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Returning from these at all is an error. > - vtpmlogerror(VTPM_LOG_VTPM, "Could not exec to launch vtpm\n"); > - } else { > - dmi_res->dmi_pid = pid; > - vtpmloginfo(VTPM_LOG_VTPM, "Launching DMI on PID = %d\n", pid); > - } > -#endif // MANUAL_DM_LAUNCH > - > - } // If DMI = VTPM_CTL_DM > - status = TPM_SUCCESS; > - > -abort_egress: > - return (status); > -} > - > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res) { > - TPM_RESULT status = TPM_SUCCESS; > - > - if (vtpm_globals->connected_dmis == 0) { > - // No more DMI's connected. Close fifo to prevent a broken pipe. > - // This is hackish. Need to think of another way. > - vtpm_ipc_close(g_rx_tpm_ipc_h); > - } > - > - > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > - vtpm_ipc_close(dmi_res->tx_tpm_ipc_h); > - vtpm_ipc_close(dmi_res->tx_vtpm_ipc_h); > - > - free(dmi_res->tx_tpm_ipc_h->name); > - free(dmi_res->tx_vtpm_ipc_h->name); > - > -#ifndef MANUAL_DM_LAUNCH > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > - if (dmi_res->dmi_pid != 0) { > - vtpmloginfo(VTPM_LOG_VTPM, "Killing dmi on pid %d.\n", dmi_res->dmi_pid); > - if (kill(dmi_res->dmi_pid, SIGKILL) !=0) { > - vtpmloginfo(VTPM_LOG_VTPM, "DMI on pid %d is already dead.\n", dmi_res->dmi_pid); > - } else if (waitpid(dmi_res->dmi_pid, NULL, 0) != dmi_res->dmi_pid) { > - vtpmlogerror(VTPM_LOG_VTPM, "DMI on pid %d failed to stop.\n", dmi_res->dmi_pid); > - status = TPM_FAIL; > - } > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not kill dmi because it's pid was 0.\n"); > - status = TPM_FAIL; > - } > - } > -#endif > - > - } //endif ! dom0 > - return status; > -} > - > - > -int main(int argc, char **argv) { > - vtpm_ipc_handle_t *tx_be_ipc_h, *rx_be_ipc_h, rx_tpm_ipc_h, rx_vtpm_ipc_h, tx_hp_ipc_h, rx_hp_ipc_h; > - struct vtpm_thread_params_s be_thread_params, dmi_thread_params, hp_thread_params; > - pthread_t be_thread, dmi_thread, hp_thread; > - > -#ifdef DUMMY_BACKEND > - vtpm_ipc_handle_t tx_dummy_ipc_h, rx_dummy_ipc_h; > -#else > - vtpm_ipc_handle_t real_be_ipc_h; > -#endif > - > - vtpmloginfo(VTPM_LOG_VTPM, "Starting VTPM.\n"); > - > - // -------------------- Initialize Manager ----------------- > - if (VTPM_Init_Manager() != TPM_SUCCESS) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing vtpmd due to error during startup.\n"); > - return -1; > - } > - > - // -------------------- Setup Ctrl+C Handlers -------------- > - ctl_c_handler.sa_handler = signal_handler; > - sigemptyset(&ctl_c_handler.sa_mask); > - ctl_c_handler.sa_flags = 0; > - > - if (sigaction(SIGINT, &ctl_c_handler, NULL) == -1) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGINT handler. Ctl+break will not stop manager gently.\n"); > - > - // For easier debuggin with gdb > - if (sigaction(SIGHUP, &ctl_c_handler, NULL) == -1) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGHUP handler. Ctl+break will not stop manager gently.\n"); > - > - sigset_t sig_mask; > - sigemptyset(&sig_mask); > - sigaddset(&sig_mask, SIGPIPE); > - sigprocmask(SIG_BLOCK, &sig_mask, NULL); > - > - // ------------------- Set up file ipc structures ---------- > -#ifdef DUMMY_BACKEND > - if ( (vtpm_ipc_init(&tx_dummy_ipc_h, VTPM_DUMMY_TX_BE_FNAME, O_RDWR, TRUE) != 0) || > - (vtpm_ipc_init(&rx_dummy_ipc_h, VTPM_DUMMY_RX_BE_FNAME, O_RDWR, TRUE) != 0) ) { > - > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create Dummy BE FIFOs.\n"); > - exit(-1); > - } > - > - tx_be_ipc_h = &tx_dummy_ipc_h; > - rx_be_ipc_h = &rx_dummy_ipc_h; > -#else > - vtpm_ipc_init(&real_be_ipc_h, VTPM_BE_FNAME, O_RDWR, FALSE); > - > - tx_be_ipc_h = &real_be_ipc_h; > - rx_be_ipc_h = &real_be_ipc_h; > -#endif > - > - if ( (vtpm_ipc_init(&rx_tpm_ipc_h, VTPM_RX_TPM_FNAME, O_RDONLY, TRUE) != 0) || > - (vtpm_ipc_init(&rx_vtpm_ipc_h, VTPM_RX_VTPM_FNAME, O_RDWR, TRUE) != 0) || //FIXME: O_RDONLY? > - (vtpm_ipc_init(&tx_hp_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || > - (vtpm_ipc_init(&rx_hp_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create initial FIFOs.\n"); > - exit(-1); > - } > - > - g_rx_tpm_ipc_h = &rx_tpm_ipc_h; > - > - // -------------------- Set up thread params ------------- > - > - be_thread_params.tx_ipc_h = tx_be_ipc_h; > - be_thread_params.rx_ipc_h = rx_be_ipc_h; > - be_thread_params.fw_tpm = TRUE; > - be_thread_params.fw_tx_ipc_h = NULL; > - be_thread_params.fw_rx_ipc_h = &rx_tpm_ipc_h; > - be_thread_params.is_priv = FALSE; > - be_thread_params.thread_name = "Backend Listener"; > - > - dmi_thread_params.tx_ipc_h = NULL; > - dmi_thread_params.rx_ipc_h = &rx_vtpm_ipc_h; > - dmi_thread_params.fw_tpm = FALSE; > - dmi_thread_params.fw_tx_ipc_h = NULL; > - dmi_thread_params.fw_rx_ipc_h = NULL; > - dmi_thread_params.is_priv = FALSE; > - dmi_thread_params.thread_name = "VTPM Listener"; > - > - hp_thread_params.tx_ipc_h = &tx_hp_ipc_h; > - hp_thread_params.rx_ipc_h = &rx_hp_ipc_h; > - hp_thread_params.fw_tpm = FALSE; > - hp_thread_params.fw_tx_ipc_h = NULL; > - hp_thread_params.fw_rx_ipc_h = NULL; > - hp_thread_params.is_priv = TRUE; > - hp_thread_params.thread_name = "Hotplug Listener"; > - > - // --------------------- Launch Threads ----------------- > - > - vtpm_lock_init(); > - > - vtpm_globals->master_pid = pthread_self(); > - > - if (pthread_create(&be_thread, NULL, vtpm_manager_thread, &be_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch BE Thread.\n"); > - exit(-1); > - } > - > - if (pthread_create(&dmi_thread, NULL, vtpm_manager_thread, &dmi_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch DMI Thread.\n"); > - exit(-1); > - } > - > - > - if (pthread_create(&hp_thread, NULL, vtpm_manager_thread, &hp_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch HP Thread.\n"); > - exit(-1); > - } > - > - //Join the other threads until exit time. > - pthread_join(be_thread, NULL); > - pthread_join(dmi_thread, NULL); > - pthread_join(hp_thread, NULL); > - > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Manager shut down unexpectedly.\n"); > - > - VTPM_Stop_Manager(); > - vtpm_lock_destroy(); > - return 0; > -} > diff --git a/tools/vtpm_manager/manager/vtpmpriv.h b/tools/vtpm_manager/manager/vtpmpriv.h > deleted file mode 100644 > index 41e8d2d..0000000 > --- a/tools/vtpm_manager/manager/vtpmpriv.h > +++ /dev/null > @@ -1,186 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpmpriv.h > -// > -// Structures and functions private to the manager > -// > -// ================================================================== > - > -#ifndef __VTPMPRIV_H__ > -#define __VTPMPRIV_H__ > - > -#include "vtpm_manager.h" > -#include "tcg.h" > -#include "tcs.h" > -#include "buffer.h" > -#include "crypto.h" > -#include "vtpm_ipc.h" > - > -#define VTPM_MANAGER_GEN 2 // This is incremented when the manager's table > - // is changed. It's used for backwards compatability > - > -#define STATE_FILE "/var/vtpm/VTPM" > -#define DMI_NVM_FILE "/var/vtpm/vtpm_dm_%d.data" > -#define VTPM_CTL_DM 0 > - > -// ------------------------ Private Structures ----------------------- > -typedef struct VTPM_DMI_RESOURCE_T { > - // I/O info for Manager to talk to DMI's and controllers > - vtpm_ipc_handle_t *tx_vtpm_ipc_h; // TX VTPM Results to DMI > - vtpm_ipc_handle_t *rx_vtpm_ipc_h; // RX VTPM Commands from DMI > - vtpm_ipc_handle_t *tx_tpm_ipc_h; // TX TPM Commands to DMI > - vtpm_ipc_handle_t *rx_tpm_ipc_h; // RX TPM Results from DMI > - > -#ifndef VTPM_MULTI_VM > - pid_t dmi_pid; > -#endif > - > - // Non-persistent Information > - bool connected; > - UINT32 dmi_domain_id; > - TCS_CONTEXT_HANDLE TCSContext; // TCS Handle > - char *NVMLocation; // NULL term string indicating location > - // of NVM. > - // Persistent Information about DMI > - UINT32 dmi_id; > - BYTE dmi_type; > - TPM_DIGEST NVM_measurement; // Equal to the SHA1 of the blob > - TPM_DIGEST DMI_measurement; // Correct measurement of the owning DMI > -} VTPM_DMI_RESOURCE; > - > -typedef struct tdVTPM_MIGKEY_LIST { > - UINT32 name_size; > - BYTE *name; // Name of destination (IP addr, domain name, etc) > - CRYPTO_INFO key; > - struct tdVTPM_MIGKEY_LIST *next; > -} VTPM_MIGKEY_LIST; > - > - > -typedef struct tdVTPM_GLOBALS { > - // Non-persistent data > -#ifndef VTPM_MULTI_VM > - pid_t master_pid; > -#endif > - > - int connected_dmis; // To close guest_rx when no dmis are connected > - > - struct hashtable *dmi_map; // Table of all DMI's known indexed by persistent instance # > - VTPM_MIGKEY_LIST *mig_keys; // Table of migration keys > - // Currently keys are loaded at migration time, > - // TODO: Make VTPM man store a keys persistently > - // and update script to check if key is needed > - // before fetching it. > - > - TCS_CONTEXT_HANDLE manager_tcs_handle; // TCS Handle used by manager > - TPM_HANDLE storageKeyHandle; // Key used by persistent store > - CRYPTO_INFO storageKey; // For software encryption > - CRYPTO_INFO bootKey; // For saving table > - TCS_AUTH keyAuth; // OIAP session for storageKey > - > - // Persistent Data > - TPM_AUTHDATA owner_usage_auth; // OwnerAuth of real TPM > - buffer_t storageKeyWrap; // Wrapped copy of storageKey > - TPM_AUTHDATA srk_usage_auth; > - TPM_AUTHDATA storage_key_usage_auth; > - > - buffer_t bootKeyWrap; // Wrapped copy of boot key > - > -}VTPM_GLOBALS; > - > -// --------------------------- Global Values -------------------------- > -extern VTPM_GLOBALS *vtpm_globals; // Key info and DMI states > -extern const TPM_AUTHDATA SRK_AUTH; // SRK Well Known Auth Value > - > -// ********************** VTPM Functions ************************* > -TPM_RESULT VTPM_Init_Manager(); // Start VTPM Service > -void VTPM_Stop_Manager(); // Stop VTPM Service > -TPM_RESULT VTPM_Manager_Handler(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - BOOL fw_tpm, // Should forward TPM cmds > - vtpm_ipc_handle_t *fw_tx_ipc_h, > - vtpm_ipc_handle_t *fw_rx_ipc_h, > - BOOL is_priv, > - char *client_name); > - > -// ********************** Command Handler Prototypes *********************** > - > -TPM_RESULT VTPM_Handle_Load_NVM( VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_Save_NVM( VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > - buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Close_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Delete_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_Handle_Migrate_Out ( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_SaveManagerData(void); > -TPM_RESULT VTPM_LoadManagerData(void); > - > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode); > - > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res); > - > -// Helper functions > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res); > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE type, VTPM_DMI_RESOURCE **dmi_res); > - > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > - CRYPTO_INFO *asymkey, > - buffer_t *sealed_data); > - > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > - TCS_CONTEXT_HANDLE TCSContext, > - TPM_HANDLE keyHandle, > - const TPM_AUTHDATA *key_usage_auth, > - buffer_t *unsealed_data); > - > -#endif // __VTPMPRIV_H__ > diff --git a/tools/vtpm_manager/manager/vtsp.c b/tools/vtpm_manager/manager/vtsp.c > deleted file mode 100644 > index fc8a66f..0000000 > --- a/tools/vtpm_manager/manager/vtsp.c > +++ /dev/null > @@ -1,1042 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtsp.c > -// > -// Higher level interface to TCS for use in service. > -// > -// ================================================================== > - > -#include > -#include "tcg.h" > -#include "tcs.h" > -#include "bsg.h" > -#include "log.h" > -#include "crypto.h" > -#include "vtsp.h" > -#include "buffer.h" > - > -#define RSA_KEY_SIZE 0x0800 > - > -/*********************************************************************************** > - * GenerateAuth: Generate authorization info to be sent back to application > - * > - * Parameters: outParamDigestText The concatenation of output parameters to be SHA1ed > - * outParamDigestTextSize Size of inParamDigestText > - * HMACkey Key to be used for HMACing > - * For OIAP use key.authUsage or PersistStore.ownerAuth > - * For OSAP use shared secret > - * pAuth Authorization information from the application > - * > - * Return: TPM_SUCCESS Authorization data created > - * TPM_AUTHFAIL Invalid (NULL) HMACkey presented for OSAP > - *************************************************************************************/ > -TPM_RESULT GenerateAuth( /*[IN]*/ const BYTE *inParamDigestText, > - /*[IN]*/ UINT32 inParamDigestTextSize, > - /*[IN]*/ const TPM_SECRET *HMACkey, > - /*[IN,OUT]*/ TCS_AUTH *auth) { > - > - if (inParamDigestText == NULL || auth == NULL) > - return (TPM_AUTHFAIL); > - else { > - > - //Generate new OddNonce > - Crypto_GetRandom(auth->NonceOdd.nonce, sizeof(TPM_NONCE)); > - > - // Create SHA1 inParamDigest > - TPM_DIGEST inParamDigest; > - Crypto_SHA1Full(inParamDigestText, inParamDigestTextSize, (BYTE *) &inParamDigest); > - > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > - > - BSG_PackList( hmacText, 4, > - BSG_TPM_DIGEST, &inParamDigest, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > - > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &(auth->HMAC)); > - > - return(TPM_SUCCESS); > - > - } > -} > - > -/*********************************************************************************** > - * VerifyAuth: Verify the authdata for a command requiring authorization > - * > - * Parameters: inParamDigestText The concatenation of parameters to be SHA1ed > - * inParamDigestTextSize Size of inParamDigestText > - * authDataUsage AuthDataUsage for the Entity being used > - * Key->authDataUsage or TPM_AUTH_OWNER > - * HMACkey Key to be used for HMACing > - * For OIAP use key.authUsage or PersistStore.ownerAuth > - * For OSAP use NULL (It will be aquired from the Auth Session) > - * If unknown (default), assume OIAP > - * sessionAuth A TCS_AUTH info for the session > - * pAuth Authorization information from the application > - * hContext If specified, on failed Auth, VerifyAuth will > - * generate a new OIAP session in place of themselves > - * destroyed session. > - * > - * Return: TPM_SUCCESS Authorization Verified > - * TPM_AUTHFAIL Authorization Failed > - * TPM_FAIL Failure during SHA1 routines > - *************************************************************************************/ > -TPM_RESULT VerifyAuth( /*[IN]*/ const BYTE *outParamDigestText, > - /*[IN]*/ UINT32 outParamDigestTextSize, > - /*[IN]*/ const TPM_SECRET *HMACkey, > - /*[IN,OUT]*/ TCS_AUTH *auth, > - /*[IN]*/ TCS_CONTEXT_HANDLE hContext) { > - if (outParamDigestText == NULL || auth == NULL) > - return (TPM_AUTHFAIL); > - > - > - // Create SHA1 inParamDigest > - TPM_DIGEST outParamDigest; > - Crypto_SHA1Full(outParamDigestText, outParamDigestTextSize, (BYTE *) &outParamDigest); > - > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > - TPM_DIGEST hm; > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > - > - BSG_PackList( hmacText, 4, > - BSG_TPM_DIGEST, &outParamDigest, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > - > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), > - (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &hm); > - > - // Compare correct HMAC with provided one. > - if (memcmp (&hm, &(auth->HMAC), sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality > - if (!auth->fContinueAuthSession) > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM by fContinue=0.\n", auth->AuthHandle); > - > - return (TPM_SUCCESS); > - } else { > - // If specified, reconnect the OIAP session. > - // NOTE: This only works for TCS's that never have a 0 context. > - if (hContext) { > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM due to failure.\n", auth->AuthHandle); > - VTSP_OIAP( hContext, auth); > - } > - return (TPM_AUTHFAIL); > - } > -} > - > -TPM_RESULT VTSP_OIAP(const TCS_CONTEXT_HANDLE hContext, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "OIAP.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPMTRYRETURN( TCSP_OIAP(hContext, > - &auth->AuthHandle, > - &auth->NonceEven) ); > - > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > - auth->fContinueAuthSession = FALSE; > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -TPM_RESULT VTSP_OSAP(const TCS_CONTEXT_HANDLE hContext, > - const TPM_ENTITY_TYPE entityType, > - const UINT32 entityValue, > - const TPM_AUTHDATA *usageAuth, > - TPM_SECRET *sharedSecret, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "OSAP.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPM_NONCE nonceEvenOSAP, nonceOddOSAP; > - > - Crypto_GetRandom((BYTE *) &nonceOddOSAP, sizeof(TPM_NONCE) ); > - > - TPMTRYRETURN( TCSP_OSAP( hContext, > - entityType, > - entityValue, > - nonceOddOSAP, > - &auth->AuthHandle, > - &auth->NonceEven, > - &nonceEvenOSAP) ); > - > - // Calculating Session Secret > - BYTE sharedSecretText[TPM_DIGEST_SIZE * 2]; > - > - BSG_PackList( sharedSecretText, 2, > - BSG_TPM_NONCE, &nonceEvenOSAP, > - BSG_TPM_NONCE, &nonceOddOSAP); > - > - Crypto_HMAC(sharedSecretText, sizeof(sharedSecretText), (BYTE *) usageAuth, TPM_DIGEST_SIZE, (BYTE *) sharedSecret); > - > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > - auth->fContinueAuthSession = FALSE; > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > - > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > - const TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Terminate Handle.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPMTRYRETURN( TCSP_TerminateHandle(hContext, auth->AuthHandle) ); > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM_TerminateHandle.\n", auth->AuthHandle); > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > - > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > - CRYPTO_INFO *crypto_info) { > - > - TPM_RESULT status; > - TPM_NONCE antiReplay; > - TPM_DIGEST checksum; > - BYTE *pubEKtext; > - UINT32 pubEKtextsize; > - > - vtpmloginfo(VTPM_LOG_VTSP, "Reading Public EK.\n"); > - > - // GenerateAuth new nonceOdd > - Crypto_GetRandom(&antiReplay, sizeof(TPM_NONCE) ); > - > - > - TPMTRYRETURN( TCSP_ReadPubek( hContext, > - antiReplay, > - &pubEKtextsize, > - &pubEKtext, > - &checksum) ); > - > - > - // Extract the remaining output parameters > - TPM_PUBKEY pubEK; > - > - BSG_Unpack(BSG_TPM_PUBKEY, pubEKtext, (BYTE *) &pubEK); > - > - // Build CryptoInfo for the bindingKey > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - pubEK.algorithmParms.parms, > - &rsaKeyParms); > - > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > - rsaKeyParms.exponent, > - pubEK.pubKey.keyLength, > - pubEK.pubKey.key, > - crypto_info); > - > - // Destroy rsaKeyParms > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > - > - // Set encryption scheme > - crypto_info->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - //crypto_info->encScheme = pubEK.algorithmParms.encScheme; > - crypto_info->algorithmID = pubEK.algorithmParms.algorithmID; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - const TPM_AUTHDATA *srkAuth, > - CRYPTO_INFO *ek_cryptoInfo, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Taking Ownership of TPM.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_TakeOwnership; > - TPM_PROTOCOL_ID proto_id = TPM_PID_OWNER; > - BYTE *new_srk; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // vars for srkpubkey parameter > - TPM_KEY srkPub; > - TPM_KEY_PARMS srkKeyInfo = {TPM_ALG_RSA, TPM_ES_RSAESOAEP_SHA1_MGF1, TPM_SS_NONE, 12, 0}; > - BYTE srkRSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > - srkKeyInfo.parms = (BYTE *) &srkRSAkeyInfo; > - > - struct pack_buf_t srkText; > - > - //These values are accurate for an enc(AuthData). > - struct pack_buf_t encOwnerAuth, encSrkAuth; > - > - encOwnerAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > - encSrkAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > - > - if (encOwnerAuth.data == NULL || encSrkAuth.data == NULL) { > - vtpmloginfo(VTPM_LOG_VTSP, "Could not malloc encrypted auths.\n"); > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) ownerAuth, &encOwnerAuth.size, encOwnerAuth.data); > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) srkAuth, &encSrkAuth.size, encSrkAuth.data); > - > - > - // Build srk public key struct > - srkPub.ver = TPM_STRUCT_VER_1_1; > - srkPub.keyUsage = TPM_KEY_STORAGE; > - srkPub.keyFlags = 0x00; > - srkPub.authDataUsage = TPM_AUTH_ALWAYS; > - memcpy(&srkPub.algorithmParms, &srkKeyInfo, sizeof(TPM_KEY_PARMS)); > - srkPub.PCRInfoSize = 0; > - srkPub.PCRInfo = 0; > - srkPub.pubKey.keyLength= 0; > - srkPub.encDataSize = 0; > - > - srkText.data = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - srkText.size = BSG_Pack(BSG_TPM_KEY, (BYTE *) &srkPub, srkText.data); > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 5, > - BSG_TPM_COMMAND_CODE,&command, > - BSG_TPM_PROTOCOL_ID, &proto_id, > - BSG_TPM_SIZE32_DATA, &encOwnerAuth, > - BSG_TPM_SIZE32_DATA, &encSrkAuth, > - BSG_TPM_KEY, &srkPub); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, ownerAuth, auth) ); > - > - new_srk = srkText.data; > - TPMTRYRETURN( TCSP_TakeOwnership ( hContext, > - proto_id, > - encOwnerAuth.size, > - encOwnerAuth.data, > - encSrkAuth.size, > - encSrkAuth.data, > - &srkText.size, > - &new_srk, > - auth ) ); > - > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - memcpy(paramText + paramTextSize, new_srk, srkText.size); > - paramTextSize += srkText.size; > - > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - ownerAuth, auth, > - hContext) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(srkText.data); > - free(encSrkAuth.data); > - free(encOwnerAuth.data); > - free(paramText); > - > - TCS_FreeMemory(hContext, new_srk); > - > - return status; > -} > - > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Disabling Pubek Read.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_DisablePubekRead; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 1, > - BSG_TPM_COMMAND_CODE, &command); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - ownerAuth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_DisablePubekRead ( hContext, // in > - auth) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - ownerAuth, auth, > - hContext) ); > - goto egress; > - > - abort_egress: > - egress: > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_USAGE usage, > - const TPM_AUTHDATA *newKeyAuth, > - const TCS_KEY_HANDLE parentHandle, > - const TPM_AUTHDATA *osapSharedSecret, > - buffer_t *pubKeyBuf, > - TCS_AUTH *auth) { > - > - int i; > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_CreateWrapKey; > - > - vtpmloginfo(VTPM_LOG_VTSP, "Creating new key of type %d.\n", usage); > - > - // vars for Calculate encUsageAuth > - BYTE *paramText; > - UINT32 paramTextSize; > - > - // vars for Calculate encUsageAuth > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > - TPM_DIGEST XORKey1; > - UINT32 XORbufferSize; > - TPM_SECRET encUsageAuth, encMigrationAuth; > - > - // vars for Flatten newKey prototype > - BYTE *flatKey = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - UINT32 flatKeySize = TCPA_MAX_BUFFER_LENGTH; > - struct pack_buf_t newKeyText; > - > - // Fill in newKey > - TPM_KEY newKey; > - > - BYTE RSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > - newKey.algorithmParms.algorithmID = TPM_ALG_RSA; > - newKey.algorithmParms.parms = (BYTE *) &RSAkeyInfo; > - newKey.algorithmParms.parmSize = 12; > - > - switch (usage) { > - case TPM_KEY_SIGNING: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Signing Key...\n"); > - newKey.keyUsage = TPM_KEY_SIGNING; > - newKey.algorithmParms.encScheme = TPM_ES_NONE; > - newKey.algorithmParms.sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1; > - break; > - case TPM_KEY_STORAGE: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Storage Key...\n"); > - newKey.keyUsage = TPM_KEY_STORAGE; > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > - break; > - case TPM_KEY_BIND: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Binding Key...\n"); > - newKey.keyUsage = TPM_KEY_BIND; > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > - break; > - default: > - vtpmloginfo(VTPM_LOG_VTSP, "Cannot create key. Invalid Key Type.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - > - newKey.ver = TPM_STRUCT_VER_1_1; > - > - newKey.keyFlags = 0; > - newKey.authDataUsage = TPM_AUTH_ALWAYS; > - newKey.pubKey.keyLength= 0; > - newKey.encDataSize = 0; > - newKey.encData = NULL; > - > - // FIXME: Support PCR bindings > - newKey.PCRInfoSize = 0; > - newKey.PCRInfo = NULL; > - > - // Calculate encUsageAuth > - XORbufferSize = BSG_PackList( XORbuffer, 2, > - BSG_TPM_SECRET, osapSharedSecret, > - BSG_TPM_NONCE, &auth->NonceEven); > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey1); > - > - // FIXME: No support for migratable keys. > - for (i=0; i < TPM_DIGEST_SIZE; i++) > - ((BYTE *) &encUsageAuth)[i] = ((BYTE *) &XORKey1)[i] ^ ((BYTE *) newKeyAuth)[i]; > - > - // Flatten newKey prototype > - flatKeySize = BSG_Pack(BSG_TPM_KEY, (BYTE *) &newKey, flatKey); > - newKeyText.data = flatKey; > - newKeyText.size = flatKeySize; > - > - // Generate HMAC > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_AUTHDATA, &encUsageAuth, > - BSG_TPM_AUTHDATA, &encMigrationAuth); > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > - paramTextSize += newKeyText.size; > - > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - osapSharedSecret, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_CreateWrapKey( hContext, > - parentHandle, > - encUsageAuth, > - encMigrationAuth, > - &newKeyText.size, > - &newKeyText.data, > - auth) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > - paramTextSize += newKeyText.size; > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - osapSharedSecret, auth, 0) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init(pubKeyBuf, 0, 0) ); > - TPMTRYRETURN(buffer_append_raw(pubKeyBuf, newKeyText.size, newKeyText.data) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(flatKey); > - free(paramText); > - TCS_FreeMemory(hContext, newKeyText.data); > - > - return status; > -} > - > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > - const TCS_KEY_HANDLE hUnwrappingKey, > - const buffer_t *rgbWrappedKeyBlob, > - const TPM_AUTHDATA *parentAuth, > - TPM_HANDLE *newKeyHandle, > - TCS_AUTH *auth, > - CRYPTO_INFO *cryptoinfo, > - const BOOL skipTPMLoad) { > - > - > - vtpmloginfo(VTPM_LOG_VTSP, "Loading Key %s.\n", (!skipTPMLoad ? "into TPM" : "only into memory")); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_LoadKey; > - > - BYTE *paramText=NULL; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // SkipTPMLoad stops key from being loaded into TPM, but still generates CRYPTO_INFO for it > - if (! skipTPMLoad) { > - > - if ((rgbWrappedKeyBlob == NULL) || (parentAuth == NULL) || > - (newKeyHandle==NULL) || (auth==NULL)) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Generate Extra TCS Parameters > - TPM_HANDLE phKeyHMAC; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 1, > - BSG_TPM_COMMAND_CODE, &command); > - > - memcpy(paramText + paramTextSize, rgbWrappedKeyBlob->bytes, buffer_len(rgbWrappedKeyBlob)); > - paramTextSize += buffer_len(rgbWrappedKeyBlob); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - parentAuth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_LoadKeyByBlob( hContext, > - hUnwrappingKey, > - buffer_len(rgbWrappedKeyBlob), > - rgbWrappedKeyBlob->bytes, > - auth, > - newKeyHandle, > - &phKeyHMAC) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_HANDLE, newKeyHandle); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - parentAuth, auth, > - hContext) ); > - } > - > - // Build cryptoinfo structure for software crypto function. > - if (cryptoinfo != NULL) { > - TPM_KEY newKey; > - > - // Unpack/return key structure > - BSG_Unpack(BSG_TPM_KEY, rgbWrappedKeyBlob->bytes , &newKey); > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - newKey.algorithmParms.parms, > - &rsaKeyParms); > - > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > - rsaKeyParms.exponent, > - newKey.pubKey.keyLength, > - newKey.pubKey.key, > - cryptoinfo); > - > - // Destroy rsaKeyParms > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > - > - // Set encryption scheme > - cryptoinfo->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - } > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE key_handle, > - const buffer_t *bound_data, > - const TPM_AUTHDATA *usage_auth, > - buffer_t *clear_data, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Unbinding %d bytes of data.\n", buffer_len(bound_data)); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_UnBind; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate Extra TCS Parameters > - struct pack_buf_t clear_data32; > - BYTE *clear_data_text; > - UINT32 clear_data_size; > - > - struct pack_buf_t bound_data32 = {bound_data->size, bound_data->bytes}; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &bound_data32); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - usage_auth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_UnBind( hContext, > - key_handle, > - buffer_len(bound_data), > - bound_data->bytes, > - auth, > - &clear_data_size, > - &clear_data_text) ); > - > - > - // Verify Auth > - clear_data32.size = clear_data_size; > - clear_data32.data = clear_data_text; > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &clear_data32); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - usage_auth, auth, > - hContext) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init(clear_data, 0, 0)); > - TPMTRYRETURN(buffer_append_raw (clear_data, clear_data_size, clear_data_text) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(paramText); > - TCS_FreeMemory(hContext, clear_data_text); > - > - return status; > -} > - > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > - const buffer_t *inData, > - buffer_t *outData) > -{ > - vtpmloginfo(VTPM_LOG_VTSP, "Binding %d bytes of data.\n", buffer_len(inData)); > - TPM_RESULT status = TPM_SUCCESS; > - TPM_BOUND_DATA boundData; > - UINT32 i; > - > - // Fill boundData's accessory information > - boundData.ver = TPM_STRUCT_VER_1_1; > - boundData.payload = TPM_PT_BIND; > - boundData.payloadData = inData->bytes; > - > - // Pack boundData before encryption > - BYTE* flatBoundData = (BYTE *)malloc(sizeof(BYTE) * > - (sizeof(TPM_VERSION) + > - sizeof(TPM_PAYLOAD_TYPE) + > - buffer_len(inData))); > - if (flatBoundData == NULL) { > - return TPM_NOSPACE; > - } > - UINT32 flatBoundDataSize = 0; > - flatBoundDataSize = BSG_PackList( flatBoundData, 2, > - BSG_TPM_VERSION, &boundData.ver, > - BSG_TYPE_BYTE, &boundData.payload); > - > - memcpy(flatBoundData+flatBoundDataSize, inData->bytes, buffer_len(inData)); > - flatBoundDataSize += buffer_len(inData); > - > - BYTE out_tmp[RSA_KEY_SIZE/8]; // RSAEnc does not do blocking, So this is what will come out. > - UINT32 out_tmp_size; > - > - // Encrypt flatBoundData > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_RSAEnc( cryptoInfo, > - flatBoundDataSize, > - flatBoundData, > - &out_tmp_size, > - out_tmp) ); > - > - if (out_tmp_size > RSA_KEY_SIZE/8) { > - // The result of RSAEnc should be a fixed size based on key size. > - vtpmlogerror(VTPM_LOG_VTSP, "Enc buffer just overflowed.\n"); > - } > - > - buffer_init(outData, 0, NULL); > - buffer_append_raw(outData, out_tmp_size, out_tmp); > - > - vtpmloginfo(VTPM_LOG_TXDATA, "Bind Generated[%d] = 0x", out_tmp_size); > - for(i = 0 ; i < out_tmp_size ; i++) { > - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out_tmp[i]); > - } > - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); > - > - goto egress; > - abort_egress: > - egress: > - > - // Free flatBoundData > - free(flatBoundData); > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_AUTHDATA *sealDataAuth, > - const TPM_PCR_COMPOSITE *pcrComp, > - const buffer_t *inData, > - TPM_STORED_DATA *sealedData, > - const TPM_SECRET *osapSharedSecret, > - TCS_AUTH *auth) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_Seal; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate PCR_Info Struct from Comp > - TPM_PCR_INFO pcrInfo; > - UINT32 pcrInfoSize, flatpcrSize; > - BYTE flatpcr[3 + // PCR_Select = 3 1 byte banks > - sizeof(UINT16) + // 2 byte UINT16 > - sizeof(UINT32) + // PCR_Comp = 4 byte UINT32 > - 24 * sizeof(TPM_PCRVALUE) ]; // up to 24 PCRs > - > - if (pcrComp != NULL) { > - //printf("\n\tBinding to PCRs: "); > - //for(int i = 0 ; i < pcrComp->select.sizeOfSelect ; i++) > - //printf("%2.2x", pcrComp->select.pcrSelect[i]); > - > - memcpy(&pcrInfo.pcrSelection, &pcrComp->select, sizeof(TPM_PCR_SELECTION)); > - > - flatpcrSize = BSG_Pack(BSG_TPM_PCR_COMPOSITE, (BYTE *) pcrComp, flatpcr); > - Crypto_SHA1Full((BYTE *) flatpcr, flatpcrSize, (BYTE *) &(pcrInfo.digestAtRelease)); > - memset(&(pcrInfo.digestAtCreation), 0, sizeof(TPM_DIGEST)); > - pcrInfoSize = BSG_Pack(BSG_TPM_PCR_INFO, (BYTE *) &pcrInfo, flatpcr); > - } else { > - //printf("\n\tBinding to no PCRS."); > - pcrInfoSize = 0; > - } > - > - // Calculate encUsageAuth > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > - UINT32 XORbufferSize = sizeof(XORbuffer); > - TPM_DIGEST XORKey; > - TPM_ENCAUTH encAuth; > - > - BSG_PackList( XORbuffer, 2, > - BSG_TPM_SECRET, osapSharedSecret, > - BSG_TPM_NONCE, &auth->NonceEven ); > - > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey); > - > - int i; > - for (i=0; i < TPM_DIGEST_SIZE; i++) > - ((BYTE *) &encAuth)[i] = ((BYTE *) &XORKey)[i] ^ ((BYTE *) sealDataAuth)[i]; > - > - // Generate Extra TCS Parameters > - UINT32 inDataSize = buffer_len(inData); > - struct pack_buf_t inData_pack = {inDataSize, inData->bytes}; > - struct pack_buf_t pcrInfo_pack = {pcrInfoSize, flatpcr}; > - > - UINT32 sealedDataSize; > - BYTE *flatSealedData=NULL; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 4, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_ENCAUTH, &encAuth, > - BSG_TPM_SIZE32_DATA, &pcrInfo_pack, > - BSG_TPM_SIZE32_DATA, &inData_pack); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - osapSharedSecret, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_Seal( hContext, > - keyHandle, > - encAuth, > - pcrInfoSize, > - flatpcr, > - inDataSize, > - inData->bytes, > - auth, > - &sealedDataSize, > - &flatSealedData) ); > - > - // Unpack/return key structure > - BSG_Unpack( BSG_TPM_STORED_DATA, flatSealedData, sealedData ); > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_STORED_DATA, sealedData); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - osapSharedSecret, auth, > - 0) ); > - > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (flatSealedData) > - TCS_FreeMemory( hContext, flatSealedData); > - > - free(paramText); > - return status; > -} > - > - > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_STORED_DATA *sealedData, > - const TPM_AUTHDATA *key_usage_auth, > - const TPM_AUTHDATA *data_usage_auth, > - buffer_t *outData, > - TCS_AUTH *auth, > - TCS_AUTH *dataAuth) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_Unseal; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate Extra TCS Parameters > - UINT32 sealDataSize, clearDataSize; > - BYTE *flatSealedData= (BYTE *) malloc(sizeof(TPM_VERSION) + > - 2 * sizeof(UINT32) + > - sealedData->sealInfoSize + > - sealedData->encDataSize), > - *clearData=NULL; > - > - sealDataSize = BSG_Pack(BSG_TPM_STORED_DATA, sealedData, flatSealedData ); > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_STORED_DATA, sealedData); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - key_usage_auth, auth) ); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - data_usage_auth, dataAuth) ); > - // Call TCS > - TPMTRYRETURN( TCSP_Unseal( hContext, > - keyHandle, > - sealDataSize, > - flatSealedData, > - auth, > - dataAuth, > - &clearDataSize, > - &clearData) ); > - > - // Verify Auth > - struct pack_buf_t clearData_pack = {clearDataSize, clearData}; > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &clearData_pack); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - key_usage_auth, auth, > - hContext) ); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - data_usage_auth, dataAuth, > - hContext) ); > - > - // Unpack/return key structure > - TPMTRYRETURN( buffer_init(outData, clearDataSize, clearData) ); > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (flatSealedData) > - TCS_FreeMemory( hContext, clearData); > - > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Calling TPM_SaveState.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - > - // Call TCS > - return ( TCSP_SaveState ( hContext ) ); > - > -} > - > - > -// Function Reaches into unsupported TCS command, beware. > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > - const buffer_t *inbuf, > - buffer_t *outbuf ) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Passthrough in use.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - > - // Generate Extra TCS Parameters > - BYTE *resultText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - UINT32 resultTextSize = TCPA_MAX_BUFFER_LENGTH; > - > - // Call TCS > - TPMTRYRETURN( TCSP_RawTransmitData(buffer_len(inbuf), inbuf->bytes, > - &resultTextSize, resultText) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init (outbuf, resultTextSize, resultText) ); > - goto egress; > - > - abort_egress: > - > - egress: > - TCS_FreeMemory(hContext, resultText); > - free(resultText); > - return status; > -} > diff --git a/tools/vtpm_manager/manager/vtsp.h b/tools/vtpm_manager/manager/vtsp.h > deleted file mode 100644 > index 2fb0440..0000000 > --- a/tools/vtpm_manager/manager/vtsp.h > +++ /dev/null > @@ -1,126 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtsp.h > -// > -// Higher level interface to TCS. > -// > -// ================================================================== > - > -#ifndef __VTSP_H__ > -#define __VTSP_H__ > - > -#include "tcg.h" > -#include "tcs.h" > - > -#define KEY_BUFFER_SIZE 2048 > - > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > - const buffer_t *inbuf, > - buffer_t *outbuf ); > - > -TPM_RESULT VTSP_OIAP( const TCS_CONTEXT_HANDLE hContext, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_OSAP( const TCS_CONTEXT_HANDLE hContext, > - const TPM_ENTITY_TYPE entityType, > - const UINT32 entityValue, > - const TPM_AUTHDATA *usageAuth, > - TPM_SECRET *sharedsecret, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > - const TCS_AUTH *auth); > - > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > - CRYPTO_INFO *cypto_info); > - > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - const TPM_AUTHDATA *srkAuth, > - CRYPTO_INFO *ek_cryptoInfo, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_USAGE usage, > - const TPM_AUTHDATA *newKeyAuth, > - const TCS_KEY_HANDLE parentHandle, > - const TPM_AUTHDATA *osapSharedSecret, > - buffer_t *pubKeyBuf, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > - const TCS_KEY_HANDLE hUnwrappingKey, > - const buffer_t *rgbWrappedKeyBlob, > - const TPM_AUTHDATA *parentAuth, > - TPM_HANDLE *newKeyHandle, > - TCS_AUTH *pAuth, > - CRYPTO_INFO *cryptoinfo, > - const BOOL skipTPMLoad); > - > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE key_handle, > - const buffer_t *bound_data, > - const TPM_AUTHDATA *usage_auth, > - buffer_t *clear_data, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > - const buffer_t *inData, > - buffer_t *outData); > - > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_AUTHDATA *sealDataAuth, > - const TPM_PCR_COMPOSITE *pcrComp, > - const buffer_t *inData, > - TPM_STORED_DATA *sealedData, > - const TPM_SECRET *osapSharedSecret, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_STORED_DATA *sealedData, > - const TPM_AUTHDATA *key_usage_auth, > - const TPM_AUTHDATA *data_usage_auth, > - buffer_t *outData, > - TCS_AUTH *auth, > - TCS_AUTH *dataAuth); > - > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext); > - > -#endif //_VTSP_H_ > diff --git a/tools/vtpm_manager/migration/Makefile b/tools/vtpm_manager/migration/Makefile > deleted file mode 100644 > index e33ae95..0000000 > --- a/tools/vtpm_manager/migration/Makefile > +++ /dev/null > @@ -1,42 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -VPATH = ../manager > - > -BIND = vtpm_migratord > -BINC = vtpm_migrator > - > -SRCSD = vtpm_manager_if.c vtpm_migratord.c vtpm_migratord_handler.c vtpm_ipc.c > -SRCSC = vtpm_manager_if.c vtpm_migrator_if.c vtpm_migratorc.c vtpm_ipc.c > - > -OBJSD = $(patsubst %.c,%.o,$(SRCSD)) > -OBJSC = $(patsubst %.c,%.o,$(SRCSC)) > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIND) $(BINC) > - > -.PHONY: install > -install: build > - $(INSTALL_PROG) $(BIND) $(DESTDIR)$(BINDIR) > - $(INSTALL_PROG) $(BINC) $(DESTDIR)$(BINDIR) > - > -.PHONY: clean > -clean: > - rm -f $(BINC) $(BIND) > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIND): $(OBJSD) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -$(BINC): $(OBJSC) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -# libraries > -LIBS += ../util/libTCGUtils.a > diff --git a/tools/vtpm_manager/migration/vtpm_manager_if.c b/tools/vtpm_manager/migration/vtpm_manager_if.c > deleted file mode 100644 > index 08986f4..0000000 > --- a/tools/vtpm_manager/migration/vtpm_manager_if.c > +++ /dev/null > @@ -1,186 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager_if.c > -// > -// Provides functions to call local vtpm manager interface (Hotplug) > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "vtpm_ipc.h" > -#include "bsg.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > - > -static vtpm_ipc_handle_t tx_ipc_h, rx_ipc_h; > - > -TPM_RESULT vtpm_manager_open(){ > - > - if ( (vtpm_ipc_init(&tx_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || //FIXME: wronly > - (vtpm_ipc_init(&rx_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { //FIXME: rdonly > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to connect to vtpm_manager.\n"); > - return TPM_IOERROR; > - } > - > - return TPM_SUCCESS; > -} > - > -void vtpm_manager_close() { > - > - vtpm_ipc_close(&tx_ipc_h); > - vtpm_ipc_close(&rx_ipc_h); > -} > - > - > -TPM_RESULT vtpm_manager_command(TPM_COMMAND_CODE ord, > - buffer_t *command_param_buf, > - TPM_RESULT *cmd_status, /* out */ > - buffer_t *result_param_buf) { > - > - TPM_RESULT status = TPM_FAIL; > - int size_read, size_write, i; > - BYTE *adj_command, response_header[VTPM_COMMAND_HEADER_SIZE_SRV]; > - UINT32 dmi_id=0, adj_command_size, out_param_size, adj_param_size; > - TPM_TAG tag=VTPM_TAG_REQ; > - > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - adj_command_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(command_param_buf); > - adj_command = (BYTE *) malloc( adj_command_size ); > - if (!adj_command) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > - BSG_PackList(adj_command, 4, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - memcpy(adj_command + VTPM_COMMAND_HEADER_SIZE_SRV, command_param_buf->bytes, buffer_len(command_param_buf)); > - > - size_write = vtpm_ipc_write(&tx_ipc_h, NULL, adj_command, adj_command_size); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MGR): 0x"); > - for (i=0; i< adj_command_size; i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", adj_command[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing VTPM Manager console.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_write != (int) adj_command_size ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to mgr (%d/%d)\n", size_write, adj_command_size); > - > - // Read header for response to manager command > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, response_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MGR): 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from vtpm_manager shorter than std header.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(response_header, 4, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, cmd_status ); > - > - // If response has parameters, read them. > - // Note that out_param_size is in the client's context > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, result_param_buf->bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > - goto abort_egress; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > - > diff --git a/tools/vtpm_manager/migration/vtpm_migrator.h b/tools/vtpm_manager/migration/vtpm_migrator.h > deleted file mode 100644 > index 8d52e66..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migrator.h > +++ /dev/null > @@ -1,104 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_migrator.h > -// > -// Public Interface header for VTPM Migrator > -// > -// ================================================================== > - > -#ifndef __VTPM_MIGRATOR_H__ > -#define __VTPM_MIGRATOR_H__ > - > -#define VTPM_MTAG_REQ 0x02c1 > -#define VTPM_MTAG_RSP 0x02c4 > - > -// Header sizes. > -#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > - > -//*********************** Connection Info ************************** > -#define VTPM_MIG_PORT 48879 > - > -//************************ Command Codes *************************** > -#define VTPM_MORD_MIG_STEP1 0x00 > -#define VTPM_MORD_MIG_STEP2 0x01 > -#define VTPM_MORD_MIG_STEP3 0x02 > -#define VTPM_MORD_MIG_STEP4 0x03 > - > -//************************ Return Codes **************************** > -#define VTPM_SUCCESS 0 > -#define VTPM_FAIL 1 > - > -/******************* Command Parameter API ************************* > - > -VTPM Command Format > - tpm tag: 2 bytes > - command size: 4 bytes // Size of command including header but not DMI > - ord: 4 bytes // Command ordinal above > - parameters: size - 10 bytes // Command Parameter > - > -VTPM Response Format > - tpm tag: 2 bytes > - response_size: 4 bytes > - status: 4 bytes > - parameters: size - 10 bytes > - > - > -VTPM_Mig_Phase1: > - Unsupported: (Handled by scripts) > - > -VTPM_Mig_Phase2 > - Input Parameters: > - domain_name_size: 4 bytes > - domain_name : domain_name_size bytes > - Output Parameters: > - pub_exp_size: 4 bytes > - pub_exp: pub_exp_size bytes > - pub_mod_size: 4 bytes > - pub_mod: pub_mod_size bytes > - > -VTPM_Mig_Phase3 > - Input Parameters: > - vtpm_state_size: 4 bytes > - vtpm_state: vtpm_state_size bytes > - Output Parameters: > - none > - > -VTPM_Mig_Phase4 > - Unsupported: (Handled by scripts) > - > - > -*********************************************************************/ > - > -#endif //_VTPM_MANAGER_H_ > diff --git a/tools/vtpm_manager/migration/vtpm_migrator_if.c b/tools/vtpm_manager/migration/vtpm_migrator_if.c > deleted file mode 100644 > index de48b2d..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migrator_if.c > +++ /dev/null > @@ -1,219 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_migrator_if.c > -// > -// Provides functions to call open network connection & call > -// a function on the vtpm_migratord on the destination > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "bsg.h" > -#include "vtpm_migrator.h" > - > -static int sock_desc; > - > - > -TPM_RESULT vtpm_migratord_open(char *server_address){ > - > - TPM_RESULT status = TPM_FAIL; > - > - /* network variables */ > - struct in_addr ip_addr; > - struct sockaddr_in server_addr; > - int addr_len; > - struct hostent *dns_info=NULL; > - > - /* set up connection to server*/ > - dns_info = gethostbyname(server_address); > - ip_addr.s_addr = *((unsigned long *) dns_info->h_addr_list[0]); > - > - if(ip_addr.s_addr < 0) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /* set up server variable */ > - memset((char *)&server_addr, 0, sizeof(server_addr)); > - server_addr.sin_family = AF_INET; > - server_addr.sin_port = htons(VTPM_MIG_PORT); > - server_addr.sin_addr.s_addr = ip_addr.s_addr; > - > - /* open socket, make connection */ > - sock_desc = socket(AF_INET, SOCK_STREAM, 0); > - > - if (sock_desc < 0 ) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (connect(sock_desc, > - (struct sockaddr *)&server_addr, > - sizeof(server_addr)) < 0 ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - status = TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > -void vtpm_migratord_close() { > - close(sock_desc); > -} > - > - > -TPM_RESULT vtpm_migratord_command(TPM_COMMAND_CODE ord, > - buffer_t *command_param_buf, > - TPM_RESULT *cmd_status, /* out */ > - buffer_t *result_param_buf) { > - > - TPM_RESULT status = TPM_FAIL; > - int size_read, size_write, i; > - BYTE *command, response_header[VTPM_COMMAND_HEADER_SIZE]; > - UINT32 dmi_id=0, command_size, out_param_size, adj_param_size; > - TPM_TAG tag=VTPM_MTAG_REQ; > - > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - command_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > - command = (BYTE *) malloc( command_size ); > - if (!command) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - BSG_PackList(command, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &command_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - memcpy(command + VTPM_COMMAND_HEADER_SIZE, command_param_buf->bytes, buffer_len(command_param_buf)); > - > - size_write = write(sock_desc, command, command_size); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MIGd): 0x"); > - for (i=0; i< command_size; i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", command[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing to migration server via network.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_write != (int) command_size ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to migration server (%d/%d)\n", size_write, command_size); > - > - // Read header for response > - size_read = read(sock_desc, response_header, VTPM_COMMAND_HEADER_SIZE); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MIGd): 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from Migration Server.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from migration server shorter than std header.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(response_header, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, cmd_status ); > - > - // If response has parameters, read them. > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > - size_read = read(sock_desc, result_param_buf->bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from migration server.\n"); > - goto abort_egress; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratorc.c b/tools/vtpm_manager/migration/vtpm_migratorc.c > deleted file mode 100644 > index 18b3bdb..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratorc.c > +++ /dev/null > @@ -1,211 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "log.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -TPM_RESULT handle_vtpm_mig_step2(char *server_addr, > - char *name, > - UINT32 instance) { > - TPM_RESULT status, cmd_status; > - buffer_t out_param_buf=NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > - UINT32 offset; > - struct pack_buf_t addr_data32; > - > - //===== Get Destination's Public Migration Key ====== > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > - > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP2, > - &out_param_buf, > - &cmd_status, > - &mig_key_buf) ); > - vtpm_migratord_close(); > - > - TPMTRYRETURN(cmd_status); > - > - //===== Load migration key into vtpm_manager ======== > - > - addr_data32.data = (BYTE *)server_addr; > - addr_data32.size = strlen(server_addr) + 1; // Include the null > - > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > - sizeof(UINT32) + addr_data32.size +buffer_len(&mig_key_buf), > - NULL ) ) ; > - > - offset = BSG_PackList(out_param_buf.bytes, 1, > - BSG_TPM_SIZE32_DATA, &addr_data32); > - > - memcpy(out_param_buf.bytes + offset , mig_key_buf.bytes, buffer_len(&mig_key_buf) ); > - > - TPMTRYRETURN ( vtpm_manager_open() ); > - > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_LOAD_MIG_KEY, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - goto egress; > - > - abort_egress: > - egress: > - > - buffer_free(&mig_key_buf); > - buffer_free(&out_param_buf); > - > - return status; > -} > - > - > -TPM_RESULT handle_vtpm_mig_step3(char *server_addr, > - char *name, > - UINT32 instance) { > - TPM_RESULT status, cmd_status; > - buffer_t out_param_buf=NULL_BUF, state_buf=NULL_BUF, empty_buf=NULL_BUF; > - struct pack_buf_t addr_data32, name_data32, state_data32; > - > - //===== Get vtpm state from vtpm_manager ======== > - addr_data32.data = (BYTE *)server_addr; > - addr_data32.size = strlen(server_addr) + 1; // Include the null > - > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > - (2 * sizeof(UINT32)) + addr_data32.size, > - NULL ) ) ; > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TYPE_UINT32, &instance, > - BSG_TPM_SIZE32_DATA, &addr_data32); > - > - TPMTRYRETURN ( vtpm_manager_open() ); > - > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_MIGRATE_OUT, > - &out_param_buf, > - &cmd_status, > - &state_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - TPMTRYRETURN( buffer_free( &out_param_buf ) ); > - > - //===== Send vtpm state to destination ====== > - name_data32.data = (BYTE *)name; > - name_data32.size = strlen(name) + 1; // Include the null > - state_data32.data = state_buf.bytes; > - state_data32.size = buffer_len(&state_buf); > - > - TPMTRYRETURN( buffer_init( &out_param_buf, > - 2 * sizeof(UINT32) + name_data32.size + state_data32.size, > - NULL ) ) ; > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TPM_SIZE32_DATA, &name_data32, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > - > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP3, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - vtpm_migratord_close(); > - > - TPMTRYRETURN(cmd_status); > - > - goto egress; > - > - abort_egress: > - egress: > - > - buffer_free( &out_param_buf); > - buffer_free( &state_buf); > - buffer_free( &empty_buf); > - > - return status; > -} > - > - > -// Usage vtpm_migrator addr domain_name instance step > - > -int main(int argc, char **argv) { > - > - /* variables for processing of command */ > - TPM_RESULT status = TPM_FAIL; > - char *server_addr, *name; > - UINT32 instance, step; > - > - if (argc != 5) { > - vtpmlogerror(VTPM_LOG_VTPM, "Usage: vtpm_migrator addr vm_name instance step\n"); > - vtpmlogerror(VTPM_LOG_VTPM, " params given %d\n", argc); > - status= TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - server_addr = argv[1]; > - name = argv[2]; > - instance = atoi( argv[3] ); > - step = atoi( argv[4] ); > - > - switch (step) { > - case VTPM_MORD_MIG_STEP2: > - status = handle_vtpm_mig_step2(server_addr, name, instance); > - break; > - > - case VTPM_MORD_MIG_STEP3: > - status = handle_vtpm_mig_step3(server_addr, name, instance); > - break; > - > - default: > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - break; > - } > - > - goto egress; > - abort_egress: > - egress: > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratord.c b/tools/vtpm_manager/migration/vtpm_migratord.c > deleted file mode 100644 > index ea18c8c..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratord.c > +++ /dev/null > @@ -1,202 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "log.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "vtpm_migrator.h" > - > -void build_error_msg( buffer_t *buf, TPM_RESULT status) { > - TPM_TAG tag = VTPM_MTAG_RSP; > - UINT32 out_param_size = VTPM_COMMAND_HEADER_SIZE; > - > - buffer_init(buf, out_param_size, NULL); > - > - BSG_PackList(buf->bytes, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_RESULT, &status ); > -} > - > -int main() { > - > - /* network variables */ > - int sock_descr, client_sock=-1, len; > - struct sockaddr_in addr; > - struct sockaddr_in client_addr; > - unsigned int client_length; > - int bytes; > - > - /* variables for processing of command */ > - TPM_RESULT status = TPM_FAIL; > - BYTE cmd_header[VTPM_COMMAND_HEADER_SIZE]; > - TPM_TAG tag; > - TPM_COMMAND_CODE ord; > - UINT32 in_param_size, adj_param_size; > - int i, size_read, size_write; > - buffer_t in_param_buf=NULL_BUF, result_buf=NULL_BUF; > - > - > - /* setup socket */ > - sock_descr = socket(AF_INET, SOCK_STREAM, 0); > - > - memset(&addr, 0, sizeof(addr)); > - addr.sin_family = AF_INET; > - addr.sin_addr.s_addr = htonl(INADDR_ANY); > - addr.sin_port = htons(VTPM_MIG_PORT); > - > - if (bind(sock_descr, (struct sockaddr *)&addr, sizeof(addr)) == -1 ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to bind to port %d.\n", VTPM_MIG_PORT); > - return 1; > - } > - > - listen(sock_descr, 10); > - > - for(;;) { > - // ============ clear client info and wait for connection ========== > - memset(&client_addr, 0, sizeof(client_addr)); > - client_length = sizeof(client_addr); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Waiting for incoming migrations...\n"); > - client_sock=accept(sock_descr, &client_addr, &client_length); > - if (client_sock == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming connectionn failed.\n"); > - goto abort_command; > - } else { > - vtpmloginfo(VTPM_LOG_VTPM, "Incoming connection accepted.\n"); > - } > - > - // =================== Read incoming command ====================== > - size_read = read( client_sock, cmd_header, VTPM_COMMAND_HEADER_SIZE); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV: 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > - build_error_msg(&result_buf, TPM_IOERROR); > - goto abort_command_with_error; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from socket shorter than std header.\n"); > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - > - // Unpack response from client > - BSG_UnpackList(cmd_header, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - > - // If response has parameters, read them. > - // Note that out_param_size is in the client's context > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - buffer_init( &in_param_buf, adj_param_size, NULL); > - size_read = read(client_sock, in_param_buf.bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param_buf.bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > - build_error_msg(&result_buf, TPM_IOERROR); > - goto abort_command_with_error; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - /* Handle Command */ > - switch (ord) { > - case VTPM_MORD_MIG_STEP2: > - handle_vtpm_mig_step2(&in_param_buf, &result_buf); > - break; > - > - case VTPM_MORD_MIG_STEP3: > - handle_vtpm_mig_step3(&in_param_buf, &result_buf); > - break; > - > - default: > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - > - abort_command_with_error: > - /* Write Response */ > - size_write = write(client_sock, result_buf.bytes, buffer_len(&result_buf)); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > - for (i=0; i< buffer_len(&result_buf); i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_buf.bytes[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing response to client.\n"); > - goto abort_command; > - } > - > - if (size_write != (int) buffer_len(&result_buf) ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not send entire response to client(%d/%d)\n", size_write, buffer_len(&result_buf)); > - > - abort_command: > - close(client_sock); > - buffer_free(&in_param_buf); > - buffer_free(&result_buf); > - > - } // For (;;) > - > - return 0; > -} > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratord_handler.c b/tools/vtpm_manager/migration/vtpm_migratord_handler.c > deleted file mode 100644 > index 0a8a2d5..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratord_handler.c > +++ /dev/null > @@ -1,177 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "log.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -#define VTPM_SH_CMD_HDR "bash -c \"cd /etc/xen/scripts; source /etc/xen/scripts/vtpm-common.sh;" > -#define VTPM_SH_CMD_FTR "\"" > -#define VTPM_SH_GETINST "vtpmdb_get_free_instancenum" > -#define VTPM_SH_ADD "vtpm_add_and_activate" > -#define VTPM_SH_RESUME "vtpm_resume" > - > -// This must be updated to the longest command name. Currently GETINST > -#define VTPM_SH_CMD_SIZE (strlen(VTPM_SH_CMD_HDR) + strlen(VTPM_SH_CMD_FTR) + 1 + strlen(VTPM_SH_GETINST) + 2) > - > -void handle_vtpm_mig_step2(buffer_t *in_param_buf, buffer_t *result_buf) > -{ > - TPM_TAG tag = VTPM_TAG_RSP; > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF; > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > - UINT32 out_param_size; > - > - if ( (!in_param_buf) || (!result_buf) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // ================= Call manager and get mig key =============== > - TPMTRYRETURN( vtpm_manager_open() ); > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_GET_MIG_KEY, > - &out_param_buf, // Empty > - &cmd_status, > - &mig_key_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - // ==================== return the mig key ===================== > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(&mig_key_buf); > - > - TPMTRYRETURN( buffer_init(result_buf, > - out_param_size, > - NULL) ); > - > - BSG_PackList( result_buf->bytes, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_RESULT, &status); > - > - memcpy(result_buf->bytes + VTPM_COMMAND_HEADER_SIZE, > - mig_key_buf.bytes, buffer_len(&mig_key_buf)); > - > - goto egress; > - > - abort_egress: > - buffer_free(result_buf); > - build_error_msg(result_buf, status); > - > - egress: > - return; > -} > - > -void handle_vtpm_mig_step3(buffer_t *in_param_buf, buffer_t *result_buf) > -{ > - TPM_TAG tag = VTPM_TAG_RSP; > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > - UINT32 out_param_size, instance; > - char *shell_cmd_str=NULL; > - size_t shell_cmd_strlen; > - FILE *shell_f=NULL; > - > - if ( (!in_param_buf) || (!result_buf) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // ================= Read Parameters =============== > - struct pack_buf_t name_data32, state_data32; > - > - BSG_UnpackList(in_param_buf->bytes, 2, > - BSG_TPM_SIZE32_DATA, &name_data32, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - // Before using this string, protect us from a non-null term array. > - if (name_data32.data[name_data32.size -1] != 0x00) { > - name_data32.data[name_data32.size -1] = 0x00; > - } > - > - // ====== Call hotplug-script and get an instance ====== > - shell_cmd_strlen = VTPM_SH_CMD_SIZE + name_data32.size + 10; > - shell_cmd_str = (char *) malloc(shell_cmd_strlen); // 10 is just padding for the UINT32 > - > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_GETINST VTPM_SH_CMD_FTR); > - > - shell_f = popen(shell_cmd_str, "r"); > - fscanf(shell_f, "%d", &instance); > - pclose(shell_f); > - > - // ====== Call hotplug-script and add instance ====== > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_ADD " %s %d" VTPM_SH_CMD_FTR, > - name_data32.data, instance); > - system(shell_cmd_str); > - > - // ========= Call vtpm_manager and load VTPM ======= > - TPMTRYRETURN( buffer_init( &out_param_buf, > - 2*sizeof(UINT32) + state_data32.size, > - NULL) ); > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TYPE_UINT32, &instance, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - TPMTRYRETURN( vtpm_manager_open() ); > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_MIGRATE_IN, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - // ====== Call hotplug-script and resume instance ====== > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_RESUME " %d" VTPM_SH_CMD_FTR, instance); > - system(shell_cmd_str); > - > - goto egress; > - abort_egress: > - egress: > - free(shell_cmd_str); > - > - // In this case no params come back, so reuse build_error_msg even for succes. > - build_error_msg(result_buf, status); > - return; > -} > - > diff --git a/tools/vtpm_manager/tcs/Makefile b/tools/vtpm_manager/tcs/Makefile > deleted file mode 100644 > index 11af91e..0000000 > --- a/tools/vtpm_manager/tcs/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libTCS.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/tcs/contextmgr.c b/tools/vtpm_manager/tcs/contextmgr.c > deleted file mode 100644 > index cf3803c..0000000 > --- a/tools/vtpm_manager/tcs/contextmgr.c > +++ /dev/null > @@ -1,224 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// contextmgr.c > -// > -// This file contains the context management functions for TCS. > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include "tcs.h" > -#include "contextmgr.h" > -#include "log.h" > -#include "hashtable.h" > - > -BYTE* AddMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - int BlockSize) { // in > - > - BLOCK* pCurrentBlock = NULL; > - BLOCK* pBlock = NULL; > - > - // check incoming params > - if (pContextHandle == NULL || BlockSize == 0) > - return NULL; > - > - // Create New Block > - pBlock = (BLOCK *)malloc(sizeof(BLOCK)); > - if (pBlock == NULL) > - return (0); > - > - pBlock->aMemory = (BYTE *)malloc(sizeof(BYTE) * BlockSize); > - if (pBlock->aMemory == NULL) > - return (0); > - > - memset(pBlock->aMemory, 0, BlockSize); > - pBlock->nBlockSize = BlockSize; > - pBlock->pNextBlock = NULL; > - > - // search for the last block created where to add the > - // newly created block > - if(pContextHandle->pTopBlock != NULL) { > - pCurrentBlock = pContextHandle->pTopBlock; > - while(pCurrentBlock->pNextBlock != NULL) > - pCurrentBlock = pCurrentBlock->pNextBlock; > - > - > - pCurrentBlock->pNextBlock= pBlock; > - } else > - pContextHandle->pTopBlock = pBlock; > - > - > - pContextHandle->nBlockCount++; > - > - return pBlock->aMemory; > -} > - > - > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - BYTE* pTCPA_BYTEs) { // in > - BLOCK* pCurrentBlock = NULL; > - BLOCK* pParentBlock = NULL; > - BOOL bFound = FALSE; > - > - if (pContextHandle == NULL) > - return FALSE; > - > - > - // Search for the Block in the context by aMemory pointer > - pParentBlock = NULL; > - pCurrentBlock = pContextHandle->pTopBlock; > - > - while(pCurrentBlock != NULL) { > - // If aMemory block is found, delete it > - if(pCurrentBlock->aMemory == pTCPA_BYTEs || pTCPA_BYTEs == NULL) { > - // if it is the top Block, remove it from the top, > - // otherwise remove it from the ParentBlock and stitch > - // the NextBlock to the ParentBlock > - if(pParentBlock == NULL) > - pContextHandle->pTopBlock = pContextHandle->pTopBlock->pNextBlock; > - else > - pParentBlock->pNextBlock = pCurrentBlock->pNextBlock; > - > - // delete memory Block associated with pointer pTCPA_BYTEs > - free(pCurrentBlock->aMemory); > - pCurrentBlock->aMemory = NULL; > - > - free(pCurrentBlock); > - pCurrentBlock = pParentBlock; > - > - pContextHandle->nBlockCount--; > - bFound = TRUE; > - } > - > - if(pCurrentBlock != NULL) { > - pParentBlock = pCurrentBlock; > - pCurrentBlock = pCurrentBlock->pNextBlock; > - } > - } > - > - return bFound; > -} > - > -BOOL AddHandleToList(TCS_CONTEXT_HANDLE hContext, // in > - TPM_RESOURCE_TYPE type, // in > - TPM_HANDLE handle) { // in > - HANDLE_LIST* pNewHandle = NULL; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Adding Handle to list\n"); > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if (pContextHandle == NULL) > - return 0; > - > - pNewHandle = (HANDLE_LIST *)malloc(sizeof(HANDLE_LIST)); > - > - if (pNewHandle == NULL) > - return (0); > - > - pNewHandle->handle = handle; > - pNewHandle->type = type; > - pNewHandle->pNextHandle = pContextHandle->pHandleList; > - > - pContextHandle->pHandleList = pNewHandle; > - > - return 1; > -} > - > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_HANDLE handle) { // in > - > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - HANDLE_LIST *pCurrentHandle = pContextHandle->pHandleList, > - *pLastHandle = pCurrentHandle; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Deleting Handle from list\n"); > - > - if (pContextHandle == NULL) > - return 0; > - > - while (1) { > - > - if (pCurrentHandle->handle == handle) { // Found element > - if (pCurrentHandle == pLastHandle) { // First element in list > - pContextHandle->pHandleList = pCurrentHandle->pNextHandle; > - free(pCurrentHandle); > - } else { // Ordinary element > - pLastHandle->pNextHandle = pCurrentHandle->pNextHandle; > - free(pCurrentHandle); > - } > - > - return 1; > - > - } else { // Not found yet; > - pLastHandle = pCurrentHandle; > - pCurrentHandle = pCurrentHandle->pNextHandle; > - if (pCurrentHandle == NULL) // Found end of list > - return 0; > - } > - > - } > -} > - > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle) { // in > - HANDLE_LIST* pCurrentHandle; > - BOOL returncode = TRUE; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Freeing all handles for context\n"); > - > - if (pContextHandle == NULL) > - return 1; > - > - pCurrentHandle = pContextHandle->pHandleList; > - while (pCurrentHandle != NULL) { > - > - switch (pCurrentHandle->type) { > - case TPM_RT_KEY: > - returncode = returncode && !TCSP_EvictKey(pContextHandle->handle, pCurrentHandle->handle); > - break; > - case TPM_RT_AUTH: > - returncode = returncode && !TCSP_TerminateHandle(pContextHandle->handle, pCurrentHandle->handle); > - break; > - default: > - returncode = FALSE; > - } > - > - pCurrentHandle = pCurrentHandle->pNextHandle; > - > - } > - > - return 1; > -} > diff --git a/tools/vtpm_manager/tcs/contextmgr.h b/tools/vtpm_manager/tcs/contextmgr.h > deleted file mode 100644 > index e3fdf0f..0000000 > --- a/tools/vtpm_manager/tcs/contextmgr.h > +++ /dev/null > @@ -1,82 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// contextmgr.c > -// > -// This file contains the context management functions for TCS. > -// > -// ================================================================== > - > -#ifndef __CONTEXTMGR_H__ > -#define __CONTEXTMGR_H__ > - > -#include "tcg.h" > - > -#define BLOCK_SIZE 300 > - > -typedef struct block { > - int nBlockSize; > - BYTE* aMemory; > - struct block* pNextBlock; > -} BLOCK; > - > -typedef struct handle_List { > - TPM_HANDLE handle; > - TPM_RESOURCE_TYPE type; > - struct handle_List* pNextHandle; > -} HANDLE_LIST; > - > -typedef struct context_handle { > - TCS_CONTEXT_HANDLE handle; > - int nBlockCount; > - BLOCK* pTopBlock; > - HANDLE_LIST* pHandleList; > -} CONTEXT_HANDLE; > - > -BYTE* AddMemBlock( CONTEXT_HANDLE* pContextHandle, // in > - int BlockSize); // in > - > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - BYTE* pTCPA_BYTEs); // in > - > - > -BOOL AddHandleToList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_RESOURCE_TYPE type, // in > - TPM_HANDLE handle); // in > - > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_HANDLE handle); // in > - > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle); // in > - > -#endif //_CONTEXTMGR_H_ > diff --git a/tools/vtpm_manager/tcs/tcs.c b/tools/vtpm_manager/tcs/tcs.c > deleted file mode 100644 > index 7c1378c..0000000 > --- a/tools/vtpm_manager/tcs/tcs.c > +++ /dev/null > @@ -1,1192 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcs.c > -// > -// This file contains the functions that implement a TCS. > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "tcs.h" > -#include "contextmgr.h" > -#include "tpmddl.h" > -#include "log.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > - > -// Static Global Vars for the TCS > -static int TCS_m_nCount = 0; > - > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > - > -static BYTE InBuf [TCPA_MAX_BUFFER_LENGTH]; > -static BYTE OutBuf[TCPA_MAX_BUFFER_LENGTH]; > - > -struct hashtable *context_ht; > - > -// -------------------------- Hash table functions -------------------- > - > -static unsigned int hashfunc32(void *ky) { > - return (* (UINT32 *) ky); > -} > - > -static int equals32(void *k1, void *k2) { > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > -} > - > -CONTEXT_HANDLE *LookupContext( TCS_CONTEXT_HANDLE hContext) { > - return( (CONTEXT_HANDLE *) hashtable_search(context_ht, &hContext) ); > -} > - > -// --------------------------------------------------------------------------------- > -// Initialization/Uninitialization SubComponent API > -// --------------------------------------------------------------------------------- > -TPM_RESULT TCS_create() { > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TPM_RESULT result = TPM_FAIL; > - > - if (TCS_m_nCount == 0) { > - vtpmloginfo(VTPM_LOG_TCS, "Constructing new TCS:\n"); > - hRes = TDDL_Open(); > - > - context_ht = create_hashtable(10, hashfunc32, equals32); > - > - if ((hRes == TDDL_SUCCESS) && (context_ht != NULL)) { > - result = TPM_SUCCESS; > - TCS_m_nCount++; > - } else { > - result = TPM_IOERROR; > - hashtable_destroy(context_ht, 1); > - } > - } else > - TCS_m_nCount++; > - > - return(result); > -} > - > - > -void TCS_destroy() > -{ > - TCS_m_nCount--; > - > - if (TCS_m_nCount == 0) { > - vtpmloginfo(VTPM_LOG_TCS, "Destructing TCS:\n"); > - TDDL_Close(); > - > - struct hashtable_itr *context_itr; > - TCS_CONTEXT_HANDLE *hContext; > - > - // Close all the TCS contexts. TCS should evict keys based on this > - if (hashtable_count(context_ht) > 0) { > - context_itr = hashtable_iterator(context_ht); > - do { > - hContext = (TCS_CONTEXT_HANDLE *) hashtable_iterator_key(context_itr); > - if (TCS_CloseContext(*hContext) != TPM_SUCCESS) > - vtpmlogerror(VTPM_LOG_TCS, "Failed to close context %d properly.\n", *hContext); > - > - } while (hashtable_iterator_advance(context_itr)); > - free(context_itr); > - } > - hashtable_destroy(context_ht, 1); > - } > - > -} > - > -TPM_RESULT TCS_Malloc( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 MemSize, // in > - BYTE** ppMemPtr) {// out > - > - TPM_RESULT returnCode = TPM_FAIL; > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if (pContextHandle != NULL && ppMemPtr != NULL) { > - *ppMemPtr = (BYTE *)AddMemBlock(pContextHandle, MemSize); > - returnCode = TPM_SUCCESS; > - } > - > - return returnCode; > -} > - > -TPM_RESULT TCS_FreeMemory( TCS_CONTEXT_HANDLE hContext, // in > - BYTE* pMemory) { // in > - TPM_RESULT returnCode = TPM_FAIL; > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if ( (pContextHandle != NULL && pMemory != NULL) && > - (DeleteMemBlock(pContextHandle, pMemory) == TRUE) ) > - returnCode = TPM_SUCCESS; > - > - > - return returnCode; > -} > - > -TPM_RESULT TCS_OpenContext(TCS_CONTEXT_HANDLE* hContext) { // out > - TPM_RESULT returnCode = TPM_FAIL; > - TCS_CONTEXT_HANDLE *newContext; > - > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_OpenContext:\n"); > - > - if (hContext) { > - CONTEXT_HANDLE* pContextHandle = (CONTEXT_HANDLE *) malloc(sizeof(CONTEXT_HANDLE)); > - if (pContextHandle == NULL) > - return TPM_SIZE; > - > - // initialize to 0 > - pContextHandle->nBlockCount = 0; > - pContextHandle->pTopBlock = NULL; > - pContextHandle->pHandleList = NULL; > - > - // Create New Block > - AddMemBlock(pContextHandle, BLOCK_SIZE); > - > - newContext = (TCS_CONTEXT_HANDLE *) malloc(sizeof(TCS_CONTEXT_HANDLE)); > - *newContext = (TCS_CONTEXT_HANDLE) (((uintptr_t) pContextHandle >> 2) & 0xffffffff); > - > - if (hashtable_search(context_ht, &newContext) !=NULL) > - *newContext += 1; > - > - pContextHandle->handle = *newContext; > - if (!hashtable_insert(context_ht, newContext, pContextHandle)) { > - free(newContext); > - free(pContextHandle); > - returnCode = TPM_FAIL; > - } else { > - *hContext = *newContext; > - returnCode = TPM_SUCCESS; > - } > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCS_CloseContext(TCS_CONTEXT_HANDLE hContext) {// in > - //FIXME: TCS SHOULD Track failed auths and make sure > - //we don't try and re-free them here. > - TPM_RESULT returnCode = TPM_FAIL; > - > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if(pContextHandle != NULL) { > - // Print test info > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_CloseContext.\n"); > - > - // free memory for all the blocks > - DeleteMemBlock(pContextHandle, NULL ); > - pContextHandle->pTopBlock = NULL; > - > - FreeHandleList(pContextHandle); > - if (pContextHandle->pHandleList != NULL) > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > - > - // Release the TPM's resources > - if (hashtable_remove(context_ht, &hContext) == NULL) > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > - > - free(pContextHandle); > - returnCode = TPM_SUCCESS; > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Finished closing context\n"); > - return(returnCode); > -} > - > -// ------------------------------------------------------------------ > -// Internal Functions > -// ------------------------------------------------------------------ > -int packAuth(BYTE* dst, TCS_AUTH* auth) { > - // CHECK: according to the command specs, the outgoing auth params are: > - // nonceEven > - // nonceOdd > - // continueAuthSession > - // auth digest for return params > - // > - // this is a bit different than this code... > - > - return BSG_PackList(dst, 4, > - BSG_TYPE_UINT32, &(auth->AuthHandle), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > -} > - > -int unpackAuth(TCS_AUTH* auth, BYTE* src) { > - return BSG_UnpackList(src, 3, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > -} > - > -// ------------------------------------------------------------------ > -// Authorization Commands > -// ------------------------------------------------------------------ > - > -TPM_RESULT TCSP_OIAP(TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonce0) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - TPM_COMMAND_CODE ordinal = TPM_ORD_OIAP; > - UINT32 paramSize = 0; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (authHandle == NULL || nonce0 == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_UnpackList(OutBuf+i, 2, > - BSG_TYPE_UINT32, authHandle, > - BSG_TPM_NONCE, nonce0); > - > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_OSAP(TCS_CONTEXT_HANDLE hContext, // in > - TPM_ENTITY_TYPE entityType, // in > - UINT32 entityValue, // in > - TPM_NONCE nonceOddOSAP, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonceEven, // out > - TPM_NONCE* nonceEvenOSAP) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_OSAP; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (authHandle == NULL || nonceEven == NULL || nonceEvenOSAP == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT16, &entityType, > - BSG_TYPE_UINT32, &entityValue, > - BSG_TPM_NONCE, &nonceOddOSAP); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_UnpackList(OutBuf+i, 3, > - BSG_TYPE_UINT32, authHandle, > - BSG_TPM_NONCE, nonceEven, > - BSG_TPM_NONCE, nonceEvenOSAP); > - > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) { > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_TakeOwnership(TCS_CONTEXT_HANDLE hContext, // in > - UINT16 protocolID, // in > - UINT32 encOwnerAuthSize, // in > - BYTE* encOwnerAuth, // in > - UINT32 encSrkAuthSize, // in > - BYTE* encSrkAuth, // in > - UINT32* SrkSize, // in, out > - BYTE** Srk, // in, out > - TCS_AUTH* ownerAuth) // in, out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_TakeOwnership; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (encOwnerAuth == NULL || encSrkAuth == NULL || SrkSize == NULL || *Srk == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT16, &protocolID, > - BSG_TYPE_UINT32, &encOwnerAuthSize); > - > - memcpy(InBuf+InLength, encOwnerAuth, encOwnerAuthSize); > - InLength += encOwnerAuthSize; > - InLength += BSG_Pack( BSG_TYPE_UINT32, > - &encSrkAuthSize, > - InBuf+InLength); > - memcpy(InBuf+InLength, encSrkAuth, encSrkAuthSize); > - InLength += encSrkAuthSize; > - memcpy(InBuf+InLength, *Srk, *SrkSize); > - InLength += *SrkSize; > - InLength += packAuth(InBuf+InLength, ownerAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, > - &InLength, > - InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS){ > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_KEY srkPub; > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &srkPub); > - unpackAuth(ownerAuth, OutBuf+i); > - > - // fill output params > - BYTE tempBuf[1024]; > - *SrkSize = BSG_Pack(BSG_TPM_KEY, &srkPub, tempBuf); > - if (TCS_Malloc(hContext, *SrkSize, Srk) == TPM_FAIL) { > - return(TPM_SIZE); > - } > - memcpy(*Srk, tempBuf, *SrkSize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TakeOwnership Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTH* ownerAuth) { // in, out > - > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_DisablePubekRead; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - > - InLength += packAuth(InBuf+InLength, ownerAuth); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS){ > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - unpackAuth(ownerAuth, OutBuf+i); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_DisablePubekRead Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_TerminateHandle(TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Terminate_Handle; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &handle); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (!DeleteHandleFromList(hContext, handle)) > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > - > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Print debug info > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TerminateHandle Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -// TPM Mandatory > -TPM_RESULT TCSP_Extend( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_DIGEST inDigest, // in > - TPM_PCRVALUE* outDigest) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Extend; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &pcrNum, > - BSG_TPM_DIGEST, &inDigest); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND){ > - // Extract the remaining output parameters > - BSG_Unpack(BSG_TPM_PCRVALUE, OutBuf+i, outDigest); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Extend Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_Seal( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_ENCAUTH encAuth, // in > - UINT32 pcrInfoSize, // in > - BYTE* PcrInfo, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* pubAuth, // in, out > - UINT32* SealedDataSize, // out > - BYTE** SealedData) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Seal; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (inData == NULL || pubAuth == NULL || SealedDataSize == NULL || SealedData == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &keyHandle, > - BSG_TPM_ENCAUTH, encAuth, > - BSG_TYPE_UINT32, &pcrInfoSize); > - memcpy(InBuf+InLength, PcrInfo, pcrInfoSize); > - InLength += pcrInfoSize; > - InLength += BSG_Pack(BSG_TYPE_UINT32, &inDataSize, InBuf+InLength); > - memcpy(InBuf+InLength, inData, inDataSize); > - InLength += inDataSize; > - InLength += packAuth(InBuf+InLength, pubAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_STORED_DATA sealedData; > - > - i += BSG_Unpack(BSG_TPM_STORED_DATA, OutBuf+i, &sealedData); > - unpackAuth(pubAuth, OutBuf+i); > - > - // fill SealedData > - BYTE tempBuf[1024]; > - *SealedDataSize = BSG_Pack(BSG_TPM_STORED_DATA, &sealedData, tempBuf); > - if (TCS_Malloc(hContext, *SealedDataSize, SealedData) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*SealedData, tempBuf, *SealedDataSize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Seal Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_Unseal(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE parentHandle, // in > - UINT32 SealedDataSize, // in > - BYTE* SealedData, // in > - TCS_AUTH* parentAuth, // in, out > - TCS_AUTH* dataAuth, // in, out > - UINT32* DataSize, // out > - BYTE** Data) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH2_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Unseal; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (SealedData == NULL || parentAuth == NULL || dataAuth == NULL || > - DataSize == NULL || Data == NULL) > - return TPM_BAD_PARAMETER; > - > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &parentHandle); > - memcpy(InBuf+InLength, SealedData, SealedDataSize); > - InLength += SealedDataSize; > - InLength += packAuth(InBuf+InLength, parentAuth); > - InLength += packAuth(InBuf+InLength, dataAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH2_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, DataSize); > - if (TCS_Malloc(hContext, *DataSize, Data) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*Data, OutBuf+i, *DataSize); > - i += *DataSize; > - i += unpackAuth(parentAuth, OutBuf+i); > - unpackAuth(dataAuth, OutBuf+i); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Unseal Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_UnBind(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* outDataSize, // out > - BYTE** outData) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_UnBind; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (inData == NULL || privAuth == NULL || outDataSize == NULL || outData == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &keyHandle, > - BSG_TYPE_UINT32, &inDataSize); > - memcpy(InBuf+InLength, inData, inDataSize); > - InLength += inDataSize; > - InLength += packAuth(InBuf+InLength, privAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "\n\tSending paramSize = %d", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, outDataSize); > - if (TCS_Malloc(hContext, *outDataSize, outData) == TPM_FAIL) > - return TPM_SIZE; > - > - memcpy(*outData, OutBuf+i, *outDataSize); > - i += *outDataSize; > - unpackAuth(privAuth, OutBuf+i); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_UnBind Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_CreateWrapKey(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hWrappingKey, // in > - TPM_ENCAUTH KeyUsageAuth, // in > - TPM_ENCAUTH KeyMigrationAuth, // in > - UINT32* pcKeySize, // in, out > - BYTE** prgbKey, // in, out > - TCS_AUTH* pAuth) // in, out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_CreateWrapKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (pcKeySize == NULL || *prgbKey == NULL || pAuth == NULL) > - return TPM_BAD_PARAMETER; > - > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hWrappingKey, > - BSG_TPM_ENCAUTH, KeyUsageAuth, > - BSG_TPM_ENCAUTH, KeyMigrationAuth); > - memcpy(InBuf+InLength, *prgbKey, *pcKeySize); > - InLength += *pcKeySize; > - InLength += packAuth(InBuf+InLength, pAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_RESULT, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_KEY wrappedKey; > - > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &wrappedKey); > - unpackAuth(pAuth, OutBuf+i); > - > - // Fill prgbKey > - BYTE tempBuf[1024]; > - *pcKeySize = BSG_Pack(BSG_TPM_KEY, &wrappedKey, tempBuf); > - if (TCS_Malloc(hContext, *pcKeySize, prgbKey) == TPM_FAIL) > - return TPM_SIZE; > - > - memcpy(*prgbKey, tempBuf, *pcKeySize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_CreateWrapKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_LoadKeyByBlob(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hUnwrappingKey, // in > - UINT32 cWrappedKeyBlobSize, // in > - BYTE* rgbWrappedKeyBlob, // in > - TCS_AUTH* pAuth, // in, out > - TCS_KEY_HANDLE* phKeyTCSI, // out > - TCS_KEY_HANDLE* phKeyHMAC) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_LoadKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (rgbWrappedKeyBlob == NULL || pAuth == NULL || phKeyTCSI == NULL || phKeyHMAC == NULL) > - return TPM_BAD_PARAMETER; > - > - *phKeyHMAC = hUnwrappingKey; // the parent key is the one that the TPM use to make the HMAC calc > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hUnwrappingKey); > - memcpy(InBuf+InLength, rgbWrappedKeyBlob, cWrappedKeyBlobSize); > - InLength += cWrappedKeyBlobSize; > - InLength += packAuth(InBuf+InLength, pAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, > - OutBuf+i, > - phKeyTCSI); > - unpackAuth(pAuth, OutBuf+i); > - > - if (!AddHandleToList(hContext, TPM_RT_KEY, *phKeyTCSI)) { > - vtpmlogerror(VTPM_LOG_TCS, "New KeyHandle not recorded\n"); > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_LoadKeyByBlob Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_EvictKey(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_EvictKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hKey); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (!DeleteHandleFromList(hContext, hKey)) { > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > - } > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_EvictKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_GetRandom(TCS_CONTEXT_HANDLE hContext, // in > - UINT32* bytesRequested, // in, out > - BYTE** randomBytes) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_GetRandom; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (bytesRequested == NULL || *randomBytes == NULL){ > - return TPM_BAD_PARAMETER; > - } > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, bytesRequested); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, bytesRequested); > - if (TCS_Malloc(hContext, *bytesRequested, randomBytes) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*randomBytes, OutBuf+i+sizeof(UINT32), *bytesRequested); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_GetRandom Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_ReadPubek(TCS_CONTEXT_HANDLE hContext, // in > - TPM_NONCE antiReplay, // in > - UINT32* pubEndorsementKeySize, // out > - BYTE** pubEndorsementKey, // out > - TPM_DIGEST* checksum) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_ReadPubek; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (pubEndorsementKeySize == NULL || pubEndorsementKey == NULL || checksum == NULL) { > - return TPM_BAD_PARAMETER; > - } > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TPM_NONCE, &antiReplay); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - TPM_PUBKEY pubEK; > - i += BSG_UnpackList(OutBuf+i, 2, > - BSG_TPM_PUBKEY, &pubEK, > - BSG_TPM_DIGEST, checksum); > - > - // fill EndorsementKey > - BYTE tempBuf[1024]; > - *pubEndorsementKeySize = BSG_Pack(BSG_TPM_PUBKEY, &pubEK, tempBuf); > - if (TCS_Malloc(hContext, *pubEndorsementKeySize, pubEndorsementKey) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*pubEndorsementKey, tempBuf, *pubEndorsementKeySize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_ReadPubek Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_SaveState; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_SaveState Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_RawTransmitData( UINT32 inDataSize, // in > - BYTE *inData, // in > - UINT32 *outDataSize,// in/out > - BYTE *outData) { // out > - > - TDDL_RESULT hRes; > - > - vtpmloginfo(VTPM_LOG_TCS, "Calling TransmitData directly.\n"); > - //FIXME: Add Context Management > - hRes = TDDL_TransmitData( inData, > - inDataSize, > - outData, > - outDataSize); > - > - if (hRes == TDDL_SUCCESS) { > - return TPM_SUCCESS; > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_RawTransmitData Failed with return code %s\n", tpm_get_error_name(TPM_IOERROR)); > - return TPM_IOERROR; > - } > - > -} > diff --git a/tools/vtpm_manager/tcs/tcs.h b/tools/vtpm_manager/tcs/tcs.h > deleted file mode 100644 > index 83b9cd0..0000000 > --- a/tools/vtpm_manager/tcs/tcs.h > +++ /dev/null > @@ -1,245 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcs.h > -// > -// This file declares the TCS API > -// > -// ================================================================== > - > -#ifndef __TCS_H__ > -#define __TCS_H__ > - > -#include "tcg.h" > -#include "contextmgr.h" > -#include "buffer.h" > - > -#define HANDLE_NULL 0 > - > -// ------------------------------------------------------------------ > -// Exposed API > -// ------------------------------------------------------------------ > - > -TPM_RESULT TCS_create(); > -void TCS_destroy(); > - > -TPM_RESULT TCS_OpenContext( /* OUT */ TCS_CONTEXT_HANDLE* hContext ); > - > -TPM_RESULT TCS_CloseContext ( /* IN */ TCS_CONTEXT_HANDLE hContext ); > - > -TPM_RESULT TCS_Malloc ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 MemSize, // in > - BYTE** ppMemPtr ); //out > - > -TPM_RESULT TCS_FreeMemory ( TCS_CONTEXT_HANDLE hContext, // in > - BYTE* pMemory); // in > - > -// ------------------------------------------------------------------ > -// Exposed API > -// ------------------------------------------------------------------ > - > -// TPM v1.1B Command Set > - > -// Authorzation > -TPM_RESULT TCSP_OIAP( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonce0 // out > - ); > - > -TPM_RESULT TCSP_OSAP ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_ENTITY_TYPE entityType, // in > - UINT32 entityValue, // in > - TPM_NONCE nonceOddOSAP, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonceEven, // out > - TPM_NONCE* nonceEvenOSAP // out > - ); > - > -TPM_RESULT TCSP_TakeOwnership ( TCS_CONTEXT_HANDLE hContext, // in > - UINT16 protocolID, // in > - UINT32 encOwnerAuthSize, // in > - BYTE* encOwnerAuth, // in > - UINT32 encSrkAuthSize, // in > - BYTE* encSrkAuth, // in > - UINT32* SrkSize, // in, out > - BYTE** Srk, // in, out > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_TerminateHandle ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle // in > - ); > - > -TPM_RESULT TCSP_FlushSpecific ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle, // in > - TPM_RESOURCE_TYPE resourceType //in > - ); > - > -// TPM Mandatory > -TPM_RESULT TCSP_Extend ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_DIGEST inDigest, // in > - TPM_PCRVALUE* outDigest // out > - ); > - > -TPM_RESULT TCSP_PcrRead ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_PCRVALUE* outDigest // out > - ); > - > -TPM_RESULT TCSP_Quote ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_NONCE antiReplay, // in > - UINT32* PcrDataSize, // in, out > - BYTE** PcrData, // in, out > - TCS_AUTH* privAuth, // in, out > - UINT32* sigSize, // out > - BYTE** sig // out > - ); > - > -TPM_RESULT TCSP_Seal ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_ENCAUTH encAuth, // in > - UINT32 pcrInfoSize, // in > - BYTE* PcrInfo, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* pubAuth, // in, out > - UINT32* SealedDataSize, // out > - BYTE** SealedData // out > - ); > - > -TPM_RESULT TCSP_Unseal ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE parentHandle, // in > - UINT32 SealedDataSize, // in > - BYTE* SealedData, // in > - TCS_AUTH* parentAuth, // in, out > - TCS_AUTH* dataAuth, // in, out > - UINT32* DataSize, // out > - BYTE** Data // out > - ); > - > -TPM_RESULT TCSP_DirWriteAuth ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_DIRINDEX dirIndex, // in > - TPM_DIRVALUE newContents, // in > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_DirRead ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_DIRINDEX dirIndex, // in > - TPM_DIRVALUE* dirValue // out > - ); > - > -TPM_RESULT TCSP_UnBind ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* outDataSize, // out > - BYTE** outData // out > - ); > - > -TPM_RESULT TCSP_CreateWrapKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hWrappingKey, // in > - TPM_ENCAUTH KeyUsageAuth, // in > - TPM_ENCAUTH KeyMigrationAuth, // in > - UINT32* pcKeySize, // in, out > - BYTE** prgbKey, // in, out > - TCS_AUTH* pAuth // in, out > - ); > - > -TPM_RESULT TCSP_LoadKeyByBlob ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hUnwrappingKey, // in > - UINT32 cWrappedKeyBlobSize, // in > - BYTE* rgbWrappedKeyBlob, // in > - TCS_AUTH* pAuth, // in, out > - TCS_KEY_HANDLE* phKeyTCSI, // out > - TCS_KEY_HANDLE* phKeyHMAC // out > - ); > - > -TPM_RESULT TCSP_GetPubKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey, // in > - TCS_AUTH* pAuth, // in, out > - UINT32* pcPubKeySize, // out > - BYTE** prgbPubKey // out > - ); > - > -TPM_RESULT TCSP_EvictKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey // in > - ); > - > -TPM_RESULT TCSP_Sign ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 areaToSignSize, // in > - BYTE* areaToSign, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* sigSize, // out > - BYTE** sig // out > - ); > - > -TPM_RESULT TCSP_GetRandom ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32* bytesRequested, // in, out > - BYTE** randomBytes // out > - ); > - > -TPM_RESULT TCSP_StirRandom ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 inDataSize, // in > - BYTE* inData // in > - ); > - > -TPM_RESULT TCSP_ReadPubek ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_NONCE antiReplay, // in > - UINT32* pubEndorsementKeySize, // out > - BYTE** pubEndorsementKey, // out > - TPM_DIGEST* checksum // out > - ); > - > - > -// Non-Standard TCSP calls > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext); // in > - > -//Give direct access to TransmitData. > -// Key and Auth Management is done before transfering command to TDDL. > -TPM_RESULT TCSP_RawTransmitData(UINT32 inDataSize, // in > - BYTE *inData, // in > - UINT32 *outDataSize,// in/out > - BYTE *outData); // out > - > -///////////// Private Functions //////////////////// > -CONTEXT_HANDLE* LookupContext( TCS_CONTEXT_HANDLE hContext); > - > -#endif //TCS_H > diff --git a/tools/vtpm_manager/tcs/tpmddl.h b/tools/vtpm_manager/tcs/tpmddl.h > deleted file mode 100644 > index e7e54f1..0000000 > --- a/tools/vtpm_manager/tcs/tpmddl.h > +++ /dev/null > @@ -1,69 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tpmddl.c > -// > -// This file defines the TDDLI API > -// > -// ================================================================== > - > -#ifndef __TPMDDL_H__ > -#define __TPMDDL_H__ > - > -#define TDDL_CAP_PROP_MANUFACTURER 0x0001 > - > -#define TDDL_E_FAIL 1 > -#define TDDL_E_SUCCESS 0 > -#define TDDL_SUCCESS 0 > - > -typedef unsigned int TDDL_UINT32; > -typedef TDDL_UINT32 TDDL_RESULT; > -typedef unsigned char TDDL_BYTE; > - > -TDDL_RESULT TDDL_Open(); > -void TDDL_Close(); > -TDDL_RESULT TDDL_TransmitData( TDDL_BYTE* in, > - TDDL_UINT32 insize, > - TDDL_BYTE* out, > - TDDL_UINT32* outsize); > -TDDL_RESULT TDDL_GetStatus(); > -TDDL_RESULT TDDL_GetCapability( TDDL_UINT32 cap, > - TDDL_UINT32 sub, > - TDDL_BYTE* buffer, > - TDDL_UINT32* size); > -TDDL_RESULT TDDL_SetCapability( TDDL_UINT32 cap, > - TDDL_UINT32 sub, > - TDDL_BYTE* buffer, > - TDDL_UINT32* size); > - > -#endif // __TPMDDL_H__ > diff --git a/tools/vtpm_manager/tcs/transmit.c b/tools/vtpm_manager/tcs/transmit.c > deleted file mode 100644 > index 74bbdca..0000000 > --- a/tools/vtpm_manager/tcs/transmit.c > +++ /dev/null > @@ -1,147 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "tpmddl.h" > - > -// flag to track whether TDDL has been opened > -static int g_TDDL_open = 0; > -static int g_tx_fd = -1; // the fd to the TPM > - > -#ifndef DUMMY_TPM > - #define TPM_TX_FNAME "/dev/tpm0" > - static int *g_rx_fdp = &g_tx_fd; > -#else > - #define TPM_TX_FNAME "/var/tpm/tpm_in.fifo" > - #define TPM_RX_FNAME "/var/tpm/tpm_out.fifo" > - static int g_rx_fd = -1; > - static int *g_rx_fdp = &g_rx_fd; // the fd to the TPM > -#endif > - > -TPM_RESULT > -TDDL_TransmitData( TDDL_BYTE* in, > - TDDL_UINT32 insize, > - TDDL_BYTE* out, > - TDDL_UINT32* outsize) { > - TPM_RESULT status = TPM_SUCCESS; > - TDDL_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 (g_tx_fd, in, insize); > - if (size < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed"); > - ERRORDIE (TPM_IOERROR); > - } > - else if ((TDDL_UINT32) size < insize) { > - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); > - // ... ? > - } > - > - // read the response > - size = read (*g_rx_fdp, out, TCPA_MAX_BUFFER_LENGTH); > - if (size < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed"); > - 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; > - // close connection > - goto egress; > - > - abort_egress: > - egress: > - return status; > -} > - > -TPM_RESULT TDDL_Open() { > - > - TDDL_RESULT status = TDDL_SUCCESS; > - > - if (g_TDDL_open) > - return TPM_FAIL; > - > -#ifdef DUMMY_TPM > - *g_rx_fdp = open (TPM_RX_FNAME, O_RDWR); > -#endif > - > - g_tx_fd = open (TPM_TX_FNAME, O_RDWR); > - if (g_tx_fd < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "TPM open failed"); > - return TPM_IOERROR; > - } > - > - g_TDDL_open = 1; > - > - return status; > -} > - > -void TDDL_Close() { > - if (! g_TDDL_open) > - return; > - > - if (g_tx_fd>= 0) { > - if (close(g_tx_fd) < 0) > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > - g_tx_fd = -1; > - } > - > - if (*g_rx_fdp>= 0) { > - if (close(*g_rx_fdp) < 0) > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > - *g_rx_fdp = -1; > - } > - > - g_TDDL_open = 0; > - > -} > diff --git a/tools/vtpm_manager/util/Makefile b/tools/vtpm_manager/util/Makefile > deleted file mode 100644 > index 36bc38f..0000000 > --- a/tools/vtpm_manager/util/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libTCGUtils.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/util/bsg.c b/tools/vtpm_manager/util/bsg.c > deleted file mode 100644 > index fa36ce7..0000000 > --- a/tools/vtpm_manager/util/bsg.c > +++ /dev/null > @@ -1,829 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// bsg.cpp > -// > -// This file will handle all the TPM Byte Stream functions > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include "tcg.h" > -#include "crypto.h" > -#include "bsg.h" > -#include "log.h" > - > -static int g_log_recursion_level = 0; > - > -// a largest buffer size. if we get a buf size bigger than this when unpacking, > -// will complain! > -#define BSG_MAX_BUF_SIZE (1<<18) > - > -#define bsglog(fmt, ...) do { \ > - int __i; \ > - for (__i=0; __i < g_log_recursion_level; __i++) { \ > - vtpmloginfomore (VTPM_LOG_BSG, "%s", " "); \ > - } \ > - vtpmloginfomore (VTPM_LOG_BSG, fmt, __VA_ARGS__); \ > - } while (0) > - > - > -// FIXME: trigger the selfcheck--need to use glibc hook to do this > -//BOOL dummy1 = BSG_static_selfcheck(); > - > - > -// Interpretting Types > -// ------------------- > -// > -// Incoming Types are composed of two parts {format, info} squished into a > -// BSG_UINT32. The first 4 bits is a format spec indicating what type of > -// data it is. If the first 4 bits are zero the info corresponds to a value in > -// BSG_s_fmt[]. This is a structure whose composition is described in > -// BSG_s_fmt[]. If the value is non-zero, info corresponds to the size of the > -// data (in bytes) being passed in. For example a UINT32 being passed in would > -// have a format of (__FMT_CONST | 4). If both, the format and info are zero, > -// this is interpretted as the end of the structure, and the result is returned. > - > -// these flags are mutually exclusive, so I'll just make them > -// format values which indicate the semantics of the 'info' part and the source > -// data. The above description has been accordingly adjusted. > - > -// format values for determining what type of data the incoming type is > -// it's a 4 bit value, occupying the high 4 bits > -#define __FMT_CONST (1UL << 28) // Constant sized value > -#define __FMT_DATA (2UL << 28) // Believed to be raw data NOT {size,data} > -#define __FMT_SIZE (3UL << 28) // A size. Used in FMT_SIZE??_DATA. > -#define __FMT_HSIZE (4UL << 28) // A number of handles > -#define __FMT_PACKED (5UL << 28) // 'info' is unused; the source data consists > - // of {size32, data} but we're to pack only the > - // data as that is already packed, and so > - // can/must be unpacked without > - // explicitly reading it size > - > -#define __FMT_MASK 0x0FFFFFFFUL // this masks out the 4-bit format > -#define __FMT_MASK_SIZE(type) ((type) & __FMT_MASK) > -#define __FMT_MASK_FORMAT(type) ((type) & (~__FMT_MASK)) > - > -// constant (8/16/32-bits) > -#define FMT_U8 (__FMT_CONST | 1UL) > -#define FMT_U16 (__FMT_CONST | 2UL) > -#define FMT_U32 (__FMT_CONST | 4UL) > - > -// const with a compiler-computed size > -#define FMT_SIZEOF(type) (__FMT_CONST | sizeof(type)) > - > -// other data (size bytes) > -// Used primarily for DIGESTS -> FMT_DATA(20) > -#define FMT_DATA(size) (__FMT_DATA | ((BSG_UINT32) (size) & __FMT_MASK)) > - > -// 16/32-bit size followed by N bytes of data > -#define FMT_SIZE16_DATA (__FMT_SIZE | 2UL) > -#define FMT_SIZE32_DATA (__FMT_SIZE | 4UL) > - > -// 16-bit size followed by N key handles > -#define FMT_SIZE16_HANDLES (__FMT_HSIZE | 2UL) > - > -#define DIGEST_SIZE 20 > -typedef BSG_UINT32 BSG_HANDLE; > - > -// TCPA_AUTH has 11 fields! > -#define MAX_FIELDS 11 > -typedef struct BSG_Format > -{ > - BSG_Type type; > - const char* name; > - BSG_UINT32 fields[MAX_FIELDS + 1]; > -} BSG_Format; > - > -/* > - * TCPA structure data formats > - */ > -// this has to be manually kept in sync with the > -// Type enum!! the static_selfcheck() function should be used regularly! > -static BSG_Format s_fmt[] = > -{ > - {BSG_TYPE_UINT32, "BSG_TYPE_UINT32", {FMT_U32, 0}}, > - {BSG_TYPE_UINT16, "BSG_TYPE_UINT16", {FMT_U16, 0}}, > - {BSG_TYPE_BYTE, "BSG_TYPE_BYTE", {FMT_U8, 0}}, > - {BSG_TYPE_BOOL, "BSG_TYPE_BOOL", {FMT_U8, 0}}, > - {BSG_TPM_SIZE32_DATA, "BSG_TPM_SIZE32_DATA", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_TAG, "BSG_TPM_TAG", {FMT_SIZEOF(TPM_TAG), 0}}, > - {BSG_TPM_HANDLE, "BSG_TPM_HANDLE", {FMT_SIZEOF(TPM_HANDLE), 0}}, > - {BSG_TPM_RESULT, "BSG_TPM_RESULT", {FMT_SIZEOF(TPM_RESULT), 0}}, > - {BSG_TPM_RESOURCE_TYPE, "BSG_TPM_RESOURCE_TYPE", {FMT_SIZEOF(TPM_RESOURCE_TYPE), 0}}, > - {BSG_TPM_COMMAND_CODE, "BSG_TPM_COMMAND_CODE", {FMT_U32, 0}}, > - {BSG_TPM_AUTH_DATA_USAGE, "BSG_TPM_AUTH_DATA_USAGE", {FMT_U8, 0}}, > - {BSG_TPM_ALGORITHM_ID, "BSG_TPM_ALGORITHM_ID", {FMT_U32, 0}}, > - {BSG_TPM_PROTOCOL_ID, "BSG_TPM_PROTOCOL_ID", {FMT_SIZEOF(TPM_PROTOCOL_ID), 0}}, > - {BSG_TPM_KEY_USAGE, "BSG_TPM_KEY_USAGE", {FMT_U16, 0}}, > - {BSG_TPM_ENC_SCHEME, "BSG_TPM_ENC_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_SIG_SCHEME, "BSG_TPM_SIG_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_MIGRATE_SCHEME, "BSG_TPM_MIGRATE_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_KEY_FLAGS, "BSG_TPM_KEY_FLAGS", {FMT_U32, 0}}, > - > - {BSG_TPM_AUTHDATA, "BSG_TPM_AUTHDATA", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_SECRET, "BSG_TPM_SECRET", {BSG_TPM_AUTHDATA, 0}}, > - {BSG_TPM_ENCAUTH, "BSG_TPM_ENCAUTH", {BSG_TPM_AUTHDATA, 0}}, > - {BSG_TPM_PAYLOAD_TYPE, "BSG_TPM_PAYLOAD_TYPE", {FMT_SIZEOF(TPM_PAYLOAD_TYPE), 0}}, > - > - {BSG_TPM_VERSION, "BSG_TPM_VERSION", {FMT_DATA(4), 0}}, // vers 1.2 > - {BSG_TPM_DIGEST, "BSG_TPM_DIGEST", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_COMPOSITE_HASH, "BSG_TPM_COMPOSITE_HASH", {BSG_TPM_DIGEST, 0}}, > - {BSG_TPM_CHOSENID_HASH, "BSG_TPM_CHOSENID_HASH", {BSG_TPM_DIGEST, 0}}, > - > - {BSG_TPM_NONCE, "BSG_TPM_NONCE", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_KEY_HANDLE, "BSG_TPM_KEY_HANDLE", {FMT_SIZEOF(TPM_KEY_HANDLE), 0}}, > - {BSG_TPM_KEY_HANDLE_LIST, "BSG_TPM_KEY_HANDLE_LIST", > - {FMT_SIZE16_HANDLES, 0}}, > - > - {BSG_TPM_KEY_PARMS, "BSG_TPM_KEY_PARMS", { > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_ENC_SCHEME, > - BSG_TPM_SIG_SCHEME, > - FMT_SIZE32_DATA, > - 0}}, > - {BSG_TPM_RSA_KEY_PARMS, "BSG_TPM_RSA_KEY_PARMS", { > - FMT_U32, FMT_U32, FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_STORE_PUBKEY, "BSG_TPM_STORE_PUBKEY", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_PUBKEY, "BSG_TPM_PUBKEY", {BSG_TPM_KEY_PARMS, BSG_TPM_STORE_PUBKEY, 0}}, > - {BSG_TPM_KEY, "BSG_TPM_KEY", { > - BSG_TPM_VERSION, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_KEY_PARMS, > - FMT_SIZE32_DATA, // the PCR_INFO > - BSG_TPM_STORE_PUBKEY, > - FMT_SIZE32_DATA, // the encrypted part > - 0}}, > - > - {BSG_TPM_MIGRATIONKEYAUTH, "BSG_TPM_MIGRATIONKEYAUTH", { > - BSG_TPM_PUBKEY, > - BSG_TPM_MIGRATE_SCHEME, > - BSG_TPM_DIGEST, 0}}, > - > - {BSG_TCPA_AUDIT_EVENT, "TCPA_AUDIT_EVENT", { > - BSG_TPM_COMMAND_CODE, > - BSG_TPM_RESULT, 0 }}, > - > - {BSG_TCPA_EVENT_CERT, "TCPA_EVENT_CERT", { > - BSG_TPM_DIGEST, > - BSG_TPM_DIGEST, > - FMT_DATA(2), > - FMT_SIZE32_DATA, 0}}, > - > - {BSG_TPM_PCR_SELECTION, "BSG_TPM_PCR_SELECTION", {FMT_SIZE16_DATA, 0} }, > - {BSG_TPM_PCR_COMPOSITE, "BSG_TPM_PCR_COMPOSITE", { BSG_TPM_PCR_SELECTION, > - FMT_SIZE32_DATA, > - 0} }, > - > - {BSG_TPM_PCR_INFO, "BSG_TPM_PCR_INFO", { BSG_TPM_PCR_SELECTION, > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_COMPOSITE_HASH, > - 0} }, > - > - > - {BSG_TPM_STORED_DATA, "BSG_TPM_STORED_DATA", { > - BSG_TPM_VERSION, > - FMT_SIZE32_DATA, > - FMT_SIZE32_DATA, > - 0}}, > - {BSG_TPM_SYMMETRIC_KEY, "BSG_TPM_SYMMETRIC_KEY", { > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_ENC_SCHEME, > - FMT_SIZE16_DATA, > - 0}}, > - {BSG_TPM_STORE_PRIVKEY, "BSG_TPM_STORE_PRIVKEY", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_STORE_ASYMKEY, "BSG_TPM_STORE_ASYMKEY", { > - BSG_TPM_PAYLOAD_TYPE, > - BSG_TPM_SECRET, > - BSG_TPM_SECRET, > - BSG_TPM_DIGEST, > - BSG_TPM_STORE_PRIVKEY, > - 0}}, > - {BSG_TPM_MIGRATE_ASYMKEY, "BSG_TPM_MIGRATE_ASYMKEY", { > - BSG_TPM_PAYLOAD_TYPE, > - BSG_TPM_SECRET, > - BSG_TPM_DIGEST, > - FMT_U32, > - BSG_TPM_STORE_PRIVKEY, > - 0}}, > - > - {BSG_TPM_QUOTE_INFO, "BSG_TPM_QUOTE_INFO", { > - BSG_TPM_VERSION, > - FMT_DATA(4), > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_NONCE, > - 0}}, > - > - {BSG_TPM_IDENTITY_CONTENTS, "BSG_TPM_IDENTITY_CONTENTS", { > - BSG_TPM_VERSION, > - FMT_U32, > - BSG_TPM_CHOSENID_HASH, > - BSG_TPM_PUBKEY, > - 0}}, > - > - {BSG_TPM_PCRVALUE, "BSG_TPM_PCRVALUE", {FMT_DATA(DIGEST_SIZE), 0}}, > - > - {BSG_TCPA_PCR_FLAGS, "TCPA_PCR_FLAGS", { > - FMT_U8, > - FMT_U8, > - 0}}, > - > - {BSG_TCS_AUTH, "TCS_AUTH", { > - BSG_TYPE_UINT32, > - BSG_TPM_NONCE, > - BSG_TPM_NONCE, > - BSG_TYPE_BOOL, > - BSG_TPM_AUTHDATA, > - 0}}, > - > - {BSG_TPM_KEY_NONSENSITIVE, "BSG_TPM_KEY_NONSENSITIVE", { > - BSG_TPM_VERSION, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_KEY_PARMS, > - FMT_SIZE32_DATA, > - BSG_TPM_STORE_PUBKEY, > - 0}}, > - > - {BSG_PACKED, "BSG_PACKED", { > - __FMT_PACKED, > - 0 }}, > - > - {BSG_TYPE_MAX, "", {0}}, > -}; > - > - > -static const BSG_Format* find_format (BSG_Type t) { > - BSG_Format * f = s_fmt; > - > - if (t >= BSG_TYPE_MAX) { > - return NULL; > - } > - > - // WARNING: this depends on the enum and s_fmt[] array being in sync! make > - // sure to run the static_selfcheck() to make sure > - f = s_fmt + (t - BSG_TYPE_FIRST); > - > - return f; > -} > - > -// > -// a consistency-checking routine which can be run at compile time > -// (ie. immediately after compilation) > -// > -// tasks: > -// - verify that s_fmt has one entry per Type t, and that entry is at s_fmt[t] > -// > -// conditions: > -// - need that s_fmt[0] is the first type listed in the Type enum! ie the first > -// Type has value 0, not 1 > -// > -// FIXME: should have a function be passed in here which is called if the test > -// fails. Then the caller can decide what to do: abort, notify, whatever > -// > -BOOL BSG_static_selfcheck () > -{ > - int i; > - > - for (i=BSG_TYPE_FIRST; i <= BSG_TYPE_MAX; i++) { > - if (s_fmt[i - BSG_TYPE_FIRST].type != i) { > - bsglog ("%s\n", "BSG: static_selfcheck failed!\n"); > - bsglog ("failure at %i, allegedly %s\n", > - i, s_fmt[i - BSG_TYPE_FIRST].name); > - abort(); > - return FALSE; > - } > - } > - > - bsglog ("%s\n", "BSG: static_selfcheck success!"); > - return TRUE; > -} > - > - > -/** > - * Flatten a TCPA structure into a buffer in big-endian format > - * @type: TCPA structure type > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > - * @dst: (OUT) flattened data > - * Returns: Flattened size or -1 for unknown types > - */ > -// make it so that it can just run through the whole process and return > -// the packed size, without packing anything. this will be done if dst is NULL. > -static int BSG_Pack_private(BSG_Type type, const BSG_BYTE** src, BSG_BYTE* dst) > -{ > - // check incoming parameters > - if (*src == NULL) > - return 0; > - > - const BSG_BYTE* s = *src; > - BSG_BYTE* d = dst; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if (format == __FMT_CONST) // We are dealing with a fixed length value eg. UINT32 > - { > - BSG_UINT32 val = 0; > - switch (size) { > - case 1: val = * (BYTE*) s; break; > - case 2: val = * (unsigned short*) s; break; > - case 4: val = * (BSG_UINT32*) s; break; > - } > - if (dst) > - BSG_PackConst(val, size, d); > - > - s += size; > - d += size; > - } else if (format == __FMT_DATA) { // We are dealing with raw data. Not sure when > - // this is used. > - > - if (dst) { > - bsglog ("BSG: __FMT_DATA size %d, src %p, dst %p\n", size, s, d); > - memcpy(d, s, size); > - } > - > - s += size; > - d += size; > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) { // It's a size, followed by that much data or handles > - > - BSG_UINT32 psize = 0; > - switch (size) { > - case 1: psize = * (BYTE*) s; break; > - case 2: psize = * (unsigned short*) s; break; > - case 4: psize = * (BSG_UINT32*) s; break; > - } > - > - if (dst) > - BSG_PackConst(psize, size, d); > - > - s += size; > - d += size; > - > - // now 's' points to an address, so cast it to BSG_BYTE** > - const BSG_BYTE* pdata = * ((BSG_BYTE**) s); > - s += sizeof(BSG_BYTE*); > - > - if (format == __FMT_HSIZE) {// This is a list of psize Handles > - if (dst) { > - BSG_HANDLE* d2 = (BSG_HANDLE*) d; > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > - BSG_UINT32 i; > - for (i = 0; i < psize; i++) > - d2[i] = BSG_UnpackConst((BSG_BYTE*)(p2 + i), 4); > - > - } > - d += psize * sizeof(BSG_HANDLE); > - } else {// If it's not psize handles, it's psize data. > - if (psize > 0) { > - if (dst) { > - bsglog ("BSG: __FMT_SIZE, size=%d, src=%p, dst=%p\n", > - psize, pdata, d); > - memcpy(d, pdata, psize); > - } > - } > - d += psize; > - } > - } else if (format == __FMT_PACKED) { > - // the source buffer is a pack_constbuf_t, which has a size and a > - // pointer. just copy the buffer value, the size is not included in the > - // output stream. > - pack_constbuf_t * buf = (pack_constbuf_t*) s; > - > - if (dst) { > - bsglog ("BSG: __FMT_PACKED, size=%d, src=%p, dst=%p\n", > - buf->size, buf->data, d); > - memcpy(d, buf->data, buf->size); > - } > - > - s += buf->size; > - d += buf->size; > - } else if (format == 0) {// No flags are set. This is a structure & it should > - // be looked up in the bsg_s_fmt[] > - > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmloginfo(VTPM_LOG_BSG, "BSG_Pack: cannot find type %d\n", type); > - return -1; > - } > - > - if (dst) > - bsglog ("BSG_Pack type %s\n", x->name); > - > - > - // iterate through the fields > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) { > - int fsize; > - > - g_log_recursion_level++; > - fsize = BSG_Pack_private((BSG_Type) *f, &s, dst ? d : NULL); > - g_log_recursion_level--; > - > - if (fsize <= 0) > - return fsize; > - > - d += fsize; > - } > - } else { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Pack(): Unknown format %d\n", format); > - return -1; > - } > - > - *src = s; > - return (d - dst); > -} > - > -/** > - * Unflatten a TCPA structure from a buffer in big-endian format > - * @type: TCPA structure type > - * @src: flattened data > - * @dst: (IN) TCPA structure (OUT) end of TCPA structure > - * Returns: Flattened size > - * Note: Returns flattened size NOT the unpacked structure size > - */ > -static int BSG_Unpack_private(BSG_Type type, const BSG_BYTE* src, BSG_BYTE** dst) { > - // check incoming parameters > - if (src == NULL) > - return 0; > - > - > - const BSG_BYTE* s = src; > - BSG_BYTE* d = dst ? *dst:NULL; > - if (dst && !d) > - dst = NULL; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if (format == __FMT_CONST) {// We are dealing with a fixed length value ie. UINT32 > - > - BSG_UINT32 val = BSG_UnpackConst(s, size); > - > - if (dst) { > - switch (size) { > - case 1: *(BYTE *) d = (BSG_BYTE) val; break; > - case 2: *(unsigned short*) d = (unsigned short) val; break; > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) val; break; > - } > - } > - > - s += size; > - d += size; > - } else if (format == __FMT_DATA) {// We are dealing with raw data. Not sure when this is used. > - if (dst) > - memcpy(d, s, size); > - > - d += size; > - s += size; > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) {// It's a size, followed by that much data or handles > - > - BSG_UINT32 psize = BSG_UnpackConst(s, size); > - > - if (psize > BSG_MAX_BUF_SIZE) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack runs into var-sized data bigger than %u bytes!!\n", > - BSG_MAX_BUF_SIZE); > - return -1; > - } > - > - if (dst) { > - switch (size) { > - case 1: *(BYTE *) d = (BSG_BYTE) psize; break; > - case 2: *(unsigned short*) d = (unsigned short) psize; break; > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) psize; break; > - } > - } > - > - s += size; > - d += size; > - > - BSG_BYTE* pdata = NULL; > - > - if (psize) { > - if (format == __FMT_HSIZE) { // This is a list of psize Handles > - if (dst) { > - BSG_HANDLE* s2 = (BSG_HANDLE*) s; > - pdata = (BSG_BYTE *)malloc(psize * sizeof(BSG_HANDLE)); > - if (!pdata) > - return -1; > - > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > - BSG_UINT32 i; > - for (i = 0; i < psize; i++) { > - BSG_PackConst(s2[i], 4, (BSG_BYTE*)(p2 + i)); > - } > - } > - s += psize * sizeof(BSG_HANDLE); > - } else { // If it's not psize handles, it's psize data. > - if (dst) { > - pdata = (BSG_BYTE *)malloc(sizeof(BSG_BYTE) * psize); > - if (!pdata) > - return -1; > - memcpy(pdata, s, psize); > - } > - s += psize; > - } > - } > - if (dst) > - *(void**) d = pdata; > - > - d += sizeof(void*); > - } else if (format == __FMT_PACKED) { > - > - // this doesn't make sense for unpacking! > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack() called with format __FMT_PACKED. " > - "This does not make sense\n"); > - > - return -1; > - } else if (format == 0) {// No flags are set. This is a structure & it should > - // be looked up in the bsg_s_fmt[] > - > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack: cannot find type %d\n", type); > - return -1; > - } > - > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) { > - int fsize = BSG_Unpack_private((BSG_Type) *f, s, dst ? &d:NULL); > - if (fsize <= 0) > - return fsize; > - s += fsize; > - } > - } > - > - if (dst) > - *dst = d; > - return (s - src); > -} > - > -/** > - * Free memory associated with unpacked TCPA structure > - * @type: TCPA structure type > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > - * Note: Destroy should be called on all structures created with Unpack > - * to ensure that any allocated memory is freed > - */ > -static void BSG_Destroy_private(BSG_Type type, BSG_BYTE** src) { > - BSG_BYTE* s = *src; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if ((src == NULL) || (*src == NULL)) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with NULL src\n"); > - return; > - } > - > - if (format == __FMT_CONST || format == __FMT_DATA) > - s += size; > - else if (format == __FMT_SIZE || format == __FMT_HSIZE) { > - s += size; > - BSG_BYTE* ptr = *(BSG_BYTE**) s; > - free(ptr); > - s += sizeof(void*); > - } else if (format == __FMT_PACKED) { > - > - // this doesn't make sense for unpacking, hence also for Destroy() > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with format __FMT_PACKED. " > - "This does not make sense\n"); > - > - return; > - } else if (format == 0) { > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy: cannot find type %d\n", type); > - return; > - } > - > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) > - BSG_Destroy_private((BSG_Type) *f, &s); > - } > - > - *src = s; > -} > - > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst) > -{ > - const BSG_BYTE* src2 = (const BSG_BYTE*) src; > - return BSG_Pack_private(type, &src2, dst); > -} > - > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst) > -{ > - BSG_BYTE* dst2 = (BSG_BYTE*) dst; > - return BSG_Unpack_private(type, src, dst ? &dst2:NULL); > -} > - > -void BSG_Destroy(BSG_Type type, void* src) > -{ > - BSG_BYTE* src2 = (BSG_BYTE*) src; > - BSG_Destroy_private(type, &src2); > -} > - > -/** > - * Pack a 8/16/32-bit constant into a buffer in big-endian format > - * @val: constant value > - * @size: constant size in bytes (1, 2, or 4) > - * @dst: (OUT) buffer > - */ > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst) { > - bsglog ("BSG: PackConst on %d of size %i into address %p\n", val, size, dst); > - > - switch (size) { > - case 4: > - dst[0] = (BSG_BYTE)((val >> 24) & 0xff); > - dst[1] = (BSG_BYTE)((val >> 16) & 0xff); > - dst[2] = (BSG_BYTE)((val >> 8) & 0xff); > - dst[3] = (BSG_BYTE)(val & 0xff); > - break; > - case 2: > - dst[0] = (BSG_BYTE)((val >> 8) & 0xff); > - dst[1] = (BSG_BYTE)(val & 0xff); > - break; > - case 1: > - dst[0] = (BSG_BYTE)(val & 0xff); > - break; > - } > -} > - > -/** > - * Unpack a 8/16/32-bit constant from a buffer in big-endian format > - * @src: buffer > - * @size: constant size in bytes (1, 2, or 4) > - */ > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size) { > - BSG_UINT32 val = 0; > - > - if (src == NULL) > - return 0; > - > - switch (size) { > - case 4: > - val = (((BSG_UINT32) src[0]) << 24 > - | ((BSG_UINT32) src[1]) << 16 > - | ((BSG_UINT32) src[2]) << 8 > - | (BSG_UINT32) src[3]); > - break; > - case 2: > - val = (((BSG_UINT32) src[0]) << 8 | (BSG_UINT32) src[1]); > - break; > - case 1: > - val = (BSG_UINT32) src[0]; > - break; > - } > - return val; > -} > - > -// Pack a list of parameters. Beware not to send values, but rather you must > -// send a pointer to your values Instead. This includes UINT32's. > -int BSG_PackList( BSG_BYTE* dst, int ParamCount, ... ) { > - int ParamNumber; > - BSG_Type format; > - BSG_BYTE* val = NULL; > - int size=0; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - //Strangeness with int is because gcc wanted an int rather than a enum of ints. > - format = (BSG_Type) va_arg( paramList, int ); > - val = va_arg( paramList, BSG_BYTE* ); > - size += BSG_Pack(format, val, dst == NULL ? NULL : dst + size); > - } > - > - va_end (paramList); > - > - return size; > -} > - > -// Unpack a list of parameters. > -int BSG_UnpackList( const BSG_BYTE* src, int ParamCount, ... ) { > - int ParamNumber = 0; > - BSG_Type format; > - BSG_BYTE* val = NULL; > - int size = 0; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - format = (BSG_Type) va_arg( paramList, int ); > - val = va_arg( paramList, BSG_BYTE* ); > - > - size += BSG_Unpack(format, src + size, val); > - } > - > - va_end( paramList ); > - > - return size; > -} > - > -// Destroy any memory allocated by calls to unpack > -void BSG_DestroyList(int ParamCount, ... ) { > - int ParamNumber = 0; > - BSG_Type argType; > - BSG_BYTE* paramValue = NULL; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - argType = (BSG_Type) va_arg( paramList, int ); > - paramValue = va_arg( paramList, BSG_BYTE* ); > - > - BSG_Destroy(argType, paramValue); > - } > - > - va_end( paramList ); > - > - return; > -} > - > - > -// and a tuple version > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]) { > - int i; > - > - for (i = 0; i < numParams; i++) > - BSG_Destroy (params[i].type, params[i].addr); > - > - return TPM_SUCCESS; > -} > - > - > -// > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > -// by the caller later > -// > - > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst) { > - int size = BSG_Pack (type, src, NULL); > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > - if (dest == NULL) > - return -1; > - > - size = BSG_Pack(type, src, dest); > - *o_dst = dest; > - return size; > -} > - > - > - > -int BSG_PackListMalloc(BSG_BYTE** outBuffer, int ParamCount, ... ) { > - va_list args; > - int size; > - > - va_start (args, ParamCount); > - size = BSG_PackList (NULL, ParamCount, args); > - va_end (args); > - > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > - if (dest == NULL) > - return -1; > - > - va_start (args, ParamCount); > - size = BSG_PackList (dest, ParamCount, args); > - va_end (args); > - > - *outBuffer = dest; > - return size; > -} > diff --git a/tools/vtpm_manager/util/bsg.h b/tools/vtpm_manager/util/bsg.h > deleted file mode 100644 > index 0896812..0000000 > --- a/tools/vtpm_manager/util/bsg.h > +++ /dev/null > @@ -1,166 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// bsg.h > -// > -// This file contains API's for the TPM Byte Stream functions > -// > -// ================================================================== > - > -#ifndef __BSG_H__ > -#define __BSG_H__ > - > -#include > -#include "buffer.h" > - > -typedef unsigned int BSG_UINT32; > -typedef unsigned char BSG_BYTE; > - > -// forward decl > -struct pack_const_tuple_t; > - > -struct pack_tuple_t; > - > - > -/** > - * Byte stream generator > - */ > -// this has to be manually kept in sync with the > -// s_fmt array!! > -// but now we have a self-check function which can make sure things are well > -// (if used!) > -typedef enum BSG_Type > -{ > - BSG_TYPE_FIRST = 1, > - BSG_TYPE_UINT32 = 1, // start at 1 so that Type 0 only serves as an > - // unused/special value > - BSG_TYPE_UINT16, > - BSG_TYPE_BYTE, > - BSG_TYPE_BOOL, > - BSG_TPM_SIZE32_DATA, // a 32 bit unsigned size, followed by > - // a pointer to that much data. can pass a > - // struct pack_buf_t as the param > - BSG_TPM_TAG, > - BSG_TPM_HANDLE, > - BSG_TPM_RESULT, > - BSG_TPM_RESOURCE_TYPE, > - BSG_TPM_COMMAND_CODE, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_PROTOCOL_ID, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_ENC_SCHEME, > - BSG_TPM_SIG_SCHEME, > - BSG_TPM_MIGRATE_SCHEME, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTHDATA, > - BSG_TPM_SECRET, > - BSG_TPM_ENCAUTH, > - BSG_TPM_PAYLOAD_TYPE, > - > - BSG_TPM_VERSION, > - BSG_TPM_DIGEST, > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_CHOSENID_HASH, > - BSG_TPM_NONCE, > - BSG_TPM_KEY_HANDLE, > - BSG_TPM_KEY_HANDLE_LIST, > - BSG_TPM_KEY_PARMS, > - BSG_TPM_RSA_KEY_PARMS, > - BSG_TPM_STORE_PUBKEY, > - BSG_TPM_PUBKEY, > - BSG_TPM_KEY, > - > - BSG_TPM_MIGRATIONKEYAUTH, > - BSG_TCPA_AUDIT_EVENT, > - BSG_TCPA_EVENT_CERT, > - BSG_TPM_PCR_SELECTION, > - BSG_TPM_PCR_COMPOSITE, > - BSG_TPM_PCR_INFO, > - BSG_TPM_STORED_DATA, > - BSG_TPM_SYMMETRIC_KEY, > - BSG_TPM_STORE_PRIVKEY, > - BSG_TPM_STORE_ASYMKEY, > - BSG_TPM_MIGRATE_ASYMKEY, > - BSG_TPM_QUOTE_INFO, > - BSG_TPM_IDENTITY_CONTENTS, > - BSG_TPM_PCRVALUE, > - BSG_TCPA_PCR_FLAGS, > - BSG_TCS_AUTH, > - > - // this is the BSG_TPM_KEY struct without the encData field > - BSG_TPM_KEY_NONSENSITIVE, > - > - BSG_PACKED, > - > - BSG_TYPE_MAX > -} BSG_Type; > - > -struct pack_const_tuple_t { > - BSG_Type type; > - const void * addr; > -}; > - > - > -typedef struct pack_tuple_t { > - BSG_Type type; > - void * addr; > -} pack_tuple_t; > - > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst); > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst); > -void BSG_Destroy(BSG_Type type, void* src); > - > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > -// by the caller later. returns size of allocated buffer, or -1 in case > -// allocation failed > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst); > -int BSG_PackListMalloc (BSG_BYTE** outBuffer, int ParamCount, ... ); > - > -// a va_list version of PackList > -int BSG_PackList(BSG_BYTE* outBuffer, int ParamCount, ... ); > -int BSG_UnpackList(const BSG_BYTE* inBuffer, int ParamCount, ... ); > -void BSG_DestroyList(int ParamCount, ... ); > - > -// wrapper of PackList which uses a buffer_t > -TPM_RESULT BSG_PackListBuf (buffer_t * o_buf, int ParamCount, ...); > - > -// and a tuple version > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]); > - > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst); > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size); > - > -BOOL BSG_static_selfcheck (); > - > -#endif > diff --git a/tools/vtpm_manager/util/buffer.c b/tools/vtpm_manager/util/buffer.c > deleted file mode 100644 > index df48bc2..0000000 > --- a/tools/vtpm_manager/util/buffer.c > +++ /dev/null > @@ -1,226 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > - > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "buffer.h" > - > -static TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize); > - > -// > -// buffer functions! > -// > - > -TPM_RESULT buffer_init (buffer_t * buf, tpm_size_t initsize, const BYTE* initval) { > - if (initsize == 0) { > - memset(buf, 0, sizeof(*buf)); > - return TPM_SUCCESS; > - } > - > - > - buf->bytes = (BYTE*) malloc (initsize); > - if (buf->bytes == NULL) > - return TPM_RESOURCES; > - > - buf->size = initsize; > - buf->alloc_size = initsize; > - > - if (initval) > - memcpy (buf->bytes, initval, initsize); > - > - buf->is_owner = TRUE; > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_init_convert (buffer_t * buf, tpm_size_t initsize, BYTE* initval) { > - > - buf->size = initsize; > - buf->alloc_size = initsize; > - buf->bytes = initval; > - > - buf->is_owner = TRUE; > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src) { > - TPM_RESULT status = buffer_init (buf, src->size, src->bytes); > - buf->is_owner = TRUE; > - > - return status; > -} > - > - > - > -// make an alias to a constant array > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val) { > - // TODO: try to enforce the const things somehow! > - buf->bytes = (BYTE*) val; > - buf->size = size; > - buf->alloc_size = 0; // this field is now unneeded > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > -// make an alias into buf, with given offset and length > -// if len = 0, make the alias go to the end of buf > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > - tpm_size_t offset, tpm_size_t len) { > - if (offset + len > b->size) { > - return TPM_NOSPACE; > - } > - > - buf->bytes = b->bytes + offset; > - buf->size = len > 0 ? len : b->size - offset; > - > - //VS/ buf->alloc_size = 0; > - if (len ==0) > - buf->alloc_size = b->alloc_size - offset; > - else > - buf->alloc_size = MIN(b->alloc_size - offset, len); > - > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > -// make an alias buffer_t into bytestream, with given length > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, tpm_size_t size, BYTE* val) { > - > - buf->size = size; > - buf->alloc_size = size; > - buf->bytes = val; > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > - > - > -// copy into the start of dest > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src) > -{ > - TPM_RESULT status = TPM_SUCCESS; > - > - if (dest->alloc_size < src->size) { > - TPMTRYRETURN( buffer_priv_realloc (dest, src->size) ); > - } > - > - memcpy (dest->bytes, src->bytes, src->size); > - dest->size = src->size; > - > - //VS/ dest->is_owner = TRUE; > - > - abort_egress: > - > - return status; > -} > - > - > - > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b) { > - return (a->size == b->size && memcmp (a->bytes, b->bytes, a->size) == 0); > -} > - > - > -void buffer_memset (buffer_t * buf, BYTE b) { > - memset (buf->bytes, b, buf->size); > -} > - > - > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes) { > - TPM_RESULT status = TPM_SUCCESS; > - > - if (buf->alloc_size < buf->size + len) { > - TPMTRYRETURN( buffer_priv_realloc (buf, buf->size + len) ); > - } > - > - memcpy (buf->bytes + buf->size, bytes, len); > - > - buf->size += len; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -tpm_size_t buffer_len (const buffer_t* buf) { > - return buf->size; > -} > - > -TPM_RESULT buffer_free (buffer_t * buf) { > - if (buf && buf->is_owner && buf->bytes != NULL) { > - free (buf->bytes); > - buf->bytes = NULL; > - buf->size = buf->alloc_size = 0; > - > - } > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize) { > - > - // we want to realloc to twice the size, or the new size, whichever > - // bigger > - > - BYTE * tmpbuf = NULL; > - > - newsize = MAX (buf->alloc_size * 2, newsize); > - > - tmpbuf = (BYTE*) realloc (buf->bytes, newsize); > - if (tmpbuf == NULL) > - return TPM_SIZE; > - > - > - buf->bytes = tmpbuf; > - buf->alloc_size = newsize; > - > - return TPM_SUCCESS; > -} > diff --git a/tools/vtpm_manager/util/buffer.h b/tools/vtpm_manager/util/buffer.h > deleted file mode 100644 > index d8a9abc..0000000 > --- a/tools/vtpm_manager/util/buffer.h > +++ /dev/null > @@ -1,95 +0,0 @@ > -// =================================================================== > -// > -// 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_BUFFER_H__ > -#define __VTPM_BUFFER_H__ > - > -#include // for pointer NULL > -#include "tcg.h" > - > -typedef UINT32 tpm_size_t; > - > -// first version, probably will be expanded... > - > -#define NULL_BUF {0,0,0,0} > - > -typedef struct { > - // private!! > - tpm_size_t size, alloc_size; > - BYTE * bytes; > - > - BOOL is_owner; // do we own this buffer, and need to free it? > -} buffer_t; > - > -// allocate the buffer if initsize > 0, copying over initval if provided > -TPM_RESULT buffer_init (buffer_t * buf, > - tpm_size_t initsize, > - const BYTE* initval); > - > -// Create a new buffer from a BYTE *. Use buffer_free to destroy original BYTE * > -TPM_RESULT buffer_init_convert (buffer_t * buf, > - tpm_size_t initsize, > - BYTE* initval); > - > -// make an alias to a constant array, no copying > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val); > - > -// make an alias into buf, with given offset and length > -// if len = 0, make the alias go to the end of buf > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > - tpm_size_t offset, tpm_size_t); > - > -// make an alias buffer into a bytestream > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, > - tpm_size_t size, BYTE* val); > - > -// "copy constructor" > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src); > - > - > -// copy into the start of a > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src); > - > -// are they equal? > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b); > - > -// set the buffer to a constant byte > -void buffer_memset (buffer_t * buf, BYTE b); > - > -tpm_size_t buffer_len (const buffer_t* buf); > - > -TPM_RESULT buffer_free (buffer_t * buf); > - > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes); > - > -#endif // _TOOLS_H_ > diff --git a/tools/vtpm_manager/util/hashtable.c b/tools/vtpm_manager/util/hashtable.c > deleted file mode 100644 > index aff0e2b..0000000 > --- a/tools/vtpm_manager/util/hashtable.c > +++ /dev/null > @@ -1,316 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable.c > - * - tools/blktap2/drivers/hashtable.c > - */ > - > -#include "hashtable.h" > -#include "hashtable_private.h" > -#include > -#include > -#include > -#include > - > -/* > -Credit for primes table: Aaron Krowne > - http://br.endernet.org/~akrowne/ > - http://planetmath.org/encyclopedia/GoodHashTablePrimes.html > -*/ > -static const unsigned int primes[] = { > -53, 97, 193, 389, > -769, 1543, 3079, 6151, > -12289, 24593, 49157, 98317, > -196613, 393241, 786433, 1572869, > -3145739, 6291469, 12582917, 25165843, > -50331653, 100663319, 201326611, 402653189, > -805306457, 1610612741 > -}; > -const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]); > -const float max_load_factor = 0.65; > - > -/*****************************************************************************/ > -struct hashtable * > -create_hashtable(unsigned int minsize, > - unsigned int (*hashf) (void*), > - int (*eqf) (void*,void*)) > -{ > - struct hashtable *h; > - unsigned int pindex, size = primes[0]; > - /* Check requested hashtable isn't too large */ > - if (minsize > (1u << 30)) return NULL; > - /* Enforce size as prime */ > - for (pindex=0; pindex < prime_table_length; pindex++) { > - if (primes[pindex] > minsize) { size = primes[pindex]; break; } > - } > - h = (struct hashtable *)malloc(sizeof(struct hashtable)); > - if (NULL == h) return NULL; /*oom*/ > - h->table = (struct entry **)malloc(sizeof(struct entry*) * size); > - if (NULL == h->table) { free(h); return NULL; } /*oom*/ > - memset(h->table, 0, size * sizeof(struct entry *)); > - h->tablelength = size; > - h->primeindex = pindex; > - h->entrycount = 0; > - h->hashfn = hashf; > - h->eqfn = eqf; > - h->loadlimit = (unsigned int) ceil(size * max_load_factor); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_init(&h->mutex, NULL); > -#endif > - return h; > -} > - > -/*****************************************************************************/ > -unsigned int > -hash(struct hashtable *h, void *k) > -{ > - unsigned int i = h->hashfn(k); > - i += ~(i << 9); > - i ^= ((i >> 14) | (i << 18)); /* >>> */ > - i += (i << 4); > - i ^= ((i >> 10) | (i << 22)); /* >>> */ > - return i; > -} > - > -/*****************************************************************************/ > -static int > -hashtable_expand(struct hashtable *h) > -{ > - /* Double the size of the table to accomodate more entries */ > - struct entry **newtable; > - struct entry *e; > - struct entry **pE; > - unsigned int newsize, i, index; > - /* Check we're not hitting max capacity */ > - if (h->primeindex == (prime_table_length - 1)) return 0; > - newsize = primes[++(h->primeindex)]; > - > - newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize); > - if (NULL != newtable) > - { > - memset(newtable, 0, newsize * sizeof(struct entry *)); > - /* This algorithm is not 'stable'. ie. it reverses the list > - * when it transfers entries between the tables */ > - for (i = 0; i < h->tablelength; i++) { > - while (NULL != (e = h->table[i])) { > - h->table[i] = e->next; > - index = indexFor(newsize,e->h); > - e->next = newtable[index]; > - newtable[index] = e; > - } > - } > - free(h->table); > - h->table = newtable; > - } > - /* Plan B: realloc instead */ > - else > - { > - newtable = (struct entry **) > - realloc(h->table, newsize * sizeof(struct entry *)); > - if (NULL == newtable) { (h->primeindex)--; return 0; } > - h->table = newtable; > - memset(newtable[h->tablelength], 0, newsize - h->tablelength); > - for (i = 0; i < h->tablelength; i++) { > - for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) { > - index = indexFor(newsize,e->h); > - if (index == i) > - { > - pE = &(e->next); > - } > - else > - { > - *pE = e->next; > - e->next = newtable[index]; > - newtable[index] = e; > - } > - } > - } > - } > - h->tablelength = newsize; > - h->loadlimit = (unsigned int) ceil(newsize * max_load_factor); > - return -1; > -} > - > -/*****************************************************************************/ > -unsigned int > -hashtable_count(struct hashtable *h) > -{ > - unsigned int count; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - count = h->entrycount; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return count; > -} > - > -/*****************************************************************************/ > -int > -hashtable_insert(struct hashtable *h, void *k, void *v) > -{ > - /* This method allows duplicate keys - but they shouldn't be used */ > - unsigned int index; > - struct entry *e; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - if (++(h->entrycount) > h->loadlimit) > - { > - /* Ignore the return value. If expand fails, we should > - * still try cramming just this value into the existing table > - * -- we may not have memory for a larger table, but one more > - * element may be ok. Next time we insert, we'll try expanding again.*/ > - hashtable_expand(h); > - } > - e = (struct entry *)malloc(sizeof(struct entry)); > - if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ > - e->h = hash(h,k); > - index = indexFor(h->tablelength,e->h); > - e->k = k; > - e->v = v; > - e->next = h->table[index]; > - h->table[index] = e; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return -1; > -} > - > -/*****************************************************************************/ > -void * /* returns value associated with key */ > -hashtable_search(struct hashtable *h, void *k) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e; > - unsigned int hashvalue, index; > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hashvalue); > - e = h->table[index]; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) { > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return e->v; > - } > - e = e->next; > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return NULL; > -} > - > -/*****************************************************************************/ > -void * /* returns value associated with key */ > -hashtable_remove(struct hashtable *h, void *k) > -{ > - /* TODO: consider compacting the table when the load factor drops enough, > - * or provide a 'compact' method. */ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e; > - struct entry **pE; > - void *v; > - unsigned int hashvalue, index; > - > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hash(h,k)); > - pE = &(h->table[index]); > - e = *pE; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > - { > - *pE = e->next; > - h->entrycount--; > - v = e->v; > - freekey(e->k); > - free(e); > - return v; > - } > - pE = &(e->next); > - e = e->next; > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return NULL; > -} > - > -/*****************************************************************************/ > -/* destroy */ > -void > -hashtable_destroy(struct hashtable *h, int free_values) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - unsigned int i; > - struct entry *e, *f; > - struct entry **table = h->table; > - if (free_values) > - { > - for (i = 0; i < h->tablelength; i++) > - { > - e = table[i]; > - while (NULL != e) > - { f = e; e = e->next; freekey(f->k); free(f->v); free(f); } > - } > - } > - else > - { > - for (i = 0; i < h->tablelength; i++) > - { > - e = table[i]; > - while (NULL != e) > - { f = e; e = e->next; freekey(f->k); free(f); } > - } > - } > - free(h->table); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_destroy(&h->mutex); > -#endif > - free(h); > -} > diff --git a/tools/vtpm_manager/util/hashtable.h b/tools/vtpm_manager/util/hashtable.h > deleted file mode 100644 > index dedc60a..0000000 > --- a/tools/vtpm_manager/util/hashtable.h > +++ /dev/null > @@ -1,204 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable.h > - * - tools/blktap2/drivers/hashtable.h > - */ > - > -#ifndef __HASHTABLE_CWC22_H__ > -#define __HASHTABLE_CWC22_H__ > - > -struct hashtable; > - > -/* Example of use: > - * > - * struct hashtable *h; > - * struct some_key *k; > - * struct some_value *v; > - * > - * static unsigned int hash_from_key_fn( void *k ); > - * static int keys_equal_fn ( void *key1, void *key2 ); > - * > - * h = create_hashtable(16, hash_from_key_fn, keys_equal_fn); > - * k = (struct some_key *) malloc(sizeof(struct some_key)); > - * v = (struct some_value *) malloc(sizeof(struct some_value)); > - * > - * (initialise k and v to suitable values) > - * > - * if (! hashtable_insert(h,k,v) ) > - * { exit(-1); } > - * > - * if (NULL == (found = hashtable_search(h,k) )) > - * { printf("not found!"); } > - * > - * if (NULL == (found = hashtable_remove(h,k) )) > - * { printf("Not found\n"); } > - * > - */ > - > -/* Macros may be used to define type-safe(r) hashtable access functions, with > - * methods specialized to take known key and value types as parameters. > - * > - * Example: > - * > - * Insert this at the start of your file: > - * > - * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value); > - * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value); > - * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value); > - * > - * This defines the functions 'insert_some', 'search_some' and 'remove_some'. > - * These operate just like hashtable_insert etc., with the same parameters, > - * but their function signatures have 'struct some_key *' rather than > - * 'void *', and hence can generate compile time errors if your program is > - * supplying incorrect data as a key (and similarly for value). > - * > - * Note that the hash and key equality functions passed to create_hashtable > - * still take 'void *' parameters instead of 'some key *'. This shouldn't be > - * a difficult issue as they're only defined and passed once, and the other > - * functions will ensure that only valid keys are supplied to them. > - * > - * The cost for this checking is increased code size and runtime overhead > - * - if performance is important, it may be worth switching back to the > - * unsafe methods once your program has been debugged with the safe methods. > - * This just requires switching to some simple alternative defines - eg: > - * #define insert_some hashtable_insert > - * > - */ > - > -/***************************************************************************** > - * create_hashtable > - > - * @name create_hashtable > - * @param minsize minimum initial size of hashtable > - * @param hashfunction function for hashing keys > - * @param key_eq_fn function for determining key equality > - * @return newly created hashtable or NULL on failure > - */ > - > -struct hashtable * > -create_hashtable(unsigned int minsize, > - unsigned int (*hashfunction) (void*), > - int (*key_eq_fn) (void*,void*)); > - > -/***************************************************************************** > - * hashtable_insert > - > - * @name hashtable_insert > - * @param h the hashtable to insert into > - * @param k the key - hashtable claims ownership and will free on removal > - * @param v the value - does not claim ownership > - * @return non-zero for successful insertion > - * > - * This function will cause the table to expand if the insertion would take > - * the ratio of entries to table size over the maximum load factor. > - * > - * This function does not check for repeated insertions with a duplicate key. > - * The value returned when using a duplicate key is undefined -- when > - * the hashtable changes size, the order of retrieval of duplicate key > - * entries is reversed. > - * If in doubt, remove before insert. > - */ > - > -int > -hashtable_insert(struct hashtable *h, void *k, void *v); > - > -#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \ > -int fnname (struct hashtable *h, keytype *k, valuetype *v) \ > -{ \ > - return hashtable_insert(h,k,v); \ > -} > - > -/***************************************************************************** > - * hashtable_search > - > - * @name hashtable_search > - * @param h the hashtable to search > - * @param k the key to search for - does not claim ownership > - * @return the value associated with the key, or NULL if none found > - */ > - > -void * > -hashtable_search(struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \ > -valuetype * fnname (struct hashtable *h, keytype *k) \ > -{ \ > - return (valuetype *) (hashtable_search(h,k)); \ > -} > - > -/***************************************************************************** > - * hashtable_remove > - > - * @name hashtable_remove > - * @param h the hashtable to remove the item from > - * @param k the key to search for - does not claim ownership > - * @return the value associated with the key, or NULL if none found > - */ > - > -void * /* returns value */ > -hashtable_remove(struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \ > -valuetype * fnname (struct hashtable *h, keytype *k) \ > -{ \ > - return (valuetype *) (hashtable_remove(h,k)); \ > -} > - > - > -/***************************************************************************** > - * hashtable_count > - > - * @name hashtable_count > - * @param h the hashtable > - * @return the number of items stored in the hashtable > - */ > -unsigned int > -hashtable_count(struct hashtable *h); > - > - > -/***************************************************************************** > - * hashtable_destroy > - > - * @name hashtable_destroy > - * @param h the hashtable > - * @param free_values whether to call 'free' on the remaining values > - */ > - > -void > -hashtable_destroy(struct hashtable *h, int free_values); > - > -#endif /* __HASHTABLE_CWC22_H__ */ > diff --git a/tools/vtpm_manager/util/hashtable_itr.c b/tools/vtpm_manager/util/hashtable_itr.c > deleted file mode 100644 > index dcf42c8..0000000 > --- a/tools/vtpm_manager/util/hashtable_itr.c > +++ /dev/null > @@ -1,236 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/blktap2/drivers/hashtable_itr.c > - */ > - > -#include "hashtable.h" > -#include "hashtable_private.h" > -#include "hashtable_itr.h" > -#include /* defines NULL */ > - > -/*****************************************************************************/ > -/* hashtable_iterator - iterator constructor */ > - > -struct hashtable_itr * > -hashtable_iterator(struct hashtable *h) > -{ > - unsigned int i, tablelength; > - struct hashtable_itr *itr = (struct hashtable_itr *) > - malloc(sizeof(struct hashtable_itr)); > - if (NULL == itr) return NULL; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - itr->h = h; > - itr->e = NULL; > - itr->parent = NULL; > - tablelength = h->tablelength; > - itr->index = tablelength; > - if (0 == h->entrycount) { > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return itr; > - } > - > - for (i = 0; i < tablelength; i++) > - { > - if (NULL != h->table[i]) > - { > - itr->e = h->table[i]; > - itr->index = i; > - break; > - } > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return itr; > -} > - > -/*****************************************************************************/ > -/* key - return the key of the (key,value) pair at the current position */ > -/* value - return the value of the (key,value) pair at the current position */ > - > -void * > -hashtable_iterator_key(struct hashtable_itr *i) > -{ return i->e->k; } > - > -void * > -hashtable_iterator_value(struct hashtable_itr *i) > -{ return i->e->v; } > - > -/*****************************************************************************/ > -/* advance - advance the iterator to the next element > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_advance(struct hashtable_itr *itr) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&itr->h->mutex); > -#endif > - unsigned int j,tablelength; > - struct entry **table; > - struct entry *next; > - int ret; > - if (NULL == itr->e) { /* stupidity check */ > - ret = 0; > - goto egress; > - } > - > - next = itr->e->next; > - if (NULL != next) > - { > - itr->parent = itr->e; > - itr->e = next; > - ret = -1; > - goto egress; > - } > - > - tablelength = itr->h->tablelength; > - itr->parent = NULL; > - if (tablelength <= (j = ++(itr->index))) > - { > - itr->e = NULL; > - ret = 0; > - goto egress; > - } > - table = itr->h->table; > - while (NULL == (next = table[j])) > - { > - if (++j >= tablelength) > - { > - itr->index = tablelength; > - itr->e = NULL; > - ret = 0; > - goto egress; > - } > - } > - itr->index = j; > - itr->e = next; > - ret = -1; > - > - egress: > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&itr->h->mutex); > -#endif > - return ret; > -} > - > -/*****************************************************************************/ > -/* remove - remove the entry at the current iterator position > - * and advance the iterator, if there is a successive > - * element. > - * If you want the value, read it before you remove: > - * beware memory leaks if you don't. > - * Returns zero if end of iteration. */ > - > -int > -hashtable_iterator_remove(struct hashtable_itr *itr) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&itr->h->mutex); > -#endif > - struct entry *remember_e, *remember_parent; > - int ret; > - > - /* Do the removal */ > - if (NULL == (itr->parent)) > - { > - /* element is head of a chain */ > - itr->h->table[itr->index] = itr->e->next; > - } else { > - /* element is mid-chain */ > - itr->parent->next = itr->e->next; > - } > - /* itr->e is now outside the hashtable */ > - remember_e = itr->e; > - itr->h->entrycount--; > - freekey(remember_e->k); > - > - /* Advance the iterator, correcting the parent */ > - remember_parent = itr->parent; > - ret = hashtable_iterator_advance(itr); > - if (itr->parent == remember_e) { itr->parent = remember_parent; } > - free(remember_e); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&itr->h->mutex); > -#endif > - return ret; > -} > - > -/*****************************************************************************/ > -int /* returns zero if not found */ > -hashtable_iterator_search(struct hashtable_itr *itr, > - struct hashtable *h, void *k) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e, *parent; > - unsigned int hashvalue, index; > - int ret; > - > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hashvalue); > - > - e = h->table[index]; > - parent = NULL; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > - { > - itr->index = index; > - itr->e = e; > - itr->parent = parent; > - itr->h = h; > - ret= -1; > - goto egress; > - } > - parent = e; > - e = e->next; > - } > - ret = 0; > - > -egress: > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return ret; > -} > diff --git a/tools/vtpm_manager/util/hashtable_itr.h b/tools/vtpm_manager/util/hashtable_itr.h > deleted file mode 100644 > index 35654e0..0000000 > --- a/tools/vtpm_manager/util/hashtable_itr.h > +++ /dev/null > @@ -1,109 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/blktap2/drivers/hashtable_itr.h > - */ > - > - > -#ifndef __HASHTABLE_ITR_CWC22__ > -#define __HASHTABLE_ITR_CWC22__ > -#include "hashtable.h" > -#include "hashtable_private.h" /* needed to enable inlining */ > - > -/*****************************************************************************/ > -/* This struct is only concrete here to allow the inlining of two of the > - * accessor functions. */ > -struct hashtable_itr > -{ > - struct hashtable *h; > - struct entry *e; > - struct entry *parent; > - unsigned int index; > -}; > - > - > -/*****************************************************************************/ > -/* hashtable_iterator > - */ > - > -struct hashtable_itr * > -hashtable_iterator(struct hashtable *h); > - > -/*****************************************************************************/ > -/* hashtable_iterator_key > - * - return the value of the (key,value) pair at the current position */ > - > -void *hashtable_iterator_key(struct hashtable_itr *i); > - > -/*****************************************************************************/ > -/* value - return the value of the (key,value) pair at the current position */ > - > -void *hashtable_iterator_value(struct hashtable_itr *i); > - > -/*****************************************************************************/ > -/* advance - advance the iterator to the next element > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_advance(struct hashtable_itr *itr); > - > -/*****************************************************************************/ > -/* remove - remove current element and advance the iterator to the next element > - * NB: if you need the value to free it, read it before > - * removing. ie: beware memory leaks! > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_remove(struct hashtable_itr *itr); > - > -/*****************************************************************************/ > -/* search - overwrite the supplied iterator, to point to the entry > - * matching the supplied key. > - h points to the hashtable to be searched. > - * returns zero if not found. */ > -int > -hashtable_iterator_search(struct hashtable_itr *itr, > - struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \ > -int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \ > -{ \ > - return (hashtable_iterator_search(i,h,k)); \ > -} > - > - > - > -#endif /* __HASHTABLE_ITR_CWC22__*/ > diff --git a/tools/vtpm_manager/util/hashtable_private.h b/tools/vtpm_manager/util/hashtable_private.h > deleted file mode 100644 > index d87a7f9..0000000 > --- a/tools/vtpm_manager/util/hashtable_private.h > +++ /dev/null > @@ -1,96 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable_private.h > - * - tools/blktap2/drivers/hashtable_private.h > - */ > - > -#ifndef __HASHTABLE_PRIVATE_CWC22_H__ > -#define __HASHTABLE_PRIVATE_CWC22_H__ > - > -#include "hashtable.h" > -#ifdef HASHTABLE_THREADED > -#include > -#endif > - > -/*****************************************************************************/ > -struct entry > -{ > - void *k, *v; > - unsigned int h; > - struct entry *next; > -}; > - > -struct hashtable { > - unsigned int tablelength; > - struct entry **table; > - unsigned int entrycount; > - unsigned int loadlimit; > - unsigned int primeindex; > - unsigned int (*hashfn) (void *k); > - int (*eqfn) (void *k1, void *k2); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_t mutex; > -#endif > -}; > - > -/*****************************************************************************/ > -unsigned int > -hash(struct hashtable *h, void *k); > - > -/*****************************************************************************/ > -/* indexFor */ > -static inline unsigned int > -indexFor(unsigned int tablelength, unsigned int hashvalue) { > - return (hashvalue % tablelength); > -}; > - > -/* Only works if tablelength == 2^N */ > -/*static inline unsigned int > -indexFor(unsigned int tablelength, unsigned int hashvalue) > -{ > - return (hashvalue & (tablelength - 1u)); > -} > -*/ > - > -/*****************************************************************************/ > -#define freekey(X) free(X) > -/*define freekey(X) ; */ > - > - > -/*****************************************************************************/ > - > -#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/ > diff --git a/tools/vtpm_manager/util/log.c b/tools/vtpm_manager/util/log.c > deleted file mode 100644 > index 75fe91a..0000000 > --- a/tools/vtpm_manager/util/log.c > +++ /dev/null > @@ -1,142 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > - > -#include "buffer.h" > -#include "tcg.h" > - > -// Helper code for the consts, eg. to produce messages for error codes. > - > -typedef struct error_code_entry_t { > - TPM_RESULT code; > - char * code_name; > - char * msg; > -} error_code_entry_t; > - > -static const error_code_entry_t error_msgs [] = { > - { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, > - { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, > - { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, > - { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, > - { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, > - { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, > - { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, > - { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, > - { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, > - { TPM_FAIL, "TPM_FAIL", "The operation failed" }, > - { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, > - { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, > - { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, > - { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, > - { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, > - { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, > - { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, > - { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, > - { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, > - { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, > - { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, > - { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, > - { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, > - { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, > - { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, > - { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, > - { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, > - { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, > - { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, > - { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, > - { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, > - { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, > - { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, > - { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, > - { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, > - { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, > - { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, > - { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, > - { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, > - { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, > - { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, > - > - { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, > - { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, > - { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, > - { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, > - { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, > - { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, > - { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, > - { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, > - { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, > - { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, > - { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, > - { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, > - { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, > - { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, > - { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, > - { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, > - { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, > - { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, > - { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, > - { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, > - { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, > - { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, > - { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, > - { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, > - { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, > - { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, > - { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, > - { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, > - { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, > - { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, > - { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, > - { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, > - { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, > - { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, > - { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, > - { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, > - { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, > - { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, > -}; > - > - > -// helper function for the error codes: > -const char* tpm_get_error_name (TPM_RESULT code) { > - // just do a linear scan for now > - unsigned i; > - for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) > - if (code == error_msgs[i].code) > - return error_msgs[i].code_name; > - > - return("Unknown Error Code"); > -} > diff --git a/tools/vtpm_manager/util/log.h b/tools/vtpm_manager/util/log.h > deleted file mode 100644 > index 1f15f5b..0000000 > --- a/tools/vtpm_manager/util/log.h > +++ /dev/null > @@ -1,94 +0,0 @@ > -// =================================================================== > -// > -// 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_LOG_H__ > -#define __VTPM_LOG_H__ > - > -#include // for uint32_t > -#include // for pointer NULL > - > -// =========================== LOGGING ============================== > - > -// the logging module numbers > -#define VTPM_LOG_CRYPTO 1 > -#define VTPM_LOG_BSG 2 > -#define VTPM_LOG_TXDATA 3 > -#define VTPM_LOG_TCS 4 > -#define VTPM_LOG_TCS_DEEP 5 > -#define VTPM_LOG_VTSP 6 > -#define VTPM_LOG_VTPM 7 > -#define VTPM_LOG_VTPM_DEEP 8 > -#define VTPM_LOG_VTSP_DEEP 9 > - > -static char *module_names[] = { "", > - "CRYPTO", > - "BSG", > - "TXDATA", > - "TCS", > - "TCS", > - "VTSP", > - "VTPM", > - "VTPM", > - "VTSP" > - }; > - > -// Default to standard logging > -#ifndef LOGGING_MODULES > -#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)) > -#endif > - > -// bit-access macros > -#define BITMASK(idx) ( 1U << (idx) ) > -#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) > -#define SETBIT(num,idx) (num) |= BITMASK(idx) > -#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) > - > -#define vtpmloginfo(module, fmt, args...) \ > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ > - } > - > -#define vtpmloginfomore(module, fmt, args...) \ > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > - fprintf (stdout, fmt,##args); \ > - } > - > -#define vtpmlogerror(module, fmt, args...) \ > - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); > - > -//typedef UINT32 tpm_size_t; > - > -// helper function for the error codes: > -const char* tpm_get_error_name (TPM_RESULT code); > - > -#endif // _VTPM_LOG_H_ > diff --git a/tools/vtpm_manager/util/tcg.h b/tools/vtpm_manager/util/tcg.h > deleted file mode 100644 > index 5c42913..0000000 > --- a/tools/vtpm_manager/util/tcg.h > +++ /dev/null > @@ -1,503 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcg.h > -// > -// This file contains all the structure and type definitions > -// > -// ================================================================== > - > -#ifndef __TCG_H__ > -#define __TCG_H__ > - > -// This pragma is used to disallow structure padding > -#pragma pack(push, 1) > - > -// *************************** TYPEDEFS ********************************* > -typedef unsigned char BYTE; > -typedef unsigned char BOOL; > -typedef unsigned short UINT16; > -typedef unsigned int UINT32; > -typedef unsigned long long UINT64; > - > -typedef UINT32 TPM_RESULT; > -typedef UINT32 TPM_PCRINDEX; > -typedef UINT32 TPM_DIRINDEX; > -typedef UINT32 TPM_HANDLE; > -typedef TPM_HANDLE TPM_AUTHHANDLE; > -typedef TPM_HANDLE TCPA_HASHHANDLE; > -typedef TPM_HANDLE TCPA_HMACHANDLE; > -typedef TPM_HANDLE TCPA_ENCHANDLE; > -typedef TPM_HANDLE TPM_KEY_HANDLE; > -typedef TPM_HANDLE TCPA_ENTITYHANDLE; > -typedef UINT32 TPM_RESOURCE_TYPE; > -typedef UINT32 TPM_COMMAND_CODE; > -typedef UINT16 TPM_PROTOCOL_ID; > -typedef BYTE TPM_AUTH_DATA_USAGE; > -typedef UINT16 TPM_ENTITY_TYPE; > -typedef UINT32 TPM_ALGORITHM_ID; > -typedef UINT16 TPM_KEY_USAGE; > -typedef UINT16 TPM_STARTUP_TYPE; > -typedef UINT32 TPM_CAPABILITY_AREA; > -typedef UINT16 TPM_ENC_SCHEME; > -typedef UINT16 TPM_SIG_SCHEME; > -typedef UINT16 TPM_MIGRATE_SCHEME; > -typedef UINT16 TPM_PHYSICAL_PRESENCE; > -typedef UINT32 TPM_KEY_FLAGS; > - > -#define TPM_DIGEST_SIZE 20 // Don't change this > -typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; > -typedef TPM_AUTHDATA TPM_SECRET; > -typedef TPM_AUTHDATA TPM_ENCAUTH; > -typedef BYTE TPM_PAYLOAD_TYPE; > -typedef UINT16 TPM_TAG; > - > -// Data Types of the TCS > -typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session > -typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle > -typedef UINT32 TCS_KEY_HANDLE; // Basic key handle > - > -// ************************* STRUCTURES ********************************** > - > -typedef struct TPM_VERSION { > - BYTE major; > - BYTE minor; > - BYTE revMajor; > - BYTE revMinor; > -} TPM_VERSION; > - > -static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; > - > -typedef struct TPM_DIGEST { > - BYTE digest[TPM_DIGEST_SIZE]; > -} TPM_DIGEST; > - > -typedef TPM_DIGEST TPM_PCRVALUE; > -typedef TPM_DIGEST TPM_COMPOSITE_HASH; > -typedef TPM_DIGEST TPM_DIRVALUE; > -typedef TPM_DIGEST TPM_HMAC; > -typedef TPM_DIGEST TPM_CHOSENID_HASH; > - > -typedef struct TPM_NONCE { > - BYTE nonce[TPM_DIGEST_SIZE]; > -} TPM_NONCE; > - > -typedef struct TPM_KEY_PARMS { > - TPM_ALGORITHM_ID algorithmID; > - TPM_ENC_SCHEME encScheme; > - TPM_SIG_SCHEME sigScheme; > - UINT32 parmSize; > - BYTE* parms; > -} TPM_KEY_PARMS; > - > -typedef struct TPM_RSA_KEY_PARMS { > - UINT32 keyLength; > - UINT32 numPrimes; > - UINT32 exponentSize; > - BYTE* exponent; > -} TPM_RSA_KEY_PARMS; > - > -typedef struct TPM_STORE_PUBKEY { > - UINT32 keyLength; > - BYTE* key; > -} TPM_STORE_PUBKEY; > - > -typedef struct TPM_PUBKEY { > - TPM_KEY_PARMS algorithmParms; > - TPM_STORE_PUBKEY pubKey; > -} TPM_PUBKEY; > - > -typedef struct TPM_KEY { > - TPM_VERSION ver; > - TPM_KEY_USAGE keyUsage; > - TPM_KEY_FLAGS keyFlags; > - TPM_AUTH_DATA_USAGE authDataUsage; > - TPM_KEY_PARMS algorithmParms; > - UINT32 PCRInfoSize; > - BYTE* PCRInfo; // this should be a TPM_PCR_INFO, or NULL > - TPM_STORE_PUBKEY pubKey; > - UINT32 encDataSize; > - BYTE* encData; > -} TPM_KEY; > - > -typedef struct TPM_PCR_SELECTION { > - UINT16 sizeOfSelect; /// in bytes > - BYTE* pcrSelect; > -} TPM_PCR_SELECTION; > - > -typedef struct TPM_PCR_COMPOSITE { > - TPM_PCR_SELECTION select; > - UINT32 valueSize; > - TPM_PCRVALUE* pcrValue; > -} TPM_PCR_COMPOSITE; > - > - > -typedef struct TPM_PCR_INFO { > - TPM_PCR_SELECTION pcrSelection; > - TPM_COMPOSITE_HASH digestAtRelease; > - TPM_COMPOSITE_HASH digestAtCreation; > -} TPM_PCR_INFO; > - > - > -typedef struct TPM_BOUND_DATA { > - TPM_VERSION ver; > - TPM_PAYLOAD_TYPE payload; > - BYTE* payloadData; > -} TPM_BOUND_DATA; > - > -typedef struct TPM_STORED_DATA { > - TPM_VERSION ver; > - UINT32 sealInfoSize; > - BYTE* sealInfo; > - UINT32 encDataSize; > - BYTE* encData; > -} TPM_STORED_DATA; > - > -typedef struct TCS_AUTH { > - TCS_AUTHHANDLE AuthHandle; > - TPM_NONCE NonceOdd; // system > - TPM_NONCE NonceEven; // TPM > - BOOL fContinueAuthSession; > - TPM_AUTHDATA HMAC; > -} TCS_AUTH; > - > -// structures for dealing with sizes followed by buffers in all the > -// TCG structure. > -typedef struct pack_buf_t { > - UINT32 size; > - BYTE * data; > -} pack_buf_t; > - > -typedef struct pack_constbuf_t { > - UINT32 size; > - const BYTE* data; > -} pack_constbuf_t; > - > - > - > -// **************************** CONSTANTS ********************************* > - > -// BOOL values > -#define TRUE 0x01 > -#define FALSE 0x00 > - > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > - > -// > -// TPM_COMMAND_CODE values > -#define TPM_PROTECTED_ORDINAL 0x00000000UL > -#define TPM_UNPROTECTED_ORDINAL 0x80000000UL > -#define TPM_CONNECTION_ORDINAL 0x40000000UL > -#define TPM_VENDOR_ORDINAL 0x20000000UL > - > -#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) > -#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) > - > - > - > -// > -// TPM_RESULT values > -// > -// just put in the whole table from spec 1.2 > - > -#define TPM_BASE 0x0 // The start of TPM return codes > -#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands > -#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. > - > -#define TPM_SUCCESS TPM_BASE // Successful completion of the operation > -#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed > -#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect > -#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad > -#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. > -#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access > -#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated > -#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled > -#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled > -#define TPM_FAIL TPM_BASE + 9 // The operation failed > -#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent > -#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled > -#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid > -#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found > -#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme > -#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed > -#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted > -#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. > -#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set > -#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM > -#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner > -#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. > -#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short > -#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. > -#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. > -#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value > -#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. > -#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. > -#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. > -#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization > -#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid > -#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM > -#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. > -#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. > -#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. > -#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed > -#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed > -#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed > -#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup > -#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information > -#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM > - > -#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. > -#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. > -#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key > -#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. > -#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value > -#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability > -#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions > -#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also > -#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success > -#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute > -#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport > -#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed > -#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource > -#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode > -#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID > -#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available > -#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command > -#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key > -#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization > -#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable > -#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation > -#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to > -#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area > -#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match > -#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to > -#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict > -#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent > -#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. > -#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect > -#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area > -#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large > -#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded > -#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set > -#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded > -#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked > -#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family > -#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled > -#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session > - > -// TPM_STARTUP_TYPE values > -#define TPM_ST_CLEAR 0x0001 > -#define TPM_ST_STATE 0x0002 > -#define TPM_ST_DEACTIVATED 0x003 > - > -// TPM_TAG values > -#define TPM_TAG_RQU_COMMAND 0x00c1 > -#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 > -#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 > -#define TPM_TAG_RSP_COMMAND 0x00c4 > -#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 > -#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 > - > -// TPM_PAYLOAD_TYPE values > -#define TPM_PT_ASYM 0x01 > -#define TPM_PT_BIND 0x02 > -#define TPM_PT_MIGRATE 0x03 > -#define TPM_PT_MAINT 0x04 > -#define TPM_PT_SEAL 0x05 > - > -// TPM_ENTITY_TYPE values > -#define TPM_ET_KEYHANDLE 0x0001 > -#define TPM_ET_OWNER 0x0002 > -#define TPM_ET_DATA 0x0003 > -#define TPM_ET_SRK 0x0004 > -#define TPM_ET_KEY 0x0005 > - > -/// TPM_ResourceTypes > -#define TPM_RT_KEY 0x00000001 > -#define TPM_RT_AUTH 0x00000002 > -#define TPM_RT_TRANS 0x00000004 > -#define TPM_RT_CONTEXT 0x00000005 > - > -// TPM_PROTOCOL_ID values > -#define TPM_PID_OIAP 0x0001 > -#define TPM_PID_OSAP 0x0002 > -#define TPM_PID_ADIP 0x0003 > -#define TPM_PID_ADCP 0x0004 > -#define TPM_PID_OWNER 0x0005 > - > -// TPM_ALGORITHM_ID values > -#define TPM_ALG_RSA 0x00000001 > -#define TPM_ALG_DES 0x00000002 > -#define TPM_ALG_3DES 0X00000003 > -#define TPM_ALG_SHA 0x00000004 > -#define TPM_ALG_HMAC 0x00000005 > -#define TCPA_ALG_AES 0x00000006 > - > -// TPM_ENC_SCHEME values > -#define TPM_ES_NONE 0x0001 > -#define TPM_ES_RSAESPKCSv15 0x0002 > -#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 > - > -// TPM_SIG_SCHEME values > -#define TPM_SS_NONE 0x0001 > -#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 > -#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 > - > -// TPM_KEY_USAGE values > -#define TPM_KEY_EK 0x0000 > -#define TPM_KEY_SIGNING 0x0010 > -#define TPM_KEY_STORAGE 0x0011 > -#define TPM_KEY_IDENTITY 0x0012 > -#define TPM_KEY_AUTHCHANGE 0X0013 > -#define TPM_KEY_BIND 0x0014 > -#define TPM_KEY_LEGACY 0x0015 > - > -// TPM_AUTH_DATA_USAGE values > -#define TPM_AUTH_NEVER 0x00 > -#define TPM_AUTH_ALWAYS 0x01 > - > -// Key Handle of owner and srk > -#define TPM_OWNER_KEYHANDLE 0x40000001 > -#define TPM_SRK_KEYHANDLE 0x40000000 > - > -// ---------------------- Functions for checking TPM_RESULTs ----------------- > - > -#include > - > -// FIXME: Review use of these and delete unneeded ones. > - > -// these are really badly dependent on local structure: > -// DEPENDS: local var 'status' of type TPM_RESULT > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > -#define ERRORDIE(s) do { status = s; \ > - fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ > - goto abort_egress; } \ > - while (0) > - > -// DEPENDS: local var 'status' of type TPM_RESULT > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > -// Try command c. If it fails, set status to s and goto abort. > -#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ > - status = s; \ > - printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > - goto abort_egress; \ > - } else {\ > - status = c; \ > - } > - > -// Try command c. If it fails, print error message, set status to actual return code. Goto abort > -#define TPMTRYRETURN(c) do { status = c; \ > - if (status != TPM_SUCCESS) { \ > - fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > - goto abort_egress; \ > - } \ > - } while(0) > - > - > -#pragma pack(pop) > - > -#endif //__TCPA_H__ > diff --git a/tools/xenstore/hashtable.c b/tools/xenstore/hashtable.c > index 3b89223..0ba1d55 100644 > --- a/tools/xenstore/hashtable.c > +++ b/tools/xenstore/hashtable.c > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable.c > - * - tools/vtpm_manager/util/hashtable.c > */ > > #include "hashtable.h" > diff --git a/tools/xenstore/hashtable.h b/tools/xenstore/hashtable.h > index 8e6bb5b..4d68223 100644 > --- a/tools/xenstore/hashtable.h > +++ b/tools/xenstore/hashtable.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable.h > - * - tools/vtpm_manager/util/hashtable.h > */ > > #ifndef __HASHTABLE_CWC22_H__ > diff --git a/tools/xenstore/hashtable_private.h b/tools/xenstore/hashtable_private.h > index cabaffe..a08559d 100644 > --- a/tools/xenstore/hashtable_private.h > +++ b/tools/xenstore/hashtable_private.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable_private.h > - * - tools/vtpm_manager/util/hashtable_private.h > */ > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > diff --git a/tools/xm-test/configure.ac b/tools/xm-test/configure.ac > index ad1eb78..c142140 100644 > --- a/tools/xm-test/configure.ac > +++ b/tools/xm-test/configure.ac > @@ -143,7 +143,6 @@ AC_CONFIG_FILES([ > tests/unpause/Makefile > tests/vcpu-pin/Makefile > tests/vcpu-disable/Makefile > - tests/vtpm/Makefile > tests/xapi/Makefile > tests/enforce_dom0_cpus/Makefile > tests/cpupool/Makefile > diff --git a/tools/xm-test/grouptest/default b/tools/xm-test/grouptest/default > index f0516b2..e04591b 100644 > --- a/tools/xm-test/grouptest/default > +++ b/tools/xm-test/grouptest/default > @@ -27,5 +27,4 @@ sysrq > unpause > vcpu-disable > vcpu-pin > -vtpm > xapi > diff --git a/tools/xm-test/grouptest/medium b/tools/xm-test/grouptest/medium > index bafc988..5c3e1b1 100644 > --- a/tools/xm-test/grouptest/medium > +++ b/tools/xm-test/grouptest/medium > @@ -22,4 +22,3 @@ sysrq 01_sysrq_basic_neg.test 02_sysrq_sync_pos.test > unpause > vcpu-disable > vcpu-pin > -vtpm > diff --git a/tools/xm-test/grouptest/xapi b/tools/xm-test/grouptest/xapi > index 3b04921..7a08b77 100644 > --- a/tools/xm-test/grouptest/xapi > +++ b/tools/xm-test/grouptest/xapi > @@ -1,2 +1 @@ > xapi > -vtpm 09_vtpm-xapi.test > diff --git a/tools/xm-test/lib/XmTestLib/XenDomain.py b/tools/xm-test/lib/XmTestLib/XenDomain.py > index ae8c550..3ba7433 100644 > --- a/tools/xm-test/lib/XmTestLib/XenDomain.py > +++ b/tools/xm-test/lib/XmTestLib/XenDomain.py > @@ -59,7 +59,6 @@ class XenConfig: > # These options need to be lists > self.defaultOpts["disk"] = [] > self.defaultOpts["vif"] = [] > - self.defaultOpts["vtpm"] = [] > > self.opts = self.defaultOpts > > diff --git a/tools/xm-test/tests/Makefile.am b/tools/xm-test/tests/Makefile.am > index 8d673ed..455f50c 100644 > --- a/tools/xm-test/tests/Makefile.am > +++ b/tools/xm-test/tests/Makefile.am > @@ -25,7 +25,6 @@ SUBDIRS = \ > unpause \ > vcpu-disable \ > vcpu-pin \ > - vtpm \ > enforce_dom0_cpus \ > save restore migrate \ > cpupool > diff --git a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py b/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > deleted file mode 100644 > index dfd1227..0000000 > --- a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > +++ /dev/null > @@ -1,40 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# verify list > - > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > - > -try: > - domain.start(noConsole=True) > -except DomainError, e: > - if verbose: > - print e.extra > - vtpm_cleanup(domain.getName()) > - FAIL("Unable to create domain") > - > - > -domName = domain.getName() > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -status, output = traceCommand("xm vtpm-list %s" % domain.getId()) > -eyecatcher = "/local/domain/0/backend/vtpm" > -where = output.find(eyecatcher) > -if status != 0: > - FAIL("xm vtpm-list returned bad status, expected 0, status is %i" % status) > -elif where < 0: > - FAIL("Fail to list virtual TPM device") > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py b/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > deleted file mode 100644 > index a18cbab..0000000 > --- a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > +++ /dev/null > @@ -1,49 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -domain.closeConsole() > - > -domain.stop() > - > -if not re.search("PCR-00:",run["output"]): > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > diff --git a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py b/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > deleted file mode 100644 > index b863f27..0000000 > --- a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > +++ /dev/null > @@ -1,99 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; suspend and resume the domain and > -# check list of pcrs again > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm save %s %s.save" % > - (domName, domName), > - timeout=30) > - > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm save did not succeed") > - > - try: > - status, ouptut = traceCommand("xm restore %s.save" % > - (domName), > - timeout=30) > - except TimeoutError, e: > - os.remove("%s.save" % domName) > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - os.remove("%s.save" % domName) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm restore did not succeed") > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > - > diff --git a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > deleted file mode 100644 > index ccc8b73..0000000 > --- a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > +++ /dev/null > @@ -1,93 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again > -# This test does local live migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > deleted file mode 100644 > index 57b87df..0000000 > --- a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > +++ /dev/null > @@ -1,93 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again > -# This test does local (non-live) migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py b/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > deleted file mode 100644 > index c70691d..0000000 > --- a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > +++ /dev/null > @@ -1,125 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; suspend and resume the domain and > -# check list of pcrs again and validate extended pcr > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm save %s %s.save" % > - (domName, domName), > - timeout=30) > - > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm save did not succeed") > - > - try: > - status, ouptut = traceCommand("xm restore %s.save" % > - (domName), > - timeout=30) > - except TimeoutError, e: > - os.remove("%s.save" % domName) > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - os.remove("%s.save" % domName) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm restore did not succeed") > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > - > diff --git a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > deleted file mode 100644 > index 4ff3360..0000000 > --- a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > +++ /dev/null > @@ -1,119 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again and validate extended pcr > -# This test does local live migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > deleted file mode 100644 > index 27125fc..0000000 > --- a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > +++ /dev/null > @@ -1,119 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again and validate extended pcr > -# This test does local (non-live) migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py b/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > deleted file mode 100644 > index a1aa8b3..0000000 > --- a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > +++ /dev/null > @@ -1,158 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Test to test the vtpm class through the Xen-API > -# > -# Tested methods: > -# VTPM: get_uuid, get_backend, get_by_uuid, get_record > -# create, destroy, get_VM > -# VM: get_VTPMS > - > -from XmTestLib import xapi > -from XmTestLib.XenAPIDomain import XmTestAPIDomain > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > - > -VTPM_RECORD_KEYS = [ 'backend', 'VM', 'uuid', 'other_config' ] > - > -try: > - # XmTestAPIDomain tries to establish a connection to XenD > - domain = XmTestAPIDomain() > -except Exception, e: > - SKIP("Skipping test. Error: %s" % str(e)) > -vm_uuid = domain.get_uuid() > - > -vtpmcfg = {} > -vtpmcfg['backend'] = DOM0_UUID > -vtpmcfg['VM'] = vm_uuid > - > -session = xapi.connect() > - > -vtpm_uuid = session.xenapi.VTPM.create(vtpmcfg) > - > -vtpm_be = session.xenapi.VTPM.get_backend(vtpm_uuid) > -if vtpm_be != vtpmcfg['backend']: > - FAIL("vTPM's backend is in '%s', expected: '%s'" % > - (vtpm_be, vtpmcfg['backend'])) > - > -vtpm_rec = session.xenapi.VTPM.get_record(vtpm_uuid) > - > -miss_keys = [] > -for k in VTPM_RECORD_KEYS: > - if k not in vtpm_rec.keys(): > - miss_keys.append(k) > -if len(miss_keys) > 0: > - FAIL("vTPM record is missing key(s): %s" % miss_keys) > - > -if vtpm_rec['uuid'] != vtpm_uuid: > - FAIL("vTPM record shows vtpm uuid '%s', expected: '%s'" % > - (vtpm_rec['uuid'], vtpm_uuid)) > -if vtpm_rec['VM'] != vm_uuid: > - FAIL("vTPM record shows VM uuid '%s', expected: '%s'" % > - (vtpm_rec['VM'], vm_uuid)) > -if vtpm_rec['backend'] != vtpmcfg['backend']: > - FAIL("vTPM record shows VM bakcned '%s', expected: '%s'" % > - (vtpm_rev['backend'], vtpmcfg['backend'])) > - > -badkeys = [] > -keys = vtpm_rec.keys() > -for k in keys: > - if k not in VTPM_RECORD_KEYS: > - badkeys.append(k) > -if len(badkeys) > 0: > - FAIL("Unexpected attributes in result: %s" % badkeys) > - > -if vm_uuid != session.xenapi.VTPM.get_VM(vtpm_uuid): > - FAIL("VM uuid from VTPM.get_VM different (%s) than expected (%s)." % > - (vm_ref, vm_uuid)) > - > -uuid = session.xenapi.VTPM.get_uuid(vtpm_uuid) > -if uuid != vtpm_uuid: > - FAIL("vTPM from VTPM.get_uuid different (%s) than expected (%s)." % > - (uuid, vtpm_uuid)) > - > -vtpm_ref = session.xenapi.VTPM.get_by_uuid(vtpm_uuid) > -if vtpm_ref != vtpm_uuid: > - FAIL("vTPM from VTPM.get_by_uuid different (%s) than expected (%s)." % > - (vtpm_ref, vtpm_uuid)) > - > -vm_vtpms = session.xenapi.VM.get_VTPMs(vm_uuid) > -if len(vm_vtpms) != 1: > - FAIL("Number of vTPMs from get_VTPMs is (%d) not what was expected (%d)" % > - (len(vm_vtpms), 1)) > -if vtpm_uuid not in vm_vtpms: > - FAIL("Other vTPM uuid (%s) returned from VM.get_VTPMs than expected (%s)" % > - (vm_vtpms[0], vtpm_uuid)) > - > -try: > - console = domain.start() > -except DomainError, e: > - FAIL("Unable to create domain.") > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("1. No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("1. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > - #Should never get here > - FAIL("Could destroy vTPM while VM is running") > -except: > - pass > - > -rc = session.xenapi.VM.suspend(vm_uuid) > -if rc: > - FAIL("Could not suspend VM") > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > - #May not throw an exception in 'suspend' state > -except: > - pass > - > -rc = session.xenapi.VM.resume(vm_uuid, False) > -if rc: > - FAIL("Could not resume VM") > - > -try: > - console = domain.getConsole() > -except ConsoleError, e: > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("2. No result from dumping the PCRs. vTPM has been removed?") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("2. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -domain.stop() > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > -except: > - FAIL("Could NOT destroy vTPM while domain is halted.") > - > -domain.destroy() > diff --git a/tools/xm-test/tests/vtpm/Makefile.am b/tools/xm-test/tests/vtpm/Makefile.am > deleted file mode 100644 > index dd67e45..0000000 > --- a/tools/xm-test/tests/vtpm/Makefile.am > +++ /dev/null > @@ -1,27 +0,0 @@ > -SUBDIRS = > - > -TESTS = 01_vtpm-list_pos.test \ > - 02_vtpm-cat_pcrs.test \ > - 03_vtpm-susp_res.test \ > - 04_vtpm-loc_migr.test \ > - 05_vtpm-loc_migr.test \ > - 06_vtpm-susp_res_pcrs.test \ > - 07_vtpm-mig_pcrs.test \ > - 08_vtpm-mig_pcrs.test \ > - 09_vtpm-xapi.test > - > -XFAIL_TESTS = > - > -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS) vtpm_utils.py > -TESTS_ENVIRONMENT=@TENV@ > - > -%.test: %.py > - cp $< $@ > - chmod +x $@ > - > -clean-local: am_config_clean-local > - > -am_config_clean-local: > - rm -f *test > - rm -f *log > - rm -f *~ > diff --git a/tools/xm-test/tests/vtpm/vtpm_utils.py b/tools/xm-test/tests/vtpm/vtpm_utils.py > deleted file mode 100644 > index 4e5b281..0000000 > --- a/tools/xm-test/tests/vtpm/vtpm_utils.py > +++ /dev/null > @@ -1,30 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -from XmTestLib import * > - > -if ENABLE_HVM_SUPPORT: > - SKIP("vtpm tests not supported for HVM domains") > - > -status, output = traceCommand("COLUMNS=200 ; " > - "ps aux | grep vtpm_manager | grep -v grep") > -if output == "": > - SKIP("virtual TPM manager must be started to run this test; might " > - "need /dev/tpm0") > - > -def vtpm_cleanup(domName): > - traceCommand("/etc/xen/scripts/vtpm-delete " > - "`xenstore-read /local/domain/0/backend/vtpm/%s/0/uuid`" % > - str(domid(domName))) > - > -def vtpm_cleanup(uuid): > - from xen.xm import main > - if main.serverType != main.SERVER_XEN_API: > - traceCommand("/etc/xen/scripts/vtpm-delete %s" % uuid) > - > -def vtpm_get_uuid(domainid): > - s, o = traceCommand("xenstore-read " > - "/local/domain/0/backend/vtpm/%s/0/uuid" % domainid) > - return o > -- > 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 Nov 13 15:05:49 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 13 Nov 2012 15:05:49 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYI3O-0006O2-FS; Tue, 13 Nov 2012 15:05:30 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYI1i-0006FD-LG for xen-devel@lists.xen.org; Tue, 13 Nov 2012 15:03:52 +0000 Received: from [85.158.137.99:17630] by server-10.bemta-3.messagelabs.com id 20/74-19806-15162A05; Tue, 13 Nov 2012 15:03:45 +0000 X-Env-Sender: Ian.Campbell@citrix.com X-Msg-Ref: server-8.tower-217.messagelabs.com!1352819022!12090297!1 X-Originating-IP: [62.200.22.115] X-SpamReason: No, hits=0.0 required=7.0 tests=Mail larger than max spam size X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 10352 invoked from network); 13 Nov 2012 15:03:43 -0000 Received: from smtp.eu.citrix.com (HELO SMTP.EU.CITRIX.COM) (62.200.22.115) by server-8.tower-217.messagelabs.com with RC4-SHA encrypted SMTP; 13 Nov 2012 15:03:43 -0000 X-IronPort-AV: E=Sophos;i="4.80,767,1344211200"; d="scan'208";a="15781742" Received: from lonpmailmx01.citrite.net ([10.30.203.162]) by LONPIPO01.EU.CITRIX.COM with ESMTP/TLS/RC4-MD5; 13 Nov 2012 15:03:39 +0000 Received: from [10.80.2.42] (10.80.2.42) by LONPMAILMX01.citrite.net (10.30.203.162) with Microsoft SMTP Server id 8.3.279.1; Tue, 13 Nov 2012 15:03:38 +0000 Message-ID: <1352819016.7491.84.camel@zakaz.uk.xensource.com> From: Ian Campbell To: "Fioravante, Matthew E." Date: Tue, 13 Nov 2012 15:03:36 +0000 In-Reply-To: <068F06DC4D106941B297C0C5F9F446EA48A229F471@aplesstripe.dom1.jhuapl.edu> References: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> <1352803755.7491.47.camel@zakaz.uk.xensource.com> <068F06DC4D106941B297C0C5F9F446EA48A229F471@aplesstripe.dom1.jhuapl.edu> Organization: Citrix Systems, Inc. X-Mailer: Evolution 3.4.3-1 MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 13 Nov 2012 15:05:28 +0000 Cc: Stefano Stabellini , "xen-devel@lists.xen.org" Subject: Re: [Xen-devel] [PATCH VTPM 6/9] Remove the vtpm process model 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, 2012-11-13 at 14:58 +0000, Fioravante, Matthew E. wrote: > Should I have removed vtpm from xm also? I left it alone because xm is depcrecated. Is xend broken by this change when not using the vtpm features? Or just some functionality (which never worked right) went away? I'm happy to leave xend alone so long as it works as well as it ever did for people not using vtpm. > > -----Original Message----- > From: Ian Campbell [mailto:Ian.Campbell@citrix.com] > Sent: Tuesday, November 13, 2012 5:49 AM > To: Fioravante, Matthew E. > Cc: xen-devel@lists.xen.org; Stefano Stabellini > Subject: Re: [PATCH VTPM 6/9] Remove the vtpm process model > > On Thu, 2012-11-01 at 20:35 +0000, Matthew Fioravante wrote: > > Remove the old vtpm process model. It doesn't work very > > well and is no longer supported. > > > > Signed-off-by: Matthew Fioravante > > Acked-by: Ian Campbell > > > > > diff --git a/tools/Makefile b/tools/Makefile > > index d8c8cc0..2ca43b9 100644 > > --- a/tools/Makefile > > +++ b/tools/Makefile > > @@ -18,8 +18,6 @@ SUBDIRS-$(CONFIG_XCUTILS) += xcutils > > SUBDIRS-$(CONFIG_X86) += firmware > > SUBDIRS-y += console > > SUBDIRS-y += xenmon > > -SUBDIRS-$(VTPM_TOOLS) += vtpm_manager > > -SUBDIRS-$(VTPM_TOOLS) += vtpm > > SUBDIRS-y += xenstat > > SUBDIRS-$(CONFIG_Linux) += $(SUBDIRS-libaio) > > SUBDIRS-$(CONFIG_Linux) += memshr > > diff --git a/tools/blktap2/drivers/hashtable.c b/tools/blktap2/drivers/hashtable.c > > index 631306b..90a6b85 100644 > > --- a/tools/blktap2/drivers/hashtable.c > > +++ b/tools/blktap2/drivers/hashtable.c > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/xenstore/hashtable.c > > - * - tools/vtpm_manager/util/hashtable.c > > */ > > > > #include "hashtable.h" > > diff --git a/tools/blktap2/drivers/hashtable.h b/tools/blktap2/drivers/hashtable.h > > index 89aa3dc..56ca053 100644 > > --- a/tools/blktap2/drivers/hashtable.h > > +++ b/tools/blktap2/drivers/hashtable.h > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/xenstore/hashtable.h > > - * - tools/vtpm_manager/util/hashtable.h > > */ > > > > #ifndef __HASHTABLE_CWC22_H__ > > diff --git a/tools/blktap2/drivers/hashtable_itr.c b/tools/blktap2/drivers/hashtable_itr.c > > index 402e06b..731917c 100644 > > --- a/tools/blktap2/drivers/hashtable_itr.c > > +++ b/tools/blktap2/drivers/hashtable_itr.c > > @@ -1,10 +1,5 @@ > > /* Copyright (C) 2002, 2004 Christopher Clark */ > > > > -/* > > - * There are duplicates of this code in: > > - * - tools/vtpm_manager/util/hashtable_itr.c > > - */ > > - > > #include "hashtable.h" > > #include "hashtable_private.h" > > #include "hashtable_itr.h" > > diff --git a/tools/blktap2/drivers/hashtable_itr.h b/tools/blktap2/drivers/hashtable_itr.h > > index 3d80638..81da838 100644 > > --- a/tools/blktap2/drivers/hashtable_itr.h > > +++ b/tools/blktap2/drivers/hashtable_itr.h > > @@ -1,10 +1,5 @@ > > /* Copyright (C) 2002, 2004 Christopher Clark */ > > > > -/* > > - * There are duplicates of this code in: > > - * - tools/vtpm_manager/util/hashtable_itr.h > > - */ > > - > > #ifndef __HASHTABLE_ITR_CWC22__ > > #define __HASHTABLE_ITR_CWC22__ > > #include "hashtable.h" > > diff --git a/tools/blktap2/drivers/hashtable_private.h b/tools/blktap2/drivers/hashtable_private.h > > index 5a13a65..954ecc3 100644 > > --- a/tools/blktap2/drivers/hashtable_private.h > > +++ b/tools/blktap2/drivers/hashtable_private.h > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/xenstore/hashtable_private.h > > - * - tools/vtpm_manager/util/hashtable_private.h > > */ > > > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > > diff --git a/tools/configure.ac b/tools/configure.ac > > index e708f01..586313d 100644 > > --- a/tools/configure.ac > > +++ b/tools/configure.ac > > @@ -40,7 +40,6 @@ m4_include([m4/fetcher.m4]) > > # Enable/disable options > > AX_ARG_DEFAULT_DISABLE([githttp], [Download GIT repositories via HTTP]) > > AX_ARG_DEFAULT_ENABLE([monitors], [Disable xenstat and xentop monitoring tools]) > > -AX_ARG_DEFAULT_DISABLE([vtpm], [Enable Virtual Trusted Platform Module]) > > AX_ARG_DEFAULT_DISABLE([xenapi], [Enable Xen API Bindings]) > > AX_ARG_DEFAULT_ENABLE([ocamltools], [Disable Ocaml tools]) > > AX_ARG_DEFAULT_DISABLE([miniterm], [Enable miniterm]) > > diff --git a/tools/examples/README b/tools/examples/README > > index 5b0314e..2225d5c 100644 > > --- a/tools/examples/README > > +++ b/tools/examples/README > > @@ -25,13 +25,7 @@ vif-bridge - virtual network start/stop script in bridged mode > > vif-common.sh - sourced by vif-bridge > > vif-nat - xen virtual network start/stop script in NAT mode > > vif-route - xen virtual network start/stop script in routed mode > > -vtpm - called by xen-backend.agent to bind/unbind vTPM devices > > -vtpm-common.sh - common code for vTPM handling > > -vtpm-delete - remove an entry from the vTPM table given the > > - domain's name > > -vtpm-hotplug-common.sh - sourced by vtpm > > -vtpm-migration.sh - sourced by external-device-migrate > > -xen-backend.agent - calls block, vif-*, vtpm scripts to add, remove, hotplug > > +xen-backend.agent - calls block, vif-* scripts to add, remove, hotplug > > devices > > xen-backend.rules - hotplug script rules > > xend-config.sxp - default xend configuration file > > diff --git a/tools/examples/xmexample.pv-grub b/tools/examples/xmexample.pv-grub > > index 85f847c..e04e6c1 100644 > > --- a/tools/examples/xmexample.pv-grub > > +++ b/tools/examples/xmexample.pv-grub > > @@ -105,20 +105,6 @@ disk = [ 'phy:hda1,hda1,w' ] > > # configured in xend-config.sxp. > > > > #---------------------------------------------------------------------------- > > -# Define to which TPM instance the user domain should communicate. > > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > > -# where INSTANCE indicates the instance number of the TPM the VM > > -# should be talking to and DOM provides the domain where the backend > > -# is located. > > -# Note that no two virtual machines should try to connect to the same > > -# TPM instance. The handling of all TPM instances does require > > -# some management effort in so far that VM configration files (and thus > > -# a VM) should be associated with a TPM instance throughout the lifetime > > -# of the VM / VM configuration file. The instance number must be > > -# greater or equal to 1. > > -#vtpm = [ 'instance=1,backend=0' ] > > - > > -#---------------------------------------------------------------------------- > > # Configure the behaviour when a domain exits. There are three 'reasons' > > # for a domain to stop: poweroff, reboot, and crash. For each of these you > > # may specify: > > diff --git a/tools/examples/xmexample1 b/tools/examples/xmexample1 > > index 330aaf0..c951200 100644 > > --- a/tools/examples/xmexample1 > > +++ b/tools/examples/xmexample1 > > @@ -101,20 +101,6 @@ disk = [ 'phy:hda1,hda1,w' ] > > # configured in xend-config.sxp. > > > > #---------------------------------------------------------------------------- > > -# Define to which TPM instance the user domain should communicate. > > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > > -# where INSTANCE indicates the instance number of the TPM the VM > > -# should be talking to and DOM provides the domain where the backend > > -# is located. > > -# Note that no two virtual machines should try to connect to the same > > -# TPM instance. The handling of all TPM instances does require > > -# some management effort in so far that VM configration files (and thus > > -# a VM) should be associated with a TPM instance throughout the lifetime > > -# of the VM / VM configuration file. The instance number must be > > -# greater or equal to 1. > > -#vtpm = [ 'instance=1,backend=0' ] > > - > > -#---------------------------------------------------------------------------- > > # Set the kernel command line for the new domain. > > # You only need to define the IP parameters and hostname if the domain's > > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > > diff --git a/tools/examples/xmexample2 b/tools/examples/xmexample2 > > index 4e5eb3d..8c5137e 100644 > > --- a/tools/examples/xmexample2 > > +++ b/tools/examples/xmexample2 > > @@ -137,20 +137,6 @@ disk = [ 'phy:sda%d,sda1,w' % (7+vmid), > > # configured in xend-config.sxp. > > > > #---------------------------------------------------------------------------- > > -# Define to which TPM instance the user domain should communicate. > > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > > -# where INSTANCE indicates the instance number of the TPM the VM > > -# should be talking to and DOM provides the domain where the backend > > -# is located. > > -# Note that no two virtual machines should try to connect to the same > > -# TPM instance. The handling of all TPM instances does require > > -# some management effort in so far that VM configration files (and thus > > -# a VM) should be associated with a TPM instance throughout the lifetime > > -# of the VM / VM configuration file. The instance number must be > > -# greater or equal to 1. > > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > > - > > -#---------------------------------------------------------------------------- > > # Set the kernel command line for the new domain. > > # You only need to define the IP parameters and hostname if the domain's > > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > > diff --git a/tools/examples/xmexample3 b/tools/examples/xmexample3 > > index dc22ce1..ae799f9 100644 > > --- a/tools/examples/xmexample3 > > +++ b/tools/examples/xmexample3 > > @@ -122,20 +122,6 @@ disk = [ 'phy:hda%d,hda1,w' % (vmid)] > > # configured in xend-config.sxp. > > > > #---------------------------------------------------------------------------- > > -# Define to which TPM instance the user domain should communicate. > > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > > -# where INSTANCE indicates the instance number of the TPM the VM > > -# should be talking to and DOM provides the domain where the backend > > -# is located. > > -# Note that no two virtual machines should try to connect to the same > > -# TPM instance. The handling of all TPM instances does require > > -# some management effort in so far that VM configration files (and thus > > -# a VM) should be associated with a TPM instance throughout the lifetime > > -# of the VM / VM configuration file. The instance number must be > > -# greater or equal to 1. > > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > > - > > -#---------------------------------------------------------------------------- > > # Set the kernel command line for the new domain. > > # You only need to define the IP parameters and hostname if the domain's > > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > > diff --git a/tools/hotplug/Linux/Makefile b/tools/hotplug/Linux/Makefile > > index 0166790..0605559 100644 > > --- a/tools/hotplug/Linux/Makefile > > +++ b/tools/hotplug/Linux/Makefile > > @@ -18,14 +18,12 @@ XEN_SCRIPTS += vif-setup > > XEN_SCRIPTS += block > > XEN_SCRIPTS += block-enbd block-nbd > > XEN_SCRIPTS += blktap > > -XEN_SCRIPTS += vtpm vtpm-delete > > XEN_SCRIPTS += xen-hotplug-cleanup > > XEN_SCRIPTS += external-device-migrate > > XEN_SCRIPTS += vscsi > > XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh > > XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh > > -XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh vtpm-hotplug-common.sh > > -XEN_SCRIPT_DATA += vtpm-migration.sh vtpm-impl > > +XEN_SCRIPT_DATA += block-common.sh > > > > UDEV_RULES_DIR = $(CONFIG_DIR)/udev > > UDEV_RULES = xen-backend.rules xend.rules > > diff --git a/tools/hotplug/Linux/vtpm b/tools/hotplug/Linux/vtpm > > deleted file mode 100644 > > index 38a4532..0000000 > > --- a/tools/hotplug/Linux/vtpm > > +++ /dev/null > > @@ -1,22 +0,0 @@ > > -#!/bin/bash > > - > > -dir=$(dirname "$0") > > -. "$dir/vtpm-hotplug-common.sh" > > - > > -vtpm_fatal_error=0 > > - > > -case "$command" in > > - add) > > - vtpm_create_instance > > - ;; > > - remove) > > - vtpm_remove_instance > > - ;; > > -esac > > - > > -if [ $vtpm_fatal_error -eq 0 ]; then > > - log debug "Successful vTPM operation '$command'." > > - success > > -else > > - fatal "Error while executing vTPM operation '$command'." > > -fi > > diff --git a/tools/hotplug/Linux/vtpm-common.sh b/tools/hotplug/Linux/vtpm-common.sh > > deleted file mode 100644 > > index d0d7935..0000000 > > --- a/tools/hotplug/Linux/vtpm-common.sh > > +++ /dev/null > > @@ -1,448 +0,0 @@ > > -# > > -# Copyright (c) 2005 IBM Corporation > > -# Copyright (c) 2005 XenSource Ltd. > > -# > > -# This library is free software; you can redistribute it and/or > > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > > -# License as published by the Free Software Foundation. > > -# > > -# This library is distributed in the hope that it will be useful, > > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > -# Lesser General Public License for more details. > > -# > > -# You should have received a copy of the GNU Lesser General Public > > -# License along with this library; if not, write to the Free Software > > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > > -# > > - > > -dir=$(dirname "$0") > > -. "$dir/logging.sh" > > -. "$dir/locking.sh" > > - > > -VTPMDB="/var/vtpm/vtpm.db" > > - > > -#In the vtpm-impl file some commands should be defined: > > -# vtpm_create, vtpm_setup, vtpm_start, etc. (see below) > > -if [ -r "$dir/vtpm-impl.alt" ]; then > > - . "$dir/vtpm-impl.alt" > > -elif [ -r "$dir/vtpm-impl" ]; then > > - . "$dir/vtpm-impl" > > -else > > - function vtpm_create () { > > - true > > - } > > - function vtpm_setup() { > > - true > > - } > > - function vtpm_start() { > > - true > > - } > > - function vtpm_suspend() { > > - true > > - } > > - function vtpm_resume() { > > - true > > - } > > - function vtpm_delete() { > > - true > > - } > > - function vtpm_migrate() { > > - echo "Error: vTPM migration accross machines not implemented." > > - } > > - function vtpm_migrate_local() { > > - echo "Error: local vTPM migration not supported" > > - } > > - function vtpm_migrate_recover() { > > - true > > - } > > -fi > > - > > - > > -#Find the instance number for the vtpm given the name of the domain > > -# Parameters > > -# - vmname : the name of the vm > > -# Return value > > -# Returns '0' if instance number could not be found, otherwise > > -# it returns the instance number in the variable 'instance' > > -function vtpmdb_find_instance () { > > - local vmname ret instance > > - vmname=$1 > > - ret=0 > > - > > - instance=$(cat $VTPMDB | \ > > - awk -vvmname=$vmname \ > > - '{ \ > > - if ( 1 != index($1,"#")) { \ > > - if ( $1 == vmname ) { \ > > - print $2; \ > > - exit; \ > > - } \ > > - } \ > > - }') > > - if [ "$instance" != "" ]; then > > - ret=$instance > > - fi > > - echo "$ret" > > -} > > - > > - > > -# Check whether a particular instance number is still available > > -# returns "0" if it is not available, "1" otherwise. > > -function vtpmdb_is_free_instancenum () { > > - local instance instances avail i > > - instance=$1 > > - avail=1 > > - #Allowed instance number range: 1-255 > > - if [ $instance -eq 0 -o $instance -gt 255 ]; then > > - avail=0 > > - else > > - instances=$(cat $VTPMDB | \ > > - awk \ > > - '{ \ > > - if (1 != index($1,"#")) { \ > > - printf("%s ",$2); \ > > - } \ > > - }') > > - for i in $instances; do > > - if [ $i -eq $instance ]; then > > - avail=0 > > - break > > - fi > > - done > > - fi > > - echo "$avail" > > -} > > - > > - > > -# Get an available instance number given the database > > -# Returns an unused instance number > > -function vtpmdb_get_free_instancenum () { > > - local ctr instances don found > > - instances=$(cat $VTPMDB | \ > > - awk \ > > - '{ \ > > - if (1 != index($1,"#")) { \ > > - printf("%s ",$2); \ > > - } \ > > - }') > > - ctr=1 > > - don=0 > > - while [ $don -eq 0 ]; do > > - found=0 > > - for i in $instances; do > > - if [ $i -eq $ctr ]; then > > - found=1; > > - break; > > - fi > > - done > > - > > - if [ $found -eq 0 ]; then > > - don=1 > > - break > > - fi > > - let ctr=ctr+1 > > - done > > - echo "$ctr" > > -} > > - > > - > > -# Add a domain name and instance number to the DB file > > -function vtpmdb_add_instance () { > > - local res vmname inst > > - vmname=$1 > > - inst=$2 > > - > > - if [ ! -f $VTPMDB ]; then > > - echo "#Database for VM to vTPM association" > $VTPMDB > > - echo "#1st column: domain name" >> $VTPMDB > > - echo "#2nd column: TPM instance number" >> $VTPMDB > > - fi > > - res=$(vtpmdb_validate_entry $vmname $inst) > > - if [ $res -eq 0 ]; then > > - echo "$vmname $inst" >> $VTPMDB > > - fi > > -} > > - > > - > > -#Validate whether an entry is the same as passed to this > > -#function > > -function vtpmdb_validate_entry () { > > - local res rc vmname inst > > - rc=0 > > - vmname=$1 > > - inst=$2 > > - > > - res=$(cat $VTPMDB | \ > > - awk -vvmname=$vmname \ > > - -vinst=$inst \ > > - '{ \ > > - if ( 1 == index($1,"#")) {\ > > - } else \ > > - if ( $1 == vmname && \ > > - $2 == inst) { \ > > - printf("1"); \ > > - exit; \ > > - } else \ > > - if ( $1 == vmname || \ > > - $2 == inst) { \ > > - printf("2"); \ > > - exit; \ > > - } \ > > - }') > > - > > - if [ "$res" == "1" ]; then > > - rc=1 > > - elif [ "$res" == "2" ]; then > > - rc=2 > > - fi > > - echo "$rc" > > -} > > - > > - > > -#Remove an entry from the vTPM database given its domain name > > -#and instance number > > -function vtpmdb_remove_entry () { > > - local vmname instance VTPMDB_TMP > > - vmname=$1 > > - instance=$2 > > - VTPMDB_TMP="$VTPMDB".tmp > > - > > - $(cat $VTPMDB | \ > > - awk -vvmname=$vmname \ > > - '{ \ > > - if ( $1 != vmname ) { \ > > - print $0; \ > > - } \ > > - '} > $VTPMDB_TMP) > > - if [ -e $VTPMDB_TMP ]; then > > - mv -f $VTPMDB_TMP $VTPMDB > > - vtpm_delete $instance > > - else > > - log err "Error creating temporary file '$VTPMDB_TMP'." > > - fi > > -} > > - > > - > > -# Find the reason for the creation of this device: > > -# Returns 'resume' or 'create' > > -function vtpm_get_create_reason () { > > - local resume > > - resume=$(xenstore_read $XENBUS_PATH/resume) > > - if [ "$resume" == "True" ]; then > > - echo "resume" > > - else > > - echo "create" > > - fi > > -} > > - > > - > > -#Create a vTPM instance > > -# If no entry in the TPM database is found, the instance is > > -# created and an entry added to the database. > > -function vtpm_create_instance () { > > - local res instance domname reason uuid > > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > > - reason=$(vtpm_get_create_reason) > > - > > - claim_lock vtpmdb > > - > > - instance="0" > > - > > - if [ "$uuid" != "" ]; then > > - instance=$(vtpmdb_find_instance $uuid) > > - fi > > - if [ "$instance" == "0" ]; then > > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > > - instance=$(vtpmdb_find_instance $domname) > > - fi > > - > > - if [ "$instance" == "0" -a "$reason" != "create" ]; then > > - release_lock vtpmdb > > - return > > - fi > > - > > - if [ "$instance" == "0" ]; then > > - #Try to give the preferred instance to the domain > > - instance=$(xenstore_read "$XENBUS_PATH"/pref_instance) > > - if [ "$instance" != "" ]; then > > - res=$(vtpmdb_is_free_instancenum $instance) > > - if [ $res -eq 0 ]; then > > - instance=$(vtpmdb_get_free_instancenum) > > - fi > > - else > > - instance=$(vtpmdb_get_free_instancenum) > > - fi > > - > > - vtpm_create $instance > > - > > - if [ $vtpm_fatal_error -eq 0 ]; then > > - if [ "$uuid" != "" ]; then > > - vtpmdb_add_instance $uuid $instance > > - else > > - vtpmdb_add_instance $domname $instance > > - fi > > - fi > > - else > > - if [ "$reason" == "resume" ]; then > > - vtpm_resume $instance > > - else > > - vtpm_start $instance > > - fi > > - fi > > - > > - release_lock vtpmdb > > - > > - xenstore_write $XENBUS_PATH/instance $instance > > -} > > - > > - > > -#Remove an instance when a VM is terminating or suspending. > > -#Since it is assumed that the VM will appear again, the > > -#entry is kept in the VTPMDB file. > > -function vtpm_remove_instance () { > > - local instance reason domname uuid > > - #Stop script execution quietly if path does not exist (anymore) > > - xenstore-exists "$XENBUS_PATH"/domain > > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > > - > > - claim_lock vtpmdb > > - > > - instance="0" > > - > > - if [ "$uuid" != "" ]; then > > - instance=$(vtpmdb_find_instance $uuid) > > - fi > > - > > - if [ "$instance" == "0" ]; then > > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > > - instance=$(vtpmdb_find_instance $domname) > > - fi > > - > > - if [ "$instance" != "0" ]; then > > - vtpm_suspend $instance > > - fi > > - > > - release_lock vtpmdb > > -} > > - > > - > > -#Remove an entry in the VTPMDB file given the domain's name > > -#1st parameter: The name of the domain > > -function vtpm_delete_instance () { > > - local instance > > - > > - claim_lock vtpmdb > > - > > - instance=$(vtpmdb_find_instance $1) > > - if [ "$instance" != "0" ]; then > > - vtpmdb_remove_entry $1 $instance > > - fi > > - > > - release_lock vtpmdb > > -} > > - > > -# Determine whether the given address is local to this machine > > -# Return values: > > -# "-1" : the given machine name is invalid > > -# "0" : this is not an address of this machine > > -# "1" : this is an address local to this machine > > -function vtpm_isLocalAddress() { > > - local addr res > > - addr=$(ping $1 -c 1 | \ > > - awk '{ print substr($3,2,length($3)-2); exit }') > > - if [ "$addr" == "" ]; then > > - echo "-1" > > - return > > - fi > > - res=$(ifconfig | grep "inet addr" | \ > > - awk -vaddr=$addr \ > > - '{ \ > > - if ( addr == substr($2, 6)) {\ > > - print "1"; \ > > - } \ > > - }' \ > > - ) > > - if [ "$res" == "" ]; then > > - echo "0" > > - return > > - fi > > - echo "1" > > -} > > - > > -# Perform a migration step. This function differentiates between migration > > -# to the local host or to a remote machine. > > -# Parameters: > > -# 1st: destination host to migrate to > > -# 2nd: name of the domain to migrate > > -# 3rd: the migration step to perform > > -function vtpm_migration_step() { > > - local res=$(vtpm_isLocalAddress $1) > > - if [ "$res" == "0" ]; then > > - vtpm_migrate $1 $2 $3 > > - else > > - vtpm_migrate_local > > - fi > > -} > > - > > -# Recover from migration due to an error. This function differentiates > > -# between migration to the local host or to a remote machine. > > -# Parameters: > > -# 1st: destination host the migration was going to > > -# 2nd: name of the domain that was to be migrated > > -# 3rd: the last successful migration step that was done > > -function vtpm_recover() { > > - local res > > - res=$(vtpm_isLocalAddress $1) > > - if [ "$res" == "0" ]; then > > - vtpm_migrate_recover $1 $2 $3 > > - fi > > -} > > - > > - > > -#Determine the domain id given a domain's name. > > -#1st parameter: name of the domain > > -#return value: domain id or -1 if domain id could not be determined > > -function vtpm_domid_from_name () { > > - local id name ids > > - ids=$(xenstore-list /local/domain) > > - for id in $ids; do > > - name=$(xenstore-read /local/domain/$id/name) > > - if [ "$name" == "$1" ]; then > > - echo "$id" > > - return > > - fi > > - done > > - echo "-1" > > -} > > - > > -#Determine the virtual TPM's instance number using the domain ID. > > -#1st parm: domain ID > > -function vtpm_uuid_by_domid() { > > - echo $(xenstore-read /local/domain/0/backend/vtpm/$1/0/uuid) > > -} > > - > > - > > -# Determine the vTPM's UUID by the name of the VM > > -function vtpm_uuid_from_vmname() { > > - local domid=$(vtpm_domid_from_name $1) > > - if [ "$domid" != "-1" ]; then > > - echo $(vtpm_uuid_by_domid $domid) > > - return > > - fi > > - echo "" > > -} > > - > > -#Add a virtual TPM instance number and its associated domain name > > -#to the VTPMDB file and activate usage of this virtual TPM instance > > -#by writing the instance number into the xenstore > > -#1st parm: name of virtual machine > > -#2nd parm: instance of associated virtual TPM > > -function vtpm_add_and_activate() { > > - local domid=$(vtpm_domid_from_name $1) > > - local vtpm_uuid=$(vtpm_uuid_from_vmname $1) > > - if [ "$vtpm_uuid" != "" -a "$domid" != "-1" ]; then > > - vtpmdb_add_instance $vtpm_uuid $2 > > - xenstore-write backend/vtpm/$domid/0/instance $2 > > - fi > > -} > > diff --git a/tools/hotplug/Linux/vtpm-delete b/tools/hotplug/Linux/vtpm-delete > > deleted file mode 100644 > > index b75b95b..0000000 > > --- a/tools/hotplug/Linux/vtpm-delete > > +++ /dev/null > > @@ -1,18 +0,0 @@ > > -#!/bin/bash > > - > > -# This scripts must be called the following way: > > -# vtpm-delete > > -# or > > -# vtpm-delete --vmname > > - > > -dir=$(dirname "$0") > > -. "$dir/vtpm-common.sh" > > - > > -if [ "$1" == "--vmname" ]; then > > - vtpm_uuid=$(vtpm_uuid_from_vmname $2) > > - if [ "$vtpm_uuid" != "" ];then > > - vtpm_delete_instance $vtpm_uuid > > - fi > > -else > > - vtpm_delete_instance $1 > > -fi > > diff --git a/tools/hotplug/Linux/vtpm-hotplug-common.sh b/tools/hotplug/Linux/vtpm-hotplug-common.sh > > deleted file mode 100644 > > index 9fd35e7..0000000 > > --- a/tools/hotplug/Linux/vtpm-hotplug-common.sh > > +++ /dev/null > > @@ -1,35 +0,0 @@ > > -# > > -# Copyright (c) 2005 IBM Corporation > > -# Copyright (c) 2005 XenSource Ltd. > > -# > > -# This library is free software; you can redistribute it and/or > > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > > -# License as published by the Free Software Foundation. > > -# > > -# This library is distributed in the hope that it will be useful, > > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > -# Lesser General Public License for more details. > > -# > > -# You should have received a copy of the GNU Lesser General Public > > -# License along with this library; if not, write to the Free Software > > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > > -# > > - > > -dir=$(dirname "$0") > > -. "$dir/xen-hotplug-common.sh" > > - > > -findCommand "$@" > > -if [ "$command" != "online" ] && > > - [ "$command" != "offline" ] && > > - [ "$command" != "add" ] && > > - [ "$command" != "remove" ] > > -then > > - log err "Invalid command: $command" > > - exit 1 > > -fi > > - > > - > > -XENBUS_PATH="${XENBUS_PATH:?}" > > - > > -. "$dir/vtpm-common.sh" > > diff --git a/tools/hotplug/Linux/vtpm-impl b/tools/hotplug/Linux/vtpm-impl > > deleted file mode 100644 > > index 4f9a1fd..0000000 > > --- a/tools/hotplug/Linux/vtpm-impl > > +++ /dev/null > > @@ -1,208 +0,0 @@ > > -#!/bin/bash > > -# =================================================================== > > -# > > -# 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. > > -# =================================================================== > > - > > -# | SRC | TAG | CMD SIZE | ORD |mtype|strt > > -TPM_CMD_OPEN=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x01 > > -TPM_CMD_RESM=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x02 > > -TPM_CMD_CLOS=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x02 > > -TPM_CMD_DELE=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x03 > > - > > -TPM_TYPE_PVM=\\x01 > > -TPM_TYPE_HVM=\\x02 > > - > > -TPM_SUCCESS=00000000 > > - > > -TX_VTPM_MANAGER=/var/vtpm/fifos/from_console.fifo > > -RX_VTPM_MANAGER=/var/vtpm/fifos/to_console.fifo > > - > > -VTPM_MIG=/usr/bin/vtpm_migrator > > - > > -# -------------------- Helpers for binary streams ----------- > > - > > -function str_to_hex32() { > > - printf "%0.8x" $1 > > -} > > - > > -function hex32_to_bin() { > > - local inst=$(str_to_hex32 $1); > > - > > - local n1=`echo $inst | sed 's/\(..\)....../\\\\x\1/'` > > - local n2=`echo $inst | sed 's/..\(..\)..../\\\\x\1/'` > > - local n3=`echo $inst | sed 's/....\(..\)../\\\\x\1/'` > > - local n4=`echo $inst | sed 's/......\(..\)/\\\\x\1/'` > > - > > - echo "$n1$n2$n3$n4" > > -} > > - > > -function vtpm_manager_cmd() { > > - local cmd=$1; > > - local inst=$2; > > - local inst_bin=$(hex32_to_bin $inst); > > - > > - claim_lock vtpm_mgr > > - > > - #send cmd to vtpm_manager > > - printf "$cmd$inst_bin" > $TX_VTPM_MANAGER > > - > > - #recv response > > - set +e > > - local resp_hex=`dd skip=10 bs=1 count=4 if=$RX_VTPM_MANAGER 2> /dev/null | xxd -ps` > > - set -e > > - > > - release_lock vtpm_mgr > > - > > - #return whether the command was successful > > - if [ $resp_hex -ne $TPM_SUCCESS ]; then > > - vtpm_fatal_error=1 > > - false > > - else > > - true > > - fi > > -} > > - > > -# Helper to get vm type to pass to vtpm_manager open/resume > > -function vtpm_get_type() { > > - local inst=$(xenstore_read $XENBUS_PATH/frontend-id) > > - local vm=$(xenstore_read /local/domain/$inst/vm) > > - if [ "$vm" != "" ]; then > > - local ostype=$(xenstore-read $vm/image/ostype) > > - if [ "$ostype" == "hvm" ]; then > > - echo $TPM_TYPE_HVM; > > - else > > - echo $TPM_TYPE_PVM; > > - fi > > - fi > > -} > > - > > -# ------------------ Command handlers ----------------- > > - > > -# Create new vtpm instance & set it up for use > > -function vtpm_create () { > > - # Creation is handled implicitly by the manager on first setup > > - # so just set it up for use > > - $(vtpm_start $1) > > -} > > - > > -# Setup vtpm instance for use. > > -function vtpm_start() { > > - local vmtype=$(vtpm_get_type); > > - $(vtpm_manager_cmd $TPM_CMD_OPEN$vmtype $1) > > -} > > - > > -function vtpm_resume() { > > - local vmtype=$(vtpm_get_type); > > - $(vtpm_manager_cmd $TPM_CMD_RESM$vmtype $1) > > -} > > - > > -# Reset the vtpm AKA clear PCRs > > -function vtpm_reset() { > > - #not used by current implemenation > > - true > > -} > > - > > -# Shutdown the vtpm while the vm is down > > -# This could be a suspend of shutdown > > -# we cannot distinquish, so save the state > > -# and decide on startup if we should keep is > > -function vtpm_suspend() { > > - $(vtpm_manager_cmd $TPM_CMD_CLOS $1) > > -} > > - > > - > > -function vtpm_delete() { > > - local inst=$1 > > - if $(vtpm_manager_cmd $TPM_CMD_DELE $inst); then > > - rm -f /var/vtpm/vtpm_dm_$1.data > > - true > > - else > > - vtpm_fatal_error=1 > > - false > > - fi > > -} > > - > > -# Perform a migration step. This function differentiates between migration > > -# to the local host or to a remote machine. > > -# Parameters: > > -# 1st: destination host to migrate to > > -# 2nd: name of the domain to migrate > > -# 3rd: the migration step to perform > > -function vtpm_migrate() { > > - local instance res > > - > > - instance=$(vtpmdb_find_instance $2) > > - if [ "$instance" == "" ]; then > > - log err "VTPM Migratoin failed. Unable to translation of domain name" > > - echo "Error: VTPM Migration failed while looking up instance number" > > - fi > > - > > - case "$3" in > > - 0) > > - #Incicate migration supported > > - echo "0" > > - ;; > > - > > - 1) > > - # Get Public Key from Destination > > - # Call vtpm_manager's migration part 1 > > - claim_lock vtpm_mgr > > - $VTPM_MIG $1 $2 $instance $3 > > - release_lock vtpm_mgr > > - ;; > > - > > - 2) > > - # Call manager's migration step 2 and send result to destination > > - # If successful remove from db > > - claim_lock vtpm_mgr > > - $VTPM_MIG $1 $2 $instance $3 > > - release_lock vtpm_mgr > > - ;; > > - > > - 3) > > - if `ps x | grep "$VTPM_MIG $1"`; then > > - log err "VTPM Migration failed to complete." > > - echo "Error: VTPM Migration failed to complete." > > - fi > > - ;; > > - esac > > - > > -} > > - > > - > > -function vtpm_migrate_recover() { > > - echo "Error: Recovery not supported yet" > > -} > > - > > -function vtpm_migrate_local() { > > - echo "Error: local vTPM migration not supported" > > -} > > diff --git a/tools/hotplug/Linux/vtpm-migration.sh b/tools/hotplug/Linux/vtpm-migration.sh > > deleted file mode 100644 > > index 7e38ae2..0000000 > > --- a/tools/hotplug/Linux/vtpm-migration.sh > > +++ /dev/null > > @@ -1,19 +0,0 @@ > > -# > > -# Copyright (c) 2005 IBM Corporation > > -# > > -# This library is free software; you can redistribute it and/or > > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > > -# License as published by the Free Software Foundation. > > -# > > -# This library is distributed in the hope that it will be useful, > > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > -# Lesser General Public License for more details. > > -# > > -# You should have received a copy of the GNU Lesser General Public > > -# License along with this library; if not, write to the Free Software > > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > > -# > > - > > -dir=$(dirname "$0") > > -. "$dir/vtpm-common.sh" > > diff --git a/tools/hotplug/Linux/xen-backend.rules b/tools/hotplug/Linux/xen-backend.rules > > index c591a3f..a0d409e 100644 > > --- a/tools/hotplug/Linux/xen-backend.rules > > +++ b/tools/hotplug/Linux/xen-backend.rules > > @@ -1,6 +1,5 @@ > > SUBSYSTEM=="xen-backend", KERNEL=="tap*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/blktap $env{ACTION}" > > SUBSYSTEM=="xen-backend", KERNEL=="vbd*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/block $env{ACTION}" > > -SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}" > > SUBSYSTEM=="xen-backend", KERNEL=="vif2-*", RUN+="/etc/xen/scripts/vif2 $env{ACTION}" > > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="online", RUN+="/etc/xen/scripts/vif-setup online type_if=vif" > > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="offline", RUN+="/etc/xen/scripts/vif-setup offline type_if=vif" > > diff --git a/tools/vtpm/Makefile b/tools/vtpm/Makefile > > deleted file mode 100644 > > index 7b3efa5..0000000 > > --- a/tools/vtpm/Makefile > > +++ /dev/null > > @@ -1,74 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../.. > > - > > -# Base definitions and rules > > -include $(XEN_ROOT)/tools/vtpm/Rules.mk > > - > > -# Dir name for emulator (as dom0 tpm driver) > > -TPM_EMULATOR_DIR = tpm_emulator > > -# Dir name for vtpm instance > > -VTPM_DIR = vtpm > > -ORIG_DIR = orig > > - > > -# Emulator tarball name > > -TPM_EMULATOR_NAME = tpm_emulator-0.5.1 > > -TPM_EMULATOR_TARFILE = $(TPM_EMULATOR_NAME).tar.gz > > - > > -GMP_HEADER = /usr/include/gmp.h > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: build_sub > > - > > -.PHONY: install > > -install: build > > - $(MAKE) -C $(VTPM_DIR) install-recursive > > - > > -.PHONY: clean > > -clean: > > - @if [ -d $(TPM_EMULATOR_DIR) ]; \ > > - then $(MAKE) -C $(TPM_EMULATOR_DIR) clean; \ > > - fi > > - @if [ -d $(VTPM_DIR) ]; \ > > - then $(MAKE) -C $(VTPM_DIR) clean; \ > > - fi > > - > > -.PHONY: mrproper > > -mrproper: > > - rm -f $(TPM_EMULATOR_TARFILE) tpm_emulator.patch.old vtpm.patch.old > > - rm -rf $(TPM_EMULATOR_DIR) $(VTPM_DIR) $(ORIG_DIR) > > - > > -# Download Swiss emulator > > -$(TPM_EMULATOR_TARFILE): > > - wget http://download.berlios.de/tpm-emulator/$(TPM_EMULATOR_TARFILE) > > - > > -# Create vtpm dirs > > -$(VTPM_DIR)/tpmd/tpmd: $(TPM_EMULATOR_TARFILE) vtpm-0.5.1.patch > > - rm -rf $(VTPM_DIR) > > - tar -xzf $(TPM_EMULATOR_TARFILE) > > - mv $(TPM_EMULATOR_NAME) $(VTPM_DIR) > > - > > - set -e; cd $(VTPM_DIR); \ > > - patch -p1 < ../vtpm-0.5.1.patch; \ > > - patch -p1 < ../vtpm-0.5.1-LDLIBS.patch > > - > > -orig: $(TPM_EMULATOR_TARFILE) > > - mkdir $(ORIG_DIR); > > - set -e; cd $(ORIG_DIR); \ > > - tar -xzf ../$(TPM_EMULATOR_TARFILE); > > - > > -updatepatches: clean orig > > - find $(VTPM_DIR) -name "*.orig" -print | xargs rm -f; > > - mv vtpm.patch vtpm.patch.old; > > - diff -uprN $(TPM_EMULATOR_DIR) $(VTPM_DIR) > vtpm.patch || true; > > - > > -.PHONY: build_sub > > -build_sub: $(VTPM_DIR)/tpmd/tpmd > > - set -e; if [ -e $(GMP_HEADER) ]; then \ > > - $(MAKE) -C $(VTPM_DIR) version; \ > > - $(MAKE) -C $(VTPM_DIR) all-recursive; \ > > - else \ > > - echo "=== Unable to build VTPMs. libgmp could not be found."; \ > > - fi > > - > > diff --git a/tools/vtpm/README b/tools/vtpm/README > > deleted file mode 100644 > > index 2008cbd..0000000 > > --- a/tools/vtpm/README > > +++ /dev/null > > @@ -1,45 +0,0 @@ > > - > > -Directory Structure > > -=================== > > -tools/vtpm/tpm_emulator-0.2b.tar.gz -> TPM Emulator downloaded at build time that will > > - be patched and used for our vtpms > > -tools/vtpm/vtpm.patch -> patch applied to tpm_emulator to make vtpm > > -tools/vtpm/vtpm/ -> (created on build) tpm_emulator moved to ring 3, > > - listens on a pair of fifos for TPM commands, > > - persistent state is sent via named fifo to vtpm > > - manager, which encrypts it and protects it. > > -tools/vtpm/tpm_emulator.patch -> To allow for debugging and testing on non-TPM > > - platforms, this patches the emulator to allow > > - it to be inserted into the dom0 kernel > > -tools/vtpm/tpm_emulator-0.2 -> (created on build) directory containing patched emulator > > - > > -Compile Flags > > -=================== > > -VTPM_MULTI_VM -> Defined (not finished): VTPMs run in their own VMs > > - Not Defined (default): VTPMs are processes > > - > > -Requirements > > -============ > > -- xen-unstable > > -- IBM frontend/backend vtpm driver patch > > -- vtpm_managerd > > -- GNU MP Big number library (GMP) > > - > > -vtpmd Flow (for vtpm_manager. vtpmd never run by default) > > -============================ > > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > > -- VTPM Manager listens to TPM BE. > > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > > -- When the manager receives the open message from the BE, it launches a vtpm > > -- Xend allows the VM to continue booting. > > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > > -- The fifo listener begins listening for the reply from vtpm for the request. > > -- Vtpm processes request and replies to manager over shared named fifo. > > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > > - > > -tpm_emulator flow > > -================== > > -Read documentation in tpm_emulator-0.2 directory > > diff --git a/tools/vtpm/Rules.mk b/tools/vtpm/Rules.mk > > deleted file mode 100644 > > index 548cff0..0000000 > > --- a/tools/vtpm/Rules.mk > > +++ /dev/null > > @@ -1,26 +0,0 @@ > > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > > -include $(XEN_ROOT)/tools/Rules.mk > > - > > -# > > -# Tool definitions > > -# > > - > > -# General compiler flags > > -CFLAGS = -Werror -g3 > > - > > -# Generic project files > > -HDRS = $(wildcard *.h) > > -SRCS = $(wildcard *.c) > > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > > - > > -# Generic (non-header) dependencies > > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm/Rules.mk > > - > > -$(OBJS): $(SRCS) > > - > > --include $(DEPS) > > - > > -BUILD_EMULATOR = y > > - > > -# Make sure these are just rules > > -.PHONY : all build install clean > > diff --git a/tools/vtpm/tpm_emulator.patch b/tools/vtpm/tpm_emulator.patch > > deleted file mode 100644 > > index c34c665..0000000 > > --- a/tools/vtpm/tpm_emulator.patch > > +++ /dev/null > > @@ -1,1919 +0,0 @@ > > -diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS > > ---- orig/tpm_emulator-0.4/AUTHORS 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/AUTHORS 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,2 +1,3 @@ > > - Mario Strasser > > - Heiko Stamer [DAA] > > -+INTEL Corp <> [Dropped to Ring3] > > -diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog > > ---- orig/tpm_emulator-0.4/ChangeLog 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/ChangeLog 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,3 +1,6 @@ > > -+????-??-?? Intel Corp > > -+ * Moved module out of kernel to run as a ring 3 app > > -+ > > - 2006-06-23 Mario Strasser > > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > > - persistent data adapted > > -diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c > > ---- orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/crypto/gmp_kernel_wrapper.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,5 +1,6 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -24,15 +25,10 @@ int __gmp_junk; > > - void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename, > > - int linenum, const char *expr) > > - { > > -- panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n", > > -+ error("%s:%d: GNU MP assertion failed: %s\n", > > - filename, linenum, expr); > > - } > > - > > --void __attribute__ ((regparm(0))) abort(void) > > --{ > > -- panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n"); > > --} > > -- > > - /* overwrite GNU MP random functions (used by mpz/millerrabin.c) */ > > - > > - void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate, > > -@@ -77,20 +73,19 @@ void __attribute__ ((regparm(0))) mpz_ur > > - > > - void __attribute__ ((regparm(0))) *kernel_allocate(size_t size) > > - { > > -- void *ret = (void*)kmalloc(size, GFP_KERNEL); > > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME > > -- "GMP: cannot allocate memory (size=%u)\n", size); > > -+ void *ret = (void*)malloc(size); > > -+ if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size); > > - return ret; > > - } > > - > > - void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr, > > - size_t old_size, size_t new_size) > > - { > > -- void *ret = (void*)kmalloc(new_size, GFP_KERNEL); > > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory " > > -- "(old_size=%u new_size=%u)\n", old_size, new_size); > > -+ void *ret = (void*)malloc(new_size); > > -+ if (!ret) error("GMP: Cannot reallocate memory " > > -+ "(old_size=%Zu new_size=%Zu)\n", old_size, new_size); > > - memcpy(ret, oldptr, old_size); > > -- kfree(oldptr); > > -+ free(oldptr); > > - return ret; > > - } > > - > > -@@ -99,7 +94,7 @@ void __attribute__ ((regparm(0))) kernel > > - /* overwrite used memory */ > > - if (blk_ptr != NULL) { > > - memset(blk_ptr, 0, blk_size); > > -- kfree(blk_ptr); > > -+ free(blk_ptr); > > - } > > - } > > - > > -diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c > > ---- orig/tpm_emulator-0.4/crypto/rsa.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/crypto/rsa.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,5 +1,6 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -381,7 +382,7 @@ static int encode_message(int type, uint > > - msg[0] = 0x00; > > - get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH); > > - sha1_init(&ctx); > > -- sha1_update(&ctx, "TCPA", 4); > > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > > - sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]); > > - memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00, > > - msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2); > > -@@ -429,7 +430,7 @@ static int decode_message(int type, uint > > - mask_generation(&msg[1], SHA1_DIGEST_LENGTH, > > - &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1); > > - sha1_init(&ctx); > > -- sha1_update(&ctx, "TCPA", 4); > > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > > - sha1_final(&ctx, &msg[1]); > > - if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH], > > - SHA1_DIGEST_LENGTH) != 0) return -1; > > -diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c > > ---- orig/tpm_emulator-0.4/linux_module.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/linux_module.c 1969-12-31 16:00:00.000000000 -0800 > > -@@ -1,195 +0,0 @@ > > --/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > -- * Copyright (C) 2004 Mario Strasser , > > -- * > > -- * This module is free software; you can redistribute it and/or modify > > -- * it under the terms of the GNU General Public License as published > > -- * by the Free Software Foundation; either version 2 of the License, > > -- * or (at your option) any later version. > > -- * > > -- * This module is distributed in the hope that it will be useful, > > -- * but WITHOUT ANY WARRANTY; without even the implied warranty of > > -- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > -- * GNU General Public License for more details. > > -- * > > -- * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $ > > -- */ > > -- > > --#include > > --#include > > --#include > > --#include > > --#include > > --#include "linux_module.h" > > --#include "tpm/tpm_emulator.h" > > -- > > --MODULE_LICENSE("GPL"); > > --MODULE_AUTHOR("Mario Strasser "); > > --MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator"); > > --MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME); > > -- > > --/* module startup parameters */ > > --char *startup = "save"; > > --module_param(startup, charp, 0444); > > --MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. " > > -- "Possible values are 'clear', 'save' (default) and 'deactivated."); > > --char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2"; > > --module_param(storage_file, charp, 0644); > > --MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage " > > -- "file of the TPM."); > > -- > > --/* TPM lock */ > > --static struct semaphore tpm_mutex; > > -- > > --/* TPM command response */ > > --static struct { > > -- uint8_t *data; > > -- uint32_t size; > > --} tpm_response; > > -- > > --/* module state */ > > --#define STATE_IS_OPEN 0 > > --static uint32_t module_state; > > --static struct timespec old_time; > > -- > > --static int tpm_open(struct inode *inode, struct file *file) > > --{ > > -- debug("%s()", __FUNCTION__); > > -- if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY; > > -- return 0; > > --} > > -- > > --static int tpm_release(struct inode *inode, struct file *file) > > --{ > > -- debug("%s()", __FUNCTION__); > > -- clear_bit(STATE_IS_OPEN, (void*)&module_state); > > -- down(&tpm_mutex); > > -- if (tpm_response.data != NULL) { > > -- kfree(tpm_response.data); > > -- tpm_response.data = NULL; > > -- } > > -- up(&tpm_mutex); > > -- return 0; > > --} > > -- > > --static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos) > > --{ > > -- debug("%s(%d)", __FUNCTION__, count); > > -- down(&tpm_mutex); > > -- if (tpm_response.data != NULL) { > > -- count = min(count, (size_t)tpm_response.size - (size_t)*ppos); > > -- count -= copy_to_user(buf, &tpm_response.data[*ppos], count); > > -- *ppos += count; > > -- if ((size_t)tpm_response.size == (size_t)*ppos) { > > -- kfree(tpm_response.data); > > -- tpm_response.data = NULL; > > -- } > > -- } else { > > -- count = 0; > > -- } > > -- up(&tpm_mutex); > > -- return count; > > --} > > -- > > --static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos) > > --{ > > -- debug("%s(%d)", __FUNCTION__, count); > > -- down(&tpm_mutex); > > -- *ppos = 0; > > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > > -- if (tpm_handle_command(buf, count, &tpm_response.data, > > -- &tpm_response.size) != 0) { > > -- count = -EILSEQ; > > -- tpm_response.data = NULL; > > -- } > > -- up(&tpm_mutex); > > -- return count; > > --} > > -- > > --#define TPMIOC_CANCEL _IO('T', 0x00) > > --#define TPMIOC_TRANSMIT _IO('T', 0x01) > > -- > > --static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) > > --{ > > -- debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg); > > -- if (cmd == TPMIOC_TRANSMIT) { > > -- uint32_t count = ntohl(*(uint32_t*)(arg + 2)); > > -- down(&tpm_mutex); > > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > > -- if (tpm_handle_command((char*)arg, count, &tpm_response.data, > > -- &tpm_response.size) == 0) { > > -- tpm_response.size -= copy_to_user((char*)arg, tpm_response.data, > > -- tpm_response.size); > > -- kfree(tpm_response.data); > > -- tpm_response.data = NULL; > > -- } else { > > -- tpm_response.size = 0; > > -- tpm_response.data = NULL; > > -- } > > -- up(&tpm_mutex); > > -- return tpm_response.size; > > -- } > > -- return -1; > > --} > > -- > > --struct file_operations fops = { > > -- .owner = THIS_MODULE, > > -- .open = tpm_open, > > -- .release = tpm_release, > > -- .read = tpm_read, > > -- .write = tpm_write, > > -- .ioctl = tpm_ioctl, > > --}; > > -- > > --static struct miscdevice tpm_dev = { > > -- .minor = TPM_DEVICE_MINOR, > > -- .name = TPM_DEVICE_NAME, > > -- .fops = &fops, > > --}; > > -- > > --int __init init_tpm_module(void) > > --{ > > -- int res = misc_register(&tpm_dev); > > -- if (res != 0) { > > -- error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR); > > -- return res; > > -- } > > -- /* initialize variables */ > > -- sema_init(&tpm_mutex, 1); > > -- module_state = 0; > > -- tpm_response.data = NULL; > > -- old_time = current_kernel_time(); > > -- /* initialize TPM emulator */ > > -- if (!strcmp(startup, "clear")) { > > -- tpm_emulator_init(1); > > -- } else if (!strcmp(startup, "save")) { > > -- tpm_emulator_init(2); > > -- } else if (!strcmp(startup, "deactivated")) { > > -- tpm_emulator_init(3); > > -- } else { > > -- error("invalid startup mode '%s'; must be 'clear', " > > -- "'save' (default) or 'deactivated", startup); > > -- misc_deregister(&tpm_dev); > > -- return -EINVAL; > > -- } > > -- return 0; > > --} > > -- > > --void __exit cleanup_tpm_module(void) > > --{ > > -- tpm_emulator_shutdown(); > > -- misc_deregister(&tpm_dev); > > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > > --} > > -- > > --module_init(init_tpm_module); > > --module_exit(cleanup_tpm_module); > > -- > > --uint64_t tpm_get_ticks(void) > > --{ > > -- struct timespec new_time = current_kernel_time(); > > -- uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000 > > -- + (new_time.tv_nsec - old_time.tv_nsec) / 1000; > > -- old_time = new_time; > > -- return (ticks > 0) ? ticks : 1; > > --} > > -- > > -diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h > > ---- orig/tpm_emulator-0.4/linux_module.h 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/linux_module.h 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,5 +1,6 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -17,54 +18,62 @@ > > - #ifndef _LINUX_MODULE_H_ > > - #define _LINUX_MODULE_H_ > > - > > --#include > > --#include > > --#include > > -+#include > > -+#include > > -+#include > > -+#include > > - #include > > --#include > > --#include > > --#include > > --#include > > - > > --/* module settings */ > > -+#include > > -+#define __BYTEORDER_HAS_U64__ > > -+#ifdef LITTLE_ENDIAN > > -+ #include > > -+#else > > -+ #include > > -+#endif > > - > > -+/* module settings */ > > -+#define min(A,B) ((A)<(B)?(A):(B)) > > -+#ifndef STR > > - #define STR(s) __STR__(s) > > - #define __STR__(s) #s > > -+#endif > > - #include "tpm_version.h" > > - > > - #define TPM_DEVICE_MINOR 224 > > - #define TPM_DEVICE_NAME "tpm" > > - #define TPM_MODULE_NAME "tpm_emulator" > > - > > --/* debug and log output functions */ > > -- > > - #ifdef DEBUG > > --#define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \ > > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > > -+ __FILE__, __LINE__, ## __VA_ARGS__) > > - #else > > - #define debug(fmt, ...) > > - #endif > > --#define info(fmt, ...) printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \ > > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > > --#define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \ > > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > > --#define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \ > > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > > -+ __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > > -+ __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > > -+ __FILE__, __LINE__, ## __VA_ARGS__) > > - > > - /* memory allocation */ > > - > > - static inline void *tpm_malloc(size_t size) > > - { > > -- return kmalloc(size, GFP_KERNEL); > > -+ return malloc(size); > > - } > > - > > - static inline void tpm_free(const void *ptr) > > - { > > -- if (ptr != NULL) kfree(ptr); > > -+ if (ptr != NULL) free( (void *) ptr); > > - } > > - > > - /* random numbers */ > > - > > -+//FIXME; > > -+void get_random_bytes(void *buf, int nbytes); > > -+ > > - static inline void tpm_get_random_bytes(void *buf, int nbytes) > > - { > > - get_random_bytes(buf, nbytes); > > -@@ -84,9 +93,9 @@ uint64_t tpm_get_ticks(void); > > - #define CPU_TO_LE16(x) __cpu_to_le16(x) > > - > > - #define BE64_TO_CPU(x) __be64_to_cpu(x) > > --#define LE64_TO_CPU(x) __be64_to_cpu(x) > > -+#define LE64_TO_CPU(x) __le64_to_cpu(x) > > - #define BE32_TO_CPU(x) __be32_to_cpu(x) > > --#define LE32_TO_CPU(x) __be32_to_cpu(x) > > -+#define LE32_TO_CPU(x) __le32_to_cpu(x) > > - #define BE16_TO_CPU(x) __be16_to_cpu(x) > > - #define LE16_TO_CPU(x) __le16_to_cpu(x) > > - > > -diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile > > ---- orig/tpm_emulator-0.4/Makefile 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/Makefile 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,24 +1,40 @@ > > - # Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - # Copyright (C) 2004 Mario Strasser > > -+# Copyright (C) 2006 INTEL Corp. > > - # > > - # $Id: Makefile 115 2006-06-23 10:36:44Z mast $ > > - > > --# kernel settings > > --KERNEL_RELEASE := $(shell uname -r) > > --KERNEL_BUILD := /lib/modules/$(KERNEL_RELEASE)/build > > --MOD_SUBDIR := misc > > -+COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > > - > > - # module settings > > --MODULE_NAME := tpm_emulator > > -+BIN := tpm_emulator > > - VERSION_MAJOR := 0 > > - VERSION_MINOR := 4 > > - VERSION_BUILD := $(shell date +"%s") > > - > > --# enable/disable DEBUG messages > > --EXTRA_CFLAGS += -Wall -DDEBUG -g > > -+# Installation program and options > > -+INSTALL = install > > -+INSTALL_PROG = $(INSTALL) -m0755 > > -+INSTALL_DIR = $(INSTALL) -d -m0755 > > -+ > > -+# Xen tools installation directory > > -+TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > > -+ > > -+CC := gcc > > -+CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > > -+CFLAGS += -I. -Itpm > > -+ > > -+# Is the simulator running in it's own vm? > > -+#CFLAGS += -DVTPM_MULTI_VM > > -+ > > -+ifeq ($(COMPILE_ARCH),x86_64) > > -+LIBDIR = lib64 > > -+else > > -+LIBDIR = lib > > -+endif > > - > > - # GNU MP configuration > > --GMP_LIB := /usr/lib/libgmp.a > > -+GMP_LIB := /usr/$(LIBDIR)/libgmp.a > > - GMP_HEADER := /usr/include/gmp.h > > - > > - # sources and objects > > -@@ -27,38 +43,32 @@ DIRS := . crypto tpm > > - SRCS := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c)) > > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > > - SRCS += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h)) > > --DISTSRC := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS) > > --DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR) > > - > > --obj-m := $(MODULE_NAME).o > > --$(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > > -+obj-m := $(BIN) > > -+$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > > - > > - EXTRA_CFLAGS += -I$(src) -I$(src)/crypto -I$(src)/tpm > > - > > - # do not print "Entering directory ..." > > - MAKEFLAGS += --no-print-directory > > - > > --all: $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version > > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules > > -+all: $(BIN) > > - > > --install: > > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install > > -- test -d /var/tpm || mkdir /var/tpm > > -- test -c /dev/tpm || mknod /dev/tpm c 10 224 > > -- chmod 666 /dev/tpm > > -- depmod -a > > -+$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS) > > -+ $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN) > > -+ > > -+%.o: %.c > > -+ $(CC) $(CFLAGS) -c $< -o $@ > > -+ > > -+install: $(BIN) > > -+ $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > > -+ @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > > - > > - clean: > > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean > > -- rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a > > -+ rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > > - > > --dist: $(DISTSRC) > > -- rm -rf $(DISTDIR) > > -- mkdir $(DISTDIR) > > -- cp --parents $(DISTSRC) $(DISTDIR)/ > > -- rm -f $(DISTDIR)/crypto/gmp.h > > -- tar -chzf $(DISTDIR).tar.gz $(DISTDIR) > > -- rm -rf $(DISTDIR) > > -+mrproper: clean > > -+ rm -f $(BIN) tpm_version.h > > - > > - $(src)/crypto/libgmp.a: > > - test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a > > -@@ -88,4 +98,3 @@ version: > > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > > - > > - .PHONY: all install clean dist gmp version > > -- > > -diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README > > ---- orig/tpm_emulator-0.4/README 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/README 2006-07-24 14:35:35.000000000 -0700 > > -@@ -13,7 +13,8 @@ $Id: README 113 2006-06-18 12:38:13Z hst > > - Copyright > > - -------------------------------------------------------------------------- > > - Copyright (C) 2004 Mario Strasser and Swiss Federal > > --Institute of Technology (ETH) Zurich. > > -+ Institute of Technology (ETH) Zurich. > > -+Copyright (C) 2005 INTEL Corp > > - > > - This program is free software; you can redistribute it and/or modify > > - it under the terms of the GNU General Public License as published by > > -@@ -43,6 +44,12 @@ Example: > > - GMP_LIB := /usr/lib/libgmp.a > > - GMP_HEADER := /usr/include/gmp.h > > - > > -+GNU MP Library on 64 bit Systems > > -+-------------------------------------------------------------------------- > > -+Some 64-bit kernels have problems with importing the user-space gmp > > -+library (/usr/lib*/libgmp.a) into kernel space. These kernels will require > > -+that the gmp library be recompiled for kernel space with -mcmodel=kernel. > > -+ > > - Installation > > - -------------------------------------------------------------------------- > > - The compilation and installation process uses the build environment for > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_capability.c tpm_emulator/tpm/tpm_capability.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_capability.c 2006-06-23 19:37:07.000000000 +0900 > > -+++ tpm_emulator/tpm/tpm_capability.c 2007-12-28 22:50:19.000000000 +0900 > > -@@ -701,7 +701,10 @@ TPM_RESULT TPM_GetCapabilityOwner(TPM_VE > > - TPM_RESULT res; > > - > > - info("TPM_GetCapabilityOwner()"); > > -- > > -+ > > -+ if (!tpmData.permanent.flags.owned) { > > -+ return TPM_NOSRK; > > -+ } > > - /* Verify owner authorization */ > > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > > - if (res != TPM_SUCCESS) return res; > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c tpm_emulator/tpm/tpm_cmd_handler.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c 2006-06-23 19:37:07.000000000 +0900 > > -+++ tpm_emulator/tpm/tpm_cmd_handler.c 2007-09-12 20:23:00.000000000 +0900 > > -@@ -565,7 +565,7 @@ static TPM_RESULT execute_TPM_Seal(TPM_R > > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > > -+ || (pcrInfoSize >0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > > - || len != 0) return TPM_BAD_PARAMETER; > > -@@ -798,7 +798,7 @@ static TPM_RESULT execute_TPM_Sealx(TPM_ > > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > > -+ || (pcrInfoSize > 0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > > - || len != 0) return TPM_BAD_PARAMETER; > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_credentials.c 2006-06-23 19:37:07.000000000 +0900 > > -+++ tpm_emulator/tpm/tpm_credentials.c 2007-09-12 20:23:30.000000000 +0900 > > -@@ -47,20 +47,20 @@ int tpm_compute_pubkey_checksum(TPM_NONC > > - > > - TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey) > > - { > > -- UINT32 key_length; > > -+ size_t key_length; > > - if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT; > > - /* setup TPM_PUBKEY structure */ > > -- key_length = tpmData.permanent.data.endorsementKey.size; > > -- pubEndorsementKey->pubKey.keyLength = key_length >> 3; > > -+ pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3; > > - pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength); > > - if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL; > > - rsa_export_modulus(&tpmData.permanent.data.endorsementKey, > > -- pubEndorsementKey->pubKey.key, > > -- &pubEndorsementKey->pubKey.keyLength); > > -+ pubEndorsementKey->pubKey.key, > > -+ &key_length); > > -+ pubEndorsementKey->pubKey.keyLength = key_length; > > - pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA; > > - pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > > - pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE; > > -- pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length; > > -+ pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length << 3; > > - pubEndorsementKey->algorithmParms.parms.rsa.numPrimes = 2; > > - pubEndorsementKey->algorithmParms.parms.rsa.exponentSize = 0; > > - pubEndorsementKey->algorithmParms.parms.rsa.exponent = NULL; > > -@@ -175,6 +175,7 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > > - { > > - TPM_RESULT res; > > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > > -+ size_t key_length; > > - info("TPM_OwnerReadInternalPub()"); > > - /* verify authorization */ > > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > > -@@ -186,7 +187,8 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > > - publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength); > > - if (publicPortion->pubKey.key == NULL) return TPM_FAIL; > > - rsa_export_modulus(&srk->key, publicPortion->pubKey.key, > > -- &publicPortion->pubKey.keyLength); > > -+ &key_length); > > -+ publicPortion->pubKey.keyLength = key_length; > > - publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA; > > - publicPortion->algorithmParms.encScheme = srk->encScheme; > > - publicPortion->algorithmParms.sigScheme = srk->sigScheme; > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_crypto.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_crypto.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -182,7 +182,8 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > > - TPM_KEY_DATA *cert, *key; > > - sha1_ctx_t sha1_ctx; > > - BYTE *buf, *p; > > -- UINT32 length; > > -+ UINT32 length32; > > -+ size_t length; > > - info("TPM_CertifyKey()"); > > - /* get keys */ > > - cert = tpm_get_key(certHandle); > > -@@ -264,14 +265,15 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > > - p = buf = tpm_malloc(length); > > -+ length32=(UINT32) length; > > - if (buf == NULL > > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > > - return TPM_FAIL; > > - } > > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > > - sha1_init(&sha1_ctx); > > -- sha1_update(&sha1_ctx, buf, length); > > -+ sha1_update(&sha1_ctx, buf, (size_t) length); > > - sha1_final(&sha1_ctx, buf); > > - res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize); > > - tpm_free(buf); > > -@@ -292,7 +294,8 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > > - TPM_KEY_DATA *cert, *key; > > - sha1_ctx_t sha1_ctx; > > - BYTE *buf, *p; > > -- UINT32 length; > > -+ size_t length; > > -+ UINT32 length32; > > - info("TPM_CertifyKey2()"); > > - /* get keys */ > > - cert = tpm_get_key(certHandle); > > -@@ -362,8 +365,9 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > > - p = buf = tpm_malloc(length); > > -+ length32 = (UINT32) length; > > - if (buf == NULL > > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > > - return TPM_FAIL; > > - } > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_daa.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_daa.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -716,14 +716,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -805,14 +805,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -1489,14 +1489,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -1712,14 +1712,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -1793,14 +1793,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -2918,14 +2918,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -3143,7 +3143,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > > - sizeof(session->DAA_session.DAA_digest)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_update(&sha1, inputData1, inputSize1); > > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > > - } > > -@@ -3172,7 +3172,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > > - sizeof(session->DAA_session.DAA_digest)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE*) "\x00", 1); > > - rsa_export_modulus(&aikData->key, scratch, &size); > > - sha1_update(&sha1, scratch, size); > > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > > -@@ -3229,14 +3229,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -@@ -3309,14 +3309,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x00", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > > - sha1_final(&sha1, scratch); > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > > - sizeof(session->DAA_tpmSpecific.DAA_count)); > > -- sha1_update(&sha1, "\x01", 1); > > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > > - mpz_init(f), mpz_init(q); > > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_data.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_data.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -40,6 +40,7 @@ static inline void init_pcr_attr(int pcr > > - void tpm_init_data(void) > > - { > > - /* endorsement key */ > > -+#ifndef TPM_GENERATE_EK > > - uint8_t ek_n[] = "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7" > > - "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93" > > - "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a" > > -@@ -77,6 +78,8 @@ void tpm_init_data(void) > > - "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b" > > - "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47" > > - "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f"; > > -+#endif > > -+ > > - int i; > > - /* reset all data to NULL, FALSE or 0 */ > > - memset(&tpmData, 0, sizeof(tpmData)); > > -@@ -152,44 +155,43 @@ void tpm_release_data(void) > > - > > - #ifdef TPM_STORE_TO_FILE > > - > > --#include > > --#include > > --#include > > -+#include > > -+#include > > -+#include > > -+#include > > - > > - #define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > > - > > - static int write_to_file(uint8_t *data, size_t data_length) > > - { > > - int res; > > -- struct file *fp; > > -- mm_segment_t old_fs = get_fs(); > > -- fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > > -- if (IS_ERR(fp)) return -1; > > -- set_fs(get_ds()); > > -- res = fp->f_op->write(fp, data, data_length, &fp->f_pos); > > -- set_fs(old_fs); > > -- filp_close(fp, NULL); > > -+ int fp; > > -+ fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > > -+ res = write(fp, data, data_length); > > -+ close(fp); > > - return (res == data_length) ? 0 : -1; > > - } > > - > > - static int read_from_file(uint8_t **data, size_t *data_length) > > - { > > - int res; > > -- struct file *fp; > > -- mm_segment_t old_fs = get_fs(); > > -- fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0); > > -- if (IS_ERR(fp)) return -1; > > -- *data_length = (size_t)fp->f_dentry->d_inode->i_size; > > -- /* *data_length = i_size_read(fp->f_dentry->d_inode); */ > > -+ int fp, file_status; > > -+ struct stat file_info; > > -+ fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > > -+ file_status = fstat(fp, &file_info); > > -+ if (file_status < 0) { > > -+ close(fp); > > -+ return -1; > > -+ } > > -+ > > -+ *data_length = file_info.st_size; > > - *data = tpm_malloc(*data_length); > > - if (*data == NULL) { > > -- filp_close(fp, NULL); > > -+ close(fp); > > - return -1; > > - } > > -- set_fs(get_ds()); > > -- res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos); > > -- set_fs(old_fs); > > -- filp_close(fp, NULL); > > -+ res = read(fp, *data, *data_length); > > -+ close(fp); > > - if (res != *data_length) { > > - tpm_free(*data); > > - return -1; > > -@@ -216,23 +218,30 @@ static int read_from_file(uint8_t **data > > - int tpm_store_permanent_data(void) > > - { > > - uint8_t *buf, *ptr; > > -- size_t buf_length, len; > > -+ UINT32 buf_length, len; > > - > > - /* marshal data */ > > -- buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > > -- + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2 > > -- + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data); > > -+ buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > > -+ + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) > > -+ + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2 > > -+ + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data) > > -+ + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data) > > -+ + sizeof_TPM_STANY_DATA(tpmData.stany.data); > > - buf = ptr = tpm_malloc(buf_length); > > - if (buf == NULL > > - || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version) > > - || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > > - || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > > -+ || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded) > > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned) > > -- || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > > -+ || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > > -+ || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > > -+ || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > > - tpm_free(buf); > > - return -1; > > - } > > -+ > > - if (write_to_file(buf, buf_length - len)) { > > - tpm_free(buf); > > - return -1; > > -@@ -244,31 +253,36 @@ int tpm_store_permanent_data(void) > > - int tpm_restore_permanent_data(void) > > - { > > - uint8_t *buf, *ptr; > > -- size_t buf_length, len; > > -+ size_t buf_length; > > -+ UINT32 len; > > - TPM_VERSION ver; > > - > > - /* read data */ > > - if (read_from_file(&buf, &buf_length)) return -1; > > - ptr = buf; > > -- len = buf_length; > > -+ len = (uint32_t) buf_length; > > - /* unmarshal data */ > > - if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver) > > - || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION)) > > - || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > > - || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > > -+ || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded) > > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned) > > -- || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > > -+ || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > > -+ || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > > -+ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > > - tpm_free(buf); > > - return -1; > > - } > > -+ > > - tpm_free(buf); > > - return 0; > > - } > > - > > - int tpm_erase_permanent_data(void) > > - { > > -- int res = write_to_file("", 0); > > -+ int res = write_to_file((uint8_t *) "", 0); > > - return res; > > - } > > - > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_deprecated.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_deprecated.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,6 +1,7 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > - * Swiss Federal Institute of Technology (ETH) Zurich > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -50,7 +51,7 @@ TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA > > - BYTE *ptr; > > - UINT32 len; > > - info("TPM_SaveKeyContext()"); > > -- res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..", > > -+ res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..", > > - keyContextSize, &contextBlob); > > - if (res != TPM_SUCCESS) return res; > > - len = *keyContextSize; > > -@@ -82,7 +83,7 @@ TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH > > - BYTE *ptr; > > - UINT32 len; > > - info("TPM_SaveAuthContext()"); > > -- res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.", > > -+ res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.", > > - authContextSize, &contextBlob); > > - if (res != TPM_SUCCESS) return res; > > - len = *authContextSize; > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h > > ---- orig/tpm_emulator-0.4/tpm/tpm_emulator.h 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_emulator.h 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,5 +1,6 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -22,7 +23,8 @@ > > - /* TPM configuration */ > > - #define TPM_STORE_TO_FILE 1 > > - #undef TPM_STRONG_PERSISTENCE > > --#undef TPM_GENERATE_EK > > -+//#undef TPM_GENERATE_EK > > -+#define TPM_GENERATE_EK > > - #undef TPM_GENERATE_SEED_DAA > > - > > - #define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */ > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_marshalling.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1312,7 +1312,7 @@ int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * > > - > > - int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v) > > - { > > -- UINT32 m_len, e_len, q_len; > > -+ size_t m_len, e_len, q_len; > > - if (*length < sizeof_RSA((*v))) return -1; > > - if (v->size > 0) { > > - rsa_export_modulus(v, &(*ptr)[6], &m_len); > > -@@ -1460,6 +1460,66 @@ int tpm_unmarshal_TPM_PERMANENT_DATA(BYT > > - return 0; > > - } > > - > > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > > -+{ > > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > > -+ || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1; > > -+ > > -+ return 0; > > -+} > > -+ > > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > > -+{ > > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > > -+ || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1; > > -+ > > -+ return 0; > > -+} > > -+ > > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > > -+{ > > -+ UINT32 i; > > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > > -+ || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) > > -+ || tpm_marshal_BOOL(ptr, length, v->auditSession) > > -+ || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > > -+ || tpm_marshal_UINT32(ptr, length, v->contextCount) > > -+ || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > > -+ if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > > -+ } > > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > > -+ if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > > -+ } > > -+ if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; > > -+ > > -+ return 0; > > -+} > > -+ > > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > > -+{ > > -+ UINT32 i; > > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > > -+ || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) > > -+ || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) > > -+ || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > > -+ || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) > > -+ || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > > -+ if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > > -+ } > > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > > -+ if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > > -+ } > > -+ if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; > > -+ > > -+ return 0; > > -+} > > -+ > > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) > > - { > > - if (tpm_marshal_BYTE(ptr, length, v->type) > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h > > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.h 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_marshalling.h 2006-07-24 14:35:35.000000000 -0700 > > -@@ -432,6 +432,12 @@ int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt > > - int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > > - int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > > - > > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > > -+ > > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > > -+ > > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > > - int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > > - > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_owner.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_owner.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -108,7 +108,7 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > > - TPM_RESULT res; > > - rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey; > > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > > -- UINT32 buf_size = ek->size >> 3; > > -+ size_t buf_size = ek->size >> 3, key_length; > > - BYTE buf[buf_size]; > > - > > - info("TPM_TakeOwnership()"); > > -@@ -173,7 +173,8 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > > - return TPM_FAIL; > > - } > > - rsa_export_modulus(&srk->key, srkPub->pubKey.key, > > -- &srkPub->pubKey.keyLength); > > -+ &key_length); > > -+ srkPub->pubKey.keyLength = (UINT32) key_length; > > - /* setup tpmProof and set state to owned */ > > - tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce, > > - sizeof(tpmData.permanent.data.tpmProof.nonce)); > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_startup.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_startup.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -41,26 +41,29 @@ void TPM_Init(TPM_STARTUP_TYPE startupTy > > - TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType) > > - { > > - int i; > > -+ int restore_fail; > > - info("TPM_Startup(%d)", startupType); > > - if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT; > > -- /* reset STANY_FLAGS */ > > -- SET_TO_ZERO(&tpmData.stany.flags); > > -- tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > > -- /* reset STANY_DATA (invalidates ALL sessions) */ > > -- SET_TO_ZERO(&tpmData.stany.data); > > -- tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > > -- /* init session-context nonce */ > > -- SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > > -+ > > -+ /* try and restore state to get EK, SRK, etc */ > > -+ restore_fail = tpm_restore_permanent_data(); > > -+ > > - /* set data and flags according to the given startup type */ > > - if (startupType == TPM_ST_CLEAR) { > > -- /* if available, restore permanent data */ > > -- tpm_restore_permanent_data(); > > -+ /* reset STANY_FLAGS */ > > -+ SET_TO_ZERO(&tpmData.stany.flags); > > -+ tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > > -+ /* reset STANY_DATA (invalidates ALL sessions) */ > > -+ SET_TO_ZERO(&tpmData.stany.data); > > -+ tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > > -+ /* init session-context nonce */ > > -+ SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > > - /* reset PCR values */ > > - for (i = 0; i < TPM_NUM_PCR; i++) { > > -- if (tpmData.permanent.data.pcrAttrib[i].pcrReset) > > -- SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest); > > -+ if (!tpmData.permanent.data.pcrAttrib[i].pcrReset) > > -+ SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest); > > - else > > -- SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest); > > -+ SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest); > > - } > > - /* reset STCLEAR_FLAGS */ > > - SET_TO_ZERO(&tpmData.stclear.flags); > > -@@ -79,7 +82,8 @@ TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE > > - /* init key-context nonce */ > > - SET_TO_RAND(&tpmData.stclear.data.contextNonceKey); > > - } else if (startupType == TPM_ST_STATE) { > > -- if (tpm_restore_permanent_data()) { > > -+ /* restore must have been successful for TPM_ST_STATE */ > > -+ if (restore_fail) { > > - error("restoring permanent data failed"); > > - tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed"; > > - tpmData.permanent.flags.selfTestSucceeded = FALSE; > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_storage.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_storage.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -58,6 +58,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > > - BYTE *enc, UINT32 *enc_size) > > - { > > - UINT32 len; > > -+ size_t enc_size32 = *enc_size; > > - BYTE *buf, *ptr; > > - rsa_public_key_t pub_key; > > - int scheme; > > -@@ -72,7 +73,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > > - if (buf == NULL > > - || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal) > > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)), > > -- enc, enc_size)) { > > -+ enc, &enc_size32)) { > > - tpm_free(buf); > > - rsa_release_public_key(&pub_key); > > - return -1; > > -@@ -85,7 +86,8 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > > - int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > > - TPM_SEALED_DATA *seal, BYTE **buf) > > - { > > -- UINT32 len; > > -+ size_t len; > > -+ UINT32 len32; > > - BYTE *ptr; > > - int scheme; > > - switch (key->encScheme) { > > -@@ -96,8 +98,12 @@ int decrypt_sealed_data(TPM_KEY_DATA *ke > > - len = enc_size; > > - *buf = ptr = tpm_malloc(len); > > - if (*buf == NULL > > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > > -- || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) { > > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){ > > -+ tpm_free(*buf); > > -+ return -1; > > -+ } > > -+ len32 = len; > > -+ if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) { > > - tpm_free(*buf); > > - return -1; > > - } > > -@@ -240,11 +246,12 @@ TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par > > - > > - TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize, > > - BYTE *inData, TPM_AUTH *auth1, > > -- UINT32 *outDataSize, BYTE **outData) > > -+ UINT32 *outDataSize32, BYTE **outData) > > - { > > - TPM_RESULT res; > > - TPM_KEY_DATA *key; > > - int scheme; > > -+ size_t outDataSize; > > - > > - info("TPM_UnBind()"); > > - /* get key */ > > -@@ -262,8 +269,8 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > > - /* the size of the input data muss be greater than zero */ > > - if (inDataSize == 0) return TPM_BAD_PARAMETER; > > - /* decrypt data */ > > -- *outDataSize = inDataSize; > > -- *outData = tpm_malloc(*outDataSize); > > -+ outDataSize = inDataSize; > > -+ *outData = tpm_malloc(outDataSize); > > - if (*outData == NULL) return TPM_NOSPACE; > > - switch (key->encScheme) { > > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > > -@@ -271,20 +278,21 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > > - default: tpm_free(*outData); return TPM_DECRYPT_ERROR; > > - } > > - if (rsa_decrypt(&key->key, scheme, inData, inDataSize, > > -- *outData, outDataSize)) { > > -+ *outData, &outDataSize)) { > > - tpm_free(*outData); > > - return TPM_DECRYPT_ERROR; > > - } > > - /* verify data if it is of type TPM_BOUND_DATA */ > > - if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1 > > - || key->keyUsage != TPM_KEY_LEGACY) { > > -- if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > > -+ if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > > - tpm_free(*outData); > > - return TPM_DECRYPT_ERROR; > > - } > > -- *outDataSize -= 5; > > -- memmove(*outData, &(*outData)[5], *outDataSize); > > -+ outDataSize -= 5; > > -+ memmove(*outData, &(*outData)[5], outDataSize); > > - } > > -+ *outDataSize32 = (UINT32) outDataSize; > > - return TPM_SUCCESS; > > - } > > - > > -@@ -334,12 +342,13 @@ int compute_pubkey_digest(TPM_PUBKEY *ke > > - } > > - > > - int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store, > > -- BYTE *enc, UINT32 *enc_size) > > -+ BYTE *enc, UINT32 *enc_size32) > > - { > > - UINT32 len; > > - BYTE *buf, *ptr; > > - rsa_public_key_t pub_key; > > - int scheme; > > -+ size_t enc_size; > > - switch (key->encScheme) { > > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > > - case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break; > > -@@ -351,11 +360,12 @@ int encrypt_private_key(TPM_KEY_DATA *ke > > - if (buf == NULL > > - || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store) > > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)), > > -- enc, enc_size)) { > > -+ enc, &enc_size)) { > > - tpm_free(buf); > > - rsa_release_public_key(&pub_key); > > - return -1; > > - } > > -+ *enc_size32 = (UINT32) enc_size; > > - tpm_free(buf); > > - rsa_release_public_key(&pub_key); > > - return 0; > > -@@ -364,7 +374,8 @@ int encrypt_private_key(TPM_KEY_DATA *ke > > - int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > > - TPM_STORE_ASYMKEY *store, BYTE **buf) > > - { > > -- UINT32 len; > > -+ UINT32 len32; > > -+ size_t len; > > - BYTE *ptr; > > - int scheme; > > - switch (key->encScheme) { > > -@@ -375,8 +386,12 @@ int decrypt_private_key(TPM_KEY_DATA *ke > > - len = enc_size; > > - *buf = ptr = tpm_malloc(len); > > - if (*buf == NULL > > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > > -- || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) { > > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) { > > -+ tpm_free(*buf); > > -+ return -1; > > -+ } > > -+ len32 = (UINT32) len; > > -+ if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { > > - tpm_free(*buf); > > - return -1; > > - } > > -@@ -394,7 +409,7 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > > - TPM_SESSION_DATA *session; > > - TPM_STORE_ASYMKEY store; > > - rsa_private_key_t rsa; > > -- UINT32 key_length; > > -+ size_t key_length; > > - > > - info("TPM_CreateWrapKey()"); > > - /* get parent key */ > > -@@ -450,11 +465,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > > - } > > - } > > - /* generate key and store it */ > > -- key_length = keyInfo->algorithmParms.parms.rsa.keyLength; > > -- if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL; > > -- wrappedKey->pubKey.keyLength = key_length >> 3; > > -+ if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength)) > > -+ return TPM_FAIL; > > -+ wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3; > > - wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength); > > -- store.privKey.keyLength = key_length >> 4; > > -+ store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4; > > - store.privKey.key = tpm_malloc(store.privKey.keyLength); > > - wrappedKey->encDataSize = parent->key.size >> 3; > > - wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize); > > -@@ -466,9 +481,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > > - tpm_free(wrappedKey->encData); > > - return TPM_NOSPACE; > > - } > > -- rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > > -- &wrappedKey->pubKey.keyLength); > > -- rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength); > > -+ rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > > -+ &key_length); > > -+ wrappedKey->pubKey.keyLength = (UINT32) key_length; > > -+ rsa_export_prime1(&rsa, store.privKey.key, &key_length); > > -+ store.privKey.keyLength = (UINT32) key_length; > > - rsa_release_private_key(&rsa); > > - /* compute the digest of the wrapped key (without encData) */ > > - if (compute_key_digest(wrappedKey, &store.pubDataDigest)) { > > -@@ -602,6 +619,7 @@ TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p > > - > > - int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms) > > - { > > -+ size_t key_length; > > - parms->algorithmID = TPM_ALG_RSA; > > - parms->encScheme = key->encScheme; > > - parms->sigScheme = key->sigScheme; > > -@@ -611,7 +629,8 @@ int tpm_setup_key_parms(TPM_KEY_DATA *ke > > - parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize); > > - if (parms->parms.rsa.exponent == NULL) return -1; > > - rsa_export_exponent(&key->key, parms->parms.rsa.exponent, > > -- &parms->parms.rsa.exponentSize); > > -+ &key_length); > > -+ parms->parms.rsa.exponentSize = (UINT32) key_length; > > - parms->parmSize = 12 + parms->parms.rsa.exponentSize; > > - return 0; > > - } > > -@@ -622,6 +641,7 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > > - TPM_RESULT res; > > - TPM_KEY_DATA *key; > > - TPM_DIGEST digest; > > -+ size_t key_length; > > - info("TPM_GetPubKey()"); > > - /* get key */ > > - if (keyHandle == TPM_KH_SRK > > -@@ -650,8 +670,8 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > > - pubKey->pubKey.keyLength = key->key.size >> 3; > > - pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength); > > - if (pubKey->pubKey.key == NULL) return TPM_NOSPACE; > > -- rsa_export_modulus(&key->key, pubKey->pubKey.key, > > -- &pubKey->pubKey.keyLength); > > -+ rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length); > > -+ pubKey->pubKey.keyLength = (UINT32) key_length; > > - if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) { > > - error("TPM_GetPubKey(): tpm_setup_key_parms() failed."); > > - tpm_free(pubKey->pubKey.key); > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h > > ---- orig/tpm_emulator-0.4/tpm/tpm_structures.h 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_structures.h 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1958,6 +1958,7 @@ typedef struct tdTPM_DAA_ISSUER { > > - TPM_DIGEST DAA_digest_gamma; > > - BYTE DAA_generic_q[26]; > > - } TPM_DAA_ISSUER; > > -+#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 ) > > - > > - /* > > - * TPM_DAA_TPM ([TPM_Part2], Section 22.4) > > -@@ -1973,6 +1974,7 @@ typedef struct tdTPM_DAA_TPM { > > - TPM_DIGEST DAA_rekey; > > - UINT32 DAA_count; > > - } TPM_DAA_TPM; > > -+#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4) > > - > > - /* > > - * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5) > > -@@ -1987,6 +1989,7 @@ typedef struct tdTPM_DAA_CONTEXT { > > - BYTE DAA_scratch[256]; > > - BYTE DAA_stage; > > - } TPM_DAA_CONTEXT; > > -+#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1) > > - > > - /* > > - * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6) > > -@@ -1998,6 +2001,7 @@ typedef struct tdTPM_DAA_JOINDATA { > > - BYTE DAA_join_u1[138]; > > - TPM_DIGEST DAA_digest_n0; > > - } TPM_DAA_JOINDATA; > > -+#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20) > > - > > - /* > > - * TPM_DAA_BLOB ([TPM_Part2], Section 22.8) > > -@@ -2202,6 +2206,7 @@ typedef struct tdTPM_STCLEAR_DATA { > > - //UINT32 ownerReference; > > - //BOOL disableResetLock; > > - } TPM_STCLEAR_DATA; > > -+#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4) > > - > > - /* > > - * TPM_SESSION_DATA > > -@@ -2238,6 +2243,11 @@ typedef struct tdTPM_DAA_SESSION_DATA { > > - TPM_DAA_JOINDATA DAA_joinSession; > > - TPM_HANDLE handle; > > - } TPM_DAA_SESSION_DATA; > > -+#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \ > > -+ + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \ > > -+ + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \ > > -+ + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \ > > -+ + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4) > > - > > - /* > > - * TPM_STANY_DATA ([TPM_Part2], Section 7.6) > > -@@ -2262,6 +2272,11 @@ typedef struct tdTPM_STANY_DATA { > > - TPM_DAAHANDLE currentDAA; > > - TPM_TRANSHANDLE transExclusive; > > - } TPM_STANY_DATA; > > -+#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \ > > -+ + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \ > > -+ + 4 + (4 * TPM_MAX_SESSION_LIST) \ > > -+ + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \ > > -+ + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4) > > - > > - /* > > - * TPM_DATA > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_testing.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_testing.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,6 +1,7 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > - * Swiss Federal Institute of Technology (ETH) Zurich > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -95,24 +96,24 @@ static int tpm_test_sha1(void) > > - struct { > > - uint8_t *data; uint32_t repetitions; uint8_t *digest; > > - } test_cases[] = {{ > > -- "abc", 1, > > -- "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > > -+ (uint8_t*)"abc", 1, > > -+ (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > > - }, { > > -- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > > -- "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > > -+ (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > > -+ (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > > - }, { > > -- "a", 1000000, > > -- "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > > -+ (uint8_t*)"a", 1000000, > > -+ (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > > - }, { > > -- "0123456701234567012345670123456701234567012345670123456701234567", 10, > > -- "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > > -+ (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10, > > -+ (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > > - }}; > > - > > - debug("tpm_test_sha1()"); > > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > > - sha1_init(&ctx); > > - for (j = 0; j < test_cases[i].repetitions; j++) > > -- sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > > -+ sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > > - sha1_final(&ctx, digest); > > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > > - } > > -@@ -128,41 +129,41 @@ static int tpm_test_hmac(void) > > - struct { > > - uint8_t *key, key_len, *data, data_len, *digest; > > - } test_cases[] = {{ > > -- "\x0b", 20, "Hi There", 8, > > -- "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > > -+ (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8, > > -+ (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > > - }, { > > -- "Jefe", 4, "what do ya want for nothing?", 28, > > -- "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > > -+ (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28, > > -+ (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > > - }, { > > -- "\xaa", 20, "\xdd", 50, > > -- "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > > -+ (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50, > > -+ (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > > - }, { > > -- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > > -- "\x15\x16\x17\x18\x19", 25, "\xcd", 50, > > -- "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > > -+ (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > > -+ "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50, > > -+ (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > > - }, { > > -- "\x0c", 20, "Test With Truncation", 20, > > -- "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > > -+ (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20, > > -+ (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > > - }, { > > -- "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54, > > -- "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > > -+ (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54, > > -+ (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > > - }, { > > -- "\xaa", 80, > > -- "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > > -- "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > > -+ (uint8_t*)"\xaa", 80, > > -+ (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > > -+ (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > > - }}; > > - > > - debug("tpm_test_hmac()"); > > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > > -- if (strlen(test_cases[i].key) < test_cases[i].key_len) { > > -+ if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) { > > - uint8_t key[test_cases[i].key_len]; > > - memset(key, test_cases[i].key[0], test_cases[i].key_len); > > - hmac_init(&ctx, key, test_cases[i].key_len); > > - } else { > > - hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len); > > - } > > -- for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) { > > -- hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > > -+ for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) { > > -+ hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > > - } > > - hmac_final(&ctx, digest); > > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > > -@@ -173,9 +174,9 @@ static int tpm_test_hmac(void) > > - static int tpm_test_rsa_EK(void) > > - { > > - int res = 0; > > -- char *data = "RSA PKCS #1 v1.5 Test-String"; > > -+ uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String"; > > - uint8_t buf[256]; > > -- size_t buf_len, data_len = strlen(data); > > -+ size_t buf_len, data_len = strlen((char*)data); > > - rsa_private_key_t priv_key; > > - rsa_public_key_t pub_key; > > - > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_ticks.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_ticks.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -1,6 +1,7 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > - * Swiss Federal Institute of Technology (ETH) Zurich > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -39,9 +40,7 @@ TPM_RESULT TPM_SetTickType(TPM_TICKTYPE > > - TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime) > > - { > > - info("TPM_GetTicks()"); > > -- memcpy(currentTime, &tpmData.stany.data.currentTicks, > > -- sizeof(TPM_CURRENT_TICKS)); > > -- return TPM_SUCCESS; > > -+ return TPM_DISABLED_CMD; > > - } > > - > > - TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay, > > -@@ -49,64 +48,11 @@ TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN > > - TPM_CURRENT_TICKS *currentTicks, > > - UINT32 *sigSize, BYTE **sig) > > - { > > -- TPM_RESULT res; > > -- TPM_KEY_DATA *key; > > -- BYTE *info, *p; > > -- UINT32 info_length, length; > > - info("TPM_TickStampBlob()"); > > -- /* get key */ > > -- key = tpm_get_key(keyHandle); > > -- if (key == NULL) return TPM_INVALID_KEYHANDLE; > > -- /* verify authorization */ > > -- res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); > > -- if (res != TPM_SUCCESS) return res; > > -- if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY > > -- && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE; > > -- /* get current ticks */ > > -- TPM_GetTicks(currentTicks); > > -- /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */ > > -- *sigSize = key->key.size >> 3; > > -- *sig = tpm_malloc(*sigSize); > > -- if (*sig == NULL) return TPM_FAIL; > > -- /* setup TPM_SIGN_INFO structure */ > > -- info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks); > > -- info = tpm_malloc(info_length); > > -- if (info == NULL) { > > -- tpm_free(*sig); > > -- return TPM_FAIL; > > -- } > > -- memcpy(&info[0], "\x05\x00TSTP", 6); > > -- memcpy(&info[6], antiReplay->nonce, 20); > > -- *(UINT32*)&info[26] = CPU_TO_BE32(20 > > -- + sizeof_TPM_CURRENT_TICKS(currentTicks)); > > -- memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST)); > > -- p = &info[30 + sizeof(TPM_DIGEST)]; > > -- length = sizeof_TPM_CURRENT_TICKS(currentTicks); > > -- if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks) > > -- || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) { > > -- tpm_free(*sig); > > -- tpm_free(info); > > -- return TPM_FAIL; > > -- } > > -- return TPM_SUCCESS; > > -+ return TPM_DISABLED_CMD; > > - } > > - > > - void tpm_update_ticks(void) > > - { > > -- if (tpmData.stany.data.currentTicks.tag == 0) { > > -- tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS; > > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > > --/* removed since v1.2 rev 94 > > -- tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType; > > --*/ > > -- tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce, > > -- sizeof(TPM_NONCE)); > > -- tpmData.stany.data.currentTicks.tickRate = 1; > > --/* removed since v1.2 rev 94 > > -- tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK; > > --*/ > > -- } else { > > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > > -- } > > - } > > - > > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c > > ---- orig/tpm_emulator-0.4/tpm/tpm_transport.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm/tpm_transport.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -189,7 +189,7 @@ static void decrypt_wrapped_command(BYTE > > - sha1_init(&sha1); > > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > > -- sha1_update(&sha1, "in", 2); > > -+ sha1_update(&sha1, (BYTE*)"in", 2); > > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > > - j = CPU_TO_BE32(i); > > - sha1_update(&sha1, (BYTE*)&j, 4); > > -@@ -211,7 +211,7 @@ static void encrypt_wrapped_command(BYTE > > - sha1_init(&sha1); > > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > > -- sha1_update(&sha1, "out", 3); > > -+ sha1_update(&sha1, (BYTE*)"out", 3); > > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > > - j = CPU_TO_BE32(i); > > - sha1_update(&sha1, (BYTE*)&j, 4); > > -diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c > > ---- orig/tpm_emulator-0.4/tpmd.c 1969-12-31 16:00:00.000000000 -0800 > > -+++ tpm_emulator/tpmd.c 2006-07-24 14:35:35.000000000 -0700 > > -@@ -0,0 +1,156 @@ > > -+/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > -+ * Copyright (C) 2005 INTEL Corp > > -+ * > > -+ * This module is free software; you can redistribute it and/or modify > > -+ * it under the terms of the GNU General Public License as published > > -+ * by the Free Software Foundation; either version 2 of the License, > > -+ * or (at your option) any later version. > > -+ * > > -+ * This module is distributed in the hope that it will be useful, > > -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of > > -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > -+ * GNU General Public License for more details. > > -+ * > > -+ */ > > -+ > > -+#include > > -+#include > > -+#include > > -+#include > > -+#include > > -+#include > > -+#include > > -+#include > > -+ > > -+#include "tpm_emulator.h" > > -+ > > -+#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > > -+#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > > -+ > > -+#define BUFFER_SIZE 2048 > > -+ > > -+static int devurandom=0; > > -+ > > -+void get_random_bytes(void *buf, int nbytes) { > > -+ > > -+ if (devurandom == 0) { > > -+ devurandom = open("/dev/urandom", O_RDONLY); > > -+ } > > -+ > > -+ if (read(devurandom, buf, nbytes) != nbytes) { > > -+ printf("Can't get random number.\n"); > > -+ exit(-1); > > -+ } > > -+} > > -+ > > -+uint64_t tpm_get_ticks(void) > > -+{ > > -+ //struct timeval tv; > > -+ //int gettimeofday(&tv, struct timezone *tz); > > -+ return 0; > > -+} > > -+ > > -+int main(int argc, char **argv) > > -+{ > > -+ uint8_t in[BUFFER_SIZE], *out; > > -+ uint32_t out_size; > > -+ int in_size, written; > > -+ int i; > > -+ struct stat file_info; > > -+ > > -+ int tpm_tx_fh=-1, tpm_rx_fh=-1; > > -+ if (argc < 2) { > > -+ printf("Usage: tpmd clear|save|deactivated\n" ); > > -+ return -1; > > -+ } > > -+ > > -+ /* initialize TPM emulator */ > > -+ if (!strcmp(argv[1], "clear")) { > > -+ printf("Initializing tpm: %s\n", argv[1]); > > -+ tpm_emulator_init(1); > > -+ } else if (!strcmp(argv[1], "save")) { > > -+ printf("Initializing tpm: %s\n", argv[1]); > > -+ tpm_emulator_init(2); > > -+ } else if (!strcmp(argv[1], "deactivated")) { > > -+ printf("Initializing tpm: %s\n", argv[1]); > > -+ tpm_emulator_init(3); > > -+ } else { > > -+ printf("invalid startup mode '%s'; must be 'clear', " > > -+ "'save' (default) or 'deactivated", argv[1]); > > -+ return -1; > > -+ } > > -+ > > -+ if ( stat(TPM_RX_FNAME, &file_info) == -1) { > > -+ if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > > -+ printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > > -+ return -1; > > -+ } > > -+ } > > -+ > > -+ if ( stat(TPM_TX_FNAME, &file_info) == -1) { > > -+ if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > > -+ printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > > -+ return -1; > > -+ } > > -+ } > > -+ > > -+ while (1) { > > -+abort_command: > > -+ if (tpm_rx_fh < 0) { > > -+ tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > > -+ } > > -+ > > -+ if (tpm_rx_fh < 0) { > > -+ printf("ERROR: failed to open devices to listen to guest.\n"); > > -+ return -1; > > -+ } > > -+ > > -+ if (tpm_tx_fh < 0) { > > -+ tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > > -+ } > > -+ > > -+ if (tpm_tx_fh < 0) { > > -+ printf("ERROR: failed to open devices to respond to guest.\n"); > > -+ return -1; > > -+ } > > -+ > > -+ in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > > -+ if (in_size < 6) { // Magic size of minium TPM command > > -+ printf("Recv[%d] to small: 0x", in_size); > > -+ if (in_size <= 0) { > > -+ close(tpm_rx_fh); > > -+ tpm_rx_fh = -1; > > -+ goto abort_command; > > -+ } > > -+ } else { > > -+ printf("Recv[%d]: 0x", in_size); > > -+ for (i=0; i< in_size; i++) > > -+ printf("%x ", in[i]); > > -+ printf("\n"); > > -+ } > > -+ > > -+ > > -+ if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > > -+ printf("ERROR: Handler Failed.\n"); > > -+ } > > -+ > > -+ written = write(tpm_tx_fh, out, out_size); > > -+ > > -+ if (written != out_size ) { > > -+ printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > > -+ } else { > > -+ printf("Sent[%Zu]: ", out_size); > > -+ } > > -+ for (i=0; i< out_size; i++) > > -+ printf("%x ", out[i]); > > -+ printf("\n"); > > -+ tpm_free(out); > > -+ > > -+ } // loop > > -+ > > -+ tpm_emulator_shutdown(); > > -+ > > -+ close(tpm_tx_fh); > > -+ close(tpm_rx_fh); > > -+ > > -+} > > -Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ > > -diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h > > ---- orig/tpm_emulator-0.4/tpm_version.h 2006-06-23 03:37:07.000000000 -0700 > > -+++ tpm_emulator/tpm_version.h 2006-07-24 14:35:41.000000000 -0700 > > -@@ -2,5 +2,5 @@ > > - #define _TPM_VERSION_H_ > > - #define VERSION_MAJOR 0 > > - #define VERSION_MINOR 4 > > --#define VERSION_BUILD 1151058734 > > -+#define VERSION_BUILD 1153776940 > > - #endif /* _TPM_VERSION_H_ */ > > diff --git a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch b/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > > deleted file mode 100644 > > index 95586c1..0000000 > > --- a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > > +++ /dev/null > > @@ -1,12 +0,0 @@ > > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm_emulator-0.5.1/tpmd/Makefile > > ---- tpm_emulator-0.5.1/tpmd/Makefile > > -+++ tpm_emulator-0.5.1/tpmd/Makefile > > -@@ -8,7 +8,7 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > > - CFLAGS += -I../../../../tools/vtpm_manager/manager > > --LDFLAGS += -lgmp > > -+LDLIBS += -lgmp > > - > > - BINDIR := /usr/bin/ > > - > > diff --git a/tools/vtpm/vtpm-0.5.1.patch b/tools/vtpm/vtpm-0.5.1.patch > > deleted file mode 100644 > > index 2aeb745..0000000 > > --- a/tools/vtpm/vtpm-0.5.1.patch > > +++ /dev/null > > @@ -1,766 +0,0 @@ > > -diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile > > ---- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 > > -+++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 > > -@@ -10,7 +10,7 @@ VERSION_MINOR := 5 > > - VERSION_BUILD := $(shell date +"%s") > > - VERSION_SUFFIX := .1 > > - > > --SUBDIRS := tpmd tpmd_dev tddl > > -+SUBDIRS := tpmd > > - > > - all: version all-recursive > > - > > -@@ -48,12 +48,12 @@ user_install: user > > - modules_install: modules > > - @$(MAKE) -C tpmd_dev install || exit -1 > > - > > --DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd > > -+DIRS := . tpm crypto tpmd > > - DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) > > - DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) > > --DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd > > -+DIRS := . tpmd > > - DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) > > --DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in > > -+DISTSRC += ./README ./AUTHORS ./ChangeLog > > - DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) > > - > > - dist: $(DISTSRC) > > -diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c > > ---- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 > > -+++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 > > -@@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su > > - > > - case TPM_CAP_PROP_TIS_TIMEOUT: > > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > > -- return TPM_FAIL; > > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > > -+ UINT32 len = *respSize = 16; > > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > > -+ if (ptr == NULL || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > > -+ tpm_free(*resp); > > -+ return TPM_FAIL; > > -+ } > > -+ return TPM_SUCCESS; > > -+ > > - > > - case TPM_CAP_PROP_STARTUP_EFFECT: > > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > > -@@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su > > - > > - case TPM_CAP_PROP_DURATION: > > - debug("[TPM_CAP_PROP_DURATION]"); > > -- /* TODO: TPM_CAP_PROP_DURATION */ > > -- return TPM_FAIL; > > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > > -+ *respSize = 16; > > -+ *resp = tpm_malloc(*respSize); > > -+ memcpy(*resp,dur,16); > > -+ > > - > > - case TPM_CAP_PROP_ACTIVE_COUNTER: > > - debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); > > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile > > ---- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 > > -+++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 > > -@@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > > - -Wwrite-strings -Wsign-compare -Wno-multichar > > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > > -+CFLAGS += -I../../../../tools/vtpm_manager/manager > > - LDFLAGS += -lgmp > > - > > --BINDIR := /usr/sbin/ > > -+BINDIR := /usr/bin/ > > - > > - TPMD := tpmd > > - DIRS := ../tpm ../crypto > > -@@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil > > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > > - OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) > > - > > -+VTPM_BIN := vtpmd > > -+ > > - vpath %.c $(strip $(DIRS)) > > - > > - all: $(TPMD) > > -@@ -32,10 +35,8 @@ TPMD_GROUP ?= tss > > - INSTALL ?= install > > - > > - install: $(TPMD) > > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm > > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm > > - $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) > > -- $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) > > -+ $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) > > - > > - .PHONY: all clean install > > - > > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c > > ---- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 > > -+++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 > > -@@ -32,6 +32,9 @@ > > - #include > > - #include "tpm_emulator_config.h" > > - #include "tpm/tpm_emulator.h" > > -+#include "tpm/tpm_structures.h" > > -+#include "tpm/tpm_marshalling.h" > > -+#include "vtpm_manager.h" > > - > > - #define TPM_DAEMON_NAME "tpmd" > > - #define TPM_CMD_BUF_SIZE 4096 > > -@@ -39,6 +42,24 @@ > > - #define TPM_RANDOM_DEVICE "/dev/urandom" > > - #undef TPM_MKDIRS > > - > > -+#ifdef VTPM_MULTI_VM > > -+ #define DEV_BE "/dev/vtpm" > > -+ #define DEV_FE "/dev/tpm" > > -+#else > > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > > -+ > > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > > -+ > > -+ static char *vtpm_rx_name=NULL; > > -+#endif > > -+ > > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > > -+ > > -+#define BUFFER_SIZE 2048 > > -+ > > - static volatile int stopflag = 0; > > - static int is_daemon = 0; > > - static int opt_debug = 0; > > -@@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ > > - static uid_t opt_uid = 0; > > - static gid_t opt_gid = 0; > > - static int tpm_startup = 2; > > -+static int vtpm_type = VTPM_TYPE_PVM; > > -+int dmi_id = 0; > > - static int rand_fh; > > - > > - void tpm_log(int priority, const char *fmt, ...) > > -@@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) > > - > > - int tpm_write_to_file(uint8_t *data, size_t data_length) > > - { > > -- int fh; > > -- ssize_t res; > > -- fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > > -- if (fh < 0) return -1; > > -- while (data_length > 0) { > > -- res = write(fh, data, data_length); > > -- if (res < 0) { > > -- close(fh); > > -- return -1; > > -- } > > -- data_length -= res; > > -- data += res; > > -+ int res, out_data_size, in_header_size; > > -+ BYTE *ptr, *out_data, *in_header; > > -+ UINT32 result, len, in_rsp_size; > > -+ UINT16 tag = VTPM_TAG_REQ; > > -+ > > -+ printf("Saving NVM\n"); > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > > -+#else > > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_tx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Send request to VTPM Manager to encrypt data > > -+#ifdef VTPM_MUTLI_VM > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > > -+#else > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > > -+#endif > > -+ > > -+ out_data = ptr = (BYTE *) malloc(len); > > -+ > > -+ if (ptr == NULL > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > > -+#endif > > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > > -+#ifdef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > > -+#else > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > > -+#endif > > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > > -+ free(out_data); > > -+ return -1; > > -+ } > > -+ > > -+ printf("\tSending SaveNVM Command.\n"); > > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > > -+ free(out_data); > > -+ if (res != out_data_size) return -1; > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = vtpm_tx_fh > > -+#else > > -+ if (vtpm_rx_name == NULL) { > > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > > - } > > -- close(fh); > > -- return 0; > > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Read Header of response so we can get the size & status > > -+#ifdef VTPM_MUTLI_VM > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ in_header = ptr = malloc(in_header_size); > > -+ > > -+ printf("\tReading SaveNVM header.\n"); > > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > > -+ > > -+ if ( (res != in_header_size) > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > > -+#endif > > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > > -+ free(in_header); > > -+ return -1; > > -+ } > > -+ free(in_header); > > -+ > > -+ if (result != VTPM_SUCCESS) { > > -+ return -1; > > -+ } > > -+ > > -+#ifdef VTPM_MUTLI_VM > > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > > -+#endif > > -+ > > -+ printf("\tFinishing up SaveNVM\n"); > > -+ return (0); > > - } > > - > > - int tpm_read_from_file(uint8_t **data, size_t *data_length) > > - { > > -- int fh; > > -- ssize_t res; > > -- size_t total_length; > > -- fh = open(opt_storage_file, O_RDONLY); > > -- if (fh < 0) return -1; > > -- total_length = lseek(fh, 0, SEEK_END); > > -- lseek(fh, 0, SEEK_SET); > > -- *data = tpm_malloc(total_length); > > -- if (*data == NULL) { > > -- close(fh); > > -- return -1; > > -- } > > -- *data_length = 0; > > -- while (total_length > 0) { > > -- res = read(fh, &(*data)[*data_length], total_length); > > -- if (res < 0) { > > -- close(fh); > > -- tpm_free(*data); > > -- return -1; > > -- } > > -- *data_length += res; > > -- total_length -= res; > > -+ int res, out_data_size, in_header_size; > > -+ uint8_t *ptr, *out_data, *in_header; > > -+ UINT16 tag = VTPM_TAG_REQ; > > -+ UINT32 len, in_rsp_size, result; > > -+#ifdef VTPM_MUTLI_VM > > -+ int vtpm_rx_fh, vtpm_tx_fh; > > -+#endif > > -+ > > -+ printf("Loading NVM.\n"); > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > > -+#else > > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_tx_fh < 0) { > > -+ printf("Error in read_from_file:301\n"); > > -+ return -1; > > -+ } > > -+ > > -+ // Send request to VTPM Manager to encrypt data > > -+#ifdef VTPM_MUTLI_VM > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ out_data = ptr = (BYTE *) malloc(len); > > -+ > > -+ if (ptr == NULL > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > > -+#endif > > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > > -+#ifdef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > > -+#else > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > > -+#endif > > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > > -+ free(out_data); > > -+ printf("Error in read_from_file:325\n"); > > -+ > > -+ return -1; > > -+ } > > -+ > > -+ printf("\tSending LoadNVM command\n"); > > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > > -+ free(out_data); > > -+ if (res != out_data_size) > > -+ { > > -+ printf("Error in read_from_file:335\n"); > > -+ return -1; > > -+ } > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = vtpm_tx_fh; > > -+#else > > -+ if (vtpm_rx_name == NULL) { > > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > > - } > > -- close(fh); > > -- return 0; > > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+ printf("Error in read_from_file:352\n"); > > -+ return -1; > > -+ } > > -+ > > -+ // Read Header of response so we can get the size & status > > -+#ifdef VTPM_MUTLI_VM > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ in_header = ptr = malloc(in_header_size); > > -+ > > -+ printf("\tReading LoadNVM header\n"); > > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > > -+ > > -+ if ( (res != in_header_size) > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > > -+#endif > > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > > -+ free(in_header); > > -+ printf("Error in read_from_file:375\n"); > > -+ return -1; > > -+ } > > -+ free(in_header); > > -+ > > -+ if (result != VTPM_SUCCESS) { > > -+ printf("Error in read_from_file:381\n"); > > -+ return -1; > > -+ } > > -+ > > -+ // Read Encrypted data from VTPM Manager > > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > > -+ *data = (uint8_t *) malloc(*data_length); > > -+ > > -+ printf("\tReading clear data from LoadNVM.\n"); > > -+ res = read(vtpm_rx_fh, *data, *data_length); > > -+#ifdef VTPM_MUTLI_VM > > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > > -+#endif > > -+ > > -+ printf("\tReturing from loading NVM\n"); > > -+ if (res != (int)*data_length) { > > -+ free(*data); > > -+ printf("Error in read_from_file:398\n"); > > -+ return -1; > > -+ } else { > > -+ return 0; > > -+ } > > -+ > > -+ > > -+ > > - } > > - > > - static void print_usage(char *name) > > - { > > - printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " > > -- "[-o user name] [-g group name] [-h] [startup mode]\n", name); > > -+ "[-o user name] [-g group name] [-h]" > > -+#ifdef VTPM_MULTI_VM > > -+ "clear|save|deactivated\n", name); > > -+#else > > -+ "clear|save|deactivated pvm|hvm vtpmid\n", name); > > -+#endif > > - printf(" d : enable debug mode\n"); > > - printf(" f : forces the application to run in the foreground\n"); > > - printf(" s : storage file to use (default: %s)\n", opt_storage_file); > > -@@ -205,7 +413,13 @@ static void parse_options(int argc, char > > - exit(EXIT_SUCCESS); > > - } > > - } > > -- if (optind < argc) { > > -+ /*Make sure we have all required options*/ > > -+#ifdef VTPM_MULTI_VM > > -+#define EXTRA_OPTS 0 > > -+#else > > -+#define EXTRA_OPTS 2 > > -+#endif > > -+ if (optind < argc - EXTRA_OPTS ) { > > - debug("startup mode = '%s'", argv[optind]); > > - if (!strcmp(argv[optind], "clear")) { > > - tpm_startup = 1; > > -@@ -219,6 +433,25 @@ static void parse_options(int argc, char > > - print_usage(argv[0]); > > - exit(EXIT_SUCCESS); > > - } > > -+#ifndef VTPM_MULTI_VM > > -+ ++optind; > > -+ if(!strcmp(argv[optind], "pvm")) { > > -+ vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > > -+ } else if (!strcmp(argv[optind], "hvm")) { > > -+ vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket > > -+ } else { > > -+ error("Invalid vm mode '%s'; must be 'pvm', " > > -+ "or 'hvm' ", argv[optind]); > > -+ print_usage(argv[0]); > > -+ exit(EXIT_SUCCESS); > > -+ } > > -+ ++optind; > > -+ dmi_id = atoi(argv[optind]); > > -+#endif > > -+ } else { > > -+ error("Invalid number of arguments"); > > -+ print_usage(argv[0]); > > -+ exit(EXIT_SUCCESS); > > - } > > - } > > - > > -@@ -348,93 +581,180 @@ static int init_socket(const char *name) > > - > > - static void main_loop(void) > > - { > > -- int sock, fh, res; > > -- int32_t in_len; > > -+ int32_t in_len, written; > > - uint32_t out_len; > > -- uint8_t in[TPM_CMD_BUF_SIZE], *out; > > -+ uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; > > -+ int guest_id=-1; > > -+ int i; > > -+ char *vtpm_rx_file=NULL; > > -+ int res; > > -+ > > -+#ifndef VTPM_MULTI_VM > > -+ int sockfd = -1; > > - struct sockaddr_un addr; > > -- socklen_t addr_len; > > -- fd_set rfds; > > -- struct timeval tv; > > -+ struct sockaddr_un client_addr; > > -+ unsigned int client_length; > > -+#endif > > -+ > > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > > -+ > > -+#ifndef VTPM_MULTI_VM > > -+ if (vtpm_type == VTPM_TYPE_PVM) { > > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ } else { > > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ > > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > > -+ error("Unable to create socket. errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ memset(&addr, 0, sizeof(addr)); > > -+ addr.sun_family = AF_UNIX; > > -+ strcpy(addr.sun_path,vtpm_rx_file ); > > -+ unlink(addr.sun_path); > > -+ } > > -+#endif > > - > > - info("staring main loop"); > > -- /* open UNIX socket */ > > -- sock = init_socket(opt_socket_name); > > -- if (sock < 0) exit(EXIT_FAILURE); > > - /* init tpm emulator */ > > -- debug("initializing TPM emulator: %d", tpm_startup); > > -+#ifdef VTPM_MULTI_VM > > -+ debug("initializing TPM emulator: state=%d", tpm_startup); > > -+#else > > -+ debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); > > -+#endif > > - tpm_emulator_init(tpm_startup); > > - /* start command processing */ > > - while (!stopflag) { > > - /* wait for incomming connections */ > > - debug("waiting for connections..."); > > -- FD_ZERO(&rfds); > > -- FD_SET(sock, &rfds); > > -- tv.tv_sec = 10; > > -- tv.tv_usec = 0; > > -- res = select(sock + 1, &rfds, NULL, NULL, &tv); > > -- if (res < 0) { > > -- error("select(sock) failed: %s", strerror(errno)); > > -- break; > > -- } else if (res == 0) { > > -- continue; > > -- } > > -- addr_len = sizeof(addr); > > -- fh = accept(sock, (struct sockaddr*)&addr, &addr_len); > > -- if (fh < 0) { > > -- error("accept() failed: %s", strerror(errno)); > > -- continue; > > -- } > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > > -+#else > > -+ if (vtpm_type == VTPM_TYPE_PVM) > > -+ { > > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > > -+ } else { > > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > > -+ error("Unable to bind(). errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ if (listen(sockfd, 10) <0) { > > -+ error("Unable to listen(). errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ memset(&client_addr, 0, sizeof(client_addr)); > > -+ client_length = sizeof(client_addr); > > -+ > > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > > -+ } > > -+#endif > > -+ } > > -+ > > -+ /*Error Checking*/ > > -+ if (vtpm_rx_fh < 0) { > > -+ error("Failed to open devices to listen to guest.\n"); > > -+ exit(-1); > > -+ } > > -+ > > - /* receive and handle commands */ > > - in_len = 0; > > - do { > > - debug("waiting for commands..."); > > -- FD_ZERO(&rfds); > > -- FD_SET(fh, &rfds); > > -- tv.tv_sec = TPM_COMMAND_TIMEOUT; > > -- tv.tv_usec = 0; > > -- res = select(fh + 1, &rfds, NULL, NULL, &tv); > > -- if (res < 0) { > > -- error("select(fh) failed: %s", strerror(errno)); > > -- close(fh); > > -- break; > > -- } else if (res == 0) { > > --#ifdef TPMD_DISCONNECT_IDLE_CLIENTS > > -- info("connection closed due to inactivity"); > > -- close(fh); > > -- break; > > --#else > > -- continue; > > --#endif > > -- } > > -- in_len = read(fh, in, sizeof(in)); > > -- if (in_len > 0) { > > -+ > > -+ in_len = read(vtpm_rx_fh, in, sizeof(in)); > > -+ /*Magic size of minimum TPM command is 6*/ > > -+ //FIXME Magic size check may not be required anymore > > -+ if (in_len < 6) { > > -+ info("Recv incomplete command of %d bytes.", in_len); > > -+ if (in_len <= 0) { > > -+ close(vtpm_rx_fh); > > -+ vtpm_rx_fh = -1; > > -+ continue; > > -+ } > > -+ } else { > > -+ /*Debug Printouts*/ > > - debug("received %d bytes", in_len); > > -+ debug_nostop("Recv[%d]: 0x", in_len); > > -+ for (i=0; i< in_len; i++) > > -+ debug_more("%x ", in[i]); > > -+ debug_more("\n"); > > -+ /*Multiple Guest check*/ > > -+ if (guest_id == -1) { > > -+ guest_id = *((int32_t *) in); > > -+ } else { > > -+ if (guest_id != *((int32_t *) in) ) { > > -+ error("WARNING: More than one guest attached\n"); > > -+ } > > -+ } > > -+ > > -+ /*Open tx handle now*/ > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > > -+ vtpm_rx_fh = vtpm_tx_fh; > > -+#else > > -+ if (vtpm_type == VTPM_TYPE_PVM) { > > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > > -+ } // No need to open the other direction for HVM > > -+#endif > > -+ } > > -+ if (vtpm_tx_fh < 0) { > > -+ error("Failed to open devices to respond to guest.\n"); > > -+ exit(-1); > > -+ } > > -+ > > -+ /*Handle the TPM command now*/ > > - out = NULL; > > -- res = tpm_handle_command(in, in_len, &out, &out_len); > > -+ res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); > > - if (res < 0) { > > - error("tpm_handle_command() failed"); > > - } else { > > - debug("sending %d bytes", out_len); > > -+ //FIXME this prepending may or may not be needed > > -+ /*Prepend the first 4 bytes of the in buffer.. why?*/ > > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); > > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_len); > > -+ out_len += sizeof(uint32_t); > > -+ /*End Prepend*/ > > -+ > > -+ /*Perform write operation now*/ > > - while (out_len > 0) { > > -- res = write(fh, out, out_len); > > -+ res = write(vtpm_tx_fh, addressed_out, out_len); > > -+ > > - if (res < 0) { > > - error("write(%d) failed: %s", out_len, strerror(errno)); > > - break; > > -- } > > -+ } else { > > -+ debug_nostop("Sent[%Zu]: ", out_len); > > -+ for (i=0; (unsigned int)i< out_len; i++) > > -+ debug_more("%x ", addressed_out[i]); > > -+ debug_more("\n"); > > -+ } > > - out_len -= res; > > - } > > - tpm_free(out); > > -+ tpm_free(addressed_out); > > - } > > - } > > - } while (in_len > 0); > > -- close(fh); > > -+ //close(fh); > > - } > > -+ > > - /* shutdown tpm emulator */ > > - tpm_emulator_shutdown(); > > -- /* close socket */ > > -- close(sock); > > -- unlink(opt_socket_name); > > -+ /* Close handles */ > > -+ close(vtpm_tx_fh); > > -+#ifndef VTPM_MULTI_VM > > -+ close(vtpm_rx_fh); > > -+ free(vtpm_rx_file); > > -+#endif > > - info("main loop stopped"); > > - } > > - > > -@@ -450,12 +770,13 @@ int main(int argc, char **argv) > > - /* open random device */ > > - init_random(); > > - /* init signal handlers */ > > -- init_signal_handler(); > > -+ //init_signal_handler(); > > - /* unless requested otherwiese, fork and daemonize process */ > > -- if (!opt_foreground) daemonize(); > > -+ //if (!opt_foreground) daemonize(); > > - /* start main processing loop */ > > - main_loop(); > > - info("stopping TPM Emulator daemon"); > > - closelog(); > > - return 0; > > - } > > -+ > > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h > > ---- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 > > -+++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 > > -@@ -29,23 +29,28 @@ > > - > > - /* TPM emulator configuration */ > > - > > --#undef TPM_STRONG_PERSISTENCE > > --#undef TPM_GENERATE_EK > > -+#define TPM_STRONG_PERSISTENCE > > -+#define TPM_GENERATE_EK > > - #undef TPM_GENERATE_SEED_DAA > > - #undef TPM_MEMORY_ALIGNMENT_MANDATORY > > - > > -+extern int dmi_id; > > -+ > > - /* log macros */ > > - > > - void tpm_log(int priority, const char *fmt, ...); > > - > > --#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > --#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > --#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > --#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) > > - > > - /* min/max macros that also do strict type-checking */ > > - > > diff --git a/tools/vtpm/vtpm.patch b/tools/vtpm/vtpm.patch > > deleted file mode 100644 > > index e896b25..0000000 > > --- a/tools/vtpm/vtpm.patch > > +++ /dev/null > > @@ -1,716 +0,0 @@ > > -diff -uprN tpm_emulator/AUTHORS vtpm/AUTHORS > > ---- tpm_emulator/AUTHORS 2006-12-08 12:51:29.000000000 -0800 > > -+++ vtpm/AUTHORS 2006-12-13 16:38:52.000000000 -0800 > > -@@ -1,3 +1,3 @@ > > - Mario Strasser > > - Heiko Stamer [DAA] > > --INTEL Corp <> [Dropped to Ring3] > > -+INTEL Corp <> [VTPM Extensions] > > -diff -uprN tpm_emulator/ChangeLog vtpm/ChangeLog > > ---- tpm_emulator/ChangeLog 2006-12-08 12:51:29.000000000 -0800 > > -+++ vtpm/ChangeLog 2006-12-13 16:38:52.000000000 -0800 > > -@@ -1,5 +1,6 @@ > > - ????-??-?? Intel Corp > > - * Moved module out of kernel to run as a ring 3 app > > -+ * Modified save_to_file and load_from_file to call xen VTPM manager > > - > > - 2006-06-23 Mario Strasser > > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > > -diff -uprN tpm_emulator/linux_module.h vtpm/linux_module.h > > ---- tpm_emulator/linux_module.h 2006-12-08 12:51:29.000000000 -0800 > > -+++ vtpm/linux_module.h 2007-01-09 14:49:06.000000000 -0800 > > -@@ -44,18 +44,26 @@ > > - #define TPM_DEVICE_NAME "tpm" > > - #define TPM_MODULE_NAME "tpm_emulator" > > - > > -+/* debug and log output functions */ > > -+extern int dmi_id; > > -+ > > - #ifdef DEBUG > > --#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug_nostop(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt, \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define debug_more(fmt, ...) printf( fmt, ## __VA_ARGS__ ) > > - #else > > - #define debug(fmt, ...) > > -+#define debug_nostop(fmt, ...) > > -+#define debug_more(fmt, ...) > > - #endif > > --#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > --#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > --#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > > -- __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define info(fmt, ...) printf("TPMD[%d]: %s:%d: Info: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define error(fmt, ...) printf("TPMD[%d]: %s:%d: Error: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > -+#define alert(fmt, ...) printf("TPMD[%d]: %s:%d: Alert: " fmt "\n", \ > > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > > - > > - /* memory allocation */ > > - > > -diff -uprN tpm_emulator/Makefile vtpm/Makefile > > ---- tpm_emulator/Makefile 2006-12-08 12:51:29.000000000 -0800 > > -+++ vtpm/Makefile 2006-12-13 16:38:52.000000000 -0800 > > -@@ -7,7 +7,7 @@ > > - COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > > - > > - # module settings > > --BIN := tpm_emulator > > -+BIN := vtpmd > > - VERSION_MAJOR := 0 > > - VERSION_MINOR := 4 > > - VERSION_BUILD := $(shell date +"%s") > > -@@ -22,7 +22,7 @@ TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > > - > > - CC := gcc > > - CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > > --CFLAGS += -I. -Itpm > > -+CFLAGS += -I. -Itpm -I../../vtpm_manager/manager > > - > > - # Is the simulator running in it's own vm? > > - #CFLAGS += -DVTPM_MULTI_VM > > -@@ -62,7 +62,6 @@ $(BIN): $(src)/crypto/gmp.h $(src)/crypt > > - > > - install: $(BIN) > > - $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > > -- @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > > - > > - clean: > > - rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > > -@@ -98,3 +97,4 @@ version: > > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > > - > > - .PHONY: all install clean dist gmp version > > -+ > > -diff -uprN tpm_emulator/tpm/tpm_capability.c vtpm/tpm/tpm_capability.c > > ---- tpm_emulator/tpm/tpm_capability.c 2006-06-23 03:37:07.000000000 -0700 > > -+++ vtpm/tpm/tpm_capability.c 2007-01-10 10:00:49.000000000 -0800 > > -@@ -136,8 +136,18 @@ static TPM_RESULT cap_property(UINT32 su > > - > > - case TPM_CAP_PROP_TIS_TIMEOUT: > > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > > -- return TPM_FAIL; > > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > > -+ UINT32 len = *respSize = 16; > > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > > -+ if (ptr == NULL || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > > -+ tpm_free(*resp); > > -+ return TPM_FAIL; > > -+ } > > -+ return TPM_SUCCESS; > > - > > - case TPM_CAP_PROP_STARTUP_EFFECT: > > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > > -@@ -190,7 +200,11 @@ static TPM_RESULT cap_property(UINT32 su > > - > > - case TPM_CAP_PROP_DURATION: > > - debug("[TPM_CAP_PROP_DURATION]"); > > -- /* TODO: TPM_CAP_PROP_DURATION */ > > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > > -+ *respSize = 16; > > -+ *resp = tpm_malloc(*respSize); > > -+ memcpy(*resp,dur,16); > > - return TPM_FAIL; > > - > > - case TPM_CAP_PROP_ACTIVE_COUNTER: > > -diff -uprN tpm_emulator/tpm/tpm_cmd_handler.c vtpm/tpm/tpm_cmd_handler.c > > ---- tpm_emulator/tpm/tpm_cmd_handler.c 2008-02-27 16:35:41.000000000 -0500 > > -+++ vtpm/tpm/tpm_cmd_handler.c 2008-02-28 14:43:28.000000000 -0500 > > -@@ -94,12 +94,18 @@ void tpm_compute_out_param_digest(TPM_CO > > - sha1_ctx_t sha1; > > - UINT32 res = CPU_TO_BE32(rsp->result); > > - UINT32 ord = CPU_TO_BE32(ordinal); > > -+ UINT32 offset = 0; > > - > > - /* compute SHA1 hash */ > > - sha1_init(&sha1); > > - sha1_update(&sha1, (BYTE*)&res, 4); > > - sha1_update(&sha1, (BYTE*)&ord, 4); > > -- sha1_update(&sha1, rsp->param, rsp->paramSize); > > -+ if (ordinal == TPM_ORD_LoadKey2) { > > -+ offset = 4; > > -+ } > > -+ if (rsp->paramSize - offset > 0) { > > -+ sha1_update(&sha1, rsp->param + offset, rsp->paramSize - offset); > > -+ } > > - sha1_final(&sha1, rsp->auth1->digest); > > - if (rsp->auth2 != NULL) memcpy(rsp->auth2->digest, > > - rsp->auth1->digest, sizeof(rsp->auth1->digest)); > > -diff -uprN tpm_emulator/tpm/tpm_data.c vtpm/tpm/tpm_data.c > > ---- tpm_emulator/tpm/tpm_data.c 2008-02-27 16:35:41.000000000 -0500 > > -+++ vtpm/tpm/tpm_data.c 2008-02-27 16:35:40.000000000 -0500 > > -@@ -1,6 +1,7 @@ > > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > > - * Copyright (C) 2004 Mario Strasser , > > - * Swiss Federal Institute of Technology (ETH) Zurich > > -+ * Copyright (C) 2005 INTEL Corp > > - * > > - * This module is free software; you can redistribute it and/or modify > > - * it under the terms of the GNU General Public License as published > > -@@ -15,10 +16,15 @@ > > - * $Id: tpm_data.c 98 2006-05-07 14:16:29Z hstamer $ > > - */ > > - > > -+#include > > -+#include > > -+#include > > -+#include > > -+ > > - #include "tpm_emulator.h" > > - #include "tpm_structures.h" > > - #include "tpm_marshalling.h" > > --#include "linux_module.h" > > -+#include "vtpm_manager.h" > > - > > - TPM_DATA tpmData; > > - > > -@@ -158,45 +164,232 @@ void tpm_release_data(void) > > - #include > > - #include > > - #include > > --#include > > - > > --#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > > -+ > > -+#ifdef VTPM_MUTLI_VM > > -+ #define DEV_FE "/dev/tpm" > > -+#else > > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > > -+ > > -+ extern int dmi_id; > > -+ static char *vtpm_rx_name=NULL; > > -+#endif > > - > > - static int write_to_file(uint8_t *data, size_t data_length) > > - { > > -- int res; > > -- int fp; > > -- fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > > -- res = write(fp, data, data_length); > > -- close(fp); > > -- return (res == data_length) ? 0 : -1; > > -+ int res, out_data_size, in_header_size; > > -+ BYTE *ptr, *out_data, *in_header; > > -+ UINT32 result, len, in_rsp_size; > > -+ UINT16 tag = VTPM_TAG_REQ; > > -+ > > -+ printf("Saving NVM\n"); > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > > -+#else > > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_tx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Send request to VTPM Manager to encrypt data > > -+#ifdef VTPM_MUTLI_VM > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > > -+#else > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > > -+#endif > > -+ > > -+ out_data = ptr = (BYTE *) malloc(len); > > -+ > > -+ if (ptr == NULL > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > > -+#endif > > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > > -+#ifdef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > > -+#else > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > > -+#endif > > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > > -+ free(out_data); > > -+ return -1; > > -+ } > > -+ > > -+ printf("\tSending SaveNVM Command.\n"); > > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > > -+ free(out_data); > > -+ if (res != out_data_size) return -1; > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = vtpm_tx_fh > > -+#else > > -+ if (vtpm_rx_name == NULL) { > > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ } > > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Read Header of response so we can get the size & status > > -+#ifdef VTPM_MUTLI_VM > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ in_header = ptr = malloc(in_header_size); > > -+ > > -+ printf("\tReading SaveNVM header.\n"); > > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > > -+ > > -+ if ( (res != in_header_size) > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > > -+#endif > > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > > -+ free(in_header); > > -+ return -1; > > -+ } > > -+ free(in_header); > > -+ > > -+ if (result != VTPM_SUCCESS) { > > -+ return -1; > > -+ } > > -+ > > -+#ifdef VTPM_MUTLI_VM > > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > > -+#endif > > -+ > > -+ printf("\tFinishing up SaveNVM\n"); > > -+ return (0); > > - } > > - > > - static int read_from_file(uint8_t **data, size_t *data_length) > > - { > > -- int res; > > -- int fp, file_status; > > -- struct stat file_info; > > -- fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > > -- file_status = fstat(fp, &file_info); > > -- if (file_status < 0) { > > -- close(fp); > > -- return -1; > > -- } > > -+ int res, out_data_size, in_header_size; > > -+ uint8_t *ptr, *out_data, *in_header; > > -+ UINT16 tag = VTPM_TAG_REQ; > > -+ UINT32 len, in_rsp_size, result; > > -+#ifdef VTPM_MUTLI_VM > > -+ int vtpm_rx_fh, vtpm_tx_fh; > > -+#endif > > -+ > > -+ printf("Loading NVM.\n"); > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > > -+#else > > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > > -+#endif > > -+ } > > - > > -- *data_length = file_info.st_size; > > -- *data = tpm_malloc(*data_length); > > -- if (*data == NULL) { > > -- close(fp); > > -+ if (vtpm_tx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Send request to VTPM Manager to encrypt data > > -+#ifdef VTPM_MUTLI_VM > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ out_data = ptr = (BYTE *) malloc(len); > > -+ > > -+ if (ptr == NULL > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > > -+#endif > > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > > -+#ifdef VTPM_MUTLI_VM > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > > -+#else > > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > > -+#endif > > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > > -+ free(out_data); > > - return -1; > > - } > > -- res = read(fp, *data, *data_length); > > -- close(fp); > > -+ > > -+ printf("\tSending LoadNVM command\n"); > > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > > -+ free(out_data); > > -+ if (res != out_data_size) return -1; > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = vtpm_tx_fh; > > -+#else > > -+ if (vtpm_rx_name == NULL) { > > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ } > > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_rx_fh < 0) { > > -+ return -1; > > -+ } > > -+ > > -+ // Read Header of response so we can get the size & status > > -+#ifdef VTPM_MUTLI_VM > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > > -+#else > > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > > -+#endif > > -+ in_header = ptr = malloc(in_header_size); > > -+ > > -+ printf("\tReading LoadNVM header\n"); > > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > > -+ > > -+ if ( (res != in_header_size) > > -+#ifndef VTPM_MUTLI_VM > > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > > -+#endif > > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > > -+ free(in_header); > > -+ return -1; > > -+ } > > -+ free(in_header); > > -+ > > -+ if (result != VTPM_SUCCESS) { > > -+ return -1; > > -+ } > > -+ > > -+ // Read Encrypted data from VTPM Manager > > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > > -+ *data = (uint8_t *) malloc(*data_length); > > -+ > > -+ printf("\tReading clear data from LoadNVM.\n"); > > -+ res = read(vtpm_rx_fh, *data, *data_length); > > -+#ifdef VTPM_MUTLI_VM > > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > > -+#endif > > -+ > > -+ printf("\tReturing from loading NVM\n"); > > - if (res != *data_length) { > > -- tpm_free(*data); > > -- return -1; > > -+ free(*data); > > -+ return -1; > > -+ } else { > > -+ return 0; > > - } > > -- return 0; > > -+ > > - } > > - > > - #else > > -diff -uprN tpm_emulator/tpmd.c vtpm/tpmd.c > > ---- tpm_emulator/tpmd.c 2006-12-08 12:51:29.000000000 -0800 > > -+++ vtpm/tpmd.c 2007-01-09 14:48:56.000000000 -0800 > > -@@ -21,12 +21,24 @@ > > - #include > > - #include > > - #include > > -+#include > > -+#include > > -+#include > > - > > - #include "tpm_emulator.h" > > -+#include "vtpm_manager.h" > > - > > --#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > > --#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > > -+#ifdef VTPM_MULTI_VM > > -+ #define DEV_BE "/dev/vtpm" > > -+#else > > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > > - > > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > > -+#endif > > -+ > > -+ int dmi_id; > > -+ > > - #define BUFFER_SIZE 2048 > > - > > - static int devurandom=0; > > -@@ -38,7 +50,7 @@ void get_random_bytes(void *buf, int nby > > - } > > - > > - if (read(devurandom, buf, nbytes) != nbytes) { > > -- printf("Can't get random number.\n"); > > -+ error("Can't get random number.\n"); > > - exit(-1); > > - } > > - } > > -@@ -52,105 +64,182 @@ uint64_t tpm_get_ticks(void) > > - > > - int main(int argc, char **argv) > > - { > > -- uint8_t in[BUFFER_SIZE], *out; > > -+ uint8_t type, in[BUFFER_SIZE], *out, *addressed_out; > > -+ char *vtpm_rx_file=NULL; > > - uint32_t out_size; > > - int in_size, written; > > -- int i; > > -- struct stat file_info; > > -+ int i, guest_id=-1; > > - > > -- int tpm_tx_fh=-1, tpm_rx_fh=-1; > > -+#ifndef VTPM_MULTI_VM > > -+ int sockfd = -1; > > -+ struct sockaddr_un addr; > > -+ struct sockaddr_un client_addr; > > -+ unsigned int client_length; > > -+ > > -+#endif > > -+ > > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > > -+#ifdef VTPM_MULTI_VM > > - if (argc < 2) { > > -- printf("Usage: tpmd clear|save|deactivated\n" ); > > -+ error("Usage: tpmd clear|save|deactivated\n" ); > > -+#else > > -+ if (argc < 4) { > > -+ error("Usage: tpmd clear|save|deactivated pvm|hvm vtpmid\n" ); > > -+#endif > > - return -1; > > - } > > - > > -+#ifndef VTPM_MULTI_VM > > -+ /* setup type of vm */ > > -+ if (!strcmp(argv[2], "pvm")) { > > -+ type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > > -+ } else if (!strcmp(argv[2], "hvm")) { > > -+ type = VTPM_TYPE_HVM; // Get commands from qemu via socket > > -+ } else { > > -+ error("invalid vTPM type '%s'.\n", argv[2]); > > -+ } > > -+ > > -+ dmi_id = atoi(argv[3]); > > -+ > > -+ if (type == VTPM_TYPE_PVM) { > > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ } else { > > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > > -+ > > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > > -+ error("Unable to create socket. errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ memset(&addr, 0, sizeof(addr)); > > -+ addr.sun_family = AF_UNIX; > > -+ strcpy(addr.sun_path,vtpm_rx_file ); > > -+ unlink(addr.sun_path); > > -+ } > > -+#endif > > -+ > > -+#ifdef VTPM_MULTI_VM > > -+ info("Initializing tpm state: %s\n", argv[1]); > > -+#else > > -+ info("Initializing tpm state: %s, type: %s, id: %d\n", argv[1], argv[2], dmi_id); > > -+#endif > > -+ > > - /* initialize TPM emulator */ > > - if (!strcmp(argv[1], "clear")) { > > -- printf("Initializing tpm: %s\n", argv[1]); > > - tpm_emulator_init(1); > > -- } else if (!strcmp(argv[1], "save")) { > > -- printf("Initializing tpm: %s\n", argv[1]); > > -+ } else if (!strcmp(argv[1], "save")) { > > - tpm_emulator_init(2); > > - } else if (!strcmp(argv[1], "deactivated")) { > > -- printf("Initializing tpm: %s\n", argv[1]); > > - tpm_emulator_init(3); > > - } else { > > -- printf("invalid startup mode '%s'; must be 'clear', " > > -+ error("invalid startup mode '%s'; must be 'clear', " > > - "'save' (default) or 'deactivated", argv[1]); > > - return -1; > > - } > > -- > > -- if ( stat(TPM_RX_FNAME, &file_info) == -1) { > > -- if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > > -- printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > > -- return -1; > > -- } > > -- } > > -- > > -- if ( stat(TPM_TX_FNAME, &file_info) == -1) { > > -- if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > > -- printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > > -- return -1; > > -- } > > -- } > > -- > > -+ > > - while (1) { > > - abort_command: > > -- if (tpm_rx_fh < 0) { > > -- tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > > -+ if (vtpm_rx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > > -+#else > > -+ if (type == VTPM_TYPE_PVM) { > > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > > -+ } else { > > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > > -+ error("Unable to bind(). errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ if (listen(sockfd, 10) <0) { > > -+ error("Unable to listen(). errno = %d\n", errno); > > -+ exit (-1); > > -+ } > > -+ > > -+ memset(&client_addr, 0, sizeof(client_addr)); > > -+ client_length = sizeof(client_addr); > > -+ > > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > > -+ } > > -+#endif > > - } > > - > > -- if (tpm_rx_fh < 0) { > > -- printf("ERROR: failed to open devices to listen to guest.\n"); > > -+ if (vtpm_rx_fh < 0) { > > -+ error("Failed to open devices to listen to guest.\n"); > > - return -1; > > - } > > - > > -- if (tpm_tx_fh < 0) { > > -- tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > > -- } > > -- > > -- if (tpm_tx_fh < 0) { > > -- printf("ERROR: failed to open devices to respond to guest.\n"); > > -- return -1; > > -- } > > -- > > -- in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > > -+ in_size = read(vtpm_rx_fh, in, BUFFER_SIZE); > > - if (in_size < 6) { // Magic size of minium TPM command > > -- printf("Recv[%d] to small: 0x", in_size); > > -+ info("Recv incomplete command of %d bytes.", in_size); > > - if (in_size <= 0) { > > -- close(tpm_rx_fh); > > -- tpm_rx_fh = -1; > > -+ close(vtpm_rx_fh); > > -+ vtpm_rx_fh = -1; > > - goto abort_command; > > - } > > - } else { > > -- printf("Recv[%d]: 0x", in_size); > > -+ debug_nostop("Recv[%d]: 0x", in_size); > > - for (i=0; i< in_size; i++) > > -- printf("%x ", in[i]); > > -- printf("\n"); > > -+ debug_more("%x ", in[i]); > > -+ debug_more("\n"); > > - } > > - > > -- > > -- if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > > -- printf("ERROR: Handler Failed.\n"); > > -+ if (guest_id == -1) { > > -+ guest_id = *((uint32_t *) in); > > -+ } else { > > -+ if (guest_id != *((uint32_t *) in) ) { > > -+ error("WARNING: More than one guest attached\n"); > > -+ } > > -+ } > > -+ > > -+ if (vtpm_tx_fh < 0) { > > -+#ifdef VTPM_MUTLI_VM > > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > > -+ vtpm_rx_fh = vtpm_tx_fh; > > -+#else > > -+ if (type == VTPM_TYPE_PVM) { > > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > > -+ } // No need to open the other direction for HVM > > -+#endif > > -+ } > > -+ > > -+ if (vtpm_tx_fh < 0) { > > -+ error("Failed to open devices to respond to guest.\n"); > > -+ return -1; > > -+ } > > -+ > > -+ // Handle the command, but skip the domain id header > > -+ if (tpm_handle_command(in + sizeof(uint32_t), in_size - sizeof(uint32_t), &out, &out_size) != 0) { > > -+ error("Handler Failed.\n"); > > - } > > - > > -- written = write(tpm_tx_fh, out, out_size); > > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_size); > > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_size); > > -+ > > -+ written = write(vtpm_tx_fh, addressed_out, out_size + sizeof(uint32_t)); > > - > > -- if (written != out_size ) { > > -- printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > > -+ if (written != out_size + sizeof(uint32_t)) { > > -+ error("Part of response not written %d/%d.\n", written, out_size); > > - } else { > > -- printf("Sent[%Zu]: ", out_size); > > -+ debug_nostop("Sent[%Zu]: ", out_size + sizeof(uint32_t)); > > -+ for (i=0; i< out_size+ sizeof(uint32_t); i++) > > -+ debug_more("%x ", addressed_out[i]); > > -+ debug_more("\n"); > > - } > > -- for (i=0; i< out_size; i++) > > -- printf("%x ", out[i]); > > -- printf("\n"); > > - tpm_free(out); > > -+ tpm_free(addressed_out); > > - > > - } // loop > > - > > - tpm_emulator_shutdown(); > > - > > -- close(tpm_tx_fh); > > -- close(tpm_rx_fh); > > -+ close(vtpm_tx_fh); > > -+#ifndef VTPM_MUTLI_VM > > -+ close(vtpm_rx_fh); > > -+ free (vtpm_rx_file); > > -+#endif > > - > > - } > > diff --git a/tools/vtpm_manager/COPYING b/tools/vtpm_manager/COPYING > > deleted file mode 100644 > > index c4b86b7..0000000 > > --- a/tools/vtpm_manager/COPYING > > +++ /dev/null > > @@ -1,32 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > diff --git a/tools/vtpm_manager/Makefile b/tools/vtpm_manager/Makefile > > deleted file mode 100644 > > index 632f41b..0000000 > > --- a/tools/vtpm_manager/Makefile > > +++ /dev/null > > @@ -1,18 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../.. > > - > > -# Base definitions and rules > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -SUBDIRS = crypto tcs util manager migration > > -OPENSSL_HEADER = /usr/include/openssl/crypto.h > > - > > -.PHONY: all clean install > > -all clean install: %: subdirs-% > > - > > -.PHONY: mrproper > > -mrproper: > > - @set -e; for subdir in $(SUBDIRS); do \ > > - $(MAKE) -C $$subdir $@; \ > > - done > > - > > - > > diff --git a/tools/vtpm_manager/README b/tools/vtpm_manager/README > > deleted file mode 100644 > > index f0d1e98..0000000 > > --- a/tools/vtpm_manager/README > > +++ /dev/null > > @@ -1,94 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -Directory Structure > > -=================== > > -tools/vtpm_manager/crypto -> crypto files > > -tools/vtpm_manager/TCS -> TCS implementation > > -tools/vtpm_manager/util -> Utility Library. Include disk-io and buffers. > > -tools/vtpm_manager/manager -> VTPM Manager > > - > > -Compile Flags > > -=================== > > -LOGGING_MODULES -> How extensive logging happens > > - see util/log.h for more info > > - > > -VTPM_MULTI_VM -> Defined: VTPMs run in their own VMs > > - Not Defined (default): VTPMs are processes > > - > > -# Debugging flags that may disappear without notice in the future > > - > > -DUMMY_BACKEND -> vtpm_manager listens on /tmp/in.fifo and > > - /tmp/out.fifo rather than backend > > - > > -MANUAL_DM_LAUNCH -> Must manually launch & kill VTPMs > > - > > -WELL_KNOWN_OWNER_AUTH -> Rather than randomly generating the password for the owner, > > - use a well known value. This is useful for debugging and for > > - poor bios which do not support clearing TPM if OwnerAuth is > > - lost. However this has no protection from malicious app > > - issuing a TPM_OwnerClear to wipe the TPM > > - > > -Requirements > > -============ > > -- xen-unstable > > -- vtpm frontend/backend driver patch > > -- OpenSSL Library > > - > > -Single-VM Flow > > -============================ > > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > > -- VTPM Manager listens to TPM BE. > > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > > -- When the manager receives the open message from the BE, it launches a vtpm > > -- Xend allows the VM to continue booting. > > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > > -- The fifo listener begins listening for the reply from vtpm for the request. > > -- Vtpm processes request and replies to manager over shared named fifo. > > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > > - > > -NOTES: > > -* SaveService SHOULD seal it's table before saving it to disk. However, > > - the current Xen infrastructure does not provide a mechanism for this to be > > - unsealed later. Specifically, the auth and wrapped key must be available ONLY > > - to the service, or it's not even worth encrypting > > - > > - In the future the vtpm manager will be protected by an early boot mechanism > > - that will allow for better protection of it's data. > > - > > -TODO: > > -- Timeout on crashed vtpms > > -- create lock for shared fifo for talking to vtpms. > > diff --git a/tools/vtpm_manager/Rules.mk b/tools/vtpm_manager/Rules.mk > > deleted file mode 100644 > > index 651772b..0000000 > > --- a/tools/vtpm_manager/Rules.mk > > +++ /dev/null > > @@ -1,59 +0,0 @@ > > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > > -include $(XEN_ROOT)/tools/Rules.mk > > - > > -# > > -# Tool definitions > > -# > > - > > -# General compiler flags > > -CFLAGS = -Werror -g3 > > - > > -# Generic project files > > -HDRS = $(wildcard *.h) > > -SRCS = $(wildcard *.c) > > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > > - > > -# Generic (non-header) dependencies > > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -$(OBJS): $(SRCS) > > - > > --include $(FILES) > > - > > -# Make sure these are just rules > > -.PHONY : all build install clean > > - > > -# > > -# Project-specific definitions > > -# > > - > > -# Need UNIX98 spec for pthread rwlocks > > -CFLAGS += -D_GNU_SOURCE > > - > > -# Logging Level. See utils/tools.h for usage > > -CFLAGS += -DLOGGING_MODULES="(BITMASK(VTPM_LOG_TCS)|BITMASK(VTPM_LOG_VTSP)|BITMASK(VTPM_LOG_VTPM))" > > - > > -# Silent Mode > > -#CFLAGS += -DLOGGING_MODULES=0x0 > > -#CFLAGS += -DLOGGING_MODULES=0xff > > - > > -# Use frontend/backend pairs between manager & DMs? > > -#CFLAGS += -DVTPM_MULTI_VM > > - > > -# vtpm_manager listens on fifo's rather than backend > > -#CFLAGS += -DDUMMY_BACKEND > > - > > -# TCS talks to fifo's rather than /dev/tpm. TPM Emulator assumed on fifos > > -#CFLAGS += -DDUMMY_TPM > > - > > -# Do not have manager launch DMs. > > -#CFLAGS += -DMANUAL_DM_LAUNCH > > - > > -# Fixed OwnerAuth > > -#CFLAGS += -DWELL_KNOWN_OWNER_AUTH > > - > > -# Include > > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/crypto > > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/util > > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/tcs > > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/manager > > diff --git a/tools/vtpm_manager/crypto/Makefile b/tools/vtpm_manager/crypto/Makefile > > deleted file mode 100644 > > index 13b61c9..0000000 > > --- a/tools/vtpm_manager/crypto/Makefile > > +++ /dev/null > > @@ -1,24 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../../.. > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -BIN = libtcpaCrypto.a > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: $(BIN) > > - > > -.PHONY: install > > -install: build > > - > > -.PHONY: clean > > -clean: > > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > > - > > -.PHONY: mrproper > > -mrproper: clean > > - rm -f *~ > > - > > -$(BIN): $(OBJS) > > - $(AR) rcs $(BIN) $(OBJS) > > diff --git a/tools/vtpm_manager/crypto/crypto.c b/tools/vtpm_manager/crypto/crypto.c > > deleted file mode 100644 > > index 7dae655..0000000 > > --- a/tools/vtpm_manager/crypto/crypto.c > > +++ /dev/null > > @@ -1,88 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// crypto.c > > -// > > -// This file will handle all the TPM Crypto functionality > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include "crypto.h" > > -#include "log.h" > > - > > -/** > > - * Initialize cryptography library > > - * @rand: random seed > > - * @size: size of @rand > > - */ > > -void Crypto_Init(const BYTE* rand, int size) { > > - ERR_load_crypto_strings(); > > - CRYPTO_malloc_init(); > > - OpenSSL_add_all_algorithms(); > > - SYM_CIPHER = EVP_aes_128_cbc(); > > - RAND_poll(); > > - if (rand == NULL) > > - return; > > - > > - RAND_add(rand, size, size); > > -} > > - > > -/** > > - * Shutdown cryptography library > > - */ > > -void Crypto_Exit() { > > - ERR_free_strings(); > > - ERR_remove_state(0); > > - EVP_cleanup(); > > -} > > - > > - > > -/** > > - * Get random data > > - * @data: (OUT) Random data > > - * @size: Size of @data > > - */ > > -void Crypto_GetRandom(void* data, int size) { > > - int result; > > - > > - result = RAND_pseudo_bytes((BYTE*) data, size); > > - > > - if (result <= 0) > > - vtpmlogerror (VTPM_LOG_CRYPTO, "RAND_pseudo_bytes failed: %s\n", > > - ERR_error_string (ERR_get_error(), NULL)); > > -} > > diff --git a/tools/vtpm_manager/crypto/crypto.h b/tools/vtpm_manager/crypto/crypto.h > > deleted file mode 100644 > > index 488d4d6..0000000 > > --- a/tools/vtpm_manager/crypto/crypto.h > > +++ /dev/null > > @@ -1,175 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// crypto.h > > -// > > -// This file defines the TPM Crypto API > > -// > > -// ================================================================== > > - > > -#ifndef __CRYPTO_H__ > > -#define __CRYPTO_H__ > > - > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "sym_crypto.h" > > - > > -#define CRYPTO_MAX_SIG_SIZE (2048 / 8) > > -#define CRYPTO_MAX_RSA_KEY_SIZE (4096 / 8) //in bytes > > - > > -#define OAEP_P "TCPA" > > -#define OAEP_P_SIZE 4 > > - > > -// Algorithms supported by crypto. Stored in CRYPTO_INFO.algorithmID > > -#define CRYPTO_ALGORITH_RSA 0x01 > > - > > -// Supported Encryption Schemes CRYPTO_INFO.encScheme > > -#define CRYPTO_ES_NONE 0x0001 > > -#define CRYPTO_ES_RSAESPKCSv15 0x0002 > > -#define CRYPTO_ES_RSAESOAEP_SHA1_MGF1 0x0003 > > - > > -// Supported Signature schemes CRYPTO_INFO.sigScheme > > -#define CRYPTO_SS_NONE 0x0001 > > -#define CRYPTO_SS_RSASSAPKCS1v15_SHA1 0x0002 > > -#define CRYPTO_SS_RSASSAPKCS1v15_DER 0x0003 > > - > > -typedef struct CRYPTO_INFO { > > - void *keyInfo; > > - UINT32 algorithmID; > > - UINT32 encScheme; > > - UINT32 sigScheme; > > -} CRYPTO_INFO; > > - > > - > > -void Crypto_Init(const BYTE* rand, int size); > > - > > -void Crypto_Exit(); > > - > > -void Crypto_GetRandom(void* data, int size); > > - > > -void Crypto_HMAC( const BYTE* text, > > - int text_len, > > - const BYTE* key, > > - int key_len, > > - BYTE* digest); > > - > > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > > - const buffer_t * key, > > - BYTE * o_digest); /* presumably of 20 bytes */ > > - > > -void Crypto_SHA1Full( const BYTE* text, > > - UINT32 size, > > - BYTE* hash); //Complete 3part SHA1 > > - > > -// o_hash needs to be large enough to hold the digest, ie 20 bytes > > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > > - BYTE * o_hash); > > - > > -void Crypto_SHA1Start(UINT32* maxNumBytes); > > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData); > > -void Crypto_SHA1Complete( int hashDataSize, > > - const BYTE* hashData, > > - BYTE* hashValue); > > - > > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > > - /*in*/ UINT32 pubExpSize, > > - /*in*/ BYTE *pubExp, > > - /*out*/ UINT32 *privExpSize, > > - /*out*/ BYTE *privExp, > > - /*out*/ UINT32 *modulusSize, > > - /*out*/ BYTE *modulus, > > - /*out*/ CRYPTO_INFO *keys); > > - > > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > > - /*[IN]*/ BYTE *pubExp, > > - /*[IN]*/ UINT32 privExpSize, > > - /*[IN]*/ BYTE *privExp, > > - /*[IN]*/ UINT32 modulusSize, > > - /*[IN]*/ BYTE *modulus, > > - /*[OUT]*/ CRYPTO_INFO* cryptoInfo); > > - > > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > > - /*[IN]*/ BYTE *pubExp, > > - /*[IN]*/ UINT32 modulusSize, > > - /*[IN]*/ BYTE *modulus, > > - CRYPTO_INFO* cryptoInfo); > > - > > -// > > -// symmetric pack and unpack operations > > -// > > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > > - BYTE ** io_buf, UINT32 * io_buflen); > > - > > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > > - BYTE * in, UINT32 len, > > - UINT32 * o_lenread); > > - > > - > > -// return 0 on success, -1 on error > > -int Crypto_RSAEnc( CRYPTO_INFO *keys, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *outDataSize, > > - /*out*/ BYTE *outData); > > - > > -// return 0 on success, -1 on error > > -int Crypto_RSADec( CRYPTO_INFO *keys, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *outDataSize, > > - /*out*/ BYTE *outData); > > - > > -// return 0 on success, -1 on error > > -int Crypto_RSASign( CRYPTO_INFO *keys, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *sigSize, > > - /*out*/ BYTE *sig); > > - > > -bool Crypto_RSAVerify( CRYPTO_INFO *keys, > > - UINT32 inDataSize, > > - BYTE *inData, > > - UINT32 sigSize, > > - BYTE *sig); > > - > > -//private: > > -int RSA_verify_DER(int dtype, unsigned char *m, unsigned int m_len, > > - unsigned char *sigbuf, unsigned int siglen, CRYPTO_INFO *key); > > - > > -int RSA_sign_DER(int type, unsigned char *m, unsigned int m_len, > > - unsigned char *sigret, unsigned int *siglen, CRYPTO_INFO *key); > > - > > -#endif // __CRYPTO_H__ > > diff --git a/tools/vtpm_manager/crypto/hash.c b/tools/vtpm_manager/crypto/hash.c > > deleted file mode 100644 > > index c73114a..0000000 > > --- a/tools/vtpm_manager/crypto/hash.c > > +++ /dev/null > > @@ -1,153 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// hash.c > > -// > > -// This file will handle all the TPM Hash functionality > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" // for TPM_SUCCESS > > -#include "crypto.h" > > - > > -static SHA_CTX g_shaContext; > > - > > -void Crypto_HMAC( const BYTE* text, > > - int text_len, > > - const BYTE* key, > > - int key_len, > > - BYTE* digest) { > > - if (text == NULL || key == NULL || text_len == 0 || key_len == 0) > > - return; > > - > > - HMAC(EVP_sha1(), key, key_len, text, text_len, digest, NULL); > > -} > > - > > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > > - const buffer_t * key, > > - BYTE * o_digest) { /* presumably of 20 bytes */ > > - > > - Crypto_HMAC (text->bytes, text->size, > > - key->bytes, key->size, > > - o_digest); > > - > > - return TPM_SUCCESS; > > -} > > - > > - > > -/* > > - * SHA1 > > - * (OUT) Create a SHA1 hash of text. Calls all three SHA1 steps internally > > - */ > > -void Crypto_SHA1Full( const BYTE* text, > > - uint32_t size, > > - BYTE* hash) { > > - > > - if (text == NULL || size == 0) > > - return; > > - > > - // Run SHA1Start + SHAUpdate (if necessary) + SHAComplete > > - uint32_t maxBytes; // Not used for anything > > - Crypto_SHA1Start(&maxBytes); > > - > > - while (size > 64){ > > - Crypto_SHA1Update(64, text); > > - size -= 64; > > - text += 64; > > - } > > - > > - Crypto_SHA1Complete(size, text, hash); > > -} > > - > > -// same thing using buffer_t > > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > > - BYTE * o_digest) { > > - > > - if (buf->bytes == NULL || buf->size == 0) > > - return TPM_BAD_PARAMETER; > > - > > - Crypto_SHA1Full (buf->bytes, buf->size, o_digest); > > - > > - return TPM_SUCCESS; > > -} > > - > > - > > -/* > > - * Initialize SHA1 > > - * (OUT) Maximum number of bytes that can be sent to SHA1Update. > > - * Must be a multiple of 64 bytes. > > - */ > > -void Crypto_SHA1Start(uint32_t* maxNumBytes) { > > - int max = SHA_CBLOCK; > > - // Initialize the crypto library > > - SHA1_Init(&g_shaContext); > > - *maxNumBytes = max; > > -} > > - > > -/* > > - * Process SHA1 > > - * @numBytes: (IN) The number of bytes in hashData. > > - * Must be a multiple of 64 bytes. > > - * @hashData: (IN) Bytes to be hashed. > > - */ > > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData) { > > - > > - if (hashData == NULL || numBytes == 0 || numBytes%64 != 0) > > - return; > > - > > - SHA1_Update(&g_shaContext, hashData, numBytes); > > -} > > - > > -/* > > - * Complete the SHA1 process > > - * @hashDataSize: (IN) Number of bytes in hashData. > > - * Must be a multiple of 64 bytes. > > - * @hashData: (IN) Final bytes to be hashed. > > - * @hashValue: (OUT) The output of the SHA-1 hash. > > - */ > > -void Crypto_SHA1Complete(int hashDataSize, > > - const BYTE* hashData, > > - BYTE* hashValue) { > > - SHA1_Update(&g_shaContext, hashData, hashDataSize); > > - SHA1_Final(hashValue, &g_shaContext); > > -} > > diff --git a/tools/vtpm_manager/crypto/rsa.c b/tools/vtpm_manager/crypto/rsa.c > > deleted file mode 100644 > > index 7737dc6..0000000 > > --- a/tools/vtpm_manager/crypto/rsa.c > > +++ /dev/null > > @@ -1,434 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// rsa.c > > -// > > -// This file will handle all the TPM RSA crypto functionality > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "buffer.h" > > -#include "crypto.h" > > -#include "log.h" > > - > > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > > - /*in*/ UINT32 pubExpSize, > > - /*in*/ BYTE *pubExp, > > - /*out*/ UINT32 *privExpSize, > > - /*out*/ BYTE *privExp, > > - /*out*/ UINT32 *modulusSize, > > - /*out*/ BYTE *modulus, > > - /*out*/ CRYPTO_INFO *keys) { > > - unsigned long e_value; > > - > > - if (pubExpSize == 0) // Default e = 2^16+1 > > - e_value = (0x01 << 16) + 1; > > - else { > > - // This is not supported, but the following line MIGHT work > > - // under then assumption that the format is BigNum compatable > > - // Though it's not in the spec, so who knows what it is. > > - // Forcing the default. > > - //BN_bin2bn(pubExp, pubExpSize, NULL); > > - e_value = (0x01 << 16) + 1; > > - } > > - > > - RSA *rsa = RSA_generate_key(keySize, e_value, NULL, NULL); > > - > > - if (keys) { > > - keys->keyInfo = rsa; > > - keys->algorithmID = CRYPTO_ALGORITH_RSA; > > - } > > - > > - if (modulus) *modulusSize = BN_bn2bin(rsa->n, modulus); > > - if (privExp) *privExpSize = BN_bn2bin(rsa->d, privExp); > > -} > > - > > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > > -// If pubExp info is NULL, use TCG default. > > -// If there is a remainder while calculating the privExp, return FALSE. > > - > > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > > - /*[IN]*/ BYTE *pubExp, > > - /*[IN]*/ UINT32 privExpSize, > > - /*[IN]*/ BYTE *privExp, > > - /*[IN]*/ UINT32 modulusSize, > > - /*[IN]*/ BYTE *modulus, > > - CRYPTO_INFO* cryptoInfo) { > > - cryptoInfo->keyInfo = RSA_new(); > > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > > - > > - rsa->e = BN_new(); > > - > > - if (pubExpSize == 0) { // Default e = 2^16+1 > > - BN_set_bit(rsa->e, 16); > > - BN_set_bit(rsa->e, 0); > > - } else { > > - // This is not supported, but the following line MIGHT work > > - // under then assumption that the format is BigNum compatable > > - // Though it's not in the spec, so who knows what it is. > > - // Forcing the default. > > - //BN_bin2bn(pubExp, pubExpSize, NULL); > > - BN_set_bit(rsa->e, 16); > > - BN_set_bit(rsa->e, 0); > > - } > > - > > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > > - rsa->d = BN_bin2bn(privExp, privExpSize, NULL); > > -} > > - > > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > > -// If pubExp info is NULL, use TCG default. > > -// If there is a remainder while calculating the privExp, return FALSE. > > - > > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > > - /*[IN]*/ BYTE *pubExp, > > - /*[IN]*/ UINT32 modulusSize, > > - /*[IN]*/ BYTE *modulus, > > - CRYPTO_INFO* cryptoInfo) { > > - cryptoInfo->keyInfo = RSA_new(); > > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > > - > > - rsa->e = BN_new(); > > - > > - if (pubExpSize == 0) { // Default e = 2^16+1 > > - BN_set_bit(rsa->e, 16); > > - BN_set_bit(rsa->e, 0); > > - } else { > > - // This is not supported, but the following line MIGHT work > > - // under then assumption that the format is BigNum compatable > > - // Though it's not in the spec, so who knows what it is. > > - // Forcing the default. > > - //BN_bin2bn(pubExp, pubExpSize, NULL); > > - BN_set_bit(rsa->e, 16); > > - BN_set_bit(rsa->e, 0); > > - } > > - > > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > > - > > -} > > - > > -int Crypto_RSAEnc( CRYPTO_INFO *key, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *outDataSize, > > - /*out*/ BYTE *outData) { > > - RSA *rsa = (RSA *) key->keyInfo; > > - UINT32 paddedDataSize = RSA_size (rsa); > > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > > - int rc; > > - > > - if (paddedData == NULL) > > - return -1; > > - > > - *outDataSize = 0; > > - > > - switch (key->encScheme) { > > - case CRYPTO_ES_RSAESPKCSv15: > > - if (RSA_padding_add_PKCS1_type_2(paddedData, paddedDataSize, inData, inDataSize) <= 0) { > > - rc = -1; > > - goto abort_egress; > > - } > > - break; > > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > > - if (RSA_padding_add_PKCS1_OAEP(paddedData,paddedDataSize,inData,inDataSize, (BYTE *) OAEP_P,OAEP_P_SIZE) <= 0 ) { > > - rc = -1; > > - goto abort_egress; > > - } > > - break; > > - default: > > - rc = -1; > > - goto abort_egress; > > - } > > - > > - rc = RSA_public_encrypt(paddedDataSize, paddedData, outData, rsa, RSA_NO_PADDING); > > - if (rc == -1) > > - goto abort_egress; > > - > > - *outDataSize = rc; > > - > > - if (rc > 0) rc = 0; > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - if (paddedData) > > - free (paddedData); > > - return rc; > > - > > -} > > - > > -int Crypto_RSADec( CRYPTO_INFO *key, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *outDataSize, > > - /*out*/ BYTE *outData) { > > - > > - RSA *rsa = (RSA *) key->keyInfo; > > - UINT32 paddedDataSize = RSA_size (rsa); > > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > > - int rc; > > - > > - if (paddedData == NULL) > > - goto abort_egress; > > - > > - rc = RSA_private_decrypt(inDataSize, inData, paddedData, rsa, RSA_NO_PADDING); > > - if (rc == -1) { > > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_private_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); > > - goto abort_egress; > > - } > > - > > - paddedDataSize = rc; > > - > > - switch (key->encScheme) { > > - case CRYPTO_ES_RSAESPKCSv15: > > - rc = RSA_padding_check_PKCS1_type_2 (outData, paddedDataSize, > > - paddedData + 1, paddedDataSize - 1, > > - RSA_size(rsa)); > > - if (rc == -1) { > > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_type_2: %s\n", > > - ERR_error_string(ERR_get_error(), NULL)); > > - goto abort_egress; > > - } > > - *outDataSize = rc; > > - break; > > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > > - rc = RSA_padding_check_PKCS1_OAEP(outData, paddedDataSize, > > - paddedData + 1, paddedDataSize - 1, > > - RSA_size(rsa), > > - (BYTE *) OAEP_P, OAEP_P_SIZE); > > - if (rc == -1) { > > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_OAEP: %s\n", > > - ERR_error_string(ERR_get_error(), NULL)); > > - goto abort_egress; > > - } > > - *outDataSize = rc; > > - break; > > - default: > > - *outDataSize = 0; > > - } > > - > > - free(paddedData); paddedData = NULL; > > - goto egress; > > - > > - abort_egress: > > - > > - if (paddedData) > > - free (paddedData); > > - return -1; > > - > > - egress: > > - return 0; > > -} > > - > > -// Signs either a SHA1 digest of a message or a DER encoding of a message > > -// Textual messages MUST be encoded or Hashed before sending into this function > > -// It will NOT SHA the message. > > -int Crypto_RSASign( CRYPTO_INFO *key, > > - UINT32 inDataSize, > > - BYTE *inData, > > - /*out*/ UINT32 *sigSize, > > - /*out*/ BYTE *sig) { > > - int status; > > - unsigned int intSigSize; > > - > > - switch(key->sigScheme) { > > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > > - status = RSA_sign(NID_sha1, inData, inDataSize, sig, &intSigSize, (RSA *) key->keyInfo); > > - break; > > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > > - // status = Crypto_RSA_sign_DER(NID_md5_sha1, inData, inDataSize, sig, &intSigSize, key); > > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > > - status = 0; > > - break; > > - default: > > - status = 0; > > - } > > - > > - if (status == 0) { > > - *sigSize = 0; > > - vtpmlogerror(VTPM_LOG_CRYPTO, "%s\n", ERR_error_string(ERR_get_error(), NULL)); > > - return -1; > > - } > > - > > - *sigSize = (UINT32) intSigSize; > > - return 0; > > -} > > - > > -bool Crypto_RSAVerify( CRYPTO_INFO *key, > > - UINT32 inDataSize, > > - BYTE *inData, > > - UINT32 sigSize, > > - BYTE *sig) { > > - int status; > > - > > - switch(key->sigScheme){ > > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > > - status = RSA_verify(NID_sha1, inData, inDataSize, sig, sigSize, (RSA *) key->keyInfo); > > - break; > > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > > - //status = Crypto_RSA_verify_DER(NID_md5_sha1, inData, inDataSize, sig, sigSize, key); > > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > > - status = 0; > > - break; > > - default: > > - status = 0; > > - } > > - > > - if (status) > > - return(1); > > - else { > > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA verify: %s\n", ERR_error_string(ERR_get_error(), NULL)); > > - return(0); > > - } > > - > > -} > > - > > -// helper which packs everything into a BIO! > > - > > -// packs the parameters first, then the private key, then the public key > > -// if *io_buf is NULL, allocate it here as needed. otherwise its size is in > > -// *io_buflen > > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > > - BYTE ** io_buf, UINT32 * io_buflen) { > > - TPM_RESULT status = TPM_SUCCESS; > > - BYTE * buf; > > - long len, outlen = *io_buflen; > > - > > - const long PARAMSLEN = 3*sizeof(UINT32); > > - > > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > > - > > - BIO *mem = BIO_new(BIO_s_mem()); > > - > > - > > - // write the openssl keys to the BIO > > - if ( i2d_RSAPrivateKey_bio (mem, rsa) == 0 ) { > > - ERR_print_errors_fp (stderr); > > - ERRORDIE (TPM_SIZE); > > - } > > - if ( i2d_RSAPublicKey_bio (mem, rsa) == 0 ) { > > - ERR_print_errors_fp (stderr); > > - ERRORDIE (TPM_SIZE); > > - } > > - > > - // get the buffer out > > - len = BIO_get_mem_data (mem, &buf); > > - > > - // see if we need to allocate a return buffer > > - if (*io_buf == NULL) { > > - *io_buf = (BYTE*) malloc (PARAMSLEN + len); > > - if (*io_buf == NULL) > > - ERRORDIE (TPM_SIZE); > > - } else { // *io_buf is already allocated > > - if (outlen < len + PARAMSLEN) > > - ERRORDIE (TPM_SIZE); // but not large enough! > > - } > > - > > - // copy over the parameters (three UINT32's starting at algorithmID) > > - memcpy (*io_buf, &cryptoInfo->algorithmID, PARAMSLEN); > > - > > - // copy over the DER keys > > - memcpy (*io_buf + PARAMSLEN, buf, len); > > - > > - *io_buflen = len + PARAMSLEN; > > - > > - goto egress; > > - > > - > > - abort_egress: > > - egress: > > - > > - BIO_free (mem); > > - > > - return status; > > -} > > - > > - > > - > > -// sets up ci, and returns the number of bytes read in o_lenread > > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > > - BYTE * in, UINT32 len, > > - UINT32 * o_lenread) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - long l; > > - BIO *mem; > > - RSA *rsa; > > - > > - // first load up the params > > - l = 3 * sizeof(UINT32); > > - memcpy (&ci->algorithmID, in, l); > > - len -= l; > > - in += l; > > - > > - // and now the openssl keys, private first > > - mem = BIO_new_mem_buf (in, len); > > - > > - if ( (rsa = d2i_RSAPrivateKey_bio (mem, NULL)) == NULL ) { > > - ERR_print_errors_fp (stderr); > > - ERRORDIE (TPM_BAD_PARAMETER); > > - } > > - // now use the same RSA object and fill in the private key > > - if ( d2i_RSAPublicKey_bio (mem, &rsa) == NULL ) { > > - ERR_print_errors_fp (stderr); > > - ERRORDIE (TPM_BAD_PARAMETER); > > - } > > - > > - ci->keyInfo = rsa; // needs to be freed somehow later > > - > > - // FIXME: havent figured out yet how to tell how many bytes were read in the > > - // above oprations! so o_lenread is not set > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - BIO_free (mem); > > - > > - return status; > > -} > > diff --git a/tools/vtpm_manager/crypto/sym_crypto.c b/tools/vtpm_manager/crypto/sym_crypto.c > > deleted file mode 100644 > > index 3d86e19..0000000 > > --- a/tools/vtpm_manager/crypto/sym_crypto.c > > +++ /dev/null > > @@ -1,237 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// sym_crypto.c > > -// > > -// Symmetric crypto portion of crypto > > -// > > -// ================================================================== > > - > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "sym_crypto.h" > > - > > -typedef enum crypt_op_type_t { > > - CRYPT_ENCRYPT, > > - CRYPT_DECRYPT > > -} crypt_op_type_t; > > - > > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > > - const buffer_t* in, > > - const buffer_t* iv, > > - buffer_t * out, > > - crypt_op_type_t optype); > > - > > - > > -// this is initialized in Crypto_Init() > > -const EVP_CIPHER * SYM_CIPHER = NULL; > > - > > -const BYTE ZERO_IV[EVP_MAX_IV_LENGTH] = {0}; > > - > > - > > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - EVP_CIPHER_CTX_init (&key->context); > > - > > - key->cipher = SYM_CIPHER; > > - > > - TPMTRYRETURN( buffer_init_copy (&key->key, keybits)); > > - > > - goto egress; > > - > > - abort_egress: > > - EVP_CIPHER_CTX_cleanup (&key->context); > > - > > - egress: > > - > > - return status; > > -} > > - > > - > > - > > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key) { > > - int res; > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - // hmm, EVP_CIPHER_CTX_init does not return a value > > - EVP_CIPHER_CTX_init (&key->context); > > - > > - key->cipher = SYM_CIPHER; > > - > > - TPMTRYRETURN( buffer_init (&key->key, EVP_CIPHER_key_length(key->cipher), NULL)) ; > > - > > - // and generate the key material > > - res = RAND_pseudo_bytes (key->key.bytes, key->key.size); > > - if (res < 0) > > - ERRORDIE (TPM_SHORTRANDOM); > > - > > - > > - goto egress; > > - > > - abort_egress: > > - EVP_CIPHER_CTX_cleanup (&key->context); > > - buffer_free (&key->key); > > - > > - egress: > > - return status; > > -} > > - > > - > > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > > - const buffer_t* clear, > > - buffer_t* o_cipher) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - buffer_t iv, cipher_alias; > > - > > - buffer_init_const (&iv, EVP_MAX_IV_LENGTH, ZERO_IV); > > - > > - buffer_init (o_cipher, > > - clear->size + > > - EVP_CIPHER_iv_length(key->cipher) + > > - EVP_CIPHER_block_size (key->cipher), > > - 0); > > - > > - // copy the IV into the front > > - buffer_copy (o_cipher, &iv); > > - > > - // make an alias into which we'll put the ciphertext > > - buffer_init_alias (&cipher_alias, o_cipher, EVP_CIPHER_iv_length(key->cipher), 0); > > - > > - TPMTRYRETURN( ossl_symcrypto_op (key, clear, &iv, &cipher_alias, CRYPT_ENCRYPT) ); > > - > > - // set the output size correctly > > - o_cipher->size += cipher_alias.size; > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > - > > -} > > - > > - > > - > > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > > - const buffer_t* cipher, > > - buffer_t* o_clear) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - buffer_t iv, cipher_alias; > > - > > - // alias for the IV > > - buffer_init_alias (&iv, cipher, 0, EVP_CIPHER_iv_length(key->cipher)); > > - > > - // make an alias to where the ciphertext is, after the IV > > - buffer_init_alias (&cipher_alias, cipher, EVP_CIPHER_iv_length(key->cipher), 0); > > - > > - // prepare the output buffer > > - TPMTRYRETURN( buffer_init (o_clear, > > - cipher->size > > - - EVP_CIPHER_iv_length(key->cipher) > > - + EVP_CIPHER_block_size(key->cipher), > > - 0) ); > > - > > - // and decrypt > > - TPMTRYRETURN ( ossl_symcrypto_op (key, &cipher_alias, &iv, o_clear, CRYPT_DECRYPT) ); > > - > > - goto egress; > > - > > - abort_egress: > > - buffer_free (o_clear); > > - > > - egress: > > - > > - return status; > > -} > > - > > - > > - > > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key) { > > - buffer_memset (&key->key, 0); > > - buffer_free (&key->key); > > - > > - EVP_CIPHER_CTX_cleanup (&key->context); > > - > > - return TPM_SUCCESS; > > -} > > - > > - > > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > > - const buffer_t* in, > > - const buffer_t* iv, > > - buffer_t * out, > > - crypt_op_type_t optype) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - int inlen, outlen; > > - tpm_size_t running; > > - > > - if ( ! EVP_CipherInit_ex (&key->context, > > - key->cipher, NULL, key->key.bytes, iv->bytes, > > - optype == CRYPT_ENCRYPT ? 1 : 0) ) > > - ERRORDIE (TPM_FAIL); > > - > > - > > - > > - inlen = in->size; > > - > > - outlen = 0; > > - running = 0; > > - > > - > > - if ( ! EVP_CipherUpdate (&key->context, out->bytes, &outlen, in->bytes, inlen) ) > > - ERRORDIE (TPM_FAIL); > > - > > - running += outlen; > > - > > - if ( ! EVP_CipherFinal_ex (&key->context, out->bytes + running, &outlen) ) > > - ERRORDIE (TPM_FAIL); > > - > > - running += outlen; > > - > > - out->size = running; > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > diff --git a/tools/vtpm_manager/crypto/sym_crypto.h b/tools/vtpm_manager/crypto/sym_crypto.h > > deleted file mode 100644 > > index 7fb59a8..0000000 > > --- a/tools/vtpm_manager/crypto/sym_crypto.h > > +++ /dev/null > > @@ -1,72 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// sym_crypto.h > > -// > > -// Symmetric Crypto > > -// > > -// ================================================================== > > - > > -#ifndef _SYM_CRYPTO_H > > -#define _SYM_CRYPTO_H > > - > > -#include > > -#include "buffer.h" > > - > > -typedef struct symkey_t { > > - buffer_t key; > > - > > - EVP_CIPHER_CTX context; > > - const EVP_CIPHER * cipher; > > -} symkey_t; > > - > > -extern const EVP_CIPHER * SYM_CIPHER; > > - > > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key); > > - > > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits); > > - > > - > > -// these functions will allocate their output buffers > > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > > - const buffer_t* clear, > > - buffer_t* o_cipher); > > - > > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > > - const buffer_t* cipher, > > - buffer_t* o_clear); > > - > > -// only free the internal parts, not the 'key' ptr > > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key); > > - > > -#endif /* _SYM_CRYPTO_H */ > > diff --git a/tools/vtpm_manager/manager/Makefile b/tools/vtpm_manager/manager/Makefile > > deleted file mode 100644 > > index a33c18a..0000000 > > --- a/tools/vtpm_manager/manager/Makefile > > +++ /dev/null > > @@ -1,38 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../../.. > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -BIN = vtpm_managerd > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: $(BIN) > > - > > -.PHONY: install > > -install: build > > - if [ ! -d "$(DESTDIR)/var/vtpm/fifos" ]; \ > > - then mkdir -p $(DESTDIR)/var/vtpm/fifos; \ > > - fi > > - if [ ! -d "$(DESTDIR)/var/vtpm/socks" ]; \ > > - then mkdir -p $(DESTDIR)/var/vtpm/socks; \ > > - fi > > - $(INSTALL_PROG) $(BIN) $(DESTDIR)$(BINDIR) > > - > > -.PHONY: clean > > -clean: > > - rm -f $(BIN) > > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > > - > > -.PHONY: mrproper > > -mrproper: clean > > - rm -f *~ > > - > > -$(BIN): $(OBJS) > > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > > - > > -# libraries > > -LIBS += ../tcs/libTCS.a ../util/libTCGUtils.a ../crypto/libtcpaCrypto.a > > -LIBS += -lcrypto $(PTHREAD_LIBS) -lm > > -CFLAGS += $(PTHREAD_CFLAGS) > > -LDFLAGS += $(PTHREAD_LDFLAGS) > > diff --git a/tools/vtpm_manager/manager/dmictl.c b/tools/vtpm_manager/manager/dmictl.c > > deleted file mode 100644 > > index 5c3cf7e..0000000 > > --- a/tools/vtpm_manager/manager/dmictl.c > > +++ /dev/null > > @@ -1,266 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// dmictl.c > > -// > > -// Functions for creating and destroying DMIs > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > - > > -#include "vtpmpriv.h" > > -#include "bsg.h" > > -#include "buffer.h" > > -#include "log.h" > > -#include "hashtable.h" > > -#include "hashtable_itr.h" > > -#include "vtpm_ipc.h" > > - > > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > > - > > -// if dmi_res is non-null, then return a pointer to new object. > > -// Also, this does not fill in the measurements. They should be filled by > > -// design dependent code or saveNVM > > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE dmi_type, VTPM_DMI_RESOURCE **dmi_res) { > > - > > - TPM_RESULT status=TPM_SUCCESS; > > - VTPM_DMI_RESOURCE *new_dmi=NULL; > > - UINT32 *dmi_id_key=NULL; > > - > > - if ((new_dmi = (VTPM_DMI_RESOURCE *) malloc (sizeof(VTPM_DMI_RESOURCE))) == NULL) { > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } > > - memset(new_dmi, 0, sizeof(VTPM_DMI_RESOURCE)); > > - new_dmi->dmi_id = dmi_id; > > - new_dmi->dmi_type = dmi_type; > > - new_dmi->connected = FALSE; > > - new_dmi->TCSContext = 0; > > - > > - new_dmi->NVMLocation = (char *) malloc(11 + strlen(DMI_NVM_FILE)); > > - sprintf(new_dmi->NVMLocation, DMI_NVM_FILE, (uint32_t) new_dmi->dmi_id); > > - > > - if ((dmi_id_key = (UINT32 *) malloc (sizeof(UINT32))) == NULL) { > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } > > - *dmi_id_key = new_dmi->dmi_id; > > - > > - // install into map > > - if (!hashtable_insert(vtpm_globals->dmi_map, dmi_id_key, new_dmi)){ > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to insert instance into table. Aborting.\n", dmi_id); > > - status = TPM_FAIL; > > - goto abort_egress; > > - } > > - > > - if (dmi_res) > > - *dmi_res = new_dmi; > > - > > - goto egress; > > - > > - abort_egress: > > - if (new_dmi) { > > - free(new_dmi->NVMLocation); > > - free(new_dmi); > > - } > > - free(dmi_id_key); > > - > > - egress: > > - return status; > > -} > > - > > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res) { > > - if (dmi_res == NULL) > > - return TPM_SUCCESS; > > - > > - if (dmi_res->dmi_id == VTPM_CTL_DM) > > - return(TPM_BAD_PARAMETER); > > - > > - TCS_CloseContext(dmi_res->TCSContext); > > - dmi_res->connected = FALSE; > > - > > - vtpm_globals->connected_dmis--; > > - > > - return (VTPM_Close_DMI_Extra(dmi_res) ); > > -} > > - > > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf) { > > - > > - VTPM_DMI_RESOURCE *new_dmi=NULL; > > - TPM_RESULT status=TPM_FAIL; > > - BYTE dmi_type, vm_type, startup_mode; > > - UINT32 dmi_id; > > - > > - if (param_buf == NULL) { // Assume creation of Dom 0 control > > - dmi_type = VTPM_TYPE_NON_MIGRATABLE; > > - dmi_id = VTPM_CTL_DM; > > - } else if (buffer_len(param_buf) != sizeof(BYTE) * 3 + sizeof(UINT32)) { > > - vtpmloginfo(VTPM_LOG_VTPM, "New DMI command wrong length: %d.\n", buffer_len(param_buf)); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } else { > > - vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0 > > - BSG_UnpackList( param_buf->bytes, 4, > > - BSG_TYPE_BYTE, &dmi_type, > > - BSG_TYPE_BYTE, &startup_mode, > > - BSG_TYPE_BYTE, &vm_type, > > - BSG_TYPE_UINT32, &dmi_id); > > - } > > - > > - if ((dmi_type != VTPM_TYPE_NON_MIGRATABLE) && (dmi_type != VTPM_TYPE_MIGRATABLE)) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Creation of VTPM with illegal type.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - new_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > > - if (new_dmi == NULL) { > > - vtpmloginfo(VTPM_LOG_VTPM, "Creating new DMI instance %d attached.\n", dmi_id ); > > - // Brand New DMI. Initialize the persistent pieces > > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &new_dmi) ); > > - } else > > - vtpmloginfo(VTPM_LOG_VTPM, "Re-attaching DMI instance %d.\n", dmi_id); > > - > > - if (new_dmi->connected) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach, currently attached instance %d. Ignoring\n", dmi_id); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - if (new_dmi->dmi_type == VTPM_TYPE_MIGRATED) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach previously migrated instance %d without recovering first. Ignoring\n", dmi_id); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // Initialize the Non-persistent pieces > > - TPMTRYRETURN( TCS_OpenContext(&new_dmi->TCSContext) ); > > - > > - new_dmi->connected = TRUE; > > - > > - // Design specific new DMI code. > > - // Includes: create IPCs, Measuring DMI, and maybe launching DMI > > - TPMTRYRETURN(VTPM_New_DMI_Extra(new_dmi, vm_type, startup_mode) ); > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create DMI id=%d due to status=%s. Cleaning.\n", dmi_id, tpm_get_error_name(status)); > > - close_dmi(new_dmi ); > > - > > - egress: > > - return status; > > -} > > - > > -TPM_RESULT VTPM_Handle_Close_DMI( const buffer_t *param_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - VTPM_DMI_RESOURCE *dmi_res=NULL; > > - UINT32 dmi_id; > > - > > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size."); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - BSG_UnpackList( param_buf->bytes, 1, > > - BSG_TYPE_UINT32, &dmi_id); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Closing DMI %d.\n", dmi_id); > > - > > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > > - if (dmi_res == NULL ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Trying to close nonexistent DMI.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - if (!dmi_res->connected) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-connected DMI.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // Close Dmi > > - TPMTRYRETURN(close_dmi( dmi_res )); > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > - > > -TPM_RESULT VTPM_Handle_Delete_DMI( const buffer_t *param_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - VTPM_DMI_RESOURCE *dmi_res=NULL; > > - UINT32 dmi_id; > > - > > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - BSG_UnpackList( param_buf->bytes, 1, > > - BSG_TYPE_UINT32, &dmi_id); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Deleting DMI %d.\n", dmi_id); > > - > > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_remove(vtpm_globals->dmi_map, &dmi_id); > > - if (dmi_res == NULL) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-existent DMI.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - //vtpm scripts delete file dmi_res->NVMLocation for us > > - > > - // Close DMI first > > - TPMTRYRETURN(close_dmi( dmi_res )); > > - free ( dmi_res ); > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > diff --git a/tools/vtpm_manager/manager/migration.c b/tools/vtpm_manager/manager/migration.c > > deleted file mode 100644 > > index 54da708..0000000 > > --- a/tools/vtpm_manager/manager/migration.c > > +++ /dev/null > > @@ -1,307 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// dmictl.c > > -// > > -// Functions for creating and destroying DMIs > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > - > > -#include "vtpmpriv.h" > > -#include "bsg.h" > > -#include "buffer.h" > > -#include "log.h" > > -#include "hashtable.h" > > - > > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > > - buffer_t *result_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - VTPM_DMI_RESOURCE *mig_dmi=NULL; > > - UINT32 dmi_id; > > - buffer_t dmi_state_abuf = NULL_BUF, enc_dmi_abuf = NULL_BUF, clear_dmi_blob = NULL_BUF; > > - > > - if (param_buf == NULL) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - struct pack_buf_t enc_dmi_state_pack; > > - > > - BSG_UnpackList(param_buf->bytes, 2, > > - BSG_TYPE_UINT32, &dmi_id, > > - BSG_TPM_SIZE32_DATA, &enc_dmi_state_pack) ; > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating VTPM in dmi %d.\n", dmi_id); > > - > > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > > - if (mig_dmi) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming VTPM claims unavailable id: %d.\n", dmi_id); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - /** UnBind Blob **/ > > - TPMTRYRETURN( buffer_init_alias_convert( &enc_dmi_abuf, > > - enc_dmi_state_pack.size, > > - enc_dmi_state_pack.data) ); > > - > > - TPMTRYRETURN( envelope_decrypt( &enc_dmi_abuf, > > - vtpm_globals->manager_tcs_handle, > > - vtpm_globals->storageKeyHandle, > > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > > - &clear_dmi_blob) ); > > - > > - // Create new dmi > > - TPMTRYRETURN( init_dmi(dmi_id, VTPM_TYPE_MIGRATABLE, &mig_dmi ) ); > > - > > - /** Open Blob **/ > > - struct pack_buf_t dmi_state_pack; > > - > > - BSG_UnpackList(clear_dmi_blob.bytes, 2, > > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > > - > > - TPMTRYRETURN( buffer_init_alias_convert(&dmi_state_abuf, > > - dmi_state_pack.size, > > - dmi_state_pack.data) ); > > - > > - TPMTRYRETURN( VTPM_Handle_Save_NVM(mig_dmi, &dmi_state_abuf, NULL ) ); > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration IN of instance %d failed because of %s.\n", dmi_id, tpm_get_error_name(status) ); > > - > > - egress: > > - buffer_free(&clear_dmi_blob); > > - buffer_free(&dmi_state_abuf); > > - > > - return status; > > -} > > - > > -TPM_RESULT VTPM_Handle_Migrate_Out( const buffer_t *param_buf, > > - buffer_t *result_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - VTPM_DMI_RESOURCE *mig_dmi; > > - UINT32 dmi_id; > > - VTPM_MIGKEY_LIST *last_mig, *mig_key; > > - buffer_t dmi_state=NULL_BUF, clear_dmi_blob=NULL_BUF; > > - > > - if (param_buf == NULL) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - struct pack_buf_t name_pack; > > - > > - BSG_UnpackList( param_buf->bytes, 2, > > - BSG_TYPE_UINT32, &dmi_id, > > - BSG_TPM_SIZE32_DATA, &name_pack); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating out dmi %d.\n", dmi_id); > > - > > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > > - if (mig_dmi == NULL) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Non-existent VTPM instance (%d) in migration.\n", dmi_id ); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - if (mig_dmi->dmi_type != VTPM_TYPE_MIGRATABLE) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Bad VTPM type (%d) in migration of instance (%d).\n", mig_dmi->dmi_type, dmi_id ); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - /** Find migration key for dest **/ > > - last_mig = NULL; > > - mig_key = vtpm_globals->mig_keys; > > - while (mig_key != NULL) { > > - if (mig_key->name_size == name_pack.size) > > - if (memcmp(mig_key->name, name_pack.data, name_pack.size) == 0) { > > - break; > > - } > > - > > - last_mig = mig_key; > > - mig_key = mig_key->next; > > - } > > - > > - if (!mig_key) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Unknown Migration target host.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - /** Mark vtpm as migrated **/ > > - mig_dmi->dmi_type = VTPM_TYPE_MIGRATED; > > - > > - /** Build Blob **/ > > - TPMTRYRETURN( VTPM_Handle_Load_NVM(mig_dmi, NULL, &dmi_state) ); > > - > > - TPMTRYRETURN( buffer_init(&clear_dmi_blob, sizeof(TPM_DIGEST) + sizeof(UINT32) + buffer_len(&dmi_state), NULL ) ); > > - > > - struct pack_constbuf_t dmi_state_pack; > > - > > - dmi_state_pack.size = buffer_len(&dmi_state); > > - dmi_state_pack.data = dmi_state.bytes; > > - > > - BSG_PackList(clear_dmi_blob.bytes, 2, > > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > > - > > - /** Bind Blob **/ > > - TPMTRYRETURN( envelope_encrypt( &clear_dmi_blob, > > - &mig_key->key, > > - result_buf) ); > > - > > - if (last_mig) > > - last_mig->next = mig_key->next; > > - else > > - vtpm_globals->mig_keys = mig_key->next; > > - > > - free(mig_key->name); > > - free(mig_key); > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration OUT of instance %d failed because of %s. Migratoin recovery may be needed.\n", dmi_id, tpm_get_error_name(status) ); > > - > > - //TODO: Create and implement a policy for what happens to mig_key on failed migrations. > > - > > - egress: > > - > > - buffer_free(&clear_dmi_blob); > > - buffer_free(&dmi_state); > > - > > - return status; > > -} > > - > > - > > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > > - buffer_t *result_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Getting Migration Public Key.\n"); > > - > > - struct pack_buf_t pubkey_exp_pack, pubkey_mod_pack; > > - TPM_KEY mig_key; > > - > > - // Unpack/return key structure > > - BSG_Unpack(BSG_TPM_KEY, vtpm_globals->storageKeyWrap.bytes , &mig_key); > > - TPM_RSA_KEY_PARMS rsaKeyParms; > > - > > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > > - mig_key.algorithmParms.parms, > > - &rsaKeyParms); > > - > > - pubkey_exp_pack.size = rsaKeyParms.exponentSize; > > - pubkey_exp_pack.data = rsaKeyParms.exponent; > > - pubkey_mod_pack.size = mig_key.pubKey.keyLength; > > - pubkey_mod_pack.data = mig_key.pubKey.key; > > - > > - TPMTRYRETURN( buffer_init( result_buf, 2*sizeof(UINT32) + > > - pubkey_exp_pack.size + > > - pubkey_mod_pack.size, NULL ) ); > > - > > - BSG_PackList( result_buf->bytes, 2, > > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > > - > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Get Migration Key failed because of %s.\n", tpm_get_error_name(status) ); > > - egress: > > - > > - return status; > > -} > > - > > -TPM_RESULT VTPM_Handle_Load_Migration_key( const buffer_t *param_buf, > > - buffer_t *result_buf) { > > - > > - TPM_RESULT status=TPM_FAIL; > > - VTPM_MIGKEY_LIST *mig_key; > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Loading Migration Public Key.\n"); > > - > > - //FIXME: Review all uses of unpacking pack_buf_t and ensure free. > > - //FIXME: Review all declarations/initializations of buffer_t that could have a goto that skips them and then tries to free them > > - > > - struct pack_buf_t name_pack, pubkey_exp_pack, pubkey_mod_pack; > > - > > - //FIXME: scan list and verify name is not already in the list > > - > > - BSG_UnpackList( param_buf->bytes, 3, > > - BSG_TPM_SIZE32_DATA, &name_pack, > > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > > - > > - //TODO: Maintain a persistent list for pub_keys. > > - //TODO: Verify pub_key is trusted > > - > > - mig_key = (VTPM_MIGKEY_LIST *) malloc(sizeof(VTPM_MIGKEY_LIST)); > > - memset(mig_key, 0, sizeof(VTPM_MIGKEY_LIST) ); > > - mig_key->name_size = name_pack.size; > > - mig_key->name = name_pack.data; > > - > > - mig_key->key.encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > > - Crypto_RSABuildCryptoInfoPublic( pubkey_exp_pack.size, > > - pubkey_exp_pack.data, > > - pubkey_mod_pack.size, > > - pubkey_mod_pack.data, > > - &mig_key->key); > > - > > - > > - mig_key->next = vtpm_globals->mig_keys; > > - vtpm_globals->mig_keys = mig_key; > > - > > - // free(name_pack.data); Do not free. data is now part of mig_key. > > - free(pubkey_exp_pack.data); > > - free(pubkey_mod_pack.data); > > - > > - return TPM_SUCCESS; > > -} > > diff --git a/tools/vtpm_manager/manager/securestorage.c b/tools/vtpm_manager/manager/securestorage.c > > deleted file mode 100644 > > index d5e6ffd..0000000 > > --- a/tools/vtpm_manager/manager/securestorage.c > > +++ /dev/null > > @@ -1,512 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// securestorage.c > > -// > > -// Functions regarding securely storing DMI secrets. > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "vtpm_manager.h" > > -#include "vtpmpriv.h" > > -#include "vtsp.h" > > -#include "bsg.h" > > -#include "crypto.h" > > -#include "hashtable.h" > > -#include "hashtable_itr.h" > > -#include "buffer.h" > > -#include "log.h" > > - > > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > > - CRYPTO_INFO *asymkey, > > - buffer_t *sealed_data) { > > - TPM_RESULT status = TPM_SUCCESS; > > - symkey_t symkey; > > - buffer_t data_cipher = NULL_BUF, > > - symkey_cipher = NULL_BUF; > > - > > - UINT32 i; > > - struct pack_constbuf_t symkey_cipher32, data_cipher32; > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Input[%d]: 0x", buffer_len(inbuf)); > > - for (i=0; i< buffer_len(inbuf); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", inbuf->bytes[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - // Generate a sym key and encrypt state with it > > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_genkey (&symkey) ); > > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_encrypt (&symkey, inbuf, &data_cipher) ); > > - > > - // Encrypt symmetric key > > - TPMTRYRETURN( VTSP_Bind( asymkey, > > - &symkey.key, > > - &symkey_cipher) ); > > - > > - // Create output blob: symkey_size + symkey_cipher + state_cipher_size + state_cipher > > - > > - symkey_cipher32.size = buffer_len(&symkey_cipher); > > - symkey_cipher32.data = symkey_cipher.bytes; > > - > > - data_cipher32.size = buffer_len(&data_cipher); > > - data_cipher32.data = data_cipher.bytes; > > - > > - TPMTRYRETURN( buffer_init(sealed_data, 2 * sizeof(UINT32) + symkey_cipher32.size + data_cipher32.size, NULL)); > > - > > - BSG_PackList(sealed_data->bytes, 2, > > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > > - BSG_TPM_SIZE32_DATA, &data_cipher32); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Saved %d bytes of E(symkey) + %d bytes of E(data)\n", buffer_len(&symkey_cipher), buffer_len(&data_cipher)); > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Output[%d]: 0x", buffer_len(sealed_data)); > > - for (i=0; i< buffer_len(sealed_data); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", sealed_data->bytes[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope encrypt\n."); > > - > > - egress: > > - > > - buffer_free ( &data_cipher); > > - buffer_free ( &symkey_cipher); > > - Crypto_symcrypto_freekey (&symkey); > > - > > - return status; > > -} > > - > > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > > - TCS_CONTEXT_HANDLE TCSContext, > > - TPM_HANDLE keyHandle, > > - const TPM_AUTHDATA *key_usage_auth, > > - buffer_t *unsealed_data) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - symkey_t symkey; > > - buffer_t data_cipher = NULL_BUF, > > - symkey_clear = NULL_BUF, > > - symkey_cipher = NULL_BUF; > > - struct pack_buf_t symkey_cipher32, data_cipher32; > > - int i; > > - > > - memset(&symkey, 0, sizeof(symkey_t)); > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypt Input[%d]: 0x", buffer_len(cipher) ); > > - for (i=0; i< buffer_len(cipher); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cipher->bytes[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - BSG_UnpackList(cipher->bytes, 2, > > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > > - BSG_TPM_SIZE32_DATA, &data_cipher32); > > - > > - TPMTRYRETURN( buffer_init_alias_convert (&symkey_cipher, > > - symkey_cipher32.size, > > - symkey_cipher32.data) ); > > - > > - TPMTRYRETURN( buffer_init_alias_convert (&data_cipher, > > - data_cipher32.size, > > - data_cipher32.data) ); > > - > > - // Decrypt Symmetric Key > > - TPMTRYRETURN( VTSP_Unbind( TCSContext, > > - keyHandle, > > - &symkey_cipher, > > - key_usage_auth, > > - &symkey_clear, > > - &(vtpm_globals->keyAuth) ) ); > > - > > - // create symmetric key using saved bits > > - Crypto_symcrypto_initkey (&symkey, &symkey_clear); > > - > > - // Decrypt State > > - TPMTRY(TPM_DECRYPT_ERROR, Crypto_symcrypto_decrypt (&symkey, &data_cipher, unsealed_data) ); > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypte Output[%d]: 0x", buffer_len(unsealed_data)); > > - for (i=0; i< buffer_len(unsealed_data); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", unsealed_data->bytes[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope decrypt data\n."); > > - > > - egress: > > - buffer_free ( &data_cipher); > > - buffer_free ( &symkey_clear); > > - buffer_free ( &symkey_cipher); > > - Crypto_symcrypto_freekey (&symkey); > > - > > - return status; > > -} > > - > > -TPM_RESULT VTPM_Handle_Save_NVM(VTPM_DMI_RESOURCE *myDMI, > > - const buffer_t *inbuf, > > - buffer_t *outbuf) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - int fh; > > - long bytes_written; > > - buffer_t sealed_NVM = NULL_BUF; > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Saving %d bytes of NVM.\n", buffer_len(inbuf)); > > - > > - TPMTRYRETURN( envelope_encrypt(inbuf, > > - &vtpm_globals->storageKey, > > - &sealed_NVM) ); > > - > > - // Write sealed blob off disk from NVMLocation > > - // TODO: How to properly return from these. Do we care if we return failure > > - // after writing the file? We can't get the old one back. > > - // TODO: Backup old file and try and recover that way. > > - fh = open(myDMI->NVMLocation, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); > > - if ( (bytes_written = write(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM) ) != (long) buffer_len(&sealed_NVM))) { > > - vtpmlogerror(VTPM_LOG_VTPM, "We just overwrote a DMI_NVM and failed to finish. %ld/%ld bytes.\n", bytes_written, (long)buffer_len(&sealed_NVM)); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - close(fh); > > - > > - Crypto_SHA1Full (sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &myDMI->NVM_measurement); > > - > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save NVM\n."); > > - > > - egress: > > - buffer_free(&sealed_NVM); > > - return status; > > -} > > - > > - > > -/* Expected Params: inbuf = null, outbuf = sealed blob size, sealed blob.*/ > > -TPM_RESULT VTPM_Handle_Load_NVM(VTPM_DMI_RESOURCE *myDMI, > > - const buffer_t *inbuf, > > - buffer_t *outbuf) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - buffer_t sealed_NVM = NULL_BUF; > > - long fh_size; > > - int fh, stat_ret, i; > > - struct stat file_stat; > > - TPM_DIGEST sealedNVMHash; > > - > > - if (myDMI->NVMLocation == NULL) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to load NVM because the file name NULL.\n"); > > - status = TPM_AUTHFAIL; > > - goto abort_egress; > > - } > > - > > - //Read sealed blob off disk from NVMLocation > > - fh = open(myDMI->NVMLocation, O_RDONLY); > > - stat_ret = fstat(fh, &file_stat); > > - if (stat_ret == 0) > > - fh_size = file_stat.st_size; > > - else { > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - TPMTRYRETURN( buffer_init( &sealed_NVM, fh_size, NULL) ); > > - if (read(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM)) != fh_size) { > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - close(fh); > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Load_NVMing[%d],\n", buffer_len(&sealed_NVM)); > > - > > - Crypto_SHA1Full(sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &sealedNVMHash); > > - > > - // Verify measurement of sealed blob. > > - if (memcmp(&sealedNVMHash, &myDMI->NVM_measurement, sizeof(TPM_DIGEST)) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM LoadNVM NVM measurement check failed.\n"); > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Correct hash: "); > > - for (i=0; i< sizeof(TPM_DIGEST); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&myDMI->NVM_measurement)[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Measured hash: "); > > - for (i=0; i< sizeof(TPM_DIGEST); i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&sealedNVMHash)[i]); > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - status = TPM_AUTHFAIL; > > - goto abort_egress; > > - } > > - > > - TPMTRYRETURN( envelope_decrypt(&sealed_NVM, > > - myDMI->TCSContext, > > - vtpm_globals->storageKeyHandle, > > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > > - outbuf) ); > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load NVM\n."); > > - > > - egress: > > - buffer_free( &sealed_NVM ); > > - > > - return status; > > -} > > - > > - > > -TPM_RESULT VTPM_SaveManagerData(void) { > > - TPM_RESULT status=TPM_SUCCESS; > > - int fh, dmis=-1; > > - > > - BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL; > > - buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF; > > - UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap); > > - UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap); > > - struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes}; > > - struct pack_buf_t boot_key_pack = {bootKeySize, vtpm_globals->bootKeyWrap.bytes}; > > - BYTE vtpm_manager_gen = VTPM_MANAGER_GEN; > > - > > - struct hashtable_itr *dmi_itr; > > - VTPM_DMI_RESOURCE *dmi_res; > > - > > - UINT32 boot_key_size = 0, flat_dmis_size = 0; > > - > > - // Initially fill these with buffer sizes for each data type. Later fill > > - // in actual size, once flattened. > > - boot_key_size = sizeof(UINT32) + // bootkeysize > > - bootKeySize; // boot key > > - > > - TPMTRYRETURN(buffer_init(&clear_flat_global,sizeof(BYTE) + // manager version > > - 3*sizeof(TPM_DIGEST) + // Auths > > - sizeof(UINT32) +// storagekeysize > > - storageKeySize, NULL) ); // storage key > > - > > - > > - flat_boot_key = (BYTE *) malloc( boot_key_size ); > > - flat_enc = (BYTE *) malloc( sizeof(UINT32) ); > > - > > - boot_key_size = BSG_PackList(flat_boot_key, 1, > > - BSG_TPM_SIZE32_DATA, &boot_key_pack); > > - > > - BSG_PackList(clear_flat_global.bytes, 4, > > - BSG_TYPE_BYTE, &vtpm_manager_gen, > > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > > - > > - TPMTRYRETURN(envelope_encrypt(&clear_flat_global, > > - &vtpm_globals->bootKey, > > - &enc_flat_global) ); > > - > > - BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc); > > - > > - // Per DMI values to be saved (if any exit) > > - if (hashtable_count(vtpm_globals->dmi_map) > 1) { > > - > > - flat_dmis = (BYTE *) malloc( > > - (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0) > > - (sizeof(UINT32) +sizeof(BYTE) + 2*sizeof(TPM_DIGEST)) ); // Per DMI info > > - > > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > > - do { > > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > > - dmis++; > > - > > - // No need to save dmi0. > > - if (dmi_res->dmi_id == 0) > > - continue; > > - > > - > > - flat_dmis_size += BSG_PackList( flat_dmis + flat_dmis_size, 4, > > - BSG_TYPE_UINT32, &dmi_res->dmi_id, > > - BSG_TYPE_BYTE, &dmi_res->dmi_type, > > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > > - > > - } while (hashtable_iterator_advance(dmi_itr)); > > - } > > - > > - fh = open(STATE_FILE, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE); > > - if (fh == -1) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to open %s file for write.\n", STATE_FILE); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if ( ( write(fh, flat_boot_key, boot_key_size) != boot_key_size ) || > > - ( write(fh, flat_enc, sizeof(UINT32)) != sizeof(UINT32) ) || > > - ( write(fh, enc_flat_global.bytes, buffer_len(&enc_flat_global)) != buffer_len(&enc_flat_global) ) || > > - ( write(fh, flat_dmis, flat_dmis_size) != flat_dmis_size ) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to completely write service data.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - free(flat_boot_key); > > - free(flat_enc); > > - buffer_free(&enc_flat_global); > > - free(flat_dmis); > > - close(fh); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Saved VTPM Manager state (status = %d, dmis = %d)\n", (int) status, dmis); > > - return status; > > -} > > - > > -TPM_RESULT VTPM_LoadManagerData(void) { > > - > > - TPM_RESULT status=TPM_SUCCESS; > > - int fh, stat_ret, dmis=0; > > - long fh_size = 0, step_size; > > - BYTE *flat_table=NULL; > > - buffer_t unsealed_data, enc_table_abuf; > > - struct pack_buf_t storage_key_pack, boot_key_pack; > > - UINT32 *dmi_id_key, enc_size; > > - BYTE vtpm_manager_gen; > > - > > - VTPM_DMI_RESOURCE *dmi_res; > > - UINT32 dmi_id; > > - BYTE dmi_type; > > - struct stat file_stat; > > - > > - TPM_HANDLE boot_key_handle; > > - TPM_AUTHDATA boot_usage_auth; > > - memset(&boot_usage_auth, 0, sizeof(TPM_AUTHDATA)); > > - > > - fh = open(STATE_FILE, O_RDONLY ); > > - stat_ret = fstat(fh, &file_stat); > > - if (stat_ret == 0) > > - fh_size = file_stat.st_size; > > - else { > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - flat_table = (BYTE *) malloc(fh_size); > > - > > - if ((long) read(fh, flat_table, fh_size) != fh_size ) { > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - // Read Boot Key > > - step_size = BSG_UnpackList( flat_table, 2, > > - BSG_TPM_SIZE32_DATA, &boot_key_pack, > > - BSG_TYPE_UINT32, &enc_size); > > - > > - TPMTRYRETURN(buffer_init(&vtpm_globals->bootKeyWrap, 0, 0) ); > > - TPMTRYRETURN(buffer_init_alias_convert(&enc_table_abuf, enc_size, flat_table + step_size) ); > > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->bootKeyWrap, boot_key_pack.size, boot_key_pack.data) ); > > - > > - //Load Boot Key > > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > > - TPM_SRK_KEYHANDLE, > > - &vtpm_globals->bootKeyWrap, > > - &SRK_AUTH, > > - &boot_key_handle, > > - &vtpm_globals->keyAuth, > > - &vtpm_globals->bootKey, > > - FALSE) ); > > - > > - TPMTRYRETURN( envelope_decrypt(&enc_table_abuf, > > - vtpm_globals->manager_tcs_handle, > > - boot_key_handle, > > - (const TPM_AUTHDATA*) &boot_usage_auth, > > - &unsealed_data) ); > > - step_size += enc_size; > > - > > - if (*unsealed_data.bytes != VTPM_MANAGER_GEN) { > > - // Once there is more than one gen, this will include some compatability stuff > > - vtpmlogerror(VTPM_LOG_VTPM, "Warning: Manager Data file is gen %d, which this manager is gen %d.\n", vtpm_manager_gen, VTPM_MANAGER_GEN); > > - } > > - > > - // Global Values needing to be saved > > - BSG_UnpackList( unsealed_data.bytes, 4, > > - BSG_TYPE_BYTE, &vtpm_manager_gen, > > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > > - > > - TPMTRYRETURN(buffer_init(&vtpm_globals->storageKeyWrap, 0, 0) ); > > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->storageKeyWrap, storage_key_pack.size, storage_key_pack.data) ); > > - > > - // Per DMI values to be saved > > - while ( step_size < fh_size ){ > > - if (fh_size - step_size < (long) (sizeof(UINT32) + sizeof(BYTE) + 2*sizeof(TPM_DIGEST))) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Encountered %ld extra bytes at end of manager state.\n", fh_size-step_size); > > - step_size = fh_size; > > - } else { > > - step_size += BSG_UnpackList(flat_table + step_size, 2, > > - BSG_TYPE_UINT32, &dmi_id, > > - BSG_TYPE_BYTE, &dmi_type); > > - > > - //TODO: Try and gracefully recover from problems. > > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &dmi_res) ); > > - dmis++; > > - > > - step_size += BSG_UnpackList(flat_table + step_size, 2, > > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > > - } > > - > > - } > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Loaded saved state (dmis = %d).\n", dmis); > > - goto egress; > > - > > - abort_egress: > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load service data with error = %s\n", tpm_get_error_name(status)); > > - egress: > > - > > - free(flat_table); > > - close(fh); > > - > > - // TODO: Could be nice and evict BootKey. (Need to add EvictKey to VTSP. > > - > > - return status; > > -} > > - > > diff --git a/tools/vtpm_manager/manager/tpmpassthrough.c b/tools/vtpm_manager/manager/tpmpassthrough.c > > deleted file mode 100644 > > index 9b1e5f8..0000000 > > --- a/tools/vtpm_manager/manager/tpmpassthrough.c > > +++ /dev/null > > @@ -1,110 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// tpmpassthrough.c > > -// > > -// Functions regarding passing DMI requests to HWTPM > > -// > > -// ================================================================== > > - > > -#include "tcg.h" > > -#include "vtpm_manager.h" > > -#include "vtpmpriv.h" > > -#include "vtsp.h" > > -#include "log.h" > > - > > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > > - buffer_t *inbuf, > > - buffer_t *outbuf) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE *ord; > > - > > - ord = (TPM_COMMAND_CODE *) (inbuf->bytes + sizeof(TPM_TAG) + sizeof(UINT32)); > > - > > - switch (*ord) { > > - > > - // Forbidden for DMI use > > - case TPM_ORD_TakeOwnership: > > - case TPM_ORD_ChangeAuthOwner: > > - case TPM_ORD_DirWriteAuth: > > - case TPM_ORD_DirRead: > > - case TPM_ORD_AuthorizeMigrationKey: > > - case TPM_ORD_CreateMaintenanceArchive: > > - case TPM_ORD_LoadMaintenanceArchive: > > - case TPM_ORD_KillMaintenanceFeature: > > - case TPM_ORD_LoadManuMaintPub: > > - case TPM_ORD_ReadManuMaintPub: > > - case TPM_ORD_SelfTestFull: > > - case TPM_ORD_SelfTestStartup: > > - case TPM_ORD_CertifySelfTest: > > - case TPM_ORD_ContinueSelfTest: > > - case TPM_ORD_GetTestResult: > > - case TPM_ORD_Reset: > > - case TPM_ORD_OwnerClear: > > - case TPM_ORD_DisableOwnerClear: > > - case TPM_ORD_ForceClear: > > - case TPM_ORD_DisableForceClear: > > - case TPM_ORD_GetCapabilityOwner: > > - case TPM_ORD_OwnerSetDisable: > > - case TPM_ORD_PhysicalEnable: > > - case TPM_ORD_PhysicalDisable: > > - case TPM_ORD_SetOwnerInstall: > > - case TPM_ORD_PhysicalSetDeactivated: > > - case TPM_ORD_SetTempDeactivated: > > - case TPM_ORD_CreateEndorsementKeyPair: > > - case TPM_ORD_GetAuditEvent: > > - case TPM_ORD_GetAuditEventSigned: > > - case TPM_ORD_GetOrdinalAuditStatus: > > - case TPM_ORD_SetOrdinalAuditStatus: > > - case TPM_ORD_SetRedirection: > > - case TPM_ORD_FieldUpgrade: > > - case TSC_ORD_PhysicalPresence: > > - status = TPM_DISABLED_CMD; > > - goto abort_egress; > > - break; > > - > > - } // End ORD Switch > > - > > - // Call TCS with command > > - > > - TPMTRY(TPM_IOERROR, VTSP_RawTransmit( dmi->TCSContext,inbuf, outbuf) ); > > - > > - goto egress; > > - > > - abort_egress: > > - vtpmloginfo(VTPM_LOG_VTPM, "TPM Command Failed in tpmpassthrough.\n"); > > - egress: > > - > > - return status; > > -} > > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.c b/tools/vtpm_manager/manager/vtpm_ipc.c > > deleted file mode 100644 > > index 319dc83..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_ipc.c > > +++ /dev/null > > @@ -1,141 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_ipc.c Implements ipc routines using file io. This file can > > -// be replaced with other ipc types. > > -// > > -// =================================================================== > > - > > -#include > > -#include "vtpm_ipc.h" > > -#include "vtpmpriv.h" > > -#include "log.h" > > - > > -int vtpm_ipc_init(vtpm_ipc_handle_t *ipc_h, char* name, int flags, BOOL create) { > > - ipc_h->name = name; > > - ipc_h->flags = flags; > > - ipc_h->fh = VTPM_IPC_CLOSED; > > - > > - if (create) > > - return(vtpm_ipc_create(ipc_h)); > > - else > > - return 0; > > -} > > - > > -// Create the file that needs opening. Used only for FIFOs > > -// FYI: This may cause problems in other file IO schemes. We'll see. > > -int vtpm_ipc_create(vtpm_ipc_handle_t *ipc_h) { > > - int fh; > > - struct stat file_info; > > - > > - if ((!ipc_h) || (!ipc_h->name)) > > - return -1; > > - > > - if ( stat(ipc_h->name, &file_info) == -1) { > > - if ( mkfifo(ipc_h->name, S_IWUSR | S_IRUSR ) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create fifo %s.\n", ipc_h->name); > > - return -1; > > - } > > - } > > - > > - ipc_h->fh = VTPM_IPC_CLOSED; > > - > > - return 0; > > -} > > - > > - > > -// Read size bytes. If FH isn't open, open it. > > -int vtpm_ipc_read(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size){ > > - vtpm_ipc_handle_t *my_ipc_h; > > - int result; > > - > > - if (ipc_h) { > > - my_ipc_h = ipc_h; > > - } else { > > - my_ipc_h = alt_ipc_h; > > - } > > - > > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > > - } > > - > > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for reading.\n", my_ipc_h->name); > > - return -1; > > - } > > - > > - result = read(my_ipc_h->fh, bytes, size); > > - if (result < 0) { > > - my_ipc_h->fh = VTPM_IPC_CLOSED; > > - } > > - > > - return (result); > > -} > > - > > -// Write size bytes. If FH isn't open, open it. > > -int vtpm_ipc_write(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size) { > > - vtpm_ipc_handle_t *my_ipc_h; > > - int result; > > - > > - if (ipc_h) { > > - my_ipc_h = ipc_h; > > - } else { > > - my_ipc_h = alt_ipc_h; > > - } > > - > > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > > - } > > - > > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for writing.\n", my_ipc_h->name); > > - return -1; > > - } > > - > > - result = write(my_ipc_h->fh, bytes, size); > > - if (result < 0) { > > - my_ipc_h->fh = VTPM_IPC_CLOSED; > > - } > > - > > - return (result); > > -} > > - > > -// Mark file as closed and try and close it. Errors not reported. > > -void vtpm_ipc_close(vtpm_ipc_handle_t *ipc_h) { > > - > > - if (ipc_h) { > > - close(ipc_h->fh); > > - ipc_h->fh = VTPM_IPC_CLOSED; > > - } > > - > > -} > > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.h b/tools/vtpm_manager/manager/vtpm_ipc.h > > deleted file mode 100644 > > index 529c4a2..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_ipc.h > > +++ /dev/null > > @@ -1,71 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_ipc.h Header for interprocess communication between VTPM manager > > -// and Guests or VTPMs > > -// > > -// =================================================================== > > - > > -#ifndef __VTPM_IO_H__ > > -#define __VTPM_IO_H__ > > - > > -#include "tcg.h" > > - > > -#define VTPM_IPC_CLOSED -1 > > - > > -// Represents an (somewhat) abstracted io handle. > > -typedef struct vtpm_ipc_handle_t { > > - int fh; // IO handle. > > - int flags; // Flags for opening. This may need to become > > - // a void *, but for now files use an int. > > - char *name; // Names for debugging as well as filenames > > - // for file-based io. > > -} vtpm_ipc_handle_t; > > - > > - > > -int vtpm_ipc_init(vtpm_ipc_handle_t *ioh, char* name, int flags, BOOL create); > > - > > -// Create the file that needs opening. Used only for FIFOs > > -// FYI: This may cause problems in other file IO schemes. We'll see. > > -int vtpm_ipc_create(vtpm_ipc_handle_t *ioh); > > - > > -// Read size bytes. If FH isn't open, open it. > > -int vtpm_ipc_read(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > > - > > -// Write size bytes. If FH isn't open, open it. > > -int vtpm_ipc_write(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > > - > > -// Mark file as closed and try and close it. Errors not reported. > > -void vtpm_ipc_close(vtpm_ipc_handle_t *ioh); > > - > > -#endif > > diff --git a/tools/vtpm_manager/manager/vtpm_lock.c b/tools/vtpm_manager/manager/vtpm_lock.c > > deleted file mode 100644 > > index e737d60..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_lock.c > > +++ /dev/null > > @@ -1,63 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_lock.c Provided controlled sync around access to vtpm structures > > -// > > -// =================================================================== > > - > > -#include > > -#include "vtpm_lock.h" > > - > > -static pthread_rwlock_t vtpm_lock; > > - > > -void vtpm_lock_init() { > > - > > - pthread_rwlock_init( &vtpm_lock, NULL); > > -} > > - > > -void vtpm_lock_destroy(){ > > - pthread_rwlock_destroy(&vtpm_lock); > > -} > > - > > -void vtpm_lock_rdlock(){ > > - pthread_rwlock_rdlock(&vtpm_lock); > > -} > > - > > -void vtpm_lock_wrlock(){ > > - pthread_rwlock_wrlock(&vtpm_lock); > > -} > > - > > -void vtpm_lock_unlock(){ > > - pthread_rwlock_unlock(&vtpm_lock); > > -} > > - > > diff --git a/tools/vtpm_manager/manager/vtpm_lock.h b/tools/vtpm_manager/manager/vtpm_lock.h > > deleted file mode 100644 > > index 53a339d..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_lock.h > > +++ /dev/null > > @@ -1,48 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_lock.h Provided controlled sync around access to vtpm structures > > -// > > -// =================================================================== > > - > > -#ifndef __VTPM_LOCK_H__ > > -#define __VTPM_LOCK_H__ > > - > > -void vtpm_lock_init(); > > -void vtpm_lock_destroy(); > > - > > -void vtpm_lock_rdlock(); > > -void vtpm_lock_wrlock(); > > -void vtpm_lock_unlock(); > > - > > -#endif > > diff --git a/tools/vtpm_manager/manager/vtpm_manager.c b/tools/vtpm_manager/manager/vtpm_manager.c > > deleted file mode 100644 > > index e089f78..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_manager.c > > +++ /dev/null > > @@ -1,285 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_manager.c > > -// > > -// This file will house the main logic of the VTPM Manager > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > - > > -#include "vtpm_manager.h" > > -#include "vtpmpriv.h" > > -#include "vtsp.h" > > -#include "bsg.h" > > -#include "hashtable.h" > > -#include "hashtable_itr.h" > > - > > -#include "log.h" > > -#include "buffer.h" > > - > > -VTPM_GLOBALS *vtpm_globals=NULL; > > - > > -// --------------------------- Well Known Auths -------------------------- > > -const TPM_AUTHDATA SRK_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > > - > > -#ifdef WELL_KNOWN_OWNER_AUTH > > -static BYTE FIXED_OWNER_AUTH[20] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > > -#endif > > - > > - > > -// -------------------------- Hash table functions -------------------- > > - > > -static unsigned int hashfunc32(void *ky) { > > - return (* (UINT32 *) ky); > > -} > > - > > -static int equals32(void *k1, void *k2) { > > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > > -} > > - > > -// --------------------------- Functions ------------------------------ > > - > > -TPM_RESULT VTPM_Create_Manager(){ > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - // Generate Auth for Owner > > -#ifdef WELL_KNOWN_OWNER_AUTH > > - memcpy(vtpm_globals->owner_usage_auth, FIXED_OWNER_AUTH, sizeof(TPM_AUTHDATA)); > > -#else > > - Crypto_GetRandom(vtpm_globals->owner_usage_auth, sizeof(TPM_AUTHDATA) ); > > -#endif > > - > > - // Take Owership of TPM > > - CRYPTO_INFO ek_cryptoInfo; > > - > > - status = VTSP_ReadPubek(vtpm_globals->manager_tcs_handle, &ek_cryptoInfo); > > - > > - // If we can read PubEK then there is no owner and we should take it. > > - // We use the abilty to read the pubEK to flag that the TPM is owned. > > - // FIXME: Change to just trying to take ownership and react to the status > > - if (status == TPM_SUCCESS) { > > - TPMTRYRETURN(VTSP_TakeOwnership(vtpm_globals->manager_tcs_handle, > > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > > - &SRK_AUTH, > > - &ek_cryptoInfo, > > - &vtpm_globals->keyAuth)); > > - > > - TPMTRYRETURN(VTSP_DisablePubekRead(vtpm_globals->manager_tcs_handle, > > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > > - &vtpm_globals->keyAuth)); > > - } else { > > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); > > - } > > - > > - // Generate storage key's auth > > - Crypto_GetRandom( &vtpm_globals->storage_key_usage_auth, > > - sizeof(TPM_AUTHDATA) ); > > - > > - TCS_AUTH osap; > > - TPM_AUTHDATA sharedsecret; > > - > > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > > - TPM_ET_KEYHANDLE, > > - TPM_SRK_KEYHANDLE, > > - &SRK_AUTH, > > - &sharedsecret, > > - &osap) ); > > - > > - osap.fContinueAuthSession = FALSE; > > - > > - > > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > > - TPM_KEY_BIND, > > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > > - TPM_SRK_KEYHANDLE, > > - (const TPM_AUTHDATA*)&sharedsecret, > > - &vtpm_globals->storageKeyWrap, > > - &osap) ); > > - > > - // Generate boot key's auth > > - TPM_AUTHDATA bootKeyWrapAuth; > > - memset(&bootKeyWrapAuth, 0, sizeof(bootKeyWrapAuth)); > > - > > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > > - TPM_ET_KEYHANDLE, > > - TPM_SRK_KEYHANDLE, > > - &SRK_AUTH, > > - &sharedsecret, > > - &osap) ); > > - > > - osap.fContinueAuthSession = FALSE; > > - > > - // FIXME: This key protects the global secrets on disk. It should use TPM > > - // PCR bindings to limit its use to legit configurations. > > - // Current binds are open, implying a Trusted VM contains this code. > > - // If this VM is not Trusted, use measurement and PCR bindings. > > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > > - TPM_KEY_BIND, > > - (const TPM_AUTHDATA*)&bootKeyWrapAuth, > > - TPM_SRK_KEYHANDLE, > > - (const TPM_AUTHDATA*)&sharedsecret, > > - &vtpm_globals->bootKeyWrap, > > - &osap) ); > > - > > - // Populate CRYPTO_INFO vtpm_globals->bootKey. This does not load it into the TPM > > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > > - TPM_SRK_KEYHANDLE, > > - &vtpm_globals->bootKeyWrap, > > - NULL, > > - NULL, > > - NULL, > > - &vtpm_globals->bootKey, > > - TRUE ) ); > > - > > - TPMTRYRETURN( VTSP_SaveState(vtpm_globals->manager_tcs_handle) ); > > - goto egress; > > - > > - abort_egress: > > - exit(1); > > - > > - egress: > > - vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager (Status = %d).\n", status); > > - return status; > > - > > -} > > - > > -/////////////////////////////////////////////////////////////////////////////// > > -TPM_RESULT VTPM_Init_Manager() { > > - TPM_RESULT status = TPM_FAIL, serviceStatus; > > - BYTE *randomsead; > > - UINT32 randomsize=256; > > - > > - if ((vtpm_globals = (VTPM_GLOBALS *) malloc(sizeof(VTPM_GLOBALS))) == NULL){ > > - status = TPM_FAIL; > > - goto abort_egress; > > - } > > - memset(vtpm_globals, 0, sizeof(VTPM_GLOBALS)); > > - > > - vtpm_globals->connected_dmis = 0; > > - > > - if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){ > > - status = TPM_FAIL; > > - goto abort_egress; > > - } > > - > > - // Create new TCS Object > > - vtpm_globals->manager_tcs_handle = 0; > > - > > - TPMTRYRETURN(TCS_create()); > > - > > - // Create TCS Context for service > > - TPMTRYRETURN( TCS_OpenContext(&vtpm_globals->manager_tcs_handle ) ); > > - > > - TPMTRYRETURN( TCSP_GetRandom(vtpm_globals->manager_tcs_handle, > > - &randomsize, > > - &randomsead)); > > - > > - Crypto_Init(randomsead, randomsize); > > - TPMTRYRETURN( TCS_FreeMemory (vtpm_globals->manager_tcs_handle, randomsead)); > > - > > - // Create OIAP session for service's authorized commands > > - TPMTRYRETURN( VTSP_OIAP( vtpm_globals->manager_tcs_handle, > > - &vtpm_globals->keyAuth) ); > > - vtpm_globals->keyAuth.fContinueAuthSession = TRUE; > > - > > - vtpm_globals->mig_keys = NULL; > > - > > - // If fails, create new Manager. > > - serviceStatus = VTPM_LoadManagerData(); > > - if (serviceStatus == TPM_IOERROR) { > > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); > > - TPMTRYRETURN( VTPM_Create_Manager() ); > > - TPMTRYRETURN( VTPM_SaveManagerData() ); > > - } else if (serviceStatus != TPM_SUCCESS) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to read existing manager file"); > > - exit(1); > > - } > > - > > - //Load Storage Key > > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > > - TPM_SRK_KEYHANDLE, > > - &vtpm_globals->storageKeyWrap, > > - &SRK_AUTH, > > - &vtpm_globals->storageKeyHandle, > > - &vtpm_globals->keyAuth, > > - &vtpm_globals->storageKey, > > - FALSE ) ); > > - > > - // Create entry for Dom0 for control messages > > - TPMTRYRETURN( VTPM_Handle_New_DMI(NULL) ); > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return(status); > > -} > > - > > -/////////////////////////////////////////////////////////////////////////////// > > -void VTPM_Stop_Manager() { > > - VTPM_DMI_RESOURCE *dmi_res; > > - struct hashtable_itr *dmi_itr; > > - > > - // Close all the TCS contexts. TCS should evict keys based on this > > - if (hashtable_count(vtpm_globals->dmi_map) > 0) { > > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > > - do { > > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > > - if (dmi_res->connected) > > - close_dmi( dmi_res ); // Not really interested in return code > > - > > - } while (hashtable_iterator_advance(dmi_itr)); > > - free (dmi_itr); > > - } > > - > > - if ( VTPM_SaveManagerData() != TPM_SUCCESS ) > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to save manager data.\n"); > > - > > - TCS_CloseContext(vtpm_globals->manager_tcs_handle); > > - TCS_destroy(); > > - > > - hashtable_destroy(vtpm_globals->dmi_map, 1); > > - free(vtpm_globals); > > - > > - Crypto_Exit(); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); > > -} > > diff --git a/tools/vtpm_manager/manager/vtpm_manager.h b/tools/vtpm_manager/manager/vtpm_manager.h > > deleted file mode 100644 > > index a324a8f..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_manager.h > > +++ /dev/null > > @@ -1,150 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_manager.h > > -// > > -// Public Interface header for VTPM Manager > > -// > > -// ================================================================== > > - > > -#ifndef __VTPM_MANAGER_H__ > > -#define __VTPM_MANAGER_H__ > > - > > -#define VTPM_TAG_REQ 0x01c1 > > -#define VTPM_TAG_RSP 0x01c4 > > -#define COMMAND_BUFFER_SIZE 4096 > > - > > -// Header sizes. Note Header MAY include the DMI > > -#define VTPM_COMMAND_HEADER_SIZE_CLT ( 2 + 4 + 4) > > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > > -#define VTPM_COMMAND_HEADER_SIZE_SRV ( 4 + VTPM_COMMAND_HEADER_SIZE_CLT ) > > -// sizeof( UINT32 + VTPM_COMMAND_HEADER_SIZE_CLT) > > - > > -//************************ 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) > > - > > -// Non-priviledged VTPM Commands (From DMI's) > > -#define VTPM_ORD_SAVENVM (VTPM_ORD_BASE + 1) // DMI Saves Secrets > > -#define VTPM_ORD_LOADNVM (VTPM_ORD_BASE + 2) // DMI Loads Secrets > > -#define VTPM_ORD_TPMCOMMAND (VTPM_ORD_BASE + 3) // DMI issues HW TPM Command > > -#define VTPM_ORD_GET_MIG_KEY (VTPM_ORD_BASE + 4) // Get manager's migration key > > -#define VTPM_ORD_LOAD_MIG_KEY (VTPM_ORD_BASE + 5) // load dest migration key > > - > > -// Priviledged VTPM Commands (From management console) > > -#define VTPM_ORD_OPEN (VTPM_PRIV_BASE + 1) // Creates/reopens DMI > > -#define VTPM_ORD_CLOSE (VTPM_PRIV_BASE + 2) // Closes a DMI > > -#define VTPM_ORD_DELETE (VTPM_PRIV_BASE + 3) // Permemently Deletes DMI > > -#define VTPM_ORD_MIGRATE_IN (VTPM_PRIV_BASE + 4) // Load migrated VTPM > > -#define VTPM_ORD_MIGRATE_OUT (VTPM_PRIV_BASE + 5) // migrate VTPM to dest > > - > > -//************************ Return Codes **************************** > > -#define VTPM_TYPE_PVM 1 // Paravirtualized Domain > > -#define VTPM_TYPE_HVM 2 // HVM Domain > > - > > -//************************ Return Codes **************************** > > -#define VTPM_SUCCESS 0 > > -#define VTPM_FAIL 1 > > -#define VTPM_UNSUPPORTED 2 > > -#define VTPM_FORBIDDEN 3 > > -#define VTPM_RESTORE_CONTEXT_FAILED 4 > > -#define VTPM_INVALID_REQUEST 5 > > - > > -//*********************** Parameter Values ************************* > > -#define VTPM_TYPE_NON_MIGRATABLE 0x00 > > -#define VTPM_TYPE_MIGRATABLE 0x01 > > -#define VTPM_TYPE_MIGRATED 0xFF // VTPM has been migrated. > > - // VTPM can be recovered or deleted only > > - > > -/******************* Command Parameter API ************************* > > - > > -VTPM Command Format > > - dmi: 4 bytes // Source of message. > > - // WARNING: This is prepended by the channel. > > - // Thus it is received by VTPM Manager, > > - // but not sent by DMI > > - tpm tag: 2 bytes > > - command size: 4 bytes // Size of command including header but not DMI > > - ord: 4 bytes // Command ordinal above > > - parameters: size - 10 bytes // Command Parameter > > - > > -VTPM Response Format > > - tpm tag: 2 bytes > > - response_size: 4 bytes > > - status: 4 bytes > > - parameters: size - 10 bytes > > - > > - > > -VTPM_Open: > > - Input Parameters: > > - mig_type: 1 byte > > - startup_mode: 1 byte // Cold Boot = 1, resume = 2, deactive = 3 > > - domain type: 1 byte > > - instance_id: 4 bytes > > - Output Parameters: > > - None > > - > > -VTPM_Close > > - Input Parameters: > > - instance_id: 4 bytes > > - Output Parameters: > > - None > > - > > -VTPM_Delete > > - Input Parameters: > > - instance_id: 4 bytes > > - Output Parameters: > > - None > > - > > -VTPM_SaveNVM > > - Input Parameters: > > - data: n bytes (Header indicates size of data) > > - Output Parameters: > > - None > > - > > -VTPM_LoadNVM > > - Input Parameters: > > - None > > - Output Parameters: > > - data: n bytes (Header indicates size of data) > > - > > -VTPM_TPMCommand > > - Input Parameters: > > - TPM Command Byte Stream: n bytes > > - Output Parameters: > > - TPM Reponse Byte Stream: n bytes > > - > > -*********************************************************************/ > > - > > -#endif //_VTPM_MANAGER_H_ > > diff --git a/tools/vtpm_manager/manager/vtpm_manager_handler.c b/tools/vtpm_manager/manager/vtpm_manager_handler.c > > deleted file mode 100644 > > index 2001074..0000000 > > --- a/tools/vtpm_manager/manager/vtpm_manager_handler.c > > +++ /dev/null > > @@ -1,488 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_manager_handler.c > > -// > > -// This file will house the main logic of the VTPM Manager > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > - > > -#include "vtpm_manager.h" > > -#include "vtpmpriv.h" > > -#include "vtsp.h" > > -#include "bsg.h" > > -#include "hashtable.h" > > -#include "hashtable_itr.h" > > -#include "log.h" > > -#include "buffer.h" > > - > > -#define vtpmhandlerloginfo(module,fmt,args...) vtpmloginfo (module, "[%s]: " fmt, thread_name, ##args ); > > -#define vtpmhandlerloginfomore(module,fmt,args...) vtpmloginfomore (module, fmt, ##args ); > > -#define vtpmhandlerlogerror(module,fmt,args...) vtpmlogerror (module, "[%s]: " fmt, thread_name, ##args ); > > - > > -// ---------------------- Prototypes ------------------- > > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > > - TPM_COMMAND_CODE ord, > > - buffer_t *command_buf, > > - buffer_t *result_buf, > > - BOOL is_priv, > > - char *thread_name); > > - > > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > > - vtpm_ipc_handle_t *rx_ipc_h, > > - VTPM_DMI_RESOURCE *dmi_res, > > - BYTE *cmd_header, > > - buffer_t *param_buf, > > - buffer_t *result_buf, > > - char *thread_name); > > - > > -TPM_RESULT VTPM_Manager_Handler( vtpm_ipc_handle_t *tx_ipc_h, > > - vtpm_ipc_handle_t *rx_ipc_h, > > - BOOL fw_tpm, // Forward TPM cmds? > > - vtpm_ipc_handle_t *fw_tx_ipc_h, > > - vtpm_ipc_handle_t *fw_rx_ipc_h, > > - BOOL is_priv, > > - char *thread_name) { > > - TPM_RESULT status = TPM_FAIL; // Should never return > > - UINT32 dmi, in_param_size, cmd_size, out_param_size, out_message_size, reply_size; > > - BYTE *cmd_header=NULL, *in_param=NULL, *out_message=NULL, *reply; > > - buffer_t *command_buf=NULL, *result_buf=NULL; > > - TPM_TAG tag; > > - TPM_COMMAND_CODE ord; > > - VTPM_DMI_RESOURCE *dmi_res; > > - int size_read, size_write, i; > > - BOOL add_header=TRUE; // This indicates to prepend a header on result_buf before sending > > - > > - cmd_header = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV); > > - command_buf = (buffer_t *) malloc(sizeof(buffer_t)); > > - result_buf = (buffer_t *) malloc(sizeof(buffer_t)); > > - > > - // ------------------------ Main Loop -------------------------------- > > - while(1) { > > - > > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "%s waiting for messages.\n", thread_name); > > - > > - // --------------------- Read Cmd from Sender ---------------- > > - > > - // Read command header > > - size_read = vtpm_ipc_read(rx_ipc_h, NULL, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > > - if (size_read > 0) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV[%d]: 0x", size_read); > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s can't read from ipc. Errono = %d. Aborting... \n", thread_name, errno); > > - goto abort_command; > > - } > > - > > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "\n"); > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command shorter than normal header (%d bytes). Aborting...\n", size_read); > > - goto abort_command; > > - } > > - > > - // Unpack header > > - BSG_UnpackList(cmd_header, 4, > > - BSG_TYPE_UINT32, &dmi, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &in_param_size, > > - BSG_TPM_COMMAND_CODE, &ord ); > > - > > - // Using the header info, read the parameters of the command > > - // Note that in_param_size is in the client's context > > - cmd_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > > - if (cmd_size > 0) { > > - in_param = (BYTE *) malloc(cmd_size); > > - size_read = vtpm_ipc_read( rx_ipc_h, NULL, in_param, cmd_size); > > - if (size_read > 0) { > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > > - > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error reading cmd from ipc. Aborting... \n", thread_name); > > - goto abort_command; > > - } > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - if (size_read < (int) cmd_size) { > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d). Aborting...\n", size_read, cmd_size); > > - goto abort_command; > > - } > > - } else { > > - in_param = NULL; > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } > > - > > - // Init the buffers used to handle the command and the response > > - if ( (buffer_init_convert(command_buf, cmd_size, in_param) != TPM_SUCCESS) || > > - (buffer_init(result_buf, 0, 0) != TPM_SUCCESS) ) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > > - goto abort_command; > > - } > > - > > - // -------------- Dispatch Commands to Handlers ----------- > > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK)) { > > - vtpm_lock_wrlock(); > > - } else { > > - vtpm_lock_rdlock(); > > - } > > - > > - if ( !(dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi)) || > > - (!dmi_res->connected) ) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempted access to non-existent or disconnected DMI %d. Aborting...\n", dmi); > > - status = TPM_BAD_PARAMETER; > > - // We have no one to reply to, they don't exist. > > - goto abort_command; > > - } > > - > > - if (tag == VTPM_TAG_REQ) { > > - > > - status = vtpm_manager_handle_vtpm_cmd(dmi_res, ord, command_buf, result_buf, is_priv, thread_name); > > - > > - } else { // This is not a VTPM Command at all. > > - if (fw_tpm) { > > - status = vtpm_manager_handle_tpm_cmd(fw_tx_ipc_h, fw_rx_ipc_h, dmi_res, cmd_header, command_buf, result_buf, thread_name); > > - > > - // This means calling the DMI failed, not that the cmd failed in the DMI > > - // Since the return will be interpretted by a TPM app, all errors are IO_ERRORs to the app > > - if (status != TPM_SUCCESS) { > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - // Unlike all other commands, forwarded commands yield a result_buf that includes the DMI's status. This > > - // should be forwarded to the caller VM > > - add_header = FALSE; > > - } else { > > - // We are not supposed to forward TPM commands at all. > > - int i; > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempt to use unsupported direct access to TPM.\n"); > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "Bad Command. dmi:%d, tag:%d, size:%d, ord:%d, Params: ", dmi, tag, in_param_size, ord); > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > > - > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - > > - status = TPM_FAIL; > > - goto abort_with_error; > > - } > > - > > - } // end else for is VTPM Command > > - > > - // ------------------- Respond to Sender ------------------ > > - > > - // Errors while handling responses jump here to reply with error messages > > - // NOTE: Currently there are no recoverable errors in multi-VM mode. If one > > - // is added to the code, this ifdef should be removed. > > - // Also note this is NOT referring to errors in commands, but rather > > - // this is about I/O errors and such. > > -#ifndef VTPM_MULTI_VM > > - abort_with_error: > > -#endif > > - > > - if (add_header) { > > - // Prepend VTPM header with destination DM stamped > > - out_param_size = buffer_len(result_buf); > > - out_message_size = VTPM_COMMAND_HEADER_SIZE_CLT + out_param_size; > > - reply_size = VTPM_COMMAND_HEADER_SIZE_SRV + out_param_size; > > - out_message = (BYTE *) malloc (reply_size); > > - reply = out_message; > > - > > - BSG_PackList(out_message, 4, > > - BSG_TYPE_UINT32, (BYTE *) &dmi, > > - BSG_TPM_TAG, (BYTE *) &tag, > > - BSG_TYPE_UINT32, (BYTE *) &out_message_size, > > - BSG_TPM_RESULT, (BYTE *) &status); > > - > > - if (buffer_len(result_buf) > 0) > > - memcpy(out_message + VTPM_COMMAND_HEADER_SIZE_SRV, result_buf->bytes, out_param_size); > > - //Note: Send message + dmi_id > > - } else { > > - reply = result_buf->bytes; > > - reply_size = buffer_len(result_buf); > > - } > > - size_write = vtpm_ipc_write(tx_ipc_h, (dmi_res ? dmi_res->tx_vtpm_ipc_h : NULL), reply, reply_size ); > > - if (size_write > 0) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > > - for (i=0; i < reply_size; i++) > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", reply[i]); > > - > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name); > > - goto abort_command; > > - } > > - free(out_message); out_message=NULL; > > - > > - if (size_write < (int)reply_size) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size); > > - goto abort_command; > > - } > > - > > - // On certain failures an error message cannot be sent. > > - // This marks the beginning of cleanup in preperation for the next command. > > - abort_command: > > - //free buffers > > - bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > > - //free(in_param); // This was converted to command_buf. No need to free > > - buffer_free(result_buf); > > - buffer_free(command_buf); > > - > > - // If we have a write lock, save the manager table > > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) && > > - (VTPM_SaveManagerData() != TPM_SUCCESS) ) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n"); > > - } > > - > > - vtpm_lock_unlock(); > > - add_header = TRUE; // Reset to the default > > - } // End while(1) > > - > > -} > > - > > -///////////////////////////////////////////////////////////////////////// > > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > > - TPM_COMMAND_CODE ord, > > - buffer_t *command_buf, > > - buffer_t *result_buf, > > - BOOL is_priv, > > - char *thread_name) { > > - > > - TPM_RESULT status = TPM_FAIL; > > - > > - switch (ord) { > > - case VTPM_ORD_SAVENVM: > > - status= VTPM_Handle_Save_NVM(dmi_res, > > - command_buf, > > - result_buf); > > - break; > > - > > - case VTPM_ORD_LOADNVM: > > - status= VTPM_Handle_Load_NVM(dmi_res, > > - command_buf, > > - result_buf); > > - break; > > - > > - case VTPM_ORD_TPMCOMMAND: > > - status= VTPM_Handle_TPM_Command(dmi_res, > > - command_buf, > > - result_buf); > > - break; > > - > > - case VTPM_ORD_GET_MIG_KEY: > > - status = VTPM_Handle_Get_Migration_key(command_buf, > > - result_buf); > > - break; > > - > > - case VTPM_ORD_LOAD_MIG_KEY: > > - status = VTPM_Handle_Load_Migration_key(command_buf, > > - result_buf); > > - break; > > - > > - default: > > - // Privileged handlers can do maintanance > > - if (is_priv) { > > - switch (ord) { > > - case VTPM_ORD_OPEN: > > - status = VTPM_Handle_New_DMI(command_buf); > > - break; > > - > > - case VTPM_ORD_CLOSE: > > - status = VTPM_Handle_Close_DMI(command_buf); > > - break; > > - > > - case VTPM_ORD_DELETE: > > - status = VTPM_Handle_Delete_DMI(command_buf); > > - break; > > - > > - case VTPM_ORD_MIGRATE_IN: > > - status = VTPM_Handle_Migrate_In(command_buf, result_buf); > > - break; > > - > > - case VTPM_ORD_MIGRATE_OUT: > > - status = VTPM_Handle_Migrate_Out(command_buf, result_buf); > > - break; > > - > > - default: > > - status = TPM_BAD_ORDINAL; > > - } // switch > > - } else { // is priv command > > - > > - status = TPM_BAD_ORDINAL; > > - } // inner switch > > - } // outer switch > > - > > - return(status); > > -} > > - > > -///////////////////////////////////////////////////////////////////// > > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > > - vtpm_ipc_handle_t *rx_ipc_h, > > - VTPM_DMI_RESOURCE *dmi_res, > > - BYTE *cmd_header, > > - buffer_t *param_buf, > > - buffer_t *result_buf, > > - char *thread_name) { > > - > > - TPM_RESULT status = TPM_FAIL; > > - UINT32 dmi_dst; > > - TPM_COMMAND_CODE ord; > > - TPM_TAG tag_out; > > - UINT32 dmi_cmd_size, in_param_size, adj_param_size; > > - BYTE *dmi_cmd, *in_param; > > - int size_read, size_write, i; > > - > > - //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness > > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n"); > > - status = TPM_FAIL; > > - goto abort_with_error; > > - } > > - > > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n"); > > - > > - //Forward TPM CMD stamped with dmi_id to DMI for handling > > - if (buffer_len(param_buf)) { > > - dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf)); > > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); > > - memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > > - memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf)); > > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size); > > - > > - if (size_write > 0) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", dmi_cmd[i]); > > - } > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - free(dmi_cmd); > > - } else { > > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV; > > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV ); > > - if (size_write > 0) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > > - > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - } > > - > > - if (size_write != (int) dmi_cmd_size) > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Could not write entire command to DMI (%d/%d)\n", size_write, dmi_cmd_size); > > - > > - buffer_free(param_buf); > > - > > - // Read header for response to TPM command from DMI > > - size_read = vtpm_ipc_read( rx_ipc_h, dmi_res->rx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > > - if (size_read > 0) { > > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x"); > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > > - > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from DMI. Aborting... \n"); > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - > > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command from DMI shorter than normal header. Aborting...\n"); > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - > > - // Unpack response from DMI for TPM command > > - BSG_UnpackList(cmd_header, 4, > > - BSG_TYPE_UINT32, &dmi_dst, > > - BSG_TPM_TAG, &tag_out, > > - BSG_TYPE_UINT32, &in_param_size, > > - BSG_TPM_COMMAND_CODE, &status ); > > - > > - // If response has parameters, read them. > > - // Note that in_param_size is in the client's context > > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > > - if (adj_param_size > 0) { > > - in_param = (BYTE *) malloc(adj_param_size); > > - size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size); > > - if (size_read > 0) { > > - for (i=0; i > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > > - > > - } else { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from BE. Aborting... \n"); > > - goto abort_with_error; > > - } > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > > - > > - if (size_read < (int)adj_param_size) { > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) from DMI is shorter than header indicates(%d). Aborting...\n", size_read, adj_param_size); > > - status = TPM_IOERROR; > > - goto abort_with_error; > > - } > > - } else { > > - in_param = NULL; > > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > > - } > > - > > - if ( (buffer_init(result_buf, VTPM_COMMAND_HEADER_SIZE_SRV, cmd_header) != TPM_SUCCESS) || > > - (buffer_append_raw(result_buf, adj_param_size, in_param) != TPM_SUCCESS) ) { > > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > > - status = TPM_FAIL; > > - goto abort_with_error; > > - } > > - > > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Sending DMI's response to guest.\n"); > > - > > - status = TPM_SUCCESS; > > - > > - abort_with_error: > > - > > - return status; > > -} > > - > > diff --git a/tools/vtpm_manager/manager/vtpmd.c b/tools/vtpm_manager/manager/vtpmd.c > > deleted file mode 100644 > > index cf58ba3..0000000 > > --- a/tools/vtpm_manager/manager/vtpmd.c > > +++ /dev/null > > @@ -1,371 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpmd.c > > -// > > -// Application > > -// > > -// =================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include "vtpm_manager.h" > > -#include "vtpmpriv.h" > > -#include "tcg.h" > > -#include "log.h" > > -#include "vtpm_ipc.h" > > - > > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > > - > > -#define VTPM_BE_FNAME "/dev/vtpm" > > -#define VTPM_DUMMY_TX_BE_FNAME "/var/vtpm/fifos/dummy_out.fifo" > > -#define VTPM_DUMMY_RX_BE_FNAME "/var/vtpm/fifos/dummy_in.fifo" > > -#define VTPM_TX_TPM_FNAME "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > > -#define VTPM_RX_TPM_FNAME "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > > -#define VTPM_TX_VTPM_FNAME "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > > -#define VTPM_RX_VTPM_FNAME "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > > - > > -#define VTPM_TYPE_PVM_STRING "pvm" > > -#define VTPM_TYPE_HVM_STRING "hvm" > > - > > -struct vtpm_thread_params_s { > > - vtpm_ipc_handle_t *tx_ipc_h; > > - vtpm_ipc_handle_t *rx_ipc_h; > > - BOOL fw_tpm; > > - vtpm_ipc_handle_t *fw_tx_ipc_h; > > - vtpm_ipc_handle_t *fw_rx_ipc_h; > > - BOOL is_priv; > > - char *thread_name; > > -}; > > - > > -// This is needed to all extra_close_dmi to close this to prevent a > > -// broken pipe when no DMIs are left. > > -static vtpm_ipc_handle_t *g_rx_tpm_ipc_h; > > - > > -void *vtpm_manager_thread(void *arg_void) { > > - TPM_RESULT *status = (TPM_RESULT *) malloc(sizeof(TPM_RESULT) ); > > - struct vtpm_thread_params_s *arg = (struct vtpm_thread_params_s *) arg_void; > > - > > - *status = VTPM_Manager_Handler(arg->tx_ipc_h, arg->rx_ipc_h, > > - arg->fw_tpm, arg->fw_tx_ipc_h, arg->fw_rx_ipc_h, > > - arg->is_priv, arg->thread_name); > > - > > - return (status); > > -} > > - > > - > > -void signal_handler(int reason) { > > - if (pthread_equal(pthread_self(), vtpm_globals->master_pid)) { > > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager shutting down for signal %d.\n", reason); > > - } else { > > - // For old Linux Thread machines, signals are delivered to each thread. Deal with them. > > - vtpmloginfo(VTPM_LOG_VTPM, "Child shutting down\n"); > > - pthread_exit(NULL); > > - } > > - > > - VTPM_Stop_Manager(); > > - exit(-1); > > -} > > - > > -struct sigaction ctl_c_handler; > > - > > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - int fh; > > - char dmi_id_str[11]; // UINT32s are up to 10 digits + NULL > > - char *tx_vtpm_name, *tx_tpm_name, *vm_type_string; > > - struct stat file_info; > > - > > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > > - dmi_res->tx_tpm_ipc_h = NULL; > > - dmi_res->rx_tpm_ipc_h = NULL; > > - dmi_res->tx_vtpm_ipc_h = NULL; > > - dmi_res->rx_vtpm_ipc_h = NULL; > > - } else { > > - // Create a pair of fifo pipes > > - dmi_res->rx_tpm_ipc_h = NULL; > > - dmi_res->rx_vtpm_ipc_h = NULL; > > - > > - if ( ((dmi_res->tx_tpm_ipc_h = (vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > > - ((dmi_res->tx_vtpm_ipc_h =(vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > > - ((tx_tpm_name = (char *) malloc(11 + strlen(VTPM_TX_TPM_FNAME))) == NULL ) || > > - ((tx_vtpm_name =(char *) malloc(11 + strlen(VTPM_TX_VTPM_FNAME))) == NULL) ) { > > - status =TPM_RESOURCES; > > - goto abort_egress; > > - } > > - > > - sprintf(tx_tpm_name, VTPM_TX_TPM_FNAME, (uint32_t) dmi_res->dmi_id); > > - sprintf(tx_vtpm_name, VTPM_TX_VTPM_FNAME, (uint32_t) dmi_res->dmi_id); > > - > > - if ( (vtpm_ipc_init(dmi_res->tx_tpm_ipc_h, tx_tpm_name, O_WRONLY | O_NONBLOCK, TRUE) != 0) || > > - (vtpm_ipc_init(dmi_res->tx_vtpm_ipc_h, tx_vtpm_name, O_WRONLY, TRUE) != 0) ) { //FIXME: O_NONBLOCK? > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - // Measure DMI > > - // FIXME: This will measure DMI. Until then use a fixed DMI_Measurement value > > - // Also, this mechanism is specific to 1 VM architecture. > > - /* > > - fh = open(TPM_EMULATOR_PATH, O_RDONLY); > > - stat_ret = fstat(fh, &file_stat); > > - if (stat_ret == 0) > > - dmi_size = file_stat.st_size; > > - else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not open vtpmd!!\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - dmi_buffer > > - */ > > - memset(&dmi_res->DMI_measurement, 0xcc, sizeof(TPM_DIGEST)); > > - > > - if (vm_type == VTPM_TYPE_PVM) > > - vm_type_string = (BYTE *)&VTPM_TYPE_PVM_STRING; > > - else > > - vm_type_string = (BYTE *)&VTPM_TYPE_HVM_STRING; > > - > > - // Launch DMI > > - sprintf(dmi_id_str, "%d", (int) dmi_res->dmi_id); > > -#ifdef MANUAL_DM_LAUNCH > > - vtpmlogerror(VTPM_LOG_VTPM, "Manually start VTPM with dmi=%s now.\n", dmi_id_str); > > - dmi_res->dmi_pid = 0; > > -#else > > - pid_t pid = fork(); > > - > > - if (pid == -1) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not fork to launch vtpm\n"); > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } else if (pid == 0) { > > - switch (startup_mode) { > > - case TPM_ST_CLEAR: > > - execl (TPM_EMULATOR_PATH, "vtpmd", "clear", vm_type_string, dmi_id_str, NULL); > > - break; > > - case TPM_ST_STATE: > > - execl (TPM_EMULATOR_PATH, "vtpmd", "save", vm_type_string, dmi_id_str, NULL); > > - break; > > - case TPM_ST_DEACTIVATED: > > - execl (TPM_EMULATOR_PATH, "vtpmd", "deactivated", vm_type_string, dmi_id_str, NULL); > > - break; > > - default: > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // Returning from these at all is an error. > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not exec to launch vtpm\n"); > > - } else { > > - dmi_res->dmi_pid = pid; > > - vtpmloginfo(VTPM_LOG_VTPM, "Launching DMI on PID = %d\n", pid); > > - } > > -#endif // MANUAL_DM_LAUNCH > > - > > - } // If DMI = VTPM_CTL_DM > > - status = TPM_SUCCESS; > > - > > -abort_egress: > > - return (status); > > -} > > - > > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - if (vtpm_globals->connected_dmis == 0) { > > - // No more DMI's connected. Close fifo to prevent a broken pipe. > > - // This is hackish. Need to think of another way. > > - vtpm_ipc_close(g_rx_tpm_ipc_h); > > - } > > - > > - > > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > > - vtpm_ipc_close(dmi_res->tx_tpm_ipc_h); > > - vtpm_ipc_close(dmi_res->tx_vtpm_ipc_h); > > - > > - free(dmi_res->tx_tpm_ipc_h->name); > > - free(dmi_res->tx_vtpm_ipc_h->name); > > - > > -#ifndef MANUAL_DM_LAUNCH > > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > > - if (dmi_res->dmi_pid != 0) { > > - vtpmloginfo(VTPM_LOG_VTPM, "Killing dmi on pid %d.\n", dmi_res->dmi_pid); > > - if (kill(dmi_res->dmi_pid, SIGKILL) !=0) { > > - vtpmloginfo(VTPM_LOG_VTPM, "DMI on pid %d is already dead.\n", dmi_res->dmi_pid); > > - } else if (waitpid(dmi_res->dmi_pid, NULL, 0) != dmi_res->dmi_pid) { > > - vtpmlogerror(VTPM_LOG_VTPM, "DMI on pid %d failed to stop.\n", dmi_res->dmi_pid); > > - status = TPM_FAIL; > > - } > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not kill dmi because it's pid was 0.\n"); > > - status = TPM_FAIL; > > - } > > - } > > -#endif > > - > > - } //endif ! dom0 > > - return status; > > -} > > - > > - > > -int main(int argc, char **argv) { > > - vtpm_ipc_handle_t *tx_be_ipc_h, *rx_be_ipc_h, rx_tpm_ipc_h, rx_vtpm_ipc_h, tx_hp_ipc_h, rx_hp_ipc_h; > > - struct vtpm_thread_params_s be_thread_params, dmi_thread_params, hp_thread_params; > > - pthread_t be_thread, dmi_thread, hp_thread; > > - > > -#ifdef DUMMY_BACKEND > > - vtpm_ipc_handle_t tx_dummy_ipc_h, rx_dummy_ipc_h; > > -#else > > - vtpm_ipc_handle_t real_be_ipc_h; > > -#endif > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Starting VTPM.\n"); > > - > > - // -------------------- Initialize Manager ----------------- > > - if (VTPM_Init_Manager() != TPM_SUCCESS) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Closing vtpmd due to error during startup.\n"); > > - return -1; > > - } > > - > > - // -------------------- Setup Ctrl+C Handlers -------------- > > - ctl_c_handler.sa_handler = signal_handler; > > - sigemptyset(&ctl_c_handler.sa_mask); > > - ctl_c_handler.sa_flags = 0; > > - > > - if (sigaction(SIGINT, &ctl_c_handler, NULL) == -1) > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGINT handler. Ctl+break will not stop manager gently.\n"); > > - > > - // For easier debuggin with gdb > > - if (sigaction(SIGHUP, &ctl_c_handler, NULL) == -1) > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGHUP handler. Ctl+break will not stop manager gently.\n"); > > - > > - sigset_t sig_mask; > > - sigemptyset(&sig_mask); > > - sigaddset(&sig_mask, SIGPIPE); > > - sigprocmask(SIG_BLOCK, &sig_mask, NULL); > > - > > - // ------------------- Set up file ipc structures ---------- > > -#ifdef DUMMY_BACKEND > > - if ( (vtpm_ipc_init(&tx_dummy_ipc_h, VTPM_DUMMY_TX_BE_FNAME, O_RDWR, TRUE) != 0) || > > - (vtpm_ipc_init(&rx_dummy_ipc_h, VTPM_DUMMY_RX_BE_FNAME, O_RDWR, TRUE) != 0) ) { > > - > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create Dummy BE FIFOs.\n"); > > - exit(-1); > > - } > > - > > - tx_be_ipc_h = &tx_dummy_ipc_h; > > - rx_be_ipc_h = &rx_dummy_ipc_h; > > -#else > > - vtpm_ipc_init(&real_be_ipc_h, VTPM_BE_FNAME, O_RDWR, FALSE); > > - > > - tx_be_ipc_h = &real_be_ipc_h; > > - rx_be_ipc_h = &real_be_ipc_h; > > -#endif > > - > > - if ( (vtpm_ipc_init(&rx_tpm_ipc_h, VTPM_RX_TPM_FNAME, O_RDONLY, TRUE) != 0) || > > - (vtpm_ipc_init(&rx_vtpm_ipc_h, VTPM_RX_VTPM_FNAME, O_RDWR, TRUE) != 0) || //FIXME: O_RDONLY? > > - (vtpm_ipc_init(&tx_hp_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || > > - (vtpm_ipc_init(&rx_hp_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create initial FIFOs.\n"); > > - exit(-1); > > - } > > - > > - g_rx_tpm_ipc_h = &rx_tpm_ipc_h; > > - > > - // -------------------- Set up thread params ------------- > > - > > - be_thread_params.tx_ipc_h = tx_be_ipc_h; > > - be_thread_params.rx_ipc_h = rx_be_ipc_h; > > - be_thread_params.fw_tpm = TRUE; > > - be_thread_params.fw_tx_ipc_h = NULL; > > - be_thread_params.fw_rx_ipc_h = &rx_tpm_ipc_h; > > - be_thread_params.is_priv = FALSE; > > - be_thread_params.thread_name = "Backend Listener"; > > - > > - dmi_thread_params.tx_ipc_h = NULL; > > - dmi_thread_params.rx_ipc_h = &rx_vtpm_ipc_h; > > - dmi_thread_params.fw_tpm = FALSE; > > - dmi_thread_params.fw_tx_ipc_h = NULL; > > - dmi_thread_params.fw_rx_ipc_h = NULL; > > - dmi_thread_params.is_priv = FALSE; > > - dmi_thread_params.thread_name = "VTPM Listener"; > > - > > - hp_thread_params.tx_ipc_h = &tx_hp_ipc_h; > > - hp_thread_params.rx_ipc_h = &rx_hp_ipc_h; > > - hp_thread_params.fw_tpm = FALSE; > > - hp_thread_params.fw_tx_ipc_h = NULL; > > - hp_thread_params.fw_rx_ipc_h = NULL; > > - hp_thread_params.is_priv = TRUE; > > - hp_thread_params.thread_name = "Hotplug Listener"; > > - > > - // --------------------- Launch Threads ----------------- > > - > > - vtpm_lock_init(); > > - > > - vtpm_globals->master_pid = pthread_self(); > > - > > - if (pthread_create(&be_thread, NULL, vtpm_manager_thread, &be_thread_params) != 0) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch BE Thread.\n"); > > - exit(-1); > > - } > > - > > - if (pthread_create(&dmi_thread, NULL, vtpm_manager_thread, &dmi_thread_params) != 0) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch DMI Thread.\n"); > > - exit(-1); > > - } > > - > > - > > - if (pthread_create(&hp_thread, NULL, vtpm_manager_thread, &hp_thread_params) != 0) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch HP Thread.\n"); > > - exit(-1); > > - } > > - > > - //Join the other threads until exit time. > > - pthread_join(be_thread, NULL); > > - pthread_join(dmi_thread, NULL); > > - pthread_join(hp_thread, NULL); > > - > > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Manager shut down unexpectedly.\n"); > > - > > - VTPM_Stop_Manager(); > > - vtpm_lock_destroy(); > > - return 0; > > -} > > diff --git a/tools/vtpm_manager/manager/vtpmpriv.h b/tools/vtpm_manager/manager/vtpmpriv.h > > deleted file mode 100644 > > index 41e8d2d..0000000 > > --- a/tools/vtpm_manager/manager/vtpmpriv.h > > +++ /dev/null > > @@ -1,186 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpmpriv.h > > -// > > -// Structures and functions private to the manager > > -// > > -// ================================================================== > > - > > -#ifndef __VTPMPRIV_H__ > > -#define __VTPMPRIV_H__ > > - > > -#include "vtpm_manager.h" > > -#include "tcg.h" > > -#include "tcs.h" > > -#include "buffer.h" > > -#include "crypto.h" > > -#include "vtpm_ipc.h" > > - > > -#define VTPM_MANAGER_GEN 2 // This is incremented when the manager's table > > - // is changed. It's used for backwards compatability > > - > > -#define STATE_FILE "/var/vtpm/VTPM" > > -#define DMI_NVM_FILE "/var/vtpm/vtpm_dm_%d.data" > > -#define VTPM_CTL_DM 0 > > - > > -// ------------------------ Private Structures ----------------------- > > -typedef struct VTPM_DMI_RESOURCE_T { > > - // I/O info for Manager to talk to DMI's and controllers > > - vtpm_ipc_handle_t *tx_vtpm_ipc_h; // TX VTPM Results to DMI > > - vtpm_ipc_handle_t *rx_vtpm_ipc_h; // RX VTPM Commands from DMI > > - vtpm_ipc_handle_t *tx_tpm_ipc_h; // TX TPM Commands to DMI > > - vtpm_ipc_handle_t *rx_tpm_ipc_h; // RX TPM Results from DMI > > - > > -#ifndef VTPM_MULTI_VM > > - pid_t dmi_pid; > > -#endif > > - > > - // Non-persistent Information > > - bool connected; > > - UINT32 dmi_domain_id; > > - TCS_CONTEXT_HANDLE TCSContext; // TCS Handle > > - char *NVMLocation; // NULL term string indicating location > > - // of NVM. > > - // Persistent Information about DMI > > - UINT32 dmi_id; > > - BYTE dmi_type; > > - TPM_DIGEST NVM_measurement; // Equal to the SHA1 of the blob > > - TPM_DIGEST DMI_measurement; // Correct measurement of the owning DMI > > -} VTPM_DMI_RESOURCE; > > - > > -typedef struct tdVTPM_MIGKEY_LIST { > > - UINT32 name_size; > > - BYTE *name; // Name of destination (IP addr, domain name, etc) > > - CRYPTO_INFO key; > > - struct tdVTPM_MIGKEY_LIST *next; > > -} VTPM_MIGKEY_LIST; > > - > > - > > -typedef struct tdVTPM_GLOBALS { > > - // Non-persistent data > > -#ifndef VTPM_MULTI_VM > > - pid_t master_pid; > > -#endif > > - > > - int connected_dmis; // To close guest_rx when no dmis are connected > > - > > - struct hashtable *dmi_map; // Table of all DMI's known indexed by persistent instance # > > - VTPM_MIGKEY_LIST *mig_keys; // Table of migration keys > > - // Currently keys are loaded at migration time, > > - // TODO: Make VTPM man store a keys persistently > > - // and update script to check if key is needed > > - // before fetching it. > > - > > - TCS_CONTEXT_HANDLE manager_tcs_handle; // TCS Handle used by manager > > - TPM_HANDLE storageKeyHandle; // Key used by persistent store > > - CRYPTO_INFO storageKey; // For software encryption > > - CRYPTO_INFO bootKey; // For saving table > > - TCS_AUTH keyAuth; // OIAP session for storageKey > > - > > - // Persistent Data > > - TPM_AUTHDATA owner_usage_auth; // OwnerAuth of real TPM > > - buffer_t storageKeyWrap; // Wrapped copy of storageKey > > - TPM_AUTHDATA srk_usage_auth; > > - TPM_AUTHDATA storage_key_usage_auth; > > - > > - buffer_t bootKeyWrap; // Wrapped copy of boot key > > - > > -}VTPM_GLOBALS; > > - > > -// --------------------------- Global Values -------------------------- > > -extern VTPM_GLOBALS *vtpm_globals; // Key info and DMI states > > -extern const TPM_AUTHDATA SRK_AUTH; // SRK Well Known Auth Value > > - > > -// ********************** VTPM Functions ************************* > > -TPM_RESULT VTPM_Init_Manager(); // Start VTPM Service > > -void VTPM_Stop_Manager(); // Stop VTPM Service > > -TPM_RESULT VTPM_Manager_Handler(vtpm_ipc_handle_t *tx_ipc_h, > > - vtpm_ipc_handle_t *rx_ipc_h, > > - BOOL fw_tpm, // Should forward TPM cmds > > - vtpm_ipc_handle_t *fw_tx_ipc_h, > > - vtpm_ipc_handle_t *fw_rx_ipc_h, > > - BOOL is_priv, > > - char *client_name); > > - > > -// ********************** Command Handler Prototypes *********************** > > - > > -TPM_RESULT VTPM_Handle_Load_NVM( VTPM_DMI_RESOURCE *myDMI, > > - const buffer_t *inbuf, > > - buffer_t *outbuf); > > - > > -TPM_RESULT VTPM_Handle_Save_NVM( VTPM_DMI_RESOURCE *myDMI, > > - const buffer_t *inbuf, > > - buffer_t *outbuf); > > - > > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > > - buffer_t *inbuf, > > - buffer_t *outbuf); > > - > > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf); > > - > > -TPM_RESULT VTPM_Handle_Close_DMI(const buffer_t *param_buf); > > - > > -TPM_RESULT VTPM_Handle_Delete_DMI(const buffer_t *param_buf); > > - > > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > > - buffer_t *result_buf); > > - > > -TPM_RESULT VTPM_Handle_Migrate_Out ( const buffer_t *param_buf, > > - buffer_t *result_buf); > > - > > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > > - buffer_t *result_buf); > > - > > -TPM_RESULT VTPM_SaveManagerData(void); > > -TPM_RESULT VTPM_LoadManagerData(void); > > - > > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode); > > - > > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res); > > - > > -// Helper functions > > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res); > > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE type, VTPM_DMI_RESOURCE **dmi_res); > > - > > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > > - CRYPTO_INFO *asymkey, > > - buffer_t *sealed_data); > > - > > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > > - TCS_CONTEXT_HANDLE TCSContext, > > - TPM_HANDLE keyHandle, > > - const TPM_AUTHDATA *key_usage_auth, > > - buffer_t *unsealed_data); > > - > > -#endif // __VTPMPRIV_H__ > > diff --git a/tools/vtpm_manager/manager/vtsp.c b/tools/vtpm_manager/manager/vtsp.c > > deleted file mode 100644 > > index fc8a66f..0000000 > > --- a/tools/vtpm_manager/manager/vtsp.c > > +++ /dev/null > > @@ -1,1042 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtsp.c > > -// > > -// Higher level interface to TCS for use in service. > > -// > > -// ================================================================== > > - > > -#include > > -#include "tcg.h" > > -#include "tcs.h" > > -#include "bsg.h" > > -#include "log.h" > > -#include "crypto.h" > > -#include "vtsp.h" > > -#include "buffer.h" > > - > > -#define RSA_KEY_SIZE 0x0800 > > - > > -/*********************************************************************************** > > - * GenerateAuth: Generate authorization info to be sent back to application > > - * > > - * Parameters: outParamDigestText The concatenation of output parameters to be SHA1ed > > - * outParamDigestTextSize Size of inParamDigestText > > - * HMACkey Key to be used for HMACing > > - * For OIAP use key.authUsage or PersistStore.ownerAuth > > - * For OSAP use shared secret > > - * pAuth Authorization information from the application > > - * > > - * Return: TPM_SUCCESS Authorization data created > > - * TPM_AUTHFAIL Invalid (NULL) HMACkey presented for OSAP > > - *************************************************************************************/ > > -TPM_RESULT GenerateAuth( /*[IN]*/ const BYTE *inParamDigestText, > > - /*[IN]*/ UINT32 inParamDigestTextSize, > > - /*[IN]*/ const TPM_SECRET *HMACkey, > > - /*[IN,OUT]*/ TCS_AUTH *auth) { > > - > > - if (inParamDigestText == NULL || auth == NULL) > > - return (TPM_AUTHFAIL); > > - else { > > - > > - //Generate new OddNonce > > - Crypto_GetRandom(auth->NonceOdd.nonce, sizeof(TPM_NONCE)); > > - > > - // Create SHA1 inParamDigest > > - TPM_DIGEST inParamDigest; > > - Crypto_SHA1Full(inParamDigestText, inParamDigestTextSize, (BYTE *) &inParamDigest); > > - > > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > > - > > - BSG_PackList( hmacText, 4, > > - BSG_TPM_DIGEST, &inParamDigest, > > - BSG_TPM_NONCE, &(auth->NonceEven), > > - BSG_TPM_NONCE, &(auth->NonceOdd), > > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > > - > > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &(auth->HMAC)); > > - > > - return(TPM_SUCCESS); > > - > > - } > > -} > > - > > -/*********************************************************************************** > > - * VerifyAuth: Verify the authdata for a command requiring authorization > > - * > > - * Parameters: inParamDigestText The concatenation of parameters to be SHA1ed > > - * inParamDigestTextSize Size of inParamDigestText > > - * authDataUsage AuthDataUsage for the Entity being used > > - * Key->authDataUsage or TPM_AUTH_OWNER > > - * HMACkey Key to be used for HMACing > > - * For OIAP use key.authUsage or PersistStore.ownerAuth > > - * For OSAP use NULL (It will be aquired from the Auth Session) > > - * If unknown (default), assume OIAP > > - * sessionAuth A TCS_AUTH info for the session > > - * pAuth Authorization information from the application > > - * hContext If specified, on failed Auth, VerifyAuth will > > - * generate a new OIAP session in place of themselves > > - * destroyed session. > > - * > > - * Return: TPM_SUCCESS Authorization Verified > > - * TPM_AUTHFAIL Authorization Failed > > - * TPM_FAIL Failure during SHA1 routines > > - *************************************************************************************/ > > -TPM_RESULT VerifyAuth( /*[IN]*/ const BYTE *outParamDigestText, > > - /*[IN]*/ UINT32 outParamDigestTextSize, > > - /*[IN]*/ const TPM_SECRET *HMACkey, > > - /*[IN,OUT]*/ TCS_AUTH *auth, > > - /*[IN]*/ TCS_CONTEXT_HANDLE hContext) { > > - if (outParamDigestText == NULL || auth == NULL) > > - return (TPM_AUTHFAIL); > > - > > - > > - // Create SHA1 inParamDigest > > - TPM_DIGEST outParamDigest; > > - Crypto_SHA1Full(outParamDigestText, outParamDigestTextSize, (BYTE *) &outParamDigest); > > - > > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > > - TPM_DIGEST hm; > > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > > - > > - BSG_PackList( hmacText, 4, > > - BSG_TPM_DIGEST, &outParamDigest, > > - BSG_TPM_NONCE, &(auth->NonceEven), > > - BSG_TPM_NONCE, &(auth->NonceOdd), > > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > > - > > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), > > - (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &hm); > > - > > - // Compare correct HMAC with provided one. > > - if (memcmp (&hm, &(auth->HMAC), sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality > > - if (!auth->fContinueAuthSession) > > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM by fContinue=0.\n", auth->AuthHandle); > > - > > - return (TPM_SUCCESS); > > - } else { > > - // If specified, reconnect the OIAP session. > > - // NOTE: This only works for TCS's that never have a 0 context. > > - if (hContext) { > > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM due to failure.\n", auth->AuthHandle); > > - VTSP_OIAP( hContext, auth); > > - } > > - return (TPM_AUTHFAIL); > > - } > > -} > > - > > -TPM_RESULT VTSP_OIAP(const TCS_CONTEXT_HANDLE hContext, > > - TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "OIAP.\n"); > > - TPM_RESULT status = TPM_SUCCESS; > > - TPMTRYRETURN( TCSP_OIAP(hContext, > > - &auth->AuthHandle, > > - &auth->NonceEven) ); > > - > > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > > - auth->fContinueAuthSession = FALSE; > > - > > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > -} > > - > > -TPM_RESULT VTSP_OSAP(const TCS_CONTEXT_HANDLE hContext, > > - const TPM_ENTITY_TYPE entityType, > > - const UINT32 entityValue, > > - const TPM_AUTHDATA *usageAuth, > > - TPM_SECRET *sharedSecret, > > - TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "OSAP.\n"); > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_NONCE nonceEvenOSAP, nonceOddOSAP; > > - > > - Crypto_GetRandom((BYTE *) &nonceOddOSAP, sizeof(TPM_NONCE) ); > > - > > - TPMTRYRETURN( TCSP_OSAP( hContext, > > - entityType, > > - entityValue, > > - nonceOddOSAP, > > - &auth->AuthHandle, > > - &auth->NonceEven, > > - &nonceEvenOSAP) ); > > - > > - // Calculating Session Secret > > - BYTE sharedSecretText[TPM_DIGEST_SIZE * 2]; > > - > > - BSG_PackList( sharedSecretText, 2, > > - BSG_TPM_NONCE, &nonceEvenOSAP, > > - BSG_TPM_NONCE, &nonceOddOSAP); > > - > > - Crypto_HMAC(sharedSecretText, sizeof(sharedSecretText), (BYTE *) usageAuth, TPM_DIGEST_SIZE, (BYTE *) sharedSecret); > > - > > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > > - auth->fContinueAuthSession = FALSE; > > - > > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > -} > > - > > - > > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > > - const TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Terminate Handle.\n"); > > - TPM_RESULT status = TPM_SUCCESS; > > - TPMTRYRETURN( TCSP_TerminateHandle(hContext, auth->AuthHandle) ); > > - > > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM_TerminateHandle.\n", auth->AuthHandle); > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > -} > > - > > - > > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > > - CRYPTO_INFO *crypto_info) { > > - > > - TPM_RESULT status; > > - TPM_NONCE antiReplay; > > - TPM_DIGEST checksum; > > - BYTE *pubEKtext; > > - UINT32 pubEKtextsize; > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Reading Public EK.\n"); > > - > > - // GenerateAuth new nonceOdd > > - Crypto_GetRandom(&antiReplay, sizeof(TPM_NONCE) ); > > - > > - > > - TPMTRYRETURN( TCSP_ReadPubek( hContext, > > - antiReplay, > > - &pubEKtextsize, > > - &pubEKtext, > > - &checksum) ); > > - > > - > > - // Extract the remaining output parameters > > - TPM_PUBKEY pubEK; > > - > > - BSG_Unpack(BSG_TPM_PUBKEY, pubEKtext, (BYTE *) &pubEK); > > - > > - // Build CryptoInfo for the bindingKey > > - TPM_RSA_KEY_PARMS rsaKeyParms; > > - > > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > > - pubEK.algorithmParms.parms, > > - &rsaKeyParms); > > - > > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > > - rsaKeyParms.exponent, > > - pubEK.pubKey.keyLength, > > - pubEK.pubKey.key, > > - crypto_info); > > - > > - // Destroy rsaKeyParms > > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > > - > > - // Set encryption scheme > > - crypto_info->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > > - //crypto_info->encScheme = pubEK.algorithmParms.encScheme; > > - crypto_info->algorithmID = pubEK.algorithmParms.algorithmID; > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > -} > > - > > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_AUTHDATA *ownerAuth, > > - const TPM_AUTHDATA *srkAuth, > > - CRYPTO_INFO *ek_cryptoInfo, > > - TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Taking Ownership of TPM.\n"); > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_TakeOwnership; > > - TPM_PROTOCOL_ID proto_id = TPM_PID_OWNER; > > - BYTE *new_srk; > > - > > - BYTE *paramText; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - // vars for srkpubkey parameter > > - TPM_KEY srkPub; > > - TPM_KEY_PARMS srkKeyInfo = {TPM_ALG_RSA, TPM_ES_RSAESOAEP_SHA1_MGF1, TPM_SS_NONE, 12, 0}; > > - BYTE srkRSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > > - srkKeyInfo.parms = (BYTE *) &srkRSAkeyInfo; > > - > > - struct pack_buf_t srkText; > > - > > - //These values are accurate for an enc(AuthData). > > - struct pack_buf_t encOwnerAuth, encSrkAuth; > > - > > - encOwnerAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > > - encSrkAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > > - > > - if (encOwnerAuth.data == NULL || encSrkAuth.data == NULL) { > > - vtpmloginfo(VTPM_LOG_VTSP, "Could not malloc encrypted auths.\n"); > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } > > - > > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) ownerAuth, &encOwnerAuth.size, encOwnerAuth.data); > > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) srkAuth, &encSrkAuth.size, encSrkAuth.data); > > - > > - > > - // Build srk public key struct > > - srkPub.ver = TPM_STRUCT_VER_1_1; > > - srkPub.keyUsage = TPM_KEY_STORAGE; > > - srkPub.keyFlags = 0x00; > > - srkPub.authDataUsage = TPM_AUTH_ALWAYS; > > - memcpy(&srkPub.algorithmParms, &srkKeyInfo, sizeof(TPM_KEY_PARMS)); > > - srkPub.PCRInfoSize = 0; > > - srkPub.PCRInfo = 0; > > - srkPub.pubKey.keyLength= 0; > > - srkPub.encDataSize = 0; > > - > > - srkText.data = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - srkText.size = BSG_Pack(BSG_TPM_KEY, (BYTE *) &srkPub, srkText.data); > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 5, > > - BSG_TPM_COMMAND_CODE,&command, > > - BSG_TPM_PROTOCOL_ID, &proto_id, > > - BSG_TPM_SIZE32_DATA, &encOwnerAuth, > > - BSG_TPM_SIZE32_DATA, &encSrkAuth, > > - BSG_TPM_KEY, &srkPub); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, ownerAuth, auth) ); > > - > > - new_srk = srkText.data; > > - TPMTRYRETURN( TCSP_TakeOwnership ( hContext, > > - proto_id, > > - encOwnerAuth.size, > > - encOwnerAuth.data, > > - encSrkAuth.size, > > - encSrkAuth.data, > > - &srkText.size, > > - &new_srk, > > - auth ) ); > > - > > - > > - paramTextSize = BSG_PackList(paramText, 2, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command); > > - memcpy(paramText + paramTextSize, new_srk, srkText.size); > > - paramTextSize += srkText.size; > > - > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - ownerAuth, auth, > > - hContext) ); > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - free(srkText.data); > > - free(encSrkAuth.data); > > - free(encOwnerAuth.data); > > - free(paramText); > > - > > - TCS_FreeMemory(hContext, new_srk); > > - > > - return status; > > -} > > - > > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_AUTHDATA *ownerAuth, > > - TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Disabling Pubek Read.\n"); > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_DisablePubekRead; > > - > > - BYTE *paramText; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 1, > > - BSG_TPM_COMMAND_CODE, &command); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - ownerAuth, auth) ); > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_DisablePubekRead ( hContext, // in > > - auth) ); > > - > > - // Verify Auth > > - paramTextSize = BSG_PackList(paramText, 2, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - ownerAuth, auth, > > - hContext) ); > > - goto egress; > > - > > - abort_egress: > > - egress: > > - free(paramText); > > - return status; > > -} > > - > > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_USAGE usage, > > - const TPM_AUTHDATA *newKeyAuth, > > - const TCS_KEY_HANDLE parentHandle, > > - const TPM_AUTHDATA *osapSharedSecret, > > - buffer_t *pubKeyBuf, > > - TCS_AUTH *auth) { > > - > > - int i; > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_CreateWrapKey; > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Creating new key of type %d.\n", usage); > > - > > - // vars for Calculate encUsageAuth > > - BYTE *paramText; > > - UINT32 paramTextSize; > > - > > - // vars for Calculate encUsageAuth > > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > > - TPM_DIGEST XORKey1; > > - UINT32 XORbufferSize; > > - TPM_SECRET encUsageAuth, encMigrationAuth; > > - > > - // vars for Flatten newKey prototype > > - BYTE *flatKey = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - UINT32 flatKeySize = TCPA_MAX_BUFFER_LENGTH; > > - struct pack_buf_t newKeyText; > > - > > - // Fill in newKey > > - TPM_KEY newKey; > > - > > - BYTE RSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > > - newKey.algorithmParms.algorithmID = TPM_ALG_RSA; > > - newKey.algorithmParms.parms = (BYTE *) &RSAkeyInfo; > > - newKey.algorithmParms.parmSize = 12; > > - > > - switch (usage) { > > - case TPM_KEY_SIGNING: > > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Signing Key...\n"); > > - newKey.keyUsage = TPM_KEY_SIGNING; > > - newKey.algorithmParms.encScheme = TPM_ES_NONE; > > - newKey.algorithmParms.sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1; > > - break; > > - case TPM_KEY_STORAGE: > > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Storage Key...\n"); > > - newKey.keyUsage = TPM_KEY_STORAGE; > > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > > - break; > > - case TPM_KEY_BIND: > > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Binding Key...\n"); > > - newKey.keyUsage = TPM_KEY_BIND; > > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > > - break; > > - default: > > - vtpmloginfo(VTPM_LOG_VTSP, "Cannot create key. Invalid Key Type.\n"); > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - > > - newKey.ver = TPM_STRUCT_VER_1_1; > > - > > - newKey.keyFlags = 0; > > - newKey.authDataUsage = TPM_AUTH_ALWAYS; > > - newKey.pubKey.keyLength= 0; > > - newKey.encDataSize = 0; > > - newKey.encData = NULL; > > - > > - // FIXME: Support PCR bindings > > - newKey.PCRInfoSize = 0; > > - newKey.PCRInfo = NULL; > > - > > - // Calculate encUsageAuth > > - XORbufferSize = BSG_PackList( XORbuffer, 2, > > - BSG_TPM_SECRET, osapSharedSecret, > > - BSG_TPM_NONCE, &auth->NonceEven); > > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey1); > > - > > - // FIXME: No support for migratable keys. > > - for (i=0; i < TPM_DIGEST_SIZE; i++) > > - ((BYTE *) &encUsageAuth)[i] = ((BYTE *) &XORKey1)[i] ^ ((BYTE *) newKeyAuth)[i]; > > - > > - // Flatten newKey prototype > > - flatKeySize = BSG_Pack(BSG_TPM_KEY, (BYTE *) &newKey, flatKey); > > - newKeyText.data = flatKey; > > - newKeyText.size = flatKeySize; > > - > > - // Generate HMAC > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 3, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_AUTHDATA, &encUsageAuth, > > - BSG_TPM_AUTHDATA, &encMigrationAuth); > > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > > - paramTextSize += newKeyText.size; > > - > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - osapSharedSecret, auth) ); > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_CreateWrapKey( hContext, > > - parentHandle, > > - encUsageAuth, > > - encMigrationAuth, > > - &newKeyText.size, > > - &newKeyText.data, > > - auth) ); > > - > > - // Verify Auth > > - paramTextSize = BSG_PackList(paramText, 2, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command); > > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > > - paramTextSize += newKeyText.size; > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - osapSharedSecret, auth, 0) ); > > - > > - // Unpack/return key structure > > - TPMTRYRETURN(buffer_init(pubKeyBuf, 0, 0) ); > > - TPMTRYRETURN(buffer_append_raw(pubKeyBuf, newKeyText.size, newKeyText.data) ); > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - free(flatKey); > > - free(paramText); > > - TCS_FreeMemory(hContext, newKeyText.data); > > - > > - return status; > > -} > > - > > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > > - const TCS_KEY_HANDLE hUnwrappingKey, > > - const buffer_t *rgbWrappedKeyBlob, > > - const TPM_AUTHDATA *parentAuth, > > - TPM_HANDLE *newKeyHandle, > > - TCS_AUTH *auth, > > - CRYPTO_INFO *cryptoinfo, > > - const BOOL skipTPMLoad) { > > - > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Loading Key %s.\n", (!skipTPMLoad ? "into TPM" : "only into memory")); > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_LoadKey; > > - > > - BYTE *paramText=NULL; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - // SkipTPMLoad stops key from being loaded into TPM, but still generates CRYPTO_INFO for it > > - if (! skipTPMLoad) { > > - > > - if ((rgbWrappedKeyBlob == NULL) || (parentAuth == NULL) || > > - (newKeyHandle==NULL) || (auth==NULL)) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // Generate Extra TCS Parameters > > - TPM_HANDLE phKeyHMAC; > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 1, > > - BSG_TPM_COMMAND_CODE, &command); > > - > > - memcpy(paramText + paramTextSize, rgbWrappedKeyBlob->bytes, buffer_len(rgbWrappedKeyBlob)); > > - paramTextSize += buffer_len(rgbWrappedKeyBlob); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - parentAuth, auth) ); > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_LoadKeyByBlob( hContext, > > - hUnwrappingKey, > > - buffer_len(rgbWrappedKeyBlob), > > - rgbWrappedKeyBlob->bytes, > > - auth, > > - newKeyHandle, > > - &phKeyHMAC) ); > > - > > - // Verify Auth > > - paramTextSize = BSG_PackList(paramText, 3, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_HANDLE, newKeyHandle); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - parentAuth, auth, > > - hContext) ); > > - } > > - > > - // Build cryptoinfo structure for software crypto function. > > - if (cryptoinfo != NULL) { > > - TPM_KEY newKey; > > - > > - // Unpack/return key structure > > - BSG_Unpack(BSG_TPM_KEY, rgbWrappedKeyBlob->bytes , &newKey); > > - TPM_RSA_KEY_PARMS rsaKeyParms; > > - > > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > > - newKey.algorithmParms.parms, > > - &rsaKeyParms); > > - > > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > > - rsaKeyParms.exponent, > > - newKey.pubKey.keyLength, > > - newKey.pubKey.key, > > - cryptoinfo); > > - > > - // Destroy rsaKeyParms > > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > > - > > - // Set encryption scheme > > - cryptoinfo->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > > - } > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - free(paramText); > > - return status; > > -} > > - > > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE key_handle, > > - const buffer_t *bound_data, > > - const TPM_AUTHDATA *usage_auth, > > - buffer_t *clear_data, > > - TCS_AUTH *auth) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Unbinding %d bytes of data.\n", buffer_len(bound_data)); > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_UnBind; > > - > > - BYTE *paramText; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - // Generate Extra TCS Parameters > > - struct pack_buf_t clear_data32; > > - BYTE *clear_data_text; > > - UINT32 clear_data_size; > > - > > - struct pack_buf_t bound_data32 = {bound_data->size, bound_data->bytes}; > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 2, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_SIZE32_DATA, &bound_data32); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - usage_auth, auth) ); > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_UnBind( hContext, > > - key_handle, > > - buffer_len(bound_data), > > - bound_data->bytes, > > - auth, > > - &clear_data_size, > > - &clear_data_text) ); > > - > > - > > - // Verify Auth > > - clear_data32.size = clear_data_size; > > - clear_data32.data = clear_data_text; > > - paramTextSize = BSG_PackList(paramText, 3, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_SIZE32_DATA, &clear_data32); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - usage_auth, auth, > > - hContext) ); > > - > > - // Unpack/return key structure > > - TPMTRYRETURN(buffer_init(clear_data, 0, 0)); > > - TPMTRYRETURN(buffer_append_raw (clear_data, clear_data_size, clear_data_text) ); > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - free(paramText); > > - TCS_FreeMemory(hContext, clear_data_text); > > - > > - return status; > > -} > > - > > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > > - const buffer_t *inData, > > - buffer_t *outData) > > -{ > > - vtpmloginfo(VTPM_LOG_VTSP, "Binding %d bytes of data.\n", buffer_len(inData)); > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_BOUND_DATA boundData; > > - UINT32 i; > > - > > - // Fill boundData's accessory information > > - boundData.ver = TPM_STRUCT_VER_1_1; > > - boundData.payload = TPM_PT_BIND; > > - boundData.payloadData = inData->bytes; > > - > > - // Pack boundData before encryption > > - BYTE* flatBoundData = (BYTE *)malloc(sizeof(BYTE) * > > - (sizeof(TPM_VERSION) + > > - sizeof(TPM_PAYLOAD_TYPE) + > > - buffer_len(inData))); > > - if (flatBoundData == NULL) { > > - return TPM_NOSPACE; > > - } > > - UINT32 flatBoundDataSize = 0; > > - flatBoundDataSize = BSG_PackList( flatBoundData, 2, > > - BSG_TPM_VERSION, &boundData.ver, > > - BSG_TYPE_BYTE, &boundData.payload); > > - > > - memcpy(flatBoundData+flatBoundDataSize, inData->bytes, buffer_len(inData)); > > - flatBoundDataSize += buffer_len(inData); > > - > > - BYTE out_tmp[RSA_KEY_SIZE/8]; // RSAEnc does not do blocking, So this is what will come out. > > - UINT32 out_tmp_size; > > - > > - // Encrypt flatBoundData > > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_RSAEnc( cryptoInfo, > > - flatBoundDataSize, > > - flatBoundData, > > - &out_tmp_size, > > - out_tmp) ); > > - > > - if (out_tmp_size > RSA_KEY_SIZE/8) { > > - // The result of RSAEnc should be a fixed size based on key size. > > - vtpmlogerror(VTPM_LOG_VTSP, "Enc buffer just overflowed.\n"); > > - } > > - > > - buffer_init(outData, 0, NULL); > > - buffer_append_raw(outData, out_tmp_size, out_tmp); > > - > > - vtpmloginfo(VTPM_LOG_TXDATA, "Bind Generated[%d] = 0x", out_tmp_size); > > - for(i = 0 ; i < out_tmp_size ; i++) { > > - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out_tmp[i]); > > - } > > - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); > > - > > - goto egress; > > - abort_egress: > > - egress: > > - > > - // Free flatBoundData > > - free(flatBoundData); > > - > > - return TPM_SUCCESS; > > -} > > - > > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE keyHandle, > > - const TPM_AUTHDATA *sealDataAuth, > > - const TPM_PCR_COMPOSITE *pcrComp, > > - const buffer_t *inData, > > - TPM_STORED_DATA *sealedData, > > - const TPM_SECRET *osapSharedSecret, > > - TCS_AUTH *auth) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_Seal; > > - > > - BYTE *paramText; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - // Generate PCR_Info Struct from Comp > > - TPM_PCR_INFO pcrInfo; > > - UINT32 pcrInfoSize, flatpcrSize; > > - BYTE flatpcr[3 + // PCR_Select = 3 1 byte banks > > - sizeof(UINT16) + // 2 byte UINT16 > > - sizeof(UINT32) + // PCR_Comp = 4 byte UINT32 > > - 24 * sizeof(TPM_PCRVALUE) ]; // up to 24 PCRs > > - > > - if (pcrComp != NULL) { > > - //printf("\n\tBinding to PCRs: "); > > - //for(int i = 0 ; i < pcrComp->select.sizeOfSelect ; i++) > > - //printf("%2.2x", pcrComp->select.pcrSelect[i]); > > - > > - memcpy(&pcrInfo.pcrSelection, &pcrComp->select, sizeof(TPM_PCR_SELECTION)); > > - > > - flatpcrSize = BSG_Pack(BSG_TPM_PCR_COMPOSITE, (BYTE *) pcrComp, flatpcr); > > - Crypto_SHA1Full((BYTE *) flatpcr, flatpcrSize, (BYTE *) &(pcrInfo.digestAtRelease)); > > - memset(&(pcrInfo.digestAtCreation), 0, sizeof(TPM_DIGEST)); > > - pcrInfoSize = BSG_Pack(BSG_TPM_PCR_INFO, (BYTE *) &pcrInfo, flatpcr); > > - } else { > > - //printf("\n\tBinding to no PCRS."); > > - pcrInfoSize = 0; > > - } > > - > > - // Calculate encUsageAuth > > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > > - UINT32 XORbufferSize = sizeof(XORbuffer); > > - TPM_DIGEST XORKey; > > - TPM_ENCAUTH encAuth; > > - > > - BSG_PackList( XORbuffer, 2, > > - BSG_TPM_SECRET, osapSharedSecret, > > - BSG_TPM_NONCE, &auth->NonceEven ); > > - > > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey); > > - > > - int i; > > - for (i=0; i < TPM_DIGEST_SIZE; i++) > > - ((BYTE *) &encAuth)[i] = ((BYTE *) &XORKey)[i] ^ ((BYTE *) sealDataAuth)[i]; > > - > > - // Generate Extra TCS Parameters > > - UINT32 inDataSize = buffer_len(inData); > > - struct pack_buf_t inData_pack = {inDataSize, inData->bytes}; > > - struct pack_buf_t pcrInfo_pack = {pcrInfoSize, flatpcr}; > > - > > - UINT32 sealedDataSize; > > - BYTE *flatSealedData=NULL; > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 4, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_ENCAUTH, &encAuth, > > - BSG_TPM_SIZE32_DATA, &pcrInfo_pack, > > - BSG_TPM_SIZE32_DATA, &inData_pack); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - osapSharedSecret, auth) ); > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_Seal( hContext, > > - keyHandle, > > - encAuth, > > - pcrInfoSize, > > - flatpcr, > > - inDataSize, > > - inData->bytes, > > - auth, > > - &sealedDataSize, > > - &flatSealedData) ); > > - > > - // Unpack/return key structure > > - BSG_Unpack( BSG_TPM_STORED_DATA, flatSealedData, sealedData ); > > - > > - paramTextSize = BSG_PackList(paramText, 3, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_STORED_DATA, sealedData); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - osapSharedSecret, auth, > > - 0) ); > > - > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - if (flatSealedData) > > - TCS_FreeMemory( hContext, flatSealedData); > > - > > - free(paramText); > > - return status; > > -} > > - > > - > > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE keyHandle, > > - const TPM_STORED_DATA *sealedData, > > - const TPM_AUTHDATA *key_usage_auth, > > - const TPM_AUTHDATA *data_usage_auth, > > - buffer_t *outData, > > - TCS_AUTH *auth, > > - TCS_AUTH *dataAuth) { > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - TPM_COMMAND_CODE command = TPM_ORD_Unseal; > > - > > - BYTE *paramText; // Digest to make Auth. > > - UINT32 paramTextSize; > > - > > - // Generate Extra TCS Parameters > > - UINT32 sealDataSize, clearDataSize; > > - BYTE *flatSealedData= (BYTE *) malloc(sizeof(TPM_VERSION) + > > - 2 * sizeof(UINT32) + > > - sealedData->sealInfoSize + > > - sealedData->encDataSize), > > - *clearData=NULL; > > - > > - sealDataSize = BSG_Pack(BSG_TPM_STORED_DATA, sealedData, flatSealedData ); > > - > > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - > > - paramTextSize = BSG_PackList(paramText, 2, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_STORED_DATA, sealedData); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - key_usage_auth, auth) ); > > - > > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > > - data_usage_auth, dataAuth) ); > > - // Call TCS > > - TPMTRYRETURN( TCSP_Unseal( hContext, > > - keyHandle, > > - sealDataSize, > > - flatSealedData, > > - auth, > > - dataAuth, > > - &clearDataSize, > > - &clearData) ); > > - > > - // Verify Auth > > - struct pack_buf_t clearData_pack = {clearDataSize, clearData}; > > - > > - paramTextSize = BSG_PackList(paramText, 3, > > - BSG_TPM_RESULT, &status, > > - BSG_TPM_COMMAND_CODE, &command, > > - BSG_TPM_SIZE32_DATA, &clearData_pack); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - key_usage_auth, auth, > > - hContext) ); > > - > > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > > - data_usage_auth, dataAuth, > > - hContext) ); > > - > > - // Unpack/return key structure > > - TPMTRYRETURN( buffer_init(outData, clearDataSize, clearData) ); > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - if (flatSealedData) > > - TCS_FreeMemory( hContext, clearData); > > - > > - free(paramText); > > - return status; > > -} > > - > > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Calling TPM_SaveState.\n"); > > - > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - // Call TCS > > - return ( TCSP_SaveState ( hContext ) ); > > - > > -} > > - > > - > > -// Function Reaches into unsupported TCS command, beware. > > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > > - const buffer_t *inbuf, > > - buffer_t *outbuf ) { > > - > > - vtpmloginfo(VTPM_LOG_VTSP, "Passthrough in use.\n"); > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - // Generate Extra TCS Parameters > > - BYTE *resultText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > > - UINT32 resultTextSize = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Call TCS > > - TPMTRYRETURN( TCSP_RawTransmitData(buffer_len(inbuf), inbuf->bytes, > > - &resultTextSize, resultText) ); > > - > > - // Unpack/return key structure > > - TPMTRYRETURN(buffer_init (outbuf, resultTextSize, resultText) ); > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - TCS_FreeMemory(hContext, resultText); > > - free(resultText); > > - return status; > > -} > > diff --git a/tools/vtpm_manager/manager/vtsp.h b/tools/vtpm_manager/manager/vtsp.h > > deleted file mode 100644 > > index 2fb0440..0000000 > > --- a/tools/vtpm_manager/manager/vtsp.h > > +++ /dev/null > > @@ -1,126 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtsp.h > > -// > > -// Higher level interface to TCS. > > -// > > -// ================================================================== > > - > > -#ifndef __VTSP_H__ > > -#define __VTSP_H__ > > - > > -#include "tcg.h" > > -#include "tcs.h" > > - > > -#define KEY_BUFFER_SIZE 2048 > > - > > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > > - const buffer_t *inbuf, > > - buffer_t *outbuf ); > > - > > -TPM_RESULT VTSP_OIAP( const TCS_CONTEXT_HANDLE hContext, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_OSAP( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_ENTITY_TYPE entityType, > > - const UINT32 entityValue, > > - const TPM_AUTHDATA *usageAuth, > > - TPM_SECRET *sharedsecret, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > > - const TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > > - CRYPTO_INFO *cypto_info); > > - > > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_AUTHDATA *ownerAuth, > > - const TPM_AUTHDATA *srkAuth, > > - CRYPTO_INFO *ek_cryptoInfo, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_AUTHDATA *ownerAuth, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_USAGE usage, > > - const TPM_AUTHDATA *newKeyAuth, > > - const TCS_KEY_HANDLE parentHandle, > > - const TPM_AUTHDATA *osapSharedSecret, > > - buffer_t *pubKeyBuf, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > > - const TCS_KEY_HANDLE hUnwrappingKey, > > - const buffer_t *rgbWrappedKeyBlob, > > - const TPM_AUTHDATA *parentAuth, > > - TPM_HANDLE *newKeyHandle, > > - TCS_AUTH *pAuth, > > - CRYPTO_INFO *cryptoinfo, > > - const BOOL skipTPMLoad); > > - > > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE key_handle, > > - const buffer_t *bound_data, > > - const TPM_AUTHDATA *usage_auth, > > - buffer_t *clear_data, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > > - const buffer_t *inData, > > - buffer_t *outData); > > - > > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE keyHandle, > > - const TPM_AUTHDATA *sealDataAuth, > > - const TPM_PCR_COMPOSITE *pcrComp, > > - const buffer_t *inData, > > - TPM_STORED_DATA *sealedData, > > - const TPM_SECRET *osapSharedSecret, > > - TCS_AUTH *auth); > > - > > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > > - const TPM_KEY_HANDLE keyHandle, > > - const TPM_STORED_DATA *sealedData, > > - const TPM_AUTHDATA *key_usage_auth, > > - const TPM_AUTHDATA *data_usage_auth, > > - buffer_t *outData, > > - TCS_AUTH *auth, > > - TCS_AUTH *dataAuth); > > - > > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext); > > - > > -#endif //_VTSP_H_ > > diff --git a/tools/vtpm_manager/migration/Makefile b/tools/vtpm_manager/migration/Makefile > > deleted file mode 100644 > > index e33ae95..0000000 > > --- a/tools/vtpm_manager/migration/Makefile > > +++ /dev/null > > @@ -1,42 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../../.. > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -VPATH = ../manager > > - > > -BIND = vtpm_migratord > > -BINC = vtpm_migrator > > - > > -SRCSD = vtpm_manager_if.c vtpm_migratord.c vtpm_migratord_handler.c vtpm_ipc.c > > -SRCSC = vtpm_manager_if.c vtpm_migrator_if.c vtpm_migratorc.c vtpm_ipc.c > > - > > -OBJSD = $(patsubst %.c,%.o,$(SRCSD)) > > -OBJSC = $(patsubst %.c,%.o,$(SRCSC)) > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: $(BIND) $(BINC) > > - > > -.PHONY: install > > -install: build > > - $(INSTALL_PROG) $(BIND) $(DESTDIR)$(BINDIR) > > - $(INSTALL_PROG) $(BINC) $(DESTDIR)$(BINDIR) > > - > > -.PHONY: clean > > -clean: > > - rm -f $(BINC) $(BIND) > > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > > - > > -.PHONY: mrproper > > -mrproper: clean > > - rm -f *~ > > - > > -$(BIND): $(OBJSD) > > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > > - > > -$(BINC): $(OBJSC) > > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > > - > > -# libraries > > -LIBS += ../util/libTCGUtils.a > > diff --git a/tools/vtpm_manager/migration/vtpm_manager_if.c b/tools/vtpm_manager/migration/vtpm_manager_if.c > > deleted file mode 100644 > > index 08986f4..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_manager_if.c > > +++ /dev/null > > @@ -1,186 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_manager_if.c > > -// > > -// Provides functions to call local vtpm manager interface (Hotplug) > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "buffer.h" > > -#include "log.h" > > -#include "vtpm_ipc.h" > > -#include "bsg.h" > > -#include "vtpm_migrator.h" > > -#include "vtpm_manager.h" > > - > > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > > - > > -static vtpm_ipc_handle_t tx_ipc_h, rx_ipc_h; > > - > > -TPM_RESULT vtpm_manager_open(){ > > - > > - if ( (vtpm_ipc_init(&tx_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || //FIXME: wronly > > - (vtpm_ipc_init(&rx_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { //FIXME: rdonly > > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to connect to vtpm_manager.\n"); > > - return TPM_IOERROR; > > - } > > - > > - return TPM_SUCCESS; > > -} > > - > > -void vtpm_manager_close() { > > - > > - vtpm_ipc_close(&tx_ipc_h); > > - vtpm_ipc_close(&rx_ipc_h); > > -} > > - > > - > > -TPM_RESULT vtpm_manager_command(TPM_COMMAND_CODE ord, > > - buffer_t *command_param_buf, > > - TPM_RESULT *cmd_status, /* out */ > > - buffer_t *result_param_buf) { > > - > > - TPM_RESULT status = TPM_FAIL; > > - int size_read, size_write, i; > > - BYTE *adj_command, response_header[VTPM_COMMAND_HEADER_SIZE_SRV]; > > - UINT32 dmi_id=0, adj_command_size, out_param_size, adj_param_size; > > - TPM_TAG tag=VTPM_TAG_REQ; > > - > > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - adj_command_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(command_param_buf); > > - adj_command = (BYTE *) malloc( adj_command_size ); > > - if (!adj_command) { > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } > > - > > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > > - BSG_PackList(adj_command, 4, > > - BSG_TYPE_UINT32, &dmi_id, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &out_param_size, > > - BSG_TPM_COMMAND_CODE, &ord ); > > - > > - memcpy(adj_command + VTPM_COMMAND_HEADER_SIZE_SRV, command_param_buf->bytes, buffer_len(command_param_buf)); > > - > > - size_write = vtpm_ipc_write(&tx_ipc_h, NULL, adj_command, adj_command_size); > > - > > - if (size_write > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MGR): 0x"); > > - for (i=0; i< adj_command_size; i++) { > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", adj_command[i]); > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing VTPM Manager console.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if (size_write != (int) adj_command_size ) > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to mgr (%d/%d)\n", size_write, adj_command_size); > > - > > - // Read header for response to manager command > > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, response_header, VTPM_COMMAND_HEADER_SIZE_SRV); > > - if (size_read > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MGR): 0x"); > > - for (i=0; i > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Command from vtpm_manager shorter than std header.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - // Unpack response from DMI for TPM command > > - BSG_UnpackList(response_header, 4, > > - BSG_TYPE_UINT32, &dmi_id, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &out_param_size, > > - BSG_TPM_COMMAND_CODE, cmd_status ); > > - > > - // If response has parameters, read them. > > - // Note that out_param_size is in the client's context > > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > > - if (adj_param_size > 0) { > > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, result_param_buf->bytes, adj_param_size); > > - if (size_read > 0) { > > - for (i=0; i< size_read; i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > > - goto abort_egress; > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - > > - if (size_read < (int)adj_param_size) { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - } else { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - } > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > - > > - > > diff --git a/tools/vtpm_manager/migration/vtpm_migrator.h b/tools/vtpm_manager/migration/vtpm_migrator.h > > deleted file mode 100644 > > index 8d52e66..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_migrator.h > > +++ /dev/null > > @@ -1,104 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_migrator.h > > -// > > -// Public Interface header for VTPM Migrator > > -// > > -// ================================================================== > > - > > -#ifndef __VTPM_MIGRATOR_H__ > > -#define __VTPM_MIGRATOR_H__ > > - > > -#define VTPM_MTAG_REQ 0x02c1 > > -#define VTPM_MTAG_RSP 0x02c4 > > - > > -// Header sizes. > > -#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) > > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > > - > > -//*********************** Connection Info ************************** > > -#define VTPM_MIG_PORT 48879 > > - > > -//************************ Command Codes *************************** > > -#define VTPM_MORD_MIG_STEP1 0x00 > > -#define VTPM_MORD_MIG_STEP2 0x01 > > -#define VTPM_MORD_MIG_STEP3 0x02 > > -#define VTPM_MORD_MIG_STEP4 0x03 > > - > > -//************************ Return Codes **************************** > > -#define VTPM_SUCCESS 0 > > -#define VTPM_FAIL 1 > > - > > -/******************* Command Parameter API ************************* > > - > > -VTPM Command Format > > - tpm tag: 2 bytes > > - command size: 4 bytes // Size of command including header but not DMI > > - ord: 4 bytes // Command ordinal above > > - parameters: size - 10 bytes // Command Parameter > > - > > -VTPM Response Format > > - tpm tag: 2 bytes > > - response_size: 4 bytes > > - status: 4 bytes > > - parameters: size - 10 bytes > > - > > - > > -VTPM_Mig_Phase1: > > - Unsupported: (Handled by scripts) > > - > > -VTPM_Mig_Phase2 > > - Input Parameters: > > - domain_name_size: 4 bytes > > - domain_name : domain_name_size bytes > > - Output Parameters: > > - pub_exp_size: 4 bytes > > - pub_exp: pub_exp_size bytes > > - pub_mod_size: 4 bytes > > - pub_mod: pub_mod_size bytes > > - > > -VTPM_Mig_Phase3 > > - Input Parameters: > > - vtpm_state_size: 4 bytes > > - vtpm_state: vtpm_state_size bytes > > - Output Parameters: > > - none > > - > > -VTPM_Mig_Phase4 > > - Unsupported: (Handled by scripts) > > - > > - > > -*********************************************************************/ > > - > > -#endif //_VTPM_MANAGER_H_ > > diff --git a/tools/vtpm_manager/migration/vtpm_migrator_if.c b/tools/vtpm_manager/migration/vtpm_migrator_if.c > > deleted file mode 100644 > > index de48b2d..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_migrator_if.c > > +++ /dev/null > > @@ -1,219 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// vtpm_migrator_if.c > > -// > > -// Provides functions to call open network connection & call > > -// a function on the vtpm_migratord on the destination > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "buffer.h" > > -#include "log.h" > > -#include "bsg.h" > > -#include "vtpm_migrator.h" > > - > > -static int sock_desc; > > - > > - > > -TPM_RESULT vtpm_migratord_open(char *server_address){ > > - > > - TPM_RESULT status = TPM_FAIL; > > - > > - /* network variables */ > > - struct in_addr ip_addr; > > - struct sockaddr_in server_addr; > > - int addr_len; > > - struct hostent *dns_info=NULL; > > - > > - /* set up connection to server*/ > > - dns_info = gethostbyname(server_address); > > - ip_addr.s_addr = *((unsigned long *) dns_info->h_addr_list[0]); > > - > > - if(ip_addr.s_addr < 0) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - /* set up server variable */ > > - memset((char *)&server_addr, 0, sizeof(server_addr)); > > - server_addr.sin_family = AF_INET; > > - server_addr.sin_port = htons(VTPM_MIG_PORT); > > - server_addr.sin_addr.s_addr = ip_addr.s_addr; > > - > > - /* open socket, make connection */ > > - sock_desc = socket(AF_INET, SOCK_STREAM, 0); > > - > > - if (sock_desc < 0 ) { > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if (connect(sock_desc, > > - (struct sockaddr *)&server_addr, > > - sizeof(server_addr)) < 0 ) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - status = TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > - > > -void vtpm_migratord_close() { > > - close(sock_desc); > > -} > > - > > - > > -TPM_RESULT vtpm_migratord_command(TPM_COMMAND_CODE ord, > > - buffer_t *command_param_buf, > > - TPM_RESULT *cmd_status, /* out */ > > - buffer_t *result_param_buf) { > > - > > - TPM_RESULT status = TPM_FAIL; > > - int size_read, size_write, i; > > - BYTE *command, response_header[VTPM_COMMAND_HEADER_SIZE]; > > - UINT32 dmi_id=0, command_size, out_param_size, adj_param_size; > > - TPM_TAG tag=VTPM_MTAG_REQ; > > - > > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - command_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > > - command = (BYTE *) malloc( command_size ); > > - if (!command) { > > - status = TPM_RESOURCES; > > - goto abort_egress; > > - } > > - > > - BSG_PackList(command, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &command_size, > > - BSG_TPM_COMMAND_CODE, &ord ); > > - > > - memcpy(command + VTPM_COMMAND_HEADER_SIZE, command_param_buf->bytes, buffer_len(command_param_buf)); > > - > > - size_write = write(sock_desc, command, command_size); > > - > > - if (size_write > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MIGd): 0x"); > > - for (i=0; i< command_size; i++) { > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", command[i]); > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing to migration server via network.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if (size_write != (int) command_size ) > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to migration server (%d/%d)\n", size_write, command_size); > > - > > - // Read header for response > > - size_read = read(sock_desc, response_header, VTPM_COMMAND_HEADER_SIZE); > > - if (size_read > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MIGd): 0x"); > > - for (i=0; i > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from Migration Server.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Command from migration server shorter than std header.\n"); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - > > - // Unpack response from DMI for TPM command > > - BSG_UnpackList(response_header, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &out_param_size, > > - BSG_TPM_COMMAND_CODE, cmd_status ); > > - > > - // If response has parameters, read them. > > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > > - if (adj_param_size > 0) { > > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > > - size_read = read(sock_desc, result_param_buf->bytes, adj_param_size); > > - if (size_read > 0) { > > - for (i=0; i< size_read; i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from migration server.\n"); > > - goto abort_egress; > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - > > - if (size_read < (int)adj_param_size) { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > > - status = TPM_IOERROR; > > - goto abort_egress; > > - } > > - } else { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - } > > - > > - status=TPM_SUCCESS; > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > - > > - > > diff --git a/tools/vtpm_manager/migration/vtpm_migratorc.c b/tools/vtpm_manager/migration/vtpm_migratorc.c > > deleted file mode 100644 > > index 18b3bdb..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_migratorc.c > > +++ /dev/null > > @@ -1,211 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "log.h" > > -#include "bsg.h" > > -#include "buffer.h" > > -#include "vtpm_migrator.h" > > -#include "vtpm_manager.h" > > - > > -TPM_RESULT handle_vtpm_mig_step2(char *server_addr, > > - char *name, > > - UINT32 instance) { > > - TPM_RESULT status, cmd_status; > > - buffer_t out_param_buf=NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > > - UINT32 offset; > > - struct pack_buf_t addr_data32; > > - > > - //===== Get Destination's Public Migration Key ====== > > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > > - > > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP2, > > - &out_param_buf, > > - &cmd_status, > > - &mig_key_buf) ); > > - vtpm_migratord_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - //===== Load migration key into vtpm_manager ======== > > - > > - addr_data32.data = (BYTE *)server_addr; > > - addr_data32.size = strlen(server_addr) + 1; // Include the null > > - > > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > > - sizeof(UINT32) + addr_data32.size +buffer_len(&mig_key_buf), > > - NULL ) ) ; > > - > > - offset = BSG_PackList(out_param_buf.bytes, 1, > > - BSG_TPM_SIZE32_DATA, &addr_data32); > > - > > - memcpy(out_param_buf.bytes + offset , mig_key_buf.bytes, buffer_len(&mig_key_buf) ); > > - > > - TPMTRYRETURN ( vtpm_manager_open() ); > > - > > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_LOAD_MIG_KEY, > > - &out_param_buf, > > - &cmd_status, > > - &empty_buf) ); > > - > > - vtpm_manager_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - buffer_free(&mig_key_buf); > > - buffer_free(&out_param_buf); > > - > > - return status; > > -} > > - > > - > > -TPM_RESULT handle_vtpm_mig_step3(char *server_addr, > > - char *name, > > - UINT32 instance) { > > - TPM_RESULT status, cmd_status; > > - buffer_t out_param_buf=NULL_BUF, state_buf=NULL_BUF, empty_buf=NULL_BUF; > > - struct pack_buf_t addr_data32, name_data32, state_data32; > > - > > - //===== Get vtpm state from vtpm_manager ======== > > - addr_data32.data = (BYTE *)server_addr; > > - addr_data32.size = strlen(server_addr) + 1; // Include the null > > - > > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > > - (2 * sizeof(UINT32)) + addr_data32.size, > > - NULL ) ) ; > > - > > - BSG_PackList(out_param_buf.bytes, 2, > > - BSG_TYPE_UINT32, &instance, > > - BSG_TPM_SIZE32_DATA, &addr_data32); > > - > > - TPMTRYRETURN ( vtpm_manager_open() ); > > - > > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_MIGRATE_OUT, > > - &out_param_buf, > > - &cmd_status, > > - &state_buf) ); > > - > > - vtpm_manager_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - TPMTRYRETURN( buffer_free( &out_param_buf ) ); > > - > > - //===== Send vtpm state to destination ====== > > - name_data32.data = (BYTE *)name; > > - name_data32.size = strlen(name) + 1; // Include the null > > - state_data32.data = state_buf.bytes; > > - state_data32.size = buffer_len(&state_buf); > > - > > - TPMTRYRETURN( buffer_init( &out_param_buf, > > - 2 * sizeof(UINT32) + name_data32.size + state_data32.size, > > - NULL ) ) ; > > - > > - BSG_PackList(out_param_buf.bytes, 2, > > - BSG_TPM_SIZE32_DATA, &name_data32, > > - BSG_TPM_SIZE32_DATA, &state_data32); > > - > > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > > - > > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP3, > > - &out_param_buf, > > - &cmd_status, > > - &empty_buf) ); > > - vtpm_migratord_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - goto egress; > > - > > - abort_egress: > > - egress: > > - > > - buffer_free( &out_param_buf); > > - buffer_free( &state_buf); > > - buffer_free( &empty_buf); > > - > > - return status; > > -} > > - > > - > > -// Usage vtpm_migrator addr domain_name instance step > > - > > -int main(int argc, char **argv) { > > - > > - /* variables for processing of command */ > > - TPM_RESULT status = TPM_FAIL; > > - char *server_addr, *name; > > - UINT32 instance, step; > > - > > - if (argc != 5) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Usage: vtpm_migrator addr vm_name instance step\n"); > > - vtpmlogerror(VTPM_LOG_VTPM, " params given %d\n", argc); > > - status= TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - server_addr = argv[1]; > > - name = argv[2]; > > - instance = atoi( argv[3] ); > > - step = atoi( argv[4] ); > > - > > - switch (step) { > > - case VTPM_MORD_MIG_STEP2: > > - status = handle_vtpm_mig_step2(server_addr, name, instance); > > - break; > > - > > - case VTPM_MORD_MIG_STEP3: > > - status = handle_vtpm_mig_step3(server_addr, name, instance); > > - break; > > - > > - default: > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - break; > > - } > > - > > - goto egress; > > - abort_egress: > > - egress: > > - > > - return status; > > -} > > - > > diff --git a/tools/vtpm_manager/migration/vtpm_migratord.c b/tools/vtpm_manager/migration/vtpm_migratord.c > > deleted file mode 100644 > > index ea18c8c..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_migratord.c > > +++ /dev/null > > @@ -1,202 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "log.h" > > -#include "bsg.h" > > -#include "buffer.h" > > -#include "vtpm_migrator.h" > > - > > -void build_error_msg( buffer_t *buf, TPM_RESULT status) { > > - TPM_TAG tag = VTPM_MTAG_RSP; > > - UINT32 out_param_size = VTPM_COMMAND_HEADER_SIZE; > > - > > - buffer_init(buf, out_param_size, NULL); > > - > > - BSG_PackList(buf->bytes, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &out_param_size, > > - BSG_TPM_RESULT, &status ); > > -} > > - > > -int main() { > > - > > - /* network variables */ > > - int sock_descr, client_sock=-1, len; > > - struct sockaddr_in addr; > > - struct sockaddr_in client_addr; > > - unsigned int client_length; > > - int bytes; > > - > > - /* variables for processing of command */ > > - TPM_RESULT status = TPM_FAIL; > > - BYTE cmd_header[VTPM_COMMAND_HEADER_SIZE]; > > - TPM_TAG tag; > > - TPM_COMMAND_CODE ord; > > - UINT32 in_param_size, adj_param_size; > > - int i, size_read, size_write; > > - buffer_t in_param_buf=NULL_BUF, result_buf=NULL_BUF; > > - > > - > > - /* setup socket */ > > - sock_descr = socket(AF_INET, SOCK_STREAM, 0); > > - > > - memset(&addr, 0, sizeof(addr)); > > - addr.sin_family = AF_INET; > > - addr.sin_addr.s_addr = htonl(INADDR_ANY); > > - addr.sin_port = htons(VTPM_MIG_PORT); > > - > > - if (bind(sock_descr, (struct sockaddr *)&addr, sizeof(addr)) == -1 ) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to bind to port %d.\n", VTPM_MIG_PORT); > > - return 1; > > - } > > - > > - listen(sock_descr, 10); > > - > > - for(;;) { > > - // ============ clear client info and wait for connection ========== > > - memset(&client_addr, 0, sizeof(client_addr)); > > - client_length = sizeof(client_addr); > > - > > - vtpmloginfo(VTPM_LOG_VTPM, "Waiting for incoming migrations...\n"); > > - client_sock=accept(sock_descr, &client_addr, &client_length); > > - if (client_sock == -1) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming connectionn failed.\n"); > > - goto abort_command; > > - } else { > > - vtpmloginfo(VTPM_LOG_VTPM, "Incoming connection accepted.\n"); > > - } > > - > > - // =================== Read incoming command ====================== > > - size_read = read( client_sock, cmd_header, VTPM_COMMAND_HEADER_SIZE); > > - if (size_read > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV: 0x"); > > - for (i=0; i > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > > - build_error_msg(&result_buf, TPM_IOERROR); > > - goto abort_command_with_error; > > - } > > - > > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > > - vtpmlogerror(VTPM_LOG_VTPM, "Command from socket shorter than std header.\n"); > > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > > - goto abort_command_with_error; > > - } > > - > > - // Unpack response from client > > - BSG_UnpackList(cmd_header, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &in_param_size, > > - BSG_TPM_COMMAND_CODE, &ord ); > > - > > - > > - // If response has parameters, read them. > > - // Note that out_param_size is in the client's context > > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE; > > - if (adj_param_size > 0) { > > - buffer_init( &in_param_buf, adj_param_size, NULL); > > - size_read = read(client_sock, in_param_buf.bytes, adj_param_size); > > - if (size_read > 0) { > > - for (i=0; i< size_read; i++) > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param_buf.bytes[i]); > > - > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > > - build_error_msg(&result_buf, TPM_IOERROR); > > - goto abort_command_with_error; > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - > > - if (size_read < (int)adj_param_size) { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > > - goto abort_command_with_error; > > - } > > - } else { > > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > > - } > > - > > - /* Handle Command */ > > - switch (ord) { > > - case VTPM_MORD_MIG_STEP2: > > - handle_vtpm_mig_step2(&in_param_buf, &result_buf); > > - break; > > - > > - case VTPM_MORD_MIG_STEP3: > > - handle_vtpm_mig_step3(&in_param_buf, &result_buf); > > - break; > > - > > - default: > > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > > - goto abort_command_with_error; > > - } > > - > > - abort_command_with_error: > > - /* Write Response */ > > - size_write = write(client_sock, result_buf.bytes, buffer_len(&result_buf)); > > - > > - if (size_write > 0) { > > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > > - for (i=0; i< buffer_len(&result_buf); i++) { > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_buf.bytes[i]); > > - } > > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > > - } else { > > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing response to client.\n"); > > - goto abort_command; > > - } > > - > > - if (size_write != (int) buffer_len(&result_buf) ) > > - vtpmlogerror(VTPM_LOG_VTPM, "Could not send entire response to client(%d/%d)\n", size_write, buffer_len(&result_buf)); > > - > > - abort_command: > > - close(client_sock); > > - buffer_free(&in_param_buf); > > - buffer_free(&result_buf); > > - > > - } // For (;;) > > - > > - return 0; > > -} > > - > > diff --git a/tools/vtpm_manager/migration/vtpm_migratord_handler.c b/tools/vtpm_manager/migration/vtpm_migratord_handler.c > > deleted file mode 100644 > > index 0a8a2d5..0000000 > > --- a/tools/vtpm_manager/migration/vtpm_migratord_handler.c > > +++ /dev/null > > @@ -1,177 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "bsg.h" > > -#include "log.h" > > -#include "vtpm_migrator.h" > > -#include "vtpm_manager.h" > > - > > -#define VTPM_SH_CMD_HDR "bash -c \"cd /etc/xen/scripts; source /etc/xen/scripts/vtpm-common.sh;" > > -#define VTPM_SH_CMD_FTR "\"" > > -#define VTPM_SH_GETINST "vtpmdb_get_free_instancenum" > > -#define VTPM_SH_ADD "vtpm_add_and_activate" > > -#define VTPM_SH_RESUME "vtpm_resume" > > - > > -// This must be updated to the longest command name. Currently GETINST > > -#define VTPM_SH_CMD_SIZE (strlen(VTPM_SH_CMD_HDR) + strlen(VTPM_SH_CMD_FTR) + 1 + strlen(VTPM_SH_GETINST) + 2) > > - > > -void handle_vtpm_mig_step2(buffer_t *in_param_buf, buffer_t *result_buf) > > -{ > > - TPM_TAG tag = VTPM_TAG_RSP; > > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF; > > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > > - UINT32 out_param_size; > > - > > - if ( (!in_param_buf) || (!result_buf) ) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // ================= Call manager and get mig key =============== > > - TPMTRYRETURN( vtpm_manager_open() ); > > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_GET_MIG_KEY, > > - &out_param_buf, // Empty > > - &cmd_status, > > - &mig_key_buf) ); > > - > > - vtpm_manager_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - // ==================== return the mig key ===================== > > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(&mig_key_buf); > > - > > - TPMTRYRETURN( buffer_init(result_buf, > > - out_param_size, > > - NULL) ); > > - > > - BSG_PackList( result_buf->bytes, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, &out_param_size, > > - BSG_TPM_RESULT, &status); > > - > > - memcpy(result_buf->bytes + VTPM_COMMAND_HEADER_SIZE, > > - mig_key_buf.bytes, buffer_len(&mig_key_buf)); > > - > > - goto egress; > > - > > - abort_egress: > > - buffer_free(result_buf); > > - build_error_msg(result_buf, status); > > - > > - egress: > > - return; > > -} > > - > > -void handle_vtpm_mig_step3(buffer_t *in_param_buf, buffer_t *result_buf) > > -{ > > - TPM_TAG tag = VTPM_TAG_RSP; > > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > > - UINT32 out_param_size, instance; > > - char *shell_cmd_str=NULL; > > - size_t shell_cmd_strlen; > > - FILE *shell_f=NULL; > > - > > - if ( (!in_param_buf) || (!result_buf) ) { > > - status = TPM_BAD_PARAMETER; > > - goto abort_egress; > > - } > > - > > - // ================= Read Parameters =============== > > - struct pack_buf_t name_data32, state_data32; > > - > > - BSG_UnpackList(in_param_buf->bytes, 2, > > - BSG_TPM_SIZE32_DATA, &name_data32, > > - BSG_TPM_SIZE32_DATA, &state_data32); > > - > > - // Before using this string, protect us from a non-null term array. > > - if (name_data32.data[name_data32.size -1] != 0x00) { > > - name_data32.data[name_data32.size -1] = 0x00; > > - } > > - > > - // ====== Call hotplug-script and get an instance ====== > > - shell_cmd_strlen = VTPM_SH_CMD_SIZE + name_data32.size + 10; > > - shell_cmd_str = (char *) malloc(shell_cmd_strlen); // 10 is just padding for the UINT32 > > - > > - snprintf(shell_cmd_str, shell_cmd_strlen, > > - VTPM_SH_CMD_HDR VTPM_SH_GETINST VTPM_SH_CMD_FTR); > > - > > - shell_f = popen(shell_cmd_str, "r"); > > - fscanf(shell_f, "%d", &instance); > > - pclose(shell_f); > > - > > - // ====== Call hotplug-script and add instance ====== > > - snprintf(shell_cmd_str, shell_cmd_strlen, > > - VTPM_SH_CMD_HDR VTPM_SH_ADD " %s %d" VTPM_SH_CMD_FTR, > > - name_data32.data, instance); > > - system(shell_cmd_str); > > - > > - // ========= Call vtpm_manager and load VTPM ======= > > - TPMTRYRETURN( buffer_init( &out_param_buf, > > - 2*sizeof(UINT32) + state_data32.size, > > - NULL) ); > > - > > - BSG_PackList(out_param_buf.bytes, 2, > > - BSG_TYPE_UINT32, &instance, > > - BSG_TPM_SIZE32_DATA, &state_data32); > > - > > - TPMTRYRETURN( vtpm_manager_open() ); > > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_MIGRATE_IN, > > - &out_param_buf, > > - &cmd_status, > > - &empty_buf) ); > > - > > - vtpm_manager_close(); > > - > > - TPMTRYRETURN(cmd_status); > > - > > - // ====== Call hotplug-script and resume instance ====== > > - snprintf(shell_cmd_str, shell_cmd_strlen, > > - VTPM_SH_CMD_HDR VTPM_SH_RESUME " %d" VTPM_SH_CMD_FTR, instance); > > - system(shell_cmd_str); > > - > > - goto egress; > > - abort_egress: > > - egress: > > - free(shell_cmd_str); > > - > > - // In this case no params come back, so reuse build_error_msg even for succes. > > - build_error_msg(result_buf, status); > > - return; > > -} > > - > > diff --git a/tools/vtpm_manager/tcs/Makefile b/tools/vtpm_manager/tcs/Makefile > > deleted file mode 100644 > > index 11af91e..0000000 > > --- a/tools/vtpm_manager/tcs/Makefile > > +++ /dev/null > > @@ -1,24 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../../.. > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -BIN = libTCS.a > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: $(BIN) > > - > > -.PHONY: install > > -install: build > > - > > -.PHONY: clean > > -clean: > > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > > - > > -.PHONY: mrproper > > -mrproper: clean > > - rm -f *~ > > - > > -$(BIN): $(OBJS) > > - $(AR) rcs $(BIN) $(OBJS) > > diff --git a/tools/vtpm_manager/tcs/contextmgr.c b/tools/vtpm_manager/tcs/contextmgr.c > > deleted file mode 100644 > > index cf3803c..0000000 > > --- a/tools/vtpm_manager/tcs/contextmgr.c > > +++ /dev/null > > @@ -1,224 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// contextmgr.c > > -// > > -// This file contains the context management functions for TCS. > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include "tcs.h" > > -#include "contextmgr.h" > > -#include "log.h" > > -#include "hashtable.h" > > - > > -BYTE* AddMemBlock(CONTEXT_HANDLE* pContextHandle, // in > > - int BlockSize) { // in > > - > > - BLOCK* pCurrentBlock = NULL; > > - BLOCK* pBlock = NULL; > > - > > - // check incoming params > > - if (pContextHandle == NULL || BlockSize == 0) > > - return NULL; > > - > > - // Create New Block > > - pBlock = (BLOCK *)malloc(sizeof(BLOCK)); > > - if (pBlock == NULL) > > - return (0); > > - > > - pBlock->aMemory = (BYTE *)malloc(sizeof(BYTE) * BlockSize); > > - if (pBlock->aMemory == NULL) > > - return (0); > > - > > - memset(pBlock->aMemory, 0, BlockSize); > > - pBlock->nBlockSize = BlockSize; > > - pBlock->pNextBlock = NULL; > > - > > - // search for the last block created where to add the > > - // newly created block > > - if(pContextHandle->pTopBlock != NULL) { > > - pCurrentBlock = pContextHandle->pTopBlock; > > - while(pCurrentBlock->pNextBlock != NULL) > > - pCurrentBlock = pCurrentBlock->pNextBlock; > > - > > - > > - pCurrentBlock->pNextBlock= pBlock; > > - } else > > - pContextHandle->pTopBlock = pBlock; > > - > > - > > - pContextHandle->nBlockCount++; > > - > > - return pBlock->aMemory; > > -} > > - > > - > > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > > - BYTE* pTCPA_BYTEs) { // in > > - BLOCK* pCurrentBlock = NULL; > > - BLOCK* pParentBlock = NULL; > > - BOOL bFound = FALSE; > > - > > - if (pContextHandle == NULL) > > - return FALSE; > > - > > - > > - // Search for the Block in the context by aMemory pointer > > - pParentBlock = NULL; > > - pCurrentBlock = pContextHandle->pTopBlock; > > - > > - while(pCurrentBlock != NULL) { > > - // If aMemory block is found, delete it > > - if(pCurrentBlock->aMemory == pTCPA_BYTEs || pTCPA_BYTEs == NULL) { > > - // if it is the top Block, remove it from the top, > > - // otherwise remove it from the ParentBlock and stitch > > - // the NextBlock to the ParentBlock > > - if(pParentBlock == NULL) > > - pContextHandle->pTopBlock = pContextHandle->pTopBlock->pNextBlock; > > - else > > - pParentBlock->pNextBlock = pCurrentBlock->pNextBlock; > > - > > - // delete memory Block associated with pointer pTCPA_BYTEs > > - free(pCurrentBlock->aMemory); > > - pCurrentBlock->aMemory = NULL; > > - > > - free(pCurrentBlock); > > - pCurrentBlock = pParentBlock; > > - > > - pContextHandle->nBlockCount--; > > - bFound = TRUE; > > - } > > - > > - if(pCurrentBlock != NULL) { > > - pParentBlock = pCurrentBlock; > > - pCurrentBlock = pCurrentBlock->pNextBlock; > > - } > > - } > > - > > - return bFound; > > -} > > - > > -BOOL AddHandleToList(TCS_CONTEXT_HANDLE hContext, // in > > - TPM_RESOURCE_TYPE type, // in > > - TPM_HANDLE handle) { // in > > - HANDLE_LIST* pNewHandle = NULL; > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Adding Handle to list\n"); > > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > > - > > - if (pContextHandle == NULL) > > - return 0; > > - > > - pNewHandle = (HANDLE_LIST *)malloc(sizeof(HANDLE_LIST)); > > - > > - if (pNewHandle == NULL) > > - return (0); > > - > > - pNewHandle->handle = handle; > > - pNewHandle->type = type; > > - pNewHandle->pNextHandle = pContextHandle->pHandleList; > > - > > - pContextHandle->pHandleList = pNewHandle; > > - > > - return 1; > > -} > > - > > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_HANDLE handle) { // in > > - > > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > > - > > - HANDLE_LIST *pCurrentHandle = pContextHandle->pHandleList, > > - *pLastHandle = pCurrentHandle; > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Deleting Handle from list\n"); > > - > > - if (pContextHandle == NULL) > > - return 0; > > - > > - while (1) { > > - > > - if (pCurrentHandle->handle == handle) { // Found element > > - if (pCurrentHandle == pLastHandle) { // First element in list > > - pContextHandle->pHandleList = pCurrentHandle->pNextHandle; > > - free(pCurrentHandle); > > - } else { // Ordinary element > > - pLastHandle->pNextHandle = pCurrentHandle->pNextHandle; > > - free(pCurrentHandle); > > - } > > - > > - return 1; > > - > > - } else { // Not found yet; > > - pLastHandle = pCurrentHandle; > > - pCurrentHandle = pCurrentHandle->pNextHandle; > > - if (pCurrentHandle == NULL) // Found end of list > > - return 0; > > - } > > - > > - } > > -} > > - > > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle) { // in > > - HANDLE_LIST* pCurrentHandle; > > - BOOL returncode = TRUE; > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Freeing all handles for context\n"); > > - > > - if (pContextHandle == NULL) > > - return 1; > > - > > - pCurrentHandle = pContextHandle->pHandleList; > > - while (pCurrentHandle != NULL) { > > - > > - switch (pCurrentHandle->type) { > > - case TPM_RT_KEY: > > - returncode = returncode && !TCSP_EvictKey(pContextHandle->handle, pCurrentHandle->handle); > > - break; > > - case TPM_RT_AUTH: > > - returncode = returncode && !TCSP_TerminateHandle(pContextHandle->handle, pCurrentHandle->handle); > > - break; > > - default: > > - returncode = FALSE; > > - } > > - > > - pCurrentHandle = pCurrentHandle->pNextHandle; > > - > > - } > > - > > - return 1; > > -} > > diff --git a/tools/vtpm_manager/tcs/contextmgr.h b/tools/vtpm_manager/tcs/contextmgr.h > > deleted file mode 100644 > > index e3fdf0f..0000000 > > --- a/tools/vtpm_manager/tcs/contextmgr.h > > +++ /dev/null > > @@ -1,82 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// contextmgr.c > > -// > > -// This file contains the context management functions for TCS. > > -// > > -// ================================================================== > > - > > -#ifndef __CONTEXTMGR_H__ > > -#define __CONTEXTMGR_H__ > > - > > -#include "tcg.h" > > - > > -#define BLOCK_SIZE 300 > > - > > -typedef struct block { > > - int nBlockSize; > > - BYTE* aMemory; > > - struct block* pNextBlock; > > -} BLOCK; > > - > > -typedef struct handle_List { > > - TPM_HANDLE handle; > > - TPM_RESOURCE_TYPE type; > > - struct handle_List* pNextHandle; > > -} HANDLE_LIST; > > - > > -typedef struct context_handle { > > - TCS_CONTEXT_HANDLE handle; > > - int nBlockCount; > > - BLOCK* pTopBlock; > > - HANDLE_LIST* pHandleList; > > -} CONTEXT_HANDLE; > > - > > -BYTE* AddMemBlock( CONTEXT_HANDLE* pContextHandle, // in > > - int BlockSize); // in > > - > > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > > - BYTE* pTCPA_BYTEs); // in > > - > > - > > -BOOL AddHandleToList( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_RESOURCE_TYPE type, // in > > - TPM_HANDLE handle); // in > > - > > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_HANDLE handle); // in > > - > > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle); // in > > - > > -#endif //_CONTEXTMGR_H_ > > diff --git a/tools/vtpm_manager/tcs/tcs.c b/tools/vtpm_manager/tcs/tcs.c > > deleted file mode 100644 > > index 7c1378c..0000000 > > --- a/tools/vtpm_manager/tcs/tcs.c > > +++ /dev/null > > @@ -1,1192 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// tcs.c > > -// > > -// This file contains the functions that implement a TCS. > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "bsg.h" > > -#include "tcs.h" > > -#include "contextmgr.h" > > -#include "tpmddl.h" > > -#include "log.h" > > -#include "hashtable.h" > > -#include "hashtable_itr.h" > > - > > -// Static Global Vars for the TCS > > -static int TCS_m_nCount = 0; > > - > > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > > - > > -static BYTE InBuf [TCPA_MAX_BUFFER_LENGTH]; > > -static BYTE OutBuf[TCPA_MAX_BUFFER_LENGTH]; > > - > > -struct hashtable *context_ht; > > - > > -// -------------------------- Hash table functions -------------------- > > - > > -static unsigned int hashfunc32(void *ky) { > > - return (* (UINT32 *) ky); > > -} > > - > > -static int equals32(void *k1, void *k2) { > > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > > -} > > - > > -CONTEXT_HANDLE *LookupContext( TCS_CONTEXT_HANDLE hContext) { > > - return( (CONTEXT_HANDLE *) hashtable_search(context_ht, &hContext) ); > > -} > > - > > -// --------------------------------------------------------------------------------- > > -// Initialization/Uninitialization SubComponent API > > -// --------------------------------------------------------------------------------- > > -TPM_RESULT TCS_create() { > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TPM_RESULT result = TPM_FAIL; > > - > > - if (TCS_m_nCount == 0) { > > - vtpmloginfo(VTPM_LOG_TCS, "Constructing new TCS:\n"); > > - hRes = TDDL_Open(); > > - > > - context_ht = create_hashtable(10, hashfunc32, equals32); > > - > > - if ((hRes == TDDL_SUCCESS) && (context_ht != NULL)) { > > - result = TPM_SUCCESS; > > - TCS_m_nCount++; > > - } else { > > - result = TPM_IOERROR; > > - hashtable_destroy(context_ht, 1); > > - } > > - } else > > - TCS_m_nCount++; > > - > > - return(result); > > -} > > - > > - > > -void TCS_destroy() > > -{ > > - TCS_m_nCount--; > > - > > - if (TCS_m_nCount == 0) { > > - vtpmloginfo(VTPM_LOG_TCS, "Destructing TCS:\n"); > > - TDDL_Close(); > > - > > - struct hashtable_itr *context_itr; > > - TCS_CONTEXT_HANDLE *hContext; > > - > > - // Close all the TCS contexts. TCS should evict keys based on this > > - if (hashtable_count(context_ht) > 0) { > > - context_itr = hashtable_iterator(context_ht); > > - do { > > - hContext = (TCS_CONTEXT_HANDLE *) hashtable_iterator_key(context_itr); > > - if (TCS_CloseContext(*hContext) != TPM_SUCCESS) > > - vtpmlogerror(VTPM_LOG_TCS, "Failed to close context %d properly.\n", *hContext); > > - > > - } while (hashtable_iterator_advance(context_itr)); > > - free(context_itr); > > - } > > - hashtable_destroy(context_ht, 1); > > - } > > - > > -} > > - > > -TPM_RESULT TCS_Malloc( TCS_CONTEXT_HANDLE hContext, // in > > - UINT32 MemSize, // in > > - BYTE** ppMemPtr) {// out > > - > > - TPM_RESULT returnCode = TPM_FAIL; > > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > > - > > - if (pContextHandle != NULL && ppMemPtr != NULL) { > > - *ppMemPtr = (BYTE *)AddMemBlock(pContextHandle, MemSize); > > - returnCode = TPM_SUCCESS; > > - } > > - > > - return returnCode; > > -} > > - > > -TPM_RESULT TCS_FreeMemory( TCS_CONTEXT_HANDLE hContext, // in > > - BYTE* pMemory) { // in > > - TPM_RESULT returnCode = TPM_FAIL; > > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > > - > > - if ( (pContextHandle != NULL && pMemory != NULL) && > > - (DeleteMemBlock(pContextHandle, pMemory) == TRUE) ) > > - returnCode = TPM_SUCCESS; > > - > > - > > - return returnCode; > > -} > > - > > -TPM_RESULT TCS_OpenContext(TCS_CONTEXT_HANDLE* hContext) { // out > > - TPM_RESULT returnCode = TPM_FAIL; > > - TCS_CONTEXT_HANDLE *newContext; > > - > > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_OpenContext:\n"); > > - > > - if (hContext) { > > - CONTEXT_HANDLE* pContextHandle = (CONTEXT_HANDLE *) malloc(sizeof(CONTEXT_HANDLE)); > > - if (pContextHandle == NULL) > > - return TPM_SIZE; > > - > > - // initialize to 0 > > - pContextHandle->nBlockCount = 0; > > - pContextHandle->pTopBlock = NULL; > > - pContextHandle->pHandleList = NULL; > > - > > - // Create New Block > > - AddMemBlock(pContextHandle, BLOCK_SIZE); > > - > > - newContext = (TCS_CONTEXT_HANDLE *) malloc(sizeof(TCS_CONTEXT_HANDLE)); > > - *newContext = (TCS_CONTEXT_HANDLE) (((uintptr_t) pContextHandle >> 2) & 0xffffffff); > > - > > - if (hashtable_search(context_ht, &newContext) !=NULL) > > - *newContext += 1; > > - > > - pContextHandle->handle = *newContext; > > - if (!hashtable_insert(context_ht, newContext, pContextHandle)) { > > - free(newContext); > > - free(pContextHandle); > > - returnCode = TPM_FAIL; > > - } else { > > - *hContext = *newContext; > > - returnCode = TPM_SUCCESS; > > - } > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCS_CloseContext(TCS_CONTEXT_HANDLE hContext) {// in > > - //FIXME: TCS SHOULD Track failed auths and make sure > > - //we don't try and re-free them here. > > - TPM_RESULT returnCode = TPM_FAIL; > > - > > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > > - > > - if(pContextHandle != NULL) { > > - // Print test info > > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_CloseContext.\n"); > > - > > - // free memory for all the blocks > > - DeleteMemBlock(pContextHandle, NULL ); > > - pContextHandle->pTopBlock = NULL; > > - > > - FreeHandleList(pContextHandle); > > - if (pContextHandle->pHandleList != NULL) > > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > > - > > - // Release the TPM's resources > > - if (hashtable_remove(context_ht, &hContext) == NULL) > > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > > - > > - free(pContextHandle); > > - returnCode = TPM_SUCCESS; > > - } > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Finished closing context\n"); > > - return(returnCode); > > -} > > - > > -// ------------------------------------------------------------------ > > -// Internal Functions > > -// ------------------------------------------------------------------ > > -int packAuth(BYTE* dst, TCS_AUTH* auth) { > > - // CHECK: according to the command specs, the outgoing auth params are: > > - // nonceEven > > - // nonceOdd > > - // continueAuthSession > > - // auth digest for return params > > - // > > - // this is a bit different than this code... > > - > > - return BSG_PackList(dst, 4, > > - BSG_TYPE_UINT32, &(auth->AuthHandle), > > - BSG_TPM_NONCE, &(auth->NonceOdd), > > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > > -} > > - > > -int unpackAuth(TCS_AUTH* auth, BYTE* src) { > > - return BSG_UnpackList(src, 3, > > - BSG_TPM_NONCE, &(auth->NonceEven), > > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > > -} > > - > > -// ------------------------------------------------------------------ > > -// Authorization Commands > > -// ------------------------------------------------------------------ > > - > > -TPM_RESULT TCSP_OIAP(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTHHANDLE* authHandle, // out > > - TPM_NONCE* nonce0) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_OIAP; > > - UINT32 paramSize = 0; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (authHandle == NULL || nonce0 == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal); > > - > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS) { > > - > > - // unpack to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList( OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - // Extract the remaining output parameters > > - BSG_UnpackList(OutBuf+i, 2, > > - BSG_TYPE_UINT32, authHandle, > > - BSG_TPM_NONCE, nonce0); > > - > > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) > > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_OSAP(TCS_CONTEXT_HANDLE hContext, // in > > - TPM_ENTITY_TYPE entityType, // in > > - UINT32 entityValue, // in > > - TPM_NONCE nonceOddOSAP, // in > > - TCS_AUTHHANDLE* authHandle, // out > > - TPM_NONCE* nonceEven, // out > > - TPM_NONCE* nonceEvenOSAP) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_OSAP; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (authHandle == NULL || nonceEven == NULL || nonceEvenOSAP == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 6, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT16, &entityType, > > - BSG_TYPE_UINT32, &entityValue, > > - BSG_TPM_NONCE, &nonceOddOSAP); > > - > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS) { > > - > > - // unpack to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - // Extract the remaining output parameters > > - BSG_UnpackList(OutBuf+i, 3, > > - BSG_TYPE_UINT32, authHandle, > > - BSG_TPM_NONCE, nonceEven, > > - BSG_TPM_NONCE, nonceEvenOSAP); > > - > > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) { > > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > > - } > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_TakeOwnership(TCS_CONTEXT_HANDLE hContext, // in > > - UINT16 protocolID, // in > > - UINT32 encOwnerAuthSize, // in > > - BYTE* encOwnerAuth, // in > > - UINT32 encSrkAuthSize, // in > > - BYTE* encSrkAuth, // in > > - UINT32* SrkSize, // in, out > > - BYTE** Srk, // in, out > > - TCS_AUTH* ownerAuth) // in, out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_TakeOwnership; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (encOwnerAuth == NULL || encSrkAuth == NULL || SrkSize == NULL || *Srk == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 5, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT16, &protocolID, > > - BSG_TYPE_UINT32, &encOwnerAuthSize); > > - > > - memcpy(InBuf+InLength, encOwnerAuth, encOwnerAuthSize); > > - InLength += encOwnerAuthSize; > > - InLength += BSG_Pack( BSG_TYPE_UINT32, > > - &encSrkAuthSize, > > - InBuf+InLength); > > - memcpy(InBuf+InLength, encSrkAuth, encSrkAuthSize); > > - InLength += encSrkAuthSize; > > - memcpy(InBuf+InLength, *Srk, *SrkSize); > > - InLength += *SrkSize; > > - InLength += packAuth(InBuf+InLength, ownerAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, > > - &InLength, > > - InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS){ > > - > > - // unpack to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList( OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - TPM_KEY srkPub; > > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &srkPub); > > - unpackAuth(ownerAuth, OutBuf+i); > > - > > - // fill output params > > - BYTE tempBuf[1024]; > > - *SrkSize = BSG_Pack(BSG_TPM_KEY, &srkPub, tempBuf); > > - if (TCS_Malloc(hContext, *SrkSize, Srk) == TPM_FAIL) { > > - return(TPM_SIZE); > > - } > > - memcpy(*Srk, tempBuf, *SrkSize); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TakeOwnership Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > - > > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTH* ownerAuth) { // in, out > > - > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_DisablePubekRead; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal); > > - > > - InLength += packAuth(InBuf+InLength, ownerAuth); > > - > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS){ > > - > > - // unpack to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList( OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - unpackAuth(ownerAuth, OutBuf+i); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_DisablePubekRead Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > - > > -TPM_RESULT TCSP_TerminateHandle(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTHHANDLE handle) // in > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_Terminate_Handle; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &handle); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS) { > > - > > - // unpack to get the tag, paramSize, & returnCode > > - BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (!DeleteHandleFromList(hContext, handle)) > > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > > - > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - // Print debug info > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TerminateHandle Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - > > - } > > - > > - return(returnCode); > > -} > > - > > -// TPM Mandatory > > -TPM_RESULT TCSP_Extend( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_PCRINDEX pcrNum, // in > > - TPM_DIGEST inDigest, // in > > - TPM_PCRVALUE* outDigest) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_Extend; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 5, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &pcrNum, > > - BSG_TPM_DIGEST, &inDigest); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS) { > > - > > - // unpack to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND){ > > - // Extract the remaining output parameters > > - BSG_Unpack(BSG_TPM_PCRVALUE, OutBuf+i, outDigest); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Extend Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_Seal( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - TPM_ENCAUTH encAuth, // in > > - UINT32 pcrInfoSize, // in > > - BYTE* PcrInfo, // in > > - UINT32 inDataSize, // in > > - BYTE* inData, // in > > - TCS_AUTH* pubAuth, // in, out > > - UINT32* SealedDataSize, // out > > - BYTE** SealedData) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_Seal; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (inData == NULL || pubAuth == NULL || SealedDataSize == NULL || SealedData == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 6, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &keyHandle, > > - BSG_TPM_ENCAUTH, encAuth, > > - BSG_TYPE_UINT32, &pcrInfoSize); > > - memcpy(InBuf+InLength, PcrInfo, pcrInfoSize); > > - InLength += pcrInfoSize; > > - InLength += BSG_Pack(BSG_TYPE_UINT32, &inDataSize, InBuf+InLength); > > - memcpy(InBuf+InLength, inData, inDataSize); > > - InLength += inDataSize; > > - InLength += packAuth(InBuf+InLength, pubAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > > - == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - TPM_STORED_DATA sealedData; > > - > > - i += BSG_Unpack(BSG_TPM_STORED_DATA, OutBuf+i, &sealedData); > > - unpackAuth(pubAuth, OutBuf+i); > > - > > - // fill SealedData > > - BYTE tempBuf[1024]; > > - *SealedDataSize = BSG_Pack(BSG_TPM_STORED_DATA, &sealedData, tempBuf); > > - if (TCS_Malloc(hContext, *SealedDataSize, SealedData) == TPM_FAIL) { > > - return TPM_SIZE; > > - } > > - memcpy(*SealedData, tempBuf, *SealedDataSize); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Seal Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_Unseal(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE parentHandle, // in > > - UINT32 SealedDataSize, // in > > - BYTE* SealedData, // in > > - TCS_AUTH* parentAuth, // in, out > > - TCS_AUTH* dataAuth, // in, out > > - UINT32* DataSize, // out > > - BYTE** Data) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH2_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_Unseal; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (SealedData == NULL || parentAuth == NULL || dataAuth == NULL || > > - DataSize == NULL || Data == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &parentHandle); > > - memcpy(InBuf+InLength, SealedData, SealedDataSize); > > - InLength += SealedDataSize; > > - InLength += packAuth(InBuf+InLength, parentAuth); > > - InLength += packAuth(InBuf+InLength, dataAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList( OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH2_COMMAND) { > > - // Extract the remaining output parameters > > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, DataSize); > > - if (TCS_Malloc(hContext, *DataSize, Data) == TPM_FAIL) { > > - return TPM_SIZE; > > - } > > - memcpy(*Data, OutBuf+i, *DataSize); > > - i += *DataSize; > > - i += unpackAuth(parentAuth, OutBuf+i); > > - unpackAuth(dataAuth, OutBuf+i); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Unseal Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_UnBind(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - UINT32 inDataSize, // in > > - BYTE* inData, // in > > - TCS_AUTH* privAuth, // in, out > > - UINT32* outDataSize, // out > > - BYTE** outData) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_UnBind; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (inData == NULL || privAuth == NULL || outDataSize == NULL || outData == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 5, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &keyHandle, > > - BSG_TYPE_UINT32, &inDataSize); > > - memcpy(InBuf+InLength, inData, inDataSize); > > - InLength += inDataSize; > > - InLength += packAuth(InBuf+InLength, privAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "\n\tSending paramSize = %d", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, outDataSize); > > - if (TCS_Malloc(hContext, *outDataSize, outData) == TPM_FAIL) > > - return TPM_SIZE; > > - > > - memcpy(*outData, OutBuf+i, *outDataSize); > > - i += *outDataSize; > > - unpackAuth(privAuth, OutBuf+i); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_UnBind Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_CreateWrapKey(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hWrappingKey, // in > > - TPM_ENCAUTH KeyUsageAuth, // in > > - TPM_ENCAUTH KeyMigrationAuth, // in > > - UINT32* pcKeySize, // in, out > > - BYTE** prgbKey, // in, out > > - TCS_AUTH* pAuth) // in, out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_CreateWrapKey; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (pcKeySize == NULL || *prgbKey == NULL || pAuth == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 6, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &hWrappingKey, > > - BSG_TPM_ENCAUTH, KeyUsageAuth, > > - BSG_TPM_ENCAUTH, KeyMigrationAuth); > > - memcpy(InBuf+InLength, *prgbKey, *pcKeySize); > > - InLength += *pcKeySize; > > - InLength += packAuth(InBuf+InLength, pAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_RESULT, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - TPM_KEY wrappedKey; > > - > > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &wrappedKey); > > - unpackAuth(pAuth, OutBuf+i); > > - > > - // Fill prgbKey > > - BYTE tempBuf[1024]; > > - *pcKeySize = BSG_Pack(BSG_TPM_KEY, &wrappedKey, tempBuf); > > - if (TCS_Malloc(hContext, *pcKeySize, prgbKey) == TPM_FAIL) > > - return TPM_SIZE; > > - > > - memcpy(*prgbKey, tempBuf, *pcKeySize); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_CreateWrapKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_LoadKeyByBlob(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hUnwrappingKey, // in > > - UINT32 cWrappedKeyBlobSize, // in > > - BYTE* rgbWrappedKeyBlob, // in > > - TCS_AUTH* pAuth, // in, out > > - TCS_KEY_HANDLE* phKeyTCSI, // out > > - TCS_KEY_HANDLE* phKeyHMAC) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_LoadKey; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (rgbWrappedKeyBlob == NULL || pAuth == NULL || phKeyTCSI == NULL || phKeyHMAC == NULL) > > - return TPM_BAD_PARAMETER; > > - > > - *phKeyHMAC = hUnwrappingKey; // the parent key is the one that the TPM use to make the HMAC calc > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &hUnwrappingKey); > > - memcpy(InBuf+InLength, rgbWrappedKeyBlob, cWrappedKeyBlobSize); > > - InLength += cWrappedKeyBlobSize; > > - InLength += packAuth(InBuf+InLength, pAuth); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > > - // Extract the remaining output parameters > > - i += BSG_Unpack(BSG_TYPE_UINT32, > > - OutBuf+i, > > - phKeyTCSI); > > - unpackAuth(pAuth, OutBuf+i); > > - > > - if (!AddHandleToList(hContext, TPM_RT_KEY, *phKeyTCSI)) { > > - vtpmlogerror(VTPM_LOG_TCS, "New KeyHandle not recorded\n"); > > - } > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_LoadKeyByBlob Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_EvictKey(TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hKey) // in > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_EvictKey; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, &hKey); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (!DeleteHandleFromList(hContext, hKey)) { > > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > > - } > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else { > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_EvictKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - } > > - > > - return(returnCode); > > -} > > - > > -TPM_RESULT TCSP_GetRandom(TCS_CONTEXT_HANDLE hContext, // in > > - UINT32* bytesRequested, // in, out > > - BYTE** randomBytes) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_GetRandom; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (bytesRequested == NULL || *randomBytes == NULL){ > > - return TPM_BAD_PARAMETER; > > - } > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TYPE_UINT32, bytesRequested); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - // Extract the remaining output parameters > > - BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, bytesRequested); > > - if (TCS_Malloc(hContext, *bytesRequested, randomBytes) == TPM_FAIL) { > > - return TPM_SIZE; > > - } > > - memcpy(*randomBytes, OutBuf+i+sizeof(UINT32), *bytesRequested); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else { > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_GetRandom Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - } > > - > > - return(returnCode); > > -} > > - > > - > > -TPM_RESULT TCSP_ReadPubek(TCS_CONTEXT_HANDLE hContext, // in > > - TPM_NONCE antiReplay, // in > > - UINT32* pubEndorsementKeySize, // out > > - BYTE** pubEndorsementKey, // out > > - TPM_DIGEST* checksum) // out > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_ReadPubek; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // check input params > > - if (pubEndorsementKeySize == NULL || pubEndorsementKey == NULL || checksum == NULL) { > > - return TPM_BAD_PARAMETER; > > - } > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 4, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal, > > - BSG_TPM_NONCE, &antiReplay); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - int i = BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - // Extract the remaining output parameters > > - TPM_PUBKEY pubEK; > > - i += BSG_UnpackList(OutBuf+i, 2, > > - BSG_TPM_PUBKEY, &pubEK, > > - BSG_TPM_DIGEST, checksum); > > - > > - // fill EndorsementKey > > - BYTE tempBuf[1024]; > > - *pubEndorsementKeySize = BSG_Pack(BSG_TPM_PUBKEY, &pubEK, tempBuf); > > - if (TCS_Malloc(hContext, *pubEndorsementKeySize, pubEndorsementKey) == TPM_FAIL) { > > - return TPM_SIZE; > > - } > > - memcpy(*pubEndorsementKey, tempBuf, *pubEndorsementKeySize); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else { > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_ReadPubek Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - } > > - > > - return(returnCode); > > -} > > - > > - > > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext) // in > > -{ > > - // setup input/output parameters block > > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > > - UINT32 paramSize = 0; > > - TPM_COMMAND_CODE ordinal = TPM_ORD_SaveState; > > - TPM_RESULT returnCode = TPM_SUCCESS; > > - > > - // setup the TPM driver input and output buffers > > - TDDL_RESULT hRes = TDDL_E_FAIL; > > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > > - > > - // Convert Byte Input parameter in the input byte stream InBuf > > - InLength = BSG_PackList(InBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &ordinal); > > - // fill paramSize again as we now have the correct size > > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > > - > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > > - > > - // call the TPM driver > > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > > - // unpack OutBuf to get the tag, paramSize, & returnCode > > - BSG_UnpackList(OutBuf, 3, > > - BSG_TPM_TAG, &tag, > > - BSG_TYPE_UINT32, ¶mSize, > > - BSG_TPM_COMMAND_CODE, &returnCode); > > - > > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > > - } else { > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_SaveState Failed with return code %s\n", tpm_get_error_name(returnCode)); > > - } > > - } > > - > > - return(returnCode); > > -} > > - > > - > > -TPM_RESULT TCSP_RawTransmitData( UINT32 inDataSize, // in > > - BYTE *inData, // in > > - UINT32 *outDataSize,// in/out > > - BYTE *outData) { // out > > - > > - TDDL_RESULT hRes; > > - > > - vtpmloginfo(VTPM_LOG_TCS, "Calling TransmitData directly.\n"); > > - //FIXME: Add Context Management > > - hRes = TDDL_TransmitData( inData, > > - inDataSize, > > - outData, > > - outDataSize); > > - > > - if (hRes == TDDL_SUCCESS) { > > - return TPM_SUCCESS; > > - } else { > > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_RawTransmitData Failed with return code %s\n", tpm_get_error_name(TPM_IOERROR)); > > - return TPM_IOERROR; > > - } > > - > > -} > > diff --git a/tools/vtpm_manager/tcs/tcs.h b/tools/vtpm_manager/tcs/tcs.h > > deleted file mode 100644 > > index 83b9cd0..0000000 > > --- a/tools/vtpm_manager/tcs/tcs.h > > +++ /dev/null > > @@ -1,245 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// tcs.h > > -// > > -// This file declares the TCS API > > -// > > -// ================================================================== > > - > > -#ifndef __TCS_H__ > > -#define __TCS_H__ > > - > > -#include "tcg.h" > > -#include "contextmgr.h" > > -#include "buffer.h" > > - > > -#define HANDLE_NULL 0 > > - > > -// ------------------------------------------------------------------ > > -// Exposed API > > -// ------------------------------------------------------------------ > > - > > -TPM_RESULT TCS_create(); > > -void TCS_destroy(); > > - > > -TPM_RESULT TCS_OpenContext( /* OUT */ TCS_CONTEXT_HANDLE* hContext ); > > - > > -TPM_RESULT TCS_CloseContext ( /* IN */ TCS_CONTEXT_HANDLE hContext ); > > - > > -TPM_RESULT TCS_Malloc ( TCS_CONTEXT_HANDLE hContext, // in > > - UINT32 MemSize, // in > > - BYTE** ppMemPtr ); //out > > - > > -TPM_RESULT TCS_FreeMemory ( TCS_CONTEXT_HANDLE hContext, // in > > - BYTE* pMemory); // in > > - > > -// ------------------------------------------------------------------ > > -// Exposed API > > -// ------------------------------------------------------------------ > > - > > -// TPM v1.1B Command Set > > - > > -// Authorzation > > -TPM_RESULT TCSP_OIAP( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTHHANDLE* authHandle, // out > > - TPM_NONCE* nonce0 // out > > - ); > > - > > -TPM_RESULT TCSP_OSAP ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_ENTITY_TYPE entityType, // in > > - UINT32 entityValue, // in > > - TPM_NONCE nonceOddOSAP, // in > > - TCS_AUTHHANDLE* authHandle, // out > > - TPM_NONCE* nonceEven, // out > > - TPM_NONCE* nonceEvenOSAP // out > > - ); > > - > > -TPM_RESULT TCSP_TakeOwnership ( TCS_CONTEXT_HANDLE hContext, // in > > - UINT16 protocolID, // in > > - UINT32 encOwnerAuthSize, // in > > - BYTE* encOwnerAuth, // in > > - UINT32 encSrkAuthSize, // in > > - BYTE* encSrkAuth, // in > > - UINT32* SrkSize, // in, out > > - BYTE** Srk, // in, out > > - TCS_AUTH* ownerAuth // in, out > > - ); > > - > > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTH* ownerAuth // in, out > > - ); > > - > > -TPM_RESULT TCSP_TerminateHandle ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTHHANDLE handle // in > > - ); > > - > > -TPM_RESULT TCSP_FlushSpecific ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_AUTHHANDLE handle, // in > > - TPM_RESOURCE_TYPE resourceType //in > > - ); > > - > > -// TPM Mandatory > > -TPM_RESULT TCSP_Extend ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_PCRINDEX pcrNum, // in > > - TPM_DIGEST inDigest, // in > > - TPM_PCRVALUE* outDigest // out > > - ); > > - > > -TPM_RESULT TCSP_PcrRead ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_PCRINDEX pcrNum, // in > > - TPM_PCRVALUE* outDigest // out > > - ); > > - > > -TPM_RESULT TCSP_Quote ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - TPM_NONCE antiReplay, // in > > - UINT32* PcrDataSize, // in, out > > - BYTE** PcrData, // in, out > > - TCS_AUTH* privAuth, // in, out > > - UINT32* sigSize, // out > > - BYTE** sig // out > > - ); > > - > > -TPM_RESULT TCSP_Seal ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - TPM_ENCAUTH encAuth, // in > > - UINT32 pcrInfoSize, // in > > - BYTE* PcrInfo, // in > > - UINT32 inDataSize, // in > > - BYTE* inData, // in > > - TCS_AUTH* pubAuth, // in, out > > - UINT32* SealedDataSize, // out > > - BYTE** SealedData // out > > - ); > > - > > -TPM_RESULT TCSP_Unseal ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE parentHandle, // in > > - UINT32 SealedDataSize, // in > > - BYTE* SealedData, // in > > - TCS_AUTH* parentAuth, // in, out > > - TCS_AUTH* dataAuth, // in, out > > - UINT32* DataSize, // out > > - BYTE** Data // out > > - ); > > - > > -TPM_RESULT TCSP_DirWriteAuth ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_DIRINDEX dirIndex, // in > > - TPM_DIRVALUE newContents, // in > > - TCS_AUTH* ownerAuth // in, out > > - ); > > - > > -TPM_RESULT TCSP_DirRead ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_DIRINDEX dirIndex, // in > > - TPM_DIRVALUE* dirValue // out > > - ); > > - > > -TPM_RESULT TCSP_UnBind ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - UINT32 inDataSize, // in > > - BYTE* inData, // in > > - TCS_AUTH* privAuth, // in, out > > - UINT32* outDataSize, // out > > - BYTE** outData // out > > - ); > > - > > -TPM_RESULT TCSP_CreateWrapKey ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hWrappingKey, // in > > - TPM_ENCAUTH KeyUsageAuth, // in > > - TPM_ENCAUTH KeyMigrationAuth, // in > > - UINT32* pcKeySize, // in, out > > - BYTE** prgbKey, // in, out > > - TCS_AUTH* pAuth // in, out > > - ); > > - > > -TPM_RESULT TCSP_LoadKeyByBlob ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hUnwrappingKey, // in > > - UINT32 cWrappedKeyBlobSize, // in > > - BYTE* rgbWrappedKeyBlob, // in > > - TCS_AUTH* pAuth, // in, out > > - TCS_KEY_HANDLE* phKeyTCSI, // out > > - TCS_KEY_HANDLE* phKeyHMAC // out > > - ); > > - > > -TPM_RESULT TCSP_GetPubKey ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hKey, // in > > - TCS_AUTH* pAuth, // in, out > > - UINT32* pcPubKeySize, // out > > - BYTE** prgbPubKey // out > > - ); > > - > > -TPM_RESULT TCSP_EvictKey ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE hKey // in > > - ); > > - > > -TPM_RESULT TCSP_Sign ( TCS_CONTEXT_HANDLE hContext, // in > > - TCS_KEY_HANDLE keyHandle, // in > > - UINT32 areaToSignSize, // in > > - BYTE* areaToSign, // in > > - TCS_AUTH* privAuth, // in, out > > - UINT32* sigSize, // out > > - BYTE** sig // out > > - ); > > - > > -TPM_RESULT TCSP_GetRandom ( TCS_CONTEXT_HANDLE hContext, // in > > - UINT32* bytesRequested, // in, out > > - BYTE** randomBytes // out > > - ); > > - > > -TPM_RESULT TCSP_StirRandom ( TCS_CONTEXT_HANDLE hContext, // in > > - UINT32 inDataSize, // in > > - BYTE* inData // in > > - ); > > - > > -TPM_RESULT TCSP_ReadPubek ( TCS_CONTEXT_HANDLE hContext, // in > > - TPM_NONCE antiReplay, // in > > - UINT32* pubEndorsementKeySize, // out > > - BYTE** pubEndorsementKey, // out > > - TPM_DIGEST* checksum // out > > - ); > > - > > - > > -// Non-Standard TCSP calls > > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext); // in > > - > > -//Give direct access to TransmitData. > > -// Key and Auth Management is done before transfering command to TDDL. > > -TPM_RESULT TCSP_RawTransmitData(UINT32 inDataSize, // in > > - BYTE *inData, // in > > - UINT32 *outDataSize,// in/out > > - BYTE *outData); // out > > - > > -///////////// Private Functions //////////////////// > > -CONTEXT_HANDLE* LookupContext( TCS_CONTEXT_HANDLE hContext); > > - > > -#endif //TCS_H > > diff --git a/tools/vtpm_manager/tcs/tpmddl.h b/tools/vtpm_manager/tcs/tpmddl.h > > deleted file mode 100644 > > index e7e54f1..0000000 > > --- a/tools/vtpm_manager/tcs/tpmddl.h > > +++ /dev/null > > @@ -1,69 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// tpmddl.c > > -// > > -// This file defines the TDDLI API > > -// > > -// ================================================================== > > - > > -#ifndef __TPMDDL_H__ > > -#define __TPMDDL_H__ > > - > > -#define TDDL_CAP_PROP_MANUFACTURER 0x0001 > > - > > -#define TDDL_E_FAIL 1 > > -#define TDDL_E_SUCCESS 0 > > -#define TDDL_SUCCESS 0 > > - > > -typedef unsigned int TDDL_UINT32; > > -typedef TDDL_UINT32 TDDL_RESULT; > > -typedef unsigned char TDDL_BYTE; > > - > > -TDDL_RESULT TDDL_Open(); > > -void TDDL_Close(); > > -TDDL_RESULT TDDL_TransmitData( TDDL_BYTE* in, > > - TDDL_UINT32 insize, > > - TDDL_BYTE* out, > > - TDDL_UINT32* outsize); > > -TDDL_RESULT TDDL_GetStatus(); > > -TDDL_RESULT TDDL_GetCapability( TDDL_UINT32 cap, > > - TDDL_UINT32 sub, > > - TDDL_BYTE* buffer, > > - TDDL_UINT32* size); > > -TDDL_RESULT TDDL_SetCapability( TDDL_UINT32 cap, > > - TDDL_UINT32 sub, > > - TDDL_BYTE* buffer, > > - TDDL_UINT32* size); > > - > > -#endif // __TPMDDL_H__ > > diff --git a/tools/vtpm_manager/tcs/transmit.c b/tools/vtpm_manager/tcs/transmit.c > > deleted file mode 100644 > > index 74bbdca..0000000 > > --- a/tools/vtpm_manager/tcs/transmit.c > > +++ /dev/null > > @@ -1,147 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "buffer.h" > > -#include "log.h" > > -#include "tpmddl.h" > > - > > -// flag to track whether TDDL has been opened > > -static int g_TDDL_open = 0; > > -static int g_tx_fd = -1; // the fd to the TPM > > - > > -#ifndef DUMMY_TPM > > - #define TPM_TX_FNAME "/dev/tpm0" > > - static int *g_rx_fdp = &g_tx_fd; > > -#else > > - #define TPM_TX_FNAME "/var/tpm/tpm_in.fifo" > > - #define TPM_RX_FNAME "/var/tpm/tpm_out.fifo" > > - static int g_rx_fd = -1; > > - static int *g_rx_fdp = &g_rx_fd; // the fd to the TPM > > -#endif > > - > > -TPM_RESULT > > -TDDL_TransmitData( TDDL_BYTE* in, > > - TDDL_UINT32 insize, > > - TDDL_BYTE* out, > > - TDDL_UINT32* outsize) { > > - TPM_RESULT status = TPM_SUCCESS; > > - TDDL_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 (g_tx_fd, in, insize); > > - if (size < 0) { > > - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed"); > > - ERRORDIE (TPM_IOERROR); > > - } > > - else if ((TDDL_UINT32) size < insize) { > > - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); > > - // ... ? > > - } > > - > > - // read the response > > - size = read (*g_rx_fdp, out, TCPA_MAX_BUFFER_LENGTH); > > - if (size < 0) { > > - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed"); > > - 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; > > - // close connection > > - goto egress; > > - > > - abort_egress: > > - egress: > > - return status; > > -} > > - > > -TPM_RESULT TDDL_Open() { > > - > > - TDDL_RESULT status = TDDL_SUCCESS; > > - > > - if (g_TDDL_open) > > - return TPM_FAIL; > > - > > -#ifdef DUMMY_TPM > > - *g_rx_fdp = open (TPM_RX_FNAME, O_RDWR); > > -#endif > > - > > - g_tx_fd = open (TPM_TX_FNAME, O_RDWR); > > - if (g_tx_fd < 0) { > > - vtpmlogerror(VTPM_LOG_TXDATA, "TPM open failed"); > > - return TPM_IOERROR; > > - } > > - > > - g_TDDL_open = 1; > > - > > - return status; > > -} > > - > > -void TDDL_Close() { > > - if (! g_TDDL_open) > > - return; > > - > > - if (g_tx_fd>= 0) { > > - if (close(g_tx_fd) < 0) > > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > > - g_tx_fd = -1; > > - } > > - > > - if (*g_rx_fdp>= 0) { > > - if (close(*g_rx_fdp) < 0) > > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > > - *g_rx_fdp = -1; > > - } > > - > > - g_TDDL_open = 0; > > - > > -} > > diff --git a/tools/vtpm_manager/util/Makefile b/tools/vtpm_manager/util/Makefile > > deleted file mode 100644 > > index 36bc38f..0000000 > > --- a/tools/vtpm_manager/util/Makefile > > +++ /dev/null > > @@ -1,24 +0,0 @@ > > -XEN_ROOT = $(CURDIR)/../../.. > > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > > - > > -BIN = libTCGUtils.a > > - > > -.PHONY: all > > -all: build > > - > > -.PHONY: build > > -build: $(BIN) > > - > > -.PHONY: install > > -install: build > > - > > -.PHONY: clean > > -clean: > > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > > - > > -.PHONY: mrproper > > -mrproper: clean > > - rm -f *~ > > - > > -$(BIN): $(OBJS) > > - $(AR) rcs $(BIN) $(OBJS) > > diff --git a/tools/vtpm_manager/util/bsg.c b/tools/vtpm_manager/util/bsg.c > > deleted file mode 100644 > > index fa36ce7..0000000 > > --- a/tools/vtpm_manager/util/bsg.c > > +++ /dev/null > > @@ -1,829 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// bsg.cpp > > -// > > -// This file will handle all the TPM Byte Stream functions > > -// > > -// ================================================================== > > - > > -#include > > -#include > > -#include > > -#include > > -#include "tcg.h" > > -#include "crypto.h" > > -#include "bsg.h" > > -#include "log.h" > > - > > -static int g_log_recursion_level = 0; > > - > > -// a largest buffer size. if we get a buf size bigger than this when unpacking, > > -// will complain! > > -#define BSG_MAX_BUF_SIZE (1<<18) > > - > > -#define bsglog(fmt, ...) do { \ > > - int __i; \ > > - for (__i=0; __i < g_log_recursion_level; __i++) { \ > > - vtpmloginfomore (VTPM_LOG_BSG, "%s", " "); \ > > - } \ > > - vtpmloginfomore (VTPM_LOG_BSG, fmt, __VA_ARGS__); \ > > - } while (0) > > - > > - > > -// FIXME: trigger the selfcheck--need to use glibc hook to do this > > -//BOOL dummy1 = BSG_static_selfcheck(); > > - > > - > > -// Interpretting Types > > -// ------------------- > > -// > > -// Incoming Types are composed of two parts {format, info} squished into a > > -// BSG_UINT32. The first 4 bits is a format spec indicating what type of > > -// data it is. If the first 4 bits are zero the info corresponds to a value in > > -// BSG_s_fmt[]. This is a structure whose composition is described in > > -// BSG_s_fmt[]. If the value is non-zero, info corresponds to the size of the > > -// data (in bytes) being passed in. For example a UINT32 being passed in would > > -// have a format of (__FMT_CONST | 4). If both, the format and info are zero, > > -// this is interpretted as the end of the structure, and the result is returned. > > - > > -// these flags are mutually exclusive, so I'll just make them > > -// format values which indicate the semantics of the 'info' part and the source > > -// data. The above description has been accordingly adjusted. > > - > > -// format values for determining what type of data the incoming type is > > -// it's a 4 bit value, occupying the high 4 bits > > -#define __FMT_CONST (1UL << 28) // Constant sized value > > -#define __FMT_DATA (2UL << 28) // Believed to be raw data NOT {size,data} > > -#define __FMT_SIZE (3UL << 28) // A size. Used in FMT_SIZE??_DATA. > > -#define __FMT_HSIZE (4UL << 28) // A number of handles > > -#define __FMT_PACKED (5UL << 28) // 'info' is unused; the source data consists > > - // of {size32, data} but we're to pack only the > > - // data as that is already packed, and so > > - // can/must be unpacked without > > - // explicitly reading it size > > - > > -#define __FMT_MASK 0x0FFFFFFFUL // this masks out the 4-bit format > > -#define __FMT_MASK_SIZE(type) ((type) & __FMT_MASK) > > -#define __FMT_MASK_FORMAT(type) ((type) & (~__FMT_MASK)) > > - > > -// constant (8/16/32-bits) > > -#define FMT_U8 (__FMT_CONST | 1UL) > > -#define FMT_U16 (__FMT_CONST | 2UL) > > -#define FMT_U32 (__FMT_CONST | 4UL) > > - > > -// const with a compiler-computed size > > -#define FMT_SIZEOF(type) (__FMT_CONST | sizeof(type)) > > - > > -// other data (size bytes) > > -// Used primarily for DIGESTS -> FMT_DATA(20) > > -#define FMT_DATA(size) (__FMT_DATA | ((BSG_UINT32) (size) & __FMT_MASK)) > > - > > -// 16/32-bit size followed by N bytes of data > > -#define FMT_SIZE16_DATA (__FMT_SIZE | 2UL) > > -#define FMT_SIZE32_DATA (__FMT_SIZE | 4UL) > > - > > -// 16-bit size followed by N key handles > > -#define FMT_SIZE16_HANDLES (__FMT_HSIZE | 2UL) > > - > > -#define DIGEST_SIZE 20 > > -typedef BSG_UINT32 BSG_HANDLE; > > - > > -// TCPA_AUTH has 11 fields! > > -#define MAX_FIELDS 11 > > -typedef struct BSG_Format > > -{ > > - BSG_Type type; > > - const char* name; > > - BSG_UINT32 fields[MAX_FIELDS + 1]; > > -} BSG_Format; > > - > > -/* > > - * TCPA structure data formats > > - */ > > -// this has to be manually kept in sync with the > > -// Type enum!! the static_selfcheck() function should be used regularly! > > -static BSG_Format s_fmt[] = > > -{ > > - {BSG_TYPE_UINT32, "BSG_TYPE_UINT32", {FMT_U32, 0}}, > > - {BSG_TYPE_UINT16, "BSG_TYPE_UINT16", {FMT_U16, 0}}, > > - {BSG_TYPE_BYTE, "BSG_TYPE_BYTE", {FMT_U8, 0}}, > > - {BSG_TYPE_BOOL, "BSG_TYPE_BOOL", {FMT_U8, 0}}, > > - {BSG_TPM_SIZE32_DATA, "BSG_TPM_SIZE32_DATA", {FMT_SIZE32_DATA, 0}}, > > - {BSG_TPM_TAG, "BSG_TPM_TAG", {FMT_SIZEOF(TPM_TAG), 0}}, > > - {BSG_TPM_HANDLE, "BSG_TPM_HANDLE", {FMT_SIZEOF(TPM_HANDLE), 0}}, > > - {BSG_TPM_RESULT, "BSG_TPM_RESULT", {FMT_SIZEOF(TPM_RESULT), 0}}, > > - {BSG_TPM_RESOURCE_TYPE, "BSG_TPM_RESOURCE_TYPE", {FMT_SIZEOF(TPM_RESOURCE_TYPE), 0}}, > > - {BSG_TPM_COMMAND_CODE, "BSG_TPM_COMMAND_CODE", {FMT_U32, 0}}, > > - {BSG_TPM_AUTH_DATA_USAGE, "BSG_TPM_AUTH_DATA_USAGE", {FMT_U8, 0}}, > > - {BSG_TPM_ALGORITHM_ID, "BSG_TPM_ALGORITHM_ID", {FMT_U32, 0}}, > > - {BSG_TPM_PROTOCOL_ID, "BSG_TPM_PROTOCOL_ID", {FMT_SIZEOF(TPM_PROTOCOL_ID), 0}}, > > - {BSG_TPM_KEY_USAGE, "BSG_TPM_KEY_USAGE", {FMT_U16, 0}}, > > - {BSG_TPM_ENC_SCHEME, "BSG_TPM_ENC_SCHEME", {FMT_U16, 0}}, > > - {BSG_TPM_SIG_SCHEME, "BSG_TPM_SIG_SCHEME", {FMT_U16, 0}}, > > - {BSG_TPM_MIGRATE_SCHEME, "BSG_TPM_MIGRATE_SCHEME", {FMT_U16, 0}}, > > - {BSG_TPM_KEY_FLAGS, "BSG_TPM_KEY_FLAGS", {FMT_U32, 0}}, > > - > > - {BSG_TPM_AUTHDATA, "BSG_TPM_AUTHDATA", {FMT_DATA(DIGEST_SIZE), 0}}, > > - {BSG_TPM_SECRET, "BSG_TPM_SECRET", {BSG_TPM_AUTHDATA, 0}}, > > - {BSG_TPM_ENCAUTH, "BSG_TPM_ENCAUTH", {BSG_TPM_AUTHDATA, 0}}, > > - {BSG_TPM_PAYLOAD_TYPE, "BSG_TPM_PAYLOAD_TYPE", {FMT_SIZEOF(TPM_PAYLOAD_TYPE), 0}}, > > - > > - {BSG_TPM_VERSION, "BSG_TPM_VERSION", {FMT_DATA(4), 0}}, // vers 1.2 > > - {BSG_TPM_DIGEST, "BSG_TPM_DIGEST", {FMT_DATA(DIGEST_SIZE), 0}}, > > - {BSG_TPM_COMPOSITE_HASH, "BSG_TPM_COMPOSITE_HASH", {BSG_TPM_DIGEST, 0}}, > > - {BSG_TPM_CHOSENID_HASH, "BSG_TPM_CHOSENID_HASH", {BSG_TPM_DIGEST, 0}}, > > - > > - {BSG_TPM_NONCE, "BSG_TPM_NONCE", {FMT_DATA(DIGEST_SIZE), 0}}, > > - {BSG_TPM_KEY_HANDLE, "BSG_TPM_KEY_HANDLE", {FMT_SIZEOF(TPM_KEY_HANDLE), 0}}, > > - {BSG_TPM_KEY_HANDLE_LIST, "BSG_TPM_KEY_HANDLE_LIST", > > - {FMT_SIZE16_HANDLES, 0}}, > > - > > - {BSG_TPM_KEY_PARMS, "BSG_TPM_KEY_PARMS", { > > - BSG_TPM_ALGORITHM_ID, > > - BSG_TPM_ENC_SCHEME, > > - BSG_TPM_SIG_SCHEME, > > - FMT_SIZE32_DATA, > > - 0}}, > > - {BSG_TPM_RSA_KEY_PARMS, "BSG_TPM_RSA_KEY_PARMS", { > > - FMT_U32, FMT_U32, FMT_SIZE32_DATA, 0}}, > > - {BSG_TPM_STORE_PUBKEY, "BSG_TPM_STORE_PUBKEY", {FMT_SIZE32_DATA, 0}}, > > - {BSG_TPM_PUBKEY, "BSG_TPM_PUBKEY", {BSG_TPM_KEY_PARMS, BSG_TPM_STORE_PUBKEY, 0}}, > > - {BSG_TPM_KEY, "BSG_TPM_KEY", { > > - BSG_TPM_VERSION, > > - BSG_TPM_KEY_USAGE, > > - BSG_TPM_KEY_FLAGS, > > - BSG_TPM_AUTH_DATA_USAGE, > > - BSG_TPM_KEY_PARMS, > > - FMT_SIZE32_DATA, // the PCR_INFO > > - BSG_TPM_STORE_PUBKEY, > > - FMT_SIZE32_DATA, // the encrypted part > > - 0}}, > > - > > - {BSG_TPM_MIGRATIONKEYAUTH, "BSG_TPM_MIGRATIONKEYAUTH", { > > - BSG_TPM_PUBKEY, > > - BSG_TPM_MIGRATE_SCHEME, > > - BSG_TPM_DIGEST, 0}}, > > - > > - {BSG_TCPA_AUDIT_EVENT, "TCPA_AUDIT_EVENT", { > > - BSG_TPM_COMMAND_CODE, > > - BSG_TPM_RESULT, 0 }}, > > - > > - {BSG_TCPA_EVENT_CERT, "TCPA_EVENT_CERT", { > > - BSG_TPM_DIGEST, > > - BSG_TPM_DIGEST, > > - FMT_DATA(2), > > - FMT_SIZE32_DATA, 0}}, > > - > > - {BSG_TPM_PCR_SELECTION, "BSG_TPM_PCR_SELECTION", {FMT_SIZE16_DATA, 0} }, > > - {BSG_TPM_PCR_COMPOSITE, "BSG_TPM_PCR_COMPOSITE", { BSG_TPM_PCR_SELECTION, > > - FMT_SIZE32_DATA, > > - 0} }, > > - > > - {BSG_TPM_PCR_INFO, "BSG_TPM_PCR_INFO", { BSG_TPM_PCR_SELECTION, > > - BSG_TPM_COMPOSITE_HASH, > > - BSG_TPM_COMPOSITE_HASH, > > - 0} }, > > - > > - > > - {BSG_TPM_STORED_DATA, "BSG_TPM_STORED_DATA", { > > - BSG_TPM_VERSION, > > - FMT_SIZE32_DATA, > > - FMT_SIZE32_DATA, > > - 0}}, > > - {BSG_TPM_SYMMETRIC_KEY, "BSG_TPM_SYMMETRIC_KEY", { > > - BSG_TPM_ALGORITHM_ID, > > - BSG_TPM_ENC_SCHEME, > > - FMT_SIZE16_DATA, > > - 0}}, > > - {BSG_TPM_STORE_PRIVKEY, "BSG_TPM_STORE_PRIVKEY", {FMT_SIZE32_DATA, 0}}, > > - {BSG_TPM_STORE_ASYMKEY, "BSG_TPM_STORE_ASYMKEY", { > > - BSG_TPM_PAYLOAD_TYPE, > > - BSG_TPM_SECRET, > > - BSG_TPM_SECRET, > > - BSG_TPM_DIGEST, > > - BSG_TPM_STORE_PRIVKEY, > > - 0}}, > > - {BSG_TPM_MIGRATE_ASYMKEY, "BSG_TPM_MIGRATE_ASYMKEY", { > > - BSG_TPM_PAYLOAD_TYPE, > > - BSG_TPM_SECRET, > > - BSG_TPM_DIGEST, > > - FMT_U32, > > - BSG_TPM_STORE_PRIVKEY, > > - 0}}, > > - > > - {BSG_TPM_QUOTE_INFO, "BSG_TPM_QUOTE_INFO", { > > - BSG_TPM_VERSION, > > - FMT_DATA(4), > > - BSG_TPM_COMPOSITE_HASH, > > - BSG_TPM_NONCE, > > - 0}}, > > - > > - {BSG_TPM_IDENTITY_CONTENTS, "BSG_TPM_IDENTITY_CONTENTS", { > > - BSG_TPM_VERSION, > > - FMT_U32, > > - BSG_TPM_CHOSENID_HASH, > > - BSG_TPM_PUBKEY, > > - 0}}, > > - > > - {BSG_TPM_PCRVALUE, "BSG_TPM_PCRVALUE", {FMT_DATA(DIGEST_SIZE), 0}}, > > - > > - {BSG_TCPA_PCR_FLAGS, "TCPA_PCR_FLAGS", { > > - FMT_U8, > > - FMT_U8, > > - 0}}, > > - > > - {BSG_TCS_AUTH, "TCS_AUTH", { > > - BSG_TYPE_UINT32, > > - BSG_TPM_NONCE, > > - BSG_TPM_NONCE, > > - BSG_TYPE_BOOL, > > - BSG_TPM_AUTHDATA, > > - 0}}, > > - > > - {BSG_TPM_KEY_NONSENSITIVE, "BSG_TPM_KEY_NONSENSITIVE", { > > - BSG_TPM_VERSION, > > - BSG_TPM_KEY_USAGE, > > - BSG_TPM_KEY_FLAGS, > > - BSG_TPM_AUTH_DATA_USAGE, > > - BSG_TPM_KEY_PARMS, > > - FMT_SIZE32_DATA, > > - BSG_TPM_STORE_PUBKEY, > > - 0}}, > > - > > - {BSG_PACKED, "BSG_PACKED", { > > - __FMT_PACKED, > > - 0 }}, > > - > > - {BSG_TYPE_MAX, "", {0}}, > > -}; > > - > > - > > -static const BSG_Format* find_format (BSG_Type t) { > > - BSG_Format * f = s_fmt; > > - > > - if (t >= BSG_TYPE_MAX) { > > - return NULL; > > - } > > - > > - // WARNING: this depends on the enum and s_fmt[] array being in sync! make > > - // sure to run the static_selfcheck() to make sure > > - f = s_fmt + (t - BSG_TYPE_FIRST); > > - > > - return f; > > -} > > - > > -// > > -// a consistency-checking routine which can be run at compile time > > -// (ie. immediately after compilation) > > -// > > -// tasks: > > -// - verify that s_fmt has one entry per Type t, and that entry is at s_fmt[t] > > -// > > -// conditions: > > -// - need that s_fmt[0] is the first type listed in the Type enum! ie the first > > -// Type has value 0, not 1 > > -// > > -// FIXME: should have a function be passed in here which is called if the test > > -// fails. Then the caller can decide what to do: abort, notify, whatever > > -// > > -BOOL BSG_static_selfcheck () > > -{ > > - int i; > > - > > - for (i=BSG_TYPE_FIRST; i <= BSG_TYPE_MAX; i++) { > > - if (s_fmt[i - BSG_TYPE_FIRST].type != i) { > > - bsglog ("%s\n", "BSG: static_selfcheck failed!\n"); > > - bsglog ("failure at %i, allegedly %s\n", > > - i, s_fmt[i - BSG_TYPE_FIRST].name); > > - abort(); > > - return FALSE; > > - } > > - } > > - > > - bsglog ("%s\n", "BSG: static_selfcheck success!"); > > - return TRUE; > > -} > > - > > - > > -/** > > - * Flatten a TCPA structure into a buffer in big-endian format > > - * @type: TCPA structure type > > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > > - * @dst: (OUT) flattened data > > - * Returns: Flattened size or -1 for unknown types > > - */ > > -// make it so that it can just run through the whole process and return > > -// the packed size, without packing anything. this will be done if dst is NULL. > > -static int BSG_Pack_private(BSG_Type type, const BSG_BYTE** src, BSG_BYTE* dst) > > -{ > > - // check incoming parameters > > - if (*src == NULL) > > - return 0; > > - > > - const BSG_BYTE* s = *src; > > - BSG_BYTE* d = dst; > > - > > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > > - > > - if (format == __FMT_CONST) // We are dealing with a fixed length value eg. UINT32 > > - { > > - BSG_UINT32 val = 0; > > - switch (size) { > > - case 1: val = * (BYTE*) s; break; > > - case 2: val = * (unsigned short*) s; break; > > - case 4: val = * (BSG_UINT32*) s; break; > > - } > > - if (dst) > > - BSG_PackConst(val, size, d); > > - > > - s += size; > > - d += size; > > - } else if (format == __FMT_DATA) { // We are dealing with raw data. Not sure when > > - // this is used. > > - > > - if (dst) { > > - bsglog ("BSG: __FMT_DATA size %d, src %p, dst %p\n", size, s, d); > > - memcpy(d, s, size); > > - } > > - > > - s += size; > > - d += size; > > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) { // It's a size, followed by that much data or handles > > - > > - BSG_UINT32 psize = 0; > > - switch (size) { > > - case 1: psize = * (BYTE*) s; break; > > - case 2: psize = * (unsigned short*) s; break; > > - case 4: psize = * (BSG_UINT32*) s; break; > > - } > > - > > - if (dst) > > - BSG_PackConst(psize, size, d); > > - > > - s += size; > > - d += size; > > - > > - // now 's' points to an address, so cast it to BSG_BYTE** > > - const BSG_BYTE* pdata = * ((BSG_BYTE**) s); > > - s += sizeof(BSG_BYTE*); > > - > > - if (format == __FMT_HSIZE) {// This is a list of psize Handles > > - if (dst) { > > - BSG_HANDLE* d2 = (BSG_HANDLE*) d; > > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > > - BSG_UINT32 i; > > - for (i = 0; i < psize; i++) > > - d2[i] = BSG_UnpackConst((BSG_BYTE*)(p2 + i), 4); > > - > > - } > > - d += psize * sizeof(BSG_HANDLE); > > - } else {// If it's not psize handles, it's psize data. > > - if (psize > 0) { > > - if (dst) { > > - bsglog ("BSG: __FMT_SIZE, size=%d, src=%p, dst=%p\n", > > - psize, pdata, d); > > - memcpy(d, pdata, psize); > > - } > > - } > > - d += psize; > > - } > > - } else if (format == __FMT_PACKED) { > > - // the source buffer is a pack_constbuf_t, which has a size and a > > - // pointer. just copy the buffer value, the size is not included in the > > - // output stream. > > - pack_constbuf_t * buf = (pack_constbuf_t*) s; > > - > > - if (dst) { > > - bsglog ("BSG: __FMT_PACKED, size=%d, src=%p, dst=%p\n", > > - buf->size, buf->data, d); > > - memcpy(d, buf->data, buf->size); > > - } > > - > > - s += buf->size; > > - d += buf->size; > > - } else if (format == 0) {// No flags are set. This is a structure & it should > > - // be looked up in the bsg_s_fmt[] > > - > > - const BSG_Format* x = find_format (type); > > - if (x == NULL) { > > - vtpmloginfo(VTPM_LOG_BSG, "BSG_Pack: cannot find type %d\n", type); > > - return -1; > > - } > > - > > - if (dst) > > - bsglog ("BSG_Pack type %s\n", x->name); > > - > > - > > - // iterate through the fields > > - const BSG_UINT32* f = x->fields; > > - for (; *f; f++) { > > - int fsize; > > - > > - g_log_recursion_level++; > > - fsize = BSG_Pack_private((BSG_Type) *f, &s, dst ? d : NULL); > > - g_log_recursion_level--; > > - > > - if (fsize <= 0) > > - return fsize; > > - > > - d += fsize; > > - } > > - } else { > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Pack(): Unknown format %d\n", format); > > - return -1; > > - } > > - > > - *src = s; > > - return (d - dst); > > -} > > - > > -/** > > - * Unflatten a TCPA structure from a buffer in big-endian format > > - * @type: TCPA structure type > > - * @src: flattened data > > - * @dst: (IN) TCPA structure (OUT) end of TCPA structure > > - * Returns: Flattened size > > - * Note: Returns flattened size NOT the unpacked structure size > > - */ > > -static int BSG_Unpack_private(BSG_Type type, const BSG_BYTE* src, BSG_BYTE** dst) { > > - // check incoming parameters > > - if (src == NULL) > > - return 0; > > - > > - > > - const BSG_BYTE* s = src; > > - BSG_BYTE* d = dst ? *dst:NULL; > > - if (dst && !d) > > - dst = NULL; > > - > > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > > - > > - if (format == __FMT_CONST) {// We are dealing with a fixed length value ie. UINT32 > > - > > - BSG_UINT32 val = BSG_UnpackConst(s, size); > > - > > - if (dst) { > > - switch (size) { > > - case 1: *(BYTE *) d = (BSG_BYTE) val; break; > > - case 2: *(unsigned short*) d = (unsigned short) val; break; > > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) val; break; > > - } > > - } > > - > > - s += size; > > - d += size; > > - } else if (format == __FMT_DATA) {// We are dealing with raw data. Not sure when this is used. > > - if (dst) > > - memcpy(d, s, size); > > - > > - d += size; > > - s += size; > > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) {// It's a size, followed by that much data or handles > > - > > - BSG_UINT32 psize = BSG_UnpackConst(s, size); > > - > > - if (psize > BSG_MAX_BUF_SIZE) { > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack runs into var-sized data bigger than %u bytes!!\n", > > - BSG_MAX_BUF_SIZE); > > - return -1; > > - } > > - > > - if (dst) { > > - switch (size) { > > - case 1: *(BYTE *) d = (BSG_BYTE) psize; break; > > - case 2: *(unsigned short*) d = (unsigned short) psize; break; > > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) psize; break; > > - } > > - } > > - > > - s += size; > > - d += size; > > - > > - BSG_BYTE* pdata = NULL; > > - > > - if (psize) { > > - if (format == __FMT_HSIZE) { // This is a list of psize Handles > > - if (dst) { > > - BSG_HANDLE* s2 = (BSG_HANDLE*) s; > > - pdata = (BSG_BYTE *)malloc(psize * sizeof(BSG_HANDLE)); > > - if (!pdata) > > - return -1; > > - > > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > > - BSG_UINT32 i; > > - for (i = 0; i < psize; i++) { > > - BSG_PackConst(s2[i], 4, (BSG_BYTE*)(p2 + i)); > > - } > > - } > > - s += psize * sizeof(BSG_HANDLE); > > - } else { // If it's not psize handles, it's psize data. > > - if (dst) { > > - pdata = (BSG_BYTE *)malloc(sizeof(BSG_BYTE) * psize); > > - if (!pdata) > > - return -1; > > - memcpy(pdata, s, psize); > > - } > > - s += psize; > > - } > > - } > > - if (dst) > > - *(void**) d = pdata; > > - > > - d += sizeof(void*); > > - } else if (format == __FMT_PACKED) { > > - > > - // this doesn't make sense for unpacking! > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack() called with format __FMT_PACKED. " > > - "This does not make sense\n"); > > - > > - return -1; > > - } else if (format == 0) {// No flags are set. This is a structure & it should > > - // be looked up in the bsg_s_fmt[] > > - > > - const BSG_Format* x = find_format (type); > > - if (x == NULL) { > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack: cannot find type %d\n", type); > > - return -1; > > - } > > - > > - const BSG_UINT32* f = x->fields; > > - for (; *f; f++) { > > - int fsize = BSG_Unpack_private((BSG_Type) *f, s, dst ? &d:NULL); > > - if (fsize <= 0) > > - return fsize; > > - s += fsize; > > - } > > - } > > - > > - if (dst) > > - *dst = d; > > - return (s - src); > > -} > > - > > -/** > > - * Free memory associated with unpacked TCPA structure > > - * @type: TCPA structure type > > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > > - * Note: Destroy should be called on all structures created with Unpack > > - * to ensure that any allocated memory is freed > > - */ > > -static void BSG_Destroy_private(BSG_Type type, BSG_BYTE** src) { > > - BSG_BYTE* s = *src; > > - > > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > > - > > - if ((src == NULL) || (*src == NULL)) { > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with NULL src\n"); > > - return; > > - } > > - > > - if (format == __FMT_CONST || format == __FMT_DATA) > > - s += size; > > - else if (format == __FMT_SIZE || format == __FMT_HSIZE) { > > - s += size; > > - BSG_BYTE* ptr = *(BSG_BYTE**) s; > > - free(ptr); > > - s += sizeof(void*); > > - } else if (format == __FMT_PACKED) { > > - > > - // this doesn't make sense for unpacking, hence also for Destroy() > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with format __FMT_PACKED. " > > - "This does not make sense\n"); > > - > > - return; > > - } else if (format == 0) { > > - const BSG_Format* x = find_format (type); > > - if (x == NULL) { > > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy: cannot find type %d\n", type); > > - return; > > - } > > - > > - const BSG_UINT32* f = x->fields; > > - for (; *f; f++) > > - BSG_Destroy_private((BSG_Type) *f, &s); > > - } > > - > > - *src = s; > > -} > > - > > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst) > > -{ > > - const BSG_BYTE* src2 = (const BSG_BYTE*) src; > > - return BSG_Pack_private(type, &src2, dst); > > -} > > - > > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst) > > -{ > > - BSG_BYTE* dst2 = (BSG_BYTE*) dst; > > - return BSG_Unpack_private(type, src, dst ? &dst2:NULL); > > -} > > - > > -void BSG_Destroy(BSG_Type type, void* src) > > -{ > > - BSG_BYTE* src2 = (BSG_BYTE*) src; > > - BSG_Destroy_private(type, &src2); > > -} > > - > > -/** > > - * Pack a 8/16/32-bit constant into a buffer in big-endian format > > - * @val: constant value > > - * @size: constant size in bytes (1, 2, or 4) > > - * @dst: (OUT) buffer > > - */ > > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst) { > > - bsglog ("BSG: PackConst on %d of size %i into address %p\n", val, size, dst); > > - > > - switch (size) { > > - case 4: > > - dst[0] = (BSG_BYTE)((val >> 24) & 0xff); > > - dst[1] = (BSG_BYTE)((val >> 16) & 0xff); > > - dst[2] = (BSG_BYTE)((val >> 8) & 0xff); > > - dst[3] = (BSG_BYTE)(val & 0xff); > > - break; > > - case 2: > > - dst[0] = (BSG_BYTE)((val >> 8) & 0xff); > > - dst[1] = (BSG_BYTE)(val & 0xff); > > - break; > > - case 1: > > - dst[0] = (BSG_BYTE)(val & 0xff); > > - break; > > - } > > -} > > - > > -/** > > - * Unpack a 8/16/32-bit constant from a buffer in big-endian format > > - * @src: buffer > > - * @size: constant size in bytes (1, 2, or 4) > > - */ > > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size) { > > - BSG_UINT32 val = 0; > > - > > - if (src == NULL) > > - return 0; > > - > > - switch (size) { > > - case 4: > > - val = (((BSG_UINT32) src[0]) << 24 > > - | ((BSG_UINT32) src[1]) << 16 > > - | ((BSG_UINT32) src[2]) << 8 > > - | (BSG_UINT32) src[3]); > > - break; > > - case 2: > > - val = (((BSG_UINT32) src[0]) << 8 | (BSG_UINT32) src[1]); > > - break; > > - case 1: > > - val = (BSG_UINT32) src[0]; > > - break; > > - } > > - return val; > > -} > > - > > -// Pack a list of parameters. Beware not to send values, but rather you must > > -// send a pointer to your values Instead. This includes UINT32's. > > -int BSG_PackList( BSG_BYTE* dst, int ParamCount, ... ) { > > - int ParamNumber; > > - BSG_Type format; > > - BSG_BYTE* val = NULL; > > - int size=0; > > - > > - va_list paramList; > > - va_start( paramList, ParamCount ); > > - > > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > > - //Strangeness with int is because gcc wanted an int rather than a enum of ints. > > - format = (BSG_Type) va_arg( paramList, int ); > > - val = va_arg( paramList, BSG_BYTE* ); > > - size += BSG_Pack(format, val, dst == NULL ? NULL : dst + size); > > - } > > - > > - va_end (paramList); > > - > > - return size; > > -} > > - > > -// Unpack a list of parameters. > > -int BSG_UnpackList( const BSG_BYTE* src, int ParamCount, ... ) { > > - int ParamNumber = 0; > > - BSG_Type format; > > - BSG_BYTE* val = NULL; > > - int size = 0; > > - > > - va_list paramList; > > - va_start( paramList, ParamCount ); > > - > > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > > - format = (BSG_Type) va_arg( paramList, int ); > > - val = va_arg( paramList, BSG_BYTE* ); > > - > > - size += BSG_Unpack(format, src + size, val); > > - } > > - > > - va_end( paramList ); > > - > > - return size; > > -} > > - > > -// Destroy any memory allocated by calls to unpack > > -void BSG_DestroyList(int ParamCount, ... ) { > > - int ParamNumber = 0; > > - BSG_Type argType; > > - BSG_BYTE* paramValue = NULL; > > - > > - va_list paramList; > > - va_start( paramList, ParamCount ); > > - > > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > > - argType = (BSG_Type) va_arg( paramList, int ); > > - paramValue = va_arg( paramList, BSG_BYTE* ); > > - > > - BSG_Destroy(argType, paramValue); > > - } > > - > > - va_end( paramList ); > > - > > - return; > > -} > > - > > - > > -// and a tuple version > > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]) { > > - int i; > > - > > - for (i = 0; i < numParams; i++) > > - BSG_Destroy (params[i].type, params[i].addr); > > - > > - return TPM_SUCCESS; > > -} > > - > > - > > -// > > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > > -// by the caller later > > -// > > - > > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst) { > > - int size = BSG_Pack (type, src, NULL); > > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > > - if (dest == NULL) > > - return -1; > > - > > - size = BSG_Pack(type, src, dest); > > - *o_dst = dest; > > - return size; > > -} > > - > > - > > - > > -int BSG_PackListMalloc(BSG_BYTE** outBuffer, int ParamCount, ... ) { > > - va_list args; > > - int size; > > - > > - va_start (args, ParamCount); > > - size = BSG_PackList (NULL, ParamCount, args); > > - va_end (args); > > - > > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > > - if (dest == NULL) > > - return -1; > > - > > - va_start (args, ParamCount); > > - size = BSG_PackList (dest, ParamCount, args); > > - va_end (args); > > - > > - *outBuffer = dest; > > - return size; > > -} > > diff --git a/tools/vtpm_manager/util/bsg.h b/tools/vtpm_manager/util/bsg.h > > deleted file mode 100644 > > index 0896812..0000000 > > --- a/tools/vtpm_manager/util/bsg.h > > +++ /dev/null > > @@ -1,166 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// bsg.h > > -// > > -// This file contains API's for the TPM Byte Stream functions > > -// > > -// ================================================================== > > - > > -#ifndef __BSG_H__ > > -#define __BSG_H__ > > - > > -#include > > -#include "buffer.h" > > - > > -typedef unsigned int BSG_UINT32; > > -typedef unsigned char BSG_BYTE; > > - > > -// forward decl > > -struct pack_const_tuple_t; > > - > > -struct pack_tuple_t; > > - > > - > > -/** > > - * Byte stream generator > > - */ > > -// this has to be manually kept in sync with the > > -// s_fmt array!! > > -// but now we have a self-check function which can make sure things are well > > -// (if used!) > > -typedef enum BSG_Type > > -{ > > - BSG_TYPE_FIRST = 1, > > - BSG_TYPE_UINT32 = 1, // start at 1 so that Type 0 only serves as an > > - // unused/special value > > - BSG_TYPE_UINT16, > > - BSG_TYPE_BYTE, > > - BSG_TYPE_BOOL, > > - BSG_TPM_SIZE32_DATA, // a 32 bit unsigned size, followed by > > - // a pointer to that much data. can pass a > > - // struct pack_buf_t as the param > > - BSG_TPM_TAG, > > - BSG_TPM_HANDLE, > > - BSG_TPM_RESULT, > > - BSG_TPM_RESOURCE_TYPE, > > - BSG_TPM_COMMAND_CODE, > > - BSG_TPM_AUTH_DATA_USAGE, > > - BSG_TPM_ALGORITHM_ID, > > - BSG_TPM_PROTOCOL_ID, > > - BSG_TPM_KEY_USAGE, > > - BSG_TPM_ENC_SCHEME, > > - BSG_TPM_SIG_SCHEME, > > - BSG_TPM_MIGRATE_SCHEME, > > - BSG_TPM_KEY_FLAGS, > > - BSG_TPM_AUTHDATA, > > - BSG_TPM_SECRET, > > - BSG_TPM_ENCAUTH, > > - BSG_TPM_PAYLOAD_TYPE, > > - > > - BSG_TPM_VERSION, > > - BSG_TPM_DIGEST, > > - BSG_TPM_COMPOSITE_HASH, > > - BSG_TPM_CHOSENID_HASH, > > - BSG_TPM_NONCE, > > - BSG_TPM_KEY_HANDLE, > > - BSG_TPM_KEY_HANDLE_LIST, > > - BSG_TPM_KEY_PARMS, > > - BSG_TPM_RSA_KEY_PARMS, > > - BSG_TPM_STORE_PUBKEY, > > - BSG_TPM_PUBKEY, > > - BSG_TPM_KEY, > > - > > - BSG_TPM_MIGRATIONKEYAUTH, > > - BSG_TCPA_AUDIT_EVENT, > > - BSG_TCPA_EVENT_CERT, > > - BSG_TPM_PCR_SELECTION, > > - BSG_TPM_PCR_COMPOSITE, > > - BSG_TPM_PCR_INFO, > > - BSG_TPM_STORED_DATA, > > - BSG_TPM_SYMMETRIC_KEY, > > - BSG_TPM_STORE_PRIVKEY, > > - BSG_TPM_STORE_ASYMKEY, > > - BSG_TPM_MIGRATE_ASYMKEY, > > - BSG_TPM_QUOTE_INFO, > > - BSG_TPM_IDENTITY_CONTENTS, > > - BSG_TPM_PCRVALUE, > > - BSG_TCPA_PCR_FLAGS, > > - BSG_TCS_AUTH, > > - > > - // this is the BSG_TPM_KEY struct without the encData field > > - BSG_TPM_KEY_NONSENSITIVE, > > - > > - BSG_PACKED, > > - > > - BSG_TYPE_MAX > > -} BSG_Type; > > - > > -struct pack_const_tuple_t { > > - BSG_Type type; > > - const void * addr; > > -}; > > - > > - > > -typedef struct pack_tuple_t { > > - BSG_Type type; > > - void * addr; > > -} pack_tuple_t; > > - > > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst); > > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst); > > -void BSG_Destroy(BSG_Type type, void* src); > > - > > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > > -// by the caller later. returns size of allocated buffer, or -1 in case > > -// allocation failed > > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst); > > -int BSG_PackListMalloc (BSG_BYTE** outBuffer, int ParamCount, ... ); > > - > > -// a va_list version of PackList > > -int BSG_PackList(BSG_BYTE* outBuffer, int ParamCount, ... ); > > -int BSG_UnpackList(const BSG_BYTE* inBuffer, int ParamCount, ... ); > > -void BSG_DestroyList(int ParamCount, ... ); > > - > > -// wrapper of PackList which uses a buffer_t > > -TPM_RESULT BSG_PackListBuf (buffer_t * o_buf, int ParamCount, ...); > > - > > -// and a tuple version > > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]); > > - > > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst); > > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size); > > - > > -BOOL BSG_static_selfcheck (); > > - > > -#endif > > diff --git a/tools/vtpm_manager/util/buffer.c b/tools/vtpm_manager/util/buffer.c > > deleted file mode 100644 > > index df48bc2..0000000 > > --- a/tools/vtpm_manager/util/buffer.c > > +++ /dev/null > > @@ -1,226 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > - > > -#include > > -#include > > -#include > > -#include > > -#include > > - > > -#include "tcg.h" > > -#include "bsg.h" > > -#include "buffer.h" > > - > > -static TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize); > > - > > -// > > -// buffer functions! > > -// > > - > > -TPM_RESULT buffer_init (buffer_t * buf, tpm_size_t initsize, const BYTE* initval) { > > - if (initsize == 0) { > > - memset(buf, 0, sizeof(*buf)); > > - return TPM_SUCCESS; > > - } > > - > > - > > - buf->bytes = (BYTE*) malloc (initsize); > > - if (buf->bytes == NULL) > > - return TPM_RESOURCES; > > - > > - buf->size = initsize; > > - buf->alloc_size = initsize; > > - > > - if (initval) > > - memcpy (buf->bytes, initval, initsize); > > - > > - buf->is_owner = TRUE; > > - > > - return TPM_SUCCESS; > > -} > > - > > -TPM_RESULT buffer_init_convert (buffer_t * buf, tpm_size_t initsize, BYTE* initval) { > > - > > - buf->size = initsize; > > - buf->alloc_size = initsize; > > - buf->bytes = initval; > > - > > - buf->is_owner = TRUE; > > - > > - return TPM_SUCCESS; > > -} > > - > > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src) { > > - TPM_RESULT status = buffer_init (buf, src->size, src->bytes); > > - buf->is_owner = TRUE; > > - > > - return status; > > -} > > - > > - > > - > > -// make an alias to a constant array > > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val) { > > - // TODO: try to enforce the const things somehow! > > - buf->bytes = (BYTE*) val; > > - buf->size = size; > > - buf->alloc_size = 0; // this field is now unneeded > > - > > - buf->is_owner = FALSE; > > - > > - return TPM_SUCCESS; > > -} > > - > > -// make an alias into buf, with given offset and length > > -// if len = 0, make the alias go to the end of buf > > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > > - tpm_size_t offset, tpm_size_t len) { > > - if (offset + len > b->size) { > > - return TPM_NOSPACE; > > - } > > - > > - buf->bytes = b->bytes + offset; > > - buf->size = len > 0 ? len : b->size - offset; > > - > > - //VS/ buf->alloc_size = 0; > > - if (len ==0) > > - buf->alloc_size = b->alloc_size - offset; > > - else > > - buf->alloc_size = MIN(b->alloc_size - offset, len); > > - > > - > > - buf->is_owner = FALSE; > > - > > - return TPM_SUCCESS; > > -} > > - > > -// make an alias buffer_t into bytestream, with given length > > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, tpm_size_t size, BYTE* val) { > > - > > - buf->size = size; > > - buf->alloc_size = size; > > - buf->bytes = val; > > - > > - buf->is_owner = FALSE; > > - > > - return TPM_SUCCESS; > > -} > > - > > - > > - > > -// copy into the start of dest > > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src) > > -{ > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - if (dest->alloc_size < src->size) { > > - TPMTRYRETURN( buffer_priv_realloc (dest, src->size) ); > > - } > > - > > - memcpy (dest->bytes, src->bytes, src->size); > > - dest->size = src->size; > > - > > - //VS/ dest->is_owner = TRUE; > > - > > - abort_egress: > > - > > - return status; > > -} > > - > > - > > - > > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b) { > > - return (a->size == b->size && memcmp (a->bytes, b->bytes, a->size) == 0); > > -} > > - > > - > > -void buffer_memset (buffer_t * buf, BYTE b) { > > - memset (buf->bytes, b, buf->size); > > -} > > - > > - > > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes) { > > - TPM_RESULT status = TPM_SUCCESS; > > - > > - if (buf->alloc_size < buf->size + len) { > > - TPMTRYRETURN( buffer_priv_realloc (buf, buf->size + len) ); > > - } > > - > > - memcpy (buf->bytes + buf->size, bytes, len); > > - > > - buf->size += len; > > - > > - goto egress; > > - > > - abort_egress: > > - > > - egress: > > - > > - return status; > > -} > > - > > -tpm_size_t buffer_len (const buffer_t* buf) { > > - return buf->size; > > -} > > - > > -TPM_RESULT buffer_free (buffer_t * buf) { > > - if (buf && buf->is_owner && buf->bytes != NULL) { > > - free (buf->bytes); > > - buf->bytes = NULL; > > - buf->size = buf->alloc_size = 0; > > - > > - } > > - > > - return TPM_SUCCESS; > > -} > > - > > -TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize) { > > - > > - // we want to realloc to twice the size, or the new size, whichever > > - // bigger > > - > > - BYTE * tmpbuf = NULL; > > - > > - newsize = MAX (buf->alloc_size * 2, newsize); > > - > > - tmpbuf = (BYTE*) realloc (buf->bytes, newsize); > > - if (tmpbuf == NULL) > > - return TPM_SIZE; > > - > > - > > - buf->bytes = tmpbuf; > > - buf->alloc_size = newsize; > > - > > - return TPM_SUCCESS; > > -} > > diff --git a/tools/vtpm_manager/util/buffer.h b/tools/vtpm_manager/util/buffer.h > > deleted file mode 100644 > > index d8a9abc..0000000 > > --- a/tools/vtpm_manager/util/buffer.h > > +++ /dev/null > > @@ -1,95 +0,0 @@ > > -// =================================================================== > > -// > > -// 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_BUFFER_H__ > > -#define __VTPM_BUFFER_H__ > > - > > -#include // for pointer NULL > > -#include "tcg.h" > > - > > -typedef UINT32 tpm_size_t; > > - > > -// first version, probably will be expanded... > > - > > -#define NULL_BUF {0,0,0,0} > > - > > -typedef struct { > > - // private!! > > - tpm_size_t size, alloc_size; > > - BYTE * bytes; > > - > > - BOOL is_owner; // do we own this buffer, and need to free it? > > -} buffer_t; > > - > > -// allocate the buffer if initsize > 0, copying over initval if provided > > -TPM_RESULT buffer_init (buffer_t * buf, > > - tpm_size_t initsize, > > - const BYTE* initval); > > - > > -// Create a new buffer from a BYTE *. Use buffer_free to destroy original BYTE * > > -TPM_RESULT buffer_init_convert (buffer_t * buf, > > - tpm_size_t initsize, > > - BYTE* initval); > > - > > -// make an alias to a constant array, no copying > > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val); > > - > > -// make an alias into buf, with given offset and length > > -// if len = 0, make the alias go to the end of buf > > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > > - tpm_size_t offset, tpm_size_t); > > - > > -// make an alias buffer into a bytestream > > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, > > - tpm_size_t size, BYTE* val); > > - > > -// "copy constructor" > > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src); > > - > > - > > -// copy into the start of a > > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src); > > - > > -// are they equal? > > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b); > > - > > -// set the buffer to a constant byte > > -void buffer_memset (buffer_t * buf, BYTE b); > > - > > -tpm_size_t buffer_len (const buffer_t* buf); > > - > > -TPM_RESULT buffer_free (buffer_t * buf); > > - > > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes); > > - > > -#endif // _TOOLS_H_ > > diff --git a/tools/vtpm_manager/util/hashtable.c b/tools/vtpm_manager/util/hashtable.c > > deleted file mode 100644 > > index aff0e2b..0000000 > > --- a/tools/vtpm_manager/util/hashtable.c > > +++ /dev/null > > @@ -1,316 +0,0 @@ > > -/* > > - * Copyright (c) 2005, Intel Corp > > - * Copyright (c) 2002, Christopher Clark > > - * 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 the original author; nor the names of any 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. > > -*/ > > - > > -/* > > - * There are duplicates of this code in: > > - * - tools/xenstore/hashtable.c > > - * - tools/blktap2/drivers/hashtable.c > > - */ > > - > > -#include "hashtable.h" > > -#include "hashtable_private.h" > > -#include > > -#include > > -#include > > -#include > > - > > -/* > > -Credit for primes table: Aaron Krowne > > - http://br.endernet.org/~akrowne/ > > - http://planetmath.org/encyclopedia/GoodHashTablePrimes.html > > -*/ > > -static const unsigned int primes[] = { > > -53, 97, 193, 389, > > -769, 1543, 3079, 6151, > > -12289, 24593, 49157, 98317, > > -196613, 393241, 786433, 1572869, > > -3145739, 6291469, 12582917, 25165843, > > -50331653, 100663319, 201326611, 402653189, > > -805306457, 1610612741 > > -}; > > -const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]); > > -const float max_load_factor = 0.65; > > - > > -/*****************************************************************************/ > > -struct hashtable * > > -create_hashtable(unsigned int minsize, > > - unsigned int (*hashf) (void*), > > - int (*eqf) (void*,void*)) > > -{ > > - struct hashtable *h; > > - unsigned int pindex, size = primes[0]; > > - /* Check requested hashtable isn't too large */ > > - if (minsize > (1u << 30)) return NULL; > > - /* Enforce size as prime */ > > - for (pindex=0; pindex < prime_table_length; pindex++) { > > - if (primes[pindex] > minsize) { size = primes[pindex]; break; } > > - } > > - h = (struct hashtable *)malloc(sizeof(struct hashtable)); > > - if (NULL == h) return NULL; /*oom*/ > > - h->table = (struct entry **)malloc(sizeof(struct entry*) * size); > > - if (NULL == h->table) { free(h); return NULL; } /*oom*/ > > - memset(h->table, 0, size * sizeof(struct entry *)); > > - h->tablelength = size; > > - h->primeindex = pindex; > > - h->entrycount = 0; > > - h->hashfn = hashf; > > - h->eqfn = eqf; > > - h->loadlimit = (unsigned int) ceil(size * max_load_factor); > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_init(&h->mutex, NULL); > > -#endif > > - return h; > > -} > > - > > -/*****************************************************************************/ > > -unsigned int > > -hash(struct hashtable *h, void *k) > > -{ > > - unsigned int i = h->hashfn(k); > > - i += ~(i << 9); > > - i ^= ((i >> 14) | (i << 18)); /* >>> */ > > - i += (i << 4); > > - i ^= ((i >> 10) | (i << 22)); /* >>> */ > > - return i; > > -} > > - > > -/*****************************************************************************/ > > -static int > > -hashtable_expand(struct hashtable *h) > > -{ > > - /* Double the size of the table to accomodate more entries */ > > - struct entry **newtable; > > - struct entry *e; > > - struct entry **pE; > > - unsigned int newsize, i, index; > > - /* Check we're not hitting max capacity */ > > - if (h->primeindex == (prime_table_length - 1)) return 0; > > - newsize = primes[++(h->primeindex)]; > > - > > - newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize); > > - if (NULL != newtable) > > - { > > - memset(newtable, 0, newsize * sizeof(struct entry *)); > > - /* This algorithm is not 'stable'. ie. it reverses the list > > - * when it transfers entries between the tables */ > > - for (i = 0; i < h->tablelength; i++) { > > - while (NULL != (e = h->table[i])) { > > - h->table[i] = e->next; > > - index = indexFor(newsize,e->h); > > - e->next = newtable[index]; > > - newtable[index] = e; > > - } > > - } > > - free(h->table); > > - h->table = newtable; > > - } > > - /* Plan B: realloc instead */ > > - else > > - { > > - newtable = (struct entry **) > > - realloc(h->table, newsize * sizeof(struct entry *)); > > - if (NULL == newtable) { (h->primeindex)--; return 0; } > > - h->table = newtable; > > - memset(newtable[h->tablelength], 0, newsize - h->tablelength); > > - for (i = 0; i < h->tablelength; i++) { > > - for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) { > > - index = indexFor(newsize,e->h); > > - if (index == i) > > - { > > - pE = &(e->next); > > - } > > - else > > - { > > - *pE = e->next; > > - e->next = newtable[index]; > > - newtable[index] = e; > > - } > > - } > > - } > > - } > > - h->tablelength = newsize; > > - h->loadlimit = (unsigned int) ceil(newsize * max_load_factor); > > - return -1; > > -} > > - > > -/*****************************************************************************/ > > -unsigned int > > -hashtable_count(struct hashtable *h) > > -{ > > - unsigned int count; > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - count = h->entrycount; > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return count; > > -} > > - > > -/*****************************************************************************/ > > -int > > -hashtable_insert(struct hashtable *h, void *k, void *v) > > -{ > > - /* This method allows duplicate keys - but they shouldn't be used */ > > - unsigned int index; > > - struct entry *e; > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - if (++(h->entrycount) > h->loadlimit) > > - { > > - /* Ignore the return value. If expand fails, we should > > - * still try cramming just this value into the existing table > > - * -- we may not have memory for a larger table, but one more > > - * element may be ok. Next time we insert, we'll try expanding again.*/ > > - hashtable_expand(h); > > - } > > - e = (struct entry *)malloc(sizeof(struct entry)); > > - if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ > > - e->h = hash(h,k); > > - index = indexFor(h->tablelength,e->h); > > - e->k = k; > > - e->v = v; > > - e->next = h->table[index]; > > - h->table[index] = e; > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return -1; > > -} > > - > > -/*****************************************************************************/ > > -void * /* returns value associated with key */ > > -hashtable_search(struct hashtable *h, void *k) > > -{ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - struct entry *e; > > - unsigned int hashvalue, index; > > - hashvalue = hash(h,k); > > - index = indexFor(h->tablelength,hashvalue); > > - e = h->table[index]; > > - while (NULL != e) > > - { > > - /* Check hash value to short circuit heavier comparison */ > > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) { > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return e->v; > > - } > > - e = e->next; > > - } > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return NULL; > > -} > > - > > -/*****************************************************************************/ > > -void * /* returns value associated with key */ > > -hashtable_remove(struct hashtable *h, void *k) > > -{ > > - /* TODO: consider compacting the table when the load factor drops enough, > > - * or provide a 'compact' method. */ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - struct entry *e; > > - struct entry **pE; > > - void *v; > > - unsigned int hashvalue, index; > > - > > - hashvalue = hash(h,k); > > - index = indexFor(h->tablelength,hash(h,k)); > > - pE = &(h->table[index]); > > - e = *pE; > > - while (NULL != e) > > - { > > - /* Check hash value to short circuit heavier comparison */ > > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > > - { > > - *pE = e->next; > > - h->entrycount--; > > - v = e->v; > > - freekey(e->k); > > - free(e); > > - return v; > > - } > > - pE = &(e->next); > > - e = e->next; > > - } > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return NULL; > > -} > > - > > -/*****************************************************************************/ > > -/* destroy */ > > -void > > -hashtable_destroy(struct hashtable *h, int free_values) > > -{ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - unsigned int i; > > - struct entry *e, *f; > > - struct entry **table = h->table; > > - if (free_values) > > - { > > - for (i = 0; i < h->tablelength; i++) > > - { > > - e = table[i]; > > - while (NULL != e) > > - { f = e; e = e->next; freekey(f->k); free(f->v); free(f); } > > - } > > - } > > - else > > - { > > - for (i = 0; i < h->tablelength; i++) > > - { > > - e = table[i]; > > - while (NULL != e) > > - { f = e; e = e->next; freekey(f->k); free(f); } > > - } > > - } > > - free(h->table); > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_destroy(&h->mutex); > > -#endif > > - free(h); > > -} > > diff --git a/tools/vtpm_manager/util/hashtable.h b/tools/vtpm_manager/util/hashtable.h > > deleted file mode 100644 > > index dedc60a..0000000 > > --- a/tools/vtpm_manager/util/hashtable.h > > +++ /dev/null > > @@ -1,204 +0,0 @@ > > -/* > > - * Copyright (c) 2005, Intel Corp > > - * Copyright (c) 2002, Christopher Clark > > - * 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 the original author; nor the names of any 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. > > -*/ > > - > > -/* > > - * There are duplicates of this code in: > > - * - tools/xenstore/hashtable.h > > - * - tools/blktap2/drivers/hashtable.h > > - */ > > - > > -#ifndef __HASHTABLE_CWC22_H__ > > -#define __HASHTABLE_CWC22_H__ > > - > > -struct hashtable; > > - > > -/* Example of use: > > - * > > - * struct hashtable *h; > > - * struct some_key *k; > > - * struct some_value *v; > > - * > > - * static unsigned int hash_from_key_fn( void *k ); > > - * static int keys_equal_fn ( void *key1, void *key2 ); > > - * > > - * h = create_hashtable(16, hash_from_key_fn, keys_equal_fn); > > - * k = (struct some_key *) malloc(sizeof(struct some_key)); > > - * v = (struct some_value *) malloc(sizeof(struct some_value)); > > - * > > - * (initialise k and v to suitable values) > > - * > > - * if (! hashtable_insert(h,k,v) ) > > - * { exit(-1); } > > - * > > - * if (NULL == (found = hashtable_search(h,k) )) > > - * { printf("not found!"); } > > - * > > - * if (NULL == (found = hashtable_remove(h,k) )) > > - * { printf("Not found\n"); } > > - * > > - */ > > - > > -/* Macros may be used to define type-safe(r) hashtable access functions, with > > - * methods specialized to take known key and value types as parameters. > > - * > > - * Example: > > - * > > - * Insert this at the start of your file: > > - * > > - * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value); > > - * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value); > > - * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value); > > - * > > - * This defines the functions 'insert_some', 'search_some' and 'remove_some'. > > - * These operate just like hashtable_insert etc., with the same parameters, > > - * but their function signatures have 'struct some_key *' rather than > > - * 'void *', and hence can generate compile time errors if your program is > > - * supplying incorrect data as a key (and similarly for value). > > - * > > - * Note that the hash and key equality functions passed to create_hashtable > > - * still take 'void *' parameters instead of 'some key *'. This shouldn't be > > - * a difficult issue as they're only defined and passed once, and the other > > - * functions will ensure that only valid keys are supplied to them. > > - * > > - * The cost for this checking is increased code size and runtime overhead > > - * - if performance is important, it may be worth switching back to the > > - * unsafe methods once your program has been debugged with the safe methods. > > - * This just requires switching to some simple alternative defines - eg: > > - * #define insert_some hashtable_insert > > - * > > - */ > > - > > -/***************************************************************************** > > - * create_hashtable > > - > > - * @name create_hashtable > > - * @param minsize minimum initial size of hashtable > > - * @param hashfunction function for hashing keys > > - * @param key_eq_fn function for determining key equality > > - * @return newly created hashtable or NULL on failure > > - */ > > - > > -struct hashtable * > > -create_hashtable(unsigned int minsize, > > - unsigned int (*hashfunction) (void*), > > - int (*key_eq_fn) (void*,void*)); > > - > > -/***************************************************************************** > > - * hashtable_insert > > - > > - * @name hashtable_insert > > - * @param h the hashtable to insert into > > - * @param k the key - hashtable claims ownership and will free on removal > > - * @param v the value - does not claim ownership > > - * @return non-zero for successful insertion > > - * > > - * This function will cause the table to expand if the insertion would take > > - * the ratio of entries to table size over the maximum load factor. > > - * > > - * This function does not check for repeated insertions with a duplicate key. > > - * The value returned when using a duplicate key is undefined -- when > > - * the hashtable changes size, the order of retrieval of duplicate key > > - * entries is reversed. > > - * If in doubt, remove before insert. > > - */ > > - > > -int > > -hashtable_insert(struct hashtable *h, void *k, void *v); > > - > > -#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \ > > -int fnname (struct hashtable *h, keytype *k, valuetype *v) \ > > -{ \ > > - return hashtable_insert(h,k,v); \ > > -} > > - > > -/***************************************************************************** > > - * hashtable_search > > - > > - * @name hashtable_search > > - * @param h the hashtable to search > > - * @param k the key to search for - does not claim ownership > > - * @return the value associated with the key, or NULL if none found > > - */ > > - > > -void * > > -hashtable_search(struct hashtable *h, void *k); > > - > > -#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \ > > -valuetype * fnname (struct hashtable *h, keytype *k) \ > > -{ \ > > - return (valuetype *) (hashtable_search(h,k)); \ > > -} > > - > > -/***************************************************************************** > > - * hashtable_remove > > - > > - * @name hashtable_remove > > - * @param h the hashtable to remove the item from > > - * @param k the key to search for - does not claim ownership > > - * @return the value associated with the key, or NULL if none found > > - */ > > - > > -void * /* returns value */ > > -hashtable_remove(struct hashtable *h, void *k); > > - > > -#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \ > > -valuetype * fnname (struct hashtable *h, keytype *k) \ > > -{ \ > > - return (valuetype *) (hashtable_remove(h,k)); \ > > -} > > - > > - > > -/***************************************************************************** > > - * hashtable_count > > - > > - * @name hashtable_count > > - * @param h the hashtable > > - * @return the number of items stored in the hashtable > > - */ > > -unsigned int > > -hashtable_count(struct hashtable *h); > > - > > - > > -/***************************************************************************** > > - * hashtable_destroy > > - > > - * @name hashtable_destroy > > - * @param h the hashtable > > - * @param free_values whether to call 'free' on the remaining values > > - */ > > - > > -void > > -hashtable_destroy(struct hashtable *h, int free_values); > > - > > -#endif /* __HASHTABLE_CWC22_H__ */ > > diff --git a/tools/vtpm_manager/util/hashtable_itr.c b/tools/vtpm_manager/util/hashtable_itr.c > > deleted file mode 100644 > > index dcf42c8..0000000 > > --- a/tools/vtpm_manager/util/hashtable_itr.c > > +++ /dev/null > > @@ -1,236 +0,0 @@ > > -/* > > - * Copyright (c) 2005, Intel Corp > > - * Copyright (c) 2002, Christopher Clark > > - * 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 the original author; nor the names of any 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. > > -*/ > > - > > -/* > > - * There are duplicates of this code in: > > - * - tools/blktap2/drivers/hashtable_itr.c > > - */ > > - > > -#include "hashtable.h" > > -#include "hashtable_private.h" > > -#include "hashtable_itr.h" > > -#include /* defines NULL */ > > - > > -/*****************************************************************************/ > > -/* hashtable_iterator - iterator constructor */ > > - > > -struct hashtable_itr * > > -hashtable_iterator(struct hashtable *h) > > -{ > > - unsigned int i, tablelength; > > - struct hashtable_itr *itr = (struct hashtable_itr *) > > - malloc(sizeof(struct hashtable_itr)); > > - if (NULL == itr) return NULL; > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - itr->h = h; > > - itr->e = NULL; > > - itr->parent = NULL; > > - tablelength = h->tablelength; > > - itr->index = tablelength; > > - if (0 == h->entrycount) { > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return itr; > > - } > > - > > - for (i = 0; i < tablelength; i++) > > - { > > - if (NULL != h->table[i]) > > - { > > - itr->e = h->table[i]; > > - itr->index = i; > > - break; > > - } > > - } > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return itr; > > -} > > - > > -/*****************************************************************************/ > > -/* key - return the key of the (key,value) pair at the current position */ > > -/* value - return the value of the (key,value) pair at the current position */ > > - > > -void * > > -hashtable_iterator_key(struct hashtable_itr *i) > > -{ return i->e->k; } > > - > > -void * > > -hashtable_iterator_value(struct hashtable_itr *i) > > -{ return i->e->v; } > > - > > -/*****************************************************************************/ > > -/* advance - advance the iterator to the next element > > - * returns zero if advanced to end of table */ > > - > > -int > > -hashtable_iterator_advance(struct hashtable_itr *itr) > > -{ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&itr->h->mutex); > > -#endif > > - unsigned int j,tablelength; > > - struct entry **table; > > - struct entry *next; > > - int ret; > > - if (NULL == itr->e) { /* stupidity check */ > > - ret = 0; > > - goto egress; > > - } > > - > > - next = itr->e->next; > > - if (NULL != next) > > - { > > - itr->parent = itr->e; > > - itr->e = next; > > - ret = -1; > > - goto egress; > > - } > > - > > - tablelength = itr->h->tablelength; > > - itr->parent = NULL; > > - if (tablelength <= (j = ++(itr->index))) > > - { > > - itr->e = NULL; > > - ret = 0; > > - goto egress; > > - } > > - table = itr->h->table; > > - while (NULL == (next = table[j])) > > - { > > - if (++j >= tablelength) > > - { > > - itr->index = tablelength; > > - itr->e = NULL; > > - ret = 0; > > - goto egress; > > - } > > - } > > - itr->index = j; > > - itr->e = next; > > - ret = -1; > > - > > - egress: > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&itr->h->mutex); > > -#endif > > - return ret; > > -} > > - > > -/*****************************************************************************/ > > -/* remove - remove the entry at the current iterator position > > - * and advance the iterator, if there is a successive > > - * element. > > - * If you want the value, read it before you remove: > > - * beware memory leaks if you don't. > > - * Returns zero if end of iteration. */ > > - > > -int > > -hashtable_iterator_remove(struct hashtable_itr *itr) > > -{ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&itr->h->mutex); > > -#endif > > - struct entry *remember_e, *remember_parent; > > - int ret; > > - > > - /* Do the removal */ > > - if (NULL == (itr->parent)) > > - { > > - /* element is head of a chain */ > > - itr->h->table[itr->index] = itr->e->next; > > - } else { > > - /* element is mid-chain */ > > - itr->parent->next = itr->e->next; > > - } > > - /* itr->e is now outside the hashtable */ > > - remember_e = itr->e; > > - itr->h->entrycount--; > > - freekey(remember_e->k); > > - > > - /* Advance the iterator, correcting the parent */ > > - remember_parent = itr->parent; > > - ret = hashtable_iterator_advance(itr); > > - if (itr->parent == remember_e) { itr->parent = remember_parent; } > > - free(remember_e); > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&itr->h->mutex); > > -#endif > > - return ret; > > -} > > - > > -/*****************************************************************************/ > > -int /* returns zero if not found */ > > -hashtable_iterator_search(struct hashtable_itr *itr, > > - struct hashtable *h, void *k) > > -{ > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_lock(&h->mutex); > > -#endif > > - struct entry *e, *parent; > > - unsigned int hashvalue, index; > > - int ret; > > - > > - hashvalue = hash(h,k); > > - index = indexFor(h->tablelength,hashvalue); > > - > > - e = h->table[index]; > > - parent = NULL; > > - while (NULL != e) > > - { > > - /* Check hash value to short circuit heavier comparison */ > > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > > - { > > - itr->index = index; > > - itr->e = e; > > - itr->parent = parent; > > - itr->h = h; > > - ret= -1; > > - goto egress; > > - } > > - parent = e; > > - e = e->next; > > - } > > - ret = 0; > > - > > -egress: > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_unlock(&h->mutex); > > -#endif > > - return ret; > > -} > > diff --git a/tools/vtpm_manager/util/hashtable_itr.h b/tools/vtpm_manager/util/hashtable_itr.h > > deleted file mode 100644 > > index 35654e0..0000000 > > --- a/tools/vtpm_manager/util/hashtable_itr.h > > +++ /dev/null > > @@ -1,109 +0,0 @@ > > -/* > > - * Copyright (c) 2005, Intel Corp > > - * Copyright (c) 2002, Christopher Clark > > - * 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 the original author; nor the names of any 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. > > -*/ > > - > > -/* > > - * There are duplicates of this code in: > > - * - tools/blktap2/drivers/hashtable_itr.h > > - */ > > - > > - > > -#ifndef __HASHTABLE_ITR_CWC22__ > > -#define __HASHTABLE_ITR_CWC22__ > > -#include "hashtable.h" > > -#include "hashtable_private.h" /* needed to enable inlining */ > > - > > -/*****************************************************************************/ > > -/* This struct is only concrete here to allow the inlining of two of the > > - * accessor functions. */ > > -struct hashtable_itr > > -{ > > - struct hashtable *h; > > - struct entry *e; > > - struct entry *parent; > > - unsigned int index; > > -}; > > - > > - > > -/*****************************************************************************/ > > -/* hashtable_iterator > > - */ > > - > > -struct hashtable_itr * > > -hashtable_iterator(struct hashtable *h); > > - > > -/*****************************************************************************/ > > -/* hashtable_iterator_key > > - * - return the value of the (key,value) pair at the current position */ > > - > > -void *hashtable_iterator_key(struct hashtable_itr *i); > > - > > -/*****************************************************************************/ > > -/* value - return the value of the (key,value) pair at the current position */ > > - > > -void *hashtable_iterator_value(struct hashtable_itr *i); > > - > > -/*****************************************************************************/ > > -/* advance - advance the iterator to the next element > > - * returns zero if advanced to end of table */ > > - > > -int > > -hashtable_iterator_advance(struct hashtable_itr *itr); > > - > > -/*****************************************************************************/ > > -/* remove - remove current element and advance the iterator to the next element > > - * NB: if you need the value to free it, read it before > > - * removing. ie: beware memory leaks! > > - * returns zero if advanced to end of table */ > > - > > -int > > -hashtable_iterator_remove(struct hashtable_itr *itr); > > - > > -/*****************************************************************************/ > > -/* search - overwrite the supplied iterator, to point to the entry > > - * matching the supplied key. > > - h points to the hashtable to be searched. > > - * returns zero if not found. */ > > -int > > -hashtable_iterator_search(struct hashtable_itr *itr, > > - struct hashtable *h, void *k); > > - > > -#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \ > > -int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \ > > -{ \ > > - return (hashtable_iterator_search(i,h,k)); \ > > -} > > - > > - > > - > > -#endif /* __HASHTABLE_ITR_CWC22__*/ > > diff --git a/tools/vtpm_manager/util/hashtable_private.h b/tools/vtpm_manager/util/hashtable_private.h > > deleted file mode 100644 > > index d87a7f9..0000000 > > --- a/tools/vtpm_manager/util/hashtable_private.h > > +++ /dev/null > > @@ -1,96 +0,0 @@ > > -/* > > - * Copyright (c) 2005, Intel Corp > > - * Copyright (c) 2002, Christopher Clark > > - * 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 the original author; nor the names of any 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. > > -*/ > > - > > -/* > > - * There are duplicates of this code in: > > - * - tools/xenstore/hashtable_private.h > > - * - tools/blktap2/drivers/hashtable_private.h > > - */ > > - > > -#ifndef __HASHTABLE_PRIVATE_CWC22_H__ > > -#define __HASHTABLE_PRIVATE_CWC22_H__ > > - > > -#include "hashtable.h" > > -#ifdef HASHTABLE_THREADED > > -#include > > -#endif > > - > > -/*****************************************************************************/ > > -struct entry > > -{ > > - void *k, *v; > > - unsigned int h; > > - struct entry *next; > > -}; > > - > > -struct hashtable { > > - unsigned int tablelength; > > - struct entry **table; > > - unsigned int entrycount; > > - unsigned int loadlimit; > > - unsigned int primeindex; > > - unsigned int (*hashfn) (void *k); > > - int (*eqfn) (void *k1, void *k2); > > -#ifdef HASHTABLE_THREADED > > - pthread_mutex_t mutex; > > -#endif > > -}; > > - > > -/*****************************************************************************/ > > -unsigned int > > -hash(struct hashtable *h, void *k); > > - > > -/*****************************************************************************/ > > -/* indexFor */ > > -static inline unsigned int > > -indexFor(unsigned int tablelength, unsigned int hashvalue) { > > - return (hashvalue % tablelength); > > -}; > > - > > -/* Only works if tablelength == 2^N */ > > -/*static inline unsigned int > > -indexFor(unsigned int tablelength, unsigned int hashvalue) > > -{ > > - return (hashvalue & (tablelength - 1u)); > > -} > > -*/ > > - > > -/*****************************************************************************/ > > -#define freekey(X) free(X) > > -/*define freekey(X) ; */ > > - > > - > > -/*****************************************************************************/ > > - > > -#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/ > > diff --git a/tools/vtpm_manager/util/log.c b/tools/vtpm_manager/util/log.c > > deleted file mode 100644 > > index 75fe91a..0000000 > > --- a/tools/vtpm_manager/util/log.c > > +++ /dev/null > > @@ -1,142 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > - > > -#include > > -#include > > -#include > > - > > -#include "buffer.h" > > -#include "tcg.h" > > - > > -// Helper code for the consts, eg. to produce messages for error codes. > > - > > -typedef struct error_code_entry_t { > > - TPM_RESULT code; > > - char * code_name; > > - char * msg; > > -} error_code_entry_t; > > - > > -static const error_code_entry_t error_msgs [] = { > > - { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, > > - { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, > > - { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, > > - { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, > > - { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, > > - { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, > > - { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, > > - { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, > > - { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, > > - { TPM_FAIL, "TPM_FAIL", "The operation failed" }, > > - { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, > > - { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, > > - { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, > > - { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, > > - { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, > > - { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, > > - { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, > > - { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, > > - { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, > > - { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, > > - { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, > > - { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, > > - { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, > > - { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, > > - { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, > > - { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, > > - { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, > > - { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, > > - { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, > > - { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, > > - { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, > > - { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, > > - { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, > > - { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, > > - { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, > > - { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, > > - { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, > > - { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, > > - { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, > > - { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, > > - { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, > > - > > - { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, > > - { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, > > - { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, > > - { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, > > - { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, > > - { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, > > - { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, > > - { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, > > - { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, > > - { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, > > - { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, > > - { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, > > - { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, > > - { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, > > - { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, > > - { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, > > - { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, > > - { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, > > - { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, > > - { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, > > - { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, > > - { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, > > - { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, > > - { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, > > - { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, > > - { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, > > - { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, > > - { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, > > - { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, > > - { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, > > - { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, > > - { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, > > - { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, > > - { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, > > - { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, > > - { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, > > - { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, > > - { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, > > -}; > > - > > - > > -// helper function for the error codes: > > -const char* tpm_get_error_name (TPM_RESULT code) { > > - // just do a linear scan for now > > - unsigned i; > > - for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) > > - if (code == error_msgs[i].code) > > - return error_msgs[i].code_name; > > - > > - return("Unknown Error Code"); > > -} > > diff --git a/tools/vtpm_manager/util/log.h b/tools/vtpm_manager/util/log.h > > deleted file mode 100644 > > index 1f15f5b..0000000 > > --- a/tools/vtpm_manager/util/log.h > > +++ /dev/null > > @@ -1,94 +0,0 @@ > > -// =================================================================== > > -// > > -// 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_LOG_H__ > > -#define __VTPM_LOG_H__ > > - > > -#include // for uint32_t > > -#include // for pointer NULL > > - > > -// =========================== LOGGING ============================== > > - > > -// the logging module numbers > > -#define VTPM_LOG_CRYPTO 1 > > -#define VTPM_LOG_BSG 2 > > -#define VTPM_LOG_TXDATA 3 > > -#define VTPM_LOG_TCS 4 > > -#define VTPM_LOG_TCS_DEEP 5 > > -#define VTPM_LOG_VTSP 6 > > -#define VTPM_LOG_VTPM 7 > > -#define VTPM_LOG_VTPM_DEEP 8 > > -#define VTPM_LOG_VTSP_DEEP 9 > > - > > -static char *module_names[] = { "", > > - "CRYPTO", > > - "BSG", > > - "TXDATA", > > - "TCS", > > - "TCS", > > - "VTSP", > > - "VTPM", > > - "VTPM", > > - "VTSP" > > - }; > > - > > -// Default to standard logging > > -#ifndef LOGGING_MODULES > > -#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)) > > -#endif > > - > > -// bit-access macros > > -#define BITMASK(idx) ( 1U << (idx) ) > > -#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) > > -#define SETBIT(num,idx) (num) |= BITMASK(idx) > > -#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) > > - > > -#define vtpmloginfo(module, fmt, args...) \ > > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > > - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ > > - } > > - > > -#define vtpmloginfomore(module, fmt, args...) \ > > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > > - fprintf (stdout, fmt,##args); \ > > - } > > - > > -#define vtpmlogerror(module, fmt, args...) \ > > - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); > > - > > -//typedef UINT32 tpm_size_t; > > - > > -// helper function for the error codes: > > -const char* tpm_get_error_name (TPM_RESULT code); > > - > > -#endif // _VTPM_LOG_H_ > > diff --git a/tools/vtpm_manager/util/tcg.h b/tools/vtpm_manager/util/tcg.h > > deleted file mode 100644 > > index 5c42913..0000000 > > --- a/tools/vtpm_manager/util/tcg.h > > +++ /dev/null > > @@ -1,503 +0,0 @@ > > -// =================================================================== > > -// > > -// 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. > > -// =================================================================== > > -// > > -// tcg.h > > -// > > -// This file contains all the structure and type definitions > > -// > > -// ================================================================== > > - > > -#ifndef __TCG_H__ > > -#define __TCG_H__ > > - > > -// This pragma is used to disallow structure padding > > -#pragma pack(push, 1) > > - > > -// *************************** TYPEDEFS ********************************* > > -typedef unsigned char BYTE; > > -typedef unsigned char BOOL; > > -typedef unsigned short UINT16; > > -typedef unsigned int UINT32; > > -typedef unsigned long long UINT64; > > - > > -typedef UINT32 TPM_RESULT; > > -typedef UINT32 TPM_PCRINDEX; > > -typedef UINT32 TPM_DIRINDEX; > > -typedef UINT32 TPM_HANDLE; > > -typedef TPM_HANDLE TPM_AUTHHANDLE; > > -typedef TPM_HANDLE TCPA_HASHHANDLE; > > -typedef TPM_HANDLE TCPA_HMACHANDLE; > > -typedef TPM_HANDLE TCPA_ENCHANDLE; > > -typedef TPM_HANDLE TPM_KEY_HANDLE; > > -typedef TPM_HANDLE TCPA_ENTITYHANDLE; > > -typedef UINT32 TPM_RESOURCE_TYPE; > > -typedef UINT32 TPM_COMMAND_CODE; > > -typedef UINT16 TPM_PROTOCOL_ID; > > -typedef BYTE TPM_AUTH_DATA_USAGE; > > -typedef UINT16 TPM_ENTITY_TYPE; > > -typedef UINT32 TPM_ALGORITHM_ID; > > -typedef UINT16 TPM_KEY_USAGE; > > -typedef UINT16 TPM_STARTUP_TYPE; > > -typedef UINT32 TPM_CAPABILITY_AREA; > > -typedef UINT16 TPM_ENC_SCHEME; > > -typedef UINT16 TPM_SIG_SCHEME; > > -typedef UINT16 TPM_MIGRATE_SCHEME; > > -typedef UINT16 TPM_PHYSICAL_PRESENCE; > > -typedef UINT32 TPM_KEY_FLAGS; > > - > > -#define TPM_DIGEST_SIZE 20 // Don't change this > > -typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; > > -typedef TPM_AUTHDATA TPM_SECRET; > > -typedef TPM_AUTHDATA TPM_ENCAUTH; > > -typedef BYTE TPM_PAYLOAD_TYPE; > > -typedef UINT16 TPM_TAG; > > - > > -// Data Types of the TCS > > -typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session > > -typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle > > -typedef UINT32 TCS_KEY_HANDLE; // Basic key handle > > - > > -// ************************* STRUCTURES ********************************** > > - > > -typedef struct TPM_VERSION { > > - BYTE major; > > - BYTE minor; > > - BYTE revMajor; > > - BYTE revMinor; > > -} TPM_VERSION; > > - > > -static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; > > - > > -typedef struct TPM_DIGEST { > > - BYTE digest[TPM_DIGEST_SIZE]; > > -} TPM_DIGEST; > > - > > -typedef TPM_DIGEST TPM_PCRVALUE; > > -typedef TPM_DIGEST TPM_COMPOSITE_HASH; > > -typedef TPM_DIGEST TPM_DIRVALUE; > > -typedef TPM_DIGEST TPM_HMAC; > > -typedef TPM_DIGEST TPM_CHOSENID_HASH; > > - > > -typedef struct TPM_NONCE { > > - BYTE nonce[TPM_DIGEST_SIZE]; > > -} TPM_NONCE; > > - > > -typedef struct TPM_KEY_PARMS { > > - TPM_ALGORITHM_ID algorithmID; > > - TPM_ENC_SCHEME encScheme; > > - TPM_SIG_SCHEME sigScheme; > > - UINT32 parmSize; > > - BYTE* parms; > > -} TPM_KEY_PARMS; > > - > > -typedef struct TPM_RSA_KEY_PARMS { > > - UINT32 keyLength; > > - UINT32 numPrimes; > > - UINT32 exponentSize; > > - BYTE* exponent; > > -} TPM_RSA_KEY_PARMS; > > - > > -typedef struct TPM_STORE_PUBKEY { > > - UINT32 keyLength; > > - BYTE* key; > > -} TPM_STORE_PUBKEY; > > - > > -typedef struct TPM_PUBKEY { > > - TPM_KEY_PARMS algorithmParms; > > - TPM_STORE_PUBKEY pubKey; > > -} TPM_PUBKEY; > > - > > -typedef struct TPM_KEY { > > - TPM_VERSION ver; > > - TPM_KEY_USAGE keyUsage; > > - TPM_KEY_FLAGS keyFlags; > > - TPM_AUTH_DATA_USAGE authDataUsage; > > - TPM_KEY_PARMS algorithmParms; > > - UINT32 PCRInfoSize; > > - BYTE* PCRInfo; // this should be a TPM_PCR_INFO, or NULL > > - TPM_STORE_PUBKEY pubKey; > > - UINT32 encDataSize; > > - BYTE* encData; > > -} TPM_KEY; > > - > > -typedef struct TPM_PCR_SELECTION { > > - UINT16 sizeOfSelect; /// in bytes > > - BYTE* pcrSelect; > > -} TPM_PCR_SELECTION; > > - > > -typedef struct TPM_PCR_COMPOSITE { > > - TPM_PCR_SELECTION select; > > - UINT32 valueSize; > > - TPM_PCRVALUE* pcrValue; > > -} TPM_PCR_COMPOSITE; > > - > > - > > -typedef struct TPM_PCR_INFO { > > - TPM_PCR_SELECTION pcrSelection; > > - TPM_COMPOSITE_HASH digestAtRelease; > > - TPM_COMPOSITE_HASH digestAtCreation; > > -} TPM_PCR_INFO; > > - > > - > > -typedef struct TPM_BOUND_DATA { > > - TPM_VERSION ver; > > - TPM_PAYLOAD_TYPE payload; > > - BYTE* payloadData; > > -} TPM_BOUND_DATA; > > - > > -typedef struct TPM_STORED_DATA { > > - TPM_VERSION ver; > > - UINT32 sealInfoSize; > > - BYTE* sealInfo; > > - UINT32 encDataSize; > > - BYTE* encData; > > -} TPM_STORED_DATA; > > - > > -typedef struct TCS_AUTH { > > - TCS_AUTHHANDLE AuthHandle; > > - TPM_NONCE NonceOdd; // system > > - TPM_NONCE NonceEven; // TPM > > - BOOL fContinueAuthSession; > > - TPM_AUTHDATA HMAC; > > -} TCS_AUTH; > > - > > -// structures for dealing with sizes followed by buffers in all the > > -// TCG structure. > > -typedef struct pack_buf_t { > > - UINT32 size; > > - BYTE * data; > > -} pack_buf_t; > > - > > -typedef struct pack_constbuf_t { > > - UINT32 size; > > - const BYTE* data; > > -} pack_constbuf_t; > > - > > - > > - > > -// **************************** CONSTANTS ********************************* > > - > > -// BOOL values > > -#define TRUE 0x01 > > -#define FALSE 0x00 > > - > > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > > - > > -// > > -// TPM_COMMAND_CODE values > > -#define TPM_PROTECTED_ORDINAL 0x00000000UL > > -#define TPM_UNPROTECTED_ORDINAL 0x80000000UL > > -#define TPM_CONNECTION_ORDINAL 0x40000000UL > > -#define TPM_VENDOR_ORDINAL 0x20000000UL > > - > > -#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) > > -#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) > > -#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) > > - > > - > > - > > -// > > -// TPM_RESULT values > > -// > > -// just put in the whole table from spec 1.2 > > - > > -#define TPM_BASE 0x0 // The start of TPM return codes > > -#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands > > -#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. > > - > > -#define TPM_SUCCESS TPM_BASE // Successful completion of the operation > > -#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed > > -#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect > > -#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad > > -#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. > > -#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access > > -#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated > > -#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled > > -#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled > > -#define TPM_FAIL TPM_BASE + 9 // The operation failed > > -#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent > > -#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled > > -#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid > > -#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found > > -#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme > > -#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed > > -#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted > > -#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. > > -#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set > > -#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM > > -#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner > > -#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. > > -#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short > > -#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. > > -#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. > > -#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value > > -#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. > > -#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. > > -#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. > > -#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization > > -#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid > > -#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM > > -#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. > > -#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. > > -#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. > > -#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed > > -#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed > > -#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed > > -#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup > > -#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information > > -#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM > > - > > -#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. > > -#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. > > -#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key > > -#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. > > -#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value > > -#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability > > -#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions > > -#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also > > -#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success > > -#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute > > -#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport > > -#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed > > -#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource > > -#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode > > -#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID > > -#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available > > -#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command > > -#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key > > -#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization > > -#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable > > -#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation > > -#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to > > -#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area > > -#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match > > -#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to > > -#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict > > -#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent > > -#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. > > -#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect > > -#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area > > -#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large > > -#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded > > -#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set > > -#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded > > -#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked > > -#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family > > -#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled > > -#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session > > - > > -// TPM_STARTUP_TYPE values > > -#define TPM_ST_CLEAR 0x0001 > > -#define TPM_ST_STATE 0x0002 > > -#define TPM_ST_DEACTIVATED 0x003 > > - > > -// TPM_TAG values > > -#define TPM_TAG_RQU_COMMAND 0x00c1 > > -#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 > > -#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 > > -#define TPM_TAG_RSP_COMMAND 0x00c4 > > -#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 > > -#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 > > - > > -// TPM_PAYLOAD_TYPE values > > -#define TPM_PT_ASYM 0x01 > > -#define TPM_PT_BIND 0x02 > > -#define TPM_PT_MIGRATE 0x03 > > -#define TPM_PT_MAINT 0x04 > > -#define TPM_PT_SEAL 0x05 > > - > > -// TPM_ENTITY_TYPE values > > -#define TPM_ET_KEYHANDLE 0x0001 > > -#define TPM_ET_OWNER 0x0002 > > -#define TPM_ET_DATA 0x0003 > > -#define TPM_ET_SRK 0x0004 > > -#define TPM_ET_KEY 0x0005 > > - > > -/// TPM_ResourceTypes > > -#define TPM_RT_KEY 0x00000001 > > -#define TPM_RT_AUTH 0x00000002 > > -#define TPM_RT_TRANS 0x00000004 > > -#define TPM_RT_CONTEXT 0x00000005 > > - > > -// TPM_PROTOCOL_ID values > > -#define TPM_PID_OIAP 0x0001 > > -#define TPM_PID_OSAP 0x0002 > > -#define TPM_PID_ADIP 0x0003 > > -#define TPM_PID_ADCP 0x0004 > > -#define TPM_PID_OWNER 0x0005 > > - > > -// TPM_ALGORITHM_ID values > > -#define TPM_ALG_RSA 0x00000001 > > -#define TPM_ALG_DES 0x00000002 > > -#define TPM_ALG_3DES 0X00000003 > > -#define TPM_ALG_SHA 0x00000004 > > -#define TPM_ALG_HMAC 0x00000005 > > -#define TCPA_ALG_AES 0x00000006 > > - > > -// TPM_ENC_SCHEME values > > -#define TPM_ES_NONE 0x0001 > > -#define TPM_ES_RSAESPKCSv15 0x0002 > > -#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 > > - > > -// TPM_SIG_SCHEME values > > -#define TPM_SS_NONE 0x0001 > > -#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 > > -#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 > > - > > -// TPM_KEY_USAGE values > > -#define TPM_KEY_EK 0x0000 > > -#define TPM_KEY_SIGNING 0x0010 > > -#define TPM_KEY_STORAGE 0x0011 > > -#define TPM_KEY_IDENTITY 0x0012 > > -#define TPM_KEY_AUTHCHANGE 0X0013 > > -#define TPM_KEY_BIND 0x0014 > > -#define TPM_KEY_LEGACY 0x0015 > > - > > -// TPM_AUTH_DATA_USAGE values > > -#define TPM_AUTH_NEVER 0x00 > > -#define TPM_AUTH_ALWAYS 0x01 > > - > > -// Key Handle of owner and srk > > -#define TPM_OWNER_KEYHANDLE 0x40000001 > > -#define TPM_SRK_KEYHANDLE 0x40000000 > > - > > -// ---------------------- Functions for checking TPM_RESULTs ----------------- > > - > > -#include > > - > > -// FIXME: Review use of these and delete unneeded ones. > > - > > -// these are really badly dependent on local structure: > > -// DEPENDS: local var 'status' of type TPM_RESULT > > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > > -#define ERRORDIE(s) do { status = s; \ > > - fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ > > - goto abort_egress; } \ > > - while (0) > > - > > -// DEPENDS: local var 'status' of type TPM_RESULT > > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > > -// Try command c. If it fails, set status to s and goto abort. > > -#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ > > - status = s; \ > > - printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > > - goto abort_egress; \ > > - } else {\ > > - status = c; \ > > - } > > - > > -// Try command c. If it fails, print error message, set status to actual return code. Goto abort > > -#define TPMTRYRETURN(c) do { status = c; \ > > - if (status != TPM_SUCCESS) { \ > > - fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > > - goto abort_egress; \ > > - } \ > > - } while(0) > > - > > - > > -#pragma pack(pop) > > - > > -#endif //__TCPA_H__ > > diff --git a/tools/xenstore/hashtable.c b/tools/xenstore/hashtable.c > > index 3b89223..0ba1d55 100644 > > --- a/tools/xenstore/hashtable.c > > +++ b/tools/xenstore/hashtable.c > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/blktap2/drivers/hashtable.c > > - * - tools/vtpm_manager/util/hashtable.c > > */ > > > > #include "hashtable.h" > > diff --git a/tools/xenstore/hashtable.h b/tools/xenstore/hashtable.h > > index 8e6bb5b..4d68223 100644 > > --- a/tools/xenstore/hashtable.h > > +++ b/tools/xenstore/hashtable.h > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/blktap2/drivers/hashtable.h > > - * - tools/vtpm_manager/util/hashtable.h > > */ > > > > #ifndef __HASHTABLE_CWC22_H__ > > diff --git a/tools/xenstore/hashtable_private.h b/tools/xenstore/hashtable_private.h > > index cabaffe..a08559d 100644 > > --- a/tools/xenstore/hashtable_private.h > > +++ b/tools/xenstore/hashtable_private.h > > @@ -3,7 +3,6 @@ > > /* > > * There are duplicates of this code in: > > * - tools/blktap2/drivers/hashtable_private.h > > - * - tools/vtpm_manager/util/hashtable_private.h > > */ > > > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > > diff --git a/tools/xm-test/configure.ac b/tools/xm-test/configure.ac > > index ad1eb78..c142140 100644 > > --- a/tools/xm-test/configure.ac > > +++ b/tools/xm-test/configure.ac > > @@ -143,7 +143,6 @@ AC_CONFIG_FILES([ > > tests/unpause/Makefile > > tests/vcpu-pin/Makefile > > tests/vcpu-disable/Makefile > > - tests/vtpm/Makefile > > tests/xapi/Makefile > > tests/enforce_dom0_cpus/Makefile > > tests/cpupool/Makefile > > diff --git a/tools/xm-test/grouptest/default b/tools/xm-test/grouptest/default > > index f0516b2..e04591b 100644 > > --- a/tools/xm-test/grouptest/default > > +++ b/tools/xm-test/grouptest/default > > @@ -27,5 +27,4 @@ sysrq > > unpause > > vcpu-disable > > vcpu-pin > > -vtpm > > xapi > > diff --git a/tools/xm-test/grouptest/medium b/tools/xm-test/grouptest/medium > > index bafc988..5c3e1b1 100644 > > --- a/tools/xm-test/grouptest/medium > > +++ b/tools/xm-test/grouptest/medium > > @@ -22,4 +22,3 @@ sysrq 01_sysrq_basic_neg.test 02_sysrq_sync_pos.test > > unpause > > vcpu-disable > > vcpu-pin > > -vtpm > > diff --git a/tools/xm-test/grouptest/xapi b/tools/xm-test/grouptest/xapi > > index 3b04921..7a08b77 100644 > > --- a/tools/xm-test/grouptest/xapi > > +++ b/tools/xm-test/grouptest/xapi > > @@ -1,2 +1 @@ > > xapi > > -vtpm 09_vtpm-xapi.test > > diff --git a/tools/xm-test/lib/XmTestLib/XenDomain.py b/tools/xm-test/lib/XmTestLib/XenDomain.py > > index ae8c550..3ba7433 100644 > > --- a/tools/xm-test/lib/XmTestLib/XenDomain.py > > +++ b/tools/xm-test/lib/XmTestLib/XenDomain.py > > @@ -59,7 +59,6 @@ class XenConfig: > > # These options need to be lists > > self.defaultOpts["disk"] = [] > > self.defaultOpts["vif"] = [] > > - self.defaultOpts["vtpm"] = [] > > > > self.opts = self.defaultOpts > > > > diff --git a/tools/xm-test/tests/Makefile.am b/tools/xm-test/tests/Makefile.am > > index 8d673ed..455f50c 100644 > > --- a/tools/xm-test/tests/Makefile.am > > +++ b/tools/xm-test/tests/Makefile.am > > @@ -25,7 +25,6 @@ SUBDIRS = \ > > unpause \ > > vcpu-disable \ > > vcpu-pin \ > > - vtpm \ > > enforce_dom0_cpus \ > > save restore migrate \ > > cpupool > > diff --git a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py b/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > > deleted file mode 100644 > > index dfd1227..0000000 > > --- a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > > +++ /dev/null > > @@ -1,40 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# verify list > > - > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > - > > -try: > > - domain.start(noConsole=True) > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - vtpm_cleanup(domain.getName()) > > - FAIL("Unable to create domain") > > - > > - > > -domName = domain.getName() > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -status, output = traceCommand("xm vtpm-list %s" % domain.getId()) > > -eyecatcher = "/local/domain/0/backend/vtpm" > > -where = output.find(eyecatcher) > > -if status != 0: > > - FAIL("xm vtpm-list returned bad status, expected 0, status is %i" % status) > > -elif where < 0: > > - FAIL("Fail to list virtual TPM device") > > - > > -domain.stop() > > diff --git a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py b/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > > deleted file mode 100644 > > index a18cbab..0000000 > > --- a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > > +++ /dev/null > > @@ -1,49 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# check list of pcrs > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -domain.closeConsole() > > - > > -domain.stop() > > - > > -if not re.search("PCR-00:",run["output"]): > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > diff --git a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py b/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > > deleted file mode 100644 > > index b863f27..0000000 > > --- a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > > +++ /dev/null > > @@ -1,99 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# check list of pcrs; suspend and resume the domain and > > -# check list of pcrs again > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm save %s %s.save" % > > - (domName, domName), > > - timeout=30) > > - > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm save did not succeed") > > - > > - try: > > - status, ouptut = traceCommand("xm restore %s.save" % > > - (domName), > > - timeout=30) > > - except TimeoutError, e: > > - os.remove("%s.save" % domName) > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - os.remove("%s.save" % domName) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm restore did not succeed") > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > - > > diff --git a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > > deleted file mode 100644 > > index ccc8b73..0000000 > > --- a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > > +++ /dev/null > > @@ -1,93 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# check list of pcrs; locally migrate the domain and > > -# check list of pcrs again > > -# This test does local live migration. > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -old_domid = domid(domName) > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > > - domName, > > - timeout=90) > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm migrate did not succeed. External device migration activated?") > > - > > - > > - domName = domain.getName() > > - new_domid = domid(domName) > > - > > - if (old_domid == new_domid): > > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > > - (old_domid,loop)) > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > diff --git a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > > deleted file mode 100644 > > index 57b87df..0000000 > > --- a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > > +++ /dev/null > > @@ -1,93 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# check list of pcrs; locally migrate the domain and > > -# check list of pcrs again > > -# This test does local (non-live) migration. > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -old_domid = domid(domName) > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm migrate %s localhost" % > > - domName, > > - timeout=90) > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm migrate did not succeed. External device migration activated?") > > - > > - > > - domName = domain.getName() > > - new_domid = domid(domName) > > - > > - if (old_domid == new_domid): > > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > > - (old_domid,loop)) > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > diff --git a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py b/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > > deleted file mode 100644 > > index c70691d..0000000 > > --- a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > > +++ /dev/null > > @@ -1,125 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# extend a pcr > > -# check list of pcrs; suspend and resume the domain and > > -# check list of pcrs again and validate extended pcr > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while creating /dev/tpm0") > > - > > -try: > > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while extending PCR 0") > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > > - > > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm save %s %s.save" % > > - (domName, domName), > > - timeout=30) > > - > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm save did not succeed") > > - > > - try: > > - status, ouptut = traceCommand("xm restore %s.save" % > > - (domName), > > - timeout=30) > > - except TimeoutError, e: > > - os.remove("%s.save" % domName) > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - os.remove("%s.save" % domName) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm restore did not succeed") > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > - > > diff --git a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > > deleted file mode 100644 > > index 4ff3360..0000000 > > --- a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > > +++ /dev/null > > @@ -1,119 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# extend a pcr > > -# check list of pcrs; locally migrate the domain and > > -# check list of pcrs again and validate extended pcr > > -# This test does local live migration. > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while creating /dev/tpm0") > > - > > -try: > > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while extending PCR 0") > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > > - > > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -old_domid = domid(domName) > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > > - domName, > > - timeout=90) > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm migrate did not succeed. External device migration activated?") > > - > > - > > - domName = domain.getName() > > - new_domid = domid(domName) > > - > > - if (old_domid == new_domid): > > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > > - (old_domid,loop)) > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > diff --git a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > > deleted file mode 100644 > > index 27125fc..0000000 > > --- a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > > +++ /dev/null > > @@ -1,119 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Positive Test: create domain with virtual TPM attached at build time, > > -# extend a pcr > > -# check list of pcrs; locally migrate the domain and > > -# check list of pcrs again and validate extended pcr > > -# This test does local (non-live) migration. > > - > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > -import os.path > > -import atexit > > - > > -config = {"vtpm":"instance=1,backend=0"} > > -domain = XmTestDomain(extraConfig=config) > > -domName = domain.getName() > > -consoleHistory = "" > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - if verbose: > > - print e.extra > > - FAIL("Unable to create domain (%s)" % domName) > > - > > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while creating /dev/tpm0") > > - > > -try: > > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("Error while extending PCR 0") > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > > - > > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > > - > > -consoleHistory = console.getHistory() > > -domain.closeConsole() > > - > > -old_domid = domid(domName) > > - > > -loop = 0 > > -while loop < 3: > > - try: > > - status, ouptut = traceCommand("xm migrate %s localhost" % > > - domName, > > - timeout=90) > > - except TimeoutError, e: > > - saveLog(consoleHistory) > > - FAIL(str(e)) > > - > > - if status != 0: > > - saveLog(consoleHistory) > > - FAIL("xm migrate did not succeed. External device migration activated?") > > - > > - > > - domName = domain.getName() > > - new_domid = domid(domName) > > - > > - if (old_domid == new_domid): > > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > > - (old_domid,loop)) > > - > > - try: > > - console = domain.getConsole() > > - except ConsoleError, e: > > - FAIL(str(e)) > > - > > - try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > - except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("No result from dumping the PCRs") > > - > > - if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > > - > > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > > - > > - loop += 1 > > - > > -domain.closeConsole() > > - > > -domain.stop() > > diff --git a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py b/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > > deleted file mode 100644 > > index a1aa8b3..0000000 > > --- a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > > +++ /dev/null > > @@ -1,158 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -# Test to test the vtpm class through the Xen-API > > -# > > -# Tested methods: > > -# VTPM: get_uuid, get_backend, get_by_uuid, get_record > > -# create, destroy, get_VM > > -# VM: get_VTPMS > > - > > -from XmTestLib import xapi > > -from XmTestLib.XenAPIDomain import XmTestAPIDomain > > -from XmTestLib import * > > -from vtpm_utils import * > > -import commands > > -import os > > - > > -VTPM_RECORD_KEYS = [ 'backend', 'VM', 'uuid', 'other_config' ] > > - > > -try: > > - # XmTestAPIDomain tries to establish a connection to XenD > > - domain = XmTestAPIDomain() > > -except Exception, e: > > - SKIP("Skipping test. Error: %s" % str(e)) > > -vm_uuid = domain.get_uuid() > > - > > -vtpmcfg = {} > > -vtpmcfg['backend'] = DOM0_UUID > > -vtpmcfg['VM'] = vm_uuid > > - > > -session = xapi.connect() > > - > > -vtpm_uuid = session.xenapi.VTPM.create(vtpmcfg) > > - > > -vtpm_be = session.xenapi.VTPM.get_backend(vtpm_uuid) > > -if vtpm_be != vtpmcfg['backend']: > > - FAIL("vTPM's backend is in '%s', expected: '%s'" % > > - (vtpm_be, vtpmcfg['backend'])) > > - > > -vtpm_rec = session.xenapi.VTPM.get_record(vtpm_uuid) > > - > > -miss_keys = [] > > -for k in VTPM_RECORD_KEYS: > > - if k not in vtpm_rec.keys(): > > - miss_keys.append(k) > > -if len(miss_keys) > 0: > > - FAIL("vTPM record is missing key(s): %s" % miss_keys) > > - > > -if vtpm_rec['uuid'] != vtpm_uuid: > > - FAIL("vTPM record shows vtpm uuid '%s', expected: '%s'" % > > - (vtpm_rec['uuid'], vtpm_uuid)) > > -if vtpm_rec['VM'] != vm_uuid: > > - FAIL("vTPM record shows VM uuid '%s', expected: '%s'" % > > - (vtpm_rec['VM'], vm_uuid)) > > -if vtpm_rec['backend'] != vtpmcfg['backend']: > > - FAIL("vTPM record shows VM bakcned '%s', expected: '%s'" % > > - (vtpm_rev['backend'], vtpmcfg['backend'])) > > - > > -badkeys = [] > > -keys = vtpm_rec.keys() > > -for k in keys: > > - if k not in VTPM_RECORD_KEYS: > > - badkeys.append(k) > > -if len(badkeys) > 0: > > - FAIL("Unexpected attributes in result: %s" % badkeys) > > - > > -if vm_uuid != session.xenapi.VTPM.get_VM(vtpm_uuid): > > - FAIL("VM uuid from VTPM.get_VM different (%s) than expected (%s)." % > > - (vm_ref, vm_uuid)) > > - > > -uuid = session.xenapi.VTPM.get_uuid(vtpm_uuid) > > -if uuid != vtpm_uuid: > > - FAIL("vTPM from VTPM.get_uuid different (%s) than expected (%s)." % > > - (uuid, vtpm_uuid)) > > - > > -vtpm_ref = session.xenapi.VTPM.get_by_uuid(vtpm_uuid) > > -if vtpm_ref != vtpm_uuid: > > - FAIL("vTPM from VTPM.get_by_uuid different (%s) than expected (%s)." % > > - (vtpm_ref, vtpm_uuid)) > > - > > -vm_vtpms = session.xenapi.VM.get_VTPMs(vm_uuid) > > -if len(vm_vtpms) != 1: > > - FAIL("Number of vTPMs from get_VTPMs is (%d) not what was expected (%d)" % > > - (len(vm_vtpms), 1)) > > -if vtpm_uuid not in vm_vtpms: > > - FAIL("Other vTPM uuid (%s) returned from VM.get_VTPMs than expected (%s)" % > > - (vm_vtpms[0], vtpm_uuid)) > > - > > -try: > > - console = domain.start() > > -except DomainError, e: > > - FAIL("Unable to create domain.") > > - > > -try: > > - console.sendInput("input") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("1. No result from dumping the PCRs") > > - > > -if re.search("No such file",run["output"]): > > - FAIL("TPM frontend support not compiled into (domU?) kernel") > > - > > -if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("1. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > > - > > -try: > > - session.xenapi.VTPM.destroy(vtpm_uuid) > > - #Should never get here > > - FAIL("Could destroy vTPM while VM is running") > > -except: > > - pass > > - > > -rc = session.xenapi.VM.suspend(vm_uuid) > > -if rc: > > - FAIL("Could not suspend VM") > > - > > -try: > > - session.xenapi.VTPM.destroy(vtpm_uuid) > > - #May not throw an exception in 'suspend' state > > -except: > > - pass > > - > > -rc = session.xenapi.VM.resume(vm_uuid, False) > > -if rc: > > - FAIL("Could not resume VM") > > - > > -try: > > - console = domain.getConsole() > > -except ConsoleError, e: > > - FAIL(str(e)) > > - > > -try: > > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > > -except ConsoleError, e: > > - saveLog(console.getHistory()) > > - FAIL("2. No result from dumping the PCRs. vTPM has been removed?") > > - > > -if not re.search("PCR-00:",run["output"]): > > - saveLog(console.getHistory()) > > - FAIL("2. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > > - > > -domain.stop() > > - > > -try: > > - session.xenapi.VTPM.destroy(vtpm_uuid) > > -except: > > - FAIL("Could NOT destroy vTPM while domain is halted.") > > - > > -domain.destroy() > > diff --git a/tools/xm-test/tests/vtpm/Makefile.am b/tools/xm-test/tests/vtpm/Makefile.am > > deleted file mode 100644 > > index dd67e45..0000000 > > --- a/tools/xm-test/tests/vtpm/Makefile.am > > +++ /dev/null > > @@ -1,27 +0,0 @@ > > -SUBDIRS = > > - > > -TESTS = 01_vtpm-list_pos.test \ > > - 02_vtpm-cat_pcrs.test \ > > - 03_vtpm-susp_res.test \ > > - 04_vtpm-loc_migr.test \ > > - 05_vtpm-loc_migr.test \ > > - 06_vtpm-susp_res_pcrs.test \ > > - 07_vtpm-mig_pcrs.test \ > > - 08_vtpm-mig_pcrs.test \ > > - 09_vtpm-xapi.test > > - > > -XFAIL_TESTS = > > - > > -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS) vtpm_utils.py > > -TESTS_ENVIRONMENT=@TENV@ > > - > > -%.test: %.py > > - cp $< $@ > > - chmod +x $@ > > - > > -clean-local: am_config_clean-local > > - > > -am_config_clean-local: > > - rm -f *test > > - rm -f *log > > - rm -f *~ > > diff --git a/tools/xm-test/tests/vtpm/vtpm_utils.py b/tools/xm-test/tests/vtpm/vtpm_utils.py > > deleted file mode 100644 > > index 4e5b281..0000000 > > --- a/tools/xm-test/tests/vtpm/vtpm_utils.py > > +++ /dev/null > > @@ -1,30 +0,0 @@ > > -#!/usr/bin/python > > - > > -# Copyright (C) International Business Machines Corp., 2006 > > -# Author: Stefan Berger > > - > > -from XmTestLib import * > > - > > -if ENABLE_HVM_SUPPORT: > > - SKIP("vtpm tests not supported for HVM domains") > > - > > -status, output = traceCommand("COLUMNS=200 ; " > > - "ps aux | grep vtpm_manager | grep -v grep") > > -if output == "": > > - SKIP("virtual TPM manager must be started to run this test; might " > > - "need /dev/tpm0") > > - > > -def vtpm_cleanup(domName): > > - traceCommand("/etc/xen/scripts/vtpm-delete " > > - "`xenstore-read /local/domain/0/backend/vtpm/%s/0/uuid`" % > > - str(domid(domName))) > > - > > -def vtpm_cleanup(uuid): > > - from xen.xm import main > > - if main.serverType != main.SERVER_XEN_API: > > - traceCommand("/etc/xen/scripts/vtpm-delete %s" % uuid) > > - > > -def vtpm_get_uuid(domainid): > > - s, o = traceCommand("xenstore-read " > > - "/local/domain/0/backend/vtpm/%s/0/uuid" % domainid) > > - return o > > -- > > 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 Nov 13 15:05:54 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 13 Nov 2012 15:05:54 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYI3N-0006Nu-Od; Tue, 13 Nov 2012 15:05:29 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYHxC-0005lh-Ty for xen-devel@lists.xen.org; Tue, 13 Nov 2012 14:59:08 +0000 Received: from [85.158.143.35:25878] by server-3.bemta-4.messagelabs.com id 91/14-06841-A3062A05; Tue, 13 Nov 2012 14:59:06 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-10.tower-21.messagelabs.com!1352818741!10180088!1 X-Originating-IP: [128.244.251.36] X-SpamReason: No, hits=0.0 required=7.0 tests=Mail larger than max spam size X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 18927 invoked from network); 13 Nov 2012 14:59:02 -0000 Received: from pilot.jhuapl.edu (HELO jhuapl.edu) (128.244.251.36) by server-10.tower-21.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 13 Nov 2012 14:59:02 -0000 Received: from ([128.244.198.91]) by pilot.jhuapl.edu with ESMTP with TLS id 63GHCH1.157225253; Tue, 13 Nov 2012 09:58:46 -0500 Received: from aplesstripe.dom1.jhuapl.edu ([128.244.198.211]) by aplexcas2.dom1.jhuapl.edu ([128.244.198.91]) with mapi; Tue, 13 Nov 2012 09:58:45 -0500 From: "Fioravante, Matthew E." To: Ian Campbell Date: Tue, 13 Nov 2012 09:58:44 -0500 Thread-Topic: [PATCH VTPM 6/9] Remove the vtpm process model Thread-Index: Ac3BjIxWUEqURI64SYK1F0IkeLy95AAIq4wg Message-ID: <068F06DC4D106941B297C0C5F9F446EA48A229F471@aplesstripe.dom1.jhuapl.edu> References: <1351802150-19258-1-git-send-email-matthew.fioravante@jhuapl.edu> <1352803755.7491.47.camel@zakaz.uk.xensource.com> In-Reply-To: <1352803755.7491.47.camel@zakaz.uk.xensource.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: acceptlanguage: en-US MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 13 Nov 2012 15:05:28 +0000 Cc: Stefano Stabellini , "xen-devel@lists.xen.org" Subject: Re: [Xen-devel] [PATCH VTPM 6/9] Remove the vtpm process model 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 Should I have removed vtpm from xm also? I left it alone because xm is depcrecated. -----Original Message----- From: Ian Campbell [mailto:Ian.Campbell@citrix.com] Sent: Tuesday, November 13, 2012 5:49 AM To: Fioravante, Matthew E. Cc: xen-devel@lists.xen.org; Stefano Stabellini Subject: Re: [PATCH VTPM 6/9] Remove the vtpm process model On Thu, 2012-11-01 at 20:35 +0000, Matthew Fioravante wrote: > Remove the old vtpm process model. It doesn't work very > well and is no longer supported. > > Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell > > diff --git a/tools/Makefile b/tools/Makefile > index d8c8cc0..2ca43b9 100644 > --- a/tools/Makefile > +++ b/tools/Makefile > @@ -18,8 +18,6 @@ SUBDIRS-$(CONFIG_XCUTILS) += xcutils > SUBDIRS-$(CONFIG_X86) += firmware > SUBDIRS-y += console > SUBDIRS-y += xenmon > -SUBDIRS-$(VTPM_TOOLS) += vtpm_manager > -SUBDIRS-$(VTPM_TOOLS) += vtpm > SUBDIRS-y += xenstat > SUBDIRS-$(CONFIG_Linux) += $(SUBDIRS-libaio) > SUBDIRS-$(CONFIG_Linux) += memshr > diff --git a/tools/blktap2/drivers/hashtable.c b/tools/blktap2/drivers/hashtable.c > index 631306b..90a6b85 100644 > --- a/tools/blktap2/drivers/hashtable.c > +++ b/tools/blktap2/drivers/hashtable.c > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable.c > - * - tools/vtpm_manager/util/hashtable.c > */ > > #include "hashtable.h" > diff --git a/tools/blktap2/drivers/hashtable.h b/tools/blktap2/drivers/hashtable.h > index 89aa3dc..56ca053 100644 > --- a/tools/blktap2/drivers/hashtable.h > +++ b/tools/blktap2/drivers/hashtable.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable.h > - * - tools/vtpm_manager/util/hashtable.h > */ > > #ifndef __HASHTABLE_CWC22_H__ > diff --git a/tools/blktap2/drivers/hashtable_itr.c b/tools/blktap2/drivers/hashtable_itr.c > index 402e06b..731917c 100644 > --- a/tools/blktap2/drivers/hashtable_itr.c > +++ b/tools/blktap2/drivers/hashtable_itr.c > @@ -1,10 +1,5 @@ > /* Copyright (C) 2002, 2004 Christopher Clark */ > > -/* > - * There are duplicates of this code in: > - * - tools/vtpm_manager/util/hashtable_itr.c > - */ > - > #include "hashtable.h" > #include "hashtable_private.h" > #include "hashtable_itr.h" > diff --git a/tools/blktap2/drivers/hashtable_itr.h b/tools/blktap2/drivers/hashtable_itr.h > index 3d80638..81da838 100644 > --- a/tools/blktap2/drivers/hashtable_itr.h > +++ b/tools/blktap2/drivers/hashtable_itr.h > @@ -1,10 +1,5 @@ > /* Copyright (C) 2002, 2004 Christopher Clark */ > > -/* > - * There are duplicates of this code in: > - * - tools/vtpm_manager/util/hashtable_itr.h > - */ > - > #ifndef __HASHTABLE_ITR_CWC22__ > #define __HASHTABLE_ITR_CWC22__ > #include "hashtable.h" > diff --git a/tools/blktap2/drivers/hashtable_private.h b/tools/blktap2/drivers/hashtable_private.h > index 5a13a65..954ecc3 100644 > --- a/tools/blktap2/drivers/hashtable_private.h > +++ b/tools/blktap2/drivers/hashtable_private.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/xenstore/hashtable_private.h > - * - tools/vtpm_manager/util/hashtable_private.h > */ > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > diff --git a/tools/configure.ac b/tools/configure.ac > index e708f01..586313d 100644 > --- a/tools/configure.ac > +++ b/tools/configure.ac > @@ -40,7 +40,6 @@ m4_include([m4/fetcher.m4]) > # Enable/disable options > AX_ARG_DEFAULT_DISABLE([githttp], [Download GIT repositories via HTTP]) > AX_ARG_DEFAULT_ENABLE([monitors], [Disable xenstat and xentop monitoring tools]) > -AX_ARG_DEFAULT_DISABLE([vtpm], [Enable Virtual Trusted Platform Module]) > AX_ARG_DEFAULT_DISABLE([xenapi], [Enable Xen API Bindings]) > AX_ARG_DEFAULT_ENABLE([ocamltools], [Disable Ocaml tools]) > AX_ARG_DEFAULT_DISABLE([miniterm], [Enable miniterm]) > diff --git a/tools/examples/README b/tools/examples/README > index 5b0314e..2225d5c 100644 > --- a/tools/examples/README > +++ b/tools/examples/README > @@ -25,13 +25,7 @@ vif-bridge - virtual network start/stop script in bridged mode > vif-common.sh - sourced by vif-bridge > vif-nat - xen virtual network start/stop script in NAT mode > vif-route - xen virtual network start/stop script in routed mode > -vtpm - called by xen-backend.agent to bind/unbind vTPM devices > -vtpm-common.sh - common code for vTPM handling > -vtpm-delete - remove an entry from the vTPM table given the > - domain's name > -vtpm-hotplug-common.sh - sourced by vtpm > -vtpm-migration.sh - sourced by external-device-migrate > -xen-backend.agent - calls block, vif-*, vtpm scripts to add, remove, hotplug > +xen-backend.agent - calls block, vif-* scripts to add, remove, hotplug > devices > xen-backend.rules - hotplug script rules > xend-config.sxp - default xend configuration file > diff --git a/tools/examples/xmexample.pv-grub b/tools/examples/xmexample.pv-grub > index 85f847c..e04e6c1 100644 > --- a/tools/examples/xmexample.pv-grub > +++ b/tools/examples/xmexample.pv-grub > @@ -105,20 +105,6 @@ disk = [ 'phy:hda1,hda1,w' ] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = [ 'instance=1,backend=0' ] > - > -#---------------------------------------------------------------------------- > # Configure the behaviour when a domain exits. There are three 'reasons' > # for a domain to stop: poweroff, reboot, and crash. For each of these you > # may specify: > diff --git a/tools/examples/xmexample1 b/tools/examples/xmexample1 > index 330aaf0..c951200 100644 > --- a/tools/examples/xmexample1 > +++ b/tools/examples/xmexample1 > @@ -101,20 +101,6 @@ disk = [ 'phy:hda1,hda1,w' ] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = [ 'instance=1,backend=0' ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/examples/xmexample2 b/tools/examples/xmexample2 > index 4e5eb3d..8c5137e 100644 > --- a/tools/examples/xmexample2 > +++ b/tools/examples/xmexample2 > @@ -137,20 +137,6 @@ disk = [ 'phy:sda%d,sda1,w' % (7+vmid), > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/examples/xmexample3 b/tools/examples/xmexample3 > index dc22ce1..ae799f9 100644 > --- a/tools/examples/xmexample3 > +++ b/tools/examples/xmexample3 > @@ -122,20 +122,6 @@ disk = [ 'phy:hda%d,hda1,w' % (vmid)] > # configured in xend-config.sxp. > > #---------------------------------------------------------------------------- > -# Define to which TPM instance the user domain should communicate. > -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' > -# where INSTANCE indicates the instance number of the TPM the VM > -# should be talking to and DOM provides the domain where the backend > -# is located. > -# Note that no two virtual machines should try to connect to the same > -# TPM instance. The handling of all TPM instances does require > -# some management effort in so far that VM configration files (and thus > -# a VM) should be associated with a TPM instance throughout the lifetime > -# of the VM / VM configuration file. The instance number must be > -# greater or equal to 1. > -#vtpm = ['instance=%d,backend=0' % (vmid) ] > - > -#---------------------------------------------------------------------------- > # Set the kernel command line for the new domain. > # You only need to define the IP parameters and hostname if the domain's > # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. > diff --git a/tools/hotplug/Linux/Makefile b/tools/hotplug/Linux/Makefile > index 0166790..0605559 100644 > --- a/tools/hotplug/Linux/Makefile > +++ b/tools/hotplug/Linux/Makefile > @@ -18,14 +18,12 @@ XEN_SCRIPTS += vif-setup > XEN_SCRIPTS += block > XEN_SCRIPTS += block-enbd block-nbd > XEN_SCRIPTS += blktap > -XEN_SCRIPTS += vtpm vtpm-delete > XEN_SCRIPTS += xen-hotplug-cleanup > XEN_SCRIPTS += external-device-migrate > XEN_SCRIPTS += vscsi > XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh > XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh > -XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh vtpm-hotplug-common.sh > -XEN_SCRIPT_DATA += vtpm-migration.sh vtpm-impl > +XEN_SCRIPT_DATA += block-common.sh > > UDEV_RULES_DIR = $(CONFIG_DIR)/udev > UDEV_RULES = xen-backend.rules xend.rules > diff --git a/tools/hotplug/Linux/vtpm b/tools/hotplug/Linux/vtpm > deleted file mode 100644 > index 38a4532..0000000 > --- a/tools/hotplug/Linux/vtpm > +++ /dev/null > @@ -1,22 +0,0 @@ > -#!/bin/bash > - > -dir=$(dirname "$0") > -. "$dir/vtpm-hotplug-common.sh" > - > -vtpm_fatal_error=0 > - > -case "$command" in > - add) > - vtpm_create_instance > - ;; > - remove) > - vtpm_remove_instance > - ;; > -esac > - > -if [ $vtpm_fatal_error -eq 0 ]; then > - log debug "Successful vTPM operation '$command'." > - success > -else > - fatal "Error while executing vTPM operation '$command'." > -fi > diff --git a/tools/hotplug/Linux/vtpm-common.sh b/tools/hotplug/Linux/vtpm-common.sh > deleted file mode 100644 > index d0d7935..0000000 > --- a/tools/hotplug/Linux/vtpm-common.sh > +++ /dev/null > @@ -1,448 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# Copyright (c) 2005 XenSource Ltd. > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/logging.sh" > -. "$dir/locking.sh" > - > -VTPMDB="/var/vtpm/vtpm.db" > - > -#In the vtpm-impl file some commands should be defined: > -# vtpm_create, vtpm_setup, vtpm_start, etc. (see below) > -if [ -r "$dir/vtpm-impl.alt" ]; then > - . "$dir/vtpm-impl.alt" > -elif [ -r "$dir/vtpm-impl" ]; then > - . "$dir/vtpm-impl" > -else > - function vtpm_create () { > - true > - } > - function vtpm_setup() { > - true > - } > - function vtpm_start() { > - true > - } > - function vtpm_suspend() { > - true > - } > - function vtpm_resume() { > - true > - } > - function vtpm_delete() { > - true > - } > - function vtpm_migrate() { > - echo "Error: vTPM migration accross machines not implemented." > - } > - function vtpm_migrate_local() { > - echo "Error: local vTPM migration not supported" > - } > - function vtpm_migrate_recover() { > - true > - } > -fi > - > - > -#Find the instance number for the vtpm given the name of the domain > -# Parameters > -# - vmname : the name of the vm > -# Return value > -# Returns '0' if instance number could not be found, otherwise > -# it returns the instance number in the variable 'instance' > -function vtpmdb_find_instance () { > - local vmname ret instance > - vmname=$1 > - ret=0 > - > - instance=$(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - '{ \ > - if ( 1 != index($1,"#")) { \ > - if ( $1 == vmname ) { \ > - print $2; \ > - exit; \ > - } \ > - } \ > - }') > - if [ "$instance" != "" ]; then > - ret=$instance > - fi > - echo "$ret" > -} > - > - > -# Check whether a particular instance number is still available > -# returns "0" if it is not available, "1" otherwise. > -function vtpmdb_is_free_instancenum () { > - local instance instances avail i > - instance=$1 > - avail=1 > - #Allowed instance number range: 1-255 > - if [ $instance -eq 0 -o $instance -gt 255 ]; then > - avail=0 > - else > - instances=$(cat $VTPMDB | \ > - awk \ > - '{ \ > - if (1 != index($1,"#")) { \ > - printf("%s ",$2); \ > - } \ > - }') > - for i in $instances; do > - if [ $i -eq $instance ]; then > - avail=0 > - break > - fi > - done > - fi > - echo "$avail" > -} > - > - > -# Get an available instance number given the database > -# Returns an unused instance number > -function vtpmdb_get_free_instancenum () { > - local ctr instances don found > - instances=$(cat $VTPMDB | \ > - awk \ > - '{ \ > - if (1 != index($1,"#")) { \ > - printf("%s ",$2); \ > - } \ > - }') > - ctr=1 > - don=0 > - while [ $don -eq 0 ]; do > - found=0 > - for i in $instances; do > - if [ $i -eq $ctr ]; then > - found=1; > - break; > - fi > - done > - > - if [ $found -eq 0 ]; then > - don=1 > - break > - fi > - let ctr=ctr+1 > - done > - echo "$ctr" > -} > - > - > -# Add a domain name and instance number to the DB file > -function vtpmdb_add_instance () { > - local res vmname inst > - vmname=$1 > - inst=$2 > - > - if [ ! -f $VTPMDB ]; then > - echo "#Database for VM to vTPM association" > $VTPMDB > - echo "#1st column: domain name" >> $VTPMDB > - echo "#2nd column: TPM instance number" >> $VTPMDB > - fi > - res=$(vtpmdb_validate_entry $vmname $inst) > - if [ $res -eq 0 ]; then > - echo "$vmname $inst" >> $VTPMDB > - fi > -} > - > - > -#Validate whether an entry is the same as passed to this > -#function > -function vtpmdb_validate_entry () { > - local res rc vmname inst > - rc=0 > - vmname=$1 > - inst=$2 > - > - res=$(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - -vinst=$inst \ > - '{ \ > - if ( 1 == index($1,"#")) {\ > - } else \ > - if ( $1 == vmname && \ > - $2 == inst) { \ > - printf("1"); \ > - exit; \ > - } else \ > - if ( $1 == vmname || \ > - $2 == inst) { \ > - printf("2"); \ > - exit; \ > - } \ > - }') > - > - if [ "$res" == "1" ]; then > - rc=1 > - elif [ "$res" == "2" ]; then > - rc=2 > - fi > - echo "$rc" > -} > - > - > -#Remove an entry from the vTPM database given its domain name > -#and instance number > -function vtpmdb_remove_entry () { > - local vmname instance VTPMDB_TMP > - vmname=$1 > - instance=$2 > - VTPMDB_TMP="$VTPMDB".tmp > - > - $(cat $VTPMDB | \ > - awk -vvmname=$vmname \ > - '{ \ > - if ( $1 != vmname ) { \ > - print $0; \ > - } \ > - '} > $VTPMDB_TMP) > - if [ -e $VTPMDB_TMP ]; then > - mv -f $VTPMDB_TMP $VTPMDB > - vtpm_delete $instance > - else > - log err "Error creating temporary file '$VTPMDB_TMP'." > - fi > -} > - > - > -# Find the reason for the creation of this device: > -# Returns 'resume' or 'create' > -function vtpm_get_create_reason () { > - local resume > - resume=$(xenstore_read $XENBUS_PATH/resume) > - if [ "$resume" == "True" ]; then > - echo "resume" > - else > - echo "create" > - fi > -} > - > - > -#Create a vTPM instance > -# If no entry in the TPM database is found, the instance is > -# created and an entry added to the database. > -function vtpm_create_instance () { > - local res instance domname reason uuid > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > - reason=$(vtpm_get_create_reason) > - > - claim_lock vtpmdb > - > - instance="0" > - > - if [ "$uuid" != "" ]; then > - instance=$(vtpmdb_find_instance $uuid) > - fi > - if [ "$instance" == "0" ]; then > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > - instance=$(vtpmdb_find_instance $domname) > - fi > - > - if [ "$instance" == "0" -a "$reason" != "create" ]; then > - release_lock vtpmdb > - return > - fi > - > - if [ "$instance" == "0" ]; then > - #Try to give the preferred instance to the domain > - instance=$(xenstore_read "$XENBUS_PATH"/pref_instance) > - if [ "$instance" != "" ]; then > - res=$(vtpmdb_is_free_instancenum $instance) > - if [ $res -eq 0 ]; then > - instance=$(vtpmdb_get_free_instancenum) > - fi > - else > - instance=$(vtpmdb_get_free_instancenum) > - fi > - > - vtpm_create $instance > - > - if [ $vtpm_fatal_error -eq 0 ]; then > - if [ "$uuid" != "" ]; then > - vtpmdb_add_instance $uuid $instance > - else > - vtpmdb_add_instance $domname $instance > - fi > - fi > - else > - if [ "$reason" == "resume" ]; then > - vtpm_resume $instance > - else > - vtpm_start $instance > - fi > - fi > - > - release_lock vtpmdb > - > - xenstore_write $XENBUS_PATH/instance $instance > -} > - > - > -#Remove an instance when a VM is terminating or suspending. > -#Since it is assumed that the VM will appear again, the > -#entry is kept in the VTPMDB file. > -function vtpm_remove_instance () { > - local instance reason domname uuid > - #Stop script execution quietly if path does not exist (anymore) > - xenstore-exists "$XENBUS_PATH"/domain > - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) > - > - claim_lock vtpmdb > - > - instance="0" > - > - if [ "$uuid" != "" ]; then > - instance=$(vtpmdb_find_instance $uuid) > - fi > - > - if [ "$instance" == "0" ]; then > - domname=$(xenstore_read "$XENBUS_PATH"/domain) > - instance=$(vtpmdb_find_instance $domname) > - fi > - > - if [ "$instance" != "0" ]; then > - vtpm_suspend $instance > - fi > - > - release_lock vtpmdb > -} > - > - > -#Remove an entry in the VTPMDB file given the domain's name > -#1st parameter: The name of the domain > -function vtpm_delete_instance () { > - local instance > - > - claim_lock vtpmdb > - > - instance=$(vtpmdb_find_instance $1) > - if [ "$instance" != "0" ]; then > - vtpmdb_remove_entry $1 $instance > - fi > - > - release_lock vtpmdb > -} > - > -# Determine whether the given address is local to this machine > -# Return values: > -# "-1" : the given machine name is invalid > -# "0" : this is not an address of this machine > -# "1" : this is an address local to this machine > -function vtpm_isLocalAddress() { > - local addr res > - addr=$(ping $1 -c 1 | \ > - awk '{ print substr($3,2,length($3)-2); exit }') > - if [ "$addr" == "" ]; then > - echo "-1" > - return > - fi > - res=$(ifconfig | grep "inet addr" | \ > - awk -vaddr=$addr \ > - '{ \ > - if ( addr == substr($2, 6)) {\ > - print "1"; \ > - } \ > - }' \ > - ) > - if [ "$res" == "" ]; then > - echo "0" > - return > - fi > - echo "1" > -} > - > -# Perform a migration step. This function differentiates between migration > -# to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host to migrate to > -# 2nd: name of the domain to migrate > -# 3rd: the migration step to perform > -function vtpm_migration_step() { > - local res=$(vtpm_isLocalAddress $1) > - if [ "$res" == "0" ]; then > - vtpm_migrate $1 $2 $3 > - else > - vtpm_migrate_local > - fi > -} > - > -# Recover from migration due to an error. This function differentiates > -# between migration to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host the migration was going to > -# 2nd: name of the domain that was to be migrated > -# 3rd: the last successful migration step that was done > -function vtpm_recover() { > - local res > - res=$(vtpm_isLocalAddress $1) > - if [ "$res" == "0" ]; then > - vtpm_migrate_recover $1 $2 $3 > - fi > -} > - > - > -#Determine the domain id given a domain's name. > -#1st parameter: name of the domain > -#return value: domain id or -1 if domain id could not be determined > -function vtpm_domid_from_name () { > - local id name ids > - ids=$(xenstore-list /local/domain) > - for id in $ids; do > - name=$(xenstore-read /local/domain/$id/name) > - if [ "$name" == "$1" ]; then > - echo "$id" > - return > - fi > - done > - echo "-1" > -} > - > -#Determine the virtual TPM's instance number using the domain ID. > -#1st parm: domain ID > -function vtpm_uuid_by_domid() { > - echo $(xenstore-read /local/domain/0/backend/vtpm/$1/0/uuid) > -} > - > - > -# Determine the vTPM's UUID by the name of the VM > -function vtpm_uuid_from_vmname() { > - local domid=$(vtpm_domid_from_name $1) > - if [ "$domid" != "-1" ]; then > - echo $(vtpm_uuid_by_domid $domid) > - return > - fi > - echo "" > -} > - > -#Add a virtual TPM instance number and its associated domain name > -#to the VTPMDB file and activate usage of this virtual TPM instance > -#by writing the instance number into the xenstore > -#1st parm: name of virtual machine > -#2nd parm: instance of associated virtual TPM > -function vtpm_add_and_activate() { > - local domid=$(vtpm_domid_from_name $1) > - local vtpm_uuid=$(vtpm_uuid_from_vmname $1) > - if [ "$vtpm_uuid" != "" -a "$domid" != "-1" ]; then > - vtpmdb_add_instance $vtpm_uuid $2 > - xenstore-write backend/vtpm/$domid/0/instance $2 > - fi > -} > diff --git a/tools/hotplug/Linux/vtpm-delete b/tools/hotplug/Linux/vtpm-delete > deleted file mode 100644 > index b75b95b..0000000 > --- a/tools/hotplug/Linux/vtpm-delete > +++ /dev/null > @@ -1,18 +0,0 @@ > -#!/bin/bash > - > -# This scripts must be called the following way: > -# vtpm-delete > -# or > -# vtpm-delete --vmname > - > -dir=$(dirname "$0") > -. "$dir/vtpm-common.sh" > - > -if [ "$1" == "--vmname" ]; then > - vtpm_uuid=$(vtpm_uuid_from_vmname $2) > - if [ "$vtpm_uuid" != "" ];then > - vtpm_delete_instance $vtpm_uuid > - fi > -else > - vtpm_delete_instance $1 > -fi > diff --git a/tools/hotplug/Linux/vtpm-hotplug-common.sh b/tools/hotplug/Linux/vtpm-hotplug-common.sh > deleted file mode 100644 > index 9fd35e7..0000000 > --- a/tools/hotplug/Linux/vtpm-hotplug-common.sh > +++ /dev/null > @@ -1,35 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# Copyright (c) 2005 XenSource Ltd. > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/xen-hotplug-common.sh" > - > -findCommand "$@" > -if [ "$command" != "online" ] && > - [ "$command" != "offline" ] && > - [ "$command" != "add" ] && > - [ "$command" != "remove" ] > -then > - log err "Invalid command: $command" > - exit 1 > -fi > - > - > -XENBUS_PATH="${XENBUS_PATH:?}" > - > -. "$dir/vtpm-common.sh" > diff --git a/tools/hotplug/Linux/vtpm-impl b/tools/hotplug/Linux/vtpm-impl > deleted file mode 100644 > index 4f9a1fd..0000000 > --- a/tools/hotplug/Linux/vtpm-impl > +++ /dev/null > @@ -1,208 +0,0 @@ > -#!/bin/bash > -# =================================================================== > -# > -# 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. > -# =================================================================== > - > -# | SRC | TAG | CMD SIZE | ORD |mtype|strt > -TPM_CMD_OPEN=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x01 > -TPM_CMD_RESM=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x02 > -TPM_CMD_CLOS=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x02 > -TPM_CMD_DELE=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x03 > - > -TPM_TYPE_PVM=\\x01 > -TPM_TYPE_HVM=\\x02 > - > -TPM_SUCCESS=00000000 > - > -TX_VTPM_MANAGER=/var/vtpm/fifos/from_console.fifo > -RX_VTPM_MANAGER=/var/vtpm/fifos/to_console.fifo > - > -VTPM_MIG=/usr/bin/vtpm_migrator > - > -# -------------------- Helpers for binary streams ----------- > - > -function str_to_hex32() { > - printf "%0.8x" $1 > -} > - > -function hex32_to_bin() { > - local inst=$(str_to_hex32 $1); > - > - local n1=`echo $inst | sed 's/\(..\)....../\\\\x\1/'` > - local n2=`echo $inst | sed 's/..\(..\)..../\\\\x\1/'` > - local n3=`echo $inst | sed 's/....\(..\)../\\\\x\1/'` > - local n4=`echo $inst | sed 's/......\(..\)/\\\\x\1/'` > - > - echo "$n1$n2$n3$n4" > -} > - > -function vtpm_manager_cmd() { > - local cmd=$1; > - local inst=$2; > - local inst_bin=$(hex32_to_bin $inst); > - > - claim_lock vtpm_mgr > - > - #send cmd to vtpm_manager > - printf "$cmd$inst_bin" > $TX_VTPM_MANAGER > - > - #recv response > - set +e > - local resp_hex=`dd skip=10 bs=1 count=4 if=$RX_VTPM_MANAGER 2> /dev/null | xxd -ps` > - set -e > - > - release_lock vtpm_mgr > - > - #return whether the command was successful > - if [ $resp_hex -ne $TPM_SUCCESS ]; then > - vtpm_fatal_error=1 > - false > - else > - true > - fi > -} > - > -# Helper to get vm type to pass to vtpm_manager open/resume > -function vtpm_get_type() { > - local inst=$(xenstore_read $XENBUS_PATH/frontend-id) > - local vm=$(xenstore_read /local/domain/$inst/vm) > - if [ "$vm" != "" ]; then > - local ostype=$(xenstore-read $vm/image/ostype) > - if [ "$ostype" == "hvm" ]; then > - echo $TPM_TYPE_HVM; > - else > - echo $TPM_TYPE_PVM; > - fi > - fi > -} > - > -# ------------------ Command handlers ----------------- > - > -# Create new vtpm instance & set it up for use > -function vtpm_create () { > - # Creation is handled implicitly by the manager on first setup > - # so just set it up for use > - $(vtpm_start $1) > -} > - > -# Setup vtpm instance for use. > -function vtpm_start() { > - local vmtype=$(vtpm_get_type); > - $(vtpm_manager_cmd $TPM_CMD_OPEN$vmtype $1) > -} > - > -function vtpm_resume() { > - local vmtype=$(vtpm_get_type); > - $(vtpm_manager_cmd $TPM_CMD_RESM$vmtype $1) > -} > - > -# Reset the vtpm AKA clear PCRs > -function vtpm_reset() { > - #not used by current implemenation > - true > -} > - > -# Shutdown the vtpm while the vm is down > -# This could be a suspend of shutdown > -# we cannot distinquish, so save the state > -# and decide on startup if we should keep is > -function vtpm_suspend() { > - $(vtpm_manager_cmd $TPM_CMD_CLOS $1) > -} > - > - > -function vtpm_delete() { > - local inst=$1 > - if $(vtpm_manager_cmd $TPM_CMD_DELE $inst); then > - rm -f /var/vtpm/vtpm_dm_$1.data > - true > - else > - vtpm_fatal_error=1 > - false > - fi > -} > - > -# Perform a migration step. This function differentiates between migration > -# to the local host or to a remote machine. > -# Parameters: > -# 1st: destination host to migrate to > -# 2nd: name of the domain to migrate > -# 3rd: the migration step to perform > -function vtpm_migrate() { > - local instance res > - > - instance=$(vtpmdb_find_instance $2) > - if [ "$instance" == "" ]; then > - log err "VTPM Migratoin failed. Unable to translation of domain name" > - echo "Error: VTPM Migration failed while looking up instance number" > - fi > - > - case "$3" in > - 0) > - #Incicate migration supported > - echo "0" > - ;; > - > - 1) > - # Get Public Key from Destination > - # Call vtpm_manager's migration part 1 > - claim_lock vtpm_mgr > - $VTPM_MIG $1 $2 $instance $3 > - release_lock vtpm_mgr > - ;; > - > - 2) > - # Call manager's migration step 2 and send result to destination > - # If successful remove from db > - claim_lock vtpm_mgr > - $VTPM_MIG $1 $2 $instance $3 > - release_lock vtpm_mgr > - ;; > - > - 3) > - if `ps x | grep "$VTPM_MIG $1"`; then > - log err "VTPM Migration failed to complete." > - echo "Error: VTPM Migration failed to complete." > - fi > - ;; > - esac > - > -} > - > - > -function vtpm_migrate_recover() { > - echo "Error: Recovery not supported yet" > -} > - > -function vtpm_migrate_local() { > - echo "Error: local vTPM migration not supported" > -} > diff --git a/tools/hotplug/Linux/vtpm-migration.sh b/tools/hotplug/Linux/vtpm-migration.sh > deleted file mode 100644 > index 7e38ae2..0000000 > --- a/tools/hotplug/Linux/vtpm-migration.sh > +++ /dev/null > @@ -1,19 +0,0 @@ > -# > -# Copyright (c) 2005 IBM Corporation > -# > -# This library is free software; you can redistribute it and/or > -# modify it under the terms of version 2.1 of the GNU Lesser General Public > -# License as published by the Free Software Foundation. > -# > -# This library is distributed in the hope that it will be useful, > -# but WITHOUT ANY WARRANTY; without even the implied warranty of > -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > -# Lesser General Public License for more details. > -# > -# You should have received a copy of the GNU Lesser General Public > -# License along with this library; if not, write to the Free Software > -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA > -# > - > -dir=$(dirname "$0") > -. "$dir/vtpm-common.sh" > diff --git a/tools/hotplug/Linux/xen-backend.rules b/tools/hotplug/Linux/xen-backend.rules > index c591a3f..a0d409e 100644 > --- a/tools/hotplug/Linux/xen-backend.rules > +++ b/tools/hotplug/Linux/xen-backend.rules > @@ -1,6 +1,5 @@ > SUBSYSTEM=="xen-backend", KERNEL=="tap*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/blktap $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vbd*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/block $env{ACTION}" > -SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vif2-*", RUN+="/etc/xen/scripts/vif2 $env{ACTION}" > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="online", RUN+="/etc/xen/scripts/vif-setup online type_if=vif" > SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="offline", RUN+="/etc/xen/scripts/vif-setup offline type_if=vif" > diff --git a/tools/vtpm/Makefile b/tools/vtpm/Makefile > deleted file mode 100644 > index 7b3efa5..0000000 > --- a/tools/vtpm/Makefile > +++ /dev/null > @@ -1,74 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../.. > - > -# Base definitions and rules > -include $(XEN_ROOT)/tools/vtpm/Rules.mk > - > -# Dir name for emulator (as dom0 tpm driver) > -TPM_EMULATOR_DIR = tpm_emulator > -# Dir name for vtpm instance > -VTPM_DIR = vtpm > -ORIG_DIR = orig > - > -# Emulator tarball name > -TPM_EMULATOR_NAME = tpm_emulator-0.5.1 > -TPM_EMULATOR_TARFILE = $(TPM_EMULATOR_NAME).tar.gz > - > -GMP_HEADER = /usr/include/gmp.h > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: build_sub > - > -.PHONY: install > -install: build > - $(MAKE) -C $(VTPM_DIR) install-recursive > - > -.PHONY: clean > -clean: > - @if [ -d $(TPM_EMULATOR_DIR) ]; \ > - then $(MAKE) -C $(TPM_EMULATOR_DIR) clean; \ > - fi > - @if [ -d $(VTPM_DIR) ]; \ > - then $(MAKE) -C $(VTPM_DIR) clean; \ > - fi > - > -.PHONY: mrproper > -mrproper: > - rm -f $(TPM_EMULATOR_TARFILE) tpm_emulator.patch.old vtpm.patch.old > - rm -rf $(TPM_EMULATOR_DIR) $(VTPM_DIR) $(ORIG_DIR) > - > -# Download Swiss emulator > -$(TPM_EMULATOR_TARFILE): > - wget http://download.berlios.de/tpm-emulator/$(TPM_EMULATOR_TARFILE) > - > -# Create vtpm dirs > -$(VTPM_DIR)/tpmd/tpmd: $(TPM_EMULATOR_TARFILE) vtpm-0.5.1.patch > - rm -rf $(VTPM_DIR) > - tar -xzf $(TPM_EMULATOR_TARFILE) > - mv $(TPM_EMULATOR_NAME) $(VTPM_DIR) > - > - set -e; cd $(VTPM_DIR); \ > - patch -p1 < ../vtpm-0.5.1.patch; \ > - patch -p1 < ../vtpm-0.5.1-LDLIBS.patch > - > -orig: $(TPM_EMULATOR_TARFILE) > - mkdir $(ORIG_DIR); > - set -e; cd $(ORIG_DIR); \ > - tar -xzf ../$(TPM_EMULATOR_TARFILE); > - > -updatepatches: clean orig > - find $(VTPM_DIR) -name "*.orig" -print | xargs rm -f; > - mv vtpm.patch vtpm.patch.old; > - diff -uprN $(TPM_EMULATOR_DIR) $(VTPM_DIR) > vtpm.patch || true; > - > -.PHONY: build_sub > -build_sub: $(VTPM_DIR)/tpmd/tpmd > - set -e; if [ -e $(GMP_HEADER) ]; then \ > - $(MAKE) -C $(VTPM_DIR) version; \ > - $(MAKE) -C $(VTPM_DIR) all-recursive; \ > - else \ > - echo "=== Unable to build VTPMs. libgmp could not be found."; \ > - fi > - > diff --git a/tools/vtpm/README b/tools/vtpm/README > deleted file mode 100644 > index 2008cbd..0000000 > --- a/tools/vtpm/README > +++ /dev/null > @@ -1,45 +0,0 @@ > - > -Directory Structure > -=================== > -tools/vtpm/tpm_emulator-0.2b.tar.gz -> TPM Emulator downloaded at build time that will > - be patched and used for our vtpms > -tools/vtpm/vtpm.patch -> patch applied to tpm_emulator to make vtpm > -tools/vtpm/vtpm/ -> (created on build) tpm_emulator moved to ring 3, > - listens on a pair of fifos for TPM commands, > - persistent state is sent via named fifo to vtpm > - manager, which encrypts it and protects it. > -tools/vtpm/tpm_emulator.patch -> To allow for debugging and testing on non-TPM > - platforms, this patches the emulator to allow > - it to be inserted into the dom0 kernel > -tools/vtpm/tpm_emulator-0.2 -> (created on build) directory containing patched emulator > - > -Compile Flags > -=================== > -VTPM_MULTI_VM -> Defined (not finished): VTPMs run in their own VMs > - Not Defined (default): VTPMs are processes > - > -Requirements > -============ > -- xen-unstable > -- IBM frontend/backend vtpm driver patch > -- vtpm_managerd > -- GNU MP Big number library (GMP) > - > -vtpmd Flow (for vtpm_manager. vtpmd never run by default) > -============================ > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > -- VTPM Manager listens to TPM BE. > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > -- When the manager receives the open message from the BE, it launches a vtpm > -- Xend allows the VM to continue booting. > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > -- The fifo listener begins listening for the reply from vtpm for the request. > -- Vtpm processes request and replies to manager over shared named fifo. > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > - > -tpm_emulator flow > -================== > -Read documentation in tpm_emulator-0.2 directory > diff --git a/tools/vtpm/Rules.mk b/tools/vtpm/Rules.mk > deleted file mode 100644 > index 548cff0..0000000 > --- a/tools/vtpm/Rules.mk > +++ /dev/null > @@ -1,26 +0,0 @@ > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > -include $(XEN_ROOT)/tools/Rules.mk > - > -# > -# Tool definitions > -# > - > -# General compiler flags > -CFLAGS = -Werror -g3 > - > -# Generic project files > -HDRS = $(wildcard *.h) > -SRCS = $(wildcard *.c) > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > - > -# Generic (non-header) dependencies > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm/Rules.mk > - > -$(OBJS): $(SRCS) > - > --include $(DEPS) > - > -BUILD_EMULATOR = y > - > -# Make sure these are just rules > -.PHONY : all build install clean > diff --git a/tools/vtpm/tpm_emulator.patch b/tools/vtpm/tpm_emulator.patch > deleted file mode 100644 > index c34c665..0000000 > --- a/tools/vtpm/tpm_emulator.patch > +++ /dev/null > @@ -1,1919 +0,0 @@ > -diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS > ---- orig/tpm_emulator-0.4/AUTHORS 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/AUTHORS 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,2 +1,3 @@ > - Mario Strasser > - Heiko Stamer [DAA] > -+INTEL Corp <> [Dropped to Ring3] > -diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog > ---- orig/tpm_emulator-0.4/ChangeLog 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/ChangeLog 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,3 +1,6 @@ > -+????-??-?? Intel Corp > -+ * Moved module out of kernel to run as a ring 3 app > -+ > - 2006-06-23 Mario Strasser > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > - persistent data adapted > -diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c > ---- orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/crypto/gmp_kernel_wrapper.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -24,15 +25,10 @@ int __gmp_junk; > - void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename, > - int linenum, const char *expr) > - { > -- panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n", > -+ error("%s:%d: GNU MP assertion failed: %s\n", > - filename, linenum, expr); > - } > - > --void __attribute__ ((regparm(0))) abort(void) > --{ > -- panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n"); > --} > -- > - /* overwrite GNU MP random functions (used by mpz/millerrabin.c) */ > - > - void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate, > -@@ -77,20 +73,19 @@ void __attribute__ ((regparm(0))) mpz_ur > - > - void __attribute__ ((regparm(0))) *kernel_allocate(size_t size) > - { > -- void *ret = (void*)kmalloc(size, GFP_KERNEL); > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME > -- "GMP: cannot allocate memory (size=%u)\n", size); > -+ void *ret = (void*)malloc(size); > -+ if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size); > - return ret; > - } > - > - void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr, > - size_t old_size, size_t new_size) > - { > -- void *ret = (void*)kmalloc(new_size, GFP_KERNEL); > -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory " > -- "(old_size=%u new_size=%u)\n", old_size, new_size); > -+ void *ret = (void*)malloc(new_size); > -+ if (!ret) error("GMP: Cannot reallocate memory " > -+ "(old_size=%Zu new_size=%Zu)\n", old_size, new_size); > - memcpy(ret, oldptr, old_size); > -- kfree(oldptr); > -+ free(oldptr); > - return ret; > - } > - > -@@ -99,7 +94,7 @@ void __attribute__ ((regparm(0))) kernel > - /* overwrite used memory */ > - if (blk_ptr != NULL) { > - memset(blk_ptr, 0, blk_size); > -- kfree(blk_ptr); > -+ free(blk_ptr); > - } > - } > - > -diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c > ---- orig/tpm_emulator-0.4/crypto/rsa.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/crypto/rsa.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -381,7 +382,7 @@ static int encode_message(int type, uint > - msg[0] = 0x00; > - get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH); > - sha1_init(&ctx); > -- sha1_update(&ctx, "TCPA", 4); > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > - sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]); > - memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00, > - msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2); > -@@ -429,7 +430,7 @@ static int decode_message(int type, uint > - mask_generation(&msg[1], SHA1_DIGEST_LENGTH, > - &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1); > - sha1_init(&ctx); > -- sha1_update(&ctx, "TCPA", 4); > -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); > - sha1_final(&ctx, &msg[1]); > - if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH], > - SHA1_DIGEST_LENGTH) != 0) return -1; > -diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c > ---- orig/tpm_emulator-0.4/linux_module.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/linux_module.c 1969-12-31 16:00:00.000000000 -0800 > -@@ -1,195 +0,0 @@ > --/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > -- * Copyright (C) 2004 Mario Strasser , > -- * > -- * This module is free software; you can redistribute it and/or modify > -- * it under the terms of the GNU General Public License as published > -- * by the Free Software Foundation; either version 2 of the License, > -- * or (at your option) any later version. > -- * > -- * This module is distributed in the hope that it will be useful, > -- * but WITHOUT ANY WARRANTY; without even the implied warranty of > -- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > -- * GNU General Public License for more details. > -- * > -- * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $ > -- */ > -- > --#include > --#include > --#include > --#include > --#include > --#include "linux_module.h" > --#include "tpm/tpm_emulator.h" > -- > --MODULE_LICENSE("GPL"); > --MODULE_AUTHOR("Mario Strasser "); > --MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator"); > --MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME); > -- > --/* module startup parameters */ > --char *startup = "save"; > --module_param(startup, charp, 0444); > --MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. " > -- "Possible values are 'clear', 'save' (default) and 'deactivated."); > --char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2"; > --module_param(storage_file, charp, 0644); > --MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage " > -- "file of the TPM."); > -- > --/* TPM lock */ > --static struct semaphore tpm_mutex; > -- > --/* TPM command response */ > --static struct { > -- uint8_t *data; > -- uint32_t size; > --} tpm_response; > -- > --/* module state */ > --#define STATE_IS_OPEN 0 > --static uint32_t module_state; > --static struct timespec old_time; > -- > --static int tpm_open(struct inode *inode, struct file *file) > --{ > -- debug("%s()", __FUNCTION__); > -- if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY; > -- return 0; > --} > -- > --static int tpm_release(struct inode *inode, struct file *file) > --{ > -- debug("%s()", __FUNCTION__); > -- clear_bit(STATE_IS_OPEN, (void*)&module_state); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) { > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return 0; > --} > -- > --static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos) > --{ > -- debug("%s(%d)", __FUNCTION__, count); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) { > -- count = min(count, (size_t)tpm_response.size - (size_t)*ppos); > -- count -= copy_to_user(buf, &tpm_response.data[*ppos], count); > -- *ppos += count; > -- if ((size_t)tpm_response.size == (size_t)*ppos) { > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } > -- } else { > -- count = 0; > -- } > -- up(&tpm_mutex); > -- return count; > --} > -- > --static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos) > --{ > -- debug("%s(%d)", __FUNCTION__, count); > -- down(&tpm_mutex); > -- *ppos = 0; > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > -- if (tpm_handle_command(buf, count, &tpm_response.data, > -- &tpm_response.size) != 0) { > -- count = -EILSEQ; > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return count; > --} > -- > --#define TPMIOC_CANCEL _IO('T', 0x00) > --#define TPMIOC_TRANSMIT _IO('T', 0x01) > -- > --static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) > --{ > -- debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg); > -- if (cmd == TPMIOC_TRANSMIT) { > -- uint32_t count = ntohl(*(uint32_t*)(arg + 2)); > -- down(&tpm_mutex); > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > -- if (tpm_handle_command((char*)arg, count, &tpm_response.data, > -- &tpm_response.size) == 0) { > -- tpm_response.size -= copy_to_user((char*)arg, tpm_response.data, > -- tpm_response.size); > -- kfree(tpm_response.data); > -- tpm_response.data = NULL; > -- } else { > -- tpm_response.size = 0; > -- tpm_response.data = NULL; > -- } > -- up(&tpm_mutex); > -- return tpm_response.size; > -- } > -- return -1; > --} > -- > --struct file_operations fops = { > -- .owner = THIS_MODULE, > -- .open = tpm_open, > -- .release = tpm_release, > -- .read = tpm_read, > -- .write = tpm_write, > -- .ioctl = tpm_ioctl, > --}; > -- > --static struct miscdevice tpm_dev = { > -- .minor = TPM_DEVICE_MINOR, > -- .name = TPM_DEVICE_NAME, > -- .fops = &fops, > --}; > -- > --int __init init_tpm_module(void) > --{ > -- int res = misc_register(&tpm_dev); > -- if (res != 0) { > -- error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR); > -- return res; > -- } > -- /* initialize variables */ > -- sema_init(&tpm_mutex, 1); > -- module_state = 0; > -- tpm_response.data = NULL; > -- old_time = current_kernel_time(); > -- /* initialize TPM emulator */ > -- if (!strcmp(startup, "clear")) { > -- tpm_emulator_init(1); > -- } else if (!strcmp(startup, "save")) { > -- tpm_emulator_init(2); > -- } else if (!strcmp(startup, "deactivated")) { > -- tpm_emulator_init(3); > -- } else { > -- error("invalid startup mode '%s'; must be 'clear', " > -- "'save' (default) or 'deactivated", startup); > -- misc_deregister(&tpm_dev); > -- return -EINVAL; > -- } > -- return 0; > --} > -- > --void __exit cleanup_tpm_module(void) > --{ > -- tpm_emulator_shutdown(); > -- misc_deregister(&tpm_dev); > -- if (tpm_response.data != NULL) kfree(tpm_response.data); > --} > -- > --module_init(init_tpm_module); > --module_exit(cleanup_tpm_module); > -- > --uint64_t tpm_get_ticks(void) > --{ > -- struct timespec new_time = current_kernel_time(); > -- uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000 > -- + (new_time.tv_nsec - old_time.tv_nsec) / 1000; > -- old_time = new_time; > -- return (ticks > 0) ? ticks : 1; > --} > -- > -diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h > ---- orig/tpm_emulator-0.4/linux_module.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/linux_module.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -17,54 +18,62 @@ > - #ifndef _LINUX_MODULE_H_ > - #define _LINUX_MODULE_H_ > - > --#include > --#include > --#include > -+#include > -+#include > -+#include > -+#include > - #include > --#include > --#include > --#include > --#include > - > --/* module settings */ > -+#include > -+#define __BYTEORDER_HAS_U64__ > -+#ifdef LITTLE_ENDIAN > -+ #include > -+#else > -+ #include > -+#endif > - > -+/* module settings */ > -+#define min(A,B) ((A)<(B)?(A):(B)) > -+#ifndef STR > - #define STR(s) __STR__(s) > - #define __STR__(s) #s > -+#endif > - #include "tpm_version.h" > - > - #define TPM_DEVICE_MINOR 224 > - #define TPM_DEVICE_NAME "tpm" > - #define TPM_MODULE_NAME "tpm_emulator" > - > --/* debug and log output functions */ > -- > - #ifdef DEBUG > --#define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > - #else > - #define debug(fmt, ...) > - #endif > --#define info(fmt, ...) printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \ > -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > -+ __FILE__, __LINE__, ## __VA_ARGS__) > - > - /* memory allocation */ > - > - static inline void *tpm_malloc(size_t size) > - { > -- return kmalloc(size, GFP_KERNEL); > -+ return malloc(size); > - } > - > - static inline void tpm_free(const void *ptr) > - { > -- if (ptr != NULL) kfree(ptr); > -+ if (ptr != NULL) free( (void *) ptr); > - } > - > - /* random numbers */ > - > -+//FIXME; > -+void get_random_bytes(void *buf, int nbytes); > -+ > - static inline void tpm_get_random_bytes(void *buf, int nbytes) > - { > - get_random_bytes(buf, nbytes); > -@@ -84,9 +93,9 @@ uint64_t tpm_get_ticks(void); > - #define CPU_TO_LE16(x) __cpu_to_le16(x) > - > - #define BE64_TO_CPU(x) __be64_to_cpu(x) > --#define LE64_TO_CPU(x) __be64_to_cpu(x) > -+#define LE64_TO_CPU(x) __le64_to_cpu(x) > - #define BE32_TO_CPU(x) __be32_to_cpu(x) > --#define LE32_TO_CPU(x) __be32_to_cpu(x) > -+#define LE32_TO_CPU(x) __le32_to_cpu(x) > - #define BE16_TO_CPU(x) __be16_to_cpu(x) > - #define LE16_TO_CPU(x) __le16_to_cpu(x) > - > -diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile > ---- orig/tpm_emulator-0.4/Makefile 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/Makefile 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,24 +1,40 @@ > - # Software-Based Trusted Platform Module (TPM) Emulator for Linux > - # Copyright (C) 2004 Mario Strasser > -+# Copyright (C) 2006 INTEL Corp. > - # > - # $Id: Makefile 115 2006-06-23 10:36:44Z mast $ > - > --# kernel settings > --KERNEL_RELEASE := $(shell uname -r) > --KERNEL_BUILD := /lib/modules/$(KERNEL_RELEASE)/build > --MOD_SUBDIR := misc > -+COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > - > - # module settings > --MODULE_NAME := tpm_emulator > -+BIN := tpm_emulator > - VERSION_MAJOR := 0 > - VERSION_MINOR := 4 > - VERSION_BUILD := $(shell date +"%s") > - > --# enable/disable DEBUG messages > --EXTRA_CFLAGS += -Wall -DDEBUG -g > -+# Installation program and options > -+INSTALL = install > -+INSTALL_PROG = $(INSTALL) -m0755 > -+INSTALL_DIR = $(INSTALL) -d -m0755 > -+ > -+# Xen tools installation directory > -+TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > -+ > -+CC := gcc > -+CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > -+CFLAGS += -I. -Itpm > -+ > -+# Is the simulator running in it's own vm? > -+#CFLAGS += -DVTPM_MULTI_VM > -+ > -+ifeq ($(COMPILE_ARCH),x86_64) > -+LIBDIR = lib64 > -+else > -+LIBDIR = lib > -+endif > - > - # GNU MP configuration > --GMP_LIB := /usr/lib/libgmp.a > -+GMP_LIB := /usr/$(LIBDIR)/libgmp.a > - GMP_HEADER := /usr/include/gmp.h > - > - # sources and objects > -@@ -27,38 +43,32 @@ DIRS := . crypto tpm > - SRCS := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c)) > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > - SRCS += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h)) > --DISTSRC := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS) > --DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR) > - > --obj-m := $(MODULE_NAME).o > --$(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > -+obj-m := $(BIN) > -+$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a > - > - EXTRA_CFLAGS += -I$(src) -I$(src)/crypto -I$(src)/tpm > - > - # do not print "Entering directory ..." > - MAKEFLAGS += --no-print-directory > - > --all: $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules > -+all: $(BIN) > - > --install: > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install > -- test -d /var/tpm || mkdir /var/tpm > -- test -c /dev/tpm || mknod /dev/tpm c 10 224 > -- chmod 666 /dev/tpm > -- depmod -a > -+$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS) > -+ $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN) > -+ > -+%.o: %.c > -+ $(CC) $(CFLAGS) -c $< -o $@ > -+ > -+install: $(BIN) > -+ $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > -+ @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > - > - clean: > -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean > -- rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a > -+ rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > - > --dist: $(DISTSRC) > -- rm -rf $(DISTDIR) > -- mkdir $(DISTDIR) > -- cp --parents $(DISTSRC) $(DISTDIR)/ > -- rm -f $(DISTDIR)/crypto/gmp.h > -- tar -chzf $(DISTDIR).tar.gz $(DISTDIR) > -- rm -rf $(DISTDIR) > -+mrproper: clean > -+ rm -f $(BIN) tpm_version.h > - > - $(src)/crypto/libgmp.a: > - test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a > -@@ -88,4 +98,3 @@ version: > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > - > - .PHONY: all install clean dist gmp version > -- > -diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README > ---- orig/tpm_emulator-0.4/README 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/README 2006-07-24 14:35:35.000000000 -0700 > -@@ -13,7 +13,8 @@ $Id: README 113 2006-06-18 12:38:13Z hst > - Copyright > - -------------------------------------------------------------------------- > - Copyright (C) 2004 Mario Strasser and Swiss Federal > --Institute of Technology (ETH) Zurich. > -+ Institute of Technology (ETH) Zurich. > -+Copyright (C) 2005 INTEL Corp > - > - This program is free software; you can redistribute it and/or modify > - it under the terms of the GNU General Public License as published by > -@@ -43,6 +44,12 @@ Example: > - GMP_LIB := /usr/lib/libgmp.a > - GMP_HEADER := /usr/include/gmp.h > - > -+GNU MP Library on 64 bit Systems > -+-------------------------------------------------------------------------- > -+Some 64-bit kernels have problems with importing the user-space gmp > -+library (/usr/lib*/libgmp.a) into kernel space. These kernels will require > -+that the gmp library be recompiled for kernel space with -mcmodel=kernel. > -+ > - Installation > - -------------------------------------------------------------------------- > - The compilation and installation process uses the build environment for > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_capability.c tpm_emulator/tpm/tpm_capability.c > ---- orig/tpm_emulator-0.4/tpm/tpm_capability.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_capability.c 2007-12-28 22:50:19.000000000 +0900 > -@@ -701,7 +701,10 @@ TPM_RESULT TPM_GetCapabilityOwner(TPM_VE > - TPM_RESULT res; > - > - info("TPM_GetCapabilityOwner()"); > -- > -+ > -+ if (!tpmData.permanent.flags.owned) { > -+ return TPM_NOSRK; > -+ } > - /* Verify owner authorization */ > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > - if (res != TPM_SUCCESS) return res; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c tpm_emulator/tpm/tpm_cmd_handler.c > ---- orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_cmd_handler.c 2007-09-12 20:23:00.000000000 +0900 > -@@ -565,7 +565,7 @@ static TPM_RESULT execute_TPM_Seal(TPM_R > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > -+ || (pcrInfoSize >0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > - || len != 0) return TPM_BAD_PARAMETER; > -@@ -798,7 +798,7 @@ static TPM_RESULT execute_TPM_Sealx(TPM_ > - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) > - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) > - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) > -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) > -+ || (pcrInfoSize > 0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) > - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) > - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) > - || len != 0) return TPM_BAD_PARAMETER; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c > ---- orig/tpm_emulator-0.4/tpm/tpm_credentials.c 2006-06-23 19:37:07.000000000 +0900 > -+++ tpm_emulator/tpm/tpm_credentials.c 2007-09-12 20:23:30.000000000 +0900 > -@@ -47,20 +47,20 @@ int tpm_compute_pubkey_checksum(TPM_NONC > - > - TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey) > - { > -- UINT32 key_length; > -+ size_t key_length; > - if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT; > - /* setup TPM_PUBKEY structure */ > -- key_length = tpmData.permanent.data.endorsementKey.size; > -- pubEndorsementKey->pubKey.keyLength = key_length >> 3; > -+ pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3; > - pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength); > - if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL; > - rsa_export_modulus(&tpmData.permanent.data.endorsementKey, > -- pubEndorsementKey->pubKey.key, > -- &pubEndorsementKey->pubKey.keyLength); > -+ pubEndorsementKey->pubKey.key, > -+ &key_length); > -+ pubEndorsementKey->pubKey.keyLength = key_length; > - pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA; > - pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE; > -- pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length; > -+ pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length << 3; > - pubEndorsementKey->algorithmParms.parms.rsa.numPrimes = 2; > - pubEndorsementKey->algorithmParms.parms.rsa.exponentSize = 0; > - pubEndorsementKey->algorithmParms.parms.rsa.exponent = NULL; > -@@ -175,6 +175,7 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > - { > - TPM_RESULT res; > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > -+ size_t key_length; > - info("TPM_OwnerReadInternalPub()"); > - /* verify authorization */ > - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); > -@@ -186,7 +187,8 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ > - publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength); > - if (publicPortion->pubKey.key == NULL) return TPM_FAIL; > - rsa_export_modulus(&srk->key, publicPortion->pubKey.key, > -- &publicPortion->pubKey.keyLength); > -+ &key_length); > -+ publicPortion->pubKey.keyLength = key_length; > - publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA; > - publicPortion->algorithmParms.encScheme = srk->encScheme; > - publicPortion->algorithmParms.sigScheme = srk->sigScheme; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c > ---- orig/tpm_emulator-0.4/tpm/tpm_crypto.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_crypto.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -182,7 +182,8 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > - TPM_KEY_DATA *cert, *key; > - sha1_ctx_t sha1_ctx; > - BYTE *buf, *p; > -- UINT32 length; > -+ UINT32 length32; > -+ size_t length; > - info("TPM_CertifyKey()"); > - /* get keys */ > - cert = tpm_get_key(certHandle); > -@@ -264,14 +265,15 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - p = buf = tpm_malloc(length); > -+ length32=(UINT32) length; > - if (buf == NULL > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > - return TPM_FAIL; > - } > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - sha1_init(&sha1_ctx); > -- sha1_update(&sha1_ctx, buf, length); > -+ sha1_update(&sha1_ctx, buf, (size_t) length); > - sha1_final(&sha1_ctx, buf); > - res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize); > - tpm_free(buf); > -@@ -292,7 +294,8 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > - TPM_KEY_DATA *cert, *key; > - sha1_ctx_t sha1_ctx; > - BYTE *buf, *p; > -- UINT32 length; > -+ size_t length; > -+ UINT32 length32; > - info("TPM_CertifyKey2()"); > - /* get keys */ > - cert = tpm_get_key(certHandle); > -@@ -362,8 +365,9 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL > - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ > - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); > - p = buf = tpm_malloc(length); > -+ length32 = (UINT32) length; > - if (buf == NULL > -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { > -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { > - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); > - return TPM_FAIL; > - } > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c > ---- orig/tpm_emulator-0.4/tpm/tpm_daa.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_daa.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -716,14 +716,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -805,14 +805,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1489,14 +1489,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1712,14 +1712,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -1793,14 +1793,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -2918,14 +2918,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -3143,7 +3143,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > - sizeof(session->DAA_session.DAA_digest)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_update(&sha1, inputData1, inputSize1); > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > - } > -@@ -3172,7 +3172,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, > - sizeof(session->DAA_session.DAA_digest)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE*) "\x00", 1); > - rsa_export_modulus(&aikData->key, scratch, &size); > - sha1_update(&sha1, scratch, size); > - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); > -@@ -3229,14 +3229,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -@@ -3309,14 +3309,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x00", 1); > -+ sha1_update(&sha1, (BYTE *) "\x00", 1); > - sha1_final(&sha1, scratch); > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, > - sizeof(session->DAA_tpmSpecific.DAA_rekey)); > - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, > - sizeof(session->DAA_tpmSpecific.DAA_count)); > -- sha1_update(&sha1, "\x01", 1); > -+ sha1_update(&sha1, (BYTE *) "\x01", 1); > - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); > - mpz_init(f), mpz_init(q); > - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c > ---- orig/tpm_emulator-0.4/tpm/tpm_data.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_data.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -40,6 +40,7 @@ static inline void init_pcr_attr(int pcr > - void tpm_init_data(void) > - { > - /* endorsement key */ > -+#ifndef TPM_GENERATE_EK > - uint8_t ek_n[] = "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7" > - "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93" > - "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a" > -@@ -77,6 +78,8 @@ void tpm_init_data(void) > - "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b" > - "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47" > - "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f"; > -+#endif > -+ > - int i; > - /* reset all data to NULL, FALSE or 0 */ > - memset(&tpmData, 0, sizeof(tpmData)); > -@@ -152,44 +155,43 @@ void tpm_release_data(void) > - > - #ifdef TPM_STORE_TO_FILE > - > --#include > --#include > --#include > -+#include > -+#include > -+#include > -+#include > - > - #define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > - > - static int write_to_file(uint8_t *data, size_t data_length) > - { > - int res; > -- struct file *fp; > -- mm_segment_t old_fs = get_fs(); > -- fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- if (IS_ERR(fp)) return -1; > -- set_fs(get_ds()); > -- res = fp->f_op->write(fp, data, data_length, &fp->f_pos); > -- set_fs(old_fs); > -- filp_close(fp, NULL); > -+ int fp; > -+ fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -+ res = write(fp, data, data_length); > -+ close(fp); > - return (res == data_length) ? 0 : -1; > - } > - > - static int read_from_file(uint8_t **data, size_t *data_length) > - { > - int res; > -- struct file *fp; > -- mm_segment_t old_fs = get_fs(); > -- fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0); > -- if (IS_ERR(fp)) return -1; > -- *data_length = (size_t)fp->f_dentry->d_inode->i_size; > -- /* *data_length = i_size_read(fp->f_dentry->d_inode); */ > -+ int fp, file_status; > -+ struct stat file_info; > -+ fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > -+ file_status = fstat(fp, &file_info); > -+ if (file_status < 0) { > -+ close(fp); > -+ return -1; > -+ } > -+ > -+ *data_length = file_info.st_size; > - *data = tpm_malloc(*data_length); > - if (*data == NULL) { > -- filp_close(fp, NULL); > -+ close(fp); > - return -1; > - } > -- set_fs(get_ds()); > -- res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos); > -- set_fs(old_fs); > -- filp_close(fp, NULL); > -+ res = read(fp, *data, *data_length); > -+ close(fp); > - if (res != *data_length) { > - tpm_free(*data); > - return -1; > -@@ -216,23 +218,30 @@ static int read_from_file(uint8_t **data > - int tpm_store_permanent_data(void) > - { > - uint8_t *buf, *ptr; > -- size_t buf_length, len; > -+ UINT32 buf_length, len; > - > - /* marshal data */ > -- buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > -- + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2 > -- + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data); > -+ buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) > -+ + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) > -+ + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2 > -+ + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data) > -+ + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data) > -+ + sizeof_TPM_STANY_DATA(tpmData.stany.data); > - buf = ptr = tpm_malloc(buf_length); > - if (buf == NULL > - || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version) > - || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > - || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > -+ || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded) > - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned) > -- || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > -+ || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > -+ || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > -+ || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > - tpm_free(buf); > - return -1; > - } > -+ > - if (write_to_file(buf, buf_length - len)) { > - tpm_free(buf); > - return -1; > -@@ -244,31 +253,36 @@ int tpm_store_permanent_data(void) > - int tpm_restore_permanent_data(void) > - { > - uint8_t *buf, *ptr; > -- size_t buf_length, len; > -+ size_t buf_length; > -+ UINT32 len; > - TPM_VERSION ver; > - > - /* read data */ > - if (read_from_file(&buf, &buf_length)) return -1; > - ptr = buf; > -- len = buf_length; > -+ len = (uint32_t) buf_length; > - /* unmarshal data */ > - if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver) > - || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION)) > - || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) > - || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) > -+ || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded) > - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned) > -- || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { > -+ || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) > -+ || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) > -+ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { > - tpm_free(buf); > - return -1; > - } > -+ > - tpm_free(buf); > - return 0; > - } > - > - int tpm_erase_permanent_data(void) > - { > -- int res = write_to_file("", 0); > -+ int res = write_to_file((uint8_t *) "", 0); > - return res; > - } > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c > ---- orig/tpm_emulator-0.4/tpm/tpm_deprecated.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_deprecated.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -50,7 +51,7 @@ TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA > - BYTE *ptr; > - UINT32 len; > - info("TPM_SaveKeyContext()"); > -- res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..", > -+ res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..", > - keyContextSize, &contextBlob); > - if (res != TPM_SUCCESS) return res; > - len = *keyContextSize; > -@@ -82,7 +83,7 @@ TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH > - BYTE *ptr; > - UINT32 len; > - info("TPM_SaveAuthContext()"); > -- res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.", > -+ res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.", > - authContextSize, &contextBlob); > - if (res != TPM_SUCCESS) return res; > - len = *authContextSize; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h > ---- orig/tpm_emulator-0.4/tpm/tpm_emulator.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_emulator.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,5 +1,6 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -22,7 +23,8 @@ > - /* TPM configuration */ > - #define TPM_STORE_TO_FILE 1 > - #undef TPM_STRONG_PERSISTENCE > --#undef TPM_GENERATE_EK > -+//#undef TPM_GENERATE_EK > -+#define TPM_GENERATE_EK > - #undef TPM_GENERATE_SEED_DAA > - > - #define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */ > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_marshalling.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1312,7 +1312,7 @@ int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * > - > - int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v) > - { > -- UINT32 m_len, e_len, q_len; > -+ size_t m_len, e_len, q_len; > - if (*length < sizeof_RSA((*v))) return -1; > - if (v->size > 0) { > - rsa_export_modulus(v, &(*ptr)[6], &m_len); > -@@ -1460,6 +1460,66 @@ int tpm_unmarshal_TPM_PERMANENT_DATA(BYT > - return 0; > - } > - > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > -+{ > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > -+ || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) > -+{ > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) > -+ || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > -+{ > -+ UINT32 i; > -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) > -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > -+ || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) > -+ || tpm_marshal_BOOL(ptr, length, v->auditSession) > -+ || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > -+ || tpm_marshal_UINT32(ptr, length, v->contextCount) > -+ || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > -+ if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > -+ } > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > -+ if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > -+ } > -+ if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; > -+ > -+ return 0; > -+} > -+ > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) > -+{ > -+ UINT32 i; > -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) > -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) > -+ || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) > -+ || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) > -+ || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) > -+ || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) > -+ || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; > -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { > -+ if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; > -+ } > -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { > -+ if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; > -+ } > -+ if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; > -+ > -+ return 0; > -+} > -+ > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) > - { > - if (tpm_marshal_BYTE(ptr, length, v->type) > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h > ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_marshalling.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -432,6 +432,12 @@ int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt > - int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > - int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); > - > -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); > -+ > -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); > -+ > - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > - int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c > ---- orig/tpm_emulator-0.4/tpm/tpm_owner.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_owner.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -108,7 +108,7 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > - TPM_RESULT res; > - rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey; > - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; > -- UINT32 buf_size = ek->size >> 3; > -+ size_t buf_size = ek->size >> 3, key_length; > - BYTE buf[buf_size]; > - > - info("TPM_TakeOwnership()"); > -@@ -173,7 +173,8 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO > - return TPM_FAIL; > - } > - rsa_export_modulus(&srk->key, srkPub->pubKey.key, > -- &srkPub->pubKey.keyLength); > -+ &key_length); > -+ srkPub->pubKey.keyLength = (UINT32) key_length; > - /* setup tpmProof and set state to owned */ > - tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce, > - sizeof(tpmData.permanent.data.tpmProof.nonce)); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c > ---- orig/tpm_emulator-0.4/tpm/tpm_startup.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_startup.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -41,26 +41,29 @@ void TPM_Init(TPM_STARTUP_TYPE startupTy > - TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType) > - { > - int i; > -+ int restore_fail; > - info("TPM_Startup(%d)", startupType); > - if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT; > -- /* reset STANY_FLAGS */ > -- SET_TO_ZERO(&tpmData.stany.flags); > -- tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > -- /* reset STANY_DATA (invalidates ALL sessions) */ > -- SET_TO_ZERO(&tpmData.stany.data); > -- tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > -- /* init session-context nonce */ > -- SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > -+ > -+ /* try and restore state to get EK, SRK, etc */ > -+ restore_fail = tpm_restore_permanent_data(); > -+ > - /* set data and flags according to the given startup type */ > - if (startupType == TPM_ST_CLEAR) { > -- /* if available, restore permanent data */ > -- tpm_restore_permanent_data(); > -+ /* reset STANY_FLAGS */ > -+ SET_TO_ZERO(&tpmData.stany.flags); > -+ tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; > -+ /* reset STANY_DATA (invalidates ALL sessions) */ > -+ SET_TO_ZERO(&tpmData.stany.data); > -+ tpmData.stany.data.tag = TPM_TAG_STANY_DATA; > -+ /* init session-context nonce */ > -+ SET_TO_RAND(&tpmData.stany.data.contextNonceSession); > - /* reset PCR values */ > - for (i = 0; i < TPM_NUM_PCR; i++) { > -- if (tpmData.permanent.data.pcrAttrib[i].pcrReset) > -- SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest); > -+ if (!tpmData.permanent.data.pcrAttrib[i].pcrReset) > -+ SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest); > - else > -- SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest); > -+ SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest); > - } > - /* reset STCLEAR_FLAGS */ > - SET_TO_ZERO(&tpmData.stclear.flags); > -@@ -79,7 +82,8 @@ TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE > - /* init key-context nonce */ > - SET_TO_RAND(&tpmData.stclear.data.contextNonceKey); > - } else if (startupType == TPM_ST_STATE) { > -- if (tpm_restore_permanent_data()) { > -+ /* restore must have been successful for TPM_ST_STATE */ > -+ if (restore_fail) { > - error("restoring permanent data failed"); > - tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed"; > - tpmData.permanent.flags.selfTestSucceeded = FALSE; > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c > ---- orig/tpm_emulator-0.4/tpm/tpm_storage.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_storage.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -58,6 +58,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - BYTE *enc, UINT32 *enc_size) > - { > - UINT32 len; > -+ size_t enc_size32 = *enc_size; > - BYTE *buf, *ptr; > - rsa_public_key_t pub_key; > - int scheme; > -@@ -72,7 +73,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - if (buf == NULL > - || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal) > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)), > -- enc, enc_size)) { > -+ enc, &enc_size32)) { > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return -1; > -@@ -85,7 +86,8 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke > - int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > - TPM_SEALED_DATA *seal, BYTE **buf) > - { > -- UINT32 len; > -+ size_t len; > -+ UINT32 len32; > - BYTE *ptr; > - int scheme; > - switch (key->encScheme) { > -@@ -96,8 +98,12 @@ int decrypt_sealed_data(TPM_KEY_DATA *ke > - len = enc_size; > - *buf = ptr = tpm_malloc(len); > - if (*buf == NULL > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > -- || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) { > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){ > -+ tpm_free(*buf); > -+ return -1; > -+ } > -+ len32 = len; > -+ if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) { > - tpm_free(*buf); > - return -1; > - } > -@@ -240,11 +246,12 @@ TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par > - > - TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize, > - BYTE *inData, TPM_AUTH *auth1, > -- UINT32 *outDataSize, BYTE **outData) > -+ UINT32 *outDataSize32, BYTE **outData) > - { > - TPM_RESULT res; > - TPM_KEY_DATA *key; > - int scheme; > -+ size_t outDataSize; > - > - info("TPM_UnBind()"); > - /* get key */ > -@@ -262,8 +269,8 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > - /* the size of the input data muss be greater than zero */ > - if (inDataSize == 0) return TPM_BAD_PARAMETER; > - /* decrypt data */ > -- *outDataSize = inDataSize; > -- *outData = tpm_malloc(*outDataSize); > -+ outDataSize = inDataSize; > -+ *outData = tpm_malloc(outDataSize); > - if (*outData == NULL) return TPM_NOSPACE; > - switch (key->encScheme) { > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > -@@ -271,20 +278,21 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key > - default: tpm_free(*outData); return TPM_DECRYPT_ERROR; > - } > - if (rsa_decrypt(&key->key, scheme, inData, inDataSize, > -- *outData, outDataSize)) { > -+ *outData, &outDataSize)) { > - tpm_free(*outData); > - return TPM_DECRYPT_ERROR; > - } > - /* verify data if it is of type TPM_BOUND_DATA */ > - if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1 > - || key->keyUsage != TPM_KEY_LEGACY) { > -- if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > -+ if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { > - tpm_free(*outData); > - return TPM_DECRYPT_ERROR; > - } > -- *outDataSize -= 5; > -- memmove(*outData, &(*outData)[5], *outDataSize); > -+ outDataSize -= 5; > -+ memmove(*outData, &(*outData)[5], outDataSize); > - } > -+ *outDataSize32 = (UINT32) outDataSize; > - return TPM_SUCCESS; > - } > - > -@@ -334,12 +342,13 @@ int compute_pubkey_digest(TPM_PUBKEY *ke > - } > - > - int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store, > -- BYTE *enc, UINT32 *enc_size) > -+ BYTE *enc, UINT32 *enc_size32) > - { > - UINT32 len; > - BYTE *buf, *ptr; > - rsa_public_key_t pub_key; > - int scheme; > -+ size_t enc_size; > - switch (key->encScheme) { > - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; > - case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break; > -@@ -351,11 +360,12 @@ int encrypt_private_key(TPM_KEY_DATA *ke > - if (buf == NULL > - || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store) > - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)), > -- enc, enc_size)) { > -+ enc, &enc_size)) { > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return -1; > - } > -+ *enc_size32 = (UINT32) enc_size; > - tpm_free(buf); > - rsa_release_public_key(&pub_key); > - return 0; > -@@ -364,7 +374,8 @@ int encrypt_private_key(TPM_KEY_DATA *ke > - int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, > - TPM_STORE_ASYMKEY *store, BYTE **buf) > - { > -- UINT32 len; > -+ UINT32 len32; > -+ size_t len; > - BYTE *ptr; > - int scheme; > - switch (key->encScheme) { > -@@ -375,8 +386,12 @@ int decrypt_private_key(TPM_KEY_DATA *ke > - len = enc_size; > - *buf = ptr = tpm_malloc(len); > - if (*buf == NULL > -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) > -- || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) { > -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) { > -+ tpm_free(*buf); > -+ return -1; > -+ } > -+ len32 = (UINT32) len; > -+ if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { > - tpm_free(*buf); > - return -1; > - } > -@@ -394,7 +409,7 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - TPM_SESSION_DATA *session; > - TPM_STORE_ASYMKEY store; > - rsa_private_key_t rsa; > -- UINT32 key_length; > -+ size_t key_length; > - > - info("TPM_CreateWrapKey()"); > - /* get parent key */ > -@@ -450,11 +465,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - } > - } > - /* generate key and store it */ > -- key_length = keyInfo->algorithmParms.parms.rsa.keyLength; > -- if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL; > -- wrappedKey->pubKey.keyLength = key_length >> 3; > -+ if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength)) > -+ return TPM_FAIL; > -+ wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3; > - wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength); > -- store.privKey.keyLength = key_length >> 4; > -+ store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4; > - store.privKey.key = tpm_malloc(store.privKey.keyLength); > - wrappedKey->encDataSize = parent->key.size >> 3; > - wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize); > -@@ -466,9 +481,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN > - tpm_free(wrappedKey->encData); > - return TPM_NOSPACE; > - } > -- rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > -- &wrappedKey->pubKey.keyLength); > -- rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength); > -+ rsa_export_modulus(&rsa, wrappedKey->pubKey.key, > -+ &key_length); > -+ wrappedKey->pubKey.keyLength = (UINT32) key_length; > -+ rsa_export_prime1(&rsa, store.privKey.key, &key_length); > -+ store.privKey.keyLength = (UINT32) key_length; > - rsa_release_private_key(&rsa); > - /* compute the digest of the wrapped key (without encData) */ > - if (compute_key_digest(wrappedKey, &store.pubDataDigest)) { > -@@ -602,6 +619,7 @@ TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p > - > - int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms) > - { > -+ size_t key_length; > - parms->algorithmID = TPM_ALG_RSA; > - parms->encScheme = key->encScheme; > - parms->sigScheme = key->sigScheme; > -@@ -611,7 +629,8 @@ int tpm_setup_key_parms(TPM_KEY_DATA *ke > - parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize); > - if (parms->parms.rsa.exponent == NULL) return -1; > - rsa_export_exponent(&key->key, parms->parms.rsa.exponent, > -- &parms->parms.rsa.exponentSize); > -+ &key_length); > -+ parms->parms.rsa.exponentSize = (UINT32) key_length; > - parms->parmSize = 12 + parms->parms.rsa.exponentSize; > - return 0; > - } > -@@ -622,6 +641,7 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > - TPM_RESULT res; > - TPM_KEY_DATA *key; > - TPM_DIGEST digest; > -+ size_t key_length; > - info("TPM_GetPubKey()"); > - /* get key */ > - if (keyHandle == TPM_KH_SRK > -@@ -650,8 +670,8 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE > - pubKey->pubKey.keyLength = key->key.size >> 3; > - pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength); > - if (pubKey->pubKey.key == NULL) return TPM_NOSPACE; > -- rsa_export_modulus(&key->key, pubKey->pubKey.key, > -- &pubKey->pubKey.keyLength); > -+ rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length); > -+ pubKey->pubKey.keyLength = (UINT32) key_length; > - if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) { > - error("TPM_GetPubKey(): tpm_setup_key_parms() failed."); > - tpm_free(pubKey->pubKey.key); > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h > ---- orig/tpm_emulator-0.4/tpm/tpm_structures.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_structures.h 2006-07-24 14:35:35.000000000 -0700 > -@@ -1958,6 +1958,7 @@ typedef struct tdTPM_DAA_ISSUER { > - TPM_DIGEST DAA_digest_gamma; > - BYTE DAA_generic_q[26]; > - } TPM_DAA_ISSUER; > -+#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 ) > - > - /* > - * TPM_DAA_TPM ([TPM_Part2], Section 22.4) > -@@ -1973,6 +1974,7 @@ typedef struct tdTPM_DAA_TPM { > - TPM_DIGEST DAA_rekey; > - UINT32 DAA_count; > - } TPM_DAA_TPM; > -+#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4) > - > - /* > - * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5) > -@@ -1987,6 +1989,7 @@ typedef struct tdTPM_DAA_CONTEXT { > - BYTE DAA_scratch[256]; > - BYTE DAA_stage; > - } TPM_DAA_CONTEXT; > -+#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1) > - > - /* > - * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6) > -@@ -1998,6 +2001,7 @@ typedef struct tdTPM_DAA_JOINDATA { > - BYTE DAA_join_u1[138]; > - TPM_DIGEST DAA_digest_n0; > - } TPM_DAA_JOINDATA; > -+#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20) > - > - /* > - * TPM_DAA_BLOB ([TPM_Part2], Section 22.8) > -@@ -2202,6 +2206,7 @@ typedef struct tdTPM_STCLEAR_DATA { > - //UINT32 ownerReference; > - //BOOL disableResetLock; > - } TPM_STCLEAR_DATA; > -+#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4) > - > - /* > - * TPM_SESSION_DATA > -@@ -2238,6 +2243,11 @@ typedef struct tdTPM_DAA_SESSION_DATA { > - TPM_DAA_JOINDATA DAA_joinSession; > - TPM_HANDLE handle; > - } TPM_DAA_SESSION_DATA; > -+#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \ > -+ + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \ > -+ + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \ > -+ + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \ > -+ + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4) > - > - /* > - * TPM_STANY_DATA ([TPM_Part2], Section 7.6) > -@@ -2262,6 +2272,11 @@ typedef struct tdTPM_STANY_DATA { > - TPM_DAAHANDLE currentDAA; > - TPM_TRANSHANDLE transExclusive; > - } TPM_STANY_DATA; > -+#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \ > -+ + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \ > -+ + 4 + (4 * TPM_MAX_SESSION_LIST) \ > -+ + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \ > -+ + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4) > - > - /* > - * TPM_DATA > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c > ---- orig/tpm_emulator-0.4/tpm/tpm_testing.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_testing.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -95,24 +96,24 @@ static int tpm_test_sha1(void) > - struct { > - uint8_t *data; uint32_t repetitions; uint8_t *digest; > - } test_cases[] = {{ > -- "abc", 1, > -- "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > -+ (uint8_t*)"abc", 1, > -+ (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" > - }, { > -- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > -- "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > -+ (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, > -+ (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" > - }, { > -- "a", 1000000, > -- "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > -+ (uint8_t*)"a", 1000000, > -+ (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" > - }, { > -- "0123456701234567012345670123456701234567012345670123456701234567", 10, > -- "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > -+ (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10, > -+ (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" > - }}; > - > - debug("tpm_test_sha1()"); > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > - sha1_init(&ctx); > - for (j = 0; j < test_cases[i].repetitions; j++) > -- sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > -+ sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > - sha1_final(&ctx, digest); > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > - } > -@@ -128,41 +129,41 @@ static int tpm_test_hmac(void) > - struct { > - uint8_t *key, key_len, *data, data_len, *digest; > - } test_cases[] = {{ > -- "\x0b", 20, "Hi There", 8, > -- "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > -+ (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8, > -+ (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" > - }, { > -- "Jefe", 4, "what do ya want for nothing?", 28, > -- "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > -+ (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28, > -+ (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" > - }, { > -- "\xaa", 20, "\xdd", 50, > -- "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > -+ (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50, > -+ (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" > - }, { > -- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > -- "\x15\x16\x17\x18\x19", 25, "\xcd", 50, > -- "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > -+ (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" > -+ "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50, > -+ (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" > - }, { > -- "\x0c", 20, "Test With Truncation", 20, > -- "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > -+ (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20, > -+ (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" > - }, { > -- "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54, > -- "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > -+ (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54, > -+ (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" > - }, { > -- "\xaa", 80, > -- "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > -- "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > -+ (uint8_t*)"\xaa", 80, > -+ (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, > -+ (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" > - }}; > - > - debug("tpm_test_hmac()"); > - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { > -- if (strlen(test_cases[i].key) < test_cases[i].key_len) { > -+ if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) { > - uint8_t key[test_cases[i].key_len]; > - memset(key, test_cases[i].key[0], test_cases[i].key_len); > - hmac_init(&ctx, key, test_cases[i].key_len); > - } else { > - hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len); > - } > -- for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) { > -- hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); > -+ for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) { > -+ hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); > - } > - hmac_final(&ctx, digest); > - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; > -@@ -173,9 +174,9 @@ static int tpm_test_hmac(void) > - static int tpm_test_rsa_EK(void) > - { > - int res = 0; > -- char *data = "RSA PKCS #1 v1.5 Test-String"; > -+ uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String"; > - uint8_t buf[256]; > -- size_t buf_len, data_len = strlen(data); > -+ size_t buf_len, data_len = strlen((char*)data); > - rsa_private_key_t priv_key; > - rsa_public_key_t pub_key; > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c > ---- orig/tpm_emulator-0.4/tpm/tpm_ticks.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_ticks.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -39,9 +40,7 @@ TPM_RESULT TPM_SetTickType(TPM_TICKTYPE > - TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime) > - { > - info("TPM_GetTicks()"); > -- memcpy(currentTime, &tpmData.stany.data.currentTicks, > -- sizeof(TPM_CURRENT_TICKS)); > -- return TPM_SUCCESS; > -+ return TPM_DISABLED_CMD; > - } > - > - TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay, > -@@ -49,64 +48,11 @@ TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN > - TPM_CURRENT_TICKS *currentTicks, > - UINT32 *sigSize, BYTE **sig) > - { > -- TPM_RESULT res; > -- TPM_KEY_DATA *key; > -- BYTE *info, *p; > -- UINT32 info_length, length; > - info("TPM_TickStampBlob()"); > -- /* get key */ > -- key = tpm_get_key(keyHandle); > -- if (key == NULL) return TPM_INVALID_KEYHANDLE; > -- /* verify authorization */ > -- res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); > -- if (res != TPM_SUCCESS) return res; > -- if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY > -- && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE; > -- /* get current ticks */ > -- TPM_GetTicks(currentTicks); > -- /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */ > -- *sigSize = key->key.size >> 3; > -- *sig = tpm_malloc(*sigSize); > -- if (*sig == NULL) return TPM_FAIL; > -- /* setup TPM_SIGN_INFO structure */ > -- info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks); > -- info = tpm_malloc(info_length); > -- if (info == NULL) { > -- tpm_free(*sig); > -- return TPM_FAIL; > -- } > -- memcpy(&info[0], "\x05\x00TSTP", 6); > -- memcpy(&info[6], antiReplay->nonce, 20); > -- *(UINT32*)&info[26] = CPU_TO_BE32(20 > -- + sizeof_TPM_CURRENT_TICKS(currentTicks)); > -- memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST)); > -- p = &info[30 + sizeof(TPM_DIGEST)]; > -- length = sizeof_TPM_CURRENT_TICKS(currentTicks); > -- if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks) > -- || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) { > -- tpm_free(*sig); > -- tpm_free(info); > -- return TPM_FAIL; > -- } > -- return TPM_SUCCESS; > -+ return TPM_DISABLED_CMD; > - } > - > - void tpm_update_ticks(void) > - { > -- if (tpmData.stany.data.currentTicks.tag == 0) { > -- tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS; > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > --/* removed since v1.2 rev 94 > -- tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType; > --*/ > -- tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce, > -- sizeof(TPM_NONCE)); > -- tpmData.stany.data.currentTicks.tickRate = 1; > --/* removed since v1.2 rev 94 > -- tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK; > --*/ > -- } else { > -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); > -- } > - } > - > -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c > ---- orig/tpm_emulator-0.4/tpm/tpm_transport.c 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm/tpm_transport.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -189,7 +189,7 @@ static void decrypt_wrapped_command(BYTE > - sha1_init(&sha1); > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > -- sha1_update(&sha1, "in", 2); > -+ sha1_update(&sha1, (BYTE*)"in", 2); > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > - j = CPU_TO_BE32(i); > - sha1_update(&sha1, (BYTE*)&j, 4); > -@@ -211,7 +211,7 @@ static void encrypt_wrapped_command(BYTE > - sha1_init(&sha1); > - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); > - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); > -- sha1_update(&sha1, "out", 3); > -+ sha1_update(&sha1, (BYTE*)"out", 3); > - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); > - j = CPU_TO_BE32(i); > - sha1_update(&sha1, (BYTE*)&j, 4); > -diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c > ---- orig/tpm_emulator-0.4/tpmd.c 1969-12-31 16:00:00.000000000 -0800 > -+++ tpm_emulator/tpmd.c 2006-07-24 14:35:35.000000000 -0700 > -@@ -0,0 +1,156 @@ > -+/* Software-Based Trusted Platform Module (TPM) Emulator for Linux > -+ * Copyright (C) 2005 INTEL Corp > -+ * > -+ * This module is free software; you can redistribute it and/or modify > -+ * it under the terms of the GNU General Public License as published > -+ * by the Free Software Foundation; either version 2 of the License, > -+ * or (at your option) any later version. > -+ * > -+ * This module is distributed in the hope that it will be useful, > -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of > -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > -+ * GNU General Public License for more details. > -+ * > -+ */ > -+ > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+#include > -+ > -+#include "tpm_emulator.h" > -+ > -+#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > -+#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > -+ > -+#define BUFFER_SIZE 2048 > -+ > -+static int devurandom=0; > -+ > -+void get_random_bytes(void *buf, int nbytes) { > -+ > -+ if (devurandom == 0) { > -+ devurandom = open("/dev/urandom", O_RDONLY); > -+ } > -+ > -+ if (read(devurandom, buf, nbytes) != nbytes) { > -+ printf("Can't get random number.\n"); > -+ exit(-1); > -+ } > -+} > -+ > -+uint64_t tpm_get_ticks(void) > -+{ > -+ //struct timeval tv; > -+ //int gettimeofday(&tv, struct timezone *tz); > -+ return 0; > -+} > -+ > -+int main(int argc, char **argv) > -+{ > -+ uint8_t in[BUFFER_SIZE], *out; > -+ uint32_t out_size; > -+ int in_size, written; > -+ int i; > -+ struct stat file_info; > -+ > -+ int tpm_tx_fh=-1, tpm_rx_fh=-1; > -+ if (argc < 2) { > -+ printf("Usage: tpmd clear|save|deactivated\n" ); > -+ return -1; > -+ } > -+ > -+ /* initialize TPM emulator */ > -+ if (!strcmp(argv[1], "clear")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(1); > -+ } else if (!strcmp(argv[1], "save")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(2); > -+ } else if (!strcmp(argv[1], "deactivated")) { > -+ printf("Initializing tpm: %s\n", argv[1]); > -+ tpm_emulator_init(3); > -+ } else { > -+ printf("invalid startup mode '%s'; must be 'clear', " > -+ "'save' (default) or 'deactivated", argv[1]); > -+ return -1; > -+ } > -+ > -+ if ( stat(TPM_RX_FNAME, &file_info) == -1) { > -+ if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > -+ printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > -+ return -1; > -+ } > -+ } > -+ > -+ if ( stat(TPM_TX_FNAME, &file_info) == -1) { > -+ if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > -+ printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > -+ return -1; > -+ } > -+ } > -+ > -+ while (1) { > -+abort_command: > -+ if (tpm_rx_fh < 0) { > -+ tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > -+ } > -+ > -+ if (tpm_rx_fh < 0) { > -+ printf("ERROR: failed to open devices to listen to guest.\n"); > -+ return -1; > -+ } > -+ > -+ if (tpm_tx_fh < 0) { > -+ tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > -+ } > -+ > -+ if (tpm_tx_fh < 0) { > -+ printf("ERROR: failed to open devices to respond to guest.\n"); > -+ return -1; > -+ } > -+ > -+ in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > -+ if (in_size < 6) { // Magic size of minium TPM command > -+ printf("Recv[%d] to small: 0x", in_size); > -+ if (in_size <= 0) { > -+ close(tpm_rx_fh); > -+ tpm_rx_fh = -1; > -+ goto abort_command; > -+ } > -+ } else { > -+ printf("Recv[%d]: 0x", in_size); > -+ for (i=0; i< in_size; i++) > -+ printf("%x ", in[i]); > -+ printf("\n"); > -+ } > -+ > -+ > -+ if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > -+ printf("ERROR: Handler Failed.\n"); > -+ } > -+ > -+ written = write(tpm_tx_fh, out, out_size); > -+ > -+ if (written != out_size ) { > -+ printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > -+ } else { > -+ printf("Sent[%Zu]: ", out_size); > -+ } > -+ for (i=0; i< out_size; i++) > -+ printf("%x ", out[i]); > -+ printf("\n"); > -+ tpm_free(out); > -+ > -+ } // loop > -+ > -+ tpm_emulator_shutdown(); > -+ > -+ close(tpm_tx_fh); > -+ close(tpm_rx_fh); > -+ > -+} > -Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ > -diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h > ---- orig/tpm_emulator-0.4/tpm_version.h 2006-06-23 03:37:07.000000000 -0700 > -+++ tpm_emulator/tpm_version.h 2006-07-24 14:35:41.000000000 -0700 > -@@ -2,5 +2,5 @@ > - #define _TPM_VERSION_H_ > - #define VERSION_MAJOR 0 > - #define VERSION_MINOR 4 > --#define VERSION_BUILD 1151058734 > -+#define VERSION_BUILD 1153776940 > - #endif /* _TPM_VERSION_H_ */ > diff --git a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch b/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > deleted file mode 100644 > index 95586c1..0000000 > --- a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch > +++ /dev/null > @@ -1,12 +0,0 @@ > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm_emulator-0.5.1/tpmd/Makefile > ---- tpm_emulator-0.5.1/tpmd/Makefile > -+++ tpm_emulator-0.5.1/tpmd/Makefile > -@@ -8,7 +8,7 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > - CFLAGS += -I../../../../tools/vtpm_manager/manager > --LDFLAGS += -lgmp > -+LDLIBS += -lgmp > - > - BINDIR := /usr/bin/ > - > diff --git a/tools/vtpm/vtpm-0.5.1.patch b/tools/vtpm/vtpm-0.5.1.patch > deleted file mode 100644 > index 2aeb745..0000000 > --- a/tools/vtpm/vtpm-0.5.1.patch > +++ /dev/null > @@ -1,766 +0,0 @@ > -diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile > ---- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 > -@@ -10,7 +10,7 @@ VERSION_MINOR := 5 > - VERSION_BUILD := $(shell date +"%s") > - VERSION_SUFFIX := .1 > - > --SUBDIRS := tpmd tpmd_dev tddl > -+SUBDIRS := tpmd > - > - all: version all-recursive > - > -@@ -48,12 +48,12 @@ user_install: user > - modules_install: modules > - @$(MAKE) -C tpmd_dev install || exit -1 > - > --DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd > -+DIRS := . tpm crypto tpmd > - DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) > - DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) > --DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd > -+DIRS := . tpmd > - DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) > --DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in > -+DISTSRC += ./README ./AUTHORS ./ChangeLog > - DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) > - > - dist: $(DISTSRC) > -diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c > ---- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 > -@@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_TIS_TIMEOUT: > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > -+ UINT32 len = *respSize = 16; > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > -+ if (ptr == NULL || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > -+ tpm_free(*resp); > -+ return TPM_FAIL; > -+ } > -+ return TPM_SUCCESS; > -+ > - > - case TPM_CAP_PROP_STARTUP_EFFECT: > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > -@@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_DURATION: > - debug("[TPM_CAP_PROP_DURATION]"); > -- /* TODO: TPM_CAP_PROP_DURATION */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > -+ *respSize = 16; > -+ *resp = tpm_malloc(*respSize); > -+ memcpy(*resp,dur,16); > -+ > - > - case TPM_CAP_PROP_ACTIVE_COUNTER: > - debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); > -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile > ---- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 > -@@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a > - -Wwrite-strings -Wsign-compare -Wno-multichar > - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing > - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing > -+CFLAGS += -I../../../../tools/vtpm_manager/manager > - LDFLAGS += -lgmp > - > --BINDIR := /usr/sbin/ > -+BINDIR := /usr/bin/ > - > - TPMD := tpmd > - DIRS := ../tpm ../crypto > -@@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil > - OBJS := $(patsubst %.c, %.o, $(SRCS)) > - OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) > - > -+VTPM_BIN := vtpmd > -+ > - vpath %.c $(strip $(DIRS)) > - > - all: $(TPMD) > -@@ -32,10 +35,8 @@ TPMD_GROUP ?= tss > - INSTALL ?= install > - > - install: $(TPMD) > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm > -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm > - $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) > -- $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) > -+ $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) > - > - .PHONY: all clean install > - > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c > ---- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 > -@@ -32,6 +32,9 @@ > - #include > - #include "tpm_emulator_config.h" > - #include "tpm/tpm_emulator.h" > -+#include "tpm/tpm_structures.h" > -+#include "tpm/tpm_marshalling.h" > -+#include "vtpm_manager.h" > - > - #define TPM_DAEMON_NAME "tpmd" > - #define TPM_CMD_BUF_SIZE 4096 > -@@ -39,6 +42,24 @@ > - #define TPM_RANDOM_DEVICE "/dev/urandom" > - #undef TPM_MKDIRS > - > -+#ifdef VTPM_MULTI_VM > -+ #define DEV_BE "/dev/vtpm" > -+ #define DEV_FE "/dev/tpm" > -+#else > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > -+ > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -+ > -+ static char *vtpm_rx_name=NULL; > -+#endif > -+ > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#define BUFFER_SIZE 2048 > -+ > - static volatile int stopflag = 0; > - static int is_daemon = 0; > - static int opt_debug = 0; > -@@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ > - static uid_t opt_uid = 0; > - static gid_t opt_gid = 0; > - static int tpm_startup = 2; > -+static int vtpm_type = VTPM_TYPE_PVM; > -+int dmi_id = 0; > - static int rand_fh; > - > - void tpm_log(int priority, const char *fmt, ...) > -@@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) > - > - int tpm_write_to_file(uint8_t *data, size_t data_length) > - { > -- int fh; > -- ssize_t res; > -- fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- if (fh < 0) return -1; > -- while (data_length > 0) { > -- res = write(fh, data, data_length); > -- if (res < 0) { > -- close(fh); > -- return -1; > -- } > -- data_length -= res; > -- data += res; > -+ int res, out_data_size, in_header_size; > -+ BYTE *ptr, *out_data, *in_header; > -+ UINT32 result, len, in_rsp_size; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ > -+ printf("Saving NVM\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > -+#endif > -+ > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > -+ free(out_data); > -+ return -1; > -+ } > -+ > -+ printf("\tSending SaveNVM Command.\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > - } > -- close(fh); > -- return 0; > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading SaveNVM header.\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > -+#endif > -+ > -+ printf("\tFinishing up SaveNVM\n"); > -+ return (0); > - } > - > - int tpm_read_from_file(uint8_t **data, size_t *data_length) > - { > -- int fh; > -- ssize_t res; > -- size_t total_length; > -- fh = open(opt_storage_file, O_RDONLY); > -- if (fh < 0) return -1; > -- total_length = lseek(fh, 0, SEEK_END); > -- lseek(fh, 0, SEEK_SET); > -- *data = tpm_malloc(total_length); > -- if (*data == NULL) { > -- close(fh); > -- return -1; > -- } > -- *data_length = 0; > -- while (total_length > 0) { > -- res = read(fh, &(*data)[*data_length], total_length); > -- if (res < 0) { > -- close(fh); > -- tpm_free(*data); > -- return -1; > -- } > -- *data_length += res; > -- total_length -= res; > -+ int res, out_data_size, in_header_size; > -+ uint8_t *ptr, *out_data, *in_header; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ UINT32 len, in_rsp_size, result; > -+#ifdef VTPM_MUTLI_VM > -+ int vtpm_rx_fh, vtpm_tx_fh; > -+#endif > -+ > -+ printf("Loading NVM.\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ printf("Error in read_from_file:301\n"); > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > -+ free(out_data); > -+ printf("Error in read_from_file:325\n"); > -+ > -+ return -1; > -+ } > -+ > -+ printf("\tSending LoadNVM command\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) > -+ { > -+ printf("Error in read_from_file:335\n"); > -+ return -1; > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > - } > -- close(fh); > -- return 0; > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ printf("Error in read_from_file:352\n"); > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading LoadNVM header\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ printf("Error in read_from_file:375\n"); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ printf("Error in read_from_file:381\n"); > -+ return -1; > -+ } > -+ > -+ // Read Encrypted data from VTPM Manager > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > -+ *data = (uint8_t *) malloc(*data_length); > -+ > -+ printf("\tReading clear data from LoadNVM.\n"); > -+ res = read(vtpm_rx_fh, *data, *data_length); > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > -+#endif > -+ > -+ printf("\tReturing from loading NVM\n"); > -+ if (res != (int)*data_length) { > -+ free(*data); > -+ printf("Error in read_from_file:398\n"); > -+ return -1; > -+ } else { > -+ return 0; > -+ } > -+ > -+ > -+ > - } > - > - static void print_usage(char *name) > - { > - printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " > -- "[-o user name] [-g group name] [-h] [startup mode]\n", name); > -+ "[-o user name] [-g group name] [-h]" > -+#ifdef VTPM_MULTI_VM > -+ "clear|save|deactivated\n", name); > -+#else > -+ "clear|save|deactivated pvm|hvm vtpmid\n", name); > -+#endif > - printf(" d : enable debug mode\n"); > - printf(" f : forces the application to run in the foreground\n"); > - printf(" s : storage file to use (default: %s)\n", opt_storage_file); > -@@ -205,7 +413,13 @@ static void parse_options(int argc, char > - exit(EXIT_SUCCESS); > - } > - } > -- if (optind < argc) { > -+ /*Make sure we have all required options*/ > -+#ifdef VTPM_MULTI_VM > -+#define EXTRA_OPTS 0 > -+#else > -+#define EXTRA_OPTS 2 > -+#endif > -+ if (optind < argc - EXTRA_OPTS ) { > - debug("startup mode = '%s'", argv[optind]); > - if (!strcmp(argv[optind], "clear")) { > - tpm_startup = 1; > -@@ -219,6 +433,25 @@ static void parse_options(int argc, char > - print_usage(argv[0]); > - exit(EXIT_SUCCESS); > - } > -+#ifndef VTPM_MULTI_VM > -+ ++optind; > -+ if(!strcmp(argv[optind], "pvm")) { > -+ vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > -+ } else if (!strcmp(argv[optind], "hvm")) { > -+ vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket > -+ } else { > -+ error("Invalid vm mode '%s'; must be 'pvm', " > -+ "or 'hvm' ", argv[optind]); > -+ print_usage(argv[0]); > -+ exit(EXIT_SUCCESS); > -+ } > -+ ++optind; > -+ dmi_id = atoi(argv[optind]); > -+#endif > -+ } else { > -+ error("Invalid number of arguments"); > -+ print_usage(argv[0]); > -+ exit(EXIT_SUCCESS); > - } > - } > - > -@@ -348,93 +581,180 @@ static int init_socket(const char *name) > - > - static void main_loop(void) > - { > -- int sock, fh, res; > -- int32_t in_len; > -+ int32_t in_len, written; > - uint32_t out_len; > -- uint8_t in[TPM_CMD_BUF_SIZE], *out; > -+ uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; > -+ int guest_id=-1; > -+ int i; > -+ char *vtpm_rx_file=NULL; > -+ int res; > -+ > -+#ifndef VTPM_MULTI_VM > -+ int sockfd = -1; > - struct sockaddr_un addr; > -- socklen_t addr_len; > -- fd_set rfds; > -- struct timeval tv; > -+ struct sockaddr_un client_addr; > -+ unsigned int client_length; > -+#endif > -+ > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#ifndef VTPM_MULTI_VM > -+ if (vtpm_type == VTPM_TYPE_PVM) { > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } else { > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > -+ error("Unable to create socket. errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&addr, 0, sizeof(addr)); > -+ addr.sun_family = AF_UNIX; > -+ strcpy(addr.sun_path,vtpm_rx_file ); > -+ unlink(addr.sun_path); > -+ } > -+#endif > - > - info("staring main loop"); > -- /* open UNIX socket */ > -- sock = init_socket(opt_socket_name); > -- if (sock < 0) exit(EXIT_FAILURE); > - /* init tpm emulator */ > -- debug("initializing TPM emulator: %d", tpm_startup); > -+#ifdef VTPM_MULTI_VM > -+ debug("initializing TPM emulator: state=%d", tpm_startup); > -+#else > -+ debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); > -+#endif > - tpm_emulator_init(tpm_startup); > - /* start command processing */ > - while (!stopflag) { > - /* wait for incomming connections */ > - debug("waiting for connections..."); > -- FD_ZERO(&rfds); > -- FD_SET(sock, &rfds); > -- tv.tv_sec = 10; > -- tv.tv_usec = 0; > -- res = select(sock + 1, &rfds, NULL, NULL, &tv); > -- if (res < 0) { > -- error("select(sock) failed: %s", strerror(errno)); > -- break; > -- } else if (res == 0) { > -- continue; > -- } > -- addr_len = sizeof(addr); > -- fh = accept(sock, (struct sockaddr*)&addr, &addr_len); > -- if (fh < 0) { > -- error("accept() failed: %s", strerror(errno)); > -- continue; > -- } > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > -+#else > -+ if (vtpm_type == VTPM_TYPE_PVM) > -+ { > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > -+ } else { > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > -+ error("Unable to bind(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ if (listen(sockfd, 10) <0) { > -+ error("Unable to listen(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&client_addr, 0, sizeof(client_addr)); > -+ client_length = sizeof(client_addr); > -+ > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > -+ } > -+#endif > -+ } > -+ > -+ /*Error Checking*/ > -+ if (vtpm_rx_fh < 0) { > -+ error("Failed to open devices to listen to guest.\n"); > -+ exit(-1); > -+ } > -+ > - /* receive and handle commands */ > - in_len = 0; > - do { > - debug("waiting for commands..."); > -- FD_ZERO(&rfds); > -- FD_SET(fh, &rfds); > -- tv.tv_sec = TPM_COMMAND_TIMEOUT; > -- tv.tv_usec = 0; > -- res = select(fh + 1, &rfds, NULL, NULL, &tv); > -- if (res < 0) { > -- error("select(fh) failed: %s", strerror(errno)); > -- close(fh); > -- break; > -- } else if (res == 0) { > --#ifdef TPMD_DISCONNECT_IDLE_CLIENTS > -- info("connection closed due to inactivity"); > -- close(fh); > -- break; > --#else > -- continue; > --#endif > -- } > -- in_len = read(fh, in, sizeof(in)); > -- if (in_len > 0) { > -+ > -+ in_len = read(vtpm_rx_fh, in, sizeof(in)); > -+ /*Magic size of minimum TPM command is 6*/ > -+ //FIXME Magic size check may not be required anymore > -+ if (in_len < 6) { > -+ info("Recv incomplete command of %d bytes.", in_len); > -+ if (in_len <= 0) { > -+ close(vtpm_rx_fh); > -+ vtpm_rx_fh = -1; > -+ continue; > -+ } > -+ } else { > -+ /*Debug Printouts*/ > - debug("received %d bytes", in_len); > -+ debug_nostop("Recv[%d]: 0x", in_len); > -+ for (i=0; i< in_len; i++) > -+ debug_more("%x ", in[i]); > -+ debug_more("\n"); > -+ /*Multiple Guest check*/ > -+ if (guest_id == -1) { > -+ guest_id = *((int32_t *) in); > -+ } else { > -+ if (guest_id != *((int32_t *) in) ) { > -+ error("WARNING: More than one guest attached\n"); > -+ } > -+ } > -+ > -+ /*Open tx handle now*/ > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_type == VTPM_TYPE_PVM) { > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > -+ } // No need to open the other direction for HVM > -+#endif > -+ } > -+ if (vtpm_tx_fh < 0) { > -+ error("Failed to open devices to respond to guest.\n"); > -+ exit(-1); > -+ } > -+ > -+ /*Handle the TPM command now*/ > - out = NULL; > -- res = tpm_handle_command(in, in_len, &out, &out_len); > -+ res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); > - if (res < 0) { > - error("tpm_handle_command() failed"); > - } else { > - debug("sending %d bytes", out_len); > -+ //FIXME this prepending may or may not be needed > -+ /*Prepend the first 4 bytes of the in buffer.. why?*/ > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_len); > -+ out_len += sizeof(uint32_t); > -+ /*End Prepend*/ > -+ > -+ /*Perform write operation now*/ > - while (out_len > 0) { > -- res = write(fh, out, out_len); > -+ res = write(vtpm_tx_fh, addressed_out, out_len); > -+ > - if (res < 0) { > - error("write(%d) failed: %s", out_len, strerror(errno)); > - break; > -- } > -+ } else { > -+ debug_nostop("Sent[%Zu]: ", out_len); > -+ for (i=0; (unsigned int)i< out_len; i++) > -+ debug_more("%x ", addressed_out[i]); > -+ debug_more("\n"); > -+ } > - out_len -= res; > - } > - tpm_free(out); > -+ tpm_free(addressed_out); > - } > - } > - } while (in_len > 0); > -- close(fh); > -+ //close(fh); > - } > -+ > - /* shutdown tpm emulator */ > - tpm_emulator_shutdown(); > -- /* close socket */ > -- close(sock); > -- unlink(opt_socket_name); > -+ /* Close handles */ > -+ close(vtpm_tx_fh); > -+#ifndef VTPM_MULTI_VM > -+ close(vtpm_rx_fh); > -+ free(vtpm_rx_file); > -+#endif > - info("main loop stopped"); > - } > - > -@@ -450,12 +770,13 @@ int main(int argc, char **argv) > - /* open random device */ > - init_random(); > - /* init signal handlers */ > -- init_signal_handler(); > -+ //init_signal_handler(); > - /* unless requested otherwiese, fork and daemonize process */ > -- if (!opt_foreground) daemonize(); > -+ //if (!opt_foreground) daemonize(); > - /* start main processing loop */ > - main_loop(); > - info("stopping TPM Emulator daemon"); > - closelog(); > - return 0; > - } > -+ > -diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h > ---- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 > -+++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 > -@@ -29,23 +29,28 @@ > - > - /* TPM emulator configuration */ > - > --#undef TPM_STRONG_PERSISTENCE > --#undef TPM_GENERATE_EK > -+#define TPM_STRONG_PERSISTENCE > -+#define TPM_GENERATE_EK > - #undef TPM_GENERATE_SEED_DAA > - #undef TPM_MEMORY_ALIGNMENT_MANDATORY > - > -+extern int dmi_id; > -+ > - /* log macros */ > - > - void tpm_log(int priority, const char *fmt, ...); > - > --#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) > - > - /* min/max macros that also do strict type-checking */ > - > diff --git a/tools/vtpm/vtpm.patch b/tools/vtpm/vtpm.patch > deleted file mode 100644 > index e896b25..0000000 > --- a/tools/vtpm/vtpm.patch > +++ /dev/null > @@ -1,716 +0,0 @@ > -diff -uprN tpm_emulator/AUTHORS vtpm/AUTHORS > ---- tpm_emulator/AUTHORS 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/AUTHORS 2006-12-13 16:38:52.000000000 -0800 > -@@ -1,3 +1,3 @@ > - Mario Strasser > - Heiko Stamer [DAA] > --INTEL Corp <> [Dropped to Ring3] > -+INTEL Corp <> [VTPM Extensions] > -diff -uprN tpm_emulator/ChangeLog vtpm/ChangeLog > ---- tpm_emulator/ChangeLog 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/ChangeLog 2006-12-13 16:38:52.000000000 -0800 > -@@ -1,5 +1,6 @@ > - ????-??-?? Intel Corp > - * Moved module out of kernel to run as a ring 3 app > -+ * Modified save_to_file and load_from_file to call xen VTPM manager > - > - 2006-06-23 Mario Strasser > - * tpm_startup.c: behaviour of ST_CLEAR and storage of > -diff -uprN tpm_emulator/linux_module.h vtpm/linux_module.h > ---- tpm_emulator/linux_module.h 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/linux_module.h 2007-01-09 14:49:06.000000000 -0800 > -@@ -44,18 +44,26 @@ > - #define TPM_DEVICE_NAME "tpm" > - #define TPM_MODULE_NAME "tpm_emulator" > - > -+/* debug and log output functions */ > -+extern int dmi_id; > -+ > - #ifdef DEBUG > --#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_nostop(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt, \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define debug_more(fmt, ...) printf( fmt, ## __VA_ARGS__ ) > - #else > - #define debug(fmt, ...) > -+#define debug_nostop(fmt, ...) > -+#define debug_more(fmt, ...) > - #endif > --#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > --#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ > -- __FILE__, __LINE__, ## __VA_ARGS__) > -+#define info(fmt, ...) printf("TPMD[%d]: %s:%d: Info: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define error(fmt, ...) printf("TPMD[%d]: %s:%d: Error: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > -+#define alert(fmt, ...) printf("TPMD[%d]: %s:%d: Alert: " fmt "\n", \ > -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) > - > - /* memory allocation */ > - > -diff -uprN tpm_emulator/Makefile vtpm/Makefile > ---- tpm_emulator/Makefile 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/Makefile 2006-12-13 16:38:52.000000000 -0800 > -@@ -7,7 +7,7 @@ > - COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) > - > - # module settings > --BIN := tpm_emulator > -+BIN := vtpmd > - VERSION_MAJOR := 0 > - VERSION_MINOR := 4 > - VERSION_BUILD := $(shell date +"%s") > -@@ -22,7 +22,7 @@ TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin > - > - CC := gcc > - CFLAGS += -g -Wall $(INCLUDE) -DDEBUG > --CFLAGS += -I. -Itpm > -+CFLAGS += -I. -Itpm -I../../vtpm_manager/manager > - > - # Is the simulator running in it's own vm? > - #CFLAGS += -DVTPM_MULTI_VM > -@@ -62,7 +62,6 @@ $(BIN): $(src)/crypto/gmp.h $(src)/crypt > - > - install: $(BIN) > - $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) > -- @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi > - > - clean: > - rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) > -@@ -98,3 +97,4 @@ version: > - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h > - > - .PHONY: all install clean dist gmp version > -+ > -diff -uprN tpm_emulator/tpm/tpm_capability.c vtpm/tpm/tpm_capability.c > ---- tpm_emulator/tpm/tpm_capability.c 2006-06-23 03:37:07.000000000 -0700 > -+++ vtpm/tpm/tpm_capability.c 2007-01-10 10:00:49.000000000 -0800 > -@@ -136,8 +136,18 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_TIS_TIMEOUT: > - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); > -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ > -- return TPM_FAIL; > -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ > -+ UINT32 len = *respSize = 16; > -+ BYTE *ptr = *resp = tpm_malloc(*respSize); > -+ if (ptr == NULL || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000) || > -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { > -+ tpm_free(*resp); > -+ return TPM_FAIL; > -+ } > -+ return TPM_SUCCESS; > - > - case TPM_CAP_PROP_STARTUP_EFFECT: > - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); > -@@ -190,7 +200,11 @@ static TPM_RESULT cap_property(UINT32 su > - > - case TPM_CAP_PROP_DURATION: > - debug("[TPM_CAP_PROP_DURATION]"); > -- /* TODO: TPM_CAP_PROP_DURATION */ > -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ > -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; > -+ *respSize = 16; > -+ *resp = tpm_malloc(*respSize); > -+ memcpy(*resp,dur,16); > - return TPM_FAIL; > - > - case TPM_CAP_PROP_ACTIVE_COUNTER: > -diff -uprN tpm_emulator/tpm/tpm_cmd_handler.c vtpm/tpm/tpm_cmd_handler.c > ---- tpm_emulator/tpm/tpm_cmd_handler.c 2008-02-27 16:35:41.000000000 -0500 > -+++ vtpm/tpm/tpm_cmd_handler.c 2008-02-28 14:43:28.000000000 -0500 > -@@ -94,12 +94,18 @@ void tpm_compute_out_param_digest(TPM_CO > - sha1_ctx_t sha1; > - UINT32 res = CPU_TO_BE32(rsp->result); > - UINT32 ord = CPU_TO_BE32(ordinal); > -+ UINT32 offset = 0; > - > - /* compute SHA1 hash */ > - sha1_init(&sha1); > - sha1_update(&sha1, (BYTE*)&res, 4); > - sha1_update(&sha1, (BYTE*)&ord, 4); > -- sha1_update(&sha1, rsp->param, rsp->paramSize); > -+ if (ordinal == TPM_ORD_LoadKey2) { > -+ offset = 4; > -+ } > -+ if (rsp->paramSize - offset > 0) { > -+ sha1_update(&sha1, rsp->param + offset, rsp->paramSize - offset); > -+ } > - sha1_final(&sha1, rsp->auth1->digest); > - if (rsp->auth2 != NULL) memcpy(rsp->auth2->digest, > - rsp->auth1->digest, sizeof(rsp->auth1->digest)); > -diff -uprN tpm_emulator/tpm/tpm_data.c vtpm/tpm/tpm_data.c > ---- tpm_emulator/tpm/tpm_data.c 2008-02-27 16:35:41.000000000 -0500 > -+++ vtpm/tpm/tpm_data.c 2008-02-27 16:35:40.000000000 -0500 > -@@ -1,6 +1,7 @@ > - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux > - * Copyright (C) 2004 Mario Strasser , > - * Swiss Federal Institute of Technology (ETH) Zurich > -+ * Copyright (C) 2005 INTEL Corp > - * > - * This module is free software; you can redistribute it and/or modify > - * it under the terms of the GNU General Public License as published > -@@ -15,10 +16,15 @@ > - * $Id: tpm_data.c 98 2006-05-07 14:16:29Z hstamer $ > - */ > - > -+#include > -+#include > -+#include > -+#include > -+ > - #include "tpm_emulator.h" > - #include "tpm_structures.h" > - #include "tpm_marshalling.h" > --#include "linux_module.h" > -+#include "vtpm_manager.h" > - > - TPM_DATA tpmData; > - > -@@ -158,45 +164,232 @@ void tpm_release_data(void) > - #include > - #include > - #include > --#include > - > --#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) > -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+ > -+#ifdef VTPM_MUTLI_VM > -+ #define DEV_FE "/dev/tpm" > -+#else > -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -+ > -+ extern int dmi_id; > -+ static char *vtpm_rx_name=NULL; > -+#endif > - > - static int write_to_file(uint8_t *data, size_t data_length) > - { > -- int res; > -- int fp; > -- fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); > -- res = write(fp, data, data_length); > -- close(fp); > -- return (res == data_length) ? 0 : -1; > -+ int res, out_data_size, in_header_size; > -+ BYTE *ptr, *out_data, *in_header; > -+ UINT32 result, len, in_rsp_size; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ > -+ printf("Saving NVM\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; > -+#endif > -+ > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) > -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { > -+ free(out_data); > -+ return -1; > -+ } > -+ > -+ printf("\tSending SaveNVM Command.\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading SaveNVM header.\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_tx_fh); close(vtpm_rx_fh); > -+#endif > -+ > -+ printf("\tFinishing up SaveNVM\n"); > -+ return (0); > - } > - > - static int read_from_file(uint8_t **data, size_t *data_length) > - { > -- int res; > -- int fp, file_status; > -- struct stat file_info; > -- fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); > -- file_status = fstat(fp, &file_info); > -- if (file_status < 0) { > -- close(fp); > -- return -1; > -- } > -+ int res, out_data_size, in_header_size; > -+ uint8_t *ptr, *out_data, *in_header; > -+ UINT16 tag = VTPM_TAG_REQ; > -+ UINT32 len, in_rsp_size, result; > -+#ifdef VTPM_MUTLI_VM > -+ int vtpm_rx_fh, vtpm_tx_fh; > -+#endif > -+ > -+ printf("Loading NVM.\n"); > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); > -+#else > -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); > -+#endif > -+ } > - > -- *data_length = file_info.st_size; > -- *data = tpm_malloc(*data_length); > -- if (*data == NULL) { > -- close(fp); > -+ if (vtpm_tx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Send request to VTPM Manager to encrypt data > -+#ifdef VTPM_MUTLI_VM > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ out_data = ptr = (BYTE *) malloc(len); > -+ > -+ if (ptr == NULL > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) > -+#endif > -+ || tpm_marshal_UINT16(&ptr, &len, tag) > -+#ifdef VTPM_MUTLI_VM > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) > -+#else > -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) > -+#endif > -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { > -+ free(out_data); > - return -1; > - } > -- res = read(fp, *data, *data_length); > -- close(fp); > -+ > -+ printf("\tSending LoadNVM command\n"); > -+ res = write(vtpm_tx_fh, out_data, out_data_size); > -+ free(out_data); > -+ if (res != out_data_size) return -1; > -+ > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (vtpm_rx_name == NULL) { > -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } > -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); > -+#endif > -+ } > -+ > -+ if (vtpm_rx_fh < 0) { > -+ return -1; > -+ } > -+ > -+ // Read Header of response so we can get the size & status > -+#ifdef VTPM_MUTLI_VM > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; > -+#else > -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; > -+#endif > -+ in_header = ptr = malloc(in_header_size); > -+ > -+ printf("\tReading LoadNVM header\n"); > -+ res = read(vtpm_rx_fh, in_header, in_header_size); > -+ > -+ if ( (res != in_header_size) > -+#ifndef VTPM_MUTLI_VM > -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) > -+#endif > -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) > -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { > -+ free(in_header); > -+ return -1; > -+ } > -+ free(in_header); > -+ > -+ if (result != VTPM_SUCCESS) { > -+ return -1; > -+ } > -+ > -+ // Read Encrypted data from VTPM Manager > -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; > -+ *data = (uint8_t *) malloc(*data_length); > -+ > -+ printf("\tReading clear data from LoadNVM.\n"); > -+ res = read(vtpm_rx_fh, *data, *data_length); > -+#ifdef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh);close(vtpm_tx_fh); > -+#endif > -+ > -+ printf("\tReturing from loading NVM\n"); > - if (res != *data_length) { > -- tpm_free(*data); > -- return -1; > -+ free(*data); > -+ return -1; > -+ } else { > -+ return 0; > - } > -- return 0; > -+ > - } > - > - #else > -diff -uprN tpm_emulator/tpmd.c vtpm/tpmd.c > ---- tpm_emulator/tpmd.c 2006-12-08 12:51:29.000000000 -0800 > -+++ vtpm/tpmd.c 2007-01-09 14:48:56.000000000 -0800 > -@@ -21,12 +21,24 @@ > - #include > - #include > - #include > -+#include > -+#include > -+#include > - > - #include "tpm_emulator.h" > -+#include "vtpm_manager.h" > - > --#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" > --#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" > -+#ifdef VTPM_MULTI_VM > -+ #define DEV_BE "/dev/vtpm" > -+#else > -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > - > -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" > -+#endif > -+ > -+ int dmi_id; > -+ > - #define BUFFER_SIZE 2048 > - > - static int devurandom=0; > -@@ -38,7 +50,7 @@ void get_random_bytes(void *buf, int nby > - } > - > - if (read(devurandom, buf, nbytes) != nbytes) { > -- printf("Can't get random number.\n"); > -+ error("Can't get random number.\n"); > - exit(-1); > - } > - } > -@@ -52,105 +64,182 @@ uint64_t tpm_get_ticks(void) > - > - int main(int argc, char **argv) > - { > -- uint8_t in[BUFFER_SIZE], *out; > -+ uint8_t type, in[BUFFER_SIZE], *out, *addressed_out; > -+ char *vtpm_rx_file=NULL; > - uint32_t out_size; > - int in_size, written; > -- int i; > -- struct stat file_info; > -+ int i, guest_id=-1; > - > -- int tpm_tx_fh=-1, tpm_rx_fh=-1; > -+#ifndef VTPM_MULTI_VM > -+ int sockfd = -1; > -+ struct sockaddr_un addr; > -+ struct sockaddr_un client_addr; > -+ unsigned int client_length; > -+ > -+#endif > -+ > -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; > -+#ifdef VTPM_MULTI_VM > - if (argc < 2) { > -- printf("Usage: tpmd clear|save|deactivated\n" ); > -+ error("Usage: tpmd clear|save|deactivated\n" ); > -+#else > -+ if (argc < 4) { > -+ error("Usage: tpmd clear|save|deactivated pvm|hvm vtpmid\n" ); > -+#endif > - return -1; > - } > - > -+#ifndef VTPM_MULTI_VM > -+ /* setup type of vm */ > -+ if (!strcmp(argv[2], "pvm")) { > -+ type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo > -+ } else if (!strcmp(argv[2], "hvm")) { > -+ type = VTPM_TYPE_HVM; // Get commands from qemu via socket > -+ } else { > -+ error("invalid vTPM type '%s'.\n", argv[2]); > -+ } > -+ > -+ dmi_id = atoi(argv[3]); > -+ > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ } else { > -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); > -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); > -+ > -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { > -+ error("Unable to create socket. errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&addr, 0, sizeof(addr)); > -+ addr.sun_family = AF_UNIX; > -+ strcpy(addr.sun_path,vtpm_rx_file ); > -+ unlink(addr.sun_path); > -+ } > -+#endif > -+ > -+#ifdef VTPM_MULTI_VM > -+ info("Initializing tpm state: %s\n", argv[1]); > -+#else > -+ info("Initializing tpm state: %s, type: %s, id: %d\n", argv[1], argv[2], dmi_id); > -+#endif > -+ > - /* initialize TPM emulator */ > - if (!strcmp(argv[1], "clear")) { > -- printf("Initializing tpm: %s\n", argv[1]); > - tpm_emulator_init(1); > -- } else if (!strcmp(argv[1], "save")) { > -- printf("Initializing tpm: %s\n", argv[1]); > -+ } else if (!strcmp(argv[1], "save")) { > - tpm_emulator_init(2); > - } else if (!strcmp(argv[1], "deactivated")) { > -- printf("Initializing tpm: %s\n", argv[1]); > - tpm_emulator_init(3); > - } else { > -- printf("invalid startup mode '%s'; must be 'clear', " > -+ error("invalid startup mode '%s'; must be 'clear', " > - "'save' (default) or 'deactivated", argv[1]); > - return -1; > - } > -- > -- if ( stat(TPM_RX_FNAME, &file_info) == -1) { > -- if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { > -- printf("Failed to create fifo %s.\n", TPM_RX_FNAME); > -- return -1; > -- } > -- } > -- > -- if ( stat(TPM_TX_FNAME, &file_info) == -1) { > -- if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { > -- printf("Failed to create fifo %s.\n", TPM_TX_FNAME); > -- return -1; > -- } > -- } > -- > -+ > - while (1) { > - abort_command: > -- if (tpm_rx_fh < 0) { > -- tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); > -+ if (vtpm_rx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); > -+#else > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); > -+ } else { > -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { > -+ error("Unable to bind(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ if (listen(sockfd, 10) <0) { > -+ error("Unable to listen(). errno = %d\n", errno); > -+ exit (-1); > -+ } > -+ > -+ memset(&client_addr, 0, sizeof(client_addr)); > -+ client_length = sizeof(client_addr); > -+ > -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); > -+ } > -+#endif > - } > - > -- if (tpm_rx_fh < 0) { > -- printf("ERROR: failed to open devices to listen to guest.\n"); > -+ if (vtpm_rx_fh < 0) { > -+ error("Failed to open devices to listen to guest.\n"); > - return -1; > - } > - > -- if (tpm_tx_fh < 0) { > -- tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); > -- } > -- > -- if (tpm_tx_fh < 0) { > -- printf("ERROR: failed to open devices to respond to guest.\n"); > -- return -1; > -- } > -- > -- in_size = read(tpm_rx_fh, in, BUFFER_SIZE); > -+ in_size = read(vtpm_rx_fh, in, BUFFER_SIZE); > - if (in_size < 6) { // Magic size of minium TPM command > -- printf("Recv[%d] to small: 0x", in_size); > -+ info("Recv incomplete command of %d bytes.", in_size); > - if (in_size <= 0) { > -- close(tpm_rx_fh); > -- tpm_rx_fh = -1; > -+ close(vtpm_rx_fh); > -+ vtpm_rx_fh = -1; > - goto abort_command; > - } > - } else { > -- printf("Recv[%d]: 0x", in_size); > -+ debug_nostop("Recv[%d]: 0x", in_size); > - for (i=0; i< in_size; i++) > -- printf("%x ", in[i]); > -- printf("\n"); > -+ debug_more("%x ", in[i]); > -+ debug_more("\n"); > - } > - > -- > -- if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { > -- printf("ERROR: Handler Failed.\n"); > -+ if (guest_id == -1) { > -+ guest_id = *((uint32_t *) in); > -+ } else { > -+ if (guest_id != *((uint32_t *) in) ) { > -+ error("WARNING: More than one guest attached\n"); > -+ } > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+#ifdef VTPM_MUTLI_VM > -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); > -+ vtpm_rx_fh = vtpm_tx_fh; > -+#else > -+ if (type == VTPM_TYPE_PVM) { > -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); > -+ } // No need to open the other direction for HVM > -+#endif > -+ } > -+ > -+ if (vtpm_tx_fh < 0) { > -+ error("Failed to open devices to respond to guest.\n"); > -+ return -1; > -+ } > -+ > -+ // Handle the command, but skip the domain id header > -+ if (tpm_handle_command(in + sizeof(uint32_t), in_size - sizeof(uint32_t), &out, &out_size) != 0) { > -+ error("Handler Failed.\n"); > - } > - > -- written = write(tpm_tx_fh, out, out_size); > -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_size); > -+ *(uint32_t *) addressed_out = *(uint32_t *) in; > -+ memcpy(addressed_out + sizeof(uint32_t), out, out_size); > -+ > -+ written = write(vtpm_tx_fh, addressed_out, out_size + sizeof(uint32_t)); > - > -- if (written != out_size ) { > -- printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); > -+ if (written != out_size + sizeof(uint32_t)) { > -+ error("Part of response not written %d/%d.\n", written, out_size); > - } else { > -- printf("Sent[%Zu]: ", out_size); > -+ debug_nostop("Sent[%Zu]: ", out_size + sizeof(uint32_t)); > -+ for (i=0; i< out_size+ sizeof(uint32_t); i++) > -+ debug_more("%x ", addressed_out[i]); > -+ debug_more("\n"); > - } > -- for (i=0; i< out_size; i++) > -- printf("%x ", out[i]); > -- printf("\n"); > - tpm_free(out); > -+ tpm_free(addressed_out); > - > - } // loop > - > - tpm_emulator_shutdown(); > - > -- close(tpm_tx_fh); > -- close(tpm_rx_fh); > -+ close(vtpm_tx_fh); > -+#ifndef VTPM_MUTLI_VM > -+ close(vtpm_rx_fh); > -+ free (vtpm_rx_file); > -+#endif > - > - } > diff --git a/tools/vtpm_manager/COPYING b/tools/vtpm_manager/COPYING > deleted file mode 100644 > index c4b86b7..0000000 > --- a/tools/vtpm_manager/COPYING > +++ /dev/null > @@ -1,32 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > diff --git a/tools/vtpm_manager/Makefile b/tools/vtpm_manager/Makefile > deleted file mode 100644 > index 632f41b..0000000 > --- a/tools/vtpm_manager/Makefile > +++ /dev/null > @@ -1,18 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../.. > - > -# Base definitions and rules > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -SUBDIRS = crypto tcs util manager migration > -OPENSSL_HEADER = /usr/include/openssl/crypto.h > - > -.PHONY: all clean install > -all clean install: %: subdirs-% > - > -.PHONY: mrproper > -mrproper: > - @set -e; for subdir in $(SUBDIRS); do \ > - $(MAKE) -C $$subdir $@; \ > - done > - > - > diff --git a/tools/vtpm_manager/README b/tools/vtpm_manager/README > deleted file mode 100644 > index f0d1e98..0000000 > --- a/tools/vtpm_manager/README > +++ /dev/null > @@ -1,94 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -Directory Structure > -=================== > -tools/vtpm_manager/crypto -> crypto files > -tools/vtpm_manager/TCS -> TCS implementation > -tools/vtpm_manager/util -> Utility Library. Include disk-io and buffers. > -tools/vtpm_manager/manager -> VTPM Manager > - > -Compile Flags > -=================== > -LOGGING_MODULES -> How extensive logging happens > - see util/log.h for more info > - > -VTPM_MULTI_VM -> Defined: VTPMs run in their own VMs > - Not Defined (default): VTPMs are processes > - > -# Debugging flags that may disappear without notice in the future > - > -DUMMY_BACKEND -> vtpm_manager listens on /tmp/in.fifo and > - /tmp/out.fifo rather than backend > - > -MANUAL_DM_LAUNCH -> Must manually launch & kill VTPMs > - > -WELL_KNOWN_OWNER_AUTH -> Rather than randomly generating the password for the owner, > - use a well known value. This is useful for debugging and for > - poor bios which do not support clearing TPM if OwnerAuth is > - lost. However this has no protection from malicious app > - issuing a TPM_OwnerClear to wipe the TPM > - > -Requirements > -============ > -- xen-unstable > -- vtpm frontend/backend driver patch > -- OpenSSL Library > - > -Single-VM Flow > -============================ > -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread > - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. > -- VTPM Manager listens to TPM BE. > -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. > -- When the manager receives the open message from the BE, it launches a vtpm > -- Xend allows the VM to continue booting. > -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. > -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. > -- The fifo listener begins listening for the reply from vtpm for the request. > -- Vtpm processes request and replies to manager over shared named fifo. > -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. > -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. > - > -NOTES: > -* SaveService SHOULD seal it's table before saving it to disk. However, > - the current Xen infrastructure does not provide a mechanism for this to be > - unsealed later. Specifically, the auth and wrapped key must be available ONLY > - to the service, or it's not even worth encrypting > - > - In the future the vtpm manager will be protected by an early boot mechanism > - that will allow for better protection of it's data. > - > -TODO: > -- Timeout on crashed vtpms > -- create lock for shared fifo for talking to vtpms. > diff --git a/tools/vtpm_manager/Rules.mk b/tools/vtpm_manager/Rules.mk > deleted file mode 100644 > index 651772b..0000000 > --- a/tools/vtpm_manager/Rules.mk > +++ /dev/null > @@ -1,59 +0,0 @@ > -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) > -include $(XEN_ROOT)/tools/Rules.mk > - > -# > -# Tool definitions > -# > - > -# General compiler flags > -CFLAGS = -Werror -g3 > - > -# Generic project files > -HDRS = $(wildcard *.h) > -SRCS = $(wildcard *.c) > -OBJS = $(patsubst %.c,%.o,$(SRCS)) > - > -# Generic (non-header) dependencies > -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -$(OBJS): $(SRCS) > - > --include $(FILES) > - > -# Make sure these are just rules > -.PHONY : all build install clean > - > -# > -# Project-specific definitions > -# > - > -# Need UNIX98 spec for pthread rwlocks > -CFLAGS += -D_GNU_SOURCE > - > -# Logging Level. See utils/tools.h for usage > -CFLAGS += -DLOGGING_MODULES="(BITMASK(VTPM_LOG_TCS)|BITMASK(VTPM_LOG_VTSP)|BITMASK(VTPM_LOG_VTPM))" > - > -# Silent Mode > -#CFLAGS += -DLOGGING_MODULES=0x0 > -#CFLAGS += -DLOGGING_MODULES=0xff > - > -# Use frontend/backend pairs between manager & DMs? > -#CFLAGS += -DVTPM_MULTI_VM > - > -# vtpm_manager listens on fifo's rather than backend > -#CFLAGS += -DDUMMY_BACKEND > - > -# TCS talks to fifo's rather than /dev/tpm. TPM Emulator assumed on fifos > -#CFLAGS += -DDUMMY_TPM > - > -# Do not have manager launch DMs. > -#CFLAGS += -DMANUAL_DM_LAUNCH > - > -# Fixed OwnerAuth > -#CFLAGS += -DWELL_KNOWN_OWNER_AUTH > - > -# Include > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/crypto > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/util > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/tcs > -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/manager > diff --git a/tools/vtpm_manager/crypto/Makefile b/tools/vtpm_manager/crypto/Makefile > deleted file mode 100644 > index 13b61c9..0000000 > --- a/tools/vtpm_manager/crypto/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libtcpaCrypto.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/crypto/crypto.c b/tools/vtpm_manager/crypto/crypto.c > deleted file mode 100644 > index 7dae655..0000000 > --- a/tools/vtpm_manager/crypto/crypto.c > +++ /dev/null > @@ -1,88 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// crypto.c > -// > -// This file will handle all the TPM Crypto functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include "crypto.h" > -#include "log.h" > - > -/** > - * Initialize cryptography library > - * @rand: random seed > - * @size: size of @rand > - */ > -void Crypto_Init(const BYTE* rand, int size) { > - ERR_load_crypto_strings(); > - CRYPTO_malloc_init(); > - OpenSSL_add_all_algorithms(); > - SYM_CIPHER = EVP_aes_128_cbc(); > - RAND_poll(); > - if (rand == NULL) > - return; > - > - RAND_add(rand, size, size); > -} > - > -/** > - * Shutdown cryptography library > - */ > -void Crypto_Exit() { > - ERR_free_strings(); > - ERR_remove_state(0); > - EVP_cleanup(); > -} > - > - > -/** > - * Get random data > - * @data: (OUT) Random data > - * @size: Size of @data > - */ > -void Crypto_GetRandom(void* data, int size) { > - int result; > - > - result = RAND_pseudo_bytes((BYTE*) data, size); > - > - if (result <= 0) > - vtpmlogerror (VTPM_LOG_CRYPTO, "RAND_pseudo_bytes failed: %s\n", > - ERR_error_string (ERR_get_error(), NULL)); > -} > diff --git a/tools/vtpm_manager/crypto/crypto.h b/tools/vtpm_manager/crypto/crypto.h > deleted file mode 100644 > index 488d4d6..0000000 > --- a/tools/vtpm_manager/crypto/crypto.h > +++ /dev/null > @@ -1,175 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// crypto.h > -// > -// This file defines the TPM Crypto API > -// > -// ================================================================== > - > -#ifndef __CRYPTO_H__ > -#define __CRYPTO_H__ > - > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "sym_crypto.h" > - > -#define CRYPTO_MAX_SIG_SIZE (2048 / 8) > -#define CRYPTO_MAX_RSA_KEY_SIZE (4096 / 8) //in bytes > - > -#define OAEP_P "TCPA" > -#define OAEP_P_SIZE 4 > - > -// Algorithms supported by crypto. Stored in CRYPTO_INFO.algorithmID > -#define CRYPTO_ALGORITH_RSA 0x01 > - > -// Supported Encryption Schemes CRYPTO_INFO.encScheme > -#define CRYPTO_ES_NONE 0x0001 > -#define CRYPTO_ES_RSAESPKCSv15 0x0002 > -#define CRYPTO_ES_RSAESOAEP_SHA1_MGF1 0x0003 > - > -// Supported Signature schemes CRYPTO_INFO.sigScheme > -#define CRYPTO_SS_NONE 0x0001 > -#define CRYPTO_SS_RSASSAPKCS1v15_SHA1 0x0002 > -#define CRYPTO_SS_RSASSAPKCS1v15_DER 0x0003 > - > -typedef struct CRYPTO_INFO { > - void *keyInfo; > - UINT32 algorithmID; > - UINT32 encScheme; > - UINT32 sigScheme; > -} CRYPTO_INFO; > - > - > -void Crypto_Init(const BYTE* rand, int size); > - > -void Crypto_Exit(); > - > -void Crypto_GetRandom(void* data, int size); > - > -void Crypto_HMAC( const BYTE* text, > - int text_len, > - const BYTE* key, > - int key_len, > - BYTE* digest); > - > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > - const buffer_t * key, > - BYTE * o_digest); /* presumably of 20 bytes */ > - > -void Crypto_SHA1Full( const BYTE* text, > - UINT32 size, > - BYTE* hash); //Complete 3part SHA1 > - > -// o_hash needs to be large enough to hold the digest, ie 20 bytes > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > - BYTE * o_hash); > - > -void Crypto_SHA1Start(UINT32* maxNumBytes); > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData); > -void Crypto_SHA1Complete( int hashDataSize, > - const BYTE* hashData, > - BYTE* hashValue); > - > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > - /*in*/ UINT32 pubExpSize, > - /*in*/ BYTE *pubExp, > - /*out*/ UINT32 *privExpSize, > - /*out*/ BYTE *privExp, > - /*out*/ UINT32 *modulusSize, > - /*out*/ BYTE *modulus, > - /*out*/ CRYPTO_INFO *keys); > - > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 privExpSize, > - /*[IN]*/ BYTE *privExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - /*[OUT]*/ CRYPTO_INFO* cryptoInfo); > - > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo); > - > -// > -// symmetric pack and unpack operations > -// > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > - BYTE ** io_buf, UINT32 * io_buflen); > - > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > - BYTE * in, UINT32 len, > - UINT32 * o_lenread); > - > - > -// return 0 on success, -1 on error > -int Crypto_RSAEnc( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData); > - > -// return 0 on success, -1 on error > -int Crypto_RSADec( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData); > - > -// return 0 on success, -1 on error > -int Crypto_RSASign( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *sigSize, > - /*out*/ BYTE *sig); > - > -bool Crypto_RSAVerify( CRYPTO_INFO *keys, > - UINT32 inDataSize, > - BYTE *inData, > - UINT32 sigSize, > - BYTE *sig); > - > -//private: > -int RSA_verify_DER(int dtype, unsigned char *m, unsigned int m_len, > - unsigned char *sigbuf, unsigned int siglen, CRYPTO_INFO *key); > - > -int RSA_sign_DER(int type, unsigned char *m, unsigned int m_len, > - unsigned char *sigret, unsigned int *siglen, CRYPTO_INFO *key); > - > -#endif // __CRYPTO_H__ > diff --git a/tools/vtpm_manager/crypto/hash.c b/tools/vtpm_manager/crypto/hash.c > deleted file mode 100644 > index c73114a..0000000 > --- a/tools/vtpm_manager/crypto/hash.c > +++ /dev/null > @@ -1,153 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// hash.c > -// > -// This file will handle all the TPM Hash functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" // for TPM_SUCCESS > -#include "crypto.h" > - > -static SHA_CTX g_shaContext; > - > -void Crypto_HMAC( const BYTE* text, > - int text_len, > - const BYTE* key, > - int key_len, > - BYTE* digest) { > - if (text == NULL || key == NULL || text_len == 0 || key_len == 0) > - return; > - > - HMAC(EVP_sha1(), key, key_len, text, text_len, digest, NULL); > -} > - > -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, > - const buffer_t * key, > - BYTE * o_digest) { /* presumably of 20 bytes */ > - > - Crypto_HMAC (text->bytes, text->size, > - key->bytes, key->size, > - o_digest); > - > - return TPM_SUCCESS; > -} > - > - > -/* > - * SHA1 > - * (OUT) Create a SHA1 hash of text. Calls all three SHA1 steps internally > - */ > -void Crypto_SHA1Full( const BYTE* text, > - uint32_t size, > - BYTE* hash) { > - > - if (text == NULL || size == 0) > - return; > - > - // Run SHA1Start + SHAUpdate (if necessary) + SHAComplete > - uint32_t maxBytes; // Not used for anything > - Crypto_SHA1Start(&maxBytes); > - > - while (size > 64){ > - Crypto_SHA1Update(64, text); > - size -= 64; > - text += 64; > - } > - > - Crypto_SHA1Complete(size, text, hash); > -} > - > -// same thing using buffer_t > -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, > - BYTE * o_digest) { > - > - if (buf->bytes == NULL || buf->size == 0) > - return TPM_BAD_PARAMETER; > - > - Crypto_SHA1Full (buf->bytes, buf->size, o_digest); > - > - return TPM_SUCCESS; > -} > - > - > -/* > - * Initialize SHA1 > - * (OUT) Maximum number of bytes that can be sent to SHA1Update. > - * Must be a multiple of 64 bytes. > - */ > -void Crypto_SHA1Start(uint32_t* maxNumBytes) { > - int max = SHA_CBLOCK; > - // Initialize the crypto library > - SHA1_Init(&g_shaContext); > - *maxNumBytes = max; > -} > - > -/* > - * Process SHA1 > - * @numBytes: (IN) The number of bytes in hashData. > - * Must be a multiple of 64 bytes. > - * @hashData: (IN) Bytes to be hashed. > - */ > -void Crypto_SHA1Update(int numBytes, const BYTE* hashData) { > - > - if (hashData == NULL || numBytes == 0 || numBytes%64 != 0) > - return; > - > - SHA1_Update(&g_shaContext, hashData, numBytes); > -} > - > -/* > - * Complete the SHA1 process > - * @hashDataSize: (IN) Number of bytes in hashData. > - * Must be a multiple of 64 bytes. > - * @hashData: (IN) Final bytes to be hashed. > - * @hashValue: (OUT) The output of the SHA-1 hash. > - */ > -void Crypto_SHA1Complete(int hashDataSize, > - const BYTE* hashData, > - BYTE* hashValue) { > - SHA1_Update(&g_shaContext, hashData, hashDataSize); > - SHA1_Final(hashValue, &g_shaContext); > -} > diff --git a/tools/vtpm_manager/crypto/rsa.c b/tools/vtpm_manager/crypto/rsa.c > deleted file mode 100644 > index 7737dc6..0000000 > --- a/tools/vtpm_manager/crypto/rsa.c > +++ /dev/null > @@ -1,434 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// rsa.c > -// > -// This file will handle all the TPM RSA crypto functionality > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "crypto.h" > -#include "log.h" > - > -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, > - /*in*/ UINT32 pubExpSize, > - /*in*/ BYTE *pubExp, > - /*out*/ UINT32 *privExpSize, > - /*out*/ BYTE *privExp, > - /*out*/ UINT32 *modulusSize, > - /*out*/ BYTE *modulus, > - /*out*/ CRYPTO_INFO *keys) { > - unsigned long e_value; > - > - if (pubExpSize == 0) // Default e = 2^16+1 > - e_value = (0x01 << 16) + 1; > - else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - e_value = (0x01 << 16) + 1; > - } > - > - RSA *rsa = RSA_generate_key(keySize, e_value, NULL, NULL); > - > - if (keys) { > - keys->keyInfo = rsa; > - keys->algorithmID = CRYPTO_ALGORITH_RSA; > - } > - > - if (modulus) *modulusSize = BN_bn2bin(rsa->n, modulus); > - if (privExp) *privExpSize = BN_bn2bin(rsa->d, privExp); > -} > - > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > -// If pubExp info is NULL, use TCG default. > -// If there is a remainder while calculating the privExp, return FALSE. > - > -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 privExpSize, > - /*[IN]*/ BYTE *privExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo) { > - cryptoInfo->keyInfo = RSA_new(); > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - rsa->e = BN_new(); > - > - if (pubExpSize == 0) { // Default e = 2^16+1 > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } > - > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > - rsa->d = BN_bin2bn(privExp, privExpSize, NULL); > -} > - > -// Create a CRYPTO_INFO struct from the BYTE * key parts. > -// If pubExp info is NULL, use TCG default. > -// If there is a remainder while calculating the privExp, return FALSE. > - > -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, > - /*[IN]*/ BYTE *pubExp, > - /*[IN]*/ UINT32 modulusSize, > - /*[IN]*/ BYTE *modulus, > - CRYPTO_INFO* cryptoInfo) { > - cryptoInfo->keyInfo = RSA_new(); > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - rsa->e = BN_new(); > - > - if (pubExpSize == 0) { // Default e = 2^16+1 > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } else { > - // This is not supported, but the following line MIGHT work > - // under then assumption that the format is BigNum compatable > - // Though it's not in the spec, so who knows what it is. > - // Forcing the default. > - //BN_bin2bn(pubExp, pubExpSize, NULL); > - BN_set_bit(rsa->e, 16); > - BN_set_bit(rsa->e, 0); > - } > - > - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); > - > -} > - > -int Crypto_RSAEnc( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData) { > - RSA *rsa = (RSA *) key->keyInfo; > - UINT32 paddedDataSize = RSA_size (rsa); > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > - int rc; > - > - if (paddedData == NULL) > - return -1; > - > - *outDataSize = 0; > - > - switch (key->encScheme) { > - case CRYPTO_ES_RSAESPKCSv15: > - if (RSA_padding_add_PKCS1_type_2(paddedData, paddedDataSize, inData, inDataSize) <= 0) { > - rc = -1; > - goto abort_egress; > - } > - break; > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > - if (RSA_padding_add_PKCS1_OAEP(paddedData,paddedDataSize,inData,inDataSize, (BYTE *) OAEP_P,OAEP_P_SIZE) <= 0 ) { > - rc = -1; > - goto abort_egress; > - } > - break; > - default: > - rc = -1; > - goto abort_egress; > - } > - > - rc = RSA_public_encrypt(paddedDataSize, paddedData, outData, rsa, RSA_NO_PADDING); > - if (rc == -1) > - goto abort_egress; > - > - *outDataSize = rc; > - > - if (rc > 0) rc = 0; > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (paddedData) > - free (paddedData); > - return rc; > - > -} > - > -int Crypto_RSADec( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *outDataSize, > - /*out*/ BYTE *outData) { > - > - RSA *rsa = (RSA *) key->keyInfo; > - UINT32 paddedDataSize = RSA_size (rsa); > - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); > - int rc; > - > - if (paddedData == NULL) > - goto abort_egress; > - > - rc = RSA_private_decrypt(inDataSize, inData, paddedData, rsa, RSA_NO_PADDING); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_private_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - > - paddedDataSize = rc; > - > - switch (key->encScheme) { > - case CRYPTO_ES_RSAESPKCSv15: > - rc = RSA_padding_check_PKCS1_type_2 (outData, paddedDataSize, > - paddedData + 1, paddedDataSize - 1, > - RSA_size(rsa)); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_type_2: %s\n", > - ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - *outDataSize = rc; > - break; > - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: > - rc = RSA_padding_check_PKCS1_OAEP(outData, paddedDataSize, > - paddedData + 1, paddedDataSize - 1, > - RSA_size(rsa), > - (BYTE *) OAEP_P, OAEP_P_SIZE); > - if (rc == -1) { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_OAEP: %s\n", > - ERR_error_string(ERR_get_error(), NULL)); > - goto abort_egress; > - } > - *outDataSize = rc; > - break; > - default: > - *outDataSize = 0; > - } > - > - free(paddedData); paddedData = NULL; > - goto egress; > - > - abort_egress: > - > - if (paddedData) > - free (paddedData); > - return -1; > - > - egress: > - return 0; > -} > - > -// Signs either a SHA1 digest of a message or a DER encoding of a message > -// Textual messages MUST be encoded or Hashed before sending into this function > -// It will NOT SHA the message. > -int Crypto_RSASign( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - /*out*/ UINT32 *sigSize, > - /*out*/ BYTE *sig) { > - int status; > - unsigned int intSigSize; > - > - switch(key->sigScheme) { > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > - status = RSA_sign(NID_sha1, inData, inDataSize, sig, &intSigSize, (RSA *) key->keyInfo); > - break; > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > - // status = Crypto_RSA_sign_DER(NID_md5_sha1, inData, inDataSize, sig, &intSigSize, key); > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > - status = 0; > - break; > - default: > - status = 0; > - } > - > - if (status == 0) { > - *sigSize = 0; > - vtpmlogerror(VTPM_LOG_CRYPTO, "%s\n", ERR_error_string(ERR_get_error(), NULL)); > - return -1; > - } > - > - *sigSize = (UINT32) intSigSize; > - return 0; > -} > - > -bool Crypto_RSAVerify( CRYPTO_INFO *key, > - UINT32 inDataSize, > - BYTE *inData, > - UINT32 sigSize, > - BYTE *sig) { > - int status; > - > - switch(key->sigScheme){ > - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: > - status = RSA_verify(NID_sha1, inData, inDataSize, sig, sigSize, (RSA *) key->keyInfo); > - break; > - case CRYPTO_SS_RSASSAPKCS1v15_DER: > - //status = Crypto_RSA_verify_DER(NID_md5_sha1, inData, inDataSize, sig, sigSize, key); > - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); > - status = 0; > - break; > - default: > - status = 0; > - } > - > - if (status) > - return(1); > - else { > - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA verify: %s\n", ERR_error_string(ERR_get_error(), NULL)); > - return(0); > - } > - > -} > - > -// helper which packs everything into a BIO! > - > -// packs the parameters first, then the private key, then the public key > -// if *io_buf is NULL, allocate it here as needed. otherwise its size is in > -// *io_buflen > -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, > - BYTE ** io_buf, UINT32 * io_buflen) { > - TPM_RESULT status = TPM_SUCCESS; > - BYTE * buf; > - long len, outlen = *io_buflen; > - > - const long PARAMSLEN = 3*sizeof(UINT32); > - > - RSA *rsa = (RSA *) cryptoInfo->keyInfo; > - > - BIO *mem = BIO_new(BIO_s_mem()); > - > - > - // write the openssl keys to the BIO > - if ( i2d_RSAPrivateKey_bio (mem, rsa) == 0 ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_SIZE); > - } > - if ( i2d_RSAPublicKey_bio (mem, rsa) == 0 ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_SIZE); > - } > - > - // get the buffer out > - len = BIO_get_mem_data (mem, &buf); > - > - // see if we need to allocate a return buffer > - if (*io_buf == NULL) { > - *io_buf = (BYTE*) malloc (PARAMSLEN + len); > - if (*io_buf == NULL) > - ERRORDIE (TPM_SIZE); > - } else { // *io_buf is already allocated > - if (outlen < len + PARAMSLEN) > - ERRORDIE (TPM_SIZE); // but not large enough! > - } > - > - // copy over the parameters (three UINT32's starting at algorithmID) > - memcpy (*io_buf, &cryptoInfo->algorithmID, PARAMSLEN); > - > - // copy over the DER keys > - memcpy (*io_buf + PARAMSLEN, buf, len); > - > - *io_buflen = len + PARAMSLEN; > - > - goto egress; > - > - > - abort_egress: > - egress: > - > - BIO_free (mem); > - > - return status; > -} > - > - > - > -// sets up ci, and returns the number of bytes read in o_lenread > -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, > - BYTE * in, UINT32 len, > - UINT32 * o_lenread) { > - > - TPM_RESULT status = TPM_SUCCESS; > - long l; > - BIO *mem; > - RSA *rsa; > - > - // first load up the params > - l = 3 * sizeof(UINT32); > - memcpy (&ci->algorithmID, in, l); > - len -= l; > - in += l; > - > - // and now the openssl keys, private first > - mem = BIO_new_mem_buf (in, len); > - > - if ( (rsa = d2i_RSAPrivateKey_bio (mem, NULL)) == NULL ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_BAD_PARAMETER); > - } > - // now use the same RSA object and fill in the private key > - if ( d2i_RSAPublicKey_bio (mem, &rsa) == NULL ) { > - ERR_print_errors_fp (stderr); > - ERRORDIE (TPM_BAD_PARAMETER); > - } > - > - ci->keyInfo = rsa; // needs to be freed somehow later > - > - // FIXME: havent figured out yet how to tell how many bytes were read in the > - // above oprations! so o_lenread is not set > - > - goto egress; > - > - abort_egress: > - egress: > - > - BIO_free (mem); > - > - return status; > -} > diff --git a/tools/vtpm_manager/crypto/sym_crypto.c b/tools/vtpm_manager/crypto/sym_crypto.c > deleted file mode 100644 > index 3d86e19..0000000 > --- a/tools/vtpm_manager/crypto/sym_crypto.c > +++ /dev/null > @@ -1,237 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// sym_crypto.c > -// > -// Symmetric crypto portion of crypto > -// > -// ================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "sym_crypto.h" > - > -typedef enum crypt_op_type_t { > - CRYPT_ENCRYPT, > - CRYPT_DECRYPT > -} crypt_op_type_t; > - > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > - const buffer_t* in, > - const buffer_t* iv, > - buffer_t * out, > - crypt_op_type_t optype); > - > - > -// this is initialized in Crypto_Init() > -const EVP_CIPHER * SYM_CIPHER = NULL; > - > -const BYTE ZERO_IV[EVP_MAX_IV_LENGTH] = {0}; > - > - > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits) { > - TPM_RESULT status = TPM_SUCCESS; > - > - EVP_CIPHER_CTX_init (&key->context); > - > - key->cipher = SYM_CIPHER; > - > - TPMTRYRETURN( buffer_init_copy (&key->key, keybits)); > - > - goto egress; > - > - abort_egress: > - EVP_CIPHER_CTX_cleanup (&key->context); > - > - egress: > - > - return status; > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key) { > - int res; > - TPM_RESULT status = TPM_SUCCESS; > - > - // hmm, EVP_CIPHER_CTX_init does not return a value > - EVP_CIPHER_CTX_init (&key->context); > - > - key->cipher = SYM_CIPHER; > - > - TPMTRYRETURN( buffer_init (&key->key, EVP_CIPHER_key_length(key->cipher), NULL)) ; > - > - // and generate the key material > - res = RAND_pseudo_bytes (key->key.bytes, key->key.size); > - if (res < 0) > - ERRORDIE (TPM_SHORTRANDOM); > - > - > - goto egress; > - > - abort_egress: > - EVP_CIPHER_CTX_cleanup (&key->context); > - buffer_free (&key->key); > - > - egress: > - return status; > -} > - > - > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > - const buffer_t* clear, > - buffer_t* o_cipher) { > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t iv, cipher_alias; > - > - buffer_init_const (&iv, EVP_MAX_IV_LENGTH, ZERO_IV); > - > - buffer_init (o_cipher, > - clear->size + > - EVP_CIPHER_iv_length(key->cipher) + > - EVP_CIPHER_block_size (key->cipher), > - 0); > - > - // copy the IV into the front > - buffer_copy (o_cipher, &iv); > - > - // make an alias into which we'll put the ciphertext > - buffer_init_alias (&cipher_alias, o_cipher, EVP_CIPHER_iv_length(key->cipher), 0); > - > - TPMTRYRETURN( ossl_symcrypto_op (key, clear, &iv, &cipher_alias, CRYPT_ENCRYPT) ); > - > - // set the output size correctly > - o_cipher->size += cipher_alias.size; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > - > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > - const buffer_t* cipher, > - buffer_t* o_clear) { > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t iv, cipher_alias; > - > - // alias for the IV > - buffer_init_alias (&iv, cipher, 0, EVP_CIPHER_iv_length(key->cipher)); > - > - // make an alias to where the ciphertext is, after the IV > - buffer_init_alias (&cipher_alias, cipher, EVP_CIPHER_iv_length(key->cipher), 0); > - > - // prepare the output buffer > - TPMTRYRETURN( buffer_init (o_clear, > - cipher->size > - - EVP_CIPHER_iv_length(key->cipher) > - + EVP_CIPHER_block_size(key->cipher), > - 0) ); > - > - // and decrypt > - TPMTRYRETURN ( ossl_symcrypto_op (key, &cipher_alias, &iv, o_clear, CRYPT_DECRYPT) ); > - > - goto egress; > - > - abort_egress: > - buffer_free (o_clear); > - > - egress: > - > - return status; > -} > - > - > - > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key) { > - buffer_memset (&key->key, 0); > - buffer_free (&key->key); > - > - EVP_CIPHER_CTX_cleanup (&key->context); > - > - return TPM_SUCCESS; > -} > - > - > -TPM_RESULT ossl_symcrypto_op (symkey_t* key, > - const buffer_t* in, > - const buffer_t* iv, > - buffer_t * out, > - crypt_op_type_t optype) { > - TPM_RESULT status = TPM_SUCCESS; > - > - int inlen, outlen; > - tpm_size_t running; > - > - if ( ! EVP_CipherInit_ex (&key->context, > - key->cipher, NULL, key->key.bytes, iv->bytes, > - optype == CRYPT_ENCRYPT ? 1 : 0) ) > - ERRORDIE (TPM_FAIL); > - > - > - > - inlen = in->size; > - > - outlen = 0; > - running = 0; > - > - > - if ( ! EVP_CipherUpdate (&key->context, out->bytes, &outlen, in->bytes, inlen) ) > - ERRORDIE (TPM_FAIL); > - > - running += outlen; > - > - if ( ! EVP_CipherFinal_ex (&key->context, out->bytes + running, &outlen) ) > - ERRORDIE (TPM_FAIL); > - > - running += outlen; > - > - out->size = running; > - > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/crypto/sym_crypto.h b/tools/vtpm_manager/crypto/sym_crypto.h > deleted file mode 100644 > index 7fb59a8..0000000 > --- a/tools/vtpm_manager/crypto/sym_crypto.h > +++ /dev/null > @@ -1,72 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// sym_crypto.h > -// > -// Symmetric Crypto > -// > -// ================================================================== > - > -#ifndef _SYM_CRYPTO_H > -#define _SYM_CRYPTO_H > - > -#include > -#include "buffer.h" > - > -typedef struct symkey_t { > - buffer_t key; > - > - EVP_CIPHER_CTX context; > - const EVP_CIPHER * cipher; > -} symkey_t; > - > -extern const EVP_CIPHER * SYM_CIPHER; > - > -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key); > - > -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits); > - > - > -// these functions will allocate their output buffers > -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, > - const buffer_t* clear, > - buffer_t* o_cipher); > - > -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, > - const buffer_t* cipher, > - buffer_t* o_clear); > - > -// only free the internal parts, not the 'key' ptr > -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key); > - > -#endif /* _SYM_CRYPTO_H */ > diff --git a/tools/vtpm_manager/manager/Makefile b/tools/vtpm_manager/manager/Makefile > deleted file mode 100644 > index a33c18a..0000000 > --- a/tools/vtpm_manager/manager/Makefile > +++ /dev/null > @@ -1,38 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = vtpm_managerd > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - if [ ! -d "$(DESTDIR)/var/vtpm/fifos" ]; \ > - then mkdir -p $(DESTDIR)/var/vtpm/fifos; \ > - fi > - if [ ! -d "$(DESTDIR)/var/vtpm/socks" ]; \ > - then mkdir -p $(DESTDIR)/var/vtpm/socks; \ > - fi > - $(INSTALL_PROG) $(BIN) $(DESTDIR)$(BINDIR) > - > -.PHONY: clean > -clean: > - rm -f $(BIN) > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -# libraries > -LIBS += ../tcs/libTCS.a ../util/libTCGUtils.a ../crypto/libtcpaCrypto.a > -LIBS += -lcrypto $(PTHREAD_LIBS) -lm > -CFLAGS += $(PTHREAD_CFLAGS) > -LDFLAGS += $(PTHREAD_LDFLAGS) > diff --git a/tools/vtpm_manager/manager/dmictl.c b/tools/vtpm_manager/manager/dmictl.c > deleted file mode 100644 > index 5c3cf7e..0000000 > --- a/tools/vtpm_manager/manager/dmictl.c > +++ /dev/null > @@ -1,266 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// dmictl.c > -// > -// Functions for creating and destroying DMIs > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpmpriv.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "log.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "vtpm_ipc.h" > - > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > - > -// if dmi_res is non-null, then return a pointer to new object. > -// Also, this does not fill in the measurements. They should be filled by > -// design dependent code or saveNVM > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE dmi_type, VTPM_DMI_RESOURCE **dmi_res) { > - > - TPM_RESULT status=TPM_SUCCESS; > - VTPM_DMI_RESOURCE *new_dmi=NULL; > - UINT32 *dmi_id_key=NULL; > - > - if ((new_dmi = (VTPM_DMI_RESOURCE *) malloc (sizeof(VTPM_DMI_RESOURCE))) == NULL) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - memset(new_dmi, 0, sizeof(VTPM_DMI_RESOURCE)); > - new_dmi->dmi_id = dmi_id; > - new_dmi->dmi_type = dmi_type; > - new_dmi->connected = FALSE; > - new_dmi->TCSContext = 0; > - > - new_dmi->NVMLocation = (char *) malloc(11 + strlen(DMI_NVM_FILE)); > - sprintf(new_dmi->NVMLocation, DMI_NVM_FILE, (uint32_t) new_dmi->dmi_id); > - > - if ((dmi_id_key = (UINT32 *) malloc (sizeof(UINT32))) == NULL) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - *dmi_id_key = new_dmi->dmi_id; > - > - // install into map > - if (!hashtable_insert(vtpm_globals->dmi_map, dmi_id_key, new_dmi)){ > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to insert instance into table. Aborting.\n", dmi_id); > - status = TPM_FAIL; > - goto abort_egress; > - } > - > - if (dmi_res) > - *dmi_res = new_dmi; > - > - goto egress; > - > - abort_egress: > - if (new_dmi) { > - free(new_dmi->NVMLocation); > - free(new_dmi); > - } > - free(dmi_id_key); > - > - egress: > - return status; > -} > - > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res) { > - if (dmi_res == NULL) > - return TPM_SUCCESS; > - > - if (dmi_res->dmi_id == VTPM_CTL_DM) > - return(TPM_BAD_PARAMETER); > - > - TCS_CloseContext(dmi_res->TCSContext); > - dmi_res->connected = FALSE; > - > - vtpm_globals->connected_dmis--; > - > - return (VTPM_Close_DMI_Extra(dmi_res) ); > -} > - > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf) { > - > - VTPM_DMI_RESOURCE *new_dmi=NULL; > - TPM_RESULT status=TPM_FAIL; > - BYTE dmi_type, vm_type, startup_mode; > - UINT32 dmi_id; > - > - if (param_buf == NULL) { // Assume creation of Dom 0 control > - dmi_type = VTPM_TYPE_NON_MIGRATABLE; > - dmi_id = VTPM_CTL_DM; > - } else if (buffer_len(param_buf) != sizeof(BYTE) * 3 + sizeof(UINT32)) { > - vtpmloginfo(VTPM_LOG_VTPM, "New DMI command wrong length: %d.\n", buffer_len(param_buf)); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } else { > - vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0 > - BSG_UnpackList( param_buf->bytes, 4, > - BSG_TYPE_BYTE, &dmi_type, > - BSG_TYPE_BYTE, &startup_mode, > - BSG_TYPE_BYTE, &vm_type, > - BSG_TYPE_UINT32, &dmi_id); > - } > - > - if ((dmi_type != VTPM_TYPE_NON_MIGRATABLE) && (dmi_type != VTPM_TYPE_MIGRATABLE)) { > - vtpmlogerror(VTPM_LOG_VTPM, "Creation of VTPM with illegal type.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - new_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (new_dmi == NULL) { > - vtpmloginfo(VTPM_LOG_VTPM, "Creating new DMI instance %d attached.\n", dmi_id ); > - // Brand New DMI. Initialize the persistent pieces > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &new_dmi) ); > - } else > - vtpmloginfo(VTPM_LOG_VTPM, "Re-attaching DMI instance %d.\n", dmi_id); > - > - if (new_dmi->connected) { > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach, currently attached instance %d. Ignoring\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (new_dmi->dmi_type == VTPM_TYPE_MIGRATED) { > - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach previously migrated instance %d without recovering first. Ignoring\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Initialize the Non-persistent pieces > - TPMTRYRETURN( TCS_OpenContext(&new_dmi->TCSContext) ); > - > - new_dmi->connected = TRUE; > - > - // Design specific new DMI code. > - // Includes: create IPCs, Measuring DMI, and maybe launching DMI > - TPMTRYRETURN(VTPM_New_DMI_Extra(new_dmi, vm_type, startup_mode) ); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create DMI id=%d due to status=%s. Cleaning.\n", dmi_id, tpm_get_error_name(status)); > - close_dmi(new_dmi ); > - > - egress: > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Close_DMI( const buffer_t *param_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *dmi_res=NULL; > - UINT32 dmi_id; > - > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size."); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - BSG_UnpackList( param_buf->bytes, 1, > - BSG_TYPE_UINT32, &dmi_id); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Closing DMI %d.\n", dmi_id); > - > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (dmi_res == NULL ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Trying to close nonexistent DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (!dmi_res->connected) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-connected DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Close Dmi > - TPMTRYRETURN(close_dmi( dmi_res )); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Delete_DMI( const buffer_t *param_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *dmi_res=NULL; > - UINT32 dmi_id; > - > - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - BSG_UnpackList( param_buf->bytes, 1, > - BSG_TYPE_UINT32, &dmi_id); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Deleting DMI %d.\n", dmi_id); > - > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_remove(vtpm_globals->dmi_map, &dmi_id); > - if (dmi_res == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-existent DMI.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - //vtpm scripts delete file dmi_res->NVMLocation for us > - > - // Close DMI first > - TPMTRYRETURN(close_dmi( dmi_res )); > - free ( dmi_res ); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/manager/migration.c b/tools/vtpm_manager/manager/migration.c > deleted file mode 100644 > index 54da708..0000000 > --- a/tools/vtpm_manager/manager/migration.c > +++ /dev/null > @@ -1,307 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// dmictl.c > -// > -// Functions for creating and destroying DMIs > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpmpriv.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "log.h" > -#include "hashtable.h" > - > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *mig_dmi=NULL; > - UINT32 dmi_id; > - buffer_t dmi_state_abuf = NULL_BUF, enc_dmi_abuf = NULL_BUF, clear_dmi_blob = NULL_BUF; > - > - if (param_buf == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - struct pack_buf_t enc_dmi_state_pack; > - > - BSG_UnpackList(param_buf->bytes, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_SIZE32_DATA, &enc_dmi_state_pack) ; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating VTPM in dmi %d.\n", dmi_id); > - > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (mig_dmi) { > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming VTPM claims unavailable id: %d.\n", dmi_id); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** UnBind Blob **/ > - TPMTRYRETURN( buffer_init_alias_convert( &enc_dmi_abuf, > - enc_dmi_state_pack.size, > - enc_dmi_state_pack.data) ); > - > - TPMTRYRETURN( envelope_decrypt( &enc_dmi_abuf, > - vtpm_globals->manager_tcs_handle, > - vtpm_globals->storageKeyHandle, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - &clear_dmi_blob) ); > - > - // Create new dmi > - TPMTRYRETURN( init_dmi(dmi_id, VTPM_TYPE_MIGRATABLE, &mig_dmi ) ); > - > - /** Open Blob **/ > - struct pack_buf_t dmi_state_pack; > - > - BSG_UnpackList(clear_dmi_blob.bytes, 2, > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > - > - TPMTRYRETURN( buffer_init_alias_convert(&dmi_state_abuf, > - dmi_state_pack.size, > - dmi_state_pack.data) ); > - > - TPMTRYRETURN( VTPM_Handle_Save_NVM(mig_dmi, &dmi_state_abuf, NULL ) ); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration IN of instance %d failed because of %s.\n", dmi_id, tpm_get_error_name(status) ); > - > - egress: > - buffer_free(&clear_dmi_blob); > - buffer_free(&dmi_state_abuf); > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Migrate_Out( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_DMI_RESOURCE *mig_dmi; > - UINT32 dmi_id; > - VTPM_MIGKEY_LIST *last_mig, *mig_key; > - buffer_t dmi_state=NULL_BUF, clear_dmi_blob=NULL_BUF; > - > - if (param_buf == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - struct pack_buf_t name_pack; > - > - BSG_UnpackList( param_buf->bytes, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_SIZE32_DATA, &name_pack); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Migrating out dmi %d.\n", dmi_id); > - > - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); > - if (mig_dmi == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Non-existent VTPM instance (%d) in migration.\n", dmi_id ); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - if (mig_dmi->dmi_type != VTPM_TYPE_MIGRATABLE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Bad VTPM type (%d) in migration of instance (%d).\n", mig_dmi->dmi_type, dmi_id ); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** Find migration key for dest **/ > - last_mig = NULL; > - mig_key = vtpm_globals->mig_keys; > - while (mig_key != NULL) { > - if (mig_key->name_size == name_pack.size) > - if (memcmp(mig_key->name, name_pack.data, name_pack.size) == 0) { > - break; > - } > - > - last_mig = mig_key; > - mig_key = mig_key->next; > - } > - > - if (!mig_key) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unknown Migration target host.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /** Mark vtpm as migrated **/ > - mig_dmi->dmi_type = VTPM_TYPE_MIGRATED; > - > - /** Build Blob **/ > - TPMTRYRETURN( VTPM_Handle_Load_NVM(mig_dmi, NULL, &dmi_state) ); > - > - TPMTRYRETURN( buffer_init(&clear_dmi_blob, sizeof(TPM_DIGEST) + sizeof(UINT32) + buffer_len(&dmi_state), NULL ) ); > - > - struct pack_constbuf_t dmi_state_pack; > - > - dmi_state_pack.size = buffer_len(&dmi_state); > - dmi_state_pack.data = dmi_state.bytes; > - > - BSG_PackList(clear_dmi_blob.bytes, 2, > - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, > - BSG_TPM_SIZE32_DATA, &dmi_state_pack); > - > - /** Bind Blob **/ > - TPMTRYRETURN( envelope_encrypt( &clear_dmi_blob, > - &mig_key->key, > - result_buf) ); > - > - if (last_mig) > - last_mig->next = mig_key->next; > - else > - vtpm_globals->mig_keys = mig_key->next; > - > - free(mig_key->name); > - free(mig_key); > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration OUT of instance %d failed because of %s. Migratoin recovery may be needed.\n", dmi_id, tpm_get_error_name(status) ); > - > - //TODO: Create and implement a policy for what happens to mig_key on failed migrations. > - > - egress: > - > - buffer_free(&clear_dmi_blob); > - buffer_free(&dmi_state); > - > - return status; > -} > - > - > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Getting Migration Public Key.\n"); > - > - struct pack_buf_t pubkey_exp_pack, pubkey_mod_pack; > - TPM_KEY mig_key; > - > - // Unpack/return key structure > - BSG_Unpack(BSG_TPM_KEY, vtpm_globals->storageKeyWrap.bytes , &mig_key); > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - mig_key.algorithmParms.parms, > - &rsaKeyParms); > - > - pubkey_exp_pack.size = rsaKeyParms.exponentSize; > - pubkey_exp_pack.data = rsaKeyParms.exponent; > - pubkey_mod_pack.size = mig_key.pubKey.keyLength; > - pubkey_mod_pack.data = mig_key.pubKey.key; > - > - TPMTRYRETURN( buffer_init( result_buf, 2*sizeof(UINT32) + > - pubkey_exp_pack.size + > - pubkey_mod_pack.size, NULL ) ); > - > - BSG_PackList( result_buf->bytes, 2, > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > - > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Get Migration Key failed because of %s.\n", tpm_get_error_name(status) ); > - egress: > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Load_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf) { > - > - TPM_RESULT status=TPM_FAIL; > - VTPM_MIGKEY_LIST *mig_key; > - > - vtpmloginfo(VTPM_LOG_VTPM, "Loading Migration Public Key.\n"); > - > - //FIXME: Review all uses of unpacking pack_buf_t and ensure free. > - //FIXME: Review all declarations/initializations of buffer_t that could have a goto that skips them and then tries to free them > - > - struct pack_buf_t name_pack, pubkey_exp_pack, pubkey_mod_pack; > - > - //FIXME: scan list and verify name is not already in the list > - > - BSG_UnpackList( param_buf->bytes, 3, > - BSG_TPM_SIZE32_DATA, &name_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, > - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); > - > - //TODO: Maintain a persistent list for pub_keys. > - //TODO: Verify pub_key is trusted > - > - mig_key = (VTPM_MIGKEY_LIST *) malloc(sizeof(VTPM_MIGKEY_LIST)); > - memset(mig_key, 0, sizeof(VTPM_MIGKEY_LIST) ); > - mig_key->name_size = name_pack.size; > - mig_key->name = name_pack.data; > - > - mig_key->key.encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - Crypto_RSABuildCryptoInfoPublic( pubkey_exp_pack.size, > - pubkey_exp_pack.data, > - pubkey_mod_pack.size, > - pubkey_mod_pack.data, > - &mig_key->key); > - > - > - mig_key->next = vtpm_globals->mig_keys; > - vtpm_globals->mig_keys = mig_key; > - > - // free(name_pack.data); Do not free. data is now part of mig_key. > - free(pubkey_exp_pack.data); > - free(pubkey_mod_pack.data); > - > - return TPM_SUCCESS; > -} > diff --git a/tools/vtpm_manager/manager/securestorage.c b/tools/vtpm_manager/manager/securestorage.c > deleted file mode 100644 > index d5e6ffd..0000000 > --- a/tools/vtpm_manager/manager/securestorage.c > +++ /dev/null > @@ -1,512 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// securestorage.c > -// > -// Functions regarding securely storing DMI secrets. > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "crypto.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "buffer.h" > -#include "log.h" > - > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > - CRYPTO_INFO *asymkey, > - buffer_t *sealed_data) { > - TPM_RESULT status = TPM_SUCCESS; > - symkey_t symkey; > - buffer_t data_cipher = NULL_BUF, > - symkey_cipher = NULL_BUF; > - > - UINT32 i; > - struct pack_constbuf_t symkey_cipher32, data_cipher32; > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Input[%d]: 0x", buffer_len(inbuf)); > - for (i=0; i< buffer_len(inbuf); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", inbuf->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - // Generate a sym key and encrypt state with it > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_genkey (&symkey) ); > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_encrypt (&symkey, inbuf, &data_cipher) ); > - > - // Encrypt symmetric key > - TPMTRYRETURN( VTSP_Bind( asymkey, > - &symkey.key, > - &symkey_cipher) ); > - > - // Create output blob: symkey_size + symkey_cipher + state_cipher_size + state_cipher > - > - symkey_cipher32.size = buffer_len(&symkey_cipher); > - symkey_cipher32.data = symkey_cipher.bytes; > - > - data_cipher32.size = buffer_len(&data_cipher); > - data_cipher32.data = data_cipher.bytes; > - > - TPMTRYRETURN( buffer_init(sealed_data, 2 * sizeof(UINT32) + symkey_cipher32.size + data_cipher32.size, NULL)); > - > - BSG_PackList(sealed_data->bytes, 2, > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > - BSG_TPM_SIZE32_DATA, &data_cipher32); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Saved %d bytes of E(symkey) + %d bytes of E(data)\n", buffer_len(&symkey_cipher), buffer_len(&data_cipher)); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Output[%d]: 0x", buffer_len(sealed_data)); > - for (i=0; i< buffer_len(sealed_data); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", sealed_data->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope encrypt\n."); > - > - egress: > - > - buffer_free ( &data_cipher); > - buffer_free ( &symkey_cipher); > - Crypto_symcrypto_freekey (&symkey); > - > - return status; > -} > - > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > - TCS_CONTEXT_HANDLE TCSContext, > - TPM_HANDLE keyHandle, > - const TPM_AUTHDATA *key_usage_auth, > - buffer_t *unsealed_data) { > - > - TPM_RESULT status = TPM_SUCCESS; > - symkey_t symkey; > - buffer_t data_cipher = NULL_BUF, > - symkey_clear = NULL_BUF, > - symkey_cipher = NULL_BUF; > - struct pack_buf_t symkey_cipher32, data_cipher32; > - int i; > - > - memset(&symkey, 0, sizeof(symkey_t)); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypt Input[%d]: 0x", buffer_len(cipher) ); > - for (i=0; i< buffer_len(cipher); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cipher->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - BSG_UnpackList(cipher->bytes, 2, > - BSG_TPM_SIZE32_DATA, &symkey_cipher32, > - BSG_TPM_SIZE32_DATA, &data_cipher32); > - > - TPMTRYRETURN( buffer_init_alias_convert (&symkey_cipher, > - symkey_cipher32.size, > - symkey_cipher32.data) ); > - > - TPMTRYRETURN( buffer_init_alias_convert (&data_cipher, > - data_cipher32.size, > - data_cipher32.data) ); > - > - // Decrypt Symmetric Key > - TPMTRYRETURN( VTSP_Unbind( TCSContext, > - keyHandle, > - &symkey_cipher, > - key_usage_auth, > - &symkey_clear, > - &(vtpm_globals->keyAuth) ) ); > - > - // create symmetric key using saved bits > - Crypto_symcrypto_initkey (&symkey, &symkey_clear); > - > - // Decrypt State > - TPMTRY(TPM_DECRYPT_ERROR, Crypto_symcrypto_decrypt (&symkey, &data_cipher, unsealed_data) ); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypte Output[%d]: 0x", buffer_len(unsealed_data)); > - for (i=0; i< buffer_len(unsealed_data); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", unsealed_data->bytes[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope decrypt data\n."); > - > - egress: > - buffer_free ( &data_cipher); > - buffer_free ( &symkey_clear); > - buffer_free ( &symkey_cipher); > - Crypto_symcrypto_freekey (&symkey); > - > - return status; > -} > - > -TPM_RESULT VTPM_Handle_Save_NVM(VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - int fh; > - long bytes_written; > - buffer_t sealed_NVM = NULL_BUF; > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Saving %d bytes of NVM.\n", buffer_len(inbuf)); > - > - TPMTRYRETURN( envelope_encrypt(inbuf, > - &vtpm_globals->storageKey, > - &sealed_NVM) ); > - > - // Write sealed blob off disk from NVMLocation > - // TODO: How to properly return from these. Do we care if we return failure > - // after writing the file? We can't get the old one back. > - // TODO: Backup old file and try and recover that way. > - fh = open(myDMI->NVMLocation, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); > - if ( (bytes_written = write(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM) ) != (long) buffer_len(&sealed_NVM))) { > - vtpmlogerror(VTPM_LOG_VTPM, "We just overwrote a DMI_NVM and failed to finish. %ld/%ld bytes.\n", bytes_written, (long)buffer_len(&sealed_NVM)); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - close(fh); > - > - Crypto_SHA1Full (sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &myDMI->NVM_measurement); > - > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save NVM\n."); > - > - egress: > - buffer_free(&sealed_NVM); > - return status; > -} > - > - > -/* Expected Params: inbuf = null, outbuf = sealed blob size, sealed blob.*/ > -TPM_RESULT VTPM_Handle_Load_NVM(VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - > - buffer_t sealed_NVM = NULL_BUF; > - long fh_size; > - int fh, stat_ret, i; > - struct stat file_stat; > - TPM_DIGEST sealedNVMHash; > - > - if (myDMI->NVMLocation == NULL) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to load NVM because the file name NULL.\n"); > - status = TPM_AUTHFAIL; > - goto abort_egress; > - } > - > - //Read sealed blob off disk from NVMLocation > - fh = open(myDMI->NVMLocation, O_RDONLY); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - fh_size = file_stat.st_size; > - else { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - TPMTRYRETURN( buffer_init( &sealed_NVM, fh_size, NULL) ); > - if (read(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM)) != fh_size) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - close(fh); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Load_NVMing[%d],\n", buffer_len(&sealed_NVM)); > - > - Crypto_SHA1Full(sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &sealedNVMHash); > - > - // Verify measurement of sealed blob. > - if (memcmp(&sealedNVMHash, &myDMI->NVM_measurement, sizeof(TPM_DIGEST)) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM LoadNVM NVM measurement check failed.\n"); > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Correct hash: "); > - for (i=0; i< sizeof(TPM_DIGEST); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&myDMI->NVM_measurement)[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Measured hash: "); > - for (i=0; i< sizeof(TPM_DIGEST); i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&sealedNVMHash)[i]); > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - status = TPM_AUTHFAIL; > - goto abort_egress; > - } > - > - TPMTRYRETURN( envelope_decrypt(&sealed_NVM, > - myDMI->TCSContext, > - vtpm_globals->storageKeyHandle, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - outbuf) ); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load NVM\n."); > - > - egress: > - buffer_free( &sealed_NVM ); > - > - return status; > -} > - > - > -TPM_RESULT VTPM_SaveManagerData(void) { > - TPM_RESULT status=TPM_SUCCESS; > - int fh, dmis=-1; > - > - BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL; > - buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF; > - UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap); > - UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap); > - struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes}; > - struct pack_buf_t boot_key_pack = {bootKeySize, vtpm_globals->bootKeyWrap.bytes}; > - BYTE vtpm_manager_gen = VTPM_MANAGER_GEN; > - > - struct hashtable_itr *dmi_itr; > - VTPM_DMI_RESOURCE *dmi_res; > - > - UINT32 boot_key_size = 0, flat_dmis_size = 0; > - > - // Initially fill these with buffer sizes for each data type. Later fill > - // in actual size, once flattened. > - boot_key_size = sizeof(UINT32) + // bootkeysize > - bootKeySize; // boot key > - > - TPMTRYRETURN(buffer_init(&clear_flat_global,sizeof(BYTE) + // manager version > - 3*sizeof(TPM_DIGEST) + // Auths > - sizeof(UINT32) +// storagekeysize > - storageKeySize, NULL) ); // storage key > - > - > - flat_boot_key = (BYTE *) malloc( boot_key_size ); > - flat_enc = (BYTE *) malloc( sizeof(UINT32) ); > - > - boot_key_size = BSG_PackList(flat_boot_key, 1, > - BSG_TPM_SIZE32_DATA, &boot_key_pack); > - > - BSG_PackList(clear_flat_global.bytes, 4, > - BSG_TYPE_BYTE, &vtpm_manager_gen, > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > - > - TPMTRYRETURN(envelope_encrypt(&clear_flat_global, > - &vtpm_globals->bootKey, > - &enc_flat_global) ); > - > - BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc); > - > - // Per DMI values to be saved (if any exit) > - if (hashtable_count(vtpm_globals->dmi_map) > 1) { > - > - flat_dmis = (BYTE *) malloc( > - (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0) > - (sizeof(UINT32) +sizeof(BYTE) + 2*sizeof(TPM_DIGEST)) ); // Per DMI info > - > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > - do { > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > - dmis++; > - > - // No need to save dmi0. > - if (dmi_res->dmi_id == 0) > - continue; > - > - > - flat_dmis_size += BSG_PackList( flat_dmis + flat_dmis_size, 4, > - BSG_TYPE_UINT32, &dmi_res->dmi_id, > - BSG_TYPE_BYTE, &dmi_res->dmi_type, > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > - > - } while (hashtable_iterator_advance(dmi_itr)); > - } > - > - fh = open(STATE_FILE, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE); > - if (fh == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to open %s file for write.\n", STATE_FILE); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if ( ( write(fh, flat_boot_key, boot_key_size) != boot_key_size ) || > - ( write(fh, flat_enc, sizeof(UINT32)) != sizeof(UINT32) ) || > - ( write(fh, enc_flat_global.bytes, buffer_len(&enc_flat_global)) != buffer_len(&enc_flat_global) ) || > - ( write(fh, flat_dmis, flat_dmis_size) != flat_dmis_size ) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to completely write service data.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - goto egress; > - > - abort_egress: > - egress: > - > - free(flat_boot_key); > - free(flat_enc); > - buffer_free(&enc_flat_global); > - free(flat_dmis); > - close(fh); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Saved VTPM Manager state (status = %d, dmis = %d)\n", (int) status, dmis); > - return status; > -} > - > -TPM_RESULT VTPM_LoadManagerData(void) { > - > - TPM_RESULT status=TPM_SUCCESS; > - int fh, stat_ret, dmis=0; > - long fh_size = 0, step_size; > - BYTE *flat_table=NULL; > - buffer_t unsealed_data, enc_table_abuf; > - struct pack_buf_t storage_key_pack, boot_key_pack; > - UINT32 *dmi_id_key, enc_size; > - BYTE vtpm_manager_gen; > - > - VTPM_DMI_RESOURCE *dmi_res; > - UINT32 dmi_id; > - BYTE dmi_type; > - struct stat file_stat; > - > - TPM_HANDLE boot_key_handle; > - TPM_AUTHDATA boot_usage_auth; > - memset(&boot_usage_auth, 0, sizeof(TPM_AUTHDATA)); > - > - fh = open(STATE_FILE, O_RDONLY ); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - fh_size = file_stat.st_size; > - else { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - flat_table = (BYTE *) malloc(fh_size); > - > - if ((long) read(fh, flat_table, fh_size) != fh_size ) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Read Boot Key > - step_size = BSG_UnpackList( flat_table, 2, > - BSG_TPM_SIZE32_DATA, &boot_key_pack, > - BSG_TYPE_UINT32, &enc_size); > - > - TPMTRYRETURN(buffer_init(&vtpm_globals->bootKeyWrap, 0, 0) ); > - TPMTRYRETURN(buffer_init_alias_convert(&enc_table_abuf, enc_size, flat_table + step_size) ); > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->bootKeyWrap, boot_key_pack.size, boot_key_pack.data) ); > - > - //Load Boot Key > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->bootKeyWrap, > - &SRK_AUTH, > - &boot_key_handle, > - &vtpm_globals->keyAuth, > - &vtpm_globals->bootKey, > - FALSE) ); > - > - TPMTRYRETURN( envelope_decrypt(&enc_table_abuf, > - vtpm_globals->manager_tcs_handle, > - boot_key_handle, > - (const TPM_AUTHDATA*) &boot_usage_auth, > - &unsealed_data) ); > - step_size += enc_size; > - > - if (*unsealed_data.bytes != VTPM_MANAGER_GEN) { > - // Once there is more than one gen, this will include some compatability stuff > - vtpmlogerror(VTPM_LOG_VTPM, "Warning: Manager Data file is gen %d, which this manager is gen %d.\n", vtpm_manager_gen, VTPM_MANAGER_GEN); > - } > - > - // Global Values needing to be saved > - BSG_UnpackList( unsealed_data.bytes, 4, > - BSG_TYPE_BYTE, &vtpm_manager_gen, > - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, > - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, > - BSG_TPM_SIZE32_DATA, &storage_key_pack); > - > - TPMTRYRETURN(buffer_init(&vtpm_globals->storageKeyWrap, 0, 0) ); > - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->storageKeyWrap, storage_key_pack.size, storage_key_pack.data) ); > - > - // Per DMI values to be saved > - while ( step_size < fh_size ){ > - if (fh_size - step_size < (long) (sizeof(UINT32) + sizeof(BYTE) + 2*sizeof(TPM_DIGEST))) { > - vtpmlogerror(VTPM_LOG_VTPM, "Encountered %ld extra bytes at end of manager state.\n", fh_size-step_size); > - step_size = fh_size; > - } else { > - step_size += BSG_UnpackList(flat_table + step_size, 2, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TYPE_BYTE, &dmi_type); > - > - //TODO: Try and gracefully recover from problems. > - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &dmi_res) ); > - dmis++; > - > - step_size += BSG_UnpackList(flat_table + step_size, 2, > - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, > - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); > - } > - > - } > - > - vtpmloginfo(VTPM_LOG_VTPM, "Loaded saved state (dmis = %d).\n", dmis); > - goto egress; > - > - abort_egress: > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load service data with error = %s\n", tpm_get_error_name(status)); > - egress: > - > - free(flat_table); > - close(fh); > - > - // TODO: Could be nice and evict BootKey. (Need to add EvictKey to VTSP. > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/manager/tpmpassthrough.c b/tools/vtpm_manager/manager/tpmpassthrough.c > deleted file mode 100644 > index 9b1e5f8..0000000 > --- a/tools/vtpm_manager/manager/tpmpassthrough.c > +++ /dev/null > @@ -1,110 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tpmpassthrough.c > -// > -// Functions regarding passing DMI requests to HWTPM > -// > -// ================================================================== > - > -#include "tcg.h" > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "log.h" > - > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > - buffer_t *inbuf, > - buffer_t *outbuf) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE *ord; > - > - ord = (TPM_COMMAND_CODE *) (inbuf->bytes + sizeof(TPM_TAG) + sizeof(UINT32)); > - > - switch (*ord) { > - > - // Forbidden for DMI use > - case TPM_ORD_TakeOwnership: > - case TPM_ORD_ChangeAuthOwner: > - case TPM_ORD_DirWriteAuth: > - case TPM_ORD_DirRead: > - case TPM_ORD_AuthorizeMigrationKey: > - case TPM_ORD_CreateMaintenanceArchive: > - case TPM_ORD_LoadMaintenanceArchive: > - case TPM_ORD_KillMaintenanceFeature: > - case TPM_ORD_LoadManuMaintPub: > - case TPM_ORD_ReadManuMaintPub: > - case TPM_ORD_SelfTestFull: > - case TPM_ORD_SelfTestStartup: > - case TPM_ORD_CertifySelfTest: > - case TPM_ORD_ContinueSelfTest: > - case TPM_ORD_GetTestResult: > - case TPM_ORD_Reset: > - case TPM_ORD_OwnerClear: > - case TPM_ORD_DisableOwnerClear: > - case TPM_ORD_ForceClear: > - case TPM_ORD_DisableForceClear: > - case TPM_ORD_GetCapabilityOwner: > - case TPM_ORD_OwnerSetDisable: > - case TPM_ORD_PhysicalEnable: > - case TPM_ORD_PhysicalDisable: > - case TPM_ORD_SetOwnerInstall: > - case TPM_ORD_PhysicalSetDeactivated: > - case TPM_ORD_SetTempDeactivated: > - case TPM_ORD_CreateEndorsementKeyPair: > - case TPM_ORD_GetAuditEvent: > - case TPM_ORD_GetAuditEventSigned: > - case TPM_ORD_GetOrdinalAuditStatus: > - case TPM_ORD_SetOrdinalAuditStatus: > - case TPM_ORD_SetRedirection: > - case TPM_ORD_FieldUpgrade: > - case TSC_ORD_PhysicalPresence: > - status = TPM_DISABLED_CMD; > - goto abort_egress; > - break; > - > - } // End ORD Switch > - > - // Call TCS with command > - > - TPMTRY(TPM_IOERROR, VTSP_RawTransmit( dmi->TCSContext,inbuf, outbuf) ); > - > - goto egress; > - > - abort_egress: > - vtpmloginfo(VTPM_LOG_VTPM, "TPM Command Failed in tpmpassthrough.\n"); > - egress: > - > - return status; > -} > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.c b/tools/vtpm_manager/manager/vtpm_ipc.c > deleted file mode 100644 > index 319dc83..0000000 > --- a/tools/vtpm_manager/manager/vtpm_ipc.c > +++ /dev/null > @@ -1,141 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_ipc.c Implements ipc routines using file io. This file can > -// be replaced with other ipc types. > -// > -// =================================================================== > - > -#include > -#include "vtpm_ipc.h" > -#include "vtpmpriv.h" > -#include "log.h" > - > -int vtpm_ipc_init(vtpm_ipc_handle_t *ipc_h, char* name, int flags, BOOL create) { > - ipc_h->name = name; > - ipc_h->flags = flags; > - ipc_h->fh = VTPM_IPC_CLOSED; > - > - if (create) > - return(vtpm_ipc_create(ipc_h)); > - else > - return 0; > -} > - > -// Create the file that needs opening. Used only for FIFOs > -// FYI: This may cause problems in other file IO schemes. We'll see. > -int vtpm_ipc_create(vtpm_ipc_handle_t *ipc_h) { > - int fh; > - struct stat file_info; > - > - if ((!ipc_h) || (!ipc_h->name)) > - return -1; > - > - if ( stat(ipc_h->name, &file_info) == -1) { > - if ( mkfifo(ipc_h->name, S_IWUSR | S_IRUSR ) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create fifo %s.\n", ipc_h->name); > - return -1; > - } > - } > - > - ipc_h->fh = VTPM_IPC_CLOSED; > - > - return 0; > -} > - > - > -// Read size bytes. If FH isn't open, open it. > -int vtpm_ipc_read(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size){ > - vtpm_ipc_handle_t *my_ipc_h; > - int result; > - > - if (ipc_h) { > - my_ipc_h = ipc_h; > - } else { > - my_ipc_h = alt_ipc_h; > - } > - > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > - } > - > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for reading.\n", my_ipc_h->name); > - return -1; > - } > - > - result = read(my_ipc_h->fh, bytes, size); > - if (result < 0) { > - my_ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > - return (result); > -} > - > -// Write size bytes. If FH isn't open, open it. > -int vtpm_ipc_write(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size) { > - vtpm_ipc_handle_t *my_ipc_h; > - int result; > - > - if (ipc_h) { > - my_ipc_h = ipc_h; > - } else { > - my_ipc_h = alt_ipc_h; > - } > - > - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { > - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); > - } > - > - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for writing.\n", my_ipc_h->name); > - return -1; > - } > - > - result = write(my_ipc_h->fh, bytes, size); > - if (result < 0) { > - my_ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > - return (result); > -} > - > -// Mark file as closed and try and close it. Errors not reported. > -void vtpm_ipc_close(vtpm_ipc_handle_t *ipc_h) { > - > - if (ipc_h) { > - close(ipc_h->fh); > - ipc_h->fh = VTPM_IPC_CLOSED; > - } > - > -} > diff --git a/tools/vtpm_manager/manager/vtpm_ipc.h b/tools/vtpm_manager/manager/vtpm_ipc.h > deleted file mode 100644 > index 529c4a2..0000000 > --- a/tools/vtpm_manager/manager/vtpm_ipc.h > +++ /dev/null > @@ -1,71 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_ipc.h Header for interprocess communication between VTPM manager > -// and Guests or VTPMs > -// > -// =================================================================== > - > -#ifndef __VTPM_IO_H__ > -#define __VTPM_IO_H__ > - > -#include "tcg.h" > - > -#define VTPM_IPC_CLOSED -1 > - > -// Represents an (somewhat) abstracted io handle. > -typedef struct vtpm_ipc_handle_t { > - int fh; // IO handle. > - int flags; // Flags for opening. This may need to become > - // a void *, but for now files use an int. > - char *name; // Names for debugging as well as filenames > - // for file-based io. > -} vtpm_ipc_handle_t; > - > - > -int vtpm_ipc_init(vtpm_ipc_handle_t *ioh, char* name, int flags, BOOL create); > - > -// Create the file that needs opening. Used only for FIFOs > -// FYI: This may cause problems in other file IO schemes. We'll see. > -int vtpm_ipc_create(vtpm_ipc_handle_t *ioh); > - > -// Read size bytes. If FH isn't open, open it. > -int vtpm_ipc_read(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > - > -// Write size bytes. If FH isn't open, open it. > -int vtpm_ipc_write(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); > - > -// Mark file as closed and try and close it. Errors not reported. > -void vtpm_ipc_close(vtpm_ipc_handle_t *ioh); > - > -#endif > diff --git a/tools/vtpm_manager/manager/vtpm_lock.c b/tools/vtpm_manager/manager/vtpm_lock.c > deleted file mode 100644 > index e737d60..0000000 > --- a/tools/vtpm_manager/manager/vtpm_lock.c > +++ /dev/null > @@ -1,63 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_lock.c Provided controlled sync around access to vtpm structures > -// > -// =================================================================== > - > -#include > -#include "vtpm_lock.h" > - > -static pthread_rwlock_t vtpm_lock; > - > -void vtpm_lock_init() { > - > - pthread_rwlock_init( &vtpm_lock, NULL); > -} > - > -void vtpm_lock_destroy(){ > - pthread_rwlock_destroy(&vtpm_lock); > -} > - > -void vtpm_lock_rdlock(){ > - pthread_rwlock_rdlock(&vtpm_lock); > -} > - > -void vtpm_lock_wrlock(){ > - pthread_rwlock_wrlock(&vtpm_lock); > -} > - > -void vtpm_lock_unlock(){ > - pthread_rwlock_unlock(&vtpm_lock); > -} > - > diff --git a/tools/vtpm_manager/manager/vtpm_lock.h b/tools/vtpm_manager/manager/vtpm_lock.h > deleted file mode 100644 > index 53a339d..0000000 > --- a/tools/vtpm_manager/manager/vtpm_lock.h > +++ /dev/null > @@ -1,48 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_lock.h Provided controlled sync around access to vtpm structures > -// > -// =================================================================== > - > -#ifndef __VTPM_LOCK_H__ > -#define __VTPM_LOCK_H__ > - > -void vtpm_lock_init(); > -void vtpm_lock_destroy(); > - > -void vtpm_lock_rdlock(); > -void vtpm_lock_wrlock(); > -void vtpm_lock_unlock(); > - > -#endif > diff --git a/tools/vtpm_manager/manager/vtpm_manager.c b/tools/vtpm_manager/manager/vtpm_manager.c > deleted file mode 100644 > index e089f78..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager.c > +++ /dev/null > @@ -1,285 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager.c > -// > -// This file will house the main logic of the VTPM Manager > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > - > -#include "log.h" > -#include "buffer.h" > - > -VTPM_GLOBALS *vtpm_globals=NULL; > - > -// --------------------------- Well Known Auths -------------------------- > -const TPM_AUTHDATA SRK_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > - > -#ifdef WELL_KNOWN_OWNER_AUTH > -static BYTE FIXED_OWNER_AUTH[20] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, > - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > -#endif > - > - > -// -------------------------- Hash table functions -------------------- > - > -static unsigned int hashfunc32(void *ky) { > - return (* (UINT32 *) ky); > -} > - > -static int equals32(void *k1, void *k2) { > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > -} > - > -// --------------------------- Functions ------------------------------ > - > -TPM_RESULT VTPM_Create_Manager(){ > - > - TPM_RESULT status = TPM_SUCCESS; > - > - // Generate Auth for Owner > -#ifdef WELL_KNOWN_OWNER_AUTH > - memcpy(vtpm_globals->owner_usage_auth, FIXED_OWNER_AUTH, sizeof(TPM_AUTHDATA)); > -#else > - Crypto_GetRandom(vtpm_globals->owner_usage_auth, sizeof(TPM_AUTHDATA) ); > -#endif > - > - // Take Owership of TPM > - CRYPTO_INFO ek_cryptoInfo; > - > - status = VTSP_ReadPubek(vtpm_globals->manager_tcs_handle, &ek_cryptoInfo); > - > - // If we can read PubEK then there is no owner and we should take it. > - // We use the abilty to read the pubEK to flag that the TPM is owned. > - // FIXME: Change to just trying to take ownership and react to the status > - if (status == TPM_SUCCESS) { > - TPMTRYRETURN(VTSP_TakeOwnership(vtpm_globals->manager_tcs_handle, > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > - &SRK_AUTH, > - &ek_cryptoInfo, > - &vtpm_globals->keyAuth)); > - > - TPMTRYRETURN(VTSP_DisablePubekRead(vtpm_globals->manager_tcs_handle, > - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, > - &vtpm_globals->keyAuth)); > - } else { > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); > - } > - > - // Generate storage key's auth > - Crypto_GetRandom( &vtpm_globals->storage_key_usage_auth, > - sizeof(TPM_AUTHDATA) ); > - > - TCS_AUTH osap; > - TPM_AUTHDATA sharedsecret; > - > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > - TPM_ET_KEYHANDLE, > - TPM_SRK_KEYHANDLE, > - &SRK_AUTH, > - &sharedsecret, > - &osap) ); > - > - osap.fContinueAuthSession = FALSE; > - > - > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > - TPM_KEY_BIND, > - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, > - TPM_SRK_KEYHANDLE, > - (const TPM_AUTHDATA*)&sharedsecret, > - &vtpm_globals->storageKeyWrap, > - &osap) ); > - > - // Generate boot key's auth > - TPM_AUTHDATA bootKeyWrapAuth; > - memset(&bootKeyWrapAuth, 0, sizeof(bootKeyWrapAuth)); > - > - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, > - TPM_ET_KEYHANDLE, > - TPM_SRK_KEYHANDLE, > - &SRK_AUTH, > - &sharedsecret, > - &osap) ); > - > - osap.fContinueAuthSession = FALSE; > - > - // FIXME: This key protects the global secrets on disk. It should use TPM > - // PCR bindings to limit its use to legit configurations. > - // Current binds are open, implying a Trusted VM contains this code. > - // If this VM is not Trusted, use measurement and PCR bindings. > - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, > - TPM_KEY_BIND, > - (const TPM_AUTHDATA*)&bootKeyWrapAuth, > - TPM_SRK_KEYHANDLE, > - (const TPM_AUTHDATA*)&sharedsecret, > - &vtpm_globals->bootKeyWrap, > - &osap) ); > - > - // Populate CRYPTO_INFO vtpm_globals->bootKey. This does not load it into the TPM > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->bootKeyWrap, > - NULL, > - NULL, > - NULL, > - &vtpm_globals->bootKey, > - TRUE ) ); > - > - TPMTRYRETURN( VTSP_SaveState(vtpm_globals->manager_tcs_handle) ); > - goto egress; > - > - abort_egress: > - exit(1); > - > - egress: > - vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager (Status = %d).\n", status); > - return status; > - > -} > - > -/////////////////////////////////////////////////////////////////////////////// > -TPM_RESULT VTPM_Init_Manager() { > - TPM_RESULT status = TPM_FAIL, serviceStatus; > - BYTE *randomsead; > - UINT32 randomsize=256; > - > - if ((vtpm_globals = (VTPM_GLOBALS *) malloc(sizeof(VTPM_GLOBALS))) == NULL){ > - status = TPM_FAIL; > - goto abort_egress; > - } > - memset(vtpm_globals, 0, sizeof(VTPM_GLOBALS)); > - > - vtpm_globals->connected_dmis = 0; > - > - if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){ > - status = TPM_FAIL; > - goto abort_egress; > - } > - > - // Create new TCS Object > - vtpm_globals->manager_tcs_handle = 0; > - > - TPMTRYRETURN(TCS_create()); > - > - // Create TCS Context for service > - TPMTRYRETURN( TCS_OpenContext(&vtpm_globals->manager_tcs_handle ) ); > - > - TPMTRYRETURN( TCSP_GetRandom(vtpm_globals->manager_tcs_handle, > - &randomsize, > - &randomsead)); > - > - Crypto_Init(randomsead, randomsize); > - TPMTRYRETURN( TCS_FreeMemory (vtpm_globals->manager_tcs_handle, randomsead)); > - > - // Create OIAP session for service's authorized commands > - TPMTRYRETURN( VTSP_OIAP( vtpm_globals->manager_tcs_handle, > - &vtpm_globals->keyAuth) ); > - vtpm_globals->keyAuth.fContinueAuthSession = TRUE; > - > - vtpm_globals->mig_keys = NULL; > - > - // If fails, create new Manager. > - serviceStatus = VTPM_LoadManagerData(); > - if (serviceStatus == TPM_IOERROR) { > - vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); > - TPMTRYRETURN( VTPM_Create_Manager() ); > - TPMTRYRETURN( VTPM_SaveManagerData() ); > - } else if (serviceStatus != TPM_SUCCESS) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to read existing manager file"); > - exit(1); > - } > - > - //Load Storage Key > - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, > - TPM_SRK_KEYHANDLE, > - &vtpm_globals->storageKeyWrap, > - &SRK_AUTH, > - &vtpm_globals->storageKeyHandle, > - &vtpm_globals->keyAuth, > - &vtpm_globals->storageKey, > - FALSE ) ); > - > - // Create entry for Dom0 for control messages > - TPMTRYRETURN( VTPM_Handle_New_DMI(NULL) ); > - > - goto egress; > - > - abort_egress: > - egress: > - > - return(status); > -} > - > -/////////////////////////////////////////////////////////////////////////////// > -void VTPM_Stop_Manager() { > - VTPM_DMI_RESOURCE *dmi_res; > - struct hashtable_itr *dmi_itr; > - > - // Close all the TCS contexts. TCS should evict keys based on this > - if (hashtable_count(vtpm_globals->dmi_map) > 0) { > - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); > - do { > - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); > - if (dmi_res->connected) > - close_dmi( dmi_res ); // Not really interested in return code > - > - } while (hashtable_iterator_advance(dmi_itr)); > - free (dmi_itr); > - } > - > - if ( VTPM_SaveManagerData() != TPM_SUCCESS ) > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to save manager data.\n"); > - > - TCS_CloseContext(vtpm_globals->manager_tcs_handle); > - TCS_destroy(); > - > - hashtable_destroy(vtpm_globals->dmi_map, 1); > - free(vtpm_globals); > - > - Crypto_Exit(); > - > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); > -} > diff --git a/tools/vtpm_manager/manager/vtpm_manager.h b/tools/vtpm_manager/manager/vtpm_manager.h > deleted file mode 100644 > index a324a8f..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager.h > +++ /dev/null > @@ -1,150 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager.h > -// > -// Public Interface header for VTPM Manager > -// > -// ================================================================== > - > -#ifndef __VTPM_MANAGER_H__ > -#define __VTPM_MANAGER_H__ > - > -#define VTPM_TAG_REQ 0x01c1 > -#define VTPM_TAG_RSP 0x01c4 > -#define COMMAND_BUFFER_SIZE 4096 > - > -// Header sizes. Note Header MAY include the DMI > -#define VTPM_COMMAND_HEADER_SIZE_CLT ( 2 + 4 + 4) > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > -#define VTPM_COMMAND_HEADER_SIZE_SRV ( 4 + VTPM_COMMAND_HEADER_SIZE_CLT ) > -// sizeof( UINT32 + VTPM_COMMAND_HEADER_SIZE_CLT) > - > -//************************ 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) > - > -// Non-priviledged VTPM Commands (From DMI's) > -#define VTPM_ORD_SAVENVM (VTPM_ORD_BASE + 1) // DMI Saves Secrets > -#define VTPM_ORD_LOADNVM (VTPM_ORD_BASE + 2) // DMI Loads Secrets > -#define VTPM_ORD_TPMCOMMAND (VTPM_ORD_BASE + 3) // DMI issues HW TPM Command > -#define VTPM_ORD_GET_MIG_KEY (VTPM_ORD_BASE + 4) // Get manager's migration key > -#define VTPM_ORD_LOAD_MIG_KEY (VTPM_ORD_BASE + 5) // load dest migration key > - > -// Priviledged VTPM Commands (From management console) > -#define VTPM_ORD_OPEN (VTPM_PRIV_BASE + 1) // Creates/reopens DMI > -#define VTPM_ORD_CLOSE (VTPM_PRIV_BASE + 2) // Closes a DMI > -#define VTPM_ORD_DELETE (VTPM_PRIV_BASE + 3) // Permemently Deletes DMI > -#define VTPM_ORD_MIGRATE_IN (VTPM_PRIV_BASE + 4) // Load migrated VTPM > -#define VTPM_ORD_MIGRATE_OUT (VTPM_PRIV_BASE + 5) // migrate VTPM to dest > - > -//************************ Return Codes **************************** > -#define VTPM_TYPE_PVM 1 // Paravirtualized Domain > -#define VTPM_TYPE_HVM 2 // HVM Domain > - > -//************************ Return Codes **************************** > -#define VTPM_SUCCESS 0 > -#define VTPM_FAIL 1 > -#define VTPM_UNSUPPORTED 2 > -#define VTPM_FORBIDDEN 3 > -#define VTPM_RESTORE_CONTEXT_FAILED 4 > -#define VTPM_INVALID_REQUEST 5 > - > -//*********************** Parameter Values ************************* > -#define VTPM_TYPE_NON_MIGRATABLE 0x00 > -#define VTPM_TYPE_MIGRATABLE 0x01 > -#define VTPM_TYPE_MIGRATED 0xFF // VTPM has been migrated. > - // VTPM can be recovered or deleted only > - > -/******************* Command Parameter API ************************* > - > -VTPM Command Format > - dmi: 4 bytes // Source of message. > - // WARNING: This is prepended by the channel. > - // Thus it is received by VTPM Manager, > - // but not sent by DMI > - tpm tag: 2 bytes > - command size: 4 bytes // Size of command including header but not DMI > - ord: 4 bytes // Command ordinal above > - parameters: size - 10 bytes // Command Parameter > - > -VTPM Response Format > - tpm tag: 2 bytes > - response_size: 4 bytes > - status: 4 bytes > - parameters: size - 10 bytes > - > - > -VTPM_Open: > - Input Parameters: > - mig_type: 1 byte > - startup_mode: 1 byte // Cold Boot = 1, resume = 2, deactive = 3 > - domain type: 1 byte > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_Close > - Input Parameters: > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_Delete > - Input Parameters: > - instance_id: 4 bytes > - Output Parameters: > - None > - > -VTPM_SaveNVM > - Input Parameters: > - data: n bytes (Header indicates size of data) > - Output Parameters: > - None > - > -VTPM_LoadNVM > - Input Parameters: > - None > - Output Parameters: > - data: n bytes (Header indicates size of data) > - > -VTPM_TPMCommand > - Input Parameters: > - TPM Command Byte Stream: n bytes > - Output Parameters: > - TPM Reponse Byte Stream: n bytes > - > -*********************************************************************/ > - > -#endif //_VTPM_MANAGER_H_ > diff --git a/tools/vtpm_manager/manager/vtpm_manager_handler.c b/tools/vtpm_manager/manager/vtpm_manager_handler.c > deleted file mode 100644 > index 2001074..0000000 > --- a/tools/vtpm_manager/manager/vtpm_manager_handler.c > +++ /dev/null > @@ -1,488 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager_handler.c > -// > -// This file will house the main logic of the VTPM Manager > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "vtsp.h" > -#include "bsg.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > -#include "log.h" > -#include "buffer.h" > - > -#define vtpmhandlerloginfo(module,fmt,args...) vtpmloginfo (module, "[%s]: " fmt, thread_name, ##args ); > -#define vtpmhandlerloginfomore(module,fmt,args...) vtpmloginfomore (module, fmt, ##args ); > -#define vtpmhandlerlogerror(module,fmt,args...) vtpmlogerror (module, "[%s]: " fmt, thread_name, ##args ); > - > -// ---------------------- Prototypes ------------------- > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > - TPM_COMMAND_CODE ord, > - buffer_t *command_buf, > - buffer_t *result_buf, > - BOOL is_priv, > - char *thread_name); > - > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - VTPM_DMI_RESOURCE *dmi_res, > - BYTE *cmd_header, > - buffer_t *param_buf, > - buffer_t *result_buf, > - char *thread_name); > - > -TPM_RESULT VTPM_Manager_Handler( vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - BOOL fw_tpm, // Forward TPM cmds? > - vtpm_ipc_handle_t *fw_tx_ipc_h, > - vtpm_ipc_handle_t *fw_rx_ipc_h, > - BOOL is_priv, > - char *thread_name) { > - TPM_RESULT status = TPM_FAIL; // Should never return > - UINT32 dmi, in_param_size, cmd_size, out_param_size, out_message_size, reply_size; > - BYTE *cmd_header=NULL, *in_param=NULL, *out_message=NULL, *reply; > - buffer_t *command_buf=NULL, *result_buf=NULL; > - TPM_TAG tag; > - TPM_COMMAND_CODE ord; > - VTPM_DMI_RESOURCE *dmi_res; > - int size_read, size_write, i; > - BOOL add_header=TRUE; // This indicates to prepend a header on result_buf before sending > - > - cmd_header = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV); > - command_buf = (buffer_t *) malloc(sizeof(buffer_t)); > - result_buf = (buffer_t *) malloc(sizeof(buffer_t)); > - > - // ------------------------ Main Loop -------------------------------- > - while(1) { > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "%s waiting for messages.\n", thread_name); > - > - // --------------------- Read Cmd from Sender ---------------- > - > - // Read command header > - size_read = vtpm_ipc_read(rx_ipc_h, NULL, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV[%d]: 0x", size_read); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s can't read from ipc. Errono = %d. Aborting... \n", thread_name, errno); > - goto abort_command; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command shorter than normal header (%d bytes). Aborting...\n", size_read); > - goto abort_command; > - } > - > - // Unpack header > - BSG_UnpackList(cmd_header, 4, > - BSG_TYPE_UINT32, &dmi, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - // Using the header info, read the parameters of the command > - // Note that in_param_size is in the client's context > - cmd_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > - if (cmd_size > 0) { > - in_param = (BYTE *) malloc(cmd_size); > - size_read = vtpm_ipc_read( rx_ipc_h, NULL, in_param, cmd_size); > - if (size_read > 0) { > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error reading cmd from ipc. Aborting... \n", thread_name); > - goto abort_command; > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - if (size_read < (int) cmd_size) { > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d). Aborting...\n", size_read, cmd_size); > - goto abort_command; > - } > - } else { > - in_param = NULL; > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } > - > - // Init the buffers used to handle the command and the response > - if ( (buffer_init_convert(command_buf, cmd_size, in_param) != TPM_SUCCESS) || > - (buffer_init(result_buf, 0, 0) != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > - goto abort_command; > - } > - > - // -------------- Dispatch Commands to Handlers ----------- > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK)) { > - vtpm_lock_wrlock(); > - } else { > - vtpm_lock_rdlock(); > - } > - > - if ( !(dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi)) || > - (!dmi_res->connected) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempted access to non-existent or disconnected DMI %d. Aborting...\n", dmi); > - status = TPM_BAD_PARAMETER; > - // We have no one to reply to, they don't exist. > - goto abort_command; > - } > - > - if (tag == VTPM_TAG_REQ) { > - > - status = vtpm_manager_handle_vtpm_cmd(dmi_res, ord, command_buf, result_buf, is_priv, thread_name); > - > - } else { // This is not a VTPM Command at all. > - if (fw_tpm) { > - status = vtpm_manager_handle_tpm_cmd(fw_tx_ipc_h, fw_rx_ipc_h, dmi_res, cmd_header, command_buf, result_buf, thread_name); > - > - // This means calling the DMI failed, not that the cmd failed in the DMI > - // Since the return will be interpretted by a TPM app, all errors are IO_ERRORs to the app > - if (status != TPM_SUCCESS) { > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - // Unlike all other commands, forwarded commands yield a result_buf that includes the DMI's status. This > - // should be forwarded to the caller VM > - add_header = FALSE; > - } else { > - // We are not supposed to forward TPM commands at all. > - int i; > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempt to use unsupported direct access to TPM.\n"); > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "Bad Command. dmi:%d, tag:%d, size:%d, ord:%d, Params: ", dmi, tag, in_param_size, ord); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - } // end else for is VTPM Command > - > - // ------------------- Respond to Sender ------------------ > - > - // Errors while handling responses jump here to reply with error messages > - // NOTE: Currently there are no recoverable errors in multi-VM mode. If one > - // is added to the code, this ifdef should be removed. > - // Also note this is NOT referring to errors in commands, but rather > - // this is about I/O errors and such. > -#ifndef VTPM_MULTI_VM > - abort_with_error: > -#endif > - > - if (add_header) { > - // Prepend VTPM header with destination DM stamped > - out_param_size = buffer_len(result_buf); > - out_message_size = VTPM_COMMAND_HEADER_SIZE_CLT + out_param_size; > - reply_size = VTPM_COMMAND_HEADER_SIZE_SRV + out_param_size; > - out_message = (BYTE *) malloc (reply_size); > - reply = out_message; > - > - BSG_PackList(out_message, 4, > - BSG_TYPE_UINT32, (BYTE *) &dmi, > - BSG_TPM_TAG, (BYTE *) &tag, > - BSG_TYPE_UINT32, (BYTE *) &out_message_size, > - BSG_TPM_RESULT, (BYTE *) &status); > - > - if (buffer_len(result_buf) > 0) > - memcpy(out_message + VTPM_COMMAND_HEADER_SIZE_SRV, result_buf->bytes, out_param_size); > - //Note: Send message + dmi_id > - } else { > - reply = result_buf->bytes; > - reply_size = buffer_len(result_buf); > - } > - size_write = vtpm_ipc_write(tx_ipc_h, (dmi_res ? dmi_res->tx_vtpm_ipc_h : NULL), reply, reply_size ); > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > - for (i=0; i < reply_size; i++) > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", reply[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name); > - goto abort_command; > - } > - free(out_message); out_message=NULL; > - > - if (size_write < (int)reply_size) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size); > - goto abort_command; > - } > - > - // On certain failures an error message cannot be sent. > - // This marks the beginning of cleanup in preperation for the next command. > - abort_command: > - //free buffers > - bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - //free(in_param); // This was converted to command_buf. No need to free > - buffer_free(result_buf); > - buffer_free(command_buf); > - > - // If we have a write lock, save the manager table > - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) && > - (VTPM_SaveManagerData() != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n"); > - } > - > - vtpm_lock_unlock(); > - add_header = TRUE; // Reset to the default > - } // End while(1) > - > -} > - > -///////////////////////////////////////////////////////////////////////// > -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, > - TPM_COMMAND_CODE ord, > - buffer_t *command_buf, > - buffer_t *result_buf, > - BOOL is_priv, > - char *thread_name) { > - > - TPM_RESULT status = TPM_FAIL; > - > - switch (ord) { > - case VTPM_ORD_SAVENVM: > - status= VTPM_Handle_Save_NVM(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_LOADNVM: > - status= VTPM_Handle_Load_NVM(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_TPMCOMMAND: > - status= VTPM_Handle_TPM_Command(dmi_res, > - command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_GET_MIG_KEY: > - status = VTPM_Handle_Get_Migration_key(command_buf, > - result_buf); > - break; > - > - case VTPM_ORD_LOAD_MIG_KEY: > - status = VTPM_Handle_Load_Migration_key(command_buf, > - result_buf); > - break; > - > - default: > - // Privileged handlers can do maintanance > - if (is_priv) { > - switch (ord) { > - case VTPM_ORD_OPEN: > - status = VTPM_Handle_New_DMI(command_buf); > - break; > - > - case VTPM_ORD_CLOSE: > - status = VTPM_Handle_Close_DMI(command_buf); > - break; > - > - case VTPM_ORD_DELETE: > - status = VTPM_Handle_Delete_DMI(command_buf); > - break; > - > - case VTPM_ORD_MIGRATE_IN: > - status = VTPM_Handle_Migrate_In(command_buf, result_buf); > - break; > - > - case VTPM_ORD_MIGRATE_OUT: > - status = VTPM_Handle_Migrate_Out(command_buf, result_buf); > - break; > - > - default: > - status = TPM_BAD_ORDINAL; > - } // switch > - } else { // is priv command > - > - status = TPM_BAD_ORDINAL; > - } // inner switch > - } // outer switch > - > - return(status); > -} > - > -///////////////////////////////////////////////////////////////////// > -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - VTPM_DMI_RESOURCE *dmi_res, > - BYTE *cmd_header, > - buffer_t *param_buf, > - buffer_t *result_buf, > - char *thread_name) { > - > - TPM_RESULT status = TPM_FAIL; > - UINT32 dmi_dst; > - TPM_COMMAND_CODE ord; > - TPM_TAG tag_out; > - UINT32 dmi_cmd_size, in_param_size, adj_param_size; > - BYTE *dmi_cmd, *in_param; > - int size_read, size_write, i; > - > - //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n"); > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n"); > - > - //Forward TPM CMD stamped with dmi_id to DMI for handling > - if (buffer_len(param_buf)) { > - dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf)); > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); > - memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf)); > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size); > - > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", dmi_cmd[i]); > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - free(dmi_cmd); > - } else { > - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV; > - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV ); > - if (size_write > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error writing to DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - } > - > - if (size_write != (int) dmi_cmd_size) > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Could not write entire command to DMI (%d/%d)\n", size_write, dmi_cmd_size); > - > - buffer_free(param_buf); > - > - // Read header for response to TPM command from DMI > - size_read = vtpm_ipc_read( rx_ipc_h, dmi_res->rx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x"); > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from DMI. Aborting... \n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command from DMI shorter than normal header. Aborting...\n"); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(cmd_header, 4, > - BSG_TYPE_UINT32, &dmi_dst, > - BSG_TPM_TAG, &tag_out, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &status ); > - > - // If response has parameters, read them. > - // Note that in_param_size is in the client's context > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE_CLT; > - if (adj_param_size > 0) { > - in_param = (BYTE *) malloc(adj_param_size); > - size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size); > - if (size_read > 0) { > - for (i=0; i - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param[i]); > - > - } else { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Error reading from BE. Aborting... \n"); > - goto abort_with_error; > - } > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Command read(%d) from DMI is shorter than header indicates(%d). Aborting...\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_with_error; > - } > - } else { > - in_param = NULL; > - vtpmhandlerloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - if ( (buffer_init(result_buf, VTPM_COMMAND_HEADER_SIZE_SRV, cmd_header) != TPM_SUCCESS) || > - (buffer_append_raw(result_buf, adj_param_size, in_param) != TPM_SUCCESS) ) { > - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Failed to setup buffers. Aborting...\n"); > - status = TPM_FAIL; > - goto abort_with_error; > - } > - > - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Sending DMI's response to guest.\n"); > - > - status = TPM_SUCCESS; > - > - abort_with_error: > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/manager/vtpmd.c b/tools/vtpm_manager/manager/vtpmd.c > deleted file mode 100644 > index cf58ba3..0000000 > --- a/tools/vtpm_manager/manager/vtpmd.c > +++ /dev/null > @@ -1,371 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpmd.c > -// > -// Application > -// > -// =================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include "vtpm_manager.h" > -#include "vtpmpriv.h" > -#include "tcg.h" > -#include "log.h" > -#include "vtpm_ipc.h" > - > -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" > - > -#define VTPM_BE_FNAME "/dev/vtpm" > -#define VTPM_DUMMY_TX_BE_FNAME "/var/vtpm/fifos/dummy_out.fifo" > -#define VTPM_DUMMY_RX_BE_FNAME "/var/vtpm/fifos/dummy_in.fifo" > -#define VTPM_TX_TPM_FNAME "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" > -#define VTPM_RX_TPM_FNAME "/var/vtpm/fifos/tpm_rsp_from_all.fifo" > -#define VTPM_TX_VTPM_FNAME "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" > -#define VTPM_RX_VTPM_FNAME "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > - > -#define VTPM_TYPE_PVM_STRING "pvm" > -#define VTPM_TYPE_HVM_STRING "hvm" > - > -struct vtpm_thread_params_s { > - vtpm_ipc_handle_t *tx_ipc_h; > - vtpm_ipc_handle_t *rx_ipc_h; > - BOOL fw_tpm; > - vtpm_ipc_handle_t *fw_tx_ipc_h; > - vtpm_ipc_handle_t *fw_rx_ipc_h; > - BOOL is_priv; > - char *thread_name; > -}; > - > -// This is needed to all extra_close_dmi to close this to prevent a > -// broken pipe when no DMIs are left. > -static vtpm_ipc_handle_t *g_rx_tpm_ipc_h; > - > -void *vtpm_manager_thread(void *arg_void) { > - TPM_RESULT *status = (TPM_RESULT *) malloc(sizeof(TPM_RESULT) ); > - struct vtpm_thread_params_s *arg = (struct vtpm_thread_params_s *) arg_void; > - > - *status = VTPM_Manager_Handler(arg->tx_ipc_h, arg->rx_ipc_h, > - arg->fw_tpm, arg->fw_tx_ipc_h, arg->fw_rx_ipc_h, > - arg->is_priv, arg->thread_name); > - > - return (status); > -} > - > - > -void signal_handler(int reason) { > - if (pthread_equal(pthread_self(), vtpm_globals->master_pid)) { > - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager shutting down for signal %d.\n", reason); > - } else { > - // For old Linux Thread machines, signals are delivered to each thread. Deal with them. > - vtpmloginfo(VTPM_LOG_VTPM, "Child shutting down\n"); > - pthread_exit(NULL); > - } > - > - VTPM_Stop_Manager(); > - exit(-1); > -} > - > -struct sigaction ctl_c_handler; > - > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode) { > - > - TPM_RESULT status = TPM_SUCCESS; > - int fh; > - char dmi_id_str[11]; // UINT32s are up to 10 digits + NULL > - char *tx_vtpm_name, *tx_tpm_name, *vm_type_string; > - struct stat file_info; > - > - if (dmi_res->dmi_id == VTPM_CTL_DM) { > - dmi_res->tx_tpm_ipc_h = NULL; > - dmi_res->rx_tpm_ipc_h = NULL; > - dmi_res->tx_vtpm_ipc_h = NULL; > - dmi_res->rx_vtpm_ipc_h = NULL; > - } else { > - // Create a pair of fifo pipes > - dmi_res->rx_tpm_ipc_h = NULL; > - dmi_res->rx_vtpm_ipc_h = NULL; > - > - if ( ((dmi_res->tx_tpm_ipc_h = (vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > - ((dmi_res->tx_vtpm_ipc_h =(vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || > - ((tx_tpm_name = (char *) malloc(11 + strlen(VTPM_TX_TPM_FNAME))) == NULL ) || > - ((tx_vtpm_name =(char *) malloc(11 + strlen(VTPM_TX_VTPM_FNAME))) == NULL) ) { > - status =TPM_RESOURCES; > - goto abort_egress; > - } > - > - sprintf(tx_tpm_name, VTPM_TX_TPM_FNAME, (uint32_t) dmi_res->dmi_id); > - sprintf(tx_vtpm_name, VTPM_TX_VTPM_FNAME, (uint32_t) dmi_res->dmi_id); > - > - if ( (vtpm_ipc_init(dmi_res->tx_tpm_ipc_h, tx_tpm_name, O_WRONLY | O_NONBLOCK, TRUE) != 0) || > - (vtpm_ipc_init(dmi_res->tx_vtpm_ipc_h, tx_vtpm_name, O_WRONLY, TRUE) != 0) ) { //FIXME: O_NONBLOCK? > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Measure DMI > - // FIXME: This will measure DMI. Until then use a fixed DMI_Measurement value > - // Also, this mechanism is specific to 1 VM architecture. > - /* > - fh = open(TPM_EMULATOR_PATH, O_RDONLY); > - stat_ret = fstat(fh, &file_stat); > - if (stat_ret == 0) > - dmi_size = file_stat.st_size; > - else { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not open vtpmd!!\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - dmi_buffer > - */ > - memset(&dmi_res->DMI_measurement, 0xcc, sizeof(TPM_DIGEST)); > - > - if (vm_type == VTPM_TYPE_PVM) > - vm_type_string = (BYTE *)&VTPM_TYPE_PVM_STRING; > - else > - vm_type_string = (BYTE *)&VTPM_TYPE_HVM_STRING; > - > - // Launch DMI > - sprintf(dmi_id_str, "%d", (int) dmi_res->dmi_id); > -#ifdef MANUAL_DM_LAUNCH > - vtpmlogerror(VTPM_LOG_VTPM, "Manually start VTPM with dmi=%s now.\n", dmi_id_str); > - dmi_res->dmi_pid = 0; > -#else > - pid_t pid = fork(); > - > - if (pid == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not fork to launch vtpm\n"); > - status = TPM_RESOURCES; > - goto abort_egress; > - } else if (pid == 0) { > - switch (startup_mode) { > - case TPM_ST_CLEAR: > - execl (TPM_EMULATOR_PATH, "vtpmd", "clear", vm_type_string, dmi_id_str, NULL); > - break; > - case TPM_ST_STATE: > - execl (TPM_EMULATOR_PATH, "vtpmd", "save", vm_type_string, dmi_id_str, NULL); > - break; > - case TPM_ST_DEACTIVATED: > - execl (TPM_EMULATOR_PATH, "vtpmd", "deactivated", vm_type_string, dmi_id_str, NULL); > - break; > - default: > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Returning from these at all is an error. > - vtpmlogerror(VTPM_LOG_VTPM, "Could not exec to launch vtpm\n"); > - } else { > - dmi_res->dmi_pid = pid; > - vtpmloginfo(VTPM_LOG_VTPM, "Launching DMI on PID = %d\n", pid); > - } > -#endif // MANUAL_DM_LAUNCH > - > - } // If DMI = VTPM_CTL_DM > - status = TPM_SUCCESS; > - > -abort_egress: > - return (status); > -} > - > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res) { > - TPM_RESULT status = TPM_SUCCESS; > - > - if (vtpm_globals->connected_dmis == 0) { > - // No more DMI's connected. Close fifo to prevent a broken pipe. > - // This is hackish. Need to think of another way. > - vtpm_ipc_close(g_rx_tpm_ipc_h); > - } > - > - > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > - vtpm_ipc_close(dmi_res->tx_tpm_ipc_h); > - vtpm_ipc_close(dmi_res->tx_vtpm_ipc_h); > - > - free(dmi_res->tx_tpm_ipc_h->name); > - free(dmi_res->tx_vtpm_ipc_h->name); > - > -#ifndef MANUAL_DM_LAUNCH > - if (dmi_res->dmi_id != VTPM_CTL_DM) { > - if (dmi_res->dmi_pid != 0) { > - vtpmloginfo(VTPM_LOG_VTPM, "Killing dmi on pid %d.\n", dmi_res->dmi_pid); > - if (kill(dmi_res->dmi_pid, SIGKILL) !=0) { > - vtpmloginfo(VTPM_LOG_VTPM, "DMI on pid %d is already dead.\n", dmi_res->dmi_pid); > - } else if (waitpid(dmi_res->dmi_pid, NULL, 0) != dmi_res->dmi_pid) { > - vtpmlogerror(VTPM_LOG_VTPM, "DMI on pid %d failed to stop.\n", dmi_res->dmi_pid); > - status = TPM_FAIL; > - } > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Could not kill dmi because it's pid was 0.\n"); > - status = TPM_FAIL; > - } > - } > -#endif > - > - } //endif ! dom0 > - return status; > -} > - > - > -int main(int argc, char **argv) { > - vtpm_ipc_handle_t *tx_be_ipc_h, *rx_be_ipc_h, rx_tpm_ipc_h, rx_vtpm_ipc_h, tx_hp_ipc_h, rx_hp_ipc_h; > - struct vtpm_thread_params_s be_thread_params, dmi_thread_params, hp_thread_params; > - pthread_t be_thread, dmi_thread, hp_thread; > - > -#ifdef DUMMY_BACKEND > - vtpm_ipc_handle_t tx_dummy_ipc_h, rx_dummy_ipc_h; > -#else > - vtpm_ipc_handle_t real_be_ipc_h; > -#endif > - > - vtpmloginfo(VTPM_LOG_VTPM, "Starting VTPM.\n"); > - > - // -------------------- Initialize Manager ----------------- > - if (VTPM_Init_Manager() != TPM_SUCCESS) { > - vtpmlogerror(VTPM_LOG_VTPM, "Closing vtpmd due to error during startup.\n"); > - return -1; > - } > - > - // -------------------- Setup Ctrl+C Handlers -------------- > - ctl_c_handler.sa_handler = signal_handler; > - sigemptyset(&ctl_c_handler.sa_mask); > - ctl_c_handler.sa_flags = 0; > - > - if (sigaction(SIGINT, &ctl_c_handler, NULL) == -1) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGINT handler. Ctl+break will not stop manager gently.\n"); > - > - // For easier debuggin with gdb > - if (sigaction(SIGHUP, &ctl_c_handler, NULL) == -1) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGHUP handler. Ctl+break will not stop manager gently.\n"); > - > - sigset_t sig_mask; > - sigemptyset(&sig_mask); > - sigaddset(&sig_mask, SIGPIPE); > - sigprocmask(SIG_BLOCK, &sig_mask, NULL); > - > - // ------------------- Set up file ipc structures ---------- > -#ifdef DUMMY_BACKEND > - if ( (vtpm_ipc_init(&tx_dummy_ipc_h, VTPM_DUMMY_TX_BE_FNAME, O_RDWR, TRUE) != 0) || > - (vtpm_ipc_init(&rx_dummy_ipc_h, VTPM_DUMMY_RX_BE_FNAME, O_RDWR, TRUE) != 0) ) { > - > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create Dummy BE FIFOs.\n"); > - exit(-1); > - } > - > - tx_be_ipc_h = &tx_dummy_ipc_h; > - rx_be_ipc_h = &rx_dummy_ipc_h; > -#else > - vtpm_ipc_init(&real_be_ipc_h, VTPM_BE_FNAME, O_RDWR, FALSE); > - > - tx_be_ipc_h = &real_be_ipc_h; > - rx_be_ipc_h = &real_be_ipc_h; > -#endif > - > - if ( (vtpm_ipc_init(&rx_tpm_ipc_h, VTPM_RX_TPM_FNAME, O_RDONLY, TRUE) != 0) || > - (vtpm_ipc_init(&rx_vtpm_ipc_h, VTPM_RX_VTPM_FNAME, O_RDWR, TRUE) != 0) || //FIXME: O_RDONLY? > - (vtpm_ipc_init(&tx_hp_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || > - (vtpm_ipc_init(&rx_hp_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create initial FIFOs.\n"); > - exit(-1); > - } > - > - g_rx_tpm_ipc_h = &rx_tpm_ipc_h; > - > - // -------------------- Set up thread params ------------- > - > - be_thread_params.tx_ipc_h = tx_be_ipc_h; > - be_thread_params.rx_ipc_h = rx_be_ipc_h; > - be_thread_params.fw_tpm = TRUE; > - be_thread_params.fw_tx_ipc_h = NULL; > - be_thread_params.fw_rx_ipc_h = &rx_tpm_ipc_h; > - be_thread_params.is_priv = FALSE; > - be_thread_params.thread_name = "Backend Listener"; > - > - dmi_thread_params.tx_ipc_h = NULL; > - dmi_thread_params.rx_ipc_h = &rx_vtpm_ipc_h; > - dmi_thread_params.fw_tpm = FALSE; > - dmi_thread_params.fw_tx_ipc_h = NULL; > - dmi_thread_params.fw_rx_ipc_h = NULL; > - dmi_thread_params.is_priv = FALSE; > - dmi_thread_params.thread_name = "VTPM Listener"; > - > - hp_thread_params.tx_ipc_h = &tx_hp_ipc_h; > - hp_thread_params.rx_ipc_h = &rx_hp_ipc_h; > - hp_thread_params.fw_tpm = FALSE; > - hp_thread_params.fw_tx_ipc_h = NULL; > - hp_thread_params.fw_rx_ipc_h = NULL; > - hp_thread_params.is_priv = TRUE; > - hp_thread_params.thread_name = "Hotplug Listener"; > - > - // --------------------- Launch Threads ----------------- > - > - vtpm_lock_init(); > - > - vtpm_globals->master_pid = pthread_self(); > - > - if (pthread_create(&be_thread, NULL, vtpm_manager_thread, &be_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch BE Thread.\n"); > - exit(-1); > - } > - > - if (pthread_create(&dmi_thread, NULL, vtpm_manager_thread, &dmi_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch DMI Thread.\n"); > - exit(-1); > - } > - > - > - if (pthread_create(&hp_thread, NULL, vtpm_manager_thread, &hp_thread_params) != 0) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch HP Thread.\n"); > - exit(-1); > - } > - > - //Join the other threads until exit time. > - pthread_join(be_thread, NULL); > - pthread_join(dmi_thread, NULL); > - pthread_join(hp_thread, NULL); > - > - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Manager shut down unexpectedly.\n"); > - > - VTPM_Stop_Manager(); > - vtpm_lock_destroy(); > - return 0; > -} > diff --git a/tools/vtpm_manager/manager/vtpmpriv.h b/tools/vtpm_manager/manager/vtpmpriv.h > deleted file mode 100644 > index 41e8d2d..0000000 > --- a/tools/vtpm_manager/manager/vtpmpriv.h > +++ /dev/null > @@ -1,186 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpmpriv.h > -// > -// Structures and functions private to the manager > -// > -// ================================================================== > - > -#ifndef __VTPMPRIV_H__ > -#define __VTPMPRIV_H__ > - > -#include "vtpm_manager.h" > -#include "tcg.h" > -#include "tcs.h" > -#include "buffer.h" > -#include "crypto.h" > -#include "vtpm_ipc.h" > - > -#define VTPM_MANAGER_GEN 2 // This is incremented when the manager's table > - // is changed. It's used for backwards compatability > - > -#define STATE_FILE "/var/vtpm/VTPM" > -#define DMI_NVM_FILE "/var/vtpm/vtpm_dm_%d.data" > -#define VTPM_CTL_DM 0 > - > -// ------------------------ Private Structures ----------------------- > -typedef struct VTPM_DMI_RESOURCE_T { > - // I/O info for Manager to talk to DMI's and controllers > - vtpm_ipc_handle_t *tx_vtpm_ipc_h; // TX VTPM Results to DMI > - vtpm_ipc_handle_t *rx_vtpm_ipc_h; // RX VTPM Commands from DMI > - vtpm_ipc_handle_t *tx_tpm_ipc_h; // TX TPM Commands to DMI > - vtpm_ipc_handle_t *rx_tpm_ipc_h; // RX TPM Results from DMI > - > -#ifndef VTPM_MULTI_VM > - pid_t dmi_pid; > -#endif > - > - // Non-persistent Information > - bool connected; > - UINT32 dmi_domain_id; > - TCS_CONTEXT_HANDLE TCSContext; // TCS Handle > - char *NVMLocation; // NULL term string indicating location > - // of NVM. > - // Persistent Information about DMI > - UINT32 dmi_id; > - BYTE dmi_type; > - TPM_DIGEST NVM_measurement; // Equal to the SHA1 of the blob > - TPM_DIGEST DMI_measurement; // Correct measurement of the owning DMI > -} VTPM_DMI_RESOURCE; > - > -typedef struct tdVTPM_MIGKEY_LIST { > - UINT32 name_size; > - BYTE *name; // Name of destination (IP addr, domain name, etc) > - CRYPTO_INFO key; > - struct tdVTPM_MIGKEY_LIST *next; > -} VTPM_MIGKEY_LIST; > - > - > -typedef struct tdVTPM_GLOBALS { > - // Non-persistent data > -#ifndef VTPM_MULTI_VM > - pid_t master_pid; > -#endif > - > - int connected_dmis; // To close guest_rx when no dmis are connected > - > - struct hashtable *dmi_map; // Table of all DMI's known indexed by persistent instance # > - VTPM_MIGKEY_LIST *mig_keys; // Table of migration keys > - // Currently keys are loaded at migration time, > - // TODO: Make VTPM man store a keys persistently > - // and update script to check if key is needed > - // before fetching it. > - > - TCS_CONTEXT_HANDLE manager_tcs_handle; // TCS Handle used by manager > - TPM_HANDLE storageKeyHandle; // Key used by persistent store > - CRYPTO_INFO storageKey; // For software encryption > - CRYPTO_INFO bootKey; // For saving table > - TCS_AUTH keyAuth; // OIAP session for storageKey > - > - // Persistent Data > - TPM_AUTHDATA owner_usage_auth; // OwnerAuth of real TPM > - buffer_t storageKeyWrap; // Wrapped copy of storageKey > - TPM_AUTHDATA srk_usage_auth; > - TPM_AUTHDATA storage_key_usage_auth; > - > - buffer_t bootKeyWrap; // Wrapped copy of boot key > - > -}VTPM_GLOBALS; > - > -// --------------------------- Global Values -------------------------- > -extern VTPM_GLOBALS *vtpm_globals; // Key info and DMI states > -extern const TPM_AUTHDATA SRK_AUTH; // SRK Well Known Auth Value > - > -// ********************** VTPM Functions ************************* > -TPM_RESULT VTPM_Init_Manager(); // Start VTPM Service > -void VTPM_Stop_Manager(); // Stop VTPM Service > -TPM_RESULT VTPM_Manager_Handler(vtpm_ipc_handle_t *tx_ipc_h, > - vtpm_ipc_handle_t *rx_ipc_h, > - BOOL fw_tpm, // Should forward TPM cmds > - vtpm_ipc_handle_t *fw_tx_ipc_h, > - vtpm_ipc_handle_t *fw_rx_ipc_h, > - BOOL is_priv, > - char *client_name); > - > -// ********************** Command Handler Prototypes *********************** > - > -TPM_RESULT VTPM_Handle_Load_NVM( VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_Save_NVM( VTPM_DMI_RESOURCE *myDMI, > - const buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, > - buffer_t *inbuf, > - buffer_t *outbuf); > - > -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Close_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Delete_DMI(const buffer_t *param_buf); > - > -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_Handle_Migrate_Out ( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, > - buffer_t *result_buf); > - > -TPM_RESULT VTPM_SaveManagerData(void); > -TPM_RESULT VTPM_LoadManagerData(void); > - > -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode); > - > -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res); > - > -// Helper functions > -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res); > -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE type, VTPM_DMI_RESOURCE **dmi_res); > - > -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, > - CRYPTO_INFO *asymkey, > - buffer_t *sealed_data); > - > -TPM_RESULT envelope_decrypt(const buffer_t *cipher, > - TCS_CONTEXT_HANDLE TCSContext, > - TPM_HANDLE keyHandle, > - const TPM_AUTHDATA *key_usage_auth, > - buffer_t *unsealed_data); > - > -#endif // __VTPMPRIV_H__ > diff --git a/tools/vtpm_manager/manager/vtsp.c b/tools/vtpm_manager/manager/vtsp.c > deleted file mode 100644 > index fc8a66f..0000000 > --- a/tools/vtpm_manager/manager/vtsp.c > +++ /dev/null > @@ -1,1042 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtsp.c > -// > -// Higher level interface to TCS for use in service. > -// > -// ================================================================== > - > -#include > -#include "tcg.h" > -#include "tcs.h" > -#include "bsg.h" > -#include "log.h" > -#include "crypto.h" > -#include "vtsp.h" > -#include "buffer.h" > - > -#define RSA_KEY_SIZE 0x0800 > - > -/*********************************************************************************** > - * GenerateAuth: Generate authorization info to be sent back to application > - * > - * Parameters: outParamDigestText The concatenation of output parameters to be SHA1ed > - * outParamDigestTextSize Size of inParamDigestText > - * HMACkey Key to be used for HMACing > - * For OIAP use key.authUsage or PersistStore.ownerAuth > - * For OSAP use shared secret > - * pAuth Authorization information from the application > - * > - * Return: TPM_SUCCESS Authorization data created > - * TPM_AUTHFAIL Invalid (NULL) HMACkey presented for OSAP > - *************************************************************************************/ > -TPM_RESULT GenerateAuth( /*[IN]*/ const BYTE *inParamDigestText, > - /*[IN]*/ UINT32 inParamDigestTextSize, > - /*[IN]*/ const TPM_SECRET *HMACkey, > - /*[IN,OUT]*/ TCS_AUTH *auth) { > - > - if (inParamDigestText == NULL || auth == NULL) > - return (TPM_AUTHFAIL); > - else { > - > - //Generate new OddNonce > - Crypto_GetRandom(auth->NonceOdd.nonce, sizeof(TPM_NONCE)); > - > - // Create SHA1 inParamDigest > - TPM_DIGEST inParamDigest; > - Crypto_SHA1Full(inParamDigestText, inParamDigestTextSize, (BYTE *) &inParamDigest); > - > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > - > - BSG_PackList( hmacText, 4, > - BSG_TPM_DIGEST, &inParamDigest, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > - > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &(auth->HMAC)); > - > - return(TPM_SUCCESS); > - > - } > -} > - > -/*********************************************************************************** > - * VerifyAuth: Verify the authdata for a command requiring authorization > - * > - * Parameters: inParamDigestText The concatenation of parameters to be SHA1ed > - * inParamDigestTextSize Size of inParamDigestText > - * authDataUsage AuthDataUsage for the Entity being used > - * Key->authDataUsage or TPM_AUTH_OWNER > - * HMACkey Key to be used for HMACing > - * For OIAP use key.authUsage or PersistStore.ownerAuth > - * For OSAP use NULL (It will be aquired from the Auth Session) > - * If unknown (default), assume OIAP > - * sessionAuth A TCS_AUTH info for the session > - * pAuth Authorization information from the application > - * hContext If specified, on failed Auth, VerifyAuth will > - * generate a new OIAP session in place of themselves > - * destroyed session. > - * > - * Return: TPM_SUCCESS Authorization Verified > - * TPM_AUTHFAIL Authorization Failed > - * TPM_FAIL Failure during SHA1 routines > - *************************************************************************************/ > -TPM_RESULT VerifyAuth( /*[IN]*/ const BYTE *outParamDigestText, > - /*[IN]*/ UINT32 outParamDigestTextSize, > - /*[IN]*/ const TPM_SECRET *HMACkey, > - /*[IN,OUT]*/ TCS_AUTH *auth, > - /*[IN]*/ TCS_CONTEXT_HANDLE hContext) { > - if (outParamDigestText == NULL || auth == NULL) > - return (TPM_AUTHFAIL); > - > - > - // Create SHA1 inParamDigest > - TPM_DIGEST outParamDigest; > - Crypto_SHA1Full(outParamDigestText, outParamDigestTextSize, (BYTE *) &outParamDigest); > - > - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). > - TPM_DIGEST hm; > - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; > - > - BSG_PackList( hmacText, 4, > - BSG_TPM_DIGEST, &outParamDigest, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); > - > - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), > - (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &hm); > - > - // Compare correct HMAC with provided one. > - if (memcmp (&hm, &(auth->HMAC), sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality > - if (!auth->fContinueAuthSession) > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM by fContinue=0.\n", auth->AuthHandle); > - > - return (TPM_SUCCESS); > - } else { > - // If specified, reconnect the OIAP session. > - // NOTE: This only works for TCS's that never have a 0 context. > - if (hContext) { > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM due to failure.\n", auth->AuthHandle); > - VTSP_OIAP( hContext, auth); > - } > - return (TPM_AUTHFAIL); > - } > -} > - > -TPM_RESULT VTSP_OIAP(const TCS_CONTEXT_HANDLE hContext, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "OIAP.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPMTRYRETURN( TCSP_OIAP(hContext, > - &auth->AuthHandle, > - &auth->NonceEven) ); > - > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > - auth->fContinueAuthSession = FALSE; > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -TPM_RESULT VTSP_OSAP(const TCS_CONTEXT_HANDLE hContext, > - const TPM_ENTITY_TYPE entityType, > - const UINT32 entityValue, > - const TPM_AUTHDATA *usageAuth, > - TPM_SECRET *sharedSecret, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "OSAP.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPM_NONCE nonceEvenOSAP, nonceOddOSAP; > - > - Crypto_GetRandom((BYTE *) &nonceOddOSAP, sizeof(TPM_NONCE) ); > - > - TPMTRYRETURN( TCSP_OSAP( hContext, > - entityType, > - entityValue, > - nonceOddOSAP, > - &auth->AuthHandle, > - &auth->NonceEven, > - &nonceEvenOSAP) ); > - > - // Calculating Session Secret > - BYTE sharedSecretText[TPM_DIGEST_SIZE * 2]; > - > - BSG_PackList( sharedSecretText, 2, > - BSG_TPM_NONCE, &nonceEvenOSAP, > - BSG_TPM_NONCE, &nonceOddOSAP); > - > - Crypto_HMAC(sharedSecretText, sizeof(sharedSecretText), (BYTE *) usageAuth, TPM_DIGEST_SIZE, (BYTE *) sharedSecret); > - > - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > - auth->fContinueAuthSession = FALSE; > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > - > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > - const TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Terminate Handle.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - TPMTRYRETURN( TCSP_TerminateHandle(hContext, auth->AuthHandle) ); > - > - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM_TerminateHandle.\n", auth->AuthHandle); > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > - > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > - CRYPTO_INFO *crypto_info) { > - > - TPM_RESULT status; > - TPM_NONCE antiReplay; > - TPM_DIGEST checksum; > - BYTE *pubEKtext; > - UINT32 pubEKtextsize; > - > - vtpmloginfo(VTPM_LOG_VTSP, "Reading Public EK.\n"); > - > - // GenerateAuth new nonceOdd > - Crypto_GetRandom(&antiReplay, sizeof(TPM_NONCE) ); > - > - > - TPMTRYRETURN( TCSP_ReadPubek( hContext, > - antiReplay, > - &pubEKtextsize, > - &pubEKtext, > - &checksum) ); > - > - > - // Extract the remaining output parameters > - TPM_PUBKEY pubEK; > - > - BSG_Unpack(BSG_TPM_PUBKEY, pubEKtext, (BYTE *) &pubEK); > - > - // Build CryptoInfo for the bindingKey > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - pubEK.algorithmParms.parms, > - &rsaKeyParms); > - > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > - rsaKeyParms.exponent, > - pubEK.pubKey.keyLength, > - pubEK.pubKey.key, > - crypto_info); > - > - // Destroy rsaKeyParms > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > - > - // Set encryption scheme > - crypto_info->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - //crypto_info->encScheme = pubEK.algorithmParms.encScheme; > - crypto_info->algorithmID = pubEK.algorithmParms.algorithmID; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - const TPM_AUTHDATA *srkAuth, > - CRYPTO_INFO *ek_cryptoInfo, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Taking Ownership of TPM.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_TakeOwnership; > - TPM_PROTOCOL_ID proto_id = TPM_PID_OWNER; > - BYTE *new_srk; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // vars for srkpubkey parameter > - TPM_KEY srkPub; > - TPM_KEY_PARMS srkKeyInfo = {TPM_ALG_RSA, TPM_ES_RSAESOAEP_SHA1_MGF1, TPM_SS_NONE, 12, 0}; > - BYTE srkRSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > - srkKeyInfo.parms = (BYTE *) &srkRSAkeyInfo; > - > - struct pack_buf_t srkText; > - > - //These values are accurate for an enc(AuthData). > - struct pack_buf_t encOwnerAuth, encSrkAuth; > - > - encOwnerAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > - encSrkAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); > - > - if (encOwnerAuth.data == NULL || encSrkAuth.data == NULL) { > - vtpmloginfo(VTPM_LOG_VTSP, "Could not malloc encrypted auths.\n"); > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) ownerAuth, &encOwnerAuth.size, encOwnerAuth.data); > - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) srkAuth, &encSrkAuth.size, encSrkAuth.data); > - > - > - // Build srk public key struct > - srkPub.ver = TPM_STRUCT_VER_1_1; > - srkPub.keyUsage = TPM_KEY_STORAGE; > - srkPub.keyFlags = 0x00; > - srkPub.authDataUsage = TPM_AUTH_ALWAYS; > - memcpy(&srkPub.algorithmParms, &srkKeyInfo, sizeof(TPM_KEY_PARMS)); > - srkPub.PCRInfoSize = 0; > - srkPub.PCRInfo = 0; > - srkPub.pubKey.keyLength= 0; > - srkPub.encDataSize = 0; > - > - srkText.data = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - srkText.size = BSG_Pack(BSG_TPM_KEY, (BYTE *) &srkPub, srkText.data); > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 5, > - BSG_TPM_COMMAND_CODE,&command, > - BSG_TPM_PROTOCOL_ID, &proto_id, > - BSG_TPM_SIZE32_DATA, &encOwnerAuth, > - BSG_TPM_SIZE32_DATA, &encSrkAuth, > - BSG_TPM_KEY, &srkPub); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, ownerAuth, auth) ); > - > - new_srk = srkText.data; > - TPMTRYRETURN( TCSP_TakeOwnership ( hContext, > - proto_id, > - encOwnerAuth.size, > - encOwnerAuth.data, > - encSrkAuth.size, > - encSrkAuth.data, > - &srkText.size, > - &new_srk, > - auth ) ); > - > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - memcpy(paramText + paramTextSize, new_srk, srkText.size); > - paramTextSize += srkText.size; > - > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - ownerAuth, auth, > - hContext) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(srkText.data); > - free(encSrkAuth.data); > - free(encOwnerAuth.data); > - free(paramText); > - > - TCS_FreeMemory(hContext, new_srk); > - > - return status; > -} > - > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Disabling Pubek Read.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_DisablePubekRead; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 1, > - BSG_TPM_COMMAND_CODE, &command); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - ownerAuth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_DisablePubekRead ( hContext, // in > - auth) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - ownerAuth, auth, > - hContext) ); > - goto egress; > - > - abort_egress: > - egress: > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_USAGE usage, > - const TPM_AUTHDATA *newKeyAuth, > - const TCS_KEY_HANDLE parentHandle, > - const TPM_AUTHDATA *osapSharedSecret, > - buffer_t *pubKeyBuf, > - TCS_AUTH *auth) { > - > - int i; > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_CreateWrapKey; > - > - vtpmloginfo(VTPM_LOG_VTSP, "Creating new key of type %d.\n", usage); > - > - // vars for Calculate encUsageAuth > - BYTE *paramText; > - UINT32 paramTextSize; > - > - // vars for Calculate encUsageAuth > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > - TPM_DIGEST XORKey1; > - UINT32 XORbufferSize; > - TPM_SECRET encUsageAuth, encMigrationAuth; > - > - // vars for Flatten newKey prototype > - BYTE *flatKey = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - UINT32 flatKeySize = TCPA_MAX_BUFFER_LENGTH; > - struct pack_buf_t newKeyText; > - > - // Fill in newKey > - TPM_KEY newKey; > - > - BYTE RSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; > - newKey.algorithmParms.algorithmID = TPM_ALG_RSA; > - newKey.algorithmParms.parms = (BYTE *) &RSAkeyInfo; > - newKey.algorithmParms.parmSize = 12; > - > - switch (usage) { > - case TPM_KEY_SIGNING: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Signing Key...\n"); > - newKey.keyUsage = TPM_KEY_SIGNING; > - newKey.algorithmParms.encScheme = TPM_ES_NONE; > - newKey.algorithmParms.sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1; > - break; > - case TPM_KEY_STORAGE: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Storage Key...\n"); > - newKey.keyUsage = TPM_KEY_STORAGE; > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > - break; > - case TPM_KEY_BIND: > - vtpmloginfo(VTPM_LOG_VTSP, "Creating Binding Key...\n"); > - newKey.keyUsage = TPM_KEY_BIND; > - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; > - newKey.algorithmParms.sigScheme = TPM_SS_NONE; > - break; > - default: > - vtpmloginfo(VTPM_LOG_VTSP, "Cannot create key. Invalid Key Type.\n"); > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - > - newKey.ver = TPM_STRUCT_VER_1_1; > - > - newKey.keyFlags = 0; > - newKey.authDataUsage = TPM_AUTH_ALWAYS; > - newKey.pubKey.keyLength= 0; > - newKey.encDataSize = 0; > - newKey.encData = NULL; > - > - // FIXME: Support PCR bindings > - newKey.PCRInfoSize = 0; > - newKey.PCRInfo = NULL; > - > - // Calculate encUsageAuth > - XORbufferSize = BSG_PackList( XORbuffer, 2, > - BSG_TPM_SECRET, osapSharedSecret, > - BSG_TPM_NONCE, &auth->NonceEven); > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey1); > - > - // FIXME: No support for migratable keys. > - for (i=0; i < TPM_DIGEST_SIZE; i++) > - ((BYTE *) &encUsageAuth)[i] = ((BYTE *) &XORKey1)[i] ^ ((BYTE *) newKeyAuth)[i]; > - > - // Flatten newKey prototype > - flatKeySize = BSG_Pack(BSG_TPM_KEY, (BYTE *) &newKey, flatKey); > - newKeyText.data = flatKey; > - newKeyText.size = flatKeySize; > - > - // Generate HMAC > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_AUTHDATA, &encUsageAuth, > - BSG_TPM_AUTHDATA, &encMigrationAuth); > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > - paramTextSize += newKeyText.size; > - > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - osapSharedSecret, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_CreateWrapKey( hContext, > - parentHandle, > - encUsageAuth, > - encMigrationAuth, > - &newKeyText.size, > - &newKeyText.data, > - auth) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command); > - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); > - paramTextSize += newKeyText.size; > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - osapSharedSecret, auth, 0) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init(pubKeyBuf, 0, 0) ); > - TPMTRYRETURN(buffer_append_raw(pubKeyBuf, newKeyText.size, newKeyText.data) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(flatKey); > - free(paramText); > - TCS_FreeMemory(hContext, newKeyText.data); > - > - return status; > -} > - > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > - const TCS_KEY_HANDLE hUnwrappingKey, > - const buffer_t *rgbWrappedKeyBlob, > - const TPM_AUTHDATA *parentAuth, > - TPM_HANDLE *newKeyHandle, > - TCS_AUTH *auth, > - CRYPTO_INFO *cryptoinfo, > - const BOOL skipTPMLoad) { > - > - > - vtpmloginfo(VTPM_LOG_VTSP, "Loading Key %s.\n", (!skipTPMLoad ? "into TPM" : "only into memory")); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_LoadKey; > - > - BYTE *paramText=NULL; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // SkipTPMLoad stops key from being loaded into TPM, but still generates CRYPTO_INFO for it > - if (! skipTPMLoad) { > - > - if ((rgbWrappedKeyBlob == NULL) || (parentAuth == NULL) || > - (newKeyHandle==NULL) || (auth==NULL)) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // Generate Extra TCS Parameters > - TPM_HANDLE phKeyHMAC; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 1, > - BSG_TPM_COMMAND_CODE, &command); > - > - memcpy(paramText + paramTextSize, rgbWrappedKeyBlob->bytes, buffer_len(rgbWrappedKeyBlob)); > - paramTextSize += buffer_len(rgbWrappedKeyBlob); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - parentAuth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_LoadKeyByBlob( hContext, > - hUnwrappingKey, > - buffer_len(rgbWrappedKeyBlob), > - rgbWrappedKeyBlob->bytes, > - auth, > - newKeyHandle, > - &phKeyHMAC) ); > - > - // Verify Auth > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_HANDLE, newKeyHandle); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - parentAuth, auth, > - hContext) ); > - } > - > - // Build cryptoinfo structure for software crypto function. > - if (cryptoinfo != NULL) { > - TPM_KEY newKey; > - > - // Unpack/return key structure > - BSG_Unpack(BSG_TPM_KEY, rgbWrappedKeyBlob->bytes , &newKey); > - TPM_RSA_KEY_PARMS rsaKeyParms; > - > - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, > - newKey.algorithmParms.parms, > - &rsaKeyParms); > - > - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, > - rsaKeyParms.exponent, > - newKey.pubKey.keyLength, > - newKey.pubKey.key, > - cryptoinfo); > - > - // Destroy rsaKeyParms > - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); > - > - // Set encryption scheme > - cryptoinfo->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; > - } > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE key_handle, > - const buffer_t *bound_data, > - const TPM_AUTHDATA *usage_auth, > - buffer_t *clear_data, > - TCS_AUTH *auth) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Unbinding %d bytes of data.\n", buffer_len(bound_data)); > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_UnBind; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate Extra TCS Parameters > - struct pack_buf_t clear_data32; > - BYTE *clear_data_text; > - UINT32 clear_data_size; > - > - struct pack_buf_t bound_data32 = {bound_data->size, bound_data->bytes}; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &bound_data32); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - usage_auth, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_UnBind( hContext, > - key_handle, > - buffer_len(bound_data), > - bound_data->bytes, > - auth, > - &clear_data_size, > - &clear_data_text) ); > - > - > - // Verify Auth > - clear_data32.size = clear_data_size; > - clear_data32.data = clear_data_text; > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &clear_data32); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - usage_auth, auth, > - hContext) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init(clear_data, 0, 0)); > - TPMTRYRETURN(buffer_append_raw (clear_data, clear_data_size, clear_data_text) ); > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - free(paramText); > - TCS_FreeMemory(hContext, clear_data_text); > - > - return status; > -} > - > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > - const buffer_t *inData, > - buffer_t *outData) > -{ > - vtpmloginfo(VTPM_LOG_VTSP, "Binding %d bytes of data.\n", buffer_len(inData)); > - TPM_RESULT status = TPM_SUCCESS; > - TPM_BOUND_DATA boundData; > - UINT32 i; > - > - // Fill boundData's accessory information > - boundData.ver = TPM_STRUCT_VER_1_1; > - boundData.payload = TPM_PT_BIND; > - boundData.payloadData = inData->bytes; > - > - // Pack boundData before encryption > - BYTE* flatBoundData = (BYTE *)malloc(sizeof(BYTE) * > - (sizeof(TPM_VERSION) + > - sizeof(TPM_PAYLOAD_TYPE) + > - buffer_len(inData))); > - if (flatBoundData == NULL) { > - return TPM_NOSPACE; > - } > - UINT32 flatBoundDataSize = 0; > - flatBoundDataSize = BSG_PackList( flatBoundData, 2, > - BSG_TPM_VERSION, &boundData.ver, > - BSG_TYPE_BYTE, &boundData.payload); > - > - memcpy(flatBoundData+flatBoundDataSize, inData->bytes, buffer_len(inData)); > - flatBoundDataSize += buffer_len(inData); > - > - BYTE out_tmp[RSA_KEY_SIZE/8]; // RSAEnc does not do blocking, So this is what will come out. > - UINT32 out_tmp_size; > - > - // Encrypt flatBoundData > - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_RSAEnc( cryptoInfo, > - flatBoundDataSize, > - flatBoundData, > - &out_tmp_size, > - out_tmp) ); > - > - if (out_tmp_size > RSA_KEY_SIZE/8) { > - // The result of RSAEnc should be a fixed size based on key size. > - vtpmlogerror(VTPM_LOG_VTSP, "Enc buffer just overflowed.\n"); > - } > - > - buffer_init(outData, 0, NULL); > - buffer_append_raw(outData, out_tmp_size, out_tmp); > - > - vtpmloginfo(VTPM_LOG_TXDATA, "Bind Generated[%d] = 0x", out_tmp_size); > - for(i = 0 ; i < out_tmp_size ; i++) { > - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out_tmp[i]); > - } > - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); > - > - goto egress; > - abort_egress: > - egress: > - > - // Free flatBoundData > - free(flatBoundData); > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_AUTHDATA *sealDataAuth, > - const TPM_PCR_COMPOSITE *pcrComp, > - const buffer_t *inData, > - TPM_STORED_DATA *sealedData, > - const TPM_SECRET *osapSharedSecret, > - TCS_AUTH *auth) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_Seal; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate PCR_Info Struct from Comp > - TPM_PCR_INFO pcrInfo; > - UINT32 pcrInfoSize, flatpcrSize; > - BYTE flatpcr[3 + // PCR_Select = 3 1 byte banks > - sizeof(UINT16) + // 2 byte UINT16 > - sizeof(UINT32) + // PCR_Comp = 4 byte UINT32 > - 24 * sizeof(TPM_PCRVALUE) ]; // up to 24 PCRs > - > - if (pcrComp != NULL) { > - //printf("\n\tBinding to PCRs: "); > - //for(int i = 0 ; i < pcrComp->select.sizeOfSelect ; i++) > - //printf("%2.2x", pcrComp->select.pcrSelect[i]); > - > - memcpy(&pcrInfo.pcrSelection, &pcrComp->select, sizeof(TPM_PCR_SELECTION)); > - > - flatpcrSize = BSG_Pack(BSG_TPM_PCR_COMPOSITE, (BYTE *) pcrComp, flatpcr); > - Crypto_SHA1Full((BYTE *) flatpcr, flatpcrSize, (BYTE *) &(pcrInfo.digestAtRelease)); > - memset(&(pcrInfo.digestAtCreation), 0, sizeof(TPM_DIGEST)); > - pcrInfoSize = BSG_Pack(BSG_TPM_PCR_INFO, (BYTE *) &pcrInfo, flatpcr); > - } else { > - //printf("\n\tBinding to no PCRS."); > - pcrInfoSize = 0; > - } > - > - // Calculate encUsageAuth > - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; > - UINT32 XORbufferSize = sizeof(XORbuffer); > - TPM_DIGEST XORKey; > - TPM_ENCAUTH encAuth; > - > - BSG_PackList( XORbuffer, 2, > - BSG_TPM_SECRET, osapSharedSecret, > - BSG_TPM_NONCE, &auth->NonceEven ); > - > - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey); > - > - int i; > - for (i=0; i < TPM_DIGEST_SIZE; i++) > - ((BYTE *) &encAuth)[i] = ((BYTE *) &XORKey)[i] ^ ((BYTE *) sealDataAuth)[i]; > - > - // Generate Extra TCS Parameters > - UINT32 inDataSize = buffer_len(inData); > - struct pack_buf_t inData_pack = {inDataSize, inData->bytes}; > - struct pack_buf_t pcrInfo_pack = {pcrInfoSize, flatpcr}; > - > - UINT32 sealedDataSize; > - BYTE *flatSealedData=NULL; > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 4, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_ENCAUTH, &encAuth, > - BSG_TPM_SIZE32_DATA, &pcrInfo_pack, > - BSG_TPM_SIZE32_DATA, &inData_pack); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - osapSharedSecret, auth) ); > - > - // Call TCS > - TPMTRYRETURN( TCSP_Seal( hContext, > - keyHandle, > - encAuth, > - pcrInfoSize, > - flatpcr, > - inDataSize, > - inData->bytes, > - auth, > - &sealedDataSize, > - &flatSealedData) ); > - > - // Unpack/return key structure > - BSG_Unpack( BSG_TPM_STORED_DATA, flatSealedData, sealedData ); > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_STORED_DATA, sealedData); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - osapSharedSecret, auth, > - 0) ); > - > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (flatSealedData) > - TCS_FreeMemory( hContext, flatSealedData); > - > - free(paramText); > - return status; > -} > - > - > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_STORED_DATA *sealedData, > - const TPM_AUTHDATA *key_usage_auth, > - const TPM_AUTHDATA *data_usage_auth, > - buffer_t *outData, > - TCS_AUTH *auth, > - TCS_AUTH *dataAuth) { > - > - TPM_RESULT status = TPM_SUCCESS; > - TPM_COMMAND_CODE command = TPM_ORD_Unseal; > - > - BYTE *paramText; // Digest to make Auth. > - UINT32 paramTextSize; > - > - // Generate Extra TCS Parameters > - UINT32 sealDataSize, clearDataSize; > - BYTE *flatSealedData= (BYTE *) malloc(sizeof(TPM_VERSION) + > - 2 * sizeof(UINT32) + > - sealedData->sealInfoSize + > - sealedData->encDataSize), > - *clearData=NULL; > - > - sealDataSize = BSG_Pack(BSG_TPM_STORED_DATA, sealedData, flatSealedData ); > - > - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - > - paramTextSize = BSG_PackList(paramText, 2, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_STORED_DATA, sealedData); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - key_usage_auth, auth) ); > - > - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, > - data_usage_auth, dataAuth) ); > - // Call TCS > - TPMTRYRETURN( TCSP_Unseal( hContext, > - keyHandle, > - sealDataSize, > - flatSealedData, > - auth, > - dataAuth, > - &clearDataSize, > - &clearData) ); > - > - // Verify Auth > - struct pack_buf_t clearData_pack = {clearDataSize, clearData}; > - > - paramTextSize = BSG_PackList(paramText, 3, > - BSG_TPM_RESULT, &status, > - BSG_TPM_COMMAND_CODE, &command, > - BSG_TPM_SIZE32_DATA, &clearData_pack); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - key_usage_auth, auth, > - hContext) ); > - > - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, > - data_usage_auth, dataAuth, > - hContext) ); > - > - // Unpack/return key structure > - TPMTRYRETURN( buffer_init(outData, clearDataSize, clearData) ); > - > - goto egress; > - > - abort_egress: > - egress: > - > - if (flatSealedData) > - TCS_FreeMemory( hContext, clearData); > - > - free(paramText); > - return status; > -} > - > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Calling TPM_SaveState.\n"); > - > - TPM_RESULT status = TPM_SUCCESS; > - > - // Call TCS > - return ( TCSP_SaveState ( hContext ) ); > - > -} > - > - > -// Function Reaches into unsupported TCS command, beware. > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > - const buffer_t *inbuf, > - buffer_t *outbuf ) { > - > - vtpmloginfo(VTPM_LOG_VTSP, "Passthrough in use.\n"); > - TPM_RESULT status = TPM_SUCCESS; > - > - // Generate Extra TCS Parameters > - BYTE *resultText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); > - UINT32 resultTextSize = TCPA_MAX_BUFFER_LENGTH; > - > - // Call TCS > - TPMTRYRETURN( TCSP_RawTransmitData(buffer_len(inbuf), inbuf->bytes, > - &resultTextSize, resultText) ); > - > - // Unpack/return key structure > - TPMTRYRETURN(buffer_init (outbuf, resultTextSize, resultText) ); > - goto egress; > - > - abort_egress: > - > - egress: > - TCS_FreeMemory(hContext, resultText); > - free(resultText); > - return status; > -} > diff --git a/tools/vtpm_manager/manager/vtsp.h b/tools/vtpm_manager/manager/vtsp.h > deleted file mode 100644 > index 2fb0440..0000000 > --- a/tools/vtpm_manager/manager/vtsp.h > +++ /dev/null > @@ -1,126 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtsp.h > -// > -// Higher level interface to TCS. > -// > -// ================================================================== > - > -#ifndef __VTSP_H__ > -#define __VTSP_H__ > - > -#include "tcg.h" > -#include "tcs.h" > - > -#define KEY_BUFFER_SIZE 2048 > - > -TPM_RESULT VTSP_RawTransmit(const TCS_CONTEXT_HANDLE hContext, > - const buffer_t *inbuf, > - buffer_t *outbuf ); > - > -TPM_RESULT VTSP_OIAP( const TCS_CONTEXT_HANDLE hContext, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_OSAP( const TCS_CONTEXT_HANDLE hContext, > - const TPM_ENTITY_TYPE entityType, > - const UINT32 entityValue, > - const TPM_AUTHDATA *usageAuth, > - TPM_SECRET *sharedsecret, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, > - const TCS_AUTH *auth); > - > -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, > - CRYPTO_INFO *cypto_info); > - > -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - const TPM_AUTHDATA *srkAuth, > - CRYPTO_INFO *ek_cryptoInfo, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, > - const TPM_AUTHDATA *ownerAuth, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_USAGE usage, > - const TPM_AUTHDATA *newKeyAuth, > - const TCS_KEY_HANDLE parentHandle, > - const TPM_AUTHDATA *osapSharedSecret, > - buffer_t *pubKeyBuf, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, > - const TCS_KEY_HANDLE hUnwrappingKey, > - const buffer_t *rgbWrappedKeyBlob, > - const TPM_AUTHDATA *parentAuth, > - TPM_HANDLE *newKeyHandle, > - TCS_AUTH *pAuth, > - CRYPTO_INFO *cryptoinfo, > - const BOOL skipTPMLoad); > - > -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE key_handle, > - const buffer_t *bound_data, > - const TPM_AUTHDATA *usage_auth, > - buffer_t *clear_data, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, > - const buffer_t *inData, > - buffer_t *outData); > - > -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_AUTHDATA *sealDataAuth, > - const TPM_PCR_COMPOSITE *pcrComp, > - const buffer_t *inData, > - TPM_STORED_DATA *sealedData, > - const TPM_SECRET *osapSharedSecret, > - TCS_AUTH *auth); > - > -TPM_RESULT VTSP_Unseal(const TCS_CONTEXT_HANDLE hContext, > - const TPM_KEY_HANDLE keyHandle, > - const TPM_STORED_DATA *sealedData, > - const TPM_AUTHDATA *key_usage_auth, > - const TPM_AUTHDATA *data_usage_auth, > - buffer_t *outData, > - TCS_AUTH *auth, > - TCS_AUTH *dataAuth); > - > -TPM_RESULT VTSP_SaveState( const TCS_CONTEXT_HANDLE hContext); > - > -#endif //_VTSP_H_ > diff --git a/tools/vtpm_manager/migration/Makefile b/tools/vtpm_manager/migration/Makefile > deleted file mode 100644 > index e33ae95..0000000 > --- a/tools/vtpm_manager/migration/Makefile > +++ /dev/null > @@ -1,42 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -VPATH = ../manager > - > -BIND = vtpm_migratord > -BINC = vtpm_migrator > - > -SRCSD = vtpm_manager_if.c vtpm_migratord.c vtpm_migratord_handler.c vtpm_ipc.c > -SRCSC = vtpm_manager_if.c vtpm_migrator_if.c vtpm_migratorc.c vtpm_ipc.c > - > -OBJSD = $(patsubst %.c,%.o,$(SRCSD)) > -OBJSC = $(patsubst %.c,%.o,$(SRCSC)) > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIND) $(BINC) > - > -.PHONY: install > -install: build > - $(INSTALL_PROG) $(BIND) $(DESTDIR)$(BINDIR) > - $(INSTALL_PROG) $(BINC) $(DESTDIR)$(BINDIR) > - > -.PHONY: clean > -clean: > - rm -f $(BINC) $(BIND) > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIND): $(OBJSD) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -$(BINC): $(OBJSC) > - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ > - > -# libraries > -LIBS += ../util/libTCGUtils.a > diff --git a/tools/vtpm_manager/migration/vtpm_manager_if.c b/tools/vtpm_manager/migration/vtpm_manager_if.c > deleted file mode 100644 > index 08986f4..0000000 > --- a/tools/vtpm_manager/migration/vtpm_manager_if.c > +++ /dev/null > @@ -1,186 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_manager_if.c > -// > -// Provides functions to call local vtpm manager interface (Hotplug) > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "vtpm_ipc.h" > -#include "bsg.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" > -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" > - > -static vtpm_ipc_handle_t tx_ipc_h, rx_ipc_h; > - > -TPM_RESULT vtpm_manager_open(){ > - > - if ( (vtpm_ipc_init(&tx_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || //FIXME: wronly > - (vtpm_ipc_init(&rx_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { //FIXME: rdonly > - vtpmlogerror(VTPM_LOG_VTPM, "Unable to connect to vtpm_manager.\n"); > - return TPM_IOERROR; > - } > - > - return TPM_SUCCESS; > -} > - > -void vtpm_manager_close() { > - > - vtpm_ipc_close(&tx_ipc_h); > - vtpm_ipc_close(&rx_ipc_h); > -} > - > - > -TPM_RESULT vtpm_manager_command(TPM_COMMAND_CODE ord, > - buffer_t *command_param_buf, > - TPM_RESULT *cmd_status, /* out */ > - buffer_t *result_param_buf) { > - > - TPM_RESULT status = TPM_FAIL; > - int size_read, size_write, i; > - BYTE *adj_command, response_header[VTPM_COMMAND_HEADER_SIZE_SRV]; > - UINT32 dmi_id=0, adj_command_size, out_param_size, adj_param_size; > - TPM_TAG tag=VTPM_TAG_REQ; > - > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - adj_command_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(command_param_buf); > - adj_command = (BYTE *) malloc( adj_command_size ); > - if (!adj_command) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > - BSG_PackList(adj_command, 4, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - memcpy(adj_command + VTPM_COMMAND_HEADER_SIZE_SRV, command_param_buf->bytes, buffer_len(command_param_buf)); > - > - size_write = vtpm_ipc_write(&tx_ipc_h, NULL, adj_command, adj_command_size); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MGR): 0x"); > - for (i=0; i< adj_command_size; i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", adj_command[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing VTPM Manager console.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_write != (int) adj_command_size ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to mgr (%d/%d)\n", size_write, adj_command_size); > - > - // Read header for response to manager command > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, response_header, VTPM_COMMAND_HEADER_SIZE_SRV); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MGR): 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE_SRV) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from vtpm_manager shorter than std header.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(response_header, 4, > - BSG_TYPE_UINT32, &dmi_id, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, cmd_status ); > - > - // If response has parameters, read them. > - // Note that out_param_size is in the client's context > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > - size_read = vtpm_ipc_read(&rx_ipc_h, NULL, result_param_buf->bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from vtpm manager.\n"); > - goto abort_egress; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > - > diff --git a/tools/vtpm_manager/migration/vtpm_migrator.h b/tools/vtpm_manager/migration/vtpm_migrator.h > deleted file mode 100644 > index 8d52e66..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migrator.h > +++ /dev/null > @@ -1,104 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_migrator.h > -// > -// Public Interface header for VTPM Migrator > -// > -// ================================================================== > - > -#ifndef __VTPM_MIGRATOR_H__ > -#define __VTPM_MIGRATOR_H__ > - > -#define VTPM_MTAG_REQ 0x02c1 > -#define VTPM_MTAG_RSP 0x02c4 > - > -// Header sizes. > -#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) > -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) > - > -//*********************** Connection Info ************************** > -#define VTPM_MIG_PORT 48879 > - > -//************************ Command Codes *************************** > -#define VTPM_MORD_MIG_STEP1 0x00 > -#define VTPM_MORD_MIG_STEP2 0x01 > -#define VTPM_MORD_MIG_STEP3 0x02 > -#define VTPM_MORD_MIG_STEP4 0x03 > - > -//************************ Return Codes **************************** > -#define VTPM_SUCCESS 0 > -#define VTPM_FAIL 1 > - > -/******************* Command Parameter API ************************* > - > -VTPM Command Format > - tpm tag: 2 bytes > - command size: 4 bytes // Size of command including header but not DMI > - ord: 4 bytes // Command ordinal above > - parameters: size - 10 bytes // Command Parameter > - > -VTPM Response Format > - tpm tag: 2 bytes > - response_size: 4 bytes > - status: 4 bytes > - parameters: size - 10 bytes > - > - > -VTPM_Mig_Phase1: > - Unsupported: (Handled by scripts) > - > -VTPM_Mig_Phase2 > - Input Parameters: > - domain_name_size: 4 bytes > - domain_name : domain_name_size bytes > - Output Parameters: > - pub_exp_size: 4 bytes > - pub_exp: pub_exp_size bytes > - pub_mod_size: 4 bytes > - pub_mod: pub_mod_size bytes > - > -VTPM_Mig_Phase3 > - Input Parameters: > - vtpm_state_size: 4 bytes > - vtpm_state: vtpm_state_size bytes > - Output Parameters: > - none > - > -VTPM_Mig_Phase4 > - Unsupported: (Handled by scripts) > - > - > -*********************************************************************/ > - > -#endif //_VTPM_MANAGER_H_ > diff --git a/tools/vtpm_manager/migration/vtpm_migrator_if.c b/tools/vtpm_manager/migration/vtpm_migrator_if.c > deleted file mode 100644 > index de48b2d..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migrator_if.c > +++ /dev/null > @@ -1,219 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// vtpm_migrator_if.c > -// > -// Provides functions to call open network connection & call > -// a function on the vtpm_migratord on the destination > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "bsg.h" > -#include "vtpm_migrator.h" > - > -static int sock_desc; > - > - > -TPM_RESULT vtpm_migratord_open(char *server_address){ > - > - TPM_RESULT status = TPM_FAIL; > - > - /* network variables */ > - struct in_addr ip_addr; > - struct sockaddr_in server_addr; > - int addr_len; > - struct hostent *dns_info=NULL; > - > - /* set up connection to server*/ > - dns_info = gethostbyname(server_address); > - ip_addr.s_addr = *((unsigned long *) dns_info->h_addr_list[0]); > - > - if(ip_addr.s_addr < 0) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - /* set up server variable */ > - memset((char *)&server_addr, 0, sizeof(server_addr)); > - server_addr.sin_family = AF_INET; > - server_addr.sin_port = htons(VTPM_MIG_PORT); > - server_addr.sin_addr.s_addr = ip_addr.s_addr; > - > - /* open socket, make connection */ > - sock_desc = socket(AF_INET, SOCK_STREAM, 0); > - > - if (sock_desc < 0 ) { > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (connect(sock_desc, > - (struct sockaddr *)&server_addr, > - sizeof(server_addr)) < 0 ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - status = TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > -void vtpm_migratord_close() { > - close(sock_desc); > -} > - > - > -TPM_RESULT vtpm_migratord_command(TPM_COMMAND_CODE ord, > - buffer_t *command_param_buf, > - TPM_RESULT *cmd_status, /* out */ > - buffer_t *result_param_buf) { > - > - TPM_RESULT status = TPM_FAIL; > - int size_read, size_write, i; > - BYTE *command, response_header[VTPM_COMMAND_HEADER_SIZE]; > - UINT32 dmi_id=0, command_size, out_param_size, adj_param_size; > - TPM_TAG tag=VTPM_MTAG_REQ; > - > - if ( (!command_param_buf) || (!result_param_buf) || (!cmd_status) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - command_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(command_param_buf); > - command = (BYTE *) malloc( command_size ); > - if (!command) { > - status = TPM_RESOURCES; > - goto abort_egress; > - } > - > - BSG_PackList(command, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &command_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - memcpy(command + VTPM_COMMAND_HEADER_SIZE, command_param_buf->bytes, buffer_len(command_param_buf)); > - > - size_write = write(sock_desc, command, command_size); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT (MIGd): 0x"); > - for (i=0; i< command_size; i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", command[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing to migration server via network.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_write != (int) command_size ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not write entire command to migration server (%d/%d)\n", size_write, command_size); > - > - // Read header for response > - size_read = read(sock_desc, response_header, VTPM_COMMAND_HEADER_SIZE); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV (MIGd): 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", response_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from Migration Server.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from migration server shorter than std header.\n"); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - > - // Unpack response from DMI for TPM command > - BSG_UnpackList(response_header, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_COMMAND_CODE, cmd_status ); > - > - // If response has parameters, read them. > - adj_param_size = out_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - TPMTRYRETURN( buffer_init( result_param_buf, adj_param_size, NULL) ); > - size_read = read(sock_desc, result_param_buf->bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_param_buf->bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from migration server.\n"); > - goto abort_egress; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - status = TPM_IOERROR; > - goto abort_egress; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - status=TPM_SUCCESS; > - goto egress; > - > - abort_egress: > - egress: > - > - return status; > -} > - > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratorc.c b/tools/vtpm_manager/migration/vtpm_migratorc.c > deleted file mode 100644 > index 18b3bdb..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratorc.c > +++ /dev/null > @@ -1,211 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "log.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -TPM_RESULT handle_vtpm_mig_step2(char *server_addr, > - char *name, > - UINT32 instance) { > - TPM_RESULT status, cmd_status; > - buffer_t out_param_buf=NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > - UINT32 offset; > - struct pack_buf_t addr_data32; > - > - //===== Get Destination's Public Migration Key ====== > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > - > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP2, > - &out_param_buf, > - &cmd_status, > - &mig_key_buf) ); > - vtpm_migratord_close(); > - > - TPMTRYRETURN(cmd_status); > - > - //===== Load migration key into vtpm_manager ======== > - > - addr_data32.data = (BYTE *)server_addr; > - addr_data32.size = strlen(server_addr) + 1; // Include the null > - > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > - sizeof(UINT32) + addr_data32.size +buffer_len(&mig_key_buf), > - NULL ) ) ; > - > - offset = BSG_PackList(out_param_buf.bytes, 1, > - BSG_TPM_SIZE32_DATA, &addr_data32); > - > - memcpy(out_param_buf.bytes + offset , mig_key_buf.bytes, buffer_len(&mig_key_buf) ); > - > - TPMTRYRETURN ( vtpm_manager_open() ); > - > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_LOAD_MIG_KEY, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - goto egress; > - > - abort_egress: > - egress: > - > - buffer_free(&mig_key_buf); > - buffer_free(&out_param_buf); > - > - return status; > -} > - > - > -TPM_RESULT handle_vtpm_mig_step3(char *server_addr, > - char *name, > - UINT32 instance) { > - TPM_RESULT status, cmd_status; > - buffer_t out_param_buf=NULL_BUF, state_buf=NULL_BUF, empty_buf=NULL_BUF; > - struct pack_buf_t addr_data32, name_data32, state_data32; > - > - //===== Get vtpm state from vtpm_manager ======== > - addr_data32.data = (BYTE *)server_addr; > - addr_data32.size = strlen(server_addr) + 1; // Include the null > - > - TPMTRYRETURN ( buffer_init ( &out_param_buf, > - (2 * sizeof(UINT32)) + addr_data32.size, > - NULL ) ) ; > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TYPE_UINT32, &instance, > - BSG_TPM_SIZE32_DATA, &addr_data32); > - > - TPMTRYRETURN ( vtpm_manager_open() ); > - > - TPMTRYRETURN ( vtpm_manager_command(VTPM_ORD_MIGRATE_OUT, > - &out_param_buf, > - &cmd_status, > - &state_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - TPMTRYRETURN( buffer_free( &out_param_buf ) ); > - > - //===== Send vtpm state to destination ====== > - name_data32.data = (BYTE *)name; > - name_data32.size = strlen(name) + 1; // Include the null > - state_data32.data = state_buf.bytes; > - state_data32.size = buffer_len(&state_buf); > - > - TPMTRYRETURN( buffer_init( &out_param_buf, > - 2 * sizeof(UINT32) + name_data32.size + state_data32.size, > - NULL ) ) ; > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TPM_SIZE32_DATA, &name_data32, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - TPMTRYRETURN( vtpm_migratord_open(server_addr) ); > - > - TPMTRYRETURN( vtpm_migratord_command(VTPM_MORD_MIG_STEP3, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - vtpm_migratord_close(); > - > - TPMTRYRETURN(cmd_status); > - > - goto egress; > - > - abort_egress: > - egress: > - > - buffer_free( &out_param_buf); > - buffer_free( &state_buf); > - buffer_free( &empty_buf); > - > - return status; > -} > - > - > -// Usage vtpm_migrator addr domain_name instance step > - > -int main(int argc, char **argv) { > - > - /* variables for processing of command */ > - TPM_RESULT status = TPM_FAIL; > - char *server_addr, *name; > - UINT32 instance, step; > - > - if (argc != 5) { > - vtpmlogerror(VTPM_LOG_VTPM, "Usage: vtpm_migrator addr vm_name instance step\n"); > - vtpmlogerror(VTPM_LOG_VTPM, " params given %d\n", argc); > - status= TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - server_addr = argv[1]; > - name = argv[2]; > - instance = atoi( argv[3] ); > - step = atoi( argv[4] ); > - > - switch (step) { > - case VTPM_MORD_MIG_STEP2: > - status = handle_vtpm_mig_step2(server_addr, name, instance); > - break; > - > - case VTPM_MORD_MIG_STEP3: > - status = handle_vtpm_mig_step3(server_addr, name, instance); > - break; > - > - default: > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - break; > - } > - > - goto egress; > - abort_egress: > - egress: > - > - return status; > -} > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratord.c b/tools/vtpm_manager/migration/vtpm_migratord.c > deleted file mode 100644 > index ea18c8c..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratord.c > +++ /dev/null > @@ -1,202 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "log.h" > -#include "bsg.h" > -#include "buffer.h" > -#include "vtpm_migrator.h" > - > -void build_error_msg( buffer_t *buf, TPM_RESULT status) { > - TPM_TAG tag = VTPM_MTAG_RSP; > - UINT32 out_param_size = VTPM_COMMAND_HEADER_SIZE; > - > - buffer_init(buf, out_param_size, NULL); > - > - BSG_PackList(buf->bytes, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_RESULT, &status ); > -} > - > -int main() { > - > - /* network variables */ > - int sock_descr, client_sock=-1, len; > - struct sockaddr_in addr; > - struct sockaddr_in client_addr; > - unsigned int client_length; > - int bytes; > - > - /* variables for processing of command */ > - TPM_RESULT status = TPM_FAIL; > - BYTE cmd_header[VTPM_COMMAND_HEADER_SIZE]; > - TPM_TAG tag; > - TPM_COMMAND_CODE ord; > - UINT32 in_param_size, adj_param_size; > - int i, size_read, size_write; > - buffer_t in_param_buf=NULL_BUF, result_buf=NULL_BUF; > - > - > - /* setup socket */ > - sock_descr = socket(AF_INET, SOCK_STREAM, 0); > - > - memset(&addr, 0, sizeof(addr)); > - addr.sin_family = AF_INET; > - addr.sin_addr.s_addr = htonl(INADDR_ANY); > - addr.sin_port = htons(VTPM_MIG_PORT); > - > - if (bind(sock_descr, (struct sockaddr *)&addr, sizeof(addr)) == -1 ) { > - vtpmlogerror(VTPM_LOG_VTPM, "Failed to bind to port %d.\n", VTPM_MIG_PORT); > - return 1; > - } > - > - listen(sock_descr, 10); > - > - for(;;) { > - // ============ clear client info and wait for connection ========== > - memset(&client_addr, 0, sizeof(client_addr)); > - client_length = sizeof(client_addr); > - > - vtpmloginfo(VTPM_LOG_VTPM, "Waiting for incoming migrations...\n"); > - client_sock=accept(sock_descr, &client_addr, &client_length); > - if (client_sock == -1) { > - vtpmlogerror(VTPM_LOG_VTPM, "Incoming connectionn failed.\n"); > - goto abort_command; > - } else { > - vtpmloginfo(VTPM_LOG_VTPM, "Incoming connection accepted.\n"); > - } > - > - // =================== Read incoming command ====================== > - size_read = read( client_sock, cmd_header, VTPM_COMMAND_HEADER_SIZE); > - if (size_read > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "RECV: 0x"); > - for (i=0; i - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cmd_header[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > - build_error_msg(&result_buf, TPM_IOERROR); > - goto abort_command_with_error; > - } > - > - if (size_read < (int) VTPM_COMMAND_HEADER_SIZE) { > - vtpmlogerror(VTPM_LOG_VTPM, "Command from socket shorter than std header.\n"); > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - > - // Unpack response from client > - BSG_UnpackList(cmd_header, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &in_param_size, > - BSG_TPM_COMMAND_CODE, &ord ); > - > - > - // If response has parameters, read them. > - // Note that out_param_size is in the client's context > - adj_param_size = in_param_size - VTPM_COMMAND_HEADER_SIZE; > - if (adj_param_size > 0) { > - buffer_init( &in_param_buf, adj_param_size, NULL); > - size_read = read(client_sock, in_param_buf.bytes, adj_param_size); > - if (size_read > 0) { > - for (i=0; i< size_read; i++) > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", in_param_buf.bytes[i]); > - > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error reading from socket.\n"); > - build_error_msg(&result_buf, TPM_IOERROR); > - goto abort_command_with_error; > - } > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - > - if (size_read < (int)adj_param_size) { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - vtpmlogerror(VTPM_LOG_VTPM, "Command read(%d) is shorter than header indicates(%d).\n", size_read, adj_param_size); > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - } else { > - vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > - } > - > - /* Handle Command */ > - switch (ord) { > - case VTPM_MORD_MIG_STEP2: > - handle_vtpm_mig_step2(&in_param_buf, &result_buf); > - break; > - > - case VTPM_MORD_MIG_STEP3: > - handle_vtpm_mig_step3(&in_param_buf, &result_buf); > - break; > - > - default: > - build_error_msg(&result_buf, TPM_BAD_PARAMETER); > - goto abort_command_with_error; > - } > - > - abort_command_with_error: > - /* Write Response */ > - size_write = write(client_sock, result_buf.bytes, buffer_len(&result_buf)); > - > - if (size_write > 0) { > - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); > - for (i=0; i< buffer_len(&result_buf); i++) { > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", result_buf.bytes[i]); > - } > - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); > - } else { > - vtpmlogerror(VTPM_LOG_VTPM, "Error writing response to client.\n"); > - goto abort_command; > - } > - > - if (size_write != (int) buffer_len(&result_buf) ) > - vtpmlogerror(VTPM_LOG_VTPM, "Could not send entire response to client(%d/%d)\n", size_write, buffer_len(&result_buf)); > - > - abort_command: > - close(client_sock); > - buffer_free(&in_param_buf); > - buffer_free(&result_buf); > - > - } // For (;;) > - > - return 0; > -} > - > diff --git a/tools/vtpm_manager/migration/vtpm_migratord_handler.c b/tools/vtpm_manager/migration/vtpm_migratord_handler.c > deleted file mode 100644 > index 0a8a2d5..0000000 > --- a/tools/vtpm_manager/migration/vtpm_migratord_handler.c > +++ /dev/null > @@ -1,177 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "log.h" > -#include "vtpm_migrator.h" > -#include "vtpm_manager.h" > - > -#define VTPM_SH_CMD_HDR "bash -c \"cd /etc/xen/scripts; source /etc/xen/scripts/vtpm-common.sh;" > -#define VTPM_SH_CMD_FTR "\"" > -#define VTPM_SH_GETINST "vtpmdb_get_free_instancenum" > -#define VTPM_SH_ADD "vtpm_add_and_activate" > -#define VTPM_SH_RESUME "vtpm_resume" > - > -// This must be updated to the longest command name. Currently GETINST > -#define VTPM_SH_CMD_SIZE (strlen(VTPM_SH_CMD_HDR) + strlen(VTPM_SH_CMD_FTR) + 1 + strlen(VTPM_SH_GETINST) + 2) > - > -void handle_vtpm_mig_step2(buffer_t *in_param_buf, buffer_t *result_buf) > -{ > - TPM_TAG tag = VTPM_TAG_RSP; > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF; > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > - UINT32 out_param_size; > - > - if ( (!in_param_buf) || (!result_buf) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // ================= Call manager and get mig key =============== > - TPMTRYRETURN( vtpm_manager_open() ); > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_GET_MIG_KEY, > - &out_param_buf, // Empty > - &cmd_status, > - &mig_key_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - // ==================== return the mig key ===================== > - out_param_size = VTPM_COMMAND_HEADER_SIZE + buffer_len(&mig_key_buf); > - > - TPMTRYRETURN( buffer_init(result_buf, > - out_param_size, > - NULL) ); > - > - BSG_PackList( result_buf->bytes, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, &out_param_size, > - BSG_TPM_RESULT, &status); > - > - memcpy(result_buf->bytes + VTPM_COMMAND_HEADER_SIZE, > - mig_key_buf.bytes, buffer_len(&mig_key_buf)); > - > - goto egress; > - > - abort_egress: > - buffer_free(result_buf); > - build_error_msg(result_buf, status); > - > - egress: > - return; > -} > - > -void handle_vtpm_mig_step3(buffer_t *in_param_buf, buffer_t *result_buf) > -{ > - TPM_TAG tag = VTPM_TAG_RSP; > - buffer_t out_param_buf= NULL_BUF, mig_key_buf=NULL_BUF, empty_buf=NULL_BUF; > - TPM_RESULT status=TPM_SUCCESS, cmd_status; > - UINT32 out_param_size, instance; > - char *shell_cmd_str=NULL; > - size_t shell_cmd_strlen; > - FILE *shell_f=NULL; > - > - if ( (!in_param_buf) || (!result_buf) ) { > - status = TPM_BAD_PARAMETER; > - goto abort_egress; > - } > - > - // ================= Read Parameters =============== > - struct pack_buf_t name_data32, state_data32; > - > - BSG_UnpackList(in_param_buf->bytes, 2, > - BSG_TPM_SIZE32_DATA, &name_data32, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - // Before using this string, protect us from a non-null term array. > - if (name_data32.data[name_data32.size -1] != 0x00) { > - name_data32.data[name_data32.size -1] = 0x00; > - } > - > - // ====== Call hotplug-script and get an instance ====== > - shell_cmd_strlen = VTPM_SH_CMD_SIZE + name_data32.size + 10; > - shell_cmd_str = (char *) malloc(shell_cmd_strlen); // 10 is just padding for the UINT32 > - > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_GETINST VTPM_SH_CMD_FTR); > - > - shell_f = popen(shell_cmd_str, "r"); > - fscanf(shell_f, "%d", &instance); > - pclose(shell_f); > - > - // ====== Call hotplug-script and add instance ====== > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_ADD " %s %d" VTPM_SH_CMD_FTR, > - name_data32.data, instance); > - system(shell_cmd_str); > - > - // ========= Call vtpm_manager and load VTPM ======= > - TPMTRYRETURN( buffer_init( &out_param_buf, > - 2*sizeof(UINT32) + state_data32.size, > - NULL) ); > - > - BSG_PackList(out_param_buf.bytes, 2, > - BSG_TYPE_UINT32, &instance, > - BSG_TPM_SIZE32_DATA, &state_data32); > - > - TPMTRYRETURN( vtpm_manager_open() ); > - TPMTRYRETURN( vtpm_manager_command(VTPM_ORD_MIGRATE_IN, > - &out_param_buf, > - &cmd_status, > - &empty_buf) ); > - > - vtpm_manager_close(); > - > - TPMTRYRETURN(cmd_status); > - > - // ====== Call hotplug-script and resume instance ====== > - snprintf(shell_cmd_str, shell_cmd_strlen, > - VTPM_SH_CMD_HDR VTPM_SH_RESUME " %d" VTPM_SH_CMD_FTR, instance); > - system(shell_cmd_str); > - > - goto egress; > - abort_egress: > - egress: > - free(shell_cmd_str); > - > - // In this case no params come back, so reuse build_error_msg even for succes. > - build_error_msg(result_buf, status); > - return; > -} > - > diff --git a/tools/vtpm_manager/tcs/Makefile b/tools/vtpm_manager/tcs/Makefile > deleted file mode 100644 > index 11af91e..0000000 > --- a/tools/vtpm_manager/tcs/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libTCS.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/tcs/contextmgr.c b/tools/vtpm_manager/tcs/contextmgr.c > deleted file mode 100644 > index cf3803c..0000000 > --- a/tools/vtpm_manager/tcs/contextmgr.c > +++ /dev/null > @@ -1,224 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// contextmgr.c > -// > -// This file contains the context management functions for TCS. > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include "tcs.h" > -#include "contextmgr.h" > -#include "log.h" > -#include "hashtable.h" > - > -BYTE* AddMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - int BlockSize) { // in > - > - BLOCK* pCurrentBlock = NULL; > - BLOCK* pBlock = NULL; > - > - // check incoming params > - if (pContextHandle == NULL || BlockSize == 0) > - return NULL; > - > - // Create New Block > - pBlock = (BLOCK *)malloc(sizeof(BLOCK)); > - if (pBlock == NULL) > - return (0); > - > - pBlock->aMemory = (BYTE *)malloc(sizeof(BYTE) * BlockSize); > - if (pBlock->aMemory == NULL) > - return (0); > - > - memset(pBlock->aMemory, 0, BlockSize); > - pBlock->nBlockSize = BlockSize; > - pBlock->pNextBlock = NULL; > - > - // search for the last block created where to add the > - // newly created block > - if(pContextHandle->pTopBlock != NULL) { > - pCurrentBlock = pContextHandle->pTopBlock; > - while(pCurrentBlock->pNextBlock != NULL) > - pCurrentBlock = pCurrentBlock->pNextBlock; > - > - > - pCurrentBlock->pNextBlock= pBlock; > - } else > - pContextHandle->pTopBlock = pBlock; > - > - > - pContextHandle->nBlockCount++; > - > - return pBlock->aMemory; > -} > - > - > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - BYTE* pTCPA_BYTEs) { // in > - BLOCK* pCurrentBlock = NULL; > - BLOCK* pParentBlock = NULL; > - BOOL bFound = FALSE; > - > - if (pContextHandle == NULL) > - return FALSE; > - > - > - // Search for the Block in the context by aMemory pointer > - pParentBlock = NULL; > - pCurrentBlock = pContextHandle->pTopBlock; > - > - while(pCurrentBlock != NULL) { > - // If aMemory block is found, delete it > - if(pCurrentBlock->aMemory == pTCPA_BYTEs || pTCPA_BYTEs == NULL) { > - // if it is the top Block, remove it from the top, > - // otherwise remove it from the ParentBlock and stitch > - // the NextBlock to the ParentBlock > - if(pParentBlock == NULL) > - pContextHandle->pTopBlock = pContextHandle->pTopBlock->pNextBlock; > - else > - pParentBlock->pNextBlock = pCurrentBlock->pNextBlock; > - > - // delete memory Block associated with pointer pTCPA_BYTEs > - free(pCurrentBlock->aMemory); > - pCurrentBlock->aMemory = NULL; > - > - free(pCurrentBlock); > - pCurrentBlock = pParentBlock; > - > - pContextHandle->nBlockCount--; > - bFound = TRUE; > - } > - > - if(pCurrentBlock != NULL) { > - pParentBlock = pCurrentBlock; > - pCurrentBlock = pCurrentBlock->pNextBlock; > - } > - } > - > - return bFound; > -} > - > -BOOL AddHandleToList(TCS_CONTEXT_HANDLE hContext, // in > - TPM_RESOURCE_TYPE type, // in > - TPM_HANDLE handle) { // in > - HANDLE_LIST* pNewHandle = NULL; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Adding Handle to list\n"); > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if (pContextHandle == NULL) > - return 0; > - > - pNewHandle = (HANDLE_LIST *)malloc(sizeof(HANDLE_LIST)); > - > - if (pNewHandle == NULL) > - return (0); > - > - pNewHandle->handle = handle; > - pNewHandle->type = type; > - pNewHandle->pNextHandle = pContextHandle->pHandleList; > - > - pContextHandle->pHandleList = pNewHandle; > - > - return 1; > -} > - > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_HANDLE handle) { // in > - > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - HANDLE_LIST *pCurrentHandle = pContextHandle->pHandleList, > - *pLastHandle = pCurrentHandle; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Deleting Handle from list\n"); > - > - if (pContextHandle == NULL) > - return 0; > - > - while (1) { > - > - if (pCurrentHandle->handle == handle) { // Found element > - if (pCurrentHandle == pLastHandle) { // First element in list > - pContextHandle->pHandleList = pCurrentHandle->pNextHandle; > - free(pCurrentHandle); > - } else { // Ordinary element > - pLastHandle->pNextHandle = pCurrentHandle->pNextHandle; > - free(pCurrentHandle); > - } > - > - return 1; > - > - } else { // Not found yet; > - pLastHandle = pCurrentHandle; > - pCurrentHandle = pCurrentHandle->pNextHandle; > - if (pCurrentHandle == NULL) // Found end of list > - return 0; > - } > - > - } > -} > - > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle) { // in > - HANDLE_LIST* pCurrentHandle; > - BOOL returncode = TRUE; > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Freeing all handles for context\n"); > - > - if (pContextHandle == NULL) > - return 1; > - > - pCurrentHandle = pContextHandle->pHandleList; > - while (pCurrentHandle != NULL) { > - > - switch (pCurrentHandle->type) { > - case TPM_RT_KEY: > - returncode = returncode && !TCSP_EvictKey(pContextHandle->handle, pCurrentHandle->handle); > - break; > - case TPM_RT_AUTH: > - returncode = returncode && !TCSP_TerminateHandle(pContextHandle->handle, pCurrentHandle->handle); > - break; > - default: > - returncode = FALSE; > - } > - > - pCurrentHandle = pCurrentHandle->pNextHandle; > - > - } > - > - return 1; > -} > diff --git a/tools/vtpm_manager/tcs/contextmgr.h b/tools/vtpm_manager/tcs/contextmgr.h > deleted file mode 100644 > index e3fdf0f..0000000 > --- a/tools/vtpm_manager/tcs/contextmgr.h > +++ /dev/null > @@ -1,82 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// contextmgr.c > -// > -// This file contains the context management functions for TCS. > -// > -// ================================================================== > - > -#ifndef __CONTEXTMGR_H__ > -#define __CONTEXTMGR_H__ > - > -#include "tcg.h" > - > -#define BLOCK_SIZE 300 > - > -typedef struct block { > - int nBlockSize; > - BYTE* aMemory; > - struct block* pNextBlock; > -} BLOCK; > - > -typedef struct handle_List { > - TPM_HANDLE handle; > - TPM_RESOURCE_TYPE type; > - struct handle_List* pNextHandle; > -} HANDLE_LIST; > - > -typedef struct context_handle { > - TCS_CONTEXT_HANDLE handle; > - int nBlockCount; > - BLOCK* pTopBlock; > - HANDLE_LIST* pHandleList; > -} CONTEXT_HANDLE; > - > -BYTE* AddMemBlock( CONTEXT_HANDLE* pContextHandle, // in > - int BlockSize); // in > - > -BOOL DeleteMemBlock(CONTEXT_HANDLE* pContextHandle, // in > - BYTE* pTCPA_BYTEs); // in > - > - > -BOOL AddHandleToList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_RESOURCE_TYPE type, // in > - TPM_HANDLE handle); // in > - > -BOOL DeleteHandleFromList( TCS_CONTEXT_HANDLE hContext, // in > - TPM_HANDLE handle); // in > - > -BOOL FreeHandleList( CONTEXT_HANDLE* pContextHandle); // in > - > -#endif //_CONTEXTMGR_H_ > diff --git a/tools/vtpm_manager/tcs/tcs.c b/tools/vtpm_manager/tcs/tcs.c > deleted file mode 100644 > index 7c1378c..0000000 > --- a/tools/vtpm_manager/tcs/tcs.c > +++ /dev/null > @@ -1,1192 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcs.c > -// > -// This file contains the functions that implement a TCS. > -// > -// ================================================================== > - > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "tcs.h" > -#include "contextmgr.h" > -#include "tpmddl.h" > -#include "log.h" > -#include "hashtable.h" > -#include "hashtable_itr.h" > - > -// Static Global Vars for the TCS > -static int TCS_m_nCount = 0; > - > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > - > -static BYTE InBuf [TCPA_MAX_BUFFER_LENGTH]; > -static BYTE OutBuf[TCPA_MAX_BUFFER_LENGTH]; > - > -struct hashtable *context_ht; > - > -// -------------------------- Hash table functions -------------------- > - > -static unsigned int hashfunc32(void *ky) { > - return (* (UINT32 *) ky); > -} > - > -static int equals32(void *k1, void *k2) { > - return (*(UINT32 *) k1 == *(UINT32 *) k2); > -} > - > -CONTEXT_HANDLE *LookupContext( TCS_CONTEXT_HANDLE hContext) { > - return( (CONTEXT_HANDLE *) hashtable_search(context_ht, &hContext) ); > -} > - > -// --------------------------------------------------------------------------------- > -// Initialization/Uninitialization SubComponent API > -// --------------------------------------------------------------------------------- > -TPM_RESULT TCS_create() { > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TPM_RESULT result = TPM_FAIL; > - > - if (TCS_m_nCount == 0) { > - vtpmloginfo(VTPM_LOG_TCS, "Constructing new TCS:\n"); > - hRes = TDDL_Open(); > - > - context_ht = create_hashtable(10, hashfunc32, equals32); > - > - if ((hRes == TDDL_SUCCESS) && (context_ht != NULL)) { > - result = TPM_SUCCESS; > - TCS_m_nCount++; > - } else { > - result = TPM_IOERROR; > - hashtable_destroy(context_ht, 1); > - } > - } else > - TCS_m_nCount++; > - > - return(result); > -} > - > - > -void TCS_destroy() > -{ > - TCS_m_nCount--; > - > - if (TCS_m_nCount == 0) { > - vtpmloginfo(VTPM_LOG_TCS, "Destructing TCS:\n"); > - TDDL_Close(); > - > - struct hashtable_itr *context_itr; > - TCS_CONTEXT_HANDLE *hContext; > - > - // Close all the TCS contexts. TCS should evict keys based on this > - if (hashtable_count(context_ht) > 0) { > - context_itr = hashtable_iterator(context_ht); > - do { > - hContext = (TCS_CONTEXT_HANDLE *) hashtable_iterator_key(context_itr); > - if (TCS_CloseContext(*hContext) != TPM_SUCCESS) > - vtpmlogerror(VTPM_LOG_TCS, "Failed to close context %d properly.\n", *hContext); > - > - } while (hashtable_iterator_advance(context_itr)); > - free(context_itr); > - } > - hashtable_destroy(context_ht, 1); > - } > - > -} > - > -TPM_RESULT TCS_Malloc( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 MemSize, // in > - BYTE** ppMemPtr) {// out > - > - TPM_RESULT returnCode = TPM_FAIL; > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if (pContextHandle != NULL && ppMemPtr != NULL) { > - *ppMemPtr = (BYTE *)AddMemBlock(pContextHandle, MemSize); > - returnCode = TPM_SUCCESS; > - } > - > - return returnCode; > -} > - > -TPM_RESULT TCS_FreeMemory( TCS_CONTEXT_HANDLE hContext, // in > - BYTE* pMemory) { // in > - TPM_RESULT returnCode = TPM_FAIL; > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if ( (pContextHandle != NULL && pMemory != NULL) && > - (DeleteMemBlock(pContextHandle, pMemory) == TRUE) ) > - returnCode = TPM_SUCCESS; > - > - > - return returnCode; > -} > - > -TPM_RESULT TCS_OpenContext(TCS_CONTEXT_HANDLE* hContext) { // out > - TPM_RESULT returnCode = TPM_FAIL; > - TCS_CONTEXT_HANDLE *newContext; > - > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_OpenContext:\n"); > - > - if (hContext) { > - CONTEXT_HANDLE* pContextHandle = (CONTEXT_HANDLE *) malloc(sizeof(CONTEXT_HANDLE)); > - if (pContextHandle == NULL) > - return TPM_SIZE; > - > - // initialize to 0 > - pContextHandle->nBlockCount = 0; > - pContextHandle->pTopBlock = NULL; > - pContextHandle->pHandleList = NULL; > - > - // Create New Block > - AddMemBlock(pContextHandle, BLOCK_SIZE); > - > - newContext = (TCS_CONTEXT_HANDLE *) malloc(sizeof(TCS_CONTEXT_HANDLE)); > - *newContext = (TCS_CONTEXT_HANDLE) (((uintptr_t) pContextHandle >> 2) & 0xffffffff); > - > - if (hashtable_search(context_ht, &newContext) !=NULL) > - *newContext += 1; > - > - pContextHandle->handle = *newContext; > - if (!hashtable_insert(context_ht, newContext, pContextHandle)) { > - free(newContext); > - free(pContextHandle); > - returnCode = TPM_FAIL; > - } else { > - *hContext = *newContext; > - returnCode = TPM_SUCCESS; > - } > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCS_CloseContext(TCS_CONTEXT_HANDLE hContext) {// in > - //FIXME: TCS SHOULD Track failed auths and make sure > - //we don't try and re-free them here. > - TPM_RESULT returnCode = TPM_FAIL; > - > - CONTEXT_HANDLE* pContextHandle = LookupContext(hContext); > - > - if(pContextHandle != NULL) { > - // Print test info > - vtpmloginfo(VTPM_LOG_TCS, "Calling TCS_CloseContext.\n"); > - > - // free memory for all the blocks > - DeleteMemBlock(pContextHandle, NULL ); > - pContextHandle->pTopBlock = NULL; > - > - FreeHandleList(pContextHandle); > - if (pContextHandle->pHandleList != NULL) > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > - > - // Release the TPM's resources > - if (hashtable_remove(context_ht, &hContext) == NULL) > - vtpmlogerror(VTPM_LOG_TCS, "Not all handles evicted from TPM.\n"); > - > - free(pContextHandle); > - returnCode = TPM_SUCCESS; > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Finished closing context\n"); > - return(returnCode); > -} > - > -// ------------------------------------------------------------------ > -// Internal Functions > -// ------------------------------------------------------------------ > -int packAuth(BYTE* dst, TCS_AUTH* auth) { > - // CHECK: according to the command specs, the outgoing auth params are: > - // nonceEven > - // nonceOdd > - // continueAuthSession > - // auth digest for return params > - // > - // this is a bit different than this code... > - > - return BSG_PackList(dst, 4, > - BSG_TYPE_UINT32, &(auth->AuthHandle), > - BSG_TPM_NONCE, &(auth->NonceOdd), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > -} > - > -int unpackAuth(TCS_AUTH* auth, BYTE* src) { > - return BSG_UnpackList(src, 3, > - BSG_TPM_NONCE, &(auth->NonceEven), > - BSG_TYPE_BOOL, &(auth->fContinueAuthSession), > - BSG_TPM_AUTHDATA, &(auth->HMAC)); > -} > - > -// ------------------------------------------------------------------ > -// Authorization Commands > -// ------------------------------------------------------------------ > - > -TPM_RESULT TCSP_OIAP(TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonce0) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - TPM_COMMAND_CODE ordinal = TPM_ORD_OIAP; > - UINT32 paramSize = 0; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (authHandle == NULL || nonce0 == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_UnpackList(OutBuf+i, 2, > - BSG_TYPE_UINT32, authHandle, > - BSG_TPM_NONCE, nonce0); > - > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_OSAP(TCS_CONTEXT_HANDLE hContext, // in > - TPM_ENTITY_TYPE entityType, // in > - UINT32 entityValue, // in > - TPM_NONCE nonceOddOSAP, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonceEven, // out > - TPM_NONCE* nonceEvenOSAP) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_OSAP; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (authHandle == NULL || nonceEven == NULL || nonceEvenOSAP == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT16, &entityType, > - BSG_TYPE_UINT32, &entityValue, > - BSG_TPM_NONCE, &nonceOddOSAP); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_UnpackList(OutBuf+i, 3, > - BSG_TYPE_UINT32, authHandle, > - BSG_TPM_NONCE, nonceEven, > - BSG_TPM_NONCE, nonceEvenOSAP); > - > - if (!AddHandleToList(hContext, TPM_RT_AUTH, *authHandle)) { > - vtpmlogerror(VTPM_LOG_TCS, "New AuthHandle not recorded\n"); > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_TakeOwnership(TCS_CONTEXT_HANDLE hContext, // in > - UINT16 protocolID, // in > - UINT32 encOwnerAuthSize, // in > - BYTE* encOwnerAuth, // in > - UINT32 encSrkAuthSize, // in > - BYTE* encSrkAuth, // in > - UINT32* SrkSize, // in, out > - BYTE** Srk, // in, out > - TCS_AUTH* ownerAuth) // in, out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_TakeOwnership; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (encOwnerAuth == NULL || encSrkAuth == NULL || SrkSize == NULL || *Srk == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT16, &protocolID, > - BSG_TYPE_UINT32, &encOwnerAuthSize); > - > - memcpy(InBuf+InLength, encOwnerAuth, encOwnerAuthSize); > - InLength += encOwnerAuthSize; > - InLength += BSG_Pack( BSG_TYPE_UINT32, > - &encSrkAuthSize, > - InBuf+InLength); > - memcpy(InBuf+InLength, encSrkAuth, encSrkAuthSize); > - InLength += encSrkAuthSize; > - memcpy(InBuf+InLength, *Srk, *SrkSize); > - InLength += *SrkSize; > - InLength += packAuth(InBuf+InLength, ownerAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, > - &InLength, > - InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS){ > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_KEY srkPub; > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &srkPub); > - unpackAuth(ownerAuth, OutBuf+i); > - > - // fill output params > - BYTE tempBuf[1024]; > - *SrkSize = BSG_Pack(BSG_TPM_KEY, &srkPub, tempBuf); > - if (TCS_Malloc(hContext, *SrkSize, Srk) == TPM_FAIL) { > - return(TPM_SIZE); > - } > - memcpy(*Srk, tempBuf, *SrkSize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TakeOwnership Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTH* ownerAuth) { // in, out > - > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_DisablePubekRead; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - > - InLength += packAuth(InBuf+InLength, ownerAuth); > - > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS){ > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - unpackAuth(ownerAuth, OutBuf+i); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_DisablePubekRead Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_TerminateHandle(TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Terminate_Handle; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &handle); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (!DeleteHandleFromList(hContext, handle)) > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > - > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Print debug info > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_TerminateHandle Failed with return code %s\n", tpm_get_error_name(returnCode)); > - > - } > - > - return(returnCode); > -} > - > -// TPM Mandatory > -TPM_RESULT TCSP_Extend( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_DIGEST inDigest, // in > - TPM_PCRVALUE* outDigest) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Extend; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &pcrNum, > - BSG_TPM_DIGEST, &inDigest); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - > - // unpack to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND){ > - // Extract the remaining output parameters > - BSG_Unpack(BSG_TPM_PCRVALUE, OutBuf+i, outDigest); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Extend Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_Seal( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_ENCAUTH encAuth, // in > - UINT32 pcrInfoSize, // in > - BYTE* PcrInfo, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* pubAuth, // in, out > - UINT32* SealedDataSize, // out > - BYTE** SealedData) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Seal; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (inData == NULL || pubAuth == NULL || SealedDataSize == NULL || SealedData == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &keyHandle, > - BSG_TPM_ENCAUTH, encAuth, > - BSG_TYPE_UINT32, &pcrInfoSize); > - memcpy(InBuf+InLength, PcrInfo, pcrInfoSize); > - InLength += pcrInfoSize; > - InLength += BSG_Pack(BSG_TYPE_UINT32, &inDataSize, InBuf+InLength); > - memcpy(InBuf+InLength, inData, inDataSize); > - InLength += inDataSize; > - InLength += packAuth(InBuf+InLength, pubAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) > - == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_STORED_DATA sealedData; > - > - i += BSG_Unpack(BSG_TPM_STORED_DATA, OutBuf+i, &sealedData); > - unpackAuth(pubAuth, OutBuf+i); > - > - // fill SealedData > - BYTE tempBuf[1024]; > - *SealedDataSize = BSG_Pack(BSG_TPM_STORED_DATA, &sealedData, tempBuf); > - if (TCS_Malloc(hContext, *SealedDataSize, SealedData) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*SealedData, tempBuf, *SealedDataSize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Seal Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_Unseal(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE parentHandle, // in > - UINT32 SealedDataSize, // in > - BYTE* SealedData, // in > - TCS_AUTH* parentAuth, // in, out > - TCS_AUTH* dataAuth, // in, out > - UINT32* DataSize, // out > - BYTE** Data) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH2_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_Unseal; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (SealedData == NULL || parentAuth == NULL || dataAuth == NULL || > - DataSize == NULL || Data == NULL) > - return TPM_BAD_PARAMETER; > - > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &parentHandle); > - memcpy(InBuf+InLength, SealedData, SealedDataSize); > - InLength += SealedDataSize; > - InLength += packAuth(InBuf+InLength, parentAuth); > - InLength += packAuth(InBuf+InLength, dataAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList( OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH2_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, DataSize); > - if (TCS_Malloc(hContext, *DataSize, Data) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*Data, OutBuf+i, *DataSize); > - i += *DataSize; > - i += unpackAuth(parentAuth, OutBuf+i); > - unpackAuth(dataAuth, OutBuf+i); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_Unseal Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_UnBind(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* outDataSize, // out > - BYTE** outData) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_UnBind; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (inData == NULL || privAuth == NULL || outDataSize == NULL || outData == NULL) > - return TPM_BAD_PARAMETER; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 5, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &keyHandle, > - BSG_TYPE_UINT32, &inDataSize); > - memcpy(InBuf+InLength, inData, inDataSize); > - InLength += inDataSize; > - InLength += packAuth(InBuf+InLength, privAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "\n\tSending paramSize = %d", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, outDataSize); > - if (TCS_Malloc(hContext, *outDataSize, outData) == TPM_FAIL) > - return TPM_SIZE; > - > - memcpy(*outData, OutBuf+i, *outDataSize); > - i += *outDataSize; > - unpackAuth(privAuth, OutBuf+i); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_UnBind Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_CreateWrapKey(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hWrappingKey, // in > - TPM_ENCAUTH KeyUsageAuth, // in > - TPM_ENCAUTH KeyMigrationAuth, // in > - UINT32* pcKeySize, // in, out > - BYTE** prgbKey, // in, out > - TCS_AUTH* pAuth) // in, out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_CreateWrapKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (pcKeySize == NULL || *prgbKey == NULL || pAuth == NULL) > - return TPM_BAD_PARAMETER; > - > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 6, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hWrappingKey, > - BSG_TPM_ENCAUTH, KeyUsageAuth, > - BSG_TPM_ENCAUTH, KeyMigrationAuth); > - memcpy(InBuf+InLength, *prgbKey, *pcKeySize); > - InLength += *pcKeySize; > - InLength += packAuth(InBuf+InLength, pAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_RESULT, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - TPM_KEY wrappedKey; > - > - i += BSG_Unpack(BSG_TPM_KEY, OutBuf+i, &wrappedKey); > - unpackAuth(pAuth, OutBuf+i); > - > - // Fill prgbKey > - BYTE tempBuf[1024]; > - *pcKeySize = BSG_Pack(BSG_TPM_KEY, &wrappedKey, tempBuf); > - if (TCS_Malloc(hContext, *pcKeySize, prgbKey) == TPM_FAIL) > - return TPM_SIZE; > - > - memcpy(*prgbKey, tempBuf, *pcKeySize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_CreateWrapKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_LoadKeyByBlob(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hUnwrappingKey, // in > - UINT32 cWrappedKeyBlobSize, // in > - BYTE* rgbWrappedKeyBlob, // in > - TCS_AUTH* pAuth, // in, out > - TCS_KEY_HANDLE* phKeyTCSI, // out > - TCS_KEY_HANDLE* phKeyHMAC) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_AUTH1_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_LoadKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (rgbWrappedKeyBlob == NULL || pAuth == NULL || phKeyTCSI == NULL || phKeyHMAC == NULL) > - return TPM_BAD_PARAMETER; > - > - *phKeyHMAC = hUnwrappingKey; // the parent key is the one that the TPM use to make the HMAC calc > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hUnwrappingKey); > - memcpy(InBuf+InLength, rgbWrappedKeyBlob, cWrappedKeyBlobSize); > - InLength += cWrappedKeyBlobSize; > - InLength += packAuth(InBuf+InLength, pAuth); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_AUTH1_COMMAND) { > - // Extract the remaining output parameters > - i += BSG_Unpack(BSG_TYPE_UINT32, > - OutBuf+i, > - phKeyTCSI); > - unpackAuth(pAuth, OutBuf+i); > - > - if (!AddHandleToList(hContext, TPM_RT_KEY, *phKeyTCSI)) { > - vtpmlogerror(VTPM_LOG_TCS, "New KeyHandle not recorded\n"); > - } > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_LoadKeyByBlob Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_EvictKey(TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_EvictKey; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, &hKey); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (!DeleteHandleFromList(hContext, hKey)) { > - vtpmlogerror(VTPM_LOG_TCS, "KeyHandle not removed from list\n"); > - } > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_EvictKey Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > -TPM_RESULT TCSP_GetRandom(TCS_CONTEXT_HANDLE hContext, // in > - UINT32* bytesRequested, // in, out > - BYTE** randomBytes) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_GetRandom; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (bytesRequested == NULL || *randomBytes == NULL){ > - return TPM_BAD_PARAMETER; > - } > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TYPE_UINT32, bytesRequested); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - BSG_Unpack(BSG_TYPE_UINT32, OutBuf+i, bytesRequested); > - if (TCS_Malloc(hContext, *bytesRequested, randomBytes) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*randomBytes, OutBuf+i+sizeof(UINT32), *bytesRequested); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_GetRandom Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_ReadPubek(TCS_CONTEXT_HANDLE hContext, // in > - TPM_NONCE antiReplay, // in > - UINT32* pubEndorsementKeySize, // out > - BYTE** pubEndorsementKey, // out > - TPM_DIGEST* checksum) // out > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_ReadPubek; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // check input params > - if (pubEndorsementKeySize == NULL || pubEndorsementKey == NULL || checksum == NULL) { > - return TPM_BAD_PARAMETER; > - } > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 4, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal, > - BSG_TPM_NONCE, &antiReplay); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - int i = BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - // Extract the remaining output parameters > - TPM_PUBKEY pubEK; > - i += BSG_UnpackList(OutBuf+i, 2, > - BSG_TPM_PUBKEY, &pubEK, > - BSG_TPM_DIGEST, checksum); > - > - // fill EndorsementKey > - BYTE tempBuf[1024]; > - *pubEndorsementKeySize = BSG_Pack(BSG_TPM_PUBKEY, &pubEK, tempBuf); > - if (TCS_Malloc(hContext, *pubEndorsementKeySize, pubEndorsementKey) == TPM_FAIL) { > - return TPM_SIZE; > - } > - memcpy(*pubEndorsementKey, tempBuf, *pubEndorsementKeySize); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_ReadPubek Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext) // in > -{ > - // setup input/output parameters block > - TPM_TAG tag = TPM_TAG_RQU_COMMAND; > - UINT32 paramSize = 0; > - TPM_COMMAND_CODE ordinal = TPM_ORD_SaveState; > - TPM_RESULT returnCode = TPM_SUCCESS; > - > - // setup the TPM driver input and output buffers > - TDDL_RESULT hRes = TDDL_E_FAIL; > - TDDL_UINT32 InLength = TCPA_MAX_BUFFER_LENGTH; > - TDDL_UINT32 OutLength = TCPA_MAX_BUFFER_LENGTH; > - > - // Convert Byte Input parameter in the input byte stream InBuf > - InLength = BSG_PackList(InBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &ordinal); > - // fill paramSize again as we now have the correct size > - BSG_Pack(BSG_TYPE_UINT32, &InLength, InBuf+2); > - > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Sending paramSize = %d\n", InLength); > - > - // call the TPM driver > - if ((hRes = TDDL_TransmitData(InBuf, InLength, OutBuf, &OutLength)) == TDDL_SUCCESS) { > - // unpack OutBuf to get the tag, paramSize, & returnCode > - BSG_UnpackList(OutBuf, 3, > - BSG_TPM_TAG, &tag, > - BSG_TYPE_UINT32, ¶mSize, > - BSG_TPM_COMMAND_CODE, &returnCode); > - > - if (returnCode == TPM_SUCCESS && tag == TPM_TAG_RSP_COMMAND) { > - vtpmloginfo(VTPM_LOG_TCS_DEEP, "Received paramSize : %d\n", paramSize); > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_SaveState Failed with return code %s\n", tpm_get_error_name(returnCode)); > - } > - } > - > - return(returnCode); > -} > - > - > -TPM_RESULT TCSP_RawTransmitData( UINT32 inDataSize, // in > - BYTE *inData, // in > - UINT32 *outDataSize,// in/out > - BYTE *outData) { // out > - > - TDDL_RESULT hRes; > - > - vtpmloginfo(VTPM_LOG_TCS, "Calling TransmitData directly.\n"); > - //FIXME: Add Context Management > - hRes = TDDL_TransmitData( inData, > - inDataSize, > - outData, > - outDataSize); > - > - if (hRes == TDDL_SUCCESS) { > - return TPM_SUCCESS; > - } else { > - vtpmlogerror(VTPM_LOG_TCS, "TCSP_RawTransmitData Failed with return code %s\n", tpm_get_error_name(TPM_IOERROR)); > - return TPM_IOERROR; > - } > - > -} > diff --git a/tools/vtpm_manager/tcs/tcs.h b/tools/vtpm_manager/tcs/tcs.h > deleted file mode 100644 > index 83b9cd0..0000000 > --- a/tools/vtpm_manager/tcs/tcs.h > +++ /dev/null > @@ -1,245 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcs.h > -// > -// This file declares the TCS API > -// > -// ================================================================== > - > -#ifndef __TCS_H__ > -#define __TCS_H__ > - > -#include "tcg.h" > -#include "contextmgr.h" > -#include "buffer.h" > - > -#define HANDLE_NULL 0 > - > -// ------------------------------------------------------------------ > -// Exposed API > -// ------------------------------------------------------------------ > - > -TPM_RESULT TCS_create(); > -void TCS_destroy(); > - > -TPM_RESULT TCS_OpenContext( /* OUT */ TCS_CONTEXT_HANDLE* hContext ); > - > -TPM_RESULT TCS_CloseContext ( /* IN */ TCS_CONTEXT_HANDLE hContext ); > - > -TPM_RESULT TCS_Malloc ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 MemSize, // in > - BYTE** ppMemPtr ); //out > - > -TPM_RESULT TCS_FreeMemory ( TCS_CONTEXT_HANDLE hContext, // in > - BYTE* pMemory); // in > - > -// ------------------------------------------------------------------ > -// Exposed API > -// ------------------------------------------------------------------ > - > -// TPM v1.1B Command Set > - > -// Authorzation > -TPM_RESULT TCSP_OIAP( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonce0 // out > - ); > - > -TPM_RESULT TCSP_OSAP ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_ENTITY_TYPE entityType, // in > - UINT32 entityValue, // in > - TPM_NONCE nonceOddOSAP, // in > - TCS_AUTHHANDLE* authHandle, // out > - TPM_NONCE* nonceEven, // out > - TPM_NONCE* nonceEvenOSAP // out > - ); > - > -TPM_RESULT TCSP_TakeOwnership ( TCS_CONTEXT_HANDLE hContext, // in > - UINT16 protocolID, // in > - UINT32 encOwnerAuthSize, // in > - BYTE* encOwnerAuth, // in > - UINT32 encSrkAuthSize, // in > - BYTE* encSrkAuth, // in > - UINT32* SrkSize, // in, out > - BYTE** Srk, // in, out > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_DisablePubekRead ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_TerminateHandle ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle // in > - ); > - > -TPM_RESULT TCSP_FlushSpecific ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_AUTHHANDLE handle, // in > - TPM_RESOURCE_TYPE resourceType //in > - ); > - > -// TPM Mandatory > -TPM_RESULT TCSP_Extend ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_DIGEST inDigest, // in > - TPM_PCRVALUE* outDigest // out > - ); > - > -TPM_RESULT TCSP_PcrRead ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_PCRINDEX pcrNum, // in > - TPM_PCRVALUE* outDigest // out > - ); > - > -TPM_RESULT TCSP_Quote ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_NONCE antiReplay, // in > - UINT32* PcrDataSize, // in, out > - BYTE** PcrData, // in, out > - TCS_AUTH* privAuth, // in, out > - UINT32* sigSize, // out > - BYTE** sig // out > - ); > - > -TPM_RESULT TCSP_Seal ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - TPM_ENCAUTH encAuth, // in > - UINT32 pcrInfoSize, // in > - BYTE* PcrInfo, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* pubAuth, // in, out > - UINT32* SealedDataSize, // out > - BYTE** SealedData // out > - ); > - > -TPM_RESULT TCSP_Unseal ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE parentHandle, // in > - UINT32 SealedDataSize, // in > - BYTE* SealedData, // in > - TCS_AUTH* parentAuth, // in, out > - TCS_AUTH* dataAuth, // in, out > - UINT32* DataSize, // out > - BYTE** Data // out > - ); > - > -TPM_RESULT TCSP_DirWriteAuth ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_DIRINDEX dirIndex, // in > - TPM_DIRVALUE newContents, // in > - TCS_AUTH* ownerAuth // in, out > - ); > - > -TPM_RESULT TCSP_DirRead ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_DIRINDEX dirIndex, // in > - TPM_DIRVALUE* dirValue // out > - ); > - > -TPM_RESULT TCSP_UnBind ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 inDataSize, // in > - BYTE* inData, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* outDataSize, // out > - BYTE** outData // out > - ); > - > -TPM_RESULT TCSP_CreateWrapKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hWrappingKey, // in > - TPM_ENCAUTH KeyUsageAuth, // in > - TPM_ENCAUTH KeyMigrationAuth, // in > - UINT32* pcKeySize, // in, out > - BYTE** prgbKey, // in, out > - TCS_AUTH* pAuth // in, out > - ); > - > -TPM_RESULT TCSP_LoadKeyByBlob ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hUnwrappingKey, // in > - UINT32 cWrappedKeyBlobSize, // in > - BYTE* rgbWrappedKeyBlob, // in > - TCS_AUTH* pAuth, // in, out > - TCS_KEY_HANDLE* phKeyTCSI, // out > - TCS_KEY_HANDLE* phKeyHMAC // out > - ); > - > -TPM_RESULT TCSP_GetPubKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey, // in > - TCS_AUTH* pAuth, // in, out > - UINT32* pcPubKeySize, // out > - BYTE** prgbPubKey // out > - ); > - > -TPM_RESULT TCSP_EvictKey ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE hKey // in > - ); > - > -TPM_RESULT TCSP_Sign ( TCS_CONTEXT_HANDLE hContext, // in > - TCS_KEY_HANDLE keyHandle, // in > - UINT32 areaToSignSize, // in > - BYTE* areaToSign, // in > - TCS_AUTH* privAuth, // in, out > - UINT32* sigSize, // out > - BYTE** sig // out > - ); > - > -TPM_RESULT TCSP_GetRandom ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32* bytesRequested, // in, out > - BYTE** randomBytes // out > - ); > - > -TPM_RESULT TCSP_StirRandom ( TCS_CONTEXT_HANDLE hContext, // in > - UINT32 inDataSize, // in > - BYTE* inData // in > - ); > - > -TPM_RESULT TCSP_ReadPubek ( TCS_CONTEXT_HANDLE hContext, // in > - TPM_NONCE antiReplay, // in > - UINT32* pubEndorsementKeySize, // out > - BYTE** pubEndorsementKey, // out > - TPM_DIGEST* checksum // out > - ); > - > - > -// Non-Standard TCSP calls > -TPM_RESULT TCSP_SaveState(TCS_CONTEXT_HANDLE hContext); // in > - > -//Give direct access to TransmitData. > -// Key and Auth Management is done before transfering command to TDDL. > -TPM_RESULT TCSP_RawTransmitData(UINT32 inDataSize, // in > - BYTE *inData, // in > - UINT32 *outDataSize,// in/out > - BYTE *outData); // out > - > -///////////// Private Functions //////////////////// > -CONTEXT_HANDLE* LookupContext( TCS_CONTEXT_HANDLE hContext); > - > -#endif //TCS_H > diff --git a/tools/vtpm_manager/tcs/tpmddl.h b/tools/vtpm_manager/tcs/tpmddl.h > deleted file mode 100644 > index e7e54f1..0000000 > --- a/tools/vtpm_manager/tcs/tpmddl.h > +++ /dev/null > @@ -1,69 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tpmddl.c > -// > -// This file defines the TDDLI API > -// > -// ================================================================== > - > -#ifndef __TPMDDL_H__ > -#define __TPMDDL_H__ > - > -#define TDDL_CAP_PROP_MANUFACTURER 0x0001 > - > -#define TDDL_E_FAIL 1 > -#define TDDL_E_SUCCESS 0 > -#define TDDL_SUCCESS 0 > - > -typedef unsigned int TDDL_UINT32; > -typedef TDDL_UINT32 TDDL_RESULT; > -typedef unsigned char TDDL_BYTE; > - > -TDDL_RESULT TDDL_Open(); > -void TDDL_Close(); > -TDDL_RESULT TDDL_TransmitData( TDDL_BYTE* in, > - TDDL_UINT32 insize, > - TDDL_BYTE* out, > - TDDL_UINT32* outsize); > -TDDL_RESULT TDDL_GetStatus(); > -TDDL_RESULT TDDL_GetCapability( TDDL_UINT32 cap, > - TDDL_UINT32 sub, > - TDDL_BYTE* buffer, > - TDDL_UINT32* size); > -TDDL_RESULT TDDL_SetCapability( TDDL_UINT32 cap, > - TDDL_UINT32 sub, > - TDDL_BYTE* buffer, > - TDDL_UINT32* size); > - > -#endif // __TPMDDL_H__ > diff --git a/tools/vtpm_manager/tcs/transmit.c b/tools/vtpm_manager/tcs/transmit.c > deleted file mode 100644 > index 74bbdca..0000000 > --- a/tools/vtpm_manager/tcs/transmit.c > +++ /dev/null > @@ -1,147 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "buffer.h" > -#include "log.h" > -#include "tpmddl.h" > - > -// flag to track whether TDDL has been opened > -static int g_TDDL_open = 0; > -static int g_tx_fd = -1; // the fd to the TPM > - > -#ifndef DUMMY_TPM > - #define TPM_TX_FNAME "/dev/tpm0" > - static int *g_rx_fdp = &g_tx_fd; > -#else > - #define TPM_TX_FNAME "/var/tpm/tpm_in.fifo" > - #define TPM_RX_FNAME "/var/tpm/tpm_out.fifo" > - static int g_rx_fd = -1; > - static int *g_rx_fdp = &g_rx_fd; // the fd to the TPM > -#endif > - > -TPM_RESULT > -TDDL_TransmitData( TDDL_BYTE* in, > - TDDL_UINT32 insize, > - TDDL_BYTE* out, > - TDDL_UINT32* outsize) { > - TPM_RESULT status = TPM_SUCCESS; > - TDDL_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 (g_tx_fd, in, insize); > - if (size < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "write() failed"); > - ERRORDIE (TPM_IOERROR); > - } > - else if ((TDDL_UINT32) size < insize) { > - vtpmlogerror(VTPM_LOG_TXDATA, "Wrote %d instead of %d bytes!\n", (int) size, insize); > - // ... ? > - } > - > - // read the response > - size = read (*g_rx_fdp, out, TCPA_MAX_BUFFER_LENGTH); > - if (size < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "read() failed"); > - 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; > - // close connection > - goto egress; > - > - abort_egress: > - egress: > - return status; > -} > - > -TPM_RESULT TDDL_Open() { > - > - TDDL_RESULT status = TDDL_SUCCESS; > - > - if (g_TDDL_open) > - return TPM_FAIL; > - > -#ifdef DUMMY_TPM > - *g_rx_fdp = open (TPM_RX_FNAME, O_RDWR); > -#endif > - > - g_tx_fd = open (TPM_TX_FNAME, O_RDWR); > - if (g_tx_fd < 0) { > - vtpmlogerror(VTPM_LOG_TXDATA, "TPM open failed"); > - return TPM_IOERROR; > - } > - > - g_TDDL_open = 1; > - > - return status; > -} > - > -void TDDL_Close() { > - if (! g_TDDL_open) > - return; > - > - if (g_tx_fd>= 0) { > - if (close(g_tx_fd) < 0) > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > - g_tx_fd = -1; > - } > - > - if (*g_rx_fdp>= 0) { > - if (close(*g_rx_fdp) < 0) > - vtpmlogerror(VTPM_LOG_TXDATA, "closeing tpm failed"); > - *g_rx_fdp = -1; > - } > - > - g_TDDL_open = 0; > - > -} > diff --git a/tools/vtpm_manager/util/Makefile b/tools/vtpm_manager/util/Makefile > deleted file mode 100644 > index 36bc38f..0000000 > --- a/tools/vtpm_manager/util/Makefile > +++ /dev/null > @@ -1,24 +0,0 @@ > -XEN_ROOT = $(CURDIR)/../../.. > -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk > - > -BIN = libTCGUtils.a > - > -.PHONY: all > -all: build > - > -.PHONY: build > -build: $(BIN) > - > -.PHONY: install > -install: build > - > -.PHONY: clean > -clean: > - rm -f *.a *.so *.o *.rpm $(DEP_FILES) > - > -.PHONY: mrproper > -mrproper: clean > - rm -f *~ > - > -$(BIN): $(OBJS) > - $(AR) rcs $(BIN) $(OBJS) > diff --git a/tools/vtpm_manager/util/bsg.c b/tools/vtpm_manager/util/bsg.c > deleted file mode 100644 > index fa36ce7..0000000 > --- a/tools/vtpm_manager/util/bsg.c > +++ /dev/null > @@ -1,829 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// bsg.cpp > -// > -// This file will handle all the TPM Byte Stream functions > -// > -// ================================================================== > - > -#include > -#include > -#include > -#include > -#include "tcg.h" > -#include "crypto.h" > -#include "bsg.h" > -#include "log.h" > - > -static int g_log_recursion_level = 0; > - > -// a largest buffer size. if we get a buf size bigger than this when unpacking, > -// will complain! > -#define BSG_MAX_BUF_SIZE (1<<18) > - > -#define bsglog(fmt, ...) do { \ > - int __i; \ > - for (__i=0; __i < g_log_recursion_level; __i++) { \ > - vtpmloginfomore (VTPM_LOG_BSG, "%s", " "); \ > - } \ > - vtpmloginfomore (VTPM_LOG_BSG, fmt, __VA_ARGS__); \ > - } while (0) > - > - > -// FIXME: trigger the selfcheck--need to use glibc hook to do this > -//BOOL dummy1 = BSG_static_selfcheck(); > - > - > -// Interpretting Types > -// ------------------- > -// > -// Incoming Types are composed of two parts {format, info} squished into a > -// BSG_UINT32. The first 4 bits is a format spec indicating what type of > -// data it is. If the first 4 bits are zero the info corresponds to a value in > -// BSG_s_fmt[]. This is a structure whose composition is described in > -// BSG_s_fmt[]. If the value is non-zero, info corresponds to the size of the > -// data (in bytes) being passed in. For example a UINT32 being passed in would > -// have a format of (__FMT_CONST | 4). If both, the format and info are zero, > -// this is interpretted as the end of the structure, and the result is returned. > - > -// these flags are mutually exclusive, so I'll just make them > -// format values which indicate the semantics of the 'info' part and the source > -// data. The above description has been accordingly adjusted. > - > -// format values for determining what type of data the incoming type is > -// it's a 4 bit value, occupying the high 4 bits > -#define __FMT_CONST (1UL << 28) // Constant sized value > -#define __FMT_DATA (2UL << 28) // Believed to be raw data NOT {size,data} > -#define __FMT_SIZE (3UL << 28) // A size. Used in FMT_SIZE??_DATA. > -#define __FMT_HSIZE (4UL << 28) // A number of handles > -#define __FMT_PACKED (5UL << 28) // 'info' is unused; the source data consists > - // of {size32, data} but we're to pack only the > - // data as that is already packed, and so > - // can/must be unpacked without > - // explicitly reading it size > - > -#define __FMT_MASK 0x0FFFFFFFUL // this masks out the 4-bit format > -#define __FMT_MASK_SIZE(type) ((type) & __FMT_MASK) > -#define __FMT_MASK_FORMAT(type) ((type) & (~__FMT_MASK)) > - > -// constant (8/16/32-bits) > -#define FMT_U8 (__FMT_CONST | 1UL) > -#define FMT_U16 (__FMT_CONST | 2UL) > -#define FMT_U32 (__FMT_CONST | 4UL) > - > -// const with a compiler-computed size > -#define FMT_SIZEOF(type) (__FMT_CONST | sizeof(type)) > - > -// other data (size bytes) > -// Used primarily for DIGESTS -> FMT_DATA(20) > -#define FMT_DATA(size) (__FMT_DATA | ((BSG_UINT32) (size) & __FMT_MASK)) > - > -// 16/32-bit size followed by N bytes of data > -#define FMT_SIZE16_DATA (__FMT_SIZE | 2UL) > -#define FMT_SIZE32_DATA (__FMT_SIZE | 4UL) > - > -// 16-bit size followed by N key handles > -#define FMT_SIZE16_HANDLES (__FMT_HSIZE | 2UL) > - > -#define DIGEST_SIZE 20 > -typedef BSG_UINT32 BSG_HANDLE; > - > -// TCPA_AUTH has 11 fields! > -#define MAX_FIELDS 11 > -typedef struct BSG_Format > -{ > - BSG_Type type; > - const char* name; > - BSG_UINT32 fields[MAX_FIELDS + 1]; > -} BSG_Format; > - > -/* > - * TCPA structure data formats > - */ > -// this has to be manually kept in sync with the > -// Type enum!! the static_selfcheck() function should be used regularly! > -static BSG_Format s_fmt[] = > -{ > - {BSG_TYPE_UINT32, "BSG_TYPE_UINT32", {FMT_U32, 0}}, > - {BSG_TYPE_UINT16, "BSG_TYPE_UINT16", {FMT_U16, 0}}, > - {BSG_TYPE_BYTE, "BSG_TYPE_BYTE", {FMT_U8, 0}}, > - {BSG_TYPE_BOOL, "BSG_TYPE_BOOL", {FMT_U8, 0}}, > - {BSG_TPM_SIZE32_DATA, "BSG_TPM_SIZE32_DATA", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_TAG, "BSG_TPM_TAG", {FMT_SIZEOF(TPM_TAG), 0}}, > - {BSG_TPM_HANDLE, "BSG_TPM_HANDLE", {FMT_SIZEOF(TPM_HANDLE), 0}}, > - {BSG_TPM_RESULT, "BSG_TPM_RESULT", {FMT_SIZEOF(TPM_RESULT), 0}}, > - {BSG_TPM_RESOURCE_TYPE, "BSG_TPM_RESOURCE_TYPE", {FMT_SIZEOF(TPM_RESOURCE_TYPE), 0}}, > - {BSG_TPM_COMMAND_CODE, "BSG_TPM_COMMAND_CODE", {FMT_U32, 0}}, > - {BSG_TPM_AUTH_DATA_USAGE, "BSG_TPM_AUTH_DATA_USAGE", {FMT_U8, 0}}, > - {BSG_TPM_ALGORITHM_ID, "BSG_TPM_ALGORITHM_ID", {FMT_U32, 0}}, > - {BSG_TPM_PROTOCOL_ID, "BSG_TPM_PROTOCOL_ID", {FMT_SIZEOF(TPM_PROTOCOL_ID), 0}}, > - {BSG_TPM_KEY_USAGE, "BSG_TPM_KEY_USAGE", {FMT_U16, 0}}, > - {BSG_TPM_ENC_SCHEME, "BSG_TPM_ENC_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_SIG_SCHEME, "BSG_TPM_SIG_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_MIGRATE_SCHEME, "BSG_TPM_MIGRATE_SCHEME", {FMT_U16, 0}}, > - {BSG_TPM_KEY_FLAGS, "BSG_TPM_KEY_FLAGS", {FMT_U32, 0}}, > - > - {BSG_TPM_AUTHDATA, "BSG_TPM_AUTHDATA", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_SECRET, "BSG_TPM_SECRET", {BSG_TPM_AUTHDATA, 0}}, > - {BSG_TPM_ENCAUTH, "BSG_TPM_ENCAUTH", {BSG_TPM_AUTHDATA, 0}}, > - {BSG_TPM_PAYLOAD_TYPE, "BSG_TPM_PAYLOAD_TYPE", {FMT_SIZEOF(TPM_PAYLOAD_TYPE), 0}}, > - > - {BSG_TPM_VERSION, "BSG_TPM_VERSION", {FMT_DATA(4), 0}}, // vers 1.2 > - {BSG_TPM_DIGEST, "BSG_TPM_DIGEST", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_COMPOSITE_HASH, "BSG_TPM_COMPOSITE_HASH", {BSG_TPM_DIGEST, 0}}, > - {BSG_TPM_CHOSENID_HASH, "BSG_TPM_CHOSENID_HASH", {BSG_TPM_DIGEST, 0}}, > - > - {BSG_TPM_NONCE, "BSG_TPM_NONCE", {FMT_DATA(DIGEST_SIZE), 0}}, > - {BSG_TPM_KEY_HANDLE, "BSG_TPM_KEY_HANDLE", {FMT_SIZEOF(TPM_KEY_HANDLE), 0}}, > - {BSG_TPM_KEY_HANDLE_LIST, "BSG_TPM_KEY_HANDLE_LIST", > - {FMT_SIZE16_HANDLES, 0}}, > - > - {BSG_TPM_KEY_PARMS, "BSG_TPM_KEY_PARMS", { > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_ENC_SCHEME, > - BSG_TPM_SIG_SCHEME, > - FMT_SIZE32_DATA, > - 0}}, > - {BSG_TPM_RSA_KEY_PARMS, "BSG_TPM_RSA_KEY_PARMS", { > - FMT_U32, FMT_U32, FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_STORE_PUBKEY, "BSG_TPM_STORE_PUBKEY", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_PUBKEY, "BSG_TPM_PUBKEY", {BSG_TPM_KEY_PARMS, BSG_TPM_STORE_PUBKEY, 0}}, > - {BSG_TPM_KEY, "BSG_TPM_KEY", { > - BSG_TPM_VERSION, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_KEY_PARMS, > - FMT_SIZE32_DATA, // the PCR_INFO > - BSG_TPM_STORE_PUBKEY, > - FMT_SIZE32_DATA, // the encrypted part > - 0}}, > - > - {BSG_TPM_MIGRATIONKEYAUTH, "BSG_TPM_MIGRATIONKEYAUTH", { > - BSG_TPM_PUBKEY, > - BSG_TPM_MIGRATE_SCHEME, > - BSG_TPM_DIGEST, 0}}, > - > - {BSG_TCPA_AUDIT_EVENT, "TCPA_AUDIT_EVENT", { > - BSG_TPM_COMMAND_CODE, > - BSG_TPM_RESULT, 0 }}, > - > - {BSG_TCPA_EVENT_CERT, "TCPA_EVENT_CERT", { > - BSG_TPM_DIGEST, > - BSG_TPM_DIGEST, > - FMT_DATA(2), > - FMT_SIZE32_DATA, 0}}, > - > - {BSG_TPM_PCR_SELECTION, "BSG_TPM_PCR_SELECTION", {FMT_SIZE16_DATA, 0} }, > - {BSG_TPM_PCR_COMPOSITE, "BSG_TPM_PCR_COMPOSITE", { BSG_TPM_PCR_SELECTION, > - FMT_SIZE32_DATA, > - 0} }, > - > - {BSG_TPM_PCR_INFO, "BSG_TPM_PCR_INFO", { BSG_TPM_PCR_SELECTION, > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_COMPOSITE_HASH, > - 0} }, > - > - > - {BSG_TPM_STORED_DATA, "BSG_TPM_STORED_DATA", { > - BSG_TPM_VERSION, > - FMT_SIZE32_DATA, > - FMT_SIZE32_DATA, > - 0}}, > - {BSG_TPM_SYMMETRIC_KEY, "BSG_TPM_SYMMETRIC_KEY", { > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_ENC_SCHEME, > - FMT_SIZE16_DATA, > - 0}}, > - {BSG_TPM_STORE_PRIVKEY, "BSG_TPM_STORE_PRIVKEY", {FMT_SIZE32_DATA, 0}}, > - {BSG_TPM_STORE_ASYMKEY, "BSG_TPM_STORE_ASYMKEY", { > - BSG_TPM_PAYLOAD_TYPE, > - BSG_TPM_SECRET, > - BSG_TPM_SECRET, > - BSG_TPM_DIGEST, > - BSG_TPM_STORE_PRIVKEY, > - 0}}, > - {BSG_TPM_MIGRATE_ASYMKEY, "BSG_TPM_MIGRATE_ASYMKEY", { > - BSG_TPM_PAYLOAD_TYPE, > - BSG_TPM_SECRET, > - BSG_TPM_DIGEST, > - FMT_U32, > - BSG_TPM_STORE_PRIVKEY, > - 0}}, > - > - {BSG_TPM_QUOTE_INFO, "BSG_TPM_QUOTE_INFO", { > - BSG_TPM_VERSION, > - FMT_DATA(4), > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_NONCE, > - 0}}, > - > - {BSG_TPM_IDENTITY_CONTENTS, "BSG_TPM_IDENTITY_CONTENTS", { > - BSG_TPM_VERSION, > - FMT_U32, > - BSG_TPM_CHOSENID_HASH, > - BSG_TPM_PUBKEY, > - 0}}, > - > - {BSG_TPM_PCRVALUE, "BSG_TPM_PCRVALUE", {FMT_DATA(DIGEST_SIZE), 0}}, > - > - {BSG_TCPA_PCR_FLAGS, "TCPA_PCR_FLAGS", { > - FMT_U8, > - FMT_U8, > - 0}}, > - > - {BSG_TCS_AUTH, "TCS_AUTH", { > - BSG_TYPE_UINT32, > - BSG_TPM_NONCE, > - BSG_TPM_NONCE, > - BSG_TYPE_BOOL, > - BSG_TPM_AUTHDATA, > - 0}}, > - > - {BSG_TPM_KEY_NONSENSITIVE, "BSG_TPM_KEY_NONSENSITIVE", { > - BSG_TPM_VERSION, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_KEY_PARMS, > - FMT_SIZE32_DATA, > - BSG_TPM_STORE_PUBKEY, > - 0}}, > - > - {BSG_PACKED, "BSG_PACKED", { > - __FMT_PACKED, > - 0 }}, > - > - {BSG_TYPE_MAX, "", {0}}, > -}; > - > - > -static const BSG_Format* find_format (BSG_Type t) { > - BSG_Format * f = s_fmt; > - > - if (t >= BSG_TYPE_MAX) { > - return NULL; > - } > - > - // WARNING: this depends on the enum and s_fmt[] array being in sync! make > - // sure to run the static_selfcheck() to make sure > - f = s_fmt + (t - BSG_TYPE_FIRST); > - > - return f; > -} > - > -// > -// a consistency-checking routine which can be run at compile time > -// (ie. immediately after compilation) > -// > -// tasks: > -// - verify that s_fmt has one entry per Type t, and that entry is at s_fmt[t] > -// > -// conditions: > -// - need that s_fmt[0] is the first type listed in the Type enum! ie the first > -// Type has value 0, not 1 > -// > -// FIXME: should have a function be passed in here which is called if the test > -// fails. Then the caller can decide what to do: abort, notify, whatever > -// > -BOOL BSG_static_selfcheck () > -{ > - int i; > - > - for (i=BSG_TYPE_FIRST; i <= BSG_TYPE_MAX; i++) { > - if (s_fmt[i - BSG_TYPE_FIRST].type != i) { > - bsglog ("%s\n", "BSG: static_selfcheck failed!\n"); > - bsglog ("failure at %i, allegedly %s\n", > - i, s_fmt[i - BSG_TYPE_FIRST].name); > - abort(); > - return FALSE; > - } > - } > - > - bsglog ("%s\n", "BSG: static_selfcheck success!"); > - return TRUE; > -} > - > - > -/** > - * Flatten a TCPA structure into a buffer in big-endian format > - * @type: TCPA structure type > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > - * @dst: (OUT) flattened data > - * Returns: Flattened size or -1 for unknown types > - */ > -// make it so that it can just run through the whole process and return > -// the packed size, without packing anything. this will be done if dst is NULL. > -static int BSG_Pack_private(BSG_Type type, const BSG_BYTE** src, BSG_BYTE* dst) > -{ > - // check incoming parameters > - if (*src == NULL) > - return 0; > - > - const BSG_BYTE* s = *src; > - BSG_BYTE* d = dst; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if (format == __FMT_CONST) // We are dealing with a fixed length value eg. UINT32 > - { > - BSG_UINT32 val = 0; > - switch (size) { > - case 1: val = * (BYTE*) s; break; > - case 2: val = * (unsigned short*) s; break; > - case 4: val = * (BSG_UINT32*) s; break; > - } > - if (dst) > - BSG_PackConst(val, size, d); > - > - s += size; > - d += size; > - } else if (format == __FMT_DATA) { // We are dealing with raw data. Not sure when > - // this is used. > - > - if (dst) { > - bsglog ("BSG: __FMT_DATA size %d, src %p, dst %p\n", size, s, d); > - memcpy(d, s, size); > - } > - > - s += size; > - d += size; > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) { // It's a size, followed by that much data or handles > - > - BSG_UINT32 psize = 0; > - switch (size) { > - case 1: psize = * (BYTE*) s; break; > - case 2: psize = * (unsigned short*) s; break; > - case 4: psize = * (BSG_UINT32*) s; break; > - } > - > - if (dst) > - BSG_PackConst(psize, size, d); > - > - s += size; > - d += size; > - > - // now 's' points to an address, so cast it to BSG_BYTE** > - const BSG_BYTE* pdata = * ((BSG_BYTE**) s); > - s += sizeof(BSG_BYTE*); > - > - if (format == __FMT_HSIZE) {// This is a list of psize Handles > - if (dst) { > - BSG_HANDLE* d2 = (BSG_HANDLE*) d; > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > - BSG_UINT32 i; > - for (i = 0; i < psize; i++) > - d2[i] = BSG_UnpackConst((BSG_BYTE*)(p2 + i), 4); > - > - } > - d += psize * sizeof(BSG_HANDLE); > - } else {// If it's not psize handles, it's psize data. > - if (psize > 0) { > - if (dst) { > - bsglog ("BSG: __FMT_SIZE, size=%d, src=%p, dst=%p\n", > - psize, pdata, d); > - memcpy(d, pdata, psize); > - } > - } > - d += psize; > - } > - } else if (format == __FMT_PACKED) { > - // the source buffer is a pack_constbuf_t, which has a size and a > - // pointer. just copy the buffer value, the size is not included in the > - // output stream. > - pack_constbuf_t * buf = (pack_constbuf_t*) s; > - > - if (dst) { > - bsglog ("BSG: __FMT_PACKED, size=%d, src=%p, dst=%p\n", > - buf->size, buf->data, d); > - memcpy(d, buf->data, buf->size); > - } > - > - s += buf->size; > - d += buf->size; > - } else if (format == 0) {// No flags are set. This is a structure & it should > - // be looked up in the bsg_s_fmt[] > - > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmloginfo(VTPM_LOG_BSG, "BSG_Pack: cannot find type %d\n", type); > - return -1; > - } > - > - if (dst) > - bsglog ("BSG_Pack type %s\n", x->name); > - > - > - // iterate through the fields > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) { > - int fsize; > - > - g_log_recursion_level++; > - fsize = BSG_Pack_private((BSG_Type) *f, &s, dst ? d : NULL); > - g_log_recursion_level--; > - > - if (fsize <= 0) > - return fsize; > - > - d += fsize; > - } > - } else { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Pack(): Unknown format %d\n", format); > - return -1; > - } > - > - *src = s; > - return (d - dst); > -} > - > -/** > - * Unflatten a TCPA structure from a buffer in big-endian format > - * @type: TCPA structure type > - * @src: flattened data > - * @dst: (IN) TCPA structure (OUT) end of TCPA structure > - * Returns: Flattened size > - * Note: Returns flattened size NOT the unpacked structure size > - */ > -static int BSG_Unpack_private(BSG_Type type, const BSG_BYTE* src, BSG_BYTE** dst) { > - // check incoming parameters > - if (src == NULL) > - return 0; > - > - > - const BSG_BYTE* s = src; > - BSG_BYTE* d = dst ? *dst:NULL; > - if (dst && !d) > - dst = NULL; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if (format == __FMT_CONST) {// We are dealing with a fixed length value ie. UINT32 > - > - BSG_UINT32 val = BSG_UnpackConst(s, size); > - > - if (dst) { > - switch (size) { > - case 1: *(BYTE *) d = (BSG_BYTE) val; break; > - case 2: *(unsigned short*) d = (unsigned short) val; break; > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) val; break; > - } > - } > - > - s += size; > - d += size; > - } else if (format == __FMT_DATA) {// We are dealing with raw data. Not sure when this is used. > - if (dst) > - memcpy(d, s, size); > - > - d += size; > - s += size; > - } else if (format == __FMT_SIZE || format == __FMT_HSIZE) {// It's a size, followed by that much data or handles > - > - BSG_UINT32 psize = BSG_UnpackConst(s, size); > - > - if (psize > BSG_MAX_BUF_SIZE) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack runs into var-sized data bigger than %u bytes!!\n", > - BSG_MAX_BUF_SIZE); > - return -1; > - } > - > - if (dst) { > - switch (size) { > - case 1: *(BYTE *) d = (BSG_BYTE) psize; break; > - case 2: *(unsigned short*) d = (unsigned short) psize; break; > - case 4: *(BSG_UINT32*) d = (BSG_UINT32) psize; break; > - } > - } > - > - s += size; > - d += size; > - > - BSG_BYTE* pdata = NULL; > - > - if (psize) { > - if (format == __FMT_HSIZE) { // This is a list of psize Handles > - if (dst) { > - BSG_HANDLE* s2 = (BSG_HANDLE*) s; > - pdata = (BSG_BYTE *)malloc(psize * sizeof(BSG_HANDLE)); > - if (!pdata) > - return -1; > - > - BSG_HANDLE* p2 = (BSG_HANDLE*) pdata; > - BSG_UINT32 i; > - for (i = 0; i < psize; i++) { > - BSG_PackConst(s2[i], 4, (BSG_BYTE*)(p2 + i)); > - } > - } > - s += psize * sizeof(BSG_HANDLE); > - } else { // If it's not psize handles, it's psize data. > - if (dst) { > - pdata = (BSG_BYTE *)malloc(sizeof(BSG_BYTE) * psize); > - if (!pdata) > - return -1; > - memcpy(pdata, s, psize); > - } > - s += psize; > - } > - } > - if (dst) > - *(void**) d = pdata; > - > - d += sizeof(void*); > - } else if (format == __FMT_PACKED) { > - > - // this doesn't make sense for unpacking! > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack() called with format __FMT_PACKED. " > - "This does not make sense\n"); > - > - return -1; > - } else if (format == 0) {// No flags are set. This is a structure & it should > - // be looked up in the bsg_s_fmt[] > - > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Unpack: cannot find type %d\n", type); > - return -1; > - } > - > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) { > - int fsize = BSG_Unpack_private((BSG_Type) *f, s, dst ? &d:NULL); > - if (fsize <= 0) > - return fsize; > - s += fsize; > - } > - } > - > - if (dst) > - *dst = d; > - return (s - src); > -} > - > -/** > - * Free memory associated with unpacked TCPA structure > - * @type: TCPA structure type > - * @src: (IN) TCPA structure (OUT) end of TCPA structure > - * Note: Destroy should be called on all structures created with Unpack > - * to ensure that any allocated memory is freed > - */ > -static void BSG_Destroy_private(BSG_Type type, BSG_BYTE** src) { > - BSG_BYTE* s = *src; > - > - BSG_UINT32 size = __FMT_MASK_SIZE(type); > - BSG_UINT32 format = __FMT_MASK_FORMAT(type); > - > - if ((src == NULL) || (*src == NULL)) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with NULL src\n"); > - return; > - } > - > - if (format == __FMT_CONST || format == __FMT_DATA) > - s += size; > - else if (format == __FMT_SIZE || format == __FMT_HSIZE) { > - s += size; > - BSG_BYTE* ptr = *(BSG_BYTE**) s; > - free(ptr); > - s += sizeof(void*); > - } else if (format == __FMT_PACKED) { > - > - // this doesn't make sense for unpacking, hence also for Destroy() > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy() called with format __FMT_PACKED. " > - "This does not make sense\n"); > - > - return; > - } else if (format == 0) { > - const BSG_Format* x = find_format (type); > - if (x == NULL) { > - vtpmlogerror(VTPM_LOG_BSG, "BSG_Destroy: cannot find type %d\n", type); > - return; > - } > - > - const BSG_UINT32* f = x->fields; > - for (; *f; f++) > - BSG_Destroy_private((BSG_Type) *f, &s); > - } > - > - *src = s; > -} > - > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst) > -{ > - const BSG_BYTE* src2 = (const BSG_BYTE*) src; > - return BSG_Pack_private(type, &src2, dst); > -} > - > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst) > -{ > - BSG_BYTE* dst2 = (BSG_BYTE*) dst; > - return BSG_Unpack_private(type, src, dst ? &dst2:NULL); > -} > - > -void BSG_Destroy(BSG_Type type, void* src) > -{ > - BSG_BYTE* src2 = (BSG_BYTE*) src; > - BSG_Destroy_private(type, &src2); > -} > - > -/** > - * Pack a 8/16/32-bit constant into a buffer in big-endian format > - * @val: constant value > - * @size: constant size in bytes (1, 2, or 4) > - * @dst: (OUT) buffer > - */ > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst) { > - bsglog ("BSG: PackConst on %d of size %i into address %p\n", val, size, dst); > - > - switch (size) { > - case 4: > - dst[0] = (BSG_BYTE)((val >> 24) & 0xff); > - dst[1] = (BSG_BYTE)((val >> 16) & 0xff); > - dst[2] = (BSG_BYTE)((val >> 8) & 0xff); > - dst[3] = (BSG_BYTE)(val & 0xff); > - break; > - case 2: > - dst[0] = (BSG_BYTE)((val >> 8) & 0xff); > - dst[1] = (BSG_BYTE)(val & 0xff); > - break; > - case 1: > - dst[0] = (BSG_BYTE)(val & 0xff); > - break; > - } > -} > - > -/** > - * Unpack a 8/16/32-bit constant from a buffer in big-endian format > - * @src: buffer > - * @size: constant size in bytes (1, 2, or 4) > - */ > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size) { > - BSG_UINT32 val = 0; > - > - if (src == NULL) > - return 0; > - > - switch (size) { > - case 4: > - val = (((BSG_UINT32) src[0]) << 24 > - | ((BSG_UINT32) src[1]) << 16 > - | ((BSG_UINT32) src[2]) << 8 > - | (BSG_UINT32) src[3]); > - break; > - case 2: > - val = (((BSG_UINT32) src[0]) << 8 | (BSG_UINT32) src[1]); > - break; > - case 1: > - val = (BSG_UINT32) src[0]; > - break; > - } > - return val; > -} > - > -// Pack a list of parameters. Beware not to send values, but rather you must > -// send a pointer to your values Instead. This includes UINT32's. > -int BSG_PackList( BSG_BYTE* dst, int ParamCount, ... ) { > - int ParamNumber; > - BSG_Type format; > - BSG_BYTE* val = NULL; > - int size=0; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - //Strangeness with int is because gcc wanted an int rather than a enum of ints. > - format = (BSG_Type) va_arg( paramList, int ); > - val = va_arg( paramList, BSG_BYTE* ); > - size += BSG_Pack(format, val, dst == NULL ? NULL : dst + size); > - } > - > - va_end (paramList); > - > - return size; > -} > - > -// Unpack a list of parameters. > -int BSG_UnpackList( const BSG_BYTE* src, int ParamCount, ... ) { > - int ParamNumber = 0; > - BSG_Type format; > - BSG_BYTE* val = NULL; > - int size = 0; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - format = (BSG_Type) va_arg( paramList, int ); > - val = va_arg( paramList, BSG_BYTE* ); > - > - size += BSG_Unpack(format, src + size, val); > - } > - > - va_end( paramList ); > - > - return size; > -} > - > -// Destroy any memory allocated by calls to unpack > -void BSG_DestroyList(int ParamCount, ... ) { > - int ParamNumber = 0; > - BSG_Type argType; > - BSG_BYTE* paramValue = NULL; > - > - va_list paramList; > - va_start( paramList, ParamCount ); > - > - for( ParamNumber = 1; ParamNumber <= ParamCount; ParamNumber++) { > - argType = (BSG_Type) va_arg( paramList, int ); > - paramValue = va_arg( paramList, BSG_BYTE* ); > - > - BSG_Destroy(argType, paramValue); > - } > - > - va_end( paramList ); > - > - return; > -} > - > - > -// and a tuple version > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]) { > - int i; > - > - for (i = 0; i < numParams; i++) > - BSG_Destroy (params[i].type, params[i].addr); > - > - return TPM_SUCCESS; > -} > - > - > -// > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > -// by the caller later > -// > - > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst) { > - int size = BSG_Pack (type, src, NULL); > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > - if (dest == NULL) > - return -1; > - > - size = BSG_Pack(type, src, dest); > - *o_dst = dest; > - return size; > -} > - > - > - > -int BSG_PackListMalloc(BSG_BYTE** outBuffer, int ParamCount, ... ) { > - va_list args; > - int size; > - > - va_start (args, ParamCount); > - size = BSG_PackList (NULL, ParamCount, args); > - va_end (args); > - > - BSG_BYTE * dest = (BSG_BYTE*) malloc (size); > - if (dest == NULL) > - return -1; > - > - va_start (args, ParamCount); > - size = BSG_PackList (dest, ParamCount, args); > - va_end (args); > - > - *outBuffer = dest; > - return size; > -} > diff --git a/tools/vtpm_manager/util/bsg.h b/tools/vtpm_manager/util/bsg.h > deleted file mode 100644 > index 0896812..0000000 > --- a/tools/vtpm_manager/util/bsg.h > +++ /dev/null > @@ -1,166 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// bsg.h > -// > -// This file contains API's for the TPM Byte Stream functions > -// > -// ================================================================== > - > -#ifndef __BSG_H__ > -#define __BSG_H__ > - > -#include > -#include "buffer.h" > - > -typedef unsigned int BSG_UINT32; > -typedef unsigned char BSG_BYTE; > - > -// forward decl > -struct pack_const_tuple_t; > - > -struct pack_tuple_t; > - > - > -/** > - * Byte stream generator > - */ > -// this has to be manually kept in sync with the > -// s_fmt array!! > -// but now we have a self-check function which can make sure things are well > -// (if used!) > -typedef enum BSG_Type > -{ > - BSG_TYPE_FIRST = 1, > - BSG_TYPE_UINT32 = 1, // start at 1 so that Type 0 only serves as an > - // unused/special value > - BSG_TYPE_UINT16, > - BSG_TYPE_BYTE, > - BSG_TYPE_BOOL, > - BSG_TPM_SIZE32_DATA, // a 32 bit unsigned size, followed by > - // a pointer to that much data. can pass a > - // struct pack_buf_t as the param > - BSG_TPM_TAG, > - BSG_TPM_HANDLE, > - BSG_TPM_RESULT, > - BSG_TPM_RESOURCE_TYPE, > - BSG_TPM_COMMAND_CODE, > - BSG_TPM_AUTH_DATA_USAGE, > - BSG_TPM_ALGORITHM_ID, > - BSG_TPM_PROTOCOL_ID, > - BSG_TPM_KEY_USAGE, > - BSG_TPM_ENC_SCHEME, > - BSG_TPM_SIG_SCHEME, > - BSG_TPM_MIGRATE_SCHEME, > - BSG_TPM_KEY_FLAGS, > - BSG_TPM_AUTHDATA, > - BSG_TPM_SECRET, > - BSG_TPM_ENCAUTH, > - BSG_TPM_PAYLOAD_TYPE, > - > - BSG_TPM_VERSION, > - BSG_TPM_DIGEST, > - BSG_TPM_COMPOSITE_HASH, > - BSG_TPM_CHOSENID_HASH, > - BSG_TPM_NONCE, > - BSG_TPM_KEY_HANDLE, > - BSG_TPM_KEY_HANDLE_LIST, > - BSG_TPM_KEY_PARMS, > - BSG_TPM_RSA_KEY_PARMS, > - BSG_TPM_STORE_PUBKEY, > - BSG_TPM_PUBKEY, > - BSG_TPM_KEY, > - > - BSG_TPM_MIGRATIONKEYAUTH, > - BSG_TCPA_AUDIT_EVENT, > - BSG_TCPA_EVENT_CERT, > - BSG_TPM_PCR_SELECTION, > - BSG_TPM_PCR_COMPOSITE, > - BSG_TPM_PCR_INFO, > - BSG_TPM_STORED_DATA, > - BSG_TPM_SYMMETRIC_KEY, > - BSG_TPM_STORE_PRIVKEY, > - BSG_TPM_STORE_ASYMKEY, > - BSG_TPM_MIGRATE_ASYMKEY, > - BSG_TPM_QUOTE_INFO, > - BSG_TPM_IDENTITY_CONTENTS, > - BSG_TPM_PCRVALUE, > - BSG_TCPA_PCR_FLAGS, > - BSG_TCS_AUTH, > - > - // this is the BSG_TPM_KEY struct without the encData field > - BSG_TPM_KEY_NONSENSITIVE, > - > - BSG_PACKED, > - > - BSG_TYPE_MAX > -} BSG_Type; > - > -struct pack_const_tuple_t { > - BSG_Type type; > - const void * addr; > -}; > - > - > -typedef struct pack_tuple_t { > - BSG_Type type; > - void * addr; > -} pack_tuple_t; > - > -int BSG_Pack(BSG_Type type, const void* src, BSG_BYTE* dst); > -int BSG_Unpack(BSG_Type type, const BSG_BYTE* src, void* dst); > -void BSG_Destroy(BSG_Type type, void* src); > - > -// wrappers of Pack and PackList which malloc the ouput buffer. to be freed > -// by the caller later. returns size of allocated buffer, or -1 in case > -// allocation failed > -int BSG_PackMalloc (BSG_Type type, const void* src, BSG_BYTE** o_dst); > -int BSG_PackListMalloc (BSG_BYTE** outBuffer, int ParamCount, ... ); > - > -// a va_list version of PackList > -int BSG_PackList(BSG_BYTE* outBuffer, int ParamCount, ... ); > -int BSG_UnpackList(const BSG_BYTE* inBuffer, int ParamCount, ... ); > -void BSG_DestroyList(int ParamCount, ... ); > - > -// wrapper of PackList which uses a buffer_t > -TPM_RESULT BSG_PackListBuf (buffer_t * o_buf, int ParamCount, ...); > - > -// and a tuple version > -TPM_RESULT BSG_DestroyTuple (int numParams, pack_tuple_t params[]); > - > -void BSG_PackConst(BSG_UINT32 val, int size, BSG_BYTE* dst); > -BSG_UINT32 BSG_UnpackConst(const BSG_BYTE* src, int size); > - > -BOOL BSG_static_selfcheck (); > - > -#endif > diff --git a/tools/vtpm_manager/util/buffer.c b/tools/vtpm_manager/util/buffer.c > deleted file mode 100644 > index df48bc2..0000000 > --- a/tools/vtpm_manager/util/buffer.c > +++ /dev/null > @@ -1,226 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > - > -#include > -#include > -#include > -#include > -#include > - > -#include "tcg.h" > -#include "bsg.h" > -#include "buffer.h" > - > -static TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize); > - > -// > -// buffer functions! > -// > - > -TPM_RESULT buffer_init (buffer_t * buf, tpm_size_t initsize, const BYTE* initval) { > - if (initsize == 0) { > - memset(buf, 0, sizeof(*buf)); > - return TPM_SUCCESS; > - } > - > - > - buf->bytes = (BYTE*) malloc (initsize); > - if (buf->bytes == NULL) > - return TPM_RESOURCES; > - > - buf->size = initsize; > - buf->alloc_size = initsize; > - > - if (initval) > - memcpy (buf->bytes, initval, initsize); > - > - buf->is_owner = TRUE; > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_init_convert (buffer_t * buf, tpm_size_t initsize, BYTE* initval) { > - > - buf->size = initsize; > - buf->alloc_size = initsize; > - buf->bytes = initval; > - > - buf->is_owner = TRUE; > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src) { > - TPM_RESULT status = buffer_init (buf, src->size, src->bytes); > - buf->is_owner = TRUE; > - > - return status; > -} > - > - > - > -// make an alias to a constant array > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val) { > - // TODO: try to enforce the const things somehow! > - buf->bytes = (BYTE*) val; > - buf->size = size; > - buf->alloc_size = 0; // this field is now unneeded > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > -// make an alias into buf, with given offset and length > -// if len = 0, make the alias go to the end of buf > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > - tpm_size_t offset, tpm_size_t len) { > - if (offset + len > b->size) { > - return TPM_NOSPACE; > - } > - > - buf->bytes = b->bytes + offset; > - buf->size = len > 0 ? len : b->size - offset; > - > - //VS/ buf->alloc_size = 0; > - if (len ==0) > - buf->alloc_size = b->alloc_size - offset; > - else > - buf->alloc_size = MIN(b->alloc_size - offset, len); > - > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > -// make an alias buffer_t into bytestream, with given length > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, tpm_size_t size, BYTE* val) { > - > - buf->size = size; > - buf->alloc_size = size; > - buf->bytes = val; > - > - buf->is_owner = FALSE; > - > - return TPM_SUCCESS; > -} > - > - > - > -// copy into the start of dest > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src) > -{ > - TPM_RESULT status = TPM_SUCCESS; > - > - if (dest->alloc_size < src->size) { > - TPMTRYRETURN( buffer_priv_realloc (dest, src->size) ); > - } > - > - memcpy (dest->bytes, src->bytes, src->size); > - dest->size = src->size; > - > - //VS/ dest->is_owner = TRUE; > - > - abort_egress: > - > - return status; > -} > - > - > - > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b) { > - return (a->size == b->size && memcmp (a->bytes, b->bytes, a->size) == 0); > -} > - > - > -void buffer_memset (buffer_t * buf, BYTE b) { > - memset (buf->bytes, b, buf->size); > -} > - > - > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes) { > - TPM_RESULT status = TPM_SUCCESS; > - > - if (buf->alloc_size < buf->size + len) { > - TPMTRYRETURN( buffer_priv_realloc (buf, buf->size + len) ); > - } > - > - memcpy (buf->bytes + buf->size, bytes, len); > - > - buf->size += len; > - > - goto egress; > - > - abort_egress: > - > - egress: > - > - return status; > -} > - > -tpm_size_t buffer_len (const buffer_t* buf) { > - return buf->size; > -} > - > -TPM_RESULT buffer_free (buffer_t * buf) { > - if (buf && buf->is_owner && buf->bytes != NULL) { > - free (buf->bytes); > - buf->bytes = NULL; > - buf->size = buf->alloc_size = 0; > - > - } > - > - return TPM_SUCCESS; > -} > - > -TPM_RESULT buffer_priv_realloc (buffer_t * buf, tpm_size_t newsize) { > - > - // we want to realloc to twice the size, or the new size, whichever > - // bigger > - > - BYTE * tmpbuf = NULL; > - > - newsize = MAX (buf->alloc_size * 2, newsize); > - > - tmpbuf = (BYTE*) realloc (buf->bytes, newsize); > - if (tmpbuf == NULL) > - return TPM_SIZE; > - > - > - buf->bytes = tmpbuf; > - buf->alloc_size = newsize; > - > - return TPM_SUCCESS; > -} > diff --git a/tools/vtpm_manager/util/buffer.h b/tools/vtpm_manager/util/buffer.h > deleted file mode 100644 > index d8a9abc..0000000 > --- a/tools/vtpm_manager/util/buffer.h > +++ /dev/null > @@ -1,95 +0,0 @@ > -// =================================================================== > -// > -// 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_BUFFER_H__ > -#define __VTPM_BUFFER_H__ > - > -#include // for pointer NULL > -#include "tcg.h" > - > -typedef UINT32 tpm_size_t; > - > -// first version, probably will be expanded... > - > -#define NULL_BUF {0,0,0,0} > - > -typedef struct { > - // private!! > - tpm_size_t size, alloc_size; > - BYTE * bytes; > - > - BOOL is_owner; // do we own this buffer, and need to free it? > -} buffer_t; > - > -// allocate the buffer if initsize > 0, copying over initval if provided > -TPM_RESULT buffer_init (buffer_t * buf, > - tpm_size_t initsize, > - const BYTE* initval); > - > -// Create a new buffer from a BYTE *. Use buffer_free to destroy original BYTE * > -TPM_RESULT buffer_init_convert (buffer_t * buf, > - tpm_size_t initsize, > - BYTE* initval); > - > -// make an alias to a constant array, no copying > -TPM_RESULT buffer_init_const (buffer_t * buf, tpm_size_t size, const BYTE* val); > - > -// make an alias into buf, with given offset and length > -// if len = 0, make the alias go to the end of buf > -TPM_RESULT buffer_init_alias (buffer_t * buf, const buffer_t * b, > - tpm_size_t offset, tpm_size_t); > - > -// make an alias buffer into a bytestream > -TPM_RESULT buffer_init_alias_convert (buffer_t * buf, > - tpm_size_t size, BYTE* val); > - > -// "copy constructor" > -TPM_RESULT buffer_init_copy (buffer_t * buf, const buffer_t * src); > - > - > -// copy into the start of a > -TPM_RESULT buffer_copy (buffer_t * dest, const buffer_t* src); > - > -// are they equal? > -BOOL buffer_eq (const buffer_t * a, const buffer_t * b); > - > -// set the buffer to a constant byte > -void buffer_memset (buffer_t * buf, BYTE b); > - > -tpm_size_t buffer_len (const buffer_t* buf); > - > -TPM_RESULT buffer_free (buffer_t * buf); > - > -TPM_RESULT buffer_append_raw (buffer_t * buf, tpm_size_t len, const BYTE* bytes); > - > -#endif // _TOOLS_H_ > diff --git a/tools/vtpm_manager/util/hashtable.c b/tools/vtpm_manager/util/hashtable.c > deleted file mode 100644 > index aff0e2b..0000000 > --- a/tools/vtpm_manager/util/hashtable.c > +++ /dev/null > @@ -1,316 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable.c > - * - tools/blktap2/drivers/hashtable.c > - */ > - > -#include "hashtable.h" > -#include "hashtable_private.h" > -#include > -#include > -#include > -#include > - > -/* > -Credit for primes table: Aaron Krowne > - http://br.endernet.org/~akrowne/ > - http://planetmath.org/encyclopedia/GoodHashTablePrimes.html > -*/ > -static const unsigned int primes[] = { > -53, 97, 193, 389, > -769, 1543, 3079, 6151, > -12289, 24593, 49157, 98317, > -196613, 393241, 786433, 1572869, > -3145739, 6291469, 12582917, 25165843, > -50331653, 100663319, 201326611, 402653189, > -805306457, 1610612741 > -}; > -const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]); > -const float max_load_factor = 0.65; > - > -/*****************************************************************************/ > -struct hashtable * > -create_hashtable(unsigned int minsize, > - unsigned int (*hashf) (void*), > - int (*eqf) (void*,void*)) > -{ > - struct hashtable *h; > - unsigned int pindex, size = primes[0]; > - /* Check requested hashtable isn't too large */ > - if (minsize > (1u << 30)) return NULL; > - /* Enforce size as prime */ > - for (pindex=0; pindex < prime_table_length; pindex++) { > - if (primes[pindex] > minsize) { size = primes[pindex]; break; } > - } > - h = (struct hashtable *)malloc(sizeof(struct hashtable)); > - if (NULL == h) return NULL; /*oom*/ > - h->table = (struct entry **)malloc(sizeof(struct entry*) * size); > - if (NULL == h->table) { free(h); return NULL; } /*oom*/ > - memset(h->table, 0, size * sizeof(struct entry *)); > - h->tablelength = size; > - h->primeindex = pindex; > - h->entrycount = 0; > - h->hashfn = hashf; > - h->eqfn = eqf; > - h->loadlimit = (unsigned int) ceil(size * max_load_factor); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_init(&h->mutex, NULL); > -#endif > - return h; > -} > - > -/*****************************************************************************/ > -unsigned int > -hash(struct hashtable *h, void *k) > -{ > - unsigned int i = h->hashfn(k); > - i += ~(i << 9); > - i ^= ((i >> 14) | (i << 18)); /* >>> */ > - i += (i << 4); > - i ^= ((i >> 10) | (i << 22)); /* >>> */ > - return i; > -} > - > -/*****************************************************************************/ > -static int > -hashtable_expand(struct hashtable *h) > -{ > - /* Double the size of the table to accomodate more entries */ > - struct entry **newtable; > - struct entry *e; > - struct entry **pE; > - unsigned int newsize, i, index; > - /* Check we're not hitting max capacity */ > - if (h->primeindex == (prime_table_length - 1)) return 0; > - newsize = primes[++(h->primeindex)]; > - > - newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize); > - if (NULL != newtable) > - { > - memset(newtable, 0, newsize * sizeof(struct entry *)); > - /* This algorithm is not 'stable'. ie. it reverses the list > - * when it transfers entries between the tables */ > - for (i = 0; i < h->tablelength; i++) { > - while (NULL != (e = h->table[i])) { > - h->table[i] = e->next; > - index = indexFor(newsize,e->h); > - e->next = newtable[index]; > - newtable[index] = e; > - } > - } > - free(h->table); > - h->table = newtable; > - } > - /* Plan B: realloc instead */ > - else > - { > - newtable = (struct entry **) > - realloc(h->table, newsize * sizeof(struct entry *)); > - if (NULL == newtable) { (h->primeindex)--; return 0; } > - h->table = newtable; > - memset(newtable[h->tablelength], 0, newsize - h->tablelength); > - for (i = 0; i < h->tablelength; i++) { > - for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) { > - index = indexFor(newsize,e->h); > - if (index == i) > - { > - pE = &(e->next); > - } > - else > - { > - *pE = e->next; > - e->next = newtable[index]; > - newtable[index] = e; > - } > - } > - } > - } > - h->tablelength = newsize; > - h->loadlimit = (unsigned int) ceil(newsize * max_load_factor); > - return -1; > -} > - > -/*****************************************************************************/ > -unsigned int > -hashtable_count(struct hashtable *h) > -{ > - unsigned int count; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - count = h->entrycount; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return count; > -} > - > -/*****************************************************************************/ > -int > -hashtable_insert(struct hashtable *h, void *k, void *v) > -{ > - /* This method allows duplicate keys - but they shouldn't be used */ > - unsigned int index; > - struct entry *e; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - if (++(h->entrycount) > h->loadlimit) > - { > - /* Ignore the return value. If expand fails, we should > - * still try cramming just this value into the existing table > - * -- we may not have memory for a larger table, but one more > - * element may be ok. Next time we insert, we'll try expanding again.*/ > - hashtable_expand(h); > - } > - e = (struct entry *)malloc(sizeof(struct entry)); > - if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ > - e->h = hash(h,k); > - index = indexFor(h->tablelength,e->h); > - e->k = k; > - e->v = v; > - e->next = h->table[index]; > - h->table[index] = e; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return -1; > -} > - > -/*****************************************************************************/ > -void * /* returns value associated with key */ > -hashtable_search(struct hashtable *h, void *k) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e; > - unsigned int hashvalue, index; > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hashvalue); > - e = h->table[index]; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) { > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return e->v; > - } > - e = e->next; > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return NULL; > -} > - > -/*****************************************************************************/ > -void * /* returns value associated with key */ > -hashtable_remove(struct hashtable *h, void *k) > -{ > - /* TODO: consider compacting the table when the load factor drops enough, > - * or provide a 'compact' method. */ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e; > - struct entry **pE; > - void *v; > - unsigned int hashvalue, index; > - > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hash(h,k)); > - pE = &(h->table[index]); > - e = *pE; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > - { > - *pE = e->next; > - h->entrycount--; > - v = e->v; > - freekey(e->k); > - free(e); > - return v; > - } > - pE = &(e->next); > - e = e->next; > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return NULL; > -} > - > -/*****************************************************************************/ > -/* destroy */ > -void > -hashtable_destroy(struct hashtable *h, int free_values) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - unsigned int i; > - struct entry *e, *f; > - struct entry **table = h->table; > - if (free_values) > - { > - for (i = 0; i < h->tablelength; i++) > - { > - e = table[i]; > - while (NULL != e) > - { f = e; e = e->next; freekey(f->k); free(f->v); free(f); } > - } > - } > - else > - { > - for (i = 0; i < h->tablelength; i++) > - { > - e = table[i]; > - while (NULL != e) > - { f = e; e = e->next; freekey(f->k); free(f); } > - } > - } > - free(h->table); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_destroy(&h->mutex); > -#endif > - free(h); > -} > diff --git a/tools/vtpm_manager/util/hashtable.h b/tools/vtpm_manager/util/hashtable.h > deleted file mode 100644 > index dedc60a..0000000 > --- a/tools/vtpm_manager/util/hashtable.h > +++ /dev/null > @@ -1,204 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable.h > - * - tools/blktap2/drivers/hashtable.h > - */ > - > -#ifndef __HASHTABLE_CWC22_H__ > -#define __HASHTABLE_CWC22_H__ > - > -struct hashtable; > - > -/* Example of use: > - * > - * struct hashtable *h; > - * struct some_key *k; > - * struct some_value *v; > - * > - * static unsigned int hash_from_key_fn( void *k ); > - * static int keys_equal_fn ( void *key1, void *key2 ); > - * > - * h = create_hashtable(16, hash_from_key_fn, keys_equal_fn); > - * k = (struct some_key *) malloc(sizeof(struct some_key)); > - * v = (struct some_value *) malloc(sizeof(struct some_value)); > - * > - * (initialise k and v to suitable values) > - * > - * if (! hashtable_insert(h,k,v) ) > - * { exit(-1); } > - * > - * if (NULL == (found = hashtable_search(h,k) )) > - * { printf("not found!"); } > - * > - * if (NULL == (found = hashtable_remove(h,k) )) > - * { printf("Not found\n"); } > - * > - */ > - > -/* Macros may be used to define type-safe(r) hashtable access functions, with > - * methods specialized to take known key and value types as parameters. > - * > - * Example: > - * > - * Insert this at the start of your file: > - * > - * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value); > - * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value); > - * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value); > - * > - * This defines the functions 'insert_some', 'search_some' and 'remove_some'. > - * These operate just like hashtable_insert etc., with the same parameters, > - * but their function signatures have 'struct some_key *' rather than > - * 'void *', and hence can generate compile time errors if your program is > - * supplying incorrect data as a key (and similarly for value). > - * > - * Note that the hash and key equality functions passed to create_hashtable > - * still take 'void *' parameters instead of 'some key *'. This shouldn't be > - * a difficult issue as they're only defined and passed once, and the other > - * functions will ensure that only valid keys are supplied to them. > - * > - * The cost for this checking is increased code size and runtime overhead > - * - if performance is important, it may be worth switching back to the > - * unsafe methods once your program has been debugged with the safe methods. > - * This just requires switching to some simple alternative defines - eg: > - * #define insert_some hashtable_insert > - * > - */ > - > -/***************************************************************************** > - * create_hashtable > - > - * @name create_hashtable > - * @param minsize minimum initial size of hashtable > - * @param hashfunction function for hashing keys > - * @param key_eq_fn function for determining key equality > - * @return newly created hashtable or NULL on failure > - */ > - > -struct hashtable * > -create_hashtable(unsigned int minsize, > - unsigned int (*hashfunction) (void*), > - int (*key_eq_fn) (void*,void*)); > - > -/***************************************************************************** > - * hashtable_insert > - > - * @name hashtable_insert > - * @param h the hashtable to insert into > - * @param k the key - hashtable claims ownership and will free on removal > - * @param v the value - does not claim ownership > - * @return non-zero for successful insertion > - * > - * This function will cause the table to expand if the insertion would take > - * the ratio of entries to table size over the maximum load factor. > - * > - * This function does not check for repeated insertions with a duplicate key. > - * The value returned when using a duplicate key is undefined -- when > - * the hashtable changes size, the order of retrieval of duplicate key > - * entries is reversed. > - * If in doubt, remove before insert. > - */ > - > -int > -hashtable_insert(struct hashtable *h, void *k, void *v); > - > -#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \ > -int fnname (struct hashtable *h, keytype *k, valuetype *v) \ > -{ \ > - return hashtable_insert(h,k,v); \ > -} > - > -/***************************************************************************** > - * hashtable_search > - > - * @name hashtable_search > - * @param h the hashtable to search > - * @param k the key to search for - does not claim ownership > - * @return the value associated with the key, or NULL if none found > - */ > - > -void * > -hashtable_search(struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \ > -valuetype * fnname (struct hashtable *h, keytype *k) \ > -{ \ > - return (valuetype *) (hashtable_search(h,k)); \ > -} > - > -/***************************************************************************** > - * hashtable_remove > - > - * @name hashtable_remove > - * @param h the hashtable to remove the item from > - * @param k the key to search for - does not claim ownership > - * @return the value associated with the key, or NULL if none found > - */ > - > -void * /* returns value */ > -hashtable_remove(struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \ > -valuetype * fnname (struct hashtable *h, keytype *k) \ > -{ \ > - return (valuetype *) (hashtable_remove(h,k)); \ > -} > - > - > -/***************************************************************************** > - * hashtable_count > - > - * @name hashtable_count > - * @param h the hashtable > - * @return the number of items stored in the hashtable > - */ > -unsigned int > -hashtable_count(struct hashtable *h); > - > - > -/***************************************************************************** > - * hashtable_destroy > - > - * @name hashtable_destroy > - * @param h the hashtable > - * @param free_values whether to call 'free' on the remaining values > - */ > - > -void > -hashtable_destroy(struct hashtable *h, int free_values); > - > -#endif /* __HASHTABLE_CWC22_H__ */ > diff --git a/tools/vtpm_manager/util/hashtable_itr.c b/tools/vtpm_manager/util/hashtable_itr.c > deleted file mode 100644 > index dcf42c8..0000000 > --- a/tools/vtpm_manager/util/hashtable_itr.c > +++ /dev/null > @@ -1,236 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/blktap2/drivers/hashtable_itr.c > - */ > - > -#include "hashtable.h" > -#include "hashtable_private.h" > -#include "hashtable_itr.h" > -#include /* defines NULL */ > - > -/*****************************************************************************/ > -/* hashtable_iterator - iterator constructor */ > - > -struct hashtable_itr * > -hashtable_iterator(struct hashtable *h) > -{ > - unsigned int i, tablelength; > - struct hashtable_itr *itr = (struct hashtable_itr *) > - malloc(sizeof(struct hashtable_itr)); > - if (NULL == itr) return NULL; > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - itr->h = h; > - itr->e = NULL; > - itr->parent = NULL; > - tablelength = h->tablelength; > - itr->index = tablelength; > - if (0 == h->entrycount) { > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return itr; > - } > - > - for (i = 0; i < tablelength; i++) > - { > - if (NULL != h->table[i]) > - { > - itr->e = h->table[i]; > - itr->index = i; > - break; > - } > - } > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return itr; > -} > - > -/*****************************************************************************/ > -/* key - return the key of the (key,value) pair at the current position */ > -/* value - return the value of the (key,value) pair at the current position */ > - > -void * > -hashtable_iterator_key(struct hashtable_itr *i) > -{ return i->e->k; } > - > -void * > -hashtable_iterator_value(struct hashtable_itr *i) > -{ return i->e->v; } > - > -/*****************************************************************************/ > -/* advance - advance the iterator to the next element > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_advance(struct hashtable_itr *itr) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&itr->h->mutex); > -#endif > - unsigned int j,tablelength; > - struct entry **table; > - struct entry *next; > - int ret; > - if (NULL == itr->e) { /* stupidity check */ > - ret = 0; > - goto egress; > - } > - > - next = itr->e->next; > - if (NULL != next) > - { > - itr->parent = itr->e; > - itr->e = next; > - ret = -1; > - goto egress; > - } > - > - tablelength = itr->h->tablelength; > - itr->parent = NULL; > - if (tablelength <= (j = ++(itr->index))) > - { > - itr->e = NULL; > - ret = 0; > - goto egress; > - } > - table = itr->h->table; > - while (NULL == (next = table[j])) > - { > - if (++j >= tablelength) > - { > - itr->index = tablelength; > - itr->e = NULL; > - ret = 0; > - goto egress; > - } > - } > - itr->index = j; > - itr->e = next; > - ret = -1; > - > - egress: > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&itr->h->mutex); > -#endif > - return ret; > -} > - > -/*****************************************************************************/ > -/* remove - remove the entry at the current iterator position > - * and advance the iterator, if there is a successive > - * element. > - * If you want the value, read it before you remove: > - * beware memory leaks if you don't. > - * Returns zero if end of iteration. */ > - > -int > -hashtable_iterator_remove(struct hashtable_itr *itr) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&itr->h->mutex); > -#endif > - struct entry *remember_e, *remember_parent; > - int ret; > - > - /* Do the removal */ > - if (NULL == (itr->parent)) > - { > - /* element is head of a chain */ > - itr->h->table[itr->index] = itr->e->next; > - } else { > - /* element is mid-chain */ > - itr->parent->next = itr->e->next; > - } > - /* itr->e is now outside the hashtable */ > - remember_e = itr->e; > - itr->h->entrycount--; > - freekey(remember_e->k); > - > - /* Advance the iterator, correcting the parent */ > - remember_parent = itr->parent; > - ret = hashtable_iterator_advance(itr); > - if (itr->parent == remember_e) { itr->parent = remember_parent; } > - free(remember_e); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&itr->h->mutex); > -#endif > - return ret; > -} > - > -/*****************************************************************************/ > -int /* returns zero if not found */ > -hashtable_iterator_search(struct hashtable_itr *itr, > - struct hashtable *h, void *k) > -{ > -#ifdef HASHTABLE_THREADED > - pthread_mutex_lock(&h->mutex); > -#endif > - struct entry *e, *parent; > - unsigned int hashvalue, index; > - int ret; > - > - hashvalue = hash(h,k); > - index = indexFor(h->tablelength,hashvalue); > - > - e = h->table[index]; > - parent = NULL; > - while (NULL != e) > - { > - /* Check hash value to short circuit heavier comparison */ > - if ((hashvalue == e->h) && (h->eqfn(k, e->k))) > - { > - itr->index = index; > - itr->e = e; > - itr->parent = parent; > - itr->h = h; > - ret= -1; > - goto egress; > - } > - parent = e; > - e = e->next; > - } > - ret = 0; > - > -egress: > -#ifdef HASHTABLE_THREADED > - pthread_mutex_unlock(&h->mutex); > -#endif > - return ret; > -} > diff --git a/tools/vtpm_manager/util/hashtable_itr.h b/tools/vtpm_manager/util/hashtable_itr.h > deleted file mode 100644 > index 35654e0..0000000 > --- a/tools/vtpm_manager/util/hashtable_itr.h > +++ /dev/null > @@ -1,109 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/blktap2/drivers/hashtable_itr.h > - */ > - > - > -#ifndef __HASHTABLE_ITR_CWC22__ > -#define __HASHTABLE_ITR_CWC22__ > -#include "hashtable.h" > -#include "hashtable_private.h" /* needed to enable inlining */ > - > -/*****************************************************************************/ > -/* This struct is only concrete here to allow the inlining of two of the > - * accessor functions. */ > -struct hashtable_itr > -{ > - struct hashtable *h; > - struct entry *e; > - struct entry *parent; > - unsigned int index; > -}; > - > - > -/*****************************************************************************/ > -/* hashtable_iterator > - */ > - > -struct hashtable_itr * > -hashtable_iterator(struct hashtable *h); > - > -/*****************************************************************************/ > -/* hashtable_iterator_key > - * - return the value of the (key,value) pair at the current position */ > - > -void *hashtable_iterator_key(struct hashtable_itr *i); > - > -/*****************************************************************************/ > -/* value - return the value of the (key,value) pair at the current position */ > - > -void *hashtable_iterator_value(struct hashtable_itr *i); > - > -/*****************************************************************************/ > -/* advance - advance the iterator to the next element > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_advance(struct hashtable_itr *itr); > - > -/*****************************************************************************/ > -/* remove - remove current element and advance the iterator to the next element > - * NB: if you need the value to free it, read it before > - * removing. ie: beware memory leaks! > - * returns zero if advanced to end of table */ > - > -int > -hashtable_iterator_remove(struct hashtable_itr *itr); > - > -/*****************************************************************************/ > -/* search - overwrite the supplied iterator, to point to the entry > - * matching the supplied key. > - h points to the hashtable to be searched. > - * returns zero if not found. */ > -int > -hashtable_iterator_search(struct hashtable_itr *itr, > - struct hashtable *h, void *k); > - > -#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \ > -int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \ > -{ \ > - return (hashtable_iterator_search(i,h,k)); \ > -} > - > - > - > -#endif /* __HASHTABLE_ITR_CWC22__*/ > diff --git a/tools/vtpm_manager/util/hashtable_private.h b/tools/vtpm_manager/util/hashtable_private.h > deleted file mode 100644 > index d87a7f9..0000000 > --- a/tools/vtpm_manager/util/hashtable_private.h > +++ /dev/null > @@ -1,96 +0,0 @@ > -/* > - * Copyright (c) 2005, Intel Corp > - * Copyright (c) 2002, Christopher Clark > - * 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 the original author; nor the names of any 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. > -*/ > - > -/* > - * There are duplicates of this code in: > - * - tools/xenstore/hashtable_private.h > - * - tools/blktap2/drivers/hashtable_private.h > - */ > - > -#ifndef __HASHTABLE_PRIVATE_CWC22_H__ > -#define __HASHTABLE_PRIVATE_CWC22_H__ > - > -#include "hashtable.h" > -#ifdef HASHTABLE_THREADED > -#include > -#endif > - > -/*****************************************************************************/ > -struct entry > -{ > - void *k, *v; > - unsigned int h; > - struct entry *next; > -}; > - > -struct hashtable { > - unsigned int tablelength; > - struct entry **table; > - unsigned int entrycount; > - unsigned int loadlimit; > - unsigned int primeindex; > - unsigned int (*hashfn) (void *k); > - int (*eqfn) (void *k1, void *k2); > -#ifdef HASHTABLE_THREADED > - pthread_mutex_t mutex; > -#endif > -}; > - > -/*****************************************************************************/ > -unsigned int > -hash(struct hashtable *h, void *k); > - > -/*****************************************************************************/ > -/* indexFor */ > -static inline unsigned int > -indexFor(unsigned int tablelength, unsigned int hashvalue) { > - return (hashvalue % tablelength); > -}; > - > -/* Only works if tablelength == 2^N */ > -/*static inline unsigned int > -indexFor(unsigned int tablelength, unsigned int hashvalue) > -{ > - return (hashvalue & (tablelength - 1u)); > -} > -*/ > - > -/*****************************************************************************/ > -#define freekey(X) free(X) > -/*define freekey(X) ; */ > - > - > -/*****************************************************************************/ > - > -#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/ > diff --git a/tools/vtpm_manager/util/log.c b/tools/vtpm_manager/util/log.c > deleted file mode 100644 > index 75fe91a..0000000 > --- a/tools/vtpm_manager/util/log.c > +++ /dev/null > @@ -1,142 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > - > -#include > -#include > -#include > - > -#include "buffer.h" > -#include "tcg.h" > - > -// Helper code for the consts, eg. to produce messages for error codes. > - > -typedef struct error_code_entry_t { > - TPM_RESULT code; > - char * code_name; > - char * msg; > -} error_code_entry_t; > - > -static const error_code_entry_t error_msgs [] = { > - { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, > - { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, > - { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, > - { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, > - { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, > - { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, > - { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, > - { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, > - { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, > - { TPM_FAIL, "TPM_FAIL", "The operation failed" }, > - { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, > - { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, > - { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, > - { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, > - { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, > - { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, > - { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, > - { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, > - { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, > - { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, > - { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, > - { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, > - { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, > - { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, > - { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, > - { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, > - { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, > - { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, > - { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, > - { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, > - { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, > - { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, > - { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, > - { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, > - { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, > - { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, > - { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, > - { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, > - { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, > - { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, > - { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, > - > - { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, > - { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, > - { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, > - { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, > - { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, > - { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, > - { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, > - { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, > - { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, > - { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, > - { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, > - { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, > - { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, > - { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, > - { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, > - { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, > - { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, > - { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, > - { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, > - { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, > - { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, > - { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, > - { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, > - { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, > - { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, > - { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, > - { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, > - { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, > - { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, > - { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, > - { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, > - { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, > - { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, > - { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, > - { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, > - { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, > - { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, > - { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, > -}; > - > - > -// helper function for the error codes: > -const char* tpm_get_error_name (TPM_RESULT code) { > - // just do a linear scan for now > - unsigned i; > - for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) > - if (code == error_msgs[i].code) > - return error_msgs[i].code_name; > - > - return("Unknown Error Code"); > -} > diff --git a/tools/vtpm_manager/util/log.h b/tools/vtpm_manager/util/log.h > deleted file mode 100644 > index 1f15f5b..0000000 > --- a/tools/vtpm_manager/util/log.h > +++ /dev/null > @@ -1,94 +0,0 @@ > -// =================================================================== > -// > -// 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_LOG_H__ > -#define __VTPM_LOG_H__ > - > -#include // for uint32_t > -#include // for pointer NULL > - > -// =========================== LOGGING ============================== > - > -// the logging module numbers > -#define VTPM_LOG_CRYPTO 1 > -#define VTPM_LOG_BSG 2 > -#define VTPM_LOG_TXDATA 3 > -#define VTPM_LOG_TCS 4 > -#define VTPM_LOG_TCS_DEEP 5 > -#define VTPM_LOG_VTSP 6 > -#define VTPM_LOG_VTPM 7 > -#define VTPM_LOG_VTPM_DEEP 8 > -#define VTPM_LOG_VTSP_DEEP 9 > - > -static char *module_names[] = { "", > - "CRYPTO", > - "BSG", > - "TXDATA", > - "TCS", > - "TCS", > - "VTSP", > - "VTPM", > - "VTPM", > - "VTSP" > - }; > - > -// Default to standard logging > -#ifndef LOGGING_MODULES > -#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)) > -#endif > - > -// bit-access macros > -#define BITMASK(idx) ( 1U << (idx) ) > -#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) > -#define SETBIT(num,idx) (num) |= BITMASK(idx) > -#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) > - > -#define vtpmloginfo(module, fmt, args...) \ > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > - fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ > - } > - > -#define vtpmloginfomore(module, fmt, args...) \ > - if (GETBIT (LOGGING_MODULES, module) == 1) { \ > - fprintf (stdout, fmt,##args); \ > - } > - > -#define vtpmlogerror(module, fmt, args...) \ > - fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); > - > -//typedef UINT32 tpm_size_t; > - > -// helper function for the error codes: > -const char* tpm_get_error_name (TPM_RESULT code); > - > -#endif // _VTPM_LOG_H_ > diff --git a/tools/vtpm_manager/util/tcg.h b/tools/vtpm_manager/util/tcg.h > deleted file mode 100644 > index 5c42913..0000000 > --- a/tools/vtpm_manager/util/tcg.h > +++ /dev/null > @@ -1,503 +0,0 @@ > -// =================================================================== > -// > -// 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. > -// =================================================================== > -// > -// tcg.h > -// > -// This file contains all the structure and type definitions > -// > -// ================================================================== > - > -#ifndef __TCG_H__ > -#define __TCG_H__ > - > -// This pragma is used to disallow structure padding > -#pragma pack(push, 1) > - > -// *************************** TYPEDEFS ********************************* > -typedef unsigned char BYTE; > -typedef unsigned char BOOL; > -typedef unsigned short UINT16; > -typedef unsigned int UINT32; > -typedef unsigned long long UINT64; > - > -typedef UINT32 TPM_RESULT; > -typedef UINT32 TPM_PCRINDEX; > -typedef UINT32 TPM_DIRINDEX; > -typedef UINT32 TPM_HANDLE; > -typedef TPM_HANDLE TPM_AUTHHANDLE; > -typedef TPM_HANDLE TCPA_HASHHANDLE; > -typedef TPM_HANDLE TCPA_HMACHANDLE; > -typedef TPM_HANDLE TCPA_ENCHANDLE; > -typedef TPM_HANDLE TPM_KEY_HANDLE; > -typedef TPM_HANDLE TCPA_ENTITYHANDLE; > -typedef UINT32 TPM_RESOURCE_TYPE; > -typedef UINT32 TPM_COMMAND_CODE; > -typedef UINT16 TPM_PROTOCOL_ID; > -typedef BYTE TPM_AUTH_DATA_USAGE; > -typedef UINT16 TPM_ENTITY_TYPE; > -typedef UINT32 TPM_ALGORITHM_ID; > -typedef UINT16 TPM_KEY_USAGE; > -typedef UINT16 TPM_STARTUP_TYPE; > -typedef UINT32 TPM_CAPABILITY_AREA; > -typedef UINT16 TPM_ENC_SCHEME; > -typedef UINT16 TPM_SIG_SCHEME; > -typedef UINT16 TPM_MIGRATE_SCHEME; > -typedef UINT16 TPM_PHYSICAL_PRESENCE; > -typedef UINT32 TPM_KEY_FLAGS; > - > -#define TPM_DIGEST_SIZE 20 // Don't change this > -typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; > -typedef TPM_AUTHDATA TPM_SECRET; > -typedef TPM_AUTHDATA TPM_ENCAUTH; > -typedef BYTE TPM_PAYLOAD_TYPE; > -typedef UINT16 TPM_TAG; > - > -// Data Types of the TCS > -typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session > -typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle > -typedef UINT32 TCS_KEY_HANDLE; // Basic key handle > - > -// ************************* STRUCTURES ********************************** > - > -typedef struct TPM_VERSION { > - BYTE major; > - BYTE minor; > - BYTE revMajor; > - BYTE revMinor; > -} TPM_VERSION; > - > -static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; > - > -typedef struct TPM_DIGEST { > - BYTE digest[TPM_DIGEST_SIZE]; > -} TPM_DIGEST; > - > -typedef TPM_DIGEST TPM_PCRVALUE; > -typedef TPM_DIGEST TPM_COMPOSITE_HASH; > -typedef TPM_DIGEST TPM_DIRVALUE; > -typedef TPM_DIGEST TPM_HMAC; > -typedef TPM_DIGEST TPM_CHOSENID_HASH; > - > -typedef struct TPM_NONCE { > - BYTE nonce[TPM_DIGEST_SIZE]; > -} TPM_NONCE; > - > -typedef struct TPM_KEY_PARMS { > - TPM_ALGORITHM_ID algorithmID; > - TPM_ENC_SCHEME encScheme; > - TPM_SIG_SCHEME sigScheme; > - UINT32 parmSize; > - BYTE* parms; > -} TPM_KEY_PARMS; > - > -typedef struct TPM_RSA_KEY_PARMS { > - UINT32 keyLength; > - UINT32 numPrimes; > - UINT32 exponentSize; > - BYTE* exponent; > -} TPM_RSA_KEY_PARMS; > - > -typedef struct TPM_STORE_PUBKEY { > - UINT32 keyLength; > - BYTE* key; > -} TPM_STORE_PUBKEY; > - > -typedef struct TPM_PUBKEY { > - TPM_KEY_PARMS algorithmParms; > - TPM_STORE_PUBKEY pubKey; > -} TPM_PUBKEY; > - > -typedef struct TPM_KEY { > - TPM_VERSION ver; > - TPM_KEY_USAGE keyUsage; > - TPM_KEY_FLAGS keyFlags; > - TPM_AUTH_DATA_USAGE authDataUsage; > - TPM_KEY_PARMS algorithmParms; > - UINT32 PCRInfoSize; > - BYTE* PCRInfo; // this should be a TPM_PCR_INFO, or NULL > - TPM_STORE_PUBKEY pubKey; > - UINT32 encDataSize; > - BYTE* encData; > -} TPM_KEY; > - > -typedef struct TPM_PCR_SELECTION { > - UINT16 sizeOfSelect; /// in bytes > - BYTE* pcrSelect; > -} TPM_PCR_SELECTION; > - > -typedef struct TPM_PCR_COMPOSITE { > - TPM_PCR_SELECTION select; > - UINT32 valueSize; > - TPM_PCRVALUE* pcrValue; > -} TPM_PCR_COMPOSITE; > - > - > -typedef struct TPM_PCR_INFO { > - TPM_PCR_SELECTION pcrSelection; > - TPM_COMPOSITE_HASH digestAtRelease; > - TPM_COMPOSITE_HASH digestAtCreation; > -} TPM_PCR_INFO; > - > - > -typedef struct TPM_BOUND_DATA { > - TPM_VERSION ver; > - TPM_PAYLOAD_TYPE payload; > - BYTE* payloadData; > -} TPM_BOUND_DATA; > - > -typedef struct TPM_STORED_DATA { > - TPM_VERSION ver; > - UINT32 sealInfoSize; > - BYTE* sealInfo; > - UINT32 encDataSize; > - BYTE* encData; > -} TPM_STORED_DATA; > - > -typedef struct TCS_AUTH { > - TCS_AUTHHANDLE AuthHandle; > - TPM_NONCE NonceOdd; // system > - TPM_NONCE NonceEven; // TPM > - BOOL fContinueAuthSession; > - TPM_AUTHDATA HMAC; > -} TCS_AUTH; > - > -// structures for dealing with sizes followed by buffers in all the > -// TCG structure. > -typedef struct pack_buf_t { > - UINT32 size; > - BYTE * data; > -} pack_buf_t; > - > -typedef struct pack_constbuf_t { > - UINT32 size; > - const BYTE* data; > -} pack_constbuf_t; > - > - > - > -// **************************** CONSTANTS ********************************* > - > -// BOOL values > -#define TRUE 0x01 > -#define FALSE 0x00 > - > -#define TCPA_MAX_BUFFER_LENGTH 0x2000 > - > -// > -// TPM_COMMAND_CODE values > -#define TPM_PROTECTED_ORDINAL 0x00000000UL > -#define TPM_UNPROTECTED_ORDINAL 0x80000000UL > -#define TPM_CONNECTION_ORDINAL 0x40000000UL > -#define TPM_VENDOR_ORDINAL 0x20000000UL > - > -#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) > -#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) > -#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) > - > - > - > -// > -// TPM_RESULT values > -// > -// just put in the whole table from spec 1.2 > - > -#define TPM_BASE 0x0 // The start of TPM return codes > -#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands > -#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. > - > -#define TPM_SUCCESS TPM_BASE // Successful completion of the operation > -#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed > -#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect > -#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad > -#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. > -#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access > -#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated > -#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled > -#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled > -#define TPM_FAIL TPM_BASE + 9 // The operation failed > -#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent > -#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled > -#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid > -#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found > -#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme > -#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed > -#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted > -#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. > -#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set > -#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM > -#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner > -#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. > -#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short > -#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. > -#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. > -#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value > -#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. > -#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. > -#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. > -#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization > -#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid > -#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM > -#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. > -#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. > -#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. > -#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed > -#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed > -#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed > -#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup > -#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information > -#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM > - > -#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. > -#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. > -#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key > -#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. > -#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value > -#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability > -#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions > -#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also > -#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success > -#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute > -#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport > -#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed > -#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource > -#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode > -#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID > -#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available > -#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command > -#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key > -#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization > -#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable > -#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation > -#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to > -#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area > -#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match > -#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to > -#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict > -#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent > -#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. > -#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect > -#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area > -#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large > -#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded > -#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set > -#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded > -#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked > -#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family > -#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled > -#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session > - > -// TPM_STARTUP_TYPE values > -#define TPM_ST_CLEAR 0x0001 > -#define TPM_ST_STATE 0x0002 > -#define TPM_ST_DEACTIVATED 0x003 > - > -// TPM_TAG values > -#define TPM_TAG_RQU_COMMAND 0x00c1 > -#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 > -#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 > -#define TPM_TAG_RSP_COMMAND 0x00c4 > -#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 > -#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 > - > -// TPM_PAYLOAD_TYPE values > -#define TPM_PT_ASYM 0x01 > -#define TPM_PT_BIND 0x02 > -#define TPM_PT_MIGRATE 0x03 > -#define TPM_PT_MAINT 0x04 > -#define TPM_PT_SEAL 0x05 > - > -// TPM_ENTITY_TYPE values > -#define TPM_ET_KEYHANDLE 0x0001 > -#define TPM_ET_OWNER 0x0002 > -#define TPM_ET_DATA 0x0003 > -#define TPM_ET_SRK 0x0004 > -#define TPM_ET_KEY 0x0005 > - > -/// TPM_ResourceTypes > -#define TPM_RT_KEY 0x00000001 > -#define TPM_RT_AUTH 0x00000002 > -#define TPM_RT_TRANS 0x00000004 > -#define TPM_RT_CONTEXT 0x00000005 > - > -// TPM_PROTOCOL_ID values > -#define TPM_PID_OIAP 0x0001 > -#define TPM_PID_OSAP 0x0002 > -#define TPM_PID_ADIP 0x0003 > -#define TPM_PID_ADCP 0x0004 > -#define TPM_PID_OWNER 0x0005 > - > -// TPM_ALGORITHM_ID values > -#define TPM_ALG_RSA 0x00000001 > -#define TPM_ALG_DES 0x00000002 > -#define TPM_ALG_3DES 0X00000003 > -#define TPM_ALG_SHA 0x00000004 > -#define TPM_ALG_HMAC 0x00000005 > -#define TCPA_ALG_AES 0x00000006 > - > -// TPM_ENC_SCHEME values > -#define TPM_ES_NONE 0x0001 > -#define TPM_ES_RSAESPKCSv15 0x0002 > -#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 > - > -// TPM_SIG_SCHEME values > -#define TPM_SS_NONE 0x0001 > -#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 > -#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 > - > -// TPM_KEY_USAGE values > -#define TPM_KEY_EK 0x0000 > -#define TPM_KEY_SIGNING 0x0010 > -#define TPM_KEY_STORAGE 0x0011 > -#define TPM_KEY_IDENTITY 0x0012 > -#define TPM_KEY_AUTHCHANGE 0X0013 > -#define TPM_KEY_BIND 0x0014 > -#define TPM_KEY_LEGACY 0x0015 > - > -// TPM_AUTH_DATA_USAGE values > -#define TPM_AUTH_NEVER 0x00 > -#define TPM_AUTH_ALWAYS 0x01 > - > -// Key Handle of owner and srk > -#define TPM_OWNER_KEYHANDLE 0x40000001 > -#define TPM_SRK_KEYHANDLE 0x40000000 > - > -// ---------------------- Functions for checking TPM_RESULTs ----------------- > - > -#include > - > -// FIXME: Review use of these and delete unneeded ones. > - > -// these are really badly dependent on local structure: > -// DEPENDS: local var 'status' of type TPM_RESULT > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > -#define ERRORDIE(s) do { status = s; \ > - fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ > - goto abort_egress; } \ > - while (0) > - > -// DEPENDS: local var 'status' of type TPM_RESULT > -// DEPENDS: label 'abort_egress' which cleans up and returns the status > -// Try command c. If it fails, set status to s and goto abort. > -#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ > - status = s; \ > - printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > - goto abort_egress; \ > - } else {\ > - status = c; \ > - } > - > -// Try command c. If it fails, print error message, set status to actual return code. Goto abort > -#define TPMTRYRETURN(c) do { status = c; \ > - if (status != TPM_SUCCESS) { \ > - fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > - goto abort_egress; \ > - } \ > - } while(0) > - > - > -#pragma pack(pop) > - > -#endif //__TCPA_H__ > diff --git a/tools/xenstore/hashtable.c b/tools/xenstore/hashtable.c > index 3b89223..0ba1d55 100644 > --- a/tools/xenstore/hashtable.c > +++ b/tools/xenstore/hashtable.c > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable.c > - * - tools/vtpm_manager/util/hashtable.c > */ > > #include "hashtable.h" > diff --git a/tools/xenstore/hashtable.h b/tools/xenstore/hashtable.h > index 8e6bb5b..4d68223 100644 > --- a/tools/xenstore/hashtable.h > +++ b/tools/xenstore/hashtable.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable.h > - * - tools/vtpm_manager/util/hashtable.h > */ > > #ifndef __HASHTABLE_CWC22_H__ > diff --git a/tools/xenstore/hashtable_private.h b/tools/xenstore/hashtable_private.h > index cabaffe..a08559d 100644 > --- a/tools/xenstore/hashtable_private.h > +++ b/tools/xenstore/hashtable_private.h > @@ -3,7 +3,6 @@ > /* > * There are duplicates of this code in: > * - tools/blktap2/drivers/hashtable_private.h > - * - tools/vtpm_manager/util/hashtable_private.h > */ > > #ifndef __HASHTABLE_PRIVATE_CWC22_H__ > diff --git a/tools/xm-test/configure.ac b/tools/xm-test/configure.ac > index ad1eb78..c142140 100644 > --- a/tools/xm-test/configure.ac > +++ b/tools/xm-test/configure.ac > @@ -143,7 +143,6 @@ AC_CONFIG_FILES([ > tests/unpause/Makefile > tests/vcpu-pin/Makefile > tests/vcpu-disable/Makefile > - tests/vtpm/Makefile > tests/xapi/Makefile > tests/enforce_dom0_cpus/Makefile > tests/cpupool/Makefile > diff --git a/tools/xm-test/grouptest/default b/tools/xm-test/grouptest/default > index f0516b2..e04591b 100644 > --- a/tools/xm-test/grouptest/default > +++ b/tools/xm-test/grouptest/default > @@ -27,5 +27,4 @@ sysrq > unpause > vcpu-disable > vcpu-pin > -vtpm > xapi > diff --git a/tools/xm-test/grouptest/medium b/tools/xm-test/grouptest/medium > index bafc988..5c3e1b1 100644 > --- a/tools/xm-test/grouptest/medium > +++ b/tools/xm-test/grouptest/medium > @@ -22,4 +22,3 @@ sysrq 01_sysrq_basic_neg.test 02_sysrq_sync_pos.test > unpause > vcpu-disable > vcpu-pin > -vtpm > diff --git a/tools/xm-test/grouptest/xapi b/tools/xm-test/grouptest/xapi > index 3b04921..7a08b77 100644 > --- a/tools/xm-test/grouptest/xapi > +++ b/tools/xm-test/grouptest/xapi > @@ -1,2 +1 @@ > xapi > -vtpm 09_vtpm-xapi.test > diff --git a/tools/xm-test/lib/XmTestLib/XenDomain.py b/tools/xm-test/lib/XmTestLib/XenDomain.py > index ae8c550..3ba7433 100644 > --- a/tools/xm-test/lib/XmTestLib/XenDomain.py > +++ b/tools/xm-test/lib/XmTestLib/XenDomain.py > @@ -59,7 +59,6 @@ class XenConfig: > # These options need to be lists > self.defaultOpts["disk"] = [] > self.defaultOpts["vif"] = [] > - self.defaultOpts["vtpm"] = [] > > self.opts = self.defaultOpts > > diff --git a/tools/xm-test/tests/Makefile.am b/tools/xm-test/tests/Makefile.am > index 8d673ed..455f50c 100644 > --- a/tools/xm-test/tests/Makefile.am > +++ b/tools/xm-test/tests/Makefile.am > @@ -25,7 +25,6 @@ SUBDIRS = \ > unpause \ > vcpu-disable \ > vcpu-pin \ > - vtpm \ > enforce_dom0_cpus \ > save restore migrate \ > cpupool > diff --git a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py b/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > deleted file mode 100644 > index dfd1227..0000000 > --- a/tools/xm-test/tests/vtpm/01_vtpm-list_pos.py > +++ /dev/null > @@ -1,40 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# verify list > - > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > - > -try: > - domain.start(noConsole=True) > -except DomainError, e: > - if verbose: > - print e.extra > - vtpm_cleanup(domain.getName()) > - FAIL("Unable to create domain") > - > - > -domName = domain.getName() > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -status, output = traceCommand("xm vtpm-list %s" % domain.getId()) > -eyecatcher = "/local/domain/0/backend/vtpm" > -where = output.find(eyecatcher) > -if status != 0: > - FAIL("xm vtpm-list returned bad status, expected 0, status is %i" % status) > -elif where < 0: > - FAIL("Fail to list virtual TPM device") > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py b/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > deleted file mode 100644 > index a18cbab..0000000 > --- a/tools/xm-test/tests/vtpm/02_vtpm-cat_pcrs.py > +++ /dev/null > @@ -1,49 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -domain.closeConsole() > - > -domain.stop() > - > -if not re.search("PCR-00:",run["output"]): > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > diff --git a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py b/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > deleted file mode 100644 > index b863f27..0000000 > --- a/tools/xm-test/tests/vtpm/03_vtpm-susp_res.py > +++ /dev/null > @@ -1,99 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; suspend and resume the domain and > -# check list of pcrs again > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm save %s %s.save" % > - (domName, domName), > - timeout=30) > - > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm save did not succeed") > - > - try: > - status, ouptut = traceCommand("xm restore %s.save" % > - (domName), > - timeout=30) > - except TimeoutError, e: > - os.remove("%s.save" % domName) > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - os.remove("%s.save" % domName) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm restore did not succeed") > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > - > diff --git a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > deleted file mode 100644 > index ccc8b73..0000000 > --- a/tools/xm-test/tests/vtpm/04_vtpm-loc_migr.py > +++ /dev/null > @@ -1,93 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again > -# This test does local live migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py b/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > deleted file mode 100644 > index 57b87df..0000000 > --- a/tools/xm-test/tests/vtpm/05_vtpm-loc_migr.py > +++ /dev/null > @@ -1,93 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again > -# This test does local (non-live) migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py b/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > deleted file mode 100644 > index c70691d..0000000 > --- a/tools/xm-test/tests/vtpm/06_vtpm-susp_res_pcrs.py > +++ /dev/null > @@ -1,125 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; suspend and resume the domain and > -# check list of pcrs again and validate extended pcr > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm save %s %s.save" % > - (domName, domName), > - timeout=30) > - > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm save did not succeed") > - > - try: > - status, ouptut = traceCommand("xm restore %s.save" % > - (domName), > - timeout=30) > - except TimeoutError, e: > - os.remove("%s.save" % domName) > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - os.remove("%s.save" % domName) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm restore did not succeed") > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > - > diff --git a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > deleted file mode 100644 > index 4ff3360..0000000 > --- a/tools/xm-test/tests/vtpm/07_vtpm-mig_pcrs.py > +++ /dev/null > @@ -1,119 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again and validate extended pcr > -# This test does local live migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate -l %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py b/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > deleted file mode 100644 > index 27125fc..0000000 > --- a/tools/xm-test/tests/vtpm/08_vtpm-mig_pcrs.py > +++ /dev/null > @@ -1,119 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Positive Test: create domain with virtual TPM attached at build time, > -# extend a pcr > -# check list of pcrs; locally migrate the domain and > -# check list of pcrs again and validate extended pcr > -# This test does local (non-live) migration. > - > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > -import os.path > -import atexit > - > -config = {"vtpm":"instance=1,backend=0"} > -domain = XmTestDomain(extraConfig=config) > -domName = domain.getName() > -consoleHistory = "" > - > -try: > - console = domain.start() > -except DomainError, e: > - if verbose: > - print e.extra > - FAIL("Unable to create domain (%s)" % domName) > - > -atexit.register(vtpm_cleanup, vtpm_get_uuid(domid(domName))) > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("mknod /dev/tpm0 c 10 224") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while creating /dev/tpm0") > - > -try: > - run = console.runCmd("echo -ne \"\\x00\\xc1\\x00\\x00\\x00\\x22\\x00\\x00\\x00\\x14\\x00\\x00\\x00\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\0xf\\x10\\x11\\x12\\x13\\x14\" > seq; cat seq > /dev/tpm0") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("Error while extending PCR 0") > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Extend did not lead to expected result (1E A7 BD ...): \n%s" % run["output"]) > - > -consoleHistory = console.getHistory() > -domain.closeConsole() > - > -old_domid = domid(domName) > - > -loop = 0 > -while loop < 3: > - try: > - status, ouptut = traceCommand("xm migrate %s localhost" % > - domName, > - timeout=90) > - except TimeoutError, e: > - saveLog(consoleHistory) > - FAIL(str(e)) > - > - if status != 0: > - saveLog(consoleHistory) > - FAIL("xm migrate did not succeed. External device migration activated?") > - > - > - domName = domain.getName() > - new_domid = domid(domName) > - > - if (old_domid == new_domid): > - FAIL("xm migrate failed, domain id is still %s (loop=%d)" % > - (old_domid,loop)) > - > - try: > - console = domain.getConsole() > - except ConsoleError, e: > - FAIL(str(e)) > - > - try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > - except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("No result from dumping the PCRs") > - > - if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM is not working correctly on /dev/vtpm on backend side") > - > - if not re.search("PCR-00: 1E A7 BD",run["output"]): > - saveLog(console.getHistory()) > - FAIL("Virtual TPM lost PCR 0 value: \n%s" % run["output"]) > - > - loop += 1 > - > -domain.closeConsole() > - > -domain.stop() > diff --git a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py b/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > deleted file mode 100644 > index a1aa8b3..0000000 > --- a/tools/xm-test/tests/vtpm/09_vtpm-xapi.py > +++ /dev/null > @@ -1,158 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -# Test to test the vtpm class through the Xen-API > -# > -# Tested methods: > -# VTPM: get_uuid, get_backend, get_by_uuid, get_record > -# create, destroy, get_VM > -# VM: get_VTPMS > - > -from XmTestLib import xapi > -from XmTestLib.XenAPIDomain import XmTestAPIDomain > -from XmTestLib import * > -from vtpm_utils import * > -import commands > -import os > - > -VTPM_RECORD_KEYS = [ 'backend', 'VM', 'uuid', 'other_config' ] > - > -try: > - # XmTestAPIDomain tries to establish a connection to XenD > - domain = XmTestAPIDomain() > -except Exception, e: > - SKIP("Skipping test. Error: %s" % str(e)) > -vm_uuid = domain.get_uuid() > - > -vtpmcfg = {} > -vtpmcfg['backend'] = DOM0_UUID > -vtpmcfg['VM'] = vm_uuid > - > -session = xapi.connect() > - > -vtpm_uuid = session.xenapi.VTPM.create(vtpmcfg) > - > -vtpm_be = session.xenapi.VTPM.get_backend(vtpm_uuid) > -if vtpm_be != vtpmcfg['backend']: > - FAIL("vTPM's backend is in '%s', expected: '%s'" % > - (vtpm_be, vtpmcfg['backend'])) > - > -vtpm_rec = session.xenapi.VTPM.get_record(vtpm_uuid) > - > -miss_keys = [] > -for k in VTPM_RECORD_KEYS: > - if k not in vtpm_rec.keys(): > - miss_keys.append(k) > -if len(miss_keys) > 0: > - FAIL("vTPM record is missing key(s): %s" % miss_keys) > - > -if vtpm_rec['uuid'] != vtpm_uuid: > - FAIL("vTPM record shows vtpm uuid '%s', expected: '%s'" % > - (vtpm_rec['uuid'], vtpm_uuid)) > -if vtpm_rec['VM'] != vm_uuid: > - FAIL("vTPM record shows VM uuid '%s', expected: '%s'" % > - (vtpm_rec['VM'], vm_uuid)) > -if vtpm_rec['backend'] != vtpmcfg['backend']: > - FAIL("vTPM record shows VM bakcned '%s', expected: '%s'" % > - (vtpm_rev['backend'], vtpmcfg['backend'])) > - > -badkeys = [] > -keys = vtpm_rec.keys() > -for k in keys: > - if k not in VTPM_RECORD_KEYS: > - badkeys.append(k) > -if len(badkeys) > 0: > - FAIL("Unexpected attributes in result: %s" % badkeys) > - > -if vm_uuid != session.xenapi.VTPM.get_VM(vtpm_uuid): > - FAIL("VM uuid from VTPM.get_VM different (%s) than expected (%s)." % > - (vm_ref, vm_uuid)) > - > -uuid = session.xenapi.VTPM.get_uuid(vtpm_uuid) > -if uuid != vtpm_uuid: > - FAIL("vTPM from VTPM.get_uuid different (%s) than expected (%s)." % > - (uuid, vtpm_uuid)) > - > -vtpm_ref = session.xenapi.VTPM.get_by_uuid(vtpm_uuid) > -if vtpm_ref != vtpm_uuid: > - FAIL("vTPM from VTPM.get_by_uuid different (%s) than expected (%s)." % > - (vtpm_ref, vtpm_uuid)) > - > -vm_vtpms = session.xenapi.VM.get_VTPMs(vm_uuid) > -if len(vm_vtpms) != 1: > - FAIL("Number of vTPMs from get_VTPMs is (%d) not what was expected (%d)" % > - (len(vm_vtpms), 1)) > -if vtpm_uuid not in vm_vtpms: > - FAIL("Other vTPM uuid (%s) returned from VM.get_VTPMs than expected (%s)" % > - (vm_vtpms[0], vtpm_uuid)) > - > -try: > - console = domain.start() > -except DomainError, e: > - FAIL("Unable to create domain.") > - > -try: > - console.sendInput("input") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("1. No result from dumping the PCRs") > - > -if re.search("No such file",run["output"]): > - FAIL("TPM frontend support not compiled into (domU?) kernel") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("1. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > - #Should never get here > - FAIL("Could destroy vTPM while VM is running") > -except: > - pass > - > -rc = session.xenapi.VM.suspend(vm_uuid) > -if rc: > - FAIL("Could not suspend VM") > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > - #May not throw an exception in 'suspend' state > -except: > - pass > - > -rc = session.xenapi.VM.resume(vm_uuid, False) > -if rc: > - FAIL("Could not resume VM") > - > -try: > - console = domain.getConsole() > -except ConsoleError, e: > - FAIL(str(e)) > - > -try: > - run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs") > -except ConsoleError, e: > - saveLog(console.getHistory()) > - FAIL("2. No result from dumping the PCRs. vTPM has been removed?") > - > -if not re.search("PCR-00:",run["output"]): > - saveLog(console.getHistory()) > - FAIL("2. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"]) > - > -domain.stop() > - > -try: > - session.xenapi.VTPM.destroy(vtpm_uuid) > -except: > - FAIL("Could NOT destroy vTPM while domain is halted.") > - > -domain.destroy() > diff --git a/tools/xm-test/tests/vtpm/Makefile.am b/tools/xm-test/tests/vtpm/Makefile.am > deleted file mode 100644 > index dd67e45..0000000 > --- a/tools/xm-test/tests/vtpm/Makefile.am > +++ /dev/null > @@ -1,27 +0,0 @@ > -SUBDIRS = > - > -TESTS = 01_vtpm-list_pos.test \ > - 02_vtpm-cat_pcrs.test \ > - 03_vtpm-susp_res.test \ > - 04_vtpm-loc_migr.test \ > - 05_vtpm-loc_migr.test \ > - 06_vtpm-susp_res_pcrs.test \ > - 07_vtpm-mig_pcrs.test \ > - 08_vtpm-mig_pcrs.test \ > - 09_vtpm-xapi.test > - > -XFAIL_TESTS = > - > -EXTRA_DIST = $(TESTS) $(XFAIL_TESTS) vtpm_utils.py > -TESTS_ENVIRONMENT=@TENV@ > - > -%.test: %.py > - cp $< $@ > - chmod +x $@ > - > -clean-local: am_config_clean-local > - > -am_config_clean-local: > - rm -f *test > - rm -f *log > - rm -f *~ > diff --git a/tools/xm-test/tests/vtpm/vtpm_utils.py b/tools/xm-test/tests/vtpm/vtpm_utils.py > deleted file mode 100644 > index 4e5b281..0000000 > --- a/tools/xm-test/tests/vtpm/vtpm_utils.py > +++ /dev/null > @@ -1,30 +0,0 @@ > -#!/usr/bin/python > - > -# Copyright (C) International Business Machines Corp., 2006 > -# Author: Stefan Berger > - > -from XmTestLib import * > - > -if ENABLE_HVM_SUPPORT: > - SKIP("vtpm tests not supported for HVM domains") > - > -status, output = traceCommand("COLUMNS=200 ; " > - "ps aux | grep vtpm_manager | grep -v grep") > -if output == "": > - SKIP("virtual TPM manager must be started to run this test; might " > - "need /dev/tpm0") > - > -def vtpm_cleanup(domName): > - traceCommand("/etc/xen/scripts/vtpm-delete " > - "`xenstore-read /local/domain/0/backend/vtpm/%s/0/uuid`" % > - str(domid(domName))) > - > -def vtpm_cleanup(uuid): > - from xen.xm import main > - if main.serverType != main.SERVER_XEN_API: > - traceCommand("/etc/xen/scripts/vtpm-delete %s" % uuid) > - > -def vtpm_get_uuid(domainid): > - s, o = traceCommand("xenstore-read " > - "/local/domain/0/backend/vtpm/%s/0/uuid" % domainid) > - return o > -- > 1.7.10.4 > _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-changelog-bounces@lists.xen.org Tue Nov 13 16:22:21 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 13 Nov 2012 16:22:21 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFj-0004GD-6d; Tue, 13 Nov 2012 16:22:19 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFg-0004Dp-Tm for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:17 +0000 Received: from [85.158.137.99:24206] by server-14.bemta-3.messagelabs.com id 19/66-12788-8B372A05; Tue, 13 Nov 2012 16:22:16 +0000 X-Env-Sender: xen@xenbits.xen.org X-Msg-Ref: server-14.tower-217.messagelabs.com!1352823730!18827904!1 X-Originating-IP: [50.57.168.107] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 19355 invoked from network); 13 Nov 2012 16:22:11 -0000 Received: from mail.xen.org (HELO mail.xen.org) (50.57.168.107) by server-14.tower-217.messagelabs.com with AES256-SHA encrypted SMTP; 13 Nov 2012 16:22:11 -0000 Received: from xenbits.xen.org ([50.57.170.242]) by mail.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFa-00037o-Dv for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:10 +0000 Received: from xen by xenbits.xen.org with local (Exim 4.72) (envelope-from ) id 1TYJFa-0006i5-9t for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:10 +0000 Message-Id: Date: Tue, 13 Nov 2012 16:22:09 +0000 From: Xen patchbot-unstable To: xen-changelog@lists.xensource.com Subject: [Xen-changelog] [xen-unstable] minios: add tpmfront, tpm_tis, and tpmback drivers X-BeenThere: xen-changelog@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: xen-devel@lists.xensource.com List-Id: "Change log for Mercurial \(receive only\)" 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-changelog-bounces@lists.xen.org Errors-To: xen-changelog-bounces@lists.xen.org # HG changeset patch # User Matthew Fioravante # Date 1352803618 0 # Node ID 34d52300f5d22102d38e8d18067671f0b7ef656e # Parent 3015f8c6174b579ee62ff01cfa177ca33d6dd531 minios: add tpmfront, tpm_tis, and tpmback drivers This patch adds 3 new drivers to mini-os. tpmfront - paravirtualized tpm frontend driver tpmback - paravirtualized tpm backend driver tpm_tis - hardware tpm driver Unfortunately these drivers were derived from GPL licensed linux kernel drivers so they must carry the GPL license. However, since mini-os now supports conditional compilation, hopefully these drivers can be included into the xen tree and conditionally removed from non-gpl projects. By default they are disabled in the makefile. Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell Committed-by: Ian Campbell --- diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/Makefile --- a/extras/mini-os/Makefile Tue Nov 13 10:46:57 2012 +0000 +++ b/extras/mini-os/Makefile Tue Nov 13 10:46:58 2012 +0000 @@ -22,6 +22,9 @@ CONFIG_QEMU_XS_ARGS ?= n CONFIG_TEST ?= n CONFIG_PCIFRONT ?= n CONFIG_BLKFRONT ?= y +CONFIG_TPMFRONT ?= n +CONFIG_TPM_TIS ?= n +CONFIG_TPMBACK ?= n CONFIG_NETFRONT ?= y CONFIG_FBFRONT ?= y CONFIG_KBDFRONT ?= y @@ -36,6 +39,9 @@ flags-$(CONFIG_SPARSE_BSS) += -DCONFIG_S flags-$(CONFIG_QEMU_XS_ARGS) += -DCONFIG_QEMU_XS_ARGS flags-$(CONFIG_PCIFRONT) += -DCONFIG_PCIFRONT flags-$(CONFIG_BLKFRONT) += -DCONFIG_BLKFRONT +flags-$(CONFIG_TPMFRONT) += -DCONFIG_TPMFRONT +flags-$(CONFIG_TPM_TIS) += -DCONFIG_TPM_TIS +flags-$(CONFIG_TPMBACK) += -DCONFIG_TPMBACK flags-$(CONFIG_NETFRONT) += -DCONFIG_NETFRONT flags-$(CONFIG_KBDFRONT) += -DCONFIG_KBDFRONT flags-$(CONFIG_FBFRONT) += -DCONFIG_FBFRONT @@ -67,6 +73,9 @@ TARGET := mini-os SUBDIRS := lib xenbus console src-$(CONFIG_BLKFRONT) += blkfront.c +src-$(CONFIG_TPMFRONT) += tpmfront.c +src-$(CONFIG_TPM_TIS) += tpm_tis.c +src-$(CONFIG_TPMBACK) += tpmback.c src-y += daytime.c src-y += events.c src-$(CONFIG_FBFRONT) += fbfront.c diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/include/lib.h --- a/extras/mini-os/include/lib.h Tue Nov 13 10:46:57 2012 +0000 +++ b/extras/mini-os/include/lib.h Tue Nov 13 10:46:58 2012 +0000 @@ -142,6 +142,8 @@ enum fd_type { FTYPE_FB, FTYPE_MEM, FTYPE_SAVEFILE, + FTYPE_TPMFRONT, + FTYPE_TPM_TIS, }; LIST_HEAD(evtchn_port_list, evtchn_port_info); @@ -185,6 +187,20 @@ extern struct file { struct { struct consfront_dev *dev; } cons; +#ifdef CONFIG_TPMFRONT + struct { + struct tpmfront_dev *dev; + int respgot; + off_t offset; + } tpmfront; +#endif +#ifdef CONFIG_TPM_TIS + struct { + struct tpm_chip *dev; + int respgot; + off_t offset; + } tpm_tis; +#endif #ifdef CONFIG_XENBUS struct { /* To each xenbus FD is associated a queue of watch events for this diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/include/tpm_tis.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/include/tpm_tis.h Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm.c + * from the linux kernel + * + * Copyright (C) 2004 IBM Corporation + * + * This code has also been derived from drivers/char/tpm/tpm_tis.c + * from the linux kernel + * + * Copyright (C) 2005, 2006 IBM Corporation + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#ifndef TPM_TIS_H +#define TPM_TIS_H + +#include +#include + +#define TPM_TIS_EN_LOCL0 1 +#define TPM_TIS_EN_LOCL1 (1 << 1) +#define TPM_TIS_EN_LOCL2 (1 << 2) +#define TPM_TIS_EN_LOCL3 (1 << 3) +#define TPM_TIS_EN_LOCL4 (1 << 4) +#define TPM_TIS_EN_LOCLALL (TPM_TIS_EN_LOCL0 | TPM_TIS_EN_LOCL1 | TPM_TIS_EN_LOCL2 | TPM_TIS_EN_LOCL3 | TPM_TIS_EN_LOCL4) +#define TPM_TIS_LOCL_INT_TO_FLAG(x) (1 << x) +#define TPM_BASEADDR 0xFED40000 +#define TPM_PROBE_IRQ 0xFFFF + +struct tpm_chip; + +struct tpm_chip* init_tpm_tis(unsigned long baseaddr, int localities, unsigned int irq); +void shutdown_tpm_tis(struct tpm_chip* tpm); + +int tpm_tis_request_locality(struct tpm_chip* tpm, int locality); +int tpm_tis_cmd(struct tpm_chip* tpm, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen); + +#ifdef HAVE_LIBC +#include +#include +/* POSIX IO functions: + * use tpm_tis_open() to get a file descriptor to the tpm device + * use write() on the fd to send a command to the backend. You must + * include the entire command in a single call to write(). + * use read() on the fd to read the response. You can use + * fstat() to get the size of the response and lseek() to seek on it. + */ +int tpm_tis_open(struct tpm_chip* tpm); +int tpm_tis_posix_read(int fd, uint8_t* buf, size_t count); +int tpm_tis_posix_write(int fd, const uint8_t* buf, size_t count); +int tpm_tis_posix_fstat(int fd, struct stat* buf); +#endif + +#endif diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/include/tpmback.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/include/tpmback.h Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/xen/tpmback/tpmback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netback/netback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This code has also been derived from drivers/xen/tpmback/xenbus.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2005 IBM Corporation + * Copyright (C) 2005 Rusty Russell + * + * This code has also been derived from drivers/xen/tpmback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself also derived from drvivers/xen/netback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2004, Keir Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ + +#include +#include +#include +#include +#ifndef TPMBACK_H +#define TPMBACK_H + +struct tpmcmd { + domid_t domid; /* Domid of the frontend */ + unsigned int handle; /* Handle of the frontend */ + unsigned char uuid[16]; /* uuid of the tpm interface */ + + unsigned int req_len; /* Size of the command in buf - set by tpmback driver */ + uint8_t* req; /* tpm command bits, allocated by driver, DON'T FREE IT */ + unsigned int resp_len; /* Size of the outgoing command, + you set this before passing the cmd object to tpmback_resp */ + uint8_t* resp; /* Buffer for response - YOU MUST ALLOCATE IT, YOU MUST ALSO FREE IT */ +}; +typedef struct tpmcmd tpmcmd_t; + +/* Initialize the tpm backend driver */ +void init_tpmback(void); + +/* Shutdown tpm backend driver */ +void shutdown_tpmback(void); + +/* Blocks until a tpm command is sent from any front end. + * Returns a pointer to the tpm command to handle. + * Do not try to free this pointer or the req buffer + * This function will return NULL if the tpm backend driver + * is shutdown or any other error occurs */ +tpmcmd_t* tpmback_req_any(void); + +/* Blocks until a tpm command from the frontend at domid/handle + * is sent. + * Returns NULL if domid/handle is not connected, tpmback is + * shutdown or shutting down, or if there is an error + */ +tpmcmd_t* tpmback_req(domid_t domid, unsigned int handle); + +/* Send the response to the tpm command back to the frontend + * This function will free the tpmcmd object, but you must free the resp + * buffer yourself */ +void tpmback_resp(tpmcmd_t* tpmcmd); + +/* Waits for the first frontend to connect and then sets domid and handle appropriately. + * If one or more frontends are already connected, this will set domid and handle to one + * of them arbitrarily. The main use for this function is to wait until a single + * frontend connection has occured. + * returns 0 on success, non-zero on failure */ +int tpmback_wait_for_frontend_connect(domid_t *domid, unsigned int *handle); + +/* returns the number of frontends connected */ +int tpmback_num_frontends(void); + +/* Returns the uuid of the specified frontend, NULL on error. + * The return value is internally allocated, so don't free it */ +unsigned char* tpmback_get_uuid(domid_t domid, unsigned int handle); + +/* Specify a function to call when a new tpm device connects */ +void tpmback_set_open_callback(void (*cb)(domid_t, unsigned int)); + +/* Specify a function to call when a tpm device disconnects */ +void tpmback_set_close_callback(void (*cb)(domid_t, unsigned int)); + +//Not Implemented +void tpmback_set_suspend_callback(void (*cb)(domid_t, unsigned int)); +void tpmback_set_resume_callback(void (*cb)(domid_t, unsigned int)); + +#endif diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/include/tpmfront.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/include/tpmfront.h Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm_vtpm.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2006 IBM Corporation + * + * This code has also been derived from drivers/char/tpm_xen.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netfront/netfront.c + * from the linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, version 2 of the + * License. + */ +#ifndef TPMFRONT_H +#define TPMFRONT_H + +#include +#include +#include +#include +#include +#include +#include + +struct tpmfront_dev { + grant_ref_t ring_ref; + evtchn_port_t evtchn; + + tpmif_tx_interface_t* tx; + + void** pages; + + domid_t bedomid; + char* nodename; + char* bepath; + + XenbusState state; + + uint8_t waiting; + struct wait_queue_head waitq; + + uint8_t* respbuf; + size_t resplen; + +#ifdef HAVE_LIBC + int fd; +#endif + +}; + + +/*Initialize frontend */ +struct tpmfront_dev* init_tpmfront(const char* nodename); +/*Shutdown frontend */ +void shutdown_tpmfront(struct tpmfront_dev* dev); + +/* Send a tpm command to the backend and wait for the response + * + * @dev - frontend device + * @req - request buffer + * @reqlen - length of request buffer + * @resp - *resp will be set to internal response buffer, don't free it! Value is undefined on error + * @resplen - *resplen will be set to the length of the response. Value is undefined on error + * + * returns 0 on success, non zero on failure. + * */ +int tpmfront_cmd(struct tpmfront_dev* dev, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen); + +#ifdef HAVE_LIBC +#include +/* POSIX IO functions: + * use tpmfront_open() to get a file descriptor to the tpm device + * use write() on the fd to send a command to the backend. You must + * include the entire command in a single call to write(). + * use read() on the fd to read the response. You can use + * fstat() to get the size of the response and lseek() to seek on it. + */ +int tpmfront_open(struct tpmfront_dev* dev); +int tpmfront_posix_read(int fd, uint8_t* buf, size_t count); +int tpmfront_posix_write(int fd, const uint8_t* buf, size_t count); +int tpmfront_posix_fstat(int fd, struct stat* buf); +#endif + + +#endif diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/lib/sys.c --- a/extras/mini-os/lib/sys.c Tue Nov 13 10:46:57 2012 +0000 +++ b/extras/mini-os/lib/sys.c Tue Nov 13 10:46:58 2012 +0000 @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include #include @@ -294,6 +296,16 @@ int read(int fd, void *buf, size_t nbyte return blkfront_posix_read(fd, buf, nbytes); } #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: { + return tpmfront_posix_read(fd, buf, nbytes); + } +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: { + return tpm_tis_posix_read(fd, buf, nbytes); + } +#endif default: break; } @@ -330,6 +342,14 @@ int write(int fd, const void *buf, size_ case FTYPE_BLK: return blkfront_posix_write(fd, buf, nbytes); #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + return tpmfront_posix_write(fd, buf, nbytes); +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + return tpm_tis_posix_write(fd, buf, nbytes); +#endif default: break; } @@ -341,8 +361,16 @@ int write(int fd, const void *buf, size_ off_t lseek(int fd, off_t offset, int whence) { switch(files[fd].type) { +#if defined(CONFIG_BLKFRONT) || defined(CONFIG_TPMFRONT) || defined(CONFIG_TPM_TIS) #ifdef CONFIG_BLKFRONT case FTYPE_BLK: +#endif +#ifdef CONFIG_TPMFRNT + case FTYPE_TPMFRONT: +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: +#endif switch (whence) { case SEEK_SET: files[fd].file.offset = offset; @@ -420,6 +448,18 @@ int close(int fd) files[fd].type = FTYPE_NONE; return 0; #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + shutdown_tpmfront(files[fd].tpmfront.dev); + files[fd].type = FTYPE_NONE; + return 0; +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + shutdown_tpm_tis(files[fd].tpm_tis.dev); + files[fd].type = FTYPE_NONE; + return 0; +#endif #ifdef CONFIG_KBDFRONT case FTYPE_KBD: shutdown_kbdfront(files[fd].kbd.dev); @@ -489,6 +529,14 @@ int fstat(int fd, struct stat *buf) case FTYPE_BLK: return blkfront_posix_fstat(fd, buf); #endif +#ifdef CONFIG_TPMFRONT + case FTYPE_TPMFRONT: + return tpmfront_posix_fstat(fd, buf); +#endif +#ifdef CONFIG_TPM_TIS + case FTYPE_TPM_TIS: + return tpm_tis_posix_fstat(fd, buf); +#endif default: break; } diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/tpm_tis.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/tpm_tis.c Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,1354 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm.c + * from the linux kernel + * + * Copyright (C) 2004 IBM Corporation + * + * This code has also been derived from drivers/char/tpm/tpm_tis.c + * from the linux kernel + * + * Copyright (C) 2005, 2006 IBM Corporation + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef min + #define min( a, b ) ( ((a) < (b)) ? (a) : (b) ) +#endif + +#define TPM_HEADER_SIZE 10 + +#define TPM_BUFSIZE 2048 + +struct tpm_input_header { + uint16_t tag; + uint32_t length; + uint32_t ordinal; +}__attribute__((packed)); + +struct tpm_output_header { + uint16_t tag; + uint32_t length; + uint32_t return_code; +}__attribute__((packed)); + +struct stclear_flags_t { + uint16_t tag; + uint8_t deactivated; + uint8_t disableForceClear; + uint8_t physicalPresence; + uint8_t physicalPresenceLock; + uint8_t bGlobalLock; +}__attribute__((packed)); + +struct tpm_version_t { + uint8_t Major; + uint8_t Minor; + uint8_t revMajor; + uint8_t revMinor; +}__attribute__((packed)); + +struct tpm_version_1_2_t { + uint16_t tag; + uint8_t Major; + uint8_t Minor; + uint8_t revMajor; + uint8_t revMinor; +}__attribute__((packed)); + +struct timeout_t { + uint32_t a; + uint32_t b; + uint32_t c; + uint32_t d; +}__attribute__((packed)); + +struct duration_t { + uint32_t tpm_short; + uint32_t tpm_medium; + uint32_t tpm_long; +}__attribute__((packed)); + +struct permanent_flags_t { + uint16_t tag; + uint8_t disable; + uint8_t ownership; + uint8_t deactivated; + uint8_t readPubek; + uint8_t disableOwnerClear; + uint8_t allowMaintenance; + uint8_t physicalPresenceLifetimeLock; + uint8_t physicalPresenceHWEnable; + uint8_t physicalPresenceCMDEnable; + uint8_t CEKPUsed; + uint8_t TPMpost; + uint8_t TPMpostLock; + uint8_t FIPS; + uint8_t operator; + uint8_t enableRevokeEK; + uint8_t nvLocked; + uint8_t readSRKPub; + uint8_t tpmEstablished; + uint8_t maintenanceDone; + uint8_t disableFullDALogicInfo; +}__attribute__((packed)); + +typedef union { + struct permanent_flags_t perm_flags; + struct stclear_flags_t stclear_flags; + bool owned; + uint32_t num_pcrs; + struct tpm_version_t tpm_version; + struct tpm_version_1_2_t tpm_version_1_2; + uint32_t manufacturer_id; + struct timeout_t timeout; + struct duration_t duration; +} cap_t; + +struct tpm_getcap_params_in { + uint32_t cap; + uint32_t subcap_size; + uint32_t subcap; +}__attribute__((packed)); + +struct tpm_getcap_params_out { + uint32_t cap_size; + cap_t cap; +}__attribute__((packed)); + +struct tpm_readpubek_params_out { + uint8_t algorithm[4]; + uint8_t encscheme[2]; + uint8_t sigscheme[2]; + uint32_t paramsize; + uint8_t parameters[12]; /*assuming RSA*/ + uint32_t keysize; + uint8_t modulus[256]; + uint8_t checksum[20]; +}__attribute__((packed)); + +typedef union { + struct tpm_input_header in; + struct tpm_output_header out; +} tpm_cmd_header; + +#define TPM_DIGEST_SIZE 20 +struct tpm_pcrread_out { + uint8_t pcr_result[TPM_DIGEST_SIZE]; +}__attribute__((packed)); + +struct tpm_pcrread_in { + uint32_t pcr_idx; +}__attribute__((packed)); + +struct tpm_pcrextend_in { + uint32_t pcr_idx; + uint8_t hash[TPM_DIGEST_SIZE]; +}__attribute__((packed)); + +typedef union { + struct tpm_getcap_params_out getcap_out; + struct tpm_readpubek_params_out readpubek_out; + uint8_t readpubek_out_buffer[sizeof(struct tpm_readpubek_params_out)]; + struct tpm_getcap_params_in getcap_in; + struct tpm_pcrread_in pcrread_in; + struct tpm_pcrread_out pcrread_out; + struct tpm_pcrextend_in pcrextend_in; +} tpm_cmd_params; + +struct tpm_cmd_t { + tpm_cmd_header header; + tpm_cmd_params params; +}__attribute__((packed)); + + +enum tpm_duration { + TPM_SHORT = 0, + TPM_MEDIUM = 1, + TPM_LONG = 2, + TPM_UNDEFINED, +}; + +#define TPM_MAX_ORDINAL 243 +#define TPM_MAX_PROTECTED_ORDINAL 12 +#define TPM_PROTECTED_ORDINAL_MASK 0xFF + +extern const uint8_t tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL]; +extern const uint8_t tpm_ordinal_duration[TPM_MAX_ORDINAL]; + +#define TPM_DIGEST_SIZE 20 +#define TPM_ERROR_SIZE 10 +#define TPM_RET_CODE_IDX 6 + +/* tpm_capabilities */ +#define TPM_CAP_FLAG cpu_to_be32(4) +#define TPM_CAP_PROP cpu_to_be32(5) +#define CAP_VERSION_1_1 cpu_to_be32(0x06) +#define CAP_VERSION_1_2 cpu_to_be32(0x1A) + +/* tpm_sub_capabilities */ +#define TPM_CAP_PROP_PCR cpu_to_be32(0x101) +#define TPM_CAP_PROP_MANUFACTURER cpu_to_be32(0x103) +#define TPM_CAP_FLAG_PERM cpu_to_be32(0x108) +#define TPM_CAP_FLAG_VOL cpu_to_be32(0x109) +#define TPM_CAP_PROP_OWNER cpu_to_be32(0x111) +#define TPM_CAP_PROP_TIS_TIMEOUT cpu_to_be32(0x115) +#define TPM_CAP_PROP_TIS_DURATION cpu_to_be32(0x120) + + +#define TPM_INTERNAL_RESULT_SIZE 200 +#define TPM_TAG_RQU_COMMAND cpu_to_be16(193) +#define TPM_ORD_GET_CAP cpu_to_be32(101) + +extern const struct tpm_input_header tpm_getcap_header; + + + +const uint8_t tpm_protected_ordinal_duration[TPM_MAX_PROTECTED_ORDINAL] = { + TPM_UNDEFINED, /* 0 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 5 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 10 */ + TPM_SHORT, +}; + +const uint8_t tpm_ordinal_duration[TPM_MAX_ORDINAL] = { + TPM_UNDEFINED, /* 0 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 5 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 10 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_LONG, + TPM_LONG, + TPM_MEDIUM, /* 15 */ + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, + TPM_LONG, + TPM_SHORT, /* 20 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, /* 25 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 30 */ + TPM_LONG, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 35 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 40 */ + TPM_LONG, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 45 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_LONG, + TPM_MEDIUM, /* 50 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 55 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 60 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 65 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 70 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 75 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 80 */ + TPM_UNDEFINED, + TPM_MEDIUM, + TPM_LONG, + TPM_SHORT, + TPM_UNDEFINED, /* 85 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 90 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 95 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 100 */ + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 105 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 110 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 115 */ + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 120 */ + TPM_LONG, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 125 */ + TPM_SHORT, + TPM_LONG, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, /* 130 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_SHORT, + TPM_MEDIUM, + TPM_UNDEFINED, /* 135 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 140 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 145 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 150 */ + TPM_MEDIUM, + TPM_MEDIUM, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 155 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 160 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 165 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_LONG, /* 170 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 175 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_MEDIUM, /* 180 */ + TPM_SHORT, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, /* 185 */ + TPM_SHORT, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 190 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 195 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 200 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 205 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_MEDIUM, /* 210 */ + TPM_UNDEFINED, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_MEDIUM, + TPM_UNDEFINED, /* 215 */ + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, + TPM_SHORT, /* 220 */ + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_SHORT, + TPM_UNDEFINED, /* 225 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 230 */ + TPM_LONG, + TPM_MEDIUM, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, /* 235 */ + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_UNDEFINED, + TPM_SHORT, /* 240 */ + TPM_UNDEFINED, + TPM_MEDIUM, +}; + +const struct tpm_input_header tpm_getcap_header = { + .tag = TPM_TAG_RQU_COMMAND, + .length = cpu_to_be32(22), + .ordinal = TPM_ORD_GET_CAP +}; + + +enum tis_access { + TPM_ACCESS_VALID = 0x80, + TPM_ACCESS_ACTIVE_LOCALITY = 0x20, /* (R) */ + TPM_ACCESS_RELINQUISH_LOCALITY = 0x20,/* (W) */ + TPM_ACCESS_REQUEST_PENDING = 0x04, /* (W) */ + TPM_ACCESS_REQUEST_USE = 0x02, /* (W) */ +}; + +enum tis_status { + TPM_STS_VALID = 0x80, /* (R) */ + TPM_STS_COMMAND_READY = 0x40, /* (R) */ + TPM_STS_DATA_AVAIL = 0x10, /* (R) */ + TPM_STS_DATA_EXPECT = 0x08, /* (R) */ + TPM_STS_GO = 0x20, /* (W) */ +}; + +enum tis_int_flags { + TPM_GLOBAL_INT_ENABLE = 0x80000000, + TPM_INTF_BURST_COUNT_STATIC = 0x100, + TPM_INTF_CMD_READY_INT = 0x080, + TPM_INTF_INT_EDGE_FALLING = 0x040, + TPM_INTF_INT_EDGE_RISING = 0x020, + TPM_INTF_INT_LEVEL_LOW = 0x010, + TPM_INTF_INT_LEVEL_HIGH = 0x008, + TPM_INTF_LOCALITY_CHANGE_INT = 0x004, + TPM_INTF_STS_VALID_INT = 0x002, + TPM_INTF_DATA_AVAIL_INT = 0x001, +}; + +enum tis_defaults { + TIS_MEM_BASE = 0xFED40000, + TIS_MEM_LEN = 0x5000, + TIS_SHORT_TIMEOUT = 750, /*ms*/ + TIS_LONG_TIMEOUT = 2000, /*2 sec */ +}; + +#define TPM_TIMEOUT 5 + +#define TPM_ACCESS(t, l) (((uint8_t*)t->pages[l]) + 0x0000) +#define TPM_INT_ENABLE(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0008)) +#define TPM_INT_VECTOR(t, l) (((uint8_t*)t->pages[l]) + 0x000C) +#define TPM_INT_STATUS(t, l) (((uint8_t*)t->pages[l]) + 0x0010) +#define TPM_INTF_CAPS(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0014)) +#define TPM_STS(t, l) ((uint8_t*)(((uint8_t*)t->pages[l]) + 0x0018)) +#define TPM_DATA_FIFO(t, l) (((uint8_t*)t->pages[l]) + 0x0024) + +#define TPM_DID_VID(t, l) ((uint32_t*)(((uint8_t*)t->pages[l]) + 0x0F00)) +#define TPM_RID(t, l) (((uint8_t*)t->pages[l]) + 0x0F04) + +struct tpm_chip { + int enabled_localities; + int locality; + unsigned long baseaddr; + uint8_t* pages[5]; + int did, vid, rid; + + uint8_t data_buffer[TPM_BUFSIZE]; + int data_len; + + s_time_t timeout_a, timeout_b, timeout_c, timeout_d; + s_time_t duration[3]; + +#ifdef HAVE_LIBC + int fd; +#endif + + unsigned int irq; + struct wait_queue_head read_queue; + struct wait_queue_head int_queue; +}; + + +static void __init_tpm_chip(struct tpm_chip* tpm) { + tpm->enabled_localities = TPM_TIS_EN_LOCLALL; + tpm->locality = -1; + tpm->baseaddr = 0; + tpm->pages[0] = tpm->pages[1] = tpm->pages[2] = tpm->pages[3] = tpm->pages[4] = NULL; + tpm->vid = 0; + tpm->did = 0; + tpm->irq = 0; + init_waitqueue_head(&tpm->read_queue); + init_waitqueue_head(&tpm->int_queue); + + tpm->data_len = -1; + +#ifdef HAVE_LIBC + tpm->fd = -1; +#endif +} + +/* + * Returns max number of nsecs to wait + */ +s_time_t tpm_calc_ordinal_duration(struct tpm_chip *chip, + uint32_t ordinal) +{ + int duration_idx = TPM_UNDEFINED; + s_time_t duration = 0; + + if (ordinal < TPM_MAX_ORDINAL) + duration_idx = tpm_ordinal_duration[ordinal]; + else if ((ordinal & TPM_PROTECTED_ORDINAL_MASK) < + TPM_MAX_PROTECTED_ORDINAL) + duration_idx = + tpm_protected_ordinal_duration[ordinal & + TPM_PROTECTED_ORDINAL_MASK]; + + if (duration_idx != TPM_UNDEFINED) { + duration = chip->duration[duration_idx]; + } + + if (duration <= 0) { + return SECONDS(120); + } + else + { + return duration; + } +} + + +static int locality_enabled(struct tpm_chip* tpm, int l) { + return tpm->enabled_localities & (1 << l); +} + +static int check_locality(struct tpm_chip* tpm, int l) { + if(locality_enabled(tpm, l) && (ioread8(TPM_ACCESS(tpm, l)) & + (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) == + (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) { + return l; + } + return -1; +} + +void release_locality(struct tpm_chip* tpm, int l, int force) +{ + if (locality_enabled(tpm, l) && (force || (ioread8(TPM_ACCESS(tpm, l)) & + (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID)) == + (TPM_ACCESS_REQUEST_PENDING | TPM_ACCESS_VALID))) { + iowrite8(TPM_ACCESS(tpm, l), TPM_ACCESS_RELINQUISH_LOCALITY); + } +} + +int tpm_tis_request_locality(struct tpm_chip* tpm, int l) { + + s_time_t stop; + /*Make sure locality is valid */ + if(!locality_enabled(tpm, l)) { + printk("tpm_tis_change_locality() Tried to change to locality %d, but it is disabled or invalid!\n", l); + return -1; + } + /* Check if we already have the current locality */ + if(check_locality(tpm, l) >= 0) { + return tpm->locality = l; + } + /* Set the new locality*/ + iowrite8(TPM_ACCESS(tpm, l), TPM_ACCESS_REQUEST_USE); + + if(tpm->irq) { + /* Wait for interrupt */ + wait_event_deadline(tpm->int_queue, (check_locality(tpm, l) >= 0), NOW() + tpm->timeout_a); + + /* FIXME: Handle timeout event, should return error in that case */ + return l; + } else { + /* Wait for burstcount */ + stop = NOW() + tpm->timeout_a; + do { + if(check_locality(tpm, l) >= 0) { + return tpm->locality = l; + } + msleep(TPM_TIMEOUT); + } while(NOW() < stop); + } + + printk("REQ LOCALITY FAILURE\n"); + return -1; +} + +static uint8_t tpm_tis_status(struct tpm_chip* tpm) { + return ioread8(TPM_STS(tpm, tpm->locality)); +} + +/* This causes the current command to be aborted */ +static void tpm_tis_ready(struct tpm_chip* tpm) { + iowrite8(TPM_STS(tpm, tpm->locality), TPM_STS_COMMAND_READY); +} +#define tpm_tis_cancel_cmd(v) tpm_tis_ready(v) + +static int get_burstcount(struct tpm_chip* tpm) { + s_time_t stop; + int burstcnt; + + stop = NOW() + tpm->timeout_d; + do { + burstcnt = ioread8((TPM_STS(tpm, tpm->locality) + 1)); + burstcnt += ioread8(TPM_STS(tpm, tpm->locality) + 2) << 8; + + if (burstcnt) { + return burstcnt; + } + msleep(TPM_TIMEOUT); + } while(NOW() < stop); + return -EBUSY; +} + +static int wait_for_stat(struct tpm_chip* tpm, uint8_t mask, + unsigned long timeout, struct wait_queue_head* queue) { + s_time_t stop; + uint8_t status; + + status = tpm_tis_status(tpm); + if((status & mask) == mask) { + return 0; + } + + if(tpm->irq) { + wait_event_deadline(*queue, ((tpm_tis_status(tpm) & mask) == mask), timeout); + /* FIXME: Check for timeout and return -ETIME */ + return 0; + } else { + stop = NOW() + timeout; + do { + msleep(TPM_TIMEOUT); + status = tpm_tis_status(tpm); + if((status & mask) == mask) + return 0; + } while( NOW() < stop); + } + return -ETIME; +} + +static int recv_data(struct tpm_chip* tpm, uint8_t* buf, size_t count) { + int size = 0; + int burstcnt; + while( size < count && + wait_for_stat(tpm, + TPM_STS_DATA_AVAIL | TPM_STS_VALID, + tpm->timeout_c, + &tpm->read_queue) + == 0) { + burstcnt = get_burstcount(tpm); + for(; burstcnt > 0 && size < count; --burstcnt) + { + buf[size++] = ioread8(TPM_DATA_FIFO(tpm, tpm->locality)); + } + } + return size; +} + +int tpm_tis_recv(struct tpm_chip* tpm, uint8_t* buf, size_t count) { + int size = 0; + int expected, status; + + if (count < TPM_HEADER_SIZE) { + size = -EIO; + goto out; + } + + /* read first 10 bytes, including tag, paramsize, and result */ + if((size = + recv_data(tpm, buf, TPM_HEADER_SIZE)) < TPM_HEADER_SIZE) { + printk("Error reading tpm cmd header\n"); + goto out; + } + + expected = be32_to_cpu(*((uint32_t*)(buf + 2))); + if(expected > count) { + size = -EIO; + goto out; + } + + if((size += recv_data(tpm, & buf[TPM_HEADER_SIZE], + expected - TPM_HEADER_SIZE)) < expected) { + printk("Unable to read rest of tpm command size=%d expected=%d\n", size, expected); + size = -ETIME; + goto out; + } + + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->int_queue); + status = tpm_tis_status(tpm); + if(status & TPM_STS_DATA_AVAIL) { + printk("Error: left over data\n"); + size = -EIO; + goto out; + } + +out: + tpm_tis_ready(tpm); + release_locality(tpm, tpm->locality, 0); + return size; +} +int tpm_tis_send(struct tpm_chip* tpm, uint8_t* buf, size_t len) { + int rc; + int status, burstcnt = 0; + int count = 0; + uint32_t ordinal; + + if(tpm_tis_request_locality(tpm, tpm->locality) < 0) { + return -EBUSY; + } + + status = tpm_tis_status(tpm); + if((status & TPM_STS_COMMAND_READY) == 0) { + tpm_tis_ready(tpm); + if(wait_for_stat(tpm, TPM_STS_COMMAND_READY, tpm->timeout_b, &tpm->int_queue) < 0) { + rc = -ETIME; + goto out_err; + } + } + + while(count < len - 1) { + burstcnt = get_burstcount(tpm); + for(;burstcnt > 0 && count < len -1; --burstcnt) { + iowrite8(TPM_DATA_FIFO(tpm, tpm->locality), buf[count++]); + } + + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->int_queue); + status = tpm_tis_status(tpm); + if((status & TPM_STS_DATA_EXPECT) == 0) { + rc = -EIO; + goto out_err; + } + } + + /*Write last byte*/ + iowrite8(TPM_DATA_FIFO(tpm, tpm->locality), buf[count]); + wait_for_stat(tpm, TPM_STS_VALID, tpm->timeout_c, &tpm->read_queue); + status = tpm_tis_status(tpm); + if((status & TPM_STS_DATA_EXPECT) != 0) { + rc = -EIO; + goto out_err; + } + + /*go and do it*/ + iowrite8(TPM_STS(tpm, tpm->locality), TPM_STS_GO); + + if(tpm->irq) { + /*Wait for interrupt */ + ordinal = be32_to_cpu(*(buf + 6)); + if(wait_for_stat(tpm, + TPM_STS_DATA_AVAIL | TPM_STS_VALID, + tpm_calc_ordinal_duration(tpm, ordinal), + &tpm->read_queue) < 0) { + rc = -ETIME; + goto out_err; + } + } +#ifdef HAVE_LIBC + if(tpm->fd >= 0) { + files[tpm->fd].read = 0; + files[tpm->fd].tpm_tis.respgot = 0; + files[tpm->fd].tpm_tis.offset = 0; + } +#endif + return len; + +out_err: + tpm_tis_ready(tpm); + release_locality(tpm, tpm->locality, 0); + return rc; +} + +static void tpm_tis_irq_handler(evtchn_port_t port, struct pt_regs *regs, void* data) +{ + struct tpm_chip* tpm = data; + uint32_t interrupt; + int i; + + interrupt = ioread32(TPM_INT_STATUS(tpm, tpm->locality)); + if(interrupt == 0) { + return; + } + + if(interrupt & TPM_INTF_DATA_AVAIL_INT) { + wake_up(&tpm->read_queue); + } + if(interrupt & TPM_INTF_LOCALITY_CHANGE_INT) { + for(i = 0; i < 5; ++i) { + if(check_locality(tpm, i) >= 0) { + break; + } + } + } + if(interrupt & (TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_STS_VALID_INT | + TPM_INTF_CMD_READY_INT)) { + wake_up(&tpm->int_queue); + } + + /* Clear interrupts handled with TPM_EOI */ + iowrite32(TPM_INT_STATUS(tpm, tpm->locality), interrupt); + ioread32(TPM_INT_STATUS(tpm, tpm->locality)); + return; +} + +/* + * Internal kernel interface to transmit TPM commands + */ +static ssize_t tpm_transmit(struct tpm_chip *chip, const uint8_t *buf, + size_t bufsiz) +{ + ssize_t rc; + uint32_t count, ordinal; + s_time_t stop; + + count = be32_to_cpu(*((uint32_t *) (buf + 2))); + ordinal = be32_to_cpu(*((uint32_t *) (buf + 6))); + if (count == 0) + return -ENODATA; + if (count > bufsiz) { + printk("Error: invalid count value %x %zx \n", count, bufsiz); + return -E2BIG; + } + + //down(&chip->tpm_mutex); + + if ((rc = tpm_tis_send(chip, (uint8_t *) buf, count)) < 0) { + printk("tpm_transmit: tpm_send: error %ld\n", rc); + goto out; + } + + if (chip->irq) + goto out_recv; + + stop = NOW() + tpm_calc_ordinal_duration(chip, ordinal); + do { + uint8_t status = tpm_tis_status(chip); + if ((status & (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) == + (TPM_STS_DATA_AVAIL | TPM_STS_VALID)) + goto out_recv; + + if ((status == TPM_STS_COMMAND_READY)) { + printk("TPM Error: Operation Canceled\n"); + rc = -ECANCELED; + goto out; + } + + msleep(TPM_TIMEOUT); /* CHECK */ + rmb(); + } while (NOW() < stop); + + /* Cancel the command */ + tpm_tis_cancel_cmd(chip); + printk("TPM Operation Timed out\n"); + rc = -ETIME; + goto out; + +out_recv: + if((rc = tpm_tis_recv(chip, (uint8_t *) buf, bufsiz)) < 0) { + printk("tpm_transmit: tpm_recv: error %d\n", rc); + } +out: + //up(&chip->tpm_mutex); + return rc; +} + +static ssize_t transmit_cmd(struct tpm_chip *chip, struct tpm_cmd_t *cmd, + int len, const char *desc) +{ + int err; + + len = tpm_transmit(chip,(uint8_t *) cmd, len); + if (len < 0) + return len; + if (len == TPM_ERROR_SIZE) { + err = be32_to_cpu(cmd->header.out.return_code); + printk("A TPM error (%d) occurred %s\n", err, desc); + return err; + } + return 0; +} + +int tpm_get_timeouts(struct tpm_chip *chip) +{ + struct tpm_cmd_t tpm_cmd; + struct timeout_t *timeout_cap; + struct duration_t *duration_cap; + ssize_t rc; + uint32_t timeout; + unsigned int scale = 1; + + tpm_cmd.header.in = tpm_getcap_header; + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_TIMEOUT; + + if((rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, + "attempting to determine the timeouts")) != 0) { + printk("transmit failed %d\n", rc); + goto duration; + } + + if(be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || + be32_to_cpu(tpm_cmd.header.out.length) != + sizeof(tpm_cmd.header.out) + sizeof(uint32_t) + 4 * sizeof(uint32_t)) { + return -EINVAL; + } + + timeout_cap = &tpm_cmd.params.getcap_out.cap.timeout; + /* Don't overwrite default if value is 0 */ + timeout = be32_to_cpu(timeout_cap->a); + if(timeout && timeout < 1000) { + /* timeouts in msc rather usec */ + scale = 1000; + } + if (timeout) + chip->timeout_a = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->b); + if (timeout) + chip->timeout_b = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->c); + if (timeout) + chip->timeout_c = MICROSECS(timeout * scale); /*Convert to msec */ + timeout = be32_to_cpu(timeout_cap->d); + if (timeout) + chip->timeout_d = MICROSECS(timeout * scale); /*Convert to msec */ + +duration: + tpm_cmd.header.in = tpm_getcap_header; + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = TPM_CAP_PROP_TIS_DURATION; + + if((rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, + "attempting to determine the durations")) < 0) { + return rc; + } + + if(be32_to_cpu(tpm_cmd.header.out.return_code) != 0 || + be32_to_cpu(tpm_cmd.header.out.length) != + sizeof(tpm_cmd.header.out) + sizeof(uint32_t) + 3 * sizeof(uint32_t)) { + return -EINVAL; + } + + duration_cap = &tpm_cmd.params.getcap_out.cap.duration; + chip->duration[TPM_SHORT] = MICROSECS(be32_to_cpu(duration_cap->tpm_short)); + chip->duration[TPM_MEDIUM] = MICROSECS(be32_to_cpu(duration_cap->tpm_medium)); + chip->duration[TPM_LONG] = MICROSECS(be32_to_cpu(duration_cap->tpm_long)); + + /* The Broadcom BCM0102 chipset in a Dell Latitude D820 gets the above + * value wrong and apparently reports msecs rather than usecs. So we + * fix up the resulting too-small TPM_SHORT value to make things work. + */ + if (chip->duration[TPM_SHORT] < MILLISECS(10)) { + chip->duration[TPM_SHORT] = SECONDS(1); + chip->duration[TPM_MEDIUM] *= 1000; + chip->duration[TPM_LONG] *= 1000; + printk("Adjusting TPM timeout parameters\n"); + } + + return 0; +} + + + +void tpm_continue_selftest(struct tpm_chip* chip) { + uint8_t data[] = { + 0, 193, /* TPM_TAG_RQU_COMMAND */ + 0, 0, 0, 10, /* length */ + 0, 0, 0, 83, /* TPM_ORD_GetCapability */ + }; + + tpm_transmit(chip, data, sizeof(data)); +} + +ssize_t tpm_getcap(struct tpm_chip *chip, uint32_t subcap_id, cap_t *cap, + const char *desc) +{ + struct tpm_cmd_t tpm_cmd; + int rc; + + tpm_cmd.header.in = tpm_getcap_header; + if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) { + tpm_cmd.params.getcap_in.cap = subcap_id; + /*subcap field not necessary */ + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0); + tpm_cmd.header.in.length -= cpu_to_be32(sizeof(uint32_t)); + } else { + if (subcap_id == TPM_CAP_FLAG_PERM || + subcap_id == TPM_CAP_FLAG_VOL) + tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG; + else + tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP; + tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4); + tpm_cmd.params.getcap_in.subcap = subcap_id; + } + rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc); + if (!rc) + *cap = tpm_cmd.params.getcap_out.cap; + return rc; +} + + +struct tpm_chip* init_tpm_tis(unsigned long baseaddr, int localities, unsigned int irq) +{ + int i; + unsigned long addr; + struct tpm_chip* tpm = NULL; + uint32_t didvid; + uint32_t intfcaps; + uint32_t intmask; + + printk("============= Init TPM TIS Driver ==============\n"); + + /*Sanity check the localities input */ + if(localities & ~TPM_TIS_EN_LOCLALL) { + printk("init_tpm_tis() Invalid locality specification! %X\n", localities); + goto abort_egress; + } + + printk("IOMEM Machine Base Address: %lX\n", baseaddr); + + /* Create the tpm data structure */ + tpm = malloc(sizeof(struct tpm_chip)); + __init_tpm_chip(tpm); + + /* Set the enabled localities - if 0 we leave default as all enabled */ + if(localities != 0) { + tpm->enabled_localities = localities; + } + printk("Enabled Localities: "); + for(i = 0; i < 5; ++i) { + if(locality_enabled(tpm, i)) { + printk("%d ", i); + } + } + printk("\n"); + + /* Set the base machine address */ + tpm->baseaddr = baseaddr; + + /* Set default timeouts */ + tpm->timeout_a = MILLISECS(TIS_SHORT_TIMEOUT); + tpm->timeout_b = MILLISECS(TIS_LONG_TIMEOUT); + tpm->timeout_c = MILLISECS(TIS_SHORT_TIMEOUT); + tpm->timeout_d = MILLISECS(TIS_SHORT_TIMEOUT); + + /*Map the mmio pages */ + addr = tpm->baseaddr; + for(i = 0; i < 5; ++i) { + if(locality_enabled(tpm, i)) { + /* Map the page in now */ + if((tpm->pages[i] = ioremap_nocache(addr, PAGE_SIZE)) == NULL) { + printk("Unable to map iomem page a address %p\n", addr); + goto abort_egress; + } + + /* Set default locality to the first enabled one */ + if (tpm->locality < 0) { + if(tpm_tis_request_locality(tpm, i) < 0) { + printk("Unable to request locality %d??\n", i); + goto abort_egress; + } + } + } + addr += PAGE_SIZE; + } + + + /* Get the vendor and device ids */ + didvid = ioread32(TPM_DID_VID(tpm, tpm->locality)); + tpm->did = didvid >> 16; + tpm->vid = didvid & 0xFFFF; + + + /* Get the revision id */ + tpm->rid = ioread8(TPM_RID(tpm, tpm->locality)); + + printk("1.2 TPM (device-id=0x%X vendor-id = %X rev-id = %X)\n", tpm->did, tpm->vid, tpm->rid); + + intfcaps = ioread32(TPM_INTF_CAPS(tpm, tpm->locality)); + printk("TPM interface capabilities (0x%x):\n", intfcaps); + if (intfcaps & TPM_INTF_BURST_COUNT_STATIC) + printk("\tBurst Count Static\n"); + if (intfcaps & TPM_INTF_CMD_READY_INT) + printk("\tCommand Ready Int Support\n"); + if (intfcaps & TPM_INTF_INT_EDGE_FALLING) + printk("\tInterrupt Edge Falling\n"); + if (intfcaps & TPM_INTF_INT_EDGE_RISING) + printk("\tInterrupt Edge Rising\n"); + if (intfcaps & TPM_INTF_INT_LEVEL_LOW) + printk("\tInterrupt Level Low\n"); + if (intfcaps & TPM_INTF_INT_LEVEL_HIGH) + printk("\tInterrupt Level High\n"); + if (intfcaps & TPM_INTF_LOCALITY_CHANGE_INT) + printk("\tLocality Change Int Support\n"); + if (intfcaps & TPM_INTF_STS_VALID_INT) + printk("\tSts Valid Int Support\n"); + if (intfcaps & TPM_INTF_DATA_AVAIL_INT) + printk("\tData Avail Int Support\n"); + + /*Interupt setup */ + intmask = ioread32(TPM_INT_ENABLE(tpm, tpm->locality)); + + intmask |= TPM_INTF_CMD_READY_INT + | TPM_INTF_LOCALITY_CHANGE_INT | TPM_INTF_DATA_AVAIL_INT + | TPM_INTF_STS_VALID_INT; + + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), intmask); + + /*If interupts are enabled, handle it */ + if(irq) { + if(irq != TPM_PROBE_IRQ) { + tpm->irq = irq; + } else { + /*FIXME add irq probing feature later */ + printk("IRQ probing not implemented\n"); + } + } + + if(tpm->irq) { + iowrite8(TPM_INT_VECTOR(tpm, tpm->locality), tpm->irq); + + if(bind_pirq(tpm->irq, 1, tpm_tis_irq_handler, tpm) != 0) { + printk("Unabled to request irq: %u for use\n", tpm->irq); + printk("Will use polling mode\n"); + tpm->irq = 0; + } else { + /* Clear all existing */ + iowrite32(TPM_INT_STATUS(tpm, tpm->locality), ioread32(TPM_INT_STATUS(tpm, tpm->locality))); + + /* Turn on interrupts */ + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), intmask | TPM_GLOBAL_INT_ENABLE); + } + } + + if(tpm_get_timeouts(tpm)) { + printk("Could not get TPM timeouts and durations\n"); + goto abort_egress; + } + tpm_continue_selftest(tpm); + + + return tpm; +abort_egress: + if(tpm != NULL) { + shutdown_tpm_tis(tpm); + } + return NULL; +} + +void shutdown_tpm_tis(struct tpm_chip* tpm){ + int i; + + printk("Shutting down tpm_tis device\n"); + + iowrite32(TPM_INT_ENABLE(tpm, tpm->locality), ~TPM_GLOBAL_INT_ENABLE); + + /*Unmap all of the mmio pages */ + for(i = 0; i < 5; ++i) { + if(tpm->pages[i] != NULL) { + iounmap(tpm->pages[i], PAGE_SIZE); + tpm->pages[i] = NULL; + } + } + free(tpm); + return; +} + + +int tpm_tis_cmd(struct tpm_chip* tpm, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen) +{ + if(tpm->locality < 0) { + printk("tpm_tis_cmd() failed! locality not set!\n"); + return -1; + } + if(reqlen > TPM_BUFSIZE) { + reqlen = TPM_BUFSIZE; + } + memcpy(tpm->data_buffer, req, reqlen); + *resplen = tpm_transmit(tpm, tpm->data_buffer, TPM_BUFSIZE); + + *resp = malloc(*resplen); + memcpy(*resp, tpm->data_buffer, *resplen); + return 0; +} + +#ifdef HAVE_LIBC +int tpm_tis_open(struct tpm_chip* tpm) +{ + /* Silently prevent multiple opens */ + if(tpm->fd != -1) { + return tpm->fd; + } + + tpm->fd = alloc_fd(FTYPE_TPM_TIS); + printk("tpm_tis_open() -> %d\n", tpm->fd); + files[tpm->fd].tpm_tis.dev = tpm; + files[tpm->fd].tpm_tis.offset = 0; + files[tpm->fd].tpm_tis.respgot = 0; + return tpm->fd; +} + +int tpm_tis_posix_write(int fd, const uint8_t* buf, size_t count) +{ + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + if(tpm->locality < 0) { + printk("tpm_tis_posix_write() failed! locality not set!\n"); + errno = EINPROGRESS; + return -1; + } + if(count == 0) { + return 0; + } + + /* Return an error if we are already processing a command */ + if(count > TPM_BUFSIZE) { + count = TPM_BUFSIZE; + } + /* Send the command now */ + memcpy(tpm->data_buffer, buf, count); + if((tpm->data_len = tpm_transmit(tpm, tpm->data_buffer, TPM_BUFSIZE)) < 0) { + errno = EIO; + return -1; + } + return count; +} + +int tpm_tis_posix_read(int fd, uint8_t* buf, size_t count) +{ + int rc; + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + if(count == 0) { + return 0; + } + + /* If there is no tpm resp to read, return EIO */ + if(tpm->data_len < 0) { + errno = EIO; + return -1; + } + + + /* Handle EOF case */ + if(files[fd].tpm_tis.offset >= tpm->data_len) { + rc = 0; + } else { + rc = min(tpm->data_len - files[fd].tpm_tis.offset, count); + memcpy(buf, tpm->data_buffer + files[fd].tpm_tis.offset, rc); + } + files[fd].tpm_tis.offset += rc; + /* Reset the data pending flag */ + return rc; +} +int tpm_tis_posix_fstat(int fd, struct stat* buf) +{ + struct tpm_chip* tpm; + tpm = files[fd].tpm_tis.dev; + + buf->st_mode = O_RDWR; + buf->st_uid = 0; + buf->st_gid = 0; + buf->st_size = be32_to_cpu(*((uint32_t*)(tpm->data_buffer + 2))); + buf->st_atime = buf->st_mtime = buf->st_ctime = time(NULL); + return 0; +} + + +#endif diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/tpmback.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/tpmback.c Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,1102 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/xen/tpmback/tpmback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netback/netback.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This code has also been derived from drivers/xen/tpmback/xenbus.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2005 IBM Corporation + * Copyright (C) 2005 Rusty Russell + * + * This code has also been derived from drivers/xen/tpmback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself also derived from drvivers/xen/netback/interface.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2004, Keir Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, version 2 + * of the License + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#ifndef HAVE_LIBC +#define strtoul simple_strtoul +#endif + +//#define TPMBACK_PRINT_DEBUG +#ifdef TPMBACK_PRINT_DEBUG +#define TPMBACK_DEBUG(fmt,...) printk("Tpmback:Debug("__FILE__":%d) " fmt, __LINE__, ##__VA_ARGS__) +#define TPMBACK_DEBUG_MORE(fmt,...) printk(fmt, ##__VA_ARGS__) +#else +#define TPMBACK_DEBUG(fmt,...) +#endif +#define TPMBACK_ERR(fmt,...) printk("Tpmback:Error " fmt, ##__VA_ARGS__) +#define TPMBACK_LOG(fmt,...) printk("Tpmback:Info " fmt, ##__VA_ARGS__) + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +/* Default size of the tpmif array at initialization */ +#define DEF_ARRAY_SIZE 1 + +/* tpmif and tpmdev flags */ +#define TPMIF_CLOSED 1 +#define TPMIF_REQ_READY 2 + +struct tpmif { + domid_t domid; + unsigned int handle; + + char* fe_path; + char* fe_state_path; + + /* Locally bound event channel*/ + evtchn_port_t evtchn; + + /* Shared page */ + tpmif_tx_interface_t* tx; + + /* pointer to TPMIF_RX_RING_SIZE pages */ + void** pages; + + enum xenbus_state state; + enum { DISCONNECTED, DISCONNECTING, CONNECTED } status; + + unsigned char uuid[16]; + + /* state flags */ + int flags; +}; +typedef struct tpmif tpmif_t; + +struct tpmback_dev { + + tpmif_t** tpmlist; + unsigned long num_tpms; + unsigned long num_alloc; + + struct gntmap map; + + /* True if at least one tpmif has a request to be handled */ + int flags; + + xenbus_event_queue events; + + /* Callbacks */ + void (*open_callback)(domid_t, unsigned int); + void (*close_callback)(domid_t, unsigned int); + void (*suspend_callback)(domid_t, unsigned int); + void (*resume_callback)(domid_t, unsigned int); +}; +typedef struct tpmback_dev tpmback_dev_t; + +enum { EV_NONE, EV_NEWFE, EV_STCHNG } tpm_ev_enum; + +/* Global objects */ +static struct thread* eventthread = NULL; +static tpmback_dev_t gtpmdev = { + .tpmlist = NULL, + .num_tpms = 0, + .num_alloc = 0, + .flags = TPMIF_CLOSED, + .events = NULL, + .open_callback = NULL, + .close_callback = NULL, + .suspend_callback = NULL, + .resume_callback = NULL, +}; +struct wait_queue_head waitq; +int globalinit = 0; + +/************************************ + * TPMIF SORTED ARRAY FUNCTIONS + * tpmback_dev_t.tpmlist is a sorted array, sorted by domid and then handle number + * Duplicates are not allowed + * **********************************/ + +inline void tpmif_req_ready(tpmif_t* tpmif) { + tpmif->flags |= TPMIF_REQ_READY; + gtpmdev.flags |= TPMIF_REQ_READY; +} + +inline void tpmdev_check_req(void) { + int i; + int flags; + local_irq_save(flags); + for(i = 0; i < gtpmdev.num_tpms; ++i) { + if(gtpmdev.tpmlist[i]->flags & TPMIF_REQ_READY) { + gtpmdev.flags |= TPMIF_REQ_READY; + local_irq_restore(flags); + return; + } + } + gtpmdev.flags &= ~TPMIF_REQ_READY; + local_irq_restore(flags); +} + +inline void tpmif_req_finished(tpmif_t* tpmif) { + tpmif->flags &= ~TPMIF_REQ_READY; + tpmdev_check_req(); +} + +int __get_tpmif_index(int st, int n, domid_t domid, unsigned int handle) +{ + int i = st + n /2; + tpmif_t* tmp; + + if( n <= 0 ) + return -1; + + tmp = gtpmdev.tpmlist[i]; + if(domid == tmp->domid && tmp->handle == handle) { + return i; + } else if ( (domid < tmp->domid) || + (domid == tmp->domid && handle < tmp->handle)) { + return __get_tpmif_index(st, n/2, domid, handle); + } else { + return __get_tpmif_index(i + 1, n/2 - ((n +1) % 2), domid, handle); + } +} + +/* Returns the array index of the tpmif domid/handle. Returns -1 if no such tpmif exists */ +int get_tpmif_index(domid_t domid, unsigned int handle) +{ + int flags; + int index; + local_irq_save(flags); + index = __get_tpmif_index(0, gtpmdev.num_tpms, domid, handle); + local_irq_restore(flags); + return index; +} + +/* Returns the tpmif domid/handle or NULL if none exists */ +tpmif_t* get_tpmif(domid_t domid, unsigned int handle) +{ + int flags; + int i; + tpmif_t* ret; + local_irq_save(flags); + i = get_tpmif_index(domid, handle); + if (i < 0) { + ret = NULL; + } else { + ret = gtpmdev.tpmlist[i]; + } + local_irq_restore(flags); + return ret; +} + +/* Remove the given tpmif. Returns 0 if it was removed, -1 if it was not removed */ +int remove_tpmif(tpmif_t* tpmif) +{ + int i, j; + char* err; + int flags; + local_irq_save(flags); + + /* Find the index in the array if it exists */ + i = get_tpmif_index(tpmif->domid, tpmif->handle); + if (i < 0) { + goto error; + } + + /* Remove the interface from the list */ + for(j = i; j < gtpmdev.num_tpms - 1; ++j) { + gtpmdev.tpmlist[j] = gtpmdev.tpmlist[j+1]; + } + gtpmdev.tpmlist[j] = NULL; + --gtpmdev.num_tpms; + + /* If removed tpm was the only ready tpm, then we need to check and turn off the ready flag */ + tpmdev_check_req(); + + local_irq_restore(flags); + + /* Stop listening for events on this tpm interface */ + if((err = xenbus_unwatch_path_token(XBT_NIL, tpmif->fe_state_path, tpmif->fe_state_path))) { + TPMBACK_ERR("Unable to unwatch path token `%s' Error was %s Ignoring..\n", tpmif->fe_state_path, err); + free(err); + } + + return 0; +error: + local_irq_restore(flags); + return -1; +} + +/* Insert tpmif into dev->tpmlist. Returns 0 on success and non zero on error. + * It is an error to insert a tpmif with the same domid and handle + * number + * as something already in the list */ +int insert_tpmif(tpmif_t* tpmif) +{ + int flags; + unsigned int i, j; + tpmif_t* tmp; + char* err; + + local_irq_save(flags); + + /*Check if we need to allocate more space */ + if (gtpmdev.num_tpms == gtpmdev.num_alloc) { + gtpmdev.num_alloc *= 2; + gtpmdev.tpmlist = realloc(gtpmdev.tpmlist, gtpmdev.num_alloc); + } + + /*Find where to put the new interface */ + for(i = 0; i < gtpmdev.num_tpms; ++i) + { + tmp = gtpmdev.tpmlist[i]; + if(tpmif->domid == tmp->domid && tpmif->handle == tmp->handle) { + TPMBACK_ERR("Tried to insert duplicate tpm interface %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + if((tpmif->domid < tmp->domid) || + (tpmif->domid == tmp->domid && tpmif->handle < tmp->handle)) { + break; + } + } + + /*Shift all the tpm pointers past i down one */ + for(j = gtpmdev.num_tpms; j > i; --j) { + gtpmdev.tpmlist[j] = gtpmdev.tpmlist[j-1]; + } + + /*Add the new interface */ + gtpmdev.tpmlist[i] = tpmif; + ++gtpmdev.num_tpms; + + /*Should not be needed, anything inserted with ready flag is probably an error */ + tpmdev_check_req(); + + local_irq_restore(flags); + + /*Listen for state changes on the new interface */ + if((err = xenbus_watch_path_token(XBT_NIL, tpmif->fe_state_path, tpmif->fe_state_path, >pmdev.events))) + { + /* if we got an error here we should carefully remove the interface and then return */ + TPMBACK_ERR("Unable to watch path token `%s' Error was %s\n", tpmif->fe_state_path, err); + free(err); + remove_tpmif(tpmif); + goto error_post_irq; + } + + return 0; +error: + local_irq_restore(flags); +error_post_irq: + return -1; +} + + +/***************** + * CHANGE BACKEND STATE + * *****************/ +/*Attempts to change the backend state in xenstore + * returns 0 on success and non-zero on error */ +int tpmif_change_state(tpmif_t* tpmif, enum xenbus_state state) +{ + char path[512]; + char *value; + char *err; + enum xenbus_state readst; + TPMBACK_DEBUG("Backend state change %u/%u from=%d to=%d\n", (unsigned int) tpmif->domid, tpmif->handle, tpmif->state, state); + if (tpmif->state == state) + return 0; + + snprintf(path, 512, "backend/vtpm/%u/%u/state", (unsigned int) tpmif->domid, tpmif->handle); + + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Unable to read backend state %s, error was %s\n", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &readst) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + /* It's possible that the backend state got updated by hotplug or something else behind our back */ + if(readst != tpmif->state) { + TPMBACK_DEBUG("tpm interface state was %d but xenstore state was %d!\n", tpmif->state, readst); + tpmif->state = readst; + } + + /*If if the state isnt changing, then we dont update xenstore b/c we dont want to fire extraneous events */ + if(tpmif->state == state) { + return 0; + } + + /*update xenstore*/ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_printf(XBT_NIL, path, "state", "%u", state))) { + TPMBACK_ERR("Error writing to xenstore %s, error was %s new state=%d\n", path, err, state); + free(err); + return -1; + } + + tpmif->state = state; + + return 0; +} +/********************************** + * TPMIF CREATION AND DELETION + * *******************************/ +inline tpmif_t* __init_tpmif(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + tpmif = malloc(sizeof(*tpmif)); + tpmif->domid = domid; + tpmif->handle = handle; + tpmif->fe_path = NULL; + tpmif->fe_state_path = NULL; + tpmif->state = XenbusStateInitialising; + tpmif->status = DISCONNECTED; + tpmif->tx = NULL; + tpmif->pages = NULL; + tpmif->flags = 0; + memset(tpmif->uuid, 0, sizeof(tpmif->uuid)); + return tpmif; +} + +void __free_tpmif(tpmif_t* tpmif) +{ + if(tpmif->pages) { + free(tpmif->pages); + } + if(tpmif->fe_path) { + free(tpmif->fe_path); + } + if(tpmif->fe_state_path) { + free(tpmif->fe_state_path); + } + free(tpmif); +} +/* Creates a new tpm interface, adds it to the sorted array and returns it. + * returns NULL on error + * If the tpm interface already exists, it is returned*/ +tpmif_t* new_tpmif(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + char* err; + char path[512]; + + /* Make sure we haven't already created this tpm + * Double events can occur */ + if((tpmif = get_tpmif(domid, handle)) != NULL) { + return tpmif; + } + + tpmif = __init_tpmif(domid, handle); + + /* Get the uuid from xenstore */ + snprintf(path, 512, "backend/vtpm/%u/%u/uuid", (unsigned int) domid, handle); + if((!xenbus_read_uuid(path, tpmif->uuid))) { + TPMBACK_ERR("Error reading %s\n", path); + goto error; + } + + /* allocate pages to be used for shared mapping */ + if((tpmif->pages = malloc(sizeof(void*) * TPMIF_TX_RING_SIZE)) == NULL) { + goto error; + } + memset(tpmif->pages, 0, sizeof(void*) * TPMIF_TX_RING_SIZE); + + if(tpmif_change_state(tpmif, XenbusStateInitWait)) { + goto error; + } + + snprintf(path, 512, "backend/vtpm/%u/%u/frontend", (unsigned int) domid, handle); + if((err = xenbus_read(XBT_NIL, path, &tpmif->fe_path))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s), Error = %s", path, err); + free(err); + goto error; + } + + /*Set the state path */ + tpmif->fe_state_path = malloc(strlen(tpmif->fe_path) + 7); + strcpy(tpmif->fe_state_path, tpmif->fe_path); + strcat(tpmif->fe_state_path, "/state"); + + if(insert_tpmif(tpmif)) { + goto error; + } + TPMBACK_DEBUG("New tpmif %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + /* Do the callback now */ + if(gtpmdev.open_callback) { + gtpmdev.open_callback(tpmif->domid, tpmif->handle); + } + return tpmif; +error: + __free_tpmif(tpmif); + return NULL; + +} + +/* Removes tpmif from dev->tpmlist and frees it's memory usage */ +void free_tpmif(tpmif_t* tpmif) +{ + char* err; + char path[512]; + TPMBACK_DEBUG("Free tpmif %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + if(tpmif->flags & TPMIF_CLOSED) { + TPMBACK_ERR("Tried to free an instance twice! Theres a bug somewhere!\n"); + BUG(); + } + tpmif->flags = TPMIF_CLOSED; + + tpmif_change_state(tpmif, XenbusStateClosing); + + /* Unmap share page and unbind event channel */ + if(tpmif->status == CONNECTED) { + tpmif->status = DISCONNECTING; + mask_evtchn(tpmif->evtchn); + + if(gntmap_munmap(>pmdev.map, (unsigned long)tpmif->tx, 1)) { + TPMBACK_ERR("%u/%u Error occured while trying to unmap shared page\n", (unsigned int) tpmif->domid, tpmif->handle); + } + + unbind_evtchn(tpmif->evtchn); + } + tpmif->status = DISCONNECTED; + tpmif_change_state(tpmif, XenbusStateClosed); + + /* Do the callback now */ + if(gtpmdev.close_callback) { + gtpmdev.close_callback(tpmif->domid, tpmif->handle); + } + + /* remove from array */ + remove_tpmif(tpmif); + + /* Wake up anyone possibly waiting on this interface and let them exit */ + wake_up(&waitq); + schedule(); + + /* Remove the old xenbus entries */ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_rm(XBT_NIL, path))) { + TPMBACK_ERR("Error cleaning up xenbus entries path=%s error=%s\n", path, err); + free(err); + } + + TPMBACK_LOG("Frontend %u/%u disconnected\n", (unsigned int) tpmif->domid, tpmif->handle); + + /* free memory */ + __free_tpmif(tpmif); + +} + +/********************** + * REMAINING TPMBACK FUNCTIONS + * ********************/ + +/*Event channel handler */ +void tpmback_handler(evtchn_port_t port, struct pt_regs *regs, void *data) +{ + tpmif_t* tpmif = (tpmif_t*) data; + tpmif_tx_request_t* tx = &tpmif->tx->ring[0].req; + /* Throw away 0 size events, these can trigger from event channel unmasking */ + if(tx->size == 0) + return; + + TPMBACK_DEBUG("EVENT CHANNEL FIRE %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + tpmif_req_ready(tpmif); + wake_up(&waitq); + +} + +/* Connect to frontend */ +int connect_fe(tpmif_t* tpmif) +{ + char path[512]; + char* err, *value; + uint32_t domid; + grant_ref_t ringref; + evtchn_port_t evtchn; + + /* If already connected then quit */ + if (tpmif->status == CONNECTED) { + TPMBACK_DEBUG("%u/%u tried to connect while it was already connected?\n", (unsigned int) tpmif->domid, tpmif->handle); + return 0; + } + + /* Fetch the grant reference */ + snprintf(path, 512, "%s/ring-ref", tpmif->fe_path); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s) Error = %s", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &ringref) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + + /* Fetch the event channel*/ + snprintf(path, 512, "%s/event-channel", tpmif->fe_path); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMBACK_ERR("Error creating new tpm instance xenbus_read(%s) Error = %s", path, err); + free(err); + return -1; + } + if(sscanf(value, "%d", &evtchn) != 1) { + TPMBACK_ERR("Non integer value (%s) in %s ??\n", value, path); + free(value); + return -1; + } + free(value); + + domid = tpmif->domid; + if((tpmif->tx = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &ringref, PROT_READ | PROT_WRITE)) == NULL) { + TPMBACK_ERR("Failed to map grant reference %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + return -1; + } + memset(tpmif->tx, 0, PAGE_SIZE); + + /*Bind the event channel */ + if((evtchn_bind_interdomain(tpmif->domid, evtchn, tpmback_handler, tpmif, &tpmif->evtchn))) + { + TPMBACK_ERR("%u/%u Unable to bind to interdomain event channel!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error_post_map; + } + unmask_evtchn(tpmif->evtchn); + + /* Write the ready flag and change status to connected */ + snprintf(path, 512, "backend/vtpm/%u/%u", (unsigned int) tpmif->domid, tpmif->handle); + if((err = xenbus_printf(XBT_NIL, path, "ready", "%u", 1))) { + TPMBACK_ERR("%u/%u Unable to write ready flag on connect_fe()\n", (unsigned int) tpmif->domid, tpmif->handle); + free(err); + goto error_post_evtchn; + } + tpmif->status = CONNECTED; + if((tpmif_change_state(tpmif, XenbusStateConnected))){ + goto error_post_evtchn; + } + + TPMBACK_LOG("Frontend %u/%u connected\n", (unsigned int) tpmif->domid, tpmif->handle); + + return 0; +error_post_evtchn: + mask_evtchn(tpmif->evtchn); + unbind_evtchn(tpmif->evtchn); +error_post_map: + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->tx, 1); + return -1; +} + +static int frontend_changed(tpmif_t* tpmif) +{ + int state = xenbus_read_integer(tpmif->fe_state_path); + if(state < 0) { + state = XenbusStateUnknown; + } + + TPMBACK_DEBUG("Frontend %u/%u state changed to %d\n", (unsigned int) tpmif->domid, tpmif->handle, state); + + switch (state) { + case XenbusStateInitialising: + case XenbusStateInitialised: + break; + + case XenbusStateConnected: + if(connect_fe(tpmif)) { + TPMBACK_ERR("Failed to connect to front end %u/%u\n", (unsigned int) tpmif->domid, tpmif->handle); + tpmif_change_state(tpmif, XenbusStateClosed); + return -1; + } + break; + + case XenbusStateClosing: + tpmif_change_state(tpmif, XenbusStateClosing); + break; + + case XenbusStateUnknown: /* keep it here */ + case XenbusStateClosed: + free_tpmif(tpmif); + break; + + default: + TPMBACK_DEBUG("BAD STATE CHANGE %u/%u state = %d for tpmif\n", (unsigned int) tpmif->domid, tpmif->handle, state); + return -1; + } + return 0; +} + + +/* parses the string that comes out of xenbus_watch_wait_return. */ +static int parse_eventstr(const char* evstr, domid_t* domid, unsigned int* handle) +{ + int ret; + char cmd[40]; + char* err; + char* value; + unsigned int udomid = 0; + tpmif_t* tpmif; + /* First check for new frontends, this occurs when /backend/vtpm// gets created. Note we what the sscanf to fail on the last %s */ + if (sscanf(evstr, "backend/vtpm/%u/%u/%40s", &udomid, handle, cmd) == 2) { + *domid = udomid; + /* Make sure the entry exists, if this event triggers because the entry dissapeared then ignore it */ + if((err = xenbus_read(XBT_NIL, evstr, &value))) { + free(err); + return EV_NONE; + } + free(value); + /* Make sure the tpmif entry does not already exist, this should not happen */ + if((tpmif = get_tpmif(*domid, *handle)) != NULL) { + TPMBACK_DEBUG("Duplicate tpm entries! %u %u\n", tpmif->domid, tpmif->handle); + return EV_NONE; + } + return EV_NEWFE; + } else if((ret = sscanf(evstr, "/local/domain/%u/device/vtpm/%u/%40s", &udomid, handle, cmd)) == 3) { + *domid = udomid; + if (!strcmp(cmd, "state")) + return EV_STCHNG; + } + return EV_NONE; +} + +void handle_backend_event(char* evstr) { + tpmif_t* tpmif; + domid_t domid; + unsigned int handle; + int event; + + TPMBACK_DEBUG("Xenbus Event: %s\n", evstr); + + event = parse_eventstr(evstr, &domid, &handle); + + switch(event) { + case EV_NEWFE: + if(new_tpmif(domid, handle) == NULL) { + TPMBACK_ERR("Failed to create new tpm instance %u/%u\n", (unsigned int) domid, handle); + } + wake_up(&waitq); + break; + case EV_STCHNG: + if((tpmif = get_tpmif(domid, handle))) { + frontend_changed(tpmif); + } else { + TPMBACK_DEBUG("Event Received for non-existant tpm! instance=%u/%u xenbus_event=%s\n", (unsigned int) domid, handle, evstr); + } + break; + } +} + +/* Runs through the given path and creates events recursively + * for all of its children. + * @path - xenstore path to scan */ +static void generate_backend_events(const char* path) +{ + char* err; + int i, len; + char **dirs; + char *entry; + + if((err = xenbus_ls(XBT_NIL, path, &dirs)) != NULL) { + free(err); + return; + } + + for(i = 0; dirs[i] != NULL; ++i) { + len = strlen(path) + strlen(dirs[i]) + 2; + entry = malloc(len); + snprintf(entry, len, "%s/%s", path, dirs[i]); + + /* Generate and handle event for the entry itself */ + handle_backend_event(entry); + + /* Do children */ + generate_backend_events(entry); + + /* Cleanup */ + free(entry); + free(dirs[i]); + } + free(dirs); + return; +} + +unsigned char* tpmback_get_uuid(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + if((tpmif = get_tpmif(domid, handle)) == NULL) { + TPMBACK_DEBUG("get_uuid() failed, %u/%u is an invalid frontend\n", (unsigned int) domid, handle); + return NULL; + } + + return tpmif->uuid; +} + +void tpmback_set_open_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.open_callback = cb; +} +void tpmback_set_close_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.close_callback = cb; +} +void tpmback_set_suspend_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.suspend_callback = cb; +} +void tpmback_set_resume_callback(void (*cb)(domid_t, unsigned int)) +{ + gtpmdev.resume_callback = cb; +} + +static void event_listener(void) +{ + const char* bepath = "backend/vtpm"; + char **path; + char* err; + + /* Setup the backend device watch */ + if((err = xenbus_watch_path_token(XBT_NIL, bepath, bepath, >pmdev.events)) != NULL) { + TPMBACK_ERR("xenbus_watch_path_token(%s) failed with error %s!\n", bepath, err); + free(err); + goto egress; + } + + /* Check for any frontends that connected before we set the watch. + * This is almost guaranteed to happen if both domains are started + * immediatly one after the other. + * We do this by manually generating events on everything in the backend + * path */ + generate_backend_events(bepath); + + /* Wait and listen for changes in frontend connections */ + while(1) { + path = xenbus_wait_for_watch_return(>pmdev.events); + + /*If quit flag was set then exit */ + if(gtpmdev.flags & TPMIF_CLOSED) { + TPMBACK_DEBUG("listener thread got quit event. Exiting..\n"); + free(path); + break; + } + handle_backend_event(*path); + free(path); + + } + + if((err = xenbus_unwatch_path_token(XBT_NIL, bepath, bepath)) != NULL) { + free(err); + } +egress: + return; +} + +void event_thread(void* p) { + event_listener(); +} + +void init_tpmback(void) +{ + if(!globalinit) { + init_waitqueue_head(&waitq); + globalinit = 1; + } + printk("============= Init TPM BACK ================\n"); + gtpmdev.tpmlist = malloc(sizeof(tpmif_t*) * DEF_ARRAY_SIZE); + gtpmdev.num_alloc = DEF_ARRAY_SIZE; + gtpmdev.num_tpms = 0; + gtpmdev.flags = 0; + + gtpmdev.open_callback = gtpmdev.close_callback = NULL; + gtpmdev.suspend_callback = gtpmdev.resume_callback = NULL; + + eventthread = create_thread("tpmback-listener", event_thread, NULL); + +} + +void shutdown_tpmback(void) +{ + /* Disable callbacks */ + gtpmdev.open_callback = gtpmdev.close_callback = NULL; + gtpmdev.suspend_callback = gtpmdev.resume_callback = NULL; + + TPMBACK_LOG("Shutting down tpm backend\n"); + /* Set the quit flag */ + gtpmdev.flags = TPMIF_CLOSED; + + //printk("num tpms is %d\n", gtpmdev.num_tpms); + /*Free all backend instances */ + while(gtpmdev.num_tpms) { + free_tpmif(gtpmdev.tpmlist[0]); + } + free(gtpmdev.tpmlist); + gtpmdev.tpmlist = NULL; + gtpmdev.num_alloc = 0; + + /* Wake up anyone possibly waiting on the device and let them exit */ + wake_up(&waitq); + schedule(); +} + +inline void init_tpmcmd(tpmcmd_t* tpmcmd, domid_t domid, unsigned int handle, unsigned char uuid[16]) +{ + tpmcmd->domid = domid; + tpmcmd->handle = handle; + memcpy(tpmcmd->uuid, uuid, sizeof(tpmcmd->uuid)); + tpmcmd->req = NULL; + tpmcmd->req_len = 0; + tpmcmd->resp = NULL; + tpmcmd->resp_len = 0; +} + +tpmcmd_t* get_request(tpmif_t* tpmif) { + tpmcmd_t* cmd; + tpmif_tx_request_t* tx; + int offset; + int tocopy; + int i; + uint32_t domid; + int flags; + + local_irq_save(flags); + + /* Allocate the cmd object to hold the data */ + if((cmd = malloc(sizeof(*cmd))) == NULL) { + goto error; + } + init_tpmcmd(cmd, tpmif->domid, tpmif->handle, tpmif->uuid); + + tx = &tpmif->tx->ring[0].req; + cmd->req_len = tx->size; + /* Allocate the buffer */ + if(cmd->req_len) { + if((cmd->req = malloc(cmd->req_len)) == NULL) { + goto error; + } + } + /* Copy the bits from the shared pages */ + offset = 0; + for(i = 0; i < TPMIF_TX_RING_SIZE && offset < cmd->req_len; ++i) { + tx = &tpmif->tx->ring[i].req; + + /* Map the page with the data */ + domid = (uint32_t)tpmif->domid; + if((tpmif->pages[i] = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &tx->ref, PROT_READ)) == NULL) { + TPMBACK_ERR("%u/%u Unable to map shared page during read!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + + /* do the copy now */ + tocopy = min(cmd->req_len - offset, PAGE_SIZE); + memcpy(&cmd->req[offset], tpmif->pages[i], tocopy); + offset += tocopy; + + /* release the page */ + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->pages[i], 1); + + } + +#ifdef TPMBACK_PRINT_DEBUG + TPMBACK_DEBUG("Received Tpm Command from %u/%u of size %u", (unsigned int) tpmif->domid, tpmif->handle, cmd->req_len); + for(i = 0; i < cmd->req_len; ++i) { + if (!(i % 30)) { + TPMBACK_DEBUG_MORE("\n"); + } + TPMBACK_DEBUG_MORE("%02hhX ", cmd->req[i]); + } + TPMBACK_DEBUG_MORE("\n\n"); +#endif + + local_irq_restore(flags); + return cmd; +error: + if(cmd != NULL) { + if (cmd->req != NULL) { + free(cmd->req); + cmd->req = NULL; + } + free(cmd); + cmd = NULL; + } + local_irq_restore(flags); + return NULL; + +} + +void send_response(tpmcmd_t* cmd, tpmif_t* tpmif) +{ + tpmif_tx_request_t* tx; + int offset; + int i; + uint32_t domid; + int tocopy; + int flags; + + local_irq_save(flags); + + tx = &tpmif->tx->ring[0].req; + tx->size = cmd->resp_len; + + offset = 0; + for(i = 0; i < TPMIF_TX_RING_SIZE && offset < cmd->resp_len; ++i) { + tx = &tpmif->tx->ring[i].req; + + /* Map the page with the data */ + domid = (uint32_t)tpmif->domid; + if((tpmif->pages[i] = gntmap_map_grant_refs(>pmdev.map, 1, &domid, 0, &tx->ref, PROT_WRITE)) == NULL) { + TPMBACK_ERR("%u/%u Unable to map shared page during write!\n", (unsigned int) tpmif->domid, tpmif->handle); + goto error; + } + + /* do the copy now */ + tocopy = min(cmd->resp_len - offset, PAGE_SIZE); + memcpy(tpmif->pages[i], &cmd->resp[offset], tocopy); + offset += tocopy; + + /* release the page */ + gntmap_munmap(>pmdev.map, (unsigned long)tpmif->pages[i], 1); + + } + +#ifdef TPMBACK_PRINT_DEBUG + TPMBACK_DEBUG("Sent response to %u/%u of size %u", (unsigned int) tpmif->domid, tpmif->handle, cmd->resp_len); + for(i = 0; i < cmd->resp_len; ++i) { + if (!(i % 30)) { + TPMBACK_DEBUG_MORE("\n"); + } + TPMBACK_DEBUG_MORE("%02hhX ", cmd->resp[i]); + } + TPMBACK_DEBUG_MORE("\n\n"); +#endif + /* clear the ready flag and send the event channel notice to the frontend */ + tpmif_req_finished(tpmif); + notify_remote_via_evtchn(tpmif->evtchn); +error: + local_irq_restore(flags); + return; +} + +tpmcmd_t* tpmback_req_any(void) +{ + int i; + /* Block until something has a request */ + wait_event(waitq, (gtpmdev.flags & (TPMIF_REQ_READY | TPMIF_CLOSED))); + + /* Check if were shutting down */ + if(gtpmdev.flags & TPMIF_CLOSED) { + /* if something was waiting for us to give up the queue so it can shutdown, let it finish */ + schedule(); + return NULL; + } + + for(i = 0; i < gtpmdev.num_tpms; ++i) { + if(gtpmdev.tpmlist[i]->flags & TPMIF_REQ_READY) { + return get_request(gtpmdev.tpmlist[i]); + } + } + + TPMBACK_ERR("backend request ready flag was set but no interfaces were actually ready\n"); + return NULL; +} + +tpmcmd_t* tpmback_req(domid_t domid, unsigned int handle) +{ + tpmif_t* tpmif; + tpmif = get_tpmif(domid, handle); + if(tpmif == NULL) { + return NULL; + } + + wait_event(waitq, (tpmif->flags & (TPMIF_REQ_READY | TPMIF_CLOSED) || gtpmdev.flags & TPMIF_CLOSED)); + + /* Check if were shutting down */ + if(tpmif->flags & TPMIF_CLOSED || gtpmdev.flags & TPMIF_CLOSED) { + /* if something was waiting for us to give up the queue so it can free this instance, let it finish */ + schedule(); + return NULL; + } + + return get_request(tpmif); +} + +void tpmback_resp(tpmcmd_t* tpmcmd) +{ + tpmif_t* tpmif; + + /* Get the associated interface, if it doesnt exist then just quit */ + tpmif = get_tpmif(tpmcmd->domid, tpmcmd->handle); + if(tpmif == NULL) { + TPMBACK_ERR("Tried to send a reponse to non existant frontend %u/%u\n", (unsigned int) tpmcmd->domid, tpmcmd->handle); + goto end; + } + + if(!(tpmif->flags & TPMIF_REQ_READY)) { + TPMBACK_ERR("Tried to send response to a frontend that was not waiting for one %u/%u\n", (unsigned int) tpmcmd->domid, tpmcmd->handle); + goto end; + } + + /* Send response to frontend */ + send_response(tpmcmd, tpmif); + +end: + if(tpmcmd->req != NULL) { + free(tpmcmd->req); + } + free(tpmcmd); + return; +} + +int tpmback_wait_for_frontend_connect(domid_t *domid, unsigned int *handle) +{ + tpmif_t* tpmif; + int flags; + wait_event(waitq, ((gtpmdev.num_tpms > 0) || gtpmdev.flags & TPMIF_CLOSED)); + if(gtpmdev.flags & TPMIF_CLOSED) { + return -1; + } + local_irq_save(flags); + tpmif = gtpmdev.tpmlist[0]; + *domid = tpmif->domid; + *handle = tpmif->handle; + local_irq_restore(flags); + + return 0; +} + +int tpmback_num_frontends(void) +{ + return gtpmdev.num_tpms; +} diff -r 3015f8c6174b -r 34d52300f5d2 extras/mini-os/tpmfront.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/extras/mini-os/tpmfront.c Tue Nov 13 10:46:58 2012 +0000 @@ -0,0 +1,608 @@ +/* + * Copyright (c) 2010-2012 United States Government, as represented by + * the Secretary of Defense. All rights reserved. + * + * This code has been derived from drivers/char/tpm_vtpm.c + * from the xen 2.6.18 linux kernel + * + * Copyright (C) 2006 IBM Corporation + * + * This code has also been derived from drivers/char/tpm_xen.c + * from the xen 2.6.18 linux kernel + * + * Copyright (c) 2005, IBM Corporation + * + * which was itself derived from drivers/xen/netfront/netfront.c + * from the linux kernel + * + * Copyright (c) 2002-2004, K A Fraser + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, version 2 of the + * License. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define TPMFRONT_PRINT_DEBUG +#ifdef TPMFRONT_PRINT_DEBUG +#define TPMFRONT_DEBUG(fmt,...) printk("Tpmfront:Debug("__FILE__":%d) " fmt, __LINE__, ##__VA_ARGS__) +#define TPMFRONT_DEBUG_MORE(fmt,...) printk(fmt, ##__VA_ARGS__) +#else +#define TPMFRONT_DEBUG(fmt,...) +#endif +#define TPMFRONT_ERR(fmt,...) printk("Tpmfront:Error " fmt, ##__VA_ARGS__) +#define TPMFRONT_LOG(fmt,...) printk("Tpmfront:Info " fmt, ##__VA_ARGS__) + +#define min(a,b) (((a) < (b)) ? (a) : (b)) + +void tpmfront_handler(evtchn_port_t port, struct pt_regs *regs, void *data) { + struct tpmfront_dev* dev = (struct tpmfront_dev*) data; + /*If we get a response when we didnt make a request, just ignore it */ + if(!dev->waiting) { + return; + } + + dev->waiting = 0; +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].read = 1; + } +#endif + wake_up(&dev->waitq); +} + +static int publish_xenbus(struct tpmfront_dev* dev) { + xenbus_transaction_t xbt; + int retry; + char* err; + /* Write the grant reference and event channel to xenstore */ +again: + if((err = xenbus_transaction_start(&xbt))) { + TPMFRONT_ERR("Unable to start xenbus transaction, error was %s\n", err); + free(err); + return -1; + } + + if((err = xenbus_printf(xbt, dev->nodename, "ring-ref", "%u", (unsigned int) dev->ring_ref))) { + TPMFRONT_ERR("Unable to write %s/ring-ref, error was %s\n", dev->nodename, err); + free(err); + goto abort_transaction; + } + + if((err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u", (unsigned int) dev->evtchn))) { + TPMFRONT_ERR("Unable to write %s/event-channel, error was %s\n", dev->nodename, err); + free(err); + goto abort_transaction; + } + + if((err = xenbus_transaction_end(xbt, 0, &retry))) { + TPMFRONT_ERR("Unable to complete xenbus transaction, error was %s\n", err); + free(err); + return -1; + } + if(retry) { + goto again; + } + + return 0; +abort_transaction: + if((err = xenbus_transaction_end(xbt, 1, &retry))) { + free(err); + } + return -1; +} + +static int wait_for_backend_connect(xenbus_event_queue* events, char* path) +{ + int state; + + TPMFRONT_LOG("Waiting for backend connection..\n"); + /* Wait for the backend to connect */ + while(1) { + state = xenbus_read_integer(path); + if ( state < 0) + state = XenbusStateUnknown; + switch(state) { + /* Bad states, we quit with error */ + case XenbusStateUnknown: + case XenbusStateClosing: + case XenbusStateClosed: + TPMFRONT_ERR("Unable to connect to backend\n"); + return -1; + /* If backend is connected then break out of loop */ + case XenbusStateConnected: + TPMFRONT_LOG("Backend Connected\n"); + return 0; + default: + xenbus_wait_for_watch(events); + } + } + +} + +static int wait_for_backend_closed(xenbus_event_queue* events, char* path) +{ + int state; + + TPMFRONT_LOG("Waiting for backend to close..\n"); + while(1) { + state = xenbus_read_integer(path); + if ( state < 0) + state = XenbusStateUnknown; + switch(state) { + case XenbusStateUnknown: + TPMFRONT_ERR("Backend Unknown state, forcing shutdown\n"); + return -1; + case XenbusStateClosed: + TPMFRONT_LOG("Backend Closed\n"); + return 0; + default: + xenbus_wait_for_watch(events); + } + } + +} + +static int wait_for_backend_state_changed(struct tpmfront_dev* dev, XenbusState state) { + char* err; + int ret = 0; + xenbus_event_queue events = NULL; + char path[512]; + + snprintf(path, 512, "%s/state", dev->bepath); + /*Setup the watch to wait for the backend */ + if((err = xenbus_watch_path_token(XBT_NIL, path, path, &events))) { + TPMFRONT_ERR("Could not set a watch on %s, error was %s\n", path, err); + free(err); + return -1; + } + + /* Do the actual wait loop now */ + switch(state) { + case XenbusStateConnected: + ret = wait_for_backend_connect(&events, path); + break; + case XenbusStateClosed: + ret = wait_for_backend_closed(&events, path); + break; + default: + break; + } + + if((err = xenbus_unwatch_path_token(XBT_NIL, path, path))) { + TPMFRONT_ERR("Unable to unwatch %s, error was %s, ignoring..\n", path, err); + free(err); + } + return ret; +} + +static int tpmfront_connect(struct tpmfront_dev* dev) +{ + char* err; + /* Create shared page */ + dev->tx = (tpmif_tx_interface_t*) alloc_page(); + if(dev->tx == NULL) { + TPMFRONT_ERR("Unable to allocate page for shared memory\n"); + goto error; + } + memset(dev->tx, 0, PAGE_SIZE); + dev->ring_ref = gnttab_grant_access(dev->bedomid, virt_to_mfn(dev->tx), 0); + TPMFRONT_DEBUG("grant ref is %lu\n", (unsigned long) dev->ring_ref); + + /*Create event channel */ + if(evtchn_alloc_unbound(dev->bedomid, tpmfront_handler, dev, &dev->evtchn)) { + TPMFRONT_ERR("Unable to allocate event channel\n"); + goto error_postmap; + } + unmask_evtchn(dev->evtchn); + TPMFRONT_DEBUG("event channel is %lu\n", (unsigned long) dev->evtchn); + + /* Write the entries to xenstore */ + if(publish_xenbus(dev)) { + goto error_postevtchn; + } + + /* Change state to connected */ + dev->state = XenbusStateConnected; + + /* Tell the backend that we are ready */ + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", dev->state))) { + TPMFRONT_ERR("Unable to write to xenstore %s/state, value=%u", dev->nodename, XenbusStateConnected); + free(err); + goto error; + } + + return 0; +error_postevtchn: + mask_evtchn(dev->evtchn); + unbind_evtchn(dev->evtchn); +error_postmap: + gnttab_end_access(dev->ring_ref); + free_page(dev->tx); +error: + return -1; +} + +struct tpmfront_dev* init_tpmfront(const char* _nodename) +{ + struct tpmfront_dev* dev; + const char* nodename; + char path[512]; + char* value, *err; + unsigned long long ival; + int i; + + printk("============= Init TPM Front ================\n"); + + dev = malloc(sizeof(struct tpmfront_dev)); + memset(dev, 0, sizeof(struct tpmfront_dev)); + +#ifdef HAVE_LIBC + dev->fd = -1; +#endif + + nodename = _nodename ? _nodename : "device/vtpm/0"; + dev->nodename = strdup(nodename); + + init_waitqueue_head(&dev->waitq); + + /* Get backend domid */ + snprintf(path, 512, "%s/backend-id", dev->nodename); + if((err = xenbus_read(XBT_NIL, path, &value))) { + TPMFRONT_ERR("Unable to read %s during tpmfront initialization! error = %s\n", path, err); + free(err); + goto error; + } + if(sscanf(value, "%llu", &ival) != 1) { + TPMFRONT_ERR("%s has non-integer value (%s)\n", path, value); + free(value); + goto error; + } + free(value); + dev->bedomid = ival; + + /* Get backend xenstore path */ + snprintf(path, 512, "%s/backend", dev->nodename); + if((err = xenbus_read(XBT_NIL, path, &dev->bepath))) { + TPMFRONT_ERR("Unable to read %s during tpmfront initialization! error = %s\n", path, err); + free(err); + goto error; + } + + /* Create and publish grant reference and event channel */ + if (tpmfront_connect(dev)) { + goto error; + } + + /* Wait for backend to connect */ + if( wait_for_backend_state_changed(dev, XenbusStateConnected)) { + goto error; + } + + /* Allocate pages that will contain the messages */ + dev->pages = malloc(sizeof(void*) * TPMIF_TX_RING_SIZE); + if(dev->pages == NULL) { + goto error; + } + memset(dev->pages, 0, sizeof(void*) * TPMIF_TX_RING_SIZE); + for(i = 0; i < TPMIF_TX_RING_SIZE; ++i) { + dev->pages[i] = (void*)alloc_page(); + if(dev->pages[i] == NULL) { + goto error; + } + } + + TPMFRONT_LOG("Initialization Completed successfully\n"); + + return dev; + +error: + shutdown_tpmfront(dev); + return NULL; +} +void shutdown_tpmfront(struct tpmfront_dev* dev) +{ + char* err; + char path[512]; + int i; + tpmif_tx_request_t* tx; + if(dev == NULL) { + return; + } + TPMFRONT_LOG("Shutting down tpmfront\n"); + /* disconnect */ + if(dev->state == XenbusStateConnected) { + dev->state = XenbusStateClosing; + //FIXME: Transaction for this? + /* Tell backend we are closing */ + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", (unsigned int) dev->state))) { + free(err); + } + + /* Clean up xenstore entries */ + snprintf(path, 512, "%s/event-channel", dev->nodename); + if((err = xenbus_rm(XBT_NIL, path))) { + free(err); + } + snprintf(path, 512, "%s/ring-ref", dev->nodename); + if((err = xenbus_rm(XBT_NIL, path))) { + free(err); + } + + /* Tell backend we are closed */ + dev->state = XenbusStateClosed; + if((err = xenbus_printf(XBT_NIL, dev->nodename, "state", "%u", (unsigned int) dev->state))) { + TPMFRONT_ERR("Unable to write to %s, error was %s", dev->nodename, err); + free(err); + } + + /* Wait for the backend to close and unmap shared pages, ignore any errors */ + wait_for_backend_state_changed(dev, XenbusStateClosed); + + /* Cleanup any shared pages */ + if(dev->pages) { + for(i = 0; i < TPMIF_TX_RING_SIZE; ++i) { + if(dev->pages[i]) { + tx = &dev->tx->ring[i].req; + if(tx->ref != 0) { + gnttab_end_access(tx->ref); + } + free_page(dev->pages[i]); + } + } + free(dev->pages); + } + + /* Close event channel and unmap shared page */ + mask_evtchn(dev->evtchn); + unbind_evtchn(dev->evtchn); + gnttab_end_access(dev->ring_ref); + + free_page(dev->tx); + + } + + /* Cleanup memory usage */ + if(dev->respbuf) { + free(dev->respbuf); + } + if(dev->bepath) { + free(dev->bepath); + } + if(dev->nodename) { + free(dev->nodename); + } + free(dev); +} + +int tpmfront_send(struct tpmfront_dev* dev, const uint8_t* msg, size_t length) +{ + int i; + tpmif_tx_request_t* tx = NULL; + /* Error Checking */ + if(dev == NULL || dev->state != XenbusStateConnected) { + TPMFRONT_ERR("Tried to send message through disconnected frontend\n"); + return -1; + } + +#ifdef TPMFRONT_PRINT_DEBUG + TPMFRONT_DEBUG("Sending Msg to backend size=%u", (unsigned int) length); + for(i = 0; i < length; ++i) { + if(!(i % 30)) { + TPMFRONT_DEBUG_MORE("\n"); + } + TPMFRONT_DEBUG_MORE("%02X ", msg[i]); + } + TPMFRONT_DEBUG_MORE("\n"); +#endif + + /* Copy to shared pages now */ + for(i = 0; length > 0 && i < TPMIF_TX_RING_SIZE; ++i) { + /* Share the page */ + tx = &dev->tx->ring[i].req; + tx->unused = 0; + tx->addr = virt_to_mach(dev->pages[i]); + tx->ref = gnttab_grant_access(dev->bedomid, virt_to_mfn(dev->pages[i]), 0); + /* Copy the bits to the page */ + tx->size = length > PAGE_SIZE ? PAGE_SIZE : length; + memcpy(dev->pages[i], &msg[i * PAGE_SIZE], tx->size); + + /* Update counters */ + length -= tx->size; + } + dev->waiting = 1; + dev->resplen = 0; +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].read = 0; + files[dev->fd].tpmfront.respgot = 0; + files[dev->fd].tpmfront.offset = 0; + } +#endif + notify_remote_via_evtchn(dev->evtchn); + return 0; +} +int tpmfront_recv(struct tpmfront_dev* dev, uint8_t** msg, size_t *length) +{ + tpmif_tx_request_t* tx; + int i; + if(dev == NULL || dev->state != XenbusStateConnected) { + TPMFRONT_ERR("Tried to receive message from disconnected frontend\n"); + return -1; + } + /*Wait for the response */ + wait_event(dev->waitq, (!dev->waiting)); + + /* Initialize */ + *msg = NULL; + *length = 0; + + /* special case, just quit */ + tx = &dev->tx->ring[0].req; + if(tx->size == 0 ) { + goto quit; + } + /* Get the total size */ + tx = &dev->tx->ring[0].req; + for(i = 0; i < TPMIF_TX_RING_SIZE && tx->size > 0; ++i) { + tx = &dev->tx->ring[i].req; + *length += tx->size; + } + /* Alloc the buffer */ + if(dev->respbuf) { + free(dev->respbuf); + } + *msg = dev->respbuf = malloc(*length); + dev->resplen = *length; + /* Copy the bits */ + tx = &dev->tx->ring[0].req; + for(i = 0; i < TPMIF_TX_RING_SIZE && tx->size > 0; ++i) { + tx = &dev->tx->ring[i].req; + memcpy(&(*msg)[i * PAGE_SIZE], dev->pages[i], tx->size); + gnttab_end_access(tx->ref); + tx->ref = 0; + } +#ifdef TPMFRONT_PRINT_DEBUG + TPMFRONT_DEBUG("Received response from backend size=%u", (unsigned int) *length); + for(i = 0; i < *length; ++i) { + if(!(i % 30)) { + TPMFRONT_DEBUG_MORE("\n"); + } + TPMFRONT_DEBUG_MORE("%02X ", (*msg)[i]); + } + TPMFRONT_DEBUG_MORE("\n"); +#endif +#ifdef HAVE_LIBC + if(dev->fd >= 0) { + files[dev->fd].tpmfront.respgot = 1; + } +#endif +quit: + return 0; +} + +int tpmfront_cmd(struct tpmfront_dev* dev, uint8_t* req, size_t reqlen, uint8_t** resp, size_t* resplen) +{ + int rc; + if((rc = tpmfront_send(dev, req, reqlen))) { + return rc; + } + if((rc = tpmfront_recv(dev, resp, resplen))) { + return rc; + } + + return 0; +} + +#ifdef HAVE_LIBC +#include +int tpmfront_open(struct tpmfront_dev* dev) +{ + /* Silently prevent multiple opens */ + if(dev->fd != -1) { + return dev->fd; + } + + dev->fd = alloc_fd(FTYPE_TPMFRONT); + printk("tpmfront_open(%s) -> %d\n", dev->nodename, dev->fd); + files[dev->fd].tpmfront.dev = dev; + files[dev->fd].tpmfront.offset = 0; + files[dev->fd].tpmfront.respgot = 0; + return dev->fd; +} + +int tpmfront_posix_write(int fd, const uint8_t* buf, size_t count) +{ + int rc; + struct tpmfront_dev* dev; + dev = files[fd].tpmfront.dev; + + if(count == 0) { + return 0; + } + + /* Return an error if we are already processing a command */ + if(dev->waiting) { + errno = EINPROGRESS; + return -1; + } + /* Send the command now */ + if((rc = tpmfront_send(dev, buf, count)) != 0) { + errno = EIO; + return -1; + } + return count; +} + +int tpmfront_posix_read(int fd, uint8_t* buf, size_t count) +{ + int rc; + uint8_t* dummybuf; + size_t dummysz; + struct tpmfront_dev* dev; + + dev = files[fd].tpmfront.dev; + + if(count == 0) { + return 0; + } + + /* get the response if we haven't already */ + if(files[dev->fd].tpmfront.respgot == 0) { + if ((rc = tpmfront_recv(dev, &dummybuf, &dummysz)) != 0) { + errno = EIO; + return -1; + } + } + + /* handle EOF case */ + if(files[dev->fd].tpmfront.offset >= dev->resplen) { + return 0; + } + + /* Compute the number of bytes and do the copy operation */ + if((rc = min(count, dev->resplen - files[dev->fd].tpmfront.offset)) != 0) { + memcpy(buf, dev->respbuf + files[dev->fd].tpmfront.offset, rc); + files[dev->fd].tpmfront.offset += rc; + } + + return rc; +} + +int tpmfront_posix_fstat(int fd, struct stat* buf) +{ + uint8_t* dummybuf; + size_t dummysz; + int rc; + struct tpmfront_dev* dev = files[fd].tpmfront.dev; + + /* If we have a response waiting, then read it now from the backend + * so we can get its length*/ + if(dev->waiting || (files[dev->fd].read == 1 && !files[dev->fd].tpmfront.respgot)) { + if ((rc = tpmfront_recv(dev, &dummybuf, &dummysz)) != 0) { + errno = EIO; + return -1; + } + } + + buf->st_mode = O_RDWR; + buf->st_uid = 0; + buf->st_gid = 0; + buf->st_size = dev->resplen; + buf->st_atime = buf->st_mtime = buf->st_ctime = time(NULL); + + return 0; +} + + +#endif _______________________________________________ Xen-changelog mailing list Xen-changelog@lists.xen.org http://lists.xensource.com/xen-changelog From xen-changelog-bounces@lists.xen.org Tue Nov 13 16:22:33 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 13 Nov 2012 16:22:33 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFw-0004Kt-LB; Tue, 13 Nov 2012 16:22:32 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFt-0004JX-1Y for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:30 +0000 Received: from [193.109.254.147:63011] by server-14.bemta-14.messagelabs.com id 8B/1F-14517-4C372A05; Tue, 13 Nov 2012 16:22:28 +0000 X-Env-Sender: xen@xenbits.xen.org X-Msg-Ref: server-3.tower-27.messagelabs.com!1352823732!10806758!1 X-Originating-IP: [50.57.168.107] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 8563 invoked from network); 13 Nov 2012 16:22:13 -0000 Received: from mail.xen.org (HELO mail.xen.org) (50.57.168.107) by server-3.tower-27.messagelabs.com with AES256-SHA encrypted SMTP; 13 Nov 2012 16:22:13 -0000 Received: from xenbits.xen.org ([50.57.170.242]) by mail.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYJFb-00037u-QR for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:11 +0000 Received: from xen by xenbits.xen.org with local (Exim 4.72) (envelope-from ) id 1TYJFb-0006ia-L6 for xen-changelog@lists.xensource.com; Tue, 13 Nov 2012 16:22:11 +0000 Message-Id: Date: Tue, 13 Nov 2012 16:22:11 +0000 From: Xen patchbot-unstable To: xen-changelog@lists.xensource.com Subject: [Xen-changelog] [xen-unstable] tools: Remove the vtpm process model X-BeenThere: xen-changelog@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: xen-devel@lists.xensource.com List-Id: "Change log for Mercurial \(receive only\)" 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-changelog-bounces@lists.xen.org Errors-To: xen-changelog-bounces@lists.xen.org # HG changeset patch # User Matthew Fioravante # Date 1352803620 0 # Node ID 170d45f7a2ebde462743d98c77a1d10ee0f51a29 # Parent 2a4c1d3a080e7d3b20354155b6ac09e53d812cc6 tools: Remove the vtpm process model Remove the old vtpm process model. It doesn't work very well and is no longer supported. Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell Committed-by: Ian Campbell --- diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/Makefile --- a/tools/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/Makefile Tue Nov 13 10:47:00 2012 +0000 @@ -18,8 +18,6 @@ SUBDIRS-$(CONFIG_XCUTILS) += xcutils SUBDIRS-$(CONFIG_X86) += firmware SUBDIRS-y += console SUBDIRS-y += xenmon -SUBDIRS-$(VTPM_TOOLS) += vtpm_manager -SUBDIRS-$(VTPM_TOOLS) += vtpm SUBDIRS-y += xenstat SUBDIRS-$(CONFIG_Linux) += $(SUBDIRS-libaio) SUBDIRS-$(CONFIG_Linux) += memshr diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/blktap2/drivers/hashtable.c --- a/tools/blktap2/drivers/hashtable.c Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/blktap2/drivers/hashtable.c Tue Nov 13 10:47:00 2012 +0000 @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable.c - * - tools/vtpm_manager/util/hashtable.c */ #include "hashtable.h" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/blktap2/drivers/hashtable.h --- a/tools/blktap2/drivers/hashtable.h Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/blktap2/drivers/hashtable.h Tue Nov 13 10:47:00 2012 +0000 @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable.h - * - tools/vtpm_manager/util/hashtable.h */ #ifndef __HASHTABLE_CWC22_H__ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/blktap2/drivers/hashtable_itr.c --- a/tools/blktap2/drivers/hashtable_itr.c Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/blktap2/drivers/hashtable_itr.c Tue Nov 13 10:47:00 2012 +0000 @@ -1,10 +1,5 @@ /* Copyright (C) 2002, 2004 Christopher Clark */ -/* - * There are duplicates of this code in: - * - tools/vtpm_manager/util/hashtable_itr.c - */ - #include "hashtable.h" #include "hashtable_private.h" #include "hashtable_itr.h" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/blktap2/drivers/hashtable_itr.h --- a/tools/blktap2/drivers/hashtable_itr.h Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/blktap2/drivers/hashtable_itr.h Tue Nov 13 10:47:00 2012 +0000 @@ -1,10 +1,5 @@ /* Copyright (C) 2002, 2004 Christopher Clark */ -/* - * There are duplicates of this code in: - * - tools/vtpm_manager/util/hashtable_itr.h - */ - #ifndef __HASHTABLE_ITR_CWC22__ #define __HASHTABLE_ITR_CWC22__ #include "hashtable.h" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/blktap2/drivers/hashtable_private.h --- a/tools/blktap2/drivers/hashtable_private.h Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/blktap2/drivers/hashtable_private.h Tue Nov 13 10:47:00 2012 +0000 @@ -3,7 +3,6 @@ /* * There are duplicates of this code in: * - tools/xenstore/hashtable_private.h - * - tools/vtpm_manager/util/hashtable_private.h */ #ifndef __HASHTABLE_PRIVATE_CWC22_H__ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/configure.ac --- a/tools/configure.ac Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/configure.ac Tue Nov 13 10:47:00 2012 +0000 @@ -40,7 +40,6 @@ m4_include([m4/fetcher.m4]) # Enable/disable options AX_ARG_DEFAULT_DISABLE([githttp], [Download GIT repositories via HTTP]) AX_ARG_DEFAULT_ENABLE([monitors], [Disable xenstat and xentop monitoring tools]) -AX_ARG_DEFAULT_DISABLE([vtpm], [Enable Virtual Trusted Platform Module]) AX_ARG_DEFAULT_DISABLE([xenapi], [Enable Xen API Bindings]) AX_ARG_DEFAULT_ENABLE([ocamltools], [Disable Ocaml tools]) AX_ARG_DEFAULT_DISABLE([miniterm], [Enable miniterm]) diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/examples/README --- a/tools/examples/README Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/examples/README Tue Nov 13 10:47:00 2012 +0000 @@ -25,13 +25,7 @@ vif-bridge - virtual network st vif-common.sh - sourced by vif-bridge vif-nat - xen virtual network start/stop script in NAT mode vif-route - xen virtual network start/stop script in routed mode -vtpm - called by xen-backend.agent to bind/unbind vTPM devices -vtpm-common.sh - common code for vTPM handling -vtpm-delete - remove an entry from the vTPM table given the - domain's name -vtpm-hotplug-common.sh - sourced by vtpm -vtpm-migration.sh - sourced by external-device-migrate -xen-backend.agent - calls block, vif-*, vtpm scripts to add, remove, hotplug +xen-backend.agent - calls block, vif-* scripts to add, remove, hotplug devices xen-backend.rules - hotplug script rules xend-config.sxp - default xend configuration file diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/examples/xmexample.pv-grub --- a/tools/examples/xmexample.pv-grub Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/examples/xmexample.pv-grub Tue Nov 13 10:47:00 2012 +0000 @@ -105,20 +105,6 @@ disk = [ 'phy:hda1,hda1,w' ] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = [ 'instance=1,backend=0' ] - -#---------------------------------------------------------------------------- # Configure the behaviour when a domain exits. There are three 'reasons' # for a domain to stop: poweroff, reboot, and crash. For each of these you # may specify: diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/examples/xmexample1 --- a/tools/examples/xmexample1 Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/examples/xmexample1 Tue Nov 13 10:47:00 2012 +0000 @@ -101,20 +101,6 @@ disk = [ 'phy:hda1,hda1,w' ] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = [ 'instance=1,backend=0' ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/examples/xmexample2 --- a/tools/examples/xmexample2 Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/examples/xmexample2 Tue Nov 13 10:47:00 2012 +0000 @@ -137,20 +137,6 @@ disk = [ 'phy:sda%d,sda1,w' % (7+vmid), # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = ['instance=%d,backend=0' % (vmid) ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/examples/xmexample3 --- a/tools/examples/xmexample3 Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/examples/xmexample3 Tue Nov 13 10:47:00 2012 +0000 @@ -122,20 +122,6 @@ disk = [ 'phy:hda%d,hda1,w' % (vmid)] # configured in xend-config.sxp. #---------------------------------------------------------------------------- -# Define to which TPM instance the user domain should communicate. -# The vtpm entry is of the form 'instance=INSTANCE,backend=DOM' -# where INSTANCE indicates the instance number of the TPM the VM -# should be talking to and DOM provides the domain where the backend -# is located. -# Note that no two virtual machines should try to connect to the same -# TPM instance. The handling of all TPM instances does require -# some management effort in so far that VM configration files (and thus -# a VM) should be associated with a TPM instance throughout the lifetime -# of the VM / VM configuration file. The instance number must be -# greater or equal to 1. -#vtpm = ['instance=%d,backend=0' % (vmid) ] - -#---------------------------------------------------------------------------- # Set the kernel command line for the new domain. # You only need to define the IP parameters and hostname if the domain's # IP config doesn't, e.g. in ifcfg-eth0 or via DHCP. diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/Makefile --- a/tools/hotplug/Linux/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/hotplug/Linux/Makefile Tue Nov 13 10:47:00 2012 +0000 @@ -18,14 +18,12 @@ XEN_SCRIPTS += vif-setup XEN_SCRIPTS += block XEN_SCRIPTS += block-enbd block-nbd XEN_SCRIPTS += blktap -XEN_SCRIPTS += vtpm vtpm-delete XEN_SCRIPTS += xen-hotplug-cleanup XEN_SCRIPTS += external-device-migrate XEN_SCRIPTS += vscsi XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh -XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh vtpm-hotplug-common.sh -XEN_SCRIPT_DATA += vtpm-migration.sh vtpm-impl +XEN_SCRIPT_DATA += block-common.sh UDEV_RULES_DIR = $(CONFIG_DIR)/udev UDEV_RULES = xen-backend.rules xend.rules diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm --- a/tools/hotplug/Linux/vtpm Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,22 +0,0 @@ -#!/bin/bash - -dir=$(dirname "$0") -. "$dir/vtpm-hotplug-common.sh" - -vtpm_fatal_error=0 - -case "$command" in - add) - vtpm_create_instance - ;; - remove) - vtpm_remove_instance - ;; -esac - -if [ $vtpm_fatal_error -eq 0 ]; then - log debug "Successful vTPM operation '$command'." - success -else - fatal "Error while executing vTPM operation '$command'." -fi diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm-common.sh --- a/tools/hotplug/Linux/vtpm-common.sh Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,448 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# Copyright (c) 2005 XenSource Ltd. -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/logging.sh" -. "$dir/locking.sh" - -VTPMDB="/var/vtpm/vtpm.db" - -#In the vtpm-impl file some commands should be defined: -# vtpm_create, vtpm_setup, vtpm_start, etc. (see below) -if [ -r "$dir/vtpm-impl.alt" ]; then - . "$dir/vtpm-impl.alt" -elif [ -r "$dir/vtpm-impl" ]; then - . "$dir/vtpm-impl" -else - function vtpm_create () { - true - } - function vtpm_setup() { - true - } - function vtpm_start() { - true - } - function vtpm_suspend() { - true - } - function vtpm_resume() { - true - } - function vtpm_delete() { - true - } - function vtpm_migrate() { - echo "Error: vTPM migration accross machines not implemented." - } - function vtpm_migrate_local() { - echo "Error: local vTPM migration not supported" - } - function vtpm_migrate_recover() { - true - } -fi - - -#Find the instance number for the vtpm given the name of the domain -# Parameters -# - vmname : the name of the vm -# Return value -# Returns '0' if instance number could not be found, otherwise -# it returns the instance number in the variable 'instance' -function vtpmdb_find_instance () { - local vmname ret instance - vmname=$1 - ret=0 - - instance=$(cat $VTPMDB | \ - awk -vvmname=$vmname \ - '{ \ - if ( 1 != index($1,"#")) { \ - if ( $1 == vmname ) { \ - print $2; \ - exit; \ - } \ - } \ - }') - if [ "$instance" != "" ]; then - ret=$instance - fi - echo "$ret" -} - - -# Check whether a particular instance number is still available -# returns "0" if it is not available, "1" otherwise. -function vtpmdb_is_free_instancenum () { - local instance instances avail i - instance=$1 - avail=1 - #Allowed instance number range: 1-255 - if [ $instance -eq 0 -o $instance -gt 255 ]; then - avail=0 - else - instances=$(cat $VTPMDB | \ - awk \ - '{ \ - if (1 != index($1,"#")) { \ - printf("%s ",$2); \ - } \ - }') - for i in $instances; do - if [ $i -eq $instance ]; then - avail=0 - break - fi - done - fi - echo "$avail" -} - - -# Get an available instance number given the database -# Returns an unused instance number -function vtpmdb_get_free_instancenum () { - local ctr instances don found - instances=$(cat $VTPMDB | \ - awk \ - '{ \ - if (1 != index($1,"#")) { \ - printf("%s ",$2); \ - } \ - }') - ctr=1 - don=0 - while [ $don -eq 0 ]; do - found=0 - for i in $instances; do - if [ $i -eq $ctr ]; then - found=1; - break; - fi - done - - if [ $found -eq 0 ]; then - don=1 - break - fi - let ctr=ctr+1 - done - echo "$ctr" -} - - -# Add a domain name and instance number to the DB file -function vtpmdb_add_instance () { - local res vmname inst - vmname=$1 - inst=$2 - - if [ ! -f $VTPMDB ]; then - echo "#Database for VM to vTPM association" > $VTPMDB - echo "#1st column: domain name" >> $VTPMDB - echo "#2nd column: TPM instance number" >> $VTPMDB - fi - res=$(vtpmdb_validate_entry $vmname $inst) - if [ $res -eq 0 ]; then - echo "$vmname $inst" >> $VTPMDB - fi -} - - -#Validate whether an entry is the same as passed to this -#function -function vtpmdb_validate_entry () { - local res rc vmname inst - rc=0 - vmname=$1 - inst=$2 - - res=$(cat $VTPMDB | \ - awk -vvmname=$vmname \ - -vinst=$inst \ - '{ \ - if ( 1 == index($1,"#")) {\ - } else \ - if ( $1 == vmname && \ - $2 == inst) { \ - printf("1"); \ - exit; \ - } else \ - if ( $1 == vmname || \ - $2 == inst) { \ - printf("2"); \ - exit; \ - } \ - }') - - if [ "$res" == "1" ]; then - rc=1 - elif [ "$res" == "2" ]; then - rc=2 - fi - echo "$rc" -} - - -#Remove an entry from the vTPM database given its domain name -#and instance number -function vtpmdb_remove_entry () { - local vmname instance VTPMDB_TMP - vmname=$1 - instance=$2 - VTPMDB_TMP="$VTPMDB".tmp - - $(cat $VTPMDB | \ - awk -vvmname=$vmname \ - '{ \ - if ( $1 != vmname ) { \ - print $0; \ - } \ - '} > $VTPMDB_TMP) - if [ -e $VTPMDB_TMP ]; then - mv -f $VTPMDB_TMP $VTPMDB - vtpm_delete $instance - else - log err "Error creating temporary file '$VTPMDB_TMP'." - fi -} - - -# Find the reason for the creation of this device: -# Returns 'resume' or 'create' -function vtpm_get_create_reason () { - local resume - resume=$(xenstore_read $XENBUS_PATH/resume) - if [ "$resume" == "True" ]; then - echo "resume" - else - echo "create" - fi -} - - -#Create a vTPM instance -# If no entry in the TPM database is found, the instance is -# created and an entry added to the database. -function vtpm_create_instance () { - local res instance domname reason uuid - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) - reason=$(vtpm_get_create_reason) - - claim_lock vtpmdb - - instance="0" - - if [ "$uuid" != "" ]; then - instance=$(vtpmdb_find_instance $uuid) - fi - if [ "$instance" == "0" ]; then - domname=$(xenstore_read "$XENBUS_PATH"/domain) - instance=$(vtpmdb_find_instance $domname) - fi - - if [ "$instance" == "0" -a "$reason" != "create" ]; then - release_lock vtpmdb - return - fi - - if [ "$instance" == "0" ]; then - #Try to give the preferred instance to the domain - instance=$(xenstore_read "$XENBUS_PATH"/pref_instance) - if [ "$instance" != "" ]; then - res=$(vtpmdb_is_free_instancenum $instance) - if [ $res -eq 0 ]; then - instance=$(vtpmdb_get_free_instancenum) - fi - else - instance=$(vtpmdb_get_free_instancenum) - fi - - vtpm_create $instance - - if [ $vtpm_fatal_error -eq 0 ]; then - if [ "$uuid" != "" ]; then - vtpmdb_add_instance $uuid $instance - else - vtpmdb_add_instance $domname $instance - fi - fi - else - if [ "$reason" == "resume" ]; then - vtpm_resume $instance - else - vtpm_start $instance - fi - fi - - release_lock vtpmdb - - xenstore_write $XENBUS_PATH/instance $instance -} - - -#Remove an instance when a VM is terminating or suspending. -#Since it is assumed that the VM will appear again, the -#entry is kept in the VTPMDB file. -function vtpm_remove_instance () { - local instance reason domname uuid - #Stop script execution quietly if path does not exist (anymore) - xenstore-exists "$XENBUS_PATH"/domain - uuid=$(xenstore_read "$XENBUS_PATH"/uuid) - - claim_lock vtpmdb - - instance="0" - - if [ "$uuid" != "" ]; then - instance=$(vtpmdb_find_instance $uuid) - fi - - if [ "$instance" == "0" ]; then - domname=$(xenstore_read "$XENBUS_PATH"/domain) - instance=$(vtpmdb_find_instance $domname) - fi - - if [ "$instance" != "0" ]; then - vtpm_suspend $instance - fi - - release_lock vtpmdb -} - - -#Remove an entry in the VTPMDB file given the domain's name -#1st parameter: The name of the domain -function vtpm_delete_instance () { - local instance - - claim_lock vtpmdb - - instance=$(vtpmdb_find_instance $1) - if [ "$instance" != "0" ]; then - vtpmdb_remove_entry $1 $instance - fi - - release_lock vtpmdb -} - -# Determine whether the given address is local to this machine -# Return values: -# "-1" : the given machine name is invalid -# "0" : this is not an address of this machine -# "1" : this is an address local to this machine -function vtpm_isLocalAddress() { - local addr res - addr=$(ping $1 -c 1 | \ - awk '{ print substr($3,2,length($3)-2); exit }') - if [ "$addr" == "" ]; then - echo "-1" - return - fi - res=$(ifconfig | grep "inet addr" | \ - awk -vaddr=$addr \ - '{ \ - if ( addr == substr($2, 6)) {\ - print "1"; \ - } \ - }' \ - ) - if [ "$res" == "" ]; then - echo "0" - return - fi - echo "1" -} - -# Perform a migration step. This function differentiates between migration -# to the local host or to a remote machine. -# Parameters: -# 1st: destination host to migrate to -# 2nd: name of the domain to migrate -# 3rd: the migration step to perform -function vtpm_migration_step() { - local res=$(vtpm_isLocalAddress $1) - if [ "$res" == "0" ]; then - vtpm_migrate $1 $2 $3 - else - vtpm_migrate_local - fi -} - -# Recover from migration due to an error. This function differentiates -# between migration to the local host or to a remote machine. -# Parameters: -# 1st: destination host the migration was going to -# 2nd: name of the domain that was to be migrated -# 3rd: the last successful migration step that was done -function vtpm_recover() { - local res - res=$(vtpm_isLocalAddress $1) - if [ "$res" == "0" ]; then - vtpm_migrate_recover $1 $2 $3 - fi -} - - -#Determine the domain id given a domain's name. -#1st parameter: name of the domain -#return value: domain id or -1 if domain id could not be determined -function vtpm_domid_from_name () { - local id name ids - ids=$(xenstore-list /local/domain) - for id in $ids; do - name=$(xenstore-read /local/domain/$id/name) - if [ "$name" == "$1" ]; then - echo "$id" - return - fi - done - echo "-1" -} - -#Determine the virtual TPM's instance number using the domain ID. -#1st parm: domain ID -function vtpm_uuid_by_domid() { - echo $(xenstore-read /local/domain/0/backend/vtpm/$1/0/uuid) -} - - -# Determine the vTPM's UUID by the name of the VM -function vtpm_uuid_from_vmname() { - local domid=$(vtpm_domid_from_name $1) - if [ "$domid" != "-1" ]; then - echo $(vtpm_uuid_by_domid $domid) - return - fi - echo "" -} - -#Add a virtual TPM instance number and its associated domain name -#to the VTPMDB file and activate usage of this virtual TPM instance -#by writing the instance number into the xenstore -#1st parm: name of virtual machine -#2nd parm: instance of associated virtual TPM -function vtpm_add_and_activate() { - local domid=$(vtpm_domid_from_name $1) - local vtpm_uuid=$(vtpm_uuid_from_vmname $1) - if [ "$vtpm_uuid" != "" -a "$domid" != "-1" ]; then - vtpmdb_add_instance $vtpm_uuid $2 - xenstore-write backend/vtpm/$domid/0/instance $2 - fi -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm-delete --- a/tools/hotplug/Linux/vtpm-delete Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,18 +0,0 @@ -#!/bin/bash - -# This scripts must be called the following way: -# vtpm-delete -# or -# vtpm-delete --vmname - -dir=$(dirname "$0") -. "$dir/vtpm-common.sh" - -if [ "$1" == "--vmname" ]; then - vtpm_uuid=$(vtpm_uuid_from_vmname $2) - if [ "$vtpm_uuid" != "" ];then - vtpm_delete_instance $vtpm_uuid - fi -else - vtpm_delete_instance $1 -fi diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm-hotplug-common.sh --- a/tools/hotplug/Linux/vtpm-hotplug-common.sh Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,35 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# Copyright (c) 2005 XenSource Ltd. -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/xen-hotplug-common.sh" - -findCommand "$@" -if [ "$command" != "online" ] && - [ "$command" != "offline" ] && - [ "$command" != "add" ] && - [ "$command" != "remove" ] -then - log err "Invalid command: $command" - exit 1 -fi - - -XENBUS_PATH="${XENBUS_PATH:?}" - -. "$dir/vtpm-common.sh" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm-impl --- a/tools/hotplug/Linux/vtpm-impl Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,208 +0,0 @@ -#!/bin/bash -# =================================================================== -# -# 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. -# =================================================================== - -# | SRC | TAG | CMD SIZE | ORD |mtype|strt -TPM_CMD_OPEN=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x01 -TPM_CMD_RESM=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x11\\x01\\x00\\x00\\x01\\x01\\x02 -TPM_CMD_CLOS=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x02 -TPM_CMD_DELE=\\x00\\x00\\x00\\x00\\x01\\xc1\\x00\\x00\\x00\\x0e\\x01\\x00\\x00\\x03 - -TPM_TYPE_PVM=\\x01 -TPM_TYPE_HVM=\\x02 - -TPM_SUCCESS=00000000 - -TX_VTPM_MANAGER=/var/vtpm/fifos/from_console.fifo -RX_VTPM_MANAGER=/var/vtpm/fifos/to_console.fifo - -VTPM_MIG=/usr/bin/vtpm_migrator - -# -------------------- Helpers for binary streams ----------- - -function str_to_hex32() { - printf "%0.8x" $1 -} - -function hex32_to_bin() { - local inst=$(str_to_hex32 $1); - - local n1=`echo $inst | sed 's/\(..\)....../\\\\x\1/'` - local n2=`echo $inst | sed 's/..\(..\)..../\\\\x\1/'` - local n3=`echo $inst | sed 's/....\(..\)../\\\\x\1/'` - local n4=`echo $inst | sed 's/......\(..\)/\\\\x\1/'` - - echo "$n1$n2$n3$n4" -} - -function vtpm_manager_cmd() { - local cmd=$1; - local inst=$2; - local inst_bin=$(hex32_to_bin $inst); - - claim_lock vtpm_mgr - - #send cmd to vtpm_manager - printf "$cmd$inst_bin" > $TX_VTPM_MANAGER - - #recv response - set +e - local resp_hex=`dd skip=10 bs=1 count=4 if=$RX_VTPM_MANAGER 2> /dev/null | xxd -ps` - set -e - - release_lock vtpm_mgr - - #return whether the command was successful - if [ $resp_hex -ne $TPM_SUCCESS ]; then - vtpm_fatal_error=1 - false - else - true - fi -} - -# Helper to get vm type to pass to vtpm_manager open/resume -function vtpm_get_type() { - local inst=$(xenstore_read $XENBUS_PATH/frontend-id) - local vm=$(xenstore_read /local/domain/$inst/vm) - if [ "$vm" != "" ]; then - local ostype=$(xenstore-read $vm/image/ostype) - if [ "$ostype" == "hvm" ]; then - echo $TPM_TYPE_HVM; - else - echo $TPM_TYPE_PVM; - fi - fi -} - -# ------------------ Command handlers ----------------- - -# Create new vtpm instance & set it up for use -function vtpm_create () { - # Creation is handled implicitly by the manager on first setup - # so just set it up for use - $(vtpm_start $1) -} - -# Setup vtpm instance for use. -function vtpm_start() { - local vmtype=$(vtpm_get_type); - $(vtpm_manager_cmd $TPM_CMD_OPEN$vmtype $1) -} - -function vtpm_resume() { - local vmtype=$(vtpm_get_type); - $(vtpm_manager_cmd $TPM_CMD_RESM$vmtype $1) -} - -# Reset the vtpm AKA clear PCRs -function vtpm_reset() { - #not used by current implemenation - true -} - -# Shutdown the vtpm while the vm is down -# This could be a suspend of shutdown -# we cannot distinquish, so save the state -# and decide on startup if we should keep is -function vtpm_suspend() { - $(vtpm_manager_cmd $TPM_CMD_CLOS $1) -} - - -function vtpm_delete() { - local inst=$1 - if $(vtpm_manager_cmd $TPM_CMD_DELE $inst); then - rm -f /var/vtpm/vtpm_dm_$1.data - true - else - vtpm_fatal_error=1 - false - fi -} - -# Perform a migration step. This function differentiates between migration -# to the local host or to a remote machine. -# Parameters: -# 1st: destination host to migrate to -# 2nd: name of the domain to migrate -# 3rd: the migration step to perform -function vtpm_migrate() { - local instance res - - instance=$(vtpmdb_find_instance $2) - if [ "$instance" == "" ]; then - log err "VTPM Migratoin failed. Unable to translation of domain name" - echo "Error: VTPM Migration failed while looking up instance number" - fi - - case "$3" in - 0) - #Incicate migration supported - echo "0" - ;; - - 1) - # Get Public Key from Destination - # Call vtpm_manager's migration part 1 - claim_lock vtpm_mgr - $VTPM_MIG $1 $2 $instance $3 - release_lock vtpm_mgr - ;; - - 2) - # Call manager's migration step 2 and send result to destination - # If successful remove from db - claim_lock vtpm_mgr - $VTPM_MIG $1 $2 $instance $3 - release_lock vtpm_mgr - ;; - - 3) - if `ps x | grep "$VTPM_MIG $1"`; then - log err "VTPM Migration failed to complete." - echo "Error: VTPM Migration failed to complete." - fi - ;; - esac - -} - - -function vtpm_migrate_recover() { - echo "Error: Recovery not supported yet" -} - -function vtpm_migrate_local() { - echo "Error: local vTPM migration not supported" -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/vtpm-migration.sh --- a/tools/hotplug/Linux/vtpm-migration.sh Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,19 +0,0 @@ -# -# Copyright (c) 2005 IBM Corporation -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of version 2.1 of the GNU Lesser General Public -# License as published by the Free Software Foundation. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# - -dir=$(dirname "$0") -. "$dir/vtpm-common.sh" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/hotplug/Linux/xen-backend.rules --- a/tools/hotplug/Linux/xen-backend.rules Tue Nov 13 10:46:59 2012 +0000 +++ b/tools/hotplug/Linux/xen-backend.rules Tue Nov 13 10:47:00 2012 +0000 @@ -1,6 +1,5 @@ SUBSYSTEM=="xen-backend", KERNEL=="tap*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/blktap $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vbd*", ENV{UDEV_CALL}="1", RUN+="/etc/xen/scripts/block $env{ACTION}" -SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vif2-*", RUN+="/etc/xen/scripts/vif2 $env{ACTION}" SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="online", RUN+="/etc/xen/scripts/vif-setup online type_if=vif" SUBSYSTEM=="xen-backend", KERNEL=="vif-*", ENV{UDEV_CALL}="1", ACTION=="offline", RUN+="/etc/xen/scripts/vif-setup offline type_if=vif" diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/Makefile --- a/tools/vtpm/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,74 +0,0 @@ -XEN_ROOT = $(CURDIR)/../.. - -# Base definitions and rules -include $(XEN_ROOT)/tools/vtpm/Rules.mk - -# Dir name for emulator (as dom0 tpm driver) -TPM_EMULATOR_DIR = tpm_emulator -# Dir name for vtpm instance -VTPM_DIR = vtpm -ORIG_DIR = orig - -# Emulator tarball name -TPM_EMULATOR_NAME = tpm_emulator-0.5.1 -TPM_EMULATOR_TARFILE = $(TPM_EMULATOR_NAME).tar.gz - -GMP_HEADER = /usr/include/gmp.h - -.PHONY: all -all: build - -.PHONY: build -build: build_sub - -.PHONY: install -install: build - $(MAKE) -C $(VTPM_DIR) install-recursive - -.PHONY: clean -clean: - @if [ -d $(TPM_EMULATOR_DIR) ]; \ - then $(MAKE) -C $(TPM_EMULATOR_DIR) clean; \ - fi - @if [ -d $(VTPM_DIR) ]; \ - then $(MAKE) -C $(VTPM_DIR) clean; \ - fi - -.PHONY: mrproper -mrproper: - rm -f $(TPM_EMULATOR_TARFILE) tpm_emulator.patch.old vtpm.patch.old - rm -rf $(TPM_EMULATOR_DIR) $(VTPM_DIR) $(ORIG_DIR) - -# Download Swiss emulator -$(TPM_EMULATOR_TARFILE): - wget http://download.berlios.de/tpm-emulator/$(TPM_EMULATOR_TARFILE) - -# Create vtpm dirs -$(VTPM_DIR)/tpmd/tpmd: $(TPM_EMULATOR_TARFILE) vtpm-0.5.1.patch - rm -rf $(VTPM_DIR) - tar -xzf $(TPM_EMULATOR_TARFILE) - mv $(TPM_EMULATOR_NAME) $(VTPM_DIR) - - set -e; cd $(VTPM_DIR); \ - patch -p1 < ../vtpm-0.5.1.patch; \ - patch -p1 < ../vtpm-0.5.1-LDLIBS.patch - -orig: $(TPM_EMULATOR_TARFILE) - mkdir $(ORIG_DIR); - set -e; cd $(ORIG_DIR); \ - tar -xzf ../$(TPM_EMULATOR_TARFILE); - -updatepatches: clean orig - find $(VTPM_DIR) -name "*.orig" -print | xargs rm -f; - mv vtpm.patch vtpm.patch.old; - diff -uprN $(TPM_EMULATOR_DIR) $(VTPM_DIR) > vtpm.patch || true; - -.PHONY: build_sub -build_sub: $(VTPM_DIR)/tpmd/tpmd - set -e; if [ -e $(GMP_HEADER) ]; then \ - $(MAKE) -C $(VTPM_DIR) version; \ - $(MAKE) -C $(VTPM_DIR) all-recursive; \ - else \ - echo "=== Unable to build VTPMs. libgmp could not be found."; \ - fi - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/README --- a/tools/vtpm/README Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,45 +0,0 @@ - -Directory Structure -=================== -tools/vtpm/tpm_emulator-0.2b.tar.gz -> TPM Emulator downloaded at build time that will - be patched and used for our vtpms -tools/vtpm/vtpm.patch -> patch applied to tpm_emulator to make vtpm -tools/vtpm/vtpm/ -> (created on build) tpm_emulator moved to ring 3, - listens on a pair of fifos for TPM commands, - persistent state is sent via named fifo to vtpm - manager, which encrypts it and protects it. -tools/vtpm/tpm_emulator.patch -> To allow for debugging and testing on non-TPM - platforms, this patches the emulator to allow - it to be inserted into the dom0 kernel -tools/vtpm/tpm_emulator-0.2 -> (created on build) directory containing patched emulator - -Compile Flags -=================== -VTPM_MULTI_VM -> Defined (not finished): VTPMs run in their own VMs - Not Defined (default): VTPMs are processes - -Requirements -============ -- xen-unstable -- IBM frontend/backend vtpm driver patch -- vtpm_managerd -- GNU MP Big number library (GMP) - -vtpmd Flow (for vtpm_manager. vtpmd never run by default) -============================ -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. -- VTPM Manager listens to TPM BE. -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. -- When the manager receives the open message from the BE, it launches a vtpm -- Xend allows the VM to continue booting. -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. -- The fifo listener begins listening for the reply from vtpm for the request. -- Vtpm processes request and replies to manager over shared named fifo. -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. - -tpm_emulator flow -================== -Read documentation in tpm_emulator-0.2 directory diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/Rules.mk --- a/tools/vtpm/Rules.mk Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,26 +0,0 @@ -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) -include $(XEN_ROOT)/tools/Rules.mk - -# -# Tool definitions -# - -# General compiler flags -CFLAGS = -Werror -g3 - -# Generic project files -HDRS = $(wildcard *.h) -SRCS = $(wildcard *.c) -OBJS = $(patsubst %.c,%.o,$(SRCS)) - -# Generic (non-header) dependencies -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm/Rules.mk - -$(OBJS): $(SRCS) - --include $(DEPS) - -BUILD_EMULATOR = y - -# Make sure these are just rules -.PHONY : all build install clean diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/tpm_emulator.patch --- a/tools/vtpm/tpm_emulator.patch Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1919 +0,0 @@ -diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS ---- orig/tpm_emulator-0.4/AUTHORS 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/AUTHORS 2006-07-24 14:35:35.000000000 -0700 -@@ -1,2 +1,3 @@ - Mario Strasser - Heiko Stamer [DAA] -+INTEL Corp <> [Dropped to Ring3] -diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog ---- orig/tpm_emulator-0.4/ChangeLog 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/ChangeLog 2006-07-24 14:35:35.000000000 -0700 -@@ -1,3 +1,6 @@ -+????-??-?? Intel Corp -+ * Moved module out of kernel to run as a ring 3 app -+ - 2006-06-23 Mario Strasser - * tpm_startup.c: behaviour of ST_CLEAR and storage of - persistent data adapted -diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c ---- orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/crypto/gmp_kernel_wrapper.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -24,15 +25,10 @@ int __gmp_junk; - void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename, - int linenum, const char *expr) - { -- panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n", -+ error("%s:%d: GNU MP assertion failed: %s\n", - filename, linenum, expr); - } - --void __attribute__ ((regparm(0))) abort(void) --{ -- panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n"); --} -- - /* overwrite GNU MP random functions (used by mpz/millerrabin.c) */ - - void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate, -@@ -77,20 +73,19 @@ void __attribute__ ((regparm(0))) mpz_ur - - void __attribute__ ((regparm(0))) *kernel_allocate(size_t size) - { -- void *ret = (void*)kmalloc(size, GFP_KERNEL); -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME -- "GMP: cannot allocate memory (size=%u)\n", size); -+ void *ret = (void*)malloc(size); -+ if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size); - return ret; - } - - void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr, - size_t old_size, size_t new_size) - { -- void *ret = (void*)kmalloc(new_size, GFP_KERNEL); -- if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory " -- "(old_size=%u new_size=%u)\n", old_size, new_size); -+ void *ret = (void*)malloc(new_size); -+ if (!ret) error("GMP: Cannot reallocate memory " -+ "(old_size=%Zu new_size=%Zu)\n", old_size, new_size); - memcpy(ret, oldptr, old_size); -- kfree(oldptr); -+ free(oldptr); - return ret; - } - -@@ -99,7 +94,7 @@ void __attribute__ ((regparm(0))) kernel - /* overwrite used memory */ - if (blk_ptr != NULL) { - memset(blk_ptr, 0, blk_size); -- kfree(blk_ptr); -+ free(blk_ptr); - } - } - -diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c ---- orig/tpm_emulator-0.4/crypto/rsa.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/crypto/rsa.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -381,7 +382,7 @@ static int encode_message(int type, uint - msg[0] = 0x00; - get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH); - sha1_init(&ctx); -- sha1_update(&ctx, "TCPA", 4); -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); - sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]); - memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00, - msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2); -@@ -429,7 +430,7 @@ static int decode_message(int type, uint - mask_generation(&msg[1], SHA1_DIGEST_LENGTH, - &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1); - sha1_init(&ctx); -- sha1_update(&ctx, "TCPA", 4); -+ sha1_update(&ctx, (uint8_t *) "TCPA", 4); - sha1_final(&ctx, &msg[1]); - if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH], - SHA1_DIGEST_LENGTH) != 0) return -1; -diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c ---- orig/tpm_emulator-0.4/linux_module.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/linux_module.c 1969-12-31 16:00:00.000000000 -0800 -@@ -1,195 +0,0 @@ --/* Software-Based Trusted Platform Module (TPM) Emulator for Linux -- * Copyright (C) 2004 Mario Strasser , -- * -- * This module is free software; you can redistribute it and/or modify -- * it under the terms of the GNU General Public License as published -- * by the Free Software Foundation; either version 2 of the License, -- * or (at your option) any later version. -- * -- * This module is distributed in the hope that it will be useful, -- * but WITHOUT ANY WARRANTY; without even the implied warranty of -- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -- * GNU General Public License for more details. -- * -- * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $ -- */ -- --#include --#include --#include --#include --#include --#include "linux_module.h" --#include "tpm/tpm_emulator.h" -- --MODULE_LICENSE("GPL"); --MODULE_AUTHOR("Mario Strasser "); --MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator"); --MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME); -- --/* module startup parameters */ --char *startup = "save"; --module_param(startup, charp, 0444); --MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. " -- "Possible values are 'clear', 'save' (default) and 'deactivated."); --char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2"; --module_param(storage_file, charp, 0644); --MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage " -- "file of the TPM."); -- --/* TPM lock */ --static struct semaphore tpm_mutex; -- --/* TPM command response */ --static struct { -- uint8_t *data; -- uint32_t size; --} tpm_response; -- --/* module state */ --#define STATE_IS_OPEN 0 --static uint32_t module_state; --static struct timespec old_time; -- --static int tpm_open(struct inode *inode, struct file *file) --{ -- debug("%s()", __FUNCTION__); -- if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY; -- return 0; --} -- --static int tpm_release(struct inode *inode, struct file *file) --{ -- debug("%s()", __FUNCTION__); -- clear_bit(STATE_IS_OPEN, (void*)&module_state); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) { -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return 0; --} -- --static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos) --{ -- debug("%s(%d)", __FUNCTION__, count); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) { -- count = min(count, (size_t)tpm_response.size - (size_t)*ppos); -- count -= copy_to_user(buf, &tpm_response.data[*ppos], count); -- *ppos += count; -- if ((size_t)tpm_response.size == (size_t)*ppos) { -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } -- } else { -- count = 0; -- } -- up(&tpm_mutex); -- return count; --} -- --static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos) --{ -- debug("%s(%d)", __FUNCTION__, count); -- down(&tpm_mutex); -- *ppos = 0; -- if (tpm_response.data != NULL) kfree(tpm_response.data); -- if (tpm_handle_command(buf, count, &tpm_response.data, -- &tpm_response.size) != 0) { -- count = -EILSEQ; -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return count; --} -- --#define TPMIOC_CANCEL _IO('T', 0x00) --#define TPMIOC_TRANSMIT _IO('T', 0x01) -- --static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) --{ -- debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg); -- if (cmd == TPMIOC_TRANSMIT) { -- uint32_t count = ntohl(*(uint32_t*)(arg + 2)); -- down(&tpm_mutex); -- if (tpm_response.data != NULL) kfree(tpm_response.data); -- if (tpm_handle_command((char*)arg, count, &tpm_response.data, -- &tpm_response.size) == 0) { -- tpm_response.size -= copy_to_user((char*)arg, tpm_response.data, -- tpm_response.size); -- kfree(tpm_response.data); -- tpm_response.data = NULL; -- } else { -- tpm_response.size = 0; -- tpm_response.data = NULL; -- } -- up(&tpm_mutex); -- return tpm_response.size; -- } -- return -1; --} -- --struct file_operations fops = { -- .owner = THIS_MODULE, -- .open = tpm_open, -- .release = tpm_release, -- .read = tpm_read, -- .write = tpm_write, -- .ioctl = tpm_ioctl, --}; -- --static struct miscdevice tpm_dev = { -- .minor = TPM_DEVICE_MINOR, -- .name = TPM_DEVICE_NAME, -- .fops = &fops, --}; -- --int __init init_tpm_module(void) --{ -- int res = misc_register(&tpm_dev); -- if (res != 0) { -- error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR); -- return res; -- } -- /* initialize variables */ -- sema_init(&tpm_mutex, 1); -- module_state = 0; -- tpm_response.data = NULL; -- old_time = current_kernel_time(); -- /* initialize TPM emulator */ -- if (!strcmp(startup, "clear")) { -- tpm_emulator_init(1); -- } else if (!strcmp(startup, "save")) { -- tpm_emulator_init(2); -- } else if (!strcmp(startup, "deactivated")) { -- tpm_emulator_init(3); -- } else { -- error("invalid startup mode '%s'; must be 'clear', " -- "'save' (default) or 'deactivated", startup); -- misc_deregister(&tpm_dev); -- return -EINVAL; -- } -- return 0; --} -- --void __exit cleanup_tpm_module(void) --{ -- tpm_emulator_shutdown(); -- misc_deregister(&tpm_dev); -- if (tpm_response.data != NULL) kfree(tpm_response.data); --} -- --module_init(init_tpm_module); --module_exit(cleanup_tpm_module); -- --uint64_t tpm_get_ticks(void) --{ -- struct timespec new_time = current_kernel_time(); -- uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000 -- + (new_time.tv_nsec - old_time.tv_nsec) / 1000; -- old_time = new_time; -- return (ticks > 0) ? ticks : 1; --} -- -diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h ---- orig/tpm_emulator-0.4/linux_module.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/linux_module.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -17,54 +18,62 @@ - #ifndef _LINUX_MODULE_H_ - #define _LINUX_MODULE_H_ - --#include --#include --#include -+#include -+#include -+#include -+#include - #include --#include --#include --#include --#include - --/* module settings */ -+#include -+#define __BYTEORDER_HAS_U64__ -+#ifdef LITTLE_ENDIAN -+ #include -+#else -+ #include -+#endif - -+/* module settings */ -+#define min(A,B) ((A)<(B)?(A):(B)) -+#ifndef STR - #define STR(s) __STR__(s) - #define __STR__(s) #s -+#endif - #include "tpm_version.h" - - #define TPM_DEVICE_MINOR 224 - #define TPM_DEVICE_NAME "tpm" - #define TPM_MODULE_NAME "tpm_emulator" - --/* debug and log output functions */ -- - #ifdef DEBUG --#define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) - #else - #define debug(fmt, ...) - #endif --#define info(fmt, ...) printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \ -- TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ -+ __FILE__, __LINE__, ## __VA_ARGS__) - - /* memory allocation */ - - static inline void *tpm_malloc(size_t size) - { -- return kmalloc(size, GFP_KERNEL); -+ return malloc(size); - } - - static inline void tpm_free(const void *ptr) - { -- if (ptr != NULL) kfree(ptr); -+ if (ptr != NULL) free( (void *) ptr); - } - - /* random numbers */ - -+//FIXME; -+void get_random_bytes(void *buf, int nbytes); -+ - static inline void tpm_get_random_bytes(void *buf, int nbytes) - { - get_random_bytes(buf, nbytes); -@@ -84,9 +93,9 @@ uint64_t tpm_get_ticks(void); - #define CPU_TO_LE16(x) __cpu_to_le16(x) - - #define BE64_TO_CPU(x) __be64_to_cpu(x) --#define LE64_TO_CPU(x) __be64_to_cpu(x) -+#define LE64_TO_CPU(x) __le64_to_cpu(x) - #define BE32_TO_CPU(x) __be32_to_cpu(x) --#define LE32_TO_CPU(x) __be32_to_cpu(x) -+#define LE32_TO_CPU(x) __le32_to_cpu(x) - #define BE16_TO_CPU(x) __be16_to_cpu(x) - #define LE16_TO_CPU(x) __le16_to_cpu(x) - -diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile ---- orig/tpm_emulator-0.4/Makefile 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/Makefile 2006-07-24 14:35:35.000000000 -0700 -@@ -1,24 +1,40 @@ - # Software-Based Trusted Platform Module (TPM) Emulator for Linux - # Copyright (C) 2004 Mario Strasser -+# Copyright (C) 2006 INTEL Corp. - # - # $Id: Makefile 115 2006-06-23 10:36:44Z mast $ - --# kernel settings --KERNEL_RELEASE := $(shell uname -r) --KERNEL_BUILD := /lib/modules/$(KERNEL_RELEASE)/build --MOD_SUBDIR := misc -+COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) - - # module settings --MODULE_NAME := tpm_emulator -+BIN := tpm_emulator - VERSION_MAJOR := 0 - VERSION_MINOR := 4 - VERSION_BUILD := $(shell date +"%s") - --# enable/disable DEBUG messages --EXTRA_CFLAGS += -Wall -DDEBUG -g -+# Installation program and options -+INSTALL = install -+INSTALL_PROG = $(INSTALL) -m0755 -+INSTALL_DIR = $(INSTALL) -d -m0755 -+ -+# Xen tools installation directory -+TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin -+ -+CC := gcc -+CFLAGS += -g -Wall $(INCLUDE) -DDEBUG -+CFLAGS += -I. -Itpm -+ -+# Is the simulator running in it's own vm? -+#CFLAGS += -DVTPM_MULTI_VM -+ -+ifeq ($(COMPILE_ARCH),x86_64) -+LIBDIR = lib64 -+else -+LIBDIR = lib -+endif - - # GNU MP configuration --GMP_LIB := /usr/lib/libgmp.a -+GMP_LIB := /usr/$(LIBDIR)/libgmp.a - GMP_HEADER := /usr/include/gmp.h - - # sources and objects -@@ -27,38 +43,32 @@ DIRS := . crypto tpm - SRCS := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c)) - OBJS := $(patsubst %.c, %.o, $(SRCS)) - SRCS += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h)) --DISTSRC := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS) --DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR) - --obj-m := $(MODULE_NAME).o --$(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a -+obj-m := $(BIN) -+$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a - - EXTRA_CFLAGS += -I$(src) -I$(src)/crypto -I$(src)/tpm - - # do not print "Entering directory ..." - MAKEFLAGS += --no-print-directory - --all: $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules -+all: $(BIN) - --install: -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install -- test -d /var/tpm || mkdir /var/tpm -- test -c /dev/tpm || mknod /dev/tpm c 10 224 -- chmod 666 /dev/tpm -- depmod -a -+$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS) -+ $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN) -+ -+%.o: %.c -+ $(CC) $(CFLAGS) -c $< -o $@ -+ -+install: $(BIN) -+ $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) -+ @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi - - clean: -- @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean -- rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a -+ rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) - --dist: $(DISTSRC) -- rm -rf $(DISTDIR) -- mkdir $(DISTDIR) -- cp --parents $(DISTSRC) $(DISTDIR)/ -- rm -f $(DISTDIR)/crypto/gmp.h -- tar -chzf $(DISTDIR).tar.gz $(DISTDIR) -- rm -rf $(DISTDIR) -+mrproper: clean -+ rm -f $(BIN) tpm_version.h - - $(src)/crypto/libgmp.a: - test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a -@@ -88,4 +98,3 @@ version: - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h - - .PHONY: all install clean dist gmp version -- -diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README ---- orig/tpm_emulator-0.4/README 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/README 2006-07-24 14:35:35.000000000 -0700 -@@ -13,7 +13,8 @@ $Id: README 113 2006-06-18 12:38:13Z hst - Copyright - -------------------------------------------------------------------------- - Copyright (C) 2004 Mario Strasser and Swiss Federal --Institute of Technology (ETH) Zurich. -+ Institute of Technology (ETH) Zurich. -+Copyright (C) 2005 INTEL Corp - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by -@@ -43,6 +44,12 @@ Example: - GMP_LIB := /usr/lib/libgmp.a - GMP_HEADER := /usr/include/gmp.h - -+GNU MP Library on 64 bit Systems -+-------------------------------------------------------------------------- -+Some 64-bit kernels have problems with importing the user-space gmp -+library (/usr/lib*/libgmp.a) into kernel space. These kernels will require -+that the gmp library be recompiled for kernel space with -mcmodel=kernel. -+ - Installation - -------------------------------------------------------------------------- - The compilation and installation process uses the build environment for -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_capability.c tpm_emulator/tpm/tpm_capability.c ---- orig/tpm_emulator-0.4/tpm/tpm_capability.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_capability.c 2007-12-28 22:50:19.000000000 +0900 -@@ -701,7 +701,10 @@ TPM_RESULT TPM_GetCapabilityOwner(TPM_VE - TPM_RESULT res; - - info("TPM_GetCapabilityOwner()"); -- -+ -+ if (!tpmData.permanent.flags.owned) { -+ return TPM_NOSRK; -+ } - /* Verify owner authorization */ - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); - if (res != TPM_SUCCESS) return res; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c tpm_emulator/tpm/tpm_cmd_handler.c ---- orig/tpm_emulator-0.4/tpm/tpm_cmd_handler.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_cmd_handler.c 2007-09-12 20:23:00.000000000 +0900 -@@ -565,7 +565,7 @@ static TPM_RESULT execute_TPM_Seal(TPM_R - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) -+ || (pcrInfoSize >0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) - || len != 0) return TPM_BAD_PARAMETER; -@@ -798,7 +798,7 @@ static TPM_RESULT execute_TPM_Sealx(TPM_ - if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle) - || tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &encAuth) - || tpm_unmarshal_UINT32(&ptr, &len, &pcrInfoSize) -- || tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo) -+ || (pcrInfoSize > 0 && tpm_unmarshal_TPM_PCR_INFO(&ptr, &len, &pcrInfo)) - || tpm_unmarshal_UINT32(&ptr, &len, &inDataSize) - || tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize) - || len != 0) return TPM_BAD_PARAMETER; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c ---- orig/tpm_emulator-0.4/tpm/tpm_credentials.c 2006-06-23 19:37:07.000000000 +0900 -+++ tpm_emulator/tpm/tpm_credentials.c 2007-09-12 20:23:30.000000000 +0900 -@@ -47,20 +47,20 @@ int tpm_compute_pubkey_checksum(TPM_NONC - - TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey) - { -- UINT32 key_length; -+ size_t key_length; - if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT; - /* setup TPM_PUBKEY structure */ -- key_length = tpmData.permanent.data.endorsementKey.size; -- pubEndorsementKey->pubKey.keyLength = key_length >> 3; -+ pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3; - pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength); - if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL; - rsa_export_modulus(&tpmData.permanent.data.endorsementKey, -- pubEndorsementKey->pubKey.key, -- &pubEndorsementKey->pubKey.keyLength); -+ pubEndorsementKey->pubKey.key, -+ &key_length); -+ pubEndorsementKey->pubKey.keyLength = key_length; - pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA; - pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE; -- pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length; -+ pubEndorsementKey->algorithmParms.parms.rsa.keyLength = key_length << 3; - pubEndorsementKey->algorithmParms.parms.rsa.numPrimes = 2; - pubEndorsementKey->algorithmParms.parms.rsa.exponentSize = 0; - pubEndorsementKey->algorithmParms.parms.rsa.exponent = NULL; -@@ -175,6 +175,7 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ - { - TPM_RESULT res; - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; -+ size_t key_length; - info("TPM_OwnerReadInternalPub()"); - /* verify authorization */ - res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); -@@ -186,7 +187,8 @@ TPM_RESULT TPM_OwnerReadInternalPub(TPM_ - publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength); - if (publicPortion->pubKey.key == NULL) return TPM_FAIL; - rsa_export_modulus(&srk->key, publicPortion->pubKey.key, -- &publicPortion->pubKey.keyLength); -+ &key_length); -+ publicPortion->pubKey.keyLength = key_length; - publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA; - publicPortion->algorithmParms.encScheme = srk->encScheme; - publicPortion->algorithmParms.sigScheme = srk->sigScheme; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c ---- orig/tpm_emulator-0.4/tpm/tpm_crypto.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_crypto.c 2006-07-24 14:35:35.000000000 -0700 -@@ -182,7 +182,8 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE - TPM_KEY_DATA *cert, *key; - sha1_ctx_t sha1_ctx; - BYTE *buf, *p; -- UINT32 length; -+ UINT32 length32; -+ size_t length; - info("TPM_CertifyKey()"); - /* get keys */ - cert = tpm_get_key(certHandle); -@@ -264,14 +265,15 @@ TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - p = buf = tpm_malloc(length); -+ length32=(UINT32) length; - if (buf == NULL -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); - return TPM_FAIL; - } - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - sha1_init(&sha1_ctx); -- sha1_update(&sha1_ctx, buf, length); -+ sha1_update(&sha1_ctx, buf, (size_t) length); - sha1_final(&sha1_ctx, buf); - res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize); - tpm_free(buf); -@@ -292,7 +294,8 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL - TPM_KEY_DATA *cert, *key; - sha1_ctx_t sha1_ctx; - BYTE *buf, *p; -- UINT32 length; -+ size_t length; -+ UINT32 length32; - info("TPM_CertifyKey2()"); - /* get keys */ - cert = tpm_get_key(certHandle); -@@ -362,8 +365,9 @@ TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL - /* compute the digest of the CERTIFY_INFO[2] structure and sign it */ - length = sizeof_TPM_CERTIFY_INFO((*certifyInfo)); - p = buf = tpm_malloc(length); -+ length32 = (UINT32) length; - if (buf == NULL -- || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) { -+ || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) { - free_TPM_KEY_PARMS(certifyInfo->algorithmParms); - return TPM_FAIL; - } -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c ---- orig/tpm_emulator-0.4/tpm/tpm_daa.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_daa.c 2006-07-24 14:35:35.000000000 -0700 -@@ -716,14 +716,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -805,14 +805,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1489,14 +1489,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1712,14 +1712,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -1793,14 +1793,14 @@ TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -2918,14 +2918,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -3143,7 +3143,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, - sizeof(session->DAA_session.DAA_digest)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_update(&sha1, inputData1, inputSize1); - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); - } -@@ -3172,7 +3172,7 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest, - sizeof(session->DAA_session.DAA_digest)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE*) "\x00", 1); - rsa_export_modulus(&aikData->key, scratch, &size); - sha1_update(&sha1, scratch, size); - sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest); -@@ -3229,14 +3229,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -@@ -3309,14 +3309,14 @@ TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x00", 1); -+ sha1_update(&sha1, (BYTE *) "\x00", 1); - sha1_final(&sha1, scratch); - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey, - sizeof(session->DAA_tpmSpecific.DAA_rekey)); - sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count, - sizeof(session->DAA_tpmSpecific.DAA_count)); -- sha1_update(&sha1, "\x01", 1); -+ sha1_update(&sha1, (BYTE *) "\x01", 1); - sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH); - mpz_init(f), mpz_init(q); - mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c ---- orig/tpm_emulator-0.4/tpm/tpm_data.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_data.c 2006-07-24 14:35:35.000000000 -0700 -@@ -40,6 +40,7 @@ static inline void init_pcr_attr(int pcr - void tpm_init_data(void) - { - /* endorsement key */ -+#ifndef TPM_GENERATE_EK - uint8_t ek_n[] = "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7" - "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93" - "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a" -@@ -77,6 +78,8 @@ void tpm_init_data(void) - "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b" - "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47" - "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f"; -+#endif -+ - int i; - /* reset all data to NULL, FALSE or 0 */ - memset(&tpmData, 0, sizeof(tpmData)); -@@ -152,44 +155,43 @@ void tpm_release_data(void) - - #ifdef TPM_STORE_TO_FILE - --#include --#include --#include -+#include -+#include -+#include -+#include - - #define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) - - static int write_to_file(uint8_t *data, size_t data_length) - { - int res; -- struct file *fp; -- mm_segment_t old_fs = get_fs(); -- fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- if (IS_ERR(fp)) return -1; -- set_fs(get_ds()); -- res = fp->f_op->write(fp, data, data_length, &fp->f_pos); -- set_fs(old_fs); -- filp_close(fp, NULL); -+ int fp; -+ fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -+ res = write(fp, data, data_length); -+ close(fp); - return (res == data_length) ? 0 : -1; - } - - static int read_from_file(uint8_t **data, size_t *data_length) - { - int res; -- struct file *fp; -- mm_segment_t old_fs = get_fs(); -- fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0); -- if (IS_ERR(fp)) return -1; -- *data_length = (size_t)fp->f_dentry->d_inode->i_size; -- /* *data_length = i_size_read(fp->f_dentry->d_inode); */ -+ int fp, file_status; -+ struct stat file_info; -+ fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); -+ file_status = fstat(fp, &file_info); -+ if (file_status < 0) { -+ close(fp); -+ return -1; -+ } -+ -+ *data_length = file_info.st_size; - *data = tpm_malloc(*data_length); - if (*data == NULL) { -- filp_close(fp, NULL); -+ close(fp); - return -1; - } -- set_fs(get_ds()); -- res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos); -- set_fs(old_fs); -- filp_close(fp, NULL); -+ res = read(fp, *data, *data_length); -+ close(fp); - if (res != *data_length) { - tpm_free(*data); - return -1; -@@ -216,23 +218,30 @@ static int read_from_file(uint8_t **data - int tpm_store_permanent_data(void) - { - uint8_t *buf, *ptr; -- size_t buf_length, len; -+ UINT32 buf_length, len; - - /* marshal data */ -- buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) -- + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2 -- + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data); -+ buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags) -+ + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) -+ + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2 -+ + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data) -+ + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data) -+ + sizeof_TPM_STANY_DATA(tpmData.stany.data); - buf = ptr = tpm_malloc(buf_length); - if (buf == NULL - || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version) - || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) - || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) -+ || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded) - || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned) -- || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { -+ || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) -+ || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) -+ || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { - tpm_free(buf); - return -1; - } -+ - if (write_to_file(buf, buf_length - len)) { - tpm_free(buf); - return -1; -@@ -244,31 +253,36 @@ int tpm_store_permanent_data(void) - int tpm_restore_permanent_data(void) - { - uint8_t *buf, *ptr; -- size_t buf_length, len; -+ size_t buf_length; -+ UINT32 len; - TPM_VERSION ver; - - /* read data */ - if (read_from_file(&buf, &buf_length)) return -1; - ptr = buf; -- len = buf_length; -+ len = (uint32_t) buf_length; - /* unmarshal data */ - if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver) - || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION)) - || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) - || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags) -+ || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags) - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded) - || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned) -- || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) { -+ || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) -+ || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) -+ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { - tpm_free(buf); - return -1; - } -+ - tpm_free(buf); - return 0; - } - - int tpm_erase_permanent_data(void) - { -- int res = write_to_file("", 0); -+ int res = write_to_file((uint8_t *) "", 0); - return res; - } - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c ---- orig/tpm_emulator-0.4/tpm/tpm_deprecated.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_deprecated.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -50,7 +51,7 @@ TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA - BYTE *ptr; - UINT32 len; - info("TPM_SaveKeyContext()"); -- res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..", -+ res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..", - keyContextSize, &contextBlob); - if (res != TPM_SUCCESS) return res; - len = *keyContextSize; -@@ -82,7 +83,7 @@ TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH - BYTE *ptr; - UINT32 len; - info("TPM_SaveAuthContext()"); -- res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.", -+ res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.", - authContextSize, &contextBlob); - if (res != TPM_SUCCESS) return res; - len = *authContextSize; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h ---- orig/tpm_emulator-0.4/tpm/tpm_emulator.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_emulator.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1,5 +1,6 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -22,7 +23,8 @@ - /* TPM configuration */ - #define TPM_STORE_TO_FILE 1 - #undef TPM_STRONG_PERSISTENCE --#undef TPM_GENERATE_EK -+//#undef TPM_GENERATE_EK -+#define TPM_GENERATE_EK - #undef TPM_GENERATE_SEED_DAA - - #define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */ -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_marshalling.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1312,7 +1312,7 @@ int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * - - int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v) - { -- UINT32 m_len, e_len, q_len; -+ size_t m_len, e_len, q_len; - if (*length < sizeof_RSA((*v))) return -1; - if (v->size > 0) { - rsa_export_modulus(v, &(*ptr)[6], &m_len); -@@ -1460,6 +1460,66 @@ int tpm_unmarshal_TPM_PERMANENT_DATA(BYT - return 0; - } - -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) -+{ -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) -+ || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1; -+ -+ return 0; -+} -+ -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) -+{ -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) -+ || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1; -+ -+ return 0; -+} -+ -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) -+{ -+ UINT32 i; -+ if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) -+ || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) -+ || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) -+ || tpm_marshal_BOOL(ptr, length, v->auditSession) -+ || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) -+ || tpm_marshal_UINT32(ptr, length, v->contextCount) -+ || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { -+ if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; -+ } -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { -+ if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; -+ } -+ if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; -+ -+ return 0; -+} -+ -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) -+{ -+ UINT32 i; -+ if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) -+ || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) -+ || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) -+ || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) -+ || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) -+ || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) -+ || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; -+ for (i = 0; i < TPM_MAX_SESSIONS; i++) { -+ if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; -+ } -+ for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { -+ if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; -+ } -+ if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; -+ -+ return 0; -+} -+ - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) - { - if (tpm_marshal_BYTE(ptr, length, v->type) -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h ---- orig/tpm_emulator-0.4/tpm/tpm_marshalling.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_marshalling.h 2006-07-24 14:35:35.000000000 -0700 -@@ -432,6 +432,12 @@ int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt - int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); - int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *); - -+int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); -+int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v); -+ -+int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); -+int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v); -+ - int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); - int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v); - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c ---- orig/tpm_emulator-0.4/tpm/tpm_owner.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_owner.c 2006-07-24 14:35:35.000000000 -0700 -@@ -108,7 +108,7 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO - TPM_RESULT res; - rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey; - TPM_KEY_DATA *srk = &tpmData.permanent.data.srk; -- UINT32 buf_size = ek->size >> 3; -+ size_t buf_size = ek->size >> 3, key_length; - BYTE buf[buf_size]; - - info("TPM_TakeOwnership()"); -@@ -173,7 +173,8 @@ TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO - return TPM_FAIL; - } - rsa_export_modulus(&srk->key, srkPub->pubKey.key, -- &srkPub->pubKey.keyLength); -+ &key_length); -+ srkPub->pubKey.keyLength = (UINT32) key_length; - /* setup tpmProof and set state to owned */ - tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce, - sizeof(tpmData.permanent.data.tpmProof.nonce)); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c ---- orig/tpm_emulator-0.4/tpm/tpm_startup.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_startup.c 2006-07-24 14:35:35.000000000 -0700 -@@ -41,26 +41,29 @@ void TPM_Init(TPM_STARTUP_TYPE startupTy - TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType) - { - int i; -+ int restore_fail; - info("TPM_Startup(%d)", startupType); - if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT; -- /* reset STANY_FLAGS */ -- SET_TO_ZERO(&tpmData.stany.flags); -- tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; -- /* reset STANY_DATA (invalidates ALL sessions) */ -- SET_TO_ZERO(&tpmData.stany.data); -- tpmData.stany.data.tag = TPM_TAG_STANY_DATA; -- /* init session-context nonce */ -- SET_TO_RAND(&tpmData.stany.data.contextNonceSession); -+ -+ /* try and restore state to get EK, SRK, etc */ -+ restore_fail = tpm_restore_permanent_data(); -+ - /* set data and flags according to the given startup type */ - if (startupType == TPM_ST_CLEAR) { -- /* if available, restore permanent data */ -- tpm_restore_permanent_data(); -+ /* reset STANY_FLAGS */ -+ SET_TO_ZERO(&tpmData.stany.flags); -+ tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS; -+ /* reset STANY_DATA (invalidates ALL sessions) */ -+ SET_TO_ZERO(&tpmData.stany.data); -+ tpmData.stany.data.tag = TPM_TAG_STANY_DATA; -+ /* init session-context nonce */ -+ SET_TO_RAND(&tpmData.stany.data.contextNonceSession); - /* reset PCR values */ - for (i = 0; i < TPM_NUM_PCR; i++) { -- if (tpmData.permanent.data.pcrAttrib[i].pcrReset) -- SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest); -+ if (!tpmData.permanent.data.pcrAttrib[i].pcrReset) -+ SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest); - else -- SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest); -+ SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest); - } - /* reset STCLEAR_FLAGS */ - SET_TO_ZERO(&tpmData.stclear.flags); -@@ -79,7 +82,8 @@ TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE - /* init key-context nonce */ - SET_TO_RAND(&tpmData.stclear.data.contextNonceKey); - } else if (startupType == TPM_ST_STATE) { -- if (tpm_restore_permanent_data()) { -+ /* restore must have been successful for TPM_ST_STATE */ -+ if (restore_fail) { - error("restoring permanent data failed"); - tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed"; - tpmData.permanent.flags.selfTestSucceeded = FALSE; -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c ---- orig/tpm_emulator-0.4/tpm/tpm_storage.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_storage.c 2006-07-24 14:35:35.000000000 -0700 -@@ -58,6 +58,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - BYTE *enc, UINT32 *enc_size) - { - UINT32 len; -+ size_t enc_size32 = *enc_size; - BYTE *buf, *ptr; - rsa_public_key_t pub_key; - int scheme; -@@ -72,7 +73,7 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - if (buf == NULL - || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal) - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)), -- enc, enc_size)) { -+ enc, &enc_size32)) { - tpm_free(buf); - rsa_release_public_key(&pub_key); - return -1; -@@ -85,7 +86,8 @@ int encrypt_sealed_data(TPM_KEY_DATA *ke - int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, - TPM_SEALED_DATA *seal, BYTE **buf) - { -- UINT32 len; -+ size_t len; -+ UINT32 len32; - BYTE *ptr; - int scheme; - switch (key->encScheme) { -@@ -96,8 +98,12 @@ int decrypt_sealed_data(TPM_KEY_DATA *ke - len = enc_size; - *buf = ptr = tpm_malloc(len); - if (*buf == NULL -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) -- || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) { -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){ -+ tpm_free(*buf); -+ return -1; -+ } -+ len32 = len; -+ if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) { - tpm_free(*buf); - return -1; - } -@@ -240,11 +246,12 @@ TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par - - TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize, - BYTE *inData, TPM_AUTH *auth1, -- UINT32 *outDataSize, BYTE **outData) -+ UINT32 *outDataSize32, BYTE **outData) - { - TPM_RESULT res; - TPM_KEY_DATA *key; - int scheme; -+ size_t outDataSize; - - info("TPM_UnBind()"); - /* get key */ -@@ -262,8 +269,8 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key - /* the size of the input data muss be greater than zero */ - if (inDataSize == 0) return TPM_BAD_PARAMETER; - /* decrypt data */ -- *outDataSize = inDataSize; -- *outData = tpm_malloc(*outDataSize); -+ outDataSize = inDataSize; -+ *outData = tpm_malloc(outDataSize); - if (*outData == NULL) return TPM_NOSPACE; - switch (key->encScheme) { - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; -@@ -271,20 +278,21 @@ TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key - default: tpm_free(*outData); return TPM_DECRYPT_ERROR; - } - if (rsa_decrypt(&key->key, scheme, inData, inDataSize, -- *outData, outDataSize)) { -+ *outData, &outDataSize)) { - tpm_free(*outData); - return TPM_DECRYPT_ERROR; - } - /* verify data if it is of type TPM_BOUND_DATA */ - if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1 - || key->keyUsage != TPM_KEY_LEGACY) { -- if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { -+ if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) { - tpm_free(*outData); - return TPM_DECRYPT_ERROR; - } -- *outDataSize -= 5; -- memmove(*outData, &(*outData)[5], *outDataSize); -+ outDataSize -= 5; -+ memmove(*outData, &(*outData)[5], outDataSize); - } -+ *outDataSize32 = (UINT32) outDataSize; - return TPM_SUCCESS; - } - -@@ -334,12 +342,13 @@ int compute_pubkey_digest(TPM_PUBKEY *ke - } - - int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store, -- BYTE *enc, UINT32 *enc_size) -+ BYTE *enc, UINT32 *enc_size32) - { - UINT32 len; - BYTE *buf, *ptr; - rsa_public_key_t pub_key; - int scheme; -+ size_t enc_size; - switch (key->encScheme) { - case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break; - case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break; -@@ -351,11 +360,12 @@ int encrypt_private_key(TPM_KEY_DATA *ke - if (buf == NULL - || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store) - || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)), -- enc, enc_size)) { -+ enc, &enc_size)) { - tpm_free(buf); - rsa_release_public_key(&pub_key); - return -1; - } -+ *enc_size32 = (UINT32) enc_size; - tpm_free(buf); - rsa_release_public_key(&pub_key); - return 0; -@@ -364,7 +374,8 @@ int encrypt_private_key(TPM_KEY_DATA *ke - int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size, - TPM_STORE_ASYMKEY *store, BYTE **buf) - { -- UINT32 len; -+ UINT32 len32; -+ size_t len; - BYTE *ptr; - int scheme; - switch (key->encScheme) { -@@ -375,8 +386,12 @@ int decrypt_private_key(TPM_KEY_DATA *ke - len = enc_size; - *buf = ptr = tpm_malloc(len); - if (*buf == NULL -- || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) -- || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) { -+ || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) { -+ tpm_free(*buf); -+ return -1; -+ } -+ len32 = (UINT32) len; -+ if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { - tpm_free(*buf); - return -1; - } -@@ -394,7 +409,7 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - TPM_SESSION_DATA *session; - TPM_STORE_ASYMKEY store; - rsa_private_key_t rsa; -- UINT32 key_length; -+ size_t key_length; - - info("TPM_CreateWrapKey()"); - /* get parent key */ -@@ -450,11 +465,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - } - } - /* generate key and store it */ -- key_length = keyInfo->algorithmParms.parms.rsa.keyLength; -- if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL; -- wrappedKey->pubKey.keyLength = key_length >> 3; -+ if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength)) -+ return TPM_FAIL; -+ wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3; - wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength); -- store.privKey.keyLength = key_length >> 4; -+ store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4; - store.privKey.key = tpm_malloc(store.privKey.keyLength); - wrappedKey->encDataSize = parent->key.size >> 3; - wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize); -@@ -466,9 +481,11 @@ TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN - tpm_free(wrappedKey->encData); - return TPM_NOSPACE; - } -- rsa_export_modulus(&rsa, wrappedKey->pubKey.key, -- &wrappedKey->pubKey.keyLength); -- rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength); -+ rsa_export_modulus(&rsa, wrappedKey->pubKey.key, -+ &key_length); -+ wrappedKey->pubKey.keyLength = (UINT32) key_length; -+ rsa_export_prime1(&rsa, store.privKey.key, &key_length); -+ store.privKey.keyLength = (UINT32) key_length; - rsa_release_private_key(&rsa); - /* compute the digest of the wrapped key (without encData) */ - if (compute_key_digest(wrappedKey, &store.pubDataDigest)) { -@@ -602,6 +619,7 @@ TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p - - int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms) - { -+ size_t key_length; - parms->algorithmID = TPM_ALG_RSA; - parms->encScheme = key->encScheme; - parms->sigScheme = key->sigScheme; -@@ -611,7 +629,8 @@ int tpm_setup_key_parms(TPM_KEY_DATA *ke - parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize); - if (parms->parms.rsa.exponent == NULL) return -1; - rsa_export_exponent(&key->key, parms->parms.rsa.exponent, -- &parms->parms.rsa.exponentSize); -+ &key_length); -+ parms->parms.rsa.exponentSize = (UINT32) key_length; - parms->parmSize = 12 + parms->parms.rsa.exponentSize; - return 0; - } -@@ -622,6 +641,7 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE - TPM_RESULT res; - TPM_KEY_DATA *key; - TPM_DIGEST digest; -+ size_t key_length; - info("TPM_GetPubKey()"); - /* get key */ - if (keyHandle == TPM_KH_SRK -@@ -650,8 +670,8 @@ TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE - pubKey->pubKey.keyLength = key->key.size >> 3; - pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength); - if (pubKey->pubKey.key == NULL) return TPM_NOSPACE; -- rsa_export_modulus(&key->key, pubKey->pubKey.key, -- &pubKey->pubKey.keyLength); -+ rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length); -+ pubKey->pubKey.keyLength = (UINT32) key_length; - if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) { - error("TPM_GetPubKey(): tpm_setup_key_parms() failed."); - tpm_free(pubKey->pubKey.key); -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h ---- orig/tpm_emulator-0.4/tpm/tpm_structures.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_structures.h 2006-07-24 14:35:35.000000000 -0700 -@@ -1958,6 +1958,7 @@ typedef struct tdTPM_DAA_ISSUER { - TPM_DIGEST DAA_digest_gamma; - BYTE DAA_generic_q[26]; - } TPM_DAA_ISSUER; -+#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 ) - - /* - * TPM_DAA_TPM ([TPM_Part2], Section 22.4) -@@ -1973,6 +1974,7 @@ typedef struct tdTPM_DAA_TPM { - TPM_DIGEST DAA_rekey; - UINT32 DAA_count; - } TPM_DAA_TPM; -+#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4) - - /* - * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5) -@@ -1987,6 +1989,7 @@ typedef struct tdTPM_DAA_CONTEXT { - BYTE DAA_scratch[256]; - BYTE DAA_stage; - } TPM_DAA_CONTEXT; -+#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1) - - /* - * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6) -@@ -1998,6 +2001,7 @@ typedef struct tdTPM_DAA_JOINDATA { - BYTE DAA_join_u1[138]; - TPM_DIGEST DAA_digest_n0; - } TPM_DAA_JOINDATA; -+#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20) - - /* - * TPM_DAA_BLOB ([TPM_Part2], Section 22.8) -@@ -2202,6 +2206,7 @@ typedef struct tdTPM_STCLEAR_DATA { - //UINT32 ownerReference; - //BOOL disableResetLock; - } TPM_STCLEAR_DATA; -+#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4) - - /* - * TPM_SESSION_DATA -@@ -2238,6 +2243,11 @@ typedef struct tdTPM_DAA_SESSION_DATA { - TPM_DAA_JOINDATA DAA_joinSession; - TPM_HANDLE handle; - } TPM_DAA_SESSION_DATA; -+#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \ -+ + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \ -+ + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \ -+ + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \ -+ + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4) - - /* - * TPM_STANY_DATA ([TPM_Part2], Section 7.6) -@@ -2262,6 +2272,11 @@ typedef struct tdTPM_STANY_DATA { - TPM_DAAHANDLE currentDAA; - TPM_TRANSHANDLE transExclusive; - } TPM_STANY_DATA; -+#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \ -+ + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \ -+ + 4 + (4 * TPM_MAX_SESSION_LIST) \ -+ + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \ -+ + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4) - - /* - * TPM_DATA -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c ---- orig/tpm_emulator-0.4/tpm/tpm_testing.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_testing.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -95,24 +96,24 @@ static int tpm_test_sha1(void) - struct { - uint8_t *data; uint32_t repetitions; uint8_t *digest; - } test_cases[] = {{ -- "abc", 1, -- "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" -+ (uint8_t*)"abc", 1, -+ (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D" - }, { -- "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, -- "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" -+ (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1, -+ (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1" - }, { -- "a", 1000000, -- "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" -+ (uint8_t*)"a", 1000000, -+ (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F" - }, { -- "0123456701234567012345670123456701234567012345670123456701234567", 10, -- "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" -+ (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10, -+ (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52" - }}; - - debug("tpm_test_sha1()"); - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { - sha1_init(&ctx); - for (j = 0; j < test_cases[i].repetitions; j++) -- sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); -+ sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); - sha1_final(&ctx, digest); - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; - } -@@ -128,41 +129,41 @@ static int tpm_test_hmac(void) - struct { - uint8_t *key, key_len, *data, data_len, *digest; - } test_cases[] = {{ -- "\x0b", 20, "Hi There", 8, -- "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" -+ (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8, -+ (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00" - }, { -- "Jefe", 4, "what do ya want for nothing?", 28, -- "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" -+ (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28, -+ (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79" - }, { -- "\xaa", 20, "\xdd", 50, -- "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" -+ (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50, -+ (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3" - }, { -- "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" -- "\x15\x16\x17\x18\x19", 25, "\xcd", 50, -- "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" -+ (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14" -+ "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50, -+ (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda" - }, { -- "\x0c", 20, "Test With Truncation", 20, -- "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" -+ (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20, -+ (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04" - }, { -- "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54, -- "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" -+ (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54, -+ (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12" - }, { -- "\xaa", 80, -- "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, -- "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" -+ (uint8_t*)"\xaa", 80, -+ (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73, -+ (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91" - }}; - - debug("tpm_test_hmac()"); - for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) { -- if (strlen(test_cases[i].key) < test_cases[i].key_len) { -+ if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) { - uint8_t key[test_cases[i].key_len]; - memset(key, test_cases[i].key[0], test_cases[i].key_len); - hmac_init(&ctx, key, test_cases[i].key_len); - } else { - hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len); - } -- for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) { -- hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data)); -+ for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) { -+ hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data)); - } - hmac_final(&ctx, digest); - if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1; -@@ -173,9 +174,9 @@ static int tpm_test_hmac(void) - static int tpm_test_rsa_EK(void) - { - int res = 0; -- char *data = "RSA PKCS #1 v1.5 Test-String"; -+ uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String"; - uint8_t buf[256]; -- size_t buf_len, data_len = strlen(data); -+ size_t buf_len, data_len = strlen((char*)data); - rsa_private_key_t priv_key; - rsa_public_key_t pub_key; - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c ---- orig/tpm_emulator-0.4/tpm/tpm_ticks.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_ticks.c 2006-07-24 14:35:35.000000000 -0700 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -39,9 +40,7 @@ TPM_RESULT TPM_SetTickType(TPM_TICKTYPE - TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime) - { - info("TPM_GetTicks()"); -- memcpy(currentTime, &tpmData.stany.data.currentTicks, -- sizeof(TPM_CURRENT_TICKS)); -- return TPM_SUCCESS; -+ return TPM_DISABLED_CMD; - } - - TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay, -@@ -49,64 +48,11 @@ TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN - TPM_CURRENT_TICKS *currentTicks, - UINT32 *sigSize, BYTE **sig) - { -- TPM_RESULT res; -- TPM_KEY_DATA *key; -- BYTE *info, *p; -- UINT32 info_length, length; - info("TPM_TickStampBlob()"); -- /* get key */ -- key = tpm_get_key(keyHandle); -- if (key == NULL) return TPM_INVALID_KEYHANDLE; -- /* verify authorization */ -- res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); -- if (res != TPM_SUCCESS) return res; -- if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY -- && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE; -- /* get current ticks */ -- TPM_GetTicks(currentTicks); -- /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */ -- *sigSize = key->key.size >> 3; -- *sig = tpm_malloc(*sigSize); -- if (*sig == NULL) return TPM_FAIL; -- /* setup TPM_SIGN_INFO structure */ -- info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks); -- info = tpm_malloc(info_length); -- if (info == NULL) { -- tpm_free(*sig); -- return TPM_FAIL; -- } -- memcpy(&info[0], "\x05\x00TSTP", 6); -- memcpy(&info[6], antiReplay->nonce, 20); -- *(UINT32*)&info[26] = CPU_TO_BE32(20 -- + sizeof_TPM_CURRENT_TICKS(currentTicks)); -- memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST)); -- p = &info[30 + sizeof(TPM_DIGEST)]; -- length = sizeof_TPM_CURRENT_TICKS(currentTicks); -- if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks) -- || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) { -- tpm_free(*sig); -- tpm_free(info); -- return TPM_FAIL; -- } -- return TPM_SUCCESS; -+ return TPM_DISABLED_CMD; - } - - void tpm_update_ticks(void) - { -- if (tpmData.stany.data.currentTicks.tag == 0) { -- tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS; -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); --/* removed since v1.2 rev 94 -- tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType; --*/ -- tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce, -- sizeof(TPM_NONCE)); -- tpmData.stany.data.currentTicks.tickRate = 1; --/* removed since v1.2 rev 94 -- tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK; --*/ -- } else { -- tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks(); -- } - } - -diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c ---- orig/tpm_emulator-0.4/tpm/tpm_transport.c 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm/tpm_transport.c 2006-07-24 14:35:35.000000000 -0700 -@@ -189,7 +189,7 @@ static void decrypt_wrapped_command(BYTE - sha1_init(&sha1); - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); -- sha1_update(&sha1, "in", 2); -+ sha1_update(&sha1, (BYTE*)"in", 2); - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); - j = CPU_TO_BE32(i); - sha1_update(&sha1, (BYTE*)&j, 4); -@@ -211,7 +211,7 @@ static void encrypt_wrapped_command(BYTE - sha1_init(&sha1); - sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce)); - sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce)); -- sha1_update(&sha1, "out", 3); -+ sha1_update(&sha1, (BYTE*)"out", 3); - sha1_update(&sha1, secret, sizeof(TPM_SECRET)); - j = CPU_TO_BE32(i); - sha1_update(&sha1, (BYTE*)&j, 4); -diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c ---- orig/tpm_emulator-0.4/tpmd.c 1969-12-31 16:00:00.000000000 -0800 -+++ tpm_emulator/tpmd.c 2006-07-24 14:35:35.000000000 -0700 -@@ -0,0 +1,156 @@ -+/* Software-Based Trusted Platform Module (TPM) Emulator for Linux -+ * Copyright (C) 2005 INTEL Corp -+ * -+ * This module is free software; you can redistribute it and/or modify -+ * it under the terms of the GNU General Public License as published -+ * by the Free Software Foundation; either version 2 of the License, -+ * or (at your option) any later version. -+ * -+ * This module is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -+ * GNU General Public License for more details. -+ * -+ */ -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#include "tpm_emulator.h" -+ -+#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" -+#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" -+ -+#define BUFFER_SIZE 2048 -+ -+static int devurandom=0; -+ -+void get_random_bytes(void *buf, int nbytes) { -+ -+ if (devurandom == 0) { -+ devurandom = open("/dev/urandom", O_RDONLY); -+ } -+ -+ if (read(devurandom, buf, nbytes) != nbytes) { -+ printf("Can't get random number.\n"); -+ exit(-1); -+ } -+} -+ -+uint64_t tpm_get_ticks(void) -+{ -+ //struct timeval tv; -+ //int gettimeofday(&tv, struct timezone *tz); -+ return 0; -+} -+ -+int main(int argc, char **argv) -+{ -+ uint8_t in[BUFFER_SIZE], *out; -+ uint32_t out_size; -+ int in_size, written; -+ int i; -+ struct stat file_info; -+ -+ int tpm_tx_fh=-1, tpm_rx_fh=-1; -+ if (argc < 2) { -+ printf("Usage: tpmd clear|save|deactivated\n" ); -+ return -1; -+ } -+ -+ /* initialize TPM emulator */ -+ if (!strcmp(argv[1], "clear")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(1); -+ } else if (!strcmp(argv[1], "save")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(2); -+ } else if (!strcmp(argv[1], "deactivated")) { -+ printf("Initializing tpm: %s\n", argv[1]); -+ tpm_emulator_init(3); -+ } else { -+ printf("invalid startup mode '%s'; must be 'clear', " -+ "'save' (default) or 'deactivated", argv[1]); -+ return -1; -+ } -+ -+ if ( stat(TPM_RX_FNAME, &file_info) == -1) { -+ if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { -+ printf("Failed to create fifo %s.\n", TPM_RX_FNAME); -+ return -1; -+ } -+ } -+ -+ if ( stat(TPM_TX_FNAME, &file_info) == -1) { -+ if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { -+ printf("Failed to create fifo %s.\n", TPM_TX_FNAME); -+ return -1; -+ } -+ } -+ -+ while (1) { -+abort_command: -+ if (tpm_rx_fh < 0) { -+ tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); -+ } -+ -+ if (tpm_rx_fh < 0) { -+ printf("ERROR: failed to open devices to listen to guest.\n"); -+ return -1; -+ } -+ -+ if (tpm_tx_fh < 0) { -+ tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); -+ } -+ -+ if (tpm_tx_fh < 0) { -+ printf("ERROR: failed to open devices to respond to guest.\n"); -+ return -1; -+ } -+ -+ in_size = read(tpm_rx_fh, in, BUFFER_SIZE); -+ if (in_size < 6) { // Magic size of minium TPM command -+ printf("Recv[%d] to small: 0x", in_size); -+ if (in_size <= 0) { -+ close(tpm_rx_fh); -+ tpm_rx_fh = -1; -+ goto abort_command; -+ } -+ } else { -+ printf("Recv[%d]: 0x", in_size); -+ for (i=0; i< in_size; i++) -+ printf("%x ", in[i]); -+ printf("\n"); -+ } -+ -+ -+ if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { -+ printf("ERROR: Handler Failed.\n"); -+ } -+ -+ written = write(tpm_tx_fh, out, out_size); -+ -+ if (written != out_size ) { -+ printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); -+ } else { -+ printf("Sent[%Zu]: ", out_size); -+ } -+ for (i=0; i< out_size; i++) -+ printf("%x ", out[i]); -+ printf("\n"); -+ tpm_free(out); -+ -+ } // loop -+ -+ tpm_emulator_shutdown(); -+ -+ close(tpm_tx_fh); -+ close(tpm_rx_fh); -+ -+} -Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ -diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h ---- orig/tpm_emulator-0.4/tpm_version.h 2006-06-23 03:37:07.000000000 -0700 -+++ tpm_emulator/tpm_version.h 2006-07-24 14:35:41.000000000 -0700 -@@ -2,5 +2,5 @@ - #define _TPM_VERSION_H_ - #define VERSION_MAJOR 0 - #define VERSION_MINOR 4 --#define VERSION_BUILD 1151058734 -+#define VERSION_BUILD 1153776940 - #endif /* _TPM_VERSION_H_ */ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/vtpm-0.5.1-LDLIBS.patch --- a/tools/vtpm/vtpm-0.5.1-LDLIBS.patch Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,12 +0,0 @@ -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm_emulator-0.5.1/tpmd/Makefile ---- tpm_emulator-0.5.1/tpmd/Makefile -+++ tpm_emulator-0.5.1/tpmd/Makefile -@@ -8,7 +8,7 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing - CFLAGS += -I../../../../tools/vtpm_manager/manager --LDFLAGS += -lgmp -+LDLIBS += -lgmp - - BINDIR := /usr/bin/ - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/vtpm-0.5.1.patch --- a/tools/vtpm/vtpm-0.5.1.patch Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,766 +0,0 @@ -diff -Naurp tpm_emulator-0.5.1/Makefile tpm5-test/Makefile ---- tpm_emulator-0.5.1/Makefile 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/Makefile 2009-07-15 09:45:28.000000000 -0400 -@@ -10,7 +10,7 @@ VERSION_MINOR := 5 - VERSION_BUILD := $(shell date +"%s") - VERSION_SUFFIX := .1 - --SUBDIRS := tpmd tpmd_dev tddl -+SUBDIRS := tpmd - - all: version all-recursive - -@@ -48,12 +48,12 @@ user_install: user - modules_install: modules - @$(MAKE) -C tpmd_dev install || exit -1 - --DIRS := . tpm crypto tpmd tpmd_dev tddl tpmd_dev_openbsd -+DIRS := . tpm crypto tpmd - DISTSRC := $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c)) - DISTSRC += $(foreach dir, $(DIRS), $(wildcard $(dir)/*.h)) --DIRS := . tpmd tpmd_dev tddl tpmd_dev_openbsd -+DIRS := . tpmd - DISTSRC += $(foreach dir, $(DIRS), $(dir)/Makefile) --DISTSRC += ./README ./AUTHORS ./ChangeLog tpmd_dev/tpmd_dev.rules.in -+DISTSRC += ./README ./AUTHORS ./ChangeLog - DISTDIR := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)$(VERSION_SUFFIX) - - dist: $(DISTSRC) -diff -Naurp tpm_emulator-0.5.1/tpm/tpm_capability.c tpm5-test/tpm/tpm_capability.c ---- tpm_emulator-0.5.1/tpm/tpm_capability.c 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpm/tpm_capability.c 2009-07-16 12:04:20.000000000 -0400 -@@ -136,8 +136,19 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_TIS_TIMEOUT: - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ -+ UINT32 len = *respSize = 16; -+ BYTE *ptr = *resp = tpm_malloc(*respSize); -+ if (ptr == NULL || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { -+ tpm_free(*resp); -+ return TPM_FAIL; -+ } -+ return TPM_SUCCESS; -+ - - case TPM_CAP_PROP_STARTUP_EFFECT: - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); -@@ -189,8 +200,12 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_DURATION: - debug("[TPM_CAP_PROP_DURATION]"); -- /* TODO: TPM_CAP_PROP_DURATION */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; -+ *respSize = 16; -+ *resp = tpm_malloc(*respSize); -+ memcpy(*resp,dur,16); -+ - - case TPM_CAP_PROP_ACTIVE_COUNTER: - debug("[TPM_CAP_PROP_ACTIVE_COUNTER]"); -diff -Naurp tpm_emulator-0.5.1/tpmd/Makefile tpm5-test/tpmd/Makefile ---- tpm_emulator-0.5.1/tpmd/Makefile 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/Makefile 2009-07-16 12:08:26.000000000 -0400 -@@ -8,9 +8,10 @@ WFLAGS := -Wall -Wno-unused -Wpointer-a - -Wwrite-strings -Wsign-compare -Wno-multichar - #WFLAGS += -Wextra -Wcast-qual -Wmissing-prototypes -Wmissing-declarations -Wstrict-aliasing - CFLAGS += $(WFLAGS) -g -I.. -I. -O2 -fno-strict-aliasing -+CFLAGS += -I../../../../tools/vtpm_manager/manager - LDFLAGS += -lgmp - --BINDIR := /usr/sbin/ -+BINDIR := /usr/bin/ - - TPMD := tpmd - DIRS := ../tpm ../crypto -@@ -18,6 +19,8 @@ SRCS := $(foreach dir, $(DIRS), $(wil - OBJS := $(patsubst %.c, %.o, $(SRCS)) - OBJS := $(foreach dir, $(DIRS), $(patsubst $(dir)/%.o, %.o, $(filter $(dir)/%.o, $(OBJS)))) - -+VTPM_BIN := vtpmd -+ - vpath %.c $(strip $(DIRS)) - - all: $(TPMD) -@@ -32,10 +35,8 @@ TPMD_GROUP ?= tss - INSTALL ?= install - - install: $(TPMD) -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/lib/tpm -- $(INSTALL) -m 755 -o $(TPMD_USER) -g $(TPMD_GROUP) -d $(DESTDIR)/var/run/tpm - $(INSTALL) -D -d $(DESTDIR)/$(BINDIR) -- $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR) -+ $(INSTALL) -m 755 $(TPMD) $(DESTDIR)/$(BINDIR)/$(VTPM_BIN) - - .PHONY: all clean install - -diff -Naurp tpm_emulator-0.5.1/tpmd/tpmd.c tpm5-test/tpmd/tpmd.c ---- tpm_emulator-0.5.1/tpmd/tpmd.c 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/tpmd.c 2009-07-16 11:19:05.000000000 -0400 -@@ -32,6 +32,9 @@ - #include - #include "tpm_emulator_config.h" - #include "tpm/tpm_emulator.h" -+#include "tpm/tpm_structures.h" -+#include "tpm/tpm_marshalling.h" -+#include "vtpm_manager.h" - - #define TPM_DAEMON_NAME "tpmd" - #define TPM_CMD_BUF_SIZE 4096 -@@ -39,6 +42,24 @@ - #define TPM_RANDOM_DEVICE "/dev/urandom" - #undef TPM_MKDIRS - -+#ifdef VTPM_MULTI_VM -+ #define DEV_BE "/dev/vtpm" -+ #define DEV_FE "/dev/tpm" -+#else -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" -+ -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -+ -+ static char *vtpm_rx_name=NULL; -+#endif -+ -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#define BUFFER_SIZE 2048 -+ - static volatile int stopflag = 0; - static int is_daemon = 0; - static int opt_debug = 0; -@@ -49,6 +70,8 @@ static const char *opt_storage_file = "/ - static uid_t opt_uid = 0; - static gid_t opt_gid = 0; - static int tpm_startup = 2; -+static int vtpm_type = VTPM_TYPE_PVM; -+int dmi_id = 0; - static int rand_fh; - - void tpm_log(int priority, const char *fmt, ...) -@@ -90,56 +113,241 @@ uint64_t tpm_get_ticks(void) - - int tpm_write_to_file(uint8_t *data, size_t data_length) - { -- int fh; -- ssize_t res; -- fh = open(opt_storage_file, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- if (fh < 0) return -1; -- while (data_length > 0) { -- res = write(fh, data, data_length); -- if (res < 0) { -- close(fh); -- return -1; -- } -- data_length -= res; -- data += res; -+ int res, out_data_size, in_header_size; -+ BYTE *ptr, *out_data, *in_header; -+ UINT32 result, len, in_rsp_size; -+ UINT16 tag = VTPM_TAG_REQ; -+ -+ printf("Saving NVM\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; -+#endif -+ -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { -+ free(out_data); -+ return -1; -+ } -+ -+ printf("\tSending SaveNVM Command.\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); - } -- close(fh); -- return 0; -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading SaveNVM header.\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_tx_fh); close(vtpm_rx_fh); -+#endif -+ -+ printf("\tFinishing up SaveNVM\n"); -+ return (0); - } - - int tpm_read_from_file(uint8_t **data, size_t *data_length) - { -- int fh; -- ssize_t res; -- size_t total_length; -- fh = open(opt_storage_file, O_RDONLY); -- if (fh < 0) return -1; -- total_length = lseek(fh, 0, SEEK_END); -- lseek(fh, 0, SEEK_SET); -- *data = tpm_malloc(total_length); -- if (*data == NULL) { -- close(fh); -- return -1; -- } -- *data_length = 0; -- while (total_length > 0) { -- res = read(fh, &(*data)[*data_length], total_length); -- if (res < 0) { -- close(fh); -- tpm_free(*data); -- return -1; -- } -- *data_length += res; -- total_length -= res; -+ int res, out_data_size, in_header_size; -+ uint8_t *ptr, *out_data, *in_header; -+ UINT16 tag = VTPM_TAG_REQ; -+ UINT32 len, in_rsp_size, result; -+#ifdef VTPM_MUTLI_VM -+ int vtpm_rx_fh, vtpm_tx_fh; -+#endif -+ -+ printf("Loading NVM.\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ printf("Error in read_from_file:301\n"); -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { -+ free(out_data); -+ printf("Error in read_from_file:325\n"); -+ -+ return -1; -+ } -+ -+ printf("\tSending LoadNVM command\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) -+ { -+ printf("Error in read_from_file:335\n"); -+ return -1; -+ } -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); - } -- close(fh); -- return 0; -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ printf("Error in read_from_file:352\n"); -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading LoadNVM header\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ printf("Error in read_from_file:375\n"); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ printf("Error in read_from_file:381\n"); -+ return -1; -+ } -+ -+ // Read Encrypted data from VTPM Manager -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; -+ *data = (uint8_t *) malloc(*data_length); -+ -+ printf("\tReading clear data from LoadNVM.\n"); -+ res = read(vtpm_rx_fh, *data, *data_length); -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_rx_fh);close(vtpm_tx_fh); -+#endif -+ -+ printf("\tReturing from loading NVM\n"); -+ if (res != (int)*data_length) { -+ free(*data); -+ printf("Error in read_from_file:398\n"); -+ return -1; -+ } else { -+ return 0; -+ } -+ -+ -+ - } - - static void print_usage(char *name) - { - printf("usage: %s [-d] [-f] [-s storage file] [-u unix socket name] " -- "[-o user name] [-g group name] [-h] [startup mode]\n", name); -+ "[-o user name] [-g group name] [-h]" -+#ifdef VTPM_MULTI_VM -+ "clear|save|deactivated\n", name); -+#else -+ "clear|save|deactivated pvm|hvm vtpmid\n", name); -+#endif - printf(" d : enable debug mode\n"); - printf(" f : forces the application to run in the foreground\n"); - printf(" s : storage file to use (default: %s)\n", opt_storage_file); -@@ -205,7 +413,13 @@ static void parse_options(int argc, char - exit(EXIT_SUCCESS); - } - } -- if (optind < argc) { -+ /*Make sure we have all required options*/ -+#ifdef VTPM_MULTI_VM -+#define EXTRA_OPTS 0 -+#else -+#define EXTRA_OPTS 2 -+#endif -+ if (optind < argc - EXTRA_OPTS ) { - debug("startup mode = '%s'", argv[optind]); - if (!strcmp(argv[optind], "clear")) { - tpm_startup = 1; -@@ -219,6 +433,25 @@ static void parse_options(int argc, char - print_usage(argv[0]); - exit(EXIT_SUCCESS); - } -+#ifndef VTPM_MULTI_VM -+ ++optind; -+ if(!strcmp(argv[optind], "pvm")) { -+ vtpm_type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo -+ } else if (!strcmp(argv[optind], "hvm")) { -+ vtpm_type = VTPM_TYPE_HVM; // Get commands from qemu via socket -+ } else { -+ error("Invalid vm mode '%s'; must be 'pvm', " -+ "or 'hvm' ", argv[optind]); -+ print_usage(argv[0]); -+ exit(EXIT_SUCCESS); -+ } -+ ++optind; -+ dmi_id = atoi(argv[optind]); -+#endif -+ } else { -+ error("Invalid number of arguments"); -+ print_usage(argv[0]); -+ exit(EXIT_SUCCESS); - } - } - -@@ -348,93 +581,180 @@ static int init_socket(const char *name) - - static void main_loop(void) - { -- int sock, fh, res; -- int32_t in_len; -+ int32_t in_len, written; - uint32_t out_len; -- uint8_t in[TPM_CMD_BUF_SIZE], *out; -+ uint8_t in[TPM_CMD_BUF_SIZE], *out, *addressed_out; -+ int guest_id=-1; -+ int i; -+ char *vtpm_rx_file=NULL; -+ int res; -+ -+#ifndef VTPM_MULTI_VM -+ int sockfd = -1; - struct sockaddr_un addr; -- socklen_t addr_len; -- fd_set rfds; -- struct timeval tv; -+ struct sockaddr_un client_addr; -+ unsigned int client_length; -+#endif -+ -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#ifndef VTPM_MULTI_VM -+ if (vtpm_type == VTPM_TYPE_PVM) { -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); -+ } else { -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); -+ -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { -+ error("Unable to create socket. errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&addr, 0, sizeof(addr)); -+ addr.sun_family = AF_UNIX; -+ strcpy(addr.sun_path,vtpm_rx_file ); -+ unlink(addr.sun_path); -+ } -+#endif - - info("staring main loop"); -- /* open UNIX socket */ -- sock = init_socket(opt_socket_name); -- if (sock < 0) exit(EXIT_FAILURE); - /* init tpm emulator */ -- debug("initializing TPM emulator: %d", tpm_startup); -+#ifdef VTPM_MULTI_VM -+ debug("initializing TPM emulator: state=%d", tpm_startup); -+#else -+ debug("initializing TPM emulator: state=%d, type=%d, id=%d", tpm_startup, vtpm_type, dmi_id); -+#endif - tpm_emulator_init(tpm_startup); - /* start command processing */ - while (!stopflag) { - /* wait for incomming connections */ - debug("waiting for connections..."); -- FD_ZERO(&rfds); -- FD_SET(sock, &rfds); -- tv.tv_sec = 10; -- tv.tv_usec = 0; -- res = select(sock + 1, &rfds, NULL, NULL, &tv); -- if (res < 0) { -- error("select(sock) failed: %s", strerror(errno)); -- break; -- } else if (res == 0) { -- continue; -- } -- addr_len = sizeof(addr); -- fh = accept(sock, (struct sockaddr*)&addr, &addr_len); -- if (fh < 0) { -- error("accept() failed: %s", strerror(errno)); -- continue; -- } -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); -+#else -+ if (vtpm_type == VTPM_TYPE_PVM) -+ { -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); -+ } else { -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { -+ error("Unable to bind(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ if (listen(sockfd, 10) <0) { -+ error("Unable to listen(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&client_addr, 0, sizeof(client_addr)); -+ client_length = sizeof(client_addr); -+ -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); -+ } -+#endif -+ } -+ -+ /*Error Checking*/ -+ if (vtpm_rx_fh < 0) { -+ error("Failed to open devices to listen to guest.\n"); -+ exit(-1); -+ } -+ - /* receive and handle commands */ - in_len = 0; - do { - debug("waiting for commands..."); -- FD_ZERO(&rfds); -- FD_SET(fh, &rfds); -- tv.tv_sec = TPM_COMMAND_TIMEOUT; -- tv.tv_usec = 0; -- res = select(fh + 1, &rfds, NULL, NULL, &tv); -- if (res < 0) { -- error("select(fh) failed: %s", strerror(errno)); -- close(fh); -- break; -- } else if (res == 0) { --#ifdef TPMD_DISCONNECT_IDLE_CLIENTS -- info("connection closed due to inactivity"); -- close(fh); -- break; --#else -- continue; --#endif -- } -- in_len = read(fh, in, sizeof(in)); -- if (in_len > 0) { -+ -+ in_len = read(vtpm_rx_fh, in, sizeof(in)); -+ /*Magic size of minimum TPM command is 6*/ -+ //FIXME Magic size check may not be required anymore -+ if (in_len < 6) { -+ info("Recv incomplete command of %d bytes.", in_len); -+ if (in_len <= 0) { -+ close(vtpm_rx_fh); -+ vtpm_rx_fh = -1; -+ continue; -+ } -+ } else { -+ /*Debug Printouts*/ - debug("received %d bytes", in_len); -+ debug_nostop("Recv[%d]: 0x", in_len); -+ for (i=0; i< in_len; i++) -+ debug_more("%x ", in[i]); -+ debug_more("\n"); -+ /*Multiple Guest check*/ -+ if (guest_id == -1) { -+ guest_id = *((int32_t *) in); -+ } else { -+ if (guest_id != *((int32_t *) in) ) { -+ error("WARNING: More than one guest attached\n"); -+ } -+ } -+ -+ /*Open tx handle now*/ -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_type == VTPM_TYPE_PVM) { -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); -+ } // No need to open the other direction for HVM -+#endif -+ } -+ if (vtpm_tx_fh < 0) { -+ error("Failed to open devices to respond to guest.\n"); -+ exit(-1); -+ } -+ -+ /*Handle the TPM command now*/ - out = NULL; -- res = tpm_handle_command(in, in_len, &out, &out_len); -+ res = tpm_handle_command(in + sizeof(uint32_t), in_len - sizeof(uint32_t), &out, &out_len); - if (res < 0) { - error("tpm_handle_command() failed"); - } else { - debug("sending %d bytes", out_len); -+ //FIXME this prepending may or may not be needed -+ /*Prepend the first 4 bytes of the in buffer.. why?*/ -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_len); -+ *(uint32_t *) addressed_out = *(uint32_t *) in; -+ memcpy(addressed_out + sizeof(uint32_t), out, out_len); -+ out_len += sizeof(uint32_t); -+ /*End Prepend*/ -+ -+ /*Perform write operation now*/ - while (out_len > 0) { -- res = write(fh, out, out_len); -+ res = write(vtpm_tx_fh, addressed_out, out_len); -+ - if (res < 0) { - error("write(%d) failed: %s", out_len, strerror(errno)); - break; -- } -+ } else { -+ debug_nostop("Sent[%Zu]: ", out_len); -+ for (i=0; (unsigned int)i< out_len; i++) -+ debug_more("%x ", addressed_out[i]); -+ debug_more("\n"); -+ } - out_len -= res; - } - tpm_free(out); -+ tpm_free(addressed_out); - } - } - } while (in_len > 0); -- close(fh); -+ //close(fh); - } -+ - /* shutdown tpm emulator */ - tpm_emulator_shutdown(); -- /* close socket */ -- close(sock); -- unlink(opt_socket_name); -+ /* Close handles */ -+ close(vtpm_tx_fh); -+#ifndef VTPM_MULTI_VM -+ close(vtpm_rx_fh); -+ free(vtpm_rx_file); -+#endif - info("main loop stopped"); - } - -@@ -450,12 +770,13 @@ int main(int argc, char **argv) - /* open random device */ - init_random(); - /* init signal handlers */ -- init_signal_handler(); -+ //init_signal_handler(); - /* unless requested otherwiese, fork and daemonize process */ -- if (!opt_foreground) daemonize(); -+ //if (!opt_foreground) daemonize(); - /* start main processing loop */ - main_loop(); - info("stopping TPM Emulator daemon"); - closelog(); - return 0; - } -+ -diff -Naurp tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h tpm5-test/tpmd/tpm_emulator_config.h ---- tpm_emulator-0.5.1/tpmd/tpm_emulator_config.h 2008-02-14 03:22:48.000000000 -0500 -+++ tpm5-test/tpmd/tpm_emulator_config.h 2009-07-16 11:25:26.000000000 -0400 -@@ -29,23 +29,28 @@ - - /* TPM emulator configuration */ - --#undef TPM_STRONG_PERSISTENCE --#undef TPM_GENERATE_EK -+#define TPM_STRONG_PERSISTENCE -+#define TPM_GENERATE_EK - #undef TPM_GENERATE_SEED_DAA - #undef TPM_MEMORY_ALIGNMENT_MANDATORY - -+extern int dmi_id; -+ - /* log macros */ - - void tpm_log(int priority, const char *fmt, ...); - --#define debug(fmt, ...) tpm_log(LOG_DEBUG, "%s:%d: Debug: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define info(fmt, ...) tpm_log(LOG_INFO, "%s:%d: Info: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) tpm_log(LOG_ERR, "%s:%d: Error: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) tpm_log(LOG_ALERT, "%s:%d: Alert: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) tpm_log(LOG_INFO, "VTPMD[%d]: %s:%d: Info: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) tpm_log(LOG_ERR, "VTPMD[%d]: %s:%d: Error: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) tpm_log(LOG_ALERT, "VTPMD[%d]: %s:%d: Alert: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_nostop(fmt, ...) tpm_log(LOG_DEBUG, "VTPMD[%d]: %s:%d: Debug: " fmt, \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_more(fmt, ...) tpm_log(LOG_DEBUG, fmt, ## __VA_ARGS__) - - /* min/max macros that also do strict type-checking */ - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm/vtpm.patch --- a/tools/vtpm/vtpm.patch Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,716 +0,0 @@ -diff -uprN tpm_emulator/AUTHORS vtpm/AUTHORS ---- tpm_emulator/AUTHORS 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/AUTHORS 2006-12-13 16:38:52.000000000 -0800 -@@ -1,3 +1,3 @@ - Mario Strasser - Heiko Stamer [DAA] --INTEL Corp <> [Dropped to Ring3] -+INTEL Corp <> [VTPM Extensions] -diff -uprN tpm_emulator/ChangeLog vtpm/ChangeLog ---- tpm_emulator/ChangeLog 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/ChangeLog 2006-12-13 16:38:52.000000000 -0800 -@@ -1,5 +1,6 @@ - ????-??-?? Intel Corp - * Moved module out of kernel to run as a ring 3 app -+ * Modified save_to_file and load_from_file to call xen VTPM manager - - 2006-06-23 Mario Strasser - * tpm_startup.c: behaviour of ST_CLEAR and storage of -diff -uprN tpm_emulator/linux_module.h vtpm/linux_module.h ---- tpm_emulator/linux_module.h 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/linux_module.h 2007-01-09 14:49:06.000000000 -0800 -@@ -44,18 +44,26 @@ - #define TPM_DEVICE_NAME "tpm" - #define TPM_MODULE_NAME "tpm_emulator" - -+/* debug and log output functions */ -+extern int dmi_id; -+ - #ifdef DEBUG --#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_nostop(fmt, ...) printf("TPMD[%d]: %s:%d: Debug: " fmt, \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define debug_more(fmt, ...) printf( fmt, ## __VA_ARGS__ ) - #else - #define debug(fmt, ...) -+#define debug_nostop(fmt, ...) -+#define debug_more(fmt, ...) - #endif --#define info(fmt, ...) printf("TPMD: %s:%d: Info: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) --#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \ -- __FILE__, __LINE__, ## __VA_ARGS__) -+#define info(fmt, ...) printf("TPMD[%d]: %s:%d: Info: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define error(fmt, ...) printf("TPMD[%d]: %s:%d: Error: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) -+#define alert(fmt, ...) printf("TPMD[%d]: %s:%d: Alert: " fmt "\n", \ -+ dmi_id, __FILE__, __LINE__, ## __VA_ARGS__) - - /* memory allocation */ - -diff -uprN tpm_emulator/Makefile vtpm/Makefile ---- tpm_emulator/Makefile 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/Makefile 2006-12-13 16:38:52.000000000 -0800 -@@ -7,7 +7,7 @@ - COMPILE_ARCH ?= $(shell uname -m | sed -e s/i.86/x86_32/) - - # module settings --BIN := tpm_emulator -+BIN := vtpmd - VERSION_MAJOR := 0 - VERSION_MINOR := 4 - VERSION_BUILD := $(shell date +"%s") -@@ -22,7 +22,7 @@ TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin - - CC := gcc - CFLAGS += -g -Wall $(INCLUDE) -DDEBUG --CFLAGS += -I. -Itpm -+CFLAGS += -I. -Itpm -I../../vtpm_manager/manager - - # Is the simulator running in it's own vm? - #CFLAGS += -DVTPM_MULTI_VM -@@ -62,7 +62,6 @@ $(BIN): $(src)/crypto/gmp.h $(src)/crypt - - install: $(BIN) - $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR) -- @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi - - clean: - rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS) -@@ -98,3 +97,4 @@ version: - @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h - - .PHONY: all install clean dist gmp version -+ -diff -uprN tpm_emulator/tpm/tpm_capability.c vtpm/tpm/tpm_capability.c ---- tpm_emulator/tpm/tpm_capability.c 2006-06-23 03:37:07.000000000 -0700 -+++ vtpm/tpm/tpm_capability.c 2007-01-10 10:00:49.000000000 -0800 -@@ -136,8 +136,18 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_TIS_TIMEOUT: - debug("[TPM_CAP_PROP_TIS_TIMEOUT]"); -- /* TODO: TPM_CAP_PROP_TIS_TIMEOUT */ -- return TPM_FAIL; -+ /* TODO: TPM_CAP_PROP_TIS_TIMEOUT: Measure these values and determine correct ones */ -+ UINT32 len = *respSize = 16; -+ BYTE *ptr = *resp = tpm_malloc(*respSize); -+ if (ptr == NULL || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000) || -+ tpm_marshal_UINT32(&ptr, &len, 200000)) { -+ tpm_free(*resp); -+ return TPM_FAIL; -+ } -+ return TPM_SUCCESS; - - case TPM_CAP_PROP_STARTUP_EFFECT: - debug("[TPM_CAP_PROP_STARTUP_EFFECT]"); -@@ -190,7 +200,11 @@ static TPM_RESULT cap_property(UINT32 su - - case TPM_CAP_PROP_DURATION: - debug("[TPM_CAP_PROP_DURATION]"); -- /* TODO: TPM_CAP_PROP_DURATION */ -+ /* TODO: TPM_CAP_PROP_DURATION: Measure these values and return accurate ones */ -+ BYTE dur[]= {0x0,0x0,0x0,0xc,0x0,0x7,0xa1,0x20,0x0,0x1e,0x84,0x80,0x11,0xe1,0xa3,0x0}; -+ *respSize = 16; -+ *resp = tpm_malloc(*respSize); -+ memcpy(*resp,dur,16); - return TPM_FAIL; - - case TPM_CAP_PROP_ACTIVE_COUNTER: -diff -uprN tpm_emulator/tpm/tpm_cmd_handler.c vtpm/tpm/tpm_cmd_handler.c ---- tpm_emulator/tpm/tpm_cmd_handler.c 2008-02-27 16:35:41.000000000 -0500 -+++ vtpm/tpm/tpm_cmd_handler.c 2008-02-28 14:43:28.000000000 -0500 -@@ -94,12 +94,18 @@ void tpm_compute_out_param_digest(TPM_CO - sha1_ctx_t sha1; - UINT32 res = CPU_TO_BE32(rsp->result); - UINT32 ord = CPU_TO_BE32(ordinal); -+ UINT32 offset = 0; - - /* compute SHA1 hash */ - sha1_init(&sha1); - sha1_update(&sha1, (BYTE*)&res, 4); - sha1_update(&sha1, (BYTE*)&ord, 4); -- sha1_update(&sha1, rsp->param, rsp->paramSize); -+ if (ordinal == TPM_ORD_LoadKey2) { -+ offset = 4; -+ } -+ if (rsp->paramSize - offset > 0) { -+ sha1_update(&sha1, rsp->param + offset, rsp->paramSize - offset); -+ } - sha1_final(&sha1, rsp->auth1->digest); - if (rsp->auth2 != NULL) memcpy(rsp->auth2->digest, - rsp->auth1->digest, sizeof(rsp->auth1->digest)); -diff -uprN tpm_emulator/tpm/tpm_data.c vtpm/tpm/tpm_data.c ---- tpm_emulator/tpm/tpm_data.c 2008-02-27 16:35:41.000000000 -0500 -+++ vtpm/tpm/tpm_data.c 2008-02-27 16:35:40.000000000 -0500 -@@ -1,6 +1,7 @@ - /* Software-Based Trusted Platform Module (TPM) Emulator for Linux - * Copyright (C) 2004 Mario Strasser , - * Swiss Federal Institute of Technology (ETH) Zurich -+ * Copyright (C) 2005 INTEL Corp - * - * This module is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published -@@ -15,10 +16,15 @@ - * $Id: tpm_data.c 98 2006-05-07 14:16:29Z hstamer $ - */ - -+#include -+#include -+#include -+#include -+ - #include "tpm_emulator.h" - #include "tpm_structures.h" - #include "tpm_marshalling.h" --#include "linux_module.h" -+#include "vtpm_manager.h" - - TPM_DATA tpmData; - -@@ -158,45 +164,232 @@ void tpm_release_data(void) - #include - #include - #include --#include - --#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR) -+ static int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+ -+#ifdef VTPM_MUTLI_VM -+ #define DEV_FE "/dev/tpm" -+#else -+ #define VTPM_RX_FIFO_D "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -+ #define VTPM_TX_FIFO "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -+ -+ extern int dmi_id; -+ static char *vtpm_rx_name=NULL; -+#endif - - static int write_to_file(uint8_t *data, size_t data_length) - { -- int res; -- int fp; -- fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR); -- res = write(fp, data, data_length); -- close(fp); -- return (res == data_length) ? 0 : -1; -+ int res, out_data_size, in_header_size; -+ BYTE *ptr, *out_data, *in_header; -+ UINT32 result, len, in_rsp_size; -+ UINT16 tag = VTPM_TAG_REQ; -+ -+ printf("Saving NVM\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT + data_length; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV + data_length; -+#endif -+ -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_SAVENVM) -+ || tpm_marshal_BYTE_ARRAY(&ptr, &len, data, data_length)) { -+ free(out_data); -+ return -1; -+ } -+ -+ printf("\tSending SaveNVM Command.\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); -+ } -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading SaveNVM header.\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_tx_fh); close(vtpm_rx_fh); -+#endif -+ -+ printf("\tFinishing up SaveNVM\n"); -+ return (0); - } - - static int read_from_file(uint8_t **data, size_t *data_length) - { -- int res; -- int fp, file_status; -- struct stat file_info; -- fp = open(TPM_STORAGE_FILE, O_RDONLY, 0); -- file_status = fstat(fp, &file_info); -- if (file_status < 0) { -- close(fp); -- return -1; -- } -+ int res, out_data_size, in_header_size; -+ uint8_t *ptr, *out_data, *in_header; -+ UINT16 tag = VTPM_TAG_REQ; -+ UINT32 len, in_rsp_size, result; -+#ifdef VTPM_MUTLI_VM -+ int vtpm_rx_fh, vtpm_tx_fh; -+#endif -+ -+ printf("Loading NVM.\n"); -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_FE, O_RDWR); -+#else -+ vtpm_tx_fh = open(VTPM_TX_FIFO, O_WRONLY); -+#endif -+ } - -- *data_length = file_info.st_size; -- *data = tpm_malloc(*data_length); -- if (*data == NULL) { -- close(fp); -+ if (vtpm_tx_fh < 0) { -+ return -1; -+ } -+ -+ // Send request to VTPM Manager to encrypt data -+#ifdef VTPM_MUTLI_VM -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ out_data_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ out_data = ptr = (BYTE *) malloc(len); -+ -+ if (ptr == NULL -+#ifndef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, dmi_id) -+#endif -+ || tpm_marshal_UINT16(&ptr, &len, tag) -+#ifdef VTPM_MUTLI_VM -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size) -+#else -+ || tpm_marshal_UINT32(&ptr, &len, out_data_size - sizeof(uint32_t)) -+#endif -+ || tpm_marshal_UINT32(&ptr, &len, VTPM_ORD_LOADNVM)) { -+ free(out_data); - return -1; - } -- res = read(fp, *data, *data_length); -- close(fp); -+ -+ printf("\tSending LoadNVM command\n"); -+ res = write(vtpm_tx_fh, out_data, out_data_size); -+ free(out_data); -+ if (res != out_data_size) return -1; -+ -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (vtpm_rx_name == NULL) { -+ vtpm_rx_name = malloc(10 + strlen(VTPM_RX_FIFO_D)); -+ sprintf(vtpm_rx_name, VTPM_RX_FIFO_D, (uint32_t) dmi_id); -+ } -+ vtpm_rx_fh = open(vtpm_rx_name, O_RDONLY); -+#endif -+ } -+ -+ if (vtpm_rx_fh < 0) { -+ return -1; -+ } -+ -+ // Read Header of response so we can get the size & status -+#ifdef VTPM_MUTLI_VM -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_CLT; -+#else -+ in_header_size = len = VTPM_COMMAND_HEADER_SIZE_SRV; -+#endif -+ in_header = ptr = malloc(in_header_size); -+ -+ printf("\tReading LoadNVM header\n"); -+ res = read(vtpm_rx_fh, in_header, in_header_size); -+ -+ if ( (res != in_header_size) -+#ifndef VTPM_MUTLI_VM -+ || tpm_unmarshal_UINT32(&ptr, &len, (UINT32*)&dmi_id) -+#endif -+ || tpm_unmarshal_UINT16(&ptr, &len, &tag) -+ || tpm_unmarshal_UINT32(&ptr, &len, &in_rsp_size) -+ || tpm_unmarshal_UINT32(&ptr, &len, &result) ) { -+ free(in_header); -+ return -1; -+ } -+ free(in_header); -+ -+ if (result != VTPM_SUCCESS) { -+ return -1; -+ } -+ -+ // Read Encrypted data from VTPM Manager -+ *data_length = in_rsp_size - VTPM_COMMAND_HEADER_SIZE_CLT; -+ *data = (uint8_t *) malloc(*data_length); -+ -+ printf("\tReading clear data from LoadNVM.\n"); -+ res = read(vtpm_rx_fh, *data, *data_length); -+#ifdef VTPM_MUTLI_VM -+ close(vtpm_rx_fh);close(vtpm_tx_fh); -+#endif -+ -+ printf("\tReturing from loading NVM\n"); - if (res != *data_length) { -- tpm_free(*data); -- return -1; -+ free(*data); -+ return -1; -+ } else { -+ return 0; - } -- return 0; -+ - } - - #else -diff -uprN tpm_emulator/tpmd.c vtpm/tpmd.c ---- tpm_emulator/tpmd.c 2006-12-08 12:51:29.000000000 -0800 -+++ vtpm/tpmd.c 2007-01-09 14:48:56.000000000 -0800 -@@ -21,12 +21,24 @@ - #include - #include - #include -+#include -+#include -+#include - - #include "tpm_emulator.h" -+#include "vtpm_manager.h" - --#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo" --#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo" -+#ifdef VTPM_MULTI_VM -+ #define DEV_BE "/dev/vtpm" -+#else -+ #define PVM_RX_FIFO_D "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -+ #define PVM_TX_FIFO "/var/vtpm/fifos/tpm_rsp_from_all.fifo" - -+ #define HVM_RX_FIFO_D "/var/vtpm/socks/%d.socket" -+#endif -+ -+ int dmi_id; -+ - #define BUFFER_SIZE 2048 - - static int devurandom=0; -@@ -38,7 +50,7 @@ void get_random_bytes(void *buf, int nby - } - - if (read(devurandom, buf, nbytes) != nbytes) { -- printf("Can't get random number.\n"); -+ error("Can't get random number.\n"); - exit(-1); - } - } -@@ -52,105 +64,182 @@ uint64_t tpm_get_ticks(void) - - int main(int argc, char **argv) - { -- uint8_t in[BUFFER_SIZE], *out; -+ uint8_t type, in[BUFFER_SIZE], *out, *addressed_out; -+ char *vtpm_rx_file=NULL; - uint32_t out_size; - int in_size, written; -- int i; -- struct stat file_info; -+ int i, guest_id=-1; - -- int tpm_tx_fh=-1, tpm_rx_fh=-1; -+#ifndef VTPM_MULTI_VM -+ int sockfd = -1; -+ struct sockaddr_un addr; -+ struct sockaddr_un client_addr; -+ unsigned int client_length; -+ -+#endif -+ -+ int vtpm_tx_fh=-1, vtpm_rx_fh=-1; -+#ifdef VTPM_MULTI_VM - if (argc < 2) { -- printf("Usage: tpmd clear|save|deactivated\n" ); -+ error("Usage: tpmd clear|save|deactivated\n" ); -+#else -+ if (argc < 4) { -+ error("Usage: tpmd clear|save|deactivated pvm|hvm vtpmid\n" ); -+#endif - return -1; - } - -+#ifndef VTPM_MULTI_VM -+ /* setup type of vm */ -+ if (!strcmp(argv[2], "pvm")) { -+ type = VTPM_TYPE_PVM; // Get commands from vTPM Manager through fifo -+ } else if (!strcmp(argv[2], "hvm")) { -+ type = VTPM_TYPE_HVM; // Get commands from qemu via socket -+ } else { -+ error("invalid vTPM type '%s'.\n", argv[2]); -+ } -+ -+ dmi_id = atoi(argv[3]); -+ -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_rx_file = malloc(10 + strlen(PVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, PVM_RX_FIFO_D, (uint32_t) dmi_id); -+ } else { -+ vtpm_rx_file = malloc(10 + strlen(HVM_RX_FIFO_D)); -+ sprintf(vtpm_rx_file, HVM_RX_FIFO_D, (uint32_t) dmi_id); -+ -+ if ( (sockfd = socket(PF_UNIX,SOCK_STREAM,0)) < 0) { -+ error("Unable to create socket. errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&addr, 0, sizeof(addr)); -+ addr.sun_family = AF_UNIX; -+ strcpy(addr.sun_path,vtpm_rx_file ); -+ unlink(addr.sun_path); -+ } -+#endif -+ -+#ifdef VTPM_MULTI_VM -+ info("Initializing tpm state: %s\n", argv[1]); -+#else -+ info("Initializing tpm state: %s, type: %s, id: %d\n", argv[1], argv[2], dmi_id); -+#endif -+ - /* initialize TPM emulator */ - if (!strcmp(argv[1], "clear")) { -- printf("Initializing tpm: %s\n", argv[1]); - tpm_emulator_init(1); -- } else if (!strcmp(argv[1], "save")) { -- printf("Initializing tpm: %s\n", argv[1]); -+ } else if (!strcmp(argv[1], "save")) { - tpm_emulator_init(2); - } else if (!strcmp(argv[1], "deactivated")) { -- printf("Initializing tpm: %s\n", argv[1]); - tpm_emulator_init(3); - } else { -- printf("invalid startup mode '%s'; must be 'clear', " -+ error("invalid startup mode '%s'; must be 'clear', " - "'save' (default) or 'deactivated", argv[1]); - return -1; - } -- -- if ( stat(TPM_RX_FNAME, &file_info) == -1) { -- if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) { -- printf("Failed to create fifo %s.\n", TPM_RX_FNAME); -- return -1; -- } -- } -- -- if ( stat(TPM_TX_FNAME, &file_info) == -1) { -- if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) { -- printf("Failed to create fifo %s.\n", TPM_TX_FNAME); -- return -1; -- } -- } -- -+ - while (1) { - abort_command: -- if (tpm_rx_fh < 0) { -- tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY); -+ if (vtpm_rx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_rx_fh = open(DEV_BE, O_RDWR); -+#else -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_rx_fh = open(vtpm_rx_file, O_RDONLY); -+ } else { -+ if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { -+ error("Unable to bind(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ if (listen(sockfd, 10) <0) { -+ error("Unable to listen(). errno = %d\n", errno); -+ exit (-1); -+ } -+ -+ memset(&client_addr, 0, sizeof(client_addr)); -+ client_length = sizeof(client_addr); -+ -+ vtpm_rx_fh = vtpm_tx_fh = accept(sockfd, (struct sockaddr *)&client_addr, &client_length); -+ } -+#endif - } - -- if (tpm_rx_fh < 0) { -- printf("ERROR: failed to open devices to listen to guest.\n"); -+ if (vtpm_rx_fh < 0) { -+ error("Failed to open devices to listen to guest.\n"); - return -1; - } - -- if (tpm_tx_fh < 0) { -- tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY); -- } -- -- if (tpm_tx_fh < 0) { -- printf("ERROR: failed to open devices to respond to guest.\n"); -- return -1; -- } -- -- in_size = read(tpm_rx_fh, in, BUFFER_SIZE); -+ in_size = read(vtpm_rx_fh, in, BUFFER_SIZE); - if (in_size < 6) { // Magic size of minium TPM command -- printf("Recv[%d] to small: 0x", in_size); -+ info("Recv incomplete command of %d bytes.", in_size); - if (in_size <= 0) { -- close(tpm_rx_fh); -- tpm_rx_fh = -1; -+ close(vtpm_rx_fh); -+ vtpm_rx_fh = -1; - goto abort_command; - } - } else { -- printf("Recv[%d]: 0x", in_size); -+ debug_nostop("Recv[%d]: 0x", in_size); - for (i=0; i< in_size; i++) -- printf("%x ", in[i]); -- printf("\n"); -+ debug_more("%x ", in[i]); -+ debug_more("\n"); - } - -- -- if (tpm_handle_command(in, in_size, &out, &out_size) != 0) { -- printf("ERROR: Handler Failed.\n"); -+ if (guest_id == -1) { -+ guest_id = *((uint32_t *) in); -+ } else { -+ if (guest_id != *((uint32_t *) in) ) { -+ error("WARNING: More than one guest attached\n"); -+ } -+ } -+ -+ if (vtpm_tx_fh < 0) { -+#ifdef VTPM_MUTLI_VM -+ vtpm_tx_fh = open(DEV_BE, O_RDWR); -+ vtpm_rx_fh = vtpm_tx_fh; -+#else -+ if (type == VTPM_TYPE_PVM) { -+ vtpm_tx_fh = open(PVM_TX_FIFO, O_WRONLY); -+ } // No need to open the other direction for HVM -+#endif -+ } -+ -+ if (vtpm_tx_fh < 0) { -+ error("Failed to open devices to respond to guest.\n"); -+ return -1; -+ } -+ -+ // Handle the command, but skip the domain id header -+ if (tpm_handle_command(in + sizeof(uint32_t), in_size - sizeof(uint32_t), &out, &out_size) != 0) { -+ error("Handler Failed.\n"); - } - -- written = write(tpm_tx_fh, out, out_size); -+ addressed_out = (uint8_t *) tpm_malloc(sizeof(uint32_t) + out_size); -+ *(uint32_t *) addressed_out = *(uint32_t *) in; -+ memcpy(addressed_out + sizeof(uint32_t), out, out_size); -+ -+ written = write(vtpm_tx_fh, addressed_out, out_size + sizeof(uint32_t)); - -- if (written != out_size ) { -- printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size); -+ if (written != out_size + sizeof(uint32_t)) { -+ error("Part of response not written %d/%d.\n", written, out_size); - } else { -- printf("Sent[%Zu]: ", out_size); -+ debug_nostop("Sent[%Zu]: ", out_size + sizeof(uint32_t)); -+ for (i=0; i< out_size+ sizeof(uint32_t); i++) -+ debug_more("%x ", addressed_out[i]); -+ debug_more("\n"); - } -- for (i=0; i< out_size; i++) -- printf("%x ", out[i]); -- printf("\n"); - tpm_free(out); -+ tpm_free(addressed_out); - - } // loop - - tpm_emulator_shutdown(); - -- close(tpm_tx_fh); -- close(tpm_rx_fh); -+ close(vtpm_tx_fh); -+#ifndef VTPM_MUTLI_VM -+ close(vtpm_rx_fh); -+ free (vtpm_rx_file); -+#endif - - } diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/COPYING --- a/tools/vtpm_manager/COPYING Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,32 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/Makefile --- a/tools/vtpm_manager/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,18 +0,0 @@ -XEN_ROOT = $(CURDIR)/../.. - -# Base definitions and rules -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -SUBDIRS = crypto tcs util manager migration -OPENSSL_HEADER = /usr/include/openssl/crypto.h - -.PHONY: all clean install -all clean install: %: subdirs-% - -.PHONY: mrproper -mrproper: - @set -e; for subdir in $(SUBDIRS); do \ - $(MAKE) -C $$subdir $@; \ - done - - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/README --- a/tools/vtpm_manager/README Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,94 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== - -Directory Structure -=================== -tools/vtpm_manager/crypto -> crypto files -tools/vtpm_manager/TCS -> TCS implementation -tools/vtpm_manager/util -> Utility Library. Include disk-io and buffers. -tools/vtpm_manager/manager -> VTPM Manager - -Compile Flags -=================== -LOGGING_MODULES -> How extensive logging happens - see util/log.h for more info - -VTPM_MULTI_VM -> Defined: VTPMs run in their own VMs - Not Defined (default): VTPMs are processes - -# Debugging flags that may disappear without notice in the future - -DUMMY_BACKEND -> vtpm_manager listens on /tmp/in.fifo and - /tmp/out.fifo rather than backend - -MANUAL_DM_LAUNCH -> Must manually launch & kill VTPMs - -WELL_KNOWN_OWNER_AUTH -> Rather than randomly generating the password for the owner, - use a well known value. This is useful for debugging and for - poor bios which do not support clearing TPM if OwnerAuth is - lost. However this has no protection from malicious app - issuing a TPM_OwnerClear to wipe the TPM - -Requirements -============ -- xen-unstable -- vtpm frontend/backend driver patch -- OpenSSL Library - -Single-VM Flow -============================ -- Launch the VTPM manager (vtpm_managerd) which which begins listening to the BE with one thread - and listens to a named fifo that is shared by the vtpms to commuincate with the manager. -- VTPM Manager listens to TPM BE. -- When xend launches a tpm frontend equipped VM it contacts the manager over the vtpm backend. -- When the manager receives the open message from the BE, it launches a vtpm -- Xend allows the VM to continue booting. -- When a TPM request is issued to the front end, the front end transmits the TPM request to the backend. -- The manager receives the TPM requests and uses a named fifo to forward the request to the vtpm. -- The fifo listener begins listening for the reply from vtpm for the request. -- Vtpm processes request and replies to manager over shared named fifo. -- If needed, the vtpm may send a request to the vtpm_manager at any time to save it's secrets to disk. -- Manager receives response from vtpm and passes it back to backend for forwarding to guest. - -NOTES: -* SaveService SHOULD seal it's table before saving it to disk. However, - the current Xen infrastructure does not provide a mechanism for this to be - unsealed later. Specifically, the auth and wrapped key must be available ONLY - to the service, or it's not even worth encrypting - - In the future the vtpm manager will be protected by an early boot mechanism - that will allow for better protection of it's data. - -TODO: -- Timeout on crashed vtpms -- create lock for shared fifo for talking to vtpms. diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/Rules.mk --- a/tools/vtpm_manager/Rules.mk Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,59 +0,0 @@ -# Base definitions and rules (XEN_ROOT must be defined in including Makefile) -include $(XEN_ROOT)/tools/Rules.mk - -# -# Tool definitions -# - -# General compiler flags -CFLAGS = -Werror -g3 - -# Generic project files -HDRS = $(wildcard *.h) -SRCS = $(wildcard *.c) -OBJS = $(patsubst %.c,%.o,$(SRCS)) - -# Generic (non-header) dependencies -$(SRCS): Makefile $(XEN_ROOT)/tools/Rules.mk $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -$(OBJS): $(SRCS) - --include $(FILES) - -# Make sure these are just rules -.PHONY : all build install clean - -# -# Project-specific definitions -# - -# Need UNIX98 spec for pthread rwlocks -CFLAGS += -D_GNU_SOURCE - -# Logging Level. See utils/tools.h for usage -CFLAGS += -DLOGGING_MODULES="(BITMASK(VTPM_LOG_TCS)|BITMASK(VTPM_LOG_VTSP)|BITMASK(VTPM_LOG_VTPM))" - -# Silent Mode -#CFLAGS += -DLOGGING_MODULES=0x0 -#CFLAGS += -DLOGGING_MODULES=0xff - -# Use frontend/backend pairs between manager & DMs? -#CFLAGS += -DVTPM_MULTI_VM - -# vtpm_manager listens on fifo's rather than backend -#CFLAGS += -DDUMMY_BACKEND - -# TCS talks to fifo's rather than /dev/tpm. TPM Emulator assumed on fifos -#CFLAGS += -DDUMMY_TPM - -# Do not have manager launch DMs. -#CFLAGS += -DMANUAL_DM_LAUNCH - -# Fixed OwnerAuth -#CFLAGS += -DWELL_KNOWN_OWNER_AUTH - -# Include -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/crypto -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/util -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/tcs -CFLAGS += -I$(XEN_ROOT)/tools/vtpm_manager/manager diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/Makefile --- a/tools/vtpm_manager/crypto/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,24 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = libtcpaCrypto.a - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - -.PHONY: clean -clean: - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(AR) rcs $(BIN) $(OBJS) diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/crypto.c --- a/tools/vtpm_manager/crypto/crypto.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,88 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// crypto.c -// -// This file will handle all the TPM Crypto functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include "crypto.h" -#include "log.h" - -/** - * Initialize cryptography library - * @rand: random seed - * @size: size of @rand - */ -void Crypto_Init(const BYTE* rand, int size) { - ERR_load_crypto_strings(); - CRYPTO_malloc_init(); - OpenSSL_add_all_algorithms(); - SYM_CIPHER = EVP_aes_128_cbc(); - RAND_poll(); - if (rand == NULL) - return; - - RAND_add(rand, size, size); -} - -/** - * Shutdown cryptography library - */ -void Crypto_Exit() { - ERR_free_strings(); - ERR_remove_state(0); - EVP_cleanup(); -} - - -/** - * Get random data - * @data: (OUT) Random data - * @size: Size of @data - */ -void Crypto_GetRandom(void* data, int size) { - int result; - - result = RAND_pseudo_bytes((BYTE*) data, size); - - if (result <= 0) - vtpmlogerror (VTPM_LOG_CRYPTO, "RAND_pseudo_bytes failed: %s\n", - ERR_error_string (ERR_get_error(), NULL)); -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/crypto.h --- a/tools/vtpm_manager/crypto/crypto.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,175 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// crypto.h -// -// This file defines the TPM Crypto API -// -// ================================================================== - -#ifndef __CRYPTO_H__ -#define __CRYPTO_H__ - -#include -#include -#include - -#include "tcg.h" -#include "sym_crypto.h" - -#define CRYPTO_MAX_SIG_SIZE (2048 / 8) -#define CRYPTO_MAX_RSA_KEY_SIZE (4096 / 8) //in bytes - -#define OAEP_P "TCPA" -#define OAEP_P_SIZE 4 - -// Algorithms supported by crypto. Stored in CRYPTO_INFO.algorithmID -#define CRYPTO_ALGORITH_RSA 0x01 - -// Supported Encryption Schemes CRYPTO_INFO.encScheme -#define CRYPTO_ES_NONE 0x0001 -#define CRYPTO_ES_RSAESPKCSv15 0x0002 -#define CRYPTO_ES_RSAESOAEP_SHA1_MGF1 0x0003 - -// Supported Signature schemes CRYPTO_INFO.sigScheme -#define CRYPTO_SS_NONE 0x0001 -#define CRYPTO_SS_RSASSAPKCS1v15_SHA1 0x0002 -#define CRYPTO_SS_RSASSAPKCS1v15_DER 0x0003 - -typedef struct CRYPTO_INFO { - void *keyInfo; - UINT32 algorithmID; - UINT32 encScheme; - UINT32 sigScheme; -} CRYPTO_INFO; - - -void Crypto_Init(const BYTE* rand, int size); - -void Crypto_Exit(); - -void Crypto_GetRandom(void* data, int size); - -void Crypto_HMAC( const BYTE* text, - int text_len, - const BYTE* key, - int key_len, - BYTE* digest); - -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, - const buffer_t * key, - BYTE * o_digest); /* presumably of 20 bytes */ - -void Crypto_SHA1Full( const BYTE* text, - UINT32 size, - BYTE* hash); //Complete 3part SHA1 - -// o_hash needs to be large enough to hold the digest, ie 20 bytes -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, - BYTE * o_hash); - -void Crypto_SHA1Start(UINT32* maxNumBytes); -void Crypto_SHA1Update(int numBytes, const BYTE* hashData); -void Crypto_SHA1Complete( int hashDataSize, - const BYTE* hashData, - BYTE* hashValue); - -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, - /*in*/ UINT32 pubExpSize, - /*in*/ BYTE *pubExp, - /*out*/ UINT32 *privExpSize, - /*out*/ BYTE *privExp, - /*out*/ UINT32 *modulusSize, - /*out*/ BYTE *modulus, - /*out*/ CRYPTO_INFO *keys); - -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 privExpSize, - /*[IN]*/ BYTE *privExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - /*[OUT]*/ CRYPTO_INFO* cryptoInfo); - -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo); - -// -// symmetric pack and unpack operations -// -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, - BYTE ** io_buf, UINT32 * io_buflen); - -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, - BYTE * in, UINT32 len, - UINT32 * o_lenread); - - -// return 0 on success, -1 on error -int Crypto_RSAEnc( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData); - -// return 0 on success, -1 on error -int Crypto_RSADec( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData); - -// return 0 on success, -1 on error -int Crypto_RSASign( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *sigSize, - /*out*/ BYTE *sig); - -bool Crypto_RSAVerify( CRYPTO_INFO *keys, - UINT32 inDataSize, - BYTE *inData, - UINT32 sigSize, - BYTE *sig); - -//private: -int RSA_verify_DER(int dtype, unsigned char *m, unsigned int m_len, - unsigned char *sigbuf, unsigned int siglen, CRYPTO_INFO *key); - -int RSA_sign_DER(int type, unsigned char *m, unsigned int m_len, - unsigned char *sigret, unsigned int *siglen, CRYPTO_INFO *key); - -#endif // __CRYPTO_H__ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/hash.c --- a/tools/vtpm_manager/crypto/hash.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,153 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// hash.c -// -// This file will handle all the TPM Hash functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "tcg.h" // for TPM_SUCCESS -#include "crypto.h" - -static SHA_CTX g_shaContext; - -void Crypto_HMAC( const BYTE* text, - int text_len, - const BYTE* key, - int key_len, - BYTE* digest) { - if (text == NULL || key == NULL || text_len == 0 || key_len == 0) - return; - - HMAC(EVP_sha1(), key, key_len, text, text_len, digest, NULL); -} - -TPM_RESULT Crypto_HMAC_buf (const buffer_t * text, - const buffer_t * key, - BYTE * o_digest) { /* presumably of 20 bytes */ - - Crypto_HMAC (text->bytes, text->size, - key->bytes, key->size, - o_digest); - - return TPM_SUCCESS; -} - - -/* - * SHA1 - * (OUT) Create a SHA1 hash of text. Calls all three SHA1 steps internally - */ -void Crypto_SHA1Full( const BYTE* text, - uint32_t size, - BYTE* hash) { - - if (text == NULL || size == 0) - return; - - // Run SHA1Start + SHAUpdate (if necessary) + SHAComplete - uint32_t maxBytes; // Not used for anything - Crypto_SHA1Start(&maxBytes); - - while (size > 64){ - Crypto_SHA1Update(64, text); - size -= 64; - text += 64; - } - - Crypto_SHA1Complete(size, text, hash); -} - -// same thing using buffer_t -TPM_RESULT Crypto_SHA1Full_buf (const buffer_t * buf, - BYTE * o_digest) { - - if (buf->bytes == NULL || buf->size == 0) - return TPM_BAD_PARAMETER; - - Crypto_SHA1Full (buf->bytes, buf->size, o_digest); - - return TPM_SUCCESS; -} - - -/* - * Initialize SHA1 - * (OUT) Maximum number of bytes that can be sent to SHA1Update. - * Must be a multiple of 64 bytes. - */ -void Crypto_SHA1Start(uint32_t* maxNumBytes) { - int max = SHA_CBLOCK; - // Initialize the crypto library - SHA1_Init(&g_shaContext); - *maxNumBytes = max; -} - -/* - * Process SHA1 - * @numBytes: (IN) The number of bytes in hashData. - * Must be a multiple of 64 bytes. - * @hashData: (IN) Bytes to be hashed. - */ -void Crypto_SHA1Update(int numBytes, const BYTE* hashData) { - - if (hashData == NULL || numBytes == 0 || numBytes%64 != 0) - return; - - SHA1_Update(&g_shaContext, hashData, numBytes); -} - -/* - * Complete the SHA1 process - * @hashDataSize: (IN) Number of bytes in hashData. - * Must be a multiple of 64 bytes. - * @hashData: (IN) Final bytes to be hashed. - * @hashValue: (OUT) The output of the SHA-1 hash. - */ -void Crypto_SHA1Complete(int hashDataSize, - const BYTE* hashData, - BYTE* hashValue) { - SHA1_Update(&g_shaContext, hashData, hashDataSize); - SHA1_Final(hashValue, &g_shaContext); -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/rsa.c --- a/tools/vtpm_manager/crypto/rsa.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,434 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// rsa.c -// -// This file will handle all the TPM RSA crypto functionality -// -// ================================================================== - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include "tcg.h" -#include "buffer.h" -#include "crypto.h" -#include "log.h" - -void Crypto_RSACreateKey( /*in*/ UINT32 keySize, - /*in*/ UINT32 pubExpSize, - /*in*/ BYTE *pubExp, - /*out*/ UINT32 *privExpSize, - /*out*/ BYTE *privExp, - /*out*/ UINT32 *modulusSize, - /*out*/ BYTE *modulus, - /*out*/ CRYPTO_INFO *keys) { - unsigned long e_value; - - if (pubExpSize == 0) // Default e = 2^16+1 - e_value = (0x01 << 16) + 1; - else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - e_value = (0x01 << 16) + 1; - } - - RSA *rsa = RSA_generate_key(keySize, e_value, NULL, NULL); - - if (keys) { - keys->keyInfo = rsa; - keys->algorithmID = CRYPTO_ALGORITH_RSA; - } - - if (modulus) *modulusSize = BN_bn2bin(rsa->n, modulus); - if (privExp) *privExpSize = BN_bn2bin(rsa->d, privExp); -} - -// Create a CRYPTO_INFO struct from the BYTE * key parts. -// If pubExp info is NULL, use TCG default. -// If there is a remainder while calculating the privExp, return FALSE. - -void Crypto_RSABuildCryptoInfo( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 privExpSize, - /*[IN]*/ BYTE *privExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo) { - cryptoInfo->keyInfo = RSA_new(); - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - rsa->e = BN_new(); - - if (pubExpSize == 0) { // Default e = 2^16+1 - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } - - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); - rsa->d = BN_bin2bn(privExp, privExpSize, NULL); -} - -// Create a CRYPTO_INFO struct from the BYTE * key parts. -// If pubExp info is NULL, use TCG default. -// If there is a remainder while calculating the privExp, return FALSE. - -void Crypto_RSABuildCryptoInfoPublic( /*[IN]*/ UINT32 pubExpSize, - /*[IN]*/ BYTE *pubExp, - /*[IN]*/ UINT32 modulusSize, - /*[IN]*/ BYTE *modulus, - CRYPTO_INFO* cryptoInfo) { - cryptoInfo->keyInfo = RSA_new(); - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - rsa->e = BN_new(); - - if (pubExpSize == 0) { // Default e = 2^16+1 - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } else { - // This is not supported, but the following line MIGHT work - // under then assumption that the format is BigNum compatable - // Though it's not in the spec, so who knows what it is. - // Forcing the default. - //BN_bin2bn(pubExp, pubExpSize, NULL); - BN_set_bit(rsa->e, 16); - BN_set_bit(rsa->e, 0); - } - - rsa->n = BN_bin2bn(modulus, modulusSize, NULL); - -} - -int Crypto_RSAEnc( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData) { - RSA *rsa = (RSA *) key->keyInfo; - UINT32 paddedDataSize = RSA_size (rsa); - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); - int rc; - - if (paddedData == NULL) - return -1; - - *outDataSize = 0; - - switch (key->encScheme) { - case CRYPTO_ES_RSAESPKCSv15: - if (RSA_padding_add_PKCS1_type_2(paddedData, paddedDataSize, inData, inDataSize) <= 0) { - rc = -1; - goto abort_egress; - } - break; - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: - if (RSA_padding_add_PKCS1_OAEP(paddedData,paddedDataSize,inData,inDataSize, (BYTE *) OAEP_P,OAEP_P_SIZE) <= 0 ) { - rc = -1; - goto abort_egress; - } - break; - default: - rc = -1; - goto abort_egress; - } - - rc = RSA_public_encrypt(paddedDataSize, paddedData, outData, rsa, RSA_NO_PADDING); - if (rc == -1) - goto abort_egress; - - *outDataSize = rc; - - if (rc > 0) rc = 0; - - goto egress; - - abort_egress: - egress: - - if (paddedData) - free (paddedData); - return rc; - -} - -int Crypto_RSADec( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *outDataSize, - /*out*/ BYTE *outData) { - - RSA *rsa = (RSA *) key->keyInfo; - UINT32 paddedDataSize = RSA_size (rsa); - BYTE *paddedData = (BYTE *)malloc(sizeof(BYTE) * paddedDataSize); - int rc; - - if (paddedData == NULL) - goto abort_egress; - - rc = RSA_private_decrypt(inDataSize, inData, paddedData, rsa, RSA_NO_PADDING); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_private_decrypt: %s\n", ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - - paddedDataSize = rc; - - switch (key->encScheme) { - case CRYPTO_ES_RSAESPKCSv15: - rc = RSA_padding_check_PKCS1_type_2 (outData, paddedDataSize, - paddedData + 1, paddedDataSize - 1, - RSA_size(rsa)); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_type_2: %s\n", - ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - *outDataSize = rc; - break; - case CRYPTO_ES_RSAESOAEP_SHA1_MGF1: - rc = RSA_padding_check_PKCS1_OAEP(outData, paddedDataSize, - paddedData + 1, paddedDataSize - 1, - RSA_size(rsa), - (BYTE *) OAEP_P, OAEP_P_SIZE); - if (rc == -1) { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA_padding_check_PKCS1_OAEP: %s\n", - ERR_error_string(ERR_get_error(), NULL)); - goto abort_egress; - } - *outDataSize = rc; - break; - default: - *outDataSize = 0; - } - - free(paddedData); paddedData = NULL; - goto egress; - - abort_egress: - - if (paddedData) - free (paddedData); - return -1; - - egress: - return 0; -} - -// Signs either a SHA1 digest of a message or a DER encoding of a message -// Textual messages MUST be encoded or Hashed before sending into this function -// It will NOT SHA the message. -int Crypto_RSASign( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - /*out*/ UINT32 *sigSize, - /*out*/ BYTE *sig) { - int status; - unsigned int intSigSize; - - switch(key->sigScheme) { - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: - status = RSA_sign(NID_sha1, inData, inDataSize, sig, &intSigSize, (RSA *) key->keyInfo); - break; - case CRYPTO_SS_RSASSAPKCS1v15_DER: - // status = Crypto_RSA_sign_DER(NID_md5_sha1, inData, inDataSize, sig, &intSigSize, key); - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); - status = 0; - break; - default: - status = 0; - } - - if (status == 0) { - *sigSize = 0; - vtpmlogerror(VTPM_LOG_CRYPTO, "%s\n", ERR_error_string(ERR_get_error(), NULL)); - return -1; - } - - *sigSize = (UINT32) intSigSize; - return 0; -} - -bool Crypto_RSAVerify( CRYPTO_INFO *key, - UINT32 inDataSize, - BYTE *inData, - UINT32 sigSize, - BYTE *sig) { - int status; - - switch(key->sigScheme){ - case CRYPTO_SS_RSASSAPKCS1v15_SHA1: - status = RSA_verify(NID_sha1, inData, inDataSize, sig, sigSize, (RSA *) key->keyInfo); - break; - case CRYPTO_SS_RSASSAPKCS1v15_DER: - //status = Crypto_RSA_verify_DER(NID_md5_sha1, inData, inDataSize, sig, sigSize, key); - vtpmlogerror(VTPM_LOG_CRYPTO, "Crypto: Unimplemented sign type (%d)\n", key->sigScheme); - status = 0; - break; - default: - status = 0; - } - - if (status) - return(1); - else { - vtpmlogerror(VTPM_LOG_CRYPTO, "RSA verify: %s\n", ERR_error_string(ERR_get_error(), NULL)); - return(0); - } - -} - -// helper which packs everything into a BIO! - -// packs the parameters first, then the private key, then the public key -// if *io_buf is NULL, allocate it here as needed. otherwise its size is in -// *io_buflen -TPM_RESULT Crypto_RSAPackCryptoInfo (const CRYPTO_INFO* cryptoInfo, - BYTE ** io_buf, UINT32 * io_buflen) { - TPM_RESULT status = TPM_SUCCESS; - BYTE * buf; - long len, outlen = *io_buflen; - - const long PARAMSLEN = 3*sizeof(UINT32); - - RSA *rsa = (RSA *) cryptoInfo->keyInfo; - - BIO *mem = BIO_new(BIO_s_mem()); - - - // write the openssl keys to the BIO - if ( i2d_RSAPrivateKey_bio (mem, rsa) == 0 ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_SIZE); - } - if ( i2d_RSAPublicKey_bio (mem, rsa) == 0 ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_SIZE); - } - - // get the buffer out - len = BIO_get_mem_data (mem, &buf); - - // see if we need to allocate a return buffer - if (*io_buf == NULL) { - *io_buf = (BYTE*) malloc (PARAMSLEN + len); - if (*io_buf == NULL) - ERRORDIE (TPM_SIZE); - } else { // *io_buf is already allocated - if (outlen < len + PARAMSLEN) - ERRORDIE (TPM_SIZE); // but not large enough! - } - - // copy over the parameters (three UINT32's starting at algorithmID) - memcpy (*io_buf, &cryptoInfo->algorithmID, PARAMSLEN); - - // copy over the DER keys - memcpy (*io_buf + PARAMSLEN, buf, len); - - *io_buflen = len + PARAMSLEN; - - goto egress; - - - abort_egress: - egress: - - BIO_free (mem); - - return status; -} - - - -// sets up ci, and returns the number of bytes read in o_lenread -TPM_RESULT Crypto_RSAUnpackCryptoInfo (CRYPTO_INFO * ci, - BYTE * in, UINT32 len, - UINT32 * o_lenread) { - - TPM_RESULT status = TPM_SUCCESS; - long l; - BIO *mem; - RSA *rsa; - - // first load up the params - l = 3 * sizeof(UINT32); - memcpy (&ci->algorithmID, in, l); - len -= l; - in += l; - - // and now the openssl keys, private first - mem = BIO_new_mem_buf (in, len); - - if ( (rsa = d2i_RSAPrivateKey_bio (mem, NULL)) == NULL ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_BAD_PARAMETER); - } - // now use the same RSA object and fill in the private key - if ( d2i_RSAPublicKey_bio (mem, &rsa) == NULL ) { - ERR_print_errors_fp (stderr); - ERRORDIE (TPM_BAD_PARAMETER); - } - - ci->keyInfo = rsa; // needs to be freed somehow later - - // FIXME: havent figured out yet how to tell how many bytes were read in the - // above oprations! so o_lenread is not set - - goto egress; - - abort_egress: - egress: - - BIO_free (mem); - - return status; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/sym_crypto.c --- a/tools/vtpm_manager/crypto/sym_crypto.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,237 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// sym_crypto.c -// -// Symmetric crypto portion of crypto -// -// ================================================================== - -#include -#include - -#include "tcg.h" -#include "sym_crypto.h" - -typedef enum crypt_op_type_t { - CRYPT_ENCRYPT, - CRYPT_DECRYPT -} crypt_op_type_t; - -TPM_RESULT ossl_symcrypto_op (symkey_t* key, - const buffer_t* in, - const buffer_t* iv, - buffer_t * out, - crypt_op_type_t optype); - - -// this is initialized in Crypto_Init() -const EVP_CIPHER * SYM_CIPHER = NULL; - -const BYTE ZERO_IV[EVP_MAX_IV_LENGTH] = {0}; - - -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits) { - TPM_RESULT status = TPM_SUCCESS; - - EVP_CIPHER_CTX_init (&key->context); - - key->cipher = SYM_CIPHER; - - TPMTRYRETURN( buffer_init_copy (&key->key, keybits)); - - goto egress; - - abort_egress: - EVP_CIPHER_CTX_cleanup (&key->context); - - egress: - - return status; -} - - - -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key) { - int res; - TPM_RESULT status = TPM_SUCCESS; - - // hmm, EVP_CIPHER_CTX_init does not return a value - EVP_CIPHER_CTX_init (&key->context); - - key->cipher = SYM_CIPHER; - - TPMTRYRETURN( buffer_init (&key->key, EVP_CIPHER_key_length(key->cipher), NULL)) ; - - // and generate the key material - res = RAND_pseudo_bytes (key->key.bytes, key->key.size); - if (res < 0) - ERRORDIE (TPM_SHORTRANDOM); - - - goto egress; - - abort_egress: - EVP_CIPHER_CTX_cleanup (&key->context); - buffer_free (&key->key); - - egress: - return status; -} - - -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, - const buffer_t* clear, - buffer_t* o_cipher) { - TPM_RESULT status = TPM_SUCCESS; - - buffer_t iv, cipher_alias; - - buffer_init_const (&iv, EVP_MAX_IV_LENGTH, ZERO_IV); - - buffer_init (o_cipher, - clear->size + - EVP_CIPHER_iv_length(key->cipher) + - EVP_CIPHER_block_size (key->cipher), - 0); - - // copy the IV into the front - buffer_copy (o_cipher, &iv); - - // make an alias into which we'll put the ciphertext - buffer_init_alias (&cipher_alias, o_cipher, EVP_CIPHER_iv_length(key->cipher), 0); - - TPMTRYRETURN( ossl_symcrypto_op (key, clear, &iv, &cipher_alias, CRYPT_ENCRYPT) ); - - // set the output size correctly - o_cipher->size += cipher_alias.size; - - goto egress; - - abort_egress: - - egress: - - return status; - -} - - - -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, - const buffer_t* cipher, - buffer_t* o_clear) { - TPM_RESULT status = TPM_SUCCESS; - - buffer_t iv, cipher_alias; - - // alias for the IV - buffer_init_alias (&iv, cipher, 0, EVP_CIPHER_iv_length(key->cipher)); - - // make an alias to where the ciphertext is, after the IV - buffer_init_alias (&cipher_alias, cipher, EVP_CIPHER_iv_length(key->cipher), 0); - - // prepare the output buffer - TPMTRYRETURN( buffer_init (o_clear, - cipher->size - - EVP_CIPHER_iv_length(key->cipher) - + EVP_CIPHER_block_size(key->cipher), - 0) ); - - // and decrypt - TPMTRYRETURN ( ossl_symcrypto_op (key, &cipher_alias, &iv, o_clear, CRYPT_DECRYPT) ); - - goto egress; - - abort_egress: - buffer_free (o_clear); - - egress: - - return status; -} - - - -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key) { - buffer_memset (&key->key, 0); - buffer_free (&key->key); - - EVP_CIPHER_CTX_cleanup (&key->context); - - return TPM_SUCCESS; -} - - -TPM_RESULT ossl_symcrypto_op (symkey_t* key, - const buffer_t* in, - const buffer_t* iv, - buffer_t * out, - crypt_op_type_t optype) { - TPM_RESULT status = TPM_SUCCESS; - - int inlen, outlen; - tpm_size_t running; - - if ( ! EVP_CipherInit_ex (&key->context, - key->cipher, NULL, key->key.bytes, iv->bytes, - optype == CRYPT_ENCRYPT ? 1 : 0) ) - ERRORDIE (TPM_FAIL); - - - - inlen = in->size; - - outlen = 0; - running = 0; - - - if ( ! EVP_CipherUpdate (&key->context, out->bytes, &outlen, in->bytes, inlen) ) - ERRORDIE (TPM_FAIL); - - running += outlen; - - if ( ! EVP_CipherFinal_ex (&key->context, out->bytes + running, &outlen) ) - ERRORDIE (TPM_FAIL); - - running += outlen; - - out->size = running; - - goto egress; - - abort_egress: - egress: - - return status; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/crypto/sym_crypto.h --- a/tools/vtpm_manager/crypto/sym_crypto.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,72 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// sym_crypto.h -// -// Symmetric Crypto -// -// ================================================================== - -#ifndef _SYM_CRYPTO_H -#define _SYM_CRYPTO_H - -#include -#include "buffer.h" - -typedef struct symkey_t { - buffer_t key; - - EVP_CIPHER_CTX context; - const EVP_CIPHER * cipher; -} symkey_t; - -extern const EVP_CIPHER * SYM_CIPHER; - -TPM_RESULT Crypto_symcrypto_genkey (symkey_t * key); - -TPM_RESULT Crypto_symcrypto_initkey (symkey_t * key, const buffer_t* keybits); - - -// these functions will allocate their output buffers -TPM_RESULT Crypto_symcrypto_encrypt (symkey_t* key, - const buffer_t* clear, - buffer_t* o_cipher); - -TPM_RESULT Crypto_symcrypto_decrypt (symkey_t* key, - const buffer_t* cipher, - buffer_t* o_clear); - -// only free the internal parts, not the 'key' ptr -TPM_RESULT Crypto_symcrypto_freekey (symkey_t * key); - -#endif /* _SYM_CRYPTO_H */ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/Makefile --- a/tools/vtpm_manager/manager/Makefile Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +0,0 @@ -XEN_ROOT = $(CURDIR)/../../.. -include $(XEN_ROOT)/tools/vtpm_manager/Rules.mk - -BIN = vtpm_managerd - -.PHONY: all -all: build - -.PHONY: build -build: $(BIN) - -.PHONY: install -install: build - if [ ! -d "$(DESTDIR)/var/vtpm/fifos" ]; \ - then mkdir -p $(DESTDIR)/var/vtpm/fifos; \ - fi - if [ ! -d "$(DESTDIR)/var/vtpm/socks" ]; \ - then mkdir -p $(DESTDIR)/var/vtpm/socks; \ - fi - $(INSTALL_PROG) $(BIN) $(DESTDIR)$(BINDIR) - -.PHONY: clean -clean: - rm -f $(BIN) - rm -f *.a *.so *.o *.rpm $(DEP_FILES) - -.PHONY: mrproper -mrproper: clean - rm -f *~ - -$(BIN): $(OBJS) - $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ - -# libraries -LIBS += ../tcs/libTCS.a ../util/libTCGUtils.a ../crypto/libtcpaCrypto.a -LIBS += -lcrypto $(PTHREAD_LIBS) -lm -CFLAGS += $(PTHREAD_CFLAGS) -LDFLAGS += $(PTHREAD_LDFLAGS) diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/dmictl.c --- a/tools/vtpm_manager/manager/dmictl.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,266 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// dmictl.c -// -// Functions for creating and destroying DMIs -// -// ================================================================== - -#include -#include -#include - -#include "vtpmpriv.h" -#include "bsg.h" -#include "buffer.h" -#include "log.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "vtpm_ipc.h" - -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" - -// if dmi_res is non-null, then return a pointer to new object. -// Also, this does not fill in the measurements. They should be filled by -// design dependent code or saveNVM -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE dmi_type, VTPM_DMI_RESOURCE **dmi_res) { - - TPM_RESULT status=TPM_SUCCESS; - VTPM_DMI_RESOURCE *new_dmi=NULL; - UINT32 *dmi_id_key=NULL; - - if ((new_dmi = (VTPM_DMI_RESOURCE *) malloc (sizeof(VTPM_DMI_RESOURCE))) == NULL) { - status = TPM_RESOURCES; - goto abort_egress; - } - memset(new_dmi, 0, sizeof(VTPM_DMI_RESOURCE)); - new_dmi->dmi_id = dmi_id; - new_dmi->dmi_type = dmi_type; - new_dmi->connected = FALSE; - new_dmi->TCSContext = 0; - - new_dmi->NVMLocation = (char *) malloc(11 + strlen(DMI_NVM_FILE)); - sprintf(new_dmi->NVMLocation, DMI_NVM_FILE, (uint32_t) new_dmi->dmi_id); - - if ((dmi_id_key = (UINT32 *) malloc (sizeof(UINT32))) == NULL) { - status = TPM_RESOURCES; - goto abort_egress; - } - *dmi_id_key = new_dmi->dmi_id; - - // install into map - if (!hashtable_insert(vtpm_globals->dmi_map, dmi_id_key, new_dmi)){ - vtpmlogerror(VTPM_LOG_VTPM, "Failed to insert instance into table. Aborting.\n", dmi_id); - status = TPM_FAIL; - goto abort_egress; - } - - if (dmi_res) - *dmi_res = new_dmi; - - goto egress; - - abort_egress: - if (new_dmi) { - free(new_dmi->NVMLocation); - free(new_dmi); - } - free(dmi_id_key); - - egress: - return status; -} - -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res) { - if (dmi_res == NULL) - return TPM_SUCCESS; - - if (dmi_res->dmi_id == VTPM_CTL_DM) - return(TPM_BAD_PARAMETER); - - TCS_CloseContext(dmi_res->TCSContext); - dmi_res->connected = FALSE; - - vtpm_globals->connected_dmis--; - - return (VTPM_Close_DMI_Extra(dmi_res) ); -} - -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf) { - - VTPM_DMI_RESOURCE *new_dmi=NULL; - TPM_RESULT status=TPM_FAIL; - BYTE dmi_type, vm_type, startup_mode; - UINT32 dmi_id; - - if (param_buf == NULL) { // Assume creation of Dom 0 control - dmi_type = VTPM_TYPE_NON_MIGRATABLE; - dmi_id = VTPM_CTL_DM; - } else if (buffer_len(param_buf) != sizeof(BYTE) * 3 + sizeof(UINT32)) { - vtpmloginfo(VTPM_LOG_VTPM, "New DMI command wrong length: %d.\n", buffer_len(param_buf)); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } else { - vtpm_globals->connected_dmis++; // Put this here so we don't count Dom0 - BSG_UnpackList( param_buf->bytes, 4, - BSG_TYPE_BYTE, &dmi_type, - BSG_TYPE_BYTE, &startup_mode, - BSG_TYPE_BYTE, &vm_type, - BSG_TYPE_UINT32, &dmi_id); - } - - if ((dmi_type != VTPM_TYPE_NON_MIGRATABLE) && (dmi_type != VTPM_TYPE_MIGRATABLE)) { - vtpmlogerror(VTPM_LOG_VTPM, "Creation of VTPM with illegal type.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - new_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (new_dmi == NULL) { - vtpmloginfo(VTPM_LOG_VTPM, "Creating new DMI instance %d attached.\n", dmi_id ); - // Brand New DMI. Initialize the persistent pieces - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &new_dmi) ); - } else - vtpmloginfo(VTPM_LOG_VTPM, "Re-attaching DMI instance %d.\n", dmi_id); - - if (new_dmi->connected) { - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach, currently attached instance %d. Ignoring\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (new_dmi->dmi_type == VTPM_TYPE_MIGRATED) { - vtpmlogerror(VTPM_LOG_VTPM, "Attempt to re-attach previously migrated instance %d without recovering first. Ignoring\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Initialize the Non-persistent pieces - TPMTRYRETURN( TCS_OpenContext(&new_dmi->TCSContext) ); - - new_dmi->connected = TRUE; - - // Design specific new DMI code. - // Includes: create IPCs, Measuring DMI, and maybe launching DMI - TPMTRYRETURN(VTPM_New_DMI_Extra(new_dmi, vm_type, startup_mode) ); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create DMI id=%d due to status=%s. Cleaning.\n", dmi_id, tpm_get_error_name(status)); - close_dmi(new_dmi ); - - egress: - return status; -} - -TPM_RESULT VTPM_Handle_Close_DMI( const buffer_t *param_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *dmi_res=NULL; - UINT32 dmi_id; - - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size."); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - BSG_UnpackList( param_buf->bytes, 1, - BSG_TYPE_UINT32, &dmi_id); - - vtpmloginfo(VTPM_LOG_VTPM, "Closing DMI %d.\n", dmi_id); - - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (dmi_res == NULL ) { - vtpmlogerror(VTPM_LOG_VTPM, "Trying to close nonexistent DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (!dmi_res->connected) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-connected DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Close Dmi - TPMTRYRETURN(close_dmi( dmi_res )); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} - -TPM_RESULT VTPM_Handle_Delete_DMI( const buffer_t *param_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *dmi_res=NULL; - UINT32 dmi_id; - - if ((param_buf == NULL) || (buffer_len(param_buf) != sizeof(UINT32)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing DMI has bad size.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - BSG_UnpackList( param_buf->bytes, 1, - BSG_TYPE_UINT32, &dmi_id); - - vtpmloginfo(VTPM_LOG_VTPM, "Deleting DMI %d.\n", dmi_id); - - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_remove(vtpm_globals->dmi_map, &dmi_id); - if (dmi_res == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing non-existent DMI.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - //vtpm scripts delete file dmi_res->NVMLocation for us - - // Close DMI first - TPMTRYRETURN(close_dmi( dmi_res )); - free ( dmi_res ); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - egress: - - return status; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/migration.c --- a/tools/vtpm_manager/manager/migration.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,307 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// dmictl.c -// -// Functions for creating and destroying DMIs -// -// ================================================================== - -#include -#include -#include - -#include "vtpmpriv.h" -#include "bsg.h" -#include "buffer.h" -#include "log.h" -#include "hashtable.h" - -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *mig_dmi=NULL; - UINT32 dmi_id; - buffer_t dmi_state_abuf = NULL_BUF, enc_dmi_abuf = NULL_BUF, clear_dmi_blob = NULL_BUF; - - if (param_buf == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - struct pack_buf_t enc_dmi_state_pack; - - BSG_UnpackList(param_buf->bytes, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TPM_SIZE32_DATA, &enc_dmi_state_pack) ; - - vtpmloginfo(VTPM_LOG_VTPM, "Migrating VTPM in dmi %d.\n", dmi_id); - - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (mig_dmi) { - vtpmlogerror(VTPM_LOG_VTPM, "Incoming VTPM claims unavailable id: %d.\n", dmi_id); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** UnBind Blob **/ - TPMTRYRETURN( buffer_init_alias_convert( &enc_dmi_abuf, - enc_dmi_state_pack.size, - enc_dmi_state_pack.data) ); - - TPMTRYRETURN( envelope_decrypt( &enc_dmi_abuf, - vtpm_globals->manager_tcs_handle, - vtpm_globals->storageKeyHandle, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - &clear_dmi_blob) ); - - // Create new dmi - TPMTRYRETURN( init_dmi(dmi_id, VTPM_TYPE_MIGRATABLE, &mig_dmi ) ); - - /** Open Blob **/ - struct pack_buf_t dmi_state_pack; - - BSG_UnpackList(clear_dmi_blob.bytes, 2, - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, - BSG_TPM_SIZE32_DATA, &dmi_state_pack); - - TPMTRYRETURN( buffer_init_alias_convert(&dmi_state_abuf, - dmi_state_pack.size, - dmi_state_pack.data) ); - - TPMTRYRETURN( VTPM_Handle_Save_NVM(mig_dmi, &dmi_state_abuf, NULL ) ); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration IN of instance %d failed because of %s.\n", dmi_id, tpm_get_error_name(status) ); - - egress: - buffer_free(&clear_dmi_blob); - buffer_free(&dmi_state_abuf); - - return status; -} - -TPM_RESULT VTPM_Handle_Migrate_Out( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_DMI_RESOURCE *mig_dmi; - UINT32 dmi_id; - VTPM_MIGKEY_LIST *last_mig, *mig_key; - buffer_t dmi_state=NULL_BUF, clear_dmi_blob=NULL_BUF; - - if (param_buf == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Migration Out Failed due to bad parameter.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - struct pack_buf_t name_pack; - - BSG_UnpackList( param_buf->bytes, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TPM_SIZE32_DATA, &name_pack); - - vtpmloginfo(VTPM_LOG_VTPM, "Migrating out dmi %d.\n", dmi_id); - - mig_dmi = (VTPM_DMI_RESOURCE *) hashtable_search(vtpm_globals->dmi_map, &dmi_id); - if (mig_dmi == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Non-existent VTPM instance (%d) in migration.\n", dmi_id ); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - if (mig_dmi->dmi_type != VTPM_TYPE_MIGRATABLE) { - vtpmlogerror(VTPM_LOG_VTPM, "Bad VTPM type (%d) in migration of instance (%d).\n", mig_dmi->dmi_type, dmi_id ); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** Find migration key for dest **/ - last_mig = NULL; - mig_key = vtpm_globals->mig_keys; - while (mig_key != NULL) { - if (mig_key->name_size == name_pack.size) - if (memcmp(mig_key->name, name_pack.data, name_pack.size) == 0) { - break; - } - - last_mig = mig_key; - mig_key = mig_key->next; - } - - if (!mig_key) { - vtpmlogerror(VTPM_LOG_VTPM, "Unknown Migration target host.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - /** Mark vtpm as migrated **/ - mig_dmi->dmi_type = VTPM_TYPE_MIGRATED; - - /** Build Blob **/ - TPMTRYRETURN( VTPM_Handle_Load_NVM(mig_dmi, NULL, &dmi_state) ); - - TPMTRYRETURN( buffer_init(&clear_dmi_blob, sizeof(TPM_DIGEST) + sizeof(UINT32) + buffer_len(&dmi_state), NULL ) ); - - struct pack_constbuf_t dmi_state_pack; - - dmi_state_pack.size = buffer_len(&dmi_state); - dmi_state_pack.data = dmi_state.bytes; - - BSG_PackList(clear_dmi_blob.bytes, 2, - BSG_TPM_DIGEST, &mig_dmi->DMI_measurement, - BSG_TPM_SIZE32_DATA, &dmi_state_pack); - - /** Bind Blob **/ - TPMTRYRETURN( envelope_encrypt( &clear_dmi_blob, - &mig_key->key, - result_buf) ); - - if (last_mig) - last_mig->next = mig_key->next; - else - vtpm_globals->mig_keys = mig_key->next; - - free(mig_key->name); - free(mig_key); - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Migration OUT of instance %d failed because of %s. Migratoin recovery may be needed.\n", dmi_id, tpm_get_error_name(status) ); - - //TODO: Create and implement a policy for what happens to mig_key on failed migrations. - - egress: - - buffer_free(&clear_dmi_blob); - buffer_free(&dmi_state); - - return status; -} - - -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - - vtpmloginfo(VTPM_LOG_VTPM, "Getting Migration Public Key.\n"); - - struct pack_buf_t pubkey_exp_pack, pubkey_mod_pack; - TPM_KEY mig_key; - - // Unpack/return key structure - BSG_Unpack(BSG_TPM_KEY, vtpm_globals->storageKeyWrap.bytes , &mig_key); - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - mig_key.algorithmParms.parms, - &rsaKeyParms); - - pubkey_exp_pack.size = rsaKeyParms.exponentSize; - pubkey_exp_pack.data = rsaKeyParms.exponent; - pubkey_mod_pack.size = mig_key.pubKey.keyLength; - pubkey_mod_pack.data = mig_key.pubKey.key; - - TPMTRYRETURN( buffer_init( result_buf, 2*sizeof(UINT32) + - pubkey_exp_pack.size + - pubkey_mod_pack.size, NULL ) ); - - BSG_PackList( result_buf->bytes, 2, - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); - - - status=TPM_SUCCESS; - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Get Migration Key failed because of %s.\n", tpm_get_error_name(status) ); - egress: - - return status; -} - -TPM_RESULT VTPM_Handle_Load_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf) { - - TPM_RESULT status=TPM_FAIL; - VTPM_MIGKEY_LIST *mig_key; - - vtpmloginfo(VTPM_LOG_VTPM, "Loading Migration Public Key.\n"); - - //FIXME: Review all uses of unpacking pack_buf_t and ensure free. - //FIXME: Review all declarations/initializations of buffer_t that could have a goto that skips them and then tries to free them - - struct pack_buf_t name_pack, pubkey_exp_pack, pubkey_mod_pack; - - //FIXME: scan list and verify name is not already in the list - - BSG_UnpackList( param_buf->bytes, 3, - BSG_TPM_SIZE32_DATA, &name_pack, - BSG_TPM_SIZE32_DATA, &pubkey_exp_pack, - BSG_TPM_SIZE32_DATA, &pubkey_mod_pack); - - //TODO: Maintain a persistent list for pub_keys. - //TODO: Verify pub_key is trusted - - mig_key = (VTPM_MIGKEY_LIST *) malloc(sizeof(VTPM_MIGKEY_LIST)); - memset(mig_key, 0, sizeof(VTPM_MIGKEY_LIST) ); - mig_key->name_size = name_pack.size; - mig_key->name = name_pack.data; - - mig_key->key.encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - Crypto_RSABuildCryptoInfoPublic( pubkey_exp_pack.size, - pubkey_exp_pack.data, - pubkey_mod_pack.size, - pubkey_mod_pack.data, - &mig_key->key); - - - mig_key->next = vtpm_globals->mig_keys; - vtpm_globals->mig_keys = mig_key; - - // free(name_pack.data); Do not free. data is now part of mig_key. - free(pubkey_exp_pack.data); - free(pubkey_mod_pack.data); - - return TPM_SUCCESS; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/securestorage.c --- a/tools/vtpm_manager/manager/securestorage.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,512 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// securestorage.c -// -// Functions regarding securely storing DMI secrets. -// -// ================================================================== - -#include -#include -#include -#include -#include - -#include "tcg.h" -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "crypto.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "buffer.h" -#include "log.h" - -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, - CRYPTO_INFO *asymkey, - buffer_t *sealed_data) { - TPM_RESULT status = TPM_SUCCESS; - symkey_t symkey; - buffer_t data_cipher = NULL_BUF, - symkey_cipher = NULL_BUF; - - UINT32 i; - struct pack_constbuf_t symkey_cipher32, data_cipher32; - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Input[%d]: 0x", buffer_len(inbuf)); - for (i=0; i< buffer_len(inbuf); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", inbuf->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - // Generate a sym key and encrypt state with it - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_genkey (&symkey) ); - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_symcrypto_encrypt (&symkey, inbuf, &data_cipher) ); - - // Encrypt symmetric key - TPMTRYRETURN( VTSP_Bind( asymkey, - &symkey.key, - &symkey_cipher) ); - - // Create output blob: symkey_size + symkey_cipher + state_cipher_size + state_cipher - - symkey_cipher32.size = buffer_len(&symkey_cipher); - symkey_cipher32.data = symkey_cipher.bytes; - - data_cipher32.size = buffer_len(&data_cipher); - data_cipher32.data = data_cipher.bytes; - - TPMTRYRETURN( buffer_init(sealed_data, 2 * sizeof(UINT32) + symkey_cipher32.size + data_cipher32.size, NULL)); - - BSG_PackList(sealed_data->bytes, 2, - BSG_TPM_SIZE32_DATA, &symkey_cipher32, - BSG_TPM_SIZE32_DATA, &data_cipher32); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved %d bytes of E(symkey) + %d bytes of E(data)\n", buffer_len(&symkey_cipher), buffer_len(&data_cipher)); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Enveloping Output[%d]: 0x", buffer_len(sealed_data)); - for (i=0; i< buffer_len(sealed_data); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", sealed_data->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope encrypt\n."); - - egress: - - buffer_free ( &data_cipher); - buffer_free ( &symkey_cipher); - Crypto_symcrypto_freekey (&symkey); - - return status; -} - -TPM_RESULT envelope_decrypt(const buffer_t *cipher, - TCS_CONTEXT_HANDLE TCSContext, - TPM_HANDLE keyHandle, - const TPM_AUTHDATA *key_usage_auth, - buffer_t *unsealed_data) { - - TPM_RESULT status = TPM_SUCCESS; - symkey_t symkey; - buffer_t data_cipher = NULL_BUF, - symkey_clear = NULL_BUF, - symkey_cipher = NULL_BUF; - struct pack_buf_t symkey_cipher32, data_cipher32; - int i; - - memset(&symkey, 0, sizeof(symkey_t)); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypt Input[%d]: 0x", buffer_len(cipher) ); - for (i=0; i< buffer_len(cipher); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", cipher->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - BSG_UnpackList(cipher->bytes, 2, - BSG_TPM_SIZE32_DATA, &symkey_cipher32, - BSG_TPM_SIZE32_DATA, &data_cipher32); - - TPMTRYRETURN( buffer_init_alias_convert (&symkey_cipher, - symkey_cipher32.size, - symkey_cipher32.data) ); - - TPMTRYRETURN( buffer_init_alias_convert (&data_cipher, - data_cipher32.size, - data_cipher32.data) ); - - // Decrypt Symmetric Key - TPMTRYRETURN( VTSP_Unbind( TCSContext, - keyHandle, - &symkey_cipher, - key_usage_auth, - &symkey_clear, - &(vtpm_globals->keyAuth) ) ); - - // create symmetric key using saved bits - Crypto_symcrypto_initkey (&symkey, &symkey_clear); - - // Decrypt State - TPMTRY(TPM_DECRYPT_ERROR, Crypto_symcrypto_decrypt (&symkey, &data_cipher, unsealed_data) ); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Envelope Decrypte Output[%d]: 0x", buffer_len(unsealed_data)); - for (i=0; i< buffer_len(unsealed_data); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", unsealed_data->bytes[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to envelope decrypt data\n."); - - egress: - buffer_free ( &data_cipher); - buffer_free ( &symkey_clear); - buffer_free ( &symkey_cipher); - Crypto_symcrypto_freekey (&symkey); - - return status; -} - -TPM_RESULT VTPM_Handle_Save_NVM(VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - int fh; - long bytes_written; - buffer_t sealed_NVM = NULL_BUF; - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Saving %d bytes of NVM.\n", buffer_len(inbuf)); - - TPMTRYRETURN( envelope_encrypt(inbuf, - &vtpm_globals->storageKey, - &sealed_NVM) ); - - // Write sealed blob off disk from NVMLocation - // TODO: How to properly return from these. Do we care if we return failure - // after writing the file? We can't get the old one back. - // TODO: Backup old file and try and recover that way. - fh = open(myDMI->NVMLocation, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE); - if ( (bytes_written = write(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM) ) != (long) buffer_len(&sealed_NVM))) { - vtpmlogerror(VTPM_LOG_VTPM, "We just overwrote a DMI_NVM and failed to finish. %ld/%ld bytes.\n", bytes_written, (long)buffer_len(&sealed_NVM)); - status = TPM_IOERROR; - goto abort_egress; - } - close(fh); - - Crypto_SHA1Full (sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &myDMI->NVM_measurement); - - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to save NVM\n."); - - egress: - buffer_free(&sealed_NVM); - return status; -} - - -/* Expected Params: inbuf = null, outbuf = sealed blob size, sealed blob.*/ -TPM_RESULT VTPM_Handle_Load_NVM(VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - - buffer_t sealed_NVM = NULL_BUF; - long fh_size; - int fh, stat_ret, i; - struct stat file_stat; - TPM_DIGEST sealedNVMHash; - - if (myDMI->NVMLocation == NULL) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to load NVM because the file name NULL.\n"); - status = TPM_AUTHFAIL; - goto abort_egress; - } - - //Read sealed blob off disk from NVMLocation - fh = open(myDMI->NVMLocation, O_RDONLY); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - fh_size = file_stat.st_size; - else { - status = TPM_IOERROR; - goto abort_egress; - } - - TPMTRYRETURN( buffer_init( &sealed_NVM, fh_size, NULL) ); - if (read(fh, sealed_NVM.bytes, buffer_len(&sealed_NVM)) != fh_size) { - status = TPM_IOERROR; - goto abort_egress; - } - close(fh); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Load_NVMing[%d],\n", buffer_len(&sealed_NVM)); - - Crypto_SHA1Full(sealed_NVM.bytes, buffer_len(&sealed_NVM), (BYTE *) &sealedNVMHash); - - // Verify measurement of sealed blob. - if (memcmp(&sealedNVMHash, &myDMI->NVM_measurement, sizeof(TPM_DIGEST)) ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM LoadNVM NVM measurement check failed.\n"); - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Correct hash: "); - for (i=0; i< sizeof(TPM_DIGEST); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&myDMI->NVM_measurement)[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - vtpmloginfo(VTPM_LOG_VTPM_DEEP, "Measured hash: "); - for (i=0; i< sizeof(TPM_DIGEST); i++) - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", ((BYTE*)&sealedNVMHash)[i]); - vtpmloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - - status = TPM_AUTHFAIL; - goto abort_egress; - } - - TPMTRYRETURN( envelope_decrypt(&sealed_NVM, - myDMI->TCSContext, - vtpm_globals->storageKeyHandle, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - outbuf) ); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load NVM\n."); - - egress: - buffer_free( &sealed_NVM ); - - return status; -} - - -TPM_RESULT VTPM_SaveManagerData(void) { - TPM_RESULT status=TPM_SUCCESS; - int fh, dmis=-1; - - BYTE *flat_boot_key=NULL, *flat_dmis=NULL, *flat_enc=NULL; - buffer_t clear_flat_global=NULL_BUF, enc_flat_global=NULL_BUF; - UINT32 storageKeySize = buffer_len(&vtpm_globals->storageKeyWrap); - UINT32 bootKeySize = buffer_len(&vtpm_globals->bootKeyWrap); - struct pack_buf_t storage_key_pack = {storageKeySize, vtpm_globals->storageKeyWrap.bytes}; - struct pack_buf_t boot_key_pack = {bootKeySize, vtpm_globals->bootKeyWrap.bytes}; - BYTE vtpm_manager_gen = VTPM_MANAGER_GEN; - - struct hashtable_itr *dmi_itr; - VTPM_DMI_RESOURCE *dmi_res; - - UINT32 boot_key_size = 0, flat_dmis_size = 0; - - // Initially fill these with buffer sizes for each data type. Later fill - // in actual size, once flattened. - boot_key_size = sizeof(UINT32) + // bootkeysize - bootKeySize; // boot key - - TPMTRYRETURN(buffer_init(&clear_flat_global,sizeof(BYTE) + // manager version - 3*sizeof(TPM_DIGEST) + // Auths - sizeof(UINT32) +// storagekeysize - storageKeySize, NULL) ); // storage key - - - flat_boot_key = (BYTE *) malloc( boot_key_size ); - flat_enc = (BYTE *) malloc( sizeof(UINT32) ); - - boot_key_size = BSG_PackList(flat_boot_key, 1, - BSG_TPM_SIZE32_DATA, &boot_key_pack); - - BSG_PackList(clear_flat_global.bytes, 4, - BSG_TYPE_BYTE, &vtpm_manager_gen, - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, - BSG_TPM_SIZE32_DATA, &storage_key_pack); - - TPMTRYRETURN(envelope_encrypt(&clear_flat_global, - &vtpm_globals->bootKey, - &enc_flat_global) ); - - BSG_PackConst(buffer_len(&enc_flat_global), 4, flat_enc); - - // Per DMI values to be saved (if any exit) - if (hashtable_count(vtpm_globals->dmi_map) > 1) { - - flat_dmis = (BYTE *) malloc( - (hashtable_count(vtpm_globals->dmi_map) - 1) * // num DMIS (-1 for Dom0) - (sizeof(UINT32) +sizeof(BYTE) + 2*sizeof(TPM_DIGEST)) ); // Per DMI info - - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); - do { - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); - dmis++; - - // No need to save dmi0. - if (dmi_res->dmi_id == 0) - continue; - - - flat_dmis_size += BSG_PackList( flat_dmis + flat_dmis_size, 4, - BSG_TYPE_UINT32, &dmi_res->dmi_id, - BSG_TYPE_BYTE, &dmi_res->dmi_type, - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); - - } while (hashtable_iterator_advance(dmi_itr)); - } - - fh = open(STATE_FILE, O_WRONLY | O_CREAT, S_IREAD | S_IWRITE); - if (fh == -1) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to open %s file for write.\n", STATE_FILE); - status = TPM_IOERROR; - goto abort_egress; - } - - if ( ( write(fh, flat_boot_key, boot_key_size) != boot_key_size ) || - ( write(fh, flat_enc, sizeof(UINT32)) != sizeof(UINT32) ) || - ( write(fh, enc_flat_global.bytes, buffer_len(&enc_flat_global)) != buffer_len(&enc_flat_global) ) || - ( write(fh, flat_dmis, flat_dmis_size) != flat_dmis_size ) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to completely write service data.\n"); - status = TPM_IOERROR; - goto abort_egress; - } - - goto egress; - - abort_egress: - egress: - - free(flat_boot_key); - free(flat_enc); - buffer_free(&enc_flat_global); - free(flat_dmis); - close(fh); - - vtpmloginfo(VTPM_LOG_VTPM, "Saved VTPM Manager state (status = %d, dmis = %d)\n", (int) status, dmis); - return status; -} - -TPM_RESULT VTPM_LoadManagerData(void) { - - TPM_RESULT status=TPM_SUCCESS; - int fh, stat_ret, dmis=0; - long fh_size = 0, step_size; - BYTE *flat_table=NULL; - buffer_t unsealed_data, enc_table_abuf; - struct pack_buf_t storage_key_pack, boot_key_pack; - UINT32 *dmi_id_key, enc_size; - BYTE vtpm_manager_gen; - - VTPM_DMI_RESOURCE *dmi_res; - UINT32 dmi_id; - BYTE dmi_type; - struct stat file_stat; - - TPM_HANDLE boot_key_handle; - TPM_AUTHDATA boot_usage_auth; - memset(&boot_usage_auth, 0, sizeof(TPM_AUTHDATA)); - - fh = open(STATE_FILE, O_RDONLY ); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - fh_size = file_stat.st_size; - else { - status = TPM_IOERROR; - goto abort_egress; - } - - flat_table = (BYTE *) malloc(fh_size); - - if ((long) read(fh, flat_table, fh_size) != fh_size ) { - status = TPM_IOERROR; - goto abort_egress; - } - - // Read Boot Key - step_size = BSG_UnpackList( flat_table, 2, - BSG_TPM_SIZE32_DATA, &boot_key_pack, - BSG_TYPE_UINT32, &enc_size); - - TPMTRYRETURN(buffer_init(&vtpm_globals->bootKeyWrap, 0, 0) ); - TPMTRYRETURN(buffer_init_alias_convert(&enc_table_abuf, enc_size, flat_table + step_size) ); - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->bootKeyWrap, boot_key_pack.size, boot_key_pack.data) ); - - //Load Boot Key - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->bootKeyWrap, - &SRK_AUTH, - &boot_key_handle, - &vtpm_globals->keyAuth, - &vtpm_globals->bootKey, - FALSE) ); - - TPMTRYRETURN( envelope_decrypt(&enc_table_abuf, - vtpm_globals->manager_tcs_handle, - boot_key_handle, - (const TPM_AUTHDATA*) &boot_usage_auth, - &unsealed_data) ); - step_size += enc_size; - - if (*unsealed_data.bytes != VTPM_MANAGER_GEN) { - // Once there is more than one gen, this will include some compatability stuff - vtpmlogerror(VTPM_LOG_VTPM, "Warning: Manager Data file is gen %d, which this manager is gen %d.\n", vtpm_manager_gen, VTPM_MANAGER_GEN); - } - - // Global Values needing to be saved - BSG_UnpackList( unsealed_data.bytes, 4, - BSG_TYPE_BYTE, &vtpm_manager_gen, - BSG_TPM_AUTHDATA, &vtpm_globals->owner_usage_auth, - BSG_TPM_SECRET, &vtpm_globals->storage_key_usage_auth, - BSG_TPM_SIZE32_DATA, &storage_key_pack); - - TPMTRYRETURN(buffer_init(&vtpm_globals->storageKeyWrap, 0, 0) ); - TPMTRYRETURN(buffer_append_raw(&vtpm_globals->storageKeyWrap, storage_key_pack.size, storage_key_pack.data) ); - - // Per DMI values to be saved - while ( step_size < fh_size ){ - if (fh_size - step_size < (long) (sizeof(UINT32) + sizeof(BYTE) + 2*sizeof(TPM_DIGEST))) { - vtpmlogerror(VTPM_LOG_VTPM, "Encountered %ld extra bytes at end of manager state.\n", fh_size-step_size); - step_size = fh_size; - } else { - step_size += BSG_UnpackList(flat_table + step_size, 2, - BSG_TYPE_UINT32, &dmi_id, - BSG_TYPE_BYTE, &dmi_type); - - //TODO: Try and gracefully recover from problems. - TPMTRYRETURN(init_dmi(dmi_id, dmi_type, &dmi_res) ); - dmis++; - - step_size += BSG_UnpackList(flat_table + step_size, 2, - BSG_TPM_DIGEST, &dmi_res->NVM_measurement, - BSG_TPM_DIGEST, &dmi_res->DMI_measurement); - } - - } - - vtpmloginfo(VTPM_LOG_VTPM, "Loaded saved state (dmis = %d).\n", dmis); - goto egress; - - abort_egress: - vtpmlogerror(VTPM_LOG_VTPM, "Failed to load service data with error = %s\n", tpm_get_error_name(status)); - egress: - - free(flat_table); - close(fh); - - // TODO: Could be nice and evict BootKey. (Need to add EvictKey to VTSP. - - return status; -} - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/tpmpassthrough.c --- a/tools/vtpm_manager/manager/tpmpassthrough.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,110 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// tpmpassthrough.c -// -// Functions regarding passing DMI requests to HWTPM -// -// ================================================================== - -#include "tcg.h" -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "log.h" - -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, - buffer_t *inbuf, - buffer_t *outbuf) { - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE *ord; - - ord = (TPM_COMMAND_CODE *) (inbuf->bytes + sizeof(TPM_TAG) + sizeof(UINT32)); - - switch (*ord) { - - // Forbidden for DMI use - case TPM_ORD_TakeOwnership: - case TPM_ORD_ChangeAuthOwner: - case TPM_ORD_DirWriteAuth: - case TPM_ORD_DirRead: - case TPM_ORD_AuthorizeMigrationKey: - case TPM_ORD_CreateMaintenanceArchive: - case TPM_ORD_LoadMaintenanceArchive: - case TPM_ORD_KillMaintenanceFeature: - case TPM_ORD_LoadManuMaintPub: - case TPM_ORD_ReadManuMaintPub: - case TPM_ORD_SelfTestFull: - case TPM_ORD_SelfTestStartup: - case TPM_ORD_CertifySelfTest: - case TPM_ORD_ContinueSelfTest: - case TPM_ORD_GetTestResult: - case TPM_ORD_Reset: - case TPM_ORD_OwnerClear: - case TPM_ORD_DisableOwnerClear: - case TPM_ORD_ForceClear: - case TPM_ORD_DisableForceClear: - case TPM_ORD_GetCapabilityOwner: - case TPM_ORD_OwnerSetDisable: - case TPM_ORD_PhysicalEnable: - case TPM_ORD_PhysicalDisable: - case TPM_ORD_SetOwnerInstall: - case TPM_ORD_PhysicalSetDeactivated: - case TPM_ORD_SetTempDeactivated: - case TPM_ORD_CreateEndorsementKeyPair: - case TPM_ORD_GetAuditEvent: - case TPM_ORD_GetAuditEventSigned: - case TPM_ORD_GetOrdinalAuditStatus: - case TPM_ORD_SetOrdinalAuditStatus: - case TPM_ORD_SetRedirection: - case TPM_ORD_FieldUpgrade: - case TSC_ORD_PhysicalPresence: - status = TPM_DISABLED_CMD; - goto abort_egress; - break; - - } // End ORD Switch - - // Call TCS with command - - TPMTRY(TPM_IOERROR, VTSP_RawTransmit( dmi->TCSContext,inbuf, outbuf) ); - - goto egress; - - abort_egress: - vtpmloginfo(VTPM_LOG_VTPM, "TPM Command Failed in tpmpassthrough.\n"); - egress: - - return status; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_ipc.c --- a/tools/vtpm_manager/manager/vtpm_ipc.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,141 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_ipc.c Implements ipc routines using file io. This file can -// be replaced with other ipc types. -// -// =================================================================== - -#include -#include "vtpm_ipc.h" -#include "vtpmpriv.h" -#include "log.h" - -int vtpm_ipc_init(vtpm_ipc_handle_t *ipc_h, char* name, int flags, BOOL create) { - ipc_h->name = name; - ipc_h->flags = flags; - ipc_h->fh = VTPM_IPC_CLOSED; - - if (create) - return(vtpm_ipc_create(ipc_h)); - else - return 0; -} - -// Create the file that needs opening. Used only for FIFOs -// FYI: This may cause problems in other file IO schemes. We'll see. -int vtpm_ipc_create(vtpm_ipc_handle_t *ipc_h) { - int fh; - struct stat file_info; - - if ((!ipc_h) || (!ipc_h->name)) - return -1; - - if ( stat(ipc_h->name, &file_info) == -1) { - if ( mkfifo(ipc_h->name, S_IWUSR | S_IRUSR ) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to create fifo %s.\n", ipc_h->name); - return -1; - } - } - - ipc_h->fh = VTPM_IPC_CLOSED; - - return 0; -} - - -// Read size bytes. If FH isn't open, open it. -int vtpm_ipc_read(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size){ - vtpm_ipc_handle_t *my_ipc_h; - int result; - - if (ipc_h) { - my_ipc_h = ipc_h; - } else { - my_ipc_h = alt_ipc_h; - } - - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); - } - - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for reading.\n", my_ipc_h->name); - return -1; - } - - result = read(my_ipc_h->fh, bytes, size); - if (result < 0) { - my_ipc_h->fh = VTPM_IPC_CLOSED; - } - - return (result); -} - -// Write size bytes. If FH isn't open, open it. -int vtpm_ipc_write(vtpm_ipc_handle_t *ipc_h, vtpm_ipc_handle_t *alt_ipc_h, BYTE *bytes, UINT32 size) { - vtpm_ipc_handle_t *my_ipc_h; - int result; - - if (ipc_h) { - my_ipc_h = ipc_h; - } else { - my_ipc_h = alt_ipc_h; - } - - if (my_ipc_h->fh == VTPM_IPC_CLOSED) { - my_ipc_h->fh = open(my_ipc_h->name, my_ipc_h->flags); - } - - if ( my_ipc_h->fh == VTPM_IPC_CLOSED ) { - vtpmlogerror(VTPM_LOG_VTPM, "VTPM ERROR: Can't open %s for writing.\n", my_ipc_h->name); - return -1; - } - - result = write(my_ipc_h->fh, bytes, size); - if (result < 0) { - my_ipc_h->fh = VTPM_IPC_CLOSED; - } - - return (result); -} - -// Mark file as closed and try and close it. Errors not reported. -void vtpm_ipc_close(vtpm_ipc_handle_t *ipc_h) { - - if (ipc_h) { - close(ipc_h->fh); - ipc_h->fh = VTPM_IPC_CLOSED; - } - -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_ipc.h --- a/tools/vtpm_manager/manager/vtpm_ipc.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,71 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_ipc.h Header for interprocess communication between VTPM manager -// and Guests or VTPMs -// -// =================================================================== - -#ifndef __VTPM_IO_H__ -#define __VTPM_IO_H__ - -#include "tcg.h" - -#define VTPM_IPC_CLOSED -1 - -// Represents an (somewhat) abstracted io handle. -typedef struct vtpm_ipc_handle_t { - int fh; // IO handle. - int flags; // Flags for opening. This may need to become - // a void *, but for now files use an int. - char *name; // Names for debugging as well as filenames - // for file-based io. -} vtpm_ipc_handle_t; - - -int vtpm_ipc_init(vtpm_ipc_handle_t *ioh, char* name, int flags, BOOL create); - -// Create the file that needs opening. Used only for FIFOs -// FYI: This may cause problems in other file IO schemes. We'll see. -int vtpm_ipc_create(vtpm_ipc_handle_t *ioh); - -// Read size bytes. If FH isn't open, open it. -int vtpm_ipc_read(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); - -// Write size bytes. If FH isn't open, open it. -int vtpm_ipc_write(vtpm_ipc_handle_t *ioh, vtpm_ipc_handle_t *alt_ioh, BYTE *bytes, UINT32 size); - -// Mark file as closed and try and close it. Errors not reported. -void vtpm_ipc_close(vtpm_ipc_handle_t *ioh); - -#endif diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_lock.c --- a/tools/vtpm_manager/manager/vtpm_lock.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,63 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_lock.c Provided controlled sync around access to vtpm structures -// -// =================================================================== - -#include -#include "vtpm_lock.h" - -static pthread_rwlock_t vtpm_lock; - -void vtpm_lock_init() { - - pthread_rwlock_init( &vtpm_lock, NULL); -} - -void vtpm_lock_destroy(){ - pthread_rwlock_destroy(&vtpm_lock); -} - -void vtpm_lock_rdlock(){ - pthread_rwlock_rdlock(&vtpm_lock); -} - -void vtpm_lock_wrlock(){ - pthread_rwlock_wrlock(&vtpm_lock); -} - -void vtpm_lock_unlock(){ - pthread_rwlock_unlock(&vtpm_lock); -} - diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_lock.h --- a/tools/vtpm_manager/manager/vtpm_lock.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,48 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_lock.h Provided controlled sync around access to vtpm structures -// -// =================================================================== - -#ifndef __VTPM_LOCK_H__ -#define __VTPM_LOCK_H__ - -void vtpm_lock_init(); -void vtpm_lock_destroy(); - -void vtpm_lock_rdlock(); -void vtpm_lock_wrlock(); -void vtpm_lock_unlock(); - -#endif diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_manager.c --- a/tools/vtpm_manager/manager/vtpm_manager.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,285 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager.c -// -// This file will house the main logic of the VTPM Manager -// -// ================================================================== - -#include -#include -#include - -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "hashtable.h" -#include "hashtable_itr.h" - -#include "log.h" -#include "buffer.h" - -VTPM_GLOBALS *vtpm_globals=NULL; - -// --------------------------- Well Known Auths -------------------------- -const TPM_AUTHDATA SRK_AUTH = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; - -#ifdef WELL_KNOWN_OWNER_AUTH -static BYTE FIXED_OWNER_AUTH[20] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, - 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; -#endif - - -// -------------------------- Hash table functions -------------------- - -static unsigned int hashfunc32(void *ky) { - return (* (UINT32 *) ky); -} - -static int equals32(void *k1, void *k2) { - return (*(UINT32 *) k1 == *(UINT32 *) k2); -} - -// --------------------------- Functions ------------------------------ - -TPM_RESULT VTPM_Create_Manager(){ - - TPM_RESULT status = TPM_SUCCESS; - - // Generate Auth for Owner -#ifdef WELL_KNOWN_OWNER_AUTH - memcpy(vtpm_globals->owner_usage_auth, FIXED_OWNER_AUTH, sizeof(TPM_AUTHDATA)); -#else - Crypto_GetRandom(vtpm_globals->owner_usage_auth, sizeof(TPM_AUTHDATA) ); -#endif - - // Take Owership of TPM - CRYPTO_INFO ek_cryptoInfo; - - status = VTSP_ReadPubek(vtpm_globals->manager_tcs_handle, &ek_cryptoInfo); - - // If we can read PubEK then there is no owner and we should take it. - // We use the abilty to read the pubEK to flag that the TPM is owned. - // FIXME: Change to just trying to take ownership and react to the status - if (status == TPM_SUCCESS) { - TPMTRYRETURN(VTSP_TakeOwnership(vtpm_globals->manager_tcs_handle, - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, - &SRK_AUTH, - &ek_cryptoInfo, - &vtpm_globals->keyAuth)); - - TPMTRYRETURN(VTSP_DisablePubekRead(vtpm_globals->manager_tcs_handle, - (const TPM_AUTHDATA*)&vtpm_globals->owner_usage_auth, - &vtpm_globals->keyAuth)); - } else { - vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); - } - - // Generate storage key's auth - Crypto_GetRandom( &vtpm_globals->storage_key_usage_auth, - sizeof(TPM_AUTHDATA) ); - - TCS_AUTH osap; - TPM_AUTHDATA sharedsecret; - - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, - TPM_ET_KEYHANDLE, - TPM_SRK_KEYHANDLE, - &SRK_AUTH, - &sharedsecret, - &osap) ); - - osap.fContinueAuthSession = FALSE; - - - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, - TPM_KEY_BIND, - (const TPM_AUTHDATA*)&vtpm_globals->storage_key_usage_auth, - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - &vtpm_globals->storageKeyWrap, - &osap) ); - - // Generate boot key's auth - TPM_AUTHDATA bootKeyWrapAuth; - memset(&bootKeyWrapAuth, 0, sizeof(bootKeyWrapAuth)); - - TPMTRYRETURN( VTSP_OSAP(vtpm_globals->manager_tcs_handle, - TPM_ET_KEYHANDLE, - TPM_SRK_KEYHANDLE, - &SRK_AUTH, - &sharedsecret, - &osap) ); - - osap.fContinueAuthSession = FALSE; - - // FIXME: This key protects the global secrets on disk. It should use TPM - // PCR bindings to limit its use to legit configurations. - // Current binds are open, implying a Trusted VM contains this code. - // If this VM is not Trusted, use measurement and PCR bindings. - TPMTRYRETURN( VTSP_CreateWrapKey( vtpm_globals->manager_tcs_handle, - TPM_KEY_BIND, - (const TPM_AUTHDATA*)&bootKeyWrapAuth, - TPM_SRK_KEYHANDLE, - (const TPM_AUTHDATA*)&sharedsecret, - &vtpm_globals->bootKeyWrap, - &osap) ); - - // Populate CRYPTO_INFO vtpm_globals->bootKey. This does not load it into the TPM - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->bootKeyWrap, - NULL, - NULL, - NULL, - &vtpm_globals->bootKey, - TRUE ) ); - - TPMTRYRETURN( VTSP_SaveState(vtpm_globals->manager_tcs_handle) ); - goto egress; - - abort_egress: - exit(1); - - egress: - vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager (Status = %d).\n", status); - return status; - -} - -/////////////////////////////////////////////////////////////////////////////// -TPM_RESULT VTPM_Init_Manager() { - TPM_RESULT status = TPM_FAIL, serviceStatus; - BYTE *randomsead; - UINT32 randomsize=256; - - if ((vtpm_globals = (VTPM_GLOBALS *) malloc(sizeof(VTPM_GLOBALS))) == NULL){ - status = TPM_FAIL; - goto abort_egress; - } - memset(vtpm_globals, 0, sizeof(VTPM_GLOBALS)); - - vtpm_globals->connected_dmis = 0; - - if ((vtpm_globals->dmi_map = create_hashtable(10, hashfunc32, equals32)) == NULL){ - status = TPM_FAIL; - goto abort_egress; - } - - // Create new TCS Object - vtpm_globals->manager_tcs_handle = 0; - - TPMTRYRETURN(TCS_create()); - - // Create TCS Context for service - TPMTRYRETURN( TCS_OpenContext(&vtpm_globals->manager_tcs_handle ) ); - - TPMTRYRETURN( TCSP_GetRandom(vtpm_globals->manager_tcs_handle, - &randomsize, - &randomsead)); - - Crypto_Init(randomsead, randomsize); - TPMTRYRETURN( TCS_FreeMemory (vtpm_globals->manager_tcs_handle, randomsead)); - - // Create OIAP session for service's authorized commands - TPMTRYRETURN( VTSP_OIAP( vtpm_globals->manager_tcs_handle, - &vtpm_globals->keyAuth) ); - vtpm_globals->keyAuth.fContinueAuthSession = TRUE; - - vtpm_globals->mig_keys = NULL; - - // If fails, create new Manager. - serviceStatus = VTPM_LoadManagerData(); - if (serviceStatus == TPM_IOERROR) { - vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); - TPMTRYRETURN( VTPM_Create_Manager() ); - TPMTRYRETURN( VTPM_SaveManagerData() ); - } else if (serviceStatus != TPM_SUCCESS) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to read existing manager file"); - exit(1); - } - - //Load Storage Key - TPMTRYRETURN( VTSP_LoadKey( vtpm_globals->manager_tcs_handle, - TPM_SRK_KEYHANDLE, - &vtpm_globals->storageKeyWrap, - &SRK_AUTH, - &vtpm_globals->storageKeyHandle, - &vtpm_globals->keyAuth, - &vtpm_globals->storageKey, - FALSE ) ); - - // Create entry for Dom0 for control messages - TPMTRYRETURN( VTPM_Handle_New_DMI(NULL) ); - - goto egress; - - abort_egress: - egress: - - return(status); -} - -/////////////////////////////////////////////////////////////////////////////// -void VTPM_Stop_Manager() { - VTPM_DMI_RESOURCE *dmi_res; - struct hashtable_itr *dmi_itr; - - // Close all the TCS contexts. TCS should evict keys based on this - if (hashtable_count(vtpm_globals->dmi_map) > 0) { - dmi_itr = hashtable_iterator(vtpm_globals->dmi_map); - do { - dmi_res = (VTPM_DMI_RESOURCE *) hashtable_iterator_value(dmi_itr); - if (dmi_res->connected) - close_dmi( dmi_res ); // Not really interested in return code - - } while (hashtable_iterator_advance(dmi_itr)); - free (dmi_itr); - } - - if ( VTPM_SaveManagerData() != TPM_SUCCESS ) - vtpmlogerror(VTPM_LOG_VTPM, "Unable to save manager data.\n"); - - TCS_CloseContext(vtpm_globals->manager_tcs_handle); - TCS_destroy(); - - hashtable_destroy(vtpm_globals->dmi_map, 1); - free(vtpm_globals); - - Crypto_Exit(); - - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_manager.h --- a/tools/vtpm_manager/manager/vtpm_manager.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,150 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager.h -// -// Public Interface header for VTPM Manager -// -// ================================================================== - -#ifndef __VTPM_MANAGER_H__ -#define __VTPM_MANAGER_H__ - -#define VTPM_TAG_REQ 0x01c1 -#define VTPM_TAG_RSP 0x01c4 -#define COMMAND_BUFFER_SIZE 4096 - -// Header sizes. Note Header MAY include the DMI -#define VTPM_COMMAND_HEADER_SIZE_CLT ( 2 + 4 + 4) -// sizeof(TPM_TAG + UINT32 + TPM_COMMAND_CODE) -#define VTPM_COMMAND_HEADER_SIZE_SRV ( 4 + VTPM_COMMAND_HEADER_SIZE_CLT ) -// sizeof( UINT32 + VTPM_COMMAND_HEADER_SIZE_CLT) - -//************************ 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) - -// Non-priviledged VTPM Commands (From DMI's) -#define VTPM_ORD_SAVENVM (VTPM_ORD_BASE + 1) // DMI Saves Secrets -#define VTPM_ORD_LOADNVM (VTPM_ORD_BASE + 2) // DMI Loads Secrets -#define VTPM_ORD_TPMCOMMAND (VTPM_ORD_BASE + 3) // DMI issues HW TPM Command -#define VTPM_ORD_GET_MIG_KEY (VTPM_ORD_BASE + 4) // Get manager's migration key -#define VTPM_ORD_LOAD_MIG_KEY (VTPM_ORD_BASE + 5) // load dest migration key - -// Priviledged VTPM Commands (From management console) -#define VTPM_ORD_OPEN (VTPM_PRIV_BASE + 1) // Creates/reopens DMI -#define VTPM_ORD_CLOSE (VTPM_PRIV_BASE + 2) // Closes a DMI -#define VTPM_ORD_DELETE (VTPM_PRIV_BASE + 3) // Permemently Deletes DMI -#define VTPM_ORD_MIGRATE_IN (VTPM_PRIV_BASE + 4) // Load migrated VTPM -#define VTPM_ORD_MIGRATE_OUT (VTPM_PRIV_BASE + 5) // migrate VTPM to dest - -//************************ Return Codes **************************** -#define VTPM_TYPE_PVM 1 // Paravirtualized Domain -#define VTPM_TYPE_HVM 2 // HVM Domain - -//************************ Return Codes **************************** -#define VTPM_SUCCESS 0 -#define VTPM_FAIL 1 -#define VTPM_UNSUPPORTED 2 -#define VTPM_FORBIDDEN 3 -#define VTPM_RESTORE_CONTEXT_FAILED 4 -#define VTPM_INVALID_REQUEST 5 - -//*********************** Parameter Values ************************* -#define VTPM_TYPE_NON_MIGRATABLE 0x00 -#define VTPM_TYPE_MIGRATABLE 0x01 -#define VTPM_TYPE_MIGRATED 0xFF // VTPM has been migrated. - // VTPM can be recovered or deleted only - -/******************* Command Parameter API ************************* - -VTPM Command Format - dmi: 4 bytes // Source of message. - // WARNING: This is prepended by the channel. - // Thus it is received by VTPM Manager, - // but not sent by DMI - tpm tag: 2 bytes - command size: 4 bytes // Size of command including header but not DMI - ord: 4 bytes // Command ordinal above - parameters: size - 10 bytes // Command Parameter - -VTPM Response Format - tpm tag: 2 bytes - response_size: 4 bytes - status: 4 bytes - parameters: size - 10 bytes - - -VTPM_Open: - Input Parameters: - mig_type: 1 byte - startup_mode: 1 byte // Cold Boot = 1, resume = 2, deactive = 3 - domain type: 1 byte - instance_id: 4 bytes - Output Parameters: - None - -VTPM_Close - Input Parameters: - instance_id: 4 bytes - Output Parameters: - None - -VTPM_Delete - Input Parameters: - instance_id: 4 bytes - Output Parameters: - None - -VTPM_SaveNVM - Input Parameters: - data: n bytes (Header indicates size of data) - Output Parameters: - None - -VTPM_LoadNVM - Input Parameters: - None - Output Parameters: - data: n bytes (Header indicates size of data) - -VTPM_TPMCommand - Input Parameters: - TPM Command Byte Stream: n bytes - Output Parameters: - TPM Reponse Byte Stream: n bytes - -*********************************************************************/ - -#endif //_VTPM_MANAGER_H_ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpm_manager_handler.c --- a/tools/vtpm_manager/manager/vtpm_manager_handler.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,488 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpm_manager_handler.c -// -// This file will house the main logic of the VTPM Manager -// -// ================================================================== - -#include -#include -#include -#include - -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "vtsp.h" -#include "bsg.h" -#include "hashtable.h" -#include "hashtable_itr.h" -#include "log.h" -#include "buffer.h" - -#define vtpmhandlerloginfo(module,fmt,args...) vtpmloginfo (module, "[%s]: " fmt, thread_name, ##args ); -#define vtpmhandlerloginfomore(module,fmt,args...) vtpmloginfomore (module, fmt, ##args ); -#define vtpmhandlerlogerror(module,fmt,args...) vtpmlogerror (module, "[%s]: " fmt, thread_name, ##args ); - -// ---------------------- Prototypes ------------------- -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, - TPM_COMMAND_CODE ord, - buffer_t *command_buf, - buffer_t *result_buf, - BOOL is_priv, - char *thread_name); - -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - VTPM_DMI_RESOURCE *dmi_res, - BYTE *cmd_header, - buffer_t *param_buf, - buffer_t *result_buf, - char *thread_name); - -TPM_RESULT VTPM_Manager_Handler( vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - BOOL fw_tpm, // Forward TPM cmds? - vtpm_ipc_handle_t *fw_tx_ipc_h, - vtpm_ipc_handle_t *fw_rx_ipc_h, - BOOL is_priv, - char *thread_name) { - TPM_RESULT status = TPM_FAIL; // Should never return - UINT32 dmi, in_param_size, cmd_size, out_param_size, out_message_size, reply_size; - BYTE *cmd_header=NULL, *in_param=NULL, *out_message=NULL, *reply; - buffer_t *command_buf=NULL, *result_buf=NULL; - TPM_TAG tag; - TPM_COMMAND_CODE ord; - VTPM_DMI_RESOURCE *dmi_res; - int size_read, size_write, i; - BOOL add_header=TRUE; // This indicates to prepend a header on result_buf before sending - - cmd_header = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV); - command_buf = (buffer_t *) malloc(sizeof(buffer_t)); - result_buf = (buffer_t *) malloc(sizeof(buffer_t)); - - // ------------------------ Main Loop -------------------------------- - while(1) { - - vtpmhandlerloginfo(VTPM_LOG_VTPM, "%s waiting for messages.\n", thread_name); - - // --------------------- Read Cmd from Sender ---------------- - - // Read command header - size_read = vtpm_ipc_read(rx_ipc_h, NULL, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - if (size_read > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV[%d]: 0x", size_read); - for (i=0; i 0) { - in_param = (BYTE *) malloc(cmd_size); - size_read = vtpm_ipc_read( rx_ipc_h, NULL, in_param, cmd_size); - if (size_read > 0) { - for (i=0; idmi_map, &dmi)) || - (!dmi_res->connected) ) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempted access to non-existent or disconnected DMI %d. Aborting...\n", dmi); - status = TPM_BAD_PARAMETER; - // We have no one to reply to, they don't exist. - goto abort_command; - } - - if (tag == VTPM_TAG_REQ) { - - status = vtpm_manager_handle_vtpm_cmd(dmi_res, ord, command_buf, result_buf, is_priv, thread_name); - - } else { // This is not a VTPM Command at all. - if (fw_tpm) { - status = vtpm_manager_handle_tpm_cmd(fw_tx_ipc_h, fw_rx_ipc_h, dmi_res, cmd_header, command_buf, result_buf, thread_name); - - // This means calling the DMI failed, not that the cmd failed in the DMI - // Since the return will be interpretted by a TPM app, all errors are IO_ERRORs to the app - if (status != TPM_SUCCESS) { - status = TPM_IOERROR; - goto abort_with_error; - } - // Unlike all other commands, forwarded commands yield a result_buf that includes the DMI's status. This - // should be forwarded to the caller VM - add_header = FALSE; - } else { - // We are not supposed to forward TPM commands at all. - int i; - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Attempt to use unsupported direct access to TPM.\n"); - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "Bad Command. dmi:%d, tag:%d, size:%d, ord:%d, Params: ", dmi, tag, in_param_size, ord); - for (i=0; i 0) - memcpy(out_message + VTPM_COMMAND_HEADER_SIZE_SRV, result_buf->bytes, out_param_size); - //Note: Send message + dmi_id - } else { - reply = result_buf->bytes; - reply_size = buffer_len(result_buf); - } - size_write = vtpm_ipc_write(tx_ipc_h, (dmi_res ? dmi_res->tx_vtpm_ipc_h : NULL), reply, reply_size ); - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT: 0x"); - for (i=0; i < reply_size; i++) - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "%x ", reply[i]); - - vtpmhandlerloginfomore(VTPM_LOG_VTPM_DEEP, "\n"); - } else { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s had error writing to ipc. Aborting... \n", thread_name); - goto abort_command; - } - free(out_message); out_message=NULL; - - if (size_write < (int)reply_size) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "%s unable to write full command to ipc (%d/%d)\n", thread_name, size_write, reply_size); - goto abort_command; - } - - // On certain failures an error message cannot be sent. - // This marks the beginning of cleanup in preperation for the next command. - abort_command: - //free buffers - bzero(cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - //free(in_param); // This was converted to command_buf. No need to free - buffer_free(result_buf); - buffer_free(command_buf); - - // If we have a write lock, save the manager table - if ((tag == VTPM_TAG_REQ) && (ord & VTPM_PRIV_MASK) && - (VTPM_SaveManagerData() != TPM_SUCCESS) ) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "ERROR: Unable to save manager data.\n"); - } - - vtpm_lock_unlock(); - add_header = TRUE; // Reset to the default - } // End while(1) - -} - -///////////////////////////////////////////////////////////////////////// -TPM_RESULT vtpm_manager_handle_vtpm_cmd(VTPM_DMI_RESOURCE *dmi_res, - TPM_COMMAND_CODE ord, - buffer_t *command_buf, - buffer_t *result_buf, - BOOL is_priv, - char *thread_name) { - - TPM_RESULT status = TPM_FAIL; - - switch (ord) { - case VTPM_ORD_SAVENVM: - status= VTPM_Handle_Save_NVM(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_LOADNVM: - status= VTPM_Handle_Load_NVM(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_TPMCOMMAND: - status= VTPM_Handle_TPM_Command(dmi_res, - command_buf, - result_buf); - break; - - case VTPM_ORD_GET_MIG_KEY: - status = VTPM_Handle_Get_Migration_key(command_buf, - result_buf); - break; - - case VTPM_ORD_LOAD_MIG_KEY: - status = VTPM_Handle_Load_Migration_key(command_buf, - result_buf); - break; - - default: - // Privileged handlers can do maintanance - if (is_priv) { - switch (ord) { - case VTPM_ORD_OPEN: - status = VTPM_Handle_New_DMI(command_buf); - break; - - case VTPM_ORD_CLOSE: - status = VTPM_Handle_Close_DMI(command_buf); - break; - - case VTPM_ORD_DELETE: - status = VTPM_Handle_Delete_DMI(command_buf); - break; - - case VTPM_ORD_MIGRATE_IN: - status = VTPM_Handle_Migrate_In(command_buf, result_buf); - break; - - case VTPM_ORD_MIGRATE_OUT: - status = VTPM_Handle_Migrate_Out(command_buf, result_buf); - break; - - default: - status = TPM_BAD_ORDINAL; - } // switch - } else { // is priv command - - status = TPM_BAD_ORDINAL; - } // inner switch - } // outer switch - - return(status); -} - -///////////////////////////////////////////////////////////////////// -TPM_RESULT vtpm_manager_handle_tpm_cmd(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - VTPM_DMI_RESOURCE *dmi_res, - BYTE *cmd_header, - buffer_t *param_buf, - buffer_t *result_buf, - char *thread_name) { - - TPM_RESULT status = TPM_FAIL; - UINT32 dmi_dst; - TPM_COMMAND_CODE ord; - TPM_TAG tag_out; - UINT32 dmi_cmd_size, in_param_size, adj_param_size; - BYTE *dmi_cmd, *in_param; - int size_read, size_write, i; - - //// Dom0 can't talk to the BE, so this must be a broken FE/BE or badness - if (dmi_res->dmi_id == VTPM_CTL_DM) { - vtpmhandlerlogerror(VTPM_LOG_VTPM, "Illegal use of TPM command from dom0\n"); - status = TPM_FAIL; - goto abort_with_error; - } - - vtpmhandlerloginfo(VTPM_LOG_VTPM, "Forwarding command to DMI.\n"); - - //Forward TPM CMD stamped with dmi_id to DMI for handling - if (buffer_len(param_buf)) { - dmi_cmd = (BYTE *) malloc(VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf)); - dmi_cmd_size = VTPM_COMMAND_HEADER_SIZE_SRV + buffer_len(param_buf); - memcpy(dmi_cmd, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - memcpy(dmi_cmd + VTPM_COMMAND_HEADER_SIZE_SRV, param_buf->bytes, buffer_len(param_buf)); - size_write = vtpm_ipc_write(tx_ipc_h, dmi_res->tx_tpm_ipc_h, dmi_cmd, dmi_cmd_size); - - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); - for (i=0; itx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV ); - if (size_write > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "SENT (DMI): 0x"); - for (i=0; irx_tpm_ipc_h, cmd_header, VTPM_COMMAND_HEADER_SIZE_SRV); - if (size_read > 0) { - vtpmhandlerloginfo(VTPM_LOG_VTPM_DEEP, "RECV (DMI): 0x"); - for (i=0; i 0) { - in_param = (BYTE *) malloc(adj_param_size); - size_read = vtpm_ipc_read(rx_ipc_h, dmi_res->rx_tpm_ipc_h, in_param, adj_param_size); - if (size_read > 0) { - for (i=0; i -#include -#include -#include -#include -#include -#include -#include -#include "vtpm_manager.h" -#include "vtpmpriv.h" -#include "tcg.h" -#include "log.h" -#include "vtpm_ipc.h" - -#define TPM_EMULATOR_PATH "/usr/bin/vtpmd" - -#define VTPM_BE_FNAME "/dev/vtpm" -#define VTPM_DUMMY_TX_BE_FNAME "/var/vtpm/fifos/dummy_out.fifo" -#define VTPM_DUMMY_RX_BE_FNAME "/var/vtpm/fifos/dummy_in.fifo" -#define VTPM_TX_TPM_FNAME "/var/vtpm/fifos/tpm_cmd_to_%d.fifo" -#define VTPM_RX_TPM_FNAME "/var/vtpm/fifos/tpm_rsp_from_all.fifo" -#define VTPM_TX_VTPM_FNAME "/var/vtpm/fifos/vtpm_rsp_to_%d.fifo" -#define VTPM_RX_VTPM_FNAME "/var/vtpm/fifos/vtpm_cmd_from_all.fifo" -#define VTPM_TX_HP_FNAME "/var/vtpm/fifos/to_console.fifo" -#define VTPM_RX_HP_FNAME "/var/vtpm/fifos/from_console.fifo" - -#define VTPM_TYPE_PVM_STRING "pvm" -#define VTPM_TYPE_HVM_STRING "hvm" - -struct vtpm_thread_params_s { - vtpm_ipc_handle_t *tx_ipc_h; - vtpm_ipc_handle_t *rx_ipc_h; - BOOL fw_tpm; - vtpm_ipc_handle_t *fw_tx_ipc_h; - vtpm_ipc_handle_t *fw_rx_ipc_h; - BOOL is_priv; - char *thread_name; -}; - -// This is needed to all extra_close_dmi to close this to prevent a -// broken pipe when no DMIs are left. -static vtpm_ipc_handle_t *g_rx_tpm_ipc_h; - -void *vtpm_manager_thread(void *arg_void) { - TPM_RESULT *status = (TPM_RESULT *) malloc(sizeof(TPM_RESULT) ); - struct vtpm_thread_params_s *arg = (struct vtpm_thread_params_s *) arg_void; - - *status = VTPM_Manager_Handler(arg->tx_ipc_h, arg->rx_ipc_h, - arg->fw_tpm, arg->fw_tx_ipc_h, arg->fw_rx_ipc_h, - arg->is_priv, arg->thread_name); - - return (status); -} - - -void signal_handler(int reason) { - if (pthread_equal(pthread_self(), vtpm_globals->master_pid)) { - vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager shutting down for signal %d.\n", reason); - } else { - // For old Linux Thread machines, signals are delivered to each thread. Deal with them. - vtpmloginfo(VTPM_LOG_VTPM, "Child shutting down\n"); - pthread_exit(NULL); - } - - VTPM_Stop_Manager(); - exit(-1); -} - -struct sigaction ctl_c_handler; - -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode) { - - TPM_RESULT status = TPM_SUCCESS; - int fh; - char dmi_id_str[11]; // UINT32s are up to 10 digits + NULL - char *tx_vtpm_name, *tx_tpm_name, *vm_type_string; - struct stat file_info; - - if (dmi_res->dmi_id == VTPM_CTL_DM) { - dmi_res->tx_tpm_ipc_h = NULL; - dmi_res->rx_tpm_ipc_h = NULL; - dmi_res->tx_vtpm_ipc_h = NULL; - dmi_res->rx_vtpm_ipc_h = NULL; - } else { - // Create a pair of fifo pipes - dmi_res->rx_tpm_ipc_h = NULL; - dmi_res->rx_vtpm_ipc_h = NULL; - - if ( ((dmi_res->tx_tpm_ipc_h = (vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || - ((dmi_res->tx_vtpm_ipc_h =(vtpm_ipc_handle_t *) malloc (sizeof(vtpm_ipc_handle_t))) == NULL ) || - ((tx_tpm_name = (char *) malloc(11 + strlen(VTPM_TX_TPM_FNAME))) == NULL ) || - ((tx_vtpm_name =(char *) malloc(11 + strlen(VTPM_TX_VTPM_FNAME))) == NULL) ) { - status =TPM_RESOURCES; - goto abort_egress; - } - - sprintf(tx_tpm_name, VTPM_TX_TPM_FNAME, (uint32_t) dmi_res->dmi_id); - sprintf(tx_vtpm_name, VTPM_TX_VTPM_FNAME, (uint32_t) dmi_res->dmi_id); - - if ( (vtpm_ipc_init(dmi_res->tx_tpm_ipc_h, tx_tpm_name, O_WRONLY | O_NONBLOCK, TRUE) != 0) || - (vtpm_ipc_init(dmi_res->tx_vtpm_ipc_h, tx_vtpm_name, O_WRONLY, TRUE) != 0) ) { //FIXME: O_NONBLOCK? - status = TPM_IOERROR; - goto abort_egress; - } - - // Measure DMI - // FIXME: This will measure DMI. Until then use a fixed DMI_Measurement value - // Also, this mechanism is specific to 1 VM architecture. - /* - fh = open(TPM_EMULATOR_PATH, O_RDONLY); - stat_ret = fstat(fh, &file_stat); - if (stat_ret == 0) - dmi_size = file_stat.st_size; - else { - vtpmlogerror(VTPM_LOG_VTPM, "Could not open vtpmd!!\n"); - status = TPM_IOERROR; - goto abort_egress; - } - dmi_buffer - */ - memset(&dmi_res->DMI_measurement, 0xcc, sizeof(TPM_DIGEST)); - - if (vm_type == VTPM_TYPE_PVM) - vm_type_string = (BYTE *)&VTPM_TYPE_PVM_STRING; - else - vm_type_string = (BYTE *)&VTPM_TYPE_HVM_STRING; - - // Launch DMI - sprintf(dmi_id_str, "%d", (int) dmi_res->dmi_id); -#ifdef MANUAL_DM_LAUNCH - vtpmlogerror(VTPM_LOG_VTPM, "Manually start VTPM with dmi=%s now.\n", dmi_id_str); - dmi_res->dmi_pid = 0; -#else - pid_t pid = fork(); - - if (pid == -1) { - vtpmlogerror(VTPM_LOG_VTPM, "Could not fork to launch vtpm\n"); - status = TPM_RESOURCES; - goto abort_egress; - } else if (pid == 0) { - switch (startup_mode) { - case TPM_ST_CLEAR: - execl (TPM_EMULATOR_PATH, "vtpmd", "clear", vm_type_string, dmi_id_str, NULL); - break; - case TPM_ST_STATE: - execl (TPM_EMULATOR_PATH, "vtpmd", "save", vm_type_string, dmi_id_str, NULL); - break; - case TPM_ST_DEACTIVATED: - execl (TPM_EMULATOR_PATH, "vtpmd", "deactivated", vm_type_string, dmi_id_str, NULL); - break; - default: - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Returning from these at all is an error. - vtpmlogerror(VTPM_LOG_VTPM, "Could not exec to launch vtpm\n"); - } else { - dmi_res->dmi_pid = pid; - vtpmloginfo(VTPM_LOG_VTPM, "Launching DMI on PID = %d\n", pid); - } -#endif // MANUAL_DM_LAUNCH - - } // If DMI = VTPM_CTL_DM - status = TPM_SUCCESS; - -abort_egress: - return (status); -} - -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res) { - TPM_RESULT status = TPM_SUCCESS; - - if (vtpm_globals->connected_dmis == 0) { - // No more DMI's connected. Close fifo to prevent a broken pipe. - // This is hackish. Need to think of another way. - vtpm_ipc_close(g_rx_tpm_ipc_h); - } - - - if (dmi_res->dmi_id != VTPM_CTL_DM) { - vtpm_ipc_close(dmi_res->tx_tpm_ipc_h); - vtpm_ipc_close(dmi_res->tx_vtpm_ipc_h); - - free(dmi_res->tx_tpm_ipc_h->name); - free(dmi_res->tx_vtpm_ipc_h->name); - -#ifndef MANUAL_DM_LAUNCH - if (dmi_res->dmi_id != VTPM_CTL_DM) { - if (dmi_res->dmi_pid != 0) { - vtpmloginfo(VTPM_LOG_VTPM, "Killing dmi on pid %d.\n", dmi_res->dmi_pid); - if (kill(dmi_res->dmi_pid, SIGKILL) !=0) { - vtpmloginfo(VTPM_LOG_VTPM, "DMI on pid %d is already dead.\n", dmi_res->dmi_pid); - } else if (waitpid(dmi_res->dmi_pid, NULL, 0) != dmi_res->dmi_pid) { - vtpmlogerror(VTPM_LOG_VTPM, "DMI on pid %d failed to stop.\n", dmi_res->dmi_pid); - status = TPM_FAIL; - } - } else { - vtpmlogerror(VTPM_LOG_VTPM, "Could not kill dmi because it's pid was 0.\n"); - status = TPM_FAIL; - } - } -#endif - - } //endif ! dom0 - return status; -} - - -int main(int argc, char **argv) { - vtpm_ipc_handle_t *tx_be_ipc_h, *rx_be_ipc_h, rx_tpm_ipc_h, rx_vtpm_ipc_h, tx_hp_ipc_h, rx_hp_ipc_h; - struct vtpm_thread_params_s be_thread_params, dmi_thread_params, hp_thread_params; - pthread_t be_thread, dmi_thread, hp_thread; - -#ifdef DUMMY_BACKEND - vtpm_ipc_handle_t tx_dummy_ipc_h, rx_dummy_ipc_h; -#else - vtpm_ipc_handle_t real_be_ipc_h; -#endif - - vtpmloginfo(VTPM_LOG_VTPM, "Starting VTPM.\n"); - - // -------------------- Initialize Manager ----------------- - if (VTPM_Init_Manager() != TPM_SUCCESS) { - vtpmlogerror(VTPM_LOG_VTPM, "Closing vtpmd due to error during startup.\n"); - return -1; - } - - // -------------------- Setup Ctrl+C Handlers -------------- - ctl_c_handler.sa_handler = signal_handler; - sigemptyset(&ctl_c_handler.sa_mask); - ctl_c_handler.sa_flags = 0; - - if (sigaction(SIGINT, &ctl_c_handler, NULL) == -1) - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGINT handler. Ctl+break will not stop manager gently.\n"); - - // For easier debuggin with gdb - if (sigaction(SIGHUP, &ctl_c_handler, NULL) == -1) - vtpmlogerror(VTPM_LOG_VTPM, "Could not install SIGHUP handler. Ctl+break will not stop manager gently.\n"); - - sigset_t sig_mask; - sigemptyset(&sig_mask); - sigaddset(&sig_mask, SIGPIPE); - sigprocmask(SIG_BLOCK, &sig_mask, NULL); - - // ------------------- Set up file ipc structures ---------- -#ifdef DUMMY_BACKEND - if ( (vtpm_ipc_init(&tx_dummy_ipc_h, VTPM_DUMMY_TX_BE_FNAME, O_RDWR, TRUE) != 0) || - (vtpm_ipc_init(&rx_dummy_ipc_h, VTPM_DUMMY_RX_BE_FNAME, O_RDWR, TRUE) != 0) ) { - - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create Dummy BE FIFOs.\n"); - exit(-1); - } - - tx_be_ipc_h = &tx_dummy_ipc_h; - rx_be_ipc_h = &rx_dummy_ipc_h; -#else - vtpm_ipc_init(&real_be_ipc_h, VTPM_BE_FNAME, O_RDWR, FALSE); - - tx_be_ipc_h = &real_be_ipc_h; - rx_be_ipc_h = &real_be_ipc_h; -#endif - - if ( (vtpm_ipc_init(&rx_tpm_ipc_h, VTPM_RX_TPM_FNAME, O_RDONLY, TRUE) != 0) || - (vtpm_ipc_init(&rx_vtpm_ipc_h, VTPM_RX_VTPM_FNAME, O_RDWR, TRUE) != 0) || //FIXME: O_RDONLY? - (vtpm_ipc_init(&tx_hp_ipc_h, VTPM_TX_HP_FNAME, O_RDWR, TRUE) != 0) || - (vtpm_ipc_init(&rx_hp_ipc_h, VTPM_RX_HP_FNAME, O_RDWR, TRUE) != 0) ) { - vtpmlogerror(VTPM_LOG_VTPM, "Unable to create initial FIFOs.\n"); - exit(-1); - } - - g_rx_tpm_ipc_h = &rx_tpm_ipc_h; - - // -------------------- Set up thread params ------------- - - be_thread_params.tx_ipc_h = tx_be_ipc_h; - be_thread_params.rx_ipc_h = rx_be_ipc_h; - be_thread_params.fw_tpm = TRUE; - be_thread_params.fw_tx_ipc_h = NULL; - be_thread_params.fw_rx_ipc_h = &rx_tpm_ipc_h; - be_thread_params.is_priv = FALSE; - be_thread_params.thread_name = "Backend Listener"; - - dmi_thread_params.tx_ipc_h = NULL; - dmi_thread_params.rx_ipc_h = &rx_vtpm_ipc_h; - dmi_thread_params.fw_tpm = FALSE; - dmi_thread_params.fw_tx_ipc_h = NULL; - dmi_thread_params.fw_rx_ipc_h = NULL; - dmi_thread_params.is_priv = FALSE; - dmi_thread_params.thread_name = "VTPM Listener"; - - hp_thread_params.tx_ipc_h = &tx_hp_ipc_h; - hp_thread_params.rx_ipc_h = &rx_hp_ipc_h; - hp_thread_params.fw_tpm = FALSE; - hp_thread_params.fw_tx_ipc_h = NULL; - hp_thread_params.fw_rx_ipc_h = NULL; - hp_thread_params.is_priv = TRUE; - hp_thread_params.thread_name = "Hotplug Listener"; - - // --------------------- Launch Threads ----------------- - - vtpm_lock_init(); - - vtpm_globals->master_pid = pthread_self(); - - if (pthread_create(&be_thread, NULL, vtpm_manager_thread, &be_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch BE Thread.\n"); - exit(-1); - } - - if (pthread_create(&dmi_thread, NULL, vtpm_manager_thread, &dmi_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch DMI Thread.\n"); - exit(-1); - } - - - if (pthread_create(&hp_thread, NULL, vtpm_manager_thread, &hp_thread_params) != 0) { - vtpmlogerror(VTPM_LOG_VTPM, "Failed to launch HP Thread.\n"); - exit(-1); - } - - //Join the other threads until exit time. - pthread_join(be_thread, NULL); - pthread_join(dmi_thread, NULL); - pthread_join(hp_thread, NULL); - - vtpmlogerror(VTPM_LOG_VTPM, "VTPM Manager shut down unexpectedly.\n"); - - VTPM_Stop_Manager(); - vtpm_lock_destroy(); - return 0; -} diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtpmpriv.h --- a/tools/vtpm_manager/manager/vtpmpriv.h Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,186 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtpmpriv.h -// -// Structures and functions private to the manager -// -// ================================================================== - -#ifndef __VTPMPRIV_H__ -#define __VTPMPRIV_H__ - -#include "vtpm_manager.h" -#include "tcg.h" -#include "tcs.h" -#include "buffer.h" -#include "crypto.h" -#include "vtpm_ipc.h" - -#define VTPM_MANAGER_GEN 2 // This is incremented when the manager's table - // is changed. It's used for backwards compatability - -#define STATE_FILE "/var/vtpm/VTPM" -#define DMI_NVM_FILE "/var/vtpm/vtpm_dm_%d.data" -#define VTPM_CTL_DM 0 - -// ------------------------ Private Structures ----------------------- -typedef struct VTPM_DMI_RESOURCE_T { - // I/O info for Manager to talk to DMI's and controllers - vtpm_ipc_handle_t *tx_vtpm_ipc_h; // TX VTPM Results to DMI - vtpm_ipc_handle_t *rx_vtpm_ipc_h; // RX VTPM Commands from DMI - vtpm_ipc_handle_t *tx_tpm_ipc_h; // TX TPM Commands to DMI - vtpm_ipc_handle_t *rx_tpm_ipc_h; // RX TPM Results from DMI - -#ifndef VTPM_MULTI_VM - pid_t dmi_pid; -#endif - - // Non-persistent Information - bool connected; - UINT32 dmi_domain_id; - TCS_CONTEXT_HANDLE TCSContext; // TCS Handle - char *NVMLocation; // NULL term string indicating location - // of NVM. - // Persistent Information about DMI - UINT32 dmi_id; - BYTE dmi_type; - TPM_DIGEST NVM_measurement; // Equal to the SHA1 of the blob - TPM_DIGEST DMI_measurement; // Correct measurement of the owning DMI -} VTPM_DMI_RESOURCE; - -typedef struct tdVTPM_MIGKEY_LIST { - UINT32 name_size; - BYTE *name; // Name of destination (IP addr, domain name, etc) - CRYPTO_INFO key; - struct tdVTPM_MIGKEY_LIST *next; -} VTPM_MIGKEY_LIST; - - -typedef struct tdVTPM_GLOBALS { - // Non-persistent data -#ifndef VTPM_MULTI_VM - pid_t master_pid; -#endif - - int connected_dmis; // To close guest_rx when no dmis are connected - - struct hashtable *dmi_map; // Table of all DMI's known indexed by persistent instance # - VTPM_MIGKEY_LIST *mig_keys; // Table of migration keys - // Currently keys are loaded at migration time, - // TODO: Make VTPM man store a keys persistently - // and update script to check if key is needed - // before fetching it. - - TCS_CONTEXT_HANDLE manager_tcs_handle; // TCS Handle used by manager - TPM_HANDLE storageKeyHandle; // Key used by persistent store - CRYPTO_INFO storageKey; // For software encryption - CRYPTO_INFO bootKey; // For saving table - TCS_AUTH keyAuth; // OIAP session for storageKey - - // Persistent Data - TPM_AUTHDATA owner_usage_auth; // OwnerAuth of real TPM - buffer_t storageKeyWrap; // Wrapped copy of storageKey - TPM_AUTHDATA srk_usage_auth; - TPM_AUTHDATA storage_key_usage_auth; - - buffer_t bootKeyWrap; // Wrapped copy of boot key - -}VTPM_GLOBALS; - -// --------------------------- Global Values -------------------------- -extern VTPM_GLOBALS *vtpm_globals; // Key info and DMI states -extern const TPM_AUTHDATA SRK_AUTH; // SRK Well Known Auth Value - -// ********************** VTPM Functions ************************* -TPM_RESULT VTPM_Init_Manager(); // Start VTPM Service -void VTPM_Stop_Manager(); // Stop VTPM Service -TPM_RESULT VTPM_Manager_Handler(vtpm_ipc_handle_t *tx_ipc_h, - vtpm_ipc_handle_t *rx_ipc_h, - BOOL fw_tpm, // Should forward TPM cmds - vtpm_ipc_handle_t *fw_tx_ipc_h, - vtpm_ipc_handle_t *fw_rx_ipc_h, - BOOL is_priv, - char *client_name); - -// ********************** Command Handler Prototypes *********************** - -TPM_RESULT VTPM_Handle_Load_NVM( VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_Save_NVM( VTPM_DMI_RESOURCE *myDMI, - const buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_TPM_Command( VTPM_DMI_RESOURCE *dmi, - buffer_t *inbuf, - buffer_t *outbuf); - -TPM_RESULT VTPM_Handle_New_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Close_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Delete_DMI(const buffer_t *param_buf); - -TPM_RESULT VTPM_Handle_Migrate_In( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_Handle_Migrate_Out ( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_Handle_Get_Migration_key( const buffer_t *param_buf, - buffer_t *result_buf); - -TPM_RESULT VTPM_SaveManagerData(void); -TPM_RESULT VTPM_LoadManagerData(void); - -TPM_RESULT VTPM_New_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res, BYTE vm_type, BYTE startup_mode); - -TPM_RESULT VTPM_Close_DMI_Extra(VTPM_DMI_RESOURCE *dmi_res); - -// Helper functions -TPM_RESULT close_dmi(VTPM_DMI_RESOURCE *dmi_res); -TPM_RESULT init_dmi(UINT32 dmi_id, BYTE type, VTPM_DMI_RESOURCE **dmi_res); - -TPM_RESULT envelope_encrypt(const buffer_t *inbuf, - CRYPTO_INFO *asymkey, - buffer_t *sealed_data); - -TPM_RESULT envelope_decrypt(const buffer_t *cipher, - TCS_CONTEXT_HANDLE TCSContext, - TPM_HANDLE keyHandle, - const TPM_AUTHDATA *key_usage_auth, - buffer_t *unsealed_data); - -#endif // __VTPMPRIV_H__ diff -r 2a4c1d3a080e -r 170d45f7a2eb tools/vtpm_manager/manager/vtsp.c --- a/tools/vtpm_manager/manager/vtsp.c Tue Nov 13 10:46:59 2012 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1042 +0,0 @@ -// =================================================================== -// -// 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. -// =================================================================== -// -// vtsp.c -// -// Higher level interface to TCS for use in service. -// -// ================================================================== - -#include -#include "tcg.h" -#include "tcs.h" -#include "bsg.h" -#include "log.h" -#include "crypto.h" -#include "vtsp.h" -#include "buffer.h" - -#define RSA_KEY_SIZE 0x0800 - -/*********************************************************************************** - * GenerateAuth: Generate authorization info to be sent back to application - * - * Parameters: outParamDigestText The concatenation of output parameters to be SHA1ed - * outParamDigestTextSize Size of inParamDigestText - * HMACkey Key to be used for HMACing - * For OIAP use key.authUsage or PersistStore.ownerAuth - * For OSAP use shared secret - * pAuth Authorization information from the application - * - * Return: TPM_SUCCESS Authorization data created - * TPM_AUTHFAIL Invalid (NULL) HMACkey presented for OSAP - *************************************************************************************/ -TPM_RESULT GenerateAuth( /*[IN]*/ const BYTE *inParamDigestText, - /*[IN]*/ UINT32 inParamDigestTextSize, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TCS_AUTH *auth) { - - if (inParamDigestText == NULL || auth == NULL) - return (TPM_AUTHFAIL); - else { - - //Generate new OddNonce - Crypto_GetRandom(auth->NonceOdd.nonce, sizeof(TPM_NONCE)); - - // Create SHA1 inParamDigest - TPM_DIGEST inParamDigest; - Crypto_SHA1Full(inParamDigestText, inParamDigestTextSize, (BYTE *) &inParamDigest); - - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - - BSG_PackList( hmacText, 4, - BSG_TPM_DIGEST, &inParamDigest, - BSG_TPM_NONCE, &(auth->NonceEven), - BSG_TPM_NONCE, &(auth->NonceOdd), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); - - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &(auth->HMAC)); - - return(TPM_SUCCESS); - - } -} - -/*********************************************************************************** - * VerifyAuth: Verify the authdata for a command requiring authorization - * - * Parameters: inParamDigestText The concatenation of parameters to be SHA1ed - * inParamDigestTextSize Size of inParamDigestText - * authDataUsage AuthDataUsage for the Entity being used - * Key->authDataUsage or TPM_AUTH_OWNER - * HMACkey Key to be used for HMACing - * For OIAP use key.authUsage or PersistStore.ownerAuth - * For OSAP use NULL (It will be aquired from the Auth Session) - * If unknown (default), assume OIAP - * sessionAuth A TCS_AUTH info for the session - * pAuth Authorization information from the application - * hContext If specified, on failed Auth, VerifyAuth will - * generate a new OIAP session in place of themselves - * destroyed session. - * - * Return: TPM_SUCCESS Authorization Verified - * TPM_AUTHFAIL Authorization Failed - * TPM_FAIL Failure during SHA1 routines - *************************************************************************************/ -TPM_RESULT VerifyAuth( /*[IN]*/ const BYTE *outParamDigestText, - /*[IN]*/ UINT32 outParamDigestTextSize, - /*[IN]*/ const TPM_SECRET *HMACkey, - /*[IN,OUT]*/ TCS_AUTH *auth, - /*[IN]*/ TCS_CONTEXT_HANDLE hContext) { - if (outParamDigestText == NULL || auth == NULL) - return (TPM_AUTHFAIL); - - - // Create SHA1 inParamDigest - TPM_DIGEST outParamDigest; - Crypto_SHA1Full(outParamDigestText, outParamDigestTextSize, (BYTE *) &outParamDigest); - - // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams). - TPM_DIGEST hm; - BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof(BOOL)]; - - BSG_PackList( hmacText, 4, - BSG_TPM_DIGEST, &outParamDigest, - BSG_TPM_NONCE, &(auth->NonceEven), - BSG_TPM_NONCE, &(auth->NonceOdd), - BSG_TYPE_BOOL, &(auth->fContinueAuthSession) ); - - Crypto_HMAC((BYTE *) hmacText, sizeof(hmacText), - (BYTE *) HMACkey, sizeof(TPM_DIGEST), (BYTE *) &hm); - - // Compare correct HMAC with provided one. - if (memcmp (&hm, &(auth->HMAC), sizeof(TPM_DIGEST)) == 0) { // 0 indicates equality - if (!auth->fContinueAuthSession) - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM by fContinue=0.\n", auth->AuthHandle); - - return (TPM_SUCCESS); - } else { - // If specified, reconnect the OIAP session. - // NOTE: This only works for TCS's that never have a 0 context. - if (hContext) { - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM due to failure.\n", auth->AuthHandle); - VTSP_OIAP( hContext, auth); - } - return (TPM_AUTHFAIL); - } -} - -TPM_RESULT VTSP_OIAP(const TCS_CONTEXT_HANDLE hContext, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "OIAP.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPMTRYRETURN( TCSP_OIAP(hContext, - &auth->AuthHandle, - &auth->NonceEven) ); - - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); - goto egress; - - abort_egress: - - egress: - - return status; -} - -TPM_RESULT VTSP_OSAP(const TCS_CONTEXT_HANDLE hContext, - const TPM_ENTITY_TYPE entityType, - const UINT32 entityValue, - const TPM_AUTHDATA *usageAuth, - TPM_SECRET *sharedSecret, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "OSAP.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPM_NONCE nonceEvenOSAP, nonceOddOSAP; - - Crypto_GetRandom((BYTE *) &nonceOddOSAP, sizeof(TPM_NONCE) ); - - TPMTRYRETURN( TCSP_OSAP( hContext, - entityType, - entityValue, - nonceOddOSAP, - &auth->AuthHandle, - &auth->NonceEven, - &nonceEvenOSAP) ); - - // Calculating Session Secret - BYTE sharedSecretText[TPM_DIGEST_SIZE * 2]; - - BSG_PackList( sharedSecretText, 2, - BSG_TPM_NONCE, &nonceEvenOSAP, - BSG_TPM_NONCE, &nonceOddOSAP); - - Crypto_HMAC(sharedSecretText, sizeof(sharedSecretText), (BYTE *) usageAuth, TPM_DIGEST_SIZE, (BYTE *) sharedSecret); - - memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); - auth->fContinueAuthSession = FALSE; - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x opened by TPM_OSAP.\n", auth->AuthHandle); - - goto egress; - - abort_egress: - - egress: - - return status; -} - - -TPM_RESULT VTSP_TerminateHandle(const TCS_CONTEXT_HANDLE hContext, - const TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Terminate Handle.\n"); - TPM_RESULT status = TPM_SUCCESS; - TPMTRYRETURN( TCSP_TerminateHandle(hContext, auth->AuthHandle) ); - - vtpmloginfo(VTPM_LOG_VTSP_DEEP, "Auth Session: 0x%x closed by TPM_TerminateHandle.\n", auth->AuthHandle); - goto egress; - - abort_egress: - - egress: - - return status; -} - - -TPM_RESULT VTSP_ReadPubek( const TCS_CONTEXT_HANDLE hContext, - CRYPTO_INFO *crypto_info) { - - TPM_RESULT status; - TPM_NONCE antiReplay; - TPM_DIGEST checksum; - BYTE *pubEKtext; - UINT32 pubEKtextsize; - - vtpmloginfo(VTPM_LOG_VTSP, "Reading Public EK.\n"); - - // GenerateAuth new nonceOdd - Crypto_GetRandom(&antiReplay, sizeof(TPM_NONCE) ); - - - TPMTRYRETURN( TCSP_ReadPubek( hContext, - antiReplay, - &pubEKtextsize, - &pubEKtext, - &checksum) ); - - - // Extract the remaining output parameters - TPM_PUBKEY pubEK; - - BSG_Unpack(BSG_TPM_PUBKEY, pubEKtext, (BYTE *) &pubEK); - - // Build CryptoInfo for the bindingKey - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - pubEK.algorithmParms.parms, - &rsaKeyParms); - - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, - rsaKeyParms.exponent, - pubEK.pubKey.keyLength, - pubEK.pubKey.key, - crypto_info); - - // Destroy rsaKeyParms - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); - - // Set encryption scheme - crypto_info->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - //crypto_info->encScheme = pubEK.algorithmParms.encScheme; - crypto_info->algorithmID = pubEK.algorithmParms.algorithmID; - - goto egress; - - abort_egress: - - egress: - - return status; -} - -TPM_RESULT VTSP_TakeOwnership( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - const TPM_AUTHDATA *srkAuth, - CRYPTO_INFO *ek_cryptoInfo, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Taking Ownership of TPM.\n"); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_TakeOwnership; - TPM_PROTOCOL_ID proto_id = TPM_PID_OWNER; - BYTE *new_srk; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // vars for srkpubkey parameter - TPM_KEY srkPub; - TPM_KEY_PARMS srkKeyInfo = {TPM_ALG_RSA, TPM_ES_RSAESOAEP_SHA1_MGF1, TPM_SS_NONE, 12, 0}; - BYTE srkRSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; - srkKeyInfo.parms = (BYTE *) &srkRSAkeyInfo; - - struct pack_buf_t srkText; - - //These values are accurate for an enc(AuthData). - struct pack_buf_t encOwnerAuth, encSrkAuth; - - encOwnerAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); - encSrkAuth.data = (BYTE *)malloc(sizeof(BYTE) * 256); - - if (encOwnerAuth.data == NULL || encSrkAuth.data == NULL) { - vtpmloginfo(VTPM_LOG_VTSP, "Could not malloc encrypted auths.\n"); - status = TPM_RESOURCES; - goto abort_egress; - } - - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) ownerAuth, &encOwnerAuth.size, encOwnerAuth.data); - Crypto_RSAEnc(ek_cryptoInfo, sizeof(TPM_SECRET), (BYTE *) srkAuth, &encSrkAuth.size, encSrkAuth.data); - - - // Build srk public key struct - srkPub.ver = TPM_STRUCT_VER_1_1; - srkPub.keyUsage = TPM_KEY_STORAGE; - srkPub.keyFlags = 0x00; - srkPub.authDataUsage = TPM_AUTH_ALWAYS; - memcpy(&srkPub.algorithmParms, &srkKeyInfo, sizeof(TPM_KEY_PARMS)); - srkPub.PCRInfoSize = 0; - srkPub.PCRInfo = 0; - srkPub.pubKey.keyLength= 0; - srkPub.encDataSize = 0; - - srkText.data = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - srkText.size = BSG_Pack(BSG_TPM_KEY, (BYTE *) &srkPub, srkText.data); - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 5, - BSG_TPM_COMMAND_CODE,&command, - BSG_TPM_PROTOCOL_ID, &proto_id, - BSG_TPM_SIZE32_DATA, &encOwnerAuth, - BSG_TPM_SIZE32_DATA, &encSrkAuth, - BSG_TPM_KEY, &srkPub); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, ownerAuth, auth) ); - - new_srk = srkText.data; - TPMTRYRETURN( TCSP_TakeOwnership ( hContext, - proto_id, - encOwnerAuth.size, - encOwnerAuth.data, - encSrkAuth.size, - encSrkAuth.data, - &srkText.size, - &new_srk, - auth ) ); - - - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - memcpy(paramText + paramTextSize, new_srk, srkText.size); - paramTextSize += srkText.size; - - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - ownerAuth, auth, - hContext) ); - - goto egress; - - abort_egress: - - egress: - - free(srkText.data); - free(encSrkAuth.data); - free(encOwnerAuth.data); - free(paramText); - - TCS_FreeMemory(hContext, new_srk); - - return status; -} - -TPM_RESULT VTSP_DisablePubekRead( const TCS_CONTEXT_HANDLE hContext, - const TPM_AUTHDATA *ownerAuth, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Disabling Pubek Read.\n"); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_DisablePubekRead; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 1, - BSG_TPM_COMMAND_CODE, &command); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - ownerAuth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_DisablePubekRead ( hContext, // in - auth) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - ownerAuth, auth, - hContext) ); - goto egress; - - abort_egress: - egress: - free(paramText); - return status; -} - -TPM_RESULT VTSP_CreateWrapKey( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_USAGE usage, - const TPM_AUTHDATA *newKeyAuth, - const TCS_KEY_HANDLE parentHandle, - const TPM_AUTHDATA *osapSharedSecret, - buffer_t *pubKeyBuf, - TCS_AUTH *auth) { - - int i; - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_CreateWrapKey; - - vtpmloginfo(VTPM_LOG_VTSP, "Creating new key of type %d.\n", usage); - - // vars for Calculate encUsageAuth - BYTE *paramText; - UINT32 paramTextSize; - - // vars for Calculate encUsageAuth - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - TPM_DIGEST XORKey1; - UINT32 XORbufferSize; - TPM_SECRET encUsageAuth, encMigrationAuth; - - // vars for Flatten newKey prototype - BYTE *flatKey = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - UINT32 flatKeySize = TCPA_MAX_BUFFER_LENGTH; - struct pack_buf_t newKeyText; - - // Fill in newKey - TPM_KEY newKey; - - BYTE RSAkeyInfo[12] = { 0x00, 0x00, (RSA_KEY_SIZE >> 8), 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}; - newKey.algorithmParms.algorithmID = TPM_ALG_RSA; - newKey.algorithmParms.parms = (BYTE *) &RSAkeyInfo; - newKey.algorithmParms.parmSize = 12; - - switch (usage) { - case TPM_KEY_SIGNING: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Signing Key...\n"); - newKey.keyUsage = TPM_KEY_SIGNING; - newKey.algorithmParms.encScheme = TPM_ES_NONE; - newKey.algorithmParms.sigScheme = TPM_SS_RSASSAPKCS1v15_SHA1; - break; - case TPM_KEY_STORAGE: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Storage Key...\n"); - newKey.keyUsage = TPM_KEY_STORAGE; - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - newKey.algorithmParms.sigScheme = TPM_SS_NONE; - break; - case TPM_KEY_BIND: - vtpmloginfo(VTPM_LOG_VTSP, "Creating Binding Key...\n"); - newKey.keyUsage = TPM_KEY_BIND; - newKey.algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1; - newKey.algorithmParms.sigScheme = TPM_SS_NONE; - break; - default: - vtpmloginfo(VTPM_LOG_VTSP, "Cannot create key. Invalid Key Type.\n"); - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - - newKey.ver = TPM_STRUCT_VER_1_1; - - newKey.keyFlags = 0; - newKey.authDataUsage = TPM_AUTH_ALWAYS; - newKey.pubKey.keyLength= 0; - newKey.encDataSize = 0; - newKey.encData = NULL; - - // FIXME: Support PCR bindings - newKey.PCRInfoSize = 0; - newKey.PCRInfo = NULL; - - // Calculate encUsageAuth - XORbufferSize = BSG_PackList( XORbuffer, 2, - BSG_TPM_SECRET, osapSharedSecret, - BSG_TPM_NONCE, &auth->NonceEven); - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey1); - - // FIXME: No support for migratable keys. - for (i=0; i < TPM_DIGEST_SIZE; i++) - ((BYTE *) &encUsageAuth)[i] = ((BYTE *) &XORKey1)[i] ^ ((BYTE *) newKeyAuth)[i]; - - // Flatten newKey prototype - flatKeySize = BSG_Pack(BSG_TPM_KEY, (BYTE *) &newKey, flatKey); - newKeyText.data = flatKey; - newKeyText.size = flatKeySize; - - // Generate HMAC - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_AUTHDATA, &encUsageAuth, - BSG_TPM_AUTHDATA, &encMigrationAuth); - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); - paramTextSize += newKeyText.size; - - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - osapSharedSecret, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_CreateWrapKey( hContext, - parentHandle, - encUsageAuth, - encMigrationAuth, - &newKeyText.size, - &newKeyText.data, - auth) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command); - memcpy(paramText + paramTextSize, newKeyText.data, newKeyText.size); - paramTextSize += newKeyText.size; - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - osapSharedSecret, auth, 0) ); - - // Unpack/return key structure - TPMTRYRETURN(buffer_init(pubKeyBuf, 0, 0) ); - TPMTRYRETURN(buffer_append_raw(pubKeyBuf, newKeyText.size, newKeyText.data) ); - - goto egress; - - abort_egress: - - egress: - - free(flatKey); - free(paramText); - TCS_FreeMemory(hContext, newKeyText.data); - - return status; -} - -TPM_RESULT VTSP_LoadKey(const TCS_CONTEXT_HANDLE hContext, - const TCS_KEY_HANDLE hUnwrappingKey, - const buffer_t *rgbWrappedKeyBlob, - const TPM_AUTHDATA *parentAuth, - TPM_HANDLE *newKeyHandle, - TCS_AUTH *auth, - CRYPTO_INFO *cryptoinfo, - const BOOL skipTPMLoad) { - - - vtpmloginfo(VTPM_LOG_VTSP, "Loading Key %s.\n", (!skipTPMLoad ? "into TPM" : "only into memory")); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_LoadKey; - - BYTE *paramText=NULL; // Digest to make Auth. - UINT32 paramTextSize; - - // SkipTPMLoad stops key from being loaded into TPM, but still generates CRYPTO_INFO for it - if (! skipTPMLoad) { - - if ((rgbWrappedKeyBlob == NULL) || (parentAuth == NULL) || - (newKeyHandle==NULL) || (auth==NULL)) { - status = TPM_BAD_PARAMETER; - goto abort_egress; - } - - // Generate Extra TCS Parameters - TPM_HANDLE phKeyHMAC; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 1, - BSG_TPM_COMMAND_CODE, &command); - - memcpy(paramText + paramTextSize, rgbWrappedKeyBlob->bytes, buffer_len(rgbWrappedKeyBlob)); - paramTextSize += buffer_len(rgbWrappedKeyBlob); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - parentAuth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_LoadKeyByBlob( hContext, - hUnwrappingKey, - buffer_len(rgbWrappedKeyBlob), - rgbWrappedKeyBlob->bytes, - auth, - newKeyHandle, - &phKeyHMAC) ); - - // Verify Auth - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_HANDLE, newKeyHandle); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - parentAuth, auth, - hContext) ); - } - - // Build cryptoinfo structure for software crypto function. - if (cryptoinfo != NULL) { - TPM_KEY newKey; - - // Unpack/return key structure - BSG_Unpack(BSG_TPM_KEY, rgbWrappedKeyBlob->bytes , &newKey); - TPM_RSA_KEY_PARMS rsaKeyParms; - - BSG_Unpack(BSG_TPM_RSA_KEY_PARMS, - newKey.algorithmParms.parms, - &rsaKeyParms); - - Crypto_RSABuildCryptoInfoPublic(rsaKeyParms.exponentSize, - rsaKeyParms.exponent, - newKey.pubKey.keyLength, - newKey.pubKey.key, - cryptoinfo); - - // Destroy rsaKeyParms - BSG_Destroy(BSG_TPM_RSA_KEY_PARMS, &rsaKeyParms); - - // Set encryption scheme - cryptoinfo->encScheme = CRYPTO_ES_RSAESOAEP_SHA1_MGF1; - } - - goto egress; - - abort_egress: - - egress: - - free(paramText); - return status; -} - -TPM_RESULT VTSP_Unbind( const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE key_handle, - const buffer_t *bound_data, - const TPM_AUTHDATA *usage_auth, - buffer_t *clear_data, - TCS_AUTH *auth) { - - vtpmloginfo(VTPM_LOG_VTSP, "Unbinding %d bytes of data.\n", buffer_len(bound_data)); - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_UnBind; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // Generate Extra TCS Parameters - struct pack_buf_t clear_data32; - BYTE *clear_data_text; - UINT32 clear_data_size; - - struct pack_buf_t bound_data32 = {bound_data->size, bound_data->bytes}; - - paramText = (BYTE *) malloc(sizeof(BYTE) * TCPA_MAX_BUFFER_LENGTH); - - paramTextSize = BSG_PackList(paramText, 2, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_SIZE32_DATA, &bound_data32); - - TPMTRYRETURN( GenerateAuth( paramText, paramTextSize, - usage_auth, auth) ); - - // Call TCS - TPMTRYRETURN( TCSP_UnBind( hContext, - key_handle, - buffer_len(bound_data), - bound_data->bytes, - auth, - &clear_data_size, - &clear_data_text) ); - - - // Verify Auth - clear_data32.size = clear_data_size; - clear_data32.data = clear_data_text; - paramTextSize = BSG_PackList(paramText, 3, - BSG_TPM_RESULT, &status, - BSG_TPM_COMMAND_CODE, &command, - BSG_TPM_SIZE32_DATA, &clear_data32); - - TPMTRYRETURN( VerifyAuth( paramText, paramTextSize, - usage_auth, auth, - hContext) ); - - // Unpack/return key structure - TPMTRYRETURN(buffer_init(clear_data, 0, 0)); - TPMTRYRETURN(buffer_append_raw (clear_data, clear_data_size, clear_data_text) ); - - goto egress; - - abort_egress: - - egress: - - free(paramText); - TCS_FreeMemory(hContext, clear_data_text); - - return status; -} - -TPM_RESULT VTSP_Bind( CRYPTO_INFO *cryptoInfo, - const buffer_t *inData, - buffer_t *outData) -{ - vtpmloginfo(VTPM_LOG_VTSP, "Binding %d bytes of data.\n", buffer_len(inData)); - TPM_RESULT status = TPM_SUCCESS; - TPM_BOUND_DATA boundData; - UINT32 i; - - // Fill boundData's accessory information - boundData.ver = TPM_STRUCT_VER_1_1; - boundData.payload = TPM_PT_BIND; - boundData.payloadData = inData->bytes; - - // Pack boundData before encryption - BYTE* flatBoundData = (BYTE *)malloc(sizeof(BYTE) * - (sizeof(TPM_VERSION) + - sizeof(TPM_PAYLOAD_TYPE) + - buffer_len(inData))); - if (flatBoundData == NULL) { - return TPM_NOSPACE; - } - UINT32 flatBoundDataSize = 0; - flatBoundDataSize = BSG_PackList( flatBoundData, 2, - BSG_TPM_VERSION, &boundData.ver, - BSG_TYPE_BYTE, &boundData.payload); - - memcpy(flatBoundData+flatBoundDataSize, inData->bytes, buffer_len(inData)); - flatBoundDataSize += buffer_len(inData); - - BYTE out_tmp[RSA_KEY_SIZE/8]; // RSAEnc does not do blocking, So this is what will come out. - UINT32 out_tmp_size; - - // Encrypt flatBoundData - TPMTRY(TPM_ENCRYPT_ERROR, Crypto_RSAEnc( cryptoInfo, - flatBoundDataSize, - flatBoundData, - &out_tmp_size, - out_tmp) ); - - if (out_tmp_size > RSA_KEY_SIZE/8) { - // The result of RSAEnc should be a fixed size based on key size. - vtpmlogerror(VTPM_LOG_VTSP, "Enc buffer just overflowed.\n"); - } - - buffer_init(outData, 0, NULL); - buffer_append_raw(outData, out_tmp_size, out_tmp); - - vtpmloginfo(VTPM_LOG_TXDATA, "Bind Generated[%d] = 0x", out_tmp_size); - for(i = 0 ; i < out_tmp_size ; i++) { - vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out_tmp[i]); - } - vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); - - goto egress; - abort_egress: - egress: - - // Free flatBoundData - free(flatBoundData); - - return TPM_SUCCESS; -} - -TPM_RESULT VTSP_Seal(const TCS_CONTEXT_HANDLE hContext, - const TPM_KEY_HANDLE keyHandle, - const TPM_AUTHDATA *sealDataAuth, - const TPM_PCR_COMPOSITE *pcrComp, - const buffer_t *inData, - TPM_STORED_DATA *sealedData, - const TPM_SECRET *osapSharedSecret, - TCS_AUTH *auth) { - - TPM_RESULT status = TPM_SUCCESS; - TPM_COMMAND_CODE command = TPM_ORD_Seal; - - BYTE *paramText; // Digest to make Auth. - UINT32 paramTextSize; - - // Generate PCR_Info Struct from Comp - TPM_PCR_INFO pcrInfo; - UINT32 pcrInfoSize, flatpcrSize; - BYTE flatpcr[3 + // PCR_Select = 3 1 byte banks - sizeof(UINT16) + // 2 byte UINT16 - sizeof(UINT32) + // PCR_Comp = 4 byte UINT32 - 24 * sizeof(TPM_PCRVALUE) ]; // up to 24 PCRs - - if (pcrComp != NULL) { - //printf("\n\tBinding to PCRs: "); - //for(int i = 0 ; i < pcrComp->select.sizeOfSelect ; i++) - //printf("%2.2x", pcrComp->select.pcrSelect[i]); - - memcpy(&pcrInfo.pcrSelection, &pcrComp->select, sizeof(TPM_PCR_SELECTION)); - - flatpcrSize = BSG_Pack(BSG_TPM_PCR_COMPOSITE, (BYTE *) pcrComp, flatpcr); - Crypto_SHA1Full((BYTE *) flatpcr, flatpcrSize, (BYTE *) &(pcrInfo.digestAtRelease)); - memset(&(pcrInfo.digestAtCreation), 0, sizeof(TPM_DIGEST)); - pcrInfoSize = BSG_Pack(BSG_TPM_PCR_INFO, (BYTE *) &pcrInfo, flatpcr); - } else { - //printf("\n\tBinding to no PCRS."); - pcrInfoSize = 0; - } - - // Calculate encUsageAuth - BYTE XORbuffer[sizeof(TPM_SECRET) + sizeof(TPM_NONCE)]; - UINT32 XORbufferSize = sizeof(XORbuffer); - TPM_DIGEST XORKey; - TPM_ENCAUTH encAuth; - - BSG_PackList( XORbuffer, 2, - BSG_TPM_SECRET, osapSharedSecret, - BSG_TPM_NONCE, &auth->NonceEven ); - - Crypto_SHA1Full(XORbuffer, XORbufferSize, (BYTE *) &XORKey); - _______________________________________________ Xen-changelog mailing list Xen-changelog@lists.xen.org http://lists.xensource.com/xen-changelog From xen-users-bounces@lists.xen.org Wed Nov 14 12:55:04 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 14 Nov 2012 12:55:04 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYcTk-0003z0-W9; Wed, 14 Nov 2012 12:54:05 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYcTi-0003yv-OB for Xen-users@lists.xen.org; Wed, 14 Nov 2012 12:54:03 +0000 Received: from [85.158.143.99:23313] by server-3.bemta-4.messagelabs.com id D4/A3-06841-A6493A05; Wed, 14 Nov 2012 12:54:02 +0000 X-Env-Sender: ghudiczius@gmail.com X-Msg-Ref: server-8.tower-216.messagelabs.com!1352897637!18961062!1 X-Originating-IP: [209.85.215.173] X-SpamReason: No, hits=1.0 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,UPPERCASE_50_75,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 8592 invoked from network); 14 Nov 2012 12:53:57 -0000 Received: from mail-ea0-f173.google.com (HELO mail-ea0-f173.google.com) (209.85.215.173) by server-8.tower-216.messagelabs.com with RC4-SHA encrypted SMTP; 14 Nov 2012 12:53:57 -0000 Received: by mail-ea0-f173.google.com with SMTP id i13so217551eaa.32 for ; Wed, 14 Nov 2012 04:53:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=message-id:date:from:reply-to:user-agent:mime-version:to:subject :content-type; bh=Nk591CIsUfE5P66tg9irgl57OuWbj6VAqQU4GjpjE+Q=; b=opF0TPavcLD0/ow9TmAwpoRm9LmiPqv5pIBePyTXgnE9oS0lR6YKlGmALOTg3i6tOB Qg7dMhLSlz4Kuzf92l3g1lhoPH8HJZH5ojdicmBYx2rL0ASmXqizlpckiDPDkpwWdWKN SB31bU+5HzJqpyIGDPRNzEtC4f7/u2sAsFv0diBaHB8vneNFsJCCQztpEfQILLmIc2GR JariyJYMHolul8x+fIgp8mm4szOSeDHTYsl0CBOJSKfWq2N0QH/0CUxXi9vgEvyzDOCc 8xaosMHU8e667ItzDqgsqnpSpsWOclSsJem5NJpGaHyLuiqdzF81kTgamY+bjd1cRCzo 43vA== Received: by 10.14.209.136 with SMTP id s8mr86135134eeo.33.1352897637315; Wed, 14 Nov 2012 04:53:57 -0800 (PST) Received: from ?IPv6:2a01:368:e10d::10? ([2a01:368:e10d::10]) by mx.google.com with ESMTPS id s1sm29425979eem.9.2012.11.14.04.53.54 (version=TLSv1/SSLv3 cipher=OTHER); Wed, 14 Nov 2012 04:53:55 -0800 (PST) Message-ID: <50A39477.7020003@gmail.com> Date: Wed, 14 Nov 2012 13:54:15 +0100 From: Gabor Hudiczius User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:16.0) Gecko/20121026 Thunderbird/16.0.2 MIME-Version: 1.0 To: Xen-users@lists.xen.org Content-Type: multipart/mixed; boundary="------------000009040509090906010603" Subject: [Xen-users] The kernel doesn't support reset from sysfs for PCI device... X-BeenThere: xen-users@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: ghudiczius@gmail.com 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 This is a multi-part message in MIME format. --------------000009040509090906010603 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Hi, i have an old proliant dl380 server, running hardened gentoo as Dom0 on Xen 4.2, with several DomUs, also running hardened gentoo. I have PCI passthrough working for a DomU (3 network cards, 2 wired, 1 wireless), but when i try to pass it my usb root hub, i get the following error, during xl create (or when i use xl pci-attach): libxl: error: libxl_pci.c:1001:libxl__device_pci_reset: The kernel doesn't support reset from sysfs for PCI device 0000:00:0f.2 After that, the system (both Dom0 and the DomUs) are terribly slow, sometimes completely inaccessible (took me several minutes to get the dmesg output (see attached for full output) and i get the following: Dom0 dmesg [ 407.581924] xen-pciback[0000:00:0f.2] IRQ line is not shared with other domains. Turning ISR off [ 409.004566] irq 11: nobody cared (try booting with the "irqpoll" option) [...] [ 409.004761] Disabling IRQ #11 xl dmesg (XEN) Cannot bind IRQ11 to dom1. Will not share with others. After that, all i can do is to reset the box. For more information about my config see attachment: kernel config (both Dom0 and DomU): .config DomU config: DomU Dom0 grub config: grub0.conf DomU grub config: grubU.conf lspci -vvv: lspci Dom0 dmesg after the problem: dmesg i've tried to reorganize the pci cards, but that didn't help what can i do to solve this problem? regards, Gabor Hudiczius --------------000009040509090906010603 Content-Type: text/plain; charset=windows-1252; name=".config" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename=".config" # # Automatically generated file; DO NOT EDIT. # Linux/i386 3.5.4-hardened-r1 Kernel Configuration # # CONFIG_64BIT is not set CONFIG_X86_32=y # CONFIG_X86_64 is not set CONFIG_X86=y CONFIG_INSTRUCTION_DECODER=y CONFIG_OUTPUT_FORMAT="elf32-i386" CONFIG_ARCH_DEFCONFIG="arch/x86/configs/i386_defconfig" CONFIG_LOCKDEP_SUPPORT=y CONFIG_STACKTRACE_SUPPORT=y CONFIG_HAVE_LATENCYTOP_SUPPORT=y CONFIG_MMU=y # CONFIG_NEED_DMA_MAP_STATE is not set CONFIG_NEED_SG_DMA_LENGTH=y CONFIG_GENERIC_ISA_DMA=y CONFIG_GENERIC_BUG=y CONFIG_GENERIC_HWEIGHT=y CONFIG_ARCH_MAY_HAVE_PC_FDC=y # CONFIG_RWSEM_GENERIC_SPINLOCK is not set CONFIG_RWSEM_XCHGADD_ALGORITHM=y CONFIG_GENERIC_CALIBRATE_DELAY=y CONFIG_ARCH_HAS_CPU_RELAX=y CONFIG_ARCH_HAS_DEFAULT_IDLE=y CONFIG_ARCH_HAS_CACHE_LINE_SIZE=y CONFIG_ARCH_HAS_CPU_AUTOPROBE=y CONFIG_HAVE_SETUP_PER_CPU_AREA=y CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK=y CONFIG_ARCH_HIBERNATION_POSSIBLE=y CONFIG_ARCH_SUSPEND_POSSIBLE=y # CONFIG_ZONE_DMA32 is not set # CONFIG_AUDIT_ARCH is not set CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING=y CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y CONFIG_X86_32_SMP=y CONFIG_X86_HT=y CONFIG_ARCH_HWEIGHT_CFLAGS="-fcall-saved-ecx -fcall-saved-edx" CONFIG_ARCH_CPU_PROBE_RELEASE=y CONFIG_ARCH_SUPPORTS_UPROBES=y CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" CONFIG_HAVE_IRQ_WORK=y CONFIG_IRQ_WORK=y CONFIG_BUILDTIME_EXTABLE_SORT=y # # General setup # CONFIG_EXPERIMENTAL=y CONFIG_INIT_ENV_ARG_LIMIT=32 CONFIG_CROSS_COMPILE="" CONFIG_LOCALVERSION="" # CONFIG_LOCALVERSION_AUTO is not set CONFIG_HAVE_KERNEL_GZIP=y CONFIG_HAVE_KERNEL_BZIP2=y CONFIG_HAVE_KERNEL_LZMA=y CONFIG_HAVE_KERNEL_XZ=y CONFIG_HAVE_KERNEL_LZO=y CONFIG_KERNEL_GZIP=y # CONFIG_KERNEL_BZIP2 is not set # CONFIG_KERNEL_LZMA is not set # CONFIG_KERNEL_XZ is not set # CONFIG_KERNEL_LZO is not set CONFIG_DEFAULT_HOSTNAME="" CONFIG_SWAP=y CONFIG_SYSVIPC=y CONFIG_SYSVIPC_SYSCTL=y CONFIG_POSIX_MQUEUE=y CONFIG_POSIX_MQUEUE_SYSCTL=y CONFIG_BSD_PROCESS_ACCT=y # CONFIG_BSD_PROCESS_ACCT_V3 is not set # CONFIG_FHANDLE is not set CONFIG_TASKSTATS=y CONFIG_TASK_DELAY_ACCT=y CONFIG_TASK_XACCT=y CONFIG_TASK_IO_ACCOUNTING=y CONFIG_AUDIT=y CONFIG_AUDITSYSCALL=y CONFIG_AUDIT_WATCH=y CONFIG_AUDIT_TREE=y # CONFIG_AUDIT_LOGINUID_IMMUTABLE is not set CONFIG_HAVE_GENERIC_HARDIRQS=y # # IRQ subsystem # CONFIG_GENERIC_HARDIRQS=y CONFIG_GENERIC_IRQ_PROBE=y CONFIG_GENERIC_IRQ_SHOW=y CONFIG_GENERIC_PENDING_IRQ=y CONFIG_IRQ_FORCED_THREADING=y CONFIG_SPARSE_IRQ=y CONFIG_CLOCKSOURCE_WATCHDOG=y CONFIG_KTIME_SCALAR=y CONFIG_GENERIC_CLOCKEVENTS=y CONFIG_GENERIC_CLOCKEVENTS_BUILD=y CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST=y CONFIG_GENERIC_CMOS_UPDATE=y # # Timers subsystem # CONFIG_TICK_ONESHOT=y CONFIG_NO_HZ=y CONFIG_HIGH_RES_TIMERS=y # # RCU Subsystem # CONFIG_TREE_RCU=y # CONFIG_PREEMPT_RCU is not set CONFIG_RCU_FANOUT=32 CONFIG_RCU_FANOUT_LEAF=16 # CONFIG_RCU_FANOUT_EXACT is not set # CONFIG_RCU_FAST_NO_HZ is not set # CONFIG_TREE_RCU_TRACE is not set CONFIG_IKCONFIG=y CONFIG_IKCONFIG_PROC=y CONFIG_LOG_BUF_SHIFT=18 CONFIG_HAVE_UNSTABLE_SCHED_CLOCK=y CONFIG_CGROUPS=y # CONFIG_CGROUP_DEBUG is not set CONFIG_CGROUP_FREEZER=y # CONFIG_CGROUP_DEVICE is not set CONFIG_CPUSETS=y CONFIG_PROC_PID_CPUSET=y CONFIG_CGROUP_CPUACCT=y CONFIG_RESOURCE_COUNTERS=y # CONFIG_CGROUP_MEM_RES_CTLR is not set # CONFIG_CGROUP_PERF is not set CONFIG_CGROUP_SCHED=y CONFIG_FAIR_GROUP_SCHED=y # CONFIG_CFS_BANDWIDTH is not set # CONFIG_RT_GROUP_SCHED is not set # CONFIG_BLK_CGROUP is not set # CONFIG_CHECKPOINT_RESTORE is not set CONFIG_NAMESPACES=y CONFIG_UTS_NS=y CONFIG_IPC_NS=y CONFIG_PID_NS=y CONFIG_NET_NS=y # CONFIG_SCHED_AUTOGROUP is not set # CONFIG_SYSFS_DEPRECATED is not set CONFIG_RELAY=y CONFIG_BLK_DEV_INITRD=y CONFIG_INITRAMFS_SOURCE="" CONFIG_RD_GZIP=y CONFIG_RD_BZIP2=y CONFIG_RD_LZMA=y CONFIG_RD_XZ=y CONFIG_RD_LZO=y # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set CONFIG_SYSCTL=y CONFIG_ANON_INODES=y # CONFIG_EXPERT is not set CONFIG_UID16=y # CONFIG_SYSCTL_SYSCALL is not set CONFIG_KALLSYMS=y # CONFIG_KALLSYMS_ALL is not set CONFIG_HOTPLUG=y CONFIG_PRINTK=y CONFIG_BUG=y CONFIG_ELF_CORE=y CONFIG_PCSPKR_PLATFORM=y CONFIG_HAVE_PCSPKR_PLATFORM=y CONFIG_BASE_FULL=y CONFIG_FUTEX=y CONFIG_EPOLL=y CONFIG_SIGNALFD=y CONFIG_TIMERFD=y CONFIG_EVENTFD=y CONFIG_SHMEM=y CONFIG_AIO=y # CONFIG_EMBEDDED is not set CONFIG_HAVE_PERF_EVENTS=y # # Kernel Performance Events And Counters # CONFIG_PERF_EVENTS=y # CONFIG_DEBUG_PERF_USE_VMALLOC is not set CONFIG_VM_EVENT_COUNTERS=y CONFIG_PCI_QUIRKS=y CONFIG_SLUB_DEBUG=y # CONFIG_COMPAT_BRK is not set # CONFIG_SLAB is not set CONFIG_SLUB=y CONFIG_PROFILING=y CONFIG_TRACEPOINTS=y # CONFIG_OPROFILE is not set CONFIG_HAVE_OPROFILE=y CONFIG_OPROFILE_NMI_TIMER=y CONFIG_KPROBES=y # CONFIG_JUMP_LABEL is not set CONFIG_OPTPROBES=y CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y CONFIG_KRETPROBES=y CONFIG_HAVE_IOREMAP_PROT=y CONFIG_HAVE_KPROBES=y CONFIG_HAVE_KRETPROBES=y CONFIG_HAVE_OPTPROBES=y CONFIG_HAVE_ARCH_TRACEHOOK=y CONFIG_HAVE_DMA_ATTRS=y CONFIG_USE_GENERIC_SMP_HELPERS=y CONFIG_GENERIC_SMP_IDLE_THREAD=y CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y CONFIG_HAVE_DMA_API_DEBUG=y CONFIG_HAVE_HW_BREAKPOINT=y CONFIG_HAVE_MIXED_BREAKPOINTS_REGS=y CONFIG_HAVE_USER_RETURN_NOTIFIER=y CONFIG_HAVE_PERF_EVENTS_NMI=y CONFIG_HAVE_ARCH_JUMP_LABEL=y CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG=y CONFIG_HAVE_ALIGNED_STRUCT_PAGE=y CONFIG_HAVE_CMPXCHG_LOCAL=y CONFIG_HAVE_CMPXCHG_DOUBLE=y CONFIG_HAVE_ARCH_SECCOMP_FILTER=y CONFIG_SECCOMP_FILTER=y # # GCOV-based kernel profiling # # CONFIG_GCOV_KERNEL is not set CONFIG_HAVE_GENERIC_DMA_COHERENT=y CONFIG_SLABINFO=y CONFIG_RT_MUTEXES=y CONFIG_BASE_SMALL=0 CONFIG_MODULES=y # CONFIG_MODULE_FORCE_LOAD is not set CONFIG_MODULE_UNLOAD=y CONFIG_MODULE_FORCE_UNLOAD=y # CONFIG_MODVERSIONS is not set # CONFIG_MODULE_SRCVERSION_ALL is not set CONFIG_STOP_MACHINE=y CONFIG_BLOCK=y CONFIG_LBDAF=y CONFIG_BLK_DEV_BSG=y # CONFIG_BLK_DEV_BSGLIB is not set # CONFIG_BLK_DEV_INTEGRITY is not set # # Partition Types # # CONFIG_PARTITION_ADVANCED is not set CONFIG_MSDOS_PARTITION=y # # IO Schedulers # CONFIG_IOSCHED_NOOP=y CONFIG_IOSCHED_DEADLINE=y CONFIG_IOSCHED_CFQ=y # CONFIG_DEFAULT_DEADLINE is not set CONFIG_DEFAULT_CFQ=y # CONFIG_DEFAULT_NOOP is not set CONFIG_DEFAULT_IOSCHED="cfq" # CONFIG_INLINE_SPIN_TRYLOCK is not set # CONFIG_INLINE_SPIN_TRYLOCK_BH is not set # CONFIG_INLINE_SPIN_LOCK is not set # CONFIG_INLINE_SPIN_LOCK_BH is not set # CONFIG_INLINE_SPIN_LOCK_IRQ is not set # CONFIG_INLINE_SPIN_LOCK_IRQSAVE is not set # CONFIG_INLINE_SPIN_UNLOCK_BH is not set CONFIG_INLINE_SPIN_UNLOCK_IRQ=y # CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE is not set # CONFIG_INLINE_READ_TRYLOCK is not set # CONFIG_INLINE_READ_LOCK is not set # CONFIG_INLINE_READ_LOCK_BH is not set # CONFIG_INLINE_READ_LOCK_IRQ is not set # CONFIG_INLINE_READ_LOCK_IRQSAVE is not set CONFIG_INLINE_READ_UNLOCK=y # CONFIG_INLINE_READ_UNLOCK_BH is not set CONFIG_INLINE_READ_UNLOCK_IRQ=y # CONFIG_INLINE_READ_UNLOCK_IRQRESTORE is not set # CONFIG_INLINE_WRITE_TRYLOCK is not set # CONFIG_INLINE_WRITE_LOCK is not set # CONFIG_INLINE_WRITE_LOCK_BH is not set # CONFIG_INLINE_WRITE_LOCK_IRQ is not set # CONFIG_INLINE_WRITE_LOCK_IRQSAVE is not set CONFIG_INLINE_WRITE_UNLOCK=y # CONFIG_INLINE_WRITE_UNLOCK_BH is not set CONFIG_INLINE_WRITE_UNLOCK_IRQ=y # CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE is not set CONFIG_MUTEX_SPIN_ON_OWNER=y CONFIG_FREEZER=y # # Processor type and features # CONFIG_ZONE_DMA=y CONFIG_SMP=y CONFIG_X86_MPPARSE=y # CONFIG_X86_BIGSMP is not set CONFIG_X86_EXTENDED_PLATFORM=y # CONFIG_X86_WANT_INTEL_MID is not set # CONFIG_X86_RDC321X is not set # CONFIG_X86_32_NON_STANDARD is not set CONFIG_X86_SUPPORTS_MEMORY_FAILURE=y # CONFIG_X86_32_IRIS is not set CONFIG_SCHED_OMIT_FRAME_POINTER=y CONFIG_PARAVIRT_GUEST=y # CONFIG_PARAVIRT_TIME_ACCOUNTING is not set CONFIG_XEN=y CONFIG_XEN_DOM0=y CONFIG_XEN_PRIVILEGED_GUEST=y CONFIG_XEN_PVHVM=y CONFIG_XEN_MAX_DOMAIN_MEMORY=64 CONFIG_XEN_SAVE_RESTORE=y # CONFIG_XEN_DEBUG_FS is not set # CONFIG_KVM_CLOCK is not set # CONFIG_KVM_GUEST is not set # CONFIG_LGUEST_GUEST is not set CONFIG_PARAVIRT=y CONFIG_PARAVIRT_SPINLOCKS=y CONFIG_PARAVIRT_CLOCK=y # CONFIG_PARAVIRT_DEBUG is not set CONFIG_NO_BOOTMEM=y # CONFIG_MEMTEST is not set # CONFIG_M386 is not set # CONFIG_M486 is not set # CONFIG_M586 is not set # CONFIG_M586TSC is not set # CONFIG_M586MMX is not set # CONFIG_M686 is not set # CONFIG_MPENTIUMII is not set # CONFIG_MPENTIUMIII is not set # CONFIG_MPENTIUMM is not set CONFIG_MPENTIUM4=y # CONFIG_MK6 is not set # CONFIG_MK7 is not set # CONFIG_MK8 is not set # CONFIG_MCRUSOE is not set # CONFIG_MEFFICEON is not set # CONFIG_MWINCHIPC6 is not set # CONFIG_MWINCHIP3D is not set # CONFIG_MELAN is not set # CONFIG_MGEODEGX1 is not set # CONFIG_MGEODE_LX is not set # CONFIG_MCYRIXIII is not set # CONFIG_MVIAC3_2 is not set # CONFIG_MVIAC7 is not set # CONFIG_MCORE2 is not set # CONFIG_MATOM is not set CONFIG_X86_GENERIC=y CONFIG_X86_INTERNODE_CACHE_SHIFT=7 CONFIG_X86_CMPXCHG=y CONFIG_X86_L1_CACHE_SHIFT=7 CONFIG_X86_XADD=y CONFIG_X86_WP_WORKS_OK=y CONFIG_X86_INVLPG=y CONFIG_X86_BSWAP=y CONFIG_X86_POPAD_OK=y CONFIG_X86_ALIGNMENT_16=y CONFIG_X86_INTEL_USERCOPY=y CONFIG_X86_USE_PPRO_CHECKSUM=y CONFIG_X86_TSC=y CONFIG_X86_CMPXCHG64=y CONFIG_X86_CMOV=y CONFIG_X86_MINIMUM_CPU_FAMILY=5 CONFIG_X86_DEBUGCTLMSR=y CONFIG_CPU_SUP_INTEL=y CONFIG_CPU_SUP_AMD=y CONFIG_CPU_SUP_CENTAUR=y CONFIG_CPU_SUP_TRANSMETA_32=y # CONFIG_HPET_TIMER is not set CONFIG_DMI=y CONFIG_SWIOTLB=y CONFIG_IOMMU_HELPER=y CONFIG_NR_CPUS=8 # CONFIG_SCHED_SMT is not set CONFIG_SCHED_MC=y # CONFIG_IRQ_TIME_ACCOUNTING is not set CONFIG_PREEMPT_NONE=y # CONFIG_PREEMPT_VOLUNTARY is not set # CONFIG_PREEMPT is not set CONFIG_X86_LOCAL_APIC=y CONFIG_X86_IO_APIC=y # CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS is not set CONFIG_X86_MCE=y CONFIG_X86_MCE_INTEL=y CONFIG_X86_MCE_AMD=y # CONFIG_X86_ANCIENT_MCE is not set CONFIG_X86_MCE_THRESHOLD=y # CONFIG_X86_MCE_INJECT is not set CONFIG_X86_THERMAL_VECTOR=y CONFIG_VM86=y # CONFIG_TOSHIBA is not set # CONFIG_I8K is not set # CONFIG_X86_REBOOTFIXUPS is not set CONFIG_MICROCODE=y CONFIG_MICROCODE_INTEL=y # CONFIG_MICROCODE_AMD is not set CONFIG_MICROCODE_OLD_INTERFACE=y CONFIG_X86_MSR=y CONFIG_X86_CPUID=y # CONFIG_NOHIGHMEM is not set # CONFIG_HIGHMEM4G is not set CONFIG_HIGHMEM64G=y CONFIG_PAGE_OFFSET=0xC0000000 CONFIG_HIGHMEM=y CONFIG_X86_PAE=y CONFIG_ARCH_PHYS_ADDR_T_64BIT=y CONFIG_ARCH_DMA_ADDR_T_64BIT=y CONFIG_ARCH_FLATMEM_ENABLE=y CONFIG_ARCH_SPARSEMEM_ENABLE=y CONFIG_ARCH_SELECT_MEMORY_MODEL=y CONFIG_ILLEGAL_POINTER_VALUE=0 CONFIG_SELECT_MEMORY_MODEL=y CONFIG_FLATMEM_MANUAL=y # CONFIG_SPARSEMEM_MANUAL is not set CONFIG_FLATMEM=y CONFIG_FLAT_NODE_MEM_MAP=y CONFIG_SPARSEMEM_STATIC=y CONFIG_HAVE_MEMBLOCK=y CONFIG_HAVE_MEMBLOCK_NODE_MAP=y CONFIG_ARCH_DISCARD_MEMBLOCK=y CONFIG_PAGEFLAGS_EXTENDED=y CONFIG_SPLIT_PTLOCK_CPUS=4 # CONFIG_COMPACTION is not set CONFIG_PHYS_ADDR_T_64BIT=y CONFIG_ZONE_DMA_FLAG=1 CONFIG_BOUNCE=y CONFIG_VIRT_TO_BUS=y CONFIG_MMU_NOTIFIER=y # CONFIG_KSM is not set CONFIG_DEFAULT_MMAP_MIN_ADDR=65536 CONFIG_ARCH_SUPPORTS_MEMORY_FAILURE=y # CONFIG_MEMORY_FAILURE is not set # CONFIG_TRANSPARENT_HUGEPAGE is not set CONFIG_CROSS_MEMORY_ATTACH=y CONFIG_CLEANCACHE=y CONFIG_FRONTSWAP=y # CONFIG_HIGHPTE is not set # CONFIG_X86_CHECK_BIOS_CORRUPTION is not set CONFIG_X86_RESERVE_LOW=64 # CONFIG_MATH_EMULATION is not set CONFIG_MTRR=y CONFIG_MTRR_SANITIZER=y CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT=0 CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT=1 CONFIG_X86_PAT=y CONFIG_ARCH_USES_PG_UNCACHED=y CONFIG_ARCH_RANDOM=y # CONFIG_EFI is not set CONFIG_SECCOMP=y CONFIG_CC_STACKPROTECTOR=y CONFIG_HZ_100=y # CONFIG_HZ_250 is not set # CONFIG_HZ_300 is not set # CONFIG_HZ_1000 is not set CONFIG_HZ=100 CONFIG_SCHED_HRTICK=y CONFIG_KEXEC=y # CONFIG_CRASH_DUMP is not set CONFIG_PHYSICAL_START=0x1000000 CONFIG_RELOCATABLE=y CONFIG_X86_NEED_RELOCS=y CONFIG_PHYSICAL_ALIGN=0x2000 CONFIG_HOTPLUG_CPU=y # CONFIG_COMPAT_VDSO is not set # CONFIG_CMDLINE_BOOL is not set CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y # # Power management and ACPI options # CONFIG_SUSPEND=y CONFIG_SUSPEND_FREEZER=y CONFIG_HIBERNATE_CALLBACKS=y # CONFIG_HIBERNATION is not set CONFIG_PM_SLEEP=y CONFIG_PM_SLEEP_SMP=y # CONFIG_PM_AUTOSLEEP is not set # CONFIG_PM_WAKELOCKS is not set # CONFIG_PM_RUNTIME is not set CONFIG_PM=y # CONFIG_PM_DEBUG is not set CONFIG_ACPI=y CONFIG_ACPI_SLEEP=y # CONFIG_ACPI_PROCFS is not set # CONFIG_ACPI_PROCFS_POWER is not set # CONFIG_ACPI_EC_DEBUGFS is not set CONFIG_ACPI_PROC_EVENT=y CONFIG_ACPI_AC=y CONFIG_ACPI_BATTERY=y CONFIG_ACPI_BUTTON=y CONFIG_ACPI_VIDEO=y CONFIG_ACPI_FAN=y # CONFIG_ACPI_DOCK is not set CONFIG_ACPI_PROCESSOR=y CONFIG_ACPI_IPMI=y CONFIG_ACPI_HOTPLUG_CPU=y # CONFIG_ACPI_PROCESSOR_AGGREGATOR is not set CONFIG_ACPI_THERMAL=y # CONFIG_ACPI_CUSTOM_DSDT is not set CONFIG_ACPI_BLACKLIST_YEAR=0 # CONFIG_ACPI_DEBUG is not set # CONFIG_ACPI_PCI_SLOT is not set CONFIG_X86_PM_TIMER=y CONFIG_ACPI_CONTAINER=y # CONFIG_ACPI_SBS is not set # CONFIG_ACPI_HED is not set # CONFIG_ACPI_CUSTOM_METHOD is not set # CONFIG_ACPI_BGRT is not set # CONFIG_ACPI_APEI is not set # CONFIG_SFI is not set # CONFIG_APM is not set # # CPU Frequency scaling # # CONFIG_CPU_FREQ is not set CONFIG_CPU_IDLE=y CONFIG_CPU_IDLE_GOV_LADDER=y CONFIG_CPU_IDLE_GOV_MENU=y # CONFIG_INTEL_IDLE is not set # # Bus options (PCI etc.) # CONFIG_PCI=y # CONFIG_PCI_GOBIOS is not set # CONFIG_PCI_GOMMCONFIG is not set # CONFIG_PCI_GODIRECT is not set CONFIG_PCI_GOANY=y CONFIG_PCI_BIOS=y CONFIG_PCI_DIRECT=y CONFIG_PCI_MMCONFIG=y CONFIG_PCI_XEN=y CONFIG_PCI_DOMAINS=y # CONFIG_PCI_CNB20LE_QUIRK is not set # CONFIG_PCIEPORTBUS is not set CONFIG_ARCH_SUPPORTS_MSI=y CONFIG_PCI_MSI=y # CONFIG_PCI_DEBUG is not set # CONFIG_PCI_REALLOC_ENABLE_AUTO is not set # CONFIG_PCI_STUB is not set CONFIG_XEN_PCIDEV_FRONTEND=y CONFIG_HT_IRQ=y # CONFIG_PCI_IOV is not set # CONFIG_PCI_PRI is not set # CONFIG_PCI_PASID is not set # CONFIG_PCI_IOAPIC is not set CONFIG_PCI_LABEL=y CONFIG_ISA_DMA_API=y # CONFIG_ISA is not set # CONFIG_SCx200 is not set # CONFIG_ALIX is not set # CONFIG_NET5501 is not set # CONFIG_GEOS is not set CONFIG_AMD_NB=y # CONFIG_PCCARD is not set CONFIG_HOTPLUG_PCI=y # CONFIG_HOTPLUG_PCI_FAKE is not set # CONFIG_HOTPLUG_PCI_COMPAQ is not set # CONFIG_HOTPLUG_PCI_IBM is not set # CONFIG_HOTPLUG_PCI_ACPI is not set # CONFIG_HOTPLUG_PCI_CPCI is not set # CONFIG_HOTPLUG_PCI_SHPC is not set # CONFIG_RAPIDIO is not set # # Executable file formats / Emulations # CONFIG_BINFMT_ELF=y CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE=y CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y CONFIG_HAVE_AOUT=y CONFIG_BINFMT_MISC=y CONFIG_HAVE_ATOMIC_IOMAP=y CONFIG_HAVE_TEXT_POKE_SMP=y CONFIG_NET=y # # Networking options # CONFIG_PACKET=y CONFIG_UNIX=y # CONFIG_UNIX_DIAG is not set CONFIG_XFRM=y CONFIG_XFRM_ALGO=y CONFIG_XFRM_USER=y # CONFIG_XFRM_SUB_POLICY is not set # CONFIG_XFRM_MIGRATE is not set # CONFIG_XFRM_STATISTICS is not set # CONFIG_NET_KEY is not set CONFIG_INET=y CONFIG_IP_MULTICAST=y CONFIG_IP_ADVANCED_ROUTER=y # CONFIG_IP_FIB_TRIE_STATS is not set CONFIG_IP_MULTIPLE_TABLES=y CONFIG_IP_ROUTE_MULTIPATH=y CONFIG_IP_ROUTE_VERBOSE=y CONFIG_IP_PNP=y CONFIG_IP_PNP_DHCP=y CONFIG_IP_PNP_BOOTP=y CONFIG_IP_PNP_RARP=y # CONFIG_NET_IPIP is not set # CONFIG_NET_IPGRE_DEMUX is not set CONFIG_IP_MROUTE=y # CONFIG_IP_MROUTE_MULTIPLE_TABLES is not set CONFIG_IP_PIMSM_V1=y CONFIG_IP_PIMSM_V2=y # CONFIG_ARPD is not set CONFIG_SYN_COOKIES=y # CONFIG_INET_AH is not set # CONFIG_INET_ESP is not set # CONFIG_INET_IPCOMP is not set # CONFIG_INET_XFRM_TUNNEL is not set CONFIG_INET_TUNNEL=y # CONFIG_INET_XFRM_MODE_TRANSPORT is not set # CONFIG_INET_XFRM_MODE_TUNNEL is not set # CONFIG_INET_XFRM_MODE_BEET is not set CONFIG_INET_LRO=y # CONFIG_INET_DIAG is not set CONFIG_TCP_CONG_ADVANCED=y # CONFIG_TCP_CONG_BIC is not set CONFIG_TCP_CONG_CUBIC=y # CONFIG_TCP_CONG_WESTWOOD is not set # CONFIG_TCP_CONG_HTCP is not set # CONFIG_TCP_CONG_HSTCP is not set # CONFIG_TCP_CONG_HYBLA is not set # CONFIG_TCP_CONG_VEGAS is not set # CONFIG_TCP_CONG_SCALABLE is not set # CONFIG_TCP_CONG_LP is not set # CONFIG_TCP_CONG_VENO is not set # CONFIG_TCP_CONG_YEAH is not set # CONFIG_TCP_CONG_ILLINOIS is not set CONFIG_DEFAULT_CUBIC=y # CONFIG_DEFAULT_RENO is not set CONFIG_DEFAULT_TCP_CONG="cubic" CONFIG_TCP_MD5SIG=y CONFIG_IPV6=y # CONFIG_IPV6_PRIVACY is not set # CONFIG_IPV6_ROUTER_PREF is not set # CONFIG_IPV6_OPTIMISTIC_DAD is not set CONFIG_INET6_AH=y CONFIG_INET6_ESP=y # CONFIG_INET6_IPCOMP is not set # CONFIG_IPV6_MIP6 is not set # CONFIG_INET6_XFRM_TUNNEL is not set # CONFIG_INET6_TUNNEL is not set CONFIG_INET6_XFRM_MODE_TRANSPORT=y CONFIG_INET6_XFRM_MODE_TUNNEL=y CONFIG_INET6_XFRM_MODE_BEET=y # CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION is not set CONFIG_IPV6_SIT=y # CONFIG_IPV6_SIT_6RD is not set CONFIG_IPV6_NDISC_NODETYPE=y # CONFIG_IPV6_TUNNEL is not set # CONFIG_IPV6_MULTIPLE_TABLES is not set # CONFIG_IPV6_MROUTE is not set CONFIG_NETLABEL=y CONFIG_NETWORK_SECMARK=y # CONFIG_NETWORK_PHY_TIMESTAMPING is not set CONFIG_NETFILTER=y # CONFIG_NETFILTER_DEBUG is not set CONFIG_NETFILTER_ADVANCED=y CONFIG_BRIDGE_NETFILTER=y # # Core Netfilter Configuration # CONFIG_NETFILTER_NETLINK=y # CONFIG_NETFILTER_NETLINK_ACCT is not set CONFIG_NETFILTER_NETLINK_QUEUE=y CONFIG_NETFILTER_NETLINK_LOG=y CONFIG_NF_CONNTRACK=y CONFIG_NF_CONNTRACK_MARK=y CONFIG_NF_CONNTRACK_SECMARK=y CONFIG_NF_CONNTRACK_PROCFS=y # CONFIG_NF_CONNTRACK_EVENTS is not set # CONFIG_NF_CONNTRACK_TIMEOUT is not set # CONFIG_NF_CONNTRACK_TIMESTAMP is not set # CONFIG_NF_CT_PROTO_DCCP is not set # CONFIG_NF_CT_PROTO_SCTP is not set # CONFIG_NF_CT_PROTO_UDPLITE is not set # CONFIG_NF_CONNTRACK_AMANDA is not set CONFIG_NF_CONNTRACK_FTP=y # CONFIG_NF_CONNTRACK_H323 is not set CONFIG_NF_CONNTRACK_IRC=y # CONFIG_NF_CONNTRACK_NETBIOS_NS is not set # CONFIG_NF_CONNTRACK_SNMP is not set # CONFIG_NF_CONNTRACK_PPTP is not set # CONFIG_NF_CONNTRACK_SANE is not set CONFIG_NF_CONNTRACK_SIP=y # CONFIG_NF_CONNTRACK_TFTP is not set CONFIG_NF_CT_NETLINK=y # CONFIG_NF_CT_NETLINK_TIMEOUT is not set # CONFIG_NETFILTER_TPROXY is not set CONFIG_NETFILTER_XTABLES=y # # Xtables combined modules # CONFIG_NETFILTER_XT_MARK=y CONFIG_NETFILTER_XT_CONNMARK=y # # Xtables targets # # CONFIG_NETFILTER_XT_TARGET_AUDIT is not set # CONFIG_NETFILTER_XT_TARGET_CHECKSUM is not set # CONFIG_NETFILTER_XT_TARGET_CLASSIFY is not set CONFIG_NETFILTER_XT_TARGET_CONNMARK=y CONFIG_NETFILTER_XT_TARGET_CONNSECMARK=y # CONFIG_NETFILTER_XT_TARGET_DSCP is not set # CONFIG_NETFILTER_XT_TARGET_HL is not set # CONFIG_NETFILTER_XT_TARGET_HMARK is not set # CONFIG_NETFILTER_XT_TARGET_IDLETIMER is not set # CONFIG_NETFILTER_XT_TARGET_LED is not set # CONFIG_NETFILTER_XT_TARGET_LOG is not set CONFIG_NETFILTER_XT_TARGET_MARK=y CONFIG_NETFILTER_XT_TARGET_NFLOG=y CONFIG_NETFILTER_XT_TARGET_NFQUEUE=y # CONFIG_NETFILTER_XT_TARGET_RATEEST is not set # CONFIG_NETFILTER_XT_TARGET_TEE is not set CONFIG_NETFILTER_XT_TARGET_SECMARK=y CONFIG_NETFILTER_XT_TARGET_TCPMSS=y # CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set # # Xtables matches # # CONFIG_NETFILTER_XT_MATCH_ADDRTYPE is not set # CONFIG_NETFILTER_XT_MATCH_CLUSTER is not set CONFIG_NETFILTER_XT_MATCH_COMMENT=y CONFIG_NETFILTER_XT_MATCH_CONNBYTES=y CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=y CONFIG_NETFILTER_XT_MATCH_CONNMARK=y CONFIG_NETFILTER_XT_MATCH_CONNTRACK=y # CONFIG_NETFILTER_XT_MATCH_CPU is not set # CONFIG_NETFILTER_XT_MATCH_DCCP is not set # CONFIG_NETFILTER_XT_MATCH_DEVGROUP is not set # CONFIG_NETFILTER_XT_MATCH_DSCP is not set # CONFIG_NETFILTER_XT_MATCH_ECN is not set # CONFIG_NETFILTER_XT_MATCH_ESP is not set CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=y # CONFIG_NETFILTER_XT_MATCH_HELPER is not set # CONFIG_NETFILTER_XT_MATCH_HL is not set CONFIG_NETFILTER_XT_MATCH_IPRANGE=y # CONFIG_NETFILTER_XT_MATCH_LENGTH is not set CONFIG_NETFILTER_XT_MATCH_LIMIT=y # CONFIG_NETFILTER_XT_MATCH_MAC is not set CONFIG_NETFILTER_XT_MATCH_MARK=y CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y # CONFIG_NETFILTER_XT_MATCH_NFACCT is not set # CONFIG_NETFILTER_XT_MATCH_OSF is not set CONFIG_NETFILTER_XT_MATCH_OWNER=y CONFIG_NETFILTER_XT_MATCH_POLICY=y # CONFIG_NETFILTER_XT_MATCH_PHYSDEV is not set # CONFIG_NETFILTER_XT_MATCH_PKTTYPE is not set CONFIG_NETFILTER_XT_MATCH_QUOTA=y # CONFIG_NETFILTER_XT_MATCH_RATEEST is not set # CONFIG_NETFILTER_XT_MATCH_REALM is not set # CONFIG_NETFILTER_XT_MATCH_RECENT is not set # CONFIG_NETFILTER_XT_MATCH_SCTP is not set CONFIG_NETFILTER_XT_MATCH_STATE=y # CONFIG_NETFILTER_XT_MATCH_STATISTIC is not set # CONFIG_NETFILTER_XT_MATCH_STRING is not set # CONFIG_NETFILTER_XT_MATCH_TCPMSS is not set # CONFIG_NETFILTER_XT_MATCH_TIME is not set # CONFIG_NETFILTER_XT_MATCH_U32 is not set # CONFIG_IP_SET is not set # CONFIG_IP_VS is not set # # IP: Netfilter Configuration # CONFIG_NF_DEFRAG_IPV4=y CONFIG_NF_CONNTRACK_IPV4=y CONFIG_NF_CONNTRACK_PROC_COMPAT=y # CONFIG_IP_NF_QUEUE is not set CONFIG_IP_NF_IPTABLES=y # CONFIG_IP_NF_MATCH_AH is not set # CONFIG_IP_NF_MATCH_ECN is not set # CONFIG_IP_NF_MATCH_RPFILTER is not set # CONFIG_IP_NF_MATCH_TTL is not set CONFIG_IP_NF_FILTER=y CONFIG_IP_NF_TARGET_REJECT=y CONFIG_IP_NF_TARGET_ULOG=y CONFIG_NF_NAT=y CONFIG_NF_NAT_NEEDED=y CONFIG_IP_NF_TARGET_MASQUERADE=y # CONFIG_IP_NF_TARGET_NETMAP is not set # CONFIG_IP_NF_TARGET_REDIRECT is not set CONFIG_NF_NAT_FTP=y CONFIG_NF_NAT_IRC=y # CONFIG_NF_NAT_TFTP is not set # CONFIG_NF_NAT_AMANDA is not set # CONFIG_NF_NAT_PPTP is not set # CONFIG_NF_NAT_H323 is not set CONFIG_NF_NAT_SIP=y CONFIG_IP_NF_MANGLE=y # CONFIG_IP_NF_TARGET_CLUSTERIP is not set # CONFIG_IP_NF_TARGET_ECN is not set # CONFIG_IP_NF_TARGET_TTL is not set # CONFIG_IP_NF_RAW is not set # CONFIG_IP_NF_SECURITY is not set # CONFIG_IP_NF_ARPTABLES is not set # # IPv6: Netfilter Configuration # CONFIG_NF_DEFRAG_IPV6=y CONFIG_NF_CONNTRACK_IPV6=y CONFIG_IP6_NF_IPTABLES=y # CONFIG_IP6_NF_MATCH_AH is not set # CONFIG_IP6_NF_MATCH_EUI64 is not set # CONFIG_IP6_NF_MATCH_FRAG is not set # CONFIG_IP6_NF_MATCH_OPTS is not set # CONFIG_IP6_NF_MATCH_HL is not set CONFIG_IP6_NF_MATCH_IPV6HEADER=y CONFIG_IP6_NF_MATCH_MH=y # CONFIG_IP6_NF_MATCH_RPFILTER is not set # CONFIG_IP6_NF_MATCH_RT is not set # CONFIG_IP6_NF_TARGET_HL is not set CONFIG_IP6_NF_FILTER=y CONFIG_IP6_NF_TARGET_REJECT=y CONFIG_IP6_NF_MANGLE=y # CONFIG_IP6_NF_RAW is not set # CONFIG_IP6_NF_SECURITY is not set # CONFIG_BRIDGE_NF_EBTABLES is not set # CONFIG_IP_DCCP is not set # CONFIG_IP_SCTP is not set # CONFIG_RDS is not set # CONFIG_TIPC is not set # CONFIG_ATM is not set # CONFIG_L2TP is not set CONFIG_STP=y CONFIG_BRIDGE=y CONFIG_BRIDGE_IGMP_SNOOPING=y # CONFIG_NET_DSA is not set # CONFIG_VLAN_8021Q is not set # CONFIG_DECNET is not set CONFIG_LLC=y # CONFIG_LLC2 is not set # CONFIG_IPX is not set # CONFIG_ATALK is not set # CONFIG_X25 is not set # CONFIG_LAPB is not set # CONFIG_WAN_ROUTER is not set # CONFIG_PHONET is not set # CONFIG_IEEE802154 is not set CONFIG_NET_SCHED=y # # Queueing/Scheduling # # CONFIG_NET_SCH_CBQ is not set # CONFIG_NET_SCH_HTB is not set # CONFIG_NET_SCH_HFSC is not set # CONFIG_NET_SCH_PRIO is not set # CONFIG_NET_SCH_MULTIQ is not set # CONFIG_NET_SCH_RED is not set # CONFIG_NET_SCH_SFB is not set # CONFIG_NET_SCH_SFQ is not set # CONFIG_NET_SCH_TEQL is not set # CONFIG_NET_SCH_TBF is not set # CONFIG_NET_SCH_GRED is not set # CONFIG_NET_SCH_DSMARK is not set # CONFIG_NET_SCH_NETEM is not set # CONFIG_NET_SCH_DRR is not set # CONFIG_NET_SCH_MQPRIO is not set # CONFIG_NET_SCH_CHOKE is not set # CONFIG_NET_SCH_QFQ is not set # CONFIG_NET_SCH_CODEL is not set # CONFIG_NET_SCH_FQ_CODEL is not set # CONFIG_NET_SCH_INGRESS is not set # CONFIG_NET_SCH_PLUG is not set # # Classification # CONFIG_NET_CLS=y # CONFIG_NET_CLS_BASIC is not set # CONFIG_NET_CLS_TCINDEX is not set # CONFIG_NET_CLS_ROUTE4 is not set # CONFIG_NET_CLS_FW is not set # CONFIG_NET_CLS_U32 is not set # CONFIG_NET_CLS_RSVP is not set # CONFIG_NET_CLS_RSVP6 is not set # CONFIG_NET_CLS_FLOW is not set # CONFIG_NET_CLS_CGROUP is not set CONFIG_NET_EMATCH=y CONFIG_NET_EMATCH_STACK=32 # CONFIG_NET_EMATCH_CMP is not set # CONFIG_NET_EMATCH_NBYTE is not set # CONFIG_NET_EMATCH_U32 is not set # CONFIG_NET_EMATCH_META is not set # CONFIG_NET_EMATCH_TEXT is not set CONFIG_NET_CLS_ACT=y # CONFIG_NET_ACT_POLICE is not set # CONFIG_NET_ACT_GACT is not set # CONFIG_NET_ACT_MIRRED is not set # CONFIG_NET_ACT_IPT is not set # CONFIG_NET_ACT_NAT is not set # CONFIG_NET_ACT_PEDIT is not set # CONFIG_NET_ACT_SIMP is not set # CONFIG_NET_ACT_SKBEDIT is not set # CONFIG_NET_ACT_CSUM is not set CONFIG_NET_SCH_FIFO=y # CONFIG_DCB is not set CONFIG_DNS_RESOLVER=y # CONFIG_BATMAN_ADV is not set # CONFIG_OPENVSWITCH is not set CONFIG_RPS=y CONFIG_RFS_ACCEL=y CONFIG_XPS=y # CONFIG_NETPRIO_CGROUP is not set CONFIG_BQL=y # # Network testing # # CONFIG_NET_PKTGEN is not set # CONFIG_NET_TCPPROBE is not set # CONFIG_NET_DROP_MONITOR is not set # CONFIG_HAMRADIO is not set # CONFIG_CAN is not set # CONFIG_IRDA is not set # CONFIG_BT is not set # CONFIG_AF_RXRPC is not set CONFIG_FIB_RULES=y CONFIG_WIRELESS=y CONFIG_WEXT_CORE=y CONFIG_WEXT_PROC=y CONFIG_CFG80211=y # CONFIG_NL80211_TESTMODE is not set # CONFIG_CFG80211_DEVELOPER_WARNINGS is not set # CONFIG_CFG80211_REG_DEBUG is not set CONFIG_CFG80211_DEFAULT_PS=y # CONFIG_CFG80211_DEBUGFS is not set # CONFIG_CFG80211_INTERNAL_REGDB is not set CONFIG_CFG80211_WEXT=y CONFIG_WIRELESS_EXT_SYSFS=y # CONFIG_LIB80211 is not set CONFIG_MAC80211=y CONFIG_MAC80211_HAS_RC=y CONFIG_MAC80211_RC_MINSTREL=y CONFIG_MAC80211_RC_MINSTREL_HT=y CONFIG_MAC80211_RC_DEFAULT_MINSTREL=y CONFIG_MAC80211_RC_DEFAULT="minstrel_ht" # CONFIG_MAC80211_MESH is not set CONFIG_MAC80211_LEDS=y # CONFIG_MAC80211_DEBUGFS is not set # CONFIG_MAC80211_DEBUG_MENU is not set # CONFIG_WIMAX is not set # CONFIG_RFKILL is not set # CONFIG_NET_9P is not set # CONFIG_CAIF is not set # CONFIG_CEPH_LIB is not set # CONFIG_NFC is not set # # Device Drivers # # # Generic Driver Options # CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug" CONFIG_DEVTMPFS=y CONFIG_DEVTMPFS_MOUNT=y CONFIG_STANDALONE=y CONFIG_PREVENT_FIRMWARE_BUILD=y CONFIG_FW_LOADER=y CONFIG_FIRMWARE_IN_KERNEL=y CONFIG_EXTRA_FIRMWARE="" # CONFIG_DEBUG_DRIVER is not set CONFIG_DEBUG_DEVRES=y CONFIG_SYS_HYPERVISOR=y # CONFIG_GENERIC_CPU_DEVICES is not set CONFIG_DMA_SHARED_BUFFER=y CONFIG_CONNECTOR=y CONFIG_PROC_EVENTS=y # CONFIG_MTD is not set # CONFIG_PARPORT is not set CONFIG_PNP=y CONFIG_PNP_DEBUG_MESSAGES=y # # Protocols # CONFIG_PNPACPI=y CONFIG_BLK_DEV=y # CONFIG_BLK_DEV_FD is not set # CONFIG_BLK_DEV_PCIESSD_MTIP32XX is not set # CONFIG_BLK_CPQ_DA is not set CONFIG_BLK_CPQ_CISS_DA=y # CONFIG_CISS_SCSI_TAPE is not set # CONFIG_BLK_DEV_DAC960 is not set # CONFIG_BLK_DEV_UMEM is not set # CONFIG_BLK_DEV_COW_COMMON is not set CONFIG_BLK_DEV_LOOP=y CONFIG_BLK_DEV_LOOP_MIN_COUNT=8 # CONFIG_BLK_DEV_CRYPTOLOOP is not set # CONFIG_BLK_DEV_DRBD is not set # CONFIG_BLK_DEV_NBD is not set # CONFIG_BLK_DEV_NVME is not set # CONFIG_BLK_DEV_SX8 is not set # CONFIG_BLK_DEV_UB is not set CONFIG_BLK_DEV_RAM=y CONFIG_BLK_DEV_RAM_COUNT=16 CONFIG_BLK_DEV_RAM_SIZE=16384 # CONFIG_BLK_DEV_XIP is not set # CONFIG_CDROM_PKTCDVD is not set # CONFIG_ATA_OVER_ETH is not set CONFIG_XEN_BLKDEV_FRONTEND=y CONFIG_XEN_BLKDEV_BACKEND=y # CONFIG_BLK_DEV_HD is not set # CONFIG_BLK_DEV_RBD is not set # # Misc devices # # CONFIG_SENSORS_LIS3LV02D is not set # CONFIG_AD525X_DPOT is not set # CONFIG_IBM_ASM is not set # CONFIG_PHANTOM is not set # CONFIG_INTEL_MID_PTI is not set # CONFIG_SGI_IOC4 is not set # CONFIG_TIFM_CORE is not set # CONFIG_ICS932S401 is not set # CONFIG_ENCLOSURE_SERVICES is not set # CONFIG_HP_ILO is not set # CONFIG_APDS9802ALS is not set # CONFIG_ISL29003 is not set # CONFIG_ISL29020 is not set # CONFIG_SENSORS_TSL2550 is not set # CONFIG_SENSORS_BH1780 is not set # CONFIG_SENSORS_BH1770 is not set # CONFIG_SENSORS_APDS990X is not set # CONFIG_HMC6352 is not set # CONFIG_DS1682 is not set # CONFIG_VMWARE_BALLOON is not set # CONFIG_BMP085_I2C is not set # CONFIG_PCH_PHUB is not set # CONFIG_USB_SWITCH_FSA9480 is not set # CONFIG_C2PORT is not set # # EEPROM support # # CONFIG_EEPROM_AT24 is not set # CONFIG_EEPROM_LEGACY is not set # CONFIG_EEPROM_MAX6875 is not set # CONFIG_EEPROM_93CX6 is not set # CONFIG_CB710_CORE is not set # # Texas Instruments shared transport line discipline # # CONFIG_SENSORS_LIS3_I2C is not set # # Altera FPGA firmware download module # # CONFIG_ALTERA_STAPL is not set CONFIG_HAVE_IDE=y # CONFIG_IDE is not set # # SCSI device support # CONFIG_SCSI_MOD=y # CONFIG_RAID_ATTRS is not set CONFIG_SCSI=y CONFIG_SCSI_DMA=y # CONFIG_SCSI_TGT is not set # CONFIG_SCSI_NETLINK is not set CONFIG_SCSI_PROC_FS=y # # SCSI support type (disk, tape, CD-ROM) # CONFIG_BLK_DEV_SD=y # CONFIG_CHR_DEV_ST is not set # CONFIG_CHR_DEV_OSST is not set # CONFIG_BLK_DEV_SR is not set CONFIG_CHR_DEV_SG=y # CONFIG_CHR_DEV_SCH is not set # CONFIG_SCSI_MULTI_LUN is not set CONFIG_SCSI_CONSTANTS=y # CONFIG_SCSI_LOGGING is not set # CONFIG_SCSI_SCAN_ASYNC is not set CONFIG_SCSI_WAIT_SCAN=m # # SCSI Transports # # CONFIG_SCSI_SPI_ATTRS is not set # CONFIG_SCSI_FC_ATTRS is not set # CONFIG_SCSI_ISCSI_ATTRS is not set # CONFIG_SCSI_SAS_ATTRS is not set # CONFIG_SCSI_SAS_LIBSAS is not set # CONFIG_SCSI_SRP_ATTRS is not set # CONFIG_SCSI_LOWLEVEL is not set # CONFIG_SCSI_DH is not set # CONFIG_SCSI_OSD_INITIATOR is not set CONFIG_ATA=y # CONFIG_ATA_NONSTANDARD is not set CONFIG_ATA_VERBOSE_ERROR=y CONFIG_ATA_ACPI=y # CONFIG_SATA_PMP is not set # # Controllers with non-SFF native interface # # CONFIG_SATA_AHCI is not set # CONFIG_SATA_AHCI_PLATFORM is not set # CONFIG_SATA_INIC162X is not set # CONFIG_SATA_ACARD_AHCI is not set # CONFIG_SATA_SIL24 is not set CONFIG_ATA_SFF=y # # SFF controllers with custom DMA interface # # CONFIG_PDC_ADMA is not set # CONFIG_SATA_QSTOR is not set # CONFIG_SATA_SX4 is not set CONFIG_ATA_BMDMA=y # # SATA SFF controllers with BMDMA # CONFIG_ATA_PIIX=y # CONFIG_SATA_MV is not set # CONFIG_SATA_NV is not set # CONFIG_SATA_PROMISE is not set # CONFIG_SATA_SIL is not set # CONFIG_SATA_SIS is not set # CONFIG_SATA_SVW is not set # CONFIG_SATA_ULI is not set # CONFIG_SATA_VIA is not set # CONFIG_SATA_VITESSE is not set # # PATA SFF controllers with BMDMA # # CONFIG_PATA_ALI is not set # CONFIG_PATA_AMD is not set # CONFIG_PATA_ARASAN_CF is not set # CONFIG_PATA_ARTOP is not set # CONFIG_PATA_ATIIXP is not set # CONFIG_PATA_ATP867X is not set # CONFIG_PATA_CMD64X is not set # CONFIG_PATA_CS5520 is not set # CONFIG_PATA_CS5530 is not set # CONFIG_PATA_CS5535 is not set # CONFIG_PATA_CS5536 is not set # CONFIG_PATA_CYPRESS is not set # CONFIG_PATA_EFAR is not set # CONFIG_PATA_HPT366 is not set # CONFIG_PATA_HPT37X is not set # CONFIG_PATA_HPT3X2N is not set # CONFIG_PATA_HPT3X3 is not set # CONFIG_PATA_IT8213 is not set # CONFIG_PATA_IT821X is not set # CONFIG_PATA_JMICRON is not set # CONFIG_PATA_MARVELL is not set # CONFIG_PATA_NETCELL is not set # CONFIG_PATA_NINJA32 is not set # CONFIG_PATA_NS87415 is not set # CONFIG_PATA_OLDPIIX is not set # CONFIG_PATA_OPTIDMA is not set # CONFIG_PATA_PDC2027X is not set # CONFIG_PATA_PDC_OLD is not set # CONFIG_PATA_RADISYS is not set # CONFIG_PATA_RDC is not set # CONFIG_PATA_SC1200 is not set # CONFIG_PATA_SCH is not set CONFIG_PATA_SERVERWORKS=y # CONFIG_PATA_SIL680 is not set # CONFIG_PATA_SIS is not set # CONFIG_PATA_TOSHIBA is not set # CONFIG_PATA_TRIFLEX is not set # CONFIG_PATA_VIA is not set # CONFIG_PATA_WINBOND is not set # # PIO-only SFF controllers # # CONFIG_PATA_CMD640_PCI is not set # CONFIG_PATA_MPIIX is not set # CONFIG_PATA_NS87410 is not set # CONFIG_PATA_OPTI is not set # CONFIG_PATA_RZ1000 is not set # # Generic fallback / legacy drivers # # CONFIG_PATA_ACPI is not set # CONFIG_ATA_GENERIC is not set # CONFIG_PATA_LEGACY is not set CONFIG_MD=y # CONFIG_BLK_DEV_MD is not set CONFIG_BLK_DEV_DM=y # CONFIG_DM_DEBUG is not set # CONFIG_DM_CRYPT is not set # CONFIG_DM_SNAPSHOT is not set # CONFIG_DM_THIN_PROVISIONING is not set # CONFIG_DM_MIRROR is not set # CONFIG_DM_RAID is not set # CONFIG_DM_ZERO is not set # CONFIG_DM_MULTIPATH is not set # CONFIG_DM_DELAY is not set # CONFIG_DM_UEVENT is not set # CONFIG_DM_FLAKEY is not set # CONFIG_DM_VERITY is not set # CONFIG_TARGET_CORE is not set # CONFIG_FUSION is not set # # IEEE 1394 (FireWire) support # # CONFIG_FIREWIRE is not set # CONFIG_FIREWIRE_NOSY is not set # CONFIG_I2O is not set # CONFIG_MACINTOSH_DRIVERS is not set CONFIG_NETDEVICES=y CONFIG_NET_CORE=y # CONFIG_BONDING is not set # CONFIG_DUMMY is not set # CONFIG_EQUALIZER is not set # CONFIG_NET_FC is not set CONFIG_MII=y # CONFIG_IFB is not set # CONFIG_NET_TEAM is not set # CONFIG_MACVLAN is not set CONFIG_NETCONSOLE=y CONFIG_NETPOLL=y # CONFIG_NETPOLL_TRAP is not set CONFIG_NET_POLL_CONTROLLER=y CONFIG_TUN=y # CONFIG_VETH is not set # CONFIG_ARCNET is not set # # CAIF transport drivers # CONFIG_ETHERNET=y CONFIG_NET_VENDOR_3COM=y CONFIG_VORTEX=y # CONFIG_TYPHOON is not set CONFIG_NET_VENDOR_ADAPTEC=y # CONFIG_ADAPTEC_STARFIRE is not set CONFIG_NET_VENDOR_ALTEON=y # CONFIG_ACENIC is not set CONFIG_NET_VENDOR_AMD=y # CONFIG_AMD8111_ETH is not set # CONFIG_PCNET32 is not set CONFIG_NET_VENDOR_ATHEROS=y # CONFIG_ATL2 is not set # CONFIG_ATL1 is not set # CONFIG_ATL1E is not set # CONFIG_ATL1C is not set CONFIG_NET_VENDOR_BROADCOM=y # CONFIG_B44 is not set CONFIG_BNX2=y CONFIG_CNIC=y CONFIG_TIGON3=y # CONFIG_BNX2X is not set CONFIG_NET_VENDOR_BROCADE=y # CONFIG_BNA is not set # CONFIG_NET_CALXEDA_XGMAC is not set CONFIG_NET_VENDOR_CHELSIO=y # CONFIG_CHELSIO_T1 is not set # CONFIG_CHELSIO_T3 is not set # CONFIG_CHELSIO_T4 is not set # CONFIG_CHELSIO_T4VF is not set CONFIG_NET_VENDOR_CISCO=y # CONFIG_ENIC is not set # CONFIG_DNET is not set CONFIG_NET_VENDOR_DEC=y # CONFIG_NET_TULIP is not set CONFIG_NET_VENDOR_DLINK=y # CONFIG_DL2K is not set # CONFIG_SUNDANCE is not set CONFIG_NET_VENDOR_EMULEX=y # CONFIG_BE2NET is not set CONFIG_NET_VENDOR_EXAR=y # CONFIG_S2IO is not set # CONFIG_VXGE is not set CONFIG_NET_VENDOR_HP=y # CONFIG_HP100 is not set CONFIG_NET_VENDOR_INTEL=y CONFIG_E100=y CONFIG_E1000=y CONFIG_E1000E=y # CONFIG_IGB is not set # CONFIG_IGBVF is not set # CONFIG_IXGB is not set # CONFIG_IXGBE is not set # CONFIG_IXGBEVF is not set CONFIG_NET_VENDOR_I825XX=y # CONFIG_ZNET is not set # CONFIG_IP1000 is not set # CONFIG_JME is not set CONFIG_NET_VENDOR_MARVELL=y # CONFIG_SKGE is not set # CONFIG_SKY2 is not set CONFIG_NET_VENDOR_MELLANOX=y # CONFIG_MLX4_EN is not set # CONFIG_MLX4_CORE is not set CONFIG_NET_VENDOR_MICREL=y # CONFIG_KS8851_MLL is not set # CONFIG_KSZ884X_PCI is not set CONFIG_NET_VENDOR_MYRI=y # CONFIG_MYRI10GE is not set # CONFIG_FEALNX is not set CONFIG_NET_VENDOR_NATSEMI=y # CONFIG_NATSEMI is not set # CONFIG_NS83820 is not set CONFIG_NET_VENDOR_8390=y # CONFIG_NE2K_PCI is not set CONFIG_NET_VENDOR_NVIDIA=y # CONFIG_FORCEDETH is not set CONFIG_NET_VENDOR_OKI=y # CONFIG_PCH_GBE is not set # CONFIG_ETHOC is not set CONFIG_NET_PACKET_ENGINE=y # CONFIG_HAMACHI is not set # CONFIG_YELLOWFIN is not set CONFIG_NET_VENDOR_QLOGIC=y # CONFIG_QLA3XXX is not set # CONFIG_QLCNIC is not set # CONFIG_QLGE is not set # CONFIG_NETXEN_NIC is not set CONFIG_NET_VENDOR_REALTEK=y # CONFIG_8139CP is not set # CONFIG_8139TOO is not set # CONFIG_R8169 is not set CONFIG_NET_VENDOR_RDC=y # CONFIG_R6040 is not set CONFIG_NET_VENDOR_SEEQ=y # CONFIG_SEEQ8005 is not set CONFIG_NET_VENDOR_SILAN=y # CONFIG_SC92031 is not set CONFIG_NET_VENDOR_SIS=y # CONFIG_SIS900 is not set # CONFIG_SIS190 is not set # CONFIG_SFC is not set CONFIG_NET_VENDOR_SMSC=y # CONFIG_EPIC100 is not set # CONFIG_SMSC9420 is not set CONFIG_NET_VENDOR_STMICRO=y # CONFIG_STMMAC_ETH is not set CONFIG_NET_VENDOR_SUN=y # CONFIG_HAPPYMEAL is not set # CONFIG_SUNGEM is not set # CONFIG_CASSINI is not set # CONFIG_NIU is not set CONFIG_NET_VENDOR_TEHUTI=y # CONFIG_TEHUTI is not set CONFIG_NET_VENDOR_TI=y # CONFIG_TLAN is not set CONFIG_NET_VENDOR_VIA=y # CONFIG_VIA_RHINE is not set # CONFIG_VIA_VELOCITY is not set # CONFIG_NET_VENDOR_WIZNET is not set # CONFIG_FDDI is not set # CONFIG_HIPPI is not set # CONFIG_NET_SB1000 is not set CONFIG_PHYLIB=y # # MII PHY device drivers # # CONFIG_AMD_PHY is not set # CONFIG_MARVELL_PHY is not set # CONFIG_DAVICOM_PHY is not set # CONFIG_QSEMI_PHY is not set # CONFIG_LXT_PHY is not set # CONFIG_CICADA_PHY is not set # CONFIG_VITESSE_PHY is not set # CONFIG_SMSC_PHY is not set # CONFIG_BROADCOM_PHY is not set # CONFIG_ICPLUS_PHY is not set # CONFIG_REALTEK_PHY is not set # CONFIG_NATIONAL_PHY is not set # CONFIG_STE10XP is not set # CONFIG_LSI_ET1011C_PHY is not set # CONFIG_MICREL_PHY is not set # CONFIG_FIXED_PHY is not set # CONFIG_MDIO_BITBANG is not set CONFIG_PPP=y CONFIG_PPP_BSDCOMP=y CONFIG_PPP_DEFLATE=y # CONFIG_PPP_FILTER is not set # CONFIG_PPP_MPPE is not set # CONFIG_PPP_MULTILINK is not set CONFIG_PPPOE=y CONFIG_PPP_ASYNC=y CONFIG_PPP_SYNC_TTY=y # CONFIG_SLIP is not set CONFIG_SLHC=y # # USB Network Adapters # # CONFIG_USB_CATC is not set # CONFIG_USB_KAWETH is not set # CONFIG_USB_PEGASUS is not set # CONFIG_USB_RTL8150 is not set # CONFIG_USB_USBNET is not set # CONFIG_USB_IPHETH is not set CONFIG_WLAN=y # CONFIG_LIBERTAS_THINFIRM is not set # CONFIG_AIRO is not set # CONFIG_ATMEL is not set # CONFIG_AT76C50X_USB is not set # CONFIG_PRISM54 is not set # CONFIG_USB_ZD1201 is not set # CONFIG_USB_NET_RNDIS_WLAN is not set # CONFIG_RTL8180 is not set # CONFIG_RTL8187 is not set # CONFIG_ADM8211 is not set # CONFIG_MAC80211_HWSIM is not set # CONFIG_MWL8K is not set CONFIG_ATH_COMMON=y # CONFIG_ATH_DEBUG is not set CONFIG_ATH5K=y # CONFIG_ATH5K_DEBUG is not set # CONFIG_ATH5K_TRACER is not set CONFIG_ATH5K_PCI=y # CONFIG_ATH9K is not set # CONFIG_ATH9K_HTC is not set # CONFIG_CARL9170 is not set # CONFIG_ATH6KL is not set # CONFIG_B43 is not set # CONFIG_B43LEGACY is not set # CONFIG_BRCMFMAC is not set # CONFIG_HOSTAP is not set # CONFIG_IPW2100 is not set # CONFIG_IPW2200 is not set # CONFIG_IWLWIFI is not set # CONFIG_IWL4965 is not set # CONFIG_IWL3945 is not set # CONFIG_LIBERTAS is not set # CONFIG_HERMES is not set # CONFIG_P54_COMMON is not set # CONFIG_RT2X00 is not set # CONFIG_RTL8192CE is not set # CONFIG_RTL8192SE is not set # CONFIG_RTL8192DE is not set # CONFIG_RTL8192CU is not set # CONFIG_WL_TI is not set # CONFIG_ZD1211RW is not set # CONFIG_MWIFIEX is not set # # Enable WiMAX (Networking options) to see the WiMAX drivers # # CONFIG_WAN is not set CONFIG_XEN_NETDEV_FRONTEND=y CONFIG_XEN_NETDEV_BACKEND=y # CONFIG_VMXNET3 is not set # CONFIG_ISDN is not set # # Input device support # CONFIG_INPUT=y CONFIG_INPUT_FF_MEMLESS=y CONFIG_INPUT_POLLDEV=y CONFIG_INPUT_SPARSEKMAP=y # CONFIG_INPUT_MATRIXKMAP is not set # # Userland interfaces # CONFIG_INPUT_MOUSEDEV=y # CONFIG_INPUT_MOUSEDEV_PSAUX is not set CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 # CONFIG_INPUT_JOYDEV is not set CONFIG_INPUT_EVDEV=y # CONFIG_INPUT_EVBUG is not set # # Input Device Drivers # CONFIG_INPUT_KEYBOARD=y # CONFIG_KEYBOARD_ADP5588 is not set # CONFIG_KEYBOARD_ADP5589 is not set CONFIG_KEYBOARD_ATKBD=y # CONFIG_KEYBOARD_QT1070 is not set # CONFIG_KEYBOARD_QT2160 is not set # CONFIG_KEYBOARD_LKKBD is not set # CONFIG_KEYBOARD_TCA6416 is not set # CONFIG_KEYBOARD_TCA8418 is not set # CONFIG_KEYBOARD_LM8323 is not set # CONFIG_KEYBOARD_LM8333 is not set # CONFIG_KEYBOARD_MAX7359 is not set # CONFIG_KEYBOARD_MCS is not set # CONFIG_KEYBOARD_MPR121 is not set # CONFIG_KEYBOARD_NEWTON is not set # CONFIG_KEYBOARD_OPENCORES is not set # CONFIG_KEYBOARD_STOWAWAY is not set # CONFIG_KEYBOARD_SUNKBD is not set # CONFIG_KEYBOARD_OMAP4 is not set # CONFIG_KEYBOARD_XTKBD is not set CONFIG_INPUT_MOUSE=y CONFIG_MOUSE_PS2=y CONFIG_MOUSE_PS2_ALPS=y CONFIG_MOUSE_PS2_LOGIPS2PP=y CONFIG_MOUSE_PS2_SYNAPTICS=y CONFIG_MOUSE_PS2_LIFEBOOK=y CONFIG_MOUSE_PS2_TRACKPOINT=y # CONFIG_MOUSE_PS2_ELANTECH is not set # CONFIG_MOUSE_PS2_SENTELIC is not set # CONFIG_MOUSE_PS2_TOUCHKIT is not set # CONFIG_MOUSE_SERIAL is not set # CONFIG_MOUSE_APPLETOUCH is not set # CONFIG_MOUSE_BCM5974 is not set # CONFIG_MOUSE_VSXXXAA is not set # CONFIG_MOUSE_SYNAPTICS_I2C is not set # CONFIG_MOUSE_SYNAPTICS_USB is not set CONFIG_INPUT_JOYSTICK=y # CONFIG_JOYSTICK_ANALOG is not set # CONFIG_JOYSTICK_A3D is not set # CONFIG_JOYSTICK_ADI is not set # CONFIG_JOYSTICK_COBRA is not set # CONFIG_JOYSTICK_GF2K is not set # CONFIG_JOYSTICK_GRIP is not set # CONFIG_JOYSTICK_GRIP_MP is not set # CONFIG_JOYSTICK_GUILLEMOT is not set # CONFIG_JOYSTICK_INTERACT is not set # CONFIG_JOYSTICK_SIDEWINDER is not set # CONFIG_JOYSTICK_TMDC is not set # CONFIG_JOYSTICK_IFORCE is not set # CONFIG_JOYSTICK_WARRIOR is not set # CONFIG_JOYSTICK_MAGELLAN is not set # CONFIG_JOYSTICK_SPACEORB is not set # CONFIG_JOYSTICK_SPACEBALL is not set # CONFIG_JOYSTICK_STINGER is not set # CONFIG_JOYSTICK_TWIDJOY is not set # CONFIG_JOYSTICK_ZHENHUA is not set # CONFIG_JOYSTICK_AS5011 is not set # CONFIG_JOYSTICK_JOYDUMP is not set # CONFIG_JOYSTICK_XPAD is not set CONFIG_INPUT_TABLET=y # CONFIG_TABLET_USB_ACECAD is not set # CONFIG_TABLET_USB_AIPTEK is not set # CONFIG_TABLET_USB_GTCO is not set # CONFIG_TABLET_USB_HANWANG is not set # CONFIG_TABLET_USB_KBTAB is not set # CONFIG_TABLET_USB_WACOM is not set CONFIG_INPUT_TOUCHSCREEN=y # CONFIG_TOUCHSCREEN_AD7879 is not set # CONFIG_TOUCHSCREEN_ATMEL_MXT is not set # CONFIG_TOUCHSCREEN_BU21013 is not set # CONFIG_TOUCHSCREEN_CYTTSP_CORE is not set # CONFIG_TOUCHSCREEN_DYNAPRO is not set # CONFIG_TOUCHSCREEN_HAMPSHIRE is not set # CONFIG_TOUCHSCREEN_EETI is not set # CONFIG_TOUCHSCREEN_EGALAX is not set # CONFIG_TOUCHSCREEN_FUJITSU is not set # CONFIG_TOUCHSCREEN_ILI210X is not set # CONFIG_TOUCHSCREEN_GUNZE is not set # CONFIG_TOUCHSCREEN_ELO is not set # CONFIG_TOUCHSCREEN_WACOM_W8001 is not set # CONFIG_TOUCHSCREEN_WACOM_I2C is not set # CONFIG_TOUCHSCREEN_MAX11801 is not set # CONFIG_TOUCHSCREEN_MCS5000 is not set # CONFIG_TOUCHSCREEN_MTOUCH is not set # CONFIG_TOUCHSCREEN_INEXIO is not set # CONFIG_TOUCHSCREEN_MK712 is not set # CONFIG_TOUCHSCREEN_PENMOUNT is not set # CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set # CONFIG_TOUCHSCREEN_TOUCHWIN is not set # CONFIG_TOUCHSCREEN_PIXCIR is not set # CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set # CONFIG_TOUCHSCREEN_TOUCHIT213 is not set # CONFIG_TOUCHSCREEN_TSC_SERIO is not set # CONFIG_TOUCHSCREEN_TSC2007 is not set # CONFIG_TOUCHSCREEN_ST1232 is not set # CONFIG_TOUCHSCREEN_TPS6507X is not set CONFIG_INPUT_MISC=y # CONFIG_INPUT_AD714X is not set # CONFIG_INPUT_BMA150 is not set # CONFIG_INPUT_PCSPKR is not set # CONFIG_INPUT_MMA8450 is not set # CONFIG_INPUT_MPU3050 is not set # CONFIG_INPUT_APANEL is not set # CONFIG_INPUT_WISTRON_BTNS is not set # CONFIG_INPUT_ATLAS_BTNS is not set # CONFIG_INPUT_ATI_REMOTE2 is not set # CONFIG_INPUT_KEYSPAN_REMOTE is not set # CONFIG_INPUT_KXTJ9 is not set # CONFIG_INPUT_POWERMATE is not set # CONFIG_INPUT_YEALINK is not set # CONFIG_INPUT_CM109 is not set # CONFIG_INPUT_UINPUT is not set # CONFIG_INPUT_PCF8574 is not set # CONFIG_INPUT_ADXL34X is not set # CONFIG_INPUT_CMA3000 is not set CONFIG_INPUT_XEN_KBDDEV_FRONTEND=y # # Hardware I/O ports # CONFIG_SERIO=y CONFIG_SERIO_I8042=y CONFIG_SERIO_SERPORT=y # CONFIG_SERIO_CT82C710 is not set # CONFIG_SERIO_PCIPS2 is not set CONFIG_SERIO_LIBPS2=y # CONFIG_SERIO_RAW is not set # CONFIG_SERIO_ALTERA_PS2 is not set # CONFIG_SERIO_PS2MULT is not set # CONFIG_GAMEPORT is not set # # Character devices # CONFIG_VT=y CONFIG_CONSOLE_TRANSLATIONS=y CONFIG_VT_CONSOLE=y CONFIG_VT_CONSOLE_SLEEP=y CONFIG_HW_CONSOLE=y CONFIG_VT_HW_CONSOLE_BINDING=y CONFIG_UNIX98_PTYS=y # CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set # CONFIG_LEGACY_PTYS is not set CONFIG_SERIAL_NONSTANDARD=y # CONFIG_ROCKETPORT is not set # CONFIG_CYCLADES is not set # CONFIG_MOXA_INTELLIO is not set # CONFIG_MOXA_SMARTIO is not set # CONFIG_SYNCLINK is not set # CONFIG_SYNCLINKMP is not set # CONFIG_SYNCLINK_GT is not set # CONFIG_NOZOMI is not set # CONFIG_ISI is not set # CONFIG_N_HDLC is not set # CONFIG_N_GSM is not set # CONFIG_TRACE_SINK is not set # # KCopy # CONFIG_KCOPY=m # CONFIG_DEVKMEM is not set # CONFIG_STALDRV is not set # # Serial drivers # # CONFIG_SERIAL_8250 is not set CONFIG_FIX_EARLYCON_MEM=y # # Non-8250 serial port support # # CONFIG_SERIAL_MFD_HSU is not set # CONFIG_SERIAL_JSM is not set # CONFIG_SERIAL_TIMBERDALE is not set # CONFIG_SERIAL_ALTERA_JTAGUART is not set # CONFIG_SERIAL_ALTERA_UART is not set # CONFIG_SERIAL_PCH_UART is not set # CONFIG_SERIAL_XILINX_PS_UART is not set CONFIG_HVC_DRIVER=y CONFIG_HVC_IRQ=y CONFIG_HVC_XEN=y CONFIG_HVC_XEN_FRONTEND=y CONFIG_IPMI_HANDLER=y # CONFIG_IPMI_PANIC_EVENT is not set CONFIG_IPMI_DEVICE_INTERFACE=y CONFIG_IPMI_SI=y CONFIG_IPMI_WATCHDOG=y CONFIG_IPMI_POWEROFF=y CONFIG_HW_RANDOM=y CONFIG_HW_RANDOM_TIMERIOMEM=y CONFIG_HW_RANDOM_INTEL=y CONFIG_HW_RANDOM_AMD=y CONFIG_HW_RANDOM_GEODE=y CONFIG_HW_RANDOM_VIA=y CONFIG_NVRAM=y # CONFIG_R3964 is not set # CONFIG_APPLICOM is not set # CONFIG_SONYPI is not set # CONFIG_MWAVE is not set # CONFIG_PC8736x_GPIO is not set # CONFIG_NSC_GPIO is not set # CONFIG_RAW_DRIVER is not set # CONFIG_HPET is not set # CONFIG_HANGCHECK_TIMER is not set # CONFIG_TCG_TPM is not set # CONFIG_TELCLOCK is not set CONFIG_DEVPORT=y CONFIG_I2C=y CONFIG_I2C_BOARDINFO=y CONFIG_I2C_COMPAT=y CONFIG_I2C_CHARDEV=y CONFIG_I2C_MUX=y # # Multiplexer I2C Chip support # # CONFIG_I2C_MUX_PCA9541 is not set # CONFIG_I2C_MUX_PCA954x is not set CONFIG_I2C_HELPER_AUTO=y CONFIG_I2C_ALGOBIT=y # # I2C Hardware Bus support # # # PC SMBus host controller drivers # # CONFIG_I2C_ALI1535 is not set # CONFIG_I2C_ALI1563 is not set # CONFIG_I2C_ALI15X3 is not set # CONFIG_I2C_AMD756 is not set # CONFIG_I2C_AMD8111 is not set # CONFIG_I2C_I801 is not set # CONFIG_I2C_ISCH is not set CONFIG_I2C_PIIX4=y # CONFIG_I2C_NFORCE2 is not set # CONFIG_I2C_SIS5595 is not set # CONFIG_I2C_SIS630 is not set # CONFIG_I2C_SIS96X is not set # CONFIG_I2C_VIA is not set # CONFIG_I2C_VIAPRO is not set # # ACPI drivers # # CONFIG_I2C_SCMI is not set # # I2C system bus drivers (mostly embedded / system-on-chip) # # CONFIG_I2C_DESIGNWARE_PCI is not set # CONFIG_I2C_EG20T is not set # CONFIG_I2C_INTEL_MID is not set # CONFIG_I2C_OCORES is not set # CONFIG_I2C_PCA_PLATFORM is not set # CONFIG_I2C_PXA_PCI is not set # CONFIG_I2C_SIMTEC is not set # CONFIG_I2C_XILINX is not set # # External I2C/SMBus adapter drivers # # CONFIG_I2C_DIOLAN_U2C is not set # CONFIG_I2C_PARPORT_LIGHT is not set # CONFIG_I2C_TAOS_EVM is not set # CONFIG_I2C_TINY_USB is not set # # Other I2C/SMBus bus drivers # # CONFIG_I2C_STUB is not set # CONFIG_SCx200_ACB is not set # CONFIG_I2C_DEBUG_CORE is not set # CONFIG_I2C_DEBUG_ALGO is not set # CONFIG_I2C_DEBUG_BUS is not set # CONFIG_SPI is not set # CONFIG_HSI is not set # # PPS support # # CONFIG_PPS is not set # # PPS generators support # # # PTP clock support # # # Enable Device Drivers -> PPS to see the PTP clock options. # CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y # CONFIG_GPIOLIB is not set # CONFIG_W1 is not set CONFIG_POWER_SUPPLY=y # CONFIG_POWER_SUPPLY_DEBUG is not set # CONFIG_PDA_POWER is not set # CONFIG_TEST_POWER is not set # CONFIG_BATTERY_DS2780 is not set # CONFIG_BATTERY_DS2781 is not set # CONFIG_BATTERY_DS2782 is not set # CONFIG_BATTERY_SBS is not set # CONFIG_BATTERY_BQ27x00 is not set # CONFIG_BATTERY_MAX17040 is not set # CONFIG_BATTERY_MAX17042 is not set # CONFIG_CHARGER_MAX8903 is not set # CONFIG_CHARGER_LP8727 is not set # CONFIG_CHARGER_SMB347 is not set # CONFIG_HWMON is not set CONFIG_THERMAL=y # CONFIG_WATCHDOG is not set CONFIG_SSB_POSSIBLE=y # # Sonics Silicon Backplane # # CONFIG_SSB is not set CONFIG_BCMA_POSSIBLE=y # # Broadcom specific AMBA # # CONFIG_BCMA is not set # # Multifunction device drivers # CONFIG_MFD_CORE=m # CONFIG_MFD_88PM860X is not set # CONFIG_MFD_SM501 is not set # CONFIG_HTC_PASIC3 is not set # CONFIG_MFD_LM3533 is not set # CONFIG_TPS6105X is not set # CONFIG_TPS6507X is not set # CONFIG_MFD_TPS65217 is not set # CONFIG_TWL4030_CORE is not set # CONFIG_TWL6040_CORE is not set # CONFIG_MFD_STMPE is not set # CONFIG_MFD_TC3589X is not set # CONFIG_MFD_TMIO is not set # CONFIG_PMIC_DA903X is not set # CONFIG_MFD_DA9052_I2C is not set # CONFIG_PMIC_ADP5520 is not set # CONFIG_MFD_MAX77693 is not set # CONFIG_MFD_MAX8925 is not set # CONFIG_MFD_MAX8997 is not set # CONFIG_MFD_MAX8998 is not set # CONFIG_MFD_S5M_CORE is not set # CONFIG_MFD_WM8400 is not set # CONFIG_MFD_WM831X_I2C is not set # CONFIG_MFD_WM8350_I2C is not set # CONFIG_MFD_WM8994 is not set # CONFIG_MFD_PCF50633 is not set # CONFIG_MFD_MC13XXX_I2C is not set # CONFIG_ABX500_CORE is not set # CONFIG_MFD_CS5535 is not set CONFIG_LPC_SCH=m # CONFIG_LPC_ICH is not set # CONFIG_MFD_RDC321X is not set # CONFIG_MFD_JANZ_CMODIO is not set # CONFIG_MFD_VX855 is not set # CONFIG_MFD_WL1273_CORE is not set # CONFIG_MFD_TPS65090 is not set # CONFIG_MFD_RC5T583 is not set # CONFIG_MFD_PALMAS is not set # CONFIG_REGULATOR is not set # CONFIG_MEDIA_SUPPORT is not set # # Graphics support # CONFIG_AGP=y # CONFIG_AGP_ALI is not set # CONFIG_AGP_ATI is not set # CONFIG_AGP_AMD is not set CONFIG_AGP_AMD64=y CONFIG_AGP_INTEL=y # CONFIG_AGP_NVIDIA is not set # CONFIG_AGP_SIS is not set # CONFIG_AGP_SWORKS is not set # CONFIG_AGP_VIA is not set # CONFIG_AGP_EFFICEON is not set CONFIG_VGA_ARB=y CONFIG_VGA_ARB_MAX_GPUS=16 # CONFIG_VGA_SWITCHEROO is not set CONFIG_DRM=y # CONFIG_DRM_TDFX is not set # CONFIG_DRM_R128 is not set # CONFIG_DRM_RADEON is not set # CONFIG_DRM_NOUVEAU is not set # CONFIG_DRM_I810 is not set # CONFIG_DRM_I915 is not set # CONFIG_DRM_MGA is not set # CONFIG_DRM_SIS is not set # CONFIG_DRM_VIA is not set # CONFIG_DRM_SAVAGE is not set # CONFIG_DRM_VMWGFX is not set # CONFIG_DRM_GMA500 is not set # CONFIG_DRM_UDL is not set # CONFIG_DRM_AST is not set # CONFIG_DRM_MGAG200 is not set # CONFIG_DRM_CIRRUS_QEMU is not set # CONFIG_STUB_POULSBO is not set # CONFIG_VGASTATE is not set CONFIG_VIDEO_OUTPUT_CONTROL=y CONFIG_FB=y # CONFIG_FIRMWARE_EDID is not set # CONFIG_FB_DDC is not set # CONFIG_FB_BOOT_VESA_SUPPORT is not set # CONFIG_FB_CFB_FILLRECT is not set # CONFIG_FB_CFB_COPYAREA is not set # CONFIG_FB_CFB_IMAGEBLIT is not set # CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set CONFIG_FB_SYS_FILLRECT=y CONFIG_FB_SYS_COPYAREA=y CONFIG_FB_SYS_IMAGEBLIT=y # CONFIG_FB_FOREIGN_ENDIAN is not set CONFIG_FB_SYS_FOPS=y # CONFIG_FB_WMT_GE_ROPS is not set CONFIG_FB_DEFERRED_IO=y # CONFIG_FB_SVGALIB is not set # CONFIG_FB_MACMODES is not set # CONFIG_FB_BACKLIGHT is not set CONFIG_FB_MODE_HELPERS=y CONFIG_FB_TILEBLITTING=y # # Frame buffer hardware drivers # # CONFIG_FB_CIRRUS is not set # CONFIG_FB_PM2 is not set # CONFIG_FB_CYBER2000 is not set # CONFIG_FB_ARC is not set # CONFIG_FB_ASILIANT is not set # CONFIG_FB_IMSTT is not set # CONFIG_FB_VGA16 is not set # CONFIG_FB_UVESA is not set # CONFIG_FB_VESA is not set # CONFIG_FB_N411 is not set # CONFIG_FB_HGA is not set # CONFIG_FB_S1D13XXX is not set # CONFIG_FB_NVIDIA is not set # CONFIG_FB_RIVA is not set # CONFIG_FB_I740 is not set # CONFIG_FB_I810 is not set # CONFIG_FB_LE80578 is not set # CONFIG_FB_MATROX is not set # CONFIG_FB_RADEON is not set # CONFIG_FB_ATY128 is not set # CONFIG_FB_ATY is not set # CONFIG_FB_S3 is not set # CONFIG_FB_SAVAGE is not set # CONFIG_FB_SIS is not set # CONFIG_FB_VIA is not set # CONFIG_FB_NEOMAGIC is not set # CONFIG_FB_KYRO is not set # CONFIG_FB_3DFX is not set # CONFIG_FB_VOODOO1 is not set # CONFIG_FB_VT8623 is not set # CONFIG_FB_TRIDENT is not set # CONFIG_FB_ARK is not set # CONFIG_FB_PM3 is not set # CONFIG_FB_CARMINE is not set # CONFIG_FB_GEODE is not set # CONFIG_FB_TMIO is not set # CONFIG_FB_SMSCUFX is not set # CONFIG_FB_UDL is not set # CONFIG_FB_VIRTUAL is not set CONFIG_XEN_FBDEV_FRONTEND=y # CONFIG_FB_METRONOME is not set # CONFIG_FB_MB862XX is not set # CONFIG_FB_BROADSHEET is not set # CONFIG_FB_AUO_K190X is not set # CONFIG_EXYNOS_VIDEO is not set CONFIG_BACKLIGHT_LCD_SUPPORT=y # CONFIG_LCD_CLASS_DEVICE is not set CONFIG_BACKLIGHT_CLASS_DEVICE=y CONFIG_BACKLIGHT_GENERIC=y # CONFIG_BACKLIGHT_PROGEAR is not set # CONFIG_BACKLIGHT_APPLE is not set # CONFIG_BACKLIGHT_SAHARA is not set # CONFIG_BACKLIGHT_ADP8860 is not set # CONFIG_BACKLIGHT_ADP8870 is not set # CONFIG_BACKLIGHT_LP855X is not set # # Console display driver support # CONFIG_VGA_CONSOLE=y CONFIG_VGACON_SOFT_SCROLLBACK=y CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=64 CONFIG_DUMMY_CONSOLE=y CONFIG_FRAMEBUFFER_CONSOLE=y CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y # CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set # CONFIG_FONTS is not set CONFIG_FONT_8x8=y CONFIG_FONT_8x16=y CONFIG_LOGO=y # CONFIG_LOGO_LINUX_MONO is not set # CONFIG_LOGO_LINUX_VGA16 is not set CONFIG_LOGO_LINUX_CLUT224=y # CONFIG_SOUND is not set # # HID support # CONFIG_HID=y # CONFIG_HID_BATTERY_STRENGTH is not set CONFIG_HIDRAW=y CONFIG_HID_GENERIC=y # # Special HID drivers # CONFIG_HID_A4TECH=y # CONFIG_HID_ACRUX is not set CONFIG_HID_APPLE=y # CONFIG_HID_AUREAL is not set CONFIG_HID_BELKIN=y CONFIG_HID_CHERRY=y CONFIG_HID_CHICONY=y CONFIG_HID_CYPRESS=y # CONFIG_HID_DRAGONRISE is not set # CONFIG_HID_EMS_FF is not set CONFIG_HID_EZKEY=y # CONFIG_HID_HOLTEK is not set # CONFIG_HID_KEYTOUCH is not set CONFIG_HID_KYE=y # CONFIG_HID_UCLOGIC is not set # CONFIG_HID_WALTOP is not set CONFIG_HID_GYRATION=y # CONFIG_HID_TWINHAN is not set CONFIG_HID_KENSINGTON=y # CONFIG_HID_LCPOWER is not set CONFIG_HID_LOGITECH=y CONFIG_HID_LOGITECH_DJ=m CONFIG_LOGITECH_FF=y # CONFIG_LOGIRUMBLEPAD2_FF is not set # CONFIG_LOGIG940_FF is not set CONFIG_LOGIWHEELS_FF=y CONFIG_HID_MICROSOFT=y CONFIG_HID_MONTEREY=y # CONFIG_HID_MULTITOUCH is not set CONFIG_HID_NTRIG=y # CONFIG_HID_ORTEK is not set CONFIG_HID_PANTHERLORD=y CONFIG_PANTHERLORD_FF=y CONFIG_HID_PETALYNX=y # CONFIG_HID_PICOLCD is not set # CONFIG_HID_PRIMAX is not set # CONFIG_HID_ROCCAT is not set # CONFIG_HID_SAITEK is not set CONFIG_HID_SAMSUNG=y CONFIG_HID_SONY=y # CONFIG_HID_SPEEDLINK is not set CONFIG_HID_SUNPLUS=y # CONFIG_HID_GREENASIA is not set # CONFIG_HID_SMARTJOYPLUS is not set # CONFIG_HID_TIVO is not set CONFIG_HID_TOPSEED=y # CONFIG_HID_THRUSTMASTER is not set # CONFIG_HID_ZEROPLUS is not set # CONFIG_HID_ZYDACRON is not set # # USB HID support # CONFIG_USB_HID=y CONFIG_HID_PID=y CONFIG_USB_HIDDEV=y CONFIG_USB_ARCH_HAS_OHCI=y CONFIG_USB_ARCH_HAS_EHCI=y CONFIG_USB_ARCH_HAS_XHCI=y CONFIG_USB_SUPPORT=y CONFIG_USB_COMMON=y CONFIG_USB_ARCH_HAS_HCD=y CONFIG_USB=y CONFIG_USB_DEBUG=y CONFIG_USB_ANNOUNCE_NEW_DEVICES=y # # Miscellaneous USB options # # CONFIG_USB_DYNAMIC_MINORS is not set # CONFIG_USB_MON is not set # CONFIG_USB_WUSB_CBAF is not set # # USB Host Controller Drivers # # CONFIG_USB_C67X00_HCD is not set # CONFIG_USB_XHCI_HCD is not set CONFIG_USB_EHCI_HCD=y # CONFIG_USB_EHCI_ROOT_HUB_TT is not set # CONFIG_USB_EHCI_TT_NEWSCHED is not set # CONFIG_USB_OXU210HP_HCD is not set # CONFIG_USB_ISP116X_HCD is not set # CONFIG_USB_ISP1760_HCD is not set # CONFIG_USB_ISP1362_HCD is not set CONFIG_USB_OHCI_HCD=y # CONFIG_USB_OHCI_HCD_PLATFORM is not set # CONFIG_USB_EHCI_HCD_PLATFORM is not set # CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set # CONFIG_USB_OHCI_BIG_ENDIAN_MMIO is not set CONFIG_USB_OHCI_LITTLE_ENDIAN=y CONFIG_USB_UHCI_HCD=y # CONFIG_USB_SL811_HCD is not set # CONFIG_USB_R8A66597_HCD is not set # CONFIG_USB_CHIPIDEA is not set # # USB Device Class drivers # # CONFIG_USB_ACM is not set # CONFIG_USB_PRINTER is not set # CONFIG_USB_WDM is not set # CONFIG_USB_TMC is not set # # NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may # # # also be needed; see USB_STORAGE Help for more info # CONFIG_USB_STORAGE=y # CONFIG_USB_STORAGE_DEBUG is not set # CONFIG_USB_STORAGE_REALTEK is not set # CONFIG_USB_STORAGE_DATAFAB is not set # CONFIG_USB_STORAGE_FREECOM is not set # CONFIG_USB_STORAGE_ISD200 is not set # CONFIG_USB_STORAGE_USBAT is not set # CONFIG_USB_STORAGE_SDDR09 is not set # CONFIG_USB_STORAGE_SDDR55 is not set # CONFIG_USB_STORAGE_JUMPSHOT is not set # CONFIG_USB_STORAGE_ALAUDA is not set # CONFIG_USB_STORAGE_ONETOUCH is not set # CONFIG_USB_STORAGE_KARMA is not set # CONFIG_USB_STORAGE_CYPRESS_ATACB is not set # CONFIG_USB_STORAGE_ENE_UB6250 is not set # CONFIG_USB_UAS is not set CONFIG_USB_LIBUSUAL=y # # USB Imaging devices # # CONFIG_USB_MDC800 is not set # CONFIG_USB_MICROTEK is not set # # USB port drivers # # CONFIG_USB_SERIAL is not set # # USB Miscellaneous drivers # # CONFIG_USB_EMI62 is not set # CONFIG_USB_EMI26 is not set # CONFIG_USB_ADUTUX is not set # CONFIG_USB_SEVSEG is not set # CONFIG_USB_RIO500 is not set # CONFIG_USB_LEGOTOWER is not set # CONFIG_USB_LCD is not set # CONFIG_USB_LED is not set # CONFIG_USB_CYPRESS_CY7C63 is not set # CONFIG_USB_CYTHERM is not set # CONFIG_USB_IDMOUSE is not set # CONFIG_USB_FTDI_ELAN is not set # CONFIG_USB_APPLEDISPLAY is not set # CONFIG_USB_SISUSBVGA is not set # CONFIG_USB_LD is not set # CONFIG_USB_TRANCEVIBRATOR is not set # CONFIG_USB_IOWARRIOR is not set # CONFIG_USB_TEST is not set # CONFIG_USB_ISIGHTFW is not set # CONFIG_USB_YUREX is not set # # USB Physical Layer drivers # # CONFIG_USB_ISP1301 is not set # CONFIG_USB_GADGET is not set # # OTG and related infrastructure # # CONFIG_NOP_USB_XCEIV is not set # CONFIG_UWB is not set # CONFIG_MMC is not set # CONFIG_MEMSTICK is not set CONFIG_NEW_LEDS=y CONFIG_LEDS_CLASS=y # # LED drivers # # CONFIG_LEDS_LM3530 is not set # CONFIG_LEDS_PCA9532 is not set # CONFIG_LEDS_LP3944 is not set # CONFIG_LEDS_LP5521 is not set # CONFIG_LEDS_LP5523 is not set # CONFIG_LEDS_CLEVO_MAIL is not set # CONFIG_LEDS_PCA955X is not set # CONFIG_LEDS_PCA9633 is not set # CONFIG_LEDS_BD2802 is not set # CONFIG_LEDS_INTEL_SS4200 is not set # CONFIG_LEDS_TCA6507 is not set # CONFIG_LEDS_OT200 is not set CONFIG_LEDS_TRIGGERS=y # # LED Triggers # # CONFIG_LEDS_TRIGGER_TIMER is not set # CONFIG_LEDS_TRIGGER_HEARTBEAT is not set # CONFIG_LEDS_TRIGGER_BACKLIGHT is not set # CONFIG_LEDS_TRIGGER_DEFAULT_ON is not set # # iptables trigger is under Netfilter config (LED target) # # CONFIG_LEDS_TRIGGER_TRANSIENT is not set # CONFIG_ACCESSIBILITY is not set # CONFIG_INFINIBAND is not set CONFIG_EDAC=y # # Reporting subsystems # # CONFIG_EDAC_DEBUG is not set CONFIG_EDAC_DECODE_MCE=y # CONFIG_EDAC_MCE_INJ is not set # CONFIG_EDAC_MM_EDAC is not set CONFIG_RTC_LIB=y CONFIG_RTC_CLASS=y # CONFIG_RTC_HCTOSYS is not set # CONFIG_RTC_DEBUG is not set # # RTC interfaces # CONFIG_RTC_INTF_SYSFS=y CONFIG_RTC_INTF_PROC=y CONFIG_RTC_INTF_DEV=y # CONFIG_RTC_INTF_DEV_UIE_EMUL is not set # CONFIG_RTC_DRV_TEST is not set # # I2C RTC drivers # # CONFIG_RTC_DRV_DS1307 is not set # CONFIG_RTC_DRV_DS1374 is not set # CONFIG_RTC_DRV_DS1672 is not set # CONFIG_RTC_DRV_DS3232 is not set # CONFIG_RTC_DRV_MAX6900 is not set # CONFIG_RTC_DRV_RS5C372 is not set # CONFIG_RTC_DRV_ISL1208 is not set # CONFIG_RTC_DRV_ISL12022 is not set # CONFIG_RTC_DRV_X1205 is not set # CONFIG_RTC_DRV_PCF8563 is not set # CONFIG_RTC_DRV_PCF8583 is not set # CONFIG_RTC_DRV_M41T80 is not set # CONFIG_RTC_DRV_BQ32K is not set # CONFIG_RTC_DRV_S35390A is not set # CONFIG_RTC_DRV_FM3130 is not set # CONFIG_RTC_DRV_RX8581 is not set # CONFIG_RTC_DRV_RX8025 is not set # CONFIG_RTC_DRV_EM3027 is not set # CONFIG_RTC_DRV_RV3029C2 is not set # # SPI RTC drivers # # # Platform RTC drivers # CONFIG_RTC_DRV_CMOS=y # CONFIG_RTC_DRV_DS1286 is not set # CONFIG_RTC_DRV_DS1511 is not set # CONFIG_RTC_DRV_DS1553 is not set # CONFIG_RTC_DRV_DS1742 is not set # CONFIG_RTC_DRV_STK17TA8 is not set # CONFIG_RTC_DRV_M48T86 is not set # CONFIG_RTC_DRV_M48T35 is not set # CONFIG_RTC_DRV_M48T59 is not set # CONFIG_RTC_DRV_MSM6242 is not set # CONFIG_RTC_DRV_BQ4802 is not set # CONFIG_RTC_DRV_RP5C01 is not set # CONFIG_RTC_DRV_V3020 is not set # # on-CPU RTC drivers # CONFIG_DMADEVICES=y # CONFIG_DMADEVICES_DEBUG is not set # # DMA Devices # # CONFIG_INTEL_MID_DMAC is not set # CONFIG_INTEL_IOATDMA is not set # CONFIG_TIMB_DMA is not set # CONFIG_PCH_DMA is not set # CONFIG_AUXDISPLAY is not set CONFIG_UIO=y # CONFIG_UIO_CIF is not set # CONFIG_UIO_PDRV is not set # CONFIG_UIO_PDRV_GENIRQ is not set # CONFIG_UIO_AEC is not set # CONFIG_UIO_SERCOS3 is not set # CONFIG_UIO_PCI_GENERIC is not set # CONFIG_UIO_NETX is not set # # Virtio drivers # # CONFIG_VIRTIO_PCI is not set # CONFIG_VIRTIO_BALLOON is not set # CONFIG_VIRTIO_MMIO is not set # # Microsoft Hyper-V guest support # # CONFIG_HYPERV is not set # # Xen driver support # CONFIG_XEN_BALLOON=y CONFIG_XEN_SELFBALLOONING=y CONFIG_XEN_SCRUB_PAGES=y CONFIG_XEN_DEV_EVTCHN=y CONFIG_XEN_BACKEND=y CONFIG_XENFS=y CONFIG_XEN_COMPAT_XENFS=y CONFIG_XEN_SYS_HYPERVISOR=y CONFIG_XEN_XENBUS_FRONTEND=y CONFIG_XEN_GNTDEV=y CONFIG_XEN_GRANT_DEV_ALLOC=y CONFIG_SWIOTLB_XEN=y CONFIG_XEN_TMEM=y CONFIG_XEN_PCIDEV_BACKEND=y CONFIG_XEN_PRIVCMD=y # CONFIG_STAGING is not set CONFIG_X86_PLATFORM_DEVICES=y # CONFIG_ACERHDF is not set # CONFIG_ASUS_LAPTOP is not set # CONFIG_FUJITSU_LAPTOP is not set # CONFIG_FUJITSU_TABLET is not set # CONFIG_HP_ACCEL is not set # CONFIG_PANASONIC_LAPTOP is not set # CONFIG_THINKPAD_ACPI is not set # CONFIG_SENSORS_HDAPS is not set # CONFIG_INTEL_MENLOW is not set # CONFIG_EEEPC_LAPTOP is not set # CONFIG_ACPI_WMI is not set # CONFIG_TOPSTAR_LAPTOP is not set # CONFIG_TOSHIBA_BT_RFKILL is not set # CONFIG_ACPI_CMPC is not set # CONFIG_INTEL_IPS is not set # CONFIG_IBM_RTL is not set # CONFIG_XO15_EBOOK is not set # CONFIG_SAMSUNG_LAPTOP is not set # CONFIG_SAMSUNG_Q10 is not set # CONFIG_APPLE_GMUX is not set # # Hardware Spinlock drivers # CONFIG_CLKSRC_I8253=y CONFIG_CLKEVT_I8253=y CONFIG_I8253_LOCK=y CONFIG_CLKBLD_I8253=y CONFIG_IOMMU_SUPPORT=y # CONFIG_INTEL_IOMMU is not set # # Remoteproc drivers (EXPERIMENTAL) # # # Rpmsg drivers (EXPERIMENTAL) # # CONFIG_VIRT_DRIVERS is not set # CONFIG_PM_DEVFREQ is not set # CONFIG_EXTCON is not set # CONFIG_MEMORY is not set # CONFIG_IIO is not set # CONFIG_VME_BUS is not set # # Firmware Drivers # # CONFIG_EDD is not set CONFIG_FIRMWARE_MEMMAP=y # CONFIG_DELL_RBU is not set # CONFIG_DCDBAS is not set CONFIG_DMIID=y # CONFIG_DMI_SYSFS is not set # CONFIG_ISCSI_IBFT_FIND is not set # CONFIG_GOOGLE_FIRMWARE is not set # # File systems # CONFIG_DCACHE_WORD_ACCESS=y CONFIG_EXT2_FS=y CONFIG_EXT2_FS_XATTR=y # CONFIG_EXT2_FS_POSIX_ACL is not set CONFIG_EXT2_FS_SECURITY=y # CONFIG_EXT2_FS_XIP is not set CONFIG_EXT3_FS=y # CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set CONFIG_EXT3_FS_XATTR=y # CONFIG_EXT3_FS_POSIX_ACL is not set CONFIG_EXT3_FS_SECURITY=y CONFIG_EXT4_FS=y CONFIG_EXT4_FS_XATTR=y # CONFIG_EXT4_FS_POSIX_ACL is not set CONFIG_EXT4_FS_SECURITY=y # CONFIG_EXT4_DEBUG is not set CONFIG_JBD=y # CONFIG_JBD_DEBUG is not set CONFIG_JBD2=y # CONFIG_JBD2_DEBUG is not set CONFIG_FS_MBCACHE=y # CONFIG_REISERFS_FS is not set # CONFIG_JFS_FS is not set # CONFIG_XFS_FS is not set # CONFIG_GFS2_FS is not set # CONFIG_BTRFS_FS is not set # CONFIG_NILFS2_FS is not set CONFIG_FS_POSIX_ACL=y CONFIG_EXPORTFS=y CONFIG_FILE_LOCKING=y CONFIG_FSNOTIFY=y CONFIG_DNOTIFY=y CONFIG_INOTIFY_USER=y # CONFIG_FANOTIFY is not set CONFIG_QUOTA=y CONFIG_QUOTA_NETLINK_INTERFACE=y # CONFIG_PRINT_QUOTA_WARNING is not set # CONFIG_QUOTA_DEBUG is not set CONFIG_QUOTA_TREE=y # CONFIG_QFMT_V1 is not set CONFIG_QFMT_V2=y CONFIG_QUOTACTL=y # CONFIG_AUTOFS4_FS is not set # CONFIG_FUSE_FS is not set CONFIG_GENERIC_ACL=y # # Caches # # CONFIG_FSCACHE is not set # # CD-ROM/DVD Filesystems # CONFIG_ISO9660_FS=y CONFIG_JOLIET=y CONFIG_ZISOFS=y # CONFIG_UDF_FS is not set # # DOS/FAT/NT Filesystems # CONFIG_FAT_FS=y CONFIG_MSDOS_FS=y CONFIG_VFAT_FS=y CONFIG_FAT_DEFAULT_CODEPAGE=437 CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" # CONFIG_NTFS_FS is not set # # Pseudo filesystems # CONFIG_PROC_FS=y # CONFIG_PROC_KCORE is not set CONFIG_PROC_SYSCTL=y # CONFIG_PROC_PAGE_MONITOR is not set CONFIG_SYSFS=y CONFIG_TMPFS=y CONFIG_TMPFS_POSIX_ACL=y CONFIG_TMPFS_XATTR=y # CONFIG_HUGETLBFS is not set # CONFIG_HUGETLB_PAGE is not set # CONFIG_CONFIGFS_FS is not set # CONFIG_MISC_FILESYSTEMS is not set CONFIG_NETWORK_FILESYSTEMS=y # CONFIG_NFS_FS is not set CONFIG_NFSD=y CONFIG_NFSD_V3=y # CONFIG_NFSD_V3_ACL is not set # CONFIG_NFSD_V4 is not set CONFIG_LOCKD=y CONFIG_LOCKD_V4=y CONFIG_NFS_COMMON=y CONFIG_SUNRPC=y # CONFIG_SUNRPC_DEBUG is not set # CONFIG_CEPH_FS is not set # CONFIG_CIFS is not set # CONFIG_NCP_FS is not set # CONFIG_CODA_FS is not set # CONFIG_AFS_FS is not set CONFIG_NLS=y CONFIG_NLS_DEFAULT="utf8" CONFIG_NLS_CODEPAGE_437=y # CONFIG_NLS_CODEPAGE_737 is not set # CONFIG_NLS_CODEPAGE_775 is not set # CONFIG_NLS_CODEPAGE_850 is not set # CONFIG_NLS_CODEPAGE_852 is not set # CONFIG_NLS_CODEPAGE_855 is not set # CONFIG_NLS_CODEPAGE_857 is not set # CONFIG_NLS_CODEPAGE_860 is not set # CONFIG_NLS_CODEPAGE_861 is not set # CONFIG_NLS_CODEPAGE_862 is not set # CONFIG_NLS_CODEPAGE_863 is not set # CONFIG_NLS_CODEPAGE_864 is not set # CONFIG_NLS_CODEPAGE_865 is not set # CONFIG_NLS_CODEPAGE_866 is not set # CONFIG_NLS_CODEPAGE_869 is not set # CONFIG_NLS_CODEPAGE_936 is not set # CONFIG_NLS_CODEPAGE_950 is not set # CONFIG_NLS_CODEPAGE_932 is not set # CONFIG_NLS_CODEPAGE_949 is not set # CONFIG_NLS_CODEPAGE_874 is not set # CONFIG_NLS_ISO8859_8 is not set CONFIG_NLS_CODEPAGE_1250=y # CONFIG_NLS_CODEPAGE_1251 is not set CONFIG_NLS_ASCII=y CONFIG_NLS_ISO8859_1=y CONFIG_NLS_ISO8859_2=y # CONFIG_NLS_ISO8859_3 is not set # CONFIG_NLS_ISO8859_4 is not set # CONFIG_NLS_ISO8859_5 is not set # CONFIG_NLS_ISO8859_6 is not set # CONFIG_NLS_ISO8859_7 is not set # CONFIG_NLS_ISO8859_9 is not set # CONFIG_NLS_ISO8859_13 is not set # CONFIG_NLS_ISO8859_14 is not set # CONFIG_NLS_ISO8859_15 is not set # CONFIG_NLS_KOI8_R is not set # CONFIG_NLS_KOI8_U is not set # CONFIG_NLS_MAC_ROMAN is not set # CONFIG_NLS_MAC_CELTIC is not set # CONFIG_NLS_MAC_CENTEURO is not set # CONFIG_NLS_MAC_CROATIAN is not set # CONFIG_NLS_MAC_CYRILLIC is not set # CONFIG_NLS_MAC_GAELIC is not set # CONFIG_NLS_MAC_GREEK is not set # CONFIG_NLS_MAC_ICELAND is not set # CONFIG_NLS_MAC_INUIT is not set # CONFIG_NLS_MAC_ROMANIAN is not set # CONFIG_NLS_MAC_TURKISH is not set CONFIG_NLS_UTF8=y # # Kernel hacking # CONFIG_TRACE_IRQFLAGS_SUPPORT=y CONFIG_PRINTK_TIME=y CONFIG_DEFAULT_MESSAGE_LOGLEVEL=4 # CONFIG_ENABLE_WARN_DEPRECATED is not set CONFIG_ENABLE_MUST_CHECK=y CONFIG_FRAME_WARN=2048 CONFIG_MAGIC_SYSRQ=y # CONFIG_STRIP_ASM_SYMS is not set # CONFIG_READABLE_ASM is not set # CONFIG_UNUSED_SYMBOLS is not set CONFIG_DEBUG_FS=y # CONFIG_HEADERS_CHECK is not set # CONFIG_DEBUG_SECTION_MISMATCH is not set CONFIG_DEBUG_KERNEL=y # CONFIG_DEBUG_SHIRQ is not set # CONFIG_LOCKUP_DETECTOR is not set # CONFIG_HARDLOCKUP_DETECTOR is not set # CONFIG_PANIC_ON_OOPS is not set CONFIG_PANIC_ON_OOPS_VALUE=0 # CONFIG_DETECT_HUNG_TASK is not set # CONFIG_SCHED_DEBUG is not set CONFIG_SCHEDSTATS=y CONFIG_TIMER_STATS=y # CONFIG_DEBUG_OBJECTS is not set # CONFIG_SLUB_DEBUG_ON is not set # CONFIG_SLUB_STATS is not set # CONFIG_DEBUG_KMEMLEAK is not set # CONFIG_DEBUG_RT_MUTEXES is not set # CONFIG_RT_MUTEX_TESTER is not set # CONFIG_DEBUG_SPINLOCK is not set # CONFIG_DEBUG_MUTEXES is not set # CONFIG_DEBUG_LOCK_ALLOC is not set # CONFIG_PROVE_LOCKING is not set # CONFIG_SPARSE_RCU_POINTER is not set # CONFIG_LOCK_STAT is not set # CONFIG_DEBUG_ATOMIC_SLEEP is not set # CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set CONFIG_STACKTRACE=y CONFIG_DEBUG_STACK_USAGE=y # CONFIG_DEBUG_KOBJECT is not set # CONFIG_DEBUG_HIGHMEM is not set CONFIG_DEBUG_BUGVERBOSE=y # CONFIG_DEBUG_INFO is not set # CONFIG_DEBUG_VM is not set # CONFIG_DEBUG_VIRTUAL is not set # CONFIG_DEBUG_WRITECOUNT is not set CONFIG_DEBUG_MEMORY_INIT=y # CONFIG_DEBUG_LIST is not set # CONFIG_TEST_LIST_SORT is not set # CONFIG_DEBUG_SG is not set # CONFIG_DEBUG_NOTIFIERS is not set # CONFIG_DEBUG_CREDENTIALS is not set CONFIG_ARCH_WANT_FRAME_POINTERS=y CONFIG_FRAME_POINTER=y # CONFIG_BOOT_PRINTK_DELAY is not set # CONFIG_RCU_TORTURE_TEST is not set CONFIG_RCU_CPU_STALL_TIMEOUT=60 # CONFIG_RCU_CPU_STALL_INFO is not set # CONFIG_RCU_TRACE is not set # CONFIG_KPROBES_SANITY_TEST is not set # CONFIG_BACKTRACE_SELF_TEST is not set # CONFIG_DEBUG_BLOCK_EXT_DEVT is not set # CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set # CONFIG_DEBUG_PER_CPU_MAPS is not set # CONFIG_LKDTM is not set # CONFIG_CPU_NOTIFIER_ERROR_INJECT is not set # CONFIG_FAULT_INJECTION is not set # CONFIG_LATENCYTOP is not set # CONFIG_DEBUG_PAGEALLOC is not set CONFIG_USER_STACKTRACE_SUPPORT=y CONFIG_NOP_TRACER=y CONFIG_HAVE_FUNCTION_TRACER=y CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y CONFIG_HAVE_FUNCTION_GRAPH_FP_TEST=y CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST=y CONFIG_HAVE_DYNAMIC_FTRACE=y CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y CONFIG_HAVE_SYSCALL_TRACEPOINTS=y CONFIG_HAVE_C_RECORDMCOUNT=y CONFIG_RING_BUFFER=y CONFIG_EVENT_TRACING=y CONFIG_EVENT_POWER_TRACING_DEPRECATED=y CONFIG_CONTEXT_SWITCH_TRACER=y CONFIG_TRACING=y CONFIG_GENERIC_TRACER=y CONFIG_TRACING_SUPPORT=y CONFIG_FTRACE=y # CONFIG_FUNCTION_TRACER is not set # CONFIG_IRQSOFF_TRACER is not set # CONFIG_SCHED_TRACER is not set # CONFIG_FTRACE_SYSCALLS is not set CONFIG_BRANCH_PROFILE_NONE=y # CONFIG_PROFILE_ANNOTATED_BRANCHES is not set # CONFIG_PROFILE_ALL_BRANCHES is not set # CONFIG_STACK_TRACER is not set CONFIG_BLK_DEV_IO_TRACE=y CONFIG_KPROBE_EVENT=y # CONFIG_UPROBE_EVENT is not set CONFIG_PROBE_EVENTS=y # CONFIG_FTRACE_STARTUP_TEST is not set # CONFIG_MMIOTRACE is not set # CONFIG_RING_BUFFER_BENCHMARK is not set CONFIG_PROVIDE_OHCI1394_DMA_INIT=y # CONFIG_DYNAMIC_DEBUG is not set # CONFIG_DMA_API_DEBUG is not set # CONFIG_ATOMIC64_SELFTEST is not set # CONFIG_SAMPLES is not set CONFIG_HAVE_ARCH_KGDB=y # CONFIG_KGDB is not set CONFIG_HAVE_ARCH_KMEMCHECK=y # CONFIG_KMEMCHECK is not set # CONFIG_TEST_KSTRTOX is not set CONFIG_STRICT_DEVMEM=y CONFIG_X86_VERBOSE_BOOTUP=y CONFIG_EARLY_PRINTK=y CONFIG_EARLY_PRINTK_DBGP=y CONFIG_DEBUG_STACKOVERFLOW=y # CONFIG_X86_PTDUMP is not set CONFIG_DEBUG_NX_TEST=m CONFIG_DOUBLEFAULT=y # CONFIG_IOMMU_STRESS is not set CONFIG_HAVE_MMIOTRACE_SUPPORT=y # CONFIG_X86_DECODER_SELFTEST is not set CONFIG_IO_DELAY_TYPE_0X80=0 CONFIG_IO_DELAY_TYPE_0XED=1 CONFIG_IO_DELAY_TYPE_UDELAY=2 CONFIG_IO_DELAY_TYPE_NONE=3 CONFIG_IO_DELAY_0X80=y # CONFIG_IO_DELAY_0XED is not set # CONFIG_IO_DELAY_UDELAY is not set # CONFIG_IO_DELAY_NONE is not set CONFIG_DEFAULT_IO_DELAY_TYPE=0 # CONFIG_DEBUG_BOOT_PARAMS is not set # CONFIG_CPA_DEBUG is not set CONFIG_OPTIMIZE_INLINING=y # CONFIG_DEBUG_STRICT_USER_COPY_CHECKS is not set # CONFIG_DEBUG_NMI_SELFTEST is not set # # Security options # # # Grsecurity # CONFIG_PAX_ENABLE_PAE=y # CONFIG_GRKERNSEC is not set CONFIG_KEYS=y # CONFIG_ENCRYPTED_KEYS is not set CONFIG_KEYS_DEBUG_PROC_KEYS=y # CONFIG_SECURITY_DMESG_RESTRICT is not set CONFIG_SECURITY=y # CONFIG_SECURITYFS is not set CONFIG_SECURITY_NETWORK=y # CONFIG_SECURITY_NETWORK_XFRM is not set # CONFIG_SECURITY_PATH is not set CONFIG_LSM_MMAP_MIN_ADDR=65536 CONFIG_SECURITY_SELINUX=y # CONFIG_SECURITY_SELINUX_BOOTPARAM is not set # CONFIG_SECURITY_SELINUX_DISABLE is not set CONFIG_SECURITY_SELINUX_DEVELOP=y # CONFIG_SECURITY_SELINUX_AVC_STATS is not set CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE=1 # CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX is not set # CONFIG_SECURITY_SMACK is not set # CONFIG_SECURITY_TOMOYO is not set # CONFIG_SECURITY_APPARMOR is not set # CONFIG_SECURITY_YAMA is not set # CONFIG_IMA is not set # CONFIG_EVM is not set CONFIG_DEFAULT_SECURITY_SELINUX=y # CONFIG_DEFAULT_SECURITY_DAC is not set CONFIG_DEFAULT_SECURITY="selinux" CONFIG_CRYPTO=y # # Crypto core or helper # CONFIG_CRYPTO_ALGAPI=y CONFIG_CRYPTO_ALGAPI2=y CONFIG_CRYPTO_AEAD=y CONFIG_CRYPTO_AEAD2=y CONFIG_CRYPTO_BLKCIPHER=y CONFIG_CRYPTO_BLKCIPHER2=y CONFIG_CRYPTO_HASH=y CONFIG_CRYPTO_HASH2=y CONFIG_CRYPTO_RNG2=y CONFIG_CRYPTO_PCOMP2=y CONFIG_CRYPTO_MANAGER=y CONFIG_CRYPTO_MANAGER2=y # CONFIG_CRYPTO_USER is not set CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y # CONFIG_CRYPTO_GF128MUL is not set # CONFIG_CRYPTO_NULL is not set # CONFIG_CRYPTO_PCRYPT is not set CONFIG_CRYPTO_WORKQUEUE=y # CONFIG_CRYPTO_CRYPTD is not set CONFIG_CRYPTO_AUTHENC=y # CONFIG_CRYPTO_TEST is not set # # Authenticated Encryption with Associated Data # # CONFIG_CRYPTO_CCM is not set # CONFIG_CRYPTO_GCM is not set # CONFIG_CRYPTO_SEQIV is not set # # Block modes # CONFIG_CRYPTO_CBC=y # CONFIG_CRYPTO_CTR is not set # CONFIG_CRYPTO_CTS is not set CONFIG_CRYPTO_ECB=y # CONFIG_CRYPTO_LRW is not set # CONFIG_CRYPTO_PCBC is not set # CONFIG_CRYPTO_XTS is not set # # Hash modes # CONFIG_CRYPTO_HMAC=y # CONFIG_CRYPTO_XCBC is not set # CONFIG_CRYPTO_VMAC is not set # # Digest # CONFIG_CRYPTO_CRC32C=y # CONFIG_CRYPTO_CRC32C_INTEL is not set # CONFIG_CRYPTO_GHASH is not set # CONFIG_CRYPTO_MD4 is not set CONFIG_CRYPTO_MD5=y # CONFIG_CRYPTO_MICHAEL_MIC is not set # CONFIG_CRYPTO_RMD128 is not set # CONFIG_CRYPTO_RMD160 is not set # CONFIG_CRYPTO_RMD256 is not set # CONFIG_CRYPTO_RMD320 is not set CONFIG_CRYPTO_SHA1=y CONFIG_CRYPTO_SHA256=y # CONFIG_CRYPTO_SHA512 is not set # CONFIG_CRYPTO_TGR192 is not set # CONFIG_CRYPTO_WP512 is not set # # Ciphers # CONFIG_CRYPTO_AES=y CONFIG_CRYPTO_AES_586=y # CONFIG_CRYPTO_AES_NI_INTEL is not set # CONFIG_CRYPTO_ANUBIS is not set CONFIG_CRYPTO_ARC4=y # CONFIG_CRYPTO_BLOWFISH is not set # CONFIG_CRYPTO_CAMELLIA is not set # CONFIG_CRYPTO_CAST5 is not set # CONFIG_CRYPTO_CAST6 is not set CONFIG_CRYPTO_DES=y # CONFIG_CRYPTO_FCRYPT is not set # CONFIG_CRYPTO_KHAZAD is not set # CONFIG_CRYPTO_SALSA20 is not set # CONFIG_CRYPTO_SALSA20_586 is not set # CONFIG_CRYPTO_SEED is not set # CONFIG_CRYPTO_SERPENT is not set # CONFIG_CRYPTO_SERPENT_SSE2_586 is not set # CONFIG_CRYPTO_TEA is not set # CONFIG_CRYPTO_TWOFISH is not set # CONFIG_CRYPTO_TWOFISH_586 is not set # # Compression # # CONFIG_CRYPTO_DEFLATE is not set # CONFIG_CRYPTO_ZLIB is not set # CONFIG_CRYPTO_LZO is not set # # Random Number Generation # # CONFIG_CRYPTO_ANSI_CPRNG is not set # CONFIG_CRYPTO_USER_API_HASH is not set # CONFIG_CRYPTO_USER_API_SKCIPHER is not set CONFIG_CRYPTO_HW=y # CONFIG_CRYPTO_DEV_PADLOCK is not set # CONFIG_CRYPTO_DEV_GEODE is not set CONFIG_HAVE_KVM=y CONFIG_VIRTUALIZATION=y # CONFIG_KVM is not set # CONFIG_VHOST_NET is not set # CONFIG_LGUEST is not set CONFIG_BINARY_PRINTF=y # # Library routines # CONFIG_BITREVERSE=y CONFIG_GENERIC_STRNCPY_FROM_USER=y CONFIG_GENERIC_STRNLEN_USER=y CONFIG_GENERIC_FIND_FIRST_BIT=y CONFIG_GENERIC_PCI_IOMAP=y CONFIG_GENERIC_IOMAP=y CONFIG_GENERIC_IO=y CONFIG_CRC_CCITT=y CONFIG_CRC16=y CONFIG_CRC_T10DIF=y # CONFIG_CRC_ITU_T is not set CONFIG_CRC32=y # CONFIG_CRC32_SELFTEST is not set CONFIG_CRC32_SLICEBY8=y # CONFIG_CRC32_SLICEBY4 is not set # CONFIG_CRC32_SARWATE is not set # CONFIG_CRC32_BIT is not set # CONFIG_CRC7 is not set # CONFIG_LIBCRC32C is not set # CONFIG_CRC8 is not set CONFIG_AUDIT_GENERIC=y CONFIG_ZLIB_INFLATE=y CONFIG_ZLIB_DEFLATE=y CONFIG_LZO_DECOMPRESS=y CONFIG_XZ_DEC=y CONFIG_XZ_DEC_X86=y CONFIG_XZ_DEC_POWERPC=y CONFIG_XZ_DEC_IA64=y CONFIG_XZ_DEC_ARM=y CONFIG_XZ_DEC_ARMTHUMB=y CONFIG_XZ_DEC_SPARC=y CONFIG_XZ_DEC_BCJ=y # CONFIG_XZ_DEC_TEST is not set CONFIG_DECOMPRESS_GZIP=y CONFIG_DECOMPRESS_BZIP2=y CONFIG_DECOMPRESS_LZMA=y CONFIG_DECOMPRESS_XZ=y CONFIG_DECOMPRESS_LZO=y CONFIG_HAS_IOMEM=y CONFIG_HAS_IOPORT=y CONFIG_HAS_DMA=y CONFIG_CPU_RMAP=y CONFIG_DQL=y CONFIG_NLATTR=y CONFIG_AVERAGE=y # CONFIG_CORDIC is not set # CONFIG_DDR is not set --------------000009040509090906010603 Content-Type: text/plain; charset=windows-1252; name="DomU" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="DomU" name = "rita" builder = "generic" vcpus = 4 maxvcpus = 4 cpus = [ 0, 1, 2, 3 ] cpu_weight = 256 memory = 1024 maxmem = 1024 bootloader = "pygrub" #kernel = "/home/xen/kernels/linux-3.5.4-hardened-selinux/boot/bzImage" #root = "/dev/xvda1 ro" #extra = "iommu=soft e820_host=1" disk = [ "phy:/dev/xendomains/rita,xvda1,w" ] vif = [ 'bridge=br0,mac=00:00:00:00:00:01' ] vfb = [ "vnc=1,vnclisten=0.0.0.0,vncdisplay=1,vncpasswd=vmrita" ] pci = [ '02:02.0,permissive=1', '06:01.0', '06:02.0' ] --------------000009040509090906010603 Content-Type: text/plain; charset=windows-1252; name="grub0.conf" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="grub0.conf" default 0 timeout 3 password --md5 $1$XIJIA/$wl/jkb1dhhA06.iLLcws40 title Xen 4.2.0 / Gentoo Linux 3.5.4 / Hardened / Selinux / Domain 0 root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all module /boot/linux-3.5.4-hardened-selinux root=/dev/cciss/c0d0p5 xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.5.4 / Hardened / Selinux / Domain 0 / IRQpoll root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all module /boot/linux-3.5.4-hardened-selinux root=/dev/cciss/c0d0p5 irqpoll xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.5.4 / Hardened / Selinux / Domain 0 / Tmem root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all tmem tmem_dedup tmem_compress module /boot/linux-3.5.4-hardened-selinux root=/dev/cciss/c0d0p5 tmem xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.4.5 / Hardened / Selinux / Domain 0 root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all module /boot/linux-3.4.5-hardened-selinux root=/dev/cciss/c0d0p5 xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.4.5 / Hardened / Selinux / Domain 0 / Tmem root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all tmem tmem_dedup tmem_compress module /boot/linux-3.4.5-hardened-selinux root=/dev/cciss/c0d0p5 tmem xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.3.8 / Selinux / Domain 0 root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all module /boot/linux-3.3.8-gentoo-selinux root=/dev/cciss/c0d0p5 xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title Xen 4.2.0 / Gentoo Linux 3.3.8 / Selinux / Domain 0 / Tmem root (hd0,0) kernel /boot/xen.gz dom0_mem=512M loglvl=all guest_loglvl=all tmem tmem_dedup tmem_compress module /boot/linux-3.3.8-gentoo-selinux root=/dev/cciss/c0d0p5 tmem xen-pciback.passthrough=1 xen-pciback.hide=(00:0f.2)(02:02.0)(03:01.0)(06:01.0)(06:02.0) title=Memtest86 root (hd0,0) kernel /boot/memtest86/memtest.bin title=Memtest86+ root (hd0,0) kernel /boot/memtest86plus/memtest.bin --------------000009040509090906010603 Content-Type: text/plain; charset=windows-1252; name="grubU.conf" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="grubU.conf" default 0 timeout 3 title Gentoo Linux 3.5.4 / Hardened / Selinux root (hd0,0) kernel /boot/linux-3.5.4-hardened-selinux root=/dev/xvda1 iommu=soft e820_host=1 --------------000009040509090906010603 Content-Type: text/plain; charset=windows-1252; name="lspci" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="lspci" 00:00.0 Host bridge: Broadcom CMIC-LE Host Bridge (GC-LE chipset) (rev 33) 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- 0002) [ 351.441035] xen: registering gsi 11 triggering 0 polarity 1 [ 351.441059] Already setup the GSI :11 [ 407.581924] xen-pciback[0000:00:0f.2] IRQ line is not shared with other domains. Turning ISR off [ 409.004566] irq 11: nobody cared (try booting with the "irqpoll" option) [ 409.004575] Pid: 0, comm: swapper/0 Not tainted 3.5.4-hardened-r1 #2 [ 409.004579] Call Trace: [ 409.004594] [] __report_bad_irq+0x24/0xc0 [ 409.004602] [] note_interrupt+0x126/0x1d0 [ 409.004608] [] ? hypercall_page+0x227/0x1000 [ 409.004614] [] handle_irq_event_percpu+0xae/0x1e0 [ 409.004619] [] ? irq_to_desc+0xf/0x20 [ 409.004624] [] ? irq_get_irq_data+0x8/0x10 [ 409.004633] [] ? pirq_from_irq+0x8/0x30 [ 409.004638] [] handle_irq_event+0x36/0x60 [ 409.004644] [] handle_edge_irq+0x5e/0xe0 [ 409.004649] [] __xen_evtchn_do_upcall+0x14e/0x1f0 [ 409.004656] [] xen_evtchn_do_upcall+0x1b/0x30 [ 409.004664] [] xen_do_upcall+0x7/0x10 [ 409.004672] [] ? clocksource_watchdog+0x1e8/0x2d0 [ 409.004678] [] ? hypercall_page+0x227/0x1000 [ 409.004685] [] ? xen_force_evtchn_callback+0x1a/0x30 [ 409.004690] [] check_events+0x8/0x14 [ 409.004696] [] ? xen_irq_enable_direct_reloc+0x4/0x4 [ 409.004701] [] ? tick_nohz_idle_enter+0x37/0x60 [ 409.004707] [] cpu_idle+0x67/0xf0 [ 409.004715] [] rest_init+0x58/0x60 [ 409.004720] [] 0xc188fa29 [ 409.004725] [] ? 0xc188f4c1 [ 409.004730] [] 0xc188f357 [ 409.004737] [] ? xen_raw_console_write+0x23/0x40 [ 409.004741] [] 0xc18925ea [ 409.004748] [] ? ath5k_beacon_send+0xb8/0x230 [ 409.004751] handlers: [ 409.004756] [] xen_pcibk_guest_interrupt [ 409.004761] Disabling IRQ #11 --------------000009040509090906010603 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 --------------000009040509090906010603-- From xen-devel-bounces@lists.xen.org Wed Nov 14 19:05:11 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Wed, 14 Nov 2012 19:05: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 1TYiGb-00056n-37; Wed, 14 Nov 2012 19:04:53 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TYiGZ-00056g-Hh for Xen-devel@lists.xensource.com; Wed, 14 Nov 2012 19:04:52 +0000 Received: from [85.158.143.99:60420] by server-3.bemta-4.messagelabs.com id 5B/39-06841-25BE3A05; Wed, 14 Nov 2012 19:04:50 +0000 X-Env-Sender: mukesh.rathor@oracle.com X-Msg-Ref: server-3.tower-216.messagelabs.com!1352919887!29381992!1 X-Originating-IP: [156.151.31.81] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogMTU2LjE1MS4zMS44MSA9PiA2MjkwNg==\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 32650 invoked from network); 14 Nov 2012 19:04:49 -0000 Received: from userp1040.oracle.com (HELO userp1040.oracle.com) (156.151.31.81) by server-3.tower-216.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 14 Nov 2012 19:04:49 -0000 Received: from acsinet21.oracle.com (acsinet21.oracle.com [141.146.126.237]) by userp1040.oracle.com (Sentrion-MTA-4.2.2/Sentrion-MTA-4.2.2) with ESMTP id qAEJ4iWD020462 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 14 Nov 2012 19:04:45 GMT Received: from acsmt358.oracle.com (acsmt358.oracle.com [141.146.40.158]) by acsinet21.oracle.com (8.14.4+Sun/8.14.4) with ESMTP id qAEJ4hXC017878 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Wed, 14 Nov 2012 19:04:43 GMT Received: from abhmt118.oracle.com (abhmt118.oracle.com [141.146.116.70]) by acsmt358.oracle.com (8.12.11.20060308/8.12.11) with ESMTP id qAEJ4hfM022749; Wed, 14 Nov 2012 13:04:43 -0600 Received: from mantra.us.oracle.com (/130.35.68.95) by default (Oracle Beehive Gateway v4.0) with ESMTP ; Wed, 14 Nov 2012 11:04:42 -0800 Date: Wed, 14 Nov 2012 11:04:41 -0800 From: Mukesh Rathor To: Ian Campbell Message-ID: <20121114110441.712a00f7@mantra.us.oracle.com> In-Reply-To: <1352887110.26873.15.camel@zakaz.uk.xensource.com> References: <20121112190934.5e702799@mantra.us.oracle.com> <1352800853.7491.22.camel@zakaz.uk.xensource.com> <20121113172138.1d3274d9@mantra.us.oracle.com> <20121113173138.61b21067@mantra.us.oracle.com> <1352887110.26873.15.camel@zakaz.uk.xensource.com> Organization: Oracle Corporation X-Mailer: Claws Mail 3.7.6 (GTK+ 2.18.9; x86_64-redhat-linux-gnu) Mime-Version: 1.0 X-Source-IP: acsinet21.oracle.com [141.146.126.237] Cc: "Xen-devel@lists.xensource.com" Subject: Re: [Xen-devel] PVH: libxl expertise... 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 Wed, 14 Nov 2012 09:58:30 +0000 Ian Campbell wrote: > On Wed, 2012-11-14 at 01:31 +0000, Mukesh Rathor wrote: > > On Tue, 13 Nov 2012 17:21:38 -0800 > > Mukesh Rathor wrote: > > > > > > Did you say that if you use the raw ELF file it works? You mean vmlinux? I couldn't its 133M and my boot partition is only 99M. > BTW for the purposes of parallelising things up you could post the > hypervisor side part of the series stuff + a patch to force enable PVH > in libxc (obviously the last not to be applied) first then we can be > reviewing the h/v side things while simultaneously figuring out how > the tools side fits together. Ok. I've been procrastinating as the patch is full of debug code, is rather big, and would take lot of time to split up in different patches. If you don't mind a very raw/debug version, all in one, here it is (built on c/s: 26124 + my KDB patch): diff -r 8b0762504037 tools/debugger/gdbsx/xg/xg_main.c --- a/tools/debugger/gdbsx/xg/xg_main.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/debugger/gdbsx/xg/xg_main.c Wed Nov 14 11:03:24 2012 -0800 @@ -80,6 +80,7 @@ int xgtrc_on = 0; struct xen_domctl domctl; /* just use a global domctl */ static int _hvm_guest; /* hvm guest? 32bit HVMs have 64bit context */ +static int _pvh_guest; /* PV guest in HVM container */ static domid_t _dom_id; /* guest domid */ static int _max_vcpu_id; /* thus max_vcpu_id+1 VCPUs */ static int _dom0_fd; /* fd of /dev/privcmd */ @@ -308,6 +309,7 @@ xg_attach(int domid, int guest_bitness) _max_vcpu_id = domctl.u.getdomaininfo.max_vcpu_id; _hvm_guest = (domctl.u.getdomaininfo.flags & XEN_DOMINF_hvm_guest); + _pvh_guest = (domctl.u.getdomaininfo.flags & XEN_DOMINF_pvh_guest); return _max_vcpu_id; } @@ -368,7 +370,7 @@ _change_TF(vcpuid_t which_vcpu, int gues int sz = sizeof(anyc); /* first try the MTF for hvm guest. otherwise do manually */ - if (_hvm_guest) { + if (_hvm_guest || _pvh_guest) { domctl.u.debug_op.vcpu = which_vcpu; domctl.u.debug_op.op = setit ? XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_ON : XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_OFF; diff -r 8b0762504037 tools/libxc/Makefile --- a/tools/libxc/Makefile Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxc/Makefile Wed Nov 14 11:03:24 2012 -0800 @@ -73,7 +73,7 @@ OSDEP_SRCS-y += xenctrl_ -include $(XEN_TARGET_ARCH)/Makefile CFLAGS += -Werror -Wmissing-prototypes -CFLAGS += -I. $(CFLAGS_xeninclude) +CFLAGS += -I. $(CFLAGS_xeninclude) -g -O0 # Needed for posix_fadvise64() in xc_linux.c CFLAGS-$(CONFIG_Linux) += -D_GNU_SOURCE diff -r 8b0762504037 tools/libxc/xc_dom_x86.c --- a/tools/libxc/xc_dom_x86.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxc/xc_dom_x86.c Wed Nov 14 11:03:24 2012 -0800 @@ -386,7 +386,8 @@ static int setup_pgtables_x86_64(struct pgpfn = (addr - dom->parms.virt_base) >> PAGE_SHIFT_X86; l1tab[l1off] = pfn_to_paddr(xc_dom_p2m_guest(dom, pgpfn)) | L1_PROT; - if ( (addr >= dom->pgtables_seg.vstart) && + if ( !(dom->flags & SIF_IS_PVH) && + (addr >= dom->pgtables_seg.vstart) && (addr < dom->pgtables_seg.vend) ) l1tab[l1off] &= ~_PAGE_RW; /* page tables are r/o */ if ( l1off == (L1_PAGETABLE_ENTRIES_X86_64 - 1) ) @@ -716,7 +717,7 @@ int arch_setup_meminit(struct xc_dom_ima rc = x86_compat(dom->xch, dom->guest_domid, dom->guest_type); if ( rc ) return rc; - if ( xc_dom_feature_translated(dom) ) + if ( xc_dom_feature_translated(dom) && !(dom->flags & SIF_IS_PVH) ) { dom->shadow_enabled = 1; rc = x86_shadow(dom->xch, dom->guest_domid); @@ -830,7 +831,7 @@ int arch_setup_bootlate(struct xc_dom_im } /* Map grant table frames into guest physmap. */ - for ( i = 0; ; i++ ) + for ( i = 0; !(dom->flags & SIF_IS_PVH); i++ ) { rc = xc_domain_add_to_physmap(dom->xch, dom->guest_domid, XENMAPSPACE_grant_table, diff -r 8b0762504037 tools/libxc/xc_domain_restore.c --- a/tools/libxc/xc_domain_restore.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxc/xc_domain_restore.c Wed Nov 14 11:03:24 2012 -0800 @@ -1933,15 +1933,15 @@ int xc_domain_restore(xc_interface *xch, munmap(start_info, PAGE_SIZE); } /* Uncanonicalise each GDT frame number. */ - if ( GET_FIELD(ctxt, gdt_ents) > 8192 ) + if ( GET_FIELD(ctxt, u.pv.gdt_ents) > 8192 ) { ERROR("GDT entry count out of range"); goto out; } - for ( j = 0; (512*j) < GET_FIELD(ctxt, gdt_ents); j++ ) + for ( j = 0; (512*j) < GET_FIELD(ctxt, u.pv.gdt_ents); j++ ) { - pfn = GET_FIELD(ctxt, gdt_frames[j]); + pfn = GET_FIELD(ctxt, u.pv.gdt_frames[j]); if ( (pfn >= dinfo->p2m_size) || (pfn_type[pfn] != XEN_DOMCTL_PFINFO_NOTAB) ) { @@ -1949,7 +1949,7 @@ int xc_domain_restore(xc_interface *xch, j, (unsigned long)pfn); goto out; } - SET_FIELD(ctxt, gdt_frames[j], ctx->p2m[pfn]); + SET_FIELD(ctxt, u.pv.gdt_frames[j], ctx->p2m[pfn]); } /* Uncanonicalise the page table base pointer. */ pfn = UNFOLD_CR3(GET_FIELD(ctxt, ctrlreg[3])); diff -r 8b0762504037 tools/libxc/xc_domain_save.c --- a/tools/libxc/xc_domain_save.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxc/xc_domain_save.c Wed Nov 14 11:03:24 2012 -0800 @@ -1889,15 +1889,15 @@ int xc_domain_save(xc_interface *xch, in } /* Canonicalise each GDT frame number. */ - for ( j = 0; (512*j) < GET_FIELD(&ctxt, gdt_ents); j++ ) + for ( j = 0; (512*j) < GET_FIELD(&ctxt, u.pv.gdt_ents); j++ ) { - mfn = GET_FIELD(&ctxt, gdt_frames[j]); + mfn = GET_FIELD(&ctxt, u.pv.gdt_frames[j]); if ( !MFN_IS_IN_PSEUDOPHYS_MAP(mfn) ) { ERROR("GDT frame is not in range of pseudophys map"); goto out; } - SET_FIELD(&ctxt, gdt_frames[j], mfn_to_pfn(mfn)); + SET_FIELD(&ctxt, u.pv.gdt_frames[j], mfn_to_pfn(mfn)); } /* Canonicalise the page table base pointer. */ diff -r 8b0762504037 tools/libxl/Makefile --- a/tools/libxl/Makefile Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxl/Makefile Wed Nov 14 11:03:24 2012 -0800 @@ -13,7 +13,7 @@ XLUMINOR = 1 CFLAGS += -Werror -Wno-format-zero-length -Wmissing-declarations \ -Wno-declaration-after-statement -Wformat-nonliteral -CFLAGS += -I. -fPIC +CFLAGS += -I. -fPIC -O0 ifeq ($(CONFIG_Linux),y) LIBUUID_LIBS += -luuid diff -r 8b0762504037 tools/libxl/libxl_create.c --- a/tools/libxl/libxl_create.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxl/libxl_create.c Wed Nov 14 11:03:24 2012 -0800 @@ -409,6 +409,8 @@ int libxl__domain_make(libxl__gc *gc, li flags |= XEN_DOMCTL_CDF_hvm_guest; flags |= libxl_defbool_val(info->hap) ? XEN_DOMCTL_CDF_hap : 0; flags |= libxl_defbool_val(info->oos) ? 0 : XEN_DOMCTL_CDF_oos_off; + } else if ( libxl_defbool_val(info->ci_pvh) ) { + flags |= (XEN_DOMCTL_CDF_pvh_guest | XEN_DOMCTL_CDF_hap); } *domid = -1; diff -r 8b0762504037 tools/libxl/libxl_dom.c --- a/tools/libxl/libxl_dom.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxl/libxl_dom.c Wed Nov 14 11:03:24 2012 -0800 @@ -270,7 +270,8 @@ int libxl__build_pre(libxl__gc *gc, uint if (rtc_timeoffset) xc_domain_set_time_offset(ctx->xch, domid, rtc_timeoffset); - if (info->type == LIBXL_DOMAIN_TYPE_HVM) { + if (info->type == LIBXL_DOMAIN_TYPE_HVM || + libxl_defbool_val(info->bi_pvh) ) { unsigned long shadow; shadow = (info->shadow_memkb + 1023) / 1024; xc_shadow_control(ctx->xch, domid, XEN_DOMCTL_SHADOW_OP_SET_ALLOCATION, NULL, 0, &shadow, 0, NULL); @@ -368,9 +369,15 @@ int libxl__build_pv(libxl__gc *gc, uint3 struct xc_dom_image *dom; int ret; int flags = 0; + int is_pvh = libxl_defbool_val(info->bi_pvh); xc_dom_loginit(ctx->xch); + if (is_pvh) { + printf("info..features:%s\n", info->u.pv.features); + info->u.pv.features = strdup("auto_translated_physmap"); + } + dom = xc_dom_allocate(ctx->xch, state->pv_cmdline, info->u.pv.features); if (!dom) { LIBXL__LOG_ERRNO(ctx, LIBXL__LOG_ERROR, "xc_dom_allocate failed"); @@ -408,6 +415,7 @@ int libxl__build_pv(libxl__gc *gc, uint3 } } + flags |= is_pvh ? SIF_IS_PVH : 0; dom->flags = flags; dom->console_evtchn = state->console_port; dom->console_domid = state->console_domid; @@ -438,7 +446,8 @@ int libxl__build_pv(libxl__gc *gc, uint3 LIBXL__LOG_ERRNO(ctx, LIBXL__LOG_ERROR, "xc_dom_boot_image failed"); goto out; } - if ( (ret = xc_dom_gnttab_init(dom)) != 0 ) { + /* PVH sets up its own grant during boot via hvm mechanisms */ + if ( !is_pvh && (ret = xc_dom_gnttab_init(dom)) != 0 ) { LIBXL__LOG_ERRNO(ctx, LIBXL__LOG_ERROR, "xc_dom_gnttab_init failed"); goto out; } diff -r 8b0762504037 tools/libxl/libxl_types.idl --- a/tools/libxl/libxl_types.idl Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxl/libxl_types.idl Wed Nov 14 11:03:24 2012 -0800 @@ -243,6 +243,7 @@ libxl_domain_create_info = Struct("domai ("platformdata", libxl_key_value_list), ("poolid", uint32), ("run_hotplug_scripts",libxl_defbool), + ("ci_pvh", libxl_defbool), ], dir=DIR_IN) MemKB = UInt(64, init_val = "LIBXL_MEMKB_DEFAULT") @@ -339,6 +340,7 @@ libxl_domain_build_info = Struct("domain ])), ("invalid", Struct(None, [])), ], keyvar_init_val = "LIBXL_DOMAIN_TYPE_INVALID")), + ("bi_pvh", libxl_defbool), ], dir=DIR_IN ) diff -r 8b0762504037 tools/libxl/xl_cmdimpl.c --- a/tools/libxl/xl_cmdimpl.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/libxl/xl_cmdimpl.c Wed Nov 14 11:03:24 2012 -0800 @@ -615,8 +615,18 @@ static void parse_config_data(const char !strncmp(buf, "hvm", strlen(buf))) c_info->type = LIBXL_DOMAIN_TYPE_HVM; + libxl_defbool_setdefault(&c_info->ci_pvh, false); + libxl_defbool_setdefault(&c_info->hap, false); + xlu_cfg_get_defbool(config, "pvh", &c_info->ci_pvh, 0); xlu_cfg_get_defbool(config, "hap", &c_info->hap, 0); + if (libxl_defbool_val(c_info->ci_pvh) && + !libxl_defbool_val(c_info->hap)) { + + fprintf(stderr, "hap is required for PVH domain\n"); + exit(1); + } + if (xlu_cfg_replace_string (config, "name", &c_info->name, 0)) { fprintf(stderr, "Domain name must be specified.\n"); exit(1); @@ -916,6 +926,7 @@ static void parse_config_data(const char b_info->u.pv.cmdline = cmdline; xlu_cfg_replace_string (config, "ramdisk", &b_info->u.pv.ramdisk, 0); + libxl_defbool_set(&b_info->bi_pvh, libxl_defbool_val(c_info->ci_pvh)); break; } default: diff -r 8b0762504037 tools/xenstore/xenstored_domain.c --- a/tools/xenstore/xenstored_domain.c Wed Oct 31 16:08:55 2012 -0700 +++ b/tools/xenstore/xenstored_domain.c Wed Nov 14 11:03:24 2012 -0800 @@ -578,11 +578,13 @@ static int close_xc_handle(void *_handle return 0; } +#if 0 static int close_xcg_handle(void *_handle) { xc_gnttab_close(*(xc_gnttab **)_handle); return 0; } +#endif /* Returns the implicit path of a connection (only domains have this) */ const char *get_implicit_path(const struct connection *conn) @@ -639,12 +641,14 @@ void domain_init(void) if (!xcg_handle) barf_perror("Failed to allocate domain gnttab handle"); +*xcg_handle = NULL; +#if 0 *xcg_handle = xc_gnttab_open(NULL, 0); if (*xcg_handle < 0) xprintf("WARNING: Failed to open connection to gnttab\n"); else talloc_set_destructor(xcg_handle, close_xcg_handle); - +#endif xce_handle = xc_evtchn_open(NULL, 0); if (xce_handle == NULL) diff -r 8b0762504037 xen/arch/x86/debug.c --- a/xen/arch/x86/debug.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/debug.c Wed Nov 14 11:03:24 2012 -0800 @@ -59,7 +59,7 @@ dbg_hvm_va2mfn(dbgva_t vaddr, struct dom return INVALID_MFN; } - mfn = mfn_x(get_gfn(dp, *gfn, &gfntype)); + mfn = mfn_x(get_gfn_query_unlocked(dp, *gfn, &gfntype)); if ( p2m_is_readonly(gfntype) && toaddr ) { DBGP2("kdb:p2m_is_readonly: gfntype:%x\n", gfntype); @@ -153,7 +153,7 @@ dbg_rw_guest_mem(dbgva_t addr, dbgbyte_t pagecnt = min_t(long, PAGE_SIZE - (addr & ~PAGE_MASK), len); - mfn = (dp->is_hvm + mfn = (is_hvm_or_pvh_domain(dp) ? dbg_hvm_va2mfn(addr, dp, toaddr, &gfn) : dbg_pv_va2mfn(addr, dp, pgd3)); if ( mfn == INVALID_MFN ) @@ -173,8 +173,6 @@ dbg_rw_guest_mem(dbgva_t addr, dbgbyte_t } unmap_domain_page(va); - if ( gfn != INVALID_GFN ) - put_gfn(dp, gfn); addr += pagecnt; buf += pagecnt; diff -r 8b0762504037 xen/arch/x86/domain.c --- a/xen/arch/x86/domain.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/domain.c Wed Nov 14 11:03:24 2012 -0800 @@ -410,7 +410,7 @@ int vcpu_initialise(struct vcpu *v) vmce_init_vcpu(v); - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) { rc = hvm_vcpu_initialise(v); goto done; @@ -476,7 +476,7 @@ void vcpu_destroy(struct vcpu *v) vcpu_destroy_fpu(v); - if ( is_hvm_vcpu(v) ) + if ( is_hvm_or_pvh_vcpu(v) ) hvm_vcpu_destroy(v); else if ( standalone_trap_ctxt(v) ) free_xenheap_page(v->arch.pv_vcpu.trap_ctxt); @@ -489,7 +489,7 @@ int arch_domain_create(struct domain *d, int rc = -ENOMEM; d->arch.hvm_domain.hap_enabled = - is_hvm_domain(d) && + is_hvm_or_pvh_domain(d) && hvm_funcs.hap_supported && (domcr_flags & DOMCRF_hap); d->arch.hvm_domain.mem_sharing_enabled = 0; @@ -539,7 +539,7 @@ int arch_domain_create(struct domain *d, __PAGE_HYPERVISOR); HYPERVISOR_COMPAT_VIRT_START(d) = - is_hvm_domain(d) ? ~0u : __HYPERVISOR_COMPAT_VIRT_START; + is_hvm_or_pvh_domain(d) ? ~0u : __HYPERVISOR_COMPAT_VIRT_START; if ( (rc = paging_domain_init(d, domcr_flags)) != 0 ) goto fail; @@ -581,7 +581,7 @@ int arch_domain_create(struct domain *d, goto fail; } - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) { if ( (rc = hvm_domain_initialise(d)) != 0 ) { @@ -593,9 +593,9 @@ int arch_domain_create(struct domain *d, { /* 64-bit PV guest by default. */ d->arch.is_32bit_pv = d->arch.has_32bit_shinfo = 0; - + } + if ( !is_hvm_domain(d) ) spin_lock_init(&d->arch.pv_domain.e820_lock); - } /* initialize default tsc behavior in case tools don't */ tsc_set_info(d, TSC_MODE_DEFAULT, 0UL, 0, 0); @@ -622,9 +622,10 @@ void arch_domain_destroy(struct domain * { unsigned int i; - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) hvm_domain_destroy(d); - else + + if ( !is_hvm_domain(d) ) xfree(d->arch.pv_domain.e820); free_domain_pirqs(d); @@ -683,6 +684,9 @@ int arch_set_info_guest( unsigned int i; int rc = 0, compat; + if ( is_pvh_vcpu(v) && is_pvh_vcpu(current) ) + return -EINVAL; + /* The context is a compat-mode one if the target domain is compat-mode; * we expect the tools to DTRT even in compat-mode callers. */ compat = is_pv_32on64_domain(d); @@ -690,7 +694,7 @@ int arch_set_info_guest( #define c(fld) (compat ? (c.cmp->fld) : (c.nat->fld)) flags = c(flags); - if ( !is_hvm_vcpu(v) ) + if ( !is_hvm_or_pvh_vcpu(v) ) { if ( !compat ) { @@ -743,7 +747,7 @@ int arch_set_info_guest( v->fpu_initialised = !!(flags & VGCF_I387_VALID); v->arch.flags &= ~TF_kernel_mode; - if ( (flags & VGCF_in_kernel) || is_hvm_vcpu(v)/*???*/ ) + if ( (flags & VGCF_in_kernel) || is_hvm_or_pvh_vcpu(v)/*???*/ ) v->arch.flags |= TF_kernel_mode; v->arch.vgc_flags = flags; @@ -752,7 +756,7 @@ int arch_set_info_guest( if ( !compat ) { memcpy(&v->arch.user_regs, &c.nat->user_regs, sizeof(c.nat->user_regs)); - if ( !is_hvm_vcpu(v) ) + if ( !is_hvm_or_pvh_vcpu(v) ) memcpy(v->arch.pv_vcpu.trap_ctxt, c.nat->trap_ctxt, sizeof(c.nat->trap_ctxt)); } @@ -768,10 +772,13 @@ int arch_set_info_guest( v->arch.user_regs.eflags |= 2; - if ( is_hvm_vcpu(v) ) + if ( is_hvm_or_pvh_vcpu(v) ) { hvm_set_info_guest(v); - goto out; + if ( is_hvm_vcpu(v) || v->is_initialised ) + goto out; + else + goto pvh_skip_pv;; } init_int80_direct_trap(v); @@ -780,7 +787,8 @@ int arch_set_info_guest( v->arch.pv_vcpu.iopl = (v->arch.user_regs.eflags >> 12) & 3; v->arch.user_regs.eflags &= ~X86_EFLAGS_IOPL; - /* Ensure real hardware interrupts are enabled. */ + /* Ensure real hardware interrupts are enabled. FYI: PVH may not have + * IDT set on all vcpus so don't enable IF for it yet. */ v->arch.user_regs.eflags |= X86_EFLAGS_IF; if ( !v->is_initialised ) @@ -811,8 +819,8 @@ int arch_set_info_guest( } for ( i = 0; i < ARRAY_SIZE(v->arch.pv_vcpu.gdt_frames); ++i ) - fail |= v->arch.pv_vcpu.gdt_frames[i] != c(gdt_frames[i]); - fail |= v->arch.pv_vcpu.gdt_ents != c(gdt_ents); + fail |= v->arch.pv_vcpu.gdt_frames[i] != c(u.pv.gdt_frames[i]); + fail |= v->arch.pv_vcpu.gdt_ents != c(u.pv.gdt_ents); fail |= v->arch.pv_vcpu.ldt_base != c(ldt_base); fail |= v->arch.pv_vcpu.ldt_ents != c(ldt_ents); @@ -861,21 +869,22 @@ int arch_set_info_guest( d->vm_assist = c(vm_assist); if ( !compat ) - rc = (int)set_gdt(v, c.nat->gdt_frames, c.nat->gdt_ents); + rc = (int)set_gdt(v, c.nat->u.pv.gdt_frames, c.nat->u.pv.gdt_ents); else { unsigned long gdt_frames[ARRAY_SIZE(v->arch.pv_vcpu.gdt_frames)]; - unsigned int n = (c.cmp->gdt_ents + 511) / 512; + unsigned int n = (c.cmp->u.pv.gdt_ents + 511) / 512; if ( n > ARRAY_SIZE(v->arch.pv_vcpu.gdt_frames) ) return -EINVAL; for ( i = 0; i < n; ++i ) - gdt_frames[i] = c.cmp->gdt_frames[i]; - rc = (int)set_gdt(v, gdt_frames, c.cmp->gdt_ents); + gdt_frames[i] = c.cmp->u.pv.gdt_frames[i]; + rc = (int)set_gdt(v, gdt_frames, c.cmp->u.pv.gdt_ents); } if ( rc != 0 ) return rc; +pvh_skip_pv: if ( !compat ) { cr3_gfn = xen_cr3_to_pfn(c.nat->ctrlreg[3]); @@ -883,19 +892,26 @@ int arch_set_info_guest( if ( !cr3_page ) { - destroy_gdt(v); + if ( !is_pvh_vcpu(v) ) + destroy_gdt(v); return -EINVAL; } if ( !paging_mode_refcounts(d) && !get_page_type(cr3_page, PGT_base_page_table) ) { put_page(cr3_page); - destroy_gdt(v); + if ( !is_pvh_vcpu(v) ) + destroy_gdt(v); return -EINVAL; } + if ( is_pvh_vcpu(v) ) { + v->arch.cr3 = page_to_mfn(cr3_page); + v->arch.hvm_vcpu.guest_cr[3] = c.nat->ctrlreg[3]; + } + v->arch.guest_table = pagetable_from_page(cr3_page); - if ( c.nat->ctrlreg[1] ) + if ( c.nat->ctrlreg[1] && !is_pvh_vcpu(v) ) { cr3_gfn = xen_cr3_to_pfn(c.nat->ctrlreg[1]); cr3_page = get_page_from_gfn(d, cr3_gfn, NULL, P2M_ALLOC); @@ -920,7 +936,8 @@ int arch_set_info_guest( } else if ( !(flags & VGCF_in_kernel) ) { - destroy_gdt(v); + if ( !is_pvh_vcpu(v) ) + destroy_gdt(v); return -EINVAL; } } @@ -961,6 +978,13 @@ int arch_set_info_guest( update_cr3(v); + if ( is_pvh_vcpu(v) ) + { + /* guest is bringing up non-boot SMP vcpu */ + if ( (rc=hvm_pvh_set_vcpu_info(v, c.nat)) != 0 ) + return rc; + } + out: if ( flags & VGCF_online ) clear_bit(_VPF_down, &v->pause_flags); @@ -991,16 +1015,21 @@ void arch_vcpu_reset(struct vcpu *v) static void unmap_vcpu_info(struct vcpu *v) { - unsigned long mfn; + unsigned long mfn, *mfnp; - if ( v->arch.pv_vcpu.vcpu_info_mfn == INVALID_MFN ) + if ( is_pvh_vcpu(v) ) + mfnp = &v->arch.hvm_vcpu.hv_pvh.pvh_vcpu_info_mfn; + else + mfnp = &v->arch.pv_vcpu.vcpu_info_mfn; + + mfn = *mfnp; + if ( mfn == INVALID_MFN ) return; - mfn = v->arch.pv_vcpu.vcpu_info_mfn; unmap_domain_page_global(v->vcpu_info); v->vcpu_info = &dummy_vcpu_info; - v->arch.pv_vcpu.vcpu_info_mfn = INVALID_MFN; + *mfnp = INVALID_MFN; put_page_and_type(mfn_to_page(mfn)); } @@ -1011,7 +1040,7 @@ unmap_vcpu_info(struct vcpu *v) * of memory, and it sets a pending event to make sure that a pending * event doesn't get missed. */ -static int +static noinline int map_vcpu_info(struct vcpu *v, unsigned long gfn, unsigned offset) { struct domain *d = v->domain; @@ -1019,11 +1048,17 @@ map_vcpu_info(struct vcpu *v, unsigned l vcpu_info_t *new_info; struct page_info *page; int i; + unsigned long *mfnp; + + if ( is_pvh_vcpu(v) ) + mfnp = &v->arch.hvm_vcpu.hv_pvh.pvh_vcpu_info_mfn; + else + mfnp = &v->arch.pv_vcpu.vcpu_info_mfn; if ( offset > (PAGE_SIZE - sizeof(vcpu_info_t)) ) return -EINVAL; - if ( v->arch.pv_vcpu.vcpu_info_mfn != INVALID_MFN ) + if ( *mfnp != INVALID_MFN ) return -EINVAL; /* Run this command on yourself or on other offline VCPUS. */ @@ -1060,7 +1095,7 @@ map_vcpu_info(struct vcpu *v, unsigned l } v->vcpu_info = new_info; - v->arch.pv_vcpu.vcpu_info_mfn = page_to_mfn(page); + *mfnp = page_to_mfn(page); /* Set new vcpu_info pointer /before/ setting pending flags. */ wmb(); @@ -1370,10 +1405,10 @@ static void save_segments(struct vcpu *v struct cpu_user_regs *regs = &v->arch.user_regs; unsigned int dirty_segment_mask = 0; - regs->ds = read_segment_register(ds); - regs->es = read_segment_register(es); - regs->fs = read_segment_register(fs); - regs->gs = read_segment_register(gs); + regs->ds = read_segment_register(v, regs, ds); + regs->es = read_segment_register(v, regs, es); + regs->fs = read_segment_register(v, regs, fs); + regs->gs = read_segment_register(v, regs, gs); if ( regs->ds ) dirty_segment_mask |= DIRTY_DS; @@ -1466,7 +1501,7 @@ static void update_runstate_area(struct static inline int need_full_gdt(struct vcpu *v) { - return (!is_hvm_vcpu(v) && !is_idle_vcpu(v)); + return (!is_hvm_or_pvh_vcpu(v) && !is_idle_vcpu(v)); } static void __context_switch(void) @@ -1593,7 +1628,7 @@ void context_switch(struct vcpu *prev, s /* Re-enable interrupts before restoring state which may fault. */ local_irq_enable(); - if ( !is_hvm_vcpu(next) ) + if ( !is_hvm_or_pvh_vcpu(next) ) { load_LDT(next); load_segments(next); @@ -2034,7 +2069,7 @@ int domain_relinquish_resources(struct d for_each_vcpu ( d, v ) vcpu_destroy_pagetables(v); - if ( !is_hvm_domain(d) ) + if ( !is_hvm_or_pvh_domain(d) ) { for_each_vcpu ( d, v ) { @@ -2045,6 +2080,7 @@ int domain_relinquish_resources(struct d */ destroy_gdt(v); +/**** PVH: unmap vcpu info here ??????????????? */ unmap_vcpu_info(v); } @@ -2109,7 +2145,7 @@ int domain_relinquish_resources(struct d BUG(); } - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) hvm_domain_relinquish_resources(d); return 0; @@ -2190,7 +2226,7 @@ void vcpu_mark_events_pending(struct vcp if ( already_pending ) return; - if ( is_hvm_vcpu(v) ) + if ( is_hvm_or_pvh_vcpu(v) ) hvm_assert_evtchn_irq(v); else vcpu_kick(v); diff -r 8b0762504037 xen/arch/x86/domain_build.c --- a/xen/arch/x86/domain_build.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/domain_build.c Wed Nov 14 11:03:24 2012 -0800 @@ -35,6 +35,8 @@ #include #include /* for bzimage_parse */ #include +#include +#include #include @@ -307,6 +309,31 @@ static void __init process_dom0_ioports_ } } +static noinline __init void dom0_update_physmap(struct domain *d, unsigned long pfn, + unsigned long mfn, unsigned long vphysmap_s) +{ + if (d->is_pvh) { + int rc = guest_physmap_add_page(d, pfn, mfn, 0); + BUG_ON(rc); /* for now while PVH feature is experimental */ + return; + } + if ( !is_pv_32on64_domain(d) ) + ((unsigned long *)vphysmap_s)[pfn] = mfn; + else + ((unsigned int *)vphysmap_s)[pfn] = mfn; + + set_gpfn_from_mfn(mfn, pfn); +} + +static __init void noinline copy_pvh(char *dest, char *src, int bytes) +{ + int rem = dbg_rw_mem((dbgva_t)dest, (unsigned char *)src, bytes, 0, 1, 0); + if (rem) { + printk("Failed to copy to dom0. len:%d rem:%d\n", bytes, rem); + domain_crash_synchronous(); + } +} + int __init construct_dom0( struct domain *d, const module_t *image, unsigned long image_headroom, @@ -314,6 +341,7 @@ int __init construct_dom0( void *(*bootstrap_map)(const module_t *), char *cmdline) { + char si_buf[PAGE_SIZE], tmp_buf[PAGE_SIZE]; int i, cpu, rc, compatible, compat32, order, machine; struct cpu_user_regs *regs; unsigned long pfn, mfn; @@ -322,7 +350,7 @@ int __init construct_dom0( unsigned long alloc_spfn; unsigned long alloc_epfn; unsigned long initrd_pfn = -1, initrd_mfn = 0; - unsigned long count; + unsigned long count, shared_info_pfn_addr = 0; struct page_info *page = NULL; start_info_t *si; struct vcpu *v = d->vcpu[0]; @@ -480,6 +508,15 @@ int __init construct_dom0( vstartinfo_end = (vstartinfo_start + sizeof(struct start_info) + sizeof(struct dom0_vga_console_info)); + + if ( is_pvh_domain(d) ) { + kdbp("MUK: vstartinfo_end:%lx\n", vstartinfo_end); + shared_info_pfn_addr = round_pgup(vstartinfo_end) - v_start; + vstartinfo_end += PAGE_SIZE; + kdbp("MUK: adjusted vstartinfo_end:%lx shared_info_pfn:%lx\n", + vstartinfo_end, shared_info_pfn_addr); + } + vpt_start = round_pgup(vstartinfo_end); for ( nr_pt_pages = 2; ; nr_pt_pages++ ) { @@ -621,20 +658,30 @@ int __init construct_dom0( maddr_to_page(mpt_alloc)->u.inuse.type_info = PGT_l3_page_table; l3start = __va(mpt_alloc); mpt_alloc += PAGE_SIZE; } - copy_page(l4tab, idle_pg_table); - l4tab[0] = l4e_empty(); /* zap trampoline mapping */ - l4tab[l4_table_offset(LINEAR_PT_VIRT_START)] = - l4e_from_paddr(__pa(l4start), __PAGE_HYPERVISOR); - l4tab[l4_table_offset(PERDOMAIN_VIRT_START)] = - l4e_from_paddr(__pa(d->arch.mm_perdomain_l3), __PAGE_HYPERVISOR); - v->arch.guest_table = pagetable_from_paddr(__pa(l4start)); - if ( is_pv_32on64_domain(d) ) - v->arch.guest_table_user = v->arch.guest_table; + if ( is_pvh_domain(d) ) + { + v->arch.guest_table = pagetable_from_paddr(vpt_start - v_start); + pfn = 0; + } else { + copy_page(l4tab, idle_pg_table); + l4tab[0] = l4e_empty(); /* zap trampoline mapping */ + l4tab[l4_table_offset(LINEAR_PT_VIRT_START)] = + l4e_from_paddr(__pa(l4start), __PAGE_HYPERVISOR); + l4tab[l4_table_offset(PERDOMAIN_VIRT_START)] = + l4e_from_paddr(__pa(d->arch.mm_perdomain_l3), __PAGE_HYPERVISOR); + v->arch.guest_table = pagetable_from_paddr(__pa(l4start)); + if ( is_pv_32on64_domain(d) ) + v->arch.guest_table_user = v->arch.guest_table; + pfn = alloc_spfn; + } l4tab += l4_table_offset(v_start); - pfn = alloc_spfn; for ( count = 0; count < ((v_end-v_start)>>PAGE_SHIFT); count++ ) { + /* initrd chunk's mfns are separate, so we need to adjust for them */ + signed long hyb_adj = is_pvh_domain(d) ? + (-alloc_spfn + PFN_UP(initrd_len))<u.inuse.type_info = PGT_l1_page_table; @@ -661,16 +708,17 @@ int __init construct_dom0( clear_page(l3tab); if ( count == 0 ) l3tab += l3_table_offset(v_start); - *l4tab = l4e_from_paddr(__pa(l3start), L4_PROT); + *l4tab = l4e_from_paddr(__pa(l3start) + hyb_adj, L4_PROT); l4tab++; } - *l3tab = l3e_from_paddr(__pa(l2start), L3_PROT); + *l3tab = l3e_from_paddr(__pa(l2start) + hyb_adj, L3_PROT); l3tab++; } - *l2tab = l2e_from_paddr(__pa(l1start), L2_PROT); + *l2tab = l2e_from_paddr(__pa(l1start) + hyb_adj, L2_PROT); l2tab++; } - if ( count < initrd_pfn || count >= initrd_pfn + PFN_UP(initrd_len) ) + if ( is_pvh_domain(d) || + count < initrd_pfn || count >= initrd_pfn + PFN_UP(initrd_len) ) mfn = pfn++; else mfn = initrd_mfn++; @@ -678,6 +726,9 @@ int __init construct_dom0( L1_PROT : COMPAT_L1_PROT)); l1tab++; + if ( is_pvh_domain(d) ) + continue; + page = mfn_to_page(mfn); if ( (page->u.inuse.type_info == 0) && !get_page_and_type(page, d, PGT_writable_page) ) @@ -714,7 +765,7 @@ int __init construct_dom0( l2tab += l2_table_offset(vpt_start); l1start = l1tab = l2e_to_l1e(*l2tab); l1tab += l1_table_offset(vpt_start); - for ( count = 0; count < nr_pt_pages; count++ ) + for ( count = 0; count < nr_pt_pages && !is_pvh_domain(d); count++ ) { l1e_remove_flags(*l1tab, _PAGE_RW); page = mfn_to_page(l1e_get_pfn(*l1tab)); @@ -758,6 +809,11 @@ int __init construct_dom0( (void)alloc_vcpu(d, i, cpu); } + if ( is_pvh_domain(d) ) + { + v->arch.cr3 = v->arch.hvm_vcpu.guest_cr[3] = + (pagetable_get_pfn(v->arch.guest_table)) << PAGE_SHIFT; + } /* Set up CR3 value for write_ptbase */ if ( paging_mode_enabled(d) ) paging_update_paging_modes(v); @@ -767,34 +823,12 @@ int __init construct_dom0( /* We run on dom0's page tables for the final part of the build process. */ write_ptbase(v); - /* Copy the OS image and free temporary buffer. */ - elf.dest = (void*)vkern_start; - rc = elf_load_binary(&elf); - if ( rc < 0 ) - { - printk("Failed to load the kernel binary\n"); - return rc; - } - bootstrap_map(NULL); + /* Set up start info area. */ + if ( is_pvh_domain(d) ) + si = (start_info_t *)si_buf; + else + si = (start_info_t *)vstartinfo_start; - if ( UNSET_ADDR != parms.virt_hypercall ) - { - if ( (parms.virt_hypercall < v_start) || - (parms.virt_hypercall >= v_end) ) - { - write_ptbase(current); - printk("Invalid HYPERCALL_PAGE field in ELF notes.\n"); - return -1; - } - hypercall_page_initialise( - d, (void *)(unsigned long)parms.virt_hypercall); - } - - /* Free temporary buffers. */ - discard_initial_images(); - - /* Set up start info area. */ - si = (start_info_t *)vstartinfo_start; clear_page(si); si->nr_pages = nr_pages; @@ -803,6 +837,8 @@ int __init construct_dom0( si->flags = SIF_PRIVILEGED | SIF_INITDOMAIN; if ( !vinitrd_start && initrd_len ) si->flags |= SIF_MOD_START_PFN; + if ( is_pvh_domain(d) ) + si->flags |= SIF_IS_PVH; si->flags |= (xen_processor_pmbits << 8) & SIF_PM_MASK; si->pt_base = vpt_start; si->nr_pt_frames = nr_pt_pages; @@ -812,7 +848,7 @@ int __init construct_dom0( count = d->tot_pages; /* Set up the phys->machine table if not part of the initial mapping. */ - if ( parms.p2m_base != UNSET_ADDR ) + if ( parms.p2m_base != UNSET_ADDR && !is_pvh_domain(d) ) { unsigned long va = vphysmap_start; @@ -911,6 +947,11 @@ int __init construct_dom0( panic("Not enough RAM for DOM0 P->M table.\n"); } + if (is_pvh_domain(d) ) + { + hap_set_pvh_alloc_for_dom0(d, nr_pages); + kdbp("MUK: Count is:%d 0x%x\n", count, count); + } /* Write the phys->machine and machine->phys table entries. */ for ( pfn = 0; pfn < count; pfn++ ) { @@ -927,11 +968,8 @@ int __init construct_dom0( if ( pfn > REVERSE_START && (vinitrd_start || pfn < initrd_pfn) ) mfn = alloc_epfn - (pfn - REVERSE_START); #endif - if ( !is_pv_32on64_domain(d) ) - ((unsigned long *)vphysmap_start)[pfn] = mfn; - else - ((unsigned int *)vphysmap_start)[pfn] = mfn; - set_gpfn_from_mfn(mfn, pfn); + dom0_update_physmap(d, pfn, mfn, vphysmap_start); + if (!(pfn & 0xfffff)) process_pending_softirqs(); } @@ -947,8 +985,8 @@ int __init construct_dom0( if ( !page->u.inuse.type_info && !get_page_and_type(page, d, PGT_writable_page) ) BUG(); - ((unsigned long *)vphysmap_start)[pfn] = mfn; - set_gpfn_from_mfn(mfn, pfn); + + dom0_update_physmap(d, pfn, mfn, vphysmap_start); ++pfn; if (!(pfn & 0xfffff)) process_pending_softirqs(); @@ -968,11 +1006,7 @@ int __init construct_dom0( #ifndef NDEBUG #define pfn (nr_pages - 1 - (pfn - (alloc_epfn - alloc_spfn))) #endif - if ( !is_pv_32on64_domain(d) ) - ((unsigned long *)vphysmap_start)[pfn] = mfn; - else - ((unsigned int *)vphysmap_start)[pfn] = mfn; - set_gpfn_from_mfn(mfn, pfn); + dom0_update_physmap(d, pfn, mfn, vphysmap_start); #undef pfn page++; pfn++; if (!(pfn & 0xfffff)) @@ -980,6 +1014,35 @@ int __init construct_dom0( } } + /* Copy the OS image and free temporary buffer. */ + elf.dest = (void*)vkern_start; + rc = elf_load_binary(&elf, is_pvh_domain(d) ); + if ( rc < 0 ) + { + printk("Failed to load the kernel binary\n"); + return rc; + } + bootstrap_map(NULL); + + if ( UNSET_ADDR != parms.virt_hypercall ) + { + void *addr = is_pvh_domain(d) ? tmp_buf : (void *)parms.virt_hypercall; + + if ( (parms.virt_hypercall < v_start) || + (parms.virt_hypercall >= v_end) ) + { + write_ptbase(current); + printk("Invalid HYPERCALL_PAGE field in ELF notes.\n"); + return -1; + } + hypercall_page_initialise(d, addr); + if ( is_pvh_domain(d) ) + copy_pvh((void *)parms.virt_hypercall, tmp_buf, PAGE_SIZE); + } + + /* Free temporary buffers. */ + discard_initial_images(); + if ( initrd_len != 0 ) { si->mod_start = vinitrd_start ?: initrd_pfn; @@ -995,6 +1058,15 @@ int __init construct_dom0( si->console.dom0.info_off = sizeof(struct start_info); si->console.dom0.info_size = sizeof(struct dom0_vga_console_info); } + if ( is_pvh_domain(d) ) { + unsigned long mfn = virt_to_mfn(d->shared_info); + unsigned long pfn = shared_info_pfn_addr>>PAGE_SHIFT; + si->shared_info = shared_info_pfn_addr; + dom0_update_physmap(d, pfn, mfn, 0); + + copy_pvh((char *)vstartinfo_start, si_buf, PAGE_SIZE); + } + kdbp("MUK: si->shared_info:%lx\n", si->shared_info); if ( is_pv_32on64_domain(d) ) xlat_start_info(si, XLAT_start_info_console_dom0); @@ -1007,6 +1079,7 @@ int __init construct_dom0( v->is_initialised = 1; clear_bit(_VPF_down, &v->pause_flags); +/* PVH NOTE: some of these are ignored */ /* * Initial register values: * DS,ES,FS,GS = FLAT_KERNEL_DS @@ -1025,12 +1098,16 @@ int __init construct_dom0( regs->eip = parms.virt_entry; regs->esp = vstack_end; regs->esi = vstartinfo_start; - regs->eflags = X86_EFLAGS_IF; + regs->eflags = X86_EFLAGS_IF | 0x2; - if ( opt_dom0_shadow ) + if ( opt_dom0_shadow ) { + if ( is_pvh_domain(d) ) { + printk("Invalid option dom0_shadow for PVH\n"); + return -EINVAL; + } if ( paging_enable(d, PG_SH_enable) == 0 ) paging_update_paging_modes(v); - + } if ( supervisor_mode_kernel ) { v->arch.pv_vcpu.kernel_ss &= ~3; diff -r 8b0762504037 xen/arch/x86/domctl.c --- a/xen/arch/x86/domctl.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/domctl.c Wed Nov 14 11:03:24 2012 -0800 @@ -46,6 +46,77 @@ static int gdbsx_guest_mem_io( return (iop->remain ? -EFAULT : 0); } +long domctl_memory_mapping(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned long nr_mfns, + int add_map) +{ + int i; + long ret = -EINVAL; + + if ( (mfn + nr_mfns - 1) < mfn || /* wrap? */ + ((mfn | (mfn + nr_mfns - 1)) >> (paddr_bits - PAGE_SHIFT)) || + (gfn + nr_mfns - 1) < gfn ) /* wrap? */ + return ret; + + ret = -EPERM; + if ( !IS_PRIV(current->domain) && + !iomem_access_permitted(current->domain, mfn, mfn + nr_mfns - 1) ) + return ret; + +/* TBD: common code with do_physdev_op() */ + + ret = xsm_iomem_permission(d, mfn, mfn + nr_mfns - 1, add_map); + if ( ret ) + return ret; + + if ( add_map ) + { + if ( !is_pvh_domain(d) ) /* PVH maps lots and lots */ + printk(XENLOG_G_INFO + "memory_map:add: dom%d gfn=%lx mfn=%lx nr=%lx\n", + d->domain_id, gfn, mfn, nr_mfns); + + ret = iomem_permit_access(d, mfn, mfn + nr_mfns - 1); + if ( !ret && paging_mode_translate(d) ) + { + for ( i = 0; !ret && i < nr_mfns; i++ ) + if ( !set_mmio_p2m_entry(d, gfn + i, _mfn(mfn + i)) ) + ret = -EIO; + if ( ret ) + { + printk(XENLOG_G_WARNING + "memory_map:fail: dom%d gfn=%lx mfn=%lx\n", + d->domain_id, gfn + i, mfn + i); + while ( i-- ) + clear_mmio_p2m_entry(d, gfn + i); + if ( iomem_deny_access(d, mfn, mfn + nr_mfns - 1) && + IS_PRIV(current->domain) ) + printk(XENLOG_ERR + "memory_map: failed to deny dom%d access to [%lx,%lx]\n", + d->domain_id, mfn, mfn + nr_mfns - 1); + } + } + } else { + if ( !is_pvh_domain(d) ) /* PVH unmaps lots and lots */ + printk(XENLOG_G_INFO + "memory_map:remove: dom%d gfn=%lx mfn=%lx nr=%lx\n", + d->domain_id, gfn, mfn, nr_mfns); + + if ( paging_mode_translate(d) ) + for ( i = 0; i < nr_mfns; i++ ) + add_map |= !clear_mmio_p2m_entry(d, gfn + i); + ret = iomem_deny_access(d, mfn, mfn + nr_mfns - 1); + if ( !ret && add_map ) + ret = -EIO; + if ( ret && IS_PRIV(current->domain) ) + printk(XENLOG_ERR + "memory_map: error %ld %s dom%d access to [%lx,%lx]\n", + ret, add_map ? "removing" : "denying", d->domain_id, + mfn, mfn + nr_mfns - 1); + } + return ret; +} + long arch_do_domctl( struct xen_domctl *domctl, XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) @@ -825,75 +896,13 @@ long arch_do_domctl( unsigned long mfn = domctl->u.memory_mapping.first_mfn; unsigned long nr_mfns = domctl->u.memory_mapping.nr_mfns; int add = domctl->u.memory_mapping.add_mapping; - unsigned long i; - ret = -EINVAL; - if ( (mfn + nr_mfns - 1) < mfn || /* wrap? */ - ((mfn | (mfn + nr_mfns - 1)) >> (paddr_bits - PAGE_SHIFT)) || - (gfn + nr_mfns - 1) < gfn ) /* wrap? */ - break; - - ret = -EPERM; - if ( !IS_PRIV(current->domain) && - !iomem_access_permitted(current->domain, mfn, mfn + nr_mfns - 1) ) - break; ret = -ESRCH; if ( unlikely((d = rcu_lock_domain_by_id(domctl->domain)) == NULL) ) break; - ret = xsm_iomem_permission(d, mfn, mfn + nr_mfns - 1, add); - if ( ret ) { - rcu_unlock_domain(d); - break; - } - - if ( add ) - { - printk(XENLOG_G_INFO - "memory_map:add: dom%d gfn=%lx mfn=%lx nr=%lx\n", - d->domain_id, gfn, mfn, nr_mfns); - - ret = iomem_permit_access(d, mfn, mfn + nr_mfns - 1); - if ( !ret && paging_mode_translate(d) ) - { - for ( i = 0; !ret && i < nr_mfns; i++ ) - if ( !set_mmio_p2m_entry(d, gfn + i, _mfn(mfn + i)) ) - ret = -EIO; - if ( ret ) - { - printk(XENLOG_G_WARNING - "memory_map:fail: dom%d gfn=%lx mfn=%lx\n", - d->domain_id, gfn + i, mfn + i); - while ( i-- ) - clear_mmio_p2m_entry(d, gfn + i); - if ( iomem_deny_access(d, mfn, mfn + nr_mfns - 1) && - IS_PRIV(current->domain) ) - printk(XENLOG_ERR - "memory_map: failed to deny dom%d access to [%lx,%lx]\n", - d->domain_id, mfn, mfn + nr_mfns - 1); - } - } - } - else - { - printk(XENLOG_G_INFO - "memory_map:remove: dom%d gfn=%lx mfn=%lx nr=%lx\n", - d->domain_id, gfn, mfn, nr_mfns); - - if ( paging_mode_translate(d) ) - for ( i = 0; i < nr_mfns; i++ ) - add |= !clear_mmio_p2m_entry(d, gfn + i); - ret = iomem_deny_access(d, mfn, mfn + nr_mfns - 1); - if ( !ret && add ) - ret = -EIO; - if ( ret && IS_PRIV(current->domain) ) - printk(XENLOG_ERR - "memory_map: error %ld %s dom%d access to [%lx,%lx]\n", - ret, add ? "removing" : "denying", d->domain_id, - mfn, mfn + nr_mfns - 1); - } - + ret = domctl_memory_mapping(d, gfn, mfn, nr_mfns, add); rcu_unlock_domain(d); } break; @@ -1646,17 +1655,21 @@ void arch_get_info_guest(struct vcpu *v, c.nat->gs_base_kernel = hvm_get_shadow_gs_base(v); } } + else if ( is_pvh_vcpu(v) ) + { + printk("PVH: FIXME: arch_get_info_guest()\n"); + } else { c(ldt_base = v->arch.pv_vcpu.ldt_base); c(ldt_ents = v->arch.pv_vcpu.ldt_ents); for ( i = 0; i < ARRAY_SIZE(v->arch.pv_vcpu.gdt_frames); ++i ) - c(gdt_frames[i] = v->arch.pv_vcpu.gdt_frames[i]); - BUILD_BUG_ON(ARRAY_SIZE(c.nat->gdt_frames) != - ARRAY_SIZE(c.cmp->gdt_frames)); - for ( ; i < ARRAY_SIZE(c.nat->gdt_frames); ++i ) - c(gdt_frames[i] = 0); - c(gdt_ents = v->arch.pv_vcpu.gdt_ents); + c(u.pv.gdt_frames[i] = v->arch.pv_vcpu.gdt_frames[i]); + BUILD_BUG_ON(ARRAY_SIZE(c.nat->u.pv.gdt_frames) != + ARRAY_SIZE(c.cmp->u.pv.gdt_frames)); + for ( ; i < ARRAY_SIZE(c.nat->u.pv.gdt_frames); ++i ) + c(u.pv.gdt_frames[i] = 0); + c(u.pv.gdt_ents = v->arch.pv_vcpu.gdt_ents); c(kernel_ss = v->arch.pv_vcpu.kernel_ss); c(kernel_sp = v->arch.pv_vcpu.kernel_sp); for ( i = 0; i < ARRAY_SIZE(v->arch.pv_vcpu.ctrlreg); ++i ) diff -r 8b0762504037 xen/arch/x86/hvm/hvm.c --- a/xen/arch/x86/hvm/hvm.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/hvm.c Wed Nov 14 11:03:24 2012 -0800 @@ -331,6 +331,9 @@ void hvm_do_resume(struct vcpu *v) { ioreq_t *p; + if ( is_pvh_vcpu(v) ) + return; + pt_restore_timer(v); check_wakeup_from_wait(); @@ -499,6 +502,29 @@ static int hvm_print_line( return X86EMUL_OKAY; } +static noinline int hvm_pvh_dom_initialise(struct domain *d) +{ + int rc; + + if (!d->arch.hvm_domain.hap_enabled) + return -EINVAL; + + spin_lock_init(&d->arch.hvm_domain.irq_lock); + hvm_init_guest_time(d); + + hvm_init_cacheattr_region_list(d); + + if ( (rc=paging_enable(d, PG_refcounts|PG_translate|PG_external)) != 0 ) + goto fail1; + + if ( (rc = hvm_funcs.domain_initialise(d)) == 0 ) + return 0; + +fail1: + hvm_destroy_cacheattr_region_list(d); + return rc; +} + int hvm_domain_initialise(struct domain *d) { int rc; @@ -509,6 +535,8 @@ int hvm_domain_initialise(struct domain "on a non-VT/AMDV platform.\n"); return -EINVAL; } + if ( is_pvh_domain(d) ) + return hvm_pvh_dom_initialise(d); spin_lock_init(&d->arch.hvm_domain.pbuf_lock); spin_lock_init(&d->arch.hvm_domain.irq_lock); @@ -572,6 +600,11 @@ int hvm_domain_initialise(struct domain void hvm_domain_relinquish_resources(struct domain *d) { + if ( is_pvh_domain(d) ) + { + pit_deinit(d); + return; + } if ( hvm_funcs.nhvm_domain_relinquish_resources ) hvm_funcs.nhvm_domain_relinquish_resources(d); @@ -597,10 +630,16 @@ void hvm_domain_relinquish_resources(str void hvm_domain_destroy(struct domain *d) { hvm_funcs.domain_destroy(d); + hvm_destroy_cacheattr_region_list(d); + + if ( is_pvh_domain(d) ) { + printk("PVH:skippoing stuff in hvm_domain_destroy(). reexamine me\n"); + return; + } + rtc_deinit(d); stdvga_deinit(d); vioapic_deinit(d); - hvm_destroy_cacheattr_region_list(d); } static int hvm_save_tsc_adjust(struct domain *d, hvm_domain_context_t *h) @@ -1054,12 +1093,44 @@ static int __init __hvm_register_CPU_XSA } __initcall(__hvm_register_CPU_XSAVE_save_and_restore); +static noinline int hvm_pvh_vcpu_initialise(struct vcpu *v) +{ + int rc; + + if ( (rc = hvm_funcs.vcpu_initialise(v)) != 0 ) + return rc; + + softirq_tasklet_init( &v->arch.hvm_vcpu.assert_evtchn_irq_tasklet, + (void(*)(unsigned long))hvm_assert_evtchn_irq, + (unsigned long)v ); + + v->arch.hvm_vcpu.hv_pvh.pvh_vcpu_info_mfn = INVALID_MFN; + v->arch.user_regs.eflags = 2; + v->arch.hvm_vcpu.inject_trap.vector = -1; + + if ( (rc=hvm_vcpu_cacheattr_init(v)) != 0 ) { + hvm_funcs.vcpu_destroy(v); + return rc; + } + + /* during domain shutdown: pvh_vmx_vmexit_handler->emulate_privileged_op + * -> guest_io_read -> pv_pit_handler -> handle_speaker_io -> _spin_lock + * so we call pit_init to initialize the spin lock */ + if ( v->vcpu_id == 0 ) + pit_init(v, cpu_khz); + + return 0; +} + int hvm_vcpu_initialise(struct vcpu *v) { int rc; hvm_asid_flush_vcpu(v); + if ( is_pvh_vcpu(v) ) + return hvm_pvh_vcpu_initialise(v); + if ( (rc = vlapic_init(v)) != 0 ) goto fail1; @@ -1147,11 +1218,14 @@ void hvm_vcpu_destroy(struct vcpu *v) free_compat_arg_xlat(v); +if ( is_pvh_vcpu(v) ) + printk("PVH: fixme: ignoring tasklet kill in hvm_vcpu_destroy(). \n"); +else { tasklet_kill(&v->arch.hvm_vcpu.assert_evtchn_irq_tasklet); hvm_vcpu_cacheattr_destroy(v); vlapic_destroy(v); +} hvm_funcs.vcpu_destroy(v); - /* Event channel is already freed by evtchn_destroy(). */ /*free_xen_event_channel(v, v->arch.hvm_vcpu.xen_port);*/ } diff -r 8b0762504037 xen/arch/x86/hvm/irq.c --- a/xen/arch/x86/hvm/irq.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/irq.c Wed Nov 14 11:03:24 2012 -0800 @@ -405,6 +405,9 @@ struct hvm_intack hvm_vcpu_has_pending_i && vcpu_info(v, evtchn_upcall_pending) ) return hvm_intack_vector(plat->irq.callback_via.vector); + if ( is_pvh_vcpu(v) ) + return hvm_intack_none; + if ( vlapic_accept_pic_intr(v) && plat->vpic[0].int_output ) return hvm_intack_pic(0); diff -r 8b0762504037 xen/arch/x86/hvm/mtrr.c --- a/xen/arch/x86/hvm/mtrr.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/mtrr.c Wed Nov 14 11:03:24 2012 -0800 @@ -553,6 +553,10 @@ int32_t hvm_get_mem_pinned_cacheattr( *type = 0; + if ( is_pvh_domain(d) ) { + printk("PVH: fixme: hvm_get_mem_pinned_cacheattr(). \n"); + return 0; + } if ( !is_hvm_domain(d) ) return 0; @@ -578,6 +582,11 @@ int32_t hvm_set_mem_pinned_cacheattr( { struct hvm_mem_pinned_cacheattr_range *range; + if ( is_pvh_domain(d) ) { + printk("PVH: fixme: hvm_set_mem_pinned_cacheattr()\n"); + return 0; + } + if ( !((type == PAT_TYPE_UNCACHABLE) || (type == PAT_TYPE_WRCOMB) || (type == PAT_TYPE_WRTHROUGH) || @@ -606,6 +615,12 @@ static int hvm_save_mtrr_msr(struct doma struct vcpu *v; struct hvm_hw_mtrr hw_mtrr; struct mtrr_state *mtrr_state; + + if ( is_pvh_domain(d) ) { + printk("PVH: fixme: hvm_save_mtrr_msr()\n"); + return 0; + } + /* save mtrr&pat */ for_each_vcpu(d, v) { @@ -644,6 +659,10 @@ static int hvm_load_mtrr_msr(struct doma struct mtrr_state *mtrr_state; struct hvm_hw_mtrr hw_mtrr; + if ( is_pvh_domain(d) ) { + printk("PVH: fixme: hvm_load_mtrr_msr()\n"); + return 0; + } vcpuid = hvm_load_instance(h); if ( vcpuid >= d->max_vcpus || (v = d->vcpu[vcpuid]) == NULL ) { @@ -693,6 +712,14 @@ uint8_t epte_get_entry_emt(struct domain ((d->vcpu == NULL) || ((v = d->vcpu[0]) == NULL)) ) return MTRR_TYPE_WRBACK; + /* PVH TBD: FIXME: this needs to be studied, figure what need to be done + * for PVH */ + if ( is_pvh_domain(d) ) { + if (direct_mmio) + return MTRR_TYPE_UNCACHABLE; + return MTRR_TYPE_WRBACK; + } + if ( !v->domain->arch.hvm_domain.params[HVM_PARAM_IDENT_PT] ) return MTRR_TYPE_WRBACK; diff -r 8b0762504037 xen/arch/x86/hvm/svm/vmcb.c --- a/xen/arch/x86/hvm/svm/vmcb.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/svm/vmcb.c Wed Nov 14 11:03:24 2012 -0800 @@ -326,7 +326,7 @@ void kdb_dump_vmcb(domid_t did, int vid) rcu_read_lock(&domlist_read_lock); for_each_domain (dp) { - if (!is_hvm_or_hyb_domain(dp) || dp->is_dying) + if (!is_hvm_or_pvh_domain(dp) || dp->is_dying) continue; if (did != 0 && did != dp->domain_id) continue; diff -r 8b0762504037 xen/arch/x86/hvm/vmx/Makefile --- a/xen/arch/x86/hvm/vmx/Makefile Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/vmx/Makefile Wed Nov 14 11:03:24 2012 -0800 @@ -5,3 +5,4 @@ obj-y += vmcs.o obj-y += vmx.o obj-y += vpmu_core2.o obj-y += vvmx.o +obj-y += vmx_pvh.o diff -r 8b0762504037 xen/arch/x86/hvm/vmx/intr.c --- a/xen/arch/x86/hvm/vmx/intr.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/vmx/intr.c Wed Nov 14 11:03:24 2012 -0800 @@ -216,15 +216,16 @@ void vmx_intr_assist(void) return; } - /* Crank the handle on interrupt state. */ - pt_vector = pt_update_irq(v); + if ( !is_pvh_vcpu(v) ) + /* Crank the handle on interrupt state. */ + pt_vector = pt_update_irq(v); do { intack = hvm_vcpu_has_pending_irq(v); if ( likely(intack.source == hvm_intsrc_none) ) goto out; - if ( unlikely(nvmx_intr_intercept(v, intack)) ) + if ( !is_pvh_vcpu(v) && unlikely(nvmx_intr_intercept(v, intack)) ) goto out; intblk = hvm_interrupt_blocked(v, intack); diff -r 8b0762504037 xen/arch/x86/hvm/vmx/vmcs.c --- a/xen/arch/x86/hvm/vmx/vmcs.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/vmx/vmcs.c Wed Nov 14 11:03:24 2012 -0800 @@ -606,7 +606,7 @@ void vmx_vmcs_exit(struct vcpu *v) { /* Don't confuse vmx_do_resume (for @v or @current!) */ vmx_clear_vmcs(v); - if ( is_hvm_vcpu(current) ) + if ( is_hvm_or_pvh_vcpu(current) ) vmx_load_vmcs(current); spin_unlock(&v->arch.hvm_vmx.vmcs_lock); @@ -697,6 +697,306 @@ void vmx_vmcs_switch(struct vmcs_struct spin_unlock(&vmx->vmcs_lock); } +static noinline int pvh_construct_vmcs(struct vcpu *v) +{ + struct domain *d = v->domain; + uint16_t sysenter_cs; + unsigned long sysenter_eip; + u32 vmexit_ctl = vmx_vmexit_control; + u32 vmentry_ctl = vmx_vmentry_control; + u64 u64val = -1; + + vmx_vmcs_enter(v); + + /* VMCS controls. */ + vmx_pin_based_exec_control &= ~PIN_BASED_VIRTUAL_NMIS; + __vmwrite(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_control); + + v->arch.hvm_vmx.exec_control = vmx_cpu_based_exec_control; + + /* if ( v->domain->arch.vtsc ) */ + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_RDTSC_EXITING; +v->arch.hvm_vmx.exec_control &= ~CPU_BASED_USE_TSC_OFFSETING; + + if ( !paging_mode_hap(d) ) + { + printk("ERROR: HAP is required to run PV in HVM container\n"); + goto out; + } + v->arch.hvm_vmx.exec_control &= ~(CPU_BASED_INVLPG_EXITING | + CPU_BASED_CR3_LOAD_EXITING | + CPU_BASED_CR3_STORE_EXITING); + v->arch.hvm_vmx.exec_control |= CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_MONITOR_TRAP_FLAG; +#if 0 + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_ACTIVATE_IO_BITMAP; /* ??? */ +#endif + v->arch.hvm_vmx.exec_control |= CPU_BASED_ACTIVATE_MSR_BITMAP; + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_TPR_SHADOW; + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; + + kdbp("MUK: writing proc based exec controls:%x\n", + v->arch.hvm_vmx.exec_control); + __vmwrite(CPU_BASED_VM_EXEC_CONTROL, v->arch.hvm_vmx.exec_control); + + /* I/O access bitmap. */ + __vmwrite(IO_BITMAP_A, virt_to_maddr((char *)hvm_io_bitmap + 0)); + __vmwrite(IO_BITMAP_B, virt_to_maddr((char *)hvm_io_bitmap + PAGE_SIZE)); + + /* MSR access bitmap. */ + if ( cpu_has_vmx_msr_bitmap ) + { + unsigned long *msr_bitmap = alloc_xenheap_page(); + int msr_type = MSR_TYPE_R | MSR_TYPE_W; + + if ( msr_bitmap == NULL ) + goto out; + + memset(msr_bitmap, ~0, PAGE_SIZE); + v->arch.hvm_vmx.msr_bitmap = msr_bitmap; + __vmwrite(MSR_BITMAP, virt_to_maddr(msr_bitmap)); + + vmx_disable_intercept_for_msr(v, MSR_FS_BASE, msr_type); + vmx_disable_intercept_for_msr(v, MSR_GS_BASE, msr_type); + vmx_disable_intercept_for_msr(v, MSR_IA32_SYSENTER_CS, msr_type); + vmx_disable_intercept_for_msr(v, MSR_IA32_SYSENTER_ESP, msr_type); + vmx_disable_intercept_for_msr(v, MSR_IA32_SYSENTER_EIP, msr_type); + vmx_disable_intercept_for_msr(v, MSR_SHADOW_GS_BASE, msr_type); + + /* pure hvm doesn't do this. safe? see: long_mode_do_msr_write() */ +#if 0 + vmx_disable_intercept_for_msr(v, MSR_STAR); + vmx_disable_intercept_for_msr(v, MSR_LSTAR); + vmx_disable_intercept_for_msr(v, MSR_CSTAR); + vmx_disable_intercept_for_msr(v, MSR_SYSCALL_MASK); +#endif + kdbp("MUK: disabled intercepts for few msrs\n"); + + } else { + kdbp("MUK: CPU does NOT have msr bitmap\n"); + for (;;) cpu_relax(); + } + + if ( !cpu_has_vmx_vpid ) { + printk("ERROR: VPID support is required to run PV in HVM container\n"); + goto out; + } + + v->arch.hvm_vmx.secondary_exec_control = vmx_secondary_exec_control; + + if ( cpu_has_vmx_secondary_exec_control ) { + v->arch.hvm_vmx.secondary_exec_control &= ~0x4FF; /* turn off all */ +#if 0 + v->arch.hvm_vmx.secondary_exec_control &= + ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; + v->arch.hvm_vmx.secondary_exec_control &= ~SECONDARY_EXEC_ENABLE_RDTSCP; + + v->arch.hvm_vmx.secondary_exec_control &= + ~SECONDARY_EXEC_UNRESTRICTED_GUEST; +#endif + v->arch.hvm_vmx.secondary_exec_control |= + SECONDARY_EXEC_PAUSE_LOOP_EXITING; + v->arch.hvm_vmx.secondary_exec_control |= SECONDARY_EXEC_ENABLE_VPID; + + if ( paging_mode_hap(d) ) + v->arch.hvm_vmx.secondary_exec_control |= SECONDARY_EXEC_ENABLE_EPT; + + kdbp("MUK: muk_construct_vmcs: sec exec:0x%x\n", + v->arch.hvm_vmx.secondary_exec_control); + __vmwrite(SECONDARY_VM_EXEC_CONTROL, + v->arch.hvm_vmx.secondary_exec_control); + } else { + printk("ERROR: NO Secondary Exec control\n"); + goto out; + } + + /* __vmwrite(VIRTUAL_PROCESSOR_ID, v->arch.hvm_vcpu.asid); */ + + if ( !paging_mode_hap(d) ) + vmexit_ctl &= ~(VM_EXIT_SAVE_GUEST_PAT | VM_EXIT_LOAD_HOST_PAT); + __vmwrite(VM_EXIT_CONTROLS, vmexit_ctl); + + #define VM_ENTRY_LOAD_DEBUG_CTLS 0x4 + #define VM_ENTRY_LOAD_EFER 0x8000 + #define GUEST_EFER 0x2806 /* see page 23-20 */ + #define GUEST_EFER_HIGH 0x2807 /* see page 23-20 */ + vmentry_ctl &= ~VM_ENTRY_LOAD_DEBUG_CTLS; + vmentry_ctl &= ~VM_ENTRY_LOAD_EFER; + vmentry_ctl &= ~VM_ENTRY_SMM; + vmentry_ctl &= ~VM_ENTRY_DEACT_DUAL_MONITOR; + vmentry_ctl |= VM_ENTRY_IA32E_MODE; + if ( !paging_mode_hap(d) ) + vmentry_ctl &= ~VM_ENTRY_LOAD_GUEST_PAT; + kdbp("MUK:muk_construct_vmcs(). vmentry_ctl:0x%x\n", vmentry_ctl); + __vmwrite(VM_ENTRY_CONTROLS, vmentry_ctl); + + /* MSR intercepts. */ + __vmwrite(VM_ENTRY_MSR_LOAD_COUNT, 0); + __vmwrite(VM_EXIT_MSR_LOAD_COUNT, 0); + __vmwrite(VM_EXIT_MSR_STORE_COUNT, 0); + + /* Host data selectors. */ + __vmwrite(HOST_SS_SELECTOR, __HYPERVISOR_DS); + __vmwrite(HOST_DS_SELECTOR, __HYPERVISOR_DS); + __vmwrite(HOST_ES_SELECTOR, __HYPERVISOR_DS); + __vmwrite(HOST_FS_SELECTOR, 0); + __vmwrite(HOST_GS_SELECTOR, 0); + __vmwrite(HOST_FS_BASE, 0); + __vmwrite(HOST_GS_BASE, 0); + + vmx_set_host_env(v); + + /* Host control registers. */ + v->arch.hvm_vmx.host_cr0 = read_cr0() | X86_CR0_TS; + __vmwrite(HOST_CR0, v->arch.hvm_vmx.host_cr0); + __vmwrite(HOST_CR4, mmu_cr4_features|(cpu_has_xsave ? X86_CR4_OSXSAVE : 0)); + + /* Host CS:RIP. */ + __vmwrite(HOST_CS_SELECTOR, __HYPERVISOR_CS); + __vmwrite(HOST_RIP, (unsigned long)vmx_asm_vmexit_handler); + + /* Host SYSENTER CS:RIP. */ + rdmsrl(MSR_IA32_SYSENTER_CS, sysenter_cs); + __vmwrite(HOST_SYSENTER_CS, sysenter_cs); + rdmsrl(MSR_IA32_SYSENTER_EIP, sysenter_eip); + __vmwrite(HOST_SYSENTER_EIP, sysenter_eip); + + __vmwrite(VM_ENTRY_INTR_INFO, 0); + + __vmwrite(CR3_TARGET_COUNT, 0); + + __vmwrite(GUEST_ACTIVITY_STATE, 0); + + /* Set default guest context values here. Some of these are then overwritten + * in vmx_pvh_set_vcpu_info() by guest itself during vcpu bringup */ + __vmwrite(GUEST_CS_BASE, 0); + __vmwrite(GUEST_CS_LIMIT, ~0u); + __vmwrite(GUEST_CS_AR_BYTES, 0xa09b); /* CS.L == 1 */ + __vmwrite(GUEST_CS_SELECTOR, 0x10); + + __vmwrite(GUEST_DS_BASE, 0); + __vmwrite(GUEST_DS_LIMIT, ~0u); + __vmwrite(GUEST_DS_AR_BYTES, 0xc093); + __vmwrite(GUEST_DS_SELECTOR, 0x18); + + __vmwrite(GUEST_SS_BASE, 0); /* use same seg as DS */ + __vmwrite(GUEST_SS_LIMIT, ~0u); + __vmwrite(GUEST_SS_AR_BYTES, 0xc093); + __vmwrite(GUEST_SS_SELECTOR, 0x18); + + __vmwrite(GUEST_ES_SELECTOR, 0); + __vmwrite(GUEST_FS_SELECTOR, 0); + __vmwrite(GUEST_GS_SELECTOR, 0); + + /* Guest segment bases. */ + __vmwrite(GUEST_ES_BASE, 0); + __vmwrite(GUEST_FS_BASE, 0); + __vmwrite(GUEST_GS_BASE, 0); + + /* Guest segment limits. */ + __vmwrite(GUEST_ES_LIMIT, ~0u); + __vmwrite(GUEST_FS_LIMIT, ~0u); + __vmwrite(GUEST_GS_LIMIT, ~0u); + + /* Guest segment AR bytes. */ + __vmwrite(GUEST_ES_AR_BYTES, 0xc093); /* read/write, accessed */ + __vmwrite(GUEST_FS_AR_BYTES, 0xc093); + __vmwrite(GUEST_GS_AR_BYTES, 0xc093); + + /* Guest IDT. */ + __vmwrite(GUEST_GDTR_BASE, 0); + __vmwrite(GUEST_GDTR_LIMIT, 0); + + /* Guest LDT. */ + __vmwrite(GUEST_LDTR_AR_BYTES, 0x82); /* LDT */ + __vmwrite(GUEST_LDTR_SELECTOR, 0); + __vmwrite(GUEST_LDTR_BASE, 0); + __vmwrite(GUEST_LDTR_LIMIT, 0); + + /* Guest TSS. */ + __vmwrite(GUEST_TR_AR_BYTES, 0x8b); /* 32-bit TSS (busy) */ + __vmwrite(GUEST_TR_BASE, 0); + __vmwrite(GUEST_TR_LIMIT, 0xff); + + __vmwrite(GUEST_INTERRUPTIBILITY_INFO, 0); + __vmwrite(GUEST_DR7, 0); + __vmwrite(VMCS_LINK_POINTER, ~0UL); + + __vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0); + __vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, 0); + + v->arch.hvm_vmx.exception_bitmap = + HVM_TRAP_MASK | (1 << TRAP_debug) | + (1U << TRAP_int3) | (1U << TRAP_no_device); + __vmwrite(EXCEPTION_BITMAP, v->arch.hvm_vmx.exception_bitmap); + +#if 0 + __vmwrite(EXCEPTION_BITMAP, + HVM_TRAP_MASK | (1<arch.hvm_vcpu.guest_cr[0] = X86_CR0_PG | X86_CR0_PE | X86_CR0_ET; + hvm_update_guest_cr(v, 0); + + v->arch.hvm_vcpu.guest_cr[4] = 0; + hvm_update_guest_cr(v, 4); +#endif + +#if 0 + u64val = X86_CR0_PG | X86_CR0_PE | X86_CR0_ET | X86_CR0_TS | + X86_CR0_NE | X86_CR0_WP; +#endif + /* make sure to set WP bit so rdonly pages are not written from CPL 0 */ + u64val = X86_CR0_PG | X86_CR0_NE | X86_CR0_PE | X86_CR0_WP; + __vmwrite(GUEST_CR0, u64val); + __vmwrite(CR0_READ_SHADOW, u64val); + v->arch.hvm_vcpu.hw_cr[0] = v->arch.hvm_vcpu.guest_cr[0] = u64val; + + u64val = X86_CR4_PAE | X86_CR4_VMXE; + __vmwrite(GUEST_CR4, u64val); + __vmwrite(CR4_READ_SHADOW, u64val); + v->arch.hvm_vcpu.guest_cr[4] = u64val; + + __vmwrite(CR0_GUEST_HOST_MASK, ~0UL); + __vmwrite(CR4_GUEST_HOST_MASK, ~0UL); + + v->arch.hvm_vmx.vmx_realmode = 0; + + if ( paging_mode_hap(d) ) + { + __vmwrite(EPT_POINTER, d->arch.hvm_domain.vmx.ept_control.eptp); +#ifdef __i386__ + __vmwrite(EPT_POINTER_HIGH, + d->arch.hvm_domain.vmx.ept_control.eptp >> 32); +#endif + } + + if ( cpu_has_vmx_pat && paging_mode_hap(d) ) + { + u64 host_pat, guest_pat; + + rdmsrl(MSR_IA32_CR_PAT, host_pat); + guest_pat = MSR_IA32_CR_PAT_RESET; + + __vmwrite(HOST_PAT, host_pat); + __vmwrite(GUEST_PAT, guest_pat); +#ifdef __i386__ +JUNK + __vmwrite(HOST_PAT_HIGH, host_pat >> 32); + __vmwrite(GUEST_PAT_HIGH, guest_pat >> 32); +#endif + } +out: + vmx_vmcs_exit(v); +#if 0 + paging_update_paging_modes(v); /* will update HOST & GUEST_CR3 as reqd */ +#endif + return 0; +} + static int construct_vmcs(struct vcpu *v) { struct domain *d = v->domain; @@ -705,6 +1005,9 @@ static int construct_vmcs(struct vcpu *v u32 vmexit_ctl = vmx_vmexit_control; u32 vmentry_ctl = vmx_vmentry_control; + if ( is_pvh_vcpu(v) ) + return pvh_construct_vmcs(v); + vmx_vmcs_enter(v); /* VMCS controls. */ @@ -1143,9 +1446,11 @@ void vmx_do_resume(struct vcpu *v) vmx_clear_vmcs(v); vmx_load_vmcs(v); - hvm_migrate_timers(v); - hvm_migrate_pirqs(v); - vmx_set_host_env(v); + if ( !is_pvh_vcpu(v) ) { + hvm_migrate_timers(v); + hvm_migrate_pirqs(v); + vmx_set_host_env(v); + } /* * Both n1 VMCS and n2 VMCS need to update the host environment after * VCPU migration. The environment of current VMCS is updated in place, @@ -1163,6 +1468,9 @@ void vmx_do_resume(struct vcpu *v) __vmwrite(GUEST_DR7, 0); #endif + if ( is_pvh_vcpu(v) ) + goto skip_inteLdbgr; /* PVH supports gdbsx and gdb inside PVH */ + debug_state = v->domain->debugger_attached || v->domain->arch.hvm_domain.params[HVM_PARAM_MEMORY_EVENT_INT3] || v->domain->arch.hvm_domain.params[HVM_PARAM_MEMORY_EVENT_SINGLE_STEP]; @@ -1173,18 +1481,11 @@ void vmx_do_resume(struct vcpu *v) vmx_update_debug_state(v); } +skip_inteLdbgr: hvm_do_resume(v); reset_stack_and_jump(vmx_asm_do_vmentry); } -static unsigned long vmr(unsigned long field) -{ - int rc; - unsigned long val; - val = __vmread_safe(field, &rc); - return rc ? 0 : val; -} - static void vmx_dump_sel(char *name, uint32_t selector) { uint32_t sel, attr, limit; @@ -1346,7 +1647,7 @@ static void vmcs_dump(unsigned char ch) for_each_domain ( d ) { - if ( !is_hvm_domain(d) ) + if ( !is_hvm_or_pvh_domain(d) ) continue; printk("\n>>> Domain %d <<<\n", d->domain_id); for_each_vcpu ( d, v ) @@ -1531,7 +1832,7 @@ void kdb_curr_cpu_flush_vmcs(void) /* looks like we got one. unfortunately, current_vmcs points to vmcs * and not VCPU, so we gotta search the entire list... */ for_each_domain (dp) { - if ( !(is_hvm_or_hyb_domain(dp)) || dp->is_dying) + if ( !(is_hvm_or_pvh_domain(dp)) || dp->is_dying) continue; for_each_vcpu (dp, vp) { if ( vp->arch.hvm_vmx.vmcs == cvp ) { @@ -1562,7 +1863,7 @@ void kdb_dump_vmcs(domid_t did, int vid) __vmptrst(&addr); for_each_domain (dp) { - if ( !(is_hvm_or_hyb_domain(dp)) || dp->is_dying) + if ( !(is_hvm_or_pvh_domain(dp)) || dp->is_dying) continue; if (did != 0 && did != dp->domain_id) continue; diff -r 8b0762504037 xen/arch/x86/hvm/vmx/vmx.c --- a/xen/arch/x86/hvm/vmx/vmx.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/hvm/vmx/vmx.c Wed Nov 14 11:03:24 2012 -0800 @@ -55,6 +55,7 @@ #include #include #include +#include enum handler_return { HNDL_done, HNDL_unhandled, HNDL_exception_raised }; @@ -92,6 +93,9 @@ static int vmx_domain_initialise(struct if ( !zalloc_cpumask_var(&d->arch.hvm_domain.vmx.ept_synced) ) return -ENOMEM; + if ( is_pvh_domain(d) ) + return 0; + if ( (rc = vmx_alloc_vlapic_mapping(d)) != 0 ) { free_cpumask_var(d->arch.hvm_domain.vmx.ept_synced); @@ -129,6 +133,12 @@ static int vmx_vcpu_initialise(struct vc vpmu_initialise(v); + if (is_pvh_vcpu(v) ) + { + /* this for hvm_long_mode_enabled(v) */ + v->arch.hvm_vcpu.guest_efer = EFER_SCE | EFER_LMA | EFER_LME; + return 0; + } vmx_install_vlapic_mapping(v); /* %eax == 1 signals full real-mode support to the guest loader. */ @@ -366,6 +376,10 @@ static int vmx_guest_x86_mode(struct vcp { unsigned int cs_ar_bytes; +/* PVH: fixme : look at vmcs.cs?? or just assume 8 ?? */ +if ( is_pvh_vcpu(v) ) + return 8; + if ( unlikely(!(v->arch.hvm_vcpu.guest_cr[0] & X86_CR0_PE)) ) return 0; if ( unlikely(guest_cpu_user_regs()->eflags & X86_EFLAGS_VM) ) @@ -593,7 +607,7 @@ static int vmx_load_vmcs_ctxt(struct vcp return 0; } -static void vmx_fpu_enter(struct vcpu *v) +void vmx_fpu_enter(struct vcpu *v) { vcpu_restore_fpu_lazy(v); v->arch.hvm_vmx.exception_bitmap &= ~(1u << TRAP_no_device); @@ -1051,6 +1065,25 @@ static void vmx_update_host_cr3(struct v vmx_vmcs_exit(v); } +static noinline void vmx_update_pvh_cr(struct vcpu *v, unsigned int cr) +{ + vmx_vmcs_enter(v); + switch ( cr ) + { + case 3: + __vmwrite(GUEST_CR3, v->arch.hvm_vcpu.guest_cr[3]); +kdbp("pvh: d:%d update cr3:%lx\n", v->domain->domain_id, v->arch.hvm_vcpu.guest_cr[3]); + hvm_asid_flush_vcpu(v); + break; + + default: + printk("pvh: d%d v%d unexpected cr%d rip:%lx update\n", + v->domain->domain_id, v->vcpu_id, cr, __vmread(GUEST_RIP)); + kdb_trap_immed(KDB_TRAP_NONFATAL); + } + vmx_vmcs_exit(v); +} + void vmx_update_debug_state(struct vcpu *v) { unsigned long mask; @@ -1070,6 +1103,11 @@ void vmx_update_debug_state(struct vcpu static void vmx_update_guest_cr(struct vcpu *v, unsigned int cr) { + if ( is_pvh_vcpu(v) ) { + vmx_update_pvh_cr(v, cr); + return; + } + vmx_vmcs_enter(v); switch ( cr ) @@ -1267,7 +1305,7 @@ static int nvmx_vmexit_trap(struct vcpu return NESTEDHVM_VMEXIT_DONE; } -static void __vmx_inject_exception(int trap, int type, int error_code) +static noinline void __vmx_inject_exception(int trap, int type, int error_code) { unsigned long intr_fields; struct vcpu *curr = current; @@ -1511,7 +1549,10 @@ static struct hvm_function_table __read_ .nhvm_intr_blocked = nvmx_intr_blocked, .nhvm_domain_relinquish_resources = nvmx_domain_relinquish_resources, .update_eoi_exit_bitmap = vmx_update_eoi_exit_bitmap, - .virtual_intr_delivery_enabled = vmx_virtual_intr_delivery_enabled + .virtual_intr_delivery_enabled = vmx_virtual_intr_delivery_enabled, + .pvh_update_cr3 = vmx_pvh_update_cr3, + .pvh_set_vcpu_info = vmx_pvh_set_vcpu_info, + .pvh_read_descriptor = vmx_pvh_read_descriptor }; struct hvm_function_table * __init start_vmx(void) @@ -1543,19 +1584,7 @@ struct hvm_function_table * __init start return &vmx_function_table; } -/* - * Not all cases receive valid value in the VM-exit instruction length field. - * Callers must know what they're doing! - */ -static int get_instruction_length(void) -{ - int len; - len = __vmread(VM_EXIT_INSTRUCTION_LEN); /* Safe: callers audited */ - BUG_ON((len < 1) || (len > 15)); - return len; -} - -static void update_guest_eip(void) +void update_guest_eip(void) { struct cpu_user_regs *regs = guest_cpu_user_regs(); unsigned long x; @@ -1633,8 +1662,8 @@ static void vmx_do_cpuid(struct cpu_user regs->edx = edx; } -static void vmx_dr_access(unsigned long exit_qualification, - struct cpu_user_regs *regs) +void vmx_dr_access(unsigned long exit_qualification, + struct cpu_user_regs *regs) { struct vcpu *v = current; @@ -2009,7 +2038,7 @@ gp_fault: return X86EMUL_EXCEPTION; } -static void vmx_do_extint(struct cpu_user_regs *regs) +void vmx_do_extint(struct cpu_user_regs *regs) { unsigned int vector; @@ -2260,6 +2289,14 @@ void vmx_vmexit_handler(struct cpu_user_ perfc_incra(vmexits, exit_reason); + if ( is_pvh_vcpu(v) ) { + if ( unlikely(exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) ) + return vmx_failed_vmentry(exit_reason, regs); + + pvh_vmx_vmexit_handler(regs); + return; + } + /* Handle the interrupt we missed before allowing any more in. */ switch ( (uint16_t)exit_reason ) { diff -r 8b0762504037 xen/arch/x86/hvm/vmx/vmx_pvh.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/arch/x86/hvm/vmx/vmx_pvh.c Wed Nov 14 11:03:24 2012 -0800 @@ -0,0 +1,1109 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if 0 +enum handler_return { HNDL_done, HNDL_unhandled, HNDL_exception_raised }; +extern enum handler_return long_mode_do_msr_read(struct cpu_user_regs *); +extern enum handler_return long_mode_do_msr_write(struct cpu_user_regs *); +#endif + +volatile int mukprint=0, mukspin=1; +#define dbgp0(...) dprintk(XENLOG_ERR, __VA_ARGS__); +#define dbgp1(...) {(mukprint==1) ? kdbp(__VA_ARGS__):0;} +#define dbgp2(...) {(mukprint==2) ? kdbp(__VA_ARGS__):0;} + + +static void read_vmcs_selectors(struct cpu_user_regs *regs) +{ + regs->cs = vmr(GUEST_CS_SELECTOR); + regs->ss = vmr(GUEST_SS_SELECTOR); + regs->ds = vmr(GUEST_DS_SELECTOR); + regs->es = vmr(GUEST_ES_SELECTOR); + regs->gs = vmr(GUEST_GS_SELECTOR); + regs->fs = vmr(GUEST_FS_SELECTOR); +} + +/* returns : 0 success */ +static noinline int vmxit_msr_read(struct cpu_user_regs *regs) +{ + int rc=1; + + u64 msr_content = 0; + switch (regs->ecx) + { + case MSR_IA32_MISC_ENABLE: + { + rdmsrl(MSR_IA32_MISC_ENABLE, msr_content); + msr_content |= MSR_IA32_MISC_ENABLE_BTS_UNAVAIL | + MSR_IA32_MISC_ENABLE_PEBS_UNAVAIL; + break; + } + default: + { + rdmsrl(regs->ecx, msr_content); + break; + } + } + regs->eax = (uint32_t)msr_content; + regs->edx = (uint32_t)(msr_content >> 32); + update_guest_eip(); + rc = 0; + +#if 0 + rc = (long_mode_do_msr_read(regs) == HNDL_done) ? 0 : 1; + + if ( hvm_msr_read_intercept(regs) == X86EMUL_OKAY ) { + update_guest_eip(); + rc = 0; + } +#endif + + dbgp1("msr read c:%lx a:%lx d:%lx RIP:%lx RSP:%lx\n", regs->ecx, regs->eax, + regs->edx, vmr(GUEST_RIP), vmr(GUEST_RSP)); + return rc; +} + +/* for now just scratch the cpu since nothing else will run on it. eventually + * we need to save and restore these MSRs + * returns : 0 success */ +static noinline int vmxit_msr_write(struct cpu_user_regs *regs) +{ + uint64_t msr_content = (uint32_t)regs->eax | ((uint64_t)regs->edx << 32); + int rc=1; +#if 0 + wrmsr(regs->ecx, regs->eax, regs->edx); + + rc = (long_mode_do_msr_write(regs) == HNDL_done) ? 0 : 1; + return rc; +#endif + + dbgp1("MUK: msr write:0x%lx. eax:0x%lx edx:0x%lx\n", regs->ecx, + regs->eax,regs->edx); + if ( hvm_msr_write_intercept(regs->ecx, msr_content) == X86EMUL_OKAY ) { + update_guest_eip(); + rc = 0; + } + return rc; +} + +/* rc == 0: handled the MTF vmexit */ +static noinline int vmxit_mtf(struct cpu_user_regs *regs) +{ + struct vcpu *vp = current; + int rc=1, ss=vp->arch.hvm_vcpu.single_step; + + dbgp2("\n"); + vp->arch.hvm_vmx.exec_control &= ~CPU_BASED_MONITOR_TRAP_FLAG; + __vmwrite(CPU_BASED_VM_EXEC_CONTROL, vp->arch.hvm_vmx.exec_control); + vp->arch.hvm_vcpu.single_step = 0; + + /* kdb will set hvm_vcpu.single_step again if ss command */ + if (kdb_handle_trap_entry(TRAP_debug, regs)) { /* TBD: ifdef KDB */ + rc = 0; + } else if ( vp->domain->debugger_attached && ss ) { + domain_pause_for_debugger(); + rc = 0; + } + return rc; +} + +static noinline int vmxit_int3(struct cpu_user_regs *regs) +{ + struct vcpu *vp = current; + + if ( vp->domain->debugger_attached ) { + update_guest_eip(); + + if (kdb_handle_trap_entry(TRAP_int3, regs)) + return 0; + else + /* gdbsx or another debugger. Never pause dom0 */ + if ( vp->domain->domain_id != 0 && guest_kernel_mode(vp, regs) ) + { + kdbp("[%d]MUK: domain pause for debugger\n",smp_processor_id()); + current->arch.gdbsx_vcpu_event = TRAP_int3; + domain_pause_for_debugger(); + } + + } else { /* User mode exception. Inject into the guest */ + + /* int ilen = get_instruction_length(); */ + struct hvm_trap trap_info = { + .vector = TRAP_int3, + .type = X86_EVENTTYPE_SW_EXCEPTION, + .error_code = HVM_DELIVER_NO_ERROR_CODE, + .insn_len = get_instruction_length() + }; + hvm_inject_trap(&trap_info); + } + return 0; +} + +volatile int mukprintpf; +/* rc == 0: handled the exception or NMI */ +static noinline int vmxit_exception(struct cpu_user_regs *regs) +{ + unsigned int vector = (__vmread(VM_EXIT_INTR_INFO)) & INTR_INFO_VECTOR_MASK; + int rc=1; + struct vcpu *vp = current; + + dbgp2(" EXCPT: vec:%d cs:%x r.IP:%lx\n", vector, vmr(GUEST_CS_SELECTOR), + regs->eip); + + if (vector == TRAP_debug) { + unsigned long exit_qualification = __vmread(EXIT_QUALIFICATION); + write_debugreg(6, exit_qualification | 0xffff0ff0); + regs->rip = vmr(GUEST_RIP); + regs->rsp = vmr(GUEST_RSP); + rc = 0; + if (kdb_handle_trap_entry(vector, regs)) /* TBD: ifdef KDB */ + return 0; + else { + /* gdbsx or another debugger */ + if ( vp->domain->domain_id != 0 && /* never pause dom0 */ + guest_kernel_mode(vp, regs) && vp->domain->debugger_attached ) + { + domain_pause_for_debugger(); + } else { + hvm_inject_hw_exception(TRAP_debug, HVM_DELIVER_NO_ERROR_CODE); + } + } + } + if (vector == TRAP_int3) { + rc = vmxit_int3(regs); + } + + if (vector == TRAP_invalid_op) { +#if 0 +kdbp("MUK: invalid op. injection exception. rip:%lx\n", (ulong)vmr(GUEST_RIP)); +kdb_trap_immed(KDB_TRAP_NONFATAL); + hvm_inject_hw_exception(TRAP_invalid_op, HVM_DELIVER_NO_ERROR_CODE); + rc = 0; +#endif + if ( guest_kernel_mode(vp, regs) || emulate_forced_invalid_op(regs)==0 ) + { + hvm_inject_hw_exception(TRAP_invalid_op, HVM_DELIVER_NO_ERROR_CODE); + rc = 0; + } + + } + if (vector == TRAP_no_device) { + hvm_funcs.fpu_dirty_intercept(); /* calls vmx_fpu_dirty_intercept */ + rc = 0; + } + + if (vector == TRAP_gp_fault) { + regs->error_code = __vmread(VM_EXIT_INTR_ERROR_CODE); + kdbp("MUK: inject GP: errcode:0x%04x RIP:%016lx RSP:%016lx\n", + regs->error_code, (ulong)vmr(GUEST_RIP), + (ulong)vmr(GUEST_RSP)); + + kdb_trap_immed(KDB_TRAP_NONFATAL); + /* hvm_inject_hw_exception(TRAP_gp_fault, regs->error_code); */ + rc = 1; + } + + if (vector == TRAP_page_fault) { + kdbp("Unexpected vector page_fault\n"); + kdb_trap_immed(KDB_TRAP_NONFATAL); +#if 0 + extern int fixup_page_fault(unsigned long , struct cpu_user_regs *); + ulong eflags_sav = regs->eflags; + unsigned long va = __vmread(EXIT_QUALIFICATION); + + regs->error_code = __vmread(VM_EXIT_INTR_ERROR_CODE); + + if (mukprintpf) + kdbp("MUK:PF va:%016lx errcode:0x%04x RIP:%016lx RSP:%016lx", + va, regs->error_code, (ulong)vmr(GUEST_RIP), + (ulong)vmr(GUEST_RSP)); + + regs->eflags |= X86_EFLAGS_IF; + if (fixup_page_fault(va, regs) == 0) { + if (mukprintpf) + kdbp(" NOT "); + current->arch.hvm_vcpu.guest_cr[2] = va; + hvm_inject_hw_exception(TRAP_page_fault, regs->error_code); + } + regs->eflags = eflags_sav; + if (mukprintpf) + kdbp(" fixedup\n"); + rc = 0; +#endif + } + + /* TBD: call do_guest_trap() here */ + if (rc) + kdbp("MUK: Unhandled trap vector:%d\n", vector); + return rc; +} + +static noinline int vmxit_invlpg(void) +{ + ulong vaddr = __vmread(EXIT_QUALIFICATION); + + update_guest_eip(); + vpid_sync_vcpu_gva(current, vaddr); + return 0; +} + +#if 0 +static noinline void native_cpuid(struct cpu_user_regs *regs); +{ + uint32_t a, b, c, d; + + a = regs->eax; + b = regs->ebx; + c = regs->ecx; + d = regs->edx; + + asm ( "cpuid" + : "=a" (a), "=b" (b), "=c" (c), "=d" (d) + : "0" (a), "1" (b), "2" (c), "3" (d) ); + + regs->eax = a; + regs->ebx = b; + regs->ecx = c; + regs->edx = d; +} +#endif + +static noinline int pvh_grant_table_op( + unsigned int cmd, XEN_GUEST_HANDLE(void) uop, unsigned int count) +{ + switch (cmd) + { + case GNTTABOP_map_grant_ref: + case GNTTABOP_unmap_grant_ref: + case GNTTABOP_setup_table: + case GNTTABOP_copy: + case GNTTABOP_query_size: + case GNTTABOP_set_version: + return do_grant_table_op(cmd, uop, count); + } +kdbp("MUK: hcall: pvh_grant_table_op: unhandled grant op:%d\n", cmd); +kdb_trap_immed(KDB_TRAP_NONFATAL); + return -ENOSYS; +} + +static long pvh_vcpu_op(int cmd, int vcpuid, XEN_GUEST_HANDLE(void) arg) +{ + long rc = -ENOSYS; + + switch ( cmd ) + { + case VCPUOP_register_runstate_memory_area: + case VCPUOP_get_runstate_info: + case VCPUOP_set_periodic_timer: + case VCPUOP_stop_periodic_timer: + case VCPUOP_set_singleshot_timer: + case VCPUOP_stop_singleshot_timer: + case VCPUOP_is_up: + case VCPUOP_up: + case VCPUOP_initialise: + rc = do_vcpu_op(cmd, vcpuid, arg); + + /* pvh boot vcpu setting context for bringing up smp vcpu */ + if (cmd == VCPUOP_initialise) + vmx_vmcs_enter(current); + } + return rc; +} + +static long pvh_physdev_op(int cmd, XEN_GUEST_HANDLE(void) arg) +{ + switch ( cmd ) + { + case PHYSDEVOP_map_pirq: + case PHYSDEVOP_unmap_pirq: + case PHYSDEVOP_eoi: + case PHYSDEVOP_irq_status_query: + case PHYSDEVOP_get_free_pirq: +#if 0 + case PHYSDEVOP_set_iopl: +#endif + return do_physdev_op(cmd, arg); + + default: + if ( IS_PRIV(current->domain) ) + return do_physdev_op(cmd, arg); + } + return -ENOSYS; +} + +static noinline long do_pvh_hvm_op(unsigned long op, XEN_GUEST_HANDLE(void) arg) +{ + long rc = -EINVAL; + struct xen_hvm_param harg; + struct domain *d; + + if ( copy_from_guest(&harg, arg, 1) ) + return -EFAULT; + + rc = rcu_lock_target_domain_by_id(harg.domid, &d); + if ( rc != 0 ) + return rc; + + if (is_hvm_domain(d)) { + /* pvh dom0 is building an hvm guest */ + rcu_unlock_domain(d); + return do_hvm_op(op, arg); + } + + rc = -ENOSYS; + if (op == HVMOP_set_param) { + if (harg.index == HVM_PARAM_CALLBACK_IRQ) { + struct hvm_irq *hvm_irq = &d->arch.hvm_domain.irq; + uint64_t via = harg.value; + uint8_t via_type = (uint8_t)(via >> 56) + 1; + + if (via_type == HVMIRQ_callback_vector) { + hvm_irq->callback_via_type = HVMIRQ_callback_vector; + hvm_irq->callback_via.vector = (uint8_t)via; + rc = 0; + } + } + } + return rc; +} + +typedef unsigned long pvh_hypercall_t( + unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, + unsigned long); + +int hcall_a[NR_hypercalls]; + +static pvh_hypercall_t *pvh_hypercall64_table[NR_hypercalls] = { + [__HYPERVISOR_platform_op] = (pvh_hypercall_t *)do_platform_op, + [__HYPERVISOR_memory_op] = (pvh_hypercall_t *)do_memory_op, + /* [__HYPERVISOR_set_timer_op] = (pvh_hypercall_t *)do_set_timer_op, */ + [__HYPERVISOR_xen_version] = (pvh_hypercall_t *)do_xen_version, + [__HYPERVISOR_console_io] = (pvh_hypercall_t *)do_console_io, + [__HYPERVISOR_grant_table_op] = (pvh_hypercall_t *)pvh_grant_table_op, + [__HYPERVISOR_vcpu_op] = (pvh_hypercall_t *)pvh_vcpu_op, + [__HYPERVISOR_mmuext_op] = (pvh_hypercall_t *)do_mmuext_op, + [__HYPERVISOR_xsm_op] = (pvh_hypercall_t *)do_xsm_op, + [__HYPERVISOR_sched_op] = (pvh_hypercall_t *)do_sched_op, + [__HYPERVISOR_event_channel_op]= (pvh_hypercall_t *)do_event_channel_op, + [__HYPERVISOR_physdev_op] = (pvh_hypercall_t *)pvh_physdev_op, + [__HYPERVISOR_hvm_op] = (pvh_hypercall_t *)do_pvh_hvm_op, + [__HYPERVISOR_sysctl] = (pvh_hypercall_t *)do_sysctl, + [__HYPERVISOR_domctl] = (pvh_hypercall_t *)do_domctl +}; + +/* TBD: Do we need to worry about this and slow things down in this path? */ +static int pvh_long_mode_enabled(void) +{ + return 1; +} + +/* Check if hypercall is valid + * Returns: 0 if hcall is not valid with eax set to the errno to ret to guest + */ +static noinline int hcall_valid(struct cpu_user_regs *regs) +{ + struct segment_register sreg; + + if (!pvh_long_mode_enabled()) { + printk("PVH Error: Expected long mode set\n"); + return 1; + } + hvm_get_segment_register(current, x86_seg_ss, &sreg); + if ( unlikely(sreg.attr.fields.dpl == 3) ) { + regs->eax = -EPERM; + return 0; + } + + /* domU's are not allowed following hcalls */ + if ( !IS_PRIV(current->domain) && + (regs->eax == __HYPERVISOR_xsm_op || + regs->eax == __HYPERVISOR_platform_op || +#if 0 + regs->eax == __HYPERVISOR_mmuext_op || /* for privcmd mmap */ +#endif + regs->eax == __HYPERVISOR_domctl) ) { /* for privcmd mmap */ + + regs->eax = -EPERM; + return 0; + } + return 1; +} +volatile int mukdbg178=1; +static noinline int vmxit_vmcall(struct cpu_user_regs *regs) +{ + uint32_t hnum = regs->eax; + + if (hnum >= NR_hypercalls || pvh_hypercall64_table[hnum] ==NULL) + { + kdbp("MUK: UnImplemented HCALL:%d. ret -ENOSYS to guest\n", regs->eax); +if (mukdbg178) + kdb_trap_immed(KDB_TRAP_NONFATAL); + regs->eax = -ENOSYS; + update_guest_eip(); + return HVM_HCALL_completed; + } + + dbgp2("vmxit_vmcall: hcall eax:$%ld\n", regs->eax); + if (regs->eax == __HYPERVISOR_sched_op && regs->rdi == SCHEDOP_shutdown) { + kdbp("MUK: FIXME: SCHEDOP_shutdown hcall\n"); + regs->eax = -ENOSYS; + update_guest_eip(); + domain_crash_synchronous(); + return HVM_HCALL_completed; + } + + if ( !hcall_valid(regs) ) { +kdbp("!hcall_valid(). hcall:%d\n", hnum); +if (mukdbg178) + kdb_trap_immed(KDB_TRAP_NONFATAL); + return HVM_HCALL_completed; + } + + +hcall_a[hnum]++; +current->arch.hvm_vcpu.hcall_preempted = 0; /* TBD */ +/* search for this and do it. PV method will not work */ + + regs->rax = pvh_hypercall64_table[hnum](regs->rdi, regs->rsi, regs->rdx, + regs->r10, regs->r8, regs->r9); + + if ( !current->arch.hvm_vcpu.hcall_preempted ) + update_guest_eip(); + else + kdbp("Hcall :%d preempted\n", hnum); + + + return HVM_HCALL_completed; +} + +static noinline uint64_t *get_gpr_ptr(struct cpu_user_regs *regs, uint gpr) +{ + switch (gpr) + { + case VMX_CONTROL_REG_ACCESS_GPR_EAX: + return ®s->eax; + case VMX_CONTROL_REG_ACCESS_GPR_ECX: + return ®s->ecx; + case VMX_CONTROL_REG_ACCESS_GPR_EDX: + return ®s->edx; + case VMX_CONTROL_REG_ACCESS_GPR_EBX: + return ®s->ebx; + case VMX_CONTROL_REG_ACCESS_GPR_ESP: + return ®s->esp; + case VMX_CONTROL_REG_ACCESS_GPR_EBP: + return ®s->ebp; + case VMX_CONTROL_REG_ACCESS_GPR_ESI: + return ®s->esi; + case VMX_CONTROL_REG_ACCESS_GPR_EDI: + return ®s->edi; + case VMX_CONTROL_REG_ACCESS_GPR_R8: + return ®s->r8; + case VMX_CONTROL_REG_ACCESS_GPR_R9: + return ®s->r9; + case VMX_CONTROL_REG_ACCESS_GPR_R10: + return ®s->r10; + case VMX_CONTROL_REG_ACCESS_GPR_R11: + return ®s->r11; + case VMX_CONTROL_REG_ACCESS_GPR_R12: + return ®s->r12; + case VMX_CONTROL_REG_ACCESS_GPR_R13: + return ®s->r13; + case VMX_CONTROL_REG_ACCESS_GPR_R14: + return ®s->r14; + case VMX_CONTROL_REG_ACCESS_GPR_R15: + return ®s->r15; + default: + return NULL; + } +} +/* rc == 0: success */ +static noinline int access_cr0(struct cpu_user_regs *regs, uint acc_typ, + uint64_t *regp) +{ + struct vcpu *vp = current; + + if (acc_typ == VMX_CONTROL_REG_ACCESS_TYPE_MOV_TO_CR ) + { + unsigned long new_cr0 = *regp; + unsigned long old_cr0 = __vmread(GUEST_CR0); + + dbgp2("MUK:writing to CR0. RIP:%lx val:0x%lx\n", vmr(GUEST_RIP),*regp); + if ( (u32)new_cr0 != new_cr0 ) + { + HVM_DBG_LOG(DBG_LEVEL_1, + "Guest setting upper 32 bits in CR0: %lx", new_cr0); + return 1; + } + + new_cr0 &= ~HVM_CR0_GUEST_RESERVED_BITS; + /* ET is reserved and should be always be 1. */ + new_cr0 |= X86_CR0_ET; + + /* pvh cannot change to real mode */ + if ( (new_cr0 & (X86_CR0_PE|X86_CR0_PG)) != (X86_CR0_PG|X86_CR0_PE) ) { + kdbp("Guest attempting to turn off PE/PG. CR0:%lx\n", new_cr0); + return 1; + } + /* TS going from 1 to 0 */ + if ( (old_cr0 & X86_CR0_TS) && ((new_cr0 & X86_CR0_TS)==0) ) + vmx_fpu_enter(vp); + + vp->arch.hvm_vcpu.hw_cr[0] = vp->arch.hvm_vcpu.guest_cr[0] = new_cr0; + __vmwrite(GUEST_CR0, new_cr0); + __vmwrite(CR0_READ_SHADOW, new_cr0); + } else { + *regp = __vmread(GUEST_CR0); + } + return 0; +} + +#if 0 +volatile int mukdbgcr3; +/* rc == 0: success */ +static noinline int access_cr3(struct cpu_user_regs *regs, uint acc_typ, + uint64_t *regp) +{ + if (acc_typ == VMX_CONTROL_REG_ACCESS_TYPE_MOV_TO_CR ) { + unsigned long new_cr3 = *regp; + + __vmwrite(GUEST_CR3, new_cr3); + vpid_sync_all(); + if (mukdbgcr3) + kdbp("MUK: mov to cr3:%016lx cs:%lx RIP:%016lx\n", new_cr3,regs->cs, + vmr(GUEST_RIP)); + } else { + *regp = __vmread(GUEST_CR3); + } + + return 0; +} +#endif + +/* rc == 0: success */ +static noinline int access_cr4(struct cpu_user_regs *regs, uint acc_typ, + uint64_t *regp) +{ + if (acc_typ == VMX_CONTROL_REG_ACCESS_TYPE_MOV_TO_CR ) + { + u64 old_cr4 = __vmread(GUEST_CR4); + /* kdbp("MUK:writing to CR4. val:0x%lx\n", *regp); */ + + if ( (old_cr4 ^ (*regp)) & (X86_CR4_PSE | X86_CR4_PGE | X86_CR4_PAE) ) + vpid_sync_all(); + + /* pvh_verify_cr4_wr(*regp)); */ + __vmwrite(GUEST_CR4, *regp); + } else { + *regp = __vmread(GUEST_CR4); + kdbp("MUK: read cr4. val:0x%lx\n", *regp); + } + return 0; +} + +/* rc == 0: success */ +static noinline int vmxit_cr_access(struct cpu_user_regs *regs) +{ + unsigned long exit_qualification = __vmread(EXIT_QUALIFICATION); + uint acc_typ = VMX_CONTROL_REG_ACCESS_TYPE(exit_qualification); + int cr, rc = 1; + + switch ( acc_typ ) + { + case VMX_CONTROL_REG_ACCESS_TYPE_MOV_TO_CR: + case VMX_CONTROL_REG_ACCESS_TYPE_MOV_FROM_CR: + { + uint gpr = VMX_CONTROL_REG_ACCESS_GPR(exit_qualification); + uint64_t *regp = get_gpr_ptr(regs, gpr); + cr = VMX_CONTROL_REG_ACCESS_NUM(exit_qualification); + + if (regp == NULL) + break; + + /* pl don't embed switch statements */ + if (cr == 0) + rc = access_cr0(regs, acc_typ, regp); + else if (cr == 3) { + printk("PVH: d%d: unexpected cr3 access vmexit. rip:%lx\n", + current->domain->domain_id, vmr(GUEST_RIP)); + domain_crash_synchronous(); + } else if (cr == 4) + rc = access_cr4(regs, acc_typ, regp); + + if (rc == 0) + update_guest_eip(); + break; + } + case VMX_CONTROL_REG_ACCESS_TYPE_CLTS: + { +#if 0 + unsigned long cr0 = __vmread(GUEST_CR0); + cr0 &= ~X86_CR0_TS; +#endif + struct vcpu *vp = current; + unsigned long cr0 = vp->arch.hvm_vcpu.guest_cr[0] & ~X86_CR0_TS; + vp->arch.hvm_vcpu.hw_cr[0] = vp->arch.hvm_vcpu.guest_cr[0] = cr0; + vmx_fpu_enter(vp); + __vmwrite(GUEST_CR0, cr0); + __vmwrite(CR0_READ_SHADOW, cr0); + update_guest_eip(); + rc = 0; + } + } + return rc; +} + +static int noinline vmxit_io_instr(struct cpu_user_regs *regs) +{ + int curr_lvl; + int requested = (regs->rflags >> 12) & 3; + + read_vmcs_selectors(regs); + curr_lvl = regs->cs & 3; + + if (requested >= curr_lvl && emulate_privileged_op(regs)) + return 0; + + kdbp("MUK: io instr about to inject gpf. req:%x curr:%x\n", requested, + curr_lvl); + kdb_trap_immed(KDB_TRAP_NONFATAL); + hvm_inject_hw_exception(TRAP_gp_fault, regs->error_code); + + return 0; +} + +static noinline int pvh_ept_handle_violation(unsigned long qualification, paddr_t gpa) +{ + unsigned long gla, gfn = gpa >> PAGE_SHIFT; + p2m_type_t p2mt; + mfn_t mfn = get_gfn_query_unlocked(current->domain, gfn, &p2mt); + + gdprintk(XENLOG_ERR, "Dom:%d EPT violation %#lx (%c%c%c/%c%c%c), " + "gpa %#"PRIpaddr", mfn %#lx, type %i.\n", + current->domain->domain_id, qualification, + (qualification & EPT_READ_VIOLATION) ? 'r' : '-', + (qualification & EPT_WRITE_VIOLATION) ? 'w' : '-', + (qualification & EPT_EXEC_VIOLATION) ? 'x' : '-', + (qualification & EPT_EFFECTIVE_READ) ? 'r' : '-', + (qualification & EPT_EFFECTIVE_WRITE) ? 'w' : '-', + (qualification & EPT_EFFECTIVE_EXEC) ? 'x' : '-', + gpa, mfn_x(mfn), p2mt); + + ept_walk_table(current->domain, gfn); + + if ( qualification & EPT_GLA_VALID ) + { + gla = __vmread(GUEST_LINEAR_ADDRESS); + gdprintk(XENLOG_ERR, " --- GLA %#lx\n", gla); + } +#if 0 + if (vmr(GUEST_CS_SELECTOR) & 3 == 3) { + kdbp("EPT Violation in user mode. inject GP\n"); + hvm_inject_hw_exception(TRAP_gp_fault, regs->error_code); + } else +#endif + hvm_inject_hw_exception(TRAP_gp_fault, 0); + kdb_trap_immed(KDB_TRAP_NONFATAL); + + return 0; +} + +#if 0 +/* emulate write_cr3(read_cr3()) in guest. */ +static noinline int vmxit_invvpid(void) +{ + hvm_asid_flush_vcpu(current); + return 0; +} +#endif +volatile int mukcpuiddbg=0; +static noinline void pvh_cpuid(struct cpu_user_regs *regs) +{ + unsigned int eax, ebx, ecx, edx; + + if (mukcpuiddbg) + kdbp("ucpuid: rax:%lx bx:%lx cx:%lx dx:%lx\n", regs->rax, regs->rbx, + regs->rcx, regs->rdx); + + asm volatile ( "cpuid" + : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) + : "0" (regs->eax), "2" (regs->rcx) ); + + regs->rax = eax; regs->rbx = ebx; regs->rcx = ecx; regs->rdx = edx; + if (mukcpuiddbg) + kdbp("done: rax:%lx bx:%lx cx:%lx dx:%lx\n", regs->rax, regs->rbx, + regs->rcx, regs->rdx); +} + +volatile int mukprdr7, mukprtsc=1, mukcrashit; +void pvh_vmx_vmexit_handler(struct cpu_user_regs *regs) +{ + unsigned long exit_qualification; + unsigned int vector, exit_reason = __vmread(VM_EXIT_REASON); + int rc=0, ccpu = smp_processor_id(); + struct vcpu *vp = current; + +#if defined(XEN_KDB_CONFIG) +{ + if (kdb_dr7) + write_debugreg(7, kdb_dr7); +} +#endif + if (mukprdr7) + kdbp("MUK: vmexit dr0:%lx 7:%lx vmcs.7:%lx\n", read_debugreg(0), + read_debugreg(7), __vmread(GUEST_DR7)); + + dbgp1("MUK:[%d]left VMCS exitreas:%d RIP:%lx RSP:%lx EFLAGS:%lx CR0:%lx\n", + ccpu, exit_reason, vmr(GUEST_RIP), vmr(GUEST_RSP), regs->rflags, + vmr(GUEST_CR0)); + + /* for guest_kernel_mode in fixup_page_fault() */ + regs->cs = vmr(GUEST_CS_SELECTOR); + + switch ( (uint16_t)exit_reason ) + { + case EXIT_REASON_EXCEPTION_NMI: + case EXIT_REASON_EXTERNAL_INTERRUPT: + case EXIT_REASON_MCE_DURING_VMENTRY: + break; + default: + local_irq_enable(); + } + + switch ( (uint16_t)exit_reason ) + { + case EXIT_REASON_EXCEPTION_NMI: /* 0 */ + rc = vmxit_exception(regs); + break; + + case EXIT_REASON_EXTERNAL_INTERRUPT: /* 1 */ + { + vector = __vmread(VM_EXIT_INTR_INFO); + vector &= INTR_INFO_VECTOR_MASK; +#if 0 + dbgp2("MUK: [%d] exit vmcs reas:%d vec:%d cr0:0x%016lx\n", ccpu, + exit_reason, vector, vmr(GUEST_CR0)); +#endif + vmx_do_extint(regs); + break; + } + + case EXIT_REASON_TRIPLE_FAULT: /* 2 */ + { +#if 0 + static int once; + if (!once) + kdbp("MUK:[%d]left VMCS exitreas:%d RIP:%lx RSP:%lx EFLAGS:%lx CR0:%lx\n", + ccpu, exit_reason, vmr(GUEST_RIP), vmr(GUEST_RSP), regs->rflags, + vmr(GUEST_CR0)); + once = 1; + hvm_inject_hw_exception(TRAP_gp_fault, regs->error_code); + rc = 0; +#endif + kdbp("MUK:Triple Flt:[%d]exitreas:%d RIP:%lx RSP:%lx EFLAGS:%lx CR3:%lx\n", + ccpu, exit_reason, vmr(GUEST_RIP), vmr(GUEST_RSP), regs->rflags, + vmr(GUEST_CR3)); + + if ( paging_mode_hap(vp->domain) && hvm_paging_enabled(vp) ) + vp->arch.hvm_vcpu.guest_cr[3] = vp->arch.hvm_vcpu.hw_cr[3] = + __vmread(GUEST_CR3); + kdb_trap_immed(KDB_TRAP_NONFATAL); + rc = 1; + break; + } + case EXIT_REASON_PENDING_VIRT_INTR: /* 7 */ + { + struct vcpu *v = current; + /* Disable the interrupt window. */ + v->arch.hvm_vmx.exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; + __vmwrite(CPU_BASED_VM_EXEC_CONTROL, v->arch.hvm_vmx.exec_control); + break; + } + + case EXIT_REASON_CPUID: /* 10 */ + { + if ( guest_kernel_mode(vp, regs) ) { + pv_cpuid(regs); + + /* Because we are setting CR4.OSFXSR to 0, we need to disable + * this because, during boot, user process "init" (which doesn't + * do cpuid), will do 'pxor xmm0,xmm0' and cause #UD. For now + * disable this. HVM doesn't allow setting of CR4.OSFXSR. + * TBD/FIXME: this and also look at CR4.OSXSAVE */ + + __clear_bit(X86_FEATURE_FXSR, ®s->edx); + } else + pvh_cpuid(regs); + + /* TBD/FIXME: investigate and fix the XSAVE/MMX/FPU stuff */ + + update_guest_eip(); + dbgp2("cpuid:%d RIP:%lx\n", regs->eax, vmr(GUEST_RIP)); + break; + } + + case EXIT_REASON_HLT: /* 12 */ + { + update_guest_eip(); + hvm_hlt(regs->eflags); + break; +#if 0 + XEN_GUEST_HANDLE(void) p = {NULL}; + /* hvm_event_pending ?? see hvm_hlt() */ + do_sched_op(SCHEDOP_block, p); +#endif + } + + case EXIT_REASON_INVLPG: /* 14 */ + rc = vmxit_invlpg(); + break; + + case EXIT_REASON_RDTSC: /* 16 */ + { +#if 0 + uint64_t tsc; + int ilen=get_instruction_length(); + rdtscll(tsc); + regs->eax = (uint32_t)tsc; + regs->edx = (uint32_t)(tsc >> 32); + rdtsc(regs->eax, regs->edx); +if (mukprtsc) + kdbp(" RDTSC: eax:%lx edx:%lx\n", regs->eax, regs->edx); + update_guest_eip(); +#endif + rc = 1; + break; + } + + case EXIT_REASON_VMCALL: /* 18 */ + rc = vmxit_vmcall(regs); + break; + + case EXIT_REASON_CR_ACCESS: /* 28 */ + rc = vmxit_cr_access(regs); + break; + + case EXIT_REASON_DR_ACCESS: /* 29 */ + { + exit_qualification = __vmread(EXIT_QUALIFICATION); +#if defined(XEN_KDB_CONFIG) + update_guest_eip(); + break; +#endif + vmx_dr_access(exit_qualification, regs); + break; + } + + case EXIT_REASON_IO_INSTRUCTION: + vmxit_io_instr(regs); + break; + + case EXIT_REASON_MSR_READ: /* 31 */ + rc = vmxit_msr_read(regs); + break; + + case EXIT_REASON_MSR_WRITE: /* 32 */ + rc = vmxit_msr_write(regs); + break; + + case EXIT_REASON_MONITOR_TRAP_FLAG: /* 37 */ + rc = vmxit_mtf(regs); + break; + + case EXIT_REASON_EPT_VIOLATION: + { + paddr_t gpa = __vmread(GUEST_PHYSICAL_ADDRESS); + exit_qualification = __vmread(EXIT_QUALIFICATION); + rc = pvh_ept_handle_violation(exit_qualification, gpa); + break; + } +#if 0 + case EXIT_REASON_INVVPID: /* 53 */ + rc = vmxit_invvpid(); + break; +#endif + default: + rc = 1; + kdbp("Unexpected exit reason:%d 0x%x\n", exit_reason, exit_reason); + } + if (rc) { + exit_qualification = __vmread(EXIT_QUALIFICATION); + kdbp("MUK: [%d] exit_reas:%d 0x%lx qual:%ld 0x%lx cr0:0x%016lx\n", + ccpu, exit_reason, exit_reason, exit_qualification, + exit_qualification, vmr(GUEST_CR0)); + kdbp("MUK: [%d] RIP:%lx RSP:%lx\n", ccpu, + vmr(GUEST_RIP), vmr(GUEST_RSP)); + domain_crash_synchronous(); + } + +if (mukcrashit) + domain_crash_synchronous(); + + /*dbgp("MUK: will enter vmcs: cs:%x ss:%x\n", vmr(GUEST_CS_SELECTOR), + vmr(GUEST_SS_SELECTOR)); */ + + dbgp1("MUK: will enter vmcs:RIP:%lx RSP:%lx cr0:%lx eflags:%lx\n", + vmr(GUEST_RIP), vmr(GUEST_RSP), vmr(GUEST_CR0), regs->rflags); + + if (mukprdr7) + kdbp("MUK: vmexit dr0:%lx 7:%lx vmcs.7:%lx\n", read_debugreg(0), + read_debugreg(7), __vmread(GUEST_DR7)); + +} + +void pvh_flush_tlb(void) +{ + vpid_sync_all(); +} + +void pvh_do_invlpg(ulong addr) +{ + /* vpid_sync_all(); */ + vpid_sync_vcpu_gva(current, addr); +} + +/* + * Sets info for non boot vcpu. VCPU 0 context is set by library which needs + * to be modified to send + * correct selectors and gs_base. For now, we use this for nonboot vcpu + * in which case the call somes from the kernel cpu_initialize_context(). + */ +int vmx_pvh_set_vcpu_info(struct vcpu *v, struct vcpu_guest_context *ctxtp) +{ +kdbp("MUK: bringup pvh vcpu: cs:%x ds:%x es:%x ss:%x gsbase:%lx\n", + ctxtp->user_regs.cs, ctxtp->user_regs.ds, ctxtp->user_regs.es, + ctxtp->user_regs.ss, ctxtp->gs_base_kernel); +kdbp("MUK: bringup pvh vcpu: gdtr base:%lx sz:%lx gsusr:%lx\n", +ctxtp->u.pvh.gdtaddr, ctxtp->u.pvh.gdtsz, ctxtp->gs_base_user); + + if (v->vcpu_id == 0) + return 0; + + vmx_vmcs_enter(v); + __vmwrite(GUEST_GDTR_BASE, ctxtp->u.pvh.gdtaddr); + __vmwrite(GUEST_GDTR_LIMIT, ctxtp->u.pvh.gdtsz); + __vmwrite(GUEST_GS_BASE, ctxtp->gs_base_user); + + __vmwrite(GUEST_CS_SELECTOR, ctxtp->user_regs.cs); + __vmwrite(GUEST_DS_SELECTOR, ctxtp->user_regs.ds); + __vmwrite(GUEST_ES_SELECTOR, ctxtp->user_regs.es); + __vmwrite(GUEST_SS_SELECTOR, ctxtp->user_regs.ss); + __vmwrite(GUEST_GS_SELECTOR, ctxtp->user_regs.gs); + + if ( vmx_add_guest_msr(MSR_SHADOW_GS_BASE) ) + return -EINVAL; + + vmx_write_guest_msr(MSR_SHADOW_GS_BASE, ctxtp->gs_base_kernel); + + vmx_vmcs_exit(v); + return 0; +} + +void vmx_pvh_update_cr3(struct vcpu *v) +{ +kdbp("MUK: in vmx_pvh_update_cr3\n"); +kdb_trap_immed(KDB_TRAP_NONFATAL); + vmx_vmcs_enter(v); + __vmwrite(GUEST_CR3, v->arch.cr3); + __vmwrite(HOST_CR3, v->arch.cr3); + + vpid_sync_all(); + /* hvm_asid_flush_vcpu(v); ????????????? */ + vmx_vmcs_exit(v); +} + + +int vmx_pvh_read_descriptor(unsigned int sel, const struct vcpu *v, + const struct cpu_user_regs *regs, + unsigned long *base, unsigned long *limit, + unsigned int *ar) +{ + unsigned int tmp_ar = 0; + BUG_ON(v!=current); + BUG_ON(!is_pvh_vcpu(v)); + + if (sel == (unsigned int)regs->cs) { + *base = vmr(GUEST_CS_BASE); + *limit = vmr(GUEST_CS_LIMIT); + tmp_ar = vmr(GUEST_CS_AR_BYTES); + } else if (sel == (unsigned int)regs->ds) { + *base = vmr(GUEST_DS_BASE); + *limit = vmr(GUEST_DS_LIMIT); + tmp_ar = vmr(GUEST_DS_AR_BYTES); + } else if (sel == (unsigned int)regs->ss) { + *base = vmr(GUEST_SS_BASE); + *limit = vmr(GUEST_SS_LIMIT); + tmp_ar = vmr(GUEST_SS_AR_BYTES); + } else if (sel == (unsigned int)regs->gs) { + *base = vmr(GUEST_GS_BASE); + *limit = vmr(GUEST_GS_LIMIT); + tmp_ar = vmr(GUEST_GS_AR_BYTES); + } else if (sel == (unsigned int)regs->fs) { + *base = vmr(GUEST_FS_BASE); + *limit = vmr(GUEST_FS_LIMIT); + tmp_ar = vmr(GUEST_FS_AR_BYTES); + } else if (sel == (unsigned int)regs->es) { + *base = vmr(GUEST_ES_BASE); + *limit = vmr(GUEST_ES_LIMIT); + tmp_ar = vmr(GUEST_ES_AR_BYTES); + } else { + kdbp("Unmatche segment selector:%d\n", sel); + kdb_trap_immed(KDB_TRAP_NONFATAL); + } + + if (tmp_ar & X86_SEG_AR_CS_LM_ACTIVE) { /* x86 mess!! */ + *base = 0UL; + *limit = ~0UL; + } + /* Fixup ar so that it looks the same as in native mode */ + *ar = (tmp_ar << 8); + return 1; +} + +int pvh_segment_bad(unsigned int ar, struct vcpu *v) +{ + int rc; + + BUG_ON(v!=current); + BUG_ON(!is_pvh_vcpu(v)); + rc = !(ar & X86_SEG_AR_DESC_TYPE) || !(ar & X86_SEG_AR_SEG_PRESENT) || + !(ar & X86_SEG_AR_SEG_TYPE_CODE); + return rc; +} + diff -r 8b0762504037 xen/arch/x86/mm.c --- a/xen/arch/x86/mm.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/mm.c Wed Nov 14 11:03:24 2012 -0800 @@ -2608,7 +2608,7 @@ static struct domain *get_pg_owner(domid goto out; } - if ( unlikely(paging_mode_translate(curr)) ) + if ( !is_pvh_domain(curr) && unlikely(paging_mode_translate(curr)) ) { MEM_LOG("Cannot mix foreign mappings with translated domains"); goto out; @@ -3667,7 +3667,7 @@ static int destroy_grant_va_mapping( return replace_grant_va_mapping(addr, frame, l1e_empty(), v); } -static int create_grant_p2m_mapping(uint64_t addr, unsigned long frame, +static noinline int create_grant_p2m_mapping(uint64_t addr, unsigned long frame, unsigned int flags, unsigned int cache_flags) { @@ -3742,6 +3742,22 @@ static int replace_grant_p2m_mapping( } guest_physmap_remove_page(d, gfn, frame, PAGE_ORDER_4K); + if (is_pvh_domain(d)) { + struct page_info *page = alloc_domheap_page(d, 0); + + if (page == NULL) { + gdprintk(XENLOG_ERR, "Unable to alloc domheap page\n"); +#if 0 + /* the guest will crash anyways with ept fault when gfn accessed */ + domain_crash_synchronous(); +#endif + } + if (guest_physmap_add_page(d, gfn, page_to_mfn(page), 0) != 0) { + gdprintk(XENLOG_ERR, "Unable to add mfn to replace grant\n"); + /* domain_crash_synchronous(); */ + return GNTST_general_error; + } + } put_gfn(d, gfn); return GNTST_okay; } @@ -4143,7 +4159,7 @@ long do_update_descriptor(u64 pa, u64 de page = get_page_from_gfn(dom, gmfn, NULL, P2M_ALLOC); if ( (((unsigned int)pa % sizeof(struct desc_struct)) != 0) || !page || - !check_descriptor(dom, &d) ) + (!is_pvh_domain(dom) && !check_descriptor(dom, &d)) ) { if ( page ) put_page(page); @@ -4217,9 +4233,106 @@ static int handle_iomem_range(unsigned l return 0; } -static int xenmem_add_to_physmap_once( - struct domain *d, - const struct xen_add_to_physmap *xatp) +/* add frames from foreign domain to current domain physmap. Similar to + * XENMAPSPACE_gmfn but the frame is foreign being mapped into current, + * and is not removed from foreign domain. + * Usage: libxl on pvh dom0 creating guest and doing privcmd_ioctl_mmap + * Returns: 0 ==> success + */ +static long noinline xenmem_add_foreign_to_pmap( domid_t foreign_domid, + unsigned long fgmfn, unsigned long gpfn) +{ + unsigned long rc=0, failed=0, prev_mfn, mfn = 0; + struct domain *fdom, *currd = current->domain; + p2m_type_t p2mt, p2mt_prev; + + if ( (fdom = get_pg_owner(foreign_domid)) == NULL ) { + kdb_trap_immed(KDB_TRAP_NONFATAL); + return -EPERM; + } +failed = 0; + + mfn = mfn_x(get_gfn_query_unlocked(fdom, fgmfn, &p2mt)); + + /* qemu, running on PVH dom0, mapping hvm domain's pages during domain + * creation, doesn't have mfns in the HAP table */ + if ( !mfn_valid(mfn) && p2m_is_mmio(p2mt) ) { + + if (!is_hvm_domain(fdom)) { + printk("mmio type for non-hvm domain. fd:%d fgmfn:%lx gpfn:%lx\n", + foreign_domid, fgmfn, gpfn); + kdb_trap_immed(KDB_TRAP_NONFATAL); + } + mfn = fgmfn; + } + + if ( !p2m_is_valid(p2mt) ) { + put_pg_owner(fdom); + return -EINVAL; + } +#if 0 + if (paging_mode_external(fdom)) { + /* Foreign mappings into guests in shadow external mode don't + * contribute to writeable mapping refcounts. (This allows the + * qemu-dm helper process in dom0 to map the domain's memory without + * messing up the count of "real" writable mappings.) */ + if (get_page_from_pagenr(mfn, fdom) == 0) + failed = 1; + } else { + if (get_page_and_type_from_pagenr(mfn, PGT_writable_page, fdom, 0, 0)) + failed = 1; + } + if (failed) { + put_pg_owner(fdom); + return -EINVAL; + } +#endif + /* Remove previously mapped page if it was present. */ + prev_mfn = mfn_x(get_gfn_query_unlocked(currd, gpfn, &p2mt_prev)); + if ( mfn_valid(prev_mfn) ) + { + if ( is_xen_heap_mfn(prev_mfn) ) + /* Xen heap frames are simply unhooked from this phys slot */ + guest_physmap_remove_page(currd, gpfn, prev_mfn, 0); + else + /* Normal domain memory is freed, to avoid leaking memory. */ + guest_remove_page(currd, gpfn); + } +/* I CAN PROB remove the mmio because all io space is mapped upfront via + * domctl_memory_mapping */ + /* Map at new location. */ + /* Can't use guest_physmap_add_page() because it will update the m2p + * table so mfn ---> gpfn in dom0 and not gpfn of domU. + */ + if ( p2m_is_mmio(p2mt) ) { + if (set_mmio_p2m_entry(currd, gpfn, mfn) == 0) { + kdbp("guest_physmap_add_page failed. gpfn:%lx mfn:%lx fgmfn:%lx\n", + gpfn, mfn, fgmfn); + kdb_trap_immed(KDB_TRAP_NONFATAL); + rc = -EINVAL; + } + goto out; + } + if (set_foreign_p2m_entry(currd, gpfn, mfn) == 0) { +#if 0 + if (paging_mode_external(fdom)) + put_page(mfn_to_page(mfn)); + else + put_page_and_type(mfn_to_page(mfn)); +#endif + kdbp("guest_physmap_add_page failed1. gpfn:%lx mfn:%lx fgmfn:%lx\n", + gpfn, mfn, fgmfn); + kdb_trap_immed(KDB_TRAP_NONFATAL); + rc = -EINVAL; + } +out: + put_pg_owner(fdom); + return rc; +} + +static noinline int xenmem_add_to_physmap_once( + struct domain *d, uint16_t xatp_space, domid_t foreign_domid, + unsigned long xatp_idx, unsigned long xatp_gpfn) { struct page_info *page = NULL; unsigned long gfn = 0; /* gcc ... */ @@ -4227,10 +4340,10 @@ static int xenmem_add_to_physmap_once( int rc; p2m_type_t p2mt; - switch ( xatp->space ) + switch ( xatp_space ) { case XENMAPSPACE_shared_info: - if ( xatp->idx == 0 ) + if ( xatp_idx == 0 ) mfn = virt_to_mfn(d->shared_info); break; case XENMAPSPACE_grant_table: @@ -4239,9 +4352,9 @@ static int xenmem_add_to_physmap_once( if ( d->grant_table->gt_version == 0 ) d->grant_table->gt_version = 1; - idx = xatp->idx; + idx = xatp_idx; if ( d->grant_table->gt_version == 2 && - (xatp->idx & XENMAPIDX_grant_table_status) ) + (xatp_idx & XENMAPIDX_grant_table_status) ) { idx &= ~XENMAPIDX_grant_table_status; if ( idx < nr_status_frames(d->grant_table) ) @@ -4263,9 +4376,9 @@ static int xenmem_add_to_physmap_once( case XENMAPSPACE_gmfn: { p2m_type_t p2mt; - gfn = xatp->idx; - - idx = mfn_x(get_gfn_unshare(d, xatp->idx, &p2mt)); + gfn = xatp_idx; + + idx = mfn_x(get_gfn_unshare(d, xatp_idx, &p2mt)); /* If the page is still shared, exit early */ if ( p2m_is_shared(p2mt) ) { @@ -4278,6 +4391,13 @@ static int xenmem_add_to_physmap_once( page = mfn_to_page(mfn); break; } + + case XENMAPSPACE_gmfn_foreign: + { + rc = xenmem_add_foreign_to_pmap(foreign_domid, xatp_idx, xatp_gpfn); + return rc; + } + default: break; } @@ -4286,8 +4406,8 @@ static int xenmem_add_to_physmap_once( { if ( page ) put_page(page); - if ( xatp->space == XENMAPSPACE_gmfn || - xatp->space == XENMAPSPACE_gmfn_range ) + if ( xatp_space == XENMAPSPACE_gmfn || + xatp_space == XENMAPSPACE_gmfn_range ) put_gfn(d, gfn); return -EINVAL; } @@ -4298,41 +4418,41 @@ static int xenmem_add_to_physmap_once( put_page(page); /* Remove previously mapped page if it was present. */ - prev_mfn = mfn_x(get_gfn(d, xatp->gpfn, &p2mt)); + prev_mfn = mfn_x(get_gfn(d, xatp_gpfn, &p2mt)); if ( mfn_valid(prev_mfn) ) { if ( is_xen_heap_mfn(prev_mfn) ) /* Xen heap frames are simply unhooked from this phys slot. */ - guest_physmap_remove_page(d, xatp->gpfn, prev_mfn, PAGE_ORDER_4K); + guest_physmap_remove_page(d, xatp_gpfn, prev_mfn, PAGE_ORDER_4K); else /* Normal domain memory is freed, to avoid leaking memory. */ - guest_remove_page(d, xatp->gpfn); + guest_remove_page(d, xatp_gpfn); } /* In the XENMAPSPACE_gmfn case we still hold a ref on the old page. */ - put_gfn(d, xatp->gpfn); + put_gfn(d, xatp_gpfn); /* Unmap from old location, if any. */ gpfn = get_gpfn_from_mfn(mfn); ASSERT( gpfn != SHARED_M2P_ENTRY ); - if ( xatp->space == XENMAPSPACE_gmfn || - xatp->space == XENMAPSPACE_gmfn_range ) + if ( xatp_space == XENMAPSPACE_gmfn || + xatp_space == XENMAPSPACE_gmfn_range ) ASSERT( gpfn == gfn ); if ( gpfn != INVALID_M2P_ENTRY ) guest_physmap_remove_page(d, gpfn, mfn, PAGE_ORDER_4K); /* Map at new location. */ - rc = guest_physmap_add_page(d, xatp->gpfn, mfn, PAGE_ORDER_4K); + rc = guest_physmap_add_page(d, xatp_gpfn, mfn, PAGE_ORDER_4K); /* In the XENMAPSPACE_gmfn, we took a ref of the gfn at the top */ - if ( xatp->space == XENMAPSPACE_gmfn || - xatp->space == XENMAPSPACE_gmfn_range ) + if ( xatp_space == XENMAPSPACE_gmfn || + xatp_space == XENMAPSPACE_gmfn_range ) put_gfn(d, gfn); domain_unlock(d); return rc; } -static int xenmem_add_to_physmap(struct domain *d, +static noinline int xenmem_add_to_physmap(struct domain *d, struct xen_add_to_physmap *xatp) { struct xen_add_to_physmap start_xatp; @@ -4346,7 +4466,8 @@ static int xenmem_add_to_physmap(struct start_xatp = *xatp; while ( xatp->size > 0 ) { - rc = xenmem_add_to_physmap_once(d, xatp); + rc = xenmem_add_to_physmap_once(d, xatp->space, -1, + xatp->idx, xatp->gpfn); if ( rc < 0 ) return rc; @@ -4372,7 +4493,50 @@ static int xenmem_add_to_physmap(struct return rc; } - return xenmem_add_to_physmap_once(d, xatp); + return xenmem_add_to_physmap_once(d, xatp->space, -1, + xatp->idx, xatp->gpfn); +} + +static noinline int xenmem_add_to_physmap_range(struct domain *d, + struct xen_add_to_physmap_range *xatpr) +{ + int rc; + + /* Process entries in reverse order to allow continuations */ + while ( xatpr->size > 0 ) + { + xen_ulong_t idx; + xen_pfn_t gpfn; + + rc = copy_from_guest_offset(&idx, xatpr->idxs, xatpr->size-1, 1); + if ( rc < 0 ) + goto out; + + rc = copy_from_guest_offset(&gpfn, xatpr->gpfns, xatpr->size-1, 1); + if ( rc < 0 ) + goto out; + + rc = xenmem_add_to_physmap_once(d, xatpr->space, xatpr->foreign_domid, + idx, gpfn); + + if (rc) + goto out; + + xatpr->size--; + + /* Check for continuation if it's not the last interation */ + if ( xatpr->size > 0 && hypercall_preempt_check() ) + { + rc = -EAGAIN; + goto out; + } + } + + rc = 0; + +out: + return rc; + } long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) @@ -4389,6 +4553,10 @@ long arch_memory_op(int op, XEN_GUEST_HA if ( copy_from_guest(&xatp, arg, 1) ) return -EFAULT; + /* This one is only supported for add_to_physmap_range */ + if ( xatp.space == XENMAPSPACE_gmfn_foreign ) + return -EINVAL; + rc = rcu_lock_target_domain_by_id(xatp.domid, &d); if ( rc != 0 ) return rc; @@ -4416,6 +4584,32 @@ long arch_memory_op(int op, XEN_GUEST_HA return rc; } + case XENMEM_add_to_physmap_range: + { + struct xen_add_to_physmap_range xatpr; + struct domain *d; + + if ( copy_from_guest(&xatpr, arg, 1) ) + return -EFAULT; + + rc = rcu_lock_target_domain_by_id(xatpr.domid, &d); + if ( rc != 0 ) + return rc; + + rc = xenmem_add_to_physmap_range(d, &xatpr); + + rcu_unlock_domain(d); + + if ( rc && copy_to_guest(arg, &xatpr, 1) ) + rc = -EFAULT; + + if ( rc == -EAGAIN ) + rc = hypercall_create_continuation( + __HYPERVISOR_memory_op, "ih", op, arg); + + return rc; + } + case XENMEM_set_memory_map: { struct xen_foreign_memory_map fmap; diff -r 8b0762504037 xen/arch/x86/mm/hap/hap.c --- a/xen/arch/x86/mm/hap/hap.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/mm/hap/hap.c Wed Nov 14 11:03:24 2012 -0800 @@ -600,6 +600,20 @@ int hap_domctl(struct domain *d, xen_dom } } +/* Resize hap table. Copied from: libxl_get_required_shadow_memory() */ +void hap_set_pvh_alloc_for_dom0(struct domain *d, unsigned long num_pages) +{ + int rc; + unsigned long memkb = num_pages * (PAGE_SIZE / 1024); + + memkb = 4 * (256 * d->max_vcpus + 2 * (memkb / 1024)); + num_pages = ((memkb+1023)/1024) << (20 - PAGE_SHIFT); + paging_lock(d); + rc = hap_set_allocation(d, num_pages, NULL); + paging_unlock(d); + BUG_ON(rc); +} + static const struct paging_mode hap_paging_real_mode; static const struct paging_mode hap_paging_protected_mode; static const struct paging_mode hap_paging_pae_mode; @@ -659,7 +673,8 @@ static void hap_update_cr3(struct vcpu * const struct paging_mode * hap_paging_get_mode(struct vcpu *v) { - return !hvm_paging_enabled(v) ? &hap_paging_real_mode : + return is_pvh_vcpu(v) ? &hap_paging_long_mode : + !hvm_paging_enabled(v) ? &hap_paging_real_mode : hvm_long_mode_enabled(v) ? &hap_paging_long_mode : hvm_pae_enabled(v) ? &hap_paging_pae_mode : &hap_paging_protected_mode; diff -r 8b0762504037 xen/arch/x86/mm/p2m-ept.c --- a/xen/arch/x86/mm/p2m-ept.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/mm/p2m-ept.c Wed Nov 14 11:03:24 2012 -0800 @@ -75,6 +75,7 @@ static void ept_p2m_type_to_flags(ept_en entry->w = 0; break; case p2m_grant_map_rw: + case p2m_map_foreign: entry->r = entry->w = 1; entry->x = 0; break; @@ -428,7 +429,7 @@ ept_set_entry(struct p2m_domain *p2m, un } /* Track the highest gfn for which we have ever had a valid mapping */ - if ( p2mt != p2m_invalid && + if ( p2mt != p2m_invalid && p2mt != p2m_mmio_dm && (gfn + (1UL << order) - 1 > p2m->max_mapped_pfn) ) p2m->max_mapped_pfn = gfn + (1UL << order) - 1; @@ -462,6 +463,9 @@ out: } else { + +if (p2m->domain->domain_id == 0) /******* PVH : FIXME */ + goto skip; if ( order > 0 ) { for ( i = 0; i < (1 << order); i++ ) @@ -472,7 +476,7 @@ out: } } } - +skip: /* Release the old intermediate tables, if any. This has to be the last thing we do, after the ept_sync_domain() and removal from the iommu tables, so as to avoid a potential diff -r 8b0762504037 xen/arch/x86/mm/p2m-pt.c --- a/xen/arch/x86/mm/p2m-pt.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/mm/p2m-pt.c Wed Nov 14 11:03:24 2012 -0800 @@ -89,6 +89,7 @@ static unsigned long p2m_type_to_flags(p case p2m_ram_rw: return flags | P2M_BASE_FLAGS | _PAGE_RW; case p2m_grant_map_rw: + case p2m_map_foreign: return flags | P2M_BASE_FLAGS | _PAGE_RW | _PAGE_NX_BIT; case p2m_mmio_direct: if ( !rangeset_contains_singleton(mmio_ro_ranges, mfn_x(mfn)) ) @@ -429,7 +430,7 @@ p2m_set_entry(struct p2m_domain *p2m, un } /* Track the highest gfn for which we have ever had a valid mapping */ - if ( p2mt != p2m_invalid + if ( p2mt != p2m_invalid && p2mt != p2m_mmio_dm && (gfn + (1UL << page_order) - 1 > p2m->max_mapped_pfn) ) p2m->max_mapped_pfn = gfn + (1UL << page_order) - 1; diff -r 8b0762504037 xen/arch/x86/mm/p2m.c --- a/xen/arch/x86/mm/p2m.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/mm/p2m.c Wed Nov 14 11:03:24 2012 -0800 @@ -488,7 +488,7 @@ p2m_remove_page(struct p2m_domain *p2m, for ( i = 0; i < (1UL << page_order); i++ ) { mfn_return = p2m->get_entry(p2m, gfn + i, &t, &a, 0, NULL); - if ( !p2m_is_grant(t) && !p2m_is_shared(t) ) + if ( !p2m_is_grant(t) && !p2m_is_shared(t) && !p2m_is_foreign(t) ) set_gpfn_from_mfn(mfn+i, INVALID_M2P_ENTRY); ASSERT( !p2m_is_valid(t) || mfn + i == mfn_x(mfn_return) ); } @@ -584,6 +584,11 @@ guest_physmap_add_entry(struct domain *d { ASSERT(mfn_valid(omfn)); set_gpfn_from_mfn(mfn_x(omfn), INVALID_M2P_ENTRY); + + /* Because PVH domU uses kmalloc for grant pfn, we need to save + * and restore the old mfn */ + if (is_pvh_domain(d) && p2m_is_grant(t)) + free_domheap_page(mfn_to_page(omfn)); } else if ( ot == p2m_populate_on_demand ) { @@ -715,7 +720,33 @@ void p2m_change_type_range(struct domain p2m_unlock(p2m); } +/* Returns: True for success. 0 for failure */ +int set_foreign_p2m_entry(struct domain *domp, unsigned long gfn, mfn_t mfn) +{ + int rc = 0; + p2m_type_t ot; + mfn_t omfn; + struct p2m_domain *p2m = p2m_get_hostp2m(domp); + if ( !paging_mode_translate(domp) ) + return 0; + + omfn = get_gfn_query_unlocked(domp, gfn, &ot); + if (mfn_valid(omfn)) { + gdprintk(XENLOG_ERR, "Already mapped mfn %lx at gfn:%lx\n", omfn, gfn); + set_gpfn_from_mfn(mfn_x(omfn), INVALID_M2P_ENTRY); + } + + P2M_DEBUG("set foreign %lx %lx\n", gfn, mfn_x(mfn)); + p2m_lock(p2m); + rc = set_p2m_entry(p2m, gfn, mfn, 0, p2m_map_foreign, p2m->default_access); + p2m_unlock(p2m); + if ( rc == 0 ) + gdprintk(XENLOG_ERR, + "set_foreign_p2m_entry: set_p2m_entry failed! gfn:%lx mfn=%08lx\n", + gfn, mfn_x(get_gfn_query(domp, gfn, &ot))); + return rc; +} int set_mmio_p2m_entry(struct domain *d, unsigned long gfn, mfn_t mfn) diff -r 8b0762504037 xen/arch/x86/msi.c --- a/xen/arch/x86/msi.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/msi.c Wed Nov 14 11:03:24 2012 -0800 @@ -766,6 +766,9 @@ static int msix_capability_init(struct p WARN_ON(rangeset_overlaps_range(mmio_ro_ranges, dev->msix_pba.first, dev->msix_pba.last)); +/* PVH: fixme: not a clue what to do here :) */ +if (is_pvh_domain(dev->domain) && dev->domain->domain_id != 0) +{ if ( rangeset_add_range(mmio_ro_ranges, dev->msix_table.first, dev->msix_table.last) ) WARN(); @@ -793,6 +796,7 @@ static int msix_capability_init(struct p /* XXX How to deal with existing mappings? */ } } +} } WARN_ON(dev->msix_nr_entries != nr_entries); WARN_ON(dev->msix_table.first != (table_paddr >> PAGE_SHIFT)); diff -r 8b0762504037 xen/arch/x86/physdev.c --- a/xen/arch/x86/physdev.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/physdev.c Wed Nov 14 11:03:24 2012 -0800 @@ -732,6 +732,25 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_H break; } + case PHYSDEVOP_pvh_map_iomem : { + + struct physdev_map_iomem iomem; + struct domain *d = current->domain; + + ret = -EPERM; + if ( !IS_PRIV(d) || !is_pvh_domain(d)) + break; + d = rcu_lock_current_domain(); + + ret = -EFAULT; + if ( copy_from_guest(&iomem, arg, 1) != 0 ) + break; + + ret = domctl_memory_mapping(d, iomem.first_gfn, iomem.first_mfn, + iomem.nr_mfns, iomem.add_mapping); + break; + } + default: ret = -ENOSYS; break; diff -r 8b0762504037 xen/arch/x86/setup.c --- a/xen/arch/x86/setup.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/setup.c Wed Nov 14 11:03:24 2012 -0800 @@ -54,6 +54,9 @@ int opt_earlykdb=0; boolean_param("earlykdb", opt_earlykdb); #endif +int opt_dom0hyb=0; +boolean_param("dom0hyb", opt_dom0hyb); + /* opt_nosmp: If true, secondary processors are ignored. */ static bool_t __initdata opt_nosmp; boolean_param("nosmp", opt_nosmp); @@ -542,7 +545,7 @@ void __init __start_xen(unsigned long mb { char *memmap_type = NULL; char *cmdline, *kextra, *loader; - unsigned int initrdidx; + unsigned int initrdidx, domcr_flags = 0; multiboot_info_t *mbi = __va(mbi_p); module_t *mod = (module_t *)__va(mbi->mods_addr); unsigned long nr_pages, modules_headroom, *module_map; @@ -1260,7 +1263,9 @@ void __init __start_xen(unsigned long mb panic("Could not protect TXT memory regions\n"); /* Create initial domain 0. */ - dom0 = domain_create(0, DOMCRF_s3_integrity, 0); + domcr_flags = (opt_dom0hyb ? DOMCRF_pvh | DOMCRF_hap : 0); + domcr_flags |= DOMCRF_s3_integrity; + dom0 = domain_create(0, domcr_flags, 0); if ( IS_ERR(dom0) || (alloc_dom0_vcpu0() == NULL) ) panic("Error creating domain 0\n"); diff -r 8b0762504037 xen/arch/x86/time.c --- a/xen/arch/x86/time.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/time.c Wed Nov 14 11:03:24 2012 -0800 @@ -1923,7 +1923,7 @@ void tsc_set_info(struct domain *d, break; } d->arch.incarnation = incarnation + 1; - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) hvm_set_rdtsc_exiting(d, d->arch.vtsc); } diff -r 8b0762504037 xen/arch/x86/traps.c --- a/xen/arch/x86/traps.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/traps.c Wed Nov 14 11:03:24 2012 -0800 @@ -723,7 +723,7 @@ int cpuid_hypervisor_leaves( uint32_t id return 1; } -static void pv_cpuid(struct cpu_user_regs *regs) +void pv_cpuid(struct cpu_user_regs *regs) { uint32_t a, b, c, d; @@ -900,7 +900,7 @@ static int emulate_invalid_rdtscp(struct return EXCRET_fault_fixed; } -static int emulate_forced_invalid_op(struct cpu_user_regs *regs) +int emulate_forced_invalid_op(struct cpu_user_regs *regs) { char sig[5], instr[2]; unsigned long eip, rc; @@ -910,6 +910,10 @@ static int emulate_forced_invalid_op(str /* Check for forced emulation signature: ud2 ; .ascii "xen". */ if ( (rc = copy_from_user(sig, (char *)eip, sizeof(sig))) != 0 ) { + /* PVH: fixme: hmm... what do we do for PVH? */ + if ( is_pvh_vcpu(current) ) + return 0; + propagate_page_fault(eip + sizeof(sig) - rc, 0); return EXCRET_fault_fixed; } @@ -920,6 +924,10 @@ static int emulate_forced_invalid_op(str /* We only emulate CPUID. */ if ( ( rc = copy_from_user(instr, (char *)eip, sizeof(instr))) != 0 ) { + /* PVH: fixme: hmm... what do we do for PVH? */ + if ( is_pvh_vcpu(current) ) + return 0; + propagate_page_fault(eip + sizeof(instr) - rc, 0); return EXCRET_fault_fixed; } @@ -1448,6 +1456,9 @@ static int read_descriptor(unsigned int { struct desc_struct desc; + if ( is_pvh_vcpu(v) ) + return hvm_pvh_read_descriptor(sel, v, regs, base, limit, ar); + if ( !vm86_mode(regs) ) { if ( sel < 4) @@ -1566,6 +1577,10 @@ static int guest_io_okay( int user_mode = !(v->arch.flags & TF_kernel_mode); #define TOGGLE_MODE() if ( user_mode ) toggle_guest_mode(v) + /* for PVH we check this in vmexit for EXIT_REASON_IO_INSTRUCTION */ + if (is_pvh_vcpu(v)) + return 1; + if ( !vm86_mode(regs) && (v->arch.pv_vcpu.iopl >= (guest_kernel_mode(v, regs) ? 1 : 3)) ) return 1; @@ -1811,14 +1826,14 @@ static inline uint64_t guest_misc_enable _ptr = (unsigned int)_ptr; \ if ( (limit) < sizeof(_x) - 1 || (eip) > (limit) - (sizeof(_x) - 1) ) \ goto fail; \ - if ( (_rc = copy_from_user(&_x, (type *)_ptr, sizeof(_x))) != 0 ) \ + if ( (_rc = raw_copy_from_guest(&_x, (type *)_ptr, sizeof(_x))) != 0 ) \ { \ propagate_page_fault(_ptr + sizeof(_x) - _rc, 0); \ goto skip; \ } \ (eip) += sizeof(_x); _x; }) -#define read_sreg(regs, sr) read_segment_register(sr) +#define read_sreg(vcpu, regs, sr) read_segment_register(vcpu, regs, sr) static int is_cpufreq_controller(struct domain *d) { @@ -1828,7 +1843,7 @@ static int is_cpufreq_controller(struct #include "x86_64/mmconfig.h" -static int emulate_privileged_op(struct cpu_user_regs *regs) +int emulate_privileged_op(struct cpu_user_regs *regs) { struct vcpu *v = current; unsigned long *reg, eip = regs->eip; @@ -1864,7 +1879,7 @@ static int emulate_privileged_op(struct goto fail; /* emulating only opcodes not allowing SS to be default */ - data_sel = read_sreg(regs, ds); + data_sel = read_sreg(v, regs, ds); /* Legacy prefixes. */ for ( i = 0; i < 8; i++, rex == opcode || (rex = 0) ) @@ -1882,17 +1897,17 @@ static int emulate_privileged_op(struct data_sel = regs->cs; continue; case 0x3e: /* DS override */ - data_sel = read_sreg(regs, ds); + data_sel = read_sreg(v, regs, ds); continue; case 0x26: /* ES override */ - data_sel = read_sreg(regs, es); + data_sel = read_sreg(v, regs, es); continue; case 0x64: /* FS override */ - data_sel = read_sreg(regs, fs); + data_sel = read_sreg(v, regs, fs); lm_ovr = lm_seg_fs; continue; case 0x65: /* GS override */ - data_sel = read_sreg(regs, gs); + data_sel = read_sreg(v, regs, gs); lm_ovr = lm_seg_gs; continue; case 0x36: /* SS override */ @@ -1939,7 +1954,7 @@ static int emulate_privileged_op(struct if ( !(opcode & 2) ) { - data_sel = read_sreg(regs, es); + data_sel = read_sreg(v, regs, es); lm_ovr = lm_seg_none; } @@ -2668,22 +2683,22 @@ static void emulate_gate_op(struct cpu_u ASSERT(opnd_sel); continue; case 0x3e: /* DS override */ - opnd_sel = read_sreg(regs, ds); + opnd_sel = read_sreg(v, regs, ds); if ( !opnd_sel ) opnd_sel = dpl; continue; case 0x26: /* ES override */ - opnd_sel = read_sreg(regs, es); + opnd_sel = read_sreg(v, regs, es); if ( !opnd_sel ) opnd_sel = dpl; continue; case 0x64: /* FS override */ - opnd_sel = read_sreg(regs, fs); + opnd_sel = read_sreg(v, regs, fs); if ( !opnd_sel ) opnd_sel = dpl; continue; case 0x65: /* GS override */ - opnd_sel = read_sreg(regs, gs); + opnd_sel = read_sreg(v, regs, gs); if ( !opnd_sel ) opnd_sel = dpl; continue; @@ -2736,7 +2751,7 @@ static void emulate_gate_op(struct cpu_u switch ( modrm & 7 ) { default: - opnd_sel = read_sreg(regs, ds); + opnd_sel = read_sreg(v, regs, ds); break; case 4: case 5: opnd_sel = regs->ss; @@ -2764,7 +2779,7 @@ static void emulate_gate_op(struct cpu_u break; } if ( !opnd_sel ) - opnd_sel = read_sreg(regs, ds); + opnd_sel = read_sreg(v, regs, ds); switch ( modrm & 7 ) { case 0: case 2: case 4: diff -r 8b0762504037 xen/arch/x86/x86_64/traps.c --- a/xen/arch/x86/x86_64/traps.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/arch/x86/x86_64/traps.c Wed Nov 14 11:03:24 2012 -0800 @@ -127,10 +127,10 @@ void show_registers(struct cpu_user_regs fault_crs[0] = read_cr0(); fault_crs[3] = read_cr3(); fault_crs[4] = read_cr4(); - fault_regs.ds = read_segment_register(ds); - fault_regs.es = read_segment_register(es); - fault_regs.fs = read_segment_register(fs); - fault_regs.gs = read_segment_register(gs); + fault_regs.ds = read_segment_register(v, regs, ds); + fault_regs.es = read_segment_register(v, regs, es); + fault_regs.fs = read_segment_register(v, regs, fs); + fault_regs.gs = read_segment_register(v, regs, gs); } print_xen_info(); @@ -624,7 +624,7 @@ static void hypercall_page_initialise_ri void hypercall_page_initialise(struct domain *d, void *hypercall_page) { memset(hypercall_page, 0xCC, PAGE_SIZE); - if ( is_hvm_domain(d) ) + if ( is_hvm_or_pvh_domain(d) ) hvm_hypercall_page_initialise(d, hypercall_page); else if ( !is_pv_32bit_domain(d) ) hypercall_page_initialise_ring3_kernel(hypercall_page); diff -r 8b0762504037 xen/common/domain.c --- a/xen/common/domain.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/domain.c Wed Nov 14 11:03:24 2012 -0800 @@ -232,6 +232,14 @@ struct domain *domain_create( if ( domcr_flags & DOMCRF_hvm ) d->is_hvm = 1; + else if ( domcr_flags & DOMCRF_pvh ) { + d->is_pvh = 1; + if ( !(domcr_flags & DOMCRF_hap) ) { + printk("PVH guest must have HAP on\n"); + goto fail; + } else + printk("Yeay... PVH guest. domid:%d\n", domid); + } if ( domid == 0 ) { diff -r 8b0762504037 xen/common/domctl.c --- a/xen/common/domctl.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/domctl.c Wed Nov 14 11:03:24 2012 -0800 @@ -149,6 +149,8 @@ void getdomaininfo(struct domain *d, str if ( is_hvm_domain(d) ) info->flags |= XEN_DOMINF_hvm_guest; + else if ( is_pvh_domain(d) ) + info->flags |= XEN_DOMINF_pvh_guest; xsm_security_domaininfo(d, info); @@ -419,6 +421,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xe if ( supervisor_mode_kernel || (op->u.createdomain.flags & ~(XEN_DOMCTL_CDF_hvm_guest | XEN_DOMCTL_CDF_hap | + XEN_DOMCTL_CDF_pvh_guest | XEN_DOMCTL_CDF_s3_integrity | XEN_DOMCTL_CDF_oos_off)) ) break; @@ -449,6 +452,8 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xe domcr_flags = 0; if ( op->u.createdomain.flags & XEN_DOMCTL_CDF_hvm_guest ) domcr_flags |= DOMCRF_hvm; + if ( op->u.createdomain.flags & XEN_DOMCTL_CDF_pvh_guest ) + domcr_flags |= DOMCRF_pvh; if ( op->u.createdomain.flags & XEN_DOMCTL_CDF_hap ) domcr_flags |= DOMCRF_hap; if ( op->u.createdomain.flags & XEN_DOMCTL_CDF_s3_integrity ) diff -r 8b0762504037 xen/common/grant_table.c --- a/xen/common/grant_table.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/grant_table.c Wed Nov 14 11:03:24 2012 -0800 @@ -529,7 +529,7 @@ static void mapcount( * addr is _either_ a host virtual address, or the address of the pte to * update, as indicated by the GNTMAP_contains_pte flag. */ -static void +static noinline void __gnttab_map_grant_ref( struct gnttab_map_grant_ref *op) { @@ -745,7 +745,7 @@ __gnttab_map_grant_ref( double_gt_lock(lgt, rgt); - if ( !is_hvm_domain(ld) && need_iommu(ld) ) + if ( !is_hvm_or_pvh_domain(ld) && need_iommu(ld) ) { unsigned int wrc, rdc; int err = 0; @@ -956,7 +956,7 @@ __gnttab_unmap_common( act->pin -= GNTPIN_hstw_inc; } - if ( !is_hvm_domain(ld) && need_iommu(ld) ) + if ( !is_hvm_or_pvh_domain(ld) && need_iommu(ld) ) { unsigned int wrc, rdc; int err = 0; diff -r 8b0762504037 xen/common/kernel.c --- a/xen/common/kernel.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/kernel.c Wed Nov 14 11:03:24 2012 -0800 @@ -289,7 +289,11 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDL if ( current->domain == dom0 ) fi.submap |= 1U << XENFEAT_dom0; #ifdef CONFIG_X86 - if ( !is_hvm_vcpu(current) ) + if ( is_pvh_vcpu(current) ) + fi.submap |= (1U << XENFEAT_hvm_safe_pvclock) | + (1U << XENFEAT_supervisor_mode_kernel) | + (1U << XENFEAT_hvm_callback_vector); + else if ( !is_hvm_vcpu(current) ) fi.submap |= (1U << XENFEAT_mmu_pt_update_preserve_ad) | (1U << XENFEAT_highmem_assist) | (1U << XENFEAT_gnttab_map_avail_bits); diff -r 8b0762504037 xen/common/libelf/libelf-loader.c --- a/xen/common/libelf/libelf-loader.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/libelf/libelf-loader.c Wed Nov 14 11:03:24 2012 -0800 @@ -17,6 +17,10 @@ */ #include "libelf-private.h" +#ifdef __XEN__ +#include +#include +#endif /* ------------------------------------------------------------------------ */ @@ -108,7 +112,8 @@ void elf_set_log(struct elf_binary *elf, elf->verbose = verbose; } -static int elf_load_image(void *dst, const void *src, uint64_t filesz, uint64_t memsz) +static int elf_load_image(void *dst, const void *src, uint64_t filesz, + uint64_t memsz, int not_used) { memcpy(dst, src, filesz); memset(dst + filesz, 0, memsz - filesz); @@ -122,11 +127,35 @@ void elf_set_verbose(struct elf_binary * elf->verbose = 1; } -static int elf_load_image(void *dst, const void *src, uint64_t filesz, uint64_t memsz) +static int elf_load_image(void *dst, const void *src, uint64_t filesz, + uint64_t memsz, int is_pvh_dom0) { int rc; if ( filesz > ULONG_MAX || memsz > ULONG_MAX ) return -1; + + /* raw_copy_to_guest -> copy_to_user_hvm -> __hvm_copy needs curr to + * point to the hvm/pvh vcpu. Hence for PVH dom0 we can't use that. For now + * just use dbg_rw_mem(). FIXME: this is kinda slow, enhance to copy + * more than one byte at a time. */ + if ( is_pvh_dom0 ) + { + int j, rem; + rem = dbg_rw_mem((dbgva_t)dst, (dbgbyte_t *)src, (int)filesz, 0, 1, 0); + if ( rem ) { + printk("Failed to copy elf binary. len:%ld rem:%d\n", filesz, rem); + return -1; + } + for (j=0; j < memsz - filesz; j++) { + unsigned char zero=0; + rem = dbg_rw_mem((dbgva_t)(dst+filesz+j), &zero, 1, 0, 1, 0); + if (rem) { + kdbp("Failed to copy to: %lx rem:%d\n", dst+filesz+j, rem); + return -1; + } + } + return 0; + } rc = raw_copy_to_guest(dst, src, filesz); if ( rc != 0 ) return -1; @@ -260,7 +289,9 @@ void elf_parse_binary(struct elf_binary __FUNCTION__, elf->pstart, elf->pend); } -int elf_load_binary(struct elf_binary *elf) +/* This function called for dom0 and also from the libraries when building + * guests */ +static int _elf_load_binary(struct elf_binary *elf, int is_pvh_dom0) { const elf_phdr *phdr; uint64_t i, count, paddr, offset, filesz, memsz; @@ -279,7 +310,8 @@ int elf_load_binary(struct elf_binary *e dest = elf_get_ptr(elf, paddr); elf_msg(elf, "%s: phdr %" PRIu64 " at 0x%p -> 0x%p\n", __func__, i, dest, dest + filesz); - if ( elf_load_image(dest, elf->image + offset, filesz, memsz) != 0 ) + if ( elf_load_image(dest, elf->image + offset, filesz, memsz, + is_pvh_dom0) != 0 ) return -1; } @@ -287,6 +319,18 @@ int elf_load_binary(struct elf_binary *e return 0; } +#ifdef __XEN__ +int elf_load_binary(struct elf_binary *elf, int is_pvh_dom0) +{ + return _elf_load_binary(elf, is_pvh_dom0); +} +#else +int elf_load_binary(struct elf_binary *elf) +{ + return _elf_load_binary(elf, 0); +} +#endif + void *elf_get_ptr(struct elf_binary *elf, unsigned long addr) { return elf->dest + addr - elf->pstart; diff -r 8b0762504037 xen/common/memory.c --- a/xen/common/memory.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/common/memory.c Wed Nov 14 11:03:24 2012 -0800 @@ -653,6 +653,8 @@ long do_memory_op(unsigned long cmd, XEN struct xen_remove_from_physmap xrfp; struct page_info *page; struct domain *d; + p2m_type_t p2mt; + int is_curr_pvh = is_pvh_vcpu(current); if ( copy_from_guest(&xrfp, arg, 1) ) return -EFAULT; @@ -669,14 +671,22 @@ long do_memory_op(unsigned long cmd, XEN domain_lock(d); - page = get_page_from_gfn(d, xrfp.gpfn, NULL, P2M_ALLOC); - if ( page ) + page = get_page_from_gfn(d, xrfp.gpfn, &p2mt, P2M_ALLOC); + if ( page || + (is_curr_pvh && (p2m_is_mmio(p2mt) || p2m_is_foreign(p2mt))) ) { - guest_physmap_remove_page(d, xrfp.gpfn, page_to_mfn(page), 0); - put_page(page); + unsigned long argmfn = page ? page_to_mfn(page) : INVALID_MFN; + guest_physmap_remove_page(d, xrfp.gpfn, argmfn, 0); + if (page) + put_page(page); } - else + else + { + if ( is_curr_pvh ) + gdprintk(XENLOG_WARNING, "%s: Domain:%u gmfn:%lx invalid\n", + __FUNCTION__, current->domain->domain_id, xrfp.gpfn); rc = -ENOENT; + } domain_unlock(d); diff -r 8b0762504037 xen/drivers/passthrough/iommu.c --- a/xen/drivers/passthrough/iommu.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/drivers/passthrough/iommu.c Wed Nov 14 11:03:24 2012 -0800 @@ -120,15 +120,25 @@ int iommu_domain_init(struct domain *d) return hd->platform_ops->init(d); } +static inline void check_dom0_pvh_reqs(struct domain *d) +{ + if (!iommu_enabled || iommu_passthrough) + panic("For pvh dom0, iommu must be enabled, dom0-passthrough must " + "not be enabled \n"); +} + void __init iommu_dom0_init(struct domain *d) { struct hvm_iommu *hd = domain_hvm_iommu(d); + if ( is_pvh_domain(d) ) + check_dom0_pvh_reqs(d); + if ( !iommu_enabled ) return; register_keyhandler('o', &iommu_p2m_table); - d->need_iommu = !!iommu_dom0_strict; + d->need_iommu = is_pvh_domain(d) || !!iommu_dom0_strict; if ( need_iommu(d) ) { struct page_info *page; @@ -141,7 +151,10 @@ void __init iommu_dom0_init(struct domai ((page->u.inuse.type_info & PGT_type_mask) == PGT_writable_page) ) mapping |= IOMMUF_writable; - hd->platform_ops->map_page(d, mfn, mfn, mapping); + if ( is_pvh_domain(d) ) + hd->platform_ops->map_page(d, mfn_to_gfn(d, mfn), mfn, mapping); + else + hd->platform_ops->map_page(d, mfn, mfn, mapping); if ( !(i++ & 0xfffff) ) process_pending_softirqs(); } diff -r 8b0762504037 xen/include/asm-x86/desc.h --- a/xen/include/asm-x86/desc.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/desc.h Wed Nov 14 11:03:24 2012 -0800 @@ -38,7 +38,8 @@ #ifndef __ASSEMBLY__ -#define GUEST_KERNEL_RPL(d) (is_pv_32bit_domain(d) ? 1 : 3) +#define GUEST_KERNEL_RPL(d) (is_pvh_domain(d) ? 0 : \ + is_pv_32bit_domain(d) ? 1 : 3) /* Fix up the RPL of a guest segment selector. */ #define __fixup_guest_selector(d, sel) \ diff -r 8b0762504037 xen/include/asm-x86/domain.h --- a/xen/include/asm-x86/domain.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/domain.h Wed Nov 14 11:03:24 2012 -0800 @@ -16,7 +16,7 @@ #define is_pv_32on64_domain(d) (is_pv_32bit_domain(d)) #define is_pv_32on64_vcpu(v) (is_pv_32on64_domain((v)->domain)) -#define is_hvm_pv_evtchn_domain(d) (is_hvm_domain(d) && \ +#define is_hvm_pv_evtchn_domain(d) (is_hvm_or_pvh_domain(d) && \ d->arch.hvm_domain.irq.callback_via_type == HVMIRQ_callback_vector) #define is_hvm_pv_evtchn_vcpu(v) (is_hvm_pv_evtchn_domain(v->domain)) @@ -252,10 +252,10 @@ struct arch_domain struct list_head pdev_list; - union { - struct pv_domain pv_domain; - struct hvm_domain hvm_domain; - }; +/* PVH fixme: pvh uses fields from both pv and hvm, so separate the union + * for now. make a separate pvh struct and put in HVM */ + struct pv_domain pv_domain; + struct hvm_domain hvm_domain; struct paging_domain paging; struct p2m_domain *p2m; @@ -396,10 +396,14 @@ struct arch_vcpu void (*ctxt_switch_to) (struct vcpu *); /* Virtual Machine Extensions */ +#if 0 union { +#endif struct pv_vcpu pv_vcpu; struct hvm_vcpu hvm_vcpu; +#if 0 }; +#endif /* * Every domain has a L1 pagetable of its own. Per-domain mappings diff -r 8b0762504037 xen/include/asm-x86/event.h --- a/xen/include/asm-x86/event.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/event.h Wed Nov 14 11:03:24 2012 -0800 @@ -18,7 +18,7 @@ int hvm_local_events_need_delivery(struc static inline int local_events_need_delivery(void) { struct vcpu *v = current; - return (is_hvm_vcpu(v) ? hvm_local_events_need_delivery(v) : + return (is_hvm_or_pvh_vcpu(v) ? hvm_local_events_need_delivery(v) : (vcpu_info(v, evtchn_upcall_pending) && !vcpu_info(v, evtchn_upcall_mask))); } diff -r 8b0762504037 xen/include/asm-x86/guest_access.h --- a/xen/include/asm-x86/guest_access.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/guest_access.h Wed Nov 14 11:03:24 2012 -0800 @@ -14,27 +14,27 @@ /* Raw access functions: no type checking. */ #define raw_copy_to_guest(dst, src, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ copy_to_user_hvm((dst), (src), (len)) : \ copy_to_user((dst), (src), (len))) #define raw_copy_from_guest(dst, src, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ copy_from_user_hvm((dst), (src), (len)) : \ copy_from_user((dst), (src), (len))) #define raw_clear_guest(dst, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ clear_user_hvm((dst), (len)) : \ clear_user((dst), (len))) #define __raw_copy_to_guest(dst, src, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ copy_to_user_hvm((dst), (src), (len)) : \ __copy_to_user((dst), (src), (len))) #define __raw_copy_from_guest(dst, src, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ copy_from_user_hvm((dst), (src), (len)) : \ __copy_from_user((dst), (src), (len))) #define __raw_clear_guest(dst, len) \ - (is_hvm_vcpu(current) ? \ + (is_hvm_or_pvh_vcpu(current) ? \ clear_user_hvm((dst), (len)) : \ clear_user((dst), (len))) diff -r 8b0762504037 xen/include/asm-x86/hap.h --- a/xen/include/asm-x86/hap.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/hap.h Wed Nov 14 11:03:24 2012 -0800 @@ -63,6 +63,7 @@ int hap_track_dirty_vram(struct domain XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); extern const struct paging_mode *hap_paging_get_mode(struct vcpu *); +void hap_set_pvh_alloc_for_dom0(struct domain *d, unsigned long num_pages); #endif /* XEN_HAP_H */ diff -r 8b0762504037 xen/include/asm-x86/hvm/hvm.h --- a/xen/include/asm-x86/hvm/hvm.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/hvm/hvm.h Wed Nov 14 11:03:24 2012 -0800 @@ -183,6 +183,13 @@ struct hvm_function_table { /* Virtual interrupt delivery */ void (*update_eoi_exit_bitmap)(struct vcpu *v, u8 vector, u8 trig); int (*virtual_intr_delivery_enabled)(void); + + /* PVH functions */ + void (*pvh_update_cr3)(struct vcpu *v); + int (*pvh_set_vcpu_info)(struct vcpu *v, struct vcpu_guest_context *ctxtp); + int (*pvh_read_descriptor)(unsigned int sel, const struct vcpu *v, + const struct cpu_user_regs *regs, unsigned long *base, + unsigned long *limit, unsigned int *ar); }; extern struct hvm_function_table hvm_funcs; @@ -316,6 +323,24 @@ static inline unsigned long hvm_get_shad return hvm_funcs.get_shadow_gs_base(v); } +static inline void hvm_pvh_update_cr3(struct vcpu *v) +{ + hvm_funcs.pvh_update_cr3(v); +} + +static inline int hvm_pvh_set_vcpu_info(struct vcpu *v, + struct vcpu_guest_context *ctxtp) +{ + return hvm_funcs.pvh_set_vcpu_info(v, ctxtp); +} + +static inline int hvm_pvh_read_descriptor(unsigned int sel, + const struct vcpu *v, const struct cpu_user_regs *regs, + unsigned long *base, unsigned long *limit, unsigned int *ar) +{ + return hvm_funcs.pvh_read_descriptor(sel, v, regs, base, limit, ar); +} + #define is_viridian_domain(_d) \ (is_hvm_domain(_d) && ((_d)->arch.hvm_domain.params[HVM_PARAM_VIRIDIAN])) diff -r 8b0762504037 xen/include/asm-x86/hvm/vcpu.h --- a/xen/include/asm-x86/hvm/vcpu.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/hvm/vcpu.h Wed Nov 14 11:03:24 2012 -0800 @@ -104,6 +104,17 @@ struct nestedvcpu { #define vcpu_nestedhvm(v) ((v)->arch.hvm_vcpu.nvcpu) +struct pvh_hvm_vcpu_ext +{ + /* I/O-port access bitmap. */ + XEN_GUEST_HANDLE(uint8) iobmp; /* Guest kernel vaddr of the bitmap. */ + unsigned int pvh_iobmp_limit; /* Number of ports in the bitmap. */ + unsigned int pvh_iopl; /* Current IOPL for this VCPU. */ + + /* Guest-specified relocation of vcpu_info. */ + unsigned long pvh_vcpu_info_mfn; +}; + struct hvm_vcpu { /* Guest control-register and EFER values, just as the guest sees them. */ unsigned long guest_cr[5]; @@ -170,6 +181,8 @@ struct hvm_vcpu { struct hvm_trap inject_trap; struct viridian_vcpu viridian; + + struct pvh_hvm_vcpu_ext hv_pvh; }; #endif /* __ASM_X86_HVM_VCPU_H__ */ diff -r 8b0762504037 xen/include/asm-x86/hvm/vmx/pvh.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/include/asm-x86/hvm/vmx/pvh.h Wed Nov 14 11:03:24 2012 -0800 @@ -0,0 +1,11 @@ +#ifndef __ASM_X86_HVM_VMX_PVH_H__ +#define __ASM_X86_HVM_VMX_PVH_H__ + +void vmx_pvh_update_cr3(struct vcpu *v); +int vmx_pvh_set_vcpu_info(struct vcpu *v, struct vcpu_guest_context *ctxtp); +int vmx_pvh_read_descriptor(unsigned int sel, const struct vcpu *v, + const struct cpu_user_regs *regs, unsigned long *base, + unsigned long *limit, unsigned int *ar); +#endif /* __ASM_X86_HVM_VMX_PVH_H__ */ + + diff -r 8b0762504037 xen/include/asm-x86/hvm/vmx/vmcs.h --- a/xen/include/asm-x86/hvm/vmx/vmcs.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/hvm/vmx/vmcs.h Wed Nov 14 11:03:24 2012 -0800 @@ -413,6 +413,7 @@ int vmx_write_guest_msr(u32 msr, u64 val int vmx_add_guest_msr(u32 msr); int vmx_add_host_load_msr(u32 msr); void vmx_vmcs_switch(struct vmcs_struct *from, struct vmcs_struct *to); +void vmx_fpu_enter(struct vcpu *v); void vmx_set_eoi_exit_bitmap(struct vcpu *v, u8 vector); void vmx_clear_eoi_exit_bitmap(struct vcpu *v, u8 vector); diff -r 8b0762504037 xen/include/asm-x86/hvm/vmx/vmx.h --- a/xen/include/asm-x86/hvm/vmx/vmx.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/hvm/vmx/vmx.h Wed Nov 14 11:03:24 2012 -0800 @@ -156,11 +156,28 @@ void vmx_update_cpu_exec_control(struct # define VMX_CONTROL_REG_ACCESS_TYPE_LMSW 3 /* 10:8 - general purpose register operand */ #define VMX_CONTROL_REG_ACCESS_GPR(eq) (((eq) >> 8) & 0xf) +#define VMX_CONTROL_REG_ACCESS_GPR_EAX 0 +#define VMX_CONTROL_REG_ACCESS_GPR_ECX 1 +#define VMX_CONTROL_REG_ACCESS_GPR_EDX 2 +#define VMX_CONTROL_REG_ACCESS_GPR_EBX 3 +#define VMX_CONTROL_REG_ACCESS_GPR_ESP 4 +#define VMX_CONTROL_REG_ACCESS_GPR_EBP 5 +#define VMX_CONTROL_REG_ACCESS_GPR_ESI 6 +#define VMX_CONTROL_REG_ACCESS_GPR_EDI 7 +#define VMX_CONTROL_REG_ACCESS_GPR_R8 8 +#define VMX_CONTROL_REG_ACCESS_GPR_R9 9 +#define VMX_CONTROL_REG_ACCESS_GPR_R10 10 +#define VMX_CONTROL_REG_ACCESS_GPR_R11 11 +#define VMX_CONTROL_REG_ACCESS_GPR_R12 12 +#define VMX_CONTROL_REG_ACCESS_GPR_R13 13 +#define VMX_CONTROL_REG_ACCESS_GPR_R14 14 +#define VMX_CONTROL_REG_ACCESS_GPR_R15 15 /* * Access Rights */ #define X86_SEG_AR_SEG_TYPE 0xf /* 3:0, segment type */ +#define X86_SEG_AR_SEG_TYPE_CODE (1u << 3) /* code (vs data) segment */ #define X86_SEG_AR_DESC_TYPE (1u << 4) /* 4, descriptor type */ #define X86_SEG_AR_DPL 0x60 /* 6:5, descriptor privilege level */ #define X86_SEG_AR_SEG_PRESENT (1u << 7) /* 7, segment present */ @@ -389,6 +406,26 @@ static inline int __vmxon(u64 addr) return rc; } +static inline unsigned long vmr(unsigned long field) +{ + int rc; + unsigned long val; + val = __vmread_safe(field, &rc); + return rc ? 0 : val; +} + +/* + * Not all cases receive valid value in the VM-exit instruction length field. + * Callers must know what they're doing! + */ +static inline int get_instruction_length(void) +{ + int len; + len = __vmread(VM_EXIT_INSTRUCTION_LEN); /* Safe: callers audited */ + BUG_ON((len < 1) || (len > 15)); + return len; +} + void vmx_get_segment_register(struct vcpu *, enum x86_segment, struct segment_register *); void vmx_inject_extint(int trap); @@ -398,6 +435,11 @@ void ept_p2m_init(struct p2m_domain *p2m void ept_walk_table(struct domain *d, unsigned long gfn); void setup_ept_dump(void); +void update_guest_eip(void); +void pvh_vmx_vmexit_handler(struct cpu_user_regs *regs); +void vmx_dr_access(unsigned long exit_qualification,struct cpu_user_regs *regs); +void vmx_do_extint(struct cpu_user_regs *regs); + /* EPT violation qualifications definitions */ #define _EPT_READ_VIOLATION 0 #define EPT_READ_VIOLATION (1UL<<_EPT_READ_VIOLATION) diff -r 8b0762504037 xen/include/asm-x86/p2m.h --- a/xen/include/asm-x86/p2m.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/p2m.h Wed Nov 14 11:03:24 2012 -0800 @@ -70,6 +70,7 @@ typedef enum { p2m_ram_paging_in = 11, /* Memory that is being paged in */ p2m_ram_shared = 12, /* Shared or sharable memory */ p2m_ram_broken = 13, /* Broken page, access cause domain crash */ + p2m_map_foreign = 14, /* ram pages from foreign domain */ } p2m_type_t; /* @@ -180,6 +181,7 @@ typedef unsigned int p2m_query_t; #define p2m_is_sharable(_t) (p2m_to_mask(_t) & P2M_SHARABLE_TYPES) #define p2m_is_shared(_t) (p2m_to_mask(_t) & P2M_SHARED_TYPES) #define p2m_is_broken(_t) (p2m_to_mask(_t) & P2M_BROKEN_TYPES) +#define p2m_is_foreign(_t) (p2m_to_mask(_t) & p2m_to_mask(p2m_map_foreign)) /* Per-p2m-table state */ struct p2m_domain { @@ -506,6 +508,8 @@ p2m_type_t p2m_change_type(struct domain int set_mmio_p2m_entry(struct domain *d, unsigned long gfn, mfn_t mfn); int clear_mmio_p2m_entry(struct domain *d, unsigned long gfn); +/* Set foreign mfn in the current guest's p2m table (for pvh dom0) */ +int set_foreign_p2m_entry(struct domain *domp, unsigned long gfn, mfn_t mfn); /* * Populate-on-demand diff -r 8b0762504037 xen/include/asm-x86/processor.h --- a/xen/include/asm-x86/processor.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/processor.h Wed Nov 14 11:03:24 2012 -0800 @@ -545,12 +545,14 @@ extern int hypercall(void); int cpuid_hypervisor_leaves( uint32_t idx, uint32_t sub_idx, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx); +void pv_cpuid(struct cpu_user_regs *regs); int rdmsr_hypervisor_regs(uint32_t idx, uint64_t *val); int wrmsr_hypervisor_regs(uint32_t idx, uint64_t val); void microcode_set_module(unsigned int); int microcode_update(XEN_GUEST_HANDLE_PARAM(const_void), unsigned long len); int microcode_resume_cpu(int cpu); +int emulate_forced_invalid_op(struct cpu_user_regs *regs); #endif /* !__ASSEMBLY__ */ diff -r 8b0762504037 xen/include/asm-x86/system.h --- a/xen/include/asm-x86/system.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/system.h Wed Nov 14 11:03:24 2012 -0800 @@ -4,9 +4,15 @@ #include #include -#define read_segment_register(name) \ +/* We need vcpu because during context switch, going from pure pv to pvh, + * in save_segments(), current has been updated to next, and no longer pointing + * to the pure pv. Btw, for pvh, we update regs->selectors on each vmexit */ +#define read_segment_register(vcpu, regs, name) \ ({ u16 __sel; \ - asm volatile ( "movw %%" STR(name) ",%0" : "=r" (__sel) ); \ + if (is_pvh_vcpu(v)) \ + __sel = regs->name; \ + else \ + asm volatile ( "movw %%" STR(name) ",%0" : "=r" (__sel) ); \ __sel; \ }) diff -r 8b0762504037 xen/include/asm-x86/traps.h --- a/xen/include/asm-x86/traps.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/traps.h Wed Nov 14 11:03:24 2012 -0800 @@ -48,5 +48,6 @@ extern int guest_has_trap_callback(struc */ extern int send_guest_trap(struct domain *d, uint16_t vcpuid, unsigned int trap_nr); +int emulate_privileged_op(struct cpu_user_regs *regs); #endif /* ASM_TRAP_H */ diff -r 8b0762504037 xen/include/asm-x86/x86_64/regs.h --- a/xen/include/asm-x86/x86_64/regs.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/asm-x86/x86_64/regs.h Wed Nov 14 11:03:24 2012 -0800 @@ -11,9 +11,10 @@ #define ring_3(r) (((r)->cs & 3) == 3) #define guest_kernel_mode(v, r) \ + ( is_pvh_vcpu(v) ? ({BUG_ON(v!=current); ring_0(r);}) : \ (!is_pv_32bit_vcpu(v) ? \ (ring_3(r) && ((v)->arch.flags & TF_kernel_mode)) : \ - (ring_1(r))) + (ring_1(r))) ) #define permit_softint(dpl, v, r) \ ((dpl) >= (guest_kernel_mode(v, r) ? 1 : 3)) diff -r 8b0762504037 xen/include/public/arch-x86/xen.h --- a/xen/include/public/arch-x86/xen.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/public/arch-x86/xen.h Wed Nov 14 11:03:24 2012 -0800 @@ -157,7 +157,16 @@ struct vcpu_guest_context { struct cpu_user_regs user_regs; /* User-level CPU registers */ struct trap_info trap_ctxt[256]; /* Virtual IDT */ unsigned long ldt_base, ldt_ents; /* LDT (linear address, # ents) */ - unsigned long gdt_frames[16], gdt_ents; /* GDT (machine frames, # ents) */ + union { + struct { + /* GDT (machine frames, # ents) */ + unsigned long gdt_frames[16], gdt_ents; + } pv; + struct { + /* PVH: GDTR addr and size */ + unsigned long gdtaddr, gdtsz; + } pvh; + } u; unsigned long kernel_ss, kernel_sp; /* Virtual TSS (only SS1/SP1) */ /* NB. User pagetable on x86/64 is placed in ctrlreg[1]. */ unsigned long ctrlreg[8]; /* CR0-CR7 (control registers) */ diff -r 8b0762504037 xen/include/public/domctl.h --- a/xen/include/public/domctl.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/public/domctl.h Wed Nov 14 11:03:24 2012 -0800 @@ -59,6 +59,10 @@ struct xen_domctl_createdomain { /* Disable out-of-sync shadow page tables? */ #define _XEN_DOMCTL_CDF_oos_off 3 #define XEN_DOMCTL_CDF_oos_off (1U<<_XEN_DOMCTL_CDF_oos_off) + /* Is this a PV guest in HVM container, aka, a pvh guest? */ + #define _XEN_DOMCTL_CDF_pvh_guest 4 + #define XEN_DOMCTL_CDF_pvh_guest (1U<<_XEN_DOMCTL_CDF_pvh_guest) + uint32_t flags; }; typedef struct xen_domctl_createdomain xen_domctl_createdomain_t; @@ -89,6 +93,10 @@ struct xen_domctl_getdomaininfo { /* Being debugged. */ #define _XEN_DOMINF_debugged 6 #define XEN_DOMINF_debugged (1U<<_XEN_DOMINF_debugged) + /* domain is PVH */ +#define _XEN_DOMINF_pvh_guest 7 +#define XEN_DOMINF_pvh_guest (1U<<_XEN_DOMINF_pvh_guest) + /* XEN_DOMINF_shutdown guest-supplied code. */ #define XEN_DOMINF_shutdownmask 255 #define XEN_DOMINF_shutdownshift 16 diff -r 8b0762504037 xen/include/public/physdev.h --- a/xen/include/public/physdev.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/public/physdev.h Wed Nov 14 11:03:24 2012 -0800 @@ -330,6 +330,19 @@ struct physdev_dbgp_op { typedef struct physdev_dbgp_op physdev_dbgp_op_t; DEFINE_XEN_GUEST_HANDLE(physdev_dbgp_op_t); + +#define PHYSDEVOP_pvh_map_iomem 30 +struct physdev_map_iomem { + /* IN */ + unsigned long first_gfn; + unsigned long first_mfn; + unsigned int nr_mfns; + unsigned int add_mapping; /* 1 == add mapping; 0 == unmap */ + +}; +typedef struct physdev_map_iomem physdev_map_iomem_t; +DEFINE_XEN_GUEST_HANDLE(physdev_map_iomem_t); + /* * Notify that some PIRQ-bound event channels have been unmasked. * ** This command is obsolete since interface version 0x00030202 and is ** diff -r 8b0762504037 xen/include/public/xen.h --- a/xen/include/public/xen.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/public/xen.h Wed Nov 14 11:03:24 2012 -0800 @@ -723,6 +723,7 @@ typedef struct start_info start_info_t; #define SIF_INITDOMAIN (1<<1) /* Is this the initial control domain? */ #define SIF_MULTIBOOT_MOD (1<<2) /* Is mod_start a multiboot module? */ #define SIF_MOD_START_PFN (1<<3) /* Is mod_start a PFN? */ +#define SIF_IS_PVH (1<<4) /* Is it a PVH guest? */ #define SIF_PM_MASK (0xFF<<8) /* reserve 1 byte for xen-pm options */ /* diff -r 8b0762504037 xen/include/xen/domain.h --- a/xen/include/xen/domain.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/xen/domain.h Wed Nov 14 11:03:24 2012 -0800 @@ -86,4 +86,7 @@ extern unsigned int xen_processor_pmbits extern bool_t opt_dom0_vcpus_pin; +extern long domctl_memory_mapping(struct domain *d, unsigned long gfn, + unsigned long mfn, unsigned long nr_mfns, int add_map); + #endif /* __XEN_DOMAIN_H__ */ diff -r 8b0762504037 xen/include/xen/lib.h --- a/xen/include/xen/lib.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/xen/lib.h Wed Nov 14 11:03:24 2012 -0800 @@ -45,6 +45,10 @@ do { #define ASSERT(p) do { if ( 0 && (p) ); } while (0) #endif +/* While PVH feature is experimental, make it an unconditional assert */ +#define PVH_ASSERT(p) \ + do { if ( unlikely(!(p)) ) assert_failed(#p); } while (0) + #define ABS(_x) ({ \ typeof(_x) __x = (_x); \ (__x < 0) ? -__x : __x; \ diff -r 8b0762504037 xen/include/xen/libelf.h --- a/xen/include/xen/libelf.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/xen/libelf.h Wed Nov 14 11:03:24 2012 -0800 @@ -192,13 +192,14 @@ int elf_phdr_is_loadable(struct elf_bina int elf_init(struct elf_binary *elf, const char *image, size_t size); #ifdef __XEN__ void elf_set_verbose(struct elf_binary *elf); +int elf_load_binary(struct elf_binary *elf, int is_pvh_dom0); #else void elf_set_log(struct elf_binary *elf, elf_log_callback*, void *log_caller_pointer, int verbose); +int elf_load_binary(struct elf_binary *elf); #endif void elf_parse_binary(struct elf_binary *elf); -int elf_load_binary(struct elf_binary *elf); void *elf_get_ptr(struct elf_binary *elf, unsigned long addr); uint64_t elf_lookup_addr(struct elf_binary *elf, const char *symbol); diff -r 8b0762504037 xen/include/xen/sched.h --- a/xen/include/xen/sched.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/include/xen/sched.h Wed Nov 14 11:03:24 2012 -0800 @@ -230,6 +230,9 @@ struct mem_event_per_domain struct mem_event_domain access; }; +/* PVH: is a PV guest running in HVM container. is_hvm is false for it. + * But it uses few of the HVM data structs. + */ struct domain { domid_t domain_id; @@ -278,6 +281,7 @@ struct domain /* Is this an HVM guest? */ bool_t is_hvm; + bool_t is_pvh; /* see above for description */ #ifdef HAS_PASSTHROUGH /* Does this guest need iommu mappings? */ bool_t need_iommu; @@ -449,6 +453,10 @@ struct domain *domain_create( /* DOMCRF_oos_off: dont use out-of-sync optimization for shadow page tables */ #define _DOMCRF_oos_off 4 #define DOMCRF_oos_off (1U<<_DOMCRF_oos_off) + /* DOMCRF_pvh: Create PV domain in HVM container */ +#define _DOMCRF_pvh 5 +#define DOMCRF_pvh (1U<<_DOMCRF_pvh) + /* * rcu_lock_domain_by_id() is more efficient than get_domain_by_id(). @@ -716,8 +724,12 @@ void watchdog_domain_destroy(struct doma #define is_hvm_domain(d) ((d)->is_hvm) #define is_hvm_vcpu(v) (is_hvm_domain(v->domain)) +#define is_pvh_domain(d) ((d)->is_pvh) +#define is_pvh_vcpu(v) (is_pvh_domain(v->domain)) #define is_pinned_vcpu(v) ((v)->domain->is_pinned || \ cpumask_weight((v)->cpu_affinity) == 1) +#define is_hvm_or_pvh_domain(d) (is_hvm_domain(d) || is_pvh_domain(d)) +#define is_hvm_or_pvh_vcpu(v) (is_hvm_or_pvh_domain(v->domain)) #ifdef HAS_PASSTHROUGH #define need_iommu(d) ((d)->need_iommu) #else diff -r 8b0762504037 xen/kdb/include/kdb_extern.h --- a/xen/kdb/include/kdb_extern.h Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/kdb/include/kdb_extern.h Wed Nov 14 11:03:24 2012 -0800 @@ -59,8 +59,5 @@ static inline void __vmptrst(u64 *addr) } extern void mukchk(unsigned long); -#define is_hvm_or_hyb_domain is_hvm_domain -#define is_hvm_or_hyb_vcpu is_hvm_vcpu - #endif /* _KDB_EXTERN_H */ diff -r 8b0762504037 xen/kdb/kdb_cmds.c --- a/xen/kdb/kdb_cmds.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/kdb/kdb_cmds.c Wed Nov 14 11:03:24 2012 -0800 @@ -317,7 +317,7 @@ kdb_guest_bitness(domid_t domid) if (is_idle_domain(dp)) retval = HYPSZ; - else if (is_hvm_or_hyb_domain(dp)) + else if (is_hvm_or_pvh_domain(dp)) retval = (hvm_long_mode_enabled(dp->vcpu[0])) ? HYPSZ : 32; else retval = is_pv_32bit_domain(dp) ? 32 : HYPSZ; @@ -977,7 +977,7 @@ kdb_cmdf_ss(int argc, const char **argv, kdbp("kdb: Failed to read byte at: %lx\n", regs->KDBIP); return KDB_CPU_MAIN_KDB; } - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) { + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) { dp->debugger_attached = 1; /* see svm_do_resume/vmx_do_ */ current->arch.hvm_vcpu.single_step = 1; } else @@ -1016,7 +1016,7 @@ kdb_cmdf_ni(int argc, const char **argv, return KDB_CPU_MAIN_KDB; kdb_sbpa[i].bp_ni = 1; - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) current->arch.hvm_vcpu.single_step = 0; else regs->eflags &= ~X86_EFLAGS_TF; @@ -1052,7 +1052,7 @@ kdb_cmdf_ssb(int argc, const char **argv kdbp("%s: regs not available\n", __FUNCTION__); return KDB_CPU_MAIN_KDB; } - if (is_hvm_or_hyb_vcpu(current)) + if (is_hvm_or_pvh_vcpu(current)) current->domain->debugger_attached = 1; /* vmx/svm_do_resume()*/ regs->eflags |= X86_EFLAGS_TF; @@ -1655,7 +1655,7 @@ kdb_set_bp(domid_t domid, kdbva_t addr, return KDBMAXSBP; } /* make sure swbp reporting is enabled in the vmcb/vmcs */ - if (is_hvm_or_hyb_domain(kdb_domid2ptr(domid))) { + if (is_hvm_or_pvh_domain(kdb_domid2ptr(domid))) { struct domain *dp = kdb_domid2ptr(domid); dp->debugger_attached = 1; /* see svm_do_resume/vmx_do_ */ KDBGP("debugger_attached set. domid:%d\n", domid); @@ -1708,7 +1708,7 @@ kdb_cmdf_bp(int argc, const char **argv, if (domidstrp && !kdb_str2domid(domidstrp, &domid, 1)) { return kdb_usgf_bp(); } - if (argc > 3 && is_hvm_or_hyb_domain(kdb_domid2ptr(domid))) { + if (argc > 3 && is_hvm_or_pvh_domain(kdb_domid2ptr(domid))) { kdbp("HVM domain not supported yet for conditional bp\n"); return KDB_CPU_MAIN_KDB; } @@ -1756,7 +1756,7 @@ kdb_cmdf_btp(int argc, const char **argv argsidx = 2; /* assume 3rd arg is not domid */ if (argc > 3 && kdb_str2domid(argv[2], &domid, 0)) { - if (is_hvm_or_hyb_domain(kdb_domid2ptr(domid))) { + if (is_hvm_or_pvh_domain(kdb_domid2ptr(domid))) { kdbp("HVM domains are not currently supprted\n"); return KDB_CPU_MAIN_KDB; } else @@ -1889,6 +1889,73 @@ kdb_cmdf_wc(int argc, const char **argv, return KDB_CPU_MAIN_KDB; } +static void +kdb_display_hvm_vcpu(struct vcpu *vp) +{ + struct hvm_vcpu *hvp; + struct vlapic *vlp; + struct hvm_io_op *ioop; + + hvp = &vp->arch.hvm_vcpu; + vlp = &hvp->vlapic; + kdbp("vcpu:%lx id:%d domid:%d\n", vp, vp->vcpu_id, vp->domain->domain_id); + + if (is_pvh_vcpu(vp)) { + struct pvh_hvm_vcpu_ext *hp = &hvp->hv_pvh; + kdbp(" &pvh_ext:%p limit:%x iopl:%x vcpu_info_mfn:%lx\n", + hp, hp->pvh_iobmp_limit, hp->pvh_iopl, hp->pvh_vcpu_info_mfn); + } + + ioop = NULL; /* compiler warning */ + kdbp(" &hvm_vcpu:%lx guest_efer:"KDBFL"\n", hvp, hvp->guest_efer); + kdbp(" guest_cr: [0]:"KDBFL" [1]:"KDBFL" [2]:"KDBFL"\n", + hvp->guest_cr[0], hvp->guest_cr[1],hvp->guest_cr[2]); + kdbp(" [3]:"KDBFL" [4]:"KDBFL"\n", hvp->guest_cr[3], + hvp->guest_cr[4]); + kdbp(" hw_cr: [0]:"KDBFL" [1]:"KDBFL" [2]:"KDBFL"\n", hvp->hw_cr[0], + hvp->hw_cr[1], hvp->hw_cr[2]); + kdbp(" [3]:"KDBFL" [4]:"KDBFL"\n", hvp->hw_cr[3], + hvp->hw_cr[4]); + + kdbp(" VLAPIC: base msr:"KDBF64" dis:%x tmrdiv:%x\n", + vlp->hw.apic_base_msr, vlp->hw.disabled, vlp->hw.timer_divisor); + kdbp(" regs:%p regs_page:%p\n", vlp->regs, vlp->regs_page); + kdbp(" periodic time:\n"); + kdb_prnt_periodic_time(&vlp->pt); + + kdbp(" xen_port:%x flag_dr_dirty:%x dbg_st_latch:%x\n", hvp->xen_port, + hvp->flag_dr_dirty, hvp->debug_state_latch); + + if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) { + + struct arch_vmx_struct *vxp = &hvp->u.vmx; + kdbp(" &vmx: %p vmcs:%lx active_cpu:%x launched:%x\n", vxp, + vxp->vmcs, vxp->active_cpu, vxp->launched); +#if XEN_VERSION != 4 /* xen 3.x.x */ + kdbp(" exec_ctrl:%x vpid:$%d\n", vxp->exec_control, vxp->vpid); +#endif + kdbp(" host_cr0: "KDBFL" vmx: {realm:%x emulate:%x}\n", + vxp->host_cr0, vxp->vmx_realmode, vxp->vmx_emulate); + +#ifdef __x86_64__ + kdbp(" &msr_state:%p exception_bitmap:%lx\n", &vxp->msr_state, + vxp->exception_bitmap); +#endif + } else if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) { + struct arch_svm_struct *svp = &hvp->u.svm; +#if XEN_VERSION != 4 /* xen 3.x.x */ + kdbp(" &svm: vmcb:%lx pa:"KDBF64" asid:"KDBF64"\n", svp, svp->vmcb, + svp->vmcb_pa, svp->asid_generation); +#endif + kdbp(" msrpm:%p lnch_core:%x vmcb_sync:%x\n", svp->msrpm, + svp->launch_core, svp->vmcb_in_sync); + } + kdbp(" cachemode:%x io: {state: %x data: "KDBFL"}\n", hvp->cache_mode, + hvp->hvm_io.io_state, hvp->hvm_io.io_data); + kdbp(" mmio: {gva: "KDBFL" gpfn: "KDBFL"}\n", hvp->hvm_io.mmio_gva, + hvp->hvm_io.mmio_gpfn); +} + /* display struct hvm_vcpu{} in struct vcpu.arch{} */ static kdb_cpu_cmd_t kdb_usgf_vcpuh(void) @@ -1900,71 +1967,17 @@ static kdb_cpu_cmd_t kdb_cmdf_vcpuh(int argc, const char **argv, struct cpu_user_regs *regs) { struct vcpu *vp; - struct hvm_vcpu *hvp; - struct hvm_io_op *ioop; - struct vlapic *vlp; if (argc < 2 || *argv[1] == '?') return kdb_usgf_vcpuh(); if (!kdb_str2ulong(argv[1], (ulong *)&vp) || !kdb_vcpu_valid(vp) || - !is_hvm_or_hyb_vcpu(vp)) { + !is_hvm_or_pvh_vcpu(vp)) { kdbp("kdb: Bad VCPU: %s\n", argv[1]); return KDB_CPU_MAIN_KDB; } - - hvp = &vp->arch.hvm_vcpu; - vlp = &hvp->vlapic; - kdbp("vcpu:%lx id:%d domid:%d\n", vp, vp->vcpu_id, vp->domain->domain_id); - - ioop = NULL; /* compiler warning */ - kdbp("&hvm_vcpu:%lx guest_efer:"KDBFL"\n", hvp, hvp->guest_efer); - kdbp(" guest_cr: [0]:"KDBFL" [1]:"KDBFL" [2]:"KDBFL"\n", hvp->guest_cr[0], - hvp->guest_cr[1],hvp->guest_cr[2]); - kdbp(" [3]:"KDBFL" [4]:"KDBFL"\n", hvp->guest_cr[3], - hvp->guest_cr[4]); - kdbp(" hw_cr: [0]:"KDBFL" [1]:"KDBFL" [2]:"KDBFL"\n", hvp->hw_cr[0], - hvp->hw_cr[1], hvp->hw_cr[2]); - kdbp(" [3]:"KDBFL" [4]:"KDBFL"\n", hvp->hw_cr[3], hvp->hw_cr[4]); - - kdbp(" VLAPIC: base msr:"KDBF64" dis:%x tmrdiv:%x\n", - vlp->hw.apic_base_msr, vlp->hw.disabled, vlp->hw.timer_divisor); - kdbp(" regs:%p regs_page:%p\n", vlp->regs, vlp->regs_page); - kdbp(" periodic time:\n"); - kdb_prnt_periodic_time(&vlp->pt); - - kdbp(" xen_port:%x flag_dr_dirty:%x dbg_st_latch:%x\n", hvp->xen_port, - hvp->flag_dr_dirty, hvp->debug_state_latch); - - if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) { - - struct arch_vmx_struct *vxp = &hvp->u.vmx; - kdbp(" &vmx: %p vmcs:%lx active_cpu:%x launched:%x\n", vxp, vxp->vmcs, - vxp->active_cpu, vxp->launched); -#if XEN_VERSION != 4 /* xen 3.x.x */ - kdbp(" exec_ctrl:%x vpid:$%d\n", vxp->exec_control, vxp->vpid); -#endif - kdbp(" host_cr0: "KDBFL" vmx: {realm:%x emulate:%x}\n", - vxp->host_cr0, vxp->vmx_realmode, vxp->vmx_emulate); - -#ifdef __x86_64__ - kdbp(" &msr_state:%p\n", &vxp->msr_state); -#endif - } else if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) { - struct arch_svm_struct *svp = &hvp->u.svm; -#if XEN_VERSION != 4 /* xen 3.x.x */ - kdbp(" &svm: vmcb:%lx pa:"KDBF64" asid:"KDBF64"\n", svp, svp->vmcb, - svp->vmcb_pa, svp->asid_generation); -#endif - kdbp(" msrpm:%p lnch_core:%x vmcb_sync:%x\n", svp->msrpm, - svp->launch_core, svp->vmcb_in_sync); - } - kdbp(" cachemode:%x io: {state: %x data: "KDBFL"}\n", hvp->cache_mode, - hvp->hvm_io.io_state, hvp->hvm_io.io_data); - kdbp(" mmio: {gva: "KDBFL" gpfn: "KDBFL"}\n", hvp->hvm_io.mmio_gva, - hvp->hvm_io.mmio_gpfn); - + kdb_display_hvm_vcpu(vp); return KDB_CPU_MAIN_KDB; } @@ -2094,7 +2107,7 @@ kdb_display_vcpu(struct vcpu *vp) kdbp(" arch info: (%p)\n", &vp->arch); kdbp(" guest_context: VGCF_ flags:%lx", vp->arch.vgc_flags); /* VGCF_in_kernel */ - if (is_hvm_or_hyb_vcpu(vp)) + if (is_hvm_or_pvh_vcpu(vp)) kdbp(" (HVM guest: IP, SP, EFLAGS may be stale)"); kdbp("\n"); kdb_print_uregs(&vp->arch.user_regs); @@ -2102,7 +2115,11 @@ kdb_display_vcpu(struct vcpu *vp) for (i=0; i < 8; i=i+4) kdbp(" %016lx %016lx %016lx %016lx\n", avp->debugreg[i], avp->debugreg[i+1], avp->debugreg[i+2], avp->debugreg[i+3]); - kdb_display_pv_vcpu(vp); + + if (is_hvm_or_pvh_vcpu(vp)) + kdb_display_hvm_vcpu(vp); + else + kdb_display_pv_vcpu(vp); kdbp(" TF_flags: %016lx guest_table: %016lx cr3:%016lx\n", vp->arch.flags, vp->arch.guest_table.pfn, avp->cr3); @@ -2291,6 +2308,21 @@ static void kdb_pr_vtsc_info(struct arch ap->vtsc_kerncount, ap->vtsc_usercount); } +static void kdb_print_p2mlock(struct domain *dp) +{ + struct p2m_domain *p2m = p2m_get_hostp2m(dp); + mm_rwlock_t *lp = p2m ? &p2m->lock : NULL; + + if (lp == NULL) { + kdbp(" p2m lock ptr is null\n"); + return; + } + kdbp(" p2m lockval: %x unlock_level:%x recurse_count:%x locker cpu:%x\n", + lp->lock.raw.lock, lp->unlock_level, lp->recurse_count, + lp->locker); + kdbp(" p2m locker_function:%s\n", lp->locker_function); +} + /* display one domain info */ static void kdb_display_dom(struct domain *dp) @@ -2332,8 +2364,8 @@ kdb_display_dom(struct domain *dp) kdbp(" mapcnt:"); kdb_print_spin_lock("mapcnt: lk:", &gp->lock, "\n"); } - kdbp(" hvm:%d priv:%d need_iommu:%d dbg:%d dying:%d paused:%d\n", - dp->is_hvm, dp->is_privileged, dp->need_iommu, + kdbp(" hvm:%d pvh:%d priv:%d need_iommu:%d dbg:%d dying:%d paused:%d\n", + dp->is_hvm, dp->is_pvh, dp->is_privileged, dp->need_iommu, dp->debugger_attached, dp->is_dying, dp->is_paused_by_controller); kdb_print_spin_lock(" shutdown: lk:", &dp->shutdown_lock, "\n"); kdbp(" shutn:%d shut:%d code:%d \n", dp->is_shutting_down, @@ -2351,13 +2383,14 @@ kdb_display_dom(struct domain *dp) kdbp(" pt_pages:0x%p ", ap->mm_perdomain_pt_pages); kdbp(" l2:0x%p l3:0x%p\n", ap->mm_perdomain_l2, ap->mm_perdomain_l3); kdbp(" ioport:0x%p &hvm_dom:0x%p\n", ap->ioport_caps, &ap->hvm_domain); - if (is_hvm_or_hyb_domain(dp)) + if (is_hvm_or_pvh_domain(dp)) kdb_prnt_hvm_dom_info(dp); kdbp(" &pging_dom:%p mode: %lx", &ap->paging, ap->paging.mode); kdb_pr_dom_pg_modes(dp); kdbp(" p2m ptr:%p pages:{%p, %p}\n", ap->p2m, ap->p2m->pages.next, KDB_PGLLE(ap->p2m->pages)); + kdb_print_p2mlock(dp); kdbp(" max_mapped_pfn:"KDBFL, ap->p2m->max_mapped_pfn); #if XEN_SUBVERSION > 0 && XEN_VERSION == 4 /* xen 4.1 and above */ kdbp(" phys_table:%p\n", ap->p2m->phys_table.pfn); @@ -2932,7 +2965,7 @@ kdb_cmdf_mmu(int argc, const char **argv return KDB_CPU_MAIN_KDB; } -/* for HVM/HYB guests, go thru EPT. For PV guest we need to go to the btree. +/* for HVM/PVH guests, go thru EPT. For PV guest we need to go to the btree. * btree: pfn_to_mfn_frame_list_list is root that points (has mfns of) upto 16 * pages (call 'em l2 nodes) that contain mfns of guest p2m table pages * NOTE: num of entries in a p2m page is same as num of entries in l2 node */ @@ -2985,7 +3018,7 @@ kdb_gpfn2mfn(struct domain *dp, ulong gp *typep = -1; return mfn; } else - return get_gfn_query(dp, gpfn, typep); + return mfn_x(get_gfn_query_unlocked(dp, gpfn, typep)); return INVALID_MFN; } @@ -3001,8 +3034,8 @@ static kdb_cpu_cmd_t kdb_cmdf_p2m(int argc, const char **argv, struct cpu_user_regs *regs) { struct domain *dp; - ulong gpfn, mfn; - p2m_type_t p2mtype; + ulong gpfn, mfn=0xdeadbeef; + p2m_type_t p2mtype = -1; if (argc < 3 || (dp=kdb_strdomid2ptr(argv[1], 1)) == NULL || @@ -3015,6 +3048,7 @@ kdb_cmdf_p2m(int argc, const char **argv kdbp("p2m[%lx] == %lx type:%d/0x%x\n", gpfn, mfn, p2mtype, p2mtype); else kdbp("p2m[%lx] == %lx type:N/A(PV)\n", gpfn, mfn); + return KDB_CPU_MAIN_KDB; } @@ -3556,6 +3590,9 @@ kdb_cmdf_info(int argc, const char **arg kdbp("|_x2apic"); kdbp("\n\n"); kdbp("CC:"); +#if defined(CONFIG_X86_64) + kdbp(" CONFIG_X86_64"); +#endif #if defined(CONFIG_COMPAT) kdbp(" CONFIG_COMPAT"); #endif diff -r 8b0762504037 xen/kdb/kdbmain.c --- a/xen/kdb/kdbmain.c Wed Oct 31 16:08:55 2012 -0700 +++ b/xen/kdb/kdbmain.c Wed Nov 14 11:03:24 2012 -0800 @@ -53,10 +53,6 @@ static inline unsigned int kdb_firstbit( return (unsigned int)val; } -void noinline mukchk(unsigned long ul) -{ -} - static void kdb_dbg_prnt_ctrps(char *label, int ccpu) { @@ -179,11 +175,6 @@ kdb_begin_session(void) } } -int noinline mukid(void) -{ - return smp_processor_id(); -} - static void kdb_smp_unpause_cpus(int ccpu) { @@ -238,8 +229,7 @@ kdb_end_session(int ccpu, struct cpu_use watchdog_enable(); KDBGP("end_session:ccpu:%d\n", ccpu); } -volatile int mukwpprnt; -unsigned long mukaddr1 = 0xffffffff81243ae7, mukaddr2 = 0xffffffff8100986e; + /* * check if we entered kdb because of DB trap. If yes, then check if * we caused it or someone else. @@ -276,14 +266,6 @@ kdb_check_dbtrap(kdb_reason_t *reasp, in } } else if (! kdb_check_watchpoints(regs)) { rc = 0; /* hyp must handle it */ - } else { - if (regs->rip==mukaddr1 || regs->rip==mukaddr2) - { - if (mukwpprnt) - kdbp("MUK: ignoring wp:%lx\n", regs->rip); - kdb_end_session(ccpu, regs); - rc = 1; - } } } return rc; @@ -382,7 +364,7 @@ kdbmain(kdb_reason_t reason, struct cpu_ } } else if (rc == 2) { /* one of ours but condition not met */ kdb_begin_session(); - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) current->arch.hvm_vcpu.single_step = 1; else regs->eflags |= X86_EFLAGS_TF; @@ -422,7 +404,7 @@ kdbmain(kdb_reason_t reason, struct cpu_ if (!cpumask_empty(&kdb_cpu_traps)) { /* execute current instruction without 0xcc */ kdb_dbg_prnt_ctrps("nempty:", ccpu); - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) current->arch.hvm_vcpu.single_step = 1; else regs->eflags |= X86_EFLAGS_TF; @@ -439,7 +421,7 @@ kdbmain(kdb_reason_t reason, struct cpu_ if (kdb_swbp_exists()) { if (reason == KDB_REASON_BPEXCP) { /* do delayed install */ - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) current->arch.hvm_vcpu.single_step = 1; else regs->eflags |= X86_EFLAGS_TF; @@ -538,7 +520,7 @@ kdb_handle_trap_entry(int vector, struct kdb_trap_immed_reason = 0; rc = kdb_keyboard(regs); } else { /* ss/ni/delayed install... */ - if (guest_mode(regs) && is_hvm_or_hyb_vcpu(current)) + if (guest_mode(regs) && is_hvm_or_pvh_vcpu(current)) current->arch.hvm_vcpu.single_step = 0; rc = kdbmain(KDB_REASON_DBEXCP, regs); } @@ -755,3 +737,8 @@ kdb_trcp(void) kdbp(" [most recent]: %016lx trcidx: 0x%x\n", &trca[i], trcidx); } +volatile int muklkdbg; +void noinline mukchk(unsigned long ul) +{ +} + _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Thu Nov 15 14:59:51 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 15 Nov 2012 14:59:51 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ0uf-0000it-Ma; Thu, 15 Nov 2012 14:59:29 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ0ue-0000io-6g for xen-devel@lists.xen.org; Thu, 15 Nov 2012 14:59:29 +0000 Received: from [85.158.143.99:32555] by server-3.bemta-4.messagelabs.com id 49/11-06841-F4305A05; Thu, 15 Nov 2012 14:59:27 +0000 X-Env-Sender: fantonifabio@tiscali.it X-Msg-Ref: server-11.tower-216.messagelabs.com!1352991565!22547102!1 X-Originating-IP: [94.23.245.208] X-SpamReason: No, hits=0.9 required=7.0 tests=HTML_20_30,HTML_MESSAGE, ML_RADAR_SPEW_LINKS_14,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 30059 invoked from network); 15 Nov 2012 14:59:25 -0000 Received: from unknown (HELO lnx3.fantu.it) (94.23.245.208) by server-11.tower-216.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 15 Nov 2012 14:59:25 -0000 Received: from localhost (localhost.localdomain [127.0.0.1]) by lnx3.fantu.it (Postfix) with ESMTP id C5D35401747; Thu, 15 Nov 2012 15:57:26 +0100 (CET) X-Virus-Scanned: Debian amavisd-new at lnx3.fantu.it Received: from lnx3.fantu.it ([127.0.0.1]) by localhost (lnx3.fantu.it [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id VNbwypF64QnJ; Thu, 15 Nov 2012 15:57:25 +0100 (CET) Received: from [192.168.178.50] (host51-78-dynamic.2-87-r.retail.telecomitalia.it [87.2.78.51]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) (Authenticated sender: prova@fantu.it) by lnx3.fantu.it (Postfix) with ESMTPSA id 1FBE94016DF; Thu, 15 Nov 2012 15:57:20 +0100 (CET) Message-ID: <50A502C5.9070904@tiscali.it> Date: Thu, 15 Nov 2012 15:57:09 +0100 From: Fabio Fantoni User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:16.0) Gecko/20121026 Thunderbird/16.0.2 MIME-Version: 1.0 To: xen-devel , Anthony Liguori , Gerd Hoffmann Subject: [Xen-devel] Qemu crash on xen hvm domU with spice + qxl X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: fantonifabio@tiscali.it List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: multipart/mixed; boundary="===============7913354209453772044==" Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org Questo è un messaggio firmato digitalmente in formato MIME. --===============7913354209453772044== Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha1; boundary="------------ms080700070703050209090706" Questo è un messaggio firmato digitalmente in formato MIME. --------------ms080700070703050209090706 Content-Type: multipart/mixed; boundary="------------060501020502040905060206" This is a multi-part message in MIME format. --------------060501020502040905060206 Content-Type: multipart/alternative; boundary="------------090700080306030300070805" --------------090700080306030300070805 Content-Type: text/plain; charset=ISO-8859-15; format=flowed Content-Transfer-Encoding: quoted-printable Starting domU with spice + qxl qemu always crashes. -------------------------------------------------------------------------= ---- /var/log/xen/qemu-dm-QUANTALHVM.log -------------------------------------------------------------------------= ---- main_channel_link: add main channel client main_channel_handle_parsed: net test: latency 51.500000 ms, bitrate=20 496725685 bps (473.714528 Mbps) red_dispatcher_set_cursor_peer: inputs_connect: inputs channel client create id 0, group 0, virt start 0, virt end ffffffffffffffff, generation 0,=20 delta 0 id 1, group 1, virt start 7f3da8327000, virt end 7f3dac325000,=20 generation 0, delta 7f3da8327000 id 2, group 1, virt start 7f3da03bd000, virt end 7f3da43bd000,=20 generation 0, delta 7f3da03bd000 *(/usr/sbin/xl:3513): Spice-CRITICAL **: red_memslots.c:123:get_virt:=20 slot_id 194 too big, addr=3Dc2c2c2c2c2c2c2c2* -------------------------------------------------------------------------= ---- Dom0: Wheezy 64 bit with kernel from package linux-image-3.2.0-4-amd64 version = 3.2.32-1, package blktap-dkms, spice 0.12.0, spice protocol 0.12.2 and=20 all dependency packages for xen hg clone http://xenbits.xen.org/hg/xen-unstable.hg (in this build=20 changeset is 26152:d1d05cb59a76) ------------------------- vi Config.mk ------------ PYTHON_PREFIX_ARG =3D QEMU_UPSTREAM_URL ?=3D git://git.qemu.org/qemu.git SEABIOS_UPSTREAM_URL ?=3D git://code.coreboot.org/seabios.git SEABIOS_UPSTREAM_TAG ?=3D master ------------------------- Added some patches: - tools: Improve make deb - Add qxl vga interface support v5 - tools: Compile qemu-xen with spice ------------------------- =2E/configure ------------------------- make deb Qemu upstream: commit ce34cf72fe508b27a78f83c184142e8d1e6a048a Seabios upstream: commit 9600c800ac2a6b34a9993d99e7d3d4f7301e9265 Are there some new seabios settings that I'm not aware of in order to=20 get xen and spice with qxl functioning. See build log on attachment for=20 details. Here the configuration of the domU tested: -------------------------------------------------------------------------= ---- name=3D'QUANTALHVM' builder=3D"hvm" memory=3D2048 vcpus=3D2 hap=3D1 pae=3D1 acpi=3D1 apic=3D1 nx=3D1 vif=3D['bridge=3Dxenbr0'] #vfb=3D['vnc=3D1,vncunused=3D1,vnclisten=3D"0.0.0.0",keymap=3D"it"'] #disk=3D['/mnt/vm/disks/PRECISEHVM.disk1.xm,raw,hda,rw',=20 '/dev/sr0,raw,hdb,ro,cdrom'] #disk=3D['/mnt/vm/disks/QUANTALHVM.disk1.xm,raw,hda,rw','/mnt/vm/iso/QUAN= TAL.iso,raw,hdb,ro,cdrom'] disk=3D['/mnt/vm/disks/QUANTALHVM.disk1.xm,raw,hda,rw'] boot=3D'c' xen_platform_pci=3D1 device_model_version=3D'qemu-xen' vnc=3D0 #vncunused=3D1 #vnclisten=3D"0.0.0.0" #keymap=3D"it" stdvga=3D0 spice=3D1 spicehost=3D'0.0.0.0' spiceport=3D6000 spicedisable_ticketing=3D1 qxl=3D1 #videoram=3D16 #device_model_args=3D["-vga","qxl","-global","qxl-vga.vram_size_mb=3D64",= "-global","qxl-vga.ram_size_mb=3D64","-device","virtio-serial-pci,id=3Dvi= rtio-serial0,max_ports=3D16","-chardev","spicevmc,name=3Dvdagent,id=3Dvda= gent","-device","virtserialport,nr=3D1,bus=3Dvirtio-serial0.0,chardev=3Dv= dagent,name=3Dcom.redhat.spice.0"] -------------------------------------------------------------------------= ---- Someone can help to solve the problem please? If you need other information and/or test tell me and I'll do it. --------------090700080306030300070805 Content-Type: text/html; charset=ISO-8859-15 Content-Transfer-Encoding: quoted-printable Starting domU with spice + qxl qemu always crashes.

-------------------------------------------------------------------------= ----
/var/log/xen/qemu-dm-QUANTALHVM.log
-------------------------------------------------------------------------= ----
main_channel_link: add main channel client
main_channel_handle_parsed: net test: latency 51.500000 ms, bitrate 496725685 bps (473.714528 Mbps)
red_dispatcher_set_cursor_peer:
inputs_connect: inputs channel client create
id 0, group 0, virt start 0, virt end ffffffffffffffff, generation 0, delta 0
id 1, group 1, virt start 7f3da8327000, virt end 7f3dac325000, generation 0, delta 7f3da8327000
id 2, group 1, virt start 7f3da03bd000, virt end 7f3da43bd000, generation 0, delta 7f3da03bd000
(/usr/sbin/xl:3513): Spice-CRITICAL **: red_memslots.c:123:get_virt: slot_id 194 too big, addr=3Dc2c2c2c2c2c2c2c2
-------------------------------------------------------------------------= ----

Dom0:
Wheezy 64 bit with kernel from package linux-image-3.2.0-4-amd64 version 3.2.32-1, package blktap-dkms, spice 0.12.0, spice protocol 0.12.2 and all dependency packages for xen
hg clone http://xenbits.x= en.org/hg/xen-unstable.hg (in this build changeset is 26152:d1d05cb59a76)
-------------------------
vi Config.mk
------------
PYTHON_PREFIX_ARG =3D
QEMU_UPSTREAM_URL ?=3D git://git.qemu.org/qemu.git
SEABIOS_UPSTREAM_URL ?=3D git://code.coreboot.org/seabios.git
SEABIOS_UPSTREAM_TAG ?=3D master
-------------------------
Added some patches:
- tools: Improve make deb
- Add qxl vga interface support v5
- tools: Compile qemu-xen with spice
-------------------------
./configure
-------------------------
make deb

Qemu upstream: commit ce34cf72fe508b27a78f83c184142e8d1e6a048a
Seabios upstream: commit 9600c800ac2a6b34a9993d99e7d3d4f7301e9265
=
Are there some new seabios settings that I'm not aware of in order to get xen and spice with qxl functioning. See build log on attachment for details.

Here the configuration of the domU tested:
-------------------------------------------------------------------------= ----
name=3D'QUANTALHVM'
builder=3D"hvm"
memory=3D2048
vcpus=3D2
hap=3D1
pae=3D1
acpi=3D1
apic=3D1
nx=3D1
vif=3D['bridge=3Dxenbr0']
#vfb=3D['vnc=3D1,vncunused=3D1,vnclisten=3D"0.0.0.0",keymap=3D"it"']<= br> #disk=3D['/mnt/vm/disks/PRECISEHVM.disk1.xm,raw,hda,rw', '/dev/sr0,raw,hdb,ro,cdrom']
#disk=3D['/mnt/vm/disks/QUANTALHVM.disk1.xm,raw,hda,rw','/mnt/vm/iso/QUAN= TAL.iso,raw,hdb,ro,cdrom']
disk=3D['/mnt/vm/disks/QUANTALHVM.disk1.xm,raw,hda,rw']
boot=3D'c'
xen_platform_pci=3D1
device_model_version=3D'qemu-xen'
vnc=3D0
#vncunused=3D1
#vnclisten=3D"0.0.0.0"
#keymap=3D"it"
stdvga=3D0
spice=3D1
spicehost=3D'0.0.0.0'
spiceport=3D6000
spicedisable_ticketing=3D1
qxl=3D1
#videoram=3D16
#device_model_args=3D["-vga","qxl","-global","qxl-vga.vram_size_mb=3D64",= "-global","qxl-vga.ram_size_mb=3D64","-device","virtio-serial-pci,id=3Dvi= rtio-serial0,max_ports=3D16","-chardev","spicevmc,name=3Dvdagent,id=3Dvda= gent","-device","virtserialport,nr=3D1,bus=3Dvirtio-serial0.0,chardev=3Dv= dagent,name=3Dcom.redhat.spice.0"]
-------------------------------------------------------------------------= ----

Someone can help to solve the problem please?
If you need other information and/or test tell me and I'll do it.
= --------------090700080306030300070805-- --------------060501020502040905060206 Content-Type: application/octet-stream; name="xenbuild.7z" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="xenbuild.7z" N3q8ryccAANhS06UXrUBAAAAAABdAAAAAAAAAJsL+xQAHmgECYbzOIC5RUbjJg66yLypbeBN TBXAfWZPAACagHoYvvxOFx9dlg1+CUEWKqPnxsQZDohW8Sg/7+7Qpw9/N0rj7LqXMaRAFVm3 XEKO9X1B9SyjCgbuv4tqJBjv5Hh9dM+NaKxkd0U6c3ASUvf4Bl1OQsgxeDUcRyn+GXFL/UdP 1k2I2k6MOl3HueExZ9GIurc382QoheY60ipcQ5ip+lJhb7rdGgJvd5xOi55aDCCb3CA7wGyd U2Ioxp38UW6geDi7t9TkxH0mJKZuAknMcqqNuNiJjiCxWqrf5V9ZW1MwhACAFLekggmD09/x niX2lzjG9rKrKXzkEfE8BbnI+9ny0kDqE7v6sZW1Nx+WK5eCAa3yztozoMmnCpvQ+PMAMKxh Nq+iEiej7CvtCkz7XgeT97KmIS4g2G+5VOG6PVbzj8TPBbd5bF6+jHdSxx9ELICd1WHQqsRv yZOjmXvnzDkkY0OpN3HNH1ZPHJzESJ9MMh/2I/Lhco6RMf2DcON7kXfO62kYZcdw4dBdc+7h E7TR3+2nUDYMu9u/+Sg21fbPI9/qfTwlCT0aJjVGh9MkogGFGjWx83BzoPxe0jcQOTbjbFYh 2e3jYFEdA98LImYGy6jf8py8/Y8CunpyfZr2+zOLzQZhTj9a8YBWYWAqf7PGNGhV1JsXh6Df WgD3iH/5t/wmNvVZzjyciY9scY7w5P7El4eF5S9fu+aISzivbCo/t2FPcmrTSbnEGVjcWbYc Y/eLoXQHzIj8KAEUE1pRpnJIXL+zNHu7aujVmi3BGup3NscsvFRrhX3lGJY3atvI8RCo24Q+ P6WO66lq52rF2vUr5/F26rWABGeKl04g15wcHqoZ6yk0qwDqCJRifkdX0+FqNfcug1DVo5FW OjLlU5SckUC+S2wlBFIwY1tRwFwttq2nE26YCSGSwirdKRSXieJ+JtGGppaMI5NkrUmpGtUL Cx6W+aQk/8Q1B/ghmX63S/2It2KP8UaAjFU8sqNt2WSZm3j4yNc2b2WhrQ+T9aVKd0PP9dhY AfoCDzOozY6PVIZfV0/Oudt9gig9dkmvyx3fw6gckSJe8BSQ8j1g+8PTA+DeuNZ2NFwo9Gwz lWW4jvWKowfdofuSIjU5+JoD7mVz9wtyEMZfOvQsR19S75B7EvO5IzjNedcg/lWrO+ZC/0bK BFd81Ipg5MfCrf8cfNt8Af1W+FF3MF6OD/9gF9Fs2EBO+V/U8RCoF2kCdJPg3H+UyjV0xnIG YETWf3LI4v6Kyq7aGh1wq7mIXblRw0G1xILypdeVH0KMv1Ty+hhtVz8SVIbQcD+Kzu1oKg2r PcvwWnU9Wno3yHBsXmKrFb+UGAQvWe7KKf/HjUJGanjit3HZBNpirpPPfit9sr0VSwBGYxn7 VdcstssOAlzkFC/D5mTUx5dN9Xmzh9F+1uwkcdi0l7jU44kVz0Q+xWltfPJ5KJhGP7naQkmG Fp1FtZED3bNR+pWNHTDHWZR6yf+XiUp+E3t8RjHP56I/BfMTN6tTFF5pMDWonHpb6T+iiSOO UZbQiNWBrgf+paI2mYCzdfaY7z6pL3vn38JyyieTd2E95Fz0ota9A9suEJcK611TrwveDKYM KAD0gk9U3tUWkr04Aw06AyZdJreLLJMU3/rdYI3KwBY9keSKX2KvT+YAfP60sPzDhc4iKmwx 1Obg1i6Nt2lTptzgwBUa/1ojZpOpJd6CUQo16WuLFr5jc9fR4K0F0uQbnlMiam6OSBfQHFCe aRNAUZh/A3IoJHTr9RHJkMR9FcMta9Sj3K8oPPb5rjmOyqHphL7icwqKvREqJk9isTHyX+jO FFYUXQsAuE0bEE8cI0KP/ci0/HCcFPX+png6qv+BpsRJoMbpin22QEYAR3LXIuXBYVqUZNI0 oBAA1Dk93mKDWufRCvuVxCuwaQkEeQFXuyDrDlNJMhYyXjE7NUj43ZDF03/b346+LRvcZHMj Lua6gKrpgTiiNly2N3bL3IA/Hk7aWVcB6Mlf+rjzRVdW0KAXz9bNXQWMy1kAHq1eem26tRwv wQpmrEaJn7Z8vpAA5BUd2Vxu+v81PajJkZbQo6yb/p7sbqNTwA0SLmKhYCdUPS/JzlgMHn89 RHhRLdfqiabLCNjqAWPfwu6i5WvoBz4P/Yojgn5AvUSE9zpvqVkxYelZQwW2rHNHffyPYE1d W4XygooE4qeDer4MzZiCZ6qF5L9HCzUOpzEa2LxDFGXdRBe+LwEN5iC7RPP2QzPVoVNFO6/F r6J6t1ap/H6hTYtMyZQUHVsUwUbWPyYu7s4x/o0ePIpt/UIRrJK8r2SSiyhZ+Ysyx/L/RjHr f5J40lDwLJYXPDYpVIT+J1zmvNDqFrZXxeB+SQsJ6pS2bp6xAnRwjpwRIzimrfUu7Fvq4Bvy 6U7hpBvB9Q18zOgKPFztkamRPZ/zYJEWUnOF8Ho5/IB0dzRNeEBpNtrzeNr/NmjoYnOzQ2zD YIUqniEx3u3HaFcsI1T0XgVFh1BI3NW7V8XbNKtE0/Tb1mf8d5eAtMTWK8L4reMHtCmHafmu HsOz3uqMXqH1SXC+SUH47FRZ9BRA3x7cPBJ14bDqMcSG96/SfyTAMBzoB6yD51PES5wMOsc+ qfKnopse8FFNvQlYv4+q1rLy8icavgfxkJqXtLharswnEobPw3SH3J1/FyAZTBO/NIxlj7lO 8WXs+X41hYhAsL4oLXng95FLHcmABfxyWIu+gdt7llzbKzbyQDqtLOXGoSHPj+3LM83UerCs B+y9ZvhMcqZ5Jf8SSMDYf3SX378k7+dqiZuZCjv2fG9ahLJZyAhmzc2WcjW8xPTcf+FFsCJs lKj4jPyxTqAwK6l9U4gAW7TELt92o1WHvWv1toUIcFxYtY3I56LZg79oIDhhB5ObCEdFaErc CK2iOCngo7hG2PpooOjtGq33GKQbj9bcxszluwpNBr2yIHGubQMuE7zd0Ds0UwrzUHuDHCQA yM3PQYSCo5ZIzgZiPFw2AZoOeB/byOSZ8SnWWJTKDvPXprpm3EFsqfUGoynIHdtw5jPNfQHd o4hP5P4mJnc46yAp9U5Ygj0BEyNLt6Buqwk5EPUm2eWbZ/BU0FTO6WfMAn8ZMcJD3j2jl8NO rg6kESrnWiD+7SERBui+KvEVVzoDTfFGZuNTH6Ykx1JYw6iGMHoCItrmEWuEvvAliR3mRvlG LSVV4FAeo3RwAzN8Fj2DEvtzgJNbAYsMeVvfIjoM38vc9PWrKuiYlUlX//0Gq59sHKm4nEtJ zFG3udxqKddEetbSwn85y/MDGnuuAh1Fhv/nhKwCmeZxDNcuUItE5CN64CzqEgw6Vr32W3TX mrxX2n4lcN+gRNupGdfTXarOqWHtviywm0jnoSVcjRqIpuL/aTxlYuKO+cQSVwroAxmNjKkS TCahTMawRt3+HAdTK1oWo2tzktR48fUNenwRyH3pnMiWLyLKfLLBfN79PBbvsuWWPFiosmx0 Sl0fWBCPcolKtFUtrKKyJkYPxmXLOGtiyshg8oMNYS/KdMVmK4IoASzsHZcbNAmm+32Dkwn6 8bI4VkxZ3hdeoEVVq5H/8fD9qIHb2UdIlHCl4EuoG6CXrpLQo/bOD8+BVhMaLwqlyJiiqMVN vTchIZhjpAECEq56UUd0nbXNsKTgWDDSsPrdDb73RoDlWUxEC/N9QlVg1pg+44FpuZsC73Mo cO1yrkp6Mif77hi9Y7Bo7vT+h5gXm9cQl1tVK7mIrNK8DnSbDwZLBvfKhgQNxsMXc34nM5VJ nGl5kxPzvlcCfUqAeYYRq07Iv8sirTK+PDOmjPh1M31H6SMXhs3AyxeGCEoM8HNHQ3hwkW82 Lj1S+DG9K6zHpu8mCBMk9VKO1v7djjg+bbrZUyR6Zxd+t9EsJ9zEHsy1H50WtkRfsFt2c9aG 5NLrnd3R7PgzHC+0VHTc21z4TIOlBn+5D1vgtAeiFOGBQcaBayIwqVTJ7BfjnMJ7kWO1HYjp z4z1Xz0V/eI5w3XPZP5nFDWzHyzFZMbPi9xtgQcAlAkmmzdvLnkEs2xyz6xm2X6Hkc/Ru/a1 B/8eo7grwjs/9E2aN3COMEYSAhSwMQqq6ThOibELwAMKOzkk6MZYa8fZf+rQGv5rfxIdJ+33 +GPVfbgsB8G4wwgDPOGChe3xt9CmObrzEXvTe45mKmzxSe4mWfchMdbo6XG+PLVZpH0UXdck fWKWSlkcGEcQ7uVFNLkycW2Xre228vrgvDW0NpC3B1utXYHnG1lhA1B0xszwq/hN5hOniytQ /H/w3kDaave9fmyPZf07wUjnf8NgfoUxKqitrr3Xn3ym/EW+OB25w50iI84YaE9alr3nQIm9 lKVM0BlUxVTjr0pC3XTfzZkuxovP3ZonfQvrGSYc1OjYdl4lRs5k19Vp0u1xcDWB391dYORb gjQtOeRaO9UteFE3m9Mip6Il6iSfGT3xHsHv20N1E9tdYmsTS0Kqewfro6F62mGHWdJdrfi2 F5bOLpR0Zof3cnWsRg7Qxtx5392Wzg55FS8zV8npVYmedDjx+Sh5M26ovWl6WfQsEICEoX4J +teNMH2/F+4JYT/m1GirTUqeXQMtgegc4Ss1ADZ3K7Jy+OE66+J2P5tyM2nn5yhxYAFIZ2sw THWdwb1dM7JwbWDigcLTGuOv6oACEBGlN9xC9ztzbW1flG3W8fiFLzM0fBVR+c29hRHQEPTP L67cqGgg+BMZIpEOWFP8mq1VfMdG4vUSwwMhn8BLY7Ri39lRsNk3Z5atAyPFDvG0D3EBIocq bV6WwgjuPVM9qbqsCNhk01MBimxNcg9q61dHatZAGmNp9wHj1T32BpWt0uC0+Zd/BCdMb8Wo rSPxqtw1HRRwMPrBSCxxZ8jZAXzAb2qzfhl89jjrKa6omVbaqjy5Xqm0sBLHuDVXBooYjt2C P8BrBIxMgPv/QMh+M0sdF2z71vBHYGQtuTy5S9i3sDcgLM2kcYpRD0psfjvwzDncdoIyOS8+ 7zvZGn0P9qGY8tDFznOvwsRqDGMJMqD7+fhzqMmvasVjTExBnZ5Bgi1cgIfnJKLcIUwWjosU AFLWVle59X3RLJHYQujfIc8uVD2O6adVIFDhPfWhEiJtEhvjETN8t8BA4XKJol2nRyQFV1k1 BKSS/pI3OHikp8Z+vqnjToVDbhlemR+jLL38oR5XAJcVInjs0CJry/JshWMYBJyouOltX/NJ aglmojrR1PMC4kLhG/uiLNBDR10+u/VN1ynJUd6bg91T+BLqJVsgessddNORdlZbRBAoy2uA esX5VftI79xEoF3MXPNR6zc9t9VtzFxeqBWyI0i7LvL/Tj2uR3ai5zVTtEfxEOtILD39hrpE peJ+UblSZAef0kKHp+9enhaJduKyAY91ReJ69lLHgtcmwUsEoWDnY/tz9884pA6OewoXdxss htrq1GNbRE/fJxSouh35uvA51MBm+McuDntsXvHSkUOepuWaGYdB8c/ITSGSIgocN7MnbuPS SXQ5bOhHtCAezQU/E3n5P/sF4xdYtyrj/hDOT9CHDciqDtcJHrbyEqA8civacjKmoKEeNVOY /iZfLIFvVuEUKiku8b+Z1vF9cJxqi6eVTekARAFUQu7Q58rkl4mQAviabioTBLn8Dx0+MDFJ fdtYCduNp/tp4qC2nW9Dy2dXV7CtVmFpSOzLwsM4NB4/T1PLA5Teq6KLs9eGeG3C0gASTZCU 0zk7eOV/TcnPk5v/yFONR7OuLlL76LX9z3HbIHoZodmS0GXEQEPbdac3eU0hqnU9706D1q0q b5Q5onK/Ub7Cz34hhm1qqX2vxrLmqhwhbwaqay/1PtYY0D8yqYSHYQB6Fut0uJo7qqqhrtxy HVpVAHmNb3FaaFOva+sext2zLbkYIvDzqoULqnEd01XIJCFe70/sS8BxaNeHSF9O9T5TyZPy JQ7nc6xNLX1lAX/gzGSmz+RgM+k2izTeCEcVLu0qGouJEbXKrMw3LvxH7J5lJLU51c8gF1WT KcX0uqGAJAEx/RQoZ6O7ApYY9ciAR1EoEVl1hQcvwo2ka9pHJIHb3t6qZPnuwmU9xStXglP7 f59RuxVzsdf5q2Wj9Aw6UeEymPw6y8XbPD4Nsk5RvJlzmUtyNwAGCw4US1Q88hWMRoAzwwbf SrOc4T/GufO6zaQwVrBXlYLKzZFz7WC8gr/o0P+ynLl7laPpusSQn9qCG8aHnKzhblEqp603 43ngVGJ+W+bZOakEvlqDPhitW0jEFTJ1bGZ9fCSBBcRhHd+UL1T9IgmWb3k48ZlBBGeJrWDw ss6j8JT2jcp5M8ZFQZl+4JxQLbYYZfh2aYGmQjnsGfeUXXEkyofkPFSpMT1p45HDeJ+X3qGE +YPMFGjysHhNsyKNBH+H66YIXYRAkLjY3cDhRJqCqft1Uu/yULz8VWyEXGaUtdcBX5fxpxz3 INXG5jAaN5/+MSRG6UCU3JPnCdEqtmRIyqybtVd+pI4gEAKbWlMqgVJMdAzHGM1PqS7XomIm aekV3X79ec14R4N5HHYgq2hvFgLTZKJcdJUla+8DTQOCLi6tvWeujmwJmDMu/WYzeIsT67Ge +gTCqYkPU3mW2TB4q+QJxVZQJw0B4tohfLdWMURTS/GtAAqEtBAGoKGX4+dyVwYZQiIcab2G mjGiQENOX4uPtQsZVq6QUGk28sS25KT8P5aW1Hkwr8fXSVnCdPZk5tUfmwyj/guI10URfFW0 oE6MWSR/YgXyvIThE9gMBymDtBlmXYSADRaTS1kvev1VnBCc9MgBOFV5KK7Nlg/vXx9W9Ros WlW10e6DKN8ZKqOF8Gu08ICcR8am0Ae3CSw7pJcSzr8Ke21vkzlI/PS7rpB9eEMTOZgaIKqQ Hz2pMU5Mu+TyFCGpiV08Mgjeaa2obBgocvS7xd/6MV6KoUKJjUJsmU0piBtXBzAmZOzNS4S2 Rw9yPxH2d8nMrFxdPo3OLN5hIvFgEm7GYhWxnvdqhcOaU1DvizIT6feov8ClUrAb6b/hzpHr I6fUWBoI2IxC5JVkbXcZgDfFSrfPu9WSdRTWRzc/LS+thzI79ruIzjiu7Ye7r0WprdYXbNAU Xcw/+bQcLmEdXFCgzXIG7Aj8TD5BXuoIShFFhQYu+Fbkd0IKzxJPFy9WfFAup+krpzuUcitZ v1z3OuPAxA8adrjn913skljkkmRR3UgsfVxHmJDIL0g5iONcW1GvI5b58LLRy9BQvunEWx4Q shNBTAunpo3IjE+wa0bykYJxJ8CLJ6Aj3Zl4UiXwLYW8ln7W8ZfdiBlFXuzFRAlZ4nQUK4DG KMCY7Oq5jW1b+5doxybhI1+uwHc6kY+hiAVUzw8CxLG+0Wfu7CYvTydVRdPzXKDQyUTJWnMF aasypRvBrReOn+j76Ljcm0p+Xz6Ce7KBBLh0MGdOxtQKPLUuA2DDU++gC2Ga+DwnCbVjbfSH GbrVzdLJkoeEXpe5/t9vRDMr098twKjfSKK02uHsJyTPZvX0eehPuw6s2mYS5dY2G0i9vy3H IkIlXKZVRMZMI8z6/DFUWW6HMWAFY6uovnmlUCvUrPkBsi9y2klTEKGswNMvo0npRDmLR+Lo /4ksh3KdqgXs4CH4WdGbewT7ybec2sXZO7jWdqzqCfKmNL/Nw6jLjb591Ok+r120xTNzrrAy 9mxR3ktWGigVPHvAbaglU3S7EAvPKBXwMeu1blU+jRI0usHddhPmP1CBkCFsEJ7bh5FaoP8I LgMTvpDWf0ixnUx4hTq4y5QCVhFRpBvy7zYxAhMGAS+K+15mPuWDI6cVFYKof6QT3PvYQgpq Rwzt8HYaeXavWDhH4hPSvLCJTTS6TSvoj1E5NQS7bLKUw+D47a5fjoylgEGQ4AZPMJg50fUk 7wxQfB9cArgZfHpz6G0v4ph8lKzLN3caYI90GJNTo1I5mxfv3gm9Efff/00CY6DplhextaRt dUEh0d1NzS/i3AFDh97leRZhWsEN+78pAyjF3Zxeq0gfRQnqHxz+gjyeYF6wnho88lLeG/Yi XqCNGnWCSeb8TjS2foC/TpG5iazJ1lcj3PcD5KnHDzF7y2/LXztvvYC+jMgN+lh0cJQiv0BX +y4xOkDlcqIzyGaDtQ1qTl3uw9rPQIdNbs7dcg/Id8vt7SH8n3PHT2nBOm8etFx5qTmzQYcf p0ps017uVk67c0NWCwIUdfCVwZ4IpkIJdLakn2miHhdlMBUbfFRGJRmKzCBCNi90ZUoHTX2W y1hVgGNtJyN93Rn34eXxMnpWdgR7MYJo3vqBxAvDiMZlfE444NWx/kD6ewqU24ls0a3z4mh/ 14jXC4JAEcKwTRvoQ40YZloVD8ZNvTx7xphiKReP/l8wZsvmtJROCr2raUx8jghf8ec3TydH sFx0clvTZFU5KHrLsLCCKbXnbeFW52io6pdVxWlsm4jg9HsKSgS+5q9RJR0cK//uRKVxb/KK R96GFsT8lKQY9asAJZQythSvowtyK5SLEKe9pncYlEu5PorO5cUolTCSOc1sMTBk/2qnL4wu kVTO6+paT0HmZdKCuv3HTUandvgygzTa2C3so3XiY5Q4V/CtKrW451tdSvfqV2Yeim82/c1Z /ddK9BJZxslQ9N+j0PVnXy4XkRdtGtbazlCu6CBiPoFQr0qGJXyOlVGXfJ3f369fhJN70FCB Iv11yh5bwyxJDk+c0gre4HJgzSxz3hxaFA/beRlP3KH2tYk2v1ZWzxbWMPglMgxRiel/rUGm W7x9SjXFXVKutLOziS/ghyR8DglJ0xuTiG4S8LjIPutmtKfz/qjRBMvwIw2Qs5a9ItQ9BLHq 1PhtHVUcE6OXXLpSwowu3MTW3LHa4pLMtZ8V/B/KH5CghfWZNewl0p0dBVrsDKxr3qSUIqcE LYGAsFeR4neH5WijkHoNI9MIMY7D4THUA13pCsTq7zPx24B+9OlsQ1SXQxrp7f6O2rsbOYbk FR0yhQGhLc+NMdjcDsgjq0Ec/xmjABZ/4UgygXBTxKDqWHWDnkb2IEXYomYnjR70GinPaedp 1u5dMS+15xIb0uXIf0GjF4fYFTVSb32uW9Gd290p7UHTwnREPMLe6bEj3UWjsZhN+0h8w3w/ gVuT40FzSyWcAITCEiiz8lCZ1Q2fWADva+PPnu+U757Jr/lN/nfSEG4mYtSSH6XUy/ca8Onl pebAwsuG0oNnXYeJKTayCVAMcjzyGR/4RQ1So/JA7GHVgpIZaAGN4vqdQi3gpO75Gl958qOF wXmO7UflSdWDFUz1zvuoxhTTJ/78hiBFdWQ5oOftR5Pa5Po7Rds5Ip3uxqV/yFzpln1N3/K0 mZecjeZEC8S7eI30Kw95UOd0EANf3y+5hQLuy56t4rGGczIBBDZho8yuwkpoXyQT13nH48sK Ui67Fnr69Qbt4V9+R7o7Nf68WsdR7I2LRKYaKElPbVnI2vBCwc4VxlGr7xMYhMf9Pe7xUdao 0VMji6Ae/i48zOtEg+9Z6swjlPbLmdyvneRouF58Wc5kz7Of2+p8Obxe9/AulCldx8qEfyBr 9Jrrpt0hA9JtHg6eyO+bth+GhOAPvyd04Cv8y13TVFkSOEuWWsb0sLsZlIEruSY/43K3LMH/ lvSBM/uCm0BhtvGmOftXKmK0D2FTTylWhz/krwDOJcgE4P3uEqKXx7JK1y6b0gzfnFa5Llrl AOt+RcPzFvSNl2/WUxDAWof3wWNi52OPHN+Rpjxx5eUfQdpUuuBDDDyH7eFO9vDKC6SRw31k QFpwDpEHJ7JdXQancwvzYasHwhwoNftPJmWjGxufLVAmJ0MK6RJBo9RPefqbENqqaV63Xxgw r7iIV2hoL/qjOp1fQehTeQ5nArFU5FGjm5E5ff9uzG72J+hRhiOEZFMn3VT+jDUKcl8x/BTs jACUqCFXsTO7rjuYa4QJJAJLpxGsaH6COQA1g7npyLBJxVOof6yOrtp2M+jAwDyx6+bKCr3U lzXqTUR/fLk115PZA/GNgke3Nnfvko8KCX61ne1YMlpGOodG/CvwNfi5N6BpVjXvBudPQVt9 neTR0UTyRiVPl2rmWEg1ynmVHFUXU1q2q5EFe4G97j7M6LLwuF951caqIA6rg+Wg7bVDVfeU AByXy1msusLDB4OPLHTJpPgqOE/KAqfCxiZsFeUsHMOH74Ex28Tll8Ab538fQZuFkMB8VoGk 6K5N9J0nWgHrXrvEkMWx38FrequQpH3AqksCErqojSHtIxKwzIC+aJ61IILNyJrL95iHzBl/ jawlxbPN+5eZeVoeLsDOaGPPXraWyoYhmNNtDruaWHn4WP2Mns8t/c+O2qIMdOrVAq90u8i0 /+3GkrbRUtXDtuf7eBVdt2F1VSMYDGOabmwi8R19GYnLtSZgzGRlARgNzZhzcVrRAYzYD9p+ LVpk9CX5uFR30WS5qRWF9x9bqHbj4dtIKyXzfTpkSn7DD0fchrz21VYHiRWVZPndXhPKzXXm WV+WbFddNFqaZwUCU6HDyx2Mj92d2JHyU40S0nuor2FPwjvAe8iyCFAeP/m0zbMKr/BLg4Ql 4bt9qT+3vCdEWKOLo6RzYiPflCsvd/aKXwJZAVd+RzNliRi0PnScpme+22qvcuUz7OLSea1E Z9yDR4tSoN+xTFsmY4gqZHvrf4jIN80fcbEVK+T7jXPWqDs4CGMWvPx1xUmcax3tqMfmTIg2 PdEvT8K1ORq8zyyhw6Kq4FBYRiH5pc8xycWM2utbcxGT7MvX3TjOXMEmdZKrSRQOKiVuHGnN n/tk/SF7gZEhvLW0wkOMdcBG2J3UggDax8hLgB521gAJM80k3xJnPESbkKp4OZuFX54HOSeM 3kQMzRENx/QckcVXVmEUC7VYNdjPSYv7A7UoQmv2zm+dR9ecrUmDARj/ZKmFa9UiTSLIazZu 4udnoiE8oV8RqYdJOJlvtORh2EmkRMiZUee9tXAB0wqH5yeevqmo6XYpzOloifK84srV+dR8 0BzgZcP/a0LH4hUV7Txm84h47/O5506OYO62a6Jq8HlDuuI9CjfglSwEVM7/l44W7NtLaIeu DXjIonyOxuQWNxem+OsBVRWaWtsPZMUJ2ngOJrbCtp74vlFdLUqe+DO9HHgLSPxqI9fQV3v8 4QRAWgd6XK5JOYd/UVOIT87f/q2cDRzHCrjifJj+kOhtSLQynJHmh/1uU9KY3l+j8AJp4bsV n4FUO7dXF7TGFE7W7lnhlmlTUbXX8ZfV2WVyQ1yWqi/Dei1L8kbftLOWdIihKXARjgZBsK2d zD9djTVu9GpeX+a45h1QT8VcKjB0vptEhgLo8nyVc1vA1+9WvLJZCN1t1KfDEcPyeArgMHYK b/4I9twR9AJDhjoClgClK6uCophyEEW9aYfKy3Wy/sxECZKeMCE+NGrFlHSaAGGB87wlkJVY WS+2BBLrRjsfYAHJda+SCJnSgYBtpefIlSHNWPjrZ6+fblPOnT8E6E90DLYH3/ks1rRURloY K/y9z5AeFhkj6iCUpWD079+opr0YLFjszPvMynguKlP9n8hf2ADuZhblcYiUfkoKeVhXVMs4 8MjYn81BSdDYZm+Ze4awzcg9PMUEiYUwD0Iuq3Q6MRt7u7yNsyUkkA+Ofd8VTIjCiSeSGUoE Us45YtvDUp+F4bCvw4ej8yBaeAzrFUI8+BnwUwCFmG+YAvJQrNCfqI28cWSZT4AFsjmK/oro ZCvteL5dCb9EtqpHVJ4HE3MiiVHeke2VMj6R4LchsPuuD+QHCEbfmhBG6IPWjbbcgRbQFUS+ SBrPaZX51l5eSf7FkGj0HSXM4pN85tENJOJ0876EEkbxh4zNz0xXn/nuX3KUOt0aIGjd7NBo FAIuVZOYNPRA/jeqW4Es7rroEjGnyUDmNbVGa9sSXoUzzTo/lI0xBplvLAnK19sl7Y6qd6UF WiS9uxyQFarlWtIMdnzQmzAYR4Q3nXlwTxQJyWYF3MdOP7r/cZM+dzQ6Rz+Jxoq+fQEaDIq/ /7ZeTZ2kXqhPWBS8CWXo2QSU8hhrg5Df8SkCf3bZ7aiJWru/KND12XdrRxw2oyxETfv+Ek06 Kkf8mEDkI7Z5YUJ2D+VD+yKSXNTgqvar6vCsWqhc/P01LegFr43jNBhzeuPT3NR0DXGJM0V5 EmH06uF7DoYcbK+khGyLZRUgFifhy3dn7zBXvs4eng4NS3chflbZnrVOvjF3UHP+vJqQSW7F pLXQSL3FQ4XQNiGuQi7xOYQ+XDNRYhj4LXbxGuHibu0mZuT8d9CUe3OWqYz+NT4RixXnYRkV 8mYGcGXnRp9tqgHbwN7OCcxwSpBUf5cR6gIlKNXUb94uz25WO/56wjuain0Ky7q74mIGe1tf /DwY1AHm/6LnFzfSnArTH+y5kYY7y1hUCn9r4n98TwOBp07ILKAwe3ohjc01ldUYEsnEktbN CpN+al09TqbynFqMQniu5HLAQGMcH8Y2Lt8ZFqk0ioV3Hizo2tjtakPu8GpEyr3umsSwNOqd bksvgabmp5XNSC1mqMVFBgM9gCTcDek7ZZw2xuP70ZEJ7xaTO4Obv5GgMuNeMYKLIVM9zBh3 +ts0mgAQ/sFc6mqfgCBbmQ+EMJ1tO2X8ayjAc7t6tXUTFvrTn1qr5RQW66EoWpTTVo6/q9Vn lbMKvPrPw4MPO7QIr2at7nN7qB24m10remRPgkwnUlxdqJsv1tnyzVqbqGJhAUD8j7XMGuXs B6Ko9mTHi6qQKtymk5EbPSYfoHi1dI3bsUy/g1sFW7LS8y2S13NeX7wK+uQ4YmEYHG9ZIeDS j/smdK6wrEoBLhPzLICJ7XSGZIQfasfh5980Qk7ywhic/y80Y0hDGYTEIQ1sdZRZqjiblyC8 jrc5P945jDd2gUnbnK0nw0cXfT1ju4MSA3t3jfkfaaW3OXF5DibGkuPSeMXqg/6aYCdvZAvB WiXTJ9POSnXvS4CULVu+rxwdstEWK1ILzciAQWlMMO5Bd/FtPUZnPZgBbQ5y7ZYGJRx6ESDy A8XDXPAsxmhDujNerTEGvdDMLHS7VfaWVfp4tYEFL9FVLvNYFTDbFH5HMyfkTMSDULJSk7rq ZfEqtCIxh7QGA8bLEXvRjtr9M3P/wQumz+eyYgETR6T+3m7tRwha7WJdoSh1d20vFj4/K9+y ulvJEREHcdyAh8wFIyTdx1zTpxg5GYTsXQBBT1Ag2bhASM62V6HZQlxcS43Re/omZOzRnrqC nZ5J4NoH6gyrtxU+J3Rzb7l/vH7yCItfaHdJ1NRHp+ZfUdCReQ+3NkI2UayK1EMi+tm1v0LK toexLFD7oGaW2NprBH/WLs53xAcsr32NAGh0Dug7GNeIY3u90D8G9yoVJyotbGNLGqh1F6Dr YYNtCKM8evE6sDKiuYC5oHHVjKa592Jpds3egxGCjSEQMzOg4K/Z1CkkQzs4ugtbbZ/1sVWy LQ4JHsED5asuWs3HReLRDxbPQlyFb4snYxMs87UfKxquPJcRHRcmvMPOli7AtgjQxstBlP9T KtYMD0DZwVLhGWlnd1kyh1BPUiPJxSe0B6cL6VTK8fUNEpyOdJxaqPs42/EFPCHyAlqfNB7f Nn44YYGhGUDFNsr0qKvOnyvgHdkFt7wai518wB9A+wLmdbCtstAgeHn1o8TOPULxYMJNwEN4 /hGn5MG3g7JimNK8RZ/l0s7RrLj6A96ikizGJx6A+ZYpzhtshZREsIX5o7qsnuTJU9cd3/1K XuZlpN5Xi4Tt5dOthf94fTIvDzsG4BOfVfXRwuf6xj/kvBzJsOoSBzPNzKDdlXYH/SnTyB8l 9PzqpSwQW+zEEaWOtddhxJSHjRXJqeOuDpJBFHieBBjIRceOqFLFaebHo0JqxwMP3z51OJkM Is/Tp3UmbJrBi25yTxAkEQ33fx1G03Ssz5DnMSbEIrJPkBClm1FalCtmfalrKzn3TjUpN+yu Cfv6pd+p0XNP8MRgQ4896WcgGCI5DmQFbG0zTxCKzazR0kcM9MY81WFcBCZWLEu0Yv0j7auI 6KBGVDTS9YGaiU+7SWfBV+66E11wds5CpeXDfKyY6qkCEX5zmhgD6GY2hJ2XPEy307xbn2Cj qCeScSSqVPxZFzIpZd7f80JSl7R/SCqwMeCLd2IyDSx5MLMVCreYh9nWO0J8H28Ykvofma8T QFcPNlbKa04HI0TBjvSHPVq+jFsJ44XM/4o8S4xZp02zu3djQwZ1qX95qY+t/IFl2h4muuWK VPeboZlQRLmBIFjwbsmcutwtDwgbgLHf2yHeL3gpfmaTgMuQQbchpOuoDYqGgfLCDZrS8+lx XLXWNAHpbJA7YrmPEqrFfzhlE2A+W0Ki0AqIoJcocg/RegHZCAhXHpS6NJ/oSt2OVgwVNfY9 QZ8GOeXlU0/yHzKL2X/N2F4G6HdHnu5hJZs7sKOkrBra3epYCH/Z1bT8bJ4WKpSwvTh8vUv8 kyzmVThaSnm+U7JYrwbSExlWSzZqxkwOJIT+K1aXcNg92HnMnHjKgoD/iF8mN9Mai5UWr2Qz PbZjmeZ8z+Gq759rjuwjQyjWRNk37mPO3Bo05CtZBWFdXQ6f2OTZ3BAaZqfI/itWUNie6drJ MDy4ZBaYZsHuR/yc+E+t3CGdo/h/HXSiQq6Yjbm1f8H3KJrBGw7h+STtSNX0B9CxI439zG3I tGbuHAVmLXn8W6ni+7qR4iYbM2qzgBCnu0wvOZQwjo3Nah0Q4PAhMwlwE+1NqBEI4vaMJPXd V4Q24VUaJt0D6GnNvDqgdEDaiu6ZHQ3F6OFV93RyAm40TSJDEPY/suMfdj7OcMqPCto//Y2w x0XTpjCod8LnVV78t6zJqacMZoUhZ8P3KKN8urkHrsgnUInZUvAM+0PiyjzDa1pHcoJZzMqg 6sWakJqxL6KDCaZ3wM+tB6GyqwivxaAnurZ8krH/v0DLu0BMgBdtKlQvT/nmU8xorcSCJAM3 eJZj1QpRQBj/j47F/p6yxC8VyCSoLvPXV5b2V68B9z2ibmGJghoKtMCR/hpVIZwpXuGfpNoH PcV8pP+AFPE/JzlNClZ/00DsfRo4sboc/j/PaneM+0wfRyqojDJYFGrIBvAXUD7bejjNpoBr mM8PmkuYoJe7aU2QIe6iBwM8ZQMQCKTlHLCfPB5bCVCxbVsvqm8Lfx/CilsdKrHHn2bCunpG cHqhULuaxS9rHY6EMMIFRNqGc548G+phOvyRnCCjIgcEKbB0OGvOBQ3qgnuFlb8A4qr5r0Ss z/IO/pD7XszqMQwjz2KcavL3ztx9NgiQuNm+tEhJiwGPikrcMNzam4zyZRlF0f9dOZFGE+hn 4K/VBtLKOVWV/irhSTb0MsoTbb1Jk0xCDrbTzDLXUrxTzOzfSwAmKAbMfOHNumkk1aTSZZuY v9fKZ+SL15A9Vf/Q0oy5Qo9aXB1sUkoFgSlzrfZlQ6pgFdNBOmnH/UyqRzPbOiJBBWuex66u Tl/fdAnvJT8OH8Ml3n5m03BBWsSvszL7e10RIzE6vhphz7IpxpimHTio0mm2KlkKOiuYpMAm RwmkmsKHxcKp+mwftsw19IkKG/RWYNxUAFzdZDu9s94oQpi0pM1IlN6KtDQdChvBEzqO+pS9 2++xChPLelUBUtU1lArlB2Niz8hrqWEwkeblZdmSjq+TNG63M8iS1yQuJLDCQJ+5rE1VVPHB sjV7n45worqOslqI5iNRu5PEd29XYw/nHzH//U7VqH+HHmhTaIZInwqIIIgdPj6J8szltouY PMLGGWF6TbbeS/WV42OfYpYM8xWKXIjtjybzDTvE1ArLStZVdrbdHGNAEKm167XVkcrRECvU g9hzqYci+/AvemFa9oxQcZZrJL/AiKC29SwNIdb90fvirGz3RoqAt2MjnnoEfU1IVVTR/aBC FEIqE5Gn4mmrHENi43CbCe0w/ndcmh3X14/q9MsCy9lZUbU8WmVnbZjLAtlK7SUWrKZ0E4iv ckCSLybwv0Cy0ffmp2q9T6AYdwCxqcpGsgQhwh2Ww+dP5D+RhZvEinxmSCYMPD2G8G1wF4iv mDRBQCvshELidFX2T607HWXquU6atm2u1e3izc9cBf+P9V+42QWe3q+s9qd4qQDJNZs6KT7Z 0rBUMmxcfUP3omgaKeMtwD7Vofp4gXGxj9ORMIpYGunMRykE5B1u9QewI+8baLR77XinmUfj KvXo+guLC6zcTvlbd51nXze9R8+7Or6A4NgDCk3OEuPbMqc8jetmi/Rxk1ro4ZAqL0bjGcSP q4GrDyzzGynwzmxrMj8iTdQ2Q1T+dlREMGPKt8Jr/+hYJgO2WQuz8hwAs6WOOW/ul4QBZCGx U1p7BqlflhJ9TSN3cDMNoaVj7D3OPz1rf5gyBJASvRo3IExStkxMIpxjzNYN3wyjSHshowq7 nnEtUFLRtd4zXbXsXCGbP0MsoovXtYxOFJOhsTx1e+n/87BvSRZPcZh1PcxNJWX0kjTmQsmJ 0DWXUBUIxzCkjvDA608HdO+525vvIS1x/yorCLEGlyT9SQX6GJWWgfJUrPQCyBAvO5jWgGOT 9GKLL+ltsY/vVfjeo0A/ECt8/J+4BtDmCqJXVNFyFnN1uueqvzIcHmae2psXlWAXTY9YQYs/ TVrapORX8oYewkLrvehd1NIVWwGRK0taD4pLZj3Ers1DBcqBakiw8vMZ/ilvJVlKdhYMe76H b1E9dpnNfa06MIpTxhlsqpC8BPWsd7ZWVHmKQutgUfIAWRu9f9btTruGKKkstfVD8uZ3GWfK H8CIVa2HqYaP2nRK1xeCG8DCikiqVpwq6G/qUrpoJBkdgGcfeKxOYOh18YNEBa60ysbZsnYY vRoMSAfyD1xBKAOjUok9XogoORL3FhPkEUt9X/WFrRONjJl8ijc3xr9WtOwz8uiiFAxO2W2B 8e+OnCgGng/ttE4c5fhIDrt7HImYxFHBsq0++MpJG9u+c7O66PaixhJFStUR/bIcdXNjZk/f D6DTx4xU86qcTlNkQc/xNo7Yvp8Banzp01+th1ONBPocHidoxO7pRClnoUrMnbDKLY1FmM3g AJzzfO5k59HoMwVebhLoB87908CrBCm8fk/DjT32kmeoEI91vMp26qGEkf4iDa7GuNPIjZml VGjwLwoG7kRH7/MAD2jl5vIM0dk7dWfJbT/H8Rh6cfn7vltre9/XTFWUZq7KSnhZXpIowAHf AtLmrU1V5uikb5V/23LEQG0A0cIyC9TO7AMPxuek4VKeGzRJX/SlOaCLrH7+OWTAlvBv1+3W MHsy/sWcEarItY75Dl11wOwbSAr0vZ920mSk4YOUZPjWtfmLP9muhvDNjBGpBis6JXvEWeP+ U8zEZQEL6OKxUAEfLL9T/4UNESk6usWL4eHXeqw0zE8iJf8XbndbKkiFWIZhOiWpom58vu2v L9yBc6hKVtYjY3lpO7iYPBc7Gl04500AIodBafJHiEQNdwxn7ejcB3yQL/VVbUZMzu8267XM 8YFh7HWt6ZMc/tXlcFRO6mH1qljRC/k6H1adlsPVUXt39TVBYk9PBvkLs+IfYCDKBOdaRDg3 g8jYGUZkXmK+/D2lR6eCUp89I8T0by4pk9GjvR3QukIN66U8v4hh2fpbL+Zte5m7ODp+3E4u txOmlcYuhLO4PBHQ60+TSV00xSsgGALJYcxhFV5CKlZ4kYEM9iPTHRXcgwcyYwIImr51OPnI OogmlEs9ZsIOBJeKHLLrBs9JrcScXNLeWLLfl+nqXNbhfoXLPurNYhF//B7EZVFzDMfTjebt 8qoafqnD9+vtQj9sXnFpUBNcIcxY7x80imNjozcwO+nTLsEq9g8ny6wWvwjLleALb43bzrVl zTLy1ggeuhCdvYTZJw8IkXwnbVuSjttqjgmZQ8SOPQrmygFS3a61e96SGxmAFnBjENfODytw HIRR3etCnJ2/iJYJkpXXD8Gx13dgN8bns3srw2hUncUD4pcf9gBvqb8AuTTiBjhMaJeff7Zb C+krACpDudP56fDuJVaCNj3Xggv9+4vht+L66LtDNdEizF30jN2qgA48qY/S2sXe2Hh8i6td 3gm9KlZ3gwJFhp/3N6sB8KMJFPWMU9YWddparrGlEJ7i3a9QDl0+fxmQPCVYRkQEQx+Ezn/8 cw4sElfc4vsXzgdZE0e6iHnYF7uVK8s9HW3xBSMx67rS8OOL/D2FpFPOris386N3J4lqIMPT J1rJ7LXnK1NhTW8y/rOJb5hzKIxUe9nfWHP2n7GKeCB51IbpqyTLU2JjDF7F+eGm6II8ugre bOF41CAMN1bQLeCWFiNrLJ0uUG3DNx6McayYB9ps+EyOrfkHelVNm3podQyFtVgya1/c3hZB QcSDPhbWzxPTrYPVHx2a/nwvTvDfyOFb+iOE6Nz1UjjRThJSV8uacu81t5WQtOEmcNdXeFFS ZbfCSIZV9cNV1IY3x1q/m4IDfwxPzYzpcWEnmXR7M4WbsJakAKsNFoKVWrePeEOzoMGeiC5J mAHua6MXySgyrmk4Hd7jjrlCCdbBbn1wQGbHTDBV8or1jem2CnTYoY26rrKePT4IE2xAgPHr 5AzAKHZ2Db97bTL25NSebBU61YwunOLjTBngUwAJPBAm4ROe34ztEAeasUJhrTQsjQVOCpEu W+/etYkhhDQJKGjxprJNbdocjbnSW9cOXEt0PcTiih/b8s7HANPGrkCFG/jHlg258HRjOaK5 ysvnLnRALw3mbA5tLb2c0fsDdVjIUiabSOOfSUrnDiCYfpvWy3VtMgry4eKogpK+IjtV0Z1x RfDFNwkLW9+IdyJKoL5Evp9sY+hFMyVU+BiLyc7AYilxAxVotofVB7dZu0VVHZYizdIMOiAr mLLaltnOfqYmpkEfuSMjdpi+BBILKbUUVezhWL3bn3HPkJ2aNS+wl1Pn2Pie0+DGE5qk4wSl SdT26bOfAfMbR5wSalmfolocnobcZCRBAUgBtTi0saZGMYGLc1HyIELlJVNJ7BM3xlrBna4b xS703gktpMULKT//jGBeFuBn7B43e02o28VOrD91CAfLHsub2yLoWJ+RTZ/8rc+XXJ0o4RZk W0oLMC4D+zvrgbxR1CdVs5AIqsBug9W6G6S9NBfTvvfyPMWQVBjU9rSIIe1/KwqBa2KSFgmH ylP+R6cmb37zhYGefTYJSWWBqtgbKu7qOCniGETXWdJcHmFuTmPGEIjXI6I4uPCrOXMj0AhY 1/2fqA/42k4wfflqcWgY3NRElvjPPOmA0w6+eX6mUDGm+uZus31MpA+bzGSu3ENHIFZzAz2J T0We8kODfpCAMcu0B1O+xa0RNRdknP6oHcj5/JVQLorYESn+efi6W3TM4DddAzfsox/9+Dtw sddl95WB9czWOEExroxauBonErS5CLha9bJSp7IRxaBwLOQtWIDLrSXiMM//7yuJjT9EfrDD dwEQf9TWghfy4hAg8qNnKhZ6WzpQUrGDASN6Wk1nMuX8wYdCe3QdnuTogiMuM270oJHmSwjm iuIW4PczNuvmzgZBXzXU5OA6qLXYeGatCrNcmnkIz0+aqEUT2hT1ZRg1K84VQLY6RVtrR3D3 xfH1oN2Aeo1QM7l0zT1xnsq2jWjg6biIlku77akx1Kv6dTHa6CKGfzGUzGv8/o3Etx87UY94 M++6+R1+ohSHxkD2mig2npyhQ+0xyUgq9bF5VXsoOPV2nwWqrmdjGqQXhuzFySzuhKHYwxY8 jUx8v39jcXCrihzy0ScQ1MOy/3lJUHvrsFSnpLNjTYH0v4SaASa5ZcPumqcALFF71TDu+mKC biJKTI4ui3Oza05Zm7WOv9+XLK9nUP+p05YxvwtAankaAt4Igi6Y3tgn4cc1hhsW6d6HpHn/ L5zQclvLlt6ueyREby23MfZQfs/zBIA2Eba1vUn48BGGTR6T4Pry2oYhQFUeJqBLGde3awtj en+d42jYKNMfBgscG6COUMFhxNpumZ7o9nc1GiSN7DmW6q99pokC1A4OjGVU5iEOq6MWOhrq ubOhmgdFJrcAkGlDAytqFAhIp/i8cEVgr3xWTWuIxP5shvvnvNy5XHu8OIMSaF8DWnUB6XZ2 8fpuJibW1OxuqL94tC0qV4VP5jEAkZ24a/Cw9clO5z8cdNubeiqNc99FjlasRk5CoJSZPsMW 6jQ9QlMwpdez1kS+ZpYJ+IjjZkoqpD2NmdVpL9sP2LMBglI7oN9wpAko5a/4l/bP0K8+Xh/k sfe+5MG56YkXn/w+e8APmzLwGYvgvQn4mo/AHw4HPCh5Fa1a0uYPjW199F8jK5UxOr1NoD85 6T4FKl+iH88EyVotX0wFI2pW9VK7cmV3G4U+1GQ9a2hgDxjS2HoCN9aOBMTPe6/Tjy+2KUly DFziu0yn49bdbNyFFaksssqTQHaZ77HW7Csp6yaitbcHXLH8NF6DgwJ3LfXgIHik5NMx59Ka fgtNxn2y92Wzgj7Vm/FvyPgh0xG2Zd0TJnTfXT9epbPKCZ3aTEsLjBJatjNHg6oO5QLmbuP7 /z4PDdMKy0QeHnLF1vgDd3+ZaeqUvY0Webtr9wgipCJyE0+k41ro8QZm+YB+24gtkd06uo7Y tInIgJySyCmlzXWDdLssSJkLmtcmbgeTcLsRCfPn/caFJGfFmNcqDrkS+jiJoyzOUYNEzQTq 8JWS6A5QgjKugdb0MZjzIs7QSHotABGGF/2Cq5a6dRo6gzXRJmhUnkh/q4FmcCnzFQXdeT0I BMHQMxDYLgZPXUeRQD0LRdAhCNroYosIrQoeSuXdDsUeIPk/SFOyg3kJcR7o+e/AzTJeiH+N ZiBThJixST+brnfmuf2LHjkoZcWMEI12lxjGuRzuWBsRNLng4bnWaaE6qPsVZwIffyC7ROWm L79pH07GtsB+kB/GV52iTP0ZnNvUt5NwLDbkgZGYj3kCgtNZskOcdS8BKrOdb6te0HCaJOLH 9F6GlNp2VrNRu6OA1kZMzaYT5OuHiIT7LjtALm685k/soYrp9o7V7IM47WsoVnczLLWsA2bY 3f2Ob0QAbGmJmYJDfog8oknakmX8RUzESUtgZCSJFLZkONMo5wAQMPFdmaVl9tc7JoUfaUn6 ft8nAxHVhYkbnj5kAJlRg7NzMy0CJzgjnw/ZQTU6Gk1X0xMSkntWDwyLNqsSVbtrWx1CPASu z3B4yshSw9hPQAse89b/azVxOpJw+o59IhUQJzxmtW6/PR1p7fR3gCJUnzOJdx9W/CQhiIsd BtheeclPOH/KXdoQ64kLbViDc7WXGf1apOSKoCnk8IgNZqHOFalqA3uBcL6vWQYE/9uOcYk6 ZWMvPgfKEd++WMMJifXtQFOKxC/ZgYLplAS6unGtgIaHGtG8WISJF1bm5U9Ii3oYGN+t1I2M jV1iuXZ5qDEVZ9YsT1/vkx+W0U8cP8IPwa4ZUXepeby6QxwAzAT2rF1xvTU1FpcHNXfVaGvZ 7L59mbd+FvmLYJSaT14s+y/S+DfSARX1Yntq8H3nP/RhBudKEhW+mRJhYRF+d6Kc2kol/W3K 1/X551UorWuqdjCgHjdaNF1ld+kHaTtIK1gDtY/opo6iDOL8AesSp2JRPXyhbdPErCZIIBXF hoKAIOb/G0iyED4pG14Nf+pluZvNq7I16lL22JUpsixHhcXsljD/hZjHFU8yoPvP/YLASIPH QCKA01M6sabpjUVdVuMWY7WukAl6anJgndk/bHiRtdf/fNPVUh0FN6A68iSA44g3+vvJjV2k UEIr80+etbmp10DcTDZVun3CPJKfvCddBd8ZlSErWrzdRR74SApKxE2tphaDXkZFHbMonukR TVFbZTilGgczdnJvBaes72PqxFSrYSxIVK3EIWvLbwxBv/a3F0Bv9QchfvdMECbhoLb45ZAG L4pcu7+ig5mKjNh4fJ+g+3M2vksGuxjO9QULYhLfZ9nXEIyRBQiUTaV9S/TjgvmSxesMBZtp ylhuB8oc3jXv2WTebgmHHe7bzJ8oTDCbPsCsainD37paybvc7b2gSoye9dJaAdpwotRpUwkZ gMhvwDCbr+wF3emrZS+ePJIQNdWwH8RiZvePwMs1XBJEfrlLOU0pYaYCjRBro7/dQkF+Sg8m uD7JuM6YJesEMAw0rUE599FI2ny6M8NDAR1j+mW1cuICjSujNurUZAL8bQfUf9OYlz6N2Ti7 FOU3fLp/EAgD2/q+rmBKQdR97pAUHZsRnlOHj/Vc4oVDdzWUTkpIeqr7kbVYfxitYxbaAu3b 5XVMMVELgCwMLC+vHYhJQl+jFGwf0Q3R8CzIgZWZ9+I2mefQBUpdoOqAqXTJxZNhfMyRddZS tK2cFU0MlHa5yuIyk+wcakLKZ1SSSm6U24Qzm+cZfh66Udrzm32szj0hlfUJy3npogamfVvb YhsOLN7Q5FNFa7PwQ85ftyMglk09Lt0mn3RdPcHLte5XXtbbLsV5QfGbjcIKcReOGOKZtcZR yWA+5LnefkgprXGcWayLlzlC+siTGCIjeiTfCKHKrwm5+ux5pSbUX8pve+DIJbf4uQiQMkbE OvHpCbc0EGu4cCLtLFZdTodgvxqO+efnbXYc8xqQUdAlweKlqc92UF+oxNlR3tq3s5udGAs6 27P56uTnoL9PWoj6D2Q9qhFvtFjEasDVMNS+QbsrvgWhYtxMDXVDammqxgELe/CU6PwSD1Df 3T9MMbZTgk1w5bXwNLL8cbmImmOChb6QoqcUyEXtvfISpT4S+m70MZoHyVEHM2zfTtiglhzE 33dwaEQ/1LmF84XlfCdkKbVDVdS2Xl9t0Wqsm8AKdg0UXOGzndhyeGZInCfgbf0joc9LaosV 8z1ViFKuN50DnqoaltwSs2kbbfz2dw6pEnCNCHzmNQAfy81DDj5/JWaJ9eWKGT3ddAAmPUGT Bd7M6mKg8+rqYUfqWnXW1nzlNZ4Gi/tN3TAgiYgcIQzPgVqXFr7vgS/PXzSriyLbxJrY4yKu ZI+gQC+Z7bOXHOrU+j4T3R05oTxc6M7XHTYjTG821Xo7qWBd3NuT0toJ/KsNF54cJ/EVTNxh tqPY6EGzQXNLjKnS4WPrJrtmTqthWIMdQwng+xMex0E0CGrAwbG8tgBaMHOGDCA42zSif+Sl wDEHLbL//pjeRQ4IB6ANWLliMzLndsKh89NLwvftcUMeKtFftyYLYrzR0MuNEzxCljurb7b0 W7BMUpJ8FOd5NZMEntLKh7OdAUqjsHVjyLRVkkJMRJYkG136crPqQ4DEAYzV13R072YZyG/b 7MfmLlYb7r5sSGJUTLYO8eGyiWBDuVBs2v3cYfrQ5whVorpMa/turmulFa/b4GJDQtUsCaO7 OFtNrwPsHok1HQSZXQ/vkraGps92XZMiHbTPMhCtsk36W422jVZoSAXKA8XfjU5uoY24G4M1 Oc7fKWXJW7SJwI8c/wZGe+X0JybOWzp13oEHeBMcYSHDxghE1CxdWrpWZS8H1itjUYZ0idf0 pFwt1FPDw1AFF+PbjqiXYnAXOybtS9fwgBgibD0rPB93NjP7AyHX31xMtR7rFYMho6NrmB+W hUQ82aiy2tWsTdTSc8MoyEYur1uf1PaKIQm4eY4Wcuq62KfJyoJ3PFSTorCkyJ3MMJ8SazKy qlIFNJ/G+tS+BDPRmocwED2aGZ6OXGVREVxutHZXJo4RjtCyIZoK3CSKrwkYrsMqW/jPzLts Rcy8Zfmi2sqPb/CQ6bUD/IkN9QWjz9kUSF5UWzMrT/3IoZ1oc/hSWSOpQRgJQq+WINhvllgO xIctpi2zwzaecOqF0PeIxBfVur0KknE75Tv5CxXNEhZeRwM5G23YNUx1xLkD56VXwhDs73ER ZbLlVEUxiG/R6ee330y30SeoQ8aqBcImEEpK4iOCnPZaUGi0SaB2SgeXs/U7WmBDv+19eIAK 9bMMTNYd4uikda27+UOXgpUUi8CoIM3Bt+VKRlK3swT20VQ4mJyMF+VulQtzM0mkR7gjT0LM pR1fRYyBHYOFCfUQ5/8GKBKowRaNzp2cinBXb7KeQHdjhlKkEkxHmTwA0U6L4XyKvNm5iVKh lRAwl52rq/tKsGc672MTDbdBrEkTYVH0VktggbnoJISu0s0SpwChCWtD5p4hy3KSA2+HmCrU GuD3tPx+ZJjeeUYX+1yKcLkxRKVwmjMQ/9USls6CbC3aQMVjrYJUk/8jzvjbcs/uwMCgX5w3 D2I9Zev4RCTA5LsTSaCKApgrPwp8OVC0t0MHOHSGkS7JVAwuyFESXg4PUeaVKlXO7oo46MaI GFhWCEsN7V9qZ8OgCaY7bfRzqDJv7mA6zdjNvHi76rnKOn1+1GLN3R4beRsy2llk7fq2IkK2 vuDMmSc6SYxJ4j/8tuRqAguvpYVsZC7yjXZxhvnYqEuVXvv4rdLc40sX8rvgRKYH9I1UrDVP 2YlOhpePrXgUatGec0PhYHLkpSfDp+Sed/eRaQ0DlyiYIi/pVA+m58UN0VDTEbdl/HoPjcKc 97Uqrdrjy5owXVwU62tHLTaWQoyHKPEOG8PYlOFUySJJn9zWgWpy8Y1T5Hc7oHOx7ea7QO8C cNq3zUbzuVGpFNDaEC+velQJ1gJ2oYmiS5AoNBWxb0Xi8dBORiSySywxREYxiKLu5YUqUo+1 ixJchT496VuYLarsFtZT4g8MMLzcr2ayxobO2PqAV8wLWUnvRI+otsg3KSOjg7Q9HqN48g2t iffg5U1OWcslMYf+dkX21Q1RrE9JI12niMrmzfwRM4wc0ieXZVgaFi8Is2VfSonBH+HHBfQq WVEKhG0i1bY0H8UyW2my9BHgpNX/y+m9VRkZIVdZKM/uAJwzt5U/WJGx8G3W7B8OW/d8ariA jiDT4a8hTkFRcv3Ak2Nr99FQzugwVAT0wQfCAWqsoFxX6FUY4W/PpjgFsgGJ32wkqf2WU65V NCN7pU6Fz8bkrcOdbWTuZSDyqdLoLHDjVcX9LFxXfhionPtO3+/HfT9UlhEV8iulQvv+rXSd aAZy9xFq3LrrM6pcOFvX/IRNCagGNsikEEq6lKiWnau7PHezfeN9mFtEHbMmhAIMALGhsgY7 konEZ3N2pps4U7lsK1ZfWdhJ023jdbyFCZOYHOLV/cSNMfFfV7gK9Hqv0i+ysA6cZfDGziUh jCnINcgG8nm99M0ShP8cppHYZw9KZDHALG9amZ0gOq7ea0jaJ+KZvYC18aWCTDGhqanhP8eh 7mfB3IFeBsm/sFrK0u5h0Bn/EmbOkC2I+TqvoO62GR1ZZeJjsSq+MbN+03r35EMrVnBxBSYs mLkE55HLAwErd8mim9dUftCsKdEdOv5rGwbhfMdlHTBzZGibKKOndxxsrTHeohcsferO3tWG J68M96XGZlzlVsqB8s2lFitIZpI0KRnIwrAAyACMy0WwnyZQOUngXVSvJx3/Tg2ifOgC2xDn 8qjw8iGqTV+lduH0brBSFWpNaN9pLSv3g3AEuM12MsM/7l/156VTXjR5QMy/yNLwEXWB+L+K v+izm9jG/4iyM4HNRbxt68SZW7r1bjg74uq08bACDwZ33EW2whg3Krt/OK8PBj15ml9919RF xVNEBsq87NVZqjNKofmVTaCeLujW9nUU31mzT63WAWgT7qidDT9ndTiJcjrmxW5Y7MYu9WLp gMapD5UVaqL5RguI++m6n6Iar4G0Q6EZwEcRU885bkEnyJdFMOLKJwuWQKOnYN/5uzD+ad5P b46fugxQVbIHidc5QAj/xlKriS4XIpC09mQEi5eiJOeil0ptOibcDQ3QE/J45jvmPeg/0YHH zhKuxW8M97iWthbhFxPn6379egIkVS+8Hj/O/MxRt/mSwxBzoqelqyGI88Z8eWe8Ud31ywOT EiedNloYuzUDUJBFs1KtRObcXie2ccLgmzd/4qhxN6+ay8QmUlQPbejkGc7i34rhM5Tl5aHm oX434mnCeqTFyri4M0Ol/02CWPaeMp806qWg8SPZrxiDzZ9JCFza1fuz5MrmemVnzd+CqUIa qB452+2B75KSSHNZmp7Wjj1Bx30r6834RUZWsSHNzrxETmRRKlThVVKsaqsnPINMIMr2/mXW UZa/uktgD+DdiQhBVDnl51S4LXuYG52KA4n4A+RA6x+k2PLe1X6mB6yvWMxqOUxMp0LTOeei xrk7Y35kvq82JRX6IikeQNC/c39C9zekirucweHfLDqtKvtiLL/iwbwg78fdgbkyNqoCuT5w Qhz5N+kCt+OL4kboVMBGCmxZfV5XYA2vkAsDNkLSn/+FZxYQ2HGf4gC/cgEB88uU7yyrDwoD b8bWzYmHtKrswMiF26heB+SAAvEfYDVtufPd80scdWTReI/NLpCSLdWZUIxikOoPZHjDP6vh TsACDEFI+EdIBRcARrc9BZBdHCfLoSp3i3pIccd5QZFYA9fMH7wWPugIY/asSMWFSYf6muvR eHF1hH6HcdF2cVQH82xH4slSk2IkaJvETRyL/j3Yvk00ln/rvQBTUR6GG85Phdsc8qevC2JJ 99JmpVqkL7Ii6pp6RQr7T1IU5ASxHV/l/nykrH8EbIZJ66vzKUAxKvVwqQgZ4a2nIh1qdYws 3KUy7Nd1cHT97EFWEmK7rCuc2M8pDwNZ88dKuNSGjPyJ7tqrlkwsCcsfTdpjf70e1UuL53gc 5OEC56y6AOB09pT3IkVogMn2tD1UN+UUcKbI4NqtJsLm48FaBl+cHbnLVPUxaRKona8JTCrc d9Vl6WS2Juid42B9A8Pb2PV8nDcs1TTJK56ZaWo6T1wykG2DIjqGL8k8rxzkew6BVcA/XTcS 6dhNuV43uGNc04ZBaLXOe0Hh1Xy4x90P+QxsY24rFDZCDqN/YFMnkSldn2klugQk+h0wE60v Hp7L7Hz2QTZ7Qe/yHCNMowA0EQ+gLJ+eyq66/Ou/rQ0iLynhexkhM4s1cJB+NaruQlVtyz5Q Krt6tnGUM22BhHScbqzrnUSBtA9PpWK95pbeMdCY8wOZmVg84BVfrOFN/WMpS0R9o2vGqGIO p1Hamwgmg7iYV5Sjdu9ffcoICXng+O6bhEbkuyBEtAydWauGCfaBVSeheB5rFz0/L+SFn12o QKOuQVIyU+5Vgd2udiuI7qsx0EAYx39ciFXPIiXFiXcYcGsNpmyh8y05vrJr/FjP88sATLAr A360PQKNiTpd4Trd8zyrRgawPelAkYEi7n5aTpYuI1ilf0Hv4VQ4AXBJArGHez21c5o3xdVE J6hiywdcD8jDcunADU6YCSrIgOLPtYyDTDCqYE87Aqf10x0Cmp5WxMQ/lB+Kr7CNcVlVH/Fw NPzOJWfYUV/zbqN2rsVxPo4IpahDt8O1CnV5Y4gN2SEVFWZoJuMsD2QnSNvgbxF+3dhsIQ8p +SV2yYZTTpCkWWapWh/CQMXpTjGOytVFcvtrV8/Q2DarFm06xaAYsrQkN5zo3MOKuGey7oeo m38U676ACmTafg8peiclMnmxNWLaKyKkxkCr1g3hLrK1HEi2dojZ80wATSTpvjHxZMY/ZsZL XdE4kRCUMBjr3oPIQXFnJy/WFGt3+6PxTW4WQqL9Vv/oNOfzlcRFGZCCIJiLWTnP1a/6I+Mu 69RMbAsMUl10RRr4aQR5atuDMQsr7G9DcK57RDnmcQ3Me20P9hbwfHoQ11odIVofiDHxcvxN kdC2UB/vVInDaKCoP90j9RhpQbybm/IW5x64SY860KRvSgYGZCiqu4nrwB1ukc8c9NrYKeby 3f0UYhdmVqNlLvnzAElSAl4cegu8zrfa9Nc09PXsT1JlzK34zrHaNqG24SlbeWaJy13d+crF z52jqczSK9ozefIXeh4aO8q4hDyT7s+RWQoh+pJMOam/Gvi++aWebZ713ZMb2Ca7j3/034Yu hXJiOQHNIud1O7bFMWFLEFYLiZd0NLiI03Zpf0eyQWSEc8sfgd4Vc/CtizH9UyeAS0Z8UaUo 9FIDjdBfD5DCkM4ImPTzN+ILwrmMW0CrmJFJ0Ar7/iC2A+IJz3Aqat8i9fXA0teXOrvsqnD3 ukWG680TItODQdM8p094SXYouN/ms7ber8xg/zKQGcrc0KyVfSxffZ4DNDqICG1xZY9nJlnP VYgHho2osbEPNzjNIpzxQyTKfJMPR2HZ14KwjT7aHPEnUDz31X97spOi8fSbyB6itpc7v5Xu KTtdekTi/Q2VItiNiBIZ5uRVSikvA966T384l1z3SsFyCl0ZGSAILxSpdGaVLGw5NfTOMF/C B8fNzE4trcgZKt/q76qMYP5cn574pkkOSNwXeLJq/8Hb1awhcSdEleHC5JgrPoCViKtAbMxp vN0ooryh2t5pwhkt8lp2RMFalo0kiGqulV2mO3Rk+pJkF6nzOKD3/wbf/InHjBP3y1T9kl+Q AerDWAa1E8lH6MP+keGOYovbUizq0lsftQG7gobiQpyez7+wyrkPnDVzZBLKYx0w3VoPRhvz k9PgC0rG7bsH9s69smuo8EQ+Ur1eexLELUmTXr+j85aZxYxRqw4w53H/n1gBzjhWCVd8en7w /uG2LLOYf3mS2RT5vyHxirzX1ieoLilMLEScYhzAATulqX7u64tDKgIq859rUU8hljBFtPxc fvcjhJtxQ8K++oxVejltjhrWZpdkt9PM2NAglxBgT7S1rmkQp/vZzZmNv1ECQfNXWjYILTRq yzChF0p7goeeQ5jycrnqqJ4nM94sy1z3Rvc2KcOVsMDMYqBgiJfl3uFpc8eSrRXxI4N+YOCO NIbOs6XM/abtA4U4EmNT4WjUHFtf9r6581oEOMZOhHDtMTQA0S/0OC8iva+VfLmVVelxHGJk uJ6/u6AyGSaERJn+/uXWhggkMR7CAFPLuVCoNaiqzJCEodlULXQh4Pxz3vspFyHUYKzS9s/n w16n6Ksidv336B3BRjGVRbx5hD7SaGWZc++EgWJhxox1IRBVJ+20ptzAbNsyuInosSQZE1iG pmSBoGvUD+ekUqwCyTO0TKTHV0623h06EC2lZvK1Ib5ztB7woJITjXLhVPN6WQ+3BEO5921+ Os5ZDqGWLAC7aTHBLp0Fwb3t8mXB3gvpt6maj4kNyT9QpXfLWmdNmfkivnZ4AML7Y9LhLrIY s24lsNhMUn+doAVFVo8nD1w7Ry93Ita+SpkW6Okl8pdZ3A61M40PHq+24f47hLepcfRGASaX +ZVc/l5UGmoAp//ZXas8Nu9Ps3zl4XbBDQ0H74lSAmtVmUBFre05Fkj26yKQ+cMm+nRSpEyl uMndCvKItbfAIhuNxENBUinFHPEngmpZDfKvA8cXUn5f2hr2TwfkfyFDzORsmk4BeeMgT4J9 1hGQDNiMCQa7R1gXK8ELu0UEtqCh9whRN3gVt71I7cK09hOe1EhwZ+7Cy0HzX7YdxxtJuoXT 1NmVFdowMbKqE98eiVHthhLRJbCNRwR59VqdrFRZ1ofjzXH7aFK+Fr4xaTQvZNlSLCkv9Lbk HsphjvIVzJFWFXsd7x/tbovvdifYKqGjWvbyVYchk+ovOEvqGumtLBGeIdj8T2l0jGEQWwbu bXVStuP/8xLBRasp/YAXgWJAb+daicMK2lzABmG/dIotsLkGvSfQZoEVNBMhg3UXu0ay871b fyxCWJeaJOx26nGAm8fbzuu4+gOtmmqIC9u9j1+5GrwBq3XWmCxdvPparC+F+A+xCTZbE0Hd dHbdEGs2cCRmmJ2uvi4FOs3jgzNFA93RPGfvUFFYvy5BT5MAUFOm7CN8U2DpYEQSK2ZXfEba baQvYnMsnMERnqhvhqfrf5W/+cUh1QGK1YMitqbIojIOPQcAda4SirF12QRKg2rMxIw6RVxA 5WtqQLDDugky7NxgGpOlwzYibldHROEeCRLxqP1wx/qoe8LM950h1a3YTTSi+Uzu1rP5KbQZ pd3fSNR6JbsgNOwFFmw6+hgmcg9jgAncYtLNz4R7BDgA+m9QAHOvIhFAUJ8sLG5pXZ1YH/ff Hum0khhhEYobi7O67HLbmEsTRva0B6GwskeImO4doymw6P1+KtHlTENbAfJOkOTmo38wf+0f 41nVYw7yKjK3G+WzDqzXgX7fUZwDGBxUMZWbmxV/Yrji9ICqAVOio5NoVDz73NRgXUXvhnZx k/HqCRo6ZOtE4fmfc7/SJCFrPKsvNHp2f+VdV4HM92Irokt9MYVOKPLv5oVsYJIRw/d0toMm I39VrfozMlhvbV344KfWHTLnOqApgOe3C7dB/lMrE/RIV8zrL7XTRYPj+Cg2+bPW4Df3yThQ 1Rucqe3nw3CXPsuTaTPmeVoyFEWXxfZfl+MP4CQWfuZGWt2YQ5QjYjoz91GrTx9UzDUr+BQg lDcYbq8GSX8LT5GpzcVDu6ImOTg9RMJKk43eBkEfU8Es3a459AQjWJs1iz75WMWpa3T7P/r2 am9m5v3nn4gAjcbR83ryjaLmK8U4kOt2xz+CTSrcnOCZ0sqgsljDjCw59UeXiG/Xd7hFXKW9 SZEVt7WmjnKSA1/yMm8V29NXHgAVvlbW/7UdL/5YJuTRKHoLomg5VZ7VquoIIvkb+se7enYC LCCwZgHgnWO6ORoN2eYUMF3raupSi7EQgYRjZzUbzGd0LIObWXf1gDVmgjJs5N+3i4BPGduV 8RTdDMXqeh4R2RCv464t2KXul1jmNm3Wd7Yv3fC10/xzN5RrdTyaiCMaCY3UqSCXbqXm3nZv fWJ5Tn6IllKjPTIyoHcXLrjSIZMet6eHY08muf3bfd9HX8AtCvQn/itBIJ5JX9PSrqVxjo+k LNoF+cYyd5p9U85F3Qf1ofI9IJ0GSpxJQo/6ty2nhD2WtOY7iJ/tjPJctzHJ/GJp8yos0U7T HYqYBQBFuQjmsDCW1VDnnRcAl5zpRoI6wwkTVYuHv6dp0+aaT4n8kPLoDEHiHRS0gOZKOHwQ MbAKEmX5pFWcSp9dYIQDiFdvFWstH9FUw1YwHhhFaYA/oQcA8hMP8g0EQtDq/x0tcTSR8bMJ 2xNR1OqBkBKjc8r2vXSZX2OjbVkNpMzkGnxpYM48gG7D2onxlzHkjhx2s3o3PNEfbfX+ESSX maQxU2N83S+0QfJ3pmh0FPp/MdwHxVFM3eJjS83crhuJeye0SQKM6dlH6BeiMioJxUJmOo4v /lq7ct/0DcPudN260gmPnmET+gzbB2XmZnwPr4/wbh6vXdDyVJoPj/qf+nvcgrndKBgOOWTH 1KRHhKtiyM9fh7HqXg6R+AOLQzDhLnrlINCxcQ5gXTsIUPtfW3FMCdhkBzeTzM9DlL1+mmRr MdYq9rO2lCrrPymmyyKtGi4faDlrvHrTT5oxS45p1WDlHyqTfgQEtmit0+Gyw+NP/21bv9yj VaCMIwoA5Eg7/04OD5uiOnYwPPZjaq0tx1MUPAAUGK2KVcyWTj9vmkiaDu39En4izurqO077 4dHBVVTfDoPF+cDAkNVXKCarBi6k/TvtAiB7jlsJB6W6zriWR/fKcdhdBqkhbEEJ5zt9ilpD gW3bMuKYl128491Wkl41eY3Sw7jLz5YLwhhUgFUEJMI7WWTtFd/SjBYRWi6kjNwgXZxVcaS+ fY/oJXIUvarZuFSbwTTiSeTE2Ziu2Q5YeIbw3tm6ePUxzI8VeVDBJIOBVB3TpdbYWyk1SPGY 11K5lhYQ/EGUnBqnnaq3fzx/99f8vcmla5BmDbJ3N3QP5NM978pruS6Wzt/pIVN2NrfCviQ5 iCC+Bm7FfD+lKoSRzvBbMwmeSsrWSRm5YGATz1qykuUT9h1FvjHq3+SY9nfcC9ihwKlSl3W0 GDvsDlKixl8Pzcm/T6m6WRqSzSCjUnfXnsuRldIcPWSdyorZhc5EV1941jOnVPhG93403Aby kwSq0tYFkXmxaVJMjIKiEAUsoeWwXGM/ml8mimA/kLCkT/AvAOZ/4NNl2rksiFfFPc9KjC97 2XJwO8QXudUDtuRS4/YTqAYGADpPMB6ofqaCgaF3DHBEKC2V2Y5NSxBcQES1OUonMADHujXb duYyOX16eUvKy4k1hYbLrAmGVuk77i9WsNrKTgBrVjx7DKN6X0j/04JtpqlS6CT6i+Gu8PS5 72AeMyYMXCTECVBJDtbx9+AylkwqVzwT2nUrcosxOUg7OgpZyTTZJW6ZDJrwGSowBuJG9tlU OnCaV4+6VJbCnAy+4UVGNkB6bPrE8r+yhNk26PEaIVIG0nCSuLVpO4TOB9FP+EeODITsOY1z miXLOGUwblqSKeHwFlIJfGdVGp18gpBKUqQDOdDgcBRz2hpLezubYNn+C1h8UmIWijnwvWan wrrsqKGKjvH69PrEYdXQGII+HQoee505cgjdmR8mqKv+QHt1CE5BWmNzKruCRScGA/GhyX6B LdMyrtTTj1XONYqLCWNXon8JLx5EBiCX2nwD6CfmoesP4w177vDtMylyGYr8bnADvazL9xg3 3+gnQ2QuYsoiYDuvzQiKSQoE1nYERpGDHiOueZBavhhhdTUCfNUafff2eG49rzbIzos4/U7d yCte9X4aOFx4vgymLMMB0+n9+vZNgyXThWrfEvNSnta0ezvsm+JJhumJepJukoZG4tPRtCcu gKzJ3XQlvMmx8n+lzJCb/dCVFlcE8LwygfigBMDh9LZPQR1FW1WWb1UVH1NY2jvtwpHz+fUX 3qUHIknnQ0im+USQeE/3whjCsuuLZSBrRp4Zy78db2phfA/2by3Ti2m6kxrg5gWRaPhsfERD /GASLctYNtjxbHQJs2X98vYafQL1B/e2Z+yh6qABjPLrJ/znW7tIJ+1gtYIvJZyxU/ZzLebd hDp6nvymfjJUJnP/Qc0FA0CimfeJeeSRU1bAAAG/RjTqEQrV8WCpmvIEwRuphPLgCjOg726L vYkLtvCo0xTptBJ+u4L9+NqLhQBt4/+FEz2BvQVWXh+XqiILG/QknJ5YX8vjHCkvQ2kW4O6P Qbe0ox8vmRWBEbdeObIpfhFkHiBaPMsIC85FGI2AOkyXE7IkLt2Q6xjdrfssOzAJY8bc4gy6 uNlzBiFwqypGN1amGiWt53NlTNOAJyGnPE6DUYd7bwHed3bumZRfOd+mlO+9o3iL/S5Bdw7Z 3U7OPJR19FMrD3f9a4V1M40+wW2e0JInX+XMWdLZihxXYmmAJBNgaWdNiOa9kMz9EsEkawlW pIa3smQaAVzNigT1MedFOyLUDsXk8rFw4VhTg4Pu9JQwQ0/RxrJst8fxszviTZIb8s8JcAa/ 3OTW3UmSxjrojSTd+vyBuf9DlE7+7F+y0GUHH75i2hKv1ahzye6eBCDSJw0fJ5TnQTnMzyrn ZOyt/FbJh7e03ss92osdFvbMqYz7bjMK9y4Q+Hz/lJEOX4n6oc2GNK1SgLXuSO0+kd8IVAsN N5+nNdhzUr4zIOPTnDrpvNHdaDTCw74esR6GsJothPP/gUzji5e8aLz9iDOEmHg/XnvhHQPo xtiUaAFMux7nR0QBo74ssAa/2YvvzmiZzvhqvG55j6Q4qCl34GzfHs2lp71IZiLfFn7GP0lW wu2EKfDhALhly497Yu64mf7oQgEuAXJ5Qh/5jLeDdyGX9hwGB/i1yF6hvGxul+vwT5d+TQoq 8K+CFI7U4QCEfMH9VC3QHFl9aWs8YmB6kyzzfch/p+txwb4EUo6v2Sl6OZOIDWuHuf/9TT3z PZ0mYIRMHmxAreWoFfZdBsgR1AVr2KiGsQoj0dQKZG5hqxlL8yc5wZzJhZRQaEl05gtYqi4K +MfE51W0JQx3cM+8gXP4sKyyhzwGEOC6NSqgHiPc6J5/me5eJSajPD03gmoSaUE/UU/d+pDt oW7/gpjb6bHHeVc5egX3TJr/+1PtbPo0p9GMFoVDycFkXW7Hdfn7JM1PkNU0t40qy3YKr6dl oUSb+J7SYYS1Io97d2VNm/r6KPX6OZAX8U0R2gqhpYhr9Wqvl2Fl/fdKQv5OErhhxpHHobQP r3cNGQDTqaImh3arFgd9BpsWiRKxc4lC6/nS1CX/vweycg3WBV1oYUQrLOLGjZAE8zXNnXPy 5hkILpUQouTttnjHZFn9QcgYd9KkU6zChPJy8L1S9bwRMMMcK7ewoCK7Sy6RmMFb6PWVZij8 qgILPoI8hWN+iFNR8Ryu1xUXlQ8jY2axGxXRLk6UqzPgYfuc01mVOde+eSI69pXRrwsgCMKF D0gX22I1zGgom3+uSplTDfRJjmcm7G43qyVrpfLDBc+MzvzgPmEhaWShdFet+zxJXPqJ8BVl 0au5YewDZ6gx/w2SIEALyjrjKePvDPAPnDh/iPGyflBcO7FLZSo7n+Ua7U/sHOLB3IFMcpbO i3oXEe/5L4MXZ+0fLawGhbyJ5xo1YHhurfdhwt1GZf1A987facLD1erIeNl/+FV4w0OnfGJA 0uVoy/1AvTC0O4/Pllrx45AdXUHoIOAcFBJt6zbgnefFsSqKbbLBAWuUVKvxOiYqfxnrJpLK /z0se2rTCDPzwl1KyoIqoYeAurBANEuLDVWOGsbF14+tTtKxIWcarExAs5/bn14x3f5eRPZD M6UacCtTJGXcpEdbIdSMaEd6z2GquBnMqKbpFCxPSkcxLekvD020yzhaJ5txst7B4Lj3kB8O YPotbCAFGlJgrNTv81qmRH/8Gn6U/YGoMQWv2DRiEH35sTB/ARRwbZq5gV3msOSErsDUTKpH JFa6iD3f2CFx8We8VqGm2cLq3p6OyYe47hnjNRofEbMKe6AwKFwhil56mvqdPPi3TAh8H+xy nox3ljI2I7nAzw7aXSG8HHiPgrmelE1yF6n/vYtWa5qPcgmb0skqNBuLTeq/GI1mZi+rCKIp xTXwltKRG9V1yLGgWVrvaPObVmWBLZsCPZ7BSiLDIhxxoOFNBUwA0VC1xHZnIGCWw5Hr2QcQ hE8q8F1LXqNadYY978seaBPLSDdKdF2ZxNoxalQUGgdjjxYK0SpgieOFqrKG1QQ3nRuzc5sT VmBTmPaFMn8rBLdWcvaSnVWWlTFUXgQO30smrr63x2PM+9mpv68whBPjX0uCe+ul0NONlzxZ R7moPXtsPVzwOQqklPb+FLCjCQ+Y1TD81ojgaFOhZiLF8ABXNQumWey6EfnSWMs429c2akU2 U0s43+5XkJfMk3dVd7ZzDtD1cTaJlNMuZ3QYsdJUDUrZpRIhQnHZ5xNteYxxhKberv07q8+7 VHBojb1CthkVjaHPKJg0kC75sGXmY0XdmMMDXuHbZHEDYckJT7T9/hfFHLdB9pKEmBYp2A5o kCPvgeeQU/7q13GwF2CQEf9JD0NS76JDxYEgT7W+Et9OHXUC61plkRwydHSR6laWcNCpUCpG E5VYco6cSg4FuBN34O5zkj4+izbp/oEErm3gmDhAXI/81nAC7NzFBBu8WweSYpS/vk+wpWgx VtElFAV+8UiaYZJ5dnP7reE9/kXcXVL7axjfin1M5DX0D4P8iEnzAVaJeSYqFbW7azSQS1KP hyQGqc/75yFBd74xHcA3LlpoJuZk9ZQpGYSVBSbE9ccHOB24FxXXv6K9EoU+YZBl10vDS1Ta /Qoiqi78yhD77C1lBMp9frOCzQ860ixLLIeOvbPUoau+Nw602zZq9PWpIJ76oyVcu9PhcEYV TAnv0/Ir/3u7PBVPud6C4IBS6H212L+ald/t44qz0z8fjJF5LzV/6QrVAyj1WMAm+/pQap8Q uVMjG+thWl4EteS5VoEslF8mFrT5O2HRp9+Y9LXBY0uwz73U2zSMoQ44xbUTCjTKq4G7h5mf 0KI1smo/ZO9xZrMGgMG7HbE1k+qjfUTC/Hfwlj9hcQPpUCyO8jcPpmRjAPlqgWbY4+sq5/gc U4qVbgDBlBa9y0xzFVW/Nh/mJkn2fX8kta3cyZ9lk312aCY8jW+yFZVv2vNmyX1nwwO+ay/g 7SwakelkrVQ2/HH0tPbJtjgUrJUrX5f7Wm8RAJKECUpzJeEWCqxfcUtY1gFPfVpHFBUM4NGe zzKevOpRQjgjDjkuSZ9vn8TiYLJGFa+QCBMSGPsNzWPcjoIVAWM7gQ0SKKF7CRzaHH48sG2H 3Yvs5EuFgPEsloSw5mBYKS+hmvQ+hIJzXXuVs1SRYiDomdCPbCMbeaMbL/vabbWAN1pjUk+Q MHxam01jMeSN3pH/VeiRfVX67dE42F55Deaecs1x0XzQYrIj8peT++J2pZ/tNMAef35cHsoo 7czVNMTuW91VkbPVT5fitOW5AcJqWKqS3YZHB0W1glngKcnDWD2E20YjuZGVJdQMiHz5YW1Q 35B+7k0tDoQMb1GIyS7kCO9iI4ZprEqa7ien3jOrayApPcu3Ps/RZPaS/tj7zDY2wMjsbxc+ 3ZWAc4vjn+BXUmV+V55oMIzEHgjLe/ks1GsyZYlc8WWis/lhi4Ob/DEWbsbm4UdcioFGHhf8 Gjl1aKEIlkBija6WwWvWGKWfs8gFdTQijCzwjgJGSFNvHJSV8pPry7n5Lc9BKJ2t+1Qa2Mig 9qAC55eD59gIXBGGVutSr2HVXHggL2xLJC+72ctj3LknsbAMfAlMPuuf9+t94PaM7ih8o+Ov QTGujNcdp6X1QQ2xGGxCgVUYBVUwjXidYleGzBQaZcm14M+E8u5OgNrS/lSsYnyz6VDlTxEi +dD4hgt5ThBFyx9FHGpeWqvXgqcMrZkWkOpiOPqnzzKIwTsyLf3AC/HHvkCLDsVSDvKjAyp3 U6Agn4nbJ5A7t9HY3NTFGCJv5+E3N0Q1ym01Vr2zCmb71pxXi8PuwvwkIkWUFomyMgzVBBaZ dzxeDzeKA4hbGvAIedOfWnm4ys5m7/CVI4H+Ru8ABppi4Wc1JJ9qaJSRJvzsqKUfGRPKP52g KPIIomW5UJZSb7+42vRBms1pfgUTHGEtEgIQPr9S/X0T6CUCdkB+VojeveKEWytvauruddyf crZ2Lt9NJQAJhmTJG4YgkIEbyKNNiD5qpiy3KdYGaVWLxUIq0GRvpS1/za+tMlnn7iCR0Z5E uo0HDk4vmDgfTi1i85x0mA/WiWtHZp/H/E77xuTVo4fqcCSRHe0GC44w9VrurjsSjZniUiaB Lf906E3yFb3P4lJIccapEwr4ETK9zfbHaxfjqnW/EBPT7KPNEVwhkJWX0m1Wq9HdXxSkZiRl 6cas25Bgwdz46kCw4IdtOgOHyZwvhhKwWIXpxHIda87oWgtOz1YrTb7b1A1ActQ3cWoX+AFD 8X08MRNI0wkZ7BKIy3HlflTAsaW+RRuNDhyAw+9piKZRNWKy0z0BPFIemnFBOozFAfjiKrBo ODpc6sjWsbS3mkMrOrZjgupwmzEXR3L+0anLqKb/xISSpLy3/YWl8BAHcx8waGnQiIKRhIYi LSZwlBvjFpLCtl/Cil3sXJ9/qkt/OsCtYg4J2+aJqE6YnaBTMi1GFmgEzP/lJMJBNqoNryww bU99AbskOIHRhV0Ph2/6WMePrr/+SHQBDNjzd6l5opZX7TgP0GGzL/SvyV21rtWaaaPOf1ee r0cSFxpfrVxAS/VsZGLRnELY5s74lOGTyUeDNeagwuj2CGa29MdGJ2MonY43Ak86kTPqnhgb vU8NRhQH/mvmfEHISfOmFULDR1jYPX0iwc9IBZlFu6PbjnTQ0KwKMOySTohEjHIi6xCoyIsE JiWF5642mwYHX60p49sWlBiGNiiyMjgUY1ZEg2ehnrpObJlD50OS04HnR4xnxEEVuG3yVG1Y vLtjzAhtxZjKKKPEaIkT6aE7wlfWaN8bpOuejng20x7SxpsN4D4roagHctxn9+QZQ/xOrEEr TtPWt8xtnQLzILZteDTv12271MRdItFpwiivJB9nHc5d7cAw/XZUh9JpMIUFzG5PT6oREDoE a5236jXFrQhl/0VgcNTWbWEguCJfU3jyesNTfvDkSppuZAKvWfPwyzKFh3X614l3qhx1dT9T fj/BQ+05fjryTKEGnHDdHFRGke9/0P/xXSzueuD2oS8mvw5hapTPbJBZoVQrhkHjFs19e+y6 7++b9pDpXigoPymSvZdO+vwjvQeBKX4HRxJ8o93/0NANLiZdX5SpMaxVWaoaHm1HBE0xFvzV PaKM4ityORBp2kjblWPbRRFAG47hMGxlpnUrQ+6vMF+oQfzxZe1HGddFCzObRFmzw2JTlJEZ dReDCekkkmgnQpiLdhxZtV99GxyHYXjAsjNin8zzKB5uMpuZ7glOQ7SoxYEUZq+Nx78kkdmr WXJzZ4XqIHjLDPeXcj8HOut7Kb6XPqeYU3evmtwwmt8y6sxg4HvQyIu1JlnskqdO6Kyiq7RI 21C03734RUTbI81AwIhjrfGR6JbcpSl7Kn4DRq6c21NZxEfjA1wrWIybpqxNvd0lCU10Raid NXa4S71GVEesySi7KVDbb2996j15JW5cHIDWzF2eYQGmzbssRZUQRkVrMculDG/o08JLCHn2 9Voij06UKQAHed6aWzoTG/7xbv4v7V351jIksYtxhzxCKkzbT6ooqHWXAMcCqh1gvs+4z0YC us7aKsd58EexVlCSWkATlI4ZiKdzHI+aLdZ3iwy8NdPkkS0h1voeYqP6bsU4qNqRZ/bbbqlj mYzJN0mv2rMa/MqDbET1FPRzQHEU+PQ3gmNRM9XEq+6oRmb/FDoBuCNAi5z/zB6X+brxJVU0 hhirlB1OmhLjKmKr+Ya9bHs3rpbu+VYZvSQErJHF2iohkj/QnlQ/n+xPOt4W+Xzzes2jZbcj 01I87GwTjViT6jwfEWqoQQZwwaOFsArfH+BN+KQt5Zyz2Rt4fHwF/G/YP2VQeO/oUUuz0J2D g2JZ5We8lERCPleX7jWUlbks//ezUkkDwU0SWzIZhGyhlZUV/1iAHLe+nPu0J7vyyIAZrBIF qpveQaGnJBDf+SEeNO+U1qMINq5cQm8uC2reoW1wTOM1/DuJYYufBmYFNp4sYxlDoYsYJBeH CrHRtZV58rvGqeT2Ke2/mtleaOI0ID82ggUJwoFFYqhS3v+fp+aLSzR4PRJadIjgmVIzJh1y 4kGwgf5dNjJ1fJW4NI8neDD7bIFrBz5AixsXQFAcmOGDyseLW6URprt0n4PY1OjouzmsG8dB gcnFoAAnppVLJVMnOKzbGadmFxQoiJmy4wRIFCfJIVzqSPfPrzcG6QRFFPf8IISq7QT3pQq6 3nxZ2IMKinESNinAqR0nf27n4/l+M5yqjg4iROGq3ZJDzZ1mXGqHQGlg9SRmGq1K6Mv+VQFl ia88UsYUtkoNKIT06vK0gVsu22YZJ07FoPNkNJ/2hfKbwfNMcd0yEd14RiSNZ+Lra3w05L3B L4R8GJdQprjuuFzzVY31kliJpJBxjeiTrlQQ1yarPV+e2DZpErrwOjmXRoNErHOgxD6sZ8cx xbtDxeTftxab7DBU/zNS8urUCJjHWNlnvQQ1tCIcK9NCDpxM+gfDq6Ay8fQWPqpWqBoLhKib 3Y7StZAmjaD4Zme2WUpsWNm2ewvA2tCOU+Cgv2JgtCQe5kjX/UhQBnpPdYa8TJv2Dz46v2sE yKMAQbq6c0Un70iAsqdwBgqzWbBTy0Ky7Pj56aw7LV56EU0qlI3mNlkaGPESbG8x+Sd/2t1V zsnineYG5qRRmyWUMob/kfWQ/hlJL9bA9415KxLlLhEfFeS5J1HwgvBb7WcWiYKC1I/Mc5Ff N3KAU+qZ1ANDeCw9wQb3czeFdz79d5OKcS4fqvNT8FBz/37myNUNmjkr1c3Zt+nkytlfuxHr mmhXCz4J7JGokSSNsB3wO3WVMOMVFDPfC7Clf96YpjDuegqKEXzswmkQkzAKTKIVjfxCfwez xz/kU++356Nl2dJ27MHD+nf8eWjf+d0pA6qcTv8IsF+YvgGoC/7eHz+2kXkD0j18iVHc0M0W O5MNlMtTrkSoXhw22Pl0SGIayFKKJPQdoPphmKaTzFawpiiQQRgCrI4sA1LMsDFg1R8002DT T/pN0BbV2z/9dU3Gkl0Reh6JQ2eSNVC2WiRWEU+jt4RqM4sF8WpiEocaCuAKyHvpvMgC0WIK hIo3DjpPaaTNdNAs/HFfkp0bVPRj51FyO0V3tkCUpPwIzYtFEtV264zPbfmfu7X0M5vNAPCr LjkTO18NXCUJarIUpVLiNySBNRmNfzoaKCJgeSE+dCKmDVPDaIBRXRTc4xc7iW2EvHr0jvwI OMaJafuaL2PnZZ2ukAi1vKYVxMxUiGNxYVmH59aNCrQqFTVHX+GdZvYADpZRIl27SR1OR2Ty 6P1mrfSCf1Edde32MBGEhg9xIZgDZOcdKa3yzuzUX0W33B1WhfyTvWLr5HFW77OYqqzk9ALN bzAy2GE83dCrLtfP6ftDR1mNV3TV4VHMN1q1kOaUyKmEvqN8SYqWjhMqvXvu3wJnI+4N7wZK 09j4WtgPCIgeJM7csfFJ4hDuWxZqNbheDiBtXkiFv9hNLhhlnxqY2XFCpwMsBT2q5crNY7hD 4SeML+i7SwvvaPnFmmT+DgURdQWXoBQyw+GiS3gqmGH35uInWmTkXRbnXTlcD78wcutqo8ye gJymfjK6zgY+Pt7gKyS+PD+rVOd1HN1KqU5bwr3yqBHzgC7bBCg73emtvlHXwpSmJiqJgojt dzO6QwSoH1GYTDX2BhFkyE5fs4MaE4Lsf/KdvDlomIEwp/8jBdstQNLtrYtWJ6PmNb2SqVRa pteQsdMmLBu2YzVCLTLpajjSeErNlqmjt9DBMnPzcOOQgySqUcRxwf4sgd8vXuuUl4rEK9Ea KI3VA7wk1O7BwlnuM3mlyEU8DNPf0esm7X0l+RE9YBsjEqVUVCgxGOTTss2a0AD/c1C3pCiB 490m/FYCLuQf0DhAxH+IMKL3t2duiX6Ia1NojosEmMXyM5iV5CZmuyzyxPWGPfFwGdTNbbBI 1My2mgdYlDKCBFivC1WpKabh0aRVMflM8tBM+scRWxmnMFkB3rpTLxUxalztqNLD/DwnqDD9 WJ5QZs/rwQD8vvCsFh1/mzatNhTeIC0pwq27AlH9VJwKIM0KwOjPCrexAakZu+Upoz+0adZM 5GsenXzUITP0KrgdKzAPhHzo6gNGJ08O50ICnQM/GCgD/SPcCDNhUh8WDxmN63ATjJfFZ58z JQh4E8myEkQ6t1hhYKE9C/H6haK1r6JemsirG0uMIGHthJd2nkL3mF13klwzqkTWtZI0jmd5 wjQlg+0/XG1EAMEzUcpTX+tW1AqItyQY7GCbgZywN90mv1RNmX+8ARenzRnnFJsJ0Z9xWIcl dz0qcbtVZ1HYyAK5eQVFqRnrcisVJE+d9P0IP/iZ6iyRcMJF6u7fJclxuZCtzDC433ivakd4 ZjDn2DXDoZi3z2Q2WGjtxs9AzsPr5jqU94TYXjlwIdXVe07mh3u625M/soAKp8ZO1ZBSClW9 l6asu8+tzDR7cPYAszqeRGe30uMeWhk1kJTQkgSyr9x1KxnCdz2ongwthIrm3aG347Yto/YM 0T2XAPvtBR3JjneCsCwlYRk6dam73p4leFNLyiqU/jqX+eb8/we4IJOxSZVvST7DkEM5EdKM dA5w+RRYiaqzUFyeF3IQOCj5KtMJxIEk8HsjdNvW0brh9bFApHSNtJqNTER9TZEKC9rhHpeb 8T+Yh3jkJUMRhU56jhJmsnPX58jSGcsrZ4nakTiNEIugQvPgg4+SBVP4sB1ilqKrqCc26hVm Po1vuJOrq+KkB8DlEWk7ILkNF9zbc84xx2Pu2AZ7UuJ51DGxIJkh+3YZUROa35rRhfBxoP0q uH+FBpMlJj7KaB3P5C/PcSAGs+onHXUGrxHGFVUHJEOQetQ9xNWwX+0kGeQyP2ZHZAJW859h NzGXewJz7CB6YinrVUcjNjuQpLv7TAnX8njmROhRrHPj0kKBdBjhOcedSTlJu844TxlKJF6A 7s66sIe0milKY0VJj1HpWlp8dX0f7hM70TYGDWECcvZCtNyA1bdUXDtHFDWB59BRN1dc5MF1 u//D5ydQXAvFCVZ8/a1DkldiDxGrpjW7wkI39nJJeOYX7oQqawyGZar1G0ym+UlS/rTP3mOV +3mCJl05Bmxaf6PNMwFnF6cNsDFGGh/2NoRUP7tkby6kvXW7DZF7bynhy1tVRyBeE1kHPvfR itrG3FfznkpOqUrWHJs07Sb2reMEeRcS6VDNGDzwLsICEa4N8KP4Vsv8+e7hED4zxMINWjnf gQVRyDkj4pnVPb2MsxTn8iK+KhoSj3Pf8Qm0p7gfrT26PoRcwRG4FYr6eDd58kk4Dkwj7AMQ 7YWDdha7ZsOR13hnQCmKc3CgY8TquK56ASCqQsv8fUANgm4onaApekvWR0248LsXHxlf4CCV ZqPa1G5CD4STlwtphdkh/dyLGC/n5h+IOYNH1Ri9WfkX6aSO6ZXikWYbn+/7d/OrHI6A0NuV lMunr6eHiBP+94mjBgHgEDrV3Gbyr0+Dg14O6TioDW5qhEYfpdtrOSstmodbr4l5WqfTefOZ YIRZqwDmGghw3OSqjeH6+Ohnz30e3JBXMNT+Y5elMofuOy8Qaj7XiBro9DjbI9pW2SJObPaF ctB1WGQu+cf9qBXbGIb1jnLmemLQkmt8kChWrmfxbMYxcl/lQ5qPHcU7oUPiLuNda2ZFKd01 KSulQm2fkiTWy/Wb8/xfXGHKyIRAYdwEF7bY5Ju8DJ3Gh+eDGzjDfKrGZPmydH3omn1CmGUF 9bmuKS3ds+DC1aci/32g1NjfHhxumGwuNky9FJluiwQZ/7Ahpn6V5kV7DjtOkzm5L8j7Vo6G YFZaLYqBOCZyCQtcDKDvm0ZeuWDfTGkX5HzEweIM7H4yQcSeIDBuGnAwaToiKHf+6v43qR4e EUkmoYhFHrLbgQ+h05Y7J5MPGOqzh6/ugw8LH3EqYgFb8tBvuTEqK6xi+HEQJE0r/JU6ZgtF sM9ZFLYv1DsJlenohEKXlIHZfQipa11cZM61L44GUXkNKkaPqk4DHP4SD2/C9zdRzNGNBNZu QHcdW0BxiUmGRFcZXkDe4bWiRJdt57qhojzQ724dBmceQujVredNxVVwU1rTfN/nUASAPxjj rQ3UJSc78DPbJVb3KYuYLZznoEE7CWZJAX8L+8KqDOULw0KSDIgfZ5JLZ8RppkRdrRqofy0L JrDONPaK3oDGlbB/M4VW5RuK6JUxS0SY5NBWZxxtcK3ROIcGC0hwXKQWtsAqLLjqytAwcYqA Kjdwfdhw4dIMJWkHSHwd5bPV/PW/4uYExT2WlR9vsJxqAGpmtfCnHdZRKmh2o5Qp2SAJXueA lCsdoXiTVkcllBtxJUPUAYGZ+qCm3omSQ7lQAA/ANLpGTtf6uxsQ989kALByZXmZuPmVe0MH jUAjqDMGbcGA9878kQrU0/OqnuakxYW8G78LznO5+E/XOwdA49pvf0T1H4BEBaodRs+9GA19 8WyRXt89+9uFFK7RKmHlqEAOQZuQzFZDpr6wJ+YtZ2tnOvX5yWjxUFYJePLa49MSWOgh5IHt 0K18Dga1put6tkOT6lCxU7ymFp7YjZwPRnGXOvxL+xSBvA0HRIXLFt9/LjhEC4XGi7+6q4xe aceNRHkGEIzTiHJ8ZQoYg2pUD4EbWCudhSfb87GwxUY4q2Vgs0hHBrQE2Vyi9mghXqFmoCKy A5v561nK+AzPGe8xszXofRCSUhUtotn7D9LQv4TYZMJkPq2vU00hsjwLNUXVvTumSd7hXYD6 QPihgjatIl19lish2T6oXttsIKjoGQqDSWLLtfuP8hnpOD8yGMYllJhL66B8bqyuGTgg4i7D JcKZ6I+lWE0M7P5UaG6iuyraNbExNrCf0ozpuoTi292b+ruELEpTCK7R1J9Fpbxgali3nuYc 7crwara/XWhGX646n4gnpysdsknRZ+PvL7392H+8RPhUL5y7+1H9t4gSnjpYSN+uEsvigwrC Oq5yd8LKlVVWJzaB4TP7NYWCC2pKLNgDhcB0b8Stt5XLWuUvpTeeHjtmwuapRp/sRncg4v1F G0rbZUwRUt1ahhnAgxagho2gwQDVqdYCwOWoHuDTvfuZAiyrMpMKEF5SVpb22ZKx4KJAVB17 MhVWFNUwZXRtjh9BAISY9I2QEvWWj7L0AsDPKGI2QVeOUolre1RakfnzO7Bx0epbQfzAQNiA aMaBiAzTMAYzOtmmVp/6BBK79Hwdt0Rc5TCRjctc63+FGfuhONuo0jlaeVPU46KNNa3lwjMq sc1GFZlLZ4S1zXy5AXUgmIiavRh3vhgibQWcAMe5B2COR+1QW19x53qeb0qv08gP3+7FWLvQ 6YCSKcWex67Yf53fbmGyLelB57wxWX1Cz4qaQJB2NOflCffN+vdYSIyMBXQPR7puOyKZeGmG YNEVFIxR/T1avGQj1Zgp5eY0dB7f7jGYpQWnk10cnKz+rug7secT8vIbMYsqrO9z146FhxeA tNkFXV//8H9KpxL9Uk3lgVoEK3APIaGjbozqjYTWtNmcoSFpiaY1vPMOpcra3ZSPNdoq663P lDBNCu6r9FQ0QKXca5kS/1kwuumMIQqA2gePQohtHycn8hlhXsXtxA3t3VuAMKIdGHnZN1sK L2HkDy9jfHaHVFaXvm/Pl+KUmczMDdQboJBJQPhew5w2uq7cHYDmyZq/lnDX9q4sZbXSBa44 62tzVv/BEfjsk86oRldGf8LwWJra/WpNsu7y8r74Tz9JfepKAk0iERp2Rj5lbhk6Fu+H/IEn fhTCETMV9f4ynxPY2/nOxOKhXU05eyyJ4UWjnAgVQtGLNAlymDvX4aJy2Xle1OiYlYXap6tt 3Le324Ea1xJAGuiHE8glMsjYFsuEJgGP3w+klC5t4Gmo0qDuCvQDc7jCAJiL33JJr+PWiI8n LqGpiqJz9r8NxDmUOmMZuUbUPYEIy4LFE4nW4beWOQdCW4BllIljhaD/CFVKYl5UbdA99vBM W7bNhIXJ/TNiawiM+qclrvGfs9lzqOXu51fDExlkjHIYv+SnFIjl9jfcnnwCsXozrOXGvcew +HQQOKZ45WPkvk3l1p6yj00D8jA0Y+TorOT1NoF5r9zeO27lvFisnCYmIyMhJXq4h8GK1uRA RB2OkorGDIZFNC/YCkbQXIodJsa8UBwkgzUTZQy5TvwdwH9AAivB9lHQpJfdoIXPVdz1+J7u 1vMPJzLPKNTJXwsvmzHwp2/ZyryyX0TGna33jJP3om/9Cjz0pgRJg/9QvM0ykc26om9lz7P1 pky53bzpDLsIhUnwKMK9vAysTuU3F5hokdS23qfD6dzhEc1Q2XKTdJfh89D4eTYE9RV5wijz HHCs1Ezddn078kyCkw3HF0wggw5dMtqEUoSKpcREmYkAW49cpkr3/B4ZUwzvSsmDoKg8Nnti VXIDycr7DgmV93HtT+84aDr8wweznyXNI32N2PyEaAQ54mXA3YVz3Y3fLKQoc6IEQnyAmgcj iISCt9AuC8cqT6WA3yS73c2sQEd5Ou71PXMB8K2EEfw7U058ybSpFZqMB3BfTLjHSw0Rys6y Z7uY9lJqLPBAsYMwQ2oNoeQH+grbEfJauaDLxS9Agw5oHAI68gbUdZvtgFsY5FTjUhastE4v iErofEPbyA6i5QbwsBKc+3EbFeTCJUvzu/gSL1wcQgW4pKxSkERZ3Ba+zrkhr2iPuvc3uXS6 69Ya4pbIwjkZZIbXKsXgZK40Ed7ZVIP0KhVfbcscoVzO+PuifMcxb/03aBg/WVkZb4d77YGd 1miY3UbXM4BfeApb2cdlD+KTBGWUI8EPliF/HW+m4OaTasytZZ9fk0GYpB7IpzEEZ8esQkUE BQfVFvHkhb6clwoUPpjBgU8HEzvNcMMxjuZ8LiJ5j9SUv68AxIYz6wVJRUFIlih/GinMJM7f zpUc2UVUudNWGfgfLkIt2fF4YetFktPClbGBGFSs8pLnswG850nG20a7PCwywwzZJ5e1oYaV 1DgMxVK7zIzWe7Q1KEu8Frt8iRRZZ221hPS5sRvh3XoU0lHuudAPPUJqx2t9f6K+V48JXAvO 1eH52tt+s+O3Q76kITAe5upD0+tOOZN/Yot3jvvdJSoTR84tuEIG24CvU56kiYsfhReRG6+A 3ZqpzEgLYUT9Q6ChEvRgO+S0Vbm3E0v9qfL2fCjQj3yGYkh+u9+29rzscLirOiq4VEZ92iHg y0LWDwLKCmMU3cDATLMnI5GwsuxLIy1dAq8JQI5e8dSQmqdhwDuoNcPxSZlpqIT+K31zgLFx bzpaNvq/D5L12EOQzcgFXQs/cHoGqHlQMZkaX62PzQlkkedpTro9POXopJnIRR+jXB/mG97n cQDsUijIUO1J38zgnyt2PsHBjwvHOfy4YSOCOMCjULQ82hbbl4/2iy3dHPW+cOQYsDf7HijG fwRO/9cZvlmRWRzwaco5pzBA8BSBT5jBRgLMbGjF7vhtEvAywyetRBcUOIbIEU1NgVqvZri8 twuNWbElEI4SFwXdKvn3auKjtUlVmjCInrwLm/EzbEtVH5YBIa834R7WXnQm2ZDXptJxKUTm P2S1KU8uOp7ZvJ53xG4ym/kqVuWMKQkS3wU31xzMBggzD7qkajvVLh5xMgjWwET1VcxJG1HH cqFb1YHrSI2L900PBLYLfRAfCUpQf9oUQNTymgChhrHAIha7ssOfX0sOz6utoyAQdugU/kBr twZg7rvJXy7srGfCqn/UzJS5/71QVTIKkXzkm+UEPi2ZvTgbw9Cqtm/2MKuNr/ibD2hpP3mL QPu4rjC/7fF51OSvjTlb4bO529976fwX64EMl0MjUulFJnlMhg1mnpR2Wr9wOWrpcXcoWTSk A/dB2fHSzxCacVif8ojR7ixC4hJanJ8ofykZU5zM8LXGJbsyGeDpTaNYSR/YaAms9blOPC0l jqULI5vhouNSfy2dDaBdEdHP8DW24plPay7AKt2bOouDyhoLqTTKHir8cfmFWc6pIpDfk2qQ ak/ELvOfpJsrERSDqNwP0PThKyNoJNGkWXxslKyTiOAgxHKZVI2pOVxP1GuzOg95UYRXs6xM RxcE5dGoQqpNDy26gB58rhJhK/2/+FG4TYShSEfxZx2PQO2rLW3MBfqPy8+WDmRNvO44Hj9c yxFjt1TbSUmmPc/shQlqbBGcMmOk+dPTCQbjDOfpfjgdgwqeyxe6wzK1ZXOYRFeq42CqpwoU gdyZUUGTlaRE0H7a1pr33WauxtVg3q1HUvQQPbnBepjwMMZBPGE9Ju7O0STOd5CSZrurnCc+ 9TvRWBAfmZeKKcnKIXFs3ZTKfZxSL7PzsfkzXd9SHUkIttnsVb2BISnyellXH7HPI2SMG7/1 ztSeAko/FwtwIMuac1NqihqyJXCzGRzrJ3QEC/TbyBM2cdq/WbWWHh89TF2yc5L8kI3UNg6M 3nzihSYOOXzqB3dn4W0ZWVBBsnG+K/LiuJAySWUUIudV/UKMIiEacM5GA4aQDKC7SjRiIhr9 OYFMjvz2tR/ZzLwNG2meklemP+BNYoXONpDUiqNg31+xlGb61zFRADEx6oa1hEiXE/Hlq53s HIu4zUyIsUNTtCKyjCAgElQ8CisKSe6kYCAUEJrughbqwcb86I0RXo7XaDE/p+Nz5hFJuh0I ALLZg8MEhoLp3f34/fMF5usDQntNGXKmJ463dJ/P9VdpPxSeh6HQ3tAfEbtSJwQN3dj/nVMA 2tT8JIgB4rJAXUo5iMgtUW5T4hCZJXEarWTrAn9PKswmIwf+qiy839wOf1nuWyoYoekybkIQ xo/2lWDo4Lx/eV8AD0TnTc6ngaIiG7KFxKlWqFMXGJvCBF/xKYAYsSXbjukScx0pKkQZWXle 0xVpVacXBXJt3JPCXQnMledWbc2+yvYvp4Tq9/jNHolDanvP7wAvpKsmPNb9qWxR2D2wS3Tn 3cY9Ufh85wU/cagO6QGpOaQjFHpWnmVcIzGkt5xPlaHNBcqCz+EBMBfhtKNCDsIO2O9SaqeN +8yYaGO5ZwixsmB/TxrXWlypcgo4riHn7zDdXPVH5DST43R3Ci6eGSgGRfATmT+NIk1zN5Up E6W//Qab/q0qPM/MXmdXJrx6vk/WnOeDYqTcWx9T9GGDWnk0R4aC+aHEJfWt2mrIYK8JLeW7 3Gha/xzh6ERbH3BrzN+tDsaSH0s7wptt8ek2sZuP0df6Ne2+9SOG6nbdImc/qN91uv45/8S4 NAdWNCbC2j/1aCiVLbXp4tPDx7OtxG4OUcDdZKOicUrg+nucAq9YDtLdbXKFI505yuLI85k7 YoX58APOqSoLUHvW4YvPONz3vhGg++ZMxbxmHfjFxyxJUa9TlyqstiOfuSchCcvw+TD09IBl E1bunZI2kzz1F5ZJDcwbQSIpFRcKuFHbz4A2HmGeyxIDH9giYYOxqWGti/p35UFHC1zbeoge vEFgNJaXhbj3Igla4XPtlmweBSOHnw/aF6tEiBPR7qlxeYVfNs7nW5/QSpxVG488bzzUHoeX eGGDwQcasiQ6Y8PL/479/uQUn2eiSHFoqlRo5ZOvSthk4HEFLr0CipWfmHOe0Az8pyQdzGSG HXgpwr2Sq/TeVsW1nD67cFwkwDF4vmJZ1DRpI47AQxwXjxK5ilankY17obzzc03g5wezN6W+ RWzM0zjAxtkJWShSDtOCQAZCpX7jtL7s6dsJtZFZmpfYfVWgKKaf90Yc011lthz6bWh2y9c9 9rlLB+nbKBnepqHfGwn+43Vio0N33AEjZTTFO95okxlV7lSpvu9f8Xd/Vs0YO93XA+CCoHIu epy4HM3vUCIp0SqnV9yt47HZpM1xLon8qCjl/E3sMqJSdcrN9Vywu89HpZ6MHwAN+XbPe6cc iBUstIi4Nus2Yt9aGBUdE0yo5lScd+eBaFFqhEHB+hRfu7RNDuYUGxxVu/0BcphNK+cpkeck KMwjEvdpupgIIfszLO2KGRf9X+O9ZpIsgBnGtDEY/Wr9iii1PyFK8jFJ5W2/uD5DACEUpBmi o/SFLGF8RtXrPI8kaysyCoEdLXJsUjgu5HQq+zTRdeeIo1JqIYflkdJeCqd2eAKNxIvsjG1r B3W3x4C0KA5/uMV2bhEEolB+PN/yToZ8aaOZSEwG+iCjH2bykG6gvhPj3TBTj8pIYJHya/bN BVQgmOxvzm3CgrthycY6nii1SMp6S1593uTPdRA32oztnoU9p4ZUdEkmqxY6hI7ZONwHnus2 9jrav/NRHzERKHoNuDwtEGHUG4RVG5OSNQ51PdibEs3u7JNe312Gv5/B1Q9EcK4n18m3TTdn pg7RBAXp2XZH91alJKgLYgYb194d6ZAukeyqkwSHsU/3N2ZfWPFtoew5fQOCR2wuptKvH8qp peK33D0gsy1LGSz095QtrKG6dPa/Q33/9XoO+bI1htg1BV6y/7NQKWKKQensiP9TRzVenhxj mmNf2U16xneKSj9Vk34maExe1SIO6kgasx1S7NcLLGAJSW13kjearTAPQQ3oZ5rIqHHijUqK 91/vkaNyvSJzBf+zQHtBicUbnpRRjr0iwb08fy7Vqu+KbSNNWidNqrZz7nbYeANd0WSYtFep OQXj50Ascs4sbcR80KjVubl9eLMZzfzjNkn8muCLfOLi2XHoKnX2/R3CqkLS4M6SnrhkO6wc UjK9Dzct4i4hN+4zQNB2UsG5NpkLIcOBgq2O4yyznEq4/na7o6qYYyJatd9g9Pul5Ka0GoYi 7HbfxIVz8BYxhSMJ8cGmcI6pT0YmdyDr74vufemWhzFooWw2JG1wYnJYwP2s+IwK+I5xrR4s wLQnfy63NMHRRSyAbO6S00YxFenHO/3m65deW74/h130ZozXZ02yzKPdjIvV1Sfkjow5Y3mR MowA1k1qF1ElHLwmwMvthq3g3dc+fgj9AkpOeRskW9fNALI9PPPbCtuaL22Ix9T95wTkgVFP 4P+p6LXoLShf0YS6mgEt2rOGlfFBsEKAcKeGPcv8lWqxEeb3Wxh0+wUBMhfl7D6FW3/q1Ci3 ofiTOCvtHceyl2kxy6t7VH2Qtbf3NMwjYwDiuKVYwdpJ0WVoiLmrKvhRxlGL/+eXfhhWVde6 opw3XTRG9mtMipy/fEuhDZ7DOyIbVUzTiz00ce+E1qaSqjXJon0TOywGFGk/IUBRXZ5U80xl 6J2bQpA3DxcSvt9/dgnPWQw0nv0aULVRoHogYSqufD7MM24OgHzUbdXVQgWweBN2wwcgBMj9 7xH5gyx5EUuZDbY0sXvoFn8ng2LT+i4cPhuPtiEI8aOWWAxnDV1isMUDRGWTyu1GQJVAuU8V BvujmtSOiDmWV+zeqWpjUynbyGU8iwBd+e9iO8+i9A6PPmeqcjot3uAsKxP/VHYtuNhWmN6A 8/8lVkMzvjOgR7lFcPFnyZ9PrU+qsBfZeK3oXzezJ4vqSyQhJIzQezoOGr/tWkFxWEyt4F5/ TfqopVpEMwyKxODHIJEhQuKmuFmbE6sXcfpUCq7TuuOXTuVTcag5cQfxKoE3viHfmfsMvNGc bIDTcBpyOPmzRASuzDvUpWanD7r+QrRhgFSR2tcCI7UxdxF9rznfBdpLuAs4qZgzhDoZVBRV E4Yz7QqHvWMUqlQx3ncz4md7D3xUrW2YZ3lvtrvDASDiEhBTZSMLg7Fx+RV3beb5qBzNdgHw Y1LqIWHmB1FJUpFxVqshYI4/eGB7tJEz4Vp0t2U/aKeu89obJi5pUfLwQG6IrHWt7LjQ35qh H1FsXkFlL9QNjj9m+/u0tXQ0uBwzynw7jjmu/nTIgugPVabLd/g4H3qtNEg1TtLOz7siMr2f l5rZI5OY4SXi+hTLvBaK3U/TAjLyUjpxpwuDzPN7cUDueoOgVD9ZGkOkV/uIZzG10Kco/XHL WJzoPvRupbHkp/Z2cEJuni6ok5+NkSpEZQyX6j2iCFXO2e6/Pn/oyUZ7tYupcoDH9KhUo3Mz 5eV0vdM9D+90zVfJD+4d4qB1fyL2BdP5+PUuNOCKzYWR36EDKZDgLJaRFmuRXc5dDd9kk1Aj ayHKnVJlehdmnTBC70C+B3gP++7SDvPrM1Hi8MIUBd8LEvYMltk0eeGIpsGJdTJq9Lb8VxjE NwCtOjXu8VtguaWxkem4lCknv9j6cT8hyxobzER/drzQU7QYtDGKmP5aLPoW62JZtydeC6El hSwEii6W6Y8EPGiS1J5foX/UvfBOBWZmzqfEfSFtz40u19qlkI6AWgCbDan9B7CSmAJshBym rj36+2vSVlY1+hWpwTZyMT/GI267OjMnZqZNqwtx1fwb4UDb/9vNgCenvTTWL+nvBU3H19YR rocbFwfxbq4pLoGuofga4RSmDXLXuhfhp5nxZt7ttFxc2sO2LEGZnDv03Ixj0hdYSRYC/XLm yJZeLxv8SwS3FYyM21jqq6mUPmRIi92tdkVZwiy14XMjg+NQjD5J5nquduuK6cjBbIsYf9YW gFrRy5XEnrsjzIhqIgBRTUbooEroF0pzwz2ujUNWPqgqYzntjs2+uC7qxM2XktN3osxP4rZq s9ul6jgy5YGyFQWIzGwmYXxayWLXfAcZHpam16Hllk+5MLM29LOP4/NxkQmIcqgn2rChwyIl YKe77v8cHhKIKQsrScDMpLgkE44ZwHyPpInEc56R019fk0g2TJ1n7L6KUekOmi7qaedJ8WMc ZnYLp6EyeEi9+9ZSVUDzx4ZMHMzGYN/kjQuEk5xkbS/MFbwpdRstKPJXBT5Td74lde4yiyUF gQpBEd8QtijB+v/t4FHe+8TSWhBuAmEopk2SdUPCwvheAfqk7c7ql6YY2xcoyaMaK97g+lTM BX/21YdWq4aTiSLxgWJE7IYtoieN1YHLVSGMbkGN9O0zhLslJVs1/Le5CdXSCPgipQnS4J4Z H9daacsi7aIR30BcfRKqAtY0yUocKUq8oLNoy/tc6kBDtIkVmHbwQ2NMD23EOCarJQB/dlil x9nRSE+CfiwEovT+xAboH/qTTwM21MXEin9WUjKJHJCUwEeIQs+mIvRXmWbmwEGGUBnq7HfN 5h+oCyvAn+iRXQpbqhbW/FBG/2MpkUKs0fG3PN9P5XLzm6Zat3gg2ocjWimytZJ7piJcTWXR FdEu3rGSr8U96FhcTH2QJCCJ0v3wISukjw1rsOkr/4RzLHvETiVuIbevF/Wjwy4Acx2zuwfc HXHgi/zgAar12cVJ7WKeqZQq24SlpJI3PFX38pnX0VWO73xmloCJCmoQWz8UikN/QYlT7qQL BNqdHl36FkIBLTAlGIJRUFWEuZl5pZEL326jmUKKWesvlnr1DgmuEAOsFuY4bSK8/Fc6RYji 0UU1eca4MtguMlDHcUk44ZhZhSPxzzRrmF0OOxKEqbVxnw39NepyE0eRRA4KhnwvQ3s8QK2/ tkawxSXSn5va6CgHy/Q/otVCoOGpghnqATekdH1Htu+Ik4+GAbmpGxJGvTBw3FWy8CNexiGr QaeFqNisg/BZuNdLuM9/7uqHkEZAS6QgArVyI2zpRjg5U749oeeaQ9KznXnnOt3+1OvJzftw k7MhCATGkGJgvxOoGm0Etl47I09kpfOtPv1TrSYWhCjzbqmZElooxkmH5/vIBgbfF61/sFZK 1x6lFG1ewcYM92UZi/w3vuDNrspkFGFj4RKyGVyW6RTYIfrdltcp+C/Nlz9aM3kwMMfsS4xa TkrkS+JJFV8CQ1IeT76P/vKYbym464T93uTGbtrCE1DdZjjh21VJeXLBzECnG0Pm7PqSwx1/ eLcW9q3f5VlnsKXM7vomEbfKehGOaHfII/PQ5qqLROkeeUtnCpP6Ld4/rv3DovXg/rkMpOJ9 vHFbaAodX8l7WQmRVdUWDyifRA3dYsdD1cHp9blBq1R4TUI6OWYsn9SoBztzuGN9gwMO6Ilv UR1Pao56ObWopaWjS3cgtlUF+IyGyP/YsBCNRT6kB1TSLMHbU29QpJIoWC9POdEjHHwZKxxC lrEcq1L+3xnsl7UhfHbF7sBNKMCPngDmJskr/hsjGd+YU/rNChtrjwXZ0U9egw7L2lQ3nLt/ FKSDelhUhT8Tne1veKmFfOaW822MI9GG4V2ynb6fE7MZ8E3rvwAnVi4Tp9qCKR0obPeJwqKl kRY4uO1uJxVCORRdBiZvChUlIVu5cN8qCainqAEoCALm8ex2Cp7qvc7vbWhhVzuCQhSdmaHz jsetPtbYKeT0rmKtCPt4/oJCx51uP1akuHbtR1PwqFyrIbsr9H+cV4SPOyPYFjIZcVNIsoQB 61sfl7Id7pFyM0Qnx2RvLNXeGYFT5Ip4Xd83bVWSEvcwsTjJWPiluCxevaHLT9IxOI7On0lG VOBNfcd/OlfvuETrOYklm2WdCKtRTq2oY7PeeGwN+0WM6MJot19yGnQP7GLcWwcPggRT6A62 +Vw3Ys+X6Q4x8F9g4mTu55h9ugNDuWQ//pxUsFsZ+Ef1N5eXDAWYPoboFCgrKzGu8V5caa0H tZknDl9BmZyQDKpcIVmhUgkjIJ2ioR3bhcfvCG451pBetCsRSqNnpysJLxdDBeKUXl3J1FRm MRUo8DCsDELSTIzS0BJ4U0qizy3ue9uCVKbrr9oX645Fxl+VhABC58UWUoTsM7e39Jrz6rYt J5gwlCl3l2HW61J7wqmODp9eyowqF4OOqWmmuCLoOIgcWBJAX6uJ/F1NdNF9lsXevursz0jh rb/gqEZAq/s5ZwPs60cCa/Q+EUlm/NPr72oOvcjO+k5T+bLrzEl8JvFLC9QmWyhBpaWGMCRL kUw5tyfKqNCJdYqOFJ8JqPY76Lu0ppi4aXWO+pyn4kKO7nAe8ktVyVfjEVlPIizJIkLr5/6G S3UDV79LwUDcFathdwbiBs0ySaTK33xVVTvL4ChjRDIT7qHKcoB/a2Ad5U++64MpSXVVQvw2 vg6lzPZCqlQ6L/wwQcnvLiemnEE7VNyPEcwY4EXv7sQitq5E17GNTtaZ7UhuALjxIBibxO8R g0SpTdKFYqqZnGA2o+bS3E2wK9Uw7Io5fEWXV9CBn+TgwvrWe45BuPVZSFfThYrGPL1768TH ubYGwUeHiRu8v+yo+frPpQXAwRz5JLWxTIG4fRWlciw2gZ4IbMgWIvzT5kDVAZOIfpvSiEkX XNh3vT0DeqfjVK874znVra6NqKXLIdpZjJS3plVXguLwS1cV4/TSwS5kCrdR3S4xaCz+nu0x 5YS+J0hvGWO55Vt6IvXm4O6c56o3scl94Gp5xzmGXqCxelh14FmHngY52o16N3rVccro+l0l utykz6MpWcq4pB3Pj+bEe4MLyrGo1Q9xSpVftyKuf/vXpekVWob9t7uuTyTVvv86TRs9rLPh AEvE2VW8VIiy3hs/fknfrK6L6WyhKTiZrgoI3ZDBvXW99od6Cr4jE5NoMhLHRsV7/Ld6lYIS o7mMPcw4YLFNA7tzVtueoB9ByQ8wN6tJpaVrpfTFnphPdbVnm7nhprVjYZtVYRPHHdg6fxLc Y+lHsmU4mWzYcsilKMIdZdlUWtDtJNYNJBxcBakaitzgUSQNU5CejtVr1UHBoRZ+YoaGi8t0 Qv+NqzONONv2ei2VYutiY0PjMnviumrfaTv3aEml+KECEaN6foq7gEFAaziV2hNuPjNSTgBS DJGWolvl40dLneCm9SMWoUsbMTgQwoUWcpkDydnkaM/47FITVP1M1o49ogqOmWApDQZFXCPG b54wem4sOm5Ek3e5CsFB2Ragibb8sXznI4mlfc0HO/8aSMv4l79+W3izyS3kdsFuAquNHDtv a890pxLhLcfItl2TL6RSDFX7Ifvh7UMUeRWvmaek/JzgaaCDZ+3GEhMLeZuVf2uYag3YTPp/ N7BrZO2bqEBAJGlMtPBji/vAgEEzHmaSlkAha6c3bwYfCh5vq7BLyH+kP+yH5lV7n8eGwgym AdHEfo2gWuVrv/Q3AT8gBoWpxhC9pkryW1xqk/as1oNUV8CpirM+xsxDtMhcuZRLUrraTy1a Yx/PhcxsFOn5c6Cud7rJ2QnfHKOXtCCWf1zObtqeg9loELRo1CtL+Vpt/zVywkpPP6TvnG2z dy/3YOxvuAR6LXkbhnKHLL4m8cAXU7A0RqwnEcuDjx0zRpDB9+LzUl76bGQ6MbB0Rd3QAHKb oES0gTJ6SMA0nabcZ57w6MhZPYhrUtjQsLZw9NwRF/OH9kTtWtL1yIHGsadsfPXhFyW6ZhJb SIfpy3yEE1CHUNr3Rk9NV+i8oWQdc8XZyujbMdk01x/hArcKnZLfGDwcwmYscNeAex/6/51X gAnA2sBAwID9UbSQho15Yg5dPPMnS5mS2YqLb+0hZuFnFTQ3xADFHK1HibU7yTx70lGgrgTB R/WF40a5XWp49e+9BSuTt+amuIStGm6R3FyWz4VJ2b+wJMWMc8WvHwCnE8LSbmTIeUQsZOIG rZCcIVhpc8dCqAcwRbrPbXy+DXVqiJINpEWKALBEkU6fy+HGmCnWbTIW3uLq3RQyuAI41vwX U53/Xapqk74IBR8YynX+8hchMTh+A5OrIR7ye6XFG3pOkGmVmOEaTHdg+nR+eZ2Q71TbldE3 1jkTbxkhJ9bTWie8k/7DP5B/SNdz8+Jr2D9mejd8Q6ozdO01wQgS4JZ0KXOxmYDgcsXsmdse apM7u+rihUNcgXHTnvKJcXy+VSKJMbIzvOJwpMLK1Uo2KPbClsjVfruCqwRiNgUObZzI+EB+ aIRzxPgHs+fr3IIx+wF/12fzSkNA0DcXdHbWhPsxmYWl826+X1hcBWkLLH97lvHMjaCvtDqD uJ70PaycCxa1ZhtgE/mtjDHUg6+6nbqM++3USEiC0wwviRRKIxn+vU3zJcZh1XCRdFDRiYpH lJcxiK/DVd79CUtnabBqb0dom5+xo+1i8GMdMojwZm4bhdU2OMOPf0qh+088IA90jkZlMp5g 5T9EqTcr5ngY6esFj/qBB6XujsrzYavqnFRDDivbxrQ4SnQLzoz8EP7MP6Mr5kxgisBt8EgN /VrQxdEqZk+1rnBiar/CiWHhw4C3RrS28YcpTDquTxZkITqVmqDBH5CAlkeKSopu0GbJuJoe 9a8tKOB79R5zGTQPEEHaKAaf8c9V3GTSdP6aJ5KkT1RZna/nzSCcTmn9+0JrrMz1fWZWIUDj 5jFkSdLIxcr4dQiv5RIgXIK4Slf9Iym95QC9bhBvGcgSr8DbO6asXdprOYNpLeZAbcy6yqC5 3fgQsVB791YhixEXBJErfxK0/SaFEdk/5g6SwosBIR2B2l3YiXWrE6a1V17fudlTtzB4FJUN GHAQkyCEgV36EQUgT52nV4wrJeEt6lPW2Mu25KmG1QYivlnL4U1EQbKcZOYK6ZTig0p60C40 DmWUoceKbj0ZbjoNSxKbjiwym/k1ddpyTS1UnOKVBLEfSbmyE5NuBob5pG2QcxLzjrlbpwCX 24RTzTQA9IfupSADfLReMJva6ec868ZO7o/BY8Q+TwBiOKilycA1MZ7JpLtSi7rN7GC/V6i1 cFX0KkwpY0C6exrw7uopPerIJ8ybnJUieZQLAppTKq+C3dS3d9hictTKaNE7yi8lvYCVWQy+ V+D5cNcVERz1gasG5z/bo+3iiVL0Wm8NpXFxV+NslAMpIfG2yi0qn1cnIGGlv+RoFtaDiDhV bEbbu4uad5DZxtbP7yxHo3lTYfWEUEMiBwf9cnN+CGviMEPv5x4PWHSFOI7RevWbK508MdQ4 aEPcoPHs66DxcV88DERUX/onj7c4gBAy+BTdYIB1HU/xtdZkmDbzVPxyEYCDozVV2AWYbSK/ Joot4KvI14JX3UDp6IxzjDcASjKYhOHNrmePB4EwK43UG08PjszxLint93yKoCvqpxzn6wtq BCeyPCq9/0avmMI1edhomFDAdd4mo2PCZT9kVPEaBDHnlBD1AcQJ+AP7UE8e4L6s0yIh2Gyz hZLC/ow4fY7WNqAwM2aHAUvihqjVMvAGMVcUMn3VXAUJxe/3zuuRVTDUEbzTzsRxPGoyVKat +LMdpk4WNrh1rkbXiNMSEJ5v28Lnd36V0NL86aq5a2X11RtKRTbg2Yl/MbgajNzvpoXf9zcY ZEqAR6lG2v2qGuRajlZHeqJiwJ0lBKqJIOlWt+0nikqTgdcg3vEtF21LMAR69eLUnqi0YzfM nmzGAhPp9UJDIhwwBFhrBMgYMLae4Q1pHDsVVesUh+gd82ceOjlYRroGLGYgOzRqAWyjKIuf qxhxN8Xum6F92pJJCYe6ETPha+8e5gsWSCEw4e6pDycgtrpdjTBG+NCHl7sD0bWpn6EFtAH2 4awfEsy8aOhw3F4j6zw9UlaSFActHvytNw2Adbm0+OOseJV1CYnVsopVoe7MwUn920XDzfY2 IliB03705NSN7beBrMArsCR9NhhbQLLdFaavWXdGBQffmCWmlqlT9hh4x8p6XrQV8nBbjULz lLEiQhe1ZSHHKFR2apm1UzuMJm+aX1++0xw2xVAs8bYNZBvX5MoYExZdVBv92G8w4u8YyUNw /Kvw0oxsVcEDSVwJW82Q6KT3f2s2xwaLEoFoVzAh00tENNqL4bF6b3t47G/fMIfXHV7IydQI Ax+QwoYRflpqTlRdGES7XYZuEil3ZnxnSK1h8Zte3cK3PDqNyVEZg3w7AKWOqiK7ZOeM9TxT REuZaM1zV5OvwumQh6r4JSB4jkGh7wpFoR5pUiHR58X5Op9NhYeeQYB2Qg1idSHrYpUyb7pY YlR+I1fQdFnY8ySasoIaIqGqxJzZ+x11sPb3qYlaJEfL0lSOiapWH9bvBrX3sVlbNHA54nBW 8ktL/F1wIducquWJPc+q+O1Vpncx90QUGbhpco/1P13zHQyOA2764hZIkDOqW221F+A5iXYv Hb4vr3siB/BvAq/LYR6hxYFTYd7WMZyqYNBh4sUrAyVKq1yoH4ScODIyx0NTj2CMVQ1slKXm Xbs69050EJIrVrWbwjWXK2mwbo94h/lF7qKZ368dvM3fiDiIOfd1bnCgRB1GmI4MwKVL/EL8 ogcP/JbCf4zbav6ZjgEcQEqx0qEdvc6VcMAToJ2UMdoivTZK56LQvTaneyUjr4e5vGVq6svq eiyPYXaX+z+J+2LU+gwPnM+yBAhlEMzyFt0k2RK7YMHm/pdVJIfwoUIho0LsGrirnBxAsIVv QqEXoLZbDca5a06DzscEwSr2TKXoiSfQmt+/zCmLPo4/q/nMqzBEryCNgWt1h9c1u1oag7Jf 8wt0QztsC+PAmwh+mj2ySSrnslZa4U3cnHxE8EPdsTG1mzRZZipnVx6hvjaBLxSfcjbdAdjR Q4vTFOa+d1LM/6kQFil1zP5bJWC1CfWS9mO3yABaLujfdOhfHLJ9TUPDNACGargcgA54sUzx LlYsOChQVjRAgUWXUOSVTywI+NwmJ9wNnd7ARLFAPAbYmOWcT7oCesmfbSzaSsEDQfqSH2CU JqLTttJuVeAlFM6NkrK9AleCPXB86MZrqYaR+lfYlPkQN7+pvQin3fzWdubLpC5ZwTELht29 59eGXOfg3QMtehT/GWc9DvvCDFrBnRDWyCLcg+KqzPeWzsTDg4qZX0SU9p+yFR6SlbLl51Ow kXvmC7CWYEZMtNYQfb/NZOJaWgS4t6KiDGktRiu3irmxsOYiDLgL8+VaZPAZdw8Mxo09IRoa +RFbkhaHZajfx+yRkvVM1yV+B9j2AdeKKZGwy9CQvdSdDhSCwb2/D5K+BGn3cHnpcVm+2wzq mb86vXJDSrRMp+HL64aFzpJGPMGFgutGPijHrATsSZ+EE0foPoPEcU8ebJ9kQoWMzpNLajUr rqR3PKiu77Zci4/Cr08nzY/1/Q++gLi/WwXX4BCAzTNp4gRSdpjKm1+eB+yX4X+hBIAwXDns dHG0ufI3woAQ1w1T4PjHjYtFCuzPtrdadUmsk+Vr+fXE68BC9kKk6bd7QAyRBjAGy817v5ou PUq8mdoXZcs0MK4F7ms+IGeStI7okkGk2PwulODRQeGzcAmsgLWP/ZkXHZoNRCyutMPBaWK1 CLi10tQTMrDLTZhELlx9W08YK16LJFWoddCZ/jor9xJp8/EpGHBPji/7RoqrJNrTGuHcDlpU EL0DBxeD3AbmwopmWYQ1eco8aBArC5V5X08efBeUIzr6vUCNQyquPmr+1b2D3QKTL+MTDSO/ jgNpNiKNvOUUHrqKS7b5g31UhiY5PfKz2Tw1WK8/zZ4jBPTDIdh8HUBTMRw+pjWnZJP/kC+V kphmLLXLJBXWgbn43uMBHoEFCMGo3oCQA2dvgUTI/Z4MrgG6mB/sEkiHne8R6ta1UTdpsufG n+Dpel6jE9C7AadFlcUbepq9iJv62e4zuah5wJCBfhmtIJlMbLqr0+IbdiV6kAaT6fao9+5X OOawVicigLqNJEctsFxi1j16dUj7vpqg3XUyHn7jqxz7+GUnocQb22xdaPOpXPhZy2d3aOi9 SX4dNvYwXHjiMQbcxCRHjORd0o7wgkk6Yz8ooTLCAMPF40xd79PJ1r61HIWI4vbXqLaiQ6C0 1+hno/rctOrWPXR14awdl5zc1s2s46eeFzxGiKpRSMqzt4TVO/Lmw+HqiKSX5p3p+V3+kYcM y49CjkSDRa6u8x04735Uc63eVUnyY6MG0wP/hVBsjAP6n71ait1aXvuVtRjlf+5bbgLZTUay OrvB+TeTzAfDkGeQZgg76LdQYWc71oqAGd8xt6LzOlFSzvEl74lX1uEbNDy2Ww7v5L99bLoY I4zVJJMu/gRUIPDXZySIl69VK+Y2LLnek/0LRTV9igSzV0MPlaUQkMKG17Sc5117jb5SQp17 4U8rDJ0xtmGDpde9QvW4HozgmuRWAXTRVhWCicfiF0NAUdde1qkPryc9gn8P68je8TIj27Rz mjRrWRS6buEvy1EWyb86gjVhfnI3724RGedisBTgLl6IO4+4o4lFjsCl5VCw/PaBgCxnGAYH s6C1do4HJcxN8oZGgOXtQEkA94wi8MExaL9Tmi7XbfgOUjxc15WTEyg/2xRPDhw8y8kuVq+o j0Km3k1JhTWdXsAnnUyPgmaDTX78IMUkGHgviLrQdijYqW+oaFNez1/A8zCLbFBljZ3SLXz7 3jSNdvxEbAkIDxIUvELLr8LdKjmSuk8DLJMF8VEYjWWnJOrJC1jMD9HvoA+eWLW0jeY/KYeC WTL5LlkbibGepnb12qCHANYnndyP6XnFX5PN8XhJYRcBn4XT2WFt0GvaQvifMe8qoOAkkYPj Mmc+h2Vxo9rCMWfvXT+ZQI54lANsbrxlbkEyrpVpOkDYJoOPZopQJFql2Fbu7JKXYLMADG8M 9KcsIihSIl3XJaZmueL3n2j6xUb4LdWlbkWeFhOmbL88q+AFxg51ic/x3Tp4aDD5e2WcMwXS FajZogcFggjQ5RyxqvPlHBy1IApp1zMyZ7rkkgsljWi9WNa46UyOq+YNC3oEEB4dTPxcHpI3 ZhxL5oc3Xxy8yLkn19kwwBsxZcFCieHfPUvgDoHYm2m+Ror2xRmRnf+piEv7YhWh9dea1pIx P7t+3tr+fD0SO3SZUbQ6DnD7tlTY8ylKhRuIVPBlkQZXVo5YrbTgafN74nG4hU5KnybjhOYn xk/BHdK22A3csqJkrkicp+tKXESBoHa0+K2sUmjmyAyTapO7pRMtcbqQ34je+oyDbcZRZoHU TSz10fv39aFRgZUcAw00RRGeklV6Mh1EfmDzZkqiACJHneaXjfYun4pjVum2Jl6JUsVjC6Fg nheAH/crCPIDrDqaTxBXBTJ5W27ti7U/x45SPkDNbQBbo6jtC29mTS5O2NyQa5mtbg5AUXIH oo69Q+jpV87SBT6V0HeKf1stqzyGNGeLbWp8vCJj8NlcnOKdEf2n9u56REwbU8rFl6B+UOJs o43ZBVFyqfGJSmb0X9jeNg8juDF99oe6mLPuxMH/xVgx+Xpj1t4Fq0Ch8zF77Nbm9npLksmE qztrht5aBhgmK1Mqks6Dn0Wwz62TImQiNSjElybyJQ8vHTBa2WND8Hgrg1HaFHapchFnco4V 5b9p4hVFiUC02ezWw3fmchnSrCQaOYvKHvXTUH6NXYB7NHwGWBGmv+kIZe+MrFbnw6ehVwiL Fc8up69h8kJ4FsCADLrqbc4rubf2Ri+wAld1uHD3e88E7LK4Gd8HM1GZbft+EHv9Gc+VaCOE X0MUGQADlFGQex+AjZb0eoa2hF8F33taaFr5YIawNDT1hVFMSHWVoKdie8ySd+5Lu8KDiVCv VL7QAslo4mYkvekCngf16qp+1IgjJKUqa7Rs/lRJbhOiOCu8D0r2B4ElFekGIttOl47ZiCl+ xyPBarb4r9xd/3HBqOi7alNRJaC2vAM/ZrW/GV9mh+nPCFF00gn7rdqbe9POTVN/NOPn/uyF ony5lfTKetX/2Vl3LSMgvfGaQNUkwQGRxQMY+neD11a4XaFM/H4ES70mPc9NYrmplvqFKFZS 12ziI7KXxS1w3sFGPtdrIX1rLXr6uRwRCvWI0rGuk0jSiu19c8i8wN0Ltufg5aQNJNHV7upo mBD1bXu77k+SWT952c4mlY4rPGrQv620jXTRAv40HKqjeAUMwEHXkmgZuxs9z2NJQsX8ElF9 Fotpph3ZjgLGNfuKmsQn+NMtMz3T1C9KeAXT7vbG8LL0+qExAgKhIUHTLHPAI38UQXQUt1hq E+9bhfYBTWlvwHZGPHsvA2tLdPedixyCOdX88gIyTO8fmcrq73j5sk8b76gjEVihNu6uGTFb 5/PBAiRa8tKcq0bgsIwu9SMO8PF0qppzIUVSDt+xQYM9KcAOuszTDYfw4BxZSZ8lCZaiKFYQ m8JaycC9a+6h/XGDtlonRCVbi7W9dkLHPETRRnfjzKrnZ94j0RmI9mFqBSYZba8puZ32PFf0 upu+W787ABxwAwtyi/JypCk2MJTkszn+KMbrsC23SfPkEBysEnoAwiGRS6T6uoKiQMIXwS1a 6VL2Ms5ORtlH33N3lWwiCYhy/rn1nXENHevZU2HHIz0oEOHOhxn3IehjUVtpNH3oZShw4KMk okZJudlaLNOJWn5mTaNcNfDOq3dlJyT3JwKU40T3nXumDrQRptPcqyYFxB93WRYdxEPVGxgB oJCeyu5irQcncFScpZiuEKQCle0Q1NGFluq4K9zRA1RhyaZsuZqkOFTlfqGm3Fa71X/zVP05 DIWjXjwIKMdD5s0CQVQquVnzGjZO4++aI3NF5ueKXDzb5y2mfyBqY0l/+9GxJ44c2QD4cpYB gBeMKzpbqdEiSf2cnCTWHmqqsSl3caUHq9CtsD6PI841Avo3DW0IxoUB//dRKOpb3gEYrGTb GVBknMn6zomUBzKXyd3NEWgmUcigKoYjBAUP9ijrlG46/DqgOfMATisbJVZQvl5S5x5yVcw1 zNt7YHR08OTIXswcjtrwn35vtpALWfdWAqpN4nEEf4iH1kxMqAP1n2AMyh7lA7KzN4ESYznU zJSCYp9r9zKRdOFgVVRD/0JTr9cvHNzAA0JGWig6Npv2lly+eYE/8+TMQUXJgUzASQmhtpKB 0bxwnKHf/00XxWp1xGcTAMTsB6w+yx5a0mccUqI5FMPiaILOmb4PFV6sTNuA8d3KBwJF2tvQ yjN8f3XJmJV4gGyM4g0NgzvMj+Kjlag2vL3F2V4egJsV56nslNL8pDQ+LNcnI6xta2jHPBhB AmotEoZ36DXJiSuy3I/Xn6uZCiQpZ3o209uEdtR3aKx2oTZLlqj56E5Oclb08Sgt0mnakFEb O2lacwu5Tr9EiT/Vk7LjYs7h0JPZ0AcDrVgzg+l55e6sfKPGF4O+D5ACE2iC0GLc72CfEhLk c9SxZLxXimhhgxTm8F1FNWSsoUFl/89LIuOvyhEUp2Vnvn94pi79aVp8y3cSUqkIh/rsrfEK fXv2J8VB7kOSodBEz637fQ1ERr+4uKUDjftskezhReUk0yb5SScs3afcKpEW6LAWh8G1oRYu AULUHyu42p3n0rCdAkQvtGSYrO6N1c40VQLzvDm4ki/4lKHPj4nnrnfsUsrXfJS6+JoWbeqP LtPs5LB1PLJ0uEXcm37Zg2q5pilM2rumvTuvjMjPsIW2tmERofDl+v91AW5yczJhXngYIia5 0qUYFfrs2gxpTw3rfcIV2MZnugpoownBwk5pyFFW5r7eb4ymg9tC2dyHJljkoRvrBczryseN Ee5Tub1bBAnE6elJJ502HA5AJLgVUsY4b5YYOrB3ILoQIyWRPT1VnEMvMt3Km4dvT3RaIIwm t1kiYNzBDZiZEDINhozOXsOaZhEF+oT+5QYzI29oIEr+nfY2647IQM7FTQkEYBPGkKgwCbTe +AGS2Jwa3cH+glvEiKIqrogmaPZcjv8NsZyLZBK9o042m6tuSPj1YkcE7lYkFjHK0XzEsF0f Z8RAbxrjEyIFapifDGNXGMurT1IoKYOdLygHpF5dSYYGQxEYzfmylhqNF5GibCEf9llhuq6V MW+nB60KQ4+nZINrrVKHhoxbK8Y6CHv3ByrpHQBFR4zuYnymYxFXBF1qxeRmYF7fGQB74OwR otdUpZwf/KXE35CmctTYLxLdcAVBmKm3vVfTY+T8Q/Mm9Y43G64M3dVYfZTgOOZqeMOOQiab 9e63p5v2K7YX4nX7fEiec26ljjJwauYwhZ+uSoFuQf06sMo1b/9AhQOsY+WXjz9ZDfYgJeoe T6NpN21IynyksyLOlCCsntmyMMsQiqOFBqsIMoPoREem1AC3W2ajQHYq9NqWi9C6cCSX37Hi luShYeAY9WXoigYbaSpWbzwfZocOCn7TwH1al8D32AwISUw1+mwyKyXGpTddNvxHB7E8OEIw jH7EozEFDEzJf72s5A0KDwnLtQ5FCxs7HcBqb4SR/To03bpLTNPy8BPFZUaVP0ckUcEplWND YoKMn9StfkzrHLWR+aIoAx3R6OdpfNix5LR6slPQiMWxIALcN6+JG+r27jpWnK/gYmAJwLlL 1BK8JSx3WYXnaf8+bfF7DXGRo3T2LKnKkN0agwuYclRs7VsB2N4nDvBj3RbfXtAMF7+1xJUa 8JV7mNMAu+H5WlkTcpEokIABWZ9QRgZVS0+8a4YjlXpScbvamEOwiBnV6aT+ig0+nEt0IKwZ D6OyMJpQJKTmGNb6n2Q4zJE0gRgXvu7Osy8KhtwAuYwFA0fjdBKBshRsbISuHvDjkFRoSGog iFWOP0M4PPk3BiwxrBMzD8HeLI0LGg3sfUNbrXkmIidkEKQNM2SgNAnbGb4G0CDrXc06A7j4 9bw64uV6OGNrDTNZEwn9S9Hij9QcOWSbESidor4Dh0+Mqqm6gFCFeTJSvD9HnAmFy6rdnpHi tJAVBjgO86t0GlJTFgVlauKvJoJ7oxohiinO0q0ryj/TxdGdMylNP4begIvWn+Ss90/gN3dW TDgwPp1beVNLINCI8NPI+xhCDx81VKhEjn6rDuzHqOUZiJgCm9EJmPhzCuly6dkx8WiTYTx6 hU61maadlb8/sX9d0FBAM/RjwheVjkMu+PsC4RcekAHy3tC2aScl7etvKK2/A+ux8xnRTABP FRzU22iSii8qqx8pcbvzrqLG19Knw8V+fPECzyYXF/z8g3BFT6birT3g41+ZT/YYm7aDNJtE l+Jzzo80bChhD9w3iccdm0TgPFC4azjavJrQzetjbbsoQHbz5vTFdwPv90qM7iiJfWLQpP2s j+THA45He+ynPoDo3GzFhMZ2pBkbcDBWnJ1TP9YDMoVQBZRp8U0N+6qThyTNFWCM39itQkU7 xQEmYrYoFfrPYhPsLycuJdTVPqxjdBUrWeHpqNrrBXpbylXypW8F/fzDJ6TOb2oZMyPu7/+u cWwLS3nhlpT3C2lZeQr0SHxK+x2tmEq/854YBawjHXbslB2gISWGLBuk3UuFsuh86oFjJJtf +KaLv6P1uuqgz1MulqxTLuAcY973WG2Smj+ghafXqXQrI6cVtn58gr4RjBj4AkBpfZv1cN/i x1j8lZuzOlguH2Zjbe8YYvm0HTj/GTN8m6QLfF6g2vmvvSnytDr7mBbGBvwnEzry93KDLzZv WwtWGTNtPkboz/3VjzqUqqI5xbuhgCmoyz3qhNoWPYjlmTwIjijrtsxdhwZhjmRynb8JAsJ+ cOomsb5da9lvYPgD17cX7+Y2ERJLbaDG8UKb9a/L5M8/z+eet+NqYdx2QzpVMESclcPNqZxL IXBveNKdzxRw2EdHkyw6NwLLYV/Ty+UHiG6CBVVLD5dKhk1cjmgeD6uvOL4SFcLnYyN7pXFd 2FCRuKeh91Eq5vXq0WwRifA1rB3dK8CGoQmfTZL7HNnVAZr9+ppqW91Uh1A8+suZ9XzBNEr9 8eoDoYPTRFXQapKgkVDKUiToQEkhWZhhzjWj7Z0zoasR7b98E/k6v1M5dhRn9OBFzmGd5Hyi YcvZVvDgIiKdyTAHKTWicTcSgQndFPy8QIR9g71duG1oYropyTwWDcj/o7Ll+pozOYAKi1dI YVe+880A8t5gQXbwmW/lSbGSZMu1WQb/oQF/j1PkfmOIQgqPK9gLVXWQoVuwjsflT6VEDit6 Jvkm48thnFFet/rjgMX9vjOUvZfRcydFkPQDZa8Sm3UtEFukECuzOtMMLSMODKgjXWkcK8Px PdQ9/mQNXEy/tI9uMyumGxGVEpEqfATiGaucYulFO9ZD8hCdn1ZROZXHjPvfa6W0lxTbi2Fn 0eVGeEevqDpSqBAIyeeVsI7+s7bs6MWm4feHiozqupHo+LkiL1t4QxqYCU8eDYa4qsmH3NSr DRfuYWs1ggO2Y3RxAe0nZA1jWTXyX65Q/gxj4UVcDZWUD7MsF3dk0CLDdRMYgL2Nk4Uw4ftj mfowETikJfLpkSE74A/I9y5gZIET7oVW+QRFb3DmgpoAQgDhCJ+842uS+bR2vmeu2KsQ5/jw sHDUM26EM7f0UC311Cp3OgaWnM/bgIunq5i8GCV3xQ4JevdpAId1ECHmpPbI9F/H9Q2KIipp zrAYwlW5EJlVVYicEDj16CGQmv3Qr40u7cyy8A/W/o2F0iEUviPKNg37N9WkuTRZcvEpDhjs UKw7eDohW6cMQmIOdx2HoHHEgSEy3Cd4dHinjuAwP4eYDknhxGIRY1ZINXM4O9zImeSfzNVV uPZg1NZ7IY5ngiAj0IPH4Z8pQpJubPV6F9wWCJLXwvU90VAQc26UwqIhNXmFlxyEHRg3Aj/b 7S9jXTqS9N20pqbpjomIbBhYblvi66TgdYdbFjpoVU/igktUVxQLv9Qh+XANzv7jOmrmSn6K aIkkTfyZQ0p8n6FlL5eRc+E/7uV4p4jYPb9JSm9EiF6xzf8RiRbEKGd9fPfHLkV+iJZbtFEn Cu90FEvFJeQ6UMDE455PGvOyqaUnEWvYtDsVcP9x+0ZwcX8OtrKQaeeLrxBF8Did9A9/I8Sp 88KK7ds539RwNAjW00hjzP1NjBZe5drnWyDnaLef2ZzbtorwuGEnNOpHl9w0n3+6mHA4VQLn A2p7pqjaokabWA/6ri0DGQTGr/Rort+OboTPAioBOvQ+MypIw78h2QawZnPQOng66lTUelyy LHzcQM/Gx1SPWvNmrNyCF8foFg5qV6BwrX9jMm+ipTRuLo3QX+/p0W2SAPtm6m+mCvC0+mGh itaiU/x7hK96HYKLoE0Bu8zDZwtDk/MLde6OQqM32czvoPjh2knStSE2VVJfn3ssWwLVDpil KNp1WfE6sLljVB1/1U5Nb398TEhoIy66Xo3cgrrEn3ReVPBtGuB4WtszDKtGEORVSlK8DUwE yW7MdkjtSRcOKHxj0SDwL708bR7IN0xOxSa+p/IVOA1NgnTgSdPLV4QGugzvvUCD2+efZym5 vpSOPIw5fyAbwrkwnkMNjk+ybw1yzbuJ3L9DxxXVWuk/zIWVMLdRiV/RpglsNjKDGi9S+3/C 8SrVh+vhvjonY0Qp1ajRRJQeOqP8BmyqO/giF1k4Z0QIKq/z28NMnmVdtMZHly1IRFqkuztp pqwrfJZiW8xXXk3nN2UjJGtfr3WHIeokzZ1tLPgUy1b0Tjyj0MZnHHYOBs+OnRUuEJhCCePM Zu4PKpEMEPgt9GnL1s8CeFmhpW1MwPXFu62R9j01dICjYux3ipYXwMscheSKCwlKPAr+5+2i Gf6MW5qYH8VxHh7ZdQwArePnA2Sum0jgMa/dDoU9pb9VRy4gAJtHxcWgZ+xY4PfWSLXJ5VFC 0aSXSgtH+xJTEulgy+nYHVOTGsUmpCo2gzdcHI6BT6xa+a3DnRZlmLXr/xOOMxkYBtwdWnlH PS5fznOhHG9oTk8bJ38yqLYRfWsa3wL+Xu5BqCma13UdXDxfQ4xh4KkW3yML86NiGGiivx1U urikZRKugBhmTCWj1PybJz4XnwYcnImkQoEPfib29FpfSuIIun66m7wgREe7Ie07Pv6FbC52 LFy10s/BOMnHNjfcvzcHTbHykC5yQsTN7yYVg3PJPNySFjy4Tpv3b7QKgxxz/T8nAte6AYUj jhPNKdb2D5xHrDp3C8a4NWpESiRJbhEg7aFsK6HSTnsbcB+wqY/g93cxQohPyRZA9uv7LB+V UZ8b98+QOU+U3qeFkzYvohjm1hKyQ8+kY5vPBUca+kna+0K9XMIvJyiYldhHeS8a/e3H58xS +AWk9s0BVV+ZjqFhKkj11itBz7m5ScCd7HZC/1xbRgeS4/yBVTNRhH/UgKmfm41JCJGyyxh1 f0KN70kJahY7xNc4a+RY/B/uCgarTpbf1okGGi6Up4k1moopD0i8zanGENHRm1LANpAcoXgI OwzvTXXZV8/jfgzta0yte+l75S76O8/V/Ou60Oou6iUCKp3JQ6t6Mxy4UNguIfZIpjfMX969 xvnfpE/6VeUGEO2eMLsGLcqo9a1Cf84ei2EYsjwzadljUses2LIHyiWOQWER6e2fzLzKdBAo fCxmWDGKXyvuyPSVrY0QNzxtHY7rB1dyPNVv3+Jj/gPb/PLK4z4n4+OoScXO6kPA5lgQkO+7 FaasFLAfTsh4YkKNr2TjQ0WAekJ9l+BuHphzrJ9ehP+pbo1TK/OhsdvasLYPPAuwvMnq8Umb iV4inOOmic/YOUp2Ua3O79oQmNdX8QOOqT9e6q3ZevY+LY7QeFCBAEYA1GcYi/n6YM8d16Ex u9CBb47N2gV9tH495XxJB6dsAeXnLH0tWJuH7tSaLDU080Yi/GzVkH45TJ+warzoZB78kRxL D7HoQp21LS7Ala6VzHSFbY3xIkcHRRckVxXn95yTxdpiSCIZ/h2824t4z9UZqCBkC8FIL2r7 EqACDxIZaXRrLSeymhr0aXLGrn3wKJ4Flb2ZfRfscJq9gRMYNDQe7TQ5AKxEBB82EduVZrKZ NuaFXloOsbltYLGyOglb88eQjmDGC7FuWm4ARylq3oeYrnve+tD0MXbemf3mdAUbGgom8Dsd g+s7rejP5wFJYACbnd9ttSYVSakHnxOxmJqWMXoolIP7Fh3TdMXBzvYxirY0hiZxOon4v8BD Ir8NlO0NOf+8G89hAkFOeTcyPEhmOLUdpzBa3cGZBGOQo6JScgBgGy2YpU7DruJez85fmnia bMH2ROqkB/oA8TyHGCVhOMPvFbg82ODTg0lVBAttEJjIs8Gy3V6FYvhqSQ1qCKNPkEMpdFvJ O14tWx65ayMbhgzVXWMiAtiJgRb7H7zybXku2YLY4kUVI3HoByawJGS6JkSwikNpjMaoNKi2 YUrvONHPOO6kS2Et3NdpTXRUTHuNJNnkjoWXvOJSQPNyjQf7ragWFeC6qDHLbaIjb4mARUmx 41uNwYPH2N6YrnuMeSCP2QbtWPT4WQS6rh7TO01dUF8PabnWSPXRmMTB9KRoZnD0yHWMj/Hc ZZsyjqRpzb+ll3ue89dylsm3/GmEOeipF4XlkTMxdZUUbbVpT2RFfKcP7bVf/oDSz0mPmELL D7khKMga1Q4C5W2SL3wv7sj7xoALN+YkVyf3lb9RfLU6/AkSZMKvv5wbV5dbR5Dl1DycRkTn R9jNi4gMYFZDIbOMIg/vOcK8s63ZHW/zTFRF+49KH/z4YsEOOZx1hNe3pSJvMh6jcyb0iAtz J/3yb9F29JagXZ9Fdu+OmpyIHPw1pLhnOKTyAst0goCma//IOIRMPGuubaSFOb/EDYvO/3wD U9ADOzcMDU7nSX4xz8NwWIJvQLCnWmNQJ/0ZWnwdmGgU3P1l+pdi6w0HOsfmRD0Zc+ZUGY09 dVw7n/8xrBR8znrCj1hbA7DwwutrXtNWOtTHypV1nb0LnCJZrfiJZKgX3wPkjrsdB4Ui/w3W 8IpDwnd/tLK7rfPiipEF4EmV18e1q21ZjEfrKkRzvWOoGarzb4K9egYHlpE7TOFRX+6uNdHB Bkp74za4XJyclc45g1wXWN7RZnd+oWjmSkExyyhqB4MhNxQDKcRH41t4DcNszCspTE3AlMF2 CkP1LL4Pr2ms8FMh+KXAK52FLJISPBHGBJYPPHUW2bzQbvzSBL9tb2SFCkHw6Qdyyn6XFYbQ 2LvB0eHbPCx/9KLRjn5VvwbCn/1/3GCE9OLL5mo81YWNI/DxCebJBOHdTkx1y8im8E2RgXmi pLHy2tZWwwHo/zEoLpPcLsV5888qi8o1RfLT5VAxNJkUmJEId/Ejy4xYecrNPxHY68m54UYw RcNTmGywEwDPej9O4fxYTgihMUc0dwM2hCgYxZ9pxfMv3DFkZFkCoHoTBEDWr1JrE9IANnVH KUFxfoApIBvl79w3FlAL5ZAHLuDZCDELBkTX35YqJPSaW4oDRsVh+tl3tzwwNqvoymQBlJ0I /i1EwXB8dMt3/rNzqfT/m1CWPQxzIObQXWJUmF6ofON6apnmghnmiZome6vjqkAk+i7HfemD vnFF/K0tEPbN7ZICMshcHwDZFvck5OQAevy23Vb4ao/8gzfBL2lSnutp2Jgqow2e/r/u1cwb Gjb6w0sZ9fj+IVCS8ID86pNZJdEAZr9/g0GurpzYfZjVZnwBXiAZZbgx7cmbAJ96A+mRs/On rxcHtYVXMaF/xqXitUAhNKEwn3ZW9/lkA2GbbRuAKFcHfbIFILb5c7jI3zZbFAkiJP3PWbXq 0xNjAoMSCJfa1aviGQGI60q3l2k6cxzED72W7gEY4BicOmKsJ69XaXYVpuZu+7sCq+0YkaWN dlY2uW5Jh+ENEEO2m+SYkpRa6s0bx2YnHq6JH6j5QG8FyONW74CHdl172RbC74TigtKhmvAa 7l91oy8MX0EZIXoF6DC0RdYlW8+Le2x+vr7EPOnZ4DCSe5jPjZm0eFooqaEFi6iEfIqj5SOO 5EVkM+2wgtTeHt+nj0BxlvDuxv/u4MNTLW0PMmrwe0GrvwYBbam1/AUH8OCSVT6pvCB7nwPh VHT6D+ghZrJsi+ks+QmmdoiQTjkPGpoKmkYujdSxNH/jF8qbYeztpGxFGIFA0dhAMC1cGg4S 7G1I7ykgcu4lmG96A8TSKBr7jEnfbcgM+RehKWKjkWjDHc4HRUbSw1s7ibSffXC5JLjyG44k 8CZM5ciVpm25fBJDPNYeVIcn4ooDXU4MvWFS+kftrYdWOufEaTzScEqhaVGtkZKU/bnsFK9D 4EYgD/KhAlMyGx0BjErgqYqAYNmuPXtKdNJ/Eh/fcDdmL2Aq44/72iW+qhnkTIywKXSbe8si c6bGHaLueKKGCY1K1UoV3H44RscGogkMSKHF13q+9telZerBdBj84WkwrysKglP4zHcdVyIT FaBUId2sEZ4nGG4DOmvFZhL6xKK3XAz6JTs4Pk/RwQaQ79Vj4Sy/5VBUADQApxGDPxPkjSIv VaR0CWxZz5TnQF18ZQMOdY2kPPohmffoP9Zks0PLLzB57p5gseurOZYqSZDPTipTHWfdu3mE 0+3mY4//A97vNNkC3HFy8ktztQpjpRg+UyGiDR8WlmzPrChgaH72w4rHrgocZ9ayop/xNmfa MxgZ+6okh7X2Sf5ZGsskJCKGK4tdittwsvU/NV/mjwUb+3s8KVW7EpZ8T/fVP8WbPljdZr3k Lj+w04oIoWv3CvXexSRoGEd7pIYW+XdhgitUMbQxVmkWxwojoqNJqCpxJJbTgU9nQSFnJ7zl v4YXqIXuvBDqhFXQZPdBGNMe6mjFsFndQW5KGVNRkjZBW2k2lNEfM/HJLe6thjytTO7bakld aS2/Eu1i+yAHCz8yqmrIvQtzVbiYomRK4ia0yFKtXEv+pMbyTRyQI1wKXNb3Vn87HKx9Q8zF IjQ0sGu0Nvojz0QfLn9i9N0Yc6Gx2LgfRGxRZJp/N6YySGVQ1xTF4ylGWYgiktdVbcz/eFAb C5URZ5ZKK1k/hz7nfaNFYg7sgxI7GDiD+HycEGGD76cEPMec1AtvmrpTwesYvg1OcUkRrjfr Q5aa0kv7M8bXENZlONrZTSueOJjDxvXSfiFV4CVtv4YuIoiqHnofCh9PdlElNfp5FbMLvq+n q2/qM6SN/gtqXkhRayi5+3pFT55U/md97H1TmIbbAJgqGLZ6k8DNeLZwJi+uOry5anW9Vo5t VUnYd+Mx8SkQ8U45TVFXVbSdJNDWBvg+dHzXQyeEZnV/Wv+XFrZoFX9nh537GXrkc3geklb9 ntrlxQox5w5C+4kY3H/cIsszJUt6V+B8V3AouPjGA3yMnEaj8aOvO2yHUV3DOC6xMi69NAvr JbR+o7IhhF7iRdlBalk11ucd5QC71KSv6uQqy0dFjHfAVU5QsNHSMeH1x0m/eEAMBKmlNmU+ VggjV9UN+OkoUsQsql60KZEv48uLm8KGAwLc/MNquG1269B495stwNTxzrrrfiy7e8vqb5As o/EkfZbxkupN/FHr831LG3FRCUUvqXFQCmG6An70YwQwZ1nCc0Om0llK/8C07anJntkML2Gd 2KfC3mIML2fQXVrP3lbl0DyiKbMPNTQG7OMxVkqetztdz/FF7rizqAJ0MlJGpG/9OAILMzFo NaGOtQ9Tgmu2xJWrX4KFxne9Gt3WkquuYwSM4aNA11wSo/2ngvdkisUsM3Bw+L0V+UI2dU+T 1XAcnHhH9s+znPJ2PL1lDyAUbgkyTIhtoh6oSMu3p521iOtlw0xGZI26DUyBVW49rTfmR15J 8eQdLfCApsUHMkjVvciJPNs3toOCbpb2aZekJFJ7ktMXtc8gRqcv1l6aT7H3pMb5ugxrfZwb ox64VVcYSuen8l9rQRbLxanwy3WQBEjaT7Ap3hnH/A2LviDETkoZWDR5E/cAYrREAfgdgSmg soOyN9pBG5M333B8PPUoCJuL7PEDIuQkOYHF9zL8ZhJd602bkj5RPreMOaDlf3KnnNN4HlNA EE6LA5TCum/WKFgdEUSQNupfGkbTjZVczcJc5PK9l3JUYg9Kr46wDnwraTqC+VGU5UN4EIoS M5bn8mxErGLc4ISfHQL3hKE+XqeGbjM0Kn1A7KKLN97SCAyusqJlmGOJSw/vxwYchpFp3yAQ hhlO5rgzqVtzqkGqUUmJyotMyHDcs4WpJ+ft0Cqc/cQsw+U/jCKYPS5Q1Bt6ntETGEoD8msZ IU/7Gs4/TthI3i6vv39+vJrTqM63GU+Par4nHsvWU4XyZ2//0wii3QeXMu/xiTi5hZFgmdRH tFemPCC9xGNQEVJPzzzwBhb4s3sJJGFEzdMzZOHTFYRyP4nxzyT+T74V82j1gXeKy89iVJ8v ZYpBW15JvVcrwLtwxnjnbzYvsGZ0CfrmB9YQV/FZKJF2xKXQ/g25JLI51/sV+CBRrrPcI2BX HpFhsaSoSKBjH/8Cr87ucln9KW8kyw2wz7RXq2Eoq47jKf1Pzl6mOWEItYe/4h5DCTyc9k5+ 2ATfR4k2nDlSqpQcS8Br80ziFNkQh81ILi+LeyUNvzXwXv0f1LbGxPYUTuQ3yVW3hRqsknvx c/HzI8rPcN/yrTtOSjuJmPnVNFElSWu0+KhWsmz7F+pUQC76xoLqc2Ch4MEGS3PJ3uPpL8aw 62cwVf1S3ktMzBJZbsMpyP/G5AiP3GDicswOj12QBj9OJRhvspCN/FYl9Os9LzUzLJTvL3qx SiKkJlA7AOSAx1DWqiR04xWNl+XrPLQ8OlV3y0bhFVBI+mW0Km57dSJyYMxAmTJkI0asTT6N 2ClExTs2zk2e+spr6kPQTHGk+pE5OWSANdSPY60/naxb0DbWecs5SJKayml0P8HVXyjT4Box N2JodBPdKqdAufzVNVR5O8SQeyMoZ1DzLjzPzYsPokD9AKuf+0I+nC0VbwmBczNVdkdDSurA RvzOwjwf274ALFHIZ1NplxrwLY2Z7XuBUul35D/dDremep0cQu54/5ChaKP3jdfHoU35LoAi W5VtevuiZvQJ7Q1oYIRSZMg1fWMeAmNN/WP1Z/NlhKOC9HWNApRyNFQY9lXUteULyyfhNDws rFfD0HCoamNeHvhwEieQ1fdGi9/bG3+LNcBBaxkQtXbklQKnn6awWh4BNRgVAwt63U+FWftm T6SpEg8OrfZwj+krrkPNdb+nV+CLhD7h0kL2u2aFAEIONhCNzSPvaw9DM0lv5ZoARwvd5vjJ UZpSHJI1MxpDozdgi1tgZa+5PPoopcuGz6Y/jo7AA2vmC13FdfCOwVtukiJKDpcw2CPEI2sG jD5lHbZwNrOPBNa6A/9EZoGczHM5Gtuy6EVVIzUjuB0MGAKheZSWUcPIsPSU92AvQ1001hLl IF4VfM4MyhJYslAAcxai/wmMIEFyw2z0LSRUwH4q5dPS9zSySXnZw/8ZgNNvvC+PtEb6SU2/ +WkEv54Rq8WpvzgJmzc3NGY8fKxwBovIEjI0Qdjrnp30a0Y5UalZrtreert2hR5qiirvoMF7 Yr2D17ZMpvFiH7y1wyU2EgBPJVYYWRA4XONeJbXx5UCnjj4/W12SwNFh0ABPGtaH4faNdwO5 D1BT0oIBTHtAT7RNJKtCEfMVkShjrOGTS+UH/+ZAadn2AEYtvhYFp1oZatDNsKRSOV7dkyq5 JGAmUq5k9Tad2DJ8gjVlEr2oT5iyJt2EB/idJoQ3opkQ8aAnJV7GeFfA00SJaeTYl0l7P1ac HJMQq0IH/+CAUcDWa+7RRO3y3S4xXwyo2w3Tz8bUeXS4HxVRUsYmmI+XNPUEnV8+zq9aSioR FzAXVqzQfI89B7oGCsKdATNsYneOF419gZUMifw+IDjTWMvA8Q4xAGMgiLmzHTssfcBkkPZY lfyAlg+nGr8YDQCqlrvGenSAGWzxFZwLKZnsDEeYNlEVZcciB7eQxX3ui2MrI9ow8jmv2ICz PRj1plLBwtWYxOUt/N+wSQE1Q9z3yVaGsFuQHUKKNaVtFrBBsiVfOePecdEeusioNyGE3pyn pcy2t1vR2nqQEhc08q7au71I1wpCqqcL4+sNgD8H5EiJNSkjWRyyfKApBEYz3z56IB3B80B/ lldSBn+9WQ8gCMBO6Y0w74zEcUhBseylbsW4dsTYVMF6qPZipKVfwksKOzp28XwVmZkHnPnH cPPx4dSpWAC9eBR7bfAjL3mhXijvOhxPP1CKFpAQOLcbZxcG3ii8AhQk6L7tj17CPO23h/NO s24p8yZe337td0Rk/3841jIBTl/rNQkC5dhuHMF4fEZw6CKzDp/OxKUYSuW/Qaq1QNcQJZap zmD4XQHysNsH8kQHOYadCnqK4pb1wv+P9izErNyz4lZSLRzKnvjvFd9nDOJFJHwBJNVyYHfy 4YRzf6ExhWhQktw2NPyK+XXOOwbkmrSNRTuOGk+4rvu/5B7PqLVfwDMoB63VkrfWep4ScvaL daxhoYPXOMRgTsFtWDxAZ3uI5SP1Bn//W3aPeXRkj3Ikf3Ygtfhk8cYSa8lo2LlHDQJ3LN+Y gCokV2vgk3mt7QsW2MoDO6tSeJakR2XPvg71vRXdWPuazYNETsYfqRhh5O52sB12fJGsSnvb i44+P++2mFv1uA3orUcQdmArczZVOXd+NK+8IX8UdPBQMC29UISvrVMJt/CpzSp+sBoBnRvb VZE5N8R3bBBGPHtzwHQwyzks25IDRi/BMCsdAYxgrjA6ucD1Qom3D00rMu/e9P1cR4WoZRhc FdmWoWsGdyUmHfwd0gA+JD3yGtLJGhrxcxxuoBLCVi/nO9Bz3wc3VpAH/KJOJFKDaB+N82VU ESPwZWVwZxHkjqbQWotjqQthSVRV59YI15t3N2ubie9yQSWy7rMrgQNeU0/p2VDRS04vag/E neqeoQ6eo/oYYU0XJcrWDsD+DZTDRtNjYddxtNz0zzrXaA5TvGvn0OaDkNwg5vRsQTdi0q4M /oJcKBeelOzeFTtlMzMiWLBmRha0T5ZTQQiEv8X2ZJnXAJzT7oD0d/GwcweG2fT/MKf2sXLQ y/ALNIEZiD0X6GLLZ4x8dQt6nJstcX3+ASF6g3BZ4GVKWtNl+J26STBmmlMb0/fg6HpQCYQ/ EwP1EXjSPmbx2nyvPtOtPZOewuZj2nWoO5w2CF96wLAvZoNXH9B/jFId512txV3Yas8eHBnX gRF4wZx7iEOTCWN24iMqgKw7r+VFUO6FEkqobXY42EIfm8Koj0wN6O9wpe0scrLoUlij0yq2 HRto+E355l0jWSAHLtEw7oiqlaeaGk438p/t6E3FbRugBHyDHNlul4AvTF1ZBOenB53+P/9M 7nHjsxMopcs51ztW0ABkvsDj00ff0VqyzfnDabtkNXB95lpcfHWAfAbAv0GtpPdtLVdVVR/v 1oR2s4UBo1Nyys92ZDxLkQf9Rgzq8a9ZGK1KU0rUzLdV0TZGDOQtguAmKUTXubhxa985Ik5F 3lp4Y8QIVmAgUVYcB2eJl1ES79pL1N7bErmBzxV6/vmzQkjCK3CpK5dDNmE5EVC0bhR19pPd 8ys0mISY1USgOgnqxfsjkRNFhwoh85Ideqlkkv24JZna1YQ4AhVPikLPu2g3gOiU+fK1ABYo 9RYxj7JRtEIOw5sataHfU92xeh0VqLYgWV2QhNbwpJsUg2SWikaFiDeJCE5X9quMlQcosz4H W6l0je0BBbLskxXpq/wxYW6pRDcf1nv9ytNEnquh63N+HqWvsElwDOPdiD8y0lNy4EPiK9U4 VfXR8GtgcLgW62wMEQEPUEfWKJRIybZNsVUMLeRt0v0hT0Sa4HP/y7npYjUK8cdtr9FsnfpO CRYUiKcMd9vaGqbcIUbEVU6fZ7fdT4a31uvRIMZ6BZoBFldt/ZuOzfWUubTb/Hgnh78RBmdx oVOUB+HQDXZ8AK84xqJPAwmvER8yzWk7I+x8AzcTnh9KwDHOVvdtX3pJXPQH1ZpVygd4ndub abXVP0q29mAYE69neZEhdmiPLrjox3AFOrDbdbb6V9WtXvmVhTARk0pNwbVBcX2G3Aw0B28b X/VZ2gYjn+dTfOUb5gHCogZpzTCpVa5Ry+wlvEdxnf5e1dJz18xzvBgGPVr8hsmOOqMHnnwO cWfrfCt3Uy4jFcYmuQ5aLCwYTvqWb0g/7RCSuMRBFqMSGYckXSwECqDBRpL+MUIuiIpjhP4W Q77VjxcQDrJf8/OCGL+gSXIsXA0dr/RGmA2xWin5AL2063TUuvaBkS/HuroZsQprrf8C/Fzp KTv3nOnRfxtfKq/wbFZyDpW/8nk6AM4kMCW9pKCCuGnHvTAzJZxySLKVCv4jSnf39X53R3av AN2JrcVr7jWTNcoHkPrwTSOuGRrtt4lSn4IiZcBans87u5+uImSODJLw9AU3upvm1ngfN9Ym /O6V5RmVVT1oc1UFUM49O1jFLDGtP/oXgehg1+caG6FC/TkOnviGx7jyBQbuo24ADcGy30XH zRydWPNjPMbygq5RtMdz9HTIm0yt6NVIQjY3z+EUoHWIGB3uxm9WpfcOdb4GO9MR+0VnkfRI 0EdB0clPUto5yTfF6wsNiKUilrDx7uWBfnB7b4WiKgMABml2tB5V71wu717bl6q1i4y7wMUY Em+mgRkbDWOoj8SGUOyyJ3M2UqtIj1wopaFyORgJv5/7OEGhGALOtJwM04pyviKTe3drDsU1 uZL2CfsEcSz7y9Mb2NO804111bKr7i6hONnSDaMMkHiELAKal5Qyhw07KznugXmlaSjAIRA8 /uZKxivv+SwhYiJUQJFQSPqG/VKJV0GPJmTMO+Z1IZjgJBbg7aW9eHGADJ44YiACg5gu2Wxl k5T7EwweuaYPa584HjyG9oCuLQh179iQP13+WD3/8usSxn9GfuHFtWcamXHlIqQI1vMuXlAc 0wWj3aSvl59rkb374+UHgrWoU9bxhCdhhi5l8bvCDmooiHhIo2BDzRtiTggV0Ol3XmbfGct3 EyhwvHFEC92NiskhmcZ8kHlDX0AxW9oVtrwGpw5DhYlEa7SpmEvbDfPKDQj5a86lLp0cwYy6 s7GNyyudY855/AfGmdIynFpvdHBosK9ChIb/IECGjeuPGWSoLqq9qzdOeLlW5s+z+EhWJ2yd SNvbQy7ObN/xH99CZCduBI1W0G9+oo81L5X6G6PGhUgrGlQoJzWlOODD6vswv5rkYrhULNM6 2gXciqlszAxF9qhavj9Kl2/ILBAKB3C14fTFtG9ub6FGS6FforrcMBTP34tGxfnOgVGpBSZp p6eCGhsXprZxaR990JwbbnMf4yBxZUyCsU3mgQ+ttYAeqDRWfP3nP+gP5B2XSHellaoxtm72 sbLdHcOAUQDOqt2in5Q8iUpezbm4rLDCXfknhXt2KuAUyeWSwwbZt/JBga8Z7YLOagX1aRqr Qgg2YRWlMbcQPAJxAJmdeuvPk4kPLs7eUROP7iWayPXIeM57rcqJVjVWgG8kpeL/OEbKr9b7 0Ae3btIOdKR/bmc8E3UywoyVy2lBfdwaZvCTR1gAwzEs2bPgjS9ZnK+UTebC5mjKOyE4zaIz uslGctMa0NMt/ZX/fmQrtmeBJ6sNFaghgVlADxhRgrwd55GIZZ7DfAl7XHhnaG0clVQtSZFV QMhQtuZs33Kd+bjxX0jW6ldbqBgJRPnkNaE7x4MPLQ8KlkKwlYJcF4txLosnk+hITZHmPzXM MV1Wp+hSNUBBFsBXW0VfxBReVVSoXSDqD5Qiq/eMQ5oP9bx5i2x+PO6clKFb/wjGtlqm52bY dxrD1I0+D/FNec7S1RLy29Zy/m1eRdS4klyQlOiY454EkxoBjLj0fIKchKvzeAvs7PDjB0OJ uZJZ2lTJso/4Uk0wVnIbMbdO7reUiDD1V/SjxxgIOnl0lC0cCblGbil8aFgefi2iQf8CtQLO H5npTn4Vwpr2U/Lc6k3157BsE0uWPdbfdaf2uzTE5as8a5X5yQgzW9Jz6QRi1t1QwNUkCCn5 09dRs/wdHP3kIDjWx9eGfUVs1+ZqRw7CAA/H43PbJ94hM/WK9CWCtqasliXteX+a2TfvqWmj JHO2ucfWWX0n4ZRAJ+UbLILFiEhIwZIrcTE2jxYCEQDnkkTj+ZbuVGkAVZhKGC0oIE4SLyDq FY0RGB82meuiDmmqHuivFJwlYRTBnBcgXXe5lLn+myGhjLN4GzBlGexRigknLwYb2iGIuw9K jGhOtUpd81pArw+s/Lklofmrjui20RK1ZkxVgb3Pjlkb/HvTWIFnHIPu2Z5bPEenLvMWzswh Pv8qlZ7nuSYirZ/iWg+tgRdplyUZbGNWuaR8m3sOreyVIOvc/yVSo5qqubvNWzavApLh3nFm 4yGyJCimW2BQibYKXrJq+cxRFD6huKUAgOUUVzKJYa/F1vv5uFBlWg8HV1Td9fdSlUzM1exD bkAbtAhXdiQC/iQd/XLfo8ScqXDfd5lcByYpj7AfD0sjZSQcoa2F9CjMaostBwrfUeivWwia DwKHFzkD3KEgfsCfJnuisrhKfYPFJpAR5BOHLPecjpyEp2G+piOUeR3tyktSURz0LSdtk7y4 kmaUPdHq3PqdWuCQ8OEvklFQRl3oH2uMyiPAJgK9qQkdUb6zMFO1Gf6FWDyY3VHkNTEp0d1J dTwwpnBbw5B1s6bmDnwZ2aVrJQFqFe0fGYtKm0A73UXQ0Kj+8Zr8PibkttIpI4zP2YxdiGuR 53TlzU/FypqKwkdL6QvduIsGff0F37FXS5hqdXJcpCuXspqZ7vAtylpLVCiEXTBE09XjSs1M vZ6fNblCGWBnUH1tZvBOmOS7MHNNCdZPSl7taxTuKR8paMrwKz0P0cQ2Pn2yfsYVogMid8Lk 0BomVMWLMl40e5cfrHGuIAeO8SrUQYrByh76gfA2jQkhpfkd/nJm9YRu4OshhmUa9W+fJ3rb 8iSUSnWU55/wepez0tYvRfpXX4DvpjwFiSx9vqgvK2CFsefpkX6KnbsSWFsbs7S0RsArn7cg ggEzYF3P8WNiHi7FxtpLuLoE53Oqpara2h/V5fPIPLqpDj8cgIAt1wqbAo+R0RaFipHay/A0 m1QIaOgk0JH09UUMvI/KI+zEFyE9EwBNQQhixQOvTOXA4CgO1ORyNVCG/oXkO/yM8h1tr0i1 xTOlplCyUb+lLykOwvlH/K3kQX74zvqbnquqj9RzilqsLKhUw5evfU4vvP3Ruu4CJpns8Jod DyAf2Cl8iwfRvxqCTv5ur/MsvsnacPhYW3a0CPGvXVTPrxUMkA57tMT+7K/heamSYeNPY6Nj b/xFV2gyJGgq5GRonBRTQXrzhki7dURYmD4Dkl9UX9cYN89TFifcy3rXqX+MrBb/oTVqaqJ+ RDCXY8Fy2+pmsNOdcyBMZ6xeGrRsuvxm9vnLS6NVGlvBMBbrDVpyBze9rGqVpFMffCurYOaZ xISk4ftw/uEO9RsRqO2sl4H7uGULQEed4GS+aEmT4u3R+jlVy2x/WmVdGfoAbb5311QRNmE5 i/OI0ERbT/xCkG7rG300KlOQxfJ3AH9McHbB1VViqxRq2j22Mji7tw3K3qzGvt9yCe1QlQDN vZvh31Bc8iVPr4SUxWGmV1B3nvq1rKH6Cew1bu3ZVy6hF182MS34ooki5pqV486vDaDC3E3z JreKjZZ1QqHhZqkpWjcpCq1sAkrsKkW91iDVHR3aq0PH7p677p7GrjR8v+xJmAk3Oqy5YxEV Tc/McR1IR+UtnZbcPs68IG5Z20wqshYjD5d1sOu4BfO+shgwYJkufAiwntlmcwrkUe446WH+ vG2ZN8HyqVWF2E+hIznpj7NuPPpLuhLwdKDYwSZY38q7Gy1ZClZq3/jx7CpFdJwAPc7iqtEH bAhXhkI4JfLkkV7c3VNdwvWa0BNQUbHC/Qndj+r/poTC6Xnq41/ZcO03Ycms2CZPXCx+WGs5 Zg8qQvNsiuNseiTT1Sj/sohesHIgUruA4rinGjNXuW9qzVUxn6st3tOVNeQCbF0w0deNtQNw 1NQ7aVefC5oZt6v+FOBnJIRS2+ySwa8VdG8ioq4n8V/VyUkxxPPyvA/RPQX7TgndtckOM7PI PibEvf4G9cjduqe+tNsWpzEv30y9XdfY3lK+cCl1Ep6gs1F6NGWdGuhHipbWxI6//6IG614m T/Wg7iicY545eg46Bi9nbGUf9V0aohop5DTh2lMJthX7X+VIfo9KsCPrdEbRdSxj6vtVVjBg +VdQ0ZOZ4SpunPWBh8iTL3TWOykhc4O6/cGoEq30VTvKSqEjxmxjXf72mftg8pLOsQPggxE2 I+7HhYtPaEhJblHYLw92nVmEIA7Imz7q9bErf4wfI3H18b2DU8MpG1qDTfPftSoE5QfiXpS0 dxNlsZd20mCQw71+LhvOS43hFEY7QrUNoNB8sAFExrlHsBlPy3XTindORFCd3HV7uKvEBmQJ 7JGdRm3RnyDlIeKPL8egUeUJK0o5lFTcFq/+z02ozULJlu65eVZ0dimQOPF3rpG5bmR90v2C 32cb4HMJHNJxWBb7/8CDsJXt5+XEEHR85scb1JjB3WxIZ1vfFrKlBA0LZqd107DTLUE8cHRT AzlqfmpkWx95RkIcL/JtjF7W0cAHQ5K1N8ztzrEMGmZT5o1kQCPJCbjQfYSAMfyBm6u8SBLM s8aE19DCgVHHHFG6mfT3/dR8NqvabBLRtLaiEcoagcE55M3TcCBnquedj6vMyMk1JJms7jdI ER7arX+8jTp8xIQkrCAt+gAV8E3xbWVpyGOCz0SrDQS9l0atwe/E190GYm/40cOdsGiFSRzv yjACA2Qn/mTMGHsNQwFoUgPEf4Zq39d5vB5rYXpaUqN7swR//Wzu931yS/U9oFQYNCsdqunZ e+Qy0apvJUzo15kmJ07eiMMoVugdy1X+Ojpl7WWd89Ji09odEktHfNU8NopFkaGFa5KYAsxB 1erUrCSMrdlJLjP3+FDVtJ/1brmn/YOADQdWf4heKlIcE4UwqqHpF5nSCNi9mRMLW7GZkAOT xws+ZYe8ODyXH7IKlPQCZdIt4MGLXYGkMqdjgEitvOIwTJRBYx2/u33lbiwimZ6TlrAYtS1P SGCxeGce69uBB4NzXNgun+6605jmJ7SAUcueQ9NHxDm4ouEvdTzIBo/2u90Dk1cD1BF/UO95 lMHE5Ll+b3qg0LwZz4+vB/0/zqyid4DHFHFCqOf5rOKMZCN2nL4KkvGnSuavXqRHAsE4XYEz HL9yYoab+NFM7c6i3L0G5ox/4nozk3hvUMH/dfIXbPFRyNWykj910wL9uB1fBrFCw78IW4lA Vcd95rOVBCHrYlMGog4utTz2wky3OGwxNBETq4JLRQ030XebVo6+CXEWxzv93mui1fd8s41E lKhNc5CUrqVaDqjIdoH9FzFo1rMD8mF7Tqd+8aCuf4sertKCSFlbyjBOVY5K+0oj4FTwzaOs AYsA7azdYTnTB2kuuBXg17Hrmp5PBSHoUwJCfByVn0L/POsOm65KoJU0uAGGKcyRJzE453yt OYqa0z6e+0UegtG+qZoFYAIQeCnRcBDWMO0veE4cfd+zdMV4bNPU5HN/Tqqn2/5x0Ij9MtiH 6J0axFaQhba6qeMS7QiFAckGAbuqYdzjCOGY0ylpVM8JgAp8L8K2GqLezA900C5TchAXNWV4 mdqO4y5f41qjNAKytG0HklY/bqUYoyyo6M2LtEckf4iuUDq4i3e2Dh9IGvL14c0X1VYuc9U1 ttCwvr8cog0fX4wO2u2bGp0mTVpLlVZXHsfeiHbWnfqUfHAcpMEuD8H31ppgOCIw7ndWMhrc lYEVqgl/5Xws00ORonWwBluzDzQm2FyUICr8tfDasXJzyoiLbOQ1v0RNdM5txgCYv8uQmG+u l4KpVEAQcuUap3wNboqb3SP9GZVuH9uM8ovnDWt0uV/akfNFk4wrAT8S01N1YhQADoZ3bTZf Om0C0h6NE0PCJHxf/+qvFVmEnv42xpTPDfoqh3kdc+4Ma6JI/s8KnjRFQMVMlebq4iBhKP6K MPLRVzsML+tmPm2x9k2MknNArna7ra0FfTa0sUcNAY/yPm4EK7U+iprHZc1d/FZBK1UCHJJR QqBAmMVyVs8W6Kp3CYn9dvGw/HbO2MrqZRfIwshXWgd16RYF6s9HhvOSTpPquxs4Z/r7ylie 3+O7HqIBSIYAvyDjJZdUxhtlUF2Fz+l656VK+EloCW/BOd8bcSIHYwyvuxIFXQ8VxZn+7kkp c49NQfEEPP1YpX0+lH/6AObt9/+fyNx7xGAjkcFKCyFzqQHyVkcdmUeeA65Oqnxk2+QEtmfv 3vGKLfeA9RpxWaGOV2eaa/iDrUu0NF61fF+IESzugaLaXgXFu496I05RfboDBOXBrwUrbFto MHrHvnRUAxY1LmjrM8RFjDWhTGsqbkwwbVxzX72fXmtDoEYPEdD9v3QXRdy+/w+lWipEnFUY wS5u2/Li8vrvfv1/xJtcWLo1AOODrZvxIao72miX4j/oGhN4sL8V/WTNsWFB/ftjxbYdrWtl 8Wdyc6nGdTabySPeDcl1YDpr5VKF+3G3k81Wpx0k2YHUcxNvtZOezGe0rtxgoUFvIzlAvvnN Zm4Iqs3kzt7oXKgiOGs1ykdlHc3U6KXbQpFQP4iHJrm6tnT9PZIQIDZSgq+soaaUbwuJcvjB J4F5ly2vYr++x7eino4FBW/FKTZu3fHu5wv/631wZFM13MqT6o5NhJKxWOTbST2PvxDDuCq4 ATDmln8pRGS1Z1XTEoInisUOXmyrAukBSdcucR44/lpP2kb8CfVCZwqgtUwfxVVwm2W22+C1 4J5Bh5eGEsi4D0xgiAizcmXHccNqtybJQ6YnXGbADQBLdvasv2Hae2vNW7PqBzkAoXI2d8N0 w1eGID0oY1w7H43ovW9zcSlojVbpdSIYgtoNnAljytzdHO2ZmyFT662NLB1mWShNDgvpGc3X 9o6KviqxWTmWNj4NNxqz+TgJBaAhmt0xg3VYOMLxse232BUcsfzu7AW8Dc9GzLZbErfqDfsu V1RVM72274GNHd3H9CX99nVWl0sU+nlQYgkQ41Gixl2yt79Nmrip5JedvBvwi9RwyfhSkqxU oc29/x+S70fA67EqkK6O4pA0xU5pdLp8o+EZOPNxdW0yEGyB2AyKm6/ET05UmUCf81jTZOwN eNHeP+HbSJDUAWESHUEwZ08sKy+7L0LA0IXufQ+uViamD6tRN1HiquY184TWwBDPgEEOZGA7 ZA/NRtpjitnubLzou8ZIAWT+r0FdMfve28pXxThjQD28qDJp+rEgW/QAqeSs6yMaWjZPw2NS V6KqsGQvAk5Q0LMpXXK9X/pt0G5HX7EZ3iXiEwfN78oPhvz2VaB7YMUVgcggC5EurKV5Emuc Jc3GcIhFcQ0kB7t9fHNSoGHMtQaYtESp8PlYgJzYOBZJoNy9uFs6ahID4awNoDrpyX1TYg28 /HzP0x9AWKf5VdQPvPq55KqbVO0ooyafR5yTwEg1BfHuLdB5x30vUo1qbirbWD8lFyLMYm5x S3VxOvb6LxNrC7VOHq66U9UdXos0UxjamdTMT78O+ZCYD2Rh3R/1xBGKGIEl/l+RH4NVa9A9 hLWmDWogI55j27O1ADcrFDxZZ7JVEyeKJLIihIa5NpG8QJz6M2ct31E3iLRDZ70r9p+TLDy0 7jz+sBdh/xpxm+SiBHUV4wrgAxBHQj3c1l2hADOmRDPa4F7qX+QiLPzaoWrP/3ccoBr97hlB 6cCZtTxh57FyWV8Am0P5rNGGNIe+uwEBWd+EI9sYWbdpShlCy35jAyAvNWucPXZj+BZKCguM /F3DXqs37r3HeBrmbX4cM8RWsL7NbRg3rI6OzmtBjUxLNC5DbySOSTDORLcGvAyidQfDdzUT gGHCM4Od1CFe9Cv1QvKdJQ10Ktc0A0L5sQWy8QddufmW58oqDcz8WT6WNT9WSdZaIOKJ60X5 5H8cliL/dVSfYXy6k2pHxlztCIt8+bh1j2wiGHz0z7NoZLVc7AuaTRzxz0j0XmTJooERzYDO DnTfH92JIBHZIry6WJ1Uu3bUxjzC/RZAUAoOhetOdp16duLGg3YFo+8V2zXTtr3sGqZW943S yd2leZvqdY4MaVmonJrW3NEZxlUHV5i8kZ1oAlKyZv4T4wjGSNxzvvNmcUlq64d3fsDddCiI wQ8OKhNOHLuOkLscCOO457hYL44R+LjDp92KNJmhjpGvTpRtG/Kv6s2w1nKJ423BjvtxVFOT IwpaN2Wk5SdliBp3UCLriq3Qcar/nhK+SX/hEndl8uWU4Uz3VPQJvVIz9JsMUKsKGfeVSih6 mExPYDnYFHu5Lia40Ik/o16yhtZ/mDOMz2JSurDdoliQBR4gTAlhbOv+rQzy8tkVGobqc30A SDB0Q22WOvFReC/Qh2aCW4TGx09p/IbAEPIogOJ6XTB+HDCh5EauuiGoKDz+NRLIAoBc4Rti mqXQi/5R6Y10TyyEmYHeEFIMagcyZhKit46FG1qF+4aeLHvJGNn2oYwAvk7Zo4e9QSaUtd1Q Bj09M7mh81gmUEGlj728rVE5T08p7RDDUrecvTGpBKPFlLXBeu8p71iiRbyT5bbuRSJkayPO WYFfa+7GDZ6MlXvnmlST9oIm2ZsS+RCLi/drpWT4grmpR1EdFHPg4GMxW6P+MJFAQ9zJiAT0 eaAxBGfkss/m+2acupnIqnkueQDQjGa3jTzoX5lKDghodkRHxVt2SZ744Y6yOdGdrMC+jJvQ Jvui19hUHVhsKN8NwosqNC7kIKt2IJO5+EUy0w9yV3hwhxu5PhHW76qGQ4b434jr3B5uGLz0 QUx/7CUlXCB7D5fHo69myXsRO6tAVO4rVaTj/Nz6VUl7dDSoMPZqdA09YFJ2GLzTkNiuDtbn BugfCduEKtcMcgcX9waSEOnh3cXICO6JHpKCEaqRlm66qeACDoNylEqZKdeobUsw5aXCnGr8 YRLUMYErYppPPuSGCDUr4G0UoyWS6u+hwR/CtTZVtwINErvUVYAyKbcKOKZh7CiODC5r8Sqa eJmnR0KDWnl7qX2ht3WiZ90YVqaTOIBdf+9TTLHQrzqZrqzbqJNxi/8xXunOo84eJHvyTI4d ynUVoBV+jc2cKmI/Fg7oM8NxEFfdpFE3wSzlTtB0Ji9iYudjgg/E72RudsKswOFDszS13ALA f39KCp8nlhO8c9JMDGAVM5pA6wjzhnKm22mVeOX7qiKuo7RsGdlhmtSKhizG68J+u+X9np1p Q+ihZMeFJKhkLp0RttmvgXh0Y7FdpZRAJirm9umv4Y8m2jzeGsnfXxy8F/IoPM9hx7/YUFAt 9lh95KB8zxDwkpOCyvv/EhNmXWZ0okcML1yF6PYLQ3w9g6cZEQ4Pge/jLGQ00bM6RsGDaIGI 5fCPtzb6PVj754NUQi8IhCxlEX/bNU25+SGcF12NPpNp3u0jlEIWZxippDIZ+OAwyAHTHW1s 6dAH/gcg/g9vzympcKWiISvDvJmmpinx70/+/s0kjNViGemY0xFoeQDvmFZt0+zk0riHKdwZ H/TLpt5boDnZUZPjtDEzwfb0jBuDzGEeQjGM8Y92z2fDXwgsnw8WwZQhsky9p/eEfJ7rM3Vw acJEy+hJZoGdAM42tPX1PBUEeMf15NfkL7pfH75/eWlFUMVTb9fxFMFVoduDYwthi75GLcUu t1d4qsL94DqhYz6t5A+VAD2rVx5ZDsy5AE+C60GFN9LCUICb8/iw8nYgIbKKd6JuZ6U02Mdu Y1q3ftjA8GH5WSx3LMVSlO+f4Au/mzm0i9jFykJ7K6nU/+TLhMHsrGBWsqTPYcIMsxOi0Vbf osC82TmlNm6/VdoznbVgeLe/kEXKXgfySSBXA7s6Vk9rTGvpO3F+fe0gcl7HCLqXgCXnWoGK SMtSAYySuSRZLc0GRITEcO3/S+hZf/PFiyhSy1BAa3dSv0Ws5hQPRghMPwGBlxTNULguRJwY 5VuqKIFwXJ2ajJKxpIbqR8/XDlotUjq83yGsvid3PsAVt9yTHQemHHixlMomRE4HKWW+zJ3l LcnhczUKsdBGeMvgM9SVPJAtR9XVqSoz7XMnGDXy36T0RLJEmbvECfVT/jskTncsY4N9n/pZ mP/94+KwR+w7s7j6td7Iwk7ImdzsVjq95EoRMBnrBcQF9AChqNG98zushZ+eWKeHybheY5hi B5bJhLUXW/KDp2PmRFKNOGjvAVOYtugx1HVQ5/J/TIVxP/iGA/gdW+s6fOaO9FlTCx7o7Mkv IpcWKBA5b9LL7dfEyEr7lZg2A8b4WN7Q4Ykn/+GBqkFZoyheHkQm/RyBG9UOoYyaAS4jQ0rA i47WTW9Mkn17JeNQnz6FwDDY/9v0EA2btBHo2QIac+Lo6g26WviT29d41xu1IbbRXi2ZfZAe ojDU97kQpwKhrBF0N7djcBubla6OU6hluApASM2GUB7Ak5h5TlHSwjALLF8cfKPOZu5JFOch ZjDBIk515vnOIJ9gPaoJcmOsyMvnFE0C7kpf6sljqnAOecdo2kyric6EU2864wmGC5ovl+lS Z2ZP6tOdHN7EWJ2K4WbtF3wNd5t39qfTD453GMvtkHXiQmaJoLjBuilv2s6iM7TxLsDGa0dN +eeZ5qHWCdB73QjNmQlK8qtDmWLCbvHkmj+wgRo3+XF5sctNxpd+NnSAzFFDgO4n3CPyul6A xaBAt7VTEMb6A0FOD6/ezkqWbqg79/l7hrDACdwBVjMOuL4PLadZNkfJpW+39PDUUQdk2lWr mxSeLDYMr34tdkZTD4U9SzOfWXuqAEteyADnNQUnnGdqQxlKkKQbgjfqRGij3yklqfg1L8PZ qtDhN6bfc7Vhm1BSG0C4abHMRQyZ3rIkPQY8OZmgD1fPYbN3mB1liTW7r2oRuq05j4/31ElF Bd2o0pex68U5VZ1RnXZRkCb0fRUkEtxPLcQX1bD5Xxw8OWDAsdt2sS+Yh/CROaOpVUpBe+MA v0xeAVlNtJ6CkueqMA5ROQTbF8i/b0R4ukxB+fMMBg+Eil22R6vtRNXJCPU2UD5FYHZoHwyX 5l33N5CpHV9B2jSC7Zsb83Jak6KDJ4OF/MZn6G8eRO0XEAjJ3UVx+Yu8w2XyBsWJwBY6Ap8T /tzdt/3K+Ch/AXobzie/7zo6aAjfUYm3qPfl1bx4Ku+P5BjFppkuc681UNbjDVGmxQOjIbOo UYmD4yh73MWZ9upgrZqPQlV/8Vo/VvbIugisWQeqvs5x0EuNcH6gXdpaX6x7MgdIPs3TDh5D ddU0GnjlWVYYHiGhFiTo35GyJN0wk3M4z0GoY/RSrVoDjq7B0VD8gaRAbG4GUxTsWBIgnzJy B452x/6xhxkVe2A35A67vEIUu6+0PoLGwQV1aC8qKqybAwih3AjRkkGZ0mLhKrsWuW2x8M58 05xwrQu77JhriQi3o553/nQpBVbqLrv2u1sr4rGh0E/f35ovNDmTEUUzY1U45NaBX6R9ipTL E2OgQLVbcqeeOz3kiiRenyeHTlgg9UpXPmAkahJ7OSTXrzUyK8ZoWEejetWERW7wY0t5t2Bj 7aLR44hCaL9B86CVMSOIUMzoOCj/KaJ+00BGmbuYX0w0Sz2xho+430BNaxjMNBEUo+YComlY peqKLjudq1uL/+w59nVFoAhbBEaWOafTwNKtYCBwyGGe0kuaajxi7ik6eGSMvrEzMoSZKUUm oz/qMmqzJrK7pyeumhtKdBL3VLMgGpUpYdNFyzqVZGb9s05t0uh0lJ4+pGFLu015NOBg1ISy 3WmG0dvNjct5exrVT/ktm/JXEyIivrCTQlpyUHcYX5pyK+iOT9BwNtSfrR2F4VbZpFe3b03S Fybim7cyCNvKnlYnyatxyvZJmAuyCp3L5wGr3gwHVGFQ4pGLb1EabDhaHosi/HzVZ0xoPg75 a6kdG/X4R9Omm98s/pY8p0sAUEszi9YWSfID1KVfiEcsH7nkqGX6yMyyOt2XaCtvEMeiY2tj Sc9dv1Ie0QWrQy6RP/EqMitb6RX7FtpLkaV62EGC0LSZ7rQ/lb44jL63uQzv+XJMDKAyAx9h ElHFpmCdUGb01p4IWHPclm+tjFirJQRhXUdNg+N4Yz5Pf2ZnuKBVCMdrzmS1aJ3g8qJYlgeh ICWFz/Zt+M+f8rfuBxE/ikXWWIa3pXH3qIpHfIDHrxBMS1j6HW9SXuryHlB02KDXAqeFefiU nVrPVWqifW/OZzcAoh4S2OxIHlJ6tv79fvoRCDOmPWJ8FhstYmnBlJJdZKzH/bZWF+UokN7Q Bwe0D30FLcfLJDIDzvgGACPSM660OiN4h+sQCROYCLV4BENfJu83PKe68mDvsxnBqc+gPBpE 5l+6JtpJry7QaMNuHQGabY7AzXT8Tt9/QPA+fEs+w6tQQwysxYscTp7MCO5GKa5vUj8FUrNl AZMxeh5uJUcrbmrDSaip4pl+HGb85eyoyreF1q3idSUFVZsmKFmyp9oxomkyV00BwDXy+DAa wld7jv9rUvkn/ToSPjcpPRpCnvigIHS1Ic1YZkPf349KBk9l+9mI7NosCtszdqyHnQizw2NQ mkVdnqr6Bwe9ERhkPdPdoMiDkoXtMA+QdQFcnzL7ZKWINm1MrKI9PZj8DIY+ORlYBNso7O2Q nxMNn7t6mfEWZcO/FenGKbB6wDWk8zPKCN3OoH0N94/SJde1fz6t5GPQD8N5eQ2xBW1nPfE+ YNLKnoXhdKl+K6z8suUWZfPq8UM8LC2XV8/cuNkU24HRg/Us3hILvBCykoY6RNS2kAk5ok+F rA9FbfkI1wYnpAzYtxK73MgaEAkDb8jDrHx0HHN/KjtdFhI/ai5gA7p8xMiraCdhysBCSh0h y6QzaJQM7WG/f8+eWdmVbNj0ptiMO5+aDsnK+LPBuIhQSpWUimjof+OS5eaKI++YysjEKYSE NM67MKZINSn6oTqc8Eqtsqvk2uO4w4OS8L1RgkBxncOBh2svbAwB3F4xDvAFkeTLEdU6B3/Y /Cgfnan/W0crTGbc038cQcRvdkaN/BbZkihJ1XJT/YlqeaacB2zGA37eDAXBnOqL7LQ49qJd VSYqdPeBwdi722KGQAXnjwCmrLS+KQyn6rA60+7YPKH1UcPiTMhhua2qUbWfsctEKYA/QNn8 CnzUsFHHi1ga+W5R56eZ4tYBbT8EK4+We+C7nwTe9R3VRvyks3Ia10F92l/j2w7qjdkgRhTo An+QNAAQ4NjYtEyo3IAGsclCOYZEnbMPvMPWQ3hXRkoaXDVR7AJDVXyLnQQ7bLuXw9+3a+FP 3VN/HFpr6pvqk/TVsYekxRGbTJMx0Ny0mpuz1Pq//gDEZW1Sw/blqqlg2sRvoGCmXlR8fPHX wuPn5twe2/nj7F6e/YYs7Ouk7Wu3Ak2atttWm7lPbTxqJnWsI0me8b3nS6Re/5Nu/ZwIpe1U /BubKuw+/qgGWo8uXF9wsplVeQZCU3elNUol0soqm8/qSsHJjaj2GRrRUpeHhgUw4QMMaZ3E 4e50QGM95O9Pf5JD0YNRJcR1B2Dn/Vzrrywhecj5QGexnkDTB1XLIs4yGJsdXdse8B8PhjNQ jkooIKBfbSAVyD+Gto/jISOYuWk7Ev7uxMRGCfUTb4urauBbEz7EaX/EzHqGVo9KYyKLRjXi /S71mavmNzY4tAZnVK9XyYH28HyC//xcg1hEjYb2xHfvzB389C+LcUJ1JAM5y0zsCP37rRni AbuPmxTqyRNUYW8AfsDuAieTnzOalzxJw55cRc8Wt/xztldJf4d/rZRUZKu6ntH0Dawd5KaJ HYM0s707ywWjrp74FlZUBRvmTWUDllM0oGL1gHhgXZEFinqr0HUf04YKfLxLHiTqTG2WNO1M q2EUs6a/F1XOZwR0xKB0bNRSBDjZC9G55ueLGt2OKwdI7AWRYwJ6s4iQXGJKRYLPrQuwPPKc APdm4EE3B82ZCHYZtQmpveFch4vzOvozxNT1LfVHISgqc/h/0Gnznqx2VIUkBzVkwyYvx2wD YCb7g5ZJhyraZCKhRFN79Thwf6JO/M/pE1WFOnZstLo06xeooNUGmbqtNGFOwu3459/IORDe IlcXcjEC9jIl6kvQFh6bPaFxLDpbhg1UC5JH607UsumEIlCYkmsmYuc5/71tOZgFnidvJncr bRr+VYSVeCRG8Knp5ech05FyltFgg0pPxFYo1Gnn+6uyIkfaEuszhNRp3zPWE13Tj9qd1kNi AYgCX8YR2s5uei3jkNdigvhtUmf7gyMP/Rz5rhOg26WfPmsYMo8yZG2TFSRPxKmcLr4i3YBI Q4N5r6MORmesF5wKF0JWyH3gU1XNww9W3qD+fudFtHE//5uvaLvYtcmDPcpM1HTW/IIDDf/+ 4r623pj9yY45f8ogEs57xPZBZGfpmgmpPtpLhsb/7GzJ40lzdPVV3knco+qeKO6uyYoISGQt KFhpX9ntiqMwJQ1kY1+rKn/nqCxeRYR7FYe0o8kj3fyPDJ3BdgzmJCbgSlipz1zx7XvCsqCk dH67g+dm64SvTvRkMZu7kVavCmkl4yqbwoQZuzj9PCEjuiCr18BgJrcY84W5uiP6eCFTAcrP mSoC5aCeM4HKhtJU7gOL2V07aMWqpxdhMMC2OQprjZra7IbqUF0HHAzi/lYViaYUs9CD8vBE ezmT8mJMam4zcjZAHlA/1ioEMwgDo8nULKe1zfx77ae+Ek22e03hDAKezNHCXxaPevdPkctF kH9yObkJc6tve0asQhZj03sMH3WDHnVlOUJS8eKrT/jcyqD9CFqt9Y46+HVZfBbrZEQQ6AlW q5s7bSyzLhr8My4d9uzSTIUufDhjP/Q3QN4Zcf8obI7VGSrsx+RB2qfz/xGF/A2skt7UQmjl aOqG1ynPdypMsvV5E5+JJEsbhJmiEvTn9tbJ12uHqB/6kbOCjJWvEgi6b3CeocqAwjl6Xm+A SnT41OfaiKkPFDMM8bZvYeyjxMCFrMtlea1kpAghNkHclIIfKjTGYE3tHhvtpMmwuZ1NXqkY KYY+b1t6ZBx8ClSF6JA7Zz7+sKlt2qbfMQGdQnsWnemUDoiApFY6z1+7O239KUVbDbidwx68 A7oEsHsCKy4zv4CxZocjIwR+mwMio7TifcoWoqbxfud4pqoZyG5ZebSv3sKB7Soj1QPnFZ6S vbBAZQF9VLiHQ4HTGBQSgJTve54VUerlZWGpI7DIWXAZcgBhP0O7XdDLJkOHeog6zlh5mMlo wVt4XkdqXdGFCkbHf+lU0SDjQAluBvp4zXEpuxAN+3VC0mP0dbn5F2exeG8d8pesyJy4M0LF hMJTrWiSjXllHssSG+d7vjHqCbI5Mh2XkwYOGRsyB+1J8Bmh3L4QCyqL5O70wzuoLcWiJ4ld q5TLo4TZKwIoF8sQBOd9ONVRxLNSUdruPu9y3Gn/PXzIAfNgM6MW6Im7BRnz/4XsOBPsRIat YJ7IW2KV2Ggne7hZgtDihNkYknGzW6xfSdYOEztK/T9Tb578ebuQnB0vK39fvyWhXNSVGCQl wsE0AgpIGUQXobcqzZqCicVRDATovHfK7YddCEs+XU3OrRrQlKGTkSS+ilucA3nU4oFUwiap l96PlPiks4I1SG/k3dp8FwXzYh80Lo0VbxXGUYcEtnAazBqzkKC778q195i3Hv1rJSQT3+oS +XSCd2ueNjph77JT9Kf7++gdVnyiGF04v5k7Dw8GTCZkdcUP7gKJ+nIKpNVDyKFtIkBcrHW0 B/CVaAhVHPjde6Z+2Da7BCd75wClbKNUV/l/JArJ2QE8AX4HzZG3IGrhYeus19GHcjrbDNgy i6QiEjAdE32LXcS+nXTHAsIka4ZP4aL/Z8hTE2GqlHIisFwvvrrOWMjVgvvsuaWn+9JLu72P Tkzq2vuYsIogJOPQQSehTm1ZW9dJupYUg6gAWMev7aThFF7m6uXgYSdai3836fIrRTUOqRaQ 2w7isshTAWlUf2FhTvQ5X4IefnxlrSgErlCejpEjL8FSOKOYynJajuAlHPsAnSeoxD8dvh9q 1k8CXdYIgfgpOkx+UVq5aNjxUu6n40MA5tqY13o3MgYKqDw3lT+juRdkMMUIjIM4NNNnhNRI WOMNYD9PLkbCJWqgQpQwQdBR7keM1rsEcuxav5cFqBZ5KGD6tJ8D9DTbJ6nFUCVSuuvPMDlz 5vH4W5aGMYsDt4OzU/QvWGZz2OTGEPHgokxHIbqURA6cnumD1ibySKQBYHByOMkNa7OHXCVQ dInPFA6L+VG2KgfooaCT6syA+azVv3H4HE+y8DnguhlILYSvT0RXJBGD+heXlFr33SZ9uhig Avt+aAmM5evyvX5NF9IZg3iBMOtJLWy+xUBQQNq7YyGLJbE6OwWieyHHPdMTrCRsnXISGdPA 3G3xEGb20AQioXdUu4WBnJ/rlAMj1Gtq3Z8sxIScbKZJqLMlT26fpHHjo3fRYopaKWHIMWvz sykjpfwWT4lYxhD/wPWVifX6/e3NNQxUyfGXKUk67laaMa5Ye+574ZN+jTyvhOCPx3O7ZRVV tt4IhwGDqP9SMc8i7H3QliJ8VfLZ6V5/BUwZTy5rZmLwaEgG8/9M2HwjikZ1B99jbb5NwJJb e3XfVHCtlaPRu7tsN87bnQK3uV5W2TT21QrcktTPIrpErmyA6xQLous3wPtb3ju7YppO1xNx aU9yHOXq2dOlVfFPW6hoZN/Ei2eLkgif8SDGSLOA6UUnZ8KuO+h/nUIk0Ts/2x+kJafm5NSI +zI4NLlUJPKxfj1JBohwuyf87Lp0rekVauM6bhb3ZoYR5cy5R3EGncFMaSpYq7Qk2rSMGpsL vcUnVG/JyVgcsVj6u/OxizMmdyCUcOIVroManQOvL/kkcE3wKy12FZCrv03c98GPgqW9SHh1 HxtkTMHFG1zHpSsPTEBCZNTfM99rUvBlqo9cr65Ajh0O76zDOLZzgkCH8iAWb5eUzaDfwoFO wDXN/fAMJJoySxbYc6QlPLkisbMQWBZ52ZZdkwkppSYllpKRxm3EZR08PikFHh7ZFx8o9bR1 A0H7UIKWQ8odm7XjzBnhqHGIoWlp8wMvE/JvflxmpKY4iHFRlOIn0xofRVaYeeNEQxYe4DjU 2UL/isHD5zAVZixfckBC++3Dl2JRpxnhQEXwEcFJkRftN8UwSY9ZelYFJyuxnv4k9xJj+/8z NbZGRVR67uQk80/bX6JUUoiU5mAYBQtKA5KdvhXInG+kYSA69qsmoUNvN/O4vNWLEkiXvTax 5XMtlC4CwBGK9sNvFSkrp4kV+rIbAa+q2p8IIBLwjzB7VKTxmDaBsWZ/Bko+AVywcyC5TukP lscrB2Lt3vI+BvU7qFPiz7ie3ASHlN154tZOEDaBVDZf8O6ENQ8ddMm2b+uZtbhiPkUTaoh1 LVQo6V1Vphz+jzrAOFZtQ640EPv3xpmoTUQ6eb7XssCgjw1ztBqSQMnF9IZqQpBXVmg7tAEf cIDaJxg5W4GoVla/zaKaMzwZxf+ZGB1UZrZFlBAzhbBYrv02DB5YBKF50XrQ8oSkPc0bf81c BvxCAcK9niaMm3IAn5k0fAm96Q8TZc0LbuIsq6nbyIh7aEGbc2YI2zOKH2vsDv8mSXXCbej7 hNdvIHmCkyi6rhsIu+phCqVq2utTUBaCF2HcELKGQsd1tAycQe9YNG1Vhx/jXM1zJtsT4XvF X9e/U5vHwL/4UhANZSbX9/BdQ/kVAKktx+JVgYOtmNMjjcqH/IsmaO4tL3lYoZYyI72UJDwy cDB1tUDIRvU8U1O0AJyIsO7NNMn4nPGzJvkA2DwcWdmu2CarcUP05d8v6236HXofH0Ss6SjE fpoDSeFDEQd9mMC4pQGmawJ0BDD+vclamNg1gtpIMntxIovMdJbAlWhuVhnLNZccvxNM/qpW +Kzcn92FavZkMZCNQe/f/2VE/4r8pxJHYg9i/+ADtqQKILHL/YzKUy4Isi64yaLmLuiNRDny 4p4xqxLKPwZd64u1J73Lv9tWLHsDOa+MMCu4l1C3p2Nw6C46XYraaGYd77Uay4gF6vMjmbE6 rHDQBIRNq5X/EvLJ1B4IamD+vVmMWBRRhcvorev5ljLM2WwNeuKdhHIQgBrogE9Mb1UrP5wJ lojrdTjR9QFYDiPyXpyM1xLxQUSlw5MaUiRdRDy3TFf4VCoT5LIHsjEezbaMKAU68imHkv1z yh8wMO79B7/TO+Nv/7y6rVmYN7ca98aCXwDRdyBO7DBQh3Mxyj5B9I9WHteMYlFM0VeC/VM3 /wbksSzcHBSVMWh4Wwv9s6f2auCLC1oOZ1sVa3dBuS4InVGkKN5xhaKDSOhwZEWtSdn34o5z uRPTQHg0mItItm63ozFgVU3ncFBwW7KB5T71z8GnjPHIK+EM/TzZd7Y9CA39RiXyGm+Ht59I VdfW4KXHjzps3L2TMz+yJ/gjb6O/FgJAkxwx3LqpD/2bRuycwfpQ3vI2CbefAi73iiCk8RmO gI3CsQZrjX+3IAFOd7JBfI3dC84L6gNYO7A68E6jjDBX4dmYro+FbqORrrEYnzyBEQj5xNQJ WazGwIKmqPyBKftfgWhdMBC7FJB3WXX2hHMM9NDzs7FKgrqxRnSaXgI36BnM3wgvvGHVK6nH s8CEXhEIkFU7GTZadf5j/vDfgtlo0GosFF94JCLI5mOT9P6oAlfVobqajw15ZHqy4ppLQO0Y oGUxQ0xDEKBPtxJkjdBL09rR4WOjwwxPrh0i9cfbnvVurRZ+A+Q/9XXN+cSaHKCViQYudfbT zyS+/sIQd4Esmm1vtGH3JHUoStlkf+fSsFqxrUKguoIRIUk93PiHlJb/mzGDzqgbLRV+oTQF 4KQbgmwRUHe01my2cFUQDt880Y59v97mHj896+pmCXfQivoQhgevRxPWHOdETmcbNzJHuAKS 4JmGbMxUyBFekcHjPSbV4iWlv9mi5P40pt7ePdPpjRv7fR2McyS07CjB2nRGC2TGUdi4ow63 /MRdZVS0whHzjdh4mmhe3lg2NMfX2jyO3XkCzpjffMQqQPwjq3hoowpTwzLcDyoGmczHxkhg cUamHwUEQMRUU6woep5kO9SdJVo9kfX7AdtjayprpjhL2vWL1VgTU0tocM5AeFleB4ZppWYS i15lSDN0cJ35zDGssORsLltDFIB8Dq2w6B1UFZg608kiJMhOKBvLn+rN3xhQbjW08T6g7iU0 WjHB5xm6Z3fW1660pqRFyhCRfaFw1po5yT7TBineR9f4Q/L1+pdv0PcBDUQ29ZSACS2YR2fI qxg10isPwBjJnzggEz0vCc9nAoXbLb42h/kh/46JLSHJ9waeKXVIVwXIzGCgvvY/mKBJthkC uHYVnHaW2zFsuQU1hzwAJ74vfnpP2wAo1uKqALFC5upcq6xDTFit7jMm6O/U9HODz4LVWR2F 8X+g8yiwwDeNsaxgUyvafQmjQxr5qAH/47WV4Hm/8gwt+Y0trCIfvsh5WlHJM099guS5/Dro qd1xOX0EwI9FmoLzRm7Wt4xYOmZI6KFSmy9eU1/uFEaCYTi0xWeGH5YrbHvex4GaQEl81kbD vJoodmNDSH3WPOU9k9gJ54a16KzzN0Mq61JzYYdGSX6Fzgv6xsw+0lrb6Gn03p3DRmrgd06y Y5Vm+it7RFN8cl0f4S4P9bO+LEXcjI8cqcJjIxfcnbr8E9xuPxBuZ8hxlVSWRhWpSuWbOR9T llQo6uo9yRySfUUP1tf/KwMNJjf/Bw9gata3fNrEHVN1wfQLYLOox6FKB8YI365D+T8WFxlp MQx1+3/LorEyy4PDWfpGno0eQIJxEwiNJUFhZLqpDCliKzakBPN4S4W7bjKiKToj8eaIkqIP KKl/WGwapXTNy11v63rbmzmSJkDcdUxsB2GRjkaOb0TlbPpaP+I/GJiuQfP4oHDyMUFpWg7z j8LJVoXLhkKhDXUcvcbXFjEBWWk2xeBLAS1rgAaDagrjO5AV3ZsFszzMZihe/72Qa7qHU3q6 j4vAflWiVEo+khdzngw6LlH0+uYfY4AK29szNaRp3RSDuegr5i6jRg0Yhxm5TA7YuNlF/zTt LfxHgsHC4G0PFMV3vf0Kia9WMSGHTVFTYQCbFeYBwOyKx/J2D1/jWm64vx44ivm9Ek0x/92g gxcYDeafo4Duh4wekntkfjMR43+p9FjdPDiep2hnQ4OfYimCAydnBGyh9iGsGN0f/m0Rb+NV DWL12l17QofVpbuiGFqvcJyMFu6TeDMCFPJaymqy6YqBFgwmNyr2nvSJqD8chrwtBsWxP7Nh GKdfIMB4As50ynd5EnMzhXBM2qpa5IYj6eKvyMHCna0BeirmcCvixdIEg+SSW0l0vg4ORNrY sfN374j/b/2TI9imWnUPlb0WqFSTNjM9160D8/nYdA0ebaGINCNWn5n0cLqF9AwhKfWcvfyX ECHOEl3E1KUs97u9pYsrrjkZ5jkznGLo2pe/yo6jvBRWJKvwdjfg36kJqyjH8Gk5782CYyDx ZjZbogmTZDb9PasuvqZEc8ZQBNz52cKWamwL/DcuvxoXC/XzvGXbK3QfhR4lvVGC0uVvqF7w ZyyssmeDwrMz7Wkxz9pLh4mPv1u/wzSBHsFLz2CyM5AM+F/qcaDPif8dspcertazgS0+JtW8 arSKjkVoWhuMcD0dw3G8V3e0gUx96bZdb1HunrUp+98tdNKe/LBn7UrOFFuocolke8kYQ5Cl bjnJoZ92UywGJ3nX0q/hgYdA+EmTdsszGgv34SjFfY9BrOexsHTJxVP5kCWt/l/NXvpUJ9C5 MZNhdunTtTUzhOzVgC94AdSrvfRhB4xLbuEdR/HtHqt/TklBRtVorJteUXKKpvt2pIcdiQVd C7VefEPCh6e17+VgzDuvwnS51YsNMaKhXeV2ZmAgX4piWebqdS9iCtynnHY5YTuIV1J79umK An1Md52OCnzJTOItzZXHg1suIvW/xO7zzDuTBOUfMzFNlRRokZwrRS3Yg0OTr1NFFj/XQ5XU A7VqVW9e6klKIFO92lTcbrYK+l+RT3AImXOVCGGxhcok3Ac0JXrAQRaIOEKtVs7jMOSNhNx/ nAxmfp9Crt+1pl64hbR7Z7X1mio7N3mEfz6vKNENkVwMkiLKNxk3mmzaRcjlK1WrN6pCKRnY hQcgbiODEKRrfs3htXaPbt9jGhwrbuX6PjyCEeOhB3oNbtGknqT+3Hl2S18T9BLGvUryYXvk vBH02cmPuhlkAqDiT2nF3CIulJPNNzsTz6yjuZfzYPzG3LCh8EIZri0v46ZsEoD98e78YiRT wh8ys/q49X+5UDcDLNAD53sjU9SXXJLQ1+y69vHmU9A0E/3rYsMrdifV8ME2e9f7+6TuJchx 14VxVTtUAyWdgJ31i6pQScPwI3sRHvefJks3TiSkuOIDX94M9s6C+mkupw7IStG7RqcwW/aM DvDThKHePm4XQ4Yvs+59py/YJtliItxcMOuZtbGRH7vvJP1ZT/GTU3rXb7/Ubix3U66gfbik ZomnxBmCetoJHHq9ItYwQtPxtjCPYdmRt9GA8u0JuQct9ZVuzNcrolI7ZGGSZuOLCdu/qfKe Z2criQaWW6r3/rXK07RGikKdguLZhLo7JZlTBygGXbn4VmGER4C7105LPn+TGWLVFqBziARL QST28+6W7j+XeSsKOA3EOHEBfamdw0e7y7/ynG1jwJn7CfCJSdqd5flILCpw/S+NkiYeOqL/ I+TH2g6EkaOTwG/kEWWtv6aHXPKzdHghKtFd8D4ptbC6ejBqunUM1Qi2dHSoIb+XJ5dOs4Sj Aw4J+AmcspudTtsfIQBvg8F2skkXPqEQ9uV6c0H00YkuNWMjUaPAkCjgh56vYg/ZW2vy6oYK iYF+SgyKta/VLqU5t6wPz2rdvdJwf0DiHESCynGnpLxNCgj5+ooGvVnv/RuwTiY7QJcjWWyq 1A4VqTEgOPgmtfIJuTWUvdcZNXmSElCSGw5hqObXmlFGMarKd+lixS7OVCydMv/TBRB48qgR aLxiUdisnb5JtV0Umu1/JBZk+bOglPdIqs88FeK5Eqr7+jhTL3OSgvHzL8mzPwz0t8qq9ezn E5/LjVNo7dxFjMeaPwVp1UjTwc9ZOVzpp90xe4FL+p/MpJG8IiLaFv1f3MoSccOt2S8R/Reg umUgRZRQOIFVq4PzOTb5SKV1WYxMuOlK1lcIm5RH4p/2wpmTnWrfN/mAUG0U/B6kSgGP9i0N C5aOA3SWaWHervk73HAn9YPIMKh0lnviaAyuOQA2Vmlz1Ha+DkAChXyd5x1zpX2Tu2oJh0eO I+NqhH0qmXiwpaqz/XXdM2BilsxXf68/aZ10i342ygtBgD2eW+Gf7O1gCnA9xdpBi8+xp41g gBFoDdsWnXsoIYPaeV/OXZ2anFNmtPRelvnL20I6Mw6mxi729TAZ2WNg+LVzoCddWPRAHvtx mQrpcKtRhLVe3mZpogx4Gi9j+xya6Zxx0WJFY8KovkYfxpkA2/lKkScvtzTzT8f8etrlecEV nyNiM+c1F5Sq/RVKC36BQagVU8N6fMIwwKnz8C+tb2N1r+jEBepkwDrCz1ZpeH5nr7n+QJEs ujlvSYC8tlBGXCNBnNEj3f3gDpc5TOgHctSjiTpQfDkWhaU6t7tW6rUcuUxPpGkf8wO/bEfe VBKvjfz4ejhFJFiN73mlzlHm/5YW5h+nppOCjnBS8B7ORHmyi0Zdtu9LKsOZCBpZl+zHpq+8 pAupS8+nbtXvgksnd8BgGuVsY5092pN6zbtrOsMDBKCy3nZsIhPna2AACZaoQeKjOd/bhpfa nL9961aFWnEmHHSM2c1z7J0HKg/eg1sojbaMSUOuuAoVjSt5tC+Sc9qBl/vRfnJP5t+SqExK 5J0jgY1/AaNCk4s32bZHYge+Vj2H4yN6UqScnlmI3KECDeJwWymvcMERBZOvpwpHqSGUEkSl s2O9vNyycdqxk7R2haW81KiMJ3OLLC+Au91PHf0/N+IBA9yvnkcHLaDjEoYlvuDzmww8JzAF Op1qTHp8oK8h5YBNzKsDaP2AgBtXdWBXNg2J8a9d1XzLutbrXnrAXb5xgmPTDYxgPYXpKIcO 72+px+XyykipY1wmgBUHA3hHxyH1Zq8jCHr+vmGT/TFdfneBx2bh6KU/bLe2nCcPwY/wT6sl pxT78WtQdfajFqlwk/VoShakl/jXyZvumXEkqkLvHx32/4yRQaB6dP2Vu92VStrl9jYbASf+ 7YU6EA5mW/QIsua+PGUk0iR7zZS0YQy22qLS7oVpLHjxzxfjQ1iTTk3ztdjaOeTHysC+LvIj YBSXIyjqzOMxWCsrrPG0zFqNPLsC7ffrsI+QJBJEe+sW3hykIvs06Jrf5enAgbfC5dyVfEpr w+Etu934+4CDGZxWpa8TjW2pHttvwHW7BTgZUQ1wr+YW9nNjaErBUHXDqxV65bL81qZ3UoHM ZpKTB4S6Fw0gTitqxAiPE1RQ1TjIC4qZ07jOaW6X8VR5JaLZZ/GvhdzxZUxLhqJw08fg5Hca KGjn5MLXOMjRapg0oBi9pX23Og1/JVQXdKAanZybtf5MG5MHSFRnUFfFH7mqpicrjfQJ86Ks z0qvB8kO4SF9IvD5SS97tC7yiqFCviYiQriL0GmovjO5/o0R0HA3r9O5agygqWqbrL3OofYw +Is3XKjWXyynVffg+tEujkWkkPGLc6+mBim/Zf70MVYtGmF+K6UwtWllpb+MlbqbZseXL5uw QhZDKZsyQYuMv5lw7Ray9NbsZDPmPrXwP3VwTTilKG8fzVSii6KOUmJlUtMakSKoJGVj2mz8 0mZiBDPo3Dv+HyDm3ja2WrdzD43v3KefdQg6E7hotYqztlx28UVM+mX7pLqiKiWmnxX4gukS p85amQ4XCOa7ZRp1biYSH34H8TqvXdi4ArFbUvTegQ1rPZVYhXjCk1o3Tw3pyDq1+W7UTQTK 9djei/dyJHvM+q4z6cZ6s5rtAno8D/TfjHvu1MFKtjc8XQhOTfmc/v7HpXpb6KgzhDXRTg1q 7NccogJYYKQZU1wRCI8WopPqVtDwga+G9TI6CXhfCzbKHcBQnZOcIPiXHyAdYq37CcUiWvQ/ XZhvYVfK5DPGbKELHMCj+8v+zlVMfs1zPz7+7OcKM/8vviEGwlte3z5VkBPVu7c6LG5yLoRP 7G6u+w5+GvOxe09GmlPX0dXKgX5E9nlbhMSZ2YiW5fOFuoJdWXhmftFte4uS6SR+wKAFMjJI yRv9kCXFgkxurokGQ/FN61nmJlY6auma9EBO357J3emHcsDlJDwYocfIRvVsLU3OmD4og5wI vKAZiZKzhcWePoD4CCmFfhRS1lRxBx/6/GTIBcJiA01PNsOz4kM7/umbdc/eGyfgPm/9Jj4V 1wnLp6DcoL1VwxlylivMGQuyllxqNQiDhbtqm4iHB+9xjEvLKNSHr2NBM3hfaNOYPGxL8TAG Uc9Ds3gyKLfMlpNej8cQRRwgdTAxu9BPRO5MEjodt+N1Dgik1Ay5EG48C0ApT2cRtv1vsCce mJ6Yla6EkQCpoz+gopuxxTkqoXpcmqSBF56PfhNe2VFW/CL2pHWqUgbWe0jDf+pzar/BZ1Di Rw6h3JbzT4dPo2qbekPrhSka1/iK7fk+AJJw9Dr8T8dfakR03YHsdki8OCgOuVZ5SyhqOCh+ MerBHRKxkiufDB2Zpf+ZKcvAt2mke3SK3PUJPEPz71FvbONpxchRlI7TUCViH/Fe1A4LX8ZJ uNnwLZVR7rXyOcI24bPvgGIZLO1R60N2pIgO21jcsf/qoMYRerG4lE+S3pSnNtQX4RXGw91F 4XWb+5YnKODFeYdUeJcEMhMP18ex1fARQrXanh6chfkx8FBscfUF9ksBkI/M18OG6R4Gmd9f xIqQbh1fqNGvVXYR3eWYv9yynD5RiFjfrcpJZq5suTSqJTwxJjmD4OrLzV1uJQTIIfbIr3et zkXa+WoM3lLpyGripRH/V+J0SjvhLrfzbBSGH3G1lWsacZ7ID9JywaV5Jg+yb4Q6BVpg+07E yEzXnT7S7zOey4VgXgWzLZJWe8BPdRVZEKKyDRgdLmjsFkwgzhq1JttrsfyhFT8MnPVu1BeP WuCcOMiB7IHuWvGEROqvrLJufnYoZfSfvhRhgvMhcMq7gIwCeRUVS5JmVlGr/NfikTOn2rgz QEYAh7YXRFhk9OuVGEps5gn7KXFN/Ac4O2+De1MB8b4kjpY2dJBkNdZKbLptmnj4zcCP2vMy xVtwvljj5MOVwAVYIXlCmFc8sJ3qC0uTLDc40yKBQpADQ2187zBGp/pN9O32KwugBIqpgZD2 4HmKtJMTILjfndy3egOi4c+Kj66jnPFUPYt34fJdmVqwKU/2D4HBuyEFIJDetHBZLVe3q9Q7 DPKyMoL0hxGsJr8KJxwlovc67he9E3/bgD/r+fJhMeuqWdC3u79gN/6Y9lHC+csHza4722vA GEODPCWrUtrSmPLJrIOaTXiUF0JNi6v68kf2osHfLZ8PyD2vMssmUTXxgSk29Sm9yVEEmLo/ CsLV1k95RwoZYvTBokwmOvAhM/aUw6dqL5/7aejxjGYBmKPAlZ9A9GkRzsmzSrTSsJNSnEex NllTmh8W9A4Qh9fFYOPhCHLGvGBu6MjPyg1CG7wKrGlffVWSRXcsYZKiHSitNoGHlYX/2xY9 XTjrYdn+p16bzHbv7Ql1M3gxh0foIK9xaCyL5UqjiPXI2JOU6QKPejd6Edi+POoc/vwX5tdh w32u3IV6VbilkD/GmocuWZ2MckFzAhbqrGN1eOkkzxA1A9oKj4aw5ECRg/MGss9ep7Gg5t5+ QO/Vivzi3CWqIrnsB2mpeM9D5OlYThLkq3YZpUmPSE6dp5IFLG3zzODpaHijdm/IKC3v3am6 wc5ccUAC4tJRxojyau1JYEMEVchH5c/s7HItizLtiDol5tSgj3WUMmz4MlUIg16Sv4Wk/x9N R08Jj+CyZFlDAciVH23QbzUleoLih1icb1mzMapIF4kESUfNO2T1ZuD36iDkRHLK5AOUf100 mxPymwNQJjNNeTmP6c4gaSKTUA8SALjyE0mPgPqigV/sCxu3Z2XNK8oEoCkIFmxzz97QkM2j msEfcMNIOM7uM95D6eUwCWo4H3c+iT5M1/a/N4NLqSYYThfwqgg8Ms3RwT3vPfDe53uGEb2D YeOPpk76hcwRAknXKysOy97a27hRn/75REBjSKPP3tzLJIcJqOmyZ17Uw4yAL+OLmOJV1GdQ FpmxYcNMKBlTjFWZClF4QEX6xerAg7Vc63tgQRQGDkTsi8OhWqfYOD5m5Xncw1vfiyLnyhPS rSd35hKm3DC6j0jIA1xYmhejiWRakXhr/4OBdTPB+SFYVHTS5rL08ZlZmhoM1ak0+rdrWFb8 e2SdUym+RbkLYzjFg4K+gm+ZFoCrXkKRznlVg5e3DbGjpcAHNND4xOxfoQ7/ddTCcshvi4oD UBA/j1TR/VvtRyFb7x0yj5vl+wMzqm4Hn1GEHGw75JsV08tDqG+tjwlNHWJ9yGuRN2KGYv03 GhtNFSgHwrA2kLDToT7lKoA2Ty+wTRaAEi1R9gl/wK7NCDhY+95TBkv0bOain19YlH1v/kYa lJk//OM2YGxVxcqYC5p3OBiXAcXbWE9peKsg5XDRShE/+cpeqjOumzfO631RISGpARhXzPzo KY6mZ60F/AkOsPaRwS2V+qemxniKxejyhLMIWQ4nYCtV7rEO/lZPy3UdAN3qiD0JkEyie7ey mKHky8i1kx0Wg1Tj+AqhFDMYY+5oklhedW/yYxtfDPYCg9UHLI9qKMG6thHK5w9F7C6sHIIu 8/Upk8zVj9kKGzBhP/UVrLFl/LO2mVZ3BDQc6liYDqosuyvxswmygj05rD6OmC1Do0TDlk9I G8HhsE+YBAzoxU9AyJaO5sHsHSXvF1eZ6k0akws8qxDvxFKUWJN+ybzzZ8PuvdjjQcDmIfXD sd7QeR9UqyxUZW92LiHKVNY8c05z317nKFuwtVrdhtzIfaHUepuKyONp89RggkSvaX5fvTEx 6xTCU7LZZxlhCu+pmXl9DjWYqu4jI5IOkSz7Ps9vZFtOf5oOnJK00vEwiX5mrPP9lzIYuL3k 0zMbBI7OFRk2Cx4pRrJiXu2n/ZtZp48a1gastpK0/ZvDkqYg4IMJb/GHYxircYvqmR4FFPN1 ERwWISwRBG9do8i9nYYZDJ6HemWByKV6ibBn9ksqXX7A4vsPB4O+cW/PWru7uJlg6izdGD3O LK8c8/IE6+RflKQnVV5ZvEXSUjKR5hJGQkaChEvZcsDrp8V36NDjfQzOUfbZ/opzfjpf2hxc tJ1E9d6PQUme9bX2r9WaFFgcqlVOSXR7J/SfKAn/CtMQN2VS7be3C1FL7qw4uMQFjSZPpFaC /s1HqlSXx+59PeEIopPIMA0QTQLo2ERSso+kxzUZ1ZVqW4TVYXy2JN2F7NvSLYrviHLNDlEq KhMeF6sclUF7yrJNaPAk2DXyiKPXUSQPQXNNrbgrUBh03ejZLqJ+6cXAlD+hTYybLxZz0TcX YUsXj1/LxCCAcavs14PujTVFycFbkh8uHSh6XhOuLfQLnSve/dhISwhwHNf4QbWjRAe1xCux up0SFlExgAXupOeZJ4PSDBrpFZdvdWkRvMRs0jvE9WKL+4wuVO6ZCM8g+7BW6iGslHl+yUc7 q7CaQulcl7BPnFLKyKnkSUvAXrv+52XdjlNFO5AcVgw5yT1sFjjpd+edhUz9Shqcd+KmzmLU kz7jSd9mPf8CfVpbawxf6Nn8FfzpmjMH9ylkBSQz5eruqUeNVQwcfAyXRWrzrOHL5bC9xvTg auJtmiX6M8lBayKeBPBrKTlfmyahwIBqse+8OcescVJNds+VGcmXEEpyGvIDM0KPsK+3dBz1 TV/mAAtSB5m9RXnqsetv1E6wZBOpY9JtXpoUq8boMstDBssah/DbFA76FNFyHdrgN/jpAMyH wI9oXyXWvhdIlaFMJJUwGEvsYpWWh3ZyXruiPJO6LQraCaP94H1j0iv97Qcf3OGE6sGId05Z jmFROsXLUJ3ZgxHlrOUBP9juw6cWw7AbWQT5DxGxZ/HOwW1k+pRQhlE4oNEl5ydq+I7sxtcZ AEJi+wLfno9vuo2gE/NdHWfBjdvukeZ6SqUYnBsA6VsMHK5HXeuejOiO9e9xDYHouiYCEt+6 o02LViuiRrflxtY43rWpkiY+Uxy3EfaPDTREC4OnW0zAj4V4LREuhg8gqviEqbeWPpnO67vH mzFIsOyCWj2/8fI9FWOWUOnbA3bZ1gUd6hT3txYRW6Vz8p6sDOlwsOpem/iGT+oJetncC1Zo 2GRSWBwM+HdxtDWmFe+1IC4YBbGNjVsyiuAS1vLxU/hBsw42brtGEoa2KFUmYwdKA6npRzjU qbCbQ6438xR9Qo50TlhhNL3pwlZDl9LrwFwVXseqZV727Mi31JV1H1HBIqBE+gGAzh+wcrz+ uhZVnMbVXyKLWzTntVgF5FIUTyvcSIh3Cqe6+1/gx0oO7gplvpnBbsaSdy7ATPfVvnHhu1F3 IR09dAJ/QS4xqpp2JOw5g8luFLTwmfYC1KDiC9roGdO2FKsLeE8ZkdqUgg7ZIbPWUSpfABi+ VNHJoaUHpBfLZvVIlKIIcSJDP50UERgFgBxJ/lB87JKtoevDxxxjeAxRPPSBNP6YRRH/ImKA GWOkW+vv2PsYG54XkIA8tjDYjlRB7gpk3haMwfvuevMvjoGeuNspZjxfDyBwl2cg2b96brZq MxK2wc5OCGNoP1W7hEIw7Xso4HQQhfN0o+PaFJmWLTSJgdKN6w0oVYiXWbUQyKHhhRw36PV+ W6fhYpsl6wrWBReYEBCXw/rNKuJtY06cDYQaOUSUPya2hloHebe+rjJbWMuN6oFkqvOr5JK0 5cHU7dyr6MrtKCCkKxhmrT5DcmL0XJdcDowokXxATl+DrSbYnCrc30AyfrmhFtlO90OJBXZd l8gP7IM+RxMPgKzqUyjmkA1bq7PEw329voGMlpqdBmJWRF++QGPpXXi/qWdN0goC5YWUWn4Z IXln/ulAdqSzl8g+vLXmruuoC6VU14YYdTZe/JzAhRKQOQVEeQ0qrdkK52J7HCuTR9tzqQLT 4M31e2NQXoxM73CnG5nceUfET59fb7TDE7gMuRc2+NLC03jmuExwa99r7o9ZPOlY4Abbh6l/ uGiVSfzSvE0/VZwNNWkxUHBHoCTLDQM6n6UBjFCKsRxFe2c8VU/7FM8od5B+BwzJwxEf6H9E KseayRVSvbn2CDf7un41hEjV2evc6IGEVbe7WSC4/K0T2iE3rQ3uSl3ghEEB8NVX/ifLJxdG lijBaYpO1YV/d7nqIr24np9kYR3/eGoHG+qXZl7R+ucAiuqgun7RCzj2F9zpaT3RGOYMaEgJ MzZd/VeoOMmgjXiw4We3eGNdzH6iKMMhvlYbb3tb7DFsbAaU7taZOdoeUACCCXr9nTvEovQV x1UZtnkjnxBD/HZoTdFF5AjOP/CBQEdqAibj0LmDP99tgr8OxOdgCF2d27RVvm9z245cPQ88 tFqjjb/8wFtJdYmIALyT12QJeibC/537N+Z76+J6ZxSBhV5SDUufGtwDg0Bn4reZ/AACr19t mtE0ZNRzqCCdaYBx6kBkZaihkikQ/KHCxvqS5DmXXW6l9k1hxNnrRXDoCujJFNUaGfqNM8DQ yubULe3cSS39AfKQtjyX478OH/iIUfSIOi/l/yduQEY3aWtJKSvnf+j93S1yMRSCewQxJ4Lg xmKOOPEhEF4FGZcsCb8VAsRPGa1epR1kaSL8xhC9MlDGvXyFlOaAMs2XKqNKYPhp58QYADc4 HvXVd2I2pT2yXAGfChu+TpBoUYSuKEjYPz8MWJqyGFRG5XaKmKKU+FgXPYJ3yK8TNMbJG5eX svArl7A2ics0TR2GCSGwS/Acj71m1k3jpbeAS6wuDAUthUO9R1XSrJ4fpDpBc2SrOz2SKnS9 Jcm1HGwfIWMzj5tS97DncSHyFR8agqSJq3xmDcix5BO95Z23awGMTugnUNbGlPatKIb/Thk4 jiaj35TsYQVJ0HA4wXqeCoVY2fJQ9n6y1H/LTPugDylLjALwHksgk4rHo4VHmwYHxRm4JWy5 k2QUs6tbDxDEdLVUwq+45MVLBuqT8Z4kgm43DRFD07gc1jmFYGZOy69IIXC3GDbdFAAxs01Q CPxHeQNH/PDVgQPhVNjNQOhtLzx7n9qdt2w2SE6PQgP4o9gE3Y9ZbbStDRC0KhQY49iNOwzb ysSd3RcfUJ72Vn4nPJRm7z0YQ3LRGRmRvrkMb9I+snjUo9kBrIka/fD0TJRKQp8IOjwul5aG +r5cZjL6P0ixQoYR+f7N3O0YWB2AOe27ppMLPc52lYaR07AEeHOiV5IxkVQvSChi0aH4jzIb Ji6b+qazfeKO4lGLuWcYlWxEQcKBeeJ6gX4nTAVZQSz+BFESiNGpMIwT5NgvdWhm1guSudmv WhezMwEVa69zPl693qF6NuV1VgMME7DMyTzUN9So5FFNdEJeUJjr5miis+SLa9l+96SoZph5 mRLR8jIiTiHcvynwl/7/lbfUli6GCNF0PTn5Iu04tBfe7wZadYj5+XoeCIT6eW2d8FuH/GNM o5vpbi9evGmYXk+lDYVYSdb8ol5TuaBSi9PPpYEvirF9SOLEo5gKEqc7Rt8/Ih5sgBK8t9Sp UGoTs6lEQD6AeVEINgI+cky3Ynf5WVXF31ia0GOvfYkTDaAtheZDk98aJyecfc6o6I8NuTHY chON+bUgFDNRrl2DS1M+mnt/OwjUR2ztmJ+p/oP+QWLYFaEpqR7kKuE9vCC4n11OWnTXh6aQ 8bQZXdAOQ3FzhMC5gBRMZpq9zp6xcUPafy3Bym9oCqze2Glk3fUpfpNffNeB4jpBNWuuDzzl pJ2d1IMwm+8mNgjIL/mfXXGvo+EyBjoyAwpIjQr2DjXMaWIHAMr/9dK6DLoStXGV2LPn5s8q yxjWdHA5bTqTXD5GojbH8usGLZgs7dj02RoXiNXPwur7uULHmWPMNTwyVqU6snoJedvhItX+ SqEBGcmW6g0OykOORKysO1bd08ybCGlALVV2UAsskYKlnt+cRDba22isUq5Sp3ipJQMHfKyR DxSduE3s/oEbCEnY3mjsBb/T7TPP5TZy/I0HtEG5wZtFuwFF8ijBrZlYQHxdeqd20He4o937 ys8Aj1ELoDfMWrEQTLB9ugEUIGBbRdGmh1+YjhK6bj1+E1/bo1wleOPRdpoWn5hYi8StsWQx /AjU+vNJcC9OhT1s7EfKBNsRGIOZyleNW7fX6bpFIyaPzIIaLC8/+NBu0wWr67zM4XW8+JZn BoOZZOmJMYgiuZ2gPCvyCqTkAReqEF410ZsHsL5NzXbL0vkPlkD510xYQg/kDH8jApG/ZYhs xZ0p1cOXyk7aeKFiyQR1fYBY3GIH7B5+1XvUHpCTrzI5XSAgY6AsVfAr7dfKtC0WxFmvw0Ep VDOgaMdJlJ1CNNzYCMyOZEkv/SFnIB4od+hZX1PwE6XYBU4lN6vEeTUOyxMirvfSUnEoL8nS w9MBjnQ5Ks/twIWdnm+jA9cCkYLDa9Fnxj7d6rTrMK3yeILmv2p5pL667f4DStcZNwNWC89K 9Vj9fzoOxIRb10lxyNWx8C6We2/nKdtGj+WPseaX8wEuWfDaOZs/iGeP+BqYLxzRid9iUXCg SDIL4s+5+G2lxBTWXYtKYF7Inse1bjcMgba64QxjvF5Q+C5yBE1pwS3Wp2N4OI49vXbYA3/G 5eOyA7MvHP7u3ZBuT986EzcIsjeP85ot+WYM7CqsVarjpgbFjIMmhqNH/3WpbtIAxbphXtIQ mcdbx7Nf66sJkNdbpHCGYHK04M2G1j/3PkXJ57dAaqOMbxRv7psxDL0mkW74myvrgJLVgcb/ frFHFFHM4doL+5ygzaIf66Huhq43TvFf4iUbU4WJWVNzskGM8cBLJoAfAtz/cFxBQIOEmfQB X/cKWdHHRhokUGpH2W7867ebugoL0pYPUZ3QZszeUyc3WRPEEA28YNx2xHV9pupOn7+KGpHY Y0x3eqwgouRHkFusnB6tPZmUwoiDDrJFnmXb69+eFeG6+Ag5YfeQy0Ih/lwJFvVF4mMnN4rs nl0XZ8hugX56HBVtA8PL7+rINh5RqfyyD0hAey+TEa0NwWiec6r5PIHtvl/mhuCUkijbsueP 6tCjKp70vv+ElGBX2L0Jyf1MF18wkZSRL7tgHLAHtxrTJGow39Sga2GnNzWBFLXCghSWVqSV iFWwbLXkVhm4OxiGksJzhYut3Lb3m8gQYScNXJ19+RIhOE5KdFWe650c9DR6fcvYKbFhtPLY X2XT3bZKDAA1fcEMkpDDsDxZlnGtgkIlr4XaZy9ue4LEvqwbUr9bn1PaNL59lB/6zd9onKN9 ygFQZjf4sT9b44fmx4G5kBK/JGx3i1YgfjpnjOR4Hld1tanQBDeUJ7PNKp7Um98zBmDwxFZl R8Z3xZUFU5MQkVv96h9nFVYiZbpzEnW41Oyjy5oeG9Tz8+zwQWr0pp9DvNTwNFzZ1b2qTB4k UEZy3Ke3C6n9nGhzM9VVz1QOid6CmGLI8bDNRxhM+eNSEzTSnBDLtftHmZXjoQ0if0XaYSOh 7Mp1BPQewLwve1mxTvViE4Dk/t0DCUbLxRAABI9hyF/pvdTGzOmWHaQ6eLxb5ZWSCdz+fE7F rV8cq+ipodNARBA8l7kubsVWJLpBDntaY7xSLyyxQTmsF3fY5yEZp70/df0WsZefwc0/DBcP tKUInP5/BZVmJ+GFJ2nNLRUVkR83UAncGFxri55YuHkDKcVKdj9/z0QXZ8ucGTwmjYNuIhOL SVljWP0AVMcDegKzqxmO8MO8S1v3LqxZjEXk/I9UrkTEPT2o0bVu4RrVTQc35pbURBie7wzv /HxVxVWz3kLJEx2HGd89b77aFpLaqXky3k8WEZIgJw4N0bzhg24MJcs9FbgW+zhmuBJrObY8 p80ZzHyHLrUrGrMdabb4+R8QtOA4HK3gg54rRid0+xfyhN4tqFWn/MMYnnviRyjjFq5uLTlC tjF/ocEQ0V+gremUIGE5yqfd4uxnWLBbQRxU/pAxsaWO6R15O23JDTmnxwU/E8y2fX9YClUL 781k7a8V9ROsOWmvpQXSJfUtL2tUQjHgCwBM9C3TnYeN5Xqe8AtEGdE5unmq8LGdvuLZrp1w 2T9s84C5t4a9LbUOZL6teDoQmHWA1qOkhDa2kZC64SVTOrdg5HnSB+5GPZ2wh5PYCoEHOq47 rLHF2kmX7GFzeVNS8AK62zb3B+JdjOvucmM/Ou+cZvKkeZglSw5ww0/zdY4s51FE8PJMwXg4 Kz2OIRlgL1J0z7Q0gDxUJBiqPbjX4S5n67HIjgL8Iefc1k35YzFyGFjKhrj0bJEVFrcHIQtD fFGyqYFVOJMBw2aqUd07syHBXw6L8ys3xJlOGn6fXstegvJT0UaSCUQ4YsR61/vH9Jkf1aHa EtNnmvxeSe9BgJotqdg9f3vTsJIQogczUJeT8BLI4kUFPcbYyIt5J0KZKuobD7xk4pnjgExJ z0np8OMYXkT9XirW5OwGlkUkCgFpDttmepPmtOcqClOqXyEzP5qywnXGQw+EemGdcodbEXkv J/Is+zBhFNl0uBqjY2Pm6ZmcGL1OrTcJqXC/k2utfFtwcXEIqHy+CnrSEhf0s7etiC1qf1tj uMjGtFtaHPsrLxWSroz9vxUC68YwmnZjOjsd1c8yP3u42NYjs8nmrDjktCME/BSylsBNZ/aW cEdxupofHb8ov0L3en5Q2OVKM3eJbKW5iYCjRSb3DFLSZNn7DmGnq0v57jAQE0T6b2E+4tci STUvCkwfwjEzTAwsFSqqi8vhIbTWKd2m4UFyP5VDqSyi15x9OucMKbZS9yRfwLhVtdUMSJ7S OKb/xd6B+ClZI9dUpAM0hlTzgrqxqYdb4qrx1gcMQ3EfiOUKDWU9nGmMpA5EDKdg49yPydx/ HX69wppL/RGm1OsSzS+UL1wcCcjIhoZjQrjMSNg49zUBtH5UEE2qTjr42CurcLQEF1HFn2z9 f2PVy9BFcZzdkC7QX24aGSm7pWty+4Rp0roJwFM0t1czigN3qg6tGGPzkyYLu5BpkSEqdf0P ZJsmlVtiN5EZyK3kuxV2wq/H4yuvkBhhXa5InkEUCRT9kDbedbtaqx7nmI6U5BO5foZGwUHO LZ63rpNpYZ0ZSsuGF2XeCX2MPrbBifSbTSUuczzpWC6kp/3T0ob3F04LRaZQSSCLMEftAnas xKJ2ykos24KnaQuwB4BIgRgaS0vcwoVRn31ZV5uNZM06tRXjQENVFfTt8WSvsx+opFN6fCPg OKN22Ig0gxWEGWlgwP0RfumhTl5ISnmf+Br7uBYFPds2RbnVpiaBQtFf4ZywATtJ97vyY7Ba zzfFh6ce5xC4P0qb/YG1mlplH3HAq56Fy2vrMt23MdWozxzFbosj5iIjUlmT2mwRtnLtD3zL wO4WJ03KjZf2uQuWUlbUs7Rx3lT9fJJ7OjeyWeCs/UQs6JjESwS9gNEFS6mFvs0TPC7qoVNO wkq3apBfdVQJ7ir002fWdz37KsqsU0gtl8tte6PHLw9Xo1r6C7pjBVsLpRz4xY/tMZqppaLy Rb3oMszHD+cyuTQdGCAq1uUe3rFA3t5XQRCKoHl5UmOtojxhUAGW2I//cXL+b6t+o5sScM3h WgC5DlHa932hDM7R1SOvfg1HMx4V7uPL7rcx6q+hMVcAc0KK5lJpX8WDw2mXhd/bf/nkelKy QZ9qdwxAmCey+a3CEtSjYATPGhckPEhIvc4TM9qx4dMAcgvE4zJOvwVbO50ydUFyRVpaP37I 9Mo7WHOCkADKILBYC/MG/KbJUp9Mc8EbEQnuWRjJxNkMoaNNtBFx0h9WNFJfoxvfHhPlRRP8 pmMcd9r7v0aAzYSmBYcRkalMzD0agbrTHpTEPVv7EKT8jLTGJU9LBPmpsZGAvECCKww+KkVT ErbTjjz16l9MoDnPk1756vuUf7BN3BND8kq/R6S+JXSI/+cj9i4bG1RHP80s7NCO3Pl9wKof GTnnRIJn42gE4ZpTKd7XGwqTGIEf6FhyE3G1PKDVoF2i8pww+9Xq/pad8J0fJZqVRb9A6FPs 3vjztE9ykNAQLKDikUYtNvTWp3KJ7H6eTSMBPoX0qKtYnTSh9KvQ4QneiAJgejiSKK9RbJkZ jWKjdPMPw7hRnjoyqFcCqxfh9ftPHv7qzO/NV7PrgZA1m+26wjz8gCqLtRd4EyMs1H6diwUY M5LNCVS/iZt12hDj29eJ8NOcIfoVly1W0FR2emFHhR6NXxcUL7eCejOau+ChTBHw6g1C5lF9 rvpLwgneZOf5uzpUDacI8UIGI1MT//OLbKJvVmHSyisKpzI9S+hR+cNpGnn8M1o6ppuLTDyh OlnAj37aZrQ5kSf532Ge7XUo6Oq2lurlICZ9I+StQCIA26zJfVO6EMkciM5bHv+Em0zDtMzo QxHA6uz17s0ukA3SZd4e2DIcgRrnYoaM7hfXI0XqtDsUQwLx8qwCC1QP9b0BlCO5bYFuseLC OY+IlKyA97K2CZB+tJyG+7bYfhWfXchnIk8diCKII7SQ/ogqGGjj58I1SwU7fGnVP9mvJXID h3WnVz5pvEkV8Vs3tjoaFLY/uQIccrRPYX4QtwT3JhQvNArZeGeDNR8JXdrBgbood7fKLUcl 8idJsJiYSNVwJz8ixsRrF9uQiYk6K2MPr9uK72Obam4N6QF9vf1w9d1Xb8fHG72tqIh4UGZX s9zxc5Tt+Qb+1ivZ2UzFfW5iEmYajRlW4Zs/roD/CvGhUG1i3E3cRAIHqHrue0+BnWO4lAju nZvRSBTzD349JnmZtEVk/bekSF1fDUa1j3qfOSIRwaKLMyo+TTWgQidbF85rvsbxlK6dJXIs lehuK0NJs1FkV8LXX5GwHgc3WFsH6+fMaZDMjgu3wBThYZaAh7GKfD/rXmWtuWa1dCtdJkQM sJnGLbT5cY+kvtUq/Efe0QGJNGtvle0N2d5E4QAAwT6jHyDkro1BEmr3wvR/k7LiyVE+Cd3Q fO8oXNqX+ydW4+kMvgK0CcZtRNwla0Zv3aps/JN9De4n2cL5Nn38GcBab5bnnTl40Etr934P KkU4k/8/98TwiqU82Gfzxb32yLEYmGuIGTcIMtUe8rgGgj9t1pYrE4w6c64pK1FaLPiUBoVj D2KdI882UaZ4U8t+8FH9lJ8BCv1UASYhRwsMuFswMZ3Ds98B0u6WQ1phU2T4CC5EefwHjoax +hmSIwLNug1NO03YX6qoa79zL9zudpjuzVFvkvbkCTrV/ZNgW9z4I+ixVVwX1tj2AlrFXgCx IUuo1EhIUbgoXGTYh3mXIq8FZatiZu8EwFBzxL4ziTV6nFUPiLGhnXWE0HzWTTgQIA0txzGp BJ2UzvrLhjxC87JjWh7Gx5bwSMOiTZRHXqt8mOCy4yL4SdX9oEWrPk8mN4aMPJR4qFYqOSTz j6MVJC84E1l09nuEOjZWVlIWNXs0m7XeORjDbbThA56KiqiymcEryjQyM2N/ttIT9lfpkSbp rSQfV+ii/zPImXTXgKMlFRIv7ffZnmwU9ojcyGKYDzzpAIzqJ9DCbySRhPWVeInLzCz/I4L3 E4y5Zf02nc8nkk3jZe4hmh1bSzkZTmK90yMs6yvWUCyRpd0WiLepKIoULvO5YHCy73Skyd9S 27ogQk2rmdPzFkm4YrsXM44vSV/lqKNCZSitUvlsokRB07gRGk/h47MXFLZbSQ4LqkkZSwkG WiTd0jenax/ip63qzsF73l68FSTi4JgA3nzkkzoCgqq2f79LDM4UAHRu2sKzyoCMtYMVSmmj XuAC+YWrQQmjT/5fISwzUYVk0gFM8EFUD9uL7ZEtJRH6zqR2wFQhjJUUb6hbVlCCdSwihMHO p9tDtbo0+41d2IiYvns9q+0AQSkShLYFJ+eIuf+Gr8qheMlcTmpI8Y2LQ+08zbGBOAz1savj +gNqCvDirKRIwWEYftOrE9Rd9CxYIti+EcJPQHLHr+rWoQqaSaL4d4syjSWdN9WpmXyusscL yNNHQCsfKxwC6rvEmLkCnSUKOswYLlPU1C3TRIWSewZsjE5KOeaaY5PD3AkL6ZbBe/R3j2sG +oi8kI7uqLJfpsAfe0BK7FLt0Yyjcqk87Cf6o5KDtYpLq2qWF5lwVtZ5n4YzVZl4NjuyynXn AGW/c1+NYMpEmynA7DdJM47qvqhr9RbEkMDQMDOXqDgmM/oH7br+/mFzY4REiOaGsfIP1psi jxC7yPhFW3ybaBPU4qgJii5esqanq7qxPnXLrlVCWV9K7vz4GSbBRndugDqzjuE/iqzf07j5 L5NYl5cI0sSut744cAhEsSrcMzrlXoA9nq9aDwnjd9DjG6wRIoNNseSIanKcggJmBDezpKcw 79UeKfZuf3wowMSNTlfybHr7Rsl+7txGx2tBUnjXtZLnVJmoeNkS+ouBgjKJZYL2pg4lzZk1 +07LG1xZbkMSCEEEZtsoyg+ruy6Onsf5Q3z8qpWrt9UsAcyt2QBh08+pgO3s1ura+YcHWOeA Ini3zFfgMYghoS4Wt4xFhHALMPOf1jXh+9OXYAvvoOOHTpwNkmTQgEFItVtUtdLDtxMnTxGP Vo1GawCnMOd3AwZcqDfR+tWOKGc7+3zwWC+O4sitbC9CdfAu9s2K2PuNIySEFs8xuUOslEXt s8LwG6qPlUAZlsShYMxbZht2yxY9IXWXIDGnMWo20TjfdpozV+j3ayLVKXGlaKzeDz8sS4vY MToQXdkVM21wSgJIKicEsZe1/VHoLgkWgaHm9VbSv5pf4iYYDD/GBu64QJbLmKjc1yc6CRby lpXJ5SJRNSYrWbthdEjBKuxauuu31y4rUZQdjX3Jmloy8Py6sYtA1fZIB1dXs1yHjUBsvMJN GhHWZANCg9X0VZdJlZqCABCeHc7Pv4answ7hm5alsStjKSlwbHXXvr7m0VG0m7Mplw3QpM+N 9cmuDYI0g/gEU57YyjLV8NkFJKXbOw1YpJWuvsGo8b3Bfo1AiKSyZ0aDNw9CSQijX14NqFZ9 5L5Vyd+yXxw67+r8iv6u0UGBxxL9UfJIuzKse999OJEQ25SdXwkHfucfLzU4Vh3iBvdLcvwe 2WT61bzFalLQ5IcHlC/5b4sd7RHZ7f0aGyuySQv61+04c/Kdf3fee81gXR/X4+lULsjWeGkX H1IB+992dUbpkLvyricBsLK0RObglxYTnzJOYZcCNDIiGlB723G3OKeGqJqXJgfVgv/MF4ci uhJPRoOGVuvp5JB3dZ7wKtn6TQs9LAkscigvSdT6hmt52YtA6yDbr0CpEyo0PQKo6JL0O/e7 HCyS/SYB0S9KPhsyEfNXCzUbcL5akbs02fD9wFmYD3fpf0vCRDYh3WfjKbs4vosJh4dkLJAG MO5q+yVaCCsuJbNfzUGMxJowT48OpaXgpywOLQWQeP+yStX9lbWRlUWALrhjp/AVyZ6BkZEQ i8Q5avqfkFTA14ysbrfOHymoM77v7Vuth1vzUoZ+BbBvCMvMvRn96S7hFlagh3QkHQ58NfEI wzptO2XfaiWp7qZL48r5BxIEr6bLLaANpHM40xNoVkpwLgtIBopBYGSoyUI6UrrhZhpp7fPn fujExZ1V7PI0uHsS67SJvO3nPuiAAqUU0/Nv4+s74BJdq4cMeuyX+dmIMUJjFkJYGhTm9QOS NE4X5FKcN0X2Q3ytTGKwp4IjYAnyZA1i4GcES3XizOLk8aAv2oMwvGh4PQiM4/YQ1X+eKs4j KiTjqkRsopsdd+E8Po/jF4Nyd0KuFOI4nXd8SsL6jRAh1hIC2ok/+j4/Mak18q+muzW3vddc ciugz+c5UC5BurRjEtIewPtG33loroRwc+rXuxlHokJTWOwYYaPk5R/GIIJJzXJTlKvJYOyS Q9OJQ+qnGI56aZ4NHwzWmC3LT0BZbg9JPmvXi+p9Rxu23Pfobz+4xvhmD7XE2wEllKy7bvbi sy/wI/gjn5gwyMDWyABH/aaBakYZQlEAh6o66Y9Prmpu+iQU3TJv27WG3E4fb9NsIf1F9p2s bhgAvmls+h/jhAfpdc7QA2HYYQs73NNW3Iv/mSXrWGpkX4VCKKXbYIO8qmEqQ8WoueqhR9rK CGmJPMhwxmrih97h4MpaLvon+e8TrmDPZ8f+wuefBnPmZIWpckjCa3poyESbPcpMGJC1fdeG p0s4Gf2IlnHouF5nv2CJ0+lfVaL6v3Jm3S2wf1q6ePD7/ZPKMaDRWzCMTgcxgoT8XqThern4 QeO3CbbgFSkuWKau3GxqZNND5Q5x+MB5Daq+5gkwDT+txMBSSA9ymAZfRgBnpTJC0I2k0QCO DB3az8/KcjIyRYds0R/J+oGo0CFg/ktTcsSmtTl1PnlPb75RhqN8QqHDFXqM868jPqqN4Ewg INFGnb2PrDdLYJvvycD/WSJ3R25BCawfTa/RKplfos8gkgj6SPvS23S9spHBR7sK49h388tS qfdP1jaxFodrx4rpwaV3Uc+VZSzaM0ejd8YJlfqcQ+G7oFkbaXL5/EnAZKnMfonrq9D/mTOK U1+n4uSNLhZ4TDy/STxnMuhVbxanJbWh20WABz8vInUtJZ6zz1I8RD7vfG7yncWcqct7Amvm LMMxt1mUm7AF5zwx5rygsRnKKHgJxk+IOA8A5jRvYlCxGF/5QOCN9JFSKWCv1h9x1FZsIphw mDLznoG//11lrGU/GW/zZVh8hIEO6v5aEcC3r2A8CI/saoGEnuJQGXclK3HwlaasjDcnQko/ TXIKcTnmy5EeH48Wq2KPKF2E/2AFOGod9verYW+DorKnA188LOBcr9IQtFUWvL6DRDDpB0Um xvAYMM3Hwcegk2NapbwlUOhPjvQOzUJwi7AlDdf/d4XuRAtEuCaS7H+0rIKwXLzYDRktJuCL GS/VGCEKFoBZ0WO3+f10vHG10f70l+MWic3TpQ3nrUlTKtHHxm94I6GOr2uxPSagXm3p4oIZ wJvv578YHi5a+LFPVbO426NMHRgfreJuZzIGAbGLIsgqK12IRJ2soPxQjaM+yckpGV30/9uC 31iNU3+FcYaT23rGjZiQ4SjOGX4nIauCmG/kRGosfrh60/Tt499clfr3ewRM7exbNmAgJLZp 2H4si3h5zz2d6U1aUrXGE5tXvwMOSOgzs43HpCkdF7cG9zsNaTU1x4uugu/E2hLk9lelpLIV LImWryymYrm6nQ2JWECp0Z6tO/1Z3Nubn99wAtXb3VJyi+RwGbTb+YNzt3FmLan6B8VM8Cbl BqX+h6/OW0XanyK2HPK9LA5S+Gxo59MZF2gBIKdvmb08RIR/VgRpR3pC4NsVQdd9gHMkbGdj zVdhzzl/JEuMZ+bVNRVj1WBWY+pJgKu/pOj6vy5doO/l6KppXCBAulhauSffOAypWH4iBy/L VSnyTdhnric/bKgP3ZPQLyuZtXA/y4u5KOUHQZdP2BBsh7kBT4MAFryGbUtj9z470YhP1bsW abTUvC0rw7y0pi9LkwViRpdXhW3s7Z9PLg29TD66orV/c0BUWw8mO56oHfvMVWDMZXczS74n 7VhYtUMdPirmYToHSORURb3xJJxqqZIhTQg/LEzcH2i2uU2e8zLoCCY7h2n/NdIy51Rgup+u Lr1Acra5g8bmEAWzZ39UAaIt42ivegIBkbQAcjxx8Z6D+ev1vLuHq8ilXHDpbcFnzsXXZJ0B ZVCIy+f0AVosYzfA1sQqskfE7ysRnFa8ZvrO8W3lucqj6R/248+xGLMz53YAY/m1SlBoq6Xz VSSvVK0Wf8BmYZdQOczr+ne//roKADRj8q9wBylugR4TUWPVBCKd/aYLjLV15vDiIFyzWfA6 m5UQ9OkZGlu2cY5cvRS92qGwsH+sSsxKrNRqjOi1lTYYZUDiR0WRMYgdEK6WJMhbW377PxMG i+oDIxrXIqhq9K+zTrUSnqkZSM1E4seXDRti4uAwKaU0q7BrNza3E4zIkihzGENzfWK4mjWT QmH8wXSpfkVjBhT9FG+hNE+ZRB0KWLQItcb9JVJziYuOo3BlTCshrv1/OwsFAFN1qzpJFMJv Y240KV5ltn+gHGEhm5BYm2W4YH0T8KFyZf18Ij9bxFMzF+X/4ZgjSJqH+ZidLBWm8aaCfUGF jGAcLxfEVi3sKOyN0yHP4Ddln0AkbJZvazvjJjtsNqrWWf+Km9WHBaG4MNy+Rp9PwaoyO0Pu DM1w30fLayqJ0jaxvRxm+vrQs3slZfzfZdwcDeGLwczAKCj3hS0Aefzlrcn0FBoGtvrgd+py sW00P0IqEvCvrRutKQ8s6XaC+AjlD9czK6Bi96a/m3uZCBpO3iu3WhCg8GCT7iFCGYAj3ewy WiYZTUkBw4R78UgiJ1Hkm6KiTvY7LqBrRJNoFFsNBiN31Kw90YCGMoZtvUxn5498XHK5LfGv UqJQNOqgstyPko5R59FWq2xJoCr4CkKGLSm7xihLVNGHoNLNikYVVvGy/KWy9cTAj6Yue1+i juwb+UqZy+Wi3xQj4J8bq9N/vH9+6cxokb1rR/nVXlQgsQ9R0gtMB/XX2nADyIuFaPENTqaK Fl+Kkm9yHUTU2blBG7t5QK9JipshI0svl2fZNLCenr6Xatpj9AKyejORhGe+cRTCtavy+7NP NGsCQFpQLt0x49qZfjaOvp8tyYt42oiV4maOSSMjw+2VYDaB2QCwGKUn98b8/s3LGdXZsaK2 XBX4tYu/AHpjB/4S02yYbJ67tOFl+TvBsRhe68RYMXsr7NI0wNW9AkoByG5CMLQ+JKevH7bE ERSZ3IoIbpar1RysWpVtaSIxjX3l5y1yxHVeVfvxiK7HoI7H37Lzu2gmA61LiHiA/lAwVRLc OJaiCo9udSVpTZDUpCYSYQ2jDv88dZE6E79TnLFtCuKSsefiln82JZxHX05kBzh3pFsMoCyB IJB38YClSv/QrM/mPJJUZv98evQdmZbmddt+C/KBJGVPJKNrwuTfKLU+SCAPUkVhv6rpVdvy icKnSNjQifUQ3fvFbNq1QI8eK3Qjuqly3xlYJlD4IzIBnxjR7kpIINqxcmwJDL8f6UFLrV11 DbPJKfyF91Qy6cW2TaUgTATCpPUDGkWp50T68gZ8e0ZJ99S/WagXxleAeqs7FIOap9UzTiYh O7alyZE3aAKxTeUFw2Y75/6fqjnjxZuWOMIzbbakptG1dySr/TMb7Ctsfwhv9IuFMDGaX8oT Megx8pKoBhKUGGSc6EVceqW+aQY4p+asSF+hR8Sd4+P7bXFs9VxNYHkK7eEELjfbkq/4RnxB e4Z/w69vDjEI68qZee0KIr0NgpDzmxAX2z3NWNg9ygvvEO2eL0kATwlZOnfUC61Mr2y0ai7r Qzth+K1ugqURTZ9cFy/wMLYnxC1eQJHh1ajHapfxyHbRVhZKVX8ytQ7L+uz6faueFCNEwVd4 ccZipbJpCas2lNKOm7ANgVSTFQ2QFPCvmQ69Lw2sr/w29lqWfTvbcRewOXqWC9EFJVcSu2lx lM7Kef7wWi+VK4NQRoZiwpMahN7jlDav7bP44HMqKjQzuI7XG2YZyZDmlCpjbcZEVMtgxAxT wZ0R04XngKjaCScgmodOMl4aEkPWU5tF4JUBuWXcbE7JyJNCyzVNH5FuliKuk43iw5TjSFH4 IUmaGG7F+8IfsWPbtEtdxFgwacanm6y5eZMufF+zJkq6WlzHDLaa4KZ9XunMnvzwNkoClDm4 ZBsIfgxnvBaoJiFzyQpSC54U0ArWayMu3QsvIbNNMdff7P4wAgKY/y2HY3AuRMKPTuJBRuXI HBfeXTbC/z1dcJQR8ssYXm4NJ/IEPnk+sN73zApglZ7i/MHyJ1+trqHr0CiMoEsnKFua6myP /6iTyDeXs4+1ZOUOW+PJEpbPbxulWzrPQkbLZ1GZDLdqv8QIGf3zL8xI9fEv20hfTZJtOuCZ ADL0vWDW8zTsDJMx1IZJxa3wnQlewVCDMikMRgeRtmTUrz3QCN7jUSgj67JxLrVrPWK0so3A oeZSDZ+gnPC1sduCU2kyHrRC/gIMKQZLWkz93+TiqgQJKmGoZHu4LngXFcDDKshLow5/Dp0g BreW9rTvTbGVur+WgWeLI++AznWZNlNWEvTPkSTsv7MG6gyPDLR75mHVu7onNqIociu6Z5gP qEeRu75sFDcteLBS1YCkKVMuP9v+xDtD8UfLpna79B4KU9k4vrrSgqn0+OpsXov3aQUXRijK jEQW8p24qnPjknUMhV8s8JIUALwSoyDyxcLNvgGns4PQ+3ULWvPOSNJuCsDKfpPzS6oS9VqQ XxKusuLRWX3xMj4H0nD5H8TrUP6oMtwt62aNdg1LoqdYyJ9hssHW/WjmeRVpE9QcSKAybSDe C0Tkoakvijm8MX0WtPUjJdiWWECYYvtspiSRY9s5C/UslIjJD3oqDk8RkSEIy7JwhHEidxaT r5rNN+9in7CjQCaD6tzigdn7C3u2LjDKmje2SJOSG8CEYhZtRS1dT4yZtK5j89zGs2qNgvVu 9jX/8DR0oZXm3ipHjb98wGHfZKTxRB56wWNNNx1aQKXwk4im/3OUbkN4wV6mgFHR9sqOfnMO Ev5T1f4OFveLKH8wO4L0edXN62JJebJOfv4j3uZJLs4kJ2SpLN+GRO98271KJvfykY9FFZNo 2vKfwPUZoZ6dVmW+o+VwNUlJI6cAkXz1+TSbWlwZcUzYtYTUqT5pdRGkHGwudGQ5zlOrnHtm j40YwWZbhy7QT2ZpZD3O5qWqPXt7hASGoxbpx0jNIIwaCTeq/wKBiCKYHm7Vfw7q2TLsFUol /O+YXEaf/BrFgsAKBXGulo6aroRTIui1ehrzluTwcsA2HkHCapSFuk5H/zxyWodPGvs0hiiW Z+LxtIsmDhih2SKT5RmX/dWfDIe/jXECOTj311yya8Q9h7ghoX//huyqfH+7su1gXTnvVmMs GWyLFKPs3zfeVLdTWnMq9/cCbpq4SXnjD8PGgswK1xgNCmDws3JUVtFzu2slH9Rwxbx47bHG BL/naq8WzNpV7IF/SiGML3rjFisKnYazVRRcGaR8vkTp6hHwEyXw3U5wwxyCVJNMRxqUE1C4 /wi5MZAAUCYjLWmI6Qwxj6qJsHmlM4vlZFutcrMvKngXTX9ghsUxCaVw492VMoDQpSbFWjoe atGl6Rp6/MDV3CBwQp9M4yb0CtyKL//xKn6OhFJFeEdKLp/niX5CYaGyk3uOO32FM/mfmLGt gWVshu7epU+OBVn2kr5q1isfJbPq+evEdYiFgU24uQeMdPw5AIKmolUPrYo5jCFfVUt5zEWR +CxxQnFtz9/o8khMTj6AQE6nPiByPymFLILLO2KgPbQKpCwbkZN/NRtNfCetoU5eVxY9yxvE gJ/1ficPr109r/rULnAGf6yyvHPTRgB0OS6u7ZCuuj8buC+UwwgdbAckj9SIKnCji7o8fEZ9 qPRepcxBbz7AytAq07tOdQ8k1Po60gzSTu4O/gsTz/Lvc1xtHqeOANIQOUx/T8Fh+ohXp25q QNV5+1mrH+QSeitJ6y1VLen6QpIUbbk2P60MEChMrJzova0qHYklJMsQ5APusCiXLZv8f000 ZXmZn00JQZfzNvM1dlX0yvVAiJ16wdvZAZw+oOXx+6BjWYZFcf3CPx9Z+AJbCxYq6B5YpFkp KLyZ588O5v5vAkIUFoMzyvhRddDNt2wON5w9wfux4qG1IslKXeRMopfZbGM9Mpsq9D1YPdnC Fc0omerv0IBZq50f88qxRXrd8gXkqkUg7jvcsDbiIw2MPgajUEi9okFKOa2yOwg5uqUmh/KA DEZ8KEgBI8H5CSpA94CpgSYyePzbSKMsPa5iVwtxiVirPdrIZ+mOkIxmoFD6U2xwnpxMkUZ8 LOBC4bGxzgUE9B/XGFsPBAWcMqSwlsM2U9TTeknhG0e5WrgrwwwBYeOF9MXk6SeI0bNidDU5 glnWw3pTgK8sy2WUaeZJIbg7eiqpB/tuLbTbRBBLFn8tLLY9It8mF56MNDzAALJjakR2kw9h SWGdWtahuXyX/1bz+2jmBSB+PL4Z7gfEL4n2Ox7g3Y8dQ9psVZ7tT/VB6v8uBXEIYixKqW1/ uNeSc2eDSKxYtn4ZIBvxAWR0x3bNoW3sV5E4uz861XuI9KMTlRY5zdN5yWY+gH/l6Bz8TE+0 TJfPt/aOQzIiio4EapafeDR3ITcWEt7s4VALc+FeFnG/q2VqzlTCDVRJM5AEZC1mniBnW/G9 0Z/P5VviRagcu57GPB7tqJOST7gYIvJDhhxxQKJgMEY6KgQ4sNcGCKajFmBm0rk8GEcLmGSA TJYqSlzGSF9OKuwH0eaDxU7Fhx9OwX3dS9ZGWfBYHnA+W2mCrXw/Dfv1tp/nuXnBCWtBUidF 24BxSOoTFLsrNqJIUgNXSP2i4ODYpOynj6W1tMPm+YGkgHzJHDXfyPmePp+cwh3AoIhuBqC4 NZQ0Mbx7kAjD9On+Rid3prB4dHjR8k2+ZmxFOGEX/Tw2c18QgQGOb6oFgWozv0ZVqo7V6/E4 LFXE1czRBb8/Wx4lCGZtqWAU0BK50huTk07A8Pel1DgY/QdbG05YBh+/gd2/B68rg5wwUHPX xdzIMYrJ+v1RvQFu2xODYu5dZsixp+1DtkXkTlAgn+6EBA/qfSkKozYzdZMEsM/Z/8567kvU OCT4+/iNz+ga7bO5aOZPE1F+dCVDqr2VDx0f31BkLm1fjUF4DNYHep1yIhV/h1/BPsN34vjv rbQxv/yIIabhWgmf7nkO5p6dRPLF91/BkOP/XbArQTciW96DEEfYGOtWa7OCYt8Y6fpQbWhI re3wd8pf1dIZ4fyAfCZg40R6+0JCSyTdsXtx2b47q6DFte2Ks1GStscVX7Gi3XNJeCxZdriL NyJGE4wMpTr1RpKUiQZK5fj1AAYy9UUFvfwr35vQAXYvLR6Ubu1M8CUnuhySIKCceMawBkwB UQ5WysFKYdpVTvitFXwCnh4VtpD9NViGcm23Qn+8ui+mYmSPsJQifp+j4+Zk96AQjCILDJpL LgXRQ3eRfx2gQrutxSvBnPryr/TbXpmc/vz3V9ol4l16qD6F4dPWAbyV/zwHcHYDXjr1Tmtu Szug3XQZ/18WRl06jvz+/s5Rtzp1Mja/YMpwWQrtxWxl1WN8s8s0F0T0wCfwcXZD2GWmjt6I nFw5G6hNn3KOaaQAQ6u0O5viIzQA9/BDjqfaCQqFXGAgqkikp+UWEXEwT8yMdyvHdEIC8qsl hSxTygvkgzxzD6EELWSRP03MPQTtcjY6qV02TO+xSojaxIayjKAKNVnDdTICM4+odg7Eh8pd vbxDtzSDNtbtNSXgh1AAz/i3e+gxyDyd55mlq9XXPeLehYUxxJArfvO0JoCGZkL3xMQw5nZd q8JR+ImrKtr+FrE/eQi2LmH15Qh2KtGjq25RwxS6ADxouqCONz0PbuCYem26iHoUYgpZPBMX rPAnyIdSGfTXGxiNIQlw1NoAY8kdT7gJDX6KLZBW26HTsyAuhEEGjzkYzdYMv1MT3J+2KOby SDrfDGLhmv1uIcFw+ehEugLvik6C4WInMUjibcFjQpw2BqOmLCJJHqA6/IPdMgtzgIYNaK7T IJlt9+CHL5Pj1QLYKl0E3w6yr4akbY/IH9ykmYN4L0sxDRBYCKWkMLLdB6KO+IeCvpWBzKRj ol/xoNMA9B8y3z1n04lN0xI+0f9xP/d19jN0ffRDAI5dBXixxsnuMvtA2rxmdGMI7S2f6y/R ZzOTCJ4Yb3yRGhsIfv9cq/i6sVMa/ZaS82CPw4SYX4orsMYXzOmwg3n42VhiZxm01AIy9fM5 P22Ffs+Ub8WdRTfK11kORKpME3/uj3cDQIw8lT8aHg3+jrBycIImkheSnvVT/Z/Ol9wPBLHY hnxFAUsPTWWHp3o3Xy1n93j4e1a4KEfAzc5vV5AgLfCSTYR2Gw9rIOLpLEPlrkuzJkCIAdbQ SpJgm4NL5aCepafBwRZytKjynfM7HG4op5aYd96fEL1D7N9GZbS6ouiOIgG6ojCkU1M3VtBl M1b9t4a52qtR3BHmZKkWmE2QPr+n/3R/4/s1ENfxyT18oW4Gu7JQrHC7WGFTc/P38QB1TSgX F45wXJ2PYNakr3qC2w9NClLBTPRt0cXqLa3VH3sqw+HCW0/tXViiQU/PZvRD85etrMm1gZTH AyMSZW20IGTu6fq2kbE0Ftx8C4c1FiOIrrdPrp8rbAncg+hUOlPRrSbHY8H+aedf4HaTXffM iZma6QQ7r22V8nwqi/sEXIG7Hc1iH0/Mj82ROgd6AD4OAfVlidLZFJtuonMemoqHG9ZR52zv EDgeCLIPGrF0fSmaJ0punkYfk/ctOOPiEobaVlY6cDQlnjlaeDBfaayjJEdLESU1CsXqkZXN ZbeOKhQq/iZ7b+uKcsEc9bynA4q5iDZwlpJU91iUVj8or03Ekab7ieYj/6zYYHVDT+xWda5E amdN/jOnCX/IKlXtPF0HX3dOWx7x3MRpQddVqQ5fuwtcenSv6D+B8sePAgUlOACEMvh3SxhT 4zNdajjhLgTpL+zuHtRLNb/a9oP4w1mIgp/JZrhpA7yW/VQsOSGJinqQrEGfppBIymvF9N/z 6kRKQn+x0s2a0FMiC6CDOTjXZhxbH2LKLg0LI45uiI6spp2yapZLTgIZyjGK+NMcT6KbB83C TZv15ZDIXs8NzQFXWLER5gpKBVqKMNdJ3eIftF2OGqX8XJdKM5ccKgaWQLTNmVUf1SluhFkL B1aB9SQUf3joti0lUplkFiUV3Y+/LVf30gwB2RlpYiZEhP0gZBlY8X268mzk+/3Pz2i8kSYH HaqQllKZ6EWXL+MPveAhl9SLlo33HA5Ra6r5Qn4vufiIo4tKD7QbnQ6FOXhGafZM2JLv87Cd hKumYoydBIU42XQq5F2Ia0ILB0jPJkGKMF9boVrtZcjYTL1nLRyXis4zt50b6mvgIlxWV3au jM9mMs06Q77Wc9UWIHUWJsXfe6fzwyjkV9dDTL3true/Qq5C371YvJN3CaMkdDSbtutJjc+S sQsD2iWJC4zBLKfh+B1sVokiZtR6DdTvUCnREZgBUNVv+dSUUxzevZiRHU/cFARXdOporsrA qdeo5QTMcz04iaeP9aLhg4qnEloT6x06pCzyJg4kImTnDBQ5mKApi2pvGdMuBH1caan8dGtP /Ddl4jAFqXi1r/X6VAA8klOyesMvNoKj5TyaaKXl7LRnLMw/Mo8prrDcPi0sXg7eyR4JyMdx qZ4atwE8WPYZ6MCz1UhpORLdjYLeYT6JLtKYR3Gez/yUga0upjUwzbiF8Jqejwggxs0N8zq5 ProUnQmOmv/wiCmGdVcd4wwcHza13U/m5kWJBIVGaoabTbxWXVvzmQB3fT1l1qhdqlVUCh10 YQBSOY5OopmXKiZTtRGcWABGhUvtCSljdbNQNqX7s/tvbJRTdp5/viWh9Rz23lC7HnpenOVM ng3Q8DQCMHs8UB3KR0PfUCfH7nFUF6j4/KZ7cFWVqBSIlK5EsftUxl06kGa0hwG8Y1yoxdCU gn2p2SmOZcNG4kwpI2gexpLrMv4dQ/az2E/KX6Uyl3plpGX/jEPYPSRXEyZRC6yWcaVPF63T Oh3/w+nmZOc53EeINvdW+A03lCqBAYMHyJJoEE3KDCHo9d+59vYaCB0hPcqcow/6gFr/IozC lO3Qy1PdsYr6boKSvpagnt3VeYLe461nKtAFJhUKcnS8d6o3r9HqMpWM3FQSUGWiqBqtfo0C aN4lYvklAjuA0msepx14uAwEW/ACAawNCg2q1Z3KOo2nJOy5O7MTWn7fozvQgCFkrhfX1Pt+ 3i4KLKG0dJ6hua43no792YVzmcHwpVdTbS7NmIaYZz0oUM9DobTrsR26mxqI84RY4EODmKHC IRTDFYjRl+S6dmBfadCpR0KbThZujCtGLsLSalGr4YA8QJpEz5MEGR5UlF3WYTaRUalaLtRm G6kmpnJggv+rnWTkE5zjyn5k4Fd6Ip9anfL8nD5Io1FkkTcwjgI7rqVoA2mJ2bk+AkPpgjjW yxSVSGkHzw9UVihgf08qpaa+p6coGsycX4hfLU+wrX5vqWbWfL+YWZJZDeanz+BHP81DlGm3 uiVPTEWgjyRKysid2kMIom31bClhNJ9vm8mL17vuSS53+myI8/09TLyh78VeJjmZPAI4ezwk QekmPDfQYbNcYOUU4nRIFNf8MaMDgp4NQHL8h3834Ess32MgvfCvlAnT8TKqRG92DAtH1fuk E1EWK96rGq2y+mRzLS3H7Tbv8ayqMPSnMqOrVHPbYXl74MHfW9oJFpA31ZnM0grx5f7dHPFS fYcq2qyDHcSthpuytAshJmN1D/grgtBNZANLGHxxyRo2x74JbJZoeAiJJRRyI+nxAkxDNOcE 3IHzkh+vrzqnafwnqHcbKf0OBppm3KczBEzpc07fTnvoOQZUyYH1pwHeh+gJXaiA+Gh3wyOF susciLGVIdLEyS7DRz4ZauWDAQltVbYhl2VCfD+FlHonHLpn6TKAsU7VDzqUEtIfRAehHF4h 2qQLHLVT3uLoiXmO82Lrnh7Epq8WGos2EOvLgn/AYOqmKtJe1JKPp8oTRU6Bp+6ebAZ8nurc WBggSdPko5OYymRDYvvkPP9/dRhGn9V2ZW5ScV0xGA+XppaED4qiH0dGXTK54i4ZKUCuXkPb G0mgvmQW+1lQsTfzsIO+DmIUNYza+niYEblLMT3ymptwNrHaPGiJrztP9au5OZLbs4jv9n44 x08F1XM6WnDFn3vtBdF/LJBgZhSaEV3zaIs1wmb87Gb6c6CuA4HI5j8cWPTkRsqR40SY1HlC dlwWrjeibBuCbXvjbNbQfmNINcxhuEQXH4YH4E0jcANioOILBRpGYxOPx7gh9GrXAIMePWCB IusunC0u/sBHv6Adtx1e9gG8iiAu012TV3aIb17QAbqC2oSRDODS/ELG9AgKeVik/wHvyZNR s6p5U/2mPhG3FjTfNHP2/ekU6mHpBNtxTgokrLQ7Qr+HN+syWRQMq8JgQjTgfTOozcpgjQZH qEPAPZ7+nolABFnvcmBWg8QBoXlXLK0sCxyg9q+r6Vi24L7clsaWKwqxbDVFyIyuFkEYtRvk xqGHQFvSoCIak4lSxHdOqG/9vhEKLau1diZ6yHb3SegOZmAkM22ifISjCgiMqaN5D7zKX4dp EtjJ4xC8xoMFUtIzQtQ4N+tmaDlXvh4VDA5Tag4cbFfsuoIuHjR8I/SemINYH6kZ3Qy70nv+ W8+Vavaa7XkBGXlASxAJsZY8tbBoGu6TOU4aAlAP+Ql3olxj6xhE8skkVUUvDkhF6ToQ4JNu zaY8f2+K6SpTyTvLmXqrIb/xXMVL3ZBDh/UxhTe47Dx81YybU1nr5JnoLkMLTfY9dLmimAS1 nCOMdavWtOA6/nQ67//errSK0gbeJEMfDPcMvlWeM1rTixEjKHDxbg3BUjPCG5RRLjXG/f2g eHmgjVqQo4BUcO5iAgvoiQx82EYhQ234GC0eoYUW9R5qonHh62RS0CnYbmihpttjt2IyjhoR 8z+8/WuMbWBVVlVkB67pJxqFyjhCvznhAjZUsRGNIbHukD1eolya8I2KN38xcmBNBBejZxq4 3SSBr5gIDbRfEq08MR3AjxiZMlBHcHxIho4yqac2KWTbwBuQxGJhoihOE2ftstb9pr7xK3wT rtG8sUsu1nEetsc5xlKuX9eHXL1mB9cP97BO4GGM9RB2sYuY0xDG8HbsM1/szMVCRsTK430F qqvcVESil7irgN5hOQYPe48rDhCWGlmBwXj3RqR1r+KGntDA2rzTrLU4mElDHw1FTRRqpLHd XvAW/Rew7GQpH2/2paDgLZtwlgRieEI25To3RyPgxu+p3a3EJ+KrBanmiXy+rL6+cVcEQXF5 3e6B0H/MrqYlXtv5KTbeK4rod+h6cLn3ahDGIv8DNf6YJGQdQuSPCItFSLx/vlnpE3Z7Fwi8 vHKuh1IKJmXdFgjSU1tdA5rNHA+L8YAnwpXtNtkntNJ8/AMPpRYY90UEyCH5jg2QUuSAoviC yMlKdtPUvXkPnurGyJgVx4Oy4zg793FlfgEhzBZhp+sTAmeLi/XTFR/wxbjP3YkH7Hdf4YoA G+TDl4bpdGrTdtpUY9nrZH1LNPoVCwuoFTO0BpGXCz2wYziD6wyB4ylcienET2YvOdlXvdhv GjsDRI7kcwXA2q/2dWVh9hhgsJ07pQITlTbDn01GP8X7g1CnQlZNc+k5U0ZKFUnjN19RXTKQ 5+FE9N8MJ4QIOE/KIV2aFJ0lvYA9nykU2ezpKymgww16HvEOvgKN2faNWqQCA2/Ld8dGtTag 9i1wVg0drR729ufIVjw8tIBa6sHiMGaF2Z6vM0L2wpL9VvvUEYvvEhYRPsDncVJAbtrPE1S7 15UofQ15r5ciYKo7EJLSvlBuMSoIWZPz1lSrPtdE8nLsk0FtoNd2doeKBQDN8zrKuNOGvmSt j0bE5gRkadMCFKpu+eQI9bPh9XKPSJmypXsCCUM78eZ2YMENQuiH4Y0JTFKU17/7BWcZO1Fk G+GBPFeJgrYx7w+PXT+hFXsPc4755y2bDkeA2xZQqVmeXQiBKp5K1m0UsSGcLjcCDLGqIlVi R2i7AqTxpqOXUmLwr/HG1LKUZgzfA+CG0c/TNoZFFv+XYMeoJMhdpd9HmijsDfFy/SKLGnsK EBMpPdpSTXWOIXqF8vTPQqaC8oiEEB5IWchn/8NQgW+EMhAGveqcEHhy2HFDC3bTq+SeK7DV 9C/NGmNWbYoOtgBL0PKlIIOAMiBgsSbb5qb1+SPExcFZtTZnKsq+N7qrgaDcPGwviNKlk5Ao c+DyEQXs1FlP72vk37rL3HNq3OgFuVFT6QoLLzCvyjLCM/u7pmkoURObpOKdmJoKKrGA0Vhw Pnxvy29c0YR7ii7RlX3NYL/V+8a4esssPa9ttNWbIk3lp6LQlsNStqCnKWudVHxooptCzWmD K+lLLb0KKPVRirUMtiuQee+iePR3nNX47pxOu4apRx95RfZWErzHTQPJI7i1LO6IMiUTNKsM BwoGQRATeeaA4k5fNOqQEF49akQPXiuEcxhy1Dg5UdTSLjW4UMxp8IHR315m0JqFn09GQyKn ILCPoWm8ovUt72kZSqhXnZ3WYGOdIZchFmWAzJnE/jWOW00V8AMiJ5hrsrwQPt2HYWY9kCRw xRVUma95W/1oaMZCuGRFBfErbpaBtetIaX4/2G16wfhc+D2flLph0hF2XGYPNrjrdTKfAai5 QhK96opydGErRtLxur7TuepJT2wvJ/mECfB2PJd8ezGVcjWxzwxlvHAlyTXnHrke1lCBdB5N qsEn7VvniEe2W6T8nx3FKbz8VP6Q26r8anPvtgy6J2IpS7IgwEawQC5q8yMP8HHsUvy+3wta kPQ50Eu0HZ+mDbCzIHrV2CqBn/R5F2xwV/mhDPVfUA65m3wfsAAPLge0yBM/exGjbNwJ1m/Z MJQ6gPrGHSxOqnIyOdM+qTUr+BOBIFTYFWKjuyZgvJsVUbbbwu1yQntsN18gTU63kjcVB8UR Bf1N7Ti8Y0clGcjYNhqGCu685DmhJzGrFUua17OEGlEISqA0WuR7M9my/pbyciuVSOloqcu/ nHc5hCS0aCWpu2hZaaQtaOwuPS2ek/gu01i3k3M004JrjZlyvVAUYN2f5I0ICr/M0z4/hifk e2vv8wbSTBTFl457HVu5tNnlAPgnDMAD2Uv+Ge7Lk9a/H48ahy0Lzt8cgCRip+90EmRwvdWr Pr7QK/2koRkc9sFawgvVkujuA1DvXNyEkpPGXB/UE46XpZNlqYWvHQOqBvHac70GR9FGK/Qd Ma7sZlIgQkSf5PBTfCWI+UPkuOi5l1cKNeDU/gYxqY+FpurotyrBiIQfuUVi1jAbnnrQYQUd xxmMmoRXm6uhjbCcCYUAy44h1NoOqRaWCt+c98ZsEl1SiRb0rYvU7ko/+yozu1+J0wguvO0s 6mR89w9hd9O0unaHDwsQBuA+b8xEmnnnxN3oEKAtx04mslv1z0BkFY7QoMmmbO8eGh9789cf 9yCoJxnzRw2KlUAwtXJ1S6V7sxyEwpVvKr+vrO4JvU2iJAhktCsTloUA0J62TBmMMicp/fgm Y39aY+8krTTmghrvsH7SIP3YnyCqAwraEmb1Gmo0DL6sx7ElPusQeybk7aisShwNXCfQP9hv o4BR3jVlK5zYI7iTx0ncyZl7VkHzp+Z6rnHsfU+XzZ7t+uOrVclHEsjaEGYvB8+jlcYv8iso KZiPcvzZOLKgWp1EyeH/RktuYVSUIani7EkjDOkR/bEaV9fFDrNUwEf/vpm4LWfRjC5+/Igh 3JA0BMI9KQp/B6ICggDYsRNowwyZNqstbbbqwOVjS3H8KYHXFeODhrhayspJ35r1SVuJ08E7 HzjuIf+bZc3Oe3l3aUFO2P1vslZ+FcF8JrhGyiFogX8bOpZm+9B8Gxp2DIFfMSyko2x91r9t 0aAMjw/drqwMrU6KYlPnBSMzvI/fdq/sY2Su6mvGbsmfKrnUVN2AAbxl+fFb3MDQDVtOnDNM FzeIN2bVf12FsXDen39MLmsSQIaMqXqLKffyMA/uZtd8pbsxEtxBwidGYnIWftuFIPYFuSmM SxI8NzjnhaDb7PhQt3jX/8g9v/zN2CHd3qwSgj8P5NaU6fB4zG2wcJwk6/VV4H8ZsLB/PvtC WNpsSKQQaPcYP3vWzd09J1AzTOe+b7t0MSJRpwGgvZ2dp3lWvqbKBzPrHFInh8fxz+Xql5ph 6uZVl/RljO5PYLrML/aA/qFSmxk59aRLJ8QpRlV0beN80/0seo2AvQ9vdr0IK4h9T4jeO071 QGyfmmviFa3eGzjr1x039XPZnSi2I1gf+6W3nOajHEweAQnlSRlhQCb054g25RlR9yyINPcS z8wfy1RynkzdzEjs3Dx6DgRKY44HlrLWuEqrhV90CEnn5qbNScjlV2sAnNz5jFikzUfusqi1 +mqALpaMDu2hVFoCFVX5SE/mJZfSSVPZO79Eym1SFK/Pvh4PS3TNuUEqJUU1ZtIQdIteWJog 4SHGnGK3U4eoIZenpu2YhlgSY0wsCEBk1kmpYs9ziGmIcGyHbh0r6/jVhOPsPZ8fLHZqYs+S LCbvR96qrBcZfHhu2Fdetyv/s5RrLMFi7aQwmPPeLgtrSMqeLFsSAGX1QuGgKZ4bWJHpNU2C +qDL+/7kJNfxyKRarLfEg4DKenYnjzkVmOMR0+TpxwCqw5S0IDewlfDeE68sNsZTp714+y8k deoStxHVcq4MCW2pqmX+Dc6opujORAj9N36d6QY2nfNhFxvU7Ek0RONtMh0GGGZ7PLVZIEBT i5tjrhTEPikA9//G0tv84mgpdCY/7dT47iwzVj3prhtPgN3+wiB2Hol45W6y6/cxSOld/591 EOe8qegcd3d5qWJoiXgVxWog1KRxUm3frI6fZwIhTe68gJtdl90tSnp5sNsIcjrVBrEcib9D cBj4m52wAVJzZCByuUGg/cbNmohCph3CUKimpmxCyFHE7GsTpHpVwNDPqMyImfpXU0vuOeQN 1Y6WFppeEMzFVdSpn5XwBwVZqGXRrwKN+4jT+ad74aC9wNNxbdAdogWK5zhopaLR5kVxsFfP ItZGyQLRV+eMWPAm/HjswSVNirUS5s9umR5H5bPf3siJSnVMllNgg4JHflBBt5lF03Wrlm5T BGSnVNOb4vh854M5Q6zuLTNbXVIJCI9EVolZODba5UXc0eoxCjO3sTdEUyJx1htGMrNXxq45 ouMsU82yDDHDt1XbOhA2oGSyMn88DlmrSB9mwzkr1ZHgVlmAM7d9ktANf/l/OWLQZtuYuC5Q XeyUcSmuEIZDcmGNkL5c9PShzpvwBFn1ibLoWYtkDcUHqI5oYiUGlAE72yD7EEdGeWMejJyU v1zradXfDeMFZ1WztRhND4COXhurSZ+grdfUOEilTMbh0Nk/IszmW1BCosC2CehJnH9bxlCw ojbjZSrETvq6ub6BAvQRNOjNaPtqHXyjcbLPo5RzgJ3Z4dIoDbGTmbnd50kbCQcddCvw2+Sn Knc6U9XI0U6ZIN0YqcUnyvkMUy9xx/79Ad2uOH1Kw7/dGbPdRk6sPOZzyxtNP99b7Si5HiMP u2eiB34Ci7OO63XAwLODeWLb+SB9IWpq78EQZ5TR3OVoeqOJj81yonh2FAGFZsirDqBymZ7R AV+vkhkK3T3UYXKrMspbI2ROGilGZXSgov+T9FesfXdqeFenzZwUDOoJdbk/jYSOerTud1Ep r1Gljw2GB8VofembL7TlJPX9hnlQVKbn4e0eVkkLP1qhozSh9OiUUIsDjq4Gahq1MLrXSb5p +nJpXslavASuxOQ5oy58AfCMbb/KYkLL118rfbIhAtkdVNSyL7++C03hlu640uWwUI6NBg2D Oqw8P2n6I3h6qn65370+Sr7nZqZEgxaLWNTsTD1O+FSJaNzBV58veB5zOWGS+SmwpS532L/8 t0D8XIEeri6bpT9vZbyrgPHEsieaDDHSvjkE3W/D2/OQIE3J8uGye4G0VEIe97QfRYIlN4TO aag9TC1q0oGwQt3tH5iwb1H+Swq4QPLp+ws5LmhiayME9fGh/RiIKhsTPnvZHxy8OUX8ICOZ 8r9SrQaPm2pxs86TzFu+iJuinXazxqv+7lo8dCbsyCWSCAkGhJl92TgTOpIbaeqAYJjIAJG6 OrEUI083N/y+h4rEbYg6Dpab7DjAJjl0WCcr8bEIyqWtfmTUt+M1sqoYFdq+MNBB5ys53Kwc 9n4KdhRZ3Al/ULqeX9bCprfTHj+O6mY7rp6IiCFP0iVyXr/yhvwU341Rul0X+ofbo2K1yW2m mvZc+3fCLtOmkR3KpBglh7QvZtSq3hIB2Z3Anv0oSsRdLZjMpBWpncClv0EgdhNucNhvMno9 6MQReBP9ZbVlTroJetAM33w/X7TIy40IwhGxRtuc2Hrwfdgo3LeETnZhaWhAI2+8m1nkMpBH +AxfBdffokqid7kjwLNGKGwtx1jt80MhwE0n0cRbapyx7Jpda48Q6q6IoQ03mBdRrQOZ/mQL GzX2pAy44lFnCCwn42hnNDuEC/9mu7MuJUN5pBlJVugcKeWHFBfLCIlxZJ81CYfoEEdNUjS/ kmCVsdvIndTtC4vQpr7gDkKXAtZ3oTGaQkM1fAn2/OhJ7DPDm7S0A0FHg73YGx8d0NBptN3h 17yLLtPUbSYwd+QqEQb10tv9+ekiozGZ9a6eCrYnm09PpKuFmQ4+A7S8U3kAaJUt/ZgXiQI0 tG1fLAagSYn3iELgm3NHr6si6CkAmvJ1oVPGKcmCGFEDokaqI1HsFWD0BsXKACezSSRq2hc2 A51B65oMJWS1tmCozMkX5Xsabv6yAeh8Kcy0D9fUfNt7/ovKud4wCJtiS06PELK9Jav5lyCW Dv2JtwSRr6rVS7wHD5jKecXGlEF6YDRoeWamBMfBdp9gSIglJ47Nkb7OjhELjL3FXYqRHUod lgJi7m/jUYREnsunZdJrOcqGfmDQnyyvEX8Gk6AF/pqdal0w+paZ0Fz+qsIzw5VXpRuMc6Ee 7ogDKEMCSCMyB/KrbZ2JJ9puRbtXepb1juIV/AxqlLNlXOEuCq2JOXoPptXNixahRmWEngLk B9FBzjCQXjv4x4IpK9j1XEVwfy7WNVn2JLyGUKObHRONZYfKCz6kVN3OS4+Tj6H2Bz8kCH/A P0/K89TmIKeNsEydg6gf4/IZYkbCDda+6I7Sp4/03f41MjxkBSHJT6///jdkDElP/2RGm7SG Ed8y0VZjkz3aQJEVRbQPjrgZhRpH5JuiWObJBxwc0JTtdXH9xzUCgFZe/6uJ8tQTwwNM6K3q uhz0nKqI7IDax1HqaX8bQzVSD+8Gb1rhFKSvtkvUeZeJS2OhpzxtnAu13sSGde/8ZgH6Jpxz cC+GC7V2UbNAMKACou+c1AhN9A5tX6oj6+FG2OUp2dk59C0uOiu0L/7E9ii7v2xlXERK6rIK tP6YYEIEX8kE8ZFVwdraa/q4uG4KQES6Tc8jvxGvf2Q14XhGYu58EC1f/ANJDjAJLE1jPIox E3A/3lALw3HhzyGP1f1MaOdQvR9iGxnTX8GaRGRdLvFhs7nlOn5iY6kF3Hxz7PYhgiOFIyAS 7cxKaL+Tiw4DLpwNX7H5XhrK11ZMdTlM3xmWX0FhNZm8AkGvSl50bppSqMOQabwyS1woGdrc QE0KtvH9EEXK7nhINJoHOXayonczx4PMaR52M8uwHR56fb9aBVHyuDJvOgYBi8daTtQgj3wJ 78MPouOML3ApZ6XV8MgNaB9AWM3vNjvkkoGiZeTq8BDAklNiE8ExFzxTgMquwGuIC+Kq4kLB OTRTE8GoFx5xqaR/7JRGQlnmiPJACQqvUDGW5cLo+dSdSaoCEqN1+yFvsj+aavFFXqbThFa+ StjE0KLwX/PS2iiyTS2utvFk/nKa0yVOmTC3iNoP8ZYsTCt/sLl+wTOa7bKbeV+X6kwRiDTC SVITtS8yFBbVhpLWq1sHYgYfOCd6ZdnlCgbuU5jXtiugJzG6Ciepy1YhGLHhuNc8O8x6iOyR KXSz7+uFpRmSOLAcGDjikINWeaL9lIsbNz4iGBzO65C/yn0Hry3+6Tj9EwjsKuA/jw2zHiuN eiL/bbMBRSlfZ3Gjc3ZsV27m/Z0WQP/apisYr+UJm0yDauJUMGAxDR9FY0MjnbCyK1B+DtxT y2y+Lab0Bk5HiCUV4MGdF1EjAkCl3rcyiqh8lKw92ou1nvYUi1o0ZlrV1vmUyWPHxi5Fhcmg BcEPG4wYCV31/FByF8Epn+ydOisXL2PYiocT3jxmZjUleQRN8kShLx0Qe13uNCSbF+rrgd2l 1oo2O35xnLi5/IfaXCL3vUFyWMGXoj08FBQSYMGj5m5l1yg5HksfE2mlZCJ6xv/KS+u7u3M4 CU8x9KoVk+TJG4xLXxvvxubSnMN5KLmAmLqi1jkSvfxL8B+VcM/2Zku3DVGx9O5VA1vDlrhc bTJhI5mprEv94oXczi3/0vGR9tDmW+rFQGu7JVbNII9adV8MtxjXLH4kJVG5NctxSW9a/z5U 6ih3Lz5yINirBo/yC6Kg1aTiqUwggDgXRA/zuVJNDqZQzGPlQdRpSBBWKGdrXD2sjfhcxf3W CGsjGuOtXPN66RPEx7v3OcBUhwqPrX6wbNR8Dg8lCHT0XxLLpY81bcFGlA25HOg3uHBMnRcL FbFfig3eJaEUxxk2xnuyjsEmw9qxuH0tnOtYVeM0yHv6exQuC/IOEOqPcdxj8LuBXQTkloGk wu2ipyk+lUa2xucNM0BYFIYeDISHBGpdNN7lGZ8B8HquCyUzDxK8ntw50IzgPmbQ8+NY41op 5jDDIxl2udP/UIWrBHSHmvLouPcpwlTlBuiD+DgqRRdLwkq0KG62eQLe0S83XCRe/5DqDPU1 ujUB5xXhuHA4LmmJxHKSm7nEF4Ja1+EfRSMf5EZkC8M+/ZQovN/384hXAl1YJW4/QDBROiHv EYhRFZc6SOE2l957thAlrxEJ3+bIJHkMwfwTuVBg0N0pi0qAdvC8zzVZFj1jYAsnd5qKLIaA ZJUSEjFTatJR+Vn34G5Q4WzNn4DFwjiqTz7ireQOaSviI+J1e5rnnsFCvRopi5X5wVMuz6o3 yoXYRQ9ko0nVJ3cRcOkQ09q2feZXGBX4LjJ/RhISQq0Eg97umWP2pNnxXozWPGEvDFQ3+utJ RaUUg3bC0GWIlq1CDaPX7XMf+hvodTIInsD7sAvLP4mY7Dq4tpThJkoN4tttKSuYYOVHhURc 04ERftTq6BPPdMvfrlQSonvp0t2HL6yhuVZ55tMjT6cBXuz9EzZrwCmQZi1xLZQuKRlSgBcS 1wHK27UAr+NupSSEL/AI9ltgG4UAxJ1pBbxv4A1NPgVtK4BhSrL+yhLqIU2xRPWtVE9snzh8 Zxo8hqWSycXViUUA0AqTBZ9IuojJtp6LZY4IMhfoRfACWzOU21SKbS29k+h7jPDJKZAtFEDO E8/aDehswoTNH3IsMJamOEgLqHs8hHvlBJJ7Yl5R/ZbtLwoXhf8twVy7C3q/FI5mZZ3+Ldx2 CKVWW4A1xfOtlrAKfLA+a4lW/rq7IY+3YFJVJeuneDGzOLNz00RjSVxX2Pmb7a0oGyMx/Xgc uTtRaM1v9oGOQMuOtXnQSQsHfuWnPZYAAQwbDiB9D4nRwPPSkAUERR99jsoY2nIw689rWuV2 XWDOs9ZC0TCfj/DLUCjrTEFBKs1QdAeROT0Iou8Y0RbQlVP/Zqc7wWMm5sHQubjOhM4zrOPS o5bwnrTTOVwQlSm/9wJnds1ZhlOOZ7/4C9edGfcuN3k5B2MvC8Pr52uHqA7+VfccKuaAvbeC +kIabn75+IobTy8fuasxC4k7nsZdlR9mxN9ui4SSVM4XRHcxvARFLWVc/5k1GU93XORU3czc /ALm2jMns8oNFH5fHa4kgY4HQDmz5Cl2KYJYFa5TD412FTq/XTbqTI6Qchn7kZ+fhbUBJRJt qGPcdcL46LVrTzjfCxueczij76iA5Q7/9Xpw1Lj8eKfbU0/ZjlPWp+LOFTYSyj2s1Kt74eXB MvM7+2PTecW2UuInoUJCoh1nWf/YA8XCqsSB/Cb7M21O0EV9yPtOK1u8iTwp+SOu8ivKRo2z kQONDaf5BlK+2iYFqgSwXkvMZWpPuczPXOyFd2vlYzU+Zjd+nyj6JEDybe6S4/eyhEtqdxku 6B9JQKBORGkMKwTu73Wew9MeZhq0WhyV6rKPPlnydBg4B8tSJK8oEZ++EqZuIyhE5IQ2ofvH pM4E4USR/9HZH5y/e0eBmFskO81SPLiTbrmqmYlub00mmiDiJP/s9I6R/hU5MEDuh5bf703M i7EmY6/BIDZr8ODoxqMWrGO1YATLrWj0epcw0hzyBD0S6yvcx1diyMIStGcrSrYo4/Hi8O62 0bivMh8Zr8q7sq4Gp9nzxfl9OoDXHHgtxaA+RSmEdIHQcmZO0iRdEDyAOgcrBJpCzgudlaHf ype8+S2fErCFnVx+JAMJV7TV24r31EK1tpBcvwUoAU4FbMgeLW9Jr/td3GYCJEoepOJSf4cN vzBmxBqcQGtGODTAaPFr9d8EcHoVC8HFndkNonP9//wQMtPJfTcgVo3tL7UGpgMmirikBdad AQewAfNM74dTjjzFUs3PffoXTrFFtfiiGqseNwf8QE9dxCvw41teKsDp+Vd6JqMmha9Asnr7 4Kx3xtRyZ//Eaj8ghIEV3k77eVLzTnqxjdwTP+/8YkpQsQPXTHqOOg98CiGY6u7x3GT9th3X DeWiohsH9ylQ8PCb034kKQZwNFhI7AVNTuuh2ezgDFqMJHSTEGk2jq50/LWrlLpaBnLoDZa6 kkXK9uJjdqTqwqUlUBS8lF0mkTrzvmvX5CzZBkAPTkuFE+9nX4P99IWQ66ZdEk6V0AqTyAFk W3029/g4KJOTCNyO9+R19duG/amx9rpXUwchTBHwClgG0tOW2e10yyyFcjxhcZbfBTAEFaz3 GmmE9Jgl6IV3Ul8auImmiYoub7VPtAULHpRPpdM1+6pln9pOY+0vsnC7rmU3ec6xmW1UPGtW nXpt8HhLgpm47iMQXODshf2v9q49JwxWXqnlPdQ5swPumaTPE6O3DIANDPFuxMAoXlDaOsE1 SNZ8i3qualuoVXlqKXhVTWnl2NmW9fJyVgNVzJvMIsVOfzmF92CRw0vhQtgSpffmivvQ2cbJ 4xI5Iio1/ikIRixOlNmNtfN8BQQDHHROulCaaAr5PNf2jBFcbN3fu2FCZrSvErQYklTz8mPw nuUTcXWRrlw66Fvk0jqX2SRoEWgfML2SquaKfk3Dt4eg+1cug0qTp9oY04Of/qSANkVtS8X3 lXVRsfYhqn3l18kG0C2i+WPpObUtwy+w5rsxCj+Yz3spKhignHDd2BtucOx96fETHNKhUCbb ZEYLQ3ktSnGjK5aM2f/EdeY6UXKedHEQ5h2jyOX5HE36KnlO4BXHV13tsosJ1ylOUWsssmYl W9+MFLMmsZGf7oqBx7MONvLUtVfRO3HHmds/z73FfWZeb4EWPPHzDBm44Jlek6jg0YWX5Yu1 JkK4XOKW9epPHdzFY7epyWOLfgopUnsqF0QK8ttNnD22/qVtVC9hERzAF3scU890Yxebt3xb bCL1YSY5pWIQQ1am9vgP7eyeJ9MoAWMGBOyME4xwkUlTOPuXHQNYuyB5F/gp3WBSMGk0H+tk mZUvZ5zyirWRcb+cmhA+SxQeNDOLxDzv0Wgk8U7Q7btJ6hrPHj0+HPPnivDaCpXoPW7WwC21 XVQgHrBA7JgF+T7mABsQzC19G4SDhoFD9w5YgPYJCmjqVoPWCSgm9EuYxhJeOjXrAMA72esC ML8cOxt54FHWw1xUFvRULY3vwnugV2ge+cbL5VEnNj5eV0Uii6Au9yUhac6JkqQm0EeKNY7V XtJ6iLQfLlwxCamj/qdp7SW8f/5sJKhhE6m20sCJrqB9S9tL9qntF8qnd8byR4QS7+mdsvol DG2NwENLJFWXwjZYaCD6aBDJijVzDpiNMs4ev3LjY1Ij9NXcdbm+XpVYVZiYRtZzTVTF6Hx6 eqrTzK/o8k0Z3s9jH69yMzvWc+8lPiMNKjifCszdbdOIvl6dRW76ym5s2mpjc2Rip1KJC26P If8pjK1dKkrw6XyoJOn7/iMGcdYwRESn1vT6MGQIoRJsoL3s4qIN1Lk5J3YmkoWCdm0zdUr0 InCmB6wbqlq27fADoWVlwp/pSwb0bMKQreZ9DCyHLeYYj/6/d4VYrx0U7PK42Joku+WJ5FqN mKhKOcLX8UdqEVqVC796WNba5Y8Pi1NAwLmq8cp4b95i69H2YDdwJl5VwdOxFt+CIqVRR9oI X77v1usCJG448SSV/Y7xOrRi0DlI1+czGzi1fey6ff4aR21fxEFKUqtf1CdaJWQlpqZiFCFh WkdMu3vBIKVmJV8+N7rtDl77q5yXSb1VdCUcMjQzYllKl2J8fF3Mjjn20Qsm0Iht+YNKcpT6 luKz+apb7eTJcG6d1015+XjDzAv4HejbAqGecsY0SI5Y4bSOPnyd0YcZ9QVv0t2OZaxTZZx9 DBfdaOssMKJ+y7oEkwmnabBmJw5/s8tnGtfSNJLt+Ec8+xUn/2uTX52WsThpKX31o0Cjzuxy nVEp0eTrcvDBuPMy/4pPD3Ic9/Z+PChS3hInfN+ipjhVC3adf/datVHDPfS3dVZ75PpcOAuP +nE0zmEWHY9QB2MlMlkoPtFyfVZHfzILWz7fY7sIoQbzSFgyYTCXNiFvXL26W4xcvi88vU05 UIoo+Y9WoQgapzacp6hriZ8rTgw0Oy1MMgYzIFTuzjtcqfJI0a2OEmxsf3oCPCLYUpptZkXA NpNFeHS+qfnmTNbcNtB92etxfEltx1VD91PUkpn585Cgiej2rE8P0Kt9OMUeMHBoWniDQnRR Q6eKAQCAbXlWTwg7zXHkvzhOnshHJaUAt6nHyPd/BPiYC1Gg1S5Hvjuax2SAfCJHM1k8Rfsf deXXaFbSER9ATsVN++bTVm9fN2/nes2/1j8rdadRBv8Ial7r4fS59bGYSOXQ2i5GVAfhDotT AhQA9jgstyJ823orADUA6ckDO35kHRenPYwm2FL4NgOriC0S1PPAZws02A7eAqFVK2yjXIEC TerG2iJic7SskbiO+z5k356bPwocf732IeiSNk9SoXlcmgLNaSe28q/TpyESvU/BDHvCmbAQ lc+el1Qt7BGb02ylmHIqGDVwBMh3W1p6izx3ay59P8aQBwkRYdgCHo1hv6g+USRBpGRiE6KN L6iRElIfFNpslFrqWF9Y5Lf1+pNFEdCo2s9vXhf42aPLiNkuraZlxP/tnku+Vl+sID5hyBcg TaMk6ky05zaBECD0mDnw7JD93D+aZE0oRXx1I2vzjC1zMjbb25tS54Do6ZtjPbu7+ODsSpI6 Mx4DKgg2jPkue+PIv/OYjaJX5xcsCirqR6vzUXkaCb1aUx5EebESP4UuvEzU9Nx0rQ9D5GSm qvRATlXkc5pYPk2shRdgv/zT1SGgzDHqEMLFNZz8kQPHwhkLWY0sbMH7ugEm3X2aBm3NY1SD BUNKflVmnu2XI4IkXrmSG8d+Il0UM2n195deCHNftUplvLsnDxC9gFlwbpfJT9YGRhJxztSW wVcGceEwm0iW8RntZxcduXBEZUw0yugj7x82uumvdnbiewTGk9auc7vlSF8chItEfX8bO2Wz Ok7XuxDW3rAUMNdnxMHNUXVqo2m6HZyMXBFACelxZcvd2z8c2px4LZRdEGp9NIlIDKb6hNrb 3RoRzHr8qJVK7AwHlDLzzIwdFPMtjUP979IpCQicv4o/Wj6tTEGfu3n0PSAgVZGSdZU/ZWRa IaqEEvj2uRMdqHR5bLU8KlW1eMbyjEIqsrKONsQsJ+4h+WvgVHBJ7tc3aE5/mGdyyd7EX7kZ X/V13omWFH0VWLYprUt0TYOg0zqCcP2LZQZIKxyhsBCBIk77Mvpt7MC4i3Ah2aq/M9p36Gvn LkVHvm2jFmRBI2UOHM7rRGWA5GwX/xH3RM3ACszx7Zu8pXUDybWqEx/HvU6nK2SgVcuVTVkP WX579E5/TG0z5PRdptH9N4uYtDGryjt8G3CDXt7/YlH/ZmGYLEIHxDZt/HEnKX86nT92AJLk ImqeYS/pffkORHH/qScMW/lCMePd4eX0Z8te9vYw785THXmMxzOlbBkkNniFcmWW2fd/dydg BUaDW4W4ZGFcPRdHVFY3csC9XzKD73uppwvjrRUmP0AkJUl+4iqBIrH9njciiXvUIBYFCdUf Z2vNEkTsm+49/Qpo8vRQk9kSBDhJd86nUUrxwf5cKnL7woGnOYHY1s6BR4fIhXWltUuuef4C Lz0or0u9Zm/HK+wK0ihR+8kNvbspnhYRTf1Lz8+sjIg/hYptBjJ82VWp53sdQzj859kjxVFH vs4NLaYdKnXPW6sVnOziSIP3GUixBpn68hRwPAReR+CX2ovUNYlZN9iBr2VAq12ME0cLiafU gnq249PioxZzc7Td3L4JG5rJdoboJcI2Y5ZdK4izTgAIapDVG/zizrBop6JZ931AVx5QXsrD ZKBIuRfzwDOOLE1CzD8AmfJ78v97rsLGVwNRJs8Ag1URpThhHFPktHoB7Yj5XJXx0Ta0jsql rkQhmnnd6up7dfwE/KTdKSG8yxULKMsDFA5a+Ua5dbK24wOkwn4o5838D5tCsw6c+C+iWm1t i/1uVPNi/u+kMRTWhNyiZOfXZzB4ffeO1Bwsl0T4bAZufB8FSYA+ufVWSbsImiYFR1h+zpe2 f0fqjdXVCk5JE3E3M6Q47oM2v07FK5CnIshiB95MON6S1bmzouU2ZCzcuJCXNLwym5lD2b81 6JaAMYSU1RFZZKPnpaNytlIFoYtkJc86hjmnA51idfqWxsnUMp3MM8IHx/gb0Zw9/bMNBXTm 32a6GJPnMygCHqhEo59as5ovY+NcAE1fjDIq1GSlYoHimofcac0reUSFo2YblNjCb39ldqZR BM0YQNF32DWtQKYguuBrWbL4lafidllnopURsmvdUSw1x2Y/kHoUh0JrltbuFRIrdotteLPX 4nxg8Ep/JJEkfaV6AlQPWiQ0WJTkyvJpXesRJiNm8K1hALWlbXjKm2B6W/AfWCAwxtkEky8c UiW63fTJWYrexA3AqAAERRYE5buf5Z/iAsr/Sl/DzWYgJMX3L9leq4QZaR/sG1Jpd59fDciX 2VoPxjdz0gU/mekWGYmc4cvhlveFKCHpbj8qwGb2I0hI2rn+3wOsM4vvmiMEX8DITcSCh36T RKArI7SydKE/aIrmwrl4BWfkCI5RUCrmTlh0jgMyJx2Niiuv0bQOx8ZojKrGfTcIgkqL24kb L+4S+LMKd1nMvTr0k+FenldzalH3IjcM10vEAmOTudzOwqsNhcu3+r7QfnZqzJHtdpVWNtB9 5MNwPywSKQa0FZWTJ5vfGfDzUlyPxnaTfKEHbSKL79gpv3QYlnZK2GS9vul9x/3naNwwyqxW 86GH3TTLwphezTzUFq/xAlRgwdXxpQd7TiV/8iOv7fwQynenTcZ74F45+Cm61N4BUHolCYSE nmPdphS2YT80RbhU2XijnOwNuAYuSmRIc2/NHvXzzrSP9Mq8yYnhxXnCd9w5Qb62EMsocJgZ wo7Qf0mIC2yP0oc0lvwl8UTPz0krORHvFUKreRdzFcQq+jTysWVt1iEMdejuhJEXMM7fRQcr y/alQOOgWBp6Pb6syf224FuQJiZHG3+bcSfivUNild5I80rl+9spWnbu6InOawxlWiz4ymn1 1DZJWZRQkvRjxPIwPXHrHVNwVj8XanrGCMEPBXf8eJtHTlXV2q42wiXgAhsDzMna8Gy4cvSd CHegtGQl7n+ZWN0exg0b301dpriGxQBgOOOmncezWhVyAUMGAj9kqCkiG6to1Ca6MzxPjJ40 BcNwyL3tB8D1Kx/NdE9tUtM+rbyT45G8HTkm9XLg8Taq9YkN0flDmqa56rQj8KFIO1rvSDdl UWsOHBMbg1NfStwrovzISrsf+w0IBBXi0aXB3a7Nvantk6ivVUSLgtL4kX9VT9jGU8uuH9gz bpASSEP1IqOHtGITCzZmVnwC9YuFM/lavFgWk5OKuxDOCpoWhCCLaPp75orHe1D0JwlWmezy nEK5zS4lz2WilCd3S8OSQ8hGhb43lyWmJRXsvpdPPADIIkq4I6gChGFSpVEUV8FmRJFs9n2t AUdavLhd499swsEq0XXaNTTqnrQbVQcRorN+QDATKrcb/SGF854Wk8P5SauYigXKMLaKCmzf bz8jJ47N+yXhvfAye4Ks1cBbuG/TE9UL6o0zgrFJc+EVq4zwkUDPJ/XSunTitXG/vURdITRH 6cmOV8wMBvsHzURoZ58yZdg15Jj2X1TQL2ghhXAUZFrNsrKxzkDG+e8U91il8M2+QLotcKz0 XtJxw4qh6byrPuUKRjnkCI388xBEOO2NMc8Fgq2yNGM9YNSxWX3cFcfIuWQsfTqDsYayL8Nt C4jRfujir8OgTQCwVZD0mAac4DuXGDW3iNKSMxE+aVendO8c1yJaa3W8LVXIdRhGylJgGfo/ 7DlbgGlGhAWiFwQIPoGA9uiNVT8jyctTr0t9N9yhRkxbh2rTTaBaBFcZa0Vh6FfVhKi4a7nz uGe0DSZgjR7ijxuL5143+Yckdjra6EAB+Zy9bd6SvA+Waft2/ZQqFWUSqKo+jm51RFM9AF+P lEuItHBRsVuOg/A+gMyiUwF5T6KtKRECEAch/bn8sHY+wtBZzEwLC6vmgKuAf2PH3EY532Lc M51Z+gc5DVm+8rbi96yD2zHH/YIiAplSSRdOgnYUoDuWVOKGvT6HR+NSITRbLgLfYAX9pYpY HUq83M+RfA70yK8WN0LEvuN3fq2/nd+UJKwJo/jNK9z80q7sCjmb6jqNi50F0qYfTM9ccWxZ +nCk/8A3fkLpA3S9floMuFPuUUd+sd/YK6ycHaRHJfuoJnnPvaGJCgUg1j/5f+MHINKMaBHd 2BqEmGgWaXyB8e3X41DK0sUa0eDC3BTWMvZrUVi779MZb1UsWPKeUPFJvl0W0kWsf1k0M1eM Vl5faSXeHNzdvr3GtTEge3aQof9IcHv/vWGpLTRrxfayC6239W+odUoQSrdsCPJFtoLybjVH 1ac+XNGCKisXb+N/nTpeL1HT3YnxIAgiXD4Q05F5QGHd0RXnCxShKEVuSqBdD0dqjS4f8dza ZFlix7GLxpEXJroHUaCjmjwpeE2IkDzVT+L1UJiuZCT6zMx4f15QBSdv50fj4MXCUIhzPEce wbv63Fbzjb29DbTzjNRiFDOKbGlWiKV1KZHUX5RGeQb5rwNtVx5nvEDRHnIgZea19pPOSklv TI0MjOWEFMfiqzQfWYuGdPpkzcmqpPKWcsNLTe1UBGj3t6N9Ue7v//7euvPsOkvQNWLTNHpb ZEzUAZZHoD4W12jHGVm2mi8PwwmMQsu0RwoGQCDDoHmGjxF7ywodjX+3Np2ePmHQwqFwtVwf nO4ZRBk7Fih4DXwbJRAM7OXhRxTSTUtV0jYnip97GSxJsavkN51egbOnOaKzFidLNgN/1QS9 q/9o0EyIgSRW1ehujiAg/di3MaAB4bemvvAKOJ1h9rJCOln1e7OwBAzJ1+oDV63MoX1PSDoS 4oDpYQ1dRguLqHEqAFNWkCsnrboomhFlI2UUeLNqZyBlP+FU3cMyEzWAt4fOSZ9zy4qXVv44 PbGy5aMzYtn0fcX5T5Tb9lkHQqwgbTZxyKnf5ue1940WABRxQ2KWKzANx5eVb20FUfqO59TH xXwv7n2Z5DadnXUbAF/jWP/W6YSbNVy7s4xy81ViTgvY9rHIjIr0jMXEMSzkt2g6bvlLxRyh YP1sX1mP41JN8sxvqGZuPzABqkIo8yApPTGWohElI6bpdHsJXY5c/LUfee09H0lQBd2Hl0tE V8XUFWeY3IEQo09yNY1FT8jSWFrz/ZbRsalWTcIeS9cAmzzTzO9WWRSvvqepjQXtnhpP5qtZ vhb3O5Uf1SSfogusN0MLZno9iqeAXvdKtBssq3v91CGVzcteMY6k8bYXAx9ihrnsn+mBKUZ3 Q2Jh11yaKL76jLdB5tTqiIDeXGE/5zeYc3/Y9hey8GZIrQjDr5X4hsf9ovQmFIUPQzb8Nvo1 2ZCSf50SwYzNNN52zch702JdXB0EQYBXmILm/b30xy8h4mhRBNKsScPJE+YxMj/Q2ygc6H5J ByR7ADKk+V5tpkJgLnRBkOTI8dWGnv8ejbWX+5R4quCrEDn0m27CIQ0VoAFPDp07qL56XTDO U/wcIZ4GoFeeJAlOCXzz9DcsVRSD8XQ9mdtHMTk+l89URAQJtjn/rYvGoAdBUBjkkguiX9nK QyJjA3hfMNmsPnw2+zwFJQiK6cG0V1sljeCWAV57lNNmfkPGhy8NxXjf0d4FQVGlcql5BKdA g1E4IbbWOljHZOfTNnsVGkoCK0+sIOAeq6cRYAV9XUa9phHpH9Mx96LRXBFLCrOTUdBXa1CN GTXaZrOKLj/SY6yq4w6qbQxRfPx9gM21WnTJe+LXQ3GPkXWBqd1srKyNlea8JlQTzCi0h5ua /tc5sPDLbKmFPcO2PK1nTou8MpFAGeUr1WJoINXbnbvSaMytI5MFOIeXvil7hSkQtMur/xJr iYrbIJSr5lIHoIMWUPoJqTx4xUVbtFzUKB6FVXxOnamgaVovK6Z6BZZKiKbigEO2TfPV8Ab2 LXM47FhwRDIe47hO1Fanp2GwChj7Bb6mxaS/cDdPPUcJDNuPEDm8WfTUAWDwpOjjX1AxKQdA zDsFR3+VZXCftn6670Xtdzj7IbrGoft7e8aRAkwAtFmThpg1Sp0IswY8RbTxGGNbiab1JAqw /6NdoZJJN7VNyYAYkC5fzBV84sS5HgHU2+8GqPvSZ4R8Fm6RBCvmwCcEDVpnZ2gAXeWYzD5o lMznT6f9xykIxX0gM7KuR01LzbsjEPm/pCG0yNEXrsJPNYCMuKg84Z+XM2Khuk0vW4JxUdc0 aZHWly03Y1Ae/X/pBLVa1PSy+ozAkrRV2k7MvG68m/OtsxfDxbVGhhG7/EVuJWcOjeL2YLy2 kTYIei+EKhAHF/vXCpOMtouLlYvaRvXy4rHV3sy3nwmya/MdEsXBSuRD9F2BugsbfJNc3AYw QrP+BVMZy+KyoFN3N7tf0ZXckYS3BtVXvDrkEHdVsVUM23nE8Vi0CYkWfTZ0WY2kxJmm5uVh mGsT8iKkzF9Q5ntqyEJDpbFGyiZYYfHxQZVjtSdVgIZ7x2z2zMpW7m4rdPZMSybD+g11FVpR gjm/g/wBha+w4XpkM2UFZ2OVQYa8kzbaHF8Py+on13TKk/TEVIxTcOBdb+X1yyy5np6y/2Yy FuSaZin4JoJXN0ggWidsqJjYZz/LSA042lSv2xGz6Dk9BJzoswh6PgWjOIG1Q0xCg/d3GNKG fJRvBCkS4ij/MR9BB7wHOvl4YUhn0u/363inJoRf+PvSK8sB71/JRYaPq+m93JQUZQGMT8z5 TMxpnGiwh1Nt8fRs5dO8uQ7KfNt2lKQdi99AlPLjUeeOgnjdKK7n/xqplVzEGaAmZ7kxJU0d E/J6wxww+TjuaI4HzGp3zG8cobIJGLAgHIfExLAPaXoZnH8cS5yQ1y12xRA9MCJpwHTpySB5 B3kcXoNxVNlBwiSLdIPUiEBxrPv8l38uRRZLglWqQuAtgs1iEK9zAM5RBMA17D5rHQcz3Y5H c0oLf5mGpNjhlASEhro+1fMQztxYUBdBeHkCxT7sAIJ9PzdXfLdhH9mxN7sNCvRkk9Zue62R ADsg8v3KIYLrYcHhuySPNA41j0CQ1ixyKVHtyE5HYrpLfUjKrYviwlygaoz66GJA2u/2cxqy kpWFvKo3vCffJC924g/CNeqrz0nt2z9pAfK3IEladS0+qpBF1UN8rkNduCaNmbOGKJkevnFp ZY2A5UL4VaAs91Hr+hikfF+p3V+PnfH+8qLpuKW7XqN1seI5xAMNkxoFZY1hvQBSmqK/VaLz BYnKizu6C5kntkA++nw0nGTIQ5vznbuOoxFa0yzH9/woJRIfXekHhCKqS/IOpQKdFvdW7i7M eySLhNea5Sv0PUlHdc9S/2aYjlxqX+S1MeCSl/4JR+ldTaEFCRdjBiRkPDBAIFmY7woW/4VT rojxvbYyqMHr7nxb8E48fp8/OIr1L8BHGRhRG0umVXbnIPb1kBLrgY1VN3MRofw8lza/wGY+ HiCct777lU/LlBRFQ/8yxIzOjRrMNUy81X4n+p3J+EpqNSrPVRLIdiJ/UgN6cf3siG/vjyQO /9/n1CS2AL/E3s7Cs4TdQIzDN0/ZWx92znOywfjgd8/b0C5E0MD3eS274VbLfYvjlE4Z4V5+ NRk7MajIfZebcRp3TJ+Q+itGt+Bvmy33q1AL9A3MUiumHRHpq0L1a6pT3ig7EKCXk3GDwoZ3 ymUCXOD8l64apPsR+ZGz5wh2HkOJwgfESMqb7oY3JAStllla45Lkcf/NUmTHUpGQARb5y8UF bQwRNle7zJVsW261ixES93D7mmhwcNApAYzmz/e7oWjUHegsB66W52B5QTUeHZoJ7V3fIz8z esSZIC5iSRXeE2h3nSq0xw6+3dG7M2w3OOAwxgEuOIzUr082962H5Okq59WGXD0xoe0RACRj wsbvx41H64bRK3dIOJJeHld8I6Sbulmd9k0SI/t4uyWCOEiE4Im9l9UiLYM/gtGjAUN9RZiT 9M/IOgWqfiXeIpGAGEkuNdaXWoXZoHN7UdawQ3Gv+S8zBPxYsyV5zK/WVt3YyHiLgVlJkdqu R4XLqiQpXrF+lOFol/H9K+EBKaGVbCCEiYirYUkCt8a4mKAME+l/3gsXhOVWVRc50kCHuP9Z 6UFjyX8RqjdaP8y0396i5uAczvexTYEtvvU4rj0HIz2XsVV/F/xU2u3uUD3fvr23auOcmnnJ dFSvlnhbfzEebsHoF2ay4AbLer2DwfgmgqMbH1LaHhSlc3dpghSx5eOX+pUutRcdPmscVvfZ bHc9e89Mud++ANuJLyU2Ux3r4bR1KOQ35XQZNm8Hk3A0i9Z/iftX5R0LOwVBfW2UZDhLc7wj 7mTO30AUJanvQYlYl1cyPjxtgl+FQwdk26KPws9d8kc4pZYxvGRRR8TGylUFf41+p5eCNM4C QEC1HROCpVUYvdvtId+c3GBa98pSMF8rypvY6PpI+lHMtK74d9NyLYGK4R62xObOOPOegsKk XWFhKYuSk5Gukjw05ZPoULyxOXGXN4z4ZOQ8g28/LrjeZOGcSPP35Kfw8DSURNejBF3lmYTE /699VFFW+zWefOoh6XV+bF3DZj1lwfEMePRD8ZODj8UIKgS1H24LNStlHkoCImlUOyGnvfg0 VgB1Uq2tOdYPi0l051L12Qqnn/WTmk7YgoYSPRrMgcwAi6UYzNHf28mU+XroU+5CesyZwa37 zbAdrGlMoT8Zd9jwXcJcxkvgdwaZAsvDtVzCS1+gGcX60qJd1oVkNDxKaj5BG0edMkyguxgV QjWXxk/zSTBPQs4XrybkMh9q139paSl/dwdUFgPVw6FBVCLl69pUdxelhiJB2y1jpZTiRyPh t8sDzDoyNFV070hnlbRHjQ9AXy63w36udOz7/dQ3k8Cuuobb4QTq5HldW3lZIZb9pLr4cbWb J4A3ETC+Xdze85WuYdRAMYc7n3rCuJJAWcCVtk0/Wdk3Gr2cB1rYbnjXBpRHWdD1ElG/Au+G K3I4aUWyU4dXkLRM21NujxXLQuoLwV6KU3yZXEp6hyDK/+ub1Fi3wese9Aro4zOijy0zYFMk Bp57gclMJjVGOZFhk/vGKVQxPnJuj9bOfFe3Sme7DIcB89VOObAZCz5BjiGyVum/KUj+LBO6 9oONOv/2L0EmP+oA38PMwKqx7A96Q/h1KOr3AehYOClqJaNHLG8I3CKkFuW9Sc3XJacm5qRm ZS2yPntzZ0lT7UCb7E9ah4lUuEdicRi/eUolIM9YfWmQqm0tm7k+3jljwyzYmZ/Ou7V1t6vw 2zPl3w0xK+zgT1KzeuVmYtXyJ6WskqqQH8SY7bDXgwqSIawkVgpqzruB8a2lhSerkMTRFv9s Eb2He9/Eye1JJ71DH2aXkrEKaZSPP7k6bwyQde6/gONTamCJdcmNZE2Bao7v0OY2w1uqOz8/ cjGQ5H813k0cye4fIhneqkFJt7ZzC2UNmWNK4F4wkfVESN1JYrEZR/EixhXMuJ8u4i2tN5+5 FB5zSKmfY6YNN/E5SqBgPaWX3pp88AahUImGqeUnPp3M50X14abavh1qPgeUmsyJbgstAw1w CsRwEBRfdz0YtTjXJSTnFxcbfEPbzmkg8aX3UoVa5fMpZPglw9tpimOgpMkgSJclUatsYSFl so0zX371BlpDCYOlYlGpW5hMA15hInbdiB0UKHFEdsbRnsAbmUZdPtx9Lg+x2fKmdOJ4C1pR PJXfPtvNaIJiWBkcAAluhE6SkubVqfaeSVCWMrYMe8bDVjlqbz6JcFv7MHCq2B8L88GIyrPE z5Azgldr+doFHU/ArlI+vjj6pK5cVvGSfvnmplRqbVU8uXCNu1bJYXRVPmwPqeKaNUm0duH2 wGsRmiZaa/hX+0ZSTz9m4kBbZFlHyTc6/f0Yoi45u5PlAgXMk6YDc1XlJLoyG+2KcFKNbZOp R26gv+Hrgnp6gbnglpHluSEl69mu7LpVsHQ57q4OvA+p8Ohd3HjTUzHOe7Nm29OWwUUZ7qhY 4NzXtZeqdhm1Nl80OkDU8DyFlMuFpybdYpUmbZUdaapqFD731km/UcQMZHjyNbUeFtdFGn/U NSRkd+HAWdkJXdEu/rupTaZ7lS27PyJpk/ojssTANJnd2S1asExopKYI3oSqRCHFt76GAtmZ jIAkXimMeJ0O5tY8k2pZQy1yyC71VQ0YTh/vg/hsu8opZXGIEQznP9OU6rbMEfW/mBkx7d6a 54AOnAYj3AARLPNi59D/qxM/EPwTChwff4gm/4CWXYRKI/TWnUj5HG5aZOlBqBCX981MH3m0 N0ZGeK5xVywOGOsT02/rRyrzAKgnN+QWCdNMrEyPaNkcQ5r8EiYc4oI3dEbOQoP16/QgOWL/ DNe89m3YJ2cjrKvVVJzxPMiZOv3/BSSJBOJp21yRvC2hakQmH6zB4LG5MNvvXA1MqQoSiYlY 3qNMV09rkgQbD1NlJ7bucrJuXqaUbXLGJWFYChTdaGMH6yZL6XYv5sYXHFWVVr77zmI5dAAp VqlQ7PKYikHDZr9uA+zkl97g5mU6XnyIftx8yPYSDpprt1dJtI2j+iYT3nKs4PiFqZfZItuL Evr0H+zPtJXY7yBMEJNBLWrGHAINo2aNiZHHYxCZ8pSGSsG9U6jd5TkQqS5fvbQbxCSdVF3F MAABBAYAAQnBXrUABwsBAAEjAwEBBV0AAGAADOC4808ACAoBt3gMMAAABQERGwB4AGUAbgBi AHUAaQBsAGQALgBsAG8AZwAAABQKAQAuFNfDPMPNARUGAQAgAAAAAAA= --------------060501020502040905060206-- --------------ms080700070703050209090706 Content-Type: application/pkcs7-signature; name="smime.p7s" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="smime.p7s" Content-Description: Firma crittografica S/MIME MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIINhjCC BjQwggQcoAMCAQICASAwDQYJKoZIhvcNAQEFBQAwfTELMAkGA1UEBhMCSUwxFjAUBgNVBAoT DVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNp Z25pbmcxKTAnBgNVBAMTIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA3 MTAyNDIxMDI1NVoXDTE3MTAyNDIxMDI1NVowgYwxCzAJBgNVBAYTAklMMRYwFAYDVQQKEw1T dGFydENvbSBMdGQuMSswKQYDVQQLEyJTZWN1cmUgRGlnaXRhbCBDZXJ0aWZpY2F0ZSBTaWdu aW5nMTgwNgYDVQQDEy9TdGFydENvbSBDbGFzcyAyIFByaW1hcnkgSW50ZXJtZWRpYXRlIENs aWVudCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMsohUWcASz7GfKrpTOM KqANy9BV7V0igWdGxA8IU77L3aTxErQ+fcxtDYZ36Z6GH0YFn7fq5RADteP0AYzrCA+EQTfi 8q1+kA3m0nwtwXG94M5sIqsvs7lRP1aycBke/s5g9hJHryZ2acScnzczjBCAo7X1v5G3yw8M DP2m2RCye0KfgZ4nODerZJVzhAlOD9YejvAXZqHksw56HzElVIoYSZ3q4+RJuPXXfIoyby+Y 2m1E+YzX5iCZXBx05gk6MKAW1vaw4/v2OOLy6FZH3XHHtOkzUreG//CsFnB9+uaYSlR65cdG zTsmoIK8WH1ygoXhRBm98SD7Hf/r3FELNvUCAwEAAaOCAa0wggGpMA8GA1UdEwEB/wQFMAMB Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSuVYNv7DHKufcd+q9rMfPIHeOsuzAfBgNV HSMEGDAWgBROC+8apEBbpRdphzDKNGhD0EGu8jBmBggrBgEFBQcBAQRaMFgwJwYIKwYBBQUH MAGGG2h0dHA6Ly9vY3NwLnN0YXJ0c3NsLmNvbS9jYTAtBggrBgEFBQcwAoYhaHR0cDovL3d3 dy5zdGFydHNzbC5jb20vc2ZzY2EuY3J0MFsGA1UdHwRUMFIwJ6AloCOGIWh0dHA6Ly93d3cu c3RhcnRzc2wuY29tL3Nmc2NhLmNybDAnoCWgI4YhaHR0cDovL2NybC5zdGFydHNzbC5jb20v c2ZzY2EuY3JsMIGABgNVHSAEeTB3MHUGCysGAQQBgbU3AQIBMGYwLgYIKwYBBQUHAgEWImh0 dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93 d3cuc3RhcnRzc2wuY29tL2ludGVybWVkaWF0ZS5wZGYwDQYJKoZIhvcNAQEFBQADggIBADqp Jw3I07QWke9plNBpxUxcffc7nUrIQpJHDci91DFG7fVhHRkMZ1J+BKg5UNUxIFJ2Z9B90Mic c/NXcs7kPBRdn6XGO/vPc87Y6R+cWS9Nc9+fp3Enmsm94OxOwI9wn8qnr/6o3mD4noP9Jphw UPTXwHovjavRnhUQHLfo/i2NG0XXgTHXS2Xm0kVUozXqpYpAdumMiB/vezj1QHQJDmUdPYMc p+reg9901zkyT3fDW/ivJVv6pWtkh6Pw2ytZT7mvg7YhX3V50Nv860cV11mocUVcqBLv0gcT +HBDYtbuvexNftwNQKD5193A7zN4vG7CTYkXxytSjKuXrpEatEiFPxWgb84nVj25SU5q/r1X hwby6mLhkbaXslkVtwEWT3Van49rKjlK4XrUKYYWtnfzq6aSak5u0Vpxd1rY79tWhD3EdCvO hNz/QplNa+VkIsrcp7+8ZhP1l1b2U6MaxIVteuVMD3X0vziIwr7jxYae9FZjbxlpUemqXjcC 0QaFfN7qI0JsQMALL7iGRBg7K0CoOBzECdD3fuZil5kU/LP9cr1BK31U0Uy651bFnAMMMkqh AChIbn0ei72VnbpSsrrSdF0BAGYQ8vyHae5aCg+H75dVCV33K6FuxZrf09yTz+Vx/PkdRUYk XmZz/OTfyJXsUOUXrym6KvI2rYpccSk5MIIHSjCCBjKgAwIBAgICHmMwDQYJKoZIhvcNAQEF BQAwgYwxCzAJBgNVBAYTAklMMRYwFAYDVQQKEw1TdGFydENvbSBMdGQuMSswKQYDVQQLEyJT ZWN1cmUgRGlnaXRhbCBDZXJ0aWZpY2F0ZSBTaWduaW5nMTgwNgYDVQQDEy9TdGFydENvbSBD bGFzcyAyIFByaW1hcnkgSW50ZXJtZWRpYXRlIENsaWVudCBDQTAeFw0xMjAzMTgyMjE0MzBa Fw0xNDAzMjAwODU3MDlaMIGMMRkwFwYDVQQNExBlQjZPRTM3UlJOUHlsNW0yMQswCQYDVQQG EwJJVDEQMA4GA1UECBMHQmVyZ2FtbzEQMA4GA1UEBxMHUm92ZXR0YTEWMBQGA1UEAxMNRmFi aW8gRmFudG9uaTEmMCQGCSqGSIb3DQEJARYXZmFudG9uaWZhYmlvQHRpc2NhbGkuaXQwggEi MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC1XhckXsX23vgJq76s2f0KT8U8Msov5QgV 10eQBb2wL/TzcmqtZotI7ztKVhio3ehHg+mfu+3EqOkX9Umgut8rP0bPi7AGjkPXbOTT/cSU Xz2Kw31VGOmiOVoUFGvpQitp3weCkhUJLBipI8EpNyBXpjtQ9yCpnIAqfuc77ybfSnCy7tTR MBq1BUkfjH1+GL45riosuS4+F+MSUvlYzLiT4rAduAX1Y2IuORDsf9Bce8GBxa6syP9rCyzl Vk7DIX5k8j2vlnyRATIypn5CQLQxGT6e0f6ac4gvWOHwO2QEBsmZKKs1ZidE4q/9OoNXYX6A jnHtp1H1vcrek/vVcs19AgMBAAGjggOyMIIDrjAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAd BgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHQYDVR0OBBYEFFan8cbEWWBmSTWFtLk2 YNdAcGUbMB8GA1UdIwQYMBaAFK5Vg2/sMcq59x36r2sx88gd46y7MCIGA1UdEQQbMBmBF2Zh bnRvbmlmYWJpb0B0aXNjYWxpLml0MIICIQYDVR0gBIICGDCCAhQwggIQBgsrBgEEAYG1NwEC AjCCAf8wLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYw NAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVkaWF0ZS5wZGYw gfcGCCsGAQUFBwICMIHqMCcWIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MAMC AQEagb5UaGlzIGNlcnRpZmljYXRlIHdhcyBpc3N1ZWQgYWNjb3JkaW5nIHRvIHRoZSBDbGFz cyAyIFZhbGlkYXRpb24gcmVxdWlyZW1lbnRzIG9mIHRoZSBTdGFydENvbSBDQSBwb2xpY3ks IHJlbGlhbmNlIG9ubHkgZm9yIHRoZSBpbnRlbmRlZCBwdXJwb3NlIGluIGNvbXBsaWFuY2Ug b2YgdGhlIHJlbHlpbmcgcGFydHkgb2JsaWdhdGlvbnMuMIGcBggrBgEFBQcCAjCBjzAnFiBT dGFydENvbSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTADAgECGmRMaWFiaWxpdHkgYW5kIHdh cnJhbnRpZXMgYXJlIGxpbWl0ZWQhIFNlZSBzZWN0aW9uICJMZWdhbCBhbmQgTGltaXRhdGlv bnMiIG9mIHRoZSBTdGFydENvbSBDQSBwb2xpY3kuMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6 Ly9jcmwuc3RhcnRzc2wuY29tL2NydHUyLWNybC5jcmwwgY4GCCsGAQUFBwEBBIGBMH8wOQYI KwYBBQUHMAGGLWh0dHA6Ly9vY3NwLnN0YXJ0c3NsLmNvbS9zdWIvY2xhc3MyL2NsaWVudC9j YTBCBggrBgEFBQcwAoY2aHR0cDovL2FpYS5zdGFydHNzbC5jb20vY2VydHMvc3ViLmNsYXNz Mi5jbGllbnQuY2EuY3J0MCMGA1UdEgQcMBqGGGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tLzAN BgkqhkiG9w0BAQUFAAOCAQEAjzHNqifpDVMkH1TSPFZVIiQ4fh49/V5JMpstgqEZPDaDe5r8 h+fMBZtUa6LLMco03Z9BNEXlqlXKiFk8feVYB8obEjz7YYq1XhO9q7JUmkSs0WGIH4xU0XB1 kPC8T8H+5E//84poYSFHE4pA+Ff68UANP2/EuFJWMjegiefnOr8aM42OAcUkjEWSlautIIX8 oD2GizwQYjWdDDjEonbuMKFP6rY2xGI3PSLI3IVU2opb0/itNhQui3WRxafloJqTlriY8m8+ qSLr2HGftbBlbyzVWB8o//aW0H0LMabjkIvrm7Zmh2vcCxiSxGBwYASuSYXGuQiKAgGptUs1 XJLZuzGCA9owggPWAgEBMIGTMIGMMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20g THRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzE4MDYG A1UEAxMvU3RhcnRDb20gQ2xhc3MgMiBQcmltYXJ5IEludGVybWVkaWF0ZSBDbGllbnQgQ0EC Ah5jMAkGBSsOAwIaBQCgggIbMBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcN AQkFMQ8XDTEyMTExNTE0NTcxMFowIwYJKoZIhvcNAQkEMRYEFAyo/Y+Q3lTEH2J8ql4b0rvK EOCgMGwGCSqGSIb3DQEJDzFfMF0wCwYJYIZIAWUDBAEqMAsGCWCGSAFlAwQBAjAKBggqhkiG 9w0DBzAOBggqhkiG9w0DAgICAIAwDQYIKoZIhvcNAwICAUAwBwYFKw4DAgcwDQYIKoZIhvcN AwICASgwgaQGCSsGAQQBgjcQBDGBljCBkzCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0 YXJ0Q29tIEx0ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25p bmcxODA2BgNVBAMTL1N0YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUgQ2xp ZW50IENBAgIeYzCBpgYLKoZIhvcNAQkQAgsxgZaggZMwgYwxCzAJBgNVBAYTAklMMRYwFAYD VQQKEw1TdGFydENvbSBMdGQuMSswKQYDVQQLEyJTZWN1cmUgRGlnaXRhbCBDZXJ0aWZpY2F0 ZSBTaWduaW5nMTgwNgYDVQQDEy9TdGFydENvbSBDbGFzcyAyIFByaW1hcnkgSW50ZXJtZWRp YXRlIENsaWVudCBDQQICHmMwDQYJKoZIhvcNAQEBBQAEggEAEFI8L31aNSVh8BOEbt0ZCIof kn6ZJEr7gApU8RSi8sCZpzF9KIM37ccxbXCzYSUPkZrgLLm/PEnjjCRVIENXtSosM3fk+BTJ fSw9z8UOczjQpuS9aXabmPK993RMDbQEeyt86hXT0hqq0SaKZgdMY862gWoQ6UXEIAXh/fgY kaOXSGIK8o20COxmc3Dw9gpWEH/W/1BZQNUUMeuhEpK/7pIHkm8kJTOgj+BBRO9bb/aIbcIi svKqX/szRRwUpUxWV7Z2WLKXQE7kyjI0Uqhk6kDANo33JUstNvXy/YEX1+pdgzdPCXGsBK9h HZBLgejK+p1DJfXweFe1GJs0OgGWowAAAAAAAA== --------------ms080700070703050209090706-- --===============7913354209453772044== 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 --===============7913354209453772044==-- From xen-devel-bounces@lists.xen.org Thu Nov 15 15:17:54 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 15 Nov 2012 15:17:54 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ1CK-0001MS-0R; Thu, 15 Nov 2012 15:17:44 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ1CI-0001Lh-1Q for xen-devel@lists.xen.org; Thu, 15 Nov 2012 15:17:42 +0000 Received: from [85.158.137.99:10385] by server-5.bemta-3.messagelabs.com id 89/8A-26311-59705A05; Thu, 15 Nov 2012 15:17:41 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-15.tower-217.messagelabs.com!1352992655!16901189!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_23,UNPARSEABLE_RELAY,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 27753 invoked from network); 15 Nov 2012 15:17:36 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-15.tower-217.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 15 Nov 2012 15:17:36 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.149187341; Thu, 15 Nov 2012 10:17:21 -0500 From: Matthew Fioravante To: Ian.Campbell@citrix.com, xen-devel@lists.xen.org Date: Thu, 15 Nov 2012 10:17:06 -0500 Message-Id: <1352992629-5850-8-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1352992629-5850-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1352992629-5850-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM v3 07/10] Regenerate configure script after removing vtpm 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 Signed-off-by: Matthew Fioravante --- tools/configure | 603 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 302 insertions(+), 301 deletions(-) diff --git a/tools/configure b/tools/configure index edf42f6..ed20d12 100755 --- a/tools/configure +++ b/tools/configure @@ -1,13 +1,11 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.67 for Xen Hypervisor 4.3. +# Generated by GNU Autoconf 2.69 for Xen Hypervisor 4.3. # # Report bugs to . # # -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software -# Foundation, Inc. +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation @@ -91,6 +89,7 @@ fi IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. +as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -135,6 +134,31 @@ export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh @@ -168,7 +192,8 @@ if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi -test x\$exitcode = x0 || exit 1" +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && @@ -213,14 +238,25 @@ IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : - # We cannot yet assume a decent shell, so we have to provide a - # neutralization value for shells without unset; and this also - # works around shells that cannot unset nonexistent variables. - BASH_ENV=/dev/null - ENV=/dev/null - (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 fi if test x$as_have_required = xno; then : @@ -323,6 +359,14 @@ $as_echo X"$as_dir" | } # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take @@ -444,6 +488,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). @@ -478,16 +526,16 @@ if (echo >conf$$.file) 2>/dev/null; then # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. + # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' + as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null @@ -499,28 +547,8 @@ else as_mkdir_p=false fi -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x +as_test_x='test -x' +as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" @@ -668,7 +696,6 @@ lomount miniterm ocamltools xenapi -vtpm monitors githttp host_os @@ -722,7 +749,6 @@ ac_user_opts=' enable_option_checking enable_githttp enable_monitors -enable_vtpm enable_xenapi enable_ocamltools enable_miniterm @@ -1166,7 +1192,7 @@ Try \`$0 --help' for more information" $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 - : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac @@ -1217,8 +1243,6 @@ target=$target_alias if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe - $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. - If a cross compiler is detected then cross compile mode will be used" >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi @@ -1381,8 +1405,6 @@ Optional Features: DISABLED) --disable-monitors Disable xenstat and xentop monitoring tools (default is ENABLED) - --enable-vtpm Enable Virtual Trusted Platform Module (default is - DISABLED) --enable-xenapi Enable Xen API Bindings (default is DISABLED) --disable-ocamltools Disable Ocaml tools (default is ENABLED) --enable-miniterm Enable miniterm (default is DISABLED) @@ -1495,9 +1517,9 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF Xen Hypervisor configure 4.3 -generated by GNU Autoconf 2.67 +generated by GNU Autoconf 2.69 -Copyright (C) 2010 Free Software Foundation, Inc. +Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1541,7 +1563,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile @@ -1578,7 +1600,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp @@ -1591,10 +1613,10 @@ fi ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval "test \"\${$3+set}\"" = set; then : + if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 @@ -1661,7 +1683,7 @@ $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" @@ -1670,7 +1692,7 @@ eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel @@ -1711,7 +1733,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run @@ -1725,7 +1747,7 @@ ac_fn_c_check_header_compile () as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -1743,7 +1765,7 @@ fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile @@ -1774,7 +1796,7 @@ $as_echo "$ac_try_echo"; } >&5 test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || - $as_test_x conftest$ac_exeext + test -x conftest$ac_exeext }; then : ac_retval=0 else @@ -1788,7 +1810,7 @@ fi # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link @@ -1797,7 +1819,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by Xen Hypervisor $as_me 4.3, which was -generated by GNU Autoconf 2.67. Invocation command line was +generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2055,7 +2077,7 @@ $as_echo "$as_me: loading site script $ac_site_file" >&6;} || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi done @@ -2199,7 +2221,7 @@ $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } -if test "${ac_cv_build+set}" = set; then : +if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias @@ -2215,7 +2237,7 @@ fi $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; -*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5 ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' @@ -2233,7 +2255,7 @@ case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } -if test "${ac_cv_host+set}" = set; then : +if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then @@ -2248,7 +2270,7 @@ fi $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; -*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5 ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' @@ -2445,29 +2467,6 @@ monitors=$ax_cv_monitors -# Check whether --enable-vtpm was given. -if test "${enable_vtpm+set}" = set; then : - enableval=$enable_vtpm; -fi - - -if test "x$enable_vtpm" = "xno"; then : - - ax_cv_vtpm="n" - -elif test "x$enable_vtpm" = "xyes"; then : - - ax_cv_vtpm="y" - -elif test -z $ax_cv_vtpm; then : - - ax_cv_vtpm="n" - -fi -vtpm=$ax_cv_vtpm - - - # Check whether --enable-xenapi was given. if test "${enable_xenapi+set}" = set; then : enableval=$enable_xenapi; @@ -2700,7 +2699,7 @@ if test -n "$ac_tool_prefix"; then set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2712,7 +2711,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2740,7 +2739,7 @@ if test -z "$ac_cv_prog_CC"; then set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : +if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then @@ -2752,7 +2751,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2793,7 +2792,7 @@ if test -z "$CC"; then set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2805,7 +2804,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2833,7 +2832,7 @@ if test -z "$CC"; then set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2846,7 +2845,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue @@ -2892,7 +2891,7 @@ if test -z "$CC"; then set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2904,7 +2903,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2936,7 +2935,7 @@ do set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : +if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then @@ -2948,7 +2947,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2991,7 +2990,7 @@ fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 @@ -3106,7 +3105,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } @@ -3149,7 +3148,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 @@ -3208,7 +3207,7 @@ $as_echo "$ac_try_echo"; } >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi fi fi @@ -3219,7 +3218,7 @@ rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } -if test "${ac_cv_objext+set}" = set; then : +if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -3260,7 +3259,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi @@ -3270,7 +3269,7 @@ OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } -if test "${ac_cv_c_compiler_gnu+set}" = set; then : +if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -3307,7 +3306,7 @@ ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } -if test "${ac_cv_prog_cc_g+set}" = set; then : +if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag @@ -3385,7 +3384,7 @@ else fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if test "${ac_cv_prog_cc_c89+set}" = set; then : +if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no @@ -3394,8 +3393,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include -#include -#include +struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); @@ -3484,7 +3482,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` -if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\"" = set; then : +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF @@ -3528,7 +3526,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 $as_echo_n "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then -if test "${ac_cv_path_install+set}" = set; then : +if ${ac_cv_path_install+:} false; then : $as_echo_n "(cached) " >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3548,7 +3546,7 @@ case $as_dir/ in #(( # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then if test $ac_prog = install && grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. @@ -3608,7 +3606,7 @@ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' set dummy bison; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BISON+set}" = set; then : +if ${ac_cv_path_BISON+:} false; then : $as_echo_n "(cached) " >&6 else case $BISON in @@ -3622,7 +3620,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BISON="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3648,7 +3646,7 @@ fi set dummy flex; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FLEX+set}" = set; then : +if ${ac_cv_path_FLEX+:} false; then : $as_echo_n "(cached) " >&6 else case $FLEX in @@ -3662,7 +3660,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_FLEX="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3688,7 +3686,7 @@ fi set dummy perl; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PERL+set}" = set; then : +if ${ac_cv_path_PERL+:} false; then : $as_echo_n "(cached) " >&6 else case $PERL in @@ -3702,7 +3700,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PERL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3735,7 +3733,7 @@ if test "x$xapi" = "xy"; then : set dummy curl-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CURL+set}" = set; then : +if ${ac_cv_path_CURL+:} false; then : $as_echo_n "(cached) " >&6 else case $CURL in @@ -3749,7 +3747,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_CURL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3780,7 +3778,7 @@ fi set dummy xml2-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_XML+set}" = set; then : +if ${ac_cv_path_XML+:} false; then : $as_echo_n "(cached) " >&6 else case $XML in @@ -3794,7 +3792,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_XML="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3831,7 +3829,7 @@ if test "x$ocamltools" = "xy"; then : set dummy ${ac_tool_prefix}ocamlc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLC+set}" = set; then : +if ${ac_cv_prog_OCAMLC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLC"; then @@ -3843,7 +3841,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLC="${ac_tool_prefix}ocamlc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3871,7 +3869,7 @@ if test -z "$ac_cv_prog_OCAMLC"; then set dummy ocamlc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLC+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLC"; then @@ -3883,7 +3881,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLC="ocamlc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3942,7 +3940,7 @@ $as_echo "OCaml library path is $OCAMLLIB" >&6; } set dummy ${ac_tool_prefix}ocamlopt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPT"; then @@ -3954,7 +3952,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPT="${ac_tool_prefix}ocamlopt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3982,7 +3980,7 @@ if test -z "$ac_cv_prog_OCAMLOPT"; then set dummy ocamlopt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLOPT"; then @@ -3994,7 +3992,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPT="ocamlopt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4052,7 +4050,7 @@ $as_echo "versions differs from ocamlc; ocamlopt discarded." >&6; } set dummy ${ac_tool_prefix}ocamlc.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLCDOTOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLCDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLCDOTOPT"; then @@ -4064,7 +4062,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLCDOTOPT="${ac_tool_prefix}ocamlc.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4092,7 +4090,7 @@ if test -z "$ac_cv_prog_OCAMLCDOTOPT"; then set dummy ocamlc.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLCDOTOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLCDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLCDOTOPT"; then @@ -4104,7 +4102,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLCDOTOPT="ocamlc.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4156,7 +4154,7 @@ $as_echo "versions differs from ocamlc; ocamlc.opt discarded." >&6; } set dummy ${ac_tool_prefix}ocamlopt.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLOPTDOTOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLOPTDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPTDOTOPT"; then @@ -4168,7 +4166,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPTDOTOPT="${ac_tool_prefix}ocamlopt.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4196,7 +4194,7 @@ if test -z "$ac_cv_prog_OCAMLOPTDOTOPT"; then set dummy ocamlopt.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLOPTDOTOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLOPTDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLOPTDOTOPT"; then @@ -4208,7 +4206,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPTDOTOPT="ocamlopt.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4265,7 +4263,7 @@ $as_echo "version differs from ocamlc; ocamlopt.opt discarded." >&6; } set dummy ${ac_tool_prefix}ocaml; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAML+set}" = set; then : +if ${ac_cv_prog_OCAML+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAML"; then @@ -4277,7 +4275,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAML="${ac_tool_prefix}ocaml" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4305,7 +4303,7 @@ if test -z "$ac_cv_prog_OCAML"; then set dummy ocaml; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAML+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAML+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAML"; then @@ -4317,7 +4315,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAML="ocaml" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4359,7 +4357,7 @@ fi set dummy ${ac_tool_prefix}ocamldep; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLDEP+set}" = set; then : +if ${ac_cv_prog_OCAMLDEP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDEP"; then @@ -4371,7 +4369,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDEP="${ac_tool_prefix}ocamldep" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4399,7 +4397,7 @@ if test -z "$ac_cv_prog_OCAMLDEP"; then set dummy ocamldep; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLDEP+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLDEP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLDEP"; then @@ -4411,7 +4409,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDEP="ocamldep" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4453,7 +4451,7 @@ fi set dummy ${ac_tool_prefix}ocamlmktop; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLMKTOP+set}" = set; then : +if ${ac_cv_prog_OCAMLMKTOP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLMKTOP"; then @@ -4465,7 +4463,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKTOP="${ac_tool_prefix}ocamlmktop" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4493,7 +4491,7 @@ if test -z "$ac_cv_prog_OCAMLMKTOP"; then set dummy ocamlmktop; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLMKTOP+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLMKTOP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLMKTOP"; then @@ -4505,7 +4503,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKTOP="ocamlmktop" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4547,7 +4545,7 @@ fi set dummy ${ac_tool_prefix}ocamlmklib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLMKLIB+set}" = set; then : +if ${ac_cv_prog_OCAMLMKLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLMKLIB"; then @@ -4559,7 +4557,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKLIB="${ac_tool_prefix}ocamlmklib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4587,7 +4585,7 @@ if test -z "$ac_cv_prog_OCAMLMKLIB"; then set dummy ocamlmklib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLMKLIB+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLMKLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLMKLIB"; then @@ -4599,7 +4597,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKLIB="ocamlmklib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4641,7 +4639,7 @@ fi set dummy ${ac_tool_prefix}ocamldoc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLDOC+set}" = set; then : +if ${ac_cv_prog_OCAMLDOC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDOC"; then @@ -4653,7 +4651,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDOC="${ac_tool_prefix}ocamldoc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4681,7 +4679,7 @@ if test -z "$ac_cv_prog_OCAMLDOC"; then set dummy ocamldoc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLDOC+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLDOC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLDOC"; then @@ -4693,7 +4691,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDOC="ocamldoc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4735,7 +4733,7 @@ fi set dummy ${ac_tool_prefix}ocamlbuild; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLBUILD+set}" = set; then : +if ${ac_cv_prog_OCAMLBUILD+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLBUILD"; then @@ -4747,7 +4745,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLBUILD="${ac_tool_prefix}ocamlbuild" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4775,7 +4773,7 @@ if test -z "$ac_cv_prog_OCAMLBUILD"; then set dummy ocamlbuild; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLBUILD+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLBUILD+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLBUILD"; then @@ -4787,7 +4785,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLBUILD="ocamlbuild" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4838,7 +4836,7 @@ fi set dummy bash; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BASH+set}" = set; then : +if ${ac_cv_path_BASH+:} false; then : $as_echo_n "(cached) " >&6 else case $BASH in @@ -4852,7 +4850,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4893,7 +4891,7 @@ fi set dummy $PYTHON; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PYTHONPATH+set}" = set; then : +if ${ac_cv_path_PYTHONPATH+:} false; then : $as_echo_n "(cached) " >&6 else case $PYTHONPATH in @@ -4907,7 +4905,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PYTHONPATH="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4960,7 +4958,7 @@ if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then - if test "${ac_cv_prog_CPP+set}" = set; then : + if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded @@ -5076,7 +5074,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c @@ -5088,7 +5086,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if test "${ac_cv_path_GREP+set}" = set; then : +if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then @@ -5102,7 +5100,7 @@ do for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue + as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in @@ -5151,7 +5149,7 @@ $as_echo "$ac_cv_path_GREP" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } -if test "${ac_cv_path_EGREP+set}" = set; then : +if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 @@ -5168,7 +5166,7 @@ do for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue + as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in @@ -5218,7 +5216,7 @@ $as_echo "$ac_cv_path_EGREP" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } -if test "${ac_cv_header_stdc+set}" = set; then : +if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -5354,7 +5352,7 @@ ac_python_version=`$PYTHON -c 'import distutils.sysconfig; \ set dummy $PYTHON-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_pyconfig+set}" = set; then : +if ${ac_cv_path_pyconfig+:} false; then : $as_echo_n "(cached) " >&6 else case $pyconfig in @@ -5368,7 +5366,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_pyconfig="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5417,7 +5415,7 @@ else fi ac_fn_c_check_header_mongrel "$LINENO" "Python.h" "ac_cv_header_Python_h" "$ac_includes_default" -if test "x$ac_cv_header_Python_h" = x""yes; then : +if test "x$ac_cv_header_Python_h" = xyes; then : else as_fn_error $? "Unable to find Python development headers" "$LINENO" 5 @@ -5427,7 +5425,7 @@ fi as_ac_Lib=`$as_echo "ac_cv_lib_python$ac_python_version''_PyArg_ParseTuple" | $as_tr_sh` { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PyArg_ParseTuple in -lpython$ac_python_version" >&5 $as_echo_n "checking for PyArg_ParseTuple in -lpython$ac_python_version... " >&6; } -if eval "test \"\${$as_ac_Lib+set}\"" = set; then : +if eval \${$as_ac_Lib+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5480,7 +5478,7 @@ LDLFAGS=$ac_previous_ldflags set dummy xgettext; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_XGETTEXT+set}" = set; then : +if ${ac_cv_path_XGETTEXT+:} false; then : $as_echo_n "(cached) " >&6 else case $XGETTEXT in @@ -5494,7 +5492,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_XGETTEXT="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5527,7 +5525,7 @@ i[3456]86|x86_64) set dummy as86; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_AS86+set}" = set; then : +if ${ac_cv_path_AS86+:} false; then : $as_echo_n "(cached) " >&6 else case $AS86 in @@ -5541,7 +5539,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_AS86="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5572,7 +5570,7 @@ fi set dummy ld86; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_LD86+set}" = set; then : +if ${ac_cv_path_LD86+:} false; then : $as_echo_n "(cached) " >&6 else case $LD86 in @@ -5586,7 +5584,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_LD86="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5617,7 +5615,7 @@ fi set dummy bcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BCC+set}" = set; then : +if ${ac_cv_path_BCC+:} false; then : $as_echo_n "(cached) " >&6 else case $BCC in @@ -5631,7 +5629,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BCC="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5662,7 +5660,7 @@ fi set dummy iasl; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_IASL+set}" = set; then : +if ${ac_cv_path_IASL+:} false; then : $as_echo_n "(cached) " >&6 else case $IASL in @@ -5676,7 +5674,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_IASL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5707,11 +5705,11 @@ fi esac ac_fn_c_check_header_mongrel "$LINENO" "uuid/uuid.h" "ac_cv_header_uuid_uuid_h" "$ac_includes_default" -if test "x$ac_cv_header_uuid_uuid_h" = x""yes; then : +if test "x$ac_cv_header_uuid_uuid_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uuid_clear in -luuid" >&5 $as_echo_n "checking for uuid_clear in -luuid... " >&6; } -if test "${ac_cv_lib_uuid_uuid_clear+set}" = set; then : +if ${ac_cv_lib_uuid_uuid_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5745,7 +5743,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_uuid_uuid_clear" >&5 $as_echo "$ac_cv_lib_uuid_uuid_clear" >&6; } -if test "x$ac_cv_lib_uuid_uuid_clear" = x""yes; then : +if test "x$ac_cv_lib_uuid_uuid_clear" = xyes; then : libuuid="y" fi @@ -5754,7 +5752,7 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "uuid.h" "ac_cv_header_uuid_h" "$ac_includes_default" -if test "x$ac_cv_header_uuid_h" = x""yes; then : +if test "x$ac_cv_header_uuid_h" = xyes; then : libuuid="y" fi @@ -5767,11 +5765,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "curses.h" "ac_cv_header_curses_h" "$ac_includes_default" -if test "x$ac_cv_header_curses_h" = x""yes; then : +if test "x$ac_cv_header_curses_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clear in -lcurses" >&5 $as_echo_n "checking for clear in -lcurses... " >&6; } -if test "${ac_cv_lib_curses_clear+set}" = set; then : +if ${ac_cv_lib_curses_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5805,7 +5803,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_curses_clear" >&5 $as_echo "$ac_cv_lib_curses_clear" >&6; } -if test "x$ac_cv_lib_curses_clear" = x""yes; then : +if test "x$ac_cv_lib_curses_clear" = xyes; then : curses="y" else curses="n" @@ -5818,11 +5816,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ncurses.h" "ac_cv_header_ncurses_h" "$ac_includes_default" -if test "x$ac_cv_header_ncurses_h" = x""yes; then : +if test "x$ac_cv_header_ncurses_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clear in -lncurses" >&5 $as_echo_n "checking for clear in -lncurses... " >&6; } -if test "${ac_cv_lib_ncurses_clear+set}" = set; then : +if ${ac_cv_lib_ncurses_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5856,7 +5854,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ncurses_clear" >&5 $as_echo "$ac_cv_lib_ncurses_clear" >&6; } -if test "x$ac_cv_lib_ncurses_clear" = x""yes; then : +if test "x$ac_cv_lib_ncurses_clear" = xyes; then : ncurses="y" else ncurses="n" @@ -5903,7 +5901,7 @@ if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PKG_CONFIG+set}" = set; then : +if ${ac_cv_path_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $PKG_CONFIG in @@ -5917,7 +5915,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5946,7 +5944,7 @@ if test -z "$ac_cv_path_PKG_CONFIG"; then set dummy pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then : +if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $ac_pt_PKG_CONFIG in @@ -5960,7 +5958,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6091,7 +6089,7 @@ and glib_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } else glib_CFLAGS=$pkg_cv_glib_CFLAGS glib_LIBS=$pkg_cv_glib_LIBS @@ -6104,7 +6102,7 @@ fi set dummy wget; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_WGET+set}" = set; then : +if ${ac_cv_path_WGET+:} false; then : $as_echo_n "(cached) " >&6 else case $WGET in @@ -6118,7 +6116,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_WGET="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6151,7 +6149,7 @@ else set dummy ftp; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FTP+set}" = set; then : +if ${ac_cv_path_FTP+:} false; then : $as_echo_n "(cached) " >&6 else case $FTP in @@ -6165,7 +6163,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_FTP="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6204,11 +6202,11 @@ fi # Checks for libraries. ac_fn_c_check_header_mongrel "$LINENO" "bzlib.h" "ac_cv_header_bzlib_h" "$ac_includes_default" -if test "x$ac_cv_header_bzlib_h" = x""yes; then : +if test "x$ac_cv_header_bzlib_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BZ2_bzDecompressInit in -lbz2" >&5 $as_echo_n "checking for BZ2_bzDecompressInit in -lbz2... " >&6; } -if test "${ac_cv_lib_bz2_BZ2_bzDecompressInit+set}" = set; then : +if ${ac_cv_lib_bz2_BZ2_bzDecompressInit+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6242,7 +6240,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bz2_BZ2_bzDecompressInit" >&5 $as_echo "$ac_cv_lib_bz2_BZ2_bzDecompressInit" >&6; } -if test "x$ac_cv_lib_bz2_BZ2_bzDecompressInit" = x""yes; then : +if test "x$ac_cv_lib_bz2_BZ2_bzDecompressInit" = xyes; then : zlib="$zlib -DHAVE_BZLIB -lbz2" fi @@ -6251,11 +6249,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "lzma.h" "ac_cv_header_lzma_h" "$ac_includes_default" -if test "x$ac_cv_header_lzma_h" = x""yes; then : +if test "x$ac_cv_header_lzma_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lzma_stream_decoder in -llzma" >&5 $as_echo_n "checking for lzma_stream_decoder in -llzma... " >&6; } -if test "${ac_cv_lib_lzma_lzma_stream_decoder+set}" = set; then : +if ${ac_cv_lib_lzma_lzma_stream_decoder+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6289,7 +6287,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lzma_lzma_stream_decoder" >&5 $as_echo "$ac_cv_lib_lzma_lzma_stream_decoder" >&6; } -if test "x$ac_cv_lib_lzma_lzma_stream_decoder" = x""yes; then : +if test "x$ac_cv_lib_lzma_lzma_stream_decoder" = xyes; then : zlib="$zlib -DHAVE_LZMA -llzma" fi @@ -6298,11 +6296,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "lzo/lzo1x.h" "ac_cv_header_lzo_lzo1x_h" "$ac_includes_default" -if test "x$ac_cv_header_lzo_lzo1x_h" = x""yes; then : +if test "x$ac_cv_header_lzo_lzo1x_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lzo1x_decompress in -llzo2" >&5 $as_echo_n "checking for lzo1x_decompress in -llzo2... " >&6; } -if test "${ac_cv_lib_lzo2_lzo1x_decompress+set}" = set; then : +if ${ac_cv_lib_lzo2_lzo1x_decompress+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6336,7 +6334,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lzo2_lzo1x_decompress" >&5 $as_echo "$ac_cv_lib_lzo2_lzo1x_decompress" >&6; } -if test "x$ac_cv_lib_lzo2_lzo1x_decompress" = x""yes; then : +if test "x$ac_cv_lib_lzo2_lzo1x_decompress" = xyes; then : zlib="$zlib -DHAVE_LZO1X -llzo2" fi @@ -6347,7 +6345,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for io_setup in -laio" >&5 $as_echo_n "checking for io_setup in -laio... " >&6; } -if test "${ac_cv_lib_aio_io_setup+set}" = set; then : +if ${ac_cv_lib_aio_io_setup+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6381,7 +6379,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_aio_io_setup" >&5 $as_echo "$ac_cv_lib_aio_io_setup" >&6; } -if test "x$ac_cv_lib_aio_io_setup" = x""yes; then : +if test "x$ac_cv_lib_aio_io_setup" = xyes; then : system_aio="y" else system_aio="n" @@ -6390,7 +6388,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MD5 in -lcrypto" >&5 $as_echo_n "checking for MD5 in -lcrypto... " >&6; } -if test "${ac_cv_lib_crypto_MD5+set}" = set; then : +if ${ac_cv_lib_crypto_MD5+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6424,7 +6422,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_MD5" >&5 $as_echo "$ac_cv_lib_crypto_MD5" >&6; } -if test "x$ac_cv_lib_crypto_MD5" = x""yes; then : +if test "x$ac_cv_lib_crypto_MD5" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBCRYPTO 1 _ACEOF @@ -6437,11 +6435,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ext2fs/ext2fs.h" "ac_cv_header_ext2fs_ext2fs_h" "$ac_includes_default" -if test "x$ac_cv_header_ext2fs_ext2fs_h" = x""yes; then : +if test "x$ac_cv_header_ext2fs_ext2fs_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ext2fs_open2 in -lext2fs" >&5 $as_echo_n "checking for ext2fs_open2 in -lext2fs... " >&6; } -if test "${ac_cv_lib_ext2fs_ext2fs_open2+set}" = set; then : +if ${ac_cv_lib_ext2fs_ext2fs_open2+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6475,7 +6473,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ext2fs_ext2fs_open2" >&5 $as_echo "$ac_cv_lib_ext2fs_ext2fs_open2" >&6; } -if test "x$ac_cv_lib_ext2fs_ext2fs_open2" = x""yes; then : +if test "x$ac_cv_lib_ext2fs_ext2fs_open2" = xyes; then : $as_echo "#define INCLUDE_EXTFS_H " >>confdefs.h @@ -6489,11 +6487,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ext4fs/ext2fs.h" "ac_cv_header_ext4fs_ext2fs_h" "$ac_includes_default" -if test "x$ac_cv_header_ext4fs_ext2fs_h" = x""yes; then : +if test "x$ac_cv_header_ext4fs_ext2fs_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ext2fs_open2 in -lext4fs" >&5 $as_echo_n "checking for ext2fs_open2 in -lext4fs... " >&6; } -if test "${ac_cv_lib_ext4fs_ext2fs_open2+set}" = set; then : +if ${ac_cv_lib_ext4fs_ext2fs_open2+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6527,7 +6525,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ext4fs_ext2fs_open2" >&5 $as_echo "$ac_cv_lib_ext4fs_ext2fs_open2" >&6; } -if test "x$ac_cv_lib_ext4fs_ext2fs_open2" = x""yes; then : +if test "x$ac_cv_lib_ext4fs_ext2fs_open2" = xyes; then : $as_echo "#define INCLUDE_EXTFS_H " >>confdefs.h @@ -6544,7 +6542,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gcry_md_hash_buffer in -lgcrypt" >&5 $as_echo_n "checking for gcry_md_hash_buffer in -lgcrypt... " >&6; } -if test "${ac_cv_lib_gcrypt_gcry_md_hash_buffer+set}" = set; then : +if ${ac_cv_lib_gcrypt_gcry_md_hash_buffer+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6578,7 +6576,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcrypt_gcry_md_hash_buffer" >&5 $as_echo "$ac_cv_lib_gcrypt_gcry_md_hash_buffer" >&6; } -if test "x$ac_cv_lib_gcrypt_gcry_md_hash_buffer" = x""yes; then : +if test "x$ac_cv_lib_gcrypt_gcry_md_hash_buffer" = xyes; then : libgcrypt="y" else libgcrypt="n" @@ -6588,7 +6586,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread flag" >&5 $as_echo_n "checking for pthread flag... " >&6; } -if test "${ax_cv_pthread_flags+set}" = set; then : +if ${ax_cv_pthread_flags+:} false; then : $as_echo_n "(cached) " >&6 else @@ -6656,7 +6654,7 @@ $as_echo "$ax_cv_pthread_flags" >&6; } CPPFLAGS="$CPPFLAGS -Werror" ac_fn_c_check_header_mongrel "$LINENO" "libutil.h" "ac_cv_header_libutil_h" "$ac_includes_default" -if test "x$ac_cv_header_libutil_h" = x""yes; then : +if test "x$ac_cv_header_libutil_h" = xyes; then : $as_echo "#define INCLUDE_LIBUTIL_H " >>confdefs.h @@ -6670,7 +6668,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for openpty et al" >&5 $as_echo_n "checking for openpty et al... " >&6; } -if test "${ax_cv_ptyfuncs_libs+set}" = set; then : +if ${ax_cv_ptyfuncs_libs+:} false; then : $as_echo_n "(cached) " >&6 else @@ -6679,7 +6677,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "Unable to find library for openpty and login_tty -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi saved_LIBS="$LIBS" @@ -6717,7 +6715,7 @@ $as_echo "$ax_cv_ptyfuncs_libs" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for yajl_alloc in -lyajl" >&5 $as_echo_n "checking for yajl_alloc in -lyajl... " >&6; } -if test "${ac_cv_lib_yajl_yajl_alloc+set}" = set; then : +if ${ac_cv_lib_yajl_yajl_alloc+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6751,7 +6749,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_yajl_yajl_alloc" >&5 $as_echo "$ac_cv_lib_yajl_yajl_alloc" >&6; } -if test "x$ac_cv_lib_yajl_yajl_alloc" = x""yes; then : +if test "x$ac_cv_lib_yajl_yajl_alloc" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBYAJL 1 _ACEOF @@ -6764,7 +6762,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for deflateCopy in -lz" >&5 $as_echo_n "checking for deflateCopy in -lz... " >&6; } -if test "${ac_cv_lib_z_deflateCopy+set}" = set; then : +if ${ac_cv_lib_z_deflateCopy+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6798,7 +6796,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_deflateCopy" >&5 $as_echo "$ac_cv_lib_z_deflateCopy" >&6; } -if test "x$ac_cv_lib_z_deflateCopy" = x""yes; then : +if test "x$ac_cv_lib_z_deflateCopy" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBZ 1 _ACEOF @@ -6811,7 +6809,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libiconv_open in -liconv" >&5 $as_echo_n "checking for libiconv_open in -liconv... " >&6; } -if test "${ac_cv_lib_iconv_libiconv_open+set}" = set; then : +if ${ac_cv_lib_iconv_libiconv_open+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6845,7 +6843,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_iconv_libiconv_open" >&5 $as_echo "$ac_cv_lib_iconv_libiconv_open" >&6; } -if test "x$ac_cv_lib_iconv_libiconv_open" = x""yes; then : +if test "x$ac_cv_lib_iconv_libiconv_open" = xyes; then : libiconv="y" else libiconv="n" @@ -6857,7 +6855,7 @@ fi for ac_header in yajl/yajl_version.h do : ac_fn_c_check_header_mongrel "$LINENO" "yajl/yajl_version.h" "ac_cv_header_yajl_yajl_version_h" "$ac_includes_default" -if test "x$ac_cv_header_yajl_yajl_version_h" = x""yes; then : +if test "x$ac_cv_header_yajl_yajl_version_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_YAJL_YAJL_VERSION_H 1 _ACEOF @@ -6931,10 +6929,21 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then - test "x$cache_file" != "x/dev/null" && + if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} - cat confcache >$cache_file + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} @@ -6966,7 +6975,7 @@ LTLIBOBJS=$ac_ltlibobjs -: ${CONFIG_STATUS=./config.status} +: "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" @@ -7067,6 +7076,7 @@ fi IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. +as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7262,16 +7272,16 @@ if (echo >conf$$.file) 2>/dev/null; then # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. + # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' + as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null @@ -7331,28 +7341,16 @@ else as_mkdir_p=false fi -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" @@ -7374,7 +7372,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # values after options handling. ac_log=" This file was extended by Xen Hypervisor $as_me 4.3, which was -generated by GNU Autoconf 2.67. Invocation command line was +generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -7437,10 +7435,10 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ Xen Hypervisor config.status 4.3 -configured by $0, generated by GNU Autoconf 2.67, +configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" -Copyright (C) 2010 Free Software Foundation, Inc. +Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -7529,7 +7527,7 @@ fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then - set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' @@ -7561,7 +7559,7 @@ do "../config/Tools.mk") CONFIG_FILES="$CONFIG_FILES ../config/Tools.mk" ;; "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; - *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;; + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done @@ -7583,9 +7581,10 @@ fi # after its creation but before its name has been assigned to `$tmp'. $debug || { - tmp= + tmp= ac_tmp= trap 'exit_status=$? - { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } @@ -7593,12 +7592,13 @@ $debug || { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && - test -n "$tmp" && test -d "$tmp" + test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. @@ -7620,7 +7620,7 @@ else ac_cs_awk_cr=$ac_cr fi -echo 'BEGIN {' >"$tmp/subs1.awk" && +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF @@ -7648,7 +7648,7 @@ done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -cat >>"\$tmp/subs1.awk" <<\\_ACAWK && +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h @@ -7696,7 +7696,7 @@ t delim rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK -cat >>"\$tmp/subs1.awk" <<_ACAWK && +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" @@ -7728,7 +7728,7 @@ if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat -fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF @@ -7762,7 +7762,7 @@ fi # test -n "$CONFIG_FILES" # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then -cat >"$tmp/defines.awk" <<\_ACAWK || +cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF @@ -7774,8 +7774,8 @@ _ACEOF # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do - ac_t=`sed -n "/$ac_delim/p" confdefs.h` - if test -z "$ac_t"; then + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 @@ -7876,7 +7876,7 @@ do esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -7895,7 +7895,7 @@ do for ac_f do case $ac_f in - -) ac_f="$tmp/stdin";; + -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. @@ -7904,7 +7904,7 @@ do [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;; + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" @@ -7930,8 +7930,8 @@ $as_echo "$as_me: creating $ac_file" >&6;} esac case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin" \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac @@ -8061,21 +8061,22 @@ s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t $ac_datarootdir_hack " -eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && - { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && - { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} - rm -f "$tmp/stdin" + rm -f "$ac_tmp/stdin" case $ac_file in - -) cat "$tmp/out" && rm -f "$tmp/out";; - *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; @@ -8086,20 +8087,20 @@ which seems to be undefined. Please make sure it is defined" >&2;} if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" - } >"$tmp/config.h" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" - mv "$tmp/config.h" "$ac_file" \ + mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; -- 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 Thu Nov 15 15:20:21 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 15 Nov 2012 15:20:21 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ1El-0002Ib-Eb; Thu, 15 Nov 2012 15:20:15 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZ1Ei-0002Hq-BG for xen-devel@lists.xen.org; Thu, 15 Nov 2012 15:20:14 +0000 Received: from [193.109.254.147:8686] by server-16.bemta-14.messagelabs.com id E1/36-09215-B2805A05; Thu, 15 Nov 2012 15:20:11 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-5.tower-27.messagelabs.com!1352992652!8430483!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UNPARSEABLE_RELAY,UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 29480 invoked from network); 15 Nov 2012 15:17:33 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-5.tower-27.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 15 Nov 2012 15:17:33 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.149187345; Thu, 15 Nov 2012 10:17:21 -0500 From: Matthew Fioravante To: Ian.Campbell@citrix.com, xen-devel@lists.xen.org Date: Thu, 15 Nov 2012 10:17:08 -0500 Message-Id: <1352992629-5850-10-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1352992629-5850-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1352992629-5850-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM v3 09/10] add stubdom/vtpmmgr code 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 Add the code base for vtpmmgrdom. Makefile changes next patch. Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell --- stubdom/vtpmmgr/Makefile | 32 ++ stubdom/vtpmmgr/init.c | 553 +++++++++++++++++++++ stubdom/vtpmmgr/log.c | 151 ++++++ stubdom/vtpmmgr/log.h | 85 ++++ stubdom/vtpmmgr/marshal.h | 528 ++++++++++++++++++++ stubdom/vtpmmgr/minios.cfg | 14 + stubdom/vtpmmgr/tcg.h | 707 +++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.c | 938 ++++++++++++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.h | 218 +++++++++ stubdom/vtpmmgr/tpmrsa.c | 175 +++++++ stubdom/vtpmmgr/tpmrsa.h | 67 +++ stubdom/vtpmmgr/uuid.h | 50 ++ stubdom/vtpmmgr/vtpm_cmd_handler.c | 152 ++++++ stubdom/vtpmmgr/vtpm_manager.h | 64 +++ stubdom/vtpmmgr/vtpm_storage.c | 783 ++++++++++++++++++++++++++++++ stubdom/vtpmmgr/vtpm_storage.h | 68 +++ stubdom/vtpmmgr/vtpmmgr.c | 93 ++++ stubdom/vtpmmgr/vtpmmgr.h | 77 +++ 18 files changed, 4755 insertions(+) create mode 100644 stubdom/vtpmmgr/Makefile create mode 100644 stubdom/vtpmmgr/init.c create mode 100644 stubdom/vtpmmgr/log.c create mode 100644 stubdom/vtpmmgr/log.h create mode 100644 stubdom/vtpmmgr/marshal.h create mode 100644 stubdom/vtpmmgr/minios.cfg create mode 100644 stubdom/vtpmmgr/tcg.h create mode 100644 stubdom/vtpmmgr/tpm.c create mode 100644 stubdom/vtpmmgr/tpm.h create mode 100644 stubdom/vtpmmgr/tpmrsa.c create mode 100644 stubdom/vtpmmgr/tpmrsa.h create mode 100644 stubdom/vtpmmgr/uuid.h create mode 100644 stubdom/vtpmmgr/vtpm_cmd_handler.c create mode 100644 stubdom/vtpmmgr/vtpm_manager.h create mode 100644 stubdom/vtpmmgr/vtpm_storage.c create mode 100644 stubdom/vtpmmgr/vtpm_storage.h create mode 100644 stubdom/vtpmmgr/vtpmmgr.c create mode 100644 stubdom/vtpmmgr/vtpmmgr.h diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile new file mode 100644 index 0000000..88c83c3 --- /dev/null +++ b/stubdom/vtpmmgr/Makefile @@ -0,0 +1,32 @@ +# 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. +# + +XEN_ROOT=../.. + +PSSL_DIR=../polarssl-$(XEN_TARGET_ARCH)/library +PSSL_OBJS=aes.o sha1.o entropy.o ctr_drbg.o bignum.o sha4.o havege.o timing.o entropy_poll.o + +TARGET=vtpmmgr.a +OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o + +CFLAGS+=-Werror -Iutil -Icrypto -Itcs +CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label + +build: $(TARGET) +$(TARGET): $(OBJS) + ar -rcs $@ $^ $(foreach obj,$(PSSL_OBJS),$(PSSL_DIR)/$(obj)) + +clean: + rm -f $(TARGET) $(OBJS) + +distclean: clean + +.PHONY: clean distclean diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c new file mode 100644 index 0000000..a158020 --- /dev/null +++ b/stubdom/vtpmmgr/init.c @@ -0,0 +1,553 @@ +/* + * 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. +*/ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_storage.h" +#include "tpm.h" +#include "marshal.h" + +struct Opts { + enum { + TPMDRV_TPM_TIS, + TPMDRV_TPMFRONT, + } tpmdriver; + unsigned long tpmiomem; + unsigned int tpmirq; + unsigned int tpmlocality; + int gen_owner_auth; +}; + +// --------------------------- Well Known Auths -------------------------- +const TPM_AUTHDATA WELLKNOWN_SRK_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 } +}; + +static int tpm_entropy_source(void* dummy, unsigned char* data, size_t len, size_t* olen) { + UINT32 sz = len; + TPM_RESULT rc = TPM_GetRandom(&sz, data); + *olen = sz; + return rc == TPM_SUCCESS ? 0 : POLARSSL_ERR_ENTROPY_SOURCE_FAILED; +} + +static TPM_RESULT check_tpm_version(void) { + TPM_RESULT status; + UINT32 rsize; + BYTE* res = NULL; + TPM_CAP_VERSION_INFO vinfo; + + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_VERSION_VAL, + 0, + NULL, + &rsize, + &res)); + if(rsize < 4) { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid size returned by GetCapability!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + unpack_TPM_CAP_VERSION_INFO(res, &vinfo, UNPACK_ALIAS); + + vtpmloginfo(VTPM_LOG_VTPM, "Hardware TPM:\n"); + vtpmloginfo(VTPM_LOG_VTPM, " version: %hhd %hhd %hhd %hhd\n", + vinfo.version.major, vinfo.version.minor, vinfo.version.revMajor, vinfo.version.revMinor); + vtpmloginfo(VTPM_LOG_VTPM, " specLevel: %hd\n", vinfo.specLevel); + vtpmloginfo(VTPM_LOG_VTPM, " errataRev: %hhd\n", vinfo.errataRev); + vtpmloginfo(VTPM_LOG_VTPM, " vendorID: %c%c%c%c\n", + vinfo.tpmVendorID[0], vinfo.tpmVendorID[1], + vinfo.tpmVendorID[2], vinfo.tpmVendorID[3]); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecificSize: %hd\n", vinfo.vendorSpecificSize); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecific: "); + for(int i = 0; i < vinfo.vendorSpecificSize; ++i) { + vtpmloginfomore(VTPM_LOG_VTPM, "%02hhx", vinfo.vendorSpecific[i]); + } + vtpmloginfomore(VTPM_LOG_VTPM, "\n"); + +abort_egress: + free(res); + return status; +} + +static TPM_RESULT flush_tpm(void) { + TPM_RESULT status = TPM_SUCCESS; + const TPM_RESOURCE_TYPE reslist[] = { TPM_RT_KEY, TPM_RT_AUTH, TPM_RT_TRANS, TPM_RT_COUNTER, TPM_RT_DAA_TPM, TPM_RT_CONTEXT }; + BYTE* keylist = NULL; + UINT32 keylistSize; + BYTE* ptr; + + //Iterate through each resource type and flush all handles + for(int i = 0; i < sizeof(reslist) / sizeof(TPM_RESOURCE_TYPE); ++i) { + TPM_RESOURCE_TYPE beres = cpu_to_be32(reslist[i]); + UINT16 size; + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_HANDLE, + sizeof(TPM_RESOURCE_TYPE), + (BYTE*)(&beres), + &keylistSize, + &keylist)); + + ptr = keylist; + ptr = unpack_UINT16(ptr, &size); + + //Flush each handle + if(size) { + vtpmloginfo(VTPM_LOG_VTPM, "Flushing %u handle(s) of type %lu\n", size, (unsigned long) reslist[i]); + for(int j = 0; j < size; ++j) { + TPM_HANDLE h; + ptr = unpack_TPM_HANDLE(ptr, &h); + TPMTRYRETURN(TPM_FlushSpecific(h, reslist[i])); + } + } + + free(keylist); + keylist = NULL; + } + + goto egress; +abort_egress: + free(keylist); +egress: + return status; +} + + +static TPM_RESULT try_take_ownership(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_PUBKEY pubEK = TPM_PUBKEY_INIT; + + // If we can read PubEK then there is no owner and we should take it. + status = TPM_ReadPubek(&pubEK); + + switch(status) { + case TPM_DISABLED_CMD: + //Cannot read ek? TPM has owner + vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); + status = TPM_SUCCESS; + break; + case TPM_NO_ENDORSEMENT: + { + //If theres no ek, we have to create one + TPM_KEY_PARMS keyInfo = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }; + TPMTRYRETURN(TPM_CreateEndorsementKeyPair(&keyInfo, &pubEK)); + } + //fall through to take ownership + case TPM_SUCCESS: + { + //Construct the Srk + TPM_KEY srk = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_STORAGE, + .keyFlags = 0x00, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey = { + .keyLength = 0, + .key = NULL, + }, + .encDataSize = 0, + }; + + TPMTRYRETURN(TPM_TakeOwnership( + &pubEK, + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &srk, + NULL, + &vtpm_globals.oiap)); + + TPMTRYRETURN(TPM_DisablePubekRead( + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + &vtpm_globals.oiap)); + } + break; + default: + break; + } +abort_egress: + free_TPM_PUBKEY(&pubEK); + 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) { + 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; + } + /* owner auth is a raw hash */ + else if(!strncmp(authstr, "hash:", 5)) { + authstr += 5; + if((rc = strlen(authstr)) != 40) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth hex string `%s' must be exactly 40 characters (20 bytes) long, length=%d\n", authstr, rc); + return -1; + } + for(int j = 0; j < 20; ++j) { + if(sscanf(authstr, "%hhX", target + j) != 1) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth string `%s' is not a valid hex string\n", authstr); + return -1; + } + authstr += 2; + } + } + /* owner auth is a string that will be hashed */ + else if(!strncmp(authstr, "text:", 5)) { + authstr += 5; + sha1((const unsigned char*)authstr, strlen(authstr), target); + } + else { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid auth string %s\n", authstr); + return -1; + } + + return 0; +} + +int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) +{ + int rc; + 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)); + + 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) { + goto err_invalid; + } + if(rc == 1) { + opts->gen_owner_auth = 1; + } + } + 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) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmdriver=", 10)) { + if(!strcmp(argv[i] + 10, "tpm_tis")) { + opts->tpmdriver = TPMDRV_TPM_TIS; + } else if(!strcmp(argv[i] + 10, "tpmfront")) { + opts->tpmdriver = TPMDRV_TPMFRONT; + } else { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmiomem=",9)) { + if(sscanf(argv[i] + 9, "0x%lX", &opts->tpmiomem) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmirq=",7)) { + if(!strcmp(argv[i] + 7, "probe")) { + opts->tpmirq = TPM_PROBE_IRQ; + } else if( sscanf(argv[i] + 7, "%u", &opts->tpmirq) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmlocality=",12)) { + if(sscanf(argv[i] + 12, "%u", &opts->tpmlocality) != 1 || opts->tpmlocality > 4) { + goto err_invalid; + } + } + } + + switch(opts->tpmdriver) { + case TPMDRV_TPM_TIS: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpm_tis driver\n"); + break; + case TPMDRV_TPMFRONT: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpmfront driver\n"); + break; + } + + return 0; +err_invalid: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid Option %s\n", argv[i]); + return -1; +} + + + +static TPM_RESULT vtpmmgr_create(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + + // Take ownership if TPM is unowned + 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, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &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()); + + goto egress; +abort_egress: +egress: + vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager\n"); + + //End the OSAP session + if(osap.AuthHandle) { + TPM_TerminateHandle(osap.AuthHandle); + } + + return status; +} + +TPM_RESULT vtpmmgr_init(int argc, char** argv) { + TPM_RESULT status = TPM_SUCCESS; + + /* Default commandline options */ + struct Opts opts = { + .tpmdriver = TPMDRV_TPM_TIS, + .tpmiomem = TPM_BASEADDR, + .tpmirq = 0, + .tpmlocality = 0, + .gen_owner_auth = 0, + }; + + if(parse_cmdline_opts(argc, argv, &opts) != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Command line parsing failed! exiting..\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + //Setup storage system + if(vtpm_storage_init() != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize storage subsystem!\n"); + status = TPM_IOERROR; + goto abort_egress; + } + + //Setup tpmback device + init_tpmback(); + + //Setup tpm access + switch(opts.tpmdriver) { + case TPMDRV_TPM_TIS: + { + struct tpm_chip* tpm; + if((tpm = init_tpm_tis(opts.tpmiomem, TPM_TIS_LOCL_INT_TO_FLAG(opts.tpmlocality), opts.tpmirq)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpm_tis_open(tpm); + tpm_tis_request_locality(tpm, opts.tpmlocality); + } + break; + case TPMDRV_TPMFRONT: + { + struct tpmfront_dev* tpmfront_dev; + if((tpmfront_dev = init_tpmfront(NULL)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpmfront_open(tpmfront_dev); + } + break; + } + + //Get the version of the tpm + TPMTRYRETURN(check_tpm_version()); + + // Blow away all stale handles left in the tpm + if(flush_tpm() != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_FlushResources failed, continuing anyway..\n"); + } + + /* Initialize the rng */ + entropy_init(&vtpm_globals.entropy); + entropy_add_source(&vtpm_globals.entropy, tpm_entropy_source, NULL, 0); + entropy_gather(&vtpm_globals.entropy); + ctr_drbg_init(&vtpm_globals.ctr_drbg, entropy_func, &vtpm_globals.entropy, NULL, 0); + ctr_drbg_set_prediction_resistance( &vtpm_globals.ctr_drbg, CTR_DRBG_PR_OFF ); + + // Generate Auth for Owner + if(opts.gen_owner_auth) { + vtpmmgr_rand(vtpm_globals.owner_auth, sizeof(TPM_AUTHDATA)); + } + + // Create OIAP session for service's authorized commands + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); + + /* Load the Manager data, if it fails create a new manager */ + if (vtpm_storage_load_header() != TPM_SUCCESS) { + /* 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) ); + } + vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); + TPMTRYRETURN( vtpmmgr_create() ); + } + + goto egress; +abort_egress: + vtpmmgr_shutdown(); +egress: + return status; +} + +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); + + vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); +} diff --git a/stubdom/vtpmmgr/log.c b/stubdom/vtpmmgr/log.c new file mode 100644 index 0000000..a82c913 --- /dev/null +++ b/stubdom/vtpmmgr/log.c @@ -0,0 +1,151 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "tcg.h" + +char *module_names[] = { "", + "TPM", + "TPM", + "VTPM", + "VTPM", + "TXDATA", + }; +// Helper code for the consts, eg. to produce messages for error codes. + +typedef struct error_code_entry_t { + TPM_RESULT code; + char * code_name; + char * msg; +} error_code_entry_t; + +static const error_code_entry_t error_msgs [] = { + { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, + { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, + { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, + { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, + { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, + { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, + { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, + { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, + { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, + { TPM_FAIL, "TPM_FAIL", "The operation failed" }, + { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, + { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, + { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, + { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, + { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, + { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, + { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, + { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, + { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, + { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, + { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, + { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, + { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, + { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, + { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, + { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, + { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, + { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, + { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, + { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, + { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, + { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, + { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, + { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, + { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, + { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, + { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, + { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, + { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, + { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, + { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, + + { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, + { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, + { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, + { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, + { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, + { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, + { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, + { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, + { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, + { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, + { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, + { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, + { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, + { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, + { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, + { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, + { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, + { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, + { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, + { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, + { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, + { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, + { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, + { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, + { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, + { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, + { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, + { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, + { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, + { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, + { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, + { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, + { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, + { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, + { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, + { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, + { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, + { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, +}; + + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code) { + // just do a linear scan for now + unsigned i; + for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) + if (code == error_msgs[i].code) + return error_msgs[i].code_name; + + return("Unknown Error Code"); +} diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h new file mode 100644 index 0000000..5c7abf5 --- /dev/null +++ b/stubdom/vtpmmgr/log.h @@ -0,0 +1,85 @@ +/* + * 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_LOG_H__ +#define __VTPM_LOG_H__ + +#include // for uint32_t +#include // for pointer NULL +#include +#include "tcg.h" + +// =========================== LOGGING ============================== + +// the logging module numbers +#define VTPM_LOG_TPM 1 +#define VTPM_LOG_TPM_DEEP 2 +#define VTPM_LOG_VTPM 3 +#define VTPM_LOG_VTPM_DEEP 4 +#define VTPM_LOG_TXDATA 5 + +extern char *module_names[]; + +// Default to standard logging +#ifndef LOGGING_MODULES +#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)|BITMASK(VTPM_LOG_TPM)) +#endif + +// bit-access macros +#define BITMASK(idx) ( 1U << (idx) ) +#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) +#define SETBIT(num,idx) (num) |= BITMASK(idx) +#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) + +#define vtpmloginfo(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + } + +#define vtpmloginfomore(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, fmt,##args); \ + } + +#define vtpmlogerror(module, fmt, args...) \ + fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + +//typedef UINT32 tpm_size_t; + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code); + +#endif // _VTPM_LOG_H_ diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h new file mode 100644 index 0000000..77d32f0 --- /dev/null +++ b/stubdom/vtpmmgr/marshal.h @@ -0,0 +1,528 @@ +/* + * 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 MARSHAL_H +#define MARSHAL_H + +#include +#include +#include +#include "tcg.h" + +typedef enum UnpackPtr { + UNPACK_ALIAS, + UNPACK_ALLOC +} UnpackPtr; + +inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { + ptr[0] = t; + return ++ptr; +} + +inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { + t[0] = ptr[0]; + return ++ptr; +} + +#define pack_BOOL(p, t) pack_BYTE(p, t) +#define unpack_BOOL(p, t) unpack_BYTE(p, t) + +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* 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); +} + +#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) +#define pack_TPM_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TPM_AUTHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HASHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HMACHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENCHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_KEY_HANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENTITYHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_RESOURCE_TYPE(p, t) pack_UINT32(p, t) +#define pack_TPM_COMMAND_CODE(p, t) pack_UINT32(p, t) +#define pack_TPM_PROTOCOL_ID(p, t) pack_UINT16(p, t) +#define pack_TPM_AUTH_DATA_USAGE(p, t) pack_BYTE(p, t) +#define pack_TPM_ENTITY_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_ALGORITHM_ID(p, t) pack_UINT32(p, t) +#define pack_TPM_KEY_USAGE(p, t) pack_UINT16(p, t) +#define pack_TPM_STARTUP_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_CAPABILITY_AREA(p, t) pack_UINT32(p, t) +#define pack_TPM_ENC_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_SIG_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t) +#define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t) + +#define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_DIRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_AUTHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HASHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HMACHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENCHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_KEY_HANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENTITYHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_RESOURCE_TYPE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_COMMAND_CODE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PROTOCOL_ID(p, t) unpack_UINT16(p, t) +#define unpack_TPM_AUTH_DATA_USAGE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_ENTITY_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_ALGORITHM_ID(p, t) unpack_UINT32(p, t) +#define unpack_TPM_KEY_USAGE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STARTUP_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_CAPABILITY_AREA(p, t) unpack_UINT32(p, t) +#define unpack_TPM_ENC_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_SIG_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, 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 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; +} + +inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { + memcpy(buf, ptr, size); + return ptr + size; +} + +inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 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; +} + +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); + } +} + +inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { + 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); +} + +#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) +#define pack_TPM_TAG(p, t) pack_UINT16(p, t) +#define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) + +#define unpack_TPM_SECRET(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, 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; +} + +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; +} + +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; +} + +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; +} + +inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { + 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); +} + +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_PCRVALUE(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 pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_DIRVALUE(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); +} + +inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { + return unpack_BUFFER(ptr, 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); +} + +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 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); +} + +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 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; +} + +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; +} + +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 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); +} + +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 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; +} + +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; +} + +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; +} + +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 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; +} + +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 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); +} + +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); +} + +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); +} + +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; +} + +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; +} + +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; +} + +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; +} + +#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); + +#endif diff --git a/stubdom/vtpmmgr/minios.cfg b/stubdom/vtpmmgr/minios.cfg new file mode 100644 index 0000000..3fb383d --- /dev/null +++ b/stubdom/vtpmmgr/minios.cfg @@ -0,0 +1,14 @@ +CONFIG_TPMFRONT=y +CONFIG_TPM_TIS=y +CONFIG_TPMBACK=y +CONFIG_START_NETWORK=n +CONFIG_TEST=n +CONFIG_PCIFRONT=n +CONFIG_BLKFRONT=y +CONFIG_NETFRONT=n +CONFIG_FBFRONT=n +CONFIG_KBDFRONT=n +CONFIG_CONSFRONT=n +CONFIG_XENBUS=y +CONFIG_LWIP=n +CONFIG_XC=n diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h new file mode 100644 index 0000000..7687eae --- /dev/null +++ b/stubdom/vtpmmgr/tcg.h @@ -0,0 +1,707 @@ +/* + * 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 __TCG_H__ +#define __TCG_H__ + +#include +#include + +// **************************** CONSTANTS ********************************* + +// BOOL values +#define TRUE 0x01 +#define FALSE 0x00 + +#define TCPA_MAX_BUFFER_LENGTH 0x2000 + +// +// TPM_COMMAND_CODE values +#define TPM_PROTECTED_ORDINAL 0x00000000UL +#define TPM_UNPROTECTED_ORDINAL 0x80000000UL +#define TPM_CONNECTION_ORDINAL 0x40000000UL +#define TPM_VENDOR_ORDINAL 0x20000000UL + +#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveContext (184UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadContext (185UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FlushSpecific (186UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PCR_Reset (200UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_DefineSpace (204UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValue (205UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValueAuth (206UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValue (207UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValueAuth (208UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_UpdateVerification (209UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_Manage (210UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateKeyDelegation (212UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateOwnerDelegation (213UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_VerifyDelegation (214UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_LoadOwnerDelegation (216UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadAuth (217UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadTable (219UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateCounter (220UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_IncrementCounter (221UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadCounter (222UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounter (223UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounterOwner (224UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EstablishTransport (230UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ExecuteTransport (231UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseTransportSigned (232UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTicks (241UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TickStampBlob (242UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MAX (256UL + TPM_PROTECTED_ORDINAL) + +#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) + + + +// +// TPM_RESULT values +// +// just put in the whole table from spec 1.2 + +#define TPM_BASE 0x0 // The start of TPM return codes +#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands +#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. + +#define TPM_SUCCESS TPM_BASE // Successful completion of the operation +#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed +#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect +#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad +#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. +#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access +#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated +#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled +#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled +#define TPM_FAIL TPM_BASE + 9 // The operation failed +#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent +#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled +#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid +#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found +#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme +#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed +#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted +#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. +#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set +#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM +#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner +#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. +#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short +#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. +#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. +#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value +#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. +#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. +#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. +#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization +#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid +#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM +#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. +#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. +#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. +#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed +#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed +#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed +#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup +#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information +#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM + +#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. +#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. +#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key +#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. +#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value +#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability +#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions +#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also +#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success +#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute +#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport +#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed +#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource +#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode +#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID +#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available +#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command +#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key +#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization +#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable +#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation +#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to +#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area +#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match +#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to +#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict +#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent +#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. +#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect +#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area +#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large +#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded +#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set +#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded +#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked +#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family +#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled +#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session + +// TPM_STARTUP_TYPE values +#define TPM_ST_CLEAR 0x0001 +#define TPM_ST_STATE 0x0002 +#define TPM_ST_DEACTIVATED 0x003 + +// TPM_TAG values +#define TPM_TAG_RQU_COMMAND 0x00c1 +#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 +#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 +#define TPM_TAG_RSP_COMMAND 0x00c4 +#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 +#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 + +// TPM_PAYLOAD_TYPE values +#define TPM_PT_ASYM 0x01 +#define TPM_PT_BIND 0x02 +#define TPM_PT_MIGRATE 0x03 +#define TPM_PT_MAINT 0x04 +#define TPM_PT_SEAL 0x05 + +// TPM_ENTITY_TYPE values +#define TPM_ET_KEYHANDLE 0x0001 +#define TPM_ET_OWNER 0x0002 +#define TPM_ET_DATA 0x0003 +#define TPM_ET_SRK 0x0004 +#define TPM_ET_KEY 0x0005 + +/// TPM_ResourceTypes +#define TPM_RT_KEY 0x00000001 +#define TPM_RT_AUTH 0x00000002 +#define TPM_RT_HASH 0x00000003 +#define TPM_RT_TRANS 0x00000004 +#define TPM_RT_CONTEXT 0x00000005 +#define TPM_RT_COUNTER 0x00000006 +#define TPM_RT_DELEGATE 0x00000007 +#define TPM_RT_DAA_TPM 0x00000008 +#define TPM_RT_DAA_V0 0x00000009 +#define TPM_RT_DAA_V1 0x0000000A + + + +// TPM_PROTOCOL_ID values +#define TPM_PID_OIAP 0x0001 +#define TPM_PID_OSAP 0x0002 +#define TPM_PID_ADIP 0x0003 +#define TPM_PID_ADCP 0x0004 +#define TPM_PID_OWNER 0x0005 + +// TPM_ALGORITHM_ID values +#define TPM_ALG_RSA 0x00000001 +#define TPM_ALG_SHA 0x00000004 +#define TPM_ALG_HMAC 0x00000005 +#define TPM_ALG_AES128 0x00000006 +#define TPM_ALG_MFG1 0x00000007 +#define TPM_ALG_AES192 0x00000008 +#define TPM_ALG_AES256 0x00000009 +#define TPM_ALG_XOR 0x0000000A + +// TPM_ENC_SCHEME values +#define TPM_ES_NONE 0x0001 +#define TPM_ES_RSAESPKCSv15 0x0002 +#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 + +// TPM_SIG_SCHEME values +#define TPM_SS_NONE 0x0001 +#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 +#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 + +/* + * TPM_CAPABILITY_AREA Values for TPM_GetCapability ([TPM_Part2], Section 21.1) + */ +#define TPM_CAP_ORD 0x00000001 +#define TPM_CAP_ALG 0x00000002 +#define TPM_CAP_PID 0x00000003 +#define TPM_CAP_FLAG 0x00000004 +#define TPM_CAP_PROPERTY 0x00000005 +#define TPM_CAP_VERSION 0x00000006 +#define TPM_CAP_KEY_HANDLE 0x00000007 +#define TPM_CAP_CHECK_LOADED 0x00000008 +#define TPM_CAP_SYM_MODE 0x00000009 +#define TPM_CAP_KEY_STATUS 0x0000000C +#define TPM_CAP_NV_LIST 0x0000000D +#define TPM_CAP_MFR 0x00000010 +#define TPM_CAP_NV_INDEX 0x00000011 +#define TPM_CAP_TRANS_ALG 0x00000012 +#define TPM_CAP_HANDLE 0x00000014 +#define TPM_CAP_TRANS_ES 0x00000015 +#define TPM_CAP_AUTH_ENCRYPT 0x00000017 +#define TPM_CAP_SELECT_SIZE 0x00000018 +#define TPM_CAP_DA_LOGIC 0x00000019 +#define TPM_CAP_VERSION_VAL 0x0000001A + +/* subCap definitions ([TPM_Part2], Section 21.2) */ +#define TPM_CAP_PROP_PCR 0x00000101 +#define TPM_CAP_PROP_DIR 0x00000102 +#define TPM_CAP_PROP_MANUFACTURER 0x00000103 +#define TPM_CAP_PROP_KEYS 0x00000104 +#define TPM_CAP_PROP_MIN_COUNTER 0x00000107 +#define TPM_CAP_FLAG_PERMANENT 0x00000108 +#define TPM_CAP_FLAG_VOLATILE 0x00000109 +#define TPM_CAP_PROP_AUTHSESS 0x0000010A +#define TPM_CAP_PROP_TRANSESS 0x0000010B +#define TPM_CAP_PROP_COUNTERS 0x0000010C +#define TPM_CAP_PROP_MAX_AUTHSESS 0x0000010D +#define TPM_CAP_PROP_MAX_TRANSESS 0x0000010E +#define TPM_CAP_PROP_MAX_COUNTERS 0x0000010F +#define TPM_CAP_PROP_MAX_KEYS 0x00000110 +#define TPM_CAP_PROP_OWNER 0x00000111 +#define TPM_CAP_PROP_CONTEXT 0x00000112 +#define TPM_CAP_PROP_MAX_CONTEXT 0x00000113 +#define TPM_CAP_PROP_FAMILYROWS 0x00000114 +#define TPM_CAP_PROP_TIS_TIMEOUT 0x00000115 +#define TPM_CAP_PROP_STARTUP_EFFECT 0x00000116 +#define TPM_CAP_PROP_DELEGATE_ROW 0x00000117 +#define TPM_CAP_PROP_MAX_DAASESS 0x00000119 +#define TPM_CAP_PROP_DAASESS 0x0000011A +#define TPM_CAP_PROP_CONTEXT_DIST 0x0000011B +#define TPM_CAP_PROP_DAA_INTERRUPT 0x0000011C +#define TPM_CAP_PROP_SESSIONS 0x0000011D +#define TPM_CAP_PROP_MAX_SESSIONS 0x0000011E +#define TPM_CAP_PROP_CMK_RESTRICTION 0x0000011F +#define TPM_CAP_PROP_DURATION 0x00000120 +#define TPM_CAP_PROP_ACTIVE_COUNTER 0x00000122 +#define TPM_CAP_PROP_MAX_NV_AVAILABLE 0x00000123 +#define TPM_CAP_PROP_INPUT_BUFFER 0x00000124 + +// TPM_KEY_USAGE values +#define TPM_KEY_EK 0x0000 +#define TPM_KEY_SIGNING 0x0010 +#define TPM_KEY_STORAGE 0x0011 +#define TPM_KEY_IDENTITY 0x0012 +#define TPM_KEY_AUTHCHANGE 0X0013 +#define TPM_KEY_BIND 0x0014 +#define TPM_KEY_LEGACY 0x0015 + +// TPM_AUTH_DATA_USAGE values +#define TPM_AUTH_NEVER 0x00 +#define TPM_AUTH_ALWAYS 0x01 + +// Key Handle of owner and srk +#define TPM_OWNER_KEYHANDLE 0x40000001 +#define TPM_SRK_KEYHANDLE 0x40000000 + + + +// *************************** TYPEDEFS ********************************* +typedef unsigned char BYTE; +typedef unsigned char BOOL; +typedef uint16_t UINT16; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef UINT32 TPM_RESULT; +typedef UINT32 TPM_PCRINDEX; +typedef UINT32 TPM_DIRINDEX; +typedef UINT32 TPM_HANDLE; +typedef TPM_HANDLE TPM_AUTHHANDLE; +typedef TPM_HANDLE TCPA_HASHHANDLE; +typedef TPM_HANDLE TCPA_HMACHANDLE; +typedef TPM_HANDLE TCPA_ENCHANDLE; +typedef TPM_HANDLE TPM_KEY_HANDLE; +typedef TPM_HANDLE TCPA_ENTITYHANDLE; +typedef UINT32 TPM_RESOURCE_TYPE; +typedef UINT32 TPM_COMMAND_CODE; +typedef UINT16 TPM_PROTOCOL_ID; +typedef BYTE TPM_AUTH_DATA_USAGE; +typedef UINT16 TPM_ENTITY_TYPE; +typedef UINT32 TPM_ALGORITHM_ID; +typedef UINT16 TPM_KEY_USAGE; +typedef UINT16 TPM_STARTUP_TYPE; +typedef UINT32 TPM_CAPABILITY_AREA; +typedef UINT16 TPM_ENC_SCHEME; +typedef UINT16 TPM_SIG_SCHEME; +typedef UINT16 TPM_MIGRATE_SCHEME; +typedef UINT16 TPM_PHYSICAL_PRESENCE; +typedef UINT32 TPM_KEY_FLAGS; + +#define TPM_DIGEST_SIZE 20 // Don't change this +typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; +typedef TPM_AUTHDATA TPM_SECRET; +typedef TPM_AUTHDATA TPM_ENCAUTH; +typedef BYTE TPM_PAYLOAD_TYPE; +typedef UINT16 TPM_TAG; +typedef UINT16 TPM_STRUCTURE_TAG; + +// Data Types of the TCS +typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session +typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle +typedef UINT32 TCS_KEY_HANDLE; // Basic key handle + +// ************************* STRUCTURES ********************************** + +typedef struct TPM_VERSION { + BYTE major; + BYTE minor; + BYTE revMajor; + BYTE revMinor; +} TPM_VERSION; + +static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; + +typedef struct TPM_CAP_VERSION_INFO { + TPM_STRUCTURE_TAG tag; + TPM_VERSION version; + UINT16 specLevel; + BYTE errataRev; + BYTE tpmVendorID[4]; + UINT16 vendorSpecificSize; + BYTE* vendorSpecific; +} TPM_CAP_VERSION_INFO; + +inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { + free(v->vendorSpecific); + v->vendorSpecific = NULL; +} + +typedef struct TPM_DIGEST { + BYTE digest[TPM_DIGEST_SIZE]; +} TPM_DIGEST; + +typedef TPM_DIGEST TPM_PCRVALUE; +typedef TPM_DIGEST TPM_COMPOSITE_HASH; +typedef TPM_DIGEST TPM_DIRVALUE; +typedef TPM_DIGEST TPM_HMAC; +typedef TPM_DIGEST TPM_CHOSENID_HASH; + +typedef struct TPM_NONCE { + BYTE nonce[TPM_DIGEST_SIZE]; +} TPM_NONCE; + +typedef struct TPM_SYMMETRIC_KEY_PARMS { + UINT32 keyLength; + UINT32 blockSize; + UINT32 ivSize; + BYTE* IV; +} TPM_SYMMETRIC_KEY_PARMS; + +inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { + free(p->IV); + p->IV = NULL; +} + +#define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } + +typedef struct TPM_RSA_KEY_PARMS { + UINT32 keyLength; + UINT32 numPrimes; + UINT32 exponentSize; + BYTE* exponent; +} TPM_RSA_KEY_PARMS; + +#define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } + +inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { + free(p->exponent); + p->exponent = NULL; +} + +typedef struct TPM_KEY_PARMS { + TPM_ALGORITHM_ID algorithmID; + TPM_ENC_SCHEME encScheme; + TPM_SIG_SCHEME sigScheme; + UINT32 parmSize; + union { + TPM_SYMMETRIC_KEY_PARMS sym; + TPM_RSA_KEY_PARMS rsa; + } parms; +} TPM_KEY_PARMS; + +#define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } + +inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { + if(p->parmSize) { + switch(p->algorithmID) { + case TPM_ALG_RSA: + free_TPM_RSA_KEY_PARMS(&p->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); + break; + } + } +} + +typedef struct TPM_STORE_PUBKEY { + UINT32 keyLength; + BYTE* key; +} TPM_STORE_PUBKEY; + +#define TPM_STORE_PUBKEY_INIT { 0, NULL } + +inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { + free(p->key); + p->key = NULL; +} + +typedef struct TPM_PUBKEY { + TPM_KEY_PARMS algorithmParms; + TPM_STORE_PUBKEY pubKey; +} TPM_PUBKEY; + +#define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } + +inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { + free_TPM_KEY_PARMS(&k->algorithmParms); + free_TPM_STORE_PUBKEY(&k->pubKey); +} + +typedef struct TPM_PCR_SELECTION { + UINT16 sizeOfSelect; + BYTE* pcrSelect; +} TPM_PCR_SELECTION; + +#define TPM_PCR_SELECTION_INIT { 0, NULL } + +inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { + free(p->pcrSelect); + p->pcrSelect = NULL; +} + +typedef struct TPM_PCR_INFO { + TPM_PCR_SELECTION pcrSelection; + TPM_COMPOSITE_HASH digestAtRelease; + TPM_COMPOSITE_HASH digestAtCreation; +} TPM_PCR_INFO; + +#define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } + +inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { + free_TPM_PCR_SELECTION(&p->pcrSelection); +} + +typedef struct TPM_PCR_COMPOSITE { + TPM_PCR_SELECTION select; + UINT32 valueSize; + TPM_PCRVALUE* pcrValue; +} TPM_PCR_COMPOSITE; + +#define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } + +inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { + free_TPM_PCR_SELECTION(&p->select); + free(p->pcrValue); + p->pcrValue = NULL; +} + +typedef struct TPM_KEY { + TPM_VERSION ver; + TPM_KEY_USAGE keyUsage; + TPM_KEY_FLAGS keyFlags; + TPM_AUTH_DATA_USAGE authDataUsage; + TPM_KEY_PARMS algorithmParms; + UINT32 PCRInfoSize; + TPM_PCR_INFO PCRInfo; + TPM_STORE_PUBKEY pubKey; + UINT32 encDataSize; + BYTE* encData; +} TPM_KEY; + +#define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\ + .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \ + .pubKey = TPM_STORE_PUBKEY_INIT, \ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_KEY(TPM_KEY* k) { + if(k->PCRInfoSize) { + free_TPM_PCR_INFO(&k->PCRInfo); + } + free_TPM_STORE_PUBKEY(&k->pubKey); + free(k->encData); + k->encData = NULL; +} + +typedef struct TPM_BOUND_DATA { + TPM_VERSION ver; + TPM_PAYLOAD_TYPE payload; + BYTE* payloadData; +} TPM_BOUND_DATA; + +#define TPM_BOUND_DATA_INIT { .payloadData = NULL } + +inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { + free(d->payloadData); + d->payloadData = NULL; +} + +typedef struct TPM_STORED_DATA { + TPM_VERSION ver; + UINT32 sealInfoSize; + TPM_PCR_INFO sealInfo; + UINT32 encDataSize; + BYTE* encData; +} TPM_STORED_DATA; + +#define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { + if(d->sealInfoSize) { + free_TPM_PCR_INFO(&d->sealInfo); + } + free(d->encData); + d->encData = NULL; +} + +typedef struct TPM_AUTH_SESSION { + TPM_AUTHHANDLE AuthHandle; + TPM_NONCE NonceOdd; // system + TPM_NONCE NonceEven; // TPM + BOOL fContinueAuthSession; + TPM_AUTHDATA HMAC; +} TPM_AUTH_SESSION; + +#define TPM_AUTH_SESSION_INIT { .AuthHandle = 0, .fContinueAuthSession = FALSE } + +// ---------------------- Functions for checking TPM_RESULTs ----------------- + +#include + +// FIXME: Review use of these and delete unneeded ones. + +// these are really badly dependent on local structure: +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +#define ERRORDIE(s) do { status = s; \ + fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ + goto abort_egress; } \ + while (0) + +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +// Try command c. If it fails, set status to s and goto abort. +#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ + status = s; \ + printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } else {\ + status = c; \ + } + +// Try command c. If it fails, print error message, set status to actual return code. Goto abort +#define TPMTRYRETURN(c) do { status = c; \ + if (status != TPM_SUCCESS) { \ + fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } \ + } while(0) + + +#endif //__TCPA_H__ diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c new file mode 100644 index 0000000..123a27c --- /dev/null +++ b/stubdom/vtpmmgr/tpm.c @@ -0,0 +1,938 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include + +#include + +#include "tcg.h" +#include "tpm.h" +#include "log.h" +#include "marshal.h" +#include "tpmrsa.h" +#include "vtpmmgr.h" + +#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_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;\ + }\ +} 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]; + } + } + +} + +static void generateAuth(const TPM_DIGEST* paramDigest, + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) +{ + //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; + + 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); +} + +static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, + /*[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; + } +} + + + +// ------------------------------------------------------------------ +// Authorization Commands +// ------------------------------------------------------------------ + +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; + + ptr = unpack_UINT32(ptr, &auth->AuthHandle); + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + +abort_egress: + 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) +{ + BYTE* nonceOddOSAP; + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + + ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); + ptr = pack_UINT32(ptr, entityValue); + + //nonce Odd OSAP + nonceOddOSAP = ptr; + vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); + ptr += TPM_DIGEST_SIZE; + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + 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, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); + + 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); + +abort_egress: + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(outSrk); + } +egress: + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_DisablePubekRead ( + 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_AUTH1_GEN(ownerAuth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + TPM_AUTH1_VERIFY(ownerAuth, auth); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in +{ + if(handle == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + + ptr = pack_TPM_AUTHHANDLE(ptr, handle); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + +abort_egress: + return status; +} + +TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in + TPM_DIGEST inDigest, // in + TPM_PCRVALUE* outDigest) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + + ptr = pack_TPM_PCRINDEX(ptr, pcrNum); + ptr = pack_TPM_DIGEST(ptr, &inDigest); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + +abort_egress: + 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 + ) +{ + 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); + + ptr = pack_UINT32(ptr, pcrInfoSize); + ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); + + ptr = pack_UINT32(ptr, inDataSize); + ptr = pack_BUFFER(ptr, inData, inDataSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(osapSharedSecret, pubAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); + dataAlloced = 1; + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + + goto egress; +abort_egress: + if(dataAlloced) { + free_TPM_STORED_DATA(sealedData); + } +egress: + TPM_AUTH_ERR_CHECK(pubAuth); + 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_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_TPM_STORED_DATA(ptr, sealedData); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(key_usage_auth, keyAuth); + TPM_AUTH2_GEN(data_usage_auth, dataAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_UINT32(ptr, outSize); + ptr = unpack_ALLOC(ptr, out, *outSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); + TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + +abort_egress: + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; +} + +TPM_RESULT TPM_Bind( + const TPM_KEY* key, + const BYTE* in, + UINT32 ilen, + BYTE* 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)); + +abort_egress: + tpmrsa_free(&rsa); + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_UINT32(ptr, ilen); + ptr = pack_BUFFER(ptr, in, ilen); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(usage_auth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + 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); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(usage_auth, auth); + +abort_egress: +egress: + TPM_AUTH_ERR_CHECK(auth); + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(key); + } +egress: + TPM_AUTH_ERR_CHECK(pAuth); + 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_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); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + +TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +{ + if(hKey == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + + ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + +abort_egress: + 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(); + +abort_egress: + return status; +} + +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + + // check input params + if (bytesRequested == NULL || randomBytes == NULL){ + return TPM_BAD_PARAMETER; + } + + ptr = pack_UINT32(ptr, *bytesRequested); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, bytesRequested); + ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + +abort_egress: + return status; +} + + +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; +abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } +egress: + return status; +} + + +TPM_RESULT TPM_SaveState(void) +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + +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); + + ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); + ptr = pack_UINT32(ptr, subCapSize); + ptr = pack_BUFFER(ptr, subCap, subCapSize); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, respSize); + ptr = unpack_ALLOC(ptr, resp, *respSize); + +abort_egress: + return status; +} + +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(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + + ptr = pack_TPM_NONCE(ptr, &antiReplay); + ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + sha1_starts(&ctx); + + kptr = ptr; + ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); + + /* Hash the pub key blob */ + sha1_update(&ctx, kptr, ptr - kptr); + ptr = unpack_TPM_DIGEST(ptr, &checksum); + + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + + 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; + } + + goto egress; +abort_egress: + if(kptr) { + free_TPM_PUBKEY(pubEK); + } +egress: + 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; + +abort_egress: +egress: + return status; +} diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h new file mode 100644 index 0000000..304e145 --- /dev/null +++ b/stubdom/vtpmmgr/tpm.h @@ -0,0 +1,218 @@ +/* + * 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/2006, 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 __TPM_H__ +#define __TPM_H__ + +#include "tcg.h" + +// ------------------------------------------------------------------ +// Exposed API +// ------------------------------------------------------------------ + +// TPM v1.1B Command Set + +// Authorzation +TPM_RESULT TPM_OIAP( + TPM_AUTH_SESSION* auth //out + ); + +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); + +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 + ); + +TPM_RESULT TPM_DisablePubekRead ( + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth + ); + +TPM_RESULT TPM_TerminateHandle ( TPM_AUTHHANDLE handle // in + ); + +TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in + TPM_RESOURCE_TYPE resourceType //in + ); + +// TPM Mandatory +TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // 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_Seal( + TCS_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* sealDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ); + +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_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 + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + 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 + ); + +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp); + +TPM_RESULT TPM_SaveState(void); + +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK); + +TPM_RESULT TPM_TransmitData( + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize); + +#endif //TPM_H diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c new file mode 100644 index 0000000..56094e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -0,0 +1,175 @@ +/* + * The RSA public-key cryptosystem + * + * Copyright (C) 2006-2011, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +/* + * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman. + * + * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf + * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf + */ + +#include "tcg.h" +#include "polarssl/sha1.h" + +#include +#include + +#include "tpmrsa.h" + +#define HASH_LEN 20 + +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen) { + + tpmrsa_free(ctx); + + if(explen == 0) { //Default e= 2^16+1 + mpi_lset(&ctx->E, 65537); + } else { + mpi_read_binary(&ctx->E, exponent, explen); + } + mpi_read_binary(&ctx->N, key, keylen); + + ctx->len = ( mpi_msb(&ctx->N) + 7) >> 3; +} + +static TPM_RESULT tpmrsa_public( tpmrsa_context *ctx, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + size_t olen; + mpi T; + + mpi_init( &T ); + + MPI_CHK( mpi_read_binary( &T, input, ctx->len ) ); + + if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 ) + { + mpi_free( &T ); + return TPM_ENCRYPT_ERROR; + } + + olen = ctx->len; + MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) ); + MPI_CHK( mpi_write_binary( &T, output, olen ) ); + +cleanup: + + mpi_free( &T ); + + if( ret != 0 ) + return TPM_ENCRYPT_ERROR; + + return TPM_SUCCESS; +} + +static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) +{ + unsigned char mask[HASH_LEN]; + unsigned char counter[4] = {0, 0, 0, 0}; + int i; + sha1_context mctx; + + //We always hash the src with the counter, so save the partial hash + sha1_starts(&mctx); + sha1_update(&mctx, src, slen); + + // Generate and apply dbMask + while(dlen > 0) { + //Copy the sha1 context + sha1_context ctx = mctx; + + //compute hash for input || counter + sha1_update(&ctx, counter, sizeof(counter)); + sha1_finish(&ctx, mask); + + //Apply the mask + for(i = 0; i < (dlen < HASH_LEN ? dlen : HASH_LEN); ++i) { + *(dst++) ^= mask[i]; + } + + //Increment counter + ++counter[3]; + + dlen -= HASH_LEN; + } +} + +/* + * Add the message padding, then do an RSA operation + */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + int olen; + unsigned char* seed = output + 1; + unsigned char* db = output + HASH_LEN +1; + + olen = ctx->len-1; + + if( f_rng == NULL ) + return TPM_ENCRYPT_ERROR; + + if( ilen > olen - 2 * HASH_LEN - 1) + return TPM_ENCRYPT_ERROR; + + output[0] = 0; + + //Encoding parameter p + sha1((unsigned char*)"TCPA", 4, db); + + //PS + memset(db + HASH_LEN, 0, + olen - ilen - 2 * HASH_LEN - 1); + + //constant 1 byte + db[olen - ilen - HASH_LEN -1] = 0x01; + + //input string + memcpy(db + olen - ilen - HASH_LEN, + input, ilen); + + //Generate random seed + if( ( ret = f_rng( p_rng, seed, HASH_LEN ) ) != 0 ) + return TPM_ENCRYPT_ERROR; + + // maskedDB: Apply dbMask to DB + mgf_mask( db, olen - HASH_LEN, seed, HASH_LEN); + + // maskedSeed: Apply seedMask to seed + mgf_mask( seed, HASH_LEN, db, olen - HASH_LEN); + + // Do the crypto op + return tpmrsa_public(ctx, output, output); +} diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h new file mode 100644 index 0000000..59579e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -0,0 +1,67 @@ +/** + * \file rsa.h + * + * \brief The RSA public-key cryptosystem + * + * Copyright (C) 2006-2010, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef TPMRSA_H +#define TPMRSA_H + +#include "tcg.h" +#include + +/* tpm software key */ +typedef struct +{ + size_t len; /*!< size(N) in chars */ + + mpi N; /*!< public modulus */ + mpi E; /*!< public exponent */ + + mpi RN; /*!< cached R^2 mod N */ +} +tpmrsa_context; + +#define TPMRSA_CTX_INIT { 0, {0, 0, NULL}, {0, 0, NULL}, {0, 0, NULL}} + +/* Setup the rsa context using tpm public key data */ +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen); + +/* Do rsa public crypto */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ); + +/* free tpmrsa key */ +inline void tpmrsa_free( tpmrsa_context *ctx ) { + mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); +} + +#endif /* tpmrsa.h */ diff --git a/stubdom/vtpmmgr/uuid.h b/stubdom/vtpmmgr/uuid.h new file mode 100644 index 0000000..4737645 --- /dev/null +++ b/stubdom/vtpmmgr/uuid.h @@ -0,0 +1,50 @@ +/* + * 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 VTPMMGR_UUID_H +#define VTPMMGR_UUID_H + +#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx" +#define UUID_FMTLEN ((2*16)+4) /* 16 hex bytes plus 4 hypens */ +#define UUID_BYTES(uuid) uuid[0], uuid[1], uuid[2], uuid[3], \ + uuid[4], uuid[5], uuid[6], uuid[7], \ + uuid[8], uuid[9], uuid[10], uuid[11], \ + uuid[12], uuid[13], uuid[14], uuid[15] + + +typedef uint8_t uuid_t[16]; + +#endif diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c new file mode 100644 index 0000000..f82a2a9 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -0,0 +1,152 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "marshal.h" +#include "log.h" +#include "vtpm_storage.h" +#include "vtpmmgr.h" +#include "tpm.h" +#include "tcg.h" + +static TPM_RESULT vtpmmgr_SaveHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + + 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; + } + + /* Do the command */ + TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + return status; +} + +static TPM_RESULT vtpmmgr_LoadHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) { + TPM_RESULT status = TPM_SUCCESS; + + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + + tpmcmd->resp_len += HASHKEYSZ; + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + + +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; + } + +abort_egress: + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, + tag + 3, tpmcmd->resp_len, status); + + return status; +} diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h new file mode 100644 index 0000000..a2bbcca --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -0,0 +1,64 @@ +/* + * 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_MANAGER_H +#define VTPM_MANAGER_H + +#define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_RSP 0x01c4 +#define COMMAND_BUFFER_SIZE 4096 + +// Header size +#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) + +//************************ 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) + +// 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 +#define VTPM_FAIL 1 +#define VTPM_UNSUPPORTED 2 +#define VTPM_FORBIDDEN 3 +#define VTPM_RESTORE_CONTEXT_FAILED 4 +#define VTPM_INVALID_REQUEST 5 + +#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c new file mode 100644 index 0000000..3862fdb --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.c @@ -0,0 +1,783 @@ +/* + * 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 Boot Key + * BYTEARRAY storage_key TPM boot key + * + * ************************************************************* + * Section 2: Key Data Table (starts at offset 4096) + * + * This is a list of blocks, each is RSA_CIPHER_SIZE long + * and is encrypted with the storage key. + * + * The first block always exists and it contains: + * uint32_t num_vtpms Number of vtpms (number of remaining blocks) + * + * The rest of the blocks look like this: + * 16 bytes uuid uuid of the owner of this key and hash + * 20 bytes hash Sha1 hash of vTPM's data, supplied by vTPM + * 32 bytes key AES-256 Encryption Key, supplied by vTPM + * + * ************************************************************* + */ +#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 (%ld)\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 new file mode 100644 index 0000000..a5a5fd7 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.h @@ -0,0 +1,68 @@ +/* + * 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.c b/stubdom/vtpmmgr/vtpmmgr.c new file mode 100644 index 0000000..563f4e8 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.c @@ -0,0 +1,93 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include +#include +#include "log.h" + +#include "vtpmmgr.h" +#include "tcg.h" + + +void main_loop(void) { + tpmcmd_t* tpmcmd; + uint8_t respbuf[TCPA_MAX_BUFFER_LENGTH]; + + while(1) { + /* Wait for requests from a vtpm */ + vtpmloginfo(VTPM_LOG_VTPM, "Waiting for commands from vTPM's:\n"); + if((tpmcmd = tpmback_req_any()) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "NULL tpmcmd\n"); + continue; + } + + tpmcmd->resp = respbuf; + + /* Process the command */ + vtpmmgr_handle_cmd(tpmcmd->uuid, tpmcmd); + + /* Send response */ + tpmback_resp(tpmcmd); + } +} + +int main(int argc, char** argv) +{ + int rc = 0; + sleep(2); + vtpmloginfo(VTPM_LOG_VTPM, "Starting vTPM manager domain\n"); + + /* Initialize the vtpm manager */ + if(vtpmmgr_init(argc, argv) != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize vtpmmgr domain!\n"); + rc = -1; + goto exit; + } + + main_loop(); + + vtpmloginfo(VTPM_LOG_VTPM, "vTPM Manager shutting down...\n"); + + vtpmmgr_shutdown(); + +exit: + return rc; + +} diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h new file mode 100644 index 0000000..50a1992 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -0,0 +1,77 @@ +/* + * 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 VTPMMGR_H +#define VTPMMGR_H + +#include +#include +#include + +#include "uuid.h" +#include "tcg.h" +#include "vtpm_manager.h" + +#define RSA_KEY_SIZE 0x0800 +#define RSA_CIPHER_SIZE (RSA_KEY_SIZE / 8) + +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; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; +}; + +// --------------------------- 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); + +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; +} + +#endif -- 1.7.10.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-users-bounces@lists.xen.org Fri Nov 16 12:46:50 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 16 Nov 2012 12:46:50 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZLIb-0001YY-Cu; Fri, 16 Nov 2012 12:45:33 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TZLIZ-0001YS-Mh for xen-users@lists.xen.org; Fri, 16 Nov 2012 12:45:32 +0000 Received: from [85.158.137.99:36156] by server-11.bemta-3.messagelabs.com id 90/9C-19361-66536A05; Fri, 16 Nov 2012 12:45:26 +0000 X-Env-Sender: sam@tacomatelematics.com X-Msg-Ref: server-13.tower-217.messagelabs.com!1353069920!19395663!1 X-Originating-IP: [173.160.255.210] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 25989 invoked from network); 16 Nov 2012 12:45:21 -0000 Received: from tacomatelematics.com (HELO mail.tacomatelematics.com) (173.160.255.210) by server-13.tower-217.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 16 Nov 2012 12:45:21 -0000 Received: from mail.tacomatelematics.com (vac [127.0.0.1]) by mail.tacomatelematics.com (Postfix) with ESMTP id C7AC058FC80B for ; Fri, 16 Nov 2012 04:45:18 -0800 (PST) Received: from smokescreen.nat.tact (173-160-255-209-Washington.hfc.comcastbusiness.net [173.160.255.209]) (using TLSv1 with cipher ECDHE-RSA-AES128-SHA (128/128 bits)) (No client certificate requested) (Authenticated sender: sam@tacomatelematics.com) by mail.tacomatelematics.com (Postfix) with ESMTPSA id 9217E58FC80A for ; Fri, 16 Nov 2012 04:45:18 -0800 (PST) From: Sam Mulvey Date: Fri, 16 Nov 2012 04:45:18 -0800 Message-Id: To: xen-users@lists.xen.org Mime-Version: 1.0 (Apple Message framework v1085) X-Mailer: Apple Mail (2.1085) X-Virus-Scanned: ClamAV using ClamSMTP Subject: [Xen-users] Hard reset on starting HVM dom0, multiple kernels, distros, xen versions 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: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xen-users-bounces@lists.xen.org Errors-To: xen-users-bounces@lists.xen.org Hello! Bit at my wits end here, sorry if I seem disjointed. There's not a whole lot else to say in this case, I'll include what info I have, but the serial console doesn't spit anything out after I start the HVM, and there isn't a lot of logging. I'm attempting to start a Windows ISO, or a debian-based Linux one. So far I've tried: Arch Linux, Xen 4.2.0 Fedora 17, Xen 4.1.3 Ubuntu 12.10, Xen 4.1.3 XCP 1.6 beta (which appears to work) The XCP system works, and I managed to install a windows 2k8 ISO by ssh'ing in and using xl. Everything else, I start the HVM and somewhere between immediately and 10 seconds, I get a hard reset with nothing coming out of the serial console. I'm thinking it's a kernel interaction problem, or I'm doing something ridiculous and not noticing it, as often happens. I've tried recent 3.0, 3.5, and 3.6.6 kernels. Since I've tried Ubuntu most recently, here's what I got from there, but if I should use something else, please let me know. ==== xl dmesg ==== (XEN) Xen version 4.1.3 (Ubuntu 4.1.3-3ubuntu1) (stefan.bader@canonical.com) (gcc version 4.7.2 (Ubuntu/Linaro 4.7.2-2ubuntu1) ) Tue Oct 2 09:33:57 UTC 2012 (XEN) Bootloader: SYSLINUX 4.06 2012-10-23 (XEN) Command line: dom0_mem=max:4G loglvl=all guest_loglvl=all com1=115200,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 3 MBR signatures (XEN) Found 3 EDD information structures (XEN) Xen-e820 RAM map: (XEN) 0000000000000000 - 000000000009f800 (usable) (XEN) 000000000009f800 - 00000000000a0000 (reserved) (XEN) 00000000000f0000 - 0000000000100000 (reserved) (XEN) 0000000000100000 - 00000000afdf0000 (usable) (XEN) 00000000afdf0000 - 00000000afdf3000 (ACPI NVS) (XEN) 00000000afdf3000 - 00000000afe00000 (ACPI data) (XEN) 00000000afe00000 - 00000000aff00000 (reserved) (XEN) 00000000e0000000 - 00000000f0000000 (reserved) (XEN) 00000000fec00000 - 0000000100000000 (reserved) (XEN) 0000000100000000 - 000000082f000000 (usable) (XEN) ACPI: RSDP 000F7860, 0014 (r0 GBT ) (XEN) ACPI: RSDT AFDF3000, 0040 (r1 GBT GBTUACPI 42302E31 GBTU 1010101) (XEN) ACPI: FACP AFDF3080, 0074 (r1 GBT GBTUACPI 42302E31 GBTU 1010101) (XEN) ACPI: DSDT AFDF3100, 683B (r1 GBT GBTUACPI 1000 MSFT 3000000) (XEN) ACPI: FACS AFDF0000, 0040 (XEN) ACPI: MSDM AFDF9A00, 0055 (r3 GBT GBTUACPI 42302E31 GBTU 1010101) (XEN) ACPI: HPET AFDF9A80, 0038 (r1 GBT GBTUACPI 42302E31 GBTU 98) (XEN) ACPI: MCFG AFDF9AC0, 003C (r1 GBT GBTUACPI 42302E31 GBTU 1010101) (XEN) ACPI: TAMG AFDF9B00, 0022 (r1 GBT GBT B0 5455312E BG 101) (XEN) ACPI: APIC AFDF9940, 00BC (r1 GBT GBTUACPI 42302E31 GBTU 1010101) (XEN) ACPI: SSDT AFDF9BA0, 1158 (r1 AMD POWERNOW 1 AMD 1) (XEN) System RAM: 32237MB (33011260kB) (XEN) No NUMA configuration found (XEN) Faking a node at 0000000000000000-000000082f000000 (XEN) Domain heap initialised (XEN) found SMP MP-table at 000f5e30 (XEN) DMI 2.4 present. (XEN) Using APIC driver default (XEN) ACPI: PM-Timer IO Port: 0x4008 (XEN) ACPI: ACPI SLEEP INFO: pm1x_cnt[4004,0], pm1x_evt[4000,0] (XEN) ACPI: wakeup_vec[afdf000c], vec_size[20] (XEN) ACPI: Local APIC address 0xfee00000 (XEN) ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled) (XEN) Processor #0 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x01] lapic_id[0x01] enabled) (XEN) Processor #1 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled) (XEN) Processor #2 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x03] lapic_id[0x03] enabled) (XEN) Processor #3 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x04] lapic_id[0x04] enabled) (XEN) Processor #4 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x05] lapic_id[0x05] enabled) (XEN) Processor #5 5:2 APIC version 16 (XEN) ACPI: LAPIC (acpi_id[0x06] lapic_id[0x06] disabled) (XEN) ACPI: LAPIC (acpi_id[0x07] lapic_id[0x07] disabled) (XEN) ACPI: LAPIC_NMI (acpi_id[0x00] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x01] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x02] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x03] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x04] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x05] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x06] dfl dfl lint[0x1]) (XEN) ACPI: LAPIC_NMI (acpi_id[0x07] dfl dfl lint[0x1]) (XEN) ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0]) (XEN) IOAPIC[0]: apic_id 2, version 33, 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 low 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: 0x10b9a201 base: 0xfed00000 (XEN) PCI: MCFG configuration 0: base e0000000 segment 0 buses 0 - 255 (XEN) PCI: MCFG area at e0000000 reserved in E820 (XEN) Table is not found! (XEN) Using ACPI (MADT) for SMP configuration information (XEN) IRQ limits: 24 GSI, 1144 MSI/MSI-X (XEN) Using scheduler: SMP Credit Scheduler (credit) (XEN) Detected 3515.589 MHz processor. (XEN) Initing memory sharing. (XEN) AMD Fam15h machine check reporting enabled (XEN) AMD-Vi: IOMMU not found! (XEN) I/O virtualisation disabled (XEN) ENABLING IO-APIC IRQs (XEN) -> Using new ACK method (XEN) ..TIMER: vector=0xF0 apic1=0 pin1=2 apic2=-1 pin2=-1 (XEN) Platform timer is 14.318MHz HPET (XEN) Allocated console ring of 64 KiB. (XEN) HVM: ASIDs enabled. (XEN) SVM: Supported advanced features: (XEN) - Nested Page Tables (NPT) (XEN) - Last Branch Record (LBR) Virtualisation (XEN) - Next-RIP Saved on #VMEXIT (XEN) - VMCB Clean Bits (XEN) - DecodeAssists (XEN) - Pause-Intercept Filter (XEN) HVM: SVM enabled (XEN) HVM: Hardware Assisted Paging (HAP) detected (XEN) HVM: HAP page sizes: 4kB, 2MB, 1GB (XEN) do_IRQ: 1.231 No irq handler for vector (irq -1) (XEN) do_IRQ: 2.231 No irq handler for vector (irq -1) (XEN) do_IRQ: 3.231 No irq handler for vector (irq -1) (XEN) do_IRQ: 4.231 No irq handler for vector (irq -1) (XEN) Brought up 6 CPUs (XEN) do_IRQ: 5.231 No irq handler for vector (irq -1) (XEN) ACPI sleep modes: S3 (XEN) MCA: Use hw thresholding to adjust polling frequency (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 -> 0x234f000 (XEN) PHYSICAL MEMORY ARRANGEMENT: (XEN) Dom0 alloc.: 0000000810000000->0000000814000000 (1021481 pages to be allocated) (XEN) Init. ramdisk: 000000082c629000->000000082efffc00 (XEN) VIRTUAL MEMORY ARRANGEMENT: (XEN) Loaded kernel: ffffffff81000000->ffffffff8234f000 (XEN) Init. ramdisk: ffffffff8234f000->ffffffff84d25c00 (XEN) Phys-Mach map: ffffffff84d26000->ffffffff85526000 (XEN) Start info: ffffffff85526000->ffffffff855264b4 (XEN) Page tables: ffffffff85527000->ffffffff85556000 (XEN) Boot stack: ffffffff85556000->ffffffff85557000 (XEN) TOTAL: ffffffff80000000->ffffffff85800000 (XEN) ENTRY ADDRESS: ffffffff81cf3210 (XEN) Dom0 has maximum 6 VCPUs (XEN) Scrubbing Free RAM: ......................................................................................................................................................................................................................................................................................done. (XEN) Xen trace buffers: disabled (XEN) Std. Loglevel: All (XEN) Guest Loglevel: All (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen) (XEN) Freed 220kB init memory. (XEN) traps.c:2488:d0 Domain attempted WRMSR 00000000c0010201 from 0x0000000000000000 to 0x000000000000abcd. (XEN) PCI add device 00:00.0 (XEN) PCI add device 00:01.0 (XEN) PCI add device 00:04.0 (XEN) PCI add device 00:06.0 (XEN) PCI add device 00:07.0 (XEN) PCI add device 00:11.0 (XEN) PCI add device 00:12.0 (XEN) PCI add device 00:12.1 (XEN) PCI add device 00:12.2 (XEN) PCI add device 00:13.0 (XEN) PCI add device 00:13.1 (XEN) PCI add device 00:13.2 (XEN) PCI add device 00:14.0 (XEN) PCI add device 00:14.1 (XEN) PCI add device 00:14.2 (XEN) PCI add device 00:14.3 (XEN) PCI add device 00:14.4 (XEN) PCI add device 00:14.5 (XEN) PCI add device 00:18.0 (XEN) PCI add device 00:18.1 (XEN) PCI add device 00:18.2 (XEN) PCI add device 00:18.3 (XEN) PCI add device 00:18.4 (XEN) PCI add device 00:18.5 (XEN) PCI add device 01:05.0 (XEN) PCI add device 01:05.1 (XEN) PCI add device 02:00.0 (XEN) PCI add device 03:00.0 (XEN) PCI add device 04:00.0 (XEN) physdev.c:171: dom0: wrong map_pirq type 3 (XEN) no cpu_id for acpi_id 6 (XEN) no cpu_id for acpi_id 7 === kernel dmesg ==== [ 0.000000] Initializing cgroup subsys cpuset [ 0.000000] Initializing cgroup subsys cpu [ 0.000000] Linux version 3.5.0-17-generic (buildd@allspice) (gcc version 4.7.2 (Ubuntu/Linaro 4.7.2-2ubuntu1) ) #28-Ubuntu SMP Tue Oct 9 19:31:23 UTC 2012 (Ubuntu 3.5.0-17.28-generic 3.5.5) [ 0.000000] Command line: root=/dev/mapper/cnG0-ubuntu.root ro console=hvc0 earlyprintk=xen nomodeset [ 0.000000] KERNEL supported cpus: [ 0.000000] Intel GenuineIntel [ 0.000000] AMD AuthenticAMD [ 0.000000] Centaur CentaurHauls [ 0.000000] Freeing 9f-100 pfn range: 97 pages freed [ 0.000000] 1-1 mapping on 9f->100 [ 0.000000] Freeing afdf0-100000 pfn range: 328208 pages freed [ 0.000000] 1-1 mapping on afdf0->100000 [ 0.000000] Released 328305 pages of unused memory [ 0.000000] Set 328305 page(s) to 1-1 mapping [ 0.000000] Populating 100000-150271 pfn range: 328305 pages added [ 0.000000] e820: BIOS-provided physical RAM map: [ 0.000000] Xen: [mem 0x0000000000000000-0x000000000009efff] usable [ 0.000000] Xen: [mem 0x000000000009f800-0x00000000000fffff] reserved [ 0.000000] Xen: [mem 0x0000000000100000-0x00000000afdeffff] usable [ 0.000000] Xen: [mem 0x00000000afdf0000-0x00000000afdf2fff] ACPI NVS [ 0.000000] Xen: [mem 0x00000000afdf3000-0x00000000afdfffff] ACPI data [ 0.000000] Xen: [mem 0x00000000afe00000-0x00000000afefffff] reserved [ 0.000000] Xen: [mem 0x00000000e0000000-0x00000000efffffff] reserved [ 0.000000] Xen: [mem 0x00000000fec00000-0x00000000ffffffff] reserved [ 0.000000] Xen: [mem 0x0000000100000000-0x0000000150270fff] usable [ 0.000000] Xen: [mem 0x0000000150271000-0x000000082effffff] unusable [ 0.000000] bootconsole [xenboot0] enabled [ 0.000000] NX (Execute Disable) protection: active [ 0.000000] DMI 2.4 present. [ 0.000000] DMI: Gigabyte Technology Co., Ltd. GA-78LMT-USB3/GA-78LMT-USB3, BIOS F2 08/10/2012 [ 0.000000] e820: update [mem 0x00000000-0x0000ffff] usable ==> reserved [ 0.000000] e820: remove [mem 0x000a0000-0x000fffff] usable [ 0.000000] No AGP bridge found [ 0.000000] e820: last_pfn = 0x150271 max_arch_pfn = 0x400000000 [ 0.000000] e820: last_pfn = 0xafdf0 max_arch_pfn = 0x400000000 [ 0.000000] initial memory mapped: [mem 0x00000000-0x04d25fff] [ 0.000000] Base memory trampoline at [ffff880000099000] 99000 size 24576 [ 0.000000] init_memory_mapping: [mem 0x00000000-0xafdeffff] [ 0.000000] [mem 0x00000000-0xafdeffff] page 4k [ 0.000000] kernel direct mapping tables up to 0xafdeffff @ [mem 0x00a7d000-0x00ffffff] [ 0.000000] xen: setting RW the range fce000 - 1000000 [ 0.000000] init_memory_mapping: [mem 0x100000000-0x150270fff] [ 0.000000] [mem 0x100000000-0x150270fff] page 4k [ 0.000000] kernel direct mapping tables up to 0x150270fff @ [mem 0xaf367000-0xafdeffff] [ 0.000000] xen: setting RW the range af5eb000 - afdf0000 [ 0.000000] RAMDISK: [mem 0x0234f000-0x04d25fff] [ 0.000000] ACPI: RSDP 00000000000f7860 00014 (v00 GBT ) [ 0.000000] ACPI: RSDT 00000000afdf3000 00040 (v01 GBT GBTUACPI 42302E31 GBTU 01010101) [ 0.000000] ACPI: FACP 00000000afdf3080 00074 (v01 GBT GBTUACPI 42302E31 GBTU 01010101) [ 0.000000] ACPI: DSDT 00000000afdf3100 0683B (v01 GBT GBTUACPI 00001000 MSFT 03000000) [ 0.000000] ACPI: FACS 00000000afdf0000 00040 [ 0.000000] ACPI: MSDM 00000000afdf9a00 00055 (v03 GBT GBTUACPI 42302E31 GBTU 01010101) [ 0.000000] ACPI: HPET 00000000afdf9a80 00038 (v01 GBT GBTUACPI 42302E31 GBTU 00000098) [ 0.000000] ACPI: MCFG 00000000afdf9ac0 0003C (v01 GBT GBTUACPI 42302E31 GBTU 01010101) [ 0.000000] ACPI: TAMG 00000000afdf9b00 00022 (v01 GBT GBT B0 5455312E BG?? 00000101) [ 0.000000] ACPI: APIC 00000000afdf9940 000BC (v01 GBT GBTUACPI 42302E31 GBTU 01010101) [ 0.000000] ACPI: SSDT 00000000afdf9ba0 01158 (v01 AMD POWERNOW 00000001 AMD 00000001) [ 0.000000] ACPI: Local APIC address 0xfee00000 [ 0.000000] NUMA turned off [ 0.000000] Faking a node at [mem 0x0000000000000000-0x0000000150270fff] [ 0.000000] Initmem setup node 0 [mem 0x00000000-0x150270fff] [ 0.000000] NODE_DATA [mem 0x15026d000-0x150270fff] [ 0.000000] Section 41 and 42 (node 0) have a circular dependency on usemap and pgdat allocations [ 0.000000] Zone ranges: [ 0.000000] DMA [mem 0x00010000-0x00ffffff] [ 0.000000] DMA32 [mem 0x01000000-0xffffffff] [ 0.000000] Normal [mem 0x100000000-0x150270fff] [ 0.000000] Movable zone start for each node [ 0.000000] Early memory node ranges [ 0.000000] node 0: [mem 0x00010000-0x0009efff] [ 0.000000] node 0: [mem 0x00100000-0xafdeffff] [ 0.000000] node 0: [mem 0x100000000-0x150270fff] [ 0.000000] On node 0 totalpages: 1048560 [ 0.000000] DMA zone: 64 pages used for memmap [ 0.000000] DMA zone: 1367 pages reserved [ 0.000000] DMA zone: 2552 pages, LIFO batch:0 [ 0.000000] DMA32 zone: 16320 pages used for memmap [ 0.000000] DMA32 zone: 699952 pages, LIFO batch:31 [ 0.000000] Normal zone: 5130 pages used for memmap [ 0.000000] Normal zone: 323175 pages, LIFO batch:31 [ 0.000000] ACPI: PM-Timer IO Port: 0x4008 [ 0.000000] ACPI: Local APIC address 0xfee00000 [ 0.000000] ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x01] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x03] lapic_id[0x03] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x04] lapic_id[0x04] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x05] lapic_id[0x05] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x06] lapic_id[0x06] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x07] lapic_id[0x07] disabled) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x00] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x01] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x02] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x03] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x04] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x05] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x06] dfl dfl lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x07] dfl dfl lint[0x1]) [ 0.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0]) [ 0.000000] IOAPIC[0]: apic_id 2, version 33, address 0xfec00000, GSI 0-23 [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl) [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 low level) [ 0.000000] ACPI: IRQ0 used by override. [ 0.000000] ACPI: IRQ2 used by override. [ 0.000000] ACPI: IRQ9 used by override. [ 0.000000] Using ACPI (MADT) for SMP configuration information [ 0.000000] ACPI: HPET id: 0x10b9a201 base: 0xfed00000 [ 0.000000] SMP: Allowing 8 CPUs, 2 hotplug CPUs [ 0.000000] nr_irqs_gsi: 40 [ 0.000000] PM: Registered nosave memory: 000000000009f000 - 00000000000a0000 [ 0.000000] PM: Registered nosave memory: 00000000000a0000 - 0000000000100000 [ 0.000000] PM: Registered nosave memory: 00000000afdf0000 - 00000000afdf3000 [ 0.000000] PM: Registered nosave memory: 00000000afdf3000 - 00000000afe00000 [ 0.000000] PM: Registered nosave memory: 00000000afe00000 - 00000000aff00000 [ 0.000000] PM: Registered nosave memory: 00000000aff00000 - 00000000e0000000 [ 0.000000] PM: Registered nosave memory: 00000000e0000000 - 00000000f0000000 [ 0.000000] PM: Registered nosave memory: 00000000f0000000 - 00000000fec00000 [ 0.000000] PM: Registered nosave memory: 00000000fec00000 - 0000000100000000 [ 0.000000] e820: [mem 0xaff00000-0xdfffffff] available for PCI devices [ 0.000000] Booting paravirtualized kernel on Xen [ 0.000000] Xen version: 4.1.3 (preserve-AD) [ 0.000000] setup_percpu: NR_CPUS:256 nr_cpumask_bits:256 nr_cpu_ids:8 nr_node_ids:1 [ 0.000000] PERCPU: Embedded 28 pages/cpu @ffff880150000000 s83584 r8192 d22912 u262144 [ 0.000000] pcpu-alloc: s83584 r8192 d22912 u262144 alloc=1*2097152 [ 0.000000] pcpu-alloc: [0] 0 1 2 3 4 5 6 7 [ 8.506849] Built 1 zonelists in Node order, mobility grouping on. Total pages: 1025679 [ 8.506851] Policy zone: Normal [ 8.506854] Kernel command line: root=/dev/mapper/cnG0-ubuntu.root ro console=hvc0 earlyprintk=xen nomodeset [ 8.507218] PID hash table entries: 4096 (order: 3, 32768 bytes) [ 8.507224] __ex_table already sorted, skipping sort [ 8.543544] software IO TLB [mem 0x147800000-0x14b7fffff] (64MB) mapped at [ffff880147800000-ffff88014b7fffff] [ 8.561472] Memory: 3984368k/5507524k available (6711k kernel code, 1313284k absent, 209872k reserved, 6459k data, 928k init) [ 8.561551] SLUB: Genslabs=15, HWalign=64, Order=0-3, MinObjects=0, CPUs=6, Nodes=1 [ 8.561588] Hierarchical RCU implementation. [ 8.561590] RCU dyntick-idle grace-period acceleration is enabled. [ 8.561600] NR_IRQS:16640 nr_irqs:728 16 [ 8.561682] xen: sci override: global_irq=9 trigger=0 polarity=1 [ 8.561684] xen: registering gsi 9 triggering 0 polarity 1 [ 8.561693] xen: --> pirq=9 -> irq=9 (gsi=9) [ 8.561700] xen: acpi sci 9 [ 8.561704] xen: --> pirq=1 -> irq=1 (gsi=1) [ 8.561706] xen: --> pirq=2 -> irq=2 (gsi=2) [ 8.561709] xen: --> pirq=3 -> irq=3 (gsi=3) [ 8.561711] xen: --> pirq=4 -> irq=4 (gsi=4) [ 8.561714] xen: --> pirq=5 -> irq=5 (gsi=5) [ 8.561716] xen: --> pirq=6 -> irq=6 (gsi=6) [ 8.561718] xen: --> pirq=7 -> irq=7 (gsi=7) [ 8.561721] xen: --> pirq=8 -> irq=8 (gsi=8) [ 8.561723] xen: --> pirq=10 -> irq=10 (gsi=10) [ 8.561726] xen: --> pirq=11 -> irq=11 (gsi=11) [ 8.561729] xen: --> pirq=12 -> irq=12 (gsi=12) [ 8.561731] xen: --> pirq=13 -> irq=13 (gsi=13) [ 8.561734] xen: --> pirq=14 -> irq=14 (gsi=14) [ 8.561736] xen: --> pirq=15 -> irq=15 (gsi=15) [ 8.562334] Console: colour VGA+ 80x25 [ 8.562338] console [hvc0] enabled, bootconsole disabled [ 8.565790] allocated 17301504 bytes of page_cgroup [ 8.565796] please try 'cgroup_disable=memory' option if you don't want memory cgroups [ 8.565831] Xen: using vcpuop timer interface [ 8.565837] installing Xen timer for CPU 0 [ 8.565863] Detected 3515.588 MHz processor. [ 8.565870] Calibrating delay loop (skipped), value calculated using timer frequency.. 7031.17 BogoMIPS (lpj=14062352) [ 8.565875] pid_max: default: 32768 minimum: 301 [ 8.565907] Security Framework initialized [ 8.565916] AppArmor: AppArmor initialized [ 8.565918] Yama: becoming mindful. [ 8.567004] Dentry cache hash table entries: 524288 (order: 10, 4194304 bytes) [ 8.568482] Inode-cache hash table entries: 262144 (order: 9, 2097152 bytes) [ 8.568973] Mount-cache hash table entries: 256 [ 8.569191] Initializing cgroup subsys cpuacct [ 8.569194] Initializing cgroup subsys memory [ 8.569208] Initializing cgroup subsys devices [ 8.569211] Initializing cgroup subsys freezer [ 8.569214] Initializing cgroup subsys blkio [ 8.569216] Initializing cgroup subsys perf_event [ 8.569274] tseg: 00aff00000 [ 8.569277] CPU: Physical Processor ID: 0 [ 8.569279] CPU: Processor Core ID: 0 [ 8.570793] ACPI: Core revision 20120320 [ 8.627497] ftrace: allocating 25118 entries in 99 pages [ 9.353037] cpu 0 spinlock event irq 41 [ 9.353058] Performance Events: Broken PMU hardware detected, using software events only. [ 9.353200] NMI watchdog: disabled (cpu0): hardware events not enabled [ 9.353308] installing Xen timer for CPU 1 [ 9.353318] cpu 1 spinlock event irq 48 [ 9.353532] installing Xen timer for CPU 2 [ 9.353541] cpu 2 spinlock event irq 55 [ 9.353739] installing Xen timer for CPU 3 [ 9.353748] cpu 3 spinlock event irq 62 [ 9.353941] installing Xen timer for CPU 4 [ 9.353953] cpu 4 spinlock event irq 69 [ 9.354111] installing Xen timer for CPU 5 [ 9.354120] cpu 5 spinlock event irq 76 [ 9.354263] Brought up 6 CPUs [ 9.354572] devtmpfs: initialized [ 9.355644] EVM: security.selinux [ 9.355646] EVM: security.SMACK64 [ 9.355648] EVM: security.capability [ 9.355723] PM: Registering ACPI NVS region [mem 0xafdf0000-0xafdf2fff] (12288 bytes) [ 9.356337] Grant tables using version 2 layout. [ 9.356351] Grant table initialized [ 9.356394] dummy: [ 9.356432] RTC time: 12:18:04, date: 11/16/12 [ 9.356463] NET: Registered protocol family 16 [ 9.356614] Trying to unpack rootfs image as initramfs... [ 9.356796] ACPI: bus type pci registered [ 9.356854] PCI: MMCONFIG for domain 0000 [bus 00-ff] at [mem 0xe0000000-0xefffffff] (base 0xe0000000) [ 9.356858] PCI: MMCONFIG at [mem 0xe0000000-0xefffffff] reserved in E820 [ 9.402307] Freeing initrd memory: 42844k freed [ 9.419567] PCI: Using configuration type 1 for base access [ 9.420720] bio: create slab at 0 [ 9.420859] ACPI: Added _OSI(Module Device) [ 9.420862] ACPI: Added _OSI(Processor Device) [ 9.420865] ACPI: Added _OSI(3.0 _SCP Extensions) [ 9.420868] ACPI: Added _OSI(Processor Aggregator Device) [ 9.422373] ACPI: EC: Look up EC in DSDT [ 9.430987] ACPI: Interpreter enabled [ 9.430994] ACPI: (supports S0 S3 S4 S5) [ 9.431023] ACPI: Using IOAPIC for interrupt routing [ 9.436198] ACPI: No dock devices found. [ 9.436204] PCI: Using host bridge windows from ACPI; if necessary, use "pci=nocrs" and report a bug [ 9.436267] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff]) [ 9.436361] pci_root PNP0A03:00: >host bridge window [io 0x0000-0x0cf7] [ 9.436365] pci_root PNP0A03:00: >host bridge window [io 0x0d00-0xffff] [ 9.436369] pci_root PNP0A03:00: >host bridge window [mem 0x000a0000-0x000bffff] [ 9.436372] pci_root PNP0A03:00: >host bridge window [mem 0x000c0000-0x000dffff] [ 9.436376] pci_root PNP0A03:00: >host bridge window [mem 0xd0000000-0xfebfffff] [ 9.436409] PCI host bridge to bus 0000:00 [ 9.436412] pci_bus 0000:00: >root bus resource [io 0x0000-0x0cf7] [ 9.436415] pci_bus 0000:00: >root bus resource [io 0x0d00-0xffff] [ 9.436419] pci_bus 0000:00: >root bus resource [mem 0x000a0000-0x000bffff] [ 9.436422] pci_bus 0000:00: >root bus resource [mem 0x000c0000-0x000dffff] [ 9.436426] pci_bus 0000:00: >root bus resource [mem 0xd0000000-0xfebfffff] [ 9.436452] pci 0000:00:00.0: >[1022:9600] type 00 class 0x060000 [ 9.436482] pci 0000:00:00.0: >reg 1c: [mem 0xe0000000-0xffffffff 64bit] [ 9.436599] pci 0000:00:01.0: >[1022:9602] type 01 class 0x060400 [ 9.436706] pci 0000:00:04.0: >[1022:9604] type 01 class 0x060400 [ 9.436804] pci 0000:00:04.0: >PME# supported from D0 D3hot D3cold [ 9.436841] pci 0000:00:06.0: >[1022:9606] type 01 class 0x060400 [ 9.436939] pci 0000:00:06.0: >PME# supported from D0 D3hot D3cold [ 9.436974] pci 0000:00:07.0: >[1022:9607] type 01 class 0x060400 [ 9.437071] pci 0000:00:07.0: >PME# supported from D0 D3hot D3cold [ 9.437128] pci 0000:00:11.0: >[1002:4390] type 00 class 0x01018f [ 9.437160] pci 0000:00:11.0: >reg 10: [io 0xff00-0xff07] [ 9.437176] pci 0000:00:11.0: >reg 14: [io 0xfe00-0xfe03] [ 9.437191] pci 0000:00:11.0: >reg 18: [io 0xfd00-0xfd07] [ 9.437206] pci 0000:00:11.0: >reg 1c: [io 0xfc00-0xfc03] [ 9.437221] pci 0000:00:11.0: >reg 20: [io 0xfb00-0xfb0f] [ 9.437236] pci 0000:00:11.0: >reg 24: [mem 0xfe02f000-0xfe02f3ff] [ 9.437269] pci 0000:00:11.0: >set SATA to AHCI mode [ 9.437348] pci 0000:00:12.0: >[1002:4397] type 00 class 0x0c0310 [ 9.437370] pci 0000:00:12.0: >reg 10: [mem 0xfe02e000-0xfe02efff] [ 9.437478] pci 0000:00:12.1: >[1002:4398] type 00 class 0x0c0310 [ 9.437499] pci 0000:00:12.1: >reg 10: [mem 0xfe02d000-0xfe02dfff] [ 9.437628] pci 0000:00:12.2: >[1002:4396] type 00 class 0x0c0320 [ 9.437659] pci 0000:00:12.2: >reg 10: [mem 0xfe02c000-0xfe02c0ff] [ 9.437800] pci 0000:00:12.2: >supports D1 D2 [ 9.437802] pci 0000:00:12.2: >PME# supported from D0 D1 D2 D3hot [ 9.437839] pci 0000:00:13.0: >[1002:4397] type 00 class 0x0c0310 [ 9.437863] pci 0000:00:13.0: >reg 10: [mem 0xfe02b000-0xfe02bfff] [ 9.437972] pci 0000:00:13.1: >[1002:4398] type 00 class 0x0c0310 [ 9.437993] pci 0000:00:13.1: >reg 10: [mem 0xfe02a000-0xfe02afff] [ 9.438111] pci 0000:00:13.2: >[1002:4396] type 00 class 0x0c0320 [ 9.438142] pci 0000:00:13.2: >reg 10: [mem 0xfe029000-0xfe0290ff] [ 9.438283] pci 0000:00:13.2: >supports D1 D2 [ 9.438284] pci 0000:00:13.2: >PME# supported from D0 D1 D2 D3hot [ 9.438328] pci 0000:00:14.0: >[1002:4385] type 00 class 0x0c0500 [ 9.438499] pci 0000:00:14.1: >[1002:439c] type 00 class 0x01018a [ 9.438526] pci 0000:00:14.1: >reg 10: [io 0x0000-0x0007] [ 9.438541] pci 0000:00:14.1: >reg 14: [io 0x0000-0x0003] [ 9.438556] pci 0000:00:14.1: >reg 18: [io 0x0000-0x0007] [ 9.438571] pci 0000:00:14.1: >reg 1c: [io 0x0000-0x0003] [ 9.438586] pci 0000:00:14.1: >reg 20: [io 0xfa00-0xfa0f] [ 9.438684] pci 0000:00:14.2: >[1002:4383] type 00 class 0x040300 [ 9.438718] pci 0000:00:14.2: >reg 10: [mem 0xfe024000-0xfe027fff 64bit] [ 9.438837] pci 0000:00:14.2: >PME# supported from D0 D3hot D3cold [ 9.438860] pci 0000:00:14.3: >[1002:439d] type 00 class 0x060100 [ 9.438999] pci 0000:00:14.4: >[1002:4384] type 01 class 0x060401 [ 9.439072] pci 0000:00:14.5: >[1002:4399] type 00 class 0x0c0310 [ 9.439093] pci 0000:00:14.5: >reg 10: [mem 0xfe028000-0xfe028fff] [ 9.439211] pci 0000:00:18.0: >[1022:1600] type 00 class 0x060000 [ 9.439279] pci 0000:00:18.1: >[1022:1601] type 00 class 0x060000 [ 9.439327] pci 0000:00:18.2: >[1022:1602] type 00 class 0x060000 [ 9.439379] pci 0000:00:18.3: >[1022:1603] type 00 class 0x060000 [ 9.439446] pci 0000:00:18.4: >[1022:1604] type 00 class 0x060000 [ 9.439495] pci 0000:00:18.5: >[1022:1605] type 00 class 0x060000 [ 9.439613] pci 0000:01:05.0: >[1002:9616] type 00 class 0x030000 [ 9.439634] pci 0000:01:05.0: >reg 10: [mem 0xd0000000-0xdfffffff pref] [ 9.439645] pci 0000:01:05.0: >reg 14: [io 0xce00-0xceff] [ 9.439655] pci 0000:01:05.0: >reg 18: [mem 0xfdae0000-0xfdaeffff] [ 9.439682] pci 0000:01:05.0: >reg 24: [mem 0xfd900000-0xfd9fffff] [ 9.439732] pci 0000:01:05.0: >supports D1 D2 [ 9.439754] pci 0000:01:05.1: >[1002:960f] type 00 class 0x040300 [ 9.439775] pci 0000:01:05.1: >reg 10: [mem 0xfdafc000-0xfdafffff] [ 9.439868] pci 0000:01:05.1: >supports D1 D2 [ 9.439936] pci 0000:00:01.0: >PCI bridge to [bus 01-01] [ 9.439945] pci 0000:00:01.0: > bridge window [io 0xc000-0xcfff] [ 9.439949] pci 0000:00:01.0: > bridge window [mem 0xfd900000-0xfdafffff] [ 9.439956] pci 0000:00:01.0: > bridge window [mem 0xd0000000-0xdfffffff 64bit pref] [ 9.440038] pci 0000:02:00.0: >[1b6f:7023] type 00 class 0x0c0330 [ 9.440064] pci 0000:02:00.0: >reg 10: [mem 0xfd6f8000-0xfd6fffff 64bit] [ 9.440191] pci 0000:02:00.0: >supports D1 D2 [ 9.440192] pci 0000:02:00.0: >PME# supported from D0 D1 D2 D3hot D3cold [ 9.450926] pci 0000:00:04.0: >PCI bridge to [bus 02-02] [ 9.450934] pci 0000:00:04.0: > bridge window [io 0xb000-0xbfff] [ 9.450939] pci 0000:00:04.0: > bridge window [mem 0xfd600000-0xfd6fffff] [ 9.450946] pci 0000:00:04.0: > bridge window [mem 0xfdf00000-0xfdffffff 64bit pref] [ 9.451034] pci 0000:03:00.0: >[10ec:8168] type 00 class 0x020000 [ 9.451054] pci 0000:03:00.0: >reg 10: [io 0xee00-0xeeff] [ 9.451089] pci 0000:03:00.0: >reg 18: [mem 0xfddff000-0xfddfffff 64bit pref] [ 9.451112] pci 0000:03:00.0: >reg 20: [mem 0xfddf8000-0xfddfbfff 64bit pref] [ 9.451211] pci 0000:03:00.0: >supports D1 D2 [ 9.451213] pci 0000:03:00.0: >PME# supported from D0 D1 D2 D3hot D3cold [ 9.463087] pci 0000:00:06.0: >PCI bridge to [bus 03-03] [ 9.463096] pci 0000:00:06.0: > bridge window [io 0xe000-0xefff] [ 9.463100] pci 0000:00:06.0: > bridge window [mem 0xfde00000-0xfdefffff] [ 9.463107] pci 0000:00:06.0: > bridge window [mem 0xfdd00000-0xfddfffff 64bit pref] [ 9.463191] pci 0000:04:00.0: >[1b6f:7023] type 00 class 0x0c0330 [ 9.463217] pci 0000:04:00.0: >reg 10: [mem 0xfdcf8000-0xfdcfffff 64bit] [ 9.463346] pci 0000:04:00.0: >supports D1 D2 [ 9.463348] pci 0000:04:00.0: >PME# supported from D0 D1 D2 D3hot D3cold [ 9.475247] pci 0000:00:07.0: >PCI bridge to [bus 04-04] [ 9.475256] pci 0000:00:07.0: > bridge window [io 0xd000-0xdfff] [ 9.475260] pci 0000:00:07.0: > bridge window [mem 0xfdc00000-0xfdcfffff] [ 9.475267] pci 0000:00:07.0: > bridge window [mem 0xfdb00000-0xfdbfffff 64bit pref] [ 9.475360] pci 0000:00:14.4: >PCI bridge to [bus 05-05] (subtractive decode) [ 9.475367] pci 0000:00:14.4: > bridge window [io 0xa000-0xafff] [ 9.475377] pci 0000:00:14.4: > bridge window [mem 0xfd800000-0xfd8fffff] [ 9.475382] pci 0000:00:14.4: > bridge window [mem 0xfd700000-0xfd7fffff pref] [ 9.475384] pci 0000:00:14.4: > bridge window [io 0x0000-0x0cf7] (subtractive decode) [ 9.475386] pci 0000:00:14.4: > bridge window [io 0x0d00-0xffff] (subtractive decode) [ 9.475388] pci 0000:00:14.4: > bridge window [mem 0x000a0000-0x000bffff] (subtractive decode) [ 9.475390] pci 0000:00:14.4: > bridge window [mem 0x000c0000-0x000dffff] (subtractive decode) [ 9.475392] pci 0000:00:14.4: > bridge window [mem 0xd0000000-0xfebfffff] (subtractive decode) [ 9.475425] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT] [ 9.475668] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.P2P_._PRT] [ 9.475708] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.PCE4._PRT] [ 9.475742] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.PCE6._PRT] [ 9.475772] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.PCE7._PRT] [ 9.475811] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.AGP_._PRT] [ 9.475847] pci0000:00: >Requesting ACPI _OSC control (0x1d) [ 9.475851] pci0000:00: >ACPI _OSC request failed (AE_NOT_FOUND), returned control mask: 0x1d [ 9.475854] ACPI _OSC control for PCIe not granted, disabling ASPM [ 9.492707] ACPI: PCI Interrupt Link [LNKA] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.492759] ACPI: PCI Interrupt Link [LNKB] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.492809] ACPI: PCI Interrupt Link [LNKC] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.492859] ACPI: PCI Interrupt Link [LNKD] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.492908] ACPI: PCI Interrupt Link [LNKE] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.492956] ACPI: PCI Interrupt Link [LNKF] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.493005] ACPI: PCI Interrupt Link [LNK0] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.493084] ACPI: PCI Interrupt Link [LNK1] (IRQs 3 4 5 6 7 10 11) *0, disabled. [ 9.493120] xen/balloon: Initialising balloon driver. [ 9.493134] xen-balloon: Initialising balloon driver. [ 9.493164] xen/balloon: Xen selfballooning driver disabled for domain0. [ 9.493248] vgaarb: device added: PCI:0000:01:05.0,decodes=io+mem,owns=io+mem,locks=none [ 9.493254] vgaarb: loaded [ 9.493256] vgaarb: bridge control possible 0000:01:05.0 [ 9.493416] SCSI subsystem initialized [ 9.493483] libata version 3.00 loaded. [ 9.493503] ACPI: bus type usb registered [ 9.493521] usbcore: registered new interface driver usbfs [ 9.493530] usbcore: registered new interface driver hub [ 9.493568] usbcore: registered new device driver usb [ 9.493655] PCI: Using ACPI for IRQ routing [ 9.508590] PCI: pci_cache_line_size set to 64 bytes [ 9.508598] pci 0000:00:00.0: >no compatible bridge window for [mem 0xe0000000-0xffffffff 64bit] [ 9.508729] e820: reserve RAM buffer [mem 0x0009f000-0x0009ffff] [ 9.508731] e820: reserve RAM buffer [mem 0xafdf0000-0xafffffff] [ 9.508733] e820: reserve RAM buffer [mem 0x150271000-0x153ffffff] [ 9.508814] NetLabel: Initializing [ 9.508816] NetLabel: domain hash size = 128 [ 9.508818] NetLabel: protocols = UNLABELED CIPSOv4 [ 9.508830] NetLabel: unlabeled traffic allowed by default [ 9.508934] Switching to clocksource xen [ 9.516813] AppArmor: AppArmor Filesystem Enabled [ 9.516829] pnp: PnP ACPI init [ 9.516840] ACPI: bus type pnp registered [ 9.516920] pnp 00:00: >[bus 00-ff] [ 9.516922] pnp 00:00: >[io 0x0cf8-0x0cff] [ 9.516924] pnp 00:00: >[io 0x0000-0x0cf7 window] [ 9.516926] pnp 00:00: >[io 0x0d00-0xffff window] [ 9.516928] pnp 00:00: >[mem 0x000a0000-0x000bffff window] [ 9.516930] pnp 00:00: >[mem 0x000c0000-0x000dffff window] [ 9.516932] pnp 00:00: >[mem 0xd0000000-0xfebfffff window] [ 9.516974] pnp 00:00: >Plug and Play ACPI device, IDs PNP0a03 (active) [ 9.516985] pnp 00:01: >[io 0x0010-0x001f] [ 9.516986] pnp 00:01: >[io 0x0022-0x003f] [ 9.516988] pnp 00:01: >[io 0x0044-0x005f] [ 9.516990] pnp 00:01: >[io 0x0062-0x0063] [ 9.516991] pnp 00:01: >[io 0x0065-0x006f] [ 9.516993] pnp 00:01: >[io 0x0074-0x007f] [ 9.516994] pnp 00:01: >[io 0x0091-0x0093] [ 9.516996] pnp 00:01: >[io 0x00a2-0x00bf] [ 9.516998] pnp 00:01: >[io 0x00e0-0x00ef] [ 9.516999] pnp 00:01: >[io 0x04d0-0x04d1] [ 9.517001] pnp 00:01: >[io 0x0220-0x0225] [ 9.517002] pnp 00:01: >[io 0x0290-0x0294] [ 9.517060] system 00:01: >[io 0x04d0-0x04d1] has been reserved [ 9.517064] system 00:01: >[io 0x0220-0x0225] has been reserved [ 9.517067] system 00:01: >[io 0x0290-0x0294] has been reserved [ 9.517071] system 00:01: >Plug and Play ACPI device, IDs PNP0c02 (active) [ 9.517640] pnp 00:02: >[io 0x4100-0x411f] [ 9.517644] pnp 00:02: >[io 0x0228-0x022f] [ 9.517646] pnp 00:02: >[io 0x040b] [ 9.517647] pnp 00:02: >[io 0x04d6] [ 9.517649] pnp 00:02: >[io 0x0c00-0x0c01] [ 9.517651] pnp 00:02: >[io 0x0c14] [ 9.517652] pnp 00:02: >[io 0x0c50-0x0c52] [ 9.517654] pnp 00:02: >[io 0x0c6c-0x0c6d] [ 9.517655] pnp 00:02: >[io 0x0c6f] [ 9.517657] pnp 00:02: >[io 0x0cd0-0x0cd1] [ 9.517658] pnp 00:02: >[io 0x0cd2-0x0cd3] [ 9.517660] pnp 00:02: >[io 0x0cd4-0x0cdf] [ 9.517661] pnp 00:02: >[io 0x4000-0x40fe] [ 9.517663] pnp 00:02: >[io 0x4210-0x4217] [ 9.517664] pnp 00:02: >[io 0x0b00-0x0b0f] [ 9.517666] pnp 00:02: >[io 0x0b10-0x0b1f] [ 9.517667] pnp 00:02: >[io 0x0b20-0x0b3f] [ 9.517669] pnp 00:02: >[mem 0x00000000-0x00000fff window] [ 9.517671] pnp 00:02: >[mem 0xfee00400-0xfee00fff window] [ 9.517677] pnp 00:02: >disabling [mem 0x00000000-0x00000fff window] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.517759] system 00:02: >[io 0x4100-0x411f] has been reserved [ 9.517764] system 00:02: >[io 0x0228-0x022f] has been reserved [ 9.517767] system 00:02: >[io 0x040b] has been reserved [ 9.517771] system 00:02: >[io 0x04d6] has been reserved [ 9.517774] system 00:02: >[io 0x0c00-0x0c01] has been reserved [ 9.517777] system 00:02: >[io 0x0c14] has been reserved [ 9.517780] system 00:02: >[io 0x0c50-0x0c52] has been reserved [ 9.517784] system 00:02: >[io 0x0c6c-0x0c6d] has been reserved [ 9.517787] system 00:02: >[io 0x0c6f] has been reserved [ 9.517790] system 00:02: >[io 0x0cd0-0x0cd1] has been reserved [ 9.517793] system 00:02: >[io 0x0cd2-0x0cd3] has been reserved [ 9.517797] system 00:02: >[io 0x0cd4-0x0cdf] has been reserved [ 9.517800] system 00:02: >[io 0x4000-0x40fe] has been reserved [ 9.517803] system 00:02: >[io 0x4210-0x4217] has been reserved [ 9.517807] system 00:02: >[io 0x0b00-0x0b0f] has been reserved [ 9.517810] system 00:02: >[io 0x0b10-0x0b1f] has been reserved [ 9.517814] system 00:02: >[io 0x0b20-0x0b3f] has been reserved [ 9.517817] system 00:02: >[mem 0xfee00400-0xfee00fff window] has been reserved [ 9.517823] system 00:02: >Plug and Play ACPI device, IDs PNP0c02 (active) [ 9.517937] pnp 00:03: >[dma 4] [ 9.517939] pnp 00:03: >[io 0x0000-0x000f] [ 9.517941] pnp 00:03: >[io 0x0080-0x0090] [ 9.517943] pnp 00:03: >[io 0x0094-0x009f] [ 9.517945] pnp 00:03: >[io 0x00c0-0x00df] [ 9.517975] pnp 00:03: >Plug and Play ACPI device, IDs PNP0200 (active) [ 9.518029] pnp 00:04: >[irq 0 disabled] [ 9.518032] xen: registering gsi 8 triggering 1 polarity 0 [ 9.518041] pnp 00:04: >[irq 8] [ 9.518042] pnp 00:04: >[mem 0xfed00000-0xfed003ff] [ 9.518071] pnp 00:04: >Plug and Play ACPI device, IDs PNP0103 (active) [ 9.518099] pnp 00:05: >[io 0x0070-0x0073] [ 9.518129] pnp 00:05: >Plug and Play ACPI device, IDs PNP0b00 (active) [ 9.518137] pnp 00:06: >[io 0x0061] [ 9.518165] pnp 00:06: >Plug and Play ACPI device, IDs PNP0800 (active) [ 9.518173] pnp 00:07: >[io 0x00f0-0x00ff] [ 9.518174] xen: registering gsi 13 triggering 1 polarity 0 [ 9.518181] pnp 00:07: >[irq 13] [ 9.518211] pnp 00:07: >Plug and Play ACPI device, IDs PNP0c04 (active) [ 9.518387] pnp 00:08: >[io 0x03f0-0x03f5] [ 9.518389] pnp 00:08: >[io 0x03f7] [ 9.518391] xen: registering gsi 6 triggering 1 polarity 0 [ 9.518397] pnp 00:08: >[irq 6] [ 9.518399] pnp 00:08: >[dma 2] [ 9.518444] pnp 00:08: >Plug and Play ACPI device, IDs PNP0700 (active) [ 9.518649] pnp 00:09: >[io 0x03f8-0x03ff] [ 9.518650] xen: registering gsi 4 triggering 1 polarity 0 [ 9.518652] Already setup the GSI :4 [ 9.518655] pnp 00:09: >[irq 4] [ 9.518710] pnp 00:09: >Plug and Play ACPI device, IDs PNP0501 (active) [ 9.518930] pnp 00:0a: >[io 0x0378-0x037f] [ 9.518932] xen: registering gsi 7 triggering 1 polarity 0 [ 9.518938] pnp 00:0a: >[irq 7] [ 9.518986] pnp 00:0a: >Plug and Play ACPI device, IDs PNP0400 (active) [ 9.519117] pnp 00:0b: >[mem 0xe0000000-0xefffffff] [ 9.519174] system 00:0b: >[mem 0xe0000000-0xefffffff] has been reserved [ 9.519179] system 00:0b: >Plug and Play ACPI device, IDs PNP0c02 (active) [ 9.519352] pnp 00:0c: >[mem 0x000cec00-0x000cffff] [ 9.519354] pnp 00:0c: >[mem 0x000f0000-0x000f7fff] [ 9.519359] pnp 00:0c: >[mem 0x000f8000-0x000fbfff] [ 9.519361] pnp 00:0c: >[mem 0x000fc000-0x000fffff] [ 9.519362] pnp 00:0c: >[mem 0xafdf0000-0xafdfffff] [ 9.519364] pnp 00:0c: >[mem 0xffff0000-0xffffffff] [ 9.519366] pnp 00:0c: >[mem 0x00000000-0x0009ffff] [ 9.519367] pnp 00:0c: >[mem 0x00100000-0xafdeffff] [ 9.519369] pnp 00:0c: >[mem 0xafe00000-0xafefffff] [ 9.519370] pnp 00:0c: >[mem 0xaff00000-0xafffffff] [ 9.519372] pnp 00:0c: >[mem 0xb0000000-0xcfffffff] [ 9.519373] pnp 00:0c: >[mem 0xfec00000-0xfec00fff] [ 9.519375] pnp 00:0c: >[mem 0xfee00000-0xfee00fff] [ 9.519376] pnp 00:0c: >[mem 0xfff80000-0xfffeffff] [ 9.519380] pnp 00:0c: >disabling [mem 0x000cec00-0x000cffff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519392] pnp 00:0c: >disabling [mem 0x000f0000-0x000f7fff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519397] pnp 00:0c: >disabling [mem 0x000f8000-0x000fbfff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519401] pnp 00:0c: >disabling [mem 0x000fc000-0x000fffff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519406] pnp 00:0c: >disabling [mem 0x00000000-0x0009ffff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519411] pnp 00:0c: >disabling [mem 0x00100000-0xafdeffff] because it overlaps 0000:00:00.0 BAR 3 [mem 0x00000000-0x1fffffff 64bit] [ 9.519480] system 00:0c: >[mem 0xafdf0000-0xafdfffff] could not be reserved [ 9.519484] system 00:0c: >[mem 0xffff0000-0xffffffff] has been reserved [ 9.519488] system 00:0c: >[mem 0xafe00000-0xafefffff] has been reserved [ 9.519491] system 00:0c: >[mem 0xaff00000-0xafffffff] could not be reserved [ 9.519495] system 00:0c: >[mem 0xb0000000-0xcfffffff] has been reserved [ 9.519498] system 00:0c: >[mem 0xfec00000-0xfec00fff] could not be reserved [ 9.519502] system 00:0c: >[mem 0xfee00000-0xfee00fff] could not be reserved [ 9.519505] system 00:0c: >[mem 0xfff80000-0xfffeffff] has been reserved [ 9.519510] system 00:0c: >Plug and Play ACPI device, IDs PNP0c01 (active) [ 9.519528] pnp: PnP ACPI: found 13 devices [ 9.519531] ACPI: ACPI bus type pnp unregistered [ 9.525700] PM-Timer failed consistency check (0x0xffffff) - aborting. [ 9.525771] pci 0000:00:01.0: >PCI bridge to [bus 01-01] [ 9.525776] pci 0000:00:01.0: > bridge window [io 0xc000-0xcfff] [ 9.525783] pci 0000:00:01.0: > bridge window [mem 0xfd900000-0xfdafffff] [ 9.525789] pci 0000:00:01.0: > bridge window [mem 0xd0000000-0xdfffffff 64bit pref] [ 9.525797] pci 0000:00:04.0: >PCI bridge to [bus 02-02] [ 9.525802] pci 0000:00:04.0: > bridge window [io 0xb000-0xbfff] [ 9.525809] pci 0000:00:04.0: > bridge window [mem 0xfd600000-0xfd6fffff] [ 9.525815] pci 0000:00:04.0: > bridge window [mem 0xfdf00000-0xfdffffff 64bit pref] [ 9.525823] pci 0000:00:06.0: >PCI bridge to [bus 03-03] [ 9.525827] pci 0000:00:06.0: > bridge window [io 0xe000-0xefff] [ 9.525834] pci 0000:00:06.0: > bridge window [mem 0xfde00000-0xfdefffff] [ 9.525840] pci 0000:00:06.0: > bridge window [mem 0xfdd00000-0xfddfffff 64bit pref] [ 9.525848] pci 0000:00:07.0: >PCI bridge to [bus 04-04] [ 9.525852] pci 0000:00:07.0: > bridge window [io 0xd000-0xdfff] [ 9.525859] pci 0000:00:07.0: > bridge window [mem 0xfdc00000-0xfdcfffff] [ 9.525865] pci 0000:00:07.0: > bridge window [mem 0xfdb00000-0xfdbfffff 64bit pref] [ 9.525873] pci 0000:00:14.4: >PCI bridge to [bus 05-05] [ 9.525878] pci 0000:00:14.4: > bridge window [io 0xa000-0xafff] [ 9.525886] pci 0000:00:14.4: > bridge window [mem 0xfd800000-0xfd8fffff] [ 9.525893] pci 0000:00:14.4: > bridge window [mem 0xfd700000-0xfd7fffff pref] [ 9.525914] xen: registering gsi 16 triggering 0 polarity 1 [ 9.525923] xen: --> pirq=16 -> irq=16 (gsi=16) [ 9.525934] xen: registering gsi 18 triggering 0 polarity 1 [ 9.525939] xen: --> pirq=18 -> irq=18 (gsi=18) [ 9.525950] xen: registering gsi 19 triggering 0 polarity 1 [ 9.525954] xen: --> pirq=19 -> irq=19 (gsi=19) [ 9.525969] pci_bus 0000:00: >resource 4 [io 0x0000-0x0cf7] [ 9.525972] pci_bus 0000:00: >resource 5 [io 0x0d00-0xffff] [ 9.525973] pci_bus 0000:00: >resource 6 [mem 0x000a0000-0x000bffff] [ 9.525975] pci_bus 0000:00: >resource 7 [mem 0x000c0000-0x000dffff] [ 9.525977] pci_bus 0000:00: >resource 8 [mem 0xd0000000-0xfebfffff] [ 9.525979] pci_bus 0000:01: >resource 0 [io 0xc000-0xcfff] [ 9.525980] pci_bus 0000:01: >resource 1 [mem 0xfd900000-0xfdafffff] [ 9.525982] pci_bus 0000:01: >resource 2 [mem 0xd0000000-0xdfffffff 64bit pref] [ 9.525984] pci_bus 0000:02: >resource 0 [io 0xb000-0xbfff] [ 9.525986] pci_bus 0000:02: >resource 1 [mem 0xfd600000-0xfd6fffff] [ 9.525987] pci_bus 0000:02: >resource 2 [mem 0xfdf00000-0xfdffffff 64bit pref] [ 9.525989] pci_bus 0000:03: >resource 0 [io 0xe000-0xefff] [ 9.525991] pci_bus 0000:03: >resource 1 [mem 0xfde00000-0xfdefffff] [ 9.525993] pci_bus 0000:03: >resource 2 [mem 0xfdd00000-0xfddfffff 64bit pref] [ 9.525994] pci_bus 0000:04: >resource 0 [io 0xd000-0xdfff] [ 9.525996] pci_bus 0000:04: >resource 1 [mem 0xfdc00000-0xfdcfffff] [ 9.525998] pci_bus 0000:04: >resource 2 [mem 0xfdb00000-0xfdbfffff 64bit pref] [ 9.526000] pci_bus 0000:05: >resource 0 [io 0xa000-0xafff] [ 9.526001] pci_bus 0000:05: >resource 1 [mem 0xfd800000-0xfd8fffff] [ 9.526003] pci_bus 0000:05: >resource 2 [mem 0xfd700000-0xfd7fffff pref] [ 9.526005] pci_bus 0000:05: >resource 4 [io 0x0000-0x0cf7] [ 9.526006] pci_bus 0000:05: >resource 5 [io 0x0d00-0xffff] [ 9.526008] pci_bus 0000:05: >resource 6 [mem 0x000a0000-0x000bffff] [ 9.526010] pci_bus 0000:05: >resource 7 [mem 0x000c0000-0x000dffff] [ 9.526011] pci_bus 0000:05: >resource 8 [mem 0xd0000000-0xfebfffff] [ 9.526039] NET: Registered protocol family 2 [ 9.526336] IP route cache hash table entries: 131072 (order: 8, 1048576 bytes) [ 9.528616] TCP established hash table entries: 524288 (order: 11, 8388608 bytes) [ 9.530582] TCP bind hash table entries: 65536 (order: 8, 1048576 bytes) [ 9.530801] TCP: Hash tables configured (established 524288 bind 65536) [ 9.530804] TCP: reno registered [ 9.530825] UDP hash table entries: 2048 (order: 4, 65536 bytes) [ 9.530858] UDP-Lite hash table entries: 2048 (order: 4, 65536 bytes) [ 9.530928] NET: Registered protocol family 1 [ 9.530938] pci 0000:00:01.0: >MSI quirk detected; subordinate MSI disabled [ 9.530966] xen: registering gsi 16 triggering 0 polarity 1 [ 9.530970] Already setup the GSI :16 [ 9.605048] xen: registering gsi 16 triggering 0 polarity 1 [ 9.605051] Already setup the GSI :16 [ 9.677052] xen: registering gsi 17 triggering 0 polarity 1 [ 9.677064] xen: --> pirq=17 -> irq=17 (gsi=17) [ 9.677121] xen: registering gsi 18 triggering 0 polarity 1 [ 9.677123] Already setup the GSI :18 [ 9.749046] xen: registering gsi 18 triggering 0 polarity 1 [ 9.749049] Already setup the GSI :18 [ 9.821052] xen: registering gsi 19 triggering 0 polarity 1 [ 9.821054] Already setup the GSI :19 [ 9.821121] xen: registering gsi 18 triggering 0 polarity 1 [ 9.821123] Already setup the GSI :18 [ 9.893070] pci 0000:01:05.0: >Boot video device [ 9.893083] xen: registering gsi 16 triggering 0 polarity 1 [ 9.893085] Already setup the GSI :16 [ 9.893150] xen: registering gsi 19 triggering 0 polarity 1 [ 9.893152] Already setup the GSI :19 [ 9.893199] PCI: CLS 64 bytes, default 64 [ 9.893736] audit: initializing netlink socket (disabled) [ 9.893753] type=2000 audit(1353068284.117:1): initialized [ 9.910549] HugeTLB registered 2 MB page size, pre-allocated 0 pages [ 9.911849] VFS: Disk quotas dquot_6.5.2 [ 9.911886] Dquot-cache hash table entries: 512 (order 0, 4096 bytes) [ 9.912343] fuse init (API version 7.19) [ 9.912421] msgmni has been set to 7865 [ 9.912917] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 252) [ 9.912959] io scheduler noop registered [ 9.912962] io scheduler deadline registered (default) [ 9.912986] io scheduler cfq registered [ 9.913508] pci_hotplug: PCI Hot Plug PCI Core version: 0.5 [ 9.913528] pciehp: PCI Express Hot Plug Controller Driver version: 0.4 [ 9.913644] input: Power Button as /devices/LNXSYSTM:00/device:00/PNP0C0C:00/input/input0 [ 9.913681] ACPI: Power Button [PWRB] [ 9.913721] input: Power Button as /devices/LNXSYSTM:00/LNXPWRBN:00/input/input1 [ 9.913725] ACPI: Power Button [PWRF] [ 9.920036] GHES: HEST is not enabled! [ 9.920974] Serial: 8250/16550 driver, 32 ports, IRQ sharing enabled [ 9.922553] hpet_acpi_add: no address or irqs in _CRS [ 9.922565] Linux agpgart interface v0.103 [ 9.924368] brd: module loaded [ 9.925074] loop: module loaded [ 9.925159] ahci 0000:00:11.0: >version 3.0 [ 9.925169] xen: registering gsi 22 triggering 0 polarity 1 [ 9.925178] xen: --> pirq=22 -> irq=22 (gsi=22) [ 9.925297] ahci 0000:00:11.0: >AHCI 0001.0100 32 slots 4 ports 3 Gbps 0xf impl SATA mode [ 9.925302] ahci 0000:00:11.0: >flags: 64bit ncq sntf ilck pm led clo pmp pio slum part ccc [ 9.925928] scsi0 : ahci [ 9.926006] scsi1 : ahci [ 9.926076] scsi2 : ahci [ 9.926177] scsi3 : ahci [ 9.926290] ata1: SATA max UDMA/133 abar m1024@0xfe02f000 port 0xfe02f100 irq 22 [ 9.926294] ata2: SATA max UDMA/133 abar m1024@0xfe02f000 port 0xfe02f180 irq 22 [ 9.926299] ata3: SATA max UDMA/133 abar m1024@0xfe02f000 port 0xfe02f200 irq 22 [ 9.926303] ata4: SATA max UDMA/133 abar m1024@0xfe02f000 port 0xfe02f280 irq 22 [ 9.926393] xen: registering gsi 16 triggering 0 polarity 1 [ 9.926395] Already setup the GSI :16 [ 9.926650] Fixed MDIO Bus: probed [ 9.926689] tun: Universal TUN/TAP device driver, 1.6 [ 9.926691] tun: (C) 1999-2004 Max Krasnyansky [ 9.926737] PPP generic driver version 2.4.2 [ 9.926778] Initialising Xen virtual ethernet driver. [ 9.926789] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver [ 9.926809] xen: registering gsi 17 triggering 0 polarity 1 [ 9.926811] Already setup the GSI :17 [ 9.926830] ehci_hcd 0000:00:12.2: >EHCI Host Controller [ 9.926836] ehci_hcd 0000:00:12.2: >new USB bus registered, assigned bus number 1 [ 9.926847] ehci_hcd 0000:00:12.2: >applying AMD SB700/SB800/Hudson-2/3 EHCI dummy qh workaround [ 9.926896] ehci_hcd 0000:00:12.2: >debug port 1 [ 9.926927] ehci_hcd 0000:00:12.2: >irq 17, io mem 0xfe02c000 [ 9.937095] ehci_hcd 0000:00:12.2: >USB 2.0 started, EHCI 1.00 [ 9.937179] usb usb1: >New USB device found, idVendor=1d6b, idProduct=0002 [ 9.937189] usb usb1: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 9.937199] usb usb1: >Product: EHCI Host Controller [ 9.937206] usb usb1: >Manufacturer: Linux 3.5.0-17-generic ehci_hcd [ 9.937214] usb usb1: >SerialNumber: 0000:00:12.2 [ 9.937424] hub 1-0:1.0: >USB hub found [ 9.937429] hub 1-0:1.0: >6 ports detected [ 9.937500] xen: registering gsi 19 triggering 0 polarity 1 [ 9.937502] Already setup the GSI :19 [ 9.937521] ehci_hcd 0000:00:13.2: >EHCI Host Controller [ 9.937527] ehci_hcd 0000:00:13.2: >new USB bus registered, assigned bus number 2 [ 9.937535] ehci_hcd 0000:00:13.2: >applying AMD SB700/SB800/Hudson-2/3 EHCI dummy qh workaround [ 9.937618] ehci_hcd 0000:00:13.2: >debug port 1 [ 9.937651] ehci_hcd 0000:00:13.2: >irq 19, io mem 0xfe029000 [ 9.949104] ehci_hcd 0000:00:13.2: >USB 2.0 started, EHCI 1.00 [ 9.949177] usb usb2: >New USB device found, idVendor=1d6b, idProduct=0002 [ 9.949188] usb usb2: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 9.949197] usb usb2: >Product: EHCI Host Controller [ 9.949204] usb usb2: >Manufacturer: Linux 3.5.0-17-generic ehci_hcd [ 9.949212] usb usb2: >SerialNumber: 0000:00:13.2 [ 9.949521] hub 2-0:1.0: >USB hub found [ 9.949533] hub 2-0:1.0: >6 ports detected [ 9.949741] ohci_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver [ 9.949792] xen: registering gsi 16 triggering 0 polarity 1 [ 9.949798] Already setup the GSI :16 [ 9.949844] ohci_hcd 0000:00:12.0: >OHCI Host Controller [ 9.949859] ohci_hcd 0000:00:12.0: >new USB bus registered, assigned bus number 3 [ 9.949949] ohci_hcd 0000:00:12.0: >irq 16, io mem 0xfe02e000 [ 10.009129] usb usb3: >New USB device found, idVendor=1d6b, idProduct=0001 [ 10.009143] usb usb3: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.009153] usb usb3: >Product: OHCI Host Controller [ 10.009160] usb usb3: >Manufacturer: Linux 3.5.0-17-generic ohci_hcd [ 10.009168] usb usb3: >SerialNumber: 0000:00:12.0 [ 10.009458] hub 3-0:1.0: >USB hub found [ 10.009473] hub 3-0:1.0: >3 ports detected [ 10.009628] xen: registering gsi 16 triggering 0 polarity 1 [ 10.009634] Already setup the GSI :16 [ 10.009684] ohci_hcd 0000:00:12.1: >OHCI Host Controller [ 10.009699] ohci_hcd 0000:00:12.1: >new USB bus registered, assigned bus number 4 [ 10.009752] ohci_hcd 0000:00:12.1: >irq 16, io mem 0xfe02d000 [ 10.069079] usb usb4: >New USB device found, idVendor=1d6b, idProduct=0001 [ 10.069092] usb usb4: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.069103] usb usb4: >Product: OHCI Host Controller [ 10.069110] usb usb4: >Manufacturer: Linux 3.5.0-17-generic ohci_hcd [ 10.069118] usb usb4: >SerialNumber: 0000:00:12.1 [ 10.069432] hub 4-0:1.0: >USB hub found [ 10.069446] hub 4-0:1.0: >3 ports detected [ 10.069605] xen: registering gsi 18 triggering 0 polarity 1 [ 10.069612] Already setup the GSI :18 [ 10.069659] ohci_hcd 0000:00:13.0: >OHCI Host Controller [ 10.069673] ohci_hcd 0000:00:13.0: >new USB bus registered, assigned bus number 5 [ 10.069757] ohci_hcd 0000:00:13.0: >irq 18, io mem 0xfe02b000 [ 10.129125] usb usb5: >New USB device found, idVendor=1d6b, idProduct=0001 [ 10.129138] usb usb5: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.129148] usb usb5: >Product: OHCI Host Controller [ 10.129155] usb usb5: >Manufacturer: Linux 3.5.0-17-generic ohci_hcd [ 10.129163] usb usb5: >SerialNumber: 0000:00:13.0 [ 10.129474] hub 5-0:1.0: >USB hub found [ 10.129492] hub 5-0:1.0: >3 ports detected [ 10.129662] xen: registering gsi 18 triggering 0 polarity 1 [ 10.129669] Already setup the GSI :18 [ 10.129717] ohci_hcd 0000:00:13.1: >OHCI Host Controller [ 10.129731] ohci_hcd 0000:00:13.1: >new USB bus registered, assigned bus number 6 [ 10.129818] ohci_hcd 0000:00:13.1: >irq 18, io mem 0xfe02a000 [ 10.189141] usb usb6: >New USB device found, idVendor=1d6b, idProduct=0001 [ 10.189154] usb usb6: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.189164] usb usb6: >Product: OHCI Host Controller [ 10.189171] usb usb6: >Manufacturer: Linux 3.5.0-17-generic ohci_hcd [ 10.189179] usb usb6: >SerialNumber: 0000:00:13.1 [ 10.189485] hub 6-0:1.0: >USB hub found [ 10.189500] hub 6-0:1.0: >3 ports detected [ 10.189690] xen: registering gsi 18 triggering 0 polarity 1 [ 10.189697] Already setup the GSI :18 [ 10.189744] ohci_hcd 0000:00:14.5: >OHCI Host Controller [ 10.189759] ohci_hcd 0000:00:14.5: >new USB bus registered, assigned bus number 7 [ 10.189852] ohci_hcd 0000:00:14.5: >irq 18, io mem 0xfe028000 [ 10.245128] ata4: SATA link down (SStatus 0 SControl 300) [ 10.249106] usb 1-2: >new high-speed USB device number 2 using ehci_hcd [ 10.249155] usb usb7: >New USB device found, idVendor=1d6b, idProduct=0001 [ 10.249169] usb usb7: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.249179] usb usb7: >Product: OHCI Host Controller [ 10.249186] usb usb7: >Manufacturer: Linux 3.5.0-17-generic ohci_hcd [ 10.249194] usb usb7: >SerialNumber: 0000:00:14.5 [ 10.249529] hub 7-0:1.0: >USB hub found [ 10.249544] hub 7-0:1.0: >2 ports detected [ 10.249695] uhci_hcd: USB Universal Host Controller Interface driver [ 10.249782] xen: registering gsi 16 triggering 0 polarity 1 [ 10.249788] Already setup the GSI :16 [ 10.249849] xhci_hcd 0000:02:00.0: >xHCI Host Controller [ 10.249863] xhci_hcd 0000:02:00.0: >new USB bus registered, assigned bus number 8 [ 10.250088] xhci_hcd 0000:02:00.0: >irq 16, io mem 0xfd6f8000 [ 10.250341] usb usb8: >New USB device found, idVendor=1d6b, idProduct=0002 [ 10.250351] usb usb8: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.250360] usb usb8: >Product: xHCI Host Controller [ 10.250367] usb usb8: >Manufacturer: Linux 3.5.0-17-generic xhci_hcd [ 10.250375] usb usb8: >SerialNumber: 0000:02:00.0 [ 10.250591] xHCI xhci_add_endpoint called for root hub [ 10.250595] xHCI xhci_check_bandwidth called for root hub [ 10.250678] hub 8-0:1.0: >USB hub found [ 10.250692] hub 8-0:1.0: >2 ports detected [ 10.250819] xhci_hcd 0000:02:00.0: >xHCI Host Controller [ 10.250830] xhci_hcd 0000:02:00.0: >new USB bus registered, assigned bus number 9 [ 10.250877] usb usb9: >New USB device found, idVendor=1d6b, idProduct=0003 [ 10.250886] usb usb9: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.250895] usb usb9: >Product: xHCI Host Controller [ 10.250903] usb usb9: >Manufacturer: Linux 3.5.0-17-generic xhci_hcd [ 10.250911] usb usb9: >SerialNumber: 0000:02:00.0 [ 10.251089] xHCI xhci_add_endpoint called for root hub [ 10.251093] xHCI xhci_check_bandwidth called for root hub [ 10.251143] hub 9-0:1.0: >USB hub found [ 10.251155] hub 9-0:1.0: >2 ports detected [ 10.251360] xen: registering gsi 19 triggering 0 polarity 1 [ 10.251369] Already setup the GSI :19 [ 10.251438] xhci_hcd 0000:04:00.0: >xHCI Host Controller [ 10.251461] xhci_hcd 0000:04:00.0: >new USB bus registered, assigned bus number 10 [ 10.251653] xhci_hcd 0000:04:00.0: >irq 19, io mem 0xfdcf8000 [ 10.251916] usb usb10: >New USB device found, idVendor=1d6b, idProduct=0002 [ 10.251926] usb usb10: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.251936] usb usb10: >Product: xHCI Host Controller [ 10.251944] usb usb10: >Manufacturer: Linux 3.5.0-17-generic xhci_hcd [ 10.251952] usb usb10: >SerialNumber: 0000:04:00.0 [ 10.252152] xHCI xhci_add_endpoint called for root hub [ 10.252156] xHCI xhci_check_bandwidth called for root hub [ 10.252207] hub 10-0:1.0: >USB hub found [ 10.252221] hub 10-0:1.0: >2 ports detected [ 10.252356] xhci_hcd 0000:04:00.0: >xHCI Host Controller [ 10.252368] xhci_hcd 0000:04:00.0: >new USB bus registered, assigned bus number 11 [ 10.252415] usb usb11: >New USB device found, idVendor=1d6b, idProduct=0003 [ 10.252424] usb usb11: >New USB device strings: Mfr=3, Product=2, SerialNumber=1 [ 10.252433] usb usb11: >Product: xHCI Host Controller [ 10.252441] usb usb11: >Manufacturer: Linux 3.5.0-17-generic xhci_hcd [ 10.252449] usb usb11: >SerialNumber: 0000:04:00.0 [ 10.252618] xHCI xhci_add_endpoint called for root hub [ 10.252622] xHCI xhci_check_bandwidth called for root hub [ 10.252675] hub 11-0:1.0: >USB hub found [ 10.252688] hub 11-0:1.0: >2 ports detected [ 10.253164] usbcore: registered new interface driver libusual [ 10.253255] i8042: PNP: No PS/2 controller found. Probing ports directly. [ 10.287177] i8042: Failed to disable AUX port, but continuing anyway... Is this a SiS? [ 10.287181] i8042: If AUX port is really absent please use the 'i8042.noaux' option [ 10.384667] usb 1-2: >New USB device found, idVendor=1bcf, idProduct=0c31 [ 10.384680] usb 1-2: >New USB device strings: Mfr=2, Product=3, SerialNumber=1 [ 10.384689] usb 1-2: >Product: USB to Serial-ATA bridge [ 10.384697] usb 1-2: >Manufacturer: Sunplus Innovation Technology. [ 10.384705] usb 1-2: >SerialNumber: FFFFFFFE0D007120004347 [ 10.391588] Initializing USB Mass Storage driver... [ 10.392054] scsi4 : usb-storage 1-2:1.0 [ 10.392191] usbcore: registered new interface driver usb-storage [ 10.392199] USB Mass Storage support registered. [ 10.417122] ata2: SATA link up 3.0 Gbps (SStatus 123 SControl 300) [ 10.417164] ata1: SATA link up 3.0 Gbps (SStatus 123 SControl 300) [ 10.417204] ata3: SATA link up 3.0 Gbps (SStatus 123 SControl 300) [ 10.417372] ata1.00: ATA-9: SanDisk SDSSDRC032G, 2.0.0, max UDMA/133 [ 10.417381] ata1.00: 62533296 sectors, multi 1: LBA48 NCQ (depth 31/32) [ 10.417627] ata1.00: configured for UDMA/133 [ 10.418038] scsi 0:0:0:0: >Direct-Access ATA SanDisk SDSSDRC0 2.0. PQ: 0 ANSI: 5 [ 10.418296] sd 0:0:0:0: >[sda] 62533296 512-byte logical blocks: (32.0 GB/29.8 GiB) [ 10.418390] sd 0:0:0:0: >Attached scsi generic sg0 type 0 [ 10.418473] sd 0:0:0:0: >[sda] Write Protect is off [ 10.418483] sd 0:0:0:0: >[sda] Mode Sense: 00 3a 00 00 [ 10.418525] ata3.00: ATA-8: WDC WD10EZRX-00A8LB0, 01.01A01, max UDMA/133 [ 10.418535] sd 0:0:0:0: >[sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA [ 10.418559] ata3.00: 1953525168 sectors, multi 16: LBA48 NCQ (depth 31/32), AA [ 10.418671] ata2.00: ATA-8: WDC WD10EZRX-00A8LB0, 01.01A01, max UDMA/133 [ 10.418682] ata2.00: 1953525168 sectors, multi 16: LBA48 NCQ (depth 31/32), AA [ 10.419351] sda: sda1 sda2 [ 10.419581] ata3.00: configured for UDMA/133 [ 10.419638] ata2.00: configured for UDMA/133 [ 10.420049] sd 0:0:0:0: >[sda] Attached SCSI disk [ 10.420317] scsi 1:0:0:0: >Direct-Access ATA WDC WD10EZRX-00A 01.0 PQ: 0 ANSI: 5 [ 10.420551] sd 1:0:0:0: >[sdb] 1953525168 512-byte logical blocks: (1.00 TB/931 GiB) [ 10.420561] sd 1:0:0:0: >[sdb] 4096-byte physical blocks [ 10.420613] sd 1:0:0:0: >Attached scsi generic sg1 type 0 [ 10.420686] sd 1:0:0:0: >[sdb] Write Protect is off [ 10.420695] sd 1:0:0:0: >[sdb] Mode Sense: 00 3a 00 00 [ 10.420746] sd 1:0:0:0: >[sdb] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA [ 10.537235] serio: i8042 KBD port at 0x60,0x64 irq 1 [ 10.537631] mousedev: PS/2 mouse device common for all mice [ 10.538007] rtc_cmos 00:05: >RTC can wake from S4 [ 10.538301] rtc_cmos 00:05: >rtc core: registered rtc_cmos as rtc0 [ 10.538359] rtc0: alarms up to one month, 242 bytes nvram [ 10.538519] device-mapper: uevent: version 1.0.3 [ 10.538699] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) initialised: dm-devel@redhat.com [ 10.538718] EFI Variables Facility v0.08 2004-May-17 [ 10.539321] ashmem: initialized [ 10.539569] TCP: cubic registered [ 10.539804] NET: Registered protocol family 10 [ 10.540207] NET: Registered protocol family 17 [ 10.540228] Key type dns_resolver registered [ 10.540570] PM: Hibernation image not present or could not be loaded. [ 10.540595] registered taskstats version 1 [ 10.548320] Key type trusted registered [ 10.555790] Key type encrypted registered [ 10.561881] Magic number: 4:775:329 [ 10.561902] tty tty50: >hash matches [ 10.761110] usb 6-1: >new full-speed USB device number 2 using ohci_hcd [ 10.926622] sdb: sdb1 [ 10.927531] sd 1:0:0:0: >[sdb] Attached SCSI disk [ 10.927667] rtc_cmos 00:05: >setting system clock to 2012-11-16 12:18:05 UTC (1353068285) [ 10.927774] scsi 2:0:0:0: >Direct-Access ATA WDC WD10EZRX-00A 01.0 PQ: 0 ANSI: 5 [ 10.927900] powernow-k8: Found 1 AMD FX(tm)-6300 Six-Core Processor (6 cpu cores) (version 2.20.00) [ 10.927954] powernow-k8: Core Performance Boosting: on. [ 10.927988] BIOS EDD facility v0.16 2004-Jun-25, 0 devices found [ 10.927996] EDD information not available. [ 10.928139] sd 2:0:0:0: >[sdc] 1953525168 512-byte logical blocks: (1.00 TB/931 GiB) [ 10.928149] sd 2:0:0:0: >[sdc] 4096-byte physical blocks [ 10.928168] usb 6-1: >New USB device found, idVendor=413c, idProduct=1002 [ 10.928171] sd 2:0:0:0: >Attached scsi generic sg2 type 0 [ 10.928193] usb 6-1: >New USB device strings: Mfr=1, Product=2, SerialNumber=0 [ 10.928208] usb 6-1: >Product: Dell USB Keyboard Hub [ 10.928221] usb 6-1: >Manufacturer: Dell [ 10.928403] sd 2:0:0:0: >[sdc] Write Protect is off [ 10.928417] sd 2:0:0:0: >[sdc] Mode Sense: 00 3a 00 00 [ 10.928525] sd 2:0:0:0: >[sdc] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA [ 10.934198] hub 6-1:1.0: >USB hub found [ 10.936174] hub 6-1:1.0: >3 ports detected [ 11.226217] usb 6-1.1: >new full-speed USB device number 3 using ohci_hcd [ 11.336166] usb 6-1.1: >New USB device found, idVendor=413c, idProduct=2002 [ 11.336179] usb 6-1.1: >New USB device strings: Mfr=1, Product=2, SerialNumber=0 [ 11.336189] usb 6-1.1: >Product: Dell USB Keyboard Hub [ 11.336197] usb 6-1.1: >Manufacturer: Dell [ 11.393327] scsi 4:0:0:0: >CD-ROM Slimtype DVD A DS8A4L 9C41 PQ: 0 ANSI: 0 [ 11.407167] sr0: scsi3-mmc drive: 24x/24x writer dvd-ram cd/rw xa/form2 cdda tray [ 11.407179] cdrom: Uniform CD-ROM driver Revision: 3.20 [ 11.407480] sr 4:0:0:0: >Attached scsi CD-ROM sr0 [ 11.407693] sr 4:0:0:0: >Attached scsi generic sg3 type 5 [ 11.418252] usb 6-1.3: >new low-speed USB device number 4 using ohci_hcd [ 11.452983] sdc: sdc1 [ 11.453850] sd 2:0:0:0: >[sdc] Attached SCSI disk [ 11.455184] Freeing unused kernel memory: 928k freed [ 11.455528] Write protecting the kernel read-only data: 12288k [ 11.473427] Freeing unused kernel memory: 1472k freed [ 11.475540] Freeing unused kernel memory: 1124k freed [ 11.526184] usb 6-1.3: >New USB device found, idVendor=192f, idProduct=0216 [ 11.526202] usb 6-1.3: >New USB device strings: Mfr=0, Product=2, SerialNumber=0 [ 11.526220] usb 6-1.3: >Product: USB Optical Mouse [ 11.570752] udevd[124]: starting version 175 [ 11.597301] md: linear personality registered for level -1 [ 11.605059] md: multipath personality registered for level -4 [ 11.609716] md: raid0 personality registered for level 0 [ 11.622689] md: raid1 personality registered for level 1 [ 11.628765] async_tx: api initialized (async) [ 11.638367] Floppy drive(s): fd0 is unknown type 13 (usb?) [ 11.652741] r8169 Gigabit Ethernet driver 2.3LK-NAPI loaded [ 11.652767] xen: registering gsi 18 triggering 0 polarity 1 [ 11.652773] Already setup the GSI :18 [ 11.653354] r8169 0000:03:00.0: >eth0: RTL8168evl/8111evl at 0xffffc9001109a000, 90:2b:34:a0:54:e6, XID 0c900800 IRQ 89 [ 11.653362] r8169 0000:03:00.0: >eth0: jumbo features [frames: 9200 bytes, tx checksumming: ko] [ 11.656841] FDC 0 is a post-1991 82077 [ 11.668900] scsi5 : pata_atiixp [ 11.669052] scsi6 : pata_atiixp [ 11.670140] ata5: PATA max UDMA/100 cmd 0x1f0 ctl 0x3f6 bmdma 0xfa00 irq 14 [ 11.670157] ata6: PATA max UDMA/100 cmd 0x170 ctl 0x376 bmdma 0xfa08 irq 15 [ 11.689206] usbcore: registered new interface driver usbhid [ 11.689212] usbhid: USB HID core driver [ 11.696273] md: bind [ 11.697022] raid6: sse2x1 4712 MB/s [ 11.755337] md: bind [ 11.757488] bio: create slab at 1 [ 11.757581] md/raid1:md0: not clean -- starting background reconstruction [ 11.757585] md/raid1:md0: active with 2 out of 2 mirrors [ 11.757606] md0: detected capacity change from 0 to 1000068677632 [ 11.757688] md: resync of RAID array md0 [ 11.757694] md: minimum _guaranteed_ speed: 1000 KB/sec/disk. [ 11.757698] md: using maximum available idle IO bandwidth (but not more than 200000 KB/sec) for resync. [ 11.757705] md: using 128k window, over a total of 976629568k. [ 11.765012] raid6: sse2x2 9875 MB/s [ 11.800917] md0: unknown partition table [ 11.833029] raid6: sse2x4 11487 MB/s [ 11.833033] raid6: using algorithm sse2x4 (11487 MB/s) [ 11.833036] raid6: using ssse3x2 recovery algorithm [ 11.850721] xor: automatically using best checksumming function: [ 11.854259] input: Dell Dell USB Keyboard Hub as /devices/pci0000:00/0000:00:13.1/usb6/6-1/6-1.1/6-1.1:1.0/input/input2 [ 11.854386] hid-generic 0003:413C:2002.0001: >input,hidraw0: USB HID v1.10 Keyboard [Dell Dell USB Keyboard Hub] on usb-0000:00:13.1-1.1/input0 [ 11.858193] input: Dell Dell USB Keyboard Hub as /devices/pci0000:00/0000:00:13.1/usb6/6-1/6-1.1/6-1.1:1.1/input/input3 [ 11.858316] hid-generic 0003:413C:2002.0002: >input,hidraw1: USB HID v1.10 Device [Dell Dell USB Keyboard Hub] on usb-0000:00:13.1-1.1/input1 [ 11.858508] input: USB Optical Mouse as /devices/pci0000:00/0000:00:13.1/usb6/6-1/6-1.3/6-1.3:1.0/input/input4 [ 11.858761] hid-generic 0003:192F:0216.0003: >input,hidraw2: USB HID v1.11 Mouse [USB Optical Mouse] on usb-0000:00:13.1-1.3/input0 [ 11.889026] generic_sse: 2853.000 MB/sec [ 11.890412] md: raid6 personality registered for level 6 [ 11.890418] md: raid5 personality registered for level 5 [ 11.890422] md: raid4 personality registered for level 4 [ 11.901128] md: raid10 personality registered for level 10 [ 12.980208] SGI XFS with ACLs, security attributes, realtime, large block/inode numbers, no debug enabled [ 12.983210] XFS (dm-4): Mounting Filesystem [ 13.091194] XFS (dm-4): Starting recovery (logdev: internal) [ 13.467563] XFS (dm-4): Ending recovery (logdev: internal) [ 16.905224] Adding 4194300k swap on /dev/mapper/cnG0-dom0.swap. Priority:-1 extents:1 across:4194300k [ 16.913437] IPv6: ADDRCONF(NETDEV_UP): eth0: link is not ready [ 16.920829] udevd[447]: starting version 175 [ 16.936776] lp: driver loaded but no devices found [ 16.946730] shpchp: Standard Hot Plug PCI Controller Driver version: 0.4 [ 16.956099] wmi: Mapper loaded [ 16.965500] [drm] Initialized drm 1.1.0 20060810 [ 16.966299] parport_pc 00:0a: >reported by Plug and Play ACPI [ 16.966389] parport0: PC-style at 0x378, irq 7 [PCSPP,TRISTATE] [ 16.982451] [drm] VGACON disable radeon kernel modesetting. [ 16.983704] xen: registering gsi 16 triggering 0 polarity 1 [ 16.983710] Already setup the GSI :16 [ 16.985466] xen: registering gsi 18 triggering 0 polarity 1 [ 16.985472] Already setup the GSI :18 [ 16.987000] pci 0000:01:05.0: >setting latency timer to 64 [ 16.987061] [drm] Supports vblank timestamp caching Rev 1 (10.10.2010). [ 16.987063] [drm] No driver support for vblank timestamp query. [ 16.987067] [drm] Initialized radeon 1.33.0 20080528 for 0000:01:05.0 on minor 0 [ 17.028520] type=1400 audit(1353068291.597:2): apparmor="STATUS" operation="profile_load" name="/sbin/dhclient" pid=525 comm="apparmor_parser" [ 17.028842] type=1400 audit(1353068291.597:3): apparmor="STATUS" operation="profile_load" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=525 comm="apparmor_parser" [ 17.029006] type=1400 audit(1353068291.597:4): apparmor="STATUS" operation="profile_load" name="/usr/lib/connman/scripts/dhclient-script" pid=525 comm="apparmor_parser" [ 17.045608] MCE: In-kernel MCE decoding enabled. [ 17.046968] EDAC MC: Ver: 2.1.0 [ 17.053698] AMD64 EDAC driver v3.4.0 [ 17.054261] input: HDA ATI SB Line as /devices/pci0000:00/0000:00:14.2/sound/card0/input5 [ 17.054390] input: HDA ATI SB Front Mic as /devices/pci0000:00/0000:00:14.2/sound/card0/input6 [ 17.054502] input: HDA ATI SB Rear Mic as /devices/pci0000:00/0000:00:14.2/sound/card0/input7 [ 17.054579] input: HDA ATI SB Front Headphone as /devices/pci0000:00/0000:00:14.2/sound/card0/input8 [ 17.054665] input: HDA ATI SB Line Out as /devices/pci0000:00/0000:00:14.2/sound/card0/input9 [ 17.055133] ACPI Warning: 0x0000000000000b00-0x0000000000000b07 SystemIO conflicts with Region \SOR1 1 (20120320/utaddress-251) [ 17.055140] ACPI: If an ACPI driver is available for this device, you should use it instead of the native driver [ 17.055803] sp5100_tco: SP5100 TCO WatchDog Timer Driver v0.01 [ 17.055897] sp5100_tco: mmio address 0xfec000f0 already in use [ 17.056353] EDAC amd64: DRAM ECC disabled. [ 17.056367] EDAC amd64: ECC disabled in the BIOS or no ECC capability, module will not load. [ 17.056367] Either enable ECC checking or force module loading by setting 'ecc_enable_override'. [ 17.056367] (Note that use of the override may cause unknown side effects.) [ 17.056371] xen: registering gsi 19 triggering 0 polarity 1 [ 17.056375] Already setup the GSI :19 [ 17.056492] snd_hda_intel 0000:01:05.1: >setting latency timer to 64 [ 17.061171] lp0: using parport0 (interrupt-driven). [ 17.070118] microcode: CPU0: patch_level=0x00000000 [ 17.164954] ppdev: user-space parallel port driver [ 17.184414] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.184565] microcode: CPU1: patch_level=0x00000000 [ 17.190442] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.190460] microcode: CPU2: patch_level=0x00000000 [ 17.193223] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.193237] microcode: CPU3: patch_level=0x00000000 [ 17.195957] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.195967] microcode: CPU4: patch_level=0x00000000 [ 17.198780] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.198796] microcode: CPU5: patch_level=0x00000000 [ 17.201368] microcode: failed to load file amd-ucode/microcode_amd_fam15h.bin [ 17.201460] microcode: Microcode Update Driver: v2.00 , Peter Oruba [ 17.298208] r8169 0000:03:00.0: >eth0: link down [ 17.298246] r8169 0000:03:00.0: >eth0: link down [ 17.298554] IPv6: ADDRCONF(NETDEV_UP): eth0: link is not ready [ 19.083014] init: udev-fallback-graphics main process (862) terminated with status 1 [ 19.140917] init: plymouth main process (369) killed by ABRT signal [ 19.142456] init: plymouth-splash main process (872) terminated with status 2 [ 19.986969] r8169 0000:03:00.0: >eth0: link up [ 19.987615] IPv6: ADDRCONF(NETDEV_CHANGE): eth0: link becomes ready [ 22.652324] init: plymouth-log main process (891) terminated with status 1 [ 22.675210] init: plymouth-upstart-bridge main process (920) terminated with status 1 [ 29.159063] init: failsafe main process (894) killed by TERM signal [ 29.323900] type=1400 audit(1353068303.893:5): apparmor="STATUS" operation="profile_replace" name="/sbin/dhclient" pid=1064 comm="apparmor_parser" [ 29.324624] type=1400 audit(1353068303.893:6): apparmor="STATUS" operation="profile_replace" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=1064 comm="apparmor_parser" [ 29.325014] type=1400 audit(1353068303.893:7): apparmor="STATUS" operation="profile_replace" name="/usr/lib/connman/scripts/dhclient-script" pid=1064 comm="apparmor_parser" [ 29.325095] type=1400 audit(1353068303.897:8): apparmor="STATUS" operation="profile_load" name="/usr/sbin/tcpdump" pid=1066 comm="apparmor_parser" [ 29.560404] Event-channel device installed. [ 29.962359] init: plymouth-stop pre-start process (1229) terminated with status 1 ==== /proc/cpuinfo ==== processor : 0 vendor_id : AuthenticAMD cpu family : 21 model : 2 model name : AMD FX(tm)-6300 Six-Core Processor stepping : 0 cpu MHz : 3515.588 cache size : 2048 KB fpu : yes fpu_exception : yes cpuid level : 13 wp : yes flags : fpu de tsc msr pae cx8 apic cmov pat clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt lm constant_tsc rep_good nopl nonstop_tsc extd_apicid pni pclmulqdq ssse3 fma cx16 sse4_1 sse4_2 popcnt aes f16c hypervisor lahf_lm cmp_legacy extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch xop fma4 tce tbm perfctr_core arat cpb hw_pstate bogomips : 7031.17 TLB size : 1536 4K pages clflush size : 64 cache_alignment : 64 address sizes : 48 bits physical, 48 bits virtual power management: ts ttp tm 100mhzsteps hwpstate cpb eff_freq_ro ==== wintest.cfg ===== (This has been reconfigured a lot, to test potential LVM issues, and between 4.2 and 4.1.3) builder = "hvm" kernel="/usr/lib/xen-4.1/boot/hvmloader" device_model="/usr/lib/xen-4.1/bin/qemu-dm" name="wintest" memory=2048 vcpus=2 vfb=[ "type=vnc,vnclisten=0.0.0.0,vncdisplay=2,vncpasswd=" ] disk = ["phy:/dev/cnG0/wintest,hda,w","file:/mnt/isos/6001.18000.080118-1840_x86fre_Server_en-us-KRMSFRE_EN_DVD.iso,hdc,r"] boot="cd" usbdevice="tablet" _______________________________________________ Xen-users mailing list Xen-users@lists.xen.org http://lists.xen.org/xen-users From xen-devel-bounces@lists.xen.org Mon Nov 19 15:40:14 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 19 Nov 2012 15:40:14 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaTS3-0005tf-P3; Mon, 19 Nov 2012 15:39:59 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaTS1-0005tV-Mc for xen-devel@lists.xen.org; Mon, 19 Nov 2012 15:39:58 +0000 Received: from [85.158.143.35:61818] by server-3.bemta-4.messagelabs.com id 44/6D-06841-DC25AA05; Mon, 19 Nov 2012 15:39:57 +0000 X-Env-Sender: linux@eikelenboom.it X-Msg-Ref: server-6.tower-21.messagelabs.com!1353339595!18320896!1 X-Originating-IP: [188.40.164.121] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 2958 invoked from network); 19 Nov 2012 15:39:55 -0000 Received: from static.121.164.40.188.clients.your-server.de (HELO smtp.eikelenboom.it) (188.40.164.121) by server-6.tower-21.messagelabs.com with AES256-SHA encrypted SMTP; 19 Nov 2012 15:39:55 -0000 Received: from 136-70-ftth.on.nl ([88.159.70.136]:54160 helo=[172.16.1.20]) by smtp.eikelenboom.it with esmtpsa (TLS1.0:RSA_AES_256_CBC_SHA1:32) (Exim 4.72) (envelope-from ) id 1TaTV0-0004xB-J9; Mon, 19 Nov 2012 16:43:02 +0100 Date: Mon, 19 Nov 2012 16:39:51 +0100 From: Sander Eikelenboom Organization: Eikelenboom IT services X-Priority: 3 (Normal) Message-ID: <368730331.20121119163951@eikelenboom.it> To: "Liu, Jinsong" In-Reply-To: References: <791265057.20121116134056@eikelenboom.it> <20121116160733.GO22320@phenom.dumpdata.com> <1422434855.20121116174754@eikelenboom.it> <20121116165834.GA18725@phenom.dumpdata.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----------0F806B23E04D37875" Cc: "xen-devel@lists.xen.org" , Konrad Rzeszutek Wilk Subject: Re: [Xen-devel] [ 3009.778974] mcelog:16842 map pfn expected mapping type write-back for [mem 0x0009f000-0x000a0fff], got uncached-minus 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 ------------0F806B23E04D37875 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Saturday, November 17, 2012, 3:14:10 PM, you wrote: > Konrad Rzeszutek Wilk wrote: >> On Fri, Nov 16, 2012 at 05:47:54PM +0100, Sander Eikelenboom wrote: >>> >>> Friday, November 16, 2012, 5:07:33 PM, you wrote: >>> >>>> On Fri, Nov 16, 2012 at 01:40:56PM +0100, Sander Eikelenboom wrote: >>>>> Hi Konrad, >>>>> >>>>> Sometime ago i reported this one at boot up: >>>>> >>>>> [ 3009.778974] mcelog:16842 map pfn expected mapping type >>>>> write-back for [mem 0x0009f000-0x000a0fff], got uncached-minus [ >>>>> 3009.788570] ------------[ cut here ]------------ [ 3009.798175] >>>>> WARNING: at arch/x86/mm/pat.c:774 untrack_pfn+0xa1/0xb0() [ >>>>> 3009.807966] Hardware name: MS-7640 [ 3009.817677] Modules linked >>>>> in: [ 3009.827524] Pid: 16842, comm: mcelog Tainted: G W >>>>> 3.7.0-rc5-20121116-reverted-persistent-warn-patwarn #1 [ >>>>> 3009.837415] Call Trace: [ 3009.847110] [] >>>>> warn_slowpath_common+0x7a/0xb0 [ 3009.856857] >>>>> [] warn_slowpath_null+0x15/0x20 [ 3009.866562] >>>>> [] untrack_pfn+0xa1/0xb0 [ 3009.876201] >>>>> [] unmap_single_vma+0x86b/0x8e0 [ 3009.885895] >>>>> [] ? release_pages+0x196/0x1f0 [ 3009.895488] >>>>> [] unmap_vmas+0x4c/0xa0 [ 3009.905134] >>>>> [] exit_mmap+0x9a/0x180 [ 3009.914706] >>>>> [] mmput+0x52/0xd0 [ 3009.924252] >>>>> [] dup_mm+0x3c7/0x510 [ 3009.933839] >>>>> [] copy_process+0xac5/0x14a0 [ 3009.943430] >>>>> [] do_fork+0x53/0x360 [ 3009.952843] >>>>> [] ? lock_release+0x117/0x250 [ 3009.962283] >>>>> [] ? _raw_spin_unlock+0x30/0x60 [ 3009.971532] >>>>> [] ? sysret_check+0x22/0x5d [ 3009.980820] >>>>> [] sys_clone+0x23/0x30 [ 3009.990046] >>>>> [] stub_clone+0x13/0x20 [ 3009.999335] >>>>> [] ? system_call_fastpath+0x16/0x1b [ >>>>> 3010.008667] ---[ end trace 2d9694c2c0a24da8 ]--- >>>>> >>>>> >>>>> It seems to be due to the "mcelog" userspace tool provided with >>>>> Debian Squeeze (mcelog 1.0~pre3-3 x86-64 Machine Check Exceptions >>>>> collector and decoder). I can trigger this warning easily by >>>>> restarting the mcelog tool with /etc/init.d/mcelog restart >>>>> >>>>> Should that one also function with the xen mcelog driver, or is a >>>>> newer version required ? >>> >>>> The reason we get is b/c I had to disable the PAT functionality in >>>> the Linux kernel for Xen. This is b/c it only worked one way - >>>> meaning you could convert a page from >>>> WriteBack to WriteCombine or WriteBack to Uncached. But you could >>>> not >>>> do WriteCombine back to WriteBack - due to one of the functions that >>>> changes the bits was using an "unfiltered" way to identify the bits >>>> on the >>>> page. >>> >>>> Anyhow, we had a disaster b/c some of these pages that used to >>>> WriteBack (WB) >>>> got converted to WriteCombine (WC) and then were returned back as >>>> such >>>> to the page pool. And if they were re-used by filesystem invariably >>>> we got >>>> corruptions. >>> >>>> So until the PAT table lookup thing that Peter H. Anvin suggested >>>> gets implemented this splat gotta show up :-( >>> >>> Not a big problem for me, i was just wondering :-) >>> I'm more interested in the netfront troubles, since it's already rc5. >>> >>>> Does mcelog still work even with this warning? >>> >>> Not the daemon: >>> >>> serveerstertje:~# sh /etc/init.d/mcelog start >>> Starting Machine Check Exceptions decoder: daemon: Cannot allocate >>> memory >>> >> Ugh. >> CC-ing Liu here. >> > How to reproduce it (sorry I miss the history of this thread)? > I have a try at Xen side, w/ kernel 3.6.0-rc7+, no problem at my side. I'm using: - Xen-unstable, latest changeset=26152 - Linux 3.7.0-rc5 kernel latest changeset=79e979eae0df58831e85281e3285f63663f3cf76 - Dom0 OS = Debian Squeeze - mcelog package: 1.0~pre3-3 x86-64 Machine Check Exceptions collector and decoder) I don't have particular interest in mcelog, but i just encountered this warn on boot. The warn (see above) is shown when the mcelog daemon (from the debian package) tries to start (for example on boot) I have attached the .config from the used kernel. If you need any more info, please ask ! -- Sander > Thanks, > Jinsong >>> >>>>> >>>>> -- >>>>> Sander ------------0F806B23E04D37875 Content-Type: application/octet-stream; name=dotconfig Content-transfer-encoding: base64 Content-Disposition: attachment; filename=dotconfig IwojIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGZpbGU7IERPIE5PVCBFRElULgojIExpbnV4 L3g4Nl82NCAzLjcuMC1yYzUtMjAxMjExMTYtcmV2ZXJ0ZWQtcGVyc2lzdGVudC1idCBLZXJu ZWwgQ29uZmlndXJhdGlvbgojCkNPTkZJR182NEJJVD15CkNPTkZJR19YODZfNjQ9eQpDT05G SUdfWDg2PXkKQ09ORklHX0lOU1RSVUNUSU9OX0RFQ09ERVI9eQpDT05GSUdfT1VUUFVUX0ZP Uk1BVD0iZWxmNjQteDg2LTY0IgpDT05GSUdfQVJDSF9ERUZDT05GSUc9ImFyY2gveDg2L2Nv bmZpZ3MveDg2XzY0X2RlZmNvbmZpZyIKQ09ORklHX0xPQ0tERVBfU1VQUE9SVD15CkNPTkZJ R19TVEFDS1RSQUNFX1NVUFBPUlQ9eQpDT05GSUdfSEFWRV9MQVRFTkNZVE9QX1NVUFBPUlQ9 eQpDT05GSUdfTU1VPXkKQ09ORklHX05FRURfRE1BX01BUF9TVEFURT15CkNPTkZJR19ORUVE X1NHX0RNQV9MRU5HVEg9eQpDT05GSUdfR0VORVJJQ19JU0FfRE1BPXkKQ09ORklHX0dFTkVS SUNfQlVHPXkKQ09ORklHX0dFTkVSSUNfQlVHX1JFTEFUSVZFX1BPSU5URVJTPXkKQ09ORklH X0dFTkVSSUNfSFdFSUdIVD15CkNPTkZJR19BUkNIX01BWV9IQVZFX1BDX0ZEQz15CkNPTkZJ R19SV1NFTV9YQ0hHQUREX0FMR09SSVRITT15CkNPTkZJR19HRU5FUklDX0NBTElCUkFURV9E RUxBWT15CkNPTkZJR19BUkNIX0hBU19DUFVfUkVMQVg9eQpDT05GSUdfQVJDSF9IQVNfREVG QVVMVF9JRExFPXkKQ09ORklHX0FSQ0hfSEFTX0NBQ0hFX0xJTkVfU0laRT15CkNPTkZJR19B UkNIX0hBU19DUFVfQVVUT1BST0JFPXkKQ09ORklHX0hBVkVfU0VUVVBfUEVSX0NQVV9BUkVB PXkKQ09ORklHX05FRURfUEVSX0NQVV9FTUJFRF9GSVJTVF9DSFVOSz15CkNPTkZJR19ORUVE X1BFUl9DUFVfUEFHRV9GSVJTVF9DSFVOSz15CkNPTkZJR19BUkNIX0hJQkVSTkFUSU9OX1BP U1NJQkxFPXkKQ09ORklHX0FSQ0hfU1VTUEVORF9QT1NTSUJMRT15CkNPTkZJR19aT05FX0RN QTMyPXkKQ09ORklHX0FVRElUX0FSQ0g9eQpDT05GSUdfQVJDSF9TVVBQT1JUU19PUFRJTUla RURfSU5MSU5JTkc9eQpDT05GSUdfQVJDSF9TVVBQT1JUU19ERUJVR19QQUdFQUxMT0M9eQpD T05GSUdfWDg2XzY0X1NNUD15CkNPTkZJR19YODZfSFQ9eQpDT05GSUdfQVJDSF9IV0VJR0hU X0NGTEFHUz0iLWZjYWxsLXNhdmVkLXJkaSAtZmNhbGwtc2F2ZWQtcnNpIC1mY2FsbC1zYXZl ZC1yZHggLWZjYWxsLXNhdmVkLXJjeCAtZmNhbGwtc2F2ZWQtcjggLWZjYWxsLXNhdmVkLXI5 IC1mY2FsbC1zYXZlZC1yMTAgLWZjYWxsLXNhdmVkLXIxMSIKQ09ORklHX0FSQ0hfQ1BVX1BS T0JFX1JFTEVBU0U9eQpDT05GSUdfQVJDSF9TVVBQT1JUU19VUFJPQkVTPXkKQ09ORklHX0RF RkNPTkZJR19MSVNUPSIvbGliL21vZHVsZXMvJFVOQU1FX1JFTEVBU0UvLmNvbmZpZyIKQ09O RklHX0hBVkVfSVJRX1dPUks9eQpDT05GSUdfSVJRX1dPUks9eQpDT05GSUdfQlVJTERUSU1F X0VYVEFCTEVfU09SVD15CgojCiMgR2VuZXJhbCBzZXR1cAojCkNPTkZJR19FWFBFUklNRU5U QUw9eQpDT05GSUdfSU5JVF9FTlZfQVJHX0xJTUlUPTMyCkNPTkZJR19DUk9TU19DT01QSUxF PSIiCkNPTkZJR19MT0NBTFZFUlNJT049IiIKIyBDT05GSUdfTE9DQUxWRVJTSU9OX0FVVE8g aXMgbm90IHNldApDT05GSUdfSEFWRV9LRVJORUxfR1pJUD15CkNPTkZJR19IQVZFX0tFUk5F TF9CWklQMj15CkNPTkZJR19IQVZFX0tFUk5FTF9MWk1BPXkKQ09ORklHX0hBVkVfS0VSTkVM X1haPXkKQ09ORklHX0hBVkVfS0VSTkVMX0xaTz15CkNPTkZJR19LRVJORUxfR1pJUD15CiMg Q09ORklHX0tFUk5FTF9CWklQMiBpcyBub3Qgc2V0CiMgQ09ORklHX0tFUk5FTF9MWk1BIGlz IG5vdCBzZXQKIyBDT05GSUdfS0VSTkVMX1haIGlzIG5vdCBzZXQKIyBDT05GSUdfS0VSTkVM X0xaTyBpcyBub3Qgc2V0CkNPTkZJR19ERUZBVUxUX0hPU1ROQU1FPSIobm9uZSkiCkNPTkZJ R19TV0FQPXkKQ09ORklHX1NZU1ZJUEM9eQpDT05GSUdfU1lTVklQQ19TWVNDVEw9eQojIENP TkZJR19QT1NJWF9NUVVFVUUgaXMgbm90IHNldAojIENPTkZJR19GSEFORExFIGlzIG5vdCBz ZXQKQ09ORklHX0FVRElUPXkKQ09ORklHX0FVRElUU1lTQ0FMTD15CkNPTkZJR19BVURJVF9X QVRDSD15CkNPTkZJR19BVURJVF9UUkVFPXkKIyBDT05GSUdfQVVESVRfTE9HSU5VSURfSU1N VVRBQkxFIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVfR0VORVJJQ19IQVJESVJRUz15CgojCiMg SVJRIHN1YnN5c3RlbQojCkNPTkZJR19HRU5FUklDX0hBUkRJUlFTPXkKQ09ORklHX0dFTkVS SUNfSVJRX1BST0JFPXkKQ09ORklHX0dFTkVSSUNfSVJRX1NIT1c9eQpDT05GSUdfR0VORVJJ Q19QRU5ESU5HX0lSUT15CkNPTkZJR19JUlFfRE9NQUlOPXkKIyBDT05GSUdfSVJRX0RPTUFJ Tl9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19JUlFfRk9SQ0VEX1RIUkVBRElORz15CkNPTkZJ R19TUEFSU0VfSVJRPXkKQ09ORklHX0NMT0NLU09VUkNFX1dBVENIRE9HPXkKQ09ORklHX0FS Q0hfQ0xPQ0tTT1VSQ0VfREFUQT15CkNPTkZJR19HRU5FUklDX1RJTUVfVlNZU0NBTEw9eQpD T05GSUdfR0VORVJJQ19DTE9DS0VWRU5UUz15CkNPTkZJR19HRU5FUklDX0NMT0NLRVZFTlRT X0JVSUxEPXkKQ09ORklHX0dFTkVSSUNfQ0xPQ0tFVkVOVFNfQlJPQURDQVNUPXkKQ09ORklH X0dFTkVSSUNfQ0xPQ0tFVkVOVFNfTUlOX0FESlVTVD15CkNPTkZJR19HRU5FUklDX0NNT1Nf VVBEQVRFPXkKCiMKIyBUaW1lcnMgc3Vic3lzdGVtCiMKQ09ORklHX1RJQ0tfT05FU0hPVD15 CkNPTkZJR19OT19IWj15CkNPTkZJR19ISUdIX1JFU19USU1FUlM9eQoKIwojIENQVS9UYXNr IHRpbWUgYW5kIHN0YXRzIGFjY291bnRpbmcKIwpDT05GSUdfVElDS19DUFVfQUNDT1VOVElO Rz15CiMgQ09ORklHX0lSUV9USU1FX0FDQ09VTlRJTkcgaXMgbm90IHNldApDT05GSUdfQlNE X1BST0NFU1NfQUNDVD15CiMgQ09ORklHX0JTRF9QUk9DRVNTX0FDQ1RfVjMgaXMgbm90IHNl dApDT05GSUdfVEFTS1NUQVRTPXkKQ09ORklHX1RBU0tfREVMQVlfQUNDVD15CkNPTkZJR19U QVNLX1hBQ0NUPXkKQ09ORklHX1RBU0tfSU9fQUNDT1VOVElORz15CgojCiMgUkNVIFN1YnN5 c3RlbQojCkNPTkZJR19UUkVFX1BSRUVNUFRfUkNVPXkKQ09ORklHX1BSRUVNUFRfUkNVPXkK IyBDT05GSUdfUkNVX1VTRVJfUVMgaXMgbm90IHNldApDT05GSUdfUkNVX0ZBTk9VVD02NApD T05GSUdfUkNVX0ZBTk9VVF9MRUFGPTE2CiMgQ09ORklHX1JDVV9GQU5PVVRfRVhBQ1QgaXMg bm90IHNldApDT05GSUdfUkNVX0ZBU1RfTk9fSFo9eQojIENPTkZJR19UUkVFX1JDVV9UUkFD RSBpcyBub3Qgc2V0CkNPTkZJR19SQ1VfQk9PU1Q9eQpDT05GSUdfUkNVX0JPT1NUX1BSSU89 MQpDT05GSUdfUkNVX0JPT1NUX0RFTEFZPTUwMApDT05GSUdfSUtDT05GSUc9eQojIENPTkZJ R19JS0NPTkZJR19QUk9DIGlzIG5vdCBzZXQKQ09ORklHX0xPR19CVUZfU0hJRlQ9MTgKQ09O RklHX0hBVkVfVU5TVEFCTEVfU0NIRURfQ0xPQ0s9eQpDT05GSUdfQ0dST1VQUz15CiMgQ09O RklHX0NHUk9VUF9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19DR1JPVVBfRlJFRVpFUj15CiMg Q09ORklHX0NHUk9VUF9ERVZJQ0UgaXMgbm90IHNldApDT05GSUdfQ1BVU0VUUz15CkNPTkZJ R19QUk9DX1BJRF9DUFVTRVQ9eQpDT05GSUdfQ0dST1VQX0NQVUFDQ1Q9eQpDT05GSUdfUkVT T1VSQ0VfQ09VTlRFUlM9eQojIENPTkZJR19NRU1DRyBpcyBub3Qgc2V0CiMgQ09ORklHX0NH Uk9VUF9IVUdFVExCIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0dST1VQX1BFUkYgaXMgbm90IHNl dApDT05GSUdfQ0dST1VQX1NDSEVEPXkKQ09ORklHX0ZBSVJfR1JPVVBfU0NIRUQ9eQojIENP TkZJR19DRlNfQkFORFdJRFRIIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRfR1JPVVBfU0NIRUQg aXMgbm90IHNldApDT05GSUdfQkxLX0NHUk9VUD15CiMgQ09ORklHX0RFQlVHX0JMS19DR1JP VVAgaXMgbm90IHNldAojIENPTkZJR19DSEVDS1BPSU5UX1JFU1RPUkUgaXMgbm90IHNldApD T05GSUdfTkFNRVNQQUNFUz15CkNPTkZJR19VVFNfTlM9eQpDT05GSUdfSVBDX05TPXkKQ09O RklHX1BJRF9OUz15CkNPTkZJR19ORVRfTlM9eQpDT05GSUdfU0NIRURfQVVUT0dST1VQPXkK IyBDT05GSUdfU1lTRlNfREVQUkVDQVRFRCBpcyBub3Qgc2V0CiMgQ09ORklHX1JFTEFZIGlz IG5vdCBzZXQKQ09ORklHX0JMS19ERVZfSU5JVFJEPXkKQ09ORklHX0lOSVRSQU1GU19TT1VS Q0U9IiIKQ09ORklHX1JEX0daSVA9eQpDT05GSUdfUkRfQlpJUDI9eQpDT05GSUdfUkRfTFpN QT15CkNPTkZJR19SRF9YWj15CkNPTkZJR19SRF9MWk89eQojIENPTkZJR19DQ19PUFRJTUla RV9GT1JfU0laRSBpcyBub3Qgc2V0CkNPTkZJR19TWVNDVEw9eQpDT05GSUdfQU5PTl9JTk9E RVM9eQojIENPTkZJR19FWFBFUlQgaXMgbm90IHNldApDT05GSUdfSEFWRV9VSUQxNj15CkNP TkZJR19VSUQxNj15CiMgQ09ORklHX1NZU0NUTF9TWVNDQUxMIGlzIG5vdCBzZXQKQ09ORklH X1NZU0NUTF9FWENFUFRJT05fVFJBQ0U9eQpDT05GSUdfS0FMTFNZTVM9eQpDT05GSUdfS0FM TFNZTVNfQUxMPXkKQ09ORklHX0hPVFBMVUc9eQpDT05GSUdfUFJJTlRLPXkKQ09ORklHX0JV Rz15CkNPTkZJR19FTEZfQ09SRT15CkNPTkZJR19QQ1NQS1JfUExBVEZPUk09eQpDT05GSUdf SEFWRV9QQ1NQS1JfUExBVEZPUk09eQpDT05GSUdfQkFTRV9GVUxMPXkKQ09ORklHX0ZVVEVY PXkKQ09ORklHX0VQT0xMPXkKQ09ORklHX1NJR05BTEZEPXkKQ09ORklHX1RJTUVSRkQ9eQpD T05GSUdfRVZFTlRGRD15CkNPTkZJR19TSE1FTT15CkNPTkZJR19BSU89eQojIENPTkZJR19F TUJFRERFRCBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX1BFUkZfRVZFTlRTPXkKCiMKIyBLZXJu ZWwgUGVyZm9ybWFuY2UgRXZlbnRzIEFuZCBDb3VudGVycwojCkNPTkZJR19QRVJGX0VWRU5U Uz15CiMgQ09ORklHX0RFQlVHX1BFUkZfVVNFX1ZNQUxMT0MgaXMgbm90IHNldApDT05GSUdf Vk1fRVZFTlRfQ09VTlRFUlM9eQpDT05GSUdfUENJX1FVSVJLUz15CkNPTkZJR19TTFVCX0RF QlVHPXkKIyBDT05GSUdfQ09NUEFUX0JSSyBpcyBub3Qgc2V0CiMgQ09ORklHX1NMQUIgaXMg bm90IHNldApDT05GSUdfU0xVQj15CiMgQ09ORklHX1BST0ZJTElORyBpcyBub3Qgc2V0CkNP TkZJR19IQVZFX09QUk9GSUxFPXkKQ09ORklHX09QUk9GSUxFX05NSV9USU1FUj15CiMgQ09O RklHX0tQUk9CRVMgaXMgbm90IHNldApDT05GSUdfSlVNUF9MQUJFTD15CkNPTkZJR19IQVZF X0VGRklDSUVOVF9VTkFMSUdORURfQUNDRVNTPXkKQ09ORklHX0hBVkVfSU9SRU1BUF9QUk9U PXkKQ09ORklHX0hBVkVfS1BST0JFUz15CkNPTkZJR19IQVZFX0tSRVRQUk9CRVM9eQpDT05G SUdfSEFWRV9PUFRQUk9CRVM9eQpDT05GSUdfSEFWRV9BUkNIX1RSQUNFSE9PSz15CkNPTkZJ R19IQVZFX0RNQV9BVFRSUz15CkNPTkZJR19VU0VfR0VORVJJQ19TTVBfSEVMUEVSUz15CkNP TkZJR19HRU5FUklDX1NNUF9JRExFX1RIUkVBRD15CkNPTkZJR19IQVZFX1JFR1NfQU5EX1NU QUNLX0FDQ0VTU19BUEk9eQpDT05GSUdfSEFWRV9ETUFfQVBJX0RFQlVHPXkKQ09ORklHX0hB VkVfSFdfQlJFQUtQT0lOVD15CkNPTkZJR19IQVZFX01JWEVEX0JSRUFLUE9JTlRTX1JFR1M9 eQpDT05GSUdfSEFWRV9VU0VSX1JFVFVSTl9OT1RJRklFUj15CkNPTkZJR19IQVZFX1BFUkZf RVZFTlRTX05NST15CkNPTkZJR19IQVZFX1BFUkZfUkVHUz15CkNPTkZJR19IQVZFX1BFUkZf VVNFUl9TVEFDS19EVU1QPXkKQ09ORklHX0hBVkVfQVJDSF9KVU1QX0xBQkVMPXkKQ09ORklH X0FSQ0hfSEFWRV9OTUlfU0FGRV9DTVBYQ0hHPXkKQ09ORklHX0hBVkVfQUxJR05FRF9TVFJV Q1RfUEFHRT15CkNPTkZJR19IQVZFX0NNUFhDSEdfTE9DQUw9eQpDT05GSUdfSEFWRV9DTVBY Q0hHX0RPVUJMRT15CkNPTkZJR19BUkNIX1dBTlRfQ09NUEFUX0lQQ19QQVJTRV9WRVJTSU9O PXkKQ09ORklHX0FSQ0hfV0FOVF9PTERfQ09NUEFUX0lQQz15CkNPTkZJR19HRU5FUklDX0tF Uk5FTF9USFJFQUQ9eQpDT05GSUdfR0VORVJJQ19LRVJORUxfRVhFQ1ZFPXkKQ09ORklHX0hB VkVfQVJDSF9TRUNDT01QX0ZJTFRFUj15CkNPTkZJR19TRUNDT01QX0ZJTFRFUj15CkNPTkZJ R19IQVZFX1JDVV9VU0VSX1FTPXkKQ09ORklHX0hBVkVfSVJRX1RJTUVfQUNDT1VOVElORz15 CkNPTkZJR19IQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0U9eQpDT05GSUdfTU9EVUxF U19VU0VfRUxGX1JFTEE9eQoKIwojIEdDT1YtYmFzZWQga2VybmVsIHByb2ZpbGluZwojCiMg Q09ORklHX0dDT1ZfS0VSTkVMIGlzIG5vdCBzZXQKIyBDT05GSUdfSEFWRV9HRU5FUklDX0RN QV9DT0hFUkVOVCBpcyBub3Qgc2V0CkNPTkZJR19TTEFCSU5GTz15CkNPTkZJR19SVF9NVVRF WEVTPXkKQ09ORklHX0JBU0VfU01BTEw9MApDT05GSUdfTU9EVUxFUz15CiMgQ09ORklHX01P RFVMRV9GT1JDRV9MT0FEIGlzIG5vdCBzZXQKQ09ORklHX01PRFVMRV9VTkxPQUQ9eQojIENP TkZJR19NT0RVTEVfRk9SQ0VfVU5MT0FEIGlzIG5vdCBzZXQKIyBDT05GSUdfTU9EVkVSU0lP TlMgaXMgbm90IHNldAojIENPTkZJR19NT0RVTEVfU1JDVkVSU0lPTl9BTEwgaXMgbm90IHNl dAojIENPTkZJR19NT0RVTEVfU0lHIGlzIG5vdCBzZXQKQ09ORklHX1NUT1BfTUFDSElORT15 CkNPTkZJR19CTE9DSz15CkNPTkZJR19CTEtfREVWX0JTRz15CiMgQ09ORklHX0JMS19ERVZf QlNHTElCIGlzIG5vdCBzZXQKQ09ORklHX0JMS19ERVZfSU5URUdSSVRZPXkKIyBDT05GSUdf QkxLX0RFVl9USFJPVFRMSU5HIGlzIG5vdCBzZXQKCiMKIyBQYXJ0aXRpb24gVHlwZXMKIwpD T05GSUdfUEFSVElUSU9OX0FEVkFOQ0VEPXkKIyBDT05GSUdfQUNPUk5fUEFSVElUSU9OIGlz IG5vdCBzZXQKQ09ORklHX09TRl9QQVJUSVRJT049eQpDT05GSUdfQU1JR0FfUEFSVElUSU9O PXkKIyBDT05GSUdfQVRBUklfUEFSVElUSU9OIGlzIG5vdCBzZXQKQ09ORklHX01BQ19QQVJU SVRJT049eQpDT05GSUdfTVNET1NfUEFSVElUSU9OPXkKQ09ORklHX0JTRF9ESVNLTEFCRUw9 eQpDT05GSUdfTUlOSVhfU1VCUEFSVElUSU9OPXkKQ09ORklHX1NPTEFSSVNfWDg2X1BBUlRJ VElPTj15CkNPTkZJR19VTklYV0FSRV9ESVNLTEFCRUw9eQojIENPTkZJR19MRE1fUEFSVElU SU9OIGlzIG5vdCBzZXQKQ09ORklHX1NHSV9QQVJUSVRJT049eQojIENPTkZJR19VTFRSSVhf UEFSVElUSU9OIGlzIG5vdCBzZXQKQ09ORklHX1NVTl9QQVJUSVRJT049eQpDT05GSUdfS0FS TUFfUEFSVElUSU9OPXkKQ09ORklHX0VGSV9QQVJUSVRJT049eQojIENPTkZJR19TWVNWNjhf UEFSVElUSU9OIGlzIG5vdCBzZXQKQ09ORklHX0JMT0NLX0NPTVBBVD15CgojCiMgSU8gU2No ZWR1bGVycwojCkNPTkZJR19JT1NDSEVEX05PT1A9eQpDT05GSUdfSU9TQ0hFRF9ERUFETElO RT15CkNPTkZJR19JT1NDSEVEX0NGUT15CkNPTkZJR19DRlFfR1JPVVBfSU9TQ0hFRD15CiMg Q09ORklHX0RFRkFVTFRfREVBRExJTkUgaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9DRlE9 eQojIENPTkZJR19ERUZBVUxUX05PT1AgaXMgbm90IHNldApDT05GSUdfREVGQVVMVF9JT1ND SEVEPSJjZnEiCkNPTkZJR19VTklOTElORV9TUElOX1VOTE9DSz15CkNPTkZJR19GUkVFWkVS PXkKCiMKIyBQcm9jZXNzb3IgdHlwZSBhbmQgZmVhdHVyZXMKIwpDT05GSUdfWk9ORV9ETUE9 eQpDT05GSUdfU01QPXkKQ09ORklHX1g4Nl9NUFBBUlNFPXkKQ09ORklHX1g4Nl9FWFRFTkRF RF9QTEFURk9STT15CiMgQ09ORklHX1g4Nl9WU01QIGlzIG5vdCBzZXQKQ09ORklHX1g4Nl9T VVBQT1JUU19NRU1PUllfRkFJTFVSRT15CkNPTkZJR19TQ0hFRF9PTUlUX0ZSQU1FX1BPSU5U RVI9eQpDT05GSUdfUEFSQVZJUlRfR1VFU1Q9eQojIENPTkZJR19QQVJBVklSVF9USU1FX0FD Q09VTlRJTkcgaXMgbm90IHNldApDT05GSUdfWEVOPXkKQ09ORklHX1hFTl9ET00wPXkKQ09O RklHX1hFTl9QUklWSUxFR0VEX0dVRVNUPXkKQ09ORklHX1hFTl9QVkhWTT15CkNPTkZJR19Y RU5fTUFYX0RPTUFJTl9NRU1PUlk9NTAwCkNPTkZJR19YRU5fU0FWRV9SRVNUT1JFPXkKQ09O RklHX1hFTl9ERUJVR19GUz15CiMgQ09ORklHX0tWTV9HVUVTVCBpcyBub3Qgc2V0CkNPTkZJ R19QQVJBVklSVD15CiMgQ09ORklHX1BBUkFWSVJUX1NQSU5MT0NLUyBpcyBub3Qgc2V0CkNP TkZJR19QQVJBVklSVF9DTE9DSz15CkNPTkZJR19QQVJBVklSVF9ERUJVRz15CkNPTkZJR19O T19CT09UTUVNPXkKIyBDT05GSUdfTUVNVEVTVCBpcyBub3Qgc2V0CkNPTkZJR19NSzg9eQoj IENPTkZJR19NUFNDIGlzIG5vdCBzZXQKIyBDT05GSUdfTUNPUkUyIGlzIG5vdCBzZXQKIyBD T05GSUdfTUFUT00gaXMgbm90IHNldAojIENPTkZJR19HRU5FUklDX0NQVSBpcyBub3Qgc2V0 CkNPTkZJR19YODZfSU5URVJOT0RFX0NBQ0hFX1NISUZUPTYKQ09ORklHX1g4Nl9DTVBYQ0hH PXkKQ09ORklHX1g4Nl9MMV9DQUNIRV9TSElGVD02CkNPTkZJR19YODZfWEFERD15CkNPTkZJ R19YODZfV1BfV09SS1NfT0s9eQpDT05GSUdfWDg2X0lOVEVMX1VTRVJDT1BZPXkKQ09ORklH X1g4Nl9VU0VfUFBST19DSEVDS1NVTT15CkNPTkZJR19YODZfVFNDPXkKQ09ORklHX1g4Nl9D TVBYQ0hHNjQ9eQpDT05GSUdfWDg2X0NNT1Y9eQpDT05GSUdfWDg2X01JTklNVU1fQ1BVX0ZB TUlMWT02NApDT05GSUdfWDg2X0RFQlVHQ1RMTVNSPXkKQ09ORklHX0NQVV9TVVBfSU5URUw9 eQpDT05GSUdfQ1BVX1NVUF9BTUQ9eQpDT05GSUdfQ1BVX1NVUF9DRU5UQVVSPXkKQ09ORklH X0hQRVRfVElNRVI9eQpDT05GSUdfSFBFVF9FTVVMQVRFX1JUQz15CkNPTkZJR19ETUk9eQpD T05GSUdfR0FSVF9JT01NVT15CiMgQ09ORklHX0NBTEdBUllfSU9NTVUgaXMgbm90IHNldApD T05GSUdfU1dJT1RMQj15CkNPTkZJR19JT01NVV9IRUxQRVI9eQojIENPTkZJR19NQVhTTVAg aXMgbm90IHNldApDT05GSUdfTlJfQ1BVUz04CkNPTkZJR19TQ0hFRF9TTVQ9eQpDT05GSUdf U0NIRURfTUM9eQojIENPTkZJR19QUkVFTVBUX05PTkUgaXMgbm90IHNldAojIENPTkZJR19Q UkVFTVBUX1ZPTFVOVEFSWSBpcyBub3Qgc2V0CkNPTkZJR19QUkVFTVBUPXkKQ09ORklHX1BS RUVNUFRfQ09VTlQ9eQpDT05GSUdfWDg2X0xPQ0FMX0FQSUM9eQpDT05GSUdfWDg2X0lPX0FQ SUM9eQpDT05GSUdfWDg2X1JFUk9VVEVfRk9SX0JST0tFTl9CT09UX0lSUVM9eQpDT05GSUdf WDg2X01DRT15CkNPTkZJR19YODZfTUNFX0lOVEVMPXkKQ09ORklHX1g4Nl9NQ0VfQU1EPXkK Q09ORklHX1g4Nl9NQ0VfVEhSRVNIT0xEPXkKIyBDT05GSUdfWDg2X01DRV9JTkpFQ1QgaXMg bm90IHNldApDT05GSUdfWDg2X1RIRVJNQUxfVkVDVE9SPXkKIyBDT05GSUdfSThLIGlzIG5v dCBzZXQKIyBDT05GSUdfTUlDUk9DT0RFIGlzIG5vdCBzZXQKQ09ORklHX1g4Nl9NU1I9eQpD T05GSUdfWDg2X0NQVUlEPXkKQ09ORklHX0FSQ0hfUEhZU19BRERSX1RfNjRCSVQ9eQpDT05G SUdfQVJDSF9ETUFfQUREUl9UXzY0QklUPXkKQ09ORklHX0RJUkVDVF9HQlBBR0VTPXkKQ09O RklHX05VTUE9eQpDT05GSUdfQU1EX05VTUE9eQpDT05GSUdfWDg2XzY0X0FDUElfTlVNQT15 CkNPTkZJR19OT0RFU19TUEFOX09USEVSX05PREVTPXkKIyBDT05GSUdfTlVNQV9FTVUgaXMg bm90IHNldApDT05GSUdfTk9ERVNfU0hJRlQ9OApDT05GSUdfQVJDSF9TUEFSU0VNRU1fRU5B QkxFPXkKQ09ORklHX0FSQ0hfU1BBUlNFTUVNX0RFRkFVTFQ9eQpDT05GSUdfQVJDSF9TRUxF Q1RfTUVNT1JZX01PREVMPXkKQ09ORklHX0FSQ0hfUFJPQ19LQ09SRV9URVhUPXkKQ09ORklH X0lMTEVHQUxfUE9JTlRFUl9WQUxVRT0weGRlYWQwMDAwMDAwMDAwMDAKQ09ORklHX1NFTEVD VF9NRU1PUllfTU9ERUw9eQpDT05GSUdfU1BBUlNFTUVNX01BTlVBTD15CkNPTkZJR19TUEFS U0VNRU09eQpDT05GSUdfTkVFRF9NVUxUSVBMRV9OT0RFUz15CkNPTkZJR19IQVZFX01FTU9S WV9QUkVTRU5UPXkKQ09ORklHX1NQQVJTRU1FTV9FWFRSRU1FPXkKQ09ORklHX1NQQVJTRU1F TV9WTUVNTUFQX0VOQUJMRT15CkNPTkZJR19TUEFSU0VNRU1fQUxMT0NfTUVNX01BUF9UT0dF VEhFUj15CkNPTkZJR19TUEFSU0VNRU1fVk1FTU1BUD15CkNPTkZJR19IQVZFX01FTUJMT0NL PXkKQ09ORklHX0hBVkVfTUVNQkxPQ0tfTk9ERV9NQVA9eQpDT05GSUdfQVJDSF9ESVNDQVJE X01FTUJMT0NLPXkKIyBDT05GSUdfTUVNT1JZX0hPVFBMVUcgaXMgbm90IHNldApDT05GSUdf UEFHRUZMQUdTX0VYVEVOREVEPXkKQ09ORklHX1NQTElUX1BUTE9DS19DUFVTPTk5OTk5OQpD T05GSUdfQ09NUEFDVElPTj15CkNPTkZJR19NSUdSQVRJT049eQpDT05GSUdfUEhZU19BRERS X1RfNjRCSVQ9eQpDT05GSUdfWk9ORV9ETUFfRkxBRz0xCkNPTkZJR19CT1VOQ0U9eQpDT05G SUdfVklSVF9UT19CVVM9eQpDT05GSUdfTU1VX05PVElGSUVSPXkKIyBDT05GSUdfS1NNIGlz IG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfTU1BUF9NSU5fQUREUj00MDk2CkNPTkZJR19BUkNI X1NVUFBPUlRTX01FTU9SWV9GQUlMVVJFPXkKIyBDT05GSUdfTUVNT1JZX0ZBSUxVUkUgaXMg bm90IHNldApDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0U9eQpDT05GSUdfVFJBTlNQQVJF TlRfSFVHRVBBR0VfQUxXQVlTPXkKIyBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0VfTUFE VklTRSBpcyBub3Qgc2V0CkNPTkZJR19DUk9TU19NRU1PUllfQVRUQUNIPXkKIyBDT05GSUdf Q0xFQU5DQUNIRSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZST05UU1dBUCBpcyBub3Qgc2V0CkNP TkZJR19YODZfQ0hFQ0tfQklPU19DT1JSVVBUSU9OPXkKQ09ORklHX1g4Nl9CT09UUEFSQU1f TUVNT1JZX0NPUlJVUFRJT05fQ0hFQ0s9eQpDT05GSUdfWDg2X1JFU0VSVkVfTE9XPTY0CkNP TkZJR19NVFJSPXkKQ09ORklHX01UUlJfU0FOSVRJWkVSPXkKQ09ORklHX01UUlJfU0FOSVRJ WkVSX0VOQUJMRV9ERUZBVUxUPTAKQ09ORklHX01UUlJfU0FOSVRJWkVSX1NQQVJFX1JFR19O Ul9ERUZBVUxUPTEKQ09ORklHX1g4Nl9QQVQ9eQpDT05GSUdfQVJDSF9VU0VTX1BHX1VOQ0FD SEVEPXkKQ09ORklHX0FSQ0hfUkFORE9NPXkKQ09ORklHX1g4Nl9TTUFQPXkKIyBDT05GSUdf RUZJIGlzIG5vdCBzZXQKQ09ORklHX1NFQ0NPTVA9eQojIENPTkZJR19DQ19TVEFDS1BST1RF Q1RPUiBpcyBub3Qgc2V0CiMgQ09ORklHX0haXzEwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0ha XzI1MCBpcyBub3Qgc2V0CkNPTkZJR19IWl8zMDA9eQojIENPTkZJR19IWl8xMDAwIGlzIG5v dCBzZXQKQ09ORklHX0haPTMwMApDT05GSUdfU0NIRURfSFJUSUNLPXkKQ09ORklHX0tFWEVD PXkKQ09ORklHX0NSQVNIX0RVTVA9eQpDT05GSUdfUEhZU0lDQUxfU1RBUlQ9MHgxMDAwMDAw CkNPTkZJR19SRUxPQ0FUQUJMRT15CkNPTkZJR19QSFlTSUNBTF9BTElHTj0weDEwMDAwMDAK Q09ORklHX0hPVFBMVUdfQ1BVPXkKIyBDT05GSUdfQ09NUEFUX1ZEU08gaXMgbm90IHNldAoj IENPTkZJR19DTURMSU5FX0JPT0wgaXMgbm90IHNldApDT05GSUdfQVJDSF9FTkFCTEVfTUVN T1JZX0hPVFBMVUc9eQpDT05GSUdfVVNFX1BFUkNQVV9OVU1BX05PREVfSUQ9eQoKIwojIFBv d2VyIG1hbmFnZW1lbnQgYW5kIEFDUEkgb3B0aW9ucwojCiMgQ09ORklHX1NVU1BFTkQgaXMg bm90IHNldApDT05GSUdfSElCRVJOQVRFX0NBTExCQUNLUz15CiMgQ09ORklHX0hJQkVSTkFU SU9OIGlzIG5vdCBzZXQKQ09ORklHX1BNX1NMRUVQPXkKQ09ORklHX1BNX1NMRUVQX1NNUD15 CiMgQ09ORklHX1BNX0FVVE9TTEVFUCBpcyBub3Qgc2V0CiMgQ09ORklHX1BNX1dBS0VMT0NL UyBpcyBub3Qgc2V0CiMgQ09ORklHX1BNX1JVTlRJTUUgaXMgbm90IHNldApDT05GSUdfUE09 eQpDT05GSUdfUE1fREVCVUc9eQojIENPTkZJR19QTV9BRFZBTkNFRF9ERUJVRyBpcyBub3Qg c2V0CkNPTkZJR19QTV9TTEVFUF9ERUJVRz15CiMgQ09ORklHX1BNX1RSQUNFX1JUQyBpcyBu b3Qgc2V0CkNPTkZJR19BQ1BJPXkKQ09ORklHX0FDUElfUFJPQ0ZTPXkKIyBDT05GSUdfQUNQ SV9QUk9DRlNfUE9XRVIgaXMgbm90IHNldAojIENPTkZJR19BQ1BJX0VDX0RFQlVHRlMgaXMg bm90IHNldAojIENPTkZJR19BQ1BJX1BST0NfRVZFTlQgaXMgbm90IHNldApDT05GSUdfQUNQ SV9BQz15CkNPTkZJR19BQ1BJX0JBVFRFUlk9eQpDT05GSUdfQUNQSV9CVVRUT049eQpDT05G SUdfQUNQSV9WSURFTz15CkNPTkZJR19BQ1BJX0ZBTj15CiMgQ09ORklHX0FDUElfRE9DSyBp cyBub3Qgc2V0CkNPTkZJR19BQ1BJX1BST0NFU1NPUj15CkNPTkZJR19BQ1BJX0hPVFBMVUdf Q1BVPXkKIyBDT05GSUdfQUNQSV9QUk9DRVNTT1JfQUdHUkVHQVRPUiBpcyBub3Qgc2V0CkNP TkZJR19BQ1BJX1RIRVJNQUw9eQpDT05GSUdfQUNQSV9OVU1BPXkKIyBDT05GSUdfQUNQSV9D VVNUT01fRFNEVCBpcyBub3Qgc2V0CkNPTkZJR19BQ1BJX0JMQUNLTElTVF9ZRUFSPTAKIyBD T05GSUdfQUNQSV9ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19BQ1BJX1BDSV9TTE9UPXkKQ09O RklHX1g4Nl9QTV9USU1FUj15CkNPTkZJR19BQ1BJX0NPTlRBSU5FUj15CiMgQ09ORklHX0FD UElfU0JTIGlzIG5vdCBzZXQKQ09ORklHX0FDUElfSEVEPXkKIyBDT05GSUdfQUNQSV9DVVNU T01fTUVUSE9EIGlzIG5vdCBzZXQKIyBDT05GSUdfQUNQSV9BUEVJIGlzIG5vdCBzZXQKIyBD T05GSUdfU0ZJIGlzIG5vdCBzZXQKCiMKIyBDUFUgRnJlcXVlbmN5IHNjYWxpbmcKIwpDT05G SUdfQ1BVX0ZSRVE9eQpDT05GSUdfQ1BVX0ZSRVFfVEFCTEU9eQojIENPTkZJR19DUFVfRlJF UV9TVEFUIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfUEVSRk9S TUFOQ0UgaXMgbm90IHNldApDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfVVNFUlNQQUNF PXkKIyBDT05GSUdfQ1BVX0ZSRVFfREVGQVVMVF9HT1ZfT05ERU1BTkQgaXMgbm90IHNldAoj IENPTkZJR19DUFVfRlJFUV9ERUZBVUxUX0dPVl9DT05TRVJWQVRJVkUgaXMgbm90IHNldApD T05GSUdfQ1BVX0ZSRVFfR09WX1BFUkZPUk1BTkNFPXkKIyBDT05GSUdfQ1BVX0ZSRVFfR09W X1BPV0VSU0FWRSBpcyBub3Qgc2V0CkNPTkZJR19DUFVfRlJFUV9HT1ZfVVNFUlNQQUNFPXkK Q09ORklHX0NQVV9GUkVRX0dPVl9PTkRFTUFORD15CiMgQ09ORklHX0NQVV9GUkVRX0dPVl9D T05TRVJWQVRJVkUgaXMgbm90IHNldAoKIwojIHg4NiBDUFUgZnJlcXVlbmN5IHNjYWxpbmcg ZHJpdmVycwojCkNPTkZJR19YODZfUENDX0NQVUZSRVE9eQpDT05GSUdfWDg2X0FDUElfQ1BV RlJFUT15CkNPTkZJR19YODZfQUNQSV9DUFVGUkVRX0NQQj15CiMgQ09ORklHX1g4Nl9QT1dF Uk5PV19LOCBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9TUEVFRFNURVBfQ0VOVFJJTk8gaXMg bm90IHNldAojIENPTkZJR19YODZfUDRfQ0xPQ0tNT0QgaXMgbm90IHNldAoKIwojIHNoYXJl ZCBvcHRpb25zCiMKIyBDT05GSUdfWDg2X1NQRUVEU1RFUF9MSUIgaXMgbm90IHNldApDT05G SUdfQ1BVX0lETEU9eQpDT05GSUdfQ1BVX0lETEVfR09WX0xBRERFUj15CkNPTkZJR19DUFVf SURMRV9HT1ZfTUVOVT15CiMgQ09ORklHX0FSQ0hfTkVFRFNfQ1BVX0lETEVfQ09VUExFRCBp cyBub3Qgc2V0CiMgQ09ORklHX0lOVEVMX0lETEUgaXMgbm90IHNldAoKIwojIE1lbW9yeSBw b3dlciBzYXZpbmdzCiMKIyBDT05GSUdfSTczMDBfSURMRSBpcyBub3Qgc2V0CgojCiMgQnVz IG9wdGlvbnMgKFBDSSBldGMuKQojCkNPTkZJR19QQ0k9eQpDT05GSUdfUENJX0RJUkVDVD15 CkNPTkZJR19QQ0lfTU1DT05GSUc9eQpDT05GSUdfUENJX1hFTj15CkNPTkZJR19QQ0lfRE9N QUlOUz15CkNPTkZJR19QQ0lFUE9SVEJVUz15CkNPTkZJR19IT1RQTFVHX1BDSV9QQ0lFPXkK Q09ORklHX1BDSUVBRVI9eQpDT05GSUdfUENJRV9FQ1JDPXkKQ09ORklHX1BDSUVBRVJfSU5K RUNUPXkKQ09ORklHX1BDSUVBU1BNPXkKQ09ORklHX1BDSUVBU1BNX0RFQlVHPXkKQ09ORklH X1BDSUVBU1BNX0RFRkFVTFQ9eQojIENPTkZJR19QQ0lFQVNQTV9QT1dFUlNBVkUgaXMgbm90 IHNldAojIENPTkZJR19QQ0lFQVNQTV9QRVJGT1JNQU5DRSBpcyBub3Qgc2V0CkNPTkZJR19B UkNIX1NVUFBPUlRTX01TST15CkNPTkZJR19QQ0lfTVNJPXkKQ09ORklHX1BDSV9ERUJVRz15 CkNPTkZJR19QQ0lfUkVBTExPQ19FTkFCTEVfQVVUTz15CiMgQ09ORklHX1BDSV9TVFVCIGlz IG5vdCBzZXQKQ09ORklHX1hFTl9QQ0lERVZfRlJPTlRFTkQ9eQpDT05GSUdfSFRfSVJRPXkK Q09ORklHX1BDSV9BVFM9eQpDT05GSUdfUENJX0lPVj15CkNPTkZJR19QQ0lfUFJJPXkKQ09O RklHX1BDSV9QQVNJRD15CkNPTkZJR19QQ0lfSU9BUElDPXkKQ09ORklHX1BDSV9MQUJFTD15 CkNPTkZJR19JU0FfRE1BX0FQST15CkNPTkZJR19BTURfTkI9eQpDT05GSUdfUENDQVJEPXkK IyBDT05GSUdfUENNQ0lBIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FSREJVUyBpcyBub3Qgc2V0 CgojCiMgUEMtY2FyZCBicmlkZ2VzCiMKIyBDT05GSUdfWUVOVEEgaXMgbm90IHNldApDT05G SUdfSE9UUExVR19QQ0k9eQpDT05GSUdfSE9UUExVR19QQ0lfQUNQST15CkNPTkZJR19IT1RQ TFVHX1BDSV9BQ1BJX0lCTT15CkNPTkZJR19IT1RQTFVHX1BDSV9DUENJPXkKQ09ORklHX0hP VFBMVUdfUENJX0NQQ0lfWlQ1NTUwPXkKQ09ORklHX0hPVFBMVUdfUENJX0NQQ0lfR0VORVJJ Qz15CkNPTkZJR19IT1RQTFVHX1BDSV9TSFBDPXkKIyBDT05GSUdfUkFQSURJTyBpcyBub3Qg c2V0CgojCiMgRXhlY3V0YWJsZSBmaWxlIGZvcm1hdHMgLyBFbXVsYXRpb25zCiMKQ09ORklH X0JJTkZNVF9FTEY9eQpDT05GSUdfQ09NUEFUX0JJTkZNVF9FTEY9eQpDT05GSUdfQVJDSF9C SU5GTVRfRUxGX1JBTkRPTUlaRV9QSUU9eQpDT05GSUdfQ09SRV9EVU1QX0RFRkFVTFRfRUxG X0hFQURFUlM9eQojIENPTkZJR19IQVZFX0FPVVQgaXMgbm90IHNldApDT05GSUdfQklORk1U X01JU0M9eQpDT05GSUdfQ09SRURVTVA9eQpDT05GSUdfSUEzMl9FTVVMQVRJT049eQojIENP TkZJR19JQTMyX0FPVVQgaXMgbm90IHNldAojIENPTkZJR19YODZfWDMyIGlzIG5vdCBzZXQK Q09ORklHX0NPTVBBVD15CkNPTkZJR19DT01QQVRfRk9SX1U2NF9BTElHTk1FTlQ9eQpDT05G SUdfU1lTVklQQ19DT01QQVQ9eQpDT05GSUdfSEFWRV9URVhUX1BPS0VfU01QPXkKQ09ORklH X1g4Nl9ERVZfRE1BX09QUz15CkNPTkZJR19ORVQ9eQoKIwojIE5ldHdvcmtpbmcgb3B0aW9u cwojCkNPTkZJR19QQUNLRVQ9eQojIENPTkZJR19QQUNLRVRfRElBRyBpcyBub3Qgc2V0CkNP TkZJR19VTklYPXkKIyBDT05GSUdfVU5JWF9ESUFHIGlzIG5vdCBzZXQKIyBDT05GSUdfWEZS TV9VU0VSIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0tFWSBpcyBub3Qgc2V0CkNPTkZJR19J TkVUPXkKQ09ORklHX0lQX01VTFRJQ0FTVD15CkNPTkZJR19JUF9BRFZBTkNFRF9ST1VURVI9 eQojIENPTkZJR19JUF9GSUJfVFJJRV9TVEFUUyBpcyBub3Qgc2V0CkNPTkZJR19JUF9NVUxU SVBMRV9UQUJMRVM9eQpDT05GSUdfSVBfUk9VVEVfTVVMVElQQVRIPXkKQ09ORklHX0lQX1JP VVRFX1ZFUkJPU0U9eQpDT05GSUdfSVBfUk9VVEVfQ0xBU1NJRD15CkNPTkZJR19JUF9QTlA9 eQpDT05GSUdfSVBfUE5QX0RIQ1A9eQpDT05GSUdfSVBfUE5QX0JPT1RQPXkKQ09ORklHX0lQ X1BOUF9SQVJQPXkKIyBDT05GSUdfTkVUX0lQSVAgaXMgbm90IHNldAojIENPTkZJR19ORVRf SVBHUkVfREVNVVggaXMgbm90IHNldApDT05GSUdfSVBfTVJPVVRFPXkKIyBDT05GSUdfSVBf TVJPVVRFX01VTFRJUExFX1RBQkxFUyBpcyBub3Qgc2V0CkNPTkZJR19JUF9QSU1TTV9WMT15 CkNPTkZJR19JUF9QSU1TTV9WMj15CiMgQ09ORklHX0FSUEQgaXMgbm90IHNldApDT05GSUdf U1lOX0NPT0tJRVM9eQojIENPTkZJR19JTkVUX0FIIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5F VF9FU1AgaXMgbm90IHNldAojIENPTkZJR19JTkVUX0lQQ09NUCBpcyBub3Qgc2V0CiMgQ09O RklHX0lORVRfWEZSTV9UVU5ORUwgaXMgbm90IHNldAojIENPTkZJR19JTkVUX1RVTk5FTCBp cyBub3Qgc2V0CiMgQ09ORklHX0lORVRfWEZSTV9NT0RFX1RSQU5TUE9SVCBpcyBub3Qgc2V0 CiMgQ09ORklHX0lORVRfWEZSTV9NT0RFX1RVTk5FTCBpcyBub3Qgc2V0CiMgQ09ORklHX0lO RVRfWEZSTV9NT0RFX0JFRVQgaXMgbm90IHNldApDT05GSUdfSU5FVF9MUk89eQojIENPTkZJ R19JTkVUX0RJQUcgaXMgbm90IHNldApDT05GSUdfVENQX0NPTkdfQURWQU5DRUQ9eQojIENP TkZJR19UQ1BfQ09OR19CSUMgaXMgbm90IHNldApDT05GSUdfVENQX0NPTkdfQ1VCSUM9eQoj IENPTkZJR19UQ1BfQ09OR19XRVNUV09PRCBpcyBub3Qgc2V0CiMgQ09ORklHX1RDUF9DT05H X0hUQ1AgaXMgbm90IHNldAojIENPTkZJR19UQ1BfQ09OR19IU1RDUCBpcyBub3Qgc2V0CiMg Q09ORklHX1RDUF9DT05HX0hZQkxBIGlzIG5vdCBzZXQKIyBDT05GSUdfVENQX0NPTkdfVkVH QVMgaXMgbm90IHNldAojIENPTkZJR19UQ1BfQ09OR19TQ0FMQUJMRSBpcyBub3Qgc2V0CiMg Q09ORklHX1RDUF9DT05HX0xQIGlzIG5vdCBzZXQKIyBDT05GSUdfVENQX0NPTkdfVkVOTyBp cyBub3Qgc2V0CiMgQ09ORklHX1RDUF9DT05HX1lFQUggaXMgbm90IHNldAojIENPTkZJR19U Q1BfQ09OR19JTExJTk9JUyBpcyBub3Qgc2V0CkNPTkZJR19ERUZBVUxUX0NVQklDPXkKIyBD T05GSUdfREVGQVVMVF9SRU5PIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfVENQX0NPTkc9 ImN1YmljIgojIENPTkZJR19UQ1BfTUQ1U0lHIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBWNiBp cyBub3Qgc2V0CkNPTkZJR19ORVRXT1JLX1NFQ01BUks9eQojIENPTkZJR19ORVRXT1JLX1BI WV9USU1FU1RBTVBJTkcgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSPXkKIyBDT05GSUdf TkVURklMVEVSX0RFQlVHIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUl9BRFZBTkNFRD15 CkNPTkZJR19CUklER0VfTkVURklMVEVSPXkKCiMKIyBDb3JlIE5ldGZpbHRlciBDb25maWd1 cmF0aW9uCiMKQ09ORklHX05FVEZJTFRFUl9ORVRMSU5LPXkKQ09ORklHX05FVEZJTFRFUl9O RVRMSU5LX0FDQ1Q9eQpDT05GSUdfTkVURklMVEVSX05FVExJTktfUVVFVUU9eQpDT05GSUdf TkVURklMVEVSX05FVExJTktfTE9HPXkKQ09ORklHX05GX0NPTk5UUkFDSz15CkNPTkZJR19O Rl9DT05OVFJBQ0tfTUFSSz15CkNPTkZJR19ORl9DT05OVFJBQ0tfU0VDTUFSSz15CkNPTkZJ R19ORl9DT05OVFJBQ0tfUFJPQ0ZTPXkKQ09ORklHX05GX0NPTk5UUkFDS19FVkVOVFM9eQoj IENPTkZJR19ORl9DT05OVFJBQ0tfVElNRU9VVCBpcyBub3Qgc2V0CkNPTkZJR19ORl9DT05O VFJBQ0tfVElNRVNUQU1QPXkKIyBDT05GSUdfTkZfQ1RfUFJPVE9fRENDUCBpcyBub3Qgc2V0 CkNPTkZJR19ORl9DVF9QUk9UT19HUkU9eQojIENPTkZJR19ORl9DVF9QUk9UT19TQ1RQIGlz IG5vdCBzZXQKIyBDT05GSUdfTkZfQ1RfUFJPVE9fVURQTElURSBpcyBub3Qgc2V0CiMgQ09O RklHX05GX0NPTk5UUkFDS19BTUFOREEgaXMgbm90IHNldApDT05GSUdfTkZfQ09OTlRSQUNL X0ZUUD15CkNPTkZJR19ORl9DT05OVFJBQ0tfSDMyMz15CkNPTkZJR19ORl9DT05OVFJBQ0tf SVJDPXkKIyBDT05GSUdfTkZfQ09OTlRSQUNLX05FVEJJT1NfTlMgaXMgbm90IHNldAojIENP TkZJR19ORl9DT05OVFJBQ0tfU05NUCBpcyBub3Qgc2V0CkNPTkZJR19ORl9DT05OVFJBQ0tf UFBUUD15CiMgQ09ORklHX05GX0NPTk5UUkFDS19TQU5FIGlzIG5vdCBzZXQKQ09ORklHX05G X0NPTk5UUkFDS19TSVA9eQojIENPTkZJR19ORl9DT05OVFJBQ0tfVEZUUCBpcyBub3Qgc2V0 CkNPTkZJR19ORl9DVF9ORVRMSU5LPXkKIyBDT05GSUdfTkZfQ1RfTkVUTElOS19USU1FT1VU IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVURklMVEVSX05FVExJTktfUVVFVUVfQ1QgaXMgbm90 IHNldApDT05GSUdfTkZfTkFUPXkKQ09ORklHX05GX05BVF9ORUVERUQ9eQojIENPTkZJR19O Rl9OQVRfQU1BTkRBIGlzIG5vdCBzZXQKQ09ORklHX05GX05BVF9GVFA9eQpDT05GSUdfTkZf TkFUX0lSQz15CkNPTkZJR19ORl9OQVRfU0lQPXkKIyBDT05GSUdfTkZfTkFUX1RGVFAgaXMg bm90IHNldAojIENPTkZJR19ORVRGSUxURVJfVFBST1hZIGlzIG5vdCBzZXQKQ09ORklHX05F VEZJTFRFUl9YVEFCTEVTPXkKCiMKIyBYdGFibGVzIGNvbWJpbmVkIG1vZHVsZXMKIwpDT05G SUdfTkVURklMVEVSX1hUX01BUks9eQpDT05GSUdfTkVURklMVEVSX1hUX0NPTk5NQVJLPXkK IyBDT05GSUdfTkVURklMVEVSX1hUX1NFVCBpcyBub3Qgc2V0CgojCiMgWHRhYmxlcyB0YXJn ZXRzCiMKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfQVVESVQ9eQpDT05GSUdfTkVURklM VEVSX1hUX1RBUkdFVF9DSEVDS1NVTT15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX0NM QVNTSUZZPXkKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfQ09OTk1BUks9eQpDT05GSUdf TkVURklMVEVSX1hUX1RBUkdFVF9DT05OU0VDTUFSSz15CiMgQ09ORklHX05FVEZJTFRFUl9Y VF9UQVJHRVRfQ1QgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9EU0NQ PXkKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfSEw9eQojIENPTkZJR19ORVRGSUxURVJf WFRfVEFSR0VUX0hNQVJLIGlzIG5vdCBzZXQKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRf SURMRVRJTUVSPXkKQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfTE9HPXkKQ09ORklHX05F VEZJTFRFUl9YVF9UQVJHRVRfTUFSSz15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX05F VE1BUD15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX05GTE9HPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9UQVJHRVRfTkZRVUVVRT15CkNPTkZJR19ORVRGSUxURVJfWFRfVEFSR0VUX1JB VEVFU1Q9eQpDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9SRURJUkVDVD15CkNPTkZJR19O RVRGSUxURVJfWFRfVEFSR0VUX1RFRT15CiMgQ09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRf VFJBQ0UgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX1RBUkdFVF9TRUNNQVJLPXkK Q09ORklHX05FVEZJTFRFUl9YVF9UQVJHRVRfVENQTVNTPXkKIyBDT05GSUdfTkVURklMVEVS X1hUX1RBUkdFVF9UQ1BPUFRTVFJJUCBpcyBub3Qgc2V0CgojCiMgWHRhYmxlcyBtYXRjaGVz CiMKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9BRERSVFlQRT15CkNPTkZJR19ORVRGSUxU RVJfWFRfTUFUQ0hfQ0xVU1RFUj15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ09NTUVO VD15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfQ09OTkJZVEVTPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9DT05OTElNSVQ9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0NP Tk5NQVJLPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9DT05OVFJBQ0s9eQpDT05GSUdf TkVURklMVEVSX1hUX01BVENIX0NQVT15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfREND UD15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfREVWR1JPVVA9eQpDT05GSUdfTkVURklM VEVSX1hUX01BVENIX0RTQ1A9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0VDTj15CkNP TkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfRVNQPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRD SF9IQVNITElNSVQ9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0hFTFBFUj15CkNPTkZJ R19ORVRGSUxURVJfWFRfTUFUQ0hfSEw9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0lQ UkFOR0U9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX0lQVlM9eQpDT05GSUdfTkVURklM VEVSX1hUX01BVENIX0xFTkdUSD15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfTElNSVQ9 eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX01BQz15CkNPTkZJR19ORVRGSUxURVJfWFRf TUFUQ0hfTUFSSz15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfTVVMVElQT1JUPXkKQ09O RklHX05FVEZJTFRFUl9YVF9NQVRDSF9ORkFDQ1Q9eQpDT05GSUdfTkVURklMVEVSX1hUX01B VENIX09TRj15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfT1dORVI9eQpDT05GSUdfTkVU RklMVEVSX1hUX01BVENIX1BIWVNERVY9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1BL VFRZUEU9eQpDT05GSUdfTkVURklMVEVSX1hUX01BVENIX1FVT1RBPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9SQVRFRVNUPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9SRUFM TT15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hfUkVDRU5UPXkKIyBDT05GSUdfTkVURklM VEVSX1hUX01BVENIX1NDVFAgaXMgbm90IHNldApDT05GSUdfTkVURklMVEVSX1hUX01BVENI X1NUQVRFPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9TVEFUSVNUSUM9eQpDT05GSUdf TkVURklMVEVSX1hUX01BVENIX1NUUklORz15CkNPTkZJR19ORVRGSUxURVJfWFRfTUFUQ0hf VENQTVNTPXkKQ09ORklHX05FVEZJTFRFUl9YVF9NQVRDSF9USU1FPXkKQ09ORklHX05FVEZJ TFRFUl9YVF9NQVRDSF9VMzI9eQpDT05GSUdfSVBfU0VUPXkKQ09ORklHX0lQX1NFVF9NQVg9 MjU2CkNPTkZJR19JUF9TRVRfQklUTUFQX0lQPXkKQ09ORklHX0lQX1NFVF9CSVRNQVBfSVBN QUM9eQpDT05GSUdfSVBfU0VUX0JJVE1BUF9QT1JUPXkKQ09ORklHX0lQX1NFVF9IQVNIX0lQ PXkKQ09ORklHX0lQX1NFVF9IQVNIX0lQUE9SVD15CkNPTkZJR19JUF9TRVRfSEFTSF9JUFBP UlRJUD15CkNPTkZJR19JUF9TRVRfSEFTSF9JUFBPUlRORVQ9eQpDT05GSUdfSVBfU0VUX0hB U0hfTkVUPXkKQ09ORklHX0lQX1NFVF9IQVNIX05FVFBPUlQ9eQpDT05GSUdfSVBfU0VUX0hB U0hfTkVUSUZBQ0U9eQpDT05GSUdfSVBfU0VUX0xJU1RfU0VUPXkKQ09ORklHX0lQX1ZTPXkK IyBDT05GSUdfSVBfVlNfREVCVUcgaXMgbm90IHNldApDT05GSUdfSVBfVlNfVEFCX0JJVFM9 MTIKCiMKIyBJUFZTIHRyYW5zcG9ydCBwcm90b2NvbCBsb2FkIGJhbGFuY2luZyBzdXBwb3J0 CiMKIyBDT05GSUdfSVBfVlNfUFJPVE9fVENQIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNf UFJPVE9fVURQIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNfUFJPVE9fQUhfRVNQIGlzIG5v dCBzZXQKIyBDT05GSUdfSVBfVlNfUFJPVE9fRVNQIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBf VlNfUFJPVE9fQUggaXMgbm90IHNldAojIENPTkZJR19JUF9WU19QUk9UT19TQ1RQIGlzIG5v dCBzZXQKCiMKIyBJUFZTIHNjaGVkdWxlcgojCiMgQ09ORklHX0lQX1ZTX1JSIGlzIG5vdCBz ZXQKIyBDT05GSUdfSVBfVlNfV1JSIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNfTEMgaXMg bm90IHNldAojIENPTkZJR19JUF9WU19XTEMgaXMgbm90IHNldAojIENPTkZJR19JUF9WU19M QkxDIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNfTEJMQ1IgaXMgbm90IHNldAojIENPTkZJ R19JUF9WU19ESCBpcyBub3Qgc2V0CiMgQ09ORklHX0lQX1ZTX1NIIGlzIG5vdCBzZXQKIyBD T05GSUdfSVBfVlNfU0VEIGlzIG5vdCBzZXQKIyBDT05GSUdfSVBfVlNfTlEgaXMgbm90IHNl dAoKIwojIElQVlMgU0ggc2NoZWR1bGVyCiMKQ09ORklHX0lQX1ZTX1NIX1RBQl9CSVRTPTgK CiMKIyBJUFZTIGFwcGxpY2F0aW9uIGhlbHBlcgojCkNPTkZJR19JUF9WU19ORkNUPXkKCiMK IyBJUDogTmV0ZmlsdGVyIENvbmZpZ3VyYXRpb24KIwpDT05GSUdfTkZfREVGUkFHX0lQVjQ9 eQpDT05GSUdfTkZfQ09OTlRSQUNLX0lQVjQ9eQpDT05GSUdfTkZfQ09OTlRSQUNLX1BST0Nf Q09NUEFUPXkKIyBDT05GSUdfSVBfTkZfUVVFVUUgaXMgbm90IHNldApDT05GSUdfSVBfTkZf SVBUQUJMRVM9eQpDT05GSUdfSVBfTkZfTUFUQ0hfQUg9eQpDT05GSUdfSVBfTkZfTUFUQ0hf RUNOPXkKIyBDT05GSUdfSVBfTkZfTUFUQ0hfUlBGSUxURVIgaXMgbm90IHNldApDT05GSUdf SVBfTkZfTUFUQ0hfVFRMPXkKQ09ORklHX0lQX05GX0ZJTFRFUj15CkNPTkZJR19JUF9ORl9U QVJHRVRfUkVKRUNUPXkKQ09ORklHX0lQX05GX1RBUkdFVF9VTE9HPXkKQ09ORklHX05GX05B VF9JUFY0PXkKQ09ORklHX0lQX05GX1RBUkdFVF9NQVNRVUVSQURFPXkKQ09ORklHX0lQX05G X1RBUkdFVF9ORVRNQVA9eQpDT05GSUdfSVBfTkZfVEFSR0VUX1JFRElSRUNUPXkKQ09ORklH X05GX05BVF9QUk9UT19HUkU9eQpDT05GSUdfTkZfTkFUX1BQVFA9eQpDT05GSUdfTkZfTkFU X0gzMjM9eQpDT05GSUdfSVBfTkZfTUFOR0xFPXkKIyBDT05GSUdfSVBfTkZfVEFSR0VUX0NM VVNURVJJUCBpcyBub3Qgc2V0CiMgQ09ORklHX0lQX05GX1RBUkdFVF9FQ04gaXMgbm90IHNl dAojIENPTkZJR19JUF9ORl9UQVJHRVRfVFRMIGlzIG5vdCBzZXQKQ09ORklHX0lQX05GX1JB Vz15CiMgQ09ORklHX0lQX05GX0FSUFRBQkxFUyBpcyBub3Qgc2V0CkNPTkZJR19CUklER0Vf TkZfRUJUQUJMRVM9eQojIENPTkZJR19CUklER0VfRUJUX0JST1VURSBpcyBub3Qgc2V0CiMg Q09ORklHX0JSSURHRV9FQlRfVF9GSUxURVIgaXMgbm90IHNldAojIENPTkZJR19CUklER0Vf RUJUX1RfTkFUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF84MDJfMyBpcyBub3Qg c2V0CiMgQ09ORklHX0JSSURHRV9FQlRfQU1PTkcgaXMgbm90IHNldAojIENPTkZJR19CUklE R0VfRUJUX0FSUCBpcyBub3Qgc2V0CiMgQ09ORklHX0JSSURHRV9FQlRfSVAgaXMgbm90IHNl dAojIENPTkZJR19CUklER0VfRUJUX0xJTUlUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdF X0VCVF9NQVJLIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9QS1RUWVBFIGlzIG5v dCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9TVFAgaXMgbm90IHNldAojIENPTkZJR19CUklE R0VfRUJUX1ZMQU4gaXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX0FSUFJFUExZIGlz IG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9ETkFUIGlzIG5vdCBzZXQKIyBDT05GSUdf QlJJREdFX0VCVF9NQVJLX1QgaXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX1JFRElS RUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJJREdFX0VCVF9TTkFUIGlzIG5vdCBzZXQKIyBD T05GSUdfQlJJREdFX0VCVF9MT0cgaXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX1VM T0cgaXMgbm90IHNldAojIENPTkZJR19CUklER0VfRUJUX05GTE9HIGlzIG5vdCBzZXQKIyBD T05GSUdfSVBfRENDUCBpcyBub3Qgc2V0CiMgQ09ORklHX0lQX1NDVFAgaXMgbm90IHNldAoj IENPTkZJR19SRFMgaXMgbm90IHNldAojIENPTkZJR19USVBDIGlzIG5vdCBzZXQKIyBDT05G SUdfQVRNIGlzIG5vdCBzZXQKIyBDT05GSUdfTDJUUCBpcyBub3Qgc2V0CkNPTkZJR19TVFA9 eQpDT05GSUdfQlJJREdFPXkKQ09ORklHX0JSSURHRV9JR01QX1NOT09QSU5HPXkKIyBDT05G SUdfTkVUX0RTQSBpcyBub3Qgc2V0CiMgQ09ORklHX1ZMQU5fODAyMVEgaXMgbm90IHNldAoj IENPTkZJR19ERUNORVQgaXMgbm90IHNldApDT05GSUdfTExDPXkKIyBDT05GSUdfTExDMiBp cyBub3Qgc2V0CiMgQ09ORklHX0lQWCBpcyBub3Qgc2V0CiMgQ09ORklHX0FUQUxLIGlzIG5v dCBzZXQKIyBDT05GSUdfWDI1IGlzIG5vdCBzZXQKIyBDT05GSUdfTEFQQiBpcyBub3Qgc2V0 CiMgQ09ORklHX1dBTl9ST1VURVIgaXMgbm90IHNldAojIENPTkZJR19QSE9ORVQgaXMgbm90 IHNldAojIENPTkZJR19JRUVFODAyMTU0IGlzIG5vdCBzZXQKQ09ORklHX05FVF9TQ0hFRD15 CgojCiMgUXVldWVpbmcvU2NoZWR1bGluZwojCiMgQ09ORklHX05FVF9TQ0hfQ0JRIGlzIG5v dCBzZXQKIyBDT05GSUdfTkVUX1NDSF9IVEIgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0NI X0hGU0MgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0NIX1BSSU8gaXMgbm90IHNldAojIENP TkZJR19ORVRfU0NIX01VTFRJUSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfUkVEIGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9TRkIgaXMgbm90IHNldAojIENPTkZJR19ORVRf U0NIX1NGUSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hfVEVRTCBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9TQ0hfVEJGIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9HUkVEIGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9EU01BUksgaXMgbm90IHNldAojIENPTkZJR19O RVRfU0NIX05FVEVNIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9EUlIgaXMgbm90IHNl dAojIENPTkZJR19ORVRfU0NIX01RUFJJTyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9TQ0hf Q0hPS0UgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0NIX1FGUSBpcyBub3Qgc2V0CiMgQ09O RklHX05FVF9TQ0hfQ09ERUwgaXMgbm90IHNldAojIENPTkZJR19ORVRfU0NIX0ZRX0NPREVM IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1NDSF9JTkdSRVNTIGlzIG5vdCBzZXQKIyBDT05G SUdfTkVUX1NDSF9QTFVHIGlzIG5vdCBzZXQKCiMKIyBDbGFzc2lmaWNhdGlvbgojCkNPTkZJ R19ORVRfQ0xTPXkKIyBDT05GSUdfTkVUX0NMU19CQVNJQyBpcyBub3Qgc2V0CiMgQ09ORklH X05FVF9DTFNfVENJTkRFWCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9DTFNfUk9VVEU0IGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19GVyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9D TFNfVTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX0NMU19SU1ZQIGlzIG5vdCBzZXQKIyBD T05GSUdfTkVUX0NMU19SU1ZQNiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9DTFNfRkxPVyBp cyBub3Qgc2V0CiMgQ09ORklHX05FVF9DTFNfQ0dST1VQIGlzIG5vdCBzZXQKQ09ORklHX05F VF9FTUFUQ0g9eQpDT05GSUdfTkVUX0VNQVRDSF9TVEFDSz0zMgojIENPTkZJR19ORVRfRU1B VENIX0NNUCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9FTUFUQ0hfTkJZVEUgaXMgbm90IHNl dAojIENPTkZJR19ORVRfRU1BVENIX1UzMiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9FTUFU Q0hfTUVUQSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9FTUFUQ0hfVEVYVCBpcyBub3Qgc2V0 CiMgQ09ORklHX05FVF9FTUFUQ0hfSVBTRVQgaXMgbm90IHNldApDT05GSUdfTkVUX0NMU19B Q1Q9eQojIENPTkZJR19ORVRfQUNUX1BPTElDRSBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9B Q1RfR0FDVCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9BQ1RfTUlSUkVEIGlzIG5vdCBzZXQK IyBDT05GSUdfTkVUX0FDVF9JUFQgaXMgbm90IHNldAojIENPTkZJR19ORVRfQUNUX05BVCBp cyBub3Qgc2V0CiMgQ09ORklHX05FVF9BQ1RfUEVESVQgaXMgbm90IHNldAojIENPTkZJR19O RVRfQUNUX1NJTVAgaXMgbm90IHNldAojIENPTkZJR19ORVRfQUNUX1NLQkVESVQgaXMgbm90 IHNldAojIENPTkZJR19ORVRfQUNUX0NTVU0gaXMgbm90IHNldApDT05GSUdfTkVUX1NDSF9G SUZPPXkKIyBDT05GSUdfRENCIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFUTUFOX0FEViBpcyBu b3Qgc2V0CiMgQ09ORklHX09QRU5WU1dJVENIIGlzIG5vdCBzZXQKQ09ORklHX1JQUz15CkNP TkZJR19SRlNfQUNDRUw9eQpDT05GSUdfWFBTPXkKIyBDT05GSUdfTkVUUFJJT19DR1JPVVAg aXMgbm90IHNldApDT05GSUdfQlFMPXkKIyBDT05GSUdfQlBGX0pJVCBpcyBub3Qgc2V0Cgoj CiMgTmV0d29yayB0ZXN0aW5nCiMKIyBDT05GSUdfTkVUX1BLVEdFTiBpcyBub3Qgc2V0CiMg Q09ORklHX0hBTVJBRElPIGlzIG5vdCBzZXQKIyBDT05GSUdfQ0FOIGlzIG5vdCBzZXQKIyBD T05GSUdfSVJEQSBpcyBub3Qgc2V0CkNPTkZJR19CVD15CkNPTkZJR19CVF9SRkNPTU09eQpD T05GSUdfQlRfUkZDT01NX1RUWT15CkNPTkZJR19CVF9CTkVQPXkKQ09ORklHX0JUX0JORVBf TUNfRklMVEVSPXkKQ09ORklHX0JUX0JORVBfUFJPVE9fRklMVEVSPXkKQ09ORklHX0JUX0hJ RFA9eQoKIwojIEJsdWV0b290aCBkZXZpY2UgZHJpdmVycwojCkNPTkZJR19CVF9IQ0lCVFVT Qj15CkNPTkZJR19CVF9IQ0lVQVJUPXkKQ09ORklHX0JUX0hDSVVBUlRfSDQ9eQpDT05GSUdf QlRfSENJVUFSVF9CQ1NQPXkKQ09ORklHX0JUX0hDSVVBUlRfQVRIM0s9eQpDT05GSUdfQlRf SENJVUFSVF9MTD15CkNPTkZJR19CVF9IQ0lVQVJUXzNXSVJFPXkKQ09ORklHX0JUX0hDSUJD TTIwM1g9eQpDT05GSUdfQlRfSENJQlBBMTBYPXkKQ09ORklHX0JUX0hDSUJGVVNCPXkKQ09O RklHX0JUX0hDSVZIQ0k9eQpDT05GSUdfQlRfTVJWTD15CkNPTkZJR19CVF9BVEgzSz15CiMg Q09ORklHX0FGX1JYUlBDIGlzIG5vdCBzZXQKQ09ORklHX0ZJQl9SVUxFUz15CkNPTkZJR19X SVJFTEVTUz15CiMgQ09ORklHX0NGRzgwMjExIGlzIG5vdCBzZXQKIyBDT05GSUdfTElCODAy MTEgaXMgbm90IHNldAoKIwojIENGRzgwMjExIG5lZWRzIHRvIGJlIGVuYWJsZWQgZm9yIE1B QzgwMjExCiMKIyBDT05GSUdfV0lNQVggaXMgbm90IHNldAojIENPTkZJR19SRktJTEwgaXMg bm90IHNldAojIENPTkZJR19ORVRfOVAgaXMgbm90IHNldAojIENPTkZJR19DQUlGIGlzIG5v dCBzZXQKIyBDT05GSUdfQ0VQSF9MSUIgaXMgbm90IHNldAojIENPTkZJR19ORkMgaXMgbm90 IHNldApDT05GSUdfSEFWRV9CUEZfSklUPXkKCiMKIyBEZXZpY2UgRHJpdmVycwojCgojCiMg R2VuZXJpYyBEcml2ZXIgT3B0aW9ucwojCkNPTkZJR19VRVZFTlRfSEVMUEVSX1BBVEg9Ii9z YmluL2hvdHBsdWciCiMgQ09ORklHX0RFVlRNUEZTIGlzIG5vdCBzZXQKQ09ORklHX1NUQU5E QUxPTkU9eQpDT05GSUdfUFJFVkVOVF9GSVJNV0FSRV9CVUlMRD15CkNPTkZJR19GV19MT0FE RVI9eQpDT05GSUdfRklSTVdBUkVfSU5fS0VSTkVMPXkKQ09ORklHX0VYVFJBX0ZJUk1XQVJF PSIiCiMgQ09ORklHX0RFQlVHX0RSSVZFUiBpcyBub3Qgc2V0CkNPTkZJR19ERUJVR19ERVZS RVM9eQpDT05GSUdfU1lTX0hZUEVSVklTT1I9eQojIENPTkZJR19HRU5FUklDX0NQVV9ERVZJ Q0VTIGlzIG5vdCBzZXQKQ09ORklHX0RNQV9TSEFSRURfQlVGRkVSPXkKCiMKIyBCdXMgZGV2 aWNlcwojCiMgQ09ORklHX09NQVBfT0NQMlNDUCBpcyBub3Qgc2V0CkNPTkZJR19DT05ORUNU T1I9eQpDT05GSUdfUFJPQ19FVkVOVFM9eQojIENPTkZJR19NVEQgaXMgbm90IHNldAojIENP TkZJR19QQVJQT1JUIGlzIG5vdCBzZXQKQ09ORklHX1BOUD15CkNPTkZJR19QTlBfREVCVUdf TUVTU0FHRVM9eQoKIwojIFByb3RvY29scwojCkNPTkZJR19QTlBBQ1BJPXkKQ09ORklHX0JM S19ERVY9eQojIENPTkZJR19CTEtfREVWX0ZEIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RF Vl9QQ0lFU1NEX01USVAzMlhYIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0NQUV9EQSBpcyBu b3Qgc2V0CiMgQ09ORklHX0JMS19DUFFfQ0lTU19EQSBpcyBub3Qgc2V0CiMgQ09ORklHX0JM S19ERVZfREFDOTYwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9VTUVNIGlzIG5vdCBz ZXQKIyBDT05GSUdfQkxLX0RFVl9DT1dfQ09NTU9OIGlzIG5vdCBzZXQKQ09ORklHX0JMS19E RVZfTE9PUD15CkNPTkZJR19CTEtfREVWX0xPT1BfTUlOX0NPVU5UPTgKIyBDT05GSUdfQkxL X0RFVl9DUllQVE9MT09QIGlzIG5vdCBzZXQKIyBDT05GSUdfQkxLX0RFVl9EUkJEIGlzIG5v dCBzZXQKIyBDT05GSUdfQkxLX0RFVl9OQkQgaXMgbm90IHNldAojIENPTkZJR19CTEtfREVW X05WTUUgaXMgbm90IHNldAojIENPTkZJR19CTEtfREVWX1NYOCBpcyBub3Qgc2V0CkNPTkZJ R19CTEtfREVWX1JBTT15CkNPTkZJR19CTEtfREVWX1JBTV9DT1VOVD0xNgpDT05GSUdfQkxL X0RFVl9SQU1fU0laRT0xNjM4NAojIENPTkZJR19CTEtfREVWX1hJUCBpcyBub3Qgc2V0CiMg Q09ORklHX0NEUk9NX1BLVENEVkQgaXMgbm90IHNldAojIENPTkZJR19BVEFfT1ZFUl9FVEgg aXMgbm90IHNldApDT05GSUdfWEVOX0JMS0RFVl9GUk9OVEVORD15CkNPTkZJR19YRU5fQkxL REVWX0JBQ0tFTkQ9eQojIENPTkZJR19CTEtfREVWX0hEIGlzIG5vdCBzZXQKIyBDT05GSUdf QkxLX0RFVl9SQkQgaXMgbm90IHNldAoKIwojIE1pc2MgZGV2aWNlcwojCiMgQ09ORklHX1NF TlNPUlNfTElTM0xWMDJEIGlzIG5vdCBzZXQKIyBDT05GSUdfQUQ1MjVYX0RQT1QgaXMgbm90 IHNldAojIENPTkZJR19JQk1fQVNNIGlzIG5vdCBzZXQKIyBDT05GSUdfUEhBTlRPTSBpcyBu b3Qgc2V0CiMgQ09ORklHX0lOVEVMX01JRF9QVEkgaXMgbm90IHNldAojIENPTkZJR19TR0lf SU9DNCBpcyBub3Qgc2V0CiMgQ09ORklHX1RJRk1fQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklH X0lDUzkzMlM0MDEgaXMgbm90IHNldAojIENPTkZJR19FTkNMT1NVUkVfU0VSVklDRVMgaXMg bm90IHNldAojIENPTkZJR19IUF9JTE8gaXMgbm90IHNldAojIENPTkZJR19BUERTOTgwMkFM UyBpcyBub3Qgc2V0CiMgQ09ORklHX0lTTDI5MDAzIGlzIG5vdCBzZXQKIyBDT05GSUdfSVNM MjkwMjAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1RTTDI1NTAgaXMgbm90IHNldAoj IENPTkZJR19TRU5TT1JTX0JIMTc4MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQkgx NzcwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BUERTOTkwWCBpcyBub3Qgc2V0CiMg Q09ORklHX0hNQzYzNTIgaXMgbm90IHNldAojIENPTkZJR19EUzE2ODIgaXMgbm90IHNldAoj IENPTkZJR19WTVdBUkVfQkFMTE9PTiBpcyBub3Qgc2V0CiMgQ09ORklHX0JNUDA4NV9JMkMg aXMgbm90IHNldAojIENPTkZJR19QQ0hfUEhVQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9T V0lUQ0hfRlNBOTQ4MCBpcyBub3Qgc2V0CiMgQ09ORklHX0MyUE9SVCBpcyBub3Qgc2V0Cgoj CiMgRUVQUk9NIHN1cHBvcnQKIwojIENPTkZJR19FRVBST01fQVQyNCBpcyBub3Qgc2V0CiMg Q09ORklHX0VFUFJPTV9MRUdBQ1kgaXMgbm90IHNldAojIENPTkZJR19FRVBST01fTUFYNjg3 NSBpcyBub3Qgc2V0CiMgQ09ORklHX0VFUFJPTV85M0NYNiBpcyBub3Qgc2V0CiMgQ09ORklH X0NCNzEwX0NPUkUgaXMgbm90IHNldAoKIwojIFRleGFzIEluc3RydW1lbnRzIHNoYXJlZCB0 cmFuc3BvcnQgbGluZSBkaXNjaXBsaW5lCiMKIyBDT05GSUdfU0VOU09SU19MSVMzX0kyQyBp cyBub3Qgc2V0CgojCiMgQWx0ZXJhIEZQR0EgZmlybXdhcmUgZG93bmxvYWQgbW9kdWxlCiMK Q09ORklHX0FMVEVSQV9TVEFQTD15CiMgQ09ORklHX0lOVEVMX01FSSBpcyBub3Qgc2V0CkNP TkZJR19IQVZFX0lERT15CiMgQ09ORklHX0lERSBpcyBub3Qgc2V0CgojCiMgU0NTSSBkZXZp Y2Ugc3VwcG9ydAojCkNPTkZJR19TQ1NJX01PRD15CiMgQ09ORklHX1JBSURfQVRUUlMgaXMg bm90IHNldApDT05GSUdfU0NTST15CkNPTkZJR19TQ1NJX0RNQT15CiMgQ09ORklHX1NDU0lf VEdUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0NTSV9ORVRMSU5LIGlzIG5vdCBzZXQKQ09ORklH X1NDU0lfUFJPQ19GUz15CgojCiMgU0NTSSBzdXBwb3J0IHR5cGUgKGRpc2ssIHRhcGUsIENE LVJPTSkKIwpDT05GSUdfQkxLX0RFVl9TRD15CiMgQ09ORklHX0NIUl9ERVZfU1QgaXMgbm90 IHNldAojIENPTkZJR19DSFJfREVWX09TU1QgaXMgbm90IHNldApDT05GSUdfQkxLX0RFVl9T Uj15CkNPTkZJR19CTEtfREVWX1NSX1ZFTkRPUj15CkNPTkZJR19DSFJfREVWX1NHPXkKIyBD T05GSUdfQ0hSX0RFVl9TQ0ggaXMgbm90IHNldAojIENPTkZJR19TQ1NJX01VTFRJX0xVTiBp cyBub3Qgc2V0CkNPTkZJR19TQ1NJX0NPTlNUQU5UUz15CiMgQ09ORklHX1NDU0lfTE9HR0lO RyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfU0NBTl9BU1lOQyBpcyBub3Qgc2V0CgojCiMg U0NTSSBUcmFuc3BvcnRzCiMKQ09ORklHX1NDU0lfU1BJX0FUVFJTPXkKIyBDT05GSUdfU0NT SV9GQ19BVFRSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfSVNDU0lfQVRUUlMgaXMgbm90 IHNldAojIENPTkZJR19TQ1NJX1NBU19BVFRSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lf U0FTX0xJQlNBUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfU1JQX0FUVFJTIGlzIG5vdCBz ZXQKIyBDT05GSUdfU0NTSV9MT1dMRVZFTCBpcyBub3Qgc2V0CiMgQ09ORklHX1NDU0lfREgg aXMgbm90IHNldAojIENPTkZJR19TQ1NJX09TRF9JTklUSUFUT1IgaXMgbm90IHNldApDT05G SUdfQVRBPXkKIyBDT05GSUdfQVRBX05PTlNUQU5EQVJEIGlzIG5vdCBzZXQKQ09ORklHX0FU QV9WRVJCT1NFX0VSUk9SPXkKQ09ORklHX0FUQV9BQ1BJPXkKQ09ORklHX1NBVEFfUE1QPXkK CiMKIyBDb250cm9sbGVycyB3aXRoIG5vbi1TRkYgbmF0aXZlIGludGVyZmFjZQojCkNPTkZJ R19TQVRBX0FIQ0k9eQpDT05GSUdfU0FUQV9BSENJX1BMQVRGT1JNPXkKIyBDT05GSUdfU0FU QV9JTklDMTYyWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NBVEFfQUNBUkRfQUhDSSBpcyBub3Qg c2V0CiMgQ09ORklHX1NBVEFfU0lMMjQgaXMgbm90IHNldAojIENPTkZJR19BVEFfU0ZGIGlz IG5vdCBzZXQKQ09ORklHX01EPXkKIyBDT05GSUdfQkxLX0RFVl9NRCBpcyBub3Qgc2V0CkNP TkZJR19CTEtfREVWX0RNPXkKQ09ORklHX0RNX0RFQlVHPXkKQ09ORklHX0RNX0NSWVBUPXkK Q09ORklHX0RNX1NOQVBTSE9UPXkKIyBDT05GSUdfRE1fVEhJTl9QUk9WSVNJT05JTkcgaXMg bm90IHNldApDT05GSUdfRE1fTUlSUk9SPXkKIyBDT05GSUdfRE1fUkFJRCBpcyBub3Qgc2V0 CiMgQ09ORklHX0RNX0xPR19VU0VSU1BBQ0UgaXMgbm90IHNldApDT05GSUdfRE1fWkVSTz15 CiMgQ09ORklHX0RNX01VTFRJUEFUSCBpcyBub3Qgc2V0CiMgQ09ORklHX0RNX0RFTEFZIGlz IG5vdCBzZXQKIyBDT05GSUdfRE1fVUVWRU5UIGlzIG5vdCBzZXQKIyBDT05GSUdfRE1fRkxB S0VZIGlzIG5vdCBzZXQKIyBDT05GSUdfRE1fVkVSSVRZIGlzIG5vdCBzZXQKIyBDT05GSUdf VEFSR0VUX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19GVVNJT04gaXMgbm90IHNldAoKIwoj IElFRUUgMTM5NCAoRmlyZVdpcmUpIHN1cHBvcnQKIwojIENPTkZJR19GSVJFV0lSRSBpcyBu b3Qgc2V0CiMgQ09ORklHX0ZJUkVXSVJFX05PU1kgaXMgbm90IHNldAojIENPTkZJR19JMk8g aXMgbm90IHNldAojIENPTkZJR19NQUNJTlRPU0hfRFJJVkVSUyBpcyBub3Qgc2V0CkNPTkZJ R19ORVRERVZJQ0VTPXkKQ09ORklHX05FVF9DT1JFPXkKIyBDT05GSUdfQk9ORElORyBpcyBu b3Qgc2V0CiMgQ09ORklHX0RVTU1ZIGlzIG5vdCBzZXQKIyBDT05GSUdfRVFVQUxJWkVSIGlz IG5vdCBzZXQKIyBDT05GSUdfTkVUX0ZDIGlzIG5vdCBzZXQKQ09ORklHX01JST15CiMgQ09O RklHX0lGQiBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9URUFNIGlzIG5vdCBzZXQKIyBDT05G SUdfTUFDVkxBTiBpcyBub3Qgc2V0CiMgQ09ORklHX1ZYTEFOIGlzIG5vdCBzZXQKQ09ORklH X05FVENPTlNPTEU9eQpDT05GSUdfTkVUUE9MTD15CiMgQ09ORklHX05FVFBPTExfVFJBUCBp cyBub3Qgc2V0CkNPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSPXkKQ09ORklHX1RVTj15CkNP TkZJR19WRVRIPXkKIyBDT05GSUdfQVJDTkVUIGlzIG5vdCBzZXQKCiMKIyBDQUlGIHRyYW5z cG9ydCBkcml2ZXJzCiMKQ09ORklHX0VUSEVSTkVUPXkKIyBDT05GSUdfTkVUX1ZFTkRPUl8z Q09NIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9BREFQVEVDIGlzIG5vdCBzZXQK IyBDT05GSUdfTkVUX1ZFTkRPUl9BTFRFT04gaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVO RE9SX0FNRCBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfQVRIRVJPUyBpcyBub3Qg c2V0CiMgQ09ORklHX05FVF9WRU5ET1JfQlJPQURDT00gaXMgbm90IHNldAojIENPTkZJR19O RVRfVkVORE9SX0JST0NBREUgaXMgbm90IHNldAojIENPTkZJR19ORVRfQ0FMWEVEQV9YR01B QyBpcyBub3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfQ0hFTFNJTyBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9WRU5ET1JfQ0lTQ08gaXMgbm90IHNldAojIENPTkZJR19ETkVUIGlzIG5v dCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9ERUMgaXMgbm90IHNldAojIENPTkZJR19ORVRf VkVORE9SX0RMSU5LIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9FTVVMRVggaXMg bm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX0VYQVIgaXMgbm90IHNldAojIENPTkZJR19O RVRfVkVORE9SX0hQIGlzIG5vdCBzZXQKQ09ORklHX05FVF9WRU5ET1JfSU5URUw9eQojIENP TkZJR19FMTAwIGlzIG5vdCBzZXQKQ09ORklHX0UxMDAwPXkKQ09ORklHX0UxMDAwRT15CkNP TkZJR19JR0I9eQojIENPTkZJR19JR0JfUFRQIGlzIG5vdCBzZXQKQ09ORklHX0lHQlZGPXkK IyBDT05GSUdfSVhHQiBpcyBub3Qgc2V0CiMgQ09ORklHX0lYR0JFIGlzIG5vdCBzZXQKIyBD T05GSUdfSVhHQkVWRiBpcyBub3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX0k4MjVYWD15CiMg Q09ORklHX1pORVQgaXMgbm90IHNldAojIENPTkZJR19JUDEwMDAgaXMgbm90IHNldAojIENP TkZJR19KTUUgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX01BUlZFTEwgaXMgbm90 IHNldAojIENPTkZJR19ORVRfVkVORE9SX01FTExBTk9YIGlzIG5vdCBzZXQKIyBDT05GSUdf TkVUX1ZFTkRPUl9NSUNSRUwgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX01ZUkkg aXMgbm90IHNldAojIENPTkZJR19GRUFMTlggaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVO RE9SX05BVFNFTUkgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX05WSURJQSBpcyBu b3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfT0tJIGlzIG5vdCBzZXQKIyBDT05GSUdfRVRI T0MgaXMgbm90IHNldAojIENPTkZJR19ORVRfUEFDS0VUX0VOR0lORSBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9WRU5ET1JfUUxPR0lDIGlzIG5vdCBzZXQKQ09ORklHX05FVF9WRU5ET1Jf UkVBTFRFSz15CiMgQ09ORklHXzgxMzlDUCBpcyBub3Qgc2V0CiMgQ09ORklHXzgxMzlUT08g aXMgbm90IHNldApDT05GSUdfUjgxNjk9eQojIENPTkZJR19ORVRfVkVORE9SX1JEQyBpcyBu b3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX1NFRVE9eQojIENPTkZJR19TRUVRODAwNSBpcyBu b3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX1NJTEFOPXkKIyBDT05GSUdfU0M5MjAzMSBpcyBu b3Qgc2V0CiMgQ09ORklHX05FVF9WRU5ET1JfU0lTIGlzIG5vdCBzZXQKIyBDT05GSUdfU0ZD IGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9TTVNDIGlzIG5vdCBzZXQKIyBDT05G SUdfTkVUX1ZFTkRPUl9TVE1JQ1JPIGlzIG5vdCBzZXQKIyBDT05GSUdfTkVUX1ZFTkRPUl9T VU4gaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1RFSFVUSSBpcyBub3Qgc2V0CiMg Q09ORklHX05FVF9WRU5ET1JfVEkgaXMgbm90IHNldAojIENPTkZJR19ORVRfVkVORE9SX1ZJ QSBpcyBub3Qgc2V0CkNPTkZJR19ORVRfVkVORE9SX1dJWk5FVD15CiMgQ09ORklHX1dJWk5F VF9XNTEwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1dJWk5FVF9XNTMwMCBpcyBub3Qgc2V0CiMg Q09ORklHX0ZEREkgaXMgbm90IHNldAojIENPTkZJR19ISVBQSSBpcyBub3Qgc2V0CiMgQ09O RklHX05FVF9TQjEwMDAgaXMgbm90IHNldApDT05GSUdfUEhZTElCPXkKCiMKIyBNSUkgUEhZ IGRldmljZSBkcml2ZXJzCiMKIyBDT05GSUdfQVQ4MDNYX1BIWSBpcyBub3Qgc2V0CiMgQ09O RklHX0FNRF9QSFkgaXMgbm90IHNldAojIENPTkZJR19NQVJWRUxMX1BIWSBpcyBub3Qgc2V0 CiMgQ09ORklHX0RBVklDT01fUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfUVNFTUlfUEhZIGlz IG5vdCBzZXQKIyBDT05GSUdfTFhUX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX0NJQ0FEQV9Q SFkgaXMgbm90IHNldAojIENPTkZJR19WSVRFU1NFX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklH X1NNU0NfUEhZIGlzIG5vdCBzZXQKIyBDT05GSUdfQlJPQURDT01fUEhZIGlzIG5vdCBzZXQK IyBDT05GSUdfQkNNODdYWF9QSFkgaXMgbm90IHNldAojIENPTkZJR19JQ1BMVVNfUEhZIGlz IG5vdCBzZXQKQ09ORklHX1JFQUxURUtfUEhZPXkKIyBDT05GSUdfTkFUSU9OQUxfUEhZIGlz IG5vdCBzZXQKIyBDT05GSUdfU1RFMTBYUCBpcyBub3Qgc2V0CiMgQ09ORklHX0xTSV9FVDEw MTFDX1BIWSBpcyBub3Qgc2V0CiMgQ09ORklHX01JQ1JFTF9QSFkgaXMgbm90IHNldAojIENP TkZJR19GSVhFRF9QSFkgaXMgbm90IHNldAojIENPTkZJR19NRElPX0JJVEJBTkcgaXMgbm90 IHNldAojIENPTkZJR19QUFAgaXMgbm90IHNldAojIENPTkZJR19TTElQIGlzIG5vdCBzZXQK CiMKIyBVU0IgTmV0d29yayBBZGFwdGVycwojCiMgQ09ORklHX1VTQl9DQVRDIGlzIG5vdCBz ZXQKIyBDT05GSUdfVVNCX0tBV0VUSCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9QRUdBU1VT IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1JUTDgxNTAgaXMgbm90IHNldAojIENPTkZJR19V 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 WUJPQVJEX09NQVA0IGlzIG5vdCBzZXQKIyBDT05GSUdfS0VZQk9BUkRfWFRLQkQgaXMgbm90 IHNldApDT05GSUdfSU5QVVRfTU9VU0U9eQpDT05GSUdfTU9VU0VfUFMyPXkKQ09ORklHX01P VVNFX1BTMl9BTFBTPXkKQ09ORklHX01PVVNFX1BTMl9MT0dJUFMyUFA9eQpDT05GSUdfTU9V U0VfUFMyX1NZTkFQVElDUz15CkNPTkZJR19NT1VTRV9QUzJfTElGRUJPT0s9eQpDT05GSUdf TU9VU0VfUFMyX1RSQUNLUE9JTlQ9eQojIENPTkZJR19NT1VTRV9QUzJfRUxBTlRFQ0ggaXMg bm90IHNldAojIENPTkZJR19NT1VTRV9QUzJfU0VOVEVMSUMgaXMgbm90IHNldAojIENPTkZJ R19NT1VTRV9QUzJfVE9VQ0hLSVQgaXMgbm90IHNldAojIENPTkZJR19NT1VTRV9TRVJJQUwg aXMgbm90IHNldAojIENPTkZJR19NT1VTRV9BUFBMRVRPVUNIIGlzIG5vdCBzZXQKIyBDT05G SUdfTU9VU0VfQkNNNTk3NCBpcyBub3Qgc2V0CiMgQ09ORklHX01PVVNFX1ZTWFhYQUEgaXMg bm90IHNldAojIENPTkZJR19NT1VTRV9TWU5BUFRJQ1NfSTJDIGlzIG5vdCBzZXQKIyBDT05G SUdfTU9VU0VfU1lOQVBUSUNTX1VTQiBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVUX0pPWVNU SUNLIGlzIG5vdCBzZXQKQ09ORklHX0lOUFVUX1RBQkxFVD15CiMgQ09ORklHX1RBQkxFVF9V U0JfQUNFQ0FEIGlzIG5vdCBzZXQKIyBDT05GSUdfVEFCTEVUX1VTQl9BSVBURUsgaXMgbm90 IHNldAojIENPTkZJR19UQUJMRVRfVVNCX0dUQ08gaXMgbm90IHNldAojIENPTkZJR19UQUJM RVRfVVNCX0hBTldBTkcgaXMgbm90IHNldAojIENPTkZJR19UQUJMRVRfVVNCX0tCVEFCIGlz IG5vdCBzZXQKIyBDT05GSUdfVEFCTEVUX1VTQl9XQUNPTSBpcyBub3Qgc2V0CkNPTkZJR19J TlBVVF9UT1VDSFNDUkVFTj15CiMgQ09ORklHX1RPVUNIU0NSRUVOX0FENzg3OSBpcyBub3Qg c2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0FUTUVMX01YVCBpcyBub3Qgc2V0CiMgQ09ORklH X1RPVUNIU0NSRUVOX0JVMjEwMTMgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9D WVRUU1BfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0RZTkFQUk8gaXMg bm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9IQU1QU0hJUkUgaXMgbm90IHNldAojIENP TkZJR19UT1VDSFNDUkVFTl9FRVRJIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5f RlVKSVRTVSBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0lMSTIxMFggaXMgbm90 IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9HVU5aRSBpcyBub3Qgc2V0CiMgQ09ORklHX1RP VUNIU0NSRUVOX0VMTyBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX1dBQ09NX1c4 MDAxIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fV0FDT01fSTJDIGlzIG5vdCBz ZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fTUFYMTE4MDEgaXMgbm90IHNldAojIENPTkZJR19U T1VDSFNDUkVFTl9NQ1M1MDAwIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fTU1T MTE0IGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fTVRPVUNIIGlzIG5vdCBzZXQK IyBDT05GSUdfVE9VQ0hTQ1JFRU5fSU5FWElPIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9VQ0hT Q1JFRU5fTUs3MTIgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9QRU5NT1VOVCBp cyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NSRUVOX0VEVF9GVDVYMDYgaXMgbm90IHNldAoj IENPTkZJR19UT1VDSFNDUkVFTl9UT1VDSFJJR0hUIGlzIG5vdCBzZXQKIyBDT05GSUdfVE9V Q0hTQ1JFRU5fVE9VQ0hXSU4gaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9QSVhD SVIgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9VU0JfQ09NUE9TSVRFIGlzIG5v dCBzZXQKIyBDT05GSUdfVE9VQ0hTQ1JFRU5fVE9VQ0hJVDIxMyBpcyBub3Qgc2V0CiMgQ09O RklHX1RPVUNIU0NSRUVOX1RTQ19TRVJJTyBpcyBub3Qgc2V0CiMgQ09ORklHX1RPVUNIU0NS RUVOX1RTQzIwMDcgaXMgbm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9TVDEyMzIgaXMg bm90IHNldAojIENPTkZJR19UT1VDSFNDUkVFTl9UUFM2NTA3WCBpcyBub3Qgc2V0CkNPTkZJ R19JTlBVVF9NSVNDPXkKIyBDT05GSUdfSU5QVVRfQUQ3MTRYIGlzIG5vdCBzZXQKIyBDT05G SUdfSU5QVVRfQk1BMTUwIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfUENTUEtSIGlzIG5v dCBzZXQKIyBDT05GSUdfSU5QVVRfTU1BODQ1MCBpcyBub3Qgc2V0CiMgQ09ORklHX0lOUFVU X01QVTMwNTAgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9BUEFORUwgaXMgbm90IHNldAoj IENPTkZJR19JTlBVVF9BVExBU19CVE5TIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfQVRJ X1JFTU9URTIgaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9LRVlTUEFOX1JFTU9URSBpcyBu b3Qgc2V0CiMgQ09ORklHX0lOUFVUX0tYVEo5IGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRf UE9XRVJNQVRFIGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfWUVBTElOSyBpcyBub3Qgc2V0 CiMgQ09ORklHX0lOUFVUX0NNMTA5IGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfVUlOUFVU IGlzIG5vdCBzZXQKIyBDT05GSUdfSU5QVVRfUENGODU3NCBpcyBub3Qgc2V0CiMgQ09ORklH X0lOUFVUX0FEWEwzNFggaXMgbm90IHNldAojIENPTkZJR19JTlBVVF9DTUEzMDAwIGlzIG5v dCBzZXQKQ09ORklHX0lOUFVUX1hFTl9LQkRERVZfRlJPTlRFTkQ9eQoKIwojIEhhcmR3YXJl IEkvTyBwb3J0cwojCkNPTkZJR19TRVJJTz15CkNPTkZJR19TRVJJT19JODA0Mj15CkNPTkZJ R19TRVJJT19TRVJQT1JUPXkKIyBDT05GSUdfU0VSSU9fQ1Q4MkM3MTAgaXMgbm90IHNldAoj IENPTkZJR19TRVJJT19QQ0lQUzIgaXMgbm90IHNldApDT05GSUdfU0VSSU9fTElCUFMyPXkK IyBDT05GSUdfU0VSSU9fUkFXIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSU9fQUxURVJBX1BT MiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFUklPX1BTMk1VTFQgaXMgbm90IHNldAojIENPTkZJ R19HQU1FUE9SVCBpcyBub3Qgc2V0CgojCiMgQ2hhcmFjdGVyIGRldmljZXMKIwpDT05GSUdf VlQ9eQpDT05GSUdfQ09OU09MRV9UUkFOU0xBVElPTlM9eQpDT05GSUdfVlRfQ09OU09MRT15 CkNPTkZJR19WVF9DT05TT0xFX1NMRUVQPXkKQ09ORklHX0hXX0NPTlNPTEU9eQpDT05GSUdf VlRfSFdfQ09OU09MRV9CSU5ESU5HPXkKQ09ORklHX1VOSVg5OF9QVFlTPXkKIyBDT05GSUdf REVWUFRTX01VTFRJUExFX0lOU1RBTkNFUyBpcyBub3Qgc2V0CiMgQ09ORklHX0xFR0FDWV9Q VFlTIGlzIG5vdCBzZXQKQ09ORklHX1NFUklBTF9OT05TVEFOREFSRD15CiMgQ09ORklHX1JP Q0tFVFBPUlQgaXMgbm90IHNldAojIENPTkZJR19DWUNMQURFUyBpcyBub3Qgc2V0CiMgQ09O RklHX01PWEFfSU5URUxMSU8gaXMgbm90IHNldAojIENPTkZJR19NT1hBX1NNQVJUSU8gaXMg bm90IHNldAojIENPTkZJR19TWU5DTElOSyBpcyBub3Qgc2V0CiMgQ09ORklHX1NZTkNMSU5L TVAgaXMgbm90IHNldAojIENPTkZJR19TWU5DTElOS19HVCBpcyBub3Qgc2V0CiMgQ09ORklH X05PWk9NSSBpcyBub3Qgc2V0CiMgQ09ORklHX0lTSSBpcyBub3Qgc2V0CiMgQ09ORklHX05f SERMQyBpcyBub3Qgc2V0CiMgQ09ORklHX05fR1NNIGlzIG5vdCBzZXQKIyBDT05GSUdfVFJB Q0VfU0lOSyBpcyBub3Qgc2V0CiMgQ09ORklHX0RFVktNRU0gaXMgbm90IHNldAojIENPTkZJ R19TVEFMRFJWIGlzIG5vdCBzZXQKCiMKIyBTZXJpYWwgZHJpdmVycwojCkNPTkZJR19TRVJJ QUxfODI1MD15CkNPTkZJR19TRVJJQUxfODI1MF9QTlA9eQpDT05GSUdfU0VSSUFMXzgyNTBf Q09OU09MRT15CkNPTkZJR19GSVhfRUFSTFlDT05fTUVNPXkKQ09ORklHX1NFUklBTF84MjUw X1BDST15CkNPTkZJR19TRVJJQUxfODI1MF9OUl9VQVJUUz0zMgpDT05GSUdfU0VSSUFMXzgy NTBfUlVOVElNRV9VQVJUUz00CkNPTkZJR19TRVJJQUxfODI1MF9FWFRFTkRFRD15CkNPTkZJ R19TRVJJQUxfODI1MF9NQU5ZX1BPUlRTPXkKQ09ORklHX1NFUklBTF84MjUwX1NIQVJFX0lS UT15CkNPTkZJR19TRVJJQUxfODI1MF9ERVRFQ1RfSVJRPXkKQ09ORklHX1NFUklBTF84MjUw X1JTQT15CgojCiMgTm9uLTgyNTAgc2VyaWFsIHBvcnQgc3VwcG9ydAojCiMgQ09ORklHX1NF UklBTF9NRkRfSFNVIGlzIG5vdCBzZXQKQ09ORklHX1NFUklBTF9DT1JFPXkKQ09ORklHX1NF UklBTF9DT1JFX0NPTlNPTEU9eQojIENPTkZJR19TRVJJQUxfSlNNIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VSSUFMX1NDQ05YUCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFUklBTF9USU1CRVJE QUxFIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VSSUFMX0FMVEVSQV9KVEFHVUFSVCBpcyBub3Qg c2V0CiMgQ09ORklHX1NFUklBTF9BTFRFUkFfVUFSVCBpcyBub3Qgc2V0CiMgQ09ORklHX1NF UklBTF9QQ0hfVUFSVCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFUklBTF9YSUxJTlhfUFNfVUFS VCBpcyBub3Qgc2V0CkNPTkZJR19IVkNfRFJJVkVSPXkKQ09ORklHX0hWQ19JUlE9eQpDT05G SUdfSFZDX1hFTj15CkNPTkZJR19IVkNfWEVOX0ZST05URU5EPXkKIyBDT05GSUdfSVBNSV9I QU5ETEVSIGlzIG5vdCBzZXQKQ09ORklHX0hXX1JBTkRPTT15CkNPTkZJR19IV19SQU5ET01f VElNRVJJT01FTT15CkNPTkZJR19IV19SQU5ET01fSU5URUw9eQpDT05GSUdfSFdfUkFORE9N X0FNRD15CkNPTkZJR19IV19SQU5ET01fVklBPXkKIyBDT05GSUdfTlZSQU0gaXMgbm90IHNl dAojIENPTkZJR19SMzk2NCBpcyBub3Qgc2V0CiMgQ09ORklHX0FQUExJQ09NIGlzIG5vdCBz ZXQKIyBDT05GSUdfTVdBVkUgaXMgbm90IHNldAojIENPTkZJR19SQVdfRFJJVkVSIGlzIG5v dCBzZXQKQ09ORklHX0hQRVQ9eQojIENPTkZJR19IUEVUX01NQVAgaXMgbm90IHNldApDT05G SUdfSEFOR0NIRUNLX1RJTUVSPXkKIyBDT05GSUdfVENHX1RQTSBpcyBub3Qgc2V0CiMgQ09O RklHX1RFTENMT0NLIGlzIG5vdCBzZXQKQ09ORklHX0RFVlBPUlQ9eQpDT05GSUdfSTJDPXkK Q09ORklHX0kyQ19CT0FSRElORk89eQpDT05GSUdfSTJDX0NPTVBBVD15CiMgQ09ORklHX0ky Q19DSEFSREVWIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX01VWCBpcyBub3Qgc2V0CkNPTkZJ R19JMkNfSEVMUEVSX0FVVE89eQpDT05GSUdfSTJDX0FMR09CSVQ9eQoKIwojIEkyQyBIYXJk d2FyZSBCdXMgc3VwcG9ydAojCgojCiMgUEMgU01CdXMgaG9zdCBjb250cm9sbGVyIGRyaXZl cnMKIwojIENPTkZJR19JMkNfQUxJMTUzNSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19BTEkx NTYzIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX0FMSTE1WDMgaXMgbm90IHNldApDT05GSUdf STJDX0FNRDc1Nj15CiMgQ09ORklHX0kyQ19BTUQ3NTZfUzQ4ODIgaXMgbm90IHNldApDT05G SUdfSTJDX0FNRDgxMTE9eQpDT05GSUdfSTJDX0k4MDE9eQpDT05GSUdfSTJDX0lTQ0g9eQpD T05GSUdfSTJDX1BJSVg0PXkKIyBDT05GSUdfSTJDX05GT1JDRTIgaXMgbm90IHNldAojIENP TkZJR19JMkNfU0lTNTU5NSBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19TSVM2MzAgaXMgbm90 IHNldAojIENPTkZJR19JMkNfU0lTOTZYIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX1ZJQSBp cyBub3Qgc2V0CiMgQ09ORklHX0kyQ19WSUFQUk8gaXMgbm90IHNldAoKIwojIEFDUEkgZHJp dmVycwojCkNPTkZJR19JMkNfU0NNST15CgojCiMgSTJDIHN5c3RlbSBidXMgZHJpdmVycyAo bW9zdGx5IGVtYmVkZGVkIC8gc3lzdGVtLW9uLWNoaXApCiMKIyBDT05GSUdfSTJDX0RFU0lH TldBUkVfUENJIGlzIG5vdCBzZXQKIyBDT05GSUdfSTJDX0VHMjBUIGlzIG5vdCBzZXQKIyBD T05GSUdfSTJDX0lOVEVMX01JRCBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19PQ09SRVMgaXMg bm90IHNldAojIENPTkZJR19JMkNfUENBX1BMQVRGT1JNIGlzIG5vdCBzZXQKIyBDT05GSUdf STJDX1BYQV9QQ0kgaXMgbm90IHNldAojIENPTkZJR19JMkNfU0lNVEVDIGlzIG5vdCBzZXQK IyBDT05GSUdfSTJDX1hJTElOWCBpcyBub3Qgc2V0CgojCiMgRXh0ZXJuYWwgSTJDL1NNQnVz IGFkYXB0ZXIgZHJpdmVycwojCiMgQ09ORklHX0kyQ19ESU9MQU5fVTJDIGlzIG5vdCBzZXQK IyBDT05GSUdfSTJDX1BBUlBPUlRfTElHSFQgaXMgbm90IHNldAojIENPTkZJR19JMkNfVEFP U19FVk0gaXMgbm90IHNldAojIENPTkZJR19JMkNfVElOWV9VU0IgaXMgbm90IHNldAoKIwoj IE90aGVyIEkyQy9TTUJ1cyBidXMgZHJpdmVycwojCiMgQ09ORklHX0kyQ19TVFVCIGlzIG5v dCBzZXQKIyBDT05GSUdfSTJDX0RFQlVHX0NPUkUgaXMgbm90IHNldAojIENPTkZJR19JMkNf REVCVUdfQUxHTyBpcyBub3Qgc2V0CiMgQ09ORklHX0kyQ19ERUJVR19CVVMgaXMgbm90IHNl dAojIENPTkZJR19TUEkgaXMgbm90IHNldAojIENPTkZJR19IU0kgaXMgbm90IHNldAoKIwoj IFBQUyBzdXBwb3J0CiMKIyBDT05GSUdfUFBTIGlzIG5vdCBzZXQKCiMKIyBQUFMgZ2VuZXJh dG9ycyBzdXBwb3J0CiMKCiMKIyBQVFAgY2xvY2sgc3VwcG9ydAojCgojCiMgRW5hYmxlIERl dmljZSBEcml2ZXJzIC0+IFBQUyB0byBzZWUgdGhlIFBUUCBjbG9jayBvcHRpb25zLgojCkNP TkZJR19BUkNIX1dBTlRfT1BUSU9OQUxfR1BJT0xJQj15CiMgQ09ORklHX0dQSU9MSUIgaXMg bm90IHNldAojIENPTkZJR19XMSBpcyBub3Qgc2V0CkNPTkZJR19QT1dFUl9TVVBQTFk9eQoj IENPTkZJR19QT1dFUl9TVVBQTFlfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19QREFfUE9X RVIgaXMgbm90IHNldAojIENPTkZJR19URVNUX1BPV0VSIGlzIG5vdCBzZXQKIyBDT05GSUdf QkFUVEVSWV9EUzI3ODAgaXMgbm90IHNldAojIENPTkZJR19CQVRURVJZX0RTMjc4MSBpcyBu b3Qgc2V0CiMgQ09ORklHX0JBVFRFUllfRFMyNzgyIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFU VEVSWV9TQlMgaXMgbm90IHNldAojIENPTkZJR19CQVRURVJZX0JRMjd4MDAgaXMgbm90IHNl dAojIENPTkZJR19CQVRURVJZX01BWDE3MDQwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFUVEVS WV9NQVgxNzA0MiBpcyBub3Qgc2V0CiMgQ09ORklHX0NIQVJHRVJfTUFYODkwMyBpcyBub3Qg c2V0CiMgQ09ORklHX0NIQVJHRVJfTFA4NzI3IGlzIG5vdCBzZXQKIyBDT05GSUdfQ0hBUkdF Ul9TTUIzNDcgaXMgbm90IHNldAojIENPTkZJR19QT1dFUl9BVlMgaXMgbm90IHNldApDT05G SUdfSFdNT049eQpDT05GSUdfSFdNT05fVklEPXkKIyBDT05GSUdfSFdNT05fREVCVUdfQ0hJ UCBpcyBub3Qgc2V0CgojCiMgTmF0aXZlIGRyaXZlcnMKIwojIENPTkZJR19TRU5TT1JTX0FC SVRVR1VSVSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfQUJJVFVHVVJVMyBpcyBub3Qg c2V0CiMgQ09ORklHX1NFTlNPUlNfQUQ3NDE0IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09S U19BRDc0MTggaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FETTEwMjEgaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX0FETTEwMjUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0FETTEwMjYgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FETTEwMjkgaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX0FETTEwMzEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0FETTkyNDAgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FEVDc0MTAgaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX0FEVDc0MTEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0FEVDc0NjIgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0FEVDc0NzAgaXMgbm90IHNl dAojIENPTkZJR19TRU5TT1JTX0FEVDc0NzUgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JT X0FTQzc2MjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0s4VEVNUCBpcyBub3Qgc2V0 CkNPTkZJR19TRU5TT1JTX0sxMFRFTVA9eQpDT05GSUdfU0VOU09SU19GQU0xNUhfUE9XRVI9 eQojIENPTkZJR19TRU5TT1JTX0FTQjEwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNf QVRYUDEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0RTNjIwIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19EUzE2MjEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0k1S19B TUIgaXMgbm90IHNldApDT05GSUdfU0VOU09SU19GNzE4MDVGPXkKQ09ORklHX1NFTlNPUlNf RjcxODgyRkc9eQpDT05GSUdfU0VOU09SU19GNzUzNzVTPXkKIyBDT05GSUdfU0VOU09SU19G U0NITUQgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX0c3NjBBIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19HTDUxOFNNIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19HTDUy MFNNIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19ISUg2MTMwIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19DT1JFVEVNUCBpcyBub3Qgc2V0CkNPTkZJR19TRU5TT1JTX0lUODc9 eQpDT05GSUdfU0VOU09SU19KQzQyPXkKIyBDT05GSUdfU0VOU09SU19MSU5FQUdFIGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTYzIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09S U19MTTczIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTc1IGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19MTTc3IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTc4IGlz IG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTgwIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VO U09SU19MTTgzIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTg1IGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19MTTg3IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTkw IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTkyIGlzIG5vdCBzZXQKIyBDT05GSUdf U0VOU09SU19MTTkzIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MVEM0MTUxIGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19MVEM0MjE1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VO U09SU19MVEM0MjQ1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19MVEM0MjYxIGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19MTTk1MjQxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VO U09SU19MTTk1MjQ1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVgxNjA2NSBpcyBu b3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfTUFYMTYxOSBpcyBub3Qgc2V0CiMgQ09ORklHX1NF TlNPUlNfTUFYMTY2OCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfTUFYMTk3IGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVg2NjM5IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VO U09SU19NQVg2NjQyIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19NQVg2NjUwIGlzIG5v dCBzZXQKIyBDT05GSUdfU0VOU09SU19NQ1AzMDIxIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VO U09SU19OVENfVEhFUk1JU1RPUiBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfUEM4NzM2 MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfUEM4NzQyNyBpcyBub3Qgc2V0CiMgQ09O RklHX1NFTlNPUlNfUENGODU5MSBpcyBub3Qgc2V0CiMgQ09ORklHX1BNQlVTIGlzIG5vdCBz ZXQKIyBDT05GSUdfU0VOU09SU19TSFQyMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNf U0lTNTU5NSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfU01NNjY1IGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19ETUUxNzM3IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19F TUMxNDAzIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19FTUMyMTAzIGlzIG5vdCBzZXQK IyBDT05GSUdfU0VOU09SU19FTUM2VzIwMSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNf U01TQzQ3TTEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1NNU0M0N00xOTIgaXMgbm90 IHNldAojIENPTkZJR19TRU5TT1JTX1NNU0M0N0IzOTcgaXMgbm90IHNldAojIENPTkZJR19T RU5TT1JTX1NDSDU2WFhfQ09NTU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19TQ0g1 NjI3IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19TQ0g1NjM2IGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19BRFMxMDE1IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BRFM3 ODI4IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19BTUM2ODIxIGlzIG5vdCBzZXQKIyBD T05GSUdfU0VOU09SU19JTkEyWFggaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1RITUM1 MCBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVE1QMTAyIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19UTVA0MDEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1RNUDQyMSBp cyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVklBX0NQVVRFTVAgaXMgbm90IHNldAojIENP TkZJR19TRU5TT1JTX1ZJQTY4NkEgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1ZUMTIx MSBpcyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVlQ4MjMxIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19XODM3ODFEIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19XODM3OTFE IGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19XODM3OTJEIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19XODM3OTMgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1c4Mzc5NSBp cyBub3Qgc2V0CiMgQ09ORklHX1NFTlNPUlNfVzgzTDc4NVRTIGlzIG5vdCBzZXQKIyBDT05G SUdfU0VOU09SU19XODNMNzg2TkcgaXMgbm90IHNldAojIENPTkZJR19TRU5TT1JTX1c4MzYy N0hGIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VOU09SU19XODM2MjdFSEYgaXMgbm90IHNldAoj IENPTkZJR19TRU5TT1JTX0FQUExFU01DIGlzIG5vdCBzZXQKCiMKIyBBQ1BJIGRyaXZlcnMK IwpDT05GSUdfU0VOU09SU19BQ1BJX1BPV0VSPXkKIyBDT05GSUdfU0VOU09SU19BVEswMTEw IGlzIG5vdCBzZXQKQ09ORklHX1RIRVJNQUw9eQpDT05GSUdfVEhFUk1BTF9IV01PTj15CiMg Q09ORklHX0NQVV9USEVSTUFMIGlzIG5vdCBzZXQKQ09ORklHX1dBVENIRE9HPXkKQ09ORklH X1dBVENIRE9HX0NPUkU9eQojIENPTkZJR19XQVRDSERPR19OT1dBWU9VVCBpcyBub3Qgc2V0 CgojCiMgV2F0Y2hkb2cgRGV2aWNlIERyaXZlcnMKIwojIENPTkZJR19TT0ZUX1dBVENIRE9H IGlzIG5vdCBzZXQKIyBDT05GSUdfQUNRVUlSRV9XRFQgaXMgbm90IHNldAojIENPTkZJR19B RFZBTlRFQ0hfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfQUxJTTE1MzVfV0RUIGlzIG5vdCBz ZXQKIyBDT05GSUdfQUxJTTcxMDFfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfRjcxODA4RV9X RFQgaXMgbm90IHNldApDT05GSUdfU1A1MTAwX1RDTz15CiMgQ09ORklHX1NDNTIwX1dEVCBp cyBub3Qgc2V0CiMgQ09ORklHX1NCQ19GSVRQQzJfV0FUQ0hET0cgaXMgbm90IHNldAojIENP TkZJR19FVVJPVEVDSF9XRFQgaXMgbm90IHNldAojIENPTkZJR19JQjcwMF9XRFQgaXMgbm90 IHNldAojIENPTkZJR19JQk1BU1IgaXMgbm90IHNldAojIENPTkZJR19XQUZFUl9XRFQgaXMg bm90IHNldAojIENPTkZJR19JNjMwMEVTQl9XRFQgaXMgbm90IHNldAojIENPTkZJR19JRTZY WF9XRFQgaXMgbm90IHNldAojIENPTkZJR19JVENPX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklH X0lUODcxMkZfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfSVQ4N19XRFQgaXMgbm90IHNldAoj IENPTkZJR19IUF9XQVRDSERPRyBpcyBub3Qgc2V0CiMgQ09ORklHX1NDMTIwMF9XRFQgaXMg bm90IHNldAojIENPTkZJR19QQzg3NDEzX1dEVCBpcyBub3Qgc2V0CiMgQ09ORklHX05WX1RD TyBpcyBub3Qgc2V0CiMgQ09ORklHXzYwWFhfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0JD ODM2MF9XRFQgaXMgbm90IHNldAojIENPTkZJR19DUFU1X1dEVCBpcyBub3Qgc2V0CiMgQ09O RklHX1NNU0NfU0NIMzExWF9XRFQgaXMgbm90IHNldAojIENPTkZJR19TTVNDMzdCNzg3X1dE VCBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJQV9XRFQgaXMgbm90IHNldAojIENPTkZJR19XODM2 MjdIRl9XRFQgaXMgbm90IHNldAojIENPTkZJR19XODM2OTdIRl9XRFQgaXMgbm90IHNldAoj IENPTkZJR19XODM2OTdVR19XRFQgaXMgbm90IHNldAojIENPTkZJR19XODM4NzdGX1dEVCBp cyBub3Qgc2V0CiMgQ09ORklHX1c4Mzk3N0ZfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfTUFD SFpfV0RUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0JDX0VQWF9DM19XQVRDSERPRyBpcyBub3Qg c2V0CkNPTkZJR19YRU5fV0RUPXkKCiMKIyBQQ0ktYmFzZWQgV2F0Y2hkb2cgQ2FyZHMKIwoj IENPTkZJR19QQ0lQQ1dBVENIRE9HIGlzIG5vdCBzZXQKIyBDT05GSUdfV0RUUENJIGlzIG5v dCBzZXQKCiMKIyBVU0ItYmFzZWQgV2F0Y2hkb2cgQ2FyZHMKIwojIENPTkZJR19VU0JQQ1dB VENIRE9HIGlzIG5vdCBzZXQKQ09ORklHX1NTQl9QT1NTSUJMRT15CgojCiMgU29uaWNzIFNp bGljb24gQmFja3BsYW5lCiMKIyBDT05GSUdfU1NCIGlzIG5vdCBzZXQKQ09ORklHX0JDTUFf UE9TU0lCTEU9eQoKIwojIEJyb2FkY29tIHNwZWNpZmljIEFNQkEKIwojIENPTkZJR19CQ01B IGlzIG5vdCBzZXQKCiMKIyBNdWx0aWZ1bmN0aW9uIGRldmljZSBkcml2ZXJzCiMKQ09ORklH X01GRF9DT1JFPXkKIyBDT05GSUdfTUZEXzg4UE04NjBYIGlzIG5vdCBzZXQKIyBDT05GSUdf TUZEXzg4UE04MDAgaXMgbm90IHNldAojIENPTkZJR19NRkRfODhQTTgwNSBpcyBub3Qgc2V0 CiMgQ09ORklHX01GRF9TTTUwMSBpcyBub3Qgc2V0CiMgQ09ORklHX0hUQ19QQVNJQzMgaXMg bm90IHNldAojIENPTkZJR19NRkRfTE0zNTMzIGlzIG5vdCBzZXQKIyBDT05GSUdfVFBTNjEw NVggaXMgbm90IHNldAojIENPTkZJR19UUFM2NTA3WCBpcyBub3Qgc2V0CiMgQ09ORklHX01G RF9UUFM2NTIxNyBpcyBub3Qgc2V0CiMgQ09ORklHX1RXTDQwMzBfQ09SRSBpcyBub3Qgc2V0 CiMgQ09ORklHX1RXTDYwNDBfQ09SRSBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9TVE1QRSBp cyBub3Qgc2V0CiMgQ09ORklHX01GRF9UQzM1ODlYIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZE X1RNSU8gaXMgbm90IHNldAojIENPTkZJR19NRkRfU01TQyBpcyBub3Qgc2V0CiMgQ09ORklH X1BNSUNfREE5MDNYIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX0RBOTA1Ml9JMkMgaXMgbm90 IHNldAojIENPTkZJR19NRkRfREE5MDU1IGlzIG5vdCBzZXQKIyBDT05GSUdfUE1JQ19BRFA1 NTIwIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX0xQODc4OCBpcyBub3Qgc2V0CiMgQ09ORklH X01GRF9NQVg3NzY4NiBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9NQVg3NzY5MyBpcyBub3Qg c2V0CiMgQ09ORklHX01GRF9NQVg4OTA3IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX01BWDg5 MjUgaXMgbm90IHNldAojIENPTkZJR19NRkRfTUFYODk5NyBpcyBub3Qgc2V0CiMgQ09ORklH X01GRF9NQVg4OTk4IGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1NFQ19DT1JFIGlzIG5vdCBz ZXQKIyBDT05GSUdfTUZEX0FSSVpPTkFfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1dN ODQwMCBpcyBub3Qgc2V0CiMgQ09ORklHX01GRF9XTTgzMVhfSTJDIGlzIG5vdCBzZXQKIyBD T05GSUdfTUZEX1dNODM1MF9JMkMgaXMgbm90IHNldAojIENPTkZJR19NRkRfV004OTk0IGlz IG5vdCBzZXQKIyBDT05GSUdfTUZEX1BDRjUwNjMzIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZE X01DMTNYWFhfSTJDIGlzIG5vdCBzZXQKIyBDT05GSUdfQUJYNTAwX0NPUkUgaXMgbm90IHNl dAojIENPTkZJR19NRkRfQ1M1NTM1IGlzIG5vdCBzZXQKQ09ORklHX0xQQ19TQ0g9eQojIENP TkZJR19MUENfSUNIIGlzIG5vdCBzZXQKIyBDT05GSUdfTUZEX1JEQzMyMVggaXMgbm90IHNl dAojIENPTkZJR19NRkRfSkFOWl9DTU9ESU8gaXMgbm90IHNldAojIENPTkZJR19NRkRfVlg4 NTUgaXMgbm90IHNldAojIENPTkZJR19NRkRfV0wxMjczX0NPUkUgaXMgbm90IHNldAojIENP TkZJR19NRkRfVFBTNjUwOTAgaXMgbm90IHNldAojIENPTkZJR19NRkRfUkM1VDU4MyBpcyBu b3Qgc2V0CiMgQ09ORklHX01GRF9QQUxNQVMgaXMgbm90IHNldAojIENPTkZJR19SRUdVTEFU T1IgaXMgbm90IHNldApDT05GSUdfTUVESUFfU1VQUE9SVD15CgojCiMgTXVsdGltZWRpYSBj b3JlIHN1cHBvcnQKIwpDT05GSUdfTUVESUFfQ0FNRVJBX1NVUFBPUlQ9eQpDT05GSUdfTUVE SUFfQU5BTE9HX1RWX1NVUFBPUlQ9eQpDT05GSUdfTUVESUFfRElHSVRBTF9UVl9TVVBQT1JU PXkKQ09ORklHX01FRElBX1JBRElPX1NVUFBPUlQ9eQpDT05GSUdfTUVESUFfUkNfU1VQUE9S VD15CiMgQ09ORklHX01FRElBX0NPTlRST0xMRVIgaXMgbm90IHNldApDT05GSUdfVklERU9f REVWPXkKQ09ORklHX1ZJREVPX1Y0TDI9eQpDT05GSUdfVklERU9fQURWX0RFQlVHPXkKIyBD T05GSUdfVklERU9fRklYRURfTUlOT1JfUkFOR0VTIGlzIG5vdCBzZXQKQ09ORklHX1ZJREVP X1RVTkVSPXkKQ09ORklHX1ZJREVPQlVGX0dFTj15CkNPTkZJR19WSURFT0JVRl9ETUFfU0c9 eQpDT05GSUdfVklERU9CVUZfRFZCPXkKQ09ORklHX0RWQl9DT1JFPXkKQ09ORklHX0RWQl9O RVQ9eQpDT05GSUdfRFZCX01BWF9BREFQVEVSUz04CiMgQ09ORklHX0RWQl9EWU5BTUlDX01J Tk9SUyBpcyBub3Qgc2V0CgojCiMgTWVkaWEgZHJpdmVycwojCkNPTkZJR19SQ19DT1JFPXkK Q09ORklHX1JDX01BUD15CkNPTkZJR19SQ19ERUNPREVSUz15CkNPTkZJR19MSVJDPXkKQ09O RklHX0lSX0xJUkNfQ09ERUM9eQpDT05GSUdfSVJfTkVDX0RFQ09ERVI9eQpDT05GSUdfSVJf UkM1X0RFQ09ERVI9eQpDT05GSUdfSVJfUkM2X0RFQ09ERVI9eQpDT05GSUdfSVJfSlZDX0RF Q09ERVI9eQpDT05GSUdfSVJfU09OWV9ERUNPREVSPXkKQ09ORklHX0lSX1JDNV9TWl9ERUNP REVSPXkKQ09ORklHX0lSX1NBTllPX0RFQ09ERVI9eQpDT05GSUdfSVJfTUNFX0tCRF9ERUNP REVSPXkKIyBDT05GSUdfUkNfREVWSUNFUyBpcyBub3Qgc2V0CkNPTkZJR19NRURJQV9VU0Jf U1VQUE9SVD15CgojCiMgV2ViY2FtIGRldmljZXMKIwojIENPTkZJR19VU0JfVklERU9fQ0xB U1MgaXMgbm90IHNldAojIENPTkZJR19VU0JfR1NQQ0EgaXMgbm90IHNldAojIENPTkZJR19V U0JfUFdDIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fQ1BJQTIgaXMgbm90IHNldAojIENP TkZJR19VU0JfWlIzNjRYWCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVEtXRUJDQU0gaXMg bm90IHNldAojIENPTkZJR19VU0JfUzIyNTUgaXMgbm90IHNldAojIENPTkZJR19VU0JfU045 QzEwMiBpcyBub3Qgc2V0CgojCiMgQW5hbG9nIFRWIFVTQiBkZXZpY2VzCiMKIyBDT05GSUdf VklERU9fQVUwODI4IGlzIG5vdCBzZXQKQ09ORklHX1ZJREVPX1BWUlVTQjI9eQpDT05GSUdf VklERU9fUFZSVVNCMl9TWVNGUz15CkNPTkZJR19WSURFT19QVlJVU0IyX0RWQj15CiMgQ09O RklHX1ZJREVPX1BWUlVTQjJfREVCVUdJRkMgaXMgbm90IHNldAojIENPTkZJR19WSURFT19I RFBWUiBpcyBub3Qgc2V0CiMgQ09ORklHX1ZJREVPX1RMRzIzMDAgaXMgbm90IHNldAojIENP TkZJR19WSURFT19VU0JWSVNJT04gaXMgbm90IHNldAojIENPTkZJR19WSURFT19TVEsxMTYw IGlzIG5vdCBzZXQKCiMKIyBBbmFsb2cvZGlnaXRhbCBUViBVU0IgZGV2aWNlcwojCiMgQ09O RklHX1ZJREVPX0NYMjMxWFggaXMgbm90IHNldAojIENPTkZJR19WSURFT19UTTYwMDAgaXMg bm90IHNldAoKIwojIERpZ2l0YWwgVFYgVVNCIGRldmljZXMKIwojIENPTkZJR19EVkJfVVNC IGlzIG5vdCBzZXQKIyBDT05GSUdfRFZCX1VTQl9WMiBpcyBub3Qgc2V0CiMgQ09ORklHX0RW Ql9UVFVTQl9CVURHRVQgaXMgbm90IHNldAojIENPTkZJR19EVkJfVFRVU0JfREVDIGlzIG5v dCBzZXQKIyBDT05GSUdfU01TX1VTQl9EUlYgaXMgbm90IHNldAojIENPTkZJR19EVkJfQjJD Ml9GTEVYQ09QX1VTQiBpcyBub3Qgc2V0CgojCiMgV2ViY2FtLCBUViAoYW5hbG9nL2RpZ2l0 YWwpIFVTQiBkZXZpY2VzCiMKIyBDT05GSUdfVklERU9fRU0yOFhYIGlzIG5vdCBzZXQKQ09O RklHX01FRElBX1BDSV9TVVBQT1JUPXkKCiMKIyBNZWRpYSBjYXB0dXJlIHN1cHBvcnQKIwoK IwojIE1lZGlhIGNhcHR1cmUvYW5hbG9nIFRWIHN1cHBvcnQKIwojIENPTkZJR19WSURFT19J VlRWIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fWk9SQU4gaXMgbm90IHNldAojIENPTkZJ R19WSURFT19IRVhJVU1fR0VNSU5JIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fSEVYSVVN X09SSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fTVhCIGlzIG5vdCBzZXQKCiMKIyBN ZWRpYSBjYXB0dXJlL2FuYWxvZy9oeWJyaWQgVFYgc3VwcG9ydAojCiMgQ09ORklHX1ZJREVP X0NYMTggaXMgbm90IHNldAojIENPTkZJR19WSURFT19DWDIzODg1IGlzIG5vdCBzZXQKQ09O RklHX1ZJREVPX0NYMjU4MjE9eQojIENPTkZJR19WSURFT19DWDI1ODIxX0FMU0EgaXMgbm90 IHNldAojIENPTkZJR19WSURFT19DWDg4IGlzIG5vdCBzZXQKIyBDT05GSUdfVklERU9fQlQ4 NDggaXMgbm90IHNldAojIENPTkZJR19WSURFT19TQUE3MTM0IGlzIG5vdCBzZXQKIyBDT05G SUdfVklERU9fU0FBNzE2NCBpcyBub3Qgc2V0CgojCiMgTWVkaWEgZGlnaXRhbCBUViBQQ0kg QWRhcHRlcnMKIwojIENPTkZJR19UVFBDSV9FRVBST00gaXMgbm90IHNldAojIENPTkZJR19E VkJfQVY3MTEwIGlzIG5vdCBzZXQKIyBDT05GSUdfRFZCX0JVREdFVF9DT1JFIGlzIG5vdCBz ZXQKIyBDT05GSUdfRFZCX0IyQzJfRkxFWENPUF9QQ0kgaXMgbm90IHNldAojIENPTkZJR19E VkJfUExVVE8yIGlzIG5vdCBzZXQKIyBDT05GSUdfRFZCX0RNMTEwNSBpcyBub3Qgc2V0CiMg Q09ORklHX0RWQl9QVDEgaXMgbm90IHNldAojIENPTkZJR19NQU5USVNfQ09SRSBpcyBub3Qg c2V0CiMgQ09ORklHX0RWQl9OR0VORSBpcyBub3Qgc2V0CiMgQ09ORklHX0RWQl9EREJSSURH RSBpcyBub3Qgc2V0CiMgQ09ORklHX1Y0TF9QTEFURk9STV9EUklWRVJTIGlzIG5vdCBzZXQK IyBDT05GSUdfVjRMX01FTTJNRU1fRFJJVkVSUyBpcyBub3Qgc2V0CiMgQ09ORklHX1Y0TF9U RVNUX0RSSVZFUlMgaXMgbm90IHNldAoKIwojIFN1cHBvcnRlZCBNTUMvU0RJTyBhZGFwdGVy cwojCiMgQ09ORklHX1JBRElPX0FEQVBURVJTIGlzIG5vdCBzZXQKQ09ORklHX01FRElBX1NV QkRSVl9BVVRPU0VMRUNUPXkKCiMKIyBNZWRpYSBhbmNpbGxhcnkgZHJpdmVycyAodHVuZXJz LCBzZW5zb3JzLCBpMmMsIGZyb250ZW5kcykKIwpDT05GSUdfVklERU9fQlRDWD15CkNPTkZJ R19WSURFT19UVkVFUFJPTT15CkNPTkZJR19WSURFT19JUl9JMkM9eQoKIwojIEF1ZGlvIGRl Y29kZXJzLCBwcm9jZXNzb3JzIGFuZCBtaXhlcnMKIwpDT05GSUdfVklERU9fTVNQMzQwMD15 CkNPTkZJR19WSURFT19DUzUzTDMyQT15CkNPTkZJR19WSURFT19XTTg3NzU9eQoKIwojIFJE UyBkZWNvZGVycwojCgojCiMgVmlkZW8gZGVjb2RlcnMKIwpDT05GSUdfVklERU9fU0FBNzEx WD15CgojCiMgVmlkZW8gYW5kIGF1ZGlvIGRlY29kZXJzCiMKQ09ORklHX1ZJREVPX0NYMjU4 NDA9eQoKIwojIE1QRUcgdmlkZW8gZW5jb2RlcnMKIwpDT05GSUdfVklERU9fQ1gyMzQxWD15 CgojCiMgVmlkZW8gZW5jb2RlcnMKIwoKIwojIENhbWVyYSBzZW5zb3IgZGV2aWNlcwojCgoj CiMgRmxhc2ggZGV2aWNlcwojCgojCiMgVmlkZW8gaW1wcm92ZW1lbnQgY2hpcHMKIwoKIwoj IE1pc2NlbGFuZW91cyBoZWxwZXIgY2hpcHMKIwoKIwojIFNlbnNvcnMgdXNlZCBvbiBzb2Nf Y2FtZXJhIGRyaXZlcgojCiMgQ09ORklHX01FRElBX0FUVEFDSCBpcyBub3Qgc2V0CkNPTkZJ R19NRURJQV9UVU5FUj15CkNPTkZJR19NRURJQV9UVU5FUl9TSU1QTEU9eQpDT05GSUdfTUVE SUFfVFVORVJfVERBODI5MD15CkNPTkZJR19NRURJQV9UVU5FUl9UREE4MjdYPXkKQ09ORklH X01FRElBX1RVTkVSX1REQTE4MjcxPXkKQ09ORklHX01FRElBX1RVTkVSX1REQTk4ODc9eQpD T05GSUdfTUVESUFfVFVORVJfVEVBNTc2MT15CkNPTkZJR19NRURJQV9UVU5FUl9URUE1NzY3 PXkKQ09ORklHX01FRElBX1RVTkVSX01UMjBYWD15CkNPTkZJR19NRURJQV9UVU5FUl9YQzIw Mjg9eQpDT05GSUdfTUVESUFfVFVORVJfWEM1MDAwPXkKQ09ORklHX01FRElBX1RVTkVSX1hD NDAwMD15CkNPTkZJR19NRURJQV9UVU5FUl9NQzQ0UzgwMz15CgojCiMgTXVsdGlzdGFuZGFy ZCAoc2F0ZWxsaXRlKSBmcm9udGVuZHMKIwoKIwojIE11bHRpc3RhbmRhcmQgKGNhYmxlICsg dGVycmVzdHJpYWwpIGZyb250ZW5kcwojCgojCiMgRFZCLVMgKHNhdGVsbGl0ZSkgZnJvbnRl bmRzCiMKCiMKIyBEVkItVCAodGVycmVzdHJpYWwpIGZyb250ZW5kcwojCkNPTkZJR19EVkJf VERBMTAwNDg9eQoKIwojIERWQi1DIChjYWJsZSkgZnJvbnRlbmRzCiMKCiMKIyBBVFNDIChO b3J0aCBBbWVyaWNhbi9Lb3JlYW4gVGVycmVzdHJpYWwvQ2FibGUgRFRWKSBmcm9udGVuZHMK IwpDT05GSUdfRFZCX0xHRFQzMzBYPXkKQ09ORklHX0RWQl9TNUgxNDA5PXkKQ09ORklHX0RW Ql9TNUgxNDExPXkKCiMKIyBJU0RCLVQgKHRlcnJlc3RyaWFsKSBmcm9udGVuZHMKIwoKIwoj IERpZ2l0YWwgdGVycmVzdHJpYWwgb25seSB0dW5lcnMvUExMCiMKCiMKIyBTRUMgY29udHJv bCBkZXZpY2VzIGZvciBEVkItUwojCgojCiMgVG9vbHMgdG8gZGV2ZWxvcCBuZXcgZnJvbnRl bmRzCiMKIyBDT05GSUdfRFZCX0RVTU1ZX0ZFIGlzIG5vdCBzZXQKCiMKIyBHcmFwaGljcyBz dXBwb3J0CiMKQ09ORklHX0FHUD15CkNPTkZJR19BR1BfQU1ENjQ9eQpDT05GSUdfQUdQX0lO VEVMPXkKIyBDT05GSUdfQUdQX1NJUyBpcyBub3Qgc2V0CiMgQ09ORklHX0FHUF9WSUEgaXMg bm90IHNldApDT05GSUdfVkdBX0FSQj15CkNPTkZJR19WR0FfQVJCX01BWF9HUFVTPTE2CiMg Q09ORklHX1ZHQV9TV0lUQ0hFUk9PIGlzIG5vdCBzZXQKQ09ORklHX0RSTT15CkNPTkZJR19E Uk1fS01TX0hFTFBFUj15CiMgQ09ORklHX0RSTV9MT0FEX0VESURfRklSTVdBUkUgaXMgbm90 IHNldAojIENPTkZJR19EUk1fVERGWCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9SMTI4IGlz IG5vdCBzZXQKIyBDT05GSUdfRFJNX1JBREVPTiBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9O T1VWRUFVIGlzIG5vdCBzZXQKCiMKIyBJMkMgZW5jb2RlciBvciBoZWxwZXIgY2hpcHMKIwpD T05GSUdfRFJNX0kyQ19DSDcwMDY9eQpDT05GSUdfRFJNX0kyQ19TSUwxNjQ9eQpDT05GSUdf RFJNX0k5MTU9eQpDT05GSUdfRFJNX0k5MTVfS01TPXkKIyBDT05GSUdfRFJNX01HQSBpcyBu b3Qgc2V0CiMgQ09ORklHX0RSTV9TSVMgaXMgbm90IHNldAojIENPTkZJR19EUk1fVklBIGlz IG5vdCBzZXQKIyBDT05GSUdfRFJNX1NBVkFHRSBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9W TVdHRlggaXMgbm90IHNldAojIENPTkZJR19EUk1fR01BNTAwIGlzIG5vdCBzZXQKIyBDT05G SUdfRFJNX1VETCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9BU1QgaXMgbm90IHNldAojIENP TkZJR19EUk1fTUdBRzIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0RSTV9DSVJSVVNfUUVNVSBp cyBub3Qgc2V0CiMgQ09ORklHX1NUVUJfUE9VTFNCTyBpcyBub3Qgc2V0CiMgQ09ORklHX1ZH QVNUQVRFIGlzIG5vdCBzZXQKQ09ORklHX1ZJREVPX09VVFBVVF9DT05UUk9MPXkKQ09ORklH X0ZCPXkKIyBDT05GSUdfRklSTVdBUkVfRURJRCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0RE QyBpcyBub3Qgc2V0CkNPTkZJR19GQl9CT09UX1ZFU0FfU1VQUE9SVD15CkNPTkZJR19GQl9D RkJfRklMTFJFQ1Q9eQpDT05GSUdfRkJfQ0ZCX0NPUFlBUkVBPXkKQ09ORklHX0ZCX0NGQl9J TUFHRUJMSVQ9eQojIENPTkZJR19GQl9DRkJfUkVWX1BJWEVMU19JTl9CWVRFIGlzIG5vdCBz ZXQKQ09ORklHX0ZCX1NZU19GSUxMUkVDVD15CkNPTkZJR19GQl9TWVNfQ09QWUFSRUE9eQpD T05GSUdfRkJfU1lTX0lNQUdFQkxJVD15CiMgQ09ORklHX0ZCX0ZPUkVJR05fRU5ESUFOIGlz IG5vdCBzZXQKQ09ORklHX0ZCX1NZU19GT1BTPXkKIyBDT05GSUdfRkJfV01UX0dFX1JPUFMg aXMgbm90IHNldApDT05GSUdfRkJfREVGRVJSRURfSU89eQojIENPTkZJR19GQl9TVkdBTElC IGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfTUFDTU9ERVMgaXMgbm90IHNldAojIENPTkZJR19G Ql9CQUNLTElHSFQgaXMgbm90IHNldApDT05GSUdfRkJfTU9ERV9IRUxQRVJTPXkKQ09ORklH X0ZCX1RJTEVCTElUVElORz15CgojCiMgRnJhbWUgYnVmZmVyIGhhcmR3YXJlIGRyaXZlcnMK IwojIENPTkZJR19GQl9DSVJSVVMgaXMgbm90IHNldAojIENPTkZJR19GQl9QTTIgaXMgbm90 IHNldAojIENPTkZJR19GQl9DWUJFUjIwMDAgaXMgbm90IHNldAojIENPTkZJR19GQl9BUkMg aXMgbm90IHNldAojIENPTkZJR19GQl9BU0lMSUFOVCBpcyBub3Qgc2V0CiMgQ09ORklHX0ZC X0lNU1RUIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfVkdBMTYgaXMgbm90IHNldAojIENPTkZJ R19GQl9VVkVTQSBpcyBub3Qgc2V0CkNPTkZJR19GQl9WRVNBPXkKIyBDT05GSUdfRkJfTjQx MSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0hHQSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1Mx RDEzWFhYIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfTlZJRElBIGlzIG5vdCBzZXQKIyBDT05G SUdfRkJfUklWQSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0k3NDAgaXMgbm90IHNldAojIENP TkZJR19GQl9MRTgwNTc4IGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfTUFUUk9YIGlzIG5vdCBz ZXQKIyBDT05GSUdfRkJfUkFERU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfQVRZMTI4IGlz IG5vdCBzZXQKIyBDT05GSUdfRkJfQVRZIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfUzMgaXMg bm90IHNldAojIENPTkZJR19GQl9TQVZBR0UgaXMgbm90IHNldAojIENPTkZJR19GQl9TSVMg aXMgbm90IHNldAojIENPTkZJR19GQl9WSUEgaXMgbm90IHNldAojIENPTkZJR19GQl9ORU9N QUdJQyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX0tZUk8gaXMgbm90IHNldAojIENPTkZJR19G Ql8zREZYIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfVk9PRE9PMSBpcyBub3Qgc2V0CiMgQ09O RklHX0ZCX1ZUODYyMyBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX1RSSURFTlQgaXMgbm90IHNl dAojIENPTkZJR19GQl9BUksgaXMgbm90IHNldAojIENPTkZJR19GQl9QTTMgaXMgbm90IHNl dAojIENPTkZJR19GQl9DQVJNSU5FIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfR0VPREUgaXMg bm90IHNldAojIENPTkZJR19GQl9UTUlPIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfU01TQ1VG WCBpcyBub3Qgc2V0CkNPTkZJR19GQl9VREw9eQojIENPTkZJR19GQl9WSVJUVUFMIGlzIG5v dCBzZXQKQ09ORklHX1hFTl9GQkRFVl9GUk9OVEVORD15CiMgQ09ORklHX0ZCX01FVFJPTk9N RSBpcyBub3Qgc2V0CiMgQ09ORklHX0ZCX01CODYyWFggaXMgbm90IHNldAojIENPTkZJR19G Ql9CUk9BRFNIRUVUIGlzIG5vdCBzZXQKIyBDT05GSUdfRkJfQVVPX0sxOTBYIGlzIG5vdCBz ZXQKIyBDT05GSUdfRVhZTk9TX1ZJREVPIGlzIG5vdCBzZXQKQ09ORklHX0JBQ0tMSUdIVF9M Q0RfU1VQUE9SVD15CiMgQ09ORklHX0xDRF9DTEFTU19ERVZJQ0UgaXMgbm90IHNldApDT05G SUdfQkFDS0xJR0hUX0NMQVNTX0RFVklDRT15CkNPTkZJR19CQUNLTElHSFRfR0VORVJJQz15 CiMgQ09ORklHX0JBQ0tMSUdIVF9BUFBMRSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdI VF9TQUhBUkEgaXMgbm90IHNldAojIENPTkZJR19CQUNLTElHSFRfQURQODg2MCBpcyBub3Qg c2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9BRFA4ODcwIGlzIG5vdCBzZXQKIyBDT05GSUdfQkFD S0xJR0hUX0xNMzYzMCBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tMSUdIVF9MTTM2MzkgaXMg bm90IHNldAojIENPTkZJR19CQUNLTElHSFRfTFA4NTVYIGlzIG5vdCBzZXQKCiMKIyBDb25z b2xlIGRpc3BsYXkgZHJpdmVyIHN1cHBvcnQKIwpDT05GSUdfVkdBX0NPTlNPTEU9eQpDT05G SUdfVkdBQ09OX1NPRlRfU0NST0xMQkFDSz15CkNPTkZJR19WR0FDT05fU09GVF9TQ1JPTExC QUNLX1NJWkU9NjQKQ09ORklHX0RVTU1ZX0NPTlNPTEU9eQpDT05GSUdfRlJBTUVCVUZGRVJf Q09OU09MRT15CkNPTkZJR19GUkFNRUJVRkZFUl9DT05TT0xFX0RFVEVDVF9QUklNQVJZPXkK IyBDT05GSUdfRlJBTUVCVUZGRVJfQ09OU09MRV9ST1RBVElPTiBpcyBub3Qgc2V0CiMgQ09O RklHX0ZPTlRTIGlzIG5vdCBzZXQKQ09ORklHX0ZPTlRfOHg4PXkKQ09ORklHX0ZPTlRfOHgx Nj15CkNPTkZJR19MT0dPPXkKIyBDT05GSUdfTE9HT19MSU5VWF9NT05PIGlzIG5vdCBzZXQK IyBDT05GSUdfTE9HT19MSU5VWF9WR0ExNiBpcyBub3Qgc2V0CkNPTkZJR19MT0dPX0xJTlVY X0NMVVQyMjQ9eQpDT05GSUdfU09VTkQ9eQpDT05GSUdfU09VTkRfT1NTX0NPUkU9eQpDT05G SUdfU09VTkRfT1NTX0NPUkVfUFJFQ0xBSU09eQpDT05GSUdfU05EPXkKQ09ORklHX1NORF9U SU1FUj15CkNPTkZJR19TTkRfUENNPXkKQ09ORklHX1NORF9IV0RFUD15CkNPTkZJR19TTkRf UkFXTUlEST15CkNPTkZJR19TTkRfU0VRVUVOQ0VSPXkKQ09ORklHX1NORF9TRVFfRFVNTVk9 eQpDT05GSUdfU05EX09TU0VNVUw9eQpDT05GSUdfU05EX01JWEVSX09TUz15CkNPTkZJR19T TkRfUENNX09TUz15CkNPTkZJR19TTkRfUENNX09TU19QTFVHSU5TPXkKQ09ORklHX1NORF9T RVFVRU5DRVJfT1NTPXkKQ09ORklHX1NORF9IUlRJTUVSPXkKQ09ORklHX1NORF9TRVFfSFJU SU1FUl9ERUZBVUxUPXkKQ09ORklHX1NORF9EWU5BTUlDX01JTk9SUz15CkNPTkZJR19TTkRf U1VQUE9SVF9PTERfQVBJPXkKQ09ORklHX1NORF9WRVJCT1NFX1BST0NGUz15CiMgQ09ORklH X1NORF9WRVJCT1NFX1BSSU5USyBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9ERUJVRyBpcyBu b3Qgc2V0CkNPTkZJR19TTkRfVk1BU1RFUj15CkNPTkZJR19TTkRfS0NUTF9KQUNLPXkKQ09O RklHX1NORF9ETUFfU0dCVUY9eQpDT05GSUdfU05EX1JBV01JRElfU0VRPXkKQ09ORklHX1NO RF9PUEwzX0xJQl9TRVE9eQojIENPTkZJR19TTkRfT1BMNF9MSUJfU0VRIGlzIG5vdCBzZXQK IyBDT05GSUdfU05EX1NCQVdFX1NFUSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9FTVUxMEsx X1NFUSBpcyBub3Qgc2V0CkNPTkZJR19TTkRfTVBVNDAxX1VBUlQ9eQpDT05GSUdfU05EX09Q TDNfTElCPXkKQ09ORklHX1NORF9EUklWRVJTPXkKIyBDT05GSUdfU05EX1BDU1AgaXMgbm90 IHNldAojIENPTkZJR19TTkRfRFVNTVkgaXMgbm90IHNldAojIENPTkZJR19TTkRfQUxPT1Ag aXMgbm90IHNldAojIENPTkZJR19TTkRfVklSTUlESSBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9NVFBBViBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9TRVJJQUxfVTE2NTUwIGlzIG5vdCBz ZXQKIyBDT05GSUdfU05EX01QVTQwMSBpcyBub3Qgc2V0CkNPTkZJR19TTkRfUENJPXkKIyBD T05GSUdfU05EX0FEMTg4OSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BTFMzMDAgaXMgbm90 IHNldAojIENPTkZJR19TTkRfQUxTNDAwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BTEk1 NDUxIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0FTSUhQSSBpcyBub3Qgc2V0CiMgQ09ORklH X1NORF9BVElJWFAgaXMgbm90IHNldAojIENPTkZJR19TTkRfQVRJSVhQX01PREVNIGlzIG5v dCBzZXQKIyBDT05GSUdfU05EX0FVODgxMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BVTg4 MjAgaXMgbm90IHNldAojIENPTkZJR19TTkRfQVU4ODMwIGlzIG5vdCBzZXQKIyBDT05GSUdf U05EX0FXMiBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9BWlQzMzI4IGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX0JUODdYIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0NBMDEwNiBpcyBub3Qg c2V0CkNPTkZJR19TTkRfQ01JUENJPXkKQ09ORklHX1NORF9PWFlHRU5fTElCPXkKQ09ORklH X1NORF9PWFlHRU49eQojIENPTkZJR19TTkRfQ1M0MjgxIGlzIG5vdCBzZXQKIyBDT05GSUdf U05EX0NTNDZYWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9DUzU1MzAgaXMgbm90IHNldAoj IENPTkZJR19TTkRfQ1M1NTM1QVVESU8gaXMgbm90IHNldAojIENPTkZJR19TTkRfQ1RYRkkg aXMgbm90IHNldAojIENPTkZJR19TTkRfREFSTEEyMCBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9HSU5BMjAgaXMgbm90IHNldAojIENPTkZJR19TTkRfTEFZTEEyMCBpcyBub3Qgc2V0CiMg Q09ORklHX1NORF9EQVJMQTI0IGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0dJTkEyNCBpcyBu b3Qgc2V0CiMgQ09ORklHX1NORF9MQVlMQTI0IGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX01P TkEgaXMgbm90IHNldAojIENPTkZJR19TTkRfTUlBIGlzIG5vdCBzZXQKIyBDT05GSUdfU05E X0VDSE8zRyBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9JTkRJR08gaXMgbm90IHNldAojIENP TkZJR19TTkRfSU5ESUdPSU8gaXMgbm90IHNldAojIENPTkZJR19TTkRfSU5ESUdPREogaXMg bm90IHNldAojIENPTkZJR19TTkRfSU5ESUdPSU9YIGlzIG5vdCBzZXQKIyBDT05GSUdfU05E X0lORElHT0RKWCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9FTVUxMEsxIGlzIG5vdCBzZXQK IyBDT05GSUdfU05EX0VNVTEwSzFYIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0VOUzEzNzAg aXMgbm90IHNldAojIENPTkZJR19TTkRfRU5TMTM3MSBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9FUzE5MzggaXMgbm90IHNldAojIENPTkZJR19TTkRfRVMxOTY4IGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX0ZNODAxIGlzIG5vdCBzZXQKQ09ORklHX1NORF9IREFfSU5URUw9eQpDT05G SUdfU05EX0hEQV9QUkVBTExPQ19TSVpFPTY0CkNPTkZJR19TTkRfSERBX0hXREVQPXkKIyBD T05GSUdfU05EX0hEQV9SRUNPTkZJRyBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9IREFfSU5Q VVRfQkVFUCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9IREFfSU5QVVRfSkFDSyBpcyBub3Qg c2V0CiMgQ09ORklHX1NORF9IREFfUEFUQ0hfTE9BREVSIGlzIG5vdCBzZXQKQ09ORklHX1NO RF9IREFfQ09ERUNfUkVBTFRFSz15CkNPTkZJR19TTkRfSERBX0NPREVDX0FOQUxPRz15CkNP TkZJR19TTkRfSERBX0NPREVDX1NJR01BVEVMPXkKQ09ORklHX1NORF9IREFfQ09ERUNfVklB PXkKQ09ORklHX1NORF9IREFfQ09ERUNfSERNST15CkNPTkZJR19TTkRfSERBX0NPREVDX0NJ UlJVUz15CkNPTkZJR19TTkRfSERBX0NPREVDX0NPTkVYQU5UPXkKQ09ORklHX1NORF9IREFf Q09ERUNfQ0EwMTEwPXkKQ09ORklHX1NORF9IREFfQ09ERUNfQ0EwMTMyPXkKQ09ORklHX1NO RF9IREFfQ09ERUNfQ01FRElBPXkKQ09ORklHX1NORF9IREFfQ09ERUNfU0kzMDU0PXkKQ09O RklHX1NORF9IREFfR0VORVJJQz15CkNPTkZJR19TTkRfSERBX1BPV0VSX1NBVkVfREVGQVVM VD0wCiMgQ09ORklHX1NORF9IRFNQIGlzIG5vdCBzZXQKIyBDT05GSUdfU05EX0hEU1BNIGlz IG5vdCBzZXQKIyBDT05GSUdfU05EX0lDRTE3MTIgaXMgbm90IHNldAojIENPTkZJR19TTkRf SUNFMTcyNCBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9JTlRFTDhYMCBpcyBub3Qgc2V0CiMg Q09ORklHX1NORF9JTlRFTDhYME0gaXMgbm90IHNldAojIENPTkZJR19TTkRfS09SRzEyMTIg aXMgbm90IHNldAojIENPTkZJR19TTkRfTE9MQSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9M WDY0NjRFUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9NQUVTVFJPMyBpcyBub3Qgc2V0CiMg Q09ORklHX1NORF9NSVhBUlQgaXMgbm90IHNldAojIENPTkZJR19TTkRfTk0yNTYgaXMgbm90 IHNldAojIENPTkZJR19TTkRfUENYSFIgaXMgbm90IHNldAojIENPTkZJR19TTkRfUklQVElE RSBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9STUUzMiBpcyBub3Qgc2V0CiMgQ09ORklHX1NO RF9STUU5NiBpcyBub3Qgc2V0CiMgQ09ORklHX1NORF9STUU5NjUyIGlzIG5vdCBzZXQKIyBD T05GSUdfU05EX1NPTklDVklCRVMgaXMgbm90IHNldAojIENPTkZJR19TTkRfVFJJREVOVCBp cyBub3Qgc2V0CiMgQ09ORklHX1NORF9WSUE4MlhYIGlzIG5vdCBzZXQKIyBDT05GSUdfU05E X1ZJQTgyWFhfTU9ERU0gaXMgbm90IHNldAojIENPTkZJR19TTkRfVklSVFVPU08gaXMgbm90 IHNldAojIENPTkZJR19TTkRfVlgyMjIgaXMgbm90IHNldAojIENPTkZJR19TTkRfWU1GUENJ IGlzIG5vdCBzZXQKQ09ORklHX1NORF9VU0I9eQpDT05GSUdfU05EX1VTQl9BVURJTz15CkNP TkZJR19TTkRfVVNCX1VBMTAxPXkKQ09ORklHX1NORF9VU0JfVVNYMlk9eQpDT05GSUdfU05E X1VTQl9DQUlBUT15CkNPTkZJR19TTkRfVVNCX0NBSUFRX0lOUFVUPXkKIyBDT05GSUdfU05E X1VTQl9VUzEyMkwgaXMgbm90IHNldApDT05GSUdfU05EX1VTQl82RklSRT15CiMgQ09ORklH X1NORF9TT0MgaXMgbm90IHNldAojIENPTkZJR19TT1VORF9QUklNRSBpcyBub3Qgc2V0Cgoj CiMgSElEIHN1cHBvcnQKIwpDT05GSUdfSElEPXkKIyBDT05GSUdfSElEX0JBVFRFUllfU1RS RU5HVEggaXMgbm90IHNldApDT05GSUdfSElEUkFXPXkKIyBDT05GSUdfVUhJRCBpcyBub3Qg c2V0CkNPTkZJR19ISURfR0VORVJJQz15CgojCiMgU3BlY2lhbCBISUQgZHJpdmVycwojCkNP TkZJR19ISURfQTRURUNIPXkKIyBDT05GSUdfSElEX0FDUlVYIGlzIG5vdCBzZXQKQ09ORklH X0hJRF9BUFBMRT15CiMgQ09ORklHX0hJRF9BVVJFQUwgaXMgbm90IHNldApDT05GSUdfSElE X0JFTEtJTj15CkNPTkZJR19ISURfQ0hFUlJZPXkKQ09ORklHX0hJRF9DSElDT05ZPXkKIyBD T05GSUdfSElEX1BST0RJS0VZUyBpcyBub3Qgc2V0CkNPTkZJR19ISURfQ1lQUkVTUz15CiMg Q09ORklHX0hJRF9EUkFHT05SSVNFIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX0VNU19GRiBp cyBub3Qgc2V0CiMgQ09ORklHX0hJRF9FTEVDT00gaXMgbm90IHNldApDT05GSUdfSElEX0Va S0VZPXkKIyBDT05GSUdfSElEX0hPTFRFSyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9LRVlU T1VDSCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9LWUUgaXMgbm90IHNldAojIENPTkZJR19I SURfVUNMT0dJQyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9XQUxUT1AgaXMgbm90IHNldAoj IENPTkZJR19ISURfR1lSQVRJT04gaXMgbm90IHNldAojIENPTkZJR19ISURfVFdJTkhBTiBp cyBub3Qgc2V0CkNPTkZJR19ISURfS0VOU0lOR1RPTj15CiMgQ09ORklHX0hJRF9MQ1BPV0VS IGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX0xFTk9WT19UUEtCRCBpcyBub3Qgc2V0CkNPTkZJ R19ISURfTE9HSVRFQ0g9eQojIENPTkZJR19ISURfTE9HSVRFQ0hfREogaXMgbm90IHNldAoj IENPTkZJR19MT0dJVEVDSF9GRiBpcyBub3Qgc2V0CiMgQ09ORklHX0xPR0lSVU1CTEVQQUQy X0ZGIGlzIG5vdCBzZXQKIyBDT05GSUdfTE9HSUc5NDBfRkYgaXMgbm90IHNldAojIENPTkZJ R19MT0dJV0hFRUxTX0ZGIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX01BR0lDTU9VU0UgaXMg bm90IHNldApDT05GSUdfSElEX01JQ1JPU09GVD15CkNPTkZJR19ISURfTU9OVEVSRVk9eQoj IENPTkZJR19ISURfTVVMVElUT1VDSCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9OVFJJRyBp cyBub3Qgc2V0CiMgQ09ORklHX0hJRF9PUlRFSyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9Q QU5USEVSTE9SRCBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9QRVRBTFlOWCBpcyBub3Qgc2V0 CiMgQ09ORklHX0hJRF9QSUNPTENEIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1BSSU1BWCBp cyBub3Qgc2V0CiMgQ09ORklHX0hJRF9QUzNSRU1PVEUgaXMgbm90IHNldAojIENPTkZJR19I SURfUk9DQ0FUIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1NBSVRFSyBpcyBub3Qgc2V0CiMg Q09ORklHX0hJRF9TQU1TVU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1NPTlkgaXMgbm90 IHNldAojIENPTkZJR19ISURfU1BFRURMSU5LIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1NV TlBMVVMgaXMgbm90IHNldAojIENPTkZJR19ISURfR1JFRU5BU0lBIGlzIG5vdCBzZXQKIyBD T05GSUdfSElEX1NNQVJUSk9ZUExVUyBpcyBub3Qgc2V0CiMgQ09ORklHX0hJRF9USVZPIGlz IG5vdCBzZXQKIyBDT05GSUdfSElEX1RPUFNFRUQgaXMgbm90IHNldAojIENPTkZJR19ISURf VEhSVVNUTUFTVEVSIGlzIG5vdCBzZXQKIyBDT05GSUdfSElEX1dBQ09NIGlzIG5vdCBzZXQK IyBDT05GSUdfSElEX1dJSU1PVEUgaXMgbm90IHNldAojIENPTkZJR19ISURfWkVST1BMVVMg aXMgbm90IHNldAojIENPTkZJR19ISURfWllEQUNST04gaXMgbm90IHNldAojIENPTkZJR19I SURfU0VOU09SX0hVQiBpcyBub3Qgc2V0CgojCiMgVVNCIEhJRCBzdXBwb3J0CiMKQ09ORklH X1VTQl9ISUQ9eQpDT05GSUdfSElEX1BJRD15CkNPTkZJR19VU0JfSElEREVWPXkKQ09ORklH X1VTQl9BUkNIX0hBU19PSENJPXkKQ09ORklHX1VTQl9BUkNIX0hBU19FSENJPXkKQ09ORklH X1VTQl9BUkNIX0hBU19YSENJPXkKQ09ORklHX1VTQl9TVVBQT1JUPXkKQ09ORklHX1VTQl9D T01NT049eQpDT05GSUdfVVNCX0FSQ0hfSEFTX0hDRD15CkNPTkZJR19VU0I9eQojIENPTkZJ R19VU0JfREVCVUcgaXMgbm90IHNldApDT05GSUdfVVNCX0FOTk9VTkNFX05FV19ERVZJQ0VT PXkKCiMKIyBNaXNjZWxsYW5lb3VzIFVTQiBvcHRpb25zCiMKIyBDT05GSUdfVVNCX0RZTkFN SUNfTUlOT1JTIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9NT049eQojIENPTkZJR19VU0JfV1VT Ql9DQkFGIGlzIG5vdCBzZXQKCiMKIyBVU0IgSG9zdCBDb250cm9sbGVyIERyaXZlcnMKIwoj IENPTkZJR19VU0JfQzY3WDAwX0hDRCBpcyBub3Qgc2V0CkNPTkZJR19VU0JfWEhDSV9IQ0Q9 eQojIENPTkZJR19VU0JfWEhDSV9IQ0RfREVCVUdHSU5HIGlzIG5vdCBzZXQKQ09ORklHX1VT Ql9FSENJX0hDRD15CkNPTkZJR19VU0JfRUhDSV9ST09UX0hVQl9UVD15CkNPTkZJR19VU0Jf RUhDSV9UVF9ORVdTQ0hFRD15CiMgQ09ORklHX1VTQl9PWFUyMTBIUF9IQ0QgaXMgbm90IHNl dAojIENPTkZJR19VU0JfSVNQMTE2WF9IQ0QgaXMgbm90IHNldAojIENPTkZJR19VU0JfSVNQ MTc2MF9IQ0QgaXMgbm90IHNldAojIENPTkZJR19VU0JfSVNQMTM2Ml9IQ0QgaXMgbm90IHNl dApDT05GSUdfVVNCX09IQ0lfSENEPXkKIyBDT05GSUdfVVNCX09IQ0lfSENEX1BMQVRGT1JN IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0VIQ0lfSENEX1BMQVRGT1JNIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX09IQ0lfQklHX0VORElBTl9ERVNDIGlzIG5vdCBzZXQKIyBDT05GSUdf VVNCX09IQ0lfQklHX0VORElBTl9NTUlPIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9PSENJX0xJ VFRMRV9FTkRJQU49eQpDT05GSUdfVVNCX1VIQ0lfSENEPXkKIyBDT05GSUdfVVNCX1NMODEx X0hDRCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9SOEE2NjU5N19IQ0QgaXMgbm90IHNldAoj IENPTkZJR19VU0JfQ0hJUElERUEgaXMgbm90IHNldAoKIwojIFVTQiBEZXZpY2UgQ2xhc3Mg ZHJpdmVycwojCiMgQ09ORklHX1VTQl9BQ00gaXMgbm90IHNldApDT05GSUdfVVNCX1BSSU5U RVI9eQojIENPTkZJR19VU0JfV0RNIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1RNQyBpcyBu b3Qgc2V0CgojCiMgTk9URTogVVNCX1NUT1JBR0UgZGVwZW5kcyBvbiBTQ1NJIGJ1dCBCTEtf REVWX1NEIG1heQojCgojCiMgYWxzbyBiZSBuZWVkZWQ7IHNlZSBVU0JfU1RPUkFHRSBIZWxw IGZvciBtb3JlIGluZm8KIwpDT05GSUdfVVNCX1NUT1JBR0U9eQojIENPTkZJR19VU0JfU1RP UkFHRV9ERUJVRyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX1JFQUxURUsgaXMg bm90IHNldAojIENPTkZJR19VU0JfU1RPUkFHRV9EQVRBRkFCIGlzIG5vdCBzZXQKIyBDT05G SUdfVVNCX1NUT1JBR0VfRlJFRUNPTSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdF X0lTRDIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX1VTQkFUIGlzIG5vdCBz ZXQKIyBDT05GSUdfVVNCX1NUT1JBR0VfU0REUjA5IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X1NUT1JBR0VfU0REUjU1IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JBR0VfSlVNUFNI T1QgaXMgbm90IHNldAojIENPTkZJR19VU0JfU1RPUkFHRV9BTEFVREEgaXMgbm90IHNldAoj IENPTkZJR19VU0JfU1RPUkFHRV9PTkVUT1VDSCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9T VE9SQUdFX0tBUk1BIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NUT1JBR0VfQ1lQUkVTU19B VEFDQiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TVE9SQUdFX0VORV9VQjYyNTAgaXMgbm90 IHNldAojIENPTkZJR19VU0JfVUFTIGlzIG5vdCBzZXQKCiMKIyBVU0IgSW1hZ2luZyBkZXZp Y2VzCiMKIyBDT05GSUdfVVNCX01EQzgwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9NSUNS T1RFSyBpcyBub3Qgc2V0CgojCiMgVVNCIHBvcnQgZHJpdmVycwojCkNPTkZJR19VU0JfU0VS SUFMPXkKQ09ORklHX1VTQl9TRVJJQUxfQ09OU09MRT15CkNPTkZJR19VU0JfU0VSSUFMX0dF TkVSSUM9eQojIENPTkZJR19VU0JfU0VSSUFMX0FJUkNBQkxFIGlzIG5vdCBzZXQKIyBDT05G SUdfVVNCX1NFUklBTF9BUkszMTE2IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9C RUxLSU4gaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0NIMzQxIGlzIG5vdCBzZXQK IyBDT05GSUdfVVNCX1NFUklBTF9XSElURUhFQVQgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U0VSSUFMX0RJR0lfQUNDRUxFUE9SVCBpcyBub3Qgc2V0CkNPTkZJR19VU0JfU0VSSUFMX0NQ MjEwWD15CkNPTkZJR19VU0JfU0VSSUFMX0NZUFJFU1NfTTg9eQojIENPTkZJR19VU0JfU0VS SUFMX0VNUEVHIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9GVERJX1NJTyBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfRlVOU09GVCBpcyBub3Qgc2V0CiMgQ09ORklH X1VTQl9TRVJJQUxfVklTT1IgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0lQQVEg aXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0lSIGlzIG5vdCBzZXQKIyBDT05GSUdf VVNCX1NFUklBTF9FREdFUE9SVCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfRURH RVBPUlRfVEkgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0Y4MTIzMiBpcyBub3Qg c2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfR0FSTUlOIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X1NFUklBTF9JUFcgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0lVVSBpcyBub3Qg c2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfS0VZU1BBTl9QREEgaXMgbm90IHNldAojIENPTkZJ R19VU0JfU0VSSUFMX0tFWVNQQU4gaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0tM U0kgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX0tPQklMX1NDVCBpcyBub3Qgc2V0 CiMgQ09ORklHX1VTQl9TRVJJQUxfTUNUX1UyMzIgaXMgbm90IHNldAojIENPTkZJR19VU0Jf U0VSSUFMX01FVFJPIGlzIG5vdCBzZXQKQ09ORklHX1VTQl9TRVJJQUxfTU9TNzcyMD15CkNP TkZJR19VU0JfU0VSSUFMX01PUzc4NDA9eQojIENPTkZJR19VU0JfU0VSSUFMX01PVE9ST0xB IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9OQVZNQU4gaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX1BMMjMwMyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxf T1RJNjg1OCBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfUUNBVVggaXMgbm90IHNl dAojIENPTkZJR19VU0JfU0VSSUFMX1FVQUxDT01NIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X1NFUklBTF9TUENQOFg1IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9IUDRYIGlz IG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9TQUZFIGlzIG5vdCBzZXQKIyBDT05GSUdf VVNCX1NFUklBTF9TSUVNRU5TX01QSSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxf U0lFUlJBV0lSRUxFU1MgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1NZTUJPTCBp cyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfVEkgaXMgbm90IHNldAojIENPTkZJR19V U0JfU0VSSUFMX0NZQkVSSkFDSyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfWElS Q09NIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9PUFRJT04gaXMgbm90IHNldAoj IENPTkZJR19VU0JfU0VSSUFMX09NTklORVQgaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VS SUFMX09QVElDT04gaXMgbm90IHNldAojIENPTkZJR19VU0JfU0VSSUFMX1ZJVk9QQVlfU0VS SUFMIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9aSU8gaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX1pURSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9TRVJJQUxfU1NV MTAwIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX1NFUklBTF9RVDIgaXMgbm90IHNldAojIENP TkZJR19VU0JfU0VSSUFMX0RFQlVHIGlzIG5vdCBzZXQKCiMKIyBVU0IgTWlzY2VsbGFuZW91 cyBkcml2ZXJzCiMKIyBDT05GSUdfVVNCX0VNSTYyIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNC X0VNSTI2IGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0FEVVRVWCBpcyBub3Qgc2V0CiMgQ09O RklHX1VTQl9TRVZTRUcgaXMgbm90IHNldAojIENPTkZJR19VU0JfUklPNTAwIGlzIG5vdCBz ZXQKIyBDT05GSUdfVVNCX0xFR09UT1dFUiBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9MQ0Qg aXMgbm90IHNldAojIENPTkZJR19VU0JfTEVEIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0NZ UFJFU1NfQ1k3QzYzIGlzIG5vdCBzZXQKIyBDT05GSUdfVVNCX0NZVEhFUk0gaXMgbm90IHNl dAojIENPTkZJR19VU0JfSURNT1VTRSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9GVERJX0VM QU4gaXMgbm90IHNldAojIENPTkZJR19VU0JfQVBQTEVESVNQTEFZIGlzIG5vdCBzZXQKIyBD T05GSUdfVVNCX1NJU1VTQlZHQSBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9MRCBpcyBub3Qg c2V0CiMgQ09ORklHX1VTQl9UUkFOQ0VWSUJSQVRPUiBpcyBub3Qgc2V0CiMgQ09ORklHX1VT Ql9JT1dBUlJJT1IgaXMgbm90IHNldAojIENPTkZJR19VU0JfVEVTVCBpcyBub3Qgc2V0CiMg Q09ORklHX1VTQl9JU0lHSFRGVyBpcyBub3Qgc2V0CiMgQ09ORklHX1VTQl9ZVVJFWCBpcyBu b3Qgc2V0CiMgQ09ORklHX1VTQl9FWlVTQl9GWDIgaXMgbm90IHNldAoKIwojIFVTQiBQaHlz aWNhbCBMYXllciBkcml2ZXJzCiMKIyBDT05GSUdfT01BUF9VU0IyIGlzIG5vdCBzZXQKIyBD T05GSUdfVVNCX0lTUDEzMDEgaXMgbm90IHNldAojIENPTkZJR19VU0JfR0FER0VUIGlzIG5v dCBzZXQKCiMKIyBPVEcgYW5kIHJlbGF0ZWQgaW5mcmFzdHJ1Y3R1cmUKIwojIENPTkZJR19O T1BfVVNCX1hDRUlWIGlzIG5vdCBzZXQKIyBDT05GSUdfVVdCIGlzIG5vdCBzZXQKIyBDT05G SUdfTU1DIGlzIG5vdCBzZXQKIyBDT05GSUdfTUVNU1RJQ0sgaXMgbm90IHNldApDT05GSUdf TkVXX0xFRFM9eQpDT05GSUdfTEVEU19DTEFTUz15CgojCiMgTEVEIGRyaXZlcnMKIwojIENP TkZJR19MRURTX0xNMzUzMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfTE0zNjQyIGlzIG5v dCBzZXQKIyBDT05GSUdfTEVEU19QQ0E5NTMyIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19M UDM5NDQgaXMgbm90IHNldAojIENPTkZJR19MRURTX0xQNTUyMSBpcyBub3Qgc2V0CiMgQ09O RklHX0xFRFNfTFA1NTIzIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19DTEVWT19NQUlMIGlz IG5vdCBzZXQKIyBDT05GSUdfTEVEU19QQ0E5NTVYIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVE U19QQ0E5NjMzIGlzIG5vdCBzZXQKIyBDT05GSUdfTEVEU19CRDI4MDIgaXMgbm90IHNldAoj IENPTkZJR19MRURTX0lOVEVMX1NTNDIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfVENB NjUwNyBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfTE0zNTV4IGlzIG5vdCBzZXQKIyBDT05G SUdfTEVEU19PVDIwMCBpcyBub3Qgc2V0CiMgQ09ORklHX0xFRFNfQkxJTktNIGlzIG5vdCBz ZXQKIyBDT05GSUdfTEVEU19UUklHR0VSUyBpcyBub3Qgc2V0CgojCiMgTEVEIFRyaWdnZXJz CiMKIyBDT05GSUdfQUNDRVNTSUJJTElUWSBpcyBub3Qgc2V0CiMgQ09ORklHX0lORklOSUJB TkQgaXMgbm90IHNldAojIENPTkZJR19FREFDIGlzIG5vdCBzZXQKQ09ORklHX1JUQ19MSUI9 eQpDT05GSUdfUlRDX0NMQVNTPXkKIyBDT05GSUdfUlRDX0hDVE9TWVMgaXMgbm90IHNldAoj IENPTkZJR19SVENfREVCVUcgaXMgbm90IHNldAoKIwojIFJUQyBpbnRlcmZhY2VzCiMKQ09O RklHX1JUQ19JTlRGX1NZU0ZTPXkKQ09ORklHX1JUQ19JTlRGX1BST0M9eQpDT05GSUdfUlRD X0lOVEZfREVWPXkKIyBDT05GSUdfUlRDX0lOVEZfREVWX1VJRV9FTVVMIGlzIG5vdCBzZXQK IyBDT05GSUdfUlRDX0RSVl9URVNUIGlzIG5vdCBzZXQKCiMKIyBJMkMgUlRDIGRyaXZlcnMK IwojIENPTkZJR19SVENfRFJWX0RTMTMwNyBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZf RFMxMzc0IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9EUzE2NzIgaXMgbm90IHNldAoj IENPTkZJR19SVENfRFJWX0RTMzIzMiBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfTUFY NjkwMCBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUlM1QzM3MiBpcyBub3Qgc2V0CiMg Q09ORklHX1JUQ19EUlZfSVNMMTIwOCBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfSVNM MTIwMjIgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX1gxMjA1IGlzIG5vdCBzZXQKIyBD T05GSUdfUlRDX0RSVl9QQ0Y4NTYzIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9QQ0Y4 NTgzIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9NNDFUODAgaXMgbm90IHNldAojIENP TkZJR19SVENfRFJWX0JRMzJLIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9TMzUzOTBB IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9GTTMxMzAgaXMgbm90IHNldAojIENPTkZJ R19SVENfRFJWX1JYODU4MSBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfUlg4MDI1IGlz IG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9FTTMwMjcgaXMgbm90IHNldAojIENPTkZJR19S VENfRFJWX1JWMzAyOUMyIGlzIG5vdCBzZXQKCiMKIyBTUEkgUlRDIGRyaXZlcnMKIwoKIwoj IFBsYXRmb3JtIFJUQyBkcml2ZXJzCiMKQ09ORklHX1JUQ19EUlZfQ01PUz15CiMgQ09ORklH X1JUQ19EUlZfRFMxMjg2IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9EUzE1MTEgaXMg bm90IHNldAojIENPTkZJR19SVENfRFJWX0RTMTU1MyBpcyBub3Qgc2V0CiMgQ09ORklHX1JU Q19EUlZfRFMxNzQyIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9TVEsxN1RBOCBpcyBu b3Qgc2V0CiMgQ09ORklHX1JUQ19EUlZfTTQ4VDg2IGlzIG5vdCBzZXQKIyBDT05GSUdfUlRD X0RSVl9NNDhUMzUgaXMgbm90IHNldAojIENPTkZJR19SVENfRFJWX000OFQ1OSBpcyBub3Qg c2V0CiMgQ09ORklHX1JUQ19EUlZfTVNNNjI0MiBpcyBub3Qgc2V0CiMgQ09ORklHX1JUQ19E UlZfQlE0ODAyIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9SUDVDMDEgaXMgbm90IHNl dAojIENPTkZJR19SVENfRFJWX1YzMDIwIGlzIG5vdCBzZXQKIyBDT05GSUdfUlRDX0RSVl9E UzI0MDQgaXMgbm90IHNldAoKIwojIG9uLUNQVSBSVEMgZHJpdmVycwojCiMgQ09ORklHX0RN QURFVklDRVMgaXMgbm90IHNldAojIENPTkZJR19BVVhESVNQTEFZIGlzIG5vdCBzZXQKIyBD T05GSUdfVUlPIGlzIG5vdCBzZXQKIyBDT05GSUdfVkZJTyBpcyBub3Qgc2V0CgojCiMgVmly dGlvIGRyaXZlcnMKIwojIENPTkZJR19WSVJUSU9fUENJIGlzIG5vdCBzZXQKIyBDT05GSUdf VklSVElPX01NSU8gaXMgbm90IHNldAoKIwojIE1pY3Jvc29mdCBIeXBlci1WIGd1ZXN0IHN1 cHBvcnQKIwojIENPTkZJR19IWVBFUlYgaXMgbm90IHNldAoKIwojIFhlbiBkcml2ZXIgc3Vw cG9ydAojCkNPTkZJR19YRU5fQkFMTE9PTj15CkNPTkZJR19YRU5fU0NSVUJfUEFHRVM9eQpD T05GSUdfWEVOX0RFVl9FVlRDSE49eQpDT05GSUdfWEVOX0JBQ0tFTkQ9eQpDT05GSUdfWEVO RlM9eQpDT05GSUdfWEVOX0NPTVBBVF9YRU5GUz15CkNPTkZJR19YRU5fU1lTX0hZUEVSVklT T1I9eQpDT05GSUdfWEVOX1hFTkJVU19GUk9OVEVORD15CkNPTkZJR19YRU5fR05UREVWPXkK Q09ORklHX1hFTl9HUkFOVF9ERVZfQUxMT0M9eQpDT05GSUdfU1dJT1RMQl9YRU49eQpDT05G SUdfWEVOX1BDSURFVl9CQUNLRU5EPXkKQ09ORklHX1hFTl9QUklWQ01EPXkKQ09ORklHX1hF Tl9BQ1BJX1BST0NFU1NPUj15CkNPTkZJR19YRU5fTUNFX0xPRz15CiMgQ09ORklHX1NUQUdJ TkcgaXMgbm90IHNldAojIENPTkZJR19YODZfUExBVEZPUk1fREVWSUNFUyBpcyBub3Qgc2V0 CgojCiMgSGFyZHdhcmUgU3BpbmxvY2sgZHJpdmVycwojCkNPTkZJR19DTEtFVlRfSTgyNTM9 eQpDT05GSUdfSTgyNTNfTE9DSz15CkNPTkZJR19DTEtCTERfSTgyNTM9eQpDT05GSUdfSU9N TVVfQVBJPXkKQ09ORklHX0lPTU1VX1NVUFBPUlQ9eQpDT05GSUdfQU1EX0lPTU1VPXkKQ09O RklHX0FNRF9JT01NVV9TVEFUUz15CiMgQ09ORklHX0lOVEVMX0lPTU1VIGlzIG5vdCBzZXQK IyBDT05GSUdfSVJRX1JFTUFQIGlzIG5vdCBzZXQKCiMKIyBSZW1vdGVwcm9jIGRyaXZlcnMg KEVYUEVSSU1FTlRBTCkKIwojIENPTkZJR19TVEVfTU9ERU1fUlBST0MgaXMgbm90IHNldAoK IwojIFJwbXNnIGRyaXZlcnMgKEVYUEVSSU1FTlRBTCkKIwojIENPTkZJR19WSVJUX0RSSVZF UlMgaXMgbm90IHNldAojIENPTkZJR19QTV9ERVZGUkVRIGlzIG5vdCBzZXQKIyBDT05GSUdf RVhUQ09OIGlzIG5vdCBzZXQKIyBDT05GSUdfTUVNT1JZIGlzIG5vdCBzZXQKIyBDT05GSUdf SUlPIGlzIG5vdCBzZXQKIyBDT05GSUdfVk1FX0JVUyBpcyBub3Qgc2V0CiMgQ09ORklHX1BX TSBpcyBub3Qgc2V0CgojCiMgRmlybXdhcmUgRHJpdmVycwojCiMgQ09ORklHX0VERCBpcyBu b3Qgc2V0CkNPTkZJR19GSVJNV0FSRV9NRU1NQVA9eQojIENPTkZJR19ERUxMX1JCVSBpcyBu b3Qgc2V0CiMgQ09ORklHX0RDREJBUyBpcyBub3Qgc2V0CkNPTkZJR19ETUlJRD15CkNPTkZJ R19ETUlfU1lTRlM9eQojIENPTkZJR19JU0NTSV9JQkZUX0ZJTkQgaXMgbm90IHNldAojIENP TkZJR19HT09HTEVfRklSTVdBUkUgaXMgbm90IHNldAoKIwojIEZpbGUgc3lzdGVtcwojCkNP TkZJR19EQ0FDSEVfV09SRF9BQ0NFU1M9eQojIENPTkZJR19FWFQyX0ZTIGlzIG5vdCBzZXQK Q09ORklHX0VYVDNfRlM9eQojIENPTkZJR19FWFQzX0RFRkFVTFRTX1RPX09SREVSRUQgaXMg bm90IHNldApDT05GSUdfRVhUM19GU19YQVRUUj15CkNPTkZJR19FWFQzX0ZTX1BPU0lYX0FD TD15CkNPTkZJR19FWFQzX0ZTX1NFQ1VSSVRZPXkKQ09ORklHX0VYVDRfRlM9eQpDT05GSUdf RVhUNF9VU0VfRk9SX0VYVDIzPXkKQ09ORklHX0VYVDRfRlNfWEFUVFI9eQojIENPTkZJR19F WFQ0X0ZTX1BPU0lYX0FDTCBpcyBub3Qgc2V0CiMgQ09ORklHX0VYVDRfRlNfU0VDVVJJVFkg aXMgbm90IHNldApDT05GSUdfRVhUNF9ERUJVRz15CkNPTkZJR19KQkQ9eQojIENPTkZJR19K QkRfREVCVUcgaXMgbm90IHNldApDT05GSUdfSkJEMj15CkNPTkZJR19KQkQyX0RFQlVHPXkK Q09ORklHX0ZTX01CQ0FDSEU9eQojIENPTkZJR19SRUlTRVJGU19GUyBpcyBub3Qgc2V0CiMg Q09ORklHX0pGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX1hGU19GUyBpcyBub3Qgc2V0CiMg Q09ORklHX0dGUzJfRlMgaXMgbm90IHNldAojIENPTkZJR19CVFJGU19GUyBpcyBub3Qgc2V0 CiMgQ09ORklHX05JTEZTMl9GUyBpcyBub3Qgc2V0CkNPTkZJR19GU19QT1NJWF9BQ0w9eQpD T05GSUdfRklMRV9MT0NLSU5HPXkKQ09ORklHX0ZTTk9USUZZPXkKQ09ORklHX0ROT1RJRlk9 eQpDT05GSUdfSU5PVElGWV9VU0VSPXkKIyBDT05GSUdfRkFOT1RJRlkgaXMgbm90IHNldApD T05GSUdfUVVPVEE9eQpDT05GSUdfUVVPVEFfTkVUTElOS19JTlRFUkZBQ0U9eQojIENPTkZJ R19QUklOVF9RVU9UQV9XQVJOSU5HIGlzIG5vdCBzZXQKIyBDT05GSUdfUVVPVEFfREVCVUcg aXMgbm90IHNldApDT05GSUdfUVVPVEFfVFJFRT15CiMgQ09ORklHX1FGTVRfVjEgaXMgbm90 IHNldApDT05GSUdfUUZNVF9WMj15CkNPTkZJR19RVU9UQUNUTD15CkNPTkZJR19RVU9UQUNU TF9DT01QQVQ9eQpDT05GSUdfQVVUT0ZTNF9GUz15CkNPTkZJR19GVVNFX0ZTPXkKIyBDT05G SUdfQ1VTRSBpcyBub3Qgc2V0CkNPTkZJR19HRU5FUklDX0FDTD15CgojCiMgQ2FjaGVzCiMK IyBDT05GSUdfRlNDQUNIRSBpcyBub3Qgc2V0CgojCiMgQ0QtUk9NL0RWRCBGaWxlc3lzdGVt cwojCkNPTkZJR19JU085NjYwX0ZTPXkKQ09ORklHX0pPTElFVD15CkNPTkZJR19aSVNPRlM9 eQojIENPTkZJR19VREZfRlMgaXMgbm90IHNldAoKIwojIERPUy9GQVQvTlQgRmlsZXN5c3Rl bXMKIwpDT05GSUdfRkFUX0ZTPXkKQ09ORklHX01TRE9TX0ZTPXkKQ09ORklHX1ZGQVRfRlM9 eQpDT05GSUdfRkFUX0RFRkFVTFRfQ09ERVBBR0U9NDM3CkNPTkZJR19GQVRfREVGQVVMVF9J T0NIQVJTRVQ9Imlzbzg4NTktMSIKQ09ORklHX05URlNfRlM9eQojIENPTkZJR19OVEZTX0RF QlVHIGlzIG5vdCBzZXQKQ09ORklHX05URlNfUlc9eQoKIwojIFBzZXVkbyBmaWxlc3lzdGVt cwojCkNPTkZJR19QUk9DX0ZTPXkKQ09ORklHX1BST0NfS0NPUkU9eQpDT05GSUdfUFJPQ19W TUNPUkU9eQpDT05GSUdfUFJPQ19TWVNDVEw9eQpDT05GSUdfUFJPQ19QQUdFX01PTklUT1I9 eQpDT05GSUdfU1lTRlM9eQpDT05GSUdfVE1QRlM9eQpDT05GSUdfVE1QRlNfUE9TSVhfQUNM PXkKQ09ORklHX1RNUEZTX1hBVFRSPXkKQ09ORklHX0hVR0VUTEJGUz15CkNPTkZJR19IVUdF VExCX1BBR0U9eQojIENPTkZJR19DT05GSUdGU19GUyBpcyBub3Qgc2V0CiMgQ09ORklHX01J U0NfRklMRVNZU1RFTVMgaXMgbm90IHNldAojIENPTkZJR19ORVRXT1JLX0ZJTEVTWVNURU1T IGlzIG5vdCBzZXQKQ09ORklHX05MUz15CkNPTkZJR19OTFNfREVGQVVMVD0idXRmOCIKQ09O RklHX05MU19DT0RFUEFHRV80Mzc9eQojIENPTkZJR19OTFNfQ09ERVBBR0VfNzM3IGlzIG5v dCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzc3NSBpcyBub3Qgc2V0CiMgQ09ORklHX05M U19DT0RFUEFHRV84NTAgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0VfODUyIGlz IG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg1NSBpcyBub3Qgc2V0CiMgQ09ORklH X05MU19DT0RFUEFHRV84NTcgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0VfODYw IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2MSBpcyBub3Qgc2V0CiMgQ09O RklHX05MU19DT0RFUEFHRV84NjIgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBBR0Vf ODYzIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2NCBpcyBub3Qgc2V0CiMg Q09ORklHX05MU19DT0RFUEFHRV84NjUgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09ERVBB R0VfODY2IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzg2OSBpcyBub3Qgc2V0 CiMgQ09ORklHX05MU19DT0RFUEFHRV85MzYgaXMgbm90IHNldAojIENPTkZJR19OTFNfQ09E RVBBR0VfOTUwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0NPREVQQUdFXzkzMiBpcyBub3Qg c2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV85NDkgaXMgbm90IHNldAojIENPTkZJR19OTFNf Q09ERVBBR0VfODc0IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4NTlfOCBpcyBub3Qg c2V0CiMgQ09ORklHX05MU19DT0RFUEFHRV8xMjUwIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxT X0NPREVQQUdFXzEyNTEgaXMgbm90IHNldApDT05GSUdfTkxTX0FTQ0lJPXkKQ09ORklHX05M U19JU084ODU5XzE9eQojIENPTkZJR19OTFNfSVNPODg1OV8yIGlzIG5vdCBzZXQKIyBDT05G SUdfTkxTX0lTTzg4NTlfMyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19JU084ODU5XzQgaXMg bm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV81IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxT X0lTTzg4NTlfNiBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19JU084ODU5XzcgaXMgbm90IHNl dAojIENPTkZJR19OTFNfSVNPODg1OV85IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0lTTzg4 NTlfMTMgaXMgbm90IHNldAojIENPTkZJR19OTFNfSVNPODg1OV8xNCBpcyBub3Qgc2V0CiMg Q09ORklHX05MU19JU084ODU5XzE1IGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX0tPSThfUiBp cyBub3Qgc2V0CiMgQ09ORklHX05MU19LT0k4X1UgaXMgbm90IHNldAojIENPTkZJR19OTFNf TUFDX1JPTUFOIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX01BQ19DRUxUSUMgaXMgbm90IHNl dAojIENPTkZJR19OTFNfTUFDX0NFTlRFVVJPIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX01B Q19DUk9BVElBTiBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfQ1lSSUxMSUMgaXMgbm90 IHNldAojIENPTkZJR19OTFNfTUFDX0dBRUxJQyBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19N QUNfR1JFRUsgaXMgbm90IHNldAojIENPTkZJR19OTFNfTUFDX0lDRUxBTkQgaXMgbm90IHNl dAojIENPTkZJR19OTFNfTUFDX0lOVUlUIGlzIG5vdCBzZXQKIyBDT05GSUdfTkxTX01BQ19S T01BTklBTiBpcyBub3Qgc2V0CiMgQ09ORklHX05MU19NQUNfVFVSS0lTSCBpcyBub3Qgc2V0 CkNPTkZJR19OTFNfVVRGOD15CgojCiMgS2VybmVsIGhhY2tpbmcKIwpDT05GSUdfVFJBQ0Vf SVJRRkxBR1NfU1VQUE9SVD15CkNPTkZJR19QUklOVEtfVElNRT15CkNPTkZJR19ERUZBVUxU X01FU1NBR0VfTE9HTEVWRUw9NgojIENPTkZJR19FTkFCTEVfV0FSTl9ERVBSRUNBVEVEIGlz IG5vdCBzZXQKIyBDT05GSUdfRU5BQkxFX01VU1RfQ0hFQ0sgaXMgbm90IHNldApDT05GSUdf RlJBTUVfV0FSTj0yMDQ4CkNPTkZJR19NQUdJQ19TWVNSUT15CiMgQ09ORklHX1NUUklQX0FT TV9TWU1TIGlzIG5vdCBzZXQKIyBDT05GSUdfUkVBREFCTEVfQVNNIGlzIG5vdCBzZXQKIyBD T05GSUdfVU5VU0VEX1NZTUJPTFMgaXMgbm90IHNldApDT05GSUdfREVCVUdfRlM9eQojIENP TkZJR19IRUFERVJTX0NIRUNLIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfU0VDVElPTl9N SVNNQVRDSCBpcyBub3Qgc2V0CkNPTkZJR19ERUJVR19LRVJORUw9eQpDT05GSUdfREVCVUdf U0hJUlE9eQpDT05GSUdfTE9DS1VQX0RFVEVDVE9SPXkKQ09ORklHX0hBUkRMT0NLVVBfREVU RUNUT1I9eQojIENPTkZJR19CT09UUEFSQU1fSEFSRExPQ0tVUF9QQU5JQyBpcyBub3Qgc2V0 CkNPTkZJR19CT09UUEFSQU1fSEFSRExPQ0tVUF9QQU5JQ19WQUxVRT0wCiMgQ09ORklHX0JP T1RQQVJBTV9TT0ZUTE9DS1VQX1BBTklDIGlzIG5vdCBzZXQKQ09ORklHX0JPT1RQQVJBTV9T T0ZUTE9DS1VQX1BBTklDX1ZBTFVFPTAKIyBDT05GSUdfUEFOSUNfT05fT09QUyBpcyBub3Qg c2V0CkNPTkZJR19QQU5JQ19PTl9PT1BTX1ZBTFVFPTAKQ09ORklHX0RFVEVDVF9IVU5HX1RB U0s9eQpDT05GSUdfREVGQVVMVF9IVU5HX1RBU0tfVElNRU9VVD0xMjAKIyBDT05GSUdfQk9P VFBBUkFNX0hVTkdfVEFTS19QQU5JQyBpcyBub3Qgc2V0CkNPTkZJR19CT09UUEFSQU1fSFVO R19UQVNLX1BBTklDX1ZBTFVFPTAKIyBDT05GSUdfU0NIRURfREVCVUcgaXMgbm90IHNldApD T05GSUdfU0NIRURTVEFUUz15CkNPTkZJR19USU1FUl9TVEFUUz15CiMgQ09ORklHX0RFQlVH X09CSkVDVFMgaXMgbm90IHNldAojIENPTkZJR19TTFVCX0RFQlVHX09OIGlzIG5vdCBzZXQK IyBDT05GSUdfU0xVQl9TVEFUUyBpcyBub3Qgc2V0CkNPTkZJR19IQVZFX0RFQlVHX0tNRU1M RUFLPXkKIyBDT05GSUdfREVCVUdfS01FTUxFQUsgaXMgbm90IHNldApDT05GSUdfREVCVUdf UFJFRU1QVD15CkNPTkZJR19ERUJVR19SVF9NVVRFWEVTPXkKQ09ORklHX0RFQlVHX1BJX0xJ U1Q9eQojIENPTkZJR19SVF9NVVRFWF9URVNURVIgaXMgbm90IHNldApDT05GSUdfREVCVUdf U1BJTkxPQ0s9eQpDT05GSUdfREVCVUdfTVVURVhFUz15CkNPTkZJR19ERUJVR19MT0NLX0FM TE9DPXkKQ09ORklHX1BST1ZFX0xPQ0tJTkc9eQojIENPTkZJR19QUk9WRV9SQ1UgaXMgbm90 IHNldAojIENPTkZJR19QUk9WRV9SQ1VfREVMQVkgaXMgbm90IHNldApDT05GSUdfU1BBUlNF X1JDVV9QT0lOVEVSPXkKQ09ORklHX0xPQ0tERVA9eQojIENPTkZJR19MT0NLX1NUQVQgaXMg bm90IHNldApDT05GSUdfREVCVUdfTE9DS0RFUD15CkNPTkZJR19UUkFDRV9JUlFGTEFHUz15 CiMgQ09ORklHX0RFQlVHX0FUT01JQ19TTEVFUCBpcyBub3Qgc2V0CiMgQ09ORklHX0RFQlVH X0xPQ0tJTkdfQVBJX1NFTEZURVNUUyBpcyBub3Qgc2V0CkNPTkZJR19TVEFDS1RSQUNFPXkK IyBDT05GSUdfREVCVUdfU1RBQ0tfVVNBR0UgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19L T0JKRUNUIGlzIG5vdCBzZXQKQ09ORklHX0RFQlVHX0JVR1ZFUkJPU0U9eQpDT05GSUdfREVC VUdfSU5GTz15CiMgQ09ORklHX0RFQlVHX0lORk9fUkVEVUNFRCBpcyBub3Qgc2V0CiMgQ09O RklHX0RFQlVHX1ZNIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfVklSVFVBTCBpcyBub3Qg c2V0CkNPTkZJR19ERUJVR19XUklURUNPVU5UPXkKQ09ORklHX0RFQlVHX01FTU9SWV9JTklU PXkKQ09ORklHX0RFQlVHX0xJU1Q9eQojIENPTkZJR19URVNUX0xJU1RfU09SVCBpcyBub3Qg c2V0CkNPTkZJR19ERUJVR19TRz15CiMgQ09ORklHX0RFQlVHX05PVElGSUVSUyBpcyBub3Qg c2V0CiMgQ09ORklHX0RFQlVHX0NSRURFTlRJQUxTIGlzIG5vdCBzZXQKQ09ORklHX0FSQ0hf V0FOVF9GUkFNRV9QT0lOVEVSUz15CkNPTkZJR19GUkFNRV9QT0lOVEVSPXkKIyBDT05GSUdf Qk9PVF9QUklOVEtfREVMQVkgaXMgbm90IHNldAojIENPTkZJR19SQ1VfVE9SVFVSRV9URVNU IGlzIG5vdCBzZXQKQ09ORklHX1JDVV9DUFVfU1RBTExfVElNRU9VVD02MApDT05GSUdfUkNV X0NQVV9TVEFMTF9WRVJCT1NFPXkKQ09ORklHX1JDVV9DUFVfU1RBTExfSU5GTz15CiMgQ09O RklHX1JDVV9UUkFDRSBpcyBub3Qgc2V0CiMgQ09ORklHX0JBQ0tUUkFDRV9TRUxGX1RFU1Qg aXMgbm90IHNldAojIENPTkZJR19ERUJVR19CTE9DS19FWFRfREVWVCBpcyBub3Qgc2V0CiMg Q09ORklHX0RFQlVHX0ZPUkNFX1dFQUtfUEVSX0NQVSBpcyBub3Qgc2V0CiMgQ09ORklHX0RF QlVHX1BFUl9DUFVfTUFQUyBpcyBub3Qgc2V0CiMgQ09ORklHX0xLRFRNIGlzIG5vdCBzZXQK IyBDT05GSUdfTk9USUZJRVJfRVJST1JfSU5KRUNUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdf RkFVTFRfSU5KRUNUSU9OIGlzIG5vdCBzZXQKIyBDT05GSUdfTEFURU5DWVRPUCBpcyBub3Qg c2V0CiMgQ09ORklHX0RFQlVHX1BBR0VBTExPQyBpcyBub3Qgc2V0CkNPTkZJR19VU0VSX1NU QUNLVFJBQ0VfU1VQUE9SVD15CkNPTkZJR19IQVZFX0ZVTkNUSU9OX1RSQUNFUj15CkNPTkZJ R19IQVZFX0ZVTkNUSU9OX0dSQVBIX1RSQUNFUj15CkNPTkZJR19IQVZFX0ZVTkNUSU9OX0dS QVBIX0ZQX1RFU1Q9eQpDT05GSUdfSEFWRV9GVU5DVElPTl9UUkFDRV9NQ09VTlRfVEVTVD15 CkNPTkZJR19IQVZFX0RZTkFNSUNfRlRSQUNFPXkKQ09ORklHX0hBVkVfRlRSQUNFX01DT1VO VF9SRUNPUkQ9eQpDT05GSUdfSEFWRV9TWVNDQUxMX1RSQUNFUE9JTlRTPXkKQ09ORklHX0hB VkVfRkVOVFJZPXkKQ09ORklHX0hBVkVfQ19SRUNPUkRNQ09VTlQ9eQpDT05GSUdfVFJBQ0lO R19TVVBQT1JUPXkKIyBDT05GSUdfRlRSQUNFIGlzIG5vdCBzZXQKIyBDT05GSUdfUkJUUkVF X1RFU1QgaXMgbm90IHNldAojIENPTkZJR19JTlRFUlZBTF9UUkVFX1RFU1QgaXMgbm90IHNl dAojIENPTkZJR19QUk9WSURFX09IQ0kxMzk0X0RNQV9JTklUIGlzIG5vdCBzZXQKIyBDT05G SUdfRFlOQU1JQ19ERUJVRyBpcyBub3Qgc2V0CkNPTkZJR19ETUFfQVBJX0RFQlVHPXkKIyBD T05GSUdfQVRPTUlDNjRfU0VMRlRFU1QgaXMgbm90IHNldAojIENPTkZJR19TQU1QTEVTIGlz IG5vdCBzZXQKQ09ORklHX0hBVkVfQVJDSF9LR0RCPXkKIyBDT05GSUdfS0dEQiBpcyBub3Qg c2V0CkNPTkZJR19IQVZFX0FSQ0hfS01FTUNIRUNLPXkKIyBDT05GSUdfS01FTUNIRUNLIGlz IG5vdCBzZXQKIyBDT05GSUdfVEVTVF9LU1RSVE9YIGlzIG5vdCBzZXQKQ09ORklHX1NUUklD VF9ERVZNRU09eQpDT05GSUdfWDg2X1ZFUkJPU0VfQk9PVFVQPXkKQ09ORklHX0VBUkxZX1BS SU5USz15CiMgQ09ORklHX0VBUkxZX1BSSU5US19EQkdQIGlzIG5vdCBzZXQKIyBDT05GSUdf REVCVUdfU1RBQ0tPVkVSRkxPVyBpcyBub3Qgc2V0CiMgQ09ORklHX1g4Nl9QVERVTVAgaXMg bm90IHNldApDT05GSUdfREVCVUdfUk9EQVRBPXkKIyBDT05GSUdfREVCVUdfUk9EQVRBX1RF U1QgaXMgbm90IHNldAojIENPTkZJR19ERUJVR19TRVRfTU9EVUxFX1JPTlggaXMgbm90IHNl dAojIENPTkZJR19ERUJVR19OWF9URVNUIGlzIG5vdCBzZXQKIyBDT05GSUdfREVCVUdfVExC RkxVU0ggaXMgbm90IHNldApDT05GSUdfSU9NTVVfREVCVUc9eQojIENPTkZJR19JT01NVV9T VFJFU1MgaXMgbm90IHNldApDT05GSUdfSU9NTVVfTEVBSz15CkNPTkZJR19IQVZFX01NSU9U UkFDRV9TVVBQT1JUPXkKQ09ORklHX0lPX0RFTEFZX1RZUEVfMFg4MD0wCkNPTkZJR19JT19E RUxBWV9UWVBFXzBYRUQ9MQpDT05GSUdfSU9fREVMQVlfVFlQRV9VREVMQVk9MgpDT05GSUdf SU9fREVMQVlfVFlQRV9OT05FPTMKQ09ORklHX0lPX0RFTEFZXzBYODA9eQojIENPTkZJR19J T19ERUxBWV8wWEVEIGlzIG5vdCBzZXQKIyBDT05GSUdfSU9fREVMQVlfVURFTEFZIGlzIG5v dCBzZXQKIyBDT05GSUdfSU9fREVMQVlfTk9ORSBpcyBub3Qgc2V0CkNPTkZJR19ERUZBVUxU X0lPX0RFTEFZX1RZUEU9MApDT05GSUdfREVCVUdfQk9PVF9QQVJBTVM9eQojIENPTkZJR19D UEFfREVCVUcgaXMgbm90IHNldAojIENPTkZJR19PUFRJTUlaRV9JTkxJTklORyBpcyBub3Qg c2V0CiMgQ09ORklHX0RFQlVHX1NUUklDVF9VU0VSX0NPUFlfQ0hFQ0tTIGlzIG5vdCBzZXQK IyBDT05GSUdfREVCVUdfTk1JX1NFTEZURVNUIGlzIG5vdCBzZXQKCiMKIyBTZWN1cml0eSBv cHRpb25zCiMKIyBDT05GSUdfS0VZUyBpcyBub3Qgc2V0CiMgQ09ORklHX1NFQ1VSSVRZX0RN RVNHX1JFU1RSSUNUIGlzIG5vdCBzZXQKIyBDT05GSUdfU0VDVVJJVFkgaXMgbm90IHNldAoj IENPTkZJR19TRUNVUklUWUZTIGlzIG5vdCBzZXQKQ09ORklHX0RFRkFVTFRfU0VDVVJJVFlf REFDPXkKQ09ORklHX0RFRkFVTFRfU0VDVVJJVFk9IiIKQ09ORklHX0NSWVBUTz15CgojCiMg Q3J5cHRvIGNvcmUgb3IgaGVscGVyCiMKQ09ORklHX0NSWVBUT19BTEdBUEk9eQpDT05GSUdf Q1JZUFRPX0FMR0FQSTI9eQpDT05GSUdfQ1JZUFRPX0FFQUQ9eQpDT05GSUdfQ1JZUFRPX0FF QUQyPXkKQ09ORklHX0NSWVBUT19CTEtDSVBIRVI9eQpDT05GSUdfQ1JZUFRPX0JMS0NJUEhF UjI9eQpDT05GSUdfQ1JZUFRPX0hBU0g9eQpDT05GSUdfQ1JZUFRPX0hBU0gyPXkKQ09ORklH X0NSWVBUT19STkc9eQpDT05GSUdfQ1JZUFRPX1JORzI9eQpDT05GSUdfQ1JZUFRPX1BDT01Q PXkKQ09ORklHX0NSWVBUT19QQ09NUDI9eQpDT05GSUdfQ1JZUFRPX01BTkFHRVI9eQpDT05G SUdfQ1JZUFRPX01BTkFHRVIyPXkKIyBDT05GSUdfQ1JZUFRPX1VTRVIgaXMgbm90IHNldApD T05GSUdfQ1JZUFRPX01BTkFHRVJfRElTQUJMRV9URVNUUz15CkNPTkZJR19DUllQVE9fR0Yx MjhNVUw9eQojIENPTkZJR19DUllQVE9fTlVMTCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBU T19QQ1JZUFQgaXMgbm90IHNldApDT05GSUdfQ1JZUFRPX1dPUktRVUVVRT15CkNPTkZJR19D UllQVE9fQ1JZUFREPXkKQ09ORklHX0NSWVBUT19BVVRIRU5DPXkKIyBDT05GSUdfQ1JZUFRP X1RFU1QgaXMgbm90IHNldApDT05GSUdfQ1JZUFRPX0FCTEtfSEVMUEVSX1g4Nj15CkNPTkZJ R19DUllQVE9fR0xVRV9IRUxQRVJfWDg2PXkKCiMKIyBBdXRoZW50aWNhdGVkIEVuY3J5cHRp b24gd2l0aCBBc3NvY2lhdGVkIERhdGEKIwojIENPTkZJR19DUllQVE9fQ0NNIGlzIG5vdCBz ZXQKIyBDT05GSUdfQ1JZUFRPX0dDTSBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19TRVFJ ViBpcyBub3Qgc2V0CgojCiMgQmxvY2sgbW9kZXMKIwpDT05GSUdfQ1JZUFRPX0NCQz15CiMg Q09ORklHX0NSWVBUT19DVFIgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fQ1RTIGlzIG5v dCBzZXQKQ09ORklHX0NSWVBUT19FQ0I9eQpDT05GSUdfQ1JZUFRPX0xSVz15CiMgQ09ORklH X0NSWVBUT19QQ0JDIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19YVFM9eQoKIwojIEhhc2gg bW9kZXMKIwpDT05GSUdfQ1JZUFRPX0hNQUM9eQojIENPTkZJR19DUllQVE9fWENCQyBpcyBu b3Qgc2V0CiMgQ09ORklHX0NSWVBUT19WTUFDIGlzIG5vdCBzZXQKCiMKIyBEaWdlc3QKIwpD T05GSUdfQ1JZUFRPX0NSQzMyQz15CkNPTkZJR19DUllQVE9fQ1JDMzJDX0lOVEVMPXkKIyBD T05GSUdfQ1JZUFRPX0dIQVNIIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX01ENCBpcyBu b3Qgc2V0CkNPTkZJR19DUllQVE9fTUQ1PXkKIyBDT05GSUdfQ1JZUFRPX01JQ0hBRUxfTUlD IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1JNRDEyOCBpcyBub3Qgc2V0CiMgQ09ORklH X0NSWVBUT19STUQxNjAgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fUk1EMjU2IGlzIG5v dCBzZXQKIyBDT05GSUdfQ1JZUFRPX1JNRDMyMCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9f U0hBMT15CkNPTkZJR19DUllQVE9fU0hBMV9TU1NFMz15CiMgQ09ORklHX0NSWVBUT19TSEEy NTYgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fU0hBNTEyIGlzIG5vdCBzZXQKIyBDT05G SUdfQ1JZUFRPX1RHUjE5MiBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19XUDUxMiBpcyBu b3Qgc2V0CiMgQ09ORklHX0NSWVBUT19HSEFTSF9DTE1VTF9OSV9JTlRFTCBpcyBub3Qgc2V0 CgojCiMgQ2lwaGVycwojCkNPTkZJR19DUllQVE9fQUVTPXkKQ09ORklHX0NSWVBUT19BRVNf WDg2XzY0PXkKQ09ORklHX0NSWVBUT19BRVNfTklfSU5URUw9eQojIENPTkZJR19DUllQVE9f QU5VQklTIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19BUkM0PXkKQ09ORklHX0NSWVBUT19C TE9XRklTSD15CkNPTkZJR19DUllQVE9fQkxPV0ZJU0hfQ09NTU9OPXkKQ09ORklHX0NSWVBU T19CTE9XRklTSF9YODZfNjQ9eQojIENPTkZJR19DUllQVE9fQ0FNRUxMSUEgaXMgbm90IHNl dAojIENPTkZJR19DUllQVE9fQ0FNRUxMSUFfWDg2XzY0IGlzIG5vdCBzZXQKIyBDT05GSUdf Q1JZUFRPX0NBU1Q1IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0NBU1Q1X0FWWF9YODZf NjQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fQ0FTVDYgaXMgbm90IHNldAojIENPTkZJ R19DUllQVE9fQ0FTVDZfQVZYX1g4Nl82NCBpcyBub3Qgc2V0CkNPTkZJR19DUllQVE9fREVT PXkKIyBDT05GSUdfQ1JZUFRPX0ZDUllQVCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19L SEFaQUQgaXMgbm90IHNldAojIENPTkZJR19DUllQVE9fU0FMU0EyMCBpcyBub3Qgc2V0CiMg Q09ORklHX0NSWVBUT19TQUxTQTIwX1g4Nl82NCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBU T19TRUVEIGlzIG5vdCBzZXQKQ09ORklHX0NSWVBUT19TRVJQRU5UPXkKQ09ORklHX0NSWVBU T19TRVJQRU5UX1NTRTJfWDg2XzY0PXkKIyBDT05GSUdfQ1JZUFRPX1NFUlBFTlRfQVZYX1g4 Nl82NCBpcyBub3Qgc2V0CiMgQ09ORklHX0NSWVBUT19URUEgaXMgbm90IHNldApDT05GSUdf Q1JZUFRPX1RXT0ZJU0g9eQpDT05GSUdfQ1JZUFRPX1RXT0ZJU0hfQ09NTU9OPXkKQ09ORklH X0NSWVBUT19UV09GSVNIX1g4Nl82ND15CkNPTkZJR19DUllQVE9fVFdPRklTSF9YODZfNjRf M1dBWT15CiMgQ09ORklHX0NSWVBUT19UV09GSVNIX0FWWF9YODZfNjQgaXMgbm90IHNldAoK IwojIENvbXByZXNzaW9uCiMKQ09ORklHX0NSWVBUT19ERUZMQVRFPXkKQ09ORklHX0NSWVBU T19aTElCPXkKQ09ORklHX0NSWVBUT19MWk89eQoKIwojIFJhbmRvbSBOdW1iZXIgR2VuZXJh dGlvbgojCkNPTkZJR19DUllQVE9fQU5TSV9DUFJORz15CiMgQ09ORklHX0NSWVBUT19VU0VS X0FQSV9IQVNIIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX1VTRVJfQVBJX1NLQ0lQSEVS IGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JZUFRPX0hXIGlzIG5vdCBzZXQKQ09ORklHX0hBVkVf S1ZNPXkKIyBDT05GSUdfVklSVFVBTElaQVRJT04gaXMgbm90IHNldAojIENPTkZJR19CSU5B UllfUFJJTlRGIGlzIG5vdCBzZXQKCiMKIyBMaWJyYXJ5IHJvdXRpbmVzCiMKQ09ORklHX0JJ VFJFVkVSU0U9eQpDT05GSUdfR0VORVJJQ19TVFJOQ1BZX0ZST01fVVNFUj15CkNPTkZJR19H RU5FUklDX1NUUk5MRU5fVVNFUj15CkNPTkZJR19HRU5FUklDX0ZJTkRfRklSU1RfQklUPXkK Q09ORklHX0dFTkVSSUNfUENJX0lPTUFQPXkKQ09ORklHX0dFTkVSSUNfSU9NQVA9eQpDT05G SUdfR0VORVJJQ19JTz15CiMgQ09ORklHX0NSQ19DQ0lUVCBpcyBub3Qgc2V0CkNPTkZJR19D UkMxNj15CkNPTkZJR19DUkNfVDEwRElGPXkKIyBDT05GSUdfQ1JDX0lUVV9UIGlzIG5vdCBz ZXQKQ09ORklHX0NSQzMyPXkKQ09ORklHX0NSQzMyX1NFTEZURVNUPXkKQ09ORklHX0NSQzMy X1NMSUNFQlk4PXkKIyBDT05GSUdfQ1JDMzJfU0xJQ0VCWTQgaXMgbm90IHNldAojIENPTkZJ R19DUkMzMl9TQVJXQVRFIGlzIG5vdCBzZXQKIyBDT05GSUdfQ1JDMzJfQklUIGlzIG5vdCBz ZXQKIyBDT05GSUdfQ1JDNyBpcyBub3Qgc2V0CkNPTkZJR19MSUJDUkMzMkM9eQojIENPTkZJ R19DUkM4IGlzIG5vdCBzZXQKQ09ORklHX1pMSUJfSU5GTEFURT15CkNPTkZJR19aTElCX0RF RkxBVEU9eQpDT05GSUdfTFpPX0NPTVBSRVNTPXkKQ09ORklHX0xaT19ERUNPTVBSRVNTPXkK Q09ORklHX1haX0RFQz15CkNPTkZJR19YWl9ERUNfWDg2PXkKQ09ORklHX1haX0RFQ19QT1dF UlBDPXkKQ09ORklHX1haX0RFQ19JQTY0PXkKQ09ORklHX1haX0RFQ19BUk09eQpDT05GSUdf WFpfREVDX0FSTVRIVU1CPXkKQ09ORklHX1haX0RFQ19TUEFSQz15CkNPTkZJR19YWl9ERUNf QkNKPXkKIyBDT05GSUdfWFpfREVDX1RFU1QgaXMgbm90IHNldApDT05GSUdfREVDT01QUkVT U19HWklQPXkKQ09ORklHX0RFQ09NUFJFU1NfQlpJUDI9eQpDT05GSUdfREVDT01QUkVTU19M Wk1BPXkKQ09ORklHX0RFQ09NUFJFU1NfWFo9eQpDT05GSUdfREVDT01QUkVTU19MWk89eQpD T05GSUdfVEVYVFNFQVJDSD15CkNPTkZJR19URVhUU0VBUkNIX0tNUD15CkNPTkZJR19URVhU U0VBUkNIX0JNPXkKQ09ORklHX1RFWFRTRUFSQ0hfRlNNPXkKQ09ORklHX0hBU19JT01FTT15 CkNPTkZJR19IQVNfSU9QT1JUPXkKQ09ORklHX0hBU19ETUE9eQpDT05GSUdfQ0hFQ0tfU0lH TkFUVVJFPXkKQ09ORklHX0NQVV9STUFQPXkKQ09ORklHX0RRTD15CkNPTkZJR19OTEFUVFI9 eQpDT05GSUdfQVJDSF9IQVNfQVRPTUlDNjRfREVDX0lGX1BPU0lUSVZFPXkKQ09ORklHX0FW RVJBR0U9eQojIENPTkZJR19DT1JESUMgaXMgbm90IHNldAojIENPTkZJR19ERFIgaXMgbm90 IHNldAo= ------------0F806B23E04D37875 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 ------------0F806B23E04D37875-- From xen-devel-bounces@lists.xen.org Mon Nov 19 19:10:26 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 19 Nov 2012 19:10:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaWjO-00027o-QT; Mon, 19 Nov 2012 19:10:06 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaW4d-00013s-1p for xen-devel@lists.xensource.com; Mon, 19 Nov 2012 18:28:00 +0000 Received: from [85.158.139.83:13645] by server-6.bemta-5.messagelabs.com id 20/34-19321-E2A7AA05; Mon, 19 Nov 2012 18:27:58 +0000 X-Env-Sender: wfp5p@viridian.itc.virginia.edu X-Msg-Ref: server-10.tower-182.messagelabs.com!1353349660!28601668!1 X-Originating-IP: [128.143.12.139] X-SpamReason: No, hits=2.2 required=7.0 tests=BIZ_TLD,BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 8645 invoked from network); 19 Nov 2012 18:27:40 -0000 Received: from viridian.itc.virginia.edu (HELO viridian.itc.virginia.edu) (128.143.12.139) by server-10.tower-182.messagelabs.com with SMTP; 19 Nov 2012 18:27:40 -0000 Received: by viridian.itc.virginia.edu (Postfix, from userid 1249) id 4042D80318; Mon, 19 Nov 2012 13:27:32 -0500 (EST) From: Bill Pemberton To: gregkh@linuxfoundation.org Date: Mon, 19 Nov 2012 13:21:47 -0500 Message-Id: <1353349642-3677-158-git-send-email-wfp5p@virginia.edu> X-Mailer: git-send-email 1.8.0 In-Reply-To: <1353349642-3677-1-git-send-email-wfp5p@virginia.edu> References: <1353349642-3677-1-git-send-email-wfp5p@virginia.edu> X-Mailman-Approved-At: Mon, 19 Nov 2012 19:10:06 +0000 Cc: linux-fbdev@vger.kernel.org, Benjamin Herrenschmidt , virtualization@lists.linux-foundation.org, Michal Januszewski , Paul Mackerras , linux-nvidia@lists.surfsouth.com, Daniel Walker , Kukjin Kim , Russell King , Wan ZongShun , Florian Tobias Schandinat , Jingoo Han , Tomi Valkeinen , David Brown , Jaya Kumar , cbe-oss-dev@lists.ozlabs.org, Antonino Daplas , linux-arm-msm@vger.kernel.org, Thomas Winischhofer , linux-geode@lists.infradead.org, linux-samsung-soc@vger.kernel.org, Ben Dooks , linux-omap@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Maik Broemme , Geoff Levand , Ferenc Bakonyi , Tony Prisk , Bryan Huntsman , Kristoffer Ericson , linuxppc-dev@lists.ozlabs.org, xen-devel@lists.xensource.com Subject: [Xen-devel] [PATCH 158/493] video: remove use of __devinit 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 CONFIG_HOTPLUG is going away as an option so __devinit is no longer needed. Signed-off-by: Bill Pemberton Cc: Florian Tobias Schandinat Cc: Jaya Kumar Cc: Paul Mackerras Cc: Benjamin Herrenschmidt Cc: Russell King Cc: Jingoo Han Cc: Ferenc Bakonyi Cc: Antonino Daplas Cc: Maik Broemme Cc: David Brown Cc: Daniel Walker Cc: Bryan Huntsman Cc: Wan ZongShun Cc: Tomi Valkeinen Cc: Geoff Levand Cc: Kristoffer Ericson Cc: Ben Dooks Cc: Kukjin Kim Cc: Thomas Winischhofer Cc: Michal Januszewski Cc: Tony Prisk Cc: linux-fbdev@vger.kernel.org Cc: linux-arm-kernel@lists.infradead.org Cc: linux-geode@lists.infradead.org Cc: linux-nvidia@lists.surfsouth.com Cc: linux-arm-msm@vger.kernel.org Cc: linux-omap@vger.kernel.org Cc: linuxppc-dev@lists.ozlabs.org Cc: cbe-oss-dev@lists.ozlabs.org Cc: linux-samsung-soc@vger.kernel.org Cc: xen-devel@lists.xensource.com Cc: virtualization@lists.linux-foundation.org --- drivers/video/acornfb.c | 14 ++-- drivers/video/arcfb.c | 2 +- drivers/video/arkfb.c | 2 +- drivers/video/asiliantfb.c | 6 +- drivers/video/aty/aty128fb.c | 22 +++--- drivers/video/aty/atyfb_base.c | 22 +++--- drivers/video/aty/mach64_ct.c | 4 +- drivers/video/aty/mach64_cursor.c | 2 +- drivers/video/aty/radeon_base.c | 14 ++-- drivers/video/aty/radeon_monitor.c | 16 ++--- drivers/video/au1100fb.c | 2 +- drivers/video/au1200fb.c | 2 +- drivers/video/auo_k1900fb.c | 2 +- drivers/video/auo_k1901fb.c | 2 +- drivers/video/auo_k190x.c | 2 +- drivers/video/bf537-lq035.c | 6 +- drivers/video/bf54x-lq043fb.c | 2 +- drivers/video/bfin-lq035q1-fb.c | 6 +- drivers/video/bfin-t350mcqb-fb.c | 2 +- drivers/video/bfin_adv7393fb.c | 2 +- drivers/video/broadsheetfb.c | 8 +-- drivers/video/bw2.c | 6 +- drivers/video/carminefb.c | 4 +- drivers/video/cg14.c | 4 +- drivers/video/cg3.c | 8 +-- drivers/video/cg6.c | 8 +-- drivers/video/chipsfb.c | 4 +- drivers/video/cirrusfb.c | 10 +-- drivers/video/cobalt_lcdfb.c | 2 +- drivers/video/console/sticore.c | 47 ++++++------- drivers/video/cyber2000fb.c | 12 ++-- drivers/video/da8xx-fb.c | 2 +- drivers/video/dnfb.c | 2 +- drivers/video/ep93xx-fb.c | 4 +- drivers/video/exynos/exynos_dp_core.c | 2 +- drivers/video/ffb.c | 2 +- drivers/video/fm2fb.c | 4 +- drivers/video/fsl-diu-fb.c | 4 +- drivers/video/gbefb.c | 4 +- drivers/video/geode/gx1fb_core.c | 6 +- drivers/video/geode/gxfb_core.c | 10 +-- drivers/video/geode/lxfb_core.c | 10 +-- drivers/video/grvga.c | 4 +- drivers/video/gxt4500.c | 4 +- drivers/video/hecubafb.c | 2 +- drivers/video/hgafb.c | 4 +- drivers/video/hitfb.c | 2 +- drivers/video/hpfb.c | 4 +- drivers/video/i740fb.c | 4 +- drivers/video/i810/i810_main.c | 26 +++---- drivers/video/i810/i810_main.h | 2 +- drivers/video/imsttfb.c | 4 +- drivers/video/intelfb/intelfbdrv.c | 16 ++--- drivers/video/jz4740_fb.c | 2 +- drivers/video/kyro/fbdev.c | 2 +- drivers/video/leo.c | 2 +- drivers/video/mb862xx/mb862xxfbdrv.c | 6 +- drivers/video/mbx/mbxdebugfs.c | 2 +- drivers/video/mbx/mbxfb.c | 10 +-- drivers/video/metronomefb.c | 12 ++-- drivers/video/msm/mddi.c | 6 +- drivers/video/mxsfb.c | 6 +- drivers/video/neofb.c | 12 ++-- drivers/video/nuc900fb.c | 4 +- drivers/video/nvidia/nvidia.c | 12 ++-- .../omap2/displays/panel-lgphilips-lb035q02.c | 2 +- drivers/video/p9100.c | 2 +- drivers/video/platinumfb.c | 6 +- drivers/video/pm2fb.c | 2 +- drivers/video/pm3fb.c | 4 +- drivers/video/pmag-ba-fb.c | 2 +- drivers/video/pmagb-b-fb.c | 6 +- drivers/video/ps3fb.c | 2 +- drivers/video/pvr2fb.c | 6 +- drivers/video/pxa168fb.c | 4 +- drivers/video/pxa3xx-gcu.c | 2 +- drivers/video/pxafb.c | 20 +++--- drivers/video/q40fb.c | 2 +- drivers/video/riva/fbdev.c | 20 +++--- drivers/video/riva/rivafb-i2c.c | 6 +- drivers/video/s1d13xxxfb.c | 4 +- drivers/video/s3c-fb.c | 6 +- drivers/video/s3c2410fb.c | 8 +-- drivers/video/s3fb.c | 6 +- drivers/video/sa1100fb.c | 6 +- drivers/video/savage/savagefb_driver.c | 8 +-- drivers/video/sgivwfb.c | 2 +- drivers/video/sh7760fb.c | 2 +- drivers/video/sh_mobile_lcdcfb.c | 16 ++--- drivers/video/sh_mobile_meram.c | 2 +- drivers/video/sis/sis_main.c | 82 +++++++++++----------- drivers/video/skeletonfb.c | 2 +- drivers/video/sm501fb.c | 8 +-- drivers/video/sstfb.c | 18 ++--- drivers/video/sunxvr1000.c | 6 +- drivers/video/sunxvr2500.c | 6 +- drivers/video/sunxvr500.c | 6 +- drivers/video/tcx.c | 2 +- drivers/video/tdfxfb.c | 10 +-- drivers/video/tgafb.c | 16 ++--- drivers/video/tmiofb.c | 2 +- drivers/video/tridentfb.c | 8 +-- drivers/video/uvesafb.c | 30 ++++---- drivers/video/vermilion/vermilion.c | 2 +- drivers/video/vfb.c | 2 +- drivers/video/vga16fb.c | 2 +- drivers/video/via/dvi.c | 8 +-- drivers/video/via/dvi.h | 4 +- drivers/video/via/hw.c | 16 ++--- drivers/video/via/hw.h | 4 +- drivers/video/via/lcd.c | 10 +-- drivers/video/via/lcd.h | 6 +- drivers/video/via/via-core.c | 10 +-- drivers/video/via/via-gpio.c | 2 +- drivers/video/via/viafbdev.c | 10 +-- drivers/video/vt8500lcdfb.c | 2 +- drivers/video/vt8623fb.c | 2 +- drivers/video/w100fb.c | 6 +- drivers/video/wm8505fb.c | 2 +- drivers/video/wmt_ge_rops.c | 2 +- drivers/video/xen-fbfront.c | 4 +- drivers/video/xilinxfb.c | 2 +- 122 files changed, 438 insertions(+), 443 deletions(-) diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c index b303f17..772f1ce 100644 --- a/drivers/video/acornfb.c +++ b/drivers/video/acornfb.c @@ -942,7 +942,7 @@ static struct fb_videomode acornfb_default_mode __devinitdata = { .vmode = FB_VMODE_NONINTERLACED }; -static void __devinit acornfb_init_fbinfo(void) +static void acornfb_init_fbinfo(void) { static int first = 1; @@ -1018,7 +1018,7 @@ static void __devinit acornfb_init_fbinfo(void) * size can optionally be followed by 'M' or 'K' for * MB or KB respectively. */ -static void __devinit acornfb_parse_mon(char *opt) +static void acornfb_parse_mon(char *opt) { char *p = opt; @@ -1065,7 +1065,7 @@ bad: current_par.montype = -1; } -static void __devinit acornfb_parse_montype(char *opt) +static void acornfb_parse_montype(char *opt) { current_par.montype = -2; @@ -1106,7 +1106,7 @@ static void __devinit acornfb_parse_montype(char *opt) } } -static void __devinit acornfb_parse_dram(char *opt) +static void acornfb_parse_dram(char *opt) { unsigned int size; @@ -1138,7 +1138,7 @@ static struct options { { NULL, NULL } }; -static int __devinit acornfb_setup(char *options) +static int acornfb_setup(char *options) { struct options *optp; char *opt; @@ -1175,7 +1175,7 @@ static int __devinit acornfb_setup(char *options) * Detect type of monitor connected * For now, we just assume SVGA */ -static int __devinit acornfb_detect_monitortype(void) +static int acornfb_detect_monitortype(void) { return 4; } @@ -1216,7 +1216,7 @@ free_unused_pages(unsigned int virtual_start, unsigned int virtual_end) printk("acornfb: freed %dK memory\n", mb_freed); } -static int __devinit acornfb_probe(struct platform_device *dev) +static int acornfb_probe(struct platform_device *dev) { unsigned long size; u_int h_sync, v_sync; diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c index 00967d2..964431a 100644 --- a/drivers/video/arcfb.c +++ b/drivers/video/arcfb.c @@ -502,7 +502,7 @@ static struct fb_ops arcfb_ops = { .fb_ioctl = arcfb_ioctl, }; -static int __devinit arcfb_probe(struct platform_device *dev) +static int arcfb_probe(struct platform_device *dev) { struct fb_info *info; int retval = -ENOMEM; diff --git a/drivers/video/arkfb.c b/drivers/video/arkfb.c index 6bcb6c1..750efbc 100644 --- a/drivers/video/arkfb.c +++ b/drivers/video/arkfb.c @@ -950,7 +950,7 @@ static struct fb_ops arkfb_ops = { /* PCI probe */ -static int __devinit ark_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) +static int ark_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct pci_bus_region bus_reg; struct resource vga_res; diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c index 640cc69..21744e9 100644 --- a/drivers/video/asiliantfb.c +++ b/drivers/video/asiliantfb.c @@ -451,7 +451,7 @@ static struct chips_init_reg chips_init_xr[] = {0xd1, 0x01}, }; -static void __devinit chips_hw_init(struct fb_info *p) +static void chips_hw_init(struct fb_info *p) { int i; @@ -504,7 +504,7 @@ static struct fb_var_screeninfo asiliantfb_var __devinitdata = { .vsync_len = 2, }; -static int __devinit init_asiliant(struct fb_info *p, unsigned long addr) +static int init_asiliant(struct fb_info *p, unsigned long addr) { int err; @@ -535,7 +535,7 @@ static int __devinit init_asiliant(struct fb_info *p, unsigned long addr) return 0; } -static int __devinit +static int asiliantfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent) { unsigned long addr, size; diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c index 426e3f2..d9f88cc 100644 --- a/drivers/video/aty/aty128fb.c +++ b/drivers/video/aty/aty128fb.c @@ -449,9 +449,9 @@ static int aty128_encode_var(struct fb_var_screeninfo *var, static int aty128_decode_var(struct fb_var_screeninfo *var, struct aty128fb_par *par); #if 0 -static void __devinit aty128_get_pllinfo(struct aty128fb_par *par, +static void aty128_get_pllinfo(struct aty128fb_par *par, void __iomem *bios); -static void __devinit __iomem *aty128_map_ROM(struct pci_dev *pdev, +static void __iomem *aty128_map_ROM(struct pci_dev *pdev, const struct aty128fb_par *par); #endif static void aty128_timings(struct aty128fb_par *par); @@ -582,7 +582,7 @@ static void aty_pll_writeupdate(const struct aty128fb_par *par) /* write to the scratch register to test r/w functionality */ -static int __devinit register_test(const struct aty128fb_par *par) +static int register_test(const struct aty128fb_par *par) { u32 val; int flag = 0; @@ -781,7 +781,7 @@ static u32 depth_to_dst(u32 depth) #ifndef __sparc__ -static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, +static void __iomem *aty128_map_ROM(const struct aty128fb_par *par, struct pci_dev *dev) { u16 dptr; @@ -868,7 +868,7 @@ static void __iomem * __devinit aty128_map_ROM(const struct aty128fb_par *par, return NULL; } -static void __devinit aty128_get_pllinfo(struct aty128fb_par *par, +static void aty128_get_pllinfo(struct aty128fb_par *par, unsigned char __iomem *bios) { unsigned int bios_hdr; @@ -891,7 +891,7 @@ static void __devinit aty128_get_pllinfo(struct aty128fb_par *par, } #ifdef CONFIG_X86 -static void __iomem * __devinit aty128_find_mem_vbios(struct aty128fb_par *par) +static void __iomem *aty128_find_mem_vbios(struct aty128fb_par *par) { /* I simplified this code as we used to miss the signatures in * a lot of case. It's now closer to XFree, we just don't check @@ -916,7 +916,7 @@ static void __iomem * __devinit aty128_find_mem_vbios(struct aty128fb_par *par) #endif /* ndef(__sparc__) */ /* fill in known card constants if pll_block is not available */ -static void __devinit aty128_timings(struct aty128fb_par *par) +static void aty128_timings(struct aty128fb_par *par) { #ifdef CONFIG_PPC_OF /* instead of a table lookup, assume OF has properly @@ -1658,7 +1658,7 @@ static int aty128fb_sync(struct fb_info *info) } #ifndef MODULE -static int __devinit aty128fb_setup(char *options) +static int aty128fb_setup(char *options) { char *this_opt; @@ -1888,7 +1888,7 @@ static void aty128_early_resume(void *data) } #endif /* CONFIG_PPC_PMAC */ -static int __devinit aty128_init(struct pci_dev *pdev, +static int aty128_init(struct pci_dev *pdev, const struct pci_device_id *ent) { struct fb_info *info = pci_get_drvdata(pdev); @@ -2039,7 +2039,7 @@ static int __devinit aty128_init(struct pci_dev *pdev, #ifdef CONFIG_PCI /* register a card ++ajoshi */ -static int __devinit aty128_probe(struct pci_dev *pdev, +static int aty128_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { unsigned long fb_addr, reg_addr; @@ -2558,7 +2558,7 @@ static int aty128_pci_resume(struct pci_dev *pdev) } -static int __devinit aty128fb_init(void) +static int aty128fb_init(void) { #ifndef MODULE char *option = NULL; diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c index bab571b..ae75dd3 100644 --- a/drivers/video/aty/atyfb_base.c +++ b/drivers/video/aty/atyfb_base.c @@ -426,7 +426,7 @@ static struct { #endif /* CONFIG_FB_ATY_CT */ }; -static int __devinit correct_chipset(struct atyfb_par *par) +static int correct_chipset(struct atyfb_par *par) { u8 rev; u16 type; @@ -588,7 +588,7 @@ static u32 atyfb_get_pixclock(struct fb_var_screeninfo *var, * Apple monitor sense */ -static int __devinit read_aty_sense(const struct atyfb_par *par) +static int read_aty_sense(const struct atyfb_par *par) { int sense, i; @@ -2273,7 +2273,7 @@ static void aty_bl_exit(struct backlight_device *bd) #endif /* CONFIG_FB_ATY_BACKLIGHT */ -static void __devinit aty_calc_mem_refresh(struct atyfb_par *par, int xclk) +static void aty_calc_mem_refresh(struct atyfb_par *par, int xclk) { const int ragepro_tbl[] = { 44, 50, 55, 66, 75, 80, 100 @@ -2307,7 +2307,7 @@ static void __devinit aty_calc_mem_refresh(struct atyfb_par *par, int xclk) static struct fb_info *fb_list = NULL; #if defined(__i386__) && defined(CONFIG_FB_ATY_GENERIC_LCD) -static int __devinit atyfb_get_timings_from_lcd(struct atyfb_par *par, +static int atyfb_get_timings_from_lcd(struct atyfb_par *par, struct fb_var_screeninfo *var) { int ret = -EINVAL; @@ -2333,7 +2333,7 @@ static int __devinit atyfb_get_timings_from_lcd(struct atyfb_par *par, } #endif /* defined(__i386__) && defined(CONFIG_FB_ATY_GENERIC_LCD) */ -static int __devinit aty_init(struct fb_info *info) +static int aty_init(struct fb_info *info) { struct atyfb_par *par = (struct atyfb_par *) info->par; const char *ramname = NULL, *xtal; @@ -2787,7 +2787,7 @@ aty_init_exit: } #if defined(CONFIG_ATARI) && !defined(MODULE) -static int __devinit store_video_par(char *video_str, unsigned char m64_num) +static int store_video_par(char *video_str, unsigned char m64_num) { char *p; unsigned long vmembase, size, guiregbase; @@ -2961,7 +2961,7 @@ static int atyfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, #ifdef __sparc__ -static int __devinit atyfb_setup_sparc(struct pci_dev *pdev, +static int atyfb_setup_sparc(struct pci_dev *pdev, struct fb_info *info, unsigned long addr) { @@ -3161,7 +3161,7 @@ static int __devinit atyfb_setup_sparc(struct pci_dev *pdev, #ifdef __i386__ #ifdef CONFIG_FB_ATY_GENERIC_LCD -static void __devinit aty_init_lcd(struct atyfb_par *par, u32 bios_base) +static void aty_init_lcd(struct atyfb_par *par, u32 bios_base) { u32 driv_inf_tab, sig; u16 lcd_ofs; @@ -3392,7 +3392,7 @@ static void __devinit aty_init_lcd(struct atyfb_par *par, u32 bios_base) } #endif /* CONFIG_FB_ATY_GENERIC_LCD */ -static int __devinit init_from_bios(struct atyfb_par *par) +static int init_from_bios(struct atyfb_par *par) { u32 bios_base, rom_addr; int ret; @@ -3445,7 +3445,7 @@ static int __devinit init_from_bios(struct atyfb_par *par) } #endif /* __i386__ */ -static int __devinit atyfb_setup_generic(struct pci_dev *pdev, +static int atyfb_setup_generic(struct pci_dev *pdev, struct fb_info *info, unsigned long addr) { @@ -3525,7 +3525,7 @@ atyfb_setup_generic_fail: #endif /* !__sparc__ */ -static int __devinit atyfb_pci_probe(struct pci_dev *pdev, +static int atyfb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { unsigned long addr, res_start, res_size; diff --git a/drivers/video/aty/mach64_ct.c b/drivers/video/aty/mach64_ct.c index 2745b85..31dd017 100644 --- a/drivers/video/aty/mach64_ct.c +++ b/drivers/video/aty/mach64_ct.c @@ -373,7 +373,7 @@ void aty_set_pll_ct(const struct fb_info *info, const union aty_pll *pll) #endif } -static void __devinit aty_get_pll_ct(const struct fb_info *info, +static void aty_get_pll_ct(const struct fb_info *info, union aty_pll *pll) { struct atyfb_par *par = (struct atyfb_par *) info->par; @@ -397,7 +397,7 @@ static void __devinit aty_get_pll_ct(const struct fb_info *info, } } -static int __devinit aty_init_pll_ct(const struct fb_info *info, +static int aty_init_pll_ct(const struct fb_info *info, union aty_pll *pll) { struct atyfb_par *par = (struct atyfb_par *) info->par; diff --git a/drivers/video/aty/mach64_cursor.c b/drivers/video/aty/mach64_cursor.c index 46f72ed..95ec042 100644 --- a/drivers/video/aty/mach64_cursor.c +++ b/drivers/video/aty/mach64_cursor.c @@ -183,7 +183,7 @@ static int atyfb_cursor(struct fb_info *info, struct fb_cursor *cursor) return 0; } -int __devinit aty_init_cursor(struct fb_info *info) +int aty_init_cursor(struct fb_info *info) { unsigned long addr; diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c index dacaa4e..7687179 100644 --- a/drivers/video/aty/radeon_base.c +++ b/drivers/video/aty/radeon_base.c @@ -293,7 +293,7 @@ static void radeon_unmap_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev) pci_unmap_rom(dev, rinfo->bios_seg); } -static int __devinit radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev) +static int radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev) { void __iomem *rom; u16 dptr; @@ -388,7 +388,7 @@ static int __devinit radeon_map_ROM(struct radeonfb_info *rinfo, struct pci_dev } #ifdef CONFIG_X86 -static int __devinit radeon_find_mem_vbios(struct radeonfb_info *rinfo) +static int radeon_find_mem_vbios(struct radeonfb_info *rinfo) { /* I simplified this code as we used to miss the signatures in * a lot of case. It's now closer to XFree, we just don't check @@ -423,7 +423,7 @@ static int __devinit radeon_find_mem_vbios(struct radeonfb_info *rinfo) * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device * tree. Hopefully, ATI OF driver is kind enough to fill these */ -static int __devinit radeon_read_xtal_OF (struct radeonfb_info *rinfo) +static int radeon_read_xtal_OF (struct radeonfb_info *rinfo) { struct device_node *dp = rinfo->of_node; const u32 *val; @@ -453,7 +453,7 @@ static int __devinit radeon_read_xtal_OF (struct radeonfb_info *rinfo) /* * Read PLL infos from chip registers */ -static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo) +static int radeon_probe_pll_params(struct radeonfb_info *rinfo) { unsigned char ppll_div_sel; unsigned Ns, Nm, M; @@ -591,7 +591,7 @@ static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo) /* * Retrieve PLL infos by different means (BIOS, Open Firmware, register probing...) */ -static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) +static void radeon_get_pllinfo(struct radeonfb_info *rinfo) { /* * In the case nothing works, these are defaults; they are mostly @@ -1868,7 +1868,7 @@ static struct fb_ops radeonfb_ops = { }; -static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo) +static int radeon_set_fbinfo (struct radeonfb_info *rinfo) { struct fb_info *info = rinfo->info; @@ -2143,7 +2143,7 @@ static struct bin_attribute edid2_attr = { }; -static int __devinit radeonfb_pci_register (struct pci_dev *pdev, +static int radeonfb_pci_register (struct pci_dev *pdev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/aty/radeon_monitor.c b/drivers/video/aty/radeon_monitor.c index 5c23eac..d6d861b 100644 --- a/drivers/video/aty/radeon_monitor.c +++ b/drivers/video/aty/radeon_monitor.c @@ -62,7 +62,7 @@ static char *radeon_get_mon_name(int type) * models with broken OF probing by hard-coding known EDIDs for some Mac * laptops internal LVDS panel. (XXX: not done yet) */ -static int __devinit radeon_parse_montype_prop(struct device_node *dp, u8 **out_EDID, +static int radeon_parse_montype_prop(struct device_node *dp, u8 **out_EDID, int hdno) { static char *propnames[] = { "DFP,EDID", "LCD,EDID", "EDID", @@ -115,7 +115,7 @@ static int __devinit radeon_parse_montype_prop(struct device_node *dp, u8 **out_ return mt; } -static int __devinit radeon_probe_OF_head(struct radeonfb_info *rinfo, int head_no, +static int radeon_probe_OF_head(struct radeonfb_info *rinfo, int head_no, u8 **out_EDID) { struct device_node *dp; @@ -163,7 +163,7 @@ static int __devinit radeon_probe_OF_head(struct radeonfb_info *rinfo, int head_ #endif /* CONFIG_PPC_OF || CONFIG_SPARC */ -static int __devinit radeon_get_panel_info_BIOS(struct radeonfb_info *rinfo) +static int radeon_get_panel_info_BIOS(struct radeonfb_info *rinfo) { unsigned long tmp, tmp0; char stmp[30]; @@ -251,7 +251,7 @@ static int __devinit radeon_get_panel_info_BIOS(struct radeonfb_info *rinfo) * doesn't quite work yet, but it's output is still useful for * debugging */ -static void __devinit radeon_parse_connector_info(struct radeonfb_info *rinfo) +static void radeon_parse_connector_info(struct radeonfb_info *rinfo) { int offset, chips, connectors, tmp, i, conn, type; @@ -297,7 +297,7 @@ static void __devinit radeon_parse_connector_info(struct radeonfb_info *rinfo) * as well and currently is only implemented for the CRT DAC, the * code for the TVDAC is commented out in XFree as "non working" */ -static int __devinit radeon_crt_is_connected(struct radeonfb_info *rinfo, int is_crt_dac) +static int radeon_crt_is_connected(struct radeonfb_info *rinfo, int is_crt_dac) { int connected = 0; @@ -369,7 +369,7 @@ static int __devinit radeon_crt_is_connected(struct radeonfb_info *rinfo, int is * Parse the "monitor_layout" string if any. This code is mostly * copied from XFree's radeon driver */ -static int __devinit radeon_parse_monitor_layout(struct radeonfb_info *rinfo, +static int radeon_parse_monitor_layout(struct radeonfb_info *rinfo, const char *monitor_layout) { char s1[5], s2[5]; @@ -433,7 +433,7 @@ static int __devinit radeon_parse_monitor_layout(struct radeonfb_info *rinfo, * try to retrieve EDID. The algorithm here comes from XFree's radeon * driver */ -void __devinit radeon_probe_screens(struct radeonfb_info *rinfo, +void radeon_probe_screens(struct radeonfb_info *rinfo, const char *monitor_layout, int ignore_edid) { #ifdef CONFIG_FB_RADEON_I2C @@ -753,7 +753,7 @@ static int is_powerblade(const char *model) * Build the modedb for head 1 (head 2 will come later), check panel infos * from either BIOS or EDID, and pick up the default mode */ -void __devinit radeon_check_modes(struct radeonfb_info *rinfo, const char *mode_option) +void radeon_check_modes(struct radeonfb_info *rinfo, const char *mode_option) { struct fb_info * info = rinfo->info; int has_default_mode = 0; diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c index fe3b6ec..b4b76dc 100644 --- a/drivers/video/au1100fb.c +++ b/drivers/video/au1100fb.c @@ -469,7 +469,7 @@ static int au1100fb_setup(struct au1100fb_device *fbdev) return 0; } -static int __devinit au1100fb_drv_probe(struct platform_device *dev) +static int au1100fb_drv_probe(struct platform_device *dev) { struct au1100fb_device *fbdev = NULL; struct resource *regs_res; diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c index 4538b07..b270a5c 100644 --- a/drivers/video/au1200fb.c +++ b/drivers/video/au1200fb.c @@ -1673,7 +1673,7 @@ out: } /* AU1200 LCD controller device driver */ -static int __devinit au1200fb_drv_probe(struct platform_device *dev) +static int au1200fb_drv_probe(struct platform_device *dev) { struct au1200fb_device *fbdev; struct au1200fb_platdata *pd; diff --git a/drivers/video/auo_k1900fb.c b/drivers/video/auo_k1900fb.c index 1581dbf..46ec47b 100644 --- a/drivers/video/auo_k1900fb.c +++ b/drivers/video/auo_k1900fb.c @@ -156,7 +156,7 @@ static bool auok1900fb_need_refresh(struct auok190xfb_par *par) return (par->update_cnt > 10); } -static int __devinit auok1900fb_probe(struct platform_device *pdev) +static int auok1900fb_probe(struct platform_device *pdev) { struct auok190x_init_data init; struct auok190x_board *board; diff --git a/drivers/video/auo_k1901fb.c b/drivers/video/auo_k1901fb.c index 94a0e01..9eb7eeb 100644 --- a/drivers/video/auo_k1901fb.c +++ b/drivers/video/auo_k1901fb.c @@ -209,7 +209,7 @@ static bool auok1901fb_need_refresh(struct auok190xfb_par *par) return (par->update_cnt > 10); } -static int __devinit auok1901fb_probe(struct platform_device *pdev) +static int auok1901fb_probe(struct platform_device *pdev) { struct auok190x_init_data init; struct auok190x_board *board; diff --git a/drivers/video/auo_k190x.c b/drivers/video/auo_k190x.c index c03ecdd..70aa5d4 100644 --- a/drivers/video/auo_k190x.c +++ b/drivers/video/auo_k190x.c @@ -773,7 +773,7 @@ EXPORT_SYMBOL_GPL(auok190x_pm); * Common probe and remove code */ -int __devinit auok190x_common_probe(struct platform_device *pdev, +int auok190x_common_probe(struct platform_device *pdev, struct auok190x_init_data *init) { struct auok190x_board *board = init->board; diff --git a/drivers/video/bf537-lq035.c b/drivers/video/bf537-lq035.c index 8081c7b..0b7c757 100644 --- a/drivers/video/bf537-lq035.c +++ b/drivers/video/bf537-lq035.c @@ -87,7 +87,7 @@ static void set_vcomm(void) pr_err("i2c_smbus_write_byte_data fail: %d\n", nr); } -static int __devinit ad5280_probe(struct i2c_client *client, +static int ad5280_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; @@ -360,7 +360,7 @@ static int config_dma(void) return 0; } -static int __devinit request_ports(void) +static int request_ports(void) { u16 tmr_req[] = TIMERS; @@ -686,7 +686,7 @@ static struct lcd_ops bfin_lcd_ops = { static struct lcd_device *lcd_dev; -static int __devinit bfin_lq035_probe(struct platform_device *pdev) +static int bfin_lq035_probe(struct platform_device *pdev) { struct backlight_properties props; dma_addr_t dma_handle; diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c index aff8520..9f72580 100644 --- a/drivers/video/bf54x-lq043fb.c +++ b/drivers/video/bf54x-lq043fb.c @@ -497,7 +497,7 @@ static irqreturn_t bfin_bf54x_irq_error(int irq, void *dev_id) return IRQ_HANDLED; } -static int __devinit bfin_bf54x_probe(struct platform_device *pdev) +static int bfin_bf54x_probe(struct platform_device *pdev) { #ifndef NO_BL_SUPPORT struct backlight_properties props; diff --git a/drivers/video/bfin-lq035q1-fb.c b/drivers/video/bfin-lq035q1-fb.c index acd438c..353fb7c 100644 --- a/drivers/video/bfin-lq035q1-fb.c +++ b/drivers/video/bfin-lq035q1-fb.c @@ -137,7 +137,7 @@ static int lq035q1_control(struct spi_device *spi, unsigned char reg, unsigned s return ret; } -static int __devinit lq035q1_spidev_probe(struct spi_device *spi) +static int lq035q1_spidev_probe(struct spi_device *spi) { int ret; struct spi_control *ctl; @@ -358,7 +358,7 @@ static inline void bfin_lq035q1_free_ports(unsigned ppi16) gpio_free(P_IDENT(P_PPI0_FS3)); } -static int __devinit bfin_lq035q1_request_ports(struct platform_device *pdev, +static int bfin_lq035q1_request_ports(struct platform_device *pdev, unsigned ppi16) { int ret; @@ -555,7 +555,7 @@ static irqreturn_t bfin_lq035q1_irq_error(int irq, void *dev_id) return IRQ_HANDLED; } -static int __devinit bfin_lq035q1_probe(struct platform_device *pdev) +static int bfin_lq035q1_probe(struct platform_device *pdev) { struct bfin_lq035q1fb_info *info; struct fb_info *fbinfo; diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c index c753abd..9456865 100644 --- a/drivers/video/bfin-t350mcqb-fb.c +++ b/drivers/video/bfin-t350mcqb-fb.c @@ -418,7 +418,7 @@ static irqreturn_t bfin_t350mcqb_irq_error(int irq, void *dev_id) return IRQ_HANDLED; } -static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev) +static int bfin_t350mcqb_probe(struct platform_device *pdev) { #ifndef NO_BL_SUPPORT struct backlight_properties props; diff --git a/drivers/video/bfin_adv7393fb.c b/drivers/video/bfin_adv7393fb.c index a32ef5a..85e9659 100644 --- a/drivers/video/bfin_adv7393fb.c +++ b/drivers/video/bfin_adv7393fb.c @@ -368,7 +368,7 @@ adv7393_write_proc(struct file *file, const char __user * buffer, return count; } -static int __devinit bfin_adv7393_fb_probe(struct i2c_client *client, +static int bfin_adv7393_fb_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; diff --git a/drivers/video/broadsheetfb.c b/drivers/video/broadsheetfb.c index 377dde3..bd15a9b 100644 --- a/drivers/video/broadsheetfb.c +++ b/drivers/video/broadsheetfb.c @@ -774,7 +774,7 @@ static DEVICE_ATTR(loadstore_waveform, S_IWUSR, NULL, broadsheet_loadstore_waveform); /* upper level functions that manipulate the display and other stuff */ -static void __devinit broadsheet_init_display(struct broadsheetfb_par *par) +static void broadsheet_init_display(struct broadsheetfb_par *par) { u16 args[5]; int xres = par->info->var.xres; @@ -834,7 +834,7 @@ static void __devinit broadsheet_init_display(struct broadsheetfb_par *par) par->board->wait_for_rdy(par); } -static void __devinit broadsheet_identify(struct broadsheetfb_par *par) +static void broadsheet_identify(struct broadsheetfb_par *par) { u16 rev, prc; struct device *dev = par->info->device; @@ -849,7 +849,7 @@ static void __devinit broadsheet_identify(struct broadsheetfb_par *par) dev_warn(dev, "Unrecognized Broadsheet Revision\n"); } -static void __devinit broadsheet_init(struct broadsheetfb_par *par) +static void broadsheet_init(struct broadsheetfb_par *par) { broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN); /* the controller needs a second */ @@ -1058,7 +1058,7 @@ static struct fb_deferred_io broadsheetfb_defio = { .deferred_io = broadsheetfb_dpy_deferred_io, }; -static int __devinit broadsheetfb_probe(struct platform_device *dev) +static int broadsheetfb_probe(struct platform_device *dev) { struct fb_info *info; struct broadsheet_board *board; diff --git a/drivers/video/bw2.c b/drivers/video/bw2.c index bc88682..21a8587 100644 --- a/drivers/video/bw2.c +++ b/drivers/video/bw2.c @@ -179,7 +179,7 @@ static int bw2_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) * Initialisation */ -static void __devinit bw2_init_fix(struct fb_info *info, int linebytes) +static void bw2_init_fix(struct fb_info *info, int linebytes) { strlcpy(info->fix.id, "bwtwo", sizeof(info->fix.id)); @@ -226,7 +226,7 @@ static u8 bw2regs_66hz[] __devinitdata = { 0x10, 0x20, 0 }; -static int __devinit bw2_do_default_mode(struct bw2_par *par, +static int bw2_do_default_mode(struct bw2_par *par, struct fb_info *info, int *linebytes) { @@ -273,7 +273,7 @@ static int __devinit bw2_do_default_mode(struct bw2_par *par, return 0; } -static int __devinit bw2_probe(struct platform_device *op) +static int bw2_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/carminefb.c b/drivers/video/carminefb.c index 27561cc..9d9eb08 100644 --- a/drivers/video/carminefb.c +++ b/drivers/video/carminefb.c @@ -537,7 +537,7 @@ static struct fb_ops carminefb_ops = { .fb_setcolreg = carmine_setcolreg, }; -static int __devinit alloc_carmine_fb(void __iomem *regs, void __iomem *smem_base, +static int alloc_carmine_fb(void __iomem *regs, void __iomem *smem_base, int smem_offset, struct device *device, struct fb_info **rinfo) { int ret; @@ -606,7 +606,7 @@ static void cleanup_fb_device(struct fb_info *info) } } -static int __devinit carminefb_probe(struct pci_dev *dev, +static int carminefb_probe(struct pci_dev *dev, const struct pci_device_id *ent) { struct carmine_hw *hw; diff --git a/drivers/video/cg14.c b/drivers/video/cg14.c index 6889f0c..e9d80c1 100644 --- a/drivers/video/cg14.c +++ b/drivers/video/cg14.c @@ -352,7 +352,7 @@ static int cg14_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) * Initialisation */ -static void __devinit cg14_init_fix(struct fb_info *info, int linebytes, +static void cg14_init_fix(struct fb_info *info, int linebytes, struct device_node *dp) { const char *name = dp->name; @@ -463,7 +463,7 @@ static void cg14_unmap_regs(struct platform_device *op, struct fb_info *info, info->screen_base, info->fix.smem_len); } -static int __devinit cg14_probe(struct platform_device *op) +static int cg14_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/cg3.c b/drivers/video/cg3.c index 0bd94d4..6102d57 100644 --- a/drivers/video/cg3.c +++ b/drivers/video/cg3.c @@ -243,7 +243,7 @@ static int cg3_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) * Initialisation */ -static void __devinit cg3_init_fix(struct fb_info *info, int linebytes, +static void cg3_init_fix(struct fb_info *info, int linebytes, struct device_node *dp) { strlcpy(info->fix.id, dp->name, sizeof(info->fix.id)); @@ -256,7 +256,7 @@ static void __devinit cg3_init_fix(struct fb_info *info, int linebytes, info->fix.accel = FB_ACCEL_SUN_CGTHREE; } -static void __devinit cg3_rdi_maybe_fixup_var(struct fb_var_screeninfo *var, +static void cg3_rdi_maybe_fixup_var(struct fb_var_screeninfo *var, struct device_node *dp) { const char *params; @@ -308,7 +308,7 @@ static u_char cg3_dacvals[] __devinitdata = { 4, 0xff, 5, 0x00, 6, 0x70, 7, 0x00, 0 }; -static int __devinit cg3_do_default_mode(struct cg3_par *par) +static int cg3_do_default_mode(struct cg3_par *par) { enum cg3_type type; u8 *p; @@ -346,7 +346,7 @@ static int __devinit cg3_do_default_mode(struct cg3_par *par) return 0; } -static int __devinit cg3_probe(struct platform_device *op) +static int cg3_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/cg6.c b/drivers/video/cg6.c index 70c7013..3204e5a 100644 --- a/drivers/video/cg6.c +++ b/drivers/video/cg6.c @@ -607,7 +607,7 @@ static int cg6_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg) * Initialisation */ -static void __devinit cg6_init_fix(struct fb_info *info, int linebytes) +static void cg6_init_fix(struct fb_info *info, int linebytes) { struct cg6_par *par = (struct cg6_par *)info->par; const char *cg6_cpu_name, *cg6_card_name; @@ -649,7 +649,7 @@ static void __devinit cg6_init_fix(struct fb_info *info, int linebytes) } /* Initialize Brooktree DAC */ -static void __devinit cg6_bt_init(struct cg6_par *par) +static void cg6_bt_init(struct cg6_par *par) { struct bt_regs __iomem *bt = par->bt; @@ -663,7 +663,7 @@ static void __devinit cg6_bt_init(struct cg6_par *par) sbus_writel(0x00 << 24, &bt->control); } -static void __devinit cg6_chip_init(struct fb_info *info) +static void cg6_chip_init(struct fb_info *info) { struct cg6_par *par = (struct cg6_par *)info->par; struct cg6_tec __iomem *tec = par->tec; @@ -737,7 +737,7 @@ static void cg6_unmap_regs(struct platform_device *op, struct fb_info *info, info->fix.smem_len); } -static int __devinit cg6_probe(struct platform_device *op) +static int cg6_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/chipsfb.c b/drivers/video/chipsfb.c index 809857d..bf131f2 100644 --- a/drivers/video/chipsfb.c +++ b/drivers/video/chipsfb.c @@ -330,7 +330,7 @@ static struct fb_var_screeninfo chipsfb_var __devinitdata = { .vsync_len = 8, }; -static void __devinit init_chips(struct fb_info *p, unsigned long addr) +static void init_chips(struct fb_info *p, unsigned long addr) { memset(p->screen_base, 0, 0x100000); @@ -347,7 +347,7 @@ static void __devinit init_chips(struct fb_info *p, unsigned long addr) chips_hw_init(); } -static int __devinit +static int chipsfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent) { struct fb_info *p; diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c index 3ce6e55..0e73200 100644 --- a/drivers/video/cirrusfb.c +++ b/drivers/video/cirrusfb.c @@ -1892,7 +1892,7 @@ static int release_io_ports; * based on the DRAM bandwidth bit and DRAM bank switching bit. This * works with 1MB, 2MB and 4MB configurations (which the Motorola boards * seem to have. */ -static unsigned int __devinit cirrusfb_get_memsize(struct fb_info *info, +static unsigned int cirrusfb_get_memsize(struct fb_info *info, u8 __iomem *regbase) { unsigned long mem; @@ -2003,7 +2003,7 @@ static struct fb_ops cirrusfb_ops = { .fb_imageblit = cirrusfb_imageblit, }; -static int __devinit cirrusfb_set_fbinfo(struct fb_info *info) +static int cirrusfb_set_fbinfo(struct fb_info *info) { struct cirrusfb_info *cinfo = info->par; struct fb_var_screeninfo *var = &info->var; @@ -2052,7 +2052,7 @@ static int __devinit cirrusfb_set_fbinfo(struct fb_info *info) return 0; } -static int __devinit cirrusfb_register(struct fb_info *info) +static int cirrusfb_register(struct fb_info *info) { struct cirrusfb_info *cinfo = info->par; int err; @@ -2109,7 +2109,7 @@ static void __devexit cirrusfb_cleanup(struct fb_info *info) } #ifdef CONFIG_PCI -static int __devinit cirrusfb_pci_register(struct pci_dev *pdev, +static int cirrusfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) { struct cirrusfb_info *cinfo; @@ -2237,7 +2237,7 @@ static struct pci_driver cirrusfb_pci_driver = { #endif /* CONFIG_PCI */ #ifdef CONFIG_ZORRO -static int __devinit cirrusfb_zorro_register(struct zorro_dev *z, +static int cirrusfb_zorro_register(struct zorro_dev *z, const struct zorro_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/cobalt_lcdfb.c b/drivers/video/cobalt_lcdfb.c index 9f2dc21..9e1e5d2 100644 --- a/drivers/video/cobalt_lcdfb.c +++ b/drivers/video/cobalt_lcdfb.c @@ -331,7 +331,7 @@ static struct fb_ops cobalt_lcd_fbops = { .fb_cursor = cobalt_lcdfb_cursor, }; -static int __devinit cobalt_lcdfb_probe(struct platform_device *dev) +static int cobalt_lcdfb_probe(struct platform_device *dev) { struct fb_info *info; struct resource *res; diff --git a/drivers/video/console/sticore.c b/drivers/video/console/sticore.c index 39571f9..0fbc03c 100644 --- a/drivers/video/console/sticore.c +++ b/drivers/video/console/sticore.c @@ -238,7 +238,7 @@ static void sti_flush(unsigned long start, unsigned long end) flush_icache_range(start, end); } -static void __devinit sti_rom_copy(unsigned long base, unsigned long count, +static void sti_rom_copy(unsigned long base, unsigned long count, void *dest) { unsigned long dest_start = (unsigned long) dest; @@ -266,7 +266,7 @@ static void __devinit sti_rom_copy(unsigned long base, unsigned long count, static char default_sti_path[21] __read_mostly; #ifndef MODULE -static int __devinit sti_setup(char *str) +static int sti_setup(char *str) { if (str) strlcpy (default_sti_path, str, sizeof (default_sti_path)); @@ -290,7 +290,7 @@ static int __devinitdata font_index[MAX_STI_ROMS], font_height[MAX_STI_ROMS], font_width[MAX_STI_ROMS]; #ifndef MODULE -static int __devinit sti_font_setup(char *str) +static int sti_font_setup(char *str) { char *x; int i = 0; @@ -343,7 +343,7 @@ __setup("sti_font=", sti_font_setup); -static void __devinit +static void sti_dump_globcfg(struct sti_glob_cfg *glob_cfg, unsigned int sti_mem_request) { struct sti_glob_cfg_ext *cfg; @@ -383,7 +383,7 @@ sti_dump_globcfg(struct sti_glob_cfg *glob_cfg, unsigned int sti_mem_request) cfg->sti_mem_addr, sti_mem_request)); } -static void __devinit +static void sti_dump_outptr(struct sti_struct *sti) { DPRINTK((KERN_INFO @@ -397,7 +397,7 @@ sti_dump_outptr(struct sti_struct *sti) sti->outptr.attributes)); } -static int __devinit +static int sti_init_glob_cfg(struct sti_struct *sti, unsigned long rom_address, unsigned long hpa) { @@ -479,7 +479,7 @@ sti_init_glob_cfg(struct sti_struct *sti, } #ifdef CONFIG_FB -static struct sti_cooked_font __devinit +static struct sti_cooked_font *sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name) { const struct font_desc *fbfont; @@ -535,14 +535,14 @@ static struct sti_cooked_font __devinit return cooked_font; } #else -static struct sti_cooked_font __devinit +static struct sti_cooked_font *sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name) { return NULL; } #endif -static struct sti_cooked_font __devinit +static struct sti_cooked_font *sti_select_font(struct sti_cooked_rom *rom, int (*search_font_fnc)(struct sti_cooked_rom *, int, int)) { @@ -569,7 +569,7 @@ static struct sti_cooked_font __devinit } -static void __devinit +static void sti_dump_rom(struct sti_rom *rom) { printk(KERN_INFO " id %04x-%04x, conforms to spec rev. %d.%02x\n", @@ -587,7 +587,7 @@ sti_dump_rom(struct sti_rom *rom) } -static int __devinit +static int sti_cook_fonts(struct sti_cooked_rom *cooked_rom, struct sti_rom *raw_rom) { @@ -622,7 +622,7 @@ sti_cook_fonts(struct sti_cooked_rom *cooked_rom, } -static int __devinit +static int sti_search_font(struct sti_cooked_rom *rom, int height, int width) { struct sti_cooked_font *font; @@ -639,8 +639,7 @@ sti_search_font(struct sti_cooked_rom *rom, int height, int width) #define BMODE_RELOCATE(offset) offset = (offset) / 4; #define BMODE_LAST_ADDR_OFFS 0x50 -static void * __devinit -sti_bmode_font_raw(struct sti_cooked_font *f) +static void *sti_bmode_font_raw(struct sti_cooked_font *f) { unsigned char *n, *p, *q; int size = f->raw->bytes_per_char*256+sizeof(struct sti_rom_font); @@ -657,7 +656,7 @@ sti_bmode_font_raw(struct sti_cooked_font *f) return n + 3; } -static void __devinit +static void sti_bmode_rom_copy(unsigned long base, unsigned long count, void *dest) { unsigned long dest_start = (unsigned long) dest; @@ -672,8 +671,7 @@ sti_bmode_rom_copy(unsigned long base, unsigned long count, void *dest) sti_flush(dest_start, (unsigned long)dest); } -static struct sti_rom * __devinit -sti_get_bmode_rom (unsigned long address) +static struct sti_rom *sti_get_bmode_rom (unsigned long address) { struct sti_rom *raw; u32 size; @@ -708,7 +706,7 @@ sti_get_bmode_rom (unsigned long address) return raw; } -static struct sti_rom __devinit *sti_get_wmode_rom(unsigned long address) +static struct sti_rom *sti_get_wmode_rom(unsigned long address) { struct sti_rom *raw; unsigned long size; @@ -723,7 +721,7 @@ static struct sti_rom __devinit *sti_get_wmode_rom(unsigned long address) return raw; } -static int __devinit sti_read_rom(int wordmode, struct sti_struct *sti, +static int sti_read_rom(int wordmode, struct sti_struct *sti, unsigned long address) { struct sti_cooked_rom *cooked; @@ -806,8 +804,7 @@ out_err: return 0; } -static struct sti_struct * __devinit -sti_try_rom_generic(unsigned long address, unsigned long hpa, struct pci_dev *pd) +static struct sti_struct *sti_try_rom_generic(unsigned long address, unsigned long hpa, struct pci_dev *pd) { struct sti_struct *sti; int ok; @@ -921,7 +918,7 @@ out_err: return NULL; } -static void __devinit sticore_check_for_default_sti(struct sti_struct *sti, char *path) +static void sticore_check_for_default_sti(struct sti_struct *sti, char *path) { if (strcmp (path, default_sti_path) == 0) default_sti = sti; @@ -932,7 +929,7 @@ static void __devinit sticore_check_for_default_sti(struct sti_struct *sti, char * in the additional address field addr[1] while on * older Systems the PDC stores it in page0->proc_sti */ -static int __devinit sticore_pa_init(struct parisc_device *dev) +static int sticore_pa_init(struct parisc_device *dev) { char pa_path[21]; struct sti_struct *sti = NULL; @@ -953,7 +950,7 @@ static int __devinit sticore_pa_init(struct parisc_device *dev) } -static int __devinit sticore_pci_init(struct pci_dev *pd, +static int sticore_pci_init(struct pci_dev *pd, const struct pci_device_id *ent) { #ifdef CONFIG_PCI @@ -1043,7 +1040,7 @@ static struct parisc_driver pa_sti_driver = { static int sticore_initialized __read_mostly; -static void __devinit sti_init_roms(void) +static void sti_init_roms(void) { if (sticore_initialized) return; diff --git a/drivers/video/cyber2000fb.c b/drivers/video/cyber2000fb.c index 9b75b29..78bb6be 100644 --- a/drivers/video/cyber2000fb.c +++ b/drivers/video/cyber2000fb.c @@ -1230,7 +1230,7 @@ static int cyber2000fb_ddc_getsda(void *data) return retval; } -static int __devinit cyber2000fb_setup_ddc_bus(struct cfb_info *cfb) +static int cyber2000fb_setup_ddc_bus(struct cfb_info *cfb) { strlcpy(cfb->ddc_adapter.name, cfb->fb.fix.id, sizeof(cfb->ddc_adapter.name)); @@ -1305,7 +1305,7 @@ static int cyber2000fb_i2c_getscl(void *data) return ret; } -static int __devinit cyber2000fb_i2c_register(struct cfb_info *cfb) +static int cyber2000fb_i2c_register(struct cfb_info *cfb) { strlcpy(cfb->i2c_adapter.name, cfb->fb.fix.id, sizeof(cfb->i2c_adapter.name)); @@ -1404,7 +1404,7 @@ static void cyberpro_init_hw(struct cfb_info *cfb) } } -static struct cfb_info __devinit *cyberpro_alloc_fb_info(unsigned int id, +static struct cfb_info *cyberpro_alloc_fb_info(unsigned int id, char *name) { struct cfb_info *cfb; @@ -1524,7 +1524,7 @@ static int cyber2000fb_setup(char *options) * - memory mapped access to the registers * - initialised mem_ctl1 and mem_ctl2 appropriately. */ -static int __devinit cyberpro_common_probe(struct cfb_info *cfb) +static int cyberpro_common_probe(struct cfb_info *cfb) { u_long smem_size; u_int h_sync, v_sync; @@ -1646,7 +1646,7 @@ static void cyberpro_common_resume(struct cfb_info *cfb) #include -static int __devinit cyberpro_vl_probe(void) +static int cyberpro_vl_probe(void) { struct cfb_info *cfb; int err = -ENOMEM; @@ -1780,7 +1780,7 @@ static int cyberpro_pci_enable_mmio(struct cfb_info *cfb) return 0; } -static int __devinit +static int cyberpro_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct cfb_info *cfb; diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c index b3aaf3b..1face18 100644 --- a/drivers/video/da8xx-fb.c +++ b/drivers/video/da8xx-fb.c @@ -1230,7 +1230,7 @@ static unsigned int da8xxfb_pixel_clk_period(struct da8xx_fb_par *par) return pix_clk_period_picosec; } -static int __devinit fb_probe(struct platform_device *device) +static int fb_probe(struct platform_device *device) { struct da8xx_lcdc_platform_data *fb_pdata = device->dev.platform_data; diff --git a/drivers/video/dnfb.c b/drivers/video/dnfb.c index 49e3dda..182b199 100644 --- a/drivers/video/dnfb.c +++ b/drivers/video/dnfb.c @@ -224,7 +224,7 @@ void dnfb_copyarea(struct fb_info *info, const struct fb_copyarea *area) * Initialization */ -static int __devinit dnfb_probe(struct platform_device *dev) +static int dnfb_probe(struct platform_device *dev) { struct fb_info *info; int err = 0; diff --git a/drivers/video/ep93xx-fb.c b/drivers/video/ep93xx-fb.c index 2f08122..ef4ca55 100644 --- a/drivers/video/ep93xx-fb.c +++ b/drivers/video/ep93xx-fb.c @@ -484,7 +484,7 @@ static void ep93xxfb_dealloc_videomem(struct fb_info *info) info->screen_base, info->fix.smem_start); } -static int __devinit ep93xxfb_probe(struct platform_device *pdev) +static int ep93xxfb_probe(struct platform_device *pdev) { struct ep93xxfb_mach_info *mach_info = pdev->dev.platform_data; struct fb_info *info; @@ -627,7 +627,7 @@ static struct platform_driver ep93xxfb_driver = { }, }; -static int __devinit ep93xxfb_init(void) +static int ep93xxfb_init(void) { return platform_driver_register(&ep93xxfb_driver); } diff --git a/drivers/video/exynos/exynos_dp_core.c b/drivers/video/exynos/exynos_dp_core.c index 07c0453..47f0448 100644 --- a/drivers/video/exynos/exynos_dp_core.c +++ b/drivers/video/exynos/exynos_dp_core.c @@ -856,7 +856,7 @@ static irqreturn_t exynos_dp_irq_handler(int irq, void *arg) return IRQ_HANDLED; } -static int __devinit exynos_dp_probe(struct platform_device *pdev) +static int exynos_dp_probe(struct platform_device *pdev) { struct resource *res; struct exynos_dp_device *dp; diff --git a/drivers/video/ffb.c b/drivers/video/ffb.c index d78dc9a..46aee0e 100644 --- a/drivers/video/ffb.c +++ b/drivers/video/ffb.c @@ -893,7 +893,7 @@ static void ffb_init_fix(struct fb_info *info) info->fix.accel = FB_ACCEL_SUN_CREATOR; } -static int __devinit ffb_probe(struct platform_device *op) +static int ffb_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct ffb_fbc __iomem *fbc; diff --git a/drivers/video/fm2fb.c b/drivers/video/fm2fb.c index d0533b7..a64c3ef 100644 --- a/drivers/video/fm2fb.c +++ b/drivers/video/fm2fb.c @@ -211,7 +211,7 @@ static int fm2fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, * Initialisation */ -static int __devinit fm2fb_probe(struct zorro_dev *z, +static int fm2fb_probe(struct zorro_dev *z, const struct zorro_device_id *id); static struct zorro_device_id fm2fb_devices[] __devinitdata = { @@ -227,7 +227,7 @@ static struct zorro_driver fm2fb_driver = { .probe = fm2fb_probe, }; -static int __devinit fm2fb_probe(struct zorro_dev *z, +static int fm2fb_probe(struct zorro_dev *z, const struct zorro_device_id *id) { struct fb_info *info; diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c index ede9e55..6bdf805 100644 --- a/drivers/video/fsl-diu-fb.c +++ b/drivers/video/fsl-diu-fb.c @@ -1244,7 +1244,7 @@ static struct fb_ops fsl_diu_ops = { .fb_release = fsl_diu_release, }; -static int __devinit install_fb(struct fb_info *info) +static int install_fb(struct fb_info *info) { int rc; struct mfb_info *mfbi = info->par; @@ -1491,7 +1491,7 @@ static ssize_t show_monitor(struct device *device, return 0; } -static int __devinit fsl_diu_probe(struct platform_device *pdev) +static int fsl_diu_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct mfb_info *mfbi; diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c index f19571b..2971511 100644 --- a/drivers/video/gbefb.c +++ b/drivers/video/gbefb.c @@ -1098,7 +1098,7 @@ static void gbefb_create_sysfs(struct device *dev) * Initialization */ -static int __devinit gbefb_setup(char *options) +static int gbefb_setup(char *options) { char *this_opt; @@ -1129,7 +1129,7 @@ static int __devinit gbefb_setup(char *options) return 0; } -static int __devinit gbefb_probe(struct platform_device *p_dev) +static int gbefb_probe(struct platform_device *p_dev) { int i, ret = 0; struct fb_info *info; diff --git a/drivers/video/geode/gx1fb_core.c b/drivers/video/geode/gx1fb_core.c index 094c352..4bdd47f 100644 --- a/drivers/video/geode/gx1fb_core.c +++ b/drivers/video/geode/gx1fb_core.c @@ -195,7 +195,7 @@ static int gx1fb_blank(int blank_mode, struct fb_info *info) return par->vid_ops->blank_display(info, blank_mode); } -static int __devinit gx1fb_map_video_memory(struct fb_info *info, struct pci_dev *dev) +static int gx1fb_map_video_memory(struct fb_info *info, struct pci_dev *dev) { struct geodefb_par *par = info->par; unsigned gx_base; @@ -268,7 +268,7 @@ static struct fb_ops gx1fb_ops = { .fb_imageblit = cfb_imageblit, }; -static struct fb_info * __devinit gx1fb_init_fbinfo(struct device *dev) +static struct fb_info *gx1fb_init_fbinfo(struct device *dev) { struct geodefb_par *par; struct fb_info *info; @@ -318,7 +318,7 @@ static struct fb_info * __devinit gx1fb_init_fbinfo(struct device *dev) return info; } -static int __devinit gx1fb_probe(struct pci_dev *pdev, const struct pci_device_id *id) +static int gx1fb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct geodefb_par *par; struct fb_info *info; diff --git a/drivers/video/geode/gxfb_core.c b/drivers/video/geode/gxfb_core.c index b4f19db..d3ad1a0 100644 --- a/drivers/video/geode/gxfb_core.c +++ b/drivers/video/geode/gxfb_core.c @@ -117,7 +117,7 @@ static struct fb_videomode gx_dcon_modedb[] __devinitdata = { FB_VMODE_NONINTERLACED, 0 } }; -static void __devinit get_modedb(struct fb_videomode **modedb, +static void get_modedb(struct fb_videomode **modedb, unsigned int *size) { if (olpc_has_dcon()) { @@ -130,7 +130,7 @@ static void __devinit get_modedb(struct fb_videomode **modedb, } #else -static void __devinit get_modedb(struct fb_videomode **modedb, +static void get_modedb(struct fb_videomode **modedb, unsigned int *size) { *modedb = (struct fb_videomode *) gx_modedb; @@ -228,7 +228,7 @@ static int gxfb_blank(int blank_mode, struct fb_info *info) return gx_blank_display(info, blank_mode); } -static int __devinit gxfb_map_video_memory(struct fb_info *info, +static int gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev) { struct gxfb_par *par = info->par; @@ -293,7 +293,7 @@ static struct fb_ops gxfb_ops = { .fb_imageblit = cfb_imageblit, }; -static struct fb_info *__devinit gxfb_init_fbinfo(struct device *dev) +static struct fb_info *gxfb_init_fbinfo(struct device *dev) { struct gxfb_par *par; struct fb_info *info; @@ -374,7 +374,7 @@ static int gxfb_resume(struct pci_dev *pdev) } #endif -static int __devinit gxfb_probe(struct pci_dev *pdev, +static int gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct gxfb_par *par; diff --git a/drivers/video/geode/lxfb_core.c b/drivers/video/geode/lxfb_core.c index 416851c..7428366 100644 --- a/drivers/video/geode/lxfb_core.c +++ b/drivers/video/geode/lxfb_core.c @@ -226,7 +226,7 @@ static struct fb_videomode olpc_dcon_modedb[] __devinitdata = { FB_VMODE_NONINTERLACED, 0 } }; -static void __devinit get_modedb(struct fb_videomode **modedb, +static void get_modedb(struct fb_videomode **modedb, unsigned int *size) { if (olpc_has_dcon()) { @@ -239,7 +239,7 @@ static void __devinit get_modedb(struct fb_videomode **modedb, } #else -static void __devinit get_modedb(struct fb_videomode **modedb, +static void get_modedb(struct fb_videomode **modedb, unsigned int *size) { *modedb = (struct fb_videomode *) geode_modedb; @@ -336,7 +336,7 @@ static int lxfb_blank(int blank_mode, struct fb_info *info) } -static int __devinit lxfb_map_video_memory(struct fb_info *info, +static int lxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev) { struct lxfb_par *par = info->par; @@ -414,7 +414,7 @@ static struct fb_ops lxfb_ops = { .fb_imageblit = cfb_imageblit, }; -static struct fb_info * __devinit lxfb_init_fbinfo(struct device *dev) +static struct fb_info *lxfb_init_fbinfo(struct device *dev) { struct lxfb_par *par; struct fb_info *info; @@ -498,7 +498,7 @@ static int lxfb_resume(struct pci_dev *pdev) #define lxfb_resume NULL #endif -static int __devinit lxfb_probe(struct pci_dev *pdev, +static int lxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct lxfb_par *par; diff --git a/drivers/video/grvga.c b/drivers/video/grvga.c index 3ddf206..bf7ea95 100644 --- a/drivers/video/grvga.c +++ b/drivers/video/grvga.c @@ -267,7 +267,7 @@ static struct fb_ops grvga_ops = { .fb_imageblit = cfb_imageblit }; -static int __devinit grvga_parse_custom(char *options, +static int grvga_parse_custom(char *options, struct fb_var_screeninfo *screendata) { char *this_opt; @@ -329,7 +329,7 @@ static int __devinit grvga_parse_custom(char *options, return 0; } -static int __devinit grvga_probe(struct platform_device *dev) +static int grvga_probe(struct platform_device *dev) { struct fb_info *info; int retval = -ENOMEM; diff --git a/drivers/video/gxt4500.c b/drivers/video/gxt4500.c index d4f103e..c0130a4 100644 --- a/drivers/video/gxt4500.c +++ b/drivers/video/gxt4500.c @@ -610,7 +610,7 @@ static struct fb_ops gxt4500_ops = { }; /* PCI functions */ -static int __devinit gxt4500_probe(struct pci_dev *pdev, +static int gxt4500_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { int err; @@ -761,7 +761,7 @@ static struct pci_driver gxt4500_driver = { .remove = gxt4500_remove, }; -static int __devinit gxt4500_init(void) +static int gxt4500_init(void) { #ifndef MODULE if (fb_get_options("gxt4500", &mode_option)) diff --git a/drivers/video/hecubafb.c b/drivers/video/hecubafb.c index b28a520..f8746a3f 100644 --- a/drivers/video/hecubafb.c +++ b/drivers/video/hecubafb.c @@ -211,7 +211,7 @@ static struct fb_deferred_io hecubafb_defio = { .deferred_io = hecubafb_dpy_deferred_io, }; -static int __devinit hecubafb_probe(struct platform_device *dev) +static int hecubafb_probe(struct platform_device *dev) { struct fb_info *info; struct hecuba_board *board; diff --git a/drivers/video/hgafb.c b/drivers/video/hgafb.c index f8a7036..20bbeb4 100644 --- a/drivers/video/hgafb.c +++ b/drivers/video/hgafb.c @@ -276,7 +276,7 @@ static void hga_blank(int blank_mode) spin_unlock_irqrestore(&hga_reg_lock, flags); } -static int __devinit hga_card_detect(void) +static int hga_card_detect(void) { int count = 0; void __iomem *p, *q; @@ -546,7 +546,7 @@ static struct fb_ops hgafb_ops = { * Initialization */ -static int __devinit hgafb_probe(struct platform_device *pdev) +static int hgafb_probe(struct platform_device *pdev) { struct fb_info *info; diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c index 4ceb978..20d8a56 100644 --- a/drivers/video/hitfb.c +++ b/drivers/video/hitfb.c @@ -324,7 +324,7 @@ static struct fb_ops hitfb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit hitfb_probe(struct platform_device *dev) +static int hitfb_probe(struct platform_device *dev) { unsigned short lcdclor, ldr3, ldvndr; struct fb_info *info; diff --git a/drivers/video/hpfb.c b/drivers/video/hpfb.c index 1f15523..aa2abe8 100644 --- a/drivers/video/hpfb.c +++ b/drivers/video/hpfb.c @@ -206,7 +206,7 @@ static struct fb_ops hpfb_ops = { #define HPFB_FBOMSB 0x5d /* Frame buffer offset */ #define HPFB_FBOLSB 0x5f -static int __devinit hpfb_init_one(unsigned long phys_base, +static int hpfb_init_one(unsigned long phys_base, unsigned long virt_base) { unsigned long fboff, fb_width, fb_height, fb_start; @@ -327,7 +327,7 @@ unmap_screen_base: /* * Initialise the framebuffer */ -static int __devinit hpfb_dio_probe(struct dio_dev * d, const struct dio_device_id * ent) +static int hpfb_dio_probe(struct dio_dev * d, const struct dio_device_id * ent) { unsigned long paddr, vaddr; diff --git a/drivers/video/i740fb.c b/drivers/video/i740fb.c index 1d3c8ee..1109617 100644 --- a/drivers/video/i740fb.c +++ b/drivers/video/i740fb.c @@ -163,7 +163,7 @@ static int i740fb_ddc_getsda(void *data) return !!(i740inreg(par, XRX, REG_DDC_STATE) & DDC_SDA); } -static int __devinit i740fb_setup_ddc_bus(struct fb_info *info) +static int i740fb_setup_ddc_bus(struct fb_info *info) { struct i740fb_par *par = info->par; @@ -1007,7 +1007,7 @@ static struct fb_ops i740fb_ops = { /* ------------------------------------------------------------------------- */ -static int __devinit i740fb_probe(struct pci_dev *dev, +static int i740fb_probe(struct pci_dev *dev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c index 5c06781..8c50b96 100644 --- a/drivers/video/i810/i810_main.c +++ b/drivers/video/i810/i810_main.c @@ -78,7 +78,7 @@ static u32 v_offset_default __devinitdata; /* For 32 MiB Aper size, 8 should be static u32 voffset __devinitdata; static int i810fb_cursor(struct fb_info *info, struct fb_cursor *cursor); -static int __devinit i810fb_init_pci (struct pci_dev *dev, +static int i810fb_init_pci (struct pci_dev *dev, const struct pci_device_id *entry); static void __exit i810fb_remove_pci(struct pci_dev *dev); static int i810fb_resume(struct pci_dev *dev); @@ -1628,7 +1628,7 @@ fail: * AGP resource allocation * ***********************************************************************/ -static void __devinit i810_fix_pointers(struct i810fb_par *par) +static void i810_fix_pointers(struct i810fb_par *par) { par->fb.physical = par->aperture.physical+(par->fb.offset << 12); par->fb.virtual = par->aperture.virtual+(par->fb.offset << 12); @@ -1640,7 +1640,7 @@ static void __devinit i810_fix_pointers(struct i810fb_par *par) (par->cursor_heap.offset << 12); } -static void __devinit i810_fix_offsets(struct i810fb_par *par) +static void i810_fix_offsets(struct i810fb_par *par) { if (vram + 1 > par->aperture.size >> 20) vram = (par->aperture.size >> 20) - 1; @@ -1660,7 +1660,7 @@ static void __devinit i810_fix_offsets(struct i810fb_par *par) par->cursor_heap.size = 4096; } -static int __devinit i810_alloc_agp_mem(struct fb_info *info) +static int i810_alloc_agp_mem(struct fb_info *info) { struct i810fb_par *par = info->par; int size; @@ -1723,7 +1723,7 @@ static int __devinit i810_alloc_agp_mem(struct fb_info *info) * Sets the user monitor's horizontal and vertical * frequency limits */ -static void __devinit i810_init_monspecs(struct fb_info *info) +static void i810_init_monspecs(struct fb_info *info) { if (!hsync1) hsync1 = HFMIN; @@ -1755,7 +1755,7 @@ static void __devinit i810_init_monspecs(struct fb_info *info) * @par: pointer to i810fb_par structure * @info: pointer to current fb_info structure */ -static void __devinit i810_init_defaults(struct i810fb_par *par, +static void i810_init_defaults(struct i810fb_par *par, struct fb_info *info) { mutex_init(&par->open_lock); @@ -1812,7 +1812,7 @@ static void __devinit i810_init_defaults(struct i810fb_par *par, * i810_init_device - initialize device * @par: pointer to i810fb_par structure */ -static void __devinit i810_init_device(struct i810fb_par *par) +static void i810_init_device(struct i810fb_par *par) { u8 reg; u8 __iomem *mmio = par->mmio_start_virtual; @@ -1833,7 +1833,7 @@ static void __devinit i810_init_device(struct i810fb_par *par) } -static int __devinit +static int i810_allocate_pci_resource(struct i810fb_par *par, const struct pci_device_id *entry) { @@ -1892,7 +1892,7 @@ i810_allocate_pci_resource(struct i810fb_par *par, return 0; } -static void __devinit i810fb_find_init_mode(struct fb_info *info) +static void i810fb_find_init_mode(struct fb_info *info) { struct fb_videomode mode; struct fb_var_screeninfo var; @@ -1956,7 +1956,7 @@ static void __devinit i810fb_find_init_mode(struct fb_info *info) } #ifndef MODULE -static int __devinit i810fb_setup(char *options) +static int i810fb_setup(char *options) { char *this_opt, *suffix = NULL; @@ -2007,7 +2007,7 @@ static int __devinit i810fb_setup(char *options) } #endif -static int __devinit i810fb_init_pci (struct pci_dev *dev, +static int i810fb_init_pci (struct pci_dev *dev, const struct pci_device_id *entry) { struct fb_info *info; @@ -2136,7 +2136,7 @@ static void __exit i810fb_remove_pci(struct pci_dev *dev) } #ifndef MODULE -static int __devinit i810fb_init(void) +static int i810fb_init(void) { char *option = NULL; @@ -2154,7 +2154,7 @@ static int __devinit i810fb_init(void) #ifdef MODULE -static int __devinit i810fb_init(void) +static int i810fb_init(void) { hsync1 *= 1000; hsync2 *= 1000; diff --git a/drivers/video/i810/i810_main.h b/drivers/video/i810/i810_main.h index 51d4f3d4..a25afaa 100644 --- a/drivers/video/i810/i810_main.h +++ b/drivers/video/i810/i810_main.h @@ -64,7 +64,7 @@ static inline void flush_cache(void) #include -static inline void __devinit set_mtrr(struct i810fb_par *par) +static inline void set_mtrr(struct i810fb_par *par) { par->mtrr_reg = mtrr_add((u32) par->aperture.physical, par->aperture.size, MTRR_TYPE_WRCOMB, 1); diff --git a/drivers/video/imsttfb.c b/drivers/video/imsttfb.c index 1bb3934..a7e8477 100644 --- a/drivers/video/imsttfb.c +++ b/drivers/video/imsttfb.c @@ -1349,7 +1349,7 @@ static struct fb_ops imsttfb_ops = { .fb_ioctl = imsttfb_ioctl, }; -static void __devinit +static void init_imstt(struct fb_info *info) { struct imstt_par *par = info->par; @@ -1466,7 +1466,7 @@ init_imstt(struct fb_info *info) info->node, info->fix.id, info->fix.smem_len >> 20, tmp); } -static int __devinit +static int imsttfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { unsigned long addr, size; diff --git a/drivers/video/intelfb/intelfbdrv.c b/drivers/video/intelfb/intelfbdrv.c index 971b5d0..860820c 100644 --- a/drivers/video/intelfb/intelfbdrv.c +++ b/drivers/video/intelfb/intelfbdrv.c @@ -132,7 +132,7 @@ #include "intelfbhw.h" #include "../edid.h" -static void __devinit get_initial_mode(struct intelfb_info *dinfo); +static void get_initial_mode(struct intelfb_info *dinfo); static void update_dinfo(struct intelfb_info *dinfo, struct fb_var_screeninfo *var); static int intelfb_open(struct fb_info *info, int user); @@ -162,10 +162,10 @@ static int intelfb_sync(struct fb_info *info); static int intelfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg); -static int __devinit intelfb_pci_register(struct pci_dev *pdev, +static int intelfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent); static void __devexit intelfb_pci_unregister(struct pci_dev *pdev); -static int __devinit intelfb_set_fbinfo(struct intelfb_info *dinfo); +static int intelfb_set_fbinfo(struct intelfb_info *dinfo); /* * Limiting the class to PCI_CLASS_DISPLAY_VGA prevents function 1 of the @@ -415,7 +415,7 @@ module_exit(intelfb_exit); ***************************************************************/ #ifdef CONFIG_MTRR -static inline void __devinit set_mtrr(struct intelfb_info *dinfo) +static inline void set_mtrr(struct intelfb_info *dinfo) { dinfo->mtrr_reg = mtrr_add(dinfo->aperture.physical, dinfo->aperture.size, MTRR_TYPE_WRCOMB, 1); @@ -497,7 +497,7 @@ static void cleanup(struct intelfb_info *dinfo) } while (0) -static int __devinit intelfb_pci_register(struct pci_dev *pdev, +static int intelfb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) { struct fb_info *info; @@ -970,7 +970,7 @@ static __inline__ int var_to_refresh(const struct fb_var_screeninfo *var) * Various intialisation functions * ***************************************************************/ -static void __devinit get_initial_mode(struct intelfb_info *dinfo) +static void get_initial_mode(struct intelfb_info *dinfo) { struct fb_var_screeninfo *var; int xtot, ytot; @@ -1037,7 +1037,7 @@ static void __devinit get_initial_mode(struct intelfb_info *dinfo) } } -static int __devinit intelfb_init_var(struct intelfb_info *dinfo) +static int intelfb_init_var(struct intelfb_info *dinfo) { struct fb_var_screeninfo *var; int msrc = 0; @@ -1118,7 +1118,7 @@ static int __devinit intelfb_init_var(struct intelfb_info *dinfo) return 0; } -static int __devinit intelfb_set_fbinfo(struct intelfb_info *dinfo) +static int intelfb_set_fbinfo(struct intelfb_info *dinfo) { struct fb_info *info = dinfo->info; diff --git a/drivers/video/jz4740_fb.c b/drivers/video/jz4740_fb.c index cb867b6..f5c645a 100644 --- a/drivers/video/jz4740_fb.c +++ b/drivers/video/jz4740_fb.c @@ -619,7 +619,7 @@ static struct fb_ops jzfb_ops = { .fb_setcolreg = jzfb_setcolreg, }; -static int __devinit jzfb_probe(struct platform_device *pdev) +static int jzfb_probe(struct platform_device *pdev) { int ret; struct jzfb *jzfb; diff --git a/drivers/video/kyro/fbdev.c b/drivers/video/kyro/fbdev.c index 2293f6a..2c498d8 100644 --- a/drivers/video/kyro/fbdev.c +++ b/drivers/video/kyro/fbdev.c @@ -667,7 +667,7 @@ static struct fb_ops kyrofb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit kyrofb_probe(struct pci_dev *pdev, +static int kyrofb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/leo.c b/drivers/video/leo.c index 52a8678..8c64c79 100644 --- a/drivers/video/leo.c +++ b/drivers/video/leo.c @@ -547,7 +547,7 @@ static void leo_unmap_regs(struct platform_device *op, struct fb_info *info, of_iounmap(&op->resource[0], info->screen_base, 0x800000); } -static int __devinit leo_probe(struct platform_device *op) +static int leo_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/mb862xx/mb862xxfbdrv.c b/drivers/video/mb862xx/mb862xxfbdrv.c index 3025cbb..9f88328 100644 --- a/drivers/video/mb862xx/mb862xxfbdrv.c +++ b/drivers/video/mb862xx/mb862xxfbdrv.c @@ -668,7 +668,7 @@ static int mb862xx_gdc_init(struct mb862xxfb_par *par) return 0; } -static int __devinit of_platform_mb862xx_probe(struct platform_device *ofdev) +static int of_platform_mb862xx_probe(struct platform_device *ofdev) { struct device_node *np = ofdev->dev.of_node; struct device *dev = &ofdev->dev; @@ -995,7 +995,7 @@ static struct pci_device_id mb862xx_pci_tbl[] __devinitdata = { MODULE_DEVICE_TABLE(pci, mb862xx_pci_tbl); -static int __devinit mb862xx_pci_probe(struct pci_dev *pdev, +static int mb862xx_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct mb862xxfb_par *par; @@ -1178,7 +1178,7 @@ static struct pci_driver mb862xxfb_pci_driver = { }; #endif -static int __devinit mb862xxfb_init(void) +static int mb862xxfb_init(void) { int ret = -ENODEV; diff --git a/drivers/video/mbx/mbxdebugfs.c b/drivers/video/mbx/mbxdebugfs.c index 12dec76..474f94f 100644 --- a/drivers/video/mbx/mbxdebugfs.c +++ b/drivers/video/mbx/mbxdebugfs.c @@ -213,7 +213,7 @@ static const struct file_operations misc_fops = { .llseek = default_llseek, }; -static void __devinit mbxfb_debugfs_init(struct fb_info *fbi) +static void mbxfb_debugfs_init(struct fb_info *fbi) { struct mbxfb_info *mfbi = fbi->par; struct mbxfb_debugfs_data *dbg; diff --git a/drivers/video/mbx/mbxfb.c b/drivers/video/mbx/mbxfb.c index a8ba922..91bf913 100644 --- a/drivers/video/mbx/mbxfb.c +++ b/drivers/video/mbx/mbxfb.c @@ -687,7 +687,7 @@ static struct fb_ops mbxfb_ops = { Enable external SDRAM controller. Assume that all clocks are active by now. */ -static void __devinit setup_memc(struct fb_info *fbi) +static void setup_memc(struct fb_info *fbi) { unsigned long tmp; int i; @@ -747,7 +747,7 @@ static void enable_clocks(struct fb_info *fbi) write_reg_dly(0x00000001, PIXCLKDIV); } -static void __devinit setup_graphics(struct fb_info *fbi) +static void setup_graphics(struct fb_info *fbi) { unsigned long gsctrl; unsigned long vscadr; @@ -781,7 +781,7 @@ static void __devinit setup_graphics(struct fb_info *fbi) write_reg_dly(vscadr, VSCADR); } -static void __devinit setup_display(struct fb_info *fbi) +static void setup_display(struct fb_info *fbi) { unsigned long dsctrl = 0; @@ -795,7 +795,7 @@ static void __devinit setup_display(struct fb_info *fbi) write_reg_dly((readl(DSCTRL) | DSCTRL_SYNCGEN_EN), DSCTRL); } -static void __devinit enable_controller(struct fb_info *fbi) +static void enable_controller(struct fb_info *fbi) { u32 svctrl, shctrl; @@ -881,7 +881,7 @@ static int mbxfb_resume(struct platform_device *dev) #define res_size(_r) (((_r)->end - (_r)->start) + 1) -static int __devinit mbxfb_probe(struct platform_device *dev) +static int mbxfb_probe(struct platform_device *dev) { int ret; struct fb_info *fbi; diff --git a/drivers/video/metronomefb.c b/drivers/video/metronomefb.c index c0c358c..d148067 100644 --- a/drivers/video/metronomefb.c +++ b/drivers/video/metronomefb.c @@ -167,7 +167,7 @@ static u16 calc_img_cksum(u16 *start, int length) } /* here we decode the incoming waveform file and populate metromem */ -static int __devinit load_waveform(u8 *mem, size_t size, int m, int t, +static int load_waveform(u8 *mem, size_t size, int m, int t, struct metronomefb_par *par) { int tta; @@ -338,7 +338,7 @@ static int metronome_display_cmd(struct metronomefb_par *par) return par->board->met_wait_event_intr(par); } -static int __devinit metronome_powerup_cmd(struct metronomefb_par *par) +static int metronome_powerup_cmd(struct metronomefb_par *par) { int i; u16 cs; @@ -367,7 +367,7 @@ static int __devinit metronome_powerup_cmd(struct metronomefb_par *par) return par->board->met_wait_event(par); } -static int __devinit metronome_config_cmd(struct metronomefb_par *par) +static int metronome_config_cmd(struct metronomefb_par *par) { /* setup config command we can't immediately set the opcode since the controller @@ -385,7 +385,7 @@ static int __devinit metronome_config_cmd(struct metronomefb_par *par) return par->board->met_wait_event(par); } -static int __devinit metronome_init_cmd(struct metronomefb_par *par) +static int metronome_init_cmd(struct metronomefb_par *par) { int i; u16 cs; @@ -411,7 +411,7 @@ static int __devinit metronome_init_cmd(struct metronomefb_par *par) return par->board->met_wait_event(par); } -static int __devinit metronome_init_regs(struct metronomefb_par *par) +static int metronome_init_regs(struct metronomefb_par *par) { int res; @@ -569,7 +569,7 @@ static struct fb_deferred_io metronomefb_defio = { .deferred_io = metronomefb_dpy_deferred_io, }; -static int __devinit metronomefb_probe(struct platform_device *dev) +static int metronomefb_probe(struct platform_device *dev) { struct fb_info *info; struct metronome_board *board; diff --git a/drivers/video/msm/mddi.c b/drivers/video/msm/mddi.c index 35ac9e8..88e9f41c 100644 --- a/drivers/video/msm/mddi.c +++ b/drivers/video/msm/mddi.c @@ -417,7 +417,7 @@ static void mddi_resume(struct msm_mddi_client_data *cdata) mddi_set_auto_hibernate(&mddi->client_data, 1); } -static int __devinit mddi_get_client_caps(struct mddi_info *mddi) +static int mddi_get_client_caps(struct mddi_info *mddi) { int i, j; @@ -619,7 +619,7 @@ uint32_t mddi_remote_read(struct msm_mddi_client_data *cdata, uint32_t reg) static struct mddi_info mddi_info[2]; -static int __devinit mddi_clk_setup(struct platform_device *pdev, +static int mddi_clk_setup(struct platform_device *pdev, struct mddi_info *mddi, unsigned long clk_rate) { @@ -664,7 +664,7 @@ static int __init mddi_rev_data_setup(struct mddi_info *mddi) return 0; } -static int __devinit mddi_probe(struct platform_device *pdev) +static int mddi_probe(struct platform_device *pdev) { struct msm_mddi_platform_data *pdata = pdev->dev.platform_data; struct mddi_info *mddi = &mddi_info[pdev->id]; diff --git a/drivers/video/mxsfb.c b/drivers/video/mxsfb.c index ddac96d..be26b36 100644 --- a/drivers/video/mxsfb.c +++ b/drivers/video/mxsfb.c @@ -586,7 +586,7 @@ static struct fb_ops mxsfb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit mxsfb_restore_mode(struct mxsfb_info *host) +static int mxsfb_restore_mode(struct mxsfb_info *host) { struct fb_info *fb_info = &host->fb_info; unsigned line_count; @@ -677,7 +677,7 @@ static int __devinit mxsfb_restore_mode(struct mxsfb_info *host) return 0; } -static int __devinit mxsfb_init_fbinfo(struct mxsfb_info *host) +static int mxsfb_init_fbinfo(struct mxsfb_info *host) { struct fb_info *fb_info = &host->fb_info; struct fb_var_screeninfo *var = &fb_info->var; @@ -772,7 +772,7 @@ static const struct of_device_id mxsfb_dt_ids[] = { }; MODULE_DEVICE_TABLE(of, mxsfb_dt_ids); -static int __devinit mxsfb_probe(struct platform_device *pdev) +static int mxsfb_probe(struct platform_device *pdev) { const struct of_device_id *of_id = of_match_device(mxsfb_dt_ids, &pdev->dev); diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c index 15c3bef..4cd9e6d 100644 --- a/drivers/video/neofb.c +++ b/drivers/video/neofb.c @@ -1646,7 +1646,7 @@ static struct fb_videomode __devinitdata mode800x480 = { .vmode = FB_VMODE_NONINTERLACED }; -static int __devinit neo_map_mmio(struct fb_info *info, +static int neo_map_mmio(struct fb_info *info, struct pci_dev *dev) { struct neofb_par *par = info->par; @@ -1707,7 +1707,7 @@ static void neo_unmap_mmio(struct fb_info *info) info->fix.mmio_len); } -static int __devinit neo_map_video(struct fb_info *info, +static int neo_map_video(struct fb_info *info, struct pci_dev *dev, int video_len) { //unsigned long addr; @@ -1772,7 +1772,7 @@ static void neo_unmap_video(struct fb_info *info) info->fix.smem_len); } -static int __devinit neo_scan_monitor(struct fb_info *info) +static int neo_scan_monitor(struct fb_info *info) { struct neofb_par *par = info->par; unsigned char type, display; @@ -1851,7 +1851,7 @@ static int __devinit neo_scan_monitor(struct fb_info *info) return 0; } -static int __devinit neo_init_hw(struct fb_info *info) +static int neo_init_hw(struct fb_info *info) { struct neofb_par *par = info->par; int videoRam = 896; @@ -1939,7 +1939,7 @@ static int __devinit neo_init_hw(struct fb_info *info) } -static struct fb_info *__devinit neo_alloc_fb_info(struct pci_dev *dev, const struct +static struct fb_info *neo_alloc_fb_info(struct pci_dev *dev, const struct pci_device_id *id) { struct fb_info *info; @@ -2038,7 +2038,7 @@ static void neo_free_fb_info(struct fb_info *info) /* --------------------------------------------------------------------- */ -static int __devinit neofb_probe(struct pci_dev *dev, +static int neofb_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct fb_info *info; diff --git a/drivers/video/nuc900fb.c b/drivers/video/nuc900fb.c index 475dfee..32581c7 100644 --- a/drivers/video/nuc900fb.c +++ b/drivers/video/nuc900fb.c @@ -387,7 +387,7 @@ static int nuc900fb_init_registers(struct fb_info *info) * The buffer should be a non-cached, non-buffered, memory region * to allow palette and pixel writes without flushing the cache. */ -static int __devinit nuc900fb_map_video_memory(struct fb_info *info) +static int nuc900fb_map_video_memory(struct fb_info *info) { struct nuc900fb_info *fbi = info->par; dma_addr_t map_dma; @@ -499,7 +499,7 @@ static inline void nuc900fb_cpufreq_deregister(struct nuc900fb_info *info) static char driver_name[] = "nuc900fb"; -static int __devinit nuc900fb_probe(struct platform_device *pdev) +static int nuc900fb_probe(struct platform_device *pdev) { struct nuc900fb_info *fbi; struct nuc900fb_display *display; diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c index 0bbed28..ca8963c 100644 --- a/drivers/video/nvidia/nvidia.c +++ b/drivers/video/nvidia/nvidia.c @@ -1105,7 +1105,7 @@ fail: #define nvidiafb_resume NULL #endif -static int __devinit nvidia_set_fbinfo(struct fb_info *info) +static int nvidia_set_fbinfo(struct fb_info *info) { struct fb_monspecs *specs = &info->monspecs; struct fb_videomode modedb; @@ -1201,7 +1201,7 @@ static int __devinit nvidia_set_fbinfo(struct fb_info *info) return nvidiafb_check_var(&info->var, info); } -static u32 __devinit nvidia_get_chipset(struct fb_info *info) +static u32 nvidia_get_chipset(struct fb_info *info) { struct nvidia_par *par = info->par; u32 id = (par->pci_dev->vendor << 16) | par->pci_dev->device; @@ -1224,7 +1224,7 @@ static u32 __devinit nvidia_get_chipset(struct fb_info *info) return id; } -static u32 __devinit nvidia_get_arch(struct fb_info *info) +static u32 nvidia_get_arch(struct fb_info *info) { struct nvidia_par *par = info->par; u32 arch = 0; @@ -1276,7 +1276,7 @@ static u32 __devinit nvidia_get_arch(struct fb_info *info) return arch; } -static int __devinit nvidiafb_probe(struct pci_dev *pd, +static int nvidiafb_probe(struct pci_dev *pd, const struct pci_device_id *ent) { struct nvidia_par *par; @@ -1473,7 +1473,7 @@ static void __devexit nvidiafb_remove(struct pci_dev *pd) * ------------------------------------------------------------------------- */ #ifndef MODULE -static int __devinit nvidiafb_setup(char *options) +static int nvidiafb_setup(char *options) { char *this_opt; @@ -1538,7 +1538,7 @@ static struct pci_driver nvidiafb_driver = { * * ------------------------------------------------------------------------- */ -static int __devinit nvidiafb_init(void) +static int nvidiafb_init(void) { #ifndef MODULE char *option = NULL; diff --git a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c index bae244f..4ed48af 100644 --- a/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c +++ b/drivers/video/omap2/displays/panel-lgphilips-lb035q02.c @@ -250,7 +250,7 @@ static void init_lb035q02_panel(struct spi_device *spi) lb035q02_write_reg(spi, 0x3b, 0x0806); } -static int __devinit lb035q02_panel_spi_probe(struct spi_device *spi) +static int lb035q02_panel_spi_probe(struct spi_device *spi) { init_lb035q02_panel(spi); return omap_dss_register_driver(&lb035q02_driver); diff --git a/drivers/video/p9100.c b/drivers/video/p9100.c index f402a69..62d8339 100644 --- a/drivers/video/p9100.c +++ b/drivers/video/p9100.c @@ -249,7 +249,7 @@ static void p9100_init_fix(struct fb_info *info, int linebytes, struct device_no info->fix.accel = FB_ACCEL_SUN_CGTHREE; } -static int __devinit p9100_probe(struct platform_device *op) +static int p9100_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/platinumfb.c b/drivers/video/platinumfb.c index 6694923..f638002 100644 --- a/drivers/video/platinumfb.c +++ b/drivers/video/platinumfb.c @@ -313,7 +313,7 @@ static void platinum_set_hardware(struct fb_info_platinum *pinfo) /* * Set misc info vars for this driver */ -static void __devinit platinum_init_info(struct fb_info *info, struct fb_info_platinum *pinfo) +static void platinum_init_info(struct fb_info *info, struct fb_info_platinum *pinfo) { /* Fill fb_info */ info->fbops = &platinumfb_ops; @@ -338,7 +338,7 @@ static void __devinit platinum_init_info(struct fb_info *info, struct fb_info_pl } -static int __devinit platinum_init_fb(struct fb_info *info) +static int platinum_init_fb(struct fb_info *info) { struct fb_info_platinum *pinfo = info->par; struct fb_var_screeninfo var; @@ -533,7 +533,7 @@ static int __init platinumfb_setup(char *options) #define invalidate_cache(addr) #endif -static int __devinit platinumfb_probe(struct platform_device* odev) +static int platinumfb_probe(struct platform_device* odev) { struct device_node *dp = odev->dev.of_node; struct fb_info *info; diff --git a/drivers/video/pm2fb.c b/drivers/video/pm2fb.c index c4f639a..70192ba 100644 --- a/drivers/video/pm2fb.c +++ b/drivers/video/pm2fb.c @@ -1515,7 +1515,7 @@ static struct fb_ops pm2fb_ops = { * @param pdev PCI device. * @param id PCI device ID. */ -static int __devinit pm2fb_probe(struct pci_dev *pdev, +static int pm2fb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct pm2fb_par *default_par; diff --git a/drivers/video/pm3fb.c b/drivers/video/pm3fb.c index e9d8e23..1fdae1d 100644 --- a/drivers/video/pm3fb.c +++ b/drivers/video/pm3fb.c @@ -1229,7 +1229,7 @@ static struct fb_ops pm3fb_ops = { /* mmio register are already mapped when this function is called */ /* the pm3fb_fix.smem_start is also set */ -static unsigned long __devinit pm3fb_size_memory(struct pm3_par *par) +static unsigned long pm3fb_size_memory(struct pm3_par *par) { unsigned long memsize = 0; unsigned long tempBypass, i, temp1, temp2; @@ -1314,7 +1314,7 @@ static unsigned long __devinit pm3fb_size_memory(struct pm3_par *par) return memsize; } -static int __devinit pm3fb_probe(struct pci_dev *dev, +static int pm3fb_probe(struct pci_dev *dev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/pmag-ba-fb.c b/drivers/video/pmag-ba-fb.c index 9b4a60b..e5d2994 100644 --- a/drivers/video/pmag-ba-fb.c +++ b/drivers/video/pmag-ba-fb.c @@ -141,7 +141,7 @@ static void __init pmagbafb_erase_cursor(struct fb_info *info) } -static int __devinit pmagbafb_probe(struct device *dev) +static int pmagbafb_probe(struct device *dev) { struct tc_dev *tdev = to_tc_dev(dev); resource_size_t start, len; diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c index 4e7a9c4..e731baf 100644 --- a/drivers/video/pmagb-b-fb.c +++ b/drivers/video/pmagb-b-fb.c @@ -147,7 +147,7 @@ static void __init pmagbbfb_erase_cursor(struct fb_info *info) /* * Set up screen parameters. */ -static void __devinit pmagbbfb_screen_setup(struct fb_info *info) +static void pmagbbfb_screen_setup(struct fb_info *info) { struct pmagbbfb_par *par = info->par; @@ -179,7 +179,7 @@ static void __devinit pmagbbfb_screen_setup(struct fb_info *info) /* * Determine oscillator configuration. */ -static void __devinit pmagbbfb_osc_setup(struct fb_info *info) +static void pmagbbfb_osc_setup(struct fb_info *info) { static unsigned int pmagbbfb_freqs[] __devinitdata = { 130808, 119843, 104000, 92980, 74370, 72800, @@ -246,7 +246,7 @@ static void __devinit pmagbbfb_osc_setup(struct fb_info *info) }; -static int __devinit pmagbbfb_probe(struct device *dev) +static int pmagbbfb_probe(struct device *dev) { struct tc_dev *tdev = to_tc_dev(dev); resource_size_t start, len; diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c index 0b340d6..536a098 100644 --- a/drivers/video/ps3fb.c +++ b/drivers/video/ps3fb.c @@ -965,7 +965,7 @@ static struct fb_fix_screeninfo ps3fb_fix __initdata = { .accel = FB_ACCEL_NONE, }; -static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev) +static int ps3fb_probe(struct ps3_system_bus_device *dev) { struct fb_info *info; struct ps3fb_par *par; diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c index 69fc2c3..1192343 100644 --- a/drivers/video/pvr2fb.c +++ b/drivers/video/pvr2fb.c @@ -763,7 +763,7 @@ out_unmap: * in for flexibility anyways. Who knows, maybe someone has tv-out on a * PCI-based version of these things ;-) */ -static int __devinit pvr2fb_common_init(void) +static int pvr2fb_common_init(void) { struct pvr2fb_par *par = currentpar; unsigned long modememused, rev; @@ -922,7 +922,7 @@ static void __exit pvr2fb_dc_exit(void) #endif /* CONFIG_SH_DREAMCAST */ #ifdef CONFIG_PCI -static int __devinit pvr2fb_pci_probe(struct pci_dev *pdev, +static int pvr2fb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { int ret; @@ -993,7 +993,7 @@ static void __exit pvr2fb_pci_exit(void) } #endif /* CONFIG_PCI */ -static int __devinit pvr2_get_param(const struct pvr2_params *p, const char *s, +static int pvr2_get_param(const struct pvr2_params *p, const char *s, int val, int size) { int i; diff --git a/drivers/video/pxa168fb.c b/drivers/video/pxa168fb.c index a8fd898..49af862 100644 --- a/drivers/video/pxa168fb.c +++ b/drivers/video/pxa168fb.c @@ -560,7 +560,7 @@ static struct fb_ops pxa168fb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit pxa168fb_init_mode(struct fb_info *info, +static int pxa168fb_init_mode(struct fb_info *info, struct pxa168fb_mach_info *mi) { struct pxa168fb_info *fbi = info->par; @@ -600,7 +600,7 @@ static int __devinit pxa168fb_init_mode(struct fb_info *info, return ret; } -static int __devinit pxa168fb_probe(struct platform_device *pdev) +static int pxa168fb_probe(struct platform_device *pdev) { struct pxa168fb_mach_info *mi; struct fb_info *info = 0; diff --git a/drivers/video/pxa3xx-gcu.c b/drivers/video/pxa3xx-gcu.c index 4493a47..f163474 100644 --- a/drivers/video/pxa3xx-gcu.c +++ b/drivers/video/pxa3xx-gcu.c @@ -574,7 +574,7 @@ free_buffers(struct platform_device *dev, priv->free = NULL; } -static int __devinit +static int pxa3xx_gcu_probe(struct platform_device *dev) { int i, ret, irq; diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c index ffa62e2..1ff1a16 100644 --- a/drivers/video/pxafb.c +++ b/drivers/video/pxafb.c @@ -869,7 +869,7 @@ static struct fb_ops overlay_fb_ops = { .fb_set_par = overlayfb_set_par, }; -static void __devinit init_pxafb_overlay(struct pxafb_info *fbi, +static void init_pxafb_overlay(struct pxafb_info *fbi, struct pxafb_layer *ofb, int id) { sprintf(ofb->fb.fix.id, "overlay%d", id + 1); @@ -903,7 +903,7 @@ static inline int pxafb_overlay_supported(void) return 0; } -static int __devinit pxafb_overlay_map_video_memory(struct pxafb_info *pxafb, +static int pxafb_overlay_map_video_memory(struct pxafb_info *pxafb, struct pxafb_layer *ofb) { /* We assume that user will use at most video_mem_size for overlay fb, @@ -927,7 +927,7 @@ static int __devinit pxafb_overlay_map_video_memory(struct pxafb_info *pxafb, return 0; } -static void __devinit pxafb_overlay_init(struct pxafb_info *fbi) +static void pxafb_overlay_init(struct pxafb_info *fbi) { int i, ret; @@ -1706,7 +1706,7 @@ static const struct dev_pm_ops pxafb_pm_ops = { }; #endif -static int __devinit pxafb_init_video_memory(struct pxafb_info *fbi) +static int pxafb_init_video_memory(struct pxafb_info *fbi) { int size = PAGE_ALIGN(fbi->video_mem_size); @@ -1789,7 +1789,7 @@ decode_mode: fbi->video_mem_size = video_mem_size; } -static struct pxafb_info * __devinit pxafb_init_fbinfo(struct device *dev) +static struct pxafb_info *pxafb_init_fbinfo(struct device *dev) { struct pxafb_info *fbi; void *addr; @@ -1853,7 +1853,7 @@ static struct pxafb_info * __devinit pxafb_init_fbinfo(struct device *dev) } #ifdef CONFIG_FB_PXA_PARAMETERS -static int __devinit parse_opt_mode(struct device *dev, const char *this_opt) +static int parse_opt_mode(struct device *dev, const char *this_opt) { struct pxafb_mach_info *inf = dev->platform_data; @@ -1912,7 +1912,7 @@ done: return 0; } -static int __devinit parse_opt(struct device *dev, char *this_opt) +static int parse_opt(struct device *dev, char *this_opt) { struct pxafb_mach_info *inf = dev->platform_data; struct pxafb_mode_info *mode = &inf->modes[0]; @@ -2012,7 +2012,7 @@ static int __devinit parse_opt(struct device *dev, char *this_opt) return 0; } -static int __devinit pxafb_parse_options(struct device *dev, char *options) +static int pxafb_parse_options(struct device *dev, char *options) { char *this_opt; int ret; @@ -2061,7 +2061,7 @@ MODULE_PARM_DESC(options, "LCD parameters (see Documentation/fb/pxafb.txt)"); #ifdef DEBUG_VAR /* Check for various illegal bit-combinations. Currently only * a warning is given. */ -static void __devinit pxafb_check_options(struct device *dev, +static void pxafb_check_options(struct device *dev, struct pxafb_mach_info *inf) { if (inf->lcd_conn) @@ -2094,7 +2094,7 @@ static void __devinit pxafb_check_options(struct device *dev, #define pxafb_check_options(...) do {} while (0) #endif -static int __devinit pxafb_probe(struct platform_device *dev) +static int pxafb_probe(struct platform_device *dev) { struct pxafb_info *fbi; struct pxafb_mach_info *inf; diff --git a/drivers/video/q40fb.c b/drivers/video/q40fb.c index a104e8c..d1a7529 100644 --- a/drivers/video/q40fb.c +++ b/drivers/video/q40fb.c @@ -83,7 +83,7 @@ static struct fb_ops q40fb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit q40fb_probe(struct platform_device *dev) +static int q40fb_probe(struct platform_device *dev) { struct fb_info *info; diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c index 693ed5e..49caea2 100644 --- a/drivers/video/riva/fbdev.c +++ b/drivers/video/riva/fbdev.c @@ -1709,7 +1709,7 @@ static struct fb_ops riva_fb_ops = { .fb_sync = rivafb_sync, }; -static int __devinit riva_set_fbinfo(struct fb_info *info) +static int riva_set_fbinfo(struct fb_info *info) { unsigned int cmap_len; struct riva_par *par = info->par; @@ -1747,7 +1747,7 @@ static int __devinit riva_set_fbinfo(struct fb_info *info) } #ifdef CONFIG_PPC_OF -static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd) +static int riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd) { struct riva_par *par = info->par; struct device_node *dp; @@ -1780,7 +1780,7 @@ static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd) #endif /* CONFIG_PPC_OF */ #if defined(CONFIG_FB_RIVA_I2C) && !defined(CONFIG_PPC_OF) -static int __devinit riva_get_EDID_i2c(struct fb_info *info) +static int riva_get_EDID_i2c(struct fb_info *info) { struct riva_par *par = info->par; struct fb_var_screeninfo var; @@ -1803,7 +1803,7 @@ static int __devinit riva_get_EDID_i2c(struct fb_info *info) } #endif /* CONFIG_FB_RIVA_I2C */ -static void __devinit riva_update_default_var(struct fb_var_screeninfo *var, +static void riva_update_default_var(struct fb_var_screeninfo *var, struct fb_info *info) { struct fb_monspecs *specs = &info->monspecs; @@ -1836,7 +1836,7 @@ static void __devinit riva_update_default_var(struct fb_var_screeninfo *var, } -static void __devinit riva_get_EDID(struct fb_info *info, struct pci_dev *pdev) +static void riva_get_EDID(struct fb_info *info, struct pci_dev *pdev) { NVTRACE_ENTER(); #ifdef CONFIG_PPC_OF @@ -1850,7 +1850,7 @@ static void __devinit riva_get_EDID(struct fb_info *info, struct pci_dev *pdev) } -static void __devinit riva_get_edidinfo(struct fb_info *info) +static void riva_get_edidinfo(struct fb_info *info) { struct fb_var_screeninfo *var = &rivafb_default_var; struct riva_par *par = info->par; @@ -1871,7 +1871,7 @@ static void __devinit riva_get_edidinfo(struct fb_info *info) * * ------------------------------------------------------------------------- */ -static u32 __devinit riva_get_arch(struct pci_dev *pd) +static u32 riva_get_arch(struct pci_dev *pd) { u32 arch = 0; @@ -1909,7 +1909,7 @@ static u32 __devinit riva_get_arch(struct pci_dev *pd) return arch; } -static int __devinit rivafb_probe(struct pci_dev *pd, +static int rivafb_probe(struct pci_dev *pd, const struct pci_device_id *ent) { struct riva_par *default_par; @@ -2145,7 +2145,7 @@ static void __devexit rivafb_remove(struct pci_dev *pd) * ------------------------------------------------------------------------- */ #ifndef MODULE -static int __devinit rivafb_setup(char *options) +static int rivafb_setup(char *options) { char *this_opt; @@ -2197,7 +2197,7 @@ static struct pci_driver rivafb_driver = { * * ------------------------------------------------------------------------- */ -static int __devinit rivafb_init(void) +static int rivafb_init(void) { #ifndef MODULE char *option = NULL; diff --git a/drivers/video/riva/rivafb-i2c.c b/drivers/video/riva/rivafb-i2c.c index 167400e..db78ac8 100644 --- a/drivers/video/riva/rivafb-i2c.c +++ b/drivers/video/riva/rivafb-i2c.c @@ -86,7 +86,7 @@ static int riva_gpio_getsda(void* data) return val; } -static int __devinit riva_setup_i2c_bus(struct riva_i2c_chan *chan, +static int riva_setup_i2c_bus(struct riva_i2c_chan *chan, const char *name, unsigned int i2c_class) { @@ -124,7 +124,7 @@ static int __devinit riva_setup_i2c_bus(struct riva_i2c_chan *chan, return rc; } -void __devinit riva_create_i2c_busses(struct riva_par *par) +void riva_create_i2c_busses(struct riva_par *par) { par->chan[0].par = par; par->chan[1].par = par; @@ -150,7 +150,7 @@ void riva_delete_i2c_busses(struct riva_par *par) } } -int __devinit riva_probe_i2c_connector(struct riva_par *par, int conn, u8 **out_edid) +int riva_probe_i2c_connector(struct riva_par *par, int conn, u8 **out_edid) { u8 *edid = NULL; diff --git a/drivers/video/s1d13xxxfb.c b/drivers/video/s1d13xxxfb.c index 28b1c6c..f7839e1 100644 --- a/drivers/video/s1d13xxxfb.c +++ b/drivers/video/s1d13xxxfb.c @@ -642,7 +642,7 @@ static int s1d13xxxfb_width_tab[2][4] __devinitdata = { * Note: some of the hardcoded values here might need some love to * work on various chips, and might need to no longer be hardcoded. */ -static void __devinit +static void s1d13xxxfb_fetch_hw_state(struct fb_info *info) { struct fb_var_screeninfo *var = &info->var; @@ -764,7 +764,7 @@ s1d13xxxfb_remove(struct platform_device *pdev) return 0; } -static int __devinit +static int s1d13xxxfb_probe(struct platform_device *pdev) { struct s1d13xxxfb_par *default_par; diff --git a/drivers/video/s3c-fb.c b/drivers/video/s3c-fb.c index 71981a5..141fefd 100644 --- a/drivers/video/s3c-fb.c +++ b/drivers/video/s3c-fb.c @@ -1079,7 +1079,7 @@ static void s3c_fb_missing_pixclock(struct fb_videomode *mode) * * Allocate memory for the given framebuffer. */ -static int __devinit s3c_fb_alloc_memory(struct s3c_fb *sfb, +static int s3c_fb_alloc_memory(struct s3c_fb *sfb, struct s3c_fb_win *win) { struct s3c_fb_pd_win *windata = win->windata; @@ -1170,7 +1170,7 @@ static void s3c_fb_release_win(struct s3c_fb *sfb, struct s3c_fb_win *win) * Allocate and do the basic initialisation for one of the hardware's graphics * windows. */ -static int __devinit s3c_fb_probe_win(struct s3c_fb *sfb, unsigned int win_no, +static int s3c_fb_probe_win(struct s3c_fb *sfb, unsigned int win_no, struct s3c_fb_win_variant *variant, struct s3c_fb_win **res) { @@ -1358,7 +1358,7 @@ static void s3c_fb_clear_win(struct s3c_fb *sfb, int win) } } -static int __devinit s3c_fb_probe(struct platform_device *pdev) +static int s3c_fb_probe(struct platform_device *pdev) { const struct platform_device_id *platid; struct s3c_fb_driverdata *fbdrv; diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c index fbf3cea..528cec6 100644 --- a/drivers/video/s3c2410fb.c +++ b/drivers/video/s3c2410fb.c @@ -637,7 +637,7 @@ static struct fb_ops s3c2410fb_ops = { * cache. Once this area is remapped, all virtual memory * access to the video memory should occur at the new region. */ -static int __devinit s3c2410fb_map_video_memory(struct fb_info *info) +static int s3c2410fb_map_video_memory(struct fb_info *info) { struct s3c2410fb_info *fbi = info->par; dma_addr_t map_dma; @@ -819,7 +819,7 @@ static inline void s3c2410fb_cpufreq_deregister(struct s3c2410fb_info *info) static const char driver_name[] = "s3c2410fb"; -static int __devinit s3c24xxfb_probe(struct platform_device *pdev, +static int s3c24xxfb_probe(struct platform_device *pdev, enum s3c_drv_type drv_type) { struct s3c2410fb_info *info; @@ -1010,12 +1010,12 @@ dealloc_fb: return ret; } -static int __devinit s3c2410fb_probe(struct platform_device *pdev) +static int s3c2410fb_probe(struct platform_device *pdev) { return s3c24xxfb_probe(pdev, DRV_S3C2410); } -static int __devinit s3c2412fb_probe(struct platform_device *pdev) +static int s3c2412fb_probe(struct platform_device *pdev) { return s3c24xxfb_probe(pdev, DRV_S3C2412); } diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c index 1b4f146..e66ecbb 100644 --- a/drivers/video/s3fb.c +++ b/drivers/video/s3fb.c @@ -255,7 +255,7 @@ static int s3fb_ddc_getsda(void *data) return !!(s3fb_ddc_read(par) & DDC_SDA_IN); } -static int __devinit s3fb_setup_ddc_bus(struct fb_info *info) +static int s3fb_setup_ddc_bus(struct fb_info *info) { struct s3fb_info *par = info->par; @@ -1066,7 +1066,7 @@ static struct fb_ops s3fb_ops = { /* ------------------------------------------------------------------------- */ -static int __devinit s3_identification(struct s3fb_info *par) +static int s3_identification(struct s3fb_info *par) { int chip = par->chip; @@ -1122,7 +1122,7 @@ static int __devinit s3_identification(struct s3fb_info *par) /* PCI probe */ -static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) +static int s3_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct pci_bus_region bus_reg; struct resource vga_res; diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c index b632584..5e79fea 100644 --- a/drivers/video/sa1100fb.c +++ b/drivers/video/sa1100fb.c @@ -1090,7 +1090,7 @@ static int sa1100fb_resume(struct platform_device *dev) * cache. Once this area is remapped, all virtual memory * access to the video memory should occur at the new region. */ -static int __devinit sa1100fb_map_video_memory(struct sa1100fb_info *fbi) +static int sa1100fb_map_video_memory(struct sa1100fb_info *fbi) { /* * We reserve one page for the palette, plus the size @@ -1124,7 +1124,7 @@ static struct fb_monspecs monspecs __devinitdata = { }; -static struct sa1100fb_info * __devinit sa1100fb_init_fbinfo(struct device *dev) +static struct sa1100fb_info *sa1100fb_init_fbinfo(struct device *dev) { struct sa1100fb_mach_info *inf = dev->platform_data; struct sa1100fb_info *fbi; @@ -1205,7 +1205,7 @@ static struct sa1100fb_info * __devinit sa1100fb_init_fbinfo(struct device *dev) return fbi; } -static int __devinit sa1100fb_probe(struct platform_device *pdev) +static int sa1100fb_probe(struct platform_device *pdev) { struct sa1100fb_info *fbi; struct resource *res; diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c index a1cc484..dbf8d62 100644 --- a/drivers/video/savage/savagefb_driver.c +++ b/drivers/video/savage/savagefb_driver.c @@ -1715,7 +1715,7 @@ static void savage_disable_mmio(struct savagefb_par *par) } -static int __devinit savage_map_mmio(struct fb_info *info) +static int savage_map_mmio(struct fb_info *info) { struct savagefb_par *par = info->par; DBG("savage_map_mmio"); @@ -1761,7 +1761,7 @@ static void savage_unmap_mmio(struct fb_info *info) } } -static int __devinit savage_map_video(struct fb_info *info, +static int savage_map_video(struct fb_info *info, int video_len) { struct savagefb_par *par = info->par; @@ -2052,7 +2052,7 @@ static int savage_init_hw(struct savagefb_par *par) return videoRambytes; } -static int __devinit savage_init_fb_info(struct fb_info *info, +static int savage_init_fb_info(struct fb_info *info, struct pci_dev *dev, const struct pci_device_id *id) { @@ -2178,7 +2178,7 @@ static int __devinit savage_init_fb_info(struct fb_info *info, /* --------------------------------------------------------------------- */ -static int __devinit savagefb_probe(struct pci_dev* dev, +static int savagefb_probe(struct pci_dev* dev, const struct pci_device_id* id) { struct fb_info *info; diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c index b5c30b9..c65ab22 100644 --- a/drivers/video/sgivwfb.c +++ b/drivers/video/sgivwfb.c @@ -745,7 +745,7 @@ int __init sgivwfb_setup(char *options) /* * Initialisation */ -static int __devinit sgivwfb_probe(struct platform_device *dev) +static int sgivwfb_probe(struct platform_device *dev) { struct sgivw_par *par; struct fb_info *info; diff --git a/drivers/video/sh7760fb.c b/drivers/video/sh7760fb.c index ff93339..0ad44d1 100644 --- a/drivers/video/sh7760fb.c +++ b/drivers/video/sh7760fb.c @@ -431,7 +431,7 @@ static int sh7760fb_alloc_mem(struct fb_info *info) return 0; } -static int __devinit sh7760fb_probe(struct platform_device *pdev) +static int sh7760fb_probe(struct platform_device *pdev) { struct fb_info *info; struct resource *res; diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c index 699487c..d776bfe 100644 --- a/drivers/video/sh_mobile_lcdcfb.c +++ b/drivers/video/sh_mobile_lcdcfb.c @@ -1639,7 +1639,7 @@ sh_mobile_lcdc_overlay_fb_unregister(struct sh_mobile_lcdc_overlay *ovl) unregister_framebuffer(ovl->info); } -static int __devinit +static int sh_mobile_lcdc_overlay_fb_register(struct sh_mobile_lcdc_overlay *ovl) { struct sh_mobile_lcdc_priv *lcdc = ovl->channel->lcdc; @@ -1678,7 +1678,7 @@ sh_mobile_lcdc_overlay_fb_cleanup(struct sh_mobile_lcdc_overlay *ovl) framebuffer_release(info); } -static int __devinit +static int sh_mobile_lcdc_overlay_fb_init(struct sh_mobile_lcdc_overlay *ovl) { struct sh_mobile_lcdc_priv *priv = ovl->channel->lcdc; @@ -2117,7 +2117,7 @@ sh_mobile_lcdc_channel_fb_unregister(struct sh_mobile_lcdc_chan *ch) unregister_framebuffer(ch->info); } -static int __devinit +static int sh_mobile_lcdc_channel_fb_register(struct sh_mobile_lcdc_chan *ch) { struct fb_info *info = ch->info; @@ -2165,7 +2165,7 @@ sh_mobile_lcdc_channel_fb_cleanup(struct sh_mobile_lcdc_chan *ch) framebuffer_release(info); } -static int __devinit +static int sh_mobile_lcdc_channel_fb_init(struct sh_mobile_lcdc_chan *ch, const struct fb_videomode *mode, unsigned int num_modes) @@ -2475,7 +2475,7 @@ static int sh_mobile_lcdc_remove(struct platform_device *pdev) return 0; } -static int __devinit sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *ch) +static int sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan *ch) { int interface_type = ch->cfg->interface_type; @@ -2515,7 +2515,7 @@ static int __devinit sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan * return 0; } -static int __devinit +static int sh_mobile_lcdc_overlay_init(struct sh_mobile_lcdc_priv *priv, struct sh_mobile_lcdc_overlay *ovl) { @@ -2570,7 +2570,7 @@ sh_mobile_lcdc_overlay_init(struct sh_mobile_lcdc_priv *priv, return 0; } -static int __devinit +static int sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv, struct sh_mobile_lcdc_chan *ch) { @@ -2675,7 +2675,7 @@ sh_mobile_lcdc_channel_init(struct sh_mobile_lcdc_priv *priv, return sh_mobile_lcdc_channel_fb_init(ch, mode, num_modes); } -static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev) +static int sh_mobile_lcdc_probe(struct platform_device *pdev) { struct sh_mobile_lcdc_info *pdata = pdev->dev.platform_data; struct sh_mobile_lcdc_priv *priv; diff --git a/drivers/video/sh_mobile_meram.c b/drivers/video/sh_mobile_meram.c index 7a0ba8b..e0f0985 100644 --- a/drivers/video/sh_mobile_meram.c +++ b/drivers/video/sh_mobile_meram.c @@ -620,7 +620,7 @@ static UNIVERSAL_DEV_PM_OPS(sh_mobile_meram_dev_pm_ops, * Probe/remove and driver init/exit */ -static int __devinit sh_mobile_meram_probe(struct platform_device *pdev) +static int sh_mobile_meram_probe(struct platform_device *pdev) { struct sh_mobile_meram_priv *priv; struct sh_mobile_meram_info *pdata = pdev->dev.platform_data; diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c index 5193138..820a002 100644 --- a/drivers/video/sis/sis_main.c +++ b/drivers/video/sis/sis_main.c @@ -106,7 +106,7 @@ sisfb_setdefaultparms(void) /* ------------- Parameter parsing -------------- */ -static void __devinit +static void sisfb_search_vesamode(unsigned int vesamode, bool quiet) { int i = 0, j = 0; @@ -146,7 +146,7 @@ sisfb_search_vesamode(unsigned int vesamode, bool quiet) printk(KERN_ERR "sisfb: Invalid VESA mode 0x%x'\n", vesamode); } -static void __devinit +static void sisfb_search_mode(char *name, bool quiet) { unsigned int j = 0, xres = 0, yres = 0, depth = 0, rate = 0; @@ -225,7 +225,7 @@ sisfb_search_mode(char *name, bool quiet) } #ifndef MODULE -static void __devinit +static void sisfb_get_vga_mode_from_kernel(void) { #ifdef CONFIG_X86 @@ -345,7 +345,7 @@ sisfb_search_specialtiming(const char *name) /* ----------- Various detection routines ----------- */ -static void __devinit +static void sisfb_detect_custom_timing(struct sis_video_info *ivideo) { unsigned char *biosver = NULL; @@ -403,7 +403,7 @@ sisfb_detect_custom_timing(struct sis_video_info *ivideo) } while(mycustomttable[i].chipID); } -static bool __devinit +static bool sisfb_interpret_edid(struct sisfb_monitor *monitor, u8 *buffer) { int i, j, xres, yres, refresh, index; @@ -505,7 +505,7 @@ sisfb_interpret_edid(struct sisfb_monitor *monitor, u8 *buffer) return monitor->datavalid; } -static void __devinit +static void sisfb_handle_ddc(struct sis_video_info *ivideo, struct sisfb_monitor *monitor, int crtno) { unsigned short temp, i, realcrtno = crtno; @@ -1898,8 +1898,7 @@ static struct fb_ops sisfb_ops = { /* ---------------- Chip generation dependent routines ---------------- */ -static struct pci_dev * __devinit -sisfb_get_northbridge(int basechipid) +static struct pci_dev *sisfb_get_northbridge(int basechipid) { struct pci_dev *pdev = NULL; int nbridgenum, nbridgeidx, i; @@ -1938,7 +1937,7 @@ sisfb_get_northbridge(int basechipid) return pdev; } -static int __devinit +static int sisfb_get_dram_size(struct sis_video_info *ivideo) { #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315) @@ -2038,7 +2037,7 @@ sisfb_get_dram_size(struct sis_video_info *ivideo) /* -------------- video bridge device detection --------------- */ -static void __devinit +static void sisfb_detect_VB_connect(struct sis_video_info *ivideo) { u8 cr32, temp; @@ -2164,7 +2163,7 @@ sisfb_detect_VB_connect(struct sis_video_info *ivideo) /* ------------------ Sensing routines ------------------ */ -static bool __devinit +static bool sisfb_test_DDC1(struct sis_video_info *ivideo) { unsigned short old; @@ -2177,7 +2176,7 @@ sisfb_test_DDC1(struct sis_video_info *ivideo) return (count != -1); } -static void __devinit +static void sisfb_sense_crt1(struct sis_video_info *ivideo) { bool mustwait = false; @@ -2259,7 +2258,7 @@ sisfb_sense_crt1(struct sis_video_info *ivideo) } /* Determine and detect attached devices on SiS30x */ -static void __devinit +static void SiS_SenseLCD(struct sis_video_info *ivideo) { unsigned char buffer[256]; @@ -2347,7 +2346,7 @@ SiS_SenseLCD(struct sis_video_info *ivideo) ivideo->SiS_Pr.PanelSelfDetected = true; } -static int __devinit +static int SISDoSense(struct sis_video_info *ivideo, u16 type, u16 test) { int temp, mytest, result, i, j; @@ -2377,7 +2376,7 @@ SISDoSense(struct sis_video_info *ivideo, u16 type, u16 test) return result; } -static void __devinit +static void SiS_Sense30x(struct sis_video_info *ivideo) { u8 backupP4_0d,backupP2_00,backupP2_4d,backupSR_1e,biosflag=0; @@ -2518,7 +2517,7 @@ SiS_Sense30x(struct sis_video_info *ivideo) } /* Determine and detect attached TV's on Chrontel */ -static void __devinit +static void SiS_SenseCh(struct sis_video_info *ivideo) { #if defined(CONFIG_FB_SIS_300) || defined(CONFIG_FB_SIS_315) @@ -2643,7 +2642,7 @@ SiS_SenseCh(struct sis_video_info *ivideo) } } -static void __devinit +static void sisfb_get_VB_type(struct sis_video_info *ivideo) { char stdstr[] = "sisfb: Detected"; @@ -2906,7 +2905,7 @@ sisfb_engine_init(struct sis_video_info *ivideo) ivideo->engineok = 1; } -static void __devinit +static void sisfb_detect_lcd_type(struct sis_video_info *ivideo) { u8 reg; @@ -2962,7 +2961,7 @@ sisfb_detect_lcd_type(struct sis_video_info *ivideo) ivideo->lcdxres, ivideo->lcdyres); } -static void __devinit +static void sisfb_save_pdc_emi(struct sis_video_info *ivideo) { #ifdef CONFIG_FB_SIS_300 @@ -3081,7 +3080,7 @@ sisfb_save_pdc_emi(struct sis_video_info *ivideo) /* -------------------- Memory manager routines ---------------------- */ -static u32 __devinit +static u32 sisfb_getheapstart(struct sis_video_info *ivideo) { u32 ret = ivideo->sisfb_parm_mem * 1024; @@ -3128,7 +3127,7 @@ sisfb_getheapstart(struct sis_video_info *ivideo) return ret; } -static u32 __devinit +static u32 sisfb_getheapsize(struct sis_video_info *ivideo) { u32 max = ivideo->video_size - ivideo->hwcursor_size - ivideo->cmdQueueSize; @@ -3154,7 +3153,7 @@ sisfb_getheapsize(struct sis_video_info *ivideo) return ret; } -static int __devinit +static int sisfb_heap_init(struct sis_video_info *ivideo) { struct SIS_OH *poh; @@ -4061,7 +4060,7 @@ static int __init sisfb_setup(char *options) } #endif -static int __devinit +static int sisfb_check_rom(void __iomem *rom_base, struct sis_video_info *ivideo) { void __iomem *rom; @@ -4089,8 +4088,7 @@ sisfb_check_rom(void __iomem *rom_base, struct sis_video_info *ivideo) return 1; } -static unsigned char * __devinit -sisfb_find_rom(struct pci_dev *pdev) +static unsigned char *sisfb_find_rom(struct pci_dev *pdev) { struct sis_video_info *ivideo = pci_get_drvdata(pdev); void __iomem *rom_base; @@ -4149,7 +4147,7 @@ sisfb_find_rom(struct pci_dev *pdev) return myrombase; } -static void __devinit +static void sisfb_post_map_vram(struct sis_video_info *ivideo, unsigned int *mapsize, unsigned int min) { @@ -4176,7 +4174,7 @@ sisfb_post_map_vram(struct sis_video_info *ivideo, unsigned int *mapsize, } #ifdef CONFIG_FB_SIS_300 -static int __devinit +static int sisfb_post_300_buswidth(struct sis_video_info *ivideo) { void __iomem *FBAddress = ivideo->video_vbase; @@ -4242,7 +4240,7 @@ static const unsigned short __devinitconst SiS_DRAMType[17][5] = { {0x09,0x08,0x01,0x01,0x00} }; -static int __devinit +static int sisfb_post_300_rwtest(struct sis_video_info *ivideo, int iteration, int buswidth, int PseudoRankCapacity, int PseudoAdrPinCount, unsigned int mapsize) @@ -4309,7 +4307,7 @@ sisfb_post_300_rwtest(struct sis_video_info *ivideo, int iteration, int buswidth return 0; } -static void __devinit +static void sisfb_post_300_ramsize(struct pci_dev *pdev, unsigned int mapsize) { struct sis_video_info *ivideo = pci_get_drvdata(pdev); @@ -4335,7 +4333,7 @@ sisfb_post_300_ramsize(struct pci_dev *pdev, unsigned int mapsize) } } -static void __devinit +static void sisfb_post_sis300(struct pci_dev *pdev) { struct sis_video_info *ivideo = pci_get_drvdata(pdev); @@ -4547,7 +4545,7 @@ sisfb_post_sis300(struct pci_dev *pdev) #ifdef CONFIG_FB_SIS_315 #if 0 -static void __devinit +static void sisfb_post_sis315330(struct pci_dev *pdev) { /* TODO */ @@ -4559,7 +4557,7 @@ static inline int sisfb_xgi_is21(struct sis_video_info *ivideo) return ivideo->chip_real_id == XGI_21; } -static void __devinit +static void sisfb_post_xgi_delay(struct sis_video_info *ivideo, int delay) { unsigned int i; @@ -4571,7 +4569,7 @@ sisfb_post_xgi_delay(struct sis_video_info *ivideo, int delay) } } -static int __devinit +static int sisfb_find_host_bridge(struct sis_video_info *ivideo, struct pci_dev *mypdev, unsigned short pcivendor) { @@ -4591,7 +4589,7 @@ sisfb_find_host_bridge(struct sis_video_info *ivideo, struct pci_dev *mypdev, return ret; } -static int __devinit +static int sisfb_post_xgi_rwtest(struct sis_video_info *ivideo, int starta, unsigned int enda, unsigned int mapsize) { @@ -4623,7 +4621,7 @@ sisfb_post_xgi_rwtest(struct sis_video_info *ivideo, int starta, return 1; } -static int __devinit +static int sisfb_post_xgi_ramsize(struct sis_video_info *ivideo) { unsigned int buswidth, ranksize, channelab, mapsize; @@ -4876,7 +4874,7 @@ bail_out: return status; } -static void __devinit +static void sisfb_post_xgi_setclocks(struct sis_video_info *ivideo, u8 regb) { u8 v1, v2, v3; @@ -4932,7 +4930,7 @@ sisfb_post_xgi_setclocks(struct sis_video_info *ivideo, u8 regb) sisfb_post_xgi_delay(ivideo, 0x43); } -static void __devinit +static void sisfb_post_xgi_ddr2_mrs_default(struct sis_video_info *ivideo, u8 regb) { unsigned char *bios = ivideo->bios_abase; @@ -4973,7 +4971,7 @@ sisfb_post_xgi_ddr2_mrs_default(struct sis_video_info *ivideo, u8 regb) sisfb_post_xgi_delay(ivideo, 1); } -static void __devinit +static void sisfb_post_xgi_ddr2_mrs_xg21(struct sis_video_info *ivideo) { sisfb_post_xgi_setclocks(ivideo, 1); @@ -5015,7 +5013,7 @@ sisfb_post_xgi_ddr2_mrs_xg21(struct sis_video_info *ivideo) sisfb_post_xgi_delay(ivideo, 1); } -static void __devinit +static void sisfb_post_xgi_ddr2(struct sis_video_info *ivideo, u8 regb) { unsigned char *bios = ivideo->bios_abase; @@ -5061,7 +5059,7 @@ sisfb_post_xgi_ddr2(struct sis_video_info *ivideo, u8 regb) sisfb_post_xgi_ddr2_mrs_default(ivideo, regb); } -static u8 __devinit +static u8 sisfb_post_xgi_ramtype(struct sis_video_info *ivideo) { unsigned char *bios = ivideo->bios_abase; @@ -5101,7 +5099,7 @@ sisfb_post_xgi_ramtype(struct sis_video_info *ivideo) return ramtype; } -static int __devinit +static int sisfb_post_xgi(struct pci_dev *pdev) { struct sis_video_info *ivideo = pci_get_drvdata(pdev); @@ -5839,7 +5837,7 @@ sisfb_post_xgi(struct pci_dev *pdev) } #endif -static int __devinit +static int sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct sisfb_chip_info *chipinfo = &sisfb_chip_info[ent->driver_data]; diff --git a/drivers/video/skeletonfb.c b/drivers/video/skeletonfb.c index ce61d9d..28a38ba 100644 --- a/drivers/video/skeletonfb.c +++ b/drivers/video/skeletonfb.c @@ -678,7 +678,7 @@ static struct fb_ops xxxfb_ops = { */ /* static int __init xxfb_probe (struct platform_device *pdev) -- for platform devs */ -static int __devinit xxxfb_probe(struct pci_dev *dev, +static int xxxfb_probe(struct pci_dev *dev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c index 3690eff..6703712 100644 --- a/drivers/video/sm501fb.c +++ b/drivers/video/sm501fb.c @@ -1664,7 +1664,7 @@ static void sm501fb_stop(struct sm501fb_info *info) resource_size(info->regs_res)); } -static int __devinit sm501fb_init_fb(struct fb_info *fb, +static int sm501fb_init_fb(struct fb_info *fb, enum sm501_controller head, const char *fbname) { @@ -1850,7 +1850,7 @@ static struct sm501_platdata_fb sm501fb_def_pdata = { static char driver_name_crt[] = "sm501fb-crt"; static char driver_name_pnl[] = "sm501fb-panel"; -static int __devinit sm501fb_probe_one(struct sm501fb_info *info, +static int sm501fb_probe_one(struct sm501fb_info *info, enum sm501_controller head) { unsigned char *name = (head == HEAD_CRT) ? "crt" : "panel"; @@ -1892,7 +1892,7 @@ static void sm501_free_init_fb(struct sm501fb_info *info, fb_dealloc_cmap(&fbi->cmap); } -static int __devinit sm501fb_start_one(struct sm501fb_info *info, +static int sm501fb_start_one(struct sm501fb_info *info, enum sm501_controller head, const char *drvname) { @@ -1922,7 +1922,7 @@ static int __devinit sm501fb_start_one(struct sm501fb_info *info, return 0; } -static int __devinit sm501fb_probe(struct platform_device *pdev) +static int sm501fb_probe(struct platform_device *pdev) { struct sm501fb_info *info; struct device *dev = &pdev->dev; diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c index 871e074..c4ce3ef 100644 --- a/drivers/video/sstfb.c +++ b/drivers/video/sstfb.c @@ -822,7 +822,7 @@ static void sstfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect) /* * get lfb size */ -static int __devinit sst_get_memsize(struct fb_info *info, __u32 *memsize) +static int sst_get_memsize(struct fb_info *info, __u32 *memsize) { u8 __iomem *fbbase_virt = info->screen_base; @@ -865,7 +865,7 @@ static int __devinit sst_get_memsize(struct fb_info *info, __u32 *memsize) /* fbi should be idle, and fifo emty and mem disabled */ /* supposed to detect AT&T ATT20C409 and Ti TVP3409 ramdacs */ -static int __devinit sst_detect_att(struct fb_info *info) +static int sst_detect_att(struct fb_info *info) { struct sstfb_par *par = info->par; int i, mir, dir; @@ -890,7 +890,7 @@ static int __devinit sst_detect_att(struct fb_info *info) return 0; } -static int __devinit sst_detect_ti(struct fb_info *info) +static int sst_detect_ti(struct fb_info *info) { struct sstfb_par *par = info->par; int i, mir, dir; @@ -926,7 +926,7 @@ static int __devinit sst_detect_ti(struct fb_info *info) * touched... * is it really safe ? how can i reset this ramdac ? geee... */ -static int __devinit sst_detect_ics(struct fb_info *info) +static int sst_detect_ics(struct fb_info *info) { struct sstfb_par *par = info->par; int m_clk0_1, m_clk0_7, m_clk1_b; @@ -1121,7 +1121,7 @@ static struct dac_switch dacs[] __devinitdata = { .set_vidmod = sst_set_vidmod_ics }, }; -static int __devinit sst_detect_dactype(struct fb_info *info, struct sstfb_par *par) +static int sst_detect_dactype(struct fb_info *info, struct sstfb_par *par) { int i, ret = 0; @@ -1140,7 +1140,7 @@ static int __devinit sst_detect_dactype(struct fb_info *info, struct sstfb_par * /* * Internal Routines */ -static int __devinit sst_init(struct fb_info *info, struct sstfb_par *par) +static int sst_init(struct fb_info *info, struct sstfb_par *par) { u32 fbiinit0, fbiinit1, fbiinit4; struct pci_dev *dev = par->dev; @@ -1271,7 +1271,7 @@ static void __devexit sst_shutdown(struct fb_info *info) /* * Interface to the world */ -static int __devinit sstfb_setup(char *options) +static int sstfb_setup(char *options) { char *this_opt; @@ -1317,7 +1317,7 @@ static struct fb_ops sstfb_ops = { .fb_ioctl = sstfb_ioctl, }; -static int __devinit sstfb_probe(struct pci_dev *pdev, +static int sstfb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct fb_info *info; @@ -1494,7 +1494,7 @@ static struct pci_driver sstfb_driver = { }; -static int __devinit sstfb_init(void) +static int sstfb_init(void) { char *option = NULL; diff --git a/drivers/video/sunxvr1000.c b/drivers/video/sunxvr1000.c index cc9bf5f..9e86e3c 100644 --- a/drivers/video/sunxvr1000.c +++ b/drivers/video/sunxvr1000.c @@ -25,7 +25,7 @@ struct gfb_info { u32 pseudo_palette[16]; }; -static int __devinit gfb_get_props(struct gfb_info *gp) +static int gfb_get_props(struct gfb_info *gp) { gp->width = of_getintprop_default(gp->of_node, "width", 0); gp->height = of_getintprop_default(gp->of_node, "height", 0); @@ -66,7 +66,7 @@ static struct fb_ops gfb_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit gfb_set_fbinfo(struct gfb_info *gp) +static int gfb_set_fbinfo(struct gfb_info *gp) { struct fb_info *info = gp->info; struct fb_var_screeninfo *var = &info->var; @@ -111,7 +111,7 @@ static int __devinit gfb_set_fbinfo(struct gfb_info *gp) return 0; } -static int __devinit gfb_probe(struct platform_device *op) +static int gfb_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/sunxvr2500.c b/drivers/video/sunxvr2500.c index 49bd77a..b6a14d2 100644 --- a/drivers/video/sunxvr2500.c +++ b/drivers/video/sunxvr2500.c @@ -29,7 +29,7 @@ struct s3d_info { u32 pseudo_palette[16]; }; -static int __devinit s3d_get_props(struct s3d_info *sp) +static int s3d_get_props(struct s3d_info *sp) { sp->width = of_getintprop_default(sp->of_node, "width", 0); sp->height = of_getintprop_default(sp->of_node, "height", 0); @@ -70,7 +70,7 @@ static struct fb_ops s3d_ops = { .fb_imageblit = cfb_imageblit, }; -static int __devinit s3d_set_fbinfo(struct s3d_info *sp) +static int s3d_set_fbinfo(struct s3d_info *sp) { struct fb_info *info = sp->info; struct fb_var_screeninfo *var = &info->var; @@ -115,7 +115,7 @@ static int __devinit s3d_set_fbinfo(struct s3d_info *sp) return 0; } -static int __devinit s3d_pci_register(struct pci_dev *pdev, +static int s3d_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) { struct fb_info *info; diff --git a/drivers/video/sunxvr500.c b/drivers/video/sunxvr500.c index e94c799..afcdab1 100644 --- a/drivers/video/sunxvr500.c +++ b/drivers/video/sunxvr500.c @@ -51,7 +51,7 @@ struct e3d_info { u32 pseudo_palette[16]; }; -static int __devinit e3d_get_props(struct e3d_info *ep) +static int e3d_get_props(struct e3d_info *ep) { ep->width = of_getintprop_default(ep->of_node, "width", 0); ep->height = of_getintprop_default(ep->of_node, "height", 0); @@ -193,7 +193,7 @@ static struct fb_ops e3d_ops = { .fb_imageblit = e3d_imageblit, }; -static int __devinit e3d_set_fbinfo(struct e3d_info *ep) +static int e3d_set_fbinfo(struct e3d_info *ep) { struct fb_info *info = ep->info; struct fb_var_screeninfo *var = &info->var; @@ -238,7 +238,7 @@ static int __devinit e3d_set_fbinfo(struct e3d_info *ep) return 0; } -static int __devinit e3d_pci_register(struct pci_dev *pdev, +static int e3d_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) { struct device_node *of_node; diff --git a/drivers/video/tcx.c b/drivers/video/tcx.c index 9f57539..cfdc1bb 100644 --- a/drivers/video/tcx.c +++ b/drivers/video/tcx.c @@ -362,7 +362,7 @@ static void tcx_unmap_regs(struct platform_device *op, struct fb_info *info, info->screen_base, info->fix.smem_len); } -static int __devinit tcx_probe(struct platform_device *op) +static int tcx_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; diff --git a/drivers/video/tdfxfb.c b/drivers/video/tdfxfb.c index bbb0d95..efbf5c9 100644 --- a/drivers/video/tdfxfb.c +++ b/drivers/video/tdfxfb.c @@ -135,7 +135,7 @@ static struct fb_var_screeninfo tdfx_var __devinitdata = { /* * PCI driver prototypes */ -static int __devinit tdfxfb_probe(struct pci_dev *pdev, +static int tdfxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id); static void __devexit tdfxfb_remove(struct pci_dev *pdev); @@ -1279,7 +1279,7 @@ static int tdfxfb_ddc_getsda(void *data) return (0 != (tdfx_inl(par, VIDSERPARPORT) & DDC_SDA_IN)); } -static int __devinit tdfxfb_setup_ddc_bus(struct tdfxfb_i2c_chan *chan, +static int tdfxfb_setup_ddc_bus(struct tdfxfb_i2c_chan *chan, const char *name, struct device *dev) { int rc; @@ -1308,7 +1308,7 @@ static int __devinit tdfxfb_setup_ddc_bus(struct tdfxfb_i2c_chan *chan, return rc; } -static int __devinit tdfxfb_setup_i2c_bus(struct tdfxfb_i2c_chan *chan, +static int tdfxfb_setup_i2c_bus(struct tdfxfb_i2c_chan *chan, const char *name, struct device *dev) { int rc; @@ -1336,7 +1336,7 @@ static int __devinit tdfxfb_setup_i2c_bus(struct tdfxfb_i2c_chan *chan, return rc; } -static void __devinit tdfxfb_create_i2c_busses(struct fb_info *info) +static void tdfxfb_create_i2c_busses(struct fb_info *info) { struct tdfx_par *par = info->par; @@ -1388,7 +1388,7 @@ static int tdfxfb_probe_i2c_connector(struct tdfx_par *par, * Initializes and allocates resources for PCI device @pdev. * */ -static int __devinit tdfxfb_probe(struct pci_dev *pdev, +static int tdfxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id) { struct tdfx_par *default_par; diff --git a/drivers/video/tgafb.c b/drivers/video/tgafb.c index 7333152..63fc5ba 100644 --- a/drivers/video/tgafb.c +++ b/drivers/video/tgafb.c @@ -61,7 +61,7 @@ static void tgafb_fillrect(struct fb_info *, const struct fb_fillrect *); static void tgafb_copyarea(struct fb_info *, const struct fb_copyarea *); static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info); -static int __devinit tgafb_register(struct device *dev); +static int tgafb_register(struct device *dev); static void __devexit tgafb_unregister(struct device *dev); static const char *mode_option; @@ -93,7 +93,7 @@ static struct fb_ops tgafb_ops = { /* * PCI registration operations */ -static int __devinit tgafb_pci_register(struct pci_dev *, +static int tgafb_pci_register(struct pci_dev *, const struct pci_device_id *); static void __devexit tgafb_pci_unregister(struct pci_dev *); @@ -110,7 +110,7 @@ static struct pci_driver tgafb_pci_driver = { .remove = tgafb_pci_unregister, }; -static int __devinit +static int tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent) { return tgafb_register(&pdev->dev); @@ -127,7 +127,7 @@ tgafb_pci_unregister(struct pci_dev *pdev) /* * TC registration operations */ -static int __devinit tgafb_tc_register(struct device *); +static int tgafb_tc_register(struct device *); static int __devexit tgafb_tc_unregister(struct device *); static struct tc_device_id const tgafb_tc_table[] = { @@ -147,7 +147,7 @@ static struct tc_driver tgafb_tc_driver = { }, }; -static int __devinit +static int tgafb_tc_register(struct device *dev) { int status = tgafb_register(dev); @@ -1546,7 +1546,7 @@ static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info return 0; } -static int __devinit +static int tgafb_register(struct device *dev) { static const struct fb_videomode modedb_tc = { @@ -1729,7 +1729,7 @@ tgafb_exit(void) } #ifndef MODULE -static int __devinit +static int tgafb_setup(char *arg) { char *this_opt; @@ -1751,7 +1751,7 @@ tgafb_setup(char *arg) } #endif /* !MODULE */ -static int __devinit +static int tgafb_init(void) { int status; diff --git a/drivers/video/tmiofb.c b/drivers/video/tmiofb.c index 7c8133e..3f7527a 100644 --- a/drivers/video/tmiofb.c +++ b/drivers/video/tmiofb.c @@ -675,7 +675,7 @@ static struct fb_ops tmiofb_ops = { /*--------------------------------------------------------------------------*/ -static int __devinit tmiofb_probe(struct platform_device *dev) +static int tmiofb_probe(struct platform_device *dev) { const struct mfd_cell *cell = mfd_get_cell(dev); struct tmio_fb_data *data = dev->dev.platform_data; diff --git a/drivers/video/tridentfb.c b/drivers/video/tridentfb.c index a3f207b..f1a8495 100644 --- a/drivers/video/tridentfb.c +++ b/drivers/video/tridentfb.c @@ -637,7 +637,7 @@ static inline void crtc_unlock(struct tridentfb_par *par) } /* Return flat panel's maximum x resolution */ -static int __devinit get_nativex(struct tridentfb_par *par) +static int get_nativex(struct tridentfb_par *par) { int x, y, tmp; @@ -771,7 +771,7 @@ static void set_number_of_lines(struct tridentfb_par *par, int lines) * If we see that FP is active we assume we have one. * Otherwise we have a CRT display. User can override. */ -static int __devinit is_flatpanel(struct tridentfb_par *par) +static int is_flatpanel(struct tridentfb_par *par) { if (fp) return 1; @@ -781,7 +781,7 @@ static int __devinit is_flatpanel(struct tridentfb_par *par) } /* Try detecting the video memory size */ -static unsigned int __devinit get_memsize(struct tridentfb_par *par) +static unsigned int get_memsize(struct tridentfb_par *par) { unsigned char tmp, tmp2; unsigned int k; @@ -1331,7 +1331,7 @@ static struct fb_ops tridentfb_ops = { .fb_sync = tridentfb_sync, }; -static int __devinit trident_pci_probe(struct pci_dev *dev, +static int trident_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { int err; diff --git a/drivers/video/uvesafb.c b/drivers/video/uvesafb.c index 2f8f82d..a776c8e 100644 --- a/drivers/video/uvesafb.c +++ b/drivers/video/uvesafb.c @@ -418,7 +418,7 @@ static void uvesafb_vbe_state_restore(struct uvesafb_par *par, u8 *state_buf) uvesafb_free(task); } -static int __devinit uvesafb_vbe_getinfo(struct uvesafb_ktask *task, +static int uvesafb_vbe_getinfo(struct uvesafb_ktask *task, struct uvesafb_par *par) { int err; @@ -477,7 +477,7 @@ static int __devinit uvesafb_vbe_getinfo(struct uvesafb_ktask *task, return 0; } -static int __devinit uvesafb_vbe_getmodes(struct uvesafb_ktask *task, +static int uvesafb_vbe_getmodes(struct uvesafb_ktask *task, struct uvesafb_par *par) { int off = 0, err; @@ -556,7 +556,7 @@ static int __devinit uvesafb_vbe_getmodes(struct uvesafb_ktask *task, * x86 and not x86_64. */ #ifdef CONFIG_X86_32 -static int __devinit uvesafb_vbe_getpmi(struct uvesafb_ktask *task, +static int uvesafb_vbe_getpmi(struct uvesafb_ktask *task, struct uvesafb_par *par) { int i, err; @@ -602,7 +602,7 @@ static int __devinit uvesafb_vbe_getpmi(struct uvesafb_ktask *task, * Check whether a video mode is supported by the Video BIOS and is * compatible with the monitor limits. */ -static int __devinit uvesafb_is_valid_mode(struct fb_videomode *mode, +static int uvesafb_is_valid_mode(struct fb_videomode *mode, struct fb_info *info) { if (info->monspecs.gtf) { @@ -618,7 +618,7 @@ static int __devinit uvesafb_is_valid_mode(struct fb_videomode *mode, return 1; } -static int __devinit uvesafb_vbe_getedid(struct uvesafb_ktask *task, +static int uvesafb_vbe_getedid(struct uvesafb_ktask *task, struct fb_info *info) { struct uvesafb_par *par = info->par; @@ -684,7 +684,7 @@ static int __devinit uvesafb_vbe_getedid(struct uvesafb_ktask *task, return err; } -static void __devinit uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task, +static void uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task, struct fb_info *info) { struct uvesafb_par *par = info->par; @@ -765,7 +765,7 @@ static void __devinit uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task, return; } -static void __devinit uvesafb_vbe_getstatesize(struct uvesafb_ktask *task, +static void uvesafb_vbe_getstatesize(struct uvesafb_ktask *task, struct uvesafb_par *par) { int err; @@ -794,7 +794,7 @@ static void __devinit uvesafb_vbe_getstatesize(struct uvesafb_ktask *task, par->vbe_state_size = 64 * (task->t.regs.ebx & 0xffff); } -static int __devinit uvesafb_vbe_init(struct fb_info *info) +static int uvesafb_vbe_init(struct fb_info *info) { struct uvesafb_ktask *task = NULL; struct uvesafb_par *par = info->par; @@ -839,7 +839,7 @@ out: uvesafb_free(task); return err; } -static int __devinit uvesafb_vbe_init_mode(struct fb_info *info) +static int uvesafb_vbe_init_mode(struct fb_info *info) { struct list_head *pos; struct fb_modelist *modelist; @@ -1444,7 +1444,7 @@ static struct fb_ops uvesafb_ops = { .fb_set_par = uvesafb_set_par, }; -static void __devinit uvesafb_init_info(struct fb_info *info, +static void uvesafb_init_info(struct fb_info *info, struct vbe_mode_ib *mode) { unsigned int size_vmode; @@ -1540,7 +1540,7 @@ static void __devinit uvesafb_init_info(struct fb_info *info, info->fbops->fb_pan_display = NULL; } -static void __devinit uvesafb_init_mtrr(struct fb_info *info) +static void uvesafb_init_mtrr(struct fb_info *info) { #ifdef CONFIG_MTRR if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) { @@ -1582,7 +1582,7 @@ static void __devinit uvesafb_init_mtrr(struct fb_info *info) #endif /* CONFIG_MTRR */ } -static void __devinit uvesafb_ioremap(struct fb_info *info) +static void uvesafb_ioremap(struct fb_info *info) { #ifdef CONFIG_X86 switch (mtrr) { @@ -1738,7 +1738,7 @@ static struct attribute_group uvesafb_dev_attgrp = { .attrs = uvesafb_dev_attrs, }; -static int __devinit uvesafb_probe(struct platform_device *dev) +static int uvesafb_probe(struct platform_device *dev) { struct fb_info *info; struct vbe_mode_ib *mode = NULL; @@ -1882,7 +1882,7 @@ static struct platform_driver uvesafb_driver = { static struct platform_device *uvesafb_device; #ifndef MODULE -static int __devinit uvesafb_setup(char *options) +static int uvesafb_setup(char *options) { char *this_opt; @@ -1950,7 +1950,7 @@ static ssize_t store_v86d(struct device_driver *dev, const char *buf, static DRIVER_ATTR(v86d, S_IRUGO | S_IWUSR, show_v86d, store_v86d); -static int __devinit uvesafb_init(void) +static int uvesafb_init(void) { int err; diff --git a/drivers/video/vermilion/vermilion.c b/drivers/video/vermilion/vermilion.c index a2bacf8..3e92d0e 100644 --- a/drivers/video/vermilion/vermilion.c +++ b/drivers/video/vermilion/vermilion.c @@ -452,7 +452,7 @@ static void vmlfb_set_pref_pixel_format(struct fb_var_screeninfo *var) * struct per pipe. Currently we have only one pipe. */ -static int __devinit vml_pci_probe(struct pci_dev *dev, +static int vml_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct vml_info *vinfo; diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c index c7f69252..f4cb015 100644 --- a/drivers/video/vfb.c +++ b/drivers/video/vfb.c @@ -477,7 +477,7 @@ static int __init vfb_setup(char *options) * Initialisation */ -static int __devinit vfb_probe(struct platform_device *dev) +static int vfb_probe(struct platform_device *dev) { struct fb_info *info; int retval = -ENOMEM; diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c index 1ab146a..0e53f39 100644 --- a/drivers/video/vga16fb.c +++ b/drivers/video/vga16fb.c @@ -1303,7 +1303,7 @@ static int __init vga16fb_setup(char *options) } #endif -static int __devinit vga16fb_probe(struct platform_device *dev) +static int vga16fb_probe(struct platform_device *dev) { struct fb_info *info; struct vga16fb_par *par; diff --git a/drivers/video/via/dvi.c b/drivers/video/via/dvi.c index 6be72f0..1c9b68c 100644 --- a/drivers/video/via/dvi.c +++ b/drivers/video/via/dvi.c @@ -25,7 +25,7 @@ static void tmds_register_write(int index, u8 data); static int tmds_register_read(int index); static int tmds_register_read_bytes(int index, u8 *buff, int buff_len); -static void __devinit dvi_get_panel_size_from_DDCv1( +static void dvi_get_panel_size_from_DDCv1( struct tmds_chip_information *tmds_chip, struct tmds_setting_information *tmds_setting); static int viafb_dvi_query_EDID(void); @@ -35,7 +35,7 @@ static inline bool check_tmds_chip(int device_id_subaddr, int device_id) return tmds_register_read(device_id_subaddr) == device_id; } -void __devinit viafb_init_dvi_size(struct tmds_chip_information *tmds_chip, +void viafb_init_dvi_size(struct tmds_chip_information *tmds_chip, struct tmds_setting_information *tmds_setting) { DEBUG_MSG(KERN_INFO "viafb_init_dvi_size()\n"); @@ -47,7 +47,7 @@ void __devinit viafb_init_dvi_size(struct tmds_chip_information *tmds_chip, return; } -bool __devinit viafb_tmds_trasmitter_identify(void) +bool viafb_tmds_trasmitter_identify(void) { unsigned char sr2a = 0, sr1e = 0, sr3e = 0; @@ -285,7 +285,7 @@ static int viafb_dvi_query_EDID(void) } /* Get Panel Size Using EDID1 Table */ -static void __devinit dvi_get_panel_size_from_DDCv1( +static void dvi_get_panel_size_from_DDCv1( struct tmds_chip_information *tmds_chip, struct tmds_setting_information *tmds_setting) { diff --git a/drivers/video/via/dvi.h b/drivers/video/via/dvi.h index db75785..4c6bfba 100644 --- a/drivers/video/via/dvi.h +++ b/drivers/video/via/dvi.h @@ -56,8 +56,8 @@ int viafb_dvi_sense(void); void viafb_dvi_disable(void); void viafb_dvi_enable(void); -bool __devinit viafb_tmds_trasmitter_identify(void); -void __devinit viafb_init_dvi_size(struct tmds_chip_information *tmds_chip, +bool viafb_tmds_trasmitter_identify(void); +void viafb_init_dvi_size(struct tmds_chip_information *tmds_chip, struct tmds_setting_information *tmds_setting); void viafb_dvi_set_mode(const struct fb_var_screeninfo *var, u16 cxres, u16 cyres, int iga); diff --git a/drivers/video/via/hw.c b/drivers/video/via/hw.c index 898590d..80233da 100644 --- a/drivers/video/via/hw.c +++ b/drivers/video/via/hw.c @@ -465,9 +465,9 @@ static struct via_device_mapping device_mapping[] = { static struct via_clock clock; static void load_fix_bit_crtc_reg(void); -static void __devinit init_gfx_chip_info(int chip_type); -static void __devinit init_tmds_chip_info(void); -static void __devinit init_lvds_chip_info(void); +static void init_gfx_chip_info(int chip_type); +static void init_tmds_chip_info(void); +static void init_lvds_chip_info(void); static void device_screen_off(void); static void device_screen_on(void); static void set_display_channel(void); @@ -1507,7 +1507,7 @@ void viafb_fill_crtc_timing(const struct fb_var_screeninfo *var, viafb_set_vclock(PICOS2KHZ(var->pixclock) * 1000, iga); } -void __devinit viafb_init_chip_info(int chip_type) +void viafb_init_chip_info(int chip_type) { via_clock_init(&clock, chip_type); init_gfx_chip_info(chip_type); @@ -1540,7 +1540,7 @@ void viafb_update_device_setting(int hres, int vres, int bpp, int flag) } } -static void __devinit init_gfx_chip_info(int chip_type) +static void init_gfx_chip_info(int chip_type) { u8 tmp; @@ -1593,7 +1593,7 @@ static void __devinit init_gfx_chip_info(int chip_type) } } -static void __devinit init_tmds_chip_info(void) +static void init_tmds_chip_info(void) { viafb_tmds_trasmitter_identify(); @@ -1638,7 +1638,7 @@ static void __devinit init_tmds_chip_info(void) &viaparinfo->shared->tmds_setting_info); } -static void __devinit init_lvds_chip_info(void) +static void init_lvds_chip_info(void) { viafb_lvds_trasmitter_identify(); viafb_init_lcd_size(); @@ -1672,7 +1672,7 @@ static void __devinit init_lvds_chip_info(void) viaparinfo->chip_info->lvds_chip_info.output_interface); } -void __devinit viafb_init_dac(int set_iga) +void viafb_init_dac(int set_iga) { int i; u8 tmp; diff --git a/drivers/video/via/hw.h b/drivers/video/via/hw.h index 6be243c..a820575 100644 --- a/drivers/video/via/hw.h +++ b/drivers/video/via/hw.h @@ -663,8 +663,8 @@ void viafb_set_dpa_gfx(int output_interface, struct GFX_DPA_SETTING\ int viafb_setmode(void); void viafb_fill_var_timing_info(struct fb_var_screeninfo *var, const struct fb_videomode *mode); -void __devinit viafb_init_chip_info(int chip_type); -void __devinit viafb_init_dac(int set_iga); +void viafb_init_chip_info(int chip_type); +void viafb_init_dac(int set_iga); int viafb_get_refresh(int hres, int vres, u32 float_refresh); void viafb_update_device_setting(int hres, int vres, int bpp, int flag); diff --git a/drivers/video/via/lcd.c b/drivers/video/via/lcd.c index 1650379..980ee1b 100644 --- a/drivers/video/via/lcd.c +++ b/drivers/video/via/lcd.c @@ -49,7 +49,7 @@ static struct _lcd_scaling_factor lcd_scaling_factor_CLE = { }; static bool lvds_identify_integratedlvds(void); -static void __devinit fp_id_to_vindex(int panel_id); +static void fp_id_to_vindex(int panel_id); static int lvds_register_read(int index); static void load_lcd_scaling(int set_hres, int set_vres, int panel_hres, int panel_vres); @@ -81,7 +81,7 @@ static inline bool check_lvds_chip(int device_id_subaddr, int device_id) return lvds_register_read(device_id_subaddr) == device_id; } -void __devinit viafb_init_lcd_size(void) +void viafb_init_lcd_size(void) { DEBUG_MSG(KERN_INFO "viafb_init_lcd_size()\n"); @@ -139,7 +139,7 @@ static bool lvds_identify_integratedlvds(void) return true; } -bool __devinit viafb_lvds_trasmitter_identify(void) +bool viafb_lvds_trasmitter_identify(void) { if (viafb_lvds_identify_vt1636(VIA_PORT_31)) { viaparinfo->chip_info->lvds_chip_info.i2c_port = VIA_PORT_31; @@ -180,7 +180,7 @@ bool __devinit viafb_lvds_trasmitter_identify(void) return false; } -static void __devinit fp_id_to_vindex(int panel_id) +static void fp_id_to_vindex(int panel_id) { DEBUG_MSG(KERN_INFO "fp_get_panel_id()\n"); @@ -914,7 +914,7 @@ static void check_diport_of_integrated_lvds( plvds_chip_info->output_interface); } -void __devinit viafb_init_lvds_output_interface(struct lvds_chip_information +void viafb_init_lvds_output_interface(struct lvds_chip_information *plvds_chip_info, struct lvds_setting_information *plvds_setting_info) diff --git a/drivers/video/via/lcd.h b/drivers/video/via/lcd.h index 8f3e4e0..5c988a0 100644 --- a/drivers/video/via/lcd.h +++ b/drivers/video/via/lcd.h @@ -71,15 +71,15 @@ void viafb_enable_lvds_vt1636(struct lvds_setting_information struct lvds_chip_information *plvds_chip_info); void viafb_lcd_disable(void); void viafb_lcd_enable(void); -void __devinit viafb_init_lcd_size(void); -void __devinit viafb_init_lvds_output_interface(struct lvds_chip_information +void viafb_init_lcd_size(void); +void viafb_init_lvds_output_interface(struct lvds_chip_information *plvds_chip_info, struct lvds_setting_information *plvds_setting_info); void viafb_lcd_set_mode(const struct fb_var_screeninfo *var, u16 cxres, u16 cyres, struct lvds_setting_information *plvds_setting_info, struct lvds_chip_information *plvds_chip_info); -bool __devinit viafb_lvds_trasmitter_identify(void); +bool viafb_lvds_trasmitter_identify(void); void viafb_init_lvds_output_interface(struct lvds_chip_information *plvds_chip_info, struct lvds_setting_information diff --git a/drivers/video/via/via-core.c b/drivers/video/via/via-core.c index 29b3af8..abbcb1b 100644 --- a/drivers/video/via/via-core.c +++ b/drivers/video/via/via-core.c @@ -80,7 +80,7 @@ static inline int viafb_mmio_read(int reg) */ static u32 viafb_enabled_ints; -static void __devinit viafb_int_init(void) +static void viafb_int_init(void) { viafb_enabled_ints = 0; @@ -475,7 +475,7 @@ static int viafb_get_fb_size_from_pci(int chip_type) /* * Figure out and map our MMIO regions. */ -static int __devinit via_pci_setup_mmio(struct viafb_dev *vdev) +static int via_pci_setup_mmio(struct viafb_dev *vdev) { int ret; /* @@ -550,7 +550,7 @@ static struct viafb_subdev_info { }; #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs) -static int __devinit via_create_subdev(struct viafb_dev *vdev, +static int via_create_subdev(struct viafb_dev *vdev, struct viafb_subdev_info *info) { int ret; @@ -573,7 +573,7 @@ static int __devinit via_create_subdev(struct viafb_dev *vdev, return ret; } -static int __devinit via_setup_subdevs(struct viafb_dev *vdev) +static int via_setup_subdevs(struct viafb_dev *vdev) { int i; @@ -671,7 +671,7 @@ static int via_resume(struct pci_dev *pdev) } #endif /* CONFIG_PM */ -static int __devinit via_pci_probe(struct pci_dev *pdev, +static int via_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { int ret; diff --git a/drivers/video/via/via-gpio.c b/drivers/video/via/via-gpio.c index d69cfef..e408679 100644 --- a/drivers/video/via/via-gpio.c +++ b/drivers/video/via/via-gpio.c @@ -212,7 +212,7 @@ EXPORT_SYMBOL_GPL(viafb_gpio_lookup); /* * Platform device stuff. */ -static __devinit int viafb_gpio_probe(struct platform_device *platdev) +static int viafb_gpio_probe(struct platform_device *platdev) { struct viafb_dev *vdev = platdev->dev.platform_data; struct via_port_cfg *port_cfg = vdev->port_cfg; diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c index c80e770..bb41017 100644 --- a/drivers/video/via/viafbdev.c +++ b/drivers/video/via/viafbdev.c @@ -1072,7 +1072,7 @@ static int __init parse_active_dev(void) return 0; } -static int __devinit parse_port(char *opt_str, int *output_interface) +static int parse_port(char *opt_str, int *output_interface) { if (!strncmp(opt_str, "DVP0", 4)) *output_interface = INTERFACE_DVP0; @@ -1089,7 +1089,7 @@ static int __devinit parse_port(char *opt_str, int *output_interface) return 0; } -static void __devinit parse_lcd_port(void) +static void parse_lcd_port(void) { parse_port(viafb_lcd_port, &viaparinfo->chip_info->lvds_chip_info. output_interface); @@ -1102,7 +1102,7 @@ static void __devinit parse_lcd_port(void) output_interface); } -static void __devinit parse_dvi_port(void) +static void parse_dvi_port(void) { parse_port(viafb_dvi_port, &viaparinfo->chip_info->tmds_chip_info. output_interface); @@ -1727,7 +1727,7 @@ static struct viafb_pm_hooks viafb_fb_pm_hooks = { #endif -static void __devinit i2c_bus_probe(struct viafb_shared *shared) +static void i2c_bus_probe(struct viafb_shared *shared) { /* should be always CRT */ printk(KERN_INFO "viafb: Probing I2C bus 0x26\n"); @@ -1753,7 +1753,7 @@ static void i2c_bus_free(struct viafb_shared *shared) via_aux_free(shared->i2c_2C); } -int __devinit via_fb_pci_probe(struct viafb_dev *vdev) +int via_fb_pci_probe(struct viafb_dev *vdev) { u32 default_xres, default_yres; struct fb_var_screeninfo default_var; diff --git a/drivers/video/vt8500lcdfb.c b/drivers/video/vt8500lcdfb.c index 22063bb..1b94610 100644 --- a/drivers/video/vt8500lcdfb.c +++ b/drivers/video/vt8500lcdfb.c @@ -273,7 +273,7 @@ static irqreturn_t vt8500lcd_handle_irq(int irq, void *dev_id) return IRQ_HANDLED; } -static int __devinit vt8500lcd_probe(struct platform_device *pdev) +static int vt8500lcd_probe(struct platform_device *pdev) { struct vt8500lcd_info *fbi; struct resource *res; diff --git a/drivers/video/vt8623fb.c b/drivers/video/vt8623fb.c index f0bce7a..c23c8c7 100644 --- a/drivers/video/vt8623fb.c +++ b/drivers/video/vt8623fb.c @@ -660,7 +660,7 @@ static struct fb_ops vt8623fb_ops = { /* PCI probe */ -static int __devinit vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) +static int vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct pci_bus_region bus_reg; struct resource vga_res; diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c index 614e1bd..1c2eaf2 100644 --- a/drivers/video/w100fb.c +++ b/drivers/video/w100fb.c @@ -54,7 +54,7 @@ static void w100_update_enable(void); static void w100_update_disable(void); static void calc_hsync(struct w100fb_par *par); static void w100_init_graphic_engine(struct w100fb_par *par); -struct w100_pll_info *w100_get_xtal_table(unsigned int freq) __devinit; +struct w100_pll_info *w100_get_xtal_table(unsigned int freq); /* Pseudo palette size */ #define MAX_PALETTES 16 @@ -630,7 +630,7 @@ static int w100fb_resume(struct platform_device *dev) #endif -int __devinit w100fb_probe(struct platform_device *pdev) +int w100fb_probe(struct platform_device *pdev) { int err = -EIO; struct w100fb_mach_info *inf; @@ -1021,7 +1021,7 @@ static struct pll_entries { { 0 }, }; -struct w100_pll_info __devinit *w100_get_xtal_table(unsigned int freq) +struct w100_pll_info *w100_get_xtal_table(unsigned int freq) { struct pll_entries *pll_entry = w100_pll_tables; diff --git a/drivers/video/wm8505fb.c b/drivers/video/wm8505fb.c index 5c126af..456694a 100644 --- a/drivers/video/wm8505fb.c +++ b/drivers/video/wm8505fb.c @@ -260,7 +260,7 @@ static struct fb_ops wm8505fb_ops = { .fb_blank = wm8505fb_blank, }; -static int __devinit wm8505fb_probe(struct platform_device *pdev) +static int wm8505fb_probe(struct platform_device *pdev) { struct wm8505fb_info *fbi; struct resource *res; diff --git a/drivers/video/wmt_ge_rops.c b/drivers/video/wmt_ge_rops.c index 46b7a09..e65361d 100644 --- a/drivers/video/wmt_ge_rops.c +++ b/drivers/video/wmt_ge_rops.c @@ -124,7 +124,7 @@ int wmt_ge_sync(struct fb_info *p) } EXPORT_SYMBOL_GPL(wmt_ge_sync); -static int __devinit wmt_ge_rops_probe(struct platform_device *pdev) +static int wmt_ge_rops_probe(struct platform_device *pdev) { struct resource *res; diff --git a/drivers/video/xen-fbfront.c b/drivers/video/xen-fbfront.c index 917bb56..ee44be8 100644 --- a/drivers/video/xen-fbfront.c +++ b/drivers/video/xen-fbfront.c @@ -358,7 +358,7 @@ static irqreturn_t xenfb_event_handler(int rq, void *dev_id) return IRQ_HANDLED; } -static int __devinit xenfb_probe(struct xenbus_device *dev, +static int xenfb_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { struct xenfb_info *info; @@ -487,7 +487,7 @@ error: return ret; } -static __devinit void +static void xenfb_make_preferred_console(void) { struct console *c; diff --git a/drivers/video/xilinxfb.c b/drivers/video/xilinxfb.c index 20a7c0e..b5d317c 100644 --- a/drivers/video/xilinxfb.c +++ b/drivers/video/xilinxfb.c @@ -403,7 +403,7 @@ static int xilinxfb_release(struct device *dev) * OF bus binding */ -static int __devinit xilinxfb_of_probe(struct platform_device *op) +static int xilinxfb_of_probe(struct platform_device *op) { const u32 *prop; u32 *p; -- 1.8.0 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Nov 20 14:22:28 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 20 Nov 2012 14:22:28 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaoiM-0005ll-Tx; Tue, 20 Nov 2012 14:22:15 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TaoiJ-0005kp-Tt for xen-devel@lists.xen.org; Tue, 20 Nov 2012 14:22:12 +0000 Received: from [85.158.138.51:6120] by server-12.bemta-3.messagelabs.com id 9C/15-22757-3129BA05; Tue, 20 Nov 2012 14:22:11 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-6.tower-174.messagelabs.com!1353421321!22741365!1 X-Originating-IP: [128.244.251.37] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UNPARSEABLE_RELAY,UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 20605 invoked from network); 20 Nov 2012 14:22:03 -0000 Received: from piper.jhuapl.edu (HELO jhuapl.edu) (128.244.251.37) by server-6.tower-174.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 20 Nov 2012 14:22:03 -0000 Received: from ([128.244.206.185]) by piper.jhuapl.edu with ESMTP with TLS id 5Y8HCH1.149572011; Tue, 20 Nov 2012 09:21:53 -0500 From: Matthew Fioravante To: xen-devel@lists.xen.org, Ian.Campbell@citrix.com Date: Tue, 20 Nov 2012 09:21:09 -0500 Message-Id: <1353421272-24797-2-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1353421272-24797-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1353421272-24797-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [PATCH VTPM v4 2/5] add stubdom/vtpmmgr code 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 Add the code base for vtpmmgrdom. Makefile changes next patch. Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell --- stubdom/vtpmmgr/Makefile | 32 ++ stubdom/vtpmmgr/init.c | 553 +++++++++++++++++++++ stubdom/vtpmmgr/log.c | 151 ++++++ stubdom/vtpmmgr/log.h | 85 ++++ stubdom/vtpmmgr/marshal.h | 528 ++++++++++++++++++++ stubdom/vtpmmgr/minios.cfg | 14 + stubdom/vtpmmgr/tcg.h | 707 +++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.c | 938 ++++++++++++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.h | 218 +++++++++ stubdom/vtpmmgr/tpmrsa.c | 175 +++++++ stubdom/vtpmmgr/tpmrsa.h | 67 +++ stubdom/vtpmmgr/uuid.h | 50 ++ stubdom/vtpmmgr/vtpm_cmd_handler.c | 152 ++++++ stubdom/vtpmmgr/vtpm_manager.h | 64 +++ stubdom/vtpmmgr/vtpm_storage.c | 794 ++++++++++++++++++++++++++++++ stubdom/vtpmmgr/vtpm_storage.h | 68 +++ stubdom/vtpmmgr/vtpmmgr.c | 93 ++++ stubdom/vtpmmgr/vtpmmgr.h | 77 +++ 18 files changed, 4766 insertions(+) create mode 100644 stubdom/vtpmmgr/Makefile create mode 100644 stubdom/vtpmmgr/init.c create mode 100644 stubdom/vtpmmgr/log.c create mode 100644 stubdom/vtpmmgr/log.h create mode 100644 stubdom/vtpmmgr/marshal.h create mode 100644 stubdom/vtpmmgr/minios.cfg create mode 100644 stubdom/vtpmmgr/tcg.h create mode 100644 stubdom/vtpmmgr/tpm.c create mode 100644 stubdom/vtpmmgr/tpm.h create mode 100644 stubdom/vtpmmgr/tpmrsa.c create mode 100644 stubdom/vtpmmgr/tpmrsa.h create mode 100644 stubdom/vtpmmgr/uuid.h create mode 100644 stubdom/vtpmmgr/vtpm_cmd_handler.c create mode 100644 stubdom/vtpmmgr/vtpm_manager.h create mode 100644 stubdom/vtpmmgr/vtpm_storage.c create mode 100644 stubdom/vtpmmgr/vtpm_storage.h create mode 100644 stubdom/vtpmmgr/vtpmmgr.c create mode 100644 stubdom/vtpmmgr/vtpmmgr.h diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile new file mode 100644 index 0000000..88c83c3 --- /dev/null +++ b/stubdom/vtpmmgr/Makefile @@ -0,0 +1,32 @@ +# 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. +# + +XEN_ROOT=../.. + +PSSL_DIR=../polarssl-$(XEN_TARGET_ARCH)/library +PSSL_OBJS=aes.o sha1.o entropy.o ctr_drbg.o bignum.o sha4.o havege.o timing.o entropy_poll.o + +TARGET=vtpmmgr.a +OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o + +CFLAGS+=-Werror -Iutil -Icrypto -Itcs +CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label + +build: $(TARGET) +$(TARGET): $(OBJS) + ar -rcs $@ $^ $(foreach obj,$(PSSL_OBJS),$(PSSL_DIR)/$(obj)) + +clean: + rm -f $(TARGET) $(OBJS) + +distclean: clean + +.PHONY: clean distclean diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c new file mode 100644 index 0000000..a158020 --- /dev/null +++ b/stubdom/vtpmmgr/init.c @@ -0,0 +1,553 @@ +/* + * 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. +*/ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_storage.h" +#include "tpm.h" +#include "marshal.h" + +struct Opts { + enum { + TPMDRV_TPM_TIS, + TPMDRV_TPMFRONT, + } tpmdriver; + unsigned long tpmiomem; + unsigned int tpmirq; + unsigned int tpmlocality; + int gen_owner_auth; +}; + +// --------------------------- Well Known Auths -------------------------- +const TPM_AUTHDATA WELLKNOWN_SRK_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 } +}; + +static int tpm_entropy_source(void* dummy, unsigned char* data, size_t len, size_t* olen) { + UINT32 sz = len; + TPM_RESULT rc = TPM_GetRandom(&sz, data); + *olen = sz; + return rc == TPM_SUCCESS ? 0 : POLARSSL_ERR_ENTROPY_SOURCE_FAILED; +} + +static TPM_RESULT check_tpm_version(void) { + TPM_RESULT status; + UINT32 rsize; + BYTE* res = NULL; + TPM_CAP_VERSION_INFO vinfo; + + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_VERSION_VAL, + 0, + NULL, + &rsize, + &res)); + if(rsize < 4) { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid size returned by GetCapability!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + unpack_TPM_CAP_VERSION_INFO(res, &vinfo, UNPACK_ALIAS); + + vtpmloginfo(VTPM_LOG_VTPM, "Hardware TPM:\n"); + vtpmloginfo(VTPM_LOG_VTPM, " version: %hhd %hhd %hhd %hhd\n", + vinfo.version.major, vinfo.version.minor, vinfo.version.revMajor, vinfo.version.revMinor); + vtpmloginfo(VTPM_LOG_VTPM, " specLevel: %hd\n", vinfo.specLevel); + vtpmloginfo(VTPM_LOG_VTPM, " errataRev: %hhd\n", vinfo.errataRev); + vtpmloginfo(VTPM_LOG_VTPM, " vendorID: %c%c%c%c\n", + vinfo.tpmVendorID[0], vinfo.tpmVendorID[1], + vinfo.tpmVendorID[2], vinfo.tpmVendorID[3]); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecificSize: %hd\n", vinfo.vendorSpecificSize); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecific: "); + for(int i = 0; i < vinfo.vendorSpecificSize; ++i) { + vtpmloginfomore(VTPM_LOG_VTPM, "%02hhx", vinfo.vendorSpecific[i]); + } + vtpmloginfomore(VTPM_LOG_VTPM, "\n"); + +abort_egress: + free(res); + return status; +} + +static TPM_RESULT flush_tpm(void) { + TPM_RESULT status = TPM_SUCCESS; + const TPM_RESOURCE_TYPE reslist[] = { TPM_RT_KEY, TPM_RT_AUTH, TPM_RT_TRANS, TPM_RT_COUNTER, TPM_RT_DAA_TPM, TPM_RT_CONTEXT }; + BYTE* keylist = NULL; + UINT32 keylistSize; + BYTE* ptr; + + //Iterate through each resource type and flush all handles + for(int i = 0; i < sizeof(reslist) / sizeof(TPM_RESOURCE_TYPE); ++i) { + TPM_RESOURCE_TYPE beres = cpu_to_be32(reslist[i]); + UINT16 size; + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_HANDLE, + sizeof(TPM_RESOURCE_TYPE), + (BYTE*)(&beres), + &keylistSize, + &keylist)); + + ptr = keylist; + ptr = unpack_UINT16(ptr, &size); + + //Flush each handle + if(size) { + vtpmloginfo(VTPM_LOG_VTPM, "Flushing %u handle(s) of type %lu\n", size, (unsigned long) reslist[i]); + for(int j = 0; j < size; ++j) { + TPM_HANDLE h; + ptr = unpack_TPM_HANDLE(ptr, &h); + TPMTRYRETURN(TPM_FlushSpecific(h, reslist[i])); + } + } + + free(keylist); + keylist = NULL; + } + + goto egress; +abort_egress: + free(keylist); +egress: + return status; +} + + +static TPM_RESULT try_take_ownership(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_PUBKEY pubEK = TPM_PUBKEY_INIT; + + // If we can read PubEK then there is no owner and we should take it. + status = TPM_ReadPubek(&pubEK); + + switch(status) { + case TPM_DISABLED_CMD: + //Cannot read ek? TPM has owner + vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); + status = TPM_SUCCESS; + break; + case TPM_NO_ENDORSEMENT: + { + //If theres no ek, we have to create one + TPM_KEY_PARMS keyInfo = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }; + TPMTRYRETURN(TPM_CreateEndorsementKeyPair(&keyInfo, &pubEK)); + } + //fall through to take ownership + case TPM_SUCCESS: + { + //Construct the Srk + TPM_KEY srk = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_STORAGE, + .keyFlags = 0x00, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey = { + .keyLength = 0, + .key = NULL, + }, + .encDataSize = 0, + }; + + TPMTRYRETURN(TPM_TakeOwnership( + &pubEK, + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &srk, + NULL, + &vtpm_globals.oiap)); + + TPMTRYRETURN(TPM_DisablePubekRead( + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + &vtpm_globals.oiap)); + } + break; + default: + break; + } +abort_egress: + free_TPM_PUBKEY(&pubEK); + 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) { + 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; + } + /* owner auth is a raw hash */ + else if(!strncmp(authstr, "hash:", 5)) { + authstr += 5; + if((rc = strlen(authstr)) != 40) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth hex string `%s' must be exactly 40 characters (20 bytes) long, length=%d\n", authstr, rc); + return -1; + } + for(int j = 0; j < 20; ++j) { + if(sscanf(authstr, "%hhX", target + j) != 1) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth string `%s' is not a valid hex string\n", authstr); + return -1; + } + authstr += 2; + } + } + /* owner auth is a string that will be hashed */ + else if(!strncmp(authstr, "text:", 5)) { + authstr += 5; + sha1((const unsigned char*)authstr, strlen(authstr), target); + } + else { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid auth string %s\n", authstr); + return -1; + } + + return 0; +} + +int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) +{ + int rc; + 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)); + + 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) { + goto err_invalid; + } + if(rc == 1) { + opts->gen_owner_auth = 1; + } + } + 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) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmdriver=", 10)) { + if(!strcmp(argv[i] + 10, "tpm_tis")) { + opts->tpmdriver = TPMDRV_TPM_TIS; + } else if(!strcmp(argv[i] + 10, "tpmfront")) { + opts->tpmdriver = TPMDRV_TPMFRONT; + } else { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmiomem=",9)) { + if(sscanf(argv[i] + 9, "0x%lX", &opts->tpmiomem) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmirq=",7)) { + if(!strcmp(argv[i] + 7, "probe")) { + opts->tpmirq = TPM_PROBE_IRQ; + } else if( sscanf(argv[i] + 7, "%u", &opts->tpmirq) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmlocality=",12)) { + if(sscanf(argv[i] + 12, "%u", &opts->tpmlocality) != 1 || opts->tpmlocality > 4) { + goto err_invalid; + } + } + } + + switch(opts->tpmdriver) { + case TPMDRV_TPM_TIS: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpm_tis driver\n"); + break; + case TPMDRV_TPMFRONT: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpmfront driver\n"); + break; + } + + return 0; +err_invalid: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid Option %s\n", argv[i]); + return -1; +} + + + +static TPM_RESULT vtpmmgr_create(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + + // Take ownership if TPM is unowned + 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, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &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()); + + goto egress; +abort_egress: +egress: + vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager\n"); + + //End the OSAP session + if(osap.AuthHandle) { + TPM_TerminateHandle(osap.AuthHandle); + } + + return status; +} + +TPM_RESULT vtpmmgr_init(int argc, char** argv) { + TPM_RESULT status = TPM_SUCCESS; + + /* Default commandline options */ + struct Opts opts = { + .tpmdriver = TPMDRV_TPM_TIS, + .tpmiomem = TPM_BASEADDR, + .tpmirq = 0, + .tpmlocality = 0, + .gen_owner_auth = 0, + }; + + if(parse_cmdline_opts(argc, argv, &opts) != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Command line parsing failed! exiting..\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + //Setup storage system + if(vtpm_storage_init() != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize storage subsystem!\n"); + status = TPM_IOERROR; + goto abort_egress; + } + + //Setup tpmback device + init_tpmback(); + + //Setup tpm access + switch(opts.tpmdriver) { + case TPMDRV_TPM_TIS: + { + struct tpm_chip* tpm; + if((tpm = init_tpm_tis(opts.tpmiomem, TPM_TIS_LOCL_INT_TO_FLAG(opts.tpmlocality), opts.tpmirq)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpm_tis_open(tpm); + tpm_tis_request_locality(tpm, opts.tpmlocality); + } + break; + case TPMDRV_TPMFRONT: + { + struct tpmfront_dev* tpmfront_dev; + if((tpmfront_dev = init_tpmfront(NULL)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpmfront_open(tpmfront_dev); + } + break; + } + + //Get the version of the tpm + TPMTRYRETURN(check_tpm_version()); + + // Blow away all stale handles left in the tpm + if(flush_tpm() != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_FlushResources failed, continuing anyway..\n"); + } + + /* Initialize the rng */ + entropy_init(&vtpm_globals.entropy); + entropy_add_source(&vtpm_globals.entropy, tpm_entropy_source, NULL, 0); + entropy_gather(&vtpm_globals.entropy); + ctr_drbg_init(&vtpm_globals.ctr_drbg, entropy_func, &vtpm_globals.entropy, NULL, 0); + ctr_drbg_set_prediction_resistance( &vtpm_globals.ctr_drbg, CTR_DRBG_PR_OFF ); + + // Generate Auth for Owner + if(opts.gen_owner_auth) { + vtpmmgr_rand(vtpm_globals.owner_auth, sizeof(TPM_AUTHDATA)); + } + + // Create OIAP session for service's authorized commands + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); + + /* Load the Manager data, if it fails create a new manager */ + if (vtpm_storage_load_header() != TPM_SUCCESS) { + /* 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) ); + } + vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); + TPMTRYRETURN( vtpmmgr_create() ); + } + + goto egress; +abort_egress: + vtpmmgr_shutdown(); +egress: + return status; +} + +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); + + vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); +} diff --git a/stubdom/vtpmmgr/log.c b/stubdom/vtpmmgr/log.c new file mode 100644 index 0000000..a82c913 --- /dev/null +++ b/stubdom/vtpmmgr/log.c @@ -0,0 +1,151 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "tcg.h" + +char *module_names[] = { "", + "TPM", + "TPM", + "VTPM", + "VTPM", + "TXDATA", + }; +// Helper code for the consts, eg. to produce messages for error codes. + +typedef struct error_code_entry_t { + TPM_RESULT code; + char * code_name; + char * msg; +} error_code_entry_t; + +static const error_code_entry_t error_msgs [] = { + { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, + { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, + { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, + { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, + { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, + { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, + { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, + { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, + { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, + { TPM_FAIL, "TPM_FAIL", "The operation failed" }, + { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, + { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, + { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, + { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, + { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, + { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, + { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, + { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, + { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, + { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, + { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, + { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, + { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, + { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, + { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, + { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, + { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, + { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, + { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, + { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, + { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, + { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, + { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, + { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, + { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, + { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, + { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, + { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, + { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, + { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, + { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, + + { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, + { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, + { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, + { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, + { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, + { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, + { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, + { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, + { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, + { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, + { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, + { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, + { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, + { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, + { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, + { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, + { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, + { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, + { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, + { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, + { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, + { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, + { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, + { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, + { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, + { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, + { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, + { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, + { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, + { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, + { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, + { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, + { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, + { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, + { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, + { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, + { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, + { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, +}; + + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code) { + // just do a linear scan for now + unsigned i; + for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) + if (code == error_msgs[i].code) + return error_msgs[i].code_name; + + return("Unknown Error Code"); +} diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h new file mode 100644 index 0000000..5c7abf5 --- /dev/null +++ b/stubdom/vtpmmgr/log.h @@ -0,0 +1,85 @@ +/* + * 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_LOG_H__ +#define __VTPM_LOG_H__ + +#include // for uint32_t +#include // for pointer NULL +#include +#include "tcg.h" + +// =========================== LOGGING ============================== + +// the logging module numbers +#define VTPM_LOG_TPM 1 +#define VTPM_LOG_TPM_DEEP 2 +#define VTPM_LOG_VTPM 3 +#define VTPM_LOG_VTPM_DEEP 4 +#define VTPM_LOG_TXDATA 5 + +extern char *module_names[]; + +// Default to standard logging +#ifndef LOGGING_MODULES +#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)|BITMASK(VTPM_LOG_TPM)) +#endif + +// bit-access macros +#define BITMASK(idx) ( 1U << (idx) ) +#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) +#define SETBIT(num,idx) (num) |= BITMASK(idx) +#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) + +#define vtpmloginfo(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + } + +#define vtpmloginfomore(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, fmt,##args); \ + } + +#define vtpmlogerror(module, fmt, args...) \ + fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + +//typedef UINT32 tpm_size_t; + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code); + +#endif // _VTPM_LOG_H_ diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h new file mode 100644 index 0000000..77d32f0 --- /dev/null +++ b/stubdom/vtpmmgr/marshal.h @@ -0,0 +1,528 @@ +/* + * 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 MARSHAL_H +#define MARSHAL_H + +#include +#include +#include +#include "tcg.h" + +typedef enum UnpackPtr { + UNPACK_ALIAS, + UNPACK_ALLOC +} UnpackPtr; + +inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { + ptr[0] = t; + return ++ptr; +} + +inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { + t[0] = ptr[0]; + return ++ptr; +} + +#define pack_BOOL(p, t) pack_BYTE(p, t) +#define unpack_BOOL(p, t) unpack_BYTE(p, t) + +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* 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); +} + +#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) +#define pack_TPM_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TPM_AUTHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HASHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HMACHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENCHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_KEY_HANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENTITYHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_RESOURCE_TYPE(p, t) pack_UINT32(p, t) +#define pack_TPM_COMMAND_CODE(p, t) pack_UINT32(p, t) +#define pack_TPM_PROTOCOL_ID(p, t) pack_UINT16(p, t) +#define pack_TPM_AUTH_DATA_USAGE(p, t) pack_BYTE(p, t) +#define pack_TPM_ENTITY_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_ALGORITHM_ID(p, t) pack_UINT32(p, t) +#define pack_TPM_KEY_USAGE(p, t) pack_UINT16(p, t) +#define pack_TPM_STARTUP_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_CAPABILITY_AREA(p, t) pack_UINT32(p, t) +#define pack_TPM_ENC_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_SIG_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t) +#define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t) + +#define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_DIRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_AUTHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HASHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HMACHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENCHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_KEY_HANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENTITYHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_RESOURCE_TYPE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_COMMAND_CODE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PROTOCOL_ID(p, t) unpack_UINT16(p, t) +#define unpack_TPM_AUTH_DATA_USAGE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_ENTITY_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_ALGORITHM_ID(p, t) unpack_UINT32(p, t) +#define unpack_TPM_KEY_USAGE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STARTUP_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_CAPABILITY_AREA(p, t) unpack_UINT32(p, t) +#define unpack_TPM_ENC_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_SIG_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, 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 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; +} + +inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { + memcpy(buf, ptr, size); + return ptr + size; +} + +inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 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; +} + +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); + } +} + +inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { + 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); +} + +#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) +#define pack_TPM_TAG(p, t) pack_UINT16(p, t) +#define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) + +#define unpack_TPM_SECRET(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, 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; +} + +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; +} + +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; +} + +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; +} + +inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { + 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); +} + +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_PCRVALUE(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 pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_DIRVALUE(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); +} + +inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { + return unpack_BUFFER(ptr, 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); +} + +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 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); +} + +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 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; +} + +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; +} + +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 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); +} + +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 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; +} + +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; +} + +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; +} + +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 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; +} + +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 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); +} + +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); +} + +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); +} + +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; +} + +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; +} + +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; +} + +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; +} + +#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); + +#endif diff --git a/stubdom/vtpmmgr/minios.cfg b/stubdom/vtpmmgr/minios.cfg new file mode 100644 index 0000000..3fb383d --- /dev/null +++ b/stubdom/vtpmmgr/minios.cfg @@ -0,0 +1,14 @@ +CONFIG_TPMFRONT=y +CONFIG_TPM_TIS=y +CONFIG_TPMBACK=y +CONFIG_START_NETWORK=n +CONFIG_TEST=n +CONFIG_PCIFRONT=n +CONFIG_BLKFRONT=y +CONFIG_NETFRONT=n +CONFIG_FBFRONT=n +CONFIG_KBDFRONT=n +CONFIG_CONSFRONT=n +CONFIG_XENBUS=y +CONFIG_LWIP=n +CONFIG_XC=n diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h new file mode 100644 index 0000000..7687eae --- /dev/null +++ b/stubdom/vtpmmgr/tcg.h @@ -0,0 +1,707 @@ +/* + * 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 __TCG_H__ +#define __TCG_H__ + +#include +#include + +// **************************** CONSTANTS ********************************* + +// BOOL values +#define TRUE 0x01 +#define FALSE 0x00 + +#define TCPA_MAX_BUFFER_LENGTH 0x2000 + +// +// TPM_COMMAND_CODE values +#define TPM_PROTECTED_ORDINAL 0x00000000UL +#define TPM_UNPROTECTED_ORDINAL 0x80000000UL +#define TPM_CONNECTION_ORDINAL 0x40000000UL +#define TPM_VENDOR_ORDINAL 0x20000000UL + +#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveContext (184UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadContext (185UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FlushSpecific (186UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PCR_Reset (200UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_DefineSpace (204UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValue (205UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValueAuth (206UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValue (207UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValueAuth (208UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_UpdateVerification (209UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_Manage (210UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateKeyDelegation (212UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateOwnerDelegation (213UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_VerifyDelegation (214UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_LoadOwnerDelegation (216UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadAuth (217UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadTable (219UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateCounter (220UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_IncrementCounter (221UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadCounter (222UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounter (223UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounterOwner (224UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EstablishTransport (230UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ExecuteTransport (231UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseTransportSigned (232UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTicks (241UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TickStampBlob (242UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MAX (256UL + TPM_PROTECTED_ORDINAL) + +#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) + + + +// +// TPM_RESULT values +// +// just put in the whole table from spec 1.2 + +#define TPM_BASE 0x0 // The start of TPM return codes +#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands +#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. + +#define TPM_SUCCESS TPM_BASE // Successful completion of the operation +#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed +#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect +#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad +#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. +#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access +#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated +#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled +#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled +#define TPM_FAIL TPM_BASE + 9 // The operation failed +#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent +#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled +#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid +#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found +#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme +#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed +#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted +#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. +#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set +#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM +#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner +#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. +#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short +#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. +#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. +#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value +#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. +#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. +#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. +#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization +#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid +#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM +#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. +#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. +#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. +#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed +#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed +#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed +#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup +#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information +#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM + +#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. +#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. +#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key +#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. +#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value +#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability +#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions +#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also +#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success +#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute +#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport +#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed +#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource +#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode +#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID +#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available +#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command +#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key +#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization +#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable +#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation +#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to +#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area +#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match +#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to +#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict +#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent +#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. +#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect +#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area +#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large +#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded +#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set +#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded +#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked +#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family +#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled +#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session + +// TPM_STARTUP_TYPE values +#define TPM_ST_CLEAR 0x0001 +#define TPM_ST_STATE 0x0002 +#define TPM_ST_DEACTIVATED 0x003 + +// TPM_TAG values +#define TPM_TAG_RQU_COMMAND 0x00c1 +#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 +#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 +#define TPM_TAG_RSP_COMMAND 0x00c4 +#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 +#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 + +// TPM_PAYLOAD_TYPE values +#define TPM_PT_ASYM 0x01 +#define TPM_PT_BIND 0x02 +#define TPM_PT_MIGRATE 0x03 +#define TPM_PT_MAINT 0x04 +#define TPM_PT_SEAL 0x05 + +// TPM_ENTITY_TYPE values +#define TPM_ET_KEYHANDLE 0x0001 +#define TPM_ET_OWNER 0x0002 +#define TPM_ET_DATA 0x0003 +#define TPM_ET_SRK 0x0004 +#define TPM_ET_KEY 0x0005 + +/// TPM_ResourceTypes +#define TPM_RT_KEY 0x00000001 +#define TPM_RT_AUTH 0x00000002 +#define TPM_RT_HASH 0x00000003 +#define TPM_RT_TRANS 0x00000004 +#define TPM_RT_CONTEXT 0x00000005 +#define TPM_RT_COUNTER 0x00000006 +#define TPM_RT_DELEGATE 0x00000007 +#define TPM_RT_DAA_TPM 0x00000008 +#define TPM_RT_DAA_V0 0x00000009 +#define TPM_RT_DAA_V1 0x0000000A + + + +// TPM_PROTOCOL_ID values +#define TPM_PID_OIAP 0x0001 +#define TPM_PID_OSAP 0x0002 +#define TPM_PID_ADIP 0x0003 +#define TPM_PID_ADCP 0x0004 +#define TPM_PID_OWNER 0x0005 + +// TPM_ALGORITHM_ID values +#define TPM_ALG_RSA 0x00000001 +#define TPM_ALG_SHA 0x00000004 +#define TPM_ALG_HMAC 0x00000005 +#define TPM_ALG_AES128 0x00000006 +#define TPM_ALG_MFG1 0x00000007 +#define TPM_ALG_AES192 0x00000008 +#define TPM_ALG_AES256 0x00000009 +#define TPM_ALG_XOR 0x0000000A + +// TPM_ENC_SCHEME values +#define TPM_ES_NONE 0x0001 +#define TPM_ES_RSAESPKCSv15 0x0002 +#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 + +// TPM_SIG_SCHEME values +#define TPM_SS_NONE 0x0001 +#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 +#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 + +/* + * TPM_CAPABILITY_AREA Values for TPM_GetCapability ([TPM_Part2], Section 21.1) + */ +#define TPM_CAP_ORD 0x00000001 +#define TPM_CAP_ALG 0x00000002 +#define TPM_CAP_PID 0x00000003 +#define TPM_CAP_FLAG 0x00000004 +#define TPM_CAP_PROPERTY 0x00000005 +#define TPM_CAP_VERSION 0x00000006 +#define TPM_CAP_KEY_HANDLE 0x00000007 +#define TPM_CAP_CHECK_LOADED 0x00000008 +#define TPM_CAP_SYM_MODE 0x00000009 +#define TPM_CAP_KEY_STATUS 0x0000000C +#define TPM_CAP_NV_LIST 0x0000000D +#define TPM_CAP_MFR 0x00000010 +#define TPM_CAP_NV_INDEX 0x00000011 +#define TPM_CAP_TRANS_ALG 0x00000012 +#define TPM_CAP_HANDLE 0x00000014 +#define TPM_CAP_TRANS_ES 0x00000015 +#define TPM_CAP_AUTH_ENCRYPT 0x00000017 +#define TPM_CAP_SELECT_SIZE 0x00000018 +#define TPM_CAP_DA_LOGIC 0x00000019 +#define TPM_CAP_VERSION_VAL 0x0000001A + +/* subCap definitions ([TPM_Part2], Section 21.2) */ +#define TPM_CAP_PROP_PCR 0x00000101 +#define TPM_CAP_PROP_DIR 0x00000102 +#define TPM_CAP_PROP_MANUFACTURER 0x00000103 +#define TPM_CAP_PROP_KEYS 0x00000104 +#define TPM_CAP_PROP_MIN_COUNTER 0x00000107 +#define TPM_CAP_FLAG_PERMANENT 0x00000108 +#define TPM_CAP_FLAG_VOLATILE 0x00000109 +#define TPM_CAP_PROP_AUTHSESS 0x0000010A +#define TPM_CAP_PROP_TRANSESS 0x0000010B +#define TPM_CAP_PROP_COUNTERS 0x0000010C +#define TPM_CAP_PROP_MAX_AUTHSESS 0x0000010D +#define TPM_CAP_PROP_MAX_TRANSESS 0x0000010E +#define TPM_CAP_PROP_MAX_COUNTERS 0x0000010F +#define TPM_CAP_PROP_MAX_KEYS 0x00000110 +#define TPM_CAP_PROP_OWNER 0x00000111 +#define TPM_CAP_PROP_CONTEXT 0x00000112 +#define TPM_CAP_PROP_MAX_CONTEXT 0x00000113 +#define TPM_CAP_PROP_FAMILYROWS 0x00000114 +#define TPM_CAP_PROP_TIS_TIMEOUT 0x00000115 +#define TPM_CAP_PROP_STARTUP_EFFECT 0x00000116 +#define TPM_CAP_PROP_DELEGATE_ROW 0x00000117 +#define TPM_CAP_PROP_MAX_DAASESS 0x00000119 +#define TPM_CAP_PROP_DAASESS 0x0000011A +#define TPM_CAP_PROP_CONTEXT_DIST 0x0000011B +#define TPM_CAP_PROP_DAA_INTERRUPT 0x0000011C +#define TPM_CAP_PROP_SESSIONS 0x0000011D +#define TPM_CAP_PROP_MAX_SESSIONS 0x0000011E +#define TPM_CAP_PROP_CMK_RESTRICTION 0x0000011F +#define TPM_CAP_PROP_DURATION 0x00000120 +#define TPM_CAP_PROP_ACTIVE_COUNTER 0x00000122 +#define TPM_CAP_PROP_MAX_NV_AVAILABLE 0x00000123 +#define TPM_CAP_PROP_INPUT_BUFFER 0x00000124 + +// TPM_KEY_USAGE values +#define TPM_KEY_EK 0x0000 +#define TPM_KEY_SIGNING 0x0010 +#define TPM_KEY_STORAGE 0x0011 +#define TPM_KEY_IDENTITY 0x0012 +#define TPM_KEY_AUTHCHANGE 0X0013 +#define TPM_KEY_BIND 0x0014 +#define TPM_KEY_LEGACY 0x0015 + +// TPM_AUTH_DATA_USAGE values +#define TPM_AUTH_NEVER 0x00 +#define TPM_AUTH_ALWAYS 0x01 + +// Key Handle of owner and srk +#define TPM_OWNER_KEYHANDLE 0x40000001 +#define TPM_SRK_KEYHANDLE 0x40000000 + + + +// *************************** TYPEDEFS ********************************* +typedef unsigned char BYTE; +typedef unsigned char BOOL; +typedef uint16_t UINT16; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef UINT32 TPM_RESULT; +typedef UINT32 TPM_PCRINDEX; +typedef UINT32 TPM_DIRINDEX; +typedef UINT32 TPM_HANDLE; +typedef TPM_HANDLE TPM_AUTHHANDLE; +typedef TPM_HANDLE TCPA_HASHHANDLE; +typedef TPM_HANDLE TCPA_HMACHANDLE; +typedef TPM_HANDLE TCPA_ENCHANDLE; +typedef TPM_HANDLE TPM_KEY_HANDLE; +typedef TPM_HANDLE TCPA_ENTITYHANDLE; +typedef UINT32 TPM_RESOURCE_TYPE; +typedef UINT32 TPM_COMMAND_CODE; +typedef UINT16 TPM_PROTOCOL_ID; +typedef BYTE TPM_AUTH_DATA_USAGE; +typedef UINT16 TPM_ENTITY_TYPE; +typedef UINT32 TPM_ALGORITHM_ID; +typedef UINT16 TPM_KEY_USAGE; +typedef UINT16 TPM_STARTUP_TYPE; +typedef UINT32 TPM_CAPABILITY_AREA; +typedef UINT16 TPM_ENC_SCHEME; +typedef UINT16 TPM_SIG_SCHEME; +typedef UINT16 TPM_MIGRATE_SCHEME; +typedef UINT16 TPM_PHYSICAL_PRESENCE; +typedef UINT32 TPM_KEY_FLAGS; + +#define TPM_DIGEST_SIZE 20 // Don't change this +typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; +typedef TPM_AUTHDATA TPM_SECRET; +typedef TPM_AUTHDATA TPM_ENCAUTH; +typedef BYTE TPM_PAYLOAD_TYPE; +typedef UINT16 TPM_TAG; +typedef UINT16 TPM_STRUCTURE_TAG; + +// Data Types of the TCS +typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session +typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle +typedef UINT32 TCS_KEY_HANDLE; // Basic key handle + +// ************************* STRUCTURES ********************************** + +typedef struct TPM_VERSION { + BYTE major; + BYTE minor; + BYTE revMajor; + BYTE revMinor; +} TPM_VERSION; + +static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; + +typedef struct TPM_CAP_VERSION_INFO { + TPM_STRUCTURE_TAG tag; + TPM_VERSION version; + UINT16 specLevel; + BYTE errataRev; + BYTE tpmVendorID[4]; + UINT16 vendorSpecificSize; + BYTE* vendorSpecific; +} TPM_CAP_VERSION_INFO; + +inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { + free(v->vendorSpecific); + v->vendorSpecific = NULL; +} + +typedef struct TPM_DIGEST { + BYTE digest[TPM_DIGEST_SIZE]; +} TPM_DIGEST; + +typedef TPM_DIGEST TPM_PCRVALUE; +typedef TPM_DIGEST TPM_COMPOSITE_HASH; +typedef TPM_DIGEST TPM_DIRVALUE; +typedef TPM_DIGEST TPM_HMAC; +typedef TPM_DIGEST TPM_CHOSENID_HASH; + +typedef struct TPM_NONCE { + BYTE nonce[TPM_DIGEST_SIZE]; +} TPM_NONCE; + +typedef struct TPM_SYMMETRIC_KEY_PARMS { + UINT32 keyLength; + UINT32 blockSize; + UINT32 ivSize; + BYTE* IV; +} TPM_SYMMETRIC_KEY_PARMS; + +inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { + free(p->IV); + p->IV = NULL; +} + +#define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } + +typedef struct TPM_RSA_KEY_PARMS { + UINT32 keyLength; + UINT32 numPrimes; + UINT32 exponentSize; + BYTE* exponent; +} TPM_RSA_KEY_PARMS; + +#define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } + +inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { + free(p->exponent); + p->exponent = NULL; +} + +typedef struct TPM_KEY_PARMS { + TPM_ALGORITHM_ID algorithmID; + TPM_ENC_SCHEME encScheme; + TPM_SIG_SCHEME sigScheme; + UINT32 parmSize; + union { + TPM_SYMMETRIC_KEY_PARMS sym; + TPM_RSA_KEY_PARMS rsa; + } parms; +} TPM_KEY_PARMS; + +#define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } + +inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { + if(p->parmSize) { + switch(p->algorithmID) { + case TPM_ALG_RSA: + free_TPM_RSA_KEY_PARMS(&p->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); + break; + } + } +} + +typedef struct TPM_STORE_PUBKEY { + UINT32 keyLength; + BYTE* key; +} TPM_STORE_PUBKEY; + +#define TPM_STORE_PUBKEY_INIT { 0, NULL } + +inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { + free(p->key); + p->key = NULL; +} + +typedef struct TPM_PUBKEY { + TPM_KEY_PARMS algorithmParms; + TPM_STORE_PUBKEY pubKey; +} TPM_PUBKEY; + +#define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } + +inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { + free_TPM_KEY_PARMS(&k->algorithmParms); + free_TPM_STORE_PUBKEY(&k->pubKey); +} + +typedef struct TPM_PCR_SELECTION { + UINT16 sizeOfSelect; + BYTE* pcrSelect; +} TPM_PCR_SELECTION; + +#define TPM_PCR_SELECTION_INIT { 0, NULL } + +inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { + free(p->pcrSelect); + p->pcrSelect = NULL; +} + +typedef struct TPM_PCR_INFO { + TPM_PCR_SELECTION pcrSelection; + TPM_COMPOSITE_HASH digestAtRelease; + TPM_COMPOSITE_HASH digestAtCreation; +} TPM_PCR_INFO; + +#define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } + +inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { + free_TPM_PCR_SELECTION(&p->pcrSelection); +} + +typedef struct TPM_PCR_COMPOSITE { + TPM_PCR_SELECTION select; + UINT32 valueSize; + TPM_PCRVALUE* pcrValue; +} TPM_PCR_COMPOSITE; + +#define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } + +inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { + free_TPM_PCR_SELECTION(&p->select); + free(p->pcrValue); + p->pcrValue = NULL; +} + +typedef struct TPM_KEY { + TPM_VERSION ver; + TPM_KEY_USAGE keyUsage; + TPM_KEY_FLAGS keyFlags; + TPM_AUTH_DATA_USAGE authDataUsage; + TPM_KEY_PARMS algorithmParms; + UINT32 PCRInfoSize; + TPM_PCR_INFO PCRInfo; + TPM_STORE_PUBKEY pubKey; + UINT32 encDataSize; + BYTE* encData; +} TPM_KEY; + +#define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\ + .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \ + .pubKey = TPM_STORE_PUBKEY_INIT, \ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_KEY(TPM_KEY* k) { + if(k->PCRInfoSize) { + free_TPM_PCR_INFO(&k->PCRInfo); + } + free_TPM_STORE_PUBKEY(&k->pubKey); + free(k->encData); + k->encData = NULL; +} + +typedef struct TPM_BOUND_DATA { + TPM_VERSION ver; + TPM_PAYLOAD_TYPE payload; + BYTE* payloadData; +} TPM_BOUND_DATA; + +#define TPM_BOUND_DATA_INIT { .payloadData = NULL } + +inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { + free(d->payloadData); + d->payloadData = NULL; +} + +typedef struct TPM_STORED_DATA { + TPM_VERSION ver; + UINT32 sealInfoSize; + TPM_PCR_INFO sealInfo; + UINT32 encDataSize; + BYTE* encData; +} TPM_STORED_DATA; + +#define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { + if(d->sealInfoSize) { + free_TPM_PCR_INFO(&d->sealInfo); + } + free(d->encData); + d->encData = NULL; +} + +typedef struct TPM_AUTH_SESSION { + TPM_AUTHHANDLE AuthHandle; + TPM_NONCE NonceOdd; // system + TPM_NONCE NonceEven; // TPM + BOOL fContinueAuthSession; + TPM_AUTHDATA HMAC; +} TPM_AUTH_SESSION; + +#define TPM_AUTH_SESSION_INIT { .AuthHandle = 0, .fContinueAuthSession = FALSE } + +// ---------------------- Functions for checking TPM_RESULTs ----------------- + +#include + +// FIXME: Review use of these and delete unneeded ones. + +// these are really badly dependent on local structure: +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +#define ERRORDIE(s) do { status = s; \ + fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ + goto abort_egress; } \ + while (0) + +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +// Try command c. If it fails, set status to s and goto abort. +#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ + status = s; \ + printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } else {\ + status = c; \ + } + +// Try command c. If it fails, print error message, set status to actual return code. Goto abort +#define TPMTRYRETURN(c) do { status = c; \ + if (status != TPM_SUCCESS) { \ + fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } \ + } while(0) + + +#endif //__TCPA_H__ diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c new file mode 100644 index 0000000..123a27c --- /dev/null +++ b/stubdom/vtpmmgr/tpm.c @@ -0,0 +1,938 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include + +#include + +#include "tcg.h" +#include "tpm.h" +#include "log.h" +#include "marshal.h" +#include "tpmrsa.h" +#include "vtpmmgr.h" + +#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_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;\ + }\ +} 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]; + } + } + +} + +static void generateAuth(const TPM_DIGEST* paramDigest, + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) +{ + //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; + + 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); +} + +static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, + /*[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; + } +} + + + +// ------------------------------------------------------------------ +// Authorization Commands +// ------------------------------------------------------------------ + +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; + + ptr = unpack_UINT32(ptr, &auth->AuthHandle); + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + +abort_egress: + 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) +{ + BYTE* nonceOddOSAP; + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + + ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); + ptr = pack_UINT32(ptr, entityValue); + + //nonce Odd OSAP + nonceOddOSAP = ptr; + vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); + ptr += TPM_DIGEST_SIZE; + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + 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, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); + + 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); + +abort_egress: + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(outSrk); + } +egress: + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_DisablePubekRead ( + 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_AUTH1_GEN(ownerAuth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + TPM_AUTH1_VERIFY(ownerAuth, auth); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in +{ + if(handle == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + + ptr = pack_TPM_AUTHHANDLE(ptr, handle); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + +abort_egress: + return status; +} + +TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in + TPM_DIGEST inDigest, // in + TPM_PCRVALUE* outDigest) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + + ptr = pack_TPM_PCRINDEX(ptr, pcrNum); + ptr = pack_TPM_DIGEST(ptr, &inDigest); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + +abort_egress: + 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 + ) +{ + 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); + + ptr = pack_UINT32(ptr, pcrInfoSize); + ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); + + ptr = pack_UINT32(ptr, inDataSize); + ptr = pack_BUFFER(ptr, inData, inDataSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(osapSharedSecret, pubAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); + dataAlloced = 1; + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + + goto egress; +abort_egress: + if(dataAlloced) { + free_TPM_STORED_DATA(sealedData); + } +egress: + TPM_AUTH_ERR_CHECK(pubAuth); + 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_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_TPM_STORED_DATA(ptr, sealedData); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(key_usage_auth, keyAuth); + TPM_AUTH2_GEN(data_usage_auth, dataAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_UINT32(ptr, outSize); + ptr = unpack_ALLOC(ptr, out, *outSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); + TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + +abort_egress: + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; +} + +TPM_RESULT TPM_Bind( + const TPM_KEY* key, + const BYTE* in, + UINT32 ilen, + BYTE* 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)); + +abort_egress: + tpmrsa_free(&rsa); + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_UINT32(ptr, ilen); + ptr = pack_BUFFER(ptr, in, ilen); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(usage_auth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + 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); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(usage_auth, auth); + +abort_egress: +egress: + TPM_AUTH_ERR_CHECK(auth); + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(key); + } +egress: + TPM_AUTH_ERR_CHECK(pAuth); + 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_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); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + +TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +{ + if(hKey == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + + ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + +abort_egress: + 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(); + +abort_egress: + return status; +} + +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + + // check input params + if (bytesRequested == NULL || randomBytes == NULL){ + return TPM_BAD_PARAMETER; + } + + ptr = pack_UINT32(ptr, *bytesRequested); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, bytesRequested); + ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + +abort_egress: + return status; +} + + +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; +abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } +egress: + return status; +} + + +TPM_RESULT TPM_SaveState(void) +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + +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); + + ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); + ptr = pack_UINT32(ptr, subCapSize); + ptr = pack_BUFFER(ptr, subCap, subCapSize); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, respSize); + ptr = unpack_ALLOC(ptr, resp, *respSize); + +abort_egress: + return status; +} + +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(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + + ptr = pack_TPM_NONCE(ptr, &antiReplay); + ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + sha1_starts(&ctx); + + kptr = ptr; + ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); + + /* Hash the pub key blob */ + sha1_update(&ctx, kptr, ptr - kptr); + ptr = unpack_TPM_DIGEST(ptr, &checksum); + + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + + 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; + } + + goto egress; +abort_egress: + if(kptr) { + free_TPM_PUBKEY(pubEK); + } +egress: + 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; + +abort_egress: +egress: + return status; +} diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h new file mode 100644 index 0000000..304e145 --- /dev/null +++ b/stubdom/vtpmmgr/tpm.h @@ -0,0 +1,218 @@ +/* + * 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/2006, 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 __TPM_H__ +#define __TPM_H__ + +#include "tcg.h" + +// ------------------------------------------------------------------ +// Exposed API +// ------------------------------------------------------------------ + +// TPM v1.1B Command Set + +// Authorzation +TPM_RESULT TPM_OIAP( + TPM_AUTH_SESSION* auth //out + ); + +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); + +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 + ); + +TPM_RESULT TPM_DisablePubekRead ( + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth + ); + +TPM_RESULT TPM_TerminateHandle ( TPM_AUTHHANDLE handle // in + ); + +TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in + TPM_RESOURCE_TYPE resourceType //in + ); + +// TPM Mandatory +TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // 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_Seal( + TCS_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* sealDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ); + +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_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 + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + 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 + ); + +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp); + +TPM_RESULT TPM_SaveState(void); + +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK); + +TPM_RESULT TPM_TransmitData( + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize); + +#endif //TPM_H diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c new file mode 100644 index 0000000..56094e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -0,0 +1,175 @@ +/* + * The RSA public-key cryptosystem + * + * Copyright (C) 2006-2011, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +/* + * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman. + * + * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf + * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf + */ + +#include "tcg.h" +#include "polarssl/sha1.h" + +#include +#include + +#include "tpmrsa.h" + +#define HASH_LEN 20 + +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen) { + + tpmrsa_free(ctx); + + if(explen == 0) { //Default e= 2^16+1 + mpi_lset(&ctx->E, 65537); + } else { + mpi_read_binary(&ctx->E, exponent, explen); + } + mpi_read_binary(&ctx->N, key, keylen); + + ctx->len = ( mpi_msb(&ctx->N) + 7) >> 3; +} + +static TPM_RESULT tpmrsa_public( tpmrsa_context *ctx, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + size_t olen; + mpi T; + + mpi_init( &T ); + + MPI_CHK( mpi_read_binary( &T, input, ctx->len ) ); + + if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 ) + { + mpi_free( &T ); + return TPM_ENCRYPT_ERROR; + } + + olen = ctx->len; + MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) ); + MPI_CHK( mpi_write_binary( &T, output, olen ) ); + +cleanup: + + mpi_free( &T ); + + if( ret != 0 ) + return TPM_ENCRYPT_ERROR; + + return TPM_SUCCESS; +} + +static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) +{ + unsigned char mask[HASH_LEN]; + unsigned char counter[4] = {0, 0, 0, 0}; + int i; + sha1_context mctx; + + //We always hash the src with the counter, so save the partial hash + sha1_starts(&mctx); + sha1_update(&mctx, src, slen); + + // Generate and apply dbMask + while(dlen > 0) { + //Copy the sha1 context + sha1_context ctx = mctx; + + //compute hash for input || counter + sha1_update(&ctx, counter, sizeof(counter)); + sha1_finish(&ctx, mask); + + //Apply the mask + for(i = 0; i < (dlen < HASH_LEN ? dlen : HASH_LEN); ++i) { + *(dst++) ^= mask[i]; + } + + //Increment counter + ++counter[3]; + + dlen -= HASH_LEN; + } +} + +/* + * Add the message padding, then do an RSA operation + */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + int olen; + unsigned char* seed = output + 1; + unsigned char* db = output + HASH_LEN +1; + + olen = ctx->len-1; + + if( f_rng == NULL ) + return TPM_ENCRYPT_ERROR; + + if( ilen > olen - 2 * HASH_LEN - 1) + return TPM_ENCRYPT_ERROR; + + output[0] = 0; + + //Encoding parameter p + sha1((unsigned char*)"TCPA", 4, db); + + //PS + memset(db + HASH_LEN, 0, + olen - ilen - 2 * HASH_LEN - 1); + + //constant 1 byte + db[olen - ilen - HASH_LEN -1] = 0x01; + + //input string + memcpy(db + olen - ilen - HASH_LEN, + input, ilen); + + //Generate random seed + if( ( ret = f_rng( p_rng, seed, HASH_LEN ) ) != 0 ) + return TPM_ENCRYPT_ERROR; + + // maskedDB: Apply dbMask to DB + mgf_mask( db, olen - HASH_LEN, seed, HASH_LEN); + + // maskedSeed: Apply seedMask to seed + mgf_mask( seed, HASH_LEN, db, olen - HASH_LEN); + + // Do the crypto op + return tpmrsa_public(ctx, output, output); +} diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h new file mode 100644 index 0000000..59579e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -0,0 +1,67 @@ +/** + * \file rsa.h + * + * \brief The RSA public-key cryptosystem + * + * Copyright (C) 2006-2010, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef TPMRSA_H +#define TPMRSA_H + +#include "tcg.h" +#include + +/* tpm software key */ +typedef struct +{ + size_t len; /*!< size(N) in chars */ + + mpi N; /*!< public modulus */ + mpi E; /*!< public exponent */ + + mpi RN; /*!< cached R^2 mod N */ +} +tpmrsa_context; + +#define TPMRSA_CTX_INIT { 0, {0, 0, NULL}, {0, 0, NULL}, {0, 0, NULL}} + +/* Setup the rsa context using tpm public key data */ +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen); + +/* Do rsa public crypto */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ); + +/* free tpmrsa key */ +inline void tpmrsa_free( tpmrsa_context *ctx ) { + mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); +} + +#endif /* tpmrsa.h */ diff --git a/stubdom/vtpmmgr/uuid.h b/stubdom/vtpmmgr/uuid.h new file mode 100644 index 0000000..4737645 --- /dev/null +++ b/stubdom/vtpmmgr/uuid.h @@ -0,0 +1,50 @@ +/* + * 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 VTPMMGR_UUID_H +#define VTPMMGR_UUID_H + +#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx" +#define UUID_FMTLEN ((2*16)+4) /* 16 hex bytes plus 4 hypens */ +#define UUID_BYTES(uuid) uuid[0], uuid[1], uuid[2], uuid[3], \ + uuid[4], uuid[5], uuid[6], uuid[7], \ + uuid[8], uuid[9], uuid[10], uuid[11], \ + uuid[12], uuid[13], uuid[14], uuid[15] + + +typedef uint8_t uuid_t[16]; + +#endif diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c new file mode 100644 index 0000000..f82a2a9 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -0,0 +1,152 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "marshal.h" +#include "log.h" +#include "vtpm_storage.h" +#include "vtpmmgr.h" +#include "tpm.h" +#include "tcg.h" + +static TPM_RESULT vtpmmgr_SaveHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + + 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; + } + + /* Do the command */ + TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + return status; +} + +static TPM_RESULT vtpmmgr_LoadHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) { + TPM_RESULT status = TPM_SUCCESS; + + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + + tpmcmd->resp_len += HASHKEYSZ; + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + + +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; + } + +abort_egress: + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, + tag + 3, tpmcmd->resp_len, status); + + return status; +} diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h new file mode 100644 index 0000000..a2bbcca --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -0,0 +1,64 @@ +/* + * 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_MANAGER_H +#define VTPM_MANAGER_H + +#define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_RSP 0x01c4 +#define COMMAND_BUFFER_SIZE 4096 + +// Header size +#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) + +//************************ 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) + +// 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 +#define VTPM_FAIL 1 +#define VTPM_UNSUPPORTED 2 +#define VTPM_FORBIDDEN 3 +#define VTPM_RESTORE_CONTEXT_FAILED 4 +#define VTPM_INVALID_REQUEST 5 + +#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c new file mode 100644 index 0000000..9ce0c32 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.c @@ -0,0 +1,794 @@ +/* + * 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 (%ld)\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 new file mode 100644 index 0000000..a5a5fd7 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.h @@ -0,0 +1,68 @@ +/* + * 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.c b/stubdom/vtpmmgr/vtpmmgr.c new file mode 100644 index 0000000..563f4e8 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.c @@ -0,0 +1,93 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include +#include +#include "log.h" + +#include "vtpmmgr.h" +#include "tcg.h" + + +void main_loop(void) { + tpmcmd_t* tpmcmd; + uint8_t respbuf[TCPA_MAX_BUFFER_LENGTH]; + + while(1) { + /* Wait for requests from a vtpm */ + vtpmloginfo(VTPM_LOG_VTPM, "Waiting for commands from vTPM's:\n"); + if((tpmcmd = tpmback_req_any()) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "NULL tpmcmd\n"); + continue; + } + + tpmcmd->resp = respbuf; + + /* Process the command */ + vtpmmgr_handle_cmd(tpmcmd->uuid, tpmcmd); + + /* Send response */ + tpmback_resp(tpmcmd); + } +} + +int main(int argc, char** argv) +{ + int rc = 0; + sleep(2); + vtpmloginfo(VTPM_LOG_VTPM, "Starting vTPM manager domain\n"); + + /* Initialize the vtpm manager */ + if(vtpmmgr_init(argc, argv) != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize vtpmmgr domain!\n"); + rc = -1; + goto exit; + } + + main_loop(); + + vtpmloginfo(VTPM_LOG_VTPM, "vTPM Manager shutting down...\n"); + + vtpmmgr_shutdown(); + +exit: + return rc; + +} diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h new file mode 100644 index 0000000..50a1992 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -0,0 +1,77 @@ +/* + * 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 VTPMMGR_H +#define VTPMMGR_H + +#include +#include +#include + +#include "uuid.h" +#include "tcg.h" +#include "vtpm_manager.h" + +#define RSA_KEY_SIZE 0x0800 +#define RSA_CIPHER_SIZE (RSA_KEY_SIZE / 8) + +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; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; +}; + +// --------------------------- 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); + +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; +} + +#endif -- 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 Nov 20 14:26:03 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 20 Nov 2012 14:26:03 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Taolt-0006Os-16; Tue, 20 Nov 2012 14:25:53 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Taolp-0006OM-R0 for xen-devel@lists.xen.org; Tue, 20 Nov 2012 14:25:50 +0000 Received: from [85.158.137.99:7504] by server-11.bemta-3.messagelabs.com id FB/59-19361-8E29BA05; Tue, 20 Nov 2012 14:25:44 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-12.tower-217.messagelabs.com!1353421533!16731644!1 X-Originating-IP: [128.244.251.36] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UNPARSEABLE_RELAY,UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 14905 invoked from network); 20 Nov 2012 14:25:35 -0000 Received: from pilot.jhuapl.edu (HELO jhuapl.edu) (128.244.251.36) by server-12.tower-217.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 20 Nov 2012 14:25:35 -0000 Received: from ([128.244.206.185]) by pilot.jhuapl.edu with ESMTP with TLS id 63GHCH1.157690906; Tue, 20 Nov 2012 09:25:23 -0500 Message-ID: <50AB92CF.8040306@jhuapl.edu> Date: Tue, 20 Nov 2012 09:25:19 -0500 From: Matthew Fioravante User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:16.0) Gecko/20121028 Thunderbird/16.0.2 MIME-Version: 1.0 To: "xen-devel@lists.xen.org" , "Ian.Campbell@citrix.com" References: <1353421272-24797-1-git-send-email-matthew.fioravante@jhuapl.edu> <1353421272-24797-2-git-send-email-matthew.fioravante@jhuapl.edu> In-Reply-To: <1353421272-24797-2-git-send-email-matthew.fioravante@jhuapl.edu> Subject: Re: [Xen-devel] [PATCH VTPM v4 2/5] add stubdom/vtpmmgr code 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: multipart/mixed; boundary="===============0475244974786596101==" Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org This is a cryptographically signed message in MIME format. --===============0475244974786596101== Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha1; boundary="------------ms080704030001010001060100" This is a cryptographically signed message in MIME format. --------------ms080704030001010001060100 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: quoted-printable Please be sure to grab this updated version. I fixed an important=20 comment about the disk image format that was out of date. On 11/20/2012 09:21 AM, Matthew Fioravante wrote: > Add the code base for vtpmmgrdom. Makefile changes > next patch. > > Signed-off-by: Matthew Fioravante > Acked-by: Ian Campbell > --- > stubdom/vtpmmgr/Makefile | 32 ++ > stubdom/vtpmmgr/init.c | 553 +++++++++++++++++++++ > stubdom/vtpmmgr/log.c | 151 ++++++ > stubdom/vtpmmgr/log.h | 85 ++++ > stubdom/vtpmmgr/marshal.h | 528 ++++++++++++++++++++ > stubdom/vtpmmgr/minios.cfg | 14 + > stubdom/vtpmmgr/tcg.h | 707 +++++++++++++++++++++++++++= > stubdom/vtpmmgr/tpm.c | 938 +++++++++++++++++++++++++++= +++++++++ > stubdom/vtpmmgr/tpm.h | 218 +++++++++ > stubdom/vtpmmgr/tpmrsa.c | 175 +++++++ > stubdom/vtpmmgr/tpmrsa.h | 67 +++ > stubdom/vtpmmgr/uuid.h | 50 ++ > stubdom/vtpmmgr/vtpm_cmd_handler.c | 152 ++++++ > stubdom/vtpmmgr/vtpm_manager.h | 64 +++ > stubdom/vtpmmgr/vtpm_storage.c | 794 +++++++++++++++++++++++++++= +++ > stubdom/vtpmmgr/vtpm_storage.h | 68 +++ > stubdom/vtpmmgr/vtpmmgr.c | 93 ++++ > stubdom/vtpmmgr/vtpmmgr.h | 77 +++ > 18 files changed, 4766 insertions(+) > create mode 100644 stubdom/vtpmmgr/Makefile > create mode 100644 stubdom/vtpmmgr/init.c > create mode 100644 stubdom/vtpmmgr/log.c > create mode 100644 stubdom/vtpmmgr/log.h > create mode 100644 stubdom/vtpmmgr/marshal.h > create mode 100644 stubdom/vtpmmgr/minios.cfg > create mode 100644 stubdom/vtpmmgr/tcg.h > create mode 100644 stubdom/vtpmmgr/tpm.c > create mode 100644 stubdom/vtpmmgr/tpm.h > create mode 100644 stubdom/vtpmmgr/tpmrsa.c > create mode 100644 stubdom/vtpmmgr/tpmrsa.h > create mode 100644 stubdom/vtpmmgr/uuid.h > create mode 100644 stubdom/vtpmmgr/vtpm_cmd_handler.c > create mode 100644 stubdom/vtpmmgr/vtpm_manager.h > create mode 100644 stubdom/vtpmmgr/vtpm_storage.c > create mode 100644 stubdom/vtpmmgr/vtpm_storage.h > create mode 100644 stubdom/vtpmmgr/vtpmmgr.c > create mode 100644 stubdom/vtpmmgr/vtpmmgr.h > > diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile > new file mode 100644 > index 0000000..88c83c3 > --- /dev/null > +++ b/stubdom/vtpmmgr/Makefile > @@ -0,0 +1,32 @@ > +# 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. > +# > + > +XEN_ROOT=3D../.. > + > +PSSL_DIR=3D../polarssl-$(XEN_TARGET_ARCH)/library > +PSSL_OBJS=3Daes.o sha1.o entropy.o ctr_drbg.o bignum.o sha4.o havege.o= timing.o entropy_poll.o > + > +TARGET=3Dvtpmmgr.a > +OBJS=3Dvtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm= =2Eo log.o > + > +CFLAGS+=3D-Werror -Iutil -Icrypto -Itcs > +CFLAGS+=3D-Wno-declaration-after-statement -Wno-unused-label > + > +build: $(TARGET) > +$(TARGET): $(OBJS) > + ar -rcs $@ $^ $(foreach obj,$(PSSL_OBJS),$(PSSL_DIR)/$(obj)) > + > +clean: > + rm -f $(TARGET) $(OBJS) > + > +distclean: clean > + > +.PHONY: clean distclean > diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c > new file mode 100644 > index 0000000..a158020 > --- /dev/null > +++ b/stubdom/vtpmmgr/init.c > @@ -0,0 +1,553 @@ > +/* > + * 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. > +*/ > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "log.h" > +#include "vtpmmgr.h" > +#include "vtpm_storage.h" > +#include "tpm.h" > +#include "marshal.h" > + > +struct Opts { > + enum { > + TPMDRV_TPM_TIS, > + TPMDRV_TPMFRONT, > + } tpmdriver; > + unsigned long tpmiomem; > + unsigned int tpmirq; > + unsigned int tpmlocality; > + int gen_owner_auth; > +}; > + > +// --------------------------- Well Known Auths ----------------------= ---- > +const TPM_AUTHDATA WELLKNOWN_SRK_AUTH =3D {0x00, 0x00, 0x00, 0x00, 0x0= 0, 0x00, 0x00, 0x00, 0x00, 0x00, > + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; > + > +const TPM_AUTHDATA WELLKNOWN_OWNER_AUTH =3D {0xff, 0xff, 0xff, 0xff, 0= xff, 0xff, 0xff, 0xff, 0xff, 0xff, > + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; > + > +struct vtpm_globals vtpm_globals =3D { > + .tpm_fd =3D -1, > + .storage_key =3D TPM_KEY_INIT, > + .storage_key_handle =3D 0, > + .oiap =3D { .AuthHandle =3D 0 } > +}; > + > +static int tpm_entropy_source(void* dummy, unsigned char* data, size_t= len, size_t* olen) { > + UINT32 sz =3D len; > + TPM_RESULT rc =3D TPM_GetRandom(&sz, data); > + *olen =3D sz; > + return rc =3D=3D TPM_SUCCESS ? 0 : POLARSSL_ERR_ENTROPY_SOURCE_FAIL= ED; > +} > + > +static TPM_RESULT check_tpm_version(void) { > + TPM_RESULT status; > + UINT32 rsize; > + BYTE* res =3D NULL; > + TPM_CAP_VERSION_INFO vinfo; > + > + TPMTRYRETURN(TPM_GetCapability( > + TPM_CAP_VERSION_VAL, > + 0, > + NULL, > + &rsize, > + &res)); > + if(rsize < 4) { > + vtpmlogerror(VTPM_LOG_VTPM, "Invalid size returned by GetCapabil= ity!\n"); > + status =3D TPM_BAD_PARAMETER; > + goto abort_egress; > + } > + > + unpack_TPM_CAP_VERSION_INFO(res, &vinfo, UNPACK_ALIAS); > + > + vtpmloginfo(VTPM_LOG_VTPM, "Hardware TPM:\n"); > + vtpmloginfo(VTPM_LOG_VTPM, " version: %hhd %hhd %hhd %hhd\n", > + vinfo.version.major, vinfo.version.minor, vinfo.version.revMa= jor, vinfo.version.revMinor); > + vtpmloginfo(VTPM_LOG_VTPM, " specLevel: %hd\n", vinfo.specLevel); > + vtpmloginfo(VTPM_LOG_VTPM, " errataRev: %hhd\n", vinfo.errataRev); > + vtpmloginfo(VTPM_LOG_VTPM, " vendorID: %c%c%c%c\n", > + vinfo.tpmVendorID[0], vinfo.tpmVendorID[1], > + vinfo.tpmVendorID[2], vinfo.tpmVendorID[3]); > + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecificSize: %hd\n", vinfo.vend= orSpecificSize); > + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecific: "); > + for(int i =3D 0; i < vinfo.vendorSpecificSize; ++i) { > + vtpmloginfomore(VTPM_LOG_VTPM, "%02hhx", vinfo.vendorSpecific[i]= ); > + } > + vtpmloginfomore(VTPM_LOG_VTPM, "\n"); > + > +abort_egress: > + free(res); > + return status; > +} > + > +static TPM_RESULT flush_tpm(void) { > + TPM_RESULT status =3D TPM_SUCCESS; > + const TPM_RESOURCE_TYPE reslist[] =3D { TPM_RT_KEY, TPM_RT_AUTH, TP= M_RT_TRANS, TPM_RT_COUNTER, TPM_RT_DAA_TPM, TPM_RT_CONTEXT }; > + BYTE* keylist =3D NULL; > + UINT32 keylistSize; > + BYTE* ptr; > + > + //Iterate through each resource type and flush all handles > + for(int i =3D 0; i < sizeof(reslist) / sizeof(TPM_RESOURCE_TYPE); += +i) { > + TPM_RESOURCE_TYPE beres =3D cpu_to_be32(reslist[i]); > + UINT16 size; > + TPMTRYRETURN(TPM_GetCapability( > + TPM_CAP_HANDLE, > + sizeof(TPM_RESOURCE_TYPE), > + (BYTE*)(&beres), > + &keylistSize, > + &keylist)); > + > + ptr =3D keylist; > + ptr =3D unpack_UINT16(ptr, &size); > + > + //Flush each handle > + if(size) { > + vtpmloginfo(VTPM_LOG_VTPM, "Flushing %u handle(s) of type %lu= \n", size, (unsigned long) reslist[i]); > + for(int j =3D 0; j < size; ++j) { > + TPM_HANDLE h; > + ptr =3D unpack_TPM_HANDLE(ptr, &h); > + TPMTRYRETURN(TPM_FlushSpecific(h, reslist[i])); > + } > + } > + > + free(keylist); > + keylist =3D NULL; > + } > + > + goto egress; > +abort_egress: > + free(keylist); > +egress: > + return status; > +} > + > + > +static TPM_RESULT try_take_ownership(void) { > + TPM_RESULT status =3D TPM_SUCCESS; > + TPM_PUBKEY pubEK =3D TPM_PUBKEY_INIT; > + > + // If we can read PubEK then there is no owner and we should take i= t. > + status =3D TPM_ReadPubek(&pubEK); > + > + switch(status) { > + case TPM_DISABLED_CMD: > + //Cannot read ek? TPM has owner > + vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has = an owner. Creating Keys off existing SRK.\n"); > + status =3D TPM_SUCCESS; > + break; > + case TPM_NO_ENDORSEMENT: > + { > + //If theres no ek, we have to create one > + TPM_KEY_PARMS keyInfo =3D { > + .algorithmID =3D TPM_ALG_RSA, > + .encScheme =3D TPM_ES_RSAESOAEP_SHA1_MGF1, > + .sigScheme =3D TPM_SS_NONE, > + .parmSize =3D 12, > + .parms.rsa =3D { > + .keyLength =3D RSA_KEY_SIZE, > + .numPrimes =3D 2, > + .exponentSize =3D 0, > + .exponent =3D NULL, > + }, > + }; > + TPMTRYRETURN(TPM_CreateEndorsementKeyPair(&keyInfo, &pubEK= )); > + } > + //fall through to take ownership > + case TPM_SUCCESS: > + { > + //Construct the Srk > + TPM_KEY srk =3D { > + .ver =3D TPM_STRUCT_VER_1_1, > + .keyUsage =3D TPM_KEY_STORAGE, > + .keyFlags =3D 0x00, > + .authDataUsage =3D TPM_AUTH_ALWAYS, > + .algorithmParms =3D { > + .algorithmID =3D TPM_ALG_RSA, > + .encScheme =3D TPM_ES_RSAESOAEP_SHA1_MGF1, > + .sigScheme =3D TPM_SS_NONE, > + .parmSize =3D 12, > + .parms.rsa =3D { > + .keyLength =3D RSA_KEY_SIZE, > + .numPrimes =3D 2, > + .exponentSize =3D 0, > + .exponent =3D NULL, > + }, > + }, > + .PCRInfoSize =3D 0, > + .pubKey =3D { > + .keyLength =3D 0, > + .key =3D NULL, > + }, > + .encDataSize =3D 0, > + }; > + > + TPMTRYRETURN(TPM_TakeOwnership( > + &pubEK, > + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, > + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, > + &srk, > + NULL, > + &vtpm_globals.oiap)); > + > + TPMTRYRETURN(TPM_DisablePubekRead( > + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, > + &vtpm_globals.oiap)); > + } > + break; > + default: > + break; > + } > +abort_egress: > + free_TPM_PUBKEY(&pubEK); > + return status; > +} > + > +static void init_storage_key(TPM_KEY* key) { > + key->ver.major =3D 1; > + key->ver.minor =3D 1; > + key->ver.revMajor =3D 0; > + key->ver.revMinor =3D 0; > + > + key->keyUsage =3D TPM_KEY_BIND; > + key->keyFlags =3D 0; > + key->authDataUsage =3D TPM_AUTH_ALWAYS; > + > + TPM_KEY_PARMS* p =3D &key->algorithmParms; > + p->algorithmID =3D TPM_ALG_RSA; > + p->encScheme =3D TPM_ES_RSAESOAEP_SHA1_MGF1; > + p->sigScheme =3D TPM_SS_NONE; > + p->parmSize =3D 12; > + > + TPM_RSA_KEY_PARMS* r =3D &p->parms.rsa; > + r->keyLength =3D RSA_KEY_SIZE; > + r->numPrimes =3D 2; > + r->exponentSize =3D 0; > + r->exponent =3D NULL; > + > + key->PCRInfoSize =3D 0; > + key->encDataSize =3D 0; > + key->encData =3D NULL; > +} > + > +static int parse_auth_string(char* authstr, BYTE* target, const TPM_AU= THDATA wellknown, int allowrandom) { > + 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; > + } > + /* owner auth is a raw hash */ > + else if(!strncmp(authstr, "hash:", 5)) { > + authstr +=3D 5; > + if((rc =3D strlen(authstr)) !=3D 40) { > + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth hex string `= %s' must be exactly 40 characters (20 bytes) long, length=3D%d\n", authst= r, rc); > + return -1; > + } > + for(int j =3D 0; j < 20; ++j) { > + if(sscanf(authstr, "%hhX", target + j) !=3D 1) { > + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth string `%= s' is not a valid hex string\n", authstr); > + return -1; > + } > + authstr +=3D 2; > + } > + } > + /* owner auth is a string that will be hashed */ > + else if(!strncmp(authstr, "text:", 5)) { > + authstr +=3D 5; > + sha1((const unsigned char*)authstr, strlen(authstr), target); > + } > + else { > + vtpmlogerror(VTPM_LOG_VTPM, "Invalid auth string %s\n", authstr)= ; > + return -1; > + } > + > + return 0; > +} > + > +int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) > +{ > + int rc; > + int i; > + > + //Set defaults > + memcpy(vtpm_globals.owner_auth, WELLKNOWN_OWNER_AUTH, sizeof(TPM_AU= THDATA)); > + memcpy(vtpm_globals.srk_auth, WELLKNOWN_SRK_AUTH, sizeof(TPM_AUTHDA= TA)); > + > + for(i =3D 1; i < argc; ++i) { > + if(!strncmp(argv[i], "owner_auth:", 10)) { > + if((rc =3D parse_auth_string(argv[i] + 10, vtpm_globals.owner= _auth, WELLKNOWN_OWNER_AUTH, 1)) < 0) { > + goto err_invalid; > + } > + if(rc =3D=3D 1) { > + opts->gen_owner_auth =3D 1; > + } > + } > + else if(!strncmp(argv[i], "srk_auth:", 8)) { > + if((rc =3D parse_auth_string(argv[i] + 8, vtpm_globals.srk_au= th, WELLKNOWN_SRK_AUTH, 0)) !=3D 0) { > + goto err_invalid; > + } > + } > + else if(!strncmp(argv[i], "tpmdriver=3D", 10)) { > + if(!strcmp(argv[i] + 10, "tpm_tis")) { > + opts->tpmdriver =3D TPMDRV_TPM_TIS; > + } else if(!strcmp(argv[i] + 10, "tpmfront")) { > + opts->tpmdriver =3D TPMDRV_TPMFRONT; > + } else { > + goto err_invalid; > + } > + } > + else if(!strncmp(argv[i], "tpmiomem=3D",9)) { > + if(sscanf(argv[i] + 9, "0x%lX", &opts->tpmiomem) !=3D 1) { > + goto err_invalid; > + } > + } > + else if(!strncmp(argv[i], "tpmirq=3D",7)) { > + if(!strcmp(argv[i] + 7, "probe")) { > + opts->tpmirq =3D TPM_PROBE_IRQ; > + } else if( sscanf(argv[i] + 7, "%u", &opts->tpmirq) !=3D 1) {= > + goto err_invalid; > + } > + } > + else if(!strncmp(argv[i], "tpmlocality=3D",12)) { > + if(sscanf(argv[i] + 12, "%u", &opts->tpmlocality) !=3D 1 || o= pts->tpmlocality > 4) { > + goto err_invalid; > + } > + } > + } > + > + switch(opts->tpmdriver) { > + case TPMDRV_TPM_TIS: > + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpm_tis driver\n");= > + break; > + case TPMDRV_TPMFRONT: > + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpmfront driver\n")= ; > + break; > + } > + > + return 0; > +err_invalid: > + vtpmlogerror(VTPM_LOG_VTPM, "Invalid Option %s\n", argv[i]); > + return -1; > +} > + > + > + > +static TPM_RESULT vtpmmgr_create(void) { > + TPM_RESULT status =3D TPM_SUCCESS; > + TPM_AUTH_SESSION osap =3D TPM_AUTH_SESSION_INIT; > + TPM_AUTHDATA sharedsecret; > + > + // Take ownership if TPM is unowned > + 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, > + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, > + &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()); > + > + goto egress; > +abort_egress: > +egress: > + vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager\n= "); > + > + //End the OSAP session > + if(osap.AuthHandle) { > + TPM_TerminateHandle(osap.AuthHandle); > + } > + > + return status; > +} > + > +TPM_RESULT vtpmmgr_init(int argc, char** argv) { > + TPM_RESULT status =3D TPM_SUCCESS; > + > + /* Default commandline options */ > + struct Opts opts =3D { > + .tpmdriver =3D TPMDRV_TPM_TIS, > + .tpmiomem =3D TPM_BASEADDR, > + .tpmirq =3D 0, > + .tpmlocality =3D 0, > + .gen_owner_auth =3D 0, > + }; > + > + if(parse_cmdline_opts(argc, argv, &opts) !=3D 0) { > + vtpmlogerror(VTPM_LOG_VTPM, "Command line parsing failed! exitin= g..\n"); > + status =3D TPM_BAD_PARAMETER; > + goto abort_egress; > + } > + > + //Setup storage system > + if(vtpm_storage_init() !=3D 0) { > + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize storage subsys= tem!\n"); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + > + //Setup tpmback device > + init_tpmback(); > + > + //Setup tpm access > + switch(opts.tpmdriver) { > + case TPMDRV_TPM_TIS: > + { > + struct tpm_chip* tpm; > + if((tpm =3D init_tpm_tis(opts.tpmiomem, TPM_TIS_LOCL_INT_T= O_FLAG(opts.tpmlocality), opts.tpmirq)) =3D=3D NULL) { > + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfr= ont device\n"); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + vtpm_globals.tpm_fd =3D tpm_tis_open(tpm); > + tpm_tis_request_locality(tpm, opts.tpmlocality); > + } > + break; > + case TPMDRV_TPMFRONT: > + { > + struct tpmfront_dev* tpmfront_dev; > + if((tpmfront_dev =3D init_tpmfront(NULL)) =3D=3D NULL) { > + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfr= ont device\n"); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + vtpm_globals.tpm_fd =3D tpmfront_open(tpmfront_dev); > + } > + break; > + } > + > + //Get the version of the tpm > + TPMTRYRETURN(check_tpm_version()); > + > + // Blow away all stale handles left in the tpm > + if(flush_tpm() !=3D TPM_SUCCESS) { > + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_FlushResources failed, continu= ing anyway..\n"); > + } > + > + /* Initialize the rng */ > + entropy_init(&vtpm_globals.entropy); > + entropy_add_source(&vtpm_globals.entropy, tpm_entropy_source, NULL,= 0); > + entropy_gather(&vtpm_globals.entropy); > + ctr_drbg_init(&vtpm_globals.ctr_drbg, entropy_func, &vtpm_globals.e= ntropy, NULL, 0); > + ctr_drbg_set_prediction_resistance( &vtpm_globals.ctr_drbg, CTR_DRB= G_PR_OFF ); > + > + // Generate Auth for Owner > + if(opts.gen_owner_auth) { > + vtpmmgr_rand(vtpm_globals.owner_auth, sizeof(TPM_AUTHDATA)); > + } > + > + // Create OIAP session for service's authorized commands > + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); > + > + /* Load the Manager data, if it fails create a new manager */ > + if (vtpm_storage_load_header() !=3D TPM_SUCCESS) { > + /* If the OIAP session was closed by an error, create a new one = */ > + if(vtpm_globals.oiap.AuthHandle =3D=3D 0) { > + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); > + } > + vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assumin= g first time initialization.\n"); > + TPMTRYRETURN( vtpmmgr_create() ); > + } > + > + goto egress; > +abort_egress: > + vtpmmgr_shutdown(); > +egress: > + return status; > +} > + > +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); > + > + vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); > +} > diff --git a/stubdom/vtpmmgr/log.c b/stubdom/vtpmmgr/log.c > new file mode 100644 > index 0000000..a82c913 > --- /dev/null > +++ b/stubdom/vtpmmgr/log.c > @@ -0,0 +1,151 @@ > +/* > + * 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. > +*/ > + > +#include > +#include > +#include > + > +#include "tcg.h" > + > +char *module_names[] =3D { "", > + "TPM", > + "TPM", > + "VTPM", > + "VTPM", > + "TXDATA", > + }; > +// Helper code for the consts, eg. to produce messages for error codes= =2E > + > +typedef struct error_code_entry_t { > + TPM_RESULT code; > + char * code_name; > + char * msg; > +} error_code_entry_t; > + > +static const error_code_entry_t error_msgs [] =3D { > + { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operatio= n" }, > + { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, > + { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other re= gister is incorrect" }, > + { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is = bad" }, > + { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed succ= essfully but the auditing of that operation failed." }, > + { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag = is set and all clear operations now require physical access" }, > + { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, > + { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, > + { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been= disabled" }, > + { TPM_FAIL, "TPM_FAIL", "The operation failed" }, > + { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or in= consistent" }, > + { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to inst= all an owner is disabled" }, > + { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle pr= esented was invalid" }, > + { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found"= }, > + { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encr= yption scheme" }, > + { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization faile= d" }, > + { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information cou= ld not be interpreted" }, > + { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, > + { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, > + { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is in= valid or was not created by this TPM" }, > + { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, > + { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal= resources to perform the requested action." }, > + { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short= " }, > + { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform = the operation." }, > + { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not = match the current PCR value." }, > + { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument = to the command has the incorrect value" }, > + { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thre= ad." }, > + { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proc= eed because the existing SHA-1 thread has already encountered an error." = }, > + { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed an= d the TPM has shutdown." }, > + { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second = key in a 2 key function failed authorization" }, > + { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is = invalid" }, > + { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting inf= ormation to the TPM" }, > + { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process ha= d a problem." }, > + { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process di= d not complete." }, > + { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid hand= le was used." }, > + { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK i= nstalled" }, > + { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key = is not allowed" }, > + { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entit= y type is not allowed" }, > + { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was rec= eived in the wrong sequence relative to TPM_Init and a subsequent TPM_Sta= rtup" }, > + { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data canno= t include additional DER information" }, > + { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties = in TPM_KEY_PARMs are not supported by this TPM" }, > + > + { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties = of this key are incorrect." }, > + { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption sch= eme for this key is incorrect or not permitted in this situation." }, > + { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or bl= ob) parameter is bad or inconsistent with the referenced key" }, > + { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as ca= pArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for = TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, > + { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence= or physicalPresenceLock bits have the wrong value" }, > + { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this v= ersion of the capability" }, > + { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not = allow for wrapped transport sessions" }, > + { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM aud= it construction failed and the underlying command was returning a failure= code also" }, > + { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit c= onstruction failed and the underlying command was returning success" }, > + { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR regi= ster that does not have the resettable attribute" }, > + { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register tha= t requires locality and locality modifier not part of command transport" = }, > + { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typ= ed" }, > + { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context= identified resource type does not match actual resource" }, > + { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a co= mmand only available when in FIPS mode" }, > + { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempti= ng to use an invalid family ID" }, > + { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to m= anipulate the NV storage is not available" }, > + { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a = signed command" }, > + { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to = load an NV key" }, > + { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires = both owner and blob authorization" }, > + { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not= writtable" }, > + { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect f= or the attempted operation" }, > + { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can'= t be written to" }, > + { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the= write to the NV area" }, > + { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does n= ot match" }, > + { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already bee= n written to" }, > + { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes = conflict" }, > + { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag= and version are invalid or inconsistent" }, > + { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under = control of the TPM Owner and can only be evicted by the TPM Owner." }, > + { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorre= ct" }, > + { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a comple= te write of the area" }, > + { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context= counts is too large" }, > + { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writ= es without an owner has been exceeded" }, > + { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value= is set" }, > + { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed = to by context is not loaded" }, > + { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administrati= on is locked" }, > + { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a f= amily other then the delegated family" }, > + { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table manage= ment not enabled" }, > + { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a c= ommand executed outside of an exclusive transport session" }, > +}; > + > + > +// helper function for the error codes: > +const char* tpm_get_error_name (TPM_RESULT code) { > + // just do a linear scan for now > + unsigned i; > + for (i =3D 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) > + if (code =3D=3D error_msgs[i].code) > + return error_msgs[i].code_name; > + > + return("Unknown Error Code"); > +} > diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h > new file mode 100644 > index 0000000..5c7abf5 > --- /dev/null > +++ b/stubdom/vtpmmgr/log.h > @@ -0,0 +1,85 @@ > +/* > + * 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_LOG_H__ > +#define __VTPM_LOG_H__ > + > +#include // for uint32_t > +#include // for pointer NULL > +#include > +#include "tcg.h" > + > +// =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D LOGGING =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D > + > +// the logging module numbers > +#define VTPM_LOG_TPM 1 > +#define VTPM_LOG_TPM_DEEP 2 > +#define VTPM_LOG_VTPM 3 > +#define VTPM_LOG_VTPM_DEEP 4 > +#define VTPM_LOG_TXDATA 5 > + > +extern char *module_names[]; > + > +// Default to standard logging > +#ifndef LOGGING_MODULES > +#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)|BITMASK(VTPM_LOG_TPM))= > +#endif > + > +// bit-access macros > +#define BITMASK(idx) ( 1U << (idx) ) > +#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) > +#define SETBIT(num,idx) (num) |=3D BITMASK(idx) > +#define CLEARBIT(num,idx) (num) &=3D ( ~ BITMASK(idx) ) > + > +#define vtpmloginfo(module, fmt, args...) \ > + if (GETBIT (LOGGING_MODULES, module) =3D=3D 1) { = \ > + fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); = \ > + } > + > +#define vtpmloginfomore(module, fmt, args...) \ > + if (GETBIT (LOGGING_MODULES, module) =3D=3D 1) { = \ > + fprintf (stdout, fmt,##args); \= > + } > + > +#define vtpmlogerror(module, fmt, args...) \ > + fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); > + > +//typedef UINT32 tpm_size_t; > + > +// helper function for the error codes: > +const char* tpm_get_error_name (TPM_RESULT code); > + > +#endif // _VTPM_LOG_H_ > diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h > new file mode 100644 > index 0000000..77d32f0 > --- /dev/null > +++ b/stubdom/vtpmmgr/marshal.h > @@ -0,0 +1,528 @@ > +/* > + * 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 MARSHAL_H > +#define MARSHAL_H > + > +#include > +#include > +#include > +#include "tcg.h" > + > +typedef enum UnpackPtr { > + UNPACK_ALIAS, > + UNPACK_ALLOC > +} UnpackPtr; > + > +inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { > + ptr[0] =3D t; > + return ++ptr; > +} > + > +inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { > + t[0] =3D ptr[0]; > + return ++ptr; > +} > + > +#define pack_BOOL(p, t) pack_BYTE(p, t) > +#define unpack_BOOL(p, t) unpack_BYTE(p, t) > + > +inline BYTE* pack_UINT16(BYTE* ptr, UINT16 t) { > + BYTE* b =3D (BYTE*)&t; > +#if __BYTE_ORDER =3D=3D __LITTLE_ENDIAN > + ptr[0] =3D b[1]; > + ptr[1] =3D b[0]; > +#elif __BYTE_ORDER =3D=3D __BIG_ENDIAN > + ptr[0] =3D b[0]; > + ptr[1] =3D b[1]; > +#endif > + return ptr + sizeof(UINT16); > +} > + > +inline BYTE* unpack_UINT16(BYTE* ptr, UINT16* t) { > + BYTE* b =3D (BYTE*)t; > +#if __BYTE_ORDER =3D=3D __LITTLE_ENDIAN > + b[0] =3D ptr[1]; > + b[1] =3D ptr[0]; > +#elif __BYTE_ORDER =3D=3D __BIG_ENDIAN > + b[0] =3D ptr[0]; > + b[1] =3D ptr[1]; > +#endif > + return ptr + sizeof(UINT16); > +} > + > +inline BYTE* pack_UINT32(BYTE* ptr, UINT32 t) { > + BYTE* b =3D (BYTE*)&t; > +#if __BYTE_ORDER =3D=3D __LITTLE_ENDIAN > + ptr[3] =3D b[0]; > + ptr[2] =3D b[1]; > + ptr[1] =3D b[2]; > + ptr[0] =3D b[3]; > +#elif __BYTE_ORDER =3D=3D __BIG_ENDIAN > + ptr[0] =3D b[0]; > + ptr[1] =3D b[1]; > + ptr[2] =3D b[2]; > + ptr[3] =3D b[3]; > +#endif > + return ptr + sizeof(UINT32); > +} > + > +inline BYTE* unpack_UINT32(BYTE* ptr, UINT32* t) { > + BYTE* b =3D (BYTE*)t; > +#if __BYTE_ORDER =3D=3D __LITTLE_ENDIAN > + b[0] =3D ptr[3]; > + b[1] =3D ptr[2]; > + b[2] =3D ptr[1]; > + b[3] =3D ptr[0]; > +#elif __BYTE_ORDER =3D=3D __BIG_ENDIAN > + b[0] =3D ptr[0]; > + b[1] =3D ptr[1]; > + b[2] =3D ptr[2]; > + b[3] =3D ptr[3]; > +#endif > + return ptr + sizeof(UINT32); > +} > + > +#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) > +#define pack_TPM_HANDLE(p, t) pack_UINT32(p, t) > +#define pack_TPM_AUTHHANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TCPA_HASHHANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TCPA_HMACHANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TCPA_ENCHANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TPM_KEY_HANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TCPA_ENTITYHANDLE(p, t) pack_TPM_HANDLE(p, t) > +#define pack_TPM_RESOURCE_TYPE(p, t) pack_UINT32(p, t) > +#define pack_TPM_COMMAND_CODE(p, t) pack_UINT32(p, t) > +#define pack_TPM_PROTOCOL_ID(p, t) pack_UINT16(p, t) > +#define pack_TPM_AUTH_DATA_USAGE(p, t) pack_BYTE(p, t) > +#define pack_TPM_ENTITY_TYPE(p, t) pack_UINT16(p, t) > +#define pack_TPM_ALGORITHM_ID(p, t) pack_UINT32(p, t) > +#define pack_TPM_KEY_USAGE(p, t) pack_UINT16(p, t) > +#define pack_TPM_STARTUP_TYPE(p, t) pack_UINT16(p, t) > +#define pack_TPM_CAPABILITY_AREA(p, t) pack_UINT32(p, t) > +#define pack_TPM_ENC_SCHEME(p, t) pack_UINT16(p, t) > +#define pack_TPM_SIG_SCHEME(p, t) pack_UINT16(p, t) > +#define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t) > +#define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t) > +#define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t) > + > +#define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_DIRINDEX(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_HANDLE(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_AUTHHANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TCPA_HASHHANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TCPA_HMACHANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TCPA_ENCHANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TPM_KEY_HANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TCPA_ENTITYHANDLE(p, t) unpack_TPM_HANDLE(p, t) > +#define unpack_TPM_RESOURCE_TYPE(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_COMMAND_CODE(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_PROTOCOL_ID(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_AUTH_DATA_USAGE(p, t) unpack_BYTE(p, t) > +#define unpack_TPM_ENTITY_TYPE(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_ALGORITHM_ID(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_KEY_USAGE(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_STARTUP_TYPE(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_CAPABILITY_AREA(p, t) unpack_UINT32(p, t) > +#define unpack_TPM_ENC_SCHEME(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_SIG_SCHEME(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, 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 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; > +} > + > +inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { > + memcpy(buf, ptr, size); > + return ptr + size; > +} > + > +inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 size) { > + *buf =3D ptr; > + return ptr + size; > +} > + > +inline BYTE* unpack_ALLOC(BYTE* ptr, BYTE** buf, UINT32 size) { > + if(size) { > + *buf =3D malloc(size); > + memcpy(*buf, ptr, size); > + } else { > + *buf =3D NULL; > + } > + return ptr + size; > +} > + > +inline BYTE* unpack_PTR(BYTE* ptr, BYTE** buf, UINT32 size, UnpackPtr = alloc) { > + if(alloc =3D=3D UNPACK_ALLOC) { > + return unpack_ALLOC(ptr, buf, size); > + } else { > + return unpack_ALIAS(ptr, buf, size); > + } > +} > + > +inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { > + 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); > +} > + > +#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) > +#define pack_TPM_TAG(p, t) pack_UINT16(p, t) > +#define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) > + > +#define unpack_TPM_SECRET(p, t) unpack_TPM_AUTHDATA(p, t) > +#define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) > +#define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) > +#define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) > +#define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, t) > + > +inline BYTE* pack_TPM_VERSION(BYTE* ptr, const TPM_VERSION* t) { > + ptr[0] =3D t->major; > + ptr[1] =3D t->minor; > + ptr[2] =3D t->revMajor; > + ptr[3] =3D t->revMinor; > + return ptr + 4; > +} > + > +inline BYTE* unpack_TPM_VERSION(BYTE* ptr, TPM_VERSION* t) { > + t->major =3D ptr[0]; > + t->minor =3D ptr[1]; > + t->revMajor =3D ptr[2]; > + t->revMinor =3D ptr[3]; > + return ptr + 4; > +} > + > +inline BYTE* pack_TPM_CAP_VERSION_INFO(BYTE* ptr, const TPM_CAP_VERSIO= N_INFO* v) { > + ptr =3D pack_TPM_STRUCTURE_TAG(ptr, v->tag); > + ptr =3D pack_TPM_VERSION(ptr, &v->version); > + ptr =3D pack_UINT16(ptr, v->specLevel); > + ptr =3D pack_BYTE(ptr, v->errataRev); > + ptr =3D pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); > + ptr =3D pack_UINT16(ptr, v->vendorSpecificSize); > + ptr =3D pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize);= > + return ptr; > +} > + > +inline BYTE* unpack_TPM_CAP_VERSION_INFO(BYTE* ptr, TPM_CAP_VERSION_IN= FO* v, UnpackPtr alloc) { > + ptr =3D unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); > + ptr =3D unpack_TPM_VERSION(ptr, &v->version); > + ptr =3D unpack_UINT16(ptr, &v->specLevel); > + ptr =3D unpack_BYTE(ptr, &v->errataRev); > + ptr =3D unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID));= > + ptr =3D unpack_UINT16(ptr, &v->vendorSpecificSize); > + ptr =3D 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); > +} > + > +inline BYTE* unpack_TPM_DIGEST(BYTE* ptr, TPM_DIGEST* d) { > + return unpack_BUFFER(ptr, 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 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_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); > +#define unpack_TPM_DIRVALUE(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); > +} > + > +inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { > + return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); > +} > + > +inline BYTE* pack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, const TPM_SYMMETR= IC_KEY_PARMS* k) { > + ptr =3D pack_UINT32(ptr, k->keyLength); > + ptr =3D pack_UINT32(ptr, k->blockSize); > + ptr =3D pack_UINT32(ptr, k->ivSize); > + return pack_BUFFER(ptr, k->IV, k->ivSize); > +} > + > +inline BYTE* unpack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, TPM_SYMMETRIC_K= EY_PARMS* k, UnpackPtr alloc) { > + ptr =3D unpack_UINT32(ptr, &k->keyLength); > + ptr =3D unpack_UINT32(ptr, &k->blockSize); > + ptr =3D unpack_UINT32(ptr, &k->ivSize); > + return unpack_PTR(ptr, &k->IV, k->ivSize, alloc); > +} > + > +inline BYTE* pack_TPM_RSA_KEY_PARMS(BYTE* ptr, const TPM_RSA_KEY_PARMS= * k) { > + ptr =3D pack_UINT32(ptr, k->keyLength); > + ptr =3D pack_UINT32(ptr, k->numPrimes); > + ptr =3D pack_UINT32(ptr, k->exponentSize); > + return pack_BUFFER(ptr, k->exponent, k->exponentSize); > +} > + > +inline BYTE* unpack_TPM_RSA_KEY_PARMS(BYTE* ptr, TPM_RSA_KEY_PARMS* k,= UnpackPtr alloc) { > + ptr =3D unpack_UINT32(ptr, &k->keyLength); > + ptr =3D unpack_UINT32(ptr, &k->numPrimes); > + ptr =3D unpack_UINT32(ptr, &k->exponentSize); > + return unpack_PTR(ptr, &k->exponent, k->exponentSize, alloc); > +} > + > +inline BYTE* pack_TPM_KEY_PARMS(BYTE* ptr, const TPM_KEY_PARMS* k) { > + ptr =3D pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); > + ptr =3D pack_TPM_ENC_SCHEME(ptr, k->encScheme); > + ptr =3D pack_TPM_SIG_SCHEME(ptr, k->sigScheme); > + ptr =3D 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, UnpackP= tr alloc) { > + ptr =3D unpack_TPM_ALGORITHM_ID(ptr, &k->algorithmID); > + ptr =3D unpack_TPM_ENC_SCHEME(ptr, &k->encScheme); > + ptr =3D unpack_TPM_SIG_SCHEME(ptr, &k->sigScheme); > + ptr =3D 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; > +} > + > +inline BYTE* pack_TPM_STORE_PUBKEY(BYTE* ptr, const TPM_STORE_PUBKEY* = k) { > + ptr =3D pack_UINT32(ptr, k->keyLength); > + ptr =3D pack_BUFFER(ptr, k->key, k->keyLength); > + return ptr; > +} > + > +inline BYTE* unpack_TPM_STORE_PUBKEY(BYTE* ptr, TPM_STORE_PUBKEY* k, U= npackPtr alloc) { > + ptr =3D unpack_UINT32(ptr, &k->keyLength); > + ptr =3D unpack_PTR(ptr, &k->key, k->keyLength, alloc); > + return ptr; > +} > + > +inline BYTE* pack_TPM_PUBKEY(BYTE* ptr, const TPM_PUBKEY* k) { > + ptr =3D 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 all= oc) { > + ptr =3D unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); > + return unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); > +} > + > +inline BYTE* pack_TPM_PCR_SELECTION(BYTE* ptr, const TPM_PCR_SELECTION= * p) { > + ptr =3D pack_UINT16(ptr, p->sizeOfSelect); > + ptr =3D pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); > + return ptr; > +} > + > +inline BYTE* unpack_TPM_PCR_SELECTION(BYTE* ptr, TPM_PCR_SELECTION* p,= UnpackPtr alloc) { > + ptr =3D unpack_UINT16(ptr, &p->sizeOfSelect); > + ptr =3D unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); > + return ptr; > +} > + > +inline BYTE* pack_TPM_PCR_INFO(BYTE* ptr, const TPM_PCR_INFO* p) { > + ptr =3D pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); > + ptr =3D pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); > + ptr =3D pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); > + return ptr; > +} > + > +inline BYTE* unpack_TPM_PCR_INFO(BYTE* ptr, TPM_PCR_INFO* p, UnpackPtr= alloc) { > + ptr =3D unpack_TPM_PCR_SELECTION(ptr, &p->pcrSelection, alloc); > + ptr =3D unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); > + ptr =3D unpack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); > + return ptr; > +} > + > +inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE= * p) { > + ptr =3D pack_TPM_PCR_SELECTION(ptr, &p->select); > + ptr =3D pack_UINT32(ptr, p->valueSize); > + ptr =3D 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 =3D unpack_TPM_PCR_SELECTION(ptr, &p->select, alloc); > + ptr =3D unpack_UINT32(ptr, &p->valueSize); > + ptr =3D unpack_PTR(ptr, (BYTE**)&p->pcrValue, p->valueSize, alloc);= > + return ptr; > +} > + > +inline BYTE* pack_TPM_KEY(BYTE* ptr, const TPM_KEY* k) { > + ptr =3D pack_TPM_VERSION(ptr, &k->ver); > + ptr =3D pack_TPM_KEY_USAGE(ptr, k->keyUsage); > + ptr =3D pack_TPM_KEY_FLAGS(ptr, k->keyFlags); > + ptr =3D pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); > + ptr =3D pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); > + ptr =3D pack_UINT32(ptr, k->PCRInfoSize); > + if(k->PCRInfoSize) { > + ptr =3D pack_TPM_PCR_INFO(ptr, &k->PCRInfo); > + } > + ptr =3D pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); > + ptr =3D 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 =3D unpack_TPM_VERSION(ptr, &k->ver); > + ptr =3D unpack_TPM_KEY_USAGE(ptr, &k->keyUsage); > + ptr =3D unpack_TPM_KEY_FLAGS(ptr, &k->keyFlags); > + ptr =3D unpack_TPM_AUTH_DATA_USAGE(ptr, &k->authDataUsage); > + ptr =3D unpack_TPM_KEY_PARMS(ptr, &k->algorithmParms, alloc); > + ptr =3D unpack_UINT32(ptr, &k->PCRInfoSize); > + if(k->PCRInfoSize) { > + ptr =3D unpack_TPM_PCR_INFO(ptr, &k->PCRInfo, alloc); > + } > + ptr =3D unpack_TPM_STORE_PUBKEY(ptr, &k->pubKey, alloc); > + ptr =3D unpack_UINT32(ptr, &k->encDataSize); > + return unpack_PTR(ptr, &k->encData, k->encDataSize, alloc); > +} > + > +inline BYTE* pack_TPM_BOUND_DATA(BYTE* ptr, const TPM_BOUND_DATA* b, U= INT32 payloadSize) { > + ptr =3D pack_TPM_VERSION(ptr, &b->ver); > + ptr =3D 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, UINT3= 2 payloadSize, UnpackPtr alloc) { > + ptr =3D unpack_TPM_VERSION(ptr, &b->ver); > + ptr =3D 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 =3D pack_TPM_VERSION(ptr, &d->ver); > + ptr =3D pack_UINT32(ptr, d->sealInfoSize); > + if(d->sealInfoSize) { > + ptr =3D pack_TPM_PCR_INFO(ptr, &d->sealInfo); > + } > + ptr =3D pack_UINT32(ptr, d->encDataSize); > + ptr =3D pack_BUFFER(ptr, d->encData, d->encDataSize); > + return ptr; > +} > + > +inline BYTE* unpack_TPM_STORED_DATA(BYTE* ptr, TPM_STORED_DATA* d, Unp= ackPtr alloc) { > + ptr =3D unpack_TPM_VERSION(ptr, &d->ver); > + ptr =3D unpack_UINT32(ptr, &d->sealInfoSize); > + if(d->sealInfoSize) { > + ptr =3D unpack_TPM_PCR_INFO(ptr, &d->sealInfo, alloc); > + } > + ptr =3D unpack_UINT32(ptr, &d->encDataSize); > + ptr =3D unpack_PTR(ptr, &d->encData, d->encDataSize, alloc); > + return ptr; > +} > + > +inline BYTE* pack_TPM_AUTH_SESSION(BYTE* ptr, const TPM_AUTH_SESSION* = auth) { > + ptr =3D pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); > + ptr =3D pack_TPM_NONCE(ptr, &auth->NonceOdd); > + ptr =3D pack_BOOL(ptr, auth->fContinueAuthSession); > + ptr =3D pack_TPM_AUTHDATA(ptr, &auth->HMAC); > + return ptr; > +} > + > +inline BYTE* unpack_TPM_AUTH_SESSION(BYTE* ptr, TPM_AUTH_SESSION* auth= ) { > + ptr =3D unpack_TPM_NONCE(ptr, &auth->NonceEven); > + ptr =3D unpack_BOOL(ptr, &auth->fContinueAuthSession); > + ptr =3D 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 =3D pack_UINT16(ptr, tag); > + ptr =3D 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 =3D unpack_UINT16(ptr, tag); > + ptr =3D unpack_UINT32(ptr, size); > + ptr =3D unpack_UINT32(ptr, ord); > + return ptr; > +} > + > +#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); > + > +#endif > diff --git a/stubdom/vtpmmgr/minios.cfg b/stubdom/vtpmmgr/minios.cfg > new file mode 100644 > index 0000000..3fb383d > --- /dev/null > +++ b/stubdom/vtpmmgr/minios.cfg > @@ -0,0 +1,14 @@ > +CONFIG_TPMFRONT=3Dy > +CONFIG_TPM_TIS=3Dy > +CONFIG_TPMBACK=3Dy > +CONFIG_START_NETWORK=3Dn > +CONFIG_TEST=3Dn > +CONFIG_PCIFRONT=3Dn > +CONFIG_BLKFRONT=3Dy > +CONFIG_NETFRONT=3Dn > +CONFIG_FBFRONT=3Dn > +CONFIG_KBDFRONT=3Dn > +CONFIG_CONSFRONT=3Dn > +CONFIG_XENBUS=3Dy > +CONFIG_LWIP=3Dn > +CONFIG_XC=3Dn > diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h > new file mode 100644 > index 0000000..7687eae > --- /dev/null > +++ b/stubdom/vtpmmgr/tcg.h > @@ -0,0 +1,707 @@ > +/* > + * 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 __TCG_H__ > +#define __TCG_H__ > + > +#include > +#include > + > +// **************************** CONSTANTS ****************************= ***** > + > +// BOOL values > +#define TRUE 0x01 > +#define FALSE 0x00 > + > +#define TCPA_MAX_BUFFER_LENGTH 0x2000 > + > +// > +// TPM_COMMAND_CODE values > +#define TPM_PROTECTED_ORDINAL 0x00000000UL > +#define TPM_UNPROTECTED_ORDINAL 0x80000000UL > +#define TPM_CONNECTION_ORDINAL 0x40000000UL > +#define TPM_VENDOR_ORDINAL 0x20000000UL > + > +#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL= ) > +#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINA= L) > +#define TPM_ORD_SaveContext (184UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_LoadContext (185UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_FlushSpecific (186UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_PCR_Reset (200UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_NV_DefineSpace (204UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_NV_WriteValue (205UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_NV_WriteValueAuth (206UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_NV_ReadValue (207UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_NV_ReadValueAuth (208UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_UpdateVerification (209UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_Manage (210UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_CreateKeyDelegation (212UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_CreateOwnerDelegation (213UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_VerifyDelegation (214UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_LoadOwnerDelegation (216UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_ReadAuth (217UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_Delegate_ReadTable (219UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_CreateCounter (220UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_IncrementCounter (221UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_ReadCounter (222UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_ReleaseCounter (223UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_ReleaseCounterOwner (224UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_EstablishTransport (230UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_ExecuteTransport (231UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_ReleaseTransportSigned (232UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_GetTicks (241UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_TickStampBlob (242UL + TPM_PROTECTE= D_ORDINAL) > +#define TPM_ORD_MAX (256UL + TPM_PROTECTE= D_ORDINAL) > + > +#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINA= L) > + > + > + > +// > +// TPM_RESULT values > +// > +// just put in the whole table from spec 1.2 > + > +#define TPM_BASE 0x0 // The start of TPM return codes > +#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error= code is vendor specific for vendor specific commands > +#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error c= ode is a non-fatal failure. > + > +#define TPM_SUCCESS TPM_BASE // Successful completion of the operati= on > +#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed > +#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or o= ther register is incorrect > +#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is= bad > +#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed su= ccessfully but the auditing of that operation failed. > +#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag = is set and all clear operations now require physical access > +#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated > +#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled > +#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has be= en disabled > +#define TPM_FAIL TPM_BASE + 9 // The operation failed > +#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown o= r inconsistent > +#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install= an owner is disabled > +#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle present= ed was invalid > +#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not fo= und > +#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryptio= n scheme > +#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization f= ailed > +#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could = not be interpreted > +#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. > +#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set > +#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is i= nvalid or was not created by this TPM > +#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner > +#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient i= nternal resources to perform the requested action. > +#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too s= hort > +#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the spac= e to perform the operation. > +#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does = not match the current PCR value. > +#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument= to the command has the incorrect value > +#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-= 1 thread. > +#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable = to proceed because the existing SHA-1 thread has already encountered an e= rror. > +#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed a= nd the TPM has shutdown. > +#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the = second key in a 2 key function failed authorization > +#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a = command is invalid > +#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmi= tting information to the TPM > +#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process = had a problem. > +#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process = did not complete. > +#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was = used. > +#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK = installed > +#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is = not allowed > +#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity t= ype is not allowed > +#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was receiv= ed in the wrong sequence relative to TPM_Init and a subsequent TPM_Startu= p > +#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot inc= lude additional DER information > +#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in = TPM_KEY_PARMs are not supported by this TPM > + > +#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properti= es of this key are incorrect. > +#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encrypt= ion scheme for this key is incorrect or not permitted in this situation. > +#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (o= r blob) parameter is bad or inconsistent with the referenced key > +#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, s= uch as capArea or subCapArea for TPM_GetCapability, phsicalPresence param= eter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBl= ob. > +#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPres= ence or physicalPresenceLock bits have the wrong value > +#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform t= his version of the capability > +#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not al= low for wrapped transport sessions > +#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construc= tion failed and the underlying command was returning a failure code also > +#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construc= tion failed and the underlying command was returning success > +#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR = register that does not have the resettable attribute > +#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR reg= ister that requires locality and locality modifier not part of command tr= ansport > +#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not pro= perly typed > +#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context = identified resource type does not match actual resource > +#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to ex= ecute a command only available when in FIPS mode > +#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attemp= ting to use an invalid family ID > +#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to ma= nipulate the NV storage is not available > +#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires= a signed command > +#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to l= oad an NV key > +#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requir= es both owner and blob authorization > +#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked an= d not writtable > +#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorre= ct for the attempted operation > +#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only = and can't be written to > +#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection o= n the write to the NV area > +#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value d= oes not match > +#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already= been written to > +#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attribute= s conflict > +#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag a= nd version are invalid or inconsistent > +#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under co= ntrol of the TPM Owner and can only be evicted by the TPM Owner. > +#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is in= correct > +#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a com= plete write of the area > +#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved co= ntext counts is too large > +#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV= writes without an owner has been exceeded > +#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorizatio= n value is set > +#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed = to by context is not loaded > +#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administr= ation is locked > +#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a f= amily other then the delegated family > +#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table mana= gement not enabled > +#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a comman= d executed outside of an exclusive transport session > + > +// TPM_STARTUP_TYPE values > +#define TPM_ST_CLEAR 0x0001 > +#define TPM_ST_STATE 0x0002 > +#define TPM_ST_DEACTIVATED 0x003 > + > +// TPM_TAG values > +#define TPM_TAG_RQU_COMMAND 0x00c1 > +#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 > +#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 > +#define TPM_TAG_RSP_COMMAND 0x00c4 > +#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 > +#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 > + > +// TPM_PAYLOAD_TYPE values > +#define TPM_PT_ASYM 0x01 > +#define TPM_PT_BIND 0x02 > +#define TPM_PT_MIGRATE 0x03 > +#define TPM_PT_MAINT 0x04 > +#define TPM_PT_SEAL 0x05 > + > +// TPM_ENTITY_TYPE values > +#define TPM_ET_KEYHANDLE 0x0001 > +#define TPM_ET_OWNER 0x0002 > +#define TPM_ET_DATA 0x0003 > +#define TPM_ET_SRK 0x0004 > +#define TPM_ET_KEY 0x0005 > + > +/// TPM_ResourceTypes > +#define TPM_RT_KEY 0x00000001 > +#define TPM_RT_AUTH 0x00000002 > +#define TPM_RT_HASH 0x00000003 > +#define TPM_RT_TRANS 0x00000004 > +#define TPM_RT_CONTEXT 0x00000005 > +#define TPM_RT_COUNTER 0x00000006 > +#define TPM_RT_DELEGATE 0x00000007 > +#define TPM_RT_DAA_TPM 0x00000008 > +#define TPM_RT_DAA_V0 0x00000009 > +#define TPM_RT_DAA_V1 0x0000000A > + > + > + > +// TPM_PROTOCOL_ID values > +#define TPM_PID_OIAP 0x0001 > +#define TPM_PID_OSAP 0x0002 > +#define TPM_PID_ADIP 0x0003 > +#define TPM_PID_ADCP 0x0004 > +#define TPM_PID_OWNER 0x0005 > + > +// TPM_ALGORITHM_ID values > +#define TPM_ALG_RSA 0x00000001 > +#define TPM_ALG_SHA 0x00000004 > +#define TPM_ALG_HMAC 0x00000005 > +#define TPM_ALG_AES128 0x00000006 > +#define TPM_ALG_MFG1 0x00000007 > +#define TPM_ALG_AES192 0x00000008 > +#define TPM_ALG_AES256 0x00000009 > +#define TPM_ALG_XOR 0x0000000A > + > +// TPM_ENC_SCHEME values > +#define TPM_ES_NONE 0x0001 > +#define TPM_ES_RSAESPKCSv15 0x0002 > +#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 > + > +// TPM_SIG_SCHEME values > +#define TPM_SS_NONE 0x0001 > +#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 > +#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 > + > +/* > + * TPM_CAPABILITY_AREA Values for TPM_GetCapability ([TPM_Part2], Sect= ion 21.1) > + */ > +#define TPM_CAP_ORD 0x00000001 > +#define TPM_CAP_ALG 0x00000002 > +#define TPM_CAP_PID 0x00000003 > +#define TPM_CAP_FLAG 0x00000004 > +#define TPM_CAP_PROPERTY 0x00000005 > +#define TPM_CAP_VERSION 0x00000006 > +#define TPM_CAP_KEY_HANDLE 0x00000007 > +#define TPM_CAP_CHECK_LOADED 0x00000008 > +#define TPM_CAP_SYM_MODE 0x00000009 > +#define TPM_CAP_KEY_STATUS 0x0000000C > +#define TPM_CAP_NV_LIST 0x0000000D > +#define TPM_CAP_MFR 0x00000010 > +#define TPM_CAP_NV_INDEX 0x00000011 > +#define TPM_CAP_TRANS_ALG 0x00000012 > +#define TPM_CAP_HANDLE 0x00000014 > +#define TPM_CAP_TRANS_ES 0x00000015 > +#define TPM_CAP_AUTH_ENCRYPT 0x00000017 > +#define TPM_CAP_SELECT_SIZE 0x00000018 > +#define TPM_CAP_DA_LOGIC 0x00000019 > +#define TPM_CAP_VERSION_VAL 0x0000001A > + > +/* subCap definitions ([TPM_Part2], Section 21.2) */ > +#define TPM_CAP_PROP_PCR 0x00000101 > +#define TPM_CAP_PROP_DIR 0x00000102 > +#define TPM_CAP_PROP_MANUFACTURER 0x00000103 > +#define TPM_CAP_PROP_KEYS 0x00000104 > +#define TPM_CAP_PROP_MIN_COUNTER 0x00000107 > +#define TPM_CAP_FLAG_PERMANENT 0x00000108 > +#define TPM_CAP_FLAG_VOLATILE 0x00000109 > +#define TPM_CAP_PROP_AUTHSESS 0x0000010A > +#define TPM_CAP_PROP_TRANSESS 0x0000010B > +#define TPM_CAP_PROP_COUNTERS 0x0000010C > +#define TPM_CAP_PROP_MAX_AUTHSESS 0x0000010D > +#define TPM_CAP_PROP_MAX_TRANSESS 0x0000010E > +#define TPM_CAP_PROP_MAX_COUNTERS 0x0000010F > +#define TPM_CAP_PROP_MAX_KEYS 0x00000110 > +#define TPM_CAP_PROP_OWNER 0x00000111 > +#define TPM_CAP_PROP_CONTEXT 0x00000112 > +#define TPM_CAP_PROP_MAX_CONTEXT 0x00000113 > +#define TPM_CAP_PROP_FAMILYROWS 0x00000114 > +#define TPM_CAP_PROP_TIS_TIMEOUT 0x00000115 > +#define TPM_CAP_PROP_STARTUP_EFFECT 0x00000116 > +#define TPM_CAP_PROP_DELEGATE_ROW 0x00000117 > +#define TPM_CAP_PROP_MAX_DAASESS 0x00000119 > +#define TPM_CAP_PROP_DAASESS 0x0000011A > +#define TPM_CAP_PROP_CONTEXT_DIST 0x0000011B > +#define TPM_CAP_PROP_DAA_INTERRUPT 0x0000011C > +#define TPM_CAP_PROP_SESSIONS 0x0000011D > +#define TPM_CAP_PROP_MAX_SESSIONS 0x0000011E > +#define TPM_CAP_PROP_CMK_RESTRICTION 0x0000011F > +#define TPM_CAP_PROP_DURATION 0x00000120 > +#define TPM_CAP_PROP_ACTIVE_COUNTER 0x00000122 > +#define TPM_CAP_PROP_MAX_NV_AVAILABLE 0x00000123 > +#define TPM_CAP_PROP_INPUT_BUFFER 0x00000124 > + > +// TPM_KEY_USAGE values > +#define TPM_KEY_EK 0x0000 > +#define TPM_KEY_SIGNING 0x0010 > +#define TPM_KEY_STORAGE 0x0011 > +#define TPM_KEY_IDENTITY 0x0012 > +#define TPM_KEY_AUTHCHANGE 0X0013 > +#define TPM_KEY_BIND 0x0014 > +#define TPM_KEY_LEGACY 0x0015 > + > +// TPM_AUTH_DATA_USAGE values > +#define TPM_AUTH_NEVER 0x00 > +#define TPM_AUTH_ALWAYS 0x01 > + > +// Key Handle of owner and srk > +#define TPM_OWNER_KEYHANDLE 0x40000001 > +#define TPM_SRK_KEYHANDLE 0x40000000 > + > + > + > +// *************************** TYPEDEFS ******************************= *** > +typedef unsigned char BYTE; > +typedef unsigned char BOOL; > +typedef uint16_t UINT16; > +typedef uint32_t UINT32; > +typedef uint64_t UINT64; > + > +typedef UINT32 TPM_RESULT; > +typedef UINT32 TPM_PCRINDEX; > +typedef UINT32 TPM_DIRINDEX; > +typedef UINT32 TPM_HANDLE; > +typedef TPM_HANDLE TPM_AUTHHANDLE; > +typedef TPM_HANDLE TCPA_HASHHANDLE; > +typedef TPM_HANDLE TCPA_HMACHANDLE; > +typedef TPM_HANDLE TCPA_ENCHANDLE; > +typedef TPM_HANDLE TPM_KEY_HANDLE; > +typedef TPM_HANDLE TCPA_ENTITYHANDLE; > +typedef UINT32 TPM_RESOURCE_TYPE; > +typedef UINT32 TPM_COMMAND_CODE; > +typedef UINT16 TPM_PROTOCOL_ID; > +typedef BYTE TPM_AUTH_DATA_USAGE; > +typedef UINT16 TPM_ENTITY_TYPE; > +typedef UINT32 TPM_ALGORITHM_ID; > +typedef UINT16 TPM_KEY_USAGE; > +typedef UINT16 TPM_STARTUP_TYPE; > +typedef UINT32 TPM_CAPABILITY_AREA; > +typedef UINT16 TPM_ENC_SCHEME; > +typedef UINT16 TPM_SIG_SCHEME; > +typedef UINT16 TPM_MIGRATE_SCHEME; > +typedef UINT16 TPM_PHYSICAL_PRESENCE; > +typedef UINT32 TPM_KEY_FLAGS; > + > +#define TPM_DIGEST_SIZE 20 // Don't change this > +typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; > +typedef TPM_AUTHDATA TPM_SECRET; > +typedef TPM_AUTHDATA TPM_ENCAUTH; > +typedef BYTE TPM_PAYLOAD_TYPE; > +typedef UINT16 TPM_TAG; > +typedef UINT16 TPM_STRUCTURE_TAG; > + > +// Data Types of the TCS > +typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization s= ession > +typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle > +typedef UINT32 TCS_KEY_HANDLE; // Basic key handle > + > +// ************************* STRUCTURES ******************************= **** > + > +typedef struct TPM_VERSION { > + BYTE major; > + BYTE minor; > + BYTE revMajor; > + BYTE revMinor; > +} TPM_VERSION; > + > +static const TPM_VERSION TPM_STRUCT_VER_1_1 =3D { 1,1,0,0 }; > + > +typedef struct TPM_CAP_VERSION_INFO { > + TPM_STRUCTURE_TAG tag; > + TPM_VERSION version; > + UINT16 specLevel; > + BYTE errataRev; > + BYTE tpmVendorID[4]; > + UINT16 vendorSpecificSize; > + BYTE* vendorSpecific; > +} TPM_CAP_VERSION_INFO; > + > +inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { > + free(v->vendorSpecific); > + v->vendorSpecific =3D NULL; > +} > + > +typedef struct TPM_DIGEST { > + BYTE digest[TPM_DIGEST_SIZE]; > +} TPM_DIGEST; > + > +typedef TPM_DIGEST TPM_PCRVALUE; > +typedef TPM_DIGEST TPM_COMPOSITE_HASH; > +typedef TPM_DIGEST TPM_DIRVALUE; > +typedef TPM_DIGEST TPM_HMAC; > +typedef TPM_DIGEST TPM_CHOSENID_HASH; > + > +typedef struct TPM_NONCE { > + BYTE nonce[TPM_DIGEST_SIZE]; > +} TPM_NONCE; > + > +typedef struct TPM_SYMMETRIC_KEY_PARMS { > + UINT32 keyLength; > + UINT32 blockSize; > + UINT32 ivSize; > + BYTE* IV; > +} TPM_SYMMETRIC_KEY_PARMS; > + > +inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) {= > + free(p->IV); > + p->IV =3D NULL; > +} > + > +#define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } > + > +typedef struct TPM_RSA_KEY_PARMS { > + UINT32 keyLength; > + UINT32 numPrimes; > + UINT32 exponentSize; > + BYTE* exponent; > +} TPM_RSA_KEY_PARMS; > + > +#define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } > + > +inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { > + free(p->exponent); > + p->exponent =3D NULL; > +} > + > +typedef struct TPM_KEY_PARMS { > + TPM_ALGORITHM_ID algorithmID; > + TPM_ENC_SCHEME encScheme; > + TPM_SIG_SCHEME sigScheme; > + UINT32 parmSize; > + union { > + TPM_SYMMETRIC_KEY_PARMS sym; > + TPM_RSA_KEY_PARMS rsa; > + } parms; > +} TPM_KEY_PARMS; > + > +#define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } > + > +inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { > + if(p->parmSize) { > + switch(p->algorithmID) { > + case TPM_ALG_RSA: > + free_TPM_RSA_KEY_PARMS(&p->parms.rsa); > + break; > + case TPM_ALG_AES128: > + case TPM_ALG_AES192: > + case TPM_ALG_AES256: > + free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); > + break; > + } > + } > +} > + > +typedef struct TPM_STORE_PUBKEY { > + UINT32 keyLength; > + BYTE* key; > +} TPM_STORE_PUBKEY; > + > +#define TPM_STORE_PUBKEY_INIT { 0, NULL } > + > +inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { > + free(p->key); > + p->key =3D NULL; > +} > + > +typedef struct TPM_PUBKEY { > + TPM_KEY_PARMS algorithmParms; > + TPM_STORE_PUBKEY pubKey; > +} TPM_PUBKEY; > + > +#define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } > + > +inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { > + free_TPM_KEY_PARMS(&k->algorithmParms); > + free_TPM_STORE_PUBKEY(&k->pubKey); > +} > + > +typedef struct TPM_PCR_SELECTION { > + UINT16 sizeOfSelect; > + BYTE* pcrSelect; > +} TPM_PCR_SELECTION; > + > +#define TPM_PCR_SELECTION_INIT { 0, NULL } > + > +inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { > + free(p->pcrSelect); > + p->pcrSelect =3D NULL; > +} > + > +typedef struct TPM_PCR_INFO { > + TPM_PCR_SELECTION pcrSelection; > + TPM_COMPOSITE_HASH digestAtRelease; > + TPM_COMPOSITE_HASH digestAtCreation; > +} TPM_PCR_INFO; > + > +#define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } > + > +inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { > + free_TPM_PCR_SELECTION(&p->pcrSelection); > +} > + > +typedef struct TPM_PCR_COMPOSITE { > + TPM_PCR_SELECTION select; > + UINT32 valueSize; > + TPM_PCRVALUE* pcrValue; > +} TPM_PCR_COMPOSITE; > + > +#define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } > + > +inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { > + free_TPM_PCR_SELECTION(&p->select); > + free(p->pcrValue); > + p->pcrValue =3D NULL; > +} > + > +typedef struct TPM_KEY { > + TPM_VERSION ver; > + TPM_KEY_USAGE keyUsage; > + TPM_KEY_FLAGS keyFlags; > + TPM_AUTH_DATA_USAGE authDataUsage; > + TPM_KEY_PARMS algorithmParms; > + UINT32 PCRInfoSize; > + TPM_PCR_INFO PCRInfo; > + TPM_STORE_PUBKEY pubKey; > + UINT32 encDataSize; > + BYTE* encData; > +} TPM_KEY; > + > +#define TPM_KEY_INIT { .algorithmParms =3D TPM_KEY_PARMS_INIT,\ > + .PCRInfoSize =3D 0, .PCRInfo =3D TPM_PCR_INFO_INIT, \ > + .pubKey =3D TPM_STORE_PUBKEY_INIT, \ > + .encDataSize =3D 0, .encData =3D NULL } > + > +inline void free_TPM_KEY(TPM_KEY* k) { > + if(k->PCRInfoSize) { > + free_TPM_PCR_INFO(&k->PCRInfo); > + } > + free_TPM_STORE_PUBKEY(&k->pubKey); > + free(k->encData); > + k->encData =3D NULL; > +} > + > +typedef struct TPM_BOUND_DATA { > + TPM_VERSION ver; > + TPM_PAYLOAD_TYPE payload; > + BYTE* payloadData; > +} TPM_BOUND_DATA; > + > +#define TPM_BOUND_DATA_INIT { .payloadData =3D NULL } > + > +inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { > + free(d->payloadData); > + d->payloadData =3D NULL; > +} > + > +typedef struct TPM_STORED_DATA { > + TPM_VERSION ver; > + UINT32 sealInfoSize; > + TPM_PCR_INFO sealInfo; > + UINT32 encDataSize; > + BYTE* encData; > +} TPM_STORED_DATA; > + > +#define TPM_STORED_DATA_INIT { .sealInfoSize =3D 0, sealInfo =3D TPM_P= CR_INFO_INIT,\ > + .encDataSize =3D 0, .encData =3D NULL } > + > +inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { > + if(d->sealInfoSize) { > + free_TPM_PCR_INFO(&d->sealInfo); > + } > + free(d->encData); > + d->encData =3D NULL; > +} > + > +typedef struct TPM_AUTH_SESSION { > + TPM_AUTHHANDLE AuthHandle; > + TPM_NONCE NonceOdd; // system > + TPM_NONCE NonceEven; // TPM > + BOOL fContinueAuthSession; > + TPM_AUTHDATA HMAC; > +} TPM_AUTH_SESSION; > + > +#define TPM_AUTH_SESSION_INIT { .AuthHandle =3D 0, .fContinueAuthSessi= on =3D FALSE } > + > +// ---------------------- Functions for checking TPM_RESULTs ---------= -------- > + > +#include > + > +// FIXME: Review use of these and delete unneeded ones. > + > +// these are really badly dependent on local structure: > +// DEPENDS: local var 'status' of type TPM_RESULT > +// DEPENDS: label 'abort_egress' which cleans up and returns the statu= s > +#define ERRORDIE(s) do { status =3D s; \ > + fprintf (stderr, "*** ERRORDIE in %s at %s: %= i\n", __func__, __FILE__, __LINE__); \ > + goto abort_egress; } \ > + while (0) > + > +// DEPENDS: local var 'status' of type TPM_RESULT > +// DEPENDS: label 'abort_egress' which cleans up and returns the statu= s > +// Try command c. If it fails, set status to s and goto abort. > +#define TPMTRY(s,c) if (c !=3D TPM_SUCCESS) { \ > + status =3D s; \ > + printf("ERROR in %s at %s:%i code: %s.\n", __fu= nc__, __FILE__, __LINE__, tpm_get_error_name(status)); \ > + goto abort_egress; \ > + } else {\ > + status =3D c; \ > + } > + > +// Try command c. If it fails, print error message, set status to actu= al return code. Goto abort > +#define TPMTRYRETURN(c) do { status =3D c; \ > + if (status !=3D TPM_SUCCESS) { \ > + fprintf(stderr, "ERROR in %s at %s:%i c= ode: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \= > + goto abort_egress; \ > + } \ > + } while(0) > + > + > +#endif //__TCPA_H__ > diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c > new file mode 100644 > index 0000000..123a27c > --- /dev/null > +++ b/stubdom/vtpmmgr/tpm.c > @@ -0,0 +1,938 @@ > +/* > + * 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. > +*/ > + > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "tcg.h" > +#include "tpm.h" > +#include "log.h" > +#include "marshal.h" > +#include "tpmrsa.h" > +#include "vtpmmgr.h" > + > +#define TCPA_MAX_BUFFER_LENGTH 0x2000 > + > +#define TPM_BEGIN(TAG, ORD) \ > + const TPM_TAG intag =3D TAG;\ > +TPM_TAG tag =3D intag;\ > +UINT32 paramSize;\ > +const TPM_COMMAND_CODE ordinal =3D ORD;\ > +TPM_RESULT status =3D TPM_SUCCESS;\ > +BYTE in_buf[TCPA_MAX_BUFFER_LENGTH];\ > +BYTE out_buf[TCPA_MAX_BUFFER_LENGTH];\ > +UINT32 out_len =3D sizeof(out_buf);\ > +BYTE* ptr =3D in_buf;\ > +/*Print a log message */\ > +vtpmloginfo(VTPM_LOG_TPM, "%s\n", __func__);\ > +/* Pack the header*/\ > +ptr =3D pack_TPM_TAG(ptr, tag);\ > +ptr +=3D sizeof(UINT32);\ > +ptr =3D pack_TPM_COMMAND_CODE(ptr, ordinal)\ > + > +#define TPM_AUTH_BEGIN() \ > + sha1_context sha1_ctx;\ > +BYTE* authbase =3D 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 =3D pack_TPM_AUTH_SESSION(ptr, auth);\ > +} while(0) > + > +#define TPM_AUTH2_GEN(HMACkey, auth) do {\ > + generateAuth(¶mDigest, HMACkey, auth);\ > + ptr =3D pack_TPM_AUTH_SESSION(ptr, auth);\ > +} while(0) > + > +#define TPM_TRANSMIT() do {\ > + /* Pack the command size */\ > + paramSize =3D ptr - in_buf;\ > + pack_UINT32(in_buf + sizeof(TPM_TAG), paramSize);\ > + if((status =3D TPM_TransmitData(in_buf, paramSize, out_buf, &out_le= n)) !=3D TPM_SUCCESS) {\ > + goto abort_egress;\ > + }\ > +} while(0) > + > +#define TPM_AUTH_VERIFY_BEGIN() do {\ > + UINT32 buf[2] =3D { cpu_to_be32(status), cpu_to_be32(ordinal) };\ > + sha1_starts(&sha1_ctx);\ > + sha1_update(&sha1_ctx, (unsigned char*)buf, sizeof(buf));\ > + authbase =3D ptr;\ > +} while(0) > + > +#define TPM_AUTH1_VERIFY(HMACkey, auth) do {\ > + sha1_finish(&sha1_ctx, paramDigest.digest);\ > + ptr =3D unpack_TPM_AUTH_SESSION(ptr, auth);\ > + if((status =3D verifyAuth(¶mDigest, HMACkey, auth)) !=3D TPM_SU= CCESS) {\ > + goto abort_egress;\ > + }\ > +} while(0) > + > +#define TPM_AUTH2_VERIFY(HMACkey, auth) do {\ > + ptr =3D unpack_TPM_AUTH_SESSION(ptr, auth);\ > + if((status =3D verifyAuth(¶mDigest, HMACkey, auth)) !=3D TPM_SU= CCESS) {\ > + goto abort_egress;\ > + }\ > +} while(0) > + > + > + > +#define TPM_UNPACK_VERIFY() do { \ > + ptr =3D out_buf;\ > + ptr =3D unpack_TPM_RSP_HEADER(ptr, \ > + &(tag), &(paramSize), &(status));\ > + if((status) !=3D TPM_SUCCESS || (tag) !=3D (intag +3)) { \ > + vtpmlogerror(VTPM_LOG_TPM, "Failed with return code %s\n", tpm_g= et_error_name(status));\ > + goto abort_egress;\ > + }\ > +} while(0) > + > +#define TPM_AUTH_HASH() do {\ > + sha1_update(&sha1_ctx, authbase, ptr - authbase);\ > + authbase =3D ptr;\ > +} while(0) > + > +#define TPM_AUTH_SKIP() do {\ > + authbase =3D ptr;\ > +} while(0) > + > +#define TPM_AUTH_ERR_CHECK(auth) do {\ > + if(status !=3D TPM_SUCCESS || auth->fContinueAuthSession =3D=3D FAL= SE) {\ > + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM\n", = auth->AuthHandle);\ > + auth->AuthHandle =3D 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 =3D XORbuffer; > + ptr =3D pack_TPM_SECRET(ptr, sharedSecret); > + ptr =3D pack_TPM_NONCE(ptr, nonce); > + > + sha1(XORbuffer, ptr - XORbuffer, XORkey); > + > + if(inAuth0) { > + for(int i =3D 0; i < TPM_DIGEST_SIZE; ++i) { > + outAuth0[i] =3D XORkey[i] ^ (*inAuth0)[i]; > + } > + } > + if(inAuth1) { > + for(int i =3D 0; i < TPM_DIGEST_SIZE; ++i) { > + outAuth1[i] =3D XORkey[i] ^ (*inAuth1)[i]; > + } > + } > + > +} > + > +static void generateAuth(const TPM_DIGEST* paramDigest, > + const TPM_SECRET* HMACkey, > + TPM_AUTH_SESSION *auth) > +{ > + //Generate new OddNonce > + vtpmmgr_rand((BYTE*)auth->NonceOdd.nonce, sizeof(TPM_NONCE)); > + > + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams)= =2E > + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof= (BOOL)]; > + BYTE* ptr =3D hmacText; > + > + ptr =3D pack_TPM_DIGEST(ptr, paramDigest); > + ptr =3D pack_TPM_NONCE(ptr, &auth->NonceEven); > + ptr =3D pack_TPM_NONCE(ptr, &auth->NonceOdd); > + ptr =3D pack_BOOL(ptr, auth->fContinueAuthSession); > + > + 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) > +{ > + > + // Create HMAC text. (Concat inParamsDigest with inAuthSetupParams)= =2E > + TPM_AUTHDATA hm; > + BYTE hmacText[sizeof(TPM_DIGEST) + (2 * sizeof(TPM_NONCE)) + sizeof= (BOOL)]; > + BYTE* ptr =3D hmacText; > + > + ptr =3D pack_TPM_DIGEST(ptr, paramDigest); > + ptr =3D pack_TPM_NONCE(ptr, &auth->NonceEven); > + ptr =3D pack_TPM_NONCE(ptr, &auth->NonceOdd); > + ptr =3D 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)) =3D=3D 0) { // 0 ind= icates equality > + return TPM_SUCCESS; > + } else { > + vtpmlogerror(VTPM_LOG_TPM, "Auth Session verification failed!\n"= ); > + return TPM_AUTHFAIL; > + } > +} > + > + > + > +// ------------------------------------------------------------------ > +// Authorization Commands > +// ------------------------------------------------------------------ > + > +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out > +{ > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > + auth->fContinueAuthSession =3D TRUE; > + > + ptr =3D unpack_UINT32(ptr, &auth->AuthHandle); > + ptr =3D unpack_TPM_NONCE(ptr, &auth->NonceEven); > + > + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n= ", auth->AuthHandle); > + > +abort_egress: > + 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) > +{ > + BYTE* nonceOddOSAP; > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); > + > + ptr =3D pack_TPM_ENTITY_TYPE(ptr, entityType); > + ptr =3D pack_UINT32(ptr, entityValue); > + > + //nonce Odd OSAP > + nonceOddOSAP =3D ptr; > + vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); > + ptr +=3D TPM_DIGEST_SIZE; > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + ptr =3D unpack_UINT32(ptr, &auth->AuthHandle); > + ptr =3D unpack_TPM_NONCE(ptr, &auth->NonceEven); > + > + //Calculate session secret > + sha1_context ctx; > + sha1_hmac_starts(&ctx, *usageAuth, TPM_DIGEST_SIZE); > + sha1_hmac_update(&ctx, ptr, TPM_DIGEST_SIZE); //ptr =3D nonceEvenOS= AP > + sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); > + sha1_hmac_finish(&ctx, *sharedSecret); > + > + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); > + auth->fContinueAuthSession =3D FALSE; > + > + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OSAP.\n= ", auth->AuthHandle); > + > +abort_egress: > + 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 > +{ > + int keyAlloced =3D 0; > + tpmrsa_context ek_rsa =3D 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 =3D pack_UINT16(ptr, TPM_PID_OWNER); > + > + /* Pack the encrypted owner auth */ > + ptr =3D 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 +=3D pubEK->algorithmParms.parms.rsa.keyLength / 8; > + > + /* Pack the encrypted srk auth */ > + ptr =3D 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 +=3D pubEK->algorithmParms.parms.rsa.keyLength / 8; > + > + /* Pack the Srk key */ > + ptr =3D 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 !=3D NULL) { > + /* If the user wants a copy of the srk we give it to them */ > + keyAlloced =3D 1; > + ptr =3D unpack_TPM_KEY(ptr, outSrk, UNPACK_ALLOC); > + } else { > + /*otherwise just parse past it */ > + TPM_KEY temp; > + ptr =3D unpack_TPM_KEY(ptr, &temp, UNPACK_ALIAS); > + } > + > + /* Hash the output key */ > + TPM_AUTH_HASH(); > + > + /* Verify authorizaton */ > + TPM_AUTH1_VERIFY(ownerAuth, auth); > + > + goto egress; > +abort_egress: > + if(keyAlloced) { > + free_TPM_KEY(outSrk); > + } > +egress: > + tpmrsa_free(&ek_rsa); > + TPM_AUTH_ERR_CHECK(auth); > + return status; > +} > + > + > +TPM_RESULT TPM_DisablePubekRead ( > + 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_AUTH1_GEN(ownerAuth, auth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + TPM_AUTH1_VERIFY(ownerAuth, auth); > + > +abort_egress: > + TPM_AUTH_ERR_CHECK(auth); > + return status; > +} > + > + > +TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in > +{ > + if(handle =3D=3D 0) { > + return TPM_SUCCESS; > + } > + > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); > + > + ptr =3D pack_TPM_AUTHHANDLE(ptr, handle); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_Termina= teHandle\n", handle); > + > +abort_egress: > + return status; > +} > + > +TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in > + TPM_DIGEST inDigest, // in > + TPM_PCRVALUE* outDigest) // out > +{ > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); > + > + ptr =3D pack_TPM_PCRINDEX(ptr, pcrNum); > + ptr =3D pack_TPM_DIGEST(ptr, &inDigest); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + ptr =3D unpack_TPM_PCRVALUE(ptr, outDigest); > + > +abort_egress: > + 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 > + ) > +{ > + int dataAlloced =3D 0; > + TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_Seal); > + TPM_AUTH_BEGIN(); > + > + TPM_AUTH_HASH(); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, keyHandle); > + > + TPM_AUTH_SKIP(); > + > + xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, > + sealedDataAuth, ptr, > + NULL, NULL); > + ptr +=3D sizeof(TPM_ENCAUTH); > + > + ptr =3D pack_UINT32(ptr, pcrInfoSize); > + ptr =3D pack_TPM_PCR_INFO(ptr, pcrInfo); > + > + ptr =3D pack_UINT32(ptr, inDataSize); > + ptr =3D pack_BUFFER(ptr, inData, inDataSize); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_GEN(osapSharedSecret, pubAuth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + ptr =3D unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); > + dataAlloced =3D 1; > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); > + > + goto egress; > +abort_egress: > + if(dataAlloced) { > + free_TPM_STORED_DATA(sealedData); > + } > +egress: > + TPM_AUTH_ERR_CHECK(pubAuth); > + 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_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); > + TPM_AUTH_BEGIN(); > + > + TPM_AUTH_HASH(); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, parentHandle); > + > + TPM_AUTH_SKIP(); > + > + ptr =3D pack_TPM_STORED_DATA(ptr, sealedData); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_GEN(key_usage_auth, keyAuth); > + TPM_AUTH2_GEN(data_usage_auth, dataAuth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + ptr =3D unpack_UINT32(ptr, outSize); > + ptr =3D unpack_ALLOC(ptr, out, *outSize); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); > + TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); > + > +abort_egress: > + TPM_AUTH_ERR_CHECK(keyAuth); > + TPM_AUTH_ERR_CHECK(dataAuth); > + return status; > +} > + > +TPM_RESULT TPM_Bind( > + const TPM_KEY* key, > + const BYTE* in, > + UINT32 ilen, > + BYTE* out) > +{ > + TPM_RESULT status; > + tpmrsa_context rsa =3D TPMRSA_CTX_INIT; > + TPM_BOUND_DATA boundData; > + uint8_t plain[TCPA_MAX_BUFFER_LENGTH]; > + BYTE* ptr =3D 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 =3D TPM_STRUCT_VER_1_1; > + boundData.payload =3D TPM_PT_BIND; > + boundData.payloadData =3D (BYTE*)in; > + > + //marshall the bound data object > + ptr =3D 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)); > + > +abort_egress: > + tpmrsa_free(&rsa); > + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); > + TPM_AUTH_BEGIN(); > + > + TPM_AUTH_HASH(); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, keyHandle); > + > + TPM_AUTH_SKIP(); > + > + ptr =3D pack_UINT32(ptr, ilen); > + ptr =3D pack_BUFFER(ptr, in, ilen); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_GEN(usage_auth, auth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + ptr =3D unpack_UINT32(ptr, olen); > + if(*olen > ilen) { > + vtpmlogerror(VTPM_LOG_TPM, "Output length < input length!\n"); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + ptr =3D unpack_BUFFER(ptr, out, *olen); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_VERIFY(usage_auth, auth); > + > +abort_egress: > +egress: > + TPM_AUTH_ERR_CHECK(auth); > + 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 > +{ > + int keyAlloced =3D 0; > + TPM_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_CreateWrapKey); > + TPM_AUTH_BEGIN(); > + > + TPM_AUTH_HASH(); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, hWrappingKey); > + > + TPM_AUTH_SKIP(); > + > + //Encrypted auths > + xorEncrypt(osapSharedSecret, &pAuth->NonceEven, > + dataUsageAuth, ptr, > + dataMigrationAuth, ptr + sizeof(TPM_ENCAUTH)); > + ptr +=3D sizeof(TPM_ENCAUTH) * 2; > + > + ptr =3D pack_TPM_KEY(ptr, key); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_GEN(osapSharedSecret, pAuth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + keyAlloced =3D 1; > + ptr =3D unpack_TPM_KEY(ptr, key, UNPACK_ALLOC); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_VERIFY(osapSharedSecret, pAuth); > + > + goto egress; > +abort_egress: > + if(keyAlloced) { > + free_TPM_KEY(key); > + } > +egress: > + TPM_AUTH_ERR_CHECK(pAuth); > + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_LoadKey); > + TPM_AUTH_BEGIN(); > + > + TPM_AUTH_HASH(); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, parentHandle); > + > + TPM_AUTH_SKIP(); > + > + ptr =3D pack_TPM_KEY(ptr, key); > + > + TPM_AUTH_HASH(); > + > + TPM_AUTH1_GEN(usage_auth, auth); > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + TPM_AUTH_VERIFY_BEGIN(); > + > + ptr =3D 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); > + > +abort_egress: > + TPM_AUTH_ERR_CHECK(auth); > + return status; > +} > + > +TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in > +{ > + if(hKey =3D=3D 0) { > + return TPM_SUCCESS; > + } > + > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); > + > + ptr =3D pack_TPM_KEY_HANDLE(ptr, hKey); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\= n", hKey); > + > +abort_egress: > + return status; > +} > + > +TPM_RESULT TPM_FlushSpecific(TPM_HANDLE handle, > + TPM_RESOURCE_TYPE rt) { > + if(handle =3D=3D 0) { > + return TPM_SUCCESS; > + } > + > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_FlushSpecific); > + > + ptr =3D pack_TPM_HANDLE(ptr, handle); > + ptr =3D pack_TPM_RESOURCE_TYPE(ptr, rt); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > +abort_egress: > + return status; > +} > + > +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out > + BYTE* randomBytes) // out > +{ > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); > + > + // check input params > + if (bytesRequested =3D=3D NULL || randomBytes =3D=3D NULL){ > + return TPM_BAD_PARAMETER; > + } > + > + ptr =3D pack_UINT32(ptr, *bytesRequested); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + ptr =3D unpack_UINT32(ptr, bytesRequested); > + ptr =3D unpack_BUFFER(ptr, randomBytes, *bytesRequested); > + > +abort_egress: > + return status; > +} > + > + > +TPM_RESULT TPM_ReadPubek( > + TPM_PUBKEY* pubEK //out > + ) > +{ > + BYTE* antiReplay =3D NULL; > + BYTE* kptr =3D 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 =3D ptr; > + ptr +=3D TPM_DIGEST_SIZE; > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + //unpack and allocate the key > + kptr =3D ptr; > + ptr =3D 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 =3D TPM_FAIL; > + goto abort_egress; > + } > + > + goto egress; > +abort_egress: > + if(kptr !=3D NULL) { //If we unpacked the pubEK, we have to free it= > + free_TPM_PUBKEY(pubEK); > + } > +egress: > + return status; > +} > + > + > +TPM_RESULT TPM_SaveState(void) > +{ > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > +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); > + > + ptr =3D pack_TPM_CAPABILITY_AREA(ptr, capArea); > + ptr =3D pack_UINT32(ptr, subCapSize); > + ptr =3D pack_BUFFER(ptr, subCap, subCapSize); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + ptr =3D unpack_UINT32(ptr, respSize); > + ptr =3D unpack_ALLOC(ptr, resp, *respSize); > + > +abort_egress: > + return status; > +} > + > +TPM_RESULT TPM_CreateEndorsementKeyPair( > + const TPM_KEY_PARMS* keyInfo, > + TPM_PUBKEY* pubEK) > +{ > + BYTE* kptr =3D NULL; > + sha1_context ctx; > + TPM_DIGEST checksum; > + TPM_DIGEST hash; > + TPM_NONCE antiReplay; > + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); > + > + //Make anti replay nonce > + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); > + > + ptr =3D pack_TPM_NONCE(ptr, &antiReplay); > + ptr =3D pack_TPM_KEY_PARMS(ptr, keyInfo); > + > + TPM_TRANSMIT(); > + TPM_UNPACK_VERIFY(); > + > + sha1_starts(&ctx); > + > + kptr =3D ptr; > + ptr =3D unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); > + > + /* Hash the pub key blob */ > + sha1_update(&ctx, kptr, ptr - kptr); > + ptr =3D unpack_TPM_DIGEST(ptr, &checksum); > + > + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); > + > + sha1_finish(&ctx, hash.digest); > + if(memcmp(checksum.digest, hash.digest, TPM_DIGEST_SIZE)) { > + vtpmloginfo(VTPM_LOG_VTPM, "TPM_CreateEndorsementKey: Checkum ve= rification failed!\n"); > + status =3D TPM_FAIL; > + goto abort_egress; > + } > + > + goto egress; > +abort_egress: > + if(kptr) { > + free_TPM_PUBKEY(pubEK); > + } > +egress: > + return status; > +} > + > +TPM_RESULT TPM_TransmitData( > + BYTE* in, > + UINT32 insize, > + BYTE* out, > + UINT32* outsize) { > + TPM_RESULT status =3D TPM_SUCCESS; > + > + UINT32 i; > + vtpmloginfo(VTPM_LOG_TXDATA, "Sending buffer =3D 0x"); > + for(i =3D 0 ; i < insize ; i++) > + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", in[i]); > + > + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); > + > + ssize_t size =3D 0; > + > + // send the request > + size =3D 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 =3D read (vtpm_globals.tpm_fd, out, *outsize); > + if (size < 0) { > + vtpmlogerror(VTPM_LOG_TXDATA, "read() failed : %s\n", strerror(e= rrno)); > + ERRORDIE (TPM_IOERROR); > + } > + > + vtpmloginfo(VTPM_LOG_TXDATA, "Receiving buffer =3D 0x"); > + for(i =3D 0 ; i < size ; i++) > + vtpmloginfomore(VTPM_LOG_TXDATA, "%2.2x ", out[i]); > + > + vtpmloginfomore(VTPM_LOG_TXDATA, "\n"); > + > + *outsize =3D size; > + goto egress; > + > +abort_egress: > +egress: > + return status; > +} > diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h > new file mode 100644 > index 0000000..304e145 > --- /dev/null > +++ b/stubdom/vtpmmgr/tpm.h > @@ -0,0 +1,218 @@ > +/* > + * 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/2006, 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 __TPM_H__ > +#define __TPM_H__ > + > +#include "tcg.h" > + > +// ------------------------------------------------------------------ > +// Exposed API > +// ------------------------------------------------------------------ > + > +// TPM v1.1B Command Set > + > +// Authorzation > +TPM_RESULT TPM_OIAP( > + TPM_AUTH_SESSION* auth //out > + ); > + > +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); > + > +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 > + ); > + > +TPM_RESULT TPM_DisablePubekRead ( > + const TPM_AUTHDATA* ownerAuth, > + TPM_AUTH_SESSION* auth > + ); > + > +TPM_RESULT TPM_TerminateHandle ( TPM_AUTHHANDLE handle // in > + ); > + > +TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in > + TPM_RESOURCE_TYPE resourceType //in > + ); > + > +// TPM Mandatory > +TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // 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_Seal( > + TCS_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* sealDataAuth, //in > + TPM_AUTH_SESSION* pubAuth // in, out > + ); > + > +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_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 > + TPM_HANDLE* keyHandle, // out > + const TPM_AUTHDATA* usage_auth, > + 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 > + ); > + > +TPM_RESULT TPM_GetCapability( > + TPM_CAPABILITY_AREA capArea, > + UINT32 subCapSize, > + const BYTE* subCap, > + UINT32* respSize, > + BYTE** resp); > + > +TPM_RESULT TPM_SaveState(void); > + > +TPM_RESULT TPM_CreateEndorsementKeyPair( > + const TPM_KEY_PARMS* keyInfo, > + TPM_PUBKEY* pubEK); > + > +TPM_RESULT TPM_TransmitData( > + BYTE* in, > + UINT32 insize, > + BYTE* out, > + UINT32* outsize); > + > +#endif //TPM_H > diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c > new file mode 100644 > index 0000000..56094e7 > --- /dev/null > +++ b/stubdom/vtpmmgr/tpmrsa.c > @@ -0,0 +1,175 @@ > +/* > + * The RSA public-key cryptosystem > + * > + * Copyright (C) 2006-2011, Brainspark B.V. > + * > + * This file is part of PolarSSL (http://www.polarssl.org) > + * Lead Maintainer: Paul Bakker = > + * > + * All rights reserved. > + * > + * This program is free software; you can redistribute it and/or modi= fy > + * it under the terms of the GNU General Public License as published = by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License = along > + * with this program; if not, write to the Free Software Foundation, = Inc., > + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. > + */ > +/* > + * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman. > + * > + * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf > + * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf > + */ > + > +#include "tcg.h" > +#include "polarssl/sha1.h" > + > +#include > +#include > + > +#include "tpmrsa.h" > + > +#define HASH_LEN 20 > + > +void tpmrsa_set_pubkey(tpmrsa_context* ctx, > + const unsigned char* key, > + int keylen, > + const unsigned char* exponent, > + int explen) { > + > + tpmrsa_free(ctx); > + > + if(explen =3D=3D 0) { //Default e=3D 2^16+1 > + mpi_lset(&ctx->E, 65537); > + } else { > + mpi_read_binary(&ctx->E, exponent, explen); > + } > + mpi_read_binary(&ctx->N, key, keylen); > + > + ctx->len =3D ( mpi_msb(&ctx->N) + 7) >> 3; > +} > + > +static TPM_RESULT tpmrsa_public( tpmrsa_context *ctx, > + const unsigned char *input, > + unsigned char *output ) > +{ > + int ret; > + size_t olen; > + mpi T; > + > + mpi_init( &T ); > + > + MPI_CHK( mpi_read_binary( &T, input, ctx->len ) ); > + > + if( mpi_cmp_mpi( &T, &ctx->N ) >=3D 0 ) > + { > + mpi_free( &T ); > + return TPM_ENCRYPT_ERROR; > + } > + > + olen =3D ctx->len; > + MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) ); > + MPI_CHK( mpi_write_binary( &T, output, olen ) ); > + > +cleanup: > + > + mpi_free( &T ); > + > + if( ret !=3D 0 ) > + return TPM_ENCRYPT_ERROR; > + > + return TPM_SUCCESS; > +} > + > +static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src= , int slen) > +{ > + unsigned char mask[HASH_LEN]; > + unsigned char counter[4] =3D {0, 0, 0, 0}; > + int i; > + sha1_context mctx; > + > + //We always hash the src with the counter, so save the partial hash= > + sha1_starts(&mctx); > + sha1_update(&mctx, src, slen); > + > + // Generate and apply dbMask > + while(dlen > 0) { > + //Copy the sha1 context > + sha1_context ctx =3D mctx; > + > + //compute hash for input || counter > + sha1_update(&ctx, counter, sizeof(counter)); > + sha1_finish(&ctx, mask); > + > + //Apply the mask > + for(i =3D 0; i < (dlen < HASH_LEN ? dlen : HASH_LEN); ++i) { > + *(dst++) ^=3D mask[i]; > + } > + > + //Increment counter > + ++counter[3]; > + > + dlen -=3D HASH_LEN; > + } > +} > + > +/* > + * Add the message padding, then do an RSA operation > + */ > +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, > + int (*f_rng)(void *, unsigned char *, size_t), > + void *p_rng, > + size_t ilen, > + const unsigned char *input, > + unsigned char *output ) > +{ > + int ret; > + int olen; > + unsigned char* seed =3D output + 1; > + unsigned char* db =3D output + HASH_LEN +1; > + > + olen =3D ctx->len-1; > + > + if( f_rng =3D=3D NULL ) > + return TPM_ENCRYPT_ERROR; > + > + if( ilen > olen - 2 * HASH_LEN - 1) > + return TPM_ENCRYPT_ERROR; > + > + output[0] =3D 0; > + > + //Encoding parameter p > + sha1((unsigned char*)"TCPA", 4, db); > + > + //PS > + memset(db + HASH_LEN, 0, > + olen - ilen - 2 * HASH_LEN - 1); > + > + //constant 1 byte > + db[olen - ilen - HASH_LEN -1] =3D 0x01; > + > + //input string > + memcpy(db + olen - ilen - HASH_LEN, > + input, ilen); > + > + //Generate random seed > + if( ( ret =3D f_rng( p_rng, seed, HASH_LEN ) ) !=3D 0 ) > + return TPM_ENCRYPT_ERROR; > + > + // maskedDB: Apply dbMask to DB > + mgf_mask( db, olen - HASH_LEN, seed, HASH_LEN); > + > + // maskedSeed: Apply seedMask to seed > + mgf_mask( seed, HASH_LEN, db, olen - HASH_LEN); > + > + // Do the crypto op > + return tpmrsa_public(ctx, output, output); > +} > diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h > new file mode 100644 > index 0000000..59579e7 > --- /dev/null > +++ b/stubdom/vtpmmgr/tpmrsa.h > @@ -0,0 +1,67 @@ > +/** > + * \file rsa.h > + * > + * \brief The RSA public-key cryptosystem > + * > + * Copyright (C) 2006-2010, Brainspark B.V. > + * > + * This file is part of PolarSSL (http://www.polarssl.org) > + * Lead Maintainer: Paul Bakker = > + * > + * All rights reserved. > + * > + * This program is free software; you can redistribute it and/or modi= fy > + * it under the terms of the GNU General Public License as published = by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License = along > + * with this program; if not, write to the Free Software Foundation, = Inc., > + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. > + */ > +#ifndef TPMRSA_H > +#define TPMRSA_H > + > +#include "tcg.h" > +#include > + > +/* tpm software key */ > +typedef struct > +{ > + size_t len; /*!< size(N) in chars */ > + > + mpi N; /*!< public modulus */ > + mpi E; /*!< public exponent */ > + > + mpi RN; /*!< cached R^2 mod N */ > +} > +tpmrsa_context; > + > +#define TPMRSA_CTX_INIT { 0, {0, 0, NULL}, {0, 0, NULL}, {0, 0, NULL}}= > + > +/* Setup the rsa context using tpm public key data */ > +void tpmrsa_set_pubkey(tpmrsa_context* ctx, > + const unsigned char* key, > + int keylen, > + const unsigned char* exponent, > + int explen); > + > +/* Do rsa public crypto */ > +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, > + int (*f_rng)(void *, unsigned char *, size_t), > + void *p_rng, > + size_t ilen, > + const unsigned char *input, > + unsigned char *output ); > + > +/* free tpmrsa key */ > +inline void tpmrsa_free( tpmrsa_context *ctx ) { > + mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); > +} > + > +#endif /* tpmrsa.h */ > diff --git a/stubdom/vtpmmgr/uuid.h b/stubdom/vtpmmgr/uuid.h > new file mode 100644 > index 0000000..4737645 > --- /dev/null > +++ b/stubdom/vtpmmgr/uuid.h > @@ -0,0 +1,50 @@ > +/* > + * 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 VTPMMGR_UUID_H > +#define VTPMMGR_UUID_H > + > +#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%= 02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx" > +#define UUID_FMTLEN ((2*16)+4) /* 16 hex bytes plus 4 hypens */ > +#define UUID_BYTES(uuid) uuid[0], uuid[1], uuid[2], uuid[3], \ > + uuid[4], uuid[5], uuid[6], uuid[7], \ > + uuid[8], uuid[9], uuid[10], uuid[11], = \ > + uuid[12], uuid[13], uuid[14], uuid[15]= > + > + > +typedef uint8_t uuid_t[16]; > + > +#endif > diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_= cmd_handler.c > new file mode 100644 > index 0000000..f82a2a9 > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c > @@ -0,0 +1,152 @@ > +/* > + * 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. > +*/ > + > +#include > +#include > +#include > + > +#include "marshal.h" > +#include "log.h" > +#include "vtpm_storage.h" > +#include "vtpmmgr.h" > +#include "tpm.h" > +#include "tcg.h" > + > +static TPM_RESULT vtpmmgr_SaveHashKey( > + const uuid_t uuid, > + tpmcmd_t* tpmcmd) > +{ > + TPM_RESULT status =3D TPM_SUCCESS; > + > + if(tpmcmd->req_len !=3D VTPM_COMMAND_HEADER_SIZE + HASHKEYSZ) { > + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_ORD_SAVEHASHKEY hashkey too sh= ort!\n"); > + status =3D TPM_BAD_PARAMETER; > + goto abort_egress; > + } > + > + /* Do the command */ > + TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COM= MAND_HEADER_SIZE)); > + > +abort_egress: > + pack_TPM_RSP_HEADER(tpmcmd->resp, > + VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); > + tpmcmd->resp_len =3D VTPM_COMMAND_HEADER_SIZE; > + > + return status; > +} > + > +static TPM_RESULT vtpmmgr_LoadHashKey( > + const uuid_t uuid, > + tpmcmd_t* tpmcmd) { > + TPM_RESULT status =3D TPM_SUCCESS; > + > + tpmcmd->resp_len =3D VTPM_COMMAND_HEADER_SIZE; > + > + TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_CO= MMAND_HEADER_SIZE)); > + > + tpmcmd->resp_len +=3D HASHKEYSZ; > + > +abort_egress: > + pack_TPM_RSP_HEADER(tpmcmd->resp, > + VTPM_TAG_RSP, tpmcmd->resp_len, status); > + > + return status; > +} > + > + > +TPM_RESULT vtpmmgr_handle_cmd( > + const uuid_t uuid, > + tpmcmd_t* tpmcmd) > +{ > + TPM_RESULT status =3D 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 %" PR= Iu32 "\n", ord); > + status =3D 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=3D%" PRIu32 "\n", ord); > + status =3D TPM_DISABLED_CMD; > + goto abort_egress; > + } > + > + size =3D TCPA_MAX_BUFFER_LENGTH; > + TPMTRYRETURN(TPM_TransmitData(tpmcmd->req, tpmcmd->req_len, t= pmcmd->resp, &size)); > + tpmcmd->resp_len =3D size; > + > + unpack_TPM_RESULT(tpmcmd->resp + sizeof(TPM_TAG) + sizeof(UIN= T32), &status); > + return status; > + > + break; > + default: > + vtpmlogerror(VTPM_LOG_VTPM, "Invalid tag=3D%" PRIu16 "\n", ta= g); > + status =3D TPM_BADTAG; > + } > + > +abort_egress: > + tpmcmd->resp_len =3D VTPM_COMMAND_HEADER_SIZE; > + pack_TPM_RSP_HEADER(tpmcmd->resp, > + tag + 3, tpmcmd->resp_len, status); > + > + return status; > +} > diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_mana= ger.h > new file mode 100644 > index 0000000..a2bbcca > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpm_manager.h > @@ -0,0 +1,64 @@ > +/* > + * 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_MANAGER_H > +#define VTPM_MANAGER_H > + > +#define VTPM_TAG_REQ 0x01c1 > +#define VTPM_TAG_RSP 0x01c4 > +#define COMMAND_BUFFER_SIZE 4096 > + > +// Header size > +#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) > + > +//************************ 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) > + > +// 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 > +#define VTPM_FAIL 1 > +#define VTPM_UNSUPPORTED 2 > +#define VTPM_FORBIDDEN 3 > +#define VTPM_RESTORE_CONTEXT_FAILED 4 > +#define VTPM_INVALID_REQUEST 5 > + > +#endif > diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_stor= age.c > new file mode 100644 > index 0000000..9ce0c32 > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpm_storage.c > @@ -0,0 +1,794 @@ > +/* > + * 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, FITNES= S > + * 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 (curr= ent =3D=3D 1) > + * uint32_t storage_key_len Length of the storage Key > + * TPM_KEY storage_key Marshalled TPM_KEY structure (S= ee TPM spec v2) > + * RSA_BLOCK aes_crypto Encrypted aes key data (RSA_CI= PHER_SIZE bytes), bound by the storage_key > + * BYTE[32] aes_key Aes key for encrypting the uui= d table > + * uint32_t cipher_sz Encrypted size of the uuid tab= le > + * > + * ************************************************************* > + * Section 2: Uuid Table > + * > + * This table is encrypted by the aes_key in the header. The cipher te= xt 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 o= n 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 encryp= ted > + * by the storage key. Each vtpm must exist on an RSA_BLOCK aligned bo= undary, > + * starting at the first RSA_BLOCK aligned offset after the uuid table= =2E > + * As the uuid table grows, vtpms may be relocated. > + * > + * RSA_BLOCK vtpm_crypto Vtpm data encrypted by storage_k= ey > + * 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 =3D read(blkfront_fd, buf, (size))) !=3D (size)) { \ > + vtpmlogerror(VTPM_LOG_VTPM, "read() failed! " msg " : rc=3D(%d/%= d), error=3D(%s)\n", rc, (int)(size), strerror(errno)); \ > + status =3D TPM_IOERROR;\ > + goto abort_egress;\ > + } \ > +} while(0) > + > +#define TRY_WRITE(buf, size, msg) do {\ > + int rc; \ > + if((rc =3D write(blkfront_fd, buf, (size))) !=3D (size)) { \ > + vtpmlogerror(VTPM_LOG_VTPM, "write() failed! " msg " : rc=3D(%d/= %d), error=3D(%s)\n", rc, (int)(size), strerror(errno)); \ > + status =3D 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 =3D NULL; > +static int blkfront_fd =3D -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 =3D { > + .vtpms =3D NULL, > +}; > + > +static int get_offset(void) { > + return lseek(blkfront_fd, 0, SEEK_CUR); > +} > + > +static void reset_store(void) { > + g_store.aes_offset =3D 0; > + g_store.uuid_offset =3D 0; > + g_store.end_offset =3D 0; > + > + g_store.num_vtpms =3D 0; > + g_store.num_vtpms_alloced =3D 0; > + free(g_store.vtpms); > + g_store.vtpms =3D NULL; > +} > + > +static int vtpm_get_index(const uuid_t uuid) { > + int st =3D 0; > + int ed =3D g_store.num_vtpms-1; > + while(st <=3D ed) { > + int mid =3D ((unsigned int)st + (unsigned int)ed) >> 1; //avoid = overflow > + int c =3D memcmp(uuid, &g_store.vtpms[mid].uuid, sizeof(uuid_t))= ; > + if(c =3D=3D 0) { > + return mid; > + } else if(c > 0) { > + st =3D mid + 1; > + } else { > + ed =3D 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 >=3D g_store.num_vtpms_alloced) { > + g_store.num_vtpms_alloced +=3D 16; > + g_store.vtpms =3D realloc( > + g_store.vtpms, > + sizeof(struct Vtpm) * g_store.num_vtpms_alloced); > + } > + > + /* Move everybody after the new guy */ > + for(int i =3D g_store.num_vtpms; i > index; --i) { > + g_store.vtpms[i] =3D g_store.vtpms[i-1]; > + } > + > + vtpmloginfo(VTPM_LOG_VTPM, "Registered vtpm " UUID_FMT "\n", UUID_B= YTES(uuid)); > + > + /* Finally add new one */ > + memcpy(g_store.vtpms[index].uuid, uuid, sizeof(uuid_t)); > + g_store.vtpms[index].offset =3D offset; > + ++g_store.num_vtpms; > +} > + > +#if 0 > +static void vtpm_remove(int index) { > + for(i =3D index; i < g_store.num_vtpms; ++i) { > + g_store.vtpms[i] =3D 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 =3D table; > + while(*nvtpms < g_store.num_vtpms && size >=3D 0) > + { > + /* Pack the uuid */ > + memcpy(ptr, (uint8_t*)g_store.vtpms[*nvtpms].uuid, sizeof(uuid_t= )); > + ptr+=3D sizeof(uuid_t); > + > + > + /* Pack the offset */ > + ptr =3D pack_UINT32(ptr, g_store.vtpms[*nvtpms].offset); > + > + ++*nvtpms; > + size -=3D UUID_TBL_ENT_SIZE; > + } > + return ptr - table; > +} > + > +/* Extract the uuids */ > +static int extract_uuid_table(uint8_t* table, int size) { > + uint8_t* ptr =3D table; > + for(;size >=3D UUID_TBL_ENT_SIZE; size -=3D UUID_TBL_ENT_SIZE) { > + int index; > + uint32_t v32; > + > + /*uuid_t is just an array of bytes, so we can do a direct cast h= ere */ > + uint8_t* uuid =3D ptr; > + ptr +=3D sizeof(uuid_t); > + > + /* Get the offset of the key */ > + ptr =3D unpack_UINT32(ptr, &v32); > + > + /* Insert the new vtpm in sorted order */ > + if((index =3D vtpm_get_index(uuid)) >=3D 0) { > + vtpmlogerror(VTPM_LOG_VTPM, "Vtpm (" UUID_FMT ") exists multi= ple times! ignoring...\n", UUID_BYTES(uuid)); > + continue; > + } > + index =3D -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 =3D extract_uuid_table(plain, cipher_sz + *overlap); > + > + /* Copy left overs to the beginning */ > + *overlap =3D 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 =3D *overlap + pack_uuid_table(plain + *overlap, block= _sz - *overlap, num_vtpms); > + bytes_to_crypt =3D 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 =3D bytes_to_crypt; > + //add padding > + bytes_to_crypt +=3D AES_BLOCK_SIZE - (bytes_to_crypt & (AES_BLOC= K_SIZE-1)); > + //fill padding with random bytes > + vtpmmgr_rand(plain + oldsz, bytes_to_crypt - oldsz); > + *overlap =3D 0; > + } else { > + *overlap =3D 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 =3D 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 +=3D RSA_CIPHER_SIZE; > + > + /* Compute the new end location of the encrypted uuid table */ > + cipher_sz =3D AES_BLOCK_SIZE; //IV > + cipher_sz +=3D g_store.num_vtpms * UUID_TBL_ENT_SIZE; //uuid table > + cipher_sz +=3D (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 =3D (g_store.uuid_offset + cipher_sz + RSA_CIPHER_SIZE= ) & ~(RSA_CIPHER_SIZE -1); > + for(int i =3D 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 =3D g_store.end_offset; > + g_store.end_offset +=3D 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 =3D plain + AES_KEY_SIZE; > + > + /* Pack the crypted size */ > + ptr =3D 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 =3D 0; > + int overlap =3D 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 =3D buf + AES_BLOCK_SIZE; > + > + /* Encrypt the first block of the uuid table */ > + bytes_crypted =3D 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 -=3D 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 =3D 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 -=3D bytes_crypted; > + } > + > + goto egress; > +abort_egress: > +egress: > + return status; > +} > + > + > +/************************************** > + * PUBLIC FUNCTIONS > + * ***********************************/ > + > +int vtpm_storage_init(void) { > + struct blkfront_info info; > + if((blkdev =3D init_blkfront(NULL, &info)) =3D=3D NULL) { > + return -1; > + } > + if((blkfront_fd =3D 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 hashke= y[HASHKEYSZ]) > +{ > + TPM_RESULT status =3D 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 =3D vtpm_get_index(uuid)) < 0) { > + index =3D -index-1; > + vtpmlogerror(VTPM_LOG_VTPM, "LoadKey failure: Unrecognized uuid!= " UUID_FMT "\n", UUID_BYTES(uuid)); > + status =3D 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 =3D 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 hashke= y[HASHKEYSZ]) > +{ > + TPM_RESULT status =3D TPM_SUCCESS; > + int index; > + uint8_t buf[RSA_CIPHER_SIZE]; > + > + /* Find the index of this uuid */ > + if((index =3D vtpm_get_index(uuid)) < 0) { > + index =3D -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 =3D TPM_SUCCESS; > + uint8_t buf[BUF_SIZE]; > + uint8_t keybuf[AES_KEY_SIZE + sizeof(uint32_t)]; > + uint8_t* ptr =3D 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 +=3D IDSTRLEN; > + > + /*Copy the version */ > + ptr =3D pack_UINT32(ptr, DISKVERS); > + > + /*Save the location of the key size */ > + sptr =3D ptr; > + ptr +=3D sizeof(UINT32); > + > + vtpmloginfo(VTPM_LOG_VTPM, "Saving root storage key..\n"); > + > + /* Copy the storage key */ > + ptr =3D 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 =3D ptr - buf; > + > + /* Store the fake aes key and vtpm count */ > + TPMTRYRETURN(TPM_Bind(&vtpm_globals.storage_key, > + keybuf, > + sizeof(keybuf), > + ptr)); > + ptr+=3D 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 =3D get_offset(); > + > + /* Save the end offset */ > + g_store.end_offset =3D (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 =3D TPM_SUCCESS; > + uint32_t v32; > + uint8_t buf[BUF_SIZE]; > + uint8_t* ptr =3D 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 hea= der"); > + > + 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 =3D TPM_FAIL; > + goto abort_egress; > + } > + ptr+=3DIDSTRLEN; > + > + /* Unpack the version */ > + ptr =3D unpack_UINT32(ptr, &v32); > + > + /* Verify the version */ > + if(v32 !=3D DISKVERS) { > + vtpmlogerror(VTPM_LOG_VTPM, "Unsupported disk image version numb= er %" PRIu32 "\n", v32); > + status =3D TPM_FAIL; > + goto abort_egress; > + } > + > + /* Size of the storage key */ > + ptr =3D unpack_UINT32(ptr, &v32); > + > + /* Sanity check */ > + if(v32 > BUF_SIZE) { > + vtpmlogerror(VTPM_LOG_VTPM, "Size of storage key (%" PRIu32 ") i= s too large!\n", v32); > + status =3D 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 =3D 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 =3D get_offset(); > + > + /* Read the rsa cipher text for the aes key */ > + TRY_READ(buf, RSA_CIPHER_SIZE, "aes key"); > + ptr =3D 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 s= mall! expected (%ld)\n", datalen, AES_KEY_SIZE + sizeof(UINT32)); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + > + /* Extract the aes key */ > + aes_setkey_dec(&aes, ptr, AES_KEY_BITS); > + ptr+=3D AES_KEY_SIZE; > + > + /* Extract the ciphertext size */ > + ptr =3D unpack_UINT32(ptr, &v32); > + int cipher_size =3D v32; > + > + /* Sanity check */ > + if(cipher_size & (AES_BLOCK_SIZE-1)) { > + vtpmlogerror(VTPM_LOG_VTPM, "Cipher text size (%" PRIu32 ") is n= ot a multiple of the aes block size! (%d)\n", v32, AES_BLOCK_SIZE); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + > + /* Save the location of the uuid table */ > + g_store.uuid_offset =3D get_offset(); > + > + /* Only decrypt the table if there are vtpms to decrypt */ > + if(cipher_size > 0) { > + int rbytes; > + int overlap =3D 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 =3D cipher_size / UUID_TBL_ENT_SIZE; > + g_store.vtpms =3D malloc(sizeof(struct Vtpm) * g_store.num_vtpms= _alloced); > + > + /* Read the iv and the first chunk of cipher text */ > + rbytes =3D MIN(cipher_size, BUF_SIZE); > + TRY_READ(buf, rbytes, "vtpm uuid table\n"); > + cipher_size -=3D rbytes; > + > + /* Copy the iv */ > + memcpy(iv, buf, AES_BLOCK_SIZE); > + ptr =3D buf + AES_BLOCK_SIZE; > + > + /* Remove the iv from the number of bytes to decrypt */ > + rbytes -=3D 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 =3D MIN(cipher_size, BUF_SIZE); > + TRY_READ(buf, rbytes, "vtpm uuid table"); > + cipher_size -=3D 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_vtp= ms); > + } > + > + /* The end of the key table, new vtpms go here */ > + int uuid_end =3D (get_offset() + RSA_CIPHER_SIZE) & ~(RSA_CIPHER_SI= ZE -1); > + g_store.end_offset =3D uuid_end; > + > + /* Compute the end offset while validating vtpms*/ > + for(int i =3D 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 =3D 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 tex= t size (%d)!\n", > + UUID_BYTES(g_store.vtpms[i].uuid), > + g_store.vtpms[i].offset, RSA_CIPHER_SIZE); > + status =3D TPM_IOERROR; > + goto abort_egress; > + } > + /* Save the last offset */ > + if(g_store.vtpms[i].offset >=3D g_store.end_offset) { > + g_store.end_offset =3D g_store.vtpms[i].offset + RSA_CIPHER_S= IZE; > + } > + } > + > + 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 =3D TPM_KEY_INIT; > + vtpm_globals.storage_key =3D key; > + } > + > + //Reset the storage key handle > + TPM_EvictKey(vtpm_globals.storage_key_handle); > + vtpm_globals.storage_key_handle =3D 0; > +egress: > + return status; > +} > + > +#if 0 > +/* For testing disk IO */ > +void add_fake_vtpms(int num) { > + for(int i =3D 0; i < num; ++i) { > + uint32_t ind =3D cpu_to_be32(i); > + > + uuid_t uuid; > + memset(uuid, 0, sizeof(uuid_t)); > + memcpy(uuid, &ind, sizeof(ind)); > + int index =3D vtpm_get_index(uuid); > + index =3D -index-1; > + > + vtpm_storage_new_vtpm(uuid, index); > + } > +} > +#endif > diff --git a/stubdom/vtpmmgr/vtpm_storage.h b/stubdom/vtpmmgr/vtpm_stor= age.h > new file mode 100644 > index 0000000..a5a5fd7 > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpm_storage.h > @@ -0,0 +1,68 @@ > +/* > + * 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 hashke= y[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 hashke= y[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.c b/stubdom/vtpmmgr/vtpmmgr.c > new file mode 100644 > index 0000000..563f4e8 > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpmmgr.c > @@ -0,0 +1,93 @@ > +/* > + * 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. > +*/ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include "log.h" > + > +#include "vtpmmgr.h" > +#include "tcg.h" > + > + > +void main_loop(void) { > + tpmcmd_t* tpmcmd; > + uint8_t respbuf[TCPA_MAX_BUFFER_LENGTH]; > + > + while(1) { > + /* Wait for requests from a vtpm */ > + vtpmloginfo(VTPM_LOG_VTPM, "Waiting for commands from vTPM's:\n"= ); > + if((tpmcmd =3D tpmback_req_any()) =3D=3D NULL) { > + vtpmlogerror(VTPM_LOG_VTPM, "NULL tpmcmd\n"); > + continue; > + } > + > + tpmcmd->resp =3D respbuf; > + > + /* Process the command */ > + vtpmmgr_handle_cmd(tpmcmd->uuid, tpmcmd); > + > + /* Send response */ > + tpmback_resp(tpmcmd); > + } > +} > + > +int main(int argc, char** argv) > +{ > + int rc =3D 0; > + sleep(2); > + vtpmloginfo(VTPM_LOG_VTPM, "Starting vTPM manager domain\n"); > + > + /* Initialize the vtpm manager */ > + if(vtpmmgr_init(argc, argv) !=3D TPM_SUCCESS) { > + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize vtpmmgr domain= !\n"); > + rc =3D -1; > + goto exit; > + } > + > + main_loop(); > + > + vtpmloginfo(VTPM_LOG_VTPM, "vTPM Manager shutting down...\n"); > + > + vtpmmgr_shutdown(); > + > +exit: > + return rc; > + > +} > diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h > new file mode 100644 > index 0000000..50a1992 > --- /dev/null > +++ b/stubdom/vtpmmgr/vtpmmgr.h > @@ -0,0 +1,77 @@ > +/* > + * 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 VTPMMGR_H > +#define VTPMMGR_H > + > +#include > +#include > +#include > + > +#include "uuid.h" > +#include "tcg.h" > +#include "vtpm_manager.h" > + > +#define RSA_KEY_SIZE 0x0800 > +#define RSA_CIPHER_SIZE (RSA_KEY_SIZE / 8) > + > +struct vtpm_globals { > + int tpm_fd; > + TPM_KEY storage_key; > + TPM_HANDLE storage_key_handle; // Key used by persis= tent store > + TPM_AUTH_SESSION oiap; // OIAP session for storag= eKey > + TPM_AUTHDATA storage_key_usage_auth; > + > + TPM_AUTHDATA owner_auth; > + TPM_AUTHDATA srk_auth; > + > + entropy_context entropy; > + ctr_drbg_context ctr_drbg; > +}; > + > +// --------------------------- 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); > + > +inline TPM_RESULT vtpmmgr_rand(unsigned char* bytes, size_t num_bytes)= { > + return ctr_drbg_random(&vtpm_globals.ctr_drbg, bytes, num_bytes) =3D= =3D 0 ? 0 : TPM_FAIL; > +} > + > +#endif > -- > 1.7.10.4 > --------------ms080704030001010001060100 Content-Type: application/pkcs7-signature; name="smime.p7s" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="smime.p7s" Content-Description: S/MIME Cryptographic Signature MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIDyjCC A8YwggMvoAMCAQICBD/xyf0wDQYJKoZIhvcNAQEFBQAwLzELMAkGA1UEBhMCVVMxDzANBgNV BAoTBkpIVUFQTDEPMA0GA1UECxMGQklTRENBMB4XDTEwMDYxMTE4MjIwNloXDTEzMDYxMTE4 NTIwNlowZjELMAkGA1UEBhMCVVMxDzANBgNVBAoTBkpIVUFQTDEPMA0GA1UECxMGUGVvcGxl MTUwFgYDVQQLEw9WUE5Hcm91cC1CSVNEQ0EwGwYDVQQDExRNYXR0aGV3IEUgRmlvcmF2YW50 ZTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnpbwVSP6o1Nb5lcW7dd3yTo9iBJdi7qz 4nANOMFPK7JOy5npKN1iiousl28U/scUJES55gPwAWYJK3uVyQAsA4adgDKi5DoD1UHDQEwp bY7iHLJeq0NPr4BqYNqnCFPbE6HC8zSJrr4qKn+gVUQT39SIFqdiIPJwZL8FYTRQ/zsCAwEA AaOCAbYwggGyMAsGA1UdDwQEAwIHgDArBgNVHRAEJDAigA8yMDEwMDYxMTE4MjIwNlqBDzIw MTIwNzE3MjI1MjA2WjAbBg0rBgEEAbMlCwMBAQEBBAoWCGZpb3JhbWUxMBsGDSsGAQQBsyUL AwEBAQIEChIIMDAxMDQyNjEwWAYJYIZIAYb6ax4BBEsMSVRoZSBwcml2YXRlIGtleSBjb3Jy ZXNwb25kaW5nIHRvIHRoaXMgY2VydGlmaWNhdGUgbWF5IGhhdmUgYmVlbiBleHBvcnRlZC4w KAYDVR0RBCEwH4EdTWF0dGhldy5GaW9yYXZhbnRlQGpodWFwbC5lZHUwUgYDVR0fBEswSTBH oEWgQ6RBMD8xCzAJBgNVBAYTAlVTMQ8wDQYDVQQKEwZKSFVBUEwxDzANBgNVBAsTBkJJU0RD QTEOMAwGA1UEAxMFQ1JMNTYwHwYDVR0jBBgwFoAUCDUpmxH52EU2CyWmF2EJMB1yqeswHQYD VR0OBBYEFO6LYxg6r9wHZ+zdQtBHn1dZ/YTNMAkGA1UdEwQCMAAwGQYJKoZIhvZ9B0EABAww ChsEVjcuMQMCBLAwDQYJKoZIhvcNAQEFBQADgYEAJO9HQh4YNChVLzuZqK5ARJARD8JoujGZ fdo75quvg2jXFQe2sEjvLnxJZgm/pv8fdZakq48CWwjYHKuvIp7sDjTEsQfo+y7SpN/N2NvJ WU5SqfK1VgYtNLRRoGJUB5Q1aZ+Dg95g3kqpyfpUMISJL8IKVLtJVfN4fggFVUYZ9wwxggGr MIIBpwIBATA3MC8xCzAJBgNVBAYTAlVTMQ8wDQYDVQQKEwZKSFVBUEwxDzANBgNVBAsTBkJJ U0RDQQIEP/HJ/TAJBgUrDgMCGgUAoIHLMBgGCSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJ KoZIhvcNAQkFMQ8XDTEyMTEyMDE0MjUxOVowIwYJKoZIhvcNAQkEMRYEFAONLixQwzoLhKP3 k2L24VD9JBdYMGwGCSqGSIb3DQEJDzFfMF0wCwYJYIZIAWUDBAEqMAsGCWCGSAFlAwQBAjAK BggqhkiG9w0DBzAOBggqhkiG9w0DAgICAIAwDQYIKoZIhvcNAwICAUAwBwYFKw4DAgcwDQYI KoZIhvcNAwICASgwDQYJKoZIhvcNAQEBBQAEgYARV3Wmi+mb394qFYY5i7D2erEwQhzvEn1G VUDRsCdpu9v+ntpU2j2Xe0gGBTl9IAJp6WVyP+eQ2BNzx+ufNWsMMauOg+lOl400p0W9u5cq H2AE6aE1OzVsO/66lHkNjIsHIlISebgIFygQFIcTvN6edvvzASWO4rndvJUnJt7b7wAAAAAA AA== --------------ms080704030001010001060100-- --===============0475244974786596101== 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 --===============0475244974786596101==-- From xen-devel-bounces@lists.xen.org Tue Nov 20 14:52:19 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 20 Nov 2012 14:52: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 1TapBJ-0007gB-Oc; Tue, 20 Nov 2012 14:52:09 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TapBI-0007fd-4O for xen-devel@lists.xen.org; Tue, 20 Nov 2012 14:52:08 +0000 Received: from [85.158.143.99:25476] by server-2.bemta-4.messagelabs.com id 34/99-28922-7199BA05; Tue, 20 Nov 2012 14:52:07 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-11.tower-216.messagelabs.com!1353423111!23152002!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.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 2692 invoked from network); 20 Nov 2012 14:51:51 -0000 Received: from emvm-gh1-uea08.nsa.gov (HELO nsa.gov) (63.239.67.9) by server-11.tower-216.messagelabs.com with SMTP; 20 Nov 2012 14:51:51 -0000 X-TM-IMSS-Message-ID: <9cf7a63b000bdf6e@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.3.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 9cf7a63b000bdf6e ; Tue, 20 Nov 2012 09:51:08 -0500 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [144.51.25.48]) by tarius.tycho.ncsc.mil (8.13.1/8.13.1) with ESMTP id qAKEpd9X028173; Tue, 20 Nov 2012 09:51:41 -0500 From: Daniel De Graaf To: tim@xen.org Date: Tue, 20 Nov 2012 09:51:38 -0500 Message-Id: <1353423098-16371-6-git-send-email-dgdegra@tycho.nsa.gov> X-Mailer: git-send-email 1.7.11.7 In-Reply-To: <1353423098-16371-1-git-send-email-dgdegra@tycho.nsa.gov> References: <50AA5521.6080907@tycho.nsa.gov> <1353423098-16371-1-git-send-email-dgdegra@tycho.nsa.gov> Cc: Daniel De Graaf , keir@xen.org, ian.campbell@citrix.com, JBeulich@suse.com, xen-devel@lists.xen.org Subject: [Xen-devel] [PATCH RFC 5/5] xen/xsm: include default hook action in name 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 Include the default XSM hook action in the name of the hook in order to allow quick understanding of how the call site is expected to be used (dom0-only, arbitrary guest, or target-only). Abbreviation explanation: xsm_dm_* Usable only by device model (IS_PRIV_FOR) xsm_hook_* No access check in dummy module. The calling code is either guest-accessible or covered by another check xsm_priv_* Privileged command (IS_PRIV) xsm_target_* Usable by guest or its device model targeted to the guest Signed-off-by: Daniel De Graaf --- xen/arch/x86/cpu/mcheck/mce.c | 2 +- xen/arch/x86/domctl.c | 10 +- xen/arch/x86/hvm/hvm.c | 26 +-- xen/arch/x86/irq.c | 2 +- xen/arch/x86/mm.c | 20 +- xen/arch/x86/mm/mem_event.c | 4 +- xen/arch/x86/mm/mem_sharing.c | 4 +- xen/arch/x86/mm/paging.c | 2 +- xen/arch/x86/msi.c | 2 +- xen/arch/x86/physdev.c | 12 +- xen/arch/x86/platform_hypercall.c | 12 +- xen/arch/x86/sysctl.c | 4 +- xen/arch/x86/traps.c | 2 +- xen/common/domain.c | 2 +- xen/common/domctl.c | 10 +- xen/common/event_channel.c | 14 +- xen/common/grant_table.c | 16 +- xen/common/kexec.c | 2 +- xen/common/memory.c | 8 +- xen/common/schedule.c | 2 +- xen/common/sysctl.c | 6 +- xen/common/xenoprof.c | 2 +- xen/drivers/char/console.c | 2 +- xen/drivers/passthrough/iommu.c | 10 +- xen/drivers/passthrough/pci.c | 4 +- xen/include/xen/tmem_xen.h | 4 +- xen/include/xsm/dummy.h | 140 ++++++------- xen/include/xsm/xsm.h | 428 +++++++++++++++++++------------------- xen/xsm/dummy.c | 150 ++++++------- xen/xsm/flask/hooks.c | 296 +++++++++++++------------- 30 files changed, 599 insertions(+), 599 deletions(-) diff --git a/xen/arch/x86/cpu/mcheck/mce.c b/xen/arch/x86/cpu/mcheck/mce.c index 658774a..72f6f18 100644 --- a/xen/arch/x86/cpu/mcheck/mce.c +++ b/xen/arch/x86/cpu/mcheck/mce.c @@ -1293,7 +1293,7 @@ long do_mca(XEN_GUEST_HANDLE_PARAM(xen_mc_t) u_xen_mc) struct xen_mc_msrinject *mc_msrinject; struct xen_mc_mceinject *mc_mceinject; - ret = xsm_do_mca(); + ret = xsm_priv_do_mca(); if ( ret ) return x86_mcerr(NULL, ret); diff --git a/xen/arch/x86/domctl.c b/xen/arch/x86/domctl.c index 2630bdb..9541ef8 100644 --- a/xen/arch/x86/domctl.c +++ b/xen/arch/x86/domctl.c @@ -76,7 +76,7 @@ long arch_do_domctl( if ( np == 0 ) ret = 0; - else if ( xsm_ioport_permission(d, fp, fp + np - 1, allow) ) + else if ( xsm_hook_ioport_permission(d, fp, fp + np - 1, allow) ) ret = -EPERM; else if ( allow ) ret = ioports_permit_access(d, fp, fp + np - 1); @@ -566,7 +566,7 @@ long arch_do_domctl( if ( !is_hvm_domain(d) ) break; - ret = xsm_bind_pt_irq(d, bind); + ret = xsm_hook_bind_pt_irq(d, bind); if ( ret ) break; @@ -599,7 +599,7 @@ long arch_do_domctl( !irq_access_permitted(current->domain, bind->machine_irq) ) break; - ret = xsm_unbind_pt_irq(d, bind); + ret = xsm_hook_unbind_pt_irq(d, bind); if ( ret ) break; @@ -634,7 +634,7 @@ long arch_do_domctl( !iomem_access_permitted(current->domain, mfn, mfn + nr_mfns - 1) ) break; - ret = xsm_iomem_mapping(d, mfn, mfn + nr_mfns - 1, add); + ret = xsm_hook_iomem_mapping(d, mfn, mfn + nr_mfns - 1, add); if ( ret ) break; @@ -712,7 +712,7 @@ long arch_do_domctl( !ioports_access_permitted(current->domain, fmp, fmp + np - 1) ) break; - ret = xsm_ioport_mapping(d, fmp, fmp + np - 1, add); + ret = xsm_hook_ioport_mapping(d, fmp, fmp + np - 1, add); if ( ret ) break; diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 5bdde8d..e75c139 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -3400,7 +3400,7 @@ static int hvmop_set_pci_intx_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_intx_level(d); + rc = xsm_dm_hvm_set_pci_intx_level(d); if ( rc ) goto out; @@ -3567,7 +3567,7 @@ static int hvmop_set_isa_irq_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_isa_irq_level(d); + rc = xsm_dm_hvm_set_isa_irq_level(d); if ( rc ) goto out; @@ -3611,7 +3611,7 @@ static int hvmop_set_pci_link_route( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_link_route(d); + rc = xsm_dm_hvm_set_pci_link_route(d); if ( rc ) goto out; @@ -3641,7 +3641,7 @@ static int hvmop_inject_msi( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_inject_msi(d); + rc = xsm_dm_hvm_inject_msi(d); if ( rc ) goto out; @@ -3738,7 +3738,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail; @@ -3984,7 +3984,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail2; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail2; @@ -4023,7 +4023,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail3; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail3; @@ -4069,7 +4069,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail_getmemtype; @@ -4124,7 +4124,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail4; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail4; @@ -4203,7 +4203,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail5; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail5; @@ -4238,7 +4238,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail6; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail6; @@ -4274,7 +4274,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) || !paging_mode_shadow(d) ) goto param_fail7; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail7; @@ -4328,7 +4328,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail8; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail8; diff --git a/xen/arch/x86/irq.c b/xen/arch/x86/irq.c index 238600a..ba8a5ce 100644 --- a/xen/arch/x86/irq.c +++ b/xen/arch/x86/irq.c @@ -1874,7 +1874,7 @@ int map_domain_pirq( return 0; } - ret = xsm_map_domain_pirq(d, irq, data); + ret = xsm_hook_map_domain_pirq(d, irq, data); if ( ret ) { dprintk(XENLOG_G_ERR, "dom%d: could not permit access to irq %d mapping to pirq %d\n", diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c index 39b2cc7..1dbe4ef 100644 --- a/xen/arch/x86/mm.c +++ b/xen/arch/x86/mm.c @@ -2715,7 +2715,7 @@ long do_mmuext_op( goto out; } - rc = xsm_mmuext_op(d, pg_owner); + rc = xsm_target_mmuext_op(d, pg_owner); if ( rc ) { rcu_unlock_domain(pg_owner); @@ -2787,7 +2787,7 @@ long do_mmuext_op( break; } - if ( (rc = xsm_memory_pin_page(d, pg_owner, page)) != 0 ) + if ( (rc = xsm_hook_memory_pin_page(d, pg_owner, page)) != 0 ) { put_page_and_type(page); okay = 0; @@ -3244,7 +3244,7 @@ long do_mmu_update( } if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, pt_owner, pg_owner, xsm_needed); + rc = xsm_target_mmu_update(d, pt_owner, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3363,7 +3363,7 @@ long do_mmu_update( xsm_needed |= XSM_MMU_MACHPHYS_UPDATE; if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, NULL, pg_owner, xsm_needed); + rc = xsm_target_mmu_update(d, NULL, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3931,7 +3931,7 @@ static int __do_update_va_mapping( perfc_incr(calls_to_update_va); - rc = xsm_update_va_mapping(d, pg_owner, val); + rc = xsm_target_update_va_mapping(d, pg_owner, val); if ( rc ) return rc; @@ -4402,7 +4402,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_add_to_physmap(current->domain, d) ) + if ( xsm_target_add_to_physmap(current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; @@ -4441,7 +4441,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_domain_memory_map(d); + rc = xsm_target_domain_memory_map(d); if ( rc ) { rcu_unlock_domain(d); @@ -4516,7 +4516,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) XEN_GUEST_HANDLE_PARAM(e820entry_t) buffer_param; unsigned int i; - rc = xsm_machine_memory_map(); + rc = xsm_priv_machine_memory_map(); if ( rc ) return rc; @@ -4600,9 +4600,9 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -ESRCH; if ( op == XENMEM_set_pod_target ) - rc = xsm_set_pod_target(d); + rc = xsm_priv_set_pod_target(d); else - rc = xsm_get_pod_target(d); + rc = xsm_priv_get_pod_target(d); if ( rc != 0 ) goto pod_target_out_unlock; diff --git a/xen/arch/x86/mm/mem_event.c b/xen/arch/x86/mm/mem_event.c index c2b3670..3a7605c 100644 --- a/xen/arch/x86/mm/mem_event.c +++ b/xen/arch/x86/mm/mem_event.c @@ -449,7 +449,7 @@ int do_mem_event_op(int op, uint32_t domain, void *arg) if ( ret ) return ret; - ret = xsm_mem_event_op(d, op); + ret = xsm_dm_mem_event_op(d, op); if ( ret ) goto out; @@ -502,7 +502,7 @@ int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, { int rc; - rc = xsm_mem_event_control(d, mec->mode, mec->op); + rc = xsm_dm_mem_event_control(d, mec->mode, mec->op); if ( rc ) return rc; diff --git a/xen/arch/x86/mm/mem_sharing.c b/xen/arch/x86/mm/mem_sharing.c index 9229b83..57f02af 100644 --- a/xen/arch/x86/mm/mem_sharing.c +++ b/xen/arch/x86/mm/mem_sharing.c @@ -1351,7 +1351,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_dm_mem_sharing_op(d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); @@ -1415,7 +1415,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_dm_mem_sharing_op(d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..1815696 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -678,7 +678,7 @@ int paging_domctl(struct domain *d, xen_domctl_shadow_op_t *sc, return -EINVAL; } - rc = xsm_shadow_control(d, sc->op); + rc = xsm_hook_shadow_control(d, sc->op); if ( rc ) return rc; diff --git a/xen/arch/x86/msi.c b/xen/arch/x86/msi.c index e48ad2e..4bad230 100644 --- a/xen/arch/x86/msi.c +++ b/xen/arch/x86/msi.c @@ -1016,7 +1016,7 @@ int pci_restore_msi_state(struct pci_dev *pdev) if (!pdev) return -EINVAL; - ret = xsm_resource_setup_pci((pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); + ret = xsm_priv_resource_setup_pci((pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); if ( ret ) return ret; diff --git a/xen/arch/x86/physdev.c b/xen/arch/x86/physdev.c index 9c30245..a894c43 100644 --- a/xen/arch/x86/physdev.c +++ b/xen/arch/x86/physdev.c @@ -232,7 +232,7 @@ int physdev_unmap_pirq(domid_t domid, int pirq) goto free_domain; } - ret = xsm_unmap_domain_pirq(d, domain_pirq_to_irq(d, pirq)); + ret = xsm_dm_unmap_domain_pirq(d, domain_pirq_to_irq(d, pirq)); if ( ret ) goto free_domain; @@ -423,7 +423,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; ret = ioapic_guest_read(apic.apic_physbase, apic.reg, &apic.value); @@ -437,7 +437,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; ret = ioapic_guest_write(apic.apic_physbase, apic.reg, apic.value); @@ -453,7 +453,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) /* Use the APIC check since this dummy hypercall should still only * be called by the domain with access to program the ioapic */ - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; @@ -578,7 +578,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) case PHYSDEVOP_pci_mmcfg_reserved: { struct physdev_pci_mmcfg_reserved info; - ret = xsm_resource_setup_misc(); + ret = xsm_priv_resource_setup_misc(); if ( ret ) break; @@ -632,7 +632,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( setup_gsi.gsi < 0 || setup_gsi.gsi >= nr_irqs_gsi ) break; - ret = xsm_resource_setup_gsi(setup_gsi.gsi); + ret = xsm_priv_resource_setup_gsi(setup_gsi.gsi); if ( ret ) break; diff --git a/xen/arch/x86/platform_hypercall.c b/xen/arch/x86/platform_hypercall.c index f267b8b..c4b20ea 100644 --- a/xen/arch/x86/platform_hypercall.c +++ b/xen/arch/x86/platform_hypercall.c @@ -72,7 +72,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) if ( op->interface_version != XENPF_INTERFACE_VERSION ) return -EACCES; - ret = xsm_platform_op(op->cmd); + ret = xsm_priv_platform_op(op->cmd); if ( ret ) return ret; @@ -496,7 +496,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -512,7 +512,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; } - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -525,7 +525,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_unplug_core(); + ret = xsm_hook_resource_unplug_core(); if ( ret ) break; @@ -554,7 +554,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_cpu_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -564,7 +564,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_mem_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; diff --git a/xen/arch/x86/sysctl.c b/xen/arch/x86/sysctl.c index 5b0c4b7..3a10a13 100644 --- a/xen/arch/x86/sysctl.c +++ b/xen/arch/x86/sysctl.c @@ -184,14 +184,14 @@ long arch_do_sysctl( switch ( sysctl->u.cpu_hotplug.op ) { case XEN_SYSCTL_CPU_HOTPLUG_ONLINE: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; ret = continue_hypercall_on_cpu( 0, cpu_up_helper, (void *)(unsigned long)cpu); break; case XEN_SYSCTL_CPU_HOTPLUG_OFFLINE: - ret = xsm_resource_unplug_core(); + ret = xsm_hook_resource_unplug_core(); if ( ret ) break; ret = continue_hypercall_on_cpu( diff --git a/xen/arch/x86/traps.c b/xen/arch/x86/traps.c index 44a866e..695e991 100644 --- a/xen/arch/x86/traps.c +++ b/xen/arch/x86/traps.c @@ -1643,7 +1643,7 @@ static int pci_cfg_ok(struct domain *d, int write, int size) start |= (d->arch.pci_cf8 >> 16) & 0xF00; } end = start + size - 1; - if (xsm_pci_config_permission(d, machine_bdf, start, end, write)) + if (xsm_hook_pci_config_permission(d, machine_bdf, start, end, write)) return 0; return 1; } diff --git a/xen/common/domain.c b/xen/common/domain.c index fcf24e2..296d735 100644 --- a/xen/common/domain.c +++ b/xen/common/domain.c @@ -252,7 +252,7 @@ struct domain *domain_create( if ( !is_idle_domain(d) ) { - if ( (err = xsm_domain_create(d, ssidref)) != 0 ) + if ( (err = xsm_hook_domain_create(d, ssidref)) != 0 ) goto fail; d->is_paused_by_controller = 1; diff --git a/xen/common/domctl.c b/xen/common/domctl.c index 6f792e9..1f88ad2 100644 --- a/xen/common/domctl.c +++ b/xen/common/domctl.c @@ -150,7 +150,7 @@ void getdomaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) if ( is_hvm_domain(d) ) info->flags |= XEN_DOMINF_hvm_guest; - xsm_security_domaininfo(d, info); + xsm_populate_security_domaininfo(d, info); info->tot_pages = d->tot_pages; info->max_pages = d->max_pages; @@ -580,7 +580,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_getdomaininfo(d); + ret = xsm_hook_getdomaininfo(d); if ( ret ) goto getdomaininfo_out; @@ -722,7 +722,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( pirq >= d->nr_pirqs ) ret = -EINVAL; - else if ( xsm_irq_permission(d, pirq, allow) ) + else if ( xsm_hook_irq_permission(d, pirq, allow) ) ret = -EPERM; else if ( allow ) ret = irq_permit_access(d, pirq); @@ -741,7 +741,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( (mfn + nr_mfns - 1) < mfn ) /* wrap? */ break; - if ( xsm_iomem_permission(d, mfn, mfn + nr_mfns - 1, allow) ) + if ( xsm_hook_iomem_permission(d, mfn, mfn + nr_mfns - 1, allow) ) ret = -EPERM; else if ( allow ) ret = iomem_permit_access(d, mfn, mfn + nr_mfns - 1); @@ -773,7 +773,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_set_target(d, e); + ret = xsm_hook_set_target(d, e); if ( ret ) { put_domain(e); break; diff --git a/xen/common/event_channel.c b/xen/common/event_channel.c index 37947a9..ef0d89b 100644 --- a/xen/common/event_channel.c +++ b/xen/common/event_channel.c @@ -175,7 +175,7 @@ static long evtchn_alloc_unbound(evtchn_alloc_unbound_t *alloc) ERROR_EXIT_DOM(port, d); chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, alloc->remote_dom); + rc = xsm_target_evtchn_unbound(d, chn, alloc->remote_dom); if ( rc ) goto out; @@ -231,7 +231,7 @@ static long evtchn_bind_interdomain(evtchn_bind_interdomain_t *bind) (rchn->u.unbound.remote_domid != ld->domain_id) ) ERROR_EXIT_DOM(-EINVAL, rd); - rc = xsm_evtchn_interdomain(ld, lchn, rd, rchn); + rc = xsm_hook_evtchn_interdomain(ld, lchn, rd, rchn); if ( rc ) goto out; @@ -535,7 +535,7 @@ static long __evtchn_close(struct domain *d1, int port1) chn1->state = ECS_FREE; chn1->notify_vcpu_id = 0; - xsm_evtchn_close_post(chn1); + xsm_hook_evtchn_close_post(chn1); out: if ( d2 != NULL ) @@ -580,7 +580,7 @@ int evtchn_send(struct domain *d, unsigned int lport) return -EINVAL; } - ret = xsm_evtchn_send(ld, lchn); + ret = xsm_hook_evtchn_send(ld, lchn); if ( ret ) goto out; @@ -812,7 +812,7 @@ static long evtchn_status(evtchn_status_t *status) chn = evtchn_from_port(d, port); - rc = xsm_evtchn_status(d, chn); + rc = xsm_target_evtchn_status(d, chn); if ( rc ) goto out; @@ -954,7 +954,7 @@ static long evtchn_reset(evtchn_reset_t *r) if ( d == NULL ) return -ESRCH; - rc = xsm_evtchn_reset(current->domain, d); + rc = xsm_target_evtchn_reset(current->domain, d); if ( rc ) goto out; @@ -1101,7 +1101,7 @@ int alloc_unbound_xen_event_channel( goto out; chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, remote_domid); + rc = xsm_target_evtchn_unbound(d, chn, remote_domid); chn->state = ECS_UNBOUND; chn->xen_consumer = get_xen_consumer(notification_fn); diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c index eae9518..e3690b6 100644 --- a/xen/common/grant_table.c +++ b/xen/common/grant_table.c @@ -552,7 +552,7 @@ __gnttab_map_grant_ref( return; } - rc = xsm_grant_mapref(ld, rd, op->flags); + rc = xsm_hook_grant_mapref(ld, rd, op->flags); if ( rc ) { rcu_unlock_domain(rd); @@ -872,7 +872,7 @@ __gnttab_unmap_common( return; } - rc = xsm_grant_unmapref(ld, rd); + rc = xsm_hook_grant_unmapref(ld, rd); if ( rc ) { rcu_unlock_domain(rd); @@ -1326,7 +1326,7 @@ gnttab_setup_table( goto out2; } - if ( xsm_grant_setup(current->domain, d) ) + if ( xsm_target_grant_setup(current->domain, d) ) { op.status = GNTST_permission_denied; goto out2; @@ -1395,7 +1395,7 @@ gnttab_query_size( goto query_out; } - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_target_grant_query_size(current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; @@ -1571,7 +1571,7 @@ gnttab_transfer( goto copyback; } - if ( xsm_grant_transfer(d, e) ) + if ( xsm_hook_grant_transfer(d, e) ) { put_gfn(d, gop.mfn); gop.status = GNTST_permission_denied; @@ -2010,7 +2010,7 @@ __gnttab_copy( PIN_FAIL(error_out, GNTST_bad_domain, "couldn't find %d\n", op->dest.domid); - rc = xsm_grant_copy(sd, dd); + rc = xsm_hook_grant_copy(sd, dd); if ( rc ) { rc = GNTST_permission_denied; @@ -2267,7 +2267,7 @@ gnttab_get_status_frames(XEN_GUEST_HANDLE_PARAM(gnttab_get_status_frames_t) uop, op.status = GNTST_bad_domain; goto out1; } - rc = xsm_grant_setup(current->domain, d); + rc = xsm_target_grant_setup(current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; goto out1; @@ -2318,7 +2318,7 @@ gnttab_get_version(XEN_GUEST_HANDLE_PARAM(gnttab_get_version_t uop)) if ( d == NULL ) return -ESRCH; - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_target_grant_query_size(current->domain, d); if ( rc ) { rcu_unlock_domain(d); diff --git a/xen/common/kexec.c b/xen/common/kexec.c index d4f6332..ff9d205 100644 --- a/xen/common/kexec.c +++ b/xen/common/kexec.c @@ -852,7 +852,7 @@ static int do_kexec_op_internal(unsigned long op, unsigned long flags; int ret = -EINVAL; - ret = xsm_kexec(); + ret = xsm_priv_kexec(); if ( ret ) return ret; diff --git a/xen/common/memory.c b/xen/common/memory.c index 7d3c326..0e216bb 100644 --- a/xen/common/memory.c +++ b/xen/common/memory.c @@ -336,7 +336,7 @@ static long memory_exchange(XEN_GUEST_HANDLE_PARAM(xen_memory_exchange_t) arg) goto fail_early; } - rc = xsm_memory_exchange(d); + rc = xsm_target_memory_exchange(d); if ( rc ) { rcu_unlock_domain(d); @@ -585,7 +585,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) return start_extent; args.domain = d; - rc = xsm_memory_adjust_reservation(current->domain, d); + rc = xsm_target_memory_adjust_reservation(current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -634,7 +634,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_memory_stat_reservation(current->domain, d); + rc = xsm_target_memory_stat_reservation(current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -672,7 +672,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_remove_from_physmap(current->domain, d) ) + if ( xsm_target_remove_from_physmap(current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; diff --git a/xen/common/schedule.c b/xen/common/schedule.c index cfd173d..2cad778 100644 --- a/xen/common/schedule.c +++ b/xen/common/schedule.c @@ -921,7 +921,7 @@ ret_t do_sched_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) break; - ret = xsm_schedop_shutdown(current->domain, d); + ret = xsm_dm_schedop_shutdown(current->domain, d); if ( ret ) { rcu_unlock_domain(d); diff --git a/xen/common/sysctl.c b/xen/common/sysctl.c index cbefb0e..d6e3f6c 100644 --- a/xen/common/sysctl.c +++ b/xen/common/sysctl.c @@ -57,7 +57,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) { case XEN_SYSCTL_readconsole: { - ret = xsm_readconsole(op->u.readconsole.clear); + ret = xsm_hook_readconsole(op->u.readconsole.clear); if ( ret ) break; @@ -100,7 +100,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) if ( num_domains == op->u.getdomaininfolist.max_domains ) break; - ret = xsm_getdomaininfo(d); + ret = xsm_hook_getdomaininfo(d); if ( ret ) continue; @@ -231,7 +231,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) uint32_t *status, *ptr; unsigned long pfn; - ret = xsm_page_offline(op->u.page_offline.cmd); + ret = xsm_hook_page_offline(op->u.page_offline.cmd); if ( ret ) break; diff --git a/xen/common/xenoprof.c b/xen/common/xenoprof.c index ae0435b..7a82e3a 100644 --- a/xen/common/xenoprof.c +++ b/xen/common/xenoprof.c @@ -680,7 +680,7 @@ ret_t do_xenoprof_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -EPERM; } - ret = xsm_profile(current->domain, op); + ret = xsm_hook_profile(current->domain, op); if ( ret ) return ret; diff --git a/xen/drivers/char/console.c b/xen/drivers/char/console.c index b2c3ee3..b6faa43 100644 --- a/xen/drivers/char/console.c +++ b/xen/drivers/char/console.c @@ -406,7 +406,7 @@ long do_console_io(int cmd, int count, XEN_GUEST_HANDLE_PARAM(char) buffer) long rc; unsigned int idx, len; - rc = xsm_console_io(current->domain, cmd); + rc = xsm_priv_console_io(current->domain, cmd); if ( rc ) return rc; diff --git a/xen/drivers/passthrough/iommu.c b/xen/drivers/passthrough/iommu.c index 9d13185..52eff81 100644 --- a/xen/drivers/passthrough/iommu.c +++ b/xen/drivers/passthrough/iommu.c @@ -452,7 +452,7 @@ static int iommu_get_device_group( ((pdev->bus == bus) && (pdev->devfn == devfn)) ) continue; - if ( xsm_get_device_group((seg << 16) | (pdev->bus << 8) | pdev->devfn) ) + if ( xsm_hook_get_device_group((seg << 16) | (pdev->bus << 8) | pdev->devfn) ) continue; sdev_id = ops->get_device_group_id(seg, pdev->bus, pdev->devfn); @@ -555,7 +555,7 @@ int iommu_do_domctl( u32 max_sdevs; XEN_GUEST_HANDLE_64(uint32) sdevs; - ret = xsm_get_device_group(domctl->u.get_device_group.machine_sbdf); + ret = xsm_hook_get_device_group(domctl->u.get_device_group.machine_sbdf); if ( ret ) break; @@ -583,7 +583,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_test_assign_device: - ret = xsm_test_assign_device(domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_test_assign_device(domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -607,7 +607,7 @@ int iommu_do_domctl( break; } - ret = xsm_assign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_assign_device(d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -626,7 +626,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_deassign_device: - ret = xsm_deassign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_deassign_device(d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; diff --git a/xen/drivers/passthrough/pci.c b/xen/drivers/passthrough/pci.c index d5ef4c1..43eceab 100644 --- a/xen/drivers/passthrough/pci.c +++ b/xen/drivers/passthrough/pci.c @@ -380,7 +380,7 @@ int pci_add_device(u16 seg, u8 bus, u8 devfn, const struct pci_dev_info *info) pdev_type = "device"; } - ret = xsm_resource_plug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_priv_resource_plug_pci((seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; @@ -496,7 +496,7 @@ int pci_remove_device(u16 seg, u8 bus, u8 devfn) struct pci_dev *pdev; int ret; - ret = xsm_resource_unplug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_priv_resource_unplug_pci((seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; diff --git a/xen/include/xen/tmem_xen.h b/xen/include/xen/tmem_xen.h index 8dec5aa..81d88f3 100644 --- a/xen/include/xen/tmem_xen.h +++ b/xen/include/xen/tmem_xen.h @@ -329,12 +329,12 @@ static inline bool_t tmh_set_client_from_id( static inline bool_t tmh_current_permitted(void) { - return !xsm_tmem_op(); + return !xsm_hook_tmem_op(); } static inline bool_t tmh_current_is_privileged(void) { - return !xsm_tmem_control(); + return !xsm_priv_tmem_control(); } static inline uint8_t tmh_get_first_byte(pfp_t *pfp) diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h index aaac50d3..09ee3f2 100644 --- a/xen/include/xsm/dummy.h +++ b/xen/include/xsm/dummy.h @@ -11,23 +11,23 @@ #include #include -static XSM_INLINE void xsm_security_domaininfo(struct domain *d, +static XSM_INLINE void xsm_populate_security_domaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) { return; } -static XSM_INLINE int xsm_domain_create(struct domain *d, u32 ssidref) +static XSM_INLINE int xsm_hook_domain_create(struct domain *d, u32 ssidref) { return 0; } -static XSM_INLINE int xsm_getdomaininfo(struct domain *d) +static XSM_INLINE int xsm_hook_getdomaininfo(struct domain *d) { return 0; } -static XSM_INLINE int xsm_set_target(struct domain *d, struct domain *e) +static XSM_INLINE int xsm_hook_set_target(struct domain *d, struct domain *e) { return 0; } @@ -58,12 +58,12 @@ static XSM_INLINE int xsm_sysctl(int cmd) return 0; } -static XSM_INLINE int xsm_readconsole(uint32_t clear) +static XSM_INLINE int xsm_hook_readconsole(uint32_t clear) { return 0; } -static XSM_INLINE int xsm_do_mca(void) +static XSM_INLINE int xsm_priv_do_mca(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; @@ -80,49 +80,49 @@ static XSM_INLINE void xsm_free_security_domain(struct domain *d) return; } -static XSM_INLINE int xsm_grant_mapref(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_hook_grant_mapref(struct domain *d1, struct domain *d2, uint32_t flags) { return 0; } -static XSM_INLINE int xsm_grant_unmapref(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_unmapref(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_setup(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_grant_setup(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_grant_transfer(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_transfer(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_copy(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_copy(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_query_size(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_grant_query_size(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_exchange(struct domain *d) +static XSM_INLINE int xsm_target_memory_exchange(struct domain *d) { if ( d != current->domain && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1, +static XSM_INLINE int xsm_target_memory_adjust_reservation(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) @@ -130,14 +130,14 @@ static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1, return 0; } -static XSM_INLINE int xsm_memory_stat_reservation(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_memory_stat_reservation(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_console_io(struct domain *d, int cmd) +static XSM_INLINE int xsm_priv_console_io(struct domain *d, int cmd) { #ifndef VERBOSE if ( !IS_PRIV(current->domain) ) @@ -146,32 +146,32 @@ static XSM_INLINE int xsm_console_io(struct domain *d, int cmd) return 0; } -static XSM_INLINE int xsm_profile(struct domain *d, int op) +static XSM_INLINE int xsm_hook_profile(struct domain *d, int op) { return 0; } -static XSM_INLINE int xsm_kexec(void) +static XSM_INLINE int xsm_priv_kexec(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_schedop_shutdown(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_dm_schedop_shutdown(struct domain *d1, struct domain *d2) { if ( !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { return 0; } -static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn, +static XSM_INLINE int xsm_target_evtchn_unbound(struct domain *d, struct evtchn *chn, domid_t id2) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) @@ -179,30 +179,30 @@ static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn, return 0; } -static XSM_INLINE int xsm_evtchn_interdomain(struct domain *d1, struct evtchn +static XSM_INLINE int xsm_hook_evtchn_interdomain(struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { return 0; } -static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn) +static XSM_INLINE void xsm_hook_evtchn_close_post(struct evtchn *chn) { return; } -static XSM_INLINE int xsm_evtchn_send(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_hook_evtchn_send(struct domain *d, struct evtchn *chn) { return 0; } -static XSM_INLINE int xsm_evtchn_status(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_target_evtchn_status(struct domain *d, struct evtchn *chn) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_evtchn_reset(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_evtchn_reset(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; @@ -224,96 +224,96 @@ static XSM_INLINE char * xsm_show_security_evtchn(struct domain *d, const struct return NULL; } -static XSM_INLINE int xsm_get_pod_target(struct domain *d) +static XSM_INLINE int xsm_priv_get_pod_target(struct domain *d) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_set_pod_target(struct domain *d) +static XSM_INLINE int xsm_priv_set_pod_target(struct domain *d) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_get_device_group(uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_get_device_group(uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_test_assign_device(uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_test_assign_device(uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_assign_device(struct domain *d, uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_resource_plug_core(void) +static XSM_INLINE int xsm_hook_resource_plug_core(void) { return 0; } -static XSM_INLINE int xsm_resource_unplug_core(void) +static XSM_INLINE int xsm_hook_resource_unplug_core(void) { return 0; } -static XSM_INLINE int xsm_resource_plug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_plug_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_unplug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_unplug_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_setup_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_gsi(int gsi) +static XSM_INLINE int xsm_priv_resource_setup_gsi(int gsi) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_misc(void) +static XSM_INLINE int xsm_priv_resource_setup_misc(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_page_offline(uint32_t cmd) +static XSM_INLINE int xsm_hook_page_offline(uint32_t cmd) { return 0; } -static XSM_INLINE int xsm_tmem_op(void) +static XSM_INLINE int xsm_hook_tmem_op(void) { return 0; } -static XSM_INLINE int xsm_tmem_control(void) +static XSM_INLINE int xsm_priv_tmem_control(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; @@ -330,34 +330,34 @@ static XSM_INLINE char * xsm_show_irq_sid(int irq) return NULL; } -static XSM_INLINE int xsm_map_domain_pirq(struct domain *d, int irq, void *data) +static XSM_INLINE int xsm_hook_map_domain_pirq(struct domain *d, int irq, void *data) { return 0; } -static XSM_INLINE int xsm_unmap_domain_pirq(struct domain *d, int irq) +static XSM_INLINE int xsm_dm_unmap_domain_pirq(struct domain *d, int irq) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_irq_permission(struct domain *d, int pirq, uint8_t allow) +static XSM_INLINE int xsm_hook_irq_permission(struct domain *d, int pirq, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_iomem_permission(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_iomem_permission(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_iomem_mapping(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_iomem_mapping(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t machine_bdf, +static XSM_INLINE int xsm_hook_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { @@ -365,96 +365,96 @@ static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t machi } #ifdef CONFIG_X86 -static XSM_INLINE int xsm_shadow_control(struct domain *d, uint32_t op) +static XSM_INLINE int xsm_hook_shadow_control(struct domain *d, uint32_t op) { return 0; } -static XSM_INLINE int xsm_hvm_param(struct domain *d, unsigned long op) +static XSM_INLINE int xsm_target_hvm_param(struct domain *d, unsigned long op) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_pci_intx_level(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_pci_intx_level(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_isa_irq_level(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_isa_irq_level(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_pci_link_route(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_pci_link_route(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_inject_msi(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_inject_msi(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_event_control(struct domain *d, int mode, int op) +static XSM_INLINE int xsm_dm_mem_event_control(struct domain *d, int mode, int op) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_event_op(struct domain *d, int op) +static XSM_INLINE int xsm_dm_mem_event_op(struct domain *d, int op) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_sharing_op(struct domain *d, struct domain *cd, int op) +static XSM_INLINE int xsm_dm_mem_sharing_op(struct domain *d, struct domain *cd, int op) { if ( !IS_PRIV_FOR(current->domain, cd) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_apic(struct domain *d, int cmd) +static XSM_INLINE int xsm_priv_apic(struct domain *d, int cmd) { if ( !IS_PRIV(d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_platform_op(uint32_t op) +static XSM_INLINE int xsm_priv_platform_op(uint32_t op) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_machine_memory_map(void) +static XSM_INLINE int xsm_priv_machine_memory_map(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_domain_memory_map(struct domain *d) +static XSM_INLINE int xsm_target_domain_memory_map(struct domain *d) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t, +static XSM_INLINE int xsm_target_mmu_update(struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { if ( t && d != t && !IS_PRIV_FOR(d, t) ) @@ -464,14 +464,14 @@ static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t, return 0; } -static XSM_INLINE int xsm_mmuext_op(struct domain *d, struct domain *f) +static XSM_INLINE int xsm_target_mmuext_op(struct domain *d, struct domain *f) { if ( d != f && !IS_PRIV_FOR(d, f) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain *f, +static XSM_INLINE int xsm_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { if ( d != f && !IS_PRIV_FOR(d, f) ) @@ -479,36 +479,36 @@ static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain *f, return 0; } -static XSM_INLINE int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_add_to_physmap(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_remove_from_physmap(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_hook_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return 0; } -static XSM_INLINE int xsm_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_hook_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return 0; } -static XSM_INLINE int xsm_ioport_permission(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_ioport_permission(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_ioport_mapping(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_ioport_mapping(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return 0; } diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h index 105201e..c3a29b6 100644 --- a/xen/include/xsm/xsm.h +++ b/xen/include/xsm/xsm.h @@ -39,30 +39,30 @@ extern xsm_initcall_t __xsm_initcall_start[], __xsm_initcall_end[]; __used_section(".xsm_initcall.init") = fn struct xsm_operations { - void (*security_domaininfo) (struct domain *d, + void (*populate_security_domaininfo) (struct domain *d, struct xen_domctl_getdomaininfo *info); - int (*domain_create) (struct domain *d, u32 ssidref); - int (*getdomaininfo) (struct domain *d); - int (*set_target) (struct domain *d, struct domain *e); + int (*hook_domain_create) (struct domain *d, u32 ssidref); + int (*hook_getdomaininfo) (struct domain *d); + int (*hook_set_target) (struct domain *d, struct domain *e); int (*domctl) (struct domain *d, int cmd); int (*sysctl) (int cmd); - int (*readconsole) (uint32_t clear); - int (*do_mca) (void); + int (*hook_readconsole) (uint32_t clear); + int (*priv_do_mca) (void); - int (*evtchn_unbound) (struct domain *d, struct evtchn *chn, domid_t id2); - int (*evtchn_interdomain) (struct domain *d1, struct evtchn *chn1, + int (*target_evtchn_unbound) (struct domain *d, struct evtchn *chn, domid_t id2); + int (*hook_evtchn_interdomain) (struct domain *d1, struct evtchn *chn1, struct domain *d2, struct evtchn *chn2); - void (*evtchn_close_post) (struct evtchn *chn); - int (*evtchn_send) (struct domain *d, struct evtchn *chn); - int (*evtchn_status) (struct domain *d, struct evtchn *chn); - int (*evtchn_reset) (struct domain *d1, struct domain *d2); - - int (*grant_mapref) (struct domain *d1, struct domain *d2, uint32_t flags); - int (*grant_unmapref) (struct domain *d1, struct domain *d2); - int (*grant_setup) (struct domain *d1, struct domain *d2); - int (*grant_transfer) (struct domain *d1, struct domain *d2); - int (*grant_copy) (struct domain *d1, struct domain *d2); - int (*grant_query_size) (struct domain *d1, struct domain *d2); + void (*hook_evtchn_close_post) (struct evtchn *chn); + int (*hook_evtchn_send) (struct domain *d, struct evtchn *chn); + int (*target_evtchn_status) (struct domain *d, struct evtchn *chn); + int (*target_evtchn_reset) (struct domain *d1, struct domain *d2); + + int (*hook_grant_mapref) (struct domain *d1, struct domain *d2, uint32_t flags); + int (*hook_grant_unmapref) (struct domain *d1, struct domain *d2); + int (*target_grant_setup) (struct domain *d1, struct domain *d2); + int (*hook_grant_transfer) (struct domain *d1, struct domain *d2); + int (*hook_grant_copy) (struct domain *d1, struct domain *d2); + int (*target_grant_query_size) (struct domain *d1, struct domain *d2); int (*alloc_security_domain) (struct domain *d); void (*free_security_domain) (struct domain *d); @@ -70,76 +70,76 @@ struct xsm_operations { void (*free_security_evtchn) (struct evtchn *chn); char *(*show_security_evtchn) (struct domain *d, const struct evtchn *chn); - int (*get_pod_target) (struct domain *d); - int (*set_pod_target) (struct domain *d); - int (*memory_exchange) (struct domain *d); - int (*memory_adjust_reservation) (struct domain *d1, struct domain *d2); - int (*memory_stat_reservation) (struct domain *d1, struct domain *d2); - int (*memory_pin_page) (struct domain *d1, struct domain *d2, struct page_info *page); - int (*remove_from_physmap) (struct domain *d1, struct domain *d2); + int (*priv_get_pod_target) (struct domain *d); + int (*priv_set_pod_target) (struct domain *d); + int (*target_memory_exchange) (struct domain *d); + int (*target_memory_adjust_reservation) (struct domain *d1, struct domain *d2); + int (*target_memory_stat_reservation) (struct domain *d1, struct domain *d2); + int (*hook_memory_pin_page) (struct domain *d1, struct domain *d2, struct page_info *page); + int (*target_remove_from_physmap) (struct domain *d1, struct domain *d2); - int (*console_io) (struct domain *d, int cmd); + int (*priv_console_io) (struct domain *d, int cmd); - int (*profile) (struct domain *d, int op); + int (*hook_profile) (struct domain *d, int op); - int (*kexec) (void); - int (*schedop_shutdown) (struct domain *d1, struct domain *d2); + int (*priv_kexec) (void); + int (*dm_schedop_shutdown) (struct domain *d1, struct domain *d2); char *(*show_irq_sid) (int irq); - int (*map_domain_pirq) (struct domain *d, int irq, void *data); - int (*unmap_domain_pirq) (struct domain *d, int irq); - int (*irq_permission) (struct domain *d, int pirq, uint8_t allow); - int (*iomem_permission) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); - int (*iomem_mapping) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); - int (*pci_config_permission) (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access); - - int (*get_device_group) (uint32_t machine_bdf); - int (*test_assign_device) (uint32_t machine_bdf); - int (*assign_device) (struct domain *d, uint32_t machine_bdf); - int (*deassign_device) (struct domain *d, uint32_t machine_bdf); - - int (*resource_plug_core) (void); - int (*resource_unplug_core) (void); - int (*resource_plug_pci) (uint32_t machine_bdf); - int (*resource_unplug_pci) (uint32_t machine_bdf); - int (*resource_setup_pci) (uint32_t machine_bdf); - int (*resource_setup_gsi) (int gsi); - int (*resource_setup_misc) (void); - - int (*page_offline)(uint32_t cmd); - int (*tmem_op)(void); - int (*tmem_control)(void); + int (*hook_map_domain_pirq) (struct domain *d, int irq, void *data); + int (*dm_unmap_domain_pirq) (struct domain *d, int irq); + int (*hook_irq_permission) (struct domain *d, int pirq, uint8_t allow); + int (*hook_iomem_permission) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); + int (*hook_iomem_mapping) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); + int (*hook_pci_config_permission) (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access); + + int (*hook_get_device_group) (uint32_t machine_bdf); + int (*hook_test_assign_device) (uint32_t machine_bdf); + int (*hook_assign_device) (struct domain *d, uint32_t machine_bdf); + int (*hook_deassign_device) (struct domain *d, uint32_t machine_bdf); + + int (*hook_resource_plug_core) (void); + int (*hook_resource_unplug_core) (void); + int (*priv_resource_plug_pci) (uint32_t machine_bdf); + int (*priv_resource_unplug_pci) (uint32_t machine_bdf); + int (*priv_resource_setup_pci) (uint32_t machine_bdf); + int (*priv_resource_setup_gsi) (int gsi); + int (*priv_resource_setup_misc) (void); + + int (*hook_page_offline)(uint32_t cmd); + int (*hook_tmem_op)(void); + int (*priv_tmem_control)(void); long (*do_xsm_op) (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op); #ifdef CONFIG_X86 - int (*shadow_control) (struct domain *d, uint32_t op); - int (*hvm_param) (struct domain *d, unsigned long op); - int (*hvm_set_pci_intx_level) (struct domain *d); - int (*hvm_set_isa_irq_level) (struct domain *d); - int (*hvm_set_pci_link_route) (struct domain *d); - int (*hvm_inject_msi) (struct domain *d); - int (*mem_event_control) (struct domain *d, int mode, int op); - int (*mem_event_op) (struct domain *d, int op); - int (*mem_sharing_op) (struct domain *d, struct domain *cd, int op); - int (*apic) (struct domain *d, int cmd); + int (*hook_shadow_control) (struct domain *d, uint32_t op); + int (*target_hvm_param) (struct domain *d, unsigned long op); + int (*dm_hvm_set_pci_intx_level) (struct domain *d); + int (*dm_hvm_set_isa_irq_level) (struct domain *d); + int (*dm_hvm_set_pci_link_route) (struct domain *d); + int (*dm_hvm_inject_msi) (struct domain *d); + int (*dm_mem_event_control) (struct domain *d, int mode, int op); + int (*dm_mem_event_op) (struct domain *d, int op); + int (*dm_mem_sharing_op) (struct domain *d, struct domain *cd, int op); + int (*priv_apic) (struct domain *d, int cmd); int (*memtype) (uint32_t access); - int (*platform_op) (uint32_t cmd); - int (*machine_memory_map) (void); - int (*domain_memory_map) (struct domain *d); + int (*priv_platform_op) (uint32_t cmd); + int (*priv_machine_memory_map) (void); + int (*target_domain_memory_map) (struct domain *d); #define XSM_MMU_UPDATE_READ 1 #define XSM_MMU_UPDATE_WRITE 2 #define XSM_MMU_NORMAL_UPDATE 4 #define XSM_MMU_MACHPHYS_UPDATE 8 - int (*mmu_update) (struct domain *d, struct domain *t, + int (*target_mmu_update) (struct domain *d, struct domain *t, struct domain *f, uint32_t flags); - int (*mmuext_op) (struct domain *d, struct domain *f); - int (*update_va_mapping) (struct domain *d, struct domain *f, l1_pgentry_t pte); - int (*add_to_physmap) (struct domain *d1, struct domain *d2); - int (*bind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); - int (*unbind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); - int (*ioport_permission) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); - int (*ioport_mapping) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); + int (*target_mmuext_op) (struct domain *d, struct domain *f); + int (*target_update_va_mapping) (struct domain *d, struct domain *f, l1_pgentry_t pte); + int (*target_add_to_physmap) (struct domain *d1, struct domain *d2); + int (*hook_bind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); + int (*hook_unbind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); + int (*hook_ioport_permission) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); + int (*hook_ioport_mapping) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); #endif }; @@ -149,25 +149,25 @@ extern struct xsm_operations *xsm_ops; #ifndef XSM_NO_WRAPPERS -static inline void xsm_security_domaininfo (struct domain *d, +static inline void xsm_populate_security_domaininfo (struct domain *d, struct xen_domctl_getdomaininfo *info) { - xsm_ops->security_domaininfo(d, info); + xsm_ops->populate_security_domaininfo(d, info); } -static inline int xsm_domain_create (struct domain *d, u32 ssidref) +static inline int xsm_hook_domain_create (struct domain *d, u32 ssidref) { - return xsm_ops->domain_create(d, ssidref); + return xsm_ops->hook_domain_create(d, ssidref); } -static inline int xsm_getdomaininfo (struct domain *d) +static inline int xsm_hook_getdomaininfo (struct domain *d) { - return xsm_ops->getdomaininfo(d); + return xsm_ops->hook_getdomaininfo(d); } -static inline int xsm_set_target (struct domain *d, struct domain *e) +static inline int xsm_hook_set_target (struct domain *d, struct domain *e) { - return xsm_ops->set_target(d, e); + return xsm_ops->hook_set_target(d, e); } static inline int xsm_domctl (struct domain *d, int cmd) @@ -180,77 +180,77 @@ static inline int xsm_sysctl (int cmd) return xsm_ops->sysctl(cmd); } -static inline int xsm_readconsole (uint32_t clear) +static inline int xsm_hook_readconsole (uint32_t clear) { - return xsm_ops->readconsole(clear); + return xsm_ops->hook_readconsole(clear); } -static inline int xsm_do_mca(void) +static inline int xsm_priv_do_mca(void) { - return xsm_ops->do_mca(); + return xsm_ops->priv_do_mca(); } -static inline int xsm_evtchn_unbound (struct domain *d1, struct evtchn *chn, +static inline int xsm_target_evtchn_unbound (struct domain *d1, struct evtchn *chn, domid_t id2) { - return xsm_ops->evtchn_unbound(d1, chn, id2); + return xsm_ops->target_evtchn_unbound(d1, chn, id2); } -static inline int xsm_evtchn_interdomain (struct domain *d1, +static inline int xsm_hook_evtchn_interdomain (struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { - return xsm_ops->evtchn_interdomain(d1, chan1, d2, chan2); + return xsm_ops->hook_evtchn_interdomain(d1, chan1, d2, chan2); } -static inline void xsm_evtchn_close_post (struct evtchn *chn) +static inline void xsm_hook_evtchn_close_post (struct evtchn *chn) { - xsm_ops->evtchn_close_post(chn); + xsm_ops->hook_evtchn_close_post(chn); } -static inline int xsm_evtchn_send (struct domain *d, struct evtchn *chn) +static inline int xsm_hook_evtchn_send (struct domain *d, struct evtchn *chn) { - return xsm_ops->evtchn_send(d, chn); + return xsm_ops->hook_evtchn_send(d, chn); } -static inline int xsm_evtchn_status (struct domain *d, struct evtchn *chn) +static inline int xsm_target_evtchn_status (struct domain *d, struct evtchn *chn) { - return xsm_ops->evtchn_status(d, chn); + return xsm_ops->target_evtchn_status(d, chn); } -static inline int xsm_evtchn_reset (struct domain *d1, struct domain *d2) +static inline int xsm_target_evtchn_reset (struct domain *d1, struct domain *d2) { - return xsm_ops->evtchn_reset(d1, d2); + return xsm_ops->target_evtchn_reset(d1, d2); } -static inline int xsm_grant_mapref (struct domain *d1, struct domain *d2, +static inline int xsm_hook_grant_mapref (struct domain *d1, struct domain *d2, uint32_t flags) { - return xsm_ops->grant_mapref(d1, d2, flags); + return xsm_ops->hook_grant_mapref(d1, d2, flags); } -static inline int xsm_grant_unmapref (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_unmapref (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_unmapref(d1, d2); + return xsm_ops->hook_grant_unmapref(d1, d2); } -static inline int xsm_grant_setup (struct domain *d1, struct domain *d2) +static inline int xsm_target_grant_setup (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_setup(d1, d2); + return xsm_ops->target_grant_setup(d1, d2); } -static inline int xsm_grant_transfer (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_transfer (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_transfer(d1, d2); + return xsm_ops->hook_grant_transfer(d1, d2); } -static inline int xsm_grant_copy (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_copy (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_copy(d1, d2); + return xsm_ops->hook_grant_copy(d1, d2); } -static inline int xsm_grant_query_size (struct domain *d1, struct domain *d2) +static inline int xsm_target_grant_query_size (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_query_size(d1, d2); + return xsm_ops->target_grant_query_size(d1, d2); } static inline int xsm_alloc_security_domain (struct domain *d) @@ -278,62 +278,62 @@ static inline char *xsm_show_security_evtchn (struct domain *d, const struct evt return xsm_ops->show_security_evtchn(d, chn); } -static inline int xsm_get_pod_target (struct domain *d) +static inline int xsm_priv_get_pod_target (struct domain *d) { - return xsm_ops->get_pod_target(d); + return xsm_ops->priv_get_pod_target(d); } -static inline int xsm_set_pod_target (struct domain *d) +static inline int xsm_priv_set_pod_target (struct domain *d) { - return xsm_ops->set_pod_target(d); + return xsm_ops->priv_set_pod_target(d); } -static inline int xsm_memory_exchange (struct domain *d) +static inline int xsm_target_memory_exchange (struct domain *d) { - return xsm_ops->memory_exchange(d); + return xsm_ops->target_memory_exchange(d); } -static inline int xsm_memory_adjust_reservation (struct domain *d1, struct +static inline int xsm_target_memory_adjust_reservation (struct domain *d1, struct domain *d2) { - return xsm_ops->memory_adjust_reservation(d1, d2); + return xsm_ops->target_memory_adjust_reservation(d1, d2); } -static inline int xsm_memory_stat_reservation (struct domain *d1, +static inline int xsm_target_memory_stat_reservation (struct domain *d1, struct domain *d2) { - return xsm_ops->memory_stat_reservation(d1, d2); + return xsm_ops->target_memory_stat_reservation(d1, d2); } -static inline int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static inline int xsm_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { - return xsm_ops->memory_pin_page(d1, d2, page); + return xsm_ops->hook_memory_pin_page(d1, d2, page); } -static inline int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_target_remove_from_physmap(struct domain *d1, struct domain *d2) { - return xsm_ops->remove_from_physmap(d1, d2); + return xsm_ops->target_remove_from_physmap(d1, d2); } -static inline int xsm_console_io (struct domain *d, int cmd) +static inline int xsm_priv_console_io (struct domain *d, int cmd) { - return xsm_ops->console_io(d, cmd); + return xsm_ops->priv_console_io(d, cmd); } -static inline int xsm_profile (struct domain *d, int op) +static inline int xsm_hook_profile (struct domain *d, int op) { - return xsm_ops->profile(d, op); + return xsm_ops->hook_profile(d, op); } -static inline int xsm_kexec (void) +static inline int xsm_priv_kexec (void) { - return xsm_ops->kexec(); + return xsm_ops->priv_kexec(); } -static inline int xsm_schedop_shutdown (struct domain *d1, struct domain *d2) +static inline int xsm_dm_schedop_shutdown (struct domain *d1, struct domain *d2) { - return xsm_ops->schedop_shutdown(d1, d2); + return xsm_ops->dm_schedop_shutdown(d1, d2); } static inline char *xsm_show_irq_sid (int irq) @@ -341,104 +341,104 @@ static inline char *xsm_show_irq_sid (int irq) return xsm_ops->show_irq_sid(irq); } -static inline int xsm_map_domain_pirq (struct domain *d, int irq, void *data) +static inline int xsm_hook_map_domain_pirq (struct domain *d, int irq, void *data) { - return xsm_ops->map_domain_pirq(d, irq, data); + return xsm_ops->hook_map_domain_pirq(d, irq, data); } -static inline int xsm_unmap_domain_pirq (struct domain *d, int irq) +static inline int xsm_dm_unmap_domain_pirq (struct domain *d, int irq) { - return xsm_ops->unmap_domain_pirq(d, irq); + return xsm_ops->dm_unmap_domain_pirq(d, irq); } -static inline int xsm_irq_permission (struct domain *d, int pirq, uint8_t allow) +static inline int xsm_hook_irq_permission (struct domain *d, int pirq, uint8_t allow) { - return xsm_ops->irq_permission(d, pirq, allow); + return xsm_ops->hook_irq_permission(d, pirq, allow); } -static inline int xsm_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_hook_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return xsm_ops->iomem_permission(d, s, e, allow); + return xsm_ops->hook_iomem_permission(d, s, e, allow); } -static inline int xsm_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_hook_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return xsm_ops->iomem_mapping(d, s, e, allow); + return xsm_ops->hook_iomem_mapping(d, s, e, allow); } -static inline int xsm_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) +static inline int xsm_hook_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { - return xsm_ops->pci_config_permission(d, machine_bdf, start, end, access); + return xsm_ops->hook_pci_config_permission(d, machine_bdf, start, end, access); } -static inline int xsm_get_device_group(uint32_t machine_bdf) +static inline int xsm_hook_get_device_group(uint32_t machine_bdf) { - return xsm_ops->get_device_group(machine_bdf); + return xsm_ops->hook_get_device_group(machine_bdf); } -static inline int xsm_test_assign_device(uint32_t machine_bdf) +static inline int xsm_hook_test_assign_device(uint32_t machine_bdf) { - return xsm_ops->test_assign_device(machine_bdf); + return xsm_ops->hook_test_assign_device(machine_bdf); } -static inline int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_hook_assign_device(struct domain *d, uint32_t machine_bdf) { - return xsm_ops->assign_device(d, machine_bdf); + return xsm_ops->hook_assign_device(d, machine_bdf); } -static inline int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { - return xsm_ops->deassign_device(d, machine_bdf); + return xsm_ops->hook_deassign_device(d, machine_bdf); } -static inline int xsm_resource_plug_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_plug_pci (uint32_t machine_bdf) { - return xsm_ops->resource_plug_pci(machine_bdf); + return xsm_ops->priv_resource_plug_pci(machine_bdf); } -static inline int xsm_resource_unplug_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_unplug_pci (uint32_t machine_bdf) { - return xsm_ops->resource_unplug_pci(machine_bdf); + return xsm_ops->priv_resource_unplug_pci(machine_bdf); } -static inline int xsm_resource_plug_core (void) +static inline int xsm_hook_resource_plug_core (void) { - return xsm_ops->resource_plug_core(); + return xsm_ops->hook_resource_plug_core(); } -static inline int xsm_resource_unplug_core (void) +static inline int xsm_hook_resource_unplug_core (void) { - return xsm_ops->resource_unplug_core(); + return xsm_ops->hook_resource_unplug_core(); } -static inline int xsm_resource_setup_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_setup_pci (uint32_t machine_bdf) { - return xsm_ops->resource_setup_pci(machine_bdf); + return xsm_ops->priv_resource_setup_pci(machine_bdf); } -static inline int xsm_resource_setup_gsi (int gsi) +static inline int xsm_priv_resource_setup_gsi (int gsi) { - return xsm_ops->resource_setup_gsi(gsi); + return xsm_ops->priv_resource_setup_gsi(gsi); } -static inline int xsm_resource_setup_misc (void) +static inline int xsm_priv_resource_setup_misc (void) { - return xsm_ops->resource_setup_misc(); + return xsm_ops->priv_resource_setup_misc(); } -static inline int xsm_page_offline(uint32_t cmd) +static inline int xsm_hook_page_offline(uint32_t cmd) { - return xsm_ops->page_offline(cmd); + return xsm_ops->hook_page_offline(cmd); } -static inline int xsm_tmem_op(void) +static inline int xsm_hook_tmem_op(void) { - return xsm_ops->tmem_op(); + return xsm_ops->hook_tmem_op(); } -static inline int xsm_tmem_control(void) +static inline int xsm_priv_tmem_control(void) { - return xsm_ops->tmem_control(); + return xsm_ops->priv_tmem_control(); } static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) @@ -447,54 +447,54 @@ static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) } #ifdef CONFIG_X86 -static inline int xsm_shadow_control (struct domain *d, uint32_t op) +static inline int xsm_hook_shadow_control (struct domain *d, uint32_t op) { - return xsm_ops->shadow_control(d, op); + return xsm_ops->hook_shadow_control(d, op); } -static inline int xsm_hvm_param (struct domain *d, unsigned long op) +static inline int xsm_target_hvm_param (struct domain *d, unsigned long op) { - return xsm_ops->hvm_param(d, op); + return xsm_ops->target_hvm_param(d, op); } -static inline int xsm_hvm_set_pci_intx_level (struct domain *d) +static inline int xsm_dm_hvm_set_pci_intx_level (struct domain *d) { - return xsm_ops->hvm_set_pci_intx_level(d); + return xsm_ops->dm_hvm_set_pci_intx_level(d); } -static inline int xsm_hvm_set_isa_irq_level (struct domain *d) +static inline int xsm_dm_hvm_set_isa_irq_level (struct domain *d) { - return xsm_ops->hvm_set_isa_irq_level(d); + return xsm_ops->dm_hvm_set_isa_irq_level(d); } -static inline int xsm_hvm_set_pci_link_route (struct domain *d) +static inline int xsm_dm_hvm_set_pci_link_route (struct domain *d) { - return xsm_ops->hvm_set_pci_link_route(d); + return xsm_ops->dm_hvm_set_pci_link_route(d); } -static inline int xsm_hvm_inject_msi (struct domain *d) +static inline int xsm_dm_hvm_inject_msi (struct domain *d) { - return xsm_ops->hvm_inject_msi(d); + return xsm_ops->dm_hvm_inject_msi(d); } -static inline int xsm_mem_event_control (struct domain *d, int mode, int op) +static inline int xsm_dm_mem_event_control (struct domain *d, int mode, int op) { - return xsm_ops->mem_event_control(d, mode, op); + return xsm_ops->dm_mem_event_control(d, mode, op); } -static inline int xsm_mem_event_op (struct domain *d, int op) +static inline int xsm_dm_mem_event_op (struct domain *d, int op) { - return xsm_ops->mem_event_op(d, op); + return xsm_ops->dm_mem_event_op(d, op); } -static inline int xsm_mem_sharing_op (struct domain *d, struct domain *cd, int op) +static inline int xsm_dm_mem_sharing_op (struct domain *d, struct domain *cd, int op) { - return xsm_ops->mem_sharing_op(d, cd, op); + return xsm_ops->dm_mem_sharing_op(d, cd, op); } -static inline int xsm_apic (struct domain *d, int cmd) +static inline int xsm_priv_apic (struct domain *d, int cmd) { - return xsm_ops->apic(d, cmd); + return xsm_ops->priv_apic(d, cmd); } static inline int xsm_memtype (uint32_t access) @@ -502,63 +502,63 @@ static inline int xsm_memtype (uint32_t access) return xsm_ops->memtype(access); } -static inline int xsm_platform_op (uint32_t op) +static inline int xsm_priv_platform_op (uint32_t op) { - return xsm_ops->platform_op(op); + return xsm_ops->priv_platform_op(op); } -static inline int xsm_machine_memory_map(void) +static inline int xsm_priv_machine_memory_map(void) { - return xsm_ops->machine_memory_map(); + return xsm_ops->priv_machine_memory_map(); } -static inline int xsm_domain_memory_map(struct domain *d) +static inline int xsm_target_domain_memory_map(struct domain *d) { - return xsm_ops->domain_memory_map(d); + return xsm_ops->target_domain_memory_map(d); } -static inline int xsm_mmu_update (struct domain *d, struct domain *t, +static inline int xsm_target_mmu_update (struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { - return xsm_ops->mmu_update(d, t, f, flags); + return xsm_ops->target_mmu_update(d, t, f, flags); } -static inline int xsm_mmuext_op (struct domain *d, struct domain *f) +static inline int xsm_target_mmuext_op (struct domain *d, struct domain *f) { - return xsm_ops->mmuext_op(d, f); + return xsm_ops->target_mmuext_op(d, f); } -static inline int xsm_update_va_mapping(struct domain *d, struct domain *f, +static inline int xsm_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { - return xsm_ops->update_va_mapping(d, f, pte); + return xsm_ops->target_update_va_mapping(d, f, pte); } -static inline int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_target_add_to_physmap(struct domain *d1, struct domain *d2) { - return xsm_ops->add_to_physmap(d1, d2); + return xsm_ops->target_add_to_physmap(d1, d2); } -static inline int xsm_bind_pt_irq(struct domain *d, +static inline int xsm_hook_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return xsm_ops->bind_pt_irq(d, bind); + return xsm_ops->hook_bind_pt_irq(d, bind); } -static inline int xsm_unbind_pt_irq(struct domain *d, +static inline int xsm_hook_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return xsm_ops->unbind_pt_irq(d, bind); + return xsm_ops->hook_unbind_pt_irq(d, bind); } -static inline int xsm_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_hook_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return xsm_ops->ioport_permission(d, s, e, allow); + return xsm_ops->hook_ioport_permission(d, s, e, allow); } -static inline int xsm_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_hook_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return xsm_ops->ioport_mapping(d, s, e, allow); + return xsm_ops->hook_ioport_mapping(d, s, e, allow); } #endif /* CONFIG_X86 */ #endif /* XSM_NO_WRAPPERS */ diff --git a/xen/xsm/dummy.c b/xen/xsm/dummy.c index 22c66e5..c29c5af 100644 --- a/xen/xsm/dummy.c +++ b/xen/xsm/dummy.c @@ -29,98 +29,98 @@ struct xsm_operations dummy_xsm_ops; void xsm_fixup_ops (struct xsm_operations *ops) { - set_to_dummy_if_null(ops, security_domaininfo); - set_to_dummy_if_null(ops, domain_create); - set_to_dummy_if_null(ops, getdomaininfo); - set_to_dummy_if_null(ops, set_target); + set_to_dummy_if_null(ops, populate_security_domaininfo); + set_to_dummy_if_null(ops, hook_domain_create); + set_to_dummy_if_null(ops, hook_getdomaininfo); + set_to_dummy_if_null(ops, hook_set_target); set_to_dummy_if_null(ops, domctl); set_to_dummy_if_null(ops, sysctl); - set_to_dummy_if_null(ops, readconsole); - set_to_dummy_if_null(ops, do_mca); - - set_to_dummy_if_null(ops, evtchn_unbound); - set_to_dummy_if_null(ops, evtchn_interdomain); - set_to_dummy_if_null(ops, evtchn_close_post); - set_to_dummy_if_null(ops, evtchn_send); - set_to_dummy_if_null(ops, evtchn_status); - set_to_dummy_if_null(ops, evtchn_reset); - - set_to_dummy_if_null(ops, grant_mapref); - set_to_dummy_if_null(ops, grant_unmapref); - set_to_dummy_if_null(ops, grant_setup); - set_to_dummy_if_null(ops, grant_transfer); - set_to_dummy_if_null(ops, grant_copy); - set_to_dummy_if_null(ops, grant_query_size); + set_to_dummy_if_null(ops, hook_readconsole); + set_to_dummy_if_null(ops, priv_do_mca); + + set_to_dummy_if_null(ops, target_evtchn_unbound); + set_to_dummy_if_null(ops, hook_evtchn_interdomain); + set_to_dummy_if_null(ops, hook_evtchn_close_post); + set_to_dummy_if_null(ops, hook_evtchn_send); + set_to_dummy_if_null(ops, target_evtchn_status); + set_to_dummy_if_null(ops, target_evtchn_reset); + + set_to_dummy_if_null(ops, hook_grant_mapref); + set_to_dummy_if_null(ops, hook_grant_unmapref); + set_to_dummy_if_null(ops, target_grant_setup); + set_to_dummy_if_null(ops, hook_grant_transfer); + set_to_dummy_if_null(ops, hook_grant_copy); + set_to_dummy_if_null(ops, target_grant_query_size); set_to_dummy_if_null(ops, alloc_security_domain); set_to_dummy_if_null(ops, free_security_domain); set_to_dummy_if_null(ops, alloc_security_evtchn); set_to_dummy_if_null(ops, free_security_evtchn); set_to_dummy_if_null(ops, show_security_evtchn); - set_to_dummy_if_null(ops, get_pod_target); - set_to_dummy_if_null(ops, set_pod_target); + set_to_dummy_if_null(ops, priv_get_pod_target); + set_to_dummy_if_null(ops, priv_set_pod_target); - set_to_dummy_if_null(ops, memory_exchange); - set_to_dummy_if_null(ops, memory_adjust_reservation); - set_to_dummy_if_null(ops, memory_stat_reservation); - set_to_dummy_if_null(ops, memory_pin_page); + set_to_dummy_if_null(ops, target_memory_exchange); + set_to_dummy_if_null(ops, target_memory_adjust_reservation); + set_to_dummy_if_null(ops, target_memory_stat_reservation); + set_to_dummy_if_null(ops, hook_memory_pin_page); - set_to_dummy_if_null(ops, console_io); + set_to_dummy_if_null(ops, priv_console_io); - set_to_dummy_if_null(ops, profile); + set_to_dummy_if_null(ops, hook_profile); - set_to_dummy_if_null(ops, kexec); - set_to_dummy_if_null(ops, schedop_shutdown); + set_to_dummy_if_null(ops, priv_kexec); + set_to_dummy_if_null(ops, dm_schedop_shutdown); set_to_dummy_if_null(ops, show_irq_sid); - set_to_dummy_if_null(ops, map_domain_pirq); - set_to_dummy_if_null(ops, unmap_domain_pirq); - set_to_dummy_if_null(ops, irq_permission); - set_to_dummy_if_null(ops, iomem_permission); - set_to_dummy_if_null(ops, iomem_mapping); - set_to_dummy_if_null(ops, pci_config_permission); - - set_to_dummy_if_null(ops, get_device_group); - set_to_dummy_if_null(ops, test_assign_device); - set_to_dummy_if_null(ops, assign_device); - set_to_dummy_if_null(ops, deassign_device); - - set_to_dummy_if_null(ops, resource_plug_core); - set_to_dummy_if_null(ops, resource_unplug_core); - set_to_dummy_if_null(ops, resource_plug_pci); - set_to_dummy_if_null(ops, resource_unplug_pci); - set_to_dummy_if_null(ops, resource_setup_pci); - set_to_dummy_if_null(ops, resource_setup_gsi); - set_to_dummy_if_null(ops, resource_setup_misc); - - set_to_dummy_if_null(ops, page_offline); - set_to_dummy_if_null(ops, tmem_op); - set_to_dummy_if_null(ops, tmem_control); + set_to_dummy_if_null(ops, hook_map_domain_pirq); + set_to_dummy_if_null(ops, dm_unmap_domain_pirq); + set_to_dummy_if_null(ops, hook_irq_permission); + set_to_dummy_if_null(ops, hook_iomem_permission); + set_to_dummy_if_null(ops, hook_iomem_mapping); + set_to_dummy_if_null(ops, hook_pci_config_permission); + + set_to_dummy_if_null(ops, hook_get_device_group); + set_to_dummy_if_null(ops, hook_test_assign_device); + set_to_dummy_if_null(ops, hook_assign_device); + set_to_dummy_if_null(ops, hook_deassign_device); + + set_to_dummy_if_null(ops, hook_resource_plug_core); + set_to_dummy_if_null(ops, hook_resource_unplug_core); + set_to_dummy_if_null(ops, priv_resource_plug_pci); + set_to_dummy_if_null(ops, priv_resource_unplug_pci); + set_to_dummy_if_null(ops, priv_resource_setup_pci); + set_to_dummy_if_null(ops, priv_resource_setup_gsi); + set_to_dummy_if_null(ops, priv_resource_setup_misc); + + set_to_dummy_if_null(ops, hook_page_offline); + set_to_dummy_if_null(ops, hook_tmem_op); + set_to_dummy_if_null(ops, priv_tmem_control); set_to_dummy_if_null(ops, do_xsm_op); #ifdef CONFIG_X86 - set_to_dummy_if_null(ops, shadow_control); - set_to_dummy_if_null(ops, hvm_param); - set_to_dummy_if_null(ops, hvm_set_pci_intx_level); - set_to_dummy_if_null(ops, hvm_set_isa_irq_level); - set_to_dummy_if_null(ops, hvm_set_pci_link_route); - set_to_dummy_if_null(ops, hvm_inject_msi); - set_to_dummy_if_null(ops, mem_event_control); - set_to_dummy_if_null(ops, mem_event_op); - set_to_dummy_if_null(ops, mem_sharing_op); - set_to_dummy_if_null(ops, apic); - set_to_dummy_if_null(ops, platform_op); - set_to_dummy_if_null(ops, machine_memory_map); - set_to_dummy_if_null(ops, domain_memory_map); - set_to_dummy_if_null(ops, mmu_update); - set_to_dummy_if_null(ops, mmuext_op); - set_to_dummy_if_null(ops, update_va_mapping); - set_to_dummy_if_null(ops, add_to_physmap); - set_to_dummy_if_null(ops, remove_from_physmap); - set_to_dummy_if_null(ops, bind_pt_irq); - set_to_dummy_if_null(ops, unbind_pt_irq); - set_to_dummy_if_null(ops, ioport_permission); - set_to_dummy_if_null(ops, ioport_mapping); + set_to_dummy_if_null(ops, hook_shadow_control); + set_to_dummy_if_null(ops, target_hvm_param); + set_to_dummy_if_null(ops, dm_hvm_set_pci_intx_level); + set_to_dummy_if_null(ops, dm_hvm_set_isa_irq_level); + set_to_dummy_if_null(ops, dm_hvm_set_pci_link_route); + set_to_dummy_if_null(ops, dm_hvm_inject_msi); + set_to_dummy_if_null(ops, dm_mem_event_control); + set_to_dummy_if_null(ops, dm_mem_event_op); + set_to_dummy_if_null(ops, dm_mem_sharing_op); + set_to_dummy_if_null(ops, priv_apic); + set_to_dummy_if_null(ops, priv_platform_op); + set_to_dummy_if_null(ops, priv_machine_memory_map); + set_to_dummy_if_null(ops, target_domain_memory_map); + set_to_dummy_if_null(ops, target_mmu_update); + set_to_dummy_if_null(ops, target_mmuext_op); + set_to_dummy_if_null(ops, target_update_va_mapping); + set_to_dummy_if_null(ops, target_add_to_physmap); + set_to_dummy_if_null(ops, target_remove_from_physmap); + set_to_dummy_if_null(ops, hook_bind_pt_irq); + set_to_dummy_if_null(ops, hook_unbind_pt_irq); + set_to_dummy_if_null(ops, hook_ioport_permission); + set_to_dummy_if_null(ops, hook_ioport_mapping); #endif } diff --git a/xen/xsm/flask/hooks.c b/xen/xsm/flask/hooks.c index 03ea675..2c46276 100644 --- a/xen/xsm/flask/hooks.c +++ b/xen/xsm/flask/hooks.c @@ -171,7 +171,7 @@ static void flask_domain_free_security(struct domain *d) xfree(dsec); } -static int flask_evtchn_unbound(struct domain *d1, struct evtchn *chn, +static int flask_target_evtchn_unbound(struct domain *d1, struct evtchn *chn, domid_t id2) { u32 sid1, sid2, newsid; @@ -206,7 +206,7 @@ static int flask_evtchn_unbound(struct domain *d1, struct evtchn *chn, return rc; } -static int flask_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, +static int flask_hook_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, struct domain *d2, struct evtchn *chn2) { u32 sid1, sid2, newsid, reverse_sid; @@ -252,7 +252,7 @@ static int flask_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, return rc; } -static void flask_evtchn_close_post(struct evtchn *chn) +static void flask_hook_evtchn_close_post(struct evtchn *chn) { struct evtchn_security_struct *esec; esec = chn->ssid; @@ -260,7 +260,7 @@ static void flask_evtchn_close_post(struct evtchn *chn) esec->sid = SECINITSID_UNLABELED; } -static int flask_evtchn_send(struct domain *d, struct evtchn *chn) +static int flask_hook_evtchn_send(struct domain *d, struct evtchn *chn) { int rc; @@ -280,12 +280,12 @@ static int flask_evtchn_send(struct domain *d, struct evtchn *chn) return rc; } -static int flask_evtchn_status(struct domain *d, struct evtchn *chn) +static int flask_target_evtchn_status(struct domain *d, struct evtchn *chn) { return domain_has_evtchn(d, chn, EVENT__STATUS); } -static int flask_evtchn_reset(struct domain *d1, struct domain *d2) +static int flask_target_evtchn_reset(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_EVENT, EVENT__RESET); } @@ -350,7 +350,7 @@ static char *flask_show_security_evtchn(struct domain *d, const struct evtchn *c return ctx; } -static int flask_grant_mapref(struct domain *d1, struct domain *d2, +static int flask_hook_grant_mapref(struct domain *d1, struct domain *d2, uint32_t flags) { u32 perms = GRANT__MAP_READ; @@ -361,63 +361,63 @@ static int flask_grant_mapref(struct domain *d1, struct domain *d2, return domain_has_perm(d1, d2, SECCLASS_GRANT, perms); } -static int flask_grant_unmapref(struct domain *d1, struct domain *d2) +static int flask_hook_grant_unmapref(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__UNMAP); } -static int flask_grant_setup(struct domain *d1, struct domain *d2) +static int flask_target_grant_setup(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__SETUP); } -static int flask_grant_transfer(struct domain *d1, struct domain *d2) +static int flask_hook_grant_transfer(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__TRANSFER); } -static int flask_grant_copy(struct domain *d1, struct domain *d2) +static int flask_hook_grant_copy(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__COPY); } -static int flask_grant_query_size(struct domain *d1, struct domain *d2) +static int flask_target_grant_query_size(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__QUERY); } -static int flask_get_pod_target(struct domain *d) +static int flask_priv_get_pod_target(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__GETPODTARGET); } -static int flask_set_pod_target(struct domain *d) +static int flask_priv_set_pod_target(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__SETPODTARGET); } -static int flask_memory_exchange(struct domain *d) +static int flask_target_memory_exchange(struct domain *d) { return current_has_perm(d, SECCLASS_MMU, MMU__EXCHANGE); } -static int flask_memory_adjust_reservation(struct domain *d1, struct domain *d2) +static int flask_target_memory_adjust_reservation(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__ADJUST); } -static int flask_memory_stat_reservation(struct domain *d1, struct domain *d2) +static int flask_target_memory_stat_reservation(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__STAT); } -static int flask_memory_pin_page(struct domain *d1, struct domain *d2, +static int flask_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PINPAGE); } -static int flask_console_io(struct domain *d, int cmd) +static int flask_priv_console_io(struct domain *d, int cmd) { u32 perm; @@ -436,7 +436,7 @@ static int flask_console_io(struct domain *d, int cmd) return domain_has_xen(d, perm); } -static int flask_profile(struct domain *d, int op) +static int flask_hook_profile(struct domain *d, int op) { u32 perm; @@ -468,23 +468,23 @@ static int flask_profile(struct domain *d, int op) return domain_has_xen(d, perm); } -static int flask_kexec(void) +static int flask_priv_kexec(void) { return domain_has_xen(current->domain, XEN__KEXEC); } -static int flask_schedop_shutdown(struct domain *d1, struct domain *d2) +static int flask_dm_schedop_shutdown(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_DOMAIN, DOMAIN__SHUTDOWN); } -static void flask_security_domaininfo(struct domain *d, +static void flask_populate_security_domaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) { info->ssidref = domain_sid(d); } -static int flask_domain_create(struct domain *d, u32 ssidref) +static int flask_hook_domain_create(struct domain *d, u32 ssidref) { int rc; struct domain_security_struct *dsec = d->ssid; @@ -512,12 +512,12 @@ static int flask_domain_create(struct domain *d, u32 ssidref) return rc; } -static int flask_getdomaininfo(struct domain *d) +static int flask_hook_getdomaininfo(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__GETDOMAININFO); } -static int flask_set_target(struct domain *d, struct domain *t) +static int flask_hook_set_target(struct domain *d, struct domain *t) { int rc; struct domain_security_struct *dsec, *tsec; @@ -753,7 +753,7 @@ static int flask_sysctl(int cmd) } } -static int flask_readconsole(uint32_t clear) +static int flask_hook_readconsole(uint32_t clear) { u32 perms = XEN__READCONSOLE; @@ -763,7 +763,7 @@ static int flask_readconsole(uint32_t clear) return domain_has_xen(current->domain, perms); } -static int flask_do_mca(void) +static int flask_priv_do_mca(void) { return domain_has_xen(current->domain, XEN__MCA_OP); } @@ -790,7 +790,7 @@ static char *flask_show_irq_sid (int irq) return ctx; } -static int flask_map_domain_pirq (struct domain *d, int irq, void *data) +static int flask_hook_map_domain_pirq (struct domain *d, int irq, void *data) { u32 sid, dsid; int rc = -EPERM; @@ -823,7 +823,7 @@ static int flask_map_domain_pirq (struct domain *d, int irq, void *data) return rc; } -static int flask_unmap_domain_pirq (struct domain *d, int irq) +static int flask_dm_unmap_domain_pirq (struct domain *d, int irq) { u32 sid; int rc = -EPERM; @@ -846,7 +846,7 @@ static int flask_unmap_domain_pirq (struct domain *d, int irq) return rc; } -static int flask_irq_permission (struct domain *d, int pirq, uint8_t access) +static int flask_hook_irq_permission (struct domain *d, int pirq, uint8_t access) { /* the PIRQ number is not useful; real IRQ is checked during mapping */ return current_has_perm(d, SECCLASS_RESOURCE, resource_to_perm(access)); @@ -876,7 +876,7 @@ static int _iomem_has_perm(void *v, u32 sid, unsigned long start, unsigned long return avc_has_perm(data->dsid, sid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_iomem_permission(struct domain *d, uint64_t start, uint64_t end, uint8_t access) +static int flask_hook_iomem_permission(struct domain *d, uint64_t start, uint64_t end, uint8_t access) { struct iomem_has_perm_data data; int rc; @@ -897,12 +897,12 @@ static int flask_iomem_permission(struct domain *d, uint64_t start, uint64_t end return security_iterate_iomem_sids(start, end, _iomem_has_perm, &data); } -static int flask_iomem_mapping(struct domain *d, uint64_t start, uint64_t end, uint8_t access) +static int flask_hook_iomem_mapping(struct domain *d, uint64_t start, uint64_t end, uint8_t access) { - return flask_iomem_permission(d, start, end, access); + return flask_hook_iomem_permission(d, start, end, access); } -static int flask_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) +static int flask_hook_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { u32 dsid, rsid; int rc = -EPERM; @@ -924,12 +924,12 @@ static int flask_pci_config_permission(struct domain *d, uint32_t machine_bdf, u } -static int flask_resource_plug_core(void) +static int flask_hook_resource_plug_core(void) { return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__PLUG, NULL); } -static int flask_resource_unplug_core(void) +static int flask_hook_resource_unplug_core(void) { return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__UNPLUG, NULL); } @@ -939,7 +939,7 @@ static int flask_resource_use_core(void) return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__USE, NULL); } -static int flask_resource_plug_pci(uint32_t machine_bdf) +static int flask_priv_resource_plug_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -954,7 +954,7 @@ static int flask_resource_plug_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__PLUG, &ad); } -static int flask_resource_unplug_pci(uint32_t machine_bdf) +static int flask_priv_resource_unplug_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -969,7 +969,7 @@ static int flask_resource_unplug_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__UNPLUG, &ad); } -static int flask_resource_setup_pci(uint32_t machine_bdf) +static int flask_priv_resource_setup_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -984,7 +984,7 @@ static int flask_resource_setup_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__SETUP, &ad); } -static int flask_resource_setup_gsi(int gsi) +static int flask_priv_resource_setup_gsi(int gsi) { u32 rsid; int rc = -EPERM; @@ -997,18 +997,18 @@ static int flask_resource_setup_gsi(int gsi) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__SETUP, &ad); } -static int flask_resource_setup_misc(void) +static int flask_priv_resource_setup_misc(void) { return avc_current_has_perm(SECINITSID_XEN, SECCLASS_RESOURCE, RESOURCE__SETUP, NULL); } -static inline int flask_page_offline(uint32_t cmd) +static inline int flask_hook_page_offline(uint32_t cmd) { switch (cmd) { case sysctl_page_offline: - return flask_resource_unplug_core(); + return flask_hook_resource_unplug_core(); case sysctl_page_online: - return flask_resource_plug_core(); + return flask_hook_resource_plug_core(); case sysctl_query_page_offline: return flask_resource_use_core(); default: @@ -1016,18 +1016,18 @@ static inline int flask_page_offline(uint32_t cmd) } } -static inline int flask_tmem_op(void) +static inline int flask_hook_tmem_op(void) { return domain_has_xen(current->domain, XEN__TMEM_OP); } -static inline int flask_tmem_control(void) +static inline int flask_priv_tmem_control(void) { return domain_has_xen(current->domain, XEN__TMEM_CONTROL); } #ifdef CONFIG_X86 -static int flask_shadow_control(struct domain *d, uint32_t op) +static int flask_hook_shadow_control(struct domain *d, uint32_t op) { u32 perm; @@ -1079,7 +1079,7 @@ static int _ioport_has_perm(void *v, u32 sid, unsigned long start, unsigned long return avc_has_perm(data->dsid, sid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_ioport_permission(struct domain *d, uint32_t start, uint32_t end, uint8_t access) +static int flask_hook_ioport_permission(struct domain *d, uint32_t start, uint32_t end, uint8_t access) { int rc; struct ioport_has_perm_data data; @@ -1101,12 +1101,12 @@ static int flask_ioport_permission(struct domain *d, uint32_t start, uint32_t en return security_iterate_ioport_sids(start, end, _ioport_has_perm, &data); } -static int flask_ioport_mapping(struct domain *d, uint32_t start, uint32_t end, uint8_t access) +static int flask_hook_ioport_mapping(struct domain *d, uint32_t start, uint32_t end, uint8_t access) { - return flask_ioport_permission(d, start, end, access); + return flask_hook_ioport_permission(d, start, end, access); } -static int flask_hvm_param(struct domain *d, unsigned long op) +static int flask_target_hvm_param(struct domain *d, unsigned long op) { u32 perm; @@ -1128,37 +1128,37 @@ static int flask_hvm_param(struct domain *d, unsigned long op) return current_has_perm(d, SECCLASS_HVM, perm); } -static int flask_hvm_set_pci_intx_level(struct domain *d) +static int flask_dm_hvm_set_pci_intx_level(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__PCILEVEL); } -static int flask_hvm_set_isa_irq_level(struct domain *d) +static int flask_dm_hvm_set_isa_irq_level(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__IRQLEVEL); } -static int flask_hvm_set_pci_link_route(struct domain *d) +static int flask_dm_hvm_set_pci_link_route(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__PCIROUTE); } -static int flask_hvm_inject_msi(struct domain *d) +static int flask_dm_hvm_inject_msi(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__SEND_IRQ); } -static int flask_mem_event_control(struct domain *d, int mode, int op) +static int flask_dm_mem_event_control(struct domain *d, int mode, int op) { return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); } -static int flask_mem_event_op(struct domain *d, int op) +static int flask_dm_mem_event_op(struct domain *d, int op) { return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); } -static int flask_mem_sharing_op(struct domain *d, struct domain *cd, int op) +static int flask_dm_mem_sharing_op(struct domain *d, struct domain *cd, int op) { int rc = current_has_perm(cd, SECCLASS_HVM, HVM__MEM_SHARING); if ( rc ) @@ -1166,7 +1166,7 @@ static int flask_mem_sharing_op(struct domain *d, struct domain *cd, int op) return domain_has_perm(d, cd, SECCLASS_HVM, HVM__SHARE_MEM); } -static int flask_apic(struct domain *d, int cmd) +static int flask_priv_apic(struct domain *d, int cmd) { u32 perm; @@ -1186,7 +1186,7 @@ static int flask_apic(struct domain *d, int cmd) return domain_has_xen(d, perm); } -static int flask_platform_op(uint32_t op) +static int flask_priv_platform_op(uint32_t op) { switch ( op ) { @@ -1241,22 +1241,22 @@ static int flask_platform_op(uint32_t op) return domain_has_xen(current->domain, XEN__GETCPUINFO); default: - printk("flask_platform_op: Unknown op %d\n", op); + printk("flask_priv_platform_op: Unknown op %d\n", op); return -EPERM; } } -static int flask_machine_memory_map(void) +static int flask_priv_machine_memory_map(void) { return avc_current_has_perm(SECINITSID_XEN, SECCLASS_MMU, MMU__MEMORYMAP, NULL); } -static int flask_domain_memory_map(struct domain *d) +static int flask_target_domain_memory_map(struct domain *d) { return current_has_perm(d, SECCLASS_MMU, MMU__MEMORYMAP); } -static int flask_mmu_update(struct domain *d, struct domain *t, +static int flask_target_mmu_update(struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { int rc = 0; @@ -1279,12 +1279,12 @@ static int flask_mmu_update(struct domain *d, struct domain *t, return rc; } -static int flask_mmuext_op(struct domain *d, struct domain *f) +static int flask_target_mmuext_op(struct domain *d, struct domain *f) { return domain_has_perm(d, f, SECCLASS_MMU, MMU__MMUEXT_OP); } -static int flask_update_va_mapping(struct domain *d, struct domain *f, +static int flask_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { u32 map_perms = MMU__MAP_READ; @@ -1296,17 +1296,17 @@ static int flask_update_va_mapping(struct domain *d, struct domain *f, return domain_has_perm(d, f, SECCLASS_MMU, map_perms); } -static int flask_add_to_physmap(struct domain *d1, struct domain *d2) +static int flask_target_add_to_physmap(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PHYSMAP); } -static int flask_remove_from_physmap(struct domain *d1, struct domain *d2) +static int flask_target_remove_from_physmap(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PHYSMAP); } -static int flask_get_device_group(uint32_t machine_bdf) +static int flask_hook_get_device_group(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -1330,7 +1330,7 @@ static int flask_test_assign_device(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__STAT_DEVICE, NULL); } -static int flask_assign_device(struct domain *d, uint32_t machine_bdf) +static int flask_hook_assign_device(struct domain *d, uint32_t machine_bdf) { u32 dsid, rsid; int rc = -EPERM; @@ -1354,7 +1354,7 @@ static int flask_assign_device(struct domain *d, uint32_t machine_bdf) return avc_has_perm(dsid, rsid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_deassign_device(struct domain *d, uint32_t machine_bdf) +static int flask_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -1370,7 +1370,7 @@ static int flask_deassign_device(struct domain *d, uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__REMOVE_DEVICE, NULL); } -static int flask_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static int flask_hook_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) { u32 dsid, rsid; int rc = -EPERM; @@ -1395,7 +1395,7 @@ static int flask_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *b return avc_has_perm(dsid, rsid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static int flask_hook_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return current_has_perm(d, SECCLASS_RESOURCE, RESOURCE__REMOVE); } @@ -1404,28 +1404,28 @@ static int flask_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq long do_flask_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) u_flask_op); static struct xsm_operations flask_ops = { - .security_domaininfo = flask_security_domaininfo, - .domain_create = flask_domain_create, - .getdomaininfo = flask_getdomaininfo, - .set_target = flask_set_target, + .populate_security_domaininfo = flask_populate_security_domaininfo, + .hook_domain_create = flask_hook_domain_create, + .hook_getdomaininfo = flask_hook_getdomaininfo, + .hook_set_target = flask_hook_set_target, .domctl = flask_domctl, .sysctl = flask_sysctl, - .readconsole = flask_readconsole, - .do_mca = flask_do_mca, - - .evtchn_unbound = flask_evtchn_unbound, - .evtchn_interdomain = flask_evtchn_interdomain, - .evtchn_close_post = flask_evtchn_close_post, - .evtchn_send = flask_evtchn_send, - .evtchn_status = flask_evtchn_status, - .evtchn_reset = flask_evtchn_reset, - - .grant_mapref = flask_grant_mapref, - .grant_unmapref = flask_grant_unmapref, - .grant_setup = flask_grant_setup, - .grant_transfer = flask_grant_transfer, - .grant_copy = flask_grant_copy, - .grant_query_size = flask_grant_query_size, + .hook_readconsole = flask_hook_readconsole, + .priv_do_mca = flask_priv_do_mca, + + .target_evtchn_unbound = flask_target_evtchn_unbound, + .hook_evtchn_interdomain = flask_hook_evtchn_interdomain, + .hook_evtchn_close_post = flask_hook_evtchn_close_post, + .hook_evtchn_send = flask_hook_evtchn_send, + .target_evtchn_status = flask_target_evtchn_status, + .target_evtchn_reset = flask_target_evtchn_reset, + + .hook_grant_mapref = flask_hook_grant_mapref, + .hook_grant_unmapref = flask_hook_grant_unmapref, + .target_grant_setup = flask_target_grant_setup, + .hook_grant_transfer = flask_hook_grant_transfer, + .hook_grant_copy = flask_hook_grant_copy, + .target_grant_query_size = flask_target_grant_query_size, .alloc_security_domain = flask_domain_alloc_security, .free_security_domain = flask_domain_free_security, @@ -1433,70 +1433,70 @@ static struct xsm_operations flask_ops = { .free_security_evtchn = flask_free_security_evtchn, .show_security_evtchn = flask_show_security_evtchn, - .get_pod_target = flask_get_pod_target, - .set_pod_target = flask_set_pod_target, - .memory_exchange = flask_memory_exchange, - .memory_adjust_reservation = flask_memory_adjust_reservation, - .memory_stat_reservation = flask_memory_stat_reservation, - .memory_pin_page = flask_memory_pin_page, + .priv_get_pod_target = flask_priv_get_pod_target, + .priv_set_pod_target = flask_priv_set_pod_target, + .target_memory_exchange = flask_target_memory_exchange, + .target_memory_adjust_reservation = flask_target_memory_adjust_reservation, + .target_memory_stat_reservation = flask_target_memory_stat_reservation, + .hook_memory_pin_page = flask_hook_memory_pin_page, - .console_io = flask_console_io, + .priv_console_io = flask_priv_console_io, - .profile = flask_profile, + .hook_profile = flask_hook_profile, - .kexec = flask_kexec, - .schedop_shutdown = flask_schedop_shutdown, + .priv_kexec = flask_priv_kexec, + .dm_schedop_shutdown = flask_dm_schedop_shutdown, .show_irq_sid = flask_show_irq_sid, - .map_domain_pirq = flask_map_domain_pirq, - .unmap_domain_pirq = flask_unmap_domain_pirq, - .irq_permission = flask_irq_permission, - .iomem_permission = flask_iomem_permission, - .iomem_mapping = flask_iomem_mapping, - .pci_config_permission = flask_pci_config_permission, - - .resource_plug_core = flask_resource_plug_core, - .resource_unplug_core = flask_resource_unplug_core, - .resource_plug_pci = flask_resource_plug_pci, - .resource_unplug_pci = flask_resource_unplug_pci, - .resource_setup_pci = flask_resource_setup_pci, - .resource_setup_gsi = flask_resource_setup_gsi, - .resource_setup_misc = flask_resource_setup_misc, - - .page_offline = flask_page_offline, - .tmem_op = flask_tmem_op, - .tmem_control = flask_tmem_control, + .hook_map_domain_pirq = flask_hook_map_domain_pirq, + .dm_unmap_domain_pirq = flask_dm_unmap_domain_pirq, + .hook_irq_permission = flask_hook_irq_permission, + .hook_iomem_permission = flask_hook_iomem_permission, + .hook_iomem_mapping = flask_hook_iomem_mapping, + .hook_pci_config_permission = flask_hook_pci_config_permission, + + .hook_resource_plug_core = flask_hook_resource_plug_core, + .hook_resource_unplug_core = flask_hook_resource_unplug_core, + .priv_resource_plug_pci = flask_priv_resource_plug_pci, + .priv_resource_unplug_pci = flask_priv_resource_unplug_pci, + .priv_resource_setup_pci = flask_priv_resource_setup_pci, + .priv_resource_setup_gsi = flask_priv_resource_setup_gsi, + .priv_resource_setup_misc = flask_priv_resource_setup_misc, + + .hook_page_offline = flask_hook_page_offline, + .hook_tmem_op = flask_hook_tmem_op, + .priv_tmem_control = flask_priv_tmem_control, .do_xsm_op = do_flask_op, #ifdef CONFIG_X86 - .shadow_control = flask_shadow_control, - .hvm_param = flask_hvm_param, - .hvm_set_pci_intx_level = flask_hvm_set_pci_intx_level, - .hvm_set_isa_irq_level = flask_hvm_set_isa_irq_level, - .hvm_set_pci_link_route = flask_hvm_set_pci_link_route, - .hvm_inject_msi = flask_hvm_inject_msi, - .mem_event_control = flask_mem_event_control, - .mem_event_op = flask_mem_event_op, - .mem_sharing_op = flask_mem_sharing_op, - .apic = flask_apic, - .platform_op = flask_platform_op, - .machine_memory_map = flask_machine_memory_map, - .domain_memory_map = flask_domain_memory_map, - .mmu_update = flask_mmu_update, - .mmuext_op = flask_mmuext_op, - .update_va_mapping = flask_update_va_mapping, - .add_to_physmap = flask_add_to_physmap, - .remove_from_physmap = flask_remove_from_physmap, - .get_device_group = flask_get_device_group, - .test_assign_device = flask_test_assign_device, - .assign_device = flask_assign_device, - .deassign_device = flask_deassign_device, - .bind_pt_irq = flask_bind_pt_irq, - .unbind_pt_irq = flask_unbind_pt_irq, - .ioport_permission = flask_ioport_permission, - .ioport_mapping = flask_ioport_mapping, + .hook_shadow_control = flask_hook_shadow_control, + .target_hvm_param = flask_target_hvm_param, + .dm_hvm_set_pci_intx_level = flask_dm_hvm_set_pci_intx_level, + .dm_hvm_set_isa_irq_level = flask_dm_hvm_set_isa_irq_level, + .dm_hvm_set_pci_link_route = flask_dm_hvm_set_pci_link_route, + .dm_hvm_inject_msi = flask_dm_hvm_inject_msi, + .dm_mem_event_control = flask_dm_mem_event_control, + .dm_mem_event_op = flask_dm_mem_event_op, + .dm_mem_sharing_op = flask_dm_mem_sharing_op, + .priv_apic = flask_priv_apic, + .priv_platform_op = flask_priv_platform_op, + .priv_machine_memory_map = flask_priv_machine_memory_map, + .target_domain_memory_map = flask_target_domain_memory_map, + .target_mmu_update = flask_target_mmu_update, + .target_mmuext_op = flask_target_mmuext_op, + .target_update_va_mapping = flask_target_update_va_mapping, + .target_add_to_physmap = flask_target_add_to_physmap, + .target_remove_from_physmap = flask_target_remove_from_physmap, + .hook_get_device_group = flask_hook_get_device_group, + .hook_test_assign_device = flask_test_assign_device, + .hook_assign_device = flask_hook_assign_device, + .hook_deassign_device = flask_hook_deassign_device, + .hook_bind_pt_irq = flask_hook_bind_pt_irq, + .hook_unbind_pt_irq = flask_hook_unbind_pt_irq, + .hook_ioport_permission = flask_hook_ioport_permission, + .hook_ioport_mapping = flask_hook_ioport_mapping, #endif }; -- 1.7.11.7 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Tue Nov 20 17:07:21 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 20 Nov 2012 17:07:21 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TarHz-0008Ua-6E; Tue, 20 Nov 2012 17:07:11 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TarHx-0008UN-Nc for xen-devel@lists.xen.org; Tue, 20 Nov 2012 17:07:10 +0000 Received: from [85.158.143.35:63093] by server-2.bemta-4.messagelabs.com id 82/92-28922-DB8BBA05; Tue, 20 Nov 2012 17:07:09 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-13.tower-21.messagelabs.com!1353431210!17875939!1 X-Originating-IP: [63.239.67.10] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 23691 invoked from network); 20 Nov 2012 17:06:51 -0000 Received: from emvm-gh1-uea09.nsa.gov (HELO nsa.gov) (63.239.67.10) by server-13.tower-21.messagelabs.com with SMTP; 20 Nov 2012 17:06:51 -0000 X-TM-IMSS-Message-ID: <0a20c06600009afe@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.3.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 0a20c06600009afe ; Mon, 19 Nov 2012 16:31:55 -0500 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [144.51.25.48]) by tarius.tycho.ncsc.mil (8.13.1/8.13.1) with ESMTP id qAJLSNQG013605; Mon, 19 Nov 2012 16:28:25 -0500 From: Daniel De Graaf To: tim@xen.org Date: Mon, 19 Nov 2012 16:28:22 -0500 Message-Id: <1353360502-27819-6-git-send-email-dgdegra@tycho.nsa.gov> X-Mailer: git-send-email 1.7.11.7 In-Reply-To: <1353360502-27819-1-git-send-email-dgdegra@tycho.nsa.gov> References: <50AA5521.6080907@tycho.nsa.gov> <1353360502-27819-1-git-send-email-dgdegra@tycho.nsa.gov> Cc: Daniel De Graaf , keir@xen.org, ian.campbell@citrix.com, JBeulich@suse.com, xen-devel@lists.xen.org Subject: [Xen-devel] [PATCH RFC 5/5] xen/xsm: include default hook action in name 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 Include the default XSM hook action in the name of the hook in order to allow quick understanding of how the call site is expected to be used (dom0-only, arbitrary guest, or target-only). Abbreviation explanation: xsm_dm_* Usable only by device model (IS_PRIV_FOR) xsm_hook_* No access check in dummy module. The calling code is either guest-accessible or covered by another check xsm_priv_* Privileged command (IS_PRIV) xsm_target_* Usable by guest or its device model targeted to the guest Signed-off-by: Daniel De Graaf --- xen/arch/x86/cpu/mcheck/mce.c | 2 +- xen/arch/x86/domctl.c | 10 +- xen/arch/x86/hvm/hvm.c | 26 +-- xen/arch/x86/irq.c | 2 +- xen/arch/x86/mm.c | 20 +- xen/arch/x86/mm/mem_event.c | 4 +- xen/arch/x86/mm/mem_sharing.c | 4 +- xen/arch/x86/mm/paging.c | 2 +- xen/arch/x86/msi.c | 2 +- xen/arch/x86/physdev.c | 12 +- xen/arch/x86/platform_hypercall.c | 12 +- xen/arch/x86/sysctl.c | 4 +- xen/arch/x86/traps.c | 2 +- xen/common/domain.c | 2 +- xen/common/domctl.c | 10 +- xen/common/event_channel.c | 14 +- xen/common/grant_table.c | 16 +- xen/common/kexec.c | 2 +- xen/common/memory.c | 8 +- xen/common/schedule.c | 2 +- xen/common/sysctl.c | 6 +- xen/common/xenoprof.c | 2 +- xen/drivers/char/console.c | 2 +- xen/drivers/passthrough/iommu.c | 10 +- xen/drivers/passthrough/pci.c | 4 +- xen/include/xen/tmem_xen.h | 4 +- xen/include/xsm/dummy.h | 140 ++++++------- xen/include/xsm/xsm.h | 428 +++++++++++++++++++------------------- xen/xsm/dummy.c | 150 ++++++------- xen/xsm/flask/hooks.c | 296 +++++++++++++------------- 30 files changed, 599 insertions(+), 599 deletions(-) diff --git a/xen/arch/x86/cpu/mcheck/mce.c b/xen/arch/x86/cpu/mcheck/mce.c index 658774a..72f6f18 100644 --- a/xen/arch/x86/cpu/mcheck/mce.c +++ b/xen/arch/x86/cpu/mcheck/mce.c @@ -1293,7 +1293,7 @@ long do_mca(XEN_GUEST_HANDLE_PARAM(xen_mc_t) u_xen_mc) struct xen_mc_msrinject *mc_msrinject; struct xen_mc_mceinject *mc_mceinject; - ret = xsm_do_mca(); + ret = xsm_priv_do_mca(); if ( ret ) return x86_mcerr(NULL, ret); diff --git a/xen/arch/x86/domctl.c b/xen/arch/x86/domctl.c index 2630bdb..9541ef8 100644 --- a/xen/arch/x86/domctl.c +++ b/xen/arch/x86/domctl.c @@ -76,7 +76,7 @@ long arch_do_domctl( if ( np == 0 ) ret = 0; - else if ( xsm_ioport_permission(d, fp, fp + np - 1, allow) ) + else if ( xsm_hook_ioport_permission(d, fp, fp + np - 1, allow) ) ret = -EPERM; else if ( allow ) ret = ioports_permit_access(d, fp, fp + np - 1); @@ -566,7 +566,7 @@ long arch_do_domctl( if ( !is_hvm_domain(d) ) break; - ret = xsm_bind_pt_irq(d, bind); + ret = xsm_hook_bind_pt_irq(d, bind); if ( ret ) break; @@ -599,7 +599,7 @@ long arch_do_domctl( !irq_access_permitted(current->domain, bind->machine_irq) ) break; - ret = xsm_unbind_pt_irq(d, bind); + ret = xsm_hook_unbind_pt_irq(d, bind); if ( ret ) break; @@ -634,7 +634,7 @@ long arch_do_domctl( !iomem_access_permitted(current->domain, mfn, mfn + nr_mfns - 1) ) break; - ret = xsm_iomem_mapping(d, mfn, mfn + nr_mfns - 1, add); + ret = xsm_hook_iomem_mapping(d, mfn, mfn + nr_mfns - 1, add); if ( ret ) break; @@ -712,7 +712,7 @@ long arch_do_domctl( !ioports_access_permitted(current->domain, fmp, fmp + np - 1) ) break; - ret = xsm_ioport_mapping(d, fmp, fmp + np - 1, add); + ret = xsm_hook_ioport_mapping(d, fmp, fmp + np - 1, add); if ( ret ) break; diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 5bdde8d..e75c139 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -3400,7 +3400,7 @@ static int hvmop_set_pci_intx_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_intx_level(d); + rc = xsm_dm_hvm_set_pci_intx_level(d); if ( rc ) goto out; @@ -3567,7 +3567,7 @@ static int hvmop_set_isa_irq_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_isa_irq_level(d); + rc = xsm_dm_hvm_set_isa_irq_level(d); if ( rc ) goto out; @@ -3611,7 +3611,7 @@ static int hvmop_set_pci_link_route( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_link_route(d); + rc = xsm_dm_hvm_set_pci_link_route(d); if ( rc ) goto out; @@ -3641,7 +3641,7 @@ static int hvmop_inject_msi( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_inject_msi(d); + rc = xsm_dm_hvm_inject_msi(d); if ( rc ) goto out; @@ -3738,7 +3738,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail; @@ -3984,7 +3984,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail2; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail2; @@ -4023,7 +4023,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail3; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail3; @@ -4069,7 +4069,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail_getmemtype; @@ -4124,7 +4124,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail4; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail4; @@ -4203,7 +4203,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail5; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail5; @@ -4238,7 +4238,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail6; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail6; @@ -4274,7 +4274,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) || !paging_mode_shadow(d) ) goto param_fail7; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail7; @@ -4328,7 +4328,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail8; - rc = xsm_hvm_param(d, op); + rc = xsm_target_hvm_param(d, op); if ( rc ) goto param_fail8; diff --git a/xen/arch/x86/irq.c b/xen/arch/x86/irq.c index 238600a..ba8a5ce 100644 --- a/xen/arch/x86/irq.c +++ b/xen/arch/x86/irq.c @@ -1874,7 +1874,7 @@ int map_domain_pirq( return 0; } - ret = xsm_map_domain_pirq(d, irq, data); + ret = xsm_hook_map_domain_pirq(d, irq, data); if ( ret ) { dprintk(XENLOG_G_ERR, "dom%d: could not permit access to irq %d mapping to pirq %d\n", diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c index 39b2cc7..1dbe4ef 100644 --- a/xen/arch/x86/mm.c +++ b/xen/arch/x86/mm.c @@ -2715,7 +2715,7 @@ long do_mmuext_op( goto out; } - rc = xsm_mmuext_op(d, pg_owner); + rc = xsm_target_mmuext_op(d, pg_owner); if ( rc ) { rcu_unlock_domain(pg_owner); @@ -2787,7 +2787,7 @@ long do_mmuext_op( break; } - if ( (rc = xsm_memory_pin_page(d, pg_owner, page)) != 0 ) + if ( (rc = xsm_hook_memory_pin_page(d, pg_owner, page)) != 0 ) { put_page_and_type(page); okay = 0; @@ -3244,7 +3244,7 @@ long do_mmu_update( } if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, pt_owner, pg_owner, xsm_needed); + rc = xsm_target_mmu_update(d, pt_owner, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3363,7 +3363,7 @@ long do_mmu_update( xsm_needed |= XSM_MMU_MACHPHYS_UPDATE; if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, NULL, pg_owner, xsm_needed); + rc = xsm_target_mmu_update(d, NULL, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3931,7 +3931,7 @@ static int __do_update_va_mapping( perfc_incr(calls_to_update_va); - rc = xsm_update_va_mapping(d, pg_owner, val); + rc = xsm_target_update_va_mapping(d, pg_owner, val); if ( rc ) return rc; @@ -4402,7 +4402,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_add_to_physmap(current->domain, d) ) + if ( xsm_target_add_to_physmap(current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; @@ -4441,7 +4441,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_domain_memory_map(d); + rc = xsm_target_domain_memory_map(d); if ( rc ) { rcu_unlock_domain(d); @@ -4516,7 +4516,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) XEN_GUEST_HANDLE_PARAM(e820entry_t) buffer_param; unsigned int i; - rc = xsm_machine_memory_map(); + rc = xsm_priv_machine_memory_map(); if ( rc ) return rc; @@ -4600,9 +4600,9 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -ESRCH; if ( op == XENMEM_set_pod_target ) - rc = xsm_set_pod_target(d); + rc = xsm_priv_set_pod_target(d); else - rc = xsm_get_pod_target(d); + rc = xsm_priv_get_pod_target(d); if ( rc != 0 ) goto pod_target_out_unlock; diff --git a/xen/arch/x86/mm/mem_event.c b/xen/arch/x86/mm/mem_event.c index c2b3670..3a7605c 100644 --- a/xen/arch/x86/mm/mem_event.c +++ b/xen/arch/x86/mm/mem_event.c @@ -449,7 +449,7 @@ int do_mem_event_op(int op, uint32_t domain, void *arg) if ( ret ) return ret; - ret = xsm_mem_event_op(d, op); + ret = xsm_dm_mem_event_op(d, op); if ( ret ) goto out; @@ -502,7 +502,7 @@ int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, { int rc; - rc = xsm_mem_event_control(d, mec->mode, mec->op); + rc = xsm_dm_mem_event_control(d, mec->mode, mec->op); if ( rc ) return rc; diff --git a/xen/arch/x86/mm/mem_sharing.c b/xen/arch/x86/mm/mem_sharing.c index 9229b83..57f02af 100644 --- a/xen/arch/x86/mm/mem_sharing.c +++ b/xen/arch/x86/mm/mem_sharing.c @@ -1351,7 +1351,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_dm_mem_sharing_op(d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); @@ -1415,7 +1415,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_dm_mem_sharing_op(d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..1815696 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -678,7 +678,7 @@ int paging_domctl(struct domain *d, xen_domctl_shadow_op_t *sc, return -EINVAL; } - rc = xsm_shadow_control(d, sc->op); + rc = xsm_hook_shadow_control(d, sc->op); if ( rc ) return rc; diff --git a/xen/arch/x86/msi.c b/xen/arch/x86/msi.c index e48ad2e..4bad230 100644 --- a/xen/arch/x86/msi.c +++ b/xen/arch/x86/msi.c @@ -1016,7 +1016,7 @@ int pci_restore_msi_state(struct pci_dev *pdev) if (!pdev) return -EINVAL; - ret = xsm_resource_setup_pci((pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); + ret = xsm_priv_resource_setup_pci((pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); if ( ret ) return ret; diff --git a/xen/arch/x86/physdev.c b/xen/arch/x86/physdev.c index 9c30245..a894c43 100644 --- a/xen/arch/x86/physdev.c +++ b/xen/arch/x86/physdev.c @@ -232,7 +232,7 @@ int physdev_unmap_pirq(domid_t domid, int pirq) goto free_domain; } - ret = xsm_unmap_domain_pirq(d, domain_pirq_to_irq(d, pirq)); + ret = xsm_dm_unmap_domain_pirq(d, domain_pirq_to_irq(d, pirq)); if ( ret ) goto free_domain; @@ -423,7 +423,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; ret = ioapic_guest_read(apic.apic_physbase, apic.reg, &apic.value); @@ -437,7 +437,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; ret = ioapic_guest_write(apic.apic_physbase, apic.reg, apic.value); @@ -453,7 +453,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) /* Use the APIC check since this dummy hypercall should still only * be called by the domain with access to program the ioapic */ - ret = xsm_apic(v->domain, cmd); + ret = xsm_priv_apic(v->domain, cmd); if ( ret ) break; @@ -578,7 +578,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) case PHYSDEVOP_pci_mmcfg_reserved: { struct physdev_pci_mmcfg_reserved info; - ret = xsm_resource_setup_misc(); + ret = xsm_priv_resource_setup_misc(); if ( ret ) break; @@ -632,7 +632,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( setup_gsi.gsi < 0 || setup_gsi.gsi >= nr_irqs_gsi ) break; - ret = xsm_resource_setup_gsi(setup_gsi.gsi); + ret = xsm_priv_resource_setup_gsi(setup_gsi.gsi); if ( ret ) break; diff --git a/xen/arch/x86/platform_hypercall.c b/xen/arch/x86/platform_hypercall.c index f267b8b..c4b20ea 100644 --- a/xen/arch/x86/platform_hypercall.c +++ b/xen/arch/x86/platform_hypercall.c @@ -72,7 +72,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) if ( op->interface_version != XENPF_INTERFACE_VERSION ) return -EACCES; - ret = xsm_platform_op(op->cmd); + ret = xsm_priv_platform_op(op->cmd); if ( ret ) return ret; @@ -496,7 +496,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -512,7 +512,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; } - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -525,7 +525,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_unplug_core(); + ret = xsm_hook_resource_unplug_core(); if ( ret ) break; @@ -554,7 +554,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_cpu_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; @@ -564,7 +564,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_mem_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; diff --git a/xen/arch/x86/sysctl.c b/xen/arch/x86/sysctl.c index 5b0c4b7..3a10a13 100644 --- a/xen/arch/x86/sysctl.c +++ b/xen/arch/x86/sysctl.c @@ -184,14 +184,14 @@ long arch_do_sysctl( switch ( sysctl->u.cpu_hotplug.op ) { case XEN_SYSCTL_CPU_HOTPLUG_ONLINE: - ret = xsm_resource_plug_core(); + ret = xsm_hook_resource_plug_core(); if ( ret ) break; ret = continue_hypercall_on_cpu( 0, cpu_up_helper, (void *)(unsigned long)cpu); break; case XEN_SYSCTL_CPU_HOTPLUG_OFFLINE: - ret = xsm_resource_unplug_core(); + ret = xsm_hook_resource_unplug_core(); if ( ret ) break; ret = continue_hypercall_on_cpu( diff --git a/xen/arch/x86/traps.c b/xen/arch/x86/traps.c index 44a866e..695e991 100644 --- a/xen/arch/x86/traps.c +++ b/xen/arch/x86/traps.c @@ -1643,7 +1643,7 @@ static int pci_cfg_ok(struct domain *d, int write, int size) start |= (d->arch.pci_cf8 >> 16) & 0xF00; } end = start + size - 1; - if (xsm_pci_config_permission(d, machine_bdf, start, end, write)) + if (xsm_hook_pci_config_permission(d, machine_bdf, start, end, write)) return 0; return 1; } diff --git a/xen/common/domain.c b/xen/common/domain.c index fcf24e2..296d735 100644 --- a/xen/common/domain.c +++ b/xen/common/domain.c @@ -252,7 +252,7 @@ struct domain *domain_create( if ( !is_idle_domain(d) ) { - if ( (err = xsm_domain_create(d, ssidref)) != 0 ) + if ( (err = xsm_hook_domain_create(d, ssidref)) != 0 ) goto fail; d->is_paused_by_controller = 1; diff --git a/xen/common/domctl.c b/xen/common/domctl.c index 6f792e9..1f88ad2 100644 --- a/xen/common/domctl.c +++ b/xen/common/domctl.c @@ -150,7 +150,7 @@ void getdomaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) if ( is_hvm_domain(d) ) info->flags |= XEN_DOMINF_hvm_guest; - xsm_security_domaininfo(d, info); + xsm_populate_security_domaininfo(d, info); info->tot_pages = d->tot_pages; info->max_pages = d->max_pages; @@ -580,7 +580,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_getdomaininfo(d); + ret = xsm_hook_getdomaininfo(d); if ( ret ) goto getdomaininfo_out; @@ -722,7 +722,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( pirq >= d->nr_pirqs ) ret = -EINVAL; - else if ( xsm_irq_permission(d, pirq, allow) ) + else if ( xsm_hook_irq_permission(d, pirq, allow) ) ret = -EPERM; else if ( allow ) ret = irq_permit_access(d, pirq); @@ -741,7 +741,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( (mfn + nr_mfns - 1) < mfn ) /* wrap? */ break; - if ( xsm_iomem_permission(d, mfn, mfn + nr_mfns - 1, allow) ) + if ( xsm_hook_iomem_permission(d, mfn, mfn + nr_mfns - 1, allow) ) ret = -EPERM; else if ( allow ) ret = iomem_permit_access(d, mfn, mfn + nr_mfns - 1); @@ -773,7 +773,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_set_target(d, e); + ret = xsm_hook_set_target(d, e); if ( ret ) { put_domain(e); break; diff --git a/xen/common/event_channel.c b/xen/common/event_channel.c index 37947a9..ef0d89b 100644 --- a/xen/common/event_channel.c +++ b/xen/common/event_channel.c @@ -175,7 +175,7 @@ static long evtchn_alloc_unbound(evtchn_alloc_unbound_t *alloc) ERROR_EXIT_DOM(port, d); chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, alloc->remote_dom); + rc = xsm_target_evtchn_unbound(d, chn, alloc->remote_dom); if ( rc ) goto out; @@ -231,7 +231,7 @@ static long evtchn_bind_interdomain(evtchn_bind_interdomain_t *bind) (rchn->u.unbound.remote_domid != ld->domain_id) ) ERROR_EXIT_DOM(-EINVAL, rd); - rc = xsm_evtchn_interdomain(ld, lchn, rd, rchn); + rc = xsm_hook_evtchn_interdomain(ld, lchn, rd, rchn); if ( rc ) goto out; @@ -535,7 +535,7 @@ static long __evtchn_close(struct domain *d1, int port1) chn1->state = ECS_FREE; chn1->notify_vcpu_id = 0; - xsm_evtchn_close_post(chn1); + xsm_hook_evtchn_close_post(chn1); out: if ( d2 != NULL ) @@ -580,7 +580,7 @@ int evtchn_send(struct domain *d, unsigned int lport) return -EINVAL; } - ret = xsm_evtchn_send(ld, lchn); + ret = xsm_hook_evtchn_send(ld, lchn); if ( ret ) goto out; @@ -812,7 +812,7 @@ static long evtchn_status(evtchn_status_t *status) chn = evtchn_from_port(d, port); - rc = xsm_evtchn_status(d, chn); + rc = xsm_target_evtchn_status(d, chn); if ( rc ) goto out; @@ -954,7 +954,7 @@ static long evtchn_reset(evtchn_reset_t *r) if ( d == NULL ) return -ESRCH; - rc = xsm_evtchn_reset(current->domain, d); + rc = xsm_target_evtchn_reset(current->domain, d); if ( rc ) goto out; @@ -1101,7 +1101,7 @@ int alloc_unbound_xen_event_channel( goto out; chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, remote_domid); + rc = xsm_target_evtchn_unbound(d, chn, remote_domid); chn->state = ECS_UNBOUND; chn->xen_consumer = get_xen_consumer(notification_fn); diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c index eae9518..e3690b6 100644 --- a/xen/common/grant_table.c +++ b/xen/common/grant_table.c @@ -552,7 +552,7 @@ __gnttab_map_grant_ref( return; } - rc = xsm_grant_mapref(ld, rd, op->flags); + rc = xsm_hook_grant_mapref(ld, rd, op->flags); if ( rc ) { rcu_unlock_domain(rd); @@ -872,7 +872,7 @@ __gnttab_unmap_common( return; } - rc = xsm_grant_unmapref(ld, rd); + rc = xsm_hook_grant_unmapref(ld, rd); if ( rc ) { rcu_unlock_domain(rd); @@ -1326,7 +1326,7 @@ gnttab_setup_table( goto out2; } - if ( xsm_grant_setup(current->domain, d) ) + if ( xsm_target_grant_setup(current->domain, d) ) { op.status = GNTST_permission_denied; goto out2; @@ -1395,7 +1395,7 @@ gnttab_query_size( goto query_out; } - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_target_grant_query_size(current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; @@ -1571,7 +1571,7 @@ gnttab_transfer( goto copyback; } - if ( xsm_grant_transfer(d, e) ) + if ( xsm_hook_grant_transfer(d, e) ) { put_gfn(d, gop.mfn); gop.status = GNTST_permission_denied; @@ -2010,7 +2010,7 @@ __gnttab_copy( PIN_FAIL(error_out, GNTST_bad_domain, "couldn't find %d\n", op->dest.domid); - rc = xsm_grant_copy(sd, dd); + rc = xsm_hook_grant_copy(sd, dd); if ( rc ) { rc = GNTST_permission_denied; @@ -2267,7 +2267,7 @@ gnttab_get_status_frames(XEN_GUEST_HANDLE_PARAM(gnttab_get_status_frames_t) uop, op.status = GNTST_bad_domain; goto out1; } - rc = xsm_grant_setup(current->domain, d); + rc = xsm_target_grant_setup(current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; goto out1; @@ -2318,7 +2318,7 @@ gnttab_get_version(XEN_GUEST_HANDLE_PARAM(gnttab_get_version_t uop)) if ( d == NULL ) return -ESRCH; - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_target_grant_query_size(current->domain, d); if ( rc ) { rcu_unlock_domain(d); diff --git a/xen/common/kexec.c b/xen/common/kexec.c index d4f6332..ff9d205 100644 --- a/xen/common/kexec.c +++ b/xen/common/kexec.c @@ -852,7 +852,7 @@ static int do_kexec_op_internal(unsigned long op, unsigned long flags; int ret = -EINVAL; - ret = xsm_kexec(); + ret = xsm_priv_kexec(); if ( ret ) return ret; diff --git a/xen/common/memory.c b/xen/common/memory.c index 7d3c326..0e216bb 100644 --- a/xen/common/memory.c +++ b/xen/common/memory.c @@ -336,7 +336,7 @@ static long memory_exchange(XEN_GUEST_HANDLE_PARAM(xen_memory_exchange_t) arg) goto fail_early; } - rc = xsm_memory_exchange(d); + rc = xsm_target_memory_exchange(d); if ( rc ) { rcu_unlock_domain(d); @@ -585,7 +585,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) return start_extent; args.domain = d; - rc = xsm_memory_adjust_reservation(current->domain, d); + rc = xsm_target_memory_adjust_reservation(current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -634,7 +634,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_memory_stat_reservation(current->domain, d); + rc = xsm_target_memory_stat_reservation(current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -672,7 +672,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_remove_from_physmap(current->domain, d) ) + if ( xsm_target_remove_from_physmap(current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; diff --git a/xen/common/schedule.c b/xen/common/schedule.c index cfd173d..2cad778 100644 --- a/xen/common/schedule.c +++ b/xen/common/schedule.c @@ -921,7 +921,7 @@ ret_t do_sched_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) break; - ret = xsm_schedop_shutdown(current->domain, d); + ret = xsm_dm_schedop_shutdown(current->domain, d); if ( ret ) { rcu_unlock_domain(d); diff --git a/xen/common/sysctl.c b/xen/common/sysctl.c index cbefb0e..d6e3f6c 100644 --- a/xen/common/sysctl.c +++ b/xen/common/sysctl.c @@ -57,7 +57,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) { case XEN_SYSCTL_readconsole: { - ret = xsm_readconsole(op->u.readconsole.clear); + ret = xsm_hook_readconsole(op->u.readconsole.clear); if ( ret ) break; @@ -100,7 +100,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) if ( num_domains == op->u.getdomaininfolist.max_domains ) break; - ret = xsm_getdomaininfo(d); + ret = xsm_hook_getdomaininfo(d); if ( ret ) continue; @@ -231,7 +231,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) uint32_t *status, *ptr; unsigned long pfn; - ret = xsm_page_offline(op->u.page_offline.cmd); + ret = xsm_hook_page_offline(op->u.page_offline.cmd); if ( ret ) break; diff --git a/xen/common/xenoprof.c b/xen/common/xenoprof.c index ae0435b..7a82e3a 100644 --- a/xen/common/xenoprof.c +++ b/xen/common/xenoprof.c @@ -680,7 +680,7 @@ ret_t do_xenoprof_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -EPERM; } - ret = xsm_profile(current->domain, op); + ret = xsm_hook_profile(current->domain, op); if ( ret ) return ret; diff --git a/xen/drivers/char/console.c b/xen/drivers/char/console.c index b2c3ee3..b6faa43 100644 --- a/xen/drivers/char/console.c +++ b/xen/drivers/char/console.c @@ -406,7 +406,7 @@ long do_console_io(int cmd, int count, XEN_GUEST_HANDLE_PARAM(char) buffer) long rc; unsigned int idx, len; - rc = xsm_console_io(current->domain, cmd); + rc = xsm_priv_console_io(current->domain, cmd); if ( rc ) return rc; diff --git a/xen/drivers/passthrough/iommu.c b/xen/drivers/passthrough/iommu.c index 9d13185..52eff81 100644 --- a/xen/drivers/passthrough/iommu.c +++ b/xen/drivers/passthrough/iommu.c @@ -452,7 +452,7 @@ static int iommu_get_device_group( ((pdev->bus == bus) && (pdev->devfn == devfn)) ) continue; - if ( xsm_get_device_group((seg << 16) | (pdev->bus << 8) | pdev->devfn) ) + if ( xsm_hook_get_device_group((seg << 16) | (pdev->bus << 8) | pdev->devfn) ) continue; sdev_id = ops->get_device_group_id(seg, pdev->bus, pdev->devfn); @@ -555,7 +555,7 @@ int iommu_do_domctl( u32 max_sdevs; XEN_GUEST_HANDLE_64(uint32) sdevs; - ret = xsm_get_device_group(domctl->u.get_device_group.machine_sbdf); + ret = xsm_hook_get_device_group(domctl->u.get_device_group.machine_sbdf); if ( ret ) break; @@ -583,7 +583,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_test_assign_device: - ret = xsm_test_assign_device(domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_test_assign_device(domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -607,7 +607,7 @@ int iommu_do_domctl( break; } - ret = xsm_assign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_assign_device(d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -626,7 +626,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_deassign_device: - ret = xsm_deassign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_hook_deassign_device(d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; diff --git a/xen/drivers/passthrough/pci.c b/xen/drivers/passthrough/pci.c index d5ef4c1..43eceab 100644 --- a/xen/drivers/passthrough/pci.c +++ b/xen/drivers/passthrough/pci.c @@ -380,7 +380,7 @@ int pci_add_device(u16 seg, u8 bus, u8 devfn, const struct pci_dev_info *info) pdev_type = "device"; } - ret = xsm_resource_plug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_priv_resource_plug_pci((seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; @@ -496,7 +496,7 @@ int pci_remove_device(u16 seg, u8 bus, u8 devfn) struct pci_dev *pdev; int ret; - ret = xsm_resource_unplug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_priv_resource_unplug_pci((seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; diff --git a/xen/include/xen/tmem_xen.h b/xen/include/xen/tmem_xen.h index 8dec5aa..81d88f3 100644 --- a/xen/include/xen/tmem_xen.h +++ b/xen/include/xen/tmem_xen.h @@ -329,12 +329,12 @@ static inline bool_t tmh_set_client_from_id( static inline bool_t tmh_current_permitted(void) { - return !xsm_tmem_op(); + return !xsm_hook_tmem_op(); } static inline bool_t tmh_current_is_privileged(void) { - return !xsm_tmem_control(); + return !xsm_priv_tmem_control(); } static inline uint8_t tmh_get_first_byte(pfp_t *pfp) diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h index aaac50d3..09ee3f2 100644 --- a/xen/include/xsm/dummy.h +++ b/xen/include/xsm/dummy.h @@ -11,23 +11,23 @@ #include #include -static XSM_INLINE void xsm_security_domaininfo(struct domain *d, +static XSM_INLINE void xsm_populate_security_domaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) { return; } -static XSM_INLINE int xsm_domain_create(struct domain *d, u32 ssidref) +static XSM_INLINE int xsm_hook_domain_create(struct domain *d, u32 ssidref) { return 0; } -static XSM_INLINE int xsm_getdomaininfo(struct domain *d) +static XSM_INLINE int xsm_hook_getdomaininfo(struct domain *d) { return 0; } -static XSM_INLINE int xsm_set_target(struct domain *d, struct domain *e) +static XSM_INLINE int xsm_hook_set_target(struct domain *d, struct domain *e) { return 0; } @@ -58,12 +58,12 @@ static XSM_INLINE int xsm_sysctl(int cmd) return 0; } -static XSM_INLINE int xsm_readconsole(uint32_t clear) +static XSM_INLINE int xsm_hook_readconsole(uint32_t clear) { return 0; } -static XSM_INLINE int xsm_do_mca(void) +static XSM_INLINE int xsm_priv_do_mca(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; @@ -80,49 +80,49 @@ static XSM_INLINE void xsm_free_security_domain(struct domain *d) return; } -static XSM_INLINE int xsm_grant_mapref(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_hook_grant_mapref(struct domain *d1, struct domain *d2, uint32_t flags) { return 0; } -static XSM_INLINE int xsm_grant_unmapref(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_unmapref(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_setup(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_grant_setup(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_grant_transfer(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_transfer(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_copy(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_hook_grant_copy(struct domain *d1, struct domain *d2) { return 0; } -static XSM_INLINE int xsm_grant_query_size(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_grant_query_size(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_exchange(struct domain *d) +static XSM_INLINE int xsm_target_memory_exchange(struct domain *d) { if ( d != current->domain && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1, +static XSM_INLINE int xsm_target_memory_adjust_reservation(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) @@ -130,14 +130,14 @@ static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1, return 0; } -static XSM_INLINE int xsm_memory_stat_reservation(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_memory_stat_reservation(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_console_io(struct domain *d, int cmd) +static XSM_INLINE int xsm_priv_console_io(struct domain *d, int cmd) { #ifndef VERBOSE if ( !IS_PRIV(current->domain) ) @@ -146,32 +146,32 @@ static XSM_INLINE int xsm_console_io(struct domain *d, int cmd) return 0; } -static XSM_INLINE int xsm_profile(struct domain *d, int op) +static XSM_INLINE int xsm_hook_profile(struct domain *d, int op) { return 0; } -static XSM_INLINE int xsm_kexec(void) +static XSM_INLINE int xsm_priv_kexec(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_schedop_shutdown(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_dm_schedop_shutdown(struct domain *d1, struct domain *d2) { if ( !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { return 0; } -static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn, +static XSM_INLINE int xsm_target_evtchn_unbound(struct domain *d, struct evtchn *chn, domid_t id2) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) @@ -179,30 +179,30 @@ static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn, return 0; } -static XSM_INLINE int xsm_evtchn_interdomain(struct domain *d1, struct evtchn +static XSM_INLINE int xsm_hook_evtchn_interdomain(struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { return 0; } -static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn) +static XSM_INLINE void xsm_hook_evtchn_close_post(struct evtchn *chn) { return; } -static XSM_INLINE int xsm_evtchn_send(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_hook_evtchn_send(struct domain *d, struct evtchn *chn) { return 0; } -static XSM_INLINE int xsm_evtchn_status(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_target_evtchn_status(struct domain *d, struct evtchn *chn) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_evtchn_reset(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_evtchn_reset(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; @@ -224,96 +224,96 @@ static XSM_INLINE char * xsm_show_security_evtchn(struct domain *d, const struct return NULL; } -static XSM_INLINE int xsm_get_pod_target(struct domain *d) +static XSM_INLINE int xsm_priv_get_pod_target(struct domain *d) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_set_pod_target(struct domain *d) +static XSM_INLINE int xsm_priv_set_pod_target(struct domain *d) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_get_device_group(uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_get_device_group(uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_test_assign_device(uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_test_assign_device(uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_assign_device(struct domain *d, uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { return 0; } -static XSM_INLINE int xsm_resource_plug_core(void) +static XSM_INLINE int xsm_hook_resource_plug_core(void) { return 0; } -static XSM_INLINE int xsm_resource_unplug_core(void) +static XSM_INLINE int xsm_hook_resource_unplug_core(void) { return 0; } -static XSM_INLINE int xsm_resource_plug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_plug_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_unplug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_unplug_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_priv_resource_setup_pci(uint32_t machine_bdf) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_gsi(int gsi) +static XSM_INLINE int xsm_priv_resource_setup_gsi(int gsi) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_resource_setup_misc(void) +static XSM_INLINE int xsm_priv_resource_setup_misc(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_page_offline(uint32_t cmd) +static XSM_INLINE int xsm_hook_page_offline(uint32_t cmd) { return 0; } -static XSM_INLINE int xsm_tmem_op(void) +static XSM_INLINE int xsm_hook_tmem_op(void) { return 0; } -static XSM_INLINE int xsm_tmem_control(void) +static XSM_INLINE int xsm_priv_tmem_control(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; @@ -330,34 +330,34 @@ static XSM_INLINE char * xsm_show_irq_sid(int irq) return NULL; } -static XSM_INLINE int xsm_map_domain_pirq(struct domain *d, int irq, void *data) +static XSM_INLINE int xsm_hook_map_domain_pirq(struct domain *d, int irq, void *data) { return 0; } -static XSM_INLINE int xsm_unmap_domain_pirq(struct domain *d, int irq) +static XSM_INLINE int xsm_dm_unmap_domain_pirq(struct domain *d, int irq) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_irq_permission(struct domain *d, int pirq, uint8_t allow) +static XSM_INLINE int xsm_hook_irq_permission(struct domain *d, int pirq, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_iomem_permission(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_iomem_permission(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_iomem_mapping(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_iomem_mapping(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t machine_bdf, +static XSM_INLINE int xsm_hook_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { @@ -365,96 +365,96 @@ static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t machi } #ifdef CONFIG_X86 -static XSM_INLINE int xsm_shadow_control(struct domain *d, uint32_t op) +static XSM_INLINE int xsm_hook_shadow_control(struct domain *d, uint32_t op) { return 0; } -static XSM_INLINE int xsm_hvm_param(struct domain *d, unsigned long op) +static XSM_INLINE int xsm_target_hvm_param(struct domain *d, unsigned long op) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_pci_intx_level(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_pci_intx_level(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_isa_irq_level(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_isa_irq_level(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_set_pci_link_route(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_set_pci_link_route(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_hvm_inject_msi(struct domain *d) +static XSM_INLINE int xsm_dm_hvm_inject_msi(struct domain *d) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_event_control(struct domain *d, int mode, int op) +static XSM_INLINE int xsm_dm_mem_event_control(struct domain *d, int mode, int op) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_event_op(struct domain *d, int op) +static XSM_INLINE int xsm_dm_mem_event_op(struct domain *d, int op) { if ( !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mem_sharing_op(struct domain *d, struct domain *cd, int op) +static XSM_INLINE int xsm_dm_mem_sharing_op(struct domain *d, struct domain *cd, int op) { if ( !IS_PRIV_FOR(current->domain, cd) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_apic(struct domain *d, int cmd) +static XSM_INLINE int xsm_priv_apic(struct domain *d, int cmd) { if ( !IS_PRIV(d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_platform_op(uint32_t op) +static XSM_INLINE int xsm_priv_platform_op(uint32_t op) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_machine_memory_map(void) +static XSM_INLINE int xsm_priv_machine_memory_map(void) { if ( !IS_PRIV(current->domain) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_domain_memory_map(struct domain *d) +static XSM_INLINE int xsm_target_domain_memory_map(struct domain *d) { if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t, +static XSM_INLINE int xsm_target_mmu_update(struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { if ( t && d != t && !IS_PRIV_FOR(d, t) ) @@ -464,14 +464,14 @@ static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t, return 0; } -static XSM_INLINE int xsm_mmuext_op(struct domain *d, struct domain *f) +static XSM_INLINE int xsm_target_mmuext_op(struct domain *d, struct domain *f) { if ( d != f && !IS_PRIV_FOR(d, f) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain *f, +static XSM_INLINE int xsm_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { if ( d != f && !IS_PRIV_FOR(d, f) ) @@ -479,36 +479,36 @@ static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain *f, return 0; } -static XSM_INLINE int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_add_to_physmap(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_target_remove_from_physmap(struct domain *d1, struct domain *d2) { if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) return -EPERM; return 0; } -static XSM_INLINE int xsm_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_hook_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return 0; } -static XSM_INLINE int xsm_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_hook_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return 0; } -static XSM_INLINE int xsm_ioport_permission(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_ioport_permission(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return 0; } -static XSM_INLINE int xsm_ioport_mapping(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_hook_ioport_mapping(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return 0; } diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h index 105201e..c3a29b6 100644 --- a/xen/include/xsm/xsm.h +++ b/xen/include/xsm/xsm.h @@ -39,30 +39,30 @@ extern xsm_initcall_t __xsm_initcall_start[], __xsm_initcall_end[]; __used_section(".xsm_initcall.init") = fn struct xsm_operations { - void (*security_domaininfo) (struct domain *d, + void (*populate_security_domaininfo) (struct domain *d, struct xen_domctl_getdomaininfo *info); - int (*domain_create) (struct domain *d, u32 ssidref); - int (*getdomaininfo) (struct domain *d); - int (*set_target) (struct domain *d, struct domain *e); + int (*hook_domain_create) (struct domain *d, u32 ssidref); + int (*hook_getdomaininfo) (struct domain *d); + int (*hook_set_target) (struct domain *d, struct domain *e); int (*domctl) (struct domain *d, int cmd); int (*sysctl) (int cmd); - int (*readconsole) (uint32_t clear); - int (*do_mca) (void); + int (*hook_readconsole) (uint32_t clear); + int (*priv_do_mca) (void); - int (*evtchn_unbound) (struct domain *d, struct evtchn *chn, domid_t id2); - int (*evtchn_interdomain) (struct domain *d1, struct evtchn *chn1, + int (*target_evtchn_unbound) (struct domain *d, struct evtchn *chn, domid_t id2); + int (*hook_evtchn_interdomain) (struct domain *d1, struct evtchn *chn1, struct domain *d2, struct evtchn *chn2); - void (*evtchn_close_post) (struct evtchn *chn); - int (*evtchn_send) (struct domain *d, struct evtchn *chn); - int (*evtchn_status) (struct domain *d, struct evtchn *chn); - int (*evtchn_reset) (struct domain *d1, struct domain *d2); - - int (*grant_mapref) (struct domain *d1, struct domain *d2, uint32_t flags); - int (*grant_unmapref) (struct domain *d1, struct domain *d2); - int (*grant_setup) (struct domain *d1, struct domain *d2); - int (*grant_transfer) (struct domain *d1, struct domain *d2); - int (*grant_copy) (struct domain *d1, struct domain *d2); - int (*grant_query_size) (struct domain *d1, struct domain *d2); + void (*hook_evtchn_close_post) (struct evtchn *chn); + int (*hook_evtchn_send) (struct domain *d, struct evtchn *chn); + int (*target_evtchn_status) (struct domain *d, struct evtchn *chn); + int (*target_evtchn_reset) (struct domain *d1, struct domain *d2); + + int (*hook_grant_mapref) (struct domain *d1, struct domain *d2, uint32_t flags); + int (*hook_grant_unmapref) (struct domain *d1, struct domain *d2); + int (*target_grant_setup) (struct domain *d1, struct domain *d2); + int (*hook_grant_transfer) (struct domain *d1, struct domain *d2); + int (*hook_grant_copy) (struct domain *d1, struct domain *d2); + int (*target_grant_query_size) (struct domain *d1, struct domain *d2); int (*alloc_security_domain) (struct domain *d); void (*free_security_domain) (struct domain *d); @@ -70,76 +70,76 @@ struct xsm_operations { void (*free_security_evtchn) (struct evtchn *chn); char *(*show_security_evtchn) (struct domain *d, const struct evtchn *chn); - int (*get_pod_target) (struct domain *d); - int (*set_pod_target) (struct domain *d); - int (*memory_exchange) (struct domain *d); - int (*memory_adjust_reservation) (struct domain *d1, struct domain *d2); - int (*memory_stat_reservation) (struct domain *d1, struct domain *d2); - int (*memory_pin_page) (struct domain *d1, struct domain *d2, struct page_info *page); - int (*remove_from_physmap) (struct domain *d1, struct domain *d2); + int (*priv_get_pod_target) (struct domain *d); + int (*priv_set_pod_target) (struct domain *d); + int (*target_memory_exchange) (struct domain *d); + int (*target_memory_adjust_reservation) (struct domain *d1, struct domain *d2); + int (*target_memory_stat_reservation) (struct domain *d1, struct domain *d2); + int (*hook_memory_pin_page) (struct domain *d1, struct domain *d2, struct page_info *page); + int (*target_remove_from_physmap) (struct domain *d1, struct domain *d2); - int (*console_io) (struct domain *d, int cmd); + int (*priv_console_io) (struct domain *d, int cmd); - int (*profile) (struct domain *d, int op); + int (*hook_profile) (struct domain *d, int op); - int (*kexec) (void); - int (*schedop_shutdown) (struct domain *d1, struct domain *d2); + int (*priv_kexec) (void); + int (*dm_schedop_shutdown) (struct domain *d1, struct domain *d2); char *(*show_irq_sid) (int irq); - int (*map_domain_pirq) (struct domain *d, int irq, void *data); - int (*unmap_domain_pirq) (struct domain *d, int irq); - int (*irq_permission) (struct domain *d, int pirq, uint8_t allow); - int (*iomem_permission) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); - int (*iomem_mapping) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); - int (*pci_config_permission) (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access); - - int (*get_device_group) (uint32_t machine_bdf); - int (*test_assign_device) (uint32_t machine_bdf); - int (*assign_device) (struct domain *d, uint32_t machine_bdf); - int (*deassign_device) (struct domain *d, uint32_t machine_bdf); - - int (*resource_plug_core) (void); - int (*resource_unplug_core) (void); - int (*resource_plug_pci) (uint32_t machine_bdf); - int (*resource_unplug_pci) (uint32_t machine_bdf); - int (*resource_setup_pci) (uint32_t machine_bdf); - int (*resource_setup_gsi) (int gsi); - int (*resource_setup_misc) (void); - - int (*page_offline)(uint32_t cmd); - int (*tmem_op)(void); - int (*tmem_control)(void); + int (*hook_map_domain_pirq) (struct domain *d, int irq, void *data); + int (*dm_unmap_domain_pirq) (struct domain *d, int irq); + int (*hook_irq_permission) (struct domain *d, int pirq, uint8_t allow); + int (*hook_iomem_permission) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); + int (*hook_iomem_mapping) (struct domain *d, uint64_t s, uint64_t e, uint8_t allow); + int (*hook_pci_config_permission) (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access); + + int (*hook_get_device_group) (uint32_t machine_bdf); + int (*hook_test_assign_device) (uint32_t machine_bdf); + int (*hook_assign_device) (struct domain *d, uint32_t machine_bdf); + int (*hook_deassign_device) (struct domain *d, uint32_t machine_bdf); + + int (*hook_resource_plug_core) (void); + int (*hook_resource_unplug_core) (void); + int (*priv_resource_plug_pci) (uint32_t machine_bdf); + int (*priv_resource_unplug_pci) (uint32_t machine_bdf); + int (*priv_resource_setup_pci) (uint32_t machine_bdf); + int (*priv_resource_setup_gsi) (int gsi); + int (*priv_resource_setup_misc) (void); + + int (*hook_page_offline)(uint32_t cmd); + int (*hook_tmem_op)(void); + int (*priv_tmem_control)(void); long (*do_xsm_op) (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op); #ifdef CONFIG_X86 - int (*shadow_control) (struct domain *d, uint32_t op); - int (*hvm_param) (struct domain *d, unsigned long op); - int (*hvm_set_pci_intx_level) (struct domain *d); - int (*hvm_set_isa_irq_level) (struct domain *d); - int (*hvm_set_pci_link_route) (struct domain *d); - int (*hvm_inject_msi) (struct domain *d); - int (*mem_event_control) (struct domain *d, int mode, int op); - int (*mem_event_op) (struct domain *d, int op); - int (*mem_sharing_op) (struct domain *d, struct domain *cd, int op); - int (*apic) (struct domain *d, int cmd); + int (*hook_shadow_control) (struct domain *d, uint32_t op); + int (*target_hvm_param) (struct domain *d, unsigned long op); + int (*dm_hvm_set_pci_intx_level) (struct domain *d); + int (*dm_hvm_set_isa_irq_level) (struct domain *d); + int (*dm_hvm_set_pci_link_route) (struct domain *d); + int (*dm_hvm_inject_msi) (struct domain *d); + int (*dm_mem_event_control) (struct domain *d, int mode, int op); + int (*dm_mem_event_op) (struct domain *d, int op); + int (*dm_mem_sharing_op) (struct domain *d, struct domain *cd, int op); + int (*priv_apic) (struct domain *d, int cmd); int (*memtype) (uint32_t access); - int (*platform_op) (uint32_t cmd); - int (*machine_memory_map) (void); - int (*domain_memory_map) (struct domain *d); + int (*priv_platform_op) (uint32_t cmd); + int (*priv_machine_memory_map) (void); + int (*target_domain_memory_map) (struct domain *d); #define XSM_MMU_UPDATE_READ 1 #define XSM_MMU_UPDATE_WRITE 2 #define XSM_MMU_NORMAL_UPDATE 4 #define XSM_MMU_MACHPHYS_UPDATE 8 - int (*mmu_update) (struct domain *d, struct domain *t, + int (*target_mmu_update) (struct domain *d, struct domain *t, struct domain *f, uint32_t flags); - int (*mmuext_op) (struct domain *d, struct domain *f); - int (*update_va_mapping) (struct domain *d, struct domain *f, l1_pgentry_t pte); - int (*add_to_physmap) (struct domain *d1, struct domain *d2); - int (*bind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); - int (*unbind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); - int (*ioport_permission) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); - int (*ioport_mapping) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); + int (*target_mmuext_op) (struct domain *d, struct domain *f); + int (*target_update_va_mapping) (struct domain *d, struct domain *f, l1_pgentry_t pte); + int (*target_add_to_physmap) (struct domain *d1, struct domain *d2); + int (*hook_bind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); + int (*hook_unbind_pt_irq) (struct domain *d, struct xen_domctl_bind_pt_irq *bind); + int (*hook_ioport_permission) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); + int (*hook_ioport_mapping) (struct domain *d, uint32_t s, uint32_t e, uint8_t allow); #endif }; @@ -149,25 +149,25 @@ extern struct xsm_operations *xsm_ops; #ifndef XSM_NO_WRAPPERS -static inline void xsm_security_domaininfo (struct domain *d, +static inline void xsm_populate_security_domaininfo (struct domain *d, struct xen_domctl_getdomaininfo *info) { - xsm_ops->security_domaininfo(d, info); + xsm_ops->populate_security_domaininfo(d, info); } -static inline int xsm_domain_create (struct domain *d, u32 ssidref) +static inline int xsm_hook_domain_create (struct domain *d, u32 ssidref) { - return xsm_ops->domain_create(d, ssidref); + return xsm_ops->hook_domain_create(d, ssidref); } -static inline int xsm_getdomaininfo (struct domain *d) +static inline int xsm_hook_getdomaininfo (struct domain *d) { - return xsm_ops->getdomaininfo(d); + return xsm_ops->hook_getdomaininfo(d); } -static inline int xsm_set_target (struct domain *d, struct domain *e) +static inline int xsm_hook_set_target (struct domain *d, struct domain *e) { - return xsm_ops->set_target(d, e); + return xsm_ops->hook_set_target(d, e); } static inline int xsm_domctl (struct domain *d, int cmd) @@ -180,77 +180,77 @@ static inline int xsm_sysctl (int cmd) return xsm_ops->sysctl(cmd); } -static inline int xsm_readconsole (uint32_t clear) +static inline int xsm_hook_readconsole (uint32_t clear) { - return xsm_ops->readconsole(clear); + return xsm_ops->hook_readconsole(clear); } -static inline int xsm_do_mca(void) +static inline int xsm_priv_do_mca(void) { - return xsm_ops->do_mca(); + return xsm_ops->priv_do_mca(); } -static inline int xsm_evtchn_unbound (struct domain *d1, struct evtchn *chn, +static inline int xsm_target_evtchn_unbound (struct domain *d1, struct evtchn *chn, domid_t id2) { - return xsm_ops->evtchn_unbound(d1, chn, id2); + return xsm_ops->target_evtchn_unbound(d1, chn, id2); } -static inline int xsm_evtchn_interdomain (struct domain *d1, +static inline int xsm_hook_evtchn_interdomain (struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { - return xsm_ops->evtchn_interdomain(d1, chan1, d2, chan2); + return xsm_ops->hook_evtchn_interdomain(d1, chan1, d2, chan2); } -static inline void xsm_evtchn_close_post (struct evtchn *chn) +static inline void xsm_hook_evtchn_close_post (struct evtchn *chn) { - xsm_ops->evtchn_close_post(chn); + xsm_ops->hook_evtchn_close_post(chn); } -static inline int xsm_evtchn_send (struct domain *d, struct evtchn *chn) +static inline int xsm_hook_evtchn_send (struct domain *d, struct evtchn *chn) { - return xsm_ops->evtchn_send(d, chn); + return xsm_ops->hook_evtchn_send(d, chn); } -static inline int xsm_evtchn_status (struct domain *d, struct evtchn *chn) +static inline int xsm_target_evtchn_status (struct domain *d, struct evtchn *chn) { - return xsm_ops->evtchn_status(d, chn); + return xsm_ops->target_evtchn_status(d, chn); } -static inline int xsm_evtchn_reset (struct domain *d1, struct domain *d2) +static inline int xsm_target_evtchn_reset (struct domain *d1, struct domain *d2) { - return xsm_ops->evtchn_reset(d1, d2); + return xsm_ops->target_evtchn_reset(d1, d2); } -static inline int xsm_grant_mapref (struct domain *d1, struct domain *d2, +static inline int xsm_hook_grant_mapref (struct domain *d1, struct domain *d2, uint32_t flags) { - return xsm_ops->grant_mapref(d1, d2, flags); + return xsm_ops->hook_grant_mapref(d1, d2, flags); } -static inline int xsm_grant_unmapref (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_unmapref (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_unmapref(d1, d2); + return xsm_ops->hook_grant_unmapref(d1, d2); } -static inline int xsm_grant_setup (struct domain *d1, struct domain *d2) +static inline int xsm_target_grant_setup (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_setup(d1, d2); + return xsm_ops->target_grant_setup(d1, d2); } -static inline int xsm_grant_transfer (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_transfer (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_transfer(d1, d2); + return xsm_ops->hook_grant_transfer(d1, d2); } -static inline int xsm_grant_copy (struct domain *d1, struct domain *d2) +static inline int xsm_hook_grant_copy (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_copy(d1, d2); + return xsm_ops->hook_grant_copy(d1, d2); } -static inline int xsm_grant_query_size (struct domain *d1, struct domain *d2) +static inline int xsm_target_grant_query_size (struct domain *d1, struct domain *d2) { - return xsm_ops->grant_query_size(d1, d2); + return xsm_ops->target_grant_query_size(d1, d2); } static inline int xsm_alloc_security_domain (struct domain *d) @@ -278,62 +278,62 @@ static inline char *xsm_show_security_evtchn (struct domain *d, const struct evt return xsm_ops->show_security_evtchn(d, chn); } -static inline int xsm_get_pod_target (struct domain *d) +static inline int xsm_priv_get_pod_target (struct domain *d) { - return xsm_ops->get_pod_target(d); + return xsm_ops->priv_get_pod_target(d); } -static inline int xsm_set_pod_target (struct domain *d) +static inline int xsm_priv_set_pod_target (struct domain *d) { - return xsm_ops->set_pod_target(d); + return xsm_ops->priv_set_pod_target(d); } -static inline int xsm_memory_exchange (struct domain *d) +static inline int xsm_target_memory_exchange (struct domain *d) { - return xsm_ops->memory_exchange(d); + return xsm_ops->target_memory_exchange(d); } -static inline int xsm_memory_adjust_reservation (struct domain *d1, struct +static inline int xsm_target_memory_adjust_reservation (struct domain *d1, struct domain *d2) { - return xsm_ops->memory_adjust_reservation(d1, d2); + return xsm_ops->target_memory_adjust_reservation(d1, d2); } -static inline int xsm_memory_stat_reservation (struct domain *d1, +static inline int xsm_target_memory_stat_reservation (struct domain *d1, struct domain *d2) { - return xsm_ops->memory_stat_reservation(d1, d2); + return xsm_ops->target_memory_stat_reservation(d1, d2); } -static inline int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static inline int xsm_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { - return xsm_ops->memory_pin_page(d1, d2, page); + return xsm_ops->hook_memory_pin_page(d1, d2, page); } -static inline int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_target_remove_from_physmap(struct domain *d1, struct domain *d2) { - return xsm_ops->remove_from_physmap(d1, d2); + return xsm_ops->target_remove_from_physmap(d1, d2); } -static inline int xsm_console_io (struct domain *d, int cmd) +static inline int xsm_priv_console_io (struct domain *d, int cmd) { - return xsm_ops->console_io(d, cmd); + return xsm_ops->priv_console_io(d, cmd); } -static inline int xsm_profile (struct domain *d, int op) +static inline int xsm_hook_profile (struct domain *d, int op) { - return xsm_ops->profile(d, op); + return xsm_ops->hook_profile(d, op); } -static inline int xsm_kexec (void) +static inline int xsm_priv_kexec (void) { - return xsm_ops->kexec(); + return xsm_ops->priv_kexec(); } -static inline int xsm_schedop_shutdown (struct domain *d1, struct domain *d2) +static inline int xsm_dm_schedop_shutdown (struct domain *d1, struct domain *d2) { - return xsm_ops->schedop_shutdown(d1, d2); + return xsm_ops->dm_schedop_shutdown(d1, d2); } static inline char *xsm_show_irq_sid (int irq) @@ -341,104 +341,104 @@ static inline char *xsm_show_irq_sid (int irq) return xsm_ops->show_irq_sid(irq); } -static inline int xsm_map_domain_pirq (struct domain *d, int irq, void *data) +static inline int xsm_hook_map_domain_pirq (struct domain *d, int irq, void *data) { - return xsm_ops->map_domain_pirq(d, irq, data); + return xsm_ops->hook_map_domain_pirq(d, irq, data); } -static inline int xsm_unmap_domain_pirq (struct domain *d, int irq) +static inline int xsm_dm_unmap_domain_pirq (struct domain *d, int irq) { - return xsm_ops->unmap_domain_pirq(d, irq); + return xsm_ops->dm_unmap_domain_pirq(d, irq); } -static inline int xsm_irq_permission (struct domain *d, int pirq, uint8_t allow) +static inline int xsm_hook_irq_permission (struct domain *d, int pirq, uint8_t allow) { - return xsm_ops->irq_permission(d, pirq, allow); + return xsm_ops->hook_irq_permission(d, pirq, allow); } -static inline int xsm_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_hook_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return xsm_ops->iomem_permission(d, s, e, allow); + return xsm_ops->hook_iomem_permission(d, s, e, allow); } -static inline int xsm_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_hook_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return xsm_ops->iomem_mapping(d, s, e, allow); + return xsm_ops->hook_iomem_mapping(d, s, e, allow); } -static inline int xsm_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) +static inline int xsm_hook_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { - return xsm_ops->pci_config_permission(d, machine_bdf, start, end, access); + return xsm_ops->hook_pci_config_permission(d, machine_bdf, start, end, access); } -static inline int xsm_get_device_group(uint32_t machine_bdf) +static inline int xsm_hook_get_device_group(uint32_t machine_bdf) { - return xsm_ops->get_device_group(machine_bdf); + return xsm_ops->hook_get_device_group(machine_bdf); } -static inline int xsm_test_assign_device(uint32_t machine_bdf) +static inline int xsm_hook_test_assign_device(uint32_t machine_bdf) { - return xsm_ops->test_assign_device(machine_bdf); + return xsm_ops->hook_test_assign_device(machine_bdf); } -static inline int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_hook_assign_device(struct domain *d, uint32_t machine_bdf) { - return xsm_ops->assign_device(d, machine_bdf); + return xsm_ops->hook_assign_device(d, machine_bdf); } -static inline int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { - return xsm_ops->deassign_device(d, machine_bdf); + return xsm_ops->hook_deassign_device(d, machine_bdf); } -static inline int xsm_resource_plug_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_plug_pci (uint32_t machine_bdf) { - return xsm_ops->resource_plug_pci(machine_bdf); + return xsm_ops->priv_resource_plug_pci(machine_bdf); } -static inline int xsm_resource_unplug_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_unplug_pci (uint32_t machine_bdf) { - return xsm_ops->resource_unplug_pci(machine_bdf); + return xsm_ops->priv_resource_unplug_pci(machine_bdf); } -static inline int xsm_resource_plug_core (void) +static inline int xsm_hook_resource_plug_core (void) { - return xsm_ops->resource_plug_core(); + return xsm_ops->hook_resource_plug_core(); } -static inline int xsm_resource_unplug_core (void) +static inline int xsm_hook_resource_unplug_core (void) { - return xsm_ops->resource_unplug_core(); + return xsm_ops->hook_resource_unplug_core(); } -static inline int xsm_resource_setup_pci (uint32_t machine_bdf) +static inline int xsm_priv_resource_setup_pci (uint32_t machine_bdf) { - return xsm_ops->resource_setup_pci(machine_bdf); + return xsm_ops->priv_resource_setup_pci(machine_bdf); } -static inline int xsm_resource_setup_gsi (int gsi) +static inline int xsm_priv_resource_setup_gsi (int gsi) { - return xsm_ops->resource_setup_gsi(gsi); + return xsm_ops->priv_resource_setup_gsi(gsi); } -static inline int xsm_resource_setup_misc (void) +static inline int xsm_priv_resource_setup_misc (void) { - return xsm_ops->resource_setup_misc(); + return xsm_ops->priv_resource_setup_misc(); } -static inline int xsm_page_offline(uint32_t cmd) +static inline int xsm_hook_page_offline(uint32_t cmd) { - return xsm_ops->page_offline(cmd); + return xsm_ops->hook_page_offline(cmd); } -static inline int xsm_tmem_op(void) +static inline int xsm_hook_tmem_op(void) { - return xsm_ops->tmem_op(); + return xsm_ops->hook_tmem_op(); } -static inline int xsm_tmem_control(void) +static inline int xsm_priv_tmem_control(void) { - return xsm_ops->tmem_control(); + return xsm_ops->priv_tmem_control(); } static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) @@ -447,54 +447,54 @@ static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) } #ifdef CONFIG_X86 -static inline int xsm_shadow_control (struct domain *d, uint32_t op) +static inline int xsm_hook_shadow_control (struct domain *d, uint32_t op) { - return xsm_ops->shadow_control(d, op); + return xsm_ops->hook_shadow_control(d, op); } -static inline int xsm_hvm_param (struct domain *d, unsigned long op) +static inline int xsm_target_hvm_param (struct domain *d, unsigned long op) { - return xsm_ops->hvm_param(d, op); + return xsm_ops->target_hvm_param(d, op); } -static inline int xsm_hvm_set_pci_intx_level (struct domain *d) +static inline int xsm_dm_hvm_set_pci_intx_level (struct domain *d) { - return xsm_ops->hvm_set_pci_intx_level(d); + return xsm_ops->dm_hvm_set_pci_intx_level(d); } -static inline int xsm_hvm_set_isa_irq_level (struct domain *d) +static inline int xsm_dm_hvm_set_isa_irq_level (struct domain *d) { - return xsm_ops->hvm_set_isa_irq_level(d); + return xsm_ops->dm_hvm_set_isa_irq_level(d); } -static inline int xsm_hvm_set_pci_link_route (struct domain *d) +static inline int xsm_dm_hvm_set_pci_link_route (struct domain *d) { - return xsm_ops->hvm_set_pci_link_route(d); + return xsm_ops->dm_hvm_set_pci_link_route(d); } -static inline int xsm_hvm_inject_msi (struct domain *d) +static inline int xsm_dm_hvm_inject_msi (struct domain *d) { - return xsm_ops->hvm_inject_msi(d); + return xsm_ops->dm_hvm_inject_msi(d); } -static inline int xsm_mem_event_control (struct domain *d, int mode, int op) +static inline int xsm_dm_mem_event_control (struct domain *d, int mode, int op) { - return xsm_ops->mem_event_control(d, mode, op); + return xsm_ops->dm_mem_event_control(d, mode, op); } -static inline int xsm_mem_event_op (struct domain *d, int op) +static inline int xsm_dm_mem_event_op (struct domain *d, int op) { - return xsm_ops->mem_event_op(d, op); + return xsm_ops->dm_mem_event_op(d, op); } -static inline int xsm_mem_sharing_op (struct domain *d, struct domain *cd, int op) +static inline int xsm_dm_mem_sharing_op (struct domain *d, struct domain *cd, int op) { - return xsm_ops->mem_sharing_op(d, cd, op); + return xsm_ops->dm_mem_sharing_op(d, cd, op); } -static inline int xsm_apic (struct domain *d, int cmd) +static inline int xsm_priv_apic (struct domain *d, int cmd) { - return xsm_ops->apic(d, cmd); + return xsm_ops->priv_apic(d, cmd); } static inline int xsm_memtype (uint32_t access) @@ -502,63 +502,63 @@ static inline int xsm_memtype (uint32_t access) return xsm_ops->memtype(access); } -static inline int xsm_platform_op (uint32_t op) +static inline int xsm_priv_platform_op (uint32_t op) { - return xsm_ops->platform_op(op); + return xsm_ops->priv_platform_op(op); } -static inline int xsm_machine_memory_map(void) +static inline int xsm_priv_machine_memory_map(void) { - return xsm_ops->machine_memory_map(); + return xsm_ops->priv_machine_memory_map(); } -static inline int xsm_domain_memory_map(struct domain *d) +static inline int xsm_target_domain_memory_map(struct domain *d) { - return xsm_ops->domain_memory_map(d); + return xsm_ops->target_domain_memory_map(d); } -static inline int xsm_mmu_update (struct domain *d, struct domain *t, +static inline int xsm_target_mmu_update (struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { - return xsm_ops->mmu_update(d, t, f, flags); + return xsm_ops->target_mmu_update(d, t, f, flags); } -static inline int xsm_mmuext_op (struct domain *d, struct domain *f) +static inline int xsm_target_mmuext_op (struct domain *d, struct domain *f) { - return xsm_ops->mmuext_op(d, f); + return xsm_ops->target_mmuext_op(d, f); } -static inline int xsm_update_va_mapping(struct domain *d, struct domain *f, +static inline int xsm_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { - return xsm_ops->update_va_mapping(d, f, pte); + return xsm_ops->target_update_va_mapping(d, f, pte); } -static inline int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_target_add_to_physmap(struct domain *d1, struct domain *d2) { - return xsm_ops->add_to_physmap(d1, d2); + return xsm_ops->target_add_to_physmap(d1, d2); } -static inline int xsm_bind_pt_irq(struct domain *d, +static inline int xsm_hook_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return xsm_ops->bind_pt_irq(d, bind); + return xsm_ops->hook_bind_pt_irq(d, bind); } -static inline int xsm_unbind_pt_irq(struct domain *d, +static inline int xsm_hook_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return xsm_ops->unbind_pt_irq(d, bind); + return xsm_ops->hook_unbind_pt_irq(d, bind); } -static inline int xsm_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_hook_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return xsm_ops->ioport_permission(d, s, e, allow); + return xsm_ops->hook_ioport_permission(d, s, e, allow); } -static inline int xsm_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_hook_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return xsm_ops->ioport_mapping(d, s, e, allow); + return xsm_ops->hook_ioport_mapping(d, s, e, allow); } #endif /* CONFIG_X86 */ #endif /* XSM_NO_WRAPPERS */ diff --git a/xen/xsm/dummy.c b/xen/xsm/dummy.c index 22c66e5..c29c5af 100644 --- a/xen/xsm/dummy.c +++ b/xen/xsm/dummy.c @@ -29,98 +29,98 @@ struct xsm_operations dummy_xsm_ops; void xsm_fixup_ops (struct xsm_operations *ops) { - set_to_dummy_if_null(ops, security_domaininfo); - set_to_dummy_if_null(ops, domain_create); - set_to_dummy_if_null(ops, getdomaininfo); - set_to_dummy_if_null(ops, set_target); + set_to_dummy_if_null(ops, populate_security_domaininfo); + set_to_dummy_if_null(ops, hook_domain_create); + set_to_dummy_if_null(ops, hook_getdomaininfo); + set_to_dummy_if_null(ops, hook_set_target); set_to_dummy_if_null(ops, domctl); set_to_dummy_if_null(ops, sysctl); - set_to_dummy_if_null(ops, readconsole); - set_to_dummy_if_null(ops, do_mca); - - set_to_dummy_if_null(ops, evtchn_unbound); - set_to_dummy_if_null(ops, evtchn_interdomain); - set_to_dummy_if_null(ops, evtchn_close_post); - set_to_dummy_if_null(ops, evtchn_send); - set_to_dummy_if_null(ops, evtchn_status); - set_to_dummy_if_null(ops, evtchn_reset); - - set_to_dummy_if_null(ops, grant_mapref); - set_to_dummy_if_null(ops, grant_unmapref); - set_to_dummy_if_null(ops, grant_setup); - set_to_dummy_if_null(ops, grant_transfer); - set_to_dummy_if_null(ops, grant_copy); - set_to_dummy_if_null(ops, grant_query_size); + set_to_dummy_if_null(ops, hook_readconsole); + set_to_dummy_if_null(ops, priv_do_mca); + + set_to_dummy_if_null(ops, target_evtchn_unbound); + set_to_dummy_if_null(ops, hook_evtchn_interdomain); + set_to_dummy_if_null(ops, hook_evtchn_close_post); + set_to_dummy_if_null(ops, hook_evtchn_send); + set_to_dummy_if_null(ops, target_evtchn_status); + set_to_dummy_if_null(ops, target_evtchn_reset); + + set_to_dummy_if_null(ops, hook_grant_mapref); + set_to_dummy_if_null(ops, hook_grant_unmapref); + set_to_dummy_if_null(ops, target_grant_setup); + set_to_dummy_if_null(ops, hook_grant_transfer); + set_to_dummy_if_null(ops, hook_grant_copy); + set_to_dummy_if_null(ops, target_grant_query_size); set_to_dummy_if_null(ops, alloc_security_domain); set_to_dummy_if_null(ops, free_security_domain); set_to_dummy_if_null(ops, alloc_security_evtchn); set_to_dummy_if_null(ops, free_security_evtchn); set_to_dummy_if_null(ops, show_security_evtchn); - set_to_dummy_if_null(ops, get_pod_target); - set_to_dummy_if_null(ops, set_pod_target); + set_to_dummy_if_null(ops, priv_get_pod_target); + set_to_dummy_if_null(ops, priv_set_pod_target); - set_to_dummy_if_null(ops, memory_exchange); - set_to_dummy_if_null(ops, memory_adjust_reservation); - set_to_dummy_if_null(ops, memory_stat_reservation); - set_to_dummy_if_null(ops, memory_pin_page); + set_to_dummy_if_null(ops, target_memory_exchange); + set_to_dummy_if_null(ops, target_memory_adjust_reservation); + set_to_dummy_if_null(ops, target_memory_stat_reservation); + set_to_dummy_if_null(ops, hook_memory_pin_page); - set_to_dummy_if_null(ops, console_io); + set_to_dummy_if_null(ops, priv_console_io); - set_to_dummy_if_null(ops, profile); + set_to_dummy_if_null(ops, hook_profile); - set_to_dummy_if_null(ops, kexec); - set_to_dummy_if_null(ops, schedop_shutdown); + set_to_dummy_if_null(ops, priv_kexec); + set_to_dummy_if_null(ops, dm_schedop_shutdown); set_to_dummy_if_null(ops, show_irq_sid); - set_to_dummy_if_null(ops, map_domain_pirq); - set_to_dummy_if_null(ops, unmap_domain_pirq); - set_to_dummy_if_null(ops, irq_permission); - set_to_dummy_if_null(ops, iomem_permission); - set_to_dummy_if_null(ops, iomem_mapping); - set_to_dummy_if_null(ops, pci_config_permission); - - set_to_dummy_if_null(ops, get_device_group); - set_to_dummy_if_null(ops, test_assign_device); - set_to_dummy_if_null(ops, assign_device); - set_to_dummy_if_null(ops, deassign_device); - - set_to_dummy_if_null(ops, resource_plug_core); - set_to_dummy_if_null(ops, resource_unplug_core); - set_to_dummy_if_null(ops, resource_plug_pci); - set_to_dummy_if_null(ops, resource_unplug_pci); - set_to_dummy_if_null(ops, resource_setup_pci); - set_to_dummy_if_null(ops, resource_setup_gsi); - set_to_dummy_if_null(ops, resource_setup_misc); - - set_to_dummy_if_null(ops, page_offline); - set_to_dummy_if_null(ops, tmem_op); - set_to_dummy_if_null(ops, tmem_control); + set_to_dummy_if_null(ops, hook_map_domain_pirq); + set_to_dummy_if_null(ops, dm_unmap_domain_pirq); + set_to_dummy_if_null(ops, hook_irq_permission); + set_to_dummy_if_null(ops, hook_iomem_permission); + set_to_dummy_if_null(ops, hook_iomem_mapping); + set_to_dummy_if_null(ops, hook_pci_config_permission); + + set_to_dummy_if_null(ops, hook_get_device_group); + set_to_dummy_if_null(ops, hook_test_assign_device); + set_to_dummy_if_null(ops, hook_assign_device); + set_to_dummy_if_null(ops, hook_deassign_device); + + set_to_dummy_if_null(ops, hook_resource_plug_core); + set_to_dummy_if_null(ops, hook_resource_unplug_core); + set_to_dummy_if_null(ops, priv_resource_plug_pci); + set_to_dummy_if_null(ops, priv_resource_unplug_pci); + set_to_dummy_if_null(ops, priv_resource_setup_pci); + set_to_dummy_if_null(ops, priv_resource_setup_gsi); + set_to_dummy_if_null(ops, priv_resource_setup_misc); + + set_to_dummy_if_null(ops, hook_page_offline); + set_to_dummy_if_null(ops, hook_tmem_op); + set_to_dummy_if_null(ops, priv_tmem_control); set_to_dummy_if_null(ops, do_xsm_op); #ifdef CONFIG_X86 - set_to_dummy_if_null(ops, shadow_control); - set_to_dummy_if_null(ops, hvm_param); - set_to_dummy_if_null(ops, hvm_set_pci_intx_level); - set_to_dummy_if_null(ops, hvm_set_isa_irq_level); - set_to_dummy_if_null(ops, hvm_set_pci_link_route); - set_to_dummy_if_null(ops, hvm_inject_msi); - set_to_dummy_if_null(ops, mem_event_control); - set_to_dummy_if_null(ops, mem_event_op); - set_to_dummy_if_null(ops, mem_sharing_op); - set_to_dummy_if_null(ops, apic); - set_to_dummy_if_null(ops, platform_op); - set_to_dummy_if_null(ops, machine_memory_map); - set_to_dummy_if_null(ops, domain_memory_map); - set_to_dummy_if_null(ops, mmu_update); - set_to_dummy_if_null(ops, mmuext_op); - set_to_dummy_if_null(ops, update_va_mapping); - set_to_dummy_if_null(ops, add_to_physmap); - set_to_dummy_if_null(ops, remove_from_physmap); - set_to_dummy_if_null(ops, bind_pt_irq); - set_to_dummy_if_null(ops, unbind_pt_irq); - set_to_dummy_if_null(ops, ioport_permission); - set_to_dummy_if_null(ops, ioport_mapping); + set_to_dummy_if_null(ops, hook_shadow_control); + set_to_dummy_if_null(ops, target_hvm_param); + set_to_dummy_if_null(ops, dm_hvm_set_pci_intx_level); + set_to_dummy_if_null(ops, dm_hvm_set_isa_irq_level); + set_to_dummy_if_null(ops, dm_hvm_set_pci_link_route); + set_to_dummy_if_null(ops, dm_hvm_inject_msi); + set_to_dummy_if_null(ops, dm_mem_event_control); + set_to_dummy_if_null(ops, dm_mem_event_op); + set_to_dummy_if_null(ops, dm_mem_sharing_op); + set_to_dummy_if_null(ops, priv_apic); + set_to_dummy_if_null(ops, priv_platform_op); + set_to_dummy_if_null(ops, priv_machine_memory_map); + set_to_dummy_if_null(ops, target_domain_memory_map); + set_to_dummy_if_null(ops, target_mmu_update); + set_to_dummy_if_null(ops, target_mmuext_op); + set_to_dummy_if_null(ops, target_update_va_mapping); + set_to_dummy_if_null(ops, target_add_to_physmap); + set_to_dummy_if_null(ops, target_remove_from_physmap); + set_to_dummy_if_null(ops, hook_bind_pt_irq); + set_to_dummy_if_null(ops, hook_unbind_pt_irq); + set_to_dummy_if_null(ops, hook_ioport_permission); + set_to_dummy_if_null(ops, hook_ioport_mapping); #endif } diff --git a/xen/xsm/flask/hooks.c b/xen/xsm/flask/hooks.c index 03ea675..2c46276 100644 --- a/xen/xsm/flask/hooks.c +++ b/xen/xsm/flask/hooks.c @@ -171,7 +171,7 @@ static void flask_domain_free_security(struct domain *d) xfree(dsec); } -static int flask_evtchn_unbound(struct domain *d1, struct evtchn *chn, +static int flask_target_evtchn_unbound(struct domain *d1, struct evtchn *chn, domid_t id2) { u32 sid1, sid2, newsid; @@ -206,7 +206,7 @@ static int flask_evtchn_unbound(struct domain *d1, struct evtchn *chn, return rc; } -static int flask_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, +static int flask_hook_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, struct domain *d2, struct evtchn *chn2) { u32 sid1, sid2, newsid, reverse_sid; @@ -252,7 +252,7 @@ static int flask_evtchn_interdomain(struct domain *d1, struct evtchn *chn1, return rc; } -static void flask_evtchn_close_post(struct evtchn *chn) +static void flask_hook_evtchn_close_post(struct evtchn *chn) { struct evtchn_security_struct *esec; esec = chn->ssid; @@ -260,7 +260,7 @@ static void flask_evtchn_close_post(struct evtchn *chn) esec->sid = SECINITSID_UNLABELED; } -static int flask_evtchn_send(struct domain *d, struct evtchn *chn) +static int flask_hook_evtchn_send(struct domain *d, struct evtchn *chn) { int rc; @@ -280,12 +280,12 @@ static int flask_evtchn_send(struct domain *d, struct evtchn *chn) return rc; } -static int flask_evtchn_status(struct domain *d, struct evtchn *chn) +static int flask_target_evtchn_status(struct domain *d, struct evtchn *chn) { return domain_has_evtchn(d, chn, EVENT__STATUS); } -static int flask_evtchn_reset(struct domain *d1, struct domain *d2) +static int flask_target_evtchn_reset(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_EVENT, EVENT__RESET); } @@ -350,7 +350,7 @@ static char *flask_show_security_evtchn(struct domain *d, const struct evtchn *c return ctx; } -static int flask_grant_mapref(struct domain *d1, struct domain *d2, +static int flask_hook_grant_mapref(struct domain *d1, struct domain *d2, uint32_t flags) { u32 perms = GRANT__MAP_READ; @@ -361,63 +361,63 @@ static int flask_grant_mapref(struct domain *d1, struct domain *d2, return domain_has_perm(d1, d2, SECCLASS_GRANT, perms); } -static int flask_grant_unmapref(struct domain *d1, struct domain *d2) +static int flask_hook_grant_unmapref(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__UNMAP); } -static int flask_grant_setup(struct domain *d1, struct domain *d2) +static int flask_target_grant_setup(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__SETUP); } -static int flask_grant_transfer(struct domain *d1, struct domain *d2) +static int flask_hook_grant_transfer(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__TRANSFER); } -static int flask_grant_copy(struct domain *d1, struct domain *d2) +static int flask_hook_grant_copy(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__COPY); } -static int flask_grant_query_size(struct domain *d1, struct domain *d2) +static int flask_target_grant_query_size(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_GRANT, GRANT__QUERY); } -static int flask_get_pod_target(struct domain *d) +static int flask_priv_get_pod_target(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__GETPODTARGET); } -static int flask_set_pod_target(struct domain *d) +static int flask_priv_set_pod_target(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__SETPODTARGET); } -static int flask_memory_exchange(struct domain *d) +static int flask_target_memory_exchange(struct domain *d) { return current_has_perm(d, SECCLASS_MMU, MMU__EXCHANGE); } -static int flask_memory_adjust_reservation(struct domain *d1, struct domain *d2) +static int flask_target_memory_adjust_reservation(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__ADJUST); } -static int flask_memory_stat_reservation(struct domain *d1, struct domain *d2) +static int flask_target_memory_stat_reservation(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__STAT); } -static int flask_memory_pin_page(struct domain *d1, struct domain *d2, +static int flask_hook_memory_pin_page(struct domain *d1, struct domain *d2, struct page_info *page) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PINPAGE); } -static int flask_console_io(struct domain *d, int cmd) +static int flask_priv_console_io(struct domain *d, int cmd) { u32 perm; @@ -436,7 +436,7 @@ static int flask_console_io(struct domain *d, int cmd) return domain_has_xen(d, perm); } -static int flask_profile(struct domain *d, int op) +static int flask_hook_profile(struct domain *d, int op) { u32 perm; @@ -468,23 +468,23 @@ static int flask_profile(struct domain *d, int op) return domain_has_xen(d, perm); } -static int flask_kexec(void) +static int flask_priv_kexec(void) { return domain_has_xen(current->domain, XEN__KEXEC); } -static int flask_schedop_shutdown(struct domain *d1, struct domain *d2) +static int flask_dm_schedop_shutdown(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_DOMAIN, DOMAIN__SHUTDOWN); } -static void flask_security_domaininfo(struct domain *d, +static void flask_populate_security_domaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) { info->ssidref = domain_sid(d); } -static int flask_domain_create(struct domain *d, u32 ssidref) +static int flask_hook_domain_create(struct domain *d, u32 ssidref) { int rc; struct domain_security_struct *dsec = d->ssid; @@ -512,12 +512,12 @@ static int flask_domain_create(struct domain *d, u32 ssidref) return rc; } -static int flask_getdomaininfo(struct domain *d) +static int flask_hook_getdomaininfo(struct domain *d) { return current_has_perm(d, SECCLASS_DOMAIN, DOMAIN__GETDOMAININFO); } -static int flask_set_target(struct domain *d, struct domain *t) +static int flask_hook_set_target(struct domain *d, struct domain *t) { int rc; struct domain_security_struct *dsec, *tsec; @@ -753,7 +753,7 @@ static int flask_sysctl(int cmd) } } -static int flask_readconsole(uint32_t clear) +static int flask_hook_readconsole(uint32_t clear) { u32 perms = XEN__READCONSOLE; @@ -763,7 +763,7 @@ static int flask_readconsole(uint32_t clear) return domain_has_xen(current->domain, perms); } -static int flask_do_mca(void) +static int flask_priv_do_mca(void) { return domain_has_xen(current->domain, XEN__MCA_OP); } @@ -790,7 +790,7 @@ static char *flask_show_irq_sid (int irq) return ctx; } -static int flask_map_domain_pirq (struct domain *d, int irq, void *data) +static int flask_hook_map_domain_pirq (struct domain *d, int irq, void *data) { u32 sid, dsid; int rc = -EPERM; @@ -823,7 +823,7 @@ static int flask_map_domain_pirq (struct domain *d, int irq, void *data) return rc; } -static int flask_unmap_domain_pirq (struct domain *d, int irq) +static int flask_dm_unmap_domain_pirq (struct domain *d, int irq) { u32 sid; int rc = -EPERM; @@ -846,7 +846,7 @@ static int flask_unmap_domain_pirq (struct domain *d, int irq) return rc; } -static int flask_irq_permission (struct domain *d, int pirq, uint8_t access) +static int flask_hook_irq_permission (struct domain *d, int pirq, uint8_t access) { /* the PIRQ number is not useful; real IRQ is checked during mapping */ return current_has_perm(d, SECCLASS_RESOURCE, resource_to_perm(access)); @@ -876,7 +876,7 @@ static int _iomem_has_perm(void *v, u32 sid, unsigned long start, unsigned long return avc_has_perm(data->dsid, sid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_iomem_permission(struct domain *d, uint64_t start, uint64_t end, uint8_t access) +static int flask_hook_iomem_permission(struct domain *d, uint64_t start, uint64_t end, uint8_t access) { struct iomem_has_perm_data data; int rc; @@ -897,12 +897,12 @@ static int flask_iomem_permission(struct domain *d, uint64_t start, uint64_t end return security_iterate_iomem_sids(start, end, _iomem_has_perm, &data); } -static int flask_iomem_mapping(struct domain *d, uint64_t start, uint64_t end, uint8_t access) +static int flask_hook_iomem_mapping(struct domain *d, uint64_t start, uint64_t end, uint8_t access) { - return flask_iomem_permission(d, start, end, access); + return flask_hook_iomem_permission(d, start, end, access); } -static int flask_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) +static int flask_hook_pci_config_permission(struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { u32 dsid, rsid; int rc = -EPERM; @@ -924,12 +924,12 @@ static int flask_pci_config_permission(struct domain *d, uint32_t machine_bdf, u } -static int flask_resource_plug_core(void) +static int flask_hook_resource_plug_core(void) { return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__PLUG, NULL); } -static int flask_resource_unplug_core(void) +static int flask_hook_resource_unplug_core(void) { return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__UNPLUG, NULL); } @@ -939,7 +939,7 @@ static int flask_resource_use_core(void) return avc_current_has_perm(SECINITSID_DOMXEN, SECCLASS_RESOURCE, RESOURCE__USE, NULL); } -static int flask_resource_plug_pci(uint32_t machine_bdf) +static int flask_priv_resource_plug_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -954,7 +954,7 @@ static int flask_resource_plug_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__PLUG, &ad); } -static int flask_resource_unplug_pci(uint32_t machine_bdf) +static int flask_priv_resource_unplug_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -969,7 +969,7 @@ static int flask_resource_unplug_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__UNPLUG, &ad); } -static int flask_resource_setup_pci(uint32_t machine_bdf) +static int flask_priv_resource_setup_pci(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -984,7 +984,7 @@ static int flask_resource_setup_pci(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__SETUP, &ad); } -static int flask_resource_setup_gsi(int gsi) +static int flask_priv_resource_setup_gsi(int gsi) { u32 rsid; int rc = -EPERM; @@ -997,18 +997,18 @@ static int flask_resource_setup_gsi(int gsi) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__SETUP, &ad); } -static int flask_resource_setup_misc(void) +static int flask_priv_resource_setup_misc(void) { return avc_current_has_perm(SECINITSID_XEN, SECCLASS_RESOURCE, RESOURCE__SETUP, NULL); } -static inline int flask_page_offline(uint32_t cmd) +static inline int flask_hook_page_offline(uint32_t cmd) { switch (cmd) { case sysctl_page_offline: - return flask_resource_unplug_core(); + return flask_hook_resource_unplug_core(); case sysctl_page_online: - return flask_resource_plug_core(); + return flask_hook_resource_plug_core(); case sysctl_query_page_offline: return flask_resource_use_core(); default: @@ -1016,18 +1016,18 @@ static inline int flask_page_offline(uint32_t cmd) } } -static inline int flask_tmem_op(void) +static inline int flask_hook_tmem_op(void) { return domain_has_xen(current->domain, XEN__TMEM_OP); } -static inline int flask_tmem_control(void) +static inline int flask_priv_tmem_control(void) { return domain_has_xen(current->domain, XEN__TMEM_CONTROL); } #ifdef CONFIG_X86 -static int flask_shadow_control(struct domain *d, uint32_t op) +static int flask_hook_shadow_control(struct domain *d, uint32_t op) { u32 perm; @@ -1079,7 +1079,7 @@ static int _ioport_has_perm(void *v, u32 sid, unsigned long start, unsigned long return avc_has_perm(data->dsid, sid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_ioport_permission(struct domain *d, uint32_t start, uint32_t end, uint8_t access) +static int flask_hook_ioport_permission(struct domain *d, uint32_t start, uint32_t end, uint8_t access) { int rc; struct ioport_has_perm_data data; @@ -1101,12 +1101,12 @@ static int flask_ioport_permission(struct domain *d, uint32_t start, uint32_t en return security_iterate_ioport_sids(start, end, _ioport_has_perm, &data); } -static int flask_ioport_mapping(struct domain *d, uint32_t start, uint32_t end, uint8_t access) +static int flask_hook_ioport_mapping(struct domain *d, uint32_t start, uint32_t end, uint8_t access) { - return flask_ioport_permission(d, start, end, access); + return flask_hook_ioport_permission(d, start, end, access); } -static int flask_hvm_param(struct domain *d, unsigned long op) +static int flask_target_hvm_param(struct domain *d, unsigned long op) { u32 perm; @@ -1128,37 +1128,37 @@ static int flask_hvm_param(struct domain *d, unsigned long op) return current_has_perm(d, SECCLASS_HVM, perm); } -static int flask_hvm_set_pci_intx_level(struct domain *d) +static int flask_dm_hvm_set_pci_intx_level(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__PCILEVEL); } -static int flask_hvm_set_isa_irq_level(struct domain *d) +static int flask_dm_hvm_set_isa_irq_level(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__IRQLEVEL); } -static int flask_hvm_set_pci_link_route(struct domain *d) +static int flask_dm_hvm_set_pci_link_route(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__PCIROUTE); } -static int flask_hvm_inject_msi(struct domain *d) +static int flask_dm_hvm_inject_msi(struct domain *d) { return current_has_perm(d, SECCLASS_HVM, HVM__SEND_IRQ); } -static int flask_mem_event_control(struct domain *d, int mode, int op) +static int flask_dm_mem_event_control(struct domain *d, int mode, int op) { return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); } -static int flask_mem_event_op(struct domain *d, int op) +static int flask_dm_mem_event_op(struct domain *d, int op) { return current_has_perm(d, SECCLASS_HVM, HVM__MEM_EVENT); } -static int flask_mem_sharing_op(struct domain *d, struct domain *cd, int op) +static int flask_dm_mem_sharing_op(struct domain *d, struct domain *cd, int op) { int rc = current_has_perm(cd, SECCLASS_HVM, HVM__MEM_SHARING); if ( rc ) @@ -1166,7 +1166,7 @@ static int flask_mem_sharing_op(struct domain *d, struct domain *cd, int op) return domain_has_perm(d, cd, SECCLASS_HVM, HVM__SHARE_MEM); } -static int flask_apic(struct domain *d, int cmd) +static int flask_priv_apic(struct domain *d, int cmd) { u32 perm; @@ -1186,7 +1186,7 @@ static int flask_apic(struct domain *d, int cmd) return domain_has_xen(d, perm); } -static int flask_platform_op(uint32_t op) +static int flask_priv_platform_op(uint32_t op) { switch ( op ) { @@ -1241,22 +1241,22 @@ static int flask_platform_op(uint32_t op) return domain_has_xen(current->domain, XEN__GETCPUINFO); default: - printk("flask_platform_op: Unknown op %d\n", op); + printk("flask_priv_platform_op: Unknown op %d\n", op); return -EPERM; } } -static int flask_machine_memory_map(void) +static int flask_priv_machine_memory_map(void) { return avc_current_has_perm(SECINITSID_XEN, SECCLASS_MMU, MMU__MEMORYMAP, NULL); } -static int flask_domain_memory_map(struct domain *d) +static int flask_target_domain_memory_map(struct domain *d) { return current_has_perm(d, SECCLASS_MMU, MMU__MEMORYMAP); } -static int flask_mmu_update(struct domain *d, struct domain *t, +static int flask_target_mmu_update(struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { int rc = 0; @@ -1279,12 +1279,12 @@ static int flask_mmu_update(struct domain *d, struct domain *t, return rc; } -static int flask_mmuext_op(struct domain *d, struct domain *f) +static int flask_target_mmuext_op(struct domain *d, struct domain *f) { return domain_has_perm(d, f, SECCLASS_MMU, MMU__MMUEXT_OP); } -static int flask_update_va_mapping(struct domain *d, struct domain *f, +static int flask_target_update_va_mapping(struct domain *d, struct domain *f, l1_pgentry_t pte) { u32 map_perms = MMU__MAP_READ; @@ -1296,17 +1296,17 @@ static int flask_update_va_mapping(struct domain *d, struct domain *f, return domain_has_perm(d, f, SECCLASS_MMU, map_perms); } -static int flask_add_to_physmap(struct domain *d1, struct domain *d2) +static int flask_target_add_to_physmap(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PHYSMAP); } -static int flask_remove_from_physmap(struct domain *d1, struct domain *d2) +static int flask_target_remove_from_physmap(struct domain *d1, struct domain *d2) { return domain_has_perm(d1, d2, SECCLASS_MMU, MMU__PHYSMAP); } -static int flask_get_device_group(uint32_t machine_bdf) +static int flask_hook_get_device_group(uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -1330,7 +1330,7 @@ static int flask_test_assign_device(uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__STAT_DEVICE, NULL); } -static int flask_assign_device(struct domain *d, uint32_t machine_bdf) +static int flask_hook_assign_device(struct domain *d, uint32_t machine_bdf) { u32 dsid, rsid; int rc = -EPERM; @@ -1354,7 +1354,7 @@ static int flask_assign_device(struct domain *d, uint32_t machine_bdf) return avc_has_perm(dsid, rsid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_deassign_device(struct domain *d, uint32_t machine_bdf) +static int flask_hook_deassign_device(struct domain *d, uint32_t machine_bdf) { u32 rsid; int rc = -EPERM; @@ -1370,7 +1370,7 @@ static int flask_deassign_device(struct domain *d, uint32_t machine_bdf) return avc_current_has_perm(rsid, SECCLASS_RESOURCE, RESOURCE__REMOVE_DEVICE, NULL); } -static int flask_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static int flask_hook_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) { u32 dsid, rsid; int rc = -EPERM; @@ -1395,7 +1395,7 @@ static int flask_bind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *b return avc_has_perm(dsid, rsid, SECCLASS_RESOURCE, RESOURCE__USE, &ad); } -static int flask_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static int flask_hook_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return current_has_perm(d, SECCLASS_RESOURCE, RESOURCE__REMOVE); } @@ -1404,28 +1404,28 @@ static int flask_unbind_pt_irq (struct domain *d, struct xen_domctl_bind_pt_irq long do_flask_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) u_flask_op); static struct xsm_operations flask_ops = { - .security_domaininfo = flask_security_domaininfo, - .domain_create = flask_domain_create, - .getdomaininfo = flask_getdomaininfo, - .set_target = flask_set_target, + .populate_security_domaininfo = flask_populate_security_domaininfo, + .hook_domain_create = flask_hook_domain_create, + .hook_getdomaininfo = flask_hook_getdomaininfo, + .hook_set_target = flask_hook_set_target, .domctl = flask_domctl, .sysctl = flask_sysctl, - .readconsole = flask_readconsole, - .do_mca = flask_do_mca, - - .evtchn_unbound = flask_evtchn_unbound, - .evtchn_interdomain = flask_evtchn_interdomain, - .evtchn_close_post = flask_evtchn_close_post, - .evtchn_send = flask_evtchn_send, - .evtchn_status = flask_evtchn_status, - .evtchn_reset = flask_evtchn_reset, - - .grant_mapref = flask_grant_mapref, - .grant_unmapref = flask_grant_unmapref, - .grant_setup = flask_grant_setup, - .grant_transfer = flask_grant_transfer, - .grant_copy = flask_grant_copy, - .grant_query_size = flask_grant_query_size, + .hook_readconsole = flask_hook_readconsole, + .priv_do_mca = flask_priv_do_mca, + + .target_evtchn_unbound = flask_target_evtchn_unbound, + .hook_evtchn_interdomain = flask_hook_evtchn_interdomain, + .hook_evtchn_close_post = flask_hook_evtchn_close_post, + .hook_evtchn_send = flask_hook_evtchn_send, + .target_evtchn_status = flask_target_evtchn_status, + .target_evtchn_reset = flask_target_evtchn_reset, + + .hook_grant_mapref = flask_hook_grant_mapref, + .hook_grant_unmapref = flask_hook_grant_unmapref, + .target_grant_setup = flask_target_grant_setup, + .hook_grant_transfer = flask_hook_grant_transfer, + .hook_grant_copy = flask_hook_grant_copy, + .target_grant_query_size = flask_target_grant_query_size, .alloc_security_domain = flask_domain_alloc_security, .free_security_domain = flask_domain_free_security, @@ -1433,70 +1433,70 @@ static struct xsm_operations flask_ops = { .free_security_evtchn = flask_free_security_evtchn, .show_security_evtchn = flask_show_security_evtchn, - .get_pod_target = flask_get_pod_target, - .set_pod_target = flask_set_pod_target, - .memory_exchange = flask_memory_exchange, - .memory_adjust_reservation = flask_memory_adjust_reservation, - .memory_stat_reservation = flask_memory_stat_reservation, - .memory_pin_page = flask_memory_pin_page, + .priv_get_pod_target = flask_priv_get_pod_target, + .priv_set_pod_target = flask_priv_set_pod_target, + .target_memory_exchange = flask_target_memory_exchange, + .target_memory_adjust_reservation = flask_target_memory_adjust_reservation, + .target_memory_stat_reservation = flask_target_memory_stat_reservation, + .hook_memory_pin_page = flask_hook_memory_pin_page, - .console_io = flask_console_io, + .priv_console_io = flask_priv_console_io, - .profile = flask_profile, + .hook_profile = flask_hook_profile, - .kexec = flask_kexec, - .schedop_shutdown = flask_schedop_shutdown, + .priv_kexec = flask_priv_kexec, + .dm_schedop_shutdown = flask_dm_schedop_shutdown, .show_irq_sid = flask_show_irq_sid, - .map_domain_pirq = flask_map_domain_pirq, - .unmap_domain_pirq = flask_unmap_domain_pirq, - .irq_permission = flask_irq_permission, - .iomem_permission = flask_iomem_permission, - .iomem_mapping = flask_iomem_mapping, - .pci_config_permission = flask_pci_config_permission, - - .resource_plug_core = flask_resource_plug_core, - .resource_unplug_core = flask_resource_unplug_core, - .resource_plug_pci = flask_resource_plug_pci, - .resource_unplug_pci = flask_resource_unplug_pci, - .resource_setup_pci = flask_resource_setup_pci, - .resource_setup_gsi = flask_resource_setup_gsi, - .resource_setup_misc = flask_resource_setup_misc, - - .page_offline = flask_page_offline, - .tmem_op = flask_tmem_op, - .tmem_control = flask_tmem_control, + .hook_map_domain_pirq = flask_hook_map_domain_pirq, + .dm_unmap_domain_pirq = flask_dm_unmap_domain_pirq, + .hook_irq_permission = flask_hook_irq_permission, + .hook_iomem_permission = flask_hook_iomem_permission, + .hook_iomem_mapping = flask_hook_iomem_mapping, + .hook_pci_config_permission = flask_hook_pci_config_permission, + + .hook_resource_plug_core = flask_hook_resource_plug_core, + .hook_resource_unplug_core = flask_hook_resource_unplug_core, + .priv_resource_plug_pci = flask_priv_resource_plug_pci, + .priv_resource_unplug_pci = flask_priv_resource_unplug_pci, + .priv_resource_setup_pci = flask_priv_resource_setup_pci, + .priv_resource_setup_gsi = flask_priv_resource_setup_gsi, + .priv_resource_setup_misc = flask_priv_resource_setup_misc, + + .hook_page_offline = flask_hook_page_offline, + .hook_tmem_op = flask_hook_tmem_op, + .priv_tmem_control = flask_priv_tmem_control, .do_xsm_op = do_flask_op, #ifdef CONFIG_X86 - .shadow_control = flask_shadow_control, - .hvm_param = flask_hvm_param, - .hvm_set_pci_intx_level = flask_hvm_set_pci_intx_level, - .hvm_set_isa_irq_level = flask_hvm_set_isa_irq_level, - .hvm_set_pci_link_route = flask_hvm_set_pci_link_route, - .hvm_inject_msi = flask_hvm_inject_msi, - .mem_event_control = flask_mem_event_control, - .mem_event_op = flask_mem_event_op, - .mem_sharing_op = flask_mem_sharing_op, - .apic = flask_apic, - .platform_op = flask_platform_op, - .machine_memory_map = flask_machine_memory_map, - .domain_memory_map = flask_domain_memory_map, - .mmu_update = flask_mmu_update, - .mmuext_op = flask_mmuext_op, - .update_va_mapping = flask_update_va_mapping, - .add_to_physmap = flask_add_to_physmap, - .remove_from_physmap = flask_remove_from_physmap, - .get_device_group = flask_get_device_group, - .test_assign_device = flask_test_assign_device, - .assign_device = flask_assign_device, - .deassign_device = flask_deassign_device, - .bind_pt_irq = flask_bind_pt_irq, - .unbind_pt_irq = flask_unbind_pt_irq, - .ioport_permission = flask_ioport_permission, - .ioport_mapping = flask_ioport_mapping, + .hook_shadow_control = flask_hook_shadow_control, + .target_hvm_param = flask_target_hvm_param, + .dm_hvm_set_pci_intx_level = flask_dm_hvm_set_pci_intx_level, + .dm_hvm_set_isa_irq_level = flask_dm_hvm_set_isa_irq_level, + .dm_hvm_set_pci_link_route = flask_dm_hvm_set_pci_link_route, + .dm_hvm_inject_msi = flask_dm_hvm_inject_msi, + .dm_mem_event_control = flask_dm_mem_event_control, + .dm_mem_event_op = flask_dm_mem_event_op, + .dm_mem_sharing_op = flask_dm_mem_sharing_op, + .priv_apic = flask_priv_apic, + .priv_platform_op = flask_priv_platform_op, + .priv_machine_memory_map = flask_priv_machine_memory_map, + .target_domain_memory_map = flask_target_domain_memory_map, + .target_mmu_update = flask_target_mmu_update, + .target_mmuext_op = flask_target_mmuext_op, + .target_update_va_mapping = flask_target_update_va_mapping, + .target_add_to_physmap = flask_target_add_to_physmap, + .target_remove_from_physmap = flask_target_remove_from_physmap, + .hook_get_device_group = flask_hook_get_device_group, + .hook_test_assign_device = flask_test_assign_device, + .hook_assign_device = flask_hook_assign_device, + .hook_deassign_device = flask_hook_deassign_device, + .hook_bind_pt_irq = flask_hook_bind_pt_irq, + .hook_unbind_pt_irq = flask_hook_unbind_pt_irq, + .hook_ioport_permission = flask_hook_ioport_permission, + .hook_ioport_mapping = flask_hook_ioport_mapping, #endif }; -- 1.7.11.7 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Thu Nov 22 18:55:05 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 22 Nov 2012 18:55: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 1Tbbv9-0004hU-95; Thu, 22 Nov 2012 18:54:43 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Tbbv7-0004hP-Ac for xen-devel@lists.xen.org; Thu, 22 Nov 2012 18:54:42 +0000 Received: from [85.158.137.99:53311] by server-6.bemta-3.messagelabs.com id 8A/FE-28265-0F47EA05; Thu, 22 Nov 2012 18:54:40 +0000 X-Env-Sender: peter.maloney@brockmann-consult.de X-Msg-Ref: server-5.tower-217.messagelabs.com!1353610477!15481477!1 X-Originating-IP: [212.227.17.9] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: QmFkIElQOiAyMTIuMjI3LjE3LjkgPT4gODI5MTU=\n,sa_preprocessor: QmFkIElQOiAyMTIuMjI3LjE3LjkgPT4gODI5MTU=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 18250 invoked from network); 22 Nov 2012 18:54:38 -0000 Received: from moutng.kundenserver.de (HELO moutng.kundenserver.de) (212.227.17.9) by server-5.tower-217.messagelabs.com with RC4-SHA encrypted SMTP; 22 Nov 2012 18:54:38 -0000 Received: from [192.168.179.201] (hmbg-4d069e58.pool.mediaWays.net [77.6.158.88]) by mrelayeu.kundenserver.de (node=mreu2) with ESMTP (Nemesis) id 0MLT3m-1Tb3x11soM-000lKP; Thu, 22 Nov 2012 19:54:33 +0100 Message-ID: <50AE74DA.6080808@brockmann-consult.de> Date: Thu, 22 Nov 2012 19:54:18 +0100 From: Peter Maloney User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:16.0) Gecko/20121025 Thunderbird/16.0.2 MIME-Version: 1.0 To: xen-devel@lists.xen.org, Andres Lagar-Cavilla References: <5082DD8C.2030608@brockmann-consult.de> <20121022135920.GE12577@ocelot.phlegethon.org> <20121101170016.GD61948@ocelot.phlegethon.org> <50A2484D.309@brockmann-consult.de> In-Reply-To: <50A2484D.309@brockmann-consult.de> Content-Type: multipart/mixed; boundary="------------090500060808000206070107" X-Provags-ID: V02:K0:GsfDOhJjaw9M53bYHCeDG1tBNyMt7bMiHIligPB5dBZ xanQZtcrWOWczsfb4rnV6w4HSZ8Y0TD4kVPcNJ0kRBbRH0IR+t mq0ZQ5mwcXvYSGGjZoDZhihuVgMHLaSl4Dta6aoxBhlVOtoYbg hoXyty4ixWYbm3/q7dKAhR+XsJ8/aFFeMuBB1iUIhAbhrVZpvJ hth5WE1jNKwJJNqPG4G/ndfV490U5j3VQLq+o7T7hVjKpEnXhH bRldJCvdRO2lgMsiTy/7mAbQtOPuW/pCd8anBlJOR8ipDsVhU/ 6YmNm/b6QMtlohvGnKUnTSLa5IRzUgwjSak7Xu3RWtlfrjv1V8 o3gaTjhtDRd3+bytgw3JI86v9Mg5d+Qq5DqnobKZTtTev62WTG MkQhw1D1f/1HA== Subject: Re: [Xen-devel] xen-unstable, winxp32 very poor performance on AMD FX-8150, I bisected and changeset is 24770:7f79475d3de7 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. --------------090500060808000206070107 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit On 11/13/2012 02:17 PM, Peter Maloney wrote: > On 2012-11-01 18:28, Andres Lagar-Cavilla wrote: >> On Nov 1, 2012, at 1:00 PM, Tim Deegan wrote: >> >>> Hi, >>> >>> At 14:59 +0100 on 22 Oct (1350917960), Tim Deegan wrote: >>>> At 19:21 +0200 on 20 Oct (1350760876), Peter Maloney wrote: >>>>> The change was 8 months ago >>>>> >>>>> changeset: 24770:7f79475d3de7 >>>>> user: Andres Lagar-Cavilla >>>>> date: Fri Feb 10 16:07:07 2012 +0000 >>>>> summary: x86/mm: Make p2m lookups fully synchronized wrt modifications >>> [...] >> Not any immediate ideas without profiling. >> >> However, most callers of hvmemul_do_io pass a stub zero ram_gpa address. We might be madly hitting the p2m locks for no reason there. >> >> How about the following patch, Peter, Tim? > I tried the patch applied to xen-unstable 4.2.0-branched 528f0708b6db+ 4.2.0-branched It seemed the same. It was extremely slow with 7 vcpus, and with 2 vcpus it was slow, but fast enough that I could bother to log in and out during the test. Attached are logs generated with this command (using xm instead of xl): for i in {1..30}; do xm debug-keys d; xm dmesg -c; done >> nameoflog xenxp_xm_dmesg_-c_7cpus_idle.log xenxp_xm_dmesg_-c_7cpus_logintooslow.log xenxp_xm_dmesg_-c_7cpus_shutdown.log xenxp_xm_dmesg_-c_duringlogin.log xenxp_xm_dmesg_-c_idling_login_screen.log Also there is xenxp_dmesg.log which is output from hitting alt+sysrq+w and p in case it's relevant. BTW this time I am testing with kernel 3.6.7 --------------090500060808000206070107 Content-Type: application/x-compressed-tar; name="xenxp_logs.tgz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="xenxp_logs.tgz" H4sIAGNzrlAAA+xdbW/bxpbu5/0VBPol3RvR8z5D46K7aZz2BrjNBm57cYGiECiKsrmRRFek HHt//Z6h7FjvM5RpUkqPEMQOpTyceWbmzHNInYd36fTupj/Or4qzb17qReClpax+wmv9Z/U7 ZURyoalQ+htCqZb8m0C+WIuWXvOijGdB8M0sz8t9n3O9f6Kvu6fxX/w6nKTFVQgHmjuHHWAl xNbx50JIGPnH8SdM2/GXhML4k+aasPv1Fx//D/ltwFhAo3MuzpkObtIynQWf0tk0HZ8Hgxk5 D27yWRnwV7fZiIakl07m3wXpFD6VDoNhVsSDMfwCJJbpf6yC8Qew4WBe9IZxOsmnv1NF5R/n wX/CK3j7jzcffnr/4afgrLgvzobpbZakxdltNivn8fhsMM6TT2fDSY/UhP3t48WbX5uHfffz +18r2KrZ7y6CUT5r+BSPyLVQOVsbM1jGvcH40yBOPp3PsulVb5aOAqq44a+D9BZGrpdcx1P4 aGBeBzezvMyTfBzQ4NV8WtykSTbK0uHrIC6K+QT+dzCNy+w2/e7Qk7L1k0YHn1SKtZO+/3ir zoM3FxeXb//nw4+vPrz79eLdv/oLFr87DxYT9jwYZ9NPwSBNcohswSyNh/cO3KdZzx5m/dOM h1H/HM+GtpFb5nxjUAr+rEH9cl9c/hnAz+v8c3CZXhWOz7/9+FtAAseHPmbD84C8DoCcyXlQ fI5vbtLZGQk+5GVQxhm0dBjwUIW6R3vDdBTPx+Xfgm9p8FN2FQ/uyzT4NU2upzlsF/fB2zx8 HfyzHIbBT296UUR+/Peb3m8X8mzlX472XL7/eB6khJPz3/8+engZSmA7iOPv/wiCrUev76HR STwe92/iq/Rv5A4On5E7+ABxne6X6nRscP4EGxOaDkkQvPvxn29++gXYsS8mlAvqzb8fPrv0 Ci5/gKMr2KOhCS7frhxddMSFf7GKxAWNAP+X99vOerF5lLrwf/i41tI0hZYSsw2fRJtHXfiU rP4fPRoBEqVrSMA0HGUrbYkH0FcnPt/WUioWSMaA1CBMRdLYo7J2+3+EqRAs2q3i2AxZogl5 ZQ98F8A0eTrH4vXwzqfpGN6seaq39lSwCHhw8TD/gnePv7y9XKLRECJBQg1ceJfs/KHpEaFx kj4gPRHGRMojvjgqVqgRRClXey8uyRbqLy7Xh3ZxlNWm/uJy29BeXKqno5Z+YifUxaVe+6xw 4n+c5bDTFkvh79XNQ1wsr+2GkU1H+crasC94My4+LR+mXDDynSuMl3aPdHxoY/EG6/NrOXxI lo7IWpShxnWKJQAQ5yLdDFPrK3DpwIDGLHXxurnwVk/BzUojJIujulPjLUT94NcZzGknpStb R0UZbB3/ZZVLv4hHaf86hr3N7hqwdTBn11bQKv4A7WGH7GfDsd2GRGp3ITdNq1iWBsBKbuaP OCYCnGEtGDmIaGphZmkB7ZlmtmtqCDha1MGJE51QATg2Syr7i8/YHdZYmrgZ1gTTTFWsz9Kb OJv10+ltvyitYARMaTdt6doH1xF5pAHxzqi+Ev1FK6HP6ewWJGQ+LeyIcmrHgbu0xxpyPGC2 49X8WO28ULbzQmnX5MyH6XmQJIGkgaCB5MHABDSBOf74ZxQQWb01CGQUJNx++IA/K/jDdfy/ C/r9s87gFprfwgYQJ1azA43BRvhyruIFQhBcQRrx8ee3JEjK2ZYweABOPp+WtTecTZxxOiqf 3x7aUL9oQ/2iDfWLNdQv1lC/WEP94g31izfUL95Qv0RD/RIN9Us01C/ZUL9kQ/2Snv0y+1L9 H+yFH0jDf9lyjWD9PwYLTbrj9fGt3cYT+z7o22AUl9fpzIE4yqbDZYyLZSVKBQVRVwX8IOBG 8KD6ARvPnWdPv6ARmsRyYMxaMmjU8gFO00G8IkvNsOYpHnXt/gNL56z66HOK5STgCyKTMrEp yGY/V2iMNwTn+il2C92NxizLGJqKNF4I3X7/c5yV/XzaH8xHo3RmVVwl4py9WxGWaRKTShAm 1+lwXulTJqyurA0ztNdusry/hGTibUrX3UOrdItxmt6sdC+qLgLVa9ZADqyeXCKrks5SA5Z7 HixjsdFoyGlFfTEfTABtkOUApa0a3UgK2h7FgZK2n/kcsEb9cTZN13qsbY83rrrsRSUJMXrR zHhe5rN0kt9a2E9pfzSfJlaPW/Vciefa/Y/U6rA89p6p2r1nIiFV79O7UvQHNsM/cIilSobc XoEsZ2naH2az6ip9v8z79oAdG27nYFKvt4mIlKhoHOb9cVyU1RqrFtmoJpIepYsBKe6LfpYn pc1fYjsCcd2epil/pGzR3VE2Hj/209h+MmcUW21dHCUkqVr3aZJO+kkMgaAPcS5PABYinc3d TFKfQCak1LwCXmpuAuNcVoPUt9dzLKe8Ng/NMdrg2Ahp1OhxbIZ3fTuhoZuWvnhkV0e9INho ywZKPbbsqVnSrllRMwYcIfM0MaxCuh0VS90bkPoRPgHZZPdD26KrtBym09Jeu9DVjYyam9hI xqNogVVW6wrW6QjCyA0IPjspLPt0/aLxhga1u3JwkQ7mV8G/0lkBwfs8uCUhJa+33RFyoH0q s0m6S5cuvc4DwSD40ZBrGikXaqUc+sl4p+J9QuXcUBNqTmnEHaj2ypsbcxWVSdcQ/W82GmVp 4ceAiKJIk/XrS7u6b7ccEPaD8Q6GzwMXka4T3RewRhZCzZmBhMufhu2rTKfJ/fZmMRH6ZQlr oJNs2r+axdP5OJ5l5f0qKD8M08qU+c1WWBiSwzCT62w87M/m0wI2y1lRrrSzLtgItq/5bOsM skzCxK4JWM6nds7Av+KxvQm9OmOCV+P8yvIwyZL1exo1pw8sqG8hagiY1WFETPDzP/7P3dTp zBI3XWtYLfrGeTzc9p9rQEAris9ZCXxt551yLql0La8FkG1Of34zhBWxDnYeRDwyrvW+gJlP 7W352Wx+U2ZrS962x6dTsB33B/E4niZbIsYiAIU2AgmPKZXMZ7Pe9/Z6wsEkVxFszzhVYVaF kgjtzjIBDuK35fp38sfBLXqEoNshPAb8CwTbDsHW78Psw+DbMQSrgSG2Y/D1LzZswbiHKFZd EdsxQNRj5j5ExB0ogCGMMnL9Hs1OoKvc3hzbBgSJLaMeAxTfXvW3Yzw0yDfkl+Xn+W56YGlT w5VLdDziwFKIx9txFBfauHBcodgK1T9hZZyfLdTh2XV8m16lw9DeMssS9wXGML1Lk/7OJQuT kvJQ2xt9HmPw8/sP/VsI89vVISzVxb7rgWQlwT4kQVmomZ1iHljxXUOtKm5sVrB1gi0j+UiB ConsROpJyHlZyFVkpN8+skDs57fwzmbDTmWDrjZVWMq7ICTlNIS/uPCItxXYTTrL8m3NghUY SsFYtP7Vil1IST4tZ9lgG5I2vs0pd3StilCRxwZQpL3vqzVb3cXeRPmyu3LuTI0e4PYuNEmV CiECR9pngQBaMZ/0qwZuoC6CieFGbdy834VVxmVWlFlShNWVwqc+11psq0iLK8tfoJ6BNHjM 1Z6NtGgTRKrgub1btKkJpGoQvwAt0ibOYO0d0DvYilbbxKSJ3NcXt8+C5TbRUBE7ow6cT/PJ FyQehSpShvmIny1QT4oBGkV15JO+AYwNCuHnNLu6Xl/LoCkbFgfPFwOc8UiHiirGPEJVi3JA Um1CGlHYHr5SQUCJIQrybS181PBfRhDQ0AgtN74Fd5AaIEpEG18MP0AN+HZrjxbwjIwtCgEp QYqGBP7ySVNdQmARSKKIetw2QClwfFLAjp3izHOT2ycFaMiZ1MZXXO6RApAZUBUx38m+TwvA ogm1MconN3CKARC9PleH2lMDz9cBSioKGo5EJPJQ8u3pgHpB6hR1gD+SSwJ4XdE5DRHgT4pL BNRE6lYE1L44mMzyaXNXBiMlTSgjwfRR5QIK1KBgAKe1z1ZwikFAESqkTQYi5nmzam8kkB6a 9zQCAWxKkaDKR014pAPSGOqxvbkigW9j9l0abCgdYKHi3Fu2NZdxu9KBKpQoQCSHijfMBrq9 MEgMpHTPzwYMiEoGkbuBbCCkOiLeueqeZEBTWDVS+mr4fbmAtqum81TA1tSt6oJ8WuTjtPcp Kx+MLPxVAoDt2Ru8ojpAlNezvCyt9cjhELu/klZnrltydoW9Gkh1h+AqLcv7/36k/Qz+4RFW kfsX4B5pb4l24DuLx721mX996/52OA7BSw4Bst8S+3fDCXLeMufT8gY5bzvKFNc1vpCGpDdD +mSAnLfM+SRJx/kV0t4y7fUuayPpzZA+vymQ9JZJj+fDrMS9tHXRWCRIeuvZUTq1Nqb5FMNM 29RbR2MkvWXSa1fuIO/N7KnJTYast56eVj+GPciXsinS3wH9mKm2T/vNLE968HtvVPQG2XQ0 KfuTrEjCib1HjKPQ0igM8rxEylul3D5uZTQfj+0TJeY3SH6r5CPpHZA+KpJPeEu1K1lZlMN8 XvYWMqc3mGXDqxQHo+XBmA/TWyS9/RXQW7zZK9Jkbp2vMPK3OgIw63uTP+fpPEXiWyf+en6V 2sdGFch9q9wvhZ2hNZlE+lulf5IOsxg5b5Xz23jWg/Mi662zbitZkPY2aUeeX5pnZHgdKZIN cQyMVW7K9mEqhfN5G0uvh6evfHx/8XRolqYgdO6D4MlI9maW5dWbtjCut96nYj7p2TeW/11V 9Tka0mvt9Tx6rR0w/TrtgIUhkfsREm43YMW18qgedLkB9yjzKEf2tgN2GpIH7dkBm1ArKbRH 91qwA64DscMOuA7EDjfgOhA7zIA9IJxewD5Gmy4zYAgNcuOxsztxdnsBM661j0dma17AFGat j/egywuYUqKdD+dxxeGF3Qdt0O6PcmpMSAzRPlGwPYsParhgoZSE+hRln6LDR8/uGNBFYcTG o393bGR/Cbs/EjIgxMdywuXvoUMJ+470NQ48Dbs/FhKhqa9r2b5FwSHwyzBihLAG/D0WgURx Y3zMK9Hg4xltehGDDxUqIRiv74a3xe6PMMG9gq2H3Z/QQh1qJb3k8EGVCY2CYHCgjfCyxYc0 wteB8OXd/uihRVLOpwIIEoVcMuPzmJr2hAG0hyqYYlrrr/XJAIxJqiEygxAWHvPM6f3l93SB E5AGNDSUa+6RHvhJAx97xBakQXPWX01Jg3rq2/lIgCqSRFqZQ62aUBl0qAxESJTmPjLaaf2l QqOJVgfuwcuNYiHMeM4PdBFbUQYa9IqEYPt8YcCUly9he8KgARVAtCShsj6UHltRezLAJi8a tgM//8ZTVAE9JiTXIdOR9nlghdML2OfhLqchA9ALePd9xuV0AC3/OrnVuzQEaPl3LNwj7S3R jpZ/xzkEyH5L7KPlX/uco+VfB1EGLf86IB0t/1rnHC3/OqEdLf+6IB0t/9onHS3/uhGNaPnX QXaEln9dUY+Wfx2QjpZ/He2paPnXRXqKln8d04+Zavu0o+XfMYwCWv61Tjla/nVIPpLeAelo +delrETLvyMYDLT862YFoOVft1fP0PKvO+LR8q/zsIOWfx188wAt/1rnHC3/umIdLf/aph15 fmmekeF1JLT8OxnLP/aVWv4JJqmfr8Jeyz+ppM+CcFn+8QYN/5Q+GsM/HfFQc+1V7I2Gf1sg XtDwzw3htPuThBEfDxyX3R81Sh2V3Z8h1Hg4aLjt/jRxuhO4YvCikJ81a/enVUgZkT7WoC3a /UVUiJBQYnxcVE+ynJ8rI2hIjFYa7f6eIKR1CyOyAbs/E3JBYCP0RDoFu7/FJqq87cb2GmdF mstQE+olfjzs/iCQCK2I9kVDU5/D2vQipj6UhREX5gBrvQ1XH0BSsGvW9wfaMPVRIY+Ipk2Y +lAaagk9PNA6cMXujxJfml7e1Yc14urDNVFRyCnE3aOSARCjhA4Vl8Rn4E5SBjDFuA6F4iJq wtXHx+3tNIQAuvp45QD1KwpcwYBJBrKUKh/b9RZDgeIh4ZyYrzUfkFIzIF5JITEfeIJgQAvs TALSpYZSAq48Aq0rEsBEfH4soMRnjbWcF0DqzZn10/VbII68wAYTyrX0MWnFrODYsgISSs4N q+/PuZEUkNBO9kOt4NfapCUV9Xu3JSkIuQYxf2B+sZwTaC09SXrBlGBxm3FJGqDjXzd3epeG AB3/joV7pL0l2tHx7ziHANlviX10/Gufc3T86yDKoONfB6Sj41/rnKPjXye0o+NfF6Sj41/7 pKPjXzeiER3/OsiO0PGvK+rR8a8D0tHxr6M9FR3/ukhP0fGvY/oxU22fdnT8O4ZRQMe/1ilH x78OyUfSOyAdHf+6lJXo+HcEg4GOf92sAHT86/bqGTr+dUc8Ov51HnbQ8a+Dbx6g41/rnKPj X1eso+Nf27Qjzy/NMzK8joSOfyfj+Me/Tsc/bojkkRfOfsc/Tj1rtfc6/gkf80FPxz/NPPhp yfGPyVBQeHmU/rbg+EeZx1C5PP+o8LAfcLn++Xh0uGz/fMpNnb5/Pi42DuM/boT0csNxGP9R Ywj34MVl/KeVMtxjPTl9/6RW2mPiOn3/CFGkGasf3ozVj5JKhZQYL5ra8/fgxEQyZIRLHx/J k3T4YBL6GEI3iefms9fhg1O/nfAI9mO0+jk8h+BYzt91Grc0BFjOfyzcI+0t0Y7l/Mc5BMh+ S+xjOX/7nGM5fwdRBsv5OyAdy/lb5xzL+TuhHcv5uyAdy/nbJx3L+bsRjVjO30F2hOX8XVGP 5fwdkI7l/B3tqVjO30V6iuX8HdOPmWr7tGM5/zGMApbzt045lvN3SD6S3gHpWM7fpazEcv4j GAws5+9mBWA5f7dXz7CcvzvisZy/87CD5fwdfPMAy/lb5xzL+btiHcv526YdeX5pnpHhdSQs 5z+Zcn7xlZbzi4hqnxp6Rzm/iIhPrbqrnL8nfEBOsJ6fipBSbZhHyVsb9fweFfCucn5Vpx07 qvl9qt9d1fzCA8NVze8zUZzV/JIa4/M4bFc1v2ZcezgluKr5qe8m5SznF4pJD5Jd5fwGlqQL xhWIF9X8oplqfgHBL5RaMeZRUt5eNT+LCGMhoUb7LI/TrOZXkeIh0ZHWHivGVc3PIj+QI9iO sZr/8BRCYDV/11nc0hBgNf+xcI+0t0Q7VvMf5xAg+y2xj9X87XOO1fwdRBms5u+AdKzmb51z rObvhHas5u+CdKzmb590rObvRjRiNX8H2RFW83dFPVbzd0A6VvN3tKdiNX8X6SlW83dMP2aq 7dOO1fzHMApYzd865VjN3yH5SHoHpGM1f5eyEqv5j2AwsJq/mxWA1fzdXj3Dav7uiMdq/s7D Dlbzd/DNA6zmb51zrObvinWs5m+bduT5pXlGhteRsJr/ZKr55Vdazc8i5vOodmc1v1bao5zL Wc3vUWbuW8yvtM+T39sp5mcmpJJ5lee2UMxfB2JHLX8diB2l/HUgdlTye0C4Cvmph5WFs5Cf U0E9JpuzkF8xwT1w2ivk51oLj1JpZyG/IMRl0+GKwYtCfllDr7nK+SkxnIeKS0E8wk575fwU QikJFRFUeIzhSZbz84hpEYpICOe8CNzl/H774BHsxq5ifhrCpsWMByWuYn4ZEiYZ8XAFOYJi fjtj0t731Xotyni2EY2qTVRFKuSUCB8bGQu31zHDKClCRSNmPCiyaKBp+1UDN1AfA0nECFc+ di4WrYzLrCizpAg/x1m51Otay2wVqZLcT1DPQBrYoNkI0qJNEKOC5/Zu0aYmkKph/AJkx0+H QpNI+mzh693LknS5USyE+am0hz3Mtmmw0igZCkYV99En22bUfPIFyuiQaeolLbZBPQkEkDpK Mw8Ra2FsVAg/p9nV9fp6BpoaEwPPlwEcdDkJjTJeUqdFVx+jlAgpkZR6TKeTlAFMc0YgV+OC +TnK7ZUB3GeCn4YQQFcfrxygnr+AKxAIqaOQSUKkhyZoLw4IpWhIaBSZrzUbkJQzERL9/+yd e28bR5bFvwqB+SfBRJV6P4xBFok1CQaYWRjyzGKAxYIgqaatjSx5Jcqxv/1WkbLNd92m2FVN +QhBHrRyWXWq+9a9TZ5feWOP0A0QFu80koA38XL0XGtCWqP1AxTyYS4NCHeEREAKUrgnaNd2 53qCVskELUHfWoKYjowkFRS5jiBeU0EYKQ+8DJYHFatU4awi1t/7OgIdmA8xGCHd5jqCoHrQ ECw+ZFwqDMD7q/M579ISgPfXF+0heyHZwfvr5xJA/ULqg/dXXnPw/ipkGfD+KogO3l9xzcH7 qyI7eH81RAfvr7zo4P3VKRrB+6vQHYH3V0t68P4qiA7eX6U9Fby/Gu0peH+V5UenWl528P76 sArg/RWXHLy/iuJD9Aqig/dXs6wE768HiwHeX507ALy/uk/PwPurJzx4f9XTDnh/Fb55AN5f cc3B+6ulOnh/pWWHzl3rDIXXI4H3dzK8P/s8eX8yaM4JOIks709zIrJhP+9PU8ZCBv4R+B1l gH9eeKa0NRTXJ4B/W0J0B/yjWF4zvD8ZrKCY8rO8v5hhJMEUWY73J53wR+D9OaOzSSaXgxes D3skxI9PNuxE0iDkm4JoD8VjRSCN15TUdZJsDyGD0iwBICnw0yzih9M2nR7sxED8HN49WBj5 azdwS0sAI39ftIfshWSHkb+fSwD1C6kPI395zWHkr5BlYOSvIDqM/MU1h5G/iuww8tcQHUb+ 8qLDyF+naISRv0J3BCN/Lelh5K8gOoz8lfZUGPlrtKcw8leWH51qedlh5O/DKsDIX1xyGPkr ig/RK4gOI3/NshJG/h4sBoz8de4AGPnrPj2Dkb+e8DDyV087MPJX+OYBjPzFNYeRv5bqMPKX lh06d60zFF6PBCP/yRj53TM18ntlzDGM/CJQTjnOGfkFxdxJ9fEHwoDK+Pidd8wYHzUihIOP fzNEdz5+ipM7a+T3RlKWNmvkV15RfNc5I38whnsCMiLv4zfWEcaT9fFbmc0xuRS88PG7o/j4 pQ9KMmG4DITZlfPxSx28YMLHsoBwNZ2kj18JzlXcRANXtF1nr49fBgKGox8bMXz8hzcPDj7+ 2v3b0hLAx98X7SF7Idnh4+/nEkD9QurDx19ec/j4K2QZ+PgriA4ff3HN4eOvIjt8/DVEh4+/ vOjw8dcpGuHjr9AdwcdfS3r4+CuIDh9/pT0VPv4a7Sl8/JXlR6daXnb4+PuwCvDxF5ccPv6K 4kP0CqLDx1+zrISPvweLAR9/nTsAPv66T8/g468nPHz81dMOfPwVvnkAH39xzeHjr6U6fPyl ZYfOXesMhdcjwcffSx9/WPvj15/uL/4vLtfrt7d/DC6aN/eZ33/56l8Dngv66uoyXko/DNI3 QF5EqUfv3zd3P/LBf97O4qokr/vlQDHL3JmI9eZ09HA9+/PgT2Lw29Wb0fjTrBn8s5m8vbm9 vn3zafDylv0w+Pvskg1++/ksBP7rv38++9e5+XHlvzLjufjbqxeDhiv+4r//Mn388YJzoUaj n/5nMNj66ttPcdCT0fX1MHUkf+Yf48s/8o9i84reeLvX87eT4xdfw464aJIJ9K+//v3n315H ddKP1DYX6ud/P/7u0s/g4pf46krs6aUfXLxceXUxkVz889VISosQ47/+27Z3Pd98dd3mthH/ l1drI22aOFLut8XnYfPVXHzBV/8fN53GSEKsRYpKx1flylhG4zjXbHy1baRCLyJ5z5Xm0gbj 06um9fh/jZfCYDFuw5V1Y+VG/Lv0wveDeJl8fY/Fz+Of/H5zHf+w5Vu9TG8VbwI1OH+8/gZ/ /fwvLy+WZPScG87VOBfvQr54HHrgYjSxj5G+CqaiMhO1eFWvSKO5tbnxnl/wLdKfX6wv7eJV 2Vr684ttS3t+Yb++muTn6YI6v3Brv6uz8V/d3U6a+/ul9Pfd+8e8GHfxZnR5dTO9Xbk30s8P i21r6WWhtOTf59L4bDT5fX1zXP+ljZt3sH59LacPI5spX8syYh0fsvEWSwGs1rrZTFPrd+DS C2Mxkk1O180bb/UtlF8ZhJGj0PbSeBmz/uCfd6NJk5V0ZeuYSxa3jv8YfGxuhvejaTN8O4p7 W9o14tYhs1NbiTbXL0Z73CHneIsYSjdpF8rLtBoryRBjJXrIYxwfYpzLVmHMOIgmhblr7uN4 bq7S1OxljOPW0Rp744wmbiJ0jHM/G8U6cvE7aYf1SSblL1sGc9LOVb9r3o+u7obNzYfh/ewu 1tkxpkmbtsntg+sRVXAx4kdvh1YPF6OMc27uPoxmV7c392lFlUjroHK1x1rk0Vimic+vj9XJ a5smr63LXZy3l82LwWQyMGKgxcCowdgPxCRe45//mg64mf/ReGDCYKLSLx/w10r8y/X4f9Hi pye9Q77Q/FPcAEaT2dWHZlHYt72LFxEGgzfNzdmrf7zkg8nsbksaPCBOenjResPZjHPdTGdP H4840rzEkeYljjQveaR5ySPNSx5pXupI81JHmpc60rz0kealjzQvfaR5mSPNyxxpXoY2r5i7 97T6v6SnsLENj4XjrMn8j18epWz9efUybeNzrlRixk1Hs7fNXSbi9Opm5QnW+XIlKrTwC1xS /LvyWg3m/4gbz0fiTL9E42IyMmPv15pBb5dfUFJN7UpZ6i9bvsXnunb/C0vvOZ8j5S2Wm4Av EaUxk9SCbM5zRcbResG58RY7C93NwSyXMaLRzWhR6A6Hf4yuZsPbm+H4YTpt7lIVNy/isrNb KSybyYjPC8KEg3uY16dSp7qydZjL9Ozm6na4FMmPtlS6hBmmSnf+rG9lemH+EKjdsMZmnOrJ JbHmpbNxMVb+OliOJafTSyXm0t8/jN/FaOOr2xjKpWp0vSkovopja9I8bx9irOnw+uqmWZux SzNef+qyPyqfcO8Wwxw9zG7vmne3H1LY35vh9OFmkurxVD3Pi+fW8w92dVk+z17a1rOXesLn s28+zvRwnDr8A5fY2MmlSk8g0+Pq4eXV3Tgl6+HsdpheSGuj0jW4TtrJzHaig9VzGS9vh9ej +9n8HpvfZNOWkdy0WSzI/af74dXtZJb6l1FagVHbmTaN+izZYrrTq+vrz/P0aZ4ym8VWRzcK Ez6Zj+73d8274WQUE8Ew5rnbSQwbM13q3fykvYBSG+PUPPDScCdxnWfzRRqm5zlJU9Vah+Mp esS10cbb6ee1ufw4TBd0nGaSbzRNd0e7JHjUkY2t/Tyyr8My6Z7VLXNAD5UXEy/nkT4kwOeX 6Y15+ww/iWVT2g/TiN40s8vmZpaeXbj5BxktN7GpGU3DItZsfl/F+3Qa08j7WPCliyKpL8aZ kK/Trjw4T98xGvxXc3cfk/eLwQfOBP9h2ydCmWi/7/ksc/XTSB2LPKGYFkrZXNRHtO31boDx 16hWB85CrL+szkRNT97yMVejbpBvN6L+79V0erWVY70RVQaTil1niNNPW04s7Me7mbq5weXe 6NN9vEcWhVq2A2HLvx23r1lzM/m0fVhSb/3gORs0oWjf3I1uHq5H6Xu3q0HVYTFTmfLwfmvY uCSHxZy8vbq+TB++38fN8u5+tjLOtsGmcft6uNtFQtdinQWdDTh7mH9cH/9rdL32TYd4xQy+ u759k3R4dzX5/mmXTyLQ830E+m1DbQm+3RaiJfh2xyj2EuhjtxessKRAexH0QVshSWH2I+jz lTCJQW/SBa9lLlUOWjPot4bIMujnaVZLb1Qukw3yDHrBSfPKYOgNZdVzIHqZb7DyKHrhXIsg O2D0Qqh8kCyOnjCQHI5eGC5iCUANtJtHb62OSTEfJ8ejF+ljdp+Pk+PRBxmvYsK8cjx6q0VY 5+O3zsgLID3f8b3DbcPKYemVtEYw6bQKhKvgMCz9tkg5LL022sVtx3u7fjzH1mgHYem3Xp4H Yel3R9qDpRc8HdHhpNCU9JjD0tN2xR7szTkovWLGh0DZVXNQ+sCEVUYTxG0Jpd8Zgg6l33rF NGc/ze/X+QfXmyEeN1TlfD6TPIbbd1MYK228/kSsGAh7Yop2//BuOB/gRtTPicSmuopww86j zUazq/vZ1eSezR8Pfp11q9tsNdLicfKXUE+INP7coD050mJMMUcNnjq7xZiOEWm+jF8CxUiO hWCVpHQj67O7mjTLYxJMSeM8JdluuQqWx6REvIPDxjE35Avq4d3Xi53ruMsZwodC22N9rRDi BLVy6yeJ7IqT0gL7o7l683b9ho5l5NGqgafXAdaE2D0ImY7N6VMd0C5JnWIdQI+UPZkm++Tt ZIoAuiiHnUzT0yKgbf2/h+17SBIIPuYAp7hUhPKiXA6wTlnFmfYhdgXPMwlYEecomXNBU5rW XCYwtEdbJ5AIpGVBKtKmRGkHpBOEKyiXCai9yZ5MQHnkUrYdaNdx59qBRSoxyll0AyfYDaRP TjzteV6mG/BMcskpzzqz3QATLnBNuPlyzYCTTHAVt5On9wLOaU+8wjtsBRY+2eW6gHhk3bax tjTS7gjRxki7K0R7I+2OSAdYlZ+8BNkj66B9Ie0heyHZqUfWYQnKLgHUL6T+ziProHlnmu88 sg6ad5dldh5ZB9G7E33XkXXQvDPN9x1ZB9k7k73dY22IfhzRdx5ZB9E7E33fkXWQvbuiceeR dRC9u+4oc2QdpO9M+t1H1kH0zkTfe2QddO9uT919ZB1U7649JRxZB/m7lB+dannZWxxZh1Xo bBV2HVkHyTuTPH9kHcTv7nqH6OVF33NkHVTvvKykH1mHxehsMXYfWQfRu7wDKEfWYQW6e3q2 98g6CN+p8HuPrIP2JdLOziPrIH933zzYdWQdNO9M8z1H1kH1TlXfdWQdZO9Kdujctc7PSGGh LYVRk1N415F1rTXed2TdloF9/Sl5ZN3GQGodWddW3gT+E88T/Ke9tnnccZ77Z7WUNNjCXu7f mZAUpzYR/KcchW1XDPynjBSO4NbMgf8oI8pQ/9qE2MH8axNiB/GPYOzP8v4IXtMs7k9TfK8Z 3p/hSnIKAyeD+5MqmEC4bHO4P++1yJOp87g/4TynQJByuD8hhM/ejrk8vMB9iCd8oyhH/DCc M2NDHGs+VkH4X9x4jOSWwoE8RdrHmTHOeiZ80OvHm+3a1L4J9J/kTLvgKHtiDvbhmPbcUzJU AdhH3J8JFw0B92E0M0LEMpoWbt99IbyRhlnjA6dSHvbgPlIesdYHdyiqDbQP2pg6oX1wJm28 HNozOjZoH5yJ2CsaQqWTo30IlspH055HuEH7EJY54/yhIJpV8p+QRP5I9+A/0eJZTq4OEEp5 z5TjWhPWrlwlELOUiqncCa+eKf7vTDmn4g2ovMyfF/IN1QIxkzjBKRsnoRRwxhtCdusBAZBY CKT2WjvviIl2302hhDWGxTufOyqydU8hsEgkQfpYyKEUOL1SwDKrdUxGTy8FBONS5w/YIZQC CQOsnT6YJLdcCyT0l9CacgpErhgwQVBLppLFwJGZoDpWBMzH0t4Srq5yhYH0SiXCYOqgCRXZ KVYGUjohPeM+3kU0nud+JijhWj2N0mB+XkVYP8f94NLAUu7iAqXBEZGgRyoNUvWtmLHckbHp e0qDeSYJIha6eEhwgpWBZtw6RQEwZ5GglnnHnT1wD14elGSx3lTqQLroamXA4gUqj1EYSCcp ybZcYXCEKkBwaZnyVlIOnCpXBqTmxTIeuLKEfHeKVcCZ1FYIZkXc8I5ABpeUJu80ygCcEbD1 uzGz9XYAKODlSMW+Ara0BEAB90V7yF5IdqCA+7kEUL+Q+kABl9ccKOAKWQYo4AqiAwVcXHOg gKvIDhRwDdGBAi4vOlDAdYpGoIArdEdAAdeSHijgCqIDBVxpTwUKuEZ7ChRwZfnRqZaXHSjg PqwCUMDFJQcKuKL4EL2C6EAB1ywrgQLuwWIABVznDgAKuO7TM6CA6wkPFHD1tAMUcIVvHgAF XFxzoIBrqQ4UcGnZoXPXOj8jhYV2nuABzSkMFPDJoIDlM0UBayMswcyaQwEb6ylO5hwKmASC PEEQsA/MCs4pyMJvBgTcJsQOEDAhRJYDnA+RowBrIz2FC5OlAIsQPOFezFGArdPGE26kLAXY C0XZ5fIUYC9cDgWQS8ELH788Ku1PBMG8loJC1StI+wtCx3ThlOHPlOlzply8JhhX1lAo3N8M 7S/RPn2gYMdyXn7PhAuCkgR64OUf0JA+LhZfIjhKhswhfWTwMZpWyigqn28v7U8EyeLQHOWG BdPnCWPqhOkjJAtKH4LG3YD6xEjWx+7wsMtgFUGoAnfiGEwfIZjz3IgDUZQrtD9BOsyiDNRH HuqPynJ+rE09PtcU4lxB2l+Q2nAWglMUPvEpVgZSWeEVk94pSi7N0v4Il/yJlAaCaeu4JqwW qTbQlDNUcrUBdTDd4/6OWBuk8luwEC/ncITaYJFKjCaTCFEa9Kk00Izr2KMcMru1ysDFAjHY A8CBW84E4ErRji/KVQY6tr+pbH16YSAVD8Sbr0xh8PQqQDmpNQuSdoBKyTLAh1gFCKcpneIp VgFn0ipnmQvS8mPQ/gItyAmUAaD97f6IcbkdAO2vyqe8S0sA2l9ftIfshWQH7a+fSwD1C6kP 2l95zUH7q5BlQPurIDpof8U1B+2viuyg/dUQHbS/8qKD9lenaATtr0J3BNpfLelB+6sgOmh/ lfZU0P5qtKeg/VWWH51qedlB++vDKoD2V1xy0P4qig/RK4gO2l/NshK0vx4sBmh/de4A0P7q Pj0D7a+e8KD9VU87oP1V+OYBaH/FNQftr5bqoP2Vlh06d63zc1LYOUGwkOUUBu3vZGh/6nnS /pSXStG4Cvtpf0pTGCc52h8J/nSCtL/AmVDGk0YE2t9miA5pfxTGTwb3p7xVJFZQBvcnvA+K YIrM4f4EtQLI8v6MNxTgUJb3x4UWuYnlkvDCya+6QvzETCiZ5Fr5fnn7tXTOsRBk8M8U/ie8 NYIz6WWgcBeziB9ajB5szjlvv3IslhwhECaUR/x4kTg2xEh7zP3UEEUQPz5oJ4mUtr2IH2es ZkFb7ii3Rgbx0yqVAPHzhDF1hfiRivv2oL0NxI/1THPBKTjtHOOHs5gk/cE4ySXGT2DOW1JS ySJ+4iVODNM94ke1eJKTBQELpTSTsWSXhC6/IAjYGWdj0guSAqA6xVrgLNbSsVnygnsKavGb AQEbJhLlibr57q8ErDWaWlOcBAh43l5zT5lUrhJQPFgTc60PFMZXFgQ8TyQ+BgXt7xRLgVhh Wh5Lw6eXAoIZERylu89VAp5xE5xoP7vNSsAx7yzn7THHG6WA1oJah5cpBY7wQMBaL5gSXhvC zMoVASmZzGHEpJxykkWANDJem7FI5fYItD9FuVdOowwA7Y/2aLC10zDbERjNRCy+KU/wC/YD RrGYBwRlGU8yERgrhGZxiwqU2u6b6QZkLEqYsiLII2SCeUNgLeFxRy4TSArwN5cLZCDWEQWb gsfHgz5I6vOOvU1ByiVeykMfwaAlqNkScGa1DpTjFnItQbw+hfDHeTionRSUZ1W5lsCx2PkK fYyDQTSlduu4IVh8+Wj5M0NwgJcjFfv+19ISgAPcF+0heyHZwQHu5xJA/ULqgwNcXnNwgCtk GXCAK4gODnBxzcEBriI7OMA1RAcHuLzo4ADXKRrBAa7QHYEDXEt6cIAriA4OcKU9FRzgGu0p OMCV5UenWl52cID7sArgABeXHBzgiuJD9AqigwNcs6wEB7gHiwEOcJ07ABzguk/PwAGuJzw4 wNXTDjjAFb55AA5wcc3BAa6lOjjApWWHzl3r/IwUFlI5glcqpzA4wCfDAdbPlANsaLkixwHW QRjCDZHjAJ9pCpP49EDAiQYUvAmK4LYGCHhLiO5AwBQrfRYEbKQTFFd3DgTspPOEODkQsOXa Ury8WQ6wtoYCm8lxgAOXWYRZLgcvWB/6OIgfrYVlRoqg+gX9Ddw4FnTQlERxkmQP6SQPzFlu KZy1HNlDBoJO/diJgfg5vHvQMPLXbuCWlgBG/r5oD9kLyQ4jfz+XAOoXUh9G/vKaw8hfIcvA yF9BdBj5i2sOI38V2WHkryE6jPzlRYeRv07RCCN/he4IRv5a0sPIX0F0GPkr7akw8tdoT2Hk ryw/OtXyssPI34dVgJG/uOQw8lcUH6JXEB1G/pplJYz8PVgMGPnr3AEw8td9egYjfz3hYeSv nnZg5K/wzQMY+YtrDiN/LdVh5C8tO3TuWudnpLAwRhEsxzmFYeQ/GSO/eaZGfhkMxTqcNfI7 LwgnE2eN/JShkH38FNd8ER9/HBKLfzOe4F2Fj39LiO58/JSrNuvjV8JRLrasj99KS+EBZH38 TnoKxCLr41cuaILGOR+/13FmT0zBCx+/OY6PX3opmXFW8BxeYFDUx+9tTF1CeSUIqp+oj9+4 JL1wirbr7PXxK0WgTPRjI4aP//DmwcDHX7t/W1oC+Pj7oj1kLyQ7fPz9XAKoX0h9+PjLaw4f f4UsAx9/BdHh4y+uOXz8VWSHj7+G6PDxlxcdPv46RSN8/BW6I/j4a0kPH38F0eHjr7Snwsdf oz2Fj7+y/OhUy8sOH38fVgE+/uKSw8dfUXyIXkF0+PhrlpXw8fdgMeDjr3MHwMdf9+kZfPz1 hIePv3ragY+/wjcP4OMvrjl8/LVUh4+/tOzQuWudn5PC1lGOzM0pDB//yfj47fP08cuglT2G j18LQ/NU7vfxU44Rpxv5CRMrZOR3gcWUEaQhhPtWjPwUzELGyC8Il0vOyU/gseSM/DJYwwlL mzXya8MpR4znjPyCWgJknfzSKU2waeac/M6Y7H6ZS8ILJ789lpM/aCYdt7JXTn6tBHdMWKst YfVO0skvlLCcGa2o/Jj9Tn5Oo8f0YCuGk//w9sHCyV+7g1taAjj5+6I9ZC8kO5z8/VwCqF9I fTj5y2sOJ3+FLAMnfwXR4eQvrjmc/FVkh5O/huhw8pcXHU7+OkXj/7N3rT1u3Fj2rxSQLxnE zfD9MAZZOPYkGCAzMOxkEWCxEKRSqa11u5VpqWP73y8pdbvVpQdvqSXeknMbQR7lzhF5SF7e S9U5JCU/QnVESn4s6knJj0A6KfmR9lRS8mOUp6TkR6afKtXytJOSvw+jQEr+4pSTkh+RfCId gXRS8mOmlaTk78FgkJIfZwWQkh/39IyU/HjEk5IfPeyQkh/hzQNS8hfnnJT8WKyTkr807cTz qXn+ihhWQoYjMExK/rNR8ruvVMnvtT6Kkl9yB5Bz5ZT8AiCHPkchf2qRV8EDhOd/GSF/F4gd Qn4ARE7HD/ECyAr5vZUgvXROyK88yCCmoJDfCojUPSvkt9Y9cYu7E/K7owj54+ZtFFPSGwmI EeWE/NJwL5jTXnDAtDxLIb8SwhsWrAiQmZ4T8ssA8OHox05MQv7DqwdHQn7sAm5tCEjI3xfu ifZCtJOQv59DQOwXYp+E/OU5JyE/QpQhIT8C6STkL845CflRaCchPwbpJOQvTzoJ+XGSRhLy I1RHJOTHop6E/Aikk5AfaU8lIT9GeUpCfmT6qVItTzsJ+fswCiTkL045CfkRySfSEUgnIT9m WklC/h4MBgn5cVYACflxT89IyI9HPAn50cMOCfkR3jwgIX9xzknIj8U6CflL0048n5rnr4lh byACxxzDJOTvpZBftv747ef5m//E4Xr7bvaxetNczjO///L1bxXPgb6ejp9Xymv1rEovgTyv JtPrcfXv2SKOSZK6jyvFLHMXImabk+Ht1eK76htR/Ty9HI4+L5rq16Z+dz27ml1+rl7O2LPq l8WYVT+/uAiB//T7i4vfXpnvH/1XpjVv/vn6edVwxZ//z98ndz9ecC6kHP7wv1W19em7z380 N/Xw6mqQ6pHv+Kf4+Hv+SWzO542Pe7v8ODl6voT08YNFPTT1xFfVP3765cXPb+MySz9St5W2 G1Avfr/73dWPTv9X9ebH+PQeW45rnx5Xb17ePV3vSA7/1Vakt/989KnLn/i7W57m8H98/YC/ ZGEsIhL3zyu7gc9D63cjYzl8wdv4jY9PRaulken4VLaf5tsv1AO+mmhZyzq2VOhHT7kfLZ+a NXwxnIz5hh9KG/+nOBWW/4+bGK6sGyk35N+mB3+r4jS5/wx9B3r3J++vr+IfdhyKl+mj4iJQ 1au7+Vf94/5fXr7hD033nBvO1SiH9+aOTjcJsbe1vUNSX5AUl7ZWq6e6NY3txq3sbfxX6236 MklevWkP7eppe2jzfLxaa+k6kn14muiPf0tPXet3dRb/9c2sbubzVeT79o+HgBh38GY4nl5P Zo9mbhrjZ6st68uCNKZOH/W3XAhfDOv37Y2x/Uvtvsr2A78ePIycjMatlVXnVuMjAOXcxkfI zbXaccFvho3HHxAfbISz9oPcxI4xv/r1Zlg3WUofbRxLyuLG8V/Vp+Z6MJnd1M2g+TPmGNeD tI2kb/HiLjJe7iHdgBOVEThmK/X7CNlcL+YRScgIJTtDmcmXNt4088XsphlMrgbj6U1Tx4Su ibVZxNYRup0C7kUWw9DUq96//9B8iD2OrR1MYrYV0erUadmt16Lmw8Aj4B+3i+vhhwSjeIQx HVHM0DcR5Xbe3MSNfPFuMFwMmg9/LD5HQNNEwGE3wOHQDsOqn3e9Ezyk7uluOHJSK7HEGSyn x+Cmvo1gQUSsphvUWMV8fQn14XoR6RpczwbNpz/iiKaRTEMpstF2g7Vx3WItjWPnuStGw+HQ RKQ/J/PBZL4YLpZAykSkjm2K68clpFjQDq6bjw9gIoGpbutgVNdju6QsBdzBx9nN+1TMJL5s RPMdV1XtJ6s5MZ5F8hfTyee0tm6Xs9al2bGhid4LaCZmPJJLwJgsD+bTy+vh1f2KF22LkBzU cNm21TnAaqpNhvNFGtUEmborsnv9bNw8r+q6MqKK9YVR1chXIsXe+78mFTfLPxpVJlS1Sr98 wF+P8EUb/+9a/PCkT8iXNt/EpGNYL6Z/NqtSsmNScYdQVZfN9cXrf73kVb242bL5HoCTjss6 JzmbOFfNZPH09ogj9UscqV/iSP2SR+qXPFK/5JH6pY7UL3Wkfqkj9UsfqV/6SP3SR+qXOVK/ zJH6ZYD9UvsOl35M5/7NOJUri/YLJe3/8cvh3daf1y+reap54r8mm8JJ3Muamwzisg5b+3n1 pS6INYHQwq8MuuLfU5lWLf8RN55PwJ4+LmRG3rcKE2/XHyjpZb1WLg2HftzxIyZjD3iw9pnL PkI+4q5JQmnJN2rRzX4+onG4UZC0P2J3ebXRmEf5X6ObIb9LmD8Op4vB7Howup1Mmpv70mAj B9wLaJp6yFPavHQgvL1aHvGlZHnDlS8LM07nhdPZYA3Jp7PCcSekZQ+XqVo6XX7UvbAt8c40 a2RGLoKtkTVN2bJx2/LbvVhyMhnf1Srz29GHiDaazlJmu7VWKT2KI2tSP2ex7plNBlfT66bV Y5d6vHEStxeV19y7VTOHt6lE/jD7M8G+jyXt7XVMD2fLUiE1d6Psy/Y/2MfDct97aTv3Xuqa L3vffFrowSidKx04xMbWY5VOvdMXJOk0YJSC9WAxGyxWVa5SaQ5u1DH7e1vrYPV9YXQVq47l GlsusklHJDdpVgOS6r/prF6kgmjItxXwuZ42jbqnbNXdyTQWRXf99KmfMhvF2ocfNa/bhx8x zs3qCBsjXSq0fN2dQKmNcWoJvNbcOo7zYjlIg3SKmDhVnXk4HqNHHBttvJ3cj8340yBN6NjN RN9wklZHtyB41JaNrL1v2UOzTFqzumMM6CHzovZyiZTOaR66N+LdI3w6Yx3endNcNovx3Wml W3551nETO+jwYiMHTbty9Sq91Vb9d3Mzj8H7efUnZ4I/2/YtZAbt/Z5vzx9//62V1k4xpRXf cN1uo965KV/t9sx+QPXWcBa8Uz7X1mQVncd8jGpk2z22jfp/08lkutU6fQNVBhMTz7DhYL6r +2nLiYn9aI+NcwYp90Gf53GNrBK1bAXC1n87bl+L5rr+vL1ZUm9/1SEHmsyPL2+G17dXw/Sm 92NQdRhmSlNu/9gKG4fkMMz63fRqnE5I53GzvJkvHrWzK9gkbl+3N7vM97XYsB/PAS5uly+I xP8aXrXerYkzpvr2anaZePgwrdvfpHWcPunSA7730oMtTe1qtbwFoqvV8vZW7L30QCjjeD77 zN96EIzg7a+OtsPsv/Vgw4V8Gwjw2oPgAFOq67UH2yCy1x54qwPzwRufi4lV/toDwTfe09qH suPmAyNyEb/K330Q0+oOIDtuPxCqC8iO+w9CbouoABcgtL9j2RaBMhcgCBNrSK2gQLtvQLDW cwfAyd2AYJSwkFHKXYAQlNCQeZe7AMFqY22O6FxAXt2AwEFmclvamLsUQXChJNPKRe7yaAde irAFKXcpgvXB+cBskAHSsANvRdg2WQ+7FWEn0u5bEaxSYhm9JYcEqNytCJCZ34+dOncpgmLe SJ4/pcxfihCYcF4bALtdL0XYBbHnUgRARJk3Fz8sV2ysEW42otPd9uqZUkZCVkWC27cqtHGB M6NiBdd+LWkH2vz2w2DZwA3UL6HEcq8hu0tCWwwX0/liWs/Z8rDwoded1tljpNXh8heoJyCN 7su1JyOt2hSDVPXU3q3adAyk5TB+AbqrnLySkA293bu4Fa23yTMZg5o7cBast0nFBRy4Bizg rfPp9sMXJGeYiVmyBq7CNtRDuhChvPPA9ZJiAvvYTC/ftVdzzCiPnBk8PRlQMugYfL3lBrBT lksGusWpc8wFLgT3XDNh3ObFfAfkArAq9wxSgTjqsWaCnJfAUgEIuQVSAcjcK5sKGGuCYoHH hBu6AexJBVIg0SzdI2chR12UCvQsFXAsBBsH8empgGBKGpc9yIekAoKJVA52z082cgHDDfPS gyrLXDIgtBECmFSUyQaengdYq4KL6ZL2vFeHAilIaWYDD5AD2HPMA+BI2UsSLaBj55IEQEk5 8JJEnCQgB5H545Uye/1gEHpJ4pa2dpVub4foJN3eAXGAOH470iHi+KcOQf6SROK+DPdEeyHa wZck0hAUHQJivxD7uy9JJM5PxfnuSxKJ85NFmd2XJBLpJyN95yWJxPmpON97SSLRfirau73X QqQfh/TdlyQS6acife8liUT7yZLG3ZckEuknq45ylyQS9aeifs8liUT6qUjff0ki8X6yPXXP JYnE+snKU8gliUT/CemnSrU87V0uSaRRONUo7LwkkSg/FeWASxKJ/JPNdyK9POn7Lkkk1k+d Vna4JJEG41SDseeSRCL9hCsAdEkijcDJTs/2X5JIxJ+S+P2XJBL3BcLO7ksSif6TvXmw85JE 4vxUnO+7JJFYPyXrOy9JJNpPRDvxfGqeieE20s5LErtyvPeSxM2GPfwUvSSx3RC0SxI70puM /8TXafynvecb9xBux9nr+2e1gViv5Xz/LoQEOOOBjf8gGuZyxn82GA+xhMsZ/0FalHH96wKx w/OvC8QOx78uEDv8/gAQWbs/kCNTxu/PcGuPYfcntVD8CHZ/1pnN+y234OTs/oTzAdKenN2f ENLqnD9NLgyvZPziiKY+Qhll48IMHmJ+Uk7ML7yL7dLGCAdBO0Mx/4Vy3ngmlXEKML/+MqY+ kjkJs5bI6fkd01Zv3lS6C+k8TH0k48oqiH1DztRHCa84M5b7ALVy2efvFwOJYzIOnCJ/vzM0 9YmbgNYS7PS419SHS61AwRZg6qOdtoCMOGfqI5xkMoSYFx+GtW7qY9N9VjCY03v6iEM1UrnM QCc3HaXS1VZ9SgxkUFwKZmJch7g1nmNmIFUM85Z5HUT+ahWA9S8gHp9JasCZVpZv3IF8aG7g FNQ6cE9uALUPLuD9e7zcoFv6ncsNVqHEKwupMSg16FtqoJkQRtju3rib1r8xqjnuDp0G642S aW9SB+eaj1IDZoU6it2f9CJ/dVrJzOAIaYCQJjAjjHWACVAuD+hWvZxjGnAhtbNx7amIBjkT zln+QSL5eeQBZPm3+3vG9XqALP9QvupdGwKy/OsL90R7IdrJ8q+fQ0DsF2KfLP/Kc06WfwhR hiz/EEgny7/inJPlHwrtZPmHQTpZ/pUnnSz/cJJGsvxDqI7I8g+LerL8QyCdLP+Q9lSy/MMo T8nyD5l+qlTL006Wf30YBbL8K045Wf4hkk+kI5BOln+YaSVZ/vVgMMjyD2cFkOUf7ukZWf7h EU+Wf+hhhyz/EN48IMu/4pyT5R8W62T5V5p24vnUPBPDbSSy/Dsbyz/5lVr+aSsszHJpr+Wf cRxiJ5Kz/FMQ98EzNfzz0gQy/DsM4oSGf3mInN2fNnGEAdYXWbs/ybUDCLhzdn8Cuj1l/f68 5BJAUN7vz+usE0cuBq+E/PKofn9KaSalF/2S84ugpGY+eS0CIthZyvmVkzYwz4W3APeov5Df X0wxAsTEISfmD4zLyDHAEuR8/P6UZFZKA3VT2+uYwWOoZdYKLqFWJ3v9/lIgMV45iEcVmfo8 oU0nMfURkgWl/QHeehuuPhHJxrDW3R9ow9THMhW4E8cw9RGCeRHz8wNbte7qY4SCeKiVcfWR R3H1iatWJ38v72Sv0oAYo0yIG4Lw7mtNA6Q1yjARAshEMuvqE2AgZ5AIkKsPqAY4ts2ntZ4J Za0C7AQlbT5lcIpZYQXkdoZzjARSWeU8C9JIDaikszafgAz6PAKB8MylmgAQ2SAlgY1V5dMj QX9sPo9YEqSqmzOjXPDQPHCfzecylHghODmAn2FFoBnXRh9QzW0UBC6lN/bQ1PtRlcK4UgJi 9JwtCNLpEpcQJ8Wsy6eSPXD5XH3HuJ4XkN0fyte8a0NAdn994Z5oL0Q72f31cwiI/ULsk91f ec7J7g8hypDdHwLpZPdXnHOy+0Ohnez+MEgnu7/ypJPdH07SSHZ/CNUR2f1hUU92fwikk90f 0p5Kdn8Y5SnZ/SHTT5VqedrJ7q8Po0B2f8UpJ7s/RPKJdATSye4PM60ku78eDAbZ/eGsALL7 wz09I7s/POLJ7g897JDdH8KbB2T3V5xzsvvDYp3s/krTTjyfmmdiuI1Edn9nY/envk67P+W1 gDjeZO3+FEjSmLP7g8jZz9Huz0gmI9ECoNomu78tECe0+4NoXjN+f8p7YSG2URm/P+GDl4D2 lPP7M0HpY/j98Tj1cwTlgvDK60Mdx+LHuuBZEEJDlmRBix/BVWwX1wEiNT9HY48LaeIPc94E C9sw9hp7RMLOZSsmi5/DywdFSn7sCm5tCEjJ3xfuifZCtJOSv59DQOwXYp+U/OU5JyU/QpQh JT8C6aTkL845KflRaCclPwbppOQvTzop+XGSRlLyI1RHpOTHop6U/Aikk5IfaU8lJT9GeUpK fmT6qVItTzsp+fswCqTkL045KfkRySfSEUgnJT9mWklK/h4MBin5cVYAKflxT89IyY9HPCn5 0cMOKfkR3jwgJX9xzknJj8U6KflL0048n5pnYriNREr+s1Hy669UyW+E8wAdVk7Jr4MKsObs VfJfgK5tB0v5AZeUF5Ly68DSpelCAeBIyr8JcTopP+je6ZyU32jDAZLwrJTfKesAlgDlpPza KQUQXOek/CG2KLcYc0F4peTXHRK2nJ5fCK0tCzLGLkAILKfnF16IdOG7kBoQwc5Sz6+8do7p dKc9wLoip+eH7Tw92I5zav6YXyx/gEh71PyWca0kJJjk1PyAiZNT80PmXnPxw3K9zhfDm41o dLeJema14h4yASPcvkUhgxCcCWu0h1i5RLSY1A6WDdxAXQUSx6QRXAC7Gnu5mM4X03rOPg6n i7Ved1pmj5GWOfcD1BOQRiloHgVp1aYYo6qn9m7VpmMgLYfxC1AaP8mcktYCsrON7k3rZr1R gmknnDtwGqw3ijPPudHuwAl1++EhFsRGCSM8YCPfBvWQH8RlqIUGLpgUFNjHZnr5rr2c4/I7 ci7Q/dXiXG4QSz3JYzYGmBLlEoPgmTCGB8CcOMuswMQ6yTKjjOeALv5lsgIjxDIx0B5QY4AS Aw8p1nOJgYfEplxqAAIpnBzE/JsbFpyPFfvTk4MUSUxMxaB5BmUGPcoMYo4onDCAU6lcYhCR uDcWckqQTQyU9AGyM+USA8MU57H8fXpeoDzIErFYWvD0BEBpE4twaYOGRKhyOUCsXKRgIYI5 wKw8yzRAOu1iRh64V5Dj4EwaICHp0nkkAmT2t/sbxrVigMz+cL7kXRsCMvvrC/dEeyHayeyv n0NA7Bdin8z+ynNOZn8IUYbM/hBIJ7O/4pyT2R8K7WT2h0E6mf2VJ53M/nCSRjL7Q6iOyOwP i3oy+0Mgncz+kPZUMvvDKE/J7A+ZfqpUy9NOZn99GAUy+ytOOZn9IZJPpCOQTmZ/mGklmf31 YDDI7A9nBZDZH+7pGZn94RFPZn/oYYfM/hDePCCzv+Kck9kfFutk9leaduL51DwTw20kMvs7 G7M/85Wa/cngIe4dWbM/FyRAGJ81+wOYE8G9/gBgZbz+lFPMaREEQOpNXn9bIHZ4/QHozHn9 QewXs15/KvnCQHH2eP1Z6TSgPeW8/pTnCkByzuvPa6mfuMXdCfnNcYT8MkjFLFccoiYvKOT3 znPmXdAQ68gzFfJ7oZgXQgdIrM8I+RVkdvZjJyYh/+HVgyEhP3YBtzYEJOTvC/dEeyHaScjf zyEg9guxT0L+8pyTkB8hypCQH4F0EvIX55yE/Ci0k5Afg3QS8pcnnYT8OEkjCfkRqiMS8mNR T0J+BNJJyI+0p5KQH6M8JSE/Mv1UqZannYT8fRgFEvIXp5yE/IjkE+kIpJOQHzOtJCF/DwaD hPw4K4CE/LinZyTkxyOehPzoYYeE/AhvHpCQvzjnJOTHYp2E/KVpJ55PzTMx3EYiIf/ZCPnt 1ynkl0FboUE4+4X8WkIuJM8K+TXEDeD8lPw2LnSpvTKA7pGSfwvEDiU/ACKn5AcouXNCfhms M4BFlBXyayN5r4T80mkPWEQ5Ib8zVufEnrkYvBLy2+MI+RU3grkY/AJAg1pOyK+VlJYpIYz7 WoX8QinrmXJByWMI+SHLpR87MQn5D68eLAn5sQu4tSEgIX9fuCfaC9FOQv5+DgGxX4h9EvKX 55yE/AhRhoT8CKSTkL845yTkR6GdhPwYpJOQvzzpJOTHSRpJyI9QHZGQH4t6EvIjkE5CfqQ9 lYT8GOUpCfmR6adKtTztJOTvwyiQkL845STkRySfSEcgnYT8mGklCfl7MBgk5MdZASTkxz09 IyE/HvEk5EcPOyTkR3jzgIT8xTknIT8W6yTkL0078XxqnonhNhIJ+c9GyO++UiG/NxIi9cwK +aUIEA1+RsgvDADj/HT8RnqmheISIDslHf8WiNPp+AVg1maF/N4GDZi5WSG/CoIDcAoK+a12 AIKyQn4bQs7oIBeDV0J+dxQhv4w8B6aM1xzgv1BOyC+NkI7pGMEcIHadpZBfCW0dk3FaSZjx y14hvwwAH45+7MQk5D+8enAk5Mcu4NaGgIT8feGeaC9EOwn5+zkExH4h9knIX55zEvIjRBkS 8iOQTkL+4pyTkB+FdhLyY5BOQv7ypJOQHydpJCE/QnVEQn4s6knIj0A6CfmR9lQS8mOUpyTk R6afKtXytJOQvw+jQEL+4pSTkB+RfCIdgXQS8mOmlSTk78FgkJAfZwWQkB/39IyE/HjEk5Af PeyQkB/hzQMS8hfnnIT8WKyTkL807cTzqXkmhttIJOTvpZBft/747ef5m//E4Xr7bvaxetNc zjO///L1bxXPgb6ejp9Xymv1rEovgTyvJtPrcfXv2SKOSZK6jyvFLHMXImabk+Ht1eK76htR /Ty9HI4+L5rq16Z+dz27ml1+rl7O2LPql8WYVT+/uAiB//T7i4vfXpnv/5+9a+1t3Na2f0XA +dKDdlS+H4OiB9OZtijQezHInHNRoCgMWZYT30ni1Hbm8e8vKTuJH7K45diknLuDog9Nukwu kpt701qLG/8VaM3Fb+9fZxXh5PWfP4xXP4YSQhkrfvwryxqfXn29q2ZlcX098PXIt+SLe/w9 +UJ35/POx32oP44NX9eQxn0wLQupC5NlP//y+5tfP7hl5n+Y2Fa07kC9+WP1u8sf4f+v7OIn 9/QBm+mxICUh2cXb1dP1joTw323iu5/S4X/4bfupx3/X8DSE/9P7p5YuWSgdEjGbSLTGJ3at V4YPx9oE8Sl5QqLWEDIixj2lWy11TLunbJu1sgzi86aWUtHEP5Vrv8u5++ViWwS4jf+Lmwr1 /6PHknClh1wX5Bv/4J+ZmyYPnyFWoKs/+Xh77f6w41C89R/lFgHP3q3mX/bzw7+8vVij0ZEo XfuHIbwL9nrVdNdoaYRaIj0RxglTJV8+FVvTWKlQe9+tt+lxEr672B7a5VPWeWq+u+CNSOrp qaff/c0/1Vu/K4L472fTsprPl5Hvm7ungOh28KoYTW7H042V4cf4u+WW9Ti1pCz9R/0zFMIX Rflxe2Pc/qXdvj78ixy5qSrdulkLHpKNh6PNlWvMtjh95yPWAbjWbP9nPq7Vjgt+dzFur+iH B4wrqllZkp34FprYLuZn/54VZRWkdGPjqClzG8e/si/V7WA8nZXVoPrkcozbgd9G/Ld4bhcZ 1XtIN2BPpQN22Ur50UFWt4u5Q6LMQbHOUNQ+tnEy+3tQ1bnVYDSZVaVL6CpXmzls4aC3XSBa kAvCi+FQL3v/uZh4L5rZbFLNHJSte1yQ7M9ZMRlR8leXBrPxuFS0hr2sbqvZpBzcFB8r186/ 76v5wrNAHbzuwEJBBFXjQtSgAwd3NxhOpg5p6DtNtWvo6GZwMx11aKjr/5CQocfcap71oJU9 pPe+oYbqatXQ8np6Ww2K25Fvsk9HVOXHf3hYex20lQ8czO+u3ZB56Ltl0FoxQrl4GLvOH2Go sMYa5SkZbQ9aqeqp23HUTDEcL1vsWrMCyyfzWZEz7kDHY99YeVhj3UTTwqM3TbP8rpgtcqnd hyj/IUWnRefn8JDsgfaQpOMMriFH3C+L+f3wxq+2eri0XwpVJyBaCWPVGtCVw6n86NBukYVW clx4IJcvzz4Phv6Ix0EVHmrYGWnkY9RgMPQbZXHl/ubnu/UxqRtNohgSVUNVXxZicFktBpPb 6agaLKMc1755ols4ZqK0Y78oa8iJw/TU+7VoOwJJNRyrB6Dr6dS/5FHPNGYf1gjt2GGpSis3 IT110kHxbqNQuqzT+PGsQdx0La59RDAOSXZF0obXg7DCuirmfppx3nlA5agsDXlq1fx6+tnv Vn4nLILZyWar2FB58u+KxdWqYYUfSZc2+OXYcc4WtiyXgfrjTXXj9nu3Vw/cpl9PM+MnB92x RYiNWBJr2GorXdwWN9VgfF1c+kyCs2Vh2w2OU1I6uNF0sMahZ7B0aF3bJgvjd6P7eTVbwhWL QXVzt/jqAKXoHHPpiEu23N5ubhd394vB7dTFgDuX5fj5Um9rwQpkE3FYGLWkr7wb3FafB/NF PWEoqdnrtvZ9h0flVof9ou+cHbp2FYVf8p/G88HYt6kG4n7Jd+5hqT3S/Ovcd/AJjHaPH3Is i7Fdgi3q+es2hnExX/i+esg6ugVrTBerX2cup5c0EzSTPBuajPqM/uGvcUZk/UfDTNqs5P6X D/hrA59u4/8g6I/P+oTwkdo/XLFblIvJp2p5hNmxmF0hZD7HePX+v96SrFzMmoq+7jj+a5rO xfUuznU1Xjy/PfRI/aJH6hc9Ur/YkfrFjtQvdqR+8SP1ix+pX/xI/RJH6pc4Ur/Ekfolj9Qv eaR+SWC/VNuXGj/5YqQa+WOyxfaLjNv/4+OXRo0/799mc3/W5v7V2+OO3V5WzQKI9fnf2s+7 xxMrQQh1Ve3SGNL93R8PZvU/3MbzBdjTzTO6oTFbB99GrT/gbLQ6Mltu00VhRh0/YjwygAdr n1n3EfIRqyZRLhjZOQPd7ecGjcVOubr9EfuP9XYas1UhVwVZHZTUR1vT28HwfjyuD7c4acqM WgFlVRbEp6a18+39df3Vkmg6AgjCjPz3VJPpYA3J+O+oRp2Q6h7WqZr/VnOje7YpHQ00ayiH uq72Hsma+BxSaocVngeNpxz/gpxzxB7FoZK+n1NXW0zHg+vJbbXVY+17bDuhkpIYvWxmcb+Y zqqb6ScP+9HVave3Lj2c3vryhTQVzsH+W7U5LA+9Z6pz75koSd37+pyhPqY5cIilKkf+cODK fzHvT6Hrk6PBYjrwDx5OCXZL3fbelsKqZfXnqtProj5mY3XVp8cdkfS4Wg6Ir4om03Lhj0EK 0lSRhnpaVfyBsmV3xxNXFK36aXw/WTCK7RwS1DX47iGBg3WRrj6xKbsTyISUmtfAa80t3Tgv 6kEa+G+v6sOSzjwcj9Ejjo2QRo0fxmb0xZ92jVw3PX2FP/Dl3YLgUVu2PKaqW/bULFkfXHaM AT1knpaG1Uj+9OKpe0PSPcKXLm0qVqcXl9VitPqWTBeNpzPtwf2gw4udHNTvytk7/zZ19j/V bO6C9+vsE8kp+a7p7ZcA2seWt7Y237sS3Dvv59QIsfN+yTbqysX/ev9dDY+oglLGcqsd/PY3 g9uo/oqCMOYmqiTb90Bso/7vZDyeNF7ZsYPKrPRfafMQ5EP3/ZbjEvthy/UBAaTQB32duzWy TNSCFUi+/ttu+1pUt+XX5mYx0fyKXQjUm+5fzorb++vCK4w2QflhmD5Nub9rhHVDchhmeTW5 HvnXDOdus5zNFxvt7Ao2dtvX/WzfpS9uJm7f6hACXNwvvzyfuwCx9U6nmzHZN9fTS8/DzaTc foOj4/Txl+2Q1st2Gpra1eK/AaKrxX9zK1ov26Fcaak0CKj1th0rlQgFpgxw2w7bfpuwCQR2 3Q6VOzegNIB1vW6nCSJ03Y4PsyQ3wjJI97pet9MGsee6nZ17iNow9ty3Ey6Ywxfu2C7t2HPj zs59Gw0YwSt3ACsgdOUOldSycMEZvnNHac7s9tepDTjBO3eklhIQVENX7ljuQkRoL8/CV+4o SSwLxYhQKF7euUP2SSsamhW6eYdzxmzOjOQ736w3oB14804DUujmHaEo17lSkoeL+oNv3mma nofdvLMXqeXmHUq0ojnhhu1c6bRnL2u7eQe2HfZgUw7du0NzTjmDLN3QvTsyF252U8Di7Xrv zj6IDvfuNM2Y6tWP9Xp15cBsJxw97aTEBVpA2PdwbYtCKmNNrglXELI92vz+ZlA3cAf1IZAo RRwsEG1RLCbzxaSc5/W54FOvOy2zTaTlOfIj1DOQhg+V2bORlm1yMSp7bu+WbToGUj2Mj0A+ ocmtVW7rPaB3k7Jab5NbwExqAwm2DbNgvU2c5lS5tAKwghsn1P3N02QnKjfSyJ3r/IBYTxmC 66BQFjrJfVjIP1eTy6vtBe3KvqNlA8/PA5QyLrRoYnqWB3QLUueYB8CRgpfvKUDHziMJgJNy 4OV7/UwCuub/bdcXHBAEKOGW5oZaKwDhLV4Q0EQL6+K3IWrnftAXEgVceShdoKO64ebaA0KB BBwtnEcksP7kiENOFiDlANWQQ5dQJADMnFAkAGZHEcuBbhV3qBxYhRLBd+8rxnLgDMoB/52J 4Tv3ox9QDpicEUY05IwxVA648GiJAM71tmpAq5xLrsSBU3O9GDCu4AXsSSeuBZZeIOuJAfRa 3oa2djULaYboZBayB+IAs5BmpEPsWJ47BOFreZH7ONwj7ZFoB1/Li0MQdQiQ/Ujs77+WFzk/ Fef7r+VFzk8WZfZfy4ukn4z0vdfyIuen4rz1Wl6k/VS0dzvXRtKPQ/r+a3mR9FOR3notL9J+ sqRx/7W8SPrJqqPQtbxI/amob7mWF0k/Fent1/Ii7yfbU1uu5UXWT1aeQq7lRfpPSD9WqvFp 73ItL47CqUZh77W8SPmpKAdcy4vkn2y+I+nxSW+7lhdZP3Va2eFaXhyMUw1Gy7W8SPoJVwDo Wl4cgZOdnrVfy4vEn5L49mt5kfsIYWf/tbxI/8nePNh7LS9yfirO267lRdZPyfrea3mR9hPR jjyfmucXxLDRYT9HAMN7r+XtynHrtby7DXv6iXot73ZDkl3L25Feb/lHX6bln3D9ETCbhFbH P+VvmAPBtDr+vaIMotSGWv4xgGw/nuUfI5xzgDYyguVfF4g9jn9dIPYY/nWB2OP3B4AI2v2J I/j9SWIFxPIyZPfHBFMWYHgQtPuDJgEhvz9qCIUYRIb8/ijlQoU6ForDS78PekS/P8q15blQ lknALIhn8UEtYdrnGQriaHmODh+vuDaa5opKC7Sc/f/h91fvE4YBKAkbfLioRA1g/vTA6icD G3xQayhkGw0ZfHBGXfrNrTYEEN+CBh8ukIjc39YOSTrQ4OMZbTqJwYfKlRCMdx+7Br8/wgQH BVuA35/Q4W1z34Rac/igmru4IhXE7idk8eE9LYFGKKe3+6OHiqRCmYHQlOSaUdBIxksMOCHc spxzpewLdQB0q0e4pExxTsK3qgC8v2DZxRmkBjR3Fa2GWL6BUgN2DO+vI6QGx/P+OlZq0C37 DqUGy0iiFIUaI2Fm0KfMQOSUykPGbtf6S+Vu+bqZ8PzUwO8AhvMDXcQ2MwMXaSmBWua1JQbM KAqEiZMYHCELoC5nyrXlIMvFiGlAp+LlHLOAV8ylvibnRBoJyDaDZsAazYCfi9RrM+Dl94zr 5QBa/iX5qndtCNDyry/cI+2RaEfLv34OAbIfiX20/IvPOVr+JYgyaPmXgHS0/IvOOVr+JaEd Lf9SkI6Wf/FJR8u/NEkjWv4lqI7Q8i8V9Wj5l4B0tPxLtKei5V+K8hQt/xLTj5VqfNrR8q8P o4CWf9EpR8u/hOQj6QlIR8u/lGklWv71YDDQ8i/NCkDLv7SnZ2j5l454tPxLHnbQ8i/Bmwdo +Redc7T8S8U6Wv7Fph15PjXPL4dhSrThMPUKWv7tb8g5Wf6xY1v+AaZPSD5ICQMIkYOuf8Io egTXP6kFAZiThFz/IDLmqJ5/EqT2Bdn+iZwpKjRApIu2fw0QJ7T9C0OETP+EVJwCTFiCpn+M aoj4OqLpH6eQjoVN/6zj6JmReCnnZ0eR83MtjcqFJdL0yu6PE6pIbrhkEP/T85TzK811bpQR /BhyfgsI8yjnb0U6Azk/Qzl/6jJubQhQzt8X7pH2SLSjnL+fQ4DsR2If5fzxOUc5f4Iog3L+ BKSjnD865yjnT0I7yvlTkI5y/viko5w/TdKIcv4E1RHK+VNRj3L+BKSjnD/Rnopy/hTlKcr5 E9OPlWp82lHO34dRQDl/dMpRzp+QfCQ9Aeko50+ZVqKcvweDgXL+NCsA5fxpT89Qzp+OeJTz Jw87KOdP8OYByvmjc45y/lSso5w/Nu3I86l5fkEMM0o1QOEYYhjl/Gcj5+fHlvMDJuIR5IMh LT83wphjaPkdEKw5rVp+AdCvRtXyA/oEEfJTlTNtBQHEDBTyN0CcUMgPcKAIKfm5MZZBrq4P KPmpJaxfSn5plQborYNKfsKEeuYet1Ly8wPFRSFtv1CC54JwqgFRI560Xyirc8OMtADjlrNU 9kvGCMmNlkTBzGBalf2wrawHG3NI1y8pdcmGtW57BoK1SPvr/dBCbGRC0n63kgHxIKTuh6HM q1c/1st2vihmOxFqbWMVTABI8nBtq4NqJUWuGVcMMq8dmstzB3UDd1Af4olkCrRIPNiiWEzm i0k5zz8Xk8Vapzstt02kOgt/gnoG0tCHzqMgLdvkYlX23N4t23QMpHoUH4H88OVEuV0dEHR3 eue2o/U2uTnFmXL7ymHTYL1RLNdGEw5Yxo0T6v7mKSConGqu1YGNekoZVskGDMaHhfxzNbm8 2l7Nrm9Hzg6enxFQyrXMFWEWYucVLyXoFqfOMifglrnoaQ0hHFAxhXICWF16BjkBz4nlQgAW bSghMDlhSkIK/x54/cRPBTgliuSKuqoFiNaWCvhA4trGiIAckWAu0LdcwOZGEamOkAvQXLo0 HGIEG0oF3AKWVtND59NaKmBNzl31BZ7oLamAEAzKUsxUoLvuKJgaSOm96CTkuDJiYuDSAkOt 1S81LZBKu7TAGK4MpgVPEJRLnjOrJaQyCGUGOreUgk4zg0cFGppetJ0UQEAg2QExOVPaUOC5 QyABd9PQkU4t5PA4lB34WGI5VYeWdZgbJMwNXJYohIXmnG25AcldCmsUcH625QYkF5pRyLdf odxA59JYKiAmxYHUQErQXhItM3h+DuA2Ic19sDSQnkU0A+5Uu5xlHsCk4S4B9hsV7Ly/NQ/g QC/7M8gE0Ay48e2YxVY9gGbAG0jRXgJbGwI0A+4L90h7JNrRDLifQ4DsR2IfzYDjc45mwAmi DJoBJyAdzYCjc45mwEloRzPgFKSjGXB80tEMOE3SiGbACaojNANORT2aAScgHc2AE+2paAac ojxFM+DE9GOlGp92NAPuwyigGXB0ytEMOCH5SHoC0tEMOGVaiWbAPRgMNANOswLQDDjt6Rma AacjHs2Ak4cdNANO8OYBmgFH5xzNgFOxjmbAsWlHnk/N8wtimGoFkW2GGEYz4LMxAxYv1AxY MkEAyv+QGbCwUsE0la1mwK8EBORM3YCpZRBnVXQDboA4nRswyPkx5AYsJQXJ+ENuwJpbiENX PDdgoRXEwTrkBmwpCzqVhILwUskvjqPkF4rJ3AipIdZq8ZT8zFJjc645yIfyPJX8WhPXRWb1 Mcx/Hcy5bMWo5D+8fBCo5E9dwa0NASr5+8I90h6JdlTy93MIkP1I7KOSPz7nqORPEGVQyZ+A dFTyR+cclfxJaEclfwrSUckfn3RU8qdJGlHJn6A6QiV/KupRyZ+AdFTyJ9pTUcmfojxFJX9i +rFSjU87Kvn7MAqo5I9OOSr5E5KPpCcgHZX8KdNKVPL3YDBQyZ9mBaCSP+3pGSr50xGPSv7k YQeV/AnePEAlf3TOUcmfinVU8semHXk+Nc8viGFGpQZI7UIMo5L/bJT88oUq+TkVHKaobFfy G6pgzWlX8gPutj9DIT8xxrXIMAnoHgr5GyBOJ+SnYAF+i5CfcwVZREEhv0MJCt6zmEJ+brSE 4rQI+Y2wLGQXEorBSyG/PI6QnxNhckOZtoDeRRTyG6NYrpWlFjAtz1PIbwiXueVCKEisDwj5 OQfE+H7sxCjkP7x6kCjkT13ArQ0BCvn7wj3SHol2FPL3cwiQ/Ujso5A/Puco5E8QZVDIn4B0 FPJH5xyF/EloRyF/CtJRyB+fdBTyp0kaUcifoDpCIX8q6lHIn4B0FPIn2lNRyJ+iPEUhf2L6 sVKNTzsK+fswCijkj045CvkTko+kJyAdhfwp00oU8vdgMFDIn2YFoJA/7ekZCvnTEY9C/uRh B4X8Cd48QCF/dM5RyJ+KdRTyx6YdeT41zy+IYWooRCYcYhiF/Gcj5FcvU8jPrNQCpqhsF/L7 HxBMu5BfAO7/hiv5Q+LhLJaSn1KTa0YEB+hzUcnfAHE6JT9gjoSE/MxqA1GEB4X8QmoFWADx hPxMWwlwKAgJ+bUiJtSvUAxeCvnVkYT8VKhcUG4k4Eb3eEJ+Fx8IySXVkgCyi7MU8lMurcmp UVQCGhYU8hNAQO3HToxC/sOrB4VC/tQF3NoQoJC/L9wj7ZFoRyF/P4cA2Y/EPgr543OOQv4E UQaF/AlIRyF/dM5RyJ+EdhTypyAdhfzxSUchf5qkEYX8CaojFPKnoh6F/AlIRyF/oj0Vhfwp ylMU8iemHyvV+LSjkL8Po4BC/uiUo5A/IflIegLSUcifMq1EIX8PBgOF/GlWAAr5056eoZA/ HfEo5E8edlDIn+DNAxTyR+cchfypWEchf2zakedT8/yCGKaWE4DAMcQwCvnPRsivX6iQ30gt YIrKdiE/4wTmB9Aq5KeARQXX8QPEsFF0/MQYkjPBhARQhDr+BojT6fgpQDgfFPIbLQxAER4U 8nPLNaBPEYX8SisoTpuQXzMesvkIxeClkF8fRcjPLNUyt9QaiBA8npCfSWpVrjQxFtCusxTy c6oJywlnWsH2i1YhP7MAH45+7MQo5D+8etAo5E9dwK0NAQr5+8I90h6JdhTy93MIkP1I7KOQ Pz7nKORPEGVQyJ+AdBTyR+cchfxJaEchfwrSUcgfn3QU8qdJGlHIn6A6QiF/KupRyJ+AdBTy J9pTUcifojxFIX9i+rFSjU87Cvn7MAoo5I9OOQr5E5KPpCcgHYX8KdNKFPL3YDBQyJ9mBaCQ P+3pGQr50xGPQv7kYQeF/AnePEAhf3TOUcifinUU8semHXk+Nc8viGFGFQfo0EIMo5C/l0J+ vfXHH77OL/52w/Xhavo5u6gu54Hff/v+PxkJgb6fjNxU+i7zb4C8dlQXd3fV7HuS/fd04UbF i91HGc9Vrl9Rl2+Oi/vrxbfZP2j26+SyGH5dVNm/q/Lqdno9vfyavZ3m32W/L0Z59uubV9aS X/548+o/7+T3G/8VaM/Fb+9fZxXh5PWfP4xXP4YSQnlR/PhXljU+vfrqGl0W19cDX5F8S764 x9+TL3R3Ru983If649jw9RNsQWjlRaA///L7m18/OHb8DxPbC20H6s0fq99d+8kufnJPN7DH I5NdvN14uuxICP/dJhIX1Dr8D781feq73afbMrcd/J/eb7W0qlxLiWnCJ3b3aQifkv9j71p7 3Lix7F8pIF8STLrC98MIMki6k8EAMwOjk1kMsFgIpVLJ1roteSW1Y//7Jav6UQ+pyFKXyJJ9 G0Ye1fIR7yF5eUnpHDb/jlwuDRLGLSTDtHlKGm3J5rhz13wXnx5qKWYVklKIMkSE5so+5YPb /5sZCknVbpFlakFyidC39sF3iRkmz+9R/Tz85t36zvxy4Ftd27cyk4AmNw/jL/n18T+ub2s0 KoQ4QnTuwrslrx6aTmXGFRMV0jNhhBVU0+opa1DDkOiI6Nv4N7foAPU3t+2urZ6SwdTf3B7q 2ptb8fzU0o/sgLq5la3XMif+6+0mL3a7Wvr79sNDXjSreJEtVuvlpjE37M/31bJVe4wpI+g7 VxrfZ/m79uLYflFn8ibt8VVPH5wUS9TKMrjtH9J5ixqAYIwV3TTVnoG1B3OckcLFa3fiNd+C qkYjOMn00KFxbbJ+8sc2ywsnpY2lo6TMLB1/TT4V69kuWxazt5lZ2+yqYZYO4gytgVbyZ9Ae VsjS38JAscKuQm6amliWBoNl7UMecJQ2OItBMHyucWFhtsXOtGe9sqGJhcGRbS+LXpwslzlm Bme3z0wdWb3GrrDK0kTVYiCYJKJkfVt8yFbbWbH+ONvtt6bONpjcLtrctQ62EamWBvGTEjPB ZlUrTczF9mO2X23WO9ujFNt+oK7ao4WczYkNvBwfzeBN/vzB/rPtmtIZnJtF8SrJ84TjhOGE 02SuEpybMf74Z5kgXv5qnnCd5NS++IQ/DfxFG/9Hhn960Tu4C81vzAKQ5fvVx6Iq7IfO4goh Sd4U66vX/7xGSb7fHkiDJ+DYw4vBC04X565Y7l/eHjxSXHikuPBIcZGR4iIjxUVGiouOFBcd KS46UlxspLjYSHGxkeLiI8XFR4qLe8al+rb6v9hTWLMNN4Xjvv3xfvsvPh2lHPx5fW2X8dJX yprGLbP922LrQFyu1o0TrJt6JYoZVpVdkvknVYwm5b/MwvPJM9InNITzjM+Vam0Glag/oBRn rFGWqsXAt3isa/sf1N6zjNHnLeqbgCdEwnlutyDdOBs0Zp2Cs/0WxwvdTmPqZQwuWJFVhe5s 9me22s8269n8frkstraKK4s4Z3SNwrLIM1QWhNYP7r6sTwmzdeVgmIU9u1ltZjUklR2qdN0R 2kq3POtrhKfLQ6BhzZrzua0na2SVpTOXBss9DupYZLlcUFxSv7ufvzdo89XGQElbjXY2BaF7 cS64jXNzb7CWs7vVumhFLG3EnVOXXlSUIyWrZmb3+822eL/5aGHfFbPl/Tq39bitnsvieXD8 WjS75TF6IgZHT1iOyuiLT3s2m9sd/oldzEW+oPYE0h5Xzxar7dwm69l+M7MPbN9QOwY7Tjv9 0eZMC1bSuNjM7rLdvpxj5SRbDkSSy6LqkN3n3Wy1yfd2/5LZHsiGRloU9JGyKtzl6u7uMU5l 4yTOLNZsXaZzlJete/e+eD/LM5MIZibPbXIDazKd3bupfDiBhHEuaQlca25u+nlfdtLMnudY TulgHsZjdMS+YVyJ5WPfLD7N7IA2YVr6sqWdHcOS4Kgtmwvx2LLnZnE7Z9nAHDBB5nGuSIn0 0Rp8PoU3R8MzfG7KJrse2ha9KfaLYr23Zxey/CBj4CK25NlSV1j7cl6Zebo0aeSDKfjsoLDs 4/ahcacGtatycmO/Y5T8V7HdmeT9KvmIUoy+P/SJkAPtXc9nmc1PIxnVlOAUEY6dpd2Dt+3d cQfjJ1RGmVap5hzz9rFNG9WevLkxm6hEu1D/d7Vcrg4aWXdQieam9MXEBfkYvl1yTGE/7zHV dSC53ujzzsyRqlBz7kDS+qvN8rUv1vnnw80i7PAHzy5Qa0X7Zput7+8y+73bJig9DdOWKfcf DsKaLjkNM3+7ulvYD993ZrHc7vaNdg4FW5rl6357zAqd4Y4ZtAtwf19+XG/+L7trfdPBjJjk 27vNG8vD+1Xe/kxj4PCxFvSo14L+QFOHGt8egBhqfHu4Fb0W9Jiashe7plfi9qDXAqv2RzaH Yfo96En7lPsQiJ8JPcHuPd1wE/pDEE4TepNmTYuUWRna1tKH4Aaa0PdBeJrQ90EcMaHvfEDX h3HEhZ56THmXDX3H1v8AhtOH3rVSJW4feswpkdQb6LgRvZBaa48Z6TKiNzsuwj1mk8uHXpu8 1/nQ7RhOjw+92bAL7Br+rkxcGdEjXzeMA8102dMzQlKiTOrwGFcnmtMfQHKZ0zNTUhJKsfug 4GRr+kND9TRr+qNIPdb0XChEU4K4lB5JwWVN77cyTmB9dhnTY25KDvOjPCagy5pephIp4UOv y5refU7i9qb3q/eKq5/KCVt+gt0FsSsrV6mS3PzbD653lgnGZUo5V51reY6g7e7fz8oGdlCr TEIZRe4zuQesfbZf7farfJeWp4TPMQ+aaU2k6lT5CeoFSPPHfdqLkao2mTSVvDS6qk1jIJWd +ARUbZnMPp561Gud6Mw61GwT4Ur7zJlDo6DeJpwKpKjyWJkOjqf7909I1KQVYip2z0nThnou F2zJjpxHEg8wNiekfxarN2/bc9nklJErg5dXApRySlPFkZYe8QWsBQSTLBVYY+WDdonVAEaS 6VRhLTv3iH3N1QBJGUZEeExaVy3AUyE08iF36DU1J5QCnpnRVQjYLbZZbn0Tbd+k4JIQljKq NPKsUvoKAZtIWEqImbIn5lsoBWKWAtKU4IIS35HQUwrglBIufdK2qxSgOMVCk85VZSfUAhzJ VCmB3J9neRQDzKxKk6oGXl4HCEk4swe/mrmaFbQOGJakLrEO8Edy3lUn/M64L6AI8CflxLvq plkEDD4Z7HH7PyEJYCQETykmUk4qCUgzsoU0ywpDPtnpErOAEDbzmiWKe23HXanA5wODy8gE 2GR/pSTzWG999gNK+qzczrPBl6cCz5om4H5g2JbbtR94yCVU0M4NuLAfuID9gP02hfL6KNe1 H1ApMePT53jJuR9IsdReS4BrOyBVKhAhp55a13cDigifTzLPvBmovDPqlYHvNbYH2jrUXOMw xCBzjSMQJ9iXHEY6xb7kpV3gvsYWuA/DPdAeiHbva2yhC4J2AbAfiP3j19gC5+fi/Pg1tsD5 2bLM8WtsgfSzkX70Glvg/Fyc915jC7Sfi/ZhB9tA+jikH7/GFkg/F+m919gC7WcrGo9fYwuk n2135LrGFqg/F/U919gC6ecifbBwB3gfZ03tucYWWD/b9tTnGlug/4z0w041PO1DrrGFXjhX Lxy9xhYoPxflHtfYAvlnG+9AenjS+66xBdbPXVYOuMYWOuNcndFzjS2QfsYZ4HWNLfTA2U7P +q+xBeLPSXz/NbbAfYC0c/waW6D/bN88OHqNLXB+Ls77rrEF1s/J+tFrbIH2M9EOPJ+bZ2C4 jXT0GtuhHPdeY9tt2PNP0Gts2w2Jdo3tQHqtGTD+Ms2AmaaaeCgIXV7AglPlJ9Tu9QK+wsTD 9dDbDNjLsDaMGbCSqVRScw+uL8MMeAjEES/gIRBHrIA9IJxOwD5iepcVMMeEUx8lrsMJ2Dr4 0hGcgLHvEuWyAsYKM+wRmMsKGGPGnKJnVx6uDD/wGa2AOWKpoEozj8wR0PYH0ZRrRH18SC7R 7uOKC0lQqpjiPnbaX435n6CVFTD18C9x2X2IlDFMfezXXXYf2hcjhBWwECkRREpPg9S+mYFN JcRTyaUWvp4KPY4fNpNIqiT1KGjA7+MFbTqL3wcyo0px53U2h6LrWAGbpU9wj/XEbQXMCZZ8 uCdhx+8Di1RhyvAYVsCMYM+5d37zPzzgNMfp/kW10CniGvuUP+FqAZOlqEwVx0p9oRaAV1Rq JVKupJeR01dTDeAUE0V9jLfdtYDCmkuPDfsEXAA9C4Fyg02JT6nkKgQMCuP25gRKfH3X+6y/ ykRiSjnlc0ICpcDUSgGRCrspH76AH7ACRoRRr2TrYQXMJPOxBXfWApKmBgp5XYjkKAYERj4H XKGLgZF9QZnkNNVEm5V4SoUBRURpmgpBic9FRpdYGRDGhcmlhDD35ZUelYHPUnoZpYFK7R32 3htzR2kgtM8pjKs08Bg5gVxBRywNhlXfzuuCykxikq/PpW1QGUytMmBma8+xGH7A0zUFNdNO IilOvOan3iiSUqqo162EzsogFRzTUxtVLwyIRmxSpwQjVAHY3l6HuWTYYwAELAMGbV4usQq4 Iiajq1RSxD0/c+6/J0DCPQEvRZr0PQHVN5Dq2wEwA64jBfsSWK0LwAx4KtwD7YFoBzPgaXYB sB+IfTADDs85mAFHyDJgBhyBdDADDs45mAFHoR3MgGOQDmbA4UkHM+A4RSOYAUfYHYEZcCzq wQw4AulgBhxpTQUz4BjbUzADjkw/7FTD0w5mwFPoBTADDk45mAFHJB9Ij0A6mAHHLCvBDHgC nQFmwHFmAJgBxz09AzPgeMSDGXD0tANmwBG+eQBmwME5BzPgWKyDGXBo2oHnc/MMDLeRwAz4 YsyAyRdqBswR97EXc5kBcymkj42vwwzYR69/iVbAZuBIKrSPPBesgA9AnNEK2A3hMgJmXBGn z+0TTo8RMCHCx6AroBEwQ8hjVjuNgAkiTrdOVw6uhPxkFCE/lULxVBOpfcxRg/r5UJISRpSP C95lCvmF1iTFWiAfNxWnkF975PhprMQg5D9990BAyB97A1frAhDyT4V7oD0Q7SDkn2YXAPuB 2Achf3jOQcgfIcuAkD8C6SDkD845CPmj0A5C/hikg5A/POkg5I9TNIKQP8LuCIT8sagHIX8E 0kHIH2lNBSF/jO0pCPkj0w871fC0g5B/Cr0AQv7glIOQPyL5QHoE0kHIH7OsBCH/BDoDhPxx ZgAI+eOenoGQPx7xIOSPnnZAyB/hmwcg5A/OOQj5Y7EOQv7QtAPP5+YZGG4jgZD/YoT89MsU 8lMlsM9Idgr5GRJ+ML1CfuZxu/1FCvlJKgWiPqror0bI79M7DiE/9tACO5X8HkPOJeWnGmGv W+sdUn5ssgv2oDaclF8gwjw6yinlN2MfubwOXFm4kvLTcaT8QnOdMoUI9VChBpTyY0xZSgnj xGNcXqiUH2mUYsyo8rN+6ZXyG8IuZS0GKf/p+wcKUv7YW7haF4CUfyrcA+2BaAcp/zS7ANgP xD5I+cNzDlL+CFkGpPwRSAcpf3DOQcofhXaQ8scgHaT84UkHKX+cohGk/BF2RyDlj0U9SPkj kA5S/khrKkj5Y2xPQcofmX7YqYanHaT8U+gFkPIHpxyk/BHJB9IjkA5S/phlJUj5J9AZIOWP MwNAyh/39Ayk/PGIByl/9LQDUv4I3zwAKX9wzkHKH4t1kPKHph14PjfPwHAbCaT8FyPlZ1+o lJ9TQfwuR+6V8jMtGfGC6ZXyXzEfYaa3lt8jsDBafiJVioTU2IOjr0bLPwTiiJbfA8Il5fe5 /dwp5eeCam9LgB4pv2RcUzeOS8ovpVWEu3GcSn6miI+1gEvJr7FCrrBcObgS8rNxhPxMIpQy IjH3MGAIJ+QnmjCWSjMKnHQllyrkl1rqVAjGkAf1LiE/0S5/iMmsxCDkP333wEDIH3sDV+sC EPJPhXugPRDtIOSfZhcA+4HYByF/eM5ByB8hy4CQPwLpIOQPzjkI+aPQDkL+GKSDkD886SDk j1M0gpA/wu4IhPyxqAchfwTSQcgfaU0FIX+M7SkI+SPTDzvV8LSDkH8KvQBC/uCUg5A/IvlA egTSQcgfs6wEIf8EOgOE/HFmAAj5456egZA/HvEg5I+edkDIH+GbByDkD845CPljsQ5C/tC0 A8/n5hkYbiOBkP9ihPz8CxXyU0K4363G/UJ+RbSfH0C/kN9H3Omt4/e59T2Ijp9ylSLqZ5nw 1ej4PUadS8fv0cEuHT/2UEw7dfyUMe6N06PjF1RTj5hcOn7suz45hfxUY+oRmEvIrzgRLgsL Vw6uhPx8HCE/xSZHCE0582ApoJBfaYVTipUWHsPgMoX8ijCaYqy1l2eLQ8hPfabLNFZiEPKf vnvgIOSPvYGrdQEI+afCPdAeiHYQ8k+zC4D9QOyDkD885yDkj5BlQMgfgXQQ8gfnHIT8UWgH IX8M0kHIH550EPLHKRpByB9hdwRC/ljUg5A/Aukg5I+0poKQP8b2FIT8kemHnWp42kHIP4Ve ACF/cMpByB+RfCA9Aukg5I9ZVoKQfwKdAUL+ODMAhPxxT89AyB+PeBDyR087IOSP8M0DEPIH 5xyE/LFYByF/aNqB53PzDAy3kUDIfzFCfvFlCvmJFpx53CXuFPIzwT1um3cK+ZmPG8DlKfkJ IynSlPpwFEDJz5gPMw4tPxsUzBE1PyUj6Pmxz73cLkW/RzAuQT/RSmiPyeQU9DOBfYwBXIJ+ JhHXzI3j1PMTRYkHPy49vxQMv3Cle9Dzi5H0/BQxk9Ep9kmB4fT8jDKkU44pVx7GJhep58dU YUM94ZR4DHSnnh/5gUxgQQY9/+mbCAF6/tj7uFoXgJ5/KtwD7YFoBz3/NLsA2A/EPuj5w3MO ev4IWQb0/BFIBz1/cM5Bzx+FdtDzxyAd9PzhSQc9f5yiEfT8EXZHoOePRT3o+SOQDnr+SGsq 6PljbE9Bzx+Zftiphqcd9PxT6AXQ8wenHPT8EckH0iOQDnr+mGUl6Pkn0Bmg548zA0DPH/f0 DPT88YgHPX/0tAN6/gjfPAA9f3DOQc8fi3XQ84emHXg+N8/AcBsJ9PwXo+eXX6ieXwnkqajs 1/MTqv1gevX82Mda4PLk/ByhVGtFkYc8N4CcfwjEETH/EIgjUv4hEEeE/B4QLhk/9jCQcOr4 lZTSoy1OHT81C4JHe1w6fuy7PrmF/EJxj1nkFPJL99B35eBKyC9HEfITTahMtZRkWkJ+wgll qWmW9Om9ixTyU6yVToUQxGeku4T8piMvZSUGIf/puwcJQv7YG7haF4CQfyrcA+2BaAch/zS7 ANgPxD4I+cNzDkL+CFkGhPwRSAchf3DOQcgfhXYQ8scgHYT84UkHIX+cohGE/BF2RyDkj0U9 CPkjkA5C/khrKgj5Y2xPQcgfmX7YqYanHYT8U+gFEPIHpxyE/BHJB9IjkA5C/phlJQj5J9AZ IOSPMwNAyB/39AyE/PGIByF/9LQDQv4I3zwAIX9wzkHIH4t1EPKHph14PjfPwHAbCYT8kxTy 69avf/+8u/0/012/v938mdwWb3aO11+//neCXKCvVwszlL5P7DdAXhmqsw8fiu0PKPnXZm96 xYrdFwlNRSqvsKk3l9n93f4vyTc4+dvqTTb/vC+SP4r87Xpzt3nzObnepN8n/9gv0uRvP19p jX77z89X/77hPzT+z9Ge27+/fpUUiKJX//3j8uFHYYQwzbKf/idJDj59+9k0Os/u7mZ2R/IX 9Mk8/gF9wt0R3Xm738u3I/NXz7AZwoUVgf762z9+/tvvhh37Q1hbAtyB+vk/D6+t/SS3v5in DezlQiW3142nVSAu/JsmEmVYG/zf/37oXW+6T9sytw7+L69bLS0K01KkDuEj3X3qwseo+Xfk cmmQMG4hGabNU9JoSzY3sTrx6aGWYlYhKYUoQ0RoruxTPrj9v5mhkFTtFlmmFiSXCH1rH3yX mGHy/B7Vz8Nv3q3vzC8HvtW1fSszCWhy8zD+kl8f/+P6tkajQogjROcuvFvy6qHpGmFlGloh PRNGWEE1rZ6yBjUMCeFq780tOkD9zW27a6unZDD1N7eHuvbmVjw/tfQjO6BubmXrtcyJ/3q7 yYvdrpb+vv3wkBfNKl5ki9V6uWnMDfvzfbVs1R5jygj6zpXG91n+rr04tl/UmbxJe3zV0wcn xRK1skzHP6TzFjUAwRgrummqPQNrD+Y4I4WL1+7Ea74FVY1GcJLpoUPj2mT95I9tlhdOShtL R0mZWTr+mnwq1rNdtixmbzOzttlVwywdxBlaA63kz6A9rJClv4WBYoVdhdw0NbEsDQbL2oc8 4ChtcBaDYPhc48LCbIudac96ZUMTC4Mj2RCcLJc5ZgZnt89MHVm9xq6wytJE1WIgmCSiZH1b fMhW21mx/jjb7bemzjaY3C7a3LUOthGplgbxkxIzwWZVK03MxfZjtl9t1jvboxTbfqCu2qOF nM2JDbwcH83gmbDBMyFdg3OzKF4leZ5wnDCccJrMVYJzM8Yf/ywTxMtfzROuk5zaF5/wp4G/ aOP/yPBPL3oHd6H5jVkAsny/+lhUhf3QWVwhJMmbYn31+p/XKMn32wNp8AQce3gxeMHp4twV y/3L24NHiguPFBceKS4yUlxkpLjISHHRkeKiI8VFR4qLjRQXGykuNlJcfKS4+Ehxcb+4TPru 2er/Yk9hzTbcFI77wvEXn45SDv68vrbLeOkrZU3jltn+bbF1IC5X68YJ1k29EuUMq8ouyfyT KkaT8l9m4fnkGekTGsJ5xudKtTaDStQfUCpy1ihL1WLgWzzWtf0Pau+JbYy+b0GKfJmRh0K3 fMB5brcg3TgbNGbtgrPzFkcL3W5j6mUMLliRVYXubPZnttrPNuvZ/H65LLa2iiuLOGd0jcKy yDNUFoTWD+6+rE8Js3XlYJiFPbtZbWY1JJUdqHQ9IrSVbnnW1whPl4dAw5o153NbT9bIKktn Lg2WexzUschyuaC4pH53P39v0OarjYGSthptbwqC9+JccBvn5t5gLWf/z9619jiOY9f+nF/h bzszSWn4fjSyAwQ7k8UCyWSwuwkGWCwKtixVO12v9aPT/e9DymVbUtnilUsm5Z5rNLqqbOma PKQuDymdw/vFY9GqsfY1bq+6dEclOTF6W8zpZv20LB6ePvmwH4vbcvOYez7u2XNFnnvX36pm s+xqz1Tv2jORk6r2xee1uJ35Gf6ZTSxVPud+BdIvV9/OF8uZT9a366db/4ZvG+77YNtpJ1Db XFglKhjnT7f309W6usaqi6zsGUmXxbZBVl9Wt4unfO3nL1PfAtO+NS0KvoNsW91ycX+/q6fx 9WTBLNYs3dTmJK9K9/GheLjNpy4R3Lo895S7sC7T+bmbyfsDyISUmleBa8XNXTuvq0a69es5 HlPeG4fhEB2wbYQ0qty1zfzzre/Qrpoevmnpr45+SXDQks2U2pXsUCzpr1nRMweMEHmaG1ZF +uQNPvfVm5H+GT53tMmPh75Ed8V6Xjyu/dqFrm5k9BzESjkt7TbWurqu3HVaujTy7Aif7xQe fToLhPyLH5UnP/pnjCb/UyxXLnm/n3wiGSX/cuyOUCDax457mc27kUJQK0RmlCWaB6K+eNve n3YwPkRVlLHMSkG0DET1K2/hmM2ojKpA1P9dlOXiqJH1q6jMSkd9tYFW3w85jtjPOkx1A5FC X/Rl5a6RLVELzkCy+tFu+FoXj/mX48Vi4uiN52BQb0V7t5w+bu6n/rnbZlB+XkxPUzbPR8O6 JjkvZv5hcT/3N99XbrBcrtaNcvYNVrrha7M8ZYUuaNsMOhhwvalu17u/pvetJx1cj5l8c/90 53F4WOTfvq37eAt60mVBf6yoIePbUJeehI1vASNQ2ISecqMNFaBAnS70VmkJK0+3C33bEf9o EKANvbYmHCxkQ8+JDCXHCcSJvsq1VCplIeECTvQimLAnYS/6cNafhN3oKaTVQ370VLAeQU44 0jOiw0GCnvSAGCFPeiq5G1PBgU6b0ivDuQJkirNM6Y8FCpnSW2E0BTRVyJReKWJVKOGH0vLW lZ4AjDKPFTHkU0+tYirjllMJaIHzfOqPRQr51FOfaB2/FEYCsvZ5PvVH++pZPvWnI3X51Gut VeYSpdWAvhb0qR/FYE0JAzRXyKjeReHWb2diNSB1h8zqfST/AkbqMKunrzayORmlw6+eKlD2 LW5+qC7e6rb26yj7kVbY9j3zU+G6rhChlLQZ48SGl4e20Vabh9uqgK+i7rKKpJqH1yZfoq2n 68VqvchXWbV4eKh1r2uuGWm72LwP9YZIs9307c2RtmVyCWvy1tptyzREpKoZ94G2MyljhITM Vdq1c6NSvUycZsoxeAh7OtYN6oXimSTSQGYDRzvU5mEfifm8S7SGMN5jsQ7UoZqeQEZOH8Yn huz/isXdh/b1/H4ieShv9uYJnRZa53AFwXjGleAEMN2IxxSEy4KOvWgOGAGvkidITTjJGLXE wiawnTwBNnnts5vNOTwBGKKLJDApq5FdCyjj6OAIKqNEMQZkQF0cQUBWeEIUQUAH4RBDoCKz ggoCoC0AhuBImRvQlQHyjS6G4HOJYFIZwFWL/GCE/IAzyoG9qosfuMQmDZxzdtADRzSI4ebM Ib1OD/zcQxgOybYhdkAZae8fdg47CIXozQ1Om4SftYhAHJXKXCJWElDZeNTAcQJBbEY015C1 32tkB0oL67CX3LjX29kBhBFfBz2gGXGzUEhjhbmBdMnOAga9npvdncMMhuIFJDPGcjbMyoFg GROcE2jC7Fo52KYSZWjwxioyg3EyAzcKQ5bJQszAZIwwN0kfYuGAaksg915CzECbTFvBoOt3 XczAcAHlTzGZwdvJAOeay0xqYyWgfhHXCXqtcF4jF7hxydPyjBM/SRvFSsEAdxTCC2OgGwqK ZMJ1TEgSCPMBJSVXA/ABCllhDTECN1QOeDcBdt8+xAmkFpI52iQMg87HOjjBNqNYKS1kjQ85 wdg4gc6sVZwNcDeBZo6yamiH7+QENKPKMnsuyayRAkndXMM4WjAAK6DCWjvA7YTwQ1NwYvB2 SqAcp7eZZsrIUd066JemrpESwCMFny+APKEzlscBQ3wADkuIDPSMlHZxIPDx1n6rvkr49Lh6 ui9uPi7WN/Np8dBnzbCnP9eJEH38uU6F6O/PdSLSGQ5ob26C1n7g7g/ANYTYXwB7hD0S7Ee3 Yf/+w6ewvAyb4JJNgOhHQr/XA76I+SCYP66fEfPYWWb1ocfTaQj6MKA/zBDzyJg/5MXJ/QUR 9ovB3u8hFwR9GNA3zyd2S0bQLwb6dDNfrHEsjU4aVzmCHn12VDx6H/SnR0wzsaGfzzYIemzQ e8t4EPdhxtT8eYGoR5+evmxZ6uZLi0eEPwH8OFOND/vz8in32/PelKub2eKxfFjfPixW+bFd vbAVLtYKs6enNUIeFfKlg7zc3N+f3pQdwb9cf0fQ44NervKPeEs1Fa1credPm/XNlubczJaL +V2BjRG5MTbz4hOCHv8K2G1JvSryjbfOxMwftQX8huwP/9gUmwKBjw78h81d4fedXCH2UbGv pZ25d6lG+KPC/1DMF1PEPCrmfk92972IenTUvQIJYY8JO+J8aZwR4XYkKwfC2CFWbcfgd2Nb BTfsqr1etm/75U8/Ht5aFoUjOl8mk4MP/fNy8VR96PWRN+06rTYPN/6D+t+VnDdQkIttfP/q FSjIn2uI/Pq0dF3Pe8hXf9bdm6u/KZeE+V8YOXrARHJCjfdxpLoKwaWQxrvbU2vFpP+T8YGP /WYHdOjNDgB9ewDjo9BWB8IqRmFazc6dDpTUArJJQWCng5thtzowADeI0FYHAJCB+xwwziUH 6NpD+xxAShTY5UBA9oAIbXIgAP0mvMlBn9qc2OQAsqNFcI8D+N4Epzc5kFQYkLA/sMcBE5KH N18M73GgldYCIFYPbXFAXa0gPTe0xQGlUtCQFUooGW+9BuiAJkSuJzOSCaI4xLct5rYG3NKM UgtKG9foOHDDDVE0c52CGcB185uxKyaZdG2voJE6LAd0ppWVegCvYmhhorgPOYC0lVC/oK7L wnvESO/5RiHDSNCRsEol1miqzvWWRfchWJku4j6k/AYEjEN7Qqf7EGGCg9ItwH1IuHEcaqTd 4T5EtcjcYM7A5psd7kPuKoTMHOJ4EtJBrIcEI9oRASUVG5U1sctRRrkhQRsFGCWvkggwYZTM LHeDFYDrBP2HIAPetVABKMa/JfehV7OAgU3KhZs6ZUYaPq6NzjjhSnuvW80gO0dcYyZgwiVf mSnNOMRvL+hRDptWXEEiEJmQQhOok2hoTqCG2OMsQiKIPyPoN+0O7l3iM4n1O2CcyblwQpBy QuD4MpVU9W+71xblKjOa6HPnhfVCsYxzw/mZFqLNCUGmJOXnFqo+H2AWPOe94Hxgey+0zgvQ ljDJ7ehaE6At4ViwR9gjwY62hONsAkQ/EvpoSxgfc7QlTJBl0JYwAehoSxgdc7QlTAI72hKm AB1tCeODjraEaUgj2hImmB2hLWEq6NGWMAHoaEuYaExFW8IU01O0JUwMP85U48OOtoRjaAW0 JYwOOdoSJgQfQU8AOtoSpqSVaEs4gsZAW8I0VwDaEqZdPUNbwnTAoy1h8rSDtoQJnjxAW8Lo mKMtYSrU0ZYwNuyI86VxRoTbkdCWcBy2hIGPvfMf+0qd/ySTEBu4kPOf1BbiTBJy/uMA6eCV +v5RLRnv45V3wvePkV62fSes/6iRAKiD5n/MAhxSQu5/WvUJcsL9T0CE1UH7v3CIkPmfUK7n AXpN0PyPcaUA5QmZ/yktqAZ0mLD5n7AMUJ6g+R+jVAxj/sfO1BmFXD+ksCRzuFkJ6FLxXD+k FDLjxioGaM5r9Py4kdQSnbnuATJhC3l+ABpvHGN0yPJDukSQESstZHQMuX7YzKNrAeCEXD8k OEiH7wdVFOhfELL+oCajSnALDNdt/SGIyYiWgkHd1jqsP3qlE7T+eEOZLmT9wRVXwSHrWO3a XoDMzR6sglg2haw/lLf+sAbAm0LWH9qlFsIFxOAqZP3hWC7U2fPyVoDsDY8dhwgCkzqT1nIx KntApkwmJdEckGaukx5oanhmjSCQWcdvxiWYutGFKaGhRl4d5MClFUEYgxaqgxxAnYY7qIGA lAPADIhhmVQuxwHtXAOmYC6aMoqqAWyCfR5RUtKz8zgSg4TEgGTSDcJQq7kuYkAy6lIa1Ea3 ixd4+zsJ2k0haAlGM+FgUmeSlTov0JYAO3hMWvB2GkAdASCZ1pYaQCeIuWFAn+nLVVIBbojw TpiupjCL398GFXBjnMwY41QCRqcwGVDaMfohVgogPtrRdg0YcKGAE85tZiQnQ9ABn09o5v7X EgnBFRICP7/n3sD87YzARVKGnOsV21opsERDF9m6GYHj0ZbqIZYKJHUMekyc4O1sgGsjlJ+J cTnA9kEuszCVMaG4AdhfAwzDuXEDg5tpDHDvoF/ZYu4eoCkVGafMDnH/gAGDXAEvwN0Djj41 s24tFKJJcCNStIfDak2AJsFjwR5hjwQ7mgSPswkQ/Ujoo0lwfMzRJDhBlkGT4ASgo0lwdMzR JDgJ7GgSnAJ0NAmODzqaBKchjWgSnGB2hCbBqaBHk+AEoKNJcKIxFU2CU0xP0SQ4Mfw4U40P O5oEj6EV0CQ4OuRoEpwQfAQ9AehoEpySVqJJ8AgaA02C01wBaBKcdvUMTYLTAY8mwcnTDpoE J3jyAE2Co2OOJsGpUEeT4NiwI86XxhkRbkdCk+CrMQnmX6dJMDeaa4DUM2gSLBhEGxsyCYZ4 sV2jSTDVGeWcQGSnIZNgSIkCDsF9QpywB+4T4oQ3cJ8QJ5yBASGCvsAQSX/AGJhbKhhELx0w BqYujgBo50PGwBQ6PgWdgRUxEAfnoDMw4TLoVBxKwltFPx9I0U8kzYjPWgAXpHj+PpwywjKm FYcYh12lvw9TzLEeJo0QMBvfTiU/h1hrjWMoRiX/+dMHjkr+1DO4WhOgkn8s2CPskWBHJf84 mwDRj4Q+KvnjY45K/gRZBpX8CUBHJX90zFHJnwR2VPKnAB2V/PFBRyV/GtKISv4EsyNU8qeC HpX8CUBHJX+iMRWV/Cmmp6jkTww/zlTjw45K/jG0Air5o0OOSv6E4CPoCUBHJX9KWolK/hE0 Bir501wBqORPu3qGSv50wKOSP3naQSV/gicPUMkfHXNU8qdCHZX8sWFHnC+NMyLcjoRK/qtR 8ouvVMkvBeMwMWSnkl9YI2HCzE4l/42A1On6pPyEq0wyqwlAN45S/iMhLiflZ4AYQSm/VNYC JOFBKb8WxgIsAUJSfsuFoVAFfpeSXxhhAV02pOS3jAR9PkI5eCvkF8MI+YVWKmPEXZkAlOIJ +ZllmmWMWcMBqes6hfyGGpJx4sZSAPQhIb9LqdcyEqOQ//zZg0Ahf+oJXK0JUMg/FuwR9kiw o5B/nE2A6EdCH4X88TFHIX+CLINC/gSgo5A/OuYo5E8COwr5U4COQv74oKOQPw1pRCF/gtkR CvlTQY9C/gSgo5A/0ZiKQv4U01MU8ieGH2eq8WFHIf8YWgGF/NEhRyF/QvAR9ASgo5A/Ja1E If8IGgOF/GmuABTyp109QyF/OuBRyJ887aCQP8GTByjkj445CvlToY5C/tiwI86XxhkRbkdC If/VCPnlVyrkdy8C2Cg+KOQ3QgGUzEEhP2BD8ivU8VOmXImohUCEOv4jIS6n46cA3XxQx8+l pEPo+JXrKwDdfEjHT6HjU1DIz60SgOwQEvIbqXlIcR3KwVshvxxGyO+SHs0EkZwAmj+mkJ8o nVmuNaRbXqmQnxuRSasppIohIT/nsLFrBCMxCvnPnz1IFPKnnsDVmgCF/GPBHmGPBDsK+cfZ BIh+JPRRyB8fcxTyJ8gyKORPADoK+aNjjkL+JLCjkD8F6Cjkjw86CvnTkEYU8ieYHaGQPxX0 KORPADoK+RONqSjkTzE9RSF/YvhxphofdhTyj6EVUMgfHXIU8icEH0FPADoK+VPSShTyj6Ax UMif5gpAIX/a1TMU8qcDHoX8ydMOCvkTPHmAQv7omKOQPxXqKOSPDTvifGmcEeF2JBTyX42Q X32dQv5ql3iADiso5BcGImUOCvkFJMjVKfmlv9CpZkJDSnR5JT9lAP1rSMtPRZ/KnFDz2z4F OSHnlwD3h5CeH7A7eEjOz6xlBBynQ84vlCAAaENyfkklU4ANy4NqfmYkZOP6kJpfK0VDYUKJ eKvmV0Op+TXPhCTGABJgPDW/4G6gyQiXjAFa7yrV/FQQ4qC3VlrYoNGt5oe4MYxjOEY1//lT CIVq/tSzuFoToJp/LNgj7JFgRzX/OJsA0Y+EPqr542OOav4EWQbV/AlARzV/dMxRzZ8EdlTz pwAd1fzxQUc1fxrSiGr+BLMjVPOngh7V/AlARzV/ojEV1fwppqeo5k8MP85U48OOav4xtAKq +aNDjmr+hOAj6AlARzV/SlqJav4RNAaq+dNcAajmT7t6hmr+dMCjmj952kE1f4InD1DNHx1z VPOnQh3V/LFhR5wvjTMi3I6Eav6rUfPrr1TNb5QUADV0UM3PQIrfkJqfAjYlvz4xvyLWZIYL ayDhAmJ+SlgfFf0JPb8MCqsnYT0/kwC5cUjPT1UfUE4I+qkaQNEPsaMISvqNYRbQPkFJP7ca IsUPSfopdKgKa/o1EQDBZlDTr4UM4RNKx1tNvx5E088sVyzjVICaLZ6mn0lOaGaVsBQS7Ro1 /ZxRx3+kshaU9gOafmZh488IBmXU9J8/kdCo6U89l6s1AWr6x4I9wh4JdtT0j7MJEP1I6KOm Pz7mqOlPkGVQ058AdNT0R8ccNf1JYEdNfwrQUdMfH3TU9KchjajpTzA7Qk1/KuhR058AdNT0 JxpTUdOfYnqKmv7E8ONMNT7sqOkfQyugpj865KjpTwg+gp4AdNT0p6SVqOkfQWOgpj/NFYCa /rSrZ6jpTwc8avqTpx3U9Cd48gA1/dExR01/KtRR0x8bdsT50jgjwu1IqOkfiab/Hb6+vtfn 4vHz8+39093q++2vnx9u5w/F6u72Jr+db5Yux1T3ZjP3/7nf4a9dJcS77VVMGj8Z54RR9Y4y IrnQ7jj5jjAilH43IUNW9NRrs1pPl5PJO39rouu40OdX+vrm159+/nbyu/nvXPoqVis3Htz8 MJlvHp794LIs7hZu2F+u/ml72MuP7777bvLjyyF/+OW/+eRuU6zWEwfkuph8MyfvP5Fv3/uj Xo73yeVvk1+LxxuRsYzcLHMxmXw26la5n9U08fePk8nPT2uXab2XxXzy9yofbc9231ClY/7y 95//9Ev1d0E4f/+3fy1fXoYSQoWa/vD33XH//h//9se/uJGo/mJGuVN/+k/3tvv5h//6+a8/ /frX95PnT9s6vJy6nH5unef6qTt+OXPvV19mCCums5LNjI+zzF/erxdkF2v+EkuXQuWETOcv 56wW7e8gvmzL+eJwfGFLaQkRu1iz58P3E1vSeZGbKtar97ffYRxSdqqFkaaciplRUzeKvsSy 7rNauYiUeXUOJbVyUTKTrkLV+/Q1lrtYlNXqOCvLfMa25/D6OZxI93/1vnh9/D6WbOJlhfV1 zJe1chniQ3FevS8a5RJElbtY+fLw/VQUxiFffX++3JfXEpqzomIX23Pmq+1Hvocdfi0Pv94d fl25XwvCvL47r37lu076x90VkX90XGGaF5Ny+fTgG+r37XZ6/3LKZNKCV6h2/yC1TsbnlLlO 2e6lzWD1PvS6s9VRrnplu9kPwdqdqNXbClMrGc31LJ+/uk5OVNN9VzNYyVrBSj5rdJa5dzh5 Vc2XT0zrDWFqtZLFXM/J+SXT7ZLNaesIYQ7BDofKorDWNktG8j3e1B1RqqmZ7b9/d+qRklGR l5ySdmvS5jWzO+JwgRFytGSlnJb2eMfbn5trU49eZYrXDdAoSAPEVlHnpy79RgO8JItAsFo1 C8vKmeH6eGv6azNQzakxrVPY7HWwWS65JrPy9bUZfOMQzEhhp8rOi1LbmZR84hrM5uVUzmaU 0tJO9+fyvMxFFYw2K34IxqyYTWdTKuYza2daTGxuSJ5PWVGS3PJpXi8IZZTO2iVjh2AFn9U/ KCvDm6nZF8dBVMqyUc18/yvPm9VsnlnwCeONOpBJ80xSTponzE9cm5Ts4X05syj0pH5mQRoN sK1FMxjfFqaYiUMwd+a2cpPmmdUbu6/Spl3N6kyxR6R5pntjd+bLzyqYO+HQpJ0Ei0w+PO34 1fC8avfdB15FzAuvMiwXhlBrSuN41cQ/IluZI93On26Lx/Xyyz+Tz2L6PflM9zU4zrqEqrOt D1+e/d3g1dPyNN8iTb7FiXD/SsXUnm+1jt/14T3fqr9O8C2y41vN75jtOsqBb9U+a/CtCiBm y0Lv+Vbj+EOm3PMtQmzOZrbgxI0ebb61fZkd36rFKrieHTgSe7+PRYtiytyMace3auWacyr2 fKv9fp1v1T4rTFGQE3xr9la+VV0EzPGHgjb5VsWhisOvXXyroqNbvkV2LeUugg62VWul981R sNGxXrX0K4jrF4U91HsXbPsJk/MDQeLCEcyiyEn9CCKn/EDuTg/2u0/2A/b+jUPDuGqV1Lzq 2c1g1Mp9lm4eqnSjZIwzxppd20V/hZkb/1xOqAdrFLXR/WrRpVSyOB7s/9l70yzJUSZdeCux gw+QQKJ30H/6nO4NxEEMVXkqMzJvRGRl9+4/QBODocEHuXum+31vVxUhkAEGejDMHtOZZFsK mrixHtMI0WE+TwDRCnf2UxgXGNVme1QJB54iGYi27ERUQoSiVrUTda0xnEgWQIG89bAiiHqS CZiGSOXwZ083Vx+FTzOhAuxoLFj3Unz92i/7YHGf/AHL6rp1PtZ1jtv6w364fCu2MlHI1qZd qbbfC2xtZwp+f/34bj6/vP+/VyE/v3x/s9UxdtWJLFX3G4WtbsX911E2fv/hKkn2/zmxi+90 a9hWenW9HF5pqzFiaxUr+aVpK/nR+fq9f5F2fQtqwPAEXxWejLpfhiek4lXt+uvJ7NyloJvV OpQdRiVoPypBACohhuI6tAKF5QuoBI+oZKqj24q3JEclQ3kBlRBTcxShkqmcTaiksH4CVDKP C4xKasAK1BiLlkebg0clUF9iKxAyFmBEVqDw3Rkq8W01hiFUQiV7rEBEtbg1KEcl9k/YqtI4 X0tWoApAJcO/7kIlwSylqKRXbEWFjvZz+ycdfXLdu1A855yln+uhMa5IBhPqRF9zK1Fd3JPr XJDiE2iY9YUNPu1EKLuQQqu1j+J6Y/5Lo9w/ZtNLsZvjSbVJW6djwXjeS41wi2MWSdZ12Zhl jZFTx6yRtrF4epsUsAJD1BeEkLI0vcAE+EkGHl0taHmpm4qtjlmIywlFbQvj8pYrzvJNJfzc croKpRdGJBWV82RUW9jUVRqisW7/n7O1ZFS8XM8cBkSc41mLWkF53SEVC8JYYHpxBXJhOU02 zsq9uOJ2BRR1ZawCYMyWdhzsJlTA5v/EoEUPU2GYmQQhyio86trC9Pr3s9q9fydgJfN/tqFp E2PKmMyXkxekRiuCCOh1uyDtBtCTVvGfE1vlL/356nxjX93n6PUv8/b6g3yztVsHhEkRyvoP iK1uq1rg9/rXv+L187urbqvS1lY1pZp++/aA9O9/v73K7z8c7CZS2TpWm0qV3P5lK9kq+tvP r6+/3r98OsQtKwfXi+/yi9xWczjT1RO+Ut1x5lG+LAJgv/a9kH+9fX6K7vXn2zfx47XnnnD/ +PFV+7aw72wZszM75aLH7P/5P//tetq5gaX6YhVEW+O6H5qxj6/f35xsql4cnK5qKHcVxZuD +d++ffnuDgbc9YcUK+mKk+FtTnX8Ral3/hkPFeU5lAa1Q9W/7WC+2ZpaDconfn79tC1Ufjjr otqJFuMm0AM7Sj+82KRx+lOqJilt3Hnmw77a1vzfL5+vfa/fbVW7fbtxaotLRUhG5CC4feG7 /vjpu0ukq1c+RNkWja3maJ9dUoXeN8jpDDO2oipODKFcd+6QqdR8Lu1sleKw7FaaTlPluvTj c8g58dofC/sulSQjuEHMSaa979SrPae9v/768qa+/3J1/TBWXemVspFuLf77Vfz4Iu34f7z+ 0G/K7R7Du92iZEWJKcFimAR/+s0b8Gf3ovp1hpJu0AEvuPj4+PLxOY5tWeVlw1ozVPz4/OvL 61fR6a9ui3SqGkCV0oE4dojA//EvvoJDRHoyRv3JePpcIaZbofiKQ0Rimv/3W9kTQmCmGRf1 eAZOvl/4BbbMT2fNLZb5FlEq7Ap7CTwhfDlvuOYksszHcnXTGTgu5/UJZ+DcEyIsTz0hgrYw KdSpCuX5GTjzhEjqpGdgXLDMWxRlRl0Nz8B2YAxBlQDOwNH7B8t8NZ2B/b8unYEnyzyaz8Dw EiFXtRmRZGXc9ZWWqK5/pSXa8pWWu/bOjUe4eKWlOmDhcIlNRylp2sLCIS/plZbDxVXpSsug rjb05fpXWruMR1IKKVFuPGrsQmtkd7zxCC9daTnFymY6G+JwURSvtOyneD6PEtVw5Z0zhgJv VemdFKbBpRTXIbwa/2KGX/lKy3drw5VWI9Sk84muRYaQ4EprHLTClVbSiUjU3Vda9qyVS7bv 4qj46Di8gajKGNlc+Hpm/BdK6k4wpaHZLLw3eSIQtRWNanS9RbIOtxqpSq+ICt7c9UNUZfbM y0xAqYBkCpA2VpkO4UpiwEb2IFdafi9YhuUVWoLlR99P1VfFGuOmv4Q1BHUD1p+C+pvAN98B 5KfpbJgR7m0YEeiOyiW52wQzgjqocbtwBDP8d4M0EjUAzLDvYCWYYf8moTsq1OgefuzB53br UwWYgTOY4d6N9CRXjM8FslsMi2BG0JcLwow9njNu7/DftgxmNFQJSrfADMhzZvjXE2CGnyX4 jsruJY2JPrez90tfucUEuBragwwynZwHl3TODWVlx8ac0KggUqR0ZwLRVP/e/VABHDO/l0XO DzKVLBPV/U75MHXOK1bVsqRE5yGDHZLZA3xnP3zZB5lMBdIuE6Ehl0+JGMJKLQjijR28zr1y C5IRTuIhkkZeZwJKBXWmZ6kmeKhA2gtAhU3fHwAlNKaMEqi5puPL0RiBXhUj0MexR2DEtgGF TL+32yPsO3gZKDCe2SOIwqYJ7BGF5ZAb8kinC0BhMuSlH3DYHqG54fUR9og9QKGqDG0JmoGC f0d/T9tKNJm3j3CxDWYJtkf0ipXNdDbE6TkF/IKmLraohl1sI9GiU/84tmXUMenQUHfta2A/ IpNuZUqYbm0Lks1fA6Ejr9giyNhkj1C8yyTbUpBc5fsGcxdbaVTsYmsLni62Ly/JEB3tYksz BcjtEUIajB/YHvEnuNiyq8KTUV3vwIRht0MtSyYMsc+E4doqmDAqVbEKRCZiwYQhchOGf0dg woieV3MgURT8wyvWElMK/klvSvyxoEMMQCbu10hRUQ6aMMT9mDCGbZAwJWs7+uO4HIdM9Gkm jD6AB4Ho4hQTxqST8+BuMmEg453ngoLpnXW3wYQxvTdWqouZMBTfdttR7Ga9hC4USgN4vAmm dLZPAuedk/pZX9n96KLYGD4BXSx0Mx6iLejikgAshTm5Jnh0gao/0oTxEMCiuSqwGD13H8Lu oQ+we+gFu4cG7R6qAfwwXHk7n+9jdIEY5lLzjeii98NgHXBB4g/lVBDa3LvdY6qBiSb4BuhC Ldk9dGr30LHdox/ieNsyuzbqdNeJvvKw03sZqkya4rq1we5Bm+lrljzKxKLdQ5XsHr3MF7N7 bI86iITfZPdQmKahxXS73WMbMtlr9+gF0VhKkU/e8XYPN0RH2z2aTAEgu4c29IHtHveJL85i kiM5k1x9Bcfp3D30IZnkeM3whZjkWkVBJjlX/mSS+69NTHJVI2jrabAi+LHdP+MMJrl+nu6C Sa7XynTa58YWmORcLy7GJGcbu1MmOSfZMpOce+LJJPe7MsmN8yyJ0N7dY8RKqJUy9wQiyRph BEAzengYWOjxf7IJ4I+RrXngbxbYPs7IFPo+krRNwfFi+Gcexj3yDk0qOYo6BvRPiHOUDA+S 4UwyPIZCj5LhQTI8SoYHyfAoGR4kw5lkeJBsosPDg2R4lGwaoVEyMpSQTDIySDbto2SQjIyS kUEyMkpGBslIJhkZJJtAMhkkI6NkIzkBGSWrBsmqUTIYYN2aSY5UoqVT1PLPtyFumdAwlBOG W3TrLdJkaxDxLdLIZ1W1E1lLi+J3ZLdIAQfWDLQaE/4yO0+JrGVsi5j4Fmkql6eQtZQC1SZH 2LnIk7WM+rGVrMWe37QOgVbwm4lfrkTWUoq3sa2xYFyOiLcJZqlE1iIr/jKu+ml2sukq6MnU mB08QkSlogsn++KazDQX44Smig3e1bi/mIVYnUExcl6ZhUuMTHGCgdC4qjMWE5BdolfIXNsy VRoLxscKE9CR+RYpHm9iWFxQOQIHrLX912I3h+HF02vzyQvmTFJHAAo35uItk9k0CYrGbGkC grqOs5pPnWDENh3WTUWd5nvlfmuSjC4R+/j5aRepd/YX5I1NgsRj1gJavLacfN3aiDbpZkgj YyIipWCKYD2DiJRIPr1RAcjKNNRtCoLAi9X/QMmSXk3jHcgumCYprEbpdfFIgQBxLiW60rQb utk/mhna5oIRAWbglWaqMY4ZWVWr7ImyxzteHcTimG0la9kAe9JK/oOyQNdiFXGRr8Xvw66+ 5+v4Jb7+8/rpOBw+XqvXr/pf/fXDN+LoVJqmLITdVBeEkPWSDP1m5QlHfrgKr3+NnDGRDD0B SZG54gziGafuAXfI1y9vWry72j/+/j/3ao7dmxf4S04irjGYjZX8a92s+7F2tllSnHBeVyin rjEYHUZd02DGmmy2vxJXVzu6FVIk66iFrt1Qma8/P/72rxZv6rX7aXc0x7hSqSUyk7qr/JCJ b+r1i63687VvxpF2aNsV14C3a5ff3nr/gLmBL9+9q8BEdeIt6tpZ1Ouisp/Mq7OfvuU0Jp7G ouG50vunfPXVfK8WuGzOJ+E5l02nYQpg08FM3QudDrEgwQ3Sh/xbq5/9/UvTenaa4mycRKjz uKQ4J10dncmkg3ImnWukFkoNFwhg0uHuqm7RQsG3M+nY1mQj8GSgyMBM4ojS8kZYBQXZZH34 Ws3kS3IT1NehAJNO/+7QQBG31Uw3QXE5lRc0UPw+TDqY3ZJJ59bsy26FN9AKR+EKX7hC3eO7 RXr/pcB3a2Z0jQmYibLfnIBTPFoyrWiVRYZtumQ04bTVOFsy/oenS5ScfKrVEIcOGe2Gv/GS uRwBszPIoENtesEsla5O0YUsGpOWTEPnVBA16w46F/XYhWwt41oYC6ZFEFXEZktsdf+l5GJF EBKczvuR4dfuZulRnG8k/R9c9DWx0i3YQfd5Cm3bKItQ6I5IBe0Er0Ahv01vg0LTxCRQaFog O0gFr7mvx+X8knc197ivPyKpYHVVKJTnH71bZ3bD9AGkgnqBVFCDpILInBTEr8TawglMjsUg ftJhbQ9pelw4QZ2b5slilKPNQfx7vMlOcmYfZ6lEKqhTUkEdkApOQxwuCiCIf3yPib/HdUe5 jO66DDFRHgL/y7/H41/Kzuz969ad2evJtSKFLGrBmX1sPeumD+JPL1dnUXc7s7dGZZKhKFaR MJ5ftcAeW4Ez+1CAcOx/Zwt2BvEPgpBaV1qxahe8nd97j0H88xAlPERXd2avMgVIG+uZgvTj OrP3K713Zv/yrp01smsXbcNPEsEHJhEkHaFGSg7AirNJBKPnKRSBPy6rtivAipRE0O/iqhiB j1oqvA3knkgECRGkhUgEnduvtjtzjMevHSO3mUSwD7ivO7LoOzXoFQwrmiR50fy9DX8RNIC5 gab3+v/LjI4LQkVKd6YFycLNPAqaj0TdHYF/NokghaHBGF5u0gh8sxyBH87mTJ9gu2QYYp0g v2EEvjk8Av93JxH841gAj6PZsXtP4SO/kQAwbKvwkWdj8HhOALjwkWcgzY45hSkYcSU3fuQX EhK4p7FuJY4JAIO+3OgjX2QKRgS3QdTrQUzB4yydwhQ8JxVI5in3AdxGs2NOodkhzBTyZDtF Wv/IT++dd+OLMgVvJfE75RvjDduh76OzpktEVoHRroINjdn3akfZXfhyT7+m5IYM3VUFmuCZ gulWybK7qo4efGlHoY98pAmXI/F7PJqdP4+K704uGTbz8WX6vYcxRyww5giQMUefxBSMWVMA CnsvGZSUCR/fHVwypCHr47HlZkzBeokxR6SMOYK3+RDHO9CZjDnjX8bv8ymXDBm5X6J1Y2N1 U5DMKWG6tcWqXbxkiA7/RZCx6ZJhK5dftkmsXDKMx+QmtSQ0T6bgcQKmITqaMYdlCpBfMlyK y+/JmLOAL27PyHecDULpkg1iIxlf2FbBBtFo0gd852R8CzYIDdogFHTRMJDxwVS/uiFG91TD ALSoQBsESMbnfnWDlWlBG4S+3UWD3S1Aql9MSSuZPB5aqE02iElrom07/FwFN5MLaCArWIIH asNFA2a84INgWp7BA9AGobKLhm2EehttENsI9YrdZIvwACbUW7DAh//9Z1D9biTUuySCajI9 SzXhcoR6x9sg7tD94CwevTrn0SNX8BXOvRYekkcPc6afPHp3wqM3/CV3Udjj+fg78Oj1WplO +9zYk0fvyaP35NF78ug9efT+QB69Y4Nu+UWCbn0Mecuz4KxWNLqmeLLRTOVrceqtqCOkNfL3 PINucxtNIehWYZ8e+8ig22CWrh10O2nJJRpbrzuROkwFXrNrwHgxrYX4UVyXGytLNtJTrIia pTxu28NdO6aCbCPZ3tgua8KZQbcA/8g1gm7TDR+dxj+yPeh2N/9IrMmH7etx+Qn+f+ih9vUn /8h+/pG78YcxjB0QdMsWgm4ZGHRLDJBByj/PO2DhcFk1WlZ139bmDFKg46xrC1O745Jx4QQQ 4NL+MJdhFr4dC8lC0C1Lg25ZEHQ7DXFsDS9kzu4oQYDTbfg9jvxVW0TtHk6B7/FosihfeE0U OKlmJ41VqpDbEpGoV1nQLSkF3W51ut3kDyP0aZmzN/m6DsMbiKqM/T5eyaOUEoYlUwqazcJ7 kydoBG+V/cRvkazDrUaq0msQFXL76YeoOgrFDz+cKUBmK5oIYs6DqLfzh/F7wTKXYIWWuASP 9o0hV8UaeVqoWwbhEgr7xhgmtsGMoA42gG+M/W7YpYWhIFz7DlqGGaKDgnCxOSE+B9MqSYPt 5ZKca5PAjCFespgGm9NG4QhmBH25IMw4Oz6nMbRBXFeBj91xQbh+lpZ8Y9KZCzyF7R6+Mw12 VrAEFbBZ940hbqDDgkiR0p0JRFP9WgiV6oK+MUKfmQb7ir4xoCB7PpmzZE/fmEgCGDRGabA7 2yf5kL4xj+E1e3vqrwPpOZoSMtjI+hXUQSVkYLCWIDLQC8hAg8gAmRI9By7Tc5CqtwJuo+do 7QIrIANCWVPXMetX0Jd7QQbzZ9Zd9Z7M+jX862msX6dF7uYcV8MP2LHLQCDTyXlwt0XuNtNl OsoVaRMyQAky2MrctQkZBMxdjakoxoZ1MkoCJJiq4cO0BcNVRDolaGM6Htd1NqKpdYK7isBe HO5HVfiontyHhp+ocb2F7RWQzLfeJPubTvlgaWKAcIIg3dqTzXThZUZPiHDMdFd1Sa6jJWQw OF64fG2aGYorfTAyqDI9SzncLsfc9YzcXcMIT3aPC7J7WIzAW9nT416a3SN6ni9ReJHS7R5I 4SXLFF5M4RayHtyS3QM3Xe05p16y273OIFzH/rFHRNassnuke1jBnABaDzKNG+uUQcOkuUOV tb275vFXZfpVcQrD7eweWwNvN2GEs9k9qkXrARx4+7QexEN0tPXgN2f3eAjrwZPT45E4PaLn 1QQvYx+GtuJaN1t9GDwsb0F44KAOMlWjugge3AGnRxkeqEbw5vTwmeM5PaYhjvedMzk9ws+0 O8rvsUdMmrKR04PV8MUEqpTJoEWs2kcQh5c4PcZv3y2Jw7cF7W6SLIMWsq50nq33UE6PeYiO Jg5/cnrcCb64PafH3eCLjcQemWrvwRd6AV9oEF8oCF8MxB4wvhCiEmwgBN3qIwkSe3hTCrGb 1ORcfC/4osAZRpiStanU8eYHtYQvdIovdIQvhiHegS/mTyOqQceH7NN8Ir5QmzjDJhfJdKvu 9CK+UGV8odEF8cU2UpCFD2/wrUxNF9Ko2HRhC56cYeMETEN0NGdYkykAhC8uQwryxBchvjiL HaTJ2UGaKwQ15bDkIdlBhBrqnM8OoiQG2UFc+ZMdZA1+9O9QTFWNpoaM83UgO0g/T3fBDtJr ZTrtc2ML7CCuFxdjB7GN3Sk7iJNsmR3EPfFkB/ld2UGU9v5V/p3uf0EB6clAYsnqNlINgqC4 7fH3MtFxyLFgarp/51gwcYDkszn8JWGix9GMkKj16XcGaMNJN5v0cBD8pXgoGp7geUGpMZE+ KmLJ2m0JpsvdnNcIq3DThqcFzVibLqdJELxifJS8btM1MjUGA6xbs4PcjbnHMMKuHxJLurJH qv1bhLdG9olSSOxSwjgjS+Yempl7UK2rBg6Jre3rSdfFPK63N/cUc8ko3NSByh/hkRrMUikk 1ilWNtPZEIeLohgSG3mzusYsWAMOrAsfe5P8Yl2DvFlXtjqsZhNBroSh7LO5J3gdaKGJeTYg UffkodWZZJsKNuzoPsmK3GBUuagbBtCYCzwVJOBk6SVr6/gJHND0tbzhFtds4VUZSD3yPDTJ VswBq1YvSHNwSCzKFGBHYw9i7nkwl9Yn+cbvRr5RVzUzdacKSAN0XIFjX9xnUIsWq+bOkAYh XPnrjJf0YqlSLvjgYMeVs8g3piHeizSGUB/4YikSDfRrjT7fEfSYVslG8g3ewXEziIyC7CXf uKjjSol8Yx7E39Nx5Q4uluYhOtpx5U8g3zgTadznvdSTr+N6fB12w0WtZAREJmfydUTPK7EQ cSMTvo5gze7i60ACSbsl3RdfR4ZM5iqaN/hol5eT+DqygnTTgM/z5Uz0JXSxha/DJdSFJXOK lO5MIADL+TrKoh7P10GX3FZcRvgk4sbcOpfNYBG3kucJdm8ScWOefB0AsPjdI25uzdehOju/ VvQf5NvrX+bt9fP76zfjcBdF0nagrc/HBpkapthAtxVvCYwNajbei87YYGDtt8qZce3an3GL OsMGwztCbADVyRg7qmtz7brdbTq9eGwQvZ+iesQGYFv3xKEujCBo0/3IZSlD/Syl2CBUklFC P81oaWccn0g/moYhIqmuN22zY6YGN1BqVuDYauH6WLYsz4si+KMXDsQGvZ6UG3NP1LHXr6It AY7zRJlWtdHVe9VxzKp4iHDTZe8vSDa9d6lX65+m3nN86tXYiQ4tBLWMw1z8aEasqoor0say czYXDFUKbhoIcFQiq/Ndg42BI5IPUSi7kEKrfMyguq51XOzmdEG23s0RBGXeXtNVzvh+UmwM 6FXpdeMPF/Ss6/aOWaORKC2nBsWPSmHyUU0HsdBYEsMPagKO19eS0q52U6RuGm1JMmDMQo4g e5Rvk1gBWw+gKoDWJuIUMLpuXpuKJcPLk7WZbCP+twuUboY+WUW3dXqM+Jf+7Kta4PMqpMOn tn7rICah5ep207LVXeUf4i/96r5pvhkria0uXMZFUoS1fptyYou/HD3tX/8KJ/lfveSuqinV 9JuEl9sR3crvP5xtj0hl61RFalu/SsZK+tvPr6/vWihbUTqjIKnK9eyS6Tl1fa1f718+HWrH zKF2XBTSa5it57Cuqyh8LYMR8ycFWQThXt/6WXn7/BTd68+3b+KH7ea3b9/f3D9+fNW9BH6U yhbFphWkc2j+7V/x9YuyArw6hP3+/vOHS4hZdbZ2U6rM7FoQ/aHjP//nv934dm6cqC5VaGuD tRfbTUivCz8/7Pnoq8vOQdwpoqiIjDOmAk3y1tZFU+3ZqisrvqC6VjkXdVe0Na4HouVhcl+/ vzm5Vb2oFV3VUPfiv8WbO2N9+/bluzuV+beRsr4bv9Dc2/62qvCmP+xBaRBc/PzqZ9MrQ70g McZNoMZ2Xn/4d5PGLZtSNUlpo4d0K7bm/375fO1Ff3fKbNys4rY4zEI2fl6d4PaF7/rj57d+ 7ajFZKzUNunWnPxu9fV/P18/fn35lH9Pi04Vh5dQrp3KC6Vmo7/T8wWr/d4anabKb7efrz9/ 9KvKH62JXJx5ijhxC+pd/3j//te7+NabD1xm2uVbiU420qn6v73RIaf0Jk7XWbE6JVgsc4L7 a5HixtkZ6rcRpwJ2/3h/FR8fXz4+x3Eqq61L1WOgVD3tplQ91TGpelLTAgJS9QhlVqJaEvvB Uqoe7+vTzVcLGbKArxam4/AWp4dWNFQxNJF5xeWw+WCQS47mg7gcT04PJbn+yFQ9lQCuFqL3 XzNVT31Vo1ueDfpuvYWwyzNZWDiXC0MnC2HoJA9Dd+i+SHOz5Jfc1l1h4YB3cnzBW4g3mr68 3JW30L44sCPu5NBSGDpJw9AJb/MhDhfFZm+hAv9+eLT0P9Du5n+L93loSxg678YIF5QrYSh7 6i2ESmHoW/n3N/ol53l/txTAni8b+fezPeqSl1UP4y20j39/Tc+WHi2YbgIFSBvrWXbbp7fQ Xd8J3p6f927gyUaS3mxl7IEnbAGeMJAlxxThCYdY+MYediV4AjgzC60W4Eml0L2FTWFGuY/S zHG9auzWdxOS3jI8YSk8YQk88UN8EjxB8qosOWYTS86U0T11N+oW4ElOHxwq5DaC303wZCvB b7ZJbIMnMMHvE57EQ3Q0PKGZAuTw5FIEv0948iQJPgCe/CYkwXWFeSXYRRId228n7xRRB8CT iyQ61kSg4xMdn0USPA1xGZ6E01fjZC92xpix9TnzcTLpu5IWTZqykSSY60L+AUxPJAm+aKLj EknwasGGr+PxiY4lV6KDZvOZ6Dj8/QkkwffNx0dyPr7qCjeXebjUQ/Lx8ZrhC/HxtaQC+fhc +ZOPb8s9TP+TraLk9Kjtk/n4+nm6Cz6+XivTaZ8bW+Djc724GB+fbexO+ficZMt8fO6JJx/f 78rHF86zx6xZgWsL9ZR3bjByHLQd5ZCk9XwQU0/78NGhoCJV7QxokUmN1stkA5lko67Y45bg Mg/pm+YbY4uPmmJjpF7ipPK/ZmRknjrD00ND8Jflxiq7qUcFwWEx7+bUiZn/cBwz1PvDb5lN 1QKC4KjAiYUCs7PtiWt9tBzCAOvJx/e4fHyw5YYiIgUqOoyxyHIzWFRq1c4YKbTcaKOrLskQ ffuLJUIEIR0C8BZp2iZN73Tdi6Vglk7j4xuHOFwUZ6dfGF43pTI4xXKTEfSNv+wQXPB7sYpY sNyMg3ZE+oVT+fiOSL9wHZac4XNMJL9xeqfbpV/4E/j4HuJm6MnC98AsfGW/WkxEAV9ULy+5 X22Rhc/Yj79k98fCB+CLm/rVnsHCNw7xSfgC3wELH24L+MIpIYwvQMlihbwYviix8K0V1NBX HHBc6VLHle7W+GIQ9X4cV7rD8cWfwML3EPji1mQ5oqkwioNB+1hQ6ga3ocvYgjfr2CLY0Byn Bk6wxUxfDmOLiUcGwBb1GrYY/zshIEi5cua2Uq6cWmZcOWlbO4Ldppiduchz5YzTtBjsNsiF rVZTMvAR7gx2wwVscRGunJpWWJspmPNIrhw7SzC26HlAgl71TCHJsNSJjjYQHBhmPZmGeWfF 44huaGx4bZ5IJpcsLSh0E2C9yBrLeEhS39+MO+VEppD0NSFQOZcpZNUgIJukQOeo50SmkJYr fgxTiNbJ8O5gCikC4mnyZqvKOJshAY6VnWPAVaoVlNfd7PLaC8LYLIgvkMCNTY563Isrnjbm wDRO6s5AqaUdlIcSGN6wgMz/qUNMhXEtu/QOq/fIEk1D28L0DoKAzlTLkgWCEB4JQnEj4/fj 9K60KMg27B5JFggidCyI3dZiQSbSoOD9AIa1gmwPzgveTwU0ZlaQirNYEKJyQaL3K7QTmG5F Pnm901hg/O6RscDUHX+ywJz/Mma4JBMJjKdDcSwwjoVFOeiOqSrO56EELp2uOBne5vlqnDOM 5/8YTxll2qLH5X5hRALcLz1Nyl1Qv7greNc/+bdWP/vTZdN6LpXyRJ7C/UJwg5iTTb+J7qvu WVR+fXlT33+NiwJXXemVj0r/ctKh+vfhjOFGr3he0u2cMdOXNOGM0YQbO9BteoweM11Bx2jP 58JFRjk75b5KOWPiFFg5ZwzvpmN0XM6vTDkbt/XkjHkIzhglJDcQW6Hf39d4mjl52WR7Cn/p ogmV4FyiJbSDpzn92wtge2rqSxIt1SWe5pLtaepLksMBNRTXWxZN3Bd+kXutUsSTFJXgZFN2 qQvbntwswTkcPC/hJOF2EmLYWuFHPRvSTI/SCSweScmi+QImIQYvyXRm82oS+1FPQpy0BRiy hr+k9hvACLbZjhLXLZAQp7KDs+mJRst2q62NAYFdo8FjEnUMc88Ggmbd3GE4jCXruvKYbTAc bhyzRtrGYi1uAF2J28Z8Qc8SOXLDYdx6uyldZ/9rE1fvlK53ccw2GA7X7Ci7DIeZqIVdIzUc NpDhcINdeBhulCpebjhM7YUAhbcXJDUcWl3JltNs/BvthYXGgjQyde8c34XWISZWugmNSGiv k7F1qlaJdWqOutjI07wR+WT1/iyaZrt9AIY2Wd27nQ0z1mTD/JW4utrZWUjxjP4wdizWKeZ1 4WfeR285weU+djVzym/etY66WPvsN6xsf3jazp62sz/NdnamGazOzWDoCmaw9LCPQOpkfknq ZCFrLurCiR5f4kTfm8EEYAYzqlPT2kvMYE6uOStjXM7ry53on2awC5nBbs9NeFAmU8eFJuBM pptpCcO2GiiTqf3Odrq3tOW0hKzM+8NkZgXrCe/ATKYYLXh317TjhTWzgzXZ/zqG2uolt4L5 voxrJvhEHeHd7Vw2hUKxFawxXcMMoSZbM8fQEi5nMo0AxibmY9AG4H+5UTfTyXlwiZ3fVZcR wiSNCiJFCmWHM5lO742VaouHNjhmaSbTrdSCxW6yRQ9tmPm40BjIvHC6ZIVMpoOosId2sbHr ZTLdyHy82da0oSA3daSacDlqwRtkMn2yCj5ZBft37Lxjm8ovzSpYWEMAIm+ajehimVVQ210W iy5CF7ePHQPRhfvtuGOD0MXwr8eyCo5DHG9b66THCySCS6THS8hEg8hk5RNCmPer9L9cCdOt LXvd+uXTHbMKTifp5IH80u2Sn92TGpsMBVNBbCFYaqw3jeg1ZkAwRG4yKmwXdfydMWZ/BKvg efDkaKTRXBVpjLRRD4E09AFIQy8gDQ0iDQXxF7tyR9pURBpa0QLSSKPUe6TBZptIFqXe8ntj wclYB8cDl6OFkfO4HGfHUEtIQ6dIQ/M2H+K9SKPv7hWzP/lurUepY+1DSXqdz5RwCWmocnoF hS6INHgm2ZaCxFzjG4Si1HEapY6f6RXGCZiG6Ogo9SZTAAhpaEP/XKRxn4aQS3MmN0/O5BJn MuZMX4YzWZAW5Ez25U/O5DX0MvexrdktOJOHeboLzuReK9Npnxsrcyb7XlyKM9k1dp+cyV6y Rc5k/8STM/l35UxW2ltZ0eA6i4IC4v+XSFa3kWrUqM6v6OZbTBfZ4X7jP3MUPko9djxrrOBb jqMZIXHr4+8MzIeTbjbp2SL4C7yfzU/wvKDUmEgfFbFkLQ7OVKd0c14jrMJNRDytGWvT5TQJ glcYsCRlhpYkgwEWygHWNUIjJ4NPEWC1ohFqDWA1+wAWl9Qe7rSueAKwvFmhO5MkeZyaWlda GdpG5qHgHRDA8nXcpy0BWH25iCIkG/s3qWiFu4Xsm+OFE/qPpI4qAKw6A1jTn1DFYoAVj+NW 1zBdtYbZY/0lABaUfXP4ZGikTr6IOhlgjfMEAKxBpQc2DWKcUYQZwoDjcapB4B5SazOElPQr RQhHjQ5/o4P/BvaQXmgTAg1EKyJSQVDyRMV4oTFTRY9qwQNq+kYqXbctihWS4/JWGXVCVFhV yevq6HWd3SxlSbImftT+97wzUiR0E97RWOCjukYB0UbTXIUz0jVEx71qDcqQzwr2jpYoOBDA ws8kGy6L+kctTnLeQvHreHfiBGxofcVrJh6ipJuRxUg69iDD6jPAAnppac0F41bFG95RGkhm MSuXRtCuwxgbPpm9iK2gemNizDWEXwivO9EJXKuO864JJOOyRVIKYtel5JUI44EQtsObHa3I i+O9DIdmbswF+IkhHwKmrjFHoxT2ao49qujQ77BCFwD5KupEkNmsr4nMS1wzyY7mHsqMan1N bcZu9jUThh/ie/ESVpBNZlb2NTVCYV0y9P9lrsnJ8ISrMF1555JNI/cy1qQDaH7pa045gvvX YTSPXNKYJu30aFyzoi+Mqa6iHRn776poq7HKdJRjI8aFDgOs25NGH+RRbP9nKtijeDNfdFCn p9NNPIotDBGi66FOzhdNSzdx7jYMiqsnBvYodnzRANSy75eSqq63121LdF7ii/a/2n7QJqiV 9uXl7m7i8A1u4sZZOsyjOCswyW/eVIt80dNe4ge0o4XbtFbXkeywR/G0FkKluqBH8VbO52I3 nx7Fj+dRjDM9SzXhcpzPT4/i35It+khggZsSsNC7gQUqAIuOKkZBYKEXgIUGgQUqAAtsvwbF UCV7YC65+IChSqIMLHjTdnGK8qAvNwIWhFiNgQh77NZJW1YdmegqmKUlYJFufAULDggs4pkq fa1LwAJtARayhYGFV6RNwAJlwKIs6m5g0RqVSgYOYrGbdNlNx6RuOmY7sNiWTGIvsBhM+AjJ jMnmJsDCDtHRwKKCV0CgCQ5YYKIfE1g8BDJI4/zRMXH+2Z1OZc/Lot0S5+/udPDLDqcZrnsX 1vBOh1S1cTwxKR4Y5ImcZqY6La2Hwy7gNFOTEA/0nVIuvDbHAyMv0fB9/cjKSYwH3Lt57W5u I0PD+LfK2QvlEFZ8gTudsS8jHoi+O+CdDpvwUx7u79u60p1OITHV9e90pnlKEcHwJx1aFiZd SwctG93i5poyqdUo0Zgu8gghDW3TONDpUdlmWpXv1E0glVsVpcY40FhUQIP7qPO7qZNuNk1+ pxM/utRNvCBZ1Fh8y4WJuzbIn0haT5kKp0fbsLGq6zTm0xOZaowjAzfWkXr5M4uttCjoJm3A VAgjnph8NuaczcmQidKHOJtN4NECmpn/O7+IHMZMxGOmMQ5QlBJNA8TEpXaL8Mp8bowau4no /Imt3TwsWOzZ2J03BgOsW7PEOB6oBuKBQiEP1IKT8p7gqh6hZWm6fORo4J4cxsmGSCsb6ZRY iRulZc4vLjCTTFYR0or+JrBMLS8hEc1vTKx0Mapk+3OXraPCHUSVPM5SyTkZXWj1T1oyDR1v Osza1bRRl91KwLQ2yaPTIohkt9q/QbI+aLiWK4KEFpBhZG61/dJ8I+n/MLOYlBvbZSPYtlEW D9L0GMK8dMNHEGFeLS9HmDdNTEKYNy0Q2KKehZ2kbV16X0/KL0iBf5f7+mmEeZjdkjDv9rw2 xxHmaVkizNtIaRO2BRHm0c7RMsvu5QWitFkgzBMgYZ4OCfNKupmuGSYGN5ZszVRqXDPz+Pe3 Q/CaqSimnL68ZLdQvi/jmgnauimlTdPUnaom17xDKW1OcW9ZoqXJv57j2Tg3/mU6OQ/uRsI8 o6KCSJFC2YuEeTohzIuYZOyqEBUWVOhkKbLUsFAizNtGS3MKFuq/ZQDnyv2da8c0TgB+XEXF RVqaDZdt/RBB4TkbG1vsVakAvIeNNOFytDSP597ypzHS2KFuVJ+rQHuy+O+/3uy4iTf1+q6N ftdvso/OD1m/T0cMbaxOJEUMniejruoRMSTPT0mYVKGtHjGE1vyEYpcYZs/8VNfzV35CDMHf AMSgmgpdEGVvSzQ1IYMx+RCAsh3QLaDsuS0KtnW29aSU5LzRTOOmHeM4j7Oe+FmCEQPjjKlk RnnkptKnooqfEPCnNM5a1Q/2SIIb6nH6uvwjD+Wk6uc0ncxsBguSSVxKQz4+0ZH5lmp8Im0s WAxDYxhT0yr7ry8eNAV62z+Bp7ctdXO939GYUQQFvoxs6ON/myjBVg+LrRJymj2x8CkNPofu HyWXpkkyvBSSE2sCpGfjo2PKM6ixQu6zoG4vSPY68CPf9wqekX7MaiPyrz7JJTNpQrNxrqJu +oRm0RNQpq+5bvLeOtXiZmE21yYvaz3P1gUuJ8E0wVknoifAlGelbjb5iCRPZBMAKG0599lY UE55VlTaRIu6nFMyT3m2dQWkY9bIOJe7Gxlg15jqpsOba2L6xC6oehIMyhpxH5ggn9FYoUyJ dHaeqjOr2y/FQpor3JnlPFfuO7JQX9ZL1fv92edT+vHqE3yNabJeq9ev+l/91XWBUddGMZ/5 uSNweqYuty0ESY6+fnnT4t3V/vH3/7k3c+zevJBo6bRMX40EMn3hajEh0DPV172n+nrgtFuN 3/LStFuYqWferT8i79YtctY3x+SsT60nCMpZ79T4wnePk1UkQ1/gPUo9Qh3o7jGwigxSiwY1 wN1jK6iUSI/+hdHdYydq1Rk2WUXi8trfST7vHpO7x4OTdZ1FJVnlXvHVFRZUHjj3kFSSQg11 zqaS5EpRiErSlz+pJP9rM5WkbHHLjqeSHObpLqgke61Mp31urEwl6XtxKSpJ19hVqCRdgbLv MjSQfbdki1SS/okzqCQV/kOoJFPJHoNKEuzEvoJnY8/GlhuDARa66jXvdC97/4lHDDuTWRIq z1gJCBCFGPwtwlv92Z0bIPGIf55CrAQCdZ1SqJWmcI5hI94K2tJVA6c4Yw1DrNIx3dHtE48U /cEUpjJQ+f14az8rQTBLcOKRXrGymc6GOFwU21KcDVPHc0aDhY+9SX6xrp2Q4sx+TfWk89Fz pC6lOAteB12UCc+8l3UiV7+g9WLikdaz18Fwt49rI4znd1swpgkYDYYChGOEKvYkHtnGaLBJ sntMPDIP0RKN5IZurj5amN5AAXY0tuuC7pl45JpeaDcmYiTOlmrWrgJJZaK7QBinoE04JfcQ i3DK6BkBe6FFOCX1UBtxSt+7yYkmZsA+0QvN091VapPfevYB2mxv9V5ok005tLd695OxTpXI VZv6ZYe91Yz39ufbhYoxfIo0skKbcMoFvdDGWcpxCmbEEIsNF/fRJPFoMoYvL+VHTeoKgRvB 7H+H5/neoSjfpTPPIvtfRJJIVCIN72ZLg93YKFmWrFRQ9j0Cvx++Y+VujuJlvkcgUCQmdLmZ VDdprM5kL37ZyKpkddaZhc9k0AkhBZtzyE1PhI3ZaQNcjdJuFtVqkmzEI+XUbTQVJHegKh3o 8say8cax7IDv0dIEhGPWaCTixmgTj2ojRcp8kXlKhoM4/qX39Q9kN2s+hTheX7lqkO3ECyI1 y7Xt6pilnBz9QqOojTwlMbcNsGBtDv7BIYpxjiAbsF1hBSiWjCovrc3UITRqfSpI5iyXbPxL qN+2ExzPWLoVlNddOt8sNUy7n/+LzAWhwenGPsXTxuZz1yaQexoMSmHgGT5NbrvJfJJqsuKT ZNfbWMk7nrxroZz3lwPlpOh34lch5MvkHUDKrjleVzNfJoPRYb5MzK4Q0SP6//yf/3ZD1Lmu 0uKM0K4TyDu7+Fc5oPz+/vOHc64gaMk352T/pf1eMid5PHWNhV1zpfdP+eqr+Qjyos9Qx4xx aib/1vKf0cHGn65cx8iio1TnvNmANw7OUQt+Sg/qYHXCTJ7kvIQp4sRp9bu2J+S/3sW3aUq6 5dP1w3ounemEhI8hQEgPzwgiQFAXdELqBNZNIzIChPFD+gIb76dD3iYCBEFNWzeQExKr1bSF J05IXq6MAKEv508CBMgJCd2UAIFc1ayUJ6a941svsY2LG1Kezbdeoi3feok2vvUa2AaKt15K FLm4LcpnhYUDcHG77OYQF7e/ksHGHkZe7uvWq5Tkg2BKWslksnAO4OLGS7deTrGymc6GOFwU wK3X+B4TeHZoJJnGODLRIEPMfGI1ww+wJg2/3Ao5rRL/Orx6/CVizj6UKWGIk+Zbr6kzpVuv iHo7EnX3rZfQ2xgUFiwjowAgjzdOebx33Hr5947KywhqKANIs1YMjb1k0K0XzRhej731modo C4/3dmvShsnLFCBtzPN4V/ICDAo3uvXqV3p/yP3yrh2a7trFiI7jibyviS1y/u6bpvjAJXIl so9cyZnMIHIl+50QiikOwAr7jgVyJZKTK/l3lFJ8gM40ww8LvgdW6HKKD8nqoU5KrkRuRq5E SFMx/7HInJeRHftbpPhYI1dKt67Fu4piig+hI8eQTdDAK+naDl3zAjRwipTuTCDgQQm50pKo gKrEY5an+JCZZFDBwuXBAjSQRsXQwBbcR4oPRaTZwyd9tRQfboiOTvGRXrjkmtCn+Ggfk1zp IZxZbs1AfSTtohElZMB20y6aAjLonG8ZiAzYAjJgIO2iKSIDDiVwd+9XzsQbJfsI+5IjAwuZ i8igqlsuKxAZsJshAywRxf7Dk2QVRXZNkfkG7SBkMM7SLmQwiuwSoa5kFc00bmxkHRmMVdZ2 bCV4XDD+VORxskC7aJorJv9S/MysoldM/gUKcjYyGES9m6yiN0j+leanyTVhZvh+IoPrIIMn IfMFCZktMpBYiRpEBmcSMkfPqxIyaCjCDO9BBrxsM6CGVBJEBrcjZM7SgM2fWXSDfONbCJmz bTBABmg7MtD7kYHeggwwr+KC8YdHp8E1ZJASMrsk9hdEBmcSMtfLyKBLkUH3RAYJMugORwa/ OSHzQyCDO6Bh9jOzwj+I1lmY+R6PBcpN1eQwYSCrnViYC0o3wwQXsxK09RHCgYC5OIp/GZ7P YELaVsrCTGaPhZJcO1x9qhEmzEWnsTB7+t/LsTDvin8psTBrwl1k6cHxL+MsbWdhjm8SIBbm LFNi9uhIPky6Ntfj9HXAbQDERuznNFOYdAYLkjkW5oFRY8wuueDJPr4/bSxYDFEnJm5p+7pR b9N+A93s66aCAN1MXfq7tS97IaoHawvR08gFBH6M+3W31HoQlxD+1iUrMlfnTxQby0muS/3O gvuSxkCS62RGMm7rDtQzYkeNT7TjfXxZWDcVdaJH3jCbE7d0KkiAujczV0+tz//aD/kGaFUk uc56tbqc5kCz/LyYdTOdInihgyTXK9MLXRSVSK47oJvlxoq9miYgkB3mtga7CZNcJ90EuK13 4dNTUFDWxh9Gwuz3V1ff+XO//hJf/3n9dPSjH2HMUC0cG3HTFBrpd5G1wCPcR4NcI/DoSaa8 KwDpeBWXFV/SUcUXdfRYHuZOV5wMb/Pd9SvDnXbHE+SCIj3DhJ5hQr8rV7Fx28+S8QDtChPy Qa9ZmJDATLOqLuVJLYYJtU01cWdMZbzhmpOJOyPqjYUYoe0gej/poDyprvxPCBPCgO3gt+Yq vsaC+k24innN8MW4inGBqxg/uYqzq7syV3GtKCWxuy9sk4Ov7s7gKsb3wlXca2U67XNji1zF +JJcxRjkKh6fGP+QdzMaormxKg+BOV0yiKs4qqBFzrDS34lhqoPhtWeWtkHBE4bWJkwrBnaz f/gxuYp7TaSSEa5KSz+agHvlKsZ1ze0Hep1rZ+n2tKU1F4wrbRreUVq92Anj0gjadRhjw+fL 0kqh4eIRR20FJj7C6050wm5jHeddU79w2SIpBdEGSV4JGQqCCcbZ7WmgtE1dhX9gL+61c8if o9g0LKJYe5ntr1UVdzOuaSWraNSHeYj6msi8xBVoYW1iNF/FeuJTpAMtdjUbFJs2fS/ixsaa nZobszV7AV7imr5grNDitJt9zdHH8SWuaQvGmjWdnnAVxCTfIsB6chVPsbQPx1UMu0o1lbaD WtHCOaYZ8VbwDru9QecY1xaRxn6MRrwV1LmrqG3fMaOYqhpNDRnx8SNwFU9DHC6KOGo706wB OfgzOehmteFjP/6l7GaVkRePv6SxDnWTZPGDRGduVrFqP7mKn1zFW7q5+mhhen9rruKH8LW6 MdnwPeELdgArDFtghWEgKwwJ8UVhJeR2UsIL+KJqIXzhvvsgviASCYnVneGLci6EqvcIORFf DP96EsfwAr5gKSsMC1hhpiFO9501fDG+OPCA9q1Xss0/zfm+H3+0w8bmidmUC4EwWXDjdkoI 44vgdRAkSBwrzsMXQm8L8Drl89aJWhsJUUif0NgFJJPluv76RgdwRmPaNLzZIlnPa8foimSE AjCqHyJ6pQkoFeBMAdLGXOg3QeJxWWEOhwq3JpBjvPK5p8eUzk5yT1BaLQOEXU7Yoz7tS0IQ JX1NExSMAKHvysWTEGBTdRdMQlCXkhBETthhDe9BCcRqGedpd29JCKpqK0C4bBICP0swQOgH KtO0bOqDr5+dEZE7LV40o8EgWeZxelhGg/H9BclSj9MzMhr4l+fdhKcocK8rSJZkNOjrJq+b 53soAK4uUkHW8wZMnVnDjpDHaSx74MtXmM18iJp2bSDKEzCr1Qgmm1T2CX6MY1aKIgNGpI4F Adj5y42V3HZLY+ZcGUvLqQHqZq2P/2JOyGgQtw44n5cak+l4a706ZhszGngnzcUnvJveBrgX L4kp2iIVtZTRAJvFjAYuCUFU0P9IHoYAZTQAGqs7lGLmdqcT9irmSWr0n4ZV7+GmfnoPn+E9 fKJbKccd4tn7JEd85X1/jpPxXSdLuIRH8nmuxUI2XhGcBFbp3vXHz299og61SAhKbZPGZ72w B7D//Xz9+PXlU/49ZfhQF5wPRhhzQ/thVUd//+IzkPzfOLSlSk2rsKv0/e31Q3/V0g2r/PHT aSrz4dDFEWGk7ZyALg9g71zuXtqHU/v9SjtpcdkV+el6fYjrNTkmQ0NqRkCA6zU3esVTFDcv W12vRwAwWgzGAokYd947L8mVQosow3I61kRXCj57Qt3Il+RKwdfp9P4MDfV8pRCXM7nFYpD+ DbYY3K3r9aNlaHiyKF+QRbmpKmRaPLlVx+84iEW5NaSwZgAW5SWuRNTRqq5fACvbTVmUrcZA VjY7tRYE/L4syq0ncghPpf5XdtWpNrIo28MTLJlTpBCVbWZRXhIVUJV4zC7OotzArjoD3Q9O GZHwDkaka7Ioa1qTu2BRdkP0ZFH+8xiRnizKF2RRtsgAi4orEBlclEUZQgb2/TWvdUVLaZtA rkSxxJXY9IFgd8SiTJS0A4xmZDBsYYQpWbt03McigzNZlFF7exbljuq4YJp+JDcgA4BFeWvq pU3I4GwWZbKIDODUSzdFBoOo98OVuC310iWRwZNF+fbI4MmifEEWZYsMiP1jAyKDM1mUC/qf 2Qzs7lfByKDSETJYdN11PVeVbhCcX+F2LMpF111NBMboaNfdLSzK4eqmar79t4rCFBS7AnhB loFAppPz4Pbutys7NmESthl4RdqEDFIW5a3utxuRwZksygt1PY1I6FuqCeeEVKtoalfBhsZa RKkgga9UL1ldx09gDTQ28aostO7cb9FmAwShLBGkyhxiruuh/JuzKPttwNbuXzd85V+F/Pzy 3d042n1skTLsT+NTtgvSuDtLfxVsZZf/WNlFKHrBcTe+hdviuDtdwwXbW0/5GDC1ADSSUGQP HuHB9OkMnIAVUA7Bg54ds4XZk2t6CgNS6Uqh5Lg7OSfH7MlzX5JrOO9LNsKD9N0ZPKhW2ZP3 GQ4K7Mk7InsuzZ5sZwmGB4oKHR3XjHNPe4n+CwHkpnBjG6hLa7NEXZq+ZlWQOpv17d+A6DoC 5iMFsQbQq6BgB6nqeITOiHIyN9Hcf3PDmI1t5JtCJHu3SMWctR6OWaPHLBfTdtSkkAoas6n1 7IlEUp5LVtKEBUdS13qrNoUJ9T+RssC07fYxC52sczdRbk8vLNt2wOXk+T3LohYGQsFGPTu8 POnEoiPp+MsbG4ck1dHQkdTKzvEcuj04kpZUgwU+9L5A5oK0oTETVbzYGMQmMBuZWiZAK9+y apD5P3UYkI5xLWNqedE0QDxgTDU+CnLCRWQgCG5iQQxrYkFQQFyf6Nk2XLqOedIa/muy4HLZ ikWPyzNcdk9zubXb11jJ+8C6jjpvVi9m2QXWLeHMBdZg9CTsvbgvrT+59wbM/9Vvr/9qi2b7 A0rlzjd12Tv2FJda1inWBq7qfTe/Eido49PVl2nCu5o5Qc271n1dN8DOJdEfxFhRC88d2j+R nVhIRiTgQtw7vN6FB7HdckWvt//5P//tRPM+tbQYrnCaDy/BDWJOMv3mONp7b9hfX97U91+u rh/Gqiu98g91470jBmXuYqeXDQjbGZRHLDDaD6Y3CcoYx7kbr6CG0tn1NrQfeJsb7d31Pr6k baGMQbl/3kRMr/HfBMygTKv6BPvB7+/G+0gMynXOoNxcYUHl3r8PyaCMOdNPBuU7YVAe3qGR av9sBuVeK9Npnxu7NYNyqCwqguHJX9qkoJ4LlH2XaSU6XTKIQTl+ok5O//2jVGvOeSwZktN4 Y8dkzEQ7+7qMVQHJHpRBOfg9GZSfDMq9LPMQPRmUFwDW7RmUj/CQmrx0BOQhtZk8OWir55ZN PKTcyVNxKV/SK1D/jgVyQ6LjK9DxHbDvdJE8ucWiI0rowhGGjVArHJNataUjTKtaxkaolfZl hFpBWwdFVcnG07xkySpEh3hzpO90MEtHRFVFnkLjZ7bsO51TFIOCYLcoQMncNUsgGeQhFa6F baKeEFUFEyCnBcVu0mXfaZP6Tptb+04PUVV2vQJuT8XGrug7bQ73nc5v4PZrwh17SD2E7/Tt uY+Pi7c2Few7vZn2OKhDCshAthXDIDJgdIH2uIPirUkRGXBRjLcmgpWiqoB4a6FlMaqqdt/h mPY46MuNkEHmOz1sYYQrI5WcENNx8dZkDRmEq3v2ne4dEeRKVNXY6zIQyHRyHtxtvtNNITWC V6QVZBC+N1aqiyGDrdTFxW5Wy8igSZFBsx0ZgIKcjQwGUe8nqqo5HBnkfnOpJlyOuvjxfKcf Aljcmin5jpIqiAOSKogFu4MAkyrgYtImVUYXiJaSKsBsLhxEFx4pMVWxODIr+DTcCF0Uk2RS VXeYqNGaexy6wEtJFUSaVEEESRWmIY63LQN/dlNkguF47+yjvgeqTKvEdWs9aRNusZp0PlPC dGuLVbuQVMEp5BZkkgES+Hu0LaorM9BB1ygAEwxNmWDo9qRNmwRZO5DvQyYL3/D+v4NHV5HJ QjfjIdqCTC4JVUimAGljngmmko+cVOEPgCfVVeFJnqs7jwcTLZ18o3++Dd7RhIZOjzAuoTtZ 5hrY6oFMXU8hYeELsGmnRPYpy1xu9fC/KVxqa0iYb6t3UcpY5kx1QrInVHLp2pbLIZV5xCVQ HwGXrrmt7SFhu3I5lELCEKm0MBMuOi6Xg5+lUkhYR+ppi59mJ5uuoTVsv2utsv8abqRBxenR MA9E0laTKLaBMiYUk0pkkxw1Rhfiy4BgmgBK2P+cEzT0iSkqAXx8DJTkAIoASwsgxxOTRvUQ ZYe3BTJUzFWGxBRQN/vZCQriDBXeDbejeWoj8AQ/9KowI37MfIaKaEZcf9bHrJ+rJA1BH0+Y SAYn00BhAhJsv2CUILI+I4BqZBMwPpr1agV+zaEpjMRzFfR7EDVVWs5A/Bt3YkRkk2TltBML 1rWlbvYFkWRLkW9ZY8tpJ6BujpE5crD7zdPbALqStr59NpfTTthqsE/S0In4P1fSTiyP2XK0 YJB24jrRgloHH40tIWEbYE9ayX9QFiJcZL0U4NJvw2vZIIinWL9KNgi3frPQspqsZXNAFZDN QVbXSeZwsciyphU+JuPL27/i65c+DsXC5Pf3nz98NJALzGhKlXcHvbS1wdqL7ca114ufH/bQ 8vXrGL5SpNvf/bKTY9BOy87wB4ZlnZD44pm54JCQp+qYkKf03IygkKearoU8kZedIU/T+Xhu pD9XpefjVjBJ7Ygu2O2z87FzjncJ0Mbz8VzuvsWx3X78mw9tInnmgr682s2oNvbxgUKeMHA+ vquQpzvjJ3YrvIFWOApX+EJM066rrpa8xCalOTNfzDJEVMMVDVQgTvZRy6atTLpkQnVScTnR FGloyfRt1TA98WC2+o2XzMXSgzaacYObLdFMl2UZ8rNUimVCZ95njCWTlswPUeX2m2veGtQ4 mClKqw7KTjmthaXGvPZvkMx/KbuKr0nWkuT9m4xd2wu2N0bzjaT/w8yfW25s1xl020ZZhEL0 mCRO6YaPACjUOeKHpY2936b3QKE6i/6eFkgKhWJNPmxfj8vRnxD9vR8K9Vc+t4JCT0LmCxIy OwtWjSgZ10z8jvMImaPnVTmJE7GCFdYM6FSsyk7FlUsJN66ZtC/jmgmsdzclZLaLomoJkvGa OSBVw4mEzNtSNYydM8Ov7FR8OiGzYVFBpEiRPXgrIfOFUzWcScj8TNXweKkanoTMD++1c2sW 57txKsZIb0MX2aLY7lRs38HL6ELzzKnY02cCTsWePhURAJFbdEOUpFqU+JzTRFD9FSabkUrq VNx11YTI00/DjdBFMZh5h6XlsujCzxLsVNwrVjbT2RDH29ZGp2J3XQw5FUeigcHMZagyaUqJ uzVuDLdkoqdIj1Oq7FScSxYiE4O2IJNNTsWK80wyFA0iYZyWP1AvBafioQAlTDvCI5Nsj7qS DWg/MskASSLZJZ2K5yFSKKl7ZafiJlOAtDGHTLShT6fi+4InZ7HepTSS6D/+pQfQSD4o651Q Q50n693dsN4pJfDp6OV3YL3rtTKd9rmxW7PejU+Mf8i7GQ3R3FgFeDyeLBnEehdVsAeArLH+ 045pcN2FccvbJvRfNXVl6Ow+CXezf/gxWe96TaSSEf5kvXuy3vWyzEP0ZL1bAFi3Z727E2vR Zuq75G/7QtBJVw5Bt3+L8NZEqlYIQS9R30nT8qZ4fwtT32no/ta1hVlttL4za1GGt8ZP6Q3S hgezVApBd4qVzXQ2xOkpcpO1CBesReMIlj/241/K1qKJzy7V7MRaVM1fj+RRmZPjxKpdDEGP +GwiUXdbi7aSpaUFSQxUj2mAe6wuvcfqtluLtt1jPay1aB6io0PQUaYAOxp7Wovu5jLr9tR7 dwNPNvLvZdq9B56wBYYcBjLkkCI8WeDfw7h4mbXDVcZ9O5E9huB7gydE8YKrDCZdjcWR8CSY pRI8YSlDDgsZcsYhPgmeFNxsYgU68TIrI/Mbfwk8qbWcdD5TQhiegJLFCnkxeLKVu2/hXL0I T0A3m43wZJMgjw9PtrnZXBKe4EwB8susS3H3PeHJ70vgdwZDzpZwpnAzpAUXXlNXE0NOGytq FAEY1YlceJt4f9/HkINNxSGGHFvO7pEhx3uevwTXVMHv6gw5pXAmTZpOzuNyHEOOn6USQ46s +DQK0+xET0AcOmljAYfN0NhEpvOScOgMLgZ4NjoDiCniYwkLskmO+gkz5IwRmeN/G4ghp9Gc Zk8sfHzmT0sUI5Q/MUiGl8KZ4qXOkwloyWxqGjl0wAsXmEwnxHJekOx1EGIaegXPSIEhxwsI osyMIQfPLDchQ070BEQdM9dN3lunWtwszOba5GWtL2WtDzohmCY460T0hEvvHE8RJNnQzSYf keSJbAIApS2T6YwF45jlHDpFpU20qOuyQcw5dLaugHTMGtnIdGRKYxaS6fjQtCpkyClx6ABK O5LpZKKuFMjC/WVKpgOOWc6hA+oZTKYTnQBBDp1doPZEhpzzckCfy7DjtvE1hh1Glwl2zkww fjo/j9s9AqaTr1/etHh3tX/8/X/uzRy7Ny+wrZyUOt4uLoDfB1fLxCW3J/j5c1LHn8BGcxLR T2Nx61zp/VO++mo+Grk4Kh0zxp0G5d9a/jNy34wkNoosppr/E6mF7j/jO7HQzg3th51S9bM3 QzStZxMqT+Qz5/tWAqSTzCdnsiaRY6gCUlsKAqgCBO1WPHzp7kTxOWtSb+/w9o+ddzn+biS8 y9G4aZoKZE1ySQUim8n4N2GXeS0okCjeleML2kzulirg7hPF3xkPtxK6c9uCh60Omnx//eZB I2ndztBOF2oXuwHNLY2BRQ1YNWhh1cA3oFXHXzZYGqE6GRc3NpckTsL5qvGWRhyumuj9VVuf s2qAMT7/BrTAxe0o/+uqO5g4aZyl1NKIazS6ScbGKpQfptvsiaLNYIEhtlgwNzY4OxPpOASQ zkwjK6ZHJxxogOj1pNyYe4KY3MBXaiw1xjpb4DiqfQ+6Nnt/obHpvUu9KpnLw8YAe4M9t9sZ GUd1wwRkgvSNDYbkNh2zmsymkaGtpjgBSd0qdf8CugnomSkYixaNolhjhkHrrP/hbL9Zah3i SA5/xbqO4t1RP2fG93wCwkf9b7afRnoG9XvhFiCUKrXTe1r8RHYohMCAdnrDeSh7zzCUDgRs 6oWZ7CPJQsuyKd8COEbOdonJfmp9/td+pDfcZ0+CxGMG0PKvLqfATh81Fpoe825mcxUudIjJ nmRVdlkaN0OfrOK5Bp0zq3feBFGyB4l20RzkdwpX3Rs9fomv/7x+umPwR2irtIcFx1NdIqru 18OawRP3hp9rUIrfxmRpMBsr+dc6C7U3wPkJKxpuRCOFgWyd3oRStr9xq9a5rdNg9CQzP/9l +824tOsE8qYwP4zhQBC0ZLg7ljd990g8raGbraG7x/ZA8ykjjDn1/LBTqL9/8ZvT/41m9Mst G9J2fkd4/3+Dorh39W5gfuPWTkhcNl+eyFd/6tp7WHPt78NXL5RZsbzW2y2vnahqRFvA8up/ 3oZzrg2pFbVou9ZbUVVqW2Jmyg2XkLRqo+qMr74v/yNIWvdbXm9L0lpf1fJaJyvjjsNPsG3p +lxqZIFLjeRcau5EF3KpFRQESNDcqbWFExxkfFhIvnD62IgG8btL0FwpJQXKja92rLqm0lW8 cA4IP0FLXGok5VIjvM2HOFwUcfhJNoNZQXjsuWSCZrSBSw1V7ey8Gj3nlDBEc2n4CSpzqcmw sUjU3eEnrZGZZFsKEuOrbxAKP2nS8JPmGR07TsA0REeHn9SZAqSN+QTNpH3g8JOHiB+5dT6c O8IX7AB8wRbwBQO5Wg3E1eqf5wX2DZd6StK6gC9SrtaBGrMU3oqrFvcZIu4IXxBcMa5RjC8a U2kjBAmyvR/HBG+W8AVL8QWL8MUwxGV8EW4PKfvGSnjrmLDnFHwxpWRKNTtuDFdyirpKlial ZXyRSxZ+EaL77/PwheKnhbfCvKMZvsA0wReYPsNbY3xhh+hofEEzBcjxxZiw6FHxxZ8Q3vrM UXPJHDUSK902FYhMzsxRU1hDueWDiBIy2WH58L9OERGzyAd9uTfLh6OtRKw6mHhjc46aSWvC rRSTxhAThpsR5ygFBB5mGWg2oQsNI5NJHfz/ZbiELkSdoYsFyebvgdARHVcRXYBjdvEcNXgJ XUijYnRhC3bmqBnqEsPsdDbVqrUo7MQyunCMyju62f9jqfXw+c05atwQPXPUXDJHTb/Ie2Tw 5V27a8CuXbxxvm8G9zQVJPqPf6sDUkE+KIM7rxm+EIO7UR3I4O7KnwzuKXKAGdw5wpKoFiU2 DdhhHUYOJzO49/N0FwzuvVam0z43tsDg7npxMQZ329jlGNxdYxdjcHeNXZHBndb2fxlmAiR7 MrgXWz+EwX38nWVWejb2bAxqDAZYTwb3ibjy4RjcoWzCQoua4K5TJYrUmMG9b0tXTTdjpOAO ibe8q01DX/I7pNHqchfZhMcjZW3ryDnm5hEY3Kchjo+AW++Q5F4Gd5P8Yl2DMhGv7E7Y5ZUf dT5eNjIift3D4B5YeYYhajTPVSlo/eIM7k0+ZuAdUsrgjncwuG8S5PHvkJ4M7s87pEdlcD/o Dsl9Fyr4DmkzeXtQhxjgDsnuo7riTIHIhNEF8vYOIkklJrhDip5fIG93dtUCMgHJ2zXo3dL3 nYq6ecnvkHxfboRMcEcq5TM8pXdIhFHCm5uQty/fIa1uhxm6yLfSCEzk6CLUyXlwe3Sxsi9j IuOCSJHSnQkEYP17Q6UKnEp6dKGYVslSZDAAS++QthKw3+wO6XTJCndIw0edSMl2XEj9VndI ONOzVBMuR8B+/B3SYyCDW5OnM14pH1v+cw7v9TdtK8zpW0BByoQegYKQjQJmTp+YwFWhrY8v WVttBAqCd2SgIHl/zpwuNzmWZF+KM5jTwxoTQ3riWOKJJ3bEopmRpOMCLq8l5vQGC4wxG6/g DmVOlxkoCAdqKgBZbOoIFDiuBpFz8/QkJiE/+fgLL95hjvHSZh1spyZlsRkZxIMqPXcJAFdS BnE00LoHBUQaHtDpeLqROcFRDAq6jlKgV4VBnLlLwG76juXdjKYoIZL2PBfFD1ydT2/2xNYJ AFhkFhvzD60gjJkyg2V05DmNUEFpAwbxTK1G0DFJNhGHFyXbwCCeFRQk28QgvrubE/EHqpLp bXJd2YB9SrOJ40VTZptvtCy33v/alJ1KwfRgGxnEw4HwrM1AY5sZxLOBKI2ZYsnw8oS6PiMf Q6sY29UdhhulilcHWmxl5xjYzyxI5HWHVCwIYxH1EjYyX04k+Giso9F1zPOSuiO5T8MqjU9T L9L4+O11plgYSHHQIgPzGdQ/bh/KqHtqssY2jiqAgUdW9042vpefg1RV5ZiR7MHgm/j45/Vd fPnQAeD3vE7Fo4U93lKnD9JzMPfHi1/iHy9p67SgKnb592QZvwTBzblMNY3nKUqZajBTfxxx 9+Oyufzh5NscXZACZqwyHruT8uoFtMXXE8Uu4CVAXl5SCpiKV5XMyLftp9xuI1qGx+7xb52o ZWdAChhbXj0pYJ7k23fsXqMPyECsFzIQazADMSq412C7F5cvsRAVhYUDXmKVQrS5xX9muFy7 oxBtzCj3XMfpwtlhr7rsJRZacq/RaQZi3bb5EIeL4m4oYLZkICZVU5CMioJ7zThoRQoYg+IT 7yzqCRQwKpcs8lEijOfp3GAnluACbChAOHYAF3syEP/mFDDzECmU1L2ye02VKUDaWE8Box84 RPshbsGeFHO/JcVcLRiML6o2wheLgdb+4yeY4vwFuA/DiN0MX0BOMsVwqfummJuGuIwv5i8h Rh1Z8FWceNsW8EUGJ4p1N7rvIun3716QTAkX8UWZAiZghRuGqEEsV79t+OI0irka/FbmFHOp +y66H/ddKEj7SHwxD9GTYu7y+OLPo2O5G6iwkZMl09I9UEEsQAUBssXpIlucWjJF6ILrDGyK UGVThKw1lvdmioAiq90PNEUcxMlShgoihQoihgr9EK9ABTjSBxXY4sYByaFC+peyKSKjgBl/ qSlCFNhonRIWoULOFhMr5MVMEVv5XEqLfg0q4BQqPE0RKVTAh0MFlilADhUuxefyjPS5Hjxp rgpPRk+vMjxxd6ENdBeKwrvQBeKXPcCkTwUcApM5j1tA+WILiGqYCuLXImDSkdbqPJ98esfy VjSEiXry6Z3KuZGMmwiYxG0JiCxOjYR0v/Hl4sVylDrm1OD9B/n0jrNUInxBZx5Ux5JJS5In gXSP642dIFmv2Y0sScbr5NE6MIgM2r9Bsj6tzGoqVreM4/eHOUrP6GZZstKjTb6R9H9wXz9t KC57NO78DG7bKBf2+UPyBqUbPoLyBjnPq8WN/SIZ2/0PpwfORJMP29fj8vbpNHIHTiNnUeTh nCKvucKCymOlH5IiD3OmL0SRpxztL0CR58qfFHlbDTkISW67siWnO2zIOZkir5+nu6DI67Uy nfa5sQWKPNeLi1Hk2cYuR5HnGrsYRZ5r7IoUeVWj5RZb2pMir9z6IRR5uK65/UDnAVN7wHRL ay4YV9o0vKO0erETxqURtOswxobP5q9KocGoiKO2Alsa4XUnOoFr1XHeNfULly2SUhBt7NZW iSgsChOMM3tYoLRNXYV/YC/utWKK4XX2XsOikN6XOY99VcXdjGtaySoa1gxms6+JzEtcgRbW Jkbz8aKnZ9CBFruaDYomoO9F3NhYs1NzY7ZmL8BLXNMXjBVanHazr8nHEYlr2oKxZk2nJ1wF Mcm3CLCeFHmPS5EHp1kSrBK8I6U0js2It4J36Fq1wDnGtlV3qqqIHvFWUOeuLs7GTymmpJUN Ts4xd02RNw1xalBfMI8M3V1IszQ+Wv7Yj38pX5xlnHnjL2mMonFzSj5LGJV8bFYp8i6YZulU irwj0iz9GRdnN0iz9CdQ5D3EzdetmWyO5LgjtMRxJ3Zz3GGI485+K7Q0nQahhVjguBMgxx0u ctypDoYWta6IUiUTaZrBsWcoqCD2Xf9r28bE0CLoywWhxR5TTpHOBiElMDr66mucpdU8SVOI 7rz1EdVwReO9sOcOge6EKMX2BLEDHoxKuraxNqjAoIs5yeABiKBwwnGX8OoU4QE4ZjnH3Zl5 kpYu9PJRVcbI5jLXhWXJKJGskpXO3lturH8COhO3olGNrhfqdhaFIhW8riyZ/4XWx36Iqpyk 57JoIPnvXM9STfAuuJV8TI47vw0sR+pXaClS/2iUcPtI4uNQAm5KKGFjEHFQBxVQgmFGw0y4 egElaBAlIHNSNkXeFFDCdOGTfr0LKIGzqmUgStA3Y8IlhNv9AkEooaurWzDhoh0oIePZr0Ej AnyYjr6Wm1AC2oQSirmaebMNJaAEJSyJuhsllAKB04JiN+my961JvW/NfTDhWi004h6YcN0Q Hc2EW8ErINCEywUC3wAl/AmOt7cOIW5pXfOMA43UPKFAg5EF33+1ASEL1HRdCVlErrdRnQBZ ROWtjul0p+fnL3iALCLX3yx8WKhS+PDklsJj2wRqOFvl2B8LBlbHqS1M4D4CLlo4QhbTOMoJ PR3tetuwSnTabHEluaz9wc8SjCw8a11g7QmZYHu/XS6bLrr80FXDwU9umPQmd/Scp3PFGB4J ks1pILunwUtmF+D/BBvrBYnqKuB18CHTT24KQvKBiJoivBSk6/aIxW7qipNMdqibjWEsuC/o bQh1U36i2M00XJuMsqKoMS+qWyLSIpiel1REjfW1KtX/NVhVjhPNGSQk7/x/Dz3LsF4wZpJX ISzJYSGSpnJOTsUn8m5Oj/bwZvrvYQL8vzcm9BbAo1oD93F+r8r1G7CMDO4wjk6AKcICr5T5 L7hVNWtWG8OZnoN6tk3hc7/tdTTmQGEnm2BJlBrLlXbHJrGtm/2IwHUDRstU1HQFjFCnqrLG Cq2Hv5JqABhzLBg5lJaorocBmEJuyoNYfN0uSLsV+aT1TmZCPY3X1G2Pw9v+0p+v3lPXA/AR lZZZcS9Abnoe3+x51KgHUpw6rzPPcezOCR8Wmn/VH39//xwOOp62ePGcY1+o1Fj/ny/yHyel I3Bti4cT1ghqa+h/bZ/eXj/s1A72T1cVUT80xQ4exshKESfu8vhd29PbX+/iWz8kLrH98s3x w1K5nsnKWh8TYJMe7BDEylrTi7OyZgE2wiJoOQS4xAE2NSftfBrZ4pimcU3tsshYWZPtPQqw 8e+3J5Xx9BaXs989cPIhAmySJUKvavKgG+5S7sSj034EDqBCYQtUKAykQjFFKhS+QIWCacmj cxcViqg7bkR9b1QoRMmKA0mPe49OJpOFcwAVilmiQmEpFQrjbT7E4aLY7NG5nwolPUDEunYK axpVBdY0p4QRfE2oUMxBVCjb0hKWFn0wZk8qlOB311QoNFOAtDFPhYLxA1OhPMSVypNq7bek WiN9tPw2fNGarowvpK41vTN8gSWiWKMMX9hhEYiQ6nh8cTrV2jTEJ+ELjG5OtTZMRS9ZpoRL +KJIteYU8oL44jSqtd+AlfVe8MXxrKx/AtXaQ+CLW3Ol3RG+0AfgC72ALzSILxSEL1y54zIo 4wuGC/iiguwXpawy9uMnpOzwneGLskMo4TzYIQ7KKjPOUglf6BRf6Bhf9ENcxhfRe0y074ff u36MkSFmifU9/csivlBb8EVVF26RnRIu4QtVtl9cMKuM4jyTDEUg7ZlV5kr4Yh6io7PKNJkC QPiiJ7N7UHzRr/QeX3x51+42sGsX02xeHVucRT6WpoBE//FvdUAKyAclHxNqqHM++ZhRHUg+ 5sqf5GOpaaNIPoYFM1jcgHysn6e7IB/rtTKd9rmxBfIx14uLkY/ZxkDysVBZVJTxO/lLmxTU c4Gy7zI0kH23ZBD5WPxE3UIfUqo15zyWDM2JXbAjAWOinb+sY1VAsgclHwt+j00+Nv7OQn/P xp6NQY3BAOtJPva7kY91SBHc1aWrJBaZegYTDOMw+ViHusogXd+ZqaeItzQR3hP7wKukc8nH piFOj4CbrpKumbVnK/kYqSaiw+RREV2QbScfu6iryqnkY0e4qmwS5HFNPbdzVXmSj93JVRK+ Kr7ISeNvSStiqhKtCNtNK0IgWhH7rWjbtsYgtGALtCIMpBUhRfIxLha8YKsSrQjopdKCt0j+ VxM1u4+nfbkRtHBfHwF5wTIl7QSr42lFyCZakUlrttwE7UEDmU7Og9t7sq5trIQkBaEipTsT iKBIQisidOBp4ldFXSulkqXIEDhmOfnYNk/WYjebRXiAU08TH3+60Sx3HVqRRXhQbOx6tCJ4 m6fJJRFUIS480ARHK0KQeEhakTu8BHqSjV2PbMzuf7wiEjY4nEk2FvYD4aXYmIruQQV8ARWo 1igQFdyObCxDBa6sMaStGsQCR/g7IhtLd63AaFBgLD8RFaBLo4LcaACigpxsLDAaTKgAJ0tx Iyo4m2yMLaMCkLH8iQriIXqSjV2UbOwh7AW3ZgsjlWgda8Hruxbq9efb1++e6oA4uoJqGRfQ nbgAw7gANVUfB+JwQRsrWREXNBEuaOLNOsUFMf9KigtQQwyIC5oBY1wo2DyjCut3tgmbx1Rh IwVUHmxOlGnViAsKK3rGBQPxEUPoqlTlUjNRtegWVGF2lmBcoKis+MRPNM1ONl0FPZkas4NH 7EfeniZi9ajJfIkxTmiq2IADa/8XE1psE3bxQTGiCwHPVbXwWcoUJxgIjas69W7J7ODze3Gu bZkqjQXjY4UJ6IYhcr94vIlJUtxVCFtQ0CoDmWvi4Z1pr/LJC+ZMUl2XPpiOMyGZTZN49VRi aQLmbhI7anyidcOMDHQMiexbKPHzXjnJaOBvNAoyFfj5aeHZHBrbX5A3NgkSj1kLaPHacvJj VhvRJt10hJFZN9MpgvWMK5Ld2pF8eqMCzvKruHkZlwSBFqv/pZJBvZrGO5BdME0yhq70ADCy PwmtspWX6ErTbuhm/2gG6uaCEd9mXnM0U41RkPUMgtkT5dzeeHUQi2O2DZBugj1pJf9BsZUc a1fPuWU/SK9/mbfXH+Sb54fyzF9FQOr3YVffM379El//ef0U3Vf98Vq9ftX/6q8fvpHKNtI0 ZSHsproghKyXZOg3K09Z9sNVeP1LvH5+99VDGXoKM12UwS04Rz0l/nLsTX/9OzZi63r6sSL7 lFf3ngXKMa29fv3ypsW7q/3j7/9zr+aOfowsMKDZNeDhueORkt9//J9nvHLEXFW5kkWLbKzk X+tm3Y+1OwyQ4oSLRgoTSPvr/YunlOvpysocW9yqLcuI6AxGbIWJDnGKWy/pX2+fVjesZn6z EyW/f/v2/c3948dX3Uvgh7nMlExo3bpjzKf4+MdWeR15xV5dMz9+OvKrRaY5xhlTgZb569nF u11FW9IPsie1swr1aU8ErxYu2kObe58f6iI13Llr62QOv/3Ucqex/jUWN8+V3j/lq6/mzr91 cVQ6ZoybRjt78p+R5m3ka1NuBnGRcI3ZL7Doj7//+T//7SbQE7zR4qq+BLvgefyAu0U+YfJO Ys0jzpLmXqTf3Ibd88/9+vKmvv9ydX23qq70yidx3kich25EnCeUuRxxnsBc23NwRpw3IZMN tOfp314Sp8pWtKIjJCPOa3nTaDynN0uI85xcnmfrIyvnl7RlPInzfhfivIPuBR1Rl4Dtf5s5 88K2GvhesGP20P+S3wvad7AFzjyZ2f96NrbCveACZx5pVFdYM+C9oCjdC2KiJWnES34v6Pvy ckf3gn3HO2DNHMOZd70kRGPnzPAr3wsWee9W7DKESdgy6RUpOrCC94LTe2Ol2uJMvOlecCvv XbGbD5eEaBD1bu4Fb5CEiGZ6lmrC5XjvnkmIfkvGPMYr5exrP37O9gPPgL5yp7gFUyR3hHFw U2D5f9lwpwi1NaUfmtuK0w/ltwszpkjen/HkVd0mAuvsQ7MZh+d3iuHz/t4jwRReLmcf34HD zWgXv8CdYin9kGxc1Co9+E5xnCUguGkaqLGgeOmUXA+J/HZg4z1RmmoknJB4e44fNaV7oqCx quOYAV8hn4wDN+E3pr+aCwqINLybY53zHDPBANSGtW0uamEQ5+sh8JPmO1bu5ihedj1UmE2X 2Sub3qSxpRQn2XvXJKuzzqxdA06Gb5ZdoOCsM+vdLKrVJNl0+bMA6sY6Wb8n2ZP/JsXGFhIE edmhG7SFCQjHrNFIxI3RBm0Ys6kT2SBmoo7/Ztav6KdHx2Q3gaiN6NIEXAvdFOntV9uujhl4 dUqorRoJ4q8uCvf9wR3FBrhZWAGKJaPKS0oLpFNb8N4YR6J4QRnqt+0Ex7NLhEWhvO7S+WZs H5hdxzxJjf7TsHoZ19TXuoxze0p2mVaTlcs0u6igyzQpFu/SvIbberaO9C/qYfb9XqHtvozY X2H3JRvtOp/VaOiNQ+jv7z9/OFs+QUtX1ydfj4mWcpNU/PGuf4h3n67KLOnXSRdll7iFEi3G TXBva2fkh383aZYG6bzLKyEbP5tOcPvCd/3x81t/WawWY1F2q83JSrD7TaemmDpVwD/1powd k2IqPbYjKMWUC9BePKJz8rL1pqx1PE4qvynTxM7zkFQ3SjGFKBUETxRtKrp1E7LmIrH6D3Ww Bm7K+nfDN2Wura5+yW7KXDl/ppi6v5uyJ0XzdP3zW1A0u+s6SbhgrLBwyEt8XTYkA56v3lLe no6Ku+PtYZR7z/OXNLjeZRgW9RbT1mWvy06naJ6GOFwUKxTN4RB13ITpqW5A0UxqPul89Bw2 bdirJ0XzgjXKGed0pRWr8vHeJNk98vbMQ/SkaC7ctz0pmmckklE0X8OtLYckD0nRzGuGnxTN d0LR3BjFVNVoasg4X38mRXOvlem0z409KZqfFM1Piubwd0LBs7FnY8uNwQDr1hTNZ1AitFtd oic7w2wcDcq5qasSJcIU4q/SOpegRBjbqnjsvjSVswuGEdQl96WZxmAbJcLs1nQDSoSS+5Lj ZmYoMY5e130pmKUlSoRxFKbZiZ6AYvbTxlJPJxe8X7e8Nt6kE1SEYvYB61PkAhQWZJMc9ZOC IcTuOYuZQnShE38LghrNafbEmvFjySkrkQyXg5uTR2ueTEBLZiRM7J/rQnh/7781dyJ12xoF yV4HWp82OmWlnQH8eqDx9nOVOWXFT+SuOGHd5L0A9UZ5NtcmL2s992cCl1MfvJ92InHb0ipt LGVjnLrZ5COSPAHE7GcTUGUjMvwyt62MFKSstIkWAQ5GWWNlly+0PGaNbGQ6MrBrYV83kTR3 ylqYgOnR3CnLtm6PgWtgpuWlbo6eTgtjFo2q98UC9azlirPs0WjMnMdDSWnvmBLhbDYDu42v OVAxuuw/dWbg+qNxIdjFBVEaVMs+HV4FM3+suuNr/lgn+uJw3CGevU9yxFfed8fuNMeJdryf mKxqqgYPGLeOPvRf3/Tb5+toU3eTpxZbOMlbzAFst4acCf/1y3fvNuSieb68GVdbuxVUFdfu 6cP0dFK7m1X1ZHQ4zE8NHeOnlppoEMjowC/H6NBhxyNSZ35qHVeyE3MkWQFfbWR0aGrVsCmS bC5nqm3iSLJErozRoS+vnowOkJ8aZrf0U7t9/pc78VPbnAQGUp7N+eVYu5AEps381CqfXqSQ Xw5MAsNlpzHRtN3qp7ZA62Dbktz505tx4QTfo7vLL1e8LD4oCUw5v5xTrGymsyEOF8Xm/HJY Xi+/XJVmlBl/SWM17ibJYlUjeQKZWLULfmouK9HF/NS2JpBJC5q4Md/g5gQy2R51pbutWbJ7 9FPbl0Dmkld4OFOAtLHLJZB55pdbgODkqvhi/DA/BL4QB+ALsYAvBIgvcBFfqIUkc1WtCvgC oI0S9qtfxBeiEwM91B3hi9QPfu6d1A2+QZI5vIQvRIovRIwv+iEu44voPZkfvGDxTaT3g4+r QPHVm/AF3oIvqtmjIFfCJXyBy/lro5Sz5+ILkUm2pQBDX/EMX0ijYnxhC5bxxfhobSdvBoeu rjKk5fK3wxduiI7GFyRTAAhf4Eo+Lr64Qz/4Z5a6K2apk8J+KmUNwoqDstRVNd+Ru1bYza2U pa4RDOsYVgR9uRGsKOWu9Snf5Bx2eEdZ6mKtibbsy+auPSlLHcEUNj14RUp3JhDwpFnqnFJt gQbgmF08S121aHpATcpG2TzZKBM2yuaZpQ5ABb9z7tpbZ6g7FBUUctTZ4n0c1VWWo879PCpw rE8QKrDvWOCoJjlHtX9HCRXQMirAoniZAaICVUYFUnLeAajA9+VeUMFYTqVBxg7k8ajgDI5q dNnctSdxVGNeRQWRIm1DBU2KCqIP+bmoQKaSZaK6X7GbZBkV4BQV4CcqSFABPhwV5IyqqSb0 qKB9SFTwR3BUP5NfXDL5hQUWnRAVCCwumvxiUrrYS0JJgninC8AC9JLoisACaWV6eoA7Sn5B iKCNN3RnyS+oXe7NwbcYW5JfpBsf/H2BgUU4UxEzTRlpTOMxKOnahs+EhiUTXc7IkwMLMPlF WdTdwOLs5Bds2dOBpp4O9NbAohdEY0n16jXS/LsesLBD9Ex+cVFg8RDI4NbZKxQVuPL9dVzO fSwP8WlZl0EBiqkxt7g24AQUzAmGYVAAcmNOupy7Nvi4tgwUAOHfUJ0se4XUJZ/jKcx6yec4 +2Ds9zkmGSgIw8Jzn+M5E8Y2n+Pd4d8u455EAChAyI7WtJ0cmb3CvhcGBS5sJU8EHz2xFEcY bIn+PSqgrskwwBRQWW5sKGjGIS6gk8q+reGKBgULOdSL7401edlPIhgRH28TwUmuuj7KvZ3M Ink66pO+STFcqdCYGgz2duyXaTZEq6+DsY+L19mKF4PXrSCM8dE0iYCP8gktiSHtw0W+47nS 9oKQomRQdneBlVGSyz2SBd30sUmbJqCPRyoOYi9Z3Uaw2IchgXCl78S8ReZZHHwM0sJsLoyI yybK4sZcPFL2LYQngIYB2o68uWrboEDUqKUBeUNfoLZLth6xvW9thluBi566DvgcZb/GCtiG RtcxT1rDf01WgyCr+wuCfMYm/oaxiQCH/jVoObdw6NdYXi42cVrdL2C26cvEJnoOfQFw6K9l m24ADn3/fXhy6N8Bh/5ZPLc057mtr7Cgcjv9Q/LcYs70hXhuW16BPLeu/Mlz+18bQhf7v7TM YBEb5eHzN2yUP5nntp+nu+C57bUynfa5sQWeW9eLi/Hc2sZAntvxifEPeTejIZobq0oRaqdI BvHcRhW0yLmsems3pjoYXtzytkHBE6ZqtMjP94BkD8pz22silYzwx+S5Vdr7CqEhLSAKCoj/ XyJZ3UbKU6M6v7Gh48MbLD2j1GPHs8YKXG04mhECv+6M0yROutmkgT/BXwqH5ukJnheUGhPp o4lRqsXmvBP4vEZYhZs2vH/TjLWZCWQUBK9ct7l8UkXJYIB1a57bY/wfpjv4hOl2DB8gbLv/ Q98Wh8ItZEs1lZV6Sa86/DsWojiJhpluYf8Hw0DHSqFFTXDXKVI4wrARagVt6arpCkeYGqlW 8Jf0qmPoywi1AnlvGm5BakzqJj3CXNX/IZilbY6VTmtCk6gf/kuEW4Q6OQ/uJsdKrKmJCibN 5xFrK+j/EL536NWl/R9ao1PJMlHdr9jNK/o/gILs+TLMkt2xY+UN/B9AS/tOTbhf/4f7D7e4 NYEUQQR7Ikf5t1Y/+zGtlTcZXzTUwlS5R+TMLgMjgukyPwm1IDkiCJQ0RgTDOyYbf4gI5pRu IG8UvQrhWvhJIggyavboxhhW5caXflxuhAjK+Q2VtBOsTje+nMEbRQFeh35iMc3uYoNDFJZc VoHfgLSon9Q03w9HtjCUq03WWLiwnEs32BgJocncWLprLZgRYGgSLo6gMQ9NNiGCQVHS3bBQ sEJCdWKyxIwUfpGEavx2Hp0scX6v/UT/3iQR8xAdnSzxOBKqDR/BrMpZERsH4ZJTwQxrEzBD 2gdhqzoudpTQEqPERqKqoA4umDiM6YwETRxigVFCgIwSuGjiUB0AaNz7RVMjWRUATZUAmoF3 sBjiUQvTTbdJaV9uBGhciIdwm+VLcpukiSABK82hRFUnx47ieiV2NNO4sbvRxzn8TU+UiarG X19gZyYumGanjRxPy7GjODNxRPxQkai7TRxbyaaK3aSLJg5k0thRc+sQj0UccQMThx2io00c uZ6lmnA5sqln7OhvSVVFKtm4ZBV9/pQgWw5fTxLoOZnOY6qaM1lt8P4K2gKYqvzvYlEi/h3P KJEMV5SSBCq7pCqU4ArYUHLBKJFxlnZFiWTDUpiPpS9RBiNOiRKZ5zR0a/fu5UzpoGBaJcCl zmqUSMahlUsWjFkaJdInWlk6wKaSZZ1YHe/pdcN/b4gSyRL9FUm1UtalkoGmpSjBoFx3yfYF ZzUbGoveSmJCkTRKJJ2A9SGKGsdMZv2GoECUJNCdewjiiNDSE7aA2Mbs/9kjWdDN7VEipTCd SLLtUSJJysf1KJFeNVfHbBgRLqJbTChKhINRIu41GifDi+chakXbUUyCC1duJOMGNBWWJFud ohNn84pRIqPsazB9V+v7DGObcE9a6xKRIrfJe+X3Nx8qYsHi/36+fvz68in/9hUdCFfFbGZ+ H3QQXqmZXdYFQBQ7eFBwyenRL39qZEl1TNar9NCBrp71yu8m3gsbiizBW84W2e6yObIk2rCj s8W0QyeRJX15+4wsuYPIkidH5PU4ImXLsEU7kJ3/MI5IhKtdCSnKHJGoY5Lk5/HbckQW7fye ye5wKqctHJHpql7EoEUqpyXixfA3PTEq6Rp+xbiOC6YBrfKkEqCd/8kReZpki1ROisn2Pqic nhyRl7bzP4Sh/tZUTqRqjZiy2g+nVRGKfrqRPtGYlMqpJ5qpeiArgfIFII1HUDBtkIEBe81I H78Hw1ROpGikXwLSq5f/c1FE6eJBAdSXDEhXHS8A6bktGrY1WK2uSOWkap8/8WAj/ThLMChQ VOjJMlf49KLIuhfpydSYHTxC21oGj/oX1/VsuxsnNFVgwJuxr5vG87k5zSQb/8XWdMOy9oGL FCcYCI0Zzsxe4DepV8il1gMDaPhblwwTSZhjhHrx/cmemMFRuZtNMCOS6rrc7/kJuDF3Hoxn hGZxwmxpAgKIZUeN86mbjNimw7rpQCwQc02Pxv/Z5oJMBbgRzP53HhSJvE5hBszm/K/9pGxA GLabtWGJ1byjFOCFWltOfsxqI2JA4TuWdzOaIp45ug4LnSuSAbh6bXrRDiahujwBi43FvZpa D2QXUjCSfdo2LPRxRPIJGBspSjZysmUsdnQsKETULo1ZMt5dl9+XlY7827s5jFkjhzQ18/Q2 +9DoOuZJa/ivia3xl/4crPL2a+RIoF5/kG/OUOpqkyIS9Xuwq+5Mja+/xNd/Xj8dc9HHa/X6 Vf+rv3544y52bFIlOql+p3H2YfHDvfX1L/H6+d3LEDSCmbtoIGWbuFu2s43aDcAIwouGab/C nB1d/OVM0X/9O77Y1qTORFw0pXv99mDaGbXl9x//5x2FHZauimZsP8EB5ZW/SbH1ZLVotm9E p9wNhq0k/XvcxUXR5N1yxd3ZwCFq9xbhX1F3nPnziCxCfcQpbn2X/nr7tJP4+vPtm52Q4bLA /uPHV+3bwn5oym5EVSukm4kf7xa+//Nqoc775+t38/r1y5uvjpZM/YTjyh2M/v148/WNvyBy x6GmHNmlW+W6/Prx9/dfrxPHjXtX63utyjWFr5lXrF3FqjjKoq1xPVxpDKP8+t13T9WLk7n/ dqirGtqvDnfn9frtm2dJ61dDUb6ukX4Ohkrvn/LVV3NjXxc3g44Z47Ra/q3lP+PVkj/Tuo6R xbXUOd0D3lh5bSm/090Qtqs3hO39ccmdMJOnXdv9qbdvd8TrdtHbN2OUMbSGb9/qkmdfpbYY DcYCiZj72uS3b4JSoaZvQHz71lS6q+uJfyoqr8zz9g26fUPslrdvzVVtbE2yMu44JzxGetsV HKQ8G3PC23fw8hWc5llOeAvhVQPkhHfl7ZykNAq1URK3ChFRWDhpNpXedMHm67wkdlhRZo8/ 4RVc6IF3o9jhlLjNv6O1i4FVoptV/rhsKn6W4JzwvWJlM50NcbgogJzwcJgOkmCYTngq97/8 QDn+pXx957u1ISe8RlNS+PhRXPHs+i5W7WK477bEr9mtHdSY4jyTbEtB4sXqG9yc+DXbo+AT /bbru4UJmCW7x3DffYlfN1jbio8WDKKBAqSNuUws2tDHzQn/e8bqnEU7m+J9dB1vu/zm8CFp Z4Ua6pxPO6sUBmlnXfmTdnYNvfTvEB0xpmqJiWE/fFcIo5eTaWf7eboL2tleK9NpnxtboJ11 vbgY7axtDKSdDZVFRcas5C9tUlDPBXbfxoYGsu+WDKKdjZ+oE2TVP0q15pzHkqGZYQQ7+lcm 2vnjPFYFJHtQ2tng95i0s9Mb65oblzcs6dUuANnSmgvGlTYN7yitXuyEcWkE7TqMseEz5qsU 4n2YM47aCgAk4XUnOoFr1XHeNfULly2SUhALkSWvRBSohAnGGQgMbr6augr/wF7ca8V01HCH HMPasPLLfFNeVXE345pWsoqGNYPZ7Gsi8xJXoIW16R1Bh8ek/4cOtNjVbFA0AX0v4sbGmp2a G7M1ewFe4pq+YKzQ4rSbfU0+jkhc0xaMNWs6PeEqiEm+RYD1pJ29IO2sqiusmBSAoej+aGeH MeGkZGFtqBYU8tW+K9rZsVxRUgfafpe0szknS7vCyTL2bvyq5radTCfnwd1EO4s6rOKCqYEq Cr990s4+aWenuk/a2Scny/JN7a2Za+/mGsowto3xLVPs7ddQ9h0L6IK12TVUT46aX0MNZKYL kWCSFdAFGAlmwEgwh5SIxg2LGd/u8BrKFdqjOFNVo6kho+HtUArb0jVUr1jZTGdDHG9bW6+h 0PWuoUZe2JVPCK7NmAglvYaSOTKJVfuyrLPwNdS9sc5mguwveJRrqHmIfl/W2ec11DXhya25 aBmvpOuvS6/r/Bqd5N6Zco0ujuwGJbnJI4i4cqCkjR+PePWTv5ERlPRdmWJP2giU5DEpMygJ I1ogGtpKbHIqyz4um53KfODPTPGWOGn5aBkgPN3Upn552e5UZsbgiQuEp5ci0WxPRLADHUcX 52ep4BvjByrTtGzqgy+uuynLg3P76KJqjd8qyvmdTEgqGV0KbiHKtKqNrhj6oCIA4TgSNdyE HxqMqa0eFBBpeBDnNr6/NGYt0KvCIM5BRYXGwngUk0YXxVMUhDwUv4lkYXpdQRCYM8UGgqgw EqQ4eXXWmRX7yejvzTTJIv+i5ARCCq3yMYsbm3SlaZNuVukT5cu9Wa1G0JPZjbL4o6UIoaxX 2ZglBXiDaoyPLo9ZY3CJIpo28QQ0UpiVUeVVeTbXA89wvAKXokRXr9DaFCYquX3MwtVDKGrj 1B4t55ltMw0oDeNryqKalWBYJZPh5YnSul0jbX1tOU2TN0s2zmYdqLWVneMq+GisI9p1zJPU 6D8Nq1FgTb0YBXZGRJfbU4IYEhetJN5d7R9//597NXdBbKQc3OV2nCwiTKqViDC75MZK/rVD 3BpWDkKTMq+eW4BAKFlPTleOJfH6mkeHNTU6KjqMceb5+MaAQ39GWTzgKNqSfpBcHacQnxYK 2zOKO+m4aBI/VOU4naqq3MTa48k38fHP67v48qGDY4cPTlwILbrvQK/9r7lEwNXvT8lIGHPr 5MNqnP7+xS/L/xvj50qVmlZhV8kuiA/9VUs3rFbrnI4yv76KI8JI2zkB3dm7D6V1L+3P5H7v 0k5aXA7ROpEQEnHizA7v+sf797/exbcp2K9btjn8qSFp5JiQtNSkgICQNLuRr7iooth8sBSS NqGCJCSt5UZ1SmRXGo7c0XmeQVcaGqPKooUsJM23ZdhkPZifrxlOsvKNfxN2r6gVnawHUbns 6i3WA6iPv3VI2m0JIW+dn+FQQkggQUN/OaN3J34CEjR4JyN75DCwk5FeSPykwcRPKHQyKulm tmYIw2trJoDx/nqusGbsIUWpl9zi5vvycqNrwDST5dxv0RpFkjVzBCHkJiejSWvi427ddSS8 MFvNbZ0VmOQX2rXQlsRPpCskfnKKFAHzIiHkNRM/wVkPdpydr5j4yQsy1CW1rrRi1Q4Oxwdx MrpB4qc0qUWuCT0hpH5IQsj7z239pIm+IE20QwUCkynKK37HMTTRlcCle7i9NNGNYBUHUMEt aaKxbJs+LVwSo05qbPXB3CFNdLi6UwefNdfjTOPG8dmGCjbQROPa8KggUqRtqOBJE32SZI+C Cp400ZdFBX+Ebw+9KrCgq8DCGRQbyKCIQoPiQgz5Hv+e3iNoMR3kUJ5m7IosdD6diiTyJbXQ idoeH3lmoVtN2SIriPvGjNjlN7bQXSwdpCYCBUQXxzFN+1kqxY6jMz1Lx5JJS+bu8g7XwI31 dfb7XrOlLElGZPIozzPMbZCsN8wbuiKZW8bx+zEg2QndLEtWerSY2tARrBiM8RI7964v4LaN cmGfPyQVV7rhI+jmxdCVmxd+/s3LtEDSm5dYkw/b1+NyLH/zff0Rb15uTwZ4kI3FkY/pko1l Iw9g2FbBxmJnus/gkfMALthYdG5j6RnmchvLIg8g5YJSQgtrZsq6EZ5burKNRXaqlqCNRd+P jWWeqYrTw1NxjbN0/VRcrU8qssPGkrPtgYLgRlZRwTwFXbXBxjKthW2i7raxbOXyK3azWbSx 4C4N7+5ubWPpBdG0lnkmh1vYWOwQHW1jaaAVEGnC5bj8nqm4hn87i4cP5Tx89ApQe8IDj83D x533Uoq4h99OHr6WVyAPnyt/8vCl6AEO364aQVtPIrbBkgKjh5N5+Pp5ugsevl4r02mfG1vg 4XO9uBgPn23sKjx8/ZuoVo06kYfPSbbMw+eeePLw/a48fEoLNb7T/S8oIP5/iWR1G6lGjeoc Wk6sdGVUNCHoUeqx41ljhWRVOJoRAr/uDACHk242KblC8JfC8Wd6gucFpcZE+mgSDNpikx+/ 9nRzXiOswk0bHhQ0Y226nCZB8Mq5QNa8K0oGA6xb0+VYvOuBsg/5cDE133+9Waws3tTruzb6 Xb9JPaDmaWcuGDr33GAFkeCJ1YYYl3QSttpEN1h9J5Ko8ign6pQT9BIR6sQMOVSvZek0Puiv m7ESgfuSWjqnyPUb5Eot3WA1TWu0rMZv3HER6n6WYKuNDzZLZlRERhofXJbMRyHa2mppVSeN cZTrcfo6oLExyjub03QysxkEu6moxJNb8GQ2eIEzklZDALsx6c6exewHyUsnQcbZLq0tqJvr /Y7GjIL5GEVCETCundAWhRrN8yutFasNcPsVPBH/J5wrFXeSifnWbztnQDZmmIqKEkQWJCvm LAUNLX1deEYCeoGwm35g8zGLx3ucqySHJZyztLCcoOSlq19yQDUmyZYaM2DOUnA24eSlReWZ BmJhAsZGUsnKOUu34kFgzJItaIlWIU9eurubU0ByuFv56W0AXUlb3z6bOSNA3Loh4UdjQ4T6 CSgoa+PoYGa/0y+ka8WdWcrX2m+Qa0H2jC5nWnWb3Rz8OYWeN3Qp1+ZvnKD19ilXmRId9vG/ v95HEdQkfoOX7MrMfhVEb8H+z//5bzdKPviXFud/dwXadQL5uG3fL3d0eX//+cOFKRC0lKDz 5OD7k0LpWadYG1BW9GvrK/FD2C7q6e4hedisp7t7elSaVIIbxNyL9JtLQN2Hhf/68qa+/3J1 fbeqrril/Znx7PgYr6rUJIEArypVVZdLsTrgIDzaGsYSgUUteVfyEAG9ZScctELRG/VGqPEc nMaz2/cTKJ59Kn96Vd2VV9WtySNJ1RG3G/Zf89ev3+U/7tsgw4vf893LzfBLF8zww+mCaYbn dy4Yj9xfXhKXquFQmhnnwgMrRB8peWnB4AMWzNSXjD5SFY1zuUvVXKcGFsxu41yJPtIOlcG1 xNGCOcI452cJNs4pynOuvMg0oblcP7MX+AX76YFbz5UuPxmXzvsjfpM085vJ73DmuusFJvkB J+Px3FtqrBn+GZJygmZDHyDCFQ1GJB/E4utAcw4GWb7DMfPAMx7EhuUkjRkpZlYwy16WrCjI NETBH3tdSV8HSSZ0xEQw/EIaRYBU3NFWgSvAY+PIikFRxC84NBa/rE2dCgNkfoLiwWNGKKvz fhd0hUtllD2C1jmvYq5WnrvHedbukCw9HSzqmT9ubt016sSQ6g4CRcVbtsL7U8CO9SVwZ7fk JrWOBieCHADHret8k8pn03E12TEPDMgjqdOKZC1khS/N1ebZ3Gac24J60jr+e7JgWsNs2bbm 9/SVM7no/nBevL3H/1OZ6U41Gf2pJ/l7YqZz6QgWTyZ8+0nexyjVpi0cTEBmOoHV5GGpotO/ 33CTWI9gh4Tio2o4PmrcIvOTvCtnv3vc6yOe5J/MdBdkptOooq0SODvMX4CZLuyH3VHLCaoo 7QprBuSg0cX4qEZgbA+w98VMl6W/9O+wL2BK1qZSN+CgWWOmS1f15GRn4WV9mfSXoU7Og7st /SVDXVwQKlKEPrcy0wkd5SmMRT2cmQ4HXo5ZfJQ0Ko6PsgW3jo8aRL0XDho3RE9muj8gPurJ Tnc9djq72hhrGYQMLsxOJ8toupMldjogcnqRna4VBkGctbdkpyOEqy4088+fWdxKdAvO2jPY 6VYTY2caN45PGSpMs72NnQ5pnRSEirQNGWSR0xdNjH0mO90zMfbjJcZ+stM92enOZKe7m8TY GLFt6CJbFCteN/E7eBldMA5z1AWJsQtrKEcXFW4K6GKy1aVf/RxdOKREVFtrFqGL8N7vzhjx G13pjTkoL4guxlkq5KD0ipXNdDbE8baVJcYe35Oz6bciHGNPtJ191PcYMcYnJoLEgtaNjdVT jADKlTDd2pLOHJAYW/E7T4w9CFJm098k2TMxdvijmQKkjc30gecikxslxr5/Sn12VWwx6tod GC3sXqZlyWghdtO96YLRopGi1iCsEAtGCwHSvemi0UItXGeIntJ/63WGLBstVCc0TKkv7sdo Mc8UluIWdG/6GLo3N1Ol720JGugtdG9EFCQTUQqgBbo3nVHql0XdbbRQHPKV2/EhqhaNFhaO JpT6za2vMwZB2tbcB92bHaKjjRbgCog0wUMDi14f0mjxEFaH2xPB3o3VYSMbbKbVe6wOesHq oEGrgwqtDmF5gQ1WVaxrnAN/AR6QBB70fqpshhqp1UHWors3qwPE5+Z+stV1g1IPoWPYYMtW B51aHXRidfBDHO87mdWhcB+CwPuQS1kd1Barg/2STjofPWcx3KLVQZWsDo6e+IJWh21Msism 9SK0SJlkvYv0HqvD/oJHsTrMQ7QFWlwSazSZAkBWh8swyd7I6vB7XoqcxUZb52y05AqOzbmT xkOy0WLO9IXYaJUzuwBstK78yUa7Bb3Y8yhTVaOpIeN8HchG28/TXbDR9lqZTvvc2AIbrevF xdhobWMgG+34xPiHvJvREM2NVQv0mbslg9hoowpakKyx/tOOqQ6GF7e8bULOKUM1lgF/EtjN /uHHZKPtNZFKRvhjstFOb6xrbgjEwrVaMDfW0poLxpU2De8orV7shHFpBO06jLHhM+arFBpM MzhqKwCQhNed6ASuVcd519QvXLZISkEsRJa8ElEsJiYYZyAwUNqmrsI/sBf3WjEdNdwhx7A2 rPwyUxBWVdzNuKaVrKJhzWA2+5rIvMQVaGFtYjQbq6T/hw602NVsUDQBfS/ixsaanZobszV7 AV7imr5grNDitJt9zTF96ktc0xaMNWs6PeEqzNbhRYCFrmotmuw8CwQX0jgk+fr+6/XLRxDw qR0/WAQpYdCFmt3GookYJjh9clOTiYQ2LV8wFuERbg2nk4izYhPPxfieqo3vkqZyegoxTFUw FgFwy1nDZ86MmIR27ss9kdCWeC4Qo26hxHdJMNy6FM9FMEslnguhRT4K0RMdqafvZjK30FF5 aAwTZuyG7j1SDED1GvC3Amasneys02owJXZWHIA8MzDpRs4znp01fWK9myC/R/DEKBnMGws+ WrfJBIQswNi5LrQwnUfVcczmb/1E9ZoKkr0ONGOl7AIldtaoMZDPExpvP1dRNyF21vRmEK5r C0Kq16FuszCba5NXZ71asYmNUfJMk4z3gERPSKFV+gQudJM2bbmb/ROZOQlQ2hE/ZaeqSeHH McuxXVFps0ezYxbeoBrTo1nr4Zg1BrN0ZMAJcENUZXwqKB/E9P0LSlsUNaZ67UVtRKdzetzp lxSItN9tu33MIh2ltmokCLdolmVP7LI07gA/aVX/WVmggm3FEhNs/81ZqC7rqxPJnsuFezo5 rNtCAubMr1/etHh3tX/8/X/uzdwxppIyT6zbYDJyWalWyGXtChsr+dcOFLhY+X4WKS28vtuK tpL0b8J+WIsGaKeVGRutwWiNjfZEPlGOO8Sz90mO+Mr7juORvQVNc8WXaJoVX1ycJxPfnsC2 egpVbtdY9D1Xev+Ur76az+W8wG9zPuntbRh29qvqqZQ8uNXYLXb5If+2Y2MVzo9K55Z83Vxw 2k/k5UGcuIF41z/ev//1Lr71jjfOO3b5WuxP5eVJkyleiZcnNbMggJendl/LRUvKDobdVlQc N3XOy0MYNR2FvW66giHFHto9ckvvrVw5xVne8uSQn/DyKM6HXMcfabk0z7zlEC8P1rfk5UlJ qNF//FsdQEI93PA6oRvD7RjUqpWOQXzZ2Lj/hhdXUjGDspVC604zVvJPa8GVgitljCzd8OYr JZ7FaKX075/ZePqBcL/OyFqXTI5l9/Xh/flKGVzO85WCwZVix0sqXlopbWGl0J0rZX/eKymz vFdecaQ79R2Xb7R/7zxP0A0vllxytnRpNCpSOrrFo3B2nk8KGhL6y1PWdRq43xp+VaxtjOa0 KJmeAo2NKyipS+a50UzziqGgwK5yTeAkQvZX44Uhsorp8l1lT0AT0GAdMbfWktTRjFRaCRK1 buesVWBjbcVU0gmjG4ChePjndMtVmIB4rtxPZomA6IpqZMMLCQIUDHO2XzJZub9K1sdfui7S MTSyaI3D8CBCkk0XoIXl1KoNdbd2c3zUDaKLfiGVp3KVHWocVVbf1RU7oVs9+XtjxXMNVeF9 5obG0oUeqkZJi7esAP+atFdjwaDWGvGuvGvMY5b3G2zdyl5sLNfvRK1T2aOwF1Ay5HnO/LOD 5dZKNLzthKgLOd6VJ6JiHCmPEo0ZWbRhgJVyg6LrZPnIcxkEAMugrla44hpvOYNsBlj+EyJx pWmdAyzigEQx2cfIVR0DLFK3TM53utE7UBdRhE7ls91gAljh3zKA5dsyE8CyiEOxrq0VxVw2 ZAlg4RFg2Tq00qbVdv3hDukRYNVWBTVzbIZGOnNZCrBSuSKARSrBSB0dRYbnayya7CiSjP25 AKuq7MERvNN1+UYp2XKne1mANczTf+Rb5dTtbEzjAjIVWPWXRiEq5sYq5/uEh/8xRW1BFxR0 0haEd7r7vKmzurVz9amjAibqCsnGed11jK9uSMutWyUeG0vuTt2zxKqDd5DE/aOLrZe7aetq Ej5aO1JZsO64+iPJom66v9RwXTv+WEUFlDUUZWsFGDP/lylv/aAJTR5uWAWqoVBtkCxNQA7T T4hd1P0wMTPejOpuKAg+mpgISapIae3WVPHCCqhN/GgluLqs0spUaeUllXaWXXWiLufvoADU vmg3V2U/u5vjj0aN7Rckq7JHstWCBcnWC3Y0lgliN8fOJJujoo1oMDG41mbZgvVklr4ks7Td WYy8DrN0QUUAhqdm1X0uuAwvMDwNv7alI9RK+zJCraCtmzI8IcIlQanV9x6YpWOtiZdw3XU6 TCzUc7eUTDzB924qMMlvemJU0rVdrkY0LggVKbyo28wsvTVeEhyzizNLz96J2+MlC439mfyR G+MlL/k1/b2Zpe+foOlJ/vhI5I/R83yBpQk1pQthgKXJTgHI0uRgDmo7TEgEDW5Pw0BIK+oh kDKBBlVd3YKl6Qzyx3GI4z3HrH1MBhoGCdMwxJMLbdnrsGIr+SPGBfJHp4Tp1hardpGGoUVb YMVGGgaY/HGtoIkbK8EKnMIKvIOGYRvD08IEgLCiF0TTmuQOzregYcDH0zD8AeSPd8qjcHcE kHeDLzayQGaqvQdfiAV8IUB8oYv4YokFErESuTTIAmnK+MKYyuA7wxcZUcK4mSG7sMjsBH8c ubRewhcixRcixhf9EJfxRbg9JDRP6Lo0T3oDvsCklpPOZ0q4hC/0QeTSMIPkPIi3I5e+Dr4Y BLk9zdM8REeTS7NMAUB8cREGySfN0+/LQimrWuDBcd/F4Xzov77ZyX0daaf8OOMo2qFA6rSf XyC9ICGqYUoP5SGdk/0JhucveMJVrRqJ6gJKIQlK8TbXal4DEUrxbdEGJqMsO/tOcfw8Iaps um6zW7yJQ4Mht/jJCpKU1yNKKbZFsz5exAqiWpw5+/ofRpWq9OhvdQS/QDBLJTInhFA+O8FS EKwT06aNx1HJIc+kJUnjWQxz5i1aDryvC5IFClvC7KuNxaHaWDTdyLkZqEOhm1PdsSCgTCoH JgNgLIpQnkgwF7xFh19b9F1QLB8zeCDysOMYc7Zc8bkxiHoCcbpuhiqPSCoq5+mowvxL4IgE WjwMN0oVL9czh28Q53hWyVZQXndIxYKEfuLDzlr090BthNMrPhs96g0MqmNd0trvNNhNqCBw a8IQNRfCuOZ1tAJEg0xbmN7h/TXaDcYCQVocvz8KvI8EqdGKIADf1ppksyAYs1iQFrH4/W0H LHRQEFbqd1myYEREm4xI28SC0PDEOLwfVo2ERKogSKoaTfDRWIe4J4CgtAn/8QjCwv/98v75 U3x10fJ93Lxrg7sgSlwErH5nDtrwPAcOfHaLr/bbVxZaXnd8LZTd72p9+Pbb56foXn++fRM/ XofAcfuPH1+1bwv7cOMy0j455PzkCO6T4rF3xydfIhT7RL6A8yK4d/f0uNDoU1XlTw2NbvLQ 6GuEJaQnRQSERgvFLxcaLezqqnmXxyOMOzpsqY7OgFCd8AzYIkrF4MOvsvKuEBrt5QJCo125 OIVj7vcPja7EoaHRZ1FlpwsK/ce/7IAF9aBU2UINdc6nytaqAamyXfmTKnvtBqh/hwukxk22 rvbcAJ1Mld3P011QZfdamU773NgCVbbrxcWosm1jIFV2qCwKpwGuwV/apKCeC5Q74bYSnS4Z RJUdP1Ent1P9o1RrznksWRBegx1lNRPtfMExVgUke1Cq7OD3gFTZ8Ifv1hTGx8RfTBfxAo6/ IEUukTz+YiQ/BOIvTFsTYg/0Ly9A/AVpy/EXRMP0xXAqTMMo5AQhUNcphVppCtCSjZ/AcExq VbpewIp3PWTI4i9Ie7P4C4koHq6D1rNFXNfJMpil1fiLgiNDCzoygDZk/8sLTPILBrdX0jUT ZqN4XDA10ETun1D8RbgWBgXxjgxRyEQk6gnxFzqTDCoodpMsOkoinMZf4Gf8RRJ/gQ+Pv8gN 0vs14X7jL/4IHwZ8VWCRM5LdrYulYWxbdGem2NtdLO07FtAFazPnBXflYmAXS8O4ANCFRTcd J03FCkxlWSZN/yHQBRdL+4Bu2NDW/btYEiS6jkkZH7CPiO70swS7WPaKlc10NsTxtrU1hKO+ noul79aWEI6qEBmKWI5MYtUuhnBEXpFFZLLJxVLo00I4knvgIjIxKTIxz0yaLy/JEB0dwoEz BUgbc5Ghdr94YBfLh8AX5Kr4IifkynMv2c3Epx/QQvm8A1Z2sZ5yqa12o4o45dLgTm8qHqdc CsoXUMX5KZem9yCIMwIbq10jqijo/56US9VLZrb3KZfmNEnbUi75xDQvL+B12Ckpl3a5RJZS LtmeKIHwFnquC7pEjrO0lHJpsIQS1SKmCGvyfbGgJ8meOudAGl9cV1FeHZ9fIFVgyB/J10Wx B2SSG8crRu6JuHBkzhQnkEzjqs6cNcEjc6+QubZlqjQWjI8VJgDKaDU8YZJ0mkEiq1AyE7L2 DF5WQUarUr9t60RSXZe+kPls0vROBkpkBRqN3L0VnzrBSJIEKxV1mu819DpJhutMkKlgKU3V 0Nj+gryxSZBYizmgxeXlFIxZn9EqeS3Ju5lOEaxnPqNV9Gjo2AtPb5YHPlDnPKPV0mJNGyv2 ahrvQPY+kVUqO9jNOKNV5nLcd7PJB6KwBUEZrcaCMeA82y3zlEtlb/C8IHr/UsqlrLHSIObd 3JpyaQ3zpDXOzLS0P/uM37VdDXd5/fpLfP3n9VN0X/VHmFwJq8o20hRzgpyd4MlubWsJnnDv l1jO8PRoKZpkIwE3VVwtu/7d3k+17iqfXEp8U69fbO2fr+brz4+/vT+ftk06d05/9Ck2IFpv Qp4b+PLdW5MnF0ivtxot5qH5PfMWdcwYdyqUf2v5zzggY94b5c6GuOyd6dQDeOPgXHvVXEk3 cdB9piK6V3/blAb8SqmIUqsDAvxtuUt6uGhhoNv9bSdYkPjbtrzh9oCPX5Jri1bQpqMdaGDw aYKa3C+wr9Pm/raCMqVy/u+gLTgVUdOcYmD4/f1tb5uK6EnkekEiV9PWVHQ9+emtiFxpTQtX fRV/eckdiYpErrgireLNywvgSHQ7IldnvxcKAXHKzKgmXTPbfWmHf70akWvmSORD5LmCggQB a5UZfvntXKaT8+CSzlGfrRhLCJNNVBApUnSK3E7kGjgS2VVh8ZFqKU2WYgg3QpBzaSLXhbr+ u0Tr+fBuP9OOf2PV+WpXwYbGWtHoivAFgjWNG0ZEd5JkPQCps/wvJclIS+Ihqjt5nQkoFfze RK7nOhIdfWdXXxUjjKj0AXyCMCIH0K6RBdo1ktOuuQ24SLsGehzbLVkrq0MdLYBr0CeoRLvm QE/XkBgo3IFPkMtiIFDmE1SRGpO6QfHt3SGM70u0aySlXSO8zYc43oHOpHUdHx2hRCxZEWQ0 EMhY+RoQxqacNfGjsjUZyMheB38NLkjr2hqZSbal4HFpXQdR78Yn6Aa0rnWmAGljPchonz5B vzdt/Kk+QegCPkGeudo5VyQ+QWP5Aqq4iE+Qf0/FM/NDX84u6BNUAya7k3yC/GXwC2yyO8Un aF9O5AJNmiaOnGCT+eGyNGl+lpZ8grKPeTqVs0tKizthFlxS8kezD2LmtALgnZL3Sj7JUT/p gt8BQGQWAAH7n7PzRu+0gsQqeFrga0slw3B65cR7pVOdaKMo1arjmM1fSN9p3ID5YPshDwqI NLyb42dHQZIdBHDKmntVmJEFp5WFbqZzVXZa8U+AvhpT3eS9c6+GgtxpZaGbWWNpr1bAE+i9 Mnai7LQyTlypm00+IskTgNNKNgFl75Wx4FwKQwPR8eVOK+vLCR4z54GQjgywa0x1s9bHf8kW 3PDbQGG4sNDj/9xKYQiO2TEUhvfpE9TvwWveNYShp3fNPXjX7CYda2uDtX+zG5teN35+6PfX r1+9F82SJ86DUM49HVSeDirZxJznoEKPIYRLj8Do+oRwdo+S/eV1lziiUGHaF9iGPp0qtxPC 6dxBhRsLtEuEcE6uPgLnIytv9mdNRX+Agwo6lhDu7nL+HOSg4nKMSNhBZXO6n7CtBnZQaRkn kIOKfQcr3zsJCVmIdHNKpmFsEqYbL5dUTWdegHsnCd479X0XqIYyDfu+vNzo3qmcaRhTjdXB 907jLG3JNNxrTXzmqTtJo3PL5TIN50l1UhXqC8h835ArUnSkAR1UprUwK9VFMw2XUvakBSuH bd/gVTIND3VJrSutWLWF+z6q20t2z0w3x2caTi+xck24XMqeZ6bh/7o8TWz1pIkt0cTymuEn Tezd0MRWjaBtHSRV+DNpYnutTKd9buzWNLHjE+Mf8m5GQzQ3VpXISi5FExtV0CI31PefZItO g+HFLQ/SA9knrB7qNod3gGQPShPbayKVjPAnTeyFaGIZrxR1dsSfcyAwdUCiOv/c3MbjTKKv n79VJp0ZEgbI/Hkcfv2gtibPirmtNjo3B+/Ivn4h4wPEEFtVm87NJvllXz//2+VZ0V8bo9zW ZMbrsw22pqGt0Evjap4VwmoRqTnZ8PW7lGdFMEvAt88AHgbc1BjlUx8sBY1pLYtHkCqbusI5 LrgRzHfLSU1KdbHdTlvV+22YyLMjOc+ErCNJW02g/YPfRqoO6bkZdvEIeEnGQcyu/ivITQOa AICXxCWySAcCPLZtu/ndwlBDlB3eTS4ewRP9pECqkbh4eK8MxxUYqFXXUZpfY+dWkE0uHr5j C92M5iq5x+9dPJIxrLPpXbCCrEwAyolhtjUW92pqPZBdSMHK/gspXkCoMBDgBIyNpJLt8NvY PmbJeEN+G8XGFqlb8vkWjczCdKZ5boC6RdlXZxPHqyfz27BnzM3GnjaBkpPfxsKY1cFHY91g s4550hr+07BGflIpuUR+chn2Er+bzPewzjdkNDQVL1/P8Mlwyy7zqajJmk8FqgCfClldx6Xi xBt7jjvEs/dJjvjK+3Z7XpzsPbH7TbsrNJixJnMZ+krcUGg3fKSoVcf7hIiWcpxU/PGufwjP A8PwkiaflsKwU6wNNopwdJp2cc09rCuKkI1nhnKC2xe+64+f37w/ElOL9mVqmzReHawi/O/n 68evL5/yb1/RWbLVBWl2iAVGbmw/5N9a/ezN5X46WNl95TR3mYf1ejnJ2n+mqww6xlUmtWkg wFWmxvJyrjIT2MpcZRrNG1669t/pKuOlzlxl0rZiV5kO15IAXC62vDO+/Okqk7jKHJw78c5y N6gOV34bJL1fsIWB33oYiNxG2E4X6hcL0s6dZYKwoWzV1KwJV01o6KhM16arBgWhRmvhVFCd LHFDxS/oYLYznMq930WHXHfVXIxiGTHOKdp05XVZimU/S6mzTKgko4D9UTSwUvjKtamzJzZa w6LGpoKZ0Rm3albgF8AaltXNFkXwRy8cYCYa9aTcmO8mj+wnirYEiF4e6Xo3WMPS9xckCzh4 y73KDBuQNSwPqlC0QxuiSwqS7bCGBVFMWWOYiooStMX4VbJSvLysjghalN2HOgB6ltheZlHh xpbInw+1ho2SXcQaVhozwBo2qXMD1M1aH/8l17PkybI1bMih0m738CpawxbGDKSl7sOZTohi KnZzNa4rFZVzmPyZmGSTiFufCuK1ObkWbDP6bYY+WUW3dfYRO/qzr2qBz6v9KuoPZ7Fr3RGQ LARldd4QUArKEu0iUfNZtruT4qEOtd1dLByqaYU/KX95+1d8/dKf8AOLVOWOy0WK4Du26B1v ZXvSHl/BlPcY4WHEkf65F+k3d7vRm5x+fXlT33+NIYK46kqvfFRb2ZlmL3wMhXF6uEeA2auS zYrZy7OFnmv2okgM/py52asacekiH8rUlqNDHhjbVFY+rYecwrirYQpj8aQwBs1et6UwvnVK sbuhJzRMHJCyVCykLBVgylIcpiwtKEi+cCrC1hZO8G0p8Bhz5bhmFesmy1dQ56b0hKUwsabR lJHWxAvnAHpCvJSyVKQpS2dX1GCIw0UR0xNGcCNOpn7llKV4S8rSGhVSljolDGVP6QnxQSlL t4WYZcaTuDHf4DNl6fy765SlJFOAtDFPT1jJB6Yn/BMyqt8+w8LdwJONaRaylbEHnugFeKJB eIIKGdWxO9SXcT3FBXiCI3gyrF8Fsycrn5xOJ1HsdwBPChnV7fca1Y6l4HB4gpbgiU7hiY7h ST/EZXiSaVbQ3faq8ARtgSeVZ77vJcuUcAmeoBI8cQp5MXiyNUVDadGvwROcwhP8ZE9O4Ak+ HJ5UmQKA8OQiKRqe7MkL+OKZnWH6Xv8e2RnsB4syqVjJ/AFkZ3CEJkV8IakU6s7wBSHcmCHW PjZ/yLbNYt3vOjvDPMRlfDHDCYw6suKQgUK2GiAHwlhnG75otpg/JJkEiZ6zm9kyvihnZ9jG sLMRX5yWnaGGvuJbGXae+CIeomd2hiuYP/6wRAtHcukZUeLSY7u59AzApWe3fUK98kEogS1w 6TGQS8+cwqVnT7aFZI+ZFaJ/dy0nueJkj6RpuIlRQtCXG6GELNnj/B0FrBCwezCEEoZ/PSnb wonJHv2Z27nrLdjox6Lyhz3TyXlwNyZ7nIP+c0VKd6YcDE3vLfaq+KUHxyzn0otgg5XDWJHD ggpJnXazsWtdSnsiQ1VS10LJqK5CpA2qoK6Rqsjo3uDg0arVIvie2p+oSZ24T+LtXzxMRfJE nbqcNgBxfdKYibNqBb3SUZUlLr2BasICGVNJrDRKXD6vzqVHMz1LNcFz6WH8kFx6j5bs8cm3 ezm+XYcRGFa8AjHCmXy70fNq4aZC1QXeIOimojW8xLdLUK1V14EY4XZ8u2BCaLuZacpUF5gl 741vt+AMAd82nIgR9CkYAWPWRgWRIm3CCDnfLkcXxAhn8u2yRWsApmmuRrqdb3ebNWDl3qmX 7I75du0QPfl27wkj3Oc9xVmUvVVO2dtcwe85d594SMpezJm+EGVv2xmQsteVPyl7/2sDZW// F2khGYvJ/rcbKM6g7O3n6S4oe3utTKd9bmyBstf14mKUvbYxkLI3VBYVRfYkf2mTgnouUC4N QSvR6ZJBlL3xE3VyxdI/SrXmnMeSITlT9jrqXCba+bs8VgUke1DK3uD3pOy9EGXv3VznG0bY 9d0FSVd2FyRd/B3sTyq84C5o2KzB0XU+doc60anCIZxFh/DhcFyrFjiE27ZQ1VZWtaJD+O2v 84vRDNodF9Chh/Bglkrugk6xspnOhjhG9xujGZC8nrug79amaIaZgTh6rop7FVznj4NWdBeM buAjUU+4zofuQTZ4nEHfGuA6v0mv85tnNMPLSzJER1/no0wBdjS28wD/jGa43vXArTnG7gie sAOiGdhCNAMDoxlIEZ7wDoAnw4+1dQGeAN6G5WgG++2sTYP5vcETOLMO5Y2whyt0A29DsgRP WBrNwNo2H+KT4EnhfuEi8KRnH1qFJ9h+syedz5QQhifjoBW9DbfdL2yCJ0J3mWRbCpJPbQme wPcLT3gSD9HR8ARnCpA25rwNCRKP7G34B8CT23NBHOS94LZDCnsvbKaBCOr0UfKJ94L91IhK Ew4iE0EXaCA6iAAVG9h7wTAlit4LThkKyAT0XhDlbMG8USZGJkFfboVMJJVjNqYkW3DFalYd nC14nKUl74V09yuc9EDvhXimSp/sErpIyBZAQUjVwJJ5RUp3JhCA9Wthm6i7vRe2UjkUu0mX jR8glcPGy6DreC/0glgt7PSO1MNXzBa8jcrhkgAs17NUEy5H5XAD74WHQAa3D5M8DhlYKFfw a9wYIRnUQZBfo0MGqqMQMrDvWPBrJLlfYx97tz/2wR5XCjaLSr8AVyowQZT7YYO6TgDIwPfl RsgA9Gt0P22PwQEbzEGxD+MsnRL7QFTDFXDxClFWl4FAppPz4G6MfZBNVBAp0iZkgDK/xuBa hCskFRJV1yVLkW1DBlujHE/5MHV272mEytw11iMM9hSUGqvUWkFwwd8iynCngcZa0XYELXE5 e5pKoXP2ekgyEgOgfoi6HKJcFRnkRPepJlwuyvHx/Br/tPhIxxXbQFyxKOSKXfBB3HOtQfqD dQAR5lyogfdhv38zFVzZRdcaAkuBJKtfkmsNu46p6IlBE/JV06ku9rqI22rg8MgBhvzG5Ku7 SRQWUia3LTPjwfug7CnjLJV8D9GFPiqTlgRPNUSlRvRtjZ0gmddsggHwMq2F6FEcOEGO2r9B Mv8x40avSOaWcfx+Wk6ye8mvev4ozTeS/g9z/F65sV0fs20b5cI+f0guuXTDRwCptp3gFedy en4uOTQukOTol2jyYft6XE7r33xfP41UG900l9ytw0CPhUI1CIVqBEGh/igLLZlQbaIlYw8u FJl8ybhyjMAl0zVId7Knrc6iQP8MKLQnEKOYSK6RLekaU0VL5ggopI+AQpOWXKKx9br968QO Mz6KlR2ZpAADKdcKUEioNFlVBoXC47wXla9dF+0r2N4YyzeS/g9zmOJ9QCF2TH6RdMNHABSy E3y5tLqTquZQqJ8w2Ap++L4el18yQehd7usnQiF5SyjUXBUKNcnKuGOXV4z0AQSbeoFgU+cE m/ZTqyCCTVfezhRRUUQOEY1UNa0KCyd1ee2zF7IOoM7q/TEtwJgWTnpNNC6cg6+Pio4lAjPe 6UqeeH10Oi2GWiLY1CnBpuZtPsSxXXqRwDsrCOr2Lq+RaCcSbI51V5ACQQy+ekKKLRB455LN oEJoEzYW35LtdXlVnGeSTWPm/YYJ47R8A/FScHkdChCOY3nFk8A7HTNH4I2Suld2eW0yBUgb c1hVG/rALq/36ZlyFjFGnRNjVFcA7LlDy0MSYwg11LkAMYb9bILEGLb8SYyRwo8iMQYybU3J LYgx/DzdBTFGr5XptM+NLRFj2F5cjhiDd/dKjGElWyHGsE88iTF+S2IM+2OS4aZmhlpFYrRW L87xZ/5/lXipXJg+qeoK238jFX6pWf8oEjVhUTfnWsx+pRvyYmvRqpmbexnrVKxqbIP1SyUa +4B93P4aWpO8samuFQP5Wrhv8oW1rGLYHmOGRl9CuVnNAr5T+77Kog1AEOL7NTfWIDsgjT2y LjSWSsa4HcLKs1kCgtCGvdiX0ArPxcFsjoJY9O969+Ke7xtkmOmaAzPCbGOt/b+o71Qwm5kg nGlm7P/H9rPmBanD+bCNTe9v7f+jVbDQAUEqETb4YgeP2/9HiwOxCLBuT8ByhKPwZG0QcAjR Ru6VoC0OhhBJO+4EN4Clx75jIbiZ6NgLaGL1KIQQUQWEENn3a9wa2eiCpadJLD3LBKj2K447 GXOvBH25kaWHKFlxiCQd2SOOBS1HBjcHs3QqASqcDRZqLCFDGT+zZWtNznCSqEP/ecNIwSTp yClfKDvgKBxKFirVBUOItvKnFLv5cCFEg6h3Q4B6gxCiVDVO0YTf11H4Pu08d0adQirZcNff X+9fPvXrz7ev3+U/bm64Fb+6EK4YvodVHoCUeRcXtDQNQCI5rvA/42IKM1yh24q3s3kjvHoN 62SkKVJPJpxErHFPWLx6zb45+69eSYYrhr6EJpzgh6e2ruRSU/Iutp837rbVDSacC7rUjLME 4wrvVJF/AMInWmxhaGE+gl3Vv0cFVpEMRnglQou3IUPBeOmTWYOmaKbJtT5bJcB1VOm9+WpZ 6ebgOUJpo+NBtMK8OHjiCuJBBCXLOpFJBos6tw5f+vTLNNs35gKYowVD3QSuwVqKEgzKdZds Xy04ZkNj0VudkTsRJM3kcjoUIJiTrN/gFV7ob+3OXZXmVZcJgrPOgN3szybhENlPQIR9O02V 3DYBuEFsBkdYcoNalUxvHSPrTjYSpnyPNKG/mEcoErWjBItS6Ep5zGwBaY1Ssa50hpIuW19g Ny0cq/PhXR5VMNJwQbJV5TnxRtw5keXMDhfBr6PseWN2wOypWW5hlChItg3QbsM9aS3/RbG1 /v732+vf4sfrm/6w0Ov1h/hLvxrx8+unbaGilUOYRVTrvzl9G/rbz68OZ/748t29ull6td+Y B5c+W/N/v3xaCd4s4Hy3VY1xaBO3tCy4VflBcPvCd/3x85uD4JgpV7GMbN22aOvJ7xZj/u/n 68evL5/yb1/RYXdlytjdbp8O+Ss13+p2tkoZ7bvdxHVQ/q3Vz/6A0LS2BiveA/v9xlb58fn6 84eyCPq1R+tEuk6VZOv3HltNv4nOAnYLn99ff315U99/ubp+JKuu9Eq3Cdm6//Ynob/Fx+sP /aYsmh/fzbzIpepuHxrmwR9K8gb83TcvNuD2nkENvODi4+PLx+c4upGF9fyDjd8CID/SdpMf KT4mpCY95aBbhdRMm1caUiOorrkEQ2r6rbDKQ2p8HQ6F1EjGDexHOn4SUj9SX06eITWQH2l1 05Ca23OT3Ykf6WaCMkh5NlOnioXbBQFSp+IidapaoE61W2dh4YDUqbpEnSqp1gLdG3UqIdwF KwBWAIxUxZubEJSVqVNFSp0qQurUcYjDRbGdOhXB1KmRaKcnasdbmN0rUfAjdUqYIoAFyWaF vGii9q3kZmnBEYnaNwnyuH6kt0vUTjIFSBu7HLnZkzr1etcT1VXhSZ5o7aYEaU2JOlXvpk5F Bb8HKqseGWTIRC9Qp2qQOhUV/B6wPSUWqVMrIUkBmYDUqW3R74EapATs96BvRp1aSg5PmJK1 qdTxyASd4/cA543ZAyYynZwHdxtBWpMURIqU7kwgAEOZ30OLtqALcMxyvweVSpaJ6n7FbjaL 6AKn6AJ32/0eQEH2fGX3o4tiY1dM/LoNXVwSgFWZnqWa0BOk6T+SIO0hgMWtWdXuxu6BETsg fpYtxM8yMH7WQPGz/nm+kFa+qkvxswC6cOGKJbtHpbtaqjuzeyxktONMy+r0AJZT42fNUvws S+NnWRg/Ow5xvG1tzWhXsHuMAzJ+W06xe0zEfqlmx43hVvBJ5zMlTLe2WLWPiZ+FU8bMg/iM n72S3WMeoqPjZ2mmALndY6S9e9o97hee3JrpzMJHjzu9Z8Ff+vP1+683O9jiTb2+a6Pf9ZvU AwhlyzCF74EphKKqqTMjiGeuqkRdgCm5kyYxLGzrI3LGHLxzQpgSPJ/BlLStlPeMzHG2Jbl2 3GtWI0yZi9xmOTt8YgL3JbnXxJ0a2OPze825LQq2dTXeM4uE1EaW+EvznpG24KTJOGMq0TQc fWEVbcmMLPrWIJqP3hVy/MLiwZvQZfHN9Dh9HQCgRj/bbE4zhUlnEOymohLP1pixcgEd5D7L U2PBYog6UdczXf2ot2m/gW72dXHseFfHknn9j1CRm/0lU0M2iMFAaOzgWTqIUGP9ussnIFsx Q8GEIFZsPZNqTHWJYXkBkVTX641Ng2jqUr/XGnNeCHFjNPMOFksTMA8vsaPG+TQijAycoWnd bL43Y54WaCyan/bqCQScG1RHKRCAnWnx2nLyY1YbEaMx37HimPVTxBno8YkVd37iiWR1Pr3j FFk0RAnKdg14KQ6NZZKlT4ATEPdqGu9AdiEFm72DR9fyTLJJ5mxEirKPa7MOPhrrGPcUFJS1 4b4vtg1X3bXjAe4iOvbfG481XZ2/zNvrp0VNFuA6mOx83xxUJUVXS7/TBy98dR9E38wP8s0h 0M5Z/0gRXvsN0tV33mevv8TXf14/nZ/ix2v1+lX/q786GbByTqZNU3Jx9NuA8zMUP9xrX/8S r5/fvRBhI8w5uxJd7IlT5X74nXviX/+Ojdi61HkAFr0/vSL5IXSOjvL7D3coIbVD61XRtVE0 cnSu9Y6x3jPX1pPVkjcnbrnibrocCnf1hK9Ud5z5WZbF4wHiFLf9PL992iF+/fn2zQ6X/P7t 2/c3948fX7VvC/vOlk80TNnTuXdD/fU+iqAm8Ru8dEZhdmsS/WnoP//nv90ode7sRouT0rRM 9UP78c0Ka9fQq/n55g9fziFUv7///OHcQQVZcrbd/VradQJ5R2A/OuGbCFp0mW5rXA8er8PY vH5/cwOj6sV53e9B3FUN7ZXe+UW/fvvm3ap7JS/6xXaNhcpzpfdP+eqreabU4iLvmDFuFuTf Wv4zOh/7A7HrmBt6XPYBdkoLvLHyalZ+p3M+b1edz9v7cz4/YSZPcux+XOfsM/2s74iv96jU BVN5lroAq0LqAm4/FaKQukAAfL1MUz5fT8SpC1xbs1NGXM6fftb3l7rgydc73QL9Jny92H0O Dd/qZ73M1yupsRtT9XJn940QYZ5F9qwTGLeSJgvn2t5M5/H1jkMcLort943tVe8bt/D12jfK Seej51ocRUzv4euNnJciUU+4b4T5etcKEqct3yDkZ41TP+sd942bBHnc+8Z5iI72s/4T+Hp/ y/vGs+h+SU73e424yjx67CHpfnnN8IXofo1uQLpfV/6k+92GXvw7tDsrbriGhNHLyXS//Tzd Bd1vr5XptM+NLdD9ul5cjO7XNnandL9OsmW6X/fEk+73t6T7hT98t6ZhJZVoqYMF71qogDSE rpOl0XNJWPtybqp28sNp46nZSMLamPCXHd8BsrSoLWJgElYiL+mHM7kLz0XeHwCHH8BU5vwD aA9QplUvsN3r6n44JbI0qmpZsw5t+ABeyg8nmCXYD0dRWfGXYU8h0+xk01XQk5fQQYV0xllU oxfXpOSgMis2fD1v/2Jih4UqluwABxXQpaFXyFzbMlUaC8bHChPQDUPkfvF4Zw4qFcL2S9Iq Y8rEtSVvl3McVKbZNAm6qc5wUAnrpqIuUN8lQzRIRpf8I/z8HOGgMggSj1kLaPHacgocVKLG uq7koBJMEaxnkIMKyac3KgC9XYa6TUEQeLH6HyhZ0qtpvAPZBdMkhTupAWt2QdAqFTXVlabd 0M3+0cx+MheMpqTs9EAz1RgFyckA8xkpj1nyF7w6iMUx20qWtgH2pJX8B2XJD0bxq/vB9Jvq ghCyXpLh5m40Tt2D2/qvX960eHe1f/z9f+7V3PmWkLJHjVsDmRuOVCtuOAazsZJ/rZt1P9be 8ans6dFIYQD/nZ4qrnxrz+sK5Q48BqM1B54TnRk47hDP3ic54ivvO85p5nhvm919O8nZ5vR+ Parvy8nEi6eO1P6JfJIoHuWng47hQ0ztGAjMq20ul1db4A7Xknm7ROin0wraUGG87eHsvNre T0fDfIg1zIfYy9UAfjqunD79dO6PD/HW+RCOJByCEiL0BDpsN+EQkBDBwc6mZZ2BCYfYAuEQ AwmHSDHREoeoEO37uVVBWdHCmgGpEGU50ZJAoqnHNZP2ZVwzwSfqGCpEQViFchufPcDYVXYD KkSyRjiUrurAzWaVcGieqSUWn/A3PZHzpGeC+P/b1AU6Q6YisoIy4RC5JuEQnGXgPgiHrpNo qRdE05rkdqMlI2v/j6XWw+fvmnAozWGQa4IjHCIWWDwk4dB9ushkVISZ0wu9AnjOOQkTpxcs 29YZSBaRAHffthOcXlCMB5zCK80a0W3C0EGdumbFHNc4xdBpW4HTS/9+rlOnl6FcxnhgKA+i oD0emP7WNKoVPU7J8QA5BUNTGEOXEiThHA84uYSQNWovggfSxIvBq5tOqC13fpd0epnmKUUE 4dRm+hH/d55jhBYaUyz21+AV4wubq1CUYpOa3MfGMvdSVLW5iqetb9v2SYtUFsqPks6oFBFM f5FtWpDU1SJ9oit1U3Xpe0X+mb3g1y13Dyk3NglCN7ZeIb0g2erkTU8M/53iu3Ctpu9N66Js C40bm3ZzgSNiJUY62q4WQKpxgGRNKkheAEhWOxaMbp4rMlZZOgv4KkW0XiebxIrvHKpVi8Rm pY2c8T2EHP2hLMJtVO02WKibqO2IQtmjcEH4K6xNGU28PWm20G4ZzFnHu+wcEUoWFYi0AHqi JFmVbDCSxeOtFVHZE4uml/qqppfx+vIhQqTIASFSZCFEiuQhUs59JAyRKmhwbrPEuC7YXya8 NU9CbxfJ8Za3JXHW8bunZJxUvsbEWRIOt7+gpRApkoZIkSBEahricFEAIVLje0y8kdWd0pE/ AzLE5Kmw8014+hqY5BfabtCGECl7KJzO+7kSBr3KUlGgUojURVNRtEZmkm0pOCwVxVCX1LrS ilW7cGCw+d9xiNTxqSjqTAHSxnqy6PZxQ6T6ld4bcL68a3eR2bWL18t/Ht3zQdc6jl5WwNc6 m5mew7Ya+FpHtIxOZpz4HawMK5iEKBRNE1zrFBZABisswixd66RMz/27awlEXrsftZ9LZl7y ax3flxvBilIeCX9HIueI9L1mnOFfT2N6PiWPBHQBMg78HiSQ6eQ8uJvySGB7lIoKIkVKd6Yc 8EzvLfaqCA02XesEbM2N6dnLak7buUCRius0Y234l/y7Mz0hjWBM5a2vXZ7M/x2c1J0/YaXS 15E1n+ZBVLd5IFj2tW7WVa0m11Ij8tbDbo6/pWudwcfVHcxVo2v7bT74Wic1Y+a83Zdja368 PBJ/Gueyc+5qIOcuFDp3LQQ577E89KAihAgzZ2IQ3tz6bOVcUQR7S2nCSaf6BJGRtxRvBB5u jdZuesYygZlmXR9dlrEsDzDkN/aWuhjLso/uovV4aDySZdnOUim4GV0otmXSkks0trluFsAA NDathbFgWgQnSNY7SdZypW5o9u5HprnoF2pHYyzfSPo/+G8Ycglby43t+pht2ygX9vm7Yauz E3w5L9jhh8d9PZuwHV6w19zX4/ITLMroofb1R/SCvT1b3XHmEqVL5pKNRHVhWwVzSWd3QMgL 1r5jwVyiQXOJagAv2CWiOtLqTipdWjM7iOqGBmlv+snMJfpm5pLMC3bRXHIQUd3JXrAFsjnQ KBEzx5XtJ9NsZ3RwmSD+/zJWSBJBcZ7cakGyGRNsJZvbaC7ZRjZX7CZZvkkByeZKdoRDvGAH Ue8m7eZGsrlLgtEm07NUEy5HNvf0gh3+7SyiuOYYn9kcUDwkURzmTF+CKK5CpFE8J4obyp9E cf+1gSiu/0ur7XHnaKK4aZ7ugiiu18p02ufGSkRxQy8uQxTXN1YkigsnufjFacJeWUhu2he7 41a17jrdVk2rLUQ/WbIForjhiW1EcU6yjk4f1j+MKC6V7AGI4oLGBKUdJwLw614tmBtrac0F 40qbhneUVi92wrg0gnYdxtjwufVK0oF4CkdtBTdxhNed6ASuVcd519QvXLZISkEsvJW8EpF5 EROMs+UUYHtBq/AP6MW9Vky3qoS8IMMiSriXmfqpquJuxjUFfaloWDOYzb4mMi9xBVpYmxjN aHCoGXDZuJoMRRPQ9yJubKip5ezi5mr2gYEvcU1fMFbgMu1mX3MU/SWuaQvGmoxPT7gKU2rh ZZ/ZWxMS3sOd1XDuT+6smNIItm2OvxRpFTNxrEX48yRaeSRC+jPurPZFJ5UZCUUjxIgaj2Qk POTOatCSSzS2Xrd/ncivyDY0Ni2CqWDQ/g2NDcQeSxFX7hffWTlReRm0XXvMso1ke2NH3lnd FXMLvzBzy5AV6dw7q7DOpff1uPyZYekO76yezC0XZG6p6roSQulxzcTvOI+5paSb2ZrhRq2t meBLXogc8r+K2fPsuGbSvoxrJmjrJsmVRtsDU9JOsLpD5pZYa4LTukaSaRylTe9jAvKv52hg yAtM8ptPgBuZW5RmcUGoSEFn9jC3bIv+2XRndTZzSx1YZ7ZG/2y4zKmtwswXjj5a05CWy13A apbsnu+snswtebVz7qzuP/CHXBUV5BmK7tFAstepd9Ll7RSIneq6ApCWAvEuc+p1DiN/iIHk Ik69jUV2XNXj1eFBTr3jLF3fQDJoyTR0I3PnCY2tC9K/DqA52Wwg0ZGBxGv/dgMJ4PwT/Vds IHGi8lXss6tge2Mk30j6P/iY1UrejVNvmpLuSk696YaPrk9tO6jqy02obTfv63E5/9339UdM QV1dFQrlvHV3y69imN5mJYGUZyO/in1HW7aSDNaQlF/FACmovWctluWFQ5guLByQ31aD/LbO 4mO3dMKbyEpye36VMp+dPRagOYTyQH4VU+RX6RUrm+lsiOPj19YU1PX1UlD7bm3gV2lQgV/F KWF6yotVu5iCWoeNRaKewK8CkmvtPaQPZovUwiKNii0stmA7v8o2r+CFCchsIIGo98Kv4obo aH6VKlOAtLGeX0U/Lr/K75mC+u7o3467v7ETVog52sj8Fm6tUMxRVddUGtkByMS+YyHmiOQx Rz2nGMi8bzVrPh6kyKQylSkgk5SiZQgPKTHvs0YwGiOToC83QiYZRYsra4xiqmo0NSQ21RzE /HYKRcu2mKOx12UwkenkPLibKFpIg+CYI69I6c4EAjB0zZijrextxW4+Y44eL+YozRSZa8Ll 2Nsej6LlIYDF7bnf7sTusZkALlsU2+0e9h0LvLIs55XtqcUKdg9eRhf2J7eji9bwst1D01ZU 92b3IFyykFd2rAB6yh4R0WyWeGVZyivLeJsPcbxtbbR7YBiZxAoEeoeUocqk9Smb3PhLGtMc Jo/zSphubQuSxQp5MbtHRBk2/1YLkjN8CZlgmuYEojt5ZfcXPJbdww3R0XYPmilAbve4FHnc 0+7x+9LOHcm1omXJ7iF2c63ogt2jsROoQGQiFuweAuRa0UW7hyojE9wZsgeZtOWMg5zgOkYm QV/uxe4xbYOO8Z7pg/1Wx1m6VsbBsU4ZTGQ6OQ/uJrsH0k1MZhopUroz5QBsem/4PRBzYx6A KdPEmClMdLls94gaS2UPfsVuPlzGwUV0cQO7xw0yDoI5NyNNmGn9HtDucZ/I4CyuFSA/IblF fsLH4FoRqivmJ9zDtUIQNw3AtTKUP7lW/msD10rx1gR2cIXRw2lcK9M83QXXSq+V6bTPjZW4 VoZeXIZrpW8M5FoZnxj/kHczGqK5sQpgJTlZMohrJaqgBcka6z/L9pweDC9u+chG3z9haG3Y PJtwN/uHH5NrpddEKhnhqrT0owm4V64VhixIRO0aPzJUMDe2g2tFkYFn7nJcK5nsgdI2mIV/ qFOulS7nWpmyli9zrXQN3se1YiuU1uYK14qtmbA0buVasTX7I9FLXBOtcq3Ymt04InFNBHOt 2Apykm8RYN2aa+Vu7pEMI+z6/rOkK/vPki7GWyOXB3yPZBjopSK0qAnuOlWy1rDEWuPa0lXT AdYarmpkzxxVGzPj3v4eaYHbzr6nZUdaa4JZKvnPEobymc6GOD4G3oH/7ET3k2p20phpComM LbIp3CMFNDXQkfzC/rM6k2xLwdN/9kL3SLfwn0WZAuxo7HmPdDf3SLfmPyGVaKnr77sW6vXn 29fv8h9vibPSV8u4ZEugc/hVKLCfEFPX9YhL2lhRxxP5CvtJE+/vKS7RbcXb2UaS4BJiegac nP2kum6WC/sqNx8RLkllzu1AfUxaaAeCxmvCJdWQGQCBAXEXC3RWVIa4/rhAZz9L8C2Slani 4yiEETDGE3BOBeMTzGqi/Vv6wSZ28Iikuh4fxXVWdyxpsioAYhqnNivIJjnqJwVJct1zYVzz qFQhlECN5pHfgQ8JXrleAaKHgyfi/2xhLNdJJugsmcM8uAk/i/2QBwVEGt7xbMyw3ckpWZTM pT+2Z+s2en8X8Y1mdeEZ6cesNiK+IvEDC6LMYLzHueIsEkS5dB7pIOY+qtM8Z4+uftIB1Zgk W2rMP7QCv4ZOCCkYSR/NM2xlA7EwAWMjqWQjY22Ttp4nHx1XXmrMhQYxkqzryisgayzr92o3 hzFr5BzpNExvA+hK2vr22cTx+so0UTTbWRrblANSse1jFmZqJxS10RaEW6540NjwRQLHDHEK HMnWBkKx4KOxDmo3wZ60kv+g2Ep/6c/XH+Iv/eo+SK9/mbfXH+Sbg3yKO0Bapt1x+7Ct/7f4 4Wq8/iVeP7/7+tXrV/2v/vrhkKYTgeiSDH5PtW3821+8/nr/8umgNG5cNayK1dxWOFdzvR6v almxu27XsnVsVy1Yff3r31FcW5M6viBTqum3Cg+i//7326v8/sMdFUjtMHTFi5XcWnGj8+83 /e3n16lrsnJSFt/lNctWc9jY1RO+Ut1x5k8msgjavZ55If96+/wUndWCb3Zi5Pdv376/uX/8 +Kr7sfWdLZ8zmlaQzqH/t3/F1y/KCvDqEPn7+88fjlqp6mztplSZ2cUg+kPKf/7Pf7th6tyR ihYVgHadcDM5yBm+iaAl7WWcMRVorz+ALZ7eFG0J60fI1nF6+mlBvj2AuWOcrd66ISb0SssF i7bGda8Q48y+fn9zcqt6USUI5dpNiFBqPqi6WSi+qqsayv3KfHNHuG/fvnx3S9HLR4qVGot5 50rvn/LVV/PUJ8VR6Zgxbm3Iv7X85/XnD68v/oTrOkYWV2Tn9B14Y+U1tPxO5/LRDiPpNp83 /WFPjMOkiJ9fP+c2ikMkKW30wPRiV+j/fvl87cVwcts92QneLkjQeOVzElhVf9cfP7/5tcXU IvEYtU0ar+1Wz//38/Xj15dP+bev6FxF1AV1gFjQ5wbpw86M+tkbKBo3Jqy4QDpNlXQ75Oc4 kb21gMhF/exkI9m8Gf8tPl5/6DflNtmhPvOvLVWnBIthLL1hI2/Am2WKO21nqN+w3FTa/eP9 VXx8fPn4HEeorPEnGUccRZCBKILaTRRB+BiKoNRSggCKoBpfPu/nZBGZ3iRqJDvmo2TOpwjy UmcUQWlbIUVQ11RdJ7l//0dW3sv1pAgK/jaewG9HEXRrtsQzbIh0nw3Rgg3YE91UvGRDLEXg 4wvaEO37EWRDxIaoS9oQcb5i3A3LdMex1YaIG8FuZkMsZZNwvAAt6uThNkQ/SxtsiIXcmggw JUE2RNrWMjYcYFNX87l5nNBUsSEboq+b2MOSRAjNkGZo+JnY2pwf4PGSPQxrXNWZWSS9Wpvf i3Nty1RpKJgss2FjBjbREkmYM9HOoxo9EVhmi93MTbSlfkNG3LCl1ERrZ8SkVie2NAHz8BI7 any2VTPiaOfY4qVfP98bjbiRapjUguLnp4Vnc2hsf0He2CRI0O/AZlulTywspwUT7arFLI3F CE200WxORtzy9C7krcvfu26ZBRszoIl23TJb2DWyXgUFxXwquWTjqs3cbCeD/7gWc9tpccyy R7PxxrHsSwZJYALCMWs0EnFjdDLS3K8Nsd+HXX13rnj9Jb7+8/opuq/6I7QhYuVsZk3J6NTv NmuGSNybP4qGqMPNg3bCxkreQDgYMaU765LigDeiU+6wbetI/yJvtCo6LFhVyK2JBqPDrIkn 2/ck1i0aztlOu768fby9dv/3qT8Gm1TZOHOqoW2/SfEkQ1vTMtXry8c3O6R2Yb6an2/eDSQa H0GW7Du7La2XsJqJFuMmMGrbl//wXSbN4lyeZWxjhDGvCXZa9PcvfqH832iYLA+ywq6SHdMP /VVL11X546e/kvD3BAuvaztv/37/f6/9tuRe2jvt+N1AO6sSLpujTrOiUcSJm893/eP9+1/v 4ttkRe2WnZIe1vx2piUNINu+RjayLWTb3HmFLRoGOHnZaklrBaVCicyS1jWV7jqaWdIccTZT sCXN1xE0iVAf6kgpXxJL2vjugiXNtsUysu2+vH6SbYNk2+yWlrTbs1neSbDAZkpLSHk2k06R BdIpkpNOVZ4ssUA6RSGyba5qzOy+qbrCwgHJtmWBdKpGxB6XVJyS7PbBAgS7IEwEBAuQWhh8 g5RkaIl0iqSkU4S3+RCHiyIOFsg0KysIYXlEOlUNXJN5Y2b4lYMFqpQfc/zFjWHUTEmg40er VhSCBUDJYoW8YLDANjrMklX4ZZl0ys58QofZPIMFXl6SITo6WKDOFCBt7HJ0mLcKFngIb//b k1oexxplRIk1aiOfZdgWxBplvxWyahXMls0WWKMYyBpliqxRC3yWFRW4AC1A1qiuzJZNaoxJ BC2CvtwIWhTYsjVmwmiOUkx+DJ/lyWzZYcLMYNPYgwYynZwHdytbNpyLwytSujPlCGp6b6xU W+ABOGY5a9R9Zju1j0pc5070vx9r1A2yndJMz1JNuBwn5ZMt+zelo7wbw8VGTspsUewxXIgF w4UA2bJ1aLgorKHc4lf1qfrOy6XukRJp6u7esoRhRjmC2LJdUnB6eJawcZZKhguRGi5EbLjo hzjetrayZcN8ltlH/RTDRUZwmWjd2FiNJi6aXAnTrS1W7SJbdou2IJNNhoutfJZpQRM3VkIm MJ/lRsPFJkEe3nCxkc/yklCFZQqQGy4uxWf5ZDm4HjxprgpPxiV+H3YPpUt2D73b7qEKdg/F FZ3uIuN3LNg9NGj3UJDdw5W7YKMcmUhlTCU72ZbyeABXKq0RZbtHxTGD2bL1/dg9hm2QMCVr Ux19pTLO0ql2D5hD6US7hzrJ7sGMjAombelIk6EL0O6hMrtHBAiK6GKj3YOnkmWiul+xm3TZ 7mFSu4d5smUndg9zuN2jyfQs1QSHLrShT7vH3QCLs8i2WU62za7gAZWbSx6SbJvXDF+IbLut DUi27cqfZNupWaRM/kgRTckf4QApGHycTLbdz9NdkG33WplO+9zYAtm268XFyLZtY5cj23aN XYxs2zV2TbLtRqn5Iw93s3/4SbZdav16ZNvwh+9JgjwcKv9MEuThcMwJ5BDMVS2R1e2GvdzZ 9QCcdMKuw44Qt1cdeAgPZuk0EuRxiGN0v/V64PYkyPY7qyadj54jqOTXOA5a8Xpg2wF+0/XA qSTIFPrWbD3AZ3sUvKP/IX6N2w7wlz3Rpwqwo7Hn9cDdXA/cmgRZ0VbxBaIzXPGI6axwYI9D lla5TEb+ka4AXWT6vCLT8RqAKBiAKJ4TMoMoS1wmAWdIxocseSlmaeIMuWLM0tSX5J7Ajcum mKV0LC9wVC/yITsPBlaj47lM/CyBB3WncEFwxDQL2bTMe+oCUXA/G0lVkutR8sQSx0SwIO2g 0uzTEflHCsVkjirquLGU7BcEQCNv6vqnY/SPAOh4h9cR1XBFUfrtjgRJ31tsbNokto2ZjxmO 8b7yCLR//4YJ2F9QbIyt6sqOxsQlJQMYi3c3ZvF811FOJSmA1fEIYD+xJQetFPFz3SV1uzZv PRKLcJDLxE58QgBu3ytK1qUgBnubnvm461hULpIFV7cwH7IPvYbXZk4NFIRbZ8tpWmjl9SUw 72TH4sZc6HWOq6c9Ifs8B4Porzn3oNd1yXY0tl4QbgUuUHwXvt2LgNL6fsNe4UoQ3TJVgtvR hyYcc4H9NjuCBeSD29tSrfOYEk5gin2SFRxCVvDn0X7SqqGiZJsEyQpawVTL8zu6lhtJ257E QGXlsYPQ+LdpT0rICny5aOsC8P+zyQrwTckKbk376VZ4A61wFK7w03MHxTX8GgvN+TNZWXxW ttCAqcAWtI0pV7SiI8CSEZUmrULQkukEZV2HJn6PADxM3KK/8ZK5GO9nw4ShZsKyR/J+2lkq XWqjCx2IJi1JntxwDjlFMv86YbakFMnqTotgLui1f0Nj/kspVJpBJLssCFwFelH10vF2f8H2 xki+kfR/8LHwlSzmzw1esw1cb9soi1DojnibhDskXAoKTaoK20DxHig0TfIV9vVYXv277+sn 8jaJW0Kh6qpQqEpWxl37N+jq+v4Nui37NwzBBClvU8G/AbukJvnC4YrVnT28YlpYOCBvkyrx NtkNvhHtvfE2ZeGP/h2lIIM9fn4n8zYt+Tc4xcpmOhvicFFsT/IMEzNMgzja5/LvcWS5i0x5 0ypx3drg31ALMul89BytI6+NnLepnOQ5JWAPjIz7/RtUJhmKBpEwTst+6i8F/4ahAOHYM9IW PP0b4jGzQ5Qg4av7N1SZAqSN9bxN+hn+eNf+DU9ayUeilSwsJADXd9Uarg/2+jI7g7TfXZZw P90BPKkErzjK7TWMt+3B7pdn00qOQ5xuW2Bj9oO2fMFGkCGmTapclVbSnT4nQTIlXIQnh7Az nEoreS12hvFRR61hEAvqKkNaLn8jeHI7doY/gFayX+k9vvjyrt29Z9cuZqx8Uko+MqWkxLhm PE//diClJEZtyVwIUEoK+7EvUSsgKiuKI1hxe0pJomTFAWoFz88oETkYVpxJKYl2UytkBUVo MCrpyg5tT0gwNMCxF9gOSkmho2CKIjQAx+zilJJ4CRpIo2JoYAue1AoRtYIboiel5JNa4cnZ dEPOJgssdFPBwOKinE1zXEeUBkOqSkm8NQ1G74nLZpCSAAvJ7DcDBBa342wiRBDv557aKxCp VMuqO+RsSje+JZtDCizmbXWJALoELNQWYFG5WHxIMkHzKxEQWOScTRflqj6Ts+nCXNXhf18H WIxM2KhjOxx8fiuu6t+cs+k+kcFZpEs0J10iV3Bfyi0VD0m6hDnTFyJdMhbWQKRLrvxJupTe dhRJl5Ay4iakS/083QXpUq+V6bTPjS2QLrleXIx0yTYGki6FyqIwQ3k3h7+0SUE9F9gTHTY0 kH23ZBDpUvxEndzE9I9SrTnnsWRovqLAjvyIiXb+sI5VAckelHQp+D0g6VLQWCdp1VhIcgLU mRtrac0F40qbhneUVi92wrg0gnYdxtjwGa9V0sg+thBHbQUXToTXnegErlXHedfUL1y2SEpB LLyVvBIyFAQTjDMAF2B7XXXhH8yLe61oJ3HsEBlqom5OvK9W2LibcU1dvZAqrBnMZl8TmZe4 giqsTYxmNNjX1Lp5CWsmZDF9L+LGql4Y3dVzY7Zm37mXuKYvGF/VtGk3fc004n4euZex5vBP 35itME/pIsC6PbnXEYaaMJL5DF6voC1uAEMNdR7QrZocxuN3LPi9Eh0baibGKPAG6DK8Xn1b umq6GR5F0IUqYTcvwFDj+3IjQ02JXNuKJZAFLUfeAAWztO0GyGlN7AuiOZa5c8jCDZBJfrlO zoO7kVxbwr6rhDSrScXC9w4Kcmly7a3cXMVuPsm1H49cO3et2q8J92uouX+/kFtzat2Nz6lh 7ICQGLYADRgYEkPMST6nVBSgwS6fU9rYszpXMoIGd+BzWswIhiuTpTI/IiSGLIXEsDQkhgUh MdMQx3tOwee0J+cKh6gzEV3o4HM6/nn8MOzBGeMTE7tNQevGxqr5IJcrYbq1JZ05ICRGaNix ZPzu3TwkZhCEWISuFat2JS9dhhV0gwPr7xkSgzMFSBtzPqcEiafP6fWwxa2ZRxQVuPL9/fHT s1W5Qa2s6M0yokAbGDozfVthHUmeX2LohBDFZoZOqE7GOiJ1CVFsYujMvhj7o9PzDOYBoygQ nY6ntg5mHdFEEDL35UjWETtLsLHBpzIs7HjDEy3GzcJ+Omqpf48KrkoyEFCkn8w25yLt5cSX N1HuZKsEgCdbaC/xCjwJRiSlvbSDaIWJAISms6iAZFknMslgUclEogqDgH6ZZvtG+P2CUprC BpocFrVTrwIuuwiF0YjVNGssfmubXSfmNKenfrcJ7kjWbwjSRTwsPYQmAmf8nzjrDNjN/lQS DpFFMiGnY8/mt20CcIPYDG2o3dSU/Y7Hstdt3LpsFF/oZqHfw+hju5emBduVNgoK6wzTIltf YDc709b58C6PKuj+lfeqE7XqdLcLBq8+Gm0FjnLwOkatUfZiY9m2fWkr1zrmSWv4r8kKJ2dF q2VSTve96dvQ335+dfjyx5fv7tXN/+fIOQvVzmPl9Dv4ILh94bv++PnN4WbM1CIM9hu9raff 1OtX/a/++vrlu7cJ9nAYa2fSI0XQ7ndUW11+t9D0fz9fP359+ZR/+/e6iqpI7rmfRdRvRG58 5N9a/ewPBU3riTxLVU4jHu23LT8morM431N4/vrypr7/cnX9RFRd6ZVu/1riHvWksGXuUbfr gNSh9ni2yB160nnmTMLRO2LZ4k4N95hGNxCOkvEck+1b4DmmnnA5cI4h6TmmFQ1qhrNHzLJF pUR6JJZOWLaGr0HGsuXKxZNw9MmydcdXCg/AslVQkHzhEFlK5b33SqFptLp7lq2xgiYCBeeQ A2ksTmbZmoY4XBRlGotjrxS2sGyhyhQSjzglTBFA0plDaCxglq21gmvRWGTvHepe4Urhz6Wx +ANYtu7/SuHWFFmkEi11/X3XQr3+fPv6Xf7j3UDCY+7pXObBToYxHGuKmqpHvQ5UtLGWgbGm E3XQBCqaeHPecKsQvx9DtwqoIcVbhVPQeJWjcXdbOt9QYFK4PYjROFYS6wIan9sK836N2WWu mPfLgooq48Y64lbBzxJ8q6CorPg0CtPsZNNV0JOpMTt4pJbOzTlWj7quU4N4kyp2AaE0NY7N oHUsmVeM6ONuh6Urb/Y4V5xgIDSu6sxOB3rQ9QqZa1umSkPB9CEMGzMmdISfHiXMSmJG+jBi knzgeJqhcjebYEYkdZ7lpX7PT8CNuUNlPCM0tftX9dIEhN+YxvBJzzAjtukqvWYIBmI5v1z/ aPyfbS7IVODnp716ejMHvQxLzPwdpYWEc0vLyY9ZbUQMKnzH8m5GU8QZaLvHirsbv6QP9cr0 zlfWG8asLk/AYmNxr6bWA9mFFIxky3kNCQcjUtxGxrWZSzZGm2QXqnQsGNditmuUxywZ7y4f oqwxsrubw5g1cgavw/Q2+xDpJtiTVvIfFFvJpQrrbxPsB8knDftBvjnIp3yysKL12+/Drr6z Wb7+El//ef101umP16q32/uMY8pfbpRuN/rdxl0SiB/uta9/idfP716IsBHmJdElSfzSnS3c bhBGt+GiWduvMmeIF385S/hf/44vtjWpA9XFewKv4x5Tu5sN+f2Hg/2kdpC6Kibg8pMc3MD8 ev/y6RC/rBYTjrW07dwdioPKrp7wlVjnb1CQLEL4livOsnp1x9lKRcQpbvsMcm+fdjqtMn2z UyO/f/v2/c3948dX7dvCfpDK5DiE1q0bpU/x8Y+t8jrekby6Zn78dAZ9spSxjHadQP4ax7/Z HQre33/+6O8dltS6pQTlQ7Y2YKKtcT1cVg21rKS+Zr04Qyfknqsa2qu8u0p7/fbN38T1Kl68 S+kaC1TnSu+f8tVX87lHildwHTPGTYIde/nPeOE0pqxTZHGBMPvJE/1Z8z//57/dsPscd7S4 Ct1F5Zj5r3xR2a5kD+w4ibIH1k7XGi9qsdZ595Qna9ruEbrN5d8fmXiwPibxYGqRQMA9oFbN 8j0g2n0PWKmX5B6ww24f2pd4cEIn6T0gd9HIJL8H7HMHjZbl+B7Qv3+2PMTlSF7Q8vD73ANW 9S3vAdlVbXUsWRm3ZYbTssQMJ3Yzw2mIGY62iLKqZ2bLmOHEAjOcAJnhdJFyVi1QzhJhCmsG pJyVZcpZgYk0Ly8vOTOcuCEznF00HZqtdf4d7vtISStZm6yZA5jh9AHMcLPGjXXM8Ctf441V ViwCOLj6yRUpOl6WmOF0RjkbEchHou4OOFYccqzdcWlULV7joSYNOG62Bxyjc1M/zpLdc8Bx c3jAMciNGGmCp5xF1ZMZ7jfmjL0TD6HNxLGZVu9JdKMXEt3oPNFNT0ma5+ErE8dKZUwlO9mW PITqHB60hhfy8NHGdAy3dxd0nFK/xfBAHg8P1FKiG50mutG8zYc43ne25uGD2eyzr3K+bW+C FmpLohvjPTB6nY+eI6YrewjllLYhtNjGZr/JQ2gr6ezCVcYCtCiw2Wd71JVuufZDi7Ubm8t7 CG1ls78k1mgyBUgbuxzp7DMP3x0T17IncW2JuFaooc75xLV2IYHEta78SVy7hl7mfjhrjLgB cW0/T3dBXNtrZTrtc2MLxLWuFxcjrrWNgcS18euaNu9mNERzY1WJGeMUySDi2qiCFrmPQv9p x1QHw4tb3jaZ50WOvQDJHpS4ttdEKhtMZGnpRxNwr8S14+8sAPls7NkY1BgMsG5PXHsn1qLN 7LXZeO+JJyPdAnttF+Ot/ljMDWAt8s/PO2WUZsiVt7wpXcA2kLVIFKxFzCIerGl779aieaaw wLwZ9+lD2WvL8WSEoXymsyFOT5Er1w9DusYrWosyKtzxlzTWosnHOlmaPGe+jVW7GE+2jfl2 k7VoK99pWpCkz+sxzVbm2wUzym5BHt1atJX59rJfwVQBdjT2INai+zT3PClwH5gCN3qedwC+ GH+SF/BFmsZwCA8u4gteaV3fG75I49XHzewG7PjBLJ1EgTsNcRlfRO/J49Uj+twbUOBirCed z5QQxhdTZ0q3UVGI+Xn4okSBu1ZAoK84gC9wii9WKHDHR2urYTM4dHVd3ia+gbX24fAFPhxf PClw7wBb3JoC946whTgAW4gFbCFAbIGL2EKJoiOsi84tYAvQEdaUsQUloqruDFtUFUO0Qbnt oqGEtZqqk++KTsUWeAlbiBRbiBhb9ENcxhaZZgWfJwTbLiLRQEfYTdhijb+2n8C64OnilHAJ W0Dsndeg14edaOdBvB29fj5mmwoeBVvMQ3Q0vf4STW//hOfCqeTjYovHsF3cmmvPRdE1UBQd CqPoTifESRdAgiwymv2hfOI73oMsWkSpwAIIS3Pl8a3I+DdbjmvJQUKcMW/gbxyWtjvEZoFm P2fZg5HFhQlx3CyVfFDQhW5GJy25RGMXlSx7dFoEcQFAx5031sdv6pwQPl/G47/3I9Ps4Ba5 6JhV+UYy/GGicis3tus7tm2jXNjnD6EdTjd8BIQb2wm+OO3wFDoJlZ8dbnyBfT0ub560w2C4 8U1ph29NDXhYuHFVJge0xfvCjauMHND9/LFZ1VVvmcjiichCuDHJw439O0rhxmB+41HiIuMw YGVp7Y5dDjduGikiK0vQlxtZWQjhvA7zGwfaIAmrYo/cQxiHDwg3HmaqZH4If6GlBG0IN0ai beOCaUAB1mDQmISaNL9xWdTd4catkZlkUEGxm/XyLUzKGuwxTaGxY/IbD4JIhPUW/Dj8rhhu vI01+JJgtIZXQKAJPdRsn+HGVzOSsDxC5xrgOWckSSJ0cMPtql2L0HHeCbsidOyakPYc20V4 wCm8pKKrZGwbsTuWadqadjJK3THVaRQXTE4YeiqvWtLpOXXH1FZFjREkxwOuTm33VFWlETpD OYnxgI9HaEgrWISh0/fAeKDv+4QHXH6qTikWyIVJLnOEB6b3N/GtCyDXhAfGcTFF28i+FIRc iBQPNIbbsyNqg93gqAidaZ5SRBBObaDcbUdNkzzRJk8Y2mWNzfORTl6GYMMhaVqUWuojpQfr Tv+F5huKVIfTbuo67oSSss3Xy9w2xly0dMOnUjj2tIqi5HW4jbVLwTaI/jWFbycKdoVU1JWv mxveTNThV5fW10u6ihuULZ+km3lSgiR2KJznpfEe+p0qQGk2RTyb2q7T1Y84yLwKTECoVsPr 2lxXihNQ5Y1l3UzfX+imQVE3m850AJ1MNGY1HIgEPTqur55IvjOS5egRA5KVFstqv0uzaVg8 m1LxelVXqlJja/FtKKD8tf9ad5qAY4Yr6Ri1k7o4i2dMU0pm5M+wZPaYy4haguB9WNtG6I8C teqnA+UTMDYGA6xb87mQShiHDXvW29eBnTgChzDYwtW62WV8eBzeF9hUiVOzy5hlYY+pEu3I 9Jz+LTW7eK6LwYQJmCon+HdFU+XUl9Ds4uVSxUzPOcya69SXgFkLORmIREdfQY2zVMrJwFEh DHq0RnGZU6abpDE4a8IwPXDrudIVD+qwZNiOMp2pWMYqxcaCXBAua4J98yT7MPt5luq8sXLa 6PE1wz9DZ2PQhuMvkbmiwYjkg7ghO3Y00ZC7TzhmcJbqhdksFcyylyUrCjINUfDHPEt1nJMh +AtIfdNk4x2ZylxOVXAFxOmq3SBqN95ZY9HLZmqGrJsLqlEugBsjtKvzfhd0hStWOdGVXFhO C0NUyFINjhmYrjrIXoAll1UwEKy2o1wreDbbOk9XLVlR8aacJ7Bkju55x/oSmGnGdWpEC6if 8/UVjFnnkr5tMtYW0lXvkWy/Wp1n79sAetIq/nPSk+9rnxz69dNCnle7U+uPPg+CM9yRhYzL dktfYWAX3SIB+41SPv+GOZsfl3r9Fnmbm2P42tOzCoIcKNQF8zb3+5BqC6eSwmVwNWIK6FSC 01OJo562Sgo5UNhyU3Cg6PfH8VQSl8vf3THOOVBg4FRyVw4UZ9GepQvqSrRn+eH/IWnPeM3w ZWjPBGk4RHvmy5+0Z/+1gYZjeIdSCB9PezbM013QnvVamU773FiZ9sz34lK0Z64xkPYsVBYV ZRJK/tImBXVwzMZUq0ah0yWDzMLxE+k5rH+Uas05jyVDszkaOzstU3j2PxirQiblx6Q9Cwqa 0tKPJuBJe/Zs7I9rDAZYT9qz3432rMFKuLjawjmmHfHWbHQq0541yBAhq3ujPXPxgJkTi//h WtBjnVrPpT2bhjhcFFekPTPJL9a18OpgMm2m708kq0wpjzd+0p75358aOvykPfvjQ4dxbsCp r2DASfnP3HE1sIjaLbdphVJbLKInGHBQFllmX9g2zpUNBhSRV2z6twxQ8LZt2iozjCbqGhlG fUNI6JfEMGpMJ1mDfnfD6G6eM9k2VZiUb6qBW8ZS3vpVQMGql9EwOhlwAgPKggFnfO04TyGk YK225fO31jArmi1wyt0xZvInrOY02G3ovLXbVMR0xhpFRCWGJ4l/FMlWTsrmnmBEyrHRuXWw MYtp6PiXUHP7AgtWaYuaxr+l8rK7BSnM+NqgsYbirn9Ng0gTdcL/09aVdmQ0nZ8YOgFJVvF+ iChtjOiCgv6fThClOlz3jXauddQKO/jj67LvRjy8ToCpsUQx67kK55XzeIUks+9vOQ8eHXrl /qJr++ka6g5PyHZ8ApAsftQ7Obofc6+zWtnIoN8VJ/X8sQ8lIw3viNvCtDTNPFemaRqOsjt/ 76dsB6xtxrioGu6mxrifAOKYWqJuWrTSv8VjK9eYd57yCzBsjLaqqdzEM2XqYQVgIeMCk+NR 3D9Bo25alWzrZqobPDpKVhMrRzevkfGJ/h9h1BOmNeoaOb23r9sxw+xXh1E1qfUoYbhGMsms KnZ4WJuknkdk7iYlnGM/EHXT2cZ43TWOSYjzWs/BxpNqkHoU3Uum6UQkmI3Z8Dpeu9fJdr54 68eM8Jqq8YnhUTRLZo+e9gXD/mWFibrpRC1J1m9B/n3TEPnXMYGnxsb3jgXZCoATgSLvUesE wNq2XskWRdtnpWiUlX2UbH5vY7dEu+HMBeOYTcrjJoAY2XdTxHpmV7gRSSe4TIeoLPuiAefJ /fZI3G/pO4p4Cw/RxxOucYYdu82wluUGHJdUrmzA4ZjjRzHggAwtR0Qln879Ng1x2YATvSfl lZWojtzJel7ZuMp1ud8qM37jUK6EsAFnhfvNER1fzIBT4n5bK2jixkoGHJxGNONuK68sln8G ryzeFtF8SQPOH8D9dv+8srfmfSNVa9zUvL5roUbfU7EecNPuCLgZfhhAFMjUZLLgpOVbLDhT nSB4ZnPAjXtP1cKcby6ec78Fp9puwXFMDbOVaoprTvqSWnCcd1nBglNNbdGwrd6Lu4Ao9sU1 FzjfGma4IN34ZTmS883OUingxm5p+ShET3RkJuJI5hbaT4fGMCPGsc253TqoOD2Bp6MxBE/G qc0KskmOV4OBHNTdc4hEIECjJKoCNZrT7In1bqZEavkTvWT/P3v/oiO7jqYHovUocQAD48Fx dfEiUeQGenC6XTV24bja3VU+HgPGIEGJ1NqJnTdn5lp71zz9IakbrwoqUqGIyFQA3bU2U7z/ JD/+l48lmHOddztBvQmgiNidKVTDonFFuGaQTAepCWGBVR00JKguhnX6XsVnpBuzouXUa3sd 3l798bbmyukmE5EI+ChytfIOCYxMQLXPW83M5rHJK4JeHQFOg78+kSiIEkPOFw2Xwm9qHKCr uapoupvdFwHmiAjtgMMCT7tR4C3VR7KbQa+CMfMSYIZojJ8GpdtjVrWQ+COTmICq4W0wvOEg etVHYodHoU02dQyGc0qn6Chv0/jjfr8pzR8zJ6KvVFmdXYOpAqwxc4OUcgNujmEeP4c5TVQO HW3TBcmo08jE3bygRx26oHOjpBnRHDUz2ZtiLnu3hesAD/6iM9x943fvzyY7vnuQP+SDDvkh pS5DppugNtuZiCE6HzBkNjEd2cK/6aiSbz+GJqispUbUyeAWs3N00Sny8fvD3cP9k+SvOvfL z3/XNTOoa04Gp5h9xTRcx7c0zy9/NwE1OkwIpzPphTVkMtXqqdaoXJh+4nRGtcys1pqQrDG8 KB3CY6RS5dMIXWfkJlcLATGXmyZ5dQCshLSbl6f3d17ffX96VNPcPD8+Pj/p/3l5kF0LzDCn H2QnmhKju+n8+a//pseoNiKdlAjCiAnBGoTS3KZmr2IflaGywWxmFSghm11FnBaw6OOc+jG+ e37S7RbFfHwVrkpm1o+OT7t7fLx/1guGzcY28aYF9EiIHDZzko6R45qxw5ImNTcvpm5UafHd Q+v20LprCq27Jm7iNUPral7ItlkaWreQm5iXomSddcIJreO0xsDVP7jtCkPruvQvEVq3nJu4 48vduYk/ATdxpS4VEvKzcBOnZDNYM3VTHgIrIGYV4+OasaC4sc4l1gwpUVsebCvg5bmJk1ZA rbNjFdny9epMbmIHWQjHFdt+ZNBy0Jwx3AUJrfezLXk53MSqTdxJcATJP8Dj6g+Pmzj3hcjo mK3OTYzmXbGjL0QmCtuGm7hvatySd0wxcw5u4rwXIj9guAu1enED8WfhJjbbgMrdVdeDYXXt fL9/1voHdU7N3oxvwom7PCuwGPybZpn3aDnqxL4/9VoxVNoX1dOffxq2PyRgyyOwQqdXBY46 c8OWOiwXTp4AVpjfYu49UxYOn3/q0skppsAEFC9SpsDJfJdnCpw4+dYxBS568mCOe48BD4qf 3RQ4zFLKFBgz9KXte7BUAte2zqnWRgx91qd+YdViU6DmGUVNKQu3ZQ5bW9fPeYPbmDFmCqSA OWZMQ1SSaQr0OQedL/qWwUjLWt/cgIQaM+pYRhL2vVjLuiG3ElDTsnry7R4a4u0sLJyAGONZ yhTodTtCI9z6psBhrkJToPMFI6F315TXq3fqVZ+QawqMTV5Q+pyNzOpEZwr0OxGaAr2yfBrh sZtVOCLeFzmmQByMSP8LTIE+6cbMcvKkKGItDQqLMkx3v/kxq5qq8UcmsmvEh4hXkZXvVR+x rLuGvkFnDepjD78BmuIkBoIcHbPQvheVM8oECw19zuVP204+hmezYI+f6aPmPL0NHzPnIQLm 7Xm3ZpBT4h2zq+F5/b2RRivf/dPb010rO8OEHuYildOIT2CRK2q2W+Qub5FbbjI6yYZXVwqk Tple35s7k8081ZgclZq0rb76NT/L5pfB2mTunrpj+gII0wYjiRnqR8RMibZJmMzD5XFmXd2o wXGxnJ8w+6dZ/8q65sCYNM3a1ffj19fvL3okEZgbkJs1G37QAlhuQ67pqyNA1ALI1rMAtq26 pZVlYAGknHJI64Dy38MSmRZAU1aUXJO1bLSMuOSavCnKtjkcfHJNnS7310mvgFwzeIPsnIq6 8Omxqw0GhIDnmQFjwpMZDKjqYGkzIGdBMKC6c8gqzuYEgZh5olTtnImFE3milMs2HQyIAWL1 wTYDXj4YEAkF9GwzoKlDVYBAWZRN4y6cuL5uRTPgMEvxYMBOsIKZDobYXhTxYEBTT+uYdmyT lh0M6M15xNYzlJE2IXbVHQ0GhEWZCgZs7NcVvGDAofSYhkcL5GrBgILFgwF7mcEFQISFSpl4 yJ013n0CgC7fKDcmxGCPiisY8kyIWS27xmDAaYgE8PKeORiQBALgF4ZbfUPBezDgikbAtYm7 t2DCv1HibsiIXIO4G6vNr8UhcXefvhN3/0sGcXffx6rm4nToceprqP08XQVxdyeV/rRPhaWI u/terEPc3RUWJe4evhj+EHbTGaKpMByJLzq5Zcfec4SSh3aX7lyGpbSGF1LNPGR90eJKNnNc nlPe2yTu7iSxbAhiIrX0nQm4NuJuaBifOuMdhDU4FHoPIh0RljqhVUOg/UVrvijUN6z7wmXx qtVfeN8FDfsVSpMCtn0CO4iGFeXQSUxHBFc0oBMpuzCV1jNyqU9l8OkBVUj/b9l/MU5RN2cU CWfMCv2cSwMgxSrDocA10mUXheheUg0ShvEq+r5PhalPTZKd10vo8wz/63xRJAsr3Lx0zDu2 rIglhKIx5tX/j6tfPwHjbtklYGaEZyBZU0PZ+M6GHJNu4j2hhSrloCtpaNsn9JHSnICmSxj1 v3GAtRN3T3TKn4G4e5CMiiRUPS7vU6+CIYxOGMlW9TSyFKhBEVXPoLa5Co/v4SjVTNbNFIly E8TdwxD7V0CvsKGeQdXTF6bAGp1R9YSHfev9vNJPIO6GPME5p4XQ6tUS4m6La9sMkZpVLENR skpfnbgbh2MW9RavfG/xKpf3Cbi8T4BgJDj6RKqeaYh24u6voOoJSLvPiS18ru6rxhZkA05J MsMpSaKckiiJLRiPmJGYLNUnQOI6gS3QITAjzTwK0khaclRFsMUlzUhpXQ6oOdr2URBrllLY gvickoTScIhzsEUQiWbTElpRJhmKBAdbOGBjXCW6WxlmJCiHN9ADM1IYieaK9jacknXQspyE c3FKOnV8bjPS5TglYSAAoRmp1q/t3a4Z6UuEo+2U1+OhcQOU1873IgZP+tUJhEjAk4iXC1Ur NQlPcInw1cGThiEcgyeEUYpFPZzGN0F5PQzxafAExOGJ07TzUl5DjOOqDyOEc/BkhvLaQRQf hSenUV57sdYpeAJ8eAIWwJOshtw8PAE75fUOT26TNXtTGp4qTsPTEpmHTKw8oI3R8DSyHpxQ AmQiyzQykXWcOtui4bH7AWDa/xYV0HuMY/xF/W9FFJkA85gYI5Pjut+XCyGTKA1P1cpalnVl 7S0b0vC0W9LwBGAikMlpcDvDypFNHlWTUTgUJH9nigKwrl4bXVg0PGpV1BixwrVOqaVI4gAs pOERfsuCplrzHnZzp+G5PRoeHMiZLwkdDY/caXiuFVhcmt9Px+9Vsfg9YMfvnc7DE6wYF1dM ZBHukxxIVEyUk5Q6Gg8OBSkZKXyNh4RFWRYiCIiTsCKCIQdXOGWVUY3HSCH4iQPi1uThKSxv tQ2f5NCzlHKtBR+81g4po5S4H4Y+pyvrtjNbptfCkDAugimhk/6MwmomhDr8+ZGW2ed7NzJV DkNQfkJ+YUW4kXR/mPjn0oUtOgHzNsqZfX6TQGd/wwduoPMwwesFOve/8aklNzl5X9x8X3fT qz3QORbo3N3JLxXofAWMhAasetQ8sM1gJET5GpZZRkJMR0ZC6k5AVMMSMhJW7rV3KSMhauOM hD0B8korBoYr5rTHyTSRW2LFXOxxMnXpE6wuCmfFnB0JDbOUYiRsMDv0kRtxPYZJSMjJWJga vJK1uLJeC+vo7tDEsTVMqC/Y8XBp9RdfOYBrFrZs+Eeb/Z5YjF0PSkhgAKuiT4B1AjlXusUP Zv+Ot8xmcWzneR6ThYWEj6l+TzyP8cKct9+62fSfvdcEGOkJmIYXqVFjbOzEQPiYHIjx1bCM 2QwoCtsUz2OsMI/wcSx9+mfA89j9wsJcnsVxzGjYq6PLySJ8dAqzOezaKM+j8zyfvdCjb7+F 0+skRCkh+7wh4WPYTa+6kBw6ycznEgFGn3yLdjP+9psnKwHPI05tQTHCxyEh/eRbIBrpt9/C GUmPmfcXeHQQk2OWzUh4HPb4mT5K5Gb2YZ3f0JX9yh9+uXvn9YN8sykJC66JAasqUUi32xzj NYQdZdvn4TXc+KExylgBQlrDqgA7reHFaQ33h8ayHho7mZWPiwZPrHzt/ZO4+/n+2896z/oh m/dn3Ww8Rwp6Go8g0nY/Tccnn/Sm2DHy/apqf/5V5zXDhOtUlbdKJXiJF8gi/IPneIEsh39Q 7bNH1HLA1TJkqOVGJcNYE6dCgDJQy6l0bdofVWm2Wk6iqqp56GAqEWtLjAK1XAdKxotQyD/I EvyDjO9quZ1/8Go9sz8X/yDodOO5/k8y7ZldYtC6/k9X4JldCd6Mmr5jdsqz+z99jH9wGGJ7 Ubie2YFkBQk2MHc8s0OWvyFP2//Sntm5/IPIPDgWaxl13iRYwj/oxJE7TV2Nf/BYgvfChCkw 9J1qWuH6TqmEPXDscPCGaGvP7C/AP3h1HlC/238b/36TT7+9qAn59vaH7p+/qavzo3z7dvf7 RkuRvtSpv94/3b01r1I+/YP6j6V1mNVUFL/r14bzvwgCWEDyO4hAiYsKFEX1O4CQSvvdAZyj w/7vuzqXXw+H370+P7/PfXfs7zf669be2qyf5c76mWL95KLP80HWTwSRAowh62efvrN++oA/ xhRRtQzABpsQzQxzfBzwn8b6Oc7TVbB+dlLpT/tUWIr1s+/FOqyfXWFR1k9bWITz2I33F+ol FBZqhKUUlQCntyzG+ul+UXiXke7TUkrGmNsy0EwWRM2+STid8OyQNdKyG2X9tH43yPoZP/h2 NsbPxcZYSQErBos69fAGDRVfVJ0gMcWXKksNL8Y4xsZ4ScUXxkrY+4AKT/FVmoDADRVf1iyd wMZoDbF/IZ659g9KhUJtu0sZk1rv58raKWyMWr8ytMz9sOEJxZdVXUxXpQVyNcXXqWyM8Uck Qsak0mdMKnfFl6P40kO0szF+fsVXFF/sjIyfi5HRGZUPPuzVHX4KvDdXhi+QYCGxgP41qrEW /dpGD3t9gJHRGuI0vnDq2e5hL5zHyAhoOf4lFMI4vhg7s8HDXilGxuEA3B/2Ohu+mIZo64e9 vgAj4/WzPV+eTnE7viJUpviKMpkUrTww5Csy50QprfhTt44ZviIe5SuCCb6iWSZFla1cAiua FF+RmiqCjGo95CviF+MrSqotNC8/Z9X2RM/wGF+Rv3UljrkoX5E7U6nzNgUNEkyKbkOaMvEQ hBYkf2eKAh7o8RXNNTUiKu6Y+XxFuWyIyW7iWdVD/CGITFPMefiK+oZQKmQOF0P/OyNfUd5D EB/SNHj/HcqZLwnrsSFegK/oJrQOO5PhakyGBhkQCgiKIoNVmQwTBg3QMrVkUp682EMGXdAy rhPIAFZli3kUGVyOyTDJOLRA4bAy49ACJsO6RJPCdSS1sl0Pafy9OgrKEhblQmQAcpCBqFs3 YfjxEuchA5/J0GHe+Sgy+DCT4UzeyKiKtm2qVU+5SGG4qkDBIAvqTRfWfVHGRINXopLFTN4a UgkElrljZgOgbohw4E+ysg3C++9PzmRotoH5oDoM5oLqvhot4dXYJqAq6fxBP2gm6AeFQT96 C7aDfhILIqJEKIoEVBh9AP0jPG6bAArAVOXh2mwTCUqeqO/DJlBhLugH+UE/iNFwiN09KPEc gw8ziDCGffuEdpg6al6ISsQOlzyYkRH0A4RoRtkKhNDf2lzRTtgmvE4kYUam70MTtCwrIePY G4bXSsAFiB33q5yhBl3QOnyRPF2v94XV1AFd5HQzBTOCrTjWMj1EOTBjzTErAgGI2SY63siP woxL+T7cHNa4NO/fZhqJFPOf2fxJHsywy6riGolKWKEGbh0kDTNIE2f+S2kkWDq2GLZJF8sF scX6V2KMS9cFwurLhWAGxOpoMzpL78FrJGpYNcXGtophlk59W6FY+rZCkJCECoOQHtmxYaPp JawER5D8nSlEU+NacIVqNY2EYHkPS84o8YcG5McHZ9oqog1ZcmROLbvetxVy44PX1EiUgZz5 kmDigyG8TY3EV3hbYWcuuSXmksQaijCX8JWUGKhScnx1b0qSkhmK3iwlxjUzl1hD7G5bMQfL juzD3YZxQ4ntxtg7WLpZzspcAiBM2Eq0EPpb20zLpiNk1TclT2Uu2exNyT4vKiSWguBwvGcm YDkyCQCJP5tey2aRyUw33SHamUtWV2JcoYPlhzgUSMihcA6awRCS3CSHAisIXIlDQRUW5VDQ 6TuHgg89YhwK3V9KprriKjaWxHaczKHQzdNVcCh0UulP+1TYDIeC7sVqHAqqsCvlUNAtm+dQ 0F/sHAqfkkNhFaXLuf1w9sJuvrA4wNq5Oj4dV4dAnBLRJFQ9VUzVw1CM3VmV1RB9ssENVD2L npC6ItfWD3N1DEPsXwGjFhbHX0UXpsAaDd1iZw771vu5snYCVwfkshpl3vmuwaERKqguqp3J dIvN9Fc5jasjZxNOusWeZ0fHVVUTyVlYWL5b7NT2bfxV8t1i1x0zXwAWFHYbqp7b81e5PG/H dhE0LU5F0GRSdlh5UDSCpqkqKMsyCjPITAQNiUbQoGRs7QxlBywKkYAZEX8VtVDSsbXqektc mGH1ZUWYscgtFkEIYxYlgCoJCN4+thZtE1urZyp1/jrYYfgiJMaINgQyEn9D0wiSvzNF0RTy ImjmmnpCbO0H/VWqWasQ9K1CsL6O2FpZFjDrnfP+d77YWphnFVrzfgxjK8CRhPVoN/bY2jgy uDzrxtVoITKpNwKpXqKF4DOMXjzK6AWTWohZ6o0y5XCyjNGrqSCkLdtAC7HI4cS3+vT7GIKo 5grP5Ggh1oUHcE4LwX1GL24zeg1D7O47Kz2Vk6beyIIWMIPRCxKaipop56Nm4EaMXnGHk+Hs +6yMXk2BG3Lce+VzMnqhQAD8wtaj7dgZQ2fwxc7dsSZ3R1NRAhsWhRarcnekI2VQ1WsLMjUP PKl5KCrOqBuQe3nuDr1fOGSh/TGBiGiKFovtNQ953B2j1DjbdoLwcwkaCGRyGtzOSHFkl0YV iBspjCD5O1MUQfncHVqoVtM8fJi7o5zVPKjZ8/xR20trHvqmXkukjB6irTUPn5u74wpdUXeu jhvm6nC+L2ce6C3EAsLPmXdKGm1c5y7h5+W1Dp+Kq2MYYnfPSWkd9PvDru8DmnwfJvKO4fPh YAhvg1FYUZ3g+4AgSGkdREgWGlQX2/93ro54Quf70PCwsJ2rw/19Ba6Or0e1cTVQIZNvI5DS JVCBzEAFEo2IbZNQYYZvA5TlIm5wMWOgoIK1VwYVUgYKQ17RAORChY34NtJQgfhQgTAaDnEa Ktjbg8/VsfhJM/8vaQPFSKLhS7ZvoCBylPlACJNQIWQCcQVyNaiQy9WRWvSHhIFiuF5DXwOx wEABwtCP1QwUVxQRCzePiC0DAQihwlpcHReDCl+AsKM6KzwJXxi/YngiN4AncgaeyCg8ETF4 otPpdAxHXkRrcgnKe36EJDzBBKBre3E1SdihpIGWUG5PBybm4In04Yl04Uk3xEfgyVBPSNjR yMBA4mU5mbBD5BB2FGB8Ei0Uwjl4ItLwJO/Zk0x4woKW5SR4OvYkPIk+e5IPT74CYUfesydr wpMqEIAYPJFtebvw5AqtJB8i7MAhYUd5BsKO0OXiJgk7ICNyJcKOqsFRwg6dvhN2HNOMTP0o Gn4Rwo5unq6CsKOTSn/ap8JmCDt0L1Yj7FCFRQk7hi+GP4TddIZoKgyH5+bpLYsRdjgZJA+J xbtzGZaWOUHdrRmdrBfqixZXsslRTt0qYUcniWVDENsJO/bC9sKihcUBFggBFjgDwBq1NSmA VUrB2zYXYMElAEuqnwewMKpEUyCQ0u2MgEHYeXBTqO3Tc2Adf9jR7Qx1VGLUE1kAS9sQAK49 B1YvfRkZa6/DmdHt+Ok2wPLbHAKs7mcDrFi7BoDl1f9xL5UGM/+1+6plADZI0qn+rQDWOE++ dmf4U+NelAVshsdWzO23RQRSS0FQoorXgW9n9FMlhJAEz9tPyENlYRACdix41klw2w69tksg Ut3EzqcNoAWMfzG1jEa62X1K3cIox3QESZVUpzmdiMjw0O/YmFGpR9MfETcBABYMYsq3M2ov ctveuG3nOKEqIog3hdeyjICWqGjovDHNkNuy1m6ZArmVZKnCwoZY/WYQFcFAoFjLTL0CevXS yooRroqCkIoG9acKK5zridpA2KgqMhhY1pbgDaUfV69Ng+hWR7zqCPW1iNFO+AldYdQrrCIx oR3yzs+mqP3CWh4pjJU1lfaukSz9uJx19TZevbSs3S+kM0UFLjCMOFc1ZdGQ1u+VhL4k4DAh Y8y6wkr7JoVbDmhj30qkYG1kApxOOINoDw/2hYc1aGhZHGDtLCUrspRIRgDEdXsIzWjbsZT0 Hku5Xj5NmqWEQla5ZrQrYSmJOQQrrFWp9n5alpI5+5L9G7/IZClBJU6wlBDXWJXPUpJrCouO 2eosJfgEU1imXvKcLCWC0oJfBUtJpilsTaXAzlJyeS+bnaXkdllK6ogmRsETDiXVF648L5sC y6oluI7AAw11SgEYuzYvm2viSv0oS8k4xO6+k8+VCtbgSrVoQ6yJyYsXwjAehgxRFUKLoLrY GbAqV2qKpeRoQsZRtzlXKq0UkCvDwnauVPf3FVhKbo4r9fKxyRsylsDU276ZYclWHhB721cy ovbdWkRghqpj5m1fFL7t2wW8TlqIxIIIDT6wrRMwY/So8Y//hBYC0pK4r+9ZfbkQzAiceYfr kjqdmu1jjYZZymUsCR1yGeb2OHmMJYHEDRmd89fBDmPRQfBvIA6dhNfCTbAFyd+ZZlo2be46 1n01LURuaHGym2RWCwFLnyu13N/29bhSy821EEUgZ74krBdavDOWhKhgD0O+pTDkxAKI+IKg 9uPQwFyPJWmwuDINRNLZ9mIP854ehjwOsbvnJOJ8Wh9W6F8dwIoZDYT/lzSsyAxDBmWCgt0I ob+1eZ3Z5GHe08KQt3iYNzRuFMtwxnJYEaAJr2Wf42HeLxCGfP3YgpwVW4Qv7F5M46AfGW9S Gge+TOMwPoceahwwL2oUhRV8RuPAQ41D95J8giNVpNlNysG/4UPsJubzQjYliWoc+MU0DkmO VFgi2pBme1ghj2kc/K3LVpLEGUqWIIFAJqfBzeNIJQ10EhxB8nemKOCRle/3kMdQkqVx6J5s /8BBhOahQZShJFPj8EU4UvMYStbUOEQ9fxxJMNAA4JvUONyG38Pl2UW2QwZCppBBJrGIXVYC GRSlulNGkYGcQQYyigxEDBl0xCIwiQyKAslMZNC5PJAJZTjIABakKZmrcLD6ci3IYGovY6AR p0b39v88jVgkwxYRcJfFfAf7XySyMQsZiFWRgRGkLGQgAmSwokdknBxkikWBiIpa0qTJBQZx qtDNK8RUmKiaQvLilHCdvjA/jkVSnwl8bHNVHVcJjFlUD9tGVuG1fhyAPq9hrp9a1iEDjBoG XdeDOWQwuA1MvQJe3jMjgyqQM18S1iMHuQAy+CBt2XWzhBRhECs6QxBr6OZwkywhXPR5Ps4S AlEVZQnR6TtLSI7hompxxUtqKA5OxBEfYAnp5ukqWEI6qfSnfSpshiVE92I1lhBVWJQlxBYW AQkIu9n/hXoJhXU8axt7JcDpLYuxhLhfFJ5Rpfu0VBcFxtyWgSmaFmq2DsLpdMQOWSMtu1GW EOt3gywh8YMPnPUqHZI2XK0BvyWInD+EANXpEAL1N+cc7C4drD3FgA/LFXz7KtkSqJVZjXOf vkID/riBaU17Sd1z8LyadmuWUiEEiIBwpoMhdoF6Lo94cT4ecdOtDAO+fspykK1ACO22Twb8 YdCSRJ3Rd1NOM+DTVgYty0mAsbMm0NI3rXC19CphIVHn8oRYy67XgK+HaGsDPggEYEFhC+/i O4/4+TT9O/fBitwH6uApIIdFFJmcnfugatWypxXvAxJDZIIOB98HIEUhbn4FoVX8ndRLch8A Ts2mEkMmVbklMsnkPphDF80RH4BA4obxOY4uMrkPIEbYSRh+ENUkQ9P/lbkPog1ZcsouRxfJ wnbuA68hn1fTfxPA4tLUCbRooTT9bZ5f/n6nd+67729quB8e9AzpThTroAvtCjTucS66MFLb M/UcJbF0/1KM6GI44cw7A/rqE/EjaGWb9CMYkcoMdUKqXRESy9HD0NrOYUtAQv9fBPr//ocb xotDoP/vfgdL/2/X7ev/rT+d94ESCERD8Kl+BKejiyh1Qi/hJTh+HkEeyGL0DIfBGW7E1ppj 0KIqjFPP3fUnRWrbNkJJCym9gHnoF5b+dEZNq7OUGNbpyH1UJ7ppJ7iFkShUQbDA0lfepJTu R8esWw5+vcdHNTZmOq9Iav+HL5pAVjwD+4gdkPSOewSFV1h4DmfrPfzS8/Qe/XaY44OwJlRB M8up+2It6oQlB1iQV28NKq+bU2cjM5QH3RJ3IhZwMRex0K0AleHt72+6Q1otY6qhOtCBWpS0 KYywCbN1CBZCpwAlhEecAoqTmK31qhpAQSBbMacA1ZAkKNDLzlI5OKvPcgqwK7dBgZuH+MzW 04qyQIG9XeSAAjeP2EHBGZwChnlKOQWAqz58Z0s/svf71aT3/ga0hLTkdMCiE2hZME6YkG3F 6rLEB4Yha1pe1rVm4GQhey5SGUTnkAadsuABsaLmNYeFqBmrFZRiDQVNw5E6RTT3RBNtGYQM BiAPHWpz9ExjdNA6nE4xps1CTmFqIJxejdGgAJd9v+2cdXvATtvLyJh1OUF7cHN6FEuWcb7P INugm11Oz+MVme4c7JxNNWisTIbuad2wZagfiMOUk6G+mzpnMw1E37Jx5KbChpxlT8hx6HJi Ny8E08h1hUlEhy+mwtycuDwQImpc1mjov84rlcSKti4ZbDk72BlgYxem66ytMT9one/4aSHk YcppyJZ1y+wMjldGMeYktbQnr/uDPLg5rdd0UCWqWNjmkHMc3mnkugTEJUWl6cXByiDaxi+s y1lYwwvM/u1Nr2iq/gs7g1sYLGkhx5Eb+i2afqwObk6VIEVVttZQe90U9bD84MHNCYqD1MxT 1pgfTIa6+09MbDbwBjRWzn5tcmd6BXVX7/ikdN//vrA4wMJnVcKET7JdsfOJ3IC/Us7wV8oo fyU4SQmDeOoR+4XOJ6goOeWHw3U5n6TwVpS/chNiqTnnE+nzV0pKwyG2F0W28wk84yP2plsf eiWWzzxiP5Qe0+PnklJlOp+IoGU5CZ5Cobt+5ZJSHUGoixpy684nuaRUayphcCAAUSUMkrfL HvElbESXJrdCpIR6jN/ke2f6001HZmCPwBKKjsOSYS/UTDo85nliqKWrpTGmbRhjaq0UD5aY uqfOTLDEO+YDUqtGhrTafXttWGLt9xCw2nu8Xp1/vKSsldSBJd33Ek2LcXrgrIcSDNBIbMg4 8pYaSJ+xmLVisn9FHjgrE7BkSWzIldFqD7MUtQ31A2gnUMnTLDz93LLwvO7qEYh6n2LbaCJo UTAvAUQMTf2nlM6d9T2OtJZpLcsirh1Rs8JIUO+QgETFRCRAIHbEmixj3q5e3hBUJUtPdzNd b5hgVdcgWrXhBAxLZbYhUQ6tMioaIbaiJfC8lJis3S0kfBLOLsydEerrq9B6hz8UhAf9TsjZ lNfgcMJo5YdCOSwnaaekUCSRgkM+6AEBlo5QkatpZg22YElLCK/UZuRupRYlXUTOgsJ83OCs HpsUfxTNo2OWGV0e44jrxqxjx1+00GMuZnPcdMfbnrkCSkLo0eW0joeTYXzHpIgX1hQAnX5l yMO0OajHz2O2YJXn5f3uVb69P7/KMWvZqJxJHGr20J6GXYFKlfn7o4G/1SwVmtkLdRu9bFw7 VkGcxKJ6KzN2T4UKf3u/e/v1/r35WfeP6IyiTaNtpg2ABy7EBO9rlSWNz/UOoFvY/CzF9w7S V9rsSZKD+EFIfxlG+1PvBIR6dwJEM+8Erk0Ynscm7F8OQHc5mFYpkZLrPizRTv54PGYMBuMt IFj1Cz3EVB7i3wIoL5uGiebgGYO73jSOcnL6W7cfDbcAN71cznrf93FOOZkqyzMGT3nWeeY4 ppyECeUkULeA4RFWh2lGfc/xUFakva5yEo+3APPPuVvAqJwE0y0gvkR23sYVeRsVMqQC0+Dm vAZvY0o2g/cqi6Y6tmZ83BRfM0jyVrKDrdC/PG8jJBVDsTVzGYV+Dm9jHFB3Svl4RGj05iwX vhQxZDmCNNX5Gn8pwgjSEUAd522krUO16EL95exMH+RtLGeV8qD1YzbanbfRi9lod97GINse s3EEe++0jyvSPipgwSgRdRRYbET7CAhLvTOxjPZRrdoSb0L7uEglLyiksYewo+9MbKGSX0L7 6CvmiDA8Ctbmqf8nskfXvBCVKHM0daPk9kJ6DFiIwk1wBCkLWPi0j10nVgMWMdrHdTR1wajW 6jgHTbXqIRlzpawYBqQiQb1zTdVfxPwyh2crZ/KmXqvMwE/dEOW8VrnmmH1y2sfrf6jyQ8SP 1TYxHiG4uEniR1YQuBLxI0I4Svyo03fiR19FESd+NHUIydDmMR7DPF0F8WMnlf60T4XNED/q XqxG/KgKu1LiR92yeeJH/cVO/PgpiR/PhQz3wvbC7MLiAAuEAKs6A8AalS8pgAVrgiq2GsCa CiZU9q9y11Z6/6tsgGW27bpU/xp32sBuqpWtAcBilFYMuMwaxouuasvpXSkHYHX1oABgdenA VdWMZbUBwBrrp/U6dlOrL6OqxhoXR1UT6WOm3XSxDahhCIcASxCBK1m2aADEmTYggj8KsIZ5 8pU11pCEYxoIUmJG7MJMPS42qAluy9kvGiZ4RlRB/I0OECGdOC1EYZBLGxJUuGDbbJV4yQT0 Tc1v2VR6qzYuURJ/zHy4PP2BWXnbuiEE+vj5CCn05VkXryYuL5N6MZjNJXF5ZCYuj0Tj8tBp cXlt6vnFJXF5LYCSy6Ie78hWnquMy7vMq87DLKXi8ogfl0emuLxpiO1FEX/VuSM4dPcP3HDg OLGv96pzwPToSd1QWAHqUbYCIbR6FcTloTQpdB5tY6Cgjxd22qvO3rtI3aGTS9sY7FFHzPgj mQbB4XgfOdu7ll1xXF4mbeOaNxcYCIBf2Hq0jfurzldKvHhF2IJvgC34DLbgUWxxIvEiIetg i4aStuOkOjO2uGFLfop40RasYKaDIT6CLRZ5AYwDMpipT8QWMANboKJIYAsthHPYAqawRa4X QCa2yHMvPOVoS3oBnEfDhysmBGsigWL5XgDTuuuN/zndTHkBZECofC+ANccMBQIQwxZrEC9e Lub/+l0Bdn6hG+YXsjdqTSsWYg11eKFSa6lTqmjsYI0xGrxOYA11t8Kt6zV4eT3GlQXyf4Rf aBrik7BGH6VuH9NOFK2JAStOxho5/EJQFKPLofspZuFD065oJ7FGOox5M36hnKNuGF6rqaJt z4o1WiQjTArJer0vtsca3RBtjTW+Ar/QzWGN4qxYI3w4+pIvVUGYCk5Ay4IT9D4ZCU5Q50Zb 46IaI4XdOmaCE1AYnGDqiL9UBUFZp4MTpPD4gsafH5zQB6glX6qqGsjjUY/oYlGPCEFBo7TR qGoKKFyXwk1oDI8FJ/hbmT2UFCI6F/U45Ekjg0Amp8HtyEKO7NiQFdRJcATJ35miaAqcM+qR +iTGsaaCzxT12DVESSEP3sH4KlGPRSBnviR0UIHeZnDCTYQtXppG8Gq0EB1v1Hm1EKoOloYH hAVaCEPWlNJCsJQWoqoqwngCHkQesuRq9cfggYE6BdMO1telhYhGHHR/0SF0fGN4MMxSXAvh EJJNMx0MsbvvXAHL8cgU5ku2p4XobnmdzDvfkQi0cEV7C5bjBCHZ0YSd5Xgtb4oLsByXgQCE WgjetBDesBbiK7Aq7HRN69E16aOmobhqo8jkg3RNzvcirbiAoE29vxBRXHCFF5KKCzU91fje ld+Xa1JcVC3iLZVVAzz7yLXTNYEroGti03M+oSD5O9NMy1yhWk1x8WG6JjiHLppWuOhCJexP bDuKCz1EO13TTtd0ViIGEsYJFmeIEwzxyE0SMUBG5EpEDJhUUSIGnb4TMeSrRcpClJcgYujm 6SqIGDqp9Kd9KmyGiEH3YjUiBlXYlRIx6JbNEzHoL3Yihk9JxBA/+MBZ799hXPxl7t/jHZDH 7t/6/Yv8+3dXFmtj929Ry7bBReT+rZmU0/6JSLr376GO+P27JWXCMtDigvPk+4fEuX/3Y0IY Td2/q1ZWMVZD05fL3b8pMNe74Ahs25pVW1oGrFla5DgQJPjYOnb70Dac1KXW/lmD2wnpkXsR wizuYwgpyXt/pF8LeU09wXFA+i2LDmKym2jecQD6jgPwOhwHBGkkug7HAbj5/TuMNF4uCVd8 /77OC/ROw3DDNAzO96yOwwP1vXmJK89xYD58QaiVw6jLpHN5x4Fk+IJEZW29E7Zd+MIHaBiG IXb3nesIX8ijYSiqUebdD91Hn/NpGFYNXziVhuEqwxc45QJGZ3MPX7B/X4CG4fbCF3Zahk9J y1DidWgZRM1ZyeSVYY2kNv5ilE8foGUYhvgI1hiZDICltAQNkRDaZ+66lE85tAzqNtuMshUI 4RzWSNIyrEz5dBotw+aUTwSBqlyV8qlsMk5lr2Wfg/LpC9AyXD/l007D8LloGIYeApapxzCq Q5oKgBC1Qvv06gIgUnSSUUv/JvGRp9MwDEN8BFskAiDiLoquAEXNHFnYIoeGQX2ViK3UQjiH LZI0DLmxlVnY4lQahjJ2gufGVi7BFssTcrHFlQRAZMZWroktvgINw6f0U7w65oYrgSfZ9A3B ylgSn4lm4jNRGJ/ZEQOcwkgJi3VUH+pWTgXaAJ7cNiMlmIvPRH58JmI0HOIseLIxIyXIiM8E 5XSihUI4C09S8ZmrMlLmUj+ccjpuzkjJKec4osjaGSndXxEIQByerEH9sJtZboYLYrtgS3XB SgRbZtJA2GVFgy1FgwrYuu8ijXXMBFuSaLBlawdbJhZECDNaIT4OM7oOcVS3Dsyw+nIhLUjg 7NlfuRDBom15cREaiJODLRNUDiFmCXgZjkOFkGwhEAf9/9SUJTwytCD5O9NMy+zNPY/KITpm YbBlnkdGsptkVpMRp3JIFLaNs2ff1GsJtsylclhT2VMGcuZLwnpUDnuw5VmARXVWYBE+X33F Sgy5gRJDzigxZJRkSpykxEBNQomB+TIlRs0prINQEt0uTf9wIXShjbJGWRGgC9EULRanR1Oe ii7EnBJD+koMyWg4xO62lWljUZv8QpKpAIg4vYjxVx47QmjJR5kPhNDf2oLq4keIhUy6Iapq 2ITi5++BRwubftYgIsLK9AF1SNhY+gQA3fhTbsJQMm73Xd9ykElWy67RxjINkQBe3jPbWKpA AEIlhlrLbXnDSoxPCU8+xAWBQi4IfAYuiNAr9Sa5ILjo83yYCwI2rI5xQZj0nQviXzK8T5Nv Ri9BL6dyQfTzdBVcEJ1U+tM+FZbmgjC9WIsLQhd2nVwQpmWzXBDmi50L4lNyQZwChs5kUtsL +8SFxQHW5TlHrkRblE08Eoz3Eo9cVM8Qj9Qu3hopLRKRxQniEViLhhCc8sitYtqiQsSIRzS7 d6VGRUJHW3R5j1wkGsxsbdGYA9YIXoh4JO2RiwgIZzoYYv8WGdMWaXoPB6nZdpW1o31GNhFf sr3CcDvJvPuhDElLvM6kon3ySEMzXV7yqCpm1Cjx8Z4jDZ1Ro9h/MNqiMa+QpPqE0T65pKHr noK+ACwo7Da0Rdcf7bOzltwua8n4rEdoiSpEKpI4Siqeeu4EcqKPRnxl2CIZSVyV+uZ7gUji 01lLxiHOwRahJeqMz51kspZAUoznUSiEcWxxhLUklxAtC1ucylqCYid4LiFaJrbIasjtWqKW EaKtiS2+AmvJp7RE7cHINxyMnFhIkWifJsW5uijaR9/LS1Zf25vwyWDkBaRq68KT04ORxyFO w5NgBoOEJDzpxyvia5kFT7KCkQUddR+hEM7Bk2QwMpctWA2epIKRh/Nza0eZ6dOmKGqSoem4 WXgyDdHWjjJfIRj5JvDFpaOJEea01P19lVzcfX96eG5+MT7Sf9CxULPAolznFXh1Z+5Cb31g AVsqbGDh5Anie8yv1TrhAFhIihmd/Ds8YAGqggXxPV06OQFYgNCHxfyKiA+L1uyOhFEGWPht HoBFrI+wSAOxEVjgnhUWgLOytVYlsy85W4YRq1mKx/eIskYzQZTqQ10XcOecEf/E7QtjIiT3 HmMmB0L20f8Qqr1HBxum9+gibEjyC9DP+syG73fCbjtvuBQHpyRAvUPSbnOisAif63AYFkHL hifiKr+p5ZAwjJnvQhQpbBoRp2V1HTnXvAR06phVzXRI9ttUFY7ZlDcoffhHanp9YAGmqfFK 50fPc8pS3RTk6JjZ3tqoBDQQjW5EKBOMBJ86Y0YhDOY7HkhvrTyVN95UxqibQOOOOt6IUK69 zWY8dwbBC+UsVCPqwooaCH+8vZY1viFwADCwHgiHer99zKaXcKeTzJ+RiBaLEonCXvlSzKE/ Zjw1ZrCa8iIBdfQt8Pcz6o9ZuJwSqtc+AU3/yW0vL6huCpFHA0xDqrKwOjEcXtZAGHKnj6HS LNjjZzIHisr0Tb7fvfBv8k4fSHff2qe7F/SocjeF1ncl8ag5QlR2lVXHm3/7we/en3V2lbXU Rrk2ldNs4AaU6sj15vlFY2fUCN3YZKy62cG6YHf5+P3h7tfX+3cNmxusMXeyLrPMVTaNNXU+ bjIVNSMGqjdJEGxWv1Wfws8v98+6odXcoJolEtTXMMCO1EeUbPAO3v/5r/+m66n1baKUqQxq LaBao/SnH/zhXqiK7jRyfn39/qLtorhWuatkbULdbPXkvf/6OrRTjGNawbnrQQUJqQK5eUA6 p9SDg0j6OoKxrlbdXx752y93r/z+TVr3Eq4rTkqcut+WWmCbt+Zn1VpzC/qV/6LrhVQLK56Z zQIWPVVC39275yedUxSz8mO0Ed20/Caf7n5IhdE7dTDWYZcFSmWssQKRukb+pK9Rj49GeIgW A5TMhDTu1DdEIaZLZT03JrXEDPUd0xNi3O5NaOlwzUuvqKYFtM/6M3+5e1I51bB2U8q/Pxgp Miu5SFZ/4ippyrLSN8w3zVzxKH+7f7/rxulVZVXHqZ4SWqYbTlDTN1xV+CrfvpvuombWFaBU JeqpbJ7VMvnt/e7t1/v35mc9lURPpUjKwPJZQQAVemiNoH7vrveVHkmSVA7UshSNWZF331+6 1WyWRNepVNuQOvaIbpt84vWD2QFe7369fxLPv+q8ZiBxnaqyqYQW0R9dPHKEPYSZJqeyt8Ts WHoSTb387e3+TUsNAnxWzJuK0LbP+fb+7f7ugdfyQWU0wmaBv5SSwQ2QgT/9AGcIkPG1DaDT NoygCRB1q22q+QAZQF21wo/HY5ExBRy0CkOKeSABgIS5QgxYLWKugI2vVdCPHtSSjFoFO70B k3el1io49TM6ahXsPLAoi/W0CiCiVXDL8lhDpjw4kR5qFYLIGC+Pr1WACa0CAKQdZNWJ69Xx yRiEWgWv/t6bAo9aBfPPOa3CaK4Ak1YhvkQuz7RzJXa+bLqdmPBkB8STmYB4Eg2Ib09j9Sv4 sYVjnQ1zdj5SN+XVPZ4kSjVaIFMdtxHdTjognvgB8YTRcIjtRRF/0KAjtdnMxTlg9/GkbiyM DSFI/uW0mHk8KSQC6v+yNulwLlVPoLA7Yudbg3TYdXEucFuXa9r5rsPF+RKkw2UgAKGdby2q nt3FOYEtyFmxxSBraWwhuCx1f19Qp616f757NFonNQyqA7SYBxbZdj440a4HwMKyZ0WAxXhQ ZgMLzKsAWETsfLE8HrCQVc8JuBIiH/2bpyRj5xtvHbadz9SPafERRB4Z47PRBWv/5oqTHKad Fe18wyz5wAKODyHb26qaZhDuhOEXyW31Yy4nPQhAjSbRATI0iIQT5vxZNS4KeTo5SRZmvkCt gwVESVGcrlAVBsJPw1H1608UNtY716vg9hGBiY62f9S6q4YMo5oxAccagt22F2gygPXfpCfA G2889TskYe7X/ZwBzOsDDNtuDYSEuEiRArph791+E06AP8xhN8fhdSegHyL9875oR8wbFKZW AOOqKYERqfLlLBQe35qmqilZi7VHxpHZbMM1kmGB1DCiahlz2u7NZqKbsYn3emVaVkZM/rHZ NJuTT2KwbAtKfjo2xB0zGkrxzHKyxqxoub8kbANz2M1grmw5i7lYoCDLIlSaDX2CjHo/NBjR GAl0VgV87nijsalWvGpzGEpq3D+cvTaWhpSlkdNZS6PZKXR2Y9v4lT/8cveutd1vd/juQf6Q D7oJUGhDYJW0eH3M2tktJ2POebkzoz9YO502dOadpMnuAyZTIhG07CwP90+Sv+rcLz//XVfN tOUMzdh6TjK5tpAMmUy12rxsxtrMd9K8QxkrQGh0rQpwxAgKWAlpJ2dP72qO774/PaoBb54f H5+f9P+8PEhTFjTDlQ7G2NiaurQ2WrRQmn7qqehE8fubfL17eBjMNsmlTBghwhJkc6WcvY9+ ePU2mM2sHCXWs8v3ZNvrSSbUDxhE66Ya+fR/Q8Ym9vj2OlrFwdx9ejem3r4xVQtAQ+YMoojM GkRLBPn8ewxGc5QWwJZgEbWowlLMOw6cogP6oBmWhGZYeAYzrK8QAhEzbFsVR8ywxVIzrAzM sONbL57SZ3h6ZYnSZ3yMxTPDDg+txJQ+pv5merzBTedrKn12M+w6Ztidl9yhj75yXnI7XYO0 cOE0om1xUze0SSyc6NuvLMkGgdUlkI4Lx7puXNIMG/CSD+kXM8Oezks+DrG9KPLffl3MBtF6 P1fWTuAlVwf7JPPOd+oKMWuGTfKS576YkmmGjfOSH0uIhw5mvpiSaYbNasjthlsuezFlTTPs zkt+o2wQH+Il990uwXnwfhjkeZO85KwgcCVeclGKKC+5Tt95yf8li5ecqetu9/ZYhq03jl5O 5iXv5ukqeMk7qfSnfSpshpdc92I1XnJVWJSXfPhi+EPYTWeIpsJwyvp4SstivOROBslTkWPq NLaGF1JGpzdZ1RdtWbSlFbwa7Wb38W3ykneSWDYEsZ2XfC9sLyxaWBxg7bzkE1v0rfGS1xFt Ea1rWkFZFHVCW0Q8bZEuS+KqnjCSpS1CleE0IFemLUIISug77Vct4JLT0vLKuQVe8nGI/Vtk lrYoxR3qNC36Ru5wTqed9nN5yUkjRpl3l03VJLRF0Zb1Q7Q2d+ipvORbcId+8lfsLscd+gV4 yT+ntujqqM2zXk8+HZnY5wKOs3tls5pbeTrSZweZmKOmBLIdNUFuHeUMq3kdY/dCbU8nuojV vBQwgUwirOY6eitmxzJdR1VZBu/rDn25FDJJvpiCiN5Zt3wxxZqlOLuXeeN71hZVRNFFFOa4 NOPH0cWQ5di+LFNv5JYitEXNtMwVqhx0ER0zs5c5UCUvJDDZzXIeXURDAjO1ennoYmYClqOL ZGHwBHQx0013iHLQxZpXap+pKpSE9ZjJs86fCLCo2jSwKNsvDyzQWYFF+M7tFes9+Aak5HyG lJxHScnhaaTkpEigi0VkBQopwQo3W3jJrBJTKFFZlSDLzrQudyic03twn5ScUxoOsbttJfQe dWlR6yFREWEu9dPu68UPDX6Tp+g9TLdy9B7VFOsVCKG/tbmindB7eJ1IIpMsvQeXPGzZSsrn 0S11Suj8Uc9z7OKqAQg2PCwsWa/3hdVUyitRySKrm71n7JGmRtU73RDhGfbcZMIHxgwFAuAX ZkjJcXPDXjJmL5h3ecdgzuV9fwBlfwBlhQdQ1CpaB2sgiVlPsnQ9NpbgAZThyqUPPbUdb+yR O8zSSQ+gjEN8BGsM9bTuxoqb2jlzVyRGwpkPoKhZGmUrEMI5rDHzAEoDVsMaqQdQjiV4/AWm wJgWpPK1INVCj9w+LyoklmLVt1+vxcZSbW5j+QIPoFw/MdJOunhLpIvO9yzmvzF2ESewRfTt 1zYR7aMu2bgQZXlt2CL19mspEWK0bDL0GCtiiw+RLo5DfARbJPw3wPnefs0lXSzbhIVFC2ES W8yRLq76uFqKdHEaxG0fV7P/8Mn9N6Yh2vpxtS9AuvglzCyX5m1EmLeG9MQQatz1b5Q4bV8N lYy+G14y9FFJ5W7quahk+ctsFmNkwNjYsJTGY2RZPGPw/vQCG/baJdAixsY+T5FAJYusK8mX 2apSiLIZIqW2ZGxUs5R6mY0B29rfEck4YI018tjRM5gd7AfJpukJ5jghdOEGH+Fes9quRrkM jo/460/de1hDvX5DQD/7NABBEbw0PAwWtGyY5f5/J9tNZ3YQIhgzJComSrshwSAmqwsxpulE DKfZA2EId9xBJKgJC+u8uVmkZUHb0y1LNmQcIuuPnaz41cWRXMwi5Tgrh7BQc/4koDSTtTOI jUdH2BXmVDbFFQbd9D+NDVHmmEHBUNjvhKx0LuBCUDmznGaGqL+V2SOjyYviZlTNUTQ7AeZt l+kKURWcl2Vq1yiowzVvqIySgpeizByNOpAvWF81okIBQ59NtS+sLVEdri+rm3VLi3BUY4VF hte+B+W0bLlYfQzSZoAeP4s5Tmbo2iCZ52szW/oRKjJe70xkV8xE9tFnnS7MYlYaKsWQxcyM 7tWTmJ3jLakcEjMu2iOkBgtIzLqdryMFs+9BEgogaEX9e5C3uWXdg/T7TxzKgMSMciKI4M49 yG1XXQz3IDed7SRmPokZb5HBrjuJ2RWYNW6OxAxFFo4CuUoS6xKkgj98ErMOLZLJROK5TDSS V83huswa0bDU7i+koazaOPjjQyRm4xDbi8I1awSSFSRYea2w1N5grO0/J5o1RI5Zo2KJsNQC 0yScP0Ji5rya7DT1BLPGaSRm3sMKpsAYiVntk5jVlzZrdA2RZVHw4/4XW5CY1TuJ2RnMGtdp l/gQCxkIWcjKMwD2EVDcNgsZZESuxUImYZyFTMKdhcyHH0mvCoBKLkqU8+JUHH6czkJm5ukq WMg6qfSnfSpsjoVMwhVZyCSMspDZwiIgAWE3+79QL6GwzjDNy1kJcHrLYixk7he+Zrn7tJSS Mea2DExPRkLNBkY4nU7XIWukZTfKQmb9dhayvbC9sGhhcYB1eZqPK1H3ZHN9BOO9JEKGzETI kGiEDEqykM1xfUCCEuqeRV6sGIO2BptE467D9QGkuh6Nrz5v5MU6zFIqQob4ETLEipAZh9i/ BiZM78u8WPs5jxA6DOd0Wt0TUIsMP68wJhNerFoI7bb7ETIoHSGzohdriidkGsRtvVinT5ui qMnH3mudCtu9WJ1eBQIQqnvW4gnZvVg/L1mItjdXMXszsO3NM+qgJcAEUeQBk4mZwFIE2TwM MWBCuQ6yR4UPTOx014BbqhKRA0yGvxlDbRMlIYMD0dknNuCuSRPCLU6ALWlC1Cyl1EBgpcvJ KCXel/yUwo43pBfksLqwsFHmZxI66c9oWee3UQRufIGnI/JGhjRnnoDUpyjcSLo/TFwU6cIW HYN5G+XMPr/J64L+hg9ijjlFc0zPjw65jjmjqMYDFHjiwhko+K2yzrKvu+mk+eT7+i065lye y2Q7QlZYpQhZM2lMrDwgRsiKMYYUUXmIKWnkDCGrjGIhkCBkhQDOhBo3xQJCVs3MnSRkVeuf ulTxVl8Ol1HSQFIx5L/IWbWCCFzJskXcXTPb0JjME7L6qzqhNLDuTzN6lSCh9X62ogXkELIK SOMta4pMQlbgEbLm0r1Hx8wnZM2lIkl2E8361cTp3jMNnF+EkDWP7n1NMIoDOfMlYT0qkgsQ st6EkqQ4KzIIX+jzkYGEuNIhAAYF3/3KH365e9eBDG93+O5B/pAPOo4FAR0OUFXzOMGD1mmc gFqipF9tADSGE0BVwDhOkKHOpBJgUmCPOGEIFe53xPzg3ykuKYITKlyuqTPBIbbWO924Kj2c YP4WYGvVPNlj2xi2HoOS7eBfK8D5w8acVPCv1plYOq7tdCZmltI6ExyMtv0FrGVTHIu8w9Pu 75feOyrCMeQWTALf//zTWC+FplQYMO312C+KtkhJ8LHC9P3HLawM3H58zw39G4XLghT6gUY2 DgRB+mrVgCBL7GQJA6Zjg0jnCnMmisYCpo8mZBygOjKqLssgLww6EwFqw+KyxqxouXuAmo4d H7NurhhxHK8FE6HCqwimNxRadRqWhpnw2IwUGRMQfBr0ahxVq+284SR8jnGK+k411RuI6AQM c+S3DPf/W/ktK2fg0Fw3uwSnZXWoPk0XhhJDlJhvXjURoNbPc5Ueoi6BVznLaRi7xIwMkaag Dnl5U4VRz3kMCHJ0zKJhyagE1G0IZYKR2S9MUOwigHoSDPIK6fZGHY/JX+5e0OPdN373/mzC gq1CIGHatCdTWNKsbx2Gyr/pMM5vP4ZCVN5SR0omo2TN6jLQVQeENs8v2oqJCo1ccTIE1IiX FT9sgp9VvgbPRb12wmBlu396e7prZRfOW2iEncppZk/l1FhWZ+WmuqJmxNwEmiTIPjHSmcEa sKC+hgF2pL6KchMce//0gz/cdwHBCmi/vn5/0RGy2MhCKjNRBwHv7h5//uu/6UbW2pxcJqe9 rGsOTGz04+Pzk1MTAnP9I4wQoSVXvpvAcWN8nrVci5Kiuah1Oh+0LsoGM6vCOw3DTDFK5rWA CyPgMxHrBexFZ5iQu+cn3W5RzMrc8ijwGldltyB1aPvd46ORl24BJmOb60oh2inT63tzZ7IZ Y8hMSHwL6JFQfmzWbzqW/2NB+aXsouvlk+h2G9Vsc93ubrBQ6tsySkoFQQRDlb19+P72892r 5OLvd/L5XnN3QpUxKbgVJUwYaXp7fLnTO+1d+/3JODI4UkzE3Eyp2oke9DclVKrWrv5h0NNV C6gzqZre5INs9ICri76WYWL0CsmxIojWZm2//q+7bsvXlXZ6CbPTSi1XMB04fxJXgGoPQ3pX eJUvr8/fXvljV6Ue43lnk5slCvhgzH+xTcy/ryYBEdNiAY+ZFhfE/I/IL2ZahDDgPvPQVsyX 1eTxYv4JlGHMv/7ViI2qAce0yBGuWGlMiG9BOthNi1HTYnNJ0+JOZXxLVMYJAYksHJFyAh8X jnXzSD6TgDGqEa/qg21fvLwT+LKguy1i/k+nMh6H2F4U8WcSOvZfYMUmgYZICF0N22rPJORS GSM8KEn8K7mYcQKfozKmreO37TT1hJj/vMcij6gTTIEx26Qf8w8WxPybevu8iCBQlZ/ymYTt Y/6/AJXx9T+TcGke4s3cljoezKjbEgQ8D1bYZVVxt6WqKDs38QBWcJKGFbwJzJGmDsttKbEA QlhBIfk4rDBdJxCS1oEVVl8uBSswZ9imEhr2sEKB9O1fXxpmadE70sG0WF+s57Y0COmxHZpR L8EWJH9nigIei0R0ER1QdMx8t6U4N+6Cg6iahQZxOqBEYcfdliJG3tPdlspmQWHnc1vKpAP6 ABIIEsKX1H1JMNAA4Nt0W/oKoWGXJyrcDlgImQIWmRyFdlkpYNFyXEWBhZwBFjIKLEQV8Yee 4yjEuCGMCJoAFqOf07RY9St6KX9owJmAbtC61ZdLAYsGlNC8nezrK6AUFRQX4ShcCCwmLARp NPA8eny7pIFZwELkAAtUJryoIA2fgZ5pmQ0sHGrAjwKLPJ7BZDfJPLAofWBR5gOLaEPWAxZX 4g+tSZk2BhZVIGe+JKzHM7gDiytgKPQjF8E2kYs3ylDIRZ/n4wyFsiyjDIU6fWcozDaWAI4g JRdgKOzm6SoYCjup9Kd9KmyGoVD3YjWGQlVYlKFw+GL4Q9hNZ4imwnDK//iUlsUYCp0MkoeO ud2prg5ia3ghZXTyKYUqgcGaTrMZ72b38W0yFHaSWDYEsZ2hcC9sLyxaWBxggbPqeUY1zYX1 PKOugcfj3hHJ1/N0ZbFo3HuLCZOER/Q8qo4ZckIkXT3PUEc87r0l0ybp6HlKWAjMQMovhYZ6 Hq3rT+p5MJcIRfQ8pi8X0vMgBFvWQz0ParUF3VbPY83SiXoekKXnsSVu7Gz/S+t5hixH9hII 69JJGH+MHzUg2S2bhGrluHcZtCyWkOzmzcW99w1RwCGLN6n/faq492h04kJJ2PU8FzUgXZ76 eDtCHXUTTBDqZLIeW3lQAljQokKjDsetY4ZQh0QJdVASWMywHkNZ8QSwiBDqaP/CFLDQURY1 jwILcjFCHX1u8RjrcVXVNWrp4F2+VIfT//M01uNTgEXkmdkuUB7jyB6dxhGBTE6Dq5+ZPbrh I6IVA1aCI0hHgIVdrw0sLD9TvSpgVXFBvaVI8oBFirnYTzjlXKs5xFVDNr8ldvWWYRBwOmF4 eDIsTG2gFcQhEaSdt3tqM7ebNn7qmlpkNHXNMfNfYw8lYT3m4tsDFltjhJ10b03SPYUR1G2y iWKED5LuJVZC6L3KSe1iBN2usmwZLWMYgc1gBN7yMooRLke6l8QIJYC8Bo37MsJVkO7FMUKe k8nQuyyMAE7BCECg1k2wBSkLI/ike6s6mXyYdG93Mrk9J5NPTrr3FZQPl+bsu6KQW7RByC2a CblFYcitYRc6JeQWUZbQQCwLudX6GgTd2JgrCLklJQMIhOhCU/VZ47IhupgLuUV+yC2yQ26H IXa3rVjIramndbdh3DTA1hGsGHLbVXc85LYAiZBbLYT+1uZ1JvXuUgNykEkASOLnURO0LCfB O9xSyETNvGcWqY6/uzTEcU2wUucVrRqxSCjMEZ3/MmQyc8/v/tv69CgyyehmN0Rbh9wWgQD4 hXXIhO4ht+fDFpem80CYtnpqDAOTanvzi2o7t5seRxSsWowooI8oDKMAZsWAKPz0GUQxst+M W+VEcptL/tvXA2JBMW2lJGsxohiCX04k/431JWC/wTUbEIVfR4AoBl09AKs4S8w9mISAhyji No0VyX+HWYrrK0TJJT/0rn5oaGn82nqMYrenrnYqLvAUtjJMqC/AEXjS5fUbouc0aNnwj/YY jWfYCXsgJCQw4M2NXpdDfmS/9F6UfDR0vGUQVbIpWgO62rad+yJZWIpsOez3RIscL8zhRzYz EuNHnpkA+4CZ50f2mzq+7ZQxm13LYEjPOyYMtMixwpRMQRKZzemf3ZBnIIqxIa4Us7BXR5eT GbOAH9lUEnbTn6L4Qjf8yM6nNituYnojhMnTMk41xH+YK1ZYslfjBFht50QiGLQ92k3ecCmm lnkMyn03q3AgEltQ+IbqlJBmUA66OYxZIGczDMqm/rpOr4CgsBkGZa+beXD0OObxc5jTZIYD lfJZClSzBx9jGy44vGq2YS2rFh3vw/2T5K8698vPf9dVM918lCYe1gIcsBU34hhbcdVE2Ioh nifePJl0GLAS0o4r9+ldzdHd96dHNd49S6/6n5cH2bXAjFZasbmYEHhb+uEKElIFAv2AdNek 5ldGSXLRD/D5FlRfrd752y9qFO/emp+l+P6gc2saV72M0Cwp6UnsvhIz1LfW0B+bJai11cOt bkZiP07xeyKJ9ceYgU8gTt75bTfhty23eTrTv/aDCL8tbo8FoHpX/Dl+25ohWTecDjf8sSZ1 akAq6SFuMxhv0jk2A1WWwIIH/LYmXY7mrVeH39a0a6K9cNPZZ38S+Rb5bS/PQXc1xrZMIrqY 8GQb2/iMsY1H+W3lafy2KPV+5lJjWykZkYcrM7alQralOout6/7ykO0PENGljW3cN7Zx19jW DbG9KJL8ttI3tumf7WyzLr+tzDK2JfltUfj2pteZlLGtBWAtY1uKxM58YYxeiLDwgh43aVnG tj5BXTedIHduYpAyrFD6Mm8b27QejdR8zmV3rmXXaGybhkgAL++ZjW0kEIDQ2LYWid1ubLtS GjpStZXotC/S3Eaff32S6vLxJO5eZStf5VMzvudDPg4yqCtFAcgwpFrakNGDDO97x/4WK+vo 45uhJn4CGfbjhTFSut4utyU6H+q3bGYBOje2g/Xsb0t4YZKPby6IKVrX/mZmKW5/M89UeTPK nPPRPEt1zMgySikqvMJc5beYDHJWdRH4M1iKgjn1JzOYwYSZsYGj47LNcNcmrFwUFtSxcgWL oTujIlauYbZnrFxBN4/32x3ENmbKMJfCyDudrh1MMofDPf5cY9CrmXdCswvzjQ3u44B1XQqL 0UYNWstqFhZmBqCcDBXTq5TDF2NTrX4XLaFRyGh/GjfNJt4JjSJj1+43tHjWDiaS5h8zz0ct NmF1+S3LeCc0ZeUigbUHBr063s3jj50OizVwg09buSJ2KO+/gy/SlkGvV5HnMecmwB6zSg7e jUNh9juhwZgNpSVEQ3/qtZQdnW9oHRrHEepJMCgo5ALvIMJ27h3Eup0zAnY75DH7HSlnzXdm L5v05tp+qRtu7AHJkdr8hVElj0MmY/Tom9kYI2n64c4Cg9Bm10JwbQ+FXrlpb38gdH8gtG9B ZQRBt0BJz6t8+26sntA8zZm+lZe0e1i0eVZC+tv73duv9907v5DoHU6sOB9IgSA9SIMp2Cxa arb9lU2VN2txPElH8kEzZbXNM5y+wgREzJRM66PmzZT5z3COHASHyDOcAATWFsNmgGDUEblj HKBe4PTEgHAIzJRd3VEzpSmrc4R+C9Kr3UwZNVPSTc2UaxNPlzvxdIp4mhUErkU8rR/6ihFP q/SdeDrHilm1TJ0nSAbraokV83TiaTNPV0E83UmlP+1TYXPE0wKuSDwtYJR42hYW4dwGvb9Q L6GwLvw6QL4S4PSWxYin3S8KT1vTfVpKyRhzW2Y50kNNAE04nYx0Q9ZIy26UeNr67cTTe2F7 YdHC4gDr8sTTV+I1ls0+HYx3vteYqqOeYZ+uXbzVaT9Za3mNOd8n2KeLBjNZ16l7DBnwllWH LASN3GNUWbU+kNtiwFtWnquiaOgPSs2mVGz8fKk1S3GvsU6wgpkOhtheFBGvsaGekKKhcu2J q3mNBWTXw88rrEiFieIiJJj0OpN6FT3v6dMsr7FcvmI/wXvkqsM0uU+fBnvUMYOutmpKLMVn fBU98+nTdU9BXwAWFLbIJrd7jR2ul3v6arBFJgF1IJpLsAWZedmC0Bj9E0piixkCalB05JYf I6A2B18FC15fG7bwdTnDRgYKDtBkhd2O/gnNYQstWMFMB0Ocgy1CYkoQJaZcBVtgn816+LmF QYDFKPOBEMaxxTBoSWzh8E1/DFvkklf7CUXsBI/QP/nYAizFFssTbgxbgO2xBQwEwC9sPfLq C2GLL8FOeXna66uBJ5nc18HKWAJP5Aw8kVF4AtpTAuYgaxPwZFHAXFGXGNICXxk8QaLBLMZ9 DWALLW/rjQLmhllKwRPpwxPpwJN+iNPwJJjBCZ6ABDxxmhZ9eCsLnoAc1YdgzdiyQAjn4AlI wZNVA+ZSvNnTIG4bMGf/Ie/RrpuFJ9MQbR0whwMBiMGTdXizLwVPbgJf7OzXDknxlbNfO9+X dVr9wYsF6g9NNpxUf2BC2ejKci34AsEWRN9QhzXjrNryYU9rlk5ivx6HeAG+CBJS+GJkkj4V X2QE5EPYuQ+FLdNCOIsvviT7tf2H8+CLviGUysijoJdQf+zs118WX1yaAfuK8AXZAF+QGXxB ooQ/bRJfsBl8AVu5BF+IJL5AjcByC/PKolj8FBf2Av3F2lzYM/iC+PiCOPiiH+I0vrD+UuuY 6KEwJCoijF/CNJceRW7NC1GJ8iR8YbqVgS9aVI0yHwhhEl8MpccggdeJj+ELwU4zr+Qcb8Pw Wgm4ANqZ5oTCjifgSkLImwh/eLJe7wurqZRXopJFVjchlUAJ6ZGmRmFUN0R4yTOmw+8DY1YG AhDiC960EN4wvjB7wXxUHAZzUXFbY43Lkwtu9ESoJjNr4k+EZvMK2mVVkSdC1b1Uisaj/Bnr IDO8ghMhp1NH/BlxCMScGkOmntyIwgyZfiK0JgV31RhWXy6kxlBXKobNC5ShGkPdMtGgPdtI jTHM0twTof5WFl7a/QvKEmQQyOQ0uFlPhMKySHADakHyd6YQTY312pu7RefXWYOIbLG3FDOf EU9xA/oJyW7COVVE0wpXFaES8p8IzVNFHDF6dS273idC9RBt/USorxMJJWE9bsALPBF6E1qI S1MDbokM1I0tgQzkYmQgEsigpRWUUWQgZ5CBjCIDEUMGOp1OMRJu7IjgjVovZQIZIA8ZdBRv ZEIZXgx8xWDPXuwjA3kxZDBj4IgoILZABmIxMggS0sggkLghTxoqjLPdZzmGDCaeL69lFSN5 yEBUZ3w8XDAWtCyWkOzm/nj47T0eXgVy5kuCRgayLXdksB4yWJvp4xwvfHwSpg/IiFyJ6aOF OMr0odN3pg9fr5B6rwAgUvMSue4RS9wvT2b66ObpKpg+Oqn0p30qbIbpQ/diNaYPVdiVMn3o ls0zfegvdqaPnekjmbAXthc2X1gcYF2e6WMLRc2oLOAxRU02yYdVVseB4ClqSopqdZvAEUWN qmMm0gVJV1Ez0kdETTgtiXqi0rrWWqKiqBOKmijJB0NpssIKERRR1Ji+XFBRU/dQzyMrVF2B YktPVGuWlptwhuGHkWiVxSYcWyanwc0y4SDSJrxJCQmfd4p1s6+3F5AFRB1Zippcoo5kN6t5 RU2UqOOiJpyuIbIsID8aajT9zqioyQumPdMBeLIk7IqanafjODzwZOdmeToSiyDiSFoWLjzQ sAUXsi7ZIWbHwXUEHhiow9XlmTjw4AocSVOPOqmrIWqFxwF2dkfSD/F0jEPs7jupQJUCenuh jnuxPEuZiFx6QeQMSGONMVMeT4eajfEvoRD6W5sr2klHUucVmiS0yHIkPZWnI+eo07zlsCjt poq2PacjaaM7FpvNRL3eF9s7knZDtLUj6Zfg6dg5M3bODDsdJCi9IIBzzqDtImfQNhFzYs6x looNoMIalF4Ilog2VZkDFVZ0+fgQZ8Y4xHlQwbR2uOGlOTOGT4dTNlTyu+evRWIRaCGObOGo AomYE96GjqRBdfHT/YtwZoRjlpUQa9nOmWH/ds6MK8EXl+fM2MibVB/JMOVNmkmXYe+NMW9S dVYI2kSNFKqOGW9SFHqTdkQMiTiTOboMXPJ8aKEd/5JxJqQWnB9CI4Xpy4WghT59uE/HVbWC CHVPK1s0+O9sSpdxWpyJzkwhirxJu9hIYcvkNLhZRgpQokSciRYkf2eKIigQeJNaLBV6VUDS YEK8pZgZZ5JLeZHs5u5NenvepEUgZ74krEd5cQEjxdcjrtguZKTlqUM+k7PCLitxyEuFS3n0 kCczhzyJhoy0yUM+yllRtVUNS3Uu08Qh74eMzHBWdAsJIVpGD3ly0ZCRuCcCbAmclvh2ISPt OUNGhk+OH/IBzUSuJ0KVCBmBpA15rcJDfqzXFarVPBFyeSeS3USzh7y64Hq8VnA/5N1DXusA Nj7ky9gh70jCerwTuydCHBlcnmbiSswL2VwTgVQvobTiM5RWPEppJatTPBHUoZCAB4souY3T pYBXZ16IcU1UbauWTvdK2ebwQM5RWnGf0oozGg6xu+9kmhfO+WJIQFzhSd1QGOIJ/YEWQn9r c0V7ixdDcnkqjlxBk9DiIy+GfHJK7su9GEICAQjNC2vxVOzmhRl8cXmyiqvBF5mMFYFoL8EX cgZfyCi+EDHKzI6xAs7YGAqSwBe+jWGGsaI7/BC8Pk/HJGUmUmMDPHxxdk/HYZZS+EL6+EJ6 +MIMcRpfWH9ZSpkZ4osATji9OMV9IRlEgYuQ7SKoLgoJ4p04FV/ksV2ccrxtT5kpNNN5WNhO men+qkAAYvhiHbaLnTLzLPQXZUh/UZ6B/iI0jtwk/QUXfZ4V6C9Igv6C7PQXoaojSX8BayYh vwT9Bbka+otOKv1pnwqbo78ga9JfkKulvyBH6S/ITn+x01/MJOyF7YXNFxYHWJenv7gS1U82 B0Yw3ksiV1A9w4FRu3hrZFdIPEY/7ZSO5wkpC9lgFuKt/gNP9dPTFcQjV4gCNgVHbAPVzyLT Eik7E1JE9WO7qW8RuWLNUipyRQtWMNPBEPtXwqjqx3+Mfnnkiv+XtGkpINQYfm5hkFYp01Lh vAFjqX4s2oyYtmblyJU4a8I0iPtrr2cyLU1DtHXkCggEYEFhN6L6+QqP0e8cHJ+SgwOIFJf6 Is8XdXY2NcYuRdcVwJM0G2oEnmwR/XI6B8c4xP62FS0MqfPMujWDhkgI7WNaDQBqQ7b1U+BJ NgcHEqNsBULob21eZzbwfDmVg2MLzxdTb58XEQSqkuDj77veDDy5nOfLF+Dg6FZ6hy/uX+W7 ylFTXd3VYAt0VmwRMqr72EKUvMaq6d/k+90L/ybv9M599619untBj6obJdb4rZ6HF3RhcO3A 2uk7vrRFURwsa5OdnoIXvEUjvBjzSIoZRSG80A4mk/AGji8t5rHgWpVejXE3iYUQgRcgxdsR WJtUVXpmUnE3Yx9da5OVbkMCnWhrUsqwngS8WIfiC8GCgiztx7oUX2aWQngBUYOI6nlwZPSG eThGu4BAfnzthxIe1JSycPfSVgE24MlrWxwrzBbTYE6dwkrbtOXOrotVurm1d79KsjJdmCd2 B9fxxaH4GofI/U+nOljXpZCxAwk1LasHIwwWY0OGKVKXwBIBAIL6Y+onpMAhpV695ezpFi3M ngCndO4ed2aUjo9ZN7yMOC0TTIRv0RfBjIRCmxyRsLB0y5KfBr0ap9dqO284QRE509I+Tnyk qd5ARCdgmCO/ZYMOr/JbVgZ7a143uwSnZXUd9DtdGErqdKLzzavGLsyd5yqS1ykaVnNy5rUD hjMy/o2XrKgXBIs1/nhLeXTMfKHtVk8JqLsnUCacl6bCLziFMGHTNOPtj8iYN95UxuxD4zg2 XQiAAoCpt1jt+sRfdIa7b/zu/dlkx3cP8od8eNPosdRlyBR8NPumKuNHF3T2KrlQmagGkI4n gJ/JBKq5mcBsHrMdqTyqn9oz69uPobG6nxoXt6mcZjMwsFj7eDXPLxq5o0KjYpz06jKroXML k4/fH+5+fb1/16C90UMKk3UZkVHZNNrV+bjJpASamItCk4ThRpKs+hSCf7l/1g2tdDuTNwxY AxbU1zDAjtRXCkahGZTHZ3Hf/v3uz//17p/+9c//sXd5gwjqAopkdlkCHTMon0QnKnf3z2Yu ++xSBw2i5MWIIIJ17e3D97efzfz//U4+3+srjq43KW0VJUyYVr89vtzpBXLXfn8yCts7fZN4 ff3+oi9KRKhSknpfog5P3l2s/vzXf9NjXOt7XJmstqgx1LPKH4Xq5+Pj97uu4arKV/nI9ZUJ G7VvskZGiLAWqrn9zV4dRUkRMT3VefSafFdXkzuFW9UdUq8wXR8qZwZKoIyB4mjVgeK0gEXv TNmL493zk+6uKGbXDSqZrPUICzFdruu5ttW4KpnZvJ70zfXx0awWouUeoWSmSuH+KdPruxLY 537rKZKDWZO21YPZ/CybX+6+vwjdLWM00B1D81udxAz1I2JmUvuemczDzTy9BTUtoH1WvUU/ qZxS9Bs9//6g5w+bra9IjtKJ20pTlpXe1d+0U+yj/O3+/a4bMt1jdZbpLtPkePGGoKZvuKrw Vb59N91Fzaz6oqTdntI8KwH97f3u7df79+ZnvZsQvZuIFYUHKaysh/ZNTan43mljKj2SJLkg a1kK3amX90ECuq2u61SqbUjhIlKbjZLXSuL0jnH36/2TeP5V5zUDietUlU3VkOmYDB2TETFN TmUvEeTzns1Gf5UUwLotUd1LgWk4f3u7f3sfRje9zJqK0LbP+Pb+7f7ugdfyQe9aWljZcb2S 67MMf/oBNniyD3QKpgGzUUAkZa084rMMtT/IpD/68XjMWbmLHaqtdFWLaFlonaK8JAp5jxYl W31UI9BI5tO29HnIpD5y66gc9ZFbFjLqq7cgHZj0heqjlPNM3FnZKstXH415cCK9mCmrjObx 1UcwYZ0CgLSDrDrcbIMi4xAwxDv199YprZmS0z/n1EejdQpM6qP4Erk8X/KGfIZVnOoomyrZ ygNijy6RosVtwetDzKIryxmq5DrKZ5h4dGmeKpnQRVTJTZrqiPOK1Qfbomv15XAZiy5CsMEV iKhcQVtBVm356JI1S2d+HbufqZSp0/6NX+CAkDjaEEibhNOYFiQb6qT5DFuf6ijd1IiouGMW 8hnG6Y79hGQ38bxVtvKtstV1PLokKC3kVTy6pIZoa6qjUH3oS8J6dMc71VEcGVye6fhKHL6y 6Y4DqV5CRYBmqAhQSEWADZHuKVRHZYqKYLHDV9UU1+aPnoYHCIjAIrsR3XGaigD5VASI0XCI 3X0ncPjqmI1ojWacbwPa4TEhakTNgBY5VEeV5GNDAiH0t7aZltlngMMekIQWWQ5fuVTJfkLc tzqTKjnYo+LnpoEWfV4EoWjLqlnR4atsjndzA4evTKrkNbFGEQiAX9h6VMlf5dGly7MibseX rO42Cb7kTEJEu6wYXzIp2hI3oI2iBD7Dl8yjfMnS5ktOyHOAEkp1nMRRAm7zUYL+CVFiEXu5 2fTlQigheBRhOkdBo+fXQQn5UWv9P08jRJxXItire4o8i123+9+pfMnyJL5kUjdOgiNI/s4U gqGx3qlXDg+hfvyz5A1lyFuKmY8iWIVVqjs1oBWk0EngTJTRe3/dsLKh9qe0BW7eKWHKYhtD ZFuxtiRYENaqZiPvU48nqBqgli6dN7zWpbst6/5SYyYKb+IZaQ4NoIgV6hSmgEAocdDv+GyW U8taF7d1eXFbqtW8RIkw9EYC0nDu+fidXYkQVaM5YrUeqeElHkX4WNDZV2M2FGUN0YyLU40y fLwZWqxRCLCCYVqzfLztb2FLRVyjoL1HOY5qFDAPH1By3W0drGDqj/h4d+kn+XhnG+naiI+3 3+YBK8T6GDHS4bGs0i6r83FfQ6MwQ26YG+G+Nrlh1McbjYPujdBpPt4la3FBUoWNcny6j7eZ U6cwx8db/xnEDoT2qI93UFg76+PtkBsmBvEUH+8Cjg3pq+vdhBEI6o+hmN7He2pCjo93pLC1 fbxNr5b5eA8DERSWHpGwsHTLkp8GvRp+q/h4uwMRnYBhjvyWndnH27RsLR/v2HwnfLy7ea78 vNhvCGT5sxnx8XZKpzTfSjbn450asyv08e5GdbGP9yIA5GW/nI/37q8dvTuc6q+92BW3otw4 790//eAP953DouX4i7UHX7VabZs7OH9OT+MbdvmtzPz7Lr/QeOLvPr9LfH4Fm/P5xWzW57cl ZuGGLrsI8FmBPUmx8EFH3yp09IVncPT1tQwg4uhLtWfHrBLBCxTPcPQdvRICzBA4+lagEhMb XeiVUEBfh2DyNDJ09AVlQeqisXUIw98Mizilow7BTScn0NB8ckff/jYb6BDc+ld19P0Q2zcI 2b7PsaCAt6BulO2bFQSuxPatVl2U7Vun72zf/5LN9k0VIiAXYPvu5ukq2L47qfSnfSpshu1b 92I1tm9V2JWyfeuWzbN96y92tu+d7TuZsBe2FzZfWBxgXZ5Oc7u4qxan4q4ymTStPCgWd1UB IQlC5cE3g5o6ZuKuSDTuCiXirlrCeDruSu34iStMJO4qRfRtfrQCUA5Qy+/LALUsNcFmT8wb 7p3ADEqRmsft467QNnFXeqaWxl2hjLgrNTUs3jItSFbL0nFXyIu7mmvq4rirXDbMZDereedo nw0T1tcRdyXLgoamzEvEXcE8Nsw1zywYWwGOJKzHhrnHXcWRwaXJMLdEBqhMIQO+GBnABDJo gejCpwJkwGeQAY8iA5hEBmIGGaDeAToTGbAkMiCwrHunaR8Z8Ishg8CZeupdRAmzBTKA50QG wydpIBDI5DS4Wc7UoKoSL7hqQcpCBjBABnlhU5nIIO+F+GQ3yTwyiIZNXRQZ9E2N82RfAhnk hU2tiQxCOfMlwYRN4WZHBmdDBpfnarmSiOxswpZAqpc8wSFnnuCQ0Sc4QOKFsHnCFqgmZAFh S5t4IUxBHV4Jgh14cPmI7MBGM+xjQC0shEY3ki1eCLNmKfUEh/Sf4JDWExzjELv7zhW8EDay sPiS7RYGSZN4gkMLob+1uaK9zQthcbKXaRAv90JYOGZZCbGWXeMTHNMQbf1CGA4EwC9sPbKX /YWwnTDm7PDkcxHGEFol4MkiwpgKNBVVV7sN4MmiJzzS4V0IMQBy4Mm6T3icThgzDrG/bUXh Sa2DWYbCkKiIMK9zTnuxF4djfPtEGdnp8+BJBmEMrDkdZSsQwll4kiKM8TrxUXhyGmFMzuk4 DK+VoOBOU6161E4JWKEpBkofUczV631hNZUqVFzJIqubkEogsDzS1CgK64YIB15P5zXsfwXC GLMXzDM8YzDH8Lw11ijPijXK6zGSIAFbnmKcIYsZZ9oY40wFJER6Q43BDDLDOEOijDNtlaKt ZWktiLoCLTKS1CkjCQK0IZAfQiOJ6cuFtCBJxhlUQFRM1NwbGUmGWTrKODNKjXPDtJX2fXSg fmLwFCPJKJPT4OYxzpS4dhIcQfJ3phBNjfW6QrWakUSwD7pPFLNGkvhjoruRxB2irY0kZSBn viQYxhkIb9JIcv3viF6eh+5qNBCZZHSBRC/RQPAZDQQPNRAdzVnCQGIFrQUaiJ6sJgINUAwa 8LSBRMiqvDoDCSmZIW/xoAEioilaLLaHBnJOA8F9DQR3NBD9ELt7TuyN8o7yzd1DcSMGXzxr x/GynEZZGzDbDT+vsAIkKGu1EPpb20zLJoHk0rFpJGFFlgbCoS+bfkcTPASUhBXQhxVHDCTD p4WSsMm6pfOKFlGWwTJ7MwaSaYi2pqwlgQCEGoi1iOz2N8qvlL/uirCF3ABbyBlsIaPYQsSw hU6nE6FrJPCclQlsgT1s0ZHKkUmF4WGLsm3YFthinQfK9SySciAb3JK8bgZbSB9bSBdbdEOc xhb29KncwE8YD2wkKiYisYgxgqwsbCFysAWmCesGGMjrEthCpK0bznPYH8UWLGzZSsp1CsoS FqXdVNG257VuCBZjdUvV632xvXWjG6KtrRtVIAAxbCHb8naxxfmhwoeoNkhItVGegWoj1F7c JNUGZESuRLXBChGl2tDpO9WGr6VIUm2gStVwCaqNbp6ugmqjk0p/2qfCZqg2dC9Wo9pQhV0p 1YZu2TzVhv5ip9rYqTaSCXthe2HzhcUBFjir5mbUuVzYV2RUHPB4QC0i+b4iXVksGlDb1BDV MPY6kapjJmIGSddXZKgjFVA7wXlLaVO1tJG8JCjlkkoCpQ0oJK6mstyAWkhJzRpHaWP1ZUWl zRq+IpcwCFmztCig1h1+Fka9LNGzBDI5DW5eQG3LiZswjjRojvmK2PX2vTJGHWkXFmvqkieO ZdCyWEKym3DOqNO0wjXqqIR8X5FoQ5Zs5lPLrtdXRA/R1r4ioUl0uSRcr6/IbUSsXJ6E60ps OtlMXIFkLgmoJTPwgEQDalEioHaeiUsdxQl4EA2obVL+Ig1nsMbl4fw2nYVMXAL3miBPE1O0 9EJMXOmAWuIH1BI7oHYYYnffSdl0TGuDBH/X8SY38YZQAmsMX+CBXsuvzisM4vEvoRD6W5sr 2kl/ESfIJAktsmw6uSxewSYR03ZE/EUq31+kWvjE8eKWHfMX6RtCaR1h8Qr2A382rU+PQouZ brpDtLW/CAwEILTprMXidSmbzk3gi8tTeV0Nvsjk8wpEewm+4DP4gkfxBWxPiogtUvhiWURs wyvVjnoDfLFKRKxEpdj+wcNhllL4gvv4grv4ohviNL6w/rJxRCzMIeyQPB7mYoRwDl/AFL5Y NSI2lwvslONt+4hYWSHQhIXtEbHuDwUCEMMX63CB7RGxOznYUqzxmcjBOEvFviwjB2u4foN+ C/aNRbEvmDPMgIs1qrZRmyejmVhjXV3GB8jBhiHOwhq55GBO006MfcGZ5GANH++/oRDOYY2d HOw8uoy+IZePfZmGaCcHWx9r7ORgW5CDbcdqriYsQdiRyQtmb61Rwo6mxo1gMIJMVB0zhB0o JOwwdaQIO8oZZCIgzkcmc6zm6irbMheZWH25EDKZsbIgOwRvOysLOEbY4e9+iZMy6oQRSNyQ Jw9dxKNynYZAgbCT4AiSvzPNtMwVqhWdMPK4vZLdvDlW8/69E9jELCXJwj4Vq3kRyJkvCetx e+1OGHFkcHkqrytRXGTzeQVSvSSwlswE1pJoYG17Em0o4G0CHiw1kgjYAPc5tCtQXKTDYTC2 xmVTPq90YC3xA2sJo+EQu/tOgrSjHUk7TNQAaIiE0IYWPWnHMB7D4XCK4iIgB/Okbrzqtglo oYXQ39q8zsQVF7lcYFmKi1wusCOnUwpaxLnAMhUXpt4+LyIIVCXBx/0mbkZxsYwLbE2sUQYC ECou1uIC20k7dtKO6feJSTvUYSUb3nBaJLCFTwg2T9rRVAjrxx6vDFuQipm78sExiggicCXL Fg2h0dthiw+QdgxDnIUtRB7P6FrYIou0oywmmXe+K04l7ViZEOw00o6dEGw1bLE9IdgXIO24 QmzxIZYPHLJ8wDOwfIR+GjfJ8sFFn+fjLB+8qKMsHzp9Z/nIUWtULQOwQbW1eWzI8tHN01Ww fHRS6U/7VNgMy4fuxWosH6qwKMuHW11Fw246QzQVhlMhBKe0LMby4WSQPOTl6s5lWFpekOpi zOjkdBm6pgy1RFp2oywfnSSWTQVRk1r6zgTsLB97YV+usDjAujzLx5WoerKpPoLxXuL/iuoZ qo/axVsjiUQilnfOywRgmFD1lIGqJ0n1UanjqQEclDcTa6OkAUKQhbfWirWxZinl/6oFK5jp YIj9K6BX2PaxNgFvyPBzC4MYyFHmAyH0b5quaG/z+lweOcQpm/DmsTZqv6Qows+6x9r4Cb4A LCjsNlQ9txdrs/OGfEreEEjrBNZYFGtDad0wIcQGWONDLivDtZ1g0ba8cHlDluh2tucNGYc4 C2vkxtoMIzgc06dgjUzeEFjAcpT5QAjjWOMob8iKsTYp3pBpEC8XaxOOWVbCrZiVpiHaOtbm K/CGfIVYm8vTjmwXa4PKeKxNNuOIlQfGCE/VtRaRFssoMuHlDONIHYu1gUnCUxEjPO1/VOS+ UjP/OK5CB7IpCweZWH25EDJRqwMXtsNLf8pc6AW8YZaOPo6bQBc0ii6iMMelAHGObPtnowsY jwIefh26gKBxEhxB8nemmZbZ50Ge00p0zPxYm1zWkGQ30QlOK5kWxC/yOG6e08qaACyUM18S 1mMNuUCszVcAFnsQ74pBvApY4BJ1rikXC+It6hST+sIgXnUX5Hx0Z/H7ciFgkWJSV83iCnXg KwzidaUGODoQClG4NRbhHp3GEYFMToObx6SuHbOdBFuQsoDFHsR7WstuBFjsQbyrA4svFo+L MG910+9+fb1/141vflGNd9q+mk1jPOC9ZOwf8FW/OhbaNFr9TERwwEuKGZ18OZ0Dvv+bf8Cb WMWGpcJwcfKA79s1F4abWBK+5mDsi33Am3YJ5PirRssqgzzFGpqD5Pu2CNsKzO3etzWzFD/g RcmAfSTAuqkAcHAPa+TcLj5tb97Dr+P0eFlRSuiSR4L1s9uuRrkMdnEY7SanEI4BCoVbGO5j eoXlvjr8IjjGPLIS2bSHhKr/32Ks3zgWcIqDMZte/E0OYrK6EMckA5PtgWjKspLuIBLUhIVh 540cu2VB29MtSzak/28SyopfXVTOoqHLtg4pYlSiJWijooFKJmtnELke76Awp7LJgz7oJlrP GwYKAcJ+J2Sl0wrXsI04sAzlzQ1Rf8GxR0YdX75Vr3eOkKVoZicAVoBMa5MyUIO2TO0aBXVi 8dQW1JCk4HXRkyAQjdFtA/IF66tGVAjCfbjWF9aWqA7Xl9VNhemKcFRjhUWG17aiplpWH1Or niRnecgyA/T4WcxxYnDhN/l+9619untXkOdO7dQKXmq4R7TyCCXzmy2997r5mb/cPck3Bdru Xvg3edfy7w865IrXWv+UhKZmq++KkI/fHzRAfbl/1pi2+oP22UlkMxujyvam/X0e5W/376oB Twqpvqqsbat7DelMu9Uu2rdbVfgq374/GhzdzIaHmV1JZWueFTb97f3u7df79+ZnM04af4s2 ib/1pqXRuxCTiVKPSxqx68Ws+9f8LMX3DuRXOniNJI2aZpWrLC/vd99fhELevd9T16lU27ql r7LJJ14roK9g9+vdr/dP4vlXndcMJK5TVeqlr/L+6G4zoc8VIqbJqex69c87bRlDbtJpy6z4 XgpMw/nb2/3b+zC6CK16IWoqQtu+trf3b/d3D7yWDyqbnpeCHb8UueF78Kcf4Azhe/7tCHS3 o3FvB0SqTbA5Er7nXYR+PB6L20veg1KKzhHX59yD1KVZFoyN96ApnQgiuHMPGv427MjDPchN 503iHpS2oILV7kFTHpxIP3IPiuTx70EwcQ9SOK4dZNVRdALeIoNd/XuQW3+v6MTjPcj8c+4e NCo6wXQPii8Rcla9Qfh8/dU6RULAN+Da4DNcGzzKtSFP4vFSIOvYwvGRV7hwjMeeZKSAjgLh CpwiiUJRCEQVCLzk/sLZgGtDznFtcJ9rgzMaDrG9KJJcG3Lk8RomupGVE9WwKteGzOHaKAAf ZSsQwhScL4bS4/blFR9TE+y0x062eEzN1NvnRYXEUqzK41VmEHd8zsfUSCAAfmGGx0uJ6M06 RV4h18bV8Xht5HigeYNkyvEgk8LLLivheECgJLEn3FUdM44HMnQ86MihQseDOQovynHDWZt6 Q20BhZf5NQNtauB4IC/IHu55NI45YCPB5m+0DrN0ZvZwY3alIHXepqCByGEPJzTh0Qhh+A5a FPCIwPEg3dTFjge5NFzJblbzjgc+xSesL+140LOHl4VeZdmFndHxII/ic00VbxVbAY4krEfD tbOH9/9am4XrHGq8T8LCxQoC12LhalmchUul7yxcvlIizsKVIACNezXE0cPpLFxmnq6ChauT Sn/ap8LmWLhUL9Zj4WpZlIXLFhYBCQi72f+FegnFlCA0p3lptX1xy2IsXO4Xvr25+7SUkjHm tgxMl3+o2bCIOmwz9EK3zMLVNYRTL2Fn4doL2wubAVg7C9ftsnA1Ad4yb7FSShimPKGtoYeI EYihmPW0almJACWeF+nljUBBmIglDbwCnhEoH2/1/9yUhWscYvcamMnCdcyFi6oDFRbnZeGq aOIV2rJ2+D6WsHC5fp52Uxcbgc7JwjUMr9VUoU7787FwoUJwwWOzmajX+2J7Fq5uiHYWrtWN QLfIwhUoc9AZlDkhHZdR5uiZ1ZrVumRFVXFyzCcLLVHmmHCTRl2cCXVcs8b0ijngYkwvxyui pcyZ/maDi6kO4rhm2XXb4ML5W41HU5CTXmDHw2RIt1ZMzDXrqIcJbtvYkrKUOUMfeUSZY37Y VubYM+Mrc7w8H1XmYFy2tR+iUrVQnVWUtOBkcLFYmePPk7UDFYCJAnFakJoWpRIt1RlRQlnL hqMGQ9F9UZZVrYS9VpjIfIE5LkjRSIjr0iuMybKtKBesQuZTdQAzWKGalXWhEjCFFIrB2WOY QlAXjWqAT1zuCIRpWaWaQmtKasJ0Ycz/olFlNG1JWolsp27cSop4ySQVuBWSm08RbBguKoyq lusvipZDBaA4rEDRfQGbkpdUFiWtuN1Nwhq7Xl9GdWF+QlSKu8K49QdoEsiUgELJxOYx9Fhh /l/MeJeFlGrLKyqAiE6oOGwqZH3hJHgt47VoOBYCV8IkIDXmApe4YKU0CZgDggtRyKKo/bbP F4aVSOGWAq4EkMBY6W7b3cK8eoNeuQ051k1/zBwZPfqFKxrS/xR5LXOFx5ditzDufUp4S2gx JeiWMV7VoqJ1baaXMmqe1YZqiGqvZQTXAjZErba6+1RtCawRmBRqRoD3+xCKOtp2u2WAenkB okWdYuSdbRluuZIf69NgbS4srGgr3sKK1DWlel23LUe1LAiVvFnkZdX4vfpYy7zdKtjg9Pfj nj8882Af4rPKnJ1HbEUeMXUxr9Rmh6J6nFV5xGYYTiuc4hGL0n3wNI8YKApUOXqcy/OIpfU4 EPMCXiOP2NHVPuN1M3ySVr0EMjkNbhbdB+Sp/VcLkn/1i6qrfB4xLVSred18mEesnHfIbX2H 3PZKvG701FyF140aop1H7At43VwdEdiVmHmy2cACqV4S64NmYn1QGOvT8UydEOsDO7eeCR4Y 2KLOVObSjB6J9VF5iGwJOdyAmedy7+oOs5SK9UF+rA9iNBxid99pF+20/q4TnMqnmHkCajFP 6obCIBovvKEQ+lubK9oJM08uk1immSePScxPiJN5ZzKJZdg/shtyeqzPpQnQlzGJrYk1ikAA /MLWYxK7lJnnJvDFpTnIQCFbPT1mhOSTuHv7+fu7eP716U7IVr6+cs0coGcJzaMMhhajDOih jOkVqTjKGFZiDGXgBMqAHsoY6/DtPc7aiFGSFU3gTGLSUZtGGX1fMpQQ5nm0umojKMMra1JC QCXfJQJ5lGSR+s/5pJuO0c+x96xNSaZmKa6E4FVRiHHmxhG1uqmpogJqMH/3t2fDzqgEC3jz Mn3RHxk1CI7frtFlldasDk31nYpjbKjDX9zS6zoM0525aQYNcQpjhLqj2vA2GNVEN1kYPjON t/pQmkH0v4ggM2e8u4ZUvJblsVOvSbih6ldyjo6ZHZaNSkCp382uIZQJRoJPnTEzrHF+U6MA VDrdjDeVMeomzFHf2U4sJYsMEaK+4IVyFjot6cKKGvgTQL2WNQl6LQZrwEZApCvGbCD+mqOg i4ApWraRXvlSzKE/Zjw1ZrBy8nJguZENQxSMWerV52jL9PfTfzIbREJIwzHrG1IVwro19exl zkDYW1BkzI41pHUawnSwjVt/G95N4g1xXoZMDoTTMqshbe2OiEQOQwJRdfKg/kUQdTkG8ksw p4tLD2bYwTAVKluVZvjS+6eVz3CijUxdSTasbrtT+VSu5kUDaVjONc9sSupzjR91PdxUUtSM GPjdJIHtibRnZkEH9TUMsCP1mcnsIPuf//pvup5aj3spkwNBuaHWun/6wR/uOzoxhYZfX7+/ 6OB+rPm1qmRtjBA9a5pVTpPBmTvF7IVElBTNMdHReSI6UTaYWRXeaRBjinlBj3oWhR4gNMNC V8Cid1zrx/Xu+Um3WxSz8rKc2a3GVamb2tHV3T0+mmknbJavrK6aBkyZXt+bbhnoe1qRHJVa Yob6Xplh1Z49Rgk9XLzSzGqaV7bP+hsyyuvHt9dxGYG5S5umsqBHWAFxSXdawCumBdQCINgc tR9mO7XfDLUfvBC1n4Jz826kYDm136hPGBLGp56j+oRiTp8QWC3Gt5g9ar/BwzumTzD1NxOV iJteF4elVguQ1Cd8Dmo/gHmUSsSt/7zUfoGnNT7DEgk5/kZP6+5XiEZKeMTTGpwaNh+SYGqn qT48fKHmDdorpWoZUJs1bARC/kpRMBQTMbnZOJq3/m/2SukeIqjbpmqX2/eAb9/z0qHVXkkk w0V8pWiH7qJKrZQisVJweqU0PLJSlmvemibQvJm+1EaXv72ndT9PsbD5QbSsbommrZuZL2AF JYwG2AzzYRcmKc1wL0pcfCvsG1oaHk6zl2C7jOCuEFA0qGDEqhdjzKhN8R58oS9CFXbDmXVx hf5L/2n3SapXjV06EwWOaQX70Qw+nZmAvu2RwuxOdKunkJCVi1xDneQPT4DdCTxpUrEWjQII 0g3iVF1jEiDt/sOnuWuESm2HcZ+TUdw2oszqJqyalkhvAhC3e1XJunH8nFSWuox6YFWSE+6u AMZ44DfPg+pyWhYIbSA8/TDnFBYk6Laj0k/A8THDrHSehS4wRtxmRagEoaIYJXH4xQqTgDa1 u0mUhXQfG2gdltC+/oTQ1rxxOyEbr1eypd6cFfHZnDph/QY2hn5nrR0DQYEq1Ei3MD0ACJXl SPQV5B0TeFl4TY0oP2P6yrJioFeym+pgC0XFkysgDrAuz294Nf5UmSSH/vD6NxM7PSQ5nPGn klHuZHGaP1Xt3UyM407LK8gPh4X+VHXTHg7X70/VzRSBnJKLkBym/amk708lfX8qPcT2okhy J4sId7Lg9hivyp0scvypEBkDSUIh9FUsXmdS/lR5BIlZ/lS5BIl+gsexZwrMJkgM9qjQNlZo Rs7xvW6dV7SIsgy645vzp8ojSMxFqLFPg8kLBMAvbD2CxJ07eRWGRBSqeqozqHrC4K+bZEiE jMiVGBLrqooyJOr0nSHxXzIYEru/tKQokQs9zqjq8efpKhgSO6n0p30qbIYhUfdiNYZEVdiV MiTqls0zJOovdobEBEOi/UstfWcCroohMX7w7cx1t8tcV0cinmld0woaYogjJg+rDlkIGr2C cwhbTHl9ZVfw4BwcNzDE1d18rH+LK/hHmevGIfahuVfY4H4hLH86dYuj0y1u7ZCmfOa6xPNF BIXR0q5obxPSdBpz3R7SdMMhTV+Buc7sBSp3F6HdX6nvePN+//yk78lQZ0dNKvtNRETBs8KT kOPuiuEJySNkCaR7CTwhNA1PCI1FXKMkPGExQhZ13glE27aoEvAk/gwSruLwBEhc46rYAJ4s 8shoGt743He9NOQS664YCzXMUgqeaMEKZjoY4ix4spRYN4QnARpxehEjczlybCDSjAxb7qdq ZactBEN1UaX+msS6XNZBy7ISMg607Yl124rTJgY2d2Jd+wcDAQgtBDVAgN+uheD2iHXxWbFG +DjSJXnfYJXifZOLed9AjPeNQ1TQrlUhzJAzvG8yyvsGErxvUMlZHGYgocZV0kyYYa4JdZL3 rVB/Zy6xi9WXC2lBUsQu6lrACQUezNiE2GUx75v5oovzjGsyliguApmcBjeL901BBewkDD/I yzqAClE0BTzeNy4FyIEK0THzed9oK/yWBU0FYKabaFaTAaDP+wYvzfvWNzWuyUgWdkbeN7g5 7xsO5MyXhI6cRe68b2fkfdvk/cSQAM7zDoCoKik44h3ABsp9eDjiHTBtndqbE7h4QAk8bgtQ 9q8f23igzxR4BzhinKN26OugcnqDx/IO6IL/pfS9A/p05uKBSFnM+Rvo2COPULAkVlAkZApR Gw84B1E8EGQMnMkMmTrh9WVQIxDggUu9nzjOk48Ixj9xGszd3MEAEaspSxXWRAqzjztRFSCY qmNniN+QsboWOHZ0xAlJ86YE/vh+YdQuDNe1hJFu9mVNn45NtQurUZF5VELVbBBuAl7WUcc/ sjAkJqCNPIgc4o10y6bCEGFl5DDzquPumEkIeVAYallLGZURrhmrZepUd/w1tCMD9pQ1zqdB y44mnMn8sxe2F3ZbhcUB1qWJ767GzAMB2SAQhMwEgpBoIEh7UiCI2sgTeGv0xpwmIR0IwkHb 8Jagw5WZedKUd2Ub6F/ObuYZZikVCEL8QBDCaDjE9qJIE+uq3MBPGG0nSFRExHwuIpfs4WhN e6FkEH6ZzwBJ0GppIbR6FQSCtKlAkJ5/MtrUEwJBzmfmGaktpgTNT3FOM08tChkWlqzX+2J7 M083RFubecpAAEIzD29aBcRv18yztS6GnBUqhFwcF7PSqK1JXWGjVhoIeB5KsMuq4laaimDU RFECJ2mUwJvASmPqSFlpRMJKg4uS10AmUELESsPV2Z200mAdUnAIrTSmLyuihEVaGdFgZltp hqspEU3R4q1f5xlm6fKv84wyOQ1uppWmjlNg4ELIDCvNWK8rVKtZaQT74Os8jm7Ct9I0rXCt NCrh0laa3jiihuMqXufRQ7S1lcZ3fA0lwZz0AO9WmrMhg8uzSWyHDNT9KoEMMokk7LISyICC pmZRZCBnkIGMIgMRQwY6XYcSR5EBggVtMM9EBp2bKJlQhmevEZrsIIoM5OWQQcxe0/0FF9Xm 7/YNs3QuZDDti3OP4TlQYRyPgK4h2hDISeMkjD8icB4yENUZ3+3LJYNIdvN23+27DmRwiXf7 qtgKcCRhPTKIHRn0//oQFwQMvT3IGbw9wuCTm+SC4KLP83EuiKKBUS4Inb5zQfxLBheEIWFs UG3tHRtyQXTzdBVcEJ1U+tM+FTbDBaF7sRoXhCrsSrkgdMvmuSD0Fx/gguD0i3BBiNTSdybg qrggVkE21+9ssBd24cLiAAuEAOscTw+MCpcUwMKoZg06BrDwIoCFKkhJixmoQl717gd99czw vQ+whl9RNQ6v+vQjhQ2whl9ZjSS6jjutjrutuHTVM2P69KKh115hA6xh8NSRSSjmIcAaBGKB O63uf0H5yPMZGy/fndbu47ncaQWLhdfIsoLQfjVyM3faYZ4i7rSICEZrAtwEamMDymAjeRl8 ESnM1NM64EytlCEEZviihsAWB8MOnUQe/h2blF5hlVcYDi7OyU85CIAldLM0xHfwGAuLkHYn BzFSWFDvfENq4bW94XWiZQqNhdNrRHl0BR5cbqwsqW42kV6l+20KixOO9/UO3dP/T8rKH29o C0/BAOZeUHC8E/HxDvnkfd2dPWbul9QvrPBappBsYjmFqyd0rC5zJ6CpnYkvWgmIL1bdF2BU fJWptTmIhtnWzOfl0aambwVTJ5LdnHsJNT15VVHjYDYH+qJ+INSmTGOFmU+hnk2vsKBlfnUz LTvWK7up2DAXpFqGvU4g1thqxtLhB5gZs2CIhrxuddSuDtawaeYBFjqrJSwkMb1ad1p1C92A NYXPsKbwKGsKTLKmiARrimzqEtM2gbeWsaYI1CrgAQ+Hs7vTfshRZuodoRaD03bhzHCONYX7 rCncZk0ZhtheFGl3WtNaqzAKgftM8DFSt9b7ubJ2AmsKkGXCnZYLhwsmYE2BKdaU3FDowIIW LyzPyeYIcjAFZodCB3tUfDbzTGkzEzC17IpJ3TJDoddUM6BAAPzCTCg0bm7YnfY67WlXx5Ry Nfgiky4lEO0l+ELO4AsZxRcggS8SdClDD4FI4IsxPNpegG3UEdccfnUr22t7tyWKL1bR53yA LiWNL6SPL6SLL7ohTuMLe3vwSGP1lX2ONLaf85PCdQLuleHnFdbCwcACQiGcwxcgjS9asBq+ SFGtTIOYCFI+gi/6BOCZGPmOL/wx0/gCeHnPjC9wIABRfLEK1cpOGntOupZzwpOQpeVq4QkE aINoYjQTTYzCaGK9h1cpeBLltB96WKbMTRF4oh03k/BE1hKM/jzB+XAlnPbTTEWiiTdhc5uL JkZ+NDFiNBxif9vKgidqJM7GaW+6lQFPJBnpTkIh9Lc2V7STnPZ5nsSZ8KQJWpaTUEaP2kxP 4kx4ktWQ24UnyzyJ14QnRSAAcXhCd3hy1fDk8mQn28UpqU0vEaeUyXNilxWNUxK4rNVBFUUm ZCZOiUTjlNpkBDObQSYUpujso4qTJhnBDKoSMJfO3urLxRQnUUeYBK/cFnFK7aYRzEFCEl2E bCLxhsiKuQnj7MAqQBchABvXgitUOegiOmZhnFIeV0mym3geXVQ+uqiuI05JUFqFVHEXiVOq No9TKgM58yVhPa6SPU4pjgwuz21yNYqLTIKTQKqXKC74jOKCR2nQ5Ek0aLhECXiwjAZN7eCQ t1f3GB8pGbDDmPt9DBEs2pYXFyE4SSsuuK+44I7ioh9id98JFBcjjYi7j+JG9dceY/NKtpcl Bg+yoIXMUVwUIAEttBD6W9tMy6YzgBrt00qKi1xyFD/BcwZOQQtY+4/x1bviwlVcqCHaWnFB AgEIFRdrkaNcSHHRrfQOX9y/yneVo6a6uqvBFjs7yprsKAKTVkAUhRVbsKPIilPZ5PKmHWNH aQiXZVTrcFF2FIj7+GrPHsJISfAnZkdxbt9Z0CCHHUW1Mv66DYBVG0CDKOAJ2VHSTd2eHaWY 1zr40MAwvF6D1qEB16J1yIMGa6KnnR3lAsjgQ+wokeDd4hLBu7fBjsIKAldiRyGERdlRdPrO juIrJdLeFBH0sMTZ82R2lG6eroIdpZNKf9qnwmbYUXQvVmNHUYVdKTuKbtk8O4r+YmdH2dlR kgl7YXth84XFAVaEfu4cjw0ep58TFNHiCMAqBoB19LFBbwigD7AKiaWougf6mild30tajCeH CeHnIfWonnHLql1ae6uOGMDqyuIBwDLpZRM8Nui3y3pssC8Lpx4bXMSO0g9XBGBZZYWPDZ7C jrIIYPlWH6upVc3F1uwo4zylAJbmOQjGIRAYJ4EWRVhYN7cFDSd7+GJYQoGYRvXxRojslsHC u+t2CW6W6qi2Z1HCBwqb44ZIfTqFFrtD1NDUUj34i6umwVwdb2qisKq0kZ7a94rYQzHOBBTJ MSu8emHV8m0n4HIH3zBEhSfFHU1My0PelmnbTxXWTy/ypohR/2HkiCSgoGVISsy9KTJNDddm FycXPmaEgrxevwNrcaLezEFM7BrFZAtOuKp7hZnOZM8m8icA06AzQWHjPCclId3v1GxW7sQz yPxdenp3VF2tQCNRNZie4wBrZ0f5XOwow+TLOoG3ok648WeEqrZmsNCcPofD2b1s1nlsUBs1 STmw9G302OCH2FHGIbYXRTI8qC4RGAub3hac5tJ7p294DS/c6hxgZv/GLwK6lOHnFdbKlClN Or5D+ewoqz42eCo7Ss7xsPljg0UpIImAyv2xQff3FdhRzF6gcv/847EzqP3M3+5e5JNQR/td ZybDugR2LV43l2dK2cjrRu9tVdzrJpskxcrTcUh4Xjc1QzWuRR2FGbJMwwxZB143Hf1GItYn SpJStY3WK9c4BTMirxXSlqVjfUrKOXZghtWXFWHGQq8bQg0D4VW8VjjM0pzXjb268yKJo5jF ZS3JggoeFYm/p3YJNS3dhHF2qpzXCseW2UK14ptEKaITP2FGqzY04EbeJOqbGnfIPaa7+hxv Evmqk1AS1iM6uYDXzVcIIr48x8mGwAKm3Hkz6U3szTTmzquARSPKWkaABdTsowlgof4WuvN2 xBkJYDFHbwLLRUHEIg0salaU8ccO0SXdeV1gMfWOCMCqCwCLbdx552hPk8AiL4hYxlumBSkP WARBxHkMrZnAIo+iJNlNNA8sogytFwUWfUNIw6/EnTePoXVNYFHEVoAjCetRlOzuvHFksNOL rEgvopCBUMuQR5HBRvQiiFQkHxnocM0EMoC8gAUVUWRwOXoRffDcGL2Ivbp9lUNzROUw9DoN BAKZnAa3424/smMj0roJjiAdRwYRepHcGOAsZPBhepFqFhnEY4B3lYM7RDu9yK5y2NlJPjE7 ifO9GCUvwk6CUn6qiVdl6gi6MEgJsBZLB11cgd9E0/CmARG9AxCoFWM0wkZ+Ex9iJxmH2N22 Mv0mmHnRynE5cJ6poqAsYXGa30QuOwmuE6/K4N6/bzE7ideJJDLJ8ps4lZ0k56Qchtdqqmjb 8/pNNGWUJDdRr/fF9n4T3RBt7TfxBdhJbs9v4vJsJVeDNTIpSwIxX4I15AzWkFGsIWJYY46y pGZclqBZ9oJdlLLEHISl2pKujgnNDzrur1yXY0ITc1hD+lhDulijG+IsrBG8MBPXggTH9IlY Q+RgjZpWo8w735XFzAszIZnKdDrkkqxmYo08upNgk3ALMwVmk6xmHMLZDTnmwt+17IqZ0DJJ VtfEGlUgADGssQ7dyU7hfi2UKWSbiN5Qg3KTlCmQEbkWZUpbxSlTtIZ/p0zJoEypWlzxkhq+ hwxNSRy9nE6ZYubpKihTOqn0p30qbI4yRfViPcqUtrpWyhTVsiOUKeqLnTLlU1KmxA8+cNZb PAjOu6u9xbcEkfNHWqI6HQKBavcc7K4rLBlpWc5YDAoGE7f4yrvF9xyR8UjLphSCVs0WFoNF t/gGlFCC8BYPS0Sbkrrn4Hlv8dYspSIttWAFMx0MsY/uj1iwe1+GxDuxTtNO5DMf8h69xVeJ 8AkthFbLrFt8tGWuQK52i6etDFqWk1DEzppc0tL9Fu8O0da3eBAIwILCbuQWf53X8IAq65z4 ImTIumJ8QTZgciAzTA4kyuSAkviCzTA54HbBO/SpEEtz+ElO2dVbCaaZgo3YnNh8mKUUviA+ kwOhNBziNL5w6hneSzHXEdAQCaF9zvbvpQzjMZwQp+CLrrqj+AKVsBllPhDCOL4YO7PBeylc 5vlKBkA8D198/L2UPi8iCFSlzYKWbOqN4YsLvJcCAwEIrQS1Wiz8dq0E1/9eyuVZorYLsERl irkhkyDKygNjzA1NKQvR1kUUVvAZ5gYeZW6ACeaGWYIoCElKbbGAIMr8CJctcmCF1ZcLwQq1 Ooo4ISeq7I1hO1gBP8DcABYwN8DlzA0wg7kBlbh2EhxB8nemmZa5QrVaGEUuyVOym3AOGjSt cKGBStjDKJwwCj1EW4dRhHLmS8J6JE97GMUnpYS6GqVFJi9UsCiWKC3kjNJCRpUWoD3pkVea om8YnQP8Uz+htFCYp746o0jikVc1XFxBD7w9ugBzSgvpKy2kq7TohtjdthJKC9D6j7wKUEUe eR3+PJwtJyotQI5RRM3SKFuBEPpbm9eZlNIij1Mq0yiSxynlJ3gxgglkkuCUOkVpEVC3J5t6 Y0qLTE6pNaEKDgQgprRYh1NqV1rsrFDnZ4VqSkkgr0UEVmzGCgU5WmAL0Q7qSaWFbEoWo5u8 JCtUlPuhm6kLKS2Ws0JZmSlE4eYWeUMkjQQCmZwGN5f7QTgJo7RoQfJ3pjjgCVih8qIespQW H2aFwvPQIBr1sCst3CHaWaHWVVp8MYInNVZmkF/4N3n3Tb7fPf/6pMaZP4m7V9nKV/nUyH7E yfyJz5YoEkrW4io88Q1bDeZF4sQHwYmPWmKX9Waf7DrmEHiKBOv74MT3y/LZnhBdrkjo64+c +Hg48ackvWeNIWHmxI/1JXg3DNdsOPH9OoIT3y3rfHwMsRM/HmWwLh+DmaX4iU8YIcKTNMdh AYqSoukU6UqLeVe2siNr7PLCYhzBUI796iKHtKSYUeTf/WsWCow/g9FuirKBE/QYMs8gnb5+ vzBrMTidKIpJX9KXVfn9jnSzy+t7tEe66YATNc71sUPaGURrICQkMHhOK3quduturvR+xbTe 73jLUNMyrsrXh3TbtsEXwzAXfpCH9fOGt2iLVL+PFoY5dgsrw0iZuQmYhhepUWPM6ab/5omC MY53ZcfukYtFcKQh1heYV4nX6ZRMQRKZzemf3aRkoCRNtlCXZaj0CXp1dDmZMSta7oIi07Gw m84UMeIr+fqFzgQKlF1FOL19Aiw51sQR4doMiVfGwmYmoPsiOptur8YJsNrOG06mp9fMfooj LRvbHIxIsu0DyC6sQ+M41DwFBQVl6PNFlaGz63KMCmpWf2XOG4M1dZ5v7dPdu0JNd+pIVZBV Zafa1oXKdHa101sV3ukD0RTzgh41Aq011EVJqGs2SJ1fR+/d/coffrl75/WDfLvDdw/yh3x4 Myo4qAqpqkQh3TagyUj4i6727hu/e382jbAKUWOjWyKTPdGi3A2/5jD59mMoROUttVKuTeU0 gmSGULOhNM8vWm2ICo3WcZL/hFcNwB2Binz8/nD36+v9u56uBuvpStZV8VqWKpvK1Jh6YKl7 lfqcMsH07GrQrqvhpo6iZsQIRZO8TXAKYWU1T11EXu6fdb8q3a3kvQfWgAX1NQywI/URtWnx ThH657/+m66n1nrXMjldFeWo1tedpx/84V6oiu70FeT19fuLVqPiWktM8q5U11wvteb58fH5 ycmIwFz/OC1g0dPe9P27e37SfRTF7LyhkkndXC7EpFnWbUwz7OCq7IT6Sd/oHh/N8HdCnJzv ulJQeMr0+t7cmWy6U0VyEdekbbUANz/L5pe77y9mNM1dV3dMyzFM7ji1xAz1I2J2ELOQdebh xppcAnVTjRxCvyFzwX58ex1XApi77Wr+JNrn1cv+SdUqRb8F8e8PRgbMsi2SI9yUZaVvzG+a w+hR/nb/fteNm+62Oj50v2ly0HhDUNO3QEntq3z7bvqMmlkFfqlKbI3oKaH77f3u7df79+Zn sz/pnVKsKEFIHfZ6jN7UvIrvneahoub4SM9mKXSnXt4HMehUD12nkm0rAUN69b7Kl9fnb6/8 cZSeet56okRAaCH/0elXIiRSbO64q0sE+TwLlTHfpEWwLc0uokVA7QLqtH17u397H4Y2vdCa itC2z/j2/u3+7kFtzA/6vNQix45rXFwCB3geAgdf9QI61csELYmkLaTzBA7AM6P8eMx/i32q qeeqi+pUigFDZzlnjGRyFnOD/g1EcbZOxakfT1YUN71zI11JpxJnbrDKCt9iT+hUhvSPv8UO E1YUAEg7yKpjRTG3NBDRqbj191YUra6R0z/ndCqjFQVMOpX4Erk0YRvCtdnTuvPo7uG5+UXv R9zWqM4QnmQqIYdbvL9g+h/0F0zVf79kwYD+dnPwzY7uNdE1Ow6X+hhRm8JziQUDN1gwY19s s6Npl0BZC8bLU0QWzGqP6TYlt10XtlNCmlmKKyFFycCoYtS2HwPEHGssayKX5/il3dG4jNMT zHFaN+F9Gb4+717amzKwLcFoN80VJtkQ0M/+xC8y/FK61pk3xwdeuElZgWkJWRA1RbPeG05W F9Voxqnr7IEwONcdRAVd4/ppfQ0LWxa0Pd2yZEOCIRp6GlQXlbMouZ3tmxZxJ9NQO9pNg6Wd QZR6vIPCnMom8qWgmznP0WeOGaSEhP1OyIpxKSmBus7PLKeZIerdLvw7Q3TMzNVgdgJgBci0 NhuisEUjUrtGQR1+ZrUFNSQpePPWBnMLWLC+zCvOokoUpm8E4fqyulm3tAhHNaprDYfX9p/M adlysUrJWZ4SMgf1+HnMeTKjQoRkXodo9vQjd3lez17lT1RXXUQDsFjV9RlVBt1mobLJJ63u 7S7fv94/iedfdV4z8rhOVak3izmtASLXqTU4ybHjg6qGKlQ1wDOoGvwLFYioGgrd+dmr03JV A/JvTmYPBWAVVYMuC0kUqBqoIWRrnJuTU7+oAlVDzQuFN8td1XAFqoYPka/CkHy1OMOCCsli bpJ8lYs+z8fJV6smTr6q03fy1X/JJYUBslJdcUlh4hqJuCP0yeSr3TxdBflqJ5X+tE+FzZCv 6l6sRr6qCrtS8lXdsnnyVf3FTr66k6/u5KtOHQs182P69uSraj0jhglreAJfkuEctFUahNEI vtR7g0ACF9XB1sxfb5wxIqIpWixOPwe3J18dh9heFPlPqCTIV4cRTG/Cw18CVbk1MXnkqy1G o8w735WEJ/Rkw6Aln1Bp7cKcpp4QZxwnX50GERFWHtXMd2eNFUzUJwDoIgdunpgP9qj4jp4X TJTVsmuMM56GSAAv706++mHy1a9Ag3J5frWrgSeZJGuBdC+BJ3yGBoVHaVBgEp7MkKypnSNF g7IgXlmfnVKt7s7R4prgSeqaLlFpiMpd9dc2JGtpeMJ9GhROaTjE/raVB0/O+MJbwOk2/NzC YG1e6+xkPhBCf2tzRXuLF95yCdqCTeIIPNlfeLviF95QIAB+YesRtO3wZGdp2wCefC6WtjoB TxaxtKmzUzRQkA3gySp+jVF4cna/xg+xtI1DnAVP/MfujzsVGfNuZKfPgic5LG2wganH7mk9 C0+SLG2+5+GH4MmpLG05p+MwvFaCwoxnfOy+bBipeFhYsl7vi+0fu++GaOvH7r8AS9vtPXa/ s7atyNomYFtyWdAIzPgwa1tiQYQwg/Lm4zDD/DjqGeiuiLUNISjb3lnC43BhoIWekeYqWNv8 24utyaB5VPPmQuccmXlQoTpONQ+rOvHKnRYkf2eKoqmQtS3d1GOO0OuztqF5TQb0NRnw0qxt fUNIM/hsZBV2RtY2uLO2RVDCTjU/CywuzRS3GbDQHC88BSzIMmBh+GLiwIKUbXewB8CCzAAL EgILU8cpwIJ1HtQrAIsKSMSjwIJcI7C4BB3sMEtHgUX3Wm5Roxlz9ShX4fE9StyQ5ziwCAsL 6jX/H4uEBwcDKANYjC2zT4A8pvgsYCFY3vN2yW6W88AiyhSfceLq2ZxQoc4rWkRZ83Fg0Tf1 euhg85ji1wQWZSBnviRgtc22EN4osNj4kCdnPeRJxiF/JZYKCHjeSR8IaL6lQtXB0ic9Z4Gl Qu2gsoo7UkAgYn6e/U+t6cRJj5yTfgi3xXXkpDdq9KahwCV+vwJLRZIGFgJZkFJsa6kYZilu qegEK5jpYIjdLSRGA2uGBHpbotblWKYLJiKu5TEW0iyUIKN8A15hmI00o6EQ+lubK9pJS4XD DplECVmWCsFOc6TIObVGqqOpqZqv6KyWipKx2Gwm6vW+2N5S0Q3R1pYKEghAaKnQtHL4hi0V W0OFS5M0bakPEDKlD5CL9QEioQ+oOCnLKEqQM/oAGdUHiNjzMDpd84KGKKFRewFu6oamDA0+ SuhfJk89D4PV/GDXn8Hqy4X0AdHnYaqW05JR0IIL6ANElj5glBrnnmbfT7txMu9JLTnYA5mc Bjf3eRjmJIzSQmkRnPRRfYAI9AF5z91n6gNivEELzpVqVh8Qf+7+ooaGvqlXow/IfO5+TX1A yLrlS4I+6WVb3qQ+4AofjfsQn0IR8imcgws19Fq4ST4FVhC4Ep8C4GWUT0Gn73wK/5LLpwA5 rSC/AJ9CN09XwafQSaU/7VNhM3wKuher8SmowqJ8CsMXwx/CbjpDNBWGI8wDJ7csxqfgZJAc BYV1RzIsrZs2hJTR6WIPVQKDNqFFvJvdx7fJp9BJYtkQxG6QT2EVVLMqRNoL+4yFxQHWztvx 6Xg7tE9ky1ORJ1HejkIkeDtkUajSysP57Tkf4u0Yc8TsOefV1HyYt2MYYvcKGI880VQX7gpX UK0ItTwZh/3wl7Q9J5e3AzQTQHI/rJ1eLeHtWDEwNsXbcSzhXIGxw6duVPOc18fMBEwt2wNj 3QRfABYUdhv2nCtU9QRkmOfEFiEH5iUjTdRlMGoAagnJC2i18qA2ZgCSJW5FwaOwgpRpWEHq WKQJak+KNGnWcggtBEHyEBqATF8uBCuQaDDzDUDmtz2ssGZpzgAUzEKQYGWJR5pMEjfkOQ4N hizHNtW6kvGWaUHyd6aZltnQYMVIEy4/6BB6c5Ems9DgAgagC0Sa+A/ChJKgI00Q4DdpALqN UJHL03FthwxQmUIGmUxcVh6YQAaFgFXMNUTVMYMMeBQZwDbiGoKPMHFBtbUlkEGEiYu2LOka AljBqzgy4JdDBggKHA0VgZQUBG8fgwo3QAb9TKWO2xQygBnIABEUj0E1gpSFDGDru4akm3oC MshzAk12k8y7hpS+a0h5aWTQNUTCpuBXEYOqhmhrZBDKmS8J67Fp7cggjgx2JqxPyYSFKPu4 4qCDOnUNtyDq/LJMWMMQu/vO7TBhIcwS9BZaCP2tzRXtnQlrUcswVecRljsT1tGEnQnrCpmw Lk9YcSVYI5u1IhDzJbGsZCaWlURjWdtkLCubiWUFdehr2vclporgKVJwWSJKgKuKuALfh5iv qWotEbiSZYuGzXhT1op0LCvxY1kJo+EQZ2ENn0oLnpEUPCDJGH4e1gC8HmU+EMIk1kiScyyI cMnCGrmMF36CFyRhCsyOcMk4hLvp/9RvliyLcFkTa5SBAIRYYy3Gi50UfKfa2ACefCaqDVDB THgyT7Uhy7JoKLo2VchnotoYhjgLnviqkJ5Zw9qLXZaKgQviRHiSRbWB2mqU+UAI5+DJTrWR 1xBXFVJUYYjOTrXh/fdXoNq4OVXIztWxJleHLCvSsCoKM1bl6kBJmAFLvozRi0yRKZ5DhtrZ ajcC5PJcHYFDxnDlKgCkzTQu18bVEddkgCKPFDxk4siCCiKHFJyKOCuXESR/Z5pp2bS5c+kE XiShQnTMVufqgHOajEat2dZLuLRDRt/Ua3HV1EO0c3XspOBnpftAId1HcQa6j9BB9CbpPiAj ciW6D8jqKN2HTt/pPnJMMH0/Gk7JBeg+unm6CrqPTir9aZ8Km6H70L1Yje5DFRal+7CFRUAC wm72f6FeQjElqH0baur401sWo/twvyg8/Uv3aSklY8xtGZhiRqGm3SCcTufykDXSshul+7B+ O93HXtheWLSwOMC6PN3HFnqeUdfA44E3mUwfVlksFnijNn1W1TwekotmPGuRdPU8I4dEIvAm wfQha1pUDSMJPU+U6YOwGNNHVyDhZUzPY/pyMT0PYrXxYQiglg4h3jTwxpql8wfeLH78LeTT iDeE0MQbLag4yslqr4W8pi7W8+SydSS7eXMhuePjb5W8isCbC4Tk+qJxiiRcsZ7nOhU1V0fW cSXeJtmMHYFkLgm8ITPwgEQDb9BJgTewWIGxw0Adoq63hQMPrsAZNkkE9lFNzAcYO9KBN8QP vCFW4M04xO6+E3ibjLwY7l6IBeTUHuP1iMACghBP6obCCpDwNtFC6G9tXmdSRGAtyIEWWd4m KbaP4ewrACKsTFsSDgln2D5BnZuO7oobaBHsUUfggdb/FBJLjW2XnpsBtOgbcnln2GmIBPDy ntkZFgYC4Be2HtvHTgS2B/VOv5sN6rXSIYB1kvNDrRyZwBYLOD/0wccaCsi1kYwGz8EM2zMR TdHiS7w7f3JQ7zjE/p4TLQx8GFu03s8rPfKUzLE9v0lhCy2E/tYWVBe/X+bxhWRhi1ODeuPn ZCZfyAnYQvtHMSiX38nT2KLMYCzdItAmjy9kTWzxBYJ6rx9bFGfFFuHDMJekEoMw5bmKlnmu 6n0x5rmq7qB1RToe8sBzFc14rqLQc9XUEbdoQFDOwIqiTb0yF4UV8fhd8yvrGrsqC6svF4IV gUVj2pnBBTxXh1laZNGwDpNcz9VR4oZCnPPWwQrDF0OWYzt0yRIWDS1I/s400zJXqFa0aDRB y2IJyW6u/Or80YYsOSLnocF1eK5e4tX5IpAzXxI6aEBv03P1JiwaO73HLdF7JBZBJH5WlAl4 sNSiwaq23ULrsAqV2MXiZ0+n9xiH2N13roBKLJPeAxQmPrGTrUAI/a3NFe0tqMROpffICizd mkqswkVbFmFhO5WY+/sK9B43Fz+7c3XcLlfHjCqCcpyvitDxjmkLR1XyagOs8eEH77ufQK24 QBDt6Vwd4xAfwRojvYVzvbSv1R+0cATUHPkWjgTW0EI4hzWSXB25AbiZWOM0rg4Yjll+AO7M ITx86kZPf+Jn1HIDcNfEGl+Aq+P6LRyX5+a4GmyRSdARiPUSbCFnsIWMYgsRwxY9QUcaW0Cc CtwoPGwxywOmLtm0btTkXhe2SPKASVSaK/Dmegwxhy2kjy2kq8fohjiNLZzpg95Gqu1NlmKj JwbzJj2iy3YObAdsDF8EfCDDzysMs2b4SyiEc9hCbMQDlkfuccrRtjkPWIULyXcesKMJVSAA MWyxDrnHxWhKb41tA+5sGym2DS76PB9n20DqTImxbej0nW3jXz5CeL4kxuNkto1unq6CbaOT Sn/ap8Jm2DZ0L1Zj21CFnZdtg05X/OUtm2fb0F/sbBufkm0jfvDtLAgrsiC0RAopy/jzoxuw IGj7NC9BeAT2HxwCRf3s86NVWXSQ4bpYEGoaJZyCoJRw01CETVkQFj8/msuCgJCXMPwUYj/m MxhnQVj1+dEPsyDc7vOjNboKFoQLPD+6syBcXte+syDcEguC8z1Lv06uNoIUPIja8duEHV9B HV6W7Nrs+Gk+SghrUaJbYkEYh9jddzKfBFO79NmeBMtkQYCsTTwJBjEIoIUr2jsLwgrnZgAt +oZc3o4/DdHOgnAGXftnZNPeiRRumEghsZAir6PDlJvhopAG1agWNu2owA/OhyshaZqOmku8 1fEhIoVxiP1t68h9t4cniRdLnaZFtRfOmW//bHiS8zq6Gu6EK4AWQn9rm2mZfaA4AY5OUzcj UsDRozaMlqz8aMlqhyeHgzdEO5HC+vDkJvDFTqawIplCq8QFcVhHoMXKZAoJwwgVkmOR4n+M PoZez5ApSF60h9AwcmEyBdcwcnlosZhMIUjwN40oTjkTmYK+ncZbVjVHDSNxMoWV6aE/SKZw RnroaEOWHJPL4cEFDCMXoIfeyRQujwx2MoVbIlNwvmczAY4wCQ+iXEs0bRgRZVFdnWEEc4YZ iPpNhGQKWwQ4nk6mMA6xu+/Mah6CBH/XCU7lUzQPmWQKkOEUPbSYoYeeI1PQArliEMJpZAre I5UpaAFr3+eiztc85PlcLNU89D4XZRHzubiA5kEN0daah69ApnAT+OLyBArbPUAum5TmIZM7 wS4roXmApMVNFFrwGc0Djz5ALm3NQ2IRhA+QM5h6gHyBUcP8RIU7SspA88Avp3m4Op4mueAB 8kyupXBjDViBsuCBzNE81IkYRSNI/s4UIqhxLfidWEnzkMt/cMphlORaOpMdYkjBVMHRssRB vXNN7biWwsKGYMWZvKkYxQwFSz7X0ppjFnVKdiRhPf6DC2gebo5m6dJUCAhzWur+vkou7r4/ PTw3v5hx/oMeqVmMUC7DCGpDDjGCCcjGrBgwAnUFLoURhIsRKnef9jGCpJjRKaqvfvHrBzGM ICoFQ5diBLPkjqgfpiR9CRqvIQYj+G0eMIJTEq7ZgBG8OvBYVmmXVbUEgFW4HK+QA0HNUhwj iLLB7NAHgyUIlQEAKTkZC1ODV7IWVwi44qHjy4fqhgn1BTv0gO/z+g3Rcxq0bPiHyqmH5ahL hi041kBISKAfCxfcfrv2G4GcK70XJR8bHW8ZalrGtQnvYPoz90WysH54YRHk9fvdz1nhh2dO 482xNyPtzEkcToCFuNSoMeZ0wgFpflNHqonjYxZlpTANsbJgXiVmU8kUJH5crtOybsgzAIe6 cJco2rJUQnI5mTErWu7iC9OxuW527Y0vdCYQdWeTEXp0eqNGGG+8h3qPtixC8xn0apwAq+28 4WRSDaYnQBem7nkw2c1k28OWDYquwNhX+g1B3hdFVM6in4ZR3l7b63oBsHXUqbySgLuFldUy cJoFe/xM5kBRmb7J97sX/k3e6QPp7lv7dPeCHjXkE0w75CbBqdmHdX4dkX/3K3/45e6d1w/y 7Q7fPcgf8uHNKM6gKqSqEoV0u41GuPxFV3v3jd+9P5tGWIVAYloikz3RK0YVonqhgfG3H0Mh Km+pucLaVE4jrwYfa4jdPL9oZR8qNDzGSVBtJmzIJB+/P5hhVxkbrSVEyQHnVcPbDs2bXL++ 3r9L0z19C4DJRla8lljlU7ka00CIdT3JK0eBgVYnanit6+GmkhYCYi4qTRL3cwphZbVPXRle 7p/1gFRzcsRgDVhQX8MAO1IfUZsq7/Sef/7rv+l6aj2AZXKeK8pRrS8mTz/4w71QFd3py8Lr 6/cXTQuHay1qydoYIcISd6OYndXqipIiYuZZ59Ey+a5uBXcKMqpLnMpO9YCi8lzri9MCFv3l rx/Xu+cn3W5RzMoLKpnUw8SFmBTYemzS90xcld0qfNJ3vsdHM+3dqkvKWV0p7Dxlen1v7kw2 fSEtkqOib+O075Ve9E9q85CiHyD+/cFMpFm0RbK5TVlW+oL6pq/Fj/K3+/e7rhGvWtBbfVWF dKYFlREE3QIleq/y7ftjtwzFLK1gqYrUy7d5VjL32/vd26/3783P4/oVK84HUpBCD9Jb87MU 3ztVQaXHhCSFtZalaPQe+H73/aVbGuaqj5o5WUGwAkS3TT7prVsvp9e7X++fxPOvOq8ZSVyn qmwqoaXmR6cTiegmmGlyKrsOJetn0dTL397u3/T8I8BnJU9NIG37nG/v3+7vHtQO+aBXpBYb dlxJ4dIqwZ9+gDPQKvnaCtBpKwYMQAGRlMHyCK2SZ7r48XiMT6nzG6wTzhKh5WIEQTGnCFOW 7RRBOWYYN6NTxJReqt1ANrZWYuppWULMjVbkLUhna2ol4nxKVlme5WLK42slhvRQK+FYLiJ5 fK0ETFguFGJtB1l1WJ/NdW4oK9JeRythuDDk9M85rcToFAEmrUT/P2vzlJGdpyzFU8YKAlfi KcMwzlOm03eesn/JjsKOkLTEtX1xZ6OTecq6eboKnrJOKv1pnwqb4SnTvViNp0wVdqU8Zbpl 8zxl+oudp2znKduQp+xKnG6zycq8vy0L90X1DFlZ7Z6DaKDBSrCRzD1wqlZiAl+Wwzlo1SEL GcOX6qRR99i6lXw4B608F2X+viLPGGuWUuG+WrCCmQ6G2F4UV/GC2chA5ku2WxhsDbNyJ/OB EFptt5xuh0Hb4gWzXHqrI92Mfrr5C2aUiTZmQttfMPMTfAFYUNgiw8X+gtnOfPa1mc8AFgms EQ3wicf/moOwUGc6uzasgVBpokpCrFE1iFVbEqN+jPnMGuI01ggkK0iw8jrUIv3kxnba41gj k/kM6TMu3jIsEljjCPNZ1+aVsEaK+exYguf5YAqMxQ77AT7gSgJ8RAMkuYoAH7B9gM9XYD67 iQCfnbrslqjLrHSowGwaX7Am9Rr7AmZVffgVsuQFvDJ8EVCXTVkiL6Qu0elvTV1mDXEaXzj1 LHshtR+vU/FFDnUZQkXCL1kL4Ry+mKEuW5FZNUVdNhyAWzOrTp82RVFnIIDF+KJvyOWpy6Yh 2ppZ9QtQl13/C6k7bdlqtGXmHtoyDGLvuWxAW9b/YFMlYEWEtkwzTCVpywguGXFgxVXQlrlq i/6IQEQ0RYs3fc8lk7bMXt0e6TqMs5rGYcV5aMsAFsRNsAXJ35lmWmZv5nncItExW522rJpV PcS5RRKFfU3askxukVUsQf3vk9OWfQW+9UuznmlP5CrmiQxsT+QZR8Ql6goEiYcrpigpywWR Wo9Yp9UVFQnUFeq6AiQtBlyRkHjHtVf9tNvN6No77Ncj5dTndu1d7dH1BeoKU+FqAcdmllIO iGA9y38nJdN/q3WDeBBkt+bNLyg99ub30JhwEZzQsqpkmKL2GIWsXsbWf6qROQ6fFiXkF1aG G0n3h4lUK13YohMwb6Oc2ec3CdnwN3zNemOFbAwTfMTDHC4N2eCRkI1+gUTvi3xGDX2efd1N //T7+vKQDd4iE0f9gZCN6L5uPuhCNuC8L+pO0LYaQZvWsRAgKInrWD5I0OZ8L9KmG4iTOpao 6aaZeTO3hZWM6lguR9AGG1BCCYCvY9EKC7A9NfxCgrbgYbtjOpZhOAINiqO4sH/jF7kEbS1t nQRHkPxLWqhjiRC05b4ck6Vj+TBBG55374i+HLPrWNwh2lrH8skJ2r6CjuXSnG5X4xiiwyPO zywvZ5jlZZRZXsSY5XU6nU5RC12os7ooAcUy5XjqW3A6niwyIRXP8VTwCrr0r1fgGDIT7HkZ ZnkxxywvfWZ5yWg4xO62dR3M8iKHWV6WccdTqGQ07RgylB5X0ztgIolMshxDhInBWX64lW5h SWTS+sikvQ7HUyXB1+J42m7ueFoFAuAXppGJbMvbdQy5UnzxIa6JIuSaQGfQBIY+JTfJNQEZ ketwTYAGwhjXhEnfuSZy4EfV4oqX1ATKZxh64vDjVK6Jfp6ugmuik0p/2qfC0lwTphdrcU3o wq6Ta8K0bJZrwnyxc018Sq6JVRQvq2px9sI+Y2FxgHV5TpMt7EijtoHH7EjZdCZWWR3bg29H akVZNe1oe3XrmAkBQtK1I41EGVE7UoLOhNY1raAsijqh6SGBpgcUElf1BI8cOxIsi5aVh9CO ZPpyIU2PNlNwE9jh+eqqA7KRoNjSV9eapTw7kpYaRzmDJINNGMazRDkTyOQ0uKjWTrNH9hJU eQnj9GsIaHUmZkey6+0FZEGYcJYdKZeSJNnNYl5bEw0TzoTNedqam7cjbe+rGwbBLZeE67Uj XX8Ez84+ckvsI4kFELplIZpyMRm1MP6RHTUCtYJggdDhyoxAyejgixiBPsY+Mgyxu+ckooOR gRXWEKmsciY6eDgYTjECZbKPqFkan8MKhdDf2rzOpIxAjt0mCSuyjECnso/EI13DEKDSDwEq 841Apt4+L1IIXSpZyAgXPmIEmoUVAZo4vxFIDdHOPrK6Eej6sUWEPry6BH04RoVo6xw+/hNM OsDVM2iJL9TuxuoImICQQjY+fidsM1CNJWHNqGeIpYv7sI6ISaf/G/JNOn06XA4mwOTjba3q siipCyZMewmqiiLiUeKVha2yMEV1BwzWit1Z9FigYK6eQSdW6gSCtQkZ3NqkM86TDyds0QrG IRhMNwuJnhnqj20JPAF1FPl9QkLs7JbpetvYzuzmpdSpvywaltzmXSMArDDxutn4pbOo4QRW rCG1+yl37UOUiCp82TDo5rQerXZ13Qz6fbSwaa7c8WZ4LsEvbKbe5YX5y9gdsxrTcANwRzVm ueJqOQnJkfcpoceq88HhWFhLggizICF8HjI6Zjo2ajRq6isF1PV63eTBQMRm0xuiSK/sMesE D9W1pCxVGIjkdXvNQFB/UJhqiVRXjmkpgr50GDZ1gWjMCF4/AX7bj2PgvhMNdea7VZcc7wtf zqaWoQlQN6QS0LKQds2qsKvagynR6DphiYbbK194xiyR2SQ6TmPuhe7oQADQeK+57NRuX4Ha DWGSUN5E44NkitpN26hQfW3UsYFdZ+rdhZQ3H6B2G4bYXhRJmvogtqiIxhbNKG9a7+fKWswm dOQURJrDfJD5QAjtti+gdnOU925T16J2O5YAwzGLKG+aVrjKG5WwUHmzPOG2lDd6iLZW3nwB arcvEWB0aRKXq4EnEJANAozITIARiQYYtdUptiVcIheeULPLEwFdeHLctlSSprm2AKM0PIlR uWwRYNTOBRgRP8CIMBoO8RF40kc61yh5I7Gpf/yEU2xLY2EJqRsK4y0eGxIIYRKehC2z4Ule 6HMWPBHsNNsSdgtLwJNE6PMSeNLnRRBWVV01K9qWyuYa4Elu6POa8KQMBCCEJwPLzs3Ck42h wuVJTq4GKmQynQRSugQq8BmowKNQQcZikY8xnQDZsiWajCRJvTrHaM1vSJOBa+o/grPEcvQB ppM0VOA+VOAeVDBDnIYKgWQFCVbekzUZI1vJNDG5moyEG4ps2SxUkGmosCJJfYolZTjLtiap t/9wnljkLqEpcCMvG4s8DdHWJPUkEIAoVFiFJWWPRZ7BFzvXyQ1zncxYStqUm2vh4YuO6wTH ImD04dfIWtT4yvDFKqyyEXzR/3NbrpNhiNP4wvqL/6BvR3psb6Y2qakuvyxhcdqDvplcJ2qP rkeZD4RwDl8kuU68TnwUX5zGdZJzvA3DazVVtO0ZH/RlZcFZlGQvUa/3xfYP+nZDtPWDvl+B 6+T6H/T9EO8JDJ1kyRmcZMNInJvkPeGiz7MC7wlJ8J6QnfckgCJztGul6srpqo7TeU/I1fCe dFLpT/tU2BzvCVmT94Sch/ekq6mUohKn8p6Qo7wnZOc92XlPZhL2wvbC5guLA6zL855cieon m/wkGO8lTrKoTjvJqr85eGuk1YialloSfaiQFk1dlGqcU+Qn1FH9DOwbKPbwhL5eqMOkBddm WkrjLVRxS+Q3JT9JO8lqwQpmOhhi/0o4swf0uEC/GbDYSdb/S1r1EzCpDD+vMGSu1l3LnO8g SKl+LL6UmLZmVZrbXLoMP2ELmtushty6k+wlaG5BIAALCrsR1c9NmJbQWfFFGNx8yTeQURl/ n0fdv/Lib6w8MMarBhvVobblUWjByzS04LXLqzbUkeJVEzxtVVJ/TUCLiNeKpsBKvs9DdbCa Ay2svlwIWqjVQUmUPAXUEPpeK1vE38BjvGpH97MAHsSPyTRZWRQeDEJ6ZGOFJWjiLdOC5O9M cePZOXnVuPzg+zw3x6vWN6QBRcTzJFnYp+JVC+XMlwQTQ4Ob23yf5yaQweXDc7dDBrBKIYPM yFwrD0ggA4RlMRp53DpmkIGMIgOQQAazkbkQiSYfGaQic/WvqGlb8CgykBdDBpBUDOl4iytQ OlizdC5kMHwSnPtZyABkIANUFPGWGUHKQgag9V/uy4uuzUIGudG1M0fmDDJIRNdeFBn0Tb0W xtXc6No1kQEO5MyXhPWia3dkEEcGxVmRQfjGzdXaJKDmosmBB4FUL3FHRTPuqCh0R9XbbjLc JW6TUPCEkgL3R3fu03sJd1SoLdyVvLbI2KQ7qkSl8WR04MHZ3VGHWUq5oyLfHRUxGg6xu+9c gTuq6VbG03uQlqPMO9/B8ghxxybuqLRtgpZlJWQcdZu7o3JQER6Nc97dUe1fEQiAX1gHLeju jrqzcOwsHB9i4UAkhTUWMbyrgxC3WJIrwxoBw/twZwIE83pCCbfAwjEO8RGsMRJXuBsrFriw 867I8J7LwmG4CHvZCoQwiTXmWTgczcPHsMapLByexsUUGDNwQN/AsSC01tTb5z0Dw/u1sHDA nYVjfaxx/QzvO23Hp6TtAAgmsEXUzNEkaDvUwScbVriE7+fBFssI39X9owWZZo6z6zE+RNsx DvERbBHXYxBhjAnWRkqN+WcYj5oXohInh9XKLD1Gw0eZD4RwDlskaTu8TnwUW+Q5T5xytA3D ayXgApxXj1FyGRaWrNf7Yns9RjdEW+sxvgJtx83pMS5P4bGRN4WmDJBxb4ps9g67rCruTVEM obQheweZYe9oAm+Kjhdi8qZILIgQZlQwBTMWqDC6kvSTYQ7MsPpyIRVG4GfZ35cQLBFtpucQ tlNhmFk6+n5tF3VxnAw0TmtRBHQaWVBBxIlEx3rN/6/Lyk2wBcnfmWZaNm3utKUgBypEx8z3 pshl4Eh2s5pVQ0DfzxIu8LOcJm+ODPSICqNrWa4aIlnY+fws4fZ+llUgZ74krMfAcQFviuvm ziAhdwY+A3dGqIe4Se4MVhC4EneG4HWUO0On79wZvi0jFstZtbjiJTWB/xn6hjgQOJk7o5un q+DO6KTSn/apsBnuDN2L1bgzhP44wp0xfDH8IeymM0RTYThUxJ/eshh3hpNBchQU1p2wsLRu 3hBSRqeLPpQlbwSxpijeze7j2+TO6CSxbAhiO3fGXtheWLSwOMC6PHfGFjqX8d7P4xEsmbQZ VlksFsGCWAkaWbtv+Y51zLwth6SrcxkJGRKxrQkXVU2j3RApEzoXEtO5FIJO8MjRuVSy0qdS LIIF0UvpXKKM7JXCDgUtGssfbVPajAydS3/Zmt6H64ZSYS26KIKl9X6hTE6D27GqH9lLUMHi bqawEeEDLLFu9vX2vVpAfZGlc8mlvkh2s5x3/YhSX2TC5i8RwZJLfXGmA/BkSbhmncsXeBoO nhVYhGSnlwyNVTfBRGgsWRwaixLAAiFIYRRYkJnQWBINjUVJYMHSpBmI0yIBLKKkGSwZGktV b1g8NJZcLDQ2ABb9DoiIaNQEi+1JM1AWsBilxtnw7YPO8jRbDCxsmZwGNw9YVCAOLIwgHQEW dr2uUK0GLLjM8ylNdpPMG3NK35hTLjTmnN6yGwEWmm92Y2DhP90eSoKOX0GA36Qx5/rdSXcq rRWptDQqaFp0ISotCsq2ZUoWU6ggERFbJVFBK3AcFVyQSuvqImIXUWkV0NsCdZDsMLZjmOuJ qACeiAri771CWoSPuEVRgU+llRvVmokKPkilNZM3GdV6Zt0xprzRHF5BvenChqjWsLDBLTSd N+kNmgF+8qNa1xyzT06ltbNi3TArljrkMcGljB7yG7FiAVwu4MucY8UCNZJtHT3kL8eKhRCG VZwVC4LyEnyZZ2XFcmcqdXI6p/4oB3msWIDixEtqWpCyDvmdFeu0ls3zZaKGkmvgy9xZsVY/ 5G/CKLCzYt0uK9YMPEB16qWOKDwQiWhSrc8ggl/dI62iwSz6CPzFSDNPZsUah9jddzJf6gA0 /lKH07QoPMiDFlmPtDaJlzq0EPpb20zLXIHMgRYBoogfKKexYm3BVHHOR+Cv6KWO7ZkqvgIr 1k3gi50J61MyYYE+9PODTFhalVIXoLk2fOGrH/rNDBEs2pYXG6sfPsSENQ5xGl849WR5LQRH 8yn4IpcJCyI0ylYghEl8MceElfvURxa+OJUJq4id4rlPfWQcvIUStgkc6ryiRZRlkFcdwxfj Ux8x1cUl8EVeCOqa+GJnwroCbHF5doqrwRaZFBWBWC/BFnIGW8gothAx3YVO19IVYgt9WNWF ZE3KtIE93UXnv0AmPUiguyDc9V+4PLaADSihBH64hCACV7Js0RBJvDwy9QMUFWlsIX1sIX3d BRlOhcW6CzD/ymg/XhH9dRa2EHm6i4RZBLHwsRBXtJO6ixasiC3i9BbTICLCyvQRk8IWfYK6 mDuxvHzXXfhjpnUXwMt7ZmxRBQIQwxbr0FvsugsbX6xNjAF2YowUMQZkRK5EjCGrMkqModN3 YgwffiQfOYd12VLiqjaWwI+TiTG6eboKYoxOKv1pnwqbIcbQvViNGEMVFiXGsIVFQALCbvZ/ oV5CYZ3q2sm/EuD0lsWIMdwvCho7TNUAMcbcloFJHwE1QQXhdDpdh6yRlt0oMYb124kx9sL2 wqKFxQHW5YkxrkTdk82OEYx3vrpH1VGnPVlR7eKtkXch6qrSkqirCq1rWkFZFClXlQXsGOou XDICa3Z16h7/URWdmFT3bMSOkVL3dIIVzHQwxP410Cts5KBwVzgWBbSVKiuakgKqjeHnFYaa iTnM+Q7VKVOSRagRNyXlMWtkuqrk8Sn4CaVbWIdpcpk1ZvQgQb0Dylv/UZVLq3uWMWusewr6 ArCgsNtQ91y/KWnnxliRG0OdE5SpHSIKKz7IjZFYAKGHCoVtAlYsJTovalhUDqy4PDeGWh0S xojOr5wbIyDd6ixBRdQSFMUoLvPFcWgwZDmyqcKCN06CI0j+zjTTsmkzXzVA5sPcGDcXIDML DWa62f3PXOn291cdIPO5uTG+BOnWTq+xIr2GAhasaGQRBRZnp9fof3WNE8BiIemWVoDIeOTt Bek1fGAxZREVuETk7SJ6DQCSF6wjkbdzTFYpYAFzgEVFE+ExWpCygIVPr7Ey6dYH6TXOSLp1 zshbCZuaX0Pk7SVItz45vcZNIIPLc3JcjTkjk5gjkOol5gw5Q/bdw4CQmCMReQtjZN/DT5AE PPC9V2cjb3FZybaA12bOuD72LTBnztCCFcx0MMTuvpP5jmtH1GW76rmkVwO11CnmjJFtw5ds r7CayVHmAyH0tzZXtJPvuOYxd2WaM/JIPU456pLMXec5NzGtK4GFiM1mLnPX1PZt3nHNZ+5a c8xwIAB+YeuReuzvuO4sH8uwxk2wfCRWRQRrVChTFdHVDWQ0UgaXFNVNJTfAGqu8Ga+xhsWS uSHWOJnlYxzi5Vije5QEURdrRJ9bdwtzoIXTixhL6JEzALIiYR/RQjiLNTZ5M/5Ulo+sQ3jr N+MV1kCyDAvb34x3f1+B5ePmsMbO+HFLjB/O92xGr9GIMoE1fFZxo9do0noNHTCPrkyvATFn mIHATZPygmAEPKxx3Ywf4xBnYY3AF6OZj8oNsYb/l7ReI5fxoyYJxg8thEmsMcf4oQVyNaxx KuOHx3dpCoy5aVa+m2a1R+UOEzAO0c74sT7W+AoOGTtpyGcjDSlog2RFUoRk8UdPEqQhuGQF KuprIzxNPGd/kSiSj5KGjEN8EjyB54UnOaQhUIcgDTLvfMfpjCpkjjSEthSsCE/ipCHHEiq3 sBQ8gT4hGTxCSLa4ITcPT+D2hGRfgTTkk8GT332532/y6bcXNSDf3v7Q/fO3xzvxKN++3f2+ uavUnLwZUfgH9cXJdWh5JkXxu160nf/F+i8Q/A4iUOKigrjCv1OgAoHidwewYj+Tv+/qWH09 HH73+vz8Pvfdsb/f6K+T/Uf5+Pz697tH/vLTq/rnDwXDxfMjPHxrn/6xhYU65R71v0TTNoen 138crIvHspV9trYVOhvMzFaM2WSY7R+anyCGPwlw+I/P3x9UuQr+qw3yudEUP8+vQqoM9CB/ e1f7309quf8j0hnbB/7t7R/B4d+Dw3N7gP/70iJZukSoSyzWLBE4Jb78/Pc3IX/oIik0I6XA Jqx++j1URb5KLv5+UCP5om4/788qvc/1n//7X9Rn6v8f/sszV/U5yX+U77LR9yV9vPwYL1fO N+pP9fe3w6u6o70d/j/gt1a2Rp3/Hw7yh2r2ofmZPz3JhwNzcv3t72/vUiFT+b80zYyq4a// 9S///Of/+jfnI3UzO7y9SPXX+7dDoYD34S//+f/pv1B7ueopUkD28EfV08O//sc/Hx7un345 AFPjN5UJaCKo0ilRffX7P//tn4YvX5+/v3fj8ee//lt5rGToljw6QEaKhm7R46fJspFXNkyX jbyy4bGycfaI4PiIdF++NPfqMv3jAOBP6PDnf/lvf/z9/zH3Ddbf/JP5xhup8SP8E5g+ShRU ZHxT2t+kKiPORzD+UdV99M9ztdGMFjG7nFRlukW1OlPUPe7t/v+RhwHNmgud/jXhPsiF6Ja2 2QTNd2YTNAZeswlaoDAy3Ka+oqtvgM/q2tv9g8bzIa+d+q7b54NOvmQ71WYNxqOhMe1EM9Nk KqNDZYaCwVRmqi3m82EQyYfSg1IFneu6Z/IVVn1znUudexHJ8euCY12WC+ZsXYlTLyKB6brK zLoSB3NKsKy6dGWdvqKZ7m2RtT2TDx7NV/j5dJtJcq7L+fpQqr5BtlA8Hx7z3T+/PL+++2Op 0/5RfaWEpPunHJdqeoMN6lPi3NdXpNoJf4KRfHDMh9x8f/n+8H4/3uQO90/37/f84f6N60vZ T86nh993LD7/8A//cCjo7+v7dwM3zH+397+pE+Mv/+2vf+3++4dqQfdf/xP/gf7fJk08P8l/ iJQIVy8RrV4iXr3EYvUSy9VLJCuW+N8UxNMqfI0y5dOP+9fnp0eNaP1q//qnf1Wn5t/++cCb 1+e3t8ML/yYP9fP3J8Ff72VX4wvXFJ9+zv/0NyX4b/Lwl7+ppvAncfjb//VP/6oSEzn+1SQp JKXwMzq8q+a9OX//v17vTYP/ZjDp4Z3XD131zlcaMOuveuga/B0igsmh/rsqX1c0fPbz/bef f9/tuh20f1PL7c0bjMNfpbkF6PIVGFOwuun27993/yxg2Yyj7YJmBfVNtr/867GG/+2d66EV h//+n/4p2oPhQw0l/+uL3hZ0L4LP1AT8hT99b3nz/v1Vvv50+Pn9/eWnP/zh/uU3+Q/Pr9/8 j//19Vl8b94PT/xRXenu//V//Mn5YqrJHxWDcn7fsLZtf9KNPgRXhkOjA6F+L7pP/vT+s3yt 1YVcFxbt2T/9x3/9c9CfH4+UHP7b3/524O8HNdgQIOru1Gaw9C7v1m1g1O+NFlLtrvz+KWzf n6janM20eHn/JwD/92RP+Gn4hxotO80EDfx0+Os//cXPDb3c5ksvN+8A0V//9Lc//fW//+mP bhH/+b/+lz/9FH7uFSEDJKXqRl7dMszYAcVU3f8TYLcIGHR+iJaIdN5r+fClnbvtHSD9agu7 2uGjKSMc5yHd8nIqAkamTZ3lyZb/+enH8y9zO8i/+6v8ca+3B7WZ/ANC8PDvDv/uj8b4qQql f4DoD6DSV3yMfkLs8O/6vG/v4sc3rvUARfWTQGrLfZf6et7/weyPDW9+1kmPz0K6e5/eC+6f 3w7/7s8KwKjPa/Uf/9D8hx+qBaTq6gXwD6jSELMofoLo8OP1+8uLfH0//Om3l7ERfWH//KeD VVoth5JAXxL+A0AahKuWqu7NlPTPz83Pb93C+/2h/n7/oMoD5A8I/4GxFcbM3nnefjrwl0fd bw2tzP/Kh/dndSY8H/71L385OFmc/+DvXG3Q+lL9n//2j5Bgiv8AyR8I1lr5p7cHA6z+8aHm h/9iPgCo+AMqS/VBUIraXTRt9U+Hf/vTX/5/h//8T3/94x///Lf/7+Gf1LWzOvxntWf//o/3 b78c/n0BmBrLv/yzPmT+d1e4/vgno20/qBu9Xzx0i//jf//j7/W+rkr/1z//vjj8R/Wfz49/ MMnPj3mlZv7Hv2qK7sP/qaSmVZDTbM0KCnz/h3SOf1bfaEk1lkzd84Puub9SnK/Maqsab7nf P71DfPezKkGoAtRd4fuTMT8cYPkfDt+fet2YAtL32m6qWven//LH//KP1MXM2iNBFaTy/DwV 8E//4x8lo+A/HP75f/wjAJU0ary/y/fDmxJnhfil+H/la61KraM5qi+adFEQZGWYFEwQZmXA 8RbFdbJZ6oi5rHMaAutW5eY7frE6VXNykibj1NvfkXHJUKpnKySOVTWrUV+mjzhW1XGdf7Y6 4pvaXd/vDKrSpx4ChT721BnCjau1LuPw71H/XYe+uo3i3xf/u0bX/x6rP7avCo2+/YOzLHBV 9stC21Zr7Vbx456PC0Nl/U9/+/MBRfRf5+7ylUzkvuJXX/FffEjTmepWjplAMtNW4zmbL6+p tymfK59IH3q3BYbvtqAzvNsScoDe5LstDWyKVd5tAazkVeTdli59rXdbIKga+cnfbSmatvJ4 ueLBsHEP0BPfbRnm6Srebemk0p/2qbDkuy1dL1Z6t8UUFn23Zfhi+EPYTWeIpsJw6L54esti 77b4pYctG4V4TDCvhEyvoul3W6RoSZnhhPsJ3m1BqaXvTMBVvdsSP/gu/Z4GwmpBatdK7Vd0 9/Dc/PL/Br9x20sycQbixfEP0Dn9Bkp/zAr79LPT/dPPL+vNjnOQShD7UE8RSQ9Ov7Ee4LJS DulInEAFAY6yUk5JOkhsXOrm9Iv1xT39dA01s08/+y/26TeVVYmRKmoF2in/0dTuL4xY47IF FYQ1S3FWSlFyycdRGBoaPwwjcjIW1hK1yGsJKHDFQ1P6DAnDhPoCHA2m0Hn9hug5DVo2/EPl 1MMy55ceCI41EBISeOyE6dtvBHKu9F6UWu93vGUQlS0oWvPQSNu2wRdwnKF0NytrRmrOi3S/ py/ihfEW+bPZetAGo7kJsPKqUWNs7GYpSuTk9QdCR8Eee17C/zRoyJgAhQB6jqNnX80g8bGd I3jdpKR2N6uwsSFWv4uWUBo29dhy6vNyN/7BdCzdzf7n82X2C52JHuyNs8kIPTK903UoI8wD HW1ZvDC3V2PpVtt5wwmaWZvzvRoTYrKSbNngmxhcDEbkOKzFoGVpoQ0+DcYbum2v67kVEJRu j1klAXcLK6tlwTPHMY+fw5wmKsc3+X6nfVnu9Gl09619untBjyoz1blRMmbG7ME6u77R3f3K H37pdNxvd/juQf6QD28mageqQqoqUUi302gOEv6ia737xu/en00brEIgYbolMtkRvVpUIaoT mrrk24+hEJW31K/BtKmcRlZNDI4mQWmeX3SkESp0CA5O0p6YyRoyycfvD2bIVcbGDBhOhigV GOgoIQ14dTYFjlWmFgJiIpuaZNCPumNBair89vSuxvjOmANVcx8fn5/0/7w8SFMWNL1NxykR tYXxLk7pz3/9N93V2khIcmTLuuY6LqqvSmPy19fvL/qZHaRDopJ9pUULpWmyHtROsr6/yde7 hwedV0csFam8RY2hHif+KO7uVcXf79qH728/69pfpeq45qUhswVwapiBpwLunw1J8PcXoQZd PxRkGqF7UKRE8/S+c1rAoufV6ef57vlJVykKPdNJaaxxVXaL4UmHdz0+3j/rgDAj/Gi1OeVN C2jfPL3snkyEQ78D8O8PuoPYCFKRXPtc3fKrrgyzAFTlL6axqJobmaYsKy0Vb5px6FH+dv9+ 1/X1VS+EVksFpMn9qpYlxHqZv6sF9/b+/Co71mddLVZZk2LPG4KavseqpSrz90cjAc3sS1EN ooYp+s3LxjVFNEx2EpVM1lr6hJiCF2uVJTmaJYNMGEl7er9/+i7vXr8/PamdTEuMnvuZARFN NyCjZP+vsV9pMWuqRq+vHx1zdsj6hPTqIsnsJYJ8njbKxGom98+6LVHdj6te03f87e3+7X0Y prSoNxWhw4S8vX+7v3vgtdT7iRFWNuVKaSVcdTz66Qc5gzreV0+ATj0xnPsUEEl50RxRx3tU DD8ej+nhwfg+xvDf5hrTp0eYGMYbv62JMKxEoA708JTjFrKKHiw9/PR94zAxDH/jraBN02lC 3oJ0WpygiQj18Ha6r4e3yvLex5jy+JqIIT3URAR6eC+Pr4mACU2EQqntIKu2JqK7wmEUeR/D qb9nYsCjJsL8c04TMTIxgEkTEV8il35TBuHa7NR3v77ev8sBxeImQ3W3gLpkuOL7C6b/QX/B VP33M6q7mOGq1a90HXJVd56KLHhQpmEp1R3cYMGMffEelIGtQFkLxstTRBbMYtWdaGATM1w1 aqMqJmbK7VhczSylVHcsvJ06ygfJmsjN2issRqU+Tk+89KjiwvsypSAb8FNTBhwT0Rt9BwxD DeXQ9n72J2vR8AtbZroUUUuMCVX/v9OtHEpaIiUVwZghUdGS2A0J+ehT1QWFTe/mzI2Zgbru ICoQGi1M4opFWha0Pd2yZEOCIRp6GlQXk7P4Az7O68Uhd4zC721UNAwutvuNSk8B3RXmVkbT dC85lLB+/ZEJ0ApgXB1tCCPuYk3pTiVVo5YYs7E6Ro9NgIXwE6LRVQcrQNy1KWD8ER6Vt6DU KV1fBJKCN6rG4y3TtwCnXs1LPbtJmS/ihbUEi3B9Wd2sW3WpDqYoNQHSnXibLClsGVeDKBg4 9trWsoSFqrvjqMfPY86TTick343C7F1hnju1Vcu3TmemL3Eomd/s6Ue0ALy+PiXAiXd5sy31 V2z52/vd26/3783PZpz0bV4kL8vLb/PLc5x2j++Wvsomn7TatbtK/3r/JJ5/HVRsENepKi+u A1ArPqoDgKWYVQKcRJv0Qc0BCjUH4AyaA/9+BCKaA4Gqec0BWKw5KEYfBndLrJslmoNxK/Q1 B7rVBRwvQm76+C6hqznot+RAc2Cl75oDT3OA+CU1B5d+c05CDMExa5Q6HxxrVFyVYHg9c72A eFuoKXO9gIaXsIqU7g07K6jP09nZ+3duM1lQVR1TWZYqwaCc/q3V8PE5XKRWUEKV0DUtsYKy vIC8vwUrqB2M0PEVBO0VNOHTUV3ycVVCxUT8bdq21CqOzVUJZpYSHrDG1cMbIRzA9mM4Hk/8 lIe4A0snk/pJtwGLt6M3qVeY5evi3/4zXFx8HG99GvTblf7AByLmMzkKlwWeIi4uIOLiEr9I ITCjbQm/aNPOTsP2ERR2NCHjujI2xOq37+LSfRG7FgdeV7kuLsmWOS4PlovLMJuW78c4vR+4 /YcuLnmFtXkuLjPKtPleMRzKyvGWLXBxyb/JZri4RFVWQPu6ZJRuj5n2mkgUVlYgPWZj6f4g ZnSzTfg2TQtu0PslWsaro3JGfdVoRAGZHLPCXl8loM4mBSlj4+aYp0o4CQb5F8uv5JRjhjhw yimqAmzmlCN4Dc3t/9fXoQmiUwWp3BWcu9cudv44f4aTvV+W602MIa9r22/y6e6HfH3r+Zqx VuoUaceJUxxtKkpEJ5Zvj2qe1VK8GygWHOcgjubavHg8a4kZ6sfTqPrMytaOL4PWI70mbtXT 5waUfAoN6aF9a36W4nvHMV5RozLbtXyWlu9ET59LKPlwqOQ7R7Sur8oAESWfQgzruQdRXlBW 4sA9aIQznoqC46pSn0eVfLz/HTwVhcqjNtU2UPL5ZdlKvlrNcimKwD2oS8e7e1BMyQcu6h50 6ceeEea0HH3cvz/1ljJU2kdRwj8oQ6lngXUIe0Wcr9SriqLwV4z+wZYKe8U4ebQxcw3/IF0W 5lGlXoVPeeU5tWKKyIoxijtsr5hAVxCumMlv6AKhfVqph4eynFeeCxPwvr1ST89Syj+oRsXo FjPOTjBdfWkQVY1E6p/2JbidD0LzCwsVc0fVQHHFnONR0vWzzIpFamOKOQqYo39E2u4zU1j/ afjsc6LfMTVQoCdQaE0iVzHnxZ6ZTsOqjrWsmx0rATVtNYVDenq4HivVZRlOwNSrxIzMKOaO KUKHuXJjsHrFnDeGRUQ0+nlerpiLiEYwAbHC2qhiLrqc4kFoSeEZB2JmAoZC/Jbh/n+rQDEX dHNYi0EEY2QQnZbNRZYFhYUhbse6OahQGtuMYKa3SsnKkEArlj+bodrt+JhNnXD/k/v9pjR/ zI6p3QQjwYkUHTOjBVqsf5TSOjRy/IMyYI+fyRwoM9F9TTEX3ddtw8d0gIiAWR2g2dOm+2ev kTOateSlc3O9oRJ6S78x6N0aPKusMiISqg1rtlks35eNkjvBv+oUdV9dNQ2YMr2+N3cmmxmO pOZqVxJupiTc/eyuONauCJVp8AzKNF9lACLKNKb7Masb8Bx+Tom1o7wo1VQHyjQKylKAcRN3 lGkSNnWrxMtXDZiyGA1i7SQEEOIqGmtXsxJhUY6qASe9qXdlWlSZdlGPufKsyrTSWxmhMo1U rTn/zU6vD43nX5+k2iCehAJqrXyVT43sz7txf4qvH7bk2XC1a7dVqFtDArYV5lHdmi0Qo25N 6yKsslzarFGHNOnWrO8D3Zpf1ovXLkRX1K31dFrZurWpL9dEm6V1a3Aoy9WtcQi21q0NsxTX rRFGiPAkDTo3PlFSRAKFmVdYP1M67sz9FNU0lGO/uhndWjCngcBk3UVF2cA2dJvxCsvyvhsW g9MJrfkeqhvk1u93pJtdXp+gcHN2MBwrrFt3c6V/gB2s19AeV8wmCzsHO9gwI6Hmjs9NgIWH Y66TYcibq5i1toTYmLn/SWcUKINiNlZYDjuYp5jtfmFhSQ1t0Kujy2mJ66Q7RSlFXVxDe2x6 l7CDFekJmC2s/TA7WDyvNSLhBAyFeC3L062dgoKCMvT5YqnazIPzs6/Vm/NmJnqPzgfvmZ1+ Rrenrn03Qt21awiDjJdj+6ogIVUgVg9IVya1Jgell0DLGjQKtMmsJVpr84QeXnVMpLJCBkqt CGyML1Wn5viV/2J6SLUqECeHalumrZNVnV+HoutEx70bYfbaebo20R2Woe4Qn0F36GtIQIyn S7D1HPHUhPC2IUbFEfB0tR0d0cejbcuSQxlG2/JSVlTEdYemXVWoOzTp5a47vD7dITmr7pB4 KyPO08VDxoociv1PzNOlriiyukKeLtOuhTxdfZ5VeLo0xX4f9Bv44VXgArpCM0sZPF0lMKew G0GZz9PFu1DnYHqCOU6rELwvV+bpSjUE9LO/Mk9XXzrSPF0QUxmMGRJNIWylSjiIC3i6TCfW 4ukaCwtaFrQ93bJkQ8Yhsv7o83R11cXkTLAYT5fDV3UyT5fud/Mhni7/09gQZY4ZkoSE/U7I iqwJgQKXMM0gFjJKOQs9IJLSQT/RMet4uuYmwOXpIoRLUcf9PVUnjvB0uYKXw9OVv764Fo26 8FeAdSNILImum3VL5Vo8XUdbtlysUnKWz9N1DPX4eXaerj2E70s6EF0ihI+EmoPyDJoD/34E IpqDQnd+Lc3BuH0FXkdYItKxcmdrDiiph7JcryOijiQcYfjW6UWc4bvfkn3NgUnnawYkfSLN wWUZvquzag4qb2WsqTlYQsvVawJkQnOAr1BzIGY0B3iDBZPSHIgTNAdiLc2B9jLq++IsmKoq m0KOr1BupzkQmZoDj7VmqeZAGGejo5oDlBK6s2sOhnrdwjrNgTiv5gCrG0Vcc8AAAOlBXKY5 EOtoDoKrjt2yoO1HW6by0pbbDem/JMdkhSVvwSxglHK8uoQEbnzgAs2BkJZPy9T2dDedZMRm ItlM6ch58hDClgUOaIPlTgphTwBjXmFNJHQUxrsJSMXLdTUHzhDBsnHaDhhymbaBACKxaxxl +HYGcaHmYH59sbataFP5a9PXHNi/cMFZg1hrj8sll/0FLTte2NGEXXPwZTUHZp/Rd3J9oX5T wPpBvv383MVbvd4ZP6SOPSzVVL0bDfl/uTeyALUHAU3lMFuO1iD8UH16unvTPjbdJV5nBaUZ 0YsrOrqtSmV7lS+vz99e+ePoxmEcXtL+cDer5figwqIKFRbFGRQW/rUMxFwd9GYxewErP66w sNPXcXXgEVeHoqoZde5fw9+Gk8BXWHTpZHd1uAJXh/9N/G+HF7Xrvylh/v3/cRD9anmV39SK lK9vR9Qb7oICP/2oNlhQEmDc6znM5qAGGhaEH1lQxhfiT39RyfbCevlxbF2Z0Z2ipzTg5HWL ajquK78h/rqq2oIo4NfApojpNYxE2OtKfy9ZqxDJ6F496TW0LzAreSWbkbDfTZ+ipxivCloq jFvUlPBwXfXtUiu7CdcVhKBqZHxdTfbHcV2Zsuq2bWoUWVdYKyOcdWV/76+rvl2cFYwm9Bp4 gV4DFpLW/stlVSuIwJUsW8SddRXXa4DIupIKNY96DTxojf7TsCISmg1rnhKE40ZZ7ckHsIQM C4iQH3iBvIgbW4ZCYbNGuZNKf9qnwnwh8qRNUqtl6oCuGxGsk9RNAHqFtcgrrMW1IyzCcVP3 /kK9hGJKEPp2WVptX9yyym+ZgN4X/o2z+7SUkjHmtgw0UxSF+qIl3CI1HrJGWgaLpsV+ZNeg axrXzPDFtMD8G2ffsrbkLYsL3pi3qahdutkpwglwGuIMotdUkVr6zgT0m8WRwqxuSobamuIq Ppt6bR7pJqfUyzIqO+MHHzirXh8E552v12e0pRqC8+bl/u5eO9Wru9t4nXLRf5Y9bD6KuJ8X 5xzsiH9agkgKXyL/HLR/iXMw1O+bOmoanIPW35xzsFNnsFZOBrH+e0iQrAqAqX8Oau+ViiBB YBJf0uEcHOs2L8vVEXypylLXG1pCfrD1+7byqj8H/fRAv2/rtz7XC57WLPn6fVuwgpkOhthe FIy03lY33VhtBfDR5yn1ZQc6tDPDX4b9M1SuTXlVt2LabLcwWKPxdQ/305LY6k7bT2cYNFV6 XCHpvrFpNzXpmKZqCz0DjWZUBi3LSshQ+w3DazVVtMYn/oTCjidAyQEtUCTsMVmv94XVVKqj oHj84PLy1hwDJrA80lS1FYeFdUOEcx7d9BM+NGa+ACwobJGKdskBFuTV63zI+/L6rDW0z6+m FBMLqrWBZZqWSO8F89orDOa0Vye52ph1pjKZrj48P2vCMCg9hXQca8CzYo1hVcz5EDBcjHx4 vTK9KDJcCBZAjMElIAIxUGuRAPvpMxBjZPqZjuzJHWABCTBq4yTAKv0knxucgBjBVbt1aQFy SYA79oELEZWkgg+AZngGYEuIYc1SyoWAy9HkBhERVElhikDC+iK5J/aW3NjrXBkEEvFPU8wl /utcqI2TAOvvYIRrwkYFoJKsDFyBZ7Z+/9Njh0Oc2gLWDeHl1LKe4tfK2w25ldAx+wZjBglm XGjNadAyq5v5JMCBy/e6JMCoPZ0E2Mxz8OnR0/k6SYDNQMxMwFCI37LzkwCjdkUS4Fg3+zHz SYCR/zoX8l80Qy2t5uTMa8dxEuD8p7ipTyIkSP6YXZgEWBDr0MhxITgKevws5jiZoQmhfJ4C WG/Cxwg+SDnP76E31MmwO3BnwMqYrJOcEDstSJDxcrQgtGihNDXroemE6PubfL17eBjiF5Ik w+d/bwxhjDWXjbo4PfK3X+5e+f2btG5BhsUmeffanr6Y05JBL+PLq3zhhm6ZwDlB3ZDIuCZt q9dE87NsfhmcQAZvjo7SJU0Gs9MXfwY3pz1A6tMFSMFtAqR8FQ7YgFqFVfWZ/Y045aAWkQAp nT7Ktk+totsVBEiZdN7uAVIxfyN4UWoVdFblJvJWRky5SVvu4/wcYpUF4VH9Dx5C3SZsMYvp Nk36BrpNVQ+I6TZhi8Sauk0YLhdDBgvt5RLri7dcDB9pYrlc7IEzJe61Or2ls1y20G2aWZrT bfYWRjQ0dEZLMRvR5CsbYatNUzYGdTifewGO6TZNXs/06sWCVB4FyTF2YhgKjtUyCXERqGui DKidQIbSFohS2/+Gz44rSid24q5lLUl+cSbl8pHZbLdkJ8ZZYxaKRruEnbgvbHlCWFinXEaR lqUS1mEn9hqG4gudDeF/42x6CsPY9EaUy8kX/dDRln2MnXhoanoCQKe8hMluJtsetmzQJQce lqXfkBzi6tSnwXh7bZ9TlKbiTgdFmATcLawc9cG5us1jmMfP8THV5gmMzWbXPkaZDAU+P2Xy 5npONb1DJqMe6bWxjRnitIKsangb0Y92eoq0fqxSF1qtrlK5GtNACOa4VZmSuFCf2kJwTJ96 otKHwRqwoL6GAXakvoLLQotc90qb1jdqjvH6u9qTtL4IizlVzAUzf/yZuaZonQIe3+7V/33z 3pkzYoGT7ahI2Wq16Utzr7rw1I7yVGiNaZpJeVOG6PNru29Y3VmZHddXd0IirkXfSRAheufR 0ZXy+d7sc38fFOVJuaQC6kzPOirzQTZ6NpqX78Y0ZuxV+/t1txiYibZ5v85XB4GoovTY+3VL FKX6PTjePUd/zsBM0jRG6SmCdOkEkLntQkFgZpfeObvvitLLBmZ6SwSfVVGKvZVx1REnEp8/ 4kTSdMSJpG7ESZcOIhEn5n6mdsf0woFAJBYOGhbOpFOoREOmSBg34qTAuIZsWDjWeXTRiBOk 7jMpLmruL5wlkZfwRJUpmIs40YIVzHQwxPaiiEScDPW07kWetC20+YsQaFFLvSwwov5r+186 4mTIe0xfgQ0fUCfzgRDaUMlmho20rP+LdtOTvqp2auoJESciaBmYYjZxARBh5VFGKfM55FxN lR00ywF0Y1VVQitosEedSZc41auGG3NuNwQXuqnHCvO1nND6NCjdzhiNf4yOmRoiAby8KCAq WzXiBAcC4BeG21qJpITpib/yiJNupXfXTnX71mi6prO3sK0jTIqzYgv/1eiYEZa3MuBrctoe hxQQ50OKcXO6kect9L57jc9bmHYtJKns85yVpHIBpFjXCguOkVRaCYnnLSZZiPo9LyGpvLbn LZCeZYi0qTpAMBGwo7uEZ86NGEklQy2MGJtzSSpj1cUx3XWRVCYbMg6R9Uf/eYuuujgMayL1 Ot77Jz9voa9D8EPPW4ScEqc/b0FqEPY7ISsG/1OM/v/s/VmS3biyNgpOJYaAhg2wzeq+18s2 q5pAGEgCO8NSCslCqcw8NfpCwwaAO9isPqS1zv3vTiEI0NHS4c33NcPKdloZorPpLaLZpL3s eaoO1V1bcuneE6SyU5U2fV9oLKG3mPdXNGaXpLfYlOz4sjpPH92h9ORVzsWo9F+f0T78L/Mm 5q8/PmbfDllTL5/4lp8+8PvzuhfuEbxd3QYsMr8dEcQn0Yl63SdByGGwSIbeg2goz0yrVqOo 5vvGnntQp3gtKANgkdlBmfokxhP5JfdJ+HL59EnkPgnCFRqNmr7/mj6J+qp2g5wxFtoN3A5v sR1O4h1+PjNmqOH9F7E3wmsVlCxuvFkxapshXgJ7twzTcMts4qtKBkwHbKDG61K/9pY5yXRA CdwymlWKklubDqZZKqFAkguFr86rZCpwS+3UxrYF8a3XXKTvH1bsEGldvwmmgmn175BMkLqq O2iygGhLqWRWtCtPQOnRGh4k4Q/cqN5QSleC3o/dNfYdlEVV6FEowsMEXzA8Y1qqmSo0b5BM FcpW8s3O9aTcCvCLn+ufMTzj/hThyl0Sxpjun++jOYHV8c36dE0o+mbpnrA58zMubyOYLpFO AI93TFJn1FLCjplcLuE37ZjFMlV2ovi2EJiuUH5dajzzSWG6NIGaEGGyATvmFpqQn6WSE6Xn S4rRPAtlmK7akMoYYFtd0qLKmVTjv9uVTCowtaAATHLSzzJMF48UH7MLpmsDoTF/dEsjOR2m yw15VLAO09WvSHYQpkvHk3dRmC4/VyfCdE3zDB7dVAkfEKZrGoiVCZgaySW7MkyXl+xSMF2F bs7ZNRFMV5jeFlkruaj7ZxOB6UpaV2L/LWUNpmtzzC4M0zUVAFELA3EYpmuH2pNX8h+UlWw2 u8+fSF1nZLD9Lkhdnw0L66Qkq1Y0Q1gDP77aUbU78tX8fO//estkVmw12efo2HKmudsfH2p4 +/f1rw+t7Tazq/fLt29//vw+7a+rJm6d53ek9rLuHYjerfcaOfca7TyIbdlLpmvKg3Pvw4r9 7WNBAmNuDxUX8Imuzp6JdvKTxdWUzxwtLsPjjs5aUjmMPtW395/69ePn+3sg1RvWkk5/N2/n mY7LBlrrmitY63KbBLk26pQyg+g7jaBO9dpwGMA5/Y5Y64SqaEcMgjrFDZVtkhOSyQVQp0L5 STA6v761jrObWuvOYrnLIwHIdczfME7692a5o6YfOMJyF8qfLHf/3cFyF/7St6LVItlXuE2P oLlWJ7LcTfP0uVnuQi8uxHLnG3tIlrsg2RrLXXjiyXL3S7LcgaVxZdf3s7HfszFcwbo3m+Jn jCOz11NlxBB5T8NPqFq3AsPNteWyQm8woa1uhoNYhmaksvu1bzCfOY4smqVrx5HNq2QeOtW2 ujcrXBzlxrYFCQs2SoyeGOhLkkXJ3PMmSBurNlPkyWi44BAxcSWOLLxf3u/4BQfJ/sYOuVvO jCMjt4kjyw98glim7ARfzjI1L9XMMjVvkMwyla3km53raXkxtfhXOdc/YxzZvckeHwjmp7kB zE+zAvPToDA/rADzYxq5QPPExNL2qKmNrEsbh08bZ25rhVhacMGEVQqnjROpAE9i6f9XPksl mJ8mh/lpIpifeYjjTfEQxNK+WzuIpcUwh8VljybIPBDmh92EWFrpDkp2IYXo9sTSgxJUYrP5 JJaOfxQsgLwxB/PDiPq8MD+fj1j63twrjeSDi/H4/nOBBa+TmIMCr/QO7pU8AD3RMFxcby21 admsYawFrGd/qyYNI2trVs3zdwANI+Z/gBoGNZztMrmAL8Vu1bzIvRICdwlUzc0UrncE9WcJ fr9iwHoXI5ncknvFzhJicjEI329EeQKoP8JW0LQWrHi+UjB1RRNAISYTVSjyunPk/EseWw++ 4/GjyW8HS0muSEVx+XFLO1hKOPa1NGjkPGApiYPti91ciZwvPmGKfDV0GIib7Kgx3knaLH6b Ymw9tjTCXp0LyrH1eQGiFu+OnN/RzUk8GDmfzCbGUlJsrNqcEchSstJYsVfTDwTMwzGbH40b 22Ip2UjZmCU7wFKyXyvbwVKC3pg8XcmO1uMxczQWhcbmyPk5XlgZOKr5IBZ92BLu/LxX6f6C aS7TawSifGYFKj96RfzR2FZPt3WevIb/NGxRoVSUPalQ4gV1AhXKk9vk+vQkh+PAbx8l3/PK R8n/GNmRf+j/fbX3x9cpVtDP0eXj7D8t1citiDVoTSRza+dD26v5/z7U1zksvlu/1v+ugeAI q8Y1AsFvzqrhA6tVX728XJV+WDIqMfphW75Y50EguBoAbEMo756wDQ8QCP5grBon0w8fAL4e fxj9MDE1xeiHffnKdrkU/TAxlcRMYMSFW56wXRi+XaqSCYzH2wXrS7ZdFkBsuF1YvF2Wti6L 2YBxabStbJQR6Xa5hQnMz9Ia/XA8cjjFadJaKfsaT7vP1utSMKIMYIFCc10gSPGJadZXrtl5 JzLjgR6275+jzMXGRuNBzLYxZ9sDycpp93kBzLbftsAEyRCLAMy2P3XMkmz7ML0tHLOlLmh9 +o+iRQAxG+Zp97511W46yvpCQDYhWm+OGcy2R3cAnnYPs+1zUVeso+uiSplR04hdjsm5YKob /rns3hmbHDTmkoqIlHRZRUI1jRKRxcsL0jTL63xBv7I35+wF7l7MZd6Y86bTtEpu6bN1mag7 FIsdLWDLP3F4aQeGzxM0CdU2iAU/HzO4nWIwHChIs/yzrpP3pzQriSBMicI6CwOBc/QcMoHd nH74LLuVHoDdqh9+TQCEljZNC4b5C3N1tbMgsOId2Wr4PZuRyX1lB03urC0D87ycRUiL21t4 jlssfMhLMFv9q99f/9ZW+f3mlg/lzqZYlVPXTzEFdW3fk6XSx1/9q6/mg2yLm+Swaa3TXLJx /DyevDcwO5vKFHRQXuKf1Vj1RINf1I3fkqj2HkjyHNrh6ivY4XJrA0HscNJRTqxaFurDSPIg 7F2zqlKMF8LeB9SwoKx61ksJw97HUPkXYIfj7SDnUyK1w/m2FAh7D+XiV09n+oxh7/dGkpdC eVytcJx5v8Lru4+l89ha50e8R0q2UQiAqvM/k9HotBXxHreVAqi6nw9htipVrV9yY5x/R1OK eLd/64Exzr9DL3smeR6NeB9/XDaFPUOnPTO25UNCNWlKe2agmtFpz+R9mfZM9F27ScS7C/3F jHF2UzT1Mi7jnumWPdPNe4agYAsnEdtOs4Qb46RsWiTqCxTECm+teMYRusxUKRQ8/s1PTIt0 w3rgfOG4ZFwmDHr+A45eXs1CH7UpKrJU0jHzYbVxCLzcF7W+YYrwDcbktP5arXszaJMVmKE0 ZjlwhjNlnyEZQh+7CDKwvofG17Vuhv9Zaz1+PoIUwbqZDtEA8QuOdPNwQY3tgGQlLEj959lE dn5/QDW3s8sB67VZDVj3mzzcGL0SHmLHex/A8TDctPcGVn+YhDhK1D71AKzq/Qlx9h2yrB4o CRLiPJxsifd+WFMPqNqvHgjToerBmK3V1al68AAJcSX1AEUIuIV64GcJT4gLCwvMNBji9Nwp JMSxeogMxpWVV+seqhbpAjqR934mEMhXdtoYFcMwr3mwCPOjbUWydEFeLCFukApItqcgAx4v qBYD6VLVYvAJfeCMwr+b+1SLlQlAVYtR1Pvz3i9DtEe1uKSu0YAFkDfmVQu7RD9vQpw/C2zt oM6MusKr8tjBTgGgZNUd8SnUk/aq6snkWn5s6KKRhRBAFxlyMObO2fo0Zuur6r6d10kKcSFr xlWLKSbDkwIPKiYOughljXQn6JI/cDvil+EWFHjzKsmeRPLothvbFiS8rgEc3nsamzfBXDCu /h2NTaG2G6Im0EVe1Lq/8gSUHm3hQRL+4L5+2tQPQ4HXQh8OvYIPJz/wybVjqeelisdSXwZU +wLnelpe97/4uf4pfDhngWrnTlHyn7/JDZyiT1DtJ6j2AX0JBdVujbTfE+LLd+hLuCHnCar9 BNV+gmr/6qDa86KRTbtIRj0KgP/5J7Sz/7Qu7s+IpECQNlsa819oHT8quTuRsickSZ9IUqbT uiZrjKm8bpNLRlDJ3KND1hinWWO8yp/oSo1xkdWlNO93nT8hSo1VLOsEF3lBPog85xGd/1JX Wd1aZHXrLn8iN5rPf2lyyRqZFbQkL5i9GLiCdW9Q7aG2Z/AcEuyCtV1E8KvqnRHRRV67cGi2 lee2A+rJvzPNtVpNC11kZNIsYdy7fWcTb+/uPLconwyga/NLmqj25blhfcl8Z9I4hLi9UE/R WBZUrouga7etrimjaWjNdU1U0SyhoTXuTyrx8gy1YJkGxjsJxrbUmCRw2YD5yuaDZ40VMoSG uiNLbse8kNInGOJUmh/NF8LUGHUJ0b3Zxo1aQ4Xa7ndhzBKeXfdcFRnPTIlGGfU3orlih9C1 U8kokjyWrgQJFw+UjDFK+n24Ufn7C5JVEukVPiNsAYMqWuIg9hKcoribLh+nIFmaCphPb/gt jY0FiPaWCrIyeaD1zazFMZOgcVGJK7KH5CFEsiTRcO5mK7YGojwBy6LdTv2ciZaL3VwZby8I lvq5Y2kgg4iMWdu3fWk7tYW6469RQw93flGydcblQQxl1Nh9FueDChCsbg+Dleqi2aje+RSd Us6cEus5c+5bsFK9r65OkXzuAJye9ee2dpSZ9OXtXasPV/v7H//n3iwdsS9byY46LWuw7THU Kr6OinP/tMHbYTr9LgmKJ2UNHp6GSyTxnUeBfV4u35Mn+cmTfE5a3gOx0ai62/BA0fblYFre jPeTvqnyrtODMcQz5DVQ5nKXrtSyaud49cSl6wjR+54CeCxf3plfPVTnNJdu9Vuz0TDeeci/ oA1NWBF8D0DWgdi26QKRb5jxx/MN047PHzQczuBRZxkOJ6qOvkjfxG+wYRYgLJ7JNbBdGyar UyEb5pIAWVZ31F2yYa4e2zbNUgkgSy7gzjXxX+H0bqxljwBTA1sfwIVapierykqLbu1uPP1S w0Zfg+joHDo6AnkoGB35SGkzsOQaH2+tF8RsAiSbZnn838V84ZIwBt3n9gTnoeqrIbZ5wUEs vg4xtpZ4eeKB8KpuOohWCV1pDEgGZC9LVhRk/HcD10r+OnSdocw9iREMZj045Ax0aXi9OO63 4ZlVLDSWvGyJHsG6ebwAb4zpQcB+F9aK7iRTZCADQgO0Z4jGpKN4ZBwECDpmXsNfbd2Deiyq FetV3delU6MSifHNHkGDLC48ZGnEUlQ0s/X5gq1Fm2fyTjeCRqvClgjdtOpiBUcVNRzC4Y3T fODO7xRviFyLOz19ne0FyNrWevI6/nuyYiyjzbq1zJ/pG8YA1T0BfX5hQJ9BrhkBuFw1Argd i97hGVEPB8hDbwPIk99vCMZD27frN38ijgLyVODm7480skRApM8PMxEUvMjQPr/IuLaYZvDm 7wO8CsHc45Ga3/w7VZl2qJ/A2PnNn3CFJumk77/mzf/e3HBn3Px3hAxND4+3Df2Jbv70QW/+ 9ISbP73kzf/B2OE2bv7Jswa7+RfWSabD51RYj3nzdwTBXC2NuVmmtt91f52b/1jegjHLBEH5 2w7d/Onhm7+d3qFL8A6CZPMExHcm0aR3F+qM5ftv/gsX2VhQuvlHV6XSxZPGkNx2h5qhTDU3 D/OWTQLUjbT6revd2nuP3PzjuXIuvqKRYg+jXmjc2QSEtu0NyS22Jk1qHHGOvt0TAG/+ILgm KqC97DmCNB9khjf/vil2s8ApGfv/Duwvz4bS12hoWvAFgjMBbrhozDojjmXpHpBsu7HNgufN /0o3f38Uuiu8v1i/RtfrRrs7fFt2OD8DB56BA78Kr5a8YC64vab7tBbkNtTJUi44n2JcV4mC FqnHczIzH9jJbIVs5xsM4NXqa4jn68urp/kAzQUX9zQfVFc1H1TZznho1D52A9Q+toLaxyBq n7sPFFH76hXUPhaI6fei9okCap9k0gyV6hMzQuwduw9qH5rsHWa275x5I90410btm2aphNrH ctQ+FqH2zUMcb4oUtQ+sLFAQ1Q2ofdNfJsUcuazHKnuiw89j6bq1jdpHlK5xyRhL7i4pat/U OnbvcQsyvugnt4uS/7qE2idMDyTbU5DZJHyDCGofzVH76AHUvl2CfHrUPnp71L4KLIC8MW46 uyTFJ0bt+xSwe/fmC9CU+9D+VVJ2qlyY/wKqVojs3ato2PWumSBjamyiaHj086rk4FtYMiL2 AFoP9YQYtEvRCO9IGTeW3TCIqQ5gD+BVKbR3djymikYQbUvRWIp8ivPcVqqht2aMCEw0dDNl B+Ia+tJWjfpkLpLiPI5Xomj0omVNf2t/xTRLBUwZNOcY2Aa3jIU8YaszSZrw/ARre82Mmb7v ZqawyxrDEomnCV/qsk6pimx6UuJHQb/T1W9yFwNGMmrQnGMjJdx62aii1tpxZ+WPlp8wxczH 6QQ5SzcoPjoLEvW7Mo0QQFREoS3lHCf+CpRDtigZS7xucgoznWczIledp7fY2CYNKJIEva+x tFdz65HsqldNOSuZbvQq5ZDNJ6Ak2bRZAZoUSCRey5fO/g38FWBUc1/i1Akk57jk5ZzSKTVR hcbmRGJszObW8yd2dNMUIARgqvER/2v6T5U/kaPdrI0ZpJtN7of2695EH41tLfUkNShrJJyN W7nCNGQ/lpOFz+H4bBjI1q3YRrauXV5TJe/zcGSmLi/aR7sVbfp+iEG2rqHkcbN1K6Ur51Qw X37++MO/UL0Pr91Pu9adx4QPax6JquPU9Vd9HV7fbNWfr6EZZ67XtgOuAX+zKL+9r0zSwNcf b/b//W/xVPhLjQ/b5EU52qY2Lk/1e/9mu/Bu5vTqyiWollNkf1mK0d+Q+/P4nJzoF6uJ9F7c D20v3//7UF9n92K3fnH/XR1qNXSoVVdwqOXXeoI41Cr3FbmUQ02omslBAUQyaUwr2h5c17Pr 3z5wZVW13RhbGzvU8rayTNxW2M6+vIBM3NYjzz0dancHV344GqzbEWTqvkSQuZMBK24LI8i0 x/NQ22/7C+ZLUysEmQolyNRFgsyhR/aM7jpRaUb9GsT2TPUCfGnKjkmRIJPy2vCXFxiS6/ry ch9fmgsE61Ffmj2a6oVa73YmLr1FkJl+SeOgwlbUzhKVXKMrgl2jXRYEreqCkyn+zU+UGbCm XyioaJcWzNPPOPCHoVdCnRFkhk7gom6l1SEEmUfjLjcfXRvVwZi+PamxA5JRt1WHCMVveu+a CcA9UWNLw10mFDSlJpmHRA5c7x2zGOs7DBHfNlNddMxQithkJVyOxeoOBJn+GFhXqDlZU6h/ NzaqBwq70TcIu9ErYTcaJcscsLAbDzdIaDnshnSb3rBl+wkjy2E3g264TFSF+4fdWFWBe3cY UBVox4Z7cGkPa2E3Og+70WnYTRji9AwCZJmeG5OIjq14dhYOs7wA9TltqxnDnrCbrpkwRHPJ unIWPSJZrLsOZI+asSvsZpASSrajINOIfIMYWSbNyTLpethNPJsL06lLS+isGrD6uYcTsEj2 wGE3dohuHXbTggWQN7bQhZ2rZtyNLPPaqsJZbE0VZGu6Rsg7DOz9vdmaiKx6jK0plD/Zmv67 N4AX0yRwowOuSZzI1jTN0+dmawq9uBBbk28MZWuanpj+ALuZDNHSGC9hUp0iGcbWlFTQCkY8 hM8srXU8vEKKxVJgnzC81WLJ4cS7GR7+nGxNYSXWfWOV4NLWTybg0diasvG+HKDYs7FnY1Nj uIJ1b7YmxpVwgP0+juX15/uYeszq2B9/JkfTbDZYPKJReaD6QEw21IgkxTCpA7w7/ncMcGVq q1oQitLyugS4ciGPKAxgzmWGilYExAI9orOJKw1gnvmxrga16tppSOYRva53J5qlEuBKx1bs 4qYQtIdDE0ZxpNOLYwqTaULzxsqBpQh3Tl4XzPr+YymNiXS8FLmoeGPuNSV2mwLmLN7NA3Gk +0/fHXGkqexdd/KYuUC/7JhqCbo0VNsrA4YXDmImKQIbWloJJcqaqXXB9kSphh8SR7p/zHbE kYJjBx0zH9Z4eG8OuWVqHl4p8hE5bICLJk/kazQOj7ayS7rom0I1jRJ4N60gTRO7M21Bjxjv Ymsi4bLYWGwTDjp0FxktRW0wnN6NHdAs/0zvU6oibR0belVLEVyZLBFkFGRfjmQiGVvKx2vE ODqMqQiDyAtSaVFaZ3sBV3aoPXml87iRzgtVPoVY6LRQZX+cYYREPtS2HP34CUOcT2b4aQbV +bDiv/75mDo7zCPV0jXb7dmh0edx71BJ6mqBz/Hu7X/Un358hVvAvCj5DaOiTwtubvueLJU+ /upffTU3lVUxPPgu/El3CYSWSvqwBn/mfdXqx88PJ7f+MK/9Xx8/xpEqs3CJwQNG2Z3yQ3/R veu0XT0/JpwouvLiXtLx4Eze6zc19VI/o7c/W/Q2wqN0DTTl3IZBUDgkc7nobc9LpCiAQ/Ic R1yXwkuORW+TulajPQTwKPH56Mmjt61cDMAhhXLyjN5+8ihhaMo9xBXsb4qmDPDDHgBNeY1H qYBOsMj1q/IolQjYbQ02kJsa93byKKWjkBpdUB4lNFAJEkSjaMprgALZkxdDU7aXW2CwiQLS /d2XqsV3PP0Q29J+NOWxdVpzwVQDrBE+Mr4ZEkHAIF6RRyl6HW6Py0GEIyYYhPd87sx+SyG0 zO6zeiVoyj5CLkMVPi4ZXrcwEEU05cJ7TzGhTbinyaNM1bz4OmQ2Qy3dKa5raW/M8Vox/MJo yjRpzN0CkumtWHHMNtCU024eQlPe3F/2eWVkV2hsE00ZI1YqmB3XeKv2Sba5inavs/1oylta T17nAdCU/Vkf7q3f7b3v1cr+EYxo4opsyidiG38SLOUbIyM/bQjnMzJdg4t5DyPTRW0I4RBU 1d4rUXbO7bchUA1tCKrWrRiSFJVUrm6+EqXl8gmp/HgZ4PdmZGrthnZW46/6a+8dT5TEJye+ VeoDmd+e3EG1AC1hauuEvTLDjyfv6EJAdZ7O5d6NmA8WngiMjKnuUBTlyHu+uleAbnZ8rzDE fODfX9grVbxXInUuuPF/TTImO0u4+UAJMrRwFKInRM1MA54oNOYoj8BUT/9hclzAUAyCGSah 52CGqWA1mMHFH0Sj+5JEk4S1NU/c+L9TQQzMuDSmVmhVRCZZn144Je2I3ApmAHQuhWCGDk34 KjSmaD5mOcoiTcHflIs3gI1N/czHjJXHDEpGkmCGLg1moD1JBWnrcjDDJNk4Imh4B1oQvZ+j s2kFkToThAp4WU3ejwEf7xaEsjp9f1fhqH+qlQyOSBJegsWgbUgWj4hJBOFC5gNhEGw9RJCm 3O+yZJEgLBOk62gmSLtvaTQEZQbfGggcfMKNSMdSQUi/ujQa3yp6OHoYuReaygFj/sBRsNKY L1igYFfiyLIJ2Gc+2FB4wIXWfUoiV/7b+4/3V6MDrbB35xcjOfw3BobMbAXMnBg84E9n8LZe ErnxvvOQAO8KI3hyhM/JsS4nRa4cjkE5A8fPHVrOzOQSQe2genuDNze9GyepdrYmvmIuOj/4 5VMZuk5mDG+YVcyctHZ69Lc3H333f1M00kqMDSV4jE1DVmNsGiY6Z8FxAxpWg3tpAEzxIYba x+iskaM9LV6/GYlY1V/O4jV/e7NbvL+CjOV7b/EO27AmBGT4CMUNle18i0+fX9KMIYmYLJCI iafFC7N4cXZPixe/qsWLZzvjolEzx1GMSmavR+QgJw/KQU5OiJohF4uaKQEeUsLr5SZ5O7MX 2YqaiTu1K2qm4P9OUARJIWrm/hzkaWM8MJGZIYIimH6IDe1UDnI8aqaAJ7n9OtTsRXZGzWQP cKQxd6XnstTY/ATPZK/k2tKYCsbfGRzkVZ9EzRh0EPNhXrEH4XWPR82g712dER/OXpqAloD3 Zh8Y2aSbleAm6THZOp94ON95Z0oTMPTl6Q0rIQNYsNcYCEa6PJpfBIqtH4ua2dpfHuh6qHq8 sc2oGYfymWSYnsFBvinZdmObBYfMXp80auYumTT+SMKjX+r+CtEvN0uC+V1v5RzeyskVbuX5 3YMgt3IptuJQSBqbf8qtXFPRUCQOxTMX6GY6hnZRe/sfNzAOhTIyLNSReS6LP+7yW7kv703/ vJU/XBxKTtZB/vM3uwFZB4ACrPXQMb21RU6CAqxENWd9+ZfZTzxvWFNnXN6tkfbEsY8T3H4V ZEihAPnUA5Jex7UDzW67QTQVBBV2zrXKqh59lUMBJuXTTpnkipAyr7JT4v7HOwWUV/8pyjVf x11f+lp1vC9FoRyBAmSDVCoHFfbv74Ya7BT8Ok4uCAU4z1N+IZ//ZBLgOdHwHLONLK5WZmRf 6b7K3dNzY5NKPxeoyE2rOkO42NVY3aqujV28WQHrrKbARL8GK5yubppJpiO0CUFJNQwd7PfW FW6RTICFVtqpL3CvLI11Vj1jcYETdRDZFEmaUwzOj0ZWBdv1duBGp4KYMSAH2RN5YxoCHBLY WD4jSGONcCjNolxXd419qhcrjeWjiYuKj+q4vUtj1mfDqwzPJAPoOciYpUtydSUA2UsTQFLJ Wl6D7JE93bTX4bYiQhQFKctekmxIJeuaXs+N9YyaRst+KeDNYDdZ6dTQtQCdgPfg7b3JdN/0 SuTDW5cDNMSO2UQlW1pP9qZdKsOQ44cXx0w0LHtCi2zOcp7fcWrqJbEnlmxzelcVrHtTPTEu jJoxccb7v9rh9OAvR50eNNGyJpYaLmYcwLx8z31kqhM7MPY6Pfx7mAFOj1Den4IDyAta1i4i c6wv2X2EDoTTwn1kdsZcCwfQpQozQuB9pCJ1ZK27JcuTnaWS00Np9dJMkttLtmENEq9bWCeZ 8pGzg+u2YjEsGm1k0wz5AkYM+OEvJrUJ+jHNFgaMJF7xoICFE0mmKa9yVGnAHLC8l8LVBpbS VDA9VpiAbhwi90vHO+J6nxqjrFGcGpMoHyYmjh99OxgbfNbvheJ992zmXO90lXt86SbG9U6L DN/RfG/7KYJkNamAIHOBnx+Bz+bY2PEC5BM/CZKOmUBWcXk7RWMWuN6TxmL6apOEzkdThK8z j9GZ9YHB6U0KEobvbDm3RUGwzep/uWRYr+bxjmRXjWbA/4lDkQY4z+xRmq2VKHC43M3wKHA3 LgVlFE+wNMpwnnBGymO23itkEItjttfpsaXz5DX812QFBFCoVRBA/3WIqnuGkNVAOX9q/z9b XOuDS7otcq2fCV14d6p2tzkiH8+Xt3etPlzt73/8n3u1dHGjbIW6+iT8REMbDD+RDs0qgOIn BEI8viqHWrA1z59Yd/zdPi774ZnZPw944RNw4Ak48FkdvQ109F7Di5VbWwjm6K3IhhdLHgy/ Hg0oSTTpeCF/AY5eLpqGoYYVN9qTmyp29Pbe9wwBBxxFNVmWWhZ+LVUrGiT82pXTZ/g15uil +p6O3nuTybpAJAUDkfZYIg+EX5vxBzZM+D1c+LVn2nzA8Gsv18Hw67HOxUALx74kG6ZvTB1F NN7OEulnaUf4deWMNu0Z4ddeRDA9WdX7hV/jjfGRkfbi4ddTN6nuhlYwGOTMhr4aZCwIGMQD 4ddFWt14ICBoIdIYiDqOWwei5p3Zb+8rhV9HMdUr6yx/NG89AdPAIqajbMq4wF/Lkn7rjN4k ayx5K5Pb5qaT2b1YyzXsd3k2Qy0HWqhq0jEQzcBAr5KdvwFaiAsS6tKWNNHepL3sMZdDkHkz /Dqe70Ph15v7S9py0QN3+67w67AlqrXwa/8XDzzCGgnNmsckO76sSutsf/j1ltaT1/ldw69v ncp9q/DrsJFtNf3uLLzhYvzP2/vw7R9X148K70qv/E1v9C280VdXuNHn9xaCJlTTPRTV54Vu x+XJjZ7UNRdipgDcDyGI0hC0VdWgEILTUZnf6EM5e97oURqC5qY3+rM433MTGbkOrwcMSHpy vj853y/A+c6IrlTz5HwnYNqXxu7N+R4vloE2BHZz/IvICqqlYHAUwXUk+0U439Mn8uD48Git tZQylYz0S9SE415vlFiuZFNVRLJPyvke/Z6c78/Gno2hjeEK1r0536Uwwl31VP/97fXNRRvY S/R8r039xrtwofaEfKf61kjl0bCmBAx16B4Tl2fwzvYdHUysi/6W6FvhGi6NbnN4Z9oweyci M9Myco8RQ+EeU0/6VvRuzdsOucforquIHqqQGjs7WmKj4ahv5eXA0RLZFQv61kXYodpGGUqq Sae9JfW7naXc0RIvLDDTYIjjTSEbk31SF8tIbHjfpmZRlW6HGjlQpu80tHIuEzPSPOcrO2us 9clBYc2DRRjJzjhjLF3aBuQBofxNsagFmzWt66bOs218YyIAp+eduMghPA1vVMBr0rdXOtGp HhSrDKKGFN+bPRGJKlz4msIVJFiXyIED9J4cEaZqMMncEHGISXTlr2C+AA40dshWfuQDBuq6 fT7V/f7xzZnKv334VnzUo4u3q8t2XXcWrFtJOVmzkvoN6U32VuSFs9lDtpYN126fOWxP19Uv 37453FuqM88Armvcm4HygXSNhl9f12hEWdewf0t0jYmJC+oa4Xm5QiXB6raga/BM1xgdhk1J 16hk0z+crsFUq8cItFTXaKuOczl9c0abaTfrGv4/12w79LCuEc1SSddoOIEzDYZ4Q9eY3mPS w7G1R0aCRkYMM4t6UDYsbOsavMS7mDW2ZFnl3566Legac2dwXWPkPURFPaxrKL2fFiH+ZbEr vkGqVEflbCbiTPdm0CYrsLrSykd4etQOW6V1nK88GCZaLA+oPAGLZFZgrlQsKq+cqAe6Gf4d PQpajyuiFhbYzTBEAzS1XFXXoGAB5I1x09nNomg5mufBdY2w00Ns/9uHdo7UTqyjhN1Yt7g3 M9UD6RbqBrqFWtEtFKpb0Fi3KOwCxI7B6oJuMfuN8m9+QbfoO0VTmqoH0C1KAaNtK2nbi8mH e0uaqhXdQuW6hUp1izDEG7oFasfYjNZyt0hzoh2DTwxPhVU32zGGGR8WLsI13YKW7RhJY+fq FgpKdkE7hsntGOK6dgxOCnYM9L3ZE/exY5ib2zEYWACYbkF5/3l1i89nx7g3J4Cm3BOzrGdh K5JkYe+C71xVOhijpBcQL8eDEVcwCGxcn/NHdFjqBESKSpWUDoooHfYdS1s5N+acIpaTBPAU lTAWDFc6gmhbBo2lyMOTLBg3DPwNBKuYCb8BDwJbsHcSvJw5E+ci3JioQcNOrqHyls6TaJYK oSoeFAXMwjIsGfZLIUQ8QoWJv7U7wWBAY44wkPTG2z7MQTCYXB1aUGFgv5MxqvMwmyoHBHM/ kxN84mAwFURkR2P0FU5vmElGIRgMlGw+PkBjmwU7PqCzIOmJIQnoDKLcQnyiEQwmextb6SaY q3idyYGJ9AnZCFCl2M0qX8WrYDB5N0FjxV7NoxrJ7vEuCt2cOxFBWxStI2M3W4zOEh+RFTCY SVMvROQQ5+ee+jtV2RwIBC/HC4JAvYDG4CDuHLO2b/t8iAiosmMHmByGafwtG25KKStJhpwJ +QTkiUQF4mB0zOItgXAcy0E20UdjW2M9SQ3KG3mC0ZwARmOXbPRSnyTkoUjW8SH8DAMsmqqT N8OiaWnTtGCyvzBXV7scIVZMSWmM7Nmc3uQru/wmB6UxME+GOJTTkm5J33kGG+cl8FieOVh4 DatRuKH90f+hh5/hWtwKnwP1TNtaGjg1beskC8DlaTqukZqyh6ZDDfJy5JnSjlAvFURvmVQC 3LeQXPOxOjtzvaSDuo6v+alcHZbrZcvlM9cLzfW6K01HdVVDWZXtjHuRZ5rw04UNA3ht7o3e 4vTzFfQWeoMNUyTPPIreMta5CHqLs4tpAu1ihHUxusIN7WI70Vsy1OIV9BaTNTbaC/IAWRS9 ZS8oNdmH3jIVTFXQbjLOF6Rnx27K1dKYm2VKjal74PtD7GKnkme2LRizTBBsEA+SZx5Bb5mm d+jKVoErGdnGX7W9VnY3VqIVOU2yHQgsK40V1lnupx2dvoQM+WzG0QH5dSGrqwVovSCZw5VJ Jj6z7qL0mjgodY7eIoykdRIN6DEcU1ETx12y4DfQW8YtsZwaB9BbtvZXYEyvC93cJs9cAI1Q 9JbNVXREsu3GNgsO2cU+KXmmP+vdbfz7z6/qx5+vH+rth44uc4quXbDPMyDcjNPyiZF68JZd wVt2c4Vbdn6XICiiSr8FALGfDFNToYXpEEQV3ilTH4zgs3VqAW/ZiktGW5Hfsv3PnrDYLXs6 vvJbdiivnrdslAxT3POWXV/1lg05MB829JWSpjq4cZbFszP01b5DlkJf/d/y2zYbqGnxtBpK ZI9sHN11otKMidLGqaaNk6hWvEU2jovLtDtdijq5bT9I6CvG2oSm1Vz9tj3NEh76GhYWmGkw xPGmOJDC666eSdRoQubSqWo4NfTVd2tH6GtDhnnNpw+mTto09HVqHbseZJ1IlfCjoa+DPC2t Zmfo65CHvlZXDn2VDYONFd+bPXGX0Nfh9qGvNVgAeWPcqN5Q+gx9vV3o673x2KVQtRuwcAvy d6fXd98B4qfpbDUjOtsGTdisnyeHv96nZsRt+VM4UTP8d6Pmpp6R2dJ3NGU1Q/fAqO/focUc 7BqXu9iLon7OellQM2ZyyMjWoXs0e9f/hmrQ1Qs06vu+3EvNsK9gOQV36F2jdZshs109e3ea Jdyob8+SFnLbrtqFSa04DMEaZ6r0/S2pCkP6MccFkRVNC+YGeglUBahNIWjia6Li9tH8LEu+ FBJIhhUUu8nnIUIycAfSphm4tsCqOiXLbYay58LBzzZQB8miDNxRECGE3tTzlt/oITiUgbvS zXSI9mTgXtI+Cl00+UpwqoI29QVUhV3fH0RL8AROBS2hNqtagt/kIfnWKwnhg907g191vwTc s3BdCcR1pVcw6836wBPX1b+fmmHoEFzXUP7Edf3vXlxXomv3Id9hpMC1hxNxXad5+ty4rqEX F8J19Y2huK7TE9MfYDeTIVoagz5perpkGK5rUkEraAwIn2Va63h4hRSLdcA+YbhdgT3QmxDJ Pimua1iJdd8w+cR1fTb2bAxtDFew7o21tk1mXaCZbLdtNNk4YAnJzPAQEdwj5SuuIDppWXOd KIhyd+Clfw/BAi+ZYcMJKChj4vGKjWYp8knHSxIxw/sCfKi8k7GWFf8F2GjizNtrJiQ3vGqo uH1Csp+lUuCl0kuA1CQprnRtpf1WvKGCpMuj4kua3DQM+QLGgwiZyXOI/ZwCyab/MMVM3WIn 4oHQtKEgzDAH+Ary+wW51nqUxB3/tiUrJmKPT0SJ2MXG2mhGxkTsQr+XJ/DG8pxtOyMG5myv TMAyvHtztpM4tNW0X/goEGQumFK1UR2rk7QB6a+xZGFSdnz7ZkGiflemEQKKurWd8Jxt37Fy N6fe4hs9z9lmeYYyMr1kJYl7Rzb5vsbSXs2tR7KrXjUgFBZP4kZ6JfnKWilKNlkSwQUUJGKv pUpnfwCPgvGmqexdd0DHSrCqVKuJShur54iKvYGXWzpPXsN/TVayj4Vayz4OZ/BWBnTlAyeL GdB3T2F2axWkIFdsIwXZTtZUyeeZuiF36dp+wIpppkJ6ovM8BbmtyDMFGV/SxwNjT0pabvue LJU+/upffTU3LVVx9zxTnZ+pzs9U5xukOtPbpDrnVgWCBGFzU10u1dmnGwdXQRKELVTLaqFB kMeUtowZEEIactu/ZG6aKaX55QVJdV7ONiTVuZ7dNGk5fwZhP16q8xN/eFSbfzH84c5sbZzo g1TEH+5ZpSrSymnjRHUektugF6IdBLlxdBQ/B394HuJ4UxS5DSjCbaASgKqLchvswh9mpIQ/ 3MXBUAfwh/dGVu0Kwj4Vf5injfkGd0dWgTMqkyxwG/S/BbfB3siq/eaV7V79BvjDj89tcG+8 4QfSLfQNdAu9oltoVLcgBd4kam9eaIJXL4mplS5FXqO8SUOBN8l++Nz6V4luMb7fXpDvpVvQ rrJ3FbLTq3cL3YKs6RY61y10qluEId7QLSaTybCEFLnPk1g+T1FA54puAVSJpBexKjFBF2yd +T0vJHhR3azqFqSkWwgzLI2FIRIu/h8svz26RdJYtD23Chj2BUd0C5rrFnRdtzgsyOfXLejN dQsOFgCqWzD9eXWLcBbY2iFSfNQVXlX/19s35xqhlKx6Cx4z8vvBUN4eRj2htqXr55+zlfxz BvPPPdrNKaYPeyhcyPTRaaIeLf+8HNpNWdUvX+Pjod0nqydr+ecszz9nUsAh3lBPpvcYeBZ3 8Rhf1PSBY5tljXVqgl/Lk8p0iUJ67kzJ9JGHuESa1FHThzA9kIwkOh5rJISrx5WASD0ZC+y3 NwmGV0fUE5hUBsLAMNk/i3qyDNFAsrpXVk8qsABw9UR8XvXk8U0f98a2uWcYs4fXQMKYp/IV jeIiYczhPTCM2ZdfNox5F68S1pdHCmMeetpjGgXqTLl6GPM0S2thzGP+DZskLXzhtsKYh6qJ Al/9i1fDmMcFjKgnoe7dw5jRTOewINdaPyOMuVGcmmIYc/REsbEd1FPRnO0OY/YzAqinKBJW i60zLIyZFoNXR+Ag14MdsxkkQ6in5gI6EE7PCGN2Q75Do5gFSVexhL3a3E54GLN/CexmPkX4 Rk/CmP2jccAvPr0oFdL4l1XqqbGb5caKvZonIJLds9sA2dFuptRTHpOYg7XSwoEoHEG7qKdy 2WvQzQPUU+n718KYd1BPlbr5DGN+MjGFMOgTmZhODHmVtCMSvK+XRG68r7EnpQr3k//3//f/ 497jYXLr4gQ2g71d+0jSfz6mVw3zuLR07ZrSyKYZolXs70+rl6+hFmwNNVlsgCb/klHZh+fs Gcb9DOP+7cK4z4zIrmFENrlCRHZuICFIRHZFt2CxD0RkzxrMNcmnouhuAIsdpU7HEdmdYrVd aSG6G5TXJY7p3zsim+p7RmQ3VzUdNtnOwMmnFKRh2GE8PIF8yhQ2zMORT9kbiX5E8ikv10Hy qbHORcinHBw2JUi0lOZiqGiTbJhbGA/1FvlU+hVOs7gD+dSyFgqk7N5i4HsNpgfMcWHRwfvx HvKpvApuU3CKYakxTz7FqGHDDnvfbI8AjU2zPP7vbAZgVA9SCATZ0COGxyMCB7H4OtTaoQ+T TwXtddtEt0gGZC9LVhRkHqLoj2Gt5K9D15nEotfjVYz4g522jS6NlNHJDWKfsTKFxpKXLdh3 oJv5o9gQ7RwzproG9ruwVlzsQE2aqghhOifY40OEcF25awM6ZoF8CkzA8qJe9jy1uzWs47Jw amyQT6UL7xD51Ob+6lSl3dUYb2wmn0r2VzRmnREajipqCobDGwdA7JHs+LIqrbP95FNbWk9e 51zyKf/5GW9x/zJ/Efz642O2+pA1o88FiKueBoT7GhA+rxHgHrncDbQc8CtYDvL7EUEsB52o 1y0HAd32kOWAoRchGsozy4FVKar5wrHnItQpXruFXbAcJBehpU44kqHlwJXLp+UgtxwQrvjU 1n0sB/cmuWha0w7BC6X9J/HbP+/anirvgz3njf7Q7/3snJhPtdMjm0U6wPMOinSYwQd0jDso e57HOwhrK+ygyfAQfokpAUYkLKaEGJYNo7wY45NuuYNynRLbQT6G4nJxSEdAqx+Mx3qaJdyU 4H1u2YzKROP1PrZ0DHkXfeXADE7/YZA4iWEJTIpeB6/Fs/UKzGk+mftuGEPd0yVMGog6F4yN UdYaIY0BFymIUTg/mjcG44FWurnd73QQDRbSMTEh4hMweem1nImdQjzQrtgtlKYcf6LYWB50 kVKbdX2j6kV2Z1igLYrlHIY8KmC9aaMQtYZLNZB+TTLQK3xGCvFAfmARK1MJ33A1HmgohsH4 eYaDuDUjCLVZSbIK9GrLZDUHSzRLGsD0aG4YotvdLHZilqwMawjHbB7v9Ek+wBnJX7dlfpk6 0e2ANcDxLFN8Q99Y3aam0bZXBoxqYWm4IDIg6vRfpfmm0Udj25RwkhoEGrl1UIc/6ldioext cS0YKpyQW3FMTb0axuTPsuVCPIcFta4aLaIEfhIQR79Osagnb8Iomwlae092ZiJbq/cChuTL YtBSxQkMkjKUbAVJXQwr8h5rl8u1tTvI1UC+XzOgqWuMcYu7/0P3f06GqYm2PSBvlo+fo8FQ F4loGpp+auOHnUp7o3C1iK8lSrXOs0eeMIOnGftqIr2B+UN///j2vw/1dZ6Kbj1T6tNaCc80 +LXQ4NdcweCXmzUIYvBTg7lcqFCneCPqCoA3ury8ZoCRD+PfhhWD35w2NUuteFdr5t8BDH7V wj8VG/yUGUTf195c8gOUV0/wRixUiIibGvzO4q5jkLvuGrF3EPPx9+auE6QVLcJdF8qf3HX/ 3QFw0JqhGXira8NUsq+OABycyF03zdPn5q4LvbgQd51v7FLcdaGxC3HXhcauyF1XV/b/iw0G SDfDw0/uulLr1+Ouwz985Kp+MQK+dxdLxj8O75Mm4wfLjDRcpcn4UfkerdLXOSUZf34PTZ1g UznTz2T8nZximlUqgjG9hRMsmqXbcopNL66qUjL+soDx+DNbNz+CfoNk/MfkFJtmBGRr35NT LP0n5vybCm7EKZZSiI2Wl66uEUqrre204nyD3UymqJSlHpxvWR+qjek9xCm2goaw2pg5m1Ns pW4YETgBUyNFycqp9lNBOcN+xQ2cSIZ41GCG/eFuzp6KKUJgnt4np9jeZHy/bReD7egcIqv2 9pu7sOwEI66onl8n//5yrqWjfom66xTxgcP+VU6N//j4+d2ZrxlZC3M+/CZRGap9H90khNX7 84f+eP3yZcoHrkp1q45TN7Dq6/D6ZiX9+Wq+/Pzxh7e3aztSzg3SrDaghF9zSwNv3/zqm10U 3gunvceotPwplaR2frDexz4Hd8E/6k8/McJ5wvgKwsKJLrRah8hu/T6ELTZJHnwTVHu3c9k7 coo/rRWNDKAVP77aVWgPs1fz892D2yYrpBnWHEF38ZExzrk75uzUfFU//nz9UG8/dBSD7Q+4 Yu3zfGXUSL+X/Lr4Yc8pe7r+8S1AHny8+rMq8BGWplrqYZjq//nmPwnUDXHRt0ea1gcE6L// 6v94907B0XXl3eA+LKBY+emou42jjtyGZS23sxDUUScv56iTxirkUkGWNWm/6ENw4J2d0++Z 2Qosa3xBJs5Y1qxcHXDUhfJnZD7qqLsvyxq9qgUy5x980Jx+nm+Ye+f0u5hAU87p5zfYMGhO v5frYE7/WOdiOf1jX5INM7R2GMmtA/GnWVrL6QezEN3popz+UIUzzWEUrE9K9XXB9GSNsxUL TPbonpz+qWCqsssG2Q49VYttqOFdZZjYYzb0XULsKys5/UNfDWIAxrnxL5IkprdsEIuvA42F iT43pz+e+CUJOZYMyF6WrCjI+O8GrpX8ddg6U7pD3ruasL47p99xAPGzcvrPybXOGmPtwGG/ C2tFdwPVihpa3gHXzelPWvfgXukTSuYR6lMnYE7/IIsLD1ka8VscRwIs2Fq0eOx8Z5rIQTPv r6ibnbH3djCqW9tpUirynP5kabhEUfPb5fT7j4u7Parh7d/Xvz60fv2fshe4L9++/fnz+xQC v2IiODut/5mffyFLwLkAf+4uWjYGcLlqDHA7F73LM6IeLjcf4Vmv7sSzbli7kZt/HNVvDqpI jrahLqD6Hc/NF30NLAC2nMiBT7wuIDffFHLzTd89Q3UfLzf/3lyop8YgCb7//j/+ACGIp2Os KkAIMpWvbJeLEIL493CF3f9t+Sns6qUYpArZLifFIC12gXsQgtj7PyNwu7gYJEHucP/3s7QV gxT/ildnl/Ks7IwkuGEGiZZxAS5WNXHxknljbbaADUI6AKNlkMaSG2NorN4VNGGwDHVBZNpN TrA7hsHYDxjZVr6x6CgDgzW4o0SL7R5ZkMxahnqYnawgituaY2IySXMcxLhXhRlZCZLZHrMw V1nQBB4kg5o5/DzPAU0h777anhFkaSATEB4FvdoywGDRMrPxJhU1X7SFDPW0E3O0zFRwgI9i +h3ho/CSXYqPotBNEC0zT2+LrJW89f2zSYsz4pPaxdDuv2WLPAxyaPaPWRKDVBORQlH48BDw RULHzAeE7DjgclEP3v9vG4MUzuCt8CHWkNXwoWco0JVCgW4XO/TMJz977J/kGo9oe/udDGln 2sQ4tImxK9jE8ps/QWxivN+yiYmjNrEKsYnxakzbRGxiw4pNjPYv0CZWKQ3xKoVPaZu/CJlN zL5fCswmNpihftrEHs8mVl3VJlZlO+MZFbM7KoasMF3cMyqGHGW6GOtcJCqmDE8pm+j9N7SK bTFdjPJlKddxVEw2hHmAQQFo7r5RMckG5oDplAKbwIWjYvJ+gzFzhMo8Yy/IBvFYVAzZyXSR /l3sYLoIoT1N6ten0iAW1BU7yiTqWFCKionCCNDZtMolje0odoeaARnEfJi3u5nVjbTtrdCH tfduWVoKpo+eidZErQvTl0VdwQd18TKyYqpLIjwotfs9CRySVA67J2Dok3idntYgTCbaASP1 RWHMNpguAILofqaLzf3lMYtUg8aFRUwX8S/bcCnThZ2lA+mkxyTbbmzvOnvcqJgLhLXcNfHF nYhLXlQUedL49KS2nJPhzrRwYbbX+b++fSwWE+YMbEXr1om2AH+4jP2MqykPMVm0W/hDYjQh vL3/1K8fP9/fQ5bNsIY1+bsRX5xpE6huA2mX33zItTNlxkON5Fccobihsr1cpoxW0CYwvgOz CUyHbW4TCOX1zRH40TqPZBNwmTKc3dMmUF/VJpDzwkKbgKackq00cnv+Jmnk+AbyLBI7jQT2 JNVMwNAZNlDTViWrGk920FhnRKdXJfA6mhsJwjuWtiIjwcLUBTksTMurUq5ZwUgQRCvsoF3w PdnfwA4yk+MQ30E03kGL5jkbQq5Hh9kOSug5gPx2HBZ+lgrQdfuIIbY09Bj6J1EZO1bNWnb2 hJltEqAxytpeMwNhbCAxxIrFYX7NBGMD+p2MEQQvUYi6b1BiCIBNQxBsGuyKBClE014FySiE RoGSzccHaGyzYMdFZBYkPTEkAZ1BzBd7wm78S1a6CeYqXmc5MYRpI9CWuUqxm1W+itvCfKPd BI0VezWPaqzkN5rB2KWsE7NvXwM+Bpp1s8UJMbARAROwFMyBOcVu7oCxAQUFyXbB2Owwk6Fj 1tp7Rj5EBFSB3QyR5HuIIYBF7/R7PRKYs3/MdgTmHDISnKQGQauB/QSsRNP01QajxAXAeM6I pnGbMwoB+PL2rtWHq/39j/9zr5bO4sBWwhDsjgXROP2wFY3T9hhHBF+/UX/GcJzfhiXipBid zxYxc0/73A0jYD4ZBs7tyGyfsDkHjYH1bQhtc5MHQYyBklyQ32Kq8gKMgU1niCkYA1eT5iI6 zrgtgvNbkDKhbRfh8Kfl3RM2B+W3uCtsTnNVY2BO9QyNgVIY4c4W1X9/e31z3277NZ6/E+mx djqPbTauKYHF6NUlqirYAOcAhL2BQnN5Eijk3yETK3r+txdoA9StXtLnkueHXsCN41zWRphm oIWNU00bZ7lx2ykgDbJxfFs1baicNk50dQjYEOPGycuBDTDyiyMb57ANkKlWYxDeKHyOJ6XQ y3+uEVjQE22AfpbyQKF4YYGZBkMcbwrZxEpAok0Nk31DEF4R0mvdJxdRUiu+hIeY8Yda2vwP eunnVe+6hYXF5I3pfl7z6YN1wi+agFlUU+uY2U75FnFRk+UXK0d1U2ussUHuiyQpGdhfYpII pToqlwlgeiBuJaYFZhDgjDrdaLEZ9BIks4c+VyoWlVdO1K3GcigYGj0KWo8rojQS2QTMQzRA PomL2E1LBQ1YAHlj3LgrGaflCLF9ZpwjHzBQ1+3zqa7V6d0l+9uHb8Vf1d01py5fB91ZYGuH e9F4DbRXdYex6u4tgcOyaE3wB0W4/Xql/puDTqG9x8At2jJOgr7wW9NW8qPz5Vt4kc6CYXD1 pL2qepIT02Hxy0rUc37bz/cxlIfVcYrK6QHM0WE42D0xe/fj8paLOa1fpAs10UuSOu7YnvWS Kdx5PEUPBDD7tpjBfJO2vL+kd59Chd77Hxd/4iegFnG+SSziv22rbuBsstDfzjfpZ6kUwNxz +TJ6Cdk8O2C6CuvkJfIAusT7FjDBsxK1yLKwcS+D/Yu5N7UIipAWFuRa6+dQixhTIT5Z+ESx sR3uW+C1XXFbp7OZ873HQAtwApbhRalFIOJD6gHEcRVArwJV+RqzBaODcXOMNbaLWsRAnntE slmQdMwE7NXmdorct0ljsUfK5GAJ0xThGx1DTWBwepMCDHBgp/uWE3iM4L7JAml9JLv3EJWu 42k3t923jtZe7OhmeHTFfTvpyAAVFeIqTGOGeKnzXq2M2XqvkEEsjtneAOYdak9e6Vznz+PQ i3w6j6ahzVTJv3YkRKGDd9cVZ+wBeOyv79K8PcTADQED7kMif4/M/SeL/KN62RAWeXonFnnp zCmrt3K538smpG6rqoHkFKriNYUs8kJx2XXdlHeUOAukM4a1EqThhzoCeNmmd2NettCWAl62 UC76C17Kfx0vW9Xc1Mt2Fot8A1nkr4H1Cp1zvzeLvN10okZY5EP5k0X+v7tY5KX9nvj20n2F G7twJ9yJLPLTPH1uFvnQiwuxyPvGLsUiHxq7EIt8aOyaLPJ1G/mn8G6Gh58s8qXWr8ciD5bG mX7QZ2PPxrDGcAWLXNWrOLsFV1GReogP0O9ARTqQ8DieSTq/v4y/x0JFCtY7+XBcYZNcR1CR ljoX4worYIV3HdmlZ13KqRjN0g5UJEa8USSx6OOoSIXkvRyh+RaoSHkV3NfgLGDTe+0ENUO7 NOZBtKkxdb/DD3gyKlLbgjHLBMEGcS8q0jTRV+UKi8HDF9nLkhUFGf+9iopEpZKFbtJWM5Jt XZOkubVigEsDToBzAEspu9Qxp4c22wH2hjQ3Rlt7FQDK5CxzL6dF22mt7f+rZ9+pZnU3GKcD Tk90RLSqa2Lkd1yyyKQaRyZqbmTCXZXhNSXdZ5KlvcrSdu18b2fpRpba1XXmjbKzE7lhuq0I LZ0aG6hIALV+PyrS5v5yKDY9r3BH7BoqUrzhooIzUJE2JdtubLPgoFNxW+vJ6zwAKtJnwin2 Z5z3Xajh9atWP35+uN7qD/Pa//XxY3QnFWX2x5yt/s3lQH3RvRuq/vvPH9Mg0aK8/qAa3XLJ e70PkK4nUD09Ow/q2UFox68BsJxfmAjm2anqPYboQ/lTCJhSo5phAPlTQrXGDvLsjck8O6Zv BsSzU1PamP4l8+yMz6P5U9MZ/QI9O6Zn/dOzg3p2+nvmT92fdvwmAcrcc97CAGWn4pqDAcp8 Ikm9QICybwsJUA7lDxmg7EMSCzvmJgHKKHiSsVeefMdcPUB5mqWrByizihudkksxsxqgPC5s JEA5/MWkqnYGMzQiZ03/NFsByhQunGggNOUViFPdGaAcVhtYSlPB9FhhAnbhS909QDnM5k0D lFchijLJTg5QHhs7XgAbmwVJxwwBXjolQNk3thqgPE0Rvs7WA5Tn6U0KzghQxjDBcBa5tFfz eEeyHw5QzndetlaiAOXQTV46gj5HgHJpED9ngLI9hzcRmwb+RGx6kPhm1fbKYFBPHrNmDepJ VgRCPbUVuVlc9G+D3PTL8rE96dUekV7tZmhN5zKy3dng2PABNTha/Xh1n52UIH6mmZLeBuYp N8YQxEw5sC0euMMwT5AHzgd6d2Y2uuSKG2amnH4vAPPdSl1RiPnuy9lswAEB6F09G12w8qeZ 8r4B6NkWYVc1U7JsZzwwzJNpFL82zJN9hyjBPPm/vUBrJTURzFNhgcCNQ+sSzNO8caIvUkxL lMA8aSpb06lh2jhRnbvCPDk+OAzmSVPF2sX/fztrpZ8lHOYpLCww02CI401RhHnqHMb5EnbQ V0NsmvGUR4mBsVOVaYdYLZv+YsYfDDuYnvDd2gHzxAc1ry2wCHMNIF3aJZgnYCVdRE2WX6wq lmCeHHHJtcJOp+GNCnhD+vakxrYLrE7JB4NFcRffmz0RiSrczUzhIeGwLpEDz1nuclFRNKsw RBxhBtwsOGPMGFgAeWPcdITy/hPDPPmzYF2Z52RNmb81ZhO/qq6RszE/tK6hb6Br6BVdQ6O6 BjElSEnaQ13DLoW+6bRivSzoGjmkZHAz8a6ka8i6Jw8HKek8o+MYJ7pGX7ekFnfwjJI1XUPn uoZOdY0wxCfqGpJk3i7fiWlAHJivOV3XIHt0DcYX72LyHO3XdQ1S0jWyTpynawgzAMl2FezT Nfzwxl/lWlxV19CkQVw5xfdmT9xF17BDdGtdg4MFgOoaTD91jdvpGvfmt38YXYPalq4PX81W 4KsZhK92B3IRvrruEPjq6dfqgq4xR2HFiv9QgK+2H8LG9Lx+MF0DzZwPv461ch6XG8FXT7NU gq9mOXw1kwIO8YauMb3HwIO1i8eYGGYW9WD6TJ+qa+yAr6ZmDi3LJUszm6CucRP46pG7PO/E 9ucqbcw3eGn4ahdulj6a8wCiomKSYfDVdb/d2K8JX12BBYDrGuLz6hphpwfosrcP7XyLnVj1 Et9at7g3Ty7jwqg5xmmMcEo45M/PER9/OCluFNedl69oFHTSKOajMoqFPgA8bQrA0+ZE4Gm+ pVEsRSfFdXuC0EmjyN8NNIoLx3U7T4kmiEbBvKJxY+vFNEuluG6l1RzXbS/mjWFNC8/EwjrJ zlPINBvHdU+hVPkCRtST8BeTeln8mGYL4yHiusNqA0tpKpgeK0zAwbjukS44lswc5A0+Ja47 zCYAYFZrExB/YPbxBoP5XvluJ5KtxnVPdMEXMdJMP9hYStc7j5lAVnF5O0VjBoCnzSbwtDkD eNrkwNPmdOBpsFn97wAp7vWAp00OPF3o5iZv8AXiujkQ9VTgaXQQz47r3tJ58hr+a7ISuCrU atzq8UDbZxT4J4sC/y1Qrj9r+Le3joSh+Ve/v/6t7dUh0BdxF/pblQO6b8L4+9lpe5/YCo+K rYBw0zZ34qZVVX85bAVNBa8HClCzvZYiZIGbtuyjsJoTDFpWFXMwP5NFIWtqvm3HQcvKDKLv a4CtEMoD5sIzaDkLWr4vN+29yd+kULWzb4aTKdDsvXsLYsI/frpfL1KmUfo3723R+/x6cVsp /Zv7eUeN4S2D6Ar+HU3Zr6d7zAo3tGNsUezXc+Uufa64Z9rAJ73Pr2dvAqhfb1zTtOYvsV8v 6svLffx6bJBKDSS1whURsW9BS+tnCbfCSdm0sUsKUMvSCqWWRW+tQ+JoM+Ov7JubqmxYR+wt qk4KkoWUqFiM5ZfzWLJ0Ue3xzaFj5p0JcVCRlEAyrKDYzXrdN2dy35yxH6tCYyi6+emSId6z SFScWnbFbBD+Z631+PkI9x3rZjpEe3xzl7TCQdjHfCU4allt6gv45nZ9f0A1t7PLbrnarIYA /ZKsspem47gGv82TjiOl46BGdRgdRyh/0nH898HpOKZ5+tx0HKEXF6Lj8I2hdBzxYhkSTIHs LyIrqJaCwQUz1ZHshyXD6DjSJ6rMaxEetQMkpUwlI0vwDnW0GI0Sy3d5qopI9knpOKLfL0LH EU98wyLNlLC2otBLRWU8AYXGTENZ28l0nQlluzlof3XyfSaJuXD5C/P/36L/tZXV1SfP2uNJ 1kQFQnVd9xCS9VUdj9lNJcMVrHvTcTxMELdpWHP9hDHWlRPG7N8SfSvciCWSMDaCsHOgby0/ WRWMPW1m7AnY820hYcz0nFulJzH23D+Iu5ic3rZDVzXNsEPfujQtx0rCGGsInGkwxPGmeIjk 9CIJRd6YmpFn4SKMZI+CuKdBu0VyukBjUz5pcjolgzIaNvZMTs8L8gVwoLGDhqJnwtjOoO57 43XfzKfEy4jdpmn25aVHdTLEbvfz343arp4OVTOauqxmNB2O2I34lPzzUpV9SqzdROyO96Eo +5QkrRV9gT4l35c7qRl2hykxmpWyyG7RVD2/fa6Yn6VTfUr9Pp/SOFOl7y+qKkyLdOuQZa1O C+KFlJ9MqDbFTO5TKot62KekdAckwwqK3WxXfUq0y3xKtNvvU4L5XockK/iUgiC6rkSzrefN v+v5lOwQ3dqnlLPMwZXg8r0YUU+f0sP4lJ4Ie78Fwh5tC9rFMYQ90xNadf2jGTFKqDf21/El reBTIOxNQ5weW4+BerMLYY8KOa8tsAjzoy1d2rdAvbkywt5tUW8oGQRDsrOeqDfp74mw94BG jHsj7J3BX35Ax5hPKySSnDwaf/kEP/Zo/OWTXEf4y5c6V+Uvb3tJeyvxzXUM8uQvj/nLARUR GWdfAJUG0X6O85c7yDneMGj1uSB/+TTRR/nL7fQOXZboHg0RMgGbBfs/vgh/+emNqUtKdtHG SEH9nJT6JCEznpqFQD5KbsvqdtflL+fodkL5y3ncmCcDSVR2W6t0atybv7xvj/OXzxuuigE6 L81fnki23dhmwSEF9clf/nh5p5+cZec+qaf8NrTe+T2CYKmnbnWv3hjq82m94/Lz+XLqWlE1 XxjmcsV1NajkwjD9bTq6pgtDWt48U08fj9b73riyqmVCp4e2P7Np7460duOWfTBOgNj2cgS4 BVAH3zR0ZdNU06ZJ3iGbHtyyw7t7bNMkbeWYslWfxAkgV5QDm6ZCNo0H3OInbJoSAtzapqGX uGU/FgLcNEu4Jd8thuRe5i474G5VZeukRdzU831wfJQ2XKoYnL2ZRnRHY+NrZ0GmWx/AaAM2 WJw9mGAASaAxSLy7MmbJEdGrRfme6oIqpW7SJSvC5OBl0yNgmAuSiRq5Zaf/7HOAPw19DMUx i0M4ra4skosaFXKQSFpyiokXIfqURTUbeH5aZ8MrRTYQ7HA4xDJ5C1baNJvzOvNB9FJSJIJB qKZRYswkngVpIgJzX9BvBx34CB37uMwbi6JdqpC2Qua8IM5ErQ7GNrqCGWXQdiyeEcqoGPBU btWKCl578zFj0ZhtTgDxRr55oEwiCOuiKfLvpwYBbUvXWRiRnfwQiWSRIImB0QtSp4K0ZPP+ PwqyP+44ej8eROUEqZpUENIjMxK/35CDt+y9mg+sdyrXsz09INdzJ2+GDtYK5a+Bb+9/qy9v 4eprVcePj5/fPbyUuwsWgeSOQ4sdrVB3nSKenNd3LBaNkTULwsmYYEo0vM0q+unslDe5UGe4 EMVb9acBBvulLTNPRLCjZpnqNohg+eWT3Mss469r5JhZxkrG5CCySHRvfjFUtgARLDyPm2UC 8pcsIIKJp1kGM8twdk+zzL0h+R8myJKS5gZ0P80K3U8D6X48JnCJ7kci1IJEd4ZUkgpWCrJk 08YZ2xrZVQp0P6YzpmvaaeNEl8aHpPs5kClKLgoLZtbofpqc7qeJ6X6mIY43RTHIMk//cDdo JP0j/SKY0+h+fLf2BFnOMZb5NUglJEZpkOXUOuaxVfqCmaKDxNM/lkFkjYQQBzj6RZT+MRYQ mmKZ2IL9dD/ImB275S7v3QsptmKzCP/OhihpPa64g+5nGaKBZHWvTPdTgwWQN+YgxQylnzjI 8nfIAbk/YOnDqCc7UUvBzjiinugV9USj6snQnpIDQiqFqyfcJOrJdg5Iw3qaopbeXz3x8ZmU IOpJo4xqZu/c7biDhjX1ROfqiU7Uk3GI82NrSz0Zg6O8zNmyWBwX0phGiLaHJ/0u9WTYoZ4w x0A0/uAiXFNPhpJ6MghKLqie7EM8PeXrOA1vdHlvW92bA0mhRyQTUsuqkoipe47xWK/Ldd4Y lh4E6zoDi/2eb4iKamFhiLa9bZdVT1qwADD15DKIp59UPXlsBNMWIpjWV7AsQgXl90YwFfaJ FkEwDeVPBNO9dhJHKmG/BCnUxRE7yYkIptM8fW4E09CLCyGY+sYeEsE0SLaGYBqeeCKY/pII pviH74ks+UsiSzJacrQdQpY0w2A3K6+RC/l0ub4P5BNXAkuYtDKr4baQT9EsnYQsOQ9xrqjv 8hdQcdRfYLJfutbi+/eUnLRxUbLf2TkwCi7CWPbdyJIJGGQYIqIbApdS1PrFkSVx2zeEi6pz uKj6kL/gvITJRbJH9BcsQ7QHLuqyRox8ARxo7Pe4kH8Kf8G9wSi32XYLV3R+WCnJ80sCjl7F q/hyHpevKCV0UkrmOhEiw24UB/ceLnEcSt6c4CUIitep0T9YX/LoH8+Ojkf/LLkqMYrDFJF7 VRQHQfphVupvl1/iZ6mE4qD0nPXsIso5Nd6MbBIoe/BE8RQ9j+AefzQuAJOc7gaDZT1PSXLT v01CiR70CNJqmTiXvV658rHIH91+othYbs5Ikza6rh5iGCTWm7aTeWN88AMQEdyPCT4VImrU 78qZyXFnSJY7n0zeWFelZmw/sKjPB82aYclKlBOMxjybKPP7NM9bgwhnhO2XrAK92tC95lhn 1YAsJQp6td3N4rKKE1387/4E974TSC7S2gTEY9ZqotLG6paUx2xqrbA0wPCKFtn5eWeQpVHA T9n0KCmksbGq2BwzmL+Fjpknaocfr1irQ/O3Dmm02zpPXsN/TVa40YVao0YPZ7DPR/juKrz+ T73+9c1X569f9N/6i8OBaGrXRjHbwJ+WS0j8SHwvfKh/MRDenz0ubl/9z4W+/+/v6cW2qs9M KCdguA3v9WAXRN9/++60fVY5NZgXw+b9ip8q+XyGUczej08xncHPOkjAMZTcLAGnkU0zRBPs byerV5uhFmwN1kOso3oMdc/lyoqyU7e2pE7PrDme/HE4Meak9JuTc4w6zSUbR8JPhfPq+EST 6d5WXq+fNYNHuRiXUXD7wg/946fvbsjHKW6XTteUhzQeW+Wvbx96Tshh3NYsbo8T39cz0U7Z MHE15fPximNTSyoHvxTe/3p7/6lfP36+v9vzyy1ut4aeWUr3zVKitwGPyY0XBMtSqvo9sQTn ZSlpKszQmhOcJ618yZwnPeHaXrAheAxljdV2kiCC6W8eJGaoPHYGBI8xvvyZpZRlKd0XPOYJ BT/7gj4BFHzy/NCVN04t+sLGybOUwt2Fl7yOveqqWr9Ar+Pdw4A5wQ18hkmVbJxbGPhOh4Kf hzjeFHuh4Ntm8Pk8sc3Cj8s0IJ2qhlP57PhOKPiuHeY1DxZhcpvdDwWfdCIR9XAY8JWh4Iec z666Kp/d0DUUCUopvjd74i5Q8MPt+eyeUPBPKPhH1jX0DXQNvaJraFTXIAVdwwEAr5Da8aGg a+SkdkHXaJa2Ml2j1y3tHlHXGMf4MWhnyJquoXNdQ6e6RhjiU3SNa9PO4ADoaWOURV5NsAjX dA1yE9oZsRNM60Rd48a0M0MnMPXgSTuT/jhYAKiuwfRT17idrnFvUNyH0TWoben66c1sJb2Z wfRmdyAX0VfqFV2Ddt1OXWOFQNfHsXJlN8Qj6hpoenPbdcyIyYh4S2DclfRmlqc3MyngEJ+i a0zpzfFnOskMdif9GXYNsiO9mRLPZRzWPFiEq7rGTdKbhemBZLsKduoauV2jvrJdQ1dIglLx vdkT99E1bm/XqMACwHUN8dQ1bqdr3BvpTVPau6idEFDwj/ry5+tfjmHkRxy1U7uonba9uM4x OyGnA9DDT1W0pHOsgPHzWeeYD9NCsHR4B8d0Dk8GMEE1AsQ3ey+ZdI5MrgLlHa2HmpWckHzS OaYCk4JyAyfkHBTNYZ1J50jesMT/Z8HS87hcBIx/HK/cl0I7Sqf5uh2kip+lQh6zH0AwC8uw xGF4UQH4fs65NXljpejpcrB09JdCY/OCNRWYwZ2NJYHWvrE6j7dNUkWmQoMGWhsp54Hw67tS pLSGE51j3FlZN/OCVcS3jbrHk67iMOpoI7g4xBrUpaAziG67O9B6e8zCXGVsCCHQOpOsAtML F22IJ1dkc0aqFcmKj4JezRMQye7DLZF1VuS2wAcCnYBpjnLJ+Pi/OS0DqUuH+EY3Q0EiGcZ+ UWwM0mCszrdqe0DGN89zi9RN20bYL4qSQRqMtHUBF16xMYQGY3PMUDK+Ag3GdvT0IYX1FC0o ayMcjVvxzzQEiBajSm8ey2xXF0Im0PMH5xI4HK7b0qZpQSjyF+Zepl0QKyuGMDZG9mwOgvaV XRS0C9Qc3PDaz+DF431Pjnw+jRWgGxq/6n7CwWnFavD9MzB5d6BwbVs0Y8Sv/vev1x//vP3V /zFTdwwXjGZ/kkzeLE64hnHC18Acy2/yBIkTlkbfj2QygAkOaD6zh/NDwMaKJJMj7GB8Rc/a wuKEbTk/JZ/5N4gTVveME26uauNqsp2Bpf9vExrviqs/ZNPKinm+YVoTfgf9aIEv/QgAQGQH y2xauu1lacMUbFqLXBfYMHNfZj/aJNdQBABAbVpjnQrZMJ+cYHKapRIAgIQpxCnCjuxThB3O NK+zxmIaVDA9WeOstOjWLpSIZIHyey6YqqDdZJzzvLEK8Z6Y7LdiawB1x/9tp+ZBv8GYsaGn XBFCyoNYfB16o9eoZzEeCK+3gtehY+aVVNg6EDXvzH5rWwPXStS6RiRD3js/CluPVnHsQE+7 6ZXqZK04ZTnpd5/ZMLPG0lmWiH1ms2DnmDFjKtjv8myGWt4dbvs0wCW55vxN8NnTMfO3g9XZ zApoL3tesurqSiQWK38RKM53yawe3QIO7C9PYaVyqMv4RgBd+fiWCGPmkdKO2JsPSLbd2GbB IZvWHq0nr+O/Jyv53rRZT/j2HxeXZaqGt39f//rQ+vV/yl7gvnz79ufP71P+/wrZYO8I2VYt AqpbNQj4T4W7ZH//+VX9+PP1Q7390JEjV9G1e/PTLvC82ycXl5swFeY3GILmANPr5wCHX43e 7bkQh0L+ykyFFRWNTtzv09+mQzO/24dy/swBfgCmwrMA+vOkevKfv/kNkup/d4B+Il2AEgTo D+VPgP7/7gDobw1vVS08uvgOEwBB9tXJAP3TPH1ugP7QiwsB9PvGUID+6YnpD7CbyRAtjfFS xMcpkmEA/UkFrWAoRIheoLWOh1fICAPNPmHqyjTLbOLdDA9/ToD+sBJrq0zLTwjQ7/Q5Zv+v 5mT6vxdGGn8v4a644uLFXm4JV/ZvtLXKqz0Al4fD/y2N2Qer+C8vTePr0rmubdv9hXPR+N9L 3dt/Npw0vKkbe2VbGvM1ZKWruhb2TNbze32TjNMX224iSKji/s6bhtc8OjWa8efr8lC38oKE /79Y6gpbmXrZoyoVj6x9TcVdNwSvGm7/S7wEAX1X7IN2RmyNeuyz78FLeHBpMmrM7kD7l3pq 0tUlLWv4KE4+3m4CuP/PMGsingAn6VK3YbCuHZiGR9P0Eg+x60HU2DTWPDRpOzH2fFkrbPqH aPyoztMTqqwqWE8iiDl59dMRQVRI6pLuSa/tga9KkCwpEcRo+asGLIzYttV1tFE1RgRx39Sl nvs86fweg4YRPzQRxDLE8aZIU5fAyho1B0cE0eNEEIloSYLQ1Mj0nYb2zmViMmaI6Zc1xvoC JAtrE77JI0QQIm4sEfWE1KXTiCDatLGg0yBEEF1OBNHtJ4JojTk/JjlI9shEEN2TCAKve1bq 0qdgcrg35BvjStQzqvHP99Grweo42u/0WI7oWGc1YSA/yQNPuewJRLGgRgyxYpHUcefuJWI5 XFuVALEcoby+cvCTO96WHKydZA5LjAc0kM6K2DXJHLCcaM0qFTm7b4n1ZmepFMvRsZWMUFOC 4ccby/H4KYbCDpIiyoDxbFOQCsz6/jM64RJQvdIA2z4PDJl7lWLWJN2EWdPFbpbx+KeCEgz/ SjchHn/BwDTJ3nUnj1kOw08dDP+OMZtbB4M4/SWElqIg+yU8/uWJ7fiXjW6q3EgkxP4xg3j8 iVqOwvCj2wnH498aiKEvTYDMOiFgZuKemKFpSPI1GtNMWNklXTQ7oZpGCawxL0jTLO/1BT2i YkYXFvuULDYWxRtVwUbXRaq1qBWqya8vjWb5J411TlqrPk2HUi0ZMAaS6fOSjRmLxmx5XVky tpR38WlFGe1JJkitRWmd7Y3l2KH25JX8B2UFfb+vVsH3z0pF0gNIReqHX5RWoVK6ct01X37+ +MPXV+/Da/fTHgoubIQPaxEZVcepE199HV7fbNWfr6EZF+agrTyuAX8FKL9d1CRp4O2bj9KY Azz85UO7y0dVSl6j9mpZu7XS/+j/0EO4gPyj/vTdF26d8OI4npyqVOsQ96LtaPkEuUnycIeh 2ngc/ItmOrWikWFp/vhq59puvFfz892T7SXZWc3qpB0ni3hmST1gNBQjrHJD69f8z3BJ9+lu TXnRPROrdgdfnWSbODNii8GIrWsEmOSGCoJEbFWu80dcHadEbAnVslrokqdjvvjvitjyUlOQ jZW3FUds2dWljKxBxFYoZyXAlN87YovcNRvriaQ8O24+HZJyj2wc53Myg2K0hG44Iw0lVxAc Sdn5r6q2qoaXx3IRoiFZ4S/1INqZg/EWLsJolk5BUl6GON4Uu12E5DBXfP6XsouQ70NSJnVb uiQzWXARToNWcBHaCyNJDSqLqCe4CE9DUs5Mqb5BxEVIaOYiJPTpInx5yYbo1i7C3wFJ+VO4 CJ/oyQnI7a+CnkzavUwNfgMqHD3ZffysGkMfLwTp0VihTkZPXoa4rF9Ef7kxK9Qe9GTSCD2v ebAIV/WLMnryBVmhroyefFtWKKZaimmLT1ao9PdET36iJz+yrtHcQNdoVnSNBuoaHuixpGvI NV2Dl4yAqK7RlXWN2kwh0g+ma4xjnNoyeMc4yYyAV9c1plkq6RpNrms0qa4RhvgUXeOqrFC+ W3tsGcv1Fy7Coq4xtY7rGklj5+kag+ygZJfTNW7LCmV1jbbGGSifrFDRrwYLAOoaqjeUPnWN 2+kaTxQ78kSxwxyND4ti91DMDHtR7GriQx4ISVQvj2JXGMPkewkx7W+BYpdXQbvpo3AKjXGv sLjZF0ClQbSfIopd/Drb1gJyTw3tB163YMy8GkZjQcAgXhHFLgoVWmkMSAZkL0tWFGT89zqK HU7z4D/LGDM4BK1LlDwX2oQujZ2gdeBcL3UzfxQbop1jZnvbw34X1oq/EAgtOwyOIPzo2hCN d6x4ZFyMFn6ZwFHsosZ81NXyRNfLjg+lUwOi2A2yuPDKBBRh+GkW++8LthZtTvMwhV81WhW2 ROimvQJXcFSxxpDhjW81cOd7UOXOlNNCfkkUuwvA0J0YcenP7PHNX7/9HSK2ex9F7EK9aTF+ 9xmqCS8YdwnVHORaqCaXq6GabqujkZaMqIcLtUTA8a4BfL8HHK+i/U1CLVvdG5HfgLJj7Wqh ltNZPN2A0vK+KtyAfu9Qy/sC37dXNRm02c6AJgO3w1tsh5N4h1/IaBDIJWLHxIKKG+HeCYg1 fR6epEfH5D22ZTxuZI86JoZ2TMn+hbfM54e+97NUQr0jF7KLz6skLejB5eJKdvEDjc2bYC4Y V/+OxsKj0FiR3yrrJhuItr91N8dfCw+S8Adn/dampitkdsduGfsOyqIq1N4GJzg/8AmGE+xu LqsH+wU4gOYNcglV6ALnelrePnGC0ayT/qaq0Fk4wfndgvzn7/YGd4snTvATJ/iAvlROSmFc 1SpLSsH1JYImpTxxgp84wWOFs3CC6wWZAu9mePiJE1xq/YkT/MQJfuIEXx4n+IxgFvay2y41 nkk6v79M50F+f7lrMEtwP0jzaMEsk1xHglmWOhcJZinB+LW6Eaye3ZO3sEtFs7QWzJI6hbBg lmUtoLhjBfS6TxHMwtwsU0YNG84KZplmefzfOQOD2pYl1X0eSzHmLy2CYIO4N5hlmuh9wSzZ A7grX/VWOtg6EDXvzH6L2anBLGI9AAjp94mUjFMYglltLHkpoGR0BVHrVGhar8zm2uSlcTf2 /9O87Q5JluzrLGZHC632rTM8mCUNHiKSzXEgI2I8Lc3mBiVjOt+HKBk391fHhVR9V+GNrVAy gi0xR7ecSsm4Kdl2Y5sFh8zM9whm8Z+fMbbjX+bjEr7++AgSjAbuMrTb3QJhzo1nscsUiWeh HtbtIQJa/Km1AO7ZkfZAbl29CtN3M8ZHf9o4Ik/9/ePb/z7UVw9W5wa/W08K+LRoZWdGw5Db AI/lNyuCuYBcDNLqHepANEw4NJUoXKEuAzymRGc3HoiG8eWUoFSR02H+krmAQrn81V37p7mA qL5nNAy9qs0Bcj5ekDugPsYdYDjOHcAMVzN3gEgngMc7JqmTcAdMJopRczrGHcC8mRcigjDD dMnocMqO4XDHeO4AHu+YXGZ0x/BOFnYMj3dMrslewuhQyqCx6kXN5JDumKsHw0yzVDI69HyO Vl8w3cF0FdbJ3JhpiNUwTMtIujyqaoFSnyY0X9hINkiom1vY3ZwCyab/MCOU+tb9LV440UBo 2lBg4+BYY2FBrrU+LqX8trItGa2H2kGdOcOB8Tfp9Ak6z1C5m+0yI6xTqir3e3kCb8wd/OmM 1MBzx9YmILqM2VGTMu4mS+rmA7GRJuEfTf8poCDxJ6xyhiXUtdNJ2iCzufxnmJQddgLbzco0 2QW6q2vEPrK1nfyYVUal1ibfMdjNZIpkgye9BF6PrA/V1vSu8HogOCdAsl2Npb2aW49kt2pk Aygx0NmM60YjUjRQTSn8UDI+/i8wVQJeD7B4ymOWjXfXIWB0WQH04W51cxyztl+Q7cbpnW+H V+UOsB+UFe4AuxBXyQP8Oezqe6Dzf9SXP1//cvkUP155wHr/4W9y1DbSlm674bTxCO/f3Wtf /zcxEMSN0ID4XoZed1t3uZCOpALO7EGLt9CzqA8aBqgPKrZBfWAnObKRTLaZnq/e0Vt7QXUT ayv1/j209oD5hceFHCQkSqg6eTOihJY2TQsW1Rfm6mpnDmLFGbG3mp7NVjBf2ZnBHMnA4AbX nu5lC9SJ/ATHjS3e4RjwGf/V769/a6u0f3OLhnJnP6qKc3MSl0HX9j1ZKn381b/6aj5mtWgb e3IXXC8hzu5HyoOxzVb569uHns1mzO3l4s448X09E+1ks4qrKePT1IrGPUk9CYYzc769/7RL 5+f7uz3o3JZYO0FOtCX+riZBepsEudzwQa5uElTcXROvahLs5NB3tAdR4dou3krOGkNqElQ1 6fpmNnCk5dcmR0zb+jQmwWCoupdJ8P50ojcMQxoKG4bmG+bemDqB+K0YhkRvsGFQTB0v10FM nbHOxcKQMIxgzaquJdmGuYVFkG6FIU0zNs9CdLvaj6mTgeeSQhjSmj0ke/LCYUjTe3NByDj7 52HqjP8LwpBcgJNseiLBmO2AUT6AqcMnLsW1MduFqQNAQGLJgOxlyYqCzEMU/TEPQwqvw9aZ 0himThJjczKmDveMzudg6lww2ZFJJWG/C2tF91S2dS1X+EGui6mTTECKqWMlM1zWpVNjMwwp Xnh7wpBisWJMHfSQ8k/gjZmGD3B/Rd28JKZODqDuqLHE7xaG9HlDiZ7QOMne/7QshnbLo0YA Wg8Ph62D0BjSO9EYDqxdNx2Qw9g6Fc1vQjGN4LWwdSZSRtR0MJ7JwHQQlT9NB7np4LemMWRc GQ0+onrbcnAC4j8AYBh/j5XANFG8PVoC0yTXccsBuaTlgBHEckDdLZDdMoEpmqUdlgNG/Cic bjnwvQbTk1V9tAQmPlIhXsty4BOYGqIG3HLQkuw2mAziMcsBzudYsBxEr8PHzCnD66YEFsk+ dwa/7OtYkFGwcgLTxvXQed6KV8s9khVXQlq3MBDY9XDtvUcsB/FcOYdfakoQKVtA8jpkNkOt 0abQtn28Vpx+nxpXnKMQzPeK5SCZXloDU0ISF2MqVhyzTctB3M2jCUzr+0sa0wpJjicwxRsu GrOzEpg2JNtubLPgoOVgU+l5Gg6eIQTPEIIL2QE4tAOwK9gB8tsOuXYIgT/JhAEhBEJqNRh6 IWC5hncB6CnLKqraTs4BzjnGrj9hcztAkFc/s4oezw5wb7phZ0xX0Jiutg0B5IAhYLrYfyZD wCPS8ni5TjAEXJKW53EQdqdZ2kQymUdhhyEA5cRL4Fuj6cnqXtgQMBVMVXA/scekyhovqOXx 7xKGgBFyQsJr0IyRXR7Eg4aAI7Q80etOMwSMouadub0hQJiMYnJTMnyIQN2jhoDCey9mCOBk cWmD1yGzGWp5Q4CyK6OO1wql1zYEpBEiJUOAlXnDEJB285AhYHN/BTTh+mRDAMLTc6ohYFOy 7cY2Cw4aAra1nge0BPiz3l1bv//8qn78+fqh3n7oyKnrE5KKtZ8GgadB4M4Ggeo2SPP5tYec hDRP290GgfEHAgMc1j9v2lJOQYHa3NbhAjEIcFUhOQXhN9MvI0jzNTAIhPLqGRjwAEjz2Rap r2oQqHcYBG4CM+IYyBUCM+KZyStWYTuGGjHEOyapk8CMzL/DFgHf1rT7QPm1s3A8qgONd0wu M7JjFkvBHWBGXGgAmdqKdswwMBIFSt+Oc8fPUski0LFqVnrnWQDTMrZGbS1G7X/GeqpBADGi R/PGxuB+FDIDTG0QNYLMAJOc7pJdxJYmAWgIqrz9p0zgPuyh16zp9osqP4jVMQuS1ZiTz+R4 DLRtGBWJJSTDwfCdpm2HSRaGPCpgvWkXaJZZkGzMADJI3KvCjPgxCzgYSWNdh4yZyQExprlK ViKGg5EHe4O6U0GEJbHA2eTvX+lm9t4K9GrfJV41mgEzVoJtqnqlh1xUZAeEuWpFuZvhCWAs QoB2pmQhQBUBIDNyMA8+FHcAwP0AECV0x9KYH10dM/sla/KRKUxA2ysDhhcfxPHXqCFnKnA/ sDeBqLO1Lmldtfsv8SrvtxD7xyzePS4RJjnPqKx4bOpNrShXhRmxH5QVmJG+WkMZCcfwFkAI a8gqQMgZYB9u/0ZxBV/e3rX6cLW///F/7tXSmRPYCjyC3d0ALKQfNsBC7PKeKvnXjpAmdPDm kzK3sFvsCMpIyEgoX7X92gC4IYaSm+GGHIaseMAKJ6OQdI3qIpSP71//WlA+ypVOwRNpRTOE RIcfX+002R3/an6+93+92dlyF6KPj5/fvY2NrQPO8mqy0gG4ENqtGVUODypnmrsz50MNb/++ /vWhtT0C7B7+8u3bnz+/ux6706c8JxeAJznPJvjE831UQ1sNDW3VFQxtuTmBoJE35oLgHZXz TQSKxD1YBOHHE7MBVifNwKkbu1ARPF/eOWRUzNAW5BKA0jGUN09KR9TQ1tzT0JaznpL//E1u wHoKSBqpklqxPVvEkTTSl0Mkje0co+Zf5lyf9l5LRD+bpBdBlOrofJDFO8VdqVhX83mnYG0N SznnpmI97ZOdMv2NDbahgaQGtqm872YDW5N2JNkplNAEfvicnZL0hYWYvjnkJurLtFOi8qqt kJAb1xfdN71SlzGwSaUGkhrYWiPtp2WQIt8puIGNIDvlVJLGeZ7WaK2nMW0Nk0IZEg2MbhoR RaMI2nBaA/d5vE6SCZI1gasvfx1obKxLezhD6etYLBnt7acrp8JB3muXgktk6PPGqrSxjgz1 6Y21aWO9bHNzkW1MSdkZ1cOYpuKMzO8vTUCfvLdrySCyJyTJ3j9gjfGqdeanrO6wFDj7hRZV UkBbBsxF06OSZJLRLm/dZE+wSsEx64S92tBoFemuIa2KJ4CLqhsqWFAYM53MFemkMDR9wuSD aAsKjblHo5mkFRVx64qreFTHMYPrbJS5WemVH1VV7+kmfLQZNKOpyceKmrcuymOm0zFTQ622 BwJpbBKkWBBkBwPRoIs2n3j7L9NrgT8xy96fECczdzNrzJhWp5K5H6ybCwKeqPy3B9tO4b00 FwQLIswLUgXrLM7snIGEXAducPZgPjmz/fupUV2LcGaH8idn9n/3cmbbGzuX3c05s6d5+tyc 2aEXF+LM9o1dijM7NHYhzuzQ2BU5s3lr6JJAjnczPPzkzC61fj3ObPzDd29eIaueCmfjVP33 t9c3Z28fvi3W3NS8ejFIkPQ7GCKOTdPwg5Fy4Vf4DsK4H/8OIcB3MPpb8h2cOAt0O38Hk+dl B76Dy6+pC2YJNn0H57acw5J3JP8Ouvh2h7WnOEvNElGsfmKWgDH8OadxSHS4hFnCnvXYd7C1 HyPa0z1miUvTC9lZyuN+4oUFZhoMcbwpZAPsCLNLIM6DaEXtzqypwAdZuCtGbE2uaYJnP/1l Oj9j/3womJ7gE39WvrKzxmqyfLjAIoxkT6D9ZnYuMGawE4moyfKLWq/rptZYY0p3ULJjuSPF R6fhjUQd7CncntTYdoG9n9Va4nE/hfdmT0SiCudVVfiHK6vbKU7kwAFTc47/WSH4n2GIOFDd LjMBpQIKFkDeGDcdYUTRcgrYvtCNIx8wUNft86nu949vLpfj24dvxTkHB+emrsveTHcWrLsH OVlzD54Ezuf3ma3ku/rl2zfnKaY5iAWua9wbsFwK5dlsgjfW+3Bf330HPKPN+WpGfLbVOIuh adQ+NSOqQw0IL/bfDTUwUqNqhqrLaobqsIRjarSYM/ST5wc1t7WoGbqvtOZW26x2qhl+H/ZL nGfuJ6RajCoLh325n5rBZe79CNIKRdomvW77K7Re/nPtuk1PVDP8LOHhxfYsaTPi+Mh/wSsr s9Z98skkteIN+GRCyOxdqgJNP+b5meoLGBM0KZh/tWBAVViRbFlUY4oqKupKVml0liUr9GhW afaHJjaOe4dm5PMZ7P3ZZAWJ6T1pKjeduOD8sz6Zi2R2/XKlEjt+5UTd3dh4P6ZLCWw9fj4y KmHdTIdogDfY62hTkwS40hitBKcqUN5fQFXY9f1BtASfVFjQEmqzqiX4Y8DWDq8bv/Kvykem uU83Javhg/6MCGFlXscI3/vexS1VRR3h1orFp4UzzZL8fjUilDU403sSodwVzrRIjTzmBtzc drEXztT21EU0EpLoWrvhTFPW0WV6wBwXFl3xMwTqxigmeRW0mxeGM+UrXx2MCIULbkBAhUdZ qAYaCwIGsfg6VHc6BGca5cFvKBWJZED2smRFQeYhiv6YE6Hk1MjLX4QZkPfydePRfiIU2p5H hIJMwGYB3hiPcliWfhfWir8wVpVi5TSj6xKhJBOQEqEwxaywOBGK7cQmiklGJ30AxWRrf0mn mPbtFopJsr+ibl6SCAWVbDVt8uR19oQzBdWePCigym/Jg3JiPsU9aFAQ+NNrhDTtgD9tdac3 aFDoARqU0exQuAeVjKtYaPn0Y8g9yL9pugctvanrvlZJLNP0t+lEnu5BaTl/op1gSRjVXZMw 7g1/6nZ4i+1wEu/wlSDAI2EPLCzzyB+xYKNF4X8Irl+yZQKBMQdwJ0JxQ2WLIQZT0WiBbZkA BCRngKBYl5ogVX7hLfMrAKDaWVrLxTheABubV8lU4O/eJza2LYhb4MIt8KnAHfpcCAobm/fC /Oi0CZaCsPp3SBbSFSU0dsNtPP13GJly8N+1wh7GXwUPkvAHbzBngq5Jduiuse+gLKpCjwT8 JreA30hKjr1FJi/Gs7jLTcUEqkLZSr7ZuZ6WL2HdhTXx2c/101Qhflcy+XsDvz1MHCgloy/j inGg9h2yFKDh/5YrRB6hJooDLSwQZOOwUhzovHFyIxTcOCFIcWAsDdB4gDhQplqN+lLsYqlk 1ycbB1eILhigMc0SHgcaFhaYaTDE8aYoxoHmwR22BSy4I/0iGNRjMf7KwR0zwGFh1U2NLShz uabAVuJAp9ZR469OvR2xqIfjQAeJx4Eug8gaCUG+8JyDKLhjLCA0zSCxBVnSYCFAsjBmx1S1 5b17gzvygly9PRTcsdLNdIgGktVFgjsuosWPvxosgLwxblRvKP3EcaC/Q4RHc1X1ZFquj2yp GXzo3EtuqWmbIVqquUZfC0Sjn/cK0Ohr3bA5DCk3braihwkq9vTWT0sNVEwcMC0lmGLC/Nf6 tpaaaZaubamZV8k8dKpyUBQ7fN4nWmpqsttSUydGHdDYtPqvY6kJI9Oe8yk7Z8waeJCEP/iv H+EPY6lpoKWGX8FSkx/45AaWmpoglpp5gxyz1FztXE/LT7lwfqpz/TNy9rVXVYUgYFiuCg1K 9w4e02PGuhCOb69fPd4rkw4ic0FZKYS8HtKGmnm2EzNNFHI6a0P2HqiyVeB2zZibyIZK96pq WmzXuEl9yc00SMgrVifThoaWqatqQyZF2E5g+v37q0CscequQcb4ijD9Tfz+22lDfpZyM020 gLL9HhUM9ttgWNOCJ5bGphU3jzqYBlCQL1JoQApTy5A0SjBh8V+dcKXGqpXG/BNcJZaVoRYM SRcKj4p1QQCBgH9/qTG1o1e57DlUWsw0kXSiI3PUZCEZiZB8AiIGBShZaB0nTsAamwcgQtZP GzthNus4XHaCt5xHH2NhaLXMkbqwxnxdngRJFlgYChokTyeg6+ohTiSOiROEptP7gWS04VIN EQZ8RpwQelWZJbeejK/Dst/HHy00tsbCgDbmR6kw3tOozowCbIFOL0pWwRnZHIiVxoBkxSem h1YuF1EnVK+a5ZYzh6OnohZIF4aYYwEsq2lvzpLx8X8L4Cgk4liYfjm0EAQQqqKPxvblZrfq Ayq6o3Ml8FWsx736Q2sF6V+JdaR/t9W3kP492ncZ6N9v2yX0coTNFz5esxhweQY7gFtXAN2/ Yhvo/j3hCEh/z1fhvYUcJMTorzp5M4z+ljZNC+b3C3N1tYtLZsUhtveUns0ry1d2S8tB4w9u tGg9FIfrVFT94+HF3nUTbMz/6vfXv7VVwYNxmrtI5qrMcHgKFn/X9n2E+v/xV7+g/lfFTXac leACCPj35NSkMkxK74O+X6PQ70a7WWnLcdCfg1bz+Dp9EnHehB8gBz+/Ej9AbssgiJWvov3l +AFmDekCoemxxTCNx2qHauBIPNYGP0DdeR4AwA9Qd08r3wPwA5wFX8sgfO01zOYQYuf3hq+1 CmBTI/C1ofwJX/vfHfC14R2Uq6G6OXztNE+fG7429OJC8LW+sUvB14bGLgRfGxq7InxtXZmY /RPtZnj4CV9bav168LX21zD7fzUn0/+9MNL4CxR3xZXViZwCxJX9G22t8moPwOXh8H9LY/bB Kv7LS9P4unSua9t2f+FcNP73Uvf2nw0nDW/qxl7Zl8Z8DVnpqq6FPZP1/F7fJOP0xbabCBKq uL/zpuF1jI/UjD9fl4e6lRck/P/FUlfYytTLHlWpeBQAYW+1rhuCVw13OP0vQUDfFfugnRFb ox777HvwEh5cmowaszvQ/qWemnR1ScsaPoqTj7ebAO7/M8yaiCfASbrUbRisawem4dE0vcRD 7HoQNTaNNQ9N2k6MPV/WCpv+IRo/qvP0hCqrCha5qtN19pg+fni8sVvw2uHx9h1dGb/Q/i3R t4KNUyIwybRhuq2WXQ/vMaxihXtMO+lb0bs1b3GYZC4bpXUrJ30rkuvO4fGsQvEL7bfQfkUm 988t8AujWSrBJLOGwJkGQxxvit3h8bQQHp+IhuIXTt/pcnj8VHfLH8Z1wd3oFmEs+xIej0o2 DpFHfEki2hNRD4fHiziBb/ltFmSeuqDTQOxD0mXYh97hA86oFa/T8QJMskcMj1+GaA/24dY6 W3sUv83EC+BAY4dcZ8/w+GuGx9+bxcHqi0bN/OUjFJDaxj8U/LBSQhGlhBkegIh7pHxFKUkp JbPAst34h+49zIBgsFDen2Jc5QWlhEIjkIOFXbAU42CwuC+ZcZV2WrMX3LjK57aSYLAxkuaK wWBup1aVnj5Ot+RusLNUwj9UWi3RWSD2a/yV1kl2ivqwpeTFLqArel0jm2bIFzASPBH+YlZj clqT587FYYPwfKdw4USSaXcF3fomLu+lcLWBpTQVTI8VJqAbh8j90vF2IVfZBFDW9prZ/4wl iyo6vT58qY8EdO2eTZNb+NTaBERqmuNUlXMn6qFmSd1c1O2In0wyENAVhwD5+RH4bI6NHS+A jc2CpGNWDOhCt1M0Zj4YK22s61ZisKYpwteZi1QB91k4vUmBbKBaPq2rtihIMYAOCYcEvZrH O5JdNZoBKNQcTnQOq9ED2HnZWmnFjm6GR0Eg2VIwKcjAgl6DpTEJwjaXFXii2nOeFQaxOGZ7 8Q+3dJ68hv+arIRxCbUWxhW+DlF1r/uuKs7+1HY1nCvk9R/15c/Xvxzq3o848IsOLmSjbctS 2yN4Req+2gg+s0fbVvAZDRE9xVCbMwLJ3OaIYsK+vL1r9eFqf//j/9yrpYuwYeWYMrdjQCBa P2wEohnaTJX8a8d4OTr4QL9ixIpqe2WQCLYA+FgOJGlVp90dx9bqvYThUlO8UNk9ASPeDCW3 i3gTykeevL3/rb68hYgZe//4+Pj53YdNufCT4oo8HKlVd50iPqzHyxm/iZE12M/Dbzojku9k IW8Yx/cMx3uG4z3D8UrVP2s4Hr1NOF5uRiJY0u1gLheOZydEGWFg0q20d9Cmmi1GudZ5xI0l VMO7EB4Dkm5bMaDwaF4uSQA8WpBX/+pgCp8x6fbeDDMP5P/VN6DJ1Ss0uRqlySUFmlxqT0dk 4+ieq3ZQVB6jyW0Wv3Tm/9UVHYaXx/L/lunib+//jWap5P/VOU2uFgIOcbwp9sOj4dx3wHV6 iv+Xl4hV0sbs3amUEazWaXJJyf9rb6aEXM7/i9GmbBdkhibfIOb/pbn/9wA82j7uu0/v/6U3 9/9ysADyxgKUr37Coz20//feQPa3ZNa1E4Yy69rifcCt8dHaIsy6XLZ2wdcVopnYdzRl4NbR 2QuQ7HFmXbuyMM1kkljSgmbCUc2EY5Fp4TfUsk00k6gvF9RMjmQCOIaBHtNM7EmvWpKp9Ldw AvtZ2sms64m3p6FkQytq54hM/DsRxlt0LiN08Xu0i3abWZeIKPweLKT8ZEIVsLAX8k5saxfo mOXMusL0QDKs4JRvGTKqjur+6mBr1NR20DkF7y03Fp7AACmEs+IqCGuSoN0ROXC9d8zi5JUw RBwBfNnZGPboZgF0aOYrYSEKOFe7uAOzrj8G1u19nKzZ+26tJdwb4/10mtwDYWLjMaVfXj4H Ta7Hv35Amlwv10Ga3LHORWhyXZgYJ1BDGFrqculurCFMs7SDJneZhVhx8jS5URV74eMQfsl/ dn2vwfTgrW/GnJF9NLlTwVQFt6r4bKSsrQKhbPxDrCquSwgM0VwAaHLH/AuZqxsjBnJMAQoH sfg6qAgVwe7jgdiiyQUaM5AMyL4p2QKHn81VmSZ3gwvVeQ3z99bboq5oCHjdaIi2lMdDQ7Q1 ZpGzMm490ACUXjcX5N30Jsi+a02TrBVFmtS+5lyWYAGUJmDo0+mlNeDNjUCtaC97LB40yLxB k5t28xBN7ub+8mixUqM7IKLJjX9ww0VjZrXEY5rohmT95vXpUMEh1fQONLn+22Lrf6jh7d/X vz60fv2fsjqp1Rb//Pl9wvpaCaQ4m2X3nnEUJwY1fJIgimdIxE1CImoYEkGvEBKR35kIEhIh ne179Xok9+OQC1W1nRS7EYpcqEQr8SSacLaOqEJveZ0awSEP745vR/k5Pd2O0nLVF25Hz5CI +4VE3JuSpZF8cF+57z+XcOg6OTtPdzeIdDRTOhafGVILUbF5u2TPJ7D9WFtzztnS1hxBlL8D GBPivBeMjoWzXRFEQCPbvV2KOWcBy5fA7WKmHIg7ApAzghgTBhEr+7ekY7GzhMAOGQQ52GEY lFKepjj/uuphY+OPgqlbMyZg14JkmZTqUisLo/Y/X7KUq/yOEedeZW210eofwbTz5ZDfMQq4 20l2VhhEkJ3VIHcMg0Jlw+ysZt+VfRAM6SYpP2GKeXq0bRgVyeTxTtIYsshd/mkbhwyEScGW Roy7TSJBon4HMO1cVMR5VILKTiwTKEJ2cdEmkAghOyuZzQg6ep7eYmPbfg+2XzIIlb1hX1MN RKSafnSjVzlCdjoBJcnKuVdTwZxytf9iDHOvSrbql5e0E2gCG2g9HrNWE1VorG5Jeczm1vMn Co3Fhj5TgEan6f6CKZxTY6pFDtb0nyp/QsQfjW1jwrbOk9fwn4atFDA+9GspYHfP4ToNDNyu ISwHq1erKVj3z436tZOOTkohakUzhBXw46sdUrtPXs3Pdx/Clcis2Jpd6bdLKTrRNHVCXthp 1qWaSOYm5EN///j2vw/1dTa5desRgb+rWQqhx2P3oserLg+cPWO7gM/ogUwd+8Xr+EDkS26W UrxrRAPMUnlbSaYOkZqJFpilQnlT7blnY335tc1StwXOfjB6PLv89GbOfdWmOfeXSNkZL4NZ YGxgmqL4DrLPYzvIQ/GYMT9tB8FkvrpSqrxFLkCVZ7+de3aQyX6FHcThDvLmDn5kB5k7W6r6 3qr/ZGfKzi0sVX6WysTBHIz2lYxLbkHuMC6t8bBlmwKhXzvRuJTRr/lxwSCVzT7jEmdrhpLx URcwsAuyUewyLg2Dp0srG5eQ1sOk7LAgiJGHrWj9mDtzJeNSMlcYDxu0beTTCxobyc16sjkj EHvpysalOd4pFZWQwkCgEzDNUS7ZzMNWNC5NP76vm6EgkQyxGJUbQ2CD1ubbs4QVlkZmXAp1 s8bp/tmEpqNYEA/asmJFTstFBhFPhmZzzFCsK1YTkQriCdDAKR0/4W0bhyxVJ6lBL7+E3ekk ErqDCD7356y7pZXqHiR3t6Wsa7qhEZFhNx6c1k1EmWTx8ER0mks2DokPMPNb1FlepuSD4uI+ O7LsfHvauRax1mOo5RYx2gyrJrHaNmnGsCv971+vP/55+6v/Y0bmGi6IscSsfuMGKQIAYn4J NGVz2G8W3HVS4szlOeuaO3HWSXJBkJypyktmehvfVDC9VUmIC9ZWxllnJ43BiDBSV003hy6k pjdVE24qCJLjyrU5BVb51ze9cXZT09tZnHUEcta1V9hQJNtQvztnXWVEPyCcdaH8yVn3370Y OtQqInVzc866aZ4+N2dd6MWFOOt8Yyhn3STq9AfYTbeMBtqIrKBaCgaf6V2T0yXDOOvSJ6os QCU8WmstpUwlc/am+T2es65OzEtIN8PDT866UutX5awzppPu/4yR/v+igvC/2wVYY3vrPht7 6MaU+7/pf08oWFWw7k0K80CYhc0NMAubFczCBsUsZAXMQtNINbcF7zGIvjWeapO+Nbblc0r7 Jcw5wSy032VtqO4nfWuZuPty1lHdFTEL3dF+sr51KmYhW8MsbHLMwibCLJyHON4UCGZhgCgk HVtN83eSRAg9cwHqZvS/snt1bix/XdaYjkJqwSKMegUwC1kZszCnpVlETZZf1HoRs1DpDkq2 aJl2VFkjIUkFrtNEmIVjAaGphqqemIX5mDnMQpLVvTJmIQULIG/MoQoxoj4zZuGNkYHYVVWF 6Rv7KVQFdQNVQa2oCgpVFWhRVRi6FZMn3wtv7IG5VFFVaFhlL4cPpiqUTTOMiKrnqWnmFvDG dE1VULmqoBJVYRziDVVhcipl9LbXhTeme1SFpkRv6xZhfrSlS7tIbyvJBVUFBSXbUYB/9gC8 Ma0zeGNaP1WFSL8NQ3RreGMGFgCmKlDef2ZV4TeAN743+wLjnc+jSTF8eL+NXCgOqCXjNvs0 yIUemv4BkQu9XAeRC8c6F0EudCHchkC1pG1573wkOywYF8Y2NvuQC2viY0LSJPCAXFgYw/QT a3KYtlsgF+ZV0G4qQekS/p0LQsbZF0ALQhSm/ciFs0gOJ1jUBowZG/pqoLEgYBAPIBfyEg9F PBC7kAvjxoBkQPayZEVBwBBNPQWvw/VCjKkiVp0RvdDFbxV0aam7RB9tswj90FjyssWHfYpa snfMOOkU7HdhrYzmxo7Jle20MkQxUmUUiIaOWUAuXJsAO4hNtjelgPgAoRMbyIXpwjuEXLi5 vzouWiXB/SOKT4M3o3SPVMmonoFciEkm9F2RC7e1nrzOudCFF8Ae9Gd9FIBtVdTvPgSXtWsJ 7XfJtP4Vw0rD3rfV9LsL+A+Rnf+8vQ/f/nF1/UDyrvTKzxqSemZ0KYfRpfUVguHyqw65UWL3 brzB7KDaR8FI6lpRVUpLne8hSXTpeLpOd5q0fHhGlz4e3uC9OY4Y71u5fA5/vo8fRCbjz0oB oXMHgUGsgiIUR0t24Y4tE6sokOLI/3abAbA6gOJoDPZEtgzfs2WAjnV8yzBgBojMFsiWoQe3 zOUyuZl3WuwJZLg0xZGVBzcDOIMFSPVNeIPwGzRU6P17sKv0kSvtWACv0lMTkYZPuTfs57vk yM0d7JayZLnCmFpKhi7kpzvJ5kHc7OYiyOEC/BZaMLtsFNCLSnYAWC65dPpstsM2hfHYJGTY uNI6tRm1dti6OsGgj+7HWGq3MoPoFTt0PctV633rzEN0rV8cNXaDxi/bOhkzJNU3v0GH/bXS WDoiTRLtFG7QieDQPTS/Rq/g5wnFB9PVeQE9JNnmFJ04m175v85Gn2S/pxlgj94DL8RmSoNe SfXkj3eTP5xOezu0tFOx+n7XS3V1m5TN/OpAsEv1IC93qR7PhOteqlXT2YU9o5Iv5dxQ2Sbx S5lcfX6pDuX181L9ACmbD0cJ2HkEyMzGrHZ41lPSi1/Ks/7kBCzD+FMCr9T1UPVV06Ub5upX 6j2cgOlXGPOs57o4ps8OIve0PphnvdCYR/5i1LBhr2edr6ivBc+6UhAq3HOWxSMCB7H4Ong9 vBwnYNwYkAzIXpasKAgYIgI96+F16DqTWD5FHL55umc9kOWd41lfI0cuFuCNsZ4y2O/CWvHR uS2ndRmC7LqedUgBGD/BqSBwnYVObHICxgvvKCcgWRkzh9NR6bbvC43NnnW4JWZHuoajijWG DG8cYrxHsuPL6twr9bbWk9c517PuPz/jLe5f5i+CX398zPBkZC108+mV//Re+c9rBLgH2BNC /8fvRP/XiXrdchDwX84DewrfllCeWQ6qDbAncBHqFK/dws4tB9lJmYE9hSM5txyEcrkLJRqT 65e1HBCuMHL07P2/Mv0f48L4b6ijdZk+oXvsBjtc8dlozrQEkcKiWy6qabvk5SvbhU7bZVG6 FhvAXruBfw8zmN3AlvenGNp4YbtQuF2K9H+pyz3fLryThe3C4+2SK6OXshsQArfLMHS8amiT bJdb2A38LJXsBkqrlxEWZ/IiH7rqh8YcdHllZL84MUeeNFblt8U2X8D4Hdj+Jc9T412OShzf sLfgkWEn4oHQtKHATIFS2e0lNdxhhMjrUtb2mhkEdx48UWxsHN6Y9rDQ7wVuHm9sD6mhWpuA 6NaEkRqu+5mHOGxlbTYDTxsCe74YbjqtmcBncw/uvBvyHVf9WZB0zATs1eZ28mMWcOeTxmLU bYOTdxoUhhvHnWdwepMClMpurNsWBVm6mb0OotqvMPbFF6tGM7DhGNpN1Ss9gMChbK20kPaw IBlE81gKyrSHYGnM/IebN3tIe7hlBVoZxOKY7bUbbOk80GqgvDc7Bd121oPv7Ku7DnkyvOL1 1J/BmyjunsLscVHc3VqNLA9f3t61+nC1v//xf+7V0onPyoDubgEDFPh+2ECBN7TB2Afp0KzS D6q2VwaBjw+mh4vhxz8Ay6FsPBL3tDJ9qvNqnvRQC7ZmARPrBrCh7rlc2Qp2ia3uhdsyHt6F q/AuRjoqjQfa770N7DWyhDXarfm2bFLSNeXBEvZhe/vtQ8/8gcxFFhXX3ol2wZ6JdjIqxdWU 35rF4TluFawllcNogHx7/6lfP36+v9tjz621tV39u5kGL8+mWN2LTXG4IKS73VCt6DpvNdsT 7jD9jlj5hGoq1tdIfFDVdnK+cyRWviBXDyDdQ7l6WvkeL+nm3myKZ8QHHUfeMIUNw/MN8wDx QcNKfNCulBu0/Pz4oOGE+KDhkvFBmFncxQcxkm2YW9j5hq34oFFAh6w0tAaLD8qGEKJI+Mu9 7zWYnqwuW7FyZI9eB3mDpY1xb6EZ0HQhKNkJyBvFMfPxCzGqABzEA8gbvhMnxAdZGVAzUxTQ EEsGZC9LVhRk/HcD10r+OnSdyQSRbRr3S8UHDfpgfFB+X9o05uyOD1JEw34X1oqLD6r0YLXg HXuzU9XQOVqbA5LlGv7qOvOc6tuLNki2GR8UL7yj8UHr+2saCLyxdeSNecNFa+UM5I1NybYb 2yw4aOe7fXzQ543xeXhGtxMY+k5LEHJb37Hz6e8f3/73ob7O5pBuHYHwdzUAIJxu9E6cbsKh MB650OwI85kBjsHplN1nhHM5ioVLCd5nqjluIanTLnELS2/WON3Gjx8M87Hl/g7wNAAAA4C4 qQHgLE63HMaGXCduDiJ2/t6cbtSorkU43UL5k9Ptv3uBw4lSotU353Sb5ulzc7qFXlyI0803 tsrpNjK3EdjN63K6BcnWON3CE6dxujlutUaJxboyVUUk+6ScbtHvE3K64R8+clU7OQHfO2gn V0aDG6PeNpPvQaaaHh7N3p8jjTZYBeTDAVRPch0xky91LgZQ/SDIVNEs7Uujtc+iZvLCOnmJ DV4ZLAy5TRrtVDBVwW2hnPM5fCxDtQpptNSYur+mmbxtwZiV4bW2X4datuVhgOqAqhV3Mx3N 001xcDZheOT2WtnfWH1ByXKr+DmNMckKBvyAjKW5KYQQ4/BaWV0JUbVKWm4qiJaZN8C+DglQ PstMPopKG6bbihTBpDYBqlFUrT1m8s395bFT+vq4mXzecMPlAKo3JNtubLPgoJl8U+nJqzyA ldwf9c7w/P3nV/Xjz9cP9fZDR4mNPpq2WPs8Y/ntsKqepuhjpmhyG6yq/CZBrh2L1ineiLpC YtF4p0wpFo1PjvHVFLpZalU1tJN4xmnFkjvDVDydXi8vCFZVXz1N0ZgpmmIms+T914xFe/JZ i4k68NPxWa+RVHa0sHH4tHEWHaRMUlm3jXR3Q+Sy/ZAkla2dxL6Z/WS3I6k8nc96HuJ4U6Qk lWBl+UcDwfV1SSp38Vkz2s+SgUWY6Gj7+awTMiJMBz+fz3qrIMu88w0iJJWEZiSVR/isdwmy dT0Lkj0wSaXjs74xSeXvwGf9KVgm702CfQbL5AEszHkZfgYj/sQQ/GhG/Emu4yyT9FJGfBfr zgimkNP29rHu0yztiHVn57FMDsL3GkwPmOPCooNH9E2wMPnIpH1FlsmGsZbXYMx8LG4bCwIG 8RjLJE4HvmbEz7Ewi0M0SwZkL0tWFAQMEcFi3RnB1xlOGF4ylR+LdXcKZX0ey+SOAPKdY8aE 0rDfhbXiLgG1Zo24F8tkMgEpy2Tdtn091KVTYzPWPV54R2Pd1/dXp2rOG11oLMHCnPdX1E17 7a0uh4W5IdnxZXWeUvpkmXziWT5ZJh8YC5NBzwS7gmcivx8RxDNRuc5fyjMxH1/ZRUjTSkgB g+Sz0+0sakqhRGe/u6hnYjqSX17yIHlXPjw9E2iQ/F1ZNO5NTSmFqp1xJhxn3tP6+u5NH8Qb dc52SsTaCcJNGQjUWLXLKRHVQbgpnYLZMnthU8B44N/RlJwS9m89ZjwgrRYzskTyfD3HFcE9 U0tT2DMzIOaiUwkjUKdEeJ7plmLGA9eXl/s4JXwEoJn2X+qU6Kum3xMAf2luSjtLuPFAyqY1 mfYd3xBLHO9Qpe1UZdoh4pAz42/VseAX6ZZ+zAxNC+KFlH/A0Vs1yUghMjr4RNSta0CwgiYr tAeSYQWnXAPAqDqXP+nbq9wposaoacxgNX7w3jVR3RM10phw6F5qjWHC1iVy4HrvmMU5G2GI +KGk781HNwsguGO+EpxjgTJxAcfCru8PqOZ2dtmnUJtVn4I/Bta1cE7WtPBb+xfuzbUl6sFh yWeYf52oM8g/XE0gl/MxFNSE+ZRN1ISZHCTDzfblgs0AVOnzeNBP+AmZqwm+Tt0DAKrJLnqC al3CzV6wroGqOjS5muDlcjCiuGo95wJmakJNhLiImlDk2+rseiF3wNPxs4TFLiBEth6psnxI mg106qFJp0FKka+941bpGQF3yV4CZmrnwCZSUoRtSKimUYIMqSBNswgSOMmgSyN3WISIDMLl xO60QnM1J7ZxJmqBOaiR4Y0LmvlflMSt01olakIkiGpFBY2x+ZixaMzCb10ytvyTx6I6jrJo ivz7KYaCnq6zMCLdvpiNRLJIkG5IBel5lwpSawHeD2fTCbJPx8vej/MguRHhfSpIg5jH4/eb anMCQMGyNIhgydIwRkKi6CBIRTcEQdIFtySLBGFVLkibLQ22c2mYptTvsmSRIKrLBRHZ0qh3 Lg2z+CciSJLT1FEvSJwnSiU1EKn/SrqtY4Tp9Aypvk8/3av55PUuB3Z8FAFGVIb61AYPOB2g in/+sGr1ly+Tebu62Mta2jQtQEb+wlzPtHNnsKIp/GRO6iea8rVcRKfBIVGrCVQLCrO/UP2j /vRVhZsRXqx6Kuqwtp/YUC3cGD2WO1lZ2ef6fBwHd9nnw+Wqz8c0fgVBlw0j6pqJIQ9ERSbJ BRNDpir5HVGo2o6aLtwRcSqyUCe0tQ+jyPem4H4JH5gX4H5x5f3T/YK5X6q7ghTfm4pM01rz TZaMlicsGZfIEBmpcl4QdrKqYGWxz+MOTNabVrX5DopX114yv1guwE7Gq10w3yb7FXYQhzto y8oCd9BkCdizgxZte45WPd/K0tMeRyOinmT35lYWP0slLCI36Plol60d+K0kmdlS3bAgDUK9 BS5f8aPJbwf1Vu4/sXe2WmoHYpM2xhVPV3KNxODBMTMJFVNQYxLqLS97Dt+Md9OHb1XYo5lk FFJvYbPJVZtGv25Tb4WR3nGTmwVJTyVJQGewqzRggxupt7K3sZVugrmKDuxAvZU8IRsBqhS7 ufRqLNig3lo1jIBVhHBSxQq+ozMqdHPuxHQXcNRbs2RTkG/azbbEtAVHZIV6i08DUezmDH8x jRlYZ2AgDrCTgcbW6OFWx6zt2z4fomzMJAenxmhmkH0NV0ImBwUzUhozSA+XN9bn4eYa5pUV xyzeEqPPIO6MHGYD3D4ry0lqUH7F+z3Jwuyawzi/+PoN2q83YNZq+y2zlp9aUK/q5O3Iv47a Y27OFnZ7w9YJ2BynmMI6x7O9VPr4q3/11bzhpTgcXWOM85X3f+j+z8nMM0F6DM5jTsumE80l G0fEz4U/H1zlydu+sp0+rRnu4SO1bwQF8zmNdvcItEboyMid6Mi20cgz3Mg1S59QLeO8BdEg vpzqmUU9L8ftFF5zQSBgbB2iAR3Z9MPsFC4421GqvmSWvlD+RCMHlj53ByaYnSJ5/69MR9a0 xge6+Q+Q+5Z9++dd22PlfbBHvNEf+r3X47d0PpQK++eIoc8ZJFoYde1pULgCGyhfEHM41WTc GNv6kaRmj+7rOJwqej7eQGhbOT0ZW2DHS3Id2EC7DH1YX8AGcpT1+Abi8QZC2rpIOBUh2Aby EQu3N/T5WcKjrr3Cna00mlwQvYIN7GtZY+NMLeEH06OsE3Ad569bMQ2BOQULJp9BtJtD3dOF V2iqvGbPXLUaus2QdKKqllv22Fab9xu3TAw+zGWrm/vj2ZBOxAPhmb5LOyJpbK/JF1h6tyWj rO01w0y+K+ssa6tdZsReKp0DsNTv5Qm8MefYSmcEmnzV2gRESnBi8qX1ULOkbj4Q3mq42s2y KQ4anqzmru1Gz+Fz/G/b5BsmZYep21tpmyzLuptR9qNebW4n3OTrO1a0tIYpkg2eTB5Mvlkf qq3pXbEBr4AFgwlYbSzt1dx6JLvqVQMmAJ3NuG40InACpkYyyfYZ+k7RgkAbd6B/pwYEOUX0 7527YZfp3/0BuWnd9OCtV7Zu+j21XIo/tBqmTIvicJ9hEXWLD1g0K7Zl0SQcsWj2fN2g+fkM k2fEztlrVs/mBe0ruxXtDGrBolYPFzcy+jyy0L9/9fvr39peAr69e1uzW/5V2Wx4UthdNzR+ 1f2Eg+NRAcoLtumqxglqPrROxqbyaUFNObf+aW18RGvjExfiV8OFQMgTqzuRJ0qxFZiYZa+d ggshlLA7QoGwKluuCa2S5LXpb5rao5z2WY67LWd8GEN+oLmSLmB7CWK1VdZ7oYG5MpQXAfJ+ X3Olx4W4bWDiWeSJeaQv+c/f7Q0ifX938kRiL0gYeWIof5In/ncHoLW91tjvCfHlO6yYBAW0 PpE8cZqnz02eGHpxIfJE39hDkicGydbIE8MTT/LEJ3niDckTJXe3aW9KmRAIq2obd5kc53NI nXjhyiJNxWcnXl5e9oIvRCi+ToahvAt3eXoPl6kTby5vTlEr+TlqJdaXXK30lvk7OfHK0ElG UnJTJ140SyXcZaUXnP15FsC0jONEGe1Ib/8z3voG8cNEj+aNwYj7FSceKACTnO4Gg1nQp/yj 6d8GjbjXcgY6CO6XBHe+NCIQh6n4RLGxXGFIw2y7vlFRzLCLCKZthzUWhjwqcLH43eJUarhU g7vvlCUDvcJnZM39AiUzBW8HS1biEnE/zWbBUxPmueipKc4I2y9ZBXpVOpHS7RT8MFPB9GjS mJ0/utXNlU7EICD+B1TXHN97EST3EPEBzkj+uuKizTqBRI+vTUA8Zq0mKm1sjqeffQXKgFEt LA3ZIPAk03+V5htxlaXJEKMpX3WYIy79pyr63YTYHDMYcY+Omaw4aaK9uRfb5pATb4fSk1fx n5MVF5pQax60cAhvOb+aet335Y7LxUI7R8q3Pua96C+5ufvLLvqpkncDjE663o9QOXbcbQUs EcDb48teHb9ybT1bq/cCUucNLFqL/foCbjZDyeO62U4Ox78p8kbVceoGVn0dXt+spD9fzZef P/7wtnxtR8r5j5rVBpTwrt2lgbdvfqHPHhDvOdE+WL/kZT4Hy+Fkx2Ktgy9Jvw9hM0+SB08E 1d67Xnb2nOJebEUjQ7LNj692Fdoj79X8fO//estWiIe+KLqm7oIN8iSBfZLAYoYQ4FKrfxUS WIKQwGoqdNuVsD6OkcD29h7f9gJkAAjHMDGkto9ZmSOUV0PVvwCXmi3vjS9/utQyl9p9sT7u TQLLuPJQYkFt/vk+Ks6sjpWQ01naZqWfVIbjQOvMcDlbC0U6ASWg9UCOOe+YidMt/F72Wgvn 9xMMaJ0ZNtwx5L9sLbx3yD+GoGp7Muh8x1w95H+apZK1sOfyZfQ/zAiRRcvXkVh4/2Jn5M6u +W2+sDFroa+bC/Lbx8JHTxQb2wF/ckosvJ+R28bCR5b11dn0kiHwJ3PBjWLhZ0HSVSxhr06M hXc/CH8Cpgjf6An8iX80BvsoTC8GxzH+ZQP+hBLE0lmczR3wJ0D2krl2Df4kdLOFA1E4gnbB n6yYa6eOT1W2/AQkWzxdV94BO+BPSt3cay3cofbklfwHZS3kfpCfJOT+dwEUuXv8fSuUv3m/ vf+tvrwFU0NkyeHu+l20ez0+qsi5O+K2qLmtaAa2w76m2EXta2dE8Dvl1e02F3gZGSCttMb1 V7u9xlfC6D9p/H+na8qDfe7DyvztY8FmYS7jprjdTkwc6JloJzNXXE15N0Wxk8cNj7Wk3sLr MhTe3n/q14+f7+/2BHYLfs3DcSok8W9qd6S3wRjOrSsEsTtysxV5fMDuKFSjmq4Gdkeh2lb3 xpcnofwjXeOK3RGEHPt3KIzi0b17zmFPMYa5aJUkwO7oy8cQ/6fd8b6h/BssqOQ64Dw5CyoM zq95y8l1gvNVsKrHwfnG9MTFCec7Zfztik7Eymd7Y/QOYG902ruQNR84DM4P5bO9cSx3pDa0 oquMTfTQTrHHDbA3Ok6Ntho4Ke4UWtgpdGWnVMhOORqcz6i21wWSB+cPzcBbXRumkp1yi+D8 cZ4yi2NYy7UelO6yOU1iw+2Vg+khe6LOb+jTGiJLPP0yQVMBaXntuO9yJ1Nub4kfTd8rY8n4 YK+nErwfNpYLMjbWp431fbcMhO6aqiua4vxZVup3KJip7ufXGTSe3o6llkN5EIkVXrgA+3xk dkjm36tF2s1GVfkTrCCZqmkHj6G5rqxlI8q8hdHSmB+NlpWdvHzMaCNAwZbFce5EnwdjIVOU NtYaRWRjtf6ksVhUbALG15Vmk9v6RySr7fGme4I3ZjXKzWg4MN9lYzQnK/12dU0lQL/zMTOG 9bKuNKib5rp0DW30ZmORIKioy49lR5DJQZPn91aiXhkzJjUK310YM+D0KIrqOiPsyLjAs6MT EGQvJLAsjXHFGXdOTMJrpjl7sf+kjDRNY3UzJvmyzqZGSx8/XMHiV3XsTp+s6zh2DzJot7hj l6w4dhPShqTO5Ry7pODYJRd27JaoMRfl6JM4dgkh4EqiWdXdxbFL7uXYJZuOXVJ07JIHcOyi rsCwINda/0UduwTJvrgjyFn+KHQ0TgU3cuyGLBuBSFYquAzIWSYYnmwBHLskd+xi04sThWfj Pb13U7LzQM4mUcsTQJIsG6SbRdmhZOUsm1yQPUuj9CgY70z2NcfuelZVlFwzNVbP3rGnY/e6 jt3PkBhycqbHiW4sSTsiwft6SeTG+34fT+zxnp7kuz23f78PY+rTefp0np7jPOW3wUHLLRjk 2kkb0phWdCE5oiu4d7ZQ54E2A5yndUVpjThPq7aTixsndp4GuWqAgxbK+TNp4/Gcp9VVbXtV tjPuatujBdteezxpwyq4l7PttQXbXvuYSRt0GLxD9G4QL3pqK94xrIvtFTe07bW3sO15y2Ua IE3aTdteW7TttVViFVFGp5K1KQSG2bLtUbhwkjslr4CJZ2fSRlhtYCllNgDUgGMnoGPVbAZM x9uNajYBVo8zpLqTbQ8i3HN2um0vrpuLOs/3Hkutl2w1acPNT8G2NzZ2vAA2NguSrmKJrOKt 7XRq0gZpdydtkDa37W0QGGTLeTVpA2zWvLFir+bxjm9KedIGKfI0pEkb4y+rmyVtYI3Nj941 aYO0F0zaiLv50LY9ew5v2fbosMoCGw7VFSH6agNp5pnz8cz5KKwNLQZvN/zxx7d/XmdkZo+N 0qyBCNmayteEFStXkRcNDLfN2jhsueNMc3dMfKjh7d/Xvxzhwv+UXfFfvn378+f3CZPpqoa/ J6DJr2kbq6BtrLmCbSy3ABDUNiYvZxtTZhB9K5DEAudqvpRtrKIdMRDQRHFD5RyBlgKaeLmC peEHKG+fiQWYbYyze9rGmqvaxnKy37sBmrCB6h6xjbnyo7YxX+dCtrHwfmgb8+WPGfdmtWM7 2/eKe+tpn6P/h589qwaW7pir28amWVqzjWXX3lNtY70ZFmzd8OJV29i4sBHbWKibRQxlccE3 sI3tjHsLqw0spbFgiqBJJDOFqLam1YP9z4Jt7L7knnZG8sAodkbcG9uKe6vWurmyNAy0jdn5 ub5tbBYk6nfE9snzJ+4Y9+ZnM7aN4dN7iNzz2nFv2QO0cGqAXuVxb1h6waG4t6kO6PdYXl5n R+LevOyXinvzjX2SuLfzbWN3N27dMu7t/kjFn4zf8wRTyCk2pq7te7JU+virf/XVPC5xOdKq McYNSP+H7v+cDC+TBSUMSdkEcl9az3P5OVsf85dHilGPTPwYBJ1PG9qD2tAaaEO7BvJAbikg GDiHO88uZUObFIqX3IbmGT1JAXJgVkAwGxp7gTY04uIQXnIbGqmrpqt6zIbWqarvTAVsaL5c m0taBH4dGxq7a3xZe1UbWs5AC21oboe32A4n8Q4/PcAsreH3WGxE85r/hEbRL+VssJ+diAFo 35YZMXDAllFVbU9gNCSzkzXjUqQoHUEzHyZD3S+8ZU5KHuVTWwmHWMP7Zj6WbmdE87NUItAk lzIhTKvkEo3tqCuONsaiSR03wVwwrv4djblvSy0BhkAuSExLGkam7a88AaVHW3iQhD9wYxeM qelawu2hW/e+g7KoCiGU4/QelONhgi+oCk1LFQ+1L6Ev3fxcT8vbZ6j9A4Tan0U5nvvnyXWA /2CE/u9OOV51EqUcd+VPyvH/7qAcH6e25q0Wyb7C9SVyUVSzcZ4+O+W468XFKMdtYyjl+PTE 9AfYzWSIlsagCkVPlwyjHE8qaAUZRIOfhNY6Hl4hRUuiJwy3yvOvTDkeVmLdN0x+QsrxqLGm rUndcGRvbhYsjYm6kqqRgzat7Oqav9gJk71RdddRSo1Uc11Ku6HzjdGkrciFxuzaVJ2i1dBJ 2bXVi+wF6R3ooSG95Cqm+7Xt2dWTSxbFqjdNxSSfnx5ehoEz0se9Mm30T6JelgrUpN20oxU9 2jQv9ZANkWJxTWKSbjpZNi8gKvyP7uKAf1dTRb5ERWplxyRtjNahpv3LMlehZjZ5jYd8pFXn /zWEXuSSuZpDLFnoWOhm+EffDZHsS4W5MVzBuj+1vTDq/8lYXn048EZoF385ymyfYscGX6X0 PCIvCLN9vQ87drJRnMxsX4k0tGsur08x5LL9t5eTQrs8SUnh9jKHwt0+7VE20bjcktneztIa s308cpcJH5lePMdVzJIcCR/ZES0CZn2/uSYNhUDzpbBuYr1Kw0f2Jn2dHj5yCdikSfaLhI/M x1FLdozZ3Dp4IhcVSlZaCRF9+cRQlMu+u5sqVw8QTvJiY5CcPB4znJMc3U44OfnWQAxNaQJk 1gmB5Z3mBbCxaUjyNVpFy9rKLumibArVNE7FKEjWNJGB2BVAeOnlyuKgyQmXxcacm2QeXq9A dxGatb3AdevdxEZkvlnZjsUzQhkVwwK2xga7JQQI1APhnkEQ02OCrEvGlnI5JIIwZcc7EaTS orTO9oZ2bek8eY3ziO3PC6Y6JdPvswZT/aK0782gOuojYf75mEZ2mBMwW5fsWRzb35gy/qTI s0sEc9lTRYX5ev3u2aHsqgqbQVyRdv1EuLBPAk/2BBu7F0P8NRIqc8MCwRIqq/6SDPE1bQfI EB+XIx7QJD0MqCQQbEwSrkFCpVdEFiUjCwaz7+8b6AH15dWvHtlyogf0rgmV92eI73yAa1AA Jv2T7zG6HQgFM+Mv3zDjD2QgTxmSRzYMiQxSu7HGIuMWIIjvZcnoRm+wYRbjGs/kGtiuDZPV KRE2HTa6GQKNbppVSpGbGt2iWSoZ3eRi86mJ/wqnxhAte5juZLLGRltTkuA4Tw+Y48Kigzfe Elr/pA31dVdadWk3PQrtEkPZV8PC083cLFNqTN3Prrjph9h8ChaduaAd/ze3dbUtGLNMEGwQ i69DLvZuog1mpsn13XR6h64MXIZMwGbBfgsetJie0RiDg5gP80pjeN1I647HbOAUsayU3wvq xnNmmkrljY1TI+yQxIL4hI6sbidWJEsHSLJ04okg2etghiu+nbyGv7rOfEpIKqoE3ZzGrEps muEiUBzVdUOlvwUc2F8BYVb2eGPuRgDOhGzD6cSG3RlxZNFuSqYONbZZcNDotq315HX892QF wp026xju/kzfsAWo7vEQx0+8mT9TtB71Vo7wJ9d34k/evpVb3eYYBHhfFS4ZpbjkKSZl1yVD 01apQYK45OwUQiDA1XzJSMt56ZLxm9/K78yffM1bOaRNxm7lPfw+9Ttu5TtQjqaHx6/+UNgw /AFv5XTlVs5vsGFKt3J6wq2cXupWXkI5attOV0RVyYa5xa2c7ryVu07ZUdhxK0f1awgggt60 WGnRnXYrnwqmKqULDrxxLPc4r+jziKJ5+pVu5d2eW3kyMvbmgdzKW1E3JNHNc8Se0uvQWznd eSvPHuDo0vC4A7B1IGremf3XiAauleiSoqPkU2yd5Y8Wprd8kY5gElbvvi6eBd6sV+6+W/0+ 2fjAG4b0Ox+ZvDHdt62yd/8ahFzBIQJWgf23ctDvqID2sucAACvaG2u3coAMtf9Wvrm/OlXb /6dwOPHtW3m0JdBbuf+LD99hjYRw4tuS6TUa8eMFh2/lW1rPA97Kf3m0lafX+9D9mt0GAiW/ RRDkfm1cJNTafYEchkAhAALFHxxdW/J6z+rvkFw9BmOkQLzeFeWVqvL7tS9n6XUheb/SmNfb /r/hmff7eF5vftX7dU4+h8IIGw2+NHr7ek0PZJrM3+/P4/QmD+r0Jidcr8nFrtetHBjBrteD 0uTWIMLTLK1dr2Pt0RsGYiXbX68L6yRTlH2vwfSAOS43lj15Lae31aDapbE7Or0TQbBBPOb0 Jpd2el8XmQVxei9LY+0O5YJGofURDGI+zLuc3nHdo07vwnuPjFk8Vy5WtXjxB6+bC7Drda3s TCfsTbQlTeqndjGuZ1yvk1PDtR7tzdXrNdu8XsfdPHa93tpfipBeDNWp12tyQac3Jlkv73q9 3lR6HvB2/WTZ/rws2+HYsNX0uwOODrfwf97eh2//TGkqlHelV/6m5gOEoZvdiaGbm+pyQfNC cTk0LYANs+Wikc0h80E4TDViPrDvqDuMhci+m+EsROPBnJsPQnlbPc0HiPmA6nuaD+qrmg/q bGfcG0E14DjkCKqULBEtsX4UL4F4yzhEPS4EhVumaiXjGNKeLZ+/WHlEixIdxxBUzRNBFbcg 0Kmt2IJgTDuQbMtc3YIwzdK1EVTnVTIPnWpb3ZsdkKqnSNYpXpE6ep0tqF0BbGzeC4tk4yZI CxBaHLSxinR0C6eJRe7JMDL0AKPLRe/pNTxIwh8cgqqh9GEQVGuoCl0D8DE/8AlEUHUTvKEK kTTyaj1/cFyqQBUaN0imCmUr+WbnelpOn6oQpgpVzT1VoTsTMjLS6uC+XuP34UNC71NwrRyI XIxCRBN+xti10aeuGO0Y1FHXStTWDhCvGXX6iGsl0Ov1s2KUlFemuswGgiBe8fOeQy5zrUzM VvkGyscrdq3M/GTXhJbX3A6k7pINdAvFyM8SohhNAwJnIV8W8RMZVFbynhpCRuUUfymm0VAL 1kDJaKc1E4lrxbH6NotB3UtB2w68vyDZ/N64V2CFR2eAZ8crNNZFoYTzIIKlFHfTwdMU1Q9W qItRzk1raWU21ybP/SrQmS2fw2gGbDQDzi6IhAbHDF8JdbvFF1gXVbZo0R5AQis0JjTSKzBm WUGJHrCDUaYbY2ZvLTnuVsSolz7aK7MxqnYQC92kLbJoi6L6/cULG30QQ7upvJs2K6j0/jFb R0ITsjUwpTmDygqP7kFC43u8buPwymyNYkhoOxob/70DCQ25mwVItDoVJEZC8wUIElr80di8 55ykBeV3JX++r/haxLqr5QxYL3dYRR6WL2/vWn242t//+D/3ZulwhtgKY91JsGCGNhgsGB2a VVwwv7MjaSfgqhD2WI5G9BsB4IlVtTE3wxOTjV8kE26bG6VhNUPx3CVxJgHok9cRTOFRoLZL AIDdxQP6C5I5nuuNHOSaN5LLVW+kafzCgc5ERtSN+RivQUK0g4+x1W4A10wAh4KRRzXg5SUP RuaVoKyU7ItbAEZV4OUFJUuBwciOmKBWKB+jsqpgL1vAxxjKnxBcqAntvsm+vxcfI0H5GKcl kHgT+2qQBN8yziItRI/FI/u5zrdMvpxS3q7etC3rX6DR7MnHWDCazW2lIFydJnfwJt6Ij3Fc JclzqEluu7FtQfwCp+DG2iAhxPNeyB89RTL7bSHUKACSD7yJDRiZO3kTW3iQhD98Aj7G6i58 jH6Ct7yJR9BIx6WK5ZlwUlCFGjTP5JrnOlb+C5/rJ6pC4qaq0Fl8jHmkIvnP3+0NIhV/ez5G IZnB+Bh9+ZOP8b+7+Rhp292Dj3Gcp0/Ox+h7cSk+RtfYxfgYfWOX4mP0jV2Vj1H3y3zj3QwP P/kYS61fj48R//DdmSfvnkE3fNEzpxvgatANEaj9IG5rX9BNoPsC38NS0E0YKGn4kAbdTOUX C7oJv5KeGQfdRMV+aHI9Mx8vRM9kl7AflJnz/GfylvaDaJbyfGZuT86hDosEzEK+LFaur1uP 5p/H1H3e9Y2q4cEyh9Qs9SirTdIYs7ecTs6dabhUA+nXJCsV7Am6iXpg9pELrgTdJHOzi1yw tFHhlf8o26B7aMUYEXVC9apZejU/ETdmp22TbXDPWpkjaYqS1bkg2yhdZea8HeSCKzsgf00a J4ORC4JIGjhmcyfW1grtCe/BfBclQ8gFpx1QjKQpNbaHXBAMM7o0dpILgkiaHRa0wg4YmmxU ZWlv7iIXzOcMSnaAXDB9f9MgE7CfXDBtzNDbB934831x687BJG3tvMHDFYJt3CEFgmUqdhUO vVNjZZ7ce1fi3nvy5x2L8Dk8OZxp7vbzhxre/n21g6rtsWB36Jdv3/786Ya3cRv7quE658Xd tF3NjEezV/a9dnjNtw/n7XjzeADcrKE1tJ3xaAvu4Vd7fr51H+qvN7sbfvw12BPjfdD/v7+/ /XSnYtutgRi0ohnCGfXj63fX0JdX8/O9903FG0uxtSCdtrMf8V3SkFVhLtSMGLSbFVdRf9G9 m1a77D2IBfdzUhzW4/FJbdcSicjsvg7rYUKnIS2eEEH1WcEV2q4ZKD60jK6J/AtRGQ7mcqgM ygzCDc1L5jz05UKfEkeFoDI0XW8aJBWRGypbHJXBy4XEUfny+lcPCjnNech/cyrDLSbtgmfw AKbj+JsxUOdboCNM4rJ6eUliqObyle0yZ+4uN0rUBrqO6ejfQ0DioS9nAzlhu/DCdqFwu8DE Q6wv2XZhzN4kCtuFx9sF3LSvi+nYEUVuT5ngZ6mE6ai0ehndLDM3fdEougHD6C3SyYsrniTg +TSFfAEjyU2hbpZElyFGthnl37YFCCycSDJNeQVwAinWWFiQcLWhRhv3mx7bsjRye8zQjvT2 P0fJTFN8otjYGDJFK9B63m/bur3yqKokGTKbuXW2UmsTsAwvs6MmF3u1N75XCAIGmO/tMUNw MHPLl58fgc/m2NjxAthYsMJXiGSlghJEamSFP8H4jm90Z1VKZzNO9MSnF5otC+Ct/r3bxvcd LoV5vJOb82x8jxIu8cacFb7YzaLsULKVfNZMkNz4XpXX2Y581lT29aRg0Ho8ZovxfWqsnm02 ezEdt3SevIb/mqwkhQm1mhN2PInNn9quhruCvP6jvvz5+pfLv/kRm2np4GAV25LFKpxNW7Ze GqxJ5QzLp9X2ulbbVih/q397/9vezIP9IrIXcXe1LxolD9v6jlc4vHZPtio/uJn006YlPnMF V41jfeXt+vY7oL68IiYye0as49BenFn0GtCle5hFJa0vZySbP945Xpd/UynCflYydiUbCqfk txU0kpG6aroKTTbsVKW5qYCRzJdrc8qt/9c3klVPZlEAAr6LWfRAquF0rc43zPh7ROqTNWbR e1Kf3JdZtARcqnlr15FMNswtzGQHmEXHWYi+6RH1SeQtxm/PESpmND1469dnFl15bzv09ns+ y97wrjJMLJat6Qcbm3CLipdWwCzqU4LFgIB9zdDD5UEsvg41Le5lFk0GsYmTIOOJd8wXUDIg e1myoiDzEEV/zJlFw+uwdWav4sh7V1kyAzIHugN2EomCc/3KNjf/ll4OsN+FtaJ70Q5GJyyZ 2Vvo2hDF8z2OjFX3CpwgG8yiI9NJ/ERDFcsNeFMnNqlP4oV3lPqErIxZUPocIA7e2Ex9kuyv aMw6IzQc1a3tNCkVjLEjkh1fVqV19rjMomeHIt2dmPQkKpNbAge5Xe3656LYfn7xwrXCX60v HGDzacNl/M70i9hO4Y9v5q/wtsZZLq9lBUD4T6+B2r2H/7QTG1YAciDPfv44YJcaGsozK0C1 YQUAlxqP9D3m8u/Osx+PV8wK0I7EJk8rQPw3rjDQ4ez917QCVFe1AlTZzoBWACmMcAeS6r+/ vb45Q7M9HuZDVyU28V3Wsz1BM2ki/aiG2JZKMWbsyMaJyxNrgH+HTGLM8r8h1gB7w21PMJ9V emvj5GoU3Dhe+x1EXanEGhCruuPGKShrizUgVtfOtwYUE+lRtG6fHK+X/1xLpKcnWgP8LMHE wWVhgZkGQxxvCtkYXHtm9bDkl/OKUDuifZrxUyu+J4t7+gu4ns9P+G5hd9+0Mdrryf2d68aV Lurm1dQ6dn0RRsaNJaIWL6N1U0OsYt9YDyXbUZDhO/sGqVIdlcsEMD3Y5WayAnvrAGcUfuNw 0UFn3WwXyexEcKViUXnlRN1qLLft0OhR0HpcEU1nzyZgHqIB5rWfeoFHH80LKrAA8sa46eyS FLTMgLvvQnfkAwbqun0+1f3+8c3d5759+Fa8R9g5dusVtFJ7FowB6B+TSm1vhZOHjZJVF7k/ KIKr1t8EvrmbIO190k9RIT9Ji/db0znj3ejYS6d/Uc72iasn9+ZXe9Kz4xwipn1AH4WX66CP YqxzGR9FT3tUK2k7XRF141DeaZbO81EUxvAltTY64zOcHrz1S/ko8ipoNxN6dsC+QMbZF0AJ KvgojtGzUyO0GBRKzy7qJhYEDOIBevaZ63BtzM7yUVSRqIvsZcmKgoAhIpiPosK66f4iO+S9 dSz7yT4KN4jq+j6K/P3IjcFZ4nm7KYhs0s1aiqW2swlDp+vsdVJsTUDso8CXRhStlLxuoCDI eKq76aOIF94xH8XW/pLGSDEQdAds0bOHDVddjp4dkaw+R/s920fxpGf/dVwTnyRO8XN6Nc50 UCC0ouQetKIueLAie3BLDzgoalXlNxqheGcvg8DO6ngMIkiqlFbU1RG8z280mg5NR3vAsJ4d eR8Zrag/W18yB4Uv77snrejjMazfmVaUDkp3zuLhcz3cd+3b61efp8GEM3qI+RZzMe/EbljD fBUgdgB+jh0AqwO4RNkl3XoVsmt8BiWPd03yfpczesauQcb4arQIbS+cg6JJds0t7AB+lnI7 gL1SKC9WdHMMt85IfwxEpOBeWlR1eSfhNGwWLI0dzy0GqxS9IId1UmwsdFMm97MCy+l2N82U 0Ji/vyDZ/N61XoGNXbg5zr2aOtGRxbqxYwLGxihre83sf774/iBjFj+R/HJzx6Hc4r2ziXLW 4hMQtFP7TyR1POQWk63c4n1jNkpGKyjIVFCkyC3Ym3JgTzfkUcEI7Dn+a35/aQdIpFeFGfFj Vgb29C/fWPA1WWPTTR6FJLJwehcC3LGgxKZLxPbkgdbLiJcImy4u+3QhTNh0k9mEQ3QGm260 rPg0ItDMM/V3evKQHWC36gOtAWeyRXY+J7CUGKzEWmJw2OpbGbqsIdfK0L0Piam9QWOZunw9 nFDIQcJM3aqTt8NXfHKR/nZcpJ3mko1D6OfQJ+SPyILel7yyO87PF7aKkqLBwPXducztVvkI C1/Qtem4i6mw0zXlQVhb5a9vH8u0ML6GM3ji+3om2smiFVdTPuW/aEatJZXDaNF8e/9p193P 93d7crrV45br09h4d2MjQsB6DdaxHQSsgpstkqQDOdFCVW2nOAAOFKptdW98eW5sVMsG2Akc aN8hBQIc6MrnZZobG1vRQ9axUE6e0dBPAtYHjobWN4iG1ivR0BpGQ3uCzygaOi53umxx47Ch FA09QwguN0arfZMG2TjaW+9qWfXTxom+R/eMhvY0KoZAe6NmlTT5xrmFvXFYi4bWeTS0TqKh xyGON0UxGrpzxpvF6d9XQ5zU6MkzEtS/TlWmRV3rZvyVo6FnDuB8ZWeN8UrNax4swvg2kERD T62DMYOdSEQ9HA09SAkk21WwYiDJhzcq4A3pD3BlHJKMGtlX1HSwseJ7syciUYW71imcBwzW JXLgekNUNOg7DBFmit4sOGPMWrAA8sYWhtzSex89GtqfBetqOSdravnVQ5vPYjjNlfcrMZxC f+hvznAqRT1gDKe+/Mlw+t8diVmtkc6s4C3xO1QRPDHrVIbTcZ4+OcOp78WlGE5dYyjDabxY BpoTKkV/EVlBtRQM7rtc1+R0yTCG0/SJHEAjPFprLaVMJSP9PN7UMY02SiwOtakqItknZTiN fp+Q4TRqjErdilqavFeH1CRRV1I1ctCmlV1d8xc7YbI3qu46Sq3yuKSz8aHqQmM0aSvKKWCy 6lSnaDV0UnZt9SJ7QezFi2lDeslVgtxCGWVrLsZq4PHT5sXlDigx/tPqFC/EtE1c+UUt7dRp N9Oa1fBSJ52IfNuhJjEvSQVdysPgy/BONdnUzVCzJckEMN+LtLGppkuPeFlqytCrqWY99v/F ebF9ie5BN0NNPY3IImTozsv4Kj0N1YuvYJbRWFWw7syk+8w0KxLnPlqm2STXkUyzpc6vhoYX zdKOTDO7XUGQ0qFMs3ug4eVV0G6GTLNCYyMV5cUzzab3O1OI/RJJMGZ70fB2ZJpNE33BTDO5 QH+diIa31FU6WVbzEEXVsLUii/lcciM9UkwK+ZFMs6muSc2UGoUoKN1ZJMLgm2wnopIZcboO bkC1gg0xGp5I2Z7ZQPtIC5h+NA8+HENCmlatJuMdR8NLhojWsVkYZprZzd4XGCjui4bHazK0 hcZWMs3mPXLBTLMNybYb2yw4ZC58Zpr9Qplm/phxcRXO+vrDqtVf9I8/voW4no9XHzlHvAG4 JKo7jKb6f775pUBd8Igo1fAnjosC+dv2ydFp/jVZfF1V4pmTi5Vvhtn3DFa5DMvlNaD78nsZ QYJVKucWOOJ0PwW6z5/FhBR87seh+5iG0H3CG5X65AaWvH9ocei+oX5mxj0edN+9WS6lUJ4B PJxM4ZR/9x6w5Jg/PU5lVsdIZayqBfPibHnT8F1xKlEd5m8dyZ7RvWwGzmTbAquFf0ddilOx f+tAXpx/hxZzgFfyvFTlOJUqBLHti1MRRqFxKmNLtZ1XiOHv+zLtmVxVL1gtLhanwlSjKmzP MNko+7k42Tl0KmqfnyXcaiFl05ps1SSuoRgJbsw7MKzMtBgZ1RMtP1H7pyemRbqhmNOhF0lB spASNZshOOHLXlgWldL7Yk3w26RzhieNYXgtMXwha+RKhktpvMcCQlOXmC2wN5wVR9/yXrvj Z9hEh1Hn/GFtdxjSJrx3L/Lelg3qEPLeRjeXIRpIVhdB3rvkBTC3jsGV4JD3GFEXiDXZ9f0B 1dzOLoeZ1GYtzCRs8pDr8PahnR7cidUL2K0R8+5M6+Oyr1q+mX1V8ST7CtcRyK5Y1slHMZ5U G7nzIl1wiY6Q/W3OnQ+9m5NUZ8SJ5R2JuWjREeLEVoznh/e7gsDBd2K3Xg3psKe/zJneGM+P o3Y9oFebKe3yihh69uTyHpcbejaiWYKxrCFzmG5lDufAePEYpl9iauKkVwMyh3sj2jMyh5tB xN6JNHOYTO8vSFYJpFdgh0WHQJY5nDTWdQR2Eyy/6DDMMoezwWSFulNBnFI7VtmbOYxNXgU6 s6EjJJnDuOxo5nAmczZEceYw6GZ4Yk/m8Apv8dTfSdT9OsIO3uIdS2N6dH3MWkNzzOFliNIJ cFy2G6MqGySyyP7sHQ+hLi+LOrnUimOGeNDSf6q83wLJnS+NWbx7HPFSgoQQyHmRxhD0CJ/k WxbVAA739MGhyYZXZmtUsOMoksvkiXyNVtGytrJLihyOQjWNjzRJBGmaRRBf0JcV213K6Wlq UK4GfrokdLsb/x+EZpoO3ifzC/JMVx33XVZfh9c3W/vnq/ny88cf3lSubZMu6twjahcbUMJf YpYG3r75+8zsYPC3Eu2zt4uM1fa66el2e+/MCJb+f9SfvgfCZaXz4lA809lB3ftmpz+9i/d1 19GaSOZ8Zh/6+8e3/32or/PC6dYTWH5XXx1Cs3UNFMs9NFvX8NXNfofp35qx2sV6v+B+h/mO vCuxfExGf8l9dao2fU8Tv8P0t44L2UgJybZ9uXgmlqMolndNLOdXtcrxbGdAX53L7qu2PkxV lXyYLuC4m+4UqVHOX65H5ym2gaojG4hcENDS3S1Mr0sbaFe4scl+52ygvC+FDUQPbqCTwo0x Z/d9EsynWUIcd9OApM4vzhErQmE+XhBz6/TI/sBc9K6uebsg8PnAQe9rA5sif92OG7Efkl2B uajjzmt/sDEgWS77tmSLSzGbIhiYW2oMxOHCwFyehQrkZpxYWy0E5o6WgDa1AQbZ95q+yoG5 U+uJChbf31zo3Hpg7hA3NgXmrrgUo8Z2Buaiknm1ez0w16SBuUF/xiWTQ6/TZbUZmJt2E3xZ cv15e39ByTpZM971SSc2KCCmPYKNWYjQ3TSTHpJsu7G8YJ9Z2mv+ZzVWLCjJnhPO7WpsS7J9 HuNTtCBwD3WfE3fl/f7zq/rx5+uHevuhI8euejwIuWcM8NOo8OmMChwaFegVjAr51YkgRgU1 mMsZFcZjERgVptPxIkYF1fAuIDrkaHW1XU54APB0XOdGBV/elVIwf2+jwn3R6u7N3c245O5z 6t08U/KO/3xupCzvC+wJvym8J7MhBP7gqqqm/ZKXr+wXOu2XRZtc7te7U5bde7hCbQgtP4Wy OwQc7dkvJnW8JqQYia0g2y9uyRb2C4/3C9CyLwRSp6e2kuBfDxhzBxuCm6VSyrLS802CskY3 tVmlQhifKGq2IwDXISoE7NITPxoXgElO+pkE9iTPUVaKxRm92K2WdXRPUT4/dN+1P6SSgifS f+KkhVbpaVS9SIYGNNkhjwpCQBMYM9pwqTwMDJAs6mZlmuwa2tU1nICs7lrsU2LdcAMLx8wg sU8kpxPwEQAl++jLC5hn8OjmDQpZGqYQ4FKBXm1Y0ZZgggZYRkqJ99FArEzA1EguWZkKAXRz 5kTYHLMqlWwt5gs0tm4Rwro5h0SkZi07vS2yVtK2qdw/mzBcKW1dtFv5B8tP5HQ4aejP+pit hyt5hgLwRULHbGe4EhD1kA1hh9KTV/GfkxXGAaHW+SzcIbwVStTUq5FE/kBdbpFzgE3r78dD sZo7B5dqYzgPWQ2fOCNoyZ0TIOioYlvMF4QjsUM9f3Dii1Yof7F+e/9bfXkLlgSrjH98/Pzu 7VDudl0M+DlMudDSpmnBGvzCnKTaBZawMr2DAxeZM+59ZZdy7wJpQiRNXVw/JwcXnRQq9Imj b1rPgZLb9WgzPIph73aWsk9r8Dop0+dMK1kFrWTNFaxkuS2AYASy5IJWsqnKC24lO5QmL1Rt Rzq0lYXeVE0X4NxTK1lrJ3PBSk3T5GvCDYVWMleui5EDv7eVjLJ7Wsnqq1rJcmrlO6bJO1p6 hafJU1Kmj0XT5APFPZomryirhpfcUubf0ZTpHJoeWMr8O/A0eatl9eU9Yx8o7Bk27Znowqj7 cpp8LwWR057J+zLtmUgVv0mavIu2YQRaytq26hTt96TJX5bOwc/SZpr8/PnNAkU8SOgyH4ND w8Nc3aoaTEweYMZfOR5nWqRb19S6rdOCeCHlH3BoW5n3Qt4JXFRkqaRjlqfJDxJPk88Ldt/G Yyd8Pqqd4pXor4P5FTVmTyKp+86A966J6p7AyDkmbobVujglQ6GbMex3GKI9lAyXHLMarLN8 JThKBkPpp0yT/wRsDA/G/MR450M7UiQ8z9654UwTbFtFmB4ez6mhoFY/Fv4vH2lxHg3/d5Lr CP7vUudi+L9jXzK12iGGDKlafQsVwc/SDvzfZRZizcnj/0YFGcRl/N31dcH04K3DRQeP7j34 v1NjUxWsmzG26chFJZfG3CxTaswYKBn/EIP9fvzf9O9tTr0OBMEGcS/+L19YqlbHLMf/tdM7 dGUdDZmAzYL9H2IE/3dZGmsgr451NXdylOnT52He5RqN64IA7LL2uPbeI2MWz5Ujey1GRIPX zQV5N93FsFM1jaLI3VrR9uaVRjVTOeyLOw5hxvggRhF1yxO0lz1HQCeCzJthxnE3D+H/bu4v T/fZidxpuyvMeN5wG4fjWlj3hmQ9x4IDSqto9zrb60zb1nryOg8AAHyetf+TMDof9xHclgP6 GVJ71FnQ3oYAOr/sEMxZ4Jj+Vq818iAB9EjOnBBASy31SAydEECrRmpBJk6C5FYzkjZnhs+x TjtgIbX+3ZizYDpfXzJnQSinT2fBA4TUnkXKmCe+k//8Xd8g8f1JyvgkZTxgLUBJGcNf2obV Z+DuPkkZn6SMT1LGJynjZsHS2JOU0f2epIyzfKsK1r1JGY/QmZ8ewEHSX6pvjaAGDWt2BXBk fyvpW9A749/RlQI4/N8SfStYmKTRS6rT+DxtmG4rwpF7jLGXJUHbtohhLCZ9azFa2SlAAzh0 r2pZ9WoM1OAwUGPSt/Jy4J25bABHWd/CUp28DqWX/7wsz0E0SxDDeFlYYKbBEMebQjYm+6TO JqNhUZB4ZeVdYPbH6Ola8UW5K3/sp7+Ugz+KXITZUdfw+axJH22tXhLL7hzO6dKG+A7jgkzi NRJRC5bY4JnGG9uTJrWatrPoNDEnhaM10APp7KcwLTCDAGfUNSzAiWR7ORKAcpdJdogjYaWb 6RANUP050s3NR/HbTLwADjR2yMB+5AMG6rp9Xo4AGchqBIg/C2ztEHAyRnC8qv6vt28uE8Te s1azI/xBERIcvI01xHL0Hkv1YbgW7s3A1Eg+uKye7z9DXoYPzEmM+qcrJTlRQqKUuDTVWmp3 95mUkuz5JBIbayshVghtpcQK0TuAUpK9H5AvcXU3YgX/44onSskk1ynEChw1rp6Uf20IFjJC VL/Eo90u/9rPEq6UsBTGH2RIT1MffXHtjCiYF+uyghXCYJucwMoY7ImCZIClgSd1uWrJqSwN Xtp1lgZWZGlgGUvD2KvCIC6ZyoXGAEsDJ6QwRVHaX/Ezxlam1xUcYGngOyavAp1Z+cBGnbgo SwPLWRpYztLAVlgaomV1AZYGvY2AuJOlgV2SpYEdZ2lgKUtDURBkb+ZPAHzF6TUu7EIMa8HK Ywt5mnkFdfzimG2lPbcmZxMv4N7tSXvmu4gVwvDKbI3eiqVhn0a7rfNkNcKnYSt/mrbVk4pB nE7F4NcrzKeujfk186lvUEE2Pil4Srr2d67VC1vddR58bxy7uPeMrGUvn5ymrUTN84rfP/R3 5VkrqrVtcXg8TkoJP3lIziCB6Pp2zn34l/kQo68/PuadRNYuo584hf3RoSmfGewPmcFOYVDa NWJocmMKQYLSOlGvx9AQcqEMdhrKM2dOdQLRezNmVydBaZmWlmWwV8ZR6ryADHZXLp9BaY9H 9H5v8ogH8oLqfWzv2OLZ7QXVouwFHdPVAWmEPgXwsS2ksXP9EntBYapE7gVVRlPzAg2OtCXN 3bygjVEM84I29iWsMl26ca7qBY1mqeQFdQsLzDQY4nhTpF5QsLL8o8ELKo56QU32S9da7PQs os3nktUFL6hbhLkGAF6HOy6HpbFxiOwowuUXa3tlL+gAJdtR0MAxw7ygtM68oLTe7wV1pv4T XHyfzAtqh+jWXlAOFkDemGOKp0xfIAX+Xl7QT+HGvD+OtD1dQRZYIjuuVtB2v1oxbpNS6jvP 1Yp7p7572Mxy6vuM13zr1Hcv18HU97HORVLfHxBH+oKp79SexRzFBoF4ymjqOystOnhC7059 Zz2S+o7XnVwUVC1OOsdFYJggQK0pOEX3pb6PrfsEXDEgXhz7F/s9jCSDg3gg9d1P9NHU92AV w5YGSM1NgaUX2cuSFQUZ/93AtZK/DlfFeuS9ibMKRrc5Kx66AyDDFs0gxkNjycuW9JpT1Iq9 Y8YpN7DfhbXiFdzOMXWubKeVIYrnOzJHomOGpr5H3tkx030uUA2Tpi3ilW+kvgNE8wOp71v7 S1ktu++GQmNz6nuyv6Ixs5MywFHd2k7IRWaPZJdbZ3tT3zeVnrzKuZnv/tviEqbV8Pbv618f Wr/+T73/z2mLf/78PoFIFx0wd0+cf/oYsm389DF8OpRc027k6ZLDKLkDze80/nTr65kbJ32e T/FL2Z2Gu08FuNMIVTFWdTDx3TNj1bO/IvYxTKfrS+ZjCOXd08fwRMmFNgBhVE6roLZNAPKA CWD8zdtl0j08wCcXgEpqKl8xAVyESsq/hxkcIJf1J3gWilRSFG4XGMqM9QVsF67awna5OpWU VTx7NL+KaGkGlm6Xq5sApllao5JqJsntqWlYA9hpdgPWucDy5MUVS+z3PmgoX8B4hKP9i4l1 90G4m2O+MLI4wjU6aroWbEw15RVgx0HtCWFBwtUGltJUMD1UmIBuHCL3S8fbxZJnExBisE3K 5WVi2q9DXF5pAsP2bJoVGFo4AdEFyI7alM+2M+w9zPcOg46XDIS9p2aTEPZ+5Vv7LEg6ZgJZ xeXtFI1ZYOpKGgNh7yR/wk4Rvs4wpi4GpzcpwEiu5vj3oiDYZvU/JDMA9Goe7/hihYa9o930 0ajlnR+mKAp7L3czPAqMb0tBOewdLI05/j3XpXeEve84z0qDWByzvSaALZ0HWgDOYZI6IaTU n9quhg9//Ed9+fP1L9V90T+S2OnBwda1xeBafwSvSN1XG/xX9mjbjN8OgaC/ffy2rDiBvFaG kpvxWh0N7GXE9syJ/OOPb/+8zsBb7k2VE5pfPrj35Hjn4xahk6KWOxegt1T6+Kt/9dVcp6oy rmRjjLOs9H/o/s/JmDRBIgamrrI96PRw52fI8vXMiceX20nWROYiddyL9Ls73INB75+39+Hb P66uH0felV7Zt4Ncs0RyuWqJNI0/LqAhkRF1TTTMGhoFyRWMgrnpg2AE81V/OeosYwZj+gGg YfpyQkrxk7M1IaHOcohXVQ+Mgr4t2YPAY/88wQnm3d9oxeb4ybScPI2Cjxd43FzVKNhkOwMn xVAQHnqHWVAcCDg24y/fMNMs5Bvm3pFB9jaiHzEyyMt1nBRDX5IUA9swmlXSkFtHBk2ztBYZ lI4CFhmUDSEaiTuI3NRzi8igvAraTa5bVSb6JkmoUPyDkoVQHcyOMf4viAyiNRdMNUiUi6cl i9ER4CAWX4faMfSRyKDodQULS8YFAVH8eST73Jn9xrfVyKCcn630XsiCNrceyb7CgubU6HKo kBvVHgsVKnSTSYRpfbNg55gxpQbY7/Jshlo+ZmjgSgMDFgO9AvONjhkaGQRajwpWSTH4JilG PN+HIoM295cjXXOXXLyxTVIMvQDQzqFCx2LRD0i23dhmwUGz4LbWk9d5AFIMf9aHq+d3B/Vl Zf8I1idB166sv/ol/ncL8DnzWt7Aazm9wrU8v3wQLFbHGUTXrhlHYnUcvaU/G7Jbhj9vHEMn ei0v5wPTNjjgs3zgivQ1uJZP9JjYtXw67/JreSjvque1/OGu5ffmqnyYfGBK9D5aa2zx7MwH tu+QZVprLUE+sOfsOiUfWIXAuLWNU9AS83zgQfVdm1zPY1XzPvnA/npOCdw4reZtx3qZbJxb XM/9LOH5wGFhgZkGQxxviiIqMqTE9jLHGqgfl2lA7Mmr3RcBuQTHqnCiG09PFBka08Zoo6b7 MoGLMNFF43zgqXX8PpF0ItXaS3kjpXzgQe4jNTzlQjcNb/x1rAlGTX2RKwA1XduaXsPGiu/N nohEnZiwd3WzQIkNjmJMMjdEeyixLzlmLVgAeWOOElub+hPnAz8+L/ZZhFh5oD35z9/sBoH2 T0KsJyHWAVUEJWhozdAMvNW1YdN8PQmxlmlfGnsSYj0JsZ6EWP6NT0KsJyFW3s1fmxDLGXdb zLhLYuPu+TEZoYY3E8VGnyXyPU3VsrdqUTfL4O0y+ghVcbv3EErf2h50NDH6TH/ruJBNz3Eq LPPLU/peLFVLs6prSWYtva7RJ5qlkp5FLmRzmFfJPHTjkrrO/Tm8jgHP8J7G5k2wKSpsLMQu Dlvfv1h7DaLS/soTUK4LDpL9jR0yMew7KF9KXjBym+DU/MAnWHDqYC4XnDov1cwLNq+6A8Gp 85xe4VxPy2n/i5/rJ2as35aq/cHItx7GC2aa5gaouM0KKm6DouIyhBs0PC9n/RtuHNm2hY0z 564vZ7iy9xqcG7Rj/dByLqeNA9wQd/KC2VdwSRD3MaspkzP/6nHT06mouGwNFbfJUXGbCBV3 HuLcOn74ezxmoHlU3Glyxzk/yQvmu7XDC2b0zEwHF2EkGUDFZSVUXLcgL+YFU7oDks1j5qGF WSNhBi1u3olQcccCQlNjnS14DFTcvqqs3rHZ2DVRcZchGkhW98qouBQsAOgF6wgj6hN7wT4F Ki67qn4xfZgf29QyxmtkppYQwHBIJSe1w05E88UU7VCVXNmV3suAypNpFvRpakFMLQ8VXzPN 0rVNLfMquURjF5UMPDpvgrSg229q0VvdjE0tYWRWuBKva2ph8CAJf/Cg7tzewx/E1MKgqYVf wdSSH/gEM7Xo6nKmlnli8LTGQ3nAcZ1Ln+tpefOrn+unmVrIXU0tTwKi+QL8CQiI4k+wPR2R jWPv7hVtW0pLAcccM7XooqllIO3QDA9makGjfMYfZDx/bAKieYjzK1jW2JSjNOcSeysBqY4S EOV/WTW1kD2mFl0iIOJk3dRSJCBSOsXyj0U9bGo5lYAoS3sezQY5AVFvhpSAyBbsN7XsEuRE U8vDEBC5IXoSEF3e1OLPAlvb40BNZpNX1f/19s1Bn1FKVsG8PoWl5oldLAvYxfI22MWcYCAl pmXD8SyoMnbxrJQsRR4qdsEb3oddTIeBVAVt/urYxY9FXzTN0i2wi901Jl0eFd/ELpa5hjPX TWI5ADnSDbCLOdZYWJBwtYGlNBVMjxUm4BB2sT3sjdUcL4VdzDqlqtIHFs5mnceVc7Y2AZGa lmAX03qoWVI3FxWhLyo9OkpGV7CL/fyIG2EX0xy7WCKruLydojEL2MXZaxnsZj5F+Drz2MXJ o84Qsz69KNzw+JdV7GLIZJY1VuzVPN6R7AG7OJcd7eYNsYsnBzY4LcvYxeCAgeOdvr/ryjsA NFYaRNjNJ3bxE7v4TOzivu2jl3oYG9dNvo54IuQgIXRx1ckndHE0uLeDLj46GqdhHZ88EofF c/qS2wwupfX17ZuH1fFARe/GyandVuArQEOfFOb4ZohFNZEet+pDf//49r8P9XUGn+7WLRy/ K9QRgkB8DVqyXQjEDsL5Up5HT/PVBk8eoCUT+jKeR9V0vb2kvIAgb26obHHPo5erhZ5HX14/ PY+Y55HflZbs3gjED+N5pETdAOpIrUAdKRTqSJ8EdUT1RaCOnFtMWO345bE8j8Ug77a1p5Ym aSjW1T2P0yyVoI5UDnWkpIBDHG8KxPMYHI0ug7tsuFmgcvOCUzyPRdzdrLElmJzARZjcaDOo I12COlI6ochORD0B6gjl+d52Xu3yPA6kTT2PgwO6WPM8xrO5uI0dxGpn+lphdrnyBCySPa7n 0Q3RrT2PDVgA0PPoLhz8M3seb+wFvDcqorOItblFrL2ZF3AoeAGHG3kBh4IXcHhQL6D7psuC Zn19BtNWBhBAmBavotPglliIO72Ak6RHvIChsYkNU5N0ecRewGlC8wWMewEH7wUEcwokm/7D OF8E3+U3wr2ADQVkBju9gHnrkRcw/m1LNvOTvmSuvXUG0+R3PQbTAXMTrU1ApDKdwmDqCvZ5 AQfoBeRJ62UGU7umaIPM5vKfYch3KAizIOkqlrBXl/MCcjAQe72AQ+4FRKd3txeQI5O30lix V/MERLIDL+Cw0wvo6S/gELVwIApHEPACRsvq+l7A4ZJewOEkL+C6zpPXONML6M/gLZ9epeia T+/plPulnXK0Gewt2Lsv/vmYZB7mDrd07f5x/GWH3dKfwfV3Q9bSVjRDuCb++GqXhz1yXs3P dx+fmoyNYpf1VZ5OeNr17Yzh+y/zLquvPz7mBUbW1ten9SI+Ps8Ks+qQG9of/R96+BlMFK3w jsMLOzo/rb/yJJPMmU7OFjo5qys4OXP7DEGcnFaPvxyfy6xRYemVNJRnvppqjc/FK2OZr8bh vwvKgJNz+mFOTofdbnA+F1sun07OB+BzOQtjPc9XJv/5u71BvvJvj7EuZItirPvyJ8b6f3dh rPNW1aKKkFpvh7E+ztMnx1j3vbgUxrpr7DEx1r1kqxjr/oknxvqvirHesMYBhZqWtfYuysxL YxrRVq1sCTO84s1Lwxvd2L/wlmnOGv3SUPs4b1pbLJuqiWaz4b6eK5f2vwu23NZI7rJAG9vK C/MI3o3PbXP//7SbS3lctx9qZBAv6zl+NnbBxnAF694Y64wrUc9G1Z/vo1mV1fHtHle36h3B ZsubXMCTmvFhonJpuJp9ySIdutk3OuR1RkyuoGi1Jv697PUlz++nqS95Kmf6FF9y6QLzy/iS MdyvWjP70RTDDX3J0SyVfMl9hBc6zw6YrsI6ecl8yS0j6fKoqpIveVnYuCfN1s2/dtu+5LWM 0k/gS6asUZyWfcmbSaBweCtTlfq9P6N0agw4G6k+PaMUq5u4I90e2v2REUhjs5SDj9s60Zcc JmXH588ZAru6BruHgl6d6Ev2HSuM2TRFJSdr8CVnklVweqcparhUA2lyyTBmybmx4gRMT6Cz mfZqnoBIdtWrJvKhe5gZsM5mmQkckaLsU/AilKzsKYbfrF3dDEOUSNZ1CAJKVsC2Tg3Qzdm9 OMGpzNM7+1/3+pJ3qD15Jf9BWXEn24X46/uT3XoF/uCKbfmDCUf8wT3/1dzBN0wwPMPxXHWc uoFVX4fXNyvpz1fz5eePP7x/R9uRcn5Bj7pzMWkZ59xJ23//+VX9+PP1Q7390JFXyC/6FSfk r+iMPsMrzJnm7vj6UMPbv6920rQ9B+xG/vLt258/3fQ17iArzsYlHMPnenhbH8mQe3jtsn66 eJ8u3hUXL0JWdA0E3dxyQhAXr3BoZasmkgMuXqFqOzp6N4KuUK1Di1uJtq/maPtF6rpqusoT DKV5rK6txU2Tu3g7E0iJchdvp/XTxYuSFel75rE+yYpmXNNfgqxI931bqUHKprBx2LRxlrtg GUG3p6RjvKPTxonuFndF0G3k0I9sm6eaFi+Yx3oWWdE8xPGm2I+gS3AE3US0E/NYd5IVMV71 85pPl1qbSPYkKwLmi2uSFT1AHusyRE+yIrTuE0F3Q4N/AvzPH41fAuB//NkLdkE9yQH+gxup WRg7UvWE2h3ePxyXYolcum16n112Q8/nuQD/8xDnxxaqnnQ1i/I9J+7zxO2QcBs7OhaaWL2m vyTf/PgXqyf7AP6HApeiW4T50ZYu7YJ6knUiEfWwenIqwP+er+M0vJGogzF9e6UgFqv4uJAz hEO7+N7siUhU4Qy5Co8Jy+p2ihM5cL0hKqqFhSHiN6bp+h0A/v1ZsG5q5GTN1HhrXaO6qq4x Gd/WdA1VuwELlt2g1b37DhA/TWerGfHnmRKWBlhNn222D80rPifbJMDK/fx3o2KN6BA1w76j KaN5sSVDJHnHqH4ANaPuECvIJHFTF9QMhLJZGIVaQfxvIJw1iZoR9eXRrCDOrkhyyuab8Ai5 WcIDrOxZ0podB2V+QTmiGYA1uQwus/O7eWKzqi7AiLiFlJ9MqDZFYhQxv6giRC5v7GmpMl22 FUF4SXSWlRpbGcRiN2vckjHBTZkckct+lEtgHXlWwj5LxsoELJJFlowgiF2FptlDRjn+6AmW jJVupkO0B5HrItrU+IMoFvlKCKqCuICqsOv7g2gJrSlrCbVZ1RI+hRXi3jw+jeSDc+F//7nk 8junPd2Iut6jFGRR1HPaaHi9i42sjOwXpSB7PkkbxdqaEbyWtkSiFETvAEpBzCWC8fhwvsun CL4UqFJQIT7FYtS1Q9bpRijNxKdopqC/HT7F+SuwRHBfJOqaETRtVEUXjVvy+NhZQpLbDMoE UlECpz7aCprWFXLBHH8cTF1Bw4jik6HJel4mpbqUtb1mBolPzr/jS2xx3lib9RuJT97Z2A7G G6KQb5JBAmeR+GSiCKiCW0X8sgNjlv4TiU+GktFOayaSFLIsPtkHv9I2/vSGScGWRtir0a7a E5/sOoOoeDBkfm98Mmws5bPZjk+Ophc0Ngb9VmRzRmB8cnE7VeVeTT8Qn4ysszFQuRCfDAYC nYBpjnLJDsQn7+tmKEgkw+KTi43t4LMB8cmFpVG3SN3i6zZnk8IZ2ZS91Fifj7fWm2NWRR+N bW10W+fJa/hPw1bINB/6Z8j0Zw2Z/rVpbbxlI4zGv/r99W/bs9GTy90dqiqHFN8wDrkxxq3P /g/d/zkFrk5sKoNbprQYe3pLKKwnnNXnj3VmtCWNk02/u2M8hBv/8/Y+fPvH1fUDybvSK59x 0mfx/bA78f1IozfipOvDUFggTlq7nK7WzJnkiwR1reiAxkl3rf0iyjpzdEx1FML3U1HdaZTv J7TVAL6fUF4946SxOGminnw/DxCI9Ivx/dQlOP9DfD89pazp+/7l5bECkZhqQygtjJMm3ZIi /Rn4fuYhjjfF7jhpKtbjpG/B98MXhxRchLkGsCLZ+BfvBpJxY4mohwORTuX7wWN+gXeR1pl3 kdb746R3CfJ546SXIXry/RRcjM846VUN/v4cQ52/tgbb0wS47yHcN1iGxAG1ZNxmOtfnxx/P 1ZIJ6+mgWuLNo0AtWWEZihGYAMtQL0tqyexXvKI+P/clDlzycg3skI9yrFNdQi3pe3tQEMRH ybqYOeWWLEN2lkrIUJI02SikmCNa9tAxguc1Gd9rMD1ZXVZadPCEh3g8qUOmr8H3g6Ld5LpV pcas7N5Z6m65uRa04u4BjY3/247/u4Ds1Fww1SD+NhdJz1UsCBjE4utQp8qAKmrxQHjzHXgd OmbeVheJWg2i0UljVJolLm3uTHE261nUsaCBayVeeNF1JJWs0zVd+I88hKYZkEHcLVmpLhgI eLnBdgCY3tJaKc3mOFdMZEGFnDa0+DpkNkOtkOagzJA4sQaXFZuozpImfKPrEzD0eSeAjzIq oL3sOe5YtzJXInEaeuNmsZuFyIbYsnlgf3kO6r7GmZm8lRPejMCGi8ZsTyDm+sIrS7bd2GbB IZ12j9aT1/Hfk+A8cy4N8/76l9V5rDrqlFpvsHeaJVtxENgzfcOzobpVx4Y/64M5/rtTha3s H8H5J1ahde7i2fBHqPNseH/Da+R1aLRzbbRlE7w7BEM37cv++vaxeKqY84wWNf4TJfWn0Tg8 cTVlVt3W/lQZXTdv7z/168fP93er1juHmlsJl3WqfF7HyOXpPpo70X2oQV4OC6azt1NRB59B eifiralCogM01fIJImGVeXWWWlVKmh6n+6hwLJjpdH7JfByhvKoKd6Lf28dBm89D90Eh3cc1 +HMghMzvTffR6s5+hSHdRyh/0n38dwfdx9hHPrQ6dYHgtgbcBXIi3cc0T5+b7iP04kJ0H74x lO5jemL6A+xmMkRLY7wU3XuKZBjdR1JBKxj2GvwDtNbx8AopliRo+4SpjO6TgFykm+Hhz0n3 EVZibRVq+QnpPvAP371pGJwi3GKKMIkV4fOt7fNwpUEAy0U8+gIiRqSdmmVLZKfnjKDk6Z2a ZWRcmLkefmHN8jNb26NZKn3/yJme3qlkXiXLQ9xQjVnMtxvbFmS+hqV/n+9ZsLFFkHkTJH+3 q3+HZNOFckPUWKuYbmBXnoBy3aJFb7uxQ+a5fQdl0WKAoMdew2KQH/jkjhaDsEEuYjE4/1xP y58Wg0ewGGxTfta3o/x0QrssT1URze1NZmOLSH7YBkDtLZRLED/sgnx6VidhkEEQXumqX9GA uAQ2AGpvKw2BO2V8B7ZTrFxGNaaLd4qPdehpxSktxBtULNkpNP2/PTvF9bGr+MA6rso7hXKw U4K8BtspVHeAiSr6DZewAfBh6DuC5UQjQClXtAHk8wR0IKXD/9aTZ5AO4X+bKh5Mzes5va6a MiDjr+YUnOb/N9Ijxlxluv3ERmNuJcyNcTOYdv6/2BWfrmHwPWd5wmGVWzZAwYpywKJ9aA8E XnWlMSP+iVoQTDujFaNDDFUGCpxcjR6y9zeZQjVPNDdZY7oHKk8qu72cl3BXCJFxY3xoOMEL QmOUqGaoi41VyaOadc1c0DVdp0kyEHUz6BoxKEx/jwWhpoZGmEWyrrK3RVZH3RRG4I21g9H2 WNXbT2w0Ft7bDB2cgBqY1NYIh8axG008JF8JyBOFpVEtIzKulRrunt2SjZtlXkW0r9PJqxGM no0d0C6DuLEl9u8AsGi7tt+8BZywnaKfRLuZCRJ3c/V1u44gSjrKQMhH0pjfI6sK1hP/9pfC v6V13TedVmzErIX6VjXpW3NbLpiHd8jNRPe9qSrR6RSY7gHSTgYpGeZz6XVv+tZM+C03BKY7 Hf92GuJ4U6RpJ2Bljd6DHWknEGV2amT6tJbTTnbi37o8/1my9ME65uE7gH970bSTU/Fvb5R2 ssNcuDIBi2TPtJP49zvg336KvJH7Y94+iH6xG/gWLO0jaa1sJa2VwbTWAKla0C9Q4FvdD2RQ pGm7gn6B0v/0JfofU7UdY4+W1roS09FJZSfy9vrFWlory9NamRRwiMv6RfIeAw/TLh5jYphZ DvPpC3GqfrEnrZV0al7z6YOUresXpbRWtyAvqF/sA80Fh8Q+/YK0OWhuu65fTI9WTh2elUNX dzBMtBA269PrF3aIbq1fVGAB4PrFJUBz76RfhJ0e9Iu3D+0CqDuxGp/+u6HmMi6Mmnm7x+QM tZ2RKtvDGgXNNYqA30dnhJm8fI8vdT4qo+zSvRmpAVNU4qi5VXMcKGPSHM5DzU36kvlSl0xV 6EudNbAUNTekOV3EYtHKgRKoUWhWdVFM0y1Rc+0slTJSlU7OYoPijaZzvoB9ZI3twxudCkbs zqZ8OEN40fIT06xv2VJK2Jm9irwwUyIoUAJ24o366R/bmmFGgWQH8EZBv1fGLJEMwxst7YjD Y+awIrPpbRFlM9QF1nEqN6c31ygIRIANrQu48PLGVBFnVYjNMYutW6y2NfCESA+DCQ+V6AmP d7lDPSmMyNBnoypFPhCnhE9NOcKzZFMBXGdOfyNS0mUVCdU0SuRrpWmW1/mCfpVlIVJlCZd5 Y8jVIU89d/qhqBUaA4YWNMs/WzSyjtaqT1FzVcu1gNObjVkpfrskCFv+mewRyqgppJ6rlgqY oxsPRIcSlR5SR7d1nryG/5o41Fz915hEar9GPi/1O/vqsutcbVa0cp0FdasHAHXbD78m1G2l dOV6a778/PGHr6/eh9fupz0yPjws8SrkJufcJez2339+VT/+fP1Qbz90pMKr1bRdew2sqyWD 1hsj/1F/eqmFA7Hlxe43ZODuyhDym7/+eLP/738+SdlDvZZQlE9HzT0Jynaoey5XlrBdpKtr +AlM+2sA0x6u8cSlvVn6NQIxy+8EMTuwYT1SlBwIph4rzAaAqaTjolWiAxCz2Vf9JJdC0ptq jgdKQkTD++lsAMDKn8HUWTD17w0x69BMFEQz2WExOwHDzeQbZvyB7IMHwHDTKxhu9AYbpoTh pk/AcNOXwnBzFjNOUIuZuovFTG9huE0zRvxXOLni4xhu8B7nDUW+12B6wBwXFh12kcbrHsZw 83phURAyzv6SzDz9Vgw2oLHxfxcMt1kkF8bRxoGW43vtSmkGEwsCBvEYhhsOthsPRIThNk3v 0CVBVokF5bwYn61Hobnz9MZgpOsZjcFs8guk9QH37OT0Fl0+m3FQQK7GZ3V7AVovSMYkSyc+ Izizr1NA9txvuYLhlgQC1kQylYo6gG5OC34Dw23cEsupsR/DbXN/2edlK/EJ2IHhpi+I4YZK VpezHc7IRd2P4bal9UCDw90x3O5iA7jVDTtsLFvtQ3//+Pa/D/V1Rm7r1l3qv+v1uoHXa3qF 63V+iSDI9ZqbrUTMA9droSopRiSiLilvW90bkd8WJjYW7LYQzpq2z28L4R0MZGCGcokzuIzn Frhe+3L+zFVGc5Xver2+N0T6A4W66huEuuqVUFf9/2fvz5LlxpW1QfQMJSZwq9AQAHHeysrs mp2XXfX/E1gGEkCmLKUl3SUpc+/ZXwDs0DhIRh8hBXcjCUF0Dgfo8OZzMIOLhlxdfbk34NQ3 DqmF0uBp4yzShzK67urauo+ySa7Z93d1DeAtUAYXMJTmFtdsvebqanKp36SurgOJ401RzeDS +dTDi4zbN4N/TrSWITBxOXlVY4WGYo0TkTaRcWcWqgGD542J6cpYBGXKuqvr1Dp0L8gmkUrf x7q6ainLkV3oMjuRNyqgHPVFDOhZbptLAbZaK9MBqolqv9kb0VBbb45Uu5wsXF0kNTUbQwUj hgYS0QJx78LX7OzfomCAvDGfwcVY9ryursNZsC6WU7Qmll/d9fUsJNWmRFG5hvBeRuP83kiq SDadBJBUh/IXkuq/dkfdNLS9A5LqtE7PjaQ6zOJCSKqhMRBJNWYWjXP/3eiXNitolgLtv8uM odNHBiGppm80mZg0vMqMkVKmI4uU4dgjmnLVLnaSqSowsidFUo2eJ0RSjRrjgiHGKbA3NwuW xlrWSMWlNlbIjjF6cAsme6tY12GMrVz84zHu9OBXiZO2IhMacZynOoUb3UnZieYg+xa5ixcx FvWSqsQI4FqnhcEoAtjhvCFyxmTC+qA1JaiPZxX8audHHZYK2KbTdNSKXuX8wHRGIkXimsgm 0/Rj2RQtx+g908UwNr6milBUFGLK0SRtDLOhZnAkTmtmi8cDvgtuuvAvPcwiH5mvqeORDRMb pjn8o+90NPalwtwYLGDdG7H3ptnxnsOzYkKCfTTPimlcx3hWLHUu5lkxziWRs9x6hZPshiqf aJV2eFYsypGoMuhZYbPGRtNgqFssT7HGFaYrj7g9nhVTwVQFnGZwwM4bAy76NnsAZdTxnhXj QwqaBa2YjChSEnGvZ8W00Ps8K9Lf8bWQhJdZjRHh2VptelbIKq6LrFwNIvVtYq0Pbswwayzu ClNdm+opDRiAXru0yAK7LNtOSKUpBp2wA2tQ3cC0jgbSplniiMZ97sqEfKA32JgT2xRbU0sC jhxOQoSDDgfPioREmCUQCINnRTwuznLkwZnhNz0rEEKneVZs7i+v86Om6+HGVjwr4g0XFZzl WVGOzOL+Gnvzl86Od16wzXkOFjeMlgjnhveU8PrU705Q/my+//l1iGL5eAvxWyiodGtD9afL VP+vT2FtsY9iams1whHiwyb+dnN6f/vuo3UGHa6vilggTXWC/jDxdF3y/xHRBl+Ol+/JfX1P AJz8ayQCy69ZCPA9cSfhJX1PmKMO5Hviy0npe6IaPwwQ22GoM2AoZL4nwap4OOShHazhXTOd 3qnvyXiyT/eppNzYvnKf+s19T8w9fU/wVRUQZYq8h1RA0IdSQAweCmRFAUFvsGHA0I4wriND O8Y6l1FA9LgHDT0BL39Wdt7I52RapTUFRPoVhhQQG9L/KEH7m+WmAoLUmO7SCoiisWQSdIKR IH6VPfAA0XsVEHRF2F8UEBER4YTuRIuWcZRdQxIiVrsrGhsW+tjQjiEueeWSU4ysGHt9ZNWB jP/mJa/k3cHaDAjoAa87/exRQIwAxjSLeRgaSzpbTM/lNAEFxGYB3BjlfVvOu8Irpte666y7 mGztgEspIIrWl7/2sqeR1kwbiqmqKSCaTQVEzHjHhXZs7S/v8IxpX2lsVkAk+yuiWWdbU1IV VA6W5I293PaM7Hi2ej4FRPj8jLe4f5NwEfzy/WPGKUFrDkcXUF788hgPN1MDPO1t/iRftzNV AHkucPLff6Mb5AJHgAqgk/jS6A7Dtb240eChPPOibzwaxDE3Gmu1O5VJoQLIjrxEBTCdrbkK YCiXv3oK1ONVAIgqKFg96/+6qfKuqQIoM+Q9bPiJ5eoGmVzUSiYXBWZywZVMLpZrVQ8/cd++ ysY5KvzEib7etq8TVcADhJ+4LqhE5cYBcVFvgbSO1zK5qDyTi4oyucwkjjdFNfyEeB+luLEW p7eqMZPLRBA7Pmlj8ZPyWnzPnex+G7cqrCWbeb5gwppgPncH30ST5CvpUI8NP1FGFSPbU0BK moFI6zhHWsf7M7l4ROKzrrXLyB4ZaR3fHGmdFAyQNxaQ1mn/xOEn4SxwtQfT6ChSuyvhj09f vZkUY7QK/fgUiWBeiebmj8bTJZqDEsGMD1Zip3gyqKX40lYmnhhDe/to4ol3lSQItlREWaVu Z6k4PdHcTOJd4kkWHSu49mr7RBkX6DJRo1ONtidGx9J9ieawnkMYUMmEa+JJNdFcNonzxJNT E83tjI4N5I0KaNNeMTrWKGMpgIBd7Td74y7RsY5Et46O/R0SzT1+dOyDJYZ5GFkDI34DJA6+ gsTBQSQOW006J4GktvPD24qsASSdc0tQV4UI2bbiwWSNlfBXzInsTg9/PUkVMq1SDYmD50gc XLYliXfJGpEqZEz2ACe1negxfaZPkTVqmSPyY1uahecLJqzKGlPrsPbiokgcYCqHiIiES7YZ lhFej1UhY4G75ycBw+oYVQhAs19JFbKQSKOs7pVVIaxggFLWUL3F+Illjd9BFXJ/HG7VsjmH y8/30W+BsBjYEZZL2A65JDoM3TFOZvfmuFw0dEaubzMuj+WSpI4/tme5ZPLtHE/RI7w1Q1sU TF3nyk9KXXeWbTMf8ySXxO97D+NJLsmaWtLgXSl1nUcIMwiQS0gQV26sA5lWqeat2VM5USHO sGStjZdleoMwixr317wxy93slPedHwpwU9SdSkRRBZCYpqUtCopFTneJhUIf/XuUJKJElJBv ECWQMDL+XqgQm7fy8clf3X6j2lh+BU/NWl3HdHzBJ70VnSwbCwQoMwNGCNXzUKN5N5a3FSC0 JDgxXZGprko/nIGwoJQJJqZLshEPeQ+T1SxTJEbrvEXEVbPW1siaYlYb4tfsr6V44a2Ji1lt T7PKVvPIps1axM2yYppzTrVtEhXdVZk2mxWQ7m/LrjjRTBik0saYQHWaTa1VWKMgb3x5qa33 zhSJutVrmrzhUVWH8bbdpNnOFInSXSHPSJG411tzh9iTVzoz9ddwDod8Y998jbc/pvR1b/Tt s/nbfPY+n9wPgdSzgfkTc/EU9MP3jnPB17LqH3hW3jxOirx5DdnIm+e4fqoUAMPHYfYhvV+V vmHli8R5FqObJc47OjkbYU3r6fNDff/L9fE2uYq++X6//fRLs5qh7egOWdeFSNpxbl70//j4 +c27ahK0xry3zZJ39LwukarOnRUKD8633/xN8ZOjzcBD7RXDqLF0f18yHkbOwtx4j2RR97o1 DNNhvB9uul8/zBz9S3yKySqbnug63ZNWTH63cTVlQxa5yzlOM4mlHn20P73/NG8fP9/fh9Br H7Rd5ZrfzXv68jj8/E44/KrpLxcLPQkuk7KgEEpgI8Z8kY6NGAYLxjWSh0MeC00V9/mMj3CE Vla3fdc2k7IgLRc3VxaAdR7JEXq6nL5w+B/A+vcEOPwVBik3jgpgsqsbJ5K7g1UOtv71iLP+ Fta/Y8Bvqzj8QjDqvqw62Ti30LKdjsM/kzjeFM+Ew481mVExSyZMrpQvHP61xrYLvKeRRRL2 NHrh8EfPC4f/ETyNzsLhz4GM0HWE91m4eOHwh/6xVZ0AcPiH8hcO/792OyK5bu6Awz+t03Pj 8A+zuBAOf2jsIXH4h5Gt4fAPb7xw+H9JHH74w3dveLKHuZJbzm8Q/MNXgn84GPxDqrHJS1bf 6EpuetM1WjCCK1dy0CG3qzjkurakQQbf4Ep+lOMLUcJAV3K3MbkQ/MYOudMq1YJ/eB78w6Pg n5nEuagONkb8ZTUmkUBdAp9MkCU2MUNXDuHpl/qVvArKlTWGsZx5Pn2RrqTGm1oHr+SXdMiF Ibfu55C79Bt7U/soXu3EBrHDu+HlkLs9q4IByit55zaLet4r+bDTB6vupw/jDVxdu2pxvLU3 7Qv35JfEPSGoq8gWIO5JX5ctmBSNejDZwl1Kda/QTnX/Y+OezCTOz5xjTtaobhrsc466vwBC mZ6sMXdkwSPzTLgmW6zgniQ5Oc6VLU7DPaHgd7LEPRE57ol4BftEItRAohfuyeXV/U8RrfMC Lnkm4JLKTgD8cNq+Il8c5U7gL9ZaNuzB5IsHcyc4C7hkJnFdvoh+uaU7wU7gEtfUnK+zZMI1 +aIKXHJRd4IrA5fc1p3ACtZSAK/95U6QPi/gkkdwJ8hkjeaqssZkHH8CWQO7lq7vukhWXBdJ 6broD+QqcAlbAUlDvTpGl2HqugzBqX0a4BLOW91iMbHd7XQZaM11keSui0S2JYk3ZI2pn8lO EsyqqOcG4ySk9KJ2ErQHuAR3FddFz4SrskbNdbG1ifrhXFkDTFa6WcDSxkKDkC7D5roMe6Qu Y6xLOEGCcQoki6kvwDKyR9Zl2JvrMpqCAWBZo31eWePx7ST3BkXjwkm5Q0CqCblPvv7zbj7e 1Lt++zDWfJj3fqBzHLcFCxlSbAsZGarInGFhOvECVBNVNRSSRMjIfsOLkLGCQuIBIZg0ViwO e7OQEf2WCxlhXKQ9QaFRDSyik5CxFHm46gg5JEEhmZFDysAi2slJyMj7KISMC6OQPBYS67RK MAoJl5zrjNMSuQBr1pLFxjG0BhlMhqj96bM0oZCQri35OO8OkFgg0JGwpgXD5CsITlOzHi+o 81Plyie1BOWZG4s2QzKJplngA8a2RD5vYJpD3dwBDphmiaCyJRfAwCHYYI6LTHwUamzYd2ut R9AH8bM9MkxE32obxE0LoN2AADVZWxl5PSxJZd5bjeVYNjZAuaS99WsLEH9ahZULqA/T/lYP 1I2EjAHXd7fE0gKNTQW4M+4WA2dNdDyFObCay1+HRdkhSw0wD6wUCItZbW6nFSybKs2GJSqR W2Ism2xkTbm80xINSD1APscScnlurLoA0xvgaloQyyYeewphM6GgFCMbx4xKilTHPsnmTfTR 2JZQTxKDikb8ByZCJZkq1IXb8MFZSTvXrmedC0f9GgxKZ9dgUIYT0tf33v5v/6jPf739UN1n 8z2GQWlC5nshqiK2Pwe2sFTwgFJRBZ24OS5Kj+igggyoKFOevp6uwhsI1RkPG+Mq9aEfzNZA FFqpZYmi0nTydigqt+bIk7FNjoe2OAkNpRN9j5ZKHz/6t1DN3yKbenZHbq3nsf5P0/81AWJM ACGarCL+dIZKMlIkkDTsNV95ulbWufQCSCyqxVhEnO5utd/CjIlYw6h5JZQEFvIUSBSCBeJ+ bObdn6wDKsk/n97113983UBI2tW6fFY4lXsko2QlBgu5QhhnrlJBAAaLtGYjjJMdjcEyA7bO PalWIdUFe0ifl/fNHHMZ22M60dGuVxFga1wHz/aYpdzdYcXiYxFjsAxtdQUGy1D+Skb5LwiD BfX3xGC5N8TxAxky1Q0MmWrFkKlADBZzEgaLk/PgjUPN4XCU05TRhj9aMkpvfB3ugKcjHUOG zPGvJyEdrxgyVW7IVKkhcyBxvCn2JaMkuscU8jg+KRllgVm6Mxkl4abilO2ZMJcAiu4g1UOG QJsO9XgMltOcsvdopQK4WM9ifRnRbdtf1Ci3aXuMOk8HIiLtjPue495jqmU12h0jG1DkONsY mRNsy8YGEjU3dpriBQOUhkx/l6LPa8g8NwPDrc2a90Z7I7S1akYVHjGFVTz0022YGQPN4IjR YacFlbMNMy9fkS9mG+b8BYmyDxyRScH1gyAbphaOz04QzGsYb0faMOuZFO5tw8SolC/AZNe3 sGGGVaplUlBGHUasitqXeJ9xjzS64ak5SIcEIFN304LmDAwb91zdfCA7jHvd2rlfME5EiAcx 7nFFcd24F72xZdyDUlmcadzTpXEPF8amDhQ9IeMerpp0RiuM30M7VnMYGc5tS1HsO9bhU32y cc+TfId8MQ8k5WJZzupE417opJxmvkQrxr3k1SznALC8qGiMRglRagNZpllvrDqreQGisSt3 ScDF2MFpql6ZwhCb1WWiJETlCCqhHBa2moI9RN5dPZVFwWdAPpCk/27lPCsaqxGxnObeTApb Mk9eI3xNVuyHrfr1zYeeVyP7yOdP70Z9+Nrf/vyP71r64ZMVG41j4ML82Ost86PoAfMjpuvw 6g9gUDw2m8DRFQTmXBQ8+Zn40RlvsyJVe8ftMzKodjF0TRXDYnYq7D6/nG2t8m3SOfyO9scT jMkv496tciWI0k5Hr2Cny3UECLDTaUovnSuhKXIluCuk7HvSH2Bzw3ztPsXckMymIbPpIsmV 4PvvlhhtqPxlp8vsdNjc1E53Fn5xbvhGtzF8/+74xcJ0DMIvHspf+MX/2otfTBoj74BfPK3T c+MXD7O4EH5xaOwh8YuHka3hFw9vvPCLfyP8YnRVIxMqvncXzNjd7s3YPftSqNkBLCqXNrIz rcXKJXUukbF77j+zM03lp9mZaoLlHJC/FAW1Po4/gPmYQcHyjnamB8rYHa3SjozdFwwimzqu 25kWxoa17K7uCXamywaRgZaJgSHXWj/HzqRbUbczRcajLTtTkUP9HDvTvCJ5omysTg8ii+vm hDgrZbotgsh6671mTrczuUWpnW5RY9WE6OVQt7bTUUFk2cDgvNiRnWlazdnOVF3eNdPQpgXs WkFk44Mrp0YxqzSIrJIHvRhZPSH6VFDLg06BbFqVV8vLAk7HvmZnqmFWTqaHOQ/61BibbTOP m7H717A1vVJ4r5oqTrbfHN1T21jchzn6VRh48ed38/H2+fOk9G9qdc8wUHErezIH14XKPrrO 25mGKDKmL26i+mUD6+6S2PyXNmdhhiTxJP0w3z6+/vGhvsxr0a37tv6utqw8deCV8n7nqgh0 Ut7vlhz22rIMlqp3e+FwyPN+U8u5LGLOpi5gWxa1lLaFzr1VjGHZwXm/OZ+v40Xeb++Cn9uy Jr/zly0LsGWpe8ac4dI6dQ1zb5ltLFin/KD9xdzdZg11stTGFsF+i5xineLFTsFU9YTBQWYY WXin+IfyfKc4mcNSjsqdMvYB7RS/6lhZGu+UoOrrcUMxrijnGpLsFJz+Z89O8cTuGqpJR1V9 pwxzTHbKMF4B7RTSRm2x/84VKBrYKUdbp3zmjw6lyjlhNddUGGaJSnbKFa1T+ToV1ik1QE8h NqkeyKj559GlEUtD2ez62Mw411Fj00U2/MkLPQbefmOjMbEoqvCBWm3F/J9YBZDycHGdJfnd uMmVMkXBinaIzCMLBwJtuhrNUHiDtQi6teOGYB2DVhcFfly88GzlmT5hXmhqs8ZMGVWWjp2p FZ9yGTdGtc9BBxYMjWGkuC6dYOd5JK8a0vG5oONdZ1BCCMa1iVdz2qTT7/FAsGUU0PDMrTc9 poRF02xtCzcmtDWN+8/2GxuNDf1y3ZULwApjL6nSbN55w8bAqASbKt6osEazUGTkFVbunt0j GzfLzEXuZhKvCCOK7wrNixleLETc2BL7d0DBtO5+uRk0eMJ2ih4JTjMbSDzN1e52HUEYdZiU KuRij6wKWK9Ma3N+iifItJb3Ub+ZyItkQrGStr1szCRvRXUeMovrEUF3sLx1+0xrM4njTVFF J8dAFldNEptYgk7eqcZ0FtL3T5/WwqA4v0H3ZlpjbOatggljRdQRmdYumsUVDuoPb9whi2v8 gz/I01cL8zQ0dmhkEDo5A9AF1gTx8O+MREnrccWHzuL6G2Rae3x08ntnWfPqWQGpZ1Gsnj3d xSrlmmbW4iysp4NrziRVjOUhgZVEx/nud4qytmeF7/6UpAjS4vjD3/Z9Eco/p7j6tfWdJ4Xy z20l46WCLZGet8yv5lap5mGM9nwpdpypM5ckBbqELb7oAZ27OjV1pJp4ZOMmiArgFF1lY8HM YUn1Kj0PhGeU6Y7wVrkozWh5kIw/zEm86o0d9Q3bd1CunPOFHau5gpI+P/ARYMdyC7yupEdH x2ShIiZr3iDgbXHm5Jud62l597Jj5XYsRBVF0Lme9H9NO9a9k8DdE9Eo5KECEI2m8pXtchFE o6EfBIpBL0SjUgyqpZl1F3F3tSXpdrmJGHQXRKPQ8Sqi0cjAsKYGnYRo9OzpSh4W0SisyA5E oyM8zdcRjYZsvntWM4ysQDSKPc1vg2g0DyTlYlnO6kRPc/8A/tz5EsEbPUE0Cq/GiEbw8h6D aNQC06w3Vp3VvADR2FNEo2ns4DRTRKMps0k2TVESonIElWrNpeDKiEah/0shGmXTfCEavRCN HgPRSLQquI5+ev9bff40+MpGjufU+4/WlvoGcEgn+32f5MUtWq4H/fL3L46YboO+2Z/vAWQ2 oYoia97HL4yiV46UF4zSI+ZIaUo9H7uCni/XZiBAz0ftFlTMEXq+1vE2NqTwV2+VEKa3ZY4U xJhaNtkuPV/oQ4sSeymUwzlSAsaSJIWeL5S3Nnh4vPR8ub/6bbGXXjlSfoscKe2m+3r0QVp1 p+oYmt3Xozr3dKeqgiuB7lTBJd0sf724O9VZOVJmEsebAnanGtKKzO6YDTeo5wYnSZ0zdyo7 PuWldvql7k5VJE3JuG5sDEuhZ94qmDCXALLJ1NypHiBHShZZHxqM3am8KxZx66eNzQrW3amm VxvH38Z76o4FxH1aGQVcd093p/JDPWKaw7+jV4vW44o73KkWEukS6+iYaW6+mhf8BjlSHt+d 6v5ZUZTPTHgY1DOTQi0ZeyUuju4XKebDqYgdDQ/ORYoJgOpIkSJoVguRYs2IGBnrirQovayJ FLMvwBVl8Xkus0gxjUuTXbJ4Vqe5gEjxiGlR3CrVjIiyRGRJpAAjPYxmVMWdw5SBn8ciF8Kw PHDroAkle7MGCjUpgnrW5SbKNV+qpV+hex/cO42d066xpN1j95vtEkXr459i/HM2BwSfx1YD Sdodp3Adj6wkYrU7UKbToJAV0yyo3lIiujGANqxBxC5GVoy9PrLqQGYSRT8OvJJ3B4thEug3 QUErZTqv/QN3QFDvJUQ0s9kpbizpbEGQPUWk2EszoltazrvCK4P8r9yQV7bTConi9Y7UmCDN grayXIClo172NGJaK2XfsDy6cZ5E07ZJ614xWWW82UgPj8xrJY/YXyFIxHQ93JjXUJb7K6LZ kPkxp+rWdgIuMXtGdjxbnSeP7hB68irhczLj9HjLnYfpeXMntZNHg67d65RJtX74tngcFaU/ /fvtx4cxb3+o9z+8tPjXTy8vco+VtQJU474IGzYN1a2aNM61TTiOA2wTmOvfzjjxMjA8aXIH dxxdzsDQMN5zy2YM3rknxRzVTKEnDeV05l7oUkPyS81U55AbGJRwi0mSS01+vB4OpSNxZ9Sv HiByYhL22wLinJXcId9Q6DoIU6Xu4PdO7oCt6qDkDkP5K7nDXvsDwlw2it88ucO0Ts+d3GGY xYWSO4TGNpM79I1A5TTHX9qsgCV5Cag0UXdHj2wtucPwxu7kDj1dopVfyR2ABXgld9ijKz81 uQN7JXc4RrC8VMhNcLKvCJa/UxLxaJXWkjtcPuRm6vjc5A5jv5AuXtgcV8R4N/gtXWE15IaW 6HE7Q24GbitYaSqYXqssQEea+UOR0ttTNVuA+4TcTCuyHXJD4WleLYn4PLI85IZGrLEWcjM2 dnxB2dg8kJSLr5pEnBaE2A65mV4t0iDsCLmJtzE8kOsmEY/GDk5zLYn4PE1REqJyBBUhNxFb XTPkZur/IiE35TQfOrmDO4e3wm6wpmthN8OhujKIvlkbwytq56midl65JYpxvnJLXC63xCsg 6RWQ9ApIuoG9EEigcQ17Ya7uQaW90McJXQ54aHIaPsBOkLW4iqPshVNPh9xe6HWIrEvsGtNv QzJ6WibQCOXoZS98vIAkIIEGvkECDRQn0JBOPjaaaLyVQKM5ygIYGsbY0NFSfaGdUlgA3VWs dRdume8U1AgjI6tdkkBjeIHEO2VQp3a2p/3RO4X2xFR2Cgd3yhI8AOyUhlZ2Sk0BCu8U3FKu +WUUoH3f5phDfn1xp2WLdilAIQsgWiyA6LgEGuM6ZRbAMCSjkSINS2nERbO8YVutexk5B7or kaa5MWVuzJ226atctVlBlxZ4RRxkgKKduwwnAP99Q3MYfUwy91he2oz8JNwPnTZFv8fquYZp 2t7QtnBlJhmJZDZvYqFphodaeCChuxYTr0A5uKPBP52X5w2rN4bQChHH/mZeXZumW00uYifQ cYvEs0qJWF/N4YmihNwFzyReuJhqa/tEn+oEdd3mIxv5mYuSi9YIMYwdXE2Nm9wdeKk76q54 HnvlGG+/aioqGBcvOnh74zM6ZI2JFqpbbIl4RdwQR5p1WWPBmhrNaiGivNACpDSDClYWoPEe 8aIg76b2EDRPIOBMqK7I0D83kq4w7cqsAi1kk1NVQKyRMLwbol+Vng/xmDT8j6atz5mEoMby rYjguvECuEO8nRUfsIB17wQamglLV7yNGU2cjXcl96vbnFO756rINb/vgf4beZTIhS4YoTX0 f0m06wa4nJQ2Z2gucYRWGJe3/RwRoTXR8iIiVwXtWmDZcdVPF5rbwTyGVQJdrqgSqfdKhnoX 6ItFV9A2s9HEFCzYplivbD3yDOiF3XY2JKCVU97CKIPTyFID22iCy9pqsmmuGMkAY1E+kOIN sLGtIDZg7MGmsGJa39lYBH9dNDYd2fOs6ga24st4DM2SkXVdKRsebaWs0cxJNbTCGkwAdavd lXyWvYrT3YPKWZVjrzXW5rimmm/SDLQ5u+9Um8SdDcai1Q0XrEI7JJEKw+dDlRIGU3SXOrLH 6D9VGf6JS5oVgX/eKRlJiZfzrFXcXQGRTvvnkMAVfunL7TR7P3pgBESl2wFJYxBURDM49nUR /kLLVIIdUZ13MjK+lIvYtI6Z6iMuJtoxPDVtsbxH2ZyPFIDK6l2wuNQMv6pdNT6fYbM90eaK KGBz7emDm1wJpdRbqPtvP7+o73+9fahP301kJwiomFUqY8e/3sbYB+PNYNn4R/0VOm69lZHW URqONhQ1HcWeWOqLfvvkJvrzzX7++f3PYA4xbvbeBMfX7LB3m+ujm2J5Q6lOrOFIXxbw8gzT a+eOJjRW/TcJ1rcv3z/mHYbW7Fi/m9n2Ze1dRJYzrb1arll7qVy19loetkdprCVIPZy1ltwm TUyuMkFgmpgNU9QrTcxvaK29f5qYO2fMI7jhrT/L+g/jz7/u68/33kvEKpzuIsBv0WZt4xC5 N3yFIictulsZadLwlXDhb+0YDwhZb5Odk9RpxLxzxisMMR1zf9PtIVUlzn3Urbdj9pkicd4v 7+dwNH5kLwmN4zcn2lNOOCNNtnO28CM5PVwgcR5aTZyX8DwzZQK53bqPHZfj8nJ+RmO7R+bu bpHuo+s5ZxGQJafSkaDJ3pCAIiX8IkoFDkoa6/oCHDGPeF1+kCTrl+RKNwDP8JI0K3Vsy5kz vjHn2KsNZJd24rgTtazsWDNkF/jRojf96cP07jLzEa6gzEuWPJpI7YtS+P+Im+TmIzQSuiYO 2fD/kd4MdTwCAB58c/bABU4bAZK95j2RyV7T1shlr2lj7PmCpG2RX132OvsL4guFpUKxNoQv n/wFifx/yE7/H/9M6xSHQHLOsWMPy5uWdwsCAA4FPWUHJFuB+rZfTtupgDeN1z4DumApOx/P uDTGrKORP5hl27aSDm4I7gLsC3gjFBSAPr5qubviKuWBff0A3DVnHHI6MhEUvANPW86YJBgC cnONita/Oo5oGVn+xviX3jLjLlZGJSNz/fZoHsgyMsaUG0CYlXFDm0YYUZUqaXD5DSHuVTdw O/frWicddrejg9/Bvpv4jaH1lI3Dse8pgfr51aGgaUNjUuJ0ebtghPBv4Nb3QhpgNdG8AEO/ DE0DikfmfmhQ/AbigpGVr9tU13KhiVT0MBAPyzAQR8yCzGsf8Zklvd5Ij0xL595I1N3wZ7wD 5kmE7qJ+idamgTyyRvJ6ykgV6wjCAKzqqv0eQp1udrfCgWZ+NcYaOGvMdEm/YWRLQTkySa1c CuLG3Gx6Mf027h4iltXM6uLoDaINS6xuyav9LIHxufWZqhMh5jXzrEFFn4zM9HYYCGk8BoYQ bpy6n0h1mLpZOHHsBp6mwbgLrNGKtpzm0IgcupOL9IhD1RanG51r2wx81vb9UuDOQS0oi2bl eBSr6Q0GMe1YFyAvY6275C1HwfzG8Kebd0Nc97k31/JgNyulNWcaYdagTvTxwe7qdnwZmWCe PNPIYAHr3pldHyjjA7lBxgeykvGBlBkfQuK4KOND8j7r5rYKeWuUKQF5C0/y1nJzUMZ9GgF5 y2gkWt0wYid5KxLu75nxgVKOmEBnOf9A/tYnZnyYVqmW8YHkGR/IkvFhIXG8KYCMD5MlQaPF vu3PmCVpwGjyZIry6MNZSFvZLzMSw1ww7xI/rR0ZH4Se8JJzh1kkk7EnGR+m1qGrrGfI3OfS nprxobV9MTKUEJFwWWaahFGNoowPYwHCKUaVK1jP+FAM5PgCaGSPmPFhIZFGWd0rZ3xoCgbI Gxs0JO3zZnwYzgJXO4T1TlawNxUSFnqjJEarLg3hoBiM08FIP+Ry6INrwMMkjWBXFU8m3Iq6 eOJthgKyGaLYZrgCCHmUYBJEmcyUoNsQCpJ6JRMtWhYpFnYJJtZ6b//jjHA+nBLTxQg3nd5E YyvsJb2SfwlFENE97kEoSGTZ7ZPPT6u0Zko4vqBsbOaSpKBhp2v/dwzE5HaJZo9dYt4EU8HE /bum6VU/Qm2NLILXHCij9jh47i/Y3xgrD5Lhh5DvCGO84mF73Gdw30G5cs4XzhXoCnr+/MBH kHOF2ED6Pd65whTOFfMGuYBzxSXO9bT8BZ39r8dzrrh3bk5CeyGXVBILOpbcBgXdo6OJPlru SksArwplDap6VSSiUNyWSEBB52d3gBZUp8jKOSJZn5pCq7iDn7Fl8rlUtgw+csscLQr1vftc IGDLEMmjudxOFAqrBIOChuR/Od7fWozPmH2q1DdU01Atx/V2OqixoJ6GKipwp3U0snmXAAqf atarYrfURxZ/8cE0VKW6Lxk7N3BjWMYkmkeW/XsJApkoA0ovURqqYiCzryymy2p65rYaWM35 zCnoXSMisAAJiTjpK2qste6OER/jJSKtsLEImOW+rPW7FAxtBi2lEKZJeaVHHJ4mk1jWOCFy Vt4v2EZ49VNeqmSoUPap7WmC8VhZ9qliASok8mA5uu27VBm7ZJ+Kn1JNPO+8iGZDXqrN9d47 MsVLep91G4v5zHtWX/BqB4z9GheovaCge+SevFb4omyGVNAHzGMVjuIlgCeKQODGhzmIegiK P1WHCATX24+vHwvkIPEzraoiT4zHCMfbSJ+4mrLBLa2qjvSn0xjG8en9p3n7+Pn+7oRsH2fk NaaXDbB4Xki8M+MleHmlv0bynvzigoArvbRbrnvt/it9q6jFUuzG7GoV7zAhMyJdfKUfT7fi Sh/qOJbKr/RT39D9ZD7lc3S7UM5q95Pf90rv0e0ouemV/qxsWDlcJLpOABLKNtTvng1LmI5B 2bCG8lc2rH/tzobVck+wHfd+2DfjxGxY0zo9dzasYRYXyoYVGtvMhqVxCd41/9JmBc1SoD3C 2Zx045SRrWXDGt7YnQ1Lo8Us9cqGBSzAE2TDwlfVfOfYr5CPohOfnCA8CPCDu8V78GJAwb3j Yqpv919LS9V3KOec7nJPjOoQW6i+jdu6xF0oRHPIVd+hD1ZzT3S/dRA2GbGmna1FyftS1d0T kVEV0RJ0T9Sge2J42h5xechV3+Ncpk/gspY3cU8kpLUGyoflr/RCdukncDMc5ALuiWGVYNW3 lFxsa15LF0NQ72R0XHc6/lZdDEmK5QMPpCWmMjKjChfDUr0274V9QwVYJaVZcGhKGutAmuUF 1WkS2MUwYBi5gWJjswKbg3QuTWXijLD2nJEBToDRQHjP1JZ/aPSM36yjXAxXppmSSJdfleuo JKfJwDsg4gTvYkiQuoCL4a7vT1HN7+y6dyGzq96FT+Ee+ADopQavgHc1+ELopTnvHTaUT9HJ hy2dRe9cQsC2IUXAqH9CJrxLoZfSa0MOBPTSxaBN4LkU6KXj3HdnzBxpeQkJ4bGM49MqVQIY QoRnwvUtye7MtJMFbWuNtahkm2K9KgsSN1ZFL53emBkmfSMfmX/mV7N+ozSUzDqpMoA3R++j wgC3nYZybd4VmjVx3Oqkt5z+bSdkyEh2QcLIMitfFTW1avmtTjOCb602No69LZmnHBnWGvmf 45vpLpTcAomz6Be2/BYJUYfsk5XGYgTQlN7xEsXT9MCKG/JeWReAj52zT66s5tbilRCwG/Le ZJcLaSjhsYMoufDOWyBg2/o0hzfqSqKFaSfxsVDbFSi5a2HJxawKmmUFpbxXBYfdoJmwuLw+ ZSi5M16mshtUTXJ5VqdZ2/k5jm57nGh6pABUVneHwUr1ll8V/PTcpJnujN1KmsnZes7MMwnw bCk3LeZTpdCtT7Qa0puGeda9Kfw+gHJ1BuDFuu1dui1SAsdajF7AsWUNrlWHg3/DPx8TtfRM aoHX7nBng842qg133KWBT1/DdXd2tQiXVhPCCappcM/IA3oP3FpmBkBR866HE2Oa9MAbOPjb kDri5ykgtqLlcti43784hnYn/Jv9+R6CBpPEsMFLqM4rxyLbPi3ELCece8b87hjKfP0UTqz/ THEtdSJr7Cs5mn43n03vp+oYKnwQgs5mpbu289vWh3IO6L++00HnE4514/cwXvPBOsVJiSFJ /Hp+mG8fX//4UF9mz61uPYT1d/VuAtBgr+HdtAcNtvEqt2NsUDvQYGcT1NyT9zxSfVCYnJuR MPagyrybWg+REiuYpt8GL6am4t1Ef3VEsqfwbnosNNjHgZax3Oyz3ULMsxNaxvXR1m23o422 AIOtQcvgvr5xCOWVjUMPgO22r0DLuC8dMmywQz8QtAwhSpg8lad/OBe0aRqTbJxj3JdOhpax VWiZgbGKlS5IHG8KAFpm6semahGPQBYrLgiyxEYYrOMD6qXCs2r3RXYbWsa9NWPflUyY3LJy aBkwQ8zloWV0MTK0OG3dH1pmHIjHHGwlpzvSN0Ije0HLxA8tGCBv7ELgu/eDlhl2+nC9cxdv L0137Wooxq0Nv/eHrbudSxjGsEvYbsS6+Fwso6HDd8KthNCAWOH64CuIdSUwTOgDdgnDiEFi he+fE4m4qIgVpBQrWqvqLmGYN6Y9AAZfP5c7iRVOoGIYMvgKLC1DuTx+A5ewsEpHuYQtXzXc gKhzsFiRRBQn39v4SUQDscMljNGK0dajV+Qn08rIUqa6mEtYDXUuL6hOk627hNncJczudwkD B3LMJ/J40aDa2BVdwuzNXcJKU3TOCZdDnXu5hMGSwb0R4wh154ifr1cUv42xwioeeiV5gDha 1zB7gU2HWsD7onJW0uXlK7oGPAkF8wEZeXTt9QIb+kEwWpyTOQ/HK+nolq5hKSpzWENzKZR0 3nXpGC+wJX/4uaFSIYc15CduSNMXaQOu7gU2rRIsFGimjDqM0SczqnlFSij5ZG7McndQ64YT lLJHQxc9xbSgOQMDiouhbiEDdHlKX8AVYuveDLsJYYM5Lhw8wG/SwJBrrUcebPGzPTJMuKLY Au5oxRvVxsReh7WwZp1STe1rGTz2khUp3MKc8LuyAJGI5agmZ19CzDQjSd18qAHYzu+hHas5 jAyvJBHHGlH3bQaBBDN3tLn1aI6B5DskjHkgKRfLclab22nxXCuvTcU08yWCN3pI2p68Gvtp wcsLyT7LNq4NZJlmvbHqrOYFiMY+OKzlYwenGRxYyq9gOk1REqJyBJVavqWgnta9mOac372g SFmQ9L/m01c0tpLWPZvmXoiULZknrxG+JiuuV61a9dwKZ7CvHizk/6jPf7398OlLv8euV03w rRE1Z5HhpNny38KDO0XdgevZPLB60UOOVHTdP0CoznhfN1erDx1htgaVcnLC7hNdPCTukCz6 6yWSG/0d78dyqq/PSc46neh7tFT6+NG/hWrB+aTuQ3LspLxU51nR41FELkhvn96t7814RqQr QEMXcO3RvJ/a8J42TrT2tVCo1dZqnefZc0LW8JdzzU2cawA0YHonNGDlE1wfo81fc67xaZAR ayDoIJ+Rq0j3N36+Jwf71Xt78UXPnGumJ763T2UKIdn3rJnu7Wl58zs412Dg3r7uXIPN74wG fDMDWAUOeDDoqOMMYDAccDCACe1k+ANkAFMrBjAFZkYwsQGsxpvFnmFsc89EwmswTMF7hrjb uoINYOpuBrAQ8Qj51RjSqCiR9S3hgDcMYOmXdLkjBSTb+HIe4q4sgm76nWqs0KxiVYqfWDlg 9hjAdPA9iApiRkouZ6ABLIUcjSYBD/VoA9iANXuWmalaUFDVfVg56sVJjR0xMn/oCy3LfteG 6t9gQGOtv0qoMtT1pNQUw/AiO99AIgoEZ+5sDHp1swBEBUk4ISSeCEq22kAe2AAWjoF1gZqi NYH61sYwcVUpYQpJXTOGqZbNiqEFOpdtpwzYg4oQnWXaADKCLw96VkBGwLZN5OqkzpkpA5K2 vFq3lBFcOb8gJGdTQ0U41h42zxGQq2eZ6gh72EWyJwlOpBPPJrvI7WSEsEo1e1hHVk5XC+jc dVUZPejcs7YWDe9Ehv1q8hUbR/EGGld9nwVFL9aANUX60Y2VOYpmp5BymnWN+rYifYVmyciA uO5SkX4qzUS/+JGOx5TI5aq4bjHU6W+15QUWYE4AEQ3E63U3P+utrE1T802axd7nhKEWNvsN GmPYMhqH5O6QXioUyYcqZZsWtDA+IkiRaHlHcqOc8Uo+wyEjqsQLF7WKc3f50elAOF+6CwX9 ynaagTFDMlgqoxwZ85csr5ItgHeXalm7D8LMF/D5XxiB1xRMcKtJPBAl2qZi+B765xTOWrJ3 IIQl/RMiFLidlJCRdRMciIW6O9IetkPsySudh0ZwjiHqREPSlN8gMST1dNOOhBI7ErqKHeli 8fvH21KOrXAkSQTmXBRs8pn4yRhvJCNVe8AZ0fEnm71OMLLczlB2CcvVfZJ0sHZADvA5LMy/ f7x9/+fTj/7PGRFDX3A9CCKNJ1KUCISINtidLmwne1pz10nX+jNtZOI2GTPzOz6C0mt4VryU jWyqcihtZP6h0F1+I2Mmye/yrXdlE4tv61LO3MqYKdlQYiPrVNN3xhY2sqG8mv7vV7KRHR+A jtSNbGT/9Zs+/zbv//729vnrH9//z+Gv/3bfkS/m+x9v/5/+TXjIEf+j295fv37//PWf/8P9 4+g+wiI3zX+NC5f8SXwwEKf/5b4SjDYCN40rdwclof91QFeYb/H8dOffx+HwXx9fv/5Ye2/r 9yd9BvY/K60MLdPKXONDUuI1/N5pZVokDAPSygzlr7Qy/9qRVkZY6eQojHbaj+EAyhPTykzr 9NxpZYZZXCitTGgMTCszvTH9UE4zIdHSGAUAK08eGZRWJqlgVKnQHZTQmJmYvK1sRaymttRj QcYqSGCaw8vPmVZm4ETWcyKfMK1M1Jg7RFrRIpYvwFH+AC1rpOJSGytkxxg9uAWTvVWs6zDG Vi4hq1S3HQ+N4aStSAdLZNOpTuFGd1J2ojnIvkV9r4ixqJdUJWlbMcGl1SliWqlV9APlB9+t mkFUqBuZZTyufOjmvzYsnWZa0y08TiYRreZQE9lDWiHns6Xm4g8wmHKMXvaXr5nhqgyzSBsb +zRSLo25mkOikENaMxRMFViTT3OoOUVRHdKarmAaJMHzG67CnJJkbgwWsNBVjfCzFf3xIlIH m4+0DU0jUqPylVv7+RGpUz80s8DP5SdZ4GsRqbvyEkBzOcICf0pE6oXyEmgZ0eUWFvholdYi Um32wEJXGyH4xzvfVmInF7D/5ClDJksjUzV2slzkdDfYuml6A+y/RUvo4BAySVeNmeOrdbD/ 4o0dZtb9CP6wydCTPCogvRVRFC+nUoVcfvWRFbOqrAgcMhnms9uanCK6RyGT02pWPD2Gdc4b azZXBHA0qI2sKWa1IslEk1C94suspldzpsVb01xNQzD+pY7gX45spnc+iXJF8u62jObTJACv hbUFiGkmDFJpY3UE/4iqFdYAPD3w5nqveXpskSh/Q1UdDdp2k2Y7PT0CJnvxakIzHwRYY9rH jEgdzuCtYFISwJ+vEkzqN29hw2/Ihg3fcS8Ex9+rx0Ljv3VUaKNM462yA4a9dxpQ7/qt++l2 oLfq0lVo9LOh8O+WMuC+0+aSB1P4tAEDTOFqeOTZ2UN6Kld2vNuOqx43j+4T8bSQ+6/A3EcN zEW3Qb3PdRoIDMy9oNPBgCLPoMDcIGIdLoF6j5gXMQCngwENH3I6GMbFy8DcAQ3/ymkV07ae xungvqj3r2TlF0tWbhtGfGu2O+Qqv5smK9eksmeAZOWtlXVkWklx3097Jp/LtGeiS8VNkGk7 SjhBkMqvZeoXTlbuV6oW7Ro/i11iZ7JypEVlZDrRGu1PVr421KMDc89OVs4jA2SJTItZhkyL 2WMkKze478ogq3pj10OmdSR6JSv//ZBp752s/JaSgbt1VyQDdbRkgCuSAXbdEFAyUCuSgQIl A1yVDHRdMsBYdfslA2V0XTLguENpKpxoLneSDIjuqQyG+DwcV5i2wXiy49xOMsBbkkG8u5mO 4roa19F+zHpsj8asxzskA7cpYMz6wEi7JAOcSQaeqS4oGZwJ2UFWJQOEc8x6fG/JYBzq42DW 45tLBiWf5ZwQMOtp/5ySQTgGXO2hu/Er/6ZCvlP/6R6C7arhf08hWLyS4VwsGc4gWBhKDSBY nJ0Mp7J9gBx7XVsRLI7EAkNNZ5ECBIt7JsOp5tgzpAlXkpsLFpvJcFKuSU9R0YgusY6H7Fng 5/tayXDcW2lBzEi7BIs8GY4yiQfHeYLF2clw8Jpg0VudChau4JUMJxEsPIleyXAuKVg8foq8 eyfCeZj0uxjxfaJBwdEb0LppH7IuGnBZpN8NOPu19LsSypPnRJPGbR8jazoHME9eB+ocvJhD tG7cly0WDaJz/U6iARjmNfyCG6vJjUWDaZXg9LsDYxUrXZA4PXOK9LuwvgL3oL6i+CKXR/a2 WBGmtZ1+lzRNJceeB6XMj7aUtSvpd92ZgPaIFYU0ATWm5X7MovgRaWMVsULjLrdkdPvT7+7T V6wswPFixYrOf/h39OqmWLEyzZREe8SKS8oZrGCAvLEAMYrx86bf/S2UFi8A84sBmAelRYM7 rkDJ5EwA8+R93dWtIbRXFckEtIb0VWsI7zqBJKi0uCOAeS1ZnxaYR1nAnwLAXIQR70mi1qnG XAfAHAvaJgUJI+UnUymAAQDmWTKxqnSxS2lxZQBzkwOYs1sAmPPOcqpJ0e/aUP0bdwEwNy8A 88sqLV4A5qmUsA1gfkspAYQwD189c7SUAECYD1JC31gLSglmRUowoJSgISnBl3vtGKi/IB1m StZMG7n+Yghspl1NSmjatps9kPO53E1KqECY+5S+hWnjFlKCPkNKaANURPKBbRB04Hrfdtwc KyXoPVICoywpmJ+eyX1Sgi6khBhk/GwpQRYjgwpO+UgBVNXW3khK6JAq+q03NrxxeylhINGt pQRR8FnOCV5KMJa9pITrSAlnAd41JeBdc4UgptJv4vcGvMNWdR0AeDeUvwDv9ltCGtMtOp2b Ad5N6/TcgHfDLC4EeBcaAwHvYmbRmKNymuMvbVbQROp0HycgNDp9ZBDgXfpGk1lphleZMVLK dGQee2XqxwPPcdUuiv6pKjCyJwW8i57nBrybnotIhq/GXo3FjcEC1r0B726jtJkVBwoOdCF8 v9KGjKg6kNLGMB9AJwGljeujrQe6EAOj3pVKG+zeFY2Tj0CljVFccVQLG2eF0gY1hoqa0kZQ zFoCKG3CXO6mtBFSQyGwoD/qdZU20SrtDYFtcLZBvXNvYusRaGX7R/hssSYkfiLiDky6dZZ0 tOI4Iumm0ibeC+MkgtKGxI0lQz3BHxVGvcsLTjTtaJuZdpr2FkqbXomOsqLftaH6N+5i2nEk urXSJmeNUzjhgZU2t7bMvHAuLolzYRg3DRh0cmGci+XDXPhvuHt35SMPeJauRrO2bd/DH/k7 4lzwVg5ozgXOBWFK8F8W52ItRBT8yO/EucC8q/hveEba+MjDOBcXjmY9E+fi6aJZx4Hw3jwG zsUdollfOBf3lwzujXPhMe4EhHGHYoy7FXPLMSEngygRCwYL/HGMeU+DawBVC5vtA40bweEO hxw0rsEtNyugcU0PCAYzlMYvDBr3zJj30SrVzCzoQvfFmUtm0nlWU/39bmXVV+dNsBQM3L+j sYAV6XFi1gcSf6AHytA9aPz7C/Y3RsqDZPhhwWGoN3bUJ2zfQblyzt8EDDQ/8BEABtr4D9wx N74dGUjnC9/c07RBLgEGeoFzPS0fcqz8wuf6M4KB0quKQmVKxYeNwbXc7NOUQMyzMwbX9bFi Dhk1Ijk8h63F4GIg0sVJxT3vjCK9PEZTYmsxuIZyJ37wRFNy/xhcP2YF4X4dYQ65rKYkrBIc gzswVrHSBYnTK1gRgzv1Y5Pbb3zrj6L+CwVF2liiVElbj0JuXWOdbTclBayRnHk+ec+gEjOs 6A6+Dtu4sXSox8bgtlYXI0MoDmQmXLL6ZftwgOk9FiCc+uqooGUpzihYIPrFY3AXEmmU1b1y DC4tGCBvbID2MM8bg/vC93gYA4zHE1C10Jid0B5xW2BojGGtkgIDYoXrYyU0hoOhMbYaQAtC e0wjNrYiVtBMrNgIjUFeSGkTsSKay53EiqoBBgyNuRG0x47QmAGNo+lI9TO3hnnRFFgbyfc2 fuY3ysaKfgeuaLOCmJHyk2llZPFhnsS8VkWDXQaYvfAc1WmydQOMzQ0w9t4GmFXR4B4GGHtz A0yewa/khMvBc/wGXhb3R8l4EAXCbqiMgkGPAfFSKyBeCgTxMlUQL732pW9rIF75l36EYqwp EJjAnJsHUyBU8T3vAxw+rVINxEvlIF4qBvGaSJweIZACYQCkSI9E0bQ4rjsqENIq0Jd+l5Rg doB4uVWqKBA8E+ZH28rIYoZM4DyrUsIuBcJemI1io2woEKZPoMilBLFfgRD6HesSJNtWclrS +2kVCAuJbg3ixQsGKBUIl4LZeCkQXtgaN8DWMEwhrOeI2LSP87A1Khug9OBs24oH5+BZuh82 vGmksKlYcX9sjcIuMZ1hPrlHjzJs0P12ifGvV8bWGPA9fV+Osn2PmRPrmj2Hal0SKHhyIe5g W9g4oQnjOClIGCk/mUCBJ8fWuKgHZ4SoMNCMctrbyEEFm17TfJrDq6JlsovrCkMVZmndpk/e oFK0VaWLaOLF00ZFH2D3qMZuruY8spzeaIrCmd4gZeSo2PZHCcqbpWCkGWplLvCsKBDmgfhg ZMcHbiWyuldWIPzi2BpnQns+NrJG7hGE/vtvdAOPoBeyxgtZ4wg5YgVZg/ZUmBeyBiqWfWns hazxQtZ4IWvEzwkFr8Zeja03BgtYL2SNCyJrcGUazhsINP3CyBoUUNm4/rueSlb1wRaQyobL dhGPEpUNQ1rTNJ3LIyBrPA4c6qnIGjFZJO5nW9GMj3q0yibmyYW4u1Q2ToCAVTbIfT63VDY1 ZI0LwqFeE1njfnComqledUW/9cZ+LzjU0hb6QtZ4IWs8BrKG+8hzKRj8kb8oskY9TzyhuvaR BzKjeB+8GrIGo41Sj4asEQJod7t7XPcjvxNZIyrIMM/7ZkjysqyH8kEhJ9llZp5ciLvPLiMq LhuBkTY+8hVkDbsv5mPXR/5sZI3Vr19j88wo/CaZUTSTDdNFv6sfan6nzCj29plRfnFkjcfH PH+40NIbJn0XNSlhZ1RpVAdVpAR3TRcdKCWYFSnBgFICqkgJGGE4syvvOek7SSpSApwZhS8R qln4h5LcQN4bYS73UwWYkMkjlxIQwQ2RXWp1uUnS99vgb7U2yRBSFxumN8rYTXAguFE9ODLM yKYqIN4L+4Z6gioAjgzNC6rT5KuOnZjl2VnZvcM/hoEY3GP1EPhb3sp14/APCu+AiBMuFxn6 wt+CJYPmqpJBmdbkrpIBrvl1kuP8Ov1pCPl1esnAGN0DkoHrY8Wvk5R+naGPE/w6XXO6IhnM /hj5F7siGQhFOgpIBmEud5IMCn+M8QgjlBPO2sxIcBPJ4Gi/zunUbdw0wbztK/qDomBVMtgT GKo6mhbEjLRPMij8OhNt7rmSQV+MDCpY+WSuSAa91alk4Ar2Swao9Fu4gGQwDvVRAkM9iW4t GTQFn+WcMEgG7XNKBr9Dyvb7I048TDDqTtiJYlMcE4zKV4JRORiMauNg1MoeKqULSmt6hyOk Cy8paet+E4l08cDBqGDe9hvBTtSDUXkejMqjYNSZxOmxVQlGtUAwahsjYZXBqBXYiW3JpEC5 yLhuaswJFjNvFUyYH20rI4s/IS3aI5kUAgnU2F7IirwgC1qoSCYad7nOolsPRp1ebRDuF7HS 19WWtKI72jZ/nGSyYgMY/h29uimZ7JjmQKJbB6OyggHyxi4HWfEKRn0BXSzPLwx0YRvBiD/v apqLI3KKBC0Mko1WjyZb6J7K3RGpjw10MZN4Q7aoaD16UOuRMtB1gS4wrSUda1mC//kCuii+ k784UuYL6OKKssVvofq4N1YGoa31q/v2YZR2Y+//cmNX8dBhoUSKo4USnAslIcy/oTPufV6+ IpTgSSiZPzumxWxUnmigHBJKQj9UwjAZlB+v8JhQtgqhpAHCW/3ROJ/BQSiB5pLh3luvLp+E krzvQiiZHDoQupg75uPkM5lWCTanaKaMqn/6p2eikztrLGrcX+NT1Fq79mpxVx/ewM1cAohL 09IOQ7XcfSeUE59QucjJPBnakzXE1fAUTIHFWySXsTPNQuqCDTvD5NsJe9qnI8PAyOaBTAVY a+SXJWqMdhLzKEesnzQWYDjkQPKogPRWdEtM6TSQ7ASR5QIss6qsSKBZY1X51SQr08zXKuFE qUmbviF5KRUudbN+l1mNBaLof2WaRWP5rDZkr3ESihuCi0kkb/TulpWuJjSycZqipEj2RrEA QBD1ZIwU+SRmOJaJZnkU+8p2yrioK3VhRWMAa0zPOs1EL/qcMjWaSZpcB1rWdrq+4cYnF37R sjTZq2UQdV6gajZA1LabNIu3BGGuBsxnrdSSR3tz/HjFUp1k9RvbPol2W+bJa4Sviavxh/nx 9k39Yd781+jtD/v+9o18cZVbX5vUlWT+DPY+wOqbr/D2h3r78TVUp2+fzd/m83cvDfMgzprq GPw54hpx/XvX4T/+nhpxdZnXudlazbB5Bxdk8+Xn57fPn96N+vC1v/35H9+1xL7nqgdy2NpB JvZOzP3Xb17yJ712lWi9kuftqNN/Pj798EI/pr2/MlQHG/ja1fOyrq+oQi3e6XDR6KsyeOCc ol7TSb5RMTBUmN0f7z9+qO7t5/sXt0791y9fvr77P759NsPIA5Xr9w0P5ykKJvlMfF0j/s+w wpWq3Mp+uHXMlX84kdpV1NrfPNx3u0rntsHN6F8+zvvt63uo2qwSuqOCycCU7/7a8uXLp6+e 0NIPlNRZwaJ27M1z87v57u4e43TVz89eAUwDnZrqtU61GIuIM9xF61vom3gi0Vq1njFhxqRi rua/P/14G4b+4aq6489Ptq3uYMKk6fxNVOvl8tq5OnXHfcO0Z+BvP95+ftOerMNVkKzzL0OS +KPiw7j77h8f6svgKOAV4+t35c7tF8/Afw/uBWWYAPGcXGWhjhGs1uMMwmW9umE7y0g30tfd KD/e1Pfvn77/mOhU5wmf7c1C2d7aXdnexG2yveVXYQRke7NiA9sJHZ3tTc+33vkz6rOqdUO2 tb3Z3pg7H9Co2s6yvSnu/phuvclsmtkF66PI9iYtnO1Nmle2twfI9nYWWBorwdLYFTZU6Vbz e4OlISfcawAsbSh/gaX9awdYmrCaayoMs0Ql+wrWJsEmrhPB0qZ1em6wtGEWFwJLC409JFja MLI1sLThjRdY2gssrVrwauzV2HpjsIB1f7C0B3Ep2o2YVtB7v0uR66NbQUzrUnlrQqIqXYpW EdOEbIiZUM52IqY1BrrHuLbcxavB7aPlzqmC03pPV9rRW4ZJR6tUS77rGatY6YLE8aZIXYoK zioKorqDS9H0S/1jP/1StysW8GvTkzWG1fR9zkaGZc2laCLaLVyK9mJsFYcEJNNcI3fO8QXQ yF4uRWlBzgBHNHaUAeZ+LkVP4RN0b5w2QlXLZvvYz/fRQkZYrJ6vqHPItmARH+sVlDZiqZzd gtqU02Y3l3WUNpEe0Ee4BQ39IxiljehT3IJqCtI5Kd9SdJJbEO57zg6wgvQmbkFQHJQ7spjV u7LnXBqlza1SzS2op/IwfnvJvDrFclX4ZG7MO+402s0cpezhvdmm7qYFzRkbcgsKdTPnG5uO TBRIawZ0iph5Ys3FBRtMm8KPATTwDwxZclvBSlPB9FplATrSzB/JlN6eqtkCYMINZ9bWI9NL r6ttZyu4Ma/nT1ek8MbBZG0BIlHLUU3K1OsKQ7Bt+XqvfHHTkeGmGMhcENanhXw/5saOLygb mweScrEEuHhrO614XZXTzJcI5rPE6yq8GvsYwcsLBZPXva7WNmveWHVWM72jsafOVtPYwWmm Xlfjk9WNna0qjc2vAl5XU0Hd2aqYZt3rqixI+u+6+g4ova429sgyzb1uQTvEnrxS+KCseAY5 RlxzDRrOYV/fGyje/lGf/3r7obrP5nvsGoQ1dY0IUR+EO1RXBtE36+5J/rDack/Cg2fIb++e dKqb0YleLxJ3SBb99RLJjf64O2zVcNP5n//9v3w/wf+EVRfwDPcl1nXK38lGnyl/9/j4+PnN +44QtDa7k52Xgn5jmN2/zfvb38ZJ/UNQCPVwGk3VWeUkr6fOUEnGYXryDJvV+/VM18AV5nxS hynlkSPHgbsOP8z3n2G6g/tT/drrWrSBFRwT/PvH2/d/Pv3o/wznh18YXV3R4x20EBfKn9fm b9fD+9t3z7eDv5PvDrEwv5d31329u3Dp3XUNZ5RcqYEA7y6l5YYzyhHeXdLbYfsmKCm6ioVj r3dXXCfx7kKMKWxmq8hcrpoOL+nkEu+uYVxsVl6k5fTl3QV5d+HbencVyS2vqe4rc1o+sDlR 7UNdhphntzlRrSRgUm2BUODj2e0p6EfdJbAVg61Lqo7gw2OZE4kWAaCg3DgYN3fR+uE1c6Ki qFzpgsTxpqgiFJR5HQK28aIM0EFhPROkU42xGkLzt+NTNyeGaW2bE6t5HQITJlfcGKFgah2y AGaTSIZ6tDlRmdMQCvYYoCbyRgVOnobyK1xEHUbcZVX1HaDaqfabvRENdUrnsGualbwOxVEM jcyTaE9eh0vSjBQMkDcWcBlp/8QIBU+Y3KHwDW+uII6XWR6Cb7hfWWGpu7Zh2bvTZ484foJv OJ5NihlHtrBwQXZL5d6o2Blp8ehPrROhg1uxxGklUnn4bTR1TlL53JZCRwM3N5NP0m6pnFRS OgxjjqXyfI6lVN4eK5Uf6xtOqSBMoVS4GBinbaLMiFf3Dc/XCfQNb9zHF6tsTf13QE2DRlZ1 muWUqnjGoknFnixEQeW8O3hkom8UXNc/npz9hNXkh7o2sgY1EheTOA/T+PiCp26MIWUExakb Ty+tKN6AG+sbpua18os350QaT1VNe9sciOWdIG5nC9FwxiORjFPutbyEM/eL4fLgHR14618j VlDODu6vkntcDcOxIKI5uD8aV6lxv4dqUWP+F8sa7mqHaXJ/+7bT/3ifjH0uGJhWeQDVwmt9 nJVorrWaXPdKiZiLG+zzlO5qzGOM4i6ahNt5vWkPjj7KiXYdbwQxfNUr7phZue5022bd6aOZ djyClCS0sBQWCzB3M185oKywbmQCOJOWxjRjTW+M6V1L0h3m27M6ZjWJUl1HNbJybJ10tGsb 15ab4tydb31HYysFEWvElFlV5tw7R8Y98Zy8sTzAsGR4TlP5ipR1ETyn0E9T4jkN5SfhOVUA rG+C5zSrvH4PPKdpldbwnGLKeS+MQ/KvzDkEATg7sXNIRu4m49dV55CibjGQ6htoXPWVMymf xLbHx9GNARhB00lfTvPKODthZJfC2QFpJnrXWLq8EM4OVLflBuKzrPs1nJ2kdSfbbH2DWlmb puabNDseZyd6NaGZNzrv+CrbHHMMHqqUbVrQ7lJ7tYpzgERL3OHEeCWflYKLb0y1KN89bTay vkhJGrlizD76vmMqEUvrRsltmiFismjM+/d7kJtyVjkXK5zTTNVohkWCNKVQpKOeSNTmNCu3 EyTsLQWzd6a31kdvYIIJBHbnByJk7IaXuIoGQnDBoe6O0v/dGs/pHF+nE32VEAV8lXq67qrk T67CdcjdWNC1oJQe38ep5XpQt37/8u3Nc9ab/fkeAGUTryVF1hxPju72aeCdeKd5YOyfpQ+Y CLj+VQ+Vp3V0eiFDParvUHMbZKj8Uo2u7Tvk87u3rGkPhZWCWqyHu3BppaB6z/25+G5nVgpM SdO6DzZkpQgIUD1rDgcAGWr0dXr5DuW+Q/yevkOv7CaTI8Mvk92kZYz02FQ2zlHZTUTbcCdW NtPGie57D5k5zX0jZXvzjO1nZTeZSRxvig0oguUKidu7Zzdxp1gtDlImAAv7s5vszfa+y3fo 1OwmWVh9aHB3tvfijLqSpXAZ2QNDEezM9r5DV1R9tVi8ggHyxp4/u8lTQBHk4Kzov/8WNwBn TfyFLOoa2ru7ob2SvxBK/IUCcECPqem7ikAxZ/qNsCT9ILnuTF8TKHAuiQ/PzB6Zv9DwWyyJ z+Pq6CmWLLxHEh/m0Si2fMBSSRxrotw1vZDEQ7ncLYnPc7HkMv5CzHazVWz2FzKsNTQ4su6w ZF3UX2haJ8hfiDR9TyKz8sxrKcnigpHqQGMT3ZfFE1JzoQ8NksJGyBlFd2ljy4LwuDGNCerW jnrffwFCUGus65lb7mJkDWqEwHj+ci2N0SQBy65vbV5lacz3i+NXm/hjuav1lZG5ScSTityi MOUNFcM0ayNDCcaJK6BNUnDEyLYbq7HGfILVPtylb/Oa9xe2XSc2jTzL8V7zbZ65SdPzRxbv kT3yCWnc2tmkQBjaFG/U8SlWXPfmE3AZWW8N7yCY0e2BlNN0jYk8oc7SL84Hgiutx9sZOoJ6 J6SJ5NUG8+10IpsCop+E6hthmz6yNmGjJe2zBWjBkZUUGb/QS13KiMnXO2msIaRr3TP+TueC 6U93FBjULo90b4jw+vRGqsA5C9o7j6Z04hi9QTTl7w7t7QMxGQDtPZS/oL3/9eDQ3tM6PTe0 9zCLC0F7h8ZAaO/pjemHcpoJiZbGKPARPnlkELR3UsGomvsCZiYmbyvbRTxwb1jHhHL5oMDT HF5+TmjvgRNZz4l8bmhv3SnUtHiHqmlFtGhZIxWX2lghO8bowS2Y7K1iXefuHFbOWjFsufJ+ LK6x9F4QqdiIbDrVKezuMlJ2ojnIvkV9r4ixqJdUJS7vGBtaBF9EYElcN9qq5fVD43mnj2dl RfRP7m51cwVs02m6n7NXk8uG36xjTRq8kpA9pBUaUB7ujFjIO9XEsT/3MIvDUsEf/LxPGxtr Gq2jtXI1jbvmZouHQ8E4Vnd9z6cZ10zqDtM5TF1Nt6BDWuHhob0V8yrFwdI/JD5+Dwq7wWnn bFPa0pc35ygIfHM3qnfUlkzBNwOb+K8YadzZfShNaa6PlTB8YlIf7qkP086RcuP7q6jercCC uut3RfPFD7EpbaQJl1F0W2rTlZziNAw/msvhTqY01wUNh1Zhg7aOYjc1pUWrBPtwS8kFkIK3 KIiqBCU5ZBZSJkGonj6zdXNYiZ0NDoQQ0iQF82NQaQ6DpjnuhX1DBVglpVnQ3Se2tX3I3NVp 4jVzWG91ag5zBVbXaJaLzf6OfdatfxlZZA4brVCkb9W2LTOa5vDHWuvx+9GFAppmSqI95rAr WgxP4oS95rBd35+imt/ZdUsYs89vCXuh9PySKD1OQEnFgyC2GMNNn4gHU99tBwTShzoey/PR kn4ElB5IPDCkMR3aZRh7FJSemcTpuVPztGlwGk7hTv0lFsfRhevoZgOpAQpJIplF7FjjFqzz BpWtb4DHO5l4vmDC/GgruoO+Abol0CRO87S5MkqPzlF6mqui9BjOEBBIVe03e+MuKD36hdJT lS/O8LS5PcjONUWFElsnFxWE6owHRv1ivvQhwAh7LFSyLh2wvcqDMRjNKlGB2UGngF+WAeC+ j65XgHTg+wYd2IdnUDjkAeCWdZAfLoowx092m4HmWDqwm1Q6iPo/HEC3mdkWlUkHQ6zmLxkA 7lcJVh74wE2xGrHaSt5Hn/wx1hBsDEkGOMbG31EwyrcSMmzz4FbXzSmXumb+fs8LN/45Ffib K5ISL/r1Maa1NjLOl35DQQ+4kOYxrbXGvMyTqsanz8daTOv6x2mJKUVdHJiLmep1l4aSMgPl LZhiSjOakYhmS3f1kUXBrahNBmI1SoNrRdts8tlAEV91p9wSEQKDqnjsPnOySQeCzGpwLTs2 i1c2EKnz/lm5AGEgjSm2U2FSLW2slZHhdZoxaXhfdledZpnZbz4Kqt1BjTF3Urc0PoIGqT8q MJJEI5u6A48g0SrIiTp6I4SZFt3tWE3gGgB3t0azaHl7io6TQidvGS0JaQUvYARWjt6ssX2i 5YbAk78ePiVRmOmn9+/vb9YMOPUh1LSpVQ3fmDI0uum3YqrDF2cIAX7/8UN1bz/fv6hvb2PG BPfHt89miM8OMbKkrzUUFtLLpe9/q8+fhujTKHKZ+ojMaqKQEwKmb9rbM6WgOHp2J0Vknzyv 3zFnxSuU+1FDuXPc2SuFcud3YwSEcktrNhwX2f5Q7vn7tfMm7MR11rQNCIUWwqwV6w+Znnyo g4tQ7lZRi6UA00AMbfFZT56WN/3hWD35OJdfOpSb3jUNxL2RAx/GwIQRuUEoN1kJ5SZlKHfA XzrFwITERdJAeOuHEZYfHsvAVM0qDyZ/vXoo97RKtVBukodyE9mWJI43RTUNBGEaxaHcqBLK PZGjvAzmv9R9V2ZosQrXTY31/RzWUzJhPPbcwIRqodweW+BiBqbW9uXI9tgoSqMcmFUe51nl 8f5Q7n2+Kxs6vGFkDxzK7aNnbhzK3RQMABqYSPvMBiZ/Frjag7/MaGF6UwFXzF/pMVq90j+F /wsrQ4/QFST4ScFYDz1iVDRsbyQ4PpwYCT5uGuL1No1qC3lkHE8RehQ9uzGZMm5PQo+QbFtp WBF6NJanJq1ovLE8Mh0AHpfdq6gmeWQ+GDwYFaoI8kQmmMbQHGd5JAR6MNyj/hRBHl9AHgGh Ze4ZejSt039DXwpmtLQ4W9M08oUIZEltdYvzmMusMZU21sqWjiSxPh6CE8cQK4f71FhjqIG+ 3U3WnW2hadKeRwE+lFBhewNg6K40VvSbTyKt64S5ortaY1Ho0VA3DYrqOOZmo7FkIOBQ69O0 AqSZ69cJpGldU8Yild4ixTRr9q/SRBkZaAjtLN8TvD3OG8ciChjpJIt4ualuLXh7eYNvyUrC GqNNL7nuC2xsgFeyturo2ThrnaetA4JXbZo4ly8TwctIq5g50xtqM9KpbIzqIcysCHnajnQC R+aRgAuWJIfBMDn/mwUrspruKqSJR2Z5Cl+g579SOs47rukuNmPEzzQEgGZDTWQPSU2TEREv VJ0qABDJoWYWLzdM5xDVNL2d3ggVBqPqqv7n/lB+twg9GqHD+jEZ1qkofnFbAg49EqIVFFT9 KL6C4tcX6SMGfLgi9GhE8Vv8gZPQI2609SjZu1H83OUFRPELj5RIyUTUiuZyJ9VPNfTIz4V2 9C4ofuuhR1FBrr7BDai+KfVIBaze9N2rq2/qKH7TEwoI0iopmB5MACS+lZHFTJW49CZDPTr0 aC8SX3WabF19Y3P1jb136NE4VFh9syE0XCH0yJPo1qFHYPBdwgmXQ+K7Q+jR76C5EVcVLEro vnsKFtrUBAtztGChK4JFS9QCH5P2sSJYGFCw0JBg4cu9r1HVptQbWhEsMCRYyKpg0QpiOw0K FuZugoU3O6hgdngUwULvEixmrkkO/PhDN9AJWQKpNupyRMGTC3F3+QS6WyBLChJG2iVY6Eyw 0DKC+PW7wv2/95tItyLfK1jIYmRQQXWafFWwgCF+X4JFSqJbCxai4LOcE7xgYSx7SsFi2OSD ZPDpw3gHqy7kT7mfVHAW8Nx9cYATLv+dgOeQbJQEgOeG8hfw3L/2eqPghtlF7XND68+wTs8N PDfM4kLAc6GxVeC5oTvRltNMSLQ0diHguaGx6wHPjWOf/jL1AozsyYHnBCZ9NrLnAJ47/H+9 d/vhnz8/fTbuu++/+P77N3z6vpgvXz/+83+sfibvDR/WMt2yIjyla1kWnQJ/N9Fx+GHStseG AGMefzGTtqK7dtoHbZO79vz+gvlVhgArnHwxpzqsn+/a2XCb+IuZ1JHjPXjlrj0VjBlfm/yL uTztjJyf9PEKAc5WCbxr781RG5+wIYy3bGz4XfNsqWWb8d5qkvuZ7HCO2jLfahzGu9aYKrFE 2mxkfRoqGDJoZtOM4nnLnTZeucYctV2akbUBRzaTN2lszlE700xlY8dQpuX9OWp30GwemX9/ +aeJB4IJZnkYrwAjnYEw2hxqcukueZKRRQPBifNto0yjyzjqemPwWo2NdRTzA0urFtj39bzZ SaprOOB0txZgD+T7jmkOgc2rqQWmgqhKiFE9Rj+R100UVD7oDhzZzlDY80fmqM+dYMAxoH4C D0dpJ8+x1bobjcXPWat5fN25YEpDeZSSZ6/kk9e7dcrisPtdRfv55/c/Q/ivetdv3U/3qfLh g1SvRSuG3e5VUl/02ydX9efb0IyP5DNflNf+UL4Wvnx0zOrJ4adtY7EJ6iyf5HoI5P353Xy8 ffZBg8SsjfKMMOB7ZFoON7mBqP82729/GyfEDtZD6nWETTWm8qSAYEoMwj70VOlP/35z627e /lDvf3jt318/AwdgV7+6oJeI7T0vSJcZhjy5jOP7z+Zv89mxctDMDgpPbGyI3a+uMOEUzxvI Z3z/z5v5+slv9tWJd4ZhOkT6frg5f/0wc8wu8XnUqzZe1XPSjxRzS+wq/wwx1EOI8OVyk+PW YH+C9d/7P92KuOvnEGHvT7CmGmPfk1ZMcbnx6JSnIq5uz1ek9KNGSqPbRErnugQEJb1u+i1N OznsjZQ2jr9b1QEKA9opxY4M+HR1WFuo2FtFhW1oJcBidoAtI6VfSa+PTHpt7hkpja+qZSuT Hz1spLTl/AZQvHwFipeDULzEwkmvLZeq7tXS8aO8WrpK0muJOWuc4H8oNW13jZTuEcOQpg2E 4r1FpDRZg+LlORQvj6B4ZxLHm2J3pDRGV42UJnY7UppgW4mU9kwYjz2PlCY1KN7WJuh3yVCP jpRWBoTS2yxo0sZCg5CrbZe72navpNeHQ0aiW0dK44IB8sZ8pDRB6hUp/dD+tq9MAc+UKSB5 X9fFE4ypPUY8gZ1u/bezRUoiyBD4kEAuWmCu0R3Ek9MzBcwkPk08uS6QC94hnmBl5+xtJROu iSfVTAGeIS8onpyWKSD71NbEE9hh9yWepCS6tXjyW2QK+A3Ek3tnJ3gg8cTcQDwxK+KJAcUT VBFPsNchlOKJ+961RrlPVl8RT/Jg48HFgcOJjCQWRMnwUX8o8YRq3Su000/pJjhza+KJycUT k4gnI4lPEk9Qvy6eZNbzY8UTtEc8MQucQ/oqs2WgcsraVZy5BF7mPPGkPQJ2P35o2lhNPEEi 156Il3iSaU/EzcUTWjAAKJ4Q8xJPHlo8uT8M7o2ilf0XHdeilXci4MZHKxSt7G7CshOYAJKJ 62MlWpmU0coDtmoFBoVBMCjjY0UtiRKgOFHubK3CoHhfLZpIJtFc7iSZEExNC0omEALuMTFH ZyDgngyDgmDbDCjmoCNhUEqc2fwYHpUfHU8KEkbKT6aVkaVMtUe6AGlWZmCGUWwXIhIuWT3i KPnKRtLFWOCkqyTSSgUU20pjYPzYZsGukT1itPJCIo2yuleOVm4KPss54XIoti8YlCsB2F5T sChxa+8Jg2JVTbDgR8Og2IpgoXirYWh9viJYcBAGxcaCRWX7lIIF7XlFsDgCWj88nbuZwjAo /H6CBQRlGx6Mm9tD60+rtBMGxQqbnqKikX0SXJLBoBQcN1XcFiymKlsHfoMqMCiekbYFi3lk sWBh0MUECy33OX2sfHFBwWK4k/dWp2oLV7AuWEyvOqkwAsfzdbUlreh+IcFiIdGtYVDKhIo5 JwR8NYyfUrB4QBiUF+rq9VBXnVTQIdZYUCq4KOpqxRBCENOY1gK2AdRVn9+kpm6ghvUclgru iLqqe9xDfhrC2jgP7Y1yNh+JutqxOOY32KGIRfHJ18LBx3UhoODJhbj7EqZiWlE3YJZ4kOxH XR0mcTGp4EzU1ZW6LWIMNyweqra2Fxf9wgGNEW6loFF24anfemPDGwxorPWBe2ot4XanKJKa mr00i7UqA4loibN/VangF0ddDcfAenAWRWvBWY8NloZLsLTmCiFcZaDK7w2Wht2hIgCwtKH8 BZb2r92p+zrBHMFONlycCJY2rdNzg6UNs7gQWFpobBUsbfqhnGZCoqWxC4GlDY1dDyzNUscK S6YWeJrDy88NlsbJKAc9FVga/OG7N/zZbS7T84VOQZdpywnff5kmI3YLdJnWsnGyZwdcpl0f K16FxKSX6amP8jKN3buicd8t4DLdtbKnbWebymWaHwAVu1xwG7LLNOuU7gxwmQ5zudtlWsiQ X6j4BEIq9utepqNVOuUyTXTfBE/I5B7qB1Ju/041xmpWuaHGT3yZlnaHih2TWgbafjOFSbwX 8klc6DLdWlOO7EJ3uYKq7trJ2htcpgVq2karot/VC7F74/aX6YFEt75M56xxCie8LtO/Unzk 7Tz8CINV7rtDI6M6uCYl2J5gUEpQbCU0soM8/LA9wRCPsanFHuQefkPfLRR74B+KtKCQh1+Y y72kBI+RChri93v4XVDlPq3SaSp3963AqI2lBGUtOk3lXkQz7s1HojFsiA+MtCElxP3mk7iQ lLA3vPFEKcGKTErg6EZSAut00e/ql969cRcpwZHo1lJCyWc5J1wuvPElJbzCFH/DMEVte41G i/q5YYpaktZ2TSIqPECYYk2nfjeQpzPCFCcSp2fQhcIUpy/0MXLHvEt2hiliOoNwZ6+2pb9f ytq/e5jivrRnGzftYWSvMMX4eYUp/hrRBPcOU+SSao8W/O3nAHMdRMAE8vd0oaRNuY4kQgmx 3LXi7sNqFkqy96eNG4QSqK0lx8vcVpbjZemjEEr8b9PegiIUKd6lvyg+LrshW/3RuMzRCyVj /6S3opNTncjQb8c8JJNQUhvXLJQE4afFbAjW+JVyvESrBJj5Z0Kl706fsXjpo61gMGv66pGM i6Ur13ghuoh9KA8Am9TqYsJFy9xfD2Ea5eoun/741eQRwxu4KVqf2SGXvfxG6ZRqsg+Nx+hN idjY7D6dYOjDCzC6cAsr5Tx2pt1F0ls4c0KA4lJFyZ6MjEWeGLbI2DP9gjVrWZssHu0k5suX PmRfwiL+fA+Uhlhj2KuJRBkGktIs05MZaJrLTo1o1liVc3HXoZVpFmsV8beWmhS8QooqlcZ8 /qqpYKwrqhsOmGbWb1OfVbq8w9gVNyQX5IpJjK/2yuhy96a8IoCIoWKaw6uF/LQUTKJkHaOD TQVFHqLxocVQ60l2Ck0W3iTiXpoJi3lOIlRQpqTZ1FpJxGKo09/qe7N8dUiEluXqQrrM1XWU RLst8+Q1wqfBZxLx3mdv/6jPf739UN1n8/2NDrknvoecKz6FgailWBgOwJCm49vbN/Ll7Q/1 9uPr2x/2PW4ED2k7qtkdwib2Y1d/eI3bH39Pjbi6Id1GNYNC2EJRhprPn96N+vC1v/35H9+1 9HkvSFVxF/ZVkIy97s9nYwlZG3yiGVqv5BlrqhS69Zk2/Dy1l8NJleJhmaPRfnr//v5mzY/+ zymnTjXti3RMyIucOhYj/mA5fG6XRefknDQnpZa5RG6YE9fivJQyqhdcAylaMNerwWZOpAip aPqvbkX+/ePt+z+fBkbF3GvTdZW8x6dPcUJT42kbkrv8HK7Rog0ZTKpreFrGladNnHLSFf7M bCvNbbKt5Pd5dFq2lfTuvp5tRTdEMCDbirscCHm0PaFFULYVRpns4GwrjZnbemVbGZ6Ts60M DqX3yrZyf9yMBzHE7QbPgJhnpyHO9SFXwDNkYYgbYBkWQ1yFQcqNQ0TNEHcEeIa3ErUWG5p6 9t7fEFcHz9iv87qgIW5aJdgQNzBWsdIFieNNARjiqsAbM1h6FJNf2LBOMcQVWB0Z102NUTED hpZMmEsA2WRqhrh9/j67DHE14I3wRoTotcvctRfRa4eFKoVjWwPeeFpD3EKiPYhelzTEsYIB SkPcpYA37mSIe6FvbMsWvxL6hpZtzwcY8Lugbxjir3419A2aiBWjAVytgH1qptMkbg+BvkFD xFAhVuDWdj1NY2Zvgcl1DPpG4aPTbIB9TpMrPvzJ9zZ+YtHA7AH7xNokBfMjmj2uwAD6xoUx uc50Bb4wJldCoV0+OisLcLxosKX7/zUwuX5x9I3fwT1HXFWwmEKqn0JpYW6gtDArSgsDKi20 ALyHfbkXWyvSBW5GWPTd3sO0A6QLLylRJ0OoWduXfxruJ108GLaXXlNamFxpYRKlxUji9Niq eA9nocyiZd7TJz59U0itCbjqRKWF3qO08KCwE8+nL+KVHGxT6+AnZCcu2E6lhSxHdqGopSou 2HU+uyE2iUOeBftxwZaxj7FJO0ZWDVJaUVrM3ezGBbskzUTBAJDSwlj2vEqLJ4hUOgscjJfg YPgKFsdS9/F7g4MhJ2prABxsKH+Bg/1rLzgYVogzfnNwsGmdnhscbJjFhcDBQmMgOFjMLBrn jr7RL21W0CwF7o7Y9LNd6pSRQeBg6RtNJiYNrzJjpJTpyFC/OG96kC6u2kUHMFUFRvak4GDR 84TgYIFmQ+n05wkFr8Zeja03BgtY9wehexDVz24kuuy34wLHSbeCRNel8taE8FWqftaQ6Brl Tmiqe1FR/bBE9UPWkOhcW9IIThV5NNXPA8VoRatUCxz3jFWsdEHi/Eq4R/XTYxr07Ms9Nwsi 8uggHmbtFNXPDC+Xc3baGNas4q/iP4vR2CPVz0S0mr+K3WeU2qX62YtddormYSJvrCThIJrc hVQ/Ptcl7srGqv1mb9xe9TOQ6NaqH1QwwBGNvVQ/1zEzAUjv5C5I7xpTQbeUOWRU5uDjlDkD iFukzFn80EDhYj4BF6+Vwd1ANrj0Ip9GFytz4vKKMqeVuV1pKte2FgA+B20DXuS1FLUVZc4y rjkAfJhjazToRW4Jhb3ITd8nwgUwrnOVOSuZ5ACvldsoc8I65eJFvLQRc/eN0P1cME1q1gd0 rWQdyS/ZyRoeVRCWaqWxZGQYclPM90llmrZ6ys+EUG3WWBHMGTdW7M+s8TL0vbYAKluA1tjs jUSJhTrTt7bWmCknUd5f6iNbWyuAZqneyX0tqanSrIyrPvUjPuzvpV9mtLR4Y2RE4trImpRm IcH12shqTEto16HMk0d1ZpM1cNaYcIMRsuPYkGSakEasCJbedByaWieoQBbQdnzDGO3YsiG2 r4xMl7MC4Hfy1vPGxm4oSycBaMTGaS7968o0E4clI61iZk2unZ6VHdCyRioutfE9M0YPkmLZ u4a7DmNs5eJsRfWghYwaw0lb+EBk06lO4UZ3UnaiOci+Re4+Stw3o5dU9XH/mGDSVEdGDgOA xvxvdvC9qQkFhjRuZJYnoDCrypwXVvAFsYLdxdx97zWcUeBMrODkfa0APc44YI+csA8reMNB mAjubo+JHieay530OJhq3QcFxh4XnlsAAG5iBWersI7nseUgbLOn5MmFuLuwgolAEhxZYKRo ZPuxgj1T7dHFgDS7OFYwi76mAIifzUH87H4HYXAgx3xmImHlYR2EPYlu7SD8i2MFP4WH773x gbUy1JM4IMLYd4/H8iWguRDkqds258sGy+vUSQColA0WjDhINpi/dbrSVqGGcT8VskEKPJYE 88d1CnBgoo7OI4DGce1Rw9gUjSjG4Rv6b5oZHBhs6w44fD7bEEGlbACCA1/XxhOtUs2jhnay 5Jrpn7p1kyRcHEZHhmC/6hse+RNMv8xUL5ZhswD8nLulJYDuvViwdDKK1hpr1hrzb9DUi1mz lpQRIuOr7fpAAjBW0X+tMbVjVsUFF2hsRDVMJ9GhWSaqLpHIGltDJhxbtxwxabyDy1ZjMwFs U2nshNVkiedWxrQWRDc0ku1ozJZIebolAM2qgkYKh9Z1TMfWpwSQsMFT/8XIMKdSadQAA4lm 5XOszDLR2B1kMh0fXGmsXN4F3RDWgnkqVWk2UHVG6ouA0aoja8oV2STESmPFyKpvTC9tSMcL xhpf9EUp/N081Op5FmEXFmw1CczzyOj4Z8VzC0XYhdNTHBLFiddEH41toXS36FNU9EdnkBH/ MD+Gqk7weXNfDiefesymgC1XhfkKh5ZH8zM/RlAy900LzbiRuOrKB7eTejS83+pbOH6crcL4 hW27gGuNoHhtwCerQmqdgf3n+arA7mvIBnZfj2gEwfbPx6cB2Y6u4oYJ1RlPHlepD/3gQIra 663UskTrazq5hdaHJMPtwATvP36o7u3n+xe3IiM2nvvj22cT2sKBNvVARNGqADT26f1v9fnT AJAWIetRjzZWA3U8HsPvxr1hzkXB6p+Jp4vxSHqkym0nYwYGTcgwyH+b97e/jbsgDBGh1G/r psoKJ4ENHk2SzlBJxnmF4yNgevor8XTNXIHAfFpgQ056ANhwgAD8rXANCRaI+7GZd4/gOkAL /vPpXX/9x9cNhKRdrcteaLmGiUjlKiai5YFXS0hDgtTDYRrSEtPwGk4puYoEAZiGtBfrTiko OKXswzQcRZXZG2Uq6RRtxlAVQA2ik3QE6W84YKXEahDfljKkwDRsgxv/4qkRq0FC/7KdTSRL eaOtZi9MwxzTcFFB3QvT8N7ZO25pVsS4hjtEjsMdChDhsFmxc2KqPZRmRez9FipmRfdbiTsU +qjhDrGualbEneaVPQOaFds67hAzXQelIA1zOdzHrEiI4n0D7hnVWcFvjDs0rdJRZsWocuth Hi5lVkTipBSkPWxWDIyUf8Dhe7vIzYotQpcyK7a2z0dWDNU/1WmKVbOik8FsVnBv3KFhIIY1 BHDKuoNZ0ZHo1mbFUtuXc8KQG6x9mRWvZla8P9rx7RAJrapJBjuBjuO2KpJBz4gVoGTAVyQD DiISWnFCcnKk8sAxPy7bGXfYlJKBT/BYdThSsiUwIiG/n2SAjTIQIqEWmEc659shEtpzEAnh rKErkkFRUIgK8/IVcMI5Cw0FFvO0IGakbclg3gspU11MMqiBFecF1WnSdYcjMGvoTskAHMjZ ksE41MdxONqXNfSSkkFpocw54XJgxS9Ewhci4W+PSFjZQ4CuTpqK3uGoNApOUqK6pal0cf+w 9CoM0BGIhJeVLk5HJJxJnB5be/OZo+vlM9+LSMiwmnmrYML8aEtZ+zZpFGBEwoWIt02jUAzk +AJoZK80CvHzOyAS/pLiyVkghnnaNHSbtGkvEMMXiOG50ouwEuEex+fPC8RwWfalsWcHMRx6 YkYL/QIxjEf2AjF8gRi+GnuUxmAB694ghrrDtIdcvBnqLx7dNhLomOi2JdJoMUQt0SmZIWp8 fEDT0dFtQ50CwZCgS0a3zamxliJvZJ+DeZbotql/Ks+KbgPq/IoIhm6VclVRzCTRAnSQ6qJ8 o/zQ9NZ/BY3YcXOeAuJ0Y3oFhsrVGys2RfKzGxykxBr5BG5sfiMPDCuj2+ZXcflqSlUPA5n3 X2tsz6yKjQIo/qrRbZsBiFBjeTAbaXpkeUYzn/dhKhjbyqPbFgLkdfOBANME+MxWIpZWI7Ww wRzneqeo5+K8WWtd6BRHxmZPtS4mHAknbfntZGf8LnAB4lfDM5M3373lvPMF8IvXKZXT2yfU TleE5RclEEnJgsGD1sn409iZZsTX3eazEhA0ndU8MlyGrJUjw1oJd6XB6WmFObCay18HSu9Q /M0DSblYomIym9tpCR7MuyMr0yzWKt7oPrIqfSMNLxyqHKVn3C36FBXPjW67Y3DccFL46iGq 5h/1+a+3Hz7O4nscHNco7KOcamFOw37YirDDQ2BQNc7njGg5bgiOQnQ+f3o36sPX/vbnf3zX 0g+frIQJKaOLaLteb0XbiR6ItnNMtBluR5NwO3qVcLsT45Yk7pAs+uslkhv9Nco0noj288/v f4aoPvWu37qfbl/7kCeq16KJmo5iP0v1Rb99clV/vg3N+KAb80V5fTYNevOLRZUdXYF1nUIh tirEK8YxgAStUbRtLDaBuzxnDdvz53fz8fb58xTAVJ3WGeGA3MqezMdKqOzPFR8OqL0xwX22 6qxzYiThSQGBTxykJ7gGgvQw179dlJ6PtOv5WqQd4auRdoxgtY4AHUx91eO48ymowVC9QKHH itRDZaTeNcxouboHAZF6ysdHHqPTWYvUC8jsrAkqki5R3VDL9RCRU3r/UJ3bz6In1IlVOq2i HTMk9FHgRi+xyolKR1nd9v0Qkfe9KG9ekXp5pJ6/LNG7RurhqypCS2D1e0bqWVoDAOVHA4AS CAC041TjUXVYAIDyFQBQDgKAkioAqIQAQG3jrjLE8K6p7JlKDl9R2TOt7bq2m/ZMPpdpz0TX k98wh++0Sjv98ZNkLCH4KLgYLwVDCltQOxKeUitU8ORC3L0AoLDXGxYy0QXUI/VIBgC6Nw8v SLMSAPRMf/yVutU8vKc0dsTIiMCqU4wU/dYbm/Lwlo1NWVnqdavJWCrTjN0k9ufhvSTNctj2 khN8pB5B6jn98Z8uD8v9YcIfxLl+N1Z4weHH5HxT7QpWeFs419OAQn2Cc73QFaxwqhJRYcO5 vmNW9H0HYYUThvi9nOv9kaGg0D0hjDsy56RYN8UKr+d884xVrHRB4vQMsmunbtRYixEACFB8 oVeMT8ksIDFj43uAyZKVoGTC/GgruoO/BxEg9EiihtuS/fIzcLOxiIhbBbikGRD211udhv25 gpdz/bQAM4n2hP1dUu4gBQPkjV0OZ/xezvWP6R3/YGDjDyRfmBvIF2ZFvjCgfIGAnLJDCBju AfnCq0KaHgtWy0Uye2TNbXlVBF8AiBL5glNNhHi04D0w7ZuwKvh53yUXCVqTL0wuX5hYvphI XJcvkn6y1GqiUTYOkSPIEttmVSBogES+SASOmVPGulvnPqEw4JAbS7cqX6CafLEXcGiXfNFa XYxsT4GAvuJ7AYd2fHgbt4GXyMuV3HbPLl/sBRy6pHxBCwYA5Qtinle+GHb6IF98+jDeENi1 q2bZF+LQEyMOue+E9TYOQKw4G3EoeV9CWISuf9F1tBlSouywcGwgDqGOE8UBtcVdEYfckERw ly6yydq+XejyQIhD+dFV0UVEFxL4E5lo+rdFg72IQ01v04LpYenHez/i0NpQj7ZwnI041KyK BigXDdCDYBHqHjEg62q1sSsiDt0ei/AXRxx6Cq0Dv6pkMJ1xT6B1wEjdADJIrUAGKRAyyIia 1kHXoYqd6KAq4sERGVCDqCOkwqkDxP21DlXIIDDL2S3EA7MGGaRyyCAl25LE6bmzbdUYLq7N VSGDzB7IIKrYPLKCCfOjLWXtqtZhX/bUXVoHLU+zamRfp6poAWZPXbmOHz2Qp9c67MyeeklZ gxcMUGodvDM4fV6tw3PIF/eHJLyd5kGbmuZhJxph3BaseWiQVK0GRQuzonkwoOZBn4J1THra V0SLI9AI/SMJNgzGOjb30zz4EPPcoDE8hllNUtHi6r6V0yrt1Tw42qG8YP7mEt03GiPoYK1L AwVPLsTd51vJO1jzEBgpP5lAzYPOsY7tPkTBnZoHGFEwLzjlY9SpxgrN4gLK0Y18K7npi37X hurfuL1v5UCiW/tWlnlic064HKLgPbCOHxrYL88dhm6TO+wF7PcC9ruEjgHh3lKVpUOCBQFY x/AC9rs+sF/anWjLaSYkWhqj5QX59JFBwH5JBaNI0dhwAcfMxORtZbt8vecr+g41z7MC+w2c yHqBSV/b+skCvID9Xo39do3BAta9gf0exqZjOeHX9yQlXd2T1IOVQdh+pU0Hc2JEg2ghb4Wg VuquwaqpBbVySPHS6HaRkSKbTk8Ya4x4OJsOZ5J1CJK3vO/BGfLW8TadaJVqnqRkiqmIV7og cXqjW7XpFAVR3cGmEylAgsvtKTadMK1tmw7WIZ0UMLJ2UicVNp2JaLdIA9GuIZvdOQ3EPneR XSMrbDp901BVLl4h3F3RprOQ6NZpIFDBAEc09rLpXM6m88LLuCBehvtWWNTwWZWT9nEeXkZl E5Q2HVbLbH1MEKx/eibF6IH6OHgZ1SDYI2CDIdFi/OuV8TKiLFHBhOMObeCAAxBY69JAwZML cXfadCzs8hEYKT+ZQAkqx8vIsEqr4sEum8418TJmfKflN2oFgRZgu7EjRjbjXaUvUg1rdvwz wVdVRtas2XRGwK7Sr3mH9nGGujphmtVXjxF6Kpzw1HgZZyaI+v3QMm4nIxBWkxF2AmVEdXBN RugEg3Jcuz5WZAQFygi4iqmlIUytcXtJ2VXUD6BLaVuNOMGaEgT5fYS53ElGIFpI7WHccxkB dCm9ut/HtEqnYGplYBcjHBVBx2kMCp5ciLtPRiBdlxQkjLRLRsAFphZBF5QR9rmFnvKJ6lSj beb30bS38PtwXwljdNHv2lD9G3fx+3AkurXfR8lnOSdcDuziham1LSU0V5USytSO95QSnIRW 8Q4lx3mH+nh9yDu09+kWuIC9Q8mKdygpvUNDHydoElAjZUVKONI7FAlMhAGkhDCXO0kJK04h uCm8Q28Cd7HlHZpfISIdOYKDR1akhKKgEBumNyYm3Tq9u56nBTEj7ZISUO4dai6oSWhtX4wM KqhOE8OGhlVIrB2fz+pAjvl8LiPbGzyyMs3hj7XW4/d3x6XuhcS6pJSQp5MqOWGArGifU0r4 JVNNPxjghVsfoYcEMyYkxfj6z7sjtk9T8mGs+TDv/WAOihMVnC5mtCkPklzMCOH7zeA/0Jfv zzkAdaWtQcwQ6VEfixlRJqxCzIizZEHwFxQfj9qJ0G5QfJtme1ryHNIosRsAih+SeMGg+EvO RAa29SvlOYxWCRYzuORcZyuqgCR+lfWIPuYDl0557+bGljRgCx/n3QGSAZTvL6xpvpjFCoLT 1KzHs1Yk9sC0Sbq5+Q3Ceq3cX/PGos0wfB2BdHPjv0Vtb0HT3J53QjMWf+WS92iDirWKhScn cUpWWG42xAzQyBMRMX7gxGzYSYqKLSPzUh4WsSAwkDwqIL0VRdZK72lFpQqJsqsjCznkeNsm /XeMlQuw1IVXZKBZkZAuEBYUtCN6T2uVppsbE9JlNCxllnmdi1ePEYCKka01Fl5aEc2iSahe cZK/mvsCo5IQKwswNZKPjI5/FilPWTHNaecVaQ0BIiYj67r6DigaK+a9Oc2RZqKPTqtheQXA K3l3+1cTp/sr40TdanGcfHuSGFQ04j8wUWKyqULdB+fsNIfuqF9Jc4g7u5bncDght1IUcraa oTCcdkuOqznjn/DVcDWdWjiklmofRunpMlGl7xnJEP0mLpIZNmQrmSGiQDLDnq4m/To5OSGS DLcDM7z/+KG6t5/vX9zCjLn13B/fPpuBtmGy9YvPfRLknZwL8JVZ75VZ75VZ74qZ9dhtMuvl ygYEZNaTnhWP0SKsZdabpZRDnllvFGdAW0Uz+d9AARWREmEctb/NiGYOqFjKmVsZ08dKhOm3 TjGf229WIqTlTX9NJULe1vNk1msAJIuk/2tm1nuhyz0TulyFQcqNQ5qaK9ARRr7BrYnwIb3m A0UigZj2/ulbd7VHuEk3zkOjy80kjjcFjGk/ALKlygDhIYcS5U+CaV9iuE0V7fjUDYR70eWw 1jNvFUyYSwArIxt/GdGQLxaJdCq6HE0bCw1C6HIiR5cTezHt0W+Cae9I9EKXq1gJf2VM+3sj y2l367QrSqbGJkqmCrwMOVq8wBW5PAGWmZGzmvmutVe8CJq/QrwYldqgeDEpvCGEuQYf70OE anJ5A8jlPtwyMsgReC6xD1EYF8PNHrk8p+UlxAvvaUxRKV649rXUbLr73BJhzq0SACuDdTjB Yq087STmy8E8W2Fy2oLixUDBgm2K9crWA3L7mWytyX7s0EporF0zO+p9NpZsmoDRZbQtlVbG phjIDqNLjSJodeyqV0aXjeUa/XGo1cZGl2vPqUVjR9hYVgSfKonmgmRkXSm81Btbt7GUNPNK 6QprZDYWDdlY8Aqf1V+t2Vh2yyp9Tm9jNmmWM+3wuWeoTbNjBn376oYLivUdUlSF4fOhSllK 68Mv7ZoT+lwwVRn+CUS9Tca9JuJiNwmJl/OsVZyrFrG0f86BBQi/9IDEG4vgiMq8sTWfyKUu aVl7QgwjX8q7ODAQE7eYye1ICWbaYnmPkk2PFIDK6l2wGNSsbKpdM7KdZ7UyurBa9foXtVq1 KqjUP73/rT5/GkwBkQ2Jer26qFXmjjPUcAn4n//9vzyZOn/nYFWzZdtY3Idhe7oOS/rzu/l4 +/x5sj401c7uYOelcs3Oq+UqC55sYTuarCeZ5E63HF7Alkcopdh3/u3nF/X9r7cP9em7ia6F Cq9ZvM4z6d3QNIetDDQO1q7v7iD6bL7/+fXH6MobDqNVT17XodZT/b8+9X8FtnM12suN8URb IEOSeCb9MN8+vv7xob4Mk/KKgHW9w9MaEc+0B4rSHoivYA/MNRMIsAcq1m3YA7E4HGkPLPQO BkvaCHyUWcPJVpwgncUuOUEWUdWM4LSJPRATKRxHQfZA5aRWpge73/e8vLcveyBkD8TmpvbA s4CiSQkUfQ0Dewkm8LsDRTv5FASK9uUvoOh/7Y4J5Mwnb9ihz4PNhScDRQ/r9OxA0X4WFwOK do2tAkVPP5TTTEi0NHYxoGjf2PWAom1jTZ8oH4FpDi8/N1A0J1LXtn6yAI8GFD2VcsGccETP i/FsWSMVl9pYITvG6MEtmOytkwc7HC4rc12MOz1omHDSVmSxJY43VadwozspO9EcZN+ivlfE WNRLqvp4IK51WvjvRx72nDdE0vltfdAeBqZf3j0gK6J/InVYKmCbThMhHr3K+YFplDwHReKa yCbT9GPZVFyq4Q+TKNJ8TRXplhViytEkbQwP4GjG/bKs1VAzWzweFIi4GZBS9DCLfGS+po5H NkxsmObwj77T0diXCg8OFE2oar2Te/BTf/v5/vlruAATFmsnVsStPeALs2+QSsEXhnJ3jsta VGQJvjDVScAXVqIi1wync/9ZVORU7lbwgheYGaJpKQqG09lpM42KXAy6xQWGdrJygbl6VGQN oglRY40lewStSxlOo1WCoyKDbvEwfrvIvDrFclX45BCFCzJpPMBgyh5zmKQrmBY0Z2ww8srX zQfi17QY2fQXu2XQWg19wwZzXHwXQLDEgSHXWo9sUPGzPTJMuKLY/fVQj9cc36g2NpIXitfM 5g3Fa8YtLdGY84rYTIrGZm0BorqOahNQhpsE04wkdfOhrkCBVV8tBrLIEKODAChmpZ4Cc+vR HAPJV4SZqWQwVDfAyGoF1e20Eo1Zn+b45H4IsadAspqpbRla3grGREbvqd/NkVVcB8BozMxT gJP8GIFZw9uqcTZNusIr1ZFNYlgh57J8IKUJf7+1v6B3Nva1eE1gAWKaCYNU2hg7Mipyl9iT VzrXWBXOYV/fKxDe/lGf/3r7obrP5nsclNgEs4yo2QOH02YrshEPdqmqMevm8YZuwaZKwXY7 RkX23opA6lYw0SsLWHwHI9KayVc2qDT5igbdyuR7tHnxZEuhN/eaurnXrJl7z7MQYomYt732 IShuMBT9o/4K5Gm99ZVW6Xyy2fZ401vQtwwr8W/z/va3cXeGAWSHeiZqqqaokwy+neh7tFT6 +NG/hWp+CZuqtbQzVJKRHMGMHg4Ib+ubvHfrW+t5gz456YGgz8Ek+lvFfBIsEPdjM+/+czBY TP/59K6//jNtYUy7WpfPauq9R7woKu3D18h7mqtdEBQvKpsNcxZKHdN32Idn9crckzRyyoje pzZg5uFXIPtw3NZa2Nv0b0MIlhkC9vSb8tPwKLyFfdiV911Q+7zsw/e1DxeZZQqLr7jCFilT zASL7zJVJrDynmWrW6Q50eI7YJ8nERxEaN2LZKcIq1DbS9ZFwZNH7JTCk2LqG9oprn8Twrmi neLVmsT1775cQASH7vuWrO0UfNROWWK70p3i6TJGfKc7BUuO+3KnEHfr73R9p7RNTRF5jMWX YNoTgVJFpLsZuS9EaC/dKVe0+ObrBFp8WS+I5iWvJZVVXwZEVhqzVsF1l4KuLbqDG2tRZItm SBlBcZ/UtSQztGIOqyJ5Y+OM9+5ebghj08jUYE7uNMvekBWFn1vi7FW8RjNEFOlpPrJKv/7V voW7i1vPGxt/6WIFEEQi/xx6apICaJrjLprbIkqZRrUnLUB1IFsFoPaQtb2TH+C6eNhkKMSD UWsxV7SjzPZtw3K76vAiSft1p0Sjx+BV1TdN0rp75PTeThWRH9B2wQ6aGWqZ8T4Pq935BxpZ Y9zaqIXxOBaywdEO4NT0pOuiAtY3clUTlnNRUpfKLi0oFcvzL41GhwYxZTvH6W6iFAudviGV f8MyK5fuThkZOFTU5LDK8y+yT17tbFqXI5G+wRGXai3uxetdmSRKc54PhKOW92XwEDQy9zmW NDtpNV5a70ZjuStoMOmF7lrKI5rBAha9qsV3+mQ9COC+qKXlMUen5UFgWh6rqc8Se8htvqGP lbQ8BkzLgyppebC755ZpeTBjPe+M+5bUAPfJJGotSnpldDUtj7st9KNtN0/LY+6blgcKlkWE mZ2i1mXT8qBT0/K4qXBtUWa1AsMrQ3YUESeQmWSywvY5vzEx6dY3i2OcFsyP3gu4X6TloXFj yVABVklpVgLu63JkF0JvKKjqk9+gW6TlocS4u0fR79pQ/Rv3Scsjbp6Wp4y8zTlhANw3zwm4 /0rLk0gJe9LyPAxs187cPAWHHwPbRVZgu0gJ2zVkfVlgu5L3GSAqLEM2FVEBzOCnQFHBiz29 Fe5unYgK0Tl/J1Gh6offS0G14qmocKPcPHXYLpLDdpEYtmsicXoGFbBdk3UpzeuD4bw+xRe6 PML3iRl7YLs4mr2sSibMj7aUtSuwXa1NkLaqYkYhXcCN7cvrkxewtLHQIATbZXPYLrsO2xX/ 4P3gzpI7lpE9MmyXvTlsV1MwQN7Y5fL63Am265Xc5wbJfRRXXEUuC39/+vjxU332XkyfP70b 5V0QWFjkfl1KOQf9azoyp/QDk5SSlDMxSwOAlNLkUoqd/Ath29Es8cRSytRPLqUMqVog21Ha lvzvAziXC1lZyaGwHS1zj21HNk8TxIo5XkSh8YCpfRrIcsSnKZYrXSzLPOdxJrUzukxWDzhu Lmd0nlmmYJOibtF6vGuFVqLSGJhGYyqYp5m/UWksCsA7ItFG9bu2aQ1QuQ91WxsZSLNIfipA oKSTyPLP9xoaVH2odiOKQPOMvLLNqAqoPNaV8PHitTmPliBQkKoloEFlC895ZDHzBRAIVCny jGhQWWOAJF2CQB0p8tRBoGiLFMgaMBpUsa8jmg3P+sjqA8EkJUTof4vPBop0J8BikaU8H0hP u21CAAKsG8j+G0TUf27VnQdiaZ8OhNdCX8b+fRjPGazRxkcvZtZKHn00tkXcE4Sgogl/IkOe 2VysemaHU6nwsLYY3QxU6/eBqjoBbuiGrsvcWn/x6P80/V+T0+uEUjQk1qmn5DnWSd5dWqmP 2vhQ+tO/3358GPP2h3r/w99d/vr5bcroVK1+CV/p85yeX8hRj4oc9UCZZFTTbwHd7PcMNlgq 1evCM9grWhg6DjnK16G0LTTrrTRadgz2d6QyubNOxcrqtu9ZM91Z0/Lm5Rn8yiST63z8DhfQ DkfxDj8dqwCoEat5gpm9GVkgUvMQLVrGIxaItwwm3HupFmqe8RH5lmlVq8zi3Zdsmem3Q6nm GdJ4/Npb5mgXYd3jHjJGCWvjK8Xt1DxhlWqQUOhCng4zl0QF+oQL286BGNwrgSMzQsbBUWPz XsjaEvWxr0wTsYbjbstLwm/j6e+dcPeSjsOR2hvTrBbsb4yXB8nww5KopN7YUffCfQdlVRTi pSiEriAK5Qc+ykWhYYH3YP7tFYVGVs2DpKYNkgdJZWfxrc71qXzi11/8XD9NFELqnqJQjjOL boMzW8BiMsu1hxRY3SLSz9sHSeHDziAp17DRmsjy0hAeHEtA40DC+/FOWX4bDd47wwmnPgpD V7BZ91Z7s34KizmWk+tLQFmQVDTHwf8A3in4ghLQ2Vn0nPRDOm8cR/lOOcId5zRYzHmdzpGB cEF1QDU88UlSALl/XEQGmguWkQ1+GenIkt2wf5rTAzUGu3/kMlDDM8rkgRhLXdJlNCtNPkl2 jSalWTQyRsoFIAmJeNM0plgikGbD7tq3AEtjub/z1C8jagVsq9IYAxtjPdc5xibYWF5wJyH0 V20sW6sTw7euMbJXY+uNjX+chVIOxKxfA9ahErOeHMe/EUo5RR1XtEQpH8tfKOX/2o1SLmiv +K1Ryud1emqU8nEWl0EpHxoDUcpjZtE4T0cW/dJmBc1SoB0R+hmk8pSRQSjl6RsNKEExY6SU 6cjQEneOw1VStYvzbyl1LoN6TpTy6HlulHJvobWc7pBxVj7g+1HKkaLdEAZ2IZRyglHhZB75 K/YJOCyRB9+tmoChsXC8YnmCEx2vGU2nmdbU6EBZMoel7lAT2UNaAVf2Jl76nWpGzlm+ZobF OcwibWys6WTW6dVQk6azmuZ/WCrIPp/mUHNyEzukNV3BVJPL6Y1QYaHGqoB1b5Ty+5v+BkfY WNIKpr/e3b8X4u2KQ2vdIY2lKPMsBds/hfMsBat4Foc2YZ/+Hqa/Z/Xwjlbp2qa/mUvSgr4/ pbETRuZR5Wjb7sFsmTfBUnfg/h0jG51kAJjy5F+x6W8gxCqA+vEFxzRWHCT7G7ul6Q/AR7yG F1R+4CPQC2rLrnGE6W9eh8ygMW8QAB8x4uSbnetp+XKDrvDEs5/rJ3pB3dX0R64qCpWJ8B42 MN/dF/dh+EDMszMw399J6xg+qoUC87GFA/Mt12olML/TlY0DBOYrYyqB+bqnmrp71LRxIhHg IQPzEcaN1STbODcIzA+rBAfmD4xVrHRB4nhTAIH5Uz/T3Src0FHPDcZx1BRBlthFDqnrPaZf VgPzsd0RmN/pJaNdwYTRrIrAfGwrgfnKJEJFMtSjA/OVUeXI9lhmV0x3k45qv2W2tOp6c+OC quATBnJMxCoOT7kAy8geNzB/MNFmda8cmE8KBsgbC4H5tH/ewPxhpw/xJp8+jI8p6NpVsPlb R9XfHxrwYWSLnfiABVsfI1uYFdnCgLIFqsgWGC0hdsfgAzaZbDFEGdIOli06I3ttZ6H8QWQL f2AojUrZAvSzvgnoz5psYXLZwsSyxUTiDdmiAvrTHgv6U4gSySxiUcItWGfbzTOfYFrJdMcU X5UtUE22aAMa7IVki73YgnkBh77gJegPZhnoD2b7QX92DeTZZQtPolvLFrRgAFC2uAi24Av0 51fGJLwhcjGGkYt3wxHGR6sAkIt131DBNQYkE9cHX4Ej7IsIsAHoroJcvAZHSJoj4AiV+7hV kYu5kEOkQoZcHOZyJ8mEEMX7MWIvkUwMafoI1eOmcITryMX56RdffntQugDFnBQfMPlkJ+LG 9EYJ+lcMJPx/ZyqaC9KUkIIrI0uZao90AdKsRC7eBwhSnSZdlS6QyCEFha25UsPOU6ePDPj+ b0oX1cbwCdLFyjRTEu2RLi4pgIFpXBNOuByk4B2Qi59CMrg3HKAjsNBDPlMT0F2+/vPuFke9 67cPY82Hee9ngBh+vpyQZ6nP5YQB0o3UstrPWdp1pa3NrPZlfutFToh+y+WEMC5ir2xWXMtq P2eiL8yKISM3bFb8nbLaR6sEywkB9yhdUZoixgWco+wNOBH9+GpK7E6WfJx3B3zap/zrxZrm i1msYGVkPV7UITOzJW9048j8M72RNxZthrExj8HGGlsmoi+zy69Mc3veKREtFHbu32tS6ccs eI+j0loYyYo3NuSEKcocygeeo0lWUpcDrzYQn02vEkRYsy8RfcBbxGIRC6aBFN1Bn/ZKmvmY ZkN2+aQxMNt4Su9orZJphuzyGWEA4Tatu4JiKVZWc2vxmmJWG/qoGSrOkMJhKsXm7JXRxYar TJOJtj7N4Y1C2AKYdiUR/TTfeajpC1RXmXZ3IvpV1phfXaWZu8zwnDKVBfCpzCvnWUzErHsZ fTS2BdSTxKCikdsD652Ly4ftGi5fZ1dx+cJ3ZKV+36xVH87nAJv3zVd4+0N5/EVfnb59Nn+b z98nXDpSBaY7lwL+hBqW3cOs/fH3NASP/+gtnFWYuHAsRAiSA2ykr/3tz//4nqXPAE9Wso+7 Q2OCjwwJ6AM0nWcXWq/kdw2EOYk1XwWdDHsoGu0/H58GqMiQ+rsOhvcAYJXHIh3efBOyrlMo 5FUPc/OXsY+Pn9+8kZygtSzwJ8NaqpZTkVUMK9o52djT1COQtrXaJ0FcngvhefQyXgJxUrUY i4jrXeffwmSJWFuX84AqVS8C//mBuw4/zPefX4atplc9Jphr0gY2cgz07x9v3//59KP/c96j +oIgp07gbDxtv/d/Gv1z0KWINnzZqkxzGpjm02JinqQGujyQ5jVisXcBaWq7J3/4Phdynw7O 3RsL9CgvpTXNgolTkVMhb5VQ5whMnETXM5Upt+lAIM1Q/lsAaeLDsS7kDaDrSfv/lYE0H8bN CyN1g9xuaiW3mypzuwWgxsjNq8Ig5cbx6ZQ3Nk50bwhGznLjBMMw0Yx1h8NDuXmBYFL+0QLz yKfjRsbUaZVqud1UnttNybYkcbwpYBfyAbYzVcSIpqexufOCLuQzlmuF66bGcD9n2S6ZMJcA ssnU3LwSkNBkqEe7eWl5mgt5ZssLDUKG2C43xHZHunmNdQmSbSt3xdJDI3tgNy9Holu7efGC AfLGFqTTcw2xLxfyKjLlNWWLEpDygWULcwPZwqzIFgaULTSUN9aXO+LVHbUaUXMhBx21bD08 rdWkoY8nW8COWh6wQsvudGSkU2ULvSZbmFy2MIlsMZK4LlsUnFUURHUHF/J0caFjepdsoffI Fmb5HpVMuCZb6JpsMYz5YrKFLEaGUOwpR7gszU/wFzySLcYChFMsKVfwGHlj3V1eqW1B5Zqy xUIijbK6V5YtRMEAkGxhLHte2eJBPb3OAmZsSmBGcQVlYOk6/lsDMxLM3DYpgRnH8hcw4792 RMcLK90tG6MCJ/sY8eM0YMZ5nZ4amHGcxWWAGYfGrgLMOPTEjBb6FGDGcWQrwIzjGy9gxl8S mBH+8N0bMO82oVLzLVBBoVKWE74/VIqkaHZxqJSRuFH9ANBSBHGTlSBuYlIX6KmPMlQKu3eF uznUb+CassoNnB0A7b4kNbMYaVpCUu1+NJd73cC9C7SHiMxv4IY0OkoBfkvEvI1QqaigYyS5 NDvy4z71hKXouEtzwZMLcYdA7I3LjPsQ9UlBwkjR2KFQqbjffBLbt2iQZmWoFAhDd5E7W6ca 9zFlcYG7lffinAvgnpER0cieL86jc79rQ/VvMKCx1js2rYLLuLrIbRqzl2ax1DaQiG6lL6s3 Br16rKLhJE544FCpcAysO9pQtOZoc2tlPb6qlFCmK8ilBOPET+r94fyV5O0f9fmvtx+q+2y+ x76rjaBuMkKcLzMsr48BAaXMQCy1sMzg3oe19phwRS/iShOPKwuvJj7x7SQz1NqS/w0gemxo 7ZeiMmwKmkt8bbZT+MIOV5p5LlO4xIVQdiGPADC8+uphU9Mq1VF2cUFt+BZdD05KVrZWd2BI WwYYlcdv/GrylLFIxQrmn/ko0iluKYlFCjTyMSopXQwsGgGxSFbO0WGYaXfeurq7vjLKJiaA clZ+ZCxSRdhqpBPWwYSMy31btB7NMVB6x8d0HkhKsxYVkwGsQ5uxSKGxOGqnnGaxVtGBDcci FVUqje2KRVqZZtZvU59VurxRrEG1sR2xSBmviNLUVE5zeBWIRZoVLOOfdWeRzVikkq3rCNgr sUg1Iu6lWRKLNJIoXQAfPlHSbJ5EQcRiqNPf6nuzfDUgU6YhdrrVgExea0zlp3TbbtKsiT4a 28LqSWLQIfcM8WfjVhwQHgIU6oFAr0ieR4/kuX103HkxKyfH5xwfkXFSTE4n+h4tlT5+9G+h WgCsX4lPedLAmhOoelrQCkOSeDv2h3H36D8+1JfhFu491taN2E8b7XJm4EqeRJD899/sBkkE 0bUDVxQijI0BIkAy55qGfr497sx90GHBitu2K1fu9pho6NNx8VlDn5b/FoErx+c+wOZ3zn1A qGp9rHUQM9wn/PPXEClKWHxewxuGHQf/577HMPyfbWgD7Rhs2yTUK6lT2LTCE0TjQ27TSm/3 hVeppRKC/3Pl/IKwPk0N1ofGO6a49pY7Zp7jPWB9HigLVLRKsE0LRrNZ0TE1VBFrE/Q5myib ile3dUybGg1YxzQscjLPdVSZuSKkY2qRXMYedEwU0k/l06ynVspGhoGRzQOZCnwGRLKqY5pA bKCRDSSPCkhvRTf7UswDyU6WAqQpnlVlRSIdUzZtQAlhc7ybaa1KHVPyhuSwrgUnGrtpdts6 ppVpFo3ls9rSNkbX4WISpY4pawvXpilKimRv7MG7oQVFxqfQMRW6zPp2yrgI0IYUja1laFul mXB3g5wysOoS79Mg7VB2pRqkYSDCSfabJktVw6zMNEggzeIt4YSBtmDaYSCt1DLSuk0fr+iN oHmoMe0+/dQusafUG5wHa+OP4S11FuHo11JnOfaGtFJ0/aoduNHVc7X60NEA9l17PfBMocRq OnkzJVbT0aC3U1/02ydX++eb/fzz+5/hum1ck155EtzOqw04hkRJA5++Bm3BrKEIijETlDg1 lSnGEjHPon2A8Bi0Bf+ov8IMWs+etG5017LFgRRfvupP9j9v//P/vP1f/+///N+jhgETzx64 On7RqqBj+PT+t/r8aRhyhHhDvaKhOuzjwXxe6D9FxZN0hXfB33np+35NfR+5Ta7TXKuBAH2f bLf0fQEX+Lxcp55yo7dGmutUOgGrme+xmb6v6aa817l3zQiYm3nX9Mbdceu5TnVTAtWEXKfq yqDEaVtPo++jd9X3vfKRza7Zr3xk2cYJbvnIYPs0uU6fMB/ZTOJ4U1wxH1n+S93pjeYJyqYn bQybEKw78Hzy3oxiDgWTT61DiqJXPrL1AmhkDwxU88pHVqv7yke2IcHfO+vIzfKReXRwVctH xo/LRxaQxuEgO8mlhPOR8ZV8ZLzMRxb6iILsKnuoFOmFaFLJxI+LNpK2aZDdahb2MHViG8ET ySSay50kk2qm1PtkYZ9W6dR8ZM3OfGQzx02NbEsXU5WNQ96JuRUYPM9I+cm0MrKUqS4WZKdl V4wMKqhOE69JF5VM6pXGcsyAfVA1G4ai46SLlWkOf6y1Hr+/Ox/Z3kzqlxTAWMFnOScEGDyM X/nIriYZvBB258/dEyDsJu/rfiVdad9XFBcUEg9qKHj+Vt01qH00xUVHVQunIWMao13+SpcV D05H2J1JnJ47OxUX7pQGFRfJ0EDxYJdosQthl9pKInXPhPnRtjKylCEvprioIewuRPw1UfAe QHGxkOjWKHi/AcLub6G4uD9I7+0UF9rUFBc78XnjtiqKC2XogKhT4vOuKC4MqLjQUCL1TXxe QURFMgHweVur6onUlSBjW7niwtxNcVGXTDw6nOApPu8tFBf6aMVFUZAfGscIEwVPLsTdhw5k ukoidc9I+ckEKi50prhIYHEHAYzLBQRp3IocFsBKxQWMsZsXVKfJVs0iyOb4/fbeiothII4L CYCxe3vFhSfRrRUXouCznBMuh7H7UlyMfzsLXjcPWUS3CVn83eF1kWwUBK87lL/gdXPpoeaQ 4c/aBp2h1zgRXndap+eG1x1mcSF43dDYQ8LrDiNbg9cd3njB677gdW8Gr+vvPAJyPUax6/HK d/AYzT7BJLs/BzBQ/1P8BXTlRPeNjpIjlJp9Amj2qegY7kpf3lCuUfwFnH/jvbY8+wIOd84Z wfcX9uU99gsY0HXntuLx8sabm5sdX8BwYb8guq5bpTpS3mXwWGcumQscS53c2KkjE9WLZfzq tAnSAr1nZKKXxH3/i2DS3G6ASUqZRm35NxxXcExjxUGyv7Gjbnr7DspDTVGKyhiN5goXnPzA 9xqvKEZjWuCNCw4+P0Zj3iCgXlRUYjTQ1c71pNzx6y9+rp+WTPhMTBbwXA8vDDEaeF0UysOY 0G3CmEYdgB+0z5RCkG0No5uwRfRYHYDsMaUNssVOwUI0HWvjnbIMZAaaBHwbTF/sFNcWR21f 7BTc8p6aBtwp4bEq3ikiiPadVViXO4U1DDO5e6fMbY14L9NOGeeojICCMvyYqUEY0AGEufTw TsG9AndKqKMvIwH1fZtjBYcUO51pb5liJ1+nTAYKQzKN7jsh8/XB0Rukc/c6HlNdthK+To1r u1LQaNKPIA1D69w7vUKN4cbds/tYXUC1uz+tte73SUNrIyNkElt8vEjeetFYysRTY4RUUh0s l8SImeefxj+gadK+14mVXxjFY4UCElqYaKihAwkZcTx5tRAFbkisnRi3RjzUTndtzhrTLyWU zmYBbWA+052Sc+vTy0XdvdIZ6fNkBKzITtAmk4FGNvzSM14ufL68TbFm4GpqS0Xar1+rle78 w+dDKWlMYIMThZkilNF4qD3Tk+NLxHiFrM2M1cxrOtyrRHW+v4VE/h9E0QmxJd1OtIOmWZLI VaYqFPgTjk3FW9tprjtQBI//EygBjql1lzQW9yu3VrObh9qOc4VwYsq6bnCEz3WnfV12B03T 19Vz3VGThbuN7pAppzki5xC8Vpf4JCGhgI+U8SWTxy4sYN0/CPZGzhreyUDAzhq741+jOghK 5WSZxB0hahK10j7YSvxrB8HeISCV0xj/2tWdNXq111ljiH/lS1vZpcRxl5pFrXwuk6gVqV1O ddY4StSqpWUQjNCuaSfV9u1g79BpqZxGfabf77EXZQWUvlONTZIOTar2uitoGWWascPQmLvY 06QgYaRo7BVnjXkv5JOAh3p0lMneGNZThNOCqp1yn6VbpHJiTLBI8pn6XRuqf+MuqZzs7VM5 0YLPck64XAzrK5XTtktnc1UpoUxwfFcpAddcOslxLp3+ZIRcOp2UQNwVGw42ISsunaR06Qx9 1KQEBqBkTA+2tWATkkkJYee1dZdOLttKLCq5m0snwVQ0/kqRSwlgsMlNUDLOiEXF/c5Y1Jnj pkb2SQk7YlERNRUtiGekfVJC5tLpmeqCUkJfjAwqqE5TrLp04i5Huuj2u3SCAznm87mM7HFj UT2Jbu3SWWaCyjlhkBLa55QSHtOl84VScT2UCicZ0NYMKRovjVKRvC8hycD6HM3MiMFAuk8y UO6zUJcMtLRQKuh7olTgHjEMwuZjSYjsbh/ssYlSEe/uPJT0/igVxN9b44L5YY3aF+zx26JU gAP51SSDF0rFxSWD3yGK9N4gF0o7Dp90NJ8+fvxUnz1A+wjVrrT24MOKXgjsIjr87ARJ26US gxFdV5MyZieO2CHERgmUv3/K2uoHNEwgefScuKb7ltXxeSIgsIvG1uBt57ZKhxCy23XKpnk1 INcpMkkZOV0mKaPaFivmeBH9w2Ml55lWCZYyFO84LqkwT3EicUZbVj2wy/QeZUHO2NCBDSdN KQaSNVamcxmnKTrVldPM6+74Ltlaeo/ljVpe2N0fuT7PomLMCs1gigyiUkjvERMCzuoB0gxO 77FFCFNieozklW1a0K6ZLaanbGwoX3JFTzw685kXWJCUeOHEVnGuWkAwGAbCI/+M8XwElncS anx/VFYbi6TZoSAKbKKkZS0oka6zBl/+GbuDuO8yUSJhDSUwmHB7yt6S0YxENNtcgHQgXewU 7rFfEUoHwky7xWcjRfbj1JLlnxSKY3IUwVzZjCK2HEjSv8mnedRAkj3i+hcM3k4hw0N1Rerd rY8sGohBGSE6nBJCHCneniIFFW3470uUeKZoJ+R0CSlNqiJrOLyB5DW8W00bcf9kNEcn9Tg5 WYnAnIsiJdJn4kdpfM5fUs1ywa3syZxfJVT2CVZ8nhPt5XvMdHVhbpsipdM8pFz6Wc5R+IXA 1Tm+cir/+5Vj5bI5Vvhtcqzkd1UE5VRm3Vb8jjgcGb+Dp0to0k5jk6iE+CfoEhp+IMsldB61 okajIeamvIQ205f9o8ixMuZ6LnOsvHIq/wuK32mAS2ja/zVzrNwfC+xhoEp3AoJBzLMbqtSs QJUaEKpUQ1ClAyAYATaOdbdJobsRkGxHjpWgztcVqFLL2p4LnXqPPABU6UqOFRH5Z94UEKwO VWpyqFITQZXOJI43RQpVWnDWcs3FFajS6VU7PqCOJDyr9iW9B6q0FZWbaYtJYV9KWbuaYyW5 gCdDPQGqdB+YWE1le1jPsYJyz5MQ1FycUZc0niBoZI8IVbqQ6NY5VkTBAHljlwMTuxdU6WNa ic5CFAOiientookTdv+dEMXczbKDEMWG8hei2B7xY4gmtiw6QG6GKDat03Mjig2zuBCiWGjs KohivkB7t1oWjf3oka0hig1vvBDFXohiN0MU00x1faGb9om8v5Ev7mvPvGaSdOs38T3QYpEI P0N1dXk5lU38KYzL99zER9GvocZx5ej5mdzEU0vX8imc+0Gpt+ZUTgBgjfFZUWHRyk18jvZc ijy48CyR71dh0U4edqiwALr8Sn4U0SoBN/GZgAVFC7IMrVnu9rVAqrDVTv00dDHjT+uX8yvK qlQvNX4Ji5FNf7EVfwbQipxMImxugznOz9LkcE3YrqpwyE2z8bM9MnfzaFljA3iFXcAm5tZx sxRkbeXI0GFpOqWa9cUb34hb8vrW2mraTKxpoAWIqniJT5bTZJoRlPcbE7HqN7PHxabgBIII 82scf+46iXnN9TPtd1iU+htT/yDNGsvbthzqCie6KqoiI4WJbTJ8ok/SUhPQk8itpvcTWl9e QIytKxzI5siaYjJb22myeipeOEzhYjJb01xhq9jnJjx1XRSbCqo+ZeWKVBsryJvNquuO0Pgk C6+EQSptbHYUK2m2T41zpACUVw9HrK/uL2tv/6jPf739UN1n8/2Nvn02f5vP34M2yPtQCFFp ZDhRgsX9m+/17Q/lXTD8GKJG8GCBr7onhF3hbcvqD2+e/ePvqRE/CW82rZqXAysG1ZA39PZf v3kNFmm8ZohWTbthLaZKweb+YZR2FXuv+iJVk7t3stKF4wfv9Ibfh2woKh1GLEa/oMNI01Hs 56q+6LdPrvLPN/v55/c/gwnduMF7h4ig7as2oNrg+7408Olr8ACYvQ6CntEENMwaW2IsEfMe JP33/k+jB13jP+qvQKvW+5DQKtFPdj4J19aByP82729/GyfYD67z1HveN1WPgZO8VkTLpQ68 8f2LYwl3WLzZn+/BWz9ZLq7XvDqOZozOUElG6vhzZzg8vE/HpJGtb7sLOMuc5/XSGYbp4MPy 4Tr/+mFmbxTi3c3qnmI9J/04dEcqV/lnmPDg/FJlpZ60YnIFiaspzw+4uoeOd85hEgdm6L++ //j0/tO8ffx8f3dHqWdaz0UXdur5XX1zAGzda/jm5KoPBPjmyAZtAYemmo0135zB12XIFNql wR52hEVKXAxaaaQ1CzLnHheDUEerElsX9cZS3seKjWRcuqn45qhagMjLN+d+vjn4qkrBMq3O w/rmWM734b9BzLPTN8f10dbx33hb+OZ4HwYb+eZUGKTcOB7bdWPjRJeC4DNTbhzL3H3BXfkU nTZOVOeevjmEKG4UAjYO194RPk02cAtkl7BKsG/OwFjFShckjjfF7jTCNd+cZGgnphGe6m7c oHHDK7HfngnjsSe+OeXIxl8u7ZujzL7Y70K3ABmgLu+bUyhNX7455TQ3X63ogSIGyBvzqDAE qSf2zfkdAsBfyLSXQ6ZlHhGNGjLHfKd9XBmZ1nFBzzujSF+TTEDMuXoaYazaDj8cMq1PgwSl EXZk7zW6qa0yWqXTkGkF1wE+b1kPHVIkHyNMFDy5EHdXGmEiUAWZ1iaGzyOQaYdJbEsXIM1u jEyrbYZM27S3QKblSDsBu+h3baj+jbsg0zoSvZBpX8i0L2TayyDTBilBy74DpISzkWkre6HQ X+BekfP1F6GlDgttASnhrsi0XkqgCJYSIq+xG0oJR+DPlVJC0DnHH1iKTpcSxGlSQlqQMNI+ KUHkUgJFF5QSLoHxABf4T2COX9/cBL+eI3eFbop+16WEO+HX69vj1//iyLRPJyXcG6XWETus UjCge1v813/e3UKpd/32Yaz5MO+9GZeMr4sMMk3DuW7yYNJYUYoMAXKTtrMTdIUBF5HB+ztG bX0HnJ0TkSF6vxAZ8rZyyFqfbOlytsJdTtDQXI5wgp5B7lIn6LmtizhBQylvEFJtr9WNRYZp lWCRgUvOdbaiNrmta9YSnvFiBX4senXy3yVdW/Jx3h3wlZ+8RYs1zRezWMHKyHpsD2MkyQzA VHJl3n/eWLQZkkk0pOb8vcwbmObwi92eZukLu/L5K4gYEQJ2/oYaG/bdWusV5+/tkWHCDWe2 6vwdvVFtTKR8tjLvxfkbbsxb9rPVzL2DMVlbgEjODD6b8ySC8zeGRKVFyqhlkCpmFUbGIj9a m/se477nrIVXc/ACXxOEBpLvkSangaQ0a8tZbW6nxQs8bSx2BraJs320RPBG9/6uxaW6XN6k oPSoXiJERHUgZeas8SmlyXJW6fKOrnDckGLD5Veg2TnXFCneccYroq1Nc5+seooUVLThvy+R I3Uwlq1a2sJHZAY38+7OHtvsTfVe5vX+ZN7sRaqOiGdXdx+KFcdv3Nlf3/Pb82EEmzaiB7ra 3/78j+9a+uGTFW9Ux5yF53ivNzzHLeaQ5zjWfNV1/AldwM+A/jvZe/xk32vVMmmzit8+zDcV vMW5XeOk09yvkUSmpA4NoIHBDflyPtcvlMEth+QXyuCRnsys9GRmV/BkzpUY6CRPZpSqJ9Y8 mVvVaoPsHKKdlosCZdCVG68yi7UTmcBCDwfQIVNM2olUvLEgymBHW2GknLUTaTk9JUT71/dk xuSensz3zhXxMJ7MGKkboAyqFZRBBaIMGghlMLyvwUxUDFFMpTW1TNagv5CEUQa9m20rCGOH w5N4MqO+pXkmKlitd0FP5mmVaiiDKkcZVLItSRxvig2UwaIgFqVjT+bgxwkrNez4lGbFmVMm QP68u7QxQnktCzaPA4tLlEFTQxkcxgwP9WhPZi1VnWbBHZxwyTYhHMLrsSfzWODumQkwkivY 78nsFXtnmRWXfgtP5r5pGiAnx5bC8ZKezAuJNMrqXtmTmRcMkDcWsli5s/J5PZmfwhX5hWKc gM0+FYoxLv2Rp6fluCJfzGbD+DivoBj7j1+PjOofTL6oohhrgXnhj/zQKMYLievyRXw85Fky 27ujGBOCzMzzBRPmR1vK2lX5InE/ToZ6gnxxGooxAb+VZaQUziOljpAvdg3k+SOl8AvF+Ary xS8ZKXUWCLIoQZDFFfSJpVTze4MgI9mYDgBBHspfIMh7pRdEpJTCnK4dOREEeVqn5wZBHmZx IRDk0NhDgiAPI1sDQR7eeIEg/5IgyFFjQhLmOioRRI+RrFrWSMWlNlbIjjF6cAsme6tY12GM rVxkPqo7HE6tWEREiQBJZNOpTuFGd1J2ojnIvkV9r4gTkXtJ3SUnrkcwKY6CGBSxifsh8uCj IVQ7/pM07IAsj1J2Into57/TGE0+0CyuiemBxo3HAJpDTddYXIHQfKNPNflC3rGmsdM0fU1K 0hgJO8wibWyq2Ysp8sPVbMigtp3qemzlMIvDUkGSfJq+JsMTWYa6Gs+UO0w1vewYCkIFs0Sa rApY9wbbfhhtkeWjM/dVcXVIV49e997CENJ2qS3CnBjRIApoi9xHyPaIOaaoaIvaTFvk+zZU dIuMFGuLrCMvHTF6nkBbdIecV9Eq1XB1PGMVK12QOL9F7tIW4Stqi2ZY+pyzs8ZsV7FGsa6G qzMRrYqrkyh4kqEerS1qYYDpzQLYslJoi5wAZrOCl7Yo1RY5Et1aW4QKBjiisZe26GGMWfeH /btdxLwTByu4OjsR/6I6BMTVsUT1iBNQMuEruDocxNUhFVwdy6Wq27EabCuSCWDHWsPVQUph ixPJJJrLnSQT7ycjQE0Q1rTpaaoJuhHi33rE/OZxWEgX8Fc28fnYli5ogasHDoTw6V6Tj8wz Un4ygQIYyXB11oZ6dMT8XtS+6jTZui3K5rYo66SLnVq9fb4uKwsAShfDQBwX9mpTNFwefIJ0 sTLNlER7pItLCmAY2gEJJ1wOte8OEfNPIRmQq0oGZVbMXDIg1J0jfr4+UseNvf/LA7DHQ684 ndOj1RVzbvvoUMMh5VKcGCwqX1FX4EkomOtUE4MlUYuFc0tI6FQKBa78pJj4WmIwwDy0FhO/ zCXzOrf+xDpE5qG470IouEJM/IMkBotWCRYKNFNG1T/b87KMrc2prOLz1R6Z02rsH4pVLpY2 f7Vc5HQ3xKGyxSTmilBOqxbJZZpTKquNr+UUGQurHPI3QK3MzpxWSxU/aSwAcwKQ04r0VkQB 9mmiqikieQH/Tj9wO3NaJSsCZ38qpjkNL+HEEM2crCYYqzytc97YNowOkLCpNrIyp9WGVmYJ B63mtIpmtT3NI3JaFSJmMc1aTitahFUXY69vp2xWYMB33jpMsyWn1dTYnNMKotnUWoU1CvLG Os3aegM4AmGjQZkHtwpUNZ1g227SrIn3F3M1YD4LgcDlxyuW6nzE73nS6LbMk9cIX5OViPJW rQWUD2fwViw44ehXyAJ2/1DuRpnGh64PmbV8fY920P10W8SHvNLVjE/Pn6BLtCrEzH56/1t9 /jT0GUWYUx84W+336OBrTjjFM7E9i/znzXz95EOLPcBAvZ5WHQ6RzP98THyi3/75+BSWWOC1 69YZxCGUhuG6Kl/U97/ePtSn7ya65wVQhypznNPx0bHeJwf7nxSwf/TCn7XLLhGyfyrnvXKk wTqMV460WyALkNvkSMsVPwhAFlBNv8cTeB+ygMHSMUJbIAsEHaJGBbLA1AWs43F1RFu4pLSK SqXbWceTNtXNupQiR1rPKjnShtxpL2SBDFngvjnS7p+E5GF8uXZmIoGYZ7cvl1nJkWbAHGno pBxpdEQDODdHmiUNxtYcDg/ly1W1mIpeUi3pjZEFplWq+XKZPEeaaduSxPGmAHy5hkA/1JEV JWGREWQuAJVW4Vm1tqI9vly0r0T+0RQvociRhmq+XBdFFqhlMVmoemdkgXEgBFspsei3wQCe xpdrIdGtkQVowQB5Y5fLYnI3X67fLBMJoaplsybx5/uoSyQsBo2DZQR2mTwkKMAWjzJCmzJN YkBN6iReVSI9a48zoCIPigzJCGL03b6ecH2SAXVACr6TAbWWrcxriHVL9sgIl85D4lapZkDt 6YyCPNsm0je6ETHbP9nazo1FJs6xMUyEbaUtkaNLOOgtA2pcUCxyuktAA6p/LzaFWMiAKoxk xRu7DKhZ6rP8jWFkbMUWlU+izRbAQ7VPr+JOt7LdhRw92VoTuSqBg566g6SXcVbwisQG1KSx rgNoZnNc6GmtSgNqRphaVpkYFzoUABa2Eg56ZZpZv00xq50GVBAXOjOxAnDQlWnGuNDFNIc3 CikCYNq6rXXLxLoiCpW21lUTa4U15leL1mOaecDhnDKwARXkBFS+kfbWqhWmrQ51NrEmrStR NaACttZVE+s6zUpb67aJ9UgD6g6xJ68UPihrqNxarqJyh8/NSv2+WbfB+mN8ywbL2boJ9kxc 8hea9zOYgJmWLQ6j+PJVf7L/efuf/+ft//p//+f/Hu0KmHha46oB+HgT6rEVbo8ffqpJkepk XkhfHcj7hcj9a9rNmtJuRq5gN8uv/AhC5LZbiNxH2M1aRbngbL7aQ+UJIjdizJ3loG901zSN +1SUdrNQRxV2s6kPyG42ttUfMrvZUH7tq33a1tPYzVB7T7vZvRPuPYzdzAkaN0DM5CuImRxE zLRVRO4FeTrBQCBaKrffahsHQORWpq8hZlrMpBhg+R/Iboap1j2EyH03xEy7hpjJc8RMHiNm TiSON8V+xMz+WAwEmz0pr0F5fTcu8USgGbcmeRUjIEqx6A62myUwM+lQj7WbabkvSrGm2D1U 7GZTCJ7IoxTFCwPhcMhIdGsMBFYwQGk3czcHjJ/ZbvYbYCDcO2HIPSMdQ84CINJxKl8RSi4S 6Rj6ASIdh/JLRjo2NUPdYlx7EkMdRaVQYkijI7rcLvtvWKWtSMdayMyWoS5f9dlQh40TQQFD XRkLeRFDXZgnbA4LXon8ioa6sNq1N8aR4T2GumFLyxVDHWGC6CMNdflAiu5gCxaNR7Yr0jEM cIehblqr0lCXvAFGOs51s36XWY0Few110OKVCI4bsldiqMsnUTfUTbae2jRFSZHsjT2Gugma TOSTKAx1RX7gOtNmXATYMovGANaYnnWaiV70OWVqNCvNcFCMc/bCWqRj1LputdiUOfsKQqr7 AJhNmu2MdGyllr9cpOPLSHd7I53bWFGnUwQdpusGiMB+hY2u6eTjZtw92ez1BAa2EwxPp5jk XqlyX4a5YmHOM8zx0jCHr2CYy+/3CApoY92GYY7tN8zNokFhmGNUtqZmXyhyWuRtZQFtnRQG MMw1gtj5CE4Mc9Larm8XjOW0fMiI9TLM5QFt/KaGubNyxeQbCl0n93SpMPutc8VQ1HGky1wx Y/krV0xut6vmioEQQo+JdzstV8y8Tk+dK2acxWVyxQyNgblipjemH8ppJiRaGqOA1+vJI4Ny xSQVjCr1DYNRCzMTk7eV7XKrx94W29gIMAye5vDyc+aKGTiR9ZzI584V48GckWmBvblZsDS2 P1cMoW57hcYulisGq3xkEdO6NYp/oIcl40koID5XTBK2dVgyx1CaTjOtaeSUM2UaS5QrZtAX Lrlihgqisjcxmsk71YzUpb5mi5IFGGaRNjbWNO6KOb3qa8phVmnNUDBVkH0+zaGmmiiS1nQF U00u5zd8hW4e36qA9coVM0d9P1+uGOAeYxnujWjF4KwI3GPEJG9FfZhGt8A9xrfVKXeWzPJW VOehcsVMX13qFpG1T5UrZiZxvClSP6mCsybJoZ4rJhnaifgCe3PFNKSC5o64qvhJgSMbSfQ7 5YrZh+a+sgDLyB7YT+qVK6ZW9yw/qadwdLp/speHkS92Znwp2PMY+YKv4BdxEL+IAPLFdsYX 5BZkd8YX5b76sB+2+/i1jRH2weQL72quNCr1OSB+0Y0yvtTlC57jF/G2LUl8knyBmhX5Yhra 6fhFZJd80cN+2IEJYfkCHFnKkBeTL/Zmi1n58K7IF73VqXzhCl5+2Il84Ul0a/kCFwyQN3a5 bDEv+WJFvrh3ypgHki/UDeQLtSJfKFC+wFX5Qq/JF4EquzPKdXX5olOGsAeTL6pxXo6fvNb2 9vIFXpMvVC5fqFS+GEh8knyB0fVy3dI8L8T0ZI1RI+eRFUy4Jl/guv4iEQnOlS9UObIdBQ30 FQfivLo8zqtbly/8q2FIgiAp7Q44xCeXLzyJbi1fkIIBIPkC0/4lX1xXvrg3/rJmwtIVB15G EwfeimMK2RYx5nNtiRzKsMtHTi3z0yFLF9ePnSIGIRj1hYixBq8YRUcVEMxkSVpb2QzHuHrR ScRYisqoLWguWdJaRxfZTCJGbVxJ1NZIy0uoMB4uP11YJVjEQMHrIOF6HyM0HN1jLIe3meS0 rTUGxfkU65UvOtAYHD6G2sksTWZGqqxu0tgeaMaQATLqjkvOdW2aMq+bqL2LzGKBh4GPkq1C uBVjj0ZmMG1q2VzTWJlh75QLkJO5nOZM3nQBgPi98Q07a4qKxjDBHertHqDN2nk0NVbJVAis ZhHXlXzYigWI5ENHNTkjjo6ZCtUOPtvOVDiODDdF/+XIwkK1Je7gUTJe9dV5ICkXy5KLV7ZT RDM4fm9lmsVaxXyWZypEedK5UKU6zR3xeyvTLBqrzmqmajT2EHxTmeZq/N744GyaAs7QCFEE iN+bCuawvaPk0yMFoLL6eQFQ/rhfCeFS7WoEWDi+o+pBKl4VqcOx6mt4J8+3f9Tnv95+qO6z +R4HfWHtJy2qicvODjxzZ89W4BkeomuukaHvmULHhOqMXy9Xqw8dYbqWIOr+kWa3zYh3Vm8C cy4KNv5M/DSNj68i1QgibmVP5m0fKvt972PPtL8qui/qxcPWbpNq7hJRa+cl/nsFr/2awWv0 NtnYcp0HgoLXtNyItWn2B691ivKWNUA2NteOHAwKpdGETteuVRyaQgrLgtcIodgd7rPm4JWN bXhOD15T90SVvHeKlYexNmLX0vVRJckKqiQpUSX9DUScko0NKbW1cSLxuJqNLZjCqFaHx7I2 Ft5MoQ8feOQ2E1mQy29nbURrqJIkR5Uksi1JHG8KAFVy6semmgnRGBbXJcgSmyUTOCMbm9hh bSR0UWsVTJjIaHk2thqqZGuTgJRkqCd4S/flyHYUiLSx0CDkLZ1bG/GGtbHod6rbuCsmNpe0 NvoY1a3GbuEtfXtrY1MwAGhtJO3zWhuHnT5ctD59GC9Nd14sriebvrWl8d6I1V3Pm2a59swK EBxuvfpyYsWARLVYGBfeG8HLYLFizcLY5GLFjHaVihVzH5A8nrSVg1U3uLAwZmBnx8jjsxPT UrRqYZzncoQ8viSDK+VxfBGx4tFwIcMqASHvRYYvNKI5RgWkt6JbDC7cJ9dGpBQrMiTByfDA 20Sr3nWM7QFlm5cjrktRi8vGkp3KKCDwBApkiHp2FVow3w7lyIq6qCDR/g9RMislqOXl2KPX /bKt0awYWVwxtq+MQwVGNn6+U1Q8G3AKa63P0IL7adakrUPQgtXGaoaeYr1nNbayJWvU69aJ uAUZupLha2hdbsrC89NmMAFI802a5db/YSsWGb52QgvukJ4sbCfPhyoljPJpRQtslvryjlQu aTatZhNxsZuExIuA2SrOVYt02j/nwAKEX/pyO81QFuG+QuUCPQ5A3Ffrkpa1+8IjksaWsH+U gGxgQpRIUCeVwHFquVMSuO0UfIpq/lheqo3pwLwQiuu6YX+2j7phbx8YjCG9CcYQbPC6feGU Dv2nopwbWp1ZOJpTULtgyqDUK75FVbUfDh/Ihsbtrwa/eIZp6pfFU+xE36Ol0sePfmAbP6mm yjR3MYDdBbaxMwzTwY714cb89cPMFinijcZV7lQ9J6Nt2o/UVf75xcwGsOru6EkrJnNQXE2F 3Vid5PHcwiSWOnD0+49P7z/d0v98f3e3Ws+Za8bwEw17v6t9jt0GXDLXFCDAPtfg/nL2uVkk KLO+Cfe5b4/RBwRASmUhcEnjU5IdDkXWN1eOEzPD9FsAkewkDC7Z8Zd97gHAJbMtIq6qQxPZ zrhcWhUpDpdIq6IraVX0jdKq6EpaFf1KqwKrzwgq1WcI24YS1N9cfabvklaFCNu6E/WGaVX0 SlqV+HpvL51WJax27Y1xZHvTquj1tCq4061sT06rovO0KrqeVoXEI7t0WhW9mVZFV9Oq6Ium VYEW72JpVfQZaVV0nlZF50pg/ShpVfQl06qUNMvTquhqWhVd6j6x2NT0raZVmV8KqrdtU/Le tCogzY5Pq1LRjoaLcI1pX2lVrhVV8Hv4xp+s1ztRPSNxh2TRXy+R3OjvdjlRfgeX9qdV0Kle hGidXM+GuV5VtDHXpB31X+bfP96+//PpR//nrPjWF1TMEidOedp+7/80+ufg+CLaoO56adnO 8Ns5UzUnStUcuYJqLldAIEA1J625ft6Xrmka3IrCVadVwmOAg7qGUIeX+SmGOgLI+0K54PNm TVRzY1v9IVPNDeX0FF3Dr6+aG1yIniPvS1PmfblGLErpcf9b530hqJUCyPsylr/yvvxrR96X oQ9MreIpjhesw4M960/L+zKv01PnfRlncZm8L0Nja3lfyPRDOc2EREtjl8n7MjZ2xbwvNFdW AtMcXn7lfam1ftW8L5xwyXtiBRHuokXsgVveikZI4biSNpQfOOWGu1+oIIYSbg4cu9e9YGRc 1YZHq8lpqOfLpft7oVabZuWWB3tBwb1BgiO2/+vw/+k0l/K4Luo6gIiXjUd4NXbBxmAB6955 XwjtQnT2oEya1IZ0h620PSbUYHzy+8v4FKG/Ij0j90YwBiXw4QhbKQhmNqgnpe1l7f4yu/Rf 8f4yzyWLYJRWV22liZyV1WkqctZFbKXasjhf0i1spdEq1WylEs1S1oIQFlU20ou/GQlLr23Q 7DQsT7HGFaYrDxLAbT4au+p7VoSa5UhCseVg7Def5pg8RkdiV138KE0oU2Pjn2L8sxA3S5o5 TuFaRBQpiVjtDppmJQNOTIigc0yJKGLMNrguYDxdxl4fWXUgEIkGXsm7g/isliMnIkQZQuq1 niBrBLVmwvCthRpL+lpufruYdrMAboxYZcp5V3jFayBJq2lbN2/iNRKNEdwxZbz6FqRZ0NKu zAr3sqcZ0zasaqxusngkr8xds9qDCHyRJveI/TXo4IrQqUirW+6vqKDz0cwFVcG9WZI3jpmu jIyxNQ+L4wuOtJVuSz15nfA9WbE1Yr5ubAxn+oY5RnUva8zLGvOrWGPQbawx+SUHQUBGzU0c pTkSvaoFTq95fhaB06EtXVpjxme+gRTWGFYCGQ3lzcsa8wDWmAdLy3aqo3RL91/+x6dwlPZ+ VQHttUQyJxGk69UcpUM/TQshmbtydsp2Ifu3S3CUxvF2geaSbZdFKVBuFxJvl1yivNTl/3Fw BqZVWnOUjinnXQkPyb+AuyeBG8shiEkOuOtGYksX16p8W2Ihl9+DeOx+1fcLy3Fu19GBdRrq 9ArYWIjzr05zAVzYnOYExlPYuFg+kDU/3WJWeb+VO+A09q47mWbCIJUdR4UDaxRqW5C3JGI+ VED7UkV/n98Awvt1q2v504FpqvwC37b7aVb6usaEkK6BMrwfpFmIFq4PtUIInaM0zeSV2SR2 hfeXjU0kmV7dH94PRUT4gXCeYKwTj+hUYdolvL/WGKD+isP7uWjWpwlRZFYXuomlqCx6zgY1 hfe3DAIfTyJQRpyBfcBlyciigRCWDMSwrk0HIuOz+BScgds7Sp/uZnyam7A7vqZKQU8wQhT0 YZj1uPYTYQPC1i/cfS1GjwsbcLLf8K8NUPCrww288LZfeNvQHfwm8fz5ZRyBeNv2cmqqEB/P SzXV9G09wGqq+X67x+jeKqG1j1EsnIYZle0Cz1vE83NUOA2HcmZfaqrHi+d/Zfcd5fAnzO7b 1bP74kH5BmycZto4y+3fwxvD2X1Jx6nWNE29F5ti74S37THKLCoVVk76aNs8u+8xXsG3z+47 kzjeFFW8bWxLvG2dBKAOeNvTz3Z8QK1EeAr3kfhiuy+7rzUzzxdMmMhoe7P7qmFxwaFWnSWO ze4b3gi3c8JlGb4Ne95GeNtjAcKpH7UrOA1vmyDpeJfTHel+oZE9YnbfhUQaZXVf2X3bXx5v +96ZfaWTVT15h1tPuCu9vYcJBHTG88WK+CwTiOR428Nhb/aJFVEdFE7dRKwI3wn30ZMEFCsM q4sVpoPsYMiaJaNvPA93W6uLFYq1FbFixtue2/IKPL60lcrjjYdqhTL6hrncSazwZwWYxqNx p2K/YFUfK1aMfz0po68pM/rOZ4ewyeeV6TmKACnc9IybJvYia20HnINrkkDBkwtxBy+yjROa NC1PChJGyk8mUOBBi/daNIlt0QCkWTjLksY0SmimUNfH5j5MTBqDs7xqROOu9XGBFyJwWreX qHijRjOh48Ub4rXSN2jcmPSfr7UgKHBFlpEVqW4ZFIMzEmA6hVTS2DiQxrDc1XQJqctHRkYw FB8HIHomiUS5wAOIBmdIAmtI4CAnTKk4zAVEg13fH0AqCKiiFamA2TWpYDgGXO2hu/Er/6b6 H5++vgfMZbSqcP/dcnI8jP4BI36DfF98Jd8XL/N9BRxyWP+AkVwRFBAWOwWFsPlUXf/g2fnR 9A9gVPKwUlpGx8SN8n1Nq1TL98XzfF9ctiWJ83sJ+AUdhIxILmrMbE8eTX9M0cU9ZPo+n6J/ mEDwN74GmPL0s5QwYX60paxdzfeVqAyqQsYu/YOW++D58wKWNhYaBPJ9ORHRZgX79Q/eVe2E T+qz6B8WEt063xcrGKDUP6jeYvy8+odzJY1wUAzqi2BUHKSG3lsim4dRYfCriicTu64H8fZl OEt/2SDemYtheyLNxZK7BvEOZ7cR9SDeGVj4pkG807iOCeJd6lwkiNfd6nqDdoolV/fjnVZp RxDvsgqxtBaCeKMq7iynDPrEqiK4EgziJTWmK0/4PUG8U8FUZUvFPynFsFq0Mpx2jSUtKqQg QGDaH8Q7tk503+hWAyGM7hf3PY1GVhJxbxDvtNAnBPFy0kOsEUcdTpPgKSdgaSNBsRxZ9kPh ncxLXsn7B5k2JBiJZGm3Q60GiJiTeZs1sroRibZUW2v9HivKTWvl85okEgzMK3lBPs1wu0Cm N0lmK3dh4Kno7LOb7F6AMoi3OEaigjGqt0KzjSDedJpHBfFu7q8pNz3c2BzEGz/lhototkcf u8549ZFtN7ZZcJRMu0fqyeucG8QbPi7euU7pT/9++/FhzNsf6v0PLy/+9fPbBFi84sR4dgzw ucG8J6UwCiepd5wMEbZvUZwtN17RKOpOfc+RbOmVOukmrpa8dLW8BpxkfmNCkKul34irdyOc JoPZERE8hzjGhe7krKVOqmps2zHNcOJqKY1URMIRwcJMIm/iajkd0tPVKC1vXqmTQFdLdU9X y/unTlItm6Njfr6Pn1XC4oiD05UJkXCiDeAMMeS/UXNQcJsuAOgMEeokzhCT6mGUiI7OnoQh ZYIWxFzSOZmWO+a07Ek+k0xlx1w/e1KPe8jG4WYibL5jbqFMCKtUUyb0dE4tvgRrFstV4ZO5 McsRk8aKPJ1R0yyejBMZcsaGL8aubm6L92tajGz6i92d8AjKBIQN5rjQXYC2+IEhN1QVU0H8 bI/Mx+GxxlYzTnkyk06pZuXCkpHXB2FX5r3VGJicKu2uWV2A6JLlqCaXFPZMMwLWja/OrWeY 3VcpKDnWVEAQYU3FgSTLOAW0PizKDp1JO+ZBLkWgfFab2ynQrEhOZeGA/WSJyoxTccB+NrKm XN5picq89MUkisaqCzC9Aa5mOqt5AZJ7j+IRPkAt49Q85oIi1bFPNrNyZNsZp6bnYTNOIZot 7xwWv1eZsEPsKbUJ7oOyEhfsGHE1MDicw76+v1e8/aM+//X2Q3Wfzfc4BVITohKFqDQynDZb eZTwEMRZT6R0TogyJ0WIckO2MhkhCoQa9/SVyOiXTmT00CnQO26tJ0j/p+n/mvQ5k7ZqIEld JePZE+hxDEleUcg9aZKmVzzzoyrZgCRI6E5JkG6lZMOtaI9VsmFiACWbch8tbYr85OHpCAi7 pxyPgkq2UP5bKNkwoDLYULIB/gdp/4+TBCnfUOg2WcV++yRI0sl7UBKkUP5KgvSvve7GWBj3 39snQRrX6cmTIIVZXCoJkm8MTIIUM4tOxMzslzYraJYC7XPWs2jsR48MSoKUvpHDpg+vMmOk lOnI0JJ7GftkRFy1izftVBUY2ZMmQYqe50yCNBezBmnF1kDwawVLYy1rpOJu41ghO8bowS2Y 7K2TBzuMsZWLkzbVnA5RVThpK1JgEtl0qlO40Z2UnWgOsm9R3ytiLOolVclQMcGkOFcixRLj XfyDPvhu1Wxm8oFnlidWp3jNaDrNtCYTB8qSOUT4f4OOzR7SCriyN/HS71QzQsD0NXk6smEW aWNjTdMvaBC+pkhnNc3/sFSQcTKXsTFfc4qgOKQ1XcFUk8v5DV+hn8e3KmDdOwnSw4R3WU74 9eFlSFePA3e/JfLWoGOUALwM5sSIBjVAeJdlVBpCTVvDQxaTvBX14XinBe4xrq3WXRiaIab9 gcK7CPGJ31Apb2mBeWRNuEV4V7RKNXgZwlG50gWJ402xO7wL9XB4VzK0JIhqItX0nS6dGJeF qaT+yRprkZ55PnmP9DoZ+xLeBY5sJFEABEmATJOhHh3eVUvss1WQhSEPMg0Q3iXy8C5xJLzM 8QXQyB45vEvcPLwLFQxwRGNHWa9e4V3XDO+6d5KGWyLUWFpDqOFHI9QQCKGGtl3jVamgZMJX EGo4iFBDKgg1lku1glATvvS7A88lGHgeXm+EaEQimURzuZNkgnvEMBThJdxtSUuaaoKuHng+ rdJRCDWLdIFbULpYESaKgqp0MTHp1rncoz4tiBkpP5lAAYwUCDUS7ZEuQJrlCDXK7Aser06T r0oXmGXSBWZOujhGq3f6yIDv/6Z0UW0MnyBdrEwzJdEe6eKSAlieDrTkBI9QQ5D6LRFqnkKw uDes7o18vf3xx2CxAlvaHuXrPcONXsDXO7RFLCRWuPL+kr7es1ixFJ2UAIowQfThcCdf70dL ABVWac3Xe9TZL2mRi+Wq8Mkh8vUmtFdMoZQ9GrLi6z0yNuDrPfxiU9/fLKtSYIwjfL1xyTgR IQymTeFoCXoHDwxZclvBSlPB9FplAbqRRP5J6e2pmi2Az/RCtPtrdZojefHcbdXH/Shf72E1 8+xdDV9bgEhIg3y9+aomYFjvDYFnHhlbczUO67MCFnimXmcqmQeS0qwFuHhrO0W+3kljsXew zX29pyWC+Qzy9Sbl8iYFpeP4ws6iOpA9KdCqs5rpHY1dcUOKOAw4Bx2cxy3jFdHumObwaiET LgX19G0Fa9TzuJUrUqdZ9gveJGKVZg/t6+3O4S1fb6zpmq/3cKiuDKJv1sZwd1dxz+6Rn+rn T+9Gffja3/78j+9aek93UvcaPy0blsUcyoaFNX+sdFi3dlJv3C4Iit8v+u3T1y9ffrr/Dze8 2Ts33NNMcJqusqS7gLNmgQYIl61/1F+BUq1nR1odgGhVcJD99P63+vxp6DNyfKfeS7ba79Eu 9pzwkPzJfv75/c/ABP95M18/eT9ivIbZwCUP+c+nPReU4qsadc1asgYy0a5jTJx70pzsnH/8 TE9yzj93fp2hkozzCwQOJ6rXE0x39ZUT5Em97U9Ew2CuRTvCWph//3j7/s+nH/2f8yGmLxin QTyOt5/fgg1CRBsc7C8bEECwQNyPzbz77+fgWv/Pp3f99Z9wXAWcj67W5bPGBJykmjozkIDc JjFarqdC106M1inauI9W0CEBQIY1M9es99mXGK3BUjM4kCBqq0iM1vHZASctbwK+8S8eSPBs idHun7zkYTzXdmYwgZhnt+eaWUmMZsDEaKiSGG09gwntVWXjHJHBxDIqtGiFNIfDY3mueUXu SON043DtVaVNsnFuochFa55rJk+MZqLEaDOJ401R9Vxz3+9FaRIwI4MVdiwI+p0wiYkenWqM 1bFUNv1ix2fVtox2eK7hliza0YIJcwkgZe2K51o2iWSoJ3iu6WJkuwp2KCUn8sZfZtb24sJe WNNfiJCEMgponqr9Zm9EQ239NUvBrv1lXSQ1NRtDBR30BhLREpLjIgtQK6AFA+SNXS77yb08 18JZsC7LU7Qmy9/aWtxcVdaYdkVd1uCSaq82/fZzUQ+wBFXxdAkjN/0mEkYMuASbimczqq60 9f1T0dYsmud9FBJGbK4CJAxByeyBVtkLQcIovhSghNEAonkVFoz0VnQSlaK5nUwXR2CMR2bn XwxjfFolIBLRAsYmJJqqpXJS5rO2DlZDi6VbMfKBaMGgQJHXxQR3qLcAgFbxHY9fTZ4dRlXI Ij5YV5PGcqMqAgC0FCxIRQtQN6oWmchguKYS5D2bVRgZLo2q5cgIwahvE2NTBqAV0JmwiP28 BkpDrDHs1UQ8DANJGU+iYjKAWFza+UsArdDnyjSLtYr4ezCqJm9EyFJzleoOWGY1FqwaVWFY 8Kix6qympzCqVqaZ40YFo2rWFs6mKWAbKkSRFaPqDLFVneaMtTXRrMTaKgoqI9uFtbW9nWCa iV70OYlQUaU2zVaVnJCNA6f7q860SgAJGLLuchBFzaOPxrZ4ui3z5DXCp2ET0wuTh8b0uo+h 1jEWZG+l6/hAJ4OCIckCZNPb2x/vP9wavf18/+LoPUJwuT++fTbDCAK16r6mT4bBdbTl9CQr n2i5Hmb2/Ysjqttpb/bne3DfTay8iqxZlY4e69Na+F54Wo+Kp9XcBrQ+v4Aj0AwmL2oG4y1o BqO2MYOmu9TmU72izceHwgxGO2YIbAZr0rv2VPwCrX860PpXft7ZrPR0+Xn7+sbBTUVJtWDX L1dSoXvaARtnQBdggj5Pfl7KNCZttnEeOj/vTOJ4U+wHcLh/fl5EQ8TqwPMFE8Zj352fV5k0 VV081KPNYKfm5800EaHBMsSytzoNsXQFLwCHaQFmEr3y817eDPY7xFneOz/vA4kn6gbiiVoR TxQonpiqeKJXvHQaJSriCYDioNwBC6E4hG9nR3v6NPhSbsyi6TMUB9iGdlnxxKyJJyoXT1Qq ngwkrosnBWcVBYV4ki4udNLvEk/grLRZY7KZwO9QyYRr4ompiyd5mOdZ4gmcyHX6fjaIcFna J2AhIBJPxgKEUwRUV7BfPPEm0GuJJ33TEAWkFM7+fU3xZCGRRlndK4snvGAAUDxxovXziieP KV+cBSeOSjhxcQV94ixQvODEB/ziVgoQTjyUv+DE92hHhNVcU2GYJdN63Q5OfFynJ4cTD7O4 FJy4b+wx4cTDyFbhxMMbLzjxXxVOnDuBk/fECiKoYMQeuOWtaIQUiFjaOPGdU264+4UKYijh 5sCxe51y4Yr91SdaTU5DPV8u3d8rKQyFdcuDvZ3EvUGCOtH/dfj/dJpLeVwXdR1AxMsKba/G LtgYLGDhUsBqriBglcCdmYDlD4u230qANAlY+DgBy8xwWkkxNYndVlhjtFFtQ+zklJjpd3CI i4gFLA+oJWTHfYLmWMCKe8nttnMdQ2Yf6bQtncBpTeUk0skAdlscC1hLHVERsHAhYA3ltOuQ BO22xJia3XaB5irstrim3zlGwCJEiUEFkAhYVCjWhq/DrQSsfJ1qApZnrXharb3htheEdJD7 8EjLSt2FLSlKxi4k6/JP8sRdLHu1A7RDW9OkTdNwhljLim9VlmSVNhelWZHC9fEP8Vdjv29j xPsNzK79RJFGtVKxBt6beEqePH3WqI4yyWSN+ccdUkuYbz6yBkeCvJPZu24UeZejAGWN9Q0U 9VGbxBYhckF+6bdZm2bZ2P5pxnXn7ghOVsR9LLt1AeveuKVa9Sp4PpIBN+bH17cvwa1ZeNfH djbNrEhcO6BL4+eQ29IiiM4+s7FZTWYFVCxrDd7soC0t/HTIbWkAdClUp4Au7XEtHm2W2y7t I5fNv+YjRyuyFhyPNtKyImtdBLpU9G7nYDzJereELnWrlNvSljCsPAZi2e64ACGc3jjmAJ6A UXXrKEa4mAt84F7f8HqYShE3QstNEf0aBgebDAOfFCMrVj/e9x5YqxiZ1x93vUgshMTI3hSt 29hgUofhHHZWMe+1aYZxrCxANAlHX1bYhXDyhvc/32qMjricOlL/zadVMpM17Nh5EmL8s/ho zTRze4jr1MyaU7Pod2N515H3I4oE1/p0eXVXSOXXxkEdH77JK0c0xs4aWUQiTjjPyGtoEqDW 4jTMEotW1/LPhX7TuipjDSJ50XpNNS95OlQna5V27rT31ZFtF0TdhTiJfXwWYiPiWVmuFUr5 vGlzc34UHlFuieXUiNGTo5CIowyxeyWfot55kIThzNqIqlHd4wXVhE3ha7tJm6+fBtTHMW9B lVZhW7hKX9/fvpvPpvcz7b/99GTiIeHBSneOsb0J+eP/N6IS+k4Hz7qwSsbTCNcjXF4RPTeJ 6HkoYLtLRvQI0XSjuRwAtqtE9BwJbIcYU1gVmuFWMSpbA95WxnH1h0Ma0TOU00smWviFInp+ c2C72+U8w6KW82wnpl1UB0E5zxqmjGTaFDf80MdKzjMD5jxDlZxn2B2MYDbWhjupgfemsmfg YB4Q027kWkHxtGfyuUx7Jhfvihv+pb1llQfPKG/4bv68v7m37LRKJ+Y8Q2gj51nBcfNkpytg 9U5YIsflx0sowJhX0qZQllzK6znPUJbzbK/HK0izPOdZDZduIeLg8boh+IfXd3u81u43mevR Po/XXSN7xJxnC4n2eLxe8lJOCz7LOeFyuHSvnGe/JIrdTQULXMl65lo6WrAQsGBhXWsCECxc H7wehjNmNyug7GqCBVsJw5G4JliAYTh9NZkqlbqzGhAswlzuJFhgqnUfgitywQJbL3BMmqXb JVMNq3SqYAGnaoc/3+J4wULsECwMrUT6ekbKT6aVkaVMdUHBoi9GBhVUp0lhwWI1VftOwQIc yK8jWByXqv2SgkWJpJZzwiBYtC/B4lEFC1Z6fZIrKPVyMBKvdYmUepZT2fUSbSj1pI82PSGs Bu3W7fmcEZzPJ0vqieAG6WjeHDLdXqgjcInWI1uB+gUoJPNEmPuPdXtD/+pXR+s5Pjd7K2iH IHECiU7NaG87xQlOD5Nub/b6jMJaNrw+/TOtUyxQcM6xYw/Lm5Z3yycIh4KezjZLMjHZwXFI K9rOcZYwjDBVnM3EvSFbfy+2vDUotE463PZjY/7bM73h/sKNh17tRc9am8OM+le9ry0JsbGe Y5t2GvIhsCoRM8seJp62nDG5eAhHXw03ENEqZaORDX/G/D+PzE2T+mlqIlX8PQv9tf08kGVk rl8m1Nz69OZhatU3xknfxwtApW9kot3YWOdap27JRV9Oc+mfMaF1PjL36tCGaKN+iZCqKbzD SN4/yqfZo9CNwSgqIFo3vD+EVjuCpiFP/fv11r07Ztc+22NjU0rnYd5t3y9LFAoIEPATBtAL Oe2/Zd7jZFyBpFYO6+1HGL1BtCEkdrmYXg3dLVIwn1svlmh6Y1qiYprYVyGND5ISwo1T98tA wtO38zSnbqbW02kajLthZMNqptMcGpGhgEjWRv27qi1WyWpybRs0kXkp4KzVYtnoKLA1VtMb DE18XjY2dReNjLG2bcRyFMxvDH+6eTfEdV9nDexmpbTmTozBrEGdR6BdDilXt+PLyATz5CnA icmSNXWZZi9Qh1UoaETXRISQjcGd371ESlxkPsUeEaATpfM2mU+NMDLDTOiub704WdAs9Ceb fvozXgAiG6bHN+QwMon6eahaMdcBIAUvWtupv3lkU2PTgJbWfXdcTQ40sIB1bxQVb/QVkNEX xUbf09PVpzUYzxQ3waXD03KStMZyokXLoniNRNIKqbuULCStVrX+YwRYURvH5AqUtIa2VKG4 mSEsXpJW6vPZO2ELlZKWwcrdpviNsxxNq1SLrkEXclKbueQSjZ0wsoGzJYANP++F9FUe1x24 f8fIBucJtBWZ47dx2n9bR62/Ls14eZAMPywgHfXGjlIx7DsoqxdpXnrHoCtcpPMDH0HeMR7L efVgZ/u9Y+aFgW/QhUI+4+Sbnetpefur36BP844ZDCv38o4RVxWFRLYz7mjEcl8tbWpGLHOc Ecu3BRuxOsz6lk57Ju1jxYhlSiNW6CMyYtV4s9gzLallfJz3TGRNCMYleM90hlqdZnyM5jLt mYpl4hgj1lGxxtV8TJh3URzE7WQhfYQRK8/aiGmwx0X2n0oCmU65e1OcXzCxDMXP/MbEpFtG rLZtk4KEkXIteGnEmvdCPgl4qEcbsbSUxcigglNkoYKqAUi+F5eRH+sjI0Ia2hJS9Ls2VP8G lL9zSt+4WhfO2rjDVjeQaE/WxkvSTBR8lnOCFzWNZc9pxHr8hI1nwcKJ0n5FryB2l8LF7w0L h63pIFi4ofwFC5fbr6qg+UgL4j7qOyQJ2B3mRFi4aZ2eGxZumMWFYOFCYw8JCzeMbA0Wbnjj BQv3q8LCTbWIEh6prYSrua3I9GrsV2wMFrDQVZU2s87lzkqbWXGg4JAmwvcrbYa2JBTSxKho ekFL0JLQR1sPaSImVdpMfZSex9i9KxpEC1Er9N/Q1sdTV5Q2HFLaNLpdxKNUceivlnBIE2nv FtKEaU/AkCZsGyu7VNS6rudxtEprSpvtHRtVgT2PNxL3xE9E3IFJt86SgA4KjQy3CUABpLSJ 98K+oZ7geQznrs4LqtPEa57HlRxDO8Xm64Q0jQ6/pDd8MwNDPM3hj7XW4/d3ex7vzTF0pQ/g yZzwwEqbp3AdxleVDEqc2IfND2Q53xfxXHAmrImBxQO+Ih7wtsgP5NXlNsoPVNkEgB20qwUm HWHT8aIO55xlgUnXyQ90EZsO09ZQ3qSBSVe36UyrBOcHGhirWOmCxOm5U0lfuNMeNBNkMliU x/a2aBGmtSM/kEWRe2HOhPnRlrJ2LT/QTntQIVHAItVp6Qv3fOqq9qDrfDeJUJ3gCFBQ7LcH LftuNAPtmmbFHlQcxTVD5B570CVphgsGyBvzQU0EqSfOD/T4RqEHw069ZfwzYTVgFXU0sAqu aCG4YyDIdcT1sQKsokBgFVwBVvEocPX457aqhQDin1urqvHPqLedhOKfw1zupIWoxj8b0pgC pv4W8c/4DGAVDGc6XpEMioI1UWEL0nIgHKsAq7SpfqQe/4wzLYRnqotpIZSBUwnmBdVpsjUt hEY2j3+2r/jnLP7Z3lwLUfJZzgkh/pn2z+k68jvEP98fse1hlBg7YduKTXGMEsOsKDEMqMRA tpbkGC+h1YmNg3a9pmNi4rNg24KkhKSP6Lu+EuMo6aLqToKxxegO0gVaU2KYXIlhEiXGSOL0 2FpNcrxIJqgFJZPio36iEgPtUWL0fIIBzw552pdOrSlrV5McJyhtVclklxKjBvm2VZB93KqS Cc4lkyOSHO8ayJby/zjJpBBIspFdMsnxQqI9ksklRRVaMACkxLgM5NsryfGKfHFv4DbVog5F AOKf3r+/v1nzo/8zB/Q+X7oYg8/wJF1kbEUq0sWcMq7AblOikC6GPlg3SRcV3o2lixA5GLIS Qdhto+NpJl0g0XWAdBFtuFG6KL4ex4eKEUB3EfqfpIvs/dkhN5MuGGrby4QAC6lHeiXShbam KaSLW5hIwirBuouWEctTWQ5lDhOSbX/DUfjKGiD7hubpukjZpgXtLj34XDDVzcWNyRBSBtr6 jw+SEi9fm1ZxrlqE0oHwKCY4FPSbTg8Tbi6VeWORqqQZvCHjL+X8cWu5iGJy1+aNFhwQPx8Q tQIz96nq5n6Jxkq0rC2XN6NZmV6s4rFSDoTEqUQwwQTKuxMGIgkwkJgQHOpunTWWgaBOpwNp Opn2z0wpK8IDEbV510cWDSTJ+egGwqhKB4JbVPQPsQZrE+Di6kCyFcEaZA2AIq1ZXREmtxdg ZSAo0aINhKiwBqElRZKB4M0FWBtIm62I+2/afwMxbb5ZpqfQDZbKwsrI8PpqYukun7kH9nXc fvaJpvtln7xm+Kq4ml4g81Wd8OYTp/AgzfZVOTF8aoZ8Me8/fqju7ef7F/Xtrf/65cvXd//H t88mtIRZu6o6E5hzj0Xg084M6WLcV/HtM/F1jc/8QqrpRbiVPZlz1oTKPmmNq6g1CXlYdK2q t+o2o1VwnPXb1/dQtVlNpdJRwaSvGHLMvH35ElLUcLmajYR3mntifftZzlF48uDqHD3yQ7uR WIcGEtcz6xBKKXZtuJvDF/X9r7cP9em7iW4ECrvq1drnJdhh7ievlu2/Osn+3z/evv/zaWBK t3qupq4SmjBpfOoXpfVyx+rWBsrdOaCGS9L//O//5W9VIbsNM7UK2ErlN024Un13t5jP5vuf X3/E+XhWVc5uhFpP9f/61P/lp6V9mqXLTeqV8ec2GX+aEtPkGuCg+S0WQZgmPpPW6k0Vi8OR mCa1i+pV1ODTv3skkGm6RA0+/dYhaUjTN9NFNS3nJ/jyVY3svxCmyV0z/rCr6ndy2NxSv0No L/yn9+2fj0/uHPz5/vlrOHKJjPPDXQTSxKrSLyV43FlU3TIo3jJxWyWkSXgultI39DEGDwNb Bu/ZMjZ7ztky+VwqWwYfuWWO1u1491c7tRWn9BUN6Vq5JxD5spAmYZVg3U4A+JoLJgqlJhUn xGV0ioX6goLFkk6/VHOvFo1Vc77OiiKi+0bjqbt4lwBap82cr/NuqY8sF0xziuiy9c1p1l9N DFV2LliWCMaKg3K+yvzuWRQglk1zPot4m5i/vEid+jA5qTKr0uY0gxIswfP22ON1miXdOHEs HkgQqJOhegk5Vk7LrtZYT4uBZDsAcaFi22ndZWm0Psckcp+AhIhBrk4pg1kP8tmQ8zUaVc8N kSnDN23aupeiwQWwCxdVlLhBhC7210pj07A6xbDQqk8a8+J0cRTAq7koQgcidrY93kK5MjJx YbSb+Cjwwv911DHT2MvGWtV2tFtDCKoWHKXb2Sf3QIoDuqk4oC/FwT30AOEoczXM325OPovw j+mS/P9v7892JcexbFG0nu9XrPdzbh02EiklUI/3APslgb1/wEGJVIQj3T0C3kRk/v0lqY7N pESZySSztWSRVRnJJVFsJsnB2YxpXkWlHZpkB81eZsa1/V3JX7392GqRWPpWf2kRDtEihClG yD/+Kg9JMRJrEWhX7Jc3uN/qZBVqEaYtMONKFG2KMTPqVJeMyqep9rUI48ESahFseZ9P+NIi hFqEU5lRzyaJP5IZVbUpZlSxmRlVQcyoJeVCFA2J1Aj2GwvMqAJkRlXJ9H4SckAdfhizxJoJ HVCth1adDm/BuOp51iJmVHFaej9DRKQgNYLJTh6tGViNsKMD6jhLq+Etk9T48JOXiLhUFgR1 pAOiK8arQlwQXiamJ0YhXYPdmAQFriB56DPFjKqi9H475g2WNRzeYp84OW+w2xCTMKmqGd3A i/Hs4S3zEB2dNxi8rHuSMJPw33ebOyO8pV/kvWn083dlcHBjzc7n+Y7exYQaJiB4UCa/GEx8 aCZUihqGACbUofxiQv1nRuhK/w29ORbt0Uyo0zy9NBPq0It9mFD7yp6RCXVo2QIT6vDExYT6 zplQ9dwQgVR1X6BzVRa1YLVUHa8bfW980xNWt50omwZbBegM46leXrYy7NXl+ESTumhEI3Ah m7puePFWm1ycrSAah7c1NVkAnfcIxiJsmYPrVV26f6Bv5rNiSp5g6Pw7Vrkvv80Oo5T63fTf VPUbdSt3Z7N/E3Vv/gupJAWOW+v45pzT0b5ZIW8C+l74lQ1vqna+lJk3+5SUb/6btmB8oW7D bvZvinFE/Dd1wfgmq6cnzAvN1L5FgHU2E2pVyqqMnFKbqgy8UmHEhbaHCU9aGqg81tLgLCpU r7wqp6zJ/vMTOA6dPfSv5R7WGt8p2yh/zWhcv0GzOZGQzEWGzBGNJzug2VR+/pqxXScG8iTz 1xDp+sYf4ezhzBIUJpwdt+OezQqhNGpQyp+GKW5nkj3ASLmiJJh9HMjUssnpYYIRY7gOZBy1 cTul3xA3bscWtIDNPxizOW6njFfaNKr27G68UIQKIrQChtctmFVTQXAIVoUAglKSUSJeQ6DY hOyYiDBuR9aM+N+vSV64TFnlhUd7LUuHy+iG0PWBiGfTNCSPvTT4fpMIl5G8Qn5DSihcZrGb zi/Gj7d4QfQNidHpgpfR5AaTsTZHf/dVF5oN3jb3tWz+VyIlq3BckF2ZuxcSTDnUTWcgNIYV ed1MxO1sXJuZBaKTVduWhXNorKsHc5FP+N5u8Tiboyjs6FtHDfspA/u+f//1p1EyErTkoVI0 FBsnAfFVfvqsX/71qfvy68fv1mCvdOONgwpbCl3SO7JVpc4VfP7DalUnHwerG1U2/omna1GF 8d7oP256Ib7JT80vfegaTwcql1xHnqQPx4Yz7RGTJCqMuROwpsXtT/ttwpdk5j6foqPCbwjm iJkPqW+i0cNqXVD+/vxN/vG3nUzzLm1Sn/ygvjMo9p1hD1Dqh5dPdF4EDu1w226MwNHvNJDv TEFKGWcVHt4BI3DG42m8YfrlxZVV+PkicC4aeo8t/Mlp6L3na4hjpSsZalHbcp5YOGRcOENd Cw40pi6CuKz8LDWO98O4cMLyhGpmTweaAs5SQ9ApDG6309BPQ+wuihwGNyiEJIPBrQt+vqy5 kTJJf/2gZbhI8YVIL3BgAw298m7XflNd8XPvDHvT0NN4zEAGNx4yuPF8Bre8DDcr9+++Zc/M 4MYPZ3D7CDT0L8HgdjL1PEENLoXt79fu26e/xJfP0lwlhdv4BB6nW3EFaQFcgTtaFQlckXBm J23HmxrEFbQv9wF5/3wCV+COdDDvPJm521Lt2sHkM8fkkkQcbwjIhz4CgHw2H5VuXYMydifu NopiXMF5SXEtR2XxcdxtdpZgx1xZNm052q0T7O4IoWjMoV11kDjvwwUpArMN4qFgAyrS/i/h sWbmNGrZ+C/dijEK6IQ7EAqzWAEbHmt9+61ALtXuGDjc33rLMFYlkfpf32x/lp5IVjYMLy6i d8N+dxo1NkIUqTPS3CuD2ewC36mCLU2Au4Pyrp5EA5eyJN67YVMtX2SOxWFsWel4dXUhiyAp OZEVPJtapjALncd83bwd8gxcMTXEH7Mq7tXCcnLGrOhEFXTTGLKjboZTBC/0WpLIlEvi6fUK agYY8IZ3ebIhczeDz4Utg3rlT++gk2WKRAsOTHOJRSuUDJsaygqvMrrZPxoBu7lgxLhL4fJj x6fxjroZ9mphzIK/4NVBTI5ZFijNQj0hyLPnScSa9pt+/0/y1QbJGoMRScJRuw2b943W8tPf 4su/Pv00quofn+inL+ov9eWHBcQmvpenrA79ZmONB3+az376TXz6+YdthFMJ7o0JSfORXTBG wy5+Mxrq3/4aK9HvWhtC0nZhxdUxIXz5/E2J7+btP3//j/l0bZpPkopuK8N23I2uvP3jz/9Y xb6x99D0S7yzBh/7kv3sdyWkDfg1WJ6k47F5KzqntTaYewpnTltoai12AD8fRmsMfTdaWGrc oDr6XlujeuV7+1iy9C24NJas1kY393elv8W/7EhVxpZFkw3glbCGi8/f7Bqy33SMkdRYL5Lf 3Wz2vPdrtPK+hqrHGFnvC+G/YzZezyT5kmwHjDBmBMNQCKg/Ptvd6D9rnJ8vRnhwsRccY4El sQUWP8ACG+qBEGSBld1+7AUN50VTJ318rTLkbvYCVJYCC4C9oKR1NecN9tgL+nZZRdSPsLzq Lg5EyAJbnGqBPT+H1nHJOTFPJefMTJ/lvIOg5JwMEVZVVL1Bxle1kJxTgck5USI5p0mfBSTn NN+vG1X3CTaANVO8+cbXXuNEm8SaIVTiwZAbJudU5yXnbFGJQb94hNpqvkMfmj7r9uScaCU5 ZyRxY1+74RdbVMcnaJSkKtxe+oJKJQyotOKRAXWhZUOBteh7Nk+vqZvZC3JTYCW7WSwbUJvQ gNpcyTmD5JzN4ck5aSRnoSTslwLrSs75LpNnHQoscIoWiWyjRaJj+p4YWPCCcJgWiSzQIpGY Fsl+IwUsygYAFuOi7FJeXUDWb+MalKRFYghXAgAWti8nAYskLZLJ+u3E/RxEizTOUg4tUi81 /i7KS1S7wCKkRYokbnwxD1hk0SKhzi9wBSkPWDySFqnqwCAqB50dS4s0fxc5qNAcwYbPgQOm rpcFFvMQHU2LFFsSQ0nogUX1ksDiCWmRnizlwtM4fGPE8qBBJNH5Dt/6G3UaGrA6cvi2pNmp lN01BA26knMsulKlGBNBh2+RdPjGijai8aDB+Q7fT5aye5wl2OG7F6xopqMh9vec3JTdxeNS dmfkSujHXE4MKMGjVRPBCl+0kw7fXvS219TNDt99RoDtJ1PAEjAckaG+ou2kr6/QBVfK7nEC piE62uG7jAQgrMyyLWJ8OXw/Fl/wh+KLkRjrCbQOej+TKqV1UJvJmGVC61BVdVWC0EItaB0U SMYsIa2DKTcsAWkTYFfmax304khrHZTeo2CtgzpV65CIJdMrZ4Zcx0ELuaZ1CLevBF5YMmcM M5U6c1PwQOZoHQqmEi3ryggexAhqWgt5Td2sdZCWHO2Ow4gvmjNwaM7AG8wZefFgW7UOfUNU WWC1gdn5ceYMfLw5g0MrwJMEAw9UV76k1uFJkcFdhMyh5xB6DHdDHEF2ETJfhMz3EjLXxj8k lyQQRg8XIfPjCZnHJ8Y/xN30hmiujMa36ttbBhEyey8oQaLK+mMZl8odXn1V4G6QS0e5aufA O7ib/cOvScjcS2LZMlJfhMwXIXPflnmILkLmBYB1NiEzoXrjN/DTxBd8GhJQZsTl1z5PVo75 ZyLKci6MdVcUU1x+WL5g/sEjyhruEV4s+1rebe87VPg6mql8Nv8E315y06awjqYAUFZMxQz1 JXDTnvKEnxWXjxCKdTSopHpzHpPsHknFTGPzzxhHKdSslh9/CR0N1euAt1UYFt4BEeRuWHhQ 1+jMAYWFR1MbPhpPstfPciGONRXRPJjCq8kBZgwcR+ERD42I9f+EuhkH9IJWLj+CHDeqMvpN FwT4geO205hDp/IwO07BwJQwN4EUHQsyNeuzN56AuVeJGXECx90ZMf1Z6KY3V7Wf1RsMHAdj zPt5jh5dBR+AaEQTAFVmH1pAMk4nRCtYFFqd4nBwBmJhAsZKwpbR4b95WHs6LDyiHwAG0WtZ 06RXQFQZEHS+0s0pMBjRYHo5ICte1RiCRanZxP7q8Z6wNO2LC93/n1VIDSJZ/ph5w9tT/zsD UdWyZtET8JiZ2OYNG9zY1E3KwXXME75hT5OFqPxKLAXl93vwWjw9YWgxnt5uaHPw4hCdbtWZ yYjFO2LwzYKPYugLshJD346pyb1Q+JYuxnNa+Ygi04umfrZI+OMotFnNmHQEztqlF43asqxI z19g3jGy9VOD8k+iNTpsI6KWxWBBwltaL/FOyHqRd+LmqPDt1M1Wg9LPwr/Vt09/KX0R6OMF qNHPF8ko2tsC0G/t2GZhefVQ9yv4/Ao+BzUcUfB5cRb9t6x3DT5nTd07jx4ffE4rvVRB+u++ XSKi/+7LqyjBVNiuDxl8jtqL/vsJvMHfDf037xpalMXGCHQOLJyuZBI3rCTluHCci8XZ9N9g oBiiGtAT6tN0Pjn99zjE7qLwvcG978RBZp1Lst3Hn7i3VvsDL/b2l1ZU0pAPfPwFlRUp8lFM bqb/9gLOvaZu9ga/lf478EyzFULR6ziMXsfL3uDjo4WJ+88KMlvRk/Ute15vcDNEF/03+O49 3uDPH2l2NrENocLmPeuVbb++Deo2UrrqDxhUlPvQ2qCuoJONsfKlbLKZLdPacH9zzrUxjnXR Gqa1oWxHKqjdbIw9b/FJNsYnSvfqzFLKxtjSma57mh3viYbMvCvB3E6VOVbAoTJMeFfVXcxj HZNTr9kY3YJokr1+wjZGezuqVmyMXNVl9ESWjVF0cMZQv2V4yfrpL/U6mICKzO48uJFVXWXx WI/mSBeI2YZEnwPhTt8reEYSNkbziz3MQJZqNLNkuzZG74kUJzOCbYyBFMfk1AvdjCoLe7WC nUb9p2WpDjsRWCFVRCQephWeusnjEQmeAMipowlImyPHgrQVcs1eNjYEoJ6OrZC5KyAcM97y NhwZ+F6DYnOkZ2NMWSEBoR3NkU5DuGgAa3NkhUx1czRHLoxZbIUE5cwxR7qHl/MEnLZ7o40x A/aEL91rhLHHzcL7bbFspjTb+JqZsucfT7N+32mGejXScL24IO5vumxEsGtBv6ffau2Heqar 3Q2kuyUPfiEKbo4Z49Ei+EJMN5WxC5OkjYV1dUsm4bUvG+k1tj5p7me4lLubCY+1ZrJGMru+ fsWDw6tFX4JG0ZoMPbRr22YYMMav8fq6sLZe27LZqBLT3lT4XTf9j+9qMvoR49qQXDaiZWTY H8x1X7/8yw5Xb2NMLtuWVHy0uLmvCZtRIE0Jv9mUXta4lgM7+edvv9Sn77++fevNp3JpQ7rR dvpRTaD0mAzIoTIGPdwEKiirygIwgRKlr7MJE+hkGVh07J5aLQqKBbXfiDIgF3OQ+5UBuf/d bgKtzjSBnk2TKTjDyHcls+dpWRpkxleiITbyZBqDkR8NMTjGkkEIAPMnXlg0xbhovG/UrA0X zXgvgxaNV1fIk1m0e/oNpLIU0hsWDblh0WBg0WyNObXREMN8rWc/PkRTaWYJNn8aYfAutEYQ IvftIpBRDhAm+Dd7qhElrYVrKCTjiGZUNnx2asgGf+5EN7M0KWvqKHfM/Mue6EJFGYpeSVRW cc8gnOnPnVT6AL73/v9sQ4WVig2zyTHL8OeG9M65mpRsVbFSwfDWVTCqZDMxxzx5c1jGOJuT nBlbK6prDHBpVNazfqa66hvCnGSMtqBdtPLadweSU1qHlTm8K0UfKztHNlNSMV4sdxMqmCM5 MXLNvrjsJGri2SRSC3xVVvH0BmNGnDFbnQC/IaR0G0L0xon879cEWk6enA0jwlL99n5ey+aG oEb6DSmcNKy2IaWKBwIws+uG8KyGBN+n4JjphpRU+A3B7sYaD0RZdWijpjIX+cTv3Zb37nxl 1nZ91O0qpZsjAI5Ns/aBlTs3Z2jbrm55MQ95oi82ZmZtjsBfvTuMVRKytJP75VR/iEapiDVK 5AEapfDejCCNUtmsaJSwzxWwpFEaT763SKOEMMVdlbgcp3yDMRnIknyNkkZcUsEaJX3bAzVK WkZBjZIt/xAaJQxcjlcyukFUAd73H6lRuijW3xfF+tTkKrFwQB7UJMW6xA1henKfy6k+SbHO edHxggt/4Tw3xfo4xO6iAJzqRzQVpIR7Aop1gfgk85EQevA1l2LdCORuTvW3UqyXfmW2Qsip vgud6rt8ivU8DtUVTVzfsmd2qu8uinX43bso1j9CXjj2UHgyiutLwBNxADwRC/BEgPBEJeGJ bAFcb847rlouiwQ8oTE8SSWHs2dn1bCueDJ4QmRLLQfYCE+c87ptEQlw/QHwRC3BExHCE+HD k36Ib4InqIXhidc0kKY9C56oLHgiEvCEyGIRnqh0BhgvF9y98ERELcspCJKeJuEJD+EJv+BJ AE/44fCERQIAwhNEL3jy1PDkSiCzZwIZqZuEcRw4eGQCmbKptyhOmmQCGUyQrFoPmTh9OUtx 0lBRg2wEuFQdn8b4HSaQSSeZT6GLrAQyLU8kkClH47izM8UADEwgk24qICr+mO2eQKZYRhdh Ahn0JAlk9OWjjPlEVx2FHpBABl0JZCBgcSWQWTJUomMMlR88gQxBVV10cQKZofxKIJNjdjG7 eMNUrjMvjB5uSyAzzdNLJ5AZerFPApm+MjCBjCss0gtgC/5SBQWFc3xpmCi5RLe3DEog4z9R BDqX/tFSqbqu/ZYZOrrxOyaRizGlRbgJaNkLJ5CRJsVOqYrU0vcm4KkSyMAH39mJPZ5Gv98x wh7P6UeaNKef/pt3DvZXjRrg9MOMKF4gAtyitfjULa2aLqXfZ8Et2nxbUd4At+iu5IKzuqrx 23Pp95PuB4oUrVE2H3iLdmYpxelnBCua6WiIfXi+mOE9KgjBecYmPP4lfQO33VrX7xOM58xn 3nMl9pwqHP3+OGhHZHivEtQ9awVXhved9PtnZHhHkQBsqOxF9PvPeQ2/OIPfNWfw2OIqhS/I G6ClrxP+A/rwE0XbsifDF0nO4HPcG+k9nMHTEKfxhfediDMYM4Az2H/lNv8BmskZTImcZD4S QhhfgC1z8cWO/gO3cgYf4T+Q1ZBXxxdn+A9cnMFPgC3IQ7FFnOx9R87gahsTBykTpv+O1inO YND0b9/ZjzNYfx9BnMG408I1goqE+O/BxDGxjeRyBhv+1DdHee/+JQIVbuzye+QMtrO0xBk8 3OsTlP3ICYMP5GSqrGOorFXHfRJfbKmux8+NExoKNoxQ9LthQ2gTJgX0D/dMml+I/xYrzHBE YgEy8/YCuVS7Ewbv/tZbluRZjp9IVhZTMqf6DSWGdWsKKZn1jHShZQZgYobkjOhRqycOgyHt K3Biuqft2m0+fDRqyFSwgWd5qn3+137IM0BFTz3TAi1LFSSXkx0zOO1rupvDL3R+GRZ6SMmM QwJiaHoBYpskzzJZbRlMQNyBaV/dtvfZXsempicAjURCqW6mOaKjykb4Gtk1y7AhS/w9ySEa v5vEm33bl5KcAhPgjhlXSPiVzTzLT8wZbPdh875lfPhbfPnXp5+i+aJ+uKS/hSVg4CnO1X63 WWMOxj0HRZo6+OhkpXrCxpcsg8mQUrW1yVzTxBw38p7UWihi3pMOo2fLclpoKbSXm6/y0+c/ vn79pf+/9YKaGB3sJUeZS06RpOHVV9jS8Je0lj2iV6T+Lf5lR6oyDCY02YAXIhvWX6OV9zVU LX6tEKowFB7dl18/frfcNeKb/NT80nuyobugcok/pGgoZt7M9NUY5gn1VZgbHrVa6odVcDyd Tal6ehalh8luJaM09ndgrDpLVJt6/TaW5DNSt+K6JIZk+NOwYsyC0f38139//vFd/De2rTBk w/RBPDjb6WwuspdjyF7IMfTBoV4GAWQvhdFDbbHqZJC9TPqX6UuCdrgWNsTg7gyqouAlYpNR xy+fHQtj+mCeoA9mH4Hs5dXog8/OcvZE1lB1gDVULVhDFWgNRQlrKNa744I1tFSJhRNaQ3st EJu9wAJrKCG0E29PZg2VVcNBxSWmVMwkONu9jm+1hqIla6gKraHKt4b2Q+wuivxoarQYTT2E ykMX/W74LVpDUY41tE55W5Ex7ihhDUVpa2iHfDXZ3NQbvK1k1DLkDSJhdZzRCrY5OtbQoQBh 309brGVQdf/wyGjqtjBKu3W74QOtofMQSRS8+2BrKI0EALKGYqJe1xr6IaKpz+aik6Vo6IKS sKSejvB+0+rEsBUgFFteosm0GpYnEIqlQx8Rynziz+ZI37Tq8TN7CMV+p6igqGpdXt6S5IDk Q/vYtBq8MvG9QH3fCO3JLgiFW7qX2F+r6IQhwjnWtDrOEhwV1eVZayIjTQx37Hdca03/YcBa s2ALWmtIEU9y8MSSXcPpRJ8Vc2zq+EhkpFnvpg1xDt/1mjoZaZItW7XW0CiBZzqz5YK1xrYd yFyQO2aetabffbhvAzNq/njMxtriQYyaOv5bt2Yoj9M++LULHg1EsjIRGsqranXMQptjD02j tA/WgAFb3cez2DC0Z8CdxJKQLBjVOrU2obQPCWg8z1ncsnTaB0dPZLM9BDPCwiBD87N/AdI+ EO+iQ+uwsiUuhjjtw0a86WRbwF6SA4pVJd2GCF5lJzkAou8SBV7aCaibtiEqaAiUdmL+ftk4 foF58HYjAIpev8c0eUta0RcxTe6YX5TJHpD/+Krf1/P5qfv1zd4BPCOTIEsGiRtsf6d89tjc Dnfk/Nzcs5PzSNxoKr8MZ+/TcFbGhrPiAYaz8P6NwLyb3Rr5CHnbkHezhPJu9rcylND/b8y7 iQuBmYxSCI4/yHBWd13TNiQynPXleE/H5fdjOCvYmYaz82mIj+P5U22K5y+TgditC+L54/r8 Eayhb7HNTH9jgedPgDx/yuX5S8lmuGZwoVY1Us4tz9qy4DVDsG7DtGbCvrztZzPbJ+0mLW35 4Roptcbz55+k8+1Pd4VJmy5uKJhSwG4xc0UyOQ8uabpq1fxAWAuHIVhBcmFOkudPBTx/Qx5b sO2AqPhjFvP85bEI32JlaUQhO1m6BbSoWn5TZRtaRnir2prh6LtLTTVPlEBllblNiCWFiH4X 1ZKq3DFzyaX6IaKxAmqXCUgVgEyXniTsxyJ8As+f3QaWATVFS4D6YgN+YTZgjRJIiQsOooRd 2YBJGiV0XZlACUCegiU2YIIlIyWIEs5jAyZYCeXmKZh7V2n4MN2EnogN2FMoBKmQYO+YBZQQ FUSwYZq+PDZg3DGYK8AKUhZKuNiAb2tZgg14aCrMFbBmarrYgF8AJbxLx5i7yIRRTCbMH6DP m+DERSbcs5eKQtUQmbAtv8iE/5lFJiyZpFyVHfFJjra49d5KJjzM04uTCdte7EUmbCoDyYTH J8Y/xN30hmiujKa4bG5pGUQm7L2gROw205/quFTu8FZ1NesVsLl/FPo/EewCWvbCZMKqLltG apla+t4EPBWZ8C7A6NH6q6uyl68MBlhnk0qymrbEcVUwQNJAT7zC+lT7ttOc4KlYxeO4EwOs T5PbrgQYoUaU1Xdl4nmZUswH5bFrsvO3UMVj+faoyDIEdcEvoeLZ7JpsmWliFQ+xDCYbjKfd 6Pj3Hlmf7CzBwVP9QEWSFk39vBQMpYaIyWAGJh+RweSzsI14LStREc/PWIAbpUjlHbU9gQ+g fDK+q5i7V35sDB2uAzBpO+5wSo3fT41ZBfQqMYgzgU+iMtfvdeomPEWgb3gwmGRhek2B6z0+ vALghbAhab6cqDMr+qLRIYopElFnxd7j8Zj5lU2ywgOG0pqGT6RB7ixWC1w/Y3/HpuaffRlc PxmiMT66PGa8w7GJahyi2I18ZVRrmhwzEbuRp5s6eo8nWiY4QKLm/88qVNhNER4ZY+aunth7 vKrrSJe75Eaebmq34k8v22B460BoIe/xteU0Td7csrT3+Cbd4jrmCd7oj4ZVtiVePIptyewp jpPll8/flPhu3v7z9/+YT9eGLIosOHre5BLdWeaayCUaS/YQn2grr5FPdMELdJRP9Gbn25vJ eThmjEfe8b2HsDKesyTtIdzVba8wnl7+qeG3cWWWVopL+Rxe0Jd78eVeHE3Mfe7F+BhenvDa jAD3Yr1ZrZgjUL578XTyBe7FZuQG8n7PCaISJanVND2eezFv67Ye3vHsEBgrPpT77sWt6igb YUfMyyOLBC+PuNyLQV4ecaZ78dlM4k/EyyMO4OURC7w8AuTlwS4vT0JAYu8hXLO1hePg1YSP sb4rctQyWkxR78475/Ly8FpSFKuWOBNl3fLaWzhHqJbwEi+PCHl5hMPLMw2xuyiSvDyxf7Ld 74cC6/Rix2UcEOMdyiXkldoNv7TnER0Z8xNSN1SG23ri5Y6F0MVJIS8PTvHyBJ3wmrqZl0eo PP/kW7T64/A6BbRAkJ/wLiYCwqW+m5E2riz53eAJp6mjW3JWNxP+ydFWDLXMDFGOf/KeY0Yi AQgrs7w8tH1hXp6Xc1K+OABflwNw5u2LQLpeRQmsMSUvmepa4ACsuLkn8uYArPHC8Uz0Hg7A aYhvxBpgLJS303e3Y40cDkBcCTrJfCSES1gjyQGYGwuVhTVSHICrBZlYA4yFehzWkBUH7Dv5 sVBnYI28WKg9x+wjcAC+HNYoHoo1RoP4C2ANrGt6NNbQ36jTUVGkBrEGT2GNEuIbNoeXcadu eAJrANlXTYQRnH1VH4SypUX7ZHqNpezujbOxHJd91c4SjDV6wYpmOhriLKwRRVRVMN/wOCDj MX0r1uA5WIO0k8z7D7IVvmGewBomHfCOWKONW5ZRAHPnRhFVuAwiqnD5HHzDz5N9VQ/R0dlX i0gAYKxRvTDWeJdhVU/GN2wMqxwyrCLXsHo7zbD/RskCYGLvXS4R0lBub5mOqHrApDEQuhZF CEwqVJYCq8hSqe+KjZ4hz5fXr6uBaYaHkPB3bKm8yeCCUQxMWM05ld0ZNMN6llLxUminO/gk JXtUdkPLrGQTDGSJnNaC9yh26JVH6c9oWc9/htY4/M0y9r9fw/krt3Yz3bLUo2W8kfR/sKwj GOOlrLebjsG8jXJhn488UOhZBHfGu2pxYy/vzwzllnseKL4kH7av++X1lRnqIrh7Yk1NJssd JDzZmhqxoKkRsaam509LaGpku2AVqlOaGoC/xiTiSWpqRFOV3dtzaWoIph1tEKypcczNB2WG GmcppakRoaZG+JqafojDG9yWwz28gPkCBPLXrGtqIsq88RdURuxUAC0zQpjU1MQt8wVyN01N iiFvVCW818xQT6CpmYfo6MxQLBKAWFOzF0PeWZqal1C1XNR4O1LjVZzQ1qzDh1PjYQBadGXT FEpXlqLGg5NOUp7C5JKhGoqbPpUaT7a4hYxAvGQMzTHHx+laVqnx3CnQY4fCgunMJZJXJQP2 wkwCXXkLgS4W2C+YfqxuIngQIyiAGk9WXqaXJDwAx2x3arwVDRIuSrepsuuOINCVoi0KEn03 XVn/xPEEuv0QHU2g+96p8Z6apo7GNHWPSDsRe6ReNHUXTd393iBmedWkuD379EVT93iaOldY JA7T0Tl/qYKCwrm6Gw8DLtHtLYNo6vwnikD/0T9aKlXXtd8y1E7jjQ1dHBMOG8X4KtCyF6Wp c34XTd1V2VUZWBkMsNBDdS6TymQpnTZuLPw0pC09ZwoxVAPTxWc3S06obpkZomB1SyqD9lRX gLKm7NJ+Bu2eWwsygbrvTCirv5PW3YCMABPoeA4vmkCju/l2EyiJ1C0OrR9gAp0p7x7k2vJE NHXOLMHqFqswjg9S9wnDgDKpW4L5mCqzupO6kw5wmaZ0fGdKdZyY3Hkb4eMQh49Ouhuj06LW CBKuEkARlPquL8nLZiFnRCy5i6eoq2WzkA062c25IZsLYOMLnFN8taDcsWVLfjJLE9BzHwW7 Zx0qz/pHcaXwnHVc/0fRzqMeG1SnziuWUge0ZSrKG+/d3gwXNsSf75hybfpukqjRYerJkzPL zjM2FTOieDHh8VHgizHZt8PLA5ofQyrFmIPNkvJE62uhsrHxPRlL6REOWIKeaCsAx6xfeU6B VcFuAR/rLdtQ2eqj3lZg6IQes9DHtoMXA64ksMFkdzM7g/YK5gnfsKfJKuMWfT7Grc3Ea3YL MsRrP9rfdQ9F29q+NaXpW3J8LmKvZyX2CvOMPIjYK7xoIDBvcL2iwC3y3SobQRmUN3jaQ8A7 xca8waIQdVcBxF76VzDwTjHtzCCxV3G5VYLEXu2ZbpVnM8Uf5vZgWA4o7PbQMZbHs+G8QzrA 7aGmVVeKYsq17X+jTPNssDjExH7jhrzBiIlmbc2EmDqxZgrVkCq6hw99GddMiLHdNRNh9z3c Hmoh3IyA9hv6A5QR3aoTYl/tLG3KCBhNi/NEkBFwBsFVZ2084zsj+E5fzEchXcGtGNfKK/AE yW077PYwrYW8pm52exCqiVoGFSS7yWGvyDE4M8wIiDdkBAQbsuXiMLfsiTMC4uMzAsYM76Ek mPhVgsSLuj18gNBVEjtPPAJ7x9Sh1nnCyIHxWW70FbDpGpaDvbc7TxTYg+D9B4taVoqGcKJE WLXVRMMPQHBMXTjBzSy0uCBN7UFw9xshBJ/eaWsvsmmuq0yp9UE4MW3cIZwguuP6mgpC8Nm3 egcITrqprhiC4wSc2OI8QWnZNS3y1fq9ORjTqpCHOU+E87QpZrVARU3nX2EKOje3UWjUHuUk PqXF+udSLcM0Xh3Bq752Sx9yt0eG1nOSkb7qhZY5MaslqgokWyfJiMBFJVTpPOGtVK8yKvV3 sfMo4YpzPhWQDnFZNfEg3nE4OppIrCSRKjGbvoK7f7TyCigpR68CuzO2oqIqalnPZjK653p7 GtgyYEdyuzm0+YamQpXhth1R0bS9c+a0DOvp9WJkTO0KVYkVoNqgsrpGC0/oG17NQmNIZq9I oXgl44KslhlQTRKV9S0TFOOyjsesREJxij19dlsUJfVrV058z/hKYjYVqvwR4cxxtMF6/+GO nAkTByAggrjxa8Eguq4wmBe1sq5PvK1oU47lcMsqL44d87JsO7TwRP8Tyf3MHW/KmjZu2dzN WlS8oNTZNWjXedX1yeZcfO72myivqZUiFC9rbooYYJUPAFgxh5kDsCgXJa5lUfCcrAU3eKfO fhNBsYT1NbO35ZrfhBn4RtUdHjw6fR0nax3/ucBvwvytjACWrUugIyhBJj2uD7D6NrsAK+xj DLAqT18DfP9+gMVJKVAIsIzgVIUT4nEYwBrnCQRYhTneRTCnJhpBjI1GnWhkGY5UwjfP/CWe iGiUw8/BLeNtsQDOzHC2Y7iuaepSywxexFEnMkyPe97xX7uyxLHKq/CJhKdlW5RimiszeZMq Y9hVJW274o3qU4wjRknX/3dYGSes5JSXpHtjinWsNpoRVrBSH5q8YDWTnOo/GMuEfkIfWgyz QldmXnOwt/1LVxbmzeFR81/j/zHft2Eq6IVWrw0SurpOveKh18VeE4CYbDWucKW4wCbgKqsy vZwQbpxO6JXXarSmx0cIWjas4EQf71FlKZXZSq8Kcy2ogs/JzUI7bEGiJlSudNP5zCSS2Kts ahlfTKMny7JolVKtrqnWm/l6r7bMJhGiafStqquH2klDm6rQdekuTp8ztWdUtlDgiIY7MosA 62zyNUJFZbwRbIa8T7++ffmj/ZdVLroeE1kUPWvxwJ0ADGOWPYv2fDtAHuVUPHDnxwPzzv29 hYYxwEHV/z6GuddI0kH1FqA1UY3MRTaP8qRhwyThiOprskjJiYSBllNXGcQdo/0cVDvkAy3b E71ltAUeL/pHcq+RlIOqLFtaT6MwzU40XQk5mSozKZdpKzTA9MWjcBLljMMQCnbsaja8G3jj dX7LeBdSfiwmMR3dbl3BcQZCYVpEehXwkOkFMpa2SJSGgmmzdyvrvDvp9ChWJZH6X+dR9Z7A 0wytWdniJNhxv6Ps6UFlNke5NyNl6DJcsKUJmIfXZFitJznrc26774YDMc139iFTxQ2ZCuz8 VBFvSbqy25CRzZfNAo/RpiwBKV5bTnbMbPJt97u2Y3E3vSmqWciPMyx0k5027ESxMr0IbVAL LyQ9X6zM79VUu9N20QoWJaNems1wRJLbyLg245aNaSt4WHuUUTvaNdJjFow3kPI5qmwpXzfc zWHMeDsnOhimd7rQ5llks2BP+JI9UKLMtyaV8p/kq80ubLPKJi2ydh827xsFwqe/xZd/ffop mi/qh5eKWRonV55yBO13m9V8zn1+26QPql26s6/mkB3ZGqOTDpp35IA2Mh7lcC7ISg7ndnQI 9lIxt3QlE7OsWZyJuanZUZmYecVk39sfX/X7WhQ/db++WbO7l2VZkCXv3c1uxcclgL45FbM1 //VN/Lf69ukvpeF774tAjStDkfTQvSmHc6NoTYZmmhXbrzrjDTF6JCRlz0ATk7TcMDl8+vyH XSPGeeLzt858WJmU5TTpEb5L8mjZTI3/oRuvAbpN026zZCffus+TXbSMtMM39RR9Vz9+2bHq HcbT7hu6xs7KkZagf//89OPvzz/b36ek6TIpDttd2hHT1wz9hvpLf+GbHZjBQ9x8DpW2f8nP adRhpsW63f/qXWh4ZV3SLxf6c13oAWbiR1iZspiJ93Shr7uuaWkFuNDbX8KFHmacn5BR7EJf UswBZuKC14J77sB+u+rIhb4v5++dcf5iJr6Yif3yBzMTpxdOXarEwgmZiQf6wAZYODYmQJAC +/HsbkzqOX70adYgDdSPzyF1FzPxNMTuosjOIYXax+WQymQmxqqAc2NbIfTuxvnMxF7aJ6+p uzETrxVQvzJbIeCDj3jgg68v0tnMxFkNWYsz7lv2jMzE8xAdnUPqIzATfwRH/POJjZ8GnmSy G0crYws8UQvwRIHwRLrwJLGQAFxfp+DJhjA/c3bqC3ERhPmdD08IEVylrJlVW9/ul38rPJFL 8ESF8ER58GQY4hV4MnEIe8eGe1wOauaOdPNZcCc8kTmJE5CcKIJiIVyCJ/KgxAkwM/J4fp6Z OAEYs/cET+YhOjpxAo8EAIIn+zAjnwRP+pXe44vP35VR9jXVosL35fiUycWn/HA+ZXPLpwCf cl9+8Snna0Y6ggU7nE95nKfX5lPue7ETn7Kt7Cn5lPuWLfEp909cfMoXn3Ky4Krsqmy5Mhhg nc2n/DSqno4R9mhVj/5Gk2Z00n/z8NbIihlbogYOULqQIxOnVD3Vm2+JsuQ7dSJHpr6lYY7a p8uRmVL1INoSOvPYHmGJcmYJVvX0ghXNdDTE4RUQskQZjlR/hfOSCI80tVf1+K/cliMzgwy5 lzWSUPUYIXR65ah6wJbNArmrJaryqWDhpgIFj7JEjY/6ZkTzrtTwlOfkhH8VVc95ligUCcCG yi5VT7iubjMjnU0UeUc0XLUPTSTpTPo3AFTgrvKoVb13IppI+8tO1+DVRWdeJ7+c7RkNByhx bPDRnGIhLxpu6uNZ0XBPkq7BmaVUNFxDiml/nmYhmpahNkzKTktp5+GADojscuK2wsricC0A 7qTituJJ9ldJlxO+03lxRMMmWKF67qYN16Lwpd8fkZgjPvkEiJ38sCEsJTLT4uoYmho7LEO2 05iDl/5+dpwC0na8mTQnhc/aP4ZcsQrGTiHBfxRBmAjXyujm2DxPEusx18c0m3FklzPPYWXr nPxAYFGqZUXUqxXstBi3FfVqvZtJsZpaNuKrSAEbJ98Y12LUMmBGws8lV0DQKyCya2kC3DHj Cgm/spKj9JiNtSVEo2bhRQPXq/MNhNZNSV682qs4pDCsTCTj9KpqdczcnBek1G/AclbrCpiz NuPkGzZw6T5EemM0nD5QFqLh2mIpGK7fhtfi2PQ9eDGO7fCYNC3A40s2Km2InGsNaifJobKT GAWldRgdFpS2OTqMY8Z4NLtfiPmYMuk0SDIMhXV12w/t9PJPDYdNfJi08UulTA7wraFlN0WI cS2BKu4jNd/jajHSavN47hIUdkZ+kyvxyLNGTeFjEo+Et2YERE3VRimx5Xq8FDVVCdrhmqei piKVeyWYHjcKsh7bpCCCAVFT5p1ete1HTfXfdm/HQV3teDv2y7exHrt9eddRU5ScGTVFHqpP imnBn9hWJfKyj0DCk22rElXaViWqyC3ZOLECtqr+eSnStipudxNo4eC3yFZlvEBTtipkzEvt 23PZqnBdGgI2QK2EtUDxO3yDbs0+gpdsVUawopmOhthdFL6tKpKsqMAFxDZqyp/chL7F/tK2 KtutjKipTiWUZUYIvTuU65Y81g7bqnZ0SxYKjpqyT5zslmwUujcYYrJsVW1BPeLrRGXv0y2Z RAIQVmYyl2Davq5b8muEPRUPxRcxK/bT4gusa3p82BNZCHsicdiTUSHeFPZEW7IGzMNzP4Ev ZCHql4nKVqSQjvniuOxmaCnsiYRhT6Su4iFO4wt3ewijsovHRWXbbmXgCzKb1GIhDLc2X7ST +MIzJ3hNvcEXpo1allOAwbMy9IVpO+n7wuiCK+zp7S0YoqN9YYpIAEB8QaoXxhcfISr7bHLp w/Kupuil7XnB8pCJWxcH8q4K4yyAGAeRCWNpZMJamF7aybvqPV9DfDH2+w0t+nfu44uxj+NW YSjvqu3LjshkS1QUkS1u4ago1EbI5OEONeMsLeVd9bZNHGylBqyMY0skr0onF0m8LzuuH6vo YhTStU2e4IT2osUoQhcxAJvWwnweGIr7HHQBjlmYd1XWd+ZdXXi3QmWJi9Jtquy6Fs58slbZ hpYRM2DSyfU2fjddWf8ElIysMhZRkcrnYn6NoKiWVOWOmRvI1w8RXXeo2XXMykjOQkmwnC8Y v2je1YMP+YsZ7pWY4RLyDGRYr+u9dBC0JuWT6SD0aVhbvo/opMcC6c3w+JP+dma4aYjDuwl4 BDYlmZ0t9TAwabJoeQesHZdxPBpR6CsxdDZkoYQ8ZjiRiMdhY2KDBPVKkhku6EQSJWTpIG5l hss5tcbhdc/TooJO612OQAMOGiqAdJDJ7wZPOE0dwUFWNxMoIUPV0g9RDkrYc8w+AjOc3QuW XY8oWnI9+mg0b6ym1rXwz1+9x55puXUpXAnOqTchjMGZPk5VJXkRux8FMmcRRpjGakQYfVc6 hspadZxM7kdBeRyc46bLgcjdKMkibY5OChBhFKngHChVVT9YKHY/6kYP7Az3o+lsnQN9dkEY w3iFVg5F0Am6BDtLAL9KByS76SUtmnpnKShcVukEKjSaunjDnQe9dyqP9eIRoAjfxYS3lU3q FAYHRee4+6j3G6KE3DiiUBxCIAVHCUVJnSSQ9SfkCoknYHBPj5M6ORwp6W5a7GM7kRzvvmU4 zikUtww3qpJZUULOE/1IQ6LhRwmhqSG+4NUo6gwAi3OihOxHFroZzZUj336UkH3CjQ0ZX0mu gLlXQwFPLjigm1FlyV6NP7ftgimCE90Mcxm1QkVpNnHQTQ5ERyVGJJqAuWBK+5TsZkb+p6gg 0bKs/E/rywkeM97yNhwiFL2S7CaOJSH9xBAcBN7luGhUlOE4moCA0AhJ5hwa6/B0HfOEb9ij YS3PVGEreXCeqTvic8wScmIdvnz+psR38/afv//HfLo2SXhIOlTHrKsovqeVazmneAvknMJ0 OXTByoF+T7/V2g9hEzmV9Pu/OUfVjQEgNW5QHX2vrVG98r3jckp9iHCjcxKD3ZEH62WDlp4/ ldVh2agI5oiZtqlv5gzoI5T+/vxN/vG3edcOJG1Sn3zV0KqbFCN3xmPxOB6reEA8VqglQVA8 lhHjLTaXpXisCdcE8VjGekhplaUQgeoKslgVBAHxWLWqyq4F47EazlmjD6+3IB6rL6+veCwo Hgu1h8Zj3UXljGIq50cEOKJgQV1UzheVM7CutlM5Y9kgri4qZxRN+1zZReV8UTlfVM7u74aC q7KrsuXKYIB1Nt3iYf7hNE242DGWFxnvvAMQLurtTjZCoVq+vQGR8axMR8azBiZcdPzDE7Ma X2FkU65dYRzVQMJrzPxw1dHWj4x3+jJCLaeuc73GUNlipUaj15GEizv6h/euYKB90v5iu2wk k/PgkqarVvcSwpHwCjxBCvUpgBVw/O5QsMHzCxyz0D9cqMf5hyc9vx68mRON7jrWyei7S03t Pb/iyh7rH57v+bXnmMWW01ASTPQZQeLyD8/x2bo4cF6XA6dJn/R04LqJT3rinfRDEGeT4sCR DTUHhXfSP4F/OBFMTDTNnlKFclo3vlLliBj1OzhwxiH2t5A7OXDGv6Rv9GnYMMtQFgcOomL0 HUGxEIZbmy/aCf9wI5C7+YenOHDWCgLfFVshlK+hCfM1NGdz4AwNaRFbZ6k9JF9Dc3iM+sWB 8yT4gj4UX8R5Np8YX6gD8IVawBcKxBcogS8wwnCkeYO6mlY4xYET4ovegZjNeaoCfMHNSnwy fAEabfTFTH+FWLfxw/EFWsIXKsQXyscX/RCn8YW7PQQcOPjBHDgZ+ILgVPxZU8pFfIHS+MKD BPfhi6qTUctyCkroFAfwRRfii+7iwAnwRXc4vqCRAID4gqgXxhcfgQPnfIq+42wcesISHDiZ 7Hzu1gpy4MimVWUQtzZ9Y4EDh8QcOPYbt9g4mkokkMlWG4eQiLK32MZh+7IjMtnGgcNrSVGs +WgZI3WLctxJ9rVxoDUOHKcgjm63XLfzVirNf91q4/AJ9XJtHCyV7soIUrgzgQAMRRw4FOWg iywbRy7D3q02Dh7aONBBNo6at9F3l5pqnjjHxsEPt3HEYVOhJOzHsHeCjePlAtvPZ8p7EiVG Nl1eJOFbSHTYAokOA0l0Op5SYszGgAgq4Ao3CagAJgqQSSOJqAtU4idTYhCsTJtjqKBIYfzy DlZijLOUItFhIYkOc0l0xiEOLzdZSgyTZOBRSoyJAy+U7ECJUZJ6kvlICMOtzRftJJGvp3dI wowsJUYu1V5q0a8pMXCoxHiSRAFPpMTAhysxykgAYiXGXlR7lxLj4vg7AJ68AMef97yEbCzD r5UpNl/Ah2Mhj5FsWEfLp+P4S/pwQN6aR8CTOzj+xiG+CZ7gFoYnXtNANt8seJLD8UeQnGmE IiFcgidJjr+qq9CO8OQ2Hw7uV5aCJzj04cCn+3A8GzzBx/twfASOv48AT86mBTwyz4BUKRuL 2pxnQCZsLMqQAILIRC3YWBSYZ0DeZmOpE96ltHrbZGPRLW6E7/3h9OUkZIKplK09b0JkQmTt jMtxyERusLFEyg8YXdxiY5lkch7cPBsLtu75c4EnSOHOFAOw6bvueVDPldlVgbgqWLAUGQzA 4jwDddQyqCDZTbqs/OCh8oNrdJFhfEg2ZMspux1dJCvDN6CLhW76Q5SDLva0sfBIzkJJMOhC deVr2ljeJbC4iy+kiPlCygfwhcQ+HxdfyMUXcrfrKZOUq7Ij43xdfCHztM+VPQtfyPiHuJuv zBdikFah/xNBRqBlL8oX0kti2TJSX3whV2VXZWBlMMBCD9XzTGqa5zdDdYywx4f6kCYd6qP/ 5uGtXkFSA6E+mBHFC30uRMoejDnjFAlcpBxqGaTsqQnEe9iVjT7fO33Xe3suMxRuUYkVgsxQ SBpq/5vx1nZljzNLqVAfI1jRTEdD7N8iYTOU/k7nITVXcdE/gTriJGRIH/bjX9JmqP5z66HE bTnlRvEfLXDKDDV1JuUl07mVeU29IdRHRS1DnraNsDom2YcxjTPeQwHCPkIVW7xk4jHLKngV M9Q8RBIF7z7YDIUiAdhQ2WuYofqV3qt7Pn9XhkG5qRa5sI+2IZ3NRUaovlSa/n5XQuq2t/8y VOxu0xOppfhmRIEBREE6k4fV0eC45QuIAo+IYnpnTqHkIwo/l06IKEhHa5iGjLJbmJRpAlFk MSlDfQmZlG2yH5hJeU5T5aWW6rMc7YAo0iE6JYvNRzCi2JuGTM8SbD6SpVBiwoKECYo7IF9T 9ERyC8zI1zR8f07TBGAd71G3IJpkfzV0UMof85zGeC4IADI66Wu/awlIRCKFvYrjfZJPJCsL dV5ey3DTlNKNXenTNMWV2QEo58xGmNFaSESApjr91hCyAoGT+2g8ecO7QUYnO7AgPgTz6BBP Er2MTrYzXpaecJ7XBnHRV3mtZUXUqxXgNHRCtIJFeYtw1Kv1bibFamrZCK4i7WsZdXNci0Ba quB/R0+kM2gFvQIyOq05i49jxhUSfmVuvqZozMbaEqJRswXOm9R8h8gVzamd3LuEvpmpdq2b Aqis/1XV6pi5Sc5Iqd+A5azWFTBnbQ6Hl/MEqsv0dSsPjq5jnvANe5pEeXpMVqg/yVeTKcO8 TdIo1OzBa0mlWLmYU8rulnNOEtN082GbyCSZieSORFRmwUeJpAqykkhKS/z4kk17MzSzteOT ztRkZj3K1NRhtJYZygpDnwTp28+fovn069tXPcZDHib9X39+UX0qK9vbtFl4c3ohJvUt12al +fv72GY5Zc7ieOm6wGrGpCNN9h6zeAmSZUXYlOzJCI7J9fRJtOY2ZMTADBRZEN+W1gviq+Vk SX5vTxi1PUHQTSmmGt62aH7p+8/2k33N3A2LhWxJL5vmiVv5CdM8aaH8cHmerlxNW3I14ThX E36Aq0iodkBQriaj1VlUMVT5uZoqQYW+tVajhmEuL8uOF9VbYLMw5W0jWkjDILoadbyNbBb9 OzzO1TR829UwBHW1o4bBL29u0TDEPiJu+XvI1YQVZLNwv79rrqaLN/jd8AaLZEi8HuYisXA2 hcQ3dSUN9fvbcxn7TJuFGxJvvzG4SbeIBAvnqXmDpyF2F0VOzFlfWYUDNdNaSHwX/HxZg7zC V4wwhCdC4q0Qhggg+hxs7NsxJP5W3uArJP5uY995IfEfgTf4XbqGX7TD74Z2OM3YY4wfmfBk kXbYnJ2U1X4Co/PhCWlbvWGgzMCzIyyHt9MOT0OcBU8CYsBWHxoIBap3BJzsefAE3QhPEr5I RgiX4EmSdjjRiVt9kW6jHc45HRtRdGHyIwYmIbrjqJ0L9EBrLKuAWLHkd4MnnKaOfIBZ3UwQ A2agsH6IcogB9xyzj0A7fLEDeljjYgc8hx0QoToXayymUGrqTraIv0SKA/OThBa8CHWIT80O OA1xGmtEkmUf7el30OnsgEik/J5RvYA1ltgBd02hdCs74OumUBqa+jyqkOPpdz4CO+BL6DLO p/c7jj9HtSn+nExmP7cuiD+nEagQTVOA0EIs8OcIkD9Hufw53vMgs5/5PtHHjcpl9uvVGLQB oIX5Mf154VtZnL7sCC225ShocQtBC0RLSXDlQ4uHqzHGWboxR0FVmpBhzy+zAPZCM1JliYsy ceam4EGC2W/89aqIAnGvYPzpAyW2lMQIaloLYSfW4QE4ZjF/Tp6l5JbDCBhV2XUH5CioUI07 paLvpivrnzg+R0E/REfnKAhxSiwJ+7HzXTkKLpY9dzd7OMueRgl6KtoaRAl3suy55dXscxAr IEhXZ6IEe9+rQQWE/fFGFRRECeex7BEieB+bG6CEsuaypPzgHM7ZLHuT1PhbIi9p5UUk25DK BZ1BVLCEEmQGStAjLfwCV5CyUELIsidUnsEiEyXcybKHl5QIbSd9JYIu2MiyN7xLUF1VNaOr Spvw3b5lz8uyZ4boYtnbEyU8Ydz0XRR5ZUyR9wi/59ik8bEp8lBVFx1AkdeXXxR5uaYLpPfa Th/iGfoFGDncSJE3ztNrU+T1vdiJIs9WtkiRNxDhobibj6XI61u2RJHXP3EbRZ6hqmOimg/V 8VWgZS9Kkef8XpAiDz74Luqy16Uuo8ANuitNBFjFMUncoEHqMlZXwA1a18UqXqHWv0Gfb8In pNYLGgHnIJPGXFd45+Bjb9DOLN1EXTYNsQ/N70zw5zXtxgw6udRlVZfIoEOklxdoC3XZjtEM KeqytYIrmmE3E/7x0QwfgLrsQ0QznM9+JqpyYgL59W3gAiGlG7wP45Jyg2bfnAoU1ux7BGju B3BXjRSdnmbfvhNp9u3PMrtEuORYArQN4clmd5z2p1wCtKmPZxCgPV0YwyIBWkOKaYufZiGa lqE2TJhiZedr9juAK80lQAvqGijSNhCgOY/Gk+yvEpAALWxIBxGgVaieu1nKkhh6ihWVNxjX kHwChF8+HxNuW1ZW3tWTNjVm8xlrO405SHnez45T0HOljQXF1FSn30kCNPfReEaGdy8CNH85 7UmABovVngRoVMYzEn5uxRz1cQjQhiN1yYul/70jArQM2BO+ZA+UBRKptljmQDPb8BoHmr5K L5KgXXxmj+Iz45gxHs3uF2I+pgyXFUlSKLGubslETmZfNuxkhh1MmvHVZ25ygG8lFruJJow1 klnp+RX30ZJTpYn0PhxXWKNKTHs2Lv3Ozz++q970bJpL9ZtJyRMtIy3wwZ7GK01sRSo+Elu5 rwljp8bJwSlrXMuB0uzzt1/q0/df377prcFIkJGFhe59KLKx/XnD2Em8YaJo9+MNU1gWpG6n i7l32gu02WBQoQrgDaNVRVXEG2Z/5azk93nDZNW2ZTFezP3yonjsxdyv63V4w8jFG/YUlrYX 4A1LCEi8cDBO8YZNC8cBuYmM0NYMVPGKiLdns7QFvqr2G330aMwbtsXj5HjesGmI3UUBWNrG 78R+rsp9d0gS5L9ym6WNhkRigdSNlRUowRtmhNC7vuXzhu2YJCjFGzbLzMlJgoaGpP1cs1r2 jJa2eYiOThL0AXjDntDZ9elIvw4KgTF7GYcNZdl8X847KDaU2XNC8WbG4/43ygW+rwYylKEu FSi7xPdFRcqBZwPfl/3xsmoLD1Y4fTkLVphMQWb/C/G4MlYJdIKhzM7SUgiMOwV67lBYMO2D um9MOptbFhKIZHIe3J6za22HrpHyC1xBCncmEPD03503c49mq/dTwk1ZBEuRhegJDoHJ5ey6 5SBqRKFXgM/ZVaIjAmVx0dZOUujxu0tNNU8cHyjbD9HRgbI0krNQEvbj7DohUPboQ7546CFf PNchj1NxrmRbnKvZ2KA4V72ddbSjJXDI628sxLmSOM7VfiN1yJcLhzxRTeYhbxdOlY5zbVp9 oAOHvO3LabqDlJcuJqVDQHYc5zhai3MNN6HEFdJxoIO3uMp9N33qj0+MQrp6yNu9E2iZEaS8 Q56Hh3y6qZvjXKuuBccsLEh2ky962uKQLAs3+XGueZ62K7qDvmXO/b9viCqLVmwImn1YnKsZ oqPjXAt4BTiS0B/y1Wse8i/hJXs2T9YdXrLVDixZluWHVpOXbOULWSZLFvf35g1esrYu0sEs WQNe2MkYN+GCuegmL1nrXDjiguAbh3jJQvwXYPTOwy//4yylvGRbWr8NAS5kmp1ouhJyMlXW MVTWquNO3l774YLMmvtxQkPBBgwU/V/CI402dXq/7gYHuDX9OOzxiRVmOIyLhJznRoFcqt3x WXN/6y3DWJVEdkt5mscnVkDGrXma3Zq8LMz9bIbOqQVbmgAHZelRq+upE9YJ2X03bKp1EjX9 z5hN27LScWztQldIUnIiK3g2Ayfkqfb5X/shz1GYjA3xx6yKe7W6nBwnZK8y16+y83y9nSmC F7p1Qg76QOLp9QpAN+XhXZ5syNzN4HMxlop75U/v4FLFFIkWXMLlthVKhk0NZYVXGd3sH41A 3VzwPHmaU4OYHLOHesnel2rV7sPmfeOy9Olv8eVfn36K5ov64brJFsLkl+U8UUm/26z52uLe W/IRvrZGXh1Hxy+fvynx3bz95+//MZ+uTfNJ2u3WCHHkq9vKFV/dDjPIVxdLtuisK3grOqe1 Yw7fPilq2hfwBZ18y6YRyHpL2k+ZO8H377/+NBZPgpakent65KNTHN/ctZtdkEXFKA9etLLT CLtPYOPVWyWFwPx7P6L/Vt8+/aX0NaWP66RG7Iq05+pNns9b569RtCZD5+x82O3IXMrHi+7C 6r3fVVpjSNFn1/70p4l61aP6vV9fFV5KO3yvr/RNrsuXqzT4OVQTI3Lf1Z/f//jtu/g6DUqz 7MvxUX2sWexjXT7AxzpU9yDIx1p2Kz7WRb6PdW3oktpefRP6WFsICJt7JvVJjquoYQoWesW8 BT7WfblPyuK3aw5+9sv55WMN+VgX7Ewf6/OpgJ/ExzqbDxgSnuyERGohIZECExJJKCFRmg/Y sBkhiaqCJxYOyAecSkjUMk4loU/HZoTVQHgDOENV0cI5hg84nZBIhQmJVF3FQ+wuimw2I5xg MxoHpBt+8ZV//EvaxjqR/IaSHVSm5r/4j5bSyzgdJSSS6YREHv2v19TNPta5XMJhAewvHNtY y9DGWm70sd5eALXsGX2s5yE6ms2IRwIQVrYfl/DFZrSLnfa/3tPv3+rbv//Uff3tx//T/+u/ 9cXyq/rx26f/b/uJ6+H+8enH779+yj/+/vbf+qmbvmFElRXFfw1S6/03QZTTsvgvTFBJC44L zv5LH5tYF72hnfsK/n7pE/P729t/ff/jj59Lz639/UV/vVjfRbAdBgijf/yFDggQ/vAE2zWr OESwbcsvgu1/ZhBsc43fcItRBMW3hDveSrA9zNOLE2zbXuxFsG0qe06CbduyRYJt+8RFsH0R bB9GsE1o2ylrpP770+cfvQHqk7FUK2P79HDr7TyWweRh7xjsr7i1y2MZli9opPB4DA5XIM+r LctDb/xOyGM5ld/EY0lhjVSR4rGk7jEI9eWZeCxNeB5CsUZKLzil9CrIOAb38tBzZinloSfU rCkYf/CpaMLz2o4LPSOrPJbOo4n7uONCBujKIl8y4/8X+HQ5PJZjP8sFj5bQt6lJ81jatlOU 4yBmk2J6tftPTC3DQMumhsxvUcHRrTyW/ZAHBY5X49iQYAep4wmYe5WYEceFLOh2ki2yiecq diHznog9p9x3g+8CnqDh9xe6GVUW9mpF8eb5koWdiF3Igrpwqps8HpHgiWgCmlhoaTQiw2/i PB3HLHJVTC+nQIoAB7GoMkA0xt/ymPGWt+HIwF6NwBC5amtgwdnfEo9l1NSVgjaBjzTcUatj lsljWdWyPoDHMhv8hK/aY2XBT68ST81meY6HnRZyyFGOLnuCWFGIHOWKpn5eR7lCVDYWSXyV nz7rz/3S/996o0weMFbnrcz8Fik3zBN80m5yDrvD16sxAaDDq/8mdoS+/vg+SQZaUrTv4Sd2 ir9XqWvsBkcq9e+fn378/fln+/vkMSqTs0M0RDSeRULK2ejSLPmzEQ1hzBj9aH9X8ldvaLFM pSztPvXBmC1vMvLc6aqFYlet4gHa7vD2jwBXrc7skEsXfLTBVWvEGuP9fiww/BKdoeAAPU6K KTrNvd8rjMrB68FTcxuOjKotI1etkf/Cvd9732/nyHy/vLlctUJXLX1Jowi43/vff890mGaF c2iFI3eF3x606r/RW20cJy17byNo9m4c7+2GPYgj2LtRL4GiqtqEZYg34ZIJxclbMkVRYA26 394AIswhMPYdL5mbVGIExUtm2MYODlodZyllF0I7cRxNUuI9R+9ieVjmOCoqHLEgQbqiaS2E j97SskrLA+5EHMQYL+Pp+8PIPHgCUo+SeCPp/zCzLaYr23SHztsok1CIxFCIPAAKhRs+CqFQ P8Erhn+UD4UmUYW81mnKa32S5MP2daj8He/rt3mt96zsZ0Ghs9k7D6LvWODuRB2tU/QdnnHQ e2cn+o7++wjm7iRyT/oOGq+Ym4yD1siSWDGHGAehy0PLmqItsnxk9ubu1LN0CH1HoZAvHsam PX5unNBQsCHjoH03MMFRv2W8C6m5l+k7cCw4zkAoTIvImgGySvUCGUsbrKp3SAQSEwBmGZxG NZgA0Drr/TbRdwwm10Rl+g7szwhgk7uFvmOyvSblbJrvdevs0DK8QN8xmlwfDEWnhvhSXANS vLacFmyvcTfDKYLlLMwhiMJse+D0Aowbw18W6TuixRpWluzVNN5O2x2Tq9N22DoL2l6DbvJ4 IBJb0BJ9R9rkGnUzbXuNC7zvN4Cpd/zFtteVNTJ386npO/Q+vEbfgSVdou+4O9Peh2T/eFXb 5Isl3ttuwzqW6aLhbYvml77/bD/Z16w2I2kJbFjXmZFsf1ftv0a72chX0I9lehYO5NY42956 UgrDy0w77u2Gkt+0TX0zp0pvKf378zf5x9/WH8ESgDRp4ZH1komX1osm3o5ZOY8ttASJpzPR 0lgviR+glwy1Lwgy0RJ+iIlW8htMtIPWIDTRFmi7iVZy2ESryy8T7ROaaM9POPA0bBqZWQcg 4clm0yALbBokZtPo+exvyFiISrG2cJwDJZWxsKFVxwtRPl3GwlRqoZbIwmFMPVA9ucSmQUI2 DTKzacxD7C4Kn03Dnb28tEQZSsBu+KWjKqZUAqEEBZXhKWFh+F2/V1HGQpRi05AVRr5Wbm6q J34u0kuxaeRmLMjQjkWPJtMS3VLZegGRmLSlABzU89MSzetuyEaU1c1EWqJoK4ZalpuWaM8x KyIBCCvbL2PBaWwaB2cgKB8KFUaN40tABXYAVGALUIGBxFvdbVBBsr2gQlPo4/HJoEIqEUHL 69axzhyXiKBbggoshAosgAp2iNNQwb2ql8Sxucm26BHTvC8G/OR6o+7MWXYLVLDdWocKWBaJ 5EZGCJNQYawdOt1FZEG9AyrIuolbth9U6EKowB4MFRgG7IXJ7wZPnAIVuuOhQhkJQAwV9BaC 8QtDBbsXLEdmULSkc76yHR2f7agoJncp9wO4q6QLMrx3oiyI9jfxDGzKdkRF5C7Vl98CMlKK vPfBpWBAhkIxyOBlgxtOjwcZdpZS7lKgt040XSNyyOVSSNAf2GEIBDtKz3IDlwKdk95kbP6d 59/hhO9G/jwg/IlTuyhwzPz/CTlydSnHHrdgNy4Fu/c3ZRk1NQzld3uVmBHYn8f2Z33Mphwz sT9P0LJUfhwnp5AenFpY3qS1GUmSWcRHeRH1agFkOJ0QrWDEnyun30NTQ6GFvHWiToy8plPL NnjrjL8t3jpjBp38yha8dRLdnBw1EA2ml4fv0hyUl5pNnJyRvnbB8z3pRNjvqsofs5gpwR0I mCABHDOYKWFtIKbYlYe6S93nqXQyi4JZv5GnUUHWPI0QBTyNWvrkjkaFUIXxq+q+/Prxu31f fJOfml9aeowbBpVLHg6bnVwIpdR4gekbx1fx41+fvovPP5RzfRCLeVyOZ07Y7vRxuSfFr17u SR/aPelikbgz4Q87KeGPvkns7aKkIBelbiuLxAR2YhcldgOLRJdgkbDMn2+Xi9KzuShdCX8m a9D7SPjT0NqkhkwunDDhT38xog2wcKxRrCm7Cr893u64hWWcyBa3Icu4+fG2Ig3vqLdwjlAJ 3pzwZx5id1Hk2h15VZoIQM+7x8QSOYNblri42e6Yk/BHg7uE3ZEwl7FxQ8KfoBNeU2+wO96W 8CfH7DUOr9NUqU+6h9odawZQZiS/GzxxvN2xH6Kj7Y4fIeHP89sd70p4UsQJTx5BARd7UV8J T66EJ/clPOn7gWqkBywDiiAAilwJT66EJ7skPJH4PSc8GSSxkryogpZdCU9uTHjyNFfyjhH2 6Cu5/kaTupLbv3nnYH/3qLv4So4ZUbxAFLySM9VRyVEqBy/3ruTDVZnVFXglL0rJSNUx4Eo+ Xq9PcQUmgivIFVhhY1on/jn42By8zizBV/JesKKZjoY4hOrglTzMwYuKrTl4u+Dny5p7A9cF jclovHZVImoKGwqPcs9JxLmSO5+DbtGV6z0xDBFROBYlp/aFqKEcD5+4AENnTZSDt+2kn4NX F1w5eMcJmIbo6By8KBKADZW9yJX8neXgBeEJfig8ifOPhvDEqG2KNTN2UXhm7NthynRIzA6t EQt1MZQDMGUpMRsEU7KdiaF3guBm0rUqZXKbTIFLJrfoXLrD5Bb2xb2uQ+16GAv1U1kOxlkC nInHAYlvZJ5I0nryl0O2NkmAu+I0g2MtVmaWWKj5OJAQ5nG171lmiPFzCzu+NySQ1cFFFtaf BERjouVMxg1JFUxt33KwBVNURItxwaYxFwgFxUPhaJjBblrfFh+F1qrxIC0NPLKDyryvGv1l 0BDA/TQsyByzAjkyOvU7HJmwMosxeV2jFFsfbAfyYigDoG6cdDxjmnHBgTUe/b+2dUshPU5R Kr2NyaATReXXbsiAFroZnSzuu8ZNZ319xS1rRNFyXnpZ9azLTry+nDGzd4q1hZ4A+Z5VL6dl q2K1Rc7cPcH4Cj0GwUZtr0RZVKx4CHd9Hsa9BQWFddzrlad3WsArDzP5Id3y7mL++lBueTh2 y0MPsOyFVwkEuOU19f7MYWS8I4S7BXBHKFJuedZcX1fRHcGWD1kTXLe8YEcK3fL67St2y9Pl 9CO45WHgjrCS0YCc6ZZ3dnInQhtiNiQn46fZxMT/s5rtHG3Q/Y8pB8IFM/xwuGDG5x91qQ7/ BlyqcdfWqQjdrEs1WJ6/YOZIXBq0S5KsBRO8U+xxqX4uGpBxllIRujVKWMBHiFu3bpYCmIEd 4seYpgeuHawseDK67vs8521bRkpaMHE0FrKpHeoyj6DEpmvBuOvKNtIQxC1bTYI8qQqCJziP xiyDKSX5OdCSg/NUBf70yiaIt17St+zqpxarCqJrIDibGpXiKEC0jAcxHOZ1fUvwrhNws6aI WPruljFz54pUPLjCkTmEM/rcVADpDpqCyYq5skJKxLxuljWuZZ7uAFQVRCoSpyDSHXhtjlUF bbqbK6LhqwoymIhKxJsGjh2eVQXuL15wzpgFuoPViV9rWXvipToH9YTv2PNkoog3kbWGIf6T 3qrVjz4NgDHfkIVrtN7TVy7yolkOyjN7/VDFD90IfW6bD3Mbtvig27/dkfp7sr75//zj+xwu SUycbtLGdWMwn90ahta6r4nOMnInlQ1miQ/Khs/ffqlP3399+6YxtonqNNNyReftcqMHchSW Z+Qo1Df62phvF28oVf6NvhJVUxTtZPXz9xYcUQhVgun/10y3cD9Hod3eogtK/05VxTf6/tvw jb7fKuMbvd3cd6QQetob/Q05Ck+90Z+do7CutGzoFd7vTL2Dwjdr90fWIWI/S3k6S2HHFM1y 6HPeCbIUmp81DTVVx0R0qbffKNMOfaqBLvUaileTFszth95Rq+SaoVWRWDN4XDMegmNzXcGa oXVZUOBSb/syrpkEHD/coW+DpXwvhz5nluBLfV0z3gVS44NBzrvCo4tBHeliT7dZ4sYXPRDs oeJp9oZX1nArbRP5E40geSiUELLQMgdAqzx+TtiEbFyAPJ8sGbUMeZ6NhNXlUlZk2ClvKEDY d+fXBZ1MjZnZcObvIjR7VOoudQwTLqIc16u33f67uU55ayqaTU55K92ch0ii4F3AKW/P+xGN 5CyUhJ7KW+0QJ5d1/kSvmZWd9scruyV/vH6R9w51n78rg4ObavGa8dFov82Nt41vvO26nr8i 65BgfHgQcQXD6OfT81tO5CfU89t2bdTzD+/soudPZgapBK5Ee3zYvZ2lHfT8/SuUKFpCG2KQ MgM9r55/TFHSP3Gint9rCJh3JF/PnyRA36bnh3u1oeAJ9PzDIIbDnKXnd9/dqudPfPcuPb97 DLnei9HnpgJIzy/N1Z55siLu1fPP3xVK4TJS/JdZen7d5hU9v9/NTXr+1fXVCC1KRQEne17R 808LzhmzO/T8YMvUQ9Zmvp5/DfWE79yr57eHi37/u5Cf//3p53elPv0mvv1m8OK/fhnEyAwP aJIz8DITPNJMsN218DIsHGJYKGPDAn2AYSG8KKGbDAs1f9vmKhjfiPQluWsLESlJK6GPhmoS j9CwoPdTGeUmcOvyDQumLuopScO9+S02LOjy9iO4Cr6aYeHsbB5mhXNohSN3hd+ezsN/w1oi ogi8UQTaudy6QjjET1lKhErQUhklXLRkdHlHi8SSQV3bTbY4B0RNKUPe8ZK5SYkw1eW2lyKl uq71lswRSgQ7Sym6HLTTTXGSkj0qW3/XJKQ0QUO3VDYtAq+gAyjc4srsSSlkvdJUl4SoHxmZ k2gkvyC/MhZvJP0fbGIqRPGSxWPTrSNvo0xCIYDM+BF8aDlkxsLEumwxGC9BoUlUYeVwyl58 +L7ul8sr3/rzQaGzyYzviJrYYE0ZrCOvZE2RT2pNkTdYU+Re1pSny2smM60pIycbYE0JhjAg ORrdfkP2nyOsKWPB+ArYTZtTJbN297ejNQUwgBjSCiqcEYkHcZs1BaZ1jq0pwTjkZ3W6wTIw qNu9SHhoiCBZqZNcTnVkAvTS5UmF/KxpNjgZFg2PYKF/109b17c93U2vmNTL+b2kIsSbEdzV IhyzURWppEd50RNeO5XZIKxwNkPXj74yxLgoI5NQ7GDmjoyJss60prS49AxOmCPmWzpZ0cXO T73ArxAs+Bn2pgJ4AgochG/YgmjBBTMEj1nTMSWiPSFYcIVHW3FX1IS38o1mjrfVQ65P7zpq 4r78WfeZRQ7kQLD7hrEcGLX/Dw2Uv6gfv//xc/DAsjncFh2w7O4yvv+vz3ZusTFxVKk37Bai 31B/6T59s6amwdRgXkWlHZpkB4+ibOi3HtPMb6L5onqrxt+fv8k//jbv2gmkTeqTd9I9mA0D tKYQJB5pTuHHJEQKb0oI0CEUxs9uLx3C+Mo2HcK2hEhueZAQiVWYeFei+W/95gzoEHT5nqme Lx3CrTqEu5IUhEo59Bgqk9gKcyUpuJIU7JCkADNRCnYlKUDRtM+VXUkKriQFdyUpcH+ppe9N wJWkYFXVfr7XwcBeAHgdOK6qHrK0HF0DSvWtU4WeiiK2TqGyYE2S06vjrfCV7f3Fpu4urwNQ 2f4kFEXOLD3e62CQkj0qy3431GwWgOJ4WgtzwbAIpoJB+jNa1vvn4XKlZb7XgRmZxWjG7QW3 KvRCFqmVyjZp5+70OkDHMDuEGz6CHDBx+Zwag0fu6375fLNJyMSr7+uvmEL57IQIT5SvieXR O0DCk52viVVpegdWRSmULd81kELZPl8LgN6haziS+opj77Y5KZQH4x8DFk7XlKQsVdsdkUJ5 CyBKqgRA74PH5mtyZimVr8kIVjTT0RC7i8LP1xRJ1nB1pYU+Ibfmawr/Epv+xieSyQyCyvQZ PbXMe47ihRTKY+2QubTqKrcyr6kJy246XxOcqmC9IAgM7a/dUb4mffn38zXpgitf0zgB0xAd na8JRwIQVmaoIQgSL5xC+SUSLp3NBf1E+EIcgC/EAr4QIL7ALr5IrIQYmGMq14B5eO4n8EUt eF08Gb5I0keBCpcj8AVewhcixBfCxxf9EKfxhfedmHpKeE5PlpVmL3wBMyAHlZGmm2QrEsIl fIHT+MLzj7oXX0DOVusFJXSKx/gCdQG+MFkUlvDF+GhhYLJDPUWJ7EjFm/eHL/QQHY0vSCQA EL7AtH1dfPH8/FMXK+WOrJT6nGg5UiUIK45ipcRtnYAVG1kpq4YpVnuw4glYKU30KKTva41C tTgh1UQeK+VEwzBr/i2HS0BnLysHGmUhgUgm58HNczImZQoatHUEDUDAE7JSevSBelVgfbqI jgVLkYXoydnLUpWFbXd+txxEjSgkl6UXNVtogPpooxCRpGa449F3l5pqniiByipRFRhiw3Tf RXrRhOEc6dAE30ymhwgI/d0TCay62b8vVsp+G1hmY6FoiY3laJRQPBQljB5+L6CBwLqmR2sg 9DfqFFSwf4OgAr9JA9G0u2ggsBRcKv5sGojnIpoYZwnWQPSCFc10NMThzQTedfXbKCzwk0HZ CLFgzgGW4jTumMdSd2tdA0E4HQMeQ5jRLFs4bO3QeeCRNdyrgag6MHhvl2NPn6GqC2BGWUHH /S5nqEEXdeHqRla/GzzhNHVEF1ndTMCMBQ3E/K4ZohyYseeYFZEAgBoIUr2uBuLDEVofplDo iUZBhQJGLA8luHVxWKEg9d4PpbnQ32BplMBaiIWh4ymFQr2gUCj6BLEZCgW7jGrQD8L+WuO4 DygUbF9OQgm4obQDQyP02HfzuBxkpxhnaUmhEO5EcYHzirVwwieehwHWT/pRSNc23BoruGVG kMKdKQZDPvfsalMBUVlWKMg6z5ch2U0vZUPsy1CGvgzlcpoL93/zrrvvxJtb5tga+oYo3CK1 aiiafw9IczEPUY6tYU+FAszq7kqCZfvC+DUVCi/hxnA2OdMTKRHUAUoEtaBEULESwZJUAG6S ptwYsmJ4oOFJ2eoxESQBD0A3SZl2k+QtL9qnUyK01GoRQnhwjhvDOEspJYIKlQiqruIh9ved TDdJVMBukl7TQHiQBS1gSqKgMqZStgqEI2ix0DJXIH0apRS0yFIiDMQ70SCuFQRcVAlo0XbS hxa6IN9NMg9aLEwACC2Gpj6LG4MZoqPdGHgkALESQa/lrnxhJcJz4ou7iBuKmLjhEWyqsW3j Im64iBv2IG4QjeDqIm5A0bTPlV3EDQ8nbhDVByFukKml703ARdzwJAr66RYoYI8/wvIV9AGr gqegV5TTpu2AG7j+xkIgAVEwc0OsoMf6WV7ocwu8gatSGltu4gZeBjdw823d4ga4gVuhYohW 5VusoLd9Oe0G/jwef84s5SroV0zxgwtg8v4xL/9x+0vfokchXbvMYNr6BeMPY7qmoHfXwtCJ yW1x/RadpaCvInpooKlLY/aUHn+04I1i0XeXmvqRPP7iUJrtkvDECvqjde0XJcH7oiQYfkUy ZBAwxQvVpXTtilRtXdK3J9O1bwoZ3HLZPYGSYBxifwtJhAwSGzI4X3Bc3e8DQgazKAlkm6Ak KFZCBpOUBEJ5PEdJlJCla09REtgnrMGCsLpcTYgQjfdQgLCvHtAFl67dHzM9RBIF716UBO8/ ZPCiI3glOgLvebmALSjPjRtcpjtSlJackyfDFklFelMrpCo06sxego5gHOJwz1nYWedjET2W 7iiLjqDBY2ofFAthuLX5op3EFp7/vtfUw+gIKHhOxnQEPKQj4Bfd0dtbMEQXHcHu2OJJ7fgR JUFkmccPsMzH3ATWMm9m0+B3USBFcbuW57QywGCbZR7XRVXNZom5nIqWlDGgMM8LPh3cMaDg EfEowryjDFUjoAi/4QKK+W8C46qgI6AYBqLrWlxQjBPRhcUEdCygwP4/CUDhWebNYDf6Tkka OnkfxMSjhI2AImgvHwGF+zSVbLbyl/8IDyyZABSbLPNUyrZBPqDQ+ziTlKuyI2NfHm6ZD+cp ssyLwR2/HOPNbWYzZDKtuUKmaDnx2hR0LHcqG7d5+98syl6H159YqYx3k3cffqOd7Pj0j7vl +jIcbfU0ZIEuQn+DqGDh3JhbZjcEWjSpMUP2ibJCErR/EyxdbX9UYNrFlAyXdmAYniaadkFl qgVONLftpejSlqHarUyvHorggr4yjASTQHzh2A/vUUUaNhU0rGkU8gairnDVAPhk/LvbENyV NHGS99tIiykpnW7qkxaujMtOFfqf9SdWKuu/y2QTT0AZyhlNj9m08vqFgVEoCcATCdEo5hEZ ZKWMV092y4bFMkkRbp31hY1TRZz1FVpOrsDzeRBXlkT+CgiFVuMPuhphe8Nycn412M2gIW43 Fz+XtQVhfXUiPCUaaFojQ2UwwLpCNPcM0VS0bvXgALqbnUM0JxEJPECqQu+pKbsQDXQ3PecT TXmAIMZ551NJnh+iSQhvJWQX4m1FGo10j9Xd3BSiOd5tfUbBpRDNWeLGSsaTMa1/yQ3RbHDp F4y/uuaR/mWhZfONOZcOEhyz3UM0y2X9C0gHmajsmBDNoamw/iVZ2eNCNDPpIPdUUV0hmuer XthDkUGcxPJMZKA34QQyEJuRgUogA1FTAkdnigVkIEBkoJLIQC6QN/AilcQCtOrA0Zn213Y1 m8Ijwr48GzLQq0Bwzo4nb1DHkDeYmUodtylkoHKQgWJBwfgzgpSFDFSADJaaegMyyLPMLFym FpEBDpEBPhsZDA1hLX0O8gbj9XEwMgBXgCcJFhkgeiGDi7zhLngQyM47IW/AaXiAik3cTlXK 6UO2evtrpQcPznf6eDIGyPvIG8Yh9vedJ2CAzCVvwKwZ/xILYbi1+aJ9BAPkreQNOUfd4QyQ JtqkACq7GCD930cgb3huHgZ+jLdHjDA+OA9DVVOQh8GWXzwM/8zmYahUK9jxPAzDPL04D4Pt xV48DKay5+RhsC1b5GGwT1w8DBcPw8XDMH4j0rUv8DAw0RjXi8nh0f/GnjwMNDoC7fcbLky8 XOIyzYPL9AoPAysNfH+Lde3n8jDobR5MGA1Z4R97mb6Vh8Edlhq303WbSF6VZg/acv+NZHIe 3KzMS7gT2CsYf7jg5ZquHeZh8ALmzaooRFuqIhKHLF37I3kYKn0M4MK5ZeozTW+iR/AwdLUe tui76cr6J47nYeiH6OJhuHgYLh6Gg3gYEvIMqM2T/nbTZTex5Xpqcyb09ly1U2hDeKKfdNIn L7sK6xN8ZqJ6BR6GaYj9LSTiYRi2h1L6sZLoobGSWTwMFU/EShohDLc2X7Q/Og8DMGbvKVZy HqKLh+EBanOzF+i3e2QyYIVPov35+Y9vBgBg8zppU6+/hFX/onJ4JSqHxEKK4Ukl8lNAm29X UApoc3ZyVQnylFZ9gu6CJ/vmdbydymEa4nDbgjfnWYnRV6ZPjsrPJ22SLC7AkwiNeL2AlBgr xwaum0QogRHCJXiSpHKQFYE6cSs8uY3KIdOqL0OrfvFQq77uVgu4Iya/GzxxilVfHm/V/whU DsezMjwSKsRkDKeFBlCbnR4MDeiYykMJzjsoYa7AXYk5iBJUmUYJGmsDKAEB5oregwxDQYPD r+Q8gRLCoMG10ICyYdjP/uz05SyUQAQX2WSSRxA+oS3mCvtF+0SviKgygwYniRsr8Y5P7+if Znt4ZW3DrRBsrrCCFO5MCy3zhWq30ICqk1HLoIJkNx8YGoBiy/YOoQFDU58naPD40AAayVko CX0GZ3WFBjwMGRQPRQZxAqVTkQFOBQ2SbUGDdEhsDyADUtWiBZCB/sZC0CCJgwbtN1LIoFwI GqQ8xdy0ISrA/hpaCl9/4PTl2ZABwgJVh2d8HmfpiIzPFUodt0lkkBM0qJ+CW2YEKQ8ZRHQC 6abegAzaqGVQQbKbfBEZ4CbM+Nw8R9CgKgtOniJoUA/R0ciggFeAIwk9MqguZPAwZHA+0dCT mBey2YYiqd4SNMgWggYZGDTY8VvMC7Tdy/tBKiL8fFNPYF5IZaEAzQsHsQ2lgwZZGDTI6ioe Yn/fgbJQ9Jw+/j7KK8Td0Lwds1BE5EaB1I2VFUhMshUJYbi1BZ2BzQu5TEVZ5oVcpqKwICC7 SUELmKkoQ+8+fXd4l6C6qmpG4/FemAAQWgxNPd/7YRtT0Z5Yo4wEIDYv7MVUdGWhuKiKHk9V xERDZVFD9ojDqIq0aG2gKqo0eE9pHViNqVKg1uFEqqKn4yLYRFWUxyewBQlEMjkPblb4BGFd 7RV4ghTuTCDgCamKPE6ZPnyiLgoZLEUWoqcHURUtmvMTfAJ73qCT4ROcRd9damrPJxBX9vA0 lpl8AnuO2TunKnpuKoEyphLgD6ASiPUOH5tKAJe4rQEqgb78ohL4ZzaVAGB+2BJdcSOVwDhP r00l0PdiJyoBW9lTUgn0LVuiEuifuKgE3iWVgFOZLJheeCrMdrIN2FVlUQtWS9XxuilL+qYn rG47UTYNxrirZ60MlQL3bhXYq8tR8ZC6aEQjcCGbum548Va3FWpbQVSH2pqK1m0IJphEW4ED 05F0v6NvPmbLFENKWtqanCIdq92X3+b/RYnfTf9NPfFEOC+6VxvaJ6bo3rwXVA2vTexYKUnv B92hcUbMm9iOlvNK3wu/suFNNQXZ9m/23Xnz37QFffeQ6jP7uJXZN/E4cm/+m7pg/FQ1jNVb /8I8cosA63zKiiex52TzVgR/2xYuQpoF3orGx1sTI0JEArnIWyFEjTCvuoTipXoD7Dk1mbGb a8/hvGsxb3xH0PPtORHeGg5Kk4oBGcXagfYcZ5ZS4SJGsKKZjobYv9FlZv7EsBNpxmE//iVt z4lIMMZfWFmXsOegViTsOQ7VBWzP8XgbvaZutufkMh2s3Pt7TAO4ipShq0h5RbO+vQVDdLQ9 B0UCsKGy17DnvIa/yMWW8UpsGd7z9UJmcTQwXGTmoOgSJNP68GsUEt2T4QsiW2otO5E+x+YD DfDFFn3O8WwZ0xDfhC9SbBle00B30nV8kcuWgVE1tSwSQhhfXGwZ/S/PFfVl8cU8RBdbxgfF FyQ2EBUPMBDFvBeegUiLoKhbWq4YiIobDUTI9xTR21NXEtY1/YHuAwqMi7IcPQ9mTxH9TksY Lqpi8hQZNyjCZS2G1JXyc/w8YCCipNA7rKxCA9FQzidPEb8X3ajztIAC6ksMKLrGAxRWW8EL SWbHWOwoAEhbioa2gIFoWLaOgWgqRCgGFH677jUQET3CIgQUXN9ycdOV1fz9owxE0zwlDERW w+kf20r4k6wKz2BRGX8R4PY3ylYooPB5OaylRi+l0CNj+u7o3mEKaEUaWa3XHh5CrnQtNHVo 2ThZ4y8+hIZfEcloUCCjgmQ3Y79O4knNNGZu25MnGo5XiP854c+mQuls7GgxEBaYAGeBRd2s qtUJoAuVrTfE+1yHvG7ypmuSouEOrxmzAnJrCUc1NF2ZX9O1LIZheH2NLKzNdENsN5k/m62s w9iZxfH2KwMsk8kx8xKJd0Xr1o5pSzq2ChDnX7iMSdhNr2X6ismIXJnN/tEly+Riy/p5QfEE 1HCBWazG7zZtO0SQfK/CzzqUs/4z+pKYgaED0VTjQQoDrPNJQp5GgZPJFBJN3hYFjlpQ4ChQ gYMSChysj4kFBU6nMhU4fXpxBvOJcS5VKcjTKXDaVsMedJcCZ18+MbSkwFGhAkd5CpxhiN1F kaQ7bUoyK78Nvzu1jopDgbmt+uaQRhSdcTu9UYGDsuhO6ykDaSyETtsjBQ5KKnD8TnhNvcFA lMcycov+YBxep4CyR/KJFS2ruyKuLPnd4IlT+MS64/nEaCQAkAJnH5aRsxQ4di/Qb//+19de g/O7+PHpT/VN6qP9U6+XoaaG+lmUORftyI60I1xvgqIpCwBmHEA70jWVZE1bl6kAIALCDMpn aBDQjtRFJzyY8QS0I8n8KYzSiJDsEJixOQDI3QatIWPCDrfmT3Flch7crAAgLfsJQjIsY6gA oqmYdsS5r1lzGEddwYOlmBkAdDftyMK75+VP0ZgBYxF9N13Zx8qf8s5pRz5elO+TKBSyQ30j Ad3CICIWGEQEyCCibmIQwS1JnPSbGET0bbfsMHk2j9MkQTkiJXbG5dBQ3zSDiAgZRERdxUMc XjRyFAojH/m8Ewbc3iOD9i0KhShuOJC6sTLRqEm2IiEMtzZftI8gKM8NE75RoXAsQbkGB3oY QYXCRVDu/FgkALFCYa8w4UuhkIk1+EOxRpyA/ImxhjoAa6gFrKFArCE5YLww5XrwYK0CrZlg PFerMJBDpb1PO9ZnmH0mrEFq3UsEYg0kQ1qRI9jK5BLWUCHWUHUVD3Eaa0SSZR/tvU+LZe9T 27QbvU/Hd9fOAKOmG1vmPyjoItaQKawh1I7GC1nXcctyHBj9ymyFcXRL20k/ukUXXNEtb2/B EB0d3cIjAYCwhurKF8Yaz+l9eheZCYt9VdkDfFVjFcgHJzMxjH4QmYktv8hM/plBZsI7ykVZ FY5B4Dgyk2GeXpzMxPZiLzITUxlIZuJ/jldxN70hmiujaQ/F7S2DyEy8F5SIVQr92YxL5Q5v VVezjiG2DY1fAVr2omQmvSSWLcekTS19bwKelcxk/B2rhrkq+xCVwQDrIjN5X2Qmww/TVFY7 vkXdUxUmmlX6TiTPoO5JkNODLLLPTWYyDXF4DYRMS4b/w1/hvNKHtvtET07vv3KbuieXzKRA xSTzkRCGN82Fls0CKZTnM+I19TAykyCpWo9pAHJ6HpLT80vd46l7zBBdZCa7q3uen5z+bCKT lrOK66b/+Ovrpx8/f/v86Yto1JfBNagYA4IWdDlbUAWpSYAqrI3cxiY5WpzRI8CRMw9VNKLE tEKBa6oxBHPJWB8lLL3yqqFymj2LKvy6cPH2BlCYDO6vmxxWhr4sOayk6gpcU+d34ohjT4sD 1lWC7+zisIJRjCpaXgjZnuCaamcppcNBO90sJinZo7L1d0eBDSRbAKGb01rwH+VVurJ0yyrE VFWvcnuYZex9n3erif82FeRXhuONpP/DzJORrmzTGZa3US7s876SnvzjL/oAJX244aN+wx97 PE7wipLebtPzxv7X17R2fpKuYV+PJiy4LQaSfNi+7pVreX3n+zpO7OtI7+s1sK8jJDqC+tCR MLLR/f5wW6TzbZGu7OvTbRHN+zq8RMhDoVBMtfLEahZxQEiwWAgJFmBIMO5u8ODFOJmsZ5MH b1UgzJqBH+551Cy4RSXODgk+IkUwXlKziDAkWFRVPMQ5ahZMSul71SQ4Y72m3c7phjPULFjU MGesFUJYzQK2zFWzeFG896lZhLrNgzcISUqqWXCoZtnA6ZbVkNdXs+DD1SwkEoCwMhvnQ9sX 9qqxe4F+u48tGtQmn0T78/Mf34wuBJvXSZt6/Tmdci7GkhdmLEksJCBFMUpR2m+DJ7STshL0 yeAJIVWnIH0NGGB0BDy5nbFkGuIVeNIz2Bu/hrTKe6IBiQpuhCdZjCUlTliBjBAuwZMkY0nV VWg3eHIrYwn3K0vBE9yElPbN08CTMkXQ5/yOoLRvDocnH4Gx5OMRjjwJVMhmHYmkdEt8EFmI DyJxfFDPZ5EgN1tkHanKBFTYwDpiz7GSEIGfDSo8I+tIOj6IhPFBpK7iIU5DBXf6VlIWD4wl kcDfChUy4oNIIej4F//RqkPLUCEdi1ygHaFCHmPJLSdVkrFkz2NvLiCyNFx44GzmMpbMbT8m FjmfsWTPMSsiAYChwh6MJR8FKpQPhQpxAuInhgrsAKjAFqACA0OJuyRUqCd9VqxVKNsiEyos JrLR51ij94in40FNJrKBQolhqLCjVmGcpRRUYCFUYD5U6Ic4DRXc7SE0eiQS2YzjMZ6yt0AF 260Mo0dZJHhQjRAmocJYO2yn2DGRjayvRDYLlb3PRDZlJAAxVBBth/ErQ4UPYPQ4n+nkIOpU w6ygUtSpmSQnbl0Qdaq+gJUl7TiITNQCdaqKqVN7+oyYOjVNcjIufd4mkAmQYs9wd0LIxP4a xjnxkInTl7OQSdregUTR0nFcDiU5yadOtV+MCsJNA76Qe6dsFrpIkJx4DdGALpEmzwhSuDPF AGxaC3lNBUTFH7OQOjWXqCTZzWLZpSK0WVhFSqKyMGI8D10sTACILoaGtEiq9RzK0w/fgC4W uukPUY7NYk+zDodWgCcJ+xGVnECd+pzI4C6OkiLmKCEPcH+OTSMfnaNE6PMH4igx5RdHyT8z OEr6fghSC+ajhy16jZs5Svp5enWOEtOL3ThKdGWLHCXjH+JuekM0V7YbR4mp7GEcJRjXuKli 3AS07MU5ShipZWrpexPwVBwl8MF3cUe8LncEAV0BhKgR5lXKa5AFt2jzbUV5A9yiu6Y2vL20 mc5Bp12nBjWkz8HDvQbv5Y6YhtiH57n6/QRV6Dge6U14/Ev6Bp7LHdEZPotB5gNZS3kNrnJH 7Jrn7DbuiCOoQt+5fv88qtAPwB3xIfT7Z9NPPBE8YQcENbCFoAYGBjWQm4IaWCUS8GRTUEOt /2ZUjU8GTwimHQXhyVkxl2QJnrAwqIFVVTzEK/CkRyPrQQ0kDGogdwQ1kBx4QqicGhIJIQxP wJa58GRHaiuhYPeDtYKL2moneHIGtRWOBCCsbOYHeVl4cjBUOJ+e4bgsqqSEXQGymRmcd3AH uALoWyllDEOuAPob5QIzQxO5AvQx/9V2ShNe7cDMYLteybL0lRhOX85CCYaqiqK7nBT3jWew s7Qpi2pQ4MYkMNmhhT1y3puzTvoEM8MkDub/4bpLuAIYQQp3JhAM4c53BZAVRTknPThmoStA LrvCLeeKSf7Fw/xo6IgsqozUqC6i7y411TxxfBbVfoiOzqIay1koCfuxK3yALKoXycErkRy4 OyvCUOTi8OMqddKHTn995CKb6/L1AUio+gkjF7mNRohPeojq+oiT/naSg2mIw3sCvGmuoIS2 kJB73M2RizkcTLVK5Fo3Qhhubb5oJyMXvcqSKCHTXHEbyUFeSF+hwiyq5SOzqBpwoMq4suR3 gydOyaKqjs+iepEc7A8VrsjFV4pcTAg1wHPKdqFrtHrtsn42z4Z0Vgxcc8Hv8PA7PnJxGuI0 VPC+E2fFaDx3gT4rxvjn8ZS9BSpkRi4aHdgkW5EQJqHCFbmIIM+GYk/Twdl8SPMQXZGLu0OF 58+KwR6KLeJMpiG2YDWVpW76n79+fvpT/NZraswI0fsRReWLjJ8Rg3QMlbXqOJkQRfD8uOos ooDq+vE5qmtiTg+/ESEK87dxYcSIQnFKsswM0cmQzZxu9rW5jwZRDN8nbcebenzHiRnQfzYT 6MUMQO2aEIVVclS47FHbwzJiNPoiTJo6B1HsqHwYZwmIGJgGynu2GA80d+qdpaBwWcUO6+MP R1OXOC5HzRKCzqBJTFLv4lKWRj9gTsdudoeMKqtmgsU4aGzuJmmEKLyW9eIQmhmcR92aDFV+ MIhdeKGFLtL+BAxbMe/q2u1mz8IfDgSsFnHyXcRjFj8xfh+YTdEV+g/u5NGmxsyxIhmXUczd s7efFEg0+rU6r4SxIU6/i854wYRNBWDwuFK9d4V/9tqO5XRzaJ4r37KWpPJns2ZVNL3JytY1 GSS/ZUW6V1PtTttFK9jS2lzulVMATECqZSPKiwKPyrFgXILpli0METQQ9rPgpUbxpsmwEXlj xhUSicpKjtJjNtUePpHqJq7jlR/2yl9fnmh4n6lIfJkKCkS49VbuobEOR9cxT/iGPRr0GzYs 8tPf4su/Pv0UzRf14xP99EX9pb78MEAWG5DIeRKLmg1QV/K7+PPTn+Trp9/Ep59/fPqt++ZW ohtnfG1VqiV2EZu2i980gvz0219jJfrd0kDbLvWmXUIW2f7+19dP7R9/GvBNCtNmWidfMjI0 vqS+/vry6bsSUr/YGtROkgNW60u8cQk2iNW8ptGtfqnT13oL9tsklEZ1iSv7wd++/dRj/OnX t696vNo/vn7945v5rz+/KFsXtr1NOyXzSpDGYPJvf4kvn6VuwCeDk79///WnuQbQxsxV6mWm d2PRXxv+1//532acGtPfMjktVdHh1jbbDOwnA1Y+/fqhvn/6YhInkda4Qic/VjMmjXCpWRzl 4p1Iamlk/SDpd4wE/dQA/JNozeVIv16ZUSZl+vWW1s4H++aaarRYmqGVVgaT+lejPy+MIGs5 Gib30x/fTLtlYdqdFMGG8rJfAd/MTenr189/mLuV/RpJy22HquFrZul800tQyaHh4tcXO5tW GIqFFmPM+zqsEOt5/dN+m3Aj/qnX2rLkasiEpd/89+efn/qmfzfC3JkbHq6SwyxabufVNFx/ 8Lv68eurlVwmF6+gpa7S2NHbP7S8/vvnpx9/f/7Z/m5fNCZ0mRxeou86RuSFlPPt2sh5WpOu IYYZ2x/t70r+6m/U3AwlS8peo0ppJP3Pn59+/dkvK3tDtjK+MPUtb43I/tU7Ffwufnz6U32T Zg8b3mf2s6nXS4LFMJY2xiCuwOoRkhtZ05V2OzBTqfeB75/Ejx+ff/wcRygtfjcpBEwKtQ5K oVZlpVBjx6RQC7UD6LYUar4m4JYUahUqC1b3RIJ+CjXGzTqCTAt92jPWvgWmhf6dW1Ko8cm0 4JeXbY4iIMIs2YoAv64rhVpWCrXz6bqexiaXydkFCU+2TU4t2OQUaJOTEJtoz9lFgIVjjDxd 0agmtXDo29tbdqb6GqG2YvjpbHLPRTw+zlLKJqdCm5zybHLDELuL4imIxycirlCy/cpwzRNO vlUyU71D8wXrqXYkHs/l+7rFJHQ48TgjNWGhGW3pu8ETH4V4nEcCANnk9uH7erfuO/qO98f3 /3z6Kv78x3f9r39pgCD/+Ere9A33fzpc6PX31fybbLv27dv3/xk1nnvTfrGL9uvhtF/6P5QC tF99+UX79c9cuhN9r2fl8bRf4zy9Nu1X34udaL9sZSDtlyssEjMUd3P4SxUUFHOB1N/qSqft m1sG0X75TxQBOOofLZWq69pvGZqdb7Ch32L6kh7BJ6BlL0r75fxekPbrPgw4/k6rzKBI849U wv6mgvG/XdHw/3JDwUJlijXI/DMVPO+YnVIZDLAuernXpZej6XgtUqfSx1SxwseweSUUPm3B OqJ31SdT+CSdsI9PH+PM0m30cuMQhxfBoLKJkS10wiZjQPTeTti59HIFSiSlNULo9GoLvdyO TtgperkBXB3uhD1/1839Y5hOpIanPMMdJdsJ+2z+lnmIjnbC/gD0cs/vhH0+N9xxhC8dTRG+ ZNLCOe8QkPBFd6lCIkELt0D4wkDCF3IL4QsRcodc97YmpApaerDC6ctZsMJ4YhMEwoqYtfbh dqRxlpYIX5yCxnj+OqYfJjkKnHkJgvZBw7vhBR175637m55I08JN4mD/vyyFX+AKUrgzgeiJ RIQvBOVAA3DMYsKXPGq3Ww6iaFQNrUp1COGLFKIQ0XeXmmqeOIfwJS+Ue88xix2BQ0nYj9rt BMIXuw0su3RRtOTSddHCvTItXFvUpBIFiBLupIXznpcirXwoFU6ghM0Z4oqu8clizqeFw6wg 1NJDAcYeUje+secI8thNtHD2i/YJewfFcP5Z+CK9MUNcJi0cqlKEL0aQslBCSAu3a4a4u2nh Xi5D3NBUWIGQrOxdZYh757RwL8Etfz6X3HHIAPMUMsikkXPeQSlkIEnPzRLTyC0gAwUiA5RA BhhhIKu9loKWNUqQtk4ggyJABn2wL4Wy3tgfo0VZg8hAPR8yAP1Qj0AG6B5k0OYhg1nixkqy kAHKQQaMJDLXNJLlIQMUIYMK7YYMcqngkt3ki8gAh8gAX8ggQAb4eGRAIzkLJWE/KrgLGcDI 4HzquOOyyncilVU+kzXOrQvKKq+RgWA1bgFkoL+xkFWegVnlO34LlbyqZAIZbLUs0Ia1kGXB 9uUkZEDa1sTbxsig5XV7SoRKtyWr/DpJ7CL1wxYq+ZibLRIH+/9lnWB+M4K0jgymtTBv4aLL czrIQgYp5rew4EbLQhdSybNjqOSlqFkbfXepqeaJUywL3fFU8mUkZ6Ek7Mf89gGo5M/mcDvy kNc3rcQhLzYf8ipxyGtZFBI85MXCIS/AQ17x1PVfLrDIFyh1/QcMA0LJtGGAy0pQ8JAXpx3y mErZPs/1f5ylTPeBKHFttXL9H3uXPtMjmZwHlzTmHr56/UeJzHBGkLIOeRUc8rJ2NLh2VRS4 wjJYiiz3kL/TMECWDQM4NAzg/Os/2JB3d/03noUHX/9B05gnCfaQN0mjX/KQ/wA5a88nuTgO WEiVAhaZ/BZuXQlg0QrFSxBYqAVgoUBgIW/SHpQska6W+uEOq9oDVFUNgoGFOk97kGaILdqy lmMk2aH8FnsmonPmdiuwkPsCCyNIWcBCRsDCoZUYgAVvVLAUs4FFHkfFjdoDFWoPysO0B5RF 313UAJQnaQ/U8doDHslZKAn7cVS8R+3BXTwT6BieiTge8mPzTKCKljXAM9GXXzwToYbh2Xgm xnl6bZ6Jvhc78UzYyhZ5JsY/xN3M5Jmo5qDB7S1b4pnon7iNZ0KjnrLQ/4ngG9CyF+WZ6CWx bBmpX5NnQiohx2+a/zgFlngybFlReaIhUBGrn8rx4TTAmXD72Oqx41FlYyBx0E3szQiBP3cH FsNBN3kYlez8Bd7P5ifquCBVmQgfFX7LKgxktNjSzXmNMIp55SoTFWNVuJymhuBl1yGsd0sc o+NFgHXFgu4YCyqqssGc1IDO5bBYUKTClMCmXTVtZQFwigpXqx7oXDA1meQAncvpsaA2t/zt FBMHx4K6k7Ouc+nQTh4bmbGgmDbUK/AEyenMllhQiqBjJiEqyzqXR8eChjqX4hCdC69a7NCB jN9d1JsUJ+lc5PE6l3ceC3qFcr5wKKc55JuyhgM2DgrlpG21wWNjMZSzprJ9tlBOQgSzCd+i Qx51dRUm833OUM6owHnl8FBOUiTIv60gZR3yVyjnbS1LeGwMDWkRZ6tEXvPvCuUMGvLEh/xL uFxcoZw7hnJqZNCyrhAgMtg1lHPBl7NRKYbJEBn0oZxsritABm3NpAKRwXmhnPb6bzeTEBlQ fV894/q/KZTTXv+jM3QosAEbUA6EHJeLKNgz0+WCFDY/5VzgCVIWMghDOWXlVXYfMrg7lHPF 5SKkgioPoYIy139ZR99dvMKXJ1FBqeOpoN55KOfRh3zx0EM+ztFx6iGPU36VZJtfpdnYIL9K c8hrSVTAIa+/seBXSWK/SvuN1CFfQod817Q1YjXBKb5HAh7ylCeu/7iksoD4GmxfTjvknypv 2DhLe+n4+9xftx7yt/hVEo5gJqeyrjOv/yj0q8zM/ZV5yLdhy6KmInDMko86Q5TI/XXEIV+U XfTddGVj7q+jD/n83F97jlkBH/KOJPSHfHUd8q9AvaDHiss+U7uyebr/+PubHmfxTX76rjr1 XX1rp1Tf7P4jv/LlgYRHvg0kL4opx27wPHWPfKiu/sjn/j7sHvmkY3rzFaKYTfHTke/8LTzy bbsonjwoE4J9V45d/SkzP96R78GB8R3q12XS3I5HfvAJGh35fl3vkYhBzxJ85NsM9sGMCk/B bzPWp+bDOVh7KaVFUFmNYjkOPwec0qrCJStQPKfhZEYzCHZTli2esIeLH7quc2qbnihlaXQB oY+WuxhsAS6id8cSnlpbUDfX++2NWemeON5ziKBorlwgo9FfXbo66m7RSQNFj66dhZFoDJTB LRNzuqTOKGowd3Xy/ZA7BaTteFNHY4YZrYWc/NqgluluFh2rKu/7TVnGEzC/C89IP2ZFJ/xj 2w4sCHqd8R7nqmZeQ2QtSWQlifHDNM/Ro1vASNSypcrsQwswyemEaAUj4aOhRyuKB2JhAsZK wpaNDj08rL2Mupnw7ATGLNiCmia9AqLKon6vdnMYM946u1U/vRyQlaByMPMuPJvYX1/AE8Q5 NNax5k0wKKrEHDC6EvO+qWh8IZ2xxB44Fm2ad37rvn36qWHTJ9Ea0Kpfr4zZiZTp1/VW73zw kzkRbTV/kq8GgzYG7JJ0yhOzQxpyc/GneePTb+LTzz/s+/TTF/WX+mLawEpTh0q1we52uo6/ epj+9/fPP03HMTevYZl8zWxS82vflZAjsE+Or91P+kky7Ou//TU2V79ZmlwtXepNu4jtOBse 9/aPP002GVIYUE+TzO1Winvqd/X115epay01rUx+q6plbebUgHXznrAvFU3NrCi0yVsEqktc 9cLw7edP0Xz69e2rnpj2j69f//hm/uvPL6ofW9vZdNQ401u76E2Y/+v//G/T08YkzimTc7j5 BY4Z45HgfSGmdYqbxiUnsWwaYSZ+6Ja5u3z//utPk2+HmOmnyenQd+liYOIfxvXTH9/MF2Wx OCGiKhkLXvzzu/pTfDcvU7YkOA3lZW1XyDdzt/v69fMfZknUposkLW0dqoYPmqX1Tf3QF7Rh oMSvL6av1M5hkbyHigpj7gifnpo/7bcJXxqktiy5uYn+MOkKvqp/f/75qW/6d/2q3kvNQFXJ /US03G5gpuH6g9/Vj19frcAxuZgJqdRVdnZO9Wz+++enH39//tn+bl80G5BMDi8pa9WYu7qU c5KnRr+Svp9rjGLG9kf7u5K/+is9r+yunJxDVcrWbBs/P/36U5rZ7+/0pF0Um6blLZt3qDjv A2FLh0FTEiyWE0fYdFbJ7afpStIMU6lXiT6Mfvz4/OPnOEJp8btJhaFnvuqGr/34+dvnT19E o76YI8iIqYNNU2oMP+CT/OOv8gEBn6E+A/X6jPHMrxBTVW1EcYui4q+va5Ges54iQkygaaIY kQyU4dLRUwytFvpyLeopFdVcXuqZUaNt3Oopxr81epalRFOkp1fedlZ/8ig9RVhX4H8wv0MT 5bGewjNNAO+Eegqc0FMgxLpRVl09xXxhjDwTve8PnolmWtX8r0t6iskzEc16CniJnM+/9iSp YbNJ2CDhyUwNq79RL5Cw1X6INB3pvaLUsAMJG8DBbmyKNRUVlSyxcMC4HZiEzdona8TnheOg 9DNTwyZDpBskaNcw5S+cY0jYUqlhe8GKZjoaYndRpFLDRgRueiQgAjf3pmp/WwyEk9SHjG7j z6+MkDqRGhY3sT3QF+1Eatiq8zx4vaZ64ueivVRq2FwCtwX1xtgA0B24C92Bu+XUsO4f8tyB V1RCfcueMTXsPEQ57sArcrb4aFjAIgEIK9uPwO2k1LAXi9shLG5PA08yqdyilbEFnqgFeKJA eCIheGLKjSIvjeubIKx47ksMT0w2jyQ8kWKEIc8DT5Yy1+emmN0XnsgleKJCeKJ8eNIP8Qo8 Gb8TZ67nrWf+2i1zfcQLN/6Cygo8UlGEO30ThyQHnTkgc32KBm48P4/OXO/+IYYnxXuCJ/MQ HZ25nkcCAMGTfWjgrsz1u5DHhbpE9I+/yAG6xI9OHqf/QylAHteXX+RxuZoR/ZeKnEAeN87T a5PH9b3YiTzOVrZIHjdQxKG4m5nkcaXT9s0tWyKP65+4jTzOkLgxUc0n6/gq0LIXJY9zfq9J Hhd0Yh/v9YMqM+7u5h+phP1NBeN/u6Lh/+WGgoXKFGuQ+WcqeN4xO6UyGGChh6p6JiXN86t6 OkbYo1U9+htNOoRc/83DWz2gr7tY1YMZUVxfUePoMow54xQJXCRY+3sc6EWXoUJRDmUD7pqm EPq+iH3W/mdW9WDG2pbejre2q3qcWYJVPb1gRTMdDXF4BYQsUfo7sapHqseoevrPZah6Kjgy DREWh58HnTlA1VMZr9GPqeop2/XK3qeqB0UCsKGyS9UTrqvbzEg4Vt7wByhvYoZaq7wxM2nW V1NQDb9xliPYDcobNIWqDx/U+BMXpFEemOgb0nR1MR1OjvLG/I3JZkzbE4MJ7CpvnEZ7cWvh 30Yw4bWrLsC4NeeMgPzBUnYjT3nT96MQDAAT0/eFr7wZyympsv3Bprr0RXcP5Y3JLdggH0zo 6zeTlKuyI6Oy7eHKm3CeAuWN122voIniVwiKRh2uzI77PHm8lozL5BPT5xItGxsyS3vRJNuO mlJ2tCqKlcr6SaorXDWJfb+vTBAlgOgY/137KGMa8DInLMtFPuP3CxRqggZpaTjHKHo06Gbp DURbihYIaBlqdMAC5oJWVeU0Ve/ylYsRcMGwF8SBO2wbP/59ehQ3+p8Wt+tPzJVVdVWDj1Zc /2NaBj2B3SdiBBBVpvQ/lRemg0uGOgesjE9AE1DWDDuiIZRQJS95NETRE6BocNHS+dG6qQ0e F25lFeNt/ATYMq4hrdMr2v/jPCEKJWX8BFhZqWgQ92nHrFdxAKM6PuFXBj5KKlIxxdT6E3Nl 5n+Bj5pCvVmy9SfmyqigAnxU6p/ggq8/kSFnXUtUZw52vf8y+IlKD3PdOCtACcrhR5GQigu9 X/OigsWatdL8n9OytoZHRDaCdrhUb40QcGWtaoquJstuxBcp8I6kwHpZawxWEVBvcycpcNCu tIuOquga1HJuAAvZFinXsEZ6ehunLyfpbfQdsqY1AvQ2EPXfU5ACu9en0At4LY1zJHFjbyfA 0QW/t3k8skiBMUGtV+AJktv2DaTAnmeM19TNrEB3kwKzRS9gvYN2QcHZpMBDU58mjbMeoosU +Erj/HKcwk9jFcokFo4WxRarkKoWiIWryAG4p6xNxCdhKD5p+GFMEugijE9aIBa2SAmXBe/e ns0qhBpCEBCfBOVyPgJdoCWrkBGsaKajIfa3rcgqZIEIMn4OaRV4RPA7FdxiFaIhS/H4Cyoj fG5IJITh1rbQMvcI8SgGk8gk0yqUR0ocLZQVq9AYfMPD+CS+bBVyZ3OGleZd2ZGKp1Rf8ARs RyYRIHmgVWgeoqPjk2gkAGFl+5ESnxafdDETvy4zsd72q5L25Y9lJoajmBt95mDc+/3mMxND viPmV1QdaiAdxMVMfDgz8fDbmH0Q8QwdRNMyr2CSFiG66KQHwdDFTLyxZURW1Ooqw++mK7uY iS9m4psP+Yuv5HX5ShYSDWHZJk56IAWh0OcvHBBsLqv60vJs+oB0VA6UZ/i5+UqmIQ7vCeAR GFoq0Pl8JUi0Kb4S2UYowRftpD7Ac+xMooQsfcCtfCVBmltbYawPaDvp6wN0Qb6XaFZDXl0f YIbo4it5gD7gA5grzuYrkQ2x7LCWN9cQ9/7x6WvPRCsNP2xV3I9N7NdcUQ6xyUjgDWETwsY+ WGwyXNf0JUKfnPpvADaxTMoRNhm+4WIT6J2IrISI7Z4QQx9jbFIAEcPGluskOCDB94ckEg8k IXz9ZAl2lkJsMvD867uS47wwZBt0EYDkbtjo+ERiZ6ZNHQ9pJJNjgRmotmA8OrQTcAK5hg8g rYBtXFzZJCfJyvpuAkkitnRzagXAmW+/n2gZFRm9ii4wANIc8314nWjQHMGSHNWosilbxBuc T8LNGhHUBcxmPwBdEXdzqbKl2QSyCKQmYAioqFANd3MpwcRSkogUNqmAyqY/iq7Q/9t17NSi hBng8JGfT2IsKOKcEEGTcdyrxIzYMbNJIsDKOi+vAizwUJKIZMuKeHrHKUomx1ioLD0B4RPj QwtI0+mEnyRiSkngNzUptNOIbEoSkWxZFAWdkSRiE7DNhj7Ri/emO2gsr3oq3YGolrMdmKW+ lu2AMLSY7uDKQZCXg+CODAGsq1sySYl92YiJIfqXZrT0dpccrltzBFw8/xfP/8Xzv87zz4/h +Q+v3wjg+RdlsxLeaT3fduH5T6n/pytjjvp/4POfrth+OfHU/+Pfep5/3o5X7KAcjOt023Xx /IPf35Xn/y6yu+KYeOnYp+Zjk92hiuojKSa768svsrscs9oZ8dLhPL022V3fi53I7mxlT0l2 17dsieyuf+Iiu3uvZHdSWf2H/ab5j1Ngj+uwZUXliYZARawiKseHFxV+9jcWjPTUcVx+Ip8m 9maEwJ+7wxiJg27y0Ojt/CWhgJqeqOOCVGUifFQEQee46+7q5rxGGMW8cq3girEq0oSNDcHL 4XlY75Y4VvAuAqyL7O4iu0uT3bVI1oJ1k6nQaddzujEdHzR9L9ndNMTuovDdmCLJigqcd/dz Y8oku8OqFHDLOhoHXPuinUy7lBdwneXGlCK7WyuAidsyA66jPeqOU/DV3ZhyA673RA4fgOzu NfyQ8EPxRcxz98T4gh0QNs0WwqYZGDZNXHyRWAmAnlQWCXyxgZTFHn5NQ9jLkOmCYdNb9Dm3 hk2TJXzBwrBpVlXxEKfxhbs9hG7S6HFu0rZbOWHTNIEvjBDC+GIctCPIdIVq4pZ5g/hMZLpg U3Na9oz4Yh6io8l0cSQAYWUmmIroi9jlJv3M8OR8uringSeZnHHRytgCT8QCPBEgPMG3wRPE d4InSoj66eDJc3lKj7OUgicihCfChyf9EIfbFghPGuN2OlZGZFtIc5yknU57PwDSxjt9FjzB OeoPiRNc/1N2vQQ8wUl40u0KT26L4so5HcfhffBVfr2ySrBSt8Z/tNXIy3miLKpats66KwvW FIBoRN81/jRKMMDE4P0vEIUNQ5QR673nmJFIACB4sg/f3FnwxO4Fy55lFC15ln08BrkDaWF4 ipo2kzzOeQdB1LT63Ohq1AdqxeRxC9S0CqSmRV2KFgYDweJaClrWKEHaOgEzgOzRQl9SoGBx 82OUcEY8mOH05SyYIXktIfK4Ddmjd6aF2UBNG0AFzqRhX3PmQ1YE2BcNs0chO1kmzt8UVEiQ x42/vqAjlV8wTUGXSwvThbQwBOVABXDMYlqYPAK4Ww6maFQbQYvqEFoY1ZUO18r43aWmmieO p4Xph+hoWpg4Ii6UhP0I4E6ghXk5lFA+FCXEWZ2fViOBUSp2e09eGbbAK8NAXpkuyStTL/DK FEmoAPDKVJ1I8Mpo2FNWlPtQ4Qk0EqSpmsEBN3AsV4jP43Icr0y3xCvDQl4ZVlfxEIc3lS27 rvNubzDxJxfawtdhhu3WukaCJJ3/jBCGW5sv2kmHDE+JkIQZWRoJWcMGk7WC0q/MVgjxzHYh z2x3tsFkcO1DSKo1JcIxPLPd4Q4ZZSQAsUZCtB3GL6yReAmLx/m8dQdpIQxPVpsip82krHPr gshpW6Rw25RTLkL/GwvktCImp+3J0G5IkEORTECLDcYO82NV1VBIC2H7cqYWgiJQCxFT1j1c CzHO0s1aCJc+wl7gHYNNoIXg27QQMTFcJA69vDCYnNYKUrgzxQhqWgthJ3bSQuTSzt2qheCh FgIdpIXw7/r9d5e1EOgkLQQ/XAsRp4gKJWE/2rlLC/H89HFHogSpUihBbUYJMoESCKflFIHr f2MBJSgQJUiIwt6UV072Y5fCvsWMVESmItvDRDf2vtckbRW4kawTIEpQp6EEY1+xIXMhSgAp 7I9QQMgNKCFKowd7XW7RGUQyOQ8uabpqdfcmNOF1iUsSe12CKEGGKKF2ojrMqmj1rtgWwVJk uSihDlsWNRWhhW4Wy0qEJlQiNPlp9MCGbDk+55Y9cRo9PURHp9GLOfJCSTAoQXXla6KEd+lw +VV9/eP7fz59FX/+47v+1780nJB/fCVvv3Xf/qfDhl7yq/k3fZNTb9++/w/OfK2cXpPua3eR jZQx2Qh6ANlIbIN5PbIRvXsjLOROZCM1b0CyEVO+F9mI0RdsJBsRXSe2kI0Mz7tQx2nXQ8lG hr+0Hee+rQVWiMBQ52aykX6ezicbmaQynPa5sgWyEdOL3chGdGXLZCNaWBqYbKT/SxUUhGQj 1ZwQb3vLILKRYFQx0LJRiN2WCWe8DdmIkh2bKTbHrwAtu4FsxC6wG8lGzLs7k42Q1NL3JuBY shE7I4tkI/53i/qN1v0/xcDy8YaJ/88bHn9DwVwZDn43FFyVvcPKYIB1PtnIEVqlSbMhYA/Y TJ4Rp64a9IBVSNJaQbYn/Y2FQBuifK3SxGARaZXSPCP2+0bjo1KBNuUbYHuqSYovUV8nOYMS I9q+PItWabz+mpS07axt2wq1hn+9jWfkFq3SOPy4zVEdjKdqQqvkyuQ8uHlaJaakVzDNQNGw Na2S+91BQDakQM7SKuVyheQrNRy2cVxLWonbKrPvksh5hIQF4taW4a6Mao95wIaGTGxbna8j 5B0n+nKOS6FCyL+oVerf7TQs5RVSke7mwVqlUDRukYT3q1W6CEMuwpA0YYj3fC3S/q/jIZ7p /wqbnyzooaQqKg8onO//mgIKhBHRlPozx5qf7iMMGYfY34EyCUMSpqsFhQAMMhwGjwhkrJwG uCEjk2UYoVlVEciIPgefBp7LahJkZPm/pghD1gqKeMzyTVfRHvXAE7Rv2TMShmwzXe2JOi7C kBe1X12EIR+BMESLmQ9PzDlIeE3rbYQhCtW0ap8tPCfpHaNfwWROCXUcPLmDMGQc4hV4MnFs eMeGe1z2Y4w60jmZHCN4Ev4l7X+bSRiib7qJKGAjhEvwJE0Ysmfa51sJQx6V9nl81M/Z3Zuy SqoAjdbN8KTMqOx9pn3+AIQh/Urv8cXn78pkkGqqxXxeH48g5GmwRSZLSCTWW7CFWsAWCsQW KKH62JUlpE2pPmTH6rqd3FGeHlvgRtLDQ3/HWUphCxViC+Vii3GI09gikqyowHn3HtUHukn1 oYyHDNSyrsaL2AKlsUWefSULW+QyjESbRKbqg4eqD/4cob+yqnBsvTlF9cEPxxY0EgAQW+zC MHKF/i7gi+Kh+CLOofe0+ALrmh5PLUIWqEVITC1iNuEktUiZphbBhQp0F/OfYnyxQC1iNgJh z/6nxxejsyeR3Qn4YolahITUIqSu4iFO4wvnL7xy/FONaaUITSusoGo+CDbiCzAqaA1fNFRN Mh8J4SK+OIRapOrasGVRU6GCd0Atglf5Sd8rtUgRCQCML6oXxhd2LzCn/re/xJfPffZufRJ/ //7rT6PIsJYVnnrZbhM9OPlf/+d/m681pq2eX/wH5yR5GmCSSUwSrYktwEQsABMBcp6pJDCR C5xnpWq2AJNqyeejKJ6NhT3pHEoKTIpqkvrjQo7VEjARITARdRUPcRqYRJIVFTjv3qz4mMhF 5onJ9fmgcMuMECaBSUyZ4gvkbsAkl9QkLODxmIFJ6EKfD7zB5+OhwKQsngSY4ON9PlgkADEw 2YvU5FJ8LOCLs9lMOOWI9IP09esv9e+f/TDpQTAzMx8VMLaw+UfyA09wI2UUeKI3unYg0YKw xXRWLmGLcTEVun+NUFWILXrSC5/OBKwrpDORYjvp2VCXwRZQH6MY33mPsdjC74v0jSoBlcuE LZxyF1sA7bo3xpfoc4XWCAVKj0qVmLbVPC4HJaAbZwnAFtOgz50iXcFK/Fb1uzghwvC3MT4/ UaqqFQRFlc1em1HtvXx3bHw3emJhm543YWGjT+bKBsHwVCpKNEFOEG7TsQyVDa4bY6/cd4mq ZVZ8zfTd6V8pY1yJqam4obQrdQOdV/qy6GiLPF0h19e+tZ5w+adRJPbjm3bMsKgSg0jnJ2Db 0fzouNiAkF+UWl5Qy5y5wgUvA44zgrmzVnCnxzWOo53y3Kf7PUwLjToDTEBFC73jVqvdJNMr LWUNaaoUn8w0IsOGrq/vC+ntVysjccuW207CqOi5Kq8y0nDpIxfMURxGlF4B0gd3OAB3tpth Z2Jw17d5jEJPQsew9iWmG2eu7BC1DQrePYPpZlhO/RN7Md3kYpPwPbtRjhju159WJfWXMIQt BnX9X0a91OoaWLICu3qHD//68vOzaaqBdNRgOkpTXjx2NejXfvznh3nDoFz1Xb9XGV+eSq5D wYjjhTyA4yXGhDHHixbIFY4X6yBiOF7w2yaOl54Q1uF4mdb1iP/ChtygWyIe/nPWYaRbcjea iONlWF3b8F+/z7j4z92QQI6XWX8W4T+KAY6XuY8T/os329fDfzdzvPTzlOJ40T0Jx8GlGEGF rKp4c09VhqulU2ZAM+EUJg4GA+7D2Usfpr2c8gCADJ0oCWHyzT1h7LtBXfiGlkUnc7rtkHKj xnpqvCFCdcGK6V3cSVIWRbWCGejY13hEWo8wpjLJ9vzplU2dOkwxh5vqyrP/Cu/ibs6TF/Vq ue2KgrOJq0pSJ37aAns+T56h2GlYhaK2h910cjoNj/Y/Z7wHwWjntqu6LESNkqCNVPGYpQZi eCIiThwHwER2+wWFO5tlh2kTPKEiPN/7W1NG4htOsTKbKLHQKYnnyunVNAFBXVBUuq5MY/0o D2UUHh98rkOwaPCma+fbGSl5yRnGW7q5sDaHhkRNDfu9Aie9hqSEdugmA3aNSL5T4+1+Tu/G 81Vv+K+7KPdwDMeKB8CxOOz7NSn3aMn3odyrNQCHKPds+Y6UewOz8nuk3Bu+0Rqd2uFwbJin 56Dcs1IZTvtcWZpyz/ZiL8o9U9ki5d74h7ibmZR7ZXkb5Z5t2SLlHtYDk6CPM7824qKbjjo9 2l1Z6P9MT8Dd7B9+Tcq9XhLLlpFappa+N2bPRrnXdaoy/4z/fUPBcmW1+QcqsP8dFXiVLT96 VfbwysbZnB69TTRggHVR7u1IuSdryfSVk769nUO5J0VZEYxiqNX/fMq9/tuK8maGR17ot2j0 7aF+CyyfF+Xe7ZR7LjldknJvhr7OMTOeqtPx6hXcR7lX+AXTDChxUe4tVHZR7vm/Pc1bsen5 fVHufThSmoOyNRlTfQlna8rmo3HewalDvmVNBx7y+gBOHvKiidybeqaTOFuTfV6m6fKwvlUk DnnAddrQf6SyNQnZEarAQ16UT3PImzJ9I2aSclV2RHiH/EF8NBmHfMgpMxRUGFWex4Zlmth8 yLsyOQ9u5iHfwpwyVpBWDnn3u75Q7XbI53LKJLvpWptyOWUydWN57s8LEzC37HmzNeVyyux5 yMdyFkrCfpwyxx/yF53MM6ECzFOoIJNJxnkHJVABZzWJnJ77byygAgWiApRABRjhST/qX/0b XFFRdQlUEDLJFFRxqVHM7KjioQIkmOIliArUaaiAkLrF9tCJMj1j0ZzEJLOMCsJdCz4c3FAJ eE/0WFHSMGF8IuZrgRtSogZuWYFjNhgQFaAIFaSbesPVP48NJtlNsoQKJMJhtDY+GxUMDWFt AQRFHY8KzBAdjQootAI8SdiPDeaEq/9LxEOdTwRzIDLAqezOmRww7m4IZXfWyKDCktUAMtDf WMjuTOLszj27SAIZLHDAENq1+fqCFAeM/XGk9ycAGdi+PBMyOJsD5vbszhGPC4wMYpaWPGTA 15EBIS33CjxBykMGQXbnXB6XTGSQx+OS7Ga5jAxAHpdLX+AP0dHIoIjkLJSE/XhcXi8Pz0sA i/KhwCJOnPzERC7sACIXtkDkwkAil47fwo6PeApdbGLH10ipQLJ7NiKXyLtz2AYJ05LJcHsw uhhnKUXkwkIiF+YQuUxD7G9bmcl7ULs1eU/4lzQysd3KYMeXVTvJViSE4dbmi/YRDLayvi15 z+sy2C4ikwiQBC17Hwy2ZSQAYWWWyAXjFyZy+Qjw5HyeuYP0HobXqk3pPTIp5ty6EnoPoScd yj+sv7Gg9xCx3qMnL0voPRYo5nibtIhsoJgzP9FxjAWo9xCn6T0SfhKNKFrV1vPecijF3OMs IuMjaTARyeQ8uLnOkNgr8AQp3JliADZ91xeq3fQeuTRxyW7yRXQB08Rdeg9/iI7We4A2QU8S 9qOJuywiMDI4myHuSGQgVQoZqM3IQCaQQYMYniJS/W8sIAMFIgMJIQNTrsctTT5LGd2CDOok MtAHC1MFiAzUiRYRYW6Ksc5CV1aVmByPDORmZDDuuoWexhWLyPjOdLpGBRFUmKYvohSLGtKP NEv4ShhBykIGMkIGNdoRGdRRy6CCZDfZMjIoQ2RQ5iMDsCHvDxmUhyMDkAXMk4S9WMAuZPC2 C58FivksygfwWcRxl6/JZ4EH6tW7+Sz0Hb2D+Cxs+Y58FgV/x3wWifiL/CDL2/kshnl6Dj4L K5XhtM+VpfksbC/24rMwlS3yWQysFQCdQiafReUk093cMojPwn+iAMmVSqXquvZbhuYYWWx4 JZio5oN1fBVo2YvyWTi/F+SzgA8+/NALdMzfdKZLYUdTwQZsc7ABgYINFKNVyRrI6K+/sRBs wMBgA5IMQazTIYije2JuCGKXdims2hpz4AJt+3LWBVq2tIbT1irUzuaLgxjWx1m68QKtF+jD LtCjkK5dbEqWSD1L/JalXQpJFGzQod0u0ELBhvt5EAmry0XavfmocC7QQ0FIZCXODzYYGnL+ BXoeIomCdx98gcaRnIWSYFwKNV65LtAXOcErkBMYZNB16lRyAn0Ibwg2WCInQDWvWt8d0OnL WcggVK2bwucmJwh3LhcZrAUbjO9E57533Lo/FxngPGTgc9Z4ghTuTCAy+LDkBGBD3g8yuMgJ PjIyuAgKdiQo0MigbhoJI4NdCQoAdzwtBS1rlCBtnUAGIUHBEEueRAa6KgnTFp1HULCUip7o ql6BoMBBBg80utNcgoKUzqCrMmmLPixBAdiQ94YMLoKCj4kMzicoeJo4wkyWgkiqt8QRkoU4 QhLHEfbx74mE8AssBSZpXL7ioNKrDE4Ir6EObRHyqYuvOEKQpSAdR0jCOELixBFOQ+zvO4sJ 4WdogWFzRHQqL2CNRWiRE0dYlBPvcSyE4dbmi3YyIbxnQUhCiwhRwJXlMRyEBUGQfBJahJ7+ aENC+KyGvH4c4fEJ4YtIAMLK9mM4uBLCL+CL83kKjnP370TK3T+TosCtC3L312dFgwsOUSPq byy4+zPQ3b9LBgLWC9CiKDa4+5uI8LTmoal7yBO5+7Pz3P2xEtIeGKG3Amqa46kRx1l6bCCg kSzScd5udPfvctz9y1bCLTOCFO5MMYKa1oIvVDu6++fRDCS7SZfhAUgzkKl5eCg1YlVx8RzU iHk0A3siqDKSs1AS9qMZuDQPMDK4KAJ2pAjQyKCt20aCyOAgigD9RLFF6ZCmCEASCYlBZPBE FAHDFkYoI6ycI+KfiCLAXd0hNSJMQLSLTWIU0pttEkaQspDBh6UIABtyNzIYmvo0NomLImBv ZPARuIcuhoEdGQY0sJBFinP5KIaBomy2AIs0wwCqayEJCCxOZBhIqxwEJkiNEncxDGQzDJQw 57IVpCxg8WEZBt55gMTFMPChVA53MQywmGGAPoBhINZUvCbDAC35LgwD2HhtAwwDffl+DAN4 cMd8jwwD/Q8wWGwJr7yRYWCcp+dgGLBSGU77XFmSYaDvxU4MA7ayp2QY6Fu2xDDQP3ExDLxL hoG3N3eemw4VDnCsSmIN137LuC88CvG4myoxZhCCHls9vhJVNjoXTd0cZ2TK8T0mZOVjwRgE VUeVjYznzSQrQ4G8C/RuL/hYlcEACz1UUTPpWU5W1EzKAgFHpRCWr6jp66qhqJSOYCmwPbPj qBRSpaNSiPIVNeM3YkUN1s/yQuOjpKKmqcuEoqb0FDXDmBQKJRQ1pWy7DlLU2L6cpKhJWYBs 8Kex8N0ItYZ/3aSocWZpuwUIiuwMViykqOmCXyyT8+BmkURj3iWoII0guW0HFDXud5O9gpq6 JSplqox3TJKyKGTNvAJWqyJry8SSmsRdzrtYMpa+6yfVIdOvKrzacUHCyki7UhnXXWWIyrZU lVsZadoyq2VYlkxMGKHzo4+T3VxS1CAStKw9WFETikYoCTnvPrGi5k4L0NHGnIvtake2K40R VCGseuHBbFeT+HmptTvSISLQhsjVZWMOURjGCCeyXRHBWqOxjtQxWDHO2fGhKdvZrqIC55WF 1Nrpg9cDDeMTNJPtinXKL5jERckMYw6F2K525bS403/0gZwWD/UfJa14Cv/RMzgtLrar85HB xXa1I9uVRgadlmEoxdRxbFeM4wQy2Og/ilWrr5YgMjiR7UrWsP8oLjHTl8OD/UfpLWxXUUEa GYyPROd+FjLIYrtqyxJumRGkLGQQsl3t6j96N9vVy6WY6huiyuI5kMEZ/qMX29X5yOB8tqsn 4bTIpryKpDqf00J/Y8G4MMCAmPIqwWmB24TioCoKVKXgAY3hQYryykKdSnI5+XGEe/tJ8CCR KaJGehNrnc3hUMqrFKdFL1jRTEdD7O87mZwWCbqs6FTeYqmYJGXksQq/H1TGUCI0BeM4e6Uv 2snc2Hl0WRGigNXReXRZK6dTClrAdFnRHvVArXsELYamPg+nRR5d1p5Yg0YCEFa2H13WxWmx gC/O58w6kE0TpwJMMumy3L0RCjDpCMGElHBya7IQYELiABP7DUfzkFgEQApLIhPQYnIRDY/8 hE2iYiWBeLZtX87SPEA2icFBEneqO4UuK8NvYWC4akhS8+DIFYhTfP6qPHiQE2BC2sovcAUp 3JkWWuZu6HmUV1mah1zKq2Q3i2V4AFJeZWoe5skz6avqEnW83aAseJEAk0zKqz0RVBHJWSgJ +1FeneG3cBFXvS5xlTnkW94o8JA/irhKdZvoKUTSvECrgncSPORPJK5KmRcsPQU6Wn+QQ1zl ru6QnuKByTQyias0Kk0c8kaQ1g95gLiq6jyLwH2H/N3EVeXyId+Fh3z3JOYFhJ7EvKCH6CKu eibnxJfQHlz0FDvSU2hgQZiopgBT/xv30VMklk8MLNo6Rba9UXtACn0phxkxz6WnUA+Iengg PYUvNd6G7x50/TihjnTAuXYbsMiip5BTGBqKBSkLWIT0FLvm70zRU8zzfuXvNL93lb/zfdNT 9Iu8Rwafv6uf+o2mMl97UWoKElNT8AdQU8ROkBc1xUVNsYNLQ4vdfeOippinfa7soqa4qCku aoqLmuKipnhoZTDAuqgp9qSm0AeM/q8SUNI8npoCY844RQIXIqGkYW++9cd8W1E+h7B6ShqM qJQCsv68DjXFY60/mdQU0QJ1h6XG26w/XfCLZXIe3CxqCsJo5xWMP2pIHJyWnU9NEbXd/S1o L2ZI8hJhp0NTz1fSnBd2GorGO6OmeAnzzfmEFE8TXJLJShFJ5pbgErYADxgYXEISwSUdqxdj T9sEPNhAMW6gjpKthiIePHjC4JJhH9OnnNTXsOJ4D1CyFFzCwuAS5gaXjEPs7ztdvDkO3A/I ubCilimMY/tPhhogjTWmVTJSTYSSHVTWqPFKGcWtthG0CDqTSpiaR08eIQqoslxGiwhHQ9qO XHryaI9agQdWeAniJaPxeK+cm9ugRbQfBC17QHBJJj35nlgDRwIQVrYfo8VJwSVPaAR6usDV AwNLeIrSIjNm1XkHJbQOlKNagLBCLVBaKJDSAiUoLTDCgM+ploKWNUqQdgPZVSpm1fy46DCC ya7UaZQWkdbBtrQTUojWRkgcDitQFiHmJDV3uoZESCCSyXlws7QOetpSgSWUZbiGTN/1hWpH rUNe3Gmym2QRGsBxp5fWwR+io7UONJKzUBL2izu9XENiVHCFm+4Zbiq7ouMN7DB6Z7ip93yZ jkTBJduUz6xJogIipf4YgArODDfFLSqx1Ul6qEAySbkqOzK66TxbuGkiEgU9LhIlM9wUly1M dGUFKQ8VfOhw09tb9iqo4Ao33RcVfIhIlCvEdc8QV9mVYshaflqIqz53twCLdIgrkoKXMI/F eSGuWB+D2AY6hNzapFDqcG7tR4e4+jOVOq1BYJEZ4or6yGCnwBWkdWBxhbje3LK1EFeprhDX lCRcIa5PDizYQ4FFnDD1TGCh2hSwEJuBhUoAC1ZobAECC7EALAQILFQSWMgFjUVRb6DmFnpM khoLXpSSgcBCnAcsqJStPbcC70mk1xQh9GA7xjhLNwIL1D6UO0PlaCxoA3tPWkHKAhYqCnH1 lAz3Aos7qbnpMrDgIbDgl8YiABb8cGABQmtPEiywQPQCFs8KLM7nzngS58tsAo1oUeQ7X+pv 1AsEGnXkfNlTM8TOl6ZcD15abUErugVddGnny04LpI8unsD5MlRbDNtgz8xVBV4SW8Jg7yDQ SDlf9oIVzXQ0xP62BTlf5pNvBJOOgV0/C5lInuN8WY1Re6GHRUUjZBJ0JsXsnUe+EQES+DzK I99Y6CY43kMBTL4R7VHwsZun8shq2TM6X85DlEO+sSdU4ZEAhJXtR75xOV/uwsDBYgYO+gAG jljX8bEZOFBdiBJg4OjLLwaOEHpADBz9X1pEuPItJlugx40MHOM8vTYDR9+LnRg4bGUgA8f4 xPiHuJveEM2V0ZR7/y0tgxg4vBeUIFFl/bmMS+UML67qah5v/URXckVi4AS07EUZOHpJLFtG 6hdn4CixJIWP5YmWjmhGSFhQhGM2/JAP2BpSR9nr98VYN1VWctHqMTaT1yrzz/jfUYFb2cqj V2V+ZTDAuhg49mPgaFHd8LbkEtDy7MzAQSOoZb8v2goznoqF8Rk4hjEpZAVoeeyv7hh9NgYO QgSPYmH6X0Palh7pnHIrA0dU4LyyX+L3UUjX9l9j4Adbxsp6zYZ0MXA8zDlFkhY9hXPKxcCx uw3pJYxA5zNwHBcPo69yiSjZTPIN5x2SQAYVx6QDkQFbiJJlYJQsSSZ+XyLf6NimzCww+Yb5 cckZhdxWbV9OQgaJKFkNilhrcpsdHyVLNkTJkodGyZKbomQlE36BK0gryMD9ri9UuyGDXAKN ZDfZEjJIEGicigyGpj6Nd0kmgcaeyABHchZKwn4EGleUbIwKyENRQcyEfiYqIGUKFYjNqAAn UEGNm46CqEAsoAIBogKcRAUyjQpwhTehgiqJCoqqQLwEUYF4HlQwbF+EyU7jcHw8KsBZqCDy Oe1f1ht2tQNjpyuT8+BmMnba4ZwLPEHKQgU4QgUV2hEV3OlzypdRQRgli68o2RAVHB8lG8tZ KAk2Spa2L4kKPoTP6fmkXE/ic5rNzBUtii2En2rBGqFAwk+UIPzExskBskZwgooy7XMaMnMV VHHZsjk6xvE5NUiJVbzFHrp4Ap9TOPXKmRwcS4SfKiT8VDPh5zzE/rYV+ZwmomEqMBomOtS3 QJVplYQ0X+PPrwwXkk8y7z2HMYmQiS/aSZ/TPFavCJDA+us8Vq+Vwy2FTGBWr2iPgo/dd+5z uo3Va0+oQiMBCCvbj9XrJJ/TDwFPLnaw/djBzFEjat5BmUoOYwdDquJb9B5pdjDE6hL5yMTp y0nIBPSTeL/sYJHEjeOThy6y2MF4Ip2sEaRwZ1pomS9UO/pJPC872MewhlzsYJfe42IHO5Md zACLRk8tDCyOYgfrcLcFWCTZwXArub6wgMDiPHawtEHllBwnj2YHmyY1iSMimZwHN8uggos6 kafECNI6sLjYwW5u2asAi4sd7AIWL0jicRywkCoFLDL5O9y6UsBCtQIGFmoBWCgQWEgXWCSW Twws6kImgMUURBse+LDGgjao6qAsJ7YvJ2osVEg7mtRYbAmivYO/43Z2sAfymccsGZE49DU1 jV/gClIWsJARO1geB0cmsMjj4Mg6vnM5ODKBRTxmUMHLAot5iHI4OPYEFjySs1AS9uPguIDF EzB4kJjBgz+AwSP2HP3YDB7YxLEBDB59+cXg8c9sBo+q42XAeb4FfNzI4DHO02szePS92InB w1YGMni4wtJghuJuDn+pgoJiLtD7Nu6qFt3eMojBw3+iCJxM+kdLpeq69luG2pnBwzBpMFHN 5/L4KtCyF2XwcH4vzuDRyaZDhaPQqkpitdt+y7gvPEoXRC1TiTGDAPjY6vGVqLKRjW/q5jgj 5VgwRoHzsWAM/qqjykZDaDPJylAg78LM2ws+VmUwwLoYPHZk8MAlJ5z32WQfy+BBgGy2mDNO kcCFSOh5fAaP/tuK8maGR56eR7SN6ipAz3Mmg0ciTtcCDYLRoellbmXwcIelxnsYkFyZnAc3 MyKHKq9gkvxSrWazvRg83rOe52LwuBg8zmTweJqQmkwaj0gyt4TUsAV4wMCQGuKG1CQWAeBf glLwYIMZyEAdphjr/IDdK6QGpPFIh9SwMKSGOSE10xD7+05mSA1+bEgNyQmpEVXKNwWJCFr4 op0IqcmlAIkQBVRZLgVIhKMhbUcuBUi0Rz3w3NwGLSJEEbTsASE1mRQge2INHAlAWNl+FCBX SM17jvg9MKSGp6hEMoN9nXdQQnFBZVNCDir6GwtUIgqkEkEJKhGMMOD5qqWgZY0SpE1Rj4bB vkNsZZJgTJ8SHQcVF+p5qERsSzU4kEVj87AdjkzQbVQiSwG7mxUXrkzOg5vn+VoJ6hWMP0yb nLy403d9odpRcZEXsJvsJllEF3DA7qW48IfoaMUFjeQslIT9AnYvB5UrVvfZY3U1sNB9Qi0A LO6O1U0sn1jlITt1v8rD/vSGQiCLyNmxuvmery8fqzsOx3Q4RwUR0hifyIzVRV0Dc5RZQcoD Fh81VhdsyPsDFles7gUsrljdM2N1NbAoaZkgATkqVrekbQJYbIvV1QCpKLsCBBbnxeoSTJl1 zXoLvVpRwwg/1NUiM1Y33Pjg82WRBGQlABYEFqOQrm34pcR+wfgzgrQOLK5Y3ZtbtpgsRUsh fYpkKVes7u7A4iWQAXsoMojT056JDPTtLoEMxGZkoBLIgDVtzUFkIBaQgQCRgUoiA7mADGhR 5SMDocckhQwIa2Q3xbuEfTkJGWAqZWsPnqegRR9nabsTZm/LaDPpwSaJGyvJQgYqBxkQmUij ZgQpCxmoKNjW0xLciwzupEWny8iAh8iAXyqHABnww5EBiI09SbDIANELGVw0HK9Aw6GRgb61 lrAx4iAaDkzaMoEMthojaiQaBiKDE2k4IJ3B+6XhiCRuHJ8sZJBDw0GwYl6BJ0hZyODD0nC8 cy+HeYguGo7LGPFQGo4ipuEoHkDDETtHfGwaDn0ACwzQcPTlFw1HqJZI03AUbcf54TQc4zy9 Ng1H34udaDhsZU9Jw9G3DKLhCEYVAy0bhdhtmXH3nUTTEHXIjk18Ce+bhoOklr43Ac9GwxF0 4lmIG67K3lNlMMC6aDh2pOEguFFl1+tm9qbhSMwqZAFK0K3SbqOep8CIQglizqTheCan07to OHo9z0487nfQcKCiEH6BK0jhRRHqZkTD4fEl2FUhzDGYErtlPc8z03CADdmymc8te0Y9z0XD 8ZEtQOfTcBwXjtLRVJxrJgOH8w5JIINOn2iQBUh/YyHOlYFxriQR59qxWiR9Q3DBU0ltQa/R Ou01WmLZdCAyYM8T5zpsYSbDS1235GCv0XGWbg1H2TXOldyEDPSo+QWuIK0gA/e7s1B5xBd2 VdSy64pgKbI8ZJDLopHsJltCBgkWjcsC5A/R0cgAR3IWSsJ+LBqXBeghwII8FFjEjOpnAgtS poCF2AwscApYNLwmILAQC8BCgMACJ4GFTAMLVLMUgQYILKq002lpLqMgsBDPAyxMGe90U3mJ HR6f44AFzgIWk9SMwKIv0Ht+5VGBoo50wLmWBSzwTQQaWCRy0hpBygIWOFI5VG5lflO3upYI dafTKV8GFmGcK75y0obA4vg411jOQkmwca60fUlg0S/yHhl8/q5+6jeaynztaVDBRau1I60W wS0qy/oAWq0JijqoQH+f4FoymiL8DGm1Cqq4bNkc1hLkfSsYLxSICs6j1TIjjK1CMicU5eEO p/ROWq0Hs1906w6nuGRwkCou2M20Wjs6nKZoteZBvPK+md+7cji9aLVeXt1wsV/syH5hgEVH aQEAi7vZLxLLJ1I3VKJKeTjUEbAw3y5aGFhg1NUNgiNZnihTvSnrndAo10hpnK+twGL41+My 1UM8EcOvjPfoNI6IZHIe3MxEIwX3CjxBWgcWZ7FfDMCCdI1QNa/CysxfGCa8qav56kwZld67 5glB5icQ4aohoY/l9CN16PYbOl12lQha1iQri3oli/AJHL2yWlk3+6s4wKLUi6P0XlkCFoiF Q3QwsHjn7Bd3AouLB+OFeTA0RsBtraBkZMfxYBRdSvkA8mCkOb1R21VKghjhPB4MQgQj5lB7 iwJOcNG29HiGrO08GFGB80qSIWuJKNsDDZPkZvJgFFXCJGEEKQsjxDwYO3J6382D8XKc3kND WMvJczBkHc/pffFgnI8MzufBeJJkZNlkGJFUw/GoUDIy/Y16gQyjjpKR9TQLczIyt1wP3gKB JkmoELbQZPWu7bIb0oc8TzKyhAoBs5rjqm6npM3HwQM7S3Aysl6wopmOhtjfd7q1A2WRYis6 lf2WeUjC6wWkflg7A+oywepthDDc2qLPwSgoj2IrQhTwgQITaawV0HjM8im2oj1qz3MTjEZ9 4mRkmRRbe2INHglAWNl+RBpnJSN7TnxxFx1GGdNh4AfQYcRGjY9Nh4EqyihAh9GXX3QY/7wn F+oW14gb6TDGeXptOoy+FzvRYdjKnpIOo28ZRIfhP1EE0Kh/tFSqrmu/ZaidxtvQYXRMVPPp Or4KtOz16TBkaul7E3DRYVyVfbjKYIB10WHsSYchq1bq/gCanrvpMIbnsX6WF4jEmh6MOeMU CVykDEHM0/QMY1LIaoZHviGINwzBsSnn0WFEhOi2oU9Nh+FetsKg1zVC9HE4xlMVVoG4P2dw eyFd2Usw7vyC6aeaZs0QlKLD2DE25W46jAfGpoAN2bKZzy17Ri/U82JTQtF4Z3QYH8EL9Xw2 jSexI2VTakSCnW9H0t9YQBesiuxIPVlDbEdao9TQ63CDHSlFqWGRUoGG7z+RHYkQUbcwr2ll Ke2PtSONswTbkXrBimY6GmJ/21q0I0UF4a4TTC60668jk4ifY/yFlgdSJ1rWLNiRxtrhI8Qz /SSRSZYdKZeOI4LheXYkmI4j2qPg2cxzUVk5diNkMiRxw61g8eRF+8Hj7UiZdBx7QhUcCUBs R9qLjuOyIy3gi4tUY09SDVkpqoUWhBZ3kmokFkEMLRoZ24jGVbiJxxMjSQQHFRfnkWo8E4/n FlKNhOJiM49nVLAED3CG4gJ1TQIeGEEKdyYQQcWkGjtGudxNqvHAHK9gQ96d4uKEHK/vm1Tj QyguzufleBrFRSY5R7Qotigu1ILiQoGKC5RQXCTJOSijDSYyRdm1gZzDIqWqxsyPjzlfcbGQ kKVpRRkoLrZ4oNxBzpFWXKhQcaF8xUU/xP621cHHbiaxR3So36i4QBmKC70NTjaVYGnyGJn4 op10gM0j9shSXOQSe2SpB3KJPTIVF/GYZRWsKC6GhpzvADsPUQ6xx55QhUYCACku9iH2OEtx 8RHgSfFQeBLnhTuVNgynInfJtshds7WCkbuy6rjACkAm+hsLkbskjty130hF7pYLkbu82hC5 W+lFmorc5S1qEEQbZvtyEjJJs5SfksF+nKVb9R6bacO64BfL5Dy4eSzlvEuE1/AqJ3J3+q4v VDs6bLRRy6CCZDeLZb1H6LCBLoeNUO9xvMNGEclZKAk9uqguvcezAouLEmRPShBZa6GhEB/p cZQgDWvzgcUiJQhvS1SCwOJUShDfV2MCFlR2nSgO9tXIoQRZABZoLf1JJHHj+KSRxiS5eZQg WpgSidGMIK0Di4sS5OaWvQqwuChBLmDxgowixwELqVLAIpNMxK0rBSwkLyBPDf2NBWChQGAh IWCxRiZSUb4JWMBkIrY/ZVV0MB+peh6NhSnjHe+aRko+byuHkoncDiw2h5hEOCKSyXlwM/lI OQwsrCBlAQsZAYs8QpBMYJFHCJLsJl0GFiAhyAUs/CE6GljwSM5CSdiPEOQCFk9AJUJiKhH2 ACqR2HP0g1OJCN5iiErEll9UIv/MduQAIlC2OHLcSiUyzNOLU4nYXuxFJWIqe04qEduyRSoR +8RFJfLeqUQoK6SqZYZPyQLKqsqiFqyWquN1U5b0TU9Y3XaibBqMcVfPcI9KVPeqPuzV5fjS kLpoRCNwIZu6bnjxZrS3bSuIRsdtTUXrNgQTHO0arnOt2Qecp9s381lRTc3RlXUlc19+m/6I itLvpv8mLd8I9fowDxHt/9C9+S/UibWJ0Qwm+zeVg+bNm4FGs++FX1nfWqTM2nib32z6Xvlv 2oLxU7wKu9m/OfI+v/lv6oJC9W8SMT1hXpjMzWNlMMBCMcDiDwBYk77GB1imeeayJAqkKO7W AJb1+rwBYPUajsYt1/eelpSedqdvCC1UMXukep6yuNaQqGojgIX1McJQ5QIs9xsuwArq6kaA NXy/61pcUIwngOV3o5i0ThZgYf+fhHbHA1imj01BJWnoBCIDs5H+9RS2HsCy7a2pC7CmXyPK qa7yH6EqQu4BsAyBSIMy43AeCLDCeYoAluhXIyr52PZ+zSNWeINp9oKhoJg2LqeycUe2/02g I3ntiZXKjCRMldFOdnz6x707+zIcwRhahiIaHgBRwaKtZ2yZ3RBo0aTGDNknygpJEMYQLD3I GRaYdjElg+9zHiKPYaJpF1Sm2mi8/bZr5JO23NVuZVSagHCwoK/MmGslkIpo7If3qCINmwoa 1jQKeQNRV7hqALQ2/t1tCO5KmkAe/TbSYkpKp5tVV8GVcdkpva2q9SdWKuu/y2QTT0AZyhlN j9m08vqFgVEoCcATCdEo5hEZZKWMV092y4bFMkkRbp31hUvalPFCh5aTK/B8HsSVJZG/AiKh bXi7quG8YTk5vxrsZtAQt5uLn8vagjBqMOEp0UDTGlkEWOdTqhzn+tvRVMhzJpuK8w6BQp5p XbdUX8XeYkOa/sZCyDMDQ55JImPwIptKKUiZgFrbDGkYF2xk+A9DntlpIc+gIa1v73lsKs9g SIsIULINaRXs+msFyW170vWXRBmDdzSk5TKinGFIAxuS37LLkJYqwJGchZKwHyPKZUi7Qp6v kOe5PB3yLGujC0ihi00hzxopMcU7P7DoCUOeh22QUEY05jnaTeeukOdpiP1tKzPnT4KMJTrU t0CVaZXkhTyjipZTy7znCkkiZOKLdpKrLY+MJQIkcGVwyPNaQZC1NolMQDKWaI/a89h9mZDn bWQse0KVjxDy/BL44opZ3jFmWZ8VilV8csLxv3FQzDJtdopZRi0rZiecsC8nQQuClags2XSo uEBCI6vmeMXFasxyuH0l8MJSaNFKIHASHuRkG24K7hdMFTRXzPKy4uKh2YZbJAEq1zMUF1fM 8s6Ki5dABuVDkUGc1u/M2CB9n0kgA7Y5NqhLIIMOU1SDyIAtIAMGxgZ1SWRQp5EBqVCKZw00 aag0m4nCbTd5j4R9OQkZpNhMdLP07BJ6sNJhnKVVk8YkNd6O7Z5U/TihjkDeBmkgEMnkPLiZ Jg0GIwMrSOvIYPquL1Q7xgbdadLAS8ig7aSPDHTB2chgaOqzmDTMEB2NDMpIzkJJsEHHGL8k MugXeY8MPn9XP/UbTWW+9jSo4KIi2ZGKxKCCBmMKooLDqEjkTlQkWEhOIUeHk6lIfG73Yfs6 ieMsh4ok3LVcR4c1KpLxnelkjQoimDBJbh4VCWplwpxgBCkLFXxYKhKwIe8NFVxUJB9TX3A+ l8iTeCpkE4pEUp3vqaC/US8QitSRp0JPVRF7KqwRiuitd4M5wXBhw1nlNNThktlD9Zk8FSJz wriPIUZNVNfB5OzjLMGeCr1gRTMdDbG/72R6KqTI2b2mgfAgC1r47CTjL6iMd1PsXiyE4da2 0DJfIHfzVEiRkcyDeB45+2Oyyi1Ci2g/CFr2PsjZeSQAYWX7kZFcngouvriLUgTHEa/0ARGv cWTGx6YUUapuIEqRvvyiFPlnBqXIGRGv4Ty9NqVI34udKEVsZU9JKdK3bIlSpH/iohR575Qi uKrb0pBfBL3ahAA3UIrUbMDVu1GKYBG2zNMdyn5c+z+UbyaWfuT5wFK3TAYvv+kapxSUuHRn k/hPGtFwqmqiKGF9aOGJI5HWLZeptam78eZWhcMlYXf6qX/6UmMEF6zMHRFbVe2+a+NRNSAd RYOykvSMBNDaNFUN75qqSNuzjJgC0qiyKWxVfQGWhSrGEVoEWOih6p6YSeQcQ9CkbRBwxCth +Yagvq4aingtSlYpRTmg6dHfWIhJIco3BI3fiA1BWD/L9Q011vRgzBmnSK/VlKaHeZqeYUxq MsM23xCkR4UIKNmN7ctJmp50xKuNASdHOo46s3SjIQjvFPHqyuQ8uHnJbpBqgoJR9Ds/Whcw BLnfHQTEevh5OyTU1C2OoypqGVSQ7CZfNATh0HEUX8luAkMQPt5xNBSNWyThMgTdZwgiD0UG MYnrmSElpExxYYjNXBg4gQxqoW/kIDIQC1wYAuTCwEkuDJnmwkBdMloVDCmpky4ipCgUhZGB OI0LA7eoxIAN6Lw0ePgOLgz8QBeRUUhXdmzMVe0VeIK0ggzcteAL1W7IwEv6HrTd/SW7yZaR QRkig/JCBgEyKA9HBrGchZJgQ0po+5ouIhcXxhFcGAfGqvIUsMikwXDeQQlgIQrVQBEp+hsL wEKBwAIlgEWCBmNc9bJLAIsNNBjmp089jZNAYKFOAxaR76kp5B2vS6lqNW8rh9Jg3A4sYCqL vYAFygAWqGsS+XWNIGUBCxQBizwqi0yVQx6VRbKb5SKwgKksLmDhD9HRwIJGchZKwn5UFhew uEgwnp0EQwOLpqQFpLE4jAQDV6LZorFYIMHgpZ4cAFicSYKB2xozlyh92AFPyq+bQ4KxBCxg z1P4+N6YXzeTBAM7Z1EsSHnA4iLBuKllrwIsLhKMC1hcHBpncmhoYNGiCksQWBzEoUFxo/KB xRKHBpJFU8PsWudxaETAYp4pLI+nBc/m0ICBBVrTWPgzlTqtQWAxCukasKAUzq9rBWkdWFwc Gje37DWAxcWhcQGLi4bjXBoODSxkzVgJAoujaDiU2pRvJE3DgWoO+1icScORzp1L9C6oB+xw YLFKw7EELM6n4cC9N/lc4AlSFrC4aDhua9lrAIuLhuMCFi/J4nEcsJAqBSwyCTzcuhLAQhWV hDUWagFYKBBYSAhYrBJ4NGiTxgIm8LBrt2ZNAlio8/i9ZEvrMKxjlwjaOwg8slk/5d2sn1HB ErBIEHiMvx5YtMQv8AQpC1jICFjkkXBkAos8Eo6s4zuXhOPSWPhDlEPCsSew4JGchZKwHwnH xfr5zzu5N3jMvYEewL0Rg4mPzb2hN6qCA9wbffnFvZGtksC0a0Rg69iCHG7k3hjn6bW5N/pe 7MS9YSsDuTfGJ8Y/xN30hmiuLE4kjW9vGcS94b2gBIkqG5KNa1QzP4eruprHWz/RlUVXzic0 3M3+4dfk3uglsWwZqV+QewM++M7nRHgSCsxsYoTgb1soMPU3mnSUgv6bdw5OIfcRBeZ+xAj9 txXlDXCD7toSl62+S3DvBu1yED6Raj55gz6IGCGdrNMIVjTT0RD70Dw3WSdMqpCxCY9/Sd++ I5aF8RdU1ooEqQIazhr3BuCLdjJZZx6pQnTphivLC6VfucD1Z00uqUK0R8Gz+c4pMLeRKux7 HQ8FYENlG2/fFwXmgnIePxRfxFyWZ8YpaKCeCIBkmwMgCRQAqc+KTuhpB6EFWwiAZGAAJEky K9RpZgVMmviKPfzpLVLOLzEroKYgQzBlGADJTguApLRtrTo5umKTousOdyccZ+mIZJ1pugIQ HoxCuraxdiX2C1xBCncmEEGRxzIr3OlO+EBmhUcm61S4peIpknWewKyAoRXgSYKJUyD6HvWK yvnXQAYX59KOnEslZojVfVqsvTmXEvIfm+2rKtds33+7SlEjNFUjCAGRwXmcS8lknYbAyPh7 3qh8H/71OM6l/mW9acd7W6z5zUjWOcnkPLhZbIx6yphX4AlSFjI4inOJ6/+BGcFk1tyY0SoI Q/WSP+D8r7QjRAbvEuLXXsga0pbbHxPzo6Jhk/1i+ImiKNYO8/5dSUVTxBPvtAx1hEsUvQK0 zO9V54eN9O9WeprKMhsZID68a5aWnheuLs6lJ/IHvOiTXpg+SWMETKq6ATHCw+mTzPebGhd1 iuWAxtoDodqk9qDQa7CGWA5OpU/CanBJP98w4czS69In4bZQXsH4wxLlshxc9Ek3tezZXfsu +qTnxAgvoXy46JN2pE8ywEIRgQFgcRh9EisozVQ+LNMn6VbhoqsBYHEmfVJK+XAe4fMqfVK4 8bnAYo0+aXwnjSMimZwHN0v5QBhrvQJPkPKAxUWfdFPLXgVYXPRJOwOLl0AGF//RjvxHGhkQ ISlMU3AQ/xESEucjg0X+o1LwFoPI4Dz+IzCasP/LU/MfDXRHDVlw3ipiyqJI4sZ30lBhGo88 /iPUikQqCDGmqbz4j8Yh/YjI4OI/2l/lcHERvS4XkT7kadnW8PX/IC6iAstNlAFJLiKsT98y ccifx0WUvv6fwp6cw0UUbkLuqb+Ziyg60yOZnAc38/pfwV6JVpCyDvmLi+i2lr3GIX9xEX2Q 6/9dtAFFTBtQPIA2ILYnXLQBF23AHkyGuGjLizbgog04lTaAK5ITsXrRBqRr/3i0AUdcoKdL nIAd8zIZA5y6atAxT+npKznsvE+qBcYA5V+gp1j06AJ9EGOAfRyxwXoQOeaR6mku0IP4t5SS 8uC8hs4s3eqYB0f9b75AuzI5D26e8z4uElpy2XhcBtAF2v3uICAbov4z7ed5Uf/JbvLFCzQc 9X9doP0hOvoCHYrGLZLwxBfoj+CYd/EF7MkXoGhRaZQJAouD+AIMu2kCWICOeWIhS4DkrAGB xXl8Aam8hrpZAulb6vGOeat8AUvAIjP90Cxx4/ikkcYkCHl8AQTpZeEWeIK0AizclvlC9Tx8 AQ/0+P8Q5vczPP7fOV/ARwAWF93AnnQDipa0FXAo4UF0A7gsZAJYEEBjsUQ3UHOhBAgsLrqB YJZysgTQIDA/QTcwG1HyNRZu7fPgZpr87XDOBZ4gZQGLkG7AiwvXq6KmrT4CcLAUWS6wuOgG LrqBd0Y3cPEFvDBfgD7kJeaTZd7/xgF8AfoAxIilcgzGh7zismWpQx51qFEVeMifxxeQTl6s d92ipcezDa7yBYSbEHyJXNQerDjLeaf++ATN4wsgRC8LqGW4adu8Qz7kC9jVr+9uvoAH+vU9 km1QspaTp2AbPMGv753zBbzE9f/8sL4nyXOQHdsXSXV+ngP9jXohtq/2HfemqLEoz8EQ2wfB g/EnWSY8WCAjth4YihSdnynQ2dvPggeh496wjxFdWVWi7pTYvlSeg16wopmOhtjfdzr43IzS Fz8wz0EUSjj+/Mpw0aXyHEgWQQtftBN5Dgy/VQ60iBAFVFluXODK6ZSEFjyEFvzKczBOwDRE R+c5KCMBCCvbLy7wrDwHH8E6cQUk7hmQqGiFSwrnMD4oIFHfRFP+lBtZB4igJYMUF2cGJOre 8T5F7lMQHd4bkPhAosNRSNc2eVyUfoErSOHOFAMwMCBxV9aBOwMSH8g6ADbkbsXFIro4XnFx BuvAFZB4PjLgD0UGcULiM5GBVClkoDYjA5lCBi1BUKSF/sYCMlAgMpAQMjDletzSyECyDQ6R JhF9ChkwzkgFUxWo85BBSIE8bGGEybboqLw92PBWZCCz+IgSeofNTIVRwRIykBnIAKMWpiqw gpSFDGSEDDq0IzKoo5YhbxAJq8t0qKF3QjrIYChA2A+xFBdVwYQM5iGSKHj3wciAR3IWSoJB BqorXxMZvEuVw11MBzRmOiAPYDqIXSxek+mADCGjOzAd4AZmOtDl+zEdaEz0bpkOeFcj3HTM 2XqOZDqw8/QcTAdWKsNpnytbYjrQvdiP6UDPBsR04ApLgxmKuzn8pQoKXF9Ek03Q+BPe3DKI 6cB/ogiMOf2jpVJ1XfstM6tq/I5hHGCims/l8VWgZS/KdOD8XpDpwPz+X/Hry8+3v3///EVp 6GBAgzn/+qPvq/r6x/f//PfiMXnxIuzIi6BXi168qAZu6y/Ii1DorQO3wG39qXgRhp3OkgxE UQZPzIswDX+96bbeBb9YJufBzeNFYArOK6DP8nLttv7BeRE+RvjixYtw3dYvXoRTeREMDGeq 6kBgcRAvAqLATbz/bTQDIH1kFhwEFmfyIpSSGlf8tyiyQXd8TtdwkBmAZvAirO6EC8DCn6mt kQ05vAiIWXME0DLqGyjyeRF2NQOkeBHGk+9MM8AjgUVbFKU4N7JhHqKjzQDvnBfhJZDBRWyw I7GBRgatbhQc83gUsYHAPBMZrBAbcNZSDOdIvogNglm6VeUAEBt4Yd1jURoIRDI5D24esYE+ M7wCT5CykEFIbGAiZXZEBpDrYKhCdlPcBH8JT1eXT6BoeTeqrt0n8u0tU0MwLlgJgZj6jiOz DJsaKdWNcUpjm/ndiNigNmGdRVsGlqAlZFDT4V3za7qWthexwROpHK50xy+c7thghI5xBWCE w9Id01JtCC9IBT6aH0NVXUJmiTPTHRNZw/mOcImZ5K2PEZ4i3bEvNanb7DBOqCMdcHmdztmo IAINkyAMQrpmlmhKWHtgBSkLI8TpjnfECHenO2aJ8R507mVoliifQ3vwRGaJ8kp3vCtG6Bd5 rz34/F391G80lfna02gOzudEeEepjjUqkAJ3CTqE+1IdJ2Q/timUIoUKJu++8LRO2BSYKBqI EvHMVMegTWG4QOEKoYNRwcZUx+0Tpjom1lnSKXAFaR0VgKmO8ygNslDB3amO6SIqgCkNMo5L n4/C8nHUJVXt+0MFmZQGe6KCK9Xxrof8xSywI7OAPuSVia4DD/mHMwt0LSf6z5zjxCEPch41 yas/l3qfl+Ah/0Spjm1LX5VZYDWhwvhO+kyPZHIe3DzzAClS5gGaGT8YMgvsmlDhbmaBByZU ABvy/g754xMqXMwC5yOD85kFnoYSMZNeIJLqLZSIaoESUYGUiBKiRFylFyAkBQ82EA9ZqFMV erY9eODs7SfBg4h4aD5r9aXs2IAFZ5ZSlIgqpERUDiXiNMT+vtOtHSiLpEW+AIE6gDTWmGRo 5AwIvx9URls1tSwSwnBrW2iZL5A50CJCFPCBAlMTrBUEbm0JaJEgLYr2qD3PTTC+73kpEXNJ i/bEGjwSgLCy/agJzqJEfE58cRfBAI4JBvgDCAbiSIfXJBiwSet3IRgQCoMEA6Z8T4IB8o4J BjrUMGX3Tw9+bAlruJlgoJ+n5yAYsFIZTvtc2QLBgOnFbgQDurKHEAyYAmkc+Sam61tatkww YJ64CAbeK8FA0AlfNAhx8CUivMBlBFHwkjPqWFnHMOFN7ctZJXQ3pRqToGH7n7my+S/E/mdG cbzQiHsQ2idsGXMKKtE0zVO0rC1Kd8wObRkMsC5qih2pKTgTRd1Y6PBgagoaQS37fd7QskSp CFIOaXpk0hCEFUcle4sNQc9ITQETST4FNQW8hIdhqfEehqB7qClwAWfWxhwXa4YgmJpi59xY d1JTPDA3FtiQLVqLuWXPbAg6PjdWKBrvjJriORU1TxdB+iSGoOww0kgy8w1B5oq2EEZaRYag PkARzI3VMblAMNHQJgEPNhBMWKhDO8x9Z9DzDUGYStkKFBuCkF5YhEyw6TiCCTtLsCGoF6xo pqMh9ved3NxYMEe1L0A3GoKimNTx51eGVQ2zXlkhDLe2hZb5ArmbIQgOQY3JKVZOpwhaDAUw OUW0R31IQ9A8RDnkFHtiDRIJQGwI2isE9cqNdSX1fomk3vqoKfVpcVJS7+HHSW7WzrWk3lTv tARUXJyX1DvKgGG73FEkC2aPyQMVF84s5Qavdl3ypASDVyOJG9/xjmz356KLnKTeqK5qv8AV pHBnWmjZfB7sHLx6Z1LvnYNXh0d7xbEgzruyIxVv3p/i4oTg1fed1Pv5g1fPp7R4EqVFNq9F JNFbvFfJgvcqib1Xe8aERELvBV4LxHGdr7QwcQhJpYU+t+XkPhLu62cpLVIJvRmVtdCfOR4a LHmvktB7ldRVPMT+npOptEgExkQn8o1KC5ST0Fsv4EnmIyEMtzZftBNKi9zAmCylRS4nRlgQ BFCmYAUcGHMpLfwhOtp7tYgEAFRa7MKJcSktLm6Nl+DW0EcNL8vqIdwa3vN1GpnghrX5yMTQ ICQTemPacoiv+0xujaS3BWWElbI4WGmRw60R7n6uSaTdM+y2uynslhXEK/AEKdyZYgD20bg1 Vhvy7pQWF7fGh/S2uAg5diTk4IaRA+GHEHIk5B9I6F2nkMFW1q22VR3MxXkeIQeRbUtcR4t5 phDRE3CwziKHkMNd3VbvEE1LGhnM+6KhTkkdtx5UmMZjENKVHRs30i/wBCkLGcSEHOmmHk/I USwjgzBFGDo9RdjQkBZJdm4mj3mILkKOZ+LrfglgcT6fx3HAQqoUsMik8nDrSgCLuka8AIGF WgAWCgQWElI5rFF5EFaVW1QOMJWHrYkygQsQWKjnUTmYMusnURXkeD+JcZZuVTnsyvQlb1M5 UOkVeIKUBSxkpHLIo+PIBBZ5dBwLJ+4CsEjQcVwqB3+IjgYWPJKzUBL2o+O4VA7Dv93FxFHG TBz0AUwcsQ3jNZk4sJC7MHGgmmEOMHH05TsycRT83TJx9P0oESsDtcSW+I8bmTjGeXoOJg4r leG0z5UlmTj6XuzExGEre0omjr5lS0wc/RMXE8e7ZOKAD77zGRKexKUwmyYh+Nu2OEjSpKMN 9N+8c3AKwI9cCgeaBBLfojHmjFOkL76ppBjsDVDP1wQBt+iurUgnW4Gpd4t+QpfCfg2cwpft zFIqDpIwFM90NMQ+PM8lxKwe51IYcS6Mv6AywuAbOCJcRTdwX7STcZB5FAvRxRs2aeQF1qcW /duKSyFIsRDtUXteL1/OpTCPYmHfK3koABsq23gDvwgxFxT0+KH4Ima2PDOQsaOpQEa2OZCR QIGM+m8Uiw4OZGQLgYwMDGQkiUDGjtULFAuy2OATqBdHUkFfKIwLyPJv+3IStIgCGYd97AwG JmeWtmfq7iMONvsERgVJeDAK6crGikuU4Ms2ghTuTCCCIlEgY4Vy4EGWgl6oO30C+SI8wKHl H2+w/IMN2XJMbocHxyvozRAdraDHkZyFkmAiDoi+R72kgv4jWP7PJ3A6DliQMgUsMrmbnHdw ClhIXjQgsBALwEKAwAIngcUSdxORmyz/MHeT/ekzT/pJPJy+nAUswiQepjCps9iiu7+Duymb IQF3h6b3TnA3jb++oBCJRJ5GkLKABY6oHfP4lzKBRR7/Utbxncu/dAELf4hy+Jf2BBaxnIWS sB//0sWQEKOCizdpR94k8zdeU8gfcGfeJCAEUUtByxolSJsiRwAzf9bpzJ81qgiMCs7jTUr4 A3KDwa1/++HqhlXepLUtcB9/QBoyK+USPndNCbYMIxlbI0BU8BF5k/SjCktEYmPP+0EFF2/S h/IHfDrupAORAU5FCmTSJrm7IRQpoP9WYqQgfQE2ntcJZKD/FkcK2G+kkMEibZIo8vUFKdok 23XedaICkIHty0nIALd6iK3lOqZN0s0tjjdEoM0hiOOue0tO8KggggrT7hqRE4VbaF8gUok7 jSDlIYNH5gTPpT5KdvPKCf56OcGLSM5CSdiP+ugyRFzcBs/ObaD/xuuuNwTszW3gPS8XgEWJ Nnk4NGlDRK2okCCwOJHbgDSkM7vn28twG4Qbnwss4EQQ8fE9SdxYyTqwyOQ20PgR+wWuIK0D i4vb4OaWvQqwuLgNPqLK4SIn2JGcQP+tKqoa8n08jJwAlSwOL+x/G8kJUIfG8InnISdYQAZl VbT0eGSwnZwgKlhFBisR/ylkIHOQQckSKaJKhvKQwYclJ3go65G+copnYD26yAk+CDK4i5yA xOQE/AHkBLHP42uSE9CS70JOgDvjmhyTE/Tl+5ET4MFd4t2SE5gb4gnkBOM8PQc5gZXKcNrn ypLkBH0vdiInsJU9JTlB37IlcoL+iYuc4F2SE5jf/yt+ffn59vfvn78offabU9+cf/3R91V9 /eP7f/578Zg8n8rgiOv2dOUTsO9fJouBU1cN+v7pNdfwpgOu2/obC9mcifKv21N8fHTd3o/F oP+2oryBr9uYNLpGDFy3bV9Oum4nfP8Ya1lDzWo/8LrtzNJ2RfxIIoH34AJ0ZXIe3Nz0A37B JPlVsXrddr87CMgGJoKs63YuE0Gym2RZEQ8yEVyKeH+Ijr5uh6JxiyRc1+2LhOB5SAi6qmZd AZnojyMhYHWXQAZbYwULWWAYGZxKQtAUbvqBcQszEf3GBePmq/TDSAiirWxuMso10U8SN1aS hgrjEzSPhMAOm1fgCtIKMnBb5gvVjrGCMAnBPIjnxQq+c2QwD9HRsYLvnITgJZDB+fGCT0N/ mBk0GEn1FvpDtaA4GGBAHDSYyKj88KBBC3UKWTXEgwfO3n4SPHgm+kNnllL0h0awopmOhtjf d6KMylNoHnIUkqhlCmNPC2EjlDPUvN557f5caIFy6A9xk4AWhK9kVE7RH+YGHEaIAq4sL+Aw 0rBB2uzcgMNoj1qBBzauhSBeMropAnE7tFg4hPv/HbRsEVosdNMfoqPpD2kkAGFl+wUcnkR/ +PxcBFfE4Z4Rh13ViIJC9ojjIg6x2OD+txRxiFq9buB0yOdFHEZah7l3dVEf7v6XE3EYbl1L BoqlpIfpML4kNMhy/0MJaGAEKdyZYMDzUSMOH+n+p6WQqmdw/7siDj+m1qF8KDKIkwydGRig N6wEMmCbAwO6BDJoS8e1z//GAjJgYGBAl0QGdRoZ4ELSfGRgctqnkAErCpZIh8yeJ2vhsIWd RIo8ztKNXARoMylyBAQimZwHN4+lqOYwF4EVpHVkMH3XF6odAwPuJEWmy8iAh8iAX1wEATLg hyODMpKzUBJsyCDGr4kMLi6Ci4tgGxdBV0kpO8iScRwXASN8i8ohzUWgZRGB2RbO5CLAbU3o 81gy3gEXQYFh+kMrSFnA4sNyEYANeX/A4uIi+Igqh4uLYE8ugq5SVU1qEBkcxUVQMbVF5ZDm IiAa4nPfx+EZuAiCdAnDFnYS/eFNXAQzMkAPpD/M5SKoVSJNoxGkLGTwYbkIwIa8N2RwcRF8 EGRwFxcBi7kIigdwEcSqho/ORSDaEuQiMOUXF0GoV9jkIbklgOJmLoJ+nl6di8D0YjcuAl0Z yEUwPjH+Ie6mN0RzZRSI2r+5ZRAXgfeCEiSqrD+WsUY283O4qqt5vHsuAok/BhdB1LLX4CJA wW9fNHhVdlWWBFgXi8WOLBZ1UzaCYziD1a4sFjSCWv339QWPlSnfEO4paoYxKWQ1w6OATprW ogYUNWeyWKRJI1FXkNln5plZLKKC8A4HXVOXqCHcnzO4vZCuKmo48wumT6zTSV8sFg/zGpWs 5UB+rDNMOBeLxYdQ1FwsFo9jsdDIoGW4PzX3ZrFIyD+QwYqkMlhNSpjwxIaRAWYlbimIDE5k sZAtrbO9RrcoYR7GYuFLjbdjZ2e8HmZkYzxJFotFw1IZrEhmBquLxSIeVef3siaceYguFouP lfGaPBQVxJzQZ6ICUqZQgdiMCnACFUjUcJj1UiygAgGiApzktpIL3FYFZwlUALp8VukoU17I Ds54LZ4t4zWlqqgxnfeE46JMcRYqiGJJ+pf1hl3tlvEa38J6iao6EWVqBCncmUBUgKOM1xXa ERXc6fLJF/UFOHT5xJfLZ5jx+niXz1jOQkmwUaa0fUlU8CFiSS5qrNelxpokL7BG1FpukxwW ITVWQRWXLZuDU1xqrLpBbcUa3xpxPjUWkTWELl6SGmsaYn/biqix4ChXXIEup9GhvgWqTKsk jxoLN2Uzybz3XOMTfl3UWI9R029DJgs3+/5/O4+uIpOFbvpDdFFjJeDJ7dRYHwKenMyuZRRD 1PT35x+//aYbbz1KP339Q5r5oabTxTI4wfngBLcVp1ah5oOTmQ8IBifTYbsETobVSFTDpnIH nEzfSICTmawrItiqtxtEhu8bcOIMNe7YbBDxRzH2So3qoonyIj1eo1dq8M790a7zPO4Q08Lo /eDEzFIMTmbB8gSeFiSe+gAjlDlbc11VvEYLTI8dI1yWLDyBpl/oC0vquaDrmpYxHLrAuu59 cDchgi3b1KrxBgJrYLxqqtlUAFQ2fjd4kkXyv+PZiLl/rus9Aa4MI2iI4Nod1JAAJ/oza/Ch Ys4+Vep/axITkAcf7hizIiUrM2tWurIt8GHDARO/qVeqZ7PAiCwZLXqR1m/8+M8P0zCDUtR3 /V5lbB2VXD+Lo6CQ8gFBIfGhHAeFaPnIDQrBb5uCQjAfj99gVtl4/CYWT3T8Dt5yvm5gXEVO UAggOvb4hd5xg0LGJXLP8QuWv7Pj1xRyfaHELRYV2mp5cI7fG4NCxnmad4B7U+CdTyz3JDq7 bHY5SDYzdXb6G/UCu1wdweKet2zW2aXkP16XBV5bl85mnvATstZNUVb9vvBEOrt04lisOszV 8aHedpZgnV0vWNFMR0Mc3uXjynoOtxhhNJGP0S46u4iqLpC6sbLSboW9bEVC6PTK19mNtcNm nzxmuiydXS4zXbRJ5OnsYGa6DGWWTyto3pUdqXgSFoMT4AGIZ9XZZTLT7amzKyMBiHV2ezHT XXT2F4PM4xlk9DnRSUxgOvuDGGQoqcsErNjGIKOXHWWN8mDF+QwyCUejE7nlVhlk3NUdktZu ZpCJkEAkk/PgZqbXbQqvwBOkcGcCAc/FIHNby17D0ehikIFRweVo5AOLr1//u/0HwZz9Q6K3 /9/37398f/uz+/aG9dWj1NDiu3RMFKWV0//77Q/5P+Hs/d960rr/wVVQ+FMX8sIrxP+f/7p+ 1+/6Xb/rd/2u3/W7ftfvg//+/6Bf3+0ASD8A --------------090500060808000206070107 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 --------------090500060808000206070107-- From xen-changelog-bounces@lists.xen.org Fri Nov 23 20:58:32 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 23 Nov 2012 20:58:32 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Tc0KQ-0002oU-HM; Fri, 23 Nov 2012 20:58:26 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Tc0KO-0002oJ-BI for xen-changelog@lists.xensource.com; Fri, 23 Nov 2012 20:58:25 +0000 Received: from [85.158.139.83:53197] by server-3.bemta-5.messagelabs.com id B1/AB-18736-F63EFA05; Fri, 23 Nov 2012 20:58:23 +0000 X-Env-Sender: ian.jackson@eu.citrix.com X-Msg-Ref: server-8.tower-182.messagelabs.com!1353704297!20405954!1 X-Originating-IP: [50.57.168.107] X-SpamReason: No, hits=0.8 required=7.0 tests=BODY_RANDOM_LONG, MAILTO_TO_SPAM_ADDR X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 23196 invoked from network); 23 Nov 2012 20:58:18 -0000 Received: from mail.xen.org (HELO mail.xen.org) (50.57.168.107) by server-8.tower-182.messagelabs.com with AES256-SHA encrypted SMTP; 23 Nov 2012 20:58:18 -0000 Received: from xenbits.xen.org ([50.57.170.242]) by mail.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Tc0KH-0007f9-Fq for xen-changelog@lists.xensource.com; Fri, 23 Nov 2012 20:58:17 +0000 Received: from xen by xenbits.xen.org with local (Exim 4.72) (envelope-from ) id 1Tc0KG-0007c3-KK for xen-changelog@lists.xensource.com; Fri, 23 Nov 2012 20:58:17 +0000 Date: Fri, 23 Nov 2012 20:58:16 +0000 Message-Id: From: patchbot@xen.org To: xen-changelog@lists.xensource.com Subject: [Xen-changelog] [qemu-upstream-unstable] Merge remote branch 'xen-staging/master' into temp X-BeenThere: xen-changelog@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: xen-devel@lists.xensource.com List-Id: "Change log for Mercurial \(receive only\)" 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-changelog-bounces@lists.xen.org Errors-To: xen-changelog-bounces@lists.xen.org === This changeset includes merge from high-traffic branch === Commits on that branch are not reported individually. commit 1e6f3bf92c84d9ba8fdc61f4deb1777e737c7a2c Merge: a8abf479276d54acbad4c3eade232897443e1189 cdf4d2bb4006805f209712fbb8ed1f83127e9984 Author: Stefano Stabellini Commit: Stefano Stabellini Merge remote branch 'xen-staging/master' into temp .exrc | 7 + .gitignore | 21 +- .gitmodules | 3 + .mailmap | 16 + CODING_STYLE | 5 +- Changelog | 6 +- HACKING | 21 +- LICENSE | 4 +- MAINTAINERS | 243 +- Makefile | 276 +- Makefile.dis | 3 - Makefile.hw | 25 - Makefile.objs | 397 +- Makefile.target | 398 +- Makefile.user | 5 +- QMP/qemu-ga-client | 299 + QMP/qmp | 126 + QMP/qmp-events.txt | 282 +- QMP/qmp-shell | 46 +- QMP/qmp-spec.txt | 28 +- QMP/qmp.py | 39 +- QMP/qom-fuse | 138 + QMP/qom-get | 67 + QMP/qom-list | 64 + QMP/qom-set | 64 + README | 4 +- VERSION | 2 +- aio-posix.c | 268 + aio-win32.c | 215 + aio.c | 230 - arch_init.c | 707 +- arch_init.h | 8 +- arm-dis.c | 6 +- arm-semi.c | 509 - async.c | 124 +- audio/Makefile.objs | 14 + audio/audio.c | 39 +- audio/audio_int.h | 6 + audio/audio_pt_int.c | 1 + audio/audio_template.h | 8 +- audio/esdaudio.c | 2 +- audio/paaudio.c | 503 +- audio/spiceaudio.c | 41 + audio/wavcapture.c | 1 + audio/winwaveaudio.c | 14 +- backends/Makefile.objs | 2 + backends/rng-egd.c | 224 + backends/rng-random.c | 161 + backends/rng.c | 93 + balloon.c | 44 +- balloon.h | 3 +- bitops.h | 116 +- block-migration.c | 240 +- block.c | 2448 +- block.h | 184 +- block/Makefile.objs | 20 + block/blkdebug.c | 124 +- block/blkverify.c | 32 +- block/commit.c | 259 + block/cow.c | 98 +- block/curl.c | 29 +- block/gluster.c | 624 + block/iscsi.c | 740 +- block/linux-aio.c | 216 + block/mirror.c | 322 + block/nbd.c | 463 +- block/qcow.c | 136 +- block/qcow2-cache.c | 43 +- block/qcow2-cluster.c | 655 +- block/qcow2-refcount.c | 266 +- block/qcow2-snapshot.c | 382 +- block/qcow2.c | 661 +- block/qcow2.h | 102 +- block/qed-check.c | 37 + block/qed-l2-cache.c | 22 +- block/qed-table.c | 25 +- block/qed.c | 286 +- block/qed.h | 14 +- block/raw-aio.h | 48 + block/raw-posix-aio.h | 43 - block/raw-posix.c | 696 +- block/raw-win32.c | 265 +- block/raw.c | 22 +- block/rbd.c | 142 +- block/sheepdog.c | 775 +- block/stream.c | 236 + block/vdi.c | 505 +- block/vmdk.c | 145 +- block/vpc.c | 300 +- block/vvfat.c | 89 +- block/win32-aio.c | 226 + block_int.h | 201 +- blockdev-nbd.c | 133 + blockdev.c | 954 +- blockdev.h | 15 +- blockjob.c | 283 + blockjob.h | 278 + bsd-user/Makefile.objs | 2 + bsd-user/bsdload.c | 2 +- bsd-user/elfload.c | 16 +- bsd-user/main.c | 21 +- bsd-user/qemu.h | 12 +- bsd-user/signal.c | 2 +- bsd-user/x86_64/syscall.h | 2 +- bt-host.c | 1 + buffered_file.c | 154 +- buffered_file.h | 12 +- cache-utils.h | 5 +- check-qdict.c | 402 - check-qfloat.c | 76 - check-qint.c | 113 - check-qjson.c | 795 - check-qlist.c | 153 - check-qstring.c | 134 - cmd.c | 50 +- compatfd.c | 2 + compiler.h | 9 +- configure | 1350 +- console.c | 337 +- console.h | 274 +- coroutine-gthread.c | 101 +- coroutine-sigaltstack.c | 334 + coroutine-ucontext.c | 42 +- cpu-all.h | 217 +- cpu-common.h | 159 +- cpu-defs.h | 30 +- cpu-exec.c | 112 +- cpus.c | 530 +- cpus.h | 2 + cputlb.c | 361 + cputlb.h | 46 + cris-dis.c | 34 +- cursor.c | 3 +- cutils.c | 242 +- darwin-user/commpage.c | 357 - darwin-user/ioctls.h | 4 - darwin-user/ioctls_types.h | 1 - darwin-user/machload.c | 902 - darwin-user/main.c | 1024 - darwin-user/mmap.c | 409 - darwin-user/qemu.h | 178 - darwin-user/signal.c | 453 - darwin-user/syscall.c | 1566 - darwin-user/syscalls.h | 384 - def-helper.h | 37 +- default-configs/alpha-softmmu.mak | 2 + default-configs/arm-softmmu.mak | 20 + default-configs/i386-darwin-user.mak | 1 - default-configs/i386-softmmu.mak | 3 + default-configs/microblaze-softmmu.mak | 4 + default-configs/microblazeel-softmmu.mak | 4 + default-configs/mips-softmmu.mak | 3 + default-configs/mips64-linux-user.mak | 1 + default-configs/mips64-softmmu.mak | 3 + default-configs/mips64el-linux-user.mak | 1 + default-configs/mips64el-softmmu.mak | 3 + default-configs/mipsel-softmmu.mak | 3 + default-configs/mipsn32-linux-user.mak | 1 + default-configs/mipsn32el-linux-user.mak | 1 + default-configs/or32-linux-user.mak | 1 + default-configs/or32-softmmu.mak | 4 + default-configs/pci.mak | 6 + default-configs/ppc-darwin-user.mak | 3 - default-configs/ppc-softmmu.mak | 5 + default-configs/ppc64-softmmu.mak | 2 + default-configs/ppcemb-softmmu.mak | 2 + default-configs/sparc64-softmmu.mak | 1 + default-configs/unicore32-softmmu.mak | 4 + default-configs/x86_64-softmmu.mak | 3 + device_tree.c | 153 +- device_tree.h | 28 +- dis-asm.h | 3 + disas.c | 190 +- disas.h | 7 +- dma-helpers.c | 270 +- dma.h | 249 +- docs/bootindex.txt | 2 +- docs/ccid.txt | 2 +- docs/libcacard.txt | 26 +- docs/live-block-ops.txt | 58 + docs/memory.txt | 6 +- docs/migration.txt | 12 + docs/qapi-code-gen.txt | 6 +- docs/qemupciserial.inf | 109 + docs/specs/acpi_pci_hotplug.txt | 18 +- docs/specs/ivshmem_device_spec.txt | 2 +- docs/specs/pci-serial.txt | 34 + docs/specs/ppc-spapr-hcalls.txt | 78 + docs/specs/qcow2.txt | 140 +- docs/specs/standard-vga.txt | 65 + docs/tracing.txt | 61 +- docs/usb-storage.txt | 38 + docs/usb2.txt | 15 + docs/writing-qmp-commands.txt | 649 + docs/xbzrle.txt | 128 + dump-stub.c | 64 + dump.c | 865 + dump.h | 35 + dyngen-exec.h | 70 - elf.h | 44 + error.c | 121 +- error.h | 50 +- error_int.h | 29 - event_notifier-posix.c | 120 + event_notifier-win32.c | 59 + event_notifier.c | 61 - event_notifier.h | 36 +- exec-all.h | 184 +- exec-memory.h | 9 +- exec.c | 2788 +- fpu/softfloat-macros.h | 18 +- fpu/softfloat-specialize.h | 107 +- fpu/softfloat.c | 144 +- fpu/softfloat.h | 22 +- fsdev/Makefile.objs | 9 + fsdev/file-op-9p.h | 25 +- fsdev/qemu-fsdev-dummy.c | 1 + fsdev/qemu-fsdev.c | 45 +- fsdev/qemu-fsdev.h | 11 +- fsdev/virtfs-proxy-helper.c | 1115 + fsdev/virtfs-proxy-helper.texi | 63 + fsdev/virtio-9p-marshal.c | 323 + fsdev/virtio-9p-marshal.h | 90 + gdbstub.c | 384 +- gdbstub.h | 25 +- gen-icount.h | 10 +- hmp-commands.hx | 349 +- hmp.c | 834 +- hmp.h | 43 + hppa-dis.c | 2 +- hw/9pfs/Makefile.objs | 9 + hw/9pfs/codir.c | 6 +- hw/9pfs/cofile.c | 14 + hw/9pfs/virtio-9p-coth.h | 2 +- hw/9pfs/virtio-9p-device.c | 74 +- hw/9pfs/virtio-9p-handle.c | 28 +- hw/9pfs/virtio-9p-local.c | 387 +- hw/9pfs/virtio-9p-posix-acl.c | 6 +- hw/9pfs/virtio-9p-proxy.c | 1210 + hw/9pfs/virtio-9p-proxy.h | 95 + hw/9pfs/virtio-9p-synth.c | 4 +- hw/9pfs/virtio-9p-xattr-user.c | 3 +- hw/9pfs/virtio-9p-xattr.c | 3 +- hw/9pfs/virtio-9p.c | 790 +- hw/9pfs/virtio-9p.h | 83 +- hw/Makefile.objs | 209 + hw/a15mpcore.c | 108 + hw/a9mpcore.c | 243 +- hw/ac97.c | 392 +- hw/acpi.c | 206 +- hw/acpi.h | 93 +- hw/acpi_piix4.c | 355 +- hw/adb.c | 8 +- hw/adb.h | 4 - hw/adlib.c | 4 +- hw/ads7846.c | 34 +- hw/alpha/Makefile.objs | 4 + hw/alpha_dp264.c | 32 +- hw/alpha_pci.c | 37 +- hw/alpha_sys.h | 6 +- hw/alpha_typhoon.c | 84 +- hw/an5206.c | 20 +- hw/apb_pci.c | 179 +- hw/apb_pci.h | 7 +- hw/apic-msidef.h | 30 + hw/apic.c | 564 +- hw/apic.h | 9 +- hw/apic_common.c | 402 + hw/apic_internal.h | 149 + hw/apm.c | 3 + hw/applesmc.c | 38 +- hw/arm-misc.h | 37 +- hw/arm/Makefile.objs | 35 + hw/arm11mpcore.c | 214 +- hw/arm_boot.c | 275 +- hw/arm_gic.c | 552 +- hw/arm_gic_common.c | 184 + hw/arm_gic_internal.h | 136 + hw/arm_l2x0.c | 194 + hw/arm_mptimer.c | 344 + hw/arm_pic.c | 8 +- hw/arm_sysctl.c | 59 +- hw/arm_timer.c | 127 +- hw/armv7m.c | 80 +- hw/armv7m_nvic.c | 271 +- hw/audiodev.h | 8 +- hw/axis_dev88.c | 86 +- hw/baum.c | 7 +- hw/baum.h | 2 +- hw/bitbang_i2c.c | 32 +- hw/blizzard.c | 12 +- hw/block-common.c | 64 + hw/block-common.h | 79 + hw/boards.h | 22 +- hw/bonito.c | 420 +- hw/bt-hci-csr.c | 2 +- hw/bt-hci.c | 8 +- hw/bt-l2cap.c | 11 +- hw/bt-sdp.c | 6 +- hw/bt.h | 2 + hw/cadence_gem.c | 1233 + hw/cadence_ttc.c | 489 + hw/cadence_uart.c | 516 + hw/ccid-card-emulated.c | 77 +- hw/ccid-card-passthru.c | 45 +- hw/ccid.h | 27 +- hw/cirrus_vga.c | 209 +- hw/cirrus_vga_template.h | 102 + hw/collie.c | 14 +- hw/cris-boot.c | 10 +- hw/cris-boot.h | 4 +- hw/cris/Makefile.objs | 13 + hw/cris_pic_cpu.c | 4 +- hw/cs4231.c | 62 +- hw/cs4231a.c | 63 +- hw/cuda.c | 14 +- hw/debugcon.c | 36 +- hw/dec_pci.c | 107 +- hw/dec_pci.h | 2 + hw/device-hotplug.c | 46 + hw/devices.h | 2 + hw/dma.c | 4 +- hw/dp8393x.c | 59 +- hw/ds1225y.c | 101 +- hw/ds1338.c | 165 +- hw/dummy_m68k.c | 15 +- hw/e1000.c | 284 +- hw/e1000_hw.h | 14 +- hw/ecc.c | 3 + hw/eccmemctl.c | 100 +- hw/eepro100.c | 265 +- hw/elf_ops.h | 25 +- hw/empty_slot.c | 56 +- hw/empty_slot.h | 2 +- hw/es1370.c | 149 +- hw/escc.c | 60 +- hw/escc.h | 4 +- hw/esp-pci.c | 518 + hw/esp.c | 356 +- hw/esp.h | 121 +- hw/etraxfs.h | 4 +- hw/etraxfs_dma.c | 52 +- hw/etraxfs_dma.h | 15 +- hw/etraxfs_eth.c | 62 +- hw/etraxfs_pic.c | 41 +- hw/etraxfs_ser.c | 37 +- hw/etraxfs_timer.c | 28 +- hw/exynos4210.c | 338 + hw/exynos4210.h | 137 + hw/exynos4210_combiner.c | 455 + hw/exynos4210_fimd.c | 1928 + hw/exynos4210_gic.c | 462 + hw/exynos4210_i2c.c | 334 + hw/exynos4210_mct.c | 1482 + hw/exynos4210_pmu.c | 499 + hw/exynos4210_pwm.c | 422 + hw/exynos4210_rtc.c | 592 + hw/exynos4210_uart.c | 676 + hw/exynos4_boards.c | 168 + hw/fdc.c | 747 +- hw/fdc.h | 36 +- hw/fifo.c | 78 + hw/fifo.h | 99 + hw/flash.h | 8 +- hw/fmopl.c | 44 +- hw/fmopl.h | 4 +- hw/framebuffer.c | 49 +- hw/framebuffer.h | 5 +- hw/fw_cfg.c | 178 +- hw/fw_cfg.h | 2 +- hw/g364fb.c | 128 +- hw/grackle_pci.c | 108 +- hw/grlib.h | 8 +- hw/grlib_apbuart.c | 150 +- hw/grlib_gptimer.c | 78 +- hw/grlib_irqmp.c | 71 +- hw/gt64xxx.c | 126 +- hw/gumstix.c | 14 +- hw/gus.c | 67 +- hw/gusemu.h | 4 +- hw/gusemu_hal.c | 4 +- hw/hd-geometry.c | 157 + hw/hda-audio.c | 308 +- hw/heathrow_pic.c | 4 +- hw/hid.h | 23 + hw/highbank.c | 338 + hw/hpet.c | 175 +- hw/hpet_emul.h | 3 + hw/hw.h | 886 +- hw/i2c.c | 142 +- hw/i2c.h | 57 +- hw/i386/Makefile.objs | 15 + hw/i82374.c | 168 + hw/i82378.c | 277 + hw/i8254.c | 374 +- hw/i8254.h | 68 + hw/i8254_common.c | 311 + hw/i8254_internal.h | 85 + hw/i8259.c | 189 +- hw/i8259_common.c | 161 + hw/i8259_internal.h | 82 + hw/ide.h | 10 +- hw/ide/Makefile.objs | 10 + hw/ide/ahci.c | 256 +- hw/ide/ahci.h | 5 +- hw/ide/atapi.c | 52 +- hw/ide/cmd646.c | 76 +- hw/ide/core.c | 363 +- hw/ide/ich.c | 60 +- hw/ide/internal.h | 40 +- hw/ide/isa.c | 44 +- hw/ide/macio.c | 38 +- hw/ide/mmio.c | 59 +- hw/ide/pci.c | 16 +- hw/ide/piix.c | 124 +- hw/ide/qdev.c | 219 +- hw/ide/via.c | 53 +- hw/imx.h | 34 + hw/imx_avic.c | 408 + hw/imx_ccm.c | 321 + hw/imx_serial.c | 467 + hw/imx_timer.c | 689 + hw/integratorcp.c | 203 +- hw/intel-hda.c | 193 +- hw/intel-hda.h | 28 +- hw/ioapic.c | 181 +- hw/ioapic_common.c | 120 + hw/ioapic_internal.h | 102 + hw/ioh3420.c | 79 +- hw/irq.c | 44 +- hw/irq.h | 18 +- hw/isa-bus.c | 145 +- hw/isa.h | 54 +- hw/isa_mmio.c | 16 +- hw/ivshmem.c | 230 +- hw/jazz_led.c | 203 +- hw/kvm/Makefile.objs | 1 + hw/kvm/apic.c | 209 + hw/kvm/clock.c | 143 + hw/kvm/clock.h | 24 + hw/kvm/i8254.c | 317 + hw/kvm/i8259.c | 138 + hw/kvm/ioapic.c | 125 + hw/kvm/pci-assign.c | 1905 + hw/kvmclock.c | 118 - hw/kvmclock.h | 24 - hw/kvmvapic.c | 821 + hw/kzm.c | 156 + hw/lan9118.c | 315 +- hw/lance.c | 52 +- hw/leon3.c | 37 +- hw/lm32/Makefile.objs | 23 + hw/lm32_boards.c | 86 +- hw/lm32_hwsetup.h | 4 +- hw/lm32_juart.c | 29 +- hw/lm32_pic.c | 27 +- hw/lm32_sys.c | 65 +- hw/lm32_timer.c | 70 +- hw/lm32_uart.c | 60 +- hw/lm4549.c | 8 +- hw/lm4549.h | 6 +- hw/lm832x.c | 41 +- hw/loader.c | 49 +- hw/loader.h | 23 +- hw/lsi53c895a.c | 119 +- hw/m25p80.c | 651 + hw/m48t59.c | 192 +- hw/m68k/Makefile.objs | 4 + hw/mac_dbdma.c | 4 +- hw/mac_dbdma.h | 2 +- hw/mac_nvram.c | 8 +- hw/macio.c | 51 +- hw/mainstone.c | 45 +- hw/marvell_88w8618_audio.c | 76 +- hw/max111x.c | 54 +- hw/max7310.c | 43 +- hw/mc146818rtc.c | 721 +- hw/mc146818rtc.h | 5 +- hw/mc146818rtc_regs.h | 67 + hw/mcf.h | 23 +- hw/mcf5206.c | 97 +- hw/mcf5208.c | 40 +- hw/mcf_fec.c | 47 +- hw/mcf_intc.c | 35 +- hw/mcf_uart.c | 34 +- hw/megasas.c | 2213 + hw/mfi.h | 1249 + hw/microblaze/Makefile.objs | 10 + hw/microblaze_boot.c | 177 + hw/microblaze_boot.h | 10 + hw/microblaze_pic_cpu.c | 4 +- hw/microblaze_pic_cpu.h | 2 +- hw/milkymist-ac97.c | 33 +- hw/milkymist-hpdmc.c | 33 +- hw/milkymist-hw.h | 24 +- hw/milkymist-memcard.c | 33 +- hw/milkymist-minimac2.c | 64 +- hw/milkymist-pfpu.c | 37 +- hw/milkymist-softusb.c | 63 +- hw/milkymist-sysctl.c | 84 +- hw/milkymist-tmu2.c | 37 +- hw/milkymist-uart.c | 35 +- hw/milkymist-vgafb.c | 54 +- hw/milkymist-vgafb_template.h | 2 +- hw/milkymist.c | 45 +- hw/mips.h | 15 +- hw/mips/Makefile.objs | 6 + hw/mips_cpudevs.h | 4 +- hw/mips_fulong2e.c | 71 +- hw/mips_int.c | 6 +- hw/mips_jazz.c | 78 +- hw/mips_malta.c | 196 +- hw/mips_mipssim.c | 37 +- hw/mips_r4k.c | 62 +- hw/mips_timer.c | 20 +- hw/mipsnet.c | 57 +- hw/mpc8544_guts.c | 60 +- hw/mpcore.c | 283 - hw/msi.c | 81 +- hw/msi.h | 9 + hw/msix.c | 436 +- hw/msix.h | 27 +- hw/msmouse.c | 5 +- hw/msmouse.h | 2 +- hw/mst_fpga.c | 60 +- hw/multiboot.c | 28 +- hw/musicpal.c | 281 +- hw/nand.c | 78 +- hw/ne2000-isa.c | 42 +- hw/ne2000.c | 103 +- hw/ne2000.h | 4 +- hw/nseries.c | 139 +- hw/null-machine.c | 35 + hw/nvram.h | 16 +- hw/omap.h | 228 +- hw/omap1.c | 352 +- hw/omap2.c | 278 +- hw/omap_dma.c | 91 +- hw/omap_dss.c | 199 +- hw/omap_gpio.c | 189 +- hw/omap_gpmc.c | 46 +- hw/omap_gptimer.c | 40 +- hw/omap_i2c.c | 140 +- hw/omap_intc.c | 86 +- hw/omap_l4.c | 190 +- hw/omap_lcdc.c | 111 +- hw/omap_mmc.c | 48 +- hw/omap_sdrc.c | 41 +- hw/omap_spi.c | 39 +- hw/omap_sx1.c | 141 +- hw/omap_synctimer.c | 36 +- hw/omap_tap.c | 34 +- hw/omap_uart.c | 50 +- hw/onenand.c | 58 +- hw/opencores_eth.c | 90 +- hw/openpic.c | 111 +- hw/openpic.h | 4 +- hw/openrisc/Makefile.objs | 3 + hw/openrisc_pic.c | 60 + hw/openrisc_sim.c | 149 + hw/openrisc_timer.c | 101 + hw/palm.c | 34 +- hw/parallel.c | 77 +- hw/pc.c | 458 +- hw/pc.h | 132 +- hw/pc_piix.c | 534 +- hw/pc_sysfw.c | 266 + hw/pci-hotplug.c | 52 +- hw/pci-stub.c | 2 +- hw/pci.c | 440 +- hw/pci.h | 247 +- hw/pci_bridge.c | 87 +- hw/pci_bridge.h | 2 +- hw/pci_bridge_dev.c | 171 + hw/pci_host.c | 23 +- hw/pci_host.h | 6 + hw/pci_ids.h | 11 + hw/pci_internals.h | 30 +- hw/pci_regs.h | 3 +- hw/pcie.c | 2 +- hw/pcie.h | 10 + hw/pcie_aer.c | 9 +- hw/pcie_host.c | 41 +- hw/pcie_host.h | 15 +- hw/pcie_port.c | 12 +- hw/pckbd.c | 83 +- hw/pcnet-pci.c | 85 +- hw/pcnet.c | 59 +- hw/pcnet.h | 11 +- hw/pcspk.c | 86 +- hw/pcspk.h | 45 + hw/petalogix_ml605_mmu.c | 211 +- hw/petalogix_s3adsp1800_mmu.c | 169 +- hw/pflash_cfi01.c | 277 +- hw/pflash_cfi02.c | 317 +- hw/piix4.c | 45 +- hw/piix_pci.c | 292 +- hw/pl011.c | 88 +- hw/pl022.c | 60 +- hw/pl031.c | 154 +- hw/pl041.c | 57 +- hw/pl041.h | 2 +- hw/pl041.hx | 2 +- hw/pl050.c | 81 +- hw/pl061.c | 81 +- hw/pl080.c | 90 +- hw/pl110.c | 155 +- hw/pl110_template.h | 22 +- hw/pl181.c | 112 +- hw/pl190.c | 83 +- hw/ppc.c | 178 +- hw/ppc.h | 28 +- hw/ppc/Makefile.objs | 31 + hw/ppc/e500.c | 580 + hw/ppc/e500.h | 21 + hw/ppc/e500plat.c | 61 + hw/ppc/mpc8544ds.c | 62 + hw/ppc405.h | 20 +- hw/ppc405_boards.c | 71 +- hw/ppc405_uc.c | 137 +- hw/ppc440.c | 106 - hw/ppc440.h | 21 - hw/ppc440_bamboo.c | 184 +- hw/ppc4xx.h | 26 +- hw/ppc4xx_devs.c | 55 +- hw/ppc4xx_pci.c | 205 +- hw/ppc_booke.c | 20 +- hw/ppc_mac.h | 5 +- hw/ppc_newworld.c | 70 +- hw/ppc_oldworld.c | 45 +- hw/ppc_prep.c | 207 +- hw/ppce500_mpc8544ds.c | 409 - hw/ppce500_pci.c | 133 +- hw/ppce500_spin.c | 65 +- hw/prep_pci.c | 221 +- hw/prep_pci.h | 11 - hw/primecell.h | 6 - hw/ps2.c | 8 +- hw/ps2.h | 29 + hw/ptimer.c | 14 + hw/ptimer.h | 39 + hw/puv3.c | 133 + hw/puv3.h | 49 + hw/puv3_dma.c | 109 + hw/puv3_gpio.c | 141 + hw/puv3_intc.c | 135 + hw/puv3_ost.c | 151 + hw/puv3_pm.c | 149 + hw/pxa.h | 35 +- hw/pxa2xx.c | 528 +- hw/pxa2xx_dma.c | 110 +- hw/pxa2xx_gpio.c | 80 +- hw/pxa2xx_keypad.c | 110 +- hw/pxa2xx_lcd.c | 150 +- hw/pxa2xx_mmci.c | 50 +- hw/pxa2xx_pcmcia.c | 98 +- hw/pxa2xx_pic.c | 138 +- hw/pxa2xx_timer.c | 108 +- hw/qdev-addr.c | 59 +- hw/qdev-addr.h | 4 +- hw/qdev-core.h | 238 + hw/qdev-dma.h | 10 + hw/qdev-monitor.c | 617 + hw/qdev-monitor.h | 16 + hw/qdev-properties.c | 1124 +- hw/qdev-properties.h | 130 + hw/qdev.c | 984 +- hw/qdev.h | 331 +- hw/qxl-logger.c | 51 +- hw/qxl-render.c | 180 +- hw/qxl.c | 1085 +- hw/qxl.h | 56 +- hw/r2d.c | 58 +- hw/rc4030.c | 85 +- hw/realview.c | 177 +- hw/realview_gic.c | 87 +- hw/rtl8139.c | 298 +- hw/s390-virtio-bus.c | 323 +- hw/s390-virtio-bus.h | 40 +- hw/s390-virtio.c | 88 +- hw/s390x/Makefile.objs | 6 + hw/s390x/event-facility.c | 398 + hw/s390x/event-facility.h | 96 + hw/s390x/sclp.c | 163 + hw/s390x/sclp.h | 118 + hw/s390x/sclpconsole.c | 306 + hw/s390x/sclpquiesce.c | 123 + hw/sb16.c | 150 +- hw/sbi.c | 60 +- hw/scsi-bus.c | 746 +- hw/scsi-defs.h | 21 +- hw/scsi-disk.c | 1610 +- hw/scsi-generic.c | 99 +- hw/scsi.h | 70 +- hw/sd.c | 308 +- hw/sd.h | 7 +- hw/serial-isa.c | 130 + hw/serial-pci.c | 252 + hw/serial.c | 182 +- hw/serial.h | 99 + hw/sga.c | 25 +- hw/sh.h | 9 +- hw/sh4/Makefile.objs | 5 + hw/sh7750.c | 173 +- hw/sh7750_regs.h | 2 +- hw/sh_intc.c | 87 +- hw/sh_intc.h | 7 +- hw/sh_pci.c | 80 +- hw/sh_serial.c | 61 +- hw/sh_timer.c | 50 +- hw/sharpsl.h | 2 +- hw/shix.c | 27 +- hw/shpc.c | 681 + hw/shpc.h | 48 + hw/slavio_intctl.c | 98 +- hw/slavio_misc.c | 309 +- hw/slavio_timer.c | 81 +- hw/slotid_cap.c | 44 + hw/slotid_cap.h | 11 + hw/sm501.c | 40 +- hw/smbios.c | 2 + hw/smbus.c | 85 +- hw/smbus.h | 40 +- hw/smbus_eeprom.c | 43 +- hw/smc91c111.c | 63 +- hw/soc_dma.c | 8 +- hw/soc_dma.h | 11 +- hw/spapr.c | 632 +- hw/spapr.h | 68 +- hw/spapr_events.c | 321 + hw/spapr_hcall.c | 206 +- hw/spapr_iommu.c | 287 + hw/spapr_llan.c | 163 +- hw/spapr_pci.c | 783 +- hw/spapr_pci.h | 49 +- hw/spapr_rtas.c | 49 +- hw/spapr_vio.c | 547 +- hw/spapr_vio.h | 131 +- hw/spapr_vscsi.c | 94 +- hw/spapr_vty.c | 66 +- hw/sparc/Makefile.objs | 8 + hw/sparc32_dma.c | 74 +- hw/sparc32_dma.h | 4 +- hw/sparc64/Makefile.objs | 4 + hw/spitz.c | 203 +- hw/srp.h | 8 +- hw/ssd0303.c | 45 +- hw/ssd0323.c | 37 +- hw/ssi-sd.c | 34 +- hw/ssi.c | 156 +- hw/ssi.h | 58 +- hw/stellaris.c | 270 +- hw/stellaris_enet.c | 49 +- hw/stream.c | 23 + hw/stream.h | 31 + hw/strongarm.c | 215 +- hw/strongarm.h | 2 +- hw/sun4c_intctl.c | 86 +- hw/sun4m.c | 415 +- hw/sun4m.h | 10 +- hw/sun4m_iommu.c | 92 +- hw/sun4u.c | 347 +- hw/syborg.c | 113 - hw/syborg.h | 18 - hw/syborg_fb.c | 560 - hw/syborg_interrupt.c | 238 - hw/syborg_keyboard.c | 221 - hw/syborg_pointer.c | 226 - hw/syborg_rtc.c | 140 - hw/syborg_serial.c | 335 - hw/syborg_timer.c | 231 - hw/syborg_virtio.c | 313 - hw/sysbus.c | 173 +- hw/sysbus.h | 58 +- hw/tc6393xb.c | 26 +- hw/tc6393xb_template.h | 2 +- hw/tcx.c | 219 +- hw/tmp105.c | 45 +- hw/tosa.c | 91 +- hw/tusb6010.c | 41 +- hw/twl92230.c | 73 +- hw/unicore32/Makefile.objs | 6 + hw/unin_pci.c | 343 +- hw/usb-bt.c | 570 - hw/usb-bus.c | 482 - hw/usb-ccid.c | 1321 - hw/usb-desc.c | 466 - hw/usb-desc.h | 112 - hw/usb-ehci.c | 2370 - hw/usb-hid.c | 612 - hw/usb-hub.c | 562 - hw/usb-libhw.c | 63 - hw/usb-msd.c | 677 - hw/usb-musb.c | 1543 - hw/usb-net.c | 1426 - hw/usb-ohci.c | 1870 - hw/usb-ohci.h | 9 - hw/usb-serial.c | 625 - hw/usb-uhci.c | 1285 - hw/usb-uhci.h | 10 - hw/usb-wacom.c | 379 - hw/usb.c | 416 - hw/usb.h | 249 +- hw/usb/Makefile.objs | 14 + hw/usb/bus.c | 628 + hw/usb/combined-packet.c | 186 + hw/usb/core.c | 767 + hw/usb/desc.c | 790 + hw/usb/desc.h | 224 + hw/usb/dev-audio.c | 700 + hw/usb/dev-bluetooth.c | 553 + hw/usb/dev-hid.c | 634 + hw/usb/dev-hub.c | 581 + hw/usb/dev-network.c | 1441 + hw/usb/dev-serial.c | 646 + hw/usb/dev-smartcard-reader.c | 1356 + hw/usb/dev-storage.c | 732 + hw/usb/dev-uas.c | 772 + hw/usb/dev-wacom.c | 378 + hw/usb/hcd-ehci-pci.c | 218 + hw/usb/hcd-ehci-sysbus.c | 77 + hw/usb/hcd-ehci.c | 2437 + hw/usb/hcd-ehci.h | 319 + hw/usb/hcd-musb.c | 1546 + hw/usb/hcd-ohci.c | 1925 + hw/usb/hcd-uhci.c | 1411 + hw/usb/hcd-xhci.c | 3184 ++ hw/usb/host-bsd.c | 644 + hw/usb/host-linux.c | 2022 + hw/usb/host-stub.c | 52 + hw/usb/libhw.c | 70 + hw/usb/redirect.c | 2000 + hw/versatile_i2c.c | 107 + hw/versatile_pci.c | 74 +- hw/versatilepb.c | 154 +- hw/vexpress.c | 457 +- hw/vfio_pci.c | 2115 + hw/vga-isa-mm.c | 26 +- hw/vga-isa.c | 37 +- hw/vga-pci.c | 184 +- hw/vga.c | 684 +- hw/vga.h | 159 + hw/vga_int.h | 67 +- hw/vga_template.h | 74 +- hw/vhost.c | 226 +- hw/vhost.h | 8 +- hw/vhost_net.c | 36 +- hw/vhost_net.h | 2 +- hw/virtex_ml507.c | 67 +- hw/virtio-balloon.c | 28 +- hw/virtio-blk.c | 191 +- hw/virtio-blk.h | 22 +- hw/virtio-console.c | 102 +- hw/virtio-net.c | 225 +- hw/virtio-net.h | 1 + hw/virtio-pci.c | 709 +- hw/virtio-pci.h | 15 +- hw/virtio-rng.c | 258 + hw/virtio-rng.h | 28 + hw/virtio-scsi.c | 742 + hw/virtio-scsi.h | 43 + hw/virtio-serial-bus.c | 268 +- hw/virtio-serial.h | 85 +- hw/virtio.c | 190 +- hw/virtio.h | 49 +- hw/vmmouse.c | 41 +- hw/vmport.c | 60 +- hw/vmware_vga.c | 550 +- hw/vmware_vga.h | 19 - hw/vt82c686.c | 192 +- hw/vt82c686.h | 2 +- hw/watchdog.c | 4 +- hw/wdt_i6300esb.c | 57 +- hw/wdt_ib700.c | 28 +- hw/wm8750.c | 51 +- hw/xen-host-pci-device.c | 396 + hw/xen-host-pci-device.h | 55 + hw/xen.h | 10 +- hw/xen_apic.c | 95 + hw/xen_backend.c | 3 + hw/xen_backend.h | 1 + hw/xen_common.h | 18 + hw/xen_devconfig.c | 23 +- hw/xen_disk.c | 6 +- hw/xen_domainbuild.c | 1 - hw/xen_machine_pv.c | 17 +- hw/xen_nic.c | 13 +- hw/xen_platform.c | 116 +- hw/xen_pt.c | 843 + hw/xen_pt.h | 302 + hw/xen_pt_config_init.c | 1882 + hw/xen_pt_msi.c | 620 + hw/xenfb.c | 6 +- hw/xgmac.c | 433 + hw/xics.c | 220 +- hw/xics.h | 3 +- hw/xilinx.h | 62 +- hw/xilinx_axidma.c | 139 +- hw/xilinx_axidma.h | 39 - hw/xilinx_axienet.c | 110 +- hw/xilinx_ethlite.c | 56 +- hw/xilinx_intc.c | 41 +- hw/xilinx_spi.c | 385 + hw/xilinx_spips.c | 575 + hw/xilinx_timer.c | 74 +- hw/xilinx_uartlite.c | 32 +- hw/xilinx_zynq.c | 213 + hw/xio3130_downstream.c | 78 +- hw/xio3130_upstream.c | 72 +- hw/xtensa/Makefile.objs | 5 + hw/xtensa_lx60.c | 78 +- hw/xtensa_pic.c | 23 +- hw/xtensa_sim.c | 52 +- hw/z2.c | 105 +- hw/zaurus.c | 64 +- hw/zynq_slcr.c | 535 + hwaddr.h | 24 + include/qemu/cpu.h | 140 + include/qemu/object.h | 992 + include/qemu/page_cache.h | 79 + include/qemu/qom-qobject.h | 42 + include/qemu/ratelimit.h | 48 + include/qemu/rng-random.h | 22 + include/qemu/rng.h | 93 + input.c | 260 +- iohandler.c | 8 +- ioport-user.c | 60 - ioport.c | 43 +- ioport.h | 2 + iorange.h | 1 + iov.c | 331 +- iov.h | 88 +- json-lexer.c | 1 + json-parser.c | 230 +- kvm-all.c | 910 +- kvm-stub.c | 75 +- kvm.h | 167 +- libcacard/Makefile | 29 +- libcacard/card_7816.c | 4 +- libcacard/card_7816.h | 2 +- libcacard/vcard.c | 1 - libcacard/vcard_emul_nss.c | 44 +- libcacard/vcardt.h | 2 +- libcacard/vreader.c | 1 - libcacard/vscard_common.h | 2 +- libcacard/vscclient.c | 22 +- linux-aio.c | 229 - linux-headers/asm-powerpc/kvm.h | 12 +- linux-headers/asm-powerpc/kvm_para.h | 47 +- linux-headers/asm-s390/kvm.h | 18 +- linux-headers/asm-s390/kvm_para.h | 8 +- linux-headers/asm-x86/hyperv.h | 1 + linux-headers/asm-x86/kvm.h | 22 + linux-headers/asm-x86/kvm_para.h | 7 + linux-headers/linux/kvm.h | 154 +- linux-headers/linux/kvm_para.h | 7 +- linux-headers/linux/vfio.h | 368 + linux-headers/linux/virtio_config.h | 6 +- linux-headers/linux/virtio_ring.h | 12 +- linux-user/Makefile.objs | 7 + linux-user/alpha/syscall_nr.h | 2 +- linux-user/alpha/target_signal.h | 7 +- linux-user/arm/nwfpe/Makefile.objs | 2 + linux-user/arm/nwfpe/fpopcode.h | 34 +- linux-user/arm/syscall_nr.h | 2 +- linux-user/cpu-uname.c | 7 +- linux-user/elfload.c | 312 +- linux-user/flatload.c | 4 +- linux-user/ioctls.h | 38 +- linux-user/linuxload.c | 8 +- linux-user/m68k/syscall.h | 2 +- linux-user/main.c | 314 +- linux-user/mips64/syscall.h | 3 + linux-user/mipsn32/syscall.h | 3 + linux-user/mmap.c | 71 +- linux-user/openrisc/syscall.h | 24 + linux-user/openrisc/syscall_nr.h | 506 + linux-user/openrisc/target_signal.h | 26 + linux-user/openrisc/termbits.h | 294 + linux-user/qemu.h | 84 +- linux-user/signal.c | 549 +- linux-user/strace.c | 31 +- linux-user/strace.list | 3 + linux-user/syscall.c | 1079 +- linux-user/syscall_defs.h | 325 +- linux-user/syscall_types.h | 43 +- linux-user/x86_64/syscall.h | 2 +- lm32-dis.c | 361 + m68k-dis.c | 2 +- m68k-semi.c | 408 - main-loop.c | 306 +- main-loop.h | 71 +- memory-internal.h | 141 + memory.c | 1005 +- memory.h | 509 +- memory_mapping-stub.c | 33 + memory_mapping.c | 246 + memory_mapping.h | 64 + migration-exec.c | 50 +- migration-fd.c | 65 +- migration-tcp.c | 117 +- migration-unix.c | 115 +- migration.c | 349 +- migration.h | 72 +- module.c | 3 +- module.h | 4 +- monitor.c | 2107 +- monitor.h | 37 +- nbd.c | 1000 +- nbd.h | 33 +- net.c | 1198 +- net.h | 126 +- net/Makefile.objs | 12 + net/checksum.c | 2 +- net/clients.h | 55 + net/dump.c | 60 +- net/dump.h | 33 - net/hub.c | 340 + net/hub.h | 27 + net/queue.c | 68 +- net/queue.h | 27 +- net/slirp.c | 228 +- net/slirp.h | 6 +- net/socket.c | 477 +- net/socket.h | 33 - net/tap-aix.c | 2 +- net/tap-bsd.c | 8 +- net/tap-haiku.c | 2 +- net/tap-linux.c | 9 +- net/tap-solaris.c | 4 +- net/tap-win32.c | 49 +- net/tap.c | 349 +- net/tap.h | 22 +- net/vde.c | 35 +- net/vde.h | 36 - notify.c | 12 +- notify.h | 8 +- os-posix.c | 52 +- os-win32.c | 20 +- osdep.c | 234 + osdep.h | 44 +- oslib-posix.c | 18 + oslib-win32.c | 32 + page_cache.c | 218 + pc-bios/README | 4 +- pc-bios/bamboo.dtb | Bin 3179 -> 3211 bytes pc-bios/bamboo.dts | 128 +- pc-bios/bios.bin | Bin 131072 -> 131072 bytes pc-bios/keymaps/fi | 2 - pc-bios/keymaps/is | 2 +- pc-bios/kvmvapic.bin | Bin 0 -> 9216 bytes pc-bios/mpc8544ds.dtb | Bin 2028 -> 0 bytes pc-bios/mpc8544ds.dts | 119 - pc-bios/ohw.diff | 2 +- pc-bios/openbios-ppc | Bin 729876 -> 729908 bytes pc-bios/openbios-sparc32 | Bin 381484 -> 381764 bytes pc-bios/openbios-sparc64 | Bin 1598328 -> 1598648 bytes pc-bios/optionrom/Makefile | 7 +- pc-bios/optionrom/kvmvapic.S | 335 + pc-bios/optionrom/multiboot.S | 2 +- pc-bios/optionrom/optionrom.h | 3 +- pc-bios/qemu-icon.bmp | Bin 0 -> 630 bytes pc-bios/slof.bin | Bin 738744 -> 878640 bytes pflib.c | 213 - pflib.h | 20 - pixman | 1 + poison.h | 3 +- posix-aio-compat.c | 696 - ppc-dis.c | 2 +- qapi-schema-guest.json | 360 +- qapi-schema-test.json | 18 +- qapi-schema.json | 2180 +- qapi/Makefile.objs | 5 + qapi/opts-visitor.c | 427 + qapi/opts-visitor.h | 31 + qapi/qapi-types-core.h | 4 +- qapi/qapi-visit-core.c | 207 +- qapi/qapi-visit-core.h | 19 + qapi/qapi-visit-impl.h | 23 + qapi/qmp-core.h | 16 +- qapi/qmp-dispatch.c | 23 +- qapi/qmp-input-visitor.c | 187 +- qapi/qmp-input-visitor.h | 2 + qapi/qmp-output-visitor.c | 30 +- qapi/qmp-registry.c | 70 +- qapi/string-input-visitor.c | 138 + qapi/string-input-visitor.h | 25 + qapi/string-output-visitor.c | 89 + qapi/string-output-visitor.h | 26 + qemu-aio.h | 232 +- qemu-barrier.h | 37 +- qemu-bridge-helper.c | 428 + qemu-char.c | 232 +- qemu-char.h | 5 +- qemu-common.h | 173 +- qemu-config.c | 216 +- qemu-config.h | 10 + qemu-coroutine-int.h | 2 +- qemu-coroutine-io.c | 65 + qemu-coroutine-lock.c | 25 +- qemu-coroutine-sleep.c | 39 + qemu-coroutine.h | 20 + qemu-doc.texi | 335 +- qemu-error.c | 5 + qemu-error.h | 1 + qemu-file.h | 241 + qemu-ga.c | 830 +- qemu-img-cmds.hx | 8 +- qemu-img.c | 575 +- qemu-img.texi | 86 +- qemu-io.c | 228 +- qemu-log.c | 167 + qemu-log.h | 157 +- qemu-nbd.c | 300 +- qemu-nbd.texi | 2 +- qemu-option-internal.h | 53 + qemu-option.c | 268 +- qemu-option.h | 26 +- qemu-options-wrapper.h | 41 + qemu-options.h | 9 +- qemu-options.hx | 655 +- qemu-os-posix.h | 2 + qemu-os-win32.h | 47 +- qemu-pixman.c | 78 + qemu-pixman.h | 39 + qemu-queue.h | 194 +- qemu-seccomp.c | 141 + qemu-seccomp.h | 22 + qemu-sockets.c | 692 +- qemu-tech.texi | 15 +- qemu-thread-posix.c | 187 +- qemu-thread-posix.h | 11 + qemu-thread-win32.c | 162 +- qemu-thread-win32.h | 12 +- qemu-thread.h | 18 +- qemu-timer.c | 233 +- qemu-timer.h | 35 +- qemu-tls.h | 4 +- qemu-tool.c | 54 +- qemu-user.c | 37 + qemu_socket.h | 45 +- qerror.c | 447 +- qerror.h | 222 +- qga/Makefile.objs | 5 + qga/channel-posix.c | 264 + qga/channel-win32.c | 344 + qga/channel.h | 33 + qga/commands-posix.c | 1001 + qga/commands-win32.c | 284 + qga/commands.c | 79 + qga/guest-agent-commands.c | 561 - qga/guest-agent-core.h | 13 +- qga/service-win32.c | 114 + qga/service-win32.h | 30 + qjson.h | 1 + qlist.c | 13 + qlist.h | 1 + qmp-commands.hx | 858 +- qmp.c | 404 +- qobject.h | 2 +- qom/Makefile.objs | 4 + qom/container.c | 52 + qom/cpu.c | 58 + qom/object.c | 1271 + qom/qom-qobject.c | 44 + qtest.c | 444 + qtest.h | 53 + readline.c | 3 + roms/Makefile | 27 + roms/SLOF | 2 +- roms/config.seabios | 1 + roms/config.vga.cirrus | 3 + roms/config.vga.isavga | 3 + roms/config.vga.qxl | 6 + roms/config.vga.stdvga | 3 + roms/config.vga.vmware | 6 + roms/configure-seabios.sh | 5 + roms/openbios | 2 +- roms/seabios | 2 +- rules.mak | 51 +- savevm.c | 674 +- scripts/analyse-9p-simpletrace.py | 75 +- scripts/check-qerror.sh | 22 + scripts/checkpatch.pl | 79 +- scripts/create_config | 14 +- scripts/gtester-cat | 26 + scripts/hxtool | 3 + scripts/kvm/kvm_flightrecorder | 126 + scripts/kvm/kvm_stat | 37 +- scripts/kvm/vmxcap | 13 + scripts/make-release | 24 + scripts/qapi-commands.py | 56 +- scripts/qapi-types.py | 68 +- scripts/qapi-visit.py | 180 +- scripts/qapi.py | 62 +- scripts/qemu-binfmt-conf.sh | 1 + scripts/qemu-gdb.py | 89 + scripts/qtest | 5 + scripts/signrom.py | 40 + scripts/signrom.sh | 45 - scripts/simpletrace.py | 116 +- scripts/texi2pod.pl | 9 + scripts/tracetool | 643 - scripts/tracetool.py | 138 + scripts/tracetool/__init__.py | 274 + scripts/tracetool/backend/__init__.py | 115 + scripts/tracetool/backend/dtrace.py | 106 + scripts/tracetool/backend/simple.py | 107 + scripts/tracetool/backend/stderr.py | 56 + scripts/tracetool/backend/ust.py | 90 + scripts/tracetool/format/__init__.py | 103 + scripts/tracetool/format/c.py | 20 + scripts/tracetool/format/d.py | 20 + scripts/tracetool/format/h.py | 45 + scripts/tracetool/format/stap.py | 20 + scripts/update-linux-headers.sh | 24 +- slirp/Makefile.objs | 3 + slirp/arp_table.c | 4 +- slirp/bootp.c | 15 +- slirp/cksum.c | 2 +- slirp/dnssearch.c | 314 + slirp/if.c | 144 +- slirp/if.h | 2 - slirp/ip.h | 20 +- slirp/ip_icmp.c | 12 + slirp/ip_icmp.h | 5 +- slirp/ip_input.c | 8 +- slirp/libslirp.h | 4 +- slirp/main.h | 1 + slirp/mbuf.c | 21 + slirp/mbuf.h | 6 + slirp/misc.c | 148 +- slirp/misc.h | 1 - slirp/sbuf.c | 6 + slirp/slirp.c | 21 +- slirp/slirp.h | 23 +- slirp/tcp.h | 34 +- slirp/tcp_input.c | 2 - slirp/tcp_output.c | 1 + slirp/tcp_subr.c | 26 +- slirp/tftp.c | 104 +- slirp/tftp.h | 2 + slirp/udp.c | 9 +- slirp/udp.h | 1 + softmmu-semi.h | 17 +- softmmu_defs.h | 41 +- softmmu_header.h | 52 +- softmmu_template.h | 169 +- sparc-dis.c | 2 +- spice-qemu-char.c | 11 +- stubs/Makefile.objs | 8 + stubs/arch-query-cpu-def.c | 9 + stubs/fd-register.c | 6 + stubs/fdset-add-fd.c | 7 + stubs/fdset-find-fd.c | 7 + stubs/fdset-get-fd.c | 7 + stubs/fdset-remove-fd.c | 7 + stubs/get-fd.c | 8 + stubs/set-fd-handler.c | 11 + sysconfigs/target/target-x86_64.conf | 86 - sysemu.h | 51 +- target-alpha/Makefile.objs | 3 + target-alpha/STATUS | 4 +- target-alpha/cpu-qom.h | 71 + target-alpha/cpu.c | 58 + target-alpha/cpu.h | 53 +- target-alpha/fpu_helper.c | 822 + target-alpha/helper.c | 76 +- target-alpha/helper.h | 213 +- target-alpha/int_helper.c | 319 + target-alpha/machine.c | 44 +- target-alpha/mem_helper.c | 151 + target-alpha/op_helper.c | 1379 - target-alpha/sys_helper.c | 87 + target-alpha/translate.c | 408 +- target-arm/Makefile.objs | 4 + target-arm/arm-semi.c | 555 + target-arm/cpu-qom.h | 113 + target-arm/cpu.c | 805 + target-arm/cpu.h | 338 +- target-arm/helper.c | 3032 +- target-arm/helper.h | 83 +- target-arm/iwmmxt_helper.c | 66 +- target-arm/machine.c | 20 +- target-arm/neon_helper.c | 123 +- target-arm/op_helper.c | 170 +- target-arm/translate.c | 1085 +- target-cris/Makefile.objs | 2 + target-cris/cpu-qom.h | 70 + target-cris/cpu.c | 90 + target-cris/cpu.h | 37 +- target-cris/helper.c | 30 +- target-cris/helper.h | 39 +- target-cris/mmu.c | 19 +- target-cris/mmu.h | 6 +- target-cris/op_helper.c | 107 +- target-cris/translate.c | 5688 ++-- target-cris/translate_v10.c | 126 +- target-i386/Makefile.objs | 8 + target-i386/TODO | 1 - target-i386/arch_dump.c | 449 + target-i386/arch_memory_mapping.c | 272 + target-i386/cc_helper.c | 390 + target-i386/cc_helper_template.h | 277 + target-i386/cpu-qom.h | 79 + target-i386/cpu.c | 2137 + target-i386/cpu.h | 227 +- target-i386/cpuid.c | 1322 - target-i386/excp_helper.c | 129 + target-i386/fpu_helper.c | 1289 + target-i386/helper.c | 369 +- target-i386/helper.h | 357 +- target-i386/helper_template.h | 334 - target-i386/hyperv.c | 64 + target-i386/hyperv.h | 45 + target-i386/int_helper.c | 500 + target-i386/ioport-user.c | 60 + target-i386/kvm-stub.c | 18 + target-i386/kvm.c | 646 +- target-i386/kvm_i386.h | 38 + target-i386/machine.c | 201 +- target-i386/mem_helper.c | 155 + target-i386/misc_helper.c | 602 + target-i386/op_helper.c | 5881 --- target-i386/ops_sse.h | 1274 +- target-i386/ops_sse_header.h | 334 +- target-i386/seg_helper.c | 2471 + target-i386/shift_helper_template.h | 112 + target-i386/smm_helper.c | 301 + target-i386/svm_helper.c | 715 + target-i386/translate.c | 1449 +- target-lm32/Makefile.objs | 2 + target-lm32/cpu-qom.h | 71 + target-lm32/cpu.c | 81 + target-lm32/cpu.h | 49 +- target-lm32/helper.c | 42 +- target-lm32/helper.h | 20 +- target-lm32/machine.c | 22 +- target-lm32/op_helper.c | 37 +- target-lm32/translate.c | 91 +- target-m68k/Makefile.objs | 3 + target-m68k/cpu-qom.h | 70 + target-m68k/cpu.c | 170 + target-m68k/cpu.h | 24 +- target-m68k/helper.c | 245 +- target-m68k/helpers.h | 2 +- target-m68k/m68k-semi.c | 465 + target-m68k/op_helper.c | 83 +- target-m68k/translate.c | 322 +- target-microblaze/Makefile.objs | 2 + target-microblaze/cpu-qom.h | 70 + target-microblaze/cpu.c | 120 + target-microblaze/cpu.h | 62 +- target-microblaze/helper.c | 18 +- target-microblaze/helper.h | 56 +- target-microblaze/mmu.c | 13 +- target-microblaze/mmu.h | 6 +- target-microblaze/op_helper.c | 136 +- target-microblaze/translate.c | 331 +- target-mips/Makefile.objs | 2 + target-mips/TODO | 7 +- target-mips/cpu-qom.h | 74 + target-mips/cpu.c | 69 + target-mips/cpu.h | 176 +- target-mips/dsp_helper.c | 4033 ++ target-mips/helper.c | 38 +- target-mips/helper.h | 838 +- target-mips/lmi_helper.c | 744 + target-mips/machine.c | 6 +- target-mips/op_helper.c | 1759 +- target-mips/translate.c | 5123 ++- target-mips/translate_init.c | 52 + target-openrisc/Makefile.objs | 4 + target-openrisc/cpu.c | 220 + target-openrisc/cpu.h | 460 + target-openrisc/exception.c | 27 + target-openrisc/exception.h | 28 + target-openrisc/exception_helper.c | 29 + target-openrisc/fpu_helper.c | 300 + target-openrisc/helper.h | 70 + target-openrisc/int_helper.c | 79 + target-openrisc/interrupt.c | 74 + target-openrisc/interrupt_helper.c | 57 + target-openrisc/machine.c | 47 + target-openrisc/mmu.c | 243 + target-openrisc/mmu_helper.c | 63 + target-openrisc/sys_helper.c | 287 + target-openrisc/translate.c | 1836 + target-ppc/Makefile.objs | 12 + target-ppc/cpu-qom.h | 77 + target-ppc/cpu.h | 244 +- target-ppc/excp_helper.c | 973 + target-ppc/fpu_helper.c | 1740 + target-ppc/helper.c | 3183 +-- target-ppc/helper.h | 592 +- target-ppc/int_helper.c | 1483 + target-ppc/kvm.c | 420 +- target-ppc/kvm_ppc.c | 2 +- target-ppc/kvm_ppc.h | 41 +- target-ppc/machine.c | 24 +- target-ppc/mem_helper.c | 295 + target-ppc/mfrom_table_gen.c | 2 +- target-ppc/misc_helper.c | 124 + target-ppc/mmu_helper.c | 3323 ++ target-ppc/mpic_helper.c | 35 + target-ppc/op_helper.c | 4413 -- target-ppc/timebase_helper.c | 159 + target-ppc/translate.c | 712 +- target-ppc/translate_init.c | 627 +- target-s390x/Makefile.objs | 4 + target-s390x/cc_helper.c | 550 + target-s390x/cpu-qom.h | 71 + target-s390x/cpu.c | 96 + target-s390x/cpu.h | 95 +- target-s390x/fpu_helper.c | 843 + target-s390x/helper.c | 182 +- target-s390x/helper.h | 152 + target-s390x/helpers.h | 152 - target-s390x/int_helper.c | 201 + target-s390x/interrupt.c | 29 + target-s390x/kvm.c | 241 +- target-s390x/mem_helper.c | 1203 + target-s390x/misc_helper.c | 387 + target-s390x/op_helper.c | 3026 -- target-s390x/translate.c | 691 +- target-sh4/Makefile.objs | 2 + target-sh4/cpu-qom.h | 70 + target-sh4/cpu.c | 90 + target-sh4/cpu.h | 44 +- target-sh4/helper.c | 49 +- target-sh4/helper.h | 86 +- target-sh4/op_helper.c | 285 +- target-sh4/translate.c | 392 +- target-sparc/Makefile.objs | 6 + target-sparc/TODO | 2 +- target-sparc/cc_helper.c | 66 +- target-sparc/cpu-qom.h | 75 + target-sparc/cpu.c | 895 + target-sparc/cpu.h | 92 +- target-sparc/cpu_init.c | 848 - target-sparc/fop_helper.c | 131 +- target-sparc/helper.c | 102 +- target-sparc/helper.h | 78 +- target-sparc/int32_helper.c | 18 +- target-sparc/int64_helper.c | 25 +- target-sparc/ldst_helper.c | 559 +- target-sparc/machine.c | 4 +- target-sparc/mmu_helper.c | 80 +- target-sparc/op_helper.c | 74 - target-sparc/translate.c | 2516 +- target-sparc/vis_helper.c | 2 +- target-sparc/win_helper.c | 58 +- target-unicore32/Makefile.objs | 4 + target-unicore32/cpu-qom.h | 59 + target-unicore32/cpu.c | 113 + target-unicore32/cpu.h | 58 +- target-unicore32/helper.c | 580 +- target-unicore32/helper.h | 46 +- target-unicore32/machine.c | 23 + target-unicore32/op_helper.c | 100 +- target-unicore32/softmmu.c | 267 + target-unicore32/translate.c | 274 +- target-unicore32/ucf64_helper.c | 345 + target-xtensa/Makefile.objs | 6 + target-xtensa/core-dc232b.c | 29 +- target-xtensa/core-dc233c.c | 55 + target-xtensa/core-dc233c/core-isa.h | 474 + target-xtensa/core-dc233c/gdb-config.c | 145 + target-xtensa/core-fsf.c | 29 +- target-xtensa/cpu-qom.h | 80 + target-xtensa/cpu.c | 88 + target-xtensa/cpu.h | 120 +- target-xtensa/helper.c | 211 +- target-xtensa/helper.h | 60 + target-xtensa/helpers.h | 32 - target-xtensa/op_helper.c | 453 +- target-xtensa/overlay_tool.h | 24 +- target-xtensa/translate.c | 612 +- target-xtensa/xtensa-semi.c | 321 + targphys.h | 21 - tcg/README | 46 +- tcg/arm/tcg-target.c | 370 +- tcg/arm/tcg-target.h | 9 +- tcg/hppa/tcg-target.c | 334 +- tcg/hppa/tcg-target.h | 8 +- tcg/i386/tcg-target.c | 914 +- tcg/i386/tcg-target.h | 22 +- tcg/ia64/tcg-target.c | 238 +- tcg/ia64/tcg-target.h | 16 +- tcg/mips/tcg-target.c | 517 +- tcg/mips/tcg-target.h | 31 +- tcg/optimize.c | 688 +- tcg/ppc/tcg-target.c | 625 +- tcg/ppc/tcg-target.h | 5 +- tcg/ppc64/tcg-target.c | 77 +- tcg/ppc64/tcg-target.h | 3 +- tcg/s390/tcg-target.c | 65 +- tcg/s390/tcg-target.h | 8 +- tcg/sparc/tcg-target.c | 1621 +- tcg/sparc/tcg-target.h | 42 +- tcg/tcg-op.h | 689 +- tcg/tcg-opc.h | 34 +- tcg/tcg.c | 1073 +- tcg/tcg.h | 175 +- tcg/tci/tcg-target.c | 48 +- tcg/tci/tcg-target.h | 14 +- tci.c | 74 +- test-coroutine.c | 192 - test-qmp-commands.c | 142 - test-visitor.c | 338 - tests/.gitignore | 13 + tests/Makefile | 302 +- tests/alpha/Makefile | 35 - tests/alpha/crt.s | 26 - tests/alpha/hello-alpha.c | 5 - tests/alpha/test-cond.c | 87 - tests/alpha/test-ovf.c | 29 - tests/check-block.sh | 21 + tests/check-qdict.c | 378 + tests/check-qfloat.c | 53 + tests/check-qint.c | 87 + tests/check-qjson.c | 781 + tests/check-qlist.c | 127 + tests/check-qstring.c | 107 + tests/cris/.gdbinit | 11 - tests/cris/Makefile | 155 - tests/cris/README | 1 - tests/cris/check_abs.c | 40 - tests/cris/check_addc.c | 58 - tests/cris/check_addcm.c | 85 - tests/cris/check_addi.s | 57 - tests/cris/check_addiv32.s | 62 - tests/cris/check_addm.s | 96 - tests/cris/check_addo.c | 125 - tests/cris/check_addoq.c | 44 - tests/cris/check_addq.s | 47 - tests/cris/check_addr.s | 96 - tests/cris/check_addxc.s | 91 - tests/cris/check_addxm.s | 106 - tests/cris/check_addxr.s | 96 - tests/cris/check_andc.s | 80 - tests/cris/check_andm.s | 90 - tests/cris/check_andq.s | 46 - tests/cris/check_andr.s | 95 - tests/cris/check_asr.s | 230 - tests/cris/check_ba.s | 93 - tests/cris/check_bas.s | 102 - tests/cris/check_bcc.s | 197 - tests/cris/check_bound.c | 142 - tests/cris/check_boundc.s | 101 - tests/cris/check_boundr.s | 125 - tests/cris/check_btst.s | 96 - tests/cris/check_clearfv32.s | 19 - tests/cris/check_clrjmp1.s | 36 - tests/cris/check_cmp-2.s | 15 - tests/cris/check_cmpc.s | 86 - tests/cris/check_cmpm.s | 96 - tests/cris/check_cmpq.s | 75 - tests/cris/check_cmpr.s | 102 - tests/cris/check_cmpxc.s | 92 - tests/cris/check_cmpxm.s | 106 - tests/cris/check_dstep.s | 42 - tests/cris/check_ftag.c | 37 - tests/cris/check_gcctorture_pr28634-1.c | 15 - tests/cris/check_gcctorture_pr28634.c | 15 - tests/cris/check_glibc_kernelversion.c | 116 - tests/cris/check_hello.c | 7 - tests/cris/check_int64.c | 47 - tests/cris/check_jsr.s | 85 - tests/cris/check_lapc.s | 78 - tests/cris/check_lsl.s | 217 - tests/cris/check_lsr.s | 218 - tests/cris/check_lz.c | 49 - tests/cris/check_mapbrk.c | 39 - tests/cris/check_mcp.s | 49 - tests/cris/check_mmap1.c | 48 - tests/cris/check_mmap2.c | 48 - tests/cris/check_mmap3.c | 33 - tests/cris/check_movdelsr1.s | 33 - tests/cris/check_movecr.s | 37 - tests/cris/check_movei.s | 50 - tests/cris/check_movemr.s | 78 - tests/cris/check_movemrv32.s | 96 - tests/cris/check_moveq.c | 51 - tests/cris/check_mover.s | 28 - tests/cris/check_moverm.s | 45 - tests/cris/check_movmp.s | 131 - tests/cris/check_movpmv32.s | 35 - tests/cris/check_movpr.s | 28 - tests/cris/check_movprv32.s | 21 - tests/cris/check_movscr.s | 29 - tests/cris/check_movsm.s | 44 - tests/cris/check_movsr.s | 46 - tests/cris/check_movucr.s | 33 - tests/cris/check_movum.s | 40 - tests/cris/check_movur.s | 45 - tests/cris/check_mulv32.s | 51 - tests/cris/check_mulx.s | 246 - tests/cris/check_neg.s | 104 - tests/cris/check_not.s | 31 - tests/cris/check_openpf1.c | 38 - tests/cris/check_openpf2.c | 16 - tests/cris/check_openpf3.c | 49 - tests/cris/check_openpf4.c | 5 - tests/cris/check_openpf5.c | 56 - tests/cris/check_orc.s | 71 - tests/cris/check_orm.s | 75 - tests/cris/check_orq.s | 41 - tests/cris/check_orr.s | 84 - tests/cris/check_ret.s | 25 - tests/cris/check_scc.s | 95 - tests/cris/check_settls1.c | 45 - tests/cris/check_sigalrm.c | 26 - tests/cris/check_stat1.c | 16 - tests/cris/check_stat2.c | 20 - tests/cris/check_stat3.c | 25 - tests/cris/check_stat4.c | 27 - tests/cris/check_subc.s | 87 - tests/cris/check_subm.s | 96 - tests/cris/check_subq.s | 52 - tests/cris/check_subr.s | 102 - tests/cris/check_swap.c | 76 - tests/cris/check_time1.c | 46 - tests/cris/check_time2.c | 18 - tests/cris/check_xarith.s | 72 - tests/cris/crisutils.h | 71 - tests/cris/crt.s | 13 - tests/cris/sys.c | 51 - tests/cris/sys.h | 16 - tests/cris/testutils.inc | 117 - tests/fdc-test.c | 563 + tests/hd-geo-test.c | 428 + tests/hello-arm.c | 113 - tests/hello-i386.c | 26 - tests/hello-mips.c | 64 - tests/libqtest.c | 478 + tests/libqtest.h | 352 + tests/linux-test.c | 537 - tests/lm32/Makefile | 102 - tests/lm32/crt.S | 84 - tests/lm32/linker.ld | 55 - tests/lm32/macros.inc | 79 - tests/lm32/test_add.S | 75 - tests/lm32/test_addi.S | 56 - tests/lm32/test_and.S | 45 - tests/lm32/test_andhi.S | 35 - tests/lm32/test_andi.S | 35 - tests/lm32/test_b.S | 13 - tests/lm32/test_be.S | 48 - tests/lm32/test_bg.S | 78 - tests/lm32/test_bge.S | 78 - tests/lm32/test_bgeu.S | 78 - tests/lm32/test_bgu.S | 78 - tests/lm32/test_bi.S | 23 - tests/lm32/test_bne.S | 48 - tests/lm32/test_break.S | 20 - tests/lm32/test_bret.S | 38 - tests/lm32/test_call.S | 16 - tests/lm32/test_calli.S | 15 - tests/lm32/test_cmpe.S | 40 - tests/lm32/test_cmpei.S | 35 - tests/lm32/test_cmpg.S | 64 - tests/lm32/test_cmpge.S | 64 - tests/lm32/test_cmpgei.S | 55 - tests/lm32/test_cmpgeu.S | 64 - tests/lm32/test_cmpgeui.S | 55 - tests/lm32/test_cmpgi.S | 55 - tests/lm32/test_cmpgu.S | 64 - tests/lm32/test_cmpgui.S | 55 - tests/lm32/test_cmpne.S | 40 - tests/lm32/test_cmpnei.S | 35 - tests/lm32/test_divu.S | 29 - tests/lm32/test_eret.S | 38 - tests/lm32/test_lb.S | 45 - tests/lm32/test_lbu.S | 45 - tests/lm32/test_lh.S | 45 - tests/lm32/test_lhu.S | 45 - tests/lm32/test_lw.S | 30 - tests/lm32/test_modu.S | 35 - tests/lm32/test_mul.S | 70 - tests/lm32/test_muli.S | 45 - tests/lm32/test_nor.S | 51 - tests/lm32/test_nori.S | 35 - tests/lm32/test_or.S | 51 - tests/lm32/test_orhi.S | 35 - tests/lm32/test_ori.S | 35 - tests/lm32/test_ret.S | 14 - tests/lm32/test_sb.S | 30 - tests/lm32/test_scall.S | 20 - tests/lm32/test_sextb.S | 20 - tests/lm32/test_sexth.S | 20 - tests/lm32/test_sh.S | 30 - tests/lm32/test_sl.S | 45 - tests/lm32/test_sli.S | 30 - tests/lm32/test_sr.S | 57 - tests/lm32/test_sri.S | 40 - tests/lm32/test_sru.S | 57 - tests/lm32/test_srui.S | 40 - tests/lm32/test_sub.S | 75 - tests/lm32/test_sw.S | 35 - tests/lm32/test_xnor.S | 51 - tests/lm32/test_xnori.S | 35 - tests/lm32/test_xor.S | 51 - tests/lm32/test_xori.S | 35 - tests/m48t59-test.c | 259 + tests/pi_10.com | Bin 54 -> 0 bytes tests/qemu-iotests-quick.sh | 17 + tests/qemu-iotests/.gitignore | 7 + tests/qemu-iotests/001 | 65 + tests/qemu-iotests/001.out | 15 + tests/qemu-iotests/002 | 72 + tests/qemu-iotests/002.out | 23 + tests/qemu-iotests/003 | 78 + tests/qemu-iotests/003.out | 23 + tests/qemu-iotests/004 | 104 + tests/qemu-iotests/004.out | 41 + tests/qemu-iotests/005 | 73 + tests/qemu-iotests/005.out | 13 + tests/qemu-iotests/006 | 54 + tests/qemu-iotests/006.out | 6 + tests/qemu-iotests/007 | 67 + tests/qemu-iotests/007.out | 18 + tests/qemu-iotests/008 | 65 + tests/qemu-iotests/008.out | 15 + tests/qemu-iotests/009 | 69 + tests/qemu-iotests/009.out | 18 + tests/qemu-iotests/010 | 71 + tests/qemu-iotests/010.out | 22 + tests/qemu-iotests/011 | 75 + tests/qemu-iotests/011.out | 50 + tests/qemu-iotests/012 | 62 + tests/qemu-iotests/012.out | 9 + tests/qemu-iotests/013 | 98 + tests/qemu-iotests/013.out |43983 ++++++++++++++++ tests/qemu-iotests/014 | 77 + tests/qemu-iotests/014.out |64074 ++++++++++++++++++++++++ tests/qemu-iotests/015 | 85 + tests/qemu-iotests/015.out | 20 + tests/qemu-iotests/016 | 70 + tests/qemu-iotests/016.out | 23 + tests/qemu-iotests/017 | 101 + tests/qemu-iotests/017.out | 1077 + tests/qemu-iotests/018 | 104 + tests/qemu-iotests/018.out | 1077 + tests/qemu-iotests/019 | 129 + tests/qemu-iotests/019.out | 1628 + tests/qemu-iotests/020 | 106 + tests/qemu-iotests/020.out | 1078 + tests/qemu-iotests/021 | 63 + tests/qemu-iotests/021.out | 93 + tests/qemu-iotests/022 | 67 + tests/qemu-iotests/022.out | 8801 ++++ tests/qemu-iotests/023 | 120 + tests/qemu-iotests/023.out |25706 ++++++++++ tests/qemu-iotests/024 | 125 + tests/qemu-iotests/024.out | 144 + tests/qemu-iotests/025 | 78 + tests/qemu-iotests/025.out | 27 + tests/qemu-iotests/026 | 199 + tests/qemu-iotests/026.out | 618 + tests/qemu-iotests/027 | 78 + tests/qemu-iotests/027.out | 23 + tests/qemu-iotests/028 | 107 + tests/qemu-iotests/028.out | 469 + tests/qemu-iotests/029 | 65 + tests/qemu-iotests/029.out | 10 + tests/qemu-iotests/030 | 530 + tests/qemu-iotests/030.out | 5 + tests/qemu-iotests/031 | 80 + tests/qemu-iotests/031.out | 204 + tests/qemu-iotests/032 | 69 + tests/qemu-iotests/032.out | 78 + tests/qemu-iotests/033 | 73 + tests/qemu-iotests/033.out | 29 + tests/qemu-iotests/034 | 113 + tests/qemu-iotests/034.out | 81 + tests/qemu-iotests/035 | 72 + tests/qemu-iotests/035.out | 392 + tests/qemu-iotests/036 | 68 + tests/qemu-iotests/036.out | 52 + tests/qemu-iotests/037 | 119 + tests/qemu-iotests/037.out | 645 + tests/qemu-iotests/038 | 133 + tests/qemu-iotests/038.out | 909 + tests/qemu-iotests/039 | 137 + tests/qemu-iotests/039.out | 59 + tests/qemu-iotests/040 | 280 + tests/qemu-iotests/040.out | 5 + tests/qemu-iotests/041 | 615 + tests/qemu-iotests/041.out | 5 + tests/qemu-iotests/042 | 78 + tests/qemu-iotests/042.out | 15 + tests/qemu-iotests/043 | 95 + tests/qemu-iotests/043.out | 66 + tests/qemu-iotests/044 | 117 + tests/qemu-iotests/044.out | 6 + tests/qemu-iotests/COPYING | 339 + tests/qemu-iotests/Makefile | 9 + tests/qemu-iotests/README | 20 + tests/qemu-iotests/check | 281 + tests/qemu-iotests/common | 365 + tests/qemu-iotests/common.config | 147 + tests/qemu-iotests/common.filter | 156 + tests/qemu-iotests/common.pattern | 140 + tests/qemu-iotests/common.rc | 399 + tests/qemu-iotests/group | 53 + tests/qemu-iotests/iotests.py | 189 + tests/qemu-iotests/qcow2.py | 241 + tests/qemu-iotests/qed.py | 235 + tests/qruncom.c | 284 - tests/rtc-test.c | 353 + tests/runcom.c | 192 - tests/sha1.c | 240 - tests/tcg/Makefile | 158 + tests/tcg/alpha/Makefile | 35 + tests/tcg/alpha/crt.s | 26 + tests/tcg/alpha/hello-alpha.c | 5 + tests/tcg/alpha/test-cond.c | 87 + tests/tcg/alpha/test-ovf.c | 29 + tests/tcg/cris/.gdbinit | 11 + tests/tcg/cris/Makefile | 155 + tests/tcg/cris/README | 1 + tests/tcg/cris/check_abs.c | 40 + tests/tcg/cris/check_addc.c | 58 + tests/tcg/cris/check_addcm.c | 85 + tests/tcg/cris/check_addi.s | 57 + tests/tcg/cris/check_addiv32.s | 62 + tests/tcg/cris/check_addm.s | 96 + tests/tcg/cris/check_addo.c | 125 + tests/tcg/cris/check_addoq.c | 44 + tests/tcg/cris/check_addq.s | 47 + tests/tcg/cris/check_addr.s | 96 + tests/tcg/cris/check_addxc.s | 91 + tests/tcg/cris/check_addxm.s | 106 + tests/tcg/cris/check_addxr.s | 96 + tests/tcg/cris/check_andc.s | 80 + tests/tcg/cris/check_andm.s | 90 + tests/tcg/cris/check_andq.s | 46 + tests/tcg/cris/check_andr.s | 95 + tests/tcg/cris/check_asr.s | 230 + tests/tcg/cris/check_ba.s | 93 + tests/tcg/cris/check_bas.s | 102 + tests/tcg/cris/check_bcc.s | 197 + tests/tcg/cris/check_bound.c | 142 + tests/tcg/cris/check_boundc.s | 101 + tests/tcg/cris/check_boundr.s | 125 + tests/tcg/cris/check_btst.s | 96 + tests/tcg/cris/check_clearfv32.s | 19 + tests/tcg/cris/check_clrjmp1.s | 36 + tests/tcg/cris/check_cmp-2.s | 15 + tests/tcg/cris/check_cmpc.s | 86 + tests/tcg/cris/check_cmpm.s | 96 + tests/tcg/cris/check_cmpq.s | 75 + tests/tcg/cris/check_cmpr.s | 102 + tests/tcg/cris/check_cmpxc.s | 92 + tests/tcg/cris/check_cmpxm.s | 106 + tests/tcg/cris/check_dstep.s | 42 + tests/tcg/cris/check_ftag.c | 37 + tests/tcg/cris/check_gcctorture_pr28634-1.c | 15 + tests/tcg/cris/check_gcctorture_pr28634.c | 15 + tests/tcg/cris/check_glibc_kernelversion.c | 116 + tests/tcg/cris/check_hello.c | 7 + tests/tcg/cris/check_int64.c | 47 + tests/tcg/cris/check_jsr.s | 85 + tests/tcg/cris/check_lapc.s | 78 + tests/tcg/cris/check_lsl.s | 217 + tests/tcg/cris/check_lsr.s | 218 + tests/tcg/cris/check_lz.c | 49 + tests/tcg/cris/check_mapbrk.c | 39 + tests/tcg/cris/check_mcp.s | 49 + tests/tcg/cris/check_mmap1.c | 48 + tests/tcg/cris/check_mmap2.c | 48 + tests/tcg/cris/check_mmap3.c | 33 + tests/tcg/cris/check_movdelsr1.s | 33 + tests/tcg/cris/check_movecr.s | 37 + tests/tcg/cris/check_movei.s | 50 + tests/tcg/cris/check_movemr.s | 78 + tests/tcg/cris/check_movemrv32.s | 96 + tests/tcg/cris/check_moveq.c | 51 + tests/tcg/cris/check_mover.s | 28 + tests/tcg/cris/check_moverm.s | 45 + tests/tcg/cris/check_movmp.s | 131 + tests/tcg/cris/check_movpmv32.s | 35 + tests/tcg/cris/check_movpr.s | 28 + tests/tcg/cris/check_movprv32.s | 21 + tests/tcg/cris/check_movscr.s | 29 + tests/tcg/cris/check_movsm.s | 44 + tests/tcg/cris/check_movsr.s | 46 + tests/tcg/cris/check_movucr.s | 33 + tests/tcg/cris/check_movum.s | 40 + tests/tcg/cris/check_movur.s | 45 + tests/tcg/cris/check_mulv32.s | 51 + tests/tcg/cris/check_mulx.s | 246 + tests/tcg/cris/check_neg.s | 104 + tests/tcg/cris/check_not.s | 31 + tests/tcg/cris/check_openpf1.c | 38 + tests/tcg/cris/check_openpf2.c | 16 + tests/tcg/cris/check_openpf3.c | 49 + tests/tcg/cris/check_openpf4.c | 5 + tests/tcg/cris/check_openpf5.c | 56 + tests/tcg/cris/check_orc.s | 71 + tests/tcg/cris/check_orm.s | 75 + tests/tcg/cris/check_orq.s | 41 + tests/tcg/cris/check_orr.s | 84 + tests/tcg/cris/check_ret.s | 25 + tests/tcg/cris/check_scc.s | 95 + tests/tcg/cris/check_settls1.c | 45 + tests/tcg/cris/check_sigalrm.c | 26 + tests/tcg/cris/check_stat1.c | 16 + tests/tcg/cris/check_stat2.c | 20 + tests/tcg/cris/check_stat3.c | 25 + tests/tcg/cris/check_stat4.c | 27 + tests/tcg/cris/check_subc.s | 87 + tests/tcg/cris/check_subm.s | 96 + tests/tcg/cris/check_subq.s | 52 + tests/tcg/cris/check_subr.s | 102 + tests/tcg/cris/check_swap.c | 76 + tests/tcg/cris/check_time1.c | 46 + tests/tcg/cris/check_time2.c | 18 + tests/tcg/cris/check_xarith.s | 72 + tests/tcg/cris/crisutils.h | 71 + tests/tcg/cris/crt.s | 13 + tests/tcg/cris/sys.c | 51 + tests/tcg/cris/sys.h | 16 + tests/tcg/cris/testutils.inc | 117 + tests/tcg/hello-arm.c | 113 + tests/tcg/hello-i386.c | 27 + tests/tcg/hello-mips.c | 64 + tests/tcg/linux-test.c | 539 + tests/tcg/lm32/Makefile | 105 + tests/tcg/lm32/crt.S | 84 + tests/tcg/lm32/linker.ld | 55 + tests/tcg/lm32/macros.inc | 79 + tests/tcg/lm32/test_add.S | 75 + tests/tcg/lm32/test_addi.S | 56 + tests/tcg/lm32/test_and.S | 45 + tests/tcg/lm32/test_andhi.S | 35 + tests/tcg/lm32/test_andi.S | 35 + tests/tcg/lm32/test_b.S | 13 + tests/tcg/lm32/test_be.S | 48 + tests/tcg/lm32/test_bg.S | 78 + tests/tcg/lm32/test_bge.S | 78 + tests/tcg/lm32/test_bgeu.S | 78 + tests/tcg/lm32/test_bgu.S | 78 + tests/tcg/lm32/test_bi.S | 23 + tests/tcg/lm32/test_bne.S | 48 + tests/tcg/lm32/test_break.S | 20 + tests/tcg/lm32/test_bret.S | 38 + tests/tcg/lm32/test_call.S | 16 + tests/tcg/lm32/test_calli.S | 15 + tests/tcg/lm32/test_cmpe.S | 40 + tests/tcg/lm32/test_cmpei.S | 35 + tests/tcg/lm32/test_cmpg.S | 64 + tests/tcg/lm32/test_cmpge.S | 64 + tests/tcg/lm32/test_cmpgei.S | 55 + tests/tcg/lm32/test_cmpgeu.S | 64 + tests/tcg/lm32/test_cmpgeui.S | 55 + tests/tcg/lm32/test_cmpgi.S | 55 + tests/tcg/lm32/test_cmpgu.S | 64 + tests/tcg/lm32/test_cmpgui.S | 55 + tests/tcg/lm32/test_cmpne.S | 40 + tests/tcg/lm32/test_cmpnei.S | 35 + tests/tcg/lm32/test_divu.S | 29 + tests/tcg/lm32/test_eret.S | 38 + tests/tcg/lm32/test_lb.S | 45 + tests/tcg/lm32/test_lbu.S | 45 + tests/tcg/lm32/test_lh.S | 45 + tests/tcg/lm32/test_lhu.S | 45 + tests/tcg/lm32/test_lw.S | 30 + tests/tcg/lm32/test_modu.S | 35 + tests/tcg/lm32/test_mul.S | 70 + tests/tcg/lm32/test_muli.S | 45 + tests/tcg/lm32/test_nor.S | 51 + tests/tcg/lm32/test_nori.S | 35 + tests/tcg/lm32/test_or.S | 51 + tests/tcg/lm32/test_orhi.S | 35 + tests/tcg/lm32/test_ori.S | 35 + tests/tcg/lm32/test_ret.S | 14 + tests/tcg/lm32/test_sb.S | 30 + tests/tcg/lm32/test_scall.S | 20 + tests/tcg/lm32/test_sextb.S | 20 + tests/tcg/lm32/test_sexth.S | 20 + tests/tcg/lm32/test_sh.S | 30 + tests/tcg/lm32/test_sl.S | 45 + tests/tcg/lm32/test_sli.S | 30 + tests/tcg/lm32/test_sr.S | 57 + tests/tcg/lm32/test_sri.S | 40 + tests/tcg/lm32/test_sru.S | 57 + tests/tcg/lm32/test_srui.S | 40 + tests/tcg/lm32/test_sub.S | 75 + tests/tcg/lm32/test_sw.S | 35 + tests/tcg/lm32/test_xnor.S | 51 + tests/tcg/lm32/test_xnori.S | 35 + tests/tcg/lm32/test_xor.S | 51 + tests/tcg/lm32/test_xori.S | 35 + tests/tcg/mips/mips32-dsp/Makefile | 136 + tests/tcg/mips/mips32-dsp/absq_s_ph.c | 31 + tests/tcg/mips/mips32-dsp/absq_s_w.c | 37 + tests/tcg/mips/mips32-dsp/addq_ph.c | 46 + tests/tcg/mips/mips32-dsp/addq_s_ph.c | 69 + tests/tcg/mips/mips32-dsp/addq_s_w.c | 44 + tests/tcg/mips/mips32-dsp/addsc.c | 33 + tests/tcg/mips/mips32-dsp/addu_qb.c | 35 + tests/tcg/mips/mips32-dsp/addu_s_qb.c | 35 + tests/tcg/mips/mips32-dsp/addwc.c | 49 + tests/tcg/mips/mips32-dsp/bitrev.c | 20 + tests/tcg/mips/mips32-dsp/bposge32.c | 44 + tests/tcg/mips/mips32-dsp/cmp_eq_ph.c | 35 + tests/tcg/mips/mips32-dsp/cmp_le_ph.c | 35 + tests/tcg/mips/mips32-dsp/cmp_lt_ph.c | 35 + tests/tcg/mips/mips32-dsp/cmpgu_eq_qb.c | 31 + tests/tcg/mips/mips32-dsp/cmpgu_le_qb.c | 31 + tests/tcg/mips/mips32-dsp/cmpgu_lt_qb.c | 31 + tests/tcg/mips/mips32-dsp/cmpu_eq_qb.c | 35 + tests/tcg/mips/mips32-dsp/cmpu_le_qb.c | 35 + tests/tcg/mips/mips32-dsp/cmpu_lt_qb.c | 35 + tests/tcg/mips/mips32-dsp/dpaq_s_w_ph.c | 31 + tests/tcg/mips/mips32-dsp/dpaq_sa_l_w.c | 77 + tests/tcg/mips/mips32-dsp/dpau_h_qbl.c | 27 + tests/tcg/mips/mips32-dsp/dpau_h_qbr.c | 27 + tests/tcg/mips/mips32-dsp/dpsq_s_w_ph.c | 45 + tests/tcg/mips/mips32-dsp/dpsq_sa_l_w.c | 55 + tests/tcg/mips/mips32-dsp/dpsu_h_qbl.c | 27 + tests/tcg/mips/mips32-dsp/dpsu_h_qbr.c | 27 + tests/tcg/mips/mips32-dsp/extp.c | 44 + tests/tcg/mips/mips32-dsp/extpdp.c | 46 + tests/tcg/mips/mips32-dsp/extpdpv.c | 47 + tests/tcg/mips/mips32-dsp/extpv.c | 45 + tests/tcg/mips/mips32-dsp/extr_r_w.c | 48 + tests/tcg/mips/mips32-dsp/extr_rs_w.c | 48 + tests/tcg/mips/mips32-dsp/extr_s_h.c | 63 + tests/tcg/mips/mips32-dsp/extr_w.c | 48 + tests/tcg/mips/mips32-dsp/extrv_r_w.c | 54 + tests/tcg/mips/mips32-dsp/extrv_rs_w.c | 52 + tests/tcg/mips/mips32-dsp/extrv_s_h.c | 71 + tests/tcg/mips/mips32-dsp/extrv_w.c | 54 + tests/tcg/mips/mips32-dsp/insv.c | 23 + tests/tcg/mips/mips32-dsp/lbux.c | 25 + tests/tcg/mips/mips32-dsp/lhx.c | 25 + tests/tcg/mips/mips32-dsp/lwx.c | 25 + tests/tcg/mips/mips32-dsp/madd.c | 31 + tests/tcg/mips/mips32-dsp/maddu.c | 31 + tests/tcg/mips/mips32-dsp/main.c | 6 + tests/tcg/mips/mips32-dsp/maq_s_w_phl.c | 55 + tests/tcg/mips/mips32-dsp/maq_s_w_phr.c | 55 + tests/tcg/mips/mips32-dsp/maq_sa_w_phl.c | 55 + tests/tcg/mips/mips32-dsp/maq_sa_w_phr.c | 55 + tests/tcg/mips/mips32-dsp/mfhi.c | 21 + tests/tcg/mips/mips32-dsp/mflo.c | 21 + tests/tcg/mips/mips32-dsp/modsub.c | 30 + tests/tcg/mips/mips32-dsp/msub.c | 30 + tests/tcg/mips/mips32-dsp/msubu.c | 30 + tests/tcg/mips/mips32-dsp/mthi.c | 21 + tests/tcg/mips/mips32-dsp/mthlip.c | 58 + tests/tcg/mips/mips32-dsp/mtlo.c | 21 + tests/tcg/mips/mips32-dsp/muleq_s_w_phl.c | 41 + tests/tcg/mips/mips32-dsp/muleq_s_w_phr.c | 40 + tests/tcg/mips/mips32-dsp/muleu_s_ph_qbl.c | 25 + tests/tcg/mips/mips32-dsp/muleu_s_ph_qbr.c | 25 + tests/tcg/mips/mips32-dsp/mulq_rs_ph.c | 25 + tests/tcg/mips/mips32-dsp/mult.c | 24 + tests/tcg/mips/mips32-dsp/multu.c | 24 + tests/tcg/mips/mips32-dsp/packrl_ph.c | 21 + tests/tcg/mips/mips32-dsp/pick_ph.c | 49 + tests/tcg/mips/mips32-dsp/pick_qb.c | 36 + tests/tcg/mips/mips32-dsp/preceq_w_phl.c | 20 + tests/tcg/mips/mips32-dsp/preceq_w_phr.c | 20 + tests/tcg/mips/mips32-dsp/precequ_ph_qbl.c | 20 + tests/tcg/mips/mips32-dsp/precequ_ph_qbla.c | 20 + tests/tcg/mips/mips32-dsp/precequ_ph_qbr.c | 20 + tests/tcg/mips/mips32-dsp/precequ_ph_qbra.c | 20 + tests/tcg/mips/mips32-dsp/preceu_ph_qbl.c | 20 + tests/tcg/mips/mips32-dsp/preceu_ph_qbla.c | 20 + tests/tcg/mips/mips32-dsp/preceu_ph_qbr.c | 20 + tests/tcg/mips/mips32-dsp/preceu_ph_qbra.c | 20 + tests/tcg/mips/mips32-dsp/precrq_ph_w.c | 21 + tests/tcg/mips/mips32-dsp/precrq_qb_ph.c | 21 + tests/tcg/mips/mips32-dsp/precrq_rs_ph_w.c | 35 + tests/tcg/mips/mips32-dsp/precrqu_s_qb_ph.c | 24 + tests/tcg/mips/mips32-dsp/raddu_w_qb.c | 20 + tests/tcg/mips/mips32-dsp/rddsp.c | 54 + tests/tcg/mips/mips32-dsp/repl_ph.c | 23 + tests/tcg/mips/mips32-dsp/repl_qb.c | 16 + tests/tcg/mips/mips32-dsp/replv_ph.c | 19 + tests/tcg/mips/mips32-dsp/replv_qb.c | 19 + tests/tcg/mips/mips32-dsp/shilo.c | 27 + tests/tcg/mips/mips32-dsp/shilov.c | 29 + tests/tcg/mips/mips32-dsp/shll_ph.c | 24 + tests/tcg/mips/mips32-dsp/shll_qb.c | 36 + tests/tcg/mips/mips32-dsp/shll_s_ph.c | 24 + tests/tcg/mips/mips32-dsp/shll_s_w.c | 52 + tests/tcg/mips/mips32-dsp/shllv_ph.c | 40 + tests/tcg/mips/mips32-dsp/shllv_qb.c | 38 + tests/tcg/mips/mips32-dsp/shllv_s_ph.c | 40 + tests/tcg/mips/mips32-dsp/shllv_s_w.c | 40 + tests/tcg/mips/mips32-dsp/shra_ph.c | 30 + tests/tcg/mips/mips32-dsp/shra_r_ph.c | 30 + tests/tcg/mips/mips32-dsp/shra_r_w.c | 30 + tests/tcg/mips/mips32-dsp/shrav_ph.c | 32 + tests/tcg/mips/mips32-dsp/shrav_r_ph.c | 32 + tests/tcg/mips/mips32-dsp/shrav_r_w.c | 32 + tests/tcg/mips/mips32-dsp/shrl_qb.c | 31 + tests/tcg/mips/mips32-dsp/shrlv_qb.c | 32 + tests/tcg/mips/mips32-dsp/subq_ph.c | 40 + tests/tcg/mips/mips32-dsp/subq_s_ph.c | 40 + tests/tcg/mips/mips32-dsp/subq_s_w.c | 58 + tests/tcg/mips/mips32-dsp/subu_qb.c | 25 + tests/tcg/mips/mips32-dsp/subu_s_qb.c | 25 + tests/tcg/mips/mips32-dsp/wrdsp.c | 54 + tests/tcg/mips/mips32-dspr2/Makefile | 71 + tests/tcg/mips/mips32-dspr2/absq_s_qb.c | 35 + tests/tcg/mips/mips32-dspr2/addqh_ph.c | 30 + tests/tcg/mips/mips32-dspr2/addqh_r_ph.c | 30 + tests/tcg/mips/mips32-dspr2/addqh_r_w.c | 34 + tests/tcg/mips/mips32-dspr2/addqh_w.c | 34 + tests/tcg/mips/mips32-dspr2/addu_ph.c | 33 + tests/tcg/mips/mips32-dspr2/addu_s_ph.c | 33 + tests/tcg/mips/mips32-dspr2/adduh_qb.c | 30 + tests/tcg/mips/mips32-dspr2/adduh_r_qb.c | 30 + tests/tcg/mips/mips32-dspr2/append.c | 30 + tests/tcg/mips/mips32-dspr2/balign.c | 30 + tests/tcg/mips/mips32-dspr2/cmpgdu_eq_qb.c | 37 + tests/tcg/mips/mips32-dspr2/cmpgdu_le_qb.c | 37 + tests/tcg/mips/mips32-dspr2/cmpgdu_lt_qb.c | 37 + tests/tcg/mips/mips32-dspr2/dpa_w_ph.c | 44 + tests/tcg/mips/mips32-dspr2/dpaqx_s_w_ph.c | 79 + tests/tcg/mips/mips32-dspr2/dpaqx_sa_w_ph.c | 53 + tests/tcg/mips/mips32-dspr2/dpax_w_ph.c | 27 + tests/tcg/mips/mips32-dspr2/dps_w_ph.c | 27 + tests/tcg/mips/mips32-dspr2/dpsqx_s_w_ph.c | 54 + tests/tcg/mips/mips32-dspr2/dpsqx_sa_w_ph.c | 53 + tests/tcg/mips/mips32-dspr2/dpsx_w_ph.c | 27 + tests/tcg/mips/mips32-dspr2/mul_ph.c | 47 + tests/tcg/mips/mips32-dspr2/mul_s_ph.c | 62 + tests/tcg/mips/mips32-dspr2/mulq_rs_w.c | 36 + tests/tcg/mips/mips32-dspr2/mulq_s_ph.c | 25 + tests/tcg/mips/mips32-dspr2/mulq_s_w.c | 36 + tests/tcg/mips/mips32-dspr2/mulsa_w_ph.c | 29 + tests/tcg/mips/mips32-dspr2/mulsaq_s_w_ph.c | 29 + tests/tcg/mips/mips32-dspr2/precr_qb_ph.c | 21 + tests/tcg/mips/mips32-dspr2/precr_sra_ph_w.c | 32 + tests/tcg/mips/mips32-dspr2/precr_sra_r_ph_w.c | 32 + tests/tcg/mips/mips32-dspr2/prepend.c | 30 + tests/tcg/mips/mips32-dspr2/shra_qb.c | 30 + tests/tcg/mips/mips32-dspr2/shra_r_qb.c | 30 + tests/tcg/mips/mips32-dspr2/shrav_qb.c | 32 + tests/tcg/mips/mips32-dspr2/shrav_r_qb.c | 32 + tests/tcg/mips/mips32-dspr2/shrl_ph.c | 20 + tests/tcg/mips/mips32-dspr2/shrlv_ph.c | 21 + tests/tcg/mips/mips32-dspr2/subqh_ph.c | 21 + tests/tcg/mips/mips32-dspr2/subqh_r_ph.c | 21 + tests/tcg/mips/mips32-dspr2/subqh_r_w.c | 21 + tests/tcg/mips/mips32-dspr2/subqh_w.c | 21 + tests/tcg/mips/mips32-dspr2/subu_ph.c | 40 + tests/tcg/mips/mips32-dspr2/subu_s_ph.c | 25 + tests/tcg/mips/mips32-dspr2/subuh_qb.c | 21 + tests/tcg/mips/mips32-dspr2/subuh_r_qb.c | 32 + tests/tcg/mips/mips64-dsp/Makefile | 306 + tests/tcg/mips/mips64-dsp/absq_s_ob.c | 63 + tests/tcg/mips/mips64-dsp/absq_s_ph.c | 37 + tests/tcg/mips/mips64-dsp/absq_s_pw.c | 66 + tests/tcg/mips/mips64-dsp/absq_s_qh.c | 40 + tests/tcg/mips/mips64-dsp/absq_s_w.c | 48 + tests/tcg/mips/mips64-dsp/addq_ph.c | 57 + tests/tcg/mips/mips64-dsp/addq_pw.c | 46 + tests/tcg/mips/mips64-dsp/addq_qh.c | 28 + tests/tcg/mips/mips64-dsp/addq_s_ph.c | 84 + tests/tcg/mips/mips64-dsp/addq_s_pw.c | 45 + tests/tcg/mips/mips64-dsp/addq_s_qh.c | 26 + tests/tcg/mips/mips64-dsp/addq_s_w.c | 48 + tests/tcg/mips/mips64-dsp/addsc.c | 39 + tests/tcg/mips/mips64-dsp/addu_ob.c | 28 + tests/tcg/mips/mips64-dsp/addu_qb.c | 40 + tests/tcg/mips/mips64-dsp/addu_s_ob.c | 27 + tests/tcg/mips/mips64-dsp/addu_s_qb.c | 40 + tests/tcg/mips/mips64-dsp/addwc.c | 59 + tests/tcg/mips/mips64-dsp/bitrev.c | 23 + tests/tcg/mips/mips64-dsp/bposge32.c | 50 + tests/tcg/mips/mips64-dsp/bposge64.c | 50 + tests/tcg/mips/mips64-dsp/cmp_eq_ph.c | 42 + tests/tcg/mips/mips64-dsp/cmp_eq_pw.c | 46 + tests/tcg/mips/mips64-dsp/cmp_eq_qh.c | 46 + tests/tcg/mips/mips64-dsp/cmp_le_ph.c | 40 + tests/tcg/mips/mips64-dsp/cmp_le_pw.c | 46 + tests/tcg/mips/mips64-dsp/cmp_le_qh.c | 46 + tests/tcg/mips/mips64-dsp/cmp_lt_ph.c | 41 + tests/tcg/mips/mips64-dsp/cmp_lt_pw.c | 46 + tests/tcg/mips/mips64-dsp/cmp_lt_qh.c | 46 + tests/tcg/mips/mips64-dsp/cmpgu_eq_ob.c | 40 + tests/tcg/mips/mips64-dsp/cmpgu_eq_qb.c | 38 + tests/tcg/mips/mips64-dsp/cmpgu_le_ob.c | 40 + tests/tcg/mips/mips64-dsp/cmpgu_le_qb.c | 37 + tests/tcg/mips/mips64-dsp/cmpgu_lt_ob.c | 40 + tests/tcg/mips/mips64-dsp/cmpgu_lt_qb.c | 38 + tests/tcg/mips/mips64-dsp/cmpu_eq_ob.c | 46 + tests/tcg/mips/mips64-dsp/cmpu_eq_qb.c | 42 + tests/tcg/mips/mips64-dsp/cmpu_le_ob.c | 44 + tests/tcg/mips/mips64-dsp/cmpu_le_qb.c | 41 + tests/tcg/mips/mips64-dsp/cmpu_lt_ob.c | 44 + tests/tcg/mips/mips64-dsp/cmpu_lt_qb.c | 42 + tests/tcg/mips/mips64-dsp/dappend.c | 37 + tests/tcg/mips/mips64-dsp/dextp.c | 54 + tests/tcg/mips/mips64-dsp/dextpdp.c | 59 + tests/tcg/mips/mips64-dsp/dextpdpv.c | 63 + tests/tcg/mips/mips64-dsp/dextpv.c | 58 + tests/tcg/mips/mips64-dsp/dextr_l.c | 44 + tests/tcg/mips/mips64-dsp/dextr_r_l.c | 54 + tests/tcg/mips/mips64-dsp/dextr_r_w.c | 54 + tests/tcg/mips/mips64-dsp/dextr_rs_l.c | 52 + tests/tcg/mips/mips64-dsp/dextr_rs_w.c | 52 + tests/tcg/mips/mips64-dsp/dextr_s_h.c | 73 + tests/tcg/mips/mips64-dsp/dextr_w.c | 44 + tests/tcg/mips/mips64-dsp/dextrv_l.c | 46 + tests/tcg/mips/mips64-dsp/dextrv_r_l.c | 56 + tests/tcg/mips/mips64-dsp/dextrv_r_w.c | 56 + tests/tcg/mips/mips64-dsp/dextrv_rs_l.c | 54 + tests/tcg/mips/mips64-dsp/dextrv_rs_w.c | 54 + tests/tcg/mips/mips64-dsp/dextrv_s_h.c | 32 + tests/tcg/mips/mips64-dsp/dextrv_w.c | 46 + tests/tcg/mips/mips64-dsp/dinsv.c | 26 + tests/tcg/mips/mips64-dsp/dmadd.c | 57 + tests/tcg/mips/mips64-dsp/dmaddu.c | 56 + tests/tcg/mips/mips64-dsp/dmsub.c | 59 + tests/tcg/mips/mips64-dsp/dmsubu.c | 59 + tests/tcg/mips/mips64-dsp/dmthlip.c | 41 + tests/tcg/mips/mips64-dsp/dpaq_s_w_ph.c | 32 + tests/tcg/mips/mips64-dsp/dpaq_s_w_qh.c | 57 + tests/tcg/mips/mips64-dsp/dpaq_sa_l_pw.c | 88 + tests/tcg/mips/mips64-dsp/dpaq_sa_l_w.c | 82 + tests/tcg/mips/mips64-dsp/dpau_h_obl.c | 59 + tests/tcg/mips/mips64-dsp/dpau_h_obr.c | 59 + tests/tcg/mips/mips64-dsp/dpau_h_qbl.c | 29 + tests/tcg/mips/mips64-dsp/dpau_h_qbr.c | 29 + tests/tcg/mips/mips64-dsp/dpsq_s_w_ph.c | 51 + tests/tcg/mips/mips64-dsp/dpsq_s_w_qh.c | 56 + tests/tcg/mips/mips64-dsp/dpsq_sa_l_pw.c | 76 + tests/tcg/mips/mips64-dsp/dpsq_sa_l_w.c | 59 + tests/tcg/mips/mips64-dsp/dpsu_h_obl.c | 32 + tests/tcg/mips/mips64-dsp/dpsu_h_obr.c | 32 + tests/tcg/mips/mips64-dsp/dpsu_h_qbl.c | 29 + tests/tcg/mips/mips64-dsp/dpsu_h_qbr.c | 29 + tests/tcg/mips/mips64-dsp/dshilo.c | 52 + tests/tcg/mips/mips64-dsp/dshilov.c | 54 + tests/tcg/mips/mips64-dsp/extp.c | 50 + tests/tcg/mips/mips64-dsp/extpdp.c | 51 + tests/tcg/mips/mips64-dsp/extpdpv.c | 52 + tests/tcg/mips/mips64-dsp/extpv.c | 51 + tests/tcg/mips/mips64-dsp/extr_r_w.c | 53 + tests/tcg/mips/mips64-dsp/extr_rs_w.c | 53 + tests/tcg/mips/mips64-dsp/extr_s_h.c | 71 + tests/tcg/mips/mips64-dsp/extr_w.c | 53 + tests/tcg/mips/mips64-dsp/extrv_r_w.c | 59 + tests/tcg/mips/mips64-dsp/extrv_rs_w.c | 59 + tests/tcg/mips/mips64-dsp/extrv_s_h.c | 79 + tests/tcg/mips/mips64-dsp/extrv_w.c | 59 + tests/tcg/mips/mips64-dsp/head.S | 16 + tests/tcg/mips/mips64-dsp/insv.c | 26 + tests/tcg/mips/mips64-dsp/io.h | 22 + tests/tcg/mips/mips64-dsp/lbux.c | 27 + tests/tcg/mips/mips64-dsp/ldx.c | 27 + tests/tcg/mips/mips64-dsp/lhx.c | 27 + tests/tcg/mips/mips64-dsp/lwx.c | 27 + tests/tcg/mips/mips64-dsp/madd.c | 33 + tests/tcg/mips/mips64-dsp/maddu.c | 33 + tests/tcg/mips/mips64-dsp/maq_s_l_pwl.c | 56 + tests/tcg/mips/mips64-dsp/maq_s_l_pwr.c | 56 + tests/tcg/mips/mips64-dsp/maq_s_w_phl.c | 60 + tests/tcg/mips/mips64-dsp/maq_s_w_phr.c | 60 + tests/tcg/mips/mips64-dsp/maq_s_w_qhll.c | 62 + tests/tcg/mips/mips64-dsp/maq_s_w_qhlr.c | 62 + tests/tcg/mips/mips64-dsp/maq_s_w_qhrl.c | 63 + tests/tcg/mips/mips64-dsp/maq_s_w_qhrr.c | 63 + tests/tcg/mips/mips64-dsp/maq_sa_w_phl.c | 60 + tests/tcg/mips/mips64-dsp/maq_sa_w_phr.c | 60 + tests/tcg/mips/mips64-dsp/maq_sa_w_qhll.c | 62 + tests/tcg/mips/mips64-dsp/maq_sa_w_qhlr.c | 64 + tests/tcg/mips/mips64-dsp/maq_sa_w_qhrl.c | 64 + tests/tcg/mips/mips64-dsp/maq_sa_w_qhrr.c | 64 + tests/tcg/mips/mips64-dsp/mfhi.c | 24 + tests/tcg/mips/mips64-dsp/mflo.c | 24 + tests/tcg/mips/mips64-dsp/mips_boot.lds | 31 + tests/tcg/mips/mips64-dsp/modsub.c | 37 + tests/tcg/mips/mips64-dsp/msub.c | 32 + tests/tcg/mips/mips64-dsp/msubu.c | 32 + tests/tcg/mips/mips64-dsp/mthi.c | 24 + tests/tcg/mips/mips64-dsp/mthlip.c | 61 + tests/tcg/mips/mips64-dsp/mtlo.c | 22 + tests/tcg/mips/mips64-dsp/muleq_s_pw_qhl.c | 56 + tests/tcg/mips/mips64-dsp/muleq_s_pw_qhr.c | 57 + tests/tcg/mips/mips64-dsp/muleq_s_w_phl.c | 46 + tests/tcg/mips/mips64-dsp/muleq_s_w_phr.c | 45 + tests/tcg/mips/mips64-dsp/muleu_s_ph_qbl.c | 27 + tests/tcg/mips/mips64-dsp/muleu_s_ph_qbr.c | 27 + tests/tcg/mips/mips64-dsp/muleu_s_qh_obl.c | 30 + tests/tcg/mips/mips64-dsp/muleu_s_qh_obr.c | 31 + tests/tcg/mips/mips64-dsp/mulq_rs_ph.c | 27 + tests/tcg/mips/mips64-dsp/mulq_rs_qh.c | 33 + tests/tcg/mips/mips64-dsp/mulsaq_s_l_pw.c | 59 + tests/tcg/mips/mips64-dsp/mulsaq_s_w_qh.c | 57 + tests/tcg/mips/mips64-dsp/mult.c | 26 + tests/tcg/mips/mips64-dsp/multu.c | 26 + tests/tcg/mips/mips64-dsp/packrl_ph.c | 24 + tests/tcg/mips/mips64-dsp/packrl_pw.c | 24 + tests/tcg/mips/mips64-dsp/pick_ob.c | 66 + tests/tcg/mips/mips64-dsp/pick_ph.c | 60 + tests/tcg/mips/mips64-dsp/pick_pw.c | 48 + tests/tcg/mips/mips64-dsp/pick_qb.c | 43 + tests/tcg/mips/mips64-dsp/pick_qh.c | 48 + tests/tcg/mips/mips64-dsp/preceq_l_pwl.c | 24 + tests/tcg/mips/mips64-dsp/preceq_l_pwr.c | 24 + tests/tcg/mips/mips64-dsp/preceq_pw_qhl.c | 21 + tests/tcg/mips/mips64-dsp/preceq_pw_qhla.c | 23 + tests/tcg/mips/mips64-dsp/preceq_pw_qhr.c | 21 + tests/tcg/mips/mips64-dsp/preceq_pw_qhra.c | 23 + tests/tcg/mips/mips64-dsp/preceq_w_phl.c | 23 + tests/tcg/mips/mips64-dsp/preceq_w_phr.c | 23 + tests/tcg/mips/mips64-dsp/precequ_ph_qbl.c | 23 + tests/tcg/mips/mips64-dsp/precequ_ph_qbla.c | 23 + tests/tcg/mips/mips64-dsp/precequ_ph_qbr.c | 23 + tests/tcg/mips/mips64-dsp/precequ_ph_qbra.c | 23 + tests/tcg/mips/mips64-dsp/precequ_qh_obl.c | 22 + tests/tcg/mips/mips64-dsp/precequ_qh_obla.c | 22 + tests/tcg/mips/mips64-dsp/precequ_qh_obr.c | 24 + tests/tcg/mips/mips64-dsp/precequ_qh_obra.c | 24 + tests/tcg/mips/mips64-dsp/preceu_ph_qbl.c | 23 + tests/tcg/mips/mips64-dsp/preceu_ph_qbla.c | 23 + tests/tcg/mips/mips64-dsp/preceu_ph_qbr.c | 23 + tests/tcg/mips/mips64-dsp/preceu_ph_qbra.c | 23 + tests/tcg/mips/mips64-dsp/preceu_qh_obl.c | 22 + tests/tcg/mips/mips64-dsp/preceu_qh_obla.c | 22 + tests/tcg/mips/mips64-dsp/preceu_qh_obr.c | 23 + tests/tcg/mips/mips64-dsp/preceu_qh_obra.c | 23 + tests/tcg/mips/mips64-dsp/precr_ob_qh.c | 25 + tests/tcg/mips/mips64-dsp/precr_sra_qh_pw.c | 40 + tests/tcg/mips/mips64-dsp/precr_sra_r_qh_pw.c | 40 + tests/tcg/mips/mips64-dsp/precrq_ob_qh.c | 25 + tests/tcg/mips/mips64-dsp/precrq_ph_w.c | 24 + tests/tcg/mips/mips64-dsp/precrq_pw_l.c | 25 + tests/tcg/mips/mips64-dsp/precrq_qb_ph.c | 24 + tests/tcg/mips/mips64-dsp/precrq_qh_pw.c | 25 + tests/tcg/mips/mips64-dsp/precrq_rs_ph_w.c | 41 + tests/tcg/mips/mips64-dsp/precrq_rs_qh_pw.c | 43 + tests/tcg/mips/mips64-dsp/precrqu_s_ob_qh.c | 27 + tests/tcg/mips/mips64-dsp/precrqu_s_qb_ph.c | 26 + tests/tcg/mips/mips64-dsp/prependd.c | 37 + tests/tcg/mips/mips64-dsp/prependw.c | 37 + tests/tcg/mips/mips64-dsp/printf.c | 266 + tests/tcg/mips/mips64-dsp/raddu_l_ob.c | 22 + tests/tcg/mips/mips64-dsp/raddu_w_qb.c | 23 + tests/tcg/mips/mips64-dsp/rddsp.c | 53 + tests/tcg/mips/mips64-dsp/repl_ob.c | 21 + tests/tcg/mips/mips64-dsp/repl_ph.c | 30 + tests/tcg/mips/mips64-dsp/repl_pw.c | 34 + tests/tcg/mips/mips64-dsp/repl_qb.c | 19 + tests/tcg/mips/mips64-dsp/repl_qh.c | 34 + tests/tcg/mips/mips64-dsp/replv_ob.c | 23 + tests/tcg/mips/mips64-dsp/replv_ph.c | 22 + tests/tcg/mips/mips64-dsp/replv_pw.c | 23 + tests/tcg/mips/mips64-dsp/replv_qb.c | 22 + tests/tcg/mips/mips64-dsp/shilo.c | 29 + tests/tcg/mips/mips64-dsp/shilov.c | 31 + tests/tcg/mips/mips64-dsp/shll_ob.c | 43 + tests/tcg/mips/mips64-dsp/shll_ph.c | 43 + tests/tcg/mips/mips64-dsp/shll_pw.c | 43 + tests/tcg/mips/mips64-dsp/shll_qb.c | 26 + tests/tcg/mips/mips64-dsp/shll_qh.c | 42 + tests/tcg/mips/mips64-dsp/shll_s_ph.c | 43 + tests/tcg/mips/mips64-dsp/shll_s_pw.c | 43 + tests/tcg/mips/mips64-dsp/shll_s_qh.c | 43 + tests/tcg/mips/mips64-dsp/shll_s_w.c | 26 + tests/tcg/mips/mips64-dsp/shllv_ob.c | 45 + tests/tcg/mips/mips64-dsp/shllv_ph.c | 27 + tests/tcg/mips/mips64-dsp/shllv_pw.c | 45 + tests/tcg/mips/mips64-dsp/shllv_qb.c | 27 + tests/tcg/mips/mips64-dsp/shllv_qh.c | 45 + tests/tcg/mips/mips64-dsp/shllv_s_ph.c | 27 + tests/tcg/mips/mips64-dsp/shllv_s_pw.c | 45 + tests/tcg/mips/mips64-dsp/shllv_s_qh.c | 45 + tests/tcg/mips/mips64-dsp/shllv_s_w.c | 27 + tests/tcg/mips/mips64-dsp/shra_ob.c | 23 + tests/tcg/mips/mips64-dsp/shra_ph.c | 23 + tests/tcg/mips/mips64-dsp/shra_pw.c | 36 + tests/tcg/mips/mips64-dsp/shra_qh.c | 37 + tests/tcg/mips/mips64-dsp/shra_r_ob.c | 22 + tests/tcg/mips/mips64-dsp/shra_r_ph.c | 23 + tests/tcg/mips/mips64-dsp/shra_r_pw.c | 36 + tests/tcg/mips/mips64-dsp/shra_r_qh.c | 37 + tests/tcg/mips/mips64-dsp/shra_r_w.c | 23 + tests/tcg/mips/mips64-dsp/shrav_ph.c | 24 + tests/tcg/mips/mips64-dsp/shrav_pw.c | 38 + tests/tcg/mips/mips64-dsp/shrav_qh.c | 39 + tests/tcg/mips/mips64-dsp/shrav_r_ph.c | 24 + tests/tcg/mips/mips64-dsp/shrav_r_pw.c | 37 + tests/tcg/mips/mips64-dsp/shrav_r_qh.c | 39 + tests/tcg/mips/mips64-dsp/shrav_r_w.c | 24 + tests/tcg/mips/mips64-dsp/shrl_ob.c | 38 + tests/tcg/mips/mips64-dsp/shrl_qb.c | 23 + tests/tcg/mips/mips64-dsp/shrl_qh.c | 22 + tests/tcg/mips/mips64-dsp/shrlv_ob.c | 39 + tests/tcg/mips/mips64-dsp/shrlv_qb.c | 24 + tests/tcg/mips/mips64-dsp/shrlv_qh.c | 23 + tests/tcg/mips/mips64-dsp/subq_ph.c | 27 + tests/tcg/mips/mips64-dsp/subq_pw.c | 44 + tests/tcg/mips/mips64-dsp/subq_qh.c | 26 + tests/tcg/mips/mips64-dsp/subq_s_ph.c | 27 + tests/tcg/mips/mips64-dsp/subq_s_pw.c | 63 + tests/tcg/mips/mips64-dsp/subq_s_qh.c | 61 + tests/tcg/mips/mips64-dsp/subq_s_w.c | 27 + tests/tcg/mips/mips64-dsp/subu_ob.c | 26 + tests/tcg/mips/mips64-dsp/subu_qb.c | 27 + tests/tcg/mips/mips64-dsp/subu_s_ob.c | 26 + tests/tcg/mips/mips64-dsp/subu_s_qb.c | 27 + tests/tcg/mips/mips64-dsp/wrdsp.c | 48 + tests/tcg/mips/mips64-dspr2/.directory | 2 + tests/tcg/mips/mips64-dspr2/Makefile | 116 + tests/tcg/mips/mips64-dspr2/absq_s_qb.c | 42 + tests/tcg/mips/mips64-dspr2/addqh_ph.c | 35 + tests/tcg/mips/mips64-dspr2/addqh_r_ph.c | 35 + tests/tcg/mips/mips64-dspr2/addqh_r_w.c | 38 + tests/tcg/mips/mips64-dspr2/addqh_w.c | 39 + tests/tcg/mips/mips64-dspr2/addu_ph.c | 37 + tests/tcg/mips/mips64-dspr2/addu_qh.c | 43 + tests/tcg/mips/mips64-dspr2/addu_s_ph.c | 37 + tests/tcg/mips/mips64-dspr2/addu_s_qh.c | 43 + tests/tcg/mips/mips64-dspr2/adduh_ob.c | 35 + tests/tcg/mips/mips64-dspr2/adduh_qb.c | 35 + tests/tcg/mips/mips64-dspr2/adduh_r_ob.c | 35 + tests/tcg/mips/mips64-dspr2/adduh_r_qb.c | 35 + tests/tcg/mips/mips64-dspr2/append.c | 35 + tests/tcg/mips/mips64-dspr2/balign.c | 35 + tests/tcg/mips/mips64-dspr2/cmpgdu_eq_ob.c | 44 + tests/tcg/mips/mips64-dspr2/cmpgdu_eq_qb.c | 41 + tests/tcg/mips/mips64-dspr2/cmpgdu_le_ob.c | 44 + tests/tcg/mips/mips64-dspr2/cmpgdu_le_qb.c | 48 + tests/tcg/mips/mips64-dspr2/cmpgdu_lt_ob.c | 44 + tests/tcg/mips/mips64-dspr2/cmpgdu_lt_qb.c | 48 + tests/tcg/mips/mips64-dspr2/dbalign.c | 39 + tests/tcg/mips/mips64-dspr2/dpa_w_ph.c | 47 + tests/tcg/mips/mips64-dspr2/dpa_w_qh.c | 56 + tests/tcg/mips/mips64-dspr2/dpaqx_s_w_ph.c | 97 + tests/tcg/mips/mips64-dspr2/dpaqx_sa_w_ph.c | 54 + tests/tcg/mips/mips64-dspr2/dpax_w_ph.c | 32 + tests/tcg/mips/mips64-dspr2/dps_w_ph.c | 28 + tests/tcg/mips/mips64-dspr2/dps_w_qh.c | 55 + tests/tcg/mips/mips64-dspr2/dpsqx_s_w_ph.c | 55 + tests/tcg/mips/mips64-dspr2/dpsqx_sa_w_ph.c | 53 + tests/tcg/mips/mips64-dspr2/dpsx_w_ph.c | 28 + tests/tcg/mips/mips64-dspr2/head.S | 16 + tests/tcg/mips/mips64-dspr2/io.h | 22 + tests/tcg/mips/mips64-dspr2/mips_boot.lds | 31 + tests/tcg/mips/mips64-dspr2/mul_ph.c | 50 + tests/tcg/mips/mips64-dspr2/mul_s_ph.c | 67 + tests/tcg/mips/mips64-dspr2/mulq_rs_w.c | 40 + tests/tcg/mips/mips64-dspr2/mulq_s_ph.c | 26 + tests/tcg/mips/mips64-dspr2/mulq_s_w.c | 40 + tests/tcg/mips/mips64-dspr2/mulsa_w_ph.c | 30 + tests/tcg/mips/mips64-dspr2/mulsaq_s_w_ph.c | 30 + tests/tcg/mips/mips64-dspr2/precr_qb_ph.c | 23 + tests/tcg/mips/mips64-dspr2/precr_sra_ph_w.c | 37 + tests/tcg/mips/mips64-dspr2/precr_sra_r_ph_w.c | 37 + tests/tcg/mips/mips64-dspr2/prepend.c | 35 + tests/tcg/mips/mips64-dspr2/printf.c | 266 + tests/tcg/mips/mips64-dspr2/shra_qb.c | 35 + tests/tcg/mips/mips64-dspr2/shra_r_qb.c | 35 + tests/tcg/mips/mips64-dspr2/shrav_ob.c | 22 + tests/tcg/mips/mips64-dspr2/shrav_qb.c | 37 + tests/tcg/mips/mips64-dspr2/shrav_r_ob.c | 22 + tests/tcg/mips/mips64-dspr2/shrav_r_qb.c | 37 + tests/tcg/mips/mips64-dspr2/shrl_ph.c | 22 + tests/tcg/mips/mips64-dspr2/shrlv_ph.c | 23 + tests/tcg/mips/mips64-dspr2/subqh_ph.c | 23 + tests/tcg/mips/mips64-dspr2/subqh_r_ph.c | 23 + tests/tcg/mips/mips64-dspr2/subqh_r_w.c | 23 + tests/tcg/mips/mips64-dspr2/subqh_w.c | 23 + tests/tcg/mips/mips64-dspr2/subu_ph.c | 26 + tests/tcg/mips/mips64-dspr2/subu_qh.c | 24 + tests/tcg/mips/mips64-dspr2/subu_s_ph.c | 25 + tests/tcg/mips/mips64-dspr2/subu_s_qh.c | 42 + tests/tcg/mips/mips64-dspr2/subuh_ob.c | 36 + tests/tcg/mips/mips64-dspr2/subuh_qb.c | 23 + tests/tcg/mips/mips64-dspr2/subuh_r_ob.c | 23 + tests/tcg/mips/mips64-dspr2/subuh_r_qb.c | 37 + tests/tcg/openrisc/Makefile | 71 + tests/tcg/openrisc/test_add.c | 43 + tests/tcg/openrisc/test_addc.c | 38 + tests/tcg/openrisc/test_addi.c | 33 + tests/tcg/openrisc/test_addic.c | 33 + tests/tcg/openrisc/test_and_or.c | 65 + tests/tcg/openrisc/test_bf.c | 47 + tests/tcg/openrisc/test_bnf.c | 51 + tests/tcg/openrisc/test_div.c | 54 + tests/tcg/openrisc/test_divu.c | 34 + tests/tcg/openrisc/test_extx.c | 78 + tests/tcg/openrisc/test_fx.c | 57 + tests/tcg/openrisc/test_j.c | 26 + tests/tcg/openrisc/test_jal.c | 26 + tests/tcg/openrisc/test_lf_add.c | 39 + tests/tcg/openrisc/test_lf_div.c | 37 + tests/tcg/openrisc/test_lf_eqs.c | 88 + tests/tcg/openrisc/test_lf_ges.c | 88 + tests/tcg/openrisc/test_lf_gts.c | 86 + tests/tcg/openrisc/test_lf_les.c | 88 + tests/tcg/openrisc/test_lf_lts.c | 92 + tests/tcg/openrisc/test_lf_mul.c | 22 + tests/tcg/openrisc/test_lf_nes.c | 89 + tests/tcg/openrisc/test_lf_rem.c | 32 + tests/tcg/openrisc/test_lf_sub.c | 35 + tests/tcg/openrisc/test_logic.c | 105 + tests/tcg/openrisc/test_lx.c | 84 + tests/tcg/openrisc/test_movhi.c | 31 + tests/tcg/openrisc/test_mul.c | 61 + tests/tcg/openrisc/test_muli.c | 48 + tests/tcg/openrisc/test_mulu.c | 48 + tests/tcg/openrisc/test_sfeq.c | 43 + tests/tcg/openrisc/test_sfeqi.c | 39 + tests/tcg/openrisc/test_sfges.c | 44 + tests/tcg/openrisc/test_sfgesi.c | 40 + tests/tcg/openrisc/test_sfgeu.c | 44 + tests/tcg/openrisc/test_sfgeui.c | 41 + tests/tcg/openrisc/test_sfgts.c | 45 + tests/tcg/openrisc/test_sfgtsi.c | 41 + tests/tcg/openrisc/test_sfgtu.c | 43 + tests/tcg/openrisc/test_sfgtui.c | 42 + tests/tcg/openrisc/test_sfles.c | 26 + tests/tcg/openrisc/test_sflesi.c | 39 + tests/tcg/openrisc/test_sfleu.c | 43 + tests/tcg/openrisc/test_sfleui.c | 39 + tests/tcg/openrisc/test_sflts.c | 43 + tests/tcg/openrisc/test_sfltsi.c | 39 + tests/tcg/openrisc/test_sfltu.c | 43 + tests/tcg/openrisc/test_sfltui.c | 39 + tests/tcg/openrisc/test_sfne.c | 43 + tests/tcg/openrisc/test_sfnei.c | 39 + tests/tcg/openrisc/test_sub.c | 35 + tests/tcg/pi_10.com | Bin 0 -> 54 bytes tests/tcg/runcom.c | 192 + tests/tcg/sha1.c | 240 + tests/tcg/test-arm-iwmmxt.s | 49 + tests/tcg/test-i386-code16.S | 79 + tests/tcg/test-i386-fprem.c | 353 + tests/tcg/test-i386-muldiv.h | 76 + tests/tcg/test-i386-shift.h | 185 + tests/tcg/test-i386-ssse3.c | 57 + tests/tcg/test-i386-vm86.S | 103 + tests/tcg/test-i386.c | 2765 + tests/tcg/test-i386.h | 152 + tests/tcg/test-mmap.c | 484 + tests/tcg/test_path.c | 161 + tests/tcg/testthread.c | 58 + tests/tcg/xtensa/Makefile | 79 + tests/tcg/xtensa/crt.S | 24 + tests/tcg/xtensa/linker.ld | 112 + tests/tcg/xtensa/macros.inc | 85 + tests/tcg/xtensa/test_b.S | 221 + tests/tcg/xtensa/test_bi.S | 103 + tests/tcg/xtensa/test_boolean.S | 23 + tests/tcg/xtensa/test_break.S | 257 + tests/tcg/xtensa/test_bz.S | 57 + tests/tcg/xtensa/test_clamps.S | 42 + tests/tcg/xtensa/test_fail.S | 9 + tests/tcg/xtensa/test_interrupt.S | 194 + tests/tcg/xtensa/test_loop.S | 163 + tests/tcg/xtensa/test_mac16.S | 243 + tests/tcg/xtensa/test_max.S | 81 + tests/tcg/xtensa/test_min.S | 81 + tests/tcg/xtensa/test_mmu.S | 511 + tests/tcg/xtensa/test_mul16.S | 83 + tests/tcg/xtensa/test_mul32.S | 20 + tests/tcg/xtensa/test_nsa.S | 59 + tests/tcg/xtensa/test_pipeline.S | 157 + tests/tcg/xtensa/test_quo.S | 147 + tests/tcg/xtensa/test_rem.S | 147 + tests/tcg/xtensa/test_rst0.S | 148 + tests/tcg/xtensa/test_sar.S | 111 + tests/tcg/xtensa/test_sext.S | 69 + tests/tcg/xtensa/test_shift.S | 206 + tests/tcg/xtensa/test_timer.S | 178 + tests/tcg/xtensa/test_windowed.S | 302 + tests/tcg/xtensa/vectors.S | 39 + tests/test-arm-iwmmxt.s | 49 - tests/test-coroutine.c | 219 + tests/test-i386-code16.S | 79 - tests/test-i386-muldiv.h | 76 - tests/test-i386-shift.h | 185 - tests/test-i386-ssse3.c | 57 - tests/test-i386-vm86.S | 103 - tests/test-i386.c | 2764 - tests/test-i386.h | 152 - tests/test-iov.c | 260 + tests/test-mmap.c | 476 - tests/test-qmp-commands.c | 181 + tests/test-qmp-input-strict.c | 234 + tests/test-qmp-input-visitor.c | 316 + tests/test-qmp-output-visitor.c | 477 + tests/test-string-input-visitor.c | 195 + tests/test-string-output-visitor.c | 188 + tests/test-visitor-serialization.c | 784 + tests/test_path.c | 160 - tests/testthread.c | 51 - tests/xtensa/Makefile | 75 - tests/xtensa/crt.S | 24 - tests/xtensa/linker.ld | 112 - tests/xtensa/macros.inc | 68 - tests/xtensa/test_b.S | 221 - tests/xtensa/test_bi.S | 103 - tests/xtensa/test_boolean.S | 23 - tests/xtensa/test_bz.S | 57 - tests/xtensa/test_clamps.S | 42 - tests/xtensa/test_fail.S | 9 - tests/xtensa/test_interrupt.S | 194 - tests/xtensa/test_loop.S | 77 - tests/xtensa/test_mac16.S | 243 - tests/xtensa/test_max.S | 81 - tests/xtensa/test_min.S | 81 - tests/xtensa/test_mmu.S | 318 - tests/xtensa/test_mul16.S | 83 - tests/xtensa/test_mul32.S | 20 - tests/xtensa/test_nsa.S | 59 - tests/xtensa/test_pipeline.S | 157 - tests/xtensa/test_quo.S | 147 - tests/xtensa/test_rem.S | 147 - tests/xtensa/test_rst0.S | 148 - tests/xtensa/test_sar.S | 111 - tests/xtensa/test_sext.S | 69 - tests/xtensa/test_shift.S | 206 - tests/xtensa/test_timer.S | 178 - tests/xtensa/test_windowed.S | 302 - tests/xtensa/vectors.S | 39 - thread-pool.c | 289 + thread-pool.h | 34 + thunk.c | 28 + thunk.h | 32 +- trace-events | 437 +- trace/control.c | 12 +- trace/simple.c | 286 +- trace/simple.h | 39 +- translate-all.c | 11 +- ui/Makefile.objs | 14 + ui/cocoa.m | 9 +- ui/curses.c | 21 +- ui/qemu-spice.h | 9 +- ui/sdl.c | 204 +- ui/spice-core.c | 148 +- ui/spice-display.c | 265 +- ui/spice-display.h | 40 +- ui/vnc-auth-sasl.c | 9 +- ui/vnc-auth-sasl.h | 4 +- ui/vnc-auth-vencrypt.c | 3 +- ui/vnc-enc-hextile-template.h | 24 +- ui/vnc-enc-hextile.c | 53 +- ui/vnc-enc-tight.c | 280 +- ui/vnc-enc-zrle.c | 18 +- ui/vnc-enc-zywrle-template.c | 2 +- ui/vnc-enc-zywrle.h | 2 +- ui/vnc-jobs-async.c | 341 - ui/vnc-jobs-sync.c | 73 - ui/vnc-jobs.c | 352 + ui/vnc-jobs.h | 18 +- ui/vnc-palette.h | 1 + ui/vnc-tls.c | 2 +- ui/vnc.c | 551 +- ui/vnc.h | 59 +- uri.c | 2249 + uri.h | 113 + usb-bsd.c | 639 - usb-linux.c | 2152 - usb-redir.c | 1252 - usb-stub.c | 52 - user-exec.c | 32 +- vl.c | 984 +- vmstate.h | 639 + xen-all.c | 314 +- xen-mapcache.c | 36 +- xen-mapcache.h | 8 +- xen-stub.c | 22 +- xtensa-semi.c | 224 - 2676 files changed, 436970 insertions(+), 133260 deletions(-) diff --git a/.exrc b/.exrc new file mode 100644 index 0000000..37755ed --- /dev/null +++ b/.exrc @@ -0,0 +1,7 @@ +"VIM settings to match QEMU coding style. They are activated by adding the +"following settings (without the " symbol) as last two lines in $HOME/.vimrc: +"set secure +"set exrc +set expandtab +set shiftwidth=4 +set smarttab diff --git a/.gitignore b/.gitignore index 406f75f..bd6ba1c 100644 --- a/.gitignore +++ b/.gitignore @@ -12,8 +12,6 @@ trace-dtrace.dtrace *-linux-user *-bsd-user libdis* -libhw32 -libhw64 libuser linux-headers/asm qapi-generated @@ -39,9 +37,18 @@ qemu-img-cmds.texi qemu-img-cmds.h qemu-io qemu-ga +qemu-bridge-helper qemu-monitor.texi +vscclient QMP/qmp-commands.txt test-coroutine +test-qmp-input-visitor +test-qmp-output-visitor +test-string-input-visitor +test-string-output-visitor +test-visitor-serialization +fsdev/virtfs-proxy-helper.1 +fsdev/virtfs-proxy-helper.pod .gdbinit *.a *.aux @@ -62,6 +69,10 @@ test-coroutine *.vr *.d *.o +*.lo +*.la +*.pc +.libs *.swp *.orig .pc @@ -69,8 +80,14 @@ patches pc-bios/bios-pq/status pc-bios/vgabios-pq/status pc-bios/optionrom/linuxboot.bin +pc-bios/optionrom/linuxboot.raw +pc-bios/optionrom/linuxboot.img pc-bios/optionrom/multiboot.bin pc-bios/optionrom/multiboot.raw +pc-bios/optionrom/multiboot.img +pc-bios/optionrom/kvmvapic.bin +pc-bios/optionrom/kvmvapic.raw +pc-bios/optionrom/kvmvapic.img .stgit-* cscope.* tags diff --git a/.gitmodules b/.gitmodules index eca876f..cfa2af9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -19,3 +19,6 @@ [submodule "roms/sgabios"] path = roms/sgabios url = git://git.qemu.org/sgabios.git +[submodule "pixman"] + path = pixman + url = git://anongit.freedesktop.org/pixman diff --git a/.mailmap b/.mailmap new file mode 100644 index 0000000..9797802 --- /dev/null +++ b/.mailmap @@ -0,0 +1,16 @@ +# This mailmap just translates the weird addresses from the original import into git +# into proper addresses so that they are counted properly in git shortlog output. +# +Andrzej Zaborowski balrog +Anthony Liguori aliguori +Aurelien Jarno aurel32 +Blue Swirl blueswir1 +Edgar E. Iglesias edgar_igl +Fabrice Bellard bellard +Jocelyn Mayer j_mayer +Paul Brook pbrook +Thiemo Seufer ths +malc malc +# There is also a: +# (no author) <(no author)@c046a42c-6fe2-441c-8c8c-71466251a162> +# for the cvs2svn initialization commit e63c3dc74bf. diff --git a/CODING_STYLE b/CODING_STYLE index 6e61c49..dcbce28 100644 --- a/CODING_STYLE +++ b/CODING_STYLE @@ -1,4 +1,4 @@ -Qemu Coding Style +QEMU Coding Style ================= Please use the script checkpatch.pl in the scripts directory to check @@ -44,7 +44,8 @@ Rationale: 3. Naming Variables are lower_case_with_underscores; easy to type and read. Structured -type names are in CamelCase; harder to type but standing out. Scalar type +type names are in CamelCase; harder to type but standing out. Enum type +names and function type names should also be in CamelCase. Scalar type names are lower_case_with_underscores_ending_with_a_t, like the POSIX uint64_t and family. Note that this last convention contradicts POSIX and is therefore likely to be changed. diff --git a/Changelog b/Changelog index 28a69af..13eebef 100644 --- a/Changelog +++ b/Changelog @@ -78,7 +78,7 @@ version 0.10.2: - fix savevm/loadvm (Anthony Liguori) - live migration: fix dirty tracking windows (Glauber Costa) - - live migration: improve error propogation (Glauber Costa) + - live migration: improve error propagation (Glauber Costa) - qcow2: fix image creation for > ~2TB images (Chris Wright) - hotplug: fix error handling for if= parameter (Eduardo Habkost) - qcow2: fix data corruption (Nolan Leake) @@ -386,7 +386,7 @@ version 0.5.3: - support of CD-ROM change - multiple network interface support - initial x86-64 host support (Gwenole Beauchesne) - - lret to outer priviledge fix (OS/2 install fix) + - lret to outer privilege fix (OS/2 install fix) - task switch fixes (SkyOS boot) - VM save/restore commands - new timer API @@ -447,7 +447,7 @@ version 0.5.0: - multi-target build - fixed: no error code in hardware interrupts - fixed: pop ss, mov ss, x and sti disable hardware irqs for the next insn - - correct single stepping thru string operations + - correct single stepping through string operations - preliminary SPARC target support (Thomas M. Ogrisegg) - tun-fd option (Rusty Russell) - automatic IDE geometry detection diff --git a/HACKING b/HACKING index 733eab2..89a6b3a 100644 --- a/HACKING +++ b/HACKING @@ -32,7 +32,7 @@ mandatory for VMState fields. Don't use Linux kernel internal types like u32, __u32 or __le32. -Use target_phys_addr_t for guest physical addresses except pcibus_t +Use hwaddr for guest physical addresses except pcibus_t for PCI addresses. In addition, ram_addr_t is a QEMU internal address space that maps guest RAM physical addresses into an intermediate address space that can map to host virtual address spaces. Generally @@ -77,11 +77,13 @@ avoided. Use of the malloc/free/realloc/calloc/valloc/memalign/posix_memalign APIs is not allowed in the QEMU codebase. Instead of these routines, -use the replacement g_malloc/g_malloc0/g_realloc/g_free or -qemu_vmalloc/qemu_memalign/qemu_vfree APIs. +use the GLib memory allocation routines g_malloc/g_malloc0/g_new/ +g_new0/g_realloc/g_free or QEMU's qemu_vmalloc/qemu_memalign/qemu_vfree +APIs. -Please note that NULL check for the g_malloc result is redundant and -that g_malloc() call with zero size is not allowed. +Please note that g_malloc will exit on allocation failure, so there +is no need to test for failure (as you would have to with malloc). +Calling g_malloc with a zero size is valid and will return NULL. Memory allocated by qemu_vmalloc or qemu_memalign must be freed with qemu_vfree, since breaking this will cause problems on Win32 and user @@ -89,10 +91,11 @@ emulators. 4. String manipulation -Do not use the strncpy function. According to the man page, it does -*not* guarantee a NULL-terminated buffer, which makes it extremely dangerous -to use. Instead, use functionally equivalent function: -void pstrcpy(char *buf, int buf_size, const char *str) +Do not use the strncpy function. As mentioned in the man page, it does *not* +guarantee a NULL-terminated buffer, which makes it extremely dangerous to use. +It also zeros trailing destination bytes out to the specified length. Instead, +use this similar function when possible, but note its different signature: +void pstrcpy(char *dest, int dest_buf_size, const char *src) Don't use strcat because it can't check for buffer overflows, but: char *pstrcat(char *buf, int buf_size, const char *s) diff --git a/LICENSE b/LICENSE index cbd92c0..acae9a3 100644 --- a/LICENSE +++ b/LICENSE @@ -6,9 +6,7 @@ The following points clarify the QEMU license: GNU General Public License. Hence each source file contains its own licensing information. -In particular, the QEMU virtual CPU core library (libqemu.a) is -released under the GNU Lesser General Public License. Many hardware -device emulation sources are released under the BSD license. +Many hardware device emulation sources are released under the BSD license. 3) The Tiny Code Generator (TCG) is released under the BSD license (see license headers in files). diff --git a/MAINTAINERS b/MAINTAINERS index 06df70c..2ede20d 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20,7 +20,7 @@ Descriptions of section entries: Supported: Someone is actually paid to look after this. Maintained: Someone actually looks after it. Odd Fixes: It has a maintainer but they don't have time to do - much other than throw the odd patch in. See below.. + much other than throw the odd patch in. See below. Orphan: No current maintainer [but maybe you could take the role as you write your new code]. Obsolete: Old code. Something tagged obsolete generally means @@ -78,7 +78,7 @@ F: target-lm32/ M68K M: Paul Brook -S: Maintained +S: Odd Fixes F: target-m68k/ MicroBlaze @@ -88,11 +88,12 @@ F: target-microblaze/ MIPS M: Aurelien Jarno -S: Maintained +S: Odd Fixes F: target-mips/ PowerPC M: Alexander Graf +L: qemu-ppc@nongnu.org S: Maintained F: target-ppc/ @@ -103,7 +104,7 @@ F: target-s390x/ SH4 M: Aurelien Jarno -S: Maintained +S: Odd Fixes F: target-sh4/ SPARC @@ -111,6 +112,11 @@ M: Blue Swirl S: Maintained F: target-sparc/ +UniCore32 +M: Guan Xuetao +S: Maintained +F: target-unicore32/ + X86 M: qemu-devel@nongnu.org S: Odd Fixes @@ -160,13 +166,53 @@ S: Supported F: xen-* F: */xen* +Hosts: +------ + +LINUX +L: qemu-devel@nongnu.org +S: Maintained +F: linux-* +F: linux-headers/ + +POSIX +L: qemu-devel@nongnu.org +S: Maintained +F: *posix* + +W32, W64 +L: qemu-devel@nongnu.org +M: Stefan Weil +S: Maintained +F: *win32* + ARM Machines ------------ +Exynos +M: Evgeny Voevodin +M: Maksim Kozlov +M: Igor Mitsyanko +M: Dmitry Solodkiy +S: Maintained +F: hw/exynos* _______________________________________________ Xen-changelog mailing list Xen-changelog@lists.xen.org http://lists.xensource.com/xen-changelog From xen-devel-bounces@lists.xen.org Mon Nov 26 16:30:33 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 26 Nov 2012 16:30:33 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Td1ZX-0000Ww-48; Mon, 26 Nov 2012 16:30:15 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Td1ZU-0000WO-Ve for xen-devel@lists.xen.org; Mon, 26 Nov 2012 16:30:13 +0000 Received: from [193.109.254.147:14060] by server-4.bemta-14.messagelabs.com id 9E/BF-18856-41993B05; Mon, 26 Nov 2012 16:30:12 +0000 X-Env-Sender: Andrew.Cooper3@citrix.com X-Msg-Ref: server-8.tower-27.messagelabs.com!1353947405!8617414!3 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAxODU5NzY=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 2310 invoked from network); 26 Nov 2012 16:30:09 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-8.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 26 Nov 2012 16:30:09 -0000 X-IronPort-AV: E=Sophos;i="4.83,321,1352073600"; d="scan'208";a="45627152" Received: from ftlpmailmx01.citrite.net ([10.13.107.65]) by FTLPIPO01.CITRIX.COM with ESMTP/TLS/RC4-MD5; 26 Nov 2012 16:30:05 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.65) with Microsoft SMTP Server id 8.3.279.1; Mon, 26 Nov 2012 11:30:04 -0500 Received: from andrewcoop.uk.xensource.com ([10.80.2.18]) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1Td1Tz-0005Uf-GO; Mon, 26 Nov 2012 16:24:31 +0000 MIME-Version: 1.0 X-Mercurial-Node: 7784cd3925c571903e75f19edf42efc4cc31749e Message-ID: <7784cd3925c571903e75.1353947052@andrewcoop.uk.xensource.com> In-Reply-To: References: User-Agent: Mercurial-patchbomb/2.3.2 Date: Mon, 26 Nov 2012 16:24:12 +0000 From: Andrew Cooper To: Cc: Keir Fraser Subject: [Xen-devel] [PATCH 4 of 4] minios/whitespace: Clean up trailing whitespace 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 This patch was generated using find . -name "*.[hcS]" | xargs sed -e "s/[ ]\+$//g" -i from the minios directory. Signed-off-by: Andrew Cooper diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/apps/daytime/daytime.c --- a/extras/mini-os/apps/daytime/daytime.c +++ b/extras/mini-os/apps/daytime/daytime.c @@ -1,6 +1,6 @@ -/* +/* * daytime.c: a simple network service based on lwIP and mini-os - * + * * Tim Deegan , July 2007 */ @@ -48,7 +48,7 @@ void run_server(void *p) while (1) { session = netconn_accept(listener); - if (session == NULL) + if (session == NULL) continue; gettimeofday(&tv, NULL); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/ioremap.c --- a/extras/mini-os/arch/x86/ioremap.c +++ b/extras/mini-os/arch/x86/ioremap.c @@ -1,22 +1,22 @@ /* * Copyright (C) 2009, Netronome Systems, Inc. - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -29,7 +29,7 @@ /* Map a physical address range into virtual address space with provided * flags. Return a virtual address range it is mapped to. */ -static void *__do_ioremap(unsigned long phys_addr, unsigned long size, +static void *__do_ioremap(unsigned long phys_addr, unsigned long size, unsigned long prot) { unsigned long va; @@ -41,7 +41,7 @@ static void *__do_ioremap(unsigned long num_pages = (offset + size + PAGE_SIZE - 1) / PAGE_SIZE; phys_addr &= PAGE_MASK; mfns = mfn = phys_addr >> PAGE_SHIFT; - + va = (unsigned long)map_frames_ex(&mfns, num_pages, 0, 1, 1, DOMID_IO, NULL, prot); return (void *)(va + offset); @@ -60,7 +60,7 @@ void *ioremap_nocache(unsigned long phys /* Un-map the io-remapped region. Currently no list of existing mappings is * maintained, so the caller has to supply the size */ void iounmap(void *virt_addr, unsigned long size) -{ +{ unsigned long num_pages; unsigned long va = (unsigned long)virt_addr; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/mm.c --- a/extras/mini-os/arch/x86/mm.c +++ b/extras/mini-os/arch/x86/mm.c @@ -1,4 +1,4 @@ -/* +/* **************************************************************************** * (C) 2003 - Rolf Neugebauer - Intel Research Cambridge * (C) 2005 - Grzegorz Milos - Intel Research Cambridge @@ -7,9 +7,9 @@ * File: mm.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos - * + * * Date: Aug 2003, chages Aug 2005 - * + * * Environment: Xen Minimal OS * Description: memory management related functions * contains buddy page allocator from Xen. @@ -21,16 +21,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -59,24 +59,24 @@ extern void page_walk(unsigned long va); * table at offset in previous level MFN (pref_l_mfn). pt_pfn is a guest * PFN. */ -static void new_pt_frame(unsigned long *pt_pfn, unsigned long prev_l_mfn, +static void new_pt_frame(unsigned long *pt_pfn, unsigned long prev_l_mfn, unsigned long offset, unsigned long level) -{ +{ pgentry_t *tab = (pgentry_t *)start_info.pt_base; - unsigned long pt_page = (unsigned long)pfn_to_virt(*pt_pfn); + unsigned long pt_page = (unsigned long)pfn_to_virt(*pt_pfn); pgentry_t prot_e, prot_t; mmu_update_t mmu_updates[1]; int rc; - + prot_e = prot_t = 0; DEBUG("Allocating new L%d pt frame for pfn=%lx, " - "prev_l_mfn=%lx, offset=%lx", + "prev_l_mfn=%lx, offset=%lx", level, *pt_pfn, prev_l_mfn, offset); /* We need to clear the page, otherwise we might fail to map it as a page table page */ - memset((void*) pt_page, 0, PAGE_SIZE); - + memset((void*) pt_page, 0, PAGE_SIZE); + switch ( level ) { case L1_FRAME: @@ -105,11 +105,11 @@ static void new_pt_frame(unsigned long * #endif tab = pte_to_virt(tab[l3_table_offset(pt_page)]); - mmu_updates[0].ptr = (tab[l2_table_offset(pt_page)] & PAGE_MASK) + + mmu_updates[0].ptr = (tab[l2_table_offset(pt_page)] & PAGE_MASK) + sizeof(pgentry_t) * l1_table_offset(pt_page); - mmu_updates[0].val = (pgentry_t)pfn_to_mfn(*pt_pfn) << PAGE_SHIFT | + mmu_updates[0].val = (pgentry_t)pfn_to_mfn(*pt_pfn) << PAGE_SHIFT | (prot_e & ~_PAGE_RW); - + if ( (rc = HYPERVISOR_mmu_update(mmu_updates, 1, NULL, DOMID_SELF)) < 0 ) { printk("ERROR: PTE for new page table page could not be updated\n"); @@ -122,7 +122,7 @@ static void new_pt_frame(unsigned long * ((pgentry_t)prev_l_mfn << PAGE_SHIFT) + sizeof(pgentry_t) * offset; mmu_updates[0].val = (pgentry_t)pfn_to_mfn(*pt_pfn) << PAGE_SHIFT | prot_t; - if ( (rc = HYPERVISOR_mmu_update(mmu_updates, 1, NULL, DOMID_SELF)) < 0 ) + if ( (rc = HYPERVISOR_mmu_update(mmu_updates, 1, NULL, DOMID_SELF)) < 0 ) { printk("ERROR: mmu_update failed with rc=%d\n", rc); do_exit(); @@ -150,38 +150,38 @@ static int need_pt_frame(unsigned long v #if defined(__x86_64__) if ( level == L3_FRAME ) { - if ( l4_table_offset(va) >= + if ( l4_table_offset(va) >= l4_table_offset(hyp_virt_start) && - l4_table_offset(va) <= + l4_table_offset(va) <= l4_table_offset(hyp_virt_end)) return 0; return 1; - } + } else #endif if ( level == L2_FRAME ) { #if defined(__x86_64__) - if ( l4_table_offset(va) >= + if ( l4_table_offset(va) >= l4_table_offset(hyp_virt_start) && - l4_table_offset(va) <= + l4_table_offset(va) <= l4_table_offset(hyp_virt_end)) #endif - if ( l3_table_offset(va) >= + if ( l3_table_offset(va) >= l3_table_offset(hyp_virt_start) && - l3_table_offset(va) <= + l3_table_offset(va) <= l3_table_offset(hyp_virt_end)) return 0; return 1; - } - else + } + else /* Always need l1 frames */ if ( level == L1_FRAME ) return 1; - printk("ERROR: Unknown frame level %d, hypervisor %llx,%llx\n", + printk("ERROR: Unknown frame level %d, hypervisor %llx,%llx\n", level, hyp_virt_start, hyp_virt_end); return -1; } @@ -200,7 +200,7 @@ static void build_pagetable(unsigned lon int count = 0; int rc; - pfn_to_map = + pfn_to_map = (start_info.nr_pt_frames - NOT_L1_FRAMES) * L1_PAGETABLE_ENTRIES; if ( *max_pfn >= virt_to_pfn(HYPERVISOR_VIRT_START) ) @@ -211,7 +211,7 @@ static void build_pagetable(unsigned lon (unsigned long)&_text)>>20); *max_pfn = virt_to_pfn(HYPERVISOR_VIRT_START - PAGE_SIZE); printk("%dMB\n", - ((unsigned long)pfn_to_virt(*max_pfn) - + ((unsigned long)pfn_to_virt(*max_pfn) - (unsigned long)&_text)>>20); } @@ -230,7 +230,7 @@ static void build_pagetable(unsigned lon offset = l4_table_offset(start_address); /* Need new L3 pt frame */ if ( !(start_address & L3_MASK) ) - if ( need_pt_frame(start_address, L3_FRAME) ) + if ( need_pt_frame(start_address, L3_FRAME) ) new_pt_frame(&pt_pfn, pt_mfn, offset, L3_FRAME); page = tab[offset]; @@ -246,7 +246,7 @@ static void build_pagetable(unsigned lon page = tab[offset]; pt_mfn = pte_to_mfn(page); tab = to_virt(mfn_to_pfn(pt_mfn) << PAGE_SHIFT); - offset = l2_table_offset(start_address); + offset = l2_table_offset(start_address); /* Need new L1 pt frame */ if ( !(start_address & L1_MASK) ) if ( need_pt_frame(start_address, L1_FRAME) ) @@ -258,7 +258,7 @@ static void build_pagetable(unsigned lon mmu_updates[count].ptr = ((pgentry_t)pt_mfn << PAGE_SHIFT) + sizeof(pgentry_t) * offset; - mmu_updates[count].val = + mmu_updates[count].val = (pgentry_t)pfn_to_mfn(pfn_to_map++) << PAGE_SHIFT | L1_PROT; count++; if ( count == L1_PAGETABLE_ENTRIES || pfn_to_map == *max_pfn ) @@ -311,7 +311,7 @@ static void set_readonly(void *text, voi page = tab[offset]; mfn = pte_to_mfn(page); tab = to_virt(mfn_to_pfn(mfn) << PAGE_SHIFT); - offset = l2_table_offset(start_address); + offset = l2_table_offset(start_address); page = tab[offset]; mfn = pte_to_mfn(page); tab = to_virt(mfn_to_pfn(mfn) << PAGE_SHIFT); @@ -320,7 +320,7 @@ static void set_readonly(void *text, voi if ( start_address != (unsigned long)&shared_info ) { - mmu_updates[count].ptr = + mmu_updates[count].ptr = ((pgentry_t)mfn << PAGE_SHIFT) + sizeof(pgentry_t) * offset; mmu_updates[count].val = tab[offset] & ~_PAGE_RW; count++; @@ -330,7 +330,7 @@ static void set_readonly(void *text, voi start_address += PAGE_SIZE; - if ( count == L1_PAGETABLE_ENTRIES || + if ( count == L1_PAGETABLE_ENTRIES || start_address + PAGE_SIZE > end_address ) { rc = HYPERVISOR_mmu_update(mmu_updates, count, NULL, DOMID_SELF); @@ -356,16 +356,16 @@ static void set_readonly(void *text, voi * A useful mem testing function. Write the address to every address in the * range provided and read back the value. If verbose, print page walk to * some VA - * + * * If we get MEM_TEST_MAX_ERRORS we might as well stop */ -#define MEM_TEST_MAX_ERRORS 10 +#define MEM_TEST_MAX_ERRORS 10 int mem_test(unsigned long *start_va, unsigned long *end_va, int verbose) { unsigned long mask = 0x10000; unsigned long *pointer; int error_count = 0; - + /* write values and print page walks */ if ( verbose && (((unsigned long)start_va) & 0xfffff) ) { @@ -386,14 +386,14 @@ int mem_test(unsigned long *start_va, un printk("MemTest End: %lx\n", end_va-1); page_walk((unsigned long)end_va-1); } - + /* verify values */ for ( pointer = start_va; pointer < end_va; pointer++ ) { if ( ((unsigned long)pointer & ~mask) != *pointer ) { printk("Read error at 0x%lx. Read: 0x%lx, should read 0x%lx\n", - (unsigned long)pointer, *pointer, + (unsigned long)pointer, *pointer, ((unsigned long)pointer & ~mask)); error_count++; if ( error_count >= MEM_TEST_MAX_ERRORS ) @@ -467,7 +467,7 @@ pgentry_t *need_pgt(unsigned long va) tab = mfn_to_virt(pt_mfn); #endif offset = l3_table_offset(va); - if ( !(tab[offset] & _PAGE_PRESENT) ) + if ( !(tab[offset] & _PAGE_PRESENT) ) { pt_pfn = virt_to_pfn(alloc_page()); new_pt_frame(&pt_pfn, pt_mfn, offset, L2_FRAME); @@ -516,7 +516,7 @@ void arch_init_demand_mapping_area(unsig demand_map_area_start = (unsigned long) pfn_to_virt(cur_pfn); cur_pfn += DEMAND_MAP_PAGES; - printk("Demand map pfns at %lx-%lx.\n", + printk("Demand map pfns at %lx-%lx.\n", demand_map_area_start, pfn_to_virt(cur_pfn)); #ifdef HAVE_LIBC @@ -535,12 +535,12 @@ unsigned long allocate_ondemand(unsigned /* Find a properly aligned run of n contiguous frames */ for ( x = 0; - x <= DEMAND_MAP_PAGES - n; + x <= DEMAND_MAP_PAGES - n; x = (x + y + 1 + alignment - 1) & ~(alignment - 1) ) { unsigned long addr = demand_map_area_start + x * PAGE_SIZE; pgentry_t *pgt = get_pgt(addr); - for ( y = 0; y < n; y++, addr += PAGE_SIZE ) + for ( y = 0; y < n; y++, addr += PAGE_SIZE ) { if ( !(addr & L1_MASK) ) pgt = get_pgt(addr); @@ -568,8 +568,8 @@ unsigned long allocate_ondemand(unsigned */ #define MAP_BATCH ((STACK_SIZE / 2) / sizeof(mmu_update_t)) void do_map_frames(unsigned long va, - const unsigned long *mfns, unsigned long n, - unsigned long stride, unsigned long incr, + const unsigned long *mfns, unsigned long n, + unsigned long stride, unsigned long incr, domid_t id, int *err, unsigned long prot) { pgentry_t *pgt = NULL; @@ -577,7 +577,7 @@ void do_map_frames(unsigned long va, unsigned long i; int rc; - if ( !mfns ) + if ( !mfns ) { printk("do_map_frames: no mfns supplied\n"); return; @@ -602,11 +602,11 @@ void do_map_frames(unsigned long va, { mmu_update_t mmu_updates[todo]; - for ( i = 0; i < todo; i++, va += PAGE_SIZE, pgt++) + for ( i = 0; i < todo; i++, va += PAGE_SIZE, pgt++) { if ( !pgt || !(va & L1_MASK) ) pgt = need_pgt(va); - + mmu_updates[i].ptr = virt_to_mach(pgt) | MMU_NORMAL_PT_UPDATE; mmu_updates[i].val = ((pgentry_t)(mfns[(done + i) * stride] + (done + i) * incr) @@ -633,7 +633,7 @@ void do_map_frames(unsigned long va, * Map an array of MFNs contiguous into virtual address space. Virtual * addresses are allocated from the on demand area. */ -void *map_frames_ex(const unsigned long *mfns, unsigned long n, +void *map_frames_ex(const unsigned long *mfns, unsigned long n, unsigned long stride, unsigned long incr, unsigned long alignment, domid_t id, int *err, unsigned long prot) @@ -676,7 +676,7 @@ int unmap_frames(unsigned long va, unsig call[i].args[arg++] = 0; #ifdef __i386__ call[i].args[arg++] = 0; -#endif +#endif call[i].args[arg++] = UVMF_INVLPG; va += PAGE_SIZE; @@ -691,7 +691,7 @@ int unmap_frames(unsigned long va, unsig for ( i = 0; i < n; i++ ) { - if ( call[i].result ) + if ( call[i].result ) { printk("update_va_mapping failed for with rc=%d.\n", ret); return -(call[i].result); @@ -705,12 +705,12 @@ int unmap_frames(unsigned long va, unsig /* * Allocate pages which are contiguous in machine memory. * Returns a VA to where they are mapped or 0 on failure. - * + * * addr_bits indicates if the region has restrictions on where it is * located. Typical values are 32 (if for example PCI devices can't access * 64bit memory) or 0 for no restrictions. * - * Allocated pages can be freed using the page allocators free_pages() + * Allocated pages can be freed using the page allocators free_pages() * function. * * based on Linux function xen_create_contiguous_region() @@ -778,7 +778,7 @@ unsigned long alloc_contig_pages(int ord call[i].args[arg++] = 0; #ifdef __i386__ call[i].args[arg++] = 0; -#endif +#endif call[i].args[arg++] = UVMF_INVLPG; } @@ -793,10 +793,10 @@ unsigned long alloc_contig_pages(int ord out_frames = virt_to_pfn(in_va); /* PFNs to populate */ ret = HYPERVISOR_memory_op(XENMEM_exchange, &exchange); if ( ret ) { - printk("mem exchanged order=0x%x failed with rc=%d, nr_exchanged=%d\n", + printk("mem exchanged order=0x%x failed with rc=%d, nr_exchanged=%d\n", order, ret, exchange.nr_exchanged); /* we still need to return the allocated pages above to the pool - * ie. map them back into the 1:1 mapping etc. so we continue but + * ie. map them back into the 1:1 mapping etc. so we continue but * in the end return the pages to the page allocator and return 0. */ exch_success = 0; } @@ -824,7 +824,7 @@ unsigned long alloc_contig_pages(int ord #else call[i].args[arg++] = pte.pte_low; call[i].args[arg++] = pte.pte_high; -#endif +#endif call[i].args[arg++] = UVMF_INVLPG; } ret = HYPERVISOR_multicall(call, i); @@ -840,7 +840,7 @@ unsigned long alloc_contig_pages(int ord free_pages((void *) in_va, order); return 0; } - + return in_va; } @@ -863,24 +863,24 @@ void arch_init_p2m(unsigned long max_pfn { #ifdef __x86_64__ #define L1_P2M_SHIFT 9 -#define L2_P2M_SHIFT 18 -#define L3_P2M_SHIFT 27 +#define L2_P2M_SHIFT 18 +#define L3_P2M_SHIFT 27 #else #define L1_P2M_SHIFT 10 -#define L2_P2M_SHIFT 20 -#define L3_P2M_SHIFT 30 +#define L2_P2M_SHIFT 20 +#define L3_P2M_SHIFT 30 #endif -#define L1_P2M_ENTRIES (1 << L1_P2M_SHIFT) -#define L2_P2M_ENTRIES (1 << (L2_P2M_SHIFT - L1_P2M_SHIFT)) -#define L3_P2M_ENTRIES (1 << (L3_P2M_SHIFT - L2_P2M_SHIFT)) -#define L1_P2M_MASK (L1_P2M_ENTRIES - 1) -#define L2_P2M_MASK (L2_P2M_ENTRIES - 1) -#define L3_P2M_MASK (L3_P2M_ENTRIES - 1) - +#define L1_P2M_ENTRIES (1 << L1_P2M_SHIFT) +#define L2_P2M_ENTRIES (1 << (L2_P2M_SHIFT - L1_P2M_SHIFT)) +#define L3_P2M_ENTRIES (1 << (L3_P2M_SHIFT - L2_P2M_SHIFT)) +#define L1_P2M_MASK (L1_P2M_ENTRIES - 1) +#define L2_P2M_MASK (L2_P2M_ENTRIES - 1) +#define L3_P2M_MASK (L3_P2M_ENTRIES - 1) + unsigned long *l1_list = NULL, *l2_list = NULL, *l3_list; unsigned long pfn; - - l3_list = (unsigned long *)alloc_page(); + + l3_list = (unsigned long *)alloc_page(); for ( pfn=0; pfn> L2_P2M_SHIFT)] = virt_to_mfn(l2_list); + l3_list[(pfn >> L2_P2M_SHIFT)] = virt_to_mfn(l2_list); } if ( !(pfn % (L1_P2M_ENTRIES)) ) { l1_list = (unsigned long*)alloc_page(); - l2_list[(pfn >> L1_P2M_SHIFT) & L2_P2M_MASK] = - virt_to_mfn(l1_list); + l2_list[(pfn >> L1_P2M_SHIFT) & L2_P2M_MASK] = + virt_to_mfn(l1_list); } - l1_list[pfn & L1_P2M_MASK] = pfn_to_mfn(pfn); + l1_list[pfn & L1_P2M_MASK] = pfn_to_mfn(pfn); } - HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list = + HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list = virt_to_mfn(l3_list); HYPERVISOR_shared_info->arch.max_pfn = max_pfn; } @@ -919,7 +919,7 @@ void arch_init_mm(unsigned long* start_p printk(" _end: %p(VA)\n", &_end); /* First page follows page table pages and 3 more pages (store page etc) */ - start_pfn = PFN_UP(to_phys(start_info.pt_base)) + + start_pfn = PFN_UP(to_phys(start_info.pt_base)) + start_info.nr_pt_frames + 3; max_pfn = start_info.nr_pages; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/sched.c --- a/extras/mini-os/arch/x86/sched.c +++ b/extras/mini-os/arch/x86/sched.c @@ -1,4 +1,4 @@ -/* +/* **************************************************************************** * (C) 2005 - Grzegorz Milos - Intel Research Cambridge **************************************************************************** @@ -6,13 +6,13 @@ * File: sched.c * Author: Grzegorz Milos * Changes: Robert Kaiser - * + * * Date: Aug 2005 - * + * * Environment: Xen Minimal OS * Description: simple scheduler for Mini-Os * - * The scheduler is non-preemptive (cooperative), and schedules according + * The scheduler is non-preemptive (cooperative), and schedules according * to Round Robin algorithm. * **************************************************************************** @@ -22,16 +22,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -57,12 +57,12 @@ void dump_stack(struct thread *thread) { - unsigned long *bottom = (unsigned long *)(thread->stack + STACK_SIZE); + unsigned long *bottom = (unsigned long *)(thread->stack + STACK_SIZE); unsigned long *pointer = (unsigned long *)thread->sp; int count; if(thread == current) { -#ifdef __i386__ +#ifdef __i386__ asm("movl %%esp,%0" : "=r"(pointer)); #else @@ -76,11 +76,11 @@ void dump_stack(struct thread *thread) printk("[0x%lx] 0x%lx\n", pointer, *pointer); pointer++; } - + if(pointer < bottom) printk(" ... continues.\n"); } -/* Gets run when a new thread is scheduled the first time ever, +/* Gets run when a new thread is scheduled the first time ever, defined in x86_[32/64].S */ extern void thread_starter(void); @@ -96,18 +96,18 @@ struct thread* arch_create_thread(char * void *data) { struct thread *thread; - + thread = xmalloc(struct thread); /* We can't use lazy allocation here since the trap handler runs on the stack */ thread->stack = (char *)alloc_pages(STACK_SIZE_PAGE_ORDER); thread->name = name; - printk("Thread \"%s\": pointer: 0x%lx, stack: 0x%lx\n", name, thread, + printk("Thread \"%s\": pointer: 0x%lx, stack: 0x%lx\n", name, thread, thread->stack); - + thread->sp = (unsigned long)thread->stack + STACK_SIZE; /* Save pointer to the thread on the stack, used by current macro */ *((unsigned long *)thread->stack) = (unsigned long)thread; - + stack_push(thread, (unsigned long) function); stack_push(thread, (unsigned long) data); thread->ip = (unsigned long) thread_starter; @@ -116,19 +116,19 @@ struct thread* arch_create_thread(char * void run_idle_thread(void) { - /* Switch stacks and run the thread */ + /* Switch stacks and run the thread */ #if defined(__i386__) __asm__ __volatile__("mov %0,%%esp\n\t" - "push %1\n\t" - "ret" + "push %1\n\t" + "ret" :"=m" (idle_thread->sp) - :"m" (idle_thread->ip)); + :"m" (idle_thread->ip)); #elif defined(__x86_64__) __asm__ __volatile__("mov %0,%%rsp\n\t" - "push %1\n\t" - "ret" + "push %1\n\t" + "ret" :"=m" (idle_thread->sp) - :"m" (idle_thread->ip)); + :"m" (idle_thread->ip)); #endif } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/setup.c --- a/extras/mini-os/arch/x86/setup.c +++ b/extras/mini-os/arch/x86/setup.c @@ -1,27 +1,27 @@ /****************************************************************************** * common.c - * + * * Common stuff special to x86 goes here. - * + * * Copyright (c) 2002-2003, K A Fraser & R Neugebauer * Copyright (c) 2005, Grzegorz Milos, Intel Research Cambridge - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/time.c --- a/extras/mini-os/arch/x86/time.c +++ b/extras/mini-os/arch/x86/time.c @@ -1,7 +1,7 @@ /* -*- Mode:C; c-basic-offset:4; tab-width:4 -*- **************************************************************************** * (C) 2003 - Rolf Neugebauer - Intel Research Cambridge - * (C) 2002-2003 - Keir Fraser - University of Cambridge + * (C) 2002-2003 - Keir Fraser - University of Cambridge * (C) 2005 - Grzegorz Milos - Intel Research Cambridge * (C) 2006 - Robert Kaiser - FH Wiesbaden **************************************************************************** @@ -18,16 +18,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -74,7 +74,7 @@ static struct shadow_time_info shadow; static inline int time_values_up_to_date(void) { - struct vcpu_time_info *src = &HYPERVISOR_shared_info->vcpu_info[0].time; + struct vcpu_time_info *src = &HYPERVISOR_shared_info->vcpu_info[0].time; return (shadow.version == src->version); } @@ -187,8 +187,8 @@ int gettimeofday(struct timeval *tv, voi { uint64_t nsec = monotonic_clock(); nsec += shadow_ts.tv_nsec; - - + + tv->tv_sec = shadow_ts.tv_sec; tv->tv_sec += NSEC_TO_SEC(nsec); tv->tv_usec = NSEC_TO_USEC(nsec % 1000000000UL); @@ -212,7 +212,7 @@ void block_domain(s_time_t until) /* - * Just a dummy + * Just a dummy */ static void timer_handler(evtchn_port_t ev, struct pt_regs *regs, void *ign) { diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/traps.c --- a/extras/mini-os/arch/x86/traps.c +++ b/extras/mini-os/arch/x86/traps.c @@ -33,7 +33,7 @@ void machine_check(void); void dump_regs(struct pt_regs *regs) { printk("Thread: %s\n", current->name); -#ifdef __i386__ +#ifdef __i386__ printk("EIP: %x, EFLAGS %x.\n", regs->eip, regs->eflags); printk("EBX: %08x ECX: %08x EDX: %08x\n", regs->ebx, regs->ecx, regs->edx); @@ -45,18 +45,18 @@ void dump_regs(struct pt_regs *regs) regs->xcs, regs->eflags, regs->esp, regs->xss); #else printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip); - printk("\nRSP: %04lx:%016lx EFLAGS: %08lx\n", + printk("\nRSP: %04lx:%016lx EFLAGS: %08lx\n", regs->ss, regs->rsp, regs->eflags); printk("RAX: %016lx RBX: %016lx RCX: %016lx\n", regs->rax, regs->rbx, regs->rcx); printk("RDX: %016lx RSI: %016lx RDI: %016lx\n", - regs->rdx, regs->rsi, regs->rdi); + regs->rdx, regs->rsi, regs->rdi); printk("RBP: %016lx R08: %016lx R09: %016lx\n", - regs->rbp, regs->r8, regs->r9); + regs->rbp, regs->r8, regs->r9); printk("R10: %016lx R11: %016lx R12: %016lx\n", - regs->r10, regs->r11, regs->r12); + regs->r10, regs->r11, regs->r12); printk("R13: %016lx R14: %016lx R15: %016lx\n", - regs->r13, regs->r14, regs->r15); + regs->r13, regs->r14, regs->r15); #endif } @@ -98,7 +98,7 @@ void page_walk(unsigned long virt_addres pgentry_t *tab = (pgentry_t *)start_info.pt_base, page; unsigned long addr = virt_address; printk("Pagetable walk from virt %lx, base %lx:\n", virt_address, start_info.pt_base); - + #if defined(__x86_64__) page = tab[l4_table_offset(addr)]; tab = pte_to_virt(page); @@ -110,7 +110,7 @@ void page_walk(unsigned long virt_addres page = tab[l2_table_offset(addr)]; tab = pte_to_virt(page); printk(" L2 = %"PRIpte" (%p) [offset = %lx]\n", page, tab, l2_table_offset(addr)); - + page = tab[l1_table_offset(addr)]; printk(" L1 = %"PRIpte" [offset = %lx]\n", page, l1_table_offset(addr)); @@ -136,7 +136,7 @@ static int handle_cow(unsigned long addr if (!(page & _PAGE_PRESENT)) return 0; tab = pte_to_virt(page); - + page = tab[l1_table_offset(addr)]; if (!(page & _PAGE_PRESENT)) return 0; @@ -204,10 +204,10 @@ void do_page_fault(struct pt_regs *regs, /* If we are already handling a page fault, and got another one that means we faulted in pagetable walk. Continuing here would cause - a recursive fault */ - if(handling_pg_fault == 1) + a recursive fault */ + if(handling_pg_fault == 1) { - printk("Page fault in pagetable walk (access to invalid memory?).\n"); + printk("Page fault in pagetable walk (access to invalid memory?).\n"); HYPERVISOR_sched_op(SCHEDOP_shutdown, &sched_shutdown); } handling_pg_fault++; @@ -244,7 +244,7 @@ void do_general_protection(struct pt_reg struct sched_shutdown sched_shutdown = { .reason = SHUTDOWN_crash }; #ifdef __i386__ printk("GPF eip: %p, error_code=%lx\n", regs->eip, error_code); -#else +#else printk("GPF rip: %p, error_code=%lx\n", regs->rip, error_code); #endif dump_regs(regs); @@ -319,12 +319,12 @@ static trap_info_t trap_table[] = { { 19, 0, __KERNEL_CS, (unsigned long)simd_coprocessor_error }, { 0, 0, 0, 0 } }; - + void trap_init(void) { - HYPERVISOR_set_trap_table(trap_table); + HYPERVISOR_set_trap_table(trap_table); } void trap_fini(void) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/x86_32.S --- a/extras/mini-os/arch/x86/x86_32.S +++ b/extras/mini-os/arch/x86/x86_32.S @@ -14,12 +14,12 @@ .text .globl _start, shared_info, hypercall_page - + _start: cld lss stack_start,%esp andl $(~(__STACK_SIZE-1)), %esp - push %esi + push %esi call start_kernel stack_start: @@ -67,7 +67,7 @@ CS = 0x2C popl %ds; \ popl %es; \ addl $4,%esp; \ - iret; + iret; ENTRY(divide_error) pushl $0 # no error code @@ -97,7 +97,7 @@ do_exception: pushl %eax call *%edi jmp ret_from_exception - + ret_from_exception: movb CS(%esp),%cl addl $8,%esp @@ -145,7 +145,7 @@ ecrit: /**** END OF CRITICAL REGION *** # registers are in each frame. We do this quickly using the lookup table # 'critical_fixup_table'. For each byte offset in the critical region, it # provides the number of bytes which have already been popped from the -# interrupted stack frame. +# interrupted stack frame. critical_region_fixup: addl $critical_fixup_table-scrit,%eax movzbl (%eax),%eax # %eax contains num bytes popped @@ -163,8 +163,8 @@ 15: subl $4,%esi # pre-decr loop 15b 16: movl %edi,%esp # final %edi is top of merged stack jmp 11b - -critical_fixup_table: + +critical_fixup_table: .byte 0x00,0x00,0x00 # testb $0xff,(%esi) .byte 0x00,0x00 # jne 14f .byte 0x00 # pop %ebx @@ -180,7 +180,7 @@ critical_fixup_table: .byte 0x28 # iret .byte 0x00,0x00,0x00,0x00 # movb $1,1(%esi) .byte 0x00,0x00 # jmp 11b - + # Hypervisor uses this for application faults while it executes. ENTRY(failsafe_callback) pop %ds @@ -188,7 +188,7 @@ ENTRY(failsafe_callback) pop %fs pop %gs iret - + ENTRY(coprocessor_error) pushl $0 pushl $do_coprocessor_error @@ -262,7 +262,7 @@ ENTRY(alignment_check) ENTRY(page_fault) pushl $do_page_fault jmp do_exception - + ENTRY(machine_check) pushl $0 pushl $do_machine_check @@ -283,8 +283,8 @@ ENTRY(thread_starter) xorl %ebp,%ebp pushl %eax call *%ebx - call exit_thread - + call exit_thread + ENTRY(__arch_switch_threads) movl 4(%esp), %ecx /* prev */ movl 8(%esp), %edx /* next */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/arch/x86/x86_64.S --- a/extras/mini-os/arch/x86/x86_64.S +++ b/extras/mini-os/arch/x86/x86_64.S @@ -36,14 +36,14 @@ hypercall_page: .org 0x3000 -/* Offsets into shared_info_t. */ +/* Offsets into shared_info_t. */ #define evtchn_upcall_pending /* 0 */ #define evtchn_upcall_mask 1 NMI_MASK = 0x80000000 #define RDI 112 -#define ORIG_RAX 120 /* + error_code */ +#define ORIG_RAX 120 /* + error_code */ #define EFLAGS 144 .macro RESTORE_ALL @@ -57,7 +57,7 @@ NMI_MASK = 0x80000000 movq 7*8(%rsp),%rsi movq 8*8(%rsp),%rdi addq $9*8+8,%rsp -.endm +.endm .macro HYPERVISOR_IRET flag @@ -80,32 +80,32 @@ 2: /* Slow iret via hypervisor. */ /* * Exception entry point. This expects an error code/orig_rax on the stack - * and the exception handler in %rax. - */ + * and the exception handler in %rax. + */ ENTRY(error_entry) /* rdi slot contains rax, oldrax contains error code */ - cld + cld subq $14*8,%rsp movq %rsi,13*8(%rsp) movq 14*8(%rsp),%rsi /* load rax from rdi slot */ movq %rdx,12*8(%rsp) movq %rcx,11*8(%rsp) - movq %rsi,10*8(%rsp) /* store rax */ + movq %rsi,10*8(%rsp) /* store rax */ movq %r8, 9*8(%rsp) movq %r9, 8*8(%rsp) movq %r10,7*8(%rsp) movq %r11,6*8(%rsp) - movq %rbx,5*8(%rsp) - movq %rbp,4*8(%rsp) - movq %r12,3*8(%rsp) - movq %r13,2*8(%rsp) - movq %r14,1*8(%rsp) - movq %r15,(%rsp) + movq %rbx,5*8(%rsp) + movq %rbp,4*8(%rsp) + movq %r12,3*8(%rsp) + movq %r13,2*8(%rsp) + movq %r14,1*8(%rsp) + movq %r15,(%rsp) error_call_handler: - movq %rdi, RDI(%rsp) + movq %rdi, RDI(%rsp) movq %rsp,%rdi - movq ORIG_RAX(%rsp),%rsi # get error code + movq ORIG_RAX(%rsp),%rsi # get error code movq $-1,ORIG_RAX(%rsp) call *%rax jmp error_exit @@ -114,11 +114,11 @@ error_call_handler: movq (%rsp),%rcx movq 8(%rsp),%r11 addq $0x10,%rsp /* skip rcx and r11 */ - pushq $0 /* push error code/oldrax */ - pushq %rax /* push real oldrax to the rdi slot */ + pushq $0 /* push error code/oldrax */ + pushq %rax /* push real oldrax to the rdi slot */ leaq \sym(%rip),%rax jmp error_entry -.endm +.endm .macro errorentry sym movq (%rsp),%rcx @@ -150,17 +150,17 @@ ENTRY(hypervisor_callback) zeroentry hypervisor_callback2 ENTRY(hypervisor_callback2) - movq %rdi, %rsp + movq %rdi, %rsp 11: movq %gs:8,%rax incl %gs:0 cmovzq %rax,%rsp pushq %rdi - call do_hypervisor_callback + call do_hypervisor_callback popq %rsp decl %gs:0 jmp error_exit -restore_all_enable_events: +restore_all_enable_events: XEN_UNBLOCK_EVENTS(%rsi) # %rsi is already set up... scrit: /**** START OF CRITICAL REGION ****/ @@ -169,16 +169,16 @@ scrit: /**** START OF CRITICAL REGION ** XEN_PUT_VCPU_INFO(%rsi) RESTORE_ALL HYPERVISOR_IRET 0 - + 14: XEN_LOCKED_BLOCK_EVENTS(%rsi) XEN_PUT_VCPU_INFO(%rsi) subq $6*8,%rsp - movq %rbx,5*8(%rsp) - movq %rbp,4*8(%rsp) - movq %r12,3*8(%rsp) - movq %r13,2*8(%rsp) - movq %r14,1*8(%rsp) - movq %r15,(%rsp) + movq %rbx,5*8(%rsp) + movq %rbp,4*8(%rsp) + movq %r12,3*8(%rsp) + movq %r13,2*8(%rsp) + movq %r14,1*8(%rsp) + movq %r15,(%rsp) movq %rsp,%rdi # set the argument again jmp 11b ecrit: /**** END OF CRITICAL REGION ****/ @@ -193,12 +193,12 @@ retint_restore_args: andb $1,%al # EAX[0] == IRET_EFLAGS.IF & event_mask jnz restore_all_enable_events # != 0 => enable event delivery XEN_PUT_VCPU_INFO(%rsi) - + RESTORE_ALL HYPERVISOR_IRET 0 -error_exit: +error_exit: movq (%rsp),%r15 movq 1*8(%rsp),%r14 movq 2*8(%rsp),%r13 @@ -206,7 +206,7 @@ error_exit: movq 4*8(%rsp),%rbp movq 5*8(%rsp),%rbx addq $6*8,%rsp - XEN_BLOCK_EVENTS(%rsi) + XEN_BLOCK_EVENTS(%rsi) jmp retint_kernel @@ -242,8 +242,8 @@ ENTRY(overflow) ENTRY(bounds) zeroentry do_bounds - - + + ENTRY(invalid_op) zeroentry do_invalid_op @@ -263,7 +263,7 @@ ENTRY(segment_not_present) /* runs on exception stack */ ENTRY(stack_segment) errorentry do_stack_segment - + ENTRY(general_protection) errorentry do_general_protection @@ -279,7 +279,7 @@ ENTRY(divide_error) ENTRY(spurious_interrupt_bug) zeroentry do_spurious_interrupt_bug - + ENTRY(page_fault) errorentry do_page_fault @@ -294,8 +294,8 @@ ENTRY(thread_starter) pushq $0 xorq %rbp,%rbp call *%rbx - call exit_thread - + call exit_thread + ENTRY(__arch_switch_threads) pushq %rbp diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/blkfront.c --- a/extras/mini-os/blkfront.c +++ b/extras/mini-os/blkfront.c @@ -1,4 +1,4 @@ -/* Minimal block driver for Mini-OS. +/* Minimal block driver for Mini-OS. * Copyright (c) 2007-2008 Samuel Thibault. * Based on netfront.c. */ @@ -111,7 +111,7 @@ struct blkfront_dev *init_blkfront(char #endif snprintf(path, sizeof(path), "%s/backend-id", nodename); - dev->dom = xenbus_read_integer(path); + dev->dom = xenbus_read_integer(path); evtchn_alloc_unbound(dev->dom, blkfront_handler, dev, &dev->evtchn); s = (struct blkif_sring*) alloc_page(); @@ -587,7 +587,7 @@ int blkfront_posix_rwop(int fd, uint8_t* /* Write mode checks */ if(write) { /*Make sure we have write permission */ - if(dev->info.info & VDISK_READONLY + if(dev->info.info & VDISK_READONLY || (dev->info.mode != O_RDWR && dev->info.mode != O_WRONLY)) { errno = EACCES; return -1; @@ -651,7 +651,7 @@ int blkfront_posix_rwop(int fd, uint8_t* } /* For an aligned R/W we can read up to the maximum transfer size */ - bytes = count > (BLKIF_MAX_SEGMENTS_PER_REQUEST-not_page_aligned)*PAGE_SIZE + bytes = count > (BLKIF_MAX_SEGMENTS_PER_REQUEST-not_page_aligned)*PAGE_SIZE ? (BLKIF_MAX_SEGMENTS_PER_REQUEST-not_page_aligned)*PAGE_SIZE : count & ~(blocksize -1); aiocb.aio_nbytes = bytes; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/console/console.c --- a/extras/mini-os/console/console.c +++ b/extras/mini-os/console/console.c @@ -1,14 +1,14 @@ -/* +/* **************************************************************************** * (C) 2006 - Grzegorz Milos - Cambridge University **************************************************************************** * * File: console.h * Author: Grzegorz Milos - * Changes: - * + * Changes: + * * Date: Mar 2006 - * + * * Environment: Xen Minimal OS * Description: Console interface. * @@ -21,19 +21,19 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ - + #include #include #include @@ -50,7 +50,7 @@ #define USE_XEN_CONSOLE -/* If console not initialised the printk will be sent to xen serial line +/* If console not initialised the printk will be sent to xen serial line NOTE: you need to enable verbose in xen/Rules.mk for it to work. */ static int console_initialised = 0; @@ -61,7 +61,7 @@ static int console_initialised = 0; /* Just repeat what's written */ buf[len] = '\0'; printk("%s", buf); - + if(buf[len-1] == '\r') printk("\nNo console input handler.\n"); } @@ -115,16 +115,16 @@ void console_print(struct consfront_dev copied_ptr[length] = '\n'; length++; } - + ring_send_fn(dev, copied_ptr, length); } void print(int direct, const char *fmt, va_list args) { static char buf[1024]; - + (void)vsnprintf(buf, sizeof(buf), fmt, args); - + if(direct) { (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf); @@ -132,9 +132,9 @@ void print(int direct, const char *fmt, } else { #ifndef USE_XEN_CONSOLE if(!console_initialised) -#endif +#endif (void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(buf), buf); - + console_print(NULL, buf, strlen(buf)); } } @@ -144,7 +144,7 @@ void printk(const char *fmt, ...) va_list args; va_start(args, fmt); print(0, fmt, args); - va_end(args); + va_end(args); } void xprintk(const char *fmt, ...) @@ -152,12 +152,12 @@ void xprintk(const char *fmt, ...) va_list args; va_start(args, fmt); print(1, fmt, args); - va_end(args); + va_end(args); } void init_console(void) -{ +{ printk("Initialising console ... "); - xencons_ring_init(); + xencons_ring_init(); console_initialised = 1; /* This is also required to notify the daemon */ printk("done.\n"); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/console/xenbus.c --- a/extras/mini-os/console/xenbus.c +++ b/extras/mini-os/console/xenbus.c @@ -84,7 +84,7 @@ struct consfront_dev *init_consfront(cha #endif snprintf(path, sizeof(path), "%s/backend-id", nodename); - if ((res = xenbus_read_integer(path)) < 0) + if ((res = xenbus_read_integer(path)) < 0) return NULL; else dev->dom = res; @@ -166,7 +166,7 @@ done: XenbusState state; char path[strlen(dev->backend) + 1 + 19 + 1]; snprintf(path, sizeof(path), "%s/state", dev->backend); - + xenbus_watch_path_token(XBT_NIL, path, path, &dev->events); msg = NULL; state = xenbus_read_integer(path); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/console/xencons_ring.c --- a/extras/mini-os/console/xencons_ring.c +++ b/extras/mini-os/console/xencons_ring.c @@ -30,10 +30,10 @@ static inline struct xencons_interface * return mfn_to_virt(start_info.console.domU.mfn); else return NULL; -} - +} + int xencons_ring_send_no_notify(struct consfront_dev *dev, const char *data, unsigned len) -{ +{ int sent = 0; struct xencons_interface *intf; XENCONS_RING_IDX cons, prod; @@ -55,7 +55,7 @@ int xencons_ring_send_no_notify(struct c wmb(); intf->out_prod = prod; - + return sent; } @@ -67,7 +67,7 @@ int xencons_ring_send(struct consfront_d notify_daemon(dev); return sent; -} +} diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/events.c --- a/extras/mini-os/events.c +++ b/extras/mini-os/events.c @@ -7,9 +7,9 @@ * File: events.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) - * + * * Date: Jul 2003, changes Jun 2005 - * + * * Environment: Xen Minimal OS * Description: Deals with events recieved on event channels * @@ -125,7 +125,7 @@ void unbind_evtchn(evtchn_port_t port ) rc = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close); if ( rc ) printk("WARN: close_port %s failed rc=%d. ignored\n", port, rc); - + } evtchn_port_t bind_virq(uint32_t virq, evtchn_handler_t handler, void *data) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/fbfront.c --- a/extras/mini-os/fbfront.c +++ b/extras/mini-os/fbfront.c @@ -1,5 +1,5 @@ /* - * Frame Buffer + Keyboard driver for Mini-OS. + * Frame Buffer + Keyboard driver for Mini-OS. * Samuel Thibault , 2008 * Based on blkfront.c. */ @@ -87,7 +87,7 @@ struct kbdfront_dev *init_kbdfront(char #endif snprintf(path, sizeof(path), "%s/backend-id", nodename); - dev->dom = xenbus_read_integer(path); + dev->dom = xenbus_read_integer(path); evtchn_alloc_unbound(dev->dom, kbdfront_handler, dev, &dev->evtchn); dev->page = s = (struct xenkbd_page*) alloc_page(); @@ -425,7 +425,7 @@ struct fbfront_dev *init_fbfront(char *_ #endif snprintf(path, sizeof(path), "%s/backend-id", nodename); - dev->dom = xenbus_read_integer(path); + dev->dom = xenbus_read_integer(path); evtchn_alloc_unbound(dev->dom, fbfront_handler, dev, &dev->evtchn); dev->page = s = (struct xenfb_page*) alloc_page(); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/gntmap.c --- a/extras/mini-os/gntmap.c +++ b/extras/mini-os/gntmap.c @@ -21,12 +21,12 @@ * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -100,7 +100,7 @@ gntmap_set_max_grants(struct gntmap *map } static int -_gntmap_map_grant_ref(struct gntmap_entry *entry, +_gntmap_map_grant_ref(struct gntmap_entry *entry, unsigned long host_addr, uint32_t domid, uint32_t ref, @@ -178,7 +178,7 @@ gntmap_munmap(struct gntmap *map, unsign } void* -gntmap_map_grant_refs(struct gntmap *map, +gntmap_map_grant_refs(struct gntmap *map, uint32_t count, uint32_t *domids, int domids_stride, diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/gnttab.c --- a/extras/mini-os/gnttab.c +++ b/extras/mini-os/gnttab.c @@ -1,14 +1,14 @@ -/* +/* **************************************************************************** * (C) 2006 - Cambridge University **************************************************************************** * * File: gnttab.c - * Author: Steven Smith (sos22@cam.ac.uk) + * Author: Steven Smith (sos22@cam.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) - * + * * Date: July 2006 - * + * * Environment: Xen Minimal OS * Description: Simple grant tables implementation. About as stupid as it's * possible to be and still work. diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/hypervisor.c --- a/extras/mini-os/hypervisor.c +++ b/extras/mini-os/hypervisor.c @@ -1,27 +1,27 @@ /****************************************************************************** * hypervisor.c - * + * * Communication to/from hypervisor. - * + * * Copyright (c) 2002-2003, K A Fraser * Copyright (c) 2005, Grzegorz Milos, gm281@cam.ac.uk,Intel Research Cambridge - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -45,7 +45,7 @@ void do_hypervisor_callback(struct pt_re vcpu_info_t *vcpu_info = &s->vcpu_info[cpu]; in_callback = 1; - + vcpu_info->evtchn_upcall_pending = 0; /* NB x86. No need for a barrier here -- XCHG is a barrier on x86. */ #if !defined(__i386__) && !defined(__x86_64__) @@ -57,7 +57,7 @@ void do_hypervisor_callback(struct pt_re { l1i = __ffs(l1); l1 &= ~(1UL << l1i); - + while ( (l2 = active_evtchns(cpu, s, l1i)) != 0 ) { l2i = __ffs(l2); @@ -105,7 +105,7 @@ inline void unmask_evtchn(uint32_t port) * The following is basically the equivalent of 'hw_resend_irq'. Just like * a real IO-APIC we 'lose the interrupt edge' if the channel is masked. */ - if ( synch_test_bit (port, &s->evtchn_pending[0]) && + if ( synch_test_bit (port, &s->evtchn_pending[0]) && !synch_test_and_set_bit(port / (sizeof(unsigned long) * 8), &vcpu_info->evtchn_pending_sel) ) { diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/arch/cc.h --- a/extras/mini-os/include/arch/cc.h +++ b/extras/mini-os/include/arch/cc.h @@ -1,7 +1,7 @@ -/* +/* * lwip/arch/cc.h * - * Compiler-specific types and macros for lwIP running on mini-os + * Compiler-specific types and macros for lwIP running on mini-os * * Tim Deegan , July 2007 */ @@ -28,7 +28,7 @@ typedef uint16_t u_short; /* Compiler hints for packing lwip's structures - */ #define PACK_STRUCT_FIELD(_x) _x #define PACK_STRUCT_STRUCT __attribute__ ((packed)) -#define PACK_STRUCT_BEGIN +#define PACK_STRUCT_BEGIN #define PACK_STRUCT_END /* Platform specific diagnostic output - */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/arch/perf.h --- a/extras/mini-os/include/arch/perf.h +++ b/extras/mini-os/include/arch/perf.h @@ -1,7 +1,7 @@ -/* +/* * lwip/arch/perf.h * - * Arch-specific performance measurement for lwIP running on mini-os + * Arch-specific performance measurement for lwIP running on mini-os * * Tim Deegan , July 2007 */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/arch/sys_arch.h --- a/extras/mini-os/include/arch/sys_arch.h +++ b/extras/mini-os/include/arch/sys_arch.h @@ -1,7 +1,7 @@ -/* +/* * lwip/arch/sys_arch.h * - * Arch-specific semaphores and mailboxes for lwIP running on mini-os + * Arch-specific semaphores and mailboxes for lwIP running on mini-os * * Tim Deegan , July 2007 */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/console.h --- a/extras/mini-os/include/console.h +++ b/extras/mini-os/include/console.h @@ -1,14 +1,14 @@ -/* +/* **************************************************************************** * (C) 2006 - Grzegorz Milos - Cambridge University **************************************************************************** * * File: console.h * Author: Grzegorz Milos - * Changes: - * + * Changes: + * * Date: Mar 2006 - * + * * Environment: Xen Minimal OS * Description: Console interface. * @@ -21,16 +21,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #ifndef _LIB_CONSOLE_H_ @@ -67,7 +67,7 @@ void print(int direct, const char *fmt, void printk(const char *fmt, ...); void xprintk(const char *fmt, ...); -#define tprintk(_fmt, _args...) printk("[%s] " _fmt, current->name, ##_args) +#define tprintk(_fmt, _args...) printk("[%s] " _fmt, current->name, ##_args) void xencons_rx(char *buf, unsigned len, struct pt_regs *regs); void xencons_tx(void); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/events.h --- a/extras/mini-os/include/events.h +++ b/extras/mini-os/include/events.h @@ -7,9 +7,9 @@ * File: events.h * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) - * + * * Date: Jul 2003, changes Jun 2005 - * + * * Environment: Xen Minimal OS * Description: Deals with events on the event channels * diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/gntmap.h --- a/extras/mini-os/include/gntmap.h +++ b/extras/mini-os/include/gntmap.h @@ -19,7 +19,7 @@ int gntmap_munmap(struct gntmap *map, unsigned long start_address, int count); void* -gntmap_map_grant_refs(struct gntmap *map, +gntmap_map_grant_refs(struct gntmap *map, uint32_t count, uint32_t *domids, int domids_stride, diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/hypervisor.h --- a/extras/mini-os/include/hypervisor.h +++ b/extras/mini-os/include/hypervisor.h @@ -1,8 +1,8 @@ /****************************************************************************** * hypervisor.h - * + * * Hypervisor handling. - * + * * * Copyright (c) 2002, K A Fraser * Copyright (c) 2005, Grzegorz Milos diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/ioremap.h --- a/extras/mini-os/include/ioremap.h +++ b/extras/mini-os/include/ioremap.h @@ -7,16 +7,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/lib-gpl.h --- a/extras/mini-os/include/lib-gpl.h +++ b/extras/mini-os/include/lib-gpl.h @@ -5,10 +5,10 @@ * * File: lib.h * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: - * + * Changes: + * * Date: Aug 2003 - * + * * Environment: Xen Minimal OS * Description: Random useful library functions, from Linux' * include/linux/kernel.h diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/lib.h --- a/extras/mini-os/include/lib.h +++ b/extras/mini-os/include/lib.h @@ -5,10 +5,10 @@ * * File: lib.h * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: - * + * Changes: + * * Date: Aug 2003 - * + * * Environment: Xen Minimal OS * Description: Random useful library functions, contains some freebsd stuff * diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/lwipopts.h --- a/extras/mini-os/include/lwipopts.h +++ b/extras/mini-os/include/lwipopts.h @@ -1,7 +1,7 @@ /* * lwipopts.h * - * Configuration for lwIP running on mini-os + * Configuration for lwIP running on mini-os * * Tim Deegan , July 2007 */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/mm.h --- a/extras/mini-os/include/mm.h +++ b/extras/mini-os/include/mm.h @@ -9,16 +9,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/netfront.h --- a/extras/mini-os/include/netfront.h +++ b/extras/mini-os/include/netfront.h @@ -15,7 +15,7 @@ extern struct wait_queue_head netfront_q #ifdef HAVE_LWIP /* Call this to bring up the netfront interface and the lwIP stack. - * N.B. _must_ be called from a thread; it's not safe to call this from + * N.B. _must_ be called from a thread; it's not safe to call this from * app_main(). */ void start_networking(void); void stop_networking(void); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/posix/net/if.h --- a/extras/mini-os/include/posix/net/if.h +++ b/extras/mini-os/include/posix/net/if.h @@ -1,5 +1,5 @@ /* - * This code is mostly taken from NetBSD net/if.h + * This code is mostly taken from NetBSD net/if.h * Changes: Stefano Stabellini * ****************************************************************************** diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/posix/sys/poll.h --- a/extras/mini-os/include/posix/sys/poll.h +++ b/extras/mini-os/include/posix/sys/poll.h @@ -1,5 +1,5 @@ /* - * This code is mostly taken from FreeBSD sys/sys/poll.h + * This code is mostly taken from FreeBSD sys/sys/poll.h * Changes: Stefano Stabellini * **************************************************************************** diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/sched.h --- a/extras/mini-os/include/sched.h +++ b/extras/mini-os/include/sched.h @@ -33,7 +33,7 @@ void idle_thread_fn(void *unused); #define clear_runnable(_thread) (_thread->flags &= ~RUNNABLE_FLAG) #define switch_threads(prev, next) arch_switch_threads(prev, next) - + /* Architecture specific setup of thread creation. */ struct thread* arch_create_thread(char *name, void (*function)(void *), void *data); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/semaphore.h --- a/extras/mini-os/include/semaphore.h +++ b/extras/mini-os/include/semaphore.h @@ -5,7 +5,7 @@ #include /* - * Implementation of semaphore in Mini-os is simple, because + * Implementation of semaphore in Mini-os is simple, because * there are no preemptive threads, the atomicity is guaranteed. */ @@ -32,10 +32,10 @@ struct rw_semaphore { #define __MUTEX_INITIALIZER(name) \ __SEMAPHORE_INITIALIZER(name,1) - + #define __DECLARE_SEMAPHORE_GENERIC(name,count) \ struct semaphore name = __SEMAPHORE_INITIALIZER(name,count) - + #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1) #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/sys/time.h --- a/extras/mini-os/include/sys/time.h +++ b/extras/mini-os/include/sys/time.h @@ -8,9 +8,9 @@ * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) * Robert Kaiser (kaiser@informatik.fh-wiesbaden.de) - * + * * Date: Jul 2003, changes: Jun 2005, Sep 2006 - * + * * Environment: Xen Minimal OS * Description: Time and timer functions * diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/time.h --- a/extras/mini-os/include/time.h +++ b/extras/mini-os/include/time.h @@ -8,9 +8,9 @@ * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) * Robert Kaiser (kaiser@informatik.fh-wiesbaden.de) - * + * * Date: Jul 2003, changes: Jun 2005, Sep 2006 - * + * * Environment: Xen Minimal OS * Description: Time and timer functions * @@ -27,7 +27,7 @@ * This value is adjusted by frequency drift. * NOW() returns the current time. * The other macros are for convenience to approximate short intervals - * of real time into system time + * of real time into system time */ typedef int64_t s_time_t; #define NOW() ((s_time_t)monotonic_clock()) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/types.h --- a/extras/mini-os/include/types.h +++ b/extras/mini-os/include/types.h @@ -5,10 +5,10 @@ * * File: types.h * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: - * + * Changes: + * * Date: May 2003 - * + * * Environment: Xen Minimal OS * Description: a random collection of type definitions * diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/wait.h --- a/extras/mini-os/include/wait.h +++ b/extras/mini-os/include/wait.h @@ -86,9 +86,9 @@ static inline void wake_up(struct wait_q wake(get_current()); \ remove_wait_queue(&wq, &__wait); \ local_irq_restore(flags); \ -} while(0) +} while(0) -#define wait_event(wq, condition) wait_event_deadline(wq, condition, 0) +#define wait_event(wq, condition) wait_event_deadline(wq, condition, 0) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/arch_limits.h --- a/extras/mini-os/include/x86/arch_limits.h +++ b/extras/mini-os/include/x86/arch_limits.h @@ -16,5 +16,5 @@ #define __STACK_SIZE_PAGE_ORDER 4 #define __STACK_SIZE (__PAGE_SIZE * (1 << __STACK_SIZE_PAGE_ORDER)) - + #endif /* __ARCH_LIMITS_H__ */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/arch_mm.h --- a/extras/mini-os/include/x86/arch_mm.h +++ b/extras/mini-os/include/x86/arch_mm.h @@ -9,16 +9,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/arch_sched.h --- a/extras/mini-os/include/x86/arch_sched.h +++ b/extras/mini-os/include/x86/arch_sched.h @@ -7,11 +7,11 @@ static inline struct thread* get_current(void) { struct thread **current; -#ifdef __i386__ +#ifdef __i386__ register unsigned long sp asm("esp"); #else register unsigned long sp asm("rsp"); -#endif +#endif current = (void *)(unsigned long)(sp & ~(__STACK_SIZE-1)); return *current; } @@ -21,5 +21,5 @@ extern void __arch_switch_threads(unsign #define arch_switch_threads(prev,next) __arch_switch_threads(&(prev)->sp, &(next)->sp) - + #endif /* __ARCH_SCHED_H__ */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/os.h --- a/extras/mini-os/include/x86/os.h +++ b/extras/mini-os/include/x86/os.h @@ -1,6 +1,6 @@ /****************************************************************************** * os.h - * + * * random collection of macros and definition */ @@ -72,7 +72,7 @@ void arch_fini(void); -/* +/* * The use of 'barrier' in the following reflects their use as local-lock * operations. Reentrancy must be prevented (e.g., __cli()) /before/ following * critical operations are executed. All critical operations must complete @@ -347,7 +347,7 @@ static inline unsigned long __xchg(unsig * @nr: Bit to clear * @addr: Address to count from * - * This operation is atomic and cannot be reordered. + * This operation is atomic and cannot be reordered. * It also implies a memory barrier. */ static __inline__ int test_and_clear_bit(int nr, volatile void * addr) @@ -515,7 +515,7 @@ static inline unsigned long __synch_cmpx static __inline__ void synch_set_bit(int nr, volatile void * addr) { - __asm__ __volatile__ ( + __asm__ __volatile__ ( "lock btsl %1,%0" : "=m" (ADDR) : "Ir" (nr) : "memory" ); } @@ -547,7 +547,7 @@ static __inline__ int synch_test_and_cle static __inline__ int synch_const_test_bit(int nr, const volatile void * addr) { - return ((1UL << (nr & 31)) & + return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0; } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/traps.h --- a/extras/mini-os/include/x86/traps.h +++ b/extras/mini-os/include/x86/traps.h @@ -1,13 +1,13 @@ -/* +/* **************************************************************************** * (C) 2005 - Grzegorz Milos - Intel Reseach Cambridge **************************************************************************** * * File: traps.h * Author: Grzegorz Milos (gm281@cam.ac.uk) - * + * * Date: Jun 2005 - * + * * Environment: Xen Minimal OS * Description: Deals with traps * @@ -46,7 +46,7 @@ struct pt_regs { unsigned long rbx; /* arguments: non interrupts/non tracing syscalls only save upto here*/ unsigned long r11; - unsigned long r10; + unsigned long r10; unsigned long r9; unsigned long r8; unsigned long rax; @@ -55,14 +55,14 @@ struct pt_regs { unsigned long rsi; unsigned long rdi; unsigned long orig_rax; -/* end of arguments */ +/* end of arguments */ /* cpu exception frame or undefined */ unsigned long rip; unsigned long cs; - unsigned long eflags; - unsigned long rsp; + unsigned long eflags; + unsigned long rsp; unsigned long ss; -/* top of stack page */ +/* top of stack page */ }; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/x86_32/hypercall-x86_32.h --- a/extras/mini-os/include/x86/x86_32/hypercall-x86_32.h +++ b/extras/mini-os/include/x86/x86_32/hypercall-x86_32.h @@ -1,23 +1,23 @@ /****************************************************************************** * hypercall-x86_32.h - * + * * Copied from XenLinux. - * + * * Copyright (c) 2002-2004, K A Fraser - * + * * This file may be distributed separately from the Linux kernel, or * incorporated into other software packages, subject to the following license: - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this source file (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/include/x86/x86_64/hypercall-x86_64.h --- a/extras/mini-os/include/x86/x86_64/hypercall-x86_64.h +++ b/extras/mini-os/include/x86/x86_64/hypercall-x86_64.h @@ -1,27 +1,27 @@ /****************************************************************************** * hypercall-x86_64.h - * + * * Copied from XenLinux. - * + * * Copyright (c) 2002-2004, K A Fraser - * + * * 64-bit updates: * Benjamin Liu * Jun Nakajima - * + * * This file may be distributed separately from the Linux kernel, or * incorporated into other software packages, subject to the following license: - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this source file (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, copy, modify, * merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE @@ -155,7 +155,7 @@ HYPERVISOR_stack_switch( static inline int HYPERVISOR_set_callbacks( - unsigned long event_address, unsigned long failsafe_address, + unsigned long event_address, unsigned long failsafe_address, unsigned long syscall_address) { return _hypercall3(int, set_callbacks, diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/kernel.c --- a/extras/mini-os/kernel.c +++ b/extras/mini-os/kernel.c @@ -1,29 +1,29 @@ /****************************************************************************** * kernel.c - * + * * Assorted crap goes here, including the initial C entry point, jumped at * from head.S. - * + * * Copyright (c) 2002-2003, K A Fraser & R Neugebauer * Copyright (c) 2005, Grzegorz Milos, Intel Research Cambridge * Copyright (c) 2006, Robert Kaiser, FH Wiesbaden - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -54,12 +54,12 @@ void setup_xen_features(void) xen_feature_info_t fi; int i, j; - for (i = 0; i < XENFEAT_NR_SUBMAPS; i++) + for (i = 0; i < XENFEAT_NR_SUBMAPS; i++) { fi.submap_idx = i; if (HYPERVISOR_xen_version(XENVER_get_features, &fi) < 0) break; - + for (j=0; j<32; j++) xen_features[i*32+j] = !!(fi.submap & 1<nr_pages); printk(" shared_inf: 0x%08lx(MA)\n", si->shared_info); - printk(" pt_base: %p(VA)\n", (void *)si->pt_base); + printk(" pt_base: %p(VA)\n", (void *)si->pt_base); printk("nr_pt_frames: 0x%lx\n", si->nr_pt_frames); - printk(" mfn_list: %p(VA)\n", (void *)si->mfn_list); + printk(" mfn_list: %p(VA)\n", (void *)si->mfn_list); printk(" mod_start: 0x%lx(VA)\n", si->mod_start); - printk(" mod_len: %lu\n", si->mod_len); + printk(" mod_len: %lu\n", si->mod_len); printk(" flags: 0x%x\n", (unsigned int)si->flags); - printk(" cmd_line: %s\n", + printk(" cmd_line: %s\n", si->cmd_line ? (const char *)si->cmd_line : "NULL"); /* Set up events. */ init_events(); - + /* ENABLE EVENT DELIVERY. This is disabled at start of day. */ __sti(); @@ -124,10 +124,10 @@ void start_kernel(start_info_t *si) /* Init grant tables */ init_gnttab(); - + /* Init scheduler. */ init_sched(); - + /* Init XenBus */ init_xenbus(); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lib/math.c --- a/extras/mini-os/lib/math.c +++ b/extras/mini-os/lib/math.c @@ -5,10 +5,10 @@ * * File: math.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: - * + * Changes: + * * Date: Aug 2003 - * + * * Environment: Xen Minimal OS * Description: Library functions for 64bit arith and other * from freebsd, files in sys/libkern/ (qdivrem.c, etc) diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lib/printf.c --- a/extras/mini-os/lib/printf.c +++ b/extras/mini-os/lib/printf.c @@ -5,7 +5,7 @@ * * File: printf.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: Grzegorz Milos (gm281@cam.ac.uk) + * Changes: Grzegorz Milos (gm281@cam.ac.uk) * * Date: Aug 2003, Aug 2005 * @@ -199,7 +199,7 @@ static char * number(char * buf, char * i = 0; if (num == 0) tmp[i++]='0'; - else + else { /* XXX KAF: force unsigned mod and div. */ unsigned long long num2=(unsigned long long)num; @@ -589,7 +589,7 @@ int vsscanf(const char * buf, const char if (!*fmt) break; ++fmt; - + /* skip this conversion. * advance both strings to next white space */ @@ -678,7 +678,7 @@ int vsscanf(const char * buf, const char break; case '%': /* looking for '%' in str */ - if (*str++ != '%') + if (*str++ != '%') return num; continue; default: diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lib/string.c --- a/extras/mini-os/lib/string.c +++ b/extras/mini-os/lib/string.c @@ -5,10 +5,10 @@ * * File: string.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) - * Changes: - * + * Changes: + * * Date: Aug 2003 - * + * * Environment: Xen Minimal OS * Description: Library function for string and memory manipulation * Origin unknown @@ -151,12 +151,12 @@ size_t strnlen(const char * s, size_t co char * strcat(char * dest, const char * src) { char *tmp = dest; - + while (*dest) dest++; - + while ((*dest++ = *src++) != '\0'); - + return tmp; } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lib/sys.c --- a/extras/mini-os/lib/sys.c +++ b/extras/mini-os/lib/sys.c @@ -529,8 +529,8 @@ int fstat(int fd, struct stat *buf) buf->st_uid = 0; buf->st_gid = 0; buf->st_size = 0; - buf->st_atime = - buf->st_mtime = + buf->st_atime = + buf->st_mtime = buf->st_ctime = time(NULL); return 0; } @@ -618,7 +618,7 @@ DIR *opendir(const char *name) struct dirent *readdir(DIR *dir) { return NULL; -} +} int closedir(DIR *dir) { @@ -1328,7 +1328,7 @@ unsupported_function_crash(umask); /* We could support that. */ unsupported_function_log(int, chdir, -1); -/* No dynamic library support. */ +/* No dynamic library support. */ unsupported_function_log(void *, dlopen, NULL); unsupported_function_log(void *, dlsym, NULL); unsupported_function_log(char *, dlerror, NULL); @@ -1368,7 +1368,7 @@ unsupported_function_log(char *, if_inde unsupported_function_log(struct if_nameindex *, if_nameindex, (struct if_nameindex *) NULL); unsupported_function_crash(if_freenameindex); -/* Linuxish abi for the Caml runtime, don't support +/* Linuxish abi for the Caml runtime, don't support Log, and return an error code if possible. If it is not possible to inform the application of an error, then crash instead! */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lib/xmalloc.c --- a/extras/mini-os/lib/xmalloc.c +++ b/extras/mini-os/lib/xmalloc.c @@ -1,4 +1,4 @@ -/* +/* **************************************************************************** * (C) 2005 - Grzegorz Milos - Intel Research Cambridge **************************************************************************** @@ -6,11 +6,11 @@ * File: xmaloc.c * Author: Grzegorz Milos (gm281@cam.ac.uk) * Samuel Thibault (samuel.thibault@eu.citrix.com) - * Changes: - * + * Changes: + * * Date: Aug 2005 * Jan 2008 - * + * * Environment: Xen Minimal OS * Description: simple memory allocator * @@ -286,9 +286,9 @@ void *_realloc(void *ptr, size_t size) maybe_split(hdr, pad->hdr_size + size, hdr->size); return ptr; } - + new = _xmalloc(size, DEFAULT_ALIGN); - if (new == NULL) + if (new == NULL) return NULL; memcpy(new, ptr, old_data_size); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lwip-arch.c --- a/extras/mini-os/lwip-arch.c +++ b/extras/mini-os/lwip-arch.c @@ -1,7 +1,7 @@ -/* +/* * lwip-arch.c * - * Arch-specific semaphores and mailboxes for lwIP running on mini-os + * Arch-specific semaphores and mailboxes for lwIP running on mini-os * * Tim Deegan , July 2007 */ @@ -44,7 +44,7 @@ void sys_sem_signal(sys_sem_t sem) * signaled. If the "timeout" argument is non-zero, the thread should * only be blocked for the specified time (measured in * milliseconds). - * + * * If the timeout argument is non-zero, the return value is the number of * milliseconds spent waiting for the semaphore to be signaled. If the * semaphore wasn't signaled within the specified time, the return value is @@ -76,9 +76,9 @@ uint32_t sys_arch_sem_wait(sys_sem_t sem if (sem->count > 0) { sem->count--; sys_arch_unprotect(prot); - return NSEC_TO_MSEC(NOW() - then); + return NSEC_TO_MSEC(NOW() - then); } - + sys_arch_unprotect(prot); return SYS_ARCH_TIMEOUT; } @@ -215,12 +215,12 @@ uint32_t sys_arch_mbox_tryfetch(sys_mbox * each thread has a list of timeouts which is repressented as a linked * list of sys_timeout structures. The sys_timeouts structure holds a * pointer to a linked list of timeouts. This function is called by - * the lwIP timeout scheduler and must not return a NULL value. + * the lwIP timeout scheduler and must not return a NULL value. * * In a single threadd sys_arch implementation, this function will * simply return a pointer to a global sys_timeouts variable stored in * the sys_arch module. */ -struct sys_timeouts *sys_arch_timeouts(void) +struct sys_timeouts *sys_arch_timeouts(void) { static struct sys_timeouts timeout; return &timeout; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/lwip-net.c --- a/extras/mini-os/lwip-net.c +++ b/extras/mini-os/lwip-net.c @@ -1,4 +1,4 @@ -/* +/* * lwip-net.c * * interface between lwIP's ethernet and Mini-os's netfront. @@ -11,9 +11,9 @@ /* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, @@ -22,21 +22,21 @@ * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. + * derived from this software without specific prior written permission. * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. * * This file is part of the lwIP TCP/IP stack. - * + * * Author: Adam Dunkels * */ @@ -118,7 +118,7 @@ low_level_output(struct netif *netif, st #if ETH_PAD_SIZE pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */ #endif - + LINK_STATS_INC(link.xmit); return ERR_OK; @@ -139,17 +139,17 @@ static err_t netfront_output(struct netif *netif, struct pbuf *p, struct ip_addr *ipaddr) { - + /* resolve hardware address, then send (or queue) packet */ return etharp_output(netif, p, ipaddr); - + } /* * netfront_input(): * * This function should be called when a packet is ready to be read - * from the interface. + * from the interface. * */ @@ -162,7 +162,7 @@ netfront_input(struct netif *netif, unsi #if ETH_PAD_SIZE len += ETH_PAD_SIZE; /* allow room for Ethernet padding */ #endif - + /* move received packet into a new pbuf */ p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL); if (p == NULL) { @@ -174,7 +174,7 @@ netfront_input(struct netif *netif, unsi #if ETH_PAD_SIZE pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */ #endif - + /* We iterate over the pbuf chain until we have read the entire * packet into the pbuf. */ for(q = p; q != NULL && len > 0; q = q->next) { @@ -196,7 +196,7 @@ netfront_input(struct netif *netif, unsi ethhdr = p->payload; ethhdr = p->payload; - + switch (htons(ethhdr->type)) { /* IP packet? */ case ETHTYPE_IP: @@ -213,7 +213,7 @@ netfront_input(struct netif *netif, unsi /* Could not store it, drop */ pbuf_free(p); break; - + case ETHTYPE_ARP: /* pass p to ARP module */ etharp_arp_input(netif, (struct eth_addr *) netif->hwaddr, p); @@ -227,10 +227,10 @@ netfront_input(struct netif *netif, unsi } -/* +/* * netif_rx(): overrides the default netif_rx behaviour in the netfront driver. - * - * Pull received packets into a pbuf queue for the low_level_input() + * + * Pull received packets into a pbuf queue for the low_level_input() * function to pass up to lwIP. */ @@ -290,14 +290,14 @@ netif_netfront_init(struct netif *netif) netif->ifoutnucastpkts = 0; netif->ifoutdiscards = 0; #endif - + netif->name[0] = IFNAME0; netif->name[1] = IFNAME1; netif->output = netfront_output; netif->linkoutput = low_level_output; - + the_interface = netif; - + /* set MAC hardware address */ netif->hwaddr_len = 6; netif->hwaddr[0] = mac[0]; @@ -312,7 +312,7 @@ netif_netfront_init(struct netif *netif) /* maximum transfer unit */ netif->mtu = 1500; - + /* broadcast capability */ netif->flags = NETIF_FLAG_BROADCAST; @@ -333,10 +333,10 @@ static void tcpip_bringup_finished(void up(&tcpip_is_up); } -/* - * Utility function to bring the whole lot up. Call this from app_main() +/* + * Utility function to bring the whole lot up. Call this from app_main() * or similar -- it starts netfront and have lwIP start its thread, - * which calls back to tcpip_bringup_finished(), which + * which calls back to tcpip_bringup_finished(), which * lets us know it's OK to continue. */ void start_networking(void) @@ -350,7 +350,7 @@ void start_networking(void) tprintk("Waiting for network.\n"); dev = init_netfront(NULL, NULL, rawmac, &ip); - + if (ip) { ipaddr.addr = inet_addr(ip); if (IN_CLASSA(ntohl(ipaddr.addr))) @@ -364,13 +364,13 @@ void start_networking(void) } tprintk("IP %x netmask %x gateway %x.\n", ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr)); - + tprintk("TCP/IP bringup begins.\n"); - + netif = xmalloc(struct netif); tcpip_init(tcpip_bringup_finished, netif); - - netif_add(netif, &ipaddr, &netmask, &gw, rawmac, + + netif_add(netif, &ipaddr, &netmask, &gw, rawmac, netif_netfront_init, ip_input); netif_set_default(netif); netif_set_up(netif); diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/mm.c --- a/extras/mini-os/mm.c +++ b/extras/mini-os/mm.c @@ -1,4 +1,4 @@ -/* +/* **************************************************************************** * (C) 2003 - Rolf Neugebauer - Intel Research Cambridge * (C) 2005 - Grzegorz Milos - Intel Research Cambridge @@ -7,9 +7,9 @@ * File: mm.c * Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk) * Changes: Grzegorz Milos - * + * * Date: Aug 2003, chages Aug 2005 - * + * * Environment: Xen Minimal OS * Description: memory management related functions * contains buddy page allocator from Xen. @@ -21,16 +21,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -62,7 +62,7 @@ static unsigned long *alloc_bitmap; /* * Hint regarding bitwise arithmetic in map_{alloc,free}: - * -(1<= n. + * -(1<= n. * (1< 1000) + if(nr_pages > 1000) { DEBUG("Can only pring 1000 pages. Increase buffer size."); } - + for(order=0; order < FREELIST_SIZE; order++) { head = free_head[order]; @@ -264,12 +264,12 @@ unsigned long alloc_pages(int order) /* Find smallest order which can satisfy the request. */ for ( i = order; i < FREELIST_SIZE; i++ ) { - if ( !FREELIST_EMPTY(free_head[i]) ) + if ( !FREELIST_EMPTY(free_head[i]) ) break; } if ( i == FREELIST_SIZE ) goto no_memory; - + /* Unlink a chunk. */ alloc_ch = free_head[i]; free_head[i] = alloc_ch->next; @@ -293,7 +293,7 @@ unsigned long alloc_pages(int order) spare_ch->next->pprev = &spare_ch->next; free_head[i] = spare_ch; } - + map_alloc(PHYS_PFN(to_phys(alloc_ch)), 1UL<level != order) break; - + /* Merge with predecessor */ - freed_ch = to_merge_ch; + freed_ch = to_merge_ch; } - else + else { to_merge_ch = (chunk_head_t *)((char *)freed_ch + mask); if(allocated_in_map(virt_to_pfn(to_merge_ch)) || to_merge_ch->level != order) break; - + /* Merge with successor */ freed_ct = (chunk_tail_t *)((char *)to_merge_ch + mask) - 1; } - + /* We are commited to merging, unlink the chunk */ *(to_merge_ch->pprev) = to_merge_ch->next; to_merge_ch->next->pprev = to_merge_ch->pprev; - + order++; } @@ -355,10 +355,10 @@ void free_pages(void *pointer, int order freed_ch->next = free_head[order]; freed_ch->pprev = &free_head[order]; freed_ct->level = order; - + freed_ch->next->pprev = &freed_ch->next; - free_head[order] = freed_ch; - + free_head[order] = freed_ch; + } int free_physical_pages(xen_pfn_t *mfns, int n) @@ -382,7 +382,7 @@ void *sbrk(ptrdiff_t increment) printk("Heap exhausted: %p + %lx = %p > %p\n", old_brk, increment, new_brk, heap_end); return NULL; } - + if (new_brk > heap_mapped) { unsigned long n = (new_brk - heap_mapped + PAGE_SIZE - 1) / PAGE_SIZE; do_map_zero(heap_mapped, n); @@ -409,13 +409,13 @@ void init_mm(void) * now we can initialise the page allocator */ printk("MM: Initialise page allocator for %lx(%lx)-%lx(%lx)\n", - (u_long)to_virt(PFN_PHYS(start_pfn)), PFN_PHYS(start_pfn), + (u_long)to_virt(PFN_PHYS(start_pfn)), PFN_PHYS(start_pfn), (u_long)to_virt(PFN_PHYS(max_pfn)), PFN_PHYS(max_pfn)); init_page_allocator(PFN_PHYS(start_pfn), PFN_PHYS(max_pfn)); printk("MM: done\n"); arch_init_p2m(max_pfn); - + arch_init_demand_mapping_area(max_pfn); } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/netfront.c --- a/extras/mini-os/netfront.c +++ b/extras/mini-os/netfront.c @@ -1,4 +1,4 @@ -/* Minimal network driver for Mini-OS. +/* Minimal network driver for Mini-OS. * Copyright (c) 2006-2007 Jacob Gorm Hansen, University of Copenhagen. * Based on netfront.c from Xen Linux. * @@ -162,7 +162,7 @@ moretodo: void* page = buf->page; /* We are sure to have free gnttab entries since they got released above */ - buf->gref = req->gref = + buf->gref = req->gref = gnttab_grant_access(dev->dom,virt_to_mfn(page),0); req->id = id; @@ -171,7 +171,7 @@ moretodo: wmb(); dev->rx.req_prod_pvt = req_prod + i; - + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&dev->rx, notify); if (notify) notify_remote_via_evtchn(dev->evtchn); @@ -189,7 +189,7 @@ void network_tx_buf_gc(struct netfront_d prod = dev->tx.sring->rsp_prod; rmb(); /* Ensure we see responses up to 'rp'. */ - for (cons = dev->tx.rsp_cons; cons != prod; cons++) + for (cons = dev->tx.rsp_cons; cons != prod; cons++) { struct netif_tx_response *txrsp; struct net_buffer *buf; @@ -571,12 +571,12 @@ void init_rx_buffers(struct netfront_dev int notify; /* Rebuild the RX buffer freelist and the RX ring itself. */ - for (requeue_idx = 0, i = 0; i < NET_RX_RING_SIZE; i++) + for (requeue_idx = 0, i = 0; i < NET_RX_RING_SIZE; i++) { struct net_buffer* buf = &dev->rx_buffers[requeue_idx]; req = RING_GET_REQUEST(&dev->rx, requeue_idx); - buf->gref = req->gref = + buf->gref = req->gref = gnttab_grant_access(dev->dom,virt_to_mfn(buf->page),0); req->id = requeue_idx; @@ -588,7 +588,7 @@ void init_rx_buffers(struct netfront_dev RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&dev->rx, notify); - if (notify) + if (notify) notify_remote_via_evtchn(dev->evtchn); dev->rx.sring->rsp_event = dev->rx.rsp_cons + 1; @@ -623,7 +623,7 @@ void netfront_xmit(struct netfront_dev * memcpy(page,data,len); - buf->gref = + buf->gref = tx->gref = gnttab_grant_access(dev->dom,virt_to_mfn(page),1); tx->offset=0; diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/pcifront.c --- a/extras/mini-os/pcifront.c +++ b/extras/mini-os/pcifront.c @@ -1,4 +1,4 @@ -/* Minimal PCI driver for Mini-OS. +/* Minimal PCI driver for Mini-OS. * Copyright (c) 2007-2008 Samuel Thibault. * Based on blkfront.c. */ @@ -157,7 +157,7 @@ struct pcifront_dev *init_pcifront(char printk("******************* PCIFRONT for %s **********\n\n\n", nodename); snprintf(path, sizeof(path), "%s/backend-id", nodename); - dom = xenbus_read_integer(path); + dom = xenbus_read_integer(path); if (dom == -1) { printk("no backend\n"); return NULL; @@ -518,7 +518,7 @@ int pcifront_enable_msi(struct pcifront_ op.devfn = PCI_DEVFN(slot, fun); pcifront_op(dev, &op); - + if (op.err) return op.err; else @@ -543,7 +543,7 @@ int pcifront_disable_msi(struct pcifront op.devfn = PCI_DEVFN(slot, fun); pcifront_op(dev, &op); - + return op.err; } @@ -572,7 +572,7 @@ int pcifront_enable_msix(struct pcifront memcpy(op.msix_entries, entries, n * sizeof(*entries)); pcifront_op(dev, &op); - + if (op.err) return op.err; @@ -600,6 +600,6 @@ int pcifront_disable_msix(struct pcifron op.devfn = PCI_DEVFN(slot, fun); pcifront_op(dev, &op); - + return op.err; } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/sched.c --- a/extras/mini-os/sched.c +++ b/extras/mini-os/sched.c @@ -1,4 +1,4 @@ -/* +/* **************************************************************************** * (C) 2005 - Grzegorz Milos - Intel Research Cambridge **************************************************************************** @@ -6,13 +6,13 @@ * File: sched.c * Author: Grzegorz Milos * Changes: Robert Kaiser - * + * * Date: Aug 2005 - * + * * Environment: Xen Minimal OS * Description: simple scheduler for Mini-Os * - * The scheduler is non-preemptive (cooperative), and schedules according + * The scheduler is non-preemptive (cooperative), and schedules according * to Round Robin algorithm. * **************************************************************************** @@ -22,16 +22,16 @@ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ @@ -79,7 +79,7 @@ void schedule(void) unsigned long flags; prev = current; - local_irq_save(flags); + local_irq_save(flags); if (in_callback) { printk("Must not call schedule() from a callback\n"); @@ -106,7 +106,7 @@ void schedule(void) else if (thread->wakeup_time < min_wakeup_time) min_wakeup_time = thread->wakeup_time; } - if(is_runnable(thread)) + if(is_runnable(thread)) { next = thread; /* Put this thread on the end of the list */ @@ -255,17 +255,17 @@ void th_f1(void *data) schedule(); printk("Thread \"%s\" releases the semaphore\n", current->name); up(&mutex); - - + + gettimeofday(&tv1, NULL); for(;;) { gettimeofday(&tv2, NULL); if(tv2.tv_sec - tv1.tv_sec > 2) break; } - - - schedule(); + + + schedule(); } } diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/test.c --- a/extras/mini-os/test.c +++ b/extras/mini-os/test.c @@ -1,28 +1,28 @@ /****************************************************************************** * test.c - * + * * Test code for all the various frontends; split from kernel.c - * + * * Copyright (c) 2002-2003, K A Fraser & R Neugebauer * Copyright (c) 2005, Grzegorz Milos, Intel Research Cambridge * Copyright (c) 2006, Robert Kaiser, FH Wiesbaden - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ diff -r 121ae49aabcb -r 7784cd3925c5 extras/mini-os/xenbus/xenbus.c --- a/extras/mini-os/xenbus/xenbus.c +++ b/extras/mini-os/xenbus/xenbus.c @@ -1,15 +1,15 @@ -/* +/* **************************************************************************** * (C) 2006 - Cambridge University **************************************************************************** * * File: xenbus.c - * Author: Steven Smith (sos22@cam.ac.uk) + * Author: Steven Smith (sos22@cam.ac.uk) * Changes: Grzegorz Milos (gm281@cam.ac.uk) * Changes: John D. Ramsdell - * + * * Date: Jun 2006, chages Aug 2005 - * + * * Environment: Xen Minimal OS * Description: Minimal implementation of xenbus * @@ -51,7 +51,7 @@ static struct watch { xenbus_event_queue *events; struct watch *next; } *watches; -struct xenbus_req_info +struct xenbus_req_info { int in_use:1; struct wait_queue_head waitq; @@ -196,10 +196,10 @@ static void xenbus_thread_func(void *ign struct xsd_sockmsg msg; unsigned prod = xenstore_buf->rsp_prod; - for (;;) + for (;;) { wait_event(xb_waitq, prod != xenstore_buf->rsp_prod); - while (1) + while (1) { prod = xenstore_buf->rsp_prod; DEBUG("Rsp_cons %d, rsp_prod %d.\n", xenstore_buf->rsp_cons, @@ -298,7 +298,7 @@ static int allocate_xenbus_id(void) static int probe; int o_probe; - while (1) + while (1) { spin_lock(&req_lock); if (nr_live_reqs < NR_REQS) @@ -308,7 +308,7 @@ static int allocate_xenbus_id(void) } o_probe = probe; - for (;;) + for (;;) { if (!req_info[o_probe].in_use) break; @@ -373,7 +373,7 @@ static void xb_write(int type, int req_i /* Wait for the ring to drain to the point where we can send the message. */ prod = xenstore_buf->req_prod; - if (prod + len - xenstore_buf->req_cons > XENSTORE_RING_SIZE) + if (prod + len - xenstore_buf->req_cons > XENSTORE_RING_SIZE) { /* Wait for there to be space on the ring */ DEBUG("prod %d, len %d, cons %d, size %d; waiting.\n", @@ -389,7 +389,7 @@ static void xb_write(int type, int req_i overflowing the ring. Do so. */ total_off = 0; req_off = 0; - while (total_off < len) + while (total_off < len) { this_chunk = min(cur_req->len - req_off, XENSTORE_RING_SIZE - MASK_XENSTORE_IDX(prod)); @@ -398,7 +398,7 @@ static void xb_write(int type, int req_i prod += this_chunk; req_off += this_chunk; total_off += this_chunk; - if (req_off == cur_req->len) + if (req_off == cur_req->len) { req_off = 0; if (cur_req == &header_req) @@ -465,7 +465,7 @@ static char *errmsg(struct xsd_sockmsg * res[rep->len] = 0; free(rep); return res; -} +} /* Send a debug message to xenbus. Can block. */ static void xenbus_debug_msg(const char *msg) @@ -535,7 +535,7 @@ char *xenbus_read(xenbus_transaction_t x char *xenbus_write(xenbus_transaction_t xbt, const char *path, const char *value) { - struct write_req req[] = { + struct write_req req[] = { {path, strlen(path) + 1}, {value, strlen(value)}, }; @@ -552,7 +552,7 @@ char* xenbus_watch_path_token( xenbus_tr { struct xsd_sockmsg *rep; - struct write_req req[] = { + struct write_req req[] = { {path, strlen(path) + 1}, {token, strlen(token) + 1}, }; @@ -582,7 +582,7 @@ char* xenbus_unwatch_path_token( xenbus_ { struct xsd_sockmsg *rep; - struct write_req req[] = { + struct write_req req[] = { {path, strlen(path) + 1}, {token, strlen(token) + 1}, }; @@ -644,7 +644,7 @@ char *xenbus_get_perms(xenbus_transactio char *xenbus_set_perms(xenbus_transaction_t xbt, const char *path, domid_t dom, char perm) { char value[PERM_MAX_SIZE]; - struct write_req req[] = { + struct write_req req[] = { {path, strlen(path) + 1}, {value, 0}, }; @@ -786,7 +786,7 @@ static void do_ls_test(const char *pre) free(msg); return; } - for (x = 0; dirs[x]; x++) + for (x = 0; dirs[x]; x++) { printk("ls %s[%d] -> %s\n", pre, x, dirs[x]); free(dirs[x]); _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Mon Nov 26 22:28:54 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Mon, 26 Nov 2012 22:28:54 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Td7AH-0003qK-Sw; Mon, 26 Nov 2012 22:28:33 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Td7AF-0003q6-FF for xen-devel@lists.xen.org; Mon, 26 Nov 2012 22:28:32 +0000 Received: from [85.158.139.211:28420] by server-13.bemta-5.messagelabs.com id FE/97-27809-E0DE3B05; Mon, 26 Nov 2012 22:28:30 +0000 X-Env-Sender: jfehlig@suse.com X-Msg-Ref: server-10.tower-206.messagelabs.com!1353968906!19658953!1 X-Originating-IP: [137.65.248.124] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 11806 invoked from network); 26 Nov 2012 22:28:26 -0000 Received: from inet-orm.provo.novell.com (HELO mail.novell.com) (137.65.248.124) by server-10.tower-206.messagelabs.com with SMTP; 26 Nov 2012 22:28:26 -0000 Received: from jfehlig1.provo.novell.com ([137.65.135.33]) by mail.novell.com with ESMTP; Mon, 26 Nov 2012 15:28:20 -0700 From: Jim Fehlig To: libvir-list@redhat.com Date: Mon, 26 Nov 2012 15:28:15 -0700 Message-Id: <1353968895-16014-1-git-send-email-jfehlig@suse.com> X-Mailer: git-send-email 1.7.10.4 Cc: xen-devel@lists.xen.org Subject: [Xen-devel] [PATCH] Convert libxl driver to Xen 4.2 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 Based on a patch originally authored by Daniel De Graaf http://lists.xen.org/archives/html/xen-devel/2012-05/msg00565.html This patch converts the Xen libxl driver to support only Xen >= 4.2. Support for Xen 4.1 libxl is dropped since that version of libxl is designated 'technology preview' only and is incompatible with Xen 4.2 libxl. Additionally, the default toolstack in Xen 4.1 is still xend, for which libvirt has a stable, functional driver. --- configure.ac | 8 +- docs/drvxen.html.in | 8 + libvirt.spec.in | 4 +- src/libxl/libxl_conf.c | 370 ++++++++++++++--------------------- src/libxl/libxl_conf.h | 17 +- src/libxl/libxl_driver.c | 488 +++++++++++++++++++++++++++------------------- 6 files changed, 459 insertions(+), 436 deletions(-) diff --git a/configure.ac b/configure.ac index 849d787..c1a9943 100644 --- a/configure.ac +++ b/configure.ac @@ -717,16 +717,14 @@ if test "$with_libxl" != "no" ; then fi CFLAGS="$CFLAGS $LIBXL_CFLAGS" LIBS="$LIBS $LIBXL_LIBS" - AC_CHECK_LIB([xenlight], [libxl_domain_create_new], [ + AC_CHECK_LIB([xenlight], [libxl_ctx_alloc], [ with_libxl=yes - LIBXL_LIBS="$LIBXL_LIBS -lxenlight -lxenstore -lxenctrl -lxenguest -luuid -lutil -lblktapctl" + LIBXL_LIBS="$LIBXL_LIBS -lxenlight" ],[ if test "$with_libxl" = "yes"; then fail=1 fi with_libxl=no - ],[ - -lxenstore -lxenctrl -lxenguest -luuid -lutil -lblktapctl ]) fi @@ -734,7 +732,7 @@ LIBS="$old_LIBS" CFLAGS="$old_CFLAGS" if test $fail = 1; then - AC_MSG_ERROR([You must install the libxl Library to compile libxenlight driver with -lxl]) + AC_MSG_ERROR([You must install the libxl Library from Xen >= 4.2 to compile libxenlight driver with -lxl]) fi if test "$with_libxl" = "yes"; then diff --git a/docs/drvxen.html.in b/docs/drvxen.html.in index 0bca935..06bd911 100644 --- a/docs/drvxen.html.in +++ b/docs/drvxen.html.in @@ -53,6 +53,14 @@ the /etc/xen directory. It is important not to place any other non-config files in this directory. +
  • + libxl: Starting with Xen 4.2, the legacy XenD/xm + toolstack is deprecated in favor of libxl, also commonly called + libxenlight. libvirt supports this new Xen toolstack via the + libxl driver. If XenD is enabled, the legacy xen driver consisting + of the above mentioned channels will be used. If XenD is disabled, + the libxl driver will be used. +

    • Connections to Xen driver

    diff --git a/libvirt.spec.in b/libvirt.spec.in index 35c103b..bb274f5 100644 --- a/libvirt.spec.in +++ b/libvirt.spec.in @@ -188,8 +188,8 @@ %endif %endif -# Fedora doesn't have new enough Xen for libxl until F16 -%if 0%{?fedora} && 0%{?fedora} < 16 +# Fedora doesn't have new enough Xen for libxl until F18 +%if 0%{?fedora} && 0%{?fedora} < 18 %define with_libxl 0 %endif diff --git a/src/libxl/libxl_conf.c b/src/libxl/libxl_conf.c index 1c3130b..73abdfa 100644 --- a/src/libxl/libxl_conf.c +++ b/src/libxl/libxl_conf.c @@ -41,6 +41,7 @@ #include "capabilities.h" #include "libxl_driver.h" #include "libxl_conf.h" +#include "libxl_utils.h" #include "storage_file.h" @@ -62,6 +63,52 @@ struct guest_arch { static const char *xen_cap_re = "(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(x86_32|x86_64|ia64|powerpc64)(p|be)?"; static regex_t xen_cap_rec; +/* + * Copied from split_string_into_string_list() in + * $xen-sources/tools/libxl/xl_cmdimpl.c, which is licensed LGPL v2.1. + */ +static int +libxlSplitStringIntoStringList(const char *str, + const char *delim, + libxl_string_list *psl) +{ + char *s, *saveptr; + const char *p; + libxl_string_list sl; + int i = 0, nr = 0; + + s = strdup(str); + if (s == NULL) { + virReportOOMError(); + return -1; + } + + /* Count number of entries */ + p = strtok_r(s, delim, &saveptr); + do { + nr++; + } while ((p = strtok_r(NULL, delim, &saveptr))); + + VIR_FREE(s); + s = strdup(str); + + if (VIR_ALLOC_N(sl, nr + 1) < 0) { + virReportOOMError(); + VIR_FREE(s); + return -1; + } + + p = strtok_r(s, delim, &saveptr); + do { + sl[i] = strdup(p); + i++; + } while ((p = strtok_r(NULL, delim, &saveptr))); + sl[i] = NULL; + + *psl = sl; + VIR_FREE(s); + return 0; +} static int libxlNextFreeVncPort(libxlDriverPrivatePtr driver, int startPort) @@ -360,18 +407,36 @@ libxlMakeCapabilitiesInternal(const char *hostmachine, } static int -libxlMakeDomCreateInfo(virDomainDefPtr def, libxl_domain_create_info *c_info) +libxlMakeDomCreateInfo(libxlDriverPrivatePtr driver, + virDomainDefPtr def, + libxl_domain_create_info *c_info) { char uuidstr[VIR_UUID_STRING_BUFLEN]; - libxl_init_create_info(c_info); + libxl_domain_create_info_init(c_info); + + if (STREQ(def->os.type, "hvm")) + c_info->type = LIBXL_DOMAIN_TYPE_HVM; + else + c_info->type = LIBXL_DOMAIN_TYPE_PV; - c_info->hvm = STREQ(def->os.type, "hvm"); if ((c_info->name = strdup(def->name)) == NULL) { virReportOOMError(); goto error; } + if (def->nseclabels && + def->seclabels[0]->type == VIR_DOMAIN_SECLABEL_STATIC) { + if (libxl_flask_context_to_sid(driver->ctx, + def->seclabels[0]->label, + strlen(def->seclabels[0]->label), + &c_info->ssidref)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("libxenlight failed to resolve security label '%s'"), + def->seclabels[0]->label); + } + } + virUUIDFormat(def->uuid, uuidstr); if (libxl_uuid_from_string(&c_info->uuid, uuidstr)) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -382,7 +447,7 @@ libxlMakeDomCreateInfo(virDomainDefPtr def, libxl_domain_create_info *c_info) return 0; error: - libxl_domain_create_info_destroy(c_info); + libxl_domain_create_info_dispose(c_info); return -1; } @@ -393,26 +458,25 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) int hvm = STREQ(def->os.type, "hvm"); int i; - /* Currently, libxenlight only supports 32 vcpus per domain. - * cur_vcpus member of struct libxl_domain_build_info is defined - * as an int, but its semantic is a bitmap of online vcpus, so - * only 32 can be represented. + /* + * libxl in Xen 4.2 supports up to 128 vcpus, cur_vcpus was replaced + * by avail_vcpus of type libxl_bitmap */ - if (def->maxvcpus > 32 || def->vcpus > 32) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("This version of libxenlight only supports 32 " - "vcpus per domain")); + if (def->maxvcpus > LIBXL_MAXVCPUS || def->vcpus > LIBXL_MAXVCPUS) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("This version of libxenlight only supports %u " + "vcpus per domain"), LIBXL_MAXVCPUS); return -1; } - libxl_init_build_info(b_info, &d_config->c_info); + libxl_domain_build_info_init(b_info); - b_info->hvm = hvm; - b_info->max_vcpus = def->maxvcpus; - if (def->vcpus == 32) - b_info->cur_vcpus = (uint32_t) -1; + if (hvm) + libxl_domain_build_info_init_type(b_info, LIBXL_DOMAIN_TYPE_HVM); else - b_info->cur_vcpus = (1 << def->vcpus) - 1; + libxl_domain_build_info_init_type(b_info, LIBXL_DOMAIN_TYPE_PV); + b_info->max_vcpus = def->maxvcpus; + libxl_bitmap_set((&b_info->avail_vcpus), def->vcpus); if (def->clock.ntimers > 0 && def->clock.timers[0]->name == VIR_DOMAIN_TIMER_NAME_TSC) { switch (def->clock.timers[0]->mode) { @@ -426,16 +490,20 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) b_info->tsc_mode = 1; } } + b_info->sched_params.weight = 1000; b_info->max_memkb = def->mem.max_balloon; b_info->target_memkb = def->mem.cur_balloon; if (hvm) { - b_info->u.hvm.pae = def->features & (1 << VIR_DOMAIN_FEATURE_PAE); - b_info->u.hvm.apic = def->features & (1 << VIR_DOMAIN_FEATURE_APIC); - b_info->u.hvm.acpi = def->features & (1 << VIR_DOMAIN_FEATURE_ACPI); + libxl_defbool_set(&b_info->u.hvm.pae, + def->features & (1 << VIR_DOMAIN_FEATURE_PAE)); + libxl_defbool_set(&b_info->u.hvm.apic, + def->features & (1 << VIR_DOMAIN_FEATURE_APIC)); + libxl_defbool_set(&b_info->u.hvm.acpi, + def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)); for (i = 0; i < def->clock.ntimers; i++) { if (def->clock.timers[i]->name == VIR_DOMAIN_TIMER_NAME_HPET && def->clock.timers[i]->present == 1) { - b_info->u.hvm.hpet = 1; + libxl_defbool_set(&b_info->u.hvm.hpet, 1); } } @@ -446,7 +514,7 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) * 256 pages (1MB) per vcpu, plus 1 page per MiB of RAM for the P2M map, * plus 1 page per MiB of RAM to shadow the resident processes. */ - b_info->shadow_memkb = 4 * (256 * b_info->cur_vcpus + + b_info->shadow_memkb = 4 * (256 * libxl_bitmap_count_set(&b_info->avail_vcpus) + 2 * (b_info->max_memkb / 1024)); } else { if (def->os.bootloader) { @@ -456,10 +524,11 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) } } if (def->os.bootloaderArgs) { - if ((b_info->u.pv.bootloader_args = strdup(def->os.bootloaderArgs)) == NULL) { - virReportOOMError(); + if (libxlSplitStringIntoStringList(def->os.bootloaderArgs, + " \t\n", + &b_info->u.pv.bootloader_args) + < 0) goto error; - } } if (def->os.cmdline) { if ((b_info->u.pv.cmdline = strdup(def->os.cmdline)) == NULL) { @@ -469,14 +538,14 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) } if (def->os.kernel) { /* libxl_init_build_info() sets kernel.path = strdup("hvmloader") */ - VIR_FREE(b_info->kernel.path); - if ((b_info->kernel.path = strdup(def->os.kernel)) == NULL) { + VIR_FREE(b_info->u.pv.kernel); + if ((b_info->u.pv.kernel = strdup(def->os.kernel)) == NULL) { virReportOOMError(); goto error; } } if (def->os.initrd) { - if ((b_info->u.pv.ramdisk.path = strdup(def->os.initrd)) == NULL) { + if ((b_info->u.pv.ramdisk = strdup(def->os.initrd)) == NULL) { virReportOOMError(); goto error; } @@ -486,13 +555,12 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) return 0; error: - libxl_domain_build_info_destroy(b_info); + libxl_domain_build_info_dispose(b_info); return -1; } int -libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, - libxl_device_disk *x_disk) +libxlMakeDisk(virDomainDiskDefPtr l_disk, libxl_device_disk *x_disk) { if (l_disk->src && (x_disk->pdev_path = strdup(l_disk->src)) == NULL) { virReportOOMError(); @@ -509,22 +577,22 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, STREQ(l_disk->driverName, "tap2")) { switch (l_disk->format) { case VIR_STORAGE_FILE_QCOW: - x_disk->format = DISK_FORMAT_QCOW; - x_disk->backend = DISK_BACKEND_QDISK; + x_disk->format = LIBXL_DISK_FORMAT_QCOW; + x_disk->backend = LIBXL_DISK_BACKEND_QDISK; break; case VIR_STORAGE_FILE_QCOW2: - x_disk->format = DISK_FORMAT_QCOW2; - x_disk->backend = DISK_BACKEND_QDISK; + x_disk->format = LIBXL_DISK_FORMAT_QCOW2; + x_disk->backend = LIBXL_DISK_BACKEND_QDISK; break; case VIR_STORAGE_FILE_VHD: - x_disk->format = DISK_FORMAT_VHD; - x_disk->backend = DISK_BACKEND_TAP; + x_disk->format = LIBXL_DISK_FORMAT_VHD; + x_disk->backend = LIBXL_DISK_BACKEND_TAP; break; case VIR_STORAGE_FILE_NONE: /* No subtype specified, default to raw/tap */ case VIR_STORAGE_FILE_RAW: - x_disk->format = DISK_FORMAT_RAW; - x_disk->backend = DISK_BACKEND_TAP; + x_disk->format = LIBXL_DISK_FORMAT_RAW; + x_disk->backend = LIBXL_DISK_BACKEND_TAP; break; default: virReportError(VIR_ERR_INTERNAL_ERROR, @@ -533,11 +601,11 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, return -1; } } else if (STREQ(l_disk->driverName, "file")) { - x_disk->format = DISK_FORMAT_RAW; - x_disk->backend = DISK_BACKEND_TAP; + x_disk->format = LIBXL_DISK_FORMAT_RAW; + x_disk->backend = LIBXL_DISK_BACKEND_TAP; } else if (STREQ(l_disk->driverName, "phy")) { - x_disk->format = DISK_FORMAT_RAW; - x_disk->backend = DISK_BACKEND_PHY; + x_disk->format = LIBXL_DISK_FORMAT_RAW; + x_disk->backend = LIBXL_DISK_BACKEND_PHY; } else { virReportError(VIR_ERR_INTERNAL_ERROR, _("libxenlight does not support disk driver %s"), @@ -546,12 +614,12 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, } } else { /* No driverName - default to raw/tap?? */ - x_disk->format = DISK_FORMAT_RAW; - x_disk->backend = DISK_BACKEND_TAP; + x_disk->format = LIBXL_DISK_FORMAT_RAW; + x_disk->backend = LIBXL_DISK_BACKEND_TAP; } - /* How to set unpluggable? */ - x_disk->unpluggable = 1; + /* XXX is this right? */ + x_disk->removable = 1; x_disk->readwrite = !l_disk->readonly; x_disk->is_cdrom = l_disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM ? 1 : 0; if (l_disk->transient) { @@ -560,8 +628,6 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, return -1; } - x_disk->domid = def->id; - return 0; } @@ -579,7 +645,7 @@ libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config) } for (i = 0; i < ndisks; i++) { - if (libxlMakeDisk(def, l_disks[i], &x_disks[i]) < 0) + if (libxlMakeDisk(l_disks[i], &x_disks[i]) < 0) goto error; } @@ -590,19 +656,19 @@ libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config) error: for (i = 0; i < ndisks; i++) - libxl_device_disk_destroy(&x_disks[i]); + libxl_device_disk_dispose(&x_disks[i]); VIR_FREE(x_disks); return -1; } int -libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, - libxl_device_nic *x_nic) +libxlMakeNic(virDomainNetDefPtr l_nic, libxl_device_nic *x_nic) { - // TODO: Where is mtu stored? - //x_nics[i].mtu = 1492; + /* TODO: Where is mtu stored? + * + * x_nics[i].mtu = 1492; + */ - x_nic->domid = def->id; virMacAddrGetRaw(&l_nic->mac, x_nic->mac); if (l_nic->model && !STREQ(l_nic->model, "netfront")) { @@ -610,9 +676,9 @@ libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, virReportOOMError(); return -1; } - x_nic->nictype = NICTYPE_IOEMU; + x_nic->nictype = LIBXL_NIC_TYPE_VIF_IOEMU; } else { - x_nic->nictype = NICTYPE_VIF; + x_nic->nictype = LIBXL_NIC_TYPE_VIF; } if (l_nic->ifname && (x_nic->ifname = strdup(l_nic->ifname)) == NULL) { @@ -659,48 +725,49 @@ libxlMakeNicList(virDomainDefPtr def, libxl_domain_config *d_config) for (i = 0; i < nnics; i++) { x_nics[i].devid = i; - if (libxlMakeNic(def, l_nics[i], &x_nics[i])) + if (libxlMakeNic(l_nics[i], &x_nics[i])) goto error; } - d_config->vifs = x_nics; - d_config->num_vifs = nnics; + d_config->nics = x_nics; + d_config->num_nics = nnics; return 0; error: for (i = 0; i < nnics; i++) - libxl_device_nic_destroy(&x_nics[i]); + libxl_device_nic_dispose(&x_nics[i]); VIR_FREE(x_nics); return -1; } int -libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, - virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb) +libxlMakeVfb(libxlDriverPrivatePtr driver, + virDomainGraphicsDefPtr l_vfb, + libxl_device_vfb *x_vfb) { int port; const char *listenAddr; switch (l_vfb->type) { case VIR_DOMAIN_GRAPHICS_TYPE_SDL: - x_vfb->sdl = 1; + libxl_defbool_set(&x_vfb->sdl.enable, 1); if (l_vfb->data.sdl.display && - (x_vfb->display = strdup(l_vfb->data.sdl.display)) == NULL) { + (x_vfb->sdl.display = strdup(l_vfb->data.sdl.display)) == NULL) { virReportOOMError(); return -1; } if (l_vfb->data.sdl.xauth && - (x_vfb->xauthority = + (x_vfb->sdl.xauthority = strdup(l_vfb->data.sdl.xauth)) == NULL) { virReportOOMError(); return -1; } break; case VIR_DOMAIN_GRAPHICS_TYPE_VNC: - x_vfb->vnc = 1; + libxl_defbool_set(&x_vfb->vnc.enable, 1); /* driver handles selection of free port */ - x_vfb->vncunused = 0; + libxl_defbool_set(&x_vfb->vnc.findunused, 0); if (l_vfb->data.vnc.autoport) { port = libxlNextFreeVncPort(driver, LIBXL_VNC_PORT_MIN); if (port < 0) { @@ -710,13 +777,13 @@ libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, } l_vfb->data.vnc.port = port; } - x_vfb->vncdisplay = l_vfb->data.vnc.port - LIBXL_VNC_PORT_MIN; + x_vfb->vnc.display = l_vfb->data.vnc.port - LIBXL_VNC_PORT_MIN; listenAddr = virDomainGraphicsListenGetAddress(l_vfb, 0); if (listenAddr) { /* libxl_device_vfb_init() does strdup("127.0.0.1") */ - VIR_FREE(x_vfb->vnclisten); - if ((x_vfb->vnclisten = strdup(listenAddr)) == NULL) { + VIR_FREE(x_vfb->vnc.listen); + if ((x_vfb->vnc.listen = strdup(listenAddr)) == NULL) { virReportOOMError(); return -1; } @@ -729,13 +796,14 @@ libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, } break; } - x_vfb->domid = def->id; + return 0; } static int libxlMakeVfbList(libxlDriverPrivatePtr driver, - virDomainDefPtr def, libxl_domain_config *d_config) + virDomainDefPtr def, + libxl_domain_config *d_config) { virDomainGraphicsDefPtr *l_vfbs = def->graphics; int nvfbs = def->ngraphics; @@ -757,10 +825,10 @@ libxlMakeVfbList(libxlDriverPrivatePtr driver, } for (i = 0; i < nvfbs; i++) { - libxl_device_vfb_init(&x_vfbs[i], i); - libxl_device_vkb_init(&x_vkbs[i], i); + libxl_device_vfb_init(&x_vfbs[i]); + libxl_device_vkb_init(&x_vkbs[i]); - if (libxlMakeVfb(driver, def, l_vfbs[i], &x_vfbs[i]) < 0) + if (libxlMakeVfb(driver, l_vfbs[i], &x_vfbs[i]) < 0) goto error; } @@ -772,148 +840,14 @@ libxlMakeVfbList(libxlDriverPrivatePtr driver, error: for (i = 0; i < nvfbs; i++) { - libxl_device_vfb_destroy(&x_vfbs[i]); - libxl_device_vkb_destroy(&x_vkbs[i]); + libxl_device_vfb_dispose(&x_vfbs[i]); + libxl_device_vkb_dispose(&x_vkbs[i]); } VIR_FREE(x_vfbs); VIR_FREE(x_vkbs); return -1; } -static int -libxlMakeChrdevStr(virDomainChrDefPtr def, char **buf) -{ - const char *type = virDomainChrTypeToString(def->source.type); - - if (!type) { - virReportError(VIR_ERR_INTERNAL_ERROR, - "%s", _("unexpected chr device type")); - return -1; - } - - switch (def->source.type) { - case VIR_DOMAIN_CHR_TYPE_NULL: - case VIR_DOMAIN_CHR_TYPE_STDIO: - case VIR_DOMAIN_CHR_TYPE_VC: - case VIR_DOMAIN_CHR_TYPE_PTY: - if (virAsprintf(buf, "%s", type) < 0) { - virReportOOMError(); - return -1; - } - break; - - case VIR_DOMAIN_CHR_TYPE_FILE: - case VIR_DOMAIN_CHR_TYPE_PIPE: - if (virAsprintf(buf, "%s:%s", type, - def->source.data.file.path) < 0) { - virReportOOMError(); - return -1; - } - break; - - case VIR_DOMAIN_CHR_TYPE_DEV: - if (virAsprintf(buf, "%s", def->source.data.file.path) < 0) { - virReportOOMError(); - return -1; - } - break; - } - - return 0; -} - -static int -libxlMakeDeviceModelInfo(virDomainDefPtr def, libxl_domain_config *d_config) -{ - libxl_device_model_info *dm_info = &d_config->dm_info; - int i; - char b_order[VIR_DOMAIN_BOOT_LAST+1]; - - libxl_init_dm_info(dm_info, &d_config->c_info, &d_config->b_info); - - if (d_config->b_info.hvm) { - /* HVM-specific device model info */ - dm_info->type = XENFV; - if (def->os.nBootDevs > 0) { - VIR_FREE(dm_info->boot); - for (i = 0; i < def->os.nBootDevs; i++) { - switch (def->os.bootDevs[i]) { - case VIR_DOMAIN_BOOT_FLOPPY: - b_order[i] = 'a'; - break; - default: - case VIR_DOMAIN_BOOT_DISK: - b_order[i] = 'c'; - break; - case VIR_DOMAIN_BOOT_CDROM: - b_order[i] = 'd'; - break; - case VIR_DOMAIN_BOOT_NET: - b_order[i] = 'n'; - break; - } - } - b_order[def->os.nBootDevs] = '\0'; - if ((dm_info->boot = strdup(b_order)) == NULL) { - virReportOOMError(); - goto error; - } - } - if (def->serials && - (libxlMakeChrdevStr(def->serials[0], &dm_info->serial) < 0)) - goto error; - } else { - /* PV-specific device model info */ - dm_info->type = XENPV; - } - - /* Build qemu graphics options from previously parsed vfb */ - if (d_config->num_vfbs > 0) { - if (d_config->vfbs[0].vnc) { - dm_info->vnc = 1; - /* driver handles selection of free port */ - dm_info->vncunused = 0; - if (d_config->vfbs[0].vnclisten) { - VIR_FREE(dm_info->vnclisten); - if ((dm_info->vnclisten = - strdup(d_config->vfbs[0].vnclisten)) == NULL) { - virReportOOMError(); - goto error; - } - } - if (d_config->vfbs[0].keymap && - (dm_info->keymap = strdup(d_config->vfbs[0].keymap)) == NULL) { - virReportOOMError(); - goto error; - } - dm_info->vncdisplay = d_config->vfbs[0].vncdisplay; - if (d_config->vfbs[0].vncpasswd && - (dm_info->vncpasswd = - strdup(d_config->vfbs[0].vncpasswd)) == NULL) { - virReportOOMError(); - goto error; - } - } else if (d_config->vfbs[0].sdl) { - dm_info->sdl = 1; - dm_info->vnc = 0; - } - } else if (d_config->num_vfbs == 0) { - dm_info->nographic = 1; - dm_info->vnc = 0; - } - - // TODO - //dm_info->usb = ; - //dm_info->usbdevice = ; - //dm_info->soundhw = ; - - return 0; - -error: - libxl_device_model_info_destroy(dm_info); - return -1; -} - virCapsPtr libxlMakeCapabilities(libxl_ctx *ctx) { @@ -947,7 +881,7 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, virDomainDefPtr def, libxl_domain_config *d_config) { - if (libxlMakeDomCreateInfo(def, &d_config->c_info) < 0) + if (libxlMakeDomCreateInfo(driver, def, &d_config->c_info) < 0) return -1; if (libxlMakeDomBuildInfo(def, d_config) < 0) { @@ -966,10 +900,6 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, goto error; } - if (libxlMakeDeviceModelInfo(def, d_config) < 0) { - goto error; - } - d_config->on_reboot = def->onReboot; d_config->on_poweroff = def->onPoweroff; d_config->on_crash = def->onCrash; @@ -977,6 +907,6 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, return 0; error: - libxl_domain_config_destroy(d_config); + libxl_domain_config_dispose(d_config); return -1; } diff --git a/src/libxl/libxl_conf.h b/src/libxl/libxl_conf.h index 56bf85c..ea62b68 100644 --- a/src/libxl/libxl_conf.h +++ b/src/libxl/libxl_conf.h @@ -37,6 +37,7 @@ # include "bitmap.h" +# define LIBXL_MAXVCPUS 128 # define LIBXL_VNC_PORT_MIN 5900 # define LIBXL_VNC_PORT_MAX 65535 @@ -58,7 +59,7 @@ struct _libxlDriverPrivate { FILE *logger_file; xentoollog_logger *logger; /* libxl ctx for driver wide ops; getVersion, getNodeInfo, ... */ - libxl_ctx ctx; + libxl_ctx *ctx; virBitmapPtr reservedVNCPorts; virDomainObjList domains; @@ -77,10 +78,8 @@ typedef struct _libxlDomainObjPrivate libxlDomainObjPrivate; typedef libxlDomainObjPrivate *libxlDomainObjPrivatePtr; struct _libxlDomainObjPrivate { /* per domain libxl ctx */ - libxl_ctx ctx; - libxl_waiter *dWaiter; - int waiterFD; - int eventHdl; + libxl_ctx *ctx; + libxl_evgen_domain_death *deathW; }; # define LIBXL_SAVE_MAGIC "libvirt-xml\n \0 \r" @@ -100,13 +99,11 @@ virCapsPtr libxlMakeCapabilities(libxl_ctx *ctx); int -libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_dev, - libxl_device_disk *x_dev); +libxlMakeDisk(virDomainDiskDefPtr l_dev, libxl_device_disk *x_dev); int -libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, - libxl_device_nic *x_nic); +libxlMakeNic(virDomainNetDefPtr l_nic, libxl_device_nic *x_nic); int -libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, +libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb); int diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index bc75730..f15129f 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -40,6 +40,7 @@ #include "memory.h" #include "uuid.h" #include "command.h" +#include "libxl.h" #include "libxl_driver.h" #include "libxl_conf.h" #include "xen_xm.h" @@ -59,6 +60,19 @@ /* Number of Xen scheduler parameters */ #define XEN_SCHED_CREDIT_NPARAM 2 +struct libxlOSEventHookFDInfo { + libxlDomainObjPrivatePtr priv; + void *xl_priv; + int watch; +}; + +struct libxlOSEventHookTimerInfo { + libxlDomainObjPrivatePtr priv; + void *xl_priv; + int id; +}; + + static void libxlDomainManagedSaveLoad(void *payload, const void *n ATTRIBUTE_UNUSED, void *opaque); @@ -84,6 +98,163 @@ libxlDriverUnlock(libxlDriverPrivatePtr driver) virMutexUnlock(&driver->lock); } + +static void libxlFDEventCallback(int watch ATTRIBUTE_UNUSED, + int fd, + int vir_events, + void *fdinfo) +{ + struct libxlOSEventHookFDInfo *info = fdinfo; + int events = 0; + + if (vir_events & VIR_EVENT_HANDLE_READABLE) + events |= POLLIN; + if (vir_events & VIR_EVENT_HANDLE_WRITABLE) + events |= POLLOUT; + if (vir_events & VIR_EVENT_HANDLE_ERROR) + events |= POLLERR; + if (vir_events & VIR_EVENT_HANDLE_HANGUP) + events |= POLLHUP; + + libxl_osevent_occurred_fd(info->priv->ctx, info->xl_priv, fd, 0, events); +} + +static void libxlFreeFDInfo(void *obj) +{ + VIR_FREE(obj); +} + +static int libxlFDRegisterEventHook(void *priv, int fd, void **hndp, + short events, void *xl_priv) +{ + int vir_events = VIR_EVENT_HANDLE_ERROR; + struct libxlOSEventHookFDInfo *fdinfo; + + if (VIR_ALLOC(fdinfo) < 0) { + virReportOOMError(); + return -1; + } + + fdinfo->priv = priv; + fdinfo->xl_priv = xl_priv; + *hndp = fdinfo; + + if (events & POLLIN) + vir_events |= VIR_EVENT_HANDLE_READABLE; + if (events & POLLOUT) + vir_events |= VIR_EVENT_HANDLE_WRITABLE; + fdinfo->watch = virEventAddHandle(fd, vir_events, libxlFDEventCallback, + fdinfo, libxlFreeFDInfo); + if (fdinfo->watch < 0) { + VIR_FREE(fdinfo); + return fdinfo->watch; + } + + return 0; +} + +static int libxlFDModifyEventHook(void *priv ATTRIBUTE_UNUSED, + int fd ATTRIBUTE_UNUSED, + void **hndp, + short events) +{ + struct libxlOSEventHookFDInfo *fdinfo = *hndp; + int vir_events = VIR_EVENT_HANDLE_ERROR; + + if (events & POLLIN) + vir_events |= VIR_EVENT_HANDLE_READABLE; + if (events & POLLOUT) + vir_events |= VIR_EVENT_HANDLE_WRITABLE; + + virEventUpdateHandle(fdinfo->watch, vir_events); + return 0; +} + +static void libxlFDDeregisterEventHook(void *priv ATTRIBUTE_UNUSED, + int fd ATTRIBUTE_UNUSED, + void *hnd) +{ + struct libxlOSEventHookFDInfo *fdinfo = hnd; + + virEventRemoveHandle(fdinfo->watch); +} + + +static void libxlTimerCallback(int timer ATTRIBUTE_UNUSED, void *timer_v) +{ + struct libxlOSEventHookTimerInfo *timer_info = timer_v; + + libxl_osevent_occurred_timeout(timer_info->priv->ctx, timer_info->xl_priv); +} + +static void libxlTimerInfoFree(void* obj) +{ + VIR_FREE(obj); +} + +static int libxlTimeoutRegisterEventHook(void *priv, + void **hndp, + struct timeval abs_t, + void *for_libxl) +{ + struct timeval now; + struct libxlOSEventHookTimerInfo *timer_info; + int timeout, timer_id; + + if (VIR_ALLOC(timer_info) < 0) { + virReportOOMError(); + return -1; + } + + gettimeofday(&now, NULL); + timeout = (abs_t.tv_usec - now.tv_usec) / 1000; + timeout += (abs_t.tv_sec - now.tv_sec) * 1000; + timer_id = virEventAddTimeout(timeout, libxlTimerCallback, + timer_info, libxlTimerInfoFree); + if (timer_id < 0) { + VIR_FREE(timer_info); + return timer_id; + } + + timer_info->priv = priv; + timer_info->xl_priv = for_libxl; + timer_info->id = timer_id; + *hndp = timer_info; + return 0; +} + +static int libxlTimeoutModifyEventHook(void *priv ATTRIBUTE_UNUSED, + void **hndp, + struct timeval abs_t) +{ + struct timeval now; + int timeout; + struct libxlOSEventHookTimerInfo *timer_info = *hndp; + + gettimeofday(&now, NULL); + timeout = (abs_t.tv_usec - now.tv_usec) / 1000; + timeout += (abs_t.tv_sec - now.tv_sec) * 1000; + virEventUpdateTimeout(timer_info->id, timeout); + return 0; +} + +static void libxlTimeoutDeregisterEventHook(void *priv ATTRIBUTE_UNUSED, + void *hnd) +{ + struct libxlOSEventHookTimerInfo *timer_info = hnd; + + virEventRemoveTimeout(timer_info->id); +} + +static const libxl_osevent_hooks libxl_event_callbacks = { + .fd_register = libxlFDRegisterEventHook, + .fd_modify = libxlFDModifyEventHook, + .fd_deregister = libxlFDDeregisterEventHook, + .timeout_register = libxlTimeoutRegisterEventHook, + .timeout_modify = libxlTimeoutModifyEventHook, + .timeout_deregister = libxlTimeoutDeregisterEventHook, +}; + static void * libxlDomainObjPrivateAlloc(void) { @@ -92,9 +263,9 @@ libxlDomainObjPrivateAlloc(void) if (VIR_ALLOC(priv) < 0) return NULL; - libxl_ctx_init(&priv->ctx, LIBXL_VERSION, libxl_driver->logger); - priv->waiterFD = -1; - priv->eventHdl = -1; + libxl_ctx_alloc(&priv->ctx, LIBXL_VERSION, 0, libxl_driver->logger); + priv->deathW = NULL; + libxl_osevent_register_hooks(priv->ctx, &libxl_event_callbacks, priv); return priv; } @@ -104,16 +275,12 @@ libxlDomainObjPrivateFree(void *data) { libxlDomainObjPrivatePtr priv = data; - if (priv->eventHdl >= 0) - virEventRemoveHandle(priv->eventHdl); - - if (priv->dWaiter) { - libxl_stop_waiting(&priv->ctx, priv->dWaiter); - libxl_free_waiter(priv->dWaiter); - VIR_FREE(priv->dWaiter); + if (priv->deathW) { + libxl_evdisable_domain_death(priv->ctx, priv->deathW); + VIR_FREE(priv->deathW); } - libxl_ctx_free(&priv->ctx); + libxl_ctx_free(priv->ctx); VIR_FREE(priv); } @@ -125,17 +292,6 @@ libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event) virDomainEventStateQueue(driver->domainEventState, event); } -/* - * Remove reference to domain object. - */ -static void -libxlDomainObjUnref(void *data) -{ - virDomainObjPtr vm = data; - - virObjectUnref(vm); -} - static void libxlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) @@ -166,13 +322,13 @@ libxlDoNodeGetInfo(libxlDriverPrivatePtr driver, virNodeInfoPtr info) const libxl_version_info* ver_info; struct utsname utsname; - if (libxl_get_physinfo(&driver->ctx, &phy_info)) { + if (libxl_get_physinfo(driver->ctx, &phy_info)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("libxl_get_physinfo_info failed")); return -1; } - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("libxl_get_version_info failed")); return -1; @@ -296,15 +452,9 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, char *file; int i; - if (priv->eventHdl >= 0) { - virEventRemoveHandle(priv->eventHdl); - priv->eventHdl = -1; - } - - if (priv->dWaiter) { - libxl_stop_waiting(&priv->ctx, priv->dWaiter); - libxl_free_waiter(priv->dWaiter); - VIR_FREE(priv->dWaiter); + if (priv->deathW) { + libxl_evdisable_domain_death(priv->ctx, priv->deathW); + priv->deathW = NULL; } if (vm->persistent) { @@ -355,12 +505,11 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, static int libxlVmReap(libxlDriverPrivatePtr driver, virDomainObjPtr vm, - int force, virDomainShutoffReason reason) { libxlDomainObjPrivatePtr priv = vm->privateData; - if (libxl_domain_destroy(&priv->ctx, vm->def->id, force) < 0) { + if (libxl_domain_destroy(priv->ctx, vm->def->id, NULL) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Unable to cleanup domain %d"), vm->def->id); return -1; @@ -373,56 +522,26 @@ libxlVmReap(libxlDriverPrivatePtr driver, /* * Handle previously registered event notification from libxenlight */ -static void libxlEventHandler(int watch, - int fd, - int events, - void *data) +static void libxlEventHandler(void *data, const libxl_event *event) { libxlDriverPrivatePtr driver = libxl_driver; virDomainObjPtr vm = data; - libxlDomainObjPrivatePtr priv; virDomainEventPtr dom_event = NULL; - libxl_event event; - libxl_dominfo info; libxlDriverLock(driver); virDomainObjLock(vm); libxlDriverUnlock(driver); - priv = vm->privateData; - - memset(&event, 0, sizeof(event)); - memset(&info, 0, sizeof(info)); - - if (priv->waiterFD != fd || priv->eventHdl != watch) { - virEventRemoveHandle(watch); - priv->eventHdl = -1; - goto cleanup; - } - - if (!(events & VIR_EVENT_HANDLE_READABLE)) - goto cleanup; - - if (libxl_get_event(&priv->ctx, &event)) - goto cleanup; - - if (event.type == LIBXL_EVENT_DOMAIN_DEATH) { + if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) { virDomainShutoffReason reason; - /* libxl_event_get_domain_death_info returns 1 if death - * event was for this domid */ - if (libxl_event_get_domain_death_info(&priv->ctx, - vm->def->id, - &event, - &info) != 1) + if (event->domid != vm->def->id) goto cleanup; - virEventRemoveHandle(watch); - priv->eventHdl = -1; - switch (info.shutdown_reason) { - case SHUTDOWN_poweroff: - case SHUTDOWN_crash: - if (info.shutdown_reason == SHUTDOWN_crash) { + switch (event->u.domain_shutdown.shutdown_reason) { + case LIBXL_SHUTDOWN_REASON_POWEROFF: + case LIBXL_SHUTDOWN_REASON_CRASH: + if (event->u.domain_shutdown.shutdown_reason == LIBXL_SHUTDOWN_REASON_CRASH) { dom_event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); @@ -430,18 +549,18 @@ static void libxlEventHandler(int watch, } else { reason = VIR_DOMAIN_SHUTOFF_SHUTDOWN; } - libxlVmReap(driver, vm, 0, reason); + libxlVmReap(driver, vm, reason); if (!vm->persistent) { virDomainRemoveInactive(&driver->domains, vm); vm = NULL; } break; - case SHUTDOWN_reboot: - libxlVmReap(driver, vm, 0, VIR_DOMAIN_SHUTOFF_SHUTDOWN); + case LIBXL_SHUTDOWN_REASON_REBOOT: + libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN); libxlVmStart(driver, vm, 0, -1); break; default: - VIR_INFO("Unhandled shutdown_reason %d", info.shutdown_reason); + VIR_INFO("Unhandled shutdown_reason %d", event->u.domain_shutdown.shutdown_reason); break; } } @@ -454,9 +573,14 @@ cleanup: libxlDomainEventQueue(driver, dom_event); libxlDriverUnlock(driver); } - libxl_free_event(&event); } +static const struct libxl_event_hooks ev_hooks = { + .event_occurs_mask = LIBXL_EVENTMASK_ALL, + .event_occurs = libxlEventHandler, + .disaster = NULL, +}; + /* * Register domain events with libxenlight and insert event handles * in libvirt's event loop. @@ -465,40 +589,18 @@ static int libxlCreateDomEvents(virDomainObjPtr vm) { libxlDomainObjPrivatePtr priv = vm->privateData; - int fd; - if (VIR_ALLOC(priv->dWaiter) < 0) { - virReportOOMError(); - return -1; - } - - if (libxl_wait_for_domain_death(&priv->ctx, vm->def->id, priv->dWaiter)) - goto error; - - libxl_get_wait_fd(&priv->ctx, &fd); - if (fd < 0) - goto error; + libxl_event_register_callbacks(priv->ctx, &ev_hooks, vm); - priv->waiterFD = fd; - /* Add a reference to the domain object while it is injected in - * the event loop. - */ - virObjectRef(vm); - if ((priv->eventHdl = virEventAddHandle( - fd, - VIR_EVENT_HANDLE_READABLE | VIR_EVENT_HANDLE_ERROR, - libxlEventHandler, - vm, libxlDomainObjUnref)) < 0) { - virObjectUnref(vm); + if (libxl_evenable_domain_death(priv->ctx, vm->def->id, 0, &priv->deathW)) goto error; - } return 0; error: - libxl_free_waiter(priv->dWaiter); - VIR_FREE(priv->dWaiter); - priv->eventHdl = -1; + if (priv->deathW) + libxl_evdisable_domain_death(priv->ctx, priv->deathW); + VIR_FREE(priv->deathW); return -1; } @@ -507,7 +609,7 @@ libxlDomainSetVcpuAffinites(libxlDriverPrivatePtr driver, virDomainObjPtr vm) { libxlDomainObjPrivatePtr priv = vm->privateData; virDomainDefPtr def = vm->def; - libxl_cpumap map; + libxl_bitmap map; uint8_t *cpumask = NULL; uint8_t *cpumap = NULL; virNodeInfo nodeinfo; @@ -539,7 +641,7 @@ libxlDomainSetVcpuAffinites(libxlDriverPrivatePtr driver, virDomainObjPtr vm) map.size = cpumaplen; map.map = cpumap; - if (libxl_set_vcpuaffinity(&priv->ctx, def->id, vcpu, &map) != 0) { + if (libxl_set_vcpuaffinity(priv->ctx, def->id, vcpu, &map) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to pin vcpu '%d' with libxenlight"), vcpu); goto cleanup; @@ -565,11 +667,10 @@ libxlFreeMem(libxlDomainObjPrivatePtr priv, libxl_domain_config *d_config) int tries = 3; int wait_secs = 10; - if ((ret = libxl_domain_need_memory(&priv->ctx, &d_config->b_info, - &d_config->dm_info, + if ((ret = libxl_domain_need_memory(priv->ctx, &d_config->b_info, &needed_mem)) >= 0) { for (i = 0; i < tries; ++i) { - if ((ret = libxl_get_free_memory(&priv->ctx, &free_mem)) < 0) + if ((ret = libxl_get_free_memory(priv->ctx, &free_mem)) < 0) break; if (free_mem >= needed_mem) { @@ -577,17 +678,17 @@ libxlFreeMem(libxlDomainObjPrivatePtr priv, libxl_domain_config *d_config) break; } - if ((ret = libxl_set_memory_target(&priv->ctx, 0, + if ((ret = libxl_set_memory_target(priv->ctx, 0, free_mem - needed_mem, /* relative */ 1, 0)) < 0) break; - ret = libxl_wait_for_free_memory(&priv->ctx, 0, needed_mem, + ret = libxl_wait_for_free_memory(priv->ctx, 0, needed_mem, wait_secs); if (ret == 0 || ret != ERROR_NOMEM) break; - if ((ret = libxl_wait_for_memory_target(&priv->ctx, 0, 1)) < 0) + if ((ret = libxl_wait_for_memory_target(priv->ctx, 0, 1)) < 0) break; } } @@ -613,7 +714,6 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, char *dom_xml = NULL; char *managed_save_path = NULL; int managed_save_fd = -1; - pid_t child_console_pid = -1; libxlDomainObjPrivatePtr priv = vm->privateData; /* If there is a managed saved state restore it instead of starting @@ -657,7 +757,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, VIR_FREE(managed_save_path); } - memset(&d_config, 0, sizeof(d_config)); + libxl_domain_config_init(&d_config); if (libxlBuildDomainConfig(driver, vm->def, &d_config) < 0) return -1; @@ -669,13 +769,14 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, goto error; } + /* use as synchronous operations => ao_how = NULL and no intermediate reports => ao_progress = NULL */ + if (restore_fd < 0) - ret = libxl_domain_create_new(&priv->ctx, &d_config, - NULL, &child_console_pid, &domid); + ret = libxl_domain_create_new(priv->ctx, &d_config, + &domid, NULL, NULL); else - ret = libxl_domain_create_restore(&priv->ctx, &d_config, NULL, - &child_console_pid, &domid, - restore_fd); + ret = libxl_domain_create_restore(priv->ctx, &d_config, &domid, + restore_fd, NULL, NULL); if (ret) { if (restore_fd < 0) @@ -693,7 +794,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, if ((dom_xml = virDomainDefFormat(vm->def, 0)) == NULL) goto error; - if (libxl_userdata_store(&priv->ctx, domid, "libvirt-xml", + if (libxl_userdata_store(priv->ctx, domid, "libvirt-xml", (uint8_t *)dom_xml, strlen(dom_xml) + 1)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("libxenlight failed to store userdata")); @@ -707,7 +808,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, goto error; if (!start_paused) { - libxl_domain_unpause(&priv->ctx, domid); + libxl_domain_unpause(priv->ctx, domid); virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); } else { virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); @@ -723,18 +824,18 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, VIR_DOMAIN_EVENT_STARTED_RESTORED); libxlDomainEventQueue(driver, event); - libxl_domain_config_destroy(&d_config); + libxl_domain_config_dispose(&d_config); VIR_FREE(dom_xml); VIR_FORCE_CLOSE(managed_save_fd); return 0; error: if (domid > 0) { - libxl_domain_destroy(&priv->ctx, domid, 0); + libxl_domain_destroy(priv->ctx, domid, NULL); vm->def->id = -1; virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_FAILED); } - libxl_domain_config_destroy(&d_config); + libxl_domain_config_dispose(&d_config); VIR_FREE(dom_xml); VIR_FREE(managed_save_path); virDomainDefFree(def); @@ -762,7 +863,7 @@ libxlReconnectDomain(void *payload, virDomainObjLock(vm); /* Does domain still exist? */ - rc = libxl_domain_info(&driver->ctx, &d_info, vm->def->id); + rc = libxl_domain_info(driver->ctx, &d_info, vm->def->id); if (rc == ERROR_INVAL) { goto out; } else if (rc != 0) { @@ -772,7 +873,7 @@ libxlReconnectDomain(void *payload, } /* Is this a domain that was under libvirt control? */ - if (libxl_userdata_retrieve(&driver->ctx, vm->def->id, + if (libxl_userdata_retrieve(driver->ctx, vm->def->id, "libvirt-xml", &data, &len)) { VIR_DEBUG("libxl_userdata_retrieve failed, ignoring domain %d", vm->def->id); goto out; @@ -810,7 +911,7 @@ libxlShutdown(void) libxlDriverLock(libxl_driver); virCapabilitiesFree(libxl_driver->caps); virDomainObjListDeinit(&libxl_driver->domains); - libxl_ctx_free(&libxl_driver->ctx); + libxl_ctx_free(libxl_driver->ctx); xtl_logger_destroy(libxl_driver->logger); if (libxl_driver->logger_file) VIR_FORCE_FCLOSE(libxl_driver->logger_file); @@ -943,14 +1044,14 @@ libxlStartup(int privileged) { goto fail; } - if (libxl_ctx_init(&libxl_driver->ctx, - LIBXL_VERSION, + if (libxl_ctx_alloc(&libxl_driver->ctx, + LIBXL_VERSION, 0, libxl_driver->logger)) { VIR_INFO("cannot initialize libxenlight context, probably not running in a Xen Dom0, disabling driver"); goto fail; } - if ((ver_info = libxl_get_version_info(&libxl_driver->ctx)) == NULL) { + if ((ver_info = libxl_get_version_info(libxl_driver->ctx)) == NULL) { VIR_INFO("cannot version information from libxenlight, disabling driver"); goto fail; } @@ -958,7 +1059,7 @@ libxlStartup(int privileged) { (ver_info->xen_version_minor * 1000); if ((libxl_driver->caps = - libxlMakeCapabilities(&libxl_driver->ctx)) == NULL) { + libxlMakeCapabilities(libxl_driver->ctx)) == NULL) { VIR_ERROR(_("cannot create capabilities for libxenlight")); goto error; } @@ -1115,7 +1216,7 @@ libxlGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) int ret; libxlDriverPrivatePtr driver = conn->privateData; - ret = libxl_get_max_cpus(&driver->ctx); + ret = libxl_get_max_cpus(driver->ctx); /* libxl_get_max_cpus() will return 0 if there were any failures, e.g. xc_physinfo() failing */ if (ret == 0) @@ -1320,7 +1421,7 @@ libxlDomainSuspend(virDomainPtr dom) priv = vm->privateData; if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { - if (libxl_domain_pause(&priv->ctx, dom->id) != 0) { + if (libxl_domain_pause(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to suspend domain '%d' with libxenlight"), dom->id); @@ -1379,7 +1480,7 @@ libxlDomainResume(virDomainPtr dom) priv = vm->privateData; if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { - if (libxl_domain_unpause(&priv->ctx, dom->id) != 0) { + if (libxl_domain_unpause(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to resume domain '%d' with libxenlight"), dom->id); @@ -1436,7 +1537,7 @@ libxlDomainShutdownFlags(virDomainPtr dom, unsigned int flags) } priv = vm->privateData; - if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_POWEROFF) != 0) { + if (libxl_domain_shutdown(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to shutdown domain '%d' with libxenlight"), dom->id); @@ -1489,7 +1590,7 @@ libxlDomainReboot(virDomainPtr dom, unsigned int flags) } priv = vm->privateData; - if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_REBOOT) != 0) { + if (libxl_domain_reboot(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to reboot domain '%d' with libxenlight"), dom->id); @@ -1534,7 +1635,7 @@ libxlDomainDestroyFlags(virDomainPtr dom, event = virDomainEventNewFromObj(vm,VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to destroy domain '%d'"), dom->id); goto cleanup; @@ -1672,7 +1773,7 @@ libxlDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem, if (flags & VIR_DOMAIN_MEM_LIVE) { priv = vm->privateData; - if (libxl_domain_setmaxmem(&priv->ctx, dom->id, newmem) < 0) { + if (libxl_domain_setmaxmem(priv->ctx, dom->id, newmem) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to set maximum memory for domain '%d'" " with libxenlight"), dom->id); @@ -1701,7 +1802,7 @@ libxlDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem, if (flags & VIR_DOMAIN_MEM_LIVE) { priv = vm->privateData; - if (libxl_set_memory_target(&priv->ctx, dom->id, newmem, 0, + if (libxl_set_memory_target(priv->ctx, dom->id, newmem, 0, /* force */ 1) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to set memory for domain '%d'" @@ -1761,7 +1862,7 @@ libxlDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) info->memory = vm->def->mem.cur_balloon; info->maxMem = vm->def->mem.max_balloon; } else { - if (libxl_domain_info(&driver->ctx, &d_info, dom->id) != 0) { + if (libxl_domain_info(driver->ctx, &d_info, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("libxl_domain_info failed for domain '%d'"), dom->id); goto cleanup; @@ -1861,7 +1962,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm, goto cleanup; } - if (libxl_domain_suspend(&priv->ctx, NULL, vm->def->id, fd) != 0) { + if (libxl_domain_suspend(priv->ctx, vm->def->id, fd, 0, NULL) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to save domain '%d' with libxenlight"), vm->def->id); @@ -1871,7 +1972,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm, event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_SAVED) != 0) { + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_SAVED) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to destroy domain '%d'"), vm->def->id); goto cleanup; @@ -2028,7 +2129,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) if (!(flags & VIR_DUMP_LIVE) && virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { - if (libxl_domain_pause(&priv->ctx, dom->id) != 0) { + if (libxl_domain_pause(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Before dumping core, failed to suspend domain '%d'" " with libxenlight"), @@ -2039,7 +2140,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) paused = true; } - if (libxl_domain_core_dump(&priv->ctx, dom->id, to) != 0) { + if (libxl_domain_core_dump(priv->ctx, dom->id, to, NULL) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to dump core of domain '%d' with libxenlight"), dom->id); @@ -2048,7 +2149,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) libxlDriverLock(driver); if (flags & VIR_DUMP_CRASH) { - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_CRASHED) != 0) { + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_CRASHED) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to destroy domain '%d'"), dom->id); goto cleanup_unlock; @@ -2069,7 +2170,7 @@ cleanup_unlock: libxlDriverUnlock(driver); cleanup_unpause: if (virDomainObjIsActive(vm) && paused) { - if (libxl_domain_unpause(&priv->ctx, dom->id) != 0) { + if (libxl_domain_unpause(priv->ctx, dom->id) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("After dumping core, failed to resume domain '%d' with" " libxenlight"), dom->id); @@ -2227,7 +2328,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, libxlDomainObjPrivatePtr priv; virDomainDefPtr def; virDomainObjPtr vm; - libxl_cpumap map; + libxl_bitmap map; uint8_t *bitmask = NULL; unsigned int maplen; unsigned int i, pos; @@ -2322,7 +2423,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, break; case VIR_DOMAIN_VCPU_LIVE: - if (libxl_set_vcpuonline(&priv->ctx, dom->id, &map) != 0) { + if (libxl_set_vcpuonline(priv->ctx, dom->id, &map) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to set vcpus for domain '%d'" " with libxenlight"), dom->id); @@ -2331,7 +2432,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, break; case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG: - if (libxl_set_vcpuonline(&priv->ctx, dom->id, &map) != 0) { + if (libxl_set_vcpuonline(priv->ctx, dom->id, &map) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to set vcpus for domain '%d'" " with libxenlight"), dom->id); @@ -2427,7 +2528,7 @@ libxlDomainPinVcpu(virDomainPtr dom, unsigned int vcpu, unsigned char *cpumap, libxlDomainObjPrivatePtr priv; virDomainObjPtr vm; int ret = -1; - libxl_cpumap map; + libxl_bitmap map; libxlDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); @@ -2448,7 +2549,7 @@ libxlDomainPinVcpu(virDomainPtr dom, unsigned int vcpu, unsigned char *cpumap, map.size = maplen; map.map = cpumap; - if (libxl_set_vcpuaffinity(&priv->ctx, dom->id, vcpu, &map) != 0) { + if (libxl_set_vcpuaffinity(priv->ctx, dom->id, vcpu, &map) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to pin vcpu '%d' with libxenlight"), vcpu); goto cleanup; @@ -2511,7 +2612,7 @@ libxlDomainGetVcpus(virDomainPtr dom, virVcpuInfoPtr info, int maxinfo, } priv = vm->privateData; - if ((vcpuinfo = libxl_list_vcpu(&priv->ctx, dom->id, &maxcpu, + if ((vcpuinfo = libxl_list_vcpu(priv->ctx, dom->id, &maxcpu, &hostcpus)) == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to list vcpus for domain '%d' with libxenlight"), @@ -2538,7 +2639,7 @@ libxlDomainGetVcpus(virDomainPtr dom, virVcpuInfoPtr info, int maxinfo, MIN(maplen, vcpuinfo[i].cpumap.size)); } - libxl_vcpuinfo_destroy(&vcpuinfo[i]); + libxl_vcpuinfo_dispose(&vcpuinfo[i]); } VIR_FREE(vcpuinfo); @@ -2596,7 +2697,7 @@ libxlDomainXMLFromNative(virConnectPtr conn, const char * nativeFormat, goto cleanup; } - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { VIR_ERROR(_("cannot get version information from libxenlight")); goto cleanup; } @@ -2639,7 +2740,7 @@ libxlDomainXMLToNative(virConnectPtr conn, const char * nativeFormat, goto cleanup; } - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { VIR_ERROR(_("cannot get version information from libxenlight")); goto cleanup; } @@ -2899,10 +3000,10 @@ libxlDomainChangeEjectableMedia(libxlDomainObjPrivatePtr priv, return -1; } - if (libxlMakeDisk(vm->def, disk, &x_disk) < 0) + if (libxlMakeDisk(disk, &x_disk) < 0) goto cleanup; - if ((ret = libxl_cdrom_insert(&priv->ctx, vm->def->id, &x_disk)) < 0) { + if ((ret = libxl_cdrom_insert(priv->ctx, vm->def->id, &x_disk, NULL)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("libxenlight failed to change media for disk '%s'"), disk->dst); @@ -2954,11 +3055,11 @@ libxlDomainAttachDeviceDiskLive(libxlDomainObjPrivatePtr priv, goto cleanup; } - if (libxlMakeDisk(vm->def, l_disk, &x_disk) < 0) + if (libxlMakeDisk(l_disk, &x_disk) < 0) goto cleanup; - if ((ret = libxl_device_disk_add(&priv->ctx, vm->def->id, - &x_disk)) < 0) { + if ((ret = libxl_device_disk_add(priv->ctx, vm->def->id, + &x_disk, NULL)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("libxenlight failed to attach disk '%s'"), l_disk->dst); @@ -2991,7 +3092,6 @@ libxlDomainDetachDeviceDiskLive(libxlDomainObjPrivatePtr priv, virDomainDiskDefPtr l_disk = NULL; libxl_device_disk x_disk; int i; - int wait_secs = 2; int ret = -1; switch (dev->data.disk->device) { @@ -3008,11 +3108,11 @@ libxlDomainDetachDeviceDiskLive(libxlDomainObjPrivatePtr priv, l_disk = vm->def->disks[i]; - if (libxlMakeDisk(vm->def, l_disk, &x_disk) < 0) + if (libxlMakeDisk(l_disk, &x_disk) < 0) goto cleanup; - if ((ret = libxl_device_disk_del(&priv->ctx, &x_disk, - wait_secs)) < 0) { + if ((ret = libxl_device_disk_remove(priv->ctx, vm->def->id, + &x_disk, NULL)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("libxenlight failed to detach disk '%s'"), l_disk->dst); @@ -3383,13 +3483,13 @@ libxlNodeGetFreeMemory(virConnectPtr conn) const libxl_version_info* ver_info; libxlDriverPrivatePtr driver = conn->privateData; - if (libxl_get_physinfo(&driver->ctx, &phy_info)) { + if (libxl_get_physinfo(driver->ctx, &phy_info)) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("libxl_get_physinfo_info failed")); return 0; } - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("libxl_get_version_info failed")); return 0; @@ -3536,7 +3636,7 @@ libxlDomainGetSchedulerType(virDomainPtr dom, int *nparams) libxlDomainObjPrivatePtr priv; virDomainObjPtr vm; char * ret = NULL; - int sched_id; + libxl_scheduler sched_id; libxlDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); @@ -3553,31 +3653,29 @@ libxlDomainGetSchedulerType(virDomainPtr dom, int *nparams) } priv = vm->privateData; - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Failed to get scheduler id for domain '%d'" - " with libxenlight"), dom->id); - goto cleanup; - } + sched_id = libxl_get_scheduler(priv->ctx); if (nparams) *nparams = 0; switch (sched_id) { - case XEN_SCHEDULER_SEDF: + case LIBXL_SCHEDULER_SEDF: ret = strdup("sedf"); break; - case XEN_SCHEDULER_CREDIT: + case LIBXL_SCHEDULER_CREDIT: ret = strdup("credit"); if (nparams) *nparams = XEN_SCHED_CREDIT_NPARAM; break; - case XEN_SCHEDULER_CREDIT2: + case LIBXL_SCHEDULER_CREDIT2: ret = strdup("credit2"); break; - case XEN_SCHEDULER_ARINC653: + case LIBXL_SCHEDULER_ARINC653: ret = strdup("arinc653"); break; default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Failed to get scheduler id for domain '%d'" + " with libxenlight"), dom->id); goto cleanup; } @@ -3599,8 +3697,8 @@ libxlDomainGetSchedulerParametersFlags(virDomainPtr dom, libxlDriverPrivatePtr driver = dom->conn->privateData; libxlDomainObjPrivatePtr priv; virDomainObjPtr vm; - libxl_sched_credit sc_info; - int sched_id; + libxl_domain_sched_params sc_info; + libxl_scheduler sched_id; int ret = -1; virCheckFlags(0, -1); @@ -3610,31 +3708,28 @@ libxlDomainGetSchedulerParametersFlags(virDomainPtr dom, libxlDriverUnlock(driver); if (!vm) { - virReportError(VIR_ERR_NO_DOMAIN, "%s", _("no domain with matching uuid")); + virReportError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching uuid")); goto cleanup; } if (!virDomainObjIsActive(vm)) { - virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not running")); + virReportError(VIR_ERR_OPERATION_INVALID, "%s", + _("Domain is not running")); goto cleanup; } priv = vm->privateData; - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Failed to get scheduler id for domain '%d'" - " with libxenlight"), dom->id); - goto cleanup; - } + sched_id = libxl_get_scheduler(priv->ctx); - if (sched_id != XEN_SCHEDULER_CREDIT) { + if (sched_id != LIBXL_SCHEDULER_CREDIT) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Only 'credit' scheduler is supported")); goto cleanup; } - if (libxl_sched_credit_domain_get(&priv->ctx, dom->id, &sc_info) != 0) { + if (libxl_domain_sched_params_get(priv->ctx, dom->id, &sc_info) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to get scheduler parameters for domain '%d'" " with libxenlight"), dom->id); @@ -3677,7 +3772,7 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, libxlDriverPrivatePtr driver = dom->conn->privateData; libxlDomainObjPrivatePtr priv; virDomainObjPtr vm; - libxl_sched_credit sc_info; + libxl_domain_sched_params sc_info; int sched_id; int i; int ret = -1; @@ -3707,20 +3802,15 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, priv = vm->privateData; - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Failed to get scheduler id for domain '%d'" - " with libxenlight"), dom->id); - goto cleanup; - } + sched_id = libxl_get_scheduler(priv->ctx); - if (sched_id != XEN_SCHEDULER_CREDIT) { + if (sched_id != LIBXL_SCHEDULER_CREDIT) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Only 'credit' scheduler is supported")); goto cleanup; } - if (libxl_sched_credit_domain_get(&priv->ctx, dom->id, &sc_info) != 0) { + if (libxl_domain_sched_params_get(priv->ctx, dom->id, &sc_info) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to get scheduler parameters for domain '%d'" " with libxenlight"), dom->id); @@ -3737,7 +3827,7 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, } } - if (libxl_sched_credit_domain_set(&priv->ctx, dom->id, &sc_info) != 0) { + if (libxl_domain_sched_params_set(priv->ctx, dom->id, &sc_info) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to set scheduler parameters for domain '%d'" " with libxenlight"), dom->id); -- 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 Nov 27 11:57:13 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 27 Nov 2012 11:57:13 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdJmh-0004IA-S2; Tue, 27 Nov 2012 11:57:03 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdJmf-0004Hv-Sx for xen-devel@lists.xen.org; Tue, 27 Nov 2012 11:57:02 +0000 Received: from [85.158.138.51:14431] by server-2.bemta-3.messagelabs.com id AE/94-04744-D8AA4B05; Tue, 27 Nov 2012 11:57:01 +0000 X-Env-Sender: Stefano.Stabellini@eu.citrix.com X-Msg-Ref: server-14.tower-174.messagelabs.com!1354017415!25303253!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAxODQ3Mzc=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 32448 invoked from network); 27 Nov 2012 11:56:56 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-14.tower-174.messagelabs.com with RC4-SHA encrypted SMTP; 27 Nov 2012 11:56:56 -0000 X-IronPort-AV: E=Sophos;i="4.83,328,1352073600"; d="scan'208";a="45723601" Received: from ftlpmailmx01.citrite.net ([10.13.107.65]) by FTLPIPO01.CITRIX.COM with ESMTP/TLS/RC4-MD5; 27 Nov 2012 11:56:53 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.65) with Microsoft SMTP Server id 8.3.279.1; Tue, 27 Nov 2012 06:56:52 -0500 Received: from kaball.uk.xensource.com ([10.80.2.59]) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1TdJmV-000574-VL; Tue, 27 Nov 2012 11:56:51 +0000 Date: Tue, 27 Nov 2012 11:56:49 +0000 From: Stefano Stabellini X-X-Sender: sstabellini@kaball.uk.xensource.com To: Jim Fehlig In-Reply-To: <1353968895-16014-1-git-send-email-jfehlig@suse.com> Message-ID: References: <1353968895-16014-1-git-send-email-jfehlig@suse.com> User-Agent: Alpine 2.02 (DEB 1266 2009-07-14) MIME-Version: 1.0 Cc: "libvir-list@redhat.com" , "xen-devel@lists.xen.org" Subject: Re: [Xen-devel] [PATCH] Convert libxl driver to Xen 4.2 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 Mon, 26 Nov 2012, Jim Fehlig wrote: > Based on a patch originally authored by Daniel De Graaf > > http://lists.xen.org/archives/html/xen-devel/2012-05/msg00565.html > > This patch converts the Xen libxl driver to support only Xen >= 4.2. > Support for Xen 4.1 libxl is dropped since that version of libxl is > designated 'technology preview' only and is incompatible with Xen 4.2 > libxl. Additionally, the default toolstack in Xen 4.1 is still xend, > for which libvirt has a stable, functional driver. It looks pretty good to me, thanks! > configure.ac | 8 +- > docs/drvxen.html.in | 8 + > libvirt.spec.in | 4 +- > src/libxl/libxl_conf.c | 370 ++++++++++++++--------------------- > src/libxl/libxl_conf.h | 17 +- > src/libxl/libxl_driver.c | 488 +++++++++++++++++++++++++++------------------- > 6 files changed, 459 insertions(+), 436 deletions(-) > > diff --git a/configure.ac b/configure.ac > index 849d787..c1a9943 100644 > --- a/configure.ac > +++ b/configure.ac > @@ -717,16 +717,14 @@ if test "$with_libxl" != "no" ; then > fi > CFLAGS="$CFLAGS $LIBXL_CFLAGS" > LIBS="$LIBS $LIBXL_LIBS" > - AC_CHECK_LIB([xenlight], [libxl_domain_create_new], [ > + AC_CHECK_LIB([xenlight], [libxl_ctx_alloc], [ > with_libxl=yes > - LIBXL_LIBS="$LIBXL_LIBS -lxenlight -lxenstore -lxenctrl -lxenguest -luuid -lutil -lblktapctl" > + LIBXL_LIBS="$LIBXL_LIBS -lxenlight" > ],[ > if test "$with_libxl" = "yes"; then > fail=1 > fi > with_libxl=no > - ],[ > - -lxenstore -lxenctrl -lxenguest -luuid -lutil -lblktapctl > ]) > fi > > @@ -734,7 +732,7 @@ LIBS="$old_LIBS" > CFLAGS="$old_CFLAGS" > > if test $fail = 1; then > - AC_MSG_ERROR([You must install the libxl Library to compile libxenlight driver with -lxl]) > + AC_MSG_ERROR([You must install the libxl Library from Xen >= 4.2 to compile libxenlight driver with -lxl]) > fi > > if test "$with_libxl" = "yes"; then > diff --git a/docs/drvxen.html.in b/docs/drvxen.html.in > index 0bca935..06bd911 100644 > --- a/docs/drvxen.html.in > +++ b/docs/drvxen.html.in > @@ -53,6 +53,14 @@ > the /etc/xen directory. It is important not to place > any other non-config files in this directory. > > +
  • > + libxl: Starting with Xen 4.2, the legacy XenD/xm > + toolstack is deprecated in favor of libxl, also commonly called > + libxenlight. libvirt supports this new Xen toolstack via the > + libxl driver. If XenD is enabled, the legacy xen driver consisting > + of the above mentioned channels will be used. If XenD is disabled, > + the libxl driver will be used. > +
    • > > >

    Connections to Xen driver

    > diff --git a/libvirt.spec.in b/libvirt.spec.in > index 35c103b..bb274f5 100644 > --- a/libvirt.spec.in > +++ b/libvirt.spec.in > @@ -188,8 +188,8 @@ > %endif > %endif > > -# Fedora doesn't have new enough Xen for libxl until F16 > -%if 0%{?fedora} && 0%{?fedora} < 16 > +# Fedora doesn't have new enough Xen for libxl until F18 > +%if 0%{?fedora} && 0%{?fedora} < 18 > %define with_libxl 0 > %endif > > diff --git a/src/libxl/libxl_conf.c b/src/libxl/libxl_conf.c > index 1c3130b..73abdfa 100644 > --- a/src/libxl/libxl_conf.c > +++ b/src/libxl/libxl_conf.c > @@ -41,6 +41,7 @@ > #include "capabilities.h" > #include "libxl_driver.h" > #include "libxl_conf.h" > +#include "libxl_utils.h" > #include "storage_file.h" > > > @@ -62,6 +63,52 @@ struct guest_arch { > static const char *xen_cap_re = "(xen|hvm)-[[:digit:]]+\\.[[:digit:]]+-(x86_32|x86_64|ia64|powerpc64)(p|be)?"; > static regex_t xen_cap_rec; > > +/* > + * Copied from split_string_into_string_list() in > + * $xen-sources/tools/libxl/xl_cmdimpl.c, which is licensed LGPL v2.1. > + */ > +static int > +libxlSplitStringIntoStringList(const char *str, > + const char *delim, > + libxl_string_list *psl) > +{ > + char *s, *saveptr; > + const char *p; > + libxl_string_list sl; > + int i = 0, nr = 0; > + > + s = strdup(str); > + if (s == NULL) { > + virReportOOMError(); > + return -1; > + } > + > + /* Count number of entries */ > + p = strtok_r(s, delim, &saveptr); > + do { > + nr++; > + } while ((p = strtok_r(NULL, delim, &saveptr))); > + > + VIR_FREE(s); > + s = strdup(str); > + > + if (VIR_ALLOC_N(sl, nr + 1) < 0) { > + virReportOOMError(); > + VIR_FREE(s); > + return -1; > + } > + > + p = strtok_r(s, delim, &saveptr); > + do { > + sl[i] = strdup(p); > + i++; > + } while ((p = strtok_r(NULL, delim, &saveptr))); > + sl[i] = NULL; > + > + *psl = sl; > + VIR_FREE(s); > + return 0; > +} > > static int > libxlNextFreeVncPort(libxlDriverPrivatePtr driver, int startPort) > @@ -360,18 +407,36 @@ libxlMakeCapabilitiesInternal(const char *hostmachine, > } > > static int > -libxlMakeDomCreateInfo(virDomainDefPtr def, libxl_domain_create_info *c_info) > +libxlMakeDomCreateInfo(libxlDriverPrivatePtr driver, > + virDomainDefPtr def, > + libxl_domain_create_info *c_info) > { > char uuidstr[VIR_UUID_STRING_BUFLEN]; > > - libxl_init_create_info(c_info); > + libxl_domain_create_info_init(c_info); > + > + if (STREQ(def->os.type, "hvm")) > + c_info->type = LIBXL_DOMAIN_TYPE_HVM; > + else > + c_info->type = LIBXL_DOMAIN_TYPE_PV; > > - c_info->hvm = STREQ(def->os.type, "hvm"); > if ((c_info->name = strdup(def->name)) == NULL) { > virReportOOMError(); > goto error; > } > > + if (def->nseclabels && > + def->seclabels[0]->type == VIR_DOMAIN_SECLABEL_STATIC) { > + if (libxl_flask_context_to_sid(driver->ctx, > + def->seclabels[0]->label, > + strlen(def->seclabels[0]->label), > + &c_info->ssidref)) { > + virReportError(VIR_ERR_INTERNAL_ERROR, > + _("libxenlight failed to resolve security label '%s'"), > + def->seclabels[0]->label); > + } > + } > + > virUUIDFormat(def->uuid, uuidstr); > if (libxl_uuid_from_string(&c_info->uuid, uuidstr)) { > virReportError(VIR_ERR_INTERNAL_ERROR, > @@ -382,7 +447,7 @@ libxlMakeDomCreateInfo(virDomainDefPtr def, libxl_domain_create_info *c_info) > return 0; > > error: > - libxl_domain_create_info_destroy(c_info); > + libxl_domain_create_info_dispose(c_info); > return -1; > } > > @@ -393,26 +458,25 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > int hvm = STREQ(def->os.type, "hvm"); > int i; > > - /* Currently, libxenlight only supports 32 vcpus per domain. > - * cur_vcpus member of struct libxl_domain_build_info is defined > - * as an int, but its semantic is a bitmap of online vcpus, so > - * only 32 can be represented. > + /* > + * libxl in Xen 4.2 supports up to 128 vcpus, cur_vcpus was replaced > + * by avail_vcpus of type libxl_bitmap > */ > - if (def->maxvcpus > 32 || def->vcpus > 32) { > - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > - _("This version of libxenlight only supports 32 " > - "vcpus per domain")); > + if (def->maxvcpus > LIBXL_MAXVCPUS || def->vcpus > LIBXL_MAXVCPUS) { > + virReportError(VIR_ERR_INTERNAL_ERROR, > + _("This version of libxenlight only supports %u " > + "vcpus per domain"), LIBXL_MAXVCPUS); > return -1; > } > > - libxl_init_build_info(b_info, &d_config->c_info); > + libxl_domain_build_info_init(b_info); > > - b_info->hvm = hvm; > - b_info->max_vcpus = def->maxvcpus; > - if (def->vcpus == 32) > - b_info->cur_vcpus = (uint32_t) -1; > + if (hvm) > + libxl_domain_build_info_init_type(b_info, LIBXL_DOMAIN_TYPE_HVM); > else > - b_info->cur_vcpus = (1 << def->vcpus) - 1; > + libxl_domain_build_info_init_type(b_info, LIBXL_DOMAIN_TYPE_PV); > + b_info->max_vcpus = def->maxvcpus; > + libxl_bitmap_set((&b_info->avail_vcpus), def->vcpus); > if (def->clock.ntimers > 0 && > def->clock.timers[0]->name == VIR_DOMAIN_TIMER_NAME_TSC) { > switch (def->clock.timers[0]->mode) { > @@ -426,16 +490,20 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > b_info->tsc_mode = 1; > } > } > + b_info->sched_params.weight = 1000; > b_info->max_memkb = def->mem.max_balloon; > b_info->target_memkb = def->mem.cur_balloon; > if (hvm) { > - b_info->u.hvm.pae = def->features & (1 << VIR_DOMAIN_FEATURE_PAE); > - b_info->u.hvm.apic = def->features & (1 << VIR_DOMAIN_FEATURE_APIC); > - b_info->u.hvm.acpi = def->features & (1 << VIR_DOMAIN_FEATURE_ACPI); > + libxl_defbool_set(&b_info->u.hvm.pae, > + def->features & (1 << VIR_DOMAIN_FEATURE_PAE)); > + libxl_defbool_set(&b_info->u.hvm.apic, > + def->features & (1 << VIR_DOMAIN_FEATURE_APIC)); > + libxl_defbool_set(&b_info->u.hvm.acpi, > + def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)); > for (i = 0; i < def->clock.ntimers; i++) { > if (def->clock.timers[i]->name == VIR_DOMAIN_TIMER_NAME_HPET && > def->clock.timers[i]->present == 1) { > - b_info->u.hvm.hpet = 1; > + libxl_defbool_set(&b_info->u.hvm.hpet, 1); > } > } > > @@ -446,7 +514,7 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > * 256 pages (1MB) per vcpu, plus 1 page per MiB of RAM for the P2M map, > * plus 1 page per MiB of RAM to shadow the resident processes. > */ > - b_info->shadow_memkb = 4 * (256 * b_info->cur_vcpus + > + b_info->shadow_memkb = 4 * (256 * libxl_bitmap_count_set(&b_info->avail_vcpus) + > 2 * (b_info->max_memkb / 1024)); > } else { > if (def->os.bootloader) { > @@ -456,10 +524,11 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > } > } > if (def->os.bootloaderArgs) { > - if ((b_info->u.pv.bootloader_args = strdup(def->os.bootloaderArgs)) == NULL) { > - virReportOOMError(); > + if (libxlSplitStringIntoStringList(def->os.bootloaderArgs, > + " \t\n", > + &b_info->u.pv.bootloader_args) > + < 0) > goto error; > - } > } > if (def->os.cmdline) { > if ((b_info->u.pv.cmdline = strdup(def->os.cmdline)) == NULL) { > @@ -469,14 +538,14 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > } > if (def->os.kernel) { > /* libxl_init_build_info() sets kernel.path = strdup("hvmloader") */ > - VIR_FREE(b_info->kernel.path); > - if ((b_info->kernel.path = strdup(def->os.kernel)) == NULL) { > + VIR_FREE(b_info->u.pv.kernel); > + if ((b_info->u.pv.kernel = strdup(def->os.kernel)) == NULL) { > virReportOOMError(); > goto error; > } > } > if (def->os.initrd) { > - if ((b_info->u.pv.ramdisk.path = strdup(def->os.initrd)) == NULL) { > + if ((b_info->u.pv.ramdisk = strdup(def->os.initrd)) == NULL) { > virReportOOMError(); > goto error; > } > @@ -486,13 +555,12 @@ libxlMakeDomBuildInfo(virDomainDefPtr def, libxl_domain_config *d_config) > return 0; > > error: > - libxl_domain_build_info_destroy(b_info); > + libxl_domain_build_info_dispose(b_info); > return -1; > } > > int > -libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, > - libxl_device_disk *x_disk) > +libxlMakeDisk(virDomainDiskDefPtr l_disk, libxl_device_disk *x_disk) > { > if (l_disk->src && (x_disk->pdev_path = strdup(l_disk->src)) == NULL) { > virReportOOMError(); > @@ -509,22 +577,22 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, > STREQ(l_disk->driverName, "tap2")) { > switch (l_disk->format) { > case VIR_STORAGE_FILE_QCOW: > - x_disk->format = DISK_FORMAT_QCOW; > - x_disk->backend = DISK_BACKEND_QDISK; > + x_disk->format = LIBXL_DISK_FORMAT_QCOW; > + x_disk->backend = LIBXL_DISK_BACKEND_QDISK; > break; > case VIR_STORAGE_FILE_QCOW2: > - x_disk->format = DISK_FORMAT_QCOW2; > - x_disk->backend = DISK_BACKEND_QDISK; > + x_disk->format = LIBXL_DISK_FORMAT_QCOW2; > + x_disk->backend = LIBXL_DISK_BACKEND_QDISK; > break; > case VIR_STORAGE_FILE_VHD: > - x_disk->format = DISK_FORMAT_VHD; > - x_disk->backend = DISK_BACKEND_TAP; > + x_disk->format = LIBXL_DISK_FORMAT_VHD; > + x_disk->backend = LIBXL_DISK_BACKEND_TAP; > break; > case VIR_STORAGE_FILE_NONE: > /* No subtype specified, default to raw/tap */ > case VIR_STORAGE_FILE_RAW: > - x_disk->format = DISK_FORMAT_RAW; > - x_disk->backend = DISK_BACKEND_TAP; > + x_disk->format = LIBXL_DISK_FORMAT_RAW; > + x_disk->backend = LIBXL_DISK_BACKEND_TAP; > break; > default: > virReportError(VIR_ERR_INTERNAL_ERROR, > @@ -533,11 +601,11 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, > return -1; > } > } else if (STREQ(l_disk->driverName, "file")) { > - x_disk->format = DISK_FORMAT_RAW; > - x_disk->backend = DISK_BACKEND_TAP; > + x_disk->format = LIBXL_DISK_FORMAT_RAW; > + x_disk->backend = LIBXL_DISK_BACKEND_TAP; > } else if (STREQ(l_disk->driverName, "phy")) { > - x_disk->format = DISK_FORMAT_RAW; > - x_disk->backend = DISK_BACKEND_PHY; > + x_disk->format = LIBXL_DISK_FORMAT_RAW; > + x_disk->backend = LIBXL_DISK_BACKEND_PHY; > } else { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("libxenlight does not support disk driver %s"), > @@ -546,12 +614,12 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, > } > } else { > /* No driverName - default to raw/tap?? */ > - x_disk->format = DISK_FORMAT_RAW; > - x_disk->backend = DISK_BACKEND_TAP; > + x_disk->format = LIBXL_DISK_FORMAT_RAW; > + x_disk->backend = LIBXL_DISK_BACKEND_TAP; > } > > - /* How to set unpluggable? */ > - x_disk->unpluggable = 1; > + /* XXX is this right? */ > + x_disk->removable = 1; > x_disk->readwrite = !l_disk->readonly; > x_disk->is_cdrom = l_disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM ? 1 : 0; > if (l_disk->transient) { > @@ -560,8 +628,6 @@ libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_disk, > return -1; > } > > - x_disk->domid = def->id; > - > return 0; > } > > @@ -579,7 +645,7 @@ libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config) > } > > for (i = 0; i < ndisks; i++) { > - if (libxlMakeDisk(def, l_disks[i], &x_disks[i]) < 0) > + if (libxlMakeDisk(l_disks[i], &x_disks[i]) < 0) > goto error; > } > > @@ -590,19 +656,19 @@ libxlMakeDiskList(virDomainDefPtr def, libxl_domain_config *d_config) > > error: > for (i = 0; i < ndisks; i++) > - libxl_device_disk_destroy(&x_disks[i]); > + libxl_device_disk_dispose(&x_disks[i]); > VIR_FREE(x_disks); > return -1; > } > > int > -libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, > - libxl_device_nic *x_nic) > +libxlMakeNic(virDomainNetDefPtr l_nic, libxl_device_nic *x_nic) > { > - // TODO: Where is mtu stored? > - //x_nics[i].mtu = 1492; > + /* TODO: Where is mtu stored? > + * > + * x_nics[i].mtu = 1492; > + */ > > - x_nic->domid = def->id; > virMacAddrGetRaw(&l_nic->mac, x_nic->mac); > > if (l_nic->model && !STREQ(l_nic->model, "netfront")) { > @@ -610,9 +676,9 @@ libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, > virReportOOMError(); > return -1; > } > - x_nic->nictype = NICTYPE_IOEMU; > + x_nic->nictype = LIBXL_NIC_TYPE_VIF_IOEMU; > } else { > - x_nic->nictype = NICTYPE_VIF; > + x_nic->nictype = LIBXL_NIC_TYPE_VIF; > } > > if (l_nic->ifname && (x_nic->ifname = strdup(l_nic->ifname)) == NULL) { > @@ -659,48 +725,49 @@ libxlMakeNicList(virDomainDefPtr def, libxl_domain_config *d_config) > for (i = 0; i < nnics; i++) { > x_nics[i].devid = i; > > - if (libxlMakeNic(def, l_nics[i], &x_nics[i])) > + if (libxlMakeNic(l_nics[i], &x_nics[i])) > goto error; > } > > - d_config->vifs = x_nics; > - d_config->num_vifs = nnics; > + d_config->nics = x_nics; > + d_config->num_nics = nnics; > > return 0; > > error: > for (i = 0; i < nnics; i++) > - libxl_device_nic_destroy(&x_nics[i]); > + libxl_device_nic_dispose(&x_nics[i]); > VIR_FREE(x_nics); > return -1; > } > > int > -libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, > - virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb) > +libxlMakeVfb(libxlDriverPrivatePtr driver, > + virDomainGraphicsDefPtr l_vfb, > + libxl_device_vfb *x_vfb) > { > int port; > const char *listenAddr; > > switch (l_vfb->type) { > case VIR_DOMAIN_GRAPHICS_TYPE_SDL: > - x_vfb->sdl = 1; > + libxl_defbool_set(&x_vfb->sdl.enable, 1); > if (l_vfb->data.sdl.display && > - (x_vfb->display = strdup(l_vfb->data.sdl.display)) == NULL) { > + (x_vfb->sdl.display = strdup(l_vfb->data.sdl.display)) == NULL) { > virReportOOMError(); > return -1; > } > if (l_vfb->data.sdl.xauth && > - (x_vfb->xauthority = > + (x_vfb->sdl.xauthority = > strdup(l_vfb->data.sdl.xauth)) == NULL) { > virReportOOMError(); > return -1; > } > break; > case VIR_DOMAIN_GRAPHICS_TYPE_VNC: > - x_vfb->vnc = 1; > + libxl_defbool_set(&x_vfb->vnc.enable, 1); > /* driver handles selection of free port */ > - x_vfb->vncunused = 0; > + libxl_defbool_set(&x_vfb->vnc.findunused, 0); > if (l_vfb->data.vnc.autoport) { > port = libxlNextFreeVncPort(driver, LIBXL_VNC_PORT_MIN); > if (port < 0) { > @@ -710,13 +777,13 @@ libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, > } > l_vfb->data.vnc.port = port; > } > - x_vfb->vncdisplay = l_vfb->data.vnc.port - LIBXL_VNC_PORT_MIN; > + x_vfb->vnc.display = l_vfb->data.vnc.port - LIBXL_VNC_PORT_MIN; > > listenAddr = virDomainGraphicsListenGetAddress(l_vfb, 0); > if (listenAddr) { > /* libxl_device_vfb_init() does strdup("127.0.0.1") */ > - VIR_FREE(x_vfb->vnclisten); > - if ((x_vfb->vnclisten = strdup(listenAddr)) == NULL) { > + VIR_FREE(x_vfb->vnc.listen); > + if ((x_vfb->vnc.listen = strdup(listenAddr)) == NULL) { > virReportOOMError(); > return -1; > } > @@ -729,13 +796,14 @@ libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, > } > break; > } > - x_vfb->domid = def->id; > + > return 0; > } > > static int > libxlMakeVfbList(libxlDriverPrivatePtr driver, > - virDomainDefPtr def, libxl_domain_config *d_config) > + virDomainDefPtr def, > + libxl_domain_config *d_config) > { > virDomainGraphicsDefPtr *l_vfbs = def->graphics; > int nvfbs = def->ngraphics; > @@ -757,10 +825,10 @@ libxlMakeVfbList(libxlDriverPrivatePtr driver, > } > > for (i = 0; i < nvfbs; i++) { > - libxl_device_vfb_init(&x_vfbs[i], i); > - libxl_device_vkb_init(&x_vkbs[i], i); > + libxl_device_vfb_init(&x_vfbs[i]); > + libxl_device_vkb_init(&x_vkbs[i]); > > - if (libxlMakeVfb(driver, def, l_vfbs[i], &x_vfbs[i]) < 0) > + if (libxlMakeVfb(driver, l_vfbs[i], &x_vfbs[i]) < 0) > goto error; > } > > @@ -772,148 +840,14 @@ libxlMakeVfbList(libxlDriverPrivatePtr driver, > > error: > for (i = 0; i < nvfbs; i++) { > - libxl_device_vfb_destroy(&x_vfbs[i]); > - libxl_device_vkb_destroy(&x_vkbs[i]); > + libxl_device_vfb_dispose(&x_vfbs[i]); > + libxl_device_vkb_dispose(&x_vkbs[i]); > } > VIR_FREE(x_vfbs); > VIR_FREE(x_vkbs); > return -1; > } > > -static int > -libxlMakeChrdevStr(virDomainChrDefPtr def, char **buf) > -{ > - const char *type = virDomainChrTypeToString(def->source.type); > - > - if (!type) { > - virReportError(VIR_ERR_INTERNAL_ERROR, > - "%s", _("unexpected chr device type")); > - return -1; > - } > - > - switch (def->source.type) { > - case VIR_DOMAIN_CHR_TYPE_NULL: > - case VIR_DOMAIN_CHR_TYPE_STDIO: > - case VIR_DOMAIN_CHR_TYPE_VC: > - case VIR_DOMAIN_CHR_TYPE_PTY: > - if (virAsprintf(buf, "%s", type) < 0) { > - virReportOOMError(); > - return -1; > - } > - break; > - > - case VIR_DOMAIN_CHR_TYPE_FILE: > - case VIR_DOMAIN_CHR_TYPE_PIPE: > - if (virAsprintf(buf, "%s:%s", type, > - def->source.data.file.path) < 0) { > - virReportOOMError(); > - return -1; > - } > - break; > - > - case VIR_DOMAIN_CHR_TYPE_DEV: > - if (virAsprintf(buf, "%s", def->source.data.file.path) < 0) { > - virReportOOMError(); > - return -1; > - } > - break; > - } > - > - return 0; > -} > - > -static int > -libxlMakeDeviceModelInfo(virDomainDefPtr def, libxl_domain_config *d_config) > -{ > - libxl_device_model_info *dm_info = &d_config->dm_info; > - int i; > - char b_order[VIR_DOMAIN_BOOT_LAST+1]; > - > - libxl_init_dm_info(dm_info, &d_config->c_info, &d_config->b_info); > - > - if (d_config->b_info.hvm) { > - /* HVM-specific device model info */ > - dm_info->type = XENFV; > - if (def->os.nBootDevs > 0) { > - VIR_FREE(dm_info->boot); > - for (i = 0; i < def->os.nBootDevs; i++) { > - switch (def->os.bootDevs[i]) { > - case VIR_DOMAIN_BOOT_FLOPPY: > - b_order[i] = 'a'; > - break; > - default: > - case VIR_DOMAIN_BOOT_DISK: > - b_order[i] = 'c'; > - break; > - case VIR_DOMAIN_BOOT_CDROM: > - b_order[i] = 'd'; > - break; > - case VIR_DOMAIN_BOOT_NET: > - b_order[i] = 'n'; > - break; > - } > - } > - b_order[def->os.nBootDevs] = '\0'; > - if ((dm_info->boot = strdup(b_order)) == NULL) { > - virReportOOMError(); > - goto error; > - } > - } > - if (def->serials && > - (libxlMakeChrdevStr(def->serials[0], &dm_info->serial) < 0)) > - goto error; > - } else { > - /* PV-specific device model info */ > - dm_info->type = XENPV; > - } > - > - /* Build qemu graphics options from previously parsed vfb */ > - if (d_config->num_vfbs > 0) { > - if (d_config->vfbs[0].vnc) { > - dm_info->vnc = 1; > - /* driver handles selection of free port */ > - dm_info->vncunused = 0; > - if (d_config->vfbs[0].vnclisten) { > - VIR_FREE(dm_info->vnclisten); > - if ((dm_info->vnclisten = > - strdup(d_config->vfbs[0].vnclisten)) == NULL) { > - virReportOOMError(); > - goto error; > - } > - } > - if (d_config->vfbs[0].keymap && > - (dm_info->keymap = strdup(d_config->vfbs[0].keymap)) == NULL) { > - virReportOOMError(); > - goto error; > - } > - dm_info->vncdisplay = d_config->vfbs[0].vncdisplay; > - if (d_config->vfbs[0].vncpasswd && > - (dm_info->vncpasswd = > - strdup(d_config->vfbs[0].vncpasswd)) == NULL) { > - virReportOOMError(); > - goto error; > - } > - } else if (d_config->vfbs[0].sdl) { > - dm_info->sdl = 1; > - dm_info->vnc = 0; > - } > - } else if (d_config->num_vfbs == 0) { > - dm_info->nographic = 1; > - dm_info->vnc = 0; > - } > - > - // TODO > - //dm_info->usb = ; > - //dm_info->usbdevice = ; > - //dm_info->soundhw = ; > - > - return 0; > - > -error: > - libxl_device_model_info_destroy(dm_info); > - return -1; > -} > - > virCapsPtr > libxlMakeCapabilities(libxl_ctx *ctx) > { > @@ -947,7 +881,7 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, > virDomainDefPtr def, libxl_domain_config *d_config) > { > > - if (libxlMakeDomCreateInfo(def, &d_config->c_info) < 0) > + if (libxlMakeDomCreateInfo(driver, def, &d_config->c_info) < 0) > return -1; > > if (libxlMakeDomBuildInfo(def, d_config) < 0) { > @@ -966,10 +900,6 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, > goto error; > } > > - if (libxlMakeDeviceModelInfo(def, d_config) < 0) { > - goto error; > - } > - > d_config->on_reboot = def->onReboot; > d_config->on_poweroff = def->onPoweroff; > d_config->on_crash = def->onCrash; > @@ -977,6 +907,6 @@ libxlBuildDomainConfig(libxlDriverPrivatePtr driver, > return 0; > > error: > - libxl_domain_config_destroy(d_config); > + libxl_domain_config_dispose(d_config); > return -1; > } > diff --git a/src/libxl/libxl_conf.h b/src/libxl/libxl_conf.h > index 56bf85c..ea62b68 100644 > --- a/src/libxl/libxl_conf.h > +++ b/src/libxl/libxl_conf.h > @@ -37,6 +37,7 @@ > # include "bitmap.h" > > > +# define LIBXL_MAXVCPUS 128 > # define LIBXL_VNC_PORT_MIN 5900 > # define LIBXL_VNC_PORT_MAX 65535 > > @@ -58,7 +59,7 @@ struct _libxlDriverPrivate { > FILE *logger_file; > xentoollog_logger *logger; > /* libxl ctx for driver wide ops; getVersion, getNodeInfo, ... */ > - libxl_ctx ctx; > + libxl_ctx *ctx; > > virBitmapPtr reservedVNCPorts; > virDomainObjList domains; > @@ -77,10 +78,8 @@ typedef struct _libxlDomainObjPrivate libxlDomainObjPrivate; > typedef libxlDomainObjPrivate *libxlDomainObjPrivatePtr; > struct _libxlDomainObjPrivate { > /* per domain libxl ctx */ > - libxl_ctx ctx; > - libxl_waiter *dWaiter; > - int waiterFD; > - int eventHdl; > + libxl_ctx *ctx; > + libxl_evgen_domain_death *deathW; > }; > > # define LIBXL_SAVE_MAGIC "libvirt-xml\n \0 \r" > @@ -100,13 +99,11 @@ virCapsPtr > libxlMakeCapabilities(libxl_ctx *ctx); > > int > -libxlMakeDisk(virDomainDefPtr def, virDomainDiskDefPtr l_dev, > - libxl_device_disk *x_dev); > +libxlMakeDisk(virDomainDiskDefPtr l_dev, libxl_device_disk *x_dev); > int > -libxlMakeNic(virDomainDefPtr def, virDomainNetDefPtr l_nic, > - libxl_device_nic *x_nic); > +libxlMakeNic(virDomainNetDefPtr l_nic, libxl_device_nic *x_nic); > int > -libxlMakeVfb(libxlDriverPrivatePtr driver, virDomainDefPtr def, > +libxlMakeVfb(libxlDriverPrivatePtr driver, > virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb); > > int > diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c > index bc75730..f15129f 100644 > --- a/src/libxl/libxl_driver.c > +++ b/src/libxl/libxl_driver.c > @@ -40,6 +40,7 @@ > #include "memory.h" > #include "uuid.h" > #include "command.h" > +#include "libxl.h" > #include "libxl_driver.h" > #include "libxl_conf.h" > #include "xen_xm.h" > @@ -59,6 +60,19 @@ > /* Number of Xen scheduler parameters */ > #define XEN_SCHED_CREDIT_NPARAM 2 > > +struct libxlOSEventHookFDInfo { > + libxlDomainObjPrivatePtr priv; > + void *xl_priv; > + int watch; > +}; > + > +struct libxlOSEventHookTimerInfo { > + libxlDomainObjPrivatePtr priv; > + void *xl_priv; > + int id; > +}; > + > + > static void libxlDomainManagedSaveLoad(void *payload, > const void *n ATTRIBUTE_UNUSED, > void *opaque); > @@ -84,6 +98,163 @@ libxlDriverUnlock(libxlDriverPrivatePtr driver) > virMutexUnlock(&driver->lock); > } > > + > +static void libxlFDEventCallback(int watch ATTRIBUTE_UNUSED, > + int fd, > + int vir_events, > + void *fdinfo) > +{ > + struct libxlOSEventHookFDInfo *info = fdinfo; > + int events = 0; > + > + if (vir_events & VIR_EVENT_HANDLE_READABLE) > + events |= POLLIN; > + if (vir_events & VIR_EVENT_HANDLE_WRITABLE) > + events |= POLLOUT; > + if (vir_events & VIR_EVENT_HANDLE_ERROR) > + events |= POLLERR; > + if (vir_events & VIR_EVENT_HANDLE_HANGUP) > + events |= POLLHUP; > + > + libxl_osevent_occurred_fd(info->priv->ctx, info->xl_priv, fd, 0, events); > +} > + > +static void libxlFreeFDInfo(void *obj) > +{ > + VIR_FREE(obj); > +} > + > +static int libxlFDRegisterEventHook(void *priv, int fd, void **hndp, > + short events, void *xl_priv) > +{ > + int vir_events = VIR_EVENT_HANDLE_ERROR; > + struct libxlOSEventHookFDInfo *fdinfo; > + > + if (VIR_ALLOC(fdinfo) < 0) { > + virReportOOMError(); > + return -1; > + } > + > + fdinfo->priv = priv; > + fdinfo->xl_priv = xl_priv; > + *hndp = fdinfo; > + > + if (events & POLLIN) > + vir_events |= VIR_EVENT_HANDLE_READABLE; > + if (events & POLLOUT) > + vir_events |= VIR_EVENT_HANDLE_WRITABLE; > + fdinfo->watch = virEventAddHandle(fd, vir_events, libxlFDEventCallback, > + fdinfo, libxlFreeFDInfo); > + if (fdinfo->watch < 0) { > + VIR_FREE(fdinfo); > + return fdinfo->watch; > + } > + > + return 0; > +} > + > +static int libxlFDModifyEventHook(void *priv ATTRIBUTE_UNUSED, > + int fd ATTRIBUTE_UNUSED, > + void **hndp, > + short events) > +{ > + struct libxlOSEventHookFDInfo *fdinfo = *hndp; > + int vir_events = VIR_EVENT_HANDLE_ERROR; > + > + if (events & POLLIN) > + vir_events |= VIR_EVENT_HANDLE_READABLE; > + if (events & POLLOUT) > + vir_events |= VIR_EVENT_HANDLE_WRITABLE; > + > + virEventUpdateHandle(fdinfo->watch, vir_events); > + return 0; > +} > + > +static void libxlFDDeregisterEventHook(void *priv ATTRIBUTE_UNUSED, > + int fd ATTRIBUTE_UNUSED, > + void *hnd) > +{ > + struct libxlOSEventHookFDInfo *fdinfo = hnd; > + > + virEventRemoveHandle(fdinfo->watch); > +} > + > + > +static void libxlTimerCallback(int timer ATTRIBUTE_UNUSED, void *timer_v) > +{ > + struct libxlOSEventHookTimerInfo *timer_info = timer_v; > + > + libxl_osevent_occurred_timeout(timer_info->priv->ctx, timer_info->xl_priv); > +} > + > +static void libxlTimerInfoFree(void* obj) > +{ > + VIR_FREE(obj); > +} > + > +static int libxlTimeoutRegisterEventHook(void *priv, > + void **hndp, > + struct timeval abs_t, > + void *for_libxl) > +{ > + struct timeval now; > + struct libxlOSEventHookTimerInfo *timer_info; > + int timeout, timer_id; > + > + if (VIR_ALLOC(timer_info) < 0) { > + virReportOOMError(); > + return -1; > + } > + > + gettimeofday(&now, NULL); > + timeout = (abs_t.tv_usec - now.tv_usec) / 1000; > + timeout += (abs_t.tv_sec - now.tv_sec) * 1000; > + timer_id = virEventAddTimeout(timeout, libxlTimerCallback, > + timer_info, libxlTimerInfoFree); > + if (timer_id < 0) { > + VIR_FREE(timer_info); > + return timer_id; > + } > + > + timer_info->priv = priv; > + timer_info->xl_priv = for_libxl; > + timer_info->id = timer_id; > + *hndp = timer_info; > + return 0; > +} > + > +static int libxlTimeoutModifyEventHook(void *priv ATTRIBUTE_UNUSED, > + void **hndp, > + struct timeval abs_t) > +{ > + struct timeval now; > + int timeout; > + struct libxlOSEventHookTimerInfo *timer_info = *hndp; > + > + gettimeofday(&now, NULL); > + timeout = (abs_t.tv_usec - now.tv_usec) / 1000; > + timeout += (abs_t.tv_sec - now.tv_sec) * 1000; > + virEventUpdateTimeout(timer_info->id, timeout); > + return 0; > +} > + > +static void libxlTimeoutDeregisterEventHook(void *priv ATTRIBUTE_UNUSED, > + void *hnd) > +{ > + struct libxlOSEventHookTimerInfo *timer_info = hnd; > + > + virEventRemoveTimeout(timer_info->id); > +} > + > +static const libxl_osevent_hooks libxl_event_callbacks = { > + .fd_register = libxlFDRegisterEventHook, > + .fd_modify = libxlFDModifyEventHook, > + .fd_deregister = libxlFDDeregisterEventHook, > + .timeout_register = libxlTimeoutRegisterEventHook, > + .timeout_modify = libxlTimeoutModifyEventHook, > + .timeout_deregister = libxlTimeoutDeregisterEventHook, > +}; > + > static void * > libxlDomainObjPrivateAlloc(void) > { > @@ -92,9 +263,9 @@ libxlDomainObjPrivateAlloc(void) > if (VIR_ALLOC(priv) < 0) > return NULL; > > - libxl_ctx_init(&priv->ctx, LIBXL_VERSION, libxl_driver->logger); > - priv->waiterFD = -1; > - priv->eventHdl = -1; > + libxl_ctx_alloc(&priv->ctx, LIBXL_VERSION, 0, libxl_driver->logger); > + priv->deathW = NULL; > + libxl_osevent_register_hooks(priv->ctx, &libxl_event_callbacks, priv); > > return priv; > } > @@ -104,16 +275,12 @@ libxlDomainObjPrivateFree(void *data) > { > libxlDomainObjPrivatePtr priv = data; > > - if (priv->eventHdl >= 0) > - virEventRemoveHandle(priv->eventHdl); > - > - if (priv->dWaiter) { > - libxl_stop_waiting(&priv->ctx, priv->dWaiter); > - libxl_free_waiter(priv->dWaiter); > - VIR_FREE(priv->dWaiter); > + if (priv->deathW) { > + libxl_evdisable_domain_death(priv->ctx, priv->deathW); > + VIR_FREE(priv->deathW); > } > > - libxl_ctx_free(&priv->ctx); > + libxl_ctx_free(priv->ctx); > VIR_FREE(priv); > } > > @@ -125,17 +292,6 @@ libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event) > virDomainEventStateQueue(driver->domainEventState, event); > } > > -/* > - * Remove reference to domain object. > - */ > -static void > -libxlDomainObjUnref(void *data) > -{ > - virDomainObjPtr vm = data; > - > - virObjectUnref(vm); > -} > - > static void > libxlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, > void *opaque) > @@ -166,13 +322,13 @@ libxlDoNodeGetInfo(libxlDriverPrivatePtr driver, virNodeInfoPtr info) > const libxl_version_info* ver_info; > struct utsname utsname; > > - if (libxl_get_physinfo(&driver->ctx, &phy_info)) { > + if (libxl_get_physinfo(driver->ctx, &phy_info)) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("libxl_get_physinfo_info failed")); > return -1; > } > > - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { > + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("libxl_get_version_info failed")); > return -1; > @@ -296,15 +452,9 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, > char *file; > int i; > > - if (priv->eventHdl >= 0) { > - virEventRemoveHandle(priv->eventHdl); > - priv->eventHdl = -1; > - } > - > - if (priv->dWaiter) { > - libxl_stop_waiting(&priv->ctx, priv->dWaiter); > - libxl_free_waiter(priv->dWaiter); > - VIR_FREE(priv->dWaiter); > + if (priv->deathW) { > + libxl_evdisable_domain_death(priv->ctx, priv->deathW); > + priv->deathW = NULL; > } > > if (vm->persistent) { > @@ -355,12 +505,11 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, > static int > libxlVmReap(libxlDriverPrivatePtr driver, > virDomainObjPtr vm, > - int force, > virDomainShutoffReason reason) > { > libxlDomainObjPrivatePtr priv = vm->privateData; > > - if (libxl_domain_destroy(&priv->ctx, vm->def->id, force) < 0) { > + if (libxl_domain_destroy(priv->ctx, vm->def->id, NULL) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Unable to cleanup domain %d"), vm->def->id); > return -1; > @@ -373,56 +522,26 @@ libxlVmReap(libxlDriverPrivatePtr driver, > /* > * Handle previously registered event notification from libxenlight > */ > -static void libxlEventHandler(int watch, > - int fd, > - int events, > - void *data) > +static void libxlEventHandler(void *data, const libxl_event *event) > { > libxlDriverPrivatePtr driver = libxl_driver; > virDomainObjPtr vm = data; > - libxlDomainObjPrivatePtr priv; > virDomainEventPtr dom_event = NULL; > - libxl_event event; > - libxl_dominfo info; > > libxlDriverLock(driver); > virDomainObjLock(vm); > libxlDriverUnlock(driver); > > - priv = vm->privateData; > - > - memset(&event, 0, sizeof(event)); > - memset(&info, 0, sizeof(info)); > - > - if (priv->waiterFD != fd || priv->eventHdl != watch) { > - virEventRemoveHandle(watch); > - priv->eventHdl = -1; > - goto cleanup; > - } > - > - if (!(events & VIR_EVENT_HANDLE_READABLE)) > - goto cleanup; > - > - if (libxl_get_event(&priv->ctx, &event)) > - goto cleanup; > - > - if (event.type == LIBXL_EVENT_DOMAIN_DEATH) { > + if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) { > virDomainShutoffReason reason; > > - /* libxl_event_get_domain_death_info returns 1 if death > - * event was for this domid */ > - if (libxl_event_get_domain_death_info(&priv->ctx, > - vm->def->id, > - &event, > - &info) != 1) > + if (event->domid != vm->def->id) > goto cleanup; > > - virEventRemoveHandle(watch); > - priv->eventHdl = -1; > - switch (info.shutdown_reason) { > - case SHUTDOWN_poweroff: > - case SHUTDOWN_crash: > - if (info.shutdown_reason == SHUTDOWN_crash) { > + switch (event->u.domain_shutdown.shutdown_reason) { > + case LIBXL_SHUTDOWN_REASON_POWEROFF: > + case LIBXL_SHUTDOWN_REASON_CRASH: > + if (event->u.domain_shutdown.shutdown_reason == LIBXL_SHUTDOWN_REASON_CRASH) { > dom_event = virDomainEventNewFromObj(vm, > VIR_DOMAIN_EVENT_STOPPED, > VIR_DOMAIN_EVENT_STOPPED_CRASHED); > @@ -430,18 +549,18 @@ static void libxlEventHandler(int watch, > } else { > reason = VIR_DOMAIN_SHUTOFF_SHUTDOWN; > } > - libxlVmReap(driver, vm, 0, reason); > + libxlVmReap(driver, vm, reason); > if (!vm->persistent) { > virDomainRemoveInactive(&driver->domains, vm); > vm = NULL; > } > break; > - case SHUTDOWN_reboot: > - libxlVmReap(driver, vm, 0, VIR_DOMAIN_SHUTOFF_SHUTDOWN); > + case LIBXL_SHUTDOWN_REASON_REBOOT: > + libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN); > libxlVmStart(driver, vm, 0, -1); > break; > default: > - VIR_INFO("Unhandled shutdown_reason %d", info.shutdown_reason); > + VIR_INFO("Unhandled shutdown_reason %d", event->u.domain_shutdown.shutdown_reason); > break; > } > } > @@ -454,9 +573,14 @@ cleanup: > libxlDomainEventQueue(driver, dom_event); > libxlDriverUnlock(driver); > } > - libxl_free_event(&event); > } > > +static const struct libxl_event_hooks ev_hooks = { > + .event_occurs_mask = LIBXL_EVENTMASK_ALL, > + .event_occurs = libxlEventHandler, > + .disaster = NULL, > +}; > + > /* > * Register domain events with libxenlight and insert event handles > * in libvirt's event loop. > @@ -465,40 +589,18 @@ static int > libxlCreateDomEvents(virDomainObjPtr vm) > { > libxlDomainObjPrivatePtr priv = vm->privateData; > - int fd; > > - if (VIR_ALLOC(priv->dWaiter) < 0) { > - virReportOOMError(); > - return -1; > - } > - > - if (libxl_wait_for_domain_death(&priv->ctx, vm->def->id, priv->dWaiter)) > - goto error; > - > - libxl_get_wait_fd(&priv->ctx, &fd); > - if (fd < 0) > - goto error; > + libxl_event_register_callbacks(priv->ctx, &ev_hooks, vm); > > - priv->waiterFD = fd; > - /* Add a reference to the domain object while it is injected in > - * the event loop. > - */ > - virObjectRef(vm); > - if ((priv->eventHdl = virEventAddHandle( > - fd, > - VIR_EVENT_HANDLE_READABLE | VIR_EVENT_HANDLE_ERROR, > - libxlEventHandler, > - vm, libxlDomainObjUnref)) < 0) { > - virObjectUnref(vm); > + if (libxl_evenable_domain_death(priv->ctx, vm->def->id, 0, &priv->deathW)) > goto error; > - } > > return 0; > > error: > - libxl_free_waiter(priv->dWaiter); > - VIR_FREE(priv->dWaiter); > - priv->eventHdl = -1; > + if (priv->deathW) > + libxl_evdisable_domain_death(priv->ctx, priv->deathW); > + VIR_FREE(priv->deathW); > return -1; > } > > @@ -507,7 +609,7 @@ libxlDomainSetVcpuAffinites(libxlDriverPrivatePtr driver, virDomainObjPtr vm) > { > libxlDomainObjPrivatePtr priv = vm->privateData; > virDomainDefPtr def = vm->def; > - libxl_cpumap map; > + libxl_bitmap map; > uint8_t *cpumask = NULL; > uint8_t *cpumap = NULL; > virNodeInfo nodeinfo; > @@ -539,7 +641,7 @@ libxlDomainSetVcpuAffinites(libxlDriverPrivatePtr driver, virDomainObjPtr vm) > map.size = cpumaplen; > map.map = cpumap; > > - if (libxl_set_vcpuaffinity(&priv->ctx, def->id, vcpu, &map) != 0) { > + if (libxl_set_vcpuaffinity(priv->ctx, def->id, vcpu, &map) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to pin vcpu '%d' with libxenlight"), vcpu); > goto cleanup; > @@ -565,11 +667,10 @@ libxlFreeMem(libxlDomainObjPrivatePtr priv, libxl_domain_config *d_config) > int tries = 3; > int wait_secs = 10; > > - if ((ret = libxl_domain_need_memory(&priv->ctx, &d_config->b_info, > - &d_config->dm_info, > + if ((ret = libxl_domain_need_memory(priv->ctx, &d_config->b_info, > &needed_mem)) >= 0) { > for (i = 0; i < tries; ++i) { > - if ((ret = libxl_get_free_memory(&priv->ctx, &free_mem)) < 0) > + if ((ret = libxl_get_free_memory(priv->ctx, &free_mem)) < 0) > break; > > if (free_mem >= needed_mem) { > @@ -577,17 +678,17 @@ libxlFreeMem(libxlDomainObjPrivatePtr priv, libxl_domain_config *d_config) > break; > } > > - if ((ret = libxl_set_memory_target(&priv->ctx, 0, > + if ((ret = libxl_set_memory_target(priv->ctx, 0, > free_mem - needed_mem, > /* relative */ 1, 0)) < 0) > break; > > - ret = libxl_wait_for_free_memory(&priv->ctx, 0, needed_mem, > + ret = libxl_wait_for_free_memory(priv->ctx, 0, needed_mem, > wait_secs); > if (ret == 0 || ret != ERROR_NOMEM) > break; > > - if ((ret = libxl_wait_for_memory_target(&priv->ctx, 0, 1)) < 0) > + if ((ret = libxl_wait_for_memory_target(priv->ctx, 0, 1)) < 0) > break; > } > } > @@ -613,7 +714,6 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > char *dom_xml = NULL; > char *managed_save_path = NULL; > int managed_save_fd = -1; > - pid_t child_console_pid = -1; > libxlDomainObjPrivatePtr priv = vm->privateData; > > /* If there is a managed saved state restore it instead of starting > @@ -657,7 +757,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > VIR_FREE(managed_save_path); > } > > - memset(&d_config, 0, sizeof(d_config)); > + libxl_domain_config_init(&d_config); > > if (libxlBuildDomainConfig(driver, vm->def, &d_config) < 0) > return -1; > @@ -669,13 +769,14 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > goto error; > } > > + /* use as synchronous operations => ao_how = NULL and no intermediate reports => ao_progress = NULL */ > + > if (restore_fd < 0) > - ret = libxl_domain_create_new(&priv->ctx, &d_config, > - NULL, &child_console_pid, &domid); > + ret = libxl_domain_create_new(priv->ctx, &d_config, > + &domid, NULL, NULL); > else > - ret = libxl_domain_create_restore(&priv->ctx, &d_config, NULL, > - &child_console_pid, &domid, > - restore_fd); > + ret = libxl_domain_create_restore(priv->ctx, &d_config, &domid, > + restore_fd, NULL, NULL); > > if (ret) { > if (restore_fd < 0) > @@ -693,7 +794,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > if ((dom_xml = virDomainDefFormat(vm->def, 0)) == NULL) > goto error; > > - if (libxl_userdata_store(&priv->ctx, domid, "libvirt-xml", > + if (libxl_userdata_store(priv->ctx, domid, "libvirt-xml", > (uint8_t *)dom_xml, strlen(dom_xml) + 1)) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("libxenlight failed to store userdata")); > @@ -707,7 +808,7 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > goto error; > > if (!start_paused) { > - libxl_domain_unpause(&priv->ctx, domid); > + libxl_domain_unpause(priv->ctx, domid); > virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); > } else { > virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); > @@ -723,18 +824,18 @@ libxlVmStart(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > VIR_DOMAIN_EVENT_STARTED_RESTORED); > libxlDomainEventQueue(driver, event); > > - libxl_domain_config_destroy(&d_config); > + libxl_domain_config_dispose(&d_config); > VIR_FREE(dom_xml); > VIR_FORCE_CLOSE(managed_save_fd); > return 0; > > error: > if (domid > 0) { > - libxl_domain_destroy(&priv->ctx, domid, 0); > + libxl_domain_destroy(priv->ctx, domid, NULL); > vm->def->id = -1; > virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_FAILED); > } > - libxl_domain_config_destroy(&d_config); > + libxl_domain_config_dispose(&d_config); > VIR_FREE(dom_xml); > VIR_FREE(managed_save_path); > virDomainDefFree(def); > @@ -762,7 +863,7 @@ libxlReconnectDomain(void *payload, > virDomainObjLock(vm); > > /* Does domain still exist? */ > - rc = libxl_domain_info(&driver->ctx, &d_info, vm->def->id); > + rc = libxl_domain_info(driver->ctx, &d_info, vm->def->id); > if (rc == ERROR_INVAL) { > goto out; > } else if (rc != 0) { > @@ -772,7 +873,7 @@ libxlReconnectDomain(void *payload, > } > > /* Is this a domain that was under libvirt control? */ > - if (libxl_userdata_retrieve(&driver->ctx, vm->def->id, > + if (libxl_userdata_retrieve(driver->ctx, vm->def->id, > "libvirt-xml", &data, &len)) { > VIR_DEBUG("libxl_userdata_retrieve failed, ignoring domain %d", vm->def->id); > goto out; > @@ -810,7 +911,7 @@ libxlShutdown(void) > libxlDriverLock(libxl_driver); > virCapabilitiesFree(libxl_driver->caps); > virDomainObjListDeinit(&libxl_driver->domains); > - libxl_ctx_free(&libxl_driver->ctx); > + libxl_ctx_free(libxl_driver->ctx); > xtl_logger_destroy(libxl_driver->logger); > if (libxl_driver->logger_file) > VIR_FORCE_FCLOSE(libxl_driver->logger_file); > @@ -943,14 +1044,14 @@ libxlStartup(int privileged) { > goto fail; > } > > - if (libxl_ctx_init(&libxl_driver->ctx, > - LIBXL_VERSION, > + if (libxl_ctx_alloc(&libxl_driver->ctx, > + LIBXL_VERSION, 0, > libxl_driver->logger)) { > VIR_INFO("cannot initialize libxenlight context, probably not running in a Xen Dom0, disabling driver"); > goto fail; > } > > - if ((ver_info = libxl_get_version_info(&libxl_driver->ctx)) == NULL) { > + if ((ver_info = libxl_get_version_info(libxl_driver->ctx)) == NULL) { > VIR_INFO("cannot version information from libxenlight, disabling driver"); > goto fail; > } > @@ -958,7 +1059,7 @@ libxlStartup(int privileged) { > (ver_info->xen_version_minor * 1000); > > if ((libxl_driver->caps = > - libxlMakeCapabilities(&libxl_driver->ctx)) == NULL) { > + libxlMakeCapabilities(libxl_driver->ctx)) == NULL) { > VIR_ERROR(_("cannot create capabilities for libxenlight")); > goto error; > } > @@ -1115,7 +1216,7 @@ libxlGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) > int ret; > libxlDriverPrivatePtr driver = conn->privateData; > > - ret = libxl_get_max_cpus(&driver->ctx); > + ret = libxl_get_max_cpus(driver->ctx); > /* libxl_get_max_cpus() will return 0 if there were any failures, > e.g. xc_physinfo() failing */ > if (ret == 0) > @@ -1320,7 +1421,7 @@ libxlDomainSuspend(virDomainPtr dom) > priv = vm->privateData; > > if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { > - if (libxl_domain_pause(&priv->ctx, dom->id) != 0) { > + if (libxl_domain_pause(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to suspend domain '%d' with libxenlight"), > dom->id); > @@ -1379,7 +1480,7 @@ libxlDomainResume(virDomainPtr dom) > priv = vm->privateData; > > if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { > - if (libxl_domain_unpause(&priv->ctx, dom->id) != 0) { > + if (libxl_domain_unpause(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to resume domain '%d' with libxenlight"), > dom->id); > @@ -1436,7 +1537,7 @@ libxlDomainShutdownFlags(virDomainPtr dom, unsigned int flags) > } > > priv = vm->privateData; > - if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_POWEROFF) != 0) { > + if (libxl_domain_shutdown(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to shutdown domain '%d' with libxenlight"), > dom->id); > @@ -1489,7 +1590,7 @@ libxlDomainReboot(virDomainPtr dom, unsigned int flags) > } > > priv = vm->privateData; > - if (libxl_domain_shutdown(&priv->ctx, dom->id, LIBXL_DOM_REQ_REBOOT) != 0) { > + if (libxl_domain_reboot(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to reboot domain '%d' with libxenlight"), > dom->id); > @@ -1534,7 +1635,7 @@ libxlDomainDestroyFlags(virDomainPtr dom, > event = virDomainEventNewFromObj(vm,VIR_DOMAIN_EVENT_STOPPED, > VIR_DOMAIN_EVENT_STOPPED_DESTROYED); > > - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { > + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to destroy domain '%d'"), dom->id); > goto cleanup; > @@ -1672,7 +1773,7 @@ libxlDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem, > > if (flags & VIR_DOMAIN_MEM_LIVE) { > priv = vm->privateData; > - if (libxl_domain_setmaxmem(&priv->ctx, dom->id, newmem) < 0) { > + if (libxl_domain_setmaxmem(priv->ctx, dom->id, newmem) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to set maximum memory for domain '%d'" > " with libxenlight"), dom->id); > @@ -1701,7 +1802,7 @@ libxlDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem, > > if (flags & VIR_DOMAIN_MEM_LIVE) { > priv = vm->privateData; > - if (libxl_set_memory_target(&priv->ctx, dom->id, newmem, 0, > + if (libxl_set_memory_target(priv->ctx, dom->id, newmem, 0, > /* force */ 1) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to set memory for domain '%d'" > @@ -1761,7 +1862,7 @@ libxlDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) > info->memory = vm->def->mem.cur_balloon; > info->maxMem = vm->def->mem.max_balloon; > } else { > - if (libxl_domain_info(&driver->ctx, &d_info, dom->id) != 0) { > + if (libxl_domain_info(driver->ctx, &d_info, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("libxl_domain_info failed for domain '%d'"), dom->id); > goto cleanup; > @@ -1861,7 +1962,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > goto cleanup; > } > > - if (libxl_domain_suspend(&priv->ctx, NULL, vm->def->id, fd) != 0) { > + if (libxl_domain_suspend(priv->ctx, vm->def->id, fd, 0, NULL) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to save domain '%d' with libxenlight"), > vm->def->id); > @@ -1871,7 +1972,7 @@ libxlDoDomainSave(libxlDriverPrivatePtr driver, virDomainObjPtr vm, > event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, > VIR_DOMAIN_EVENT_STOPPED_SAVED); > > - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_SAVED) != 0) { > + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_SAVED) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to destroy domain '%d'"), vm->def->id); > goto cleanup; > @@ -2028,7 +2129,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) > > if (!(flags & VIR_DUMP_LIVE) && > virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { > - if (libxl_domain_pause(&priv->ctx, dom->id) != 0) { > + if (libxl_domain_pause(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Before dumping core, failed to suspend domain '%d'" > " with libxenlight"), > @@ -2039,7 +2140,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) > paused = true; > } > > - if (libxl_domain_core_dump(&priv->ctx, dom->id, to) != 0) { > + if (libxl_domain_core_dump(priv->ctx, dom->id, to, NULL) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to dump core of domain '%d' with libxenlight"), > dom->id); > @@ -2048,7 +2149,7 @@ libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags) > > libxlDriverLock(driver); > if (flags & VIR_DUMP_CRASH) { > - if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_CRASHED) != 0) { > + if (libxlVmReap(driver, vm, VIR_DOMAIN_SHUTOFF_CRASHED) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to destroy domain '%d'"), dom->id); > goto cleanup_unlock; > @@ -2069,7 +2170,7 @@ cleanup_unlock: > libxlDriverUnlock(driver); > cleanup_unpause: > if (virDomainObjIsActive(vm) && paused) { > - if (libxl_domain_unpause(&priv->ctx, dom->id) != 0) { > + if (libxl_domain_unpause(priv->ctx, dom->id) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("After dumping core, failed to resume domain '%d' with" > " libxenlight"), dom->id); > @@ -2227,7 +2328,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, > libxlDomainObjPrivatePtr priv; > virDomainDefPtr def; > virDomainObjPtr vm; > - libxl_cpumap map; > + libxl_bitmap map; > uint8_t *bitmask = NULL; > unsigned int maplen; > unsigned int i, pos; > @@ -2322,7 +2423,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, > break; > > case VIR_DOMAIN_VCPU_LIVE: > - if (libxl_set_vcpuonline(&priv->ctx, dom->id, &map) != 0) { > + if (libxl_set_vcpuonline(priv->ctx, dom->id, &map) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to set vcpus for domain '%d'" > " with libxenlight"), dom->id); > @@ -2331,7 +2432,7 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, > break; > > case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG: > - if (libxl_set_vcpuonline(&priv->ctx, dom->id, &map) != 0) { > + if (libxl_set_vcpuonline(priv->ctx, dom->id, &map) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to set vcpus for domain '%d'" > " with libxenlight"), dom->id); > @@ -2427,7 +2528,7 @@ libxlDomainPinVcpu(virDomainPtr dom, unsigned int vcpu, unsigned char *cpumap, > libxlDomainObjPrivatePtr priv; > virDomainObjPtr vm; > int ret = -1; > - libxl_cpumap map; > + libxl_bitmap map; > > libxlDriverLock(driver); > vm = virDomainFindByUUID(&driver->domains, dom->uuid); > @@ -2448,7 +2549,7 @@ libxlDomainPinVcpu(virDomainPtr dom, unsigned int vcpu, unsigned char *cpumap, > > map.size = maplen; > map.map = cpumap; > - if (libxl_set_vcpuaffinity(&priv->ctx, dom->id, vcpu, &map) != 0) { > + if (libxl_set_vcpuaffinity(priv->ctx, dom->id, vcpu, &map) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to pin vcpu '%d' with libxenlight"), vcpu); > goto cleanup; > @@ -2511,7 +2612,7 @@ libxlDomainGetVcpus(virDomainPtr dom, virVcpuInfoPtr info, int maxinfo, > } > > priv = vm->privateData; > - if ((vcpuinfo = libxl_list_vcpu(&priv->ctx, dom->id, &maxcpu, > + if ((vcpuinfo = libxl_list_vcpu(priv->ctx, dom->id, &maxcpu, > &hostcpus)) == NULL) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to list vcpus for domain '%d' with libxenlight"), > @@ -2538,7 +2639,7 @@ libxlDomainGetVcpus(virDomainPtr dom, virVcpuInfoPtr info, int maxinfo, > MIN(maplen, vcpuinfo[i].cpumap.size)); > } > > - libxl_vcpuinfo_destroy(&vcpuinfo[i]); > + libxl_vcpuinfo_dispose(&vcpuinfo[i]); > } > VIR_FREE(vcpuinfo); > > @@ -2596,7 +2697,7 @@ libxlDomainXMLFromNative(virConnectPtr conn, const char * nativeFormat, > goto cleanup; > } > > - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { > + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { > VIR_ERROR(_("cannot get version information from libxenlight")); > goto cleanup; > } > @@ -2639,7 +2740,7 @@ libxlDomainXMLToNative(virConnectPtr conn, const char * nativeFormat, > goto cleanup; > } > > - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { > + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { > VIR_ERROR(_("cannot get version information from libxenlight")); > goto cleanup; > } > @@ -2899,10 +3000,10 @@ libxlDomainChangeEjectableMedia(libxlDomainObjPrivatePtr priv, > return -1; > } > > - if (libxlMakeDisk(vm->def, disk, &x_disk) < 0) > + if (libxlMakeDisk(disk, &x_disk) < 0) > goto cleanup; > > - if ((ret = libxl_cdrom_insert(&priv->ctx, vm->def->id, &x_disk)) < 0) { > + if ((ret = libxl_cdrom_insert(priv->ctx, vm->def->id, &x_disk, NULL)) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("libxenlight failed to change media for disk '%s'"), > disk->dst); > @@ -2954,11 +3055,11 @@ libxlDomainAttachDeviceDiskLive(libxlDomainObjPrivatePtr priv, > goto cleanup; > } > > - if (libxlMakeDisk(vm->def, l_disk, &x_disk) < 0) > + if (libxlMakeDisk(l_disk, &x_disk) < 0) > goto cleanup; > > - if ((ret = libxl_device_disk_add(&priv->ctx, vm->def->id, > - &x_disk)) < 0) { > + if ((ret = libxl_device_disk_add(priv->ctx, vm->def->id, > + &x_disk, NULL)) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("libxenlight failed to attach disk '%s'"), > l_disk->dst); > @@ -2991,7 +3092,6 @@ libxlDomainDetachDeviceDiskLive(libxlDomainObjPrivatePtr priv, > virDomainDiskDefPtr l_disk = NULL; > libxl_device_disk x_disk; > int i; > - int wait_secs = 2; > int ret = -1; > > switch (dev->data.disk->device) { > @@ -3008,11 +3108,11 @@ libxlDomainDetachDeviceDiskLive(libxlDomainObjPrivatePtr priv, > > l_disk = vm->def->disks[i]; > > - if (libxlMakeDisk(vm->def, l_disk, &x_disk) < 0) > + if (libxlMakeDisk(l_disk, &x_disk) < 0) > goto cleanup; > > - if ((ret = libxl_device_disk_del(&priv->ctx, &x_disk, > - wait_secs)) < 0) { > + if ((ret = libxl_device_disk_remove(priv->ctx, vm->def->id, > + &x_disk, NULL)) < 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("libxenlight failed to detach disk '%s'"), > l_disk->dst); > @@ -3383,13 +3483,13 @@ libxlNodeGetFreeMemory(virConnectPtr conn) > const libxl_version_info* ver_info; > libxlDriverPrivatePtr driver = conn->privateData; > > - if (libxl_get_physinfo(&driver->ctx, &phy_info)) { > + if (libxl_get_physinfo(driver->ctx, &phy_info)) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("libxl_get_physinfo_info failed")); > return 0; > } > > - if ((ver_info = libxl_get_version_info(&driver->ctx)) == NULL) { > + if ((ver_info = libxl_get_version_info(driver->ctx)) == NULL) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("libxl_get_version_info failed")); > return 0; > @@ -3536,7 +3636,7 @@ libxlDomainGetSchedulerType(virDomainPtr dom, int *nparams) > libxlDomainObjPrivatePtr priv; > virDomainObjPtr vm; > char * ret = NULL; > - int sched_id; > + libxl_scheduler sched_id; > > libxlDriverLock(driver); > vm = virDomainFindByUUID(&driver->domains, dom->uuid); > @@ -3553,31 +3653,29 @@ libxlDomainGetSchedulerType(virDomainPtr dom, int *nparams) > } > > priv = vm->privateData; > - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { > - virReportError(VIR_ERR_INTERNAL_ERROR, > - _("Failed to get scheduler id for domain '%d'" > - " with libxenlight"), dom->id); > - goto cleanup; > - } > + sched_id = libxl_get_scheduler(priv->ctx); > > if (nparams) > *nparams = 0; > switch (sched_id) { > - case XEN_SCHEDULER_SEDF: > + case LIBXL_SCHEDULER_SEDF: > ret = strdup("sedf"); > break; > - case XEN_SCHEDULER_CREDIT: > + case LIBXL_SCHEDULER_CREDIT: > ret = strdup("credit"); > if (nparams) > *nparams = XEN_SCHED_CREDIT_NPARAM; > break; > - case XEN_SCHEDULER_CREDIT2: > + case LIBXL_SCHEDULER_CREDIT2: > ret = strdup("credit2"); > break; > - case XEN_SCHEDULER_ARINC653: > + case LIBXL_SCHEDULER_ARINC653: > ret = strdup("arinc653"); > break; > default: > + virReportError(VIR_ERR_INTERNAL_ERROR, > + _("Failed to get scheduler id for domain '%d'" > + " with libxenlight"), dom->id); > goto cleanup; > } > > @@ -3599,8 +3697,8 @@ libxlDomainGetSchedulerParametersFlags(virDomainPtr dom, > libxlDriverPrivatePtr driver = dom->conn->privateData; > libxlDomainObjPrivatePtr priv; > virDomainObjPtr vm; > - libxl_sched_credit sc_info; > - int sched_id; > + libxl_domain_sched_params sc_info; > + libxl_scheduler sched_id; > int ret = -1; > > virCheckFlags(0, -1); > @@ -3610,31 +3708,28 @@ libxlDomainGetSchedulerParametersFlags(virDomainPtr dom, > libxlDriverUnlock(driver); > > if (!vm) { > - virReportError(VIR_ERR_NO_DOMAIN, "%s", _("no domain with matching uuid")); > + virReportError(VIR_ERR_NO_DOMAIN, "%s", > + _("no domain with matching uuid")); > goto cleanup; > } > > if (!virDomainObjIsActive(vm)) { > - virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not running")); > + virReportError(VIR_ERR_OPERATION_INVALID, "%s", > + _("Domain is not running")); > goto cleanup; > } > > priv = vm->privateData; > > - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { > - virReportError(VIR_ERR_INTERNAL_ERROR, > - _("Failed to get scheduler id for domain '%d'" > - " with libxenlight"), dom->id); > - goto cleanup; > - } > + sched_id = libxl_get_scheduler(priv->ctx); > > - if (sched_id != XEN_SCHEDULER_CREDIT) { > + if (sched_id != LIBXL_SCHEDULER_CREDIT) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("Only 'credit' scheduler is supported")); > goto cleanup; > } > > - if (libxl_sched_credit_domain_get(&priv->ctx, dom->id, &sc_info) != 0) { > + if (libxl_domain_sched_params_get(priv->ctx, dom->id, &sc_info) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to get scheduler parameters for domain '%d'" > " with libxenlight"), dom->id); > @@ -3677,7 +3772,7 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, > libxlDriverPrivatePtr driver = dom->conn->privateData; > libxlDomainObjPrivatePtr priv; > virDomainObjPtr vm; > - libxl_sched_credit sc_info; > + libxl_domain_sched_params sc_info; > int sched_id; > int i; > int ret = -1; > @@ -3707,20 +3802,15 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, > > priv = vm->privateData; > > - if ((sched_id = libxl_get_sched_id(&priv->ctx)) < 0) { > - virReportError(VIR_ERR_INTERNAL_ERROR, > - _("Failed to get scheduler id for domain '%d'" > - " with libxenlight"), dom->id); > - goto cleanup; > - } > + sched_id = libxl_get_scheduler(priv->ctx); > > - if (sched_id != XEN_SCHEDULER_CREDIT) { > + if (sched_id != LIBXL_SCHEDULER_CREDIT) { > virReportError(VIR_ERR_INTERNAL_ERROR, "%s", > _("Only 'credit' scheduler is supported")); > goto cleanup; > } > > - if (libxl_sched_credit_domain_get(&priv->ctx, dom->id, &sc_info) != 0) { > + if (libxl_domain_sched_params_get(priv->ctx, dom->id, &sc_info) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to get scheduler parameters for domain '%d'" > " with libxenlight"), dom->id); > @@ -3737,7 +3827,7 @@ libxlDomainSetSchedulerParametersFlags(virDomainPtr dom, > } > } > > - if (libxl_sched_credit_domain_set(&priv->ctx, dom->id, &sc_info) != 0) { > + if (libxl_domain_sched_params_set(priv->ctx, dom->id, &sc_info) != 0) { > virReportError(VIR_ERR_INTERNAL_ERROR, > _("Failed to set scheduler parameters for domain '%d'" > " with libxenlight"), dom->id); > -- > 1.7.10.4 > > > _______________________________________________ > Xen-devel mailing list > Xen-devel@lists.xen.org > http://lists.xen.org/xen-devel > _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-users-bounces@lists.xen.org Tue Nov 27 14:03:50 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 27 Nov 2012 14:03:50 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdLkH-00076M-NS; Tue, 27 Nov 2012 14:02:41 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdLkF-00076C-Cz for xen-users@lists.xen.org; Tue, 27 Nov 2012 14:02:39 +0000 Received: from [193.109.254.147:56334] by server-15.bemta-14.messagelabs.com id 5B/6D-12105-EF7C4B05; Tue, 27 Nov 2012 14:02:38 +0000 X-Env-Sender: altman87120@gmail.com X-Msg-Ref: server-12.tower-27.messagelabs.com!1354024931!8523553!1 X-Originating-IP: [209.85.160.45] X-SpamReason: No, hits=0.8 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 7831 invoked from network); 27 Nov 2012 14:02:14 -0000 Received: from mail-pb0-f45.google.com (HELO mail-pb0-f45.google.com) (209.85.160.45) by server-12.tower-27.messagelabs.com with RC4-SHA encrypted SMTP; 27 Nov 2012 14:02:14 -0000 Received: by mail-pb0-f45.google.com with SMTP id mc8so8936248pbc.32 for ; Tue, 27 Nov 2012 06:02:11 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:content-type:subject:message-id:date:to:mime-version:x-mailer; bh=V0K8b28f17ugSe9fxM/p8MaEE/iDcdjOifFM0w2d27U=; b=EtD0PsvqCtqorNAP4grXzLnTDjoZvnfsXT6XtImxYIoxmuBWzLvTQuKNcB24MZpQzm hgoVIyAMKBHHqo/OI1CqYD+ct+qnW/4P/5wBhH3aw5yxanTmJO1Xa4ZPQVuAUhTm18Z+ XLV0vDOapkiaWOHsfl5UYg2YvSiRMF1OQLutUUKb3wR9vshz/rGMlvGIcka6fB4RxpXB Xwv0ZGD7WAm6ZQ4Ctbyhlm97YA8cihtLyePtMjE2VhTbWSSO/ofMpCiyFrWW1jH2BW4j dMErCFrDQEM4riSk22qzIujKfiLGckHEzudwi8ToMNan3WIPXL5g5vlLF6TRWtdAmxdo vveg== Received: by 10.68.223.131 with SMTP id qu3mr47767147pbc.89.1354024929744; Tue, 27 Nov 2012 06:02:09 -0800 (PST) Received: from [192.168.108.14] ([221.234.46.28]) by mx.google.com with ESMTPS id o10sm10716537paz.37.2012.11.27.06.02.00 (version=TLSv1/SSLv3 cipher=OTHER); Tue, 27 Nov 2012 06:02:04 -0800 (PST) From: =?GB2312?B?vfAguOo=?= Content-Type: multipart/mixed; boundary="Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77" Message-Id: Date: Tue, 27 Nov 2012 22:02:00 +0800 To: xen-users@lists.xen.org Mime-Version: 1.0 (Mac OS X Mail 6.2 \(1499\)) X-Mailer: Apple Mail (2.1499) Subject: [Xen-users] DebianWheezy xen4.1 and Windows 7 thin pc , where is the error ocurr ? 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 --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset=us-ascii Hi, list.I'm new to xen. I follow this article = http://www.virtuatopia.com/index.php/Installing_and_Running_Windows_7_as_a= _Xen_HVM_domainU_Guest and install my first windows 7 xen guest. I just = change a little to need my fits. And This is my xenwin7.cfg kernel =3D"/usr/lib/xen-4.1/boot/hvmloader" builder=3D'hvm' memory =3D 1024 # Should be at least 2KB per MB of domain memory, plus a few MB per = vcpu. shadow_memory =3D 8 name =3D "xenwin7" #vif =3D [ 'type=3Dioemu, bridge=3Dxenbr0' ] acpi =3D 1 apic =3D 1 disk =3D [ 'file:/home/xen/xenwin7.img,hda,w', = 'file:/home/xen/windows7.iso,hdc:cdrom,r' ] device_model =3D '/usr/lib/xen-4.1/bin/qemu-dm' = #-------------------------------------------------------------------------= ---- # boot on floppy (a), hard disk (c) or CD-ROM (d) # default: hard disk, cd-rom, floppy boot=3D"dc" sdl=3D0 vnc=3D1 vncconsole=3D1 vncpasswd=3D'' when i start my guest and use my vnc client (vncviewer and Chicken = both!) connect to my windows7 machine. It just failed,=20 i use xm list: root@xenhost:/home# xm list Name ID Mem VCPUs State = Time(s) Domain-0 0 2243 4 r----- = 63.5 xenwin7 2 1024 1 r----- = 23.5 after a few seconds, the xenwin7 disappear.=20 root@xenhost:/home# xm list Name ID Mem VCPUs State = Time(s) Domain-0 0 2243 4 r----- = 65.2 I google a lot.But still doesn't know how to fix it. And this is the xenwin7 guest log. Using file /home/xen/xenwin7.img in read-write mode Using file /home/xen/windows7.iso in read-only mode Watching /local/domain/0/device-model/2/logdirty/cmd Watching /local/domain/0/device-model/2/command Watching /local/domain/2/cpu char device redirected to /dev/pts/2 qemu_map_cache_init nr_buckets =3D 10000 size 4194304 shared page at pfn feffd buffered io page at pfn feffb Guest uuid =3D 9d6fd940-b893-fdec-092d-208a90b9e5fc Time offset set 0 populating video RAM at ff000000 mapping video RAM from ff000000 Register xen platform. Done register platform. platform_fixed_ioport: changed ro/rw state of ROM memory area. now is rw = state. xs_read(/local/domain/0/device-model/2/xen_extended_power_mgmt): read = error xs_read(): vncpasswd get error. = /vm/9d6fd940-b893-fdec-092d-208a90b9e5fc/vncpasswd. medium change watch on `hdc' (index: 1): /home/xen/windows7.iso I/O request not ready: 0, ptr: 0, port: 0, data: 0, count: 0, size: 0 Log-dirty: no command yet. vcpu-set: watch node error. xs_read(/local/domain/2/log-throttling): read error qemu: ignoring not-understood drive `/local/domain/2/log-throttling' medium change watch on `/local/domain/2/log-throttling' - unknown = device, ignored char device redirected to /dev/pts/3 xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed cirrus vga map change while on lfb mode mapping vram to f0000000 - f0400000 platform_fixed_ioport: changed ro/rw state of ROM memory area. now is rw = state. platform_fixed_ioport: changed ro/rw state of ROM memory area. now is ro = state. I also upload other log for help. And anyone can give me a help?=20 --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 Content-Disposition: attachment; filename=qemu-dm-xenwin7.log Content-Type: application/octet-stream; name="qemu-dm-xenwin7.log" Content-Transfer-Encoding: 7bit domid: 2 Using file /home/xen/xenwin7.img in read-write mode Using file /home/xen/windows7.iso in read-only mode Watching /local/domain/0/device-model/2/logdirty/cmd Watching /local/domain/0/device-model/2/command Watching /local/domain/2/cpu char device redirected to /dev/pts/2 qemu_map_cache_init nr_buckets = 10000 size 4194304 shared page at pfn feffd buffered io page at pfn feffb Guest uuid = 9d6fd940-b893-fdec-092d-208a90b9e5fc Time offset set 0 populating video RAM at ff000000 mapping video RAM from ff000000 Register xen platform. Done register platform. platform_fixed_ioport: changed ro/rw state of ROM memory area. now is rw state. xs_read(/local/domain/0/device-model/2/xen_extended_power_mgmt): read error xs_read(): vncpasswd get error. /vm/9d6fd940-b893-fdec-092d-208a90b9e5fc/vncpasswd. medium change watch on `hdc' (index: 1): /home/xen/windows7.iso I/O request not ready: 0, ptr: 0, port: 0, data: 0, count: 0, size: 0 Log-dirty: no command yet. vcpu-set: watch node error. xs_read(/local/domain/2/log-throttling): read error qemu: ignoring not-understood drive `/local/domain/2/log-throttling' medium change watch on `/local/domain/2/log-throttling' - unknown device, ignored char device redirected to /dev/pts/3 xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed xen be: console-0: xen be: console-0: initialise() failed initialise() failed cirrus vga map change while on lfb mode mapping vram to f0000000 - f0400000 platform_fixed_ioport: changed ro/rw state of ROM memory area. now is rw state. platform_fixed_ioport: changed ro/rw state of ROM memory area. now is ro state. --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 Content-Disposition: attachment; filename=cpuinfo.txt Content-Type: text/plain; name="cpuinfo.txt" Content-Transfer-Encoding: quoted-printable root@xenhost:/var/log/xen# cat /proc/cpuinfo=20 processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 26 model name : Intel(R) Xeon(R) CPU E5506 @ 2.13GHz stepping : 5 microcode : 0x11 cpu MHz : 1600.011 cache size : 4096 KB physical id : 0 siblings : 1 core id : 0 cpu cores : 1 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu de tsc msr pae cx8 apic sep cmov pat clflush acpi = mmx fxsr sse sse2 ss ht syscall nx lm constant_tsc rep_good nopl = nonstop_tsc pni est ssse3 cx16 sse4_1 sse4_2 popcnt hypervisor lahf_lm = dtherm bogomips : 3200.02 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 26 model name : Intel(R) Xeon(R) CPU E5506 @ 2.13GHz stepping : 5 microcode : 0x11 cpu MHz : 1600.011 cache size : 4096 KB physical id : 0 siblings : 1 core id : 1 cpu cores : 1 apicid : 2 initial apicid : 2 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu de tsc msr pae cx8 apic sep cmov pat clflush acpi = mmx fxsr sse sse2 ss ht syscall nx lm constant_tsc rep_good nopl = nonstop_tsc pni est ssse3 cx16 sse4_1 sse4_2 popcnt hypervisor lahf_lm = dtherm bogomips : 3200.02 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: processor : 2 vendor_id : GenuineIntel cpu family : 6 model : 26 model name : Intel(R) Xeon(R) CPU E5506 @ 2.13GHz stepping : 5 microcode : 0x11 cpu MHz : 1600.011 cache size : 4096 KB physical id : 0 siblings : 1 core id : 2 cpu cores : 1 apicid : 4 initial apicid : 4 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu de tsc msr pae cx8 apic sep cmov pat clflush acpi = mmx fxsr sse sse2 ss ht syscall nx lm constant_tsc rep_good nopl = nonstop_tsc pni est ssse3 cx16 sse4_1 sse4_2 popcnt hypervisor lahf_lm = dtherm bogomips : 3200.02 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: processor : 3 vendor_id : GenuineIntel cpu family : 6 model : 26 model name : Intel(R) Xeon(R) CPU E5506 @ 2.13GHz stepping : 5 microcode : 0x11 cpu MHz : 1600.011 cache size : 4096 KB physical id : 0 siblings : 1 core id : 3 cpu cores : 1 apicid : 6 initial apicid : 6 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu de tsc msr pae cx8 apic sep cmov pat clflush acpi = mmx fxsr sse sse2 ss ht syscall nx lm constant_tsc rep_good nopl = nonstop_tsc pni est ssse3 cx16 sse4_1 sse4_2 popcnt hypervisor lahf_lm = dtherm bogomips : 3200.02 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management:= --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 Content-Disposition: attachment; filename=dmesg.txt Content-Type: text/plain; name="dmesg.txt" Content-Transfer-Encoding: quoted-printable [ 0.000000] Initializing cgroup subsys cpuset [ 0.000000] Initializing cgroup subsys cpu [ 0.000000] Linux version 3.2.0-4-amd64 = (debian-kernel@lists.debian.org) (gcc version 4.6.3 (Debian 4.6.3-12) ) = #1 SMP Debian 3.2.32-1 [ 0.000000] Command line: placeholder = root=3DUUID=3Dbea043b7-24b2-436a-b333-62a4cb361e12 ro quiet [ 0.000000] Freeing 9a-100 pfn range: 102 pages freed [ 0.000000] 1-1 mapping on 9a->100 [ 0.000000] Freeing 8c404-f03f3 pfn range: 409583 pages freed [ 0.000000] 1-1 mapping on 8c404->100000 [ 0.000000] Released 409685 pages of unused memory [ 0.000000] Set 474210 page(s) to 1-1 mapping [ 0.000000] BIOS-provided physical RAM map: [ 0.000000] Xen: 0000000000000000 - 000000000009a000 (usable) [ 0.000000] Xen: 000000000009a400 - 0000000000100000 (reserved) [ 0.000000] Xen: 0000000000100000 - 000000008c404000 (usable) [ 0.000000] Xen: 000000008c404000 - 000000008c4dc000 (ACPI NVS) [ 0.000000] Xen: 000000008c4dc000 - 000000008c5c2000 (ACPI data) [ 0.000000] Xen: 000000008c5c2000 - 000000008d9c2000 (ACPI NVS) [ 0.000000] Xen: 000000008d9c2000 - 000000008f602000 (ACPI data) [ 0.000000] Xen: 000000008f602000 - 000000008f64f000 (reserved) [ 0.000000] Xen: 000000008f64f000 - 000000008f6e6000 (ACPI data) [ 0.000000] Xen: 000000008f6e6000 - 000000008f6f0000 (ACPI NVS) [ 0.000000] Xen: 000000008f6f0000 - 000000008f6f2000 (ACPI data) [ 0.000000] Xen: 000000008f6f2000 - 000000008f7cf000 (ACPI NVS) [ 0.000000] Xen: 000000008f7cf000 - 000000008f800000 (ACPI data) [ 0.000000] Xen: 000000008f800000 - 0000000090000000 (reserved) [ 0.000000] Xen: 00000000a0000000 - 00000000b0000000 (reserved) [ 0.000000] Xen: 00000000fc000000 - 00000000fd000000 (reserved) [ 0.000000] Xen: 00000000fec00000 - 00000000fec01000 (reserved) [ 0.000000] Xen: 00000000fec90000 - 00000000fec91000 (reserved) [ 0.000000] Xen: 00000000fed1c000 - 00000000fed20000 (reserved) [ 0.000000] Xen: 00000000fee00000 - 00000000fee01000 (reserved) [ 0.000000] Xen: 00000000ff800000 - 0000000100000000 (reserved) [ 0.000000] Xen: 0000000100000000 - 0000000170000000 (usable) [ 0.000000] NX (Execute Disable) protection: active [ 0.000000] DMI 2.5 present. [ 0.000000] DMI: Intel Corporation S5500BC/S5500BC, BIOS = S5500.86B.01.00.0050.050620101605 05/06/2010 [ 0.000000] e820 update range: 0000000000000000 - 0000000000010000 = (usable) =3D=3D> (reserved) [ 0.000000] e820 remove range: 00000000000a0000 - 0000000000100000 = (usable) [ 0.000000] No AGP bridge found [ 0.000000] last_pfn =3D 0x170000 max_arch_pfn =3D 0x400000000 [ 0.000000] last_pfn =3D 0x8c404 max_arch_pfn =3D 0x400000000 [ 0.000000] initial memory mapped : 0 - 0386d000 [ 0.000000] Base memory trampoline at [ffff880000095000] 95000 size = 20480 [ 0.000000] init_memory_mapping: 0000000000000000-000000008c404000 [ 0.000000] 0000000000 - 008c404000 page 4k [ 0.000000] kernel direct mapping tables up to 8c404000 @ = b99000-1000000 [ 0.000000] xen: setting RW the range fd8000 - 1000000 [ 0.000000] init_memory_mapping: 0000000100000000-0000000170000000 [ 0.000000] 0100000000 - 0170000000 page 4k [ 0.000000] kernel direct mapping tables up to 170000000 @ = 8b87d000-8c404000 [ 0.000000] xen: setting RW the range 8bbff000 - 8c404000 [ 0.000000] RAMDISK: 0193d000 - 0386d000 [ 0.000000] ACPI: RSDP 00000000000f0410 00024 (v02 INTEL ) [ 0.000000] ACPI: XSDT 000000008f7fd120 00094 (v01 INTEL S5500BC = 00000000 01000013) [ 0.000000] ACPI: FACP 000000008f7fb000 000F4 (v04 INTEL S5500BC = 00000000 MSFT 0100000D) [ 0.000000] ACPI: DSDT 000000008f7f4000 06485 (v02 INTEL S5500BC = 00000003 MSFT 0100000D) [ 0.000000] ACPI: FACS 000000008f6f2000 00040 [ 0.000000] ACPI: APIC 000000008f7f3000 001A8 (v02 INTEL S5500BC = 00000000 MSFT 0100000D) [ 0.000000] ACPI: MCFG 000000008f7f2000 0003C (v01 INTEL S5500BC = 00000001 MSFT 0100000D) [ 0.000000] ACPI: HPET 000000008f7f1000 00038 (v01 INTEL S5500BC = 00000001 MSFT 0100000D) [ 0.000000] ACPI: SLIT 000000008f7f0000 00030 (v01 INTEL S5500BC = 00000001 MSFT 0100000D) [ 0.000000] ACPI: SPCR 000000008f7ef000 00050 (v01 INTEL S5500BC = 00000000 MSFT 0100000D) [ 0.000000] ACPI: WDDT 000000008f7ee000 00040 (v01 INTEL S5500BC = 00000000 MSFT 0100000D) [ 0.000000] ACPI: SSDT 000000008f7d3000 1AFC4 (v02 INTEL SSDT PM = 00004000 INTL 20061109) [ 0.000000] ACPI: SSDT 000000008f7d2000 001D8 (v02 INTEL IPMI = 00004000 INTL 20061109) [ 0.000000] ACPI: HEST 000000008f7d1000 000A8 (v01 INTEL S5500BC = 00000001 INTL 00000001) [ 0.000000] ACPI: BERT 000000008f7d0000 00030 (v01 INTEL S5500BC = 00000001 INTL 00000001) [ 0.000000] ACPI: ERST 000000008f7cf000 00230 (v01 INTEL S5500BC = 00000001 INTL 00000001) [ 0.000000] ACPI: EINJ 000000008f6f1000 00130 (v01 INTEL S5500BC = 00000001 INTL 00000001) [ 0.000000] ACPI: XMAR 000000008f6f0000 001C8 (v01 INTEL S5500BC = 00000001 MSFT 0100000D) [ 0.000000] ACPI: Local APIC address 0xfee00000 [ 0.000000] NUMA turned off [ 0.000000] Faking a node at 0000000000000000-0000000170000000 [ 0.000000] Initmem setup node 0 0000000000000000-0000000170000000 [ 0.000000] NODE_DATA [000000008c3ff000 - 000000008c403fff] [ 0.000000] Zone PFN ranges: [ 0.000000] DMA 0x00000010 -> 0x00001000 [ 0.000000] DMA32 0x00001000 -> 0x00100000 [ 0.000000] Normal 0x00100000 -> 0x00170000 [ 0.000000] Movable zone start PFN for each node [ 0.000000] early_node_map[3] active PFN ranges [ 0.000000] 0: 0x00000010 -> 0x0000009a [ 0.000000] 0: 0x00000100 -> 0x0008c404 [ 0.000000] 0: 0x00100000 -> 0x00170000 [ 0.000000] On node 0 totalpages: 1033102 [ 0.000000] DMA zone: 56 pages used for memmap [ 0.000000] DMA zone: 1092 pages reserved [ 0.000000] DMA zone: 2830 pages, LIFO batch:0 [ 0.000000] DMA32 zone: 14280 pages used for memmap [ 0.000000] DMA32 zone: 556092 pages, LIFO batch:31 [ 0.000000] Normal zone: 6272 pages used for memmap [ 0.000000] Normal zone: 452480 pages, LIFO batch:31 [ 0.000000] ACPI: PM-Timer IO Port: 0x408 [ 0.000000] ACPI: Local APIC address 0xfee00000 [ 0.000000] ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled) [ 0.000000] BIOS bug: APIC version is 0 for CPU 0/0x0, fixing up to = 0x10 [ 0.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x02] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x02] lapic_id[0x04] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x03] lapic_id[0x06] enabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x04] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x05] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x06] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x07] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x08] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x09] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0a] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0b] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0c] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0d] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0e] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x0f] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x10] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x11] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x12] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x13] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x14] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x15] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x16] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC (acpi_id[0x17] lapic_id[0xff] disabled) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x00] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x01] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x02] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x03] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x04] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x05] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x06] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x07] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x08] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x09] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0a] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0b] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0c] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0d] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0e] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x0f] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x10] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x11] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x12] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x13] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x14] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x15] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x16] high level lint[0x1]) [ 0.000000] ACPI: LAPIC_NMI (acpi_id[0x17] high level lint[0x1]) [ 0.000000] ACPI: IOAPIC (id[0x08] address[0xfec00000] gsi_base[0]) [ 0.000000] IOAPIC[0]: apic_id 8, version 255, address 0xfec00000, = GSI 0-255 [ 0.000000] ACPI: IOAPIC (id[0x09] address[0xfec90000] gsi_base[24]) [ 0.000000] IOAPIC[1]: apic_id 9, version 255, address 0xfec90000, = GSI 24-279 [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl) [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high = level) [ 0.000000] ACPI: IRQ0 used by override. [ 0.000000] ACPI: IRQ2 used by override. [ 0.000000] ACPI: IRQ9 used by override. [ 0.000000] Using ACPI (MADT) for SMP configuration information [ 0.000000] ACPI: HPET id: 0x8086a401 base: 0xfed00000 [ 0.000000] SMP: Allowing 24 CPUs, 20 hotplug CPUs [ 0.000000] nr_irqs_gsi: 296 [ 0.000000] PM: Registered nosave memory: 000000000009a000 - = 000000000009b000 [ 0.000000] PM: Registered nosave memory: 000000000009b000 - = 0000000000100000 [ 0.000000] PM: Registered nosave memory: 000000008c404000 - = 000000008c4dc000 [ 0.000000] PM: Registered nosave memory: 000000008c4dc000 - = 000000008c5c2000 [ 0.000000] PM: Registered nosave memory: 000000008c5c2000 - = 000000008d9c2000 [ 0.000000] PM: Registered nosave memory: 000000008d9c2000 - = 000000008f602000 [ 0.000000] PM: Registered nosave memory: 000000008f602000 - = 000000008f64f000 [ 0.000000] PM: Registered nosave memory: 000000008f64f000 - = 000000008f6e6000 [ 0.000000] PM: Registered nosave memory: 000000008f6e6000 - = 000000008f6f0000 [ 0.000000] PM: Registered nosave memory: 000000008f6f0000 - = 000000008f6f2000 [ 0.000000] PM: Registered nosave memory: 000000008f6f2000 - = 000000008f7cf000 [ 0.000000] PM: Registered nosave memory: 000000008f7cf000 - = 000000008f800000 [ 0.000000] PM: Registered nosave memory: 000000008f800000 - = 0000000090000000 [ 0.000000] PM: Registered nosave memory: 0000000090000000 - = 00000000a0000000 [ 0.000000] PM: Registered nosave memory: 00000000a0000000 - = 00000000b0000000 [ 0.000000] PM: Registered nosave memory: 00000000b0000000 - = 00000000fc000000 [ 0.000000] PM: Registered nosave memory: 00000000fc000000 - = 00000000fd000000 [ 0.000000] PM: Registered nosave memory: 00000000fd000000 - = 00000000fec00000 [ 0.000000] PM: Registered nosave memory: 00000000fec00000 - = 00000000fec01000 [ 0.000000] PM: Registered nosave memory: 00000000fec01000 - = 00000000fec90000 [ 0.000000] PM: Registered nosave memory: 00000000fec90000 - = 00000000fec91000 [ 0.000000] PM: Registered nosave memory: 00000000fec91000 - = 00000000fed1c000 [ 0.000000] PM: Registered nosave memory: 00000000fed1c000 - = 00000000fed20000 [ 0.000000] PM: Registered nosave memory: 00000000fed20000 - = 00000000fee00000 [ 0.000000] PM: Registered nosave memory: 00000000fee00000 - = 00000000fee01000 [ 0.000000] PM: Registered nosave memory: 00000000fee01000 - = 00000000ff800000 [ 0.000000] PM: Registered nosave memory: 00000000ff800000 - = 0000000100000000 [ 0.000000] Allocating PCI resources starting at b0000000 (gap: = b0000000:4c000000) [ 0.000000] Booting paravirtualized kernel on Xen [ 0.000000] Xen version: 4.1.3 (preserve-AD) [ 0.000000] setup_percpu: NR_CPUS:512 nr_cpumask_bits:512 = nr_cpu_ids:24 nr_node_ids:1 [ 0.000000] PERCPU: Embedded 28 pages/cpu @ffff88008b400000 s82880 = r8192 d23616 u131072 [ 0.000000] pcpu-alloc: s82880 r8192 d23616 u131072 alloc=3D1*2097152 [ 0.000000] pcpu-alloc: [0] 00 01 02 03 04 05 06 07 08 09 10 11 12 13 = 14 15=20 [ 0.000000] pcpu-alloc: [0] 16 17 18 19 20 21 22 23 -- -- -- -- -- -- = -- --=20 [ 1.639645] Built 1 zonelists in Node order, mobility grouping on. = Total pages: 1011402 [ 1.639649] Policy zone: Normal [ 1.639652] Kernel command line: placeholder = root=3DUUID=3Dbea043b7-24b2-436a-b333-62a4cb361e12 ro quiet [ 1.639719] PID hash table entries: 4096 (order: 3, 32768 bytes) [ 1.679060] Placing 64MB software IO TLB between ffff880083400000 - = ffff880087400000 [ 1.679065] software IO TLB at phys 0x83400000 - 0x87400000 [ 1.690989] Memory: 2114864k/6029312k available (3416k kernel code, = 1896904k absent, 2017544k reserved, 3319k data, 576k init) [ 1.691107] Hierarchical RCU implementation. [ 1.691109] RCU dyntick-idle grace-period acceleration is enabled. [ 1.691122] NR_IRQS:33024 nr_irqs:1024 16 [ 1.691231] xen: sci override: global_irq=3D9 trigger=3D0 polarity=3D0 [ 1.691235] xen: registering gsi 9 triggering 0 polarity 0 [ 1.691248] xen: --> pirq=3D9 -> irq=3D9 (gsi=3D9) [ 1.691285] xen: acpi sci 9 [ 1.691289] xen: --> pirq=3D1 -> irq=3D1 (gsi=3D1) [ 1.691293] xen: --> pirq=3D2 -> irq=3D2 (gsi=3D2) [ 1.691297] xen: --> pirq=3D3 -> irq=3D3 (gsi=3D3) [ 1.691301] xen: --> pirq=3D4 -> irq=3D4 (gsi=3D4) [ 1.691306] xen: --> pirq=3D5 -> irq=3D5 (gsi=3D5) [ 1.691310] xen: --> pirq=3D6 -> irq=3D6 (gsi=3D6) [ 1.691314] xen: --> pirq=3D7 -> irq=3D7 (gsi=3D7) [ 1.691318] xen: --> pirq=3D8 -> irq=3D8 (gsi=3D8) [ 1.691322] xen: --> pirq=3D10 -> irq=3D10 (gsi=3D10) [ 1.691326] xen: --> pirq=3D11 -> irq=3D11 (gsi=3D11) [ 1.691331] xen: --> pirq=3D12 -> irq=3D12 (gsi=3D12) [ 1.691335] xen: --> pirq=3D13 -> irq=3D13 (gsi=3D13) [ 1.691339] xen: --> pirq=3D14 -> irq=3D14 (gsi=3D14) [ 1.691343] xen: --> pirq=3D15 -> irq=3D15 (gsi=3D15) [ 1.701137] Console: colour VGA+ 80x25 [ 1.701181] console [tty0] enabled [ 1.701221] Xen: using vcpuop timer interface [ 1.701227] installing Xen timer for CPU 0 [ 1.701252] Detected 1600.011 MHz processor. [ 1.701258] Calibrating delay loop (skipped), value calculated using = timer frequency.. 3200.02 BogoMIPS (lpj=3D6400044) [ 1.701263] pid_max: default: 32768 minimum: 301 [ 1.701317] Security Framework initialized [ 1.701323] AppArmor: AppArmor disabled by boot time parameter [ 1.703042] Dentry cache hash table entries: 524288 (order: 10, = 4194304 bytes) [ 1.705443] Inode-cache hash table entries: 262144 (order: 9, 2097152 = bytes) [ 1.706226] Mount-cache hash table entries: 256 [ 1.706376] Initializing cgroup subsys cpuacct [ 1.706383] Initializing cgroup subsys memory [ 1.706397] Initializing cgroup subsys devices [ 1.706400] Initializing cgroup subsys freezer [ 1.706402] Initializing cgroup subsys net_cls [ 1.706405] Initializing cgroup subsys blkio [ 1.706414] Initializing cgroup subsys perf_event [ 1.706491] CPU: Physical Processor ID: 0 [ 1.706493] CPU: Processor Core ID: 0 [ 1.707131] ACPI: Core revision 20110623 [ 1.736396] Performance Events: unsupported p6 CPU model 26 no PMU = driver, software events only. [ 1.736559] NMI watchdog disabled (cpu0): hardware events not enabled [ 1.736691] installing Xen timer for CPU 1 [ 1.736862] NMI watchdog disabled (cpu1): hardware events not enabled [ 1.736989] installing Xen timer for CPU 2 [ 1.737138] NMI watchdog disabled (cpu2): hardware events not enabled [ 1.737261] installing Xen timer for CPU 3 [ 1.737409] NMI watchdog disabled (cpu3): hardware events not enabled [ 1.737437] Brought up 4 CPUs [ 1.737772] devtmpfs: initialized [ 1.742014] PM: Registering ACPI NVS region at 8c404000 (884736 = bytes) [ 1.742065] PM: Registering ACPI NVS region at 8c5c2000 (20971520 = bytes) [ 1.743249] PM: Registering ACPI NVS region at 8f6e6000 (40960 bytes) [ 1.743254] PM: Registering ACPI NVS region at 8f6f2000 (905216 = bytes) [ 1.743446] Grant table initialized [ 1.743531] print_constraints: dummy:=20 [ 1.743625] NET: Registered protocol family 16 [ 1.743853] ACPI FADT declares the system doesn't support PCIe ASPM, = so disable it [ 1.743858] ACPI: bus type pci registered [ 1.743980] PCI: MMCONFIG for domain 0000 [bus 00-ff] at [mem = 0xa0000000-0xafffffff] (base 0xa0000000) [ 1.743985] PCI: MMCONFIG at [mem 0xa0000000-0xafffffff] reserved in = E820 [ 1.853287] PCI: Using configuration type 1 for base access [ 1.854417] bio: create slab at 0 [ 1.854602] ACPI: Added _OSI(Module Device) [ 1.854606] ACPI: Added _OSI(Processor Device) [ 1.854608] ACPI: Added _OSI(3.0 _SCP Extensions) [ 1.854611] ACPI: Added _OSI(Processor Aggregator Device) [ 1.856711] ACPI: EC: Look up EC in DSDT [ 1.919216] ACPI Error: Field [CPB3] at 96 exceeds Buffer [NULL] size = 64 (bits) (20110623/dsopcode-236) [ 1.919224] ACPI Error: Method parse/execution failed [\_SB_._OSC] = (Node ffff880083276d80), AE_AML_BUFFER_LIMIT (20110623/psparse-536) [ 1.921401] ACPI: Interpreter enabled [ 1.921407] ACPI: (supports S0 S1 S5) [ 1.921430] ACPI: Using IOAPIC for interrupt routing [ 1.931689] ACPI: No dock devices found. [ 1.931761] HEST: Table parsing has been initialized. [ 1.931766] PCI: Using host bridge windows from ACPI; if necessary, = use "pci=3Dnocrs" and report a bug [ 1.932492] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-fd]) [ 1.933633] pci_root PNP0A08:00: host bridge window [io = 0x0000-0x0cf7] [ 1.933638] pci_root PNP0A08:00: host bridge window [io = 0x0d00-0xffff] [ 1.933641] pci_root PNP0A08:00: host bridge window [mem = 0x000a0000-0x000bffff] [ 1.933644] pci_root PNP0A08:00: host bridge window [mem = 0x000c4000-0x000cbfff] [ 1.933648] pci_root PNP0A08:00: host bridge window [mem = 0xfed40000-0xfedfffff] [ 1.933651] pci_root PNP0A08:00: host bridge window [mem = 0xb0000000-0xfdffffff] [ 1.933659] pci_root PNP0A08:00: ignoring host bridge window [mem = 0x000c4000-0x000cbfff] (conflicts with Video ROM [mem = 0x000c0000-0x000c7fff]) [ 1.933694] pci 0000:00:00.0: [8086:3403] type 0 class 0x000600 [ 1.933841] pci 0000:00:00.0: PME# supported from D0 D3hot D3cold [ 1.933902] pci 0000:00:01.0: [8086:3408] type 1 class 0x000604 [ 1.934058] pci 0000:00:01.0: PME# supported from D0 D3hot D3cold [ 1.934122] pci 0000:00:03.0: [8086:340a] type 1 class 0x000604 [ 1.934280] pci 0000:00:03.0: PME# supported from D0 D3hot D3cold [ 1.934347] pci 0000:00:07.0: [8086:340e] type 1 class 0x000604 [ 1.934504] pci 0000:00:07.0: PME# supported from D0 D3hot D3cold [ 1.934569] pci 0000:00:09.0: [8086:3410] type 1 class 0x000604 [ 1.934726] pci 0000:00:09.0: PME# supported from D0 D3hot D3cold [ 1.934788] pci 0000:00:10.0: [8086:3425] type 0 class 0x000800 [ 1.934969] pci 0000:00:10.1: [8086:3426] type 0 class 0x000800 [ 1.935127] pci 0000:00:11.0: [8086:3427] type 0 class 0x000800 [ 1.935308] pci 0000:00:11.1: [8086:3428] type 0 class 0x000800 [ 1.935467] pci 0000:00:13.0: [8086:342d] type 0 class 0x000800 [ 1.935496] pci 0000:00:13.0: reg 10: [mem 0xb2745000-0xb2745fff] [ 1.935632] pci 0000:00:13.0: PME# supported from D0 D3hot D3cold [ 1.935682] pci 0000:00:14.0: [8086:342e] type 0 class 0x000800 [ 1.935864] pci 0000:00:14.1: [8086:3422] type 0 class 0x000800 [ 1.936057] pci 0000:00:14.2: [8086:3423] type 0 class 0x000800 [ 1.936231] pci 0000:00:14.3: [8086:3438] type 0 class 0x000800 [ 1.936378] pci 0000:00:15.0: [8086:342f] type 0 class 0x000800 [ 1.936542] pci 0000:00:16.0: [8086:3430] type 0 class 0x000880 [ 1.936573] pci 0000:00:16.0: reg 10: [mem 0xb2720000-0xb2723fff = 64bit] [ 1.936766] pci 0000:00:16.1: [8086:3431] type 0 class 0x000880 [ 1.936797] pci 0000:00:16.1: reg 10: [mem 0xb2724000-0xb2727fff = 64bit] [ 1.936989] pci 0000:00:16.2: [8086:3432] type 0 class 0x000880 [ 1.937020] pci 0000:00:16.2: reg 10: [mem 0xb2728000-0xb272bfff = 64bit] [ 1.937213] pci 0000:00:16.3: [8086:3433] type 0 class 0x000880 [ 1.937244] pci 0000:00:16.3: reg 10: [mem 0xb272c000-0xb272ffff = 64bit] [ 1.937436] pci 0000:00:16.4: [8086:3429] type 0 class 0x000880 [ 1.937467] pci 0000:00:16.4: reg 10: [mem 0xb2730000-0xb2733fff = 64bit] [ 1.937660] pci 0000:00:16.5: [8086:342a] type 0 class 0x000880 [ 1.937691] pci 0000:00:16.5: reg 10: [mem 0xb2734000-0xb2737fff = 64bit] [ 1.937883] pci 0000:00:16.6: [8086:342b] type 0 class 0x000880 [ 1.937914] pci 0000:00:16.6: reg 10: [mem 0xb2738000-0xb273bfff = 64bit] [ 1.938106] pci 0000:00:16.7: [8086:342c] type 0 class 0x000880 [ 1.938137] pci 0000:00:16.7: reg 10: [mem 0xb273c000-0xb273ffff = 64bit] [ 1.938338] pci 0000:00:19.0: [8086:10cc] type 0 class 0x000200 [ 1.938380] pci 0000:00:19.0: reg 10: [mem 0xb2700000-0xb271ffff] [ 1.938399] pci 0000:00:19.0: reg 14: [mem 0xb2744000-0xb2744fff] [ 1.938417] pci 0000:00:19.0: reg 18: [io 0x3100-0x311f] [ 1.938566] pci 0000:00:19.0: PME# supported from D0 D3hot D3cold [ 1.938614] pci 0000:00:1a.0: [8086:3a37] type 0 class 0x000c03 [ 1.938711] pci 0000:00:1a.0: reg 20: [io 0x30e0-0x30ff] [ 1.938828] pci 0000:00:1a.1: [8086:3a38] type 0 class 0x000c03 [ 1.938925] pci 0000:00:1a.1: reg 20: [io 0x30c0-0x30df] [ 1.939041] pci 0000:00:1a.2: [8086:3a39] type 0 class 0x000c03 [ 1.939138] pci 0000:00:1a.2: reg 20: [io 0x30a0-0x30bf] [ 1.939277] pci 0000:00:1a.7: [8086:3a3c] type 0 class 0x000c03 [ 1.939321] pci 0000:00:1a.7: reg 10: [mem 0xb2742000-0xb27423ff] [ 1.939517] pci 0000:00:1a.7: PME# supported from D0 D3hot D3cold [ 1.939569] pci 0000:00:1c.0: [8086:3a40] type 1 class 0x000604 [ 1.939737] pci 0000:00:1c.0: PME# supported from D0 D3hot D3cold [ 1.939799] pci 0000:00:1c.4: [8086:3a48] type 1 class 0x000604 [ 1.939967] pci 0000:00:1c.4: PME# supported from D0 D3hot D3cold [ 1.940027] pci 0000:00:1d.0: [8086:3a34] type 0 class 0x000c03 [ 1.940131] pci 0000:00:1d.0: reg 20: [io 0x3080-0x309f] [ 1.940249] pci 0000:00:1d.1: [8086:3a35] type 0 class 0x000c03 [ 1.940346] pci 0000:00:1d.1: reg 20: [io 0x3060-0x307f] [ 1.940463] pci 0000:00:1d.2: [8086:3a36] type 0 class 0x000c03 [ 1.940560] pci 0000:00:1d.2: reg 20: [io 0x3040-0x305f] [ 1.940696] pci 0000:00:1d.7: [8086:3a3a] type 0 class 0x000c03 [ 1.940741] pci 0000:00:1d.7: reg 10: [mem 0xb2741000-0xb27413ff] [ 1.940937] pci 0000:00:1d.7: PME# supported from D0 D3hot D3cold [ 1.940984] pci 0000:00:1e.0: [8086:244e] type 1 class 0x000604 [ 1.941132] pci 0000:00:1f.0: [8086:3a16] type 0 class 0x000601 [ 1.941294] pci 0000:00:1f.0: ICH7 LPC Generic IO decode 1 PIO at = 0680 (mask 000f) [ 1.941300] pci 0000:00:1f.0: ICH7 LPC Generic IO decode 2 PIO at = 0ca0 (mask 000f) [ 1.941306] pci 0000:00:1f.0: ICH7 LPC Generic IO decode 3 PIO at = 0600 (mask 001f) [ 1.941410] pci 0000:00:1f.2: [8086:3a22] type 0 class 0x000106 [ 1.941455] pci 0000:00:1f.2: reg 10: [io 0x3128-0x312f] [ 1.941473] pci 0000:00:1f.2: reg 14: [io 0x3134-0x3137] [ 1.941491] pci 0000:00:1f.2: reg 18: [io 0x3120-0x3127] [ 1.941509] pci 0000:00:1f.2: reg 1c: [io 0x3130-0x3133] [ 1.941527] pci 0000:00:1f.2: reg 20: [io 0x3020-0x303f] [ 1.941545] pci 0000:00:1f.2: reg 24: [mem 0xb2740000-0xb27407ff] [ 1.941658] pci 0000:00:1f.2: PME# supported from D3hot [ 1.941701] pci 0000:00:1f.3: [8086:3a30] type 0 class 0x000c05 [ 1.941735] pci 0000:00:1f.3: reg 10: [mem 0xb2743000-0xb27430ff = 64bit] [ 1.941785] pci 0000:00:1f.3: reg 20: [io 0x3000-0x301f] [ 1.941979] pci 0000:01:00.0: [8086:10d3] type 0 class 0x000200 [ 1.942013] pci 0000:01:00.0: reg 10: [mem 0xb2600000-0xb261ffff] [ 1.942038] pci 0000:01:00.0: reg 14: [mem 0xb2500000-0xb25fffff] [ 1.942063] pci 0000:01:00.0: reg 18: [io 0x2000-0x201f] [ 1.942088] pci 0000:01:00.0: reg 1c: [mem 0xb2620000-0xb2623fff] [ 1.942157] pci 0000:01:00.0: reg 30: [mem 0xfffc0000-0xffffffff = pref] [ 1.942290] pci 0000:01:00.0: PME# supported from D0 D3hot D3cold [ 1.942925] pci 0000:00:01.0: PCI bridge to [bus 01-01] [ 1.942932] pci 0000:00:01.0: bridge window [io 0x2000-0x2fff] [ 1.942939] pci 0000:00:01.0: bridge window [mem = 0xb2500000-0xb26fffff] [ 1.943044] pci 0000:00:03.0: PCI bridge to [bus 02-02] [ 1.943156] pci 0000:00:07.0: PCI bridge to [bus 03-03] [ 1.943267] pci 0000:00:09.0: PCI bridge to [bus 04-04] [ 1.943417] pci 0000:05:00.0: [8086:10c9] type 0 class 0x000200 [ 1.943447] pci 0000:05:00.0: reg 10: [mem 0xb2420000-0xb243ffff] [ 1.943469] pci 0000:05:00.0: reg 14: [mem 0xb2000000-0xb23fffff] [ 1.943490] pci 0000:05:00.0: reg 18: [io 0x1020-0x103f] [ 1.943512] pci 0000:05:00.0: reg 1c: [mem 0xb24c4000-0xb24c7fff] [ 1.943572] pci 0000:05:00.0: reg 30: [mem 0xffc00000-0xffffffff = pref] [ 1.943687] pci 0000:05:00.0: PME# supported from D0 D3hot D3cold [ 1.943763] pci 0000:05:00.0: reg 184: [mem 0xb2440000-0xb2443fff = 64bit] [ 1.943796] pci 0000:05:00.0: reg 190: [mem 0xb2460000-0xb2463fff = 64bit] [ 1.943862] pci 0000:05:00.1: [8086:10c9] type 0 class 0x000200 [ 1.943891] pci 0000:05:00.1: reg 10: [mem 0xb2400000-0xb241ffff] [ 1.943913] pci 0000:05:00.1: reg 14: [mem 0xb1c00000-0xb1ffffff] [ 1.943935] pci 0000:05:00.1: reg 18: [io 0x1000-0x101f] [ 1.943957] pci 0000:05:00.1: reg 1c: [mem 0xb24c0000-0xb24c3fff] [ 1.944016] pci 0000:05:00.1: reg 30: [mem 0xffc00000-0xffffffff = pref] [ 1.944141] pci 0000:05:00.1: PME# supported from D0 D3hot D3cold [ 1.944208] pci 0000:05:00.1: reg 184: [mem 0xb2480000-0xb2483fff = 64bit] [ 1.944242] pci 0000:05:00.1: reg 190: [mem 0xb24a0000-0xb24a3fff = 64bit] [ 1.952204] pci 0000:00:1c.0: PCI bridge to [bus 05-07] [ 1.952212] pci 0000:00:1c.0: bridge window [io 0x1000-0x1fff] [ 1.952220] pci 0000:00:1c.0: bridge window [mem = 0xb1c00000-0xb24fffff] [ 1.952359] pci 0000:08:00.0: [102b:0522] type 0 class 0x000300 [ 1.952393] pci 0000:08:00.0: reg 10: [mem 0xb0000000-0xb0ffffff = pref] [ 1.952418] pci 0000:08:00.0: reg 14: [mem 0xb1800000-0xb1803fff] [ 1.952443] pci 0000:08:00.0: reg 18: [mem 0xb1000000-0xb17fffff] [ 1.952533] pci 0000:08:00.0: reg 30: [mem 0xffff0000-0xffffffff = pref] [ 1.960283] pci 0000:00:1c.4: PCI bridge to [bus 08-08] [ 1.960295] pci 0000:00:1c.4: bridge window [mem = 0xb1000000-0xb18fffff] [ 1.960307] pci 0000:00:1c.4: bridge window [mem = 0xb0000000-0xb0ffffff 64bit pref] [ 1.960438] pci 0000:00:1e.0: PCI bridge to [bus 09-09] (subtractive = decode) [ 1.960460] pci 0000:00:1e.0: bridge window [io 0x0000-0x0cf7] = (subtractive decode) [ 1.960464] pci 0000:00:1e.0: bridge window [io 0x0d00-0xffff] = (subtractive decode) [ 1.960468] pci 0000:00:1e.0: bridge window [mem = 0x000a0000-0x000bffff] (subtractive decode) [ 1.960471] pci 0000:00:1e.0: bridge window [mem = 0xfed40000-0xfedfffff] (subtractive decode) [ 1.960475] pci 0000:00:1e.0: bridge window [mem = 0xb0000000-0xfdffffff] (subtractive decode) [ 1.960544] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT] [ 1.972954] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.MRP1._PRT] [ 1.973042] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.MRP3._PRT] [ 1.973167] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.MRP7._PRT] [ 1.973281] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.MRP9._PRT] [ 1.973447] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.PEX0._PRT] [ 1.973565] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.PEX4._PRT] [ 1.973637] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.IP2P._PRT] [ 1.973901] pci0000:00: Requesting ACPI _OSC control (0x1d) [ 1.974136] pci0000:00: ACPI _OSC control (0x1d) granted [ 1.997628] ACPI: PCI Interrupt Link [LNKA] (IRQs 3 4 5 6 7 9 10 *11 = 12 14 15) [ 1.997739] ACPI: PCI Interrupt Link [LNKB] (IRQs 3 4 5 6 7 9 *10 11 = 12 14 15) [ 1.997844] ACPI: PCI Interrupt Link [LNKC] (IRQs 3 4 5 6 7 *9 10 11 = 12 14 15) [ 1.997948] ACPI: PCI Interrupt Link [LNKD] (IRQs 3 4 *5 6 7 9 10 11 = 12 14 15) [ 1.998052] ACPI: PCI Interrupt Link [LNKE] (IRQs 3 4 5 6 7 9 10 *11 = 12 14 15) [ 1.998156] ACPI: PCI Interrupt Link [LNKF] (IRQs 3 4 5 6 7 9 10 11 = 12 14 15) *0, disabled. [ 1.998262] ACPI: PCI Interrupt Link [LNKG] (IRQs 3 4 5 6 7 9 10 11 = 12 14 15) *0, disabled. [ 1.998367] ACPI: PCI Interrupt Link [LNKH] (IRQs 3 4 5 6 7 9 10 11 = 12 14 15) *0, disabled. [ 1.998424] xen/balloon: Initialising balloon driver. [ 2.007892] xen-balloon: Initialising balloon driver. [ 2.008089] vgaarb: device added: = PCI:0000:08:00.0,decodes=3Dio+mem,owns=3Dio+mem,locks=3Dnone [ 2.008093] vgaarb: loaded [ 2.008095] vgaarb: bridge control possible 0000:08:00.0 [ 2.008158] PCI: Using ACPI for IRQ routing [ 2.024834] PCI: Discovered peer bus ff [ 2.024905] pci 0000:ff:00.0: [8086:2c40] type 0 class 0x000600 [ 2.024989] pci 0000:ff:00.1: [8086:2c01] type 0 class 0x000600 [ 2.025077] pci 0000:ff:02.0: [8086:2c10] type 0 class 0x000600 [ 2.025154] pci 0000:ff:02.1: [8086:2c11] type 0 class 0x000600 [ 2.025233] pci 0000:ff:02.4: [8086:2c14] type 0 class 0x000600 [ 2.025309] pci 0000:ff:02.5: [8086:2c15] type 0 class 0x000600 [ 2.025388] pci 0000:ff:03.0: [8086:2c18] type 0 class 0x000600 [ 2.025464] pci 0000:ff:03.1: [8086:2c19] type 0 class 0x000600 [ 2.025540] pci 0000:ff:03.2: [8086:2c1a] type 0 class 0x000600 [ 2.025618] pci 0000:ff:03.4: [8086:2c1c] type 0 class 0x000600 [ 2.025699] pci 0000:ff:04.0: [8086:2c20] type 0 class 0x000600 [ 2.025775] pci 0000:ff:04.1: [8086:2c21] type 0 class 0x000600 [ 2.025852] pci 0000:ff:04.2: [8086:2c22] type 0 class 0x000600 [ 2.025928] pci 0000:ff:04.3: [8086:2c23] type 0 class 0x000600 [ 2.026011] pci 0000:ff:05.0: [8086:2c28] type 0 class 0x000600 [ 2.026087] pci 0000:ff:05.1: [8086:2c29] type 0 class 0x000600 [ 2.026162] pci 0000:ff:05.2: [8086:2c2a] type 0 class 0x000600 [ 2.026238] pci 0000:ff:05.3: [8086:2c2b] type 0 class 0x000600 [ 2.026322] pci 0000:ff:06.0: [8086:2c30] type 0 class 0x000600 [ 2.026398] pci 0000:ff:06.1: [8086:2c31] type 0 class 0x000600 [ 2.026473] pci 0000:ff:06.2: [8086:2c32] type 0 class 0x000600 [ 2.026549] pci 0000:ff:06.3: [8086:2c33] type 0 class 0x000600 [ 2.027516] PCI: pci_cache_line_size set to 64 bytes [ 2.027879] reserve RAM buffer: 000000000009a000 - 000000000009ffff=20= [ 2.027882] reserve RAM buffer: 000000008c404000 - 000000008fffffff=20= [ 2.028080] Switching to clocksource xen [ 2.030527] pnp: PnP ACPI init [ 2.030546] ACPI: bus type pnp registered [ 2.031200] pnp 00:00: [bus 00-fd] [ 2.031204] pnp 00:00: [io 0x0cf8-0x0cff] [ 2.031207] pnp 00:00: [io 0x0000-0x0cf7 window] [ 2.031213] pnp 00:00: [io 0x0d00-0xffff window] [ 2.031216] pnp 00:00: [mem 0x000a0000-0x000bffff window] [ 2.031219] pnp 00:00: [mem 0x000c4000-0x000cbfff window] [ 2.031223] pnp 00:00: [mem 0xfed40000-0xfedfffff window] [ 2.031226] pnp 00:00: [mem 0xb0000000-0xfdffffff window] [ 2.031228] pnp 00:00: [mem 0x00000000 window] [ 2.031337] pnp 00:00: Plug and Play ACPI device, IDs PNP0a08 PNP0a03 = (active) [ 2.031352] pnp 00:01: [mem 0xfec00000-0xfecfffff] [ 2.031390] pnp 00:01: Plug and Play ACPI device, IDs PNP0003 = (active) [ 2.031731] pnp 00:02: [io 0x0000-0x000f] [ 2.031734] pnp 00:02: [io 0x0081-0x0083] [ 2.031737] pnp 00:02: [io 0x0087] [ 2.031739] pnp 00:02: [io 0x0089-0x008b] [ 2.031742] pnp 00:02: [io 0x008f] [ 2.031744] pnp 00:02: [io 0x00c0-0x00df] [ 2.031747] pnp 00:02: [dma 4] [ 2.031810] pnp 00:02: Plug and Play ACPI device, IDs PNP0200 = (active) [ 2.031825] pnp 00:03: [io 0x0070-0x0071] [ 2.031828] pnp 00:03: [io 0x0074-0x0077] [ 2.031833] xen: registering gsi 8 triggering 1 polarity 0 [ 2.031872] pnp 00:03: [irq 8] [ 2.031929] pnp 00:03: Plug and Play ACPI device, IDs PNP0b00 = (active) [ 2.031945] pnp 00:04: [io 0x00f0] [ 2.031948] xen: registering gsi 13 triggering 1 polarity 0 [ 2.031982] pnp 00:04: [irq 13] [ 2.032042] pnp 00:04: Plug and Play ACPI device, IDs PNP0c04 = (active) [ 2.032058] pnp 00:05: [io 0x0061] [ 2.032119] pnp 00:05: Plug and Play ACPI device, IDs PNP0800 = (active) [ 2.032210] pnp 00:06: [mem 0xfed00000-0xfed003ff] [ 2.032276] pnp 00:06: Plug and Play ACPI device, IDs PNP0103 = (active) [ 2.032294] pnp 00:07: [io 0x0500-0x057f] [ 2.032298] pnp 00:07: [io 0x0400-0x047f] [ 2.032300] pnp 00:07: [io 0x0092] [ 2.032303] pnp 00:07: [io 0x0010-0x001f] [ 2.032305] pnp 00:07: [io 0x0072-0x0073] [ 2.032308] pnp 00:07: [io 0x0080] [ 2.032310] pnp 00:07: [io 0x0084-0x0086] [ 2.032313] pnp 00:07: [io 0x0088] [ 2.032315] pnp 00:07: [io 0x008c-0x008e] [ 2.032319] pnp 00:07: [io 0x0090-0x009f] [ 2.032322] pnp 00:07: [io 0x0800-0x081f] [ 2.032325] pnp 00:07: [io 0x0ca2-0x0ca3] [ 2.032327] pnp 00:07: [io 0x0600-0x061f] [ 2.032330] pnp 00:07: [io 0x0880-0x0883] [ 2.032332] pnp 00:07: [io 0x0ca4-0x0ca5] [ 2.032335] pnp 00:07: [mem 0xfed1c000-0xfed3fffe] [ 2.032338] pnp 00:07: [mem 0xff000000-0xffffffff] [ 2.032341] pnp 00:07: [mem 0xfee00000-0xfeefffff] [ 2.032344] pnp 00:07: [mem 0xfe900000-0xfe90001f] [ 2.032346] pnp 00:07: [mem 0xfea00000-0xfea0001f] [ 2.032349] pnp 00:07: [mem 0xfed1b000-0xfed1bfff] [ 2.032509] system 00:07: [io 0x0500-0x057f] has been reserved [ 2.032513] system 00:07: [io 0x0400-0x047f] has been reserved [ 2.032517] system 00:07: [io 0x0800-0x081f] has been reserved [ 2.032521] system 00:07: [io 0x0ca2-0x0ca3] has been reserved [ 2.032524] system 00:07: [io 0x0600-0x061f] has been reserved [ 2.032528] system 00:07: [io 0x0880-0x0883] has been reserved [ 2.032531] system 00:07: [io 0x0ca4-0x0ca5] has been reserved [ 2.032536] system 00:07: [mem 0xfed1c000-0xfed3fffe] could not be = reserved [ 2.032540] system 00:07: [mem 0xff000000-0xffffffff] could not be = reserved [ 2.032544] system 00:07: [mem 0xfee00000-0xfeefffff] could not be = reserved [ 2.032548] system 00:07: [mem 0xfe900000-0xfe90001f] has been = reserved [ 2.032552] system 00:07: [mem 0xfea00000-0xfea0001f] has been = reserved [ 2.032556] system 00:07: [mem 0xfed1b000-0xfed1bfff] has been = reserved [ 2.032560] system 00:07: Plug and Play ACPI device, IDs PNP0c02 = (active) [ 2.032830] pnp 00:08: [io 0x03f8-0x03ff] [ 2.032834] xen: registering gsi 4 triggering 1 polarity 0 [ 2.032869] pnp 00:08: [irq 4] [ 2.032995] pnp 00:08: Plug and Play ACPI device, IDs PNP0501 = (active) [ 2.033253] pnp 00:09: [io 0x02f8-0x02ff] [ 2.033257] xen: registering gsi 3 triggering 1 polarity 0 [ 2.033291] pnp 00:09: [irq 3] [ 2.033414] pnp 00:09: Plug and Play ACPI device, IDs PNP0501 = (active) [ 2.033494] pnp 00:0a: [io 0x0ca2] [ 2.033497] pnp 00:0a: [io 0x0ca3] [ 2.033559] pnp 00:0a: Plug and Play ACPI device, IDs IPI0001 = (active) [ 2.033637] pnp: PnP ACPI: found 11 devices [ 2.033639] ACPI: ACPI bus type pnp unregistered [ 2.043824] PM-Timer failed consistency check (0x0xffffff) - = aborting. [ 2.043852] pci 0000:01:00.0: no compatible bridge window for [mem = 0xfffc0000-0xffffffff pref] [ 2.043856] pci 0000:05:00.0: no compatible bridge window for [mem = 0xffc00000-0xffffffff pref] [ 2.043860] pci 0000:05:00.1: no compatible bridge window for [mem = 0xffc00000-0xffffffff pref] [ 2.043864] pci 0000:08:00.0: no compatible bridge window for [mem = 0xffff0000-0xffffffff pref] [ 2.043883] PCI: max bus depth: 1 pci_try_num: 2 [ 2.044014] pci 0000:00:1c.0: BAR 15: assigned [mem = 0xb2800000-0xb2ffffff pref] [ 2.044019] pci 0000:00:01.0: BAR 15: assigned [mem = 0xb1900000-0xb19fffff pref] [ 2.044024] pci 0000:00:1c.4: BAR 13: assigned [io 0x4000-0x4fff] [ 2.044029] pci 0000:01:00.0: BAR 6: assigned [mem = 0xb1900000-0xb193ffff pref] [ 2.044033] pci 0000:00:01.0: PCI bridge to [bus 01-01] [ 2.044038] pci 0000:00:01.0: bridge window [io 0x2000-0x2fff] [ 2.044047] pci 0000:00:01.0: bridge window [mem = 0xb2500000-0xb26fffff] [ 2.044054] pci 0000:00:01.0: bridge window [mem = 0xb1900000-0xb19fffff pref] [ 2.044066] pci 0000:00:03.0: PCI bridge to [bus 02-02] [ 2.044087] pci 0000:00:07.0: PCI bridge to [bus 03-03] [ 2.044108] pci 0000:00:09.0: PCI bridge to [bus 04-04] [ 2.044131] pci 0000:05:00.0: BAR 6: assigned [mem = 0xb2800000-0xb2bfffff pref] [ 2.044136] pci 0000:05:00.1: BAR 6: assigned [mem = 0xb2c00000-0xb2ffffff pref] [ 2.044147] pci 0000:00:1c.0: PCI bridge to [bus 05-07] [ 2.044152] pci 0000:00:1c.0: bridge window [io 0x1000-0x1fff] [ 2.044162] pci 0000:00:1c.0: bridge window [mem = 0xb1c00000-0xb24fffff] [ 2.044169] pci 0000:00:1c.0: bridge window [mem = 0xb2800000-0xb2ffffff pref] [ 2.044183] pci 0000:08:00.0: BAR 6: assigned [mem = 0xb1810000-0xb181ffff pref] [ 2.044186] pci 0000:00:1c.4: PCI bridge to [bus 08-08] [ 2.044191] pci 0000:00:1c.4: bridge window [io 0x4000-0x4fff] [ 2.044201] pci 0000:00:1c.4: bridge window [mem = 0xb1000000-0xb18fffff] [ 2.044208] pci 0000:00:1c.4: bridge window [mem = 0xb0000000-0xb0ffffff 64bit pref] [ 2.044220] pci 0000:00:1e.0: PCI bridge to [bus 09-09] [ 2.044251] xen: registering gsi 28 triggering 0 polarity 1 [ 2.044270] xen: --> pirq=3D28 -> irq=3D28 (gsi=3D28) [ 2.044311] pci 0000:00:01.0: setting latency timer to 64 [ 2.044322] xen: registering gsi 24 triggering 0 polarity 1 [ 2.044330] xen: --> pirq=3D24 -> irq=3D24 (gsi=3D24) [ 2.044368] pci 0000:00:03.0: setting latency timer to 64 [ 2.044379] xen: registering gsi 30 triggering 0 polarity 1 [ 2.044386] xen: --> pirq=3D30 -> irq=3D30 (gsi=3D30) [ 2.044424] pci 0000:00:07.0: setting latency timer to 64 [ 2.044433] xen: registering gsi 32 triggering 0 polarity 1 [ 2.044440] xen: --> pirq=3D32 -> irq=3D32 (gsi=3D32) [ 2.044478] pci 0000:00:09.0: setting latency timer to 64 [ 2.044490] xen: registering gsi 16 triggering 0 polarity 1 [ 2.044497] xen: --> pirq=3D16 -> irq=3D16 (gsi=3D16) [ 2.044534] pci 0000:00:1c.0: setting latency timer to 64 [ 2.044544] xen: registering gsi 16 triggering 0 polarity 1 [ 2.044547] Already setup the GSI :16 [ 2.044554] pci 0000:00:1c.4: setting latency timer to 64 [ 2.044566] pci 0000:00:1e.0: setting latency timer to 64 [ 2.044573] pci_bus 0000:00: resource 4 [io 0x0000-0x0cf7] [ 2.044576] pci_bus 0000:00: resource 5 [io 0x0d00-0xffff] [ 2.044579] pci_bus 0000:00: resource 6 [mem 0x000a0000-0x000bffff] [ 2.044583] pci_bus 0000:00: resource 7 [mem 0xfed40000-0xfedfffff] [ 2.044586] pci_bus 0000:00: resource 8 [mem 0xb0000000-0xfdffffff] [ 2.044589] pci_bus 0000:01: resource 0 [io 0x2000-0x2fff] [ 2.044592] pci_bus 0000:01: resource 1 [mem 0xb2500000-0xb26fffff] [ 2.044595] pci_bus 0000:01: resource 2 [mem 0xb1900000-0xb19fffff = pref] [ 2.044599] pci_bus 0000:05: resource 0 [io 0x1000-0x1fff] [ 2.044602] pci_bus 0000:05: resource 1 [mem 0xb1c00000-0xb24fffff] [ 2.044606] pci_bus 0000:05: resource 2 [mem 0xb2800000-0xb2ffffff = pref] [ 2.044609] pci_bus 0000:08: resource 0 [io 0x4000-0x4fff] [ 2.044612] pci_bus 0000:08: resource 1 [mem 0xb1000000-0xb18fffff] [ 2.044615] pci_bus 0000:08: resource 2 [mem 0xb0000000-0xb0ffffff = 64bit pref] [ 2.044619] pci_bus 0000:09: resource 4 [io 0x0000-0x0cf7] [ 2.044622] pci_bus 0000:09: resource 5 [io 0x0d00-0xffff] [ 2.044625] pci_bus 0000:09: resource 6 [mem 0x000a0000-0x000bffff] [ 2.044628] pci_bus 0000:09: resource 7 [mem 0xfed40000-0xfedfffff] [ 2.044631] pci_bus 0000:09: resource 8 [mem 0xb0000000-0xfdffffff] [ 2.044634] pci_bus 0000:ff: resource 0 [io 0x0000-0xffff] [ 2.044637] pci_bus 0000:ff: resource 1 [mem 0x00000000-0xffffffffff] [ 2.044735] NET: Registered protocol family 2 [ 2.045245] IP route cache hash table entries: 131072 (order: 8, = 1048576 bytes) [ 2.049037] TCP established hash table entries: 524288 (order: 11, = 8388608 bytes) [ 2.052489] TCP bind hash table entries: 65536 (order: 8, 1048576 = bytes) [ 2.052877] TCP: Hash tables configured (established 524288 bind = 65536) [ 2.052880] TCP reno registered [ 2.052917] UDP hash table entries: 2048 (order: 4, 65536 bytes) [ 2.052970] UDP-Lite hash table entries: 2048 (order: 4, 65536 bytes) [ 2.053157] NET: Registered protocol family 1 [ 2.053279] xen: registering gsi 19 triggering 0 polarity 1 [ 2.053296] xen: --> pirq=3D19 -> irq=3D19 (gsi=3D19) [ 2.053368] xen: registering gsi 19 triggering 0 polarity 1 [ 2.053371] Already setup the GSI :19 [ 2.053406] xen: registering gsi 19 triggering 0 polarity 1 [ 2.053408] Already setup the GSI :19 [ 2.053446] xen: registering gsi 19 triggering 0 polarity 1 [ 2.053449] Already setup the GSI :19 [ 2.053617] xen: registering gsi 16 triggering 0 polarity 1 [ 2.053620] Already setup the GSI :16 [ 2.053655] xen: registering gsi 16 triggering 0 polarity 1 [ 2.053658] Already setup the GSI :16 [ 2.053693] xen: registering gsi 16 triggering 0 polarity 1 [ 2.053696] Already setup the GSI :16 [ 2.053733] xen: registering gsi 16 triggering 0 polarity 1 [ 2.053736] Already setup the GSI :16 [ 2.053927] pci 0000:08:00.0: Boot video device [ 2.054006] PCI: CLS 64 bytes, default 64 [ 2.054074] Unpacking initramfs... [ 2.105047] Freeing initrd memory: 31936k freed [ 2.115812] audit: initializing netlink socket (disabled) [ 2.115827] type=3D2000 audit(1354049828.105:1): initialized [ 2.136259] HugeTLB registered 2 MB page size, pre-allocated 0 pages [ 2.136637] VFS: Disk quotas dquot_6.5.2 [ 2.136678] Dquot-cache hash table entries: 512 (order 0, 4096 bytes) [ 2.136776] msgmni has been set to 4192 [ 2.137019] alg: No test for stdrng (krng) [ 2.137068] Block layer SCSI generic (bsg) driver version 0.4 loaded = (major 253) [ 2.137072] io scheduler noop registered [ 2.137075] io scheduler deadline registered [ 2.137102] io scheduler cfq registered (default) [ 2.137331] pcieport 0000:00:01.0: setting latency timer to 64 [ 2.137624] pcieport 0000:00:03.0: setting latency timer to 64 [ 2.137883] pcieport 0000:00:07.0: setting latency timer to 64 [ 2.138145] pcieport 0000:00:09.0: setting latency timer to 64 [ 2.138402] pcieport 0000:00:1c.0: setting latency timer to 64 [ 2.138677] pcieport 0000:00:1c.4: setting latency timer to 64 [ 2.139007] aer 0000:00:01.0:pcie02: service driver aer loaded [ 2.139068] aer 0000:00:03.0:pcie02: service driver aer loaded [ 2.139126] aer 0000:00:07.0:pcie02: service driver aer loaded [ 2.139184] aer 0000:00:09.0:pcie02: service driver aer loaded [ 2.139214] pcieport 0000:00:01.0: Signaling PME through PCIe PME = interrupt [ 2.139217] pci 0000:01:00.0: Signaling PME through PCIe PME = interrupt [ 2.139225] pcie_pme 0000:00:01.0:pcie01: service driver pcie_pme = loaded [ 2.139241] pcieport 0000:00:03.0: Signaling PME through PCIe PME = interrupt [ 2.139248] pcie_pme 0000:00:03.0:pcie01: service driver pcie_pme = loaded [ 2.139264] pcieport 0000:00:07.0: Signaling PME through PCIe PME = interrupt [ 2.139271] pcie_pme 0000:00:07.0:pcie01: service driver pcie_pme = loaded [ 2.139287] pcieport 0000:00:09.0: Signaling PME through PCIe PME = interrupt [ 2.139294] pcie_pme 0000:00:09.0:pcie01: service driver pcie_pme = loaded [ 2.139341] pcieport 0000:00:1c.0: Signaling PME through PCIe PME = interrupt [ 2.139344] pci 0000:05:00.0: Signaling PME through PCIe PME = interrupt [ 2.139347] pci 0000:05:00.1: Signaling PME through PCIe PME = interrupt [ 2.139355] pcie_pme 0000:00:1c.0:pcie01: service driver pcie_pme = loaded [ 2.139399] pcieport 0000:00:1c.4: Signaling PME through PCIe PME = interrupt [ 2.139402] pci 0000:08:00.0: Signaling PME through PCIe PME = interrupt [ 2.139410] pcie_pme 0000:00:1c.4:pcie01: service driver pcie_pme = loaded [ 2.139438] pci_hotplug: PCI Hot Plug PCI Core version: 0.5 [ 2.139529] pciehp 0000:00:1c.0:pcie04: HPC vendor_id 8086 device_id = 3a40 ss_vid 8086 ss_did 34da [ 2.139563] pciehp 0000:00:1c.0:pcie04: service driver pciehp loaded [ 2.139584] pciehp 0000:00:1c.4:pcie04: HPC vendor_id 8086 device_id = 3a48 ss_vid 8086 ss_did 34da [ 2.139615] pciehp 0000:00:1c.4:pcie04: service driver pciehp loaded [ 2.139624] pciehp: PCI Express Hot Plug Controller Driver version: = 0.4 [ 2.139627] acpiphp: ACPI Hot Plug PCI Controller Driver version: 0.5 [ 2.140714] ERST: Error Record Serialization Table (ERST) support is = initialized. [ 2.141040] GHES: APEI firmware first mode is enabled by WHEA _OSC. [ 2.141592] Serial: 8250/16550 driver, 4 ports, IRQ sharing enabled [ 2.162398] serial8250: ttyS0 at I/O 0x3f8 (irq =3D 4) is a 16550A [ 2.220889] serial8250: ttyS1 at I/O 0x2f8 (irq =3D 3) is a 16550A [ 2.329193] 00:08: ttyS0 at I/O 0x3f8 (irq =3D 4) is a 16550A [ 2.368974] 00:09: ttyS1 at I/O 0x2f8 (irq =3D 3) is a 16550A [ 2.388479] hpet_acpi_add: no address or irqs in _CRS [ 2.388497] Linux agpgart interface v0.103 [ 2.388717] i8042: PNP: No PS/2 controller found. Probing ports = directly. [ 2.389618] i8042: No controller found [ 2.389810] mousedev: PS/2 mouse device common for all mice [ 2.389868] rtc_cmos 00:03: RTC can wake from S4 [ 2.390051] rtc_cmos 00:03: rtc core: registered rtc_cmos as rtc0 [ 2.390139] rtc0: alarms up to one month, y3k, 114 bytes nvram [ 2.390399] TCP cubic registered [ 2.390477] NET: Registered protocol family 10 [ 2.391076] Mobile IPv6 [ 2.391080] NET: Registered protocol family 17 [ 2.391085] Registering the dns_resolver key type [ 2.391284] PM: Hibernation image not present or could not be loaded. [ 2.391301] registered taskstats version 1 [ 2.392460] rtc_cmos 00:03: setting system clock to 2012-11-27 = 20:57:08 UTC (1354049828) [ 2.392556] Initializing network drop monitor service [ 2.392944] Freeing unused kernel memory: 576k freed [ 2.393068] Write protecting the kernel read-only data: 6144k [ 2.397056] Freeing unused kernel memory: 664k freed [ 2.397574] Freeing unused kernel memory: 680k freed [ 2.434982] udevd[57]: starting version 175 [ 2.547267] e1000e: Intel(R) PRO/1000 Network Driver - 1.5.1-k [ 2.547271] e1000e: Copyright(c) 1999 - 2011 Intel Corporation. [ 2.547331] xen: registering gsi 20 triggering 0 polarity 1 [ 2.547354] xen: --> pirq=3D20 -> irq=3D20 (gsi=3D20) [ 2.547413] e1000e 0000:00:19.0: setting latency timer to 64 [ 2.578776] dca service started, version 1.12.1 [ 2.580273] usbcore: registered new interface driver usbfs [ 2.580305] usbcore: registered new interface driver hub [ 2.581721] Intel(R) Gigabit Ethernet Network Driver - version = 3.2.10-k [ 2.581725] Copyright (c) 2007-2011 Intel Corporation. [ 2.581783] xen: registering gsi 16 triggering 0 polarity 1 [ 2.581790] Already setup the GSI :16 [ 2.581817] igb 0000:05:00.0: setting latency timer to 64 [ 2.606547] usbcore: registered new device driver usb [ 2.607714] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) = Driver [ 2.612487] SCSI subsystem initialized [ 2.622194] libata version 3.00 loaded. [ 2.640863] uhci_hcd: USB Universal Host Controller Interface driver [ 2.738573] e1000e 0000:00:19.0: eth0: (PCI Express:2.5GT/s:Width x1) = 00:15:17:fb:4f:b0 [ 2.738577] e1000e 0000:00:19.0: eth0: Intel(R) PRO/1000 Network = Connection [ 2.738611] e1000e 0000:00:19.0: eth0: MAC: 7, PHY: 8, PBA No: = 0101FF-0FF [ 2.738637] e1000e 0000:01:00.0: Disabling ASPM L0s L1 [ 2.738663] xen: registering gsi 28 triggering 0 polarity 1 [ 2.738668] xen: registering gsi 19 triggering 0 polarity 1 [ 2.738676] Already setup the GSI :28 [ 2.738679] Already setup the GSI :19 [ 2.738720] e1000e 0000:01:00.0: setting latency timer to 64 [ 2.738747] ehci_hcd 0000:00:1a.7: setting latency timer to 64 [ 2.738755] ehci_hcd 0000:00:1a.7: EHCI Host Controller [ 2.738786] ehci_hcd 0000:00:1a.7: new USB bus registered, assigned = bus number 1 [ 2.738845] ehci_hcd 0000:00:1a.7: debug port 1 [ 2.742736] ehci_hcd 0000:00:1a.7: cache line size of 64 is not = supported [ 2.742813] ehci_hcd 0000:00:1a.7: irq 19, io mem 0xb2742000 [ 2.756150] ehci_hcd 0000:00:1a.7: USB 2.0 started, EHCI 1.00 [ 2.756179] usb usb1: New USB device found, idVendor=3D1d6b, = idProduct=3D0002 [ 2.756182] usb usb1: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.756185] usb usb1: Product: EHCI Host Controller [ 2.756188] usb usb1: Manufacturer: Linux 3.2.0-4-amd64 ehci_hcd [ 2.756191] usb usb1: SerialNumber: 0000:00:1a.7 [ 2.756347] hub 1-0:1.0: USB hub found [ 2.756353] hub 1-0:1.0: 6 ports detected [ 2.756488] xen: registering gsi 16 triggering 0 polarity 1 [ 2.756492] Already setup the GSI :16 [ 2.756522] ehci_hcd 0000:00:1d.7: setting latency timer to 64 [ 2.756528] ehci_hcd 0000:00:1d.7: EHCI Host Controller [ 2.756538] ehci_hcd 0000:00:1d.7: new USB bus registered, assigned = bus number 2 [ 2.756577] ehci_hcd 0000:00:1d.7: debug port 1 [ 2.760468] ehci_hcd 0000:00:1d.7: cache line size of 64 is not = supported [ 2.760536] ehci_hcd 0000:00:1d.7: irq 16, io mem 0xb2741000 [ 2.776151] ehci_hcd 0000:00:1d.7: USB 2.0 started, EHCI 1.00 [ 2.776173] usb usb2: New USB device found, idVendor=3D1d6b, = idProduct=3D0002 [ 2.776176] usb usb2: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.776179] usb usb2: Product: EHCI Host Controller [ 2.776182] usb usb2: Manufacturer: Linux 3.2.0-4-amd64 ehci_hcd [ 2.776185] usb usb2: SerialNumber: 0000:00:1d.7 [ 2.776323] hub 2-0:1.0: USB hub found [ 2.776329] hub 2-0:1.0: 6 ports detected [ 2.776456] ahci 0000:00:1f.2: version 3.0 [ 2.776472] xen: registering gsi 18 triggering 0 polarity 1 [ 2.776498] xen: --> pirq=3D18 -> irq=3D18 (gsi=3D18) [ 2.776717] ahci 0000:00:1f.2: AHCI 0001.0200 32 slots 6 ports 3 Gbps = 0x11 impl SATA mode [ 2.776723] ahci 0000:00:1f.2: flags: 64bit ncq sntf pm led clo pio = slum part ccc=20 [ 2.776731] ahci 0000:00:1f.2: setting latency timer to 64 [ 2.777713] scsi0 : ahci [ 2.777885] scsi1 : ahci [ 2.777996] scsi2 : ahci [ 2.778100] scsi3 : ahci [ 2.778239] scsi4 : ahci [ 2.778371] scsi5 : ahci [ 2.778619] ata1: SATA max UDMA/133 abar m2048@0xb2740000 port = 0xb2740100 irq 337 [ 2.778622] ata2: DUMMY [ 2.778624] ata3: DUMMY [ 2.778626] ata4: DUMMY [ 2.778629] ata5: SATA max UDMA/133 abar m2048@0xb2740000 port = 0xb2740300 irq 337 [ 2.778632] ata6: DUMMY [ 2.778682] xen: registering gsi 19 triggering 0 polarity 1 [ 2.778688] Already setup the GSI :19 [ 2.778703] uhci_hcd 0000:00:1a.0: setting latency timer to 64 [ 2.778708] uhci_hcd 0000:00:1a.0: UHCI Host Controller [ 2.778729] uhci_hcd 0000:00:1a.0: new USB bus registered, assigned = bus number 3 [ 2.778771] uhci_hcd 0000:00:1a.0: irq 19, io base 0x000030e0 [ 2.778819] usb usb3: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.778822] usb usb3: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.778825] usb usb3: Product: UHCI Host Controller [ 2.778830] usb usb3: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.778833] usb usb3: SerialNumber: 0000:00:1a.0 [ 2.779015] hub 3-0:1.0: USB hub found [ 2.779022] hub 3-0:1.0: 2 ports detected [ 2.779139] xen: registering gsi 19 triggering 0 polarity 1 [ 2.779143] Already setup the GSI :19 [ 2.779156] uhci_hcd 0000:00:1a.1: setting latency timer to 64 [ 2.779161] uhci_hcd 0000:00:1a.1: UHCI Host Controller [ 2.779171] uhci_hcd 0000:00:1a.1: new USB bus registered, assigned = bus number 4 [ 2.779210] uhci_hcd 0000:00:1a.1: irq 19, io base 0x000030c0 [ 2.779275] usb usb4: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.779279] usb usb4: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.779282] usb usb4: Product: UHCI Host Controller [ 2.779285] usb usb4: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.779287] usb usb4: SerialNumber: 0000:00:1a.1 [ 2.779454] hub 4-0:1.0: USB hub found [ 2.779460] hub 4-0:1.0: 2 ports detected [ 2.779571] xen: registering gsi 19 triggering 0 polarity 1 [ 2.779576] Already setup the GSI :19 [ 2.779589] uhci_hcd 0000:00:1a.2: setting latency timer to 64 [ 2.779594] uhci_hcd 0000:00:1a.2: UHCI Host Controller [ 2.779603] uhci_hcd 0000:00:1a.2: new USB bus registered, assigned = bus number 5 [ 2.779645] uhci_hcd 0000:00:1a.2: irq 19, io base 0x000030a0 [ 2.779693] usb usb5: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.779696] usb usb5: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.779699] usb usb5: Product: UHCI Host Controller [ 2.779702] usb usb5: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.779705] usb usb5: SerialNumber: 0000:00:1a.2 [ 2.779867] hub 5-0:1.0: USB hub found [ 2.779873] hub 5-0:1.0: 2 ports detected [ 2.779980] xen: registering gsi 16 triggering 0 polarity 1 [ 2.779985] Already setup the GSI :16 [ 2.779997] uhci_hcd 0000:00:1d.0: setting latency timer to 64 [ 2.780003] uhci_hcd 0000:00:1d.0: UHCI Host Controller [ 2.780012] uhci_hcd 0000:00:1d.0: new USB bus registered, assigned = bus number 6 [ 2.780051] uhci_hcd 0000:00:1d.0: irq 16, io base 0x00003080 [ 2.780100] usb usb6: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.780103] usb usb6: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.780106] usb usb6: Product: UHCI Host Controller [ 2.780109] usb usb6: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.780111] usb usb6: SerialNumber: 0000:00:1d.0 [ 2.780290] hub 6-0:1.0: USB hub found [ 2.780296] hub 6-0:1.0: 2 ports detected [ 2.780416] xen: registering gsi 16 triggering 0 polarity 1 [ 2.780420] Already setup the GSI :16 [ 2.780433] uhci_hcd 0000:00:1d.1: setting latency timer to 64 [ 2.780438] uhci_hcd 0000:00:1d.1: UHCI Host Controller [ 2.780447] uhci_hcd 0000:00:1d.1: new USB bus registered, assigned = bus number 7 [ 2.780489] uhci_hcd 0000:00:1d.1: irq 16, io base 0x00003060 [ 2.780536] usb usb7: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.780540] usb usb7: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.780543] usb usb7: Product: UHCI Host Controller [ 2.780546] usb usb7: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.780548] usb usb7: SerialNumber: 0000:00:1d.1 [ 2.780729] hub 7-0:1.0: USB hub found [ 2.780739] hub 7-0:1.0: 2 ports detected [ 2.780851] xen: registering gsi 16 triggering 0 polarity 1 [ 2.780856] Already setup the GSI :16 [ 2.780868] uhci_hcd 0000:00:1d.2: setting latency timer to 64 [ 2.780873] uhci_hcd 0000:00:1d.2: UHCI Host Controller [ 2.780883] uhci_hcd 0000:00:1d.2: new USB bus registered, assigned = bus number 8 [ 2.780922] uhci_hcd 0000:00:1d.2: irq 16, io base 0x00003040 [ 2.780969] usb usb8: New USB device found, idVendor=3D1d6b, = idProduct=3D0001 [ 2.780973] usb usb8: New USB device strings: Mfr=3D3, Product=3D2, = SerialNumber=3D1 [ 2.780976] usb usb8: Product: UHCI Host Controller [ 2.780979] usb usb8: Manufacturer: Linux 3.2.0-4-amd64 uhci_hcd [ 2.780981] usb usb8: SerialNumber: 0000:00:1d.2 [ 2.781153] hub 8-0:1.0: USB hub found [ 2.781158] hub 8-0:1.0: 2 ports detected [ 2.800932] igb 0000:05:00.0: Intel(R) Gigabit Ethernet Network = Connection [ 2.800937] igb 0000:05:00.0: eth1: (PCIe:2.5Gb/s:Width x4) = 00:1b:21:a7:62:f4 [ 2.801264] igb 0000:05:00.0: eth1: PBA No: G18758-001 [ 2.801267] igb 0000:05:00.0: Using MSI-X interrupts. 4 rx queue(s), = 4 tx queue(s) [ 2.801299] xen: registering gsi 17 triggering 0 polarity 1 [ 2.801318] xen: --> pirq=3D17 -> irq=3D17 (gsi=3D17) [ 2.801378] igb 0000:05:00.1: setting latency timer to 64 [ 2.849418] e1000e 0000:01:00.0: eth2: (PCI Express:2.5GT/s:Width x1) = 00:15:17:fb:4f:b1 [ 2.849423] e1000e 0000:01:00.0: eth2: Intel(R) PRO/1000 Network = Connection [ 2.849437] e1000e 0000:01:00.0: eth2: MAC: 3, PHY: 8, PBA No: = 1030FF-0FF [ 2.992968] igb 0000:05:00.1: Intel(R) Gigabit Ethernet Network = Connection [ 2.992973] igb 0000:05:00.1: eth3: (PCIe:2.5Gb/s:Width x4) = 00:1b:21:a7:62:f5 [ 2.993300] igb 0000:05:00.1: eth3: PBA No: G18758-001 [ 2.993303] igb 0000:05:00.1: Using MSI-X interrupts. 4 rx queue(s), = 4 tx queue(s) [ 3.096166] ata1: SATA link up 1.5 Gbps (SStatus 113 SControl 300) [ 3.100163] ata5: SATA link up 1.5 Gbps (SStatus 113 SControl 300) [ 3.100416] ata5.00: ATAPI: HL-DT-ST DVDROM DH18NS40, 1.01, max = UDMA/100 [ 3.101100] ata5.00: configured for UDMA/100 [ 3.125896] ata1.00: ATA-6: WDC WD800JD-75HKA1, 14.03G14, max = UDMA/133 [ 3.125900] ata1.00: 156250000 sectors, multi 0: LBA=20 [ 3.126758] ata1.00: configured for UDMA/133 [ 3.126893] scsi 0:0:0:0: Direct-Access ATA WDC WD800JD-75HK = 14.0 PQ: 0 ANSI: 5 [ 3.127746] scsi 4:0:0:0: CD-ROM HL-DT-ST DVDROM DH18NS40 = 1.01 PQ: 0 ANSI: 5 [ 3.138304] sd 0:0:0:0: [sda] 156250000 512-byte logical blocks: = (80.0 GB/74.5 GiB) [ 3.138382] sd 0:0:0:0: [sda] Write Protect is off [ 3.138386] sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00 [ 3.138419] sd 0:0:0:0: [sda] Write cache: enabled, read cache: = enabled, doesn't support DPO or FUA [ 3.140571] sr0: scsi3-mmc drive: 12x/48x cd/rw xa/form2 cdda tray [ 3.140575] cdrom: Uniform CD-ROM driver Revision: 3.20 [ 3.140740] sr 4:0:0:0: Attached scsi CD-ROM sr0 [ 3.172703] sda: sda1 sda2 < sda5 sda6 > [ 3.173164] sd 0:0:0:0: [sda] Attached SCSI disk [ 3.177660] sd 0:0:0:0: Attached scsi generic sg0 type 0 [ 3.177726] sr 4:0:0:0: Attached scsi generic sg1 type 5 [ 3.364157] usb 3-1: new low-speed USB device number 2 using uhci_hcd [ 3.540835] usb 3-1: New USB device found, idVendor=3D0a81, = idProduct=3D0101 [ 3.540839] usb 3-1: New USB device strings: Mfr=3D1, Product=3D2, = SerialNumber=3D0 [ 3.540843] usb 3-1: Product: USB Keyboard [ 3.540845] usb 3-1: Manufacturer: CHESEN [ 3.564133] input: CHESEN USB Keyboard as = /devices/pci0000:00/0000:00:1a.0/usb3/3-1/3-1:1.0/input/input0 [ 3.564244] generic-usb 0003:0A81:0101.0001: input,hidraw0: USB HID = v1.10 Keyboard [CHESEN USB Keyboard] on usb-0000:00:1a.0-1/input0 [ 3.593910] input: CHESEN USB Keyboard as = /devices/pci0000:00/0000:00:1a.0/usb3/3-1/3-1:1.1/input/input1 [ 3.593999] generic-usb 0003:0A81:0101.0002: input,hidraw1: USB HID = v1.10 Device [CHESEN USB Keyboard] on usb-0000:00:1a.0-1/input1 [ 3.594021] usbcore: registered new interface driver usbhid [ 3.594024] usbhid: USB HID core driver [ 3.780156] usb 5-1: new full-speed USB device number 2 using = uhci_hcd [ 3.943702] usb 5-1: New USB device found, idVendor=3D046b, = idProduct=3Dff10 [ 3.943707] usb 5-1: New USB device strings: Mfr=3D1, Product=3D2, = SerialNumber=3D3 [ 3.943711] usb 5-1: Product: Virtual Keyboard and Mouse [ 3.943714] usb 5-1: Manufacturer: American Megatrends Inc. [ 3.943716] usb 5-1: SerialNumber: serial [ 3.953968] input: American Megatrends Inc. Virtual Keyboard and = Mouse as /devices/pci0000:00/0000:00:1a.2/usb5/5-1/5-1:1.0/input/input2 [ 3.954057] generic-usb 0003:046B:FF10.0003: input,hidraw2: USB HID = v1.10 Keyboard [American Megatrends Inc. Virtual Keyboard and Mouse] on = usb-0000:00:1a.2-1/input0 [ 3.959931] input: American Megatrends Inc. Virtual Keyboard and = Mouse as /devices/pci0000:00/0000:00:1a.2/usb5/5-1/5-1:1.1/input/input3 [ 3.960064] generic-usb 0003:046B:FF10.0004: input,hidraw3: USB HID = v1.10 Mouse [American Megatrends Inc. Virtual Keyboard and Mouse] on = usb-0000:00:1a.2-1/input1 [ 4.031919] device-mapper: uevent: version 1.0.3 [ 4.032020] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) = initialised: dm-devel@redhat.com [ 4.244096] PM: Starting manual resume from disk [ 4.244101] PM: Hibernation image partition 8:5 present [ 4.244103] PM: Looking for hibernation image. [ 4.244289] PM: Image not found (code -22) [ 4.244292] PM: Hibernation image not present or could not be loaded. [ 4.293114] EXT4-fs (sda1): mounted filesystem with ordered data = mode. Opts: (null) [ 6.526898] udevd[431]: starting version 175 [ 6.984190] ACPI: Requesting acpi_cpufreq [ 6.984431] input: Sleep Button as = /devices/LNXSYSTM:00/device:00/PNP0C0E:00/input/input4 [ 6.984442] ACPI: Sleep Button [SLPB] [ 6.986709] input: Power Button as = /devices/LNXSYSTM:00/LNXPWRBN:00/input/input5 [ 6.986716] ACPI: Power Button [PWRF] [ 7.018855] [Firmware Bug]: ACPI: Invalid BIOS _PSS frequency: = 0x80000000 MHz [ 7.018955] [Firmware Bug]: BIOS needs update for CPU frequency = support [ 7.019167] [Firmware Bug]: ACPI: Invalid BIOS _PSS frequency: = 0x80000000 MHz [ 7.019257] [Firmware Bug]: BIOS needs update for CPU frequency = support [ 7.019431] [Firmware Bug]: ACPI: Invalid BIOS _PSS frequency: = 0x80000000 MHz [ 7.019513] [Firmware Bug]: BIOS needs update for CPU frequency = support [ 7.019710] [Firmware Bug]: ACPI: Invalid BIOS _PSS frequency: = 0x80000000 MHz [ 7.019790] [Firmware Bug]: BIOS needs update for CPU frequency = support [ 7.192030] iTCO_vendor_support: vendor-support=3D0 [ 7.206358] input: PC Speaker as = /devices/platform/pcspkr/input/input6 [ 7.348810] Error: Driver 'pcspkr' is already registered, aborting... [ 7.409524] EDAC MC: Ver: 2.1.0 [ 7.430641] EDAC MC0: Giving out device to 'i7core_edac.c' 'i7 core = #0': DEV 0000:ff:03.0 [ 7.430664] EDAC PCI0: Giving out device to module 'i7core_edac' = controller 'EDAC PCI controller': DEV '0000:ff:03.0' (POLLED) [ 7.430920] EDAC i7core: Driver loaded, 1 memory controller(s) found. [ 7.440547] xen: registering gsi 18 triggering 0 polarity 1 [ 7.440557] Already setup the GSI :18 [ 7.451375] iTCO_wdt: Intel TCO WatchDog Timer Driver v1.07 [ 7.451507] iTCO_wdt: unable to reset NO_REBOOT flag, device disabled = by hardware/BIOS [ 7.513917] ioatdma: Intel(R) QuickData Technology Driver 4.00 [ 7.513985] xen: registering gsi 43 triggering 0 polarity 1 [ 7.514006] xen: --> pirq=3D43 -> irq=3D43 (gsi=3D43) [ 7.514086] ioatdma 0000:00:16.0: setting latency timer to 64 [ 7.514523] xen: registering gsi 44 triggering 0 polarity 1 [ 7.514538] xen: --> pirq=3D44 -> irq=3D44 (gsi=3D44) [ 7.514613] ioatdma 0000:00:16.1: setting latency timer to 64 [ 7.515101] xen: registering gsi 45 triggering 0 polarity 1 [ 7.515115] xen: --> pirq=3D45 -> irq=3D45 (gsi=3D45) [ 7.515185] ioatdma 0000:00:16.2: setting latency timer to 64 [ 7.515602] xen: registering gsi 46 triggering 0 polarity 1 [ 7.515615] xen: --> pirq=3D46 -> irq=3D46 (gsi=3D46) [ 7.515684] ioatdma 0000:00:16.3: setting latency timer to 64 [ 7.516082] xen: registering gsi 43 triggering 0 polarity 1 [ 7.516088] Already setup the GSI :43 [ 7.516124] ioatdma 0000:00:16.4: setting latency timer to 64 [ 7.516543] xen: registering gsi 44 triggering 0 polarity 1 [ 7.516549] Already setup the GSI :44 [ 7.516585] ioatdma 0000:00:16.5: setting latency timer to 64 [ 7.516990] xen: registering gsi 45 triggering 0 polarity 1 [ 7.516996] Already setup the GSI :45 [ 7.517032] ioatdma 0000:00:16.6: setting latency timer to 64 [ 7.517430] xen: registering gsi 46 triggering 0 polarity 1 [ 7.517436] Already setup the GSI :46 [ 7.517472] ioatdma 0000:00:16.7: setting latency timer to 64 [ 10.042172] Adding 7811068k swap on /dev/sda5. Priority:-1 extents:1 = across:7811068k=20 [ 10.086574] EXT4-fs (sda1): re-mounted. Opts: (null) [ 10.430977] EXT4-fs (sda1): re-mounted. Opts: errors=3Dremount-ro [ 10.599778] loop: module loaded [ 11.987222] EXT4-fs (sda6): mounted filesystem with ordered data = mode. Opts: (null) [ 13.498950] RPC: Registered named UNIX socket transport module. [ 13.498954] RPC: Registered udp transport module. [ 13.498957] RPC: Registered tcp transport module. [ 13.498959] RPC: Registered tcp NFSv4.1 backchannel transport module. [ 13.558747] FS-Cache: Loaded [ 13.634784] FS-Cache: Netfs 'nfs' registered for caching [ 13.652268] Installing knfsd (copyright (C) 1996 okir@monad.swb.de). [ 16.120817] Event-channel device installed. [ 16.440165] XENBUS: Unable to read cpu state [ 16.440408] XENBUS: Unable to read cpu state [ 16.440649] XENBUS: Unable to read cpu state [ 16.440886] XENBUS: Unable to read cpu state [ 19.851845] Ebtables v2.0 registered [ 20.121357] ip_tables: (C) 2000-2006 Netfilter Core Team [ 20.254596] ip6_tables: (C) 2000-2006 Netfilter Core Team [ 22.884271] Bridge firewalling registered [ 83.088886] ADDRCONF(NETDEV_UP): eth0: link is not ready [ 84.737011] e1000e: eth0 NIC Link is Up 100 Mbps Full Duplex, Flow = Control: None [ 84.737017] e1000e 0000:00:19.0: eth0: 10/100 speed: disabling TSO [ 84.737485] ADDRCONF(NETDEV_CHANGE): eth0: link becomes ready [ 95.096146] eth0: no IPv6 routers present= --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 Content-Disposition: attachment; filename=xm-dmesg.log Content-Type: application/octet-stream; name="xm-dmesg.log" Content-Transfer-Encoding: 7bit (XEN) Xen version 4.1.3 (Debian 4.1.3-3) (waldi@debian.org) (gcc version 4.7.1 (Debian 4.7.1-9) ) Tue Sep 18 11:27:45 UTC 2012 (XEN) Bootloader: GRUB 1.99-23 (XEN) Command line: placeholder (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 1 MBR signatures (XEN) Found 1 EDD information structures (XEN) Xen-e820 RAM map: (XEN) 0000000000000000 - 000000000009a400 (usable) (XEN) 000000000009a400 - 00000000000a0000 (reserved) (XEN) 00000000000e0000 - 0000000000100000 (reserved) (XEN) 0000000000100000 - 000000008c404000 (usable) (XEN) 000000008c404000 - 000000008c4dc000 (ACPI NVS) (XEN) 000000008c4dc000 - 000000008c5c2000 (ACPI data) (XEN) 000000008c5c2000 - 000000008d9c2000 (ACPI NVS) (XEN) 000000008d9c2000 - 000000008f602000 (ACPI data) (XEN) 000000008f602000 - 000000008f64f000 (reserved) (XEN) 000000008f64f000 - 000000008f6e6000 (ACPI data) (XEN) 000000008f6e6000 - 000000008f6f0000 (ACPI NVS) (XEN) 000000008f6f0000 - 000000008f6f2000 (ACPI data) (XEN) 000000008f6f2000 - 000000008f7cf000 (ACPI NVS) (XEN) 000000008f7cf000 - 000000008f800000 (ACPI data) (XEN) 000000008f800000 - 0000000090000000 (reserved) (XEN) 00000000a0000000 - 00000000b0000000 (reserved) (XEN) 00000000fc000000 - 00000000fd000000 (reserved) (XEN) 00000000fed1c000 - 00000000fed20000 (reserved) (XEN) 00000000ff800000 - 0000000100000000 (reserved) (XEN) 0000000100000000 - 0000000170000000 (usable) (XEN) ACPI: RSDP 000F0410, 0024 (r2 INTEL ) (XEN) ACPI: XSDT 8F7FD120, 0094 (r1 INTEL S5500BC 0 1000013) (XEN) ACPI: FACP 8F7FB000, 00F4 (r4 INTEL S5500BC 0 MSFT 100000D) (XEN) ACPI: DSDT 8F7F4000, 6485 (r2 INTEL S5500BC 3 MSFT 100000D) (XEN) ACPI: FACS 8F6F2000, 0040 (XEN) ACPI: APIC 8F7F3000, 01A8 (r2 INTEL S5500BC 0 MSFT 100000D) (XEN) ACPI: MCFG 8F7F2000, 003C (r1 INTEL S5500BC 1 MSFT 100000D) (XEN) ACPI: HPET 8F7F1000, 0038 (r1 INTEL S5500BC 1 MSFT 100000D) (XEN) ACPI: SLIT 8F7F0000, 0030 (r1 INTEL S5500BC 1 MSFT 100000D) (XEN) ACPI: SPCR 8F7EF000, 0050 (r1 INTEL S5500BC 0 MSFT 100000D) (XEN) ACPI: WDDT 8F7EE000, 0040 (r1 INTEL S5500BC 0 MSFT 100000D) (XEN) ACPI: SSDT 8F7D3000, 1AFC4 (r2 INTEL SSDT PM 4000 INTL 20061109) (XEN) ACPI: SSDT 8F7D2000, 01D8 (r2 INTEL IPMI 4000 INTL 20061109) (XEN) ACPI: HEST 8F7D1000, 00A8 (r1 INTEL S5500BC 1 INTL 1) (XEN) ACPI: BERT 8F7D0000, 0030 (r1 INTEL S5500BC 1 INTL 1) (XEN) ACPI: ERST 8F7CF000, 0230 (r1 INTEL S5500BC 1 INTL 1) (XEN) ACPI: EINJ 8F6F1000, 0130 (r1 INTEL S5500BC 1 INTL 1) (XEN) ACPI: DMAR 8F6F0000, 01C8 (r1 INTEL S5500BC 1 MSFT 100000D) (XEN) System RAM: 4035MB (4132472kB) (XEN) Domain heap initialised (XEN) Processor #0 7:10 APIC version 21 (XEN) Processor #2 7:10 APIC version 21 (XEN) Processor #4 7:10 APIC version 21 (XEN) Processor #6 7:10 APIC version 21 (XEN) IOAPIC[0]: apic_id 8, version 32, address 0xfec00000, GSI 0-23 (XEN) IOAPIC[1]: apic_id 9, version 32, address 0xfec90000, GSI 24-47 (XEN) Enabling APIC mode: Flat. Using 2 I/O APICs (XEN) Using scheduler: SMP Credit Scheduler (credit) (XEN) Detected 1600.011 MHz processor. (XEN) Initing memory sharing. (XEN) Intel VT-d supported page sizes: 4kB. (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 not enabled. (XEN) I/O virtualisation enabled (XEN) - Dom0 mode: Relaxed (XEN) ENABLING IO-APIC IRQs (XEN) -> Using new ACK method (XEN) Platform timer is 14.318MHz HPET (XEN) Allocated console ring of 16 KiB. (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) HVM: ASIDs enabled. (XEN) HVM: VMX enabled (XEN) HVM: Hardware Assisted Paging (HAP) detected (XEN) HVM: HAP page sizes: 4kB, 2MB (XEN) Brought up 4 CPUs (XEN) *** LOADING DOMAIN 0 *** (XEN) Xen kernel: 64-bit, lsb, compat32 (XEN) Dom0 kernel: 64-bit, PAE, lsb, paddr 0x1000000 -> 0x193d000 (XEN) PHYSICAL MEMORY ARRANGEMENT: (XEN) Dom0 alloc.: 0000000164000000->0000000168000000 (959683 pages to be allocated) (XEN) Init. ramdisk: 000000016e0d0000->000000016ffffc00 (XEN) VIRTUAL MEMORY ARRANGEMENT: (XEN) Loaded kernel: ffffffff81000000->ffffffff8193d000 (XEN) Init. ramdisk: ffffffff8193d000->ffffffff8386cc00 (XEN) Phys-Mach map: ffffffff8386d000->ffffffff83feef98 (XEN) Start info: ffffffff83fef000->ffffffff83fef4b4 (XEN) Page tables: ffffffff83ff0000->ffffffff84015000 (XEN) Boot stack: ffffffff84015000->ffffffff84016000 (XEN) TOTAL: ffffffff80000000->ffffffff84400000 (XEN) ENTRY ADDRESS: ffffffff816ab200 (XEN) Dom0 has maximum 4 VCPUs (XEN) Scrubbing Free RAM: .done. (XEN) Xen trace buffers: disabled (XEN) Std. Loglevel: Errors and warnings (XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings) (XEN) Xen is relinquishing VGA console. (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen) (XEN) Freed 220kB init memory. (XEN) physdev.c:171: dom0: wrong map_pirq type 3 --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77 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 --Apple-Mail=_E4C42B47-476D-4031-A3CB-FC0189E55E77-- From xen-devel-bounces@lists.xen.org Tue Nov 27 15:53:49 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Tue, 27 Nov 2012 15:53:49 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdNTd-0003mL-Rp; Tue, 27 Nov 2012 15:53:37 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TdNTc-0003mG-MS for xen-devel@lists.xen.org; Tue, 27 Nov 2012 15:53:37 +0000 Received: from [85.158.143.35:19053] by server-2.bemta-4.messagelabs.com id DA/33-28922-002E4B05; Tue, 27 Nov 2012 15:53:36 +0000 X-Env-Sender: robert.phillips@citrix.com X-Msg-Ref: server-15.tower-21.messagelabs.com!1354031601!13860350!1 X-Originating-IP: [66.165.176.89] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni44OSA9PiAxODQ3Mzc=\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 28174 invoked from network); 27 Nov 2012 15:53:26 -0000 Received: from smtp.citrix.com (HELO SMTP.CITRIX.COM) (66.165.176.89) by server-15.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 27 Nov 2012 15:53:26 -0000 X-SBRS: None X-MesageID: 45758669 X-Ironport-Server: ftlpip01.citrite.net X-Remote-IP: 75.150.106.249 X-Policy: $Relay X-IronPort-AV: E=Sophos;i="4.83,328,1352073600"; d="scan'208";a="45758669" Received: from 75-150-106-249-newengland.hfc.comcastbusiness.net (HELO paine.oldroadcomputing.net) ([75.150.106.249]) by SMTP.CITRIX.COM with ESMTP; 27 Nov 2012 15:53:19 +0000 From: Robert Phillips To: xen-devel@lists.xen.org Date: Tue, 27 Nov 2012 10:52:55 -0500 Message-Id: <1354031575-11897-1-git-send-email-robert.phillips@citrix.com> X-Mailer: git-send-email 1.7.9.5 Cc: Robert Phillips Subject: [Xen-devel] [PATCH] Provide support for multiple frame buffers in Xen 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 Support is provided for both shadow and hardware assisted paging (HAP) modes. This code bookkeeps the set of video frame buffers (vram), detects when the guest has modified any of those buffers and, upon request, returns a bitmap of the modified pages. This lets other software components re-paint the portions of the monitor (or monitors) that have changed. Each monitor has a frame buffer of some size at some position in guest physical memory. The set of frame buffers being tracked can change over time as monitors are plugged and unplugged. (Version 4 of this patch.) Signed-Off-By: Robert Phillips --- tools/libxc/xenctrl.h | 17 +- xen/arch/x86/hvm/hvm.c | 9 +- xen/arch/x86/mm/Makefile | 1 + xen/arch/x86/mm/dirty_vram.c | 1000 ++++++++++++++++++++++++++++++++++++++ xen/arch/x86/mm/hap/hap.c | 140 +----- xen/arch/x86/mm/paging.c | 222 +++------ xen/arch/x86/mm/shadow/common.c | 334 +++++++------ xen/arch/x86/mm/shadow/multi.c | 174 +++---- xen/arch/x86/mm/shadow/multi.h | 7 +- xen/arch/x86/mm/shadow/types.h | 1 + xen/include/asm-x86/dirty_vram.h | 202 ++++++++ xen/include/asm-x86/hap.h | 4 - xen/include/asm-x86/hvm/domain.h | 2 +- xen/include/asm-x86/paging.h | 23 +- xen/include/asm-x86/shadow.h | 6 - 15 files changed, 1574 insertions(+), 568 deletions(-) create mode 100644 xen/arch/x86/mm/dirty_vram.c create mode 100644 xen/include/asm-x86/dirty_vram.h diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h index 7eb5743..693d7fe 100644 --- a/tools/libxc/xenctrl.h +++ b/tools/libxc/xenctrl.h @@ -1552,15 +1552,20 @@ int xc_hvm_inject_msi( xc_interface *xch, domid_t dom, uint64_t addr, uint32_t data); /* - * Track dirty bit changes in the VRAM area + * Track dirty bit changes in a VRAM region defined by + * [ first_pfn : first_pfn + nr - 1 ] * * All of this is done atomically: - * - get the dirty bitmap since the last call - * - set up dirty tracking area for period up to the next call - * - clear the dirty tracking area. + * - gets the dirty bitmap since the last call, all zeroes for + * the first call with some new region + * - sets up a dirty tracking region for period up to the next call + * - clears the specified dirty tracking region. * - * Returns -ENODATA and does not fill bitmap if the area has changed since the - * last call. + * Creating a new region causes any existing regions that it overlaps + * to be discarded. + * + * Specifying nr == 0 causes all regions to be discarded and + * disables dirty bit tracking. */ int xc_hvm_track_dirty_vram( xc_interface *xch, domid_t dom, diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 34da2f5..4c4d438 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -57,6 +57,7 @@ #include #include #include +#include #include #include #include @@ -66,6 +67,7 @@ #include #include #include +#include "../mm/mm-locks.h" bool_t __read_mostly hvm_enabled; @@ -1433,8 +1435,11 @@ int hvm_hap_nested_page_fault(paddr_t gpa, */ if ( access_w ) { - paging_mark_dirty(v->domain, mfn_x(mfn)); - p2m_change_type(v->domain, gfn, p2m_ram_logdirty, p2m_ram_rw); + if ( p2m_change_type(v->domain, gfn, p2m_ram_logdirty, + p2m_ram_rw) == p2m_ram_logdirty ) + { + paging_mark_dirty_gpfn(v->domain, gfn); + } } rc = 1; goto out_put_gfn; diff --git a/xen/arch/x86/mm/Makefile b/xen/arch/x86/mm/Makefile index 73dcdf4..becd0c9 100644 --- a/xen/arch/x86/mm/Makefile +++ b/xen/arch/x86/mm/Makefile @@ -5,6 +5,7 @@ obj-y += paging.o obj-y += p2m.o p2m-pt.o p2m-ept.o p2m-pod.o obj-y += guest_walk_2.o obj-y += guest_walk_3.o +obj-y += dirty_vram.o obj-$(x86_64) += guest_walk_4.o obj-$(x86_64) += mem_event.o obj-$(x86_64) += mem_paging.o diff --git a/xen/arch/x86/mm/dirty_vram.c b/xen/arch/x86/mm/dirty_vram.c new file mode 100644 index 0000000..32fcc13 --- /dev/null +++ b/xen/arch/x86/mm/dirty_vram.c @@ -0,0 +1,1000 @@ +/* + * arch/x86/mm/dirty_vram.c: Bookkeep/query dirty VRAM pages + * with support for multiple frame buffers. + * + * Copyright (c) 2012, Citrix Systems, Inc. (Robert Phillips) + * Parts of this code are Copyright (c) 2007 Advanced Micro Devices (Wei Huang) + * Parts of this code are Copyright (c) 2007 XenSource Inc. + * Parts of this code are Copyright (c) 2006 by Michael A Fetterman + * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple + * Place - Suite 330, Boston, MA 02111-1307 USA. + */ + + +#include +#include +#include +#include +#include +#include "mm-locks.h" + +#define DEBUG_stop_tracking_all_vram 0 +#define DEBUG_allocating_dirty_vram_range 0 +#define DEBUG_high_water_mark_for_vram_ranges 0 +#define DEBUG_freeing_dirty_vram_range 0 +#define DEBUG_allocate_paddr_links_page 0 +#define DEBUG_update_vram_mapping 0 +#define DEBUG_alloc_paddr_inject_fault 0 + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram; + ASSERT( paging_locked_by_me(d) ); + dirty_vram = d->arch.hvm_domain.dirty_vram = xzalloc(dv_dirty_vram_t); + if ( dirty_vram ) + { + INIT_LIST_HEAD(&dirty_vram->range_head); + INIT_LIST_HEAD(&dirty_vram->ext_head); + } + return dirty_vram; +} + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( !dirty_vram ) + dirty_vram = dirty_vram_alloc(d); + return dirty_vram; +} + + +/* Free domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr, *next; + /* Free all the ranges */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); +#if DEBUG_stop_tracking_all_vram + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] stop tracking all vram\n", + range->begin_pfn, range->end_pfn); +#endif + xfree(range->pl_tab); + xfree(range); + } + /* Free all the extension pages */ + list_for_each_safe(curr, next, &dirty_vram->ext_head) + { + struct dv_paddr_link_ext *ext = + container_of( + curr, struct dv_paddr_link_ext, ext_link); + struct page_info *pg = __virt_to_page(ext); + d->arch.paging.free_page(d, pg); + } + + xfree(dirty_vram); + d->arch.hvm_domain.dirty_vram = NULL; + } +} + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn) +{ + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( gfn >= range->begin_pfn && + gfn < range->end_pfn ) + return range; + } + } + return NULL; +} + +/* + * Returns pointer to dirty vram range matching [begin_pfn .. end_pfn ), + * NULL if none. + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + struct list_head *curr; + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + if ( begin_pfn == range->begin_pfn && + end_pfn == range->end_pfn ) + return range; + } + } + return NULL; +} + +/* Allocate specified dirty_vram range */ +static dv_range_t * +_dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range = NULL; + unsigned long end_pfn = begin_pfn + nr; + dv_pl_entry_t *pl_tab = NULL; + int i; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + +#if DEBUG_allocating_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Allocating dirty vram range hap:%d\n", + begin_pfn, end_pfn, + d->arch.hvm_domain.hap_enabled); +#endif + + range = xzalloc(dv_range_t); + if ( range == NULL ) + goto err_out; + + INIT_LIST_HEAD(&range->range_link); + + range->begin_pfn = begin_pfn; + range->end_pfn = end_pfn; + + if ( !hap_enabled(d) ) + { + if ( (pl_tab = xzalloc_array(dv_pl_entry_t, nr)) == NULL ) + goto err_out; + + for ( i = 0; i != nr; i++ ) + { + pl_tab[i].mapping.sl1ma = INVALID_PADDR; + } + } + + range->pl_tab = pl_tab; + range->mappings_hwm = 1; + + list_add(&range->range_link, &dirty_vram->range_head); + if ( ++dirty_vram->nr_ranges > dirty_vram->ranges_hwm ) + { + dirty_vram->ranges_hwm = dirty_vram->nr_ranges; +#if DEBUG_high_water_mark_for_vram_ranges + gdprintk(XENLOG_DEBUG, + "High water mark for number of vram ranges is now:%d\n", + dirty_vram->ranges_hwm); +#endif + } + return range; + + err_out: + xfree(pl_tab); + xfree(range); + return NULL; +} + + +/* Frees specified dirty_vram range */ +void dirty_vram_range_free(struct domain *d, + dv_range_t *range) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + ASSERT( paging_locked_by_me(d) ); + if ( dirty_vram ) + { + int i, nr = range->end_pfn - range->begin_pfn; + +#if DEBUG_freeing_dirty_vram_range + gdprintk(XENLOG_DEBUG, + "[%05lx:%05lx] Freeing dirty vram range\n", + range->begin_pfn, range->end_pfn); +#endif + + if ( range->pl_tab ) + { + for ( i = 0; i != nr; i++ ) + { + dv_paddr_link_t *plx; + plx = range->pl_tab[i].mapping.pl_next; + /* Does current FB page have multiple mappings? */ + if ( plx ) /* yes */ + { + /* Find the last element in singly-linked list */ + while ( plx->pl_next != NULL ) + plx = plx->pl_next; + + /* Prepend whole list to the free list */ + plx->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = range->pl_tab[i].mapping.pl_next; + } + } + xfree(range->pl_tab); + range->pl_tab = NULL; + } + + /* Remove range from the linked list, free it, and adjust count*/ + list_del(&range->range_link); + xfree(range); + dirty_vram->nr_ranges--; + } +} + +/* + * dirty_vram_range_alloc() + * This function ensures that the new range does not overlap any existing + * ranges -- deleting them if necessary -- and then calls + * _dirty_vram_range_alloc to actually allocate the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + unsigned long end_pfn = begin_pfn + nr; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + struct list_head *curr, *next; + + ASSERT( paging_locked_by_me(d) ); + ASSERT( dirty_vram != NULL ); + + /* + * Ranges cannot overlap so + * free any range that overlaps [ begin_pfn .. end_pfn ) + */ + list_for_each_safe(curr, next, &dirty_vram->range_head) + { + dv_range_t *rng = list_entry(curr, dv_range_t, range_link); + if ( ( ( rng->begin_pfn <= begin_pfn ) && + ( begin_pfn < rng->end_pfn ) + ) || + ( ( begin_pfn <= rng->begin_pfn ) && + ( rng->begin_pfn < end_pfn ) + ) ) + { + /* Different tracking, tear the previous down. */ + dirty_vram_range_free(d, rng); + } + } + + range = _dirty_vram_range_alloc(d, begin_pfn, nr); + if ( !range ) + goto out; + + out: + return range; +} + +/* + * dirty_vram_range_find_or_alloc() + * Find the range for [begin_pfn:begin_pfn+nr). + * If it doesn't exists, create it. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr) +{ + dv_range_t *range; + ASSERT( paging_locked_by_me(d) ); + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + range = dirty_vram_range_alloc(d, begin_pfn, nr); + + return range; +} + + + +/* Allocate a dv_paddr_link struct */ +static dv_paddr_link_t * +alloc_paddr_link(struct domain *d) +{ + dv_paddr_link_t * pl = NULL; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + + ASSERT( paging_locked_by_me(d) ); + BUILD_BUG_ON(sizeof(dv_paddr_link_ext_t) > PAGE_SIZE); + /* Is the list of free pl's empty? */ + if ( dirty_vram->pl_free == NULL ) /* yes */ + { + /* + * Allocate another page of pl's. + * Link them all together and point the free list head at them + */ + int i; + struct page_info *pg = d->arch.paging.alloc_page(d); + dv_paddr_link_ext_t *ext = __page_to_virt(pg); + if ( ext == NULL ) + goto out; + +#if DEBUG_allocate_paddr_links_page + gdprintk(XENLOG_DEBUG, "Allocated another page of paddr_links\n"); +#endif + list_add(&ext->ext_link, &dirty_vram->ext_head); + + /* initialize and link together the new pl entries */ + for ( i = 0; i != ARRAY_SIZE(ext->entries); i++ ) + { + ext->entries[i].sl1ma = INVALID_PADDR; + ext->entries[i].pl_next = &ext->entries[i+1]; + } + ext->entries[ARRAY_SIZE(ext->entries) - 1].pl_next = NULL; + dirty_vram->pl_free = &ext->entries[0]; + } + pl = dirty_vram->pl_free; + dirty_vram->pl_free = pl->pl_next; + + pl->sl1ma = INVALID_PADDR; + pl->pl_next = NULL; + out: + return pl; +} + + +/* + * Free a paddr_link struct. + * + * The caller has walked the singly-linked list of elements + * that have, as their head, an element in a pl_tab cell. + * The list walks has reached the element to be freed. + * (Each element is a dv_paddr_link_t struct.) + * + * @pl points to the element to be freed. + * @ppl points to its predecessor element's next member. + * + * After linking the precessor to the element's successor, + * we can free @pl by prepending it to the list of free + * elements. + * + * As a boundary case (which happens to be the common case), + * @pl points to a cell in the pl_tab rather than to some + * extension element danging from that cell. + * We recognize this case because @ppl is NULL. + * In that case we promote the first extension element by + * copying it into the pl_tab cell and free it. + */ + +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl) +{ + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_paddr_link_t *npl; /* next pl */ + + ASSERT( paging_locked_by_me(d) ); + /* extension mapping? */ + if ( ppl ) /* yes. free it */ + { + ASSERT(pl == (*ppl)); + (*ppl) = npl = pl->pl_next; + } + else /* main table */ + { + /* + * move 2nd mapping to main table. + * and free 2nd mapping + */ + dv_paddr_link_t * spl; + spl = pl->pl_next; + if ( spl == NULL ) + { + pl->sl1ma = INVALID_PADDR; + return pl; + } + pl->sl1ma = spl->sl1ma; + pl->pl_next = spl->pl_next; + npl = pl; /* reprocess main table entry again */ + pl = spl; + } + pl->sl1ma = INVALID_PADDR; + pl->pl_next = dirty_vram->pl_free; + dirty_vram->pl_free = pl; + return npl; +} + + +/* + * dirty_vram_range_update() + * + * This is called whenever a level 1 page table entry is modified. + * If the L1PTE is being cleared, the function removes any paddr_links + * that refer to it. + * If the L1PTE is being set to a frame buffer page, a paddr_link is + * created for that page's entry in pl_tab. + * Returns 1 iff entry found and set or cleared. + */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set) +{ + int effective = 0; + dv_range_t *range; + unsigned long i; + dv_paddr_link_t *pl; + dv_paddr_link_t **ppl; + int len = 0; + + ASSERT(paging_locked_by_me(d)); + range = dirty_vram_range_find_gfn(d, gfn); + if ( !range ) + return effective; + + + i = gfn - range->begin_pfn; + pl = &range->pl_tab[ i ].mapping; + ppl = NULL; + + /* + * find matching entry (pl), if any, and its predecessor + * in linked list (ppl) + */ + while ( pl != NULL ) + { + if ( pl->sl1ma == sl1ma || pl->sl1ma == INVALID_PADDR ) + break; + + ppl = &pl->pl_next; + pl = *ppl; + len++; + } + + if ( set ) + { + /* Did we find sl1ma in either the main table or the linked list? */ + if ( pl == NULL ) /* no, so we'll need to alloc a link */ + { + ASSERT(ppl != NULL); + +#if DEBUG_alloc_paddr_inject_fault + { + static int counter; + + /* Test stuck_dirty logic for some cases */ + if ( (++counter) % 4 == 0 ) + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + gdprintk(XENLOG_DEBUG, + "[%lx] inject stuck dirty fault\n", + gfn ); + goto out; + } + } +#endif + /* + * Have we reached the limit of mappings we're willing + * to bookkeep? + */ + if (len > DV_ADDR_LINK_LIST_LIMIT) /* yes */ + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + + gdprintk(XENLOG_DEBUG, + "[%lx] link limit exceeded\n", + gfn ); + + goto out; + } + + /* alloc link and append it to list */ + (*ppl) = pl = alloc_paddr_link(d); + /* Were we able to allocate a link? */ + if ( pl == NULL ) /* no */ + { + /* Simply mark the frame buffer page as always dirty */ + range->pl_tab[ i ].stuck_dirty = 1; + + gdprintk(XENLOG_DEBUG, + "[%lx] alloc failure\n", + gfn ); + + goto out; + } + } + if ( pl->sl1ma != sl1ma ) + { + ASSERT(pl->sl1ma == INVALID_PADDR); + pl->sl1ma = sl1ma; + range->nr_mappings++; + } + effective = 1; + if ( len > range->mappings_hwm ) + { + range->mappings_hwm = len; +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] set sl1ma:%lx hwm:%d mappings:%d " + "freepages:%d\n", + gfn, sl1ma, + range->mappings_hwm, + range->nr_mappings, + d->arch.paging.shadow.free_pages); +#endif + } + } + else /* clear */ + { + if ( pl && pl->sl1ma == sl1ma ) + { +#if DEBUG_update_vram_mapping + gdprintk(XENLOG_DEBUG, + "[%lx] clear sl1ma:%lx mappings:%d\n", + gfn, sl1ma, + range->nr_mappings - 1); +#endif + free_paddr_link(d, ppl, pl); + --range->nr_mappings; + effective = 1; + } + } + out: + return effective; +} + + +/* + * shadow_scan_dirty_flags() + * This produces a dirty bitmap for the range by examining every + * L1PTE referenced by some dv_paddr_link in the range's pl_tab table. + * It tests and clears each such L1PTE's dirty flag. + */ +static int shadow_scan_dirty_flags(struct domain *d, + dv_range_t *range, + uint8_t *dirty_bitmap) +{ + int flush_tlb = 0; + unsigned long i; + unsigned long nr = range->end_pfn - range->begin_pfn; + + ASSERT( paging_locked_by_me(d) ); + /* Iterate over VRAM to track dirty bits. */ + for ( i = 0; i < nr; i++ ) + { + int dirty = 0, len = 1; + dv_paddr_link_t *pl; + /* Does the frame buffer have an incomplete set of mappings? */ + if ( unlikely(range->pl_tab[i].stuck_dirty) ) /* yes */ + dirty = 1; + else /* The frame buffer's set of mappings is complete. Scan it. */ + for ( pl = &range->pl_tab[i].mapping; + pl; + pl = pl->pl_next, len++ ) + { + l1_pgentry_t *sl1e; + paddr_t sl1ma = pl->sl1ma; + if (sl1ma == INVALID_PADDR) /* FB page is unmapped */ + continue; + sl1e = maddr_to_virt(sl1ma); + if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) + { + dirty = 1; + /* Clear dirty so we can detect if page gets re-dirtied. + * Note: this is atomic, so we may clear a + * _PAGE_ACCESSED set by another processor. + */ + l1e_remove_flags(*sl1e, _PAGE_DIRTY); + flush_tlb = 1; + } + } /* for */ + + if ( dirty ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + + } + + return flush_tlb; +} + + +/* + * shadow_track_dirty_vram() + * This is the API called by the guest to determine which pages in the range + * from [begin_pfn:begin_pfn+nr) have been dirtied since the last call. + * It creates the domain's dv_dirty_vram on demand. + * It creates ranges on demand when some [begin_pfn:nr) is first encountered. + * To collect the dirty bitmask it calls shadow_scan_dirty_flags(). + * It copies the dirty bitmask into guest storage. + */ +int shadow_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + int rc = 0; + unsigned long end_pfn = begin_pfn + nr; + int flush_tlb = 0; + dv_range_t *range; + struct p2m_domain *p2m = p2m_get_hostp2m(d); + + /* + * This range test is tricky. + * + * The range [begin_pfn..end_pfn) is an open interval, so end_pfn + * is a pfn beyond the end of the range. + * + * p2m->max_mapped_pfn is a valid PFN so p2m->max_mapped_pfn + 1 is an + * invalid PFN. + * + * If end_pfn is beyond *that* then the range is invalid. + */ + if ( end_pfn < begin_pfn + || begin_pfn > p2m->max_mapped_pfn + || end_pfn > p2m->max_mapped_pfn + 1 ) + return -EINVAL; + + paging_lock(d); + + if (!nr) + { + dirty_vram_free(d); + goto out; + } + + if ( guest_handle_is_null(guest_dirty_bitmap) ) + goto out; + + if ( !dirty_vram_find_or_alloc(d) ) + { + rc = -ENOMEM; + goto out; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + range = dirty_vram_range_alloc(d, begin_pfn, nr); + if ( range ) + sh_find_all_vram_mappings(d->vcpu[0], range); + } + if ( range ) + { + int size = (nr + BITS_PER_LONG - 1) / BITS_PER_LONG; + unsigned long dirty_bitmap[size]; + + memset(dirty_bitmap, 0x00, size * BYTES_PER_LONG); + + flush_tlb |= shadow_scan_dirty_flags(d, range, (uint8_t*)dirty_bitmap); + + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + (uint8_t*)dirty_bitmap, + size * BYTES_PER_LONG) == 0 ) + rc = 0; + } + + if ( flush_tlb ) + flush_tlb_mask(d->domain_dirty_cpumask); + +out: + paging_unlock(d); + return rc; +} + + +/************************************************/ +/* HAP VRAM TRACKING SUPPORT */ +/************************************************/ + +/* + * hap_enable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-only. + */ +static int hap_enable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + /* turn on PG_log_dirty bit in paging mode */ + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + + /* + * dirty_vram != NULL iff we're tracking dirty vram. + * If we start tracking dirty pages for all memory then + * the dirty_vram structure is freed. + */ + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table to be read-only. */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] enable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_rw, p2m_ram_logdirty); + } + + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_disable_vram_tracking() + * For all ranges, mark all vram pages in range as logdirty read-write. + */ +static int hap_disable_vram_tracking(struct domain *d) +{ + int rc = 0; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr; + + paging_lock(d); + d->arch.paging.mode &= ~PG_log_dirty; + paging_unlock(d); + + p2m_lock(p2m_get_hostp2m(d)); + paging_lock(d); + + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( !dirty_vram ) + { + rc = -EINVAL; + goto out; + } + + /* set l1e entries of P2M table with normal mode */ + list_for_each(curr, &dirty_vram->range_head) + { + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] disable vram tracking\n", + range->begin_pfn, range->end_pfn); + p2m_change_type_range(d, range->begin_pfn, range->end_pfn, + p2m_ram_logdirty, p2m_ram_rw); + } + flush_tlb_mask(d->domain_dirty_cpumask); + out: + paging_unlock(d); + p2m_unlock(p2m_get_hostp2m(d)); + if ( rc ) + { + paging_lock(d); + d->arch.paging.mode |= PG_log_dirty; + paging_unlock(d); + } + return rc; +} + +/* + * hap_clean_vram_tracking_range() + * For all the pages in the range specified by [begin_pfn,nr), + * note in the dirty bitmap any page that has been marked as read-write, + * which signifies that the page has been dirtied, and reset the page + * to ram_logdirty. + */ +void hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) +{ + int i; + unsigned long pfn; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; + dv_range_t *range; + + ASSERT(p2m_locked_by_me(p2m_get_hostp2m(d))); + ASSERT(paging_locked_by_me(d)); + + if ( !dirty_vram ) + { + gdprintk(XENLOG_DEBUG, + "Should only be called while tracking dirty vram.\n"); + return; + } + + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + return; + + /* set l1e entries of P2M table to be read-only. */ + /* + * On first write, it page faults, its entry is changed to read-write, + * its bit in the dirty bitmap is set, and on retry the write succeeds. + */ + for ( i = 0, pfn = range->begin_pfn; pfn < range->end_pfn; i++, pfn++ ) + { + p2m_type_t pt; + pt = p2m_change_type(d, pfn, p2m_ram_rw, p2m_ram_logdirty); + if ( pt == p2m_ram_rw ) + dirty_bitmap[i >> 3] |= (1 << (i & 7)); + } + flush_tlb_mask(d->domain_dirty_cpumask); +} + +static void hap_vram_tracking_init(struct domain *d) +{ + paging_log_dirty_init(d, hap_enable_vram_tracking, + hap_disable_vram_tracking, + NULL); +} + +/* + * hap_track_dirty_vram() + * Create the domain's dv_dirty_vram struct on demand. + * Create a dirty vram range on demand when some [begin_pfn:begin_pfn+nr] is + * first encountered. + * Collect the guest_dirty bitmask, a bit mask of the dirty vram pages, by + * calling paging_log_dirty_range(). + */ +int hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) guest_dirty_bitmap) +{ + long rc = 0; + dv_dirty_vram_t *dirty_vram; + + paging_lock(d); + dirty_vram = d->arch.hvm_domain.dirty_vram; + if ( nr ) + { + dv_range_t *range = NULL; + int size = ( nr + BITS_PER_LONG - 1 ) & ~( BITS_PER_LONG - 1 ); + uint8_t dirty_bitmap[size]; + bool_t new_range = 0; + + /* Already tracking dirty vram? */ + if ( paging_mode_log_dirty(d) && dirty_vram ) /* yes */ + { + /* Handle the addition of another range */ + range = dirty_vram_range_find(d, begin_pfn, nr); + if ( !range ) + { + rc = -ENOMEM; + if ( !(range = dirty_vram_range_alloc(d, begin_pfn, nr)) ) + goto param_fail; + new_range = 1; + } + } + /* Just starting to track dirty vram? */ + else if ( !paging_mode_log_dirty(d) && !dirty_vram ) /* yes */ + { + rc = -ENOMEM; + if ( !(dirty_vram = dirty_vram_alloc(d)) ) + goto param_fail; + + if ( !(range = dirty_vram_range_find_or_alloc(d, begin_pfn, + nr)) ) + goto param_fail; + + new_range = 1; + + /* Initialize callbacks for vram tracking */ + hap_vram_tracking_init(d); + + /* Enable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_enable(d); + paging_lock(d); + + if ( rc != 0 ) + goto param_fail; + } + else + { + /* Test for invalid combination */ + if ( !paging_mode_log_dirty(d) && dirty_vram ) + rc = -EINVAL; + else /* logging dirty of all memory, not tracking dirty vram */ + rc = -ENODATA; + goto param_fail; + } + + paging_unlock(d); + /* Is this query the very first for this range? */ + if ( new_range ) /* yes */ + memset(dirty_bitmap, 0xff, size); /* consider all pages dirty */ + else + { + memset(dirty_bitmap, 0x00, size); + paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); + } + rc = -EFAULT; + if ( copy_to_guest(guest_dirty_bitmap, + dirty_bitmap, + size) == 0 ) + { + rc = 0; + } + } + else + { + /* + * If zero pages specified while already tracking dirty vram + * then stop tracking + */ + if ( paging_mode_log_dirty(d) && dirty_vram ) + { + /* Disable HAP vram tracking */ + paging_unlock(d); + rc = paging_log_dirty_disable(d); + paging_lock(d); + + dirty_vram_free(d); + } + else /* benign no-op */ + { + rc = 0; + } + paging_unlock(d); + } + + return rc; + +param_fail: + dirty_vram_free(d); + paging_unlock(d); + return rc; +} + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/arch/x86/mm/hap/hap.c b/xen/arch/x86/mm/hap/hap.c index fd99cde..09cdba2 100644 --- a/xen/arch/x86/mm/hap/hap.c +++ b/xen/arch/x86/mm/hap/hap.c @@ -41,6 +41,7 @@ #include #include #include +#include #include "private.h" @@ -53,139 +54,6 @@ #define page_to_mfn(_pg) _mfn(__page_to_mfn(_pg)) /************************************************/ -/* HAP VRAM TRACKING SUPPORT */ -/************************************************/ - -static int hap_enable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - /* turn on PG_log_dirty bit in paging mode */ - paging_lock(d); - d->arch.paging.mode |= PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static int hap_disable_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return -EINVAL; - - paging_lock(d); - d->arch.paging.mode &= ~PG_log_dirty; - paging_unlock(d); - - /* set l1e entries of P2M table with normal mode */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_logdirty, p2m_ram_rw); - - flush_tlb_mask(d->domain_dirty_cpumask); - return 0; -} - -static void hap_clean_vram_tracking(struct domain *d) -{ - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram ) - return; - - /* set l1e entries of P2M table to be read-only. */ - p2m_change_type_range(d, dirty_vram->begin_pfn, dirty_vram->end_pfn, - p2m_ram_rw, p2m_ram_logdirty); - - flush_tlb_mask(d->domain_dirty_cpumask); -} - -static void hap_vram_tracking_init(struct domain *d) -{ - paging_log_dirty_init(d, hap_enable_vram_tracking, - hap_disable_vram_tracking, - hap_clean_vram_tracking); -} - -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - long rc = 0; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( nr ) - { - if ( paging_mode_log_dirty(d) && dirty_vram ) - { - if ( begin_pfn != dirty_vram->begin_pfn || - begin_pfn + nr != dirty_vram->end_pfn ) - { - paging_log_dirty_disable(d); - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - } - else if ( !paging_mode_log_dirty(d) && !dirty_vram ) - { - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto param_fail; - - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = begin_pfn + nr; - d->arch.hvm_domain.dirty_vram = dirty_vram; - hap_vram_tracking_init(d); - rc = paging_log_dirty_enable(d); - if (rc != 0) - goto param_fail; - } - else - { - if ( !paging_mode_log_dirty(d) && dirty_vram ) - rc = -EINVAL; - else - rc = -ENODATA; - goto param_fail; - } - /* get the bitmap */ - rc = paging_log_dirty_range(d, begin_pfn, nr, dirty_bitmap); - } - else - { - if ( paging_mode_log_dirty(d) && dirty_vram ) { - rc = paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } else - rc = 0; - } - - return rc; - -param_fail: - if ( dirty_vram ) - { - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } - return rc; -} - -/************************************************/ /* HAP LOG DIRTY SUPPORT */ /************************************************/ @@ -223,14 +91,12 @@ static void hap_clean_dirty_bitmap(struct domain *d) void hap_logdirty_init(struct domain *d) { - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + struct dv_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; if ( paging_mode_log_dirty(d) && dirty_vram ) { paging_log_dirty_disable(d); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; + dirty_vram_free(d); } - /* Reinitialize logdirty mechanism */ paging_log_dirty_init(d, hap_enable_log_dirty, hap_disable_log_dirty, diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..f0ac512 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -27,6 +27,7 @@ #include #include #include +#include #include #include @@ -192,15 +193,11 @@ int paging_log_dirty_disable(struct domain *d) return ret; } -/* Mark a page as dirty */ +/* Given a guest mfn, mark a page as dirty */ void paging_mark_dirty(struct domain *d, unsigned long guest_mfn) { unsigned long pfn; mfn_t gmfn; - int changed; - mfn_t mfn, *l4, *l3, *l2; - unsigned long *l1; - int i1, i2, i3, i4; gmfn = _mfn(guest_mfn); @@ -210,6 +207,19 @@ void paging_mark_dirty(struct domain *d, unsigned long guest_mfn) /* We /really/ mean PFN here, even for non-translated guests. */ pfn = get_gpfn_from_mfn(mfn_x(gmfn)); + paging_mark_dirty_gpfn(d, pfn); +} + + +/* Given a guest pfn, mark a page as dirty */ +void paging_mark_dirty_gpfn(struct domain *d, unsigned long pfn) +{ + int changed; + mfn_t mfn, *l4, *l3, *l2; + unsigned long *l1; + int i1, i2, i3, i4; + dv_range_t *range; + /* Shared MFNs should NEVER be marked dirty */ BUG_ON(SHARED_M2P(pfn)); @@ -229,6 +239,11 @@ void paging_mark_dirty(struct domain *d, unsigned long guest_mfn) /* Recursive: this is called from inside the shadow code */ paging_lock_recursive(d); + d->arch.paging.log_dirty.dirty_count++; + range = dirty_vram_range_find_gfn(d, pfn); + if ( range ) + range->dirty_count++; + if ( unlikely(!mfn_valid(d->arch.paging.log_dirty.top)) ) { d->arch.paging.log_dirty.top = paging_new_log_dirty_node(d); @@ -333,8 +348,11 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) mfn_t *l4, *l3, *l2; unsigned long *l1; int i4, i3, i2; + struct p2m_domain *p2m = p2m_get_hostp2m(d); domain_pause(d); + /* Locking hierarchy requires p2m lock to be taken first */ + p2m_lock(p2m); paging_lock(d); clean = (sc->op == XEN_DOMCTL_SHADOW_OP_CLEAN); @@ -345,6 +363,16 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) d->arch.paging.log_dirty.fault_count, d->arch.paging.log_dirty.dirty_count); + if ( hap_enabled(d) && d->arch.hvm_domain.dirty_vram ) + { + /* + * If we're cleaning/peeking all guest memory, we should not + * be tracking dirty vram. + */ + rv = -EINVAL; + goto out; + } + sc->stats.fault_count = d->arch.paging.log_dirty.fault_count; sc->stats.dirty_count = d->arch.paging.log_dirty.dirty_count; @@ -424,170 +452,64 @@ int paging_log_dirty_op(struct domain *d, struct xen_domctl_shadow_op *sc) if ( clean ) { - /* We need to further call clean_dirty_bitmap() functions of specific - * paging modes (shadow or hap). Safe because the domain is paused. */ - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + /* Is null if tracking dirty vram */ + if ( d->arch.paging.log_dirty.clean_dirty_bitmap ) + { + /* + * We need to call clean_dirty_bitmap() functions of specific + * paging modes (shadow or hap). + * Safe because the domain is paused. + */ + d->arch.paging.log_dirty.clean_dirty_bitmap(d); + } } domain_unpause(d); return rv; out: paging_unlock(d); + p2m_unlock(p2m); domain_unpause(d); return rv; } -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap) { - int rv = 0; - unsigned long pages = 0; - mfn_t *l4, *l3, *l2; - unsigned long *l1; - int b1, b2, b3, b4; - int i2, i3, i4; - - d->arch.paging.log_dirty.clean_dirty_bitmap(d); + struct p2m_domain *p2m = p2m_get_hostp2m(d); + dv_range_t *range; + unsigned int range_dirty_count = 0; + + p2m_lock(p2m); paging_lock(d); - PAGING_DEBUG(LOGDIRTY, "log-dirty-range: dom %u faults=%u dirty=%u\n", - d->domain_id, - d->arch.paging.log_dirty.fault_count, - d->arch.paging.log_dirty.dirty_count); - - if ( unlikely(d->arch.paging.log_dirty.failed_allocs) ) { - printk("%s: %d failed page allocs while logging dirty pages\n", - __FUNCTION__, d->arch.paging.log_dirty.failed_allocs); - rv = -ENOMEM; - goto out; - } - - if ( !d->arch.paging.log_dirty.fault_count && - !d->arch.paging.log_dirty.dirty_count ) { - unsigned int size = BITS_TO_LONGS(nr); - - if ( clear_guest(dirty_bitmap, size * BYTES_PER_LONG) != 0 ) - rv = -EFAULT; - goto out; - } - d->arch.paging.log_dirty.fault_count = 0; - d->arch.paging.log_dirty.dirty_count = 0; - - b1 = L1_LOGDIRTY_IDX(begin_pfn); - b2 = L2_LOGDIRTY_IDX(begin_pfn); - b3 = L3_LOGDIRTY_IDX(begin_pfn); - b4 = L4_LOGDIRTY_IDX(begin_pfn); - l4 = paging_map_log_dirty_bitmap(d); - - for ( i4 = b4; - (pages < nr) && (i4 < LOGDIRTY_NODE_ENTRIES); - i4++ ) + /* Only called when tracking dirty vram in HAP mode */ + ASSERT(hap_enabled(d) && d->arch.hvm_domain.dirty_vram); + + range = dirty_vram_range_find_gfn(d, begin_pfn); + if ( range ) { - l3 = (l4 && mfn_valid(l4[i4])) ? map_domain_page(mfn_x(l4[i4])) : NULL; - for ( i3 = b3; - (pages < nr) && (i3 < LOGDIRTY_NODE_ENTRIES); - i3++ ) - { - l2 = ((l3 && mfn_valid(l3[i3])) ? - map_domain_page(mfn_x(l3[i3])) : NULL); - for ( i2 = b2; - (pages < nr) && (i2 < LOGDIRTY_NODE_ENTRIES); - i2++ ) - { - unsigned int bytes = PAGE_SIZE; - uint8_t *s; - l1 = ((l2 && mfn_valid(l2[i2])) ? - map_domain_page(mfn_x(l2[i2])) : NULL); - - s = ((uint8_t*)l1) + (b1 >> 3); - bytes -= b1 >> 3; - - if ( likely(((nr - pages + 7) >> 3) < bytes) ) - bytes = (unsigned int)((nr - pages + 7) >> 3); - - if ( !l1 ) - { - if ( clear_guest_offset(dirty_bitmap, pages >> 3, - bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - /* begin_pfn is not 32K aligned, hence we have to bit - * shift the bitmap */ - else if ( b1 & 0x7 ) - { - int i, j; - uint32_t *l = (uint32_t*) s; - int bits = b1 & 0x7; - int bitmask = (1 << bits) - 1; - int size = (bytes + BYTES_PER_LONG - 1) / BYTES_PER_LONG; - unsigned long bitmap[size]; - static unsigned long printed = 0; - - if ( printed != begin_pfn ) - { - dprintk(XENLOG_DEBUG, "%s: begin_pfn %lx is not 32K aligned!\n", - __FUNCTION__, begin_pfn); - printed = begin_pfn; - } - - for ( i = 0; i < size - 1; i++, l++ ) { - bitmap[i] = ((*l) >> bits) | - (((*((uint8_t*)(l + 1))) & bitmask) << (sizeof(*l) * 8 - bits)); - } - s = (uint8_t*) l; - size = BYTES_PER_LONG - ((b1 >> 3) & 0x3); - bitmap[i] = 0; - for ( j = 0; j < size; j++, s++ ) - bitmap[i] |= (*s) << (j * 8); - bitmap[i] = (bitmap[i] >> bits) | (bitmask << (size * 8 - bits)); - if ( copy_to_guest_offset(dirty_bitmap, (pages >> 3), - (uint8_t*) bitmap, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - else - { - if ( copy_to_guest_offset(dirty_bitmap, pages >> 3, - s, bytes) != 0 ) - { - rv = -EFAULT; - goto out; - } - } - - pages += bytes << 3; - if ( l1 ) - { - clear_page(l1); - unmap_domain_page(l1); - } - b1 = b1 & 0x7; - } - b2 = 0; - if ( l2 ) - unmap_domain_page(l2); - } - b3 = 0; - if ( l3 ) - unmap_domain_page(l3); + range_dirty_count = range->dirty_count; + range->dirty_count = 0; } - if ( l4 ) - unmap_domain_page(l4); - - paging_unlock(d); + + if ( !range_dirty_count) + goto out; - return rv; + PAGING_DEBUG(LOGDIRTY, + "log-dirty-range: dom %u [%05lx:%05lx] range_dirty=%u\n", + d->domain_id, + begin_pfn, + range->end_pfn, + range_dirty_count); + hap_clean_vram_tracking_range(d, begin_pfn, nr, dirty_bitmap); out: paging_unlock(d); - return rv; + p2m_unlock(p2m); + return; } /* Note that this function takes three function pointers. Callers must supply diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c index ce79131..30829b6 100644 --- a/xen/arch/x86/mm/shadow/common.c +++ b/xen/arch/x86/mm/shadow/common.c @@ -36,6 +36,7 @@ #include #include #include +#include #include #include "private.h" @@ -3121,12 +3122,7 @@ void shadow_teardown(struct domain *d) * calls now that we've torn down the bitmap */ d->arch.paging.mode &= ~PG_log_dirty; - if (d->arch.hvm_domain.dirty_vram) { - xfree(d->arch.hvm_domain.dirty_vram->sl1ma); - xfree(d->arch.hvm_domain.dirty_vram->dirty_bitmap); - xfree(d->arch.hvm_domain.dirty_vram); - d->arch.hvm_domain.dirty_vram = NULL; - } + dirty_vram_free(d); paging_unlock(d); @@ -3463,177 +3459,209 @@ void shadow_clean_dirty_bitmap(struct domain *d) /**************************************************************************/ -/* VRAM dirty tracking support */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap) -{ - int rc; - unsigned long end_pfn = begin_pfn + nr; - unsigned long dirty_size = (nr + 7) / 8; - int flush_tlb = 0; - unsigned long i; - p2m_type_t t; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - struct p2m_domain *p2m = p2m_get_hostp2m(d); - - if (end_pfn < begin_pfn - || begin_pfn > p2m->max_mapped_pfn - || end_pfn >= p2m->max_mapped_pfn) - return -EINVAL; - - /* We perform p2m lookups, so lock the p2m upfront to avoid deadlock */ - p2m_lock(p2m_get_hostp2m(d)); - paging_lock(d); +/* Support functions for shadow-based dirty VRAM code */ - if ( dirty_vram && (!nr || - ( begin_pfn != dirty_vram->begin_pfn - || end_pfn != dirty_vram->end_pfn )) ) - { - /* Different tracking, tear the previous down. */ - gdprintk(XENLOG_INFO, "stopping tracking VRAM %lx - %lx\n", dirty_vram->begin_pfn, dirty_vram->end_pfn); - xfree(dirty_vram->sl1ma); - xfree(dirty_vram->dirty_bitmap); - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; - } +#define DEBUG_unshadow_sl1ma 0 +#define DEBUG_unshadow_sl1ma_detail 0 +#define DEBUG_count_initial_mappings 1 - if ( !nr ) +/* smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn) +{ + static unsigned int l1_shadow_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; + struct domain *d = v->domain; + dv_dirty_vram_t *dirty_vram; + struct list_head *curr, *next; + + ASSERT(paging_locked_by_me(d)); + /* Ignore all but level 1 shadows */ + + if ((l1_shadow_mask & (1 << shadow_type)) == 0) { - rc = 0; goto out; } - /* This should happen seldomly (Video mode change), - * no need to be careful. */ + dirty_vram = d->arch.hvm_domain.dirty_vram; if ( !dirty_vram ) { - /* Throw away all the shadows rather than walking through them - * up to nr times getting rid of mappings of each pfn */ - shadow_blow_tables(d); - - gdprintk(XENLOG_INFO, "tracking VRAM %lx - %lx\n", begin_pfn, end_pfn); - - rc = -ENOMEM; - if ( (dirty_vram = xmalloc(struct sh_dirty_vram)) == NULL ) - goto out; - dirty_vram->begin_pfn = begin_pfn; - dirty_vram->end_pfn = end_pfn; - d->arch.hvm_domain.dirty_vram = dirty_vram; - - if ( (dirty_vram->sl1ma = xmalloc_array(paddr_t, nr)) == NULL ) - goto out_dirty_vram; - memset(dirty_vram->sl1ma, ~0, sizeof(paddr_t) * nr); - - if ( (dirty_vram->dirty_bitmap = xzalloc_array(uint8_t, dirty_size)) == NULL ) - goto out_sl1ma; - - dirty_vram->last_dirty = NOW(); - - /* Tell the caller that this time we could not track dirty bits. */ - rc = -ENODATA; - } - else if (dirty_vram->last_dirty == -1) - { - /* still completely clean, just copy our empty bitmap */ - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) - rc = 0; + goto out; } - else + + list_for_each_safe(curr, next, &dirty_vram->range_head) { - /* Iterate over VRAM to track dirty bits. */ - for ( i = 0; i < nr; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, begin_pfn + i, &t); - struct page_info *page; - int dirty = 0; - paddr_t sl1ma = dirty_vram->sl1ma[i]; - - if (mfn_x(mfn) == INVALID_MFN) - { - dirty = 1; - } - else + dv_range_t *range = list_entry(curr, dv_range_t, range_link); + unsigned long i; + int max_mappings = 1, mappings = 0; + int unshadowed = 0; + for (i = 0; i != range->end_pfn - range->begin_pfn; i++) + { + dv_paddr_link_t *pl = &range->pl_tab[ i ].mapping; + dv_paddr_link_t **ppl = NULL; + mappings = 0; + + while (pl != NULL) { - page = mfn_to_page(mfn); - switch (page->u.inuse.type_info & PGT_count_mask) - { - case 0: - /* No guest reference, nothing to track. */ - break; - case 1: - /* One guest reference. */ - if ( sl1ma == INVALID_PADDR ) - { - /* We don't know which sl1e points to this, too bad. */ - dirty = 1; - /* TODO: Heuristics for finding the single mapping of - * this gmfn */ - flush_tlb |= sh_remove_all_mappings(d->vcpu[0], mfn); - } - else - { - /* Hopefully the most common case: only one mapping, - * whose dirty bit we can use. */ - l1_pgentry_t *sl1e = maddr_to_virt(sl1ma); - - if ( l1e_get_flags(*sl1e) & _PAGE_DIRTY ) - { - dirty = 1; - /* Note: this is atomic, so we may clear a - * _PAGE_ACCESSED set by another processor. */ - l1e_remove_flags(*sl1e, _PAGE_DIRTY); - flush_tlb = 1; - } - } - break; - default: - /* More than one guest reference, - * we don't afford tracking that. */ - dirty = 1; + paddr_t sl1ma = pl->sl1ma; + unsigned long sl1mn; + + if (sl1ma == INVALID_PADDR ) break; + + sl1mn = sl1ma >> PAGE_SHIFT; + if (sl1mn == mfn_x(smfn)) { +#if DEBUG_unshadow_sl1ma_detail + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%lx] unshadow sl1ma:%lx\n", + mfn_x(smfn), + range->begin_pfn + i, + sl1ma); +#endif + unshadowed++; + pl = free_paddr_link(d, ppl, pl); + --range->nr_mappings; + } + else + { + ppl = &pl->pl_next; + pl = *ppl; + mappings++; } } - - if ( dirty ) + } + if (mappings > max_mappings) + max_mappings = mappings; + + if (unshadowed) { +#if DEBUG_unshadow_sl1ma + gdprintk(XENLOG_DEBUG, + "[%lx] gfn[%05lx:%05lx] unshadowed:%d mappings:0x%x max_mappings:%d\n", + mfn_x(smfn), + range->begin_pfn, range->end_pfn, + unshadowed, range->nr_mappings, max_mappings); +#endif + if ( range->nr_mappings == 0 ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + dirty_vram_range_free(d, range); } } + } + out: + return; +} + + +typedef int (*hash_pfn_callback_t)(struct vcpu *v, + mfn_t smfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); - rc = -EFAULT; - if ( copy_to_guest(dirty_bitmap, dirty_vram->dirty_bitmap, dirty_size) == 0 ) { - memset(dirty_vram->dirty_bitmap, 0, dirty_size); - if (dirty_vram->last_dirty + SECONDS(2) < NOW()) +static int hash_pfn_foreach(struct vcpu *v, + unsigned int callback_mask, + hash_pfn_callback_t callbacks[], + unsigned long begin_pfn, + unsigned long end_pfn) +/* Walk the hash table looking at the types of the entries and + * calling the appropriate callback function for each entry. + * The mask determines which shadow types we call back for, and the array + * of callbacks tells us which function to call. + * Any callback may return non-zero to let us skip the rest of the scan. + * + * WARNING: Callbacks MUST NOT add or remove hash entries unless they + * then return non-zero to terminate the scan. */ +{ + int i, done = 0, removed = 0; + struct domain *d = v->domain; + struct page_info *x; + + /* Say we're here, to stop hash-lookups reordering the chains */ + ASSERT(paging_locked_by_me(d)); + ASSERT(d->arch.paging.shadow.hash_walking == 0); + d->arch.paging.shadow.hash_walking = 1; + + for ( i = 0; i < SHADOW_HASH_BUCKETS; i++ ) + { + /* WARNING: This is not safe against changes to the hash table. + * The callback *must* return non-zero if it has inserted or + * deleted anything from the hash (lookups are OK, though). */ + for ( x = d->arch.paging.shadow.hash_table[i]; x; x = next_shadow(x) ) + { + if ( callback_mask & (1 << x->u.sh.type) ) { - /* was clean for more than two seconds, try to disable guest - * write access */ - for ( i = begin_pfn; i < end_pfn; i++ ) { - mfn_t mfn = get_gfn_query_unlocked(d, i, &t); - if (mfn_x(mfn) != INVALID_MFN) - flush_tlb |= sh_remove_write_access(d->vcpu[0], mfn, 1, 0); - } - dirty_vram->last_dirty = -1; + ASSERT(x->u.sh.type <= 15); + ASSERT(callbacks[x->u.sh.type] != NULL); + done = callbacks[x->u.sh.type](v, page_to_mfn(x), + begin_pfn, end_pfn, + &removed); + if ( done ) break; } - rc = 0; } + if ( done ) break; } - if ( flush_tlb ) - flush_tlb_mask(d->domain_dirty_cpumask); - goto out; + d->arch.paging.shadow.hash_walking = 0; + return removed; +} + +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range) +{ + /* Dispatch table for getting per-type functions */ + static hash_pfn_callback_t callbacks[SH_type_unused] = { + NULL, /* none */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* l1_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 2), /* fl1_32 */ + NULL, /* l2_32 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* l1_pae */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 3), /* fl1_pae */ + NULL, /* l2_pae */ + NULL, /* l2h_pae */ +#if CONFIG_PAGING_LEVELS >= 4 + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* l1_64 */ + SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, 4), /* fl1_64 */ +#else + NULL, /* l1_64 */ + NULL, /* fl1_64 */ +#endif + NULL, /* l2_64 */ + NULL, /* l2h_64 */ + NULL, /* l3_64 */ + NULL, /* l4_64 */ + NULL, /* p2m */ + NULL /* unused */ + }; -out_sl1ma: - xfree(dirty_vram->sl1ma); -out_dirty_vram: - xfree(dirty_vram); - dirty_vram = d->arch.hvm_domain.dirty_vram = NULL; + static unsigned int callback_mask = + 1 << SH_type_l1_32_shadow + | 1 << SH_type_fl1_32_shadow + | 1 << SH_type_l1_pae_shadow + | 1 << SH_type_fl1_pae_shadow + | 1 << SH_type_l1_64_shadow + | 1 << SH_type_fl1_64_shadow + ; -out: - paging_unlock(d); - p2m_unlock(p2m_get_hostp2m(d)); - return rc; + perfc_incr(shadow_mappings); + + hash_pfn_foreach(v, callback_mask, callbacks, + range->begin_pfn, + range->end_pfn); + +#if DEBUG_count_initial_mappings + gdprintk(XENLOG_DEBUG, "[%05lx:%05lx] count of initial mappings:%d\n", + range->begin_pfn, range->end_pfn, + range->nr_mappings); +#endif } /**************************************************************************/ diff --git a/xen/arch/x86/mm/shadow/multi.c b/xen/arch/x86/mm/shadow/multi.c index 4967da1..bb983bc 100644 --- a/xen/arch/x86/mm/shadow/multi.c +++ b/xen/arch/x86/mm/shadow/multi.c @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -149,6 +150,10 @@ delete_fl1_shadow_status(struct vcpu *v, gfn_t gfn, mfn_t smfn) SHADOW_PRINTK("gfn=%"SH_PRI_gfn", type=%08x, smfn=%05lx\n", gfn_x(gfn), SH_type_fl1_shadow, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); + shadow_hash_delete(v, gfn_x(gfn), SH_type_fl1_shadow, smfn); } @@ -160,6 +165,10 @@ delete_shadow_status(struct vcpu *v, mfn_t gmfn, u32 shadow_type, mfn_t smfn) v->domain->domain_id, v->vcpu_id, mfn_x(gmfn), shadow_type, mfn_x(smfn)); ASSERT(mfn_to_page(smfn)->u.sh.head); + + /* Removing any dv_paddr_links to the erstwhile shadow page */ + dirty_vram_delete_shadow(v, mfn_x(gmfn), shadow_type, smfn); + shadow_hash_delete(v, mfn_x(gmfn), shadow_type, smfn); /* 32-on-64 PV guests don't own their l4 pages; see set_shadow_status */ if ( !is_pv_32on64_vcpu(v) || shadow_type != SH_type_l4_64_shadow ) @@ -516,7 +525,6 @@ _sh_propagate(struct vcpu *v, guest_l1e_t guest_entry = { guest_intpte }; shadow_l1e_t *sp = shadow_entry_ptr; struct domain *d = v->domain; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; gfn_t target_gfn = guest_l1e_get_gfn(guest_entry); u32 pass_thru_flags; u32 gflags, sflags; @@ -663,17 +671,6 @@ _sh_propagate(struct vcpu *v, } } - if ( unlikely((level == 1) && dirty_vram - && dirty_vram->last_dirty == -1 - && gfn_x(target_gfn) >= dirty_vram->begin_pfn - && gfn_x(target_gfn) < dirty_vram->end_pfn) ) - { - if ( ft & FETCH_TYPE_WRITE ) - dirty_vram->last_dirty = NOW(); - else - sflags &= ~_PAGE_RW; - } - /* Read-only memory */ if ( p2m_is_readonly(p2mt) || (p2mt == p2m_mmio_direct && @@ -1072,101 +1069,60 @@ static int shadow_set_l2e(struct vcpu *v, return flags; } -static inline void shadow_vram_get_l1e(shadow_l1e_t new_sl1e, +/* shadow_vram_fix_l1e() + * + * Tests L1PTEs as they are modified, looking for when they start to (or + * cease to) point to frame buffer pages. If the old and new gfns differ, + * calls dirty_vram_range_update() to updates the dirty_vram structures. + */ +static inline void shadow_vram_fix_l1e(shadow_l1e_t old_sl1e, + shadow_l1e_t new_sl1e, shadow_l1e_t *sl1e, mfn_t sl1mfn, struct domain *d) { - mfn_t mfn = shadow_l1e_get_mfn(new_sl1e); - int flags = shadow_l1e_get_flags(new_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; + mfn_t new_mfn, old_mfn; + unsigned long new_gfn = INVALID_M2P_ENTRY, old_gfn = INVALID_M2P_ENTRY; + paddr_t sl1ma; + dv_dirty_vram_t *dirty_vram = d->arch.hvm_domain.dirty_vram; - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ + if ( !dirty_vram ) return; - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); + sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) | ((unsigned long)sl1e & ~PAGE_MASK); - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + old_mfn = shadow_l1e_get_mfn(old_sl1e); + + if ( !sh_l1e_is_magic(old_sl1e) && + (l1e_get_flags(old_sl1e) & _PAGE_PRESENT) && + mfn_valid(old_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - /* Initial guest reference, record it */ - dirty_vram->sl1ma[i] = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + old_gfn = mfn_to_gfn(d, old_mfn); } -} - -static inline void shadow_vram_put_l1e(shadow_l1e_t old_sl1e, - shadow_l1e_t *sl1e, - mfn_t sl1mfn, - struct domain *d) -{ - mfn_t mfn = shadow_l1e_get_mfn(old_sl1e); - int flags = shadow_l1e_get_flags(old_sl1e); - unsigned long gfn; - struct sh_dirty_vram *dirty_vram = d->arch.hvm_domain.dirty_vram; - - if ( !dirty_vram /* tracking disabled? */ - || !(flags & _PAGE_RW) /* read-only mapping? */ - || !mfn_valid(mfn) ) /* mfn can be invalid in mmio_direct */ - return; - - gfn = mfn_to_gfn(d, mfn); - /* Page sharing not supported on shadow PTs */ - BUG_ON(SHARED_M2P(gfn)); - - if ( (gfn >= dirty_vram->begin_pfn) && (gfn < dirty_vram->end_pfn) ) + + new_mfn = shadow_l1e_get_mfn(new_sl1e); + if ( !sh_l1e_is_magic(new_sl1e) && + (l1e_get_flags(new_sl1e) & _PAGE_PRESENT) && + mfn_valid(new_mfn)) { - unsigned long i = gfn - dirty_vram->begin_pfn; - struct page_info *page = mfn_to_page(mfn); - int dirty = 0; - paddr_t sl1ma = pfn_to_paddr(mfn_x(sl1mfn)) - | ((unsigned long)sl1e & ~PAGE_MASK); + new_gfn = mfn_to_gfn(d, new_mfn); + } - if ( (page->u.inuse.type_info & PGT_count_mask) == 1 ) - { - /* Last reference */ - if ( dirty_vram->sl1ma[i] == INVALID_PADDR ) { - /* We didn't know it was that one, let's say it is dirty */ - dirty = 1; - } - else - { - ASSERT(dirty_vram->sl1ma[i] == sl1ma); - dirty_vram->sl1ma[i] = INVALID_PADDR; - if ( flags & _PAGE_DIRTY ) - dirty = 1; - } - } - else + if ( old_gfn == new_gfn ) return; + + if ( VALID_M2P(old_gfn) ) + if ( dirty_vram_range_update(d, old_gfn, sl1ma, 0/*clear*/) ) { - /* We had more than one reference, just consider the page dirty. */ - dirty = 1; - /* Check that it's not the one we recorded. */ - if ( dirty_vram->sl1ma[i] == sl1ma ) - { - /* Too bad, we remembered the wrong one... */ - dirty_vram->sl1ma[i] = INVALID_PADDR; - } - else - { - /* Ok, our recorded sl1e is still pointing to this page, let's - * just hope it will remain. */ - } + SHADOW_PRINTK("gfn %lx (mfn %lx) cleared vram pte\n", + old_gfn, mfn_x(old_mfn)); } - if ( dirty ) + + if ( VALID_M2P(new_gfn) ) + if ( dirty_vram_range_update(d, new_gfn, sl1ma, 1/*set*/) ) { - dirty_vram->dirty_bitmap[i / 8] |= 1 << (i % 8); - dirty_vram->last_dirty = NOW(); + SHADOW_PRINTK("gfn %lx (mfn %lx) set vram pte\n", + new_gfn, mfn_x(new_mfn)); } - } } static int shadow_set_l1e(struct vcpu *v, @@ -1211,12 +1167,13 @@ static int shadow_set_l1e(struct vcpu *v, shadow_l1e_remove_flags(new_sl1e, _PAGE_RW); /* fall through */ case 0: - shadow_vram_get_l1e(new_sl1e, sl1e, sl1mfn, d); break; } } } + shadow_vram_fix_l1e(old_sl1e, new_sl1e, sl1e, sl1mfn, d); + /* Write the new entry */ shadow_write_entries(sl1e, &new_sl1e, 1, sl1mfn); flags |= SHADOW_SET_CHANGED; @@ -1231,7 +1188,6 @@ static int shadow_set_l1e(struct vcpu *v, * trigger a flush later. */ if ( shadow_mode_refcounts(d) ) { - shadow_vram_put_l1e(old_sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(old_sl1e, d); TRACE_SHADOW_PATH_FLAG(TRCE_SFLAG_SHADOW_L1_PUT_REF); } @@ -2018,7 +1974,6 @@ void sh_destroy_l1_shadow(struct vcpu *v, mfn_t smfn) SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, 0, { if ( (shadow_l1e_get_flags(*sl1e) & _PAGE_PRESENT) && !sh_l1e_is_magic(*sl1e) ) { - shadow_vram_put_l1e(*sl1e, sl1e, sl1mfn, d); shadow_put_page_from_l1e(*sl1e, d); } }); @@ -4336,6 +4291,37 @@ int sh_rm_mappings_from_l1(struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn) return done; } + +int sh_find_vram_mappings_in_l1(struct vcpu *v, + mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed) +/* Find all VRAM mappings in this shadow l1 table */ +{ + struct domain *d = v->domain; + shadow_l1e_t *sl1e; + int done = 0; + + /* only returns _PAGE_PRESENT entries */ + SHADOW_FOREACH_L1E(sl1mfn, sl1e, 0, done, + { + unsigned long gfn; + mfn_t gmfn = shadow_l1e_get_mfn(*sl1e); + if ( !mfn_valid(gmfn) ) + continue; + gfn = mfn_to_gfn(d, gmfn); + if ( VALID_M2P(gfn) && (begin_pfn <= gfn) && (gfn < end_pfn) ) + { + paddr_t sl1ma = + pfn_to_paddr(mfn_x(sl1mfn)) | + ( (unsigned long)sl1e & ~PAGE_MASK ); + dirty_vram_range_update(v->domain, gfn, sl1ma, 1/*set*/); + } + }); + return 0; +} + /**************************************************************************/ /* Functions to excise all pointers to shadows from higher-level shadows. */ diff --git a/xen/arch/x86/mm/shadow/multi.h b/xen/arch/x86/mm/shadow/multi.h index 835121e..436a4ac 100644 --- a/xen/arch/x86/mm/shadow/multi.h +++ b/xen/arch/x86/mm/shadow/multi.h @@ -66,7 +66,12 @@ SHADOW_INTERNAL_NAME(sh_rm_write_access_from_l1, GUEST_LEVELS) extern int SHADOW_INTERNAL_NAME(sh_rm_mappings_from_l1, GUEST_LEVELS) (struct vcpu *v, mfn_t sl1mfn, mfn_t target_mfn); - +extern int +SHADOW_INTERNAL_NAME(sh_find_vram_mappings_in_l1, GUEST_LEVELS) + (struct vcpu *v, mfn_t sl1mfn, + unsigned long begin_pfn, + unsigned long end_pfn, + int *removed); extern void SHADOW_INTERNAL_NAME(sh_clear_shadow_entry, GUEST_LEVELS) (struct vcpu *v, void *ep, mfn_t smfn); diff --git a/xen/arch/x86/mm/shadow/types.h b/xen/arch/x86/mm/shadow/types.h index 43ce1db..5b0f9f7 100644 --- a/xen/arch/x86/mm/shadow/types.h +++ b/xen/arch/x86/mm/shadow/types.h @@ -229,6 +229,7 @@ static inline shadow_l4e_t shadow_l4e_from_mfn(mfn_t mfn, u32 flags) #define sh_update_cr3 INTERNAL_NAME(sh_update_cr3) #define sh_rm_write_access_from_l1 INTERNAL_NAME(sh_rm_write_access_from_l1) #define sh_rm_mappings_from_l1 INTERNAL_NAME(sh_rm_mappings_from_l1) +#define sh_find_vram_mappings_in_l1 INTERNAL_NAME(sh_find_vram_mappings_in_l1) #define sh_remove_l1_shadow INTERNAL_NAME(sh_remove_l1_shadow) #define sh_remove_l2_shadow INTERNAL_NAME(sh_remove_l2_shadow) #define sh_remove_l3_shadow INTERNAL_NAME(sh_remove_l3_shadow) diff --git a/xen/include/asm-x86/dirty_vram.h b/xen/include/asm-x86/dirty_vram.h new file mode 100644 index 0000000..b107d0e --- /dev/null +++ b/xen/include/asm-x86/dirty_vram.h @@ -0,0 +1,202 @@ +/**************************************************************************** + * include/asm-x86/dirty_vram.h + * + * Interface for tracking dirty VRAM pages + * + * Copyright (c) 2012 Citrix Systems, Inc. (Robert Phillips) + * Parts of this code are Copyright (c) 2007 Advanced Micro Devices (Wei Huang) + * Parts of this code are Copyright (c) 2006 by XenSource Inc. + * Parts of this code are Copyright (c) 2006 by Michael A Fetterman + * Parts based on earlier work by Michael A Fetterman, Ian Pratt et al. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _DIRTY_VRAM_H +#define _DIRTY_VRAM_H + +/* + * In shadow mode we need to bookkeep all the L1 page table entries that + * map a frame buffer page. Struct dv_paddr_link does this by + * recording the address of a L1 page table entry for some frame buffer page. + * Also has a link to additional pl entries if the frame buffer page + * has multiple mappings. + * In practice very few pages have multiple mappings. + * But to rule out some pathological situation, we limit the number of + * mappings we're willing to bookkeep. + */ + +#define DV_ADDR_LINK_LIST_LIMIT 20 + +typedef struct dv_paddr_link { + paddr_t sl1ma; + struct dv_paddr_link *pl_next; +} dv_paddr_link_t; + +typedef struct dv_pl_entry { + dv_paddr_link_t mapping; + bool_t stuck_dirty; +} dv_pl_entry_t; + +/* + * This defines an extension page of pl entries for FB pages with multiple + * mappings. All such pages (of a domain) are linked together. + */ +typedef struct dv_paddr_link_ext { + struct list_head ext_link; + dv_paddr_link_t entries[ ( PAGE_SIZE - sizeof( struct list_head ) ) / + sizeof( dv_paddr_link_t ) ]; +} dv_paddr_link_ext_t; + +/* + * This defines a single frame buffer range. It bookkeeps all the + * level 1 PTEs that map guest pages within that range. + * All such ranges (of a domain) are linked together. + */ +typedef struct dv_range { + struct list_head range_link; /* the several ranges form a linked list */ + unsigned long begin_pfn; + unsigned long end_pfn; + dv_pl_entry_t *pl_tab; /* table has 1 pl entry per pfn in range */ + int nr_mappings; /* total number of mappings in this range */ + int mappings_hwm; /* high water mark of max mapping count */ + unsigned int dirty_count; +} dv_range_t; + +/* + * This contains all the data structures required by a domain to + * bookkeep the dirty pages within its frame buffers. + */ +typedef struct dv_dirty_vram { + struct list_head range_head; /* head of the linked list of ranges */ + struct list_head ext_head; /* head of list of extension pages */ + dv_paddr_link_t *pl_free; /* free list of pl's within extension pages */ + int nr_ranges; /* bookkeeps number of ranges */ + int ranges_hwm; /* high water mark of max number of ranges */ +} dv_dirty_vram_t; + +/* Allocates domain's dirty_vram structure */ +dv_dirty_vram_t * +dirty_vram_alloc(struct domain *d); + +/* + * Returns domain's dirty_vram structure, + * allocating it if necessary + */ +dv_dirty_vram_t * +dirty_vram_find_or_alloc(struct domain *d); + +/* Frees domain's dirty_vram structure */ +void dirty_vram_free(struct domain *d); + +/* Returns dirty vram range containing gfn, NULL if none */ +struct dv_range * +dirty_vram_range_find_gfn(struct domain *d, + unsigned long gfn); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * NULL if none + */ +dv_range_t * +dirty_vram_range_find(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Allocate dirty vram range containing [ begin_pfn .. begin_pfn+nr ), + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +/* + * Returns dirty vram range matching [ begin_pfn .. begin_pfn+nr ), + * creating a range if none already exists and + * freeing any existing range that overlaps the new range. + */ +dv_range_t * +dirty_vram_range_find_or_alloc(struct domain *d, + unsigned long begin_pfn, + unsigned long nr); + +void dirty_vram_range_free(struct domain *d, + dv_range_t *range); + +/* Bookkeep PTE address of a frame buffer page */ +int dirty_vram_range_update(struct domain *d, + unsigned long gfn, + paddr_t sl1ma, + int set); + +/* + * smfn is no longer a shadow page. Remove it from any + * dirty vram range mapping. + */ +void +dirty_vram_delete_shadow(struct vcpu *v, + unsigned long gfn, + unsigned int shadow_type, + mfn_t smfn); + + +/* + * Scan all the L1 tables looking for VRAM mappings. + * Record them in the domain's dv_dirty_vram structure + */ +void sh_find_all_vram_mappings(struct vcpu *v, + dv_range_t *range); + +/* + * Free a paddr_link struct, given address of its + * predecessor in singly-linked list + */ +dv_paddr_link_t * +free_paddr_link(struct domain *d, + dv_paddr_link_t **ppl, + dv_paddr_link_t *pl); + + +/* Enable VRAM dirty tracking. */ +int +shadow_track_dirty_vram(struct domain *d, + unsigned long first_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +int +hap_track_dirty_vram(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); + +void +hap_clean_vram_tracking_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); + +#endif /* _DIRTY_VRAM_H */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/xen/include/asm-x86/hap.h b/xen/include/asm-x86/hap.h index 916a35b..3e3a1f5 100644 --- a/xen/include/asm-x86/hap.h +++ b/xen/include/asm-x86/hap.h @@ -57,10 +57,6 @@ void hap_final_teardown(struct domain *d); void hap_teardown(struct domain *d); void hap_vcpu_init(struct vcpu *v); void hap_logdirty_init(struct domain *d); -int hap_track_dirty_vram(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); extern const struct paging_mode *hap_paging_get_mode(struct vcpu *); diff --git a/xen/include/asm-x86/hvm/domain.h b/xen/include/asm-x86/hvm/domain.h index 27b3de5..6146542 100644 --- a/xen/include/asm-x86/hvm/domain.h +++ b/xen/include/asm-x86/hvm/domain.h @@ -74,7 +74,7 @@ struct hvm_domain { struct list_head pinned_cacheattr_ranges; /* VRAM dirty support. */ - struct sh_dirty_vram *dirty_vram; + struct dv_dirty_vram * dirty_vram; /* If one of vcpus of this domain is in no_fill_mode or * mtrr/pat between vcpus is not the same, set is_in_uc_mode diff --git a/xen/include/asm-x86/paging.h b/xen/include/asm-x86/paging.h index 9a40f2c..e7d4cb3 100644 --- a/xen/include/asm-x86/paging.h +++ b/xen/include/asm-x86/paging.h @@ -137,10 +137,10 @@ struct paging_mode { void paging_free_log_dirty_bitmap(struct domain *d); /* get the dirty bitmap for a specific range of pfns */ -int paging_log_dirty_range(struct domain *d, - unsigned long begin_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); +void paging_log_dirty_range(struct domain *d, + unsigned long begin_pfn, + unsigned long nr, + uint8_t *dirty_bitmap); /* enable log dirty */ int paging_log_dirty_enable(struct domain *d); @@ -154,9 +154,13 @@ void paging_log_dirty_init(struct domain *d, int (*disable_log_dirty)(struct domain *d), void (*clean_dirty_bitmap)(struct domain *d)); -/* mark a page as dirty */ +/* mark a page as dirty, a wrapper around mark a page as dirty */ void paging_mark_dirty(struct domain *d, unsigned long guest_mfn); +/* mark a page as dirty */ +void paging_mark_dirty_gpfn(struct domain *d, unsigned long gpfn); + + /* is this guest page dirty? * This is called from inside paging code, with the paging lock held. */ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn); @@ -183,15 +187,6 @@ int paging_mfn_is_dirty(struct domain *d, mfn_t gmfn); #define L4_LOGDIRTY_IDX(pfn) 0 #endif -/* VRAM dirty tracking support */ -struct sh_dirty_vram { - unsigned long begin_pfn; - unsigned long end_pfn; - paddr_t *sl1ma; - uint8_t *dirty_bitmap; - s_time_t last_dirty; -}; - /***************************************************************************** * Entry points into the paging-assistance code */ diff --git a/xen/include/asm-x86/shadow.h b/xen/include/asm-x86/shadow.h index 2eb6efc..940d7fd 100644 --- a/xen/include/asm-x86/shadow.h +++ b/xen/include/asm-x86/shadow.h @@ -62,12 +62,6 @@ void shadow_vcpu_init(struct vcpu *v); /* Enable an arbitrary shadow mode. Call once at domain creation. */ int shadow_enable(struct domain *d, u32 mode); -/* Enable VRAM dirty bit tracking. */ -int shadow_track_dirty_vram(struct domain *d, - unsigned long first_pfn, - unsigned long nr, - XEN_GUEST_HANDLE_64(uint8) dirty_bitmap); - /* Handler for shadow control ops: operations from user-space to enable * and disable ephemeral shadow modes (test mode and log-dirty mode) and * manipulate the log-dirty bitmap. */ -- 1.7.9.5 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Thu Nov 29 17:36:15 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 29 Nov 2012 17:36:15 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te81x-0007uH-Rc; Thu, 29 Nov 2012 17:36:09 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te81v-0007so-Gx for xen-devel@lists.xen.org; Thu, 29 Nov 2012 17:36:08 +0000 Received: from [85.158.138.51:40544] by server-2.bemta-3.messagelabs.com id 02/B9-04744-60D97B05; Thu, 29 Nov 2012 17:36:06 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-9.tower-174.messagelabs.com!1354210557!32037323!1 X-Originating-IP: [128.244.251.36] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, UNPARSEABLE_RELAY,UPPERCASE_25_50 X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 11050 invoked from network); 29 Nov 2012 17:35:59 -0000 Received: from pilot.jhuapl.edu (HELO jhuapl.edu) (128.244.251.36) by server-9.tower-174.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 29 Nov 2012 17:35:59 -0000 Received: from ([128.244.206.185]) by pilot.jhuapl.edu with ESMTP with TLS id 63GHCH1.158386742; Thu, 29 Nov 2012 12:35:48 -0500 From: Matthew Fioravante To: xen-devel@lists.xen.org, Ian.Jackson@eu.citrix.com, Ian.Campbell@citrix.com Date: Thu, 29 Nov 2012 12:35:29 -0500 Message-Id: <1354210534-31052-3-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [VTPM v5 2/7] add stubdom/vtpmmgr code 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 Add the code base for vtpmmgrdom. Makefile changes next patch. Signed-off-by: Matthew Fioravante Acked-by: Ian Campbell --- stubdom/vtpmmgr/Makefile | 32 ++ stubdom/vtpmmgr/init.c | 553 +++++++++++++++++++++ stubdom/vtpmmgr/log.c | 151 ++++++ stubdom/vtpmmgr/log.h | 85 ++++ stubdom/vtpmmgr/marshal.h | 528 ++++++++++++++++++++ stubdom/vtpmmgr/minios.cfg | 14 + stubdom/vtpmmgr/tcg.h | 707 +++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.c | 938 ++++++++++++++++++++++++++++++++++++ stubdom/vtpmmgr/tpm.h | 218 +++++++++ stubdom/vtpmmgr/tpmrsa.c | 175 +++++++ stubdom/vtpmmgr/tpmrsa.h | 67 +++ stubdom/vtpmmgr/uuid.h | 50 ++ stubdom/vtpmmgr/vtpm_cmd_handler.c | 152 ++++++ stubdom/vtpmmgr/vtpm_manager.h | 64 +++ stubdom/vtpmmgr/vtpm_storage.c | 794 ++++++++++++++++++++++++++++++ stubdom/vtpmmgr/vtpm_storage.h | 68 +++ stubdom/vtpmmgr/vtpmmgr.c | 93 ++++ stubdom/vtpmmgr/vtpmmgr.h | 77 +++ 18 files changed, 4766 insertions(+) create mode 100644 stubdom/vtpmmgr/Makefile create mode 100644 stubdom/vtpmmgr/init.c create mode 100644 stubdom/vtpmmgr/log.c create mode 100644 stubdom/vtpmmgr/log.h create mode 100644 stubdom/vtpmmgr/marshal.h create mode 100644 stubdom/vtpmmgr/minios.cfg create mode 100644 stubdom/vtpmmgr/tcg.h create mode 100644 stubdom/vtpmmgr/tpm.c create mode 100644 stubdom/vtpmmgr/tpm.h create mode 100644 stubdom/vtpmmgr/tpmrsa.c create mode 100644 stubdom/vtpmmgr/tpmrsa.h create mode 100644 stubdom/vtpmmgr/uuid.h create mode 100644 stubdom/vtpmmgr/vtpm_cmd_handler.c create mode 100644 stubdom/vtpmmgr/vtpm_manager.h create mode 100644 stubdom/vtpmmgr/vtpm_storage.c create mode 100644 stubdom/vtpmmgr/vtpm_storage.h create mode 100644 stubdom/vtpmmgr/vtpmmgr.c create mode 100644 stubdom/vtpmmgr/vtpmmgr.h diff --git a/stubdom/vtpmmgr/Makefile b/stubdom/vtpmmgr/Makefile new file mode 100644 index 0000000..88c83c3 --- /dev/null +++ b/stubdom/vtpmmgr/Makefile @@ -0,0 +1,32 @@ +# 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. +# + +XEN_ROOT=../.. + +PSSL_DIR=../polarssl-$(XEN_TARGET_ARCH)/library +PSSL_OBJS=aes.o sha1.o entropy.o ctr_drbg.o bignum.o sha4.o havege.o timing.o entropy_poll.o + +TARGET=vtpmmgr.a +OBJS=vtpmmgr.o vtpm_cmd_handler.o vtpm_storage.o init.o tpmrsa.o tpm.o log.o + +CFLAGS+=-Werror -Iutil -Icrypto -Itcs +CFLAGS+=-Wno-declaration-after-statement -Wno-unused-label + +build: $(TARGET) +$(TARGET): $(OBJS) + ar -rcs $@ $^ $(foreach obj,$(PSSL_OBJS),$(PSSL_DIR)/$(obj)) + +clean: + rm -f $(TARGET) $(OBJS) + +distclean: clean + +.PHONY: clean distclean diff --git a/stubdom/vtpmmgr/init.c b/stubdom/vtpmmgr/init.c new file mode 100644 index 0000000..a158020 --- /dev/null +++ b/stubdom/vtpmmgr/init.c @@ -0,0 +1,553 @@ +/* + * 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. +*/ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "log.h" +#include "vtpmmgr.h" +#include "vtpm_storage.h" +#include "tpm.h" +#include "marshal.h" + +struct Opts { + enum { + TPMDRV_TPM_TIS, + TPMDRV_TPMFRONT, + } tpmdriver; + unsigned long tpmiomem; + unsigned int tpmirq; + unsigned int tpmlocality; + int gen_owner_auth; +}; + +// --------------------------- Well Known Auths -------------------------- +const TPM_AUTHDATA WELLKNOWN_SRK_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 } +}; + +static int tpm_entropy_source(void* dummy, unsigned char* data, size_t len, size_t* olen) { + UINT32 sz = len; + TPM_RESULT rc = TPM_GetRandom(&sz, data); + *olen = sz; + return rc == TPM_SUCCESS ? 0 : POLARSSL_ERR_ENTROPY_SOURCE_FAILED; +} + +static TPM_RESULT check_tpm_version(void) { + TPM_RESULT status; + UINT32 rsize; + BYTE* res = NULL; + TPM_CAP_VERSION_INFO vinfo; + + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_VERSION_VAL, + 0, + NULL, + &rsize, + &res)); + if(rsize < 4) { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid size returned by GetCapability!\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + unpack_TPM_CAP_VERSION_INFO(res, &vinfo, UNPACK_ALIAS); + + vtpmloginfo(VTPM_LOG_VTPM, "Hardware TPM:\n"); + vtpmloginfo(VTPM_LOG_VTPM, " version: %hhd %hhd %hhd %hhd\n", + vinfo.version.major, vinfo.version.minor, vinfo.version.revMajor, vinfo.version.revMinor); + vtpmloginfo(VTPM_LOG_VTPM, " specLevel: %hd\n", vinfo.specLevel); + vtpmloginfo(VTPM_LOG_VTPM, " errataRev: %hhd\n", vinfo.errataRev); + vtpmloginfo(VTPM_LOG_VTPM, " vendorID: %c%c%c%c\n", + vinfo.tpmVendorID[0], vinfo.tpmVendorID[1], + vinfo.tpmVendorID[2], vinfo.tpmVendorID[3]); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecificSize: %hd\n", vinfo.vendorSpecificSize); + vtpmloginfo(VTPM_LOG_VTPM, " vendorSpecific: "); + for(int i = 0; i < vinfo.vendorSpecificSize; ++i) { + vtpmloginfomore(VTPM_LOG_VTPM, "%02hhx", vinfo.vendorSpecific[i]); + } + vtpmloginfomore(VTPM_LOG_VTPM, "\n"); + +abort_egress: + free(res); + return status; +} + +static TPM_RESULT flush_tpm(void) { + TPM_RESULT status = TPM_SUCCESS; + const TPM_RESOURCE_TYPE reslist[] = { TPM_RT_KEY, TPM_RT_AUTH, TPM_RT_TRANS, TPM_RT_COUNTER, TPM_RT_DAA_TPM, TPM_RT_CONTEXT }; + BYTE* keylist = NULL; + UINT32 keylistSize; + BYTE* ptr; + + //Iterate through each resource type and flush all handles + for(int i = 0; i < sizeof(reslist) / sizeof(TPM_RESOURCE_TYPE); ++i) { + TPM_RESOURCE_TYPE beres = cpu_to_be32(reslist[i]); + UINT16 size; + TPMTRYRETURN(TPM_GetCapability( + TPM_CAP_HANDLE, + sizeof(TPM_RESOURCE_TYPE), + (BYTE*)(&beres), + &keylistSize, + &keylist)); + + ptr = keylist; + ptr = unpack_UINT16(ptr, &size); + + //Flush each handle + if(size) { + vtpmloginfo(VTPM_LOG_VTPM, "Flushing %u handle(s) of type %lu\n", size, (unsigned long) reslist[i]); + for(int j = 0; j < size; ++j) { + TPM_HANDLE h; + ptr = unpack_TPM_HANDLE(ptr, &h); + TPMTRYRETURN(TPM_FlushSpecific(h, reslist[i])); + } + } + + free(keylist); + keylist = NULL; + } + + goto egress; +abort_egress: + free(keylist); +egress: + return status; +} + + +static TPM_RESULT try_take_ownership(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_PUBKEY pubEK = TPM_PUBKEY_INIT; + + // If we can read PubEK then there is no owner and we should take it. + status = TPM_ReadPubek(&pubEK); + + switch(status) { + case TPM_DISABLED_CMD: + //Cannot read ek? TPM has owner + vtpmloginfo(VTPM_LOG_VTPM, "Failed to readEK meaning TPM has an owner. Creating Keys off existing SRK.\n"); + status = TPM_SUCCESS; + break; + case TPM_NO_ENDORSEMENT: + { + //If theres no ek, we have to create one + TPM_KEY_PARMS keyInfo = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }; + TPMTRYRETURN(TPM_CreateEndorsementKeyPair(&keyInfo, &pubEK)); + } + //fall through to take ownership + case TPM_SUCCESS: + { + //Construct the Srk + TPM_KEY srk = { + .ver = TPM_STRUCT_VER_1_1, + .keyUsage = TPM_KEY_STORAGE, + .keyFlags = 0x00, + .authDataUsage = TPM_AUTH_ALWAYS, + .algorithmParms = { + .algorithmID = TPM_ALG_RSA, + .encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1, + .sigScheme = TPM_SS_NONE, + .parmSize = 12, + .parms.rsa = { + .keyLength = RSA_KEY_SIZE, + .numPrimes = 2, + .exponentSize = 0, + .exponent = NULL, + }, + }, + .PCRInfoSize = 0, + .pubKey = { + .keyLength = 0, + .key = NULL, + }, + .encDataSize = 0, + }; + + TPMTRYRETURN(TPM_TakeOwnership( + &pubEK, + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &srk, + NULL, + &vtpm_globals.oiap)); + + TPMTRYRETURN(TPM_DisablePubekRead( + (const TPM_AUTHDATA*)&vtpm_globals.owner_auth, + &vtpm_globals.oiap)); + } + break; + default: + break; + } +abort_egress: + free_TPM_PUBKEY(&pubEK); + 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) { + 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; + } + /* owner auth is a raw hash */ + else if(!strncmp(authstr, "hash:", 5)) { + authstr += 5; + if((rc = strlen(authstr)) != 40) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth hex string `%s' must be exactly 40 characters (20 bytes) long, length=%d\n", authstr, rc); + return -1; + } + for(int j = 0; j < 20; ++j) { + if(sscanf(authstr, "%hhX", target + j) != 1) { + vtpmlogerror(VTPM_LOG_VTPM, "Supplied owner auth string `%s' is not a valid hex string\n", authstr); + return -1; + } + authstr += 2; + } + } + /* owner auth is a string that will be hashed */ + else if(!strncmp(authstr, "text:", 5)) { + authstr += 5; + sha1((const unsigned char*)authstr, strlen(authstr), target); + } + else { + vtpmlogerror(VTPM_LOG_VTPM, "Invalid auth string %s\n", authstr); + return -1; + } + + return 0; +} + +int parse_cmdline_opts(int argc, char** argv, struct Opts* opts) +{ + int rc; + 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)); + + 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) { + goto err_invalid; + } + if(rc == 1) { + opts->gen_owner_auth = 1; + } + } + 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) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmdriver=", 10)) { + if(!strcmp(argv[i] + 10, "tpm_tis")) { + opts->tpmdriver = TPMDRV_TPM_TIS; + } else if(!strcmp(argv[i] + 10, "tpmfront")) { + opts->tpmdriver = TPMDRV_TPMFRONT; + } else { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmiomem=",9)) { + if(sscanf(argv[i] + 9, "0x%lX", &opts->tpmiomem) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmirq=",7)) { + if(!strcmp(argv[i] + 7, "probe")) { + opts->tpmirq = TPM_PROBE_IRQ; + } else if( sscanf(argv[i] + 7, "%u", &opts->tpmirq) != 1) { + goto err_invalid; + } + } + else if(!strncmp(argv[i], "tpmlocality=",12)) { + if(sscanf(argv[i] + 12, "%u", &opts->tpmlocality) != 1 || opts->tpmlocality > 4) { + goto err_invalid; + } + } + } + + switch(opts->tpmdriver) { + case TPMDRV_TPM_TIS: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpm_tis driver\n"); + break; + case TPMDRV_TPMFRONT: + vtpmloginfo(VTPM_LOG_VTPM, "Option: Using tpmfront driver\n"); + break; + } + + return 0; +err_invalid: + vtpmlogerror(VTPM_LOG_VTPM, "Invalid Option %s\n", argv[i]); + return -1; +} + + + +static TPM_RESULT vtpmmgr_create(void) { + TPM_RESULT status = TPM_SUCCESS; + TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT; + TPM_AUTHDATA sharedsecret; + + // Take ownership if TPM is unowned + 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, + (const TPM_AUTHDATA*)&vtpm_globals.srk_auth, + &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()); + + goto egress; +abort_egress: +egress: + vtpmloginfo(VTPM_LOG_VTPM, "Finished initialized new VTPM manager\n"); + + //End the OSAP session + if(osap.AuthHandle) { + TPM_TerminateHandle(osap.AuthHandle); + } + + return status; +} + +TPM_RESULT vtpmmgr_init(int argc, char** argv) { + TPM_RESULT status = TPM_SUCCESS; + + /* Default commandline options */ + struct Opts opts = { + .tpmdriver = TPMDRV_TPM_TIS, + .tpmiomem = TPM_BASEADDR, + .tpmirq = 0, + .tpmlocality = 0, + .gen_owner_auth = 0, + }; + + if(parse_cmdline_opts(argc, argv, &opts) != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Command line parsing failed! exiting..\n"); + status = TPM_BAD_PARAMETER; + goto abort_egress; + } + + //Setup storage system + if(vtpm_storage_init() != 0) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize storage subsystem!\n"); + status = TPM_IOERROR; + goto abort_egress; + } + + //Setup tpmback device + init_tpmback(); + + //Setup tpm access + switch(opts.tpmdriver) { + case TPMDRV_TPM_TIS: + { + struct tpm_chip* tpm; + if((tpm = init_tpm_tis(opts.tpmiomem, TPM_TIS_LOCL_INT_TO_FLAG(opts.tpmlocality), opts.tpmirq)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpm_tis_open(tpm); + tpm_tis_request_locality(tpm, opts.tpmlocality); + } + break; + case TPMDRV_TPMFRONT: + { + struct tpmfront_dev* tpmfront_dev; + if((tpmfront_dev = init_tpmfront(NULL)) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize tpmfront device\n"); + status = TPM_IOERROR; + goto abort_egress; + } + vtpm_globals.tpm_fd = tpmfront_open(tpmfront_dev); + } + break; + } + + //Get the version of the tpm + TPMTRYRETURN(check_tpm_version()); + + // Blow away all stale handles left in the tpm + if(flush_tpm() != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "VTPM_FlushResources failed, continuing anyway..\n"); + } + + /* Initialize the rng */ + entropy_init(&vtpm_globals.entropy); + entropy_add_source(&vtpm_globals.entropy, tpm_entropy_source, NULL, 0); + entropy_gather(&vtpm_globals.entropy); + ctr_drbg_init(&vtpm_globals.ctr_drbg, entropy_func, &vtpm_globals.entropy, NULL, 0); + ctr_drbg_set_prediction_resistance( &vtpm_globals.ctr_drbg, CTR_DRBG_PR_OFF ); + + // Generate Auth for Owner + if(opts.gen_owner_auth) { + vtpmmgr_rand(vtpm_globals.owner_auth, sizeof(TPM_AUTHDATA)); + } + + // Create OIAP session for service's authorized commands + TPMTRYRETURN( TPM_OIAP(&vtpm_globals.oiap) ); + + /* Load the Manager data, if it fails create a new manager */ + if (vtpm_storage_load_header() != TPM_SUCCESS) { + /* 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) ); + } + vtpmloginfo(VTPM_LOG_VTPM, "Failed to read manager file. Assuming first time initialization.\n"); + TPMTRYRETURN( vtpmmgr_create() ); + } + + goto egress; +abort_egress: + vtpmmgr_shutdown(); +egress: + return status; +} + +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); + + vtpmloginfo(VTPM_LOG_VTPM, "VTPM Manager stopped.\n"); +} diff --git a/stubdom/vtpmmgr/log.c b/stubdom/vtpmmgr/log.c new file mode 100644 index 0000000..a82c913 --- /dev/null +++ b/stubdom/vtpmmgr/log.c @@ -0,0 +1,151 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "tcg.h" + +char *module_names[] = { "", + "TPM", + "TPM", + "VTPM", + "VTPM", + "TXDATA", + }; +// Helper code for the consts, eg. to produce messages for error codes. + +typedef struct error_code_entry_t { + TPM_RESULT code; + char * code_name; + char * msg; +} error_code_entry_t; + +static const error_code_entry_t error_msgs [] = { + { TPM_SUCCESS, "TPM_SUCCESS", "Successful completion of the operation" }, + { TPM_AUTHFAIL, "TPM_AUTHFAIL", "Authentication failed" }, + { TPM_BADINDEX, "TPM_BADINDEX", "The index to a PCR, DIR or other register is incorrect" }, + { TPM_BAD_PARAMETER, "TPM_BAD_PARAMETER", "One or more parameter is bad" }, + { TPM_AUDITFAILURE, "TPM_AUDITFAILURE", "An operation completed successfully but the auditing of that operation failed." }, + { TPM_CLEAR_DISABLED, "TPM_CLEAR_DISABLED", "The clear disable flag is set and all clear operations now require physical access" }, + { TPM_DEACTIVATED, "TPM_DEACTIVATED", "The TPM is deactivated" }, + { TPM_DISABLED, "TPM_DISABLED", "The TPM is disabled" }, + { TPM_DISABLED_CMD, "TPM_DISABLED_CMD", "The target command has been disabled" }, + { TPM_FAIL, "TPM_FAIL", "The operation failed" }, + { TPM_BAD_ORDINAL, "TPM_BAD_ORDINAL", "The ordinal was unknown or inconsistent" }, + { TPM_INSTALL_DISABLED, "TPM_INSTALL_DISABLED", "The ability to install an owner is disabled" }, + { TPM_INVALID_KEYHANDLE, "TPM_INVALID_KEYHANDLE", "The key handle presented was invalid" }, + { TPM_KEYNOTFOUND, "TPM_KEYNOTFOUND", "The target key was not found" }, + { TPM_INAPPROPRIATE_ENC, "TPM_INAPPROPRIATE_ENC", "Unacceptable encryption scheme" }, + { TPM_MIGRATEFAIL, "TPM_MIGRATEFAIL", "Migration authorization failed" }, + { TPM_INVALID_PCR_INFO, "TPM_INVALID_PCR_INFO", "PCR information could not be interpreted" }, + { TPM_NOSPACE, "TPM_NOSPACE", "No room to load key." }, + { TPM_NOSRK, "TPM_NOSRK", "There is no SRK set" }, + { TPM_NOTSEALED_BLOB, "TPM_NOTSEALED_BLOB", "An encrypted blob is invalid or was not created by this TPM" }, + { TPM_OWNER_SET, "TPM_OWNER_SET", "There is already an Owner" }, + { TPM_RESOURCES, "TPM_RESOURCES", "The TPM has insufficient internal resources to perform the requested action." }, + { TPM_SHORTRANDOM, "TPM_SHORTRANDOM", "A random string was too short" }, + { TPM_SIZE, "TPM_SIZE", "The TPM does not have the space to perform the operation." }, + { TPM_WRONGPCRVAL, "TPM_WRONGPCRVAL", "The named PCR value does not match the current PCR value." }, + { TPM_BAD_PARAM_SIZE, "TPM_BAD_PARAM_SIZE", "The paramSize argument to the command has the incorrect value" }, + { TPM_SHA_THREAD, "TPM_SHA_THREAD", "There is no existing SHA-1 thread." }, + { TPM_SHA_ERROR, "TPM_SHA_ERROR", "The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error." }, + { TPM_FAILEDSELFTEST, "TPM_FAILEDSELFTEST", "Self-test has failed and the TPM has shutdown." }, + { TPM_AUTH2FAIL, "TPM_AUTH2FAIL", "The authorization for the second key in a 2 key function failed authorization" }, + { TPM_BADTAG, "TPM_BADTAG", "The tag value sent to for a command is invalid" }, + { TPM_IOERROR, "TPM_IOERROR", "An IO error occurred transmitting information to the TPM" }, + { TPM_ENCRYPT_ERROR, "TPM_ENCRYPT_ERROR", "The encryption process had a problem." }, + { TPM_DECRYPT_ERROR, "TPM_DECRYPT_ERROR", "The decryption process did not complete." }, + { TPM_INVALID_AUTHHANDLE, "TPM_INVALID_AUTHHANDLE", "An invalid handle was used." }, + { TPM_NO_ENDORSEMENT, "TPM_NO_ENDORSEMENT", "The TPM does not a EK installed" }, + { TPM_INVALID_KEYUSAGE, "TPM_INVALID_KEYUSAGE", "The usage of a key is not allowed" }, + { TPM_WRONG_ENTITYTYPE, "TPM_WRONG_ENTITYTYPE", "The submitted entity type is not allowed" }, + { TPM_INVALID_POSTINIT, "TPM_INVALID_POSTINIT", "The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup" }, + { TPM_INAPPROPRIATE_SIG, "TPM_INAPPROPRIATE_SIG", "Signed data cannot include additional DER information" }, + { TPM_BAD_KEY_PROPERTY, "TPM_BAD_KEY_PROPERTY", "The key properties in TPM_KEY_PARMs are not supported by this TPM" }, + + { TPM_BAD_MIGRATION, "TPM_BAD_MIGRATION", "The migration properties of this key are incorrect." }, + { TPM_BAD_SCHEME, "TPM_BAD_SCHEME", "The signature or encryption scheme for this key is incorrect or not permitted in this situation." }, + { TPM_BAD_DATASIZE, "TPM_BAD_DATASIZE", "The size of the data (or blob) parameter is bad or inconsistent with the referenced key" }, + { TPM_BAD_MODE, "TPM_BAD_MODE", "A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob." }, + { TPM_BAD_PRESENCE, "TPM_BAD_PRESENCE", "Either the physicalPresence or physicalPresenceLock bits have the wrong value" }, + { TPM_BAD_VERSION, "TPM_BAD_VERSION", "The TPM cannot perform this version of the capability" }, + { TPM_NO_WRAP_TRANSPORT, "TPM_NO_WRAP_TRANSPORT", "The TPM does not allow for wrapped transport sessions" }, + { TPM_AUDITFAIL_UNSUCCESSFUL, "TPM_AUDITFAIL_UNSUCCESSFUL", "TPM audit construction failed and the underlying command was returning a failure code also" }, + { TPM_AUDITFAIL_SUCCESSFUL, "TPM_AUDITFAIL_SUCCESSFUL", "TPM audit construction failed and the underlying command was returning success" }, + { TPM_NOTRESETABLE, "TPM_NOTRESETABLE", "Attempt to reset a PCR register that does not have the resettable attribute" }, + { TPM_NOTLOCAL, "TPM_NOTLOCAL", "Attempt to reset a PCR register that requires locality and locality modifier not part of command transport" }, + { TPM_BAD_TYPE, "TPM_BAD_TYPE", "Make identity blob not properly typed" }, + { TPM_INVALID_RESOURCE, "TPM_INVALID_RESOURCE", "When saving context identified resource type does not match actual resource" }, + { TPM_NOTFIPS, "TPM_NOTFIPS", "The TPM is attempting to execute a command only available when in FIPS mode" }, + { TPM_INVALID_FAMILY, "TPM_INVALID_FAMILY", "The command is attempting to use an invalid family ID" }, + { TPM_NO_NV_PERMISSION, "TPM_NO_NV_PERMISSION", "The permission to manipulate the NV storage is not available" }, + { TPM_REQUIRES_SIGN, "TPM_REQUIRES_SIGN", "The operation requires a signed command" }, + { TPM_KEY_NOTSUPPORTED, "TPM_KEY_NOTSUPPORTED", "Wrong operation to load an NV key" }, + { TPM_AUTH_CONFLICT, "TPM_AUTH_CONFLICT", "NV_LoadKey blob requires both owner and blob authorization" }, + { TPM_AREA_LOCKED, "TPM_AREA_LOCKED", "The NV area is locked and not writtable" }, + { TPM_BAD_LOCALITY, "TPM_BAD_LOCALITY", "The locality is incorrect for the attempted operation" }, + { TPM_READ_ONLY, "TPM_READ_ONLY", "The NV area is read only and can't be written to" }, + { TPM_PER_NOWRITE, "TPM_PER_NOWRITE", "There is no protection on the write to the NV area" }, + { TPM_FAMILYCOUNT, "TPM_FAMILYCOUNT", "The family count value does not match" }, + { TPM_WRITE_LOCKED, "TPM_WRITE_LOCKED", "The NV area has already been written to" }, + { TPM_BAD_ATTRIBUTES, "TPM_BAD_ATTRIBUTES", "The NV area attributes conflict" }, + { TPM_INVALID_STRUCTURE, "TPM_INVALID_STRUCTURE", "The structure tag and version are invalid or inconsistent" }, + { TPM_KEY_OWNER_CONTROL, "TPM_KEY_OWNER_CONTROL", "The key is under control of the TPM Owner and can only be evicted by the TPM Owner." }, + { TPM_BAD_COUNTER, "TPM_BAD_COUNTER", "The counter handle is incorrect" }, + { TPM_NOT_FULLWRITE, "TPM_NOT_FULLWRITE", "The write is not a complete write of the area" }, + { TPM_CONTEXT_GAP, "TPM_CONTEXT_GAP", "The gap between saved context counts is too large" }, + { TPM_MAXNVWRITES, "TPM_MAXNVWRITES", "The maximum number of NV writes without an owner has been exceeded" }, + { TPM_NOOPERATOR, "TPM_NOOPERATOR", "No operator authorization value is set" }, + { TPM_RESOURCEMISSING, "TPM_RESOURCEMISSING", "The resource pointed to by context is not loaded" }, + { TPM_DELEGATE_LOCK, "TPM_DELEGATE_LOCK", "The delegate administration is locked" }, + { TPM_DELEGATE_FAMILY, "TPM_DELEGATE_FAMILY", "Attempt to manage a family other then the delegated family" }, + { TPM_DELEGATE_ADMIN, "TPM_DELEGATE_ADMIN", "Delegation table management not enabled" }, + { TPM_TRANSPORT_EXCLUSIVE, "TPM_TRANSPORT_EXCLUSIVE", "There was a command executed outside of an exclusive transport session" }, +}; + + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code) { + // just do a linear scan for now + unsigned i; + for (i = 0; i < sizeof(error_msgs)/sizeof(error_msgs[0]); i++) + if (code == error_msgs[i].code) + return error_msgs[i].code_name; + + return("Unknown Error Code"); +} diff --git a/stubdom/vtpmmgr/log.h b/stubdom/vtpmmgr/log.h new file mode 100644 index 0000000..5c7abf5 --- /dev/null +++ b/stubdom/vtpmmgr/log.h @@ -0,0 +1,85 @@ +/* + * 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_LOG_H__ +#define __VTPM_LOG_H__ + +#include // for uint32_t +#include // for pointer NULL +#include +#include "tcg.h" + +// =========================== LOGGING ============================== + +// the logging module numbers +#define VTPM_LOG_TPM 1 +#define VTPM_LOG_TPM_DEEP 2 +#define VTPM_LOG_VTPM 3 +#define VTPM_LOG_VTPM_DEEP 4 +#define VTPM_LOG_TXDATA 5 + +extern char *module_names[]; + +// Default to standard logging +#ifndef LOGGING_MODULES +#define LOGGING_MODULES (BITMASK(VTPM_LOG_VTPM)|BITMASK(VTPM_LOG_TPM)) +#endif + +// bit-access macros +#define BITMASK(idx) ( 1U << (idx) ) +#define GETBIT(num,idx) ( ((num) & BITMASK(idx)) >> idx ) +#define SETBIT(num,idx) (num) |= BITMASK(idx) +#define CLEARBIT(num,idx) (num) &= ( ~ BITMASK(idx) ) + +#define vtpmloginfo(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, "INFO[%s]: " fmt, module_names[module], ##args); \ + } + +#define vtpmloginfomore(module, fmt, args...) \ + if (GETBIT (LOGGING_MODULES, module) == 1) { \ + fprintf (stdout, fmt,##args); \ + } + +#define vtpmlogerror(module, fmt, args...) \ + fprintf (stderr, "ERROR[%s]: " fmt, module_names[module], ##args); + +//typedef UINT32 tpm_size_t; + +// helper function for the error codes: +const char* tpm_get_error_name (TPM_RESULT code); + +#endif // _VTPM_LOG_H_ diff --git a/stubdom/vtpmmgr/marshal.h b/stubdom/vtpmmgr/marshal.h new file mode 100644 index 0000000..77d32f0 --- /dev/null +++ b/stubdom/vtpmmgr/marshal.h @@ -0,0 +1,528 @@ +/* + * 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 MARSHAL_H +#define MARSHAL_H + +#include +#include +#include +#include "tcg.h" + +typedef enum UnpackPtr { + UNPACK_ALIAS, + UNPACK_ALLOC +} UnpackPtr; + +inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { + ptr[0] = t; + return ++ptr; +} + +inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { + t[0] = ptr[0]; + return ++ptr; +} + +#define pack_BOOL(p, t) pack_BYTE(p, t) +#define unpack_BOOL(p, t) unpack_BYTE(p, t) + +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* 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); +} + +#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) +#define pack_TPM_HANDLE(p, t) pack_UINT32(p, t) +#define pack_TPM_AUTHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HASHHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_HMACHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENCHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_KEY_HANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TCPA_ENTITYHANDLE(p, t) pack_TPM_HANDLE(p, t) +#define pack_TPM_RESOURCE_TYPE(p, t) pack_UINT32(p, t) +#define pack_TPM_COMMAND_CODE(p, t) pack_UINT32(p, t) +#define pack_TPM_PROTOCOL_ID(p, t) pack_UINT16(p, t) +#define pack_TPM_AUTH_DATA_USAGE(p, t) pack_BYTE(p, t) +#define pack_TPM_ENTITY_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_ALGORITHM_ID(p, t) pack_UINT32(p, t) +#define pack_TPM_KEY_USAGE(p, t) pack_UINT16(p, t) +#define pack_TPM_STARTUP_TYPE(p, t) pack_UINT16(p, t) +#define pack_TPM_CAPABILITY_AREA(p, t) pack_UINT32(p, t) +#define pack_TPM_ENC_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_SIG_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t) +#define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t) +#define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t) + +#define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_DIRINDEX(p, t) unpack_UINT32(p, t) +#define unpack_TPM_HANDLE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_AUTHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HASHHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_HMACHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENCHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_KEY_HANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TCPA_ENTITYHANDLE(p, t) unpack_TPM_HANDLE(p, t) +#define unpack_TPM_RESOURCE_TYPE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_COMMAND_CODE(p, t) unpack_UINT32(p, t) +#define unpack_TPM_PROTOCOL_ID(p, t) unpack_UINT16(p, t) +#define unpack_TPM_AUTH_DATA_USAGE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_ENTITY_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_ALGORITHM_ID(p, t) unpack_UINT32(p, t) +#define unpack_TPM_KEY_USAGE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STARTUP_TYPE(p, t) unpack_UINT16(p, t) +#define unpack_TPM_CAPABILITY_AREA(p, t) unpack_UINT32(p, t) +#define unpack_TPM_ENC_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_SIG_SCHEME(p, t) unpack_UINT16(p, t) +#define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, 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 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; +} + +inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { + memcpy(buf, ptr, size); + return ptr + size; +} + +inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 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; +} + +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); + } +} + +inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { + 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); +} + +#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) +#define pack_TPM_TAG(p, t) pack_UINT16(p, t) +#define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) + +#define unpack_TPM_SECRET(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) +#define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) +#define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) +#define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, 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; +} + +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; +} + +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; +} + +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; +} + +inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { + 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); +} + +#define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_PCRVALUE(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 pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d); +#define unpack_TPM_DIRVALUE(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); +} + +inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { + return unpack_BUFFER(ptr, 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); +} + +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 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); +} + +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 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; +} + +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; +} + +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 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); +} + +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 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; +} + +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; +} + +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; +} + +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 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; +} + +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 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); +} + +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); +} + +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); +} + +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; +} + +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; +} + +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; +} + +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; +} + +#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); + +#endif diff --git a/stubdom/vtpmmgr/minios.cfg b/stubdom/vtpmmgr/minios.cfg new file mode 100644 index 0000000..3fb383d --- /dev/null +++ b/stubdom/vtpmmgr/minios.cfg @@ -0,0 +1,14 @@ +CONFIG_TPMFRONT=y +CONFIG_TPM_TIS=y +CONFIG_TPMBACK=y +CONFIG_START_NETWORK=n +CONFIG_TEST=n +CONFIG_PCIFRONT=n +CONFIG_BLKFRONT=y +CONFIG_NETFRONT=n +CONFIG_FBFRONT=n +CONFIG_KBDFRONT=n +CONFIG_CONSFRONT=n +CONFIG_XENBUS=y +CONFIG_LWIP=n +CONFIG_XC=n diff --git a/stubdom/vtpmmgr/tcg.h b/stubdom/vtpmmgr/tcg.h new file mode 100644 index 0000000..7687eae --- /dev/null +++ b/stubdom/vtpmmgr/tcg.h @@ -0,0 +1,707 @@ +/* + * 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 __TCG_H__ +#define __TCG_H__ + +#include +#include + +// **************************** CONSTANTS ********************************* + +// BOOL values +#define TRUE 0x01 +#define FALSE 0x00 + +#define TCPA_MAX_BUFFER_LENGTH 0x2000 + +// +// TPM_COMMAND_CODE values +#define TPM_PROTECTED_ORDINAL 0x00000000UL +#define TPM_UNPROTECTED_ORDINAL 0x80000000UL +#define TPM_CONNECTION_ORDINAL 0x40000000UL +#define TPM_VENDOR_ORDINAL 0x20000000UL + +#define TPM_ORD_OIAP (10UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OSAP (11UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuth (12UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TakeOwnership (13UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymStart (14UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthAsymFinish (15UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ChangeAuthOwner (16UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Extend (20UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PcrRead (21UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Quote (22UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Seal (23UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Unseal (24UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirWriteAuth (25UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DirRead (26UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_UnBind (30UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateWrapKey (31UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKey (32UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetPubKey (33UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EvictKey (34UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMigrationBlob (40UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReWrapKey (41UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ConvertMigrationBlob (42UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_AuthorizeMigrationKey (43UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateMaintenanceArchive (44UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadMaintenanceArchive (45UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_KillMaintenanceFeature (46UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadManuMaintPub (47UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadManuMaintPub (48UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifyKey (50UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Sign (60UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetRandom (70UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_StirRandom (71UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestFull (80UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SelfTestStartup (81UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CertifySelfTest (82UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ContinueSelfTest (83UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTestResult (84UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Reset (90UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerClear (91UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableOwnerClear (92UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ForceClear (93UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisableForceClear (94UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilitySigned (100UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapability (101UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetCapabilityOwner (102UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerSetDisable (110UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalEnable (111UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalDisable (112UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOwnerInstall (113UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PhysicalSetDeactivated (114UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetTempDeactivated (115UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateEndorsementKeyPair (120UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MakeIdentity (121UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ActivateIdentity (122UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadPubek (124UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_OwnerReadPubek (125UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_DisablePubekRead (126UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEvent (130UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetAuditEventSigned (131UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetOrdinalAuditStatus (140UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetOrdinalAuditStatus (141UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Terminate_Handle (150UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Init (151UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveState (152UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Startup (153UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SetRedirection (154UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Start (160UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Update (161UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1Complete (162UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SHA1CompleteExtend (163UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FieldUpgrade (170UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveKeyContext (180UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadKeyContext (181UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveAuthContext (182UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadAuthContext (183UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_SaveContext (184UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_LoadContext (185UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_FlushSpecific (186UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_PCR_Reset (200UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_DefineSpace (204UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValue (205UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_WriteValueAuth (206UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValue (207UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_NV_ReadValueAuth (208UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_UpdateVerification (209UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_Manage (210UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateKeyDelegation (212UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_CreateOwnerDelegation (213UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_VerifyDelegation (214UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_LoadOwnerDelegation (216UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadAuth (217UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_Delegate_ReadTable (219UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_CreateCounter (220UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_IncrementCounter (221UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReadCounter (222UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounter (223UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseCounterOwner (224UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_EstablishTransport (230UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ExecuteTransport (231UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_ReleaseTransportSigned (232UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_GetTicks (241UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_TickStampBlob (242UL + TPM_PROTECTED_ORDINAL) +#define TPM_ORD_MAX (256UL + TPM_PROTECTED_ORDINAL) + +#define TSC_ORD_PhysicalPresence (10UL + TPM_CONNECTION_ORDINAL) + + + +// +// TPM_RESULT values +// +// just put in the whole table from spec 1.2 + +#define TPM_BASE 0x0 // The start of TPM return codes +#define TPM_VENDOR_ERROR 0x00000400 // Mask to indicate that the error code is vendor specific for vendor specific commands +#define TPM_NON_FATAL 0x00000800 // Mask to indicate that the error code is a non-fatal failure. + +#define TPM_SUCCESS TPM_BASE // Successful completion of the operation +#define TPM_AUTHFAIL TPM_BASE + 1 // Authentication failed +#define TPM_BADINDEX TPM_BASE + 2 // The index to a PCR, DIR or other register is incorrect +#define TPM_BAD_PARAMETER TPM_BASE + 3 // One or more parameter is bad +#define TPM_AUDITFAILURE TPM_BASE + 4 // An operation completed successfully but the auditing of that operation failed. +#define TPM_CLEAR_DISABLED TPM_BASE + 5 // The clear disable flag is set and all clear operations now require physical access +#define TPM_DEACTIVATED TPM_BASE + 6 // The TPM is deactivated +#define TPM_DISABLED TPM_BASE + 7 // The TPM is disabled +#define TPM_DISABLED_CMD TPM_BASE + 8 // The target command has been disabled +#define TPM_FAIL TPM_BASE + 9 // The operation failed +#define TPM_BAD_ORDINAL TPM_BASE + 10 // The ordinal was unknown or inconsistent +#define TPM_INSTALL_DISABLED TPM_BASE + 11 // The ability to install an owner is disabled +#define TPM_INVALID_KEYHANDLE TPM_BASE + 12 // The key handle presented was invalid +#define TPM_KEYNOTFOUND TPM_BASE + 13 // The target key was not found +#define TPM_INAPPROPRIATE_ENC TPM_BASE + 14 // Unacceptable encryption scheme +#define TPM_MIGRATEFAIL TPM_BASE + 15 // Migration authorization failed +#define TPM_INVALID_PCR_INFO TPM_BASE + 16 // PCR information could not be interpreted +#define TPM_NOSPACE TPM_BASE + 17 // No room to load key. +#define TPM_NOSRK TPM_BASE + 18 // There is no SRK set +#define TPM_NOTSEALED_BLOB TPM_BASE + 19 // An encrypted blob is invalid or was not created by this TPM +#define TPM_OWNER_SET TPM_BASE + 20 // There is already an Owner +#define TPM_RESOURCES TPM_BASE + 21 // The TPM has insufficient internal resources to perform the requested action. +#define TPM_SHORTRANDOM TPM_BASE + 22 // A random string was too short +#define TPM_SIZE TPM_BASE + 23 // The TPM does not have the space to perform the operation. +#define TPM_WRONGPCRVAL TPM_BASE + 24 // The named PCR value does not match the current PCR value. +#define TPM_BAD_PARAM_SIZE TPM_BASE + 25 // The paramSize argument to the command has the incorrect value +#define TPM_SHA_THREAD TPM_BASE + 26 // There is no existing SHA-1 thread. +#define TPM_SHA_ERROR TPM_BASE + 27 // The calculation is unable to proceed because the existing SHA-1 thread has already encountered an error. +#define TPM_FAILEDSELFTEST TPM_BASE + 28 // Self-test has failed and the TPM has shutdown. +#define TPM_AUTH2FAIL TPM_BASE + 29 // The authorization for the second key in a 2 key function failed authorization +#define TPM_BADTAG TPM_BASE + 30 // The tag value sent to for a command is invalid +#define TPM_IOERROR TPM_BASE + 31 // An IO error occurred transmitting information to the TPM +#define TPM_ENCRYPT_ERROR TPM_BASE + 32 // The encryption process had a problem. +#define TPM_DECRYPT_ERROR TPM_BASE + 33 // The decryption process did not complete. +#define TPM_INVALID_AUTHHANDLE TPM_BASE + 34 // An invalid handle was used. +#define TPM_NO_ENDORSEMENT TPM_BASE + 35 // The TPM does not a EK installed +#define TPM_INVALID_KEYUSAGE TPM_BASE + 36 // The usage of a key is not allowed +#define TPM_WRONG_ENTITYTYPE TPM_BASE + 37 // The submitted entity type is not allowed +#define TPM_INVALID_POSTINIT TPM_BASE + 38 // The command was received in the wrong sequence relative to TPM_Init and a subsequent TPM_Startup +#define TPM_INAPPROPRIATE_SIG TPM_BASE + 39 // Signed data cannot include additional DER information +#define TPM_BAD_KEY_PROPERTY TPM_BASE + 40 // The key properties in TPM_KEY_PARMs are not supported by this TPM + +#define TPM_BAD_MIGRATION TPM_BASE + 41 // The migration properties of this key are incorrect. +#define TPM_BAD_SCHEME TPM_BASE + 42 // The signature or encryption scheme for this key is incorrect or not permitted in this situation. +#define TPM_BAD_DATASIZE TPM_BASE + 43 // The size of the data (or blob) parameter is bad or inconsistent with the referenced key +#define TPM_BAD_MODE TPM_BASE + 44 // A mode parameter is bad, such as capArea or subCapArea for TPM_GetCapability, phsicalPresence parameter for TPM_PhysicalPresence, or migrationType for TPM_CreateMigrationBlob. +#define TPM_BAD_PRESENCE TPM_BASE + 45 // Either the physicalPresence or physicalPresenceLock bits have the wrong value +#define TPM_BAD_VERSION TPM_BASE + 46 // The TPM cannot perform this version of the capability +#define TPM_NO_WRAP_TRANSPORT TPM_BASE + 47 // The TPM does not allow for wrapped transport sessions +#define TPM_AUDITFAIL_UNSUCCESSFUL TPM_BASE + 48 // TPM audit construction failed and the underlying command was returning a failure code also +#define TPM_AUDITFAIL_SUCCESSFUL TPM_BASE + 49 // TPM audit construction failed and the underlying command was returning success +#define TPM_NOTRESETABLE TPM_BASE + 50 // Attempt to reset a PCR register that does not have the resettable attribute +#define TPM_NOTLOCAL TPM_BASE + 51 // Attempt to reset a PCR register that requires locality and locality modifier not part of command transport +#define TPM_BAD_TYPE TPM_BASE + 52 // Make identity blob not properly typed +#define TPM_INVALID_RESOURCE TPM_BASE + 53 // When saving context identified resource type does not match actual resource +#define TPM_NOTFIPS TPM_BASE + 54 // The TPM is attempting to execute a command only available when in FIPS mode +#define TPM_INVALID_FAMILY TPM_BASE + 55 // The command is attempting to use an invalid family ID +#define TPM_NO_NV_PERMISSION TPM_BASE + 56 // The permission to manipulate the NV storage is not available +#define TPM_REQUIRES_SIGN TPM_BASE + 57 // The operation requires a signed command +#define TPM_KEY_NOTSUPPORTED TPM_BASE + 58 // Wrong operation to load an NV key +#define TPM_AUTH_CONFLICT TPM_BASE + 59 // NV_LoadKey blob requires both owner and blob authorization +#define TPM_AREA_LOCKED TPM_BASE + 60 // The NV area is locked and not writtable +#define TPM_BAD_LOCALITY TPM_BASE + 61 // The locality is incorrect for the attempted operation +#define TPM_READ_ONLY TPM_BASE + 62 // The NV area is read only and can't be written to +#define TPM_PER_NOWRITE TPM_BASE + 63 // There is no protection on the write to the NV area +#define TPM_FAMILYCOUNT TPM_BASE + 64 // The family count value does not match +#define TPM_WRITE_LOCKED TPM_BASE + 65 // The NV area has already been written to +#define TPM_BAD_ATTRIBUTES TPM_BASE + 66 // The NV area attributes conflict +#define TPM_INVALID_STRUCTURE TPM_BASE + 67 // The structure tag and version are invalid or inconsistent +#define TPM_KEY_OWNER_CONTROL TPM_BASE + 68 // The key is under control of the TPM Owner and can only be evicted by the TPM Owner. +#define TPM_BAD_COUNTER TPM_BASE + 69 // The counter handle is incorrect +#define TPM_NOT_FULLWRITE TPM_BASE + 70 // The write is not a complete write of the area +#define TPM_CONTEXT_GAP TPM_BASE + 71 // The gap between saved context counts is too large +#define TPM_MAXNVWRITES TPM_BASE + 72 // The maximum number of NV writes without an owner has been exceeded +#define TPM_NOOPERATOR TPM_BASE + 73 // No operator authorization value is set +#define TPM_RESOURCEMISSING TPM_BASE + 74 // The resource pointed to by context is not loaded +#define TPM_DELEGATE_LOCK TPM_BASE + 75 // The delegate administration is locked +#define TPM_DELEGATE_FAMILY TPM_BASE + 76 // Attempt to manage a family other then the delegated family +#define TPM_DELEGATE_ADMIN TPM_BASE + 77 // Delegation table management not enabled +#define TPM_TRANSPORT_EXCLUSIVE TPM_BASE + 78 // There was a command executed outside of an exclusive transport session + +// TPM_STARTUP_TYPE values +#define TPM_ST_CLEAR 0x0001 +#define TPM_ST_STATE 0x0002 +#define TPM_ST_DEACTIVATED 0x003 + +// TPM_TAG values +#define TPM_TAG_RQU_COMMAND 0x00c1 +#define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2 +#define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3 +#define TPM_TAG_RSP_COMMAND 0x00c4 +#define TPM_TAG_RSP_AUTH1_COMMAND 0x00c5 +#define TPM_TAG_RSP_AUTH2_COMMAND 0x00c6 + +// TPM_PAYLOAD_TYPE values +#define TPM_PT_ASYM 0x01 +#define TPM_PT_BIND 0x02 +#define TPM_PT_MIGRATE 0x03 +#define TPM_PT_MAINT 0x04 +#define TPM_PT_SEAL 0x05 + +// TPM_ENTITY_TYPE values +#define TPM_ET_KEYHANDLE 0x0001 +#define TPM_ET_OWNER 0x0002 +#define TPM_ET_DATA 0x0003 +#define TPM_ET_SRK 0x0004 +#define TPM_ET_KEY 0x0005 + +/// TPM_ResourceTypes +#define TPM_RT_KEY 0x00000001 +#define TPM_RT_AUTH 0x00000002 +#define TPM_RT_HASH 0x00000003 +#define TPM_RT_TRANS 0x00000004 +#define TPM_RT_CONTEXT 0x00000005 +#define TPM_RT_COUNTER 0x00000006 +#define TPM_RT_DELEGATE 0x00000007 +#define TPM_RT_DAA_TPM 0x00000008 +#define TPM_RT_DAA_V0 0x00000009 +#define TPM_RT_DAA_V1 0x0000000A + + + +// TPM_PROTOCOL_ID values +#define TPM_PID_OIAP 0x0001 +#define TPM_PID_OSAP 0x0002 +#define TPM_PID_ADIP 0x0003 +#define TPM_PID_ADCP 0x0004 +#define TPM_PID_OWNER 0x0005 + +// TPM_ALGORITHM_ID values +#define TPM_ALG_RSA 0x00000001 +#define TPM_ALG_SHA 0x00000004 +#define TPM_ALG_HMAC 0x00000005 +#define TPM_ALG_AES128 0x00000006 +#define TPM_ALG_MFG1 0x00000007 +#define TPM_ALG_AES192 0x00000008 +#define TPM_ALG_AES256 0x00000009 +#define TPM_ALG_XOR 0x0000000A + +// TPM_ENC_SCHEME values +#define TPM_ES_NONE 0x0001 +#define TPM_ES_RSAESPKCSv15 0x0002 +#define TPM_ES_RSAESOAEP_SHA1_MGF1 0x0003 + +// TPM_SIG_SCHEME values +#define TPM_SS_NONE 0x0001 +#define TPM_SS_RSASSAPKCS1v15_SHA1 0x0002 +#define TPM_SS_RSASSAPKCS1v15_DER 0x0003 + +/* + * TPM_CAPABILITY_AREA Values for TPM_GetCapability ([TPM_Part2], Section 21.1) + */ +#define TPM_CAP_ORD 0x00000001 +#define TPM_CAP_ALG 0x00000002 +#define TPM_CAP_PID 0x00000003 +#define TPM_CAP_FLAG 0x00000004 +#define TPM_CAP_PROPERTY 0x00000005 +#define TPM_CAP_VERSION 0x00000006 +#define TPM_CAP_KEY_HANDLE 0x00000007 +#define TPM_CAP_CHECK_LOADED 0x00000008 +#define TPM_CAP_SYM_MODE 0x00000009 +#define TPM_CAP_KEY_STATUS 0x0000000C +#define TPM_CAP_NV_LIST 0x0000000D +#define TPM_CAP_MFR 0x00000010 +#define TPM_CAP_NV_INDEX 0x00000011 +#define TPM_CAP_TRANS_ALG 0x00000012 +#define TPM_CAP_HANDLE 0x00000014 +#define TPM_CAP_TRANS_ES 0x00000015 +#define TPM_CAP_AUTH_ENCRYPT 0x00000017 +#define TPM_CAP_SELECT_SIZE 0x00000018 +#define TPM_CAP_DA_LOGIC 0x00000019 +#define TPM_CAP_VERSION_VAL 0x0000001A + +/* subCap definitions ([TPM_Part2], Section 21.2) */ +#define TPM_CAP_PROP_PCR 0x00000101 +#define TPM_CAP_PROP_DIR 0x00000102 +#define TPM_CAP_PROP_MANUFACTURER 0x00000103 +#define TPM_CAP_PROP_KEYS 0x00000104 +#define TPM_CAP_PROP_MIN_COUNTER 0x00000107 +#define TPM_CAP_FLAG_PERMANENT 0x00000108 +#define TPM_CAP_FLAG_VOLATILE 0x00000109 +#define TPM_CAP_PROP_AUTHSESS 0x0000010A +#define TPM_CAP_PROP_TRANSESS 0x0000010B +#define TPM_CAP_PROP_COUNTERS 0x0000010C +#define TPM_CAP_PROP_MAX_AUTHSESS 0x0000010D +#define TPM_CAP_PROP_MAX_TRANSESS 0x0000010E +#define TPM_CAP_PROP_MAX_COUNTERS 0x0000010F +#define TPM_CAP_PROP_MAX_KEYS 0x00000110 +#define TPM_CAP_PROP_OWNER 0x00000111 +#define TPM_CAP_PROP_CONTEXT 0x00000112 +#define TPM_CAP_PROP_MAX_CONTEXT 0x00000113 +#define TPM_CAP_PROP_FAMILYROWS 0x00000114 +#define TPM_CAP_PROP_TIS_TIMEOUT 0x00000115 +#define TPM_CAP_PROP_STARTUP_EFFECT 0x00000116 +#define TPM_CAP_PROP_DELEGATE_ROW 0x00000117 +#define TPM_CAP_PROP_MAX_DAASESS 0x00000119 +#define TPM_CAP_PROP_DAASESS 0x0000011A +#define TPM_CAP_PROP_CONTEXT_DIST 0x0000011B +#define TPM_CAP_PROP_DAA_INTERRUPT 0x0000011C +#define TPM_CAP_PROP_SESSIONS 0x0000011D +#define TPM_CAP_PROP_MAX_SESSIONS 0x0000011E +#define TPM_CAP_PROP_CMK_RESTRICTION 0x0000011F +#define TPM_CAP_PROP_DURATION 0x00000120 +#define TPM_CAP_PROP_ACTIVE_COUNTER 0x00000122 +#define TPM_CAP_PROP_MAX_NV_AVAILABLE 0x00000123 +#define TPM_CAP_PROP_INPUT_BUFFER 0x00000124 + +// TPM_KEY_USAGE values +#define TPM_KEY_EK 0x0000 +#define TPM_KEY_SIGNING 0x0010 +#define TPM_KEY_STORAGE 0x0011 +#define TPM_KEY_IDENTITY 0x0012 +#define TPM_KEY_AUTHCHANGE 0X0013 +#define TPM_KEY_BIND 0x0014 +#define TPM_KEY_LEGACY 0x0015 + +// TPM_AUTH_DATA_USAGE values +#define TPM_AUTH_NEVER 0x00 +#define TPM_AUTH_ALWAYS 0x01 + +// Key Handle of owner and srk +#define TPM_OWNER_KEYHANDLE 0x40000001 +#define TPM_SRK_KEYHANDLE 0x40000000 + + + +// *************************** TYPEDEFS ********************************* +typedef unsigned char BYTE; +typedef unsigned char BOOL; +typedef uint16_t UINT16; +typedef uint32_t UINT32; +typedef uint64_t UINT64; + +typedef UINT32 TPM_RESULT; +typedef UINT32 TPM_PCRINDEX; +typedef UINT32 TPM_DIRINDEX; +typedef UINT32 TPM_HANDLE; +typedef TPM_HANDLE TPM_AUTHHANDLE; +typedef TPM_HANDLE TCPA_HASHHANDLE; +typedef TPM_HANDLE TCPA_HMACHANDLE; +typedef TPM_HANDLE TCPA_ENCHANDLE; +typedef TPM_HANDLE TPM_KEY_HANDLE; +typedef TPM_HANDLE TCPA_ENTITYHANDLE; +typedef UINT32 TPM_RESOURCE_TYPE; +typedef UINT32 TPM_COMMAND_CODE; +typedef UINT16 TPM_PROTOCOL_ID; +typedef BYTE TPM_AUTH_DATA_USAGE; +typedef UINT16 TPM_ENTITY_TYPE; +typedef UINT32 TPM_ALGORITHM_ID; +typedef UINT16 TPM_KEY_USAGE; +typedef UINT16 TPM_STARTUP_TYPE; +typedef UINT32 TPM_CAPABILITY_AREA; +typedef UINT16 TPM_ENC_SCHEME; +typedef UINT16 TPM_SIG_SCHEME; +typedef UINT16 TPM_MIGRATE_SCHEME; +typedef UINT16 TPM_PHYSICAL_PRESENCE; +typedef UINT32 TPM_KEY_FLAGS; + +#define TPM_DIGEST_SIZE 20 // Don't change this +typedef BYTE TPM_AUTHDATA[TPM_DIGEST_SIZE]; +typedef TPM_AUTHDATA TPM_SECRET; +typedef TPM_AUTHDATA TPM_ENCAUTH; +typedef BYTE TPM_PAYLOAD_TYPE; +typedef UINT16 TPM_TAG; +typedef UINT16 TPM_STRUCTURE_TAG; + +// Data Types of the TCS +typedef UINT32 TCS_AUTHHANDLE; // Handle addressing a authorization session +typedef UINT32 TCS_CONTEXT_HANDLE; // Basic context handle +typedef UINT32 TCS_KEY_HANDLE; // Basic key handle + +// ************************* STRUCTURES ********************************** + +typedef struct TPM_VERSION { + BYTE major; + BYTE minor; + BYTE revMajor; + BYTE revMinor; +} TPM_VERSION; + +static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; + +typedef struct TPM_CAP_VERSION_INFO { + TPM_STRUCTURE_TAG tag; + TPM_VERSION version; + UINT16 specLevel; + BYTE errataRev; + BYTE tpmVendorID[4]; + UINT16 vendorSpecificSize; + BYTE* vendorSpecific; +} TPM_CAP_VERSION_INFO; + +inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { + free(v->vendorSpecific); + v->vendorSpecific = NULL; +} + +typedef struct TPM_DIGEST { + BYTE digest[TPM_DIGEST_SIZE]; +} TPM_DIGEST; + +typedef TPM_DIGEST TPM_PCRVALUE; +typedef TPM_DIGEST TPM_COMPOSITE_HASH; +typedef TPM_DIGEST TPM_DIRVALUE; +typedef TPM_DIGEST TPM_HMAC; +typedef TPM_DIGEST TPM_CHOSENID_HASH; + +typedef struct TPM_NONCE { + BYTE nonce[TPM_DIGEST_SIZE]; +} TPM_NONCE; + +typedef struct TPM_SYMMETRIC_KEY_PARMS { + UINT32 keyLength; + UINT32 blockSize; + UINT32 ivSize; + BYTE* IV; +} TPM_SYMMETRIC_KEY_PARMS; + +inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { + free(p->IV); + p->IV = NULL; +} + +#define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } + +typedef struct TPM_RSA_KEY_PARMS { + UINT32 keyLength; + UINT32 numPrimes; + UINT32 exponentSize; + BYTE* exponent; +} TPM_RSA_KEY_PARMS; + +#define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } + +inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { + free(p->exponent); + p->exponent = NULL; +} + +typedef struct TPM_KEY_PARMS { + TPM_ALGORITHM_ID algorithmID; + TPM_ENC_SCHEME encScheme; + TPM_SIG_SCHEME sigScheme; + UINT32 parmSize; + union { + TPM_SYMMETRIC_KEY_PARMS sym; + TPM_RSA_KEY_PARMS rsa; + } parms; +} TPM_KEY_PARMS; + +#define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } + +inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { + if(p->parmSize) { + switch(p->algorithmID) { + case TPM_ALG_RSA: + free_TPM_RSA_KEY_PARMS(&p->parms.rsa); + break; + case TPM_ALG_AES128: + case TPM_ALG_AES192: + case TPM_ALG_AES256: + free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); + break; + } + } +} + +typedef struct TPM_STORE_PUBKEY { + UINT32 keyLength; + BYTE* key; +} TPM_STORE_PUBKEY; + +#define TPM_STORE_PUBKEY_INIT { 0, NULL } + +inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { + free(p->key); + p->key = NULL; +} + +typedef struct TPM_PUBKEY { + TPM_KEY_PARMS algorithmParms; + TPM_STORE_PUBKEY pubKey; +} TPM_PUBKEY; + +#define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } + +inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { + free_TPM_KEY_PARMS(&k->algorithmParms); + free_TPM_STORE_PUBKEY(&k->pubKey); +} + +typedef struct TPM_PCR_SELECTION { + UINT16 sizeOfSelect; + BYTE* pcrSelect; +} TPM_PCR_SELECTION; + +#define TPM_PCR_SELECTION_INIT { 0, NULL } + +inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { + free(p->pcrSelect); + p->pcrSelect = NULL; +} + +typedef struct TPM_PCR_INFO { + TPM_PCR_SELECTION pcrSelection; + TPM_COMPOSITE_HASH digestAtRelease; + TPM_COMPOSITE_HASH digestAtCreation; +} TPM_PCR_INFO; + +#define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } + +inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { + free_TPM_PCR_SELECTION(&p->pcrSelection); +} + +typedef struct TPM_PCR_COMPOSITE { + TPM_PCR_SELECTION select; + UINT32 valueSize; + TPM_PCRVALUE* pcrValue; +} TPM_PCR_COMPOSITE; + +#define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } + +inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { + free_TPM_PCR_SELECTION(&p->select); + free(p->pcrValue); + p->pcrValue = NULL; +} + +typedef struct TPM_KEY { + TPM_VERSION ver; + TPM_KEY_USAGE keyUsage; + TPM_KEY_FLAGS keyFlags; + TPM_AUTH_DATA_USAGE authDataUsage; + TPM_KEY_PARMS algorithmParms; + UINT32 PCRInfoSize; + TPM_PCR_INFO PCRInfo; + TPM_STORE_PUBKEY pubKey; + UINT32 encDataSize; + BYTE* encData; +} TPM_KEY; + +#define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\ + .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \ + .pubKey = TPM_STORE_PUBKEY_INIT, \ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_KEY(TPM_KEY* k) { + if(k->PCRInfoSize) { + free_TPM_PCR_INFO(&k->PCRInfo); + } + free_TPM_STORE_PUBKEY(&k->pubKey); + free(k->encData); + k->encData = NULL; +} + +typedef struct TPM_BOUND_DATA { + TPM_VERSION ver; + TPM_PAYLOAD_TYPE payload; + BYTE* payloadData; +} TPM_BOUND_DATA; + +#define TPM_BOUND_DATA_INIT { .payloadData = NULL } + +inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { + free(d->payloadData); + d->payloadData = NULL; +} + +typedef struct TPM_STORED_DATA { + TPM_VERSION ver; + UINT32 sealInfoSize; + TPM_PCR_INFO sealInfo; + UINT32 encDataSize; + BYTE* encData; +} TPM_STORED_DATA; + +#define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\ + .encDataSize = 0, .encData = NULL } + +inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { + if(d->sealInfoSize) { + free_TPM_PCR_INFO(&d->sealInfo); + } + free(d->encData); + d->encData = NULL; +} + +typedef struct TPM_AUTH_SESSION { + TPM_AUTHHANDLE AuthHandle; + TPM_NONCE NonceOdd; // system + TPM_NONCE NonceEven; // TPM + BOOL fContinueAuthSession; + TPM_AUTHDATA HMAC; +} TPM_AUTH_SESSION; + +#define TPM_AUTH_SESSION_INIT { .AuthHandle = 0, .fContinueAuthSession = FALSE } + +// ---------------------- Functions for checking TPM_RESULTs ----------------- + +#include + +// FIXME: Review use of these and delete unneeded ones. + +// these are really badly dependent on local structure: +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +#define ERRORDIE(s) do { status = s; \ + fprintf (stderr, "*** ERRORDIE in %s at %s: %i\n", __func__, __FILE__, __LINE__); \ + goto abort_egress; } \ + while (0) + +// DEPENDS: local var 'status' of type TPM_RESULT +// DEPENDS: label 'abort_egress' which cleans up and returns the status +// Try command c. If it fails, set status to s and goto abort. +#define TPMTRY(s,c) if (c != TPM_SUCCESS) { \ + status = s; \ + printf("ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } else {\ + status = c; \ + } + +// Try command c. If it fails, print error message, set status to actual return code. Goto abort +#define TPMTRYRETURN(c) do { status = c; \ + if (status != TPM_SUCCESS) { \ + fprintf(stderr, "ERROR in %s at %s:%i code: %s.\n", __func__, __FILE__, __LINE__, tpm_get_error_name(status)); \ + goto abort_egress; \ + } \ + } while(0) + + +#endif //__TCPA_H__ diff --git a/stubdom/vtpmmgr/tpm.c b/stubdom/vtpmmgr/tpm.c new file mode 100644 index 0000000..123a27c --- /dev/null +++ b/stubdom/vtpmmgr/tpm.c @@ -0,0 +1,938 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include + +#include + +#include "tcg.h" +#include "tpm.h" +#include "log.h" +#include "marshal.h" +#include "tpmrsa.h" +#include "vtpmmgr.h" + +#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_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;\ + }\ +} 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]; + } + } + +} + +static void generateAuth(const TPM_DIGEST* paramDigest, + const TPM_SECRET* HMACkey, + TPM_AUTH_SESSION *auth) +{ + //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; + + 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); +} + +static TPM_RESULT verifyAuth(const TPM_DIGEST* paramDigest, + /*[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; + } +} + + + +// ------------------------------------------------------------------ +// Authorization Commands +// ------------------------------------------------------------------ + +TPM_RESULT TPM_OIAP(TPM_AUTH_SESSION* auth) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + memset(&auth->HMAC, 0, sizeof(TPM_DIGEST)); + auth->fContinueAuthSession = TRUE; + + ptr = unpack_UINT32(ptr, &auth->AuthHandle); + ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x opened by TPM_OIAP.\n", auth->AuthHandle); + +abort_egress: + 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) +{ + BYTE* nonceOddOSAP; + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); + + ptr = pack_TPM_ENTITY_TYPE(ptr, entityType); + ptr = pack_UINT32(ptr, entityValue); + + //nonce Odd OSAP + nonceOddOSAP = ptr; + vtpmmgr_rand(ptr, TPM_DIGEST_SIZE); + ptr += TPM_DIGEST_SIZE; + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + 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, ptr, TPM_DIGEST_SIZE); //ptr = nonceEvenOSAP + sha1_hmac_update(&ctx, nonceOddOSAP, TPM_DIGEST_SIZE); + sha1_hmac_finish(&ctx, *sharedSecret); + + 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); + +abort_egress: + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(outSrk); + } +egress: + tpmrsa_free(&ek_rsa); + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_DisablePubekRead ( + 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_AUTH1_GEN(ownerAuth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + TPM_AUTH1_VERIFY(ownerAuth, auth); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + + +TPM_RESULT TPM_TerminateHandle(TPM_AUTHHANDLE handle) // in +{ + if(handle == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Terminate_Handle); + + ptr = pack_TPM_AUTHHANDLE(ptr, handle); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Auth Session: 0x%x closed by TPM_TerminateHandle\n", handle); + +abort_egress: + return status; +} + +TPM_RESULT TPM_Extend( TPM_PCRINDEX pcrNum, // in + TPM_DIGEST inDigest, // in + TPM_PCRVALUE* outDigest) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_Extend); + + ptr = pack_TPM_PCRINDEX(ptr, pcrNum); + ptr = pack_TPM_DIGEST(ptr, &inDigest); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_TPM_PCRVALUE(ptr, outDigest); + +abort_egress: + 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 + ) +{ + 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); + + ptr = pack_UINT32(ptr, pcrInfoSize); + ptr = pack_TPM_PCR_INFO(ptr, pcrInfo); + + ptr = pack_UINT32(ptr, inDataSize); + ptr = pack_BUFFER(ptr, inData, inDataSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(osapSharedSecret, pubAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_TPM_STORED_DATA(ptr, sealedData, UNPACK_ALLOC); + dataAlloced = 1; + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(osapSharedSecret, pubAuth); + + goto egress; +abort_egress: + if(dataAlloced) { + free_TPM_STORED_DATA(sealedData); + } +egress: + TPM_AUTH_ERR_CHECK(pubAuth); + 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_BEGIN(TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_Unseal); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, parentHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_TPM_STORED_DATA(ptr, sealedData); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(key_usage_auth, keyAuth); + TPM_AUTH2_GEN(data_usage_auth, dataAuth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + ptr = unpack_UINT32(ptr, outSize); + ptr = unpack_ALLOC(ptr, out, *outSize); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(key_usage_auth, keyAuth); + TPM_AUTH2_VERIFY(data_usage_auth, dataAuth); + +abort_egress: + TPM_AUTH_ERR_CHECK(keyAuth); + TPM_AUTH_ERR_CHECK(dataAuth); + return status; +} + +TPM_RESULT TPM_Bind( + const TPM_KEY* key, + const BYTE* in, + UINT32 ilen, + BYTE* 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)); + +abort_egress: + tpmrsa_free(&rsa); + 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_BEGIN(TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_UnBind); + TPM_AUTH_BEGIN(); + + TPM_AUTH_HASH(); + + ptr = pack_TPM_KEY_HANDLE(ptr, keyHandle); + + TPM_AUTH_SKIP(); + + ptr = pack_UINT32(ptr, ilen); + ptr = pack_BUFFER(ptr, in, ilen); + + TPM_AUTH_HASH(); + + TPM_AUTH1_GEN(usage_auth, auth); + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + TPM_AUTH_VERIFY_BEGIN(); + + 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); + + TPM_AUTH_HASH(); + + TPM_AUTH1_VERIFY(usage_auth, auth); + +abort_egress: +egress: + TPM_AUTH_ERR_CHECK(auth); + 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 +{ + 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; +abort_egress: + if(keyAlloced) { + free_TPM_KEY(key); + } +egress: + TPM_AUTH_ERR_CHECK(pAuth); + 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_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); + +abort_egress: + TPM_AUTH_ERR_CHECK(auth); + return status; +} + +TPM_RESULT TPM_EvictKey( TPM_KEY_HANDLE hKey) // in +{ + if(hKey == 0) { + return TPM_SUCCESS; + } + + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_EvictKey); + + ptr = pack_TPM_KEY_HANDLE(ptr, hKey); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + vtpmloginfo(VTPM_LOG_TPM, "Key handle: 0x%x closed by TPM_EvictKey\n", hKey); + +abort_egress: + 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(); + +abort_egress: + return status; +} + +TPM_RESULT TPM_GetRandom( UINT32* bytesRequested, // in, out + BYTE* randomBytes) // out +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_GetRandom); + + // check input params + if (bytesRequested == NULL || randomBytes == NULL){ + return TPM_BAD_PARAMETER; + } + + ptr = pack_UINT32(ptr, *bytesRequested); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, bytesRequested); + ptr = unpack_BUFFER(ptr, randomBytes, *bytesRequested); + +abort_egress: + return status; +} + + +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; +abort_egress: + if(kptr != NULL) { //If we unpacked the pubEK, we have to free it + free_TPM_PUBKEY(pubEK); + } +egress: + return status; +} + + +TPM_RESULT TPM_SaveState(void) +{ + TPM_BEGIN(TPM_TAG_RQU_COMMAND, TPM_ORD_SaveState); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + +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); + + ptr = pack_TPM_CAPABILITY_AREA(ptr, capArea); + ptr = pack_UINT32(ptr, subCapSize); + ptr = pack_BUFFER(ptr, subCap, subCapSize); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + ptr = unpack_UINT32(ptr, respSize); + ptr = unpack_ALLOC(ptr, resp, *respSize); + +abort_egress: + return status; +} + +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(TPM_TAG_RQU_COMMAND, TPM_ORD_CreateEndorsementKeyPair); + + //Make anti replay nonce + vtpmmgr_rand(antiReplay.nonce, sizeof(antiReplay.nonce)); + + ptr = pack_TPM_NONCE(ptr, &antiReplay); + ptr = pack_TPM_KEY_PARMS(ptr, keyInfo); + + TPM_TRANSMIT(); + TPM_UNPACK_VERIFY(); + + sha1_starts(&ctx); + + kptr = ptr; + ptr = unpack_TPM_PUBKEY(ptr, pubEK, UNPACK_ALLOC); + + /* Hash the pub key blob */ + sha1_update(&ctx, kptr, ptr - kptr); + ptr = unpack_TPM_DIGEST(ptr, &checksum); + + sha1_update(&ctx, antiReplay.nonce, sizeof(antiReplay.nonce)); + + 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; + } + + goto egress; +abort_egress: + if(kptr) { + free_TPM_PUBKEY(pubEK); + } +egress: + 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; + +abort_egress: +egress: + return status; +} diff --git a/stubdom/vtpmmgr/tpm.h b/stubdom/vtpmmgr/tpm.h new file mode 100644 index 0000000..304e145 --- /dev/null +++ b/stubdom/vtpmmgr/tpm.h @@ -0,0 +1,218 @@ +/* + * 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/2006, 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 __TPM_H__ +#define __TPM_H__ + +#include "tcg.h" + +// ------------------------------------------------------------------ +// Exposed API +// ------------------------------------------------------------------ + +// TPM v1.1B Command Set + +// Authorzation +TPM_RESULT TPM_OIAP( + TPM_AUTH_SESSION* auth //out + ); + +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); + +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 + ); + +TPM_RESULT TPM_DisablePubekRead ( + const TPM_AUTHDATA* ownerAuth, + TPM_AUTH_SESSION* auth + ); + +TPM_RESULT TPM_TerminateHandle ( TPM_AUTHHANDLE handle // in + ); + +TPM_RESULT TPM_FlushSpecific ( TPM_HANDLE handle, // in + TPM_RESOURCE_TYPE resourceType //in + ); + +// TPM Mandatory +TPM_RESULT TPM_Extend ( TPM_PCRINDEX pcrNum, // 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_Seal( + TCS_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* sealDataAuth, //in + TPM_AUTH_SESSION* pubAuth // in, out + ); + +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_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 + TPM_HANDLE* keyHandle, // out + const TPM_AUTHDATA* usage_auth, + 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 + ); + +TPM_RESULT TPM_GetCapability( + TPM_CAPABILITY_AREA capArea, + UINT32 subCapSize, + const BYTE* subCap, + UINT32* respSize, + BYTE** resp); + +TPM_RESULT TPM_SaveState(void); + +TPM_RESULT TPM_CreateEndorsementKeyPair( + const TPM_KEY_PARMS* keyInfo, + TPM_PUBKEY* pubEK); + +TPM_RESULT TPM_TransmitData( + BYTE* in, + UINT32 insize, + BYTE* out, + UINT32* outsize); + +#endif //TPM_H diff --git a/stubdom/vtpmmgr/tpmrsa.c b/stubdom/vtpmmgr/tpmrsa.c new file mode 100644 index 0000000..56094e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.c @@ -0,0 +1,175 @@ +/* + * The RSA public-key cryptosystem + * + * Copyright (C) 2006-2011, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +/* + * RSA was designed by Ron Rivest, Adi Shamir and Len Adleman. + * + * http://theory.lcs.mit.edu/~rivest/rsapaper.pdf + * http://www.cacr.math.uwaterloo.ca/hac/about/chap8.pdf + */ + +#include "tcg.h" +#include "polarssl/sha1.h" + +#include +#include + +#include "tpmrsa.h" + +#define HASH_LEN 20 + +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen) { + + tpmrsa_free(ctx); + + if(explen == 0) { //Default e= 2^16+1 + mpi_lset(&ctx->E, 65537); + } else { + mpi_read_binary(&ctx->E, exponent, explen); + } + mpi_read_binary(&ctx->N, key, keylen); + + ctx->len = ( mpi_msb(&ctx->N) + 7) >> 3; +} + +static TPM_RESULT tpmrsa_public( tpmrsa_context *ctx, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + size_t olen; + mpi T; + + mpi_init( &T ); + + MPI_CHK( mpi_read_binary( &T, input, ctx->len ) ); + + if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 ) + { + mpi_free( &T ); + return TPM_ENCRYPT_ERROR; + } + + olen = ctx->len; + MPI_CHK( mpi_exp_mod( &T, &T, &ctx->E, &ctx->N, &ctx->RN ) ); + MPI_CHK( mpi_write_binary( &T, output, olen ) ); + +cleanup: + + mpi_free( &T ); + + if( ret != 0 ) + return TPM_ENCRYPT_ERROR; + + return TPM_SUCCESS; +} + +static void mgf_mask( unsigned char *dst, int dlen, unsigned char *src, int slen) +{ + unsigned char mask[HASH_LEN]; + unsigned char counter[4] = {0, 0, 0, 0}; + int i; + sha1_context mctx; + + //We always hash the src with the counter, so save the partial hash + sha1_starts(&mctx); + sha1_update(&mctx, src, slen); + + // Generate and apply dbMask + while(dlen > 0) { + //Copy the sha1 context + sha1_context ctx = mctx; + + //compute hash for input || counter + sha1_update(&ctx, counter, sizeof(counter)); + sha1_finish(&ctx, mask); + + //Apply the mask + for(i = 0; i < (dlen < HASH_LEN ? dlen : HASH_LEN); ++i) { + *(dst++) ^= mask[i]; + } + + //Increment counter + ++counter[3]; + + dlen -= HASH_LEN; + } +} + +/* + * Add the message padding, then do an RSA operation + */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ) +{ + int ret; + int olen; + unsigned char* seed = output + 1; + unsigned char* db = output + HASH_LEN +1; + + olen = ctx->len-1; + + if( f_rng == NULL ) + return TPM_ENCRYPT_ERROR; + + if( ilen > olen - 2 * HASH_LEN - 1) + return TPM_ENCRYPT_ERROR; + + output[0] = 0; + + //Encoding parameter p + sha1((unsigned char*)"TCPA", 4, db); + + //PS + memset(db + HASH_LEN, 0, + olen - ilen - 2 * HASH_LEN - 1); + + //constant 1 byte + db[olen - ilen - HASH_LEN -1] = 0x01; + + //input string + memcpy(db + olen - ilen - HASH_LEN, + input, ilen); + + //Generate random seed + if( ( ret = f_rng( p_rng, seed, HASH_LEN ) ) != 0 ) + return TPM_ENCRYPT_ERROR; + + // maskedDB: Apply dbMask to DB + mgf_mask( db, olen - HASH_LEN, seed, HASH_LEN); + + // maskedSeed: Apply seedMask to seed + mgf_mask( seed, HASH_LEN, db, olen - HASH_LEN); + + // Do the crypto op + return tpmrsa_public(ctx, output, output); +} diff --git a/stubdom/vtpmmgr/tpmrsa.h b/stubdom/vtpmmgr/tpmrsa.h new file mode 100644 index 0000000..59579e7 --- /dev/null +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -0,0 +1,67 @@ +/** + * \file rsa.h + * + * \brief The RSA public-key cryptosystem + * + * Copyright (C) 2006-2010, Brainspark B.V. + * + * This file is part of PolarSSL (http://www.polarssl.org) + * Lead Maintainer: Paul Bakker + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#ifndef TPMRSA_H +#define TPMRSA_H + +#include "tcg.h" +#include + +/* tpm software key */ +typedef struct +{ + size_t len; /*!< size(N) in chars */ + + mpi N; /*!< public modulus */ + mpi E; /*!< public exponent */ + + mpi RN; /*!< cached R^2 mod N */ +} +tpmrsa_context; + +#define TPMRSA_CTX_INIT { 0, {0, 0, NULL}, {0, 0, NULL}, {0, 0, NULL}} + +/* Setup the rsa context using tpm public key data */ +void tpmrsa_set_pubkey(tpmrsa_context* ctx, + const unsigned char* key, + int keylen, + const unsigned char* exponent, + int explen); + +/* Do rsa public crypto */ +TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, + int (*f_rng)(void *, unsigned char *, size_t), + void *p_rng, + size_t ilen, + const unsigned char *input, + unsigned char *output ); + +/* free tpmrsa key */ +inline void tpmrsa_free( tpmrsa_context *ctx ) { + mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); +} + +#endif /* tpmrsa.h */ diff --git a/stubdom/vtpmmgr/uuid.h b/stubdom/vtpmmgr/uuid.h new file mode 100644 index 0000000..4737645 --- /dev/null +++ b/stubdom/vtpmmgr/uuid.h @@ -0,0 +1,50 @@ +/* + * 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 VTPMMGR_UUID_H +#define VTPMMGR_UUID_H + +#define UUID_FMT "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx" +#define UUID_FMTLEN ((2*16)+4) /* 16 hex bytes plus 4 hypens */ +#define UUID_BYTES(uuid) uuid[0], uuid[1], uuid[2], uuid[3], \ + uuid[4], uuid[5], uuid[6], uuid[7], \ + uuid[8], uuid[9], uuid[10], uuid[11], \ + uuid[12], uuid[13], uuid[14], uuid[15] + + +typedef uint8_t uuid_t[16]; + +#endif diff --git a/stubdom/vtpmmgr/vtpm_cmd_handler.c b/stubdom/vtpmmgr/vtpm_cmd_handler.c new file mode 100644 index 0000000..f82a2a9 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_cmd_handler.c @@ -0,0 +1,152 @@ +/* + * 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. +*/ + +#include +#include +#include + +#include "marshal.h" +#include "log.h" +#include "vtpm_storage.h" +#include "vtpmmgr.h" +#include "tpm.h" +#include "tcg.h" + +static TPM_RESULT vtpmmgr_SaveHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) +{ + TPM_RESULT status = TPM_SUCCESS; + + 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; + } + + /* Do the command */ + TPMTRYRETURN(vtpm_storage_save_hashkey(uuid, tpmcmd->req + VTPM_COMMAND_HEADER_SIZE)); + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, VTPM_COMMAND_HEADER_SIZE, status); + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + return status; +} + +static TPM_RESULT vtpmmgr_LoadHashKey( + const uuid_t uuid, + tpmcmd_t* tpmcmd) { + TPM_RESULT status = TPM_SUCCESS; + + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + + TPMTRYRETURN(vtpm_storage_load_hashkey(uuid, tpmcmd->resp + VTPM_COMMAND_HEADER_SIZE)); + + tpmcmd->resp_len += HASHKEYSZ; + +abort_egress: + pack_TPM_RSP_HEADER(tpmcmd->resp, + VTPM_TAG_RSP, tpmcmd->resp_len, status); + + return status; +} + + +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; + } + +abort_egress: + tpmcmd->resp_len = VTPM_COMMAND_HEADER_SIZE; + pack_TPM_RSP_HEADER(tpmcmd->resp, + tag + 3, tpmcmd->resp_len, status); + + return status; +} diff --git a/stubdom/vtpmmgr/vtpm_manager.h b/stubdom/vtpmmgr/vtpm_manager.h new file mode 100644 index 0000000..a2bbcca --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_manager.h @@ -0,0 +1,64 @@ +/* + * 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_MANAGER_H +#define VTPM_MANAGER_H + +#define VTPM_TAG_REQ 0x01c1 +#define VTPM_TAG_RSP 0x01c4 +#define COMMAND_BUFFER_SIZE 4096 + +// Header size +#define VTPM_COMMAND_HEADER_SIZE ( 2 + 4 + 4) + +//************************ 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) + +// 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 +#define VTPM_FAIL 1 +#define VTPM_UNSUPPORTED 2 +#define VTPM_FORBIDDEN 3 +#define VTPM_RESTORE_CONTEXT_FAILED 4 +#define VTPM_INVALID_REQUEST 5 + +#endif diff --git a/stubdom/vtpmmgr/vtpm_storage.c b/stubdom/vtpmmgr/vtpm_storage.c new file mode 100644 index 0000000..abb0dba --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.c @@ -0,0 +1,794 @@ +/* + * 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 (%ld)\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 new file mode 100644 index 0000000..a5a5fd7 --- /dev/null +++ b/stubdom/vtpmmgr/vtpm_storage.h @@ -0,0 +1,68 @@ +/* + * 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.c b/stubdom/vtpmmgr/vtpmmgr.c new file mode 100644 index 0000000..563f4e8 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.c @@ -0,0 +1,93 @@ +/* + * 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. +*/ + +#include +#include +#include +#include +#include +#include +#include "log.h" + +#include "vtpmmgr.h" +#include "tcg.h" + + +void main_loop(void) { + tpmcmd_t* tpmcmd; + uint8_t respbuf[TCPA_MAX_BUFFER_LENGTH]; + + while(1) { + /* Wait for requests from a vtpm */ + vtpmloginfo(VTPM_LOG_VTPM, "Waiting for commands from vTPM's:\n"); + if((tpmcmd = tpmback_req_any()) == NULL) { + vtpmlogerror(VTPM_LOG_VTPM, "NULL tpmcmd\n"); + continue; + } + + tpmcmd->resp = respbuf; + + /* Process the command */ + vtpmmgr_handle_cmd(tpmcmd->uuid, tpmcmd); + + /* Send response */ + tpmback_resp(tpmcmd); + } +} + +int main(int argc, char** argv) +{ + int rc = 0; + sleep(2); + vtpmloginfo(VTPM_LOG_VTPM, "Starting vTPM manager domain\n"); + + /* Initialize the vtpm manager */ + if(vtpmmgr_init(argc, argv) != TPM_SUCCESS) { + vtpmlogerror(VTPM_LOG_VTPM, "Unable to initialize vtpmmgr domain!\n"); + rc = -1; + goto exit; + } + + main_loop(); + + vtpmloginfo(VTPM_LOG_VTPM, "vTPM Manager shutting down...\n"); + + vtpmmgr_shutdown(); + +exit: + return rc; + +} diff --git a/stubdom/vtpmmgr/vtpmmgr.h b/stubdom/vtpmmgr/vtpmmgr.h new file mode 100644 index 0000000..50a1992 --- /dev/null +++ b/stubdom/vtpmmgr/vtpmmgr.h @@ -0,0 +1,77 @@ +/* + * 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 VTPMMGR_H +#define VTPMMGR_H + +#include +#include +#include + +#include "uuid.h" +#include "tcg.h" +#include "vtpm_manager.h" + +#define RSA_KEY_SIZE 0x0800 +#define RSA_CIPHER_SIZE (RSA_KEY_SIZE / 8) + +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; + + entropy_context entropy; + ctr_drbg_context ctr_drbg; +}; + +// --------------------------- 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); + +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; +} + +#endif -- 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 Thu Nov 29 17:36:26 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 29 Nov 2012 17:36:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te829-00080u-UJ; Thu, 29 Nov 2012 17:36:21 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te827-0007zW-Nn for xen-devel@lists.xen.org; Thu, 29 Nov 2012 17:36:20 +0000 Received: from [85.158.139.211:51984] by server-3.bemta-5.messagelabs.com id 9C/63-18736-21D97B05; Thu, 29 Nov 2012 17:36:18 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-14.tower-206.messagelabs.com!1354210558!18366979!1 X-Originating-IP: [128.244.251.36] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_23,UNPARSEABLE_RELAY,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 27372 invoked from network); 29 Nov 2012 17:35:59 -0000 Received: from pilot.jhuapl.edu (HELO jhuapl.edu) (128.244.251.36) by server-14.tower-206.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 29 Nov 2012 17:35:59 -0000 Received: from ([128.244.206.185]) by pilot.jhuapl.edu with ESMTP with TLS id 63GHCH1.158386752; Thu, 29 Nov 2012 12:35:48 -0500 From: Matthew Fioravante To: xen-devel@lists.xen.org, Ian.Jackson@eu.citrix.com, Ian.Campbell@citrix.com Date: Thu, 29 Nov 2012 12:35:34 -0500 Message-Id: <1354210534-31052-8-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> Cc: Matthew Fioravante Subject: [Xen-devel] [VTPM v5 7/7] Add a real top level configure script that calls the others 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 Signed-off-by: Matthew Fioravante --- autogen.sh | 1 + configure | 3013 +++++++++++++++++++++++++++++++++++++++++++++++++++- configure.ac | 14 + tools/configure | 601 ++++++----- tools/configure.ac | 2 +- 5 files changed, 3341 insertions(+), 290 deletions(-) create mode 100644 configure.ac diff --git a/autogen.sh b/autogen.sh index ada482c..1456d94 100755 --- a/autogen.sh +++ b/autogen.sh @@ -1,4 +1,5 @@ #!/bin/sh -e +autoconf cd tools autoconf autoheader diff --git a/configure b/configure index ba3bc39..3284a46 100755 --- a/configure +++ b/configure @@ -1,2 +1,3011 @@ -#!/bin/sh -e -cd tools && ./configure $@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69 for Xen Hypervisor 4.3. +# +# Report bugs to . +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org and +$0: xen-devel@lists.xen.org about your system, including +$0: any error possibly output before this message. Then +$0: install a modern shell, or manually run the script +$0: under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='Xen Hypervisor' +PACKAGE_TARNAME='xen' +PACKAGE_VERSION='4.3' +PACKAGE_STRING='Xen Hypervisor 4.3' +PACKAGE_BUGREPORT='xen-devel@lists.xen.org' +PACKAGE_URL='http://www.xen.org/' + +ac_unique_file="./tools/libxl/libxl.c" +ac_default_prefix=/usr +enable_option_checking=no +ac_subst_vars='LTLIBOBJS +LIBOBJS +subdirs +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +' + ac_precious_vars='build_alias +host_alias +target_alias' +ac_subdirs_all='tools stubdom' + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures Xen Hypervisor 4.3 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/xen] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of Xen Hypervisor 4.3:";; + esac + cat <<\_ACEOF + +Report bugs to . +Xen Hypervisor home page: . +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +Xen Hypervisor configure 4.3 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by Xen Hypervisor $as_me 4.3, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + +ac_config_files="$ac_config_files ./config/Tools.mk" + + +ac_aux_dir= +for ac_dir in . "$srcdir"/.; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in . \"$srcdir\"/." "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + + + + +subdirs="$subdirs tools stubdom" + + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +# Transform confdefs.h into DEFS. +# Protect against shell expansion while executing Makefile rules. +# Protect against Makefile macro expansion. +# +# If the first sed substitution is executed (which looks for macros that +# take arguments), then branch to the quote section. Otherwise, +# look for a macro that doesn't take arguments. +ac_script=' +:mline +/\\$/{ + N + s,\\\n,, + b mline +} +t clear +:clear +s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g +t quote +s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g +t quote +b any +:quote +s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g +s/\[/\\&/g +s/\]/\\&/g +s/\$/$$/g +H +:any +${ + g + s/^\n// + s/\n/ /g + p +} +' +DEFS=`sed -n "$ac_script" confdefs.h` + + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by Xen Hypervisor $as_me 4.3, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + +Configuration files: +$config_files + +Report bugs to . +Xen Hypervisor home page: ." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +Xen Hypervisor config.status 4.3 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h | --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "./config/Tools.mk") CONFIG_FILES="$CONFIG_FILES ./config/Tools.mk" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + + +eval set X " :F $CONFIG_FILES " +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + + + + esac + +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi + +# +# CONFIG_SUBDIRS section. +# +if test "$no_recursion" != yes; then + + # Remove --cache-file, --srcdir, and --disable-option-checking arguments + # so they do not pile up. + ac_sub_configure_args= + ac_prev= + eval "set x $ac_configure_args" + shift + for ac_arg + do + if test -n "$ac_prev"; then + ac_prev= + continue + fi + case $ac_arg in + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \ + | --c=*) + ;; + --config-cache | -C) + ;; + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + ;; + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + ;; + --disable-option-checking) + ;; + *) + case $ac_arg in + *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append ac_sub_configure_args " '$ac_arg'" ;; + esac + done + + # Always prepend --prefix to ensure using the same prefix + # in subdir configurations. + ac_arg="--prefix=$prefix" + case $ac_arg in + *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args" + + # Pass --silent + if test "$silent" = yes; then + ac_sub_configure_args="--silent $ac_sub_configure_args" + fi + + # Always prepend --disable-option-checking to silence warnings, since + # different subdirs can have different --enable and --with options. + ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args" + + ac_popdir=`pwd` + for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue + + # Do not complain, so a configure script can configure whichever + # parts of a large source tree are present. + test -d "$srcdir/$ac_dir" || continue + + ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)" + $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5 + $as_echo "$ac_msg" >&6 + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + cd "$ac_dir" + + # Check for guested configure; otherwise get Cygnus style configure. + if test -f "$ac_srcdir/configure.gnu"; then + ac_sub_configure=$ac_srcdir/configure.gnu + elif test -f "$ac_srcdir/configure"; then + ac_sub_configure=$ac_srcdir/configure + elif test -f "$ac_srcdir/configure.in"; then + # This should be Cygnus configure. + ac_sub_configure=$ac_aux_dir/configure + else + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5 +$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;} + ac_sub_configure= + fi + + # The recursion is here. + if test -n "$ac_sub_configure"; then + # Make the cache file name correct relative to the subdirectory. + case $cache_file in + [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;; + *) # Relative name. + ac_sub_cache_file=$ac_top_build_prefix$cache_file ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5 +$as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;} + # The eval makes quoting arguments work. + eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \ + --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" || + as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5 + fi + + cd "$ac_popdir" + done +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..3a6339c --- /dev/null +++ b/configure.ac @@ -0,0 +1,14 @@ +# -*- Autoconf -*- +# Process this file with autoconf to produce a configure script. + +AC_PREREQ([2.67]) +AC_INIT([Xen Hypervisor], m4_esyscmd([./version.sh ./xen/Makefile]), + [xen-devel@lists.xen.org], [xen], [http://www.xen.org/]) +AC_CONFIG_SRCDIR([./tools/libxl/libxl.c]) +AC_CONFIG_FILES([./config/Tools.mk]) +AC_PREFIX_DEFAULT([/usr]) +AC_CONFIG_AUX_DIR([.]) + +AC_CONFIG_SUBDIRS([tools stubdom]) + +AC_OUTPUT() diff --git a/tools/configure b/tools/configure index 1168436..fbd48a8 100755 --- a/tools/configure +++ b/tools/configure @@ -1,13 +1,11 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.67 for Xen Hypervisor 4.3. +# Generated by GNU Autoconf 2.69 for Xen Hypervisor Tools 4.3. # # Report bugs to . # # -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software -# Foundation, Inc. +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation @@ -91,6 +89,7 @@ fi IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. +as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -135,6 +134,31 @@ export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh @@ -168,7 +192,8 @@ if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi -test x\$exitcode = x0 || exit 1" +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && @@ -213,14 +238,25 @@ IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : - # We cannot yet assume a decent shell, so we have to provide a - # neutralization value for shells without unset; and this also - # works around shells that cannot unset nonexistent variables. - BASH_ENV=/dev/null - ENV=/dev/null - (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 fi if test x$as_have_required = xno; then : @@ -323,6 +359,14 @@ $as_echo X"$as_dir" | } # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take @@ -444,6 +488,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). @@ -478,16 +526,16 @@ if (echo >conf$$.file) 2>/dev/null; then # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. + # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' + as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null @@ -499,28 +547,8 @@ else as_mkdir_p=false fi -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x +as_test_x='test -x' +as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" @@ -550,10 +578,10 @@ MFLAGS= MAKEFLAGS= # Identity of this package. -PACKAGE_NAME='Xen Hypervisor' +PACKAGE_NAME='Xen Hypervisor Tools' PACKAGE_TARNAME='xen' PACKAGE_VERSION='4.3' -PACKAGE_STRING='Xen Hypervisor 4.3' +PACKAGE_STRING='Xen Hypervisor Tools 4.3' PACKAGE_BUGREPORT='xen-devel@lists.xen.org' PACKAGE_URL='http://www.xen.org/' @@ -1164,7 +1192,7 @@ Try \`$0 --help' for more information" $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 - : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac @@ -1215,8 +1243,6 @@ target=$target_alias if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe - $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. - If a cross compiler is detected then cross compile mode will be used" >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi @@ -1302,7 +1328,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures Xen Hypervisor 4.3 to adapt to many kinds of systems. +\`configure' configures Xen Hypervisor Tools 4.3 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1367,7 +1393,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of Xen Hypervisor 4.3:";; + short | recursive ) echo "Configuration of Xen Hypervisor Tools 4.3:";; esac cat <<\_ACEOF @@ -1427,7 +1453,7 @@ Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . -Xen Hypervisor home page: . +Xen Hypervisor Tools home page: . _ACEOF ac_status=$? fi @@ -1490,10 +1516,10 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -Xen Hypervisor configure 4.3 -generated by GNU Autoconf 2.67 +Xen Hypervisor Tools configure 4.3 +generated by GNU Autoconf 2.69 -Copyright (C) 2010 Free Software Foundation, Inc. +Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1537,7 +1563,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile @@ -1574,7 +1600,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp @@ -1587,10 +1613,10 @@ fi ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval "test \"\${$3+set}\"" = set; then : + if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 @@ -1657,7 +1683,7 @@ $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" @@ -1666,7 +1692,7 @@ eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel @@ -1707,7 +1733,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run @@ -1721,7 +1747,7 @@ ac_fn_c_check_header_compile () as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } -if eval "test \"\${$3+set}\"" = set; then : +if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -1739,7 +1765,7 @@ fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile @@ -1770,7 +1796,7 @@ $as_echo "$ac_try_echo"; } >&5 test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || - $as_test_x conftest$ac_exeext + test -x conftest$ac_exeext }; then : ac_retval=0 else @@ -1784,7 +1810,7 @@ fi # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link @@ -1792,8 +1818,8 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by Xen Hypervisor $as_me 4.3, which was -generated by GNU Autoconf 2.67. Invocation command line was +It was created by Xen Hypervisor Tools $as_me 4.3, which was +generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2051,7 +2077,7 @@ $as_echo "$as_me: loading site script $ac_site_file" >&6;} || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi done @@ -2195,7 +2221,7 @@ $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } -if test "${ac_cv_build+set}" = set; then : +if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias @@ -2211,7 +2237,7 @@ fi $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; -*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5 ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' @@ -2229,7 +2255,7 @@ case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } -if test "${ac_cv_host+set}" = set; then : +if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then @@ -2244,7 +2270,7 @@ fi $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; -*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5 ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' @@ -2308,7 +2334,6 @@ case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac - # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- # serial 1 (pkg-config-0.24) # @@ -2675,7 +2700,7 @@ if test -n "$ac_tool_prefix"; then set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2687,7 +2712,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2715,7 +2740,7 @@ if test -z "$ac_cv_prog_CC"; then set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : +if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then @@ -2727,7 +2752,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2768,7 +2793,7 @@ if test -z "$CC"; then set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2780,7 +2805,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2808,7 +2833,7 @@ if test -z "$CC"; then set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2821,7 +2846,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue @@ -2867,7 +2892,7 @@ if test -z "$CC"; then set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_CC+set}" = set; then : +if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then @@ -2879,7 +2904,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2911,7 +2936,7 @@ do set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : +if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then @@ -2923,7 +2948,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -2966,7 +2991,7 @@ fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 @@ -3081,7 +3106,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } @@ -3124,7 +3149,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 @@ -3183,7 +3208,7 @@ $as_echo "$ac_try_echo"; } >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi fi fi @@ -3194,7 +3219,7 @@ rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } -if test "${ac_cv_objext+set}" = set; then : +if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -3235,7 +3260,7 @@ sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi @@ -3245,7 +3270,7 @@ OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } -if test "${ac_cv_c_compiler_gnu+set}" = set; then : +if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -3282,7 +3307,7 @@ ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } -if test "${ac_cv_prog_cc_g+set}" = set; then : +if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag @@ -3360,7 +3385,7 @@ else fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if test "${ac_cv_prog_cc_c89+set}" = set; then : +if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no @@ -3369,8 +3394,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include -#include -#include +struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); @@ -3459,7 +3483,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` -if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\"" = set; then : +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF @@ -3503,7 +3527,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 $as_echo_n "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then -if test "${ac_cv_path_install+set}" = set; then : +if ${ac_cv_path_install+:} false; then : $as_echo_n "(cached) " >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3523,7 +3547,7 @@ case $as_dir/ in #(( # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then if test $ac_prog = install && grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. @@ -3583,7 +3607,7 @@ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' set dummy bison; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BISON+set}" = set; then : +if ${ac_cv_path_BISON+:} false; then : $as_echo_n "(cached) " >&6 else case $BISON in @@ -3597,7 +3621,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BISON="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3623,7 +3647,7 @@ fi set dummy flex; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FLEX+set}" = set; then : +if ${ac_cv_path_FLEX+:} false; then : $as_echo_n "(cached) " >&6 else case $FLEX in @@ -3637,7 +3661,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_FLEX="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3663,7 +3687,7 @@ fi set dummy perl; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PERL+set}" = set; then : +if ${ac_cv_path_PERL+:} false; then : $as_echo_n "(cached) " >&6 else case $PERL in @@ -3677,7 +3701,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PERL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3710,7 +3734,7 @@ if test "x$xapi" = "xy"; then : set dummy curl-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_CURL+set}" = set; then : +if ${ac_cv_path_CURL+:} false; then : $as_echo_n "(cached) " >&6 else case $CURL in @@ -3724,7 +3748,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_CURL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3755,7 +3779,7 @@ fi set dummy xml2-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_XML+set}" = set; then : +if ${ac_cv_path_XML+:} false; then : $as_echo_n "(cached) " >&6 else case $XML in @@ -3769,7 +3793,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_XML="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3806,7 +3830,7 @@ if test "x$ocamltools" = "xy"; then : set dummy ${ac_tool_prefix}ocamlc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLC+set}" = set; then : +if ${ac_cv_prog_OCAMLC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLC"; then @@ -3818,7 +3842,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLC="${ac_tool_prefix}ocamlc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3846,7 +3870,7 @@ if test -z "$ac_cv_prog_OCAMLC"; then set dummy ocamlc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLC+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLC"; then @@ -3858,7 +3882,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLC="ocamlc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3917,7 +3941,7 @@ $as_echo "OCaml library path is $OCAMLLIB" >&6; } set dummy ${ac_tool_prefix}ocamlopt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPT"; then @@ -3929,7 +3953,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPT="${ac_tool_prefix}ocamlopt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -3957,7 +3981,7 @@ if test -z "$ac_cv_prog_OCAMLOPT"; then set dummy ocamlopt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLOPT"; then @@ -3969,7 +3993,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPT="ocamlopt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4027,7 +4051,7 @@ $as_echo "versions differs from ocamlc; ocamlopt discarded." >&6; } set dummy ${ac_tool_prefix}ocamlc.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLCDOTOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLCDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLCDOTOPT"; then @@ -4039,7 +4063,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLCDOTOPT="${ac_tool_prefix}ocamlc.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4067,7 +4091,7 @@ if test -z "$ac_cv_prog_OCAMLCDOTOPT"; then set dummy ocamlc.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLCDOTOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLCDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLCDOTOPT"; then @@ -4079,7 +4103,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLCDOTOPT="ocamlc.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4131,7 +4155,7 @@ $as_echo "versions differs from ocamlc; ocamlc.opt discarded." >&6; } set dummy ${ac_tool_prefix}ocamlopt.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLOPTDOTOPT+set}" = set; then : +if ${ac_cv_prog_OCAMLOPTDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLOPTDOTOPT"; then @@ -4143,7 +4167,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLOPTDOTOPT="${ac_tool_prefix}ocamlopt.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4171,7 +4195,7 @@ if test -z "$ac_cv_prog_OCAMLOPTDOTOPT"; then set dummy ocamlopt.opt; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLOPTDOTOPT+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLOPTDOTOPT+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLOPTDOTOPT"; then @@ -4183,7 +4207,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLOPTDOTOPT="ocamlopt.opt" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4240,7 +4264,7 @@ $as_echo "version differs from ocamlc; ocamlopt.opt discarded." >&6; } set dummy ${ac_tool_prefix}ocaml; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAML+set}" = set; then : +if ${ac_cv_prog_OCAML+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAML"; then @@ -4252,7 +4276,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAML="${ac_tool_prefix}ocaml" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4280,7 +4304,7 @@ if test -z "$ac_cv_prog_OCAML"; then set dummy ocaml; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAML+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAML+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAML"; then @@ -4292,7 +4316,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAML="ocaml" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4334,7 +4358,7 @@ fi set dummy ${ac_tool_prefix}ocamldep; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLDEP+set}" = set; then : +if ${ac_cv_prog_OCAMLDEP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDEP"; then @@ -4346,7 +4370,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDEP="${ac_tool_prefix}ocamldep" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4374,7 +4398,7 @@ if test -z "$ac_cv_prog_OCAMLDEP"; then set dummy ocamldep; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLDEP+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLDEP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLDEP"; then @@ -4386,7 +4410,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDEP="ocamldep" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4428,7 +4452,7 @@ fi set dummy ${ac_tool_prefix}ocamlmktop; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLMKTOP+set}" = set; then : +if ${ac_cv_prog_OCAMLMKTOP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLMKTOP"; then @@ -4440,7 +4464,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKTOP="${ac_tool_prefix}ocamlmktop" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4468,7 +4492,7 @@ if test -z "$ac_cv_prog_OCAMLMKTOP"; then set dummy ocamlmktop; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLMKTOP+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLMKTOP+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLMKTOP"; then @@ -4480,7 +4504,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKTOP="ocamlmktop" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4522,7 +4546,7 @@ fi set dummy ${ac_tool_prefix}ocamlmklib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLMKLIB+set}" = set; then : +if ${ac_cv_prog_OCAMLMKLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLMKLIB"; then @@ -4534,7 +4558,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLMKLIB="${ac_tool_prefix}ocamlmklib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4562,7 +4586,7 @@ if test -z "$ac_cv_prog_OCAMLMKLIB"; then set dummy ocamlmklib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLMKLIB+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLMKLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLMKLIB"; then @@ -4574,7 +4598,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLMKLIB="ocamlmklib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4616,7 +4640,7 @@ fi set dummy ${ac_tool_prefix}ocamldoc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLDOC+set}" = set; then : +if ${ac_cv_prog_OCAMLDOC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLDOC"; then @@ -4628,7 +4652,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLDOC="${ac_tool_prefix}ocamldoc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4656,7 +4680,7 @@ if test -z "$ac_cv_prog_OCAMLDOC"; then set dummy ocamldoc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLDOC+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLDOC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLDOC"; then @@ -4668,7 +4692,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLDOC="ocamldoc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4710,7 +4734,7 @@ fi set dummy ${ac_tool_prefix}ocamlbuild; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_OCAMLBUILD+set}" = set; then : +if ${ac_cv_prog_OCAMLBUILD+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$OCAMLBUILD"; then @@ -4722,7 +4746,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_OCAMLBUILD="${ac_tool_prefix}ocamlbuild" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4750,7 +4774,7 @@ if test -z "$ac_cv_prog_OCAMLBUILD"; then set dummy ocamlbuild; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_prog_ac_ct_OCAMLBUILD+set}" = set; then : +if ${ac_cv_prog_ac_ct_OCAMLBUILD+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_OCAMLBUILD"; then @@ -4762,7 +4786,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OCAMLBUILD="ocamlbuild" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4813,7 +4837,7 @@ fi set dummy bash; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BASH+set}" = set; then : +if ${ac_cv_path_BASH+:} false; then : $as_echo_n "(cached) " >&6 else case $BASH in @@ -4827,7 +4851,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4868,7 +4892,7 @@ fi set dummy $PYTHON; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PYTHONPATH+set}" = set; then : +if ${ac_cv_path_PYTHONPATH+:} false; then : $as_echo_n "(cached) " >&6 else case $PYTHONPATH in @@ -4882,7 +4906,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PYTHONPATH="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -4935,7 +4959,7 @@ if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then - if test "${ac_cv_prog_CPP+set}" = set; then : + if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded @@ -5051,7 +5075,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c @@ -5063,7 +5087,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if test "${ac_cv_path_GREP+set}" = set; then : +if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then @@ -5077,7 +5101,7 @@ do for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue + as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in @@ -5126,7 +5150,7 @@ $as_echo "$ac_cv_path_GREP" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } -if test "${ac_cv_path_EGREP+set}" = set; then : +if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 @@ -5143,7 +5167,7 @@ do for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue + as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in @@ -5193,7 +5217,7 @@ $as_echo "$ac_cv_path_EGREP" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } -if test "${ac_cv_header_stdc+set}" = set; then : +if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -5329,7 +5353,7 @@ ac_python_version=`$PYTHON -c 'import distutils.sysconfig; \ set dummy $PYTHON-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_pyconfig+set}" = set; then : +if ${ac_cv_path_pyconfig+:} false; then : $as_echo_n "(cached) " >&6 else case $pyconfig in @@ -5343,7 +5367,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_pyconfig="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5392,7 +5416,7 @@ else fi ac_fn_c_check_header_mongrel "$LINENO" "Python.h" "ac_cv_header_Python_h" "$ac_includes_default" -if test "x$ac_cv_header_Python_h" = x""yes; then : +if test "x$ac_cv_header_Python_h" = xyes; then : else as_fn_error $? "Unable to find Python development headers" "$LINENO" 5 @@ -5402,7 +5426,7 @@ fi as_ac_Lib=`$as_echo "ac_cv_lib_python$ac_python_version''_PyArg_ParseTuple" | $as_tr_sh` { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PyArg_ParseTuple in -lpython$ac_python_version" >&5 $as_echo_n "checking for PyArg_ParseTuple in -lpython$ac_python_version... " >&6; } -if eval "test \"\${$as_ac_Lib+set}\"" = set; then : +if eval \${$as_ac_Lib+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5455,7 +5479,7 @@ LDLFAGS=$ac_previous_ldflags set dummy xgettext; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_XGETTEXT+set}" = set; then : +if ${ac_cv_path_XGETTEXT+:} false; then : $as_echo_n "(cached) " >&6 else case $XGETTEXT in @@ -5469,7 +5493,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_XGETTEXT="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5502,7 +5526,7 @@ i[3456]86|x86_64) set dummy as86; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_AS86+set}" = set; then : +if ${ac_cv_path_AS86+:} false; then : $as_echo_n "(cached) " >&6 else case $AS86 in @@ -5516,7 +5540,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_AS86="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5547,7 +5571,7 @@ fi set dummy ld86; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_LD86+set}" = set; then : +if ${ac_cv_path_LD86+:} false; then : $as_echo_n "(cached) " >&6 else case $LD86 in @@ -5561,7 +5585,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_LD86="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5592,7 +5616,7 @@ fi set dummy bcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_BCC+set}" = set; then : +if ${ac_cv_path_BCC+:} false; then : $as_echo_n "(cached) " >&6 else case $BCC in @@ -5606,7 +5630,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_BCC="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5637,7 +5661,7 @@ fi set dummy iasl; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_IASL+set}" = set; then : +if ${ac_cv_path_IASL+:} false; then : $as_echo_n "(cached) " >&6 else case $IASL in @@ -5651,7 +5675,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_IASL="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5682,11 +5706,11 @@ fi esac ac_fn_c_check_header_mongrel "$LINENO" "uuid/uuid.h" "ac_cv_header_uuid_uuid_h" "$ac_includes_default" -if test "x$ac_cv_header_uuid_uuid_h" = x""yes; then : +if test "x$ac_cv_header_uuid_uuid_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uuid_clear in -luuid" >&5 $as_echo_n "checking for uuid_clear in -luuid... " >&6; } -if test "${ac_cv_lib_uuid_uuid_clear+set}" = set; then : +if ${ac_cv_lib_uuid_uuid_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5720,7 +5744,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_uuid_uuid_clear" >&5 $as_echo "$ac_cv_lib_uuid_uuid_clear" >&6; } -if test "x$ac_cv_lib_uuid_uuid_clear" = x""yes; then : +if test "x$ac_cv_lib_uuid_uuid_clear" = xyes; then : libuuid="y" fi @@ -5729,7 +5753,7 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "uuid.h" "ac_cv_header_uuid_h" "$ac_includes_default" -if test "x$ac_cv_header_uuid_h" = x""yes; then : +if test "x$ac_cv_header_uuid_h" = xyes; then : libuuid="y" fi @@ -5742,11 +5766,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "curses.h" "ac_cv_header_curses_h" "$ac_includes_default" -if test "x$ac_cv_header_curses_h" = x""yes; then : +if test "x$ac_cv_header_curses_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clear in -lcurses" >&5 $as_echo_n "checking for clear in -lcurses... " >&6; } -if test "${ac_cv_lib_curses_clear+set}" = set; then : +if ${ac_cv_lib_curses_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5780,7 +5804,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_curses_clear" >&5 $as_echo "$ac_cv_lib_curses_clear" >&6; } -if test "x$ac_cv_lib_curses_clear" = x""yes; then : +if test "x$ac_cv_lib_curses_clear" = xyes; then : curses="y" else curses="n" @@ -5793,11 +5817,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ncurses.h" "ac_cv_header_ncurses_h" "$ac_includes_default" -if test "x$ac_cv_header_ncurses_h" = x""yes; then : +if test "x$ac_cv_header_ncurses_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clear in -lncurses" >&5 $as_echo_n "checking for clear in -lncurses... " >&6; } -if test "${ac_cv_lib_ncurses_clear+set}" = set; then : +if ${ac_cv_lib_ncurses_clear+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -5831,7 +5855,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ncurses_clear" >&5 $as_echo "$ac_cv_lib_ncurses_clear" >&6; } -if test "x$ac_cv_lib_ncurses_clear" = x""yes; then : +if test "x$ac_cv_lib_ncurses_clear" = xyes; then : ncurses="y" else ncurses="n" @@ -5878,7 +5902,7 @@ if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_PKG_CONFIG+set}" = set; then : +if ${ac_cv_path_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $PKG_CONFIG in @@ -5892,7 +5916,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -5921,7 +5945,7 @@ if test -z "$ac_cv_path_PKG_CONFIG"; then set dummy pkg-config; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then : +if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then : $as_echo_n "(cached) " >&6 else case $ac_pt_PKG_CONFIG in @@ -5935,7 +5959,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6026,7 +6050,7 @@ fi if test $pkg_failed = yes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then @@ -6053,7 +6077,7 @@ Alternatively, you may set the environment variables glib_CFLAGS and glib_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details." "$LINENO" 5 elif test $pkg_failed = untried; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} @@ -6066,7 +6090,7 @@ and glib_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } else glib_CFLAGS=$pkg_cv_glib_CFLAGS glib_LIBS=$pkg_cv_glib_LIBS @@ -6079,7 +6103,7 @@ fi set dummy wget; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_WGET+set}" = set; then : +if ${ac_cv_path_WGET+:} false; then : $as_echo_n "(cached) " >&6 else case $WGET in @@ -6093,7 +6117,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_WGET="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6126,7 +6150,7 @@ else set dummy ftp; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } -if test "${ac_cv_path_FTP+set}" = set; then : +if ${ac_cv_path_FTP+:} false; then : $as_echo_n "(cached) " >&6 else case $FTP in @@ -6140,7 +6164,7 @@ do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_path_FTP="$as_dir/$ac_word$ac_exec_ext" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 @@ -6179,11 +6203,11 @@ fi # Checks for libraries. ac_fn_c_check_header_mongrel "$LINENO" "bzlib.h" "ac_cv_header_bzlib_h" "$ac_includes_default" -if test "x$ac_cv_header_bzlib_h" = x""yes; then : +if test "x$ac_cv_header_bzlib_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BZ2_bzDecompressInit in -lbz2" >&5 $as_echo_n "checking for BZ2_bzDecompressInit in -lbz2... " >&6; } -if test "${ac_cv_lib_bz2_BZ2_bzDecompressInit+set}" = set; then : +if ${ac_cv_lib_bz2_BZ2_bzDecompressInit+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6217,7 +6241,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bz2_BZ2_bzDecompressInit" >&5 $as_echo "$ac_cv_lib_bz2_BZ2_bzDecompressInit" >&6; } -if test "x$ac_cv_lib_bz2_BZ2_bzDecompressInit" = x""yes; then : +if test "x$ac_cv_lib_bz2_BZ2_bzDecompressInit" = xyes; then : zlib="$zlib -DHAVE_BZLIB -lbz2" fi @@ -6226,11 +6250,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "lzma.h" "ac_cv_header_lzma_h" "$ac_includes_default" -if test "x$ac_cv_header_lzma_h" = x""yes; then : +if test "x$ac_cv_header_lzma_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lzma_stream_decoder in -llzma" >&5 $as_echo_n "checking for lzma_stream_decoder in -llzma... " >&6; } -if test "${ac_cv_lib_lzma_lzma_stream_decoder+set}" = set; then : +if ${ac_cv_lib_lzma_lzma_stream_decoder+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6264,7 +6288,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lzma_lzma_stream_decoder" >&5 $as_echo "$ac_cv_lib_lzma_lzma_stream_decoder" >&6; } -if test "x$ac_cv_lib_lzma_lzma_stream_decoder" = x""yes; then : +if test "x$ac_cv_lib_lzma_lzma_stream_decoder" = xyes; then : zlib="$zlib -DHAVE_LZMA -llzma" fi @@ -6273,11 +6297,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "lzo/lzo1x.h" "ac_cv_header_lzo_lzo1x_h" "$ac_includes_default" -if test "x$ac_cv_header_lzo_lzo1x_h" = x""yes; then : +if test "x$ac_cv_header_lzo_lzo1x_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for lzo1x_decompress in -llzo2" >&5 $as_echo_n "checking for lzo1x_decompress in -llzo2... " >&6; } -if test "${ac_cv_lib_lzo2_lzo1x_decompress+set}" = set; then : +if ${ac_cv_lib_lzo2_lzo1x_decompress+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6311,7 +6335,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_lzo2_lzo1x_decompress" >&5 $as_echo "$ac_cv_lib_lzo2_lzo1x_decompress" >&6; } -if test "x$ac_cv_lib_lzo2_lzo1x_decompress" = x""yes; then : +if test "x$ac_cv_lib_lzo2_lzo1x_decompress" = xyes; then : zlib="$zlib -DHAVE_LZO1X -llzo2" fi @@ -6322,7 +6346,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for io_setup in -laio" >&5 $as_echo_n "checking for io_setup in -laio... " >&6; } -if test "${ac_cv_lib_aio_io_setup+set}" = set; then : +if ${ac_cv_lib_aio_io_setup+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6356,7 +6380,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_aio_io_setup" >&5 $as_echo "$ac_cv_lib_aio_io_setup" >&6; } -if test "x$ac_cv_lib_aio_io_setup" = x""yes; then : +if test "x$ac_cv_lib_aio_io_setup" = xyes; then : system_aio="y" else system_aio="n" @@ -6365,7 +6389,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MD5 in -lcrypto" >&5 $as_echo_n "checking for MD5 in -lcrypto... " >&6; } -if test "${ac_cv_lib_crypto_MD5+set}" = set; then : +if ${ac_cv_lib_crypto_MD5+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6399,7 +6423,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_crypto_MD5" >&5 $as_echo "$ac_cv_lib_crypto_MD5" >&6; } -if test "x$ac_cv_lib_crypto_MD5" = x""yes; then : +if test "x$ac_cv_lib_crypto_MD5" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBCRYPTO 1 _ACEOF @@ -6412,11 +6436,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ext2fs/ext2fs.h" "ac_cv_header_ext2fs_ext2fs_h" "$ac_includes_default" -if test "x$ac_cv_header_ext2fs_ext2fs_h" = x""yes; then : +if test "x$ac_cv_header_ext2fs_ext2fs_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ext2fs_open2 in -lext2fs" >&5 $as_echo_n "checking for ext2fs_open2 in -lext2fs... " >&6; } -if test "${ac_cv_lib_ext2fs_ext2fs_open2+set}" = set; then : +if ${ac_cv_lib_ext2fs_ext2fs_open2+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6450,7 +6474,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ext2fs_ext2fs_open2" >&5 $as_echo "$ac_cv_lib_ext2fs_ext2fs_open2" >&6; } -if test "x$ac_cv_lib_ext2fs_ext2fs_open2" = x""yes; then : +if test "x$ac_cv_lib_ext2fs_ext2fs_open2" = xyes; then : $as_echo "#define INCLUDE_EXTFS_H " >>confdefs.h @@ -6464,11 +6488,11 @@ fi ac_fn_c_check_header_mongrel "$LINENO" "ext4fs/ext2fs.h" "ac_cv_header_ext4fs_ext2fs_h" "$ac_includes_default" -if test "x$ac_cv_header_ext4fs_ext2fs_h" = x""yes; then : +if test "x$ac_cv_header_ext4fs_ext2fs_h" = xyes; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ext2fs_open2 in -lext4fs" >&5 $as_echo_n "checking for ext2fs_open2 in -lext4fs... " >&6; } -if test "${ac_cv_lib_ext4fs_ext2fs_open2+set}" = set; then : +if ${ac_cv_lib_ext4fs_ext2fs_open2+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6502,7 +6526,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ext4fs_ext2fs_open2" >&5 $as_echo "$ac_cv_lib_ext4fs_ext2fs_open2" >&6; } -if test "x$ac_cv_lib_ext4fs_ext2fs_open2" = x""yes; then : +if test "x$ac_cv_lib_ext4fs_ext2fs_open2" = xyes; then : $as_echo "#define INCLUDE_EXTFS_H " >>confdefs.h @@ -6519,7 +6543,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gcry_md_hash_buffer in -lgcrypt" >&5 $as_echo_n "checking for gcry_md_hash_buffer in -lgcrypt... " >&6; } -if test "${ac_cv_lib_gcrypt_gcry_md_hash_buffer+set}" = set; then : +if ${ac_cv_lib_gcrypt_gcry_md_hash_buffer+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6553,7 +6577,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gcrypt_gcry_md_hash_buffer" >&5 $as_echo "$ac_cv_lib_gcrypt_gcry_md_hash_buffer" >&6; } -if test "x$ac_cv_lib_gcrypt_gcry_md_hash_buffer" = x""yes; then : +if test "x$ac_cv_lib_gcrypt_gcry_md_hash_buffer" = xyes; then : libgcrypt="y" else libgcrypt="n" @@ -6563,7 +6587,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread flag" >&5 $as_echo_n "checking for pthread flag... " >&6; } -if test "${ax_cv_pthread_flags+set}" = set; then : +if ${ax_cv_pthread_flags+:} false; then : $as_echo_n "(cached) " >&6 else @@ -6631,7 +6655,7 @@ $as_echo "$ax_cv_pthread_flags" >&6; } CPPFLAGS="$CPPFLAGS -Werror" ac_fn_c_check_header_mongrel "$LINENO" "libutil.h" "ac_cv_header_libutil_h" "$ac_includes_default" -if test "x$ac_cv_header_libutil_h" = x""yes; then : +if test "x$ac_cv_header_libutil_h" = xyes; then : $as_echo "#define INCLUDE_LIBUTIL_H " >>confdefs.h @@ -6645,7 +6669,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for openpty et al" >&5 $as_echo_n "checking for openpty et al... " >&6; } -if test "${ax_cv_ptyfuncs_libs+set}" = set; then : +if ${ax_cv_ptyfuncs_libs+:} false; then : $as_echo_n "(cached) " >&6 else @@ -6654,7 +6678,7 @@ else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "Unable to find library for openpty and login_tty -See \`config.log' for more details" "$LINENO" 5 ; } +See \`config.log' for more details" "$LINENO" 5; } fi saved_LIBS="$LIBS" @@ -6692,7 +6716,7 @@ $as_echo "$ax_cv_ptyfuncs_libs" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for yajl_alloc in -lyajl" >&5 $as_echo_n "checking for yajl_alloc in -lyajl... " >&6; } -if test "${ac_cv_lib_yajl_yajl_alloc+set}" = set; then : +if ${ac_cv_lib_yajl_yajl_alloc+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6726,7 +6750,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_yajl_yajl_alloc" >&5 $as_echo "$ac_cv_lib_yajl_yajl_alloc" >&6; } -if test "x$ac_cv_lib_yajl_yajl_alloc" = x""yes; then : +if test "x$ac_cv_lib_yajl_yajl_alloc" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBYAJL 1 _ACEOF @@ -6739,7 +6763,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for deflateCopy in -lz" >&5 $as_echo_n "checking for deflateCopy in -lz... " >&6; } -if test "${ac_cv_lib_z_deflateCopy+set}" = set; then : +if ${ac_cv_lib_z_deflateCopy+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6773,7 +6797,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_deflateCopy" >&5 $as_echo "$ac_cv_lib_z_deflateCopy" >&6; } -if test "x$ac_cv_lib_z_deflateCopy" = x""yes; then : +if test "x$ac_cv_lib_z_deflateCopy" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBZ 1 _ACEOF @@ -6786,7 +6810,7 @@ fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for libiconv_open in -liconv" >&5 $as_echo_n "checking for libiconv_open in -liconv... " >&6; } -if test "${ac_cv_lib_iconv_libiconv_open+set}" = set; then : +if ${ac_cv_lib_iconv_libiconv_open+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS @@ -6820,7 +6844,7 @@ LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_iconv_libiconv_open" >&5 $as_echo "$ac_cv_lib_iconv_libiconv_open" >&6; } -if test "x$ac_cv_lib_iconv_libiconv_open" = x""yes; then : +if test "x$ac_cv_lib_iconv_libiconv_open" = xyes; then : libiconv="y" else libiconv="n" @@ -6832,7 +6856,7 @@ fi for ac_header in yajl/yajl_version.h do : ac_fn_c_check_header_mongrel "$LINENO" "yajl/yajl_version.h" "ac_cv_header_yajl_yajl_version_h" "$ac_includes_default" -if test "x$ac_cv_header_yajl_yajl_version_h" = x""yes; then : +if test "x$ac_cv_header_yajl_yajl_version_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_YAJL_YAJL_VERSION_H 1 _ACEOF @@ -6906,10 +6930,21 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then - test "x$cache_file" != "x/dev/null" && + if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} - cat confcache >$cache_file + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} @@ -6941,7 +6976,7 @@ LTLIBOBJS=$ac_ltlibobjs -: ${CONFIG_STATUS=./config.status} +: "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" @@ -7042,6 +7077,7 @@ fi IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. +as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7237,16 +7273,16 @@ if (echo >conf$$.file) 2>/dev/null; then # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. + # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' + as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi else - as_ln_s='cp -p' + as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null @@ -7306,28 +7342,16 @@ else as_mkdir_p=false fi -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in #( - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" @@ -7348,8 +7372,8 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by Xen Hypervisor $as_me 4.3, which was -generated by GNU Autoconf 2.67. Invocation command line was +This file was extended by Xen Hypervisor Tools $as_me 4.3, which was +generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -7405,17 +7429,17 @@ Configuration headers: $config_headers Report bugs to . -Xen Hypervisor home page: ." +Xen Hypervisor Tools home page: ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -Xen Hypervisor config.status 4.3 -configured by $0, generated by GNU Autoconf 2.67, +Xen Hypervisor Tools config.status 4.3 +configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" -Copyright (C) 2010 Free Software Foundation, Inc. +Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -7504,7 +7528,7 @@ fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then - set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' @@ -7536,7 +7560,7 @@ do "../config/Tools.mk") CONFIG_FILES="$CONFIG_FILES ../config/Tools.mk" ;; "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; - *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;; + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done @@ -7558,9 +7582,10 @@ fi # after its creation but before its name has been assigned to `$tmp'. $debug || { - tmp= + tmp= ac_tmp= trap 'exit_status=$? - { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } @@ -7568,12 +7593,13 @@ $debug || { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && - test -n "$tmp" && test -d "$tmp" + test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. @@ -7595,7 +7621,7 @@ else ac_cs_awk_cr=$ac_cr fi -echo 'BEGIN {' >"$tmp/subs1.awk" && +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF @@ -7623,7 +7649,7 @@ done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 -cat >>"\$tmp/subs1.awk" <<\\_ACAWK && +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h @@ -7671,7 +7697,7 @@ t delim rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK -cat >>"\$tmp/subs1.awk" <<_ACAWK && +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" @@ -7703,7 +7729,7 @@ if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat -fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF @@ -7737,7 +7763,7 @@ fi # test -n "$CONFIG_FILES" # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then -cat >"$tmp/defines.awk" <<\_ACAWK || +cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF @@ -7749,8 +7775,8 @@ _ACEOF # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do - ac_t=`sed -n "/$ac_delim/p" confdefs.h` - if test -z "$ac_t"; then + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 @@ -7851,7 +7877,7 @@ do esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -7870,7 +7896,7 @@ do for ac_f do case $ac_f in - -) ac_f="$tmp/stdin";; + -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. @@ -7879,7 +7905,7 @@ do [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;; + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" @@ -7905,8 +7931,8 @@ $as_echo "$as_me: creating $ac_file" >&6;} esac case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin" \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac @@ -8036,21 +8062,22 @@ s&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t $ac_datarootdir_hack " -eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ - || as_fn_error $? "could not create $ac_file" "$LINENO" 5 +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && - { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && - { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} - rm -f "$tmp/stdin" + rm -f "$ac_tmp/stdin" case $ac_file in - -) cat "$tmp/out" && rm -f "$tmp/out";; - *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; @@ -8061,20 +8088,20 @@ which seems to be undefined. Please make sure it is defined" >&2;} if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" - } >"$tmp/config.h" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 - if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" - mv "$tmp/config.h" "$ac_file" \ + mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ - && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; diff --git a/tools/configure.ac b/tools/configure.ac index 971e3e9..9924852 100644 --- a/tools/configure.ac +++ b/tools/configure.ac @@ -2,7 +2,7 @@ # Process this file with autoconf to produce a configure script. AC_PREREQ([2.67]) -AC_INIT([Xen Hypervisor], m4_esyscmd([../version.sh ../xen/Makefile]), +AC_INIT([Xen Hypervisor Tools], m4_esyscmd([../version.sh ../xen/Makefile]), [xen-devel@lists.xen.org], [xen], [http://www.xen.org/]) AC_CONFIG_SRCDIR([libxl/libxl.c]) AC_CONFIG_FILES([../config/Tools.mk]) -- 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 Thu Nov 29 17:36:34 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 29 Nov 2012 17:36:34 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te82H-00084w-QG; Thu, 29 Nov 2012 17:36:29 +0000 Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te82F-000832-9x for xen-devel@lists.xen.org; Thu, 29 Nov 2012 17:36:28 +0000 Received: from [193.109.254.147:65298] by server-2.bemta-14.messagelabs.com id C5/A0-20829-91D97B05; Thu, 29 Nov 2012 17:36:25 +0000 X-Env-Sender: matthew.fioravante@jhuapl.edu X-Msg-Ref: server-6.tower-27.messagelabs.com!1354210557!3163192!1 X-Originating-IP: [128.244.251.36] X-SpamReason: No, hits=0.5 required=7.0 tests=BODY_RANDOM_LONG, ML_RADAR_SPEW_LINKS_23, SUBJECT_EXCESS_QP, UNPARSEABLE_RELAY, spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 28161 invoked from network); 29 Nov 2012 17:36:06 -0000 Received: from pilot.jhuapl.edu (HELO jhuapl.edu) (128.244.251.36) by server-6.tower-27.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 29 Nov 2012 17:36:06 -0000 Received: from ([128.244.206.185]) by pilot.jhuapl.edu with ESMTP with TLS id 63GHCH1.158386750; Thu, 29 Nov 2012 12:35:48 -0500 From: Matthew Fioravante To: xen-devel@lists.xen.org, Ian.Jackson@eu.citrix.com, Ian.Campbell@citrix.com Date: Thu, 29 Nov 2012 12:35:33 -0500 Message-Id: <1354210534-31052-7-git-send-email-matthew.fioravante@jhuapl.edu> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> References: <1354210534-31052-1-git-send-email-matthew.fioravante@jhuapl.edu> MIME-Version: 1.0 Cc: Matthew Fioravante Subject: [Xen-devel] =?utf-8?q?=5BVTPM_v5_6/7=5D_Add_autoconf_to_stubdom?= 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="utf-8" Content-Transfer-Encoding: base64 Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org U2lnbmVkLW9mZi1ieTogTWF0dGhldyBGaW9yYXZhbnRlIDxtYXR0aGV3LmZpb3JhdmFudGVAamh1 YXBsLmVkdT4KLS0tCiBhdXRvZ2VuLnNoICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIGNv bmZpZy9TdHViZG9tLm1rLmluICAgICAgICAgICB8ICAgNDQgKwogbTQvY3Vyc2VzLm00ICAgICAg ICAgICAgICAgICAgIHwgICAyMCArCiBtNC9leHRmcy5tNCAgICAgICAgICAgICAgICAgICAgfCAg IDIwICsKIG00L2ZlYXR1cmVzLm00ICAgICAgICAgICAgICAgICB8ICAgMjEgKwogbTQvZmV0Y2hl ci5tNCAgICAgICAgICAgICAgICAgIHwgICAxNCArCiBtNC9vY2FtbC5tNCAgICAgICAgICAgICAg ICAgICAgfCAgMjQxICsrKwogbTQvcGF0aF9vcl9mYWlsLm00ICAgICAgICAgICAgIHwgICAxMyAr CiBtNC9wa2cubTQgICAgICAgICAgICAgICAgICAgICAgfCAgMTU3ICsrCiBtNC9wdGhyZWFkLm00 ICAgICAgICAgICAgICAgICAgfCAgIDQxICsKIG00L3B0eWZ1bmNzLm00ICAgICAgICAgICAgICAg ICB8ICAgMzUgKwogbTQvcHl0aG9uX2RldmVsLm00ICAgICAgICAgICAgIHwgICAzNiArCiBtNC9w eXRob25fdmVyc2lvbi5tNCAgICAgICAgICAgfCAgIDEyICsKIG00L3NhdmV2YXIubTQgICAgICAg ICAgICAgICAgICB8ICAgIDYgKwogbTQvc2V0X2NmbGFnc19sZGZsYWdzLm00ICAgICAgIHwgICAx OSArCiBtNC9zdHViZG9tLm00ICAgICAgICAgICAgICAgICAgfCAgIDYzICsKIG00L3V1aWQubTQg ICAgICAgICAgICAgICAgICAgICB8ICAgIDkgKwogc3R1YmRvbS9NYWtlZmlsZSAgICAgICAgICAg ICAgIHwgICA0OCArLQogc3R1YmRvbS9jb25maWd1cmUgICAgICAgICAgICAgIHwgNDM3MCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBzdHViZG9tL2NvbmZpZ3VyZS5h YyAgICAgICAgICAgfCAgIDU0ICsKIHN0dWJkb20vaW5zdGFsbC5zaCAgICAgICAgICAgICB8ICAg IDEgKwogdG9vbHMvY29uZmlndXJlICAgICAgICAgICAgICAgIHwgICAgMiArCiB0b29scy9jb25m aWd1cmUuYWMgICAgICAgICAgICAgfCAgIDI4ICstCiB0b29scy9tNC9jdXJzZXMubTQgICAgICAg ICAgICAgfCAgIDIwIC0KIHRvb2xzL200L2V4dGZzLm00ICAgICAgICAgICAgICB8ICAgMjAgLQog dG9vbHMvbTQvZmVhdHVyZXMubTQgICAgICAgICAgIHwgICAyMSAtCiB0b29scy9tNC9mZXRjaGVy Lm00ICAgICAgICAgICAgfCAgIDE0IC0KIHRvb2xzL200L29jYW1sLm00ICAgICAgICAgICAgICB8 ICAyNDEgLS0tCiB0b29scy9tNC9wYXRoX29yX2ZhaWwubTQgICAgICAgfCAgICA2IC0KIHRvb2xz L200L3BrZy5tNCAgICAgICAgICAgICAgICB8ICAxNTcgLS0KIHRvb2xzL200L3B0aHJlYWQubTQg ICAgICAgICAgICB8ICAgNDEgLQogdG9vbHMvbTQvcHR5ZnVuY3MubTQgICAgICAgICAgIHwgICAz NSAtCiB0b29scy9tNC9weXRob25fZGV2ZWwubTQgICAgICAgfCAgIDM2IC0KIHRvb2xzL200L3B5 dGhvbl92ZXJzaW9uLm00ICAgICB8ICAgMTIgLQogdG9vbHMvbTQvc2F2ZXZhci5tNCAgICAgICAg ICAgIHwgICAgNiAtCiB0b29scy9tNC9zZXRfY2ZsYWdzX2xkZmxhZ3MubTQgfCAgIDIwIC0KIHRv b2xzL200L3V1aWQubTQgICAgICAgICAgICAgICB8ICAgIDkgLQogMzcgZmlsZXMgY2hhbmdlZCwg NTIwMCBpbnNlcnRpb25zKCspLCA2OTQgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQg Y29uZmlnL1N0dWJkb20ubWsuaW4KIGNyZWF0ZSBtb2RlIDEwMDY0NCBtNC9jdXJzZXMubTQKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBtNC9leHRmcy5tNAogY3JlYXRlIG1vZGUgMTAwNjQ0IG00L2ZlYXR1 cmVzLm00CiBjcmVhdGUgbW9kZSAxMDA2NDQgbTQvZmV0Y2hlci5tNAogY3JlYXRlIG1vZGUgMTAw NjQ0IG00L29jYW1sLm00CiBjcmVhdGUgbW9kZSAxMDA2NDQgbTQvcGF0aF9vcl9mYWlsLm00CiBj cmVhdGUgbW9kZSAxMDA2NDQgbTQvcGtnLm00CiBjcmVhdGUgbW9kZSAxMDA2NDQgbTQvcHRocmVh ZC5tNAogY3JlYXRlIG1vZGUgMTAwNjQ0IG00L3B0eWZ1bmNzLm00CiBjcmVhdGUgbW9kZSAxMDA2 NDQgbTQvcHl0aG9uX2RldmVsLm00CiBjcmVhdGUgbW9kZSAxMDA2NDQgbTQvcHl0aG9uX3ZlcnNp b24ubTQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBtNC9zYXZldmFyLm00CiBjcmVhdGUgbW9kZSAxMDA2 NDQgbTQvc2V0X2NmbGFnc19sZGZsYWdzLm00CiBjcmVhdGUgbW9kZSAxMDA2NDQgbTQvc3R1YmRv bS5tNAogY3JlYXRlIG1vZGUgMTAwNjQ0IG00L3V1aWQubTQKIGNyZWF0ZSBtb2RlIDEwMDc1NSBz dHViZG9tL2NvbmZpZ3VyZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHN0dWJkb20vY29uZmlndXJlLmFj CiBjcmVhdGUgbW9kZSAxMDA2NDQgc3R1YmRvbS9pbnN0YWxsLnNoCiBkZWxldGUgbW9kZSAxMDA2 NDQgdG9vbHMvbTQvY3Vyc2VzLm00CiBkZWxldGUgbW9kZSAxMDA2NDQgdG9vbHMvbTQvZXh0ZnMu bTQKIGRlbGV0ZSBtb2RlIDEwMDY0NCB0b29scy9tNC9mZWF0dXJlcy5tNAogZGVsZXRlIG1vZGUg MTAwNjQ0IHRvb2xzL200L2ZldGNoZXIubTQKIGRlbGV0ZSBtb2RlIDEwMDY0NCB0b29scy9tNC9v Y2FtbC5tNAogZGVsZXRlIG1vZGUgMTAwNjQ0IHRvb2xzL200L3BhdGhfb3JfZmFpbC5tNAogZGVs ZXRlIG1vZGUgMTAwNjQ0IHRvb2xzL200L3BrZy5tNAogZGVsZXRlIG1vZGUgMTAwNjQ0IHRvb2xz L200L3B0aHJlYWQubTQKIGRlbGV0ZSBtb2RlIDEwMDY0NCB0b29scy9tNC9wdHlmdW5jcy5tNAog ZGVsZXRlIG1vZGUgMTAwNjQ0IHRvb2xzL200L3B5dGhvbl9kZXZlbC5tNAogZGVsZXRlIG1vZGUg MTAwNjQ0IHRvb2xzL200L3B5dGhvbl92ZXJzaW9uLm00CiBkZWxldGUgbW9kZSAxMDA2NDQgdG9v bHMvbTQvc2F2ZXZhci5tNAogZGVsZXRlIG1vZGUgMTAwNjQ0IHRvb2xzL200L3NldF9jZmxhZ3Nf bGRmbGFncy5tNAogZGVsZXRlIG1vZGUgMTAwNjQ0IHRvb2xzL200L3V1aWQubTQKCmRpZmYgLS1n aXQgYS9hdXRvZ2VuLnNoIGIvYXV0b2dlbi5zaAppbmRleCA1OGE3MWNlLi5hZGE0ODJjIDEwMDc1 NQotLS0gYS9hdXRvZ2VuLnNoCisrKyBiL2F1dG9nZW4uc2gKQEAgLTIsMyArMiw1IEBACiBjZCB0 b29scwogYXV0b2NvbmYKIGF1dG9oZWFkZXIKK2NkIC4uL3N0dWJkb20KK2F1dG9jb25mCmRpZmYg LS1naXQgYS9jb25maWcvU3R1YmRvbS5tay5pbiBiL2NvbmZpZy9TdHViZG9tLm1rLmluCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQyNDU2YTkKLS0tIC9kZXYvbnVsbAorKysg Yi9jb25maWcvU3R1YmRvbS5tay5pbgpAQCAtMCwwICsxLDQ0IEBACisjIFByZWZpeCBhbmQgaW5z dGFsbCBmb2xkZXIKK3ByZWZpeCAgICAgICAgICAgICAgOj0gQHByZWZpeEAKK1BSRUZJWCAgICAg ICAgICAgICAgOj0gJChwcmVmaXgpCitleGVjX3ByZWZpeCAgICAgICAgIDo9IEBleGVjX3ByZWZp eEAKK2xpYmRpciAgICAgICAgICAgICAgOj0gQGxpYmRpckAKK0xJQkRJUiAgICAgICAgICAgICAg Oj0gJChsaWJkaXIpCisKKyMgUGF0aCBQcm9ncmFtcworQ01BS0UgICAgICAgICAgICAgICA6PSBA Q01BS0VACitXR0VUICAgICAgICAgICAgICAgIDo9IEBXR0VUQCAtYworCisjIEEgZGVidWcgYnVp bGQgb2Ygc3R1YmRvbT8gLy9GSVhNRTogU29tZW9uZSBtYWtlIHRoaXMgZG8gc29tZXRoaW5nCitk ZWJ1ZyAgICAgICAgICAgICAgIDo9IEBkZWJ1Z0AKKworU1RVQkRPTV9UQVJHRVRTICAgICA6PSBA U1RVQkRPTV9UQVJHRVRTQAorU1RVQkRPTV9CVUlMRCAgICAgICA6PSBAU1RVQkRPTV9CVUlMREAK K1NUVUJET01fSU5TVEFMTCAgICAgOj0gQFNUVUJET01fSU5TVEFMTEAKKworWkxJQl9WRVJTSU9O ICAgICAgICA6PSBAWkxJQl9WRVJTSU9OQAorWkxJQl9VUkwgICAgICAgICAgICA6PSBAWkxJQl9V UkxACisKK0xJQlBDSV9WRVJTSU9OICAgICAgOj0gQExJQlBDSV9WRVJTSU9OQAorTElCUENJX1VS TCAgICAgICAgICA6PSBATElCUENJX1VSTEAKKworTkVXTElCX1ZFUlNJT04gICAgICA6PSBATkVX TElCX1ZFUlNJT05ACitORVdMSUJfVVJMICAgICAgICAgIDo9IEBORVdMSUJfVVJMQAorCitMV0lQ X1ZFUlNJT04gICAgICAgIDo9IEBMV0lQX1ZFUlNJT05ACitMV0lQX1VSTCAgICAgICAgICAgIDo9 IEBMV0lQX1VSTEAKKworR1JVQl9WRVJTSU9OICAgICAgICA6PSBAR1JVQl9WRVJTSU9OQAorR1JV Ql9VUkwgICAgICAgICAgICA6PSBAR1JVQl9VUkxACisKK09DQU1MX1ZFUlNJT04gICAgICAgOj0g QE9DQU1MX1ZFUlNJT05ACitPQ0FNTF9VUkwgICAgICAgICAgIDo9IEBPQ0FNTF9VUkxACisKK0dN UF9WRVJTSU9OICAgICAgICAgOj0gQEdNUF9WRVJTSU9OQAorR01QX1VSTCAgICAgICAgICAgICA6 PSBAR01QX1VSTEAKKworUE9MQVJTU0xfVkVSU0lPTiAgICA6PSBAUE9MQVJTU0xfVkVSU0lPTkAK K1BPTEFSU1NMX1VSTCAgICAgICAgOj0gQFBPTEFSU1NMX1VSTEAKKworVFBNRU1VX1ZFUlNJT04g ICAgICA6PSBAVFBNRU1VX1ZFUlNJT05ACitUUE1FTVVfVVJMICAgICAgICAgIDo9IEBUUE1FTVVf VVJMQApkaWZmIC0tZ2l0IGEvbTQvY3Vyc2VzLm00IGIvbTQvY3Vyc2VzLm00Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMxZTQ4M2YKLS0tIC9kZXYvbnVsbAorKysgYi9tNC9j dXJzZXMubTQKQEAgLTAsMCArMSwyMCBAQAorQUNfREVGVU4oW0FYX0NIRUNLX0NVUlNFU10sIFsK K0FDX0NIRUNLX0hFQURFUihbY3Vyc2VzLmhdLCBbCisgICAgQUNfQ0hFQ0tfTElCKFtjdXJzZXNd LCBbY2xlYXJdLCBbY3Vyc2VzPSJ5Il0sIFtjdXJzZXM9Im4iXSkKK10sIFtjdXJzZXM9Im4iXSkK K0FDX0NIRUNLX0hFQURFUihbbmN1cnNlcy5oXSwgWworICAgIEFDX0NIRUNLX0xJQihbbmN1cnNl c10sIFtjbGVhcl0sIFtuY3Vyc2VzPSJ5Il0sIFtuY3Vyc2VzPSJuIl0pCitdLCBbbmN1cnNlcz0i biJdKQorQVNfSUYoW3Rlc3QgIiRjdXJzZXMiID0gIm4iICYmIHRlc3QgIiRuY3Vyc2VzIiA9ICJu Il0sIFsKKyAgICBBQ19NU0dfRVJST1IoW1VuYWJsZSB0byBmaW5kIGEgc3VpdGFibGUgY3Vyc2Vz IGxpYnJhcnldKQorXSkKKyMgUHJlZmVyIG5jdXJzZXMgb3ZlciBjdXJzZXMgaWYgYm90aCBhcmUg cHJlc2VudAorQVNfSUYoW3Rlc3QgIiRuY3Vyc2VzIiA9ICJ5Il0sIFsKKyAgICBDVVJTRVNfTElC Uz0iLWxuY3Vyc2VzIgorICAgIEFDX0RFRklORShbSU5DTFVERV9DVVJTRVNfSF0sIFs8bmN1cnNl cy5oPl0sIFtEZWZpbmUgY3Vyc2VzIGhlYWRlciB0byB1c2VdKQorXSwgWworICAgIENVUlNFU19M SUJTPSItbGN1cnNlcyIKKyAgICBBQ19ERUZJTkUoW0lOQ0xVREVfQ1VSU0VTX0hdLCBbPGN1cnNl cy5oPl0sIFtEZWZpbmUgY3Vyc2VzIGhlYWRlciB0byB1c2VdKQorXSkKK0FDX1NVQlNUKENVUlNF U19MSUJTKQorXSkKZGlmZiAtLWdpdCBhL200L2V4dGZzLm00IGIvbTQvZXh0ZnMubTQKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzMwOWRhOQotLS0gL2Rldi9udWxsCisrKyBi L200L2V4dGZzLm00CkBAIC0wLDAgKzEsMjAgQEAKK0FDX0RFRlVOKFtBWF9DSEVDS19FWFRGU10s IFsKK0FDX0NIRUNLX0hFQURFUihbZXh0MmZzL2V4dDJmcy5oXSwgWworQUNfQ0hFQ0tfTElCKFtl eHQyZnNdLCBbZXh0MmZzX29wZW4yXSwgWworICAgIEFDX0RFRklORShbSU5DTFVERV9FWFRGU19I XSwgWzxleHQyZnMvZXh0MmZzLmg+XSwKKyAgICAgICAgICAgICAgW0RlZmluZSBleHRmcyBoZWFk ZXIgdG8gdXNlXSkKKyAgICBFWFRGU19MSUJTPSItbGV4dDJmcyIKK10pCitdKQorZG5sIFRoaXMg aXMgYSB0ZW1wb3JhcnkgaGFjayBmb3IgQ2VudE9TIDUueCwgd2hpY2ggc3BsaXQgdGhlIGV4dDQg c3VwcG9ydAorZG5sIG9mIGV4dDJmcyBpbiBhIGRpZmZlcmVudCBwYWNrYWdlLiBPbmNlIENlbnRP UyA1LnggaXMgbm8gbG9uZ2VyIHN1cHBvcnRlZAorZG5sIHdlIGNhbiByZW1vdmUgdGhpcy4KK0FD X0NIRUNLX0hFQURFUihbZXh0NGZzL2V4dDJmcy5oXSwgWworQUNfQ0hFQ0tfTElCKFtleHQ0ZnNd LCBbZXh0MmZzX29wZW4yXSwgWworICAgIEFDX0RFRklORShbSU5DTFVERV9FWFRGU19IXSwgWzxl eHQ0ZnMvZXh0MmZzLmg+XSwKKyAgICAgICAgICAgICAgW0RlZmluZSBleHRmcyBoZWFkZXIgdG8g dXNlXSkKKyAgICBFWFRGU19MSUJTPSItbGV4dDRmcyIKK10pCitdKQorQUNfU1VCU1QoRVhURlNf TElCUykKK10pCmRpZmYgLS1naXQgYS9tNC9mZWF0dXJlcy5tNCBiL200L2ZlYXR1cmVzLm00Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJkNjcyYWIKLS0tIC9kZXYvbnVsbAor KysgYi9tNC9mZWF0dXJlcy5tNApAQCAtMCwwICsxLDIxIEBACitBQ19ERUZVTihbQVhfQVJHX0RF RkFVTFRfRU5BQkxFXSwgWworQUNfQVJHX0VOQUJMRShbJDFdLCBBU19IRUxQX1NUUklORyhbLS1k aXNhYmxlLSQxXSwgWyQyIChkZWZhdWx0IGlzIEVOQUJMRUQpXSkpCitBWF9QQVJTRV9WQUxVRShb JDFdLCBbeV0pCitdKQorCitBQ19ERUZVTihbQVhfQVJHX0RFRkFVTFRfRElTQUJMRV0sIFsKK0FD X0FSR19FTkFCTEUoWyQxXSwgQVNfSEVMUF9TVFJJTkcoWy0tZW5hYmxlLSQxXSwgWyQyIChkZWZh dWx0IGlzIERJU0FCTEVEKV0pKQorQVhfUEFSU0VfVkFMVUUoWyQxXSwgW25dKQorXSkKKworZG5s IFRoaXMgZnVuY3Rpb24gc2hvdWxkIG5vdCBiZSBjYWxsZWQgb3V0c2lkZSBvZiB0aGlzIGZpbGUK K0FDX0RFRlVOKFtBWF9QQVJTRV9WQUxVRV0sIFsKK0FTX0lGKFt0ZXN0ICJ4JGVuYWJsZV8kMSIg PSAieG5vIl0sIFsKKyAgICBheF9jdl8kMT0ibiIKK10sIFt0ZXN0ICJ4JGVuYWJsZV8kMSIgPSAi eHllcyJdLCBbCisgICAgYXhfY3ZfJDE9InkiCitdLCBbdGVzdCAteiAkYXhfY3ZfJDFdLCBbCisg ICAgYXhfY3ZfJDE9IiQyIgorXSkKKyQxPSRheF9jdl8kMQorQUNfU1VCU1QoJDEpXSkKZGlmZiAt LWdpdCBhL200L2ZldGNoZXIubTQgYi9tNC9mZXRjaGVyLm00Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjg2ZjMzYjMKLS0tIC9kZXYvbnVsbAorKysgYi9tNC9mZXRjaGVyLm00 CkBAIC0wLDAgKzEsMTQgQEAKK0FDX0RFRlVOKFtBWF9DSEVDS19GRVRDSEVSXSwgWworQUNfUEFU SF9QUk9HKFtXR0VUXSxbd2dldF0sIFtub10pCitBU19JRihbdGVzdCB4IiRXR0VUIiAhPSB4Im5v Il0sIFsKKyAgICBGRVRDSEVSPSIkV0dFVCAtYyAtTyIKK10sIFsKKyAgICBBQ19QQVRIX1BST0co W0ZUUF0sW2Z0cF0sIFtub10pCisgICAgQVNfSUYoW3Rlc3QgeCIkRlRQIiAhPSB4Im5vIl0sIFsK KyAgICAgICAgRkVUQ0hFUj0iJEZUUCAtbyIKKyAgICBdLCBbCisgICAgICAgIEFDX01TR19FUlJP UihbY2Fubm90IGZpbmQgd2dldCBvciBmdHBdKQorICAgIF0pCitdKQorQUNfU1VCU1QoRkVUQ0hF UikKK10pCmRpZmYgLS1naXQgYS9tNC9vY2FtbC5tNCBiL200L29jYW1sLm00Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIwNjdlZTkKLS0tIC9kZXYvbnVsbAorKysgYi9tNC9v Y2FtbC5tNApAQCAtMCwwICsxLDI0MSBAQAorZG5sIGF1dG9jb25mIG1hY3JvcyBmb3IgT0NhbWwK K2RubCBmcm9tIGh0dHA6Ly9mb3JnZS5vY2FtbGNvcmUub3JnLworZG5sCitkbmwgQ29weXJpZ2h0 IMKpIDIwMDkgICAgICBSaWNoYXJkIFcuTS4gSm9uZXMKK2RubCBDb3B5cmlnaHQgwqkgMjAwOSAg ICAgIFN0ZWZhbm8gWmFjY2hpcm9saQorZG5sIENvcHlyaWdodCDCqSAyMDAwLTIwMDUgT2xpdmll ciBBbmRyaWV1CitkbmwgQ29weXJpZ2h0IMKpIDIwMDAtMjAwNSBKZWFuLUNocmlzdG9waGUgRmls bGnDonRyZQorZG5sIENvcHlyaWdodCDCqSAyMDAwLTIwMDUgR2VvcmdlcyBNYXJpYW5vCitkbmwK K2RubCBGb3IgZG9jdW1lbnRhdGlvbiwgcGxlYXNlIHJlYWQgdGhlIG9jYW1sLm00IG1hbiBwYWdl LgorCitBQ19ERUZVTihbQUNfUFJPR19PQ0FNTF0sCitbZG5sCisgICMgY2hlY2tpbmcgZm9yIG9j YW1sYworICBBQ19DSEVDS19UT09MKFtPQ0FNTENdLFtvY2FtbGNdLFtub10pCisKKyAgaWYgdGVz dCAiJE9DQU1MQyIgIT0gIm5vIjsgdGhlbgorICAgICBPQ0FNTFZFUlNJT049YCRPQ0FNTEMgLXYg fCBzZWQgLW4gLWUgJ3N8Lip2ZXJzaW9uKiAqXCguKlwpJHxcMXxwJ2AKKyAgICAgQUNfTVNHX1JF U1VMVChbT0NhbWwgdmVyc2lvbiBpcyAkT0NBTUxWRVJTSU9OXSkKKyAgICAgIyBJZiBPQ0FNTExJ QiBpcyBzZXQsIHVzZSBpdAorICAgICBpZiB0ZXN0ICIkT0NBTUxMSUIiID0gIiI7IHRoZW4KKyAg ICAgICAgT0NBTUxMSUI9YCRPQ0FNTEMgLXdoZXJlIDI+L2Rldi9udWxsIHx8ICRPQ0FNTEMgLXZ8 dGFpbCAtMXxjdXQgLWQgJyAnIC1mIDRgCisgICAgIGVsc2UKKyAgICAgICAgQUNfTVNHX1JFU1VM VChbT0NBTUxMSUIgcHJldmlvdXNseSBzZXQ7IHByZXNlcnZpbmcgaXQuXSkKKyAgICAgZmkKKyAg ICAgQUNfTVNHX1JFU1VMVChbT0NhbWwgbGlicmFyeSBwYXRoIGlzICRPQ0FNTExJQl0pCisKKyAg ICAgQUNfU1VCU1QoW09DQU1MVkVSU0lPTl0pCisgICAgIEFDX1NVQlNUKFtPQ0FNTExJQl0pCisK KyAgICAgIyBjaGVja2luZyBmb3Igb2NhbWxvcHQKKyAgICAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxP UFRdLFtvY2FtbG9wdF0sW25vXSkKKyAgICAgT0NBTUxCRVNUPWJ5dGUKKyAgICAgaWYgdGVzdCAi JE9DQU1MT1BUIiA9ICJubyI7IHRoZW4KKwlBQ19NU0dfV0FSTihbQ2Fubm90IGZpbmQgb2NhbWxv cHQ7IGJ5dGVjb2RlIGNvbXBpbGF0aW9uIG9ubHkuXSkKKyAgICAgZWxzZQorCVRNUFZFUlNJT049 YCRPQ0FNTE9QVCAtdiB8IHNlZCAtbiAtZSAnc3wuKnZlcnNpb24qICpcKC4qXCkkfFwxfHAnIGAK KwlpZiB0ZXN0ICIkVE1QVkVSU0lPTiIgIT0gIiRPQ0FNTFZFUlNJT04iIDsgdGhlbgorCSAgICBB Q19NU0dfUkVTVUxUKFt2ZXJzaW9ucyBkaWZmZXJzIGZyb20gb2NhbWxjOyBvY2FtbG9wdCBkaXNj YXJkZWQuXSkKKwkgICAgT0NBTUxPUFQ9bm8KKwllbHNlCisJICAgIE9DQU1MQkVTVD1vcHQKKwlm aQorICAgICBmaQorCisgICAgIEFDX1NVQlNUKFtPQ0FNTEJFU1RdKQorCisgICAgICMgY2hlY2tp bmcgZm9yIG9jYW1sYy5vcHQKKyAgICAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxDRE9UT1BUXSxbb2Nh bWxjLm9wdF0sW25vXSkKKyAgICAgaWYgdGVzdCAiJE9DQU1MQ0RPVE9QVCIgIT0gIm5vIjsgdGhl bgorCVRNUFZFUlNJT049YCRPQ0FNTENET1RPUFQgLXYgfCBzZWQgLW4gLWUgJ3N8Lip2ZXJzaW9u KiAqXCguKlwpJHxcMXxwJyBgCisJaWYgdGVzdCAiJFRNUFZFUlNJT04iICE9ICIkT0NBTUxWRVJT SU9OIiA7IHRoZW4KKwkgICAgQUNfTVNHX1JFU1VMVChbdmVyc2lvbnMgZGlmZmVycyBmcm9tIG9j YW1sYzsgb2NhbWxjLm9wdCBkaXNjYXJkZWQuXSkKKwllbHNlCisJICAgIE9DQU1MQz0kT0NBTUxD RE9UT1BUCisJZmkKKyAgICAgZmkKKworICAgICAjIGNoZWNraW5nIGZvciBvY2FtbG9wdC5vcHQK KyAgICAgaWYgdGVzdCAiJE9DQU1MT1BUIiAhPSAibm8iIDsgdGhlbgorCUFDX0NIRUNLX1RPT0wo W09DQU1MT1BURE9UT1BUXSxbb2NhbWxvcHQub3B0XSxbbm9dKQorCWlmIHRlc3QgIiRPQ0FNTE9Q VERPVE9QVCIgIT0gIm5vIjsgdGhlbgorCSAgIFRNUFZFUlNJT049YCRPQ0FNTE9QVERPVE9QVCAt diB8IHNlZCAtbiAtZSAnc3wuKnZlcnNpb24qICpcKC4qXCkkfFwxfHAnIGAKKwkgICBpZiB0ZXN0 ICIkVE1QVkVSU0lPTiIgIT0gIiRPQ0FNTFZFUlNJT04iIDsgdGhlbgorCSAgICAgIEFDX01TR19S RVNVTFQoW3ZlcnNpb24gZGlmZmVycyBmcm9tIG9jYW1sYzsgb2NhbWxvcHQub3B0IGRpc2NhcmRl ZC5dKQorCSAgIGVsc2UKKwkgICAgICBPQ0FNTE9QVD0kT0NBTUxPUFRET1RPUFQKKwkgICBmaQor ICAgICAgICBmaQorICAgICBmaQorCisgICAgIEFDX1NVQlNUKFtPQ0FNTE9QVF0pCisgIGZpCisK KyAgQUNfU1VCU1QoW09DQU1MQ10pCisKKyAgIyBjaGVja2luZyBmb3Igb2NhbWwgdG9wbGV2ZWwK KyAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxdLFtvY2FtbF0sW25vXSkKKworICAjIGNoZWNraW5nIGZv ciBvY2FtbGRlcAorICBBQ19DSEVDS19UT09MKFtPQ0FNTERFUF0sW29jYW1sZGVwXSxbbm9dKQor CisgICMgY2hlY2tpbmcgZm9yIG9jYW1sbWt0b3AKKyAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxNS1RP UF0sW29jYW1sbWt0b3BdLFtub10pCisKKyAgIyBjaGVja2luZyBmb3Igb2NhbWxta2xpYgorICBB Q19DSEVDS19UT09MKFtPQ0FNTE1LTElCXSxbb2NhbWxta2xpYl0sW25vXSkKKworICAjIGNoZWNr aW5nIGZvciBvY2FtbGRvYworICBBQ19DSEVDS19UT09MKFtPQ0FNTERPQ10sW29jYW1sZG9jXSxb bm9dKQorCisgICMgY2hlY2tpbmcgZm9yIG9jYW1sYnVpbGQKKyAgQUNfQ0hFQ0tfVE9PTChbT0NB TUxCVUlMRF0sW29jYW1sYnVpbGRdLFtub10pCitdKQorCisKK0FDX0RFRlVOKFtBQ19QUk9HX09D QU1MTEVYXSwKK1tkbmwKKyAgIyBjaGVja2luZyBmb3Igb2NhbWxsZXgKKyAgQUNfQ0hFQ0tfVE9P TChbT0NBTUxMRVhdLFtvY2FtbGxleF0sW25vXSkKKyAgaWYgdGVzdCAiJE9DQU1MTEVYIiAhPSAi bm8iOyB0aGVuCisgICAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxMRVhET1RPUFRdLFtvY2FtbGxleC5v cHRdLFtub10pCisgICAgaWYgdGVzdCAiJE9DQU1MTEVYRE9UT1BUIiAhPSAibm8iOyB0aGVuCisJ T0NBTUxMRVg9JE9DQU1MTEVYRE9UT1BUCisgICAgZmkKKyAgZmkKKyAgQUNfU1VCU1QoW09DQU1M TEVYXSkKK10pCisKK0FDX0RFRlVOKFtBQ19QUk9HX09DQU1MWUFDQ10sCitbZG5sCisgIEFDX0NI RUNLX1RPT0woW09DQU1MWUFDQ10sW29jYW1seWFjY10sW25vXSkKKyAgQUNfU1VCU1QoW09DQU1M WUFDQ10pCitdKQorCisKK0FDX0RFRlVOKFtBQ19QUk9HX0NBTUxQNF0sCitbZG5sCisgIEFDX1JF UVVJUkUoW0FDX1BST0dfT0NBTUxdKWRubAorCisgICMgY2hlY2tpbmcgZm9yIGNhbWxwNAorICBB Q19DSEVDS19UT09MKFtDQU1MUDRdLFtjYW1scDRdLFtub10pCisgIGlmIHRlc3QgIiRDQU1MUDQi ICE9ICJubyI7IHRoZW4KKyAgICAgVE1QVkVSU0lPTj1gJENBTUxQNCAtdiAyPiYxfCBzZWQgLW4g LWUgJ3N8Lip2ZXJzaW9uICpcKC4qXCkkfFwxfHAnYAorICAgICBpZiB0ZXN0ICIkVE1QVkVSU0lP TiIgIT0gIiRPQ0FNTFZFUlNJT04iIDsgdGhlbgorCUFDX01TR19SRVNVTFQoW3ZlcnNpb25zIGRp ZmZlcnMgZnJvbSBvY2FtbGNdKQorICAgICAgICBDQU1MUDQ9bm8KKyAgICAgZmkKKyAgZmkKKyAg QUNfU1VCU1QoW0NBTUxQNF0pCisKKyAgIyBjaGVja2luZyBmb3IgY29tcGFuaW9uIHRvb2xzCisg IEFDX0NIRUNLX1RPT0woW0NBTUxQNEJPT1RdLFtjYW1scDRib290XSxbbm9dKQorICBBQ19DSEVD S19UT09MKFtDQU1MUDRPXSxbY2FtbHA0b10sW25vXSkKKyAgQUNfQ0hFQ0tfVE9PTChbQ0FNTFA0 T0ZdLFtjYW1scDRvZl0sW25vXSkKKyAgQUNfQ0hFQ0tfVE9PTChbQ0FNTFA0T09GXSxbY2FtbHA0 b29mXSxbbm9dKQorICBBQ19DSEVDS19UT09MKFtDQU1MUDRPUkZdLFtjYW1scDRvcmZdLFtub10p CisgIEFDX0NIRUNLX1RPT0woW0NBTUxQNFBST0ZdLFtjYW1scDRwcm9mXSxbbm9dKQorICBBQ19D SEVDS19UT09MKFtDQU1MUDRSXSxbY2FtbHA0cl0sW25vXSkKKyAgQUNfQ0hFQ0tfVE9PTChbQ0FN TFA0UkZdLFtjYW1scDRyZl0sW25vXSkKKyAgQUNfU1VCU1QoW0NBTUxQNEJPT1RdKQorICBBQ19T VUJTVChbQ0FNTFA0T10pCisgIEFDX1NVQlNUKFtDQU1MUDRPRl0pCisgIEFDX1NVQlNUKFtDQU1M UDRPT0ZdKQorICBBQ19TVUJTVChbQ0FNTFA0T1JGXSkKKyAgQUNfU1VCU1QoW0NBTUxQNFBST0Zd KQorICBBQ19TVUJTVChbQ0FNTFA0Ul0pCisgIEFDX1NVQlNUKFtDQU1MUDRSRl0pCitdKQorCisK K0FDX0RFRlVOKFtBQ19QUk9HX0ZJTkRMSUJdLAorW2RubAorICBBQ19SRVFVSVJFKFtBQ19QUk9H X09DQU1MXSlkbmwKKworICAjIGNoZWNraW5nIGZvciBvY2FtbGZpbmQKKyAgQUNfQ0hFQ0tfVE9P TChbT0NBTUxGSU5EXSxbb2NhbWxmaW5kXSxbbm9dKQorICBBQ19TVUJTVChbT0NBTUxGSU5EXSkK K10pCisKKworZG5sIFRoYW5rcyB0byBKaW0gTWV5ZXJpbmcgZm9yIHdvcmtpbmcgdGhpcyBuZXh0 IGJpdCBvdXQgZm9yIHVzLgorZG5sIFhYWCBXZSBzaG91bGQgZGVmaW5lIEFTX1RSX1NIIGlmIGl0 J3Mgbm90IGRlZmluZWQgYWxyZWFkeQorZG5sIChlZy4gZm9yIG9sZCBhdXRvY29uZikuCitBQ19E RUZVTihbQUNfQ0hFQ0tfT0NBTUxfUEtHXSwKK1tkbmwKKyAgQUNfUkVRVUlSRShbQUNfUFJPR19G SU5ETElCXSlkbmwKKworICBBQ19NU0dfQ0hFQ0tJTkcoW2ZvciBPQ2FtbCBmaW5kbGliIHBhY2th Z2UgJDFdKQorCisgIHVuc2V0IGZvdW5kCisgIHVuc2V0IHBrZworICBmb3VuZD1ubworICBmb3Ig cGtnIGluICQxICQyIDsgZG8KKyAgICBpZiAkT0NBTUxGSU5EIHF1ZXJ5ICRwa2cgPi9kZXYvbnVs bCAyPi9kZXYvbnVsbDsgdGhlbgorICAgICAgQUNfTVNHX1JFU1VMVChbZm91bmRdKQorICAgICAg QVNfVFJfU0goW09DQU1MX1BLR18kMV0pPSRwa2cKKyAgICAgIGZvdW5kPXllcworICAgICAgYnJl YWsKKyAgICBmaQorICBkb25lCisgIGlmIHRlc3QgIiRmb3VuZCIgPSAibm8iIDsgdGhlbgorICAg IEFDX01TR19SRVNVTFQoW25vdCBmb3VuZF0pCisgICAgQVNfVFJfU0goW09DQU1MX1BLR18kMV0p PW5vCisgIGZpCisKKyAgQUNfU1VCU1QoQVNfVFJfU0goW09DQU1MX1BLR18kMV0pKQorXSkKKwor CitBQ19ERUZVTihbQUNfQ0hFQ0tfT0NBTUxfTU9EVUxFXSwKK1tkbmwKKyAgQUNfTVNHX0NIRUNL SU5HKFtmb3IgT0NhbWwgbW9kdWxlICQyXSkKKworICBjYXQgPiBjb25mdGVzdC5tbCA8PEVPRgor b3BlbiAkMworRU9GCisgIHVuc2V0IGZvdW5kCisgIGZvciAkMSBpbiAkJDEgJDQgOyBkbworICAg IGlmICRPQ0FNTEMgLWMgLUkgIiQkMSIgY29uZnRlc3QubWwgPiY1IDI+JjUgOyB0aGVuCisgICAg ICBmb3VuZD15ZXMKKyAgICAgIGJyZWFrCisgICAgZmkKKyAgZG9uZQorCisgIGlmIHRlc3QgIiRm b3VuZCIgOyB0aGVuCisgICAgQUNfTVNHX1JFU1VMVChbJCQxXSkKKyAgZWxzZQorICAgIEFDX01T R19SRVNVTFQoW25vdCBmb3VuZF0pCisgICAgJDE9bm8KKyAgZmkKKyAgQUNfU1VCU1QoWyQxXSkK K10pCisKKworZG5sIFhYWCBDcm9zcy1jb21waWxpbmcKK0FDX0RFRlVOKFtBQ19DSEVDS19PQ0FN TF9XT1JEX1NJWkVdLAorW2RubAorICBBQ19SRVFVSVJFKFtBQ19QUk9HX09DQU1MXSlkbmwKKyAg QUNfTVNHX0NIRUNLSU5HKFtmb3IgT0NhbWwgY29tcGlsZXIgd29yZCBzaXplXSkKKyAgY2F0ID4g Y29uZnRlc3QubWwgPDxFT0YKKyAgcHJpbnRfZW5kbGluZSAoc3RyaW5nX29mX2ludCBTeXMud29y ZF9zaXplKQorICBFT0YKKyAgT0NBTUxfV09SRF9TSVpFPWAkT0NBTUwgY29uZnRlc3QubWxgCisg IEFDX01TR19SRVNVTFQoWyRPQ0FNTF9XT1JEX1NJWkVdKQorICBBQ19TVUJTVChbT0NBTUxfV09S RF9TSVpFXSkKK10pCisKK0FDX0RFRlVOKFtBQ19DSEVDS19PQ0FNTF9PU19UWVBFXSwKK1tkbmwK KyAgQUNfUkVRVUlSRShbQUNfUFJPR19PQ0FNTF0pZG5sCisgIEFDX01TR19DSEVDS0lORyhbT0Nh bWwgU3lzLm9zX3R5cGVdKQorCisgIGNhdCA+IGNvbmZ0ZXN0Lm1sIDw8RU9GCisgIHByaW50X3N0 cmluZyhTeXMub3NfdHlwZSk7OworRU9GCisKKyAgT0NBTUxfT1NfVFlQRT1gJE9DQU1MIGNvbmZ0 ZXN0Lm1sYAorICBBQ19NU0dfUkVTVUxUKFskT0NBTUxfT1NfVFlQRV0pCisgIEFDX1NVQlNUKFtP Q0FNTF9PU19UWVBFXSkKK10pCmRpZmYgLS1naXQgYS9tNC9wYXRoX29yX2ZhaWwubTQgYi9tNC9w YXRoX29yX2ZhaWwubTQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWZkYjkw ZAotLS0gL2Rldi9udWxsCisrKyBiL200L3BhdGhfb3JfZmFpbC5tNApAQCAtMCwwICsxLDEzIEBA CitBQ19ERUZVTihbQVhfUEFUSF9QUk9HX09SX0ZBSUxdLAorW0FDX1BBVEhfUFJPRyhbJDFdLCBb JDJdLCBbbm9dKQoraWYgdGVzdCB4IiR7JDF9IiA9PSB4Im5vIgordGhlbgorICAgIEFDX01TR19F UlJPUihbVW5hYmxlIHRvIGZpbmQgJDIsIHBsZWFzZSBpbnN0YWxsICQyXSkKK2ZpXSkKKworQUNf REVGVU4oW0FYX1BBVEhfUFJPR19PUl9GQUlMX0FSR10sWworQVNfSUYoW3Rlc3QgIngkJDEiID0g Inh5Il0sIFtBWF9QQVRIX1BST0dfT1JfRkFJTChbJDJdLCBbJDNdKV0sIFsKKyQyPSIvJDMtZGlz YWJsZWQtaW4tY29uZmlndXJlLXNjcmlwdCIKK0FDX1NVQlNUKCQyKQorXSkKK10pCmRpZmYgLS1n aXQgYS9tNC9wa2cubTQgYi9tNC9wa2cubTQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uM2U5ZTkwMAotLS0gL2Rldi9udWxsCisrKyBiL200L3BrZy5tNApAQCAtMCwwICsxLDE1 NyBAQAorIyBwa2cubTQgLSBNYWNyb3MgdG8gbG9jYXRlIGFuZCB1dGlsaXNlIHBrZy1jb25maWcu ICAgICAgICAgICAgLSotIEF1dG9jb25mIC0qLQorIyBzZXJpYWwgMSAocGtnLWNvbmZpZy0wLjI0 KQorIworIyBDb3B5cmlnaHQgwqkgMjAwNCBTY290dCBKYW1lcyBSZW1uYW50IDxzY290dEBuZXRz cGxpdC5jb20+LgorIworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorIyB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgor IyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIworIyBUaGlzIHByb2dyYW0g aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0Cisj IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyMgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyMgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorIworIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0 ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorIyBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxh Y2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorIworIyBBcyBhIHNw ZWNpYWwgZXhjZXB0aW9uIHRvIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwgaWYgeW91 CisjIGRpc3RyaWJ1dGUgdGhpcyBmaWxlIGFzIHBhcnQgb2YgYSBwcm9ncmFtIHRoYXQgY29udGFp bnMgYQorIyBjb25maWd1cmF0aW9uIHNjcmlwdCBnZW5lcmF0ZWQgYnkgQXV0b2NvbmYsIHlvdSBt YXkgaW5jbHVkZSBpdCB1bmRlcgorIyB0aGUgc2FtZSBkaXN0cmlidXRpb24gdGVybXMgdGhhdCB5 b3UgdXNlIGZvciB0aGUgcmVzdCBvZiB0aGF0IHByb2dyYW0uCisKKyMgUEtHX1BST0dfUEtHX0NP TkZJRyhbTUlOLVZFUlNJT05dKQorIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CitBQ19ERUZVTihbUEtHX1BST0dfUEtHX0NPTkZJR10sCitbbTRfcGF0dGVybl9mb3JiaWQoW15f P1BLR19bQS1aX10rJF0pCittNF9wYXR0ZXJuX2FsbG93KFteUEtHX0NPTkZJRyhfUEFUSCk/JF0p CitBQ19BUkdfVkFSKFtQS0dfQ09ORklHXSwgW3BhdGggdG8gcGtnLWNvbmZpZyB1dGlsaXR5XSkK K0FDX0FSR19WQVIoW1BLR19DT05GSUdfUEFUSF0sIFtkaXJlY3RvcmllcyB0byBhZGQgdG8gcGtn LWNvbmZpZydzIHNlYXJjaCBwYXRoXSkKK0FDX0FSR19WQVIoW1BLR19DT05GSUdfTElCRElSXSwg W3BhdGggb3ZlcnJpZGluZyBwa2ctY29uZmlnJ3MgYnVpbHQtaW4gc2VhcmNoIHBhdGhdKQorCitp ZiB0ZXN0ICJ4JGFjX2N2X2Vudl9QS0dfQ09ORklHX3NldCIgIT0gInhzZXQiOyB0aGVuCisJQUNf UEFUSF9UT09MKFtQS0dfQ09ORklHXSwgW3BrZy1jb25maWddKQorZmkKK2lmIHRlc3QgLW4gIiRQ S0dfQ09ORklHIjsgdGhlbgorCV9wa2dfbWluX3ZlcnNpb249bTRfZGVmYXVsdChbJDFdLCBbMC45 LjBdKQorCUFDX01TR19DSEVDS0lORyhbcGtnLWNvbmZpZyBpcyBhdCBsZWFzdCB2ZXJzaW9uICRf cGtnX21pbl92ZXJzaW9uXSkKKwlpZiAkUEtHX0NPTkZJRyAtLWF0bGVhc3QtcGtnY29uZmlnLXZl cnNpb24gJF9wa2dfbWluX3ZlcnNpb247IHRoZW4KKwkJQUNfTVNHX1JFU1VMVChbeWVzXSkKKwll bHNlCisJCUFDX01TR19SRVNVTFQoW25vXSkKKwkJUEtHX0NPTkZJRz0iIgorCWZpCitmaVtdZG5s CitdKSMgUEtHX1BST0dfUEtHX0NPTkZJRworCisjIFBLR19DSEVDS19FWElTVFMoTU9EVUxFUywg W0FDVElPTi1JRi1GT1VORF0sIFtBQ1RJT04tSUYtTk9ULUZPVU5EXSkKKyMKKyMgQ2hlY2sgdG8g c2VlIHdoZXRoZXIgYSBwYXJ0aWN1bGFyIHNldCBvZiBtb2R1bGVzIGV4aXN0cy4gIFNpbWlsYXIK KyMgdG8gUEtHX0NIRUNLX01PRFVMRVMoKSwgYnV0IGRvZXMgbm90IHNldCB2YXJpYWJsZXMgb3Ig cHJpbnQgZXJyb3JzLgorIworIyBQbGVhc2UgcmVtZW1iZXIgdGhhdCBtNCBleHBhbmRzIEFDX1JF UVVJUkUoW1BLR19QUk9HX1BLR19DT05GSUddKQorIyBvbmx5IGF0IHRoZSBmaXJzdCBvY2N1cmVu Y2UgaW4gY29uZmlndXJlLmFjLCBzbyBpZiB0aGUgZmlyc3QgcGxhY2UKKyMgaXQncyBjYWxsZWQg bWlnaHQgYmUgc2tpcHBlZCAoc3VjaCBhcyBpZiBpdCBpcyB3aXRoaW4gYW4gImlmIiwgeW91Cisj IGhhdmUgdG8gY2FsbCBQS0dfQ0hFQ0tfRVhJU1RTIG1hbnVhbGx5CisjIC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitBQ19ERUZV TihbUEtHX0NIRUNLX0VYSVNUU10sCitbQUNfUkVRVUlSRShbUEtHX1BST0dfUEtHX0NPTkZJR10p ZG5sCitpZiB0ZXN0IC1uICIkUEtHX0NPTkZJRyIgJiYgXAorICAgIEFDX1JVTl9MT0coWyRQS0df Q09ORklHIC0tZXhpc3RzIC0tcHJpbnQtZXJyb3JzICIkMSJdKTsgdGhlbgorICBtNF9kZWZhdWx0 KFskMl0sIFs6XSkKK200X2lmdmFsbihbJDNdLCBbZWxzZQorICAkM10pZG5sCitmaV0pCisKKyMg X1BLR19DT05GSUcoW1ZBUklBQkxFXSwgW0NPTU1BTkRdLCBbTU9EVUxFU10pCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorbTRfZGVmaW5lKFtfUEtHX0NP TkZJR10sCitbaWYgdGVzdCAtbiAiJCQxIjsgdGhlbgorICAgIHBrZ19jdl9bXSQxPSIkJDEiCisg ZWxpZiB0ZXN0IC1uICIkUEtHX0NPTkZJRyI7IHRoZW4KKyAgICBQS0dfQ0hFQ0tfRVhJU1RTKFsk M10sCisgICAgICAgICAgICAgICAgICAgICBbcGtnX2N2X1tdJDE9YCRQS0dfQ09ORklHIC0tW10k MiAiJDMiIDI+L2Rldi9udWxsYF0sCisJCSAgICAgW3BrZ19mYWlsZWQ9eWVzXSkKKyBlbHNlCisg ICAgcGtnX2ZhaWxlZD11bnRyaWVkCitmaVtdZG5sCitdKSMgX1BLR19DT05GSUcKKworIyBfUEtH X1NIT1JUX0VSUk9SU19TVVBQT1JURUQKKyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K K0FDX0RFRlVOKFtfUEtHX1NIT1JUX0VSUk9SU19TVVBQT1JURURdLAorW0FDX1JFUVVJUkUoW1BL R19QUk9HX1BLR19DT05GSUddKQoraWYgJFBLR19DT05GSUcgLS1hdGxlYXN0LXBrZ2NvbmZpZy12 ZXJzaW9uIDAuMjA7IHRoZW4KKyAgICAgICAgX3BrZ19zaG9ydF9lcnJvcnNfc3VwcG9ydGVkPXll cworZWxzZQorICAgICAgICBfcGtnX3Nob3J0X2Vycm9yc19zdXBwb3J0ZWQ9bm8KK2ZpW11kbmwK K10pIyBfUEtHX1NIT1JUX0VSUk9SU19TVVBQT1JURUQKKworCisjIFBLR19DSEVDS19NT0RVTEVT KFZBUklBQkxFLVBSRUZJWCwgTU9EVUxFUywgW0FDVElPTi1JRi1GT1VORF0sCisjIFtBQ1RJT04t SUYtTk9ULUZPVU5EXSkKKyMKKyMKKyMgTm90ZSB0aGF0IGlmIHRoZXJlIGlzIGEgcG9zc2liaWxp dHkgdGhlIGZpcnN0IGNhbGwgdG8KKyMgUEtHX0NIRUNLX01PRFVMRVMgbWlnaHQgbm90IGhhcHBl biwgeW91IHNob3VsZCBiZSBzdXJlIHRvIGluY2x1ZGUgYW4KKyMgZXhwbGljaXQgY2FsbCB0byBQ S0dfUFJPR19QS0dfQ09ORklHIGluIHlvdXIgY29uZmlndXJlLmFjCisjCisjCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitB Q19ERUZVTihbUEtHX0NIRUNLX01PRFVMRVNdLAorW0FDX1JFUVVJUkUoW1BLR19QUk9HX1BLR19D T05GSUddKWRubAorQUNfQVJHX1ZBUihbJDFdW19DRkxBR1NdLCBbQyBjb21waWxlciBmbGFncyBm b3IgJDEsIG92ZXJyaWRpbmcgcGtnLWNvbmZpZ10pZG5sCitBQ19BUkdfVkFSKFskMV1bX0xJQlNd LCBbbGlua2VyIGZsYWdzIGZvciAkMSwgb3ZlcnJpZGluZyBwa2ctY29uZmlnXSlkbmwKKworcGtn X2ZhaWxlZD1ubworQUNfTVNHX0NIRUNLSU5HKFtmb3IgJDFdKQorCitfUEtHX0NPTkZJRyhbJDFd W19DRkxBR1NdLCBbY2ZsYWdzXSwgWyQyXSkKK19QS0dfQ09ORklHKFskMV1bX0xJQlNdLCBbbGli c10sIFskMl0pCisKK200X2RlZmluZShbX1BLR19URVhUXSwgW0FsdGVybmF0aXZlbHksIHlvdSBt YXkgc2V0IHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZXMgJDFbXV9DRkxBR1MKK2FuZCAkMVtdX0xJ QlMgdG8gYXZvaWQgdGhlIG5lZWQgdG8gY2FsbCBwa2ctY29uZmlnLgorU2VlIHRoZSBwa2ctY29u ZmlnIG1hbiBwYWdlIGZvciBtb3JlIGRldGFpbHMuXSkKKworaWYgdGVzdCAkcGtnX2ZhaWxlZCA9 IHllczsgdGhlbgorCUFDX01TR19SRVNVTFQoW25vXSkKKyAgICAgICAgX1BLR19TSE9SVF9FUlJP UlNfU1VQUE9SVEVECisgICAgICAgIGlmIHRlc3QgJF9wa2dfc2hvcnRfZXJyb3JzX3N1cHBvcnRl ZCA9IHllczsgdGhlbgorCSAgICAgICAgJDFbXV9QS0dfRVJST1JTPWAkUEtHX0NPTkZJRyAtLXNo b3J0LWVycm9ycyAtLXByaW50LWVycm9ycyAiJDIiIDI+JjFgCisgICAgICAgIGVsc2UKKwkgICAg ICAgICQxW11fUEtHX0VSUk9SUz1gJFBLR19DT05GSUcgLS1wcmludC1lcnJvcnMgIiQyIiAyPiYx YAorICAgICAgICBmaQorCSMgUHV0IHRoZSBuYXN0eSBlcnJvciBtZXNzYWdlIGluIGNvbmZpZy5s b2cgd2hlcmUgaXQgYmVsb25ncworCWVjaG8gIiQkMVtdX1BLR19FUlJPUlMiID4mQVNfTUVTU0FH RV9MT0dfRkQKKworCW00X2RlZmF1bHQoWyQ0XSwgW0FDX01TR19FUlJPUigKK1tQYWNrYWdlIHJl cXVpcmVtZW50cyAoJDIpIHdlcmUgbm90IG1ldDoKKworJCQxX1BLR19FUlJPUlMKKworQ29uc2lk ZXIgYWRqdXN0aW5nIHRoZSBQS0dfQ09ORklHX1BBVEggZW52aXJvbm1lbnQgdmFyaWFibGUgaWYg eW91CitpbnN0YWxsZWQgc29mdHdhcmUgaW4gYSBub24tc3RhbmRhcmQgcHJlZml4LgorCitfUEtH X1RFWFRdKWRubAorICAgICAgICBdKQorZWxpZiB0ZXN0ICRwa2dfZmFpbGVkID0gdW50cmllZDsg dGhlbgorCUFDX01TR19SRVNVTFQoW25vXSkKKwltNF9kZWZhdWx0KFskNF0sIFtBQ19NU0dfRkFJ TFVSRSgKK1tUaGUgcGtnLWNvbmZpZyBzY3JpcHQgY291bGQgbm90IGJlIGZvdW5kIG9yIGlzIHRv byBvbGQuICBNYWtlIHN1cmUgaXQKK2lzIGluIHlvdXIgUEFUSCBvciBzZXQgdGhlIFBLR19DT05G SUcgZW52aXJvbm1lbnQgdmFyaWFibGUgdG8gdGhlIGZ1bGwKK3BhdGggdG8gcGtnLWNvbmZpZy4K KworX1BLR19URVhUCisKK1RvIGdldCBwa2ctY29uZmlnLCBzZWUgPGh0dHA6Ly9wa2ctY29uZmln LmZyZWVkZXNrdG9wLm9yZy8+Ll0pZG5sCisgICAgICAgIF0pCitlbHNlCisJJDFbXV9DRkxBR1M9 JHBrZ19jdl9bXSQxW11fQ0ZMQUdTCisJJDFbXV9MSUJTPSRwa2dfY3ZfW10kMVtdX0xJQlMKKyAg ICAgICAgQUNfTVNHX1JFU1VMVChbeWVzXSkKKwkkMworZmlbXWRubAorXSkjIFBLR19DSEVDS19N T0RVTEVTCmRpZmYgLS1naXQgYS9tNC9wdGhyZWFkLm00IGIvbTQvcHRocmVhZC5tNApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jODE4OTk5Ci0tLSAvZGV2L251bGwKKysrIGIv bTQvcHRocmVhZC5tNApAQCAtMCwwICsxLDQxIEBACisjIFdlIGRlZmluZSwgc2VwYXJhdGVseSwg UFRIUkVBRF9DRkxBR1MsIF9MREZMQUdTIGFuZCBfTElCUworIyBldmVuIHRob3VnaCBjdXJyZW50 bHkgd2UgZG9uJ3Qgc2V0IHRoZW0gdmVyeSBzZXBhcmF0ZWx5LgorIyBUaGlzIG1lYW5zIHRoYXQg dGhlIG1ha2VmaWxlcyB3aWxsIG5vdCBuZWVkIHRvIGNoYW5nZSBpbgorIyB0aGUgZnV0dXJlIGlm IHdlIG1ha2UgdGhlIHRlc3QgbW9yZSBzb3BoaXN0aWNhdGVkLgorCitBQ19ERUZVTihbQVhfUFRI UkVBRF9DVjJWQVJTXSxbCisgICAgUFRIUkVBRF9DRkxBR1M9IiRheF9jdl9wdGhyZWFkX2ZsYWdz IgorICAgIFBUSFJFQURfTERGTEFHUz0iJGF4X2N2X3B0aHJlYWRfZmxhZ3MiCisgICAgUFRIUkVB RF9MSUJTPSIiCitdKQorCisjIFdlIGludm9rZSBBWF9QVEhSRUFEX1ZBUlMgd2l0aCB0aGUgbmFt ZSBvZiBhbm90aGVyIG1hY3JvCisjIHdoaWNoIGlzIHRoZW4gZXhwYW5kZWQgb25jZSBmb3IgZWFj aCB2YXJpYWJsZS4KK0FDX0RFRlVOKFtBWF9QVEhSRUFEX1ZBUlNdLFskMShDRkxBR1MpICQxKExE RkxBR1MpICQxKExJQlMpXSkKKworQUNfREVGVU4oW0FYX1BUSFJFQURfVkFSX0FQUExZXSxbCisg ICAgJDE9IiQkMSAkUFRIUkVBRF8kMSIKK10pCitBQ19ERUZVTihbQVhfUFRIUkVBRF9WQVJfU1VC U1RdLFtBQ19TVUJTVChQVEhSRUFEXyQxKV0pCisKK0FDX0RFRlVOKFtBWF9DSEVDS19QVEhSRUFE XSxbCisgICAgQUNfQ0FDSEVfQ0hFQ0soW2ZvciBwdGhyZWFkIGZsYWddLCBbYXhfY3ZfcHRocmVh ZF9mbGFnc10sIFsKKyAgICAgICAgYXhfY3ZfcHRocmVhZF9mbGFncz0tcHRocmVhZAorICAgICAg ICBBWF9QVEhSRUFEX0NWMlZBUlMKKyAgICAgICAgQVhfUFRIUkVBRF9WQVJTKFtBWF9TQVZFVkFS X1NBVkVdKQorICAgICAgICBBWF9QVEhSRUFEX1ZBUlMoW0FYX1BUSFJFQURfVkFSX0FQUExZXSkK KyAgICAgICAgQUNfTElOS19JRkVMU0UoW0FDX0xBTkdfU09VUkNFKFsKKyNpbmNsdWRlIDxwdGhy ZWFkLmg+CitpbnQgbWFpbih2b2lkKSB7CisgIHB0aHJlYWRfYXRmb3JrKDAsMCwwKTsKKyAgcHRo cmVhZF9jcmVhdGUoMCwwLDAsMCk7Cit9CitdKV0sW10sW2F4X2N2X3B0aHJlYWRfZmxhZ3M9ZmFp bGVkXSkKKyAgICAgICAgQVhfUFRIUkVBRF9WQVJTKFtBWF9TQVZFVkFSX1JFU1RPUkVdKQorICAg IF0pCisgICAgaWYgdGVzdCAieCRheF9jdl9wdGhyZWFkX2ZsYWdzIiA9IHhmYWlsZWQ7IHRoZW4K KyAgICAgICAgQUNfTVNHX0VSUk9SKFstcHRocmVhZCBkb2VzIG5vdCB3b3JrXSkKKyAgICBmaQor ICAgIEFYX1BUSFJFQURfQ1YyVkFSUworICAgIEFYX1BUSFJFQURfVkFSUyhbQVhfUFRIUkVBRF9W QVJfU1VCU1RdKQorXSkKZGlmZiAtLWdpdCBhL200L3B0eWZ1bmNzLm00IGIvbTQvcHR5ZnVuY3Mu bTQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2UzN2I1YQotLS0gL2Rldi9u dWxsCisrKyBiL200L3B0eWZ1bmNzLm00CkBAIC0wLDAgKzEsMzUgQEAKK0FDX0RFRlVOKFtBWF9D SEVDS19QVFlGVU5DU10sIFsKKyAgICBkbmwgVGhpcyBpcyBhIHdvcmthcm91bmQgZm9yIGEgYnVn IGluIERlYmlhbiBwYWNrYWdlCisgICAgZG5sIGxpYmJzZC1kZXYtMC4zLjAtMS4gT25jZSB3ZSBu byBsb25nZXIgc3VwcG9ydCB0aGF0CisgICAgZG5sIHBhY2thZ2Ugd2UgY2FuIHJlbW92ZSB0aGUg YWRkaXRpb24gb2YgLVdlcnJvciB0bworICAgIGRubCBDUFBGTEFHUy4KKyAgICBBWF9TQVZFVkFS X1NBVkUoQ1BQRkxBR1MpCisgICAgQ1BQRkxBR1M9IiRDUFBGTEFHUyAtV2Vycm9yIgorICAgIEFD X0NIRUNLX0hFQURFUihbbGlidXRpbC5oXSxbCisgICAgICBBQ19ERUZJTkUoW0lOQ0xVREVfTElC VVRJTF9IXSxbPGxpYnV0aWwuaD5dLFtsaWJ1dGlsIGhlYWRlciBmaWxlIG5hbWVdKQorICAgIF0p CisgICAgQVhfU0FWRVZBUl9SRVNUT1JFKENQUEZMQUdTKQorICAgIEFDX0NBQ0hFX0NIRUNLKFtm b3Igb3BlbnB0eSBldCBhbF0sIFtheF9jdl9wdHlmdW5jc19saWJzXSwgWworICAgICAgICBmb3Ig YXhfY3ZfcHR5ZnVuY3NfbGlicyBpbiAtbHV0aWwgIiIgTk9UX0ZPVU5EOyBkbworICAgICAgICAg ICAgaWYgdGVzdCAieCRheF9jdl9wdHlmdW5jc19saWJzIiA9ICJ4Tk9UX0ZPVU5EIjsgdGhlbgor ICAgICAgICAgICAgICAgIEFDX01TR19GQUlMVVJFKFtVbmFibGUgdG8gZmluZCBsaWJyYXJ5IGZv ciBvcGVucHR5IGFuZCBsb2dpbl90dHldKQorICAgICAgICAgICAgZmkKKyAgICAgICAgICAgIEFY X1NBVkVWQVJfU0FWRShMSUJTKQorICAgICAgICAgICAgTElCUz0iJExJQlMgJGF4X2N2X3B0eWZ1 bmNzX2xpYnMiCisgICAgICAgICAgICBBQ19MSU5LX0lGRUxTRShbQUNfTEFOR19TT1VSQ0UoWwor I2lmZGVmIElOQ0xVREVfTElCVVRJTF9ICisjaW5jbHVkZSBJTkNMVURFX0xJQlVUSUxfSAorI2Vu ZGlmCitpbnQgbWFpbih2b2lkKSB7CisgIG9wZW5wdHkoMCwwLDAsMCwwKTsKKyAgbG9naW5fdHR5 KDApOworfQorXSldLFsKKyAgICAgICAgICAgICAgICBicmVhaworICAgICAgICAgICAgXSxbXSkK KyAgICAgICAgICAgIEFYX1NBVkVWQVJfUkVTVE9SRShMSUJTKQorICAgICAgICBkb25lCisgICAg XSkKKyAgICBQVFlGVU5DU19MSUJTPSIkYXhfY3ZfcHR5ZnVuY3NfbGlicyIKKyAgICBBQ19TVUJT VChQVFlGVU5DU19MSUJTKQorXSkKZGlmZiAtLWdpdCBhL200L3B5dGhvbl9kZXZlbC5tNCBiL200 L3B5dGhvbl9kZXZlbC5tNApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wYTIy MDJjCi0tLSAvZGV2L251bGwKKysrIGIvbTQvcHl0aG9uX2RldmVsLm00CkBAIC0wLDAgKzEsMzYg QEAKK0FDX0RFRlVOKFtBWF9DSEVDS19QWVRIT05fREVWRUxdLCBbCithY19wcmV2aW91c19jcHBm bGFncz0kQ1BQRkxBR1MKK2FjX3ByZXZpb3VzX2xkZmxhZ3M9JExERkxBR1MKK2FjX3B5dGhvbl92 ZXJzaW9uPWAkUFlUSE9OIC1jICdpbXBvcnQgZGlzdHV0aWxzLnN5c2NvbmZpZzsgXAorICAgIHBy aW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIoIlZFUlNJT04iKSdgCitBQ19Q QVRIX1BST0coW3B5Y29uZmlnXSwgWyRQWVRIT04tY29uZmlnXSwgW25vXSkKK0FTX0lGKFt0ZXN0 IHgiJHB5Y29uZmlnIiA9PSB4Im5vIl0sIFsKKyAgICBkbmwgRm9yIHRob3NlIHRoYXQgZG9uJ3Qg aGF2ZSBweXRob24tY29uZmlnCisgICAgQ1BQRkxBR1M9IiRDRkxBR1MgYCRQWVRIT04gLWMgJ2lt cG9ydCBkaXN0dXRpbHMuc3lzY29uZmlnOyBcCisgICAgICAgIHByaW50ICItSSIgKyBkaXN0dXRp bHMuc3lzY29uZmlnLmdldF9jb25maWdfdmFyKCJJTkNMVURFUFkiKSdgIgorICAgIENQUEZMQUdT PSIkQ1BQRkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMuc3lzY29uZmlnOyBcCisg ICAgICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIoIkNGTEFHUyIp J2AiCisgICAgTERGTEFHUz0iJExERkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMu c3lzY29uZmlnOyBcCisgICAgICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZp Z192YXIoIkxJQlMiKSdgIgorICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9OIC1jICdpbXBv cnQgZGlzdHV0aWxzLnN5c2NvbmZpZzsgXAorICAgICAgICBwcmludCBkaXN0dXRpbHMuc3lzY29u ZmlnLmdldF9jb25maWdfdmFyKCJTWVNMSUJTIiknYCIKKyAgICBMREZMQUdTPSIkTERGTEFHUyBg JFBZVEhPTiAtYyAnaW1wb3J0IGRpc3R1dGlscy5zeXNjb25maWc7IFwKKyAgICAgICAgcHJpbnQg Ii1MIiArIGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X3B5dGhvbl9saWIocGxhdF9zcGVjaWZpYz0x LFwKKyAgICAgICAgc3RhbmRhcmRfbGliPTEpICsgIi9jb25maWciJ2AiCisgICAgTERGTEFHUz0i JExERkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMuc3lzY29uZmlnOyBcCisgICAg ICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIoIkxJTktGT1JTSEFS RUQiKSdgIgorICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9OIC1jICdpbXBvcnQgZGlzdHV0 aWxzLnN5c2NvbmZpZzsgXAorICAgICAgICBwcmludCBkaXN0dXRpbHMuc3lzY29uZmlnLmdldF9j b25maWdfdmFyKCJMREZMQUdTIiknYCIKK10sIFsKKyAgICBkbmwgSWYgcHl0aG9uLWNvbmZpZyBp cyBmb3VuZCB1c2UgaXQKKyAgICBDUFBGTEFHUz0iJENGTEFHUyBgJFBZVEhPTi1jb25maWcgLS1j ZmxhZ3NgIgorICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9OLWNvbmZpZyAtLWxkZmxhZ3Ng IgorXSkKKworQUNfQ0hFQ0tfSEVBREVSKFtQeXRob24uaF0sIFtdLAorICAgIFtBQ19NU0dfRVJS T1IoW1VuYWJsZSB0byBmaW5kIFB5dGhvbiBkZXZlbG9wbWVudCBoZWFkZXJzXSldLCkKK0FDX0NI RUNLX0xJQihweXRob24kYWNfcHl0aG9uX3ZlcnNpb24sIFB5QXJnX1BhcnNlVHVwbGUsIFtdLAor ICAgIFtBQ19NU0dfRVJST1IoW1VuYWJsZSB0byBmaW5kIGEgc3VpdGFibGUgcHl0aG9uIGRldmVs b3BtZW50IGxpYnJhcnldKV0pCitDUFBGTEFHUz0kYWNfcHJldmlvdXNfY3BwZmxhZ3MKK0xETEZB R1M9JGFjX3ByZXZpb3VzX2xkZmxhZ3MKK10pCmRpZmYgLS1naXQgYS9tNC9weXRob25fdmVyc2lv bi5tNCBiL200L3B5dGhvbl92ZXJzaW9uLm00Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjRlMmI1OTQKLS0tIC9kZXYvbnVsbAorKysgYi9tNC9weXRob25fdmVyc2lvbi5tNApA QCAtMCwwICsxLDEyIEBACitBQ19ERUZVTihbQVhfQ0hFQ0tfUFlUSE9OX1ZFUlNJT05dLAorW0FD X01TR19DSEVDS0lORyhbZm9yIHB5dGhvbiB2ZXJzaW9uID49ICQxLiQyIF0pCitgJFBZVEhPTiAt YyAnaW1wb3J0IHN5czsgc3lzLmV4aXQoZXZhbCgic3lzLnZlcnNpb25faW5mbyA8ICgkMSwgJDIp IikpJ2AKK2lmIHRlc3QgIiQ/IiAhPSAiMCIKK3RoZW4KKyAgICBweXRob25fdmVyc2lvbj1gJFBZ VEhPTiAtViAyPiYxYAorICAgIEFDX01TR19SRVNVTFQoW25vXSkKKyAgICBBQ19NU0dfRVJST1Io CisgICAgICAgIFskcHl0aG9uX3ZlcnNpb24gaXMgdG9vIG9sZCwgbWluaW11bSByZXF1aXJlZCB2 ZXJzaW9uIGlzICQxLiQyXSkKK2Vsc2UKKyAgICBBQ19NU0dfUkVTVUxUKFt5ZXNdKQorZmldKQpk aWZmIC0tZ2l0IGEvbTQvc2F2ZXZhci5tNCBiL200L3NhdmV2YXIubTQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uMjE1NmJlZQotLS0gL2Rldi9udWxsCisrKyBiL200L3NhdmV2 YXIubTQKQEAgLTAsMCArMSw2IEBACitBQ19ERUZVTihbQVhfU0FWRVZBUl9TQVZFXSxbCisgICAg c2F2ZWRfJDE9IiQkMSIKK10pCitBQ19ERUZVTihbQVhfU0FWRVZBUl9SRVNUT1JFXSxbCisgICAg JDE9IiRzYXZlZF8kMSIKK10pCmRpZmYgLS1naXQgYS9tNC9zZXRfY2ZsYWdzX2xkZmxhZ3MubTQg Yi9tNC9zZXRfY2ZsYWdzX2xkZmxhZ3MubTQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uZWMzYWM5ZgotLS0gL2Rldi9udWxsCisrKyBiL200L3NldF9jZmxhZ3NfbGRmbGFncy5t NApAQCAtMCwwICsxLDE5IEBACitBQ19ERUZVTihbQVhfU0VUX0ZMQUdTXSwKK1tmb3IgY3BwZmxh ZyBpbiAkUFJFUEVORF9JTkNMVURFUworZG8KKyAgICBQUkVQRU5EX0NQUEZMQUdTPSIkUFJFUEVO RF9DUFBGTEFHUyAtSSRjcHBmbGFnIgorZG9uZQorZm9yIGxkZmxhZyBpbiAkUFJFUEVORF9MSUIK K2RvCisgICAgUFJFUEVORF9MREZMQUdTPSIkUFJFUEVORF9MREZMQUdTIC1MJGxkZmxhZyIKK2Rv bmUKK2ZvciBjcHBmbGFnIGluICRBUFBFTkRfSU5DTFVERVMKK2RvCisgICAgQVBQRU5EX0NQUEZM QUdTPSIkQVBQRU5EX0NQUEZMQUdTIC1JJGNwcGZsYWciCitkb25lCitmb3IgbGRmbGFnIGluICRB UFBFTkRfTElCCitkbworICAgIEFQUEVORF9MREZMQUdTPSIkQVBQRU5EX0xERkxBR1MgLUwkbGRm bGFnIgorZG9uZQorQ1BQRkxBR1M9IiRQUkVQRU5EX0NQUEZMQUdTICRDUFBGTEFHUyAkQVBQRU5E X0NQUEZMQUdTIgorTERGTEFHUz0iJFBSRVBFTkRfTERGTEFHUyAkTERGTEFHUyAkQVBQRU5EX0xE RkxBR1MiXSkKZGlmZiAtLWdpdCBhL200L3N0dWJkb20ubTQgYi9tNC9zdHViZG9tLm00Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVjMzRhYTYKLS0tIC9kZXYvbnVsbAorKysg Yi9tNC9zdHViZG9tLm00CkBAIC0wLDAgKzEsNjMgQEAKK0FDX0RFRlVOKFtBWF9TVFVCRE9NX0lO SVRdLCBbCitTVFVCRE9NX1RBUkdFVFM9CitTVFVCRE9NX0JVSUxEPQorU1RVQkRPTV9JTlNUQUxM PQorXSkKKworQUNfREVGVU4oW0FYX1NUVUJET01fREVGQVVMVF9FTkFCTEVdLCBbCitBQ19BUkdf RU5BQkxFKFskMV0sCitBU19IRUxQX1NUUklORyhbLS1kaXNhYmxlLSQxXSwgW0J1aWxkIGFuZCBp bnN0YWxsICQxIChkZWZhdWx0IGlzIEVOQUJMRUQpXSksWworJDI9bgorXSxbCiskMj15CitTVFVC RE9NX1RBUkdFVFM9IiRTVFVCRE9NX1RBUkdFVFMgJDIiCitTVFVCRE9NX0JVSUxEPSIkU1RVQkRP TV9CVUlMRCAkMSIKK1NUVUJET01fSU5TVEFMTD0iJFNUVUJET01fSU5TVEFMTCBpbnN0YWxsLSQy IgorXSkKK0FDX1NVQlNUKCQyKQorXSkKKworQUNfREVGVU4oW0FYX1NUVUJET01fREVGQVVMVF9E SVNBQkxFXSwgWworQUNfQVJHX0VOQUJMRShbJDFdLAorQVNfSEVMUF9TVFJJTkcoWy0tZW5hYmxl LSQxXSwgW0J1aWxkIGFuZCBpbnN0YWxsICQxIChkZWZhdWx0IGlzIERJU0FCTEVEKV0pLFsKKyQy PXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01fVEFSR0VUUyAkMiIKK1NUVUJET01fQlVJTEQ9 IiRTVFVCRE9NX0JVSUxEICQxIgorU1RVQkRPTV9JTlNUQUxMPSIkU1RVQkRPTV9JTlNUQUxMIGlu c3RhbGwtJDIiCitdLFsKKyQyPW4KK10pCitBQ19TVUJTVCgkMikKK10pCisKK0FDX0RFRlVOKFtB WF9TVFVCRE9NX0ZJTklTSF0sIFsKK0FDX1NVQlNUKFNUVUJET01fVEFSR0VUUykKK0FDX1NVQlNU KFNUVUJET01fQlVJTEQpCitBQ19TVUJTVChTVFVCRE9NX0lOU1RBTEwpCitlY2hvICJXaWxsIGJ1 aWxkIHRoZSBmb2xsb3dpbmcgc3R1YiBkb21haW5zOiIKK2ZvciB4IGluICRTVFVCRE9NX0JVSUxE OyBkbworCWVjaG8gIiAgJHgiCitkb25lCitdKQorCitBQ19ERUZVTihbQVhfU1RVQkRPTV9MSUJd LCBbCitBQ19BUkdfVkFSKFskMV9VUkxdLCBbRG93bmxvYWQgdXJsIGZvciAkMl0pCitBU19JRihb dGVzdCAieCQkMV9VUkwiID0gIngiXSwgWworCUFTX0lGKFt0ZXN0ICJ4JGV4dGZpbGVzIiA9ICJ4 eSJdLAorCQlbJDFfVVJMPVxAU3xAXEB7OkBYRU5fRVhURklMRVNfVVJMXEA6fUBdLAorCQlbJDFf VVJMPSIkNCJdKQorCV0pCiskMV9WRVJTSU9OPSIkMyIKK0FDX1NVQlNUKCQxX1VSTCkKK0FDX1NV QlNUKCQxX1ZFUlNJT04pCitdKQorCitBQ19ERUZVTihbQVhfU1RVQkRPTV9MSUJfTk9FWFRdLCBb CitBQ19BUkdfVkFSKFskMV9VUkxdLCBbRG93bmxvYWQgdXJsIGZvciAkMl0pCitBU19JRihbdGVz dCAieCQkMV9VUkwiID0gIngiXSwgWworCSQxX1VSTD0iJDQiCisJXSkKKyQxX1ZFUlNJT049IiQz IgorQUNfU1VCU1QoJDFfVVJMKQorQUNfU1VCU1QoJDFfVkVSU0lPTikKK10pCmRpZmYgLS1naXQg YS9tNC91dWlkLm00IGIvbTQvdXVpZC5tNApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi4xMTdkYTVjCi0tLSAvZGV2L251bGwKKysrIGIvbTQvdXVpZC5tNApAQCAtMCwwICsxLDkg QEAKK0FDX0RFRlVOKFtBWF9DSEVDS19VVUlEXSwgWworQUNfQ0hFQ0tfSEVBREVSKFt1dWlkL3V1 aWQuaF0sWworICAgIEFDX0NIRUNLX0xJQihbdXVpZF0sIFt1dWlkX2NsZWFyXSwgW2xpYnV1aWQ9 InkiXSkKK10pCitBQ19DSEVDS19IRUFERVIoW3V1aWQuaF0sW2xpYnV1aWQ9InkiXSkKK0FTX0lG KFt0ZXN0ICIkbGlidXVpZCIgIT0gInkiXSwgWworICAgIEFDX01TR19FUlJPUihbY2Fubm90IGZp bmQgYSB2YWxpZCB1dWlkIGxpYnJhcnldKQorXSkKK10pCmRpZmYgLS1naXQgYS9zdHViZG9tL01h a2VmaWxlIGIvc3R1YmRvbS9NYWtlZmlsZQppbmRleCBmYzcwZDg4Li5mY2M2MDhlIDEwMDY0NAot LS0gYS9zdHViZG9tL01ha2VmaWxlCisrKyBiL3N0dWJkb20vTWFrZWZpbGUKQEAgLTYsNDQgKzYs NyBAQCBleHBvcnQgWEVOX09TPU1pbmlPUwogZXhwb3J0IHN0dWJkb209eQogZXhwb3J0IGRlYnVn PXkKIGluY2x1ZGUgJChYRU5fUk9PVCkvQ29uZmlnLm1rCi0KLSNaTElCX1VSTD89aHR0cDovL3d3 dy56bGliLm5ldAotWkxJQl9VUkw9JChYRU5fRVhURklMRVNfVVJMKQotWkxJQl9WRVJTSU9OPTEu Mi4zCi0KLSNMSUJQQ0lfVVJMPz1odHRwOi8vd3d3Lmtlcm5lbC5vcmcvcHViL3NvZnR3YXJlL3V0 aWxzL3BjaXV0aWxzCi1MSUJQQ0lfVVJMPz0kKFhFTl9FWFRGSUxFU19VUkwpCi1MSUJQQ0lfVkVS U0lPTj0yLjIuOQotCi0jTkVXTElCX1VSTD89ZnRwOi8vc291cmNlcy5yZWRoYXQuY29tL3B1Yi9u ZXdsaWIKLU5FV0xJQl9VUkw/PSQoWEVOX0VYVEZJTEVTX1VSTCkKLU5FV0xJQl9WRVJTSU9OPTEu MTYuMAotCi0jTFdJUF9VUkw/PWh0dHA6Ly9kb3dubG9hZC5zYXZhbm5haC5nbnUub3JnL3JlbGVh c2VzL2x3aXAKLUxXSVBfVVJMPz0kKFhFTl9FWFRGSUxFU19VUkwpCi1MV0lQX1ZFUlNJT049MS4z LjAKLQotI0dSVUJfVVJMPz1odHRwOi8vYWxwaGEuZ251Lm9yZy9nbnUvZ3J1YgotR1JVQl9VUkw/ PSQoWEVOX0VYVEZJTEVTX1VSTCkKLUdSVUJfVkVSU0lPTj0wLjk3Ci0KLSNPQ0FNTF9VUkw/PSQo WEVOX0VYVEZJTEVTX1VSTCkKLU9DQU1MX1VSTD89aHR0cDovL2NhbWwuaW5yaWEuZnIvcHViL2Rp c3RyaWIvb2NhbWwtMy4xMQotT0NBTUxfVkVSU0lPTj0zLjExLjAKLQotR01QX1ZFUlNJT049NC4z LjIKLUdNUF9VUkw/PSQoWEVOX0VYVEZJTEVTX1VSTCkKLSNHTVBfVVJMPz1mdHA6Ly9mdHAuZ21w bGliLm9yZy9wdWIvZ21wLSQoR01QX1ZFUlNJT04pCi0KLVBPTEFSU1NMX1ZFUlNJT049MS4xLjQK LVBPTEFSU1NMX1VSTD89JChYRU5fRVhURklMRVNfVVJMKQotI1BPTEFSU1NMX1VSTD89aHR0cDov L3BvbGFyc3NsLm9yZy9jb2RlL3JlbGVhc2VzCi0KLVRQTUVNVV9WRVJTSU9OPTAuNy40Ci1UUE1F TVVfVVJMPz0kKFhFTl9FWFRGSUxFU19VUkwpCi0jVFBNRU1VX1VSTD89aHR0cDovL2Rvd25sb2Fk LmJlcmxpb3MuZGUvdHBtLWVtdWxhdG9yCi0KLVdHRVQ9d2dldCAtYworaW5jbHVkZSAkKFhFTl9S T09UKS9jb25maWcvU3R1YmRvbS5tawogCiBHTlVfVEFSR0VUX0FSQ0g6PSQoWEVOX1RBUkdFVF9B UkNIKQogaWZlcSAoJChYRU5fVEFSR0VUX0FSQ0gpLHg4Nl8zMikKQEAgLTg2LDEyICs0OSwxMiBA QCBUQVJHRVRfQ1BQRkxBR1MgKz0gLUkkKFhFTl9ST09UKS94ZW4vaW5jbHVkZQogCiBUQVJHRVRf TERGTEFHUyArPSAtbm9zdGRsaWIgLUwkKENST1NTX1BSRUZJWCkvJChHTlVfVEFSR0VUX0FSQ0gp LXhlbi1lbGYvbGliCiAKLVRBUkdFVFM9aW9lbXUgYyBjYW1sIGdydWIgeGVuc3RvcmUgdnRwbSB2 dHBtbWdyCitUQVJHRVRTPSQoU1RVQkRPTV9UQVJHRVRTKQogCiAuUEhPTlk6IGFsbAogYWxsOiBi dWlsZAogaWZlcSAoJChTVFVCRE9NX1NVUFBPUlRFRCksMSkKLWJ1aWxkOiBnZW5wYXRoIGlvZW11 LXN0dWJkb20gYy1zdHViZG9tIHB2LWdydWIgeGVuc3RvcmUtc3R1YmRvbSB2dHBtLXN0dWJkb20g dnRwbW1ncmRvbQorYnVpbGQ6IGdlbnBhdGggJChTVFVCRE9NX0JVSUxEKQogZWxzZQogYnVpbGQ6 IGdlbnBhdGgKIGVuZGlmCkBAIC0yNDUsNyArMjA4LDcgQEAgdHBtX2VtdWxhdG9yLSQoWEVOX1RB UkdFVF9BUkNIKTogdHBtX2VtdWxhdG9yLSQoVFBNRU1VX1ZFUlNJT04pLnRhci5negogCW12IHRw bV9lbXVsYXRvci0kKFRQTUVNVV9WRVJTSU9OKSAkQAogCXBhdGNoIC1kICRAIC1wMSA8IHRwbWVt dS0kKFRQTUVNVV9WRVJTSU9OKS5wYXRjaDsKIAlta2RpciAkQC9idWlsZAotCWNkICRAL2J1aWxk OyBjbWFrZSAuLiAtRENNQUtFX0NfQ09NUElMRVI9JHtDQ30gLURDTUFLRV9DX0ZMQUdTPSItc3Rk PWM5OSAtRFRQTV9OT19FWFRFUk4gJChUQVJHRVRfQ1BQRkxBR1MpICQoVEFSR0VUX0NGTEFHUykg LVduby1kZWNsYXJhdGlvbi1hZnRlci1zdGF0ZW1lbnQiCisJY2QgJEAvYnVpbGQ7ICQoQ01BS0Up IC4uIC1EQ01BS0VfQ19DT01QSUxFUj0ke0NDfSAtRENNQUtFX0NfRkxBR1M9Ii1zdGQ9Yzk5IC1E VFBNX05PX0VYVEVSTiAkKFRBUkdFVF9DUFBGTEFHUykgJChUQVJHRVRfQ0ZMQUdTKSAtV25vLWRl Y2xhcmF0aW9uLWFmdGVyLXN0YXRlbWVudCIKIAl0b3VjaCAkQAogCiBUUE1FTVVfU1RBTVBGSUxF PSQoQ1JPU1NfUk9PVCkvJChHTlVfVEFSR0VUX0FSQ0gpLXhlbi1lbGYvbGliL2xpYnRwbS5hCkBA IC00ODMsNyArNDQ2LDcgQEAgeGVuc3RvcmUtc3R1YmRvbTogbWluaS1vcy0kKFhFTl9UQVJHRVRf QVJDSCkteGVuc3RvcmUgbGlieGMgeGVuc3RvcmUKICMjIyMjIyMjIwogCiBpZmVxICgkKFNUVUJE T01fU1VQUE9SVEVEKSwxKQotaW5zdGFsbDogZ2VucGF0aCBpbnN0YWxsLXJlYWRtZSBpbnN0YWxs LWlvZW11IGluc3RhbGwtZ3J1YiBpbnN0YWxsLXhlbnN0b3JlIGluc3RhbGwtdnRwbSBpbnN0YWxs LXZ0cG1tZ3IKK2luc3RhbGw6IGdlbnBhdGggaW5zdGFsbC1yZWFkbWUgJChTVFVCRE9NX0lOU1RB TEwpCiBlbHNlCiBpbnN0YWxsOiBnZW5wYXRoCiBlbmRpZgpAQCAtNTgxLDMgKzU0NCw0IEBAIGRv d25sb2FkY2xlYW46IHBhdGNoY2xlYW4KIAogLlBIT05ZOiBkaXN0Y2xlYW4KIGRpc3RjbGVhbjog ZG93bmxvYWRjbGVhbgorCS1ybSBjb25maWd1cmUKZGlmZiAtLWdpdCBhL3N0dWJkb20vY29uZmln dXJlIGIvc3R1YmRvbS9jb25maWd1cmUKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAw MC4uNmFiN2ZkMwotLS0gL2Rldi9udWxsCisrKyBiL3N0dWJkb20vY29uZmlndXJlCkBAIC0wLDAg KzEsNDM3MCBAQAorIyEgL2Jpbi9zaAorIyBHdWVzcyB2YWx1ZXMgZm9yIHN5c3RlbS1kZXBlbmRl bnQgdmFyaWFibGVzIGFuZCBjcmVhdGUgTWFrZWZpbGVzLgorIyBHZW5lcmF0ZWQgYnkgR05VIEF1 dG9jb25mIDIuNjkgZm9yIFhlbiBIeXBlcnZpc29yIFN0dWIgRG9tYWlucyA0LjMuCisjCisjIFJl cG9ydCBidWdzIHRvIDx4ZW4tZGV2ZWxAbGlzdHMueGVuLm9yZz4uCisjCisjCisjIENvcHlyaWdo dCAoQykgMTk5Mi0xOTk2LCAxOTk4LTIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu CisjCisjCisjIFRoaXMgY29uZmlndXJlIHNjcmlwdCBpcyBmcmVlIHNvZnR3YXJlOyB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisjIGdpdmVzIHVubGltaXRlZCBwZXJtaXNzaW9uIHRvIGNv cHksIGRpc3RyaWJ1dGUgYW5kIG1vZGlmeSBpdC4KKyMjIC0tLS0tLS0tLS0tLS0tLS0tLS0tICMj CisjIyBNNHNoIEluaXRpYWxpemF0aW9uLiAjIworIyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0gIyMK KworIyBCZSBtb3JlIEJvdXJuZSBjb21wYXRpYmxlCitEVUFMQ0FTRT0xOyBleHBvcnQgRFVBTENB U0UgIyBmb3IgTUtTIHNoCitpZiB0ZXN0IC1uICIke1pTSF9WRVJTSU9OK3NldH0iICYmIChlbXVs YXRlIHNoKSA+L2Rldi9udWxsIDI+JjE7IHRoZW4gOgorICBlbXVsYXRlIHNoCisgIE5VTExDTUQ9 OgorICAjIFByZS00LjIgdmVyc2lvbnMgb2YgWnNoIGRvIHdvcmQgc3BsaXR0aW5nIG9uICR7MSsi JEAifSwgd2hpY2gKKyAgIyBpcyBjb250cmFyeSB0byBvdXIgdXNhZ2UuICBEaXNhYmxlIHRoaXMg ZmVhdHVyZS4KKyAgYWxpYXMgLWcgJyR7MSsiJEAifSc9JyIkQCInCisgIHNldG9wdCBOT19HTE9C X1NVQlNUCitlbHNlCisgIGNhc2UgYChzZXQgLW8pIDI+L2Rldi9udWxsYCBpbiAjKAorICAqcG9z aXgqKSA6CisgICAgc2V0IC1vIHBvc2l4IDs7ICMoCisgICopIDoKKyAgICAgOzsKK2VzYWMKK2Zp CisKKworYXNfbmw9JworJworZXhwb3J0IGFzX25sCisjIFByaW50aW5nIGEgbG9uZyBzdHJpbmcg Y3Jhc2hlcyBTb2xhcmlzIDcgL3Vzci9iaW4vcHJpbnRmLgorYXNfZWNobz0nXFxcXFxcXFxcXFxc XFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxc XFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXCcKK2FzX2VjaG89JGFzX2VjaG8kYXNf ZWNobyRhc19lY2hvJGFzX2VjaG8kYXNfZWNobworYXNfZWNobz0kYXNfZWNobyRhc19lY2hvJGFz X2VjaG8kYXNfZWNobyRhc19lY2hvJGFzX2VjaG8KKyMgUHJlZmVyIGEga3NoIHNoZWxsIGJ1aWx0 aW4gb3ZlciBhbiBleHRlcm5hbCBwcmludGYgcHJvZ3JhbSBvbiBTb2xhcmlzLAorIyBidXQgd2l0 aG91dCB3YXN0aW5nIGZvcmtzIGZvciBiYXNoIG9yIHpzaC4KK2lmIHRlc3QgLXogIiRCQVNIX1ZF UlNJT04kWlNIX1ZFUlNJT04iIFwKKyAgICAmJiAodGVzdCAiWGBwcmludCAtciAtLSAkYXNfZWNo b2AiID0gIlgkYXNfZWNobyIpIDI+L2Rldi9udWxsOyB0aGVuCisgIGFzX2VjaG89J3ByaW50IC1y IC0tJworICBhc19lY2hvX249J3ByaW50IC1ybiAtLScKK2VsaWYgKHRlc3QgIlhgcHJpbnRmICVz ICRhc19lY2hvYCIgPSAiWCRhc19lY2hvIikgMj4vZGV2L251bGw7IHRoZW4KKyAgYXNfZWNobz0n cHJpbnRmICVzXG4nCisgIGFzX2VjaG9fbj0ncHJpbnRmICVzJworZWxzZQorICBpZiB0ZXN0ICJY YCgvdXNyL3VjYi9lY2hvIC1uIC1uICRhc19lY2hvKSAyPi9kZXYvbnVsbGAiID0gIlgtbiAkYXNf ZWNobyI7IHRoZW4KKyAgICBhc19lY2hvX2JvZHk9J2V2YWwgL3Vzci91Y2IvZWNobyAtbiAiJDEk YXNfbmwiJworICAgIGFzX2VjaG9fbj0nL3Vzci91Y2IvZWNobyAtbicKKyAgZWxzZQorICAgIGFz X2VjaG9fYm9keT0nZXZhbCBleHByICJYJDEiIDogIlhcXCguKlxcKSInCisgICAgYXNfZWNob19u X2JvZHk9J2V2YWwKKyAgICAgIGFyZz0kMTsKKyAgICAgIGNhc2UgJGFyZyBpbiAjKAorICAgICAg KiIkYXNfbmwiKikKKwlleHByICJYJGFyZyIgOiAiWFxcKC4qXFwpJGFzX25sIjsKKwlhcmc9YGV4 cHIgIlgkYXJnIiA6ICIuKiRhc19ubFxcKC4qXFwpImA7OworICAgICAgZXNhYzsKKyAgICAgIGV4 cHIgIlgkYXJnIiA6ICJYXFwoLipcXCkiIHwgdHIgLWQgIiRhc19ubCIKKyAgICAnCisgICAgZXhw b3J0IGFzX2VjaG9fbl9ib2R5CisgICAgYXNfZWNob19uPSdzaCAtYyAkYXNfZWNob19uX2JvZHkg YXNfZWNobycKKyAgZmkKKyAgZXhwb3J0IGFzX2VjaG9fYm9keQorICBhc19lY2hvPSdzaCAtYyAk YXNfZWNob19ib2R5IGFzX2VjaG8nCitmaQorCisjIFRoZSB1c2VyIGlzIGFsd2F5cyByaWdodC4K K2lmIHRlc3QgIiR7UEFUSF9TRVBBUkFUT1Irc2V0fSIgIT0gc2V0OyB0aGVuCisgIFBBVEhfU0VQ QVJBVE9SPToKKyAgKFBBVEg9Jy9iaW47L2Jpbic7IEZQQVRIPSRQQVRIOyBzaCAtYyA6KSA+L2Rl di9udWxsIDI+JjEgJiYgeworICAgIChQQVRIPScvYmluOi9iaW4nOyBGUEFUSD0kUEFUSDsgc2gg LWMgOikgPi9kZXYvbnVsbCAyPiYxIHx8CisgICAgICBQQVRIX1NFUEFSQVRPUj0nOycKKyAgfQor ZmkKKworCisjIElGUworIyBXZSBuZWVkIHNwYWNlLCB0YWIgYW5kIG5ldyBsaW5lLCBpbiBwcmVj aXNlbHkgdGhhdCBvcmRlci4gIFF1b3RpbmcgaXMKKyMgdGhlcmUgdG8gcHJldmVudCBlZGl0b3Jz IGZyb20gY29tcGxhaW5pbmcgYWJvdXQgc3BhY2UtdGFiLgorIyAoSWYgX0FTX1BBVEhfV0FMSyB3 ZXJlIGNhbGxlZCB3aXRoIElGUyB1bnNldCwgaXQgd291bGQgZGlzYWJsZSB3b3JkCisjIHNwbGl0 dGluZyBieSBzZXR0aW5nIElGUyB0byBlbXB0eSB2YWx1ZS4pCitJRlM9IiAiIgkkYXNfbmwiCisK KyMgRmluZCB3aG8gd2UgYXJlLiAgTG9vayBpbiB0aGUgcGF0aCBpZiB3ZSBjb250YWluIG5vIGRp cmVjdG9yeSBzZXBhcmF0b3IuCithc19teXNlbGY9CitjYXNlICQwIGluICMoKAorICAqW1xcL10q ICkgYXNfbXlzZWxmPSQwIDs7CisgICopIGFzX3NhdmVfSUZTPSRJRlM7IElGUz0kUEFUSF9TRVBB UkFUT1IKK2ZvciBhc19kaXIgaW4gJFBBVEgKK2RvCisgIElGUz0kYXNfc2F2ZV9JRlMKKyAgdGVz dCAteiAiJGFzX2RpciIgJiYgYXNfZGlyPS4KKyAgICB0ZXN0IC1yICIkYXNfZGlyLyQwIiAmJiBh c19teXNlbGY9JGFzX2Rpci8kMCAmJiBicmVhaworICBkb25lCitJRlM9JGFzX3NhdmVfSUZTCisK KyAgICAgOzsKK2VzYWMKKyMgV2UgZGlkIG5vdCBmaW5kIG91cnNlbHZlcywgbW9zdCBwcm9iYWJs eSB3ZSB3ZXJlIHJ1biBhcyBgc2ggQ09NTUFORCcKKyMgaW4gd2hpY2ggY2FzZSB3ZSBhcmUgbm90 IHRvIGJlIGZvdW5kIGluIHRoZSBwYXRoLgoraWYgdGVzdCAieCRhc19teXNlbGYiID0geDsgdGhl bgorICBhc19teXNlbGY9JDAKK2ZpCitpZiB0ZXN0ICEgLWYgIiRhc19teXNlbGYiOyB0aGVuCisg ICRhc19lY2hvICIkYXNfbXlzZWxmOiBlcnJvcjogY2Fubm90IGZpbmQgbXlzZWxmOyByZXJ1biB3 aXRoIGFuIGFic29sdXRlIGZpbGUgbmFtZSIgPiYyCisgIGV4aXQgMQorZmkKKworIyBVbnNldCB2 YXJpYWJsZXMgdGhhdCB3ZSBkbyBub3QgbmVlZCBhbmQgd2hpY2ggY2F1c2UgYnVncyAoZS5nLiBp bgorIyBwcmUtMy4wIFVXSU4ga3NoKS4gIEJ1dCBkbyBub3QgY2F1c2UgYnVncyBpbiBiYXNoIDIu MDE7IHRoZSAifHwgZXhpdCAxIgorIyBzdXBwcmVzc2VzIGFueSAiU2VnbWVudGF0aW9uIGZhdWx0 IiBtZXNzYWdlIHRoZXJlLiAgJygoJyBjb3VsZAorIyB0cmlnZ2VyIGEgYnVnIGluIHBka3NoIDUu Mi4xNC4KK2ZvciBhc192YXIgaW4gQkFTSF9FTlYgRU5WIE1BSUwgTUFJTFBBVEgKK2RvIGV2YWwg dGVzdCB4XCR7JGFzX3ZhcitzZXR9ID0geHNldCBcCisgICYmICggKHVuc2V0ICRhc192YXIpIHx8 IGV4aXQgMSkgPi9kZXYvbnVsbCAyPiYxICYmIHVuc2V0ICRhc192YXIgfHwgOgorZG9uZQorUFMx PSckICcKK1BTMj0nPiAnCitQUzQ9JysgJworCisjIE5MUyBudWlzYW5jZXMuCitMQ19BTEw9Qwor ZXhwb3J0IExDX0FMTAorTEFOR1VBR0U9QworZXhwb3J0IExBTkdVQUdFCisKKyMgQ0RQQVRILgor KHVuc2V0IENEUEFUSCkgPi9kZXYvbnVsbCAyPiYxICYmIHVuc2V0IENEUEFUSAorCisjIFVzZSBh IHByb3BlciBpbnRlcm5hbCBlbnZpcm9ubWVudCB2YXJpYWJsZSB0byBlbnN1cmUgd2UgZG9uJ3Qg ZmFsbAorICAjIGludG8gYW4gaW5maW5pdGUgbG9vcCwgY29udGludW91c2x5IHJlLWV4ZWN1dGlu ZyBvdXJzZWx2ZXMuCisgIGlmIHRlc3QgeCIke19hc19jYW5fcmVleGVjfSIgIT0geG5vICYmIHRl c3QgIngkQ09ORklHX1NIRUxMIiAhPSB4OyB0aGVuCisgICAgX2FzX2Nhbl9yZWV4ZWM9bm87IGV4 cG9ydCBfYXNfY2FuX3JlZXhlYzsKKyAgICAjIFdlIGNhbm5vdCB5ZXQgYXNzdW1lIGEgZGVjZW50 IHNoZWxsLCBzbyB3ZSBoYXZlIHRvIHByb3ZpZGUgYQorIyBuZXV0cmFsaXphdGlvbiB2YWx1ZSBm b3Igc2hlbGxzIHdpdGhvdXQgdW5zZXQ7IGFuZCB0aGlzIGFsc28KKyMgd29ya3MgYXJvdW5kIHNo ZWxscyB0aGF0IGNhbm5vdCB1bnNldCBub25leGlzdGVudCB2YXJpYWJsZXMuCisjIFByZXNlcnZl IC12IGFuZCAteCB0byB0aGUgcmVwbGFjZW1lbnQgc2hlbGwuCitCQVNIX0VOVj0vZGV2L251bGwK K0VOVj0vZGV2L251bGwKKyh1bnNldCBCQVNIX0VOVikgPi9kZXYvbnVsbCAyPiYxICYmIHVuc2V0 IEJBU0hfRU5WIEVOVgorY2FzZSAkLSBpbiAjICgoKCgKKyAgKnYqeCogfCAqeCp2KiApIGFzX29w dHM9LXZ4IDs7CisgICp2KiApIGFzX29wdHM9LXYgOzsKKyAgKngqICkgYXNfb3B0cz0teCA7Owor ICAqICkgYXNfb3B0cz0gOzsKK2VzYWMKK2V4ZWMgJENPTkZJR19TSEVMTCAkYXNfb3B0cyAiJGFz X215c2VsZiIgJHsxKyIkQCJ9CisjIEFkbWl0dGVkbHksIHRoaXMgaXMgcXVpdGUgcGFyYW5vaWQs IHNpbmNlIGFsbCB0aGUga25vd24gc2hlbGxzIGJhaWwKKyMgb3V0IGFmdGVyIGEgZmFpbGVkIGBl eGVjJy4KKyRhc19lY2hvICIkMDogY291bGQgbm90IHJlLWV4ZWN1dGUgd2l0aCAkQ09ORklHX1NI RUxMIiA+JjIKK2FzX2ZuX2V4aXQgMjU1CisgIGZpCisgICMgV2UgZG9uJ3Qgd2FudCB0aGlzIHRv IHByb3BhZ2F0ZSB0byBvdGhlciBzdWJwcm9jZXNzZXMuCisgICAgICAgICAgeyBfYXNfY2FuX3Jl ZXhlYz07IHVuc2V0IF9hc19jYW5fcmVleGVjO30KK2lmIHRlc3QgIngkQ09ORklHX1NIRUxMIiA9 IHg7IHRoZW4KKyAgYXNfYm91cm5lX2NvbXBhdGlibGU9ImlmIHRlc3QgLW4gXCJcJHtaU0hfVkVS U0lPTitzZXR9XCIgJiYgKGVtdWxhdGUgc2gpID4vZGV2L251bGwgMj4mMTsgdGhlbiA6CisgIGVt dWxhdGUgc2gKKyAgTlVMTENNRD06CisgICMgUHJlLTQuMiB2ZXJzaW9ucyBvZiBac2ggZG8gd29y ZCBzcGxpdHRpbmcgb24gXCR7MStcIlwkQFwifSwgd2hpY2gKKyAgIyBpcyBjb250cmFyeSB0byBv dXIgdXNhZ2UuICBEaXNhYmxlIHRoaXMgZmVhdHVyZS4KKyAgYWxpYXMgLWcgJ1wkezErXCJcJEBc In0nPSdcIlwkQFwiJworICBzZXRvcHQgTk9fR0xPQl9TVUJTVAorZWxzZQorICBjYXNlIFxgKHNl dCAtbykgMj4vZGV2L251bGxcYCBpbiAjKAorICAqcG9zaXgqKSA6CisgICAgc2V0IC1vIHBvc2l4 IDs7ICMoCisgICopIDoKKyAgICAgOzsKK2VzYWMKK2ZpCisiCisgIGFzX3JlcXVpcmVkPSJhc19m bl9yZXR1cm4gKCkgeyAoZXhpdCBcJDEpOyB9Cithc19mbl9zdWNjZXNzICgpIHsgYXNfZm5fcmV0 dXJuIDA7IH0KK2FzX2ZuX2ZhaWx1cmUgKCkgeyBhc19mbl9yZXR1cm4gMTsgfQorYXNfZm5fcmV0 X3N1Y2Nlc3MgKCkgeyByZXR1cm4gMDsgfQorYXNfZm5fcmV0X2ZhaWx1cmUgKCkgeyByZXR1cm4g MTsgfQorCitleGl0Y29kZT0wCithc19mbl9zdWNjZXNzIHx8IHsgZXhpdGNvZGU9MTsgZWNobyBh c19mbl9zdWNjZXNzIGZhaWxlZC47IH0KK2FzX2ZuX2ZhaWx1cmUgJiYgeyBleGl0Y29kZT0xOyBl Y2hvIGFzX2ZuX2ZhaWx1cmUgc3VjY2VlZGVkLjsgfQorYXNfZm5fcmV0X3N1Y2Nlc3MgfHwgeyBl eGl0Y29kZT0xOyBlY2hvIGFzX2ZuX3JldF9zdWNjZXNzIGZhaWxlZC47IH0KK2FzX2ZuX3JldF9m YWlsdXJlICYmIHsgZXhpdGNvZGU9MTsgZWNobyBhc19mbl9yZXRfZmFpbHVyZSBzdWNjZWVkZWQu OyB9CitpZiAoIHNldCB4OyBhc19mbl9yZXRfc3VjY2VzcyB5ICYmIHRlc3QgeCA9IFwiXCQxXCIg KTsgdGhlbiA6CisKK2Vsc2UKKyAgZXhpdGNvZGU9MTsgZWNobyBwb3NpdGlvbmFsIHBhcmFtZXRl cnMgd2VyZSBub3Qgc2F2ZWQuCitmaQordGVzdCB4XCRleGl0Y29kZSA9IHgwIHx8IGV4aXQgMQor dGVzdCAteCAvIHx8IGV4aXQgMSIKKyAgYXNfc3VnZ2VzdGVkPSIgIGFzX2xpbmVub18xPSI7YXNf c3VnZ2VzdGVkPSRhc19zdWdnZXN0ZWQkTElORU5PO2FzX3N1Z2dlc3RlZD0kYXNfc3VnZ2VzdGVk IiBhc19saW5lbm9fMWE9XCRMSU5FTk8KKyAgYXNfbGluZW5vXzI9Ijthc19zdWdnZXN0ZWQ9JGFz X3N1Z2dlc3RlZCRMSU5FTk87YXNfc3VnZ2VzdGVkPSRhc19zdWdnZXN0ZWQiIGFzX2xpbmVub18y YT1cJExJTkVOTworICBldmFsICd0ZXN0IFwieFwkYXNfbGluZW5vXzEnXCRhc19ydW4nXCIgIT0g XCJ4XCRhc19saW5lbm9fMidcJGFzX3J1bidcIiAmJgorICB0ZXN0IFwieFxgZXhwciBcJGFzX2xp bmVub18xJ1wkYXNfcnVuJyArIDFcYFwiID0gXCJ4XCRhc19saW5lbm9fMidcJGFzX3J1bidcIicg fHwgZXhpdCAxIgorICBpZiAoZXZhbCAiJGFzX3JlcXVpcmVkIikgMj4vZGV2L251bGw7IHRoZW4g OgorICBhc19oYXZlX3JlcXVpcmVkPXllcworZWxzZQorICBhc19oYXZlX3JlcXVpcmVkPW5vCitm aQorICBpZiB0ZXN0IHgkYXNfaGF2ZV9yZXF1aXJlZCA9IHh5ZXMgJiYgKGV2YWwgIiRhc19zdWdn ZXN0ZWQiKSAyPi9kZXYvbnVsbDsgdGhlbiA6CisKK2Vsc2UKKyAgYXNfc2F2ZV9JRlM9JElGUzsg SUZTPSRQQVRIX1NFUEFSQVRPUgorYXNfZm91bmQ9ZmFsc2UKK2ZvciBhc19kaXIgaW4gL2JpbiRQ QVRIX1NFUEFSQVRPUi91c3IvYmluJFBBVEhfU0VQQVJBVE9SJFBBVEgKK2RvCisgIElGUz0kYXNf c2F2ZV9JRlMKKyAgdGVzdCAteiAiJGFzX2RpciIgJiYgYXNfZGlyPS4KKyAgYXNfZm91bmQ9Ogor ICBjYXNlICRhc19kaXIgaW4gIygKKwkgLyopCisJICAgZm9yIGFzX2Jhc2UgaW4gc2ggYmFzaCBr c2ggc2g1OyBkbworCSAgICAgIyBUcnkgb25seSBzaGVsbHMgdGhhdCBleGlzdCwgdG8gc2F2ZSBz ZXZlcmFsIGZvcmtzLgorCSAgICAgYXNfc2hlbGw9JGFzX2Rpci8kYXNfYmFzZQorCSAgICAgaWYg eyB0ZXN0IC1mICIkYXNfc2hlbGwiIHx8IHRlc3QgLWYgIiRhc19zaGVsbC5leGUiOyB9ICYmCisJ CSAgICB7ICRhc19lY2hvICIkYXNfYm91cm5lX2NvbXBhdGlibGUiIiRhc19yZXF1aXJlZCIgfCBh c19ydW49YSAiJGFzX3NoZWxsIjsgfSAyPi9kZXYvbnVsbDsgdGhlbiA6CisgIENPTkZJR19TSEVM TD0kYXNfc2hlbGwgYXNfaGF2ZV9yZXF1aXJlZD15ZXMKKwkJICAgaWYgeyAkYXNfZWNobyAiJGFz X2JvdXJuZV9jb21wYXRpYmxlIiIkYXNfc3VnZ2VzdGVkIiB8IGFzX3J1bj1hICIkYXNfc2hlbGwi OyB9IDI+L2Rldi9udWxsOyB0aGVuIDoKKyAgYnJlYWsgMgorZmkKK2ZpCisJICAgZG9uZTs7Cisg ICAgICAgZXNhYworICBhc19mb3VuZD1mYWxzZQorZG9uZQorJGFzX2ZvdW5kIHx8IHsgaWYgeyB0 ZXN0IC1mICIkU0hFTEwiIHx8IHRlc3QgLWYgIiRTSEVMTC5leGUiOyB9ICYmCisJICAgICAgeyAk YXNfZWNobyAiJGFzX2JvdXJuZV9jb21wYXRpYmxlIiIkYXNfcmVxdWlyZWQiIHwgYXNfcnVuPWEg IiRTSEVMTCI7IH0gMj4vZGV2L251bGw7IHRoZW4gOgorICBDT05GSUdfU0hFTEw9JFNIRUxMIGFz X2hhdmVfcmVxdWlyZWQ9eWVzCitmaTsgfQorSUZTPSRhc19zYXZlX0lGUworCisKKyAgICAgIGlm IHRlc3QgIngkQ09ORklHX1NIRUxMIiAhPSB4OyB0aGVuIDoKKyAgZXhwb3J0IENPTkZJR19TSEVM TAorICAgICAgICAgICAgICMgV2UgY2Fubm90IHlldCBhc3N1bWUgYSBkZWNlbnQgc2hlbGwsIHNv IHdlIGhhdmUgdG8gcHJvdmlkZSBhCisjIG5ldXRyYWxpemF0aW9uIHZhbHVlIGZvciBzaGVsbHMg d2l0aG91dCB1bnNldDsgYW5kIHRoaXMgYWxzbworIyB3b3JrcyBhcm91bmQgc2hlbGxzIHRoYXQg Y2Fubm90IHVuc2V0IG5vbmV4aXN0ZW50IHZhcmlhYmxlcy4KKyMgUHJlc2VydmUgLXYgYW5kIC14 IHRvIHRoZSByZXBsYWNlbWVudCBzaGVsbC4KK0JBU0hfRU5WPS9kZXYvbnVsbAorRU5WPS9kZXYv bnVsbAorKHVuc2V0IEJBU0hfRU5WKSA+L2Rldi9udWxsIDI+JjEgJiYgdW5zZXQgQkFTSF9FTlYg RU5WCitjYXNlICQtIGluICMgKCgoKAorICAqdip4KiB8ICp4KnYqICkgYXNfb3B0cz0tdnggOzsK KyAgKnYqICkgYXNfb3B0cz0tdiA7OworICAqeCogKSBhc19vcHRzPS14IDs7CisgICogKSBhc19v cHRzPSA7OworZXNhYworZXhlYyAkQ09ORklHX1NIRUxMICRhc19vcHRzICIkYXNfbXlzZWxmIiAk ezErIiRAIn0KKyMgQWRtaXR0ZWRseSwgdGhpcyBpcyBxdWl0ZSBwYXJhbm9pZCwgc2luY2UgYWxs IHRoZSBrbm93biBzaGVsbHMgYmFpbAorIyBvdXQgYWZ0ZXIgYSBmYWlsZWQgYGV4ZWMnLgorJGFz X2VjaG8gIiQwOiBjb3VsZCBub3QgcmUtZXhlY3V0ZSB3aXRoICRDT05GSUdfU0hFTEwiID4mMgor ZXhpdCAyNTUKK2ZpCisKKyAgICBpZiB0ZXN0IHgkYXNfaGF2ZV9yZXF1aXJlZCA9IHhubzsgdGhl biA6CisgICRhc19lY2hvICIkMDogVGhpcyBzY3JpcHQgcmVxdWlyZXMgYSBzaGVsbCBtb3JlIG1v ZGVybiB0aGFuIGFsbCIKKyAgJGFzX2VjaG8gIiQwOiB0aGUgc2hlbGxzIHRoYXQgSSBmb3VuZCBv biB5b3VyIHN5c3RlbS4iCisgIGlmIHRlc3QgeCR7WlNIX1ZFUlNJT04rc2V0fSA9IHhzZXQgOyB0 aGVuCisgICAgJGFzX2VjaG8gIiQwOiBJbiBwYXJ0aWN1bGFyLCB6c2ggJFpTSF9WRVJTSU9OIGhh cyBidWdzIGFuZCBzaG91bGQiCisgICAgJGFzX2VjaG8gIiQwOiBiZSB1cGdyYWRlZCB0byB6c2gg NC4zLjQgb3IgbGF0ZXIuIgorICBlbHNlCisgICAgJGFzX2VjaG8gIiQwOiBQbGVhc2UgdGVsbCBi dWctYXV0b2NvbmZAZ251Lm9yZyBhbmQKKyQwOiB4ZW4tZGV2ZWxAbGlzdHMueGVuLm9yZyBhYm91 dCB5b3VyIHN5c3RlbSwgaW5jbHVkaW5nCiskMDogYW55IGVycm9yIHBvc3NpYmx5IG91dHB1dCBi ZWZvcmUgdGhpcyBtZXNzYWdlLiBUaGVuCiskMDogaW5zdGFsbCBhIG1vZGVybiBzaGVsbCwgb3Ig bWFudWFsbHkgcnVuIHRoZSBzY3JpcHQKKyQwOiB1bmRlciBzdWNoIGEgc2hlbGwgaWYgeW91IGRv IGhhdmUgb25lLiIKKyAgZmkKKyAgZXhpdCAxCitmaQorZmkKK2ZpCitTSEVMTD0ke0NPTkZJR19T SEVMTC0vYmluL3NofQorZXhwb3J0IFNIRUxMCisjIFVuc2V0IG1vcmUgdmFyaWFibGVzIGtub3du IHRvIGludGVyZmVyZSB3aXRoIGJlaGF2aW9yIG9mIGNvbW1vbiB0b29scy4KK0NMSUNPTE9SX0ZP UkNFPSBHUkVQX09QVElPTlM9Cit1bnNldCBDTElDT0xPUl9GT1JDRSBHUkVQX09QVElPTlMKKwor IyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tICMjCisjIyBNNHNoIFNoZWxsIEZ1bmN0aW9ucy4gIyMK KyMjIC0tLS0tLS0tLS0tLS0tLS0tLS0tLSAjIworIyBhc19mbl91bnNldCBWQVIKKyMgLS0tLS0t LS0tLS0tLS0tCisjIFBvcnRhYmx5IHVuc2V0IFZBUi4KK2FzX2ZuX3Vuc2V0ICgpCit7CisgIHsg ZXZhbCAkMT07IHVuc2V0ICQxO30KK30KK2FzX3Vuc2V0PWFzX2ZuX3Vuc2V0CisKKyMgYXNfZm5f c2V0X3N0YXR1cyBTVEFUVVMKKyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyMgU2V0ICQ/IHRv IFNUQVRVUywgd2l0aG91dCBmb3JraW5nLgorYXNfZm5fc2V0X3N0YXR1cyAoKQoreworICByZXR1 cm4gJDEKK30gIyBhc19mbl9zZXRfc3RhdHVzCisKKyMgYXNfZm5fZXhpdCBTVEFUVVMKKyMgLS0t LS0tLS0tLS0tLS0tLS0KKyMgRXhpdCB0aGUgc2hlbGwgd2l0aCBTVEFUVVMsIGV2ZW4gaW4gYSAi dHJhcCAwIiBvciAic2V0IC1lIiBjb250ZXh0LgorYXNfZm5fZXhpdCAoKQoreworICBzZXQgK2UK KyAgYXNfZm5fc2V0X3N0YXR1cyAkMQorICBleGl0ICQxCit9ICMgYXNfZm5fZXhpdAorCisjIGFz X2ZuX21rZGlyX3AKKyMgLS0tLS0tLS0tLS0tLQorIyBDcmVhdGUgIiRhc19kaXIiIGFzIGEgZGly ZWN0b3J5LCBpbmNsdWRpbmcgcGFyZW50cyBpZiBuZWNlc3NhcnkuCithc19mbl9ta2Rpcl9wICgp Cit7CisKKyAgY2FzZSAkYXNfZGlyIGluICMoCisgIC0qKSBhc19kaXI9Li8kYXNfZGlyOzsKKyAg ZXNhYworICB0ZXN0IC1kICIkYXNfZGlyIiB8fCBldmFsICRhc19ta2Rpcl9wIHx8IHsKKyAgICBh c19kaXJzPQorICAgIHdoaWxlIDo7IGRvCisgICAgICBjYXNlICRhc19kaXIgaW4gIygKKyAgICAg ICpcJyopIGFzX3FkaXI9YCRhc19lY2hvICIkYXNfZGlyIiB8IHNlZCAicy8nLydcXFxcXFxcXCcn L2ciYDs7ICMnKAorICAgICAgKikgYXNfcWRpcj0kYXNfZGlyOzsKKyAgICAgIGVzYWMKKyAgICAg IGFzX2RpcnM9IickYXNfcWRpcicgJGFzX2RpcnMiCisgICAgICBhc19kaXI9YCRhc19kaXJuYW1l IC0tICIkYXNfZGlyIiB8fAorJGFzX2V4cHIgWCIkYXNfZGlyIiA6ICdYXCguKlteL11cKS8vKlte L11bXi9dKi8qJCcgXHwgXAorCSBYIiRhc19kaXIiIDogJ1hcKC8vXClbXi9dJyBcfCBcCisJIFgi JGFzX2RpciIgOiAnWFwoLy9cKSQnIFx8IFwKKwkgWCIkYXNfZGlyIiA6ICdYXCgvXCknIFx8IC4g Mj4vZGV2L251bGwgfHwKKyRhc19lY2hvIFgiJGFzX2RpciIgfAorICAgIHNlZCAnL15YXCguKlte L11cKVwvXC8qW14vXVteL10qXC8qJC97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICAv XlhcKFwvXC9cKVteL10uKi97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICAvXlhcKFwv XC9cKSQveworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgL15YXChcL1wpLioveworCSAg ICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgcy8uKi8uLzsgcSdgCisgICAgICB0ZXN0IC1kICIk YXNfZGlyIiAmJiBicmVhaworICAgIGRvbmUKKyAgICB0ZXN0IC16ICIkYXNfZGlycyIgfHwgZXZh bCAibWtkaXIgJGFzX2RpcnMiCisgIH0gfHwgdGVzdCAtZCAiJGFzX2RpciIgfHwgYXNfZm5fZXJy b3IgJD8gImNhbm5vdCBjcmVhdGUgZGlyZWN0b3J5ICRhc19kaXIiCisKKworfSAjIGFzX2ZuX21r ZGlyX3AKKworIyBhc19mbl9leGVjdXRhYmxlX3AgRklMRQorIyAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQorIyBUZXN0IGlmIEZJTEUgaXMgYW4gZXhlY3V0YWJsZSByZWd1bGFyIGZpbGUuCithc19m bl9leGVjdXRhYmxlX3AgKCkKK3sKKyAgdGVzdCAtZiAiJDEiICYmIHRlc3QgLXggIiQxIgorfSAj IGFzX2ZuX2V4ZWN1dGFibGVfcAorIyBhc19mbl9hcHBlbmQgVkFSIFZBTFVFCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KKyMgQXBwZW5kIHRoZSB0ZXh0IGluIFZBTFVFIHRvIHRoZSBlbmQgb2Yg dGhlIGRlZmluaXRpb24gY29udGFpbmVkIGluIFZBUi4gVGFrZQorIyBhZHZhbnRhZ2Ugb2YgYW55 IHNoZWxsIG9wdGltaXphdGlvbnMgdGhhdCBhbGxvdyBhbW9ydGl6ZWQgbGluZWFyIGdyb3d0aCBv dmVyCisjIHJlcGVhdGVkIGFwcGVuZHMsIGluc3RlYWQgb2YgdGhlIHR5cGljYWwgcXVhZHJhdGlj IGdyb3d0aCBwcmVzZW50IGluIG5haXZlCisjIGltcGxlbWVudGF0aW9ucy4KK2lmIChldmFsICJh c192YXI9MTsgYXNfdmFyKz0yOyB0ZXN0IHhcJGFzX3ZhciA9IHgxMiIpIDI+L2Rldi9udWxsOyB0 aGVuIDoKKyAgZXZhbCAnYXNfZm5fYXBwZW5kICgpCisgIHsKKyAgICBldmFsICQxKz1cJDIKKyAg fScKK2Vsc2UKKyAgYXNfZm5fYXBwZW5kICgpCisgIHsKKyAgICBldmFsICQxPVwkJDFcJDIKKyAg fQorZmkgIyBhc19mbl9hcHBlbmQKKworIyBhc19mbl9hcml0aCBBUkcuLi4KKyMgLS0tLS0tLS0t LS0tLS0tLS0tCisjIFBlcmZvcm0gYXJpdGhtZXRpYyBldmFsdWF0aW9uIG9uIHRoZSBBUkdzLCBh bmQgc3RvcmUgdGhlIHJlc3VsdCBpbiB0aGUKKyMgZ2xvYmFsICRhc192YWwuIFRha2UgYWR2YW50 YWdlIG9mIHNoZWxscyB0aGF0IGNhbiBhdm9pZCBmb3Jrcy4gVGhlIGFyZ3VtZW50cworIyBtdXN0 IGJlIHBvcnRhYmxlIGFjcm9zcyAkKCgpKSBhbmQgZXhwci4KK2lmIChldmFsICJ0ZXN0IFwkKCgg MSArIDEgKSkgPSAyIikgMj4vZGV2L251bGw7IHRoZW4gOgorICBldmFsICdhc19mbl9hcml0aCAo KQorICB7CisgICAgYXNfdmFsPSQoKCAkKiApKQorICB9JworZWxzZQorICBhc19mbl9hcml0aCAo KQorICB7CisgICAgYXNfdmFsPWBleHByICIkQCIgfHwgdGVzdCAkPyAtZXEgMWAKKyAgfQorZmkg IyBhc19mbl9hcml0aAorCisKKyMgYXNfZm5fZXJyb3IgU1RBVFVTIEVSUk9SIFtMSU5FTk8gTE9H X0ZEXQorIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisjIE91dHB1 dCAiYGJhc2VuYW1lICQwYDogZXJyb3I6IEVSUk9SIiB0byBzdGRlcnIuIElmIExJTkVOTyBhbmQg TE9HX0ZEIGFyZQorIyBwcm92aWRlZCwgYWxzbyBvdXRwdXQgdGhlIGVycm9yIHRvIExPR19GRCwg cmVmZXJlbmNpbmcgTElORU5PLiBUaGVuIGV4aXQgdGhlCisjIHNjcmlwdCB3aXRoIFNUQVRVUywg dXNpbmcgMSBpZiB0aGF0IHdhcyAwLgorYXNfZm5fZXJyb3IgKCkKK3sKKyAgYXNfc3RhdHVzPSQx OyB0ZXN0ICRhc19zdGF0dXMgLWVxIDAgJiYgYXNfc3RhdHVzPTEKKyAgaWYgdGVzdCAiJDQiOyB0 aGVuCisgICAgYXNfbGluZW5vPSR7YXNfbGluZW5vLSIkMyJ9IGFzX2xpbmVub19zdGFjaz1hc19s aW5lbm9fc3RhY2s9JGFzX2xpbmVub19zdGFjaworICAgICRhc19lY2hvICIkYXNfbWU6JHthc19s aW5lbm8tJExJTkVOT306IGVycm9yOiAkMiIgPiYkNAorICBmaQorICAkYXNfZWNobyAiJGFzX21l OiBlcnJvcjogJDIiID4mMgorICBhc19mbl9leGl0ICRhc19zdGF0dXMKK30gIyBhc19mbl9lcnJv cgorCitpZiBleHByIGEgOiAnXChhXCknID4vZGV2L251bGwgMj4mMSAmJgorICAgdGVzdCAiWGBl eHByIDAwMDAxIDogJy4qXCguLi5cKSdgIiA9IFgwMDE7IHRoZW4KKyAgYXNfZXhwcj1leHByCitl bHNlCisgIGFzX2V4cHI9ZmFsc2UKK2ZpCisKK2lmIChiYXNlbmFtZSAtLSAvKSA+L2Rldi9udWxs IDI+JjEgJiYgdGVzdCAiWGBiYXNlbmFtZSAtLSAvIDI+JjFgIiA9ICJYLyI7IHRoZW4KKyAgYXNf YmFzZW5hbWU9YmFzZW5hbWUKK2Vsc2UKKyAgYXNfYmFzZW5hbWU9ZmFsc2UKK2ZpCisKK2lmIChh c19kaXI9YGRpcm5hbWUgLS0gL2AgJiYgdGVzdCAiWCRhc19kaXIiID0gWC8pID4vZGV2L251bGwg Mj4mMTsgdGhlbgorICBhc19kaXJuYW1lPWRpcm5hbWUKK2Vsc2UKKyAgYXNfZGlybmFtZT1mYWxz ZQorZmkKKworYXNfbWU9YCRhc19iYXNlbmFtZSAtLSAiJDAiIHx8CiskYXNfZXhwciBYLyIkMCIg OiAnLiovXChbXi9dW14vXSpcKS8qJCcgXHwgXAorCSBYIiQwIiA6ICdYXCgvL1wpJCcgXHwgXAor CSBYIiQwIiA6ICdYXCgvXCknIFx8IC4gMj4vZGV2L251bGwgfHwKKyRhc19lY2hvIFgvIiQwIiB8 CisgICAgc2VkICcvXi4qXC9cKFteL11bXi9dKlwpXC8qJC97CisJICAgIHMvL1wxLworCSAgICBx CisJICB9CisJICAvXlhcL1woXC9cL1wpJC97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJ ICAvXlhcL1woXC9cKS4qL3sKKwkgICAgcy8vXDEvCisJICAgIHEKKwkgIH0KKwkgIHMvLiovLi87 IHEnYAorCisjIEF2b2lkIGRlcGVuZGluZyB1cG9uIENoYXJhY3RlciBSYW5nZXMuCithc19jcl9s ZXR0ZXJzPSdhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5eicKK2FzX2NyX0xFVFRFUlM9J0FCQ0RF RkdISUpLTE1OT1BRUlNUVVZXWFlaJworYXNfY3JfTGV0dGVycz0kYXNfY3JfbGV0dGVycyRhc19j cl9MRVRURVJTCithc19jcl9kaWdpdHM9JzAxMjM0NTY3ODknCithc19jcl9hbG51bT0kYXNfY3Jf TGV0dGVycyRhc19jcl9kaWdpdHMKKworCisgIGFzX2xpbmVub18xPSRMSU5FTk8gYXNfbGluZW5v XzFhPSRMSU5FTk8KKyAgYXNfbGluZW5vXzI9JExJTkVOTyBhc19saW5lbm9fMmE9JExJTkVOTwor ICBldmFsICd0ZXN0ICJ4JGFzX2xpbmVub18xJyRhc19ydW4nIiAhPSAieCRhc19saW5lbm9fMick YXNfcnVuJyIgJiYKKyAgdGVzdCAieGBleHByICRhc19saW5lbm9fMSckYXNfcnVuJyArIDFgIiA9 ICJ4JGFzX2xpbmVub18yJyRhc19ydW4nIicgfHwgeworICAjIEJsYW1lIExlZSBFLiBNY01haG9u ICgxOTMxLTE5ODkpIGZvciBzZWQncyBzeW50YXguICA6LSkKKyAgc2VkIC1uICcKKyAgICBwCisg ICAgL1skXUxJTkVOTy89CisgICcgPCRhc19teXNlbGYgfAorICAgIHNlZCAnCisgICAgICBzL1sk XUxJTkVOTy4qLyYtLworICAgICAgdCBsaW5lbm8KKyAgICAgIGIKKyAgICAgIDpsaW5lbm8KKyAg ICAgIE4KKyAgICAgIDpsb29wCisgICAgICBzL1skXUxJTkVOT1woW14nJGFzX2NyX2FsbnVtJ19d LipcblwpXCguKlwpL1wyXDFcMi8KKyAgICAgIHQgbG9vcAorICAgICAgcy8tXG4uKi8vCisgICAg JyA+JGFzX21lLmxpbmVubyAmJgorICBjaG1vZCAreCAiJGFzX21lLmxpbmVubyIgfHwKKyAgICB7 ICRhc19lY2hvICIkYXNfbWU6IGVycm9yOiBjYW5ub3QgY3JlYXRlICRhc19tZS5saW5lbm87IHJl cnVuIHdpdGggYSBQT1NJWCBzaGVsbCIgPiYyOyBhc19mbl9leGl0IDE7IH0KKworICAjIElmIHdl IGhhZCB0byByZS1leGVjdXRlIHdpdGggJENPTkZJR19TSEVMTCwgd2UncmUgZW5zdXJlZCB0byBo YXZlCisgICMgYWxyZWFkeSBkb25lIHRoYXQsIHNvIGVuc3VyZSB3ZSBkb24ndCB0cnkgdG8gZG8g c28gYWdhaW4gYW5kIGZhbGwKKyAgIyBpbiBhbiBpbmZpbml0ZSBsb29wLiAgVGhpcyBoYXMgYWxy ZWFkeSBoYXBwZW5lZCBpbiBwcmFjdGljZS4KKyAgX2FzX2Nhbl9yZWV4ZWM9bm87IGV4cG9ydCBf YXNfY2FuX3JlZXhlYworICAjIERvbid0IHRyeSB0byBleGVjIGFzIGl0IGNoYW5nZXMgJFswXSwg Y2F1c2luZyBhbGwgc29ydCBvZiBwcm9ibGVtcworICAjICh0aGUgZGlybmFtZSBvZiAkWzBdIGlz IG5vdCB0aGUgcGxhY2Ugd2hlcmUgd2UgbWlnaHQgZmluZCB0aGUKKyAgIyBvcmlnaW5hbCBhbmQg c28gb24uICBBdXRvY29uZiBpcyBlc3BlY2lhbGx5IHNlbnNpdGl2ZSB0byB0aGlzKS4KKyAgLiAi Li8kYXNfbWUubGluZW5vIgorICAjIEV4aXQgc3RhdHVzIGlzIHRoYXQgb2YgdGhlIGxhc3QgY29t bWFuZC4KKyAgZXhpdAorfQorCitFQ0hPX0M9IEVDSE9fTj0gRUNIT19UPQorY2FzZSBgZWNobyAt biB4YCBpbiAjKCgoKCgKKy1uKikKKyAgY2FzZSBgZWNobyAneHlcYydgIGluCisgICpjKikgRUNI T19UPScJJzs7CSMgRUNIT19UIGlzIHNpbmdsZSB0YWIgY2hhcmFjdGVyLgorICB4eSkgIEVDSE9f Qz0nXGMnOzsKKyAgKikgICBlY2hvIGBlY2hvIGtzaDg4IGJ1ZyBvbiBBSVggNi4xYCA+IC9kZXYv bnVsbAorICAgICAgIEVDSE9fVD0nCSc7OworICBlc2FjOzsKKyopCisgIEVDSE9fTj0nLW4nOzsK K2VzYWMKKworcm0gLWYgY29uZiQkIGNvbmYkJC5leGUgY29uZiQkLmZpbGUKK2lmIHRlc3QgLWQg Y29uZiQkLmRpcjsgdGhlbgorICBybSAtZiBjb25mJCQuZGlyL2NvbmYkJC5maWxlCitlbHNlCisg IHJtIC1mIGNvbmYkJC5kaXIKKyAgbWtkaXIgY29uZiQkLmRpciAyPi9kZXYvbnVsbAorZmkKK2lm IChlY2hvID5jb25mJCQuZmlsZSkgMj4vZGV2L251bGw7IHRoZW4KKyAgaWYgbG4gLXMgY29uZiQk LmZpbGUgY29uZiQkIDI+L2Rldi9udWxsOyB0aGVuCisgICAgYXNfbG5fcz0nbG4gLXMnCisgICAg IyAuLi4gYnV0IHRoZXJlIGFyZSB0d28gZ290Y2hhczoKKyAgICAjIDEpIE9uIE1TWVMsIGJvdGgg YGxuIC1zIGZpbGUgZGlyJyBhbmQgYGxuIGZpbGUgZGlyJyBmYWlsLgorICAgICMgMikgREpHUFAg PCAyLjA0IGhhcyBubyBzeW1saW5rczsgYGxuIC1zJyBjcmVhdGVzIGEgd3JhcHBlciBleGVjdXRh YmxlLgorICAgICMgSW4gYm90aCBjYXNlcywgd2UgaGF2ZSB0byBkZWZhdWx0IHRvIGBjcCAtcFIn LgorICAgIGxuIC1zIGNvbmYkJC5maWxlIGNvbmYkJC5kaXIgMj4vZGV2L251bGwgJiYgdGVzdCAh IC1mIGNvbmYkJC5leGUgfHwKKyAgICAgIGFzX2xuX3M9J2NwIC1wUicKKyAgZWxpZiBsbiBjb25m JCQuZmlsZSBjb25mJCQgMj4vZGV2L251bGw7IHRoZW4KKyAgICBhc19sbl9zPWxuCisgIGVsc2UK KyAgICBhc19sbl9zPSdjcCAtcFInCisgIGZpCitlbHNlCisgIGFzX2xuX3M9J2NwIC1wUicKK2Zp CitybSAtZiBjb25mJCQgY29uZiQkLmV4ZSBjb25mJCQuZGlyL2NvbmYkJC5maWxlIGNvbmYkJC5m aWxlCitybWRpciBjb25mJCQuZGlyIDI+L2Rldi9udWxsCisKK2lmIG1rZGlyIC1wIC4gMj4vZGV2 L251bGw7IHRoZW4KKyAgYXNfbWtkaXJfcD0nbWtkaXIgLXAgIiRhc19kaXIiJworZWxzZQorICB0 ZXN0IC1kIC4vLXAgJiYgcm1kaXIgLi8tcAorICBhc19ta2Rpcl9wPWZhbHNlCitmaQorCithc190 ZXN0X3g9J3Rlc3QgLXgnCithc19leGVjdXRhYmxlX3A9YXNfZm5fZXhlY3V0YWJsZV9wCisKKyMg U2VkIGV4cHJlc3Npb24gdG8gbWFwIGEgc3RyaW5nIG9udG8gYSB2YWxpZCBDUFAgbmFtZS4KK2Fz X3RyX2NwcD0iZXZhbCBzZWQgJ3klKiRhc19jcl9sZXR0ZXJzJVAkYXNfY3JfTEVUVEVSUyU7cyVb Xl8kYXNfY3JfYWxudW1dJV8lZyciCisKKyMgU2VkIGV4cHJlc3Npb24gdG8gbWFwIGEgc3RyaW5n IG9udG8gYSB2YWxpZCB2YXJpYWJsZSBuYW1lLgorYXNfdHJfc2g9ImV2YWwgc2VkICd5JSorJXBw JTtzJVteXyRhc19jcl9hbG51bV0lXyVnJyIKKworCit0ZXN0IC1uICIkREpESVIiIHx8IGV4ZWMg NzwmMCA8L2Rldi9udWxsCitleGVjIDY+JjEKKworIyBOYW1lIG9mIHRoZSBob3N0LgorIyBob3N0 bmFtZSBvbiBzb21lIHN5c3RlbXMgKFNWUjMuMiwgb2xkIEdOVS9MaW51eCkgcmV0dXJucyBhIGJv Z3VzIGV4aXQgc3RhdHVzLAorIyBzbyB1bmFtZSBnZXRzIHJ1biB0b28uCithY19ob3N0bmFtZT1g KGhvc3RuYW1lIHx8IHVuYW1lIC1uKSAyPi9kZXYvbnVsbCB8IHNlZCAxcWAKKworIworIyBJbml0 aWFsaXphdGlvbnMuCisjCithY19kZWZhdWx0X3ByZWZpeD0vdXNyL2xvY2FsCithY19jbGVhbl9m aWxlcz0KK2FjX2NvbmZpZ19saWJvYmpfZGlyPS4KK0xJQk9CSlM9Citjcm9zc19jb21waWxpbmc9 bm8KK3N1YmRpcnM9CitNRkxBR1M9CitNQUtFRkxBR1M9CisKKyMgSWRlbnRpdHkgb2YgdGhpcyBw YWNrYWdlLgorUEFDS0FHRV9OQU1FPSdYZW4gSHlwZXJ2aXNvciBTdHViIERvbWFpbnMnCitQQUNL QUdFX1RBUk5BTUU9J3hlbicKK1BBQ0tBR0VfVkVSU0lPTj0nNC4zJworUEFDS0FHRV9TVFJJTkc9 J1hlbiBIeXBlcnZpc29yIFN0dWIgRG9tYWlucyA0LjMnCitQQUNLQUdFX0JVR1JFUE9SVD0neGVu LWRldmVsQGxpc3RzLnhlbi5vcmcnCitQQUNLQUdFX1VSTD0naHR0cDovL3d3dy54ZW4ub3JnLycK KworYWNfdW5pcXVlX2ZpbGU9Ii4uL2V4dHJhcy9taW5pLW9zL2tlcm5lbC5jIgorYWNfZGVmYXVs dF9wcmVmaXg9L3VzcgorYWNfc3Vic3RfdmFycz0nTFRMSUJPQkpTCitMSUJPQkpTCitTVFVCRE9N X0lOU1RBTEwKK1NUVUJET01fQlVJTEQKK1NUVUJET01fVEFSR0VUUworVFBNRU1VX1ZFUlNJT04K K1RQTUVNVV9VUkwKK1BPTEFSU1NMX1ZFUlNJT04KK1BPTEFSU1NMX1VSTAorR01QX1ZFUlNJT04K K0dNUF9VUkwKK09DQU1MX1ZFUlNJT04KK09DQU1MX1VSTAorR1JVQl9WRVJTSU9OCitHUlVCX1VS TAorTFdJUF9WRVJTSU9OCitMV0lQX1VSTAorTkVXTElCX1ZFUlNJT04KK05FV0xJQl9VUkwKK0xJ QlBDSV9WRVJTSU9OCitMSUJQQ0lfVVJMCitaTElCX1ZFUlNJT04KK1pMSUJfVVJMCitJTlNUQUxM X0RBVEEKK0lOU1RBTExfU0NSSVBUCitJTlNUQUxMX1BST0dSQU0KK1NFVF9NQUtFCitPQkpFWFQK K0VYRUVYVAorYWNfY3RfQ0MKK0NQUEZMQUdTCitMREZMQUdTCitDRkxBR1MKK0NDCitXR0VUCitD TUFLRQorZXh0ZmlsZXMKK2RlYnVnCit2dHBtbWdyCit2dHBtCit4ZW5zdG9yZQorZ3J1YgorY2Ft bAorYworaW9lbXUKK3RhcmdldF9hbGlhcworaG9zdF9hbGlhcworYnVpbGRfYWxpYXMKK0xJQlMK K0VDSE9fVAorRUNIT19OCitFQ0hPX0MKK0RFRlMKK21hbmRpcgorbG9jYWxlZGlyCitsaWJkaXIK K3BzZGlyCitwZGZkaXIKK2R2aWRpcgoraHRtbGRpcgoraW5mb2RpcgorZG9jZGlyCitvbGRpbmNs dWRlZGlyCitpbmNsdWRlZGlyCitsb2NhbHN0YXRlZGlyCitzaGFyZWRzdGF0ZWRpcgorc3lzY29u ZmRpcgorZGF0YWRpcgorZGF0YXJvb3RkaXIKK2xpYmV4ZWNkaXIKK3NiaW5kaXIKK2JpbmRpcgor cHJvZ3JhbV90cmFuc2Zvcm1fbmFtZQorcHJlZml4CitleGVjX3ByZWZpeAorUEFDS0FHRV9VUkwK K1BBQ0tBR0VfQlVHUkVQT1JUCitQQUNLQUdFX1NUUklORworUEFDS0FHRV9WRVJTSU9OCitQQUNL QUdFX1RBUk5BTUUKK1BBQ0tBR0VfTkFNRQorUEFUSF9TRVBBUkFUT1IKK1NIRUxMJworYWNfc3Vi c3RfZmlsZXM9JycKK2FjX3VzZXJfb3B0cz0nCitlbmFibGVfb3B0aW9uX2NoZWNraW5nCitlbmFi bGVfaW9lbXVfc3R1YmRvbQorZW5hYmxlX2Nfc3R1YmRvbQorZW5hYmxlX2NhbWxfc3R1YmRvbQor ZW5hYmxlX3B2X2dydWIKK2VuYWJsZV94ZW5zdG9yZV9zdHViZG9tCitlbmFibGVfdnRwbV9zdHVi ZG9tCitlbmFibGVfdnRwbW1ncmRvbQorZW5hYmxlX2RlYnVnCitlbmFibGVfZXh0ZmlsZXMKKycK KyAgICAgIGFjX3ByZWNpb3VzX3ZhcnM9J2J1aWxkX2FsaWFzCitob3N0X2FsaWFzCit0YXJnZXRf YWxpYXMKK0NNQUtFCitXR0VUCitDQworQ0ZMQUdTCitMREZMQUdTCitMSUJTCitDUFBGTEFHUwor WkxJQl9VUkwKK0xJQlBDSV9VUkwKK05FV0xJQl9VUkwKK0xXSVBfVVJMCitHUlVCX1VSTAorT0NB TUxfVVJMCitHTVBfVVJMCitQT0xBUlNTTF9VUkwKK1RQTUVNVV9VUkwnCisKKworIyBJbml0aWFs aXplIHNvbWUgdmFyaWFibGVzIHNldCBieSBvcHRpb25zLgorYWNfaW5pdF9oZWxwPQorYWNfaW5p dF92ZXJzaW9uPWZhbHNlCithY191bnJlY29nbml6ZWRfb3B0cz0KK2FjX3VucmVjb2duaXplZF9z ZXA9CisjIFRoZSB2YXJpYWJsZXMgaGF2ZSB0aGUgc2FtZSBuYW1lcyBhcyB0aGUgb3B0aW9ucywg d2l0aAorIyBkYXNoZXMgY2hhbmdlZCB0byB1bmRlcmxpbmVzLgorY2FjaGVfZmlsZT0vZGV2L251 bGwKK2V4ZWNfcHJlZml4PU5PTkUKK25vX2NyZWF0ZT0KK25vX3JlY3Vyc2lvbj0KK3ByZWZpeD1O T05FCitwcm9ncmFtX3ByZWZpeD1OT05FCitwcm9ncmFtX3N1ZmZpeD1OT05FCitwcm9ncmFtX3Ry YW5zZm9ybV9uYW1lPXMseCx4LAorc2lsZW50PQorc2l0ZT0KK3NyY2Rpcj0KK3ZlcmJvc2U9Cit4 X2luY2x1ZGVzPU5PTkUKK3hfbGlicmFyaWVzPU5PTkUKKworIyBJbnN0YWxsYXRpb24gZGlyZWN0 b3J5IG9wdGlvbnMuCisjIFRoZXNlIGFyZSBsZWZ0IHVuZXhwYW5kZWQgc28gdXNlcnMgY2FuICJt YWtlIGluc3RhbGwgZXhlY19wcmVmaXg9L2ZvbyIKKyMgYW5kIGFsbCB0aGUgdmFyaWFibGVzIHRo YXQgYXJlIHN1cHBvc2VkIHRvIGJlIGJhc2VkIG9uIGV4ZWNfcHJlZml4CisjIGJ5IGRlZmF1bHQg d2lsbCBhY3R1YWxseSBjaGFuZ2UuCisjIFVzZSBicmFjZXMgaW5zdGVhZCBvZiBwYXJlbnMgYmVj YXVzZSBzaCwgcGVybCwgZXRjLiBhbHNvIGFjY2VwdCB0aGVtLgorIyAoVGhlIGxpc3QgZm9sbG93 cyB0aGUgc2FtZSBvcmRlciBhcyB0aGUgR05VIENvZGluZyBTdGFuZGFyZHMuKQorYmluZGlyPSck e2V4ZWNfcHJlZml4fS9iaW4nCitzYmluZGlyPScke2V4ZWNfcHJlZml4fS9zYmluJworbGliZXhl Y2Rpcj0nJHtleGVjX3ByZWZpeH0vbGliZXhlYycKK2RhdGFyb290ZGlyPScke3ByZWZpeH0vc2hh cmUnCitkYXRhZGlyPScke2RhdGFyb290ZGlyfScKK3N5c2NvbmZkaXI9JyR7cHJlZml4fS9ldGMn CitzaGFyZWRzdGF0ZWRpcj0nJHtwcmVmaXh9L2NvbScKK2xvY2Fsc3RhdGVkaXI9JyR7cHJlZml4 fS92YXInCitpbmNsdWRlZGlyPScke3ByZWZpeH0vaW5jbHVkZScKK29sZGluY2x1ZGVkaXI9Jy91 c3IvaW5jbHVkZScKK2RvY2Rpcj0nJHtkYXRhcm9vdGRpcn0vZG9jLyR7UEFDS0FHRV9UQVJOQU1F fScKK2luZm9kaXI9JyR7ZGF0YXJvb3RkaXJ9L2luZm8nCitodG1sZGlyPScke2RvY2Rpcn0nCitk dmlkaXI9JyR7ZG9jZGlyfScKK3BkZmRpcj0nJHtkb2NkaXJ9JworcHNkaXI9JyR7ZG9jZGlyfScK K2xpYmRpcj0nJHtleGVjX3ByZWZpeH0vbGliJworbG9jYWxlZGlyPScke2RhdGFyb290ZGlyfS9s b2NhbGUnCittYW5kaXI9JyR7ZGF0YXJvb3RkaXJ9L21hbicKKworYWNfcHJldj0KK2FjX2Rhc2hk YXNoPQorZm9yIGFjX29wdGlvbgorZG8KKyAgIyBJZiB0aGUgcHJldmlvdXMgb3B0aW9uIG5lZWRz IGFuIGFyZ3VtZW50LCBhc3NpZ24gaXQuCisgIGlmIHRlc3QgLW4gIiRhY19wcmV2IjsgdGhlbgor ICAgIGV2YWwgJGFjX3ByZXY9XCRhY19vcHRpb24KKyAgICBhY19wcmV2PQorICAgIGNvbnRpbnVl CisgIGZpCisKKyAgY2FzZSAkYWNfb3B0aW9uIGluCisgICo9PyopIGFjX29wdGFyZz1gZXhwciAi WCRhY19vcHRpb24iIDogJ1tePV0qPVwoLipcKSdgIDs7CisgICo9KSAgIGFjX29wdGFyZz0gOzsK KyAgKikgICAgYWNfb3B0YXJnPXllcyA7OworICBlc2FjCisKKyAgIyBBY2NlcHQgdGhlIGltcG9y dGFudCBDeWdudXMgY29uZmlndXJlIG9wdGlvbnMsIHNvIHdlIGNhbiBkaWFnbm9zZSB0eXBvcy4K KworICBjYXNlICRhY19kYXNoZGFzaCRhY19vcHRpb24gaW4KKyAgLS0pCisgICAgYWNfZGFzaGRh c2g9eWVzIDs7CisKKyAgLWJpbmRpciB8IC0tYmluZGlyIHwgLS1iaW5kaSB8IC0tYmluZCB8IC0t YmluIHwgLS1iaSkKKyAgICBhY19wcmV2PWJpbmRpciA7OworICAtYmluZGlyPSogfCAtLWJpbmRp cj0qIHwgLS1iaW5kaT0qIHwgLS1iaW5kPSogfCAtLWJpbj0qIHwgLS1iaT0qKQorICAgIGJpbmRp cj0kYWNfb3B0YXJnIDs7CisKKyAgLWJ1aWxkIHwgLS1idWlsZCB8IC0tYnVpbCB8IC0tYnVpIHwg LS1idSkKKyAgICBhY19wcmV2PWJ1aWxkX2FsaWFzIDs7CisgIC1idWlsZD0qIHwgLS1idWlsZD0q IHwgLS1idWlsPSogfCAtLWJ1aT0qIHwgLS1idT0qKQorICAgIGJ1aWxkX2FsaWFzPSRhY19vcHRh cmcgOzsKKworICAtY2FjaGUtZmlsZSB8IC0tY2FjaGUtZmlsZSB8IC0tY2FjaGUtZmlsIHwgLS1j YWNoZS1maSBcCisgIHwgLS1jYWNoZS1mIHwgLS1jYWNoZS0gfCAtLWNhY2hlIHwgLS1jYWNoIHwg LS1jYWMgfCAtLWNhIHwgLS1jKQorICAgIGFjX3ByZXY9Y2FjaGVfZmlsZSA7OworICAtY2FjaGUt ZmlsZT0qIHwgLS1jYWNoZS1maWxlPSogfCAtLWNhY2hlLWZpbD0qIHwgLS1jYWNoZS1maT0qIFwK KyAgfCAtLWNhY2hlLWY9KiB8IC0tY2FjaGUtPSogfCAtLWNhY2hlPSogfCAtLWNhY2g9KiB8IC0t Y2FjPSogfCAtLWNhPSogfCAtLWM9KikKKyAgICBjYWNoZV9maWxlPSRhY19vcHRhcmcgOzsKKwor ICAtLWNvbmZpZy1jYWNoZSB8IC1DKQorICAgIGNhY2hlX2ZpbGU9Y29uZmlnLmNhY2hlIDs7CisK KyAgLWRhdGFkaXIgfCAtLWRhdGFkaXIgfCAtLWRhdGFkaSB8IC0tZGF0YWQpCisgICAgYWNfcHJl dj1kYXRhZGlyIDs7CisgIC1kYXRhZGlyPSogfCAtLWRhdGFkaXI9KiB8IC0tZGF0YWRpPSogfCAt LWRhdGFkPSopCisgICAgZGF0YWRpcj0kYWNfb3B0YXJnIDs7CisKKyAgLWRhdGFyb290ZGlyIHwg LS1kYXRhcm9vdGRpciB8IC0tZGF0YXJvb3RkaSB8IC0tZGF0YXJvb3RkIHwgLS1kYXRhcm9vdCBc CisgIHwgLS1kYXRhcm9vIHwgLS1kYXRhcm8gfCAtLWRhdGFyKQorICAgIGFjX3ByZXY9ZGF0YXJv b3RkaXIgOzsKKyAgLWRhdGFyb290ZGlyPSogfCAtLWRhdGFyb290ZGlyPSogfCAtLWRhdGFyb290 ZGk9KiB8IC0tZGF0YXJvb3RkPSogXAorICB8IC0tZGF0YXJvb3Q9KiB8IC0tZGF0YXJvbz0qIHwg LS1kYXRhcm89KiB8IC0tZGF0YXI9KikKKyAgICBkYXRhcm9vdGRpcj0kYWNfb3B0YXJnIDs7CisK KyAgLWRpc2FibGUtKiB8IC0tZGlzYWJsZS0qKQorICAgIGFjX3VzZXJvcHQ9YGV4cHIgIngkYWNf b3B0aW9uIiA6ICd4LSpkaXNhYmxlLVwoLipcKSdgCisgICAgIyBSZWplY3QgbmFtZXMgdGhhdCBh cmUgbm90IHZhbGlkIHNoZWxsIHZhcmlhYmxlIG5hbWVzLgorICAgIGV4cHIgIngkYWNfdXNlcm9w dCIgOiAiLipbXi0rLl8kYXNfY3JfYWxudW1dIiA+L2Rldi9udWxsICYmCisgICAgICBhc19mbl9l cnJvciAkPyAiaW52YWxpZCBmZWF0dXJlIG5hbWU6ICRhY191c2Vyb3B0IgorICAgIGFjX3VzZXJv cHRfb3JpZz0kYWNfdXNlcm9wdAorICAgIGFjX3VzZXJvcHQ9YCRhc19lY2hvICIkYWNfdXNlcm9w dCIgfCBzZWQgJ3MvWy0rLl0vXy9nJ2AKKyAgICBjYXNlICRhY191c2VyX29wdHMgaW4KKyAgICAg ICoiCisiZW5hYmxlXyRhY191c2Vyb3B0IgorIiopIDs7CisgICAgICAqKSBhY191bnJlY29nbml6 ZWRfb3B0cz0iJGFjX3VucmVjb2duaXplZF9vcHRzJGFjX3VucmVjb2duaXplZF9zZXAtLWRpc2Fi bGUtJGFjX3VzZXJvcHRfb3JpZyIKKwkgYWNfdW5yZWNvZ25pemVkX3NlcD0nLCAnOzsKKyAgICBl c2FjCisgICAgZXZhbCBlbmFibGVfJGFjX3VzZXJvcHQ9bm8gOzsKKworICAtZG9jZGlyIHwgLS1k b2NkaXIgfCAtLWRvY2RpIHwgLS1kb2MgfCAtLWRvKQorICAgIGFjX3ByZXY9ZG9jZGlyIDs7Cisg IC1kb2NkaXI9KiB8IC0tZG9jZGlyPSogfCAtLWRvY2RpPSogfCAtLWRvYz0qIHwgLS1kbz0qKQor ICAgIGRvY2Rpcj0kYWNfb3B0YXJnIDs7CisKKyAgLWR2aWRpciB8IC0tZHZpZGlyIHwgLS1kdmlk aSB8IC0tZHZpZCB8IC0tZHZpIHwgLS1kdikKKyAgICBhY19wcmV2PWR2aWRpciA7OworICAtZHZp ZGlyPSogfCAtLWR2aWRpcj0qIHwgLS1kdmlkaT0qIHwgLS1kdmlkPSogfCAtLWR2aT0qIHwgLS1k dj0qKQorICAgIGR2aWRpcj0kYWNfb3B0YXJnIDs7CisKKyAgLWVuYWJsZS0qIHwgLS1lbmFibGUt KikKKyAgICBhY191c2Vyb3B0PWBleHByICJ4JGFjX29wdGlvbiIgOiAneC0qZW5hYmxlLVwoW149 XSpcKSdgCisgICAgIyBSZWplY3QgbmFtZXMgdGhhdCBhcmUgbm90IHZhbGlkIHNoZWxsIHZhcmlh YmxlIG5hbWVzLgorICAgIGV4cHIgIngkYWNfdXNlcm9wdCIgOiAiLipbXi0rLl8kYXNfY3JfYWxu dW1dIiA+L2Rldi9udWxsICYmCisgICAgICBhc19mbl9lcnJvciAkPyAiaW52YWxpZCBmZWF0dXJl IG5hbWU6ICRhY191c2Vyb3B0IgorICAgIGFjX3VzZXJvcHRfb3JpZz0kYWNfdXNlcm9wdAorICAg IGFjX3VzZXJvcHQ9YCRhc19lY2hvICIkYWNfdXNlcm9wdCIgfCBzZWQgJ3MvWy0rLl0vXy9nJ2AK KyAgICBjYXNlICRhY191c2VyX29wdHMgaW4KKyAgICAgICoiCisiZW5hYmxlXyRhY191c2Vyb3B0 IgorIiopIDs7CisgICAgICAqKSBhY191bnJlY29nbml6ZWRfb3B0cz0iJGFjX3VucmVjb2duaXpl ZF9vcHRzJGFjX3VucmVjb2duaXplZF9zZXAtLWVuYWJsZS0kYWNfdXNlcm9wdF9vcmlnIgorCSBh Y191bnJlY29nbml6ZWRfc2VwPScsICc7OworICAgIGVzYWMKKyAgICBldmFsIGVuYWJsZV8kYWNf dXNlcm9wdD1cJGFjX29wdGFyZyA7OworCisgIC1leGVjLXByZWZpeCB8IC0tZXhlY19wcmVmaXgg fCAtLWV4ZWMtcHJlZml4IHwgLS1leGVjLXByZWZpIFwKKyAgfCAtLWV4ZWMtcHJlZiB8IC0tZXhl Yy1wcmUgfCAtLWV4ZWMtcHIgfCAtLWV4ZWMtcCB8IC0tZXhlYy0gXAorICB8IC0tZXhlYyB8IC0t ZXhlIHwgLS1leCkKKyAgICBhY19wcmV2PWV4ZWNfcHJlZml4IDs7CisgIC1leGVjLXByZWZpeD0q IHwgLS1leGVjX3ByZWZpeD0qIHwgLS1leGVjLXByZWZpeD0qIHwgLS1leGVjLXByZWZpPSogXAor ICB8IC0tZXhlYy1wcmVmPSogfCAtLWV4ZWMtcHJlPSogfCAtLWV4ZWMtcHI9KiB8IC0tZXhlYy1w PSogfCAtLWV4ZWMtPSogXAorICB8IC0tZXhlYz0qIHwgLS1leGU9KiB8IC0tZXg9KikKKyAgICBl eGVjX3ByZWZpeD0kYWNfb3B0YXJnIDs7CisKKyAgLWdhcyB8IC0tZ2FzIHwgLS1nYSB8IC0tZykK KyAgICAjIE9ic29sZXRlOyB1c2UgLS13aXRoLWdhcy4KKyAgICB3aXRoX2dhcz15ZXMgOzsKKwor ICAtaGVscCB8IC0taGVscCB8IC0taGVsIHwgLS1oZSB8IC1oKQorICAgIGFjX2luaXRfaGVscD1s b25nIDs7CisgIC1oZWxwPXIqIHwgLS1oZWxwPXIqIHwgLS1oZWw9ciogfCAtLWhlPXIqIHwgLWhy KikKKyAgICBhY19pbml0X2hlbHA9cmVjdXJzaXZlIDs7CisgIC1oZWxwPXMqIHwgLS1oZWxwPXMq IHwgLS1oZWw9cyogfCAtLWhlPXMqIHwgLWhzKikKKyAgICBhY19pbml0X2hlbHA9c2hvcnQgOzsK KworICAtaG9zdCB8IC0taG9zdCB8IC0taG9zIHwgLS1obykKKyAgICBhY19wcmV2PWhvc3RfYWxp YXMgOzsKKyAgLWhvc3Q9KiB8IC0taG9zdD0qIHwgLS1ob3M9KiB8IC0taG89KikKKyAgICBob3N0 X2FsaWFzPSRhY19vcHRhcmcgOzsKKworICAtaHRtbGRpciB8IC0taHRtbGRpciB8IC0taHRtbGRp IHwgLS1odG1sZCB8IC0taHRtbCB8IC0taHRtIHwgLS1odCkKKyAgICBhY19wcmV2PWh0bWxkaXIg OzsKKyAgLWh0bWxkaXI9KiB8IC0taHRtbGRpcj0qIHwgLS1odG1sZGk9KiB8IC0taHRtbGQ9KiB8 IC0taHRtbD0qIHwgLS1odG09KiBcCisgIHwgLS1odD0qKQorICAgIGh0bWxkaXI9JGFjX29wdGFy ZyA7OworCisgIC1pbmNsdWRlZGlyIHwgLS1pbmNsdWRlZGlyIHwgLS1pbmNsdWRlZGkgfCAtLWlu Y2x1ZGVkIHwgLS1pbmNsdWRlIFwKKyAgfCAtLWluY2x1ZCB8IC0taW5jbHUgfCAtLWluY2wgfCAt LWluYykKKyAgICBhY19wcmV2PWluY2x1ZGVkaXIgOzsKKyAgLWluY2x1ZGVkaXI9KiB8IC0taW5j bHVkZWRpcj0qIHwgLS1pbmNsdWRlZGk9KiB8IC0taW5jbHVkZWQ9KiB8IC0taW5jbHVkZT0qIFwK KyAgfCAtLWluY2x1ZD0qIHwgLS1pbmNsdT0qIHwgLS1pbmNsPSogfCAtLWluYz0qKQorICAgIGlu Y2x1ZGVkaXI9JGFjX29wdGFyZyA7OworCisgIC1pbmZvZGlyIHwgLS1pbmZvZGlyIHwgLS1pbmZv ZGkgfCAtLWluZm9kIHwgLS1pbmZvIHwgLS1pbmYpCisgICAgYWNfcHJldj1pbmZvZGlyIDs7Cisg IC1pbmZvZGlyPSogfCAtLWluZm9kaXI9KiB8IC0taW5mb2RpPSogfCAtLWluZm9kPSogfCAtLWlu Zm89KiB8IC0taW5mPSopCisgICAgaW5mb2Rpcj0kYWNfb3B0YXJnIDs7CisKKyAgLWxpYmRpciB8 IC0tbGliZGlyIHwgLS1saWJkaSB8IC0tbGliZCkKKyAgICBhY19wcmV2PWxpYmRpciA7OworICAt bGliZGlyPSogfCAtLWxpYmRpcj0qIHwgLS1saWJkaT0qIHwgLS1saWJkPSopCisgICAgbGliZGly PSRhY19vcHRhcmcgOzsKKworICAtbGliZXhlY2RpciB8IC0tbGliZXhlY2RpciB8IC0tbGliZXhl Y2RpIHwgLS1saWJleGVjZCB8IC0tbGliZXhlYyBcCisgIHwgLS1saWJleGUgfCAtLWxpYmV4IHwg LS1saWJlKQorICAgIGFjX3ByZXY9bGliZXhlY2RpciA7OworICAtbGliZXhlY2Rpcj0qIHwgLS1s aWJleGVjZGlyPSogfCAtLWxpYmV4ZWNkaT0qIHwgLS1saWJleGVjZD0qIHwgLS1saWJleGVjPSog XAorICB8IC0tbGliZXhlPSogfCAtLWxpYmV4PSogfCAtLWxpYmU9KikKKyAgICBsaWJleGVjZGly PSRhY19vcHRhcmcgOzsKKworICAtbG9jYWxlZGlyIHwgLS1sb2NhbGVkaXIgfCAtLWxvY2FsZWRp IHwgLS1sb2NhbGVkIHwgLS1sb2NhbGUpCisgICAgYWNfcHJldj1sb2NhbGVkaXIgOzsKKyAgLWxv Y2FsZWRpcj0qIHwgLS1sb2NhbGVkaXI9KiB8IC0tbG9jYWxlZGk9KiB8IC0tbG9jYWxlZD0qIHwg LS1sb2NhbGU9KikKKyAgICBsb2NhbGVkaXI9JGFjX29wdGFyZyA7OworCisgIC1sb2NhbHN0YXRl ZGlyIHwgLS1sb2NhbHN0YXRlZGlyIHwgLS1sb2NhbHN0YXRlZGkgfCAtLWxvY2Fsc3RhdGVkIFwK KyAgfCAtLWxvY2Fsc3RhdGUgfCAtLWxvY2Fsc3RhdCB8IC0tbG9jYWxzdGEgfCAtLWxvY2Fsc3Qg fCAtLWxvY2FscykKKyAgICBhY19wcmV2PWxvY2Fsc3RhdGVkaXIgOzsKKyAgLWxvY2Fsc3RhdGVk aXI9KiB8IC0tbG9jYWxzdGF0ZWRpcj0qIHwgLS1sb2NhbHN0YXRlZGk9KiB8IC0tbG9jYWxzdGF0 ZWQ9KiBcCisgIHwgLS1sb2NhbHN0YXRlPSogfCAtLWxvY2Fsc3RhdD0qIHwgLS1sb2NhbHN0YT0q IHwgLS1sb2NhbHN0PSogfCAtLWxvY2Fscz0qKQorICAgIGxvY2Fsc3RhdGVkaXI9JGFjX29wdGFy ZyA7OworCisgIC1tYW5kaXIgfCAtLW1hbmRpciB8IC0tbWFuZGkgfCAtLW1hbmQgfCAtLW1hbiB8 IC0tbWEgfCAtLW0pCisgICAgYWNfcHJldj1tYW5kaXIgOzsKKyAgLW1hbmRpcj0qIHwgLS1tYW5k aXI9KiB8IC0tbWFuZGk9KiB8IC0tbWFuZD0qIHwgLS1tYW49KiB8IC0tbWE9KiB8IC0tbT0qKQor ICAgIG1hbmRpcj0kYWNfb3B0YXJnIDs7CisKKyAgLW5mcCB8IC0tbmZwIHwgLS1uZikKKyAgICAj IE9ic29sZXRlOyB1c2UgLS13aXRob3V0LWZwLgorICAgIHdpdGhfZnA9bm8gOzsKKworICAtbm8t Y3JlYXRlIHwgLS1uby1jcmVhdGUgfCAtLW5vLWNyZWF0IHwgLS1uby1jcmVhIHwgLS1uby1jcmUg XAorICB8IC0tbm8tY3IgfCAtLW5vLWMgfCAtbikKKyAgICBub19jcmVhdGU9eWVzIDs7CisKKyAg LW5vLXJlY3Vyc2lvbiB8IC0tbm8tcmVjdXJzaW9uIHwgLS1uby1yZWN1cnNpbyB8IC0tbm8tcmVj dXJzaSBcCisgIHwgLS1uby1yZWN1cnMgfCAtLW5vLXJlY3VyIHwgLS1uby1yZWN1IHwgLS1uby1y ZWMgfCAtLW5vLXJlIHwgLS1uby1yKQorICAgIG5vX3JlY3Vyc2lvbj15ZXMgOzsKKworICAtb2xk aW5jbHVkZWRpciB8IC0tb2xkaW5jbHVkZWRpciB8IC0tb2xkaW5jbHVkZWRpIHwgLS1vbGRpbmNs dWRlZCBcCisgIHwgLS1vbGRpbmNsdWRlIHwgLS1vbGRpbmNsdWQgfCAtLW9sZGluY2x1IHwgLS1v bGRpbmNsIHwgLS1vbGRpbmMgXAorICB8IC0tb2xkaW4gfCAtLW9sZGkgfCAtLW9sZCB8IC0tb2wg fCAtLW8pCisgICAgYWNfcHJldj1vbGRpbmNsdWRlZGlyIDs7CisgIC1vbGRpbmNsdWRlZGlyPSog fCAtLW9sZGluY2x1ZGVkaXI9KiB8IC0tb2xkaW5jbHVkZWRpPSogfCAtLW9sZGluY2x1ZGVkPSog XAorICB8IC0tb2xkaW5jbHVkZT0qIHwgLS1vbGRpbmNsdWQ9KiB8IC0tb2xkaW5jbHU9KiB8IC0t b2xkaW5jbD0qIHwgLS1vbGRpbmM9KiBcCisgIHwgLS1vbGRpbj0qIHwgLS1vbGRpPSogfCAtLW9s ZD0qIHwgLS1vbD0qIHwgLS1vPSopCisgICAgb2xkaW5jbHVkZWRpcj0kYWNfb3B0YXJnIDs7CisK KyAgLXByZWZpeCB8IC0tcHJlZml4IHwgLS1wcmVmaSB8IC0tcHJlZiB8IC0tcHJlIHwgLS1wciB8 IC0tcCkKKyAgICBhY19wcmV2PXByZWZpeCA7OworICAtcHJlZml4PSogfCAtLXByZWZpeD0qIHwg LS1wcmVmaT0qIHwgLS1wcmVmPSogfCAtLXByZT0qIHwgLS1wcj0qIHwgLS1wPSopCisgICAgcHJl Zml4PSRhY19vcHRhcmcgOzsKKworICAtcHJvZ3JhbS1wcmVmaXggfCAtLXByb2dyYW0tcHJlZml4 IHwgLS1wcm9ncmFtLXByZWZpIHwgLS1wcm9ncmFtLXByZWYgXAorICB8IC0tcHJvZ3JhbS1wcmUg fCAtLXByb2dyYW0tcHIgfCAtLXByb2dyYW0tcCkKKyAgICBhY19wcmV2PXByb2dyYW1fcHJlZml4 IDs7CisgIC1wcm9ncmFtLXByZWZpeD0qIHwgLS1wcm9ncmFtLXByZWZpeD0qIHwgLS1wcm9ncmFt LXByZWZpPSogXAorICB8IC0tcHJvZ3JhbS1wcmVmPSogfCAtLXByb2dyYW0tcHJlPSogfCAtLXBy b2dyYW0tcHI9KiB8IC0tcHJvZ3JhbS1wPSopCisgICAgcHJvZ3JhbV9wcmVmaXg9JGFjX29wdGFy ZyA7OworCisgIC1wcm9ncmFtLXN1ZmZpeCB8IC0tcHJvZ3JhbS1zdWZmaXggfCAtLXByb2dyYW0t c3VmZmkgfCAtLXByb2dyYW0tc3VmZiBcCisgIHwgLS1wcm9ncmFtLXN1ZiB8IC0tcHJvZ3JhbS1z dSB8IC0tcHJvZ3JhbS1zKQorICAgIGFjX3ByZXY9cHJvZ3JhbV9zdWZmaXggOzsKKyAgLXByb2dy YW0tc3VmZml4PSogfCAtLXByb2dyYW0tc3VmZml4PSogfCAtLXByb2dyYW0tc3VmZmk9KiBcCisg IHwgLS1wcm9ncmFtLXN1ZmY9KiB8IC0tcHJvZ3JhbS1zdWY9KiB8IC0tcHJvZ3JhbS1zdT0qIHwg LS1wcm9ncmFtLXM9KikKKyAgICBwcm9ncmFtX3N1ZmZpeD0kYWNfb3B0YXJnIDs7CisKKyAgLXBy b2dyYW0tdHJhbnNmb3JtLW5hbWUgfCAtLXByb2dyYW0tdHJhbnNmb3JtLW5hbWUgXAorICB8IC0t cHJvZ3JhbS10cmFuc2Zvcm0tbmFtIHwgLS1wcm9ncmFtLXRyYW5zZm9ybS1uYSBcCisgIHwgLS1w cm9ncmFtLXRyYW5zZm9ybS1uIHwgLS1wcm9ncmFtLXRyYW5zZm9ybS0gXAorICB8IC0tcHJvZ3Jh bS10cmFuc2Zvcm0gfCAtLXByb2dyYW0tdHJhbnNmb3IgXAorICB8IC0tcHJvZ3JhbS10cmFuc2Zv IHwgLS1wcm9ncmFtLXRyYW5zZiBcCisgIHwgLS1wcm9ncmFtLXRyYW5zIHwgLS1wcm9ncmFtLXRy YW4gXAorICB8IC0tcHJvZ3ItdHJhIHwgLS1wcm9ncmFtLXRyIHwgLS1wcm9ncmFtLXQpCisgICAg YWNfcHJldj1wcm9ncmFtX3RyYW5zZm9ybV9uYW1lIDs7CisgIC1wcm9ncmFtLXRyYW5zZm9ybS1u YW1lPSogfCAtLXByb2dyYW0tdHJhbnNmb3JtLW5hbWU9KiBcCisgIHwgLS1wcm9ncmFtLXRyYW5z Zm9ybS1uYW09KiB8IC0tcHJvZ3JhbS10cmFuc2Zvcm0tbmE9KiBcCisgIHwgLS1wcm9ncmFtLXRy YW5zZm9ybS1uPSogfCAtLXByb2dyYW0tdHJhbnNmb3JtLT0qIFwKKyAgfCAtLXByb2dyYW0tdHJh bnNmb3JtPSogfCAtLXByb2dyYW0tdHJhbnNmb3I9KiBcCisgIHwgLS1wcm9ncmFtLXRyYW5zZm89 KiB8IC0tcHJvZ3JhbS10cmFuc2Y9KiBcCisgIHwgLS1wcm9ncmFtLXRyYW5zPSogfCAtLXByb2dy YW0tdHJhbj0qIFwKKyAgfCAtLXByb2dyLXRyYT0qIHwgLS1wcm9ncmFtLXRyPSogfCAtLXByb2dy YW0tdD0qKQorICAgIHByb2dyYW1fdHJhbnNmb3JtX25hbWU9JGFjX29wdGFyZyA7OworCisgIC1w ZGZkaXIgfCAtLXBkZmRpciB8IC0tcGRmZGkgfCAtLXBkZmQgfCAtLXBkZiB8IC0tcGQpCisgICAg YWNfcHJldj1wZGZkaXIgOzsKKyAgLXBkZmRpcj0qIHwgLS1wZGZkaXI9KiB8IC0tcGRmZGk9KiB8 IC0tcGRmZD0qIHwgLS1wZGY9KiB8IC0tcGQ9KikKKyAgICBwZGZkaXI9JGFjX29wdGFyZyA7Owor CisgIC1wc2RpciB8IC0tcHNkaXIgfCAtLXBzZGkgfCAtLXBzZCB8IC0tcHMpCisgICAgYWNfcHJl dj1wc2RpciA7OworICAtcHNkaXI9KiB8IC0tcHNkaXI9KiB8IC0tcHNkaT0qIHwgLS1wc2Q9KiB8 IC0tcHM9KikKKyAgICBwc2Rpcj0kYWNfb3B0YXJnIDs7CisKKyAgLXEgfCAtcXVpZXQgfCAtLXF1 aWV0IHwgLS1xdWllIHwgLS1xdWkgfCAtLXF1IHwgLS1xIFwKKyAgfCAtc2lsZW50IHwgLS1zaWxl bnQgfCAtLXNpbGVuIHwgLS1zaWxlIHwgLS1zaWwpCisgICAgc2lsZW50PXllcyA7OworCisgIC1z YmluZGlyIHwgLS1zYmluZGlyIHwgLS1zYmluZGkgfCAtLXNiaW5kIHwgLS1zYmluIHwgLS1zYmkg fCAtLXNiKQorICAgIGFjX3ByZXY9c2JpbmRpciA7OworICAtc2JpbmRpcj0qIHwgLS1zYmluZGly PSogfCAtLXNiaW5kaT0qIHwgLS1zYmluZD0qIHwgLS1zYmluPSogXAorICB8IC0tc2JpPSogfCAt LXNiPSopCisgICAgc2JpbmRpcj0kYWNfb3B0YXJnIDs7CisKKyAgLXNoYXJlZHN0YXRlZGlyIHwg LS1zaGFyZWRzdGF0ZWRpciB8IC0tc2hhcmVkc3RhdGVkaSBcCisgIHwgLS1zaGFyZWRzdGF0ZWQg fCAtLXNoYXJlZHN0YXRlIHwgLS1zaGFyZWRzdGF0IHwgLS1zaGFyZWRzdGEgXAorICB8IC0tc2hh cmVkc3QgfCAtLXNoYXJlZHMgfCAtLXNoYXJlZCB8IC0tc2hhcmUgfCAtLXNoYXIgXAorICB8IC0t c2hhIHwgLS1zaCkKKyAgICBhY19wcmV2PXNoYXJlZHN0YXRlZGlyIDs7CisgIC1zaGFyZWRzdGF0 ZWRpcj0qIHwgLS1zaGFyZWRzdGF0ZWRpcj0qIHwgLS1zaGFyZWRzdGF0ZWRpPSogXAorICB8IC0t c2hhcmVkc3RhdGVkPSogfCAtLXNoYXJlZHN0YXRlPSogfCAtLXNoYXJlZHN0YXQ9KiB8IC0tc2hh cmVkc3RhPSogXAorICB8IC0tc2hhcmVkc3Q9KiB8IC0tc2hhcmVkcz0qIHwgLS1zaGFyZWQ9KiB8 IC0tc2hhcmU9KiB8IC0tc2hhcj0qIFwKKyAgfCAtLXNoYT0qIHwgLS1zaD0qKQorICAgIHNoYXJl ZHN0YXRlZGlyPSRhY19vcHRhcmcgOzsKKworICAtc2l0ZSB8IC0tc2l0ZSB8IC0tc2l0KQorICAg IGFjX3ByZXY9c2l0ZSA7OworICAtc2l0ZT0qIHwgLS1zaXRlPSogfCAtLXNpdD0qKQorICAgIHNp dGU9JGFjX29wdGFyZyA7OworCisgIC1zcmNkaXIgfCAtLXNyY2RpciB8IC0tc3JjZGkgfCAtLXNy Y2QgfCAtLXNyYyB8IC0tc3IpCisgICAgYWNfcHJldj1zcmNkaXIgOzsKKyAgLXNyY2Rpcj0qIHwg LS1zcmNkaXI9KiB8IC0tc3JjZGk9KiB8IC0tc3JjZD0qIHwgLS1zcmM9KiB8IC0tc3I9KikKKyAg ICBzcmNkaXI9JGFjX29wdGFyZyA7OworCisgIC1zeXNjb25mZGlyIHwgLS1zeXNjb25mZGlyIHwg LS1zeXNjb25mZGkgfCAtLXN5c2NvbmZkIHwgLS1zeXNjb25mIFwKKyAgfCAtLXN5c2NvbiB8IC0t c3lzY28gfCAtLXN5c2MgfCAtLXN5cyB8IC0tc3kpCisgICAgYWNfcHJldj1zeXNjb25mZGlyIDs7 CisgIC1zeXNjb25mZGlyPSogfCAtLXN5c2NvbmZkaXI9KiB8IC0tc3lzY29uZmRpPSogfCAtLXN5 c2NvbmZkPSogfCAtLXN5c2NvbmY9KiBcCisgIHwgLS1zeXNjb249KiB8IC0tc3lzY289KiB8IC0t c3lzYz0qIHwgLS1zeXM9KiB8IC0tc3k9KikKKyAgICBzeXNjb25mZGlyPSRhY19vcHRhcmcgOzsK KworICAtdGFyZ2V0IHwgLS10YXJnZXQgfCAtLXRhcmdlIHwgLS10YXJnIHwgLS10YXIgfCAtLXRh IHwgLS10KQorICAgIGFjX3ByZXY9dGFyZ2V0X2FsaWFzIDs7CisgIC10YXJnZXQ9KiB8IC0tdGFy Z2V0PSogfCAtLXRhcmdlPSogfCAtLXRhcmc9KiB8IC0tdGFyPSogfCAtLXRhPSogfCAtLXQ9KikK KyAgICB0YXJnZXRfYWxpYXM9JGFjX29wdGFyZyA7OworCisgIC12IHwgLXZlcmJvc2UgfCAtLXZl cmJvc2UgfCAtLXZlcmJvcyB8IC0tdmVyYm8gfCAtLXZlcmIpCisgICAgdmVyYm9zZT15ZXMgOzsK KworICAtdmVyc2lvbiB8IC0tdmVyc2lvbiB8IC0tdmVyc2lvIHwgLS12ZXJzaSB8IC0tdmVycyB8 IC1WKQorICAgIGFjX2luaXRfdmVyc2lvbj06IDs7CisKKyAgLXdpdGgtKiB8IC0td2l0aC0qKQor ICAgIGFjX3VzZXJvcHQ9YGV4cHIgIngkYWNfb3B0aW9uIiA6ICd4LSp3aXRoLVwoW149XSpcKSdg CisgICAgIyBSZWplY3QgbmFtZXMgdGhhdCBhcmUgbm90IHZhbGlkIHNoZWxsIHZhcmlhYmxlIG5h bWVzLgorICAgIGV4cHIgIngkYWNfdXNlcm9wdCIgOiAiLipbXi0rLl8kYXNfY3JfYWxudW1dIiA+ L2Rldi9udWxsICYmCisgICAgICBhc19mbl9lcnJvciAkPyAiaW52YWxpZCBwYWNrYWdlIG5hbWU6 ICRhY191c2Vyb3B0IgorICAgIGFjX3VzZXJvcHRfb3JpZz0kYWNfdXNlcm9wdAorICAgIGFjX3Vz ZXJvcHQ9YCRhc19lY2hvICIkYWNfdXNlcm9wdCIgfCBzZWQgJ3MvWy0rLl0vXy9nJ2AKKyAgICBj YXNlICRhY191c2VyX29wdHMgaW4KKyAgICAgICoiCisid2l0aF8kYWNfdXNlcm9wdCIKKyIqKSA7 OworICAgICAgKikgYWNfdW5yZWNvZ25pemVkX29wdHM9IiRhY191bnJlY29nbml6ZWRfb3B0cyRh Y191bnJlY29nbml6ZWRfc2VwLS13aXRoLSRhY191c2Vyb3B0X29yaWciCisJIGFjX3VucmVjb2du aXplZF9zZXA9JywgJzs7CisgICAgZXNhYworICAgIGV2YWwgd2l0aF8kYWNfdXNlcm9wdD1cJGFj X29wdGFyZyA7OworCisgIC13aXRob3V0LSogfCAtLXdpdGhvdXQtKikKKyAgICBhY191c2Vyb3B0 PWBleHByICJ4JGFjX29wdGlvbiIgOiAneC0qd2l0aG91dC1cKC4qXCknYAorICAgICMgUmVqZWN0 IG5hbWVzIHRoYXQgYXJlIG5vdCB2YWxpZCBzaGVsbCB2YXJpYWJsZSBuYW1lcy4KKyAgICBleHBy ICJ4JGFjX3VzZXJvcHQiIDogIi4qW14tKy5fJGFzX2NyX2FsbnVtXSIgPi9kZXYvbnVsbCAmJgor ICAgICAgYXNfZm5fZXJyb3IgJD8gImludmFsaWQgcGFja2FnZSBuYW1lOiAkYWNfdXNlcm9wdCIK KyAgICBhY191c2Vyb3B0X29yaWc9JGFjX3VzZXJvcHQKKyAgICBhY191c2Vyb3B0PWAkYXNfZWNo byAiJGFjX3VzZXJvcHQiIHwgc2VkICdzL1stKy5dL18vZydgCisgICAgY2FzZSAkYWNfdXNlcl9v cHRzIGluCisgICAgICAqIgorIndpdGhfJGFjX3VzZXJvcHQiCisiKikgOzsKKyAgICAgICopIGFj X3VucmVjb2duaXplZF9vcHRzPSIkYWNfdW5yZWNvZ25pemVkX29wdHMkYWNfdW5yZWNvZ25pemVk X3NlcC0td2l0aG91dC0kYWNfdXNlcm9wdF9vcmlnIgorCSBhY191bnJlY29nbml6ZWRfc2VwPScs ICc7OworICAgIGVzYWMKKyAgICBldmFsIHdpdGhfJGFjX3VzZXJvcHQ9bm8gOzsKKworICAtLXgp CisgICAgIyBPYnNvbGV0ZTsgdXNlIC0td2l0aC14LgorICAgIHdpdGhfeD15ZXMgOzsKKworICAt eC1pbmNsdWRlcyB8IC0teC1pbmNsdWRlcyB8IC0teC1pbmNsdWRlIHwgLS14LWluY2x1ZCB8IC0t eC1pbmNsdSBcCisgIHwgLS14LWluY2wgfCAtLXgtaW5jIHwgLS14LWluIHwgLS14LWkpCisgICAg YWNfcHJldj14X2luY2x1ZGVzIDs7CisgIC14LWluY2x1ZGVzPSogfCAtLXgtaW5jbHVkZXM9KiB8 IC0teC1pbmNsdWRlPSogfCAtLXgtaW5jbHVkPSogfCAtLXgtaW5jbHU9KiBcCisgIHwgLS14LWlu Y2w9KiB8IC0teC1pbmM9KiB8IC0teC1pbj0qIHwgLS14LWk9KikKKyAgICB4X2luY2x1ZGVzPSRh Y19vcHRhcmcgOzsKKworICAteC1saWJyYXJpZXMgfCAtLXgtbGlicmFyaWVzIHwgLS14LWxpYnJh cmllIHwgLS14LWxpYnJhcmkgXAorICB8IC0teC1saWJyYXIgfCAtLXgtbGlicmEgfCAtLXgtbGli ciB8IC0teC1saWIgfCAtLXgtbGkgfCAtLXgtbCkKKyAgICBhY19wcmV2PXhfbGlicmFyaWVzIDs7 CisgIC14LWxpYnJhcmllcz0qIHwgLS14LWxpYnJhcmllcz0qIHwgLS14LWxpYnJhcmllPSogfCAt LXgtbGlicmFyaT0qIFwKKyAgfCAtLXgtbGlicmFyPSogfCAtLXgtbGlicmE9KiB8IC0teC1saWJy PSogfCAtLXgtbGliPSogfCAtLXgtbGk9KiB8IC0teC1sPSopCisgICAgeF9saWJyYXJpZXM9JGFj X29wdGFyZyA7OworCisgIC0qKSBhc19mbl9lcnJvciAkPyAidW5yZWNvZ25pemVkIG9wdGlvbjog XGAkYWNfb3B0aW9uJworVHJ5IFxgJDAgLS1oZWxwJyBmb3IgbW9yZSBpbmZvcm1hdGlvbiIKKyAg ICA7OworCisgICo9KikKKyAgICBhY19lbnZ2YXI9YGV4cHIgIngkYWNfb3B0aW9uIiA6ICd4XChb Xj1dKlwpPSdgCisgICAgIyBSZWplY3QgbmFtZXMgdGhhdCBhcmUgbm90IHZhbGlkIHNoZWxsIHZh cmlhYmxlIG5hbWVzLgorICAgIGNhc2UgJGFjX2VudnZhciBpbiAjKAorICAgICAgJycgfCBbMC05 XSogfCAqWyFfJGFzX2NyX2FsbnVtXSogKQorICAgICAgYXNfZm5fZXJyb3IgJD8gImludmFsaWQg dmFyaWFibGUgbmFtZTogXGAkYWNfZW52dmFyJyIgOzsKKyAgICBlc2FjCisgICAgZXZhbCAkYWNf ZW52dmFyPVwkYWNfb3B0YXJnCisgICAgZXhwb3J0ICRhY19lbnZ2YXIgOzsKKworICAqKQorICAg ICMgRklYTUU6IHNob3VsZCBiZSByZW1vdmVkIGluIGF1dG9jb25mIDMuMC4KKyAgICAkYXNfZWNo byAiJGFzX21lOiBXQVJOSU5HOiB5b3Ugc2hvdWxkIHVzZSAtLWJ1aWxkLCAtLWhvc3QsIC0tdGFy Z2V0IiA+JjIKKyAgICBleHByICJ4JGFjX29wdGlvbiIgOiAiLipbXi0uXyRhc19jcl9hbG51bV0i ID4vZGV2L251bGwgJiYKKyAgICAgICRhc19lY2hvICIkYXNfbWU6IFdBUk5JTkc6IGludmFsaWQg aG9zdCB0eXBlOiAkYWNfb3B0aW9uIiA+JjIKKyAgICA6ICIke2J1aWxkX2FsaWFzPSRhY19vcHRp b259ICR7aG9zdF9hbGlhcz0kYWNfb3B0aW9ufSAke3RhcmdldF9hbGlhcz0kYWNfb3B0aW9ufSIK KyAgICA7OworCisgIGVzYWMKK2RvbmUKKworaWYgdGVzdCAtbiAiJGFjX3ByZXYiOyB0aGVuCisg IGFjX29wdGlvbj0tLWBlY2hvICRhY19wcmV2IHwgc2VkICdzL18vLS9nJ2AKKyAgYXNfZm5fZXJy b3IgJD8gIm1pc3NpbmcgYXJndW1lbnQgdG8gJGFjX29wdGlvbiIKK2ZpCisKK2lmIHRlc3QgLW4g IiRhY191bnJlY29nbml6ZWRfb3B0cyI7IHRoZW4KKyAgY2FzZSAkZW5hYmxlX29wdGlvbl9jaGVj a2luZyBpbgorICAgIG5vKSA7OworICAgIGZhdGFsKSBhc19mbl9lcnJvciAkPyAidW5yZWNvZ25p emVkIG9wdGlvbnM6ICRhY191bnJlY29nbml6ZWRfb3B0cyIgOzsKKyAgICAqKSAgICAgJGFzX2Vj aG8gIiRhc19tZTogV0FSTklORzogdW5yZWNvZ25pemVkIG9wdGlvbnM6ICRhY191bnJlY29nbml6 ZWRfb3B0cyIgPiYyIDs7CisgIGVzYWMKK2ZpCisKKyMgQ2hlY2sgYWxsIGRpcmVjdG9yeSBhcmd1 bWVudHMgZm9yIGNvbnNpc3RlbmN5LgorZm9yIGFjX3ZhciBpbglleGVjX3ByZWZpeCBwcmVmaXgg YmluZGlyIHNiaW5kaXIgbGliZXhlY2RpciBkYXRhcm9vdGRpciBcCisJCWRhdGFkaXIgc3lzY29u ZmRpciBzaGFyZWRzdGF0ZWRpciBsb2NhbHN0YXRlZGlyIGluY2x1ZGVkaXIgXAorCQlvbGRpbmNs dWRlZGlyIGRvY2RpciBpbmZvZGlyIGh0bWxkaXIgZHZpZGlyIHBkZmRpciBwc2RpciBcCisJCWxp YmRpciBsb2NhbGVkaXIgbWFuZGlyCitkbworICBldmFsIGFjX3ZhbD1cJCRhY192YXIKKyAgIyBS ZW1vdmUgdHJhaWxpbmcgc2xhc2hlcy4KKyAgY2FzZSAkYWNfdmFsIGluCisgICAgKi8gKQorICAg ICAgYWNfdmFsPWBleHByICJYJGFjX3ZhbCIgOiAnWFwoLipbXi9dXCknIFx8ICJYJGFjX3ZhbCIg OiAnWFwoLipcKSdgCisgICAgICBldmFsICRhY192YXI9XCRhY192YWw7OworICBlc2FjCisgICMg QmUgc3VyZSB0byBoYXZlIGFic29sdXRlIGRpcmVjdG9yeSBuYW1lcy4KKyAgY2FzZSAkYWNfdmFs IGluCisgICAgW1xcLyRdKiB8ID86W1xcL10qICkgIGNvbnRpbnVlOzsKKyAgICBOT05FIHwgJycg KSBjYXNlICRhY192YXIgaW4gKnByZWZpeCApIGNvbnRpbnVlOzsgZXNhYzs7CisgIGVzYWMKKyAg YXNfZm5fZXJyb3IgJD8gImV4cGVjdGVkIGFuIGFic29sdXRlIGRpcmVjdG9yeSBuYW1lIGZvciAt LSRhY192YXI6ICRhY192YWwiCitkb25lCisKKyMgVGhlcmUgbWlnaHQgYmUgcGVvcGxlIHdobyBk ZXBlbmQgb24gdGhlIG9sZCBicm9rZW4gYmVoYXZpb3I6IGAkaG9zdCcKKyMgdXNlZCB0byBob2xk IHRoZSBhcmd1bWVudCBvZiAtLWhvc3QgZXRjLgorIyBGSVhNRTogVG8gcmVtb3ZlIHNvbWUgZGF5 LgorYnVpbGQ9JGJ1aWxkX2FsaWFzCitob3N0PSRob3N0X2FsaWFzCit0YXJnZXQ9JHRhcmdldF9h bGlhcworCisjIEZJWE1FOiBUbyByZW1vdmUgc29tZSBkYXkuCitpZiB0ZXN0ICJ4JGhvc3RfYWxp YXMiICE9IHg7IHRoZW4KKyAgaWYgdGVzdCAieCRidWlsZF9hbGlhcyIgPSB4OyB0aGVuCisgICAg Y3Jvc3NfY29tcGlsaW5nPW1heWJlCisgIGVsaWYgdGVzdCAieCRidWlsZF9hbGlhcyIgIT0gIngk aG9zdF9hbGlhcyI7IHRoZW4KKyAgICBjcm9zc19jb21waWxpbmc9eWVzCisgIGZpCitmaQorCith Y190b29sX3ByZWZpeD0KK3Rlc3QgLW4gIiRob3N0X2FsaWFzIiAmJiBhY190b29sX3ByZWZpeD0k aG9zdF9hbGlhcy0KKwordGVzdCAiJHNpbGVudCIgPSB5ZXMgJiYgZXhlYyA2Pi9kZXYvbnVsbAor CisKK2FjX3B3ZD1gcHdkYCAmJiB0ZXN0IC1uICIkYWNfcHdkIiAmJgorYWNfbHNfZGk9YGxzIC1k aSAuYCAmJgorYWNfcHdkX2xzX2RpPWBjZCAiJGFjX3B3ZCIgJiYgbHMgLWRpIC5gIHx8CisgIGFz X2ZuX2Vycm9yICQ/ICJ3b3JraW5nIGRpcmVjdG9yeSBjYW5ub3QgYmUgZGV0ZXJtaW5lZCIKK3Rl c3QgIlgkYWNfbHNfZGkiID0gIlgkYWNfcHdkX2xzX2RpIiB8fAorICBhc19mbl9lcnJvciAkPyAi cHdkIGRvZXMgbm90IHJlcG9ydCBuYW1lIG9mIHdvcmtpbmcgZGlyZWN0b3J5IgorCisKKyMgRmlu ZCB0aGUgc291cmNlIGZpbGVzLCBpZiBsb2NhdGlvbiB3YXMgbm90IHNwZWNpZmllZC4KK2lmIHRl c3QgLXogIiRzcmNkaXIiOyB0aGVuCisgIGFjX3NyY2Rpcl9kZWZhdWx0ZWQ9eWVzCisgICMgVHJ5 IHRoZSBkaXJlY3RvcnkgY29udGFpbmluZyB0aGlzIHNjcmlwdCwgdGhlbiB0aGUgcGFyZW50IGRp cmVjdG9yeS4KKyAgYWNfY29uZmRpcj1gJGFzX2Rpcm5hbWUgLS0gIiRhc19teXNlbGYiIHx8Cisk YXNfZXhwciBYIiRhc19teXNlbGYiIDogJ1hcKC4qW14vXVwpLy8qW14vXVteL10qLyokJyBcfCBc CisJIFgiJGFzX215c2VsZiIgOiAnWFwoLy9cKVteL10nIFx8IFwKKwkgWCIkYXNfbXlzZWxmIiA6 ICdYXCgvL1wpJCcgXHwgXAorCSBYIiRhc19teXNlbGYiIDogJ1hcKC9cKScgXHwgLiAyPi9kZXYv bnVsbCB8fAorJGFzX2VjaG8gWCIkYXNfbXlzZWxmIiB8CisgICAgc2VkICcvXlhcKC4qW14vXVwp XC9cLypbXi9dW14vXSpcLyokL3sKKwkgICAgcy8vXDEvCisJICAgIHEKKwkgIH0KKwkgIC9eWFwo XC9cL1wpW14vXS4qL3sKKwkgICAgcy8vXDEvCisJICAgIHEKKwkgIH0KKwkgIC9eWFwoXC9cL1wp JC97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICAvXlhcKFwvXCkuKi97CisJICAgIHMv L1wxLworCSAgICBxCisJICB9CisJICBzLy4qLy4vOyBxJ2AKKyAgc3JjZGlyPSRhY19jb25mZGly CisgIGlmIHRlc3QgISAtciAiJHNyY2Rpci8kYWNfdW5pcXVlX2ZpbGUiOyB0aGVuCisgICAgc3Jj ZGlyPS4uCisgIGZpCitlbHNlCisgIGFjX3NyY2Rpcl9kZWZhdWx0ZWQ9bm8KK2ZpCitpZiB0ZXN0 ICEgLXIgIiRzcmNkaXIvJGFjX3VuaXF1ZV9maWxlIjsgdGhlbgorICB0ZXN0ICIkYWNfc3JjZGly X2RlZmF1bHRlZCIgPSB5ZXMgJiYgc3JjZGlyPSIkYWNfY29uZmRpciBvciAuLiIKKyAgYXNfZm5f ZXJyb3IgJD8gImNhbm5vdCBmaW5kIHNvdXJjZXMgKCRhY191bmlxdWVfZmlsZSkgaW4gJHNyY2Rp ciIKK2ZpCithY19tc2c9InNvdXJjZXMgYXJlIGluICRzcmNkaXIsIGJ1dCBcYGNkICRzcmNkaXIn IGRvZXMgbm90IHdvcmsiCithY19hYnNfY29uZmRpcj1gKAorCWNkICIkc3JjZGlyIiAmJiB0ZXN0 IC1yICIuLyRhY191bmlxdWVfZmlsZSIgfHwgYXNfZm5fZXJyb3IgJD8gIiRhY19tc2ciCisJcHdk KWAKKyMgV2hlbiBidWlsZGluZyBpbiBwbGFjZSwgc2V0IHNyY2Rpcj0uCitpZiB0ZXN0ICIkYWNf YWJzX2NvbmZkaXIiID0gIiRhY19wd2QiOyB0aGVuCisgIHNyY2Rpcj0uCitmaQorIyBSZW1vdmUg dW5uZWNlc3NhcnkgdHJhaWxpbmcgc2xhc2hlcyBmcm9tIHNyY2Rpci4KKyMgRG91YmxlIHNsYXNo ZXMgaW4gZmlsZSBuYW1lcyBpbiBvYmplY3QgZmlsZSBkZWJ1Z2dpbmcgaW5mbworIyBtZXNzIHVw IE0teCBnZGIgaW4gRW1hY3MuCitjYXNlICRzcmNkaXIgaW4KKyovKSBzcmNkaXI9YGV4cHIgIlgk c3JjZGlyIiA6ICdYXCguKlteL11cKScgXHwgIlgkc3JjZGlyIiA6ICdYXCguKlwpJ2A7OworZXNh YworZm9yIGFjX3ZhciBpbiAkYWNfcHJlY2lvdXNfdmFyczsgZG8KKyAgZXZhbCBhY19lbnZfJHth Y192YXJ9X3NldD1cJHske2FjX3Zhcn0rc2V0fQorICBldmFsIGFjX2Vudl8ke2FjX3Zhcn1fdmFs dWU9XCQke2FjX3Zhcn0KKyAgZXZhbCBhY19jdl9lbnZfJHthY192YXJ9X3NldD1cJHske2FjX3Zh cn0rc2V0fQorICBldmFsIGFjX2N2X2Vudl8ke2FjX3Zhcn1fdmFsdWU9XCQke2FjX3Zhcn0KK2Rv bmUKKworIworIyBSZXBvcnQgdGhlIC0taGVscCBtZXNzYWdlLgorIworaWYgdGVzdCAiJGFjX2lu aXRfaGVscCIgPSAibG9uZyI7IHRoZW4KKyAgIyBPbWl0IHNvbWUgaW50ZXJuYWwgb3Igb2Jzb2xl dGUgb3B0aW9ucyB0byBtYWtlIHRoZSBsaXN0IGxlc3MgaW1wb3NpbmcuCisgICMgVGhpcyBtZXNz YWdlIGlzIHRvbyBsb25nIHRvIGJlIGEgc3RyaW5nIGluIHRoZSBBL1VYIDMuMSBzaC4KKyAgY2F0 IDw8X0FDRU9GCitcYGNvbmZpZ3VyZScgY29uZmlndXJlcyBYZW4gSHlwZXJ2aXNvciBTdHViIERv bWFpbnMgNC4zIHRvIGFkYXB0IHRvIG1hbnkga2luZHMgb2Ygc3lzdGVtcy4KKworVXNhZ2U6ICQw IFtPUFRJT05dLi4uIFtWQVI9VkFMVUVdLi4uCisKK1RvIGFzc2lnbiBlbnZpcm9ubWVudCB2YXJp YWJsZXMgKGUuZy4sIENDLCBDRkxBR1MuLi4pLCBzcGVjaWZ5IHRoZW0gYXMKK1ZBUj1WQUxVRS4g IFNlZSBiZWxvdyBmb3IgZGVzY3JpcHRpb25zIG9mIHNvbWUgb2YgdGhlIHVzZWZ1bCB2YXJpYWJs ZXMuCisKK0RlZmF1bHRzIGZvciB0aGUgb3B0aW9ucyBhcmUgc3BlY2lmaWVkIGluIGJyYWNrZXRz LgorCitDb25maWd1cmF0aW9uOgorICAtaCwgLS1oZWxwICAgICAgICAgICAgICBkaXNwbGF5IHRo aXMgaGVscCBhbmQgZXhpdAorICAgICAgLS1oZWxwPXNob3J0ICAgICAgICBkaXNwbGF5IG9wdGlv bnMgc3BlY2lmaWMgdG8gdGhpcyBwYWNrYWdlCisgICAgICAtLWhlbHA9cmVjdXJzaXZlICAgIGRp c3BsYXkgdGhlIHNob3J0IGhlbHAgb2YgYWxsIHRoZSBpbmNsdWRlZCBwYWNrYWdlcworICAtViwg LS12ZXJzaW9uICAgICAgICAgICBkaXNwbGF5IHZlcnNpb24gaW5mb3JtYXRpb24gYW5kIGV4aXQK KyAgLXEsIC0tcXVpZXQsIC0tc2lsZW50ICAgZG8gbm90IHByaW50IFxgY2hlY2tpbmcgLi4uJyBt ZXNzYWdlcworICAgICAgLS1jYWNoZS1maWxlPUZJTEUgICBjYWNoZSB0ZXN0IHJlc3VsdHMgaW4g RklMRSBbZGlzYWJsZWRdCisgIC1DLCAtLWNvbmZpZy1jYWNoZSAgICAgIGFsaWFzIGZvciBcYC0t Y2FjaGUtZmlsZT1jb25maWcuY2FjaGUnCisgIC1uLCAtLW5vLWNyZWF0ZSAgICAgICAgIGRvIG5v dCBjcmVhdGUgb3V0cHV0IGZpbGVzCisgICAgICAtLXNyY2Rpcj1ESVIgICAgICAgIGZpbmQgdGhl IHNvdXJjZXMgaW4gRElSIFtjb25maWd1cmUgZGlyIG9yIFxgLi4nXQorCitJbnN0YWxsYXRpb24g ZGlyZWN0b3JpZXM6CisgIC0tcHJlZml4PVBSRUZJWCAgICAgICAgIGluc3RhbGwgYXJjaGl0ZWN0 dXJlLWluZGVwZW5kZW50IGZpbGVzIGluIFBSRUZJWAorICAgICAgICAgICAgICAgICAgICAgICAg ICBbJGFjX2RlZmF1bHRfcHJlZml4XQorICAtLWV4ZWMtcHJlZml4PUVQUkVGSVggICBpbnN0YWxs IGFyY2hpdGVjdHVyZS1kZXBlbmRlbnQgZmlsZXMgaW4gRVBSRUZJWAorICAgICAgICAgICAgICAg ICAgICAgICAgICBbUFJFRklYXQorCitCeSBkZWZhdWx0LCBcYG1ha2UgaW5zdGFsbCcgd2lsbCBp bnN0YWxsIGFsbCB0aGUgZmlsZXMgaW4KK1xgJGFjX2RlZmF1bHRfcHJlZml4L2JpbicsIFxgJGFj X2RlZmF1bHRfcHJlZml4L2xpYicgZXRjLiAgWW91IGNhbiBzcGVjaWZ5CithbiBpbnN0YWxsYXRp b24gcHJlZml4IG90aGVyIHRoYW4gXGAkYWNfZGVmYXVsdF9wcmVmaXgnIHVzaW5nIFxgLS1wcmVm aXgnLAorZm9yIGluc3RhbmNlIFxgLS1wcmVmaXg9XCRIT01FJy4KKworRm9yIGJldHRlciBjb250 cm9sLCB1c2UgdGhlIG9wdGlvbnMgYmVsb3cuCisKK0ZpbmUgdHVuaW5nIG9mIHRoZSBpbnN0YWxs YXRpb24gZGlyZWN0b3JpZXM6CisgIC0tYmluZGlyPURJUiAgICAgICAgICAgIHVzZXIgZXhlY3V0 YWJsZXMgW0VQUkVGSVgvYmluXQorICAtLXNiaW5kaXI9RElSICAgICAgICAgICBzeXN0ZW0gYWRt aW4gZXhlY3V0YWJsZXMgW0VQUkVGSVgvc2Jpbl0KKyAgLS1saWJleGVjZGlyPURJUiAgICAgICAg cHJvZ3JhbSBleGVjdXRhYmxlcyBbRVBSRUZJWC9saWJleGVjXQorICAtLXN5c2NvbmZkaXI9RElS ICAgICAgICByZWFkLW9ubHkgc2luZ2xlLW1hY2hpbmUgZGF0YSBbUFJFRklYL2V0Y10KKyAgLS1z aGFyZWRzdGF0ZWRpcj1ESVIgICAgbW9kaWZpYWJsZSBhcmNoaXRlY3R1cmUtaW5kZXBlbmRlbnQg ZGF0YSBbUFJFRklYL2NvbV0KKyAgLS1sb2NhbHN0YXRlZGlyPURJUiAgICAgbW9kaWZpYWJsZSBz aW5nbGUtbWFjaGluZSBkYXRhIFtQUkVGSVgvdmFyXQorICAtLWxpYmRpcj1ESVIgICAgICAgICAg ICBvYmplY3QgY29kZSBsaWJyYXJpZXMgW0VQUkVGSVgvbGliXQorICAtLWluY2x1ZGVkaXI9RElS ICAgICAgICBDIGhlYWRlciBmaWxlcyBbUFJFRklYL2luY2x1ZGVdCisgIC0tb2xkaW5jbHVkZWRp cj1ESVIgICAgIEMgaGVhZGVyIGZpbGVzIGZvciBub24tZ2NjIFsvdXNyL2luY2x1ZGVdCisgIC0t ZGF0YXJvb3RkaXI9RElSICAgICAgIHJlYWQtb25seSBhcmNoLi1pbmRlcGVuZGVudCBkYXRhIHJv b3QgW1BSRUZJWC9zaGFyZV0KKyAgLS1kYXRhZGlyPURJUiAgICAgICAgICAgcmVhZC1vbmx5IGFy Y2hpdGVjdHVyZS1pbmRlcGVuZGVudCBkYXRhIFtEQVRBUk9PVERJUl0KKyAgLS1pbmZvZGlyPURJ UiAgICAgICAgICAgaW5mbyBkb2N1bWVudGF0aW9uIFtEQVRBUk9PVERJUi9pbmZvXQorICAtLWxv Y2FsZWRpcj1ESVIgICAgICAgICBsb2NhbGUtZGVwZW5kZW50IGRhdGEgW0RBVEFST09URElSL2xv Y2FsZV0KKyAgLS1tYW5kaXI9RElSICAgICAgICAgICAgbWFuIGRvY3VtZW50YXRpb24gW0RBVEFS T09URElSL21hbl0KKyAgLS1kb2NkaXI9RElSICAgICAgICAgICAgZG9jdW1lbnRhdGlvbiByb290 IFtEQVRBUk9PVERJUi9kb2MveGVuXQorICAtLWh0bWxkaXI9RElSICAgICAgICAgICBodG1sIGRv Y3VtZW50YXRpb24gW0RPQ0RJUl0KKyAgLS1kdmlkaXI9RElSICAgICAgICAgICAgZHZpIGRvY3Vt ZW50YXRpb24gW0RPQ0RJUl0KKyAgLS1wZGZkaXI9RElSICAgICAgICAgICAgcGRmIGRvY3VtZW50 YXRpb24gW0RPQ0RJUl0KKyAgLS1wc2Rpcj1ESVIgICAgICAgICAgICAgcHMgZG9jdW1lbnRhdGlv biBbRE9DRElSXQorX0FDRU9GCisKKyAgY2F0IDw8XF9BQ0VPRgorX0FDRU9GCitmaQorCitpZiB0 ZXN0IC1uICIkYWNfaW5pdF9oZWxwIjsgdGhlbgorICBjYXNlICRhY19pbml0X2hlbHAgaW4KKyAg ICAgc2hvcnQgfCByZWN1cnNpdmUgKSBlY2hvICJDb25maWd1cmF0aW9uIG9mIFhlbiBIeXBlcnZp c29yIFN0dWIgRG9tYWlucyA0LjM6Ijs7CisgICBlc2FjCisgIGNhdCA8PFxfQUNFT0YKKworT3B0 aW9uYWwgRmVhdHVyZXM6CisgIC0tZGlzYWJsZS1vcHRpb24tY2hlY2tpbmcgIGlnbm9yZSB1bnJl Y29nbml6ZWQgLS1lbmFibGUvLS13aXRoIG9wdGlvbnMKKyAgLS1kaXNhYmxlLUZFQVRVUkUgICAg ICAgZG8gbm90IGluY2x1ZGUgRkVBVFVSRSAoc2FtZSBhcyAtLWVuYWJsZS1GRUFUVVJFPW5vKQor ICAtLWVuYWJsZS1GRUFUVVJFWz1BUkddICBpbmNsdWRlIEZFQVRVUkUgW0FSRz15ZXNdCisgIC0t ZGlzYWJsZS1pb2VtdS1zdHViZG9tIEJ1aWxkIGFuZCBpbnN0YWxsIGlvZW11LXN0dWJkb20gKGRl ZmF1bHQgaXMgRU5BQkxFRCkKKyAgLS1lbmFibGUtYy1zdHViZG9tICAgICAgQnVpbGQgYW5kIGlu c3RhbGwgYy1zdHViZG9tIChkZWZhdWx0IGlzIERJU0FCTEVEKQorICAtLWRpc2FibGUtY2FtbC1z dHViZG9tICBCdWlsZCBhbmQgaW5zdGFsbCBjYW1sLXN0dWJkb20gKGRlZmF1bHQgaXMgRU5BQkxF RCkKKyAgLS1kaXNhYmxlLXB2LWdydWIgICAgICAgQnVpbGQgYW5kIGluc3RhbGwgcHYtZ3J1YiAo ZGVmYXVsdCBpcyBFTkFCTEVEKQorICAtLWRpc2FibGUteGVuc3RvcmUtc3R1YmRvbQorICAgICAg ICAgICAgICAgICAgICAgICAgICBCdWlsZCBhbmQgaW5zdGFsbCB4ZW5zdG9yZS1zdHViZG9tIChk ZWZhdWx0IGlzCisgICAgICAgICAgICAgICAgICAgICAgICAgIEVOQUJMRUQpCisgIC0tZGlzYWJs ZS12dHBtLXN0dWJkb20gIEJ1aWxkIGFuZCBpbnN0YWxsIHZ0cG0tc3R1YmRvbSAoZGVmYXVsdCBp cyBFTkFCTEVEKQorICAtLWRpc2FibGUtdnRwbW1ncmRvbSAgICBCdWlsZCBhbmQgaW5zdGFsbCB2 dHBtbWdyZG9tIChkZWZhdWx0IGlzIEVOQUJMRUQpCisgIC0tZGlzYWJsZS1kZWJ1ZyAgICAgICAg IERpc2FibGUgZGVidWcgYnVpbGQgb2Ygc3R1YmRvbSAoZGVmYXVsdCBpcyBFTkFCTEVEKQorICAt LWRpc2FibGUtZXh0ZmlsZXMgICAgICBVc2UgeGVuIGV4dGZpbGVzIHJlcG9zaXRvcnkgZm9yIGxp YnJhcmllcyAoZGVmYXVsdAorICAgICAgICAgICAgICAgICAgICAgICAgICBpcyBFTkFCTEVEKQor CitTb21lIGluZmx1ZW50aWFsIGVudmlyb25tZW50IHZhcmlhYmxlczoKKyAgQ01BS0UgICAgICAg UGF0aCB0byB0aGUgY21ha2UgcHJvZ3JhbQorICBXR0VUICAgICAgICBQYXRoIHRvIHdnZXQgcHJv Z3JhbQorICBDQyAgICAgICAgICBDIGNvbXBpbGVyIGNvbW1hbmQKKyAgQ0ZMQUdTICAgICAgQyBj b21waWxlciBmbGFncworICBMREZMQUdTICAgICBsaW5rZXIgZmxhZ3MsIGUuZy4gLUw8bGliIGRp cj4gaWYgeW91IGhhdmUgbGlicmFyaWVzIGluIGEKKyAgICAgICAgICAgICAgbm9uc3RhbmRhcmQg ZGlyZWN0b3J5IDxsaWIgZGlyPgorICBMSUJTICAgICAgICBsaWJyYXJpZXMgdG8gcGFzcyB0byB0 aGUgbGlua2VyLCBlLmcuIC1sPGxpYnJhcnk+CisgIENQUEZMQUdTICAgIChPYmplY3RpdmUpIEMv QysrIHByZXByb2Nlc3NvciBmbGFncywgZS5nLiAtSTxpbmNsdWRlIGRpcj4gaWYKKyAgICAgICAg ICAgICAgeW91IGhhdmUgaGVhZGVycyBpbiBhIG5vbnN0YW5kYXJkIGRpcmVjdG9yeSA8aW5jbHVk ZSBkaXI+CisgIFpMSUJfVVJMICAgIERvd25sb2FkIHVybCBmb3IgemxpYgorICBMSUJQQ0lfVVJM ICBEb3dubG9hZCB1cmwgZm9yIGxpYnBjaQorICBORVdMSUJfVVJMICBEb3dubG9hZCB1cmwgZm9y IG5ld2xpYgorICBMV0lQX1VSTCAgICBEb3dubG9hZCB1cmwgZm9yIGx3aXAKKyAgR1JVQl9VUkwg ICAgRG93bmxvYWQgdXJsIGZvciBncnViCisgIE9DQU1MX1VSTCAgIERvd25sb2FkIHVybCBmb3Ig b2NhbWwKKyAgR01QX1VSTCAgICAgRG93bmxvYWQgdXJsIGZvciBsaWJnbXAKKyAgUE9MQVJTU0xf VVJMCisgICAgICAgICAgICAgIERvd25sb2FkIHVybCBmb3IgcG9sYXJzc2wKKyAgVFBNRU1VX1VS TCAgRG93bmxvYWQgdXJsIGZvciBiZXJsaW9zIHRwbSBlbXVsYXRvcgorCitVc2UgdGhlc2UgdmFy aWFibGVzIHRvIG92ZXJyaWRlIHRoZSBjaG9pY2VzIG1hZGUgYnkgYGNvbmZpZ3VyZScgb3IgdG8g aGVscAoraXQgdG8gZmluZCBsaWJyYXJpZXMgYW5kIHByb2dyYW1zIHdpdGggbm9uc3RhbmRhcmQg bmFtZXMvbG9jYXRpb25zLgorCitSZXBvcnQgYnVncyB0byA8eGVuLWRldmVsQGxpc3RzLnhlbi5v cmc+LgorWGVuIEh5cGVydmlzb3IgU3R1YiBEb21haW5zIGhvbWUgcGFnZTogPGh0dHA6Ly93d3cu eGVuLm9yZy8+LgorX0FDRU9GCithY19zdGF0dXM9JD8KK2ZpCisKK2lmIHRlc3QgIiRhY19pbml0 X2hlbHAiID0gInJlY3Vyc2l2ZSI7IHRoZW4KKyAgIyBJZiB0aGVyZSBhcmUgc3ViZGlycywgcmVw b3J0IHRoZWlyIHNwZWNpZmljIC0taGVscC4KKyAgZm9yIGFjX2RpciBpbiA6ICRhY19zdWJkaXJz X2FsbDsgZG8gdGVzdCAieCRhY19kaXIiID0geDogJiYgY29udGludWUKKyAgICB0ZXN0IC1kICIk YWNfZGlyIiB8fAorICAgICAgeyBjZCAiJHNyY2RpciIgJiYgYWNfcHdkPWBwd2RgICYmIHNyY2Rp cj0uICYmIHRlc3QgLWQgIiRhY19kaXIiOyB9IHx8CisgICAgICBjb250aW51ZQorICAgIGFjX2J1 aWxkZGlyPS4KKworY2FzZSAiJGFjX2RpciIgaW4KKy4pIGFjX2Rpcl9zdWZmaXg9IGFjX3RvcF9i dWlsZGRpcl9zdWI9LiBhY190b3BfYnVpbGRfcHJlZml4PSA7OworKikKKyAgYWNfZGlyX3N1ZmZp eD0vYCRhc19lY2hvICIkYWNfZGlyIiB8IHNlZCAnc3xeXC5bXFwvXXx8J2AKKyAgIyBBICIuLiIg Zm9yIGVhY2ggZGlyZWN0b3J5IGluICRhY19kaXJfc3VmZml4LgorICBhY190b3BfYnVpbGRkaXJf c3ViPWAkYXNfZWNobyAiJGFjX2Rpcl9zdWZmaXgiIHwgc2VkICdzfC9bXlxcL10qfC8uLnxnO3N8 L3x8J2AKKyAgY2FzZSAkYWNfdG9wX2J1aWxkZGlyX3N1YiBpbgorICAiIikgYWNfdG9wX2J1aWxk ZGlyX3N1Yj0uIGFjX3RvcF9idWlsZF9wcmVmaXg9IDs7CisgICopICBhY190b3BfYnVpbGRfcHJl Zml4PSRhY190b3BfYnVpbGRkaXJfc3ViLyA7OworICBlc2FjIDs7Citlc2FjCithY19hYnNfdG9w X2J1aWxkZGlyPSRhY19wd2QKK2FjX2Fic19idWlsZGRpcj0kYWNfcHdkJGFjX2Rpcl9zdWZmaXgK KyMgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHk6CithY190b3BfYnVpbGRkaXI9JGFjX3RvcF9i dWlsZF9wcmVmaXgKKworY2FzZSAkc3JjZGlyIGluCisgIC4pICAjIFdlIGFyZSBidWlsZGluZyBp biBwbGFjZS4KKyAgICBhY19zcmNkaXI9LgorICAgIGFjX3RvcF9zcmNkaXI9JGFjX3RvcF9idWls ZGRpcl9zdWIKKyAgICBhY19hYnNfdG9wX3NyY2Rpcj0kYWNfcHdkIDs7CisgIFtcXC9dKiB8ID86 W1xcL10qICkgICMgQWJzb2x1dGUgbmFtZS4KKyAgICBhY19zcmNkaXI9JHNyY2RpciRhY19kaXJf c3VmZml4OworICAgIGFjX3RvcF9zcmNkaXI9JHNyY2RpcgorICAgIGFjX2Fic190b3Bfc3JjZGly PSRzcmNkaXIgOzsKKyAgKikgIyBSZWxhdGl2ZSBuYW1lLgorICAgIGFjX3NyY2Rpcj0kYWNfdG9w X2J1aWxkX3ByZWZpeCRzcmNkaXIkYWNfZGlyX3N1ZmZpeAorICAgIGFjX3RvcF9zcmNkaXI9JGFj X3RvcF9idWlsZF9wcmVmaXgkc3JjZGlyCisgICAgYWNfYWJzX3RvcF9zcmNkaXI9JGFjX3B3ZC8k c3JjZGlyIDs7Citlc2FjCithY19hYnNfc3JjZGlyPSRhY19hYnNfdG9wX3NyY2RpciRhY19kaXJf c3VmZml4CisKKyAgICBjZCAiJGFjX2RpciIgfHwgeyBhY19zdGF0dXM9JD87IGNvbnRpbnVlOyB9 CisgICAgIyBDaGVjayBmb3IgZ3Vlc3RlZCBjb25maWd1cmUuCisgICAgaWYgdGVzdCAtZiAiJGFj X3NyY2Rpci9jb25maWd1cmUuZ251IjsgdGhlbgorICAgICAgZWNobyAmJgorICAgICAgJFNIRUxM ICIkYWNfc3JjZGlyL2NvbmZpZ3VyZS5nbnUiIC0taGVscD1yZWN1cnNpdmUKKyAgICBlbGlmIHRl c3QgLWYgIiRhY19zcmNkaXIvY29uZmlndXJlIjsgdGhlbgorICAgICAgZWNobyAmJgorICAgICAg JFNIRUxMICIkYWNfc3JjZGlyL2NvbmZpZ3VyZSIgLS1oZWxwPXJlY3Vyc2l2ZQorICAgIGVsc2UK KyAgICAgICRhc19lY2hvICIkYXNfbWU6IFdBUk5JTkc6IG5vIGNvbmZpZ3VyYXRpb24gaW5mb3Jt YXRpb24gaXMgaW4gJGFjX2RpciIgPiYyCisgICAgZmkgfHwgYWNfc3RhdHVzPSQ/CisgICAgY2Qg IiRhY19wd2QiIHx8IHsgYWNfc3RhdHVzPSQ/OyBicmVhazsgfQorICBkb25lCitmaQorCit0ZXN0 IC1uICIkYWNfaW5pdF9oZWxwIiAmJiBleGl0ICRhY19zdGF0dXMKK2lmICRhY19pbml0X3ZlcnNp b247IHRoZW4KKyAgY2F0IDw8XF9BQ0VPRgorWGVuIEh5cGVydmlzb3IgU3R1YiBEb21haW5zIGNv bmZpZ3VyZSA0LjMKK2dlbmVyYXRlZCBieSBHTlUgQXV0b2NvbmYgMi42OQorCitDb3B5cmlnaHQg KEMpIDIwMTIgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCitUaGlzIGNvbmZpZ3VyZSBz Y3JpcHQgaXMgZnJlZSBzb2Z0d2FyZTsgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorZ2l2 ZXMgdW5saW1pdGVkIHBlcm1pc3Npb24gdG8gY29weSwgZGlzdHJpYnV0ZSBhbmQgbW9kaWZ5IGl0 LgorX0FDRU9GCisgIGV4aXQKK2ZpCisKKyMjIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAjIwor IyMgQXV0b2NvbmYgaW5pdGlhbGl6YXRpb24uICMjCisjIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0gIyMKKworIyBhY19mbl9jX3RyeV9jb21waWxlIExJTkVOTworIyAtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorIyBUcnkgdG8gY29tcGlsZSBjb25mdGVzdC4kYWNfZXh0LCBhbmQgcmV0dXJu IHdoZXRoZXIgdGhpcyBzdWNjZWVkZWQuCithY19mbl9jX3RyeV9jb21waWxlICgpCit7CisgIGFz X2xpbmVubz0ke2FzX2xpbmVuby0iJDEifSBhc19saW5lbm9fc3RhY2s9YXNfbGluZW5vX3N0YWNr PSRhc19saW5lbm9fc3RhY2sKKyAgcm0gLWYgY29uZnRlc3QuJGFjX29iamV4dAorICBpZiB7IHsg YWNfdHJ5PSIkYWNfY29tcGlsZSIKK2Nhc2UgIigoJGFjX3RyeSIgaW4KKyAgKlwiKiB8ICpcYCog fCAqXFwqKSBhY190cnlfZWNobz1cJGFjX3RyeTs7CisgICopIGFjX3RyeV9lY2hvPSRhY190cnk7 OworZXNhYworZXZhbCBhY190cnlfZWNobz0iXCJcJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99 OiAkYWNfdHJ5X2VjaG9cIiIKKyRhc19lY2hvICIkYWNfdHJ5X2VjaG8iOyB9ID4mNQorICAoZXZh bCAiJGFjX2NvbXBpbGUiKSAyPmNvbmZ0ZXN0LmVycgorICBhY19zdGF0dXM9JD8KKyAgaWYgdGVz dCAtcyBjb25mdGVzdC5lcnI7IHRoZW4KKyAgICBncmVwIC12ICdeICorJyBjb25mdGVzdC5lcnIg PmNvbmZ0ZXN0LmVyMQorICAgIGNhdCBjb25mdGVzdC5lcjEgPiY1CisgICAgbXYgLWYgY29uZnRl c3QuZXIxIGNvbmZ0ZXN0LmVycgorICBmaQorICAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5v LSRMSU5FTk99OiBcJD8gPSAkYWNfc3RhdHVzIiA+JjUKKyAgdGVzdCAkYWNfc3RhdHVzID0gMDsg fSAmJiB7CisJIHRlc3QgLXogIiRhY19jX3dlcnJvcl9mbGFnIiB8fAorCSB0ZXN0ICEgLXMgY29u ZnRlc3QuZXJyCisgICAgICAgfSAmJiB0ZXN0IC1zIGNvbmZ0ZXN0LiRhY19vYmpleHQ7IHRoZW4g OgorICBhY19yZXR2YWw9MAorZWxzZQorICAkYXNfZWNobyAiJGFzX21lOiBmYWlsZWQgcHJvZ3Jh bSB3YXM6IiA+JjUKK3NlZCAncy9eL3wgLycgY29uZnRlc3QuJGFjX2V4dCA+JjUKKworCWFjX3Jl dHZhbD0xCitmaQorICBldmFsICRhc19saW5lbm9fc3RhY2s7ICR7YXNfbGluZW5vX3N0YWNrOis6 fSB1bnNldCBhc19saW5lbm8KKyAgYXNfZm5fc2V0X3N0YXR1cyAkYWNfcmV0dmFsCisKK30gIyBh Y19mbl9jX3RyeV9jb21waWxlCitjYXQgPmNvbmZpZy5sb2cgPDxfQUNFT0YKK1RoaXMgZmlsZSBj b250YWlucyBhbnkgbWVzc2FnZXMgcHJvZHVjZWQgYnkgY29tcGlsZXJzIHdoaWxlCitydW5uaW5n IGNvbmZpZ3VyZSwgdG8gYWlkIGRlYnVnZ2luZyBpZiBjb25maWd1cmUgbWFrZXMgYSBtaXN0YWtl LgorCitJdCB3YXMgY3JlYXRlZCBieSBYZW4gSHlwZXJ2aXNvciBTdHViIERvbWFpbnMgJGFzX21l IDQuMywgd2hpY2ggd2FzCitnZW5lcmF0ZWQgYnkgR05VIEF1dG9jb25mIDIuNjkuICBJbnZvY2F0 aW9uIGNvbW1hbmQgbGluZSB3YXMKKworICAkICQwICRACisKK19BQ0VPRgorZXhlYyA1Pj5jb25m aWcubG9nCit7CitjYXQgPDxfQVNVTkFNRQorIyMgLS0tLS0tLS0tICMjCisjIyBQbGF0Zm9ybS4g IyMKKyMjIC0tLS0tLS0tLSAjIworCitob3N0bmFtZSA9IGAoaG9zdG5hbWUgfHwgdW5hbWUgLW4p IDI+L2Rldi9udWxsIHwgc2VkIDFxYAordW5hbWUgLW0gPSBgKHVuYW1lIC1tKSAyPi9kZXYvbnVs bCB8fCBlY2hvIHVua25vd25gCit1bmFtZSAtciA9IGAodW5hbWUgLXIpIDI+L2Rldi9udWxsIHx8 IGVjaG8gdW5rbm93bmAKK3VuYW1lIC1zID0gYCh1bmFtZSAtcykgMj4vZGV2L251bGwgfHwgZWNo byB1bmtub3duYAordW5hbWUgLXYgPSBgKHVuYW1lIC12KSAyPi9kZXYvbnVsbCB8fCBlY2hvIHVu a25vd25gCisKKy91c3IvYmluL3VuYW1lIC1wID0gYCgvdXNyL2Jpbi91bmFtZSAtcCkgMj4vZGV2 L251bGwgfHwgZWNobyB1bmtub3duYAorL2Jpbi91bmFtZSAtWCAgICAgPSBgKC9iaW4vdW5hbWUg LVgpIDI+L2Rldi9udWxsICAgICB8fCBlY2hvIHVua25vd25gCisKKy9iaW4vYXJjaCAgICAgICAg ICAgICAgPSBgKC9iaW4vYXJjaCkgMj4vZGV2L251bGwgICAgICAgICAgICAgIHx8IGVjaG8gdW5r bm93bmAKKy91c3IvYmluL2FyY2ggLWsgICAgICAgPSBgKC91c3IvYmluL2FyY2ggLWspIDI+L2Rl di9udWxsICAgICAgIHx8IGVjaG8gdW5rbm93bmAKKy91c3IvY29udmV4L2dldHN5c2luZm8gPSBg KC91c3IvY29udmV4L2dldHN5c2luZm8pIDI+L2Rldi9udWxsIHx8IGVjaG8gdW5rbm93bmAKKy91 c3IvYmluL2hvc3RpbmZvICAgICAgPSBgKC91c3IvYmluL2hvc3RpbmZvKSAyPi9kZXYvbnVsbCAg ICAgIHx8IGVjaG8gdW5rbm93bmAKKy9iaW4vbWFjaGluZSAgICAgICAgICAgPSBgKC9iaW4vbWFj aGluZSkgMj4vZGV2L251bGwgICAgICAgICAgIHx8IGVjaG8gdW5rbm93bmAKKy91c3IvYmluL29z bGV2ZWwgICAgICAgPSBgKC91c3IvYmluL29zbGV2ZWwpIDI+L2Rldi9udWxsICAgICAgIHx8IGVj aG8gdW5rbm93bmAKKy9iaW4vdW5pdmVyc2UgICAgICAgICAgPSBgKC9iaW4vdW5pdmVyc2UpIDI+ L2Rldi9udWxsICAgICAgICAgIHx8IGVjaG8gdW5rbm93bmAKKworX0FTVU5BTUUKKworYXNfc2F2 ZV9JRlM9JElGUzsgSUZTPSRQQVRIX1NFUEFSQVRPUgorZm9yIGFzX2RpciBpbiAkUEFUSAorZG8K KyAgSUZTPSRhc19zYXZlX0lGUworICB0ZXN0IC16ICIkYXNfZGlyIiAmJiBhc19kaXI9LgorICAg ICRhc19lY2hvICJQQVRIOiAkYXNfZGlyIgorICBkb25lCitJRlM9JGFzX3NhdmVfSUZTCisKK30g PiY1CisKK2NhdCA+JjUgPDxfQUNFT0YKKworCisjIyAtLS0tLS0tLS0tLSAjIworIyMgQ29yZSB0 ZXN0cy4gIyMKKyMjIC0tLS0tLS0tLS0tICMjCisKK19BQ0VPRgorCisKKyMgS2VlcCBhIHRyYWNl IG9mIHRoZSBjb21tYW5kIGxpbmUuCisjIFN0cmlwIG91dCAtLW5vLWNyZWF0ZSBhbmQgLS1uby1y ZWN1cnNpb24gc28gdGhleSBkbyBub3QgcGlsZSB1cC4KKyMgU3RyaXAgb3V0IC0tc2lsZW50IGJl Y2F1c2Ugd2UgZG9uJ3Qgd2FudCB0byByZWNvcmQgaXQgZm9yIGZ1dHVyZSBydW5zLgorIyBBbHNv IHF1b3RlIGFueSBhcmdzIGNvbnRhaW5pbmcgc2hlbGwgbWV0YS1jaGFyYWN0ZXJzLgorIyBNYWtl IHR3byBwYXNzZXMgdG8gYWxsb3cgZm9yIHByb3BlciBkdXBsaWNhdGUtYXJndW1lbnQgc3VwcHJl c3Npb24uCithY19jb25maWd1cmVfYXJncz0KK2FjX2NvbmZpZ3VyZV9hcmdzMD0KK2FjX2NvbmZp Z3VyZV9hcmdzMT0KK2FjX211c3Rfa2VlcF9uZXh0PWZhbHNlCitmb3IgYWNfcGFzcyBpbiAxIDIK K2RvCisgIGZvciBhY19hcmcKKyAgZG8KKyAgICBjYXNlICRhY19hcmcgaW4KKyAgICAtbm8tY3Jl YXRlIHwgLS1uby1jKiB8IC1uIHwgLW5vLXJlY3Vyc2lvbiB8IC0tbm8tciopIGNvbnRpbnVlIDs7 CisgICAgLXEgfCAtcXVpZXQgfCAtLXF1aWV0IHwgLS1xdWllIHwgLS1xdWkgfCAtLXF1IHwgLS1x IFwKKyAgICB8IC1zaWxlbnQgfCAtLXNpbGVudCB8IC0tc2lsZW4gfCAtLXNpbGUgfCAtLXNpbCkK KyAgICAgIGNvbnRpbnVlIDs7CisgICAgKlwnKikKKyAgICAgIGFjX2FyZz1gJGFzX2VjaG8gIiRh Y19hcmciIHwgc2VkICJzLycvJ1xcXFxcXFxcJycvZyJgIDs7CisgICAgZXNhYworICAgIGNhc2Ug JGFjX3Bhc3MgaW4KKyAgICAxKSBhc19mbl9hcHBlbmQgYWNfY29uZmlndXJlX2FyZ3MwICIgJyRh Y19hcmcnIiA7OworICAgIDIpCisgICAgICBhc19mbl9hcHBlbmQgYWNfY29uZmlndXJlX2FyZ3Mx ICIgJyRhY19hcmcnIgorICAgICAgaWYgdGVzdCAkYWNfbXVzdF9rZWVwX25leHQgPSB0cnVlOyB0 aGVuCisJYWNfbXVzdF9rZWVwX25leHQ9ZmFsc2UgIyBHb3QgdmFsdWUsIGJhY2sgdG8gbm9ybWFs LgorICAgICAgZWxzZQorCWNhc2UgJGFjX2FyZyBpbgorCSAgKj0qIHwgLS1jb25maWctY2FjaGUg fCAtQyB8IC1kaXNhYmxlLSogfCAtLWRpc2FibGUtKiBcCisJICB8IC1lbmFibGUtKiB8IC0tZW5h YmxlLSogfCAtZ2FzIHwgLS1nKiB8IC1uZnAgfCAtLW5mKiBcCisJICB8IC1xIHwgLXF1aWV0IHwg LS1xKiB8IC1zaWxlbnQgfCAtLXNpbCogfCAtdiB8IC12ZXJiKiBcCisJICB8IC13aXRoLSogfCAt LXdpdGgtKiB8IC13aXRob3V0LSogfCAtLXdpdGhvdXQtKiB8IC0teCkKKwkgICAgY2FzZSAiJGFj X2NvbmZpZ3VyZV9hcmdzMCAiIGluCisJICAgICAgIiRhY19jb25maWd1cmVfYXJnczEiKiIgJyRh Y19hcmcnICIqICkgY29udGludWUgOzsKKwkgICAgZXNhYworCSAgICA7OworCSAgLSogKSBhY19t dXN0X2tlZXBfbmV4dD10cnVlIDs7CisJZXNhYworICAgICAgZmkKKyAgICAgIGFzX2ZuX2FwcGVu ZCBhY19jb25maWd1cmVfYXJncyAiICckYWNfYXJnJyIKKyAgICAgIDs7CisgICAgZXNhYworICBk b25lCitkb25lCit7IGFjX2NvbmZpZ3VyZV9hcmdzMD07IHVuc2V0IGFjX2NvbmZpZ3VyZV9hcmdz MDt9Cit7IGFjX2NvbmZpZ3VyZV9hcmdzMT07IHVuc2V0IGFjX2NvbmZpZ3VyZV9hcmdzMTt9CisK KyMgV2hlbiBpbnRlcnJ1cHRlZCBvciBleGl0J2QsIGNsZWFudXAgdGVtcG9yYXJ5IGZpbGVzLCBh bmQgY29tcGxldGUKKyMgY29uZmlnLmxvZy4gIFdlIHJlbW92ZSBjb21tZW50cyBiZWNhdXNlIGFu eXdheSB0aGUgcXVvdGVzIGluIHRoZXJlCisjIHdvdWxkIGNhdXNlIHByb2JsZW1zIG9yIGxvb2sg dWdseS4KKyMgV0FSTklORzogVXNlICdcJycgdG8gcmVwcmVzZW50IGFuIGFwb3N0cm9waGUgd2l0 aGluIHRoZSB0cmFwLgorIyBXQVJOSU5HOiBEbyBub3Qgc3RhcnQgdGhlIHRyYXAgY29kZSB3aXRo IGEgbmV3bGluZSwgZHVlIHRvIGEgRnJlZUJTRCA0LjAgYnVnLgordHJhcCAnZXhpdF9zdGF0dXM9 JD8KKyAgIyBTYXZlIGludG8gY29uZmlnLmxvZyBzb21lIGluZm9ybWF0aW9uIHRoYXQgbWlnaHQg aGVscCBpbiBkZWJ1Z2dpbmcuCisgIHsKKyAgICBlY2hvCisKKyAgICAkYXNfZWNobyAiIyMgLS0t LS0tLS0tLS0tLS0tLSAjIworIyMgQ2FjaGUgdmFyaWFibGVzLiAjIworIyMgLS0tLS0tLS0tLS0t LS0tLSAjIyIKKyAgICBlY2hvCisgICAgIyBUaGUgZm9sbG93aW5nIHdheSBvZiB3cml0aW5nIHRo ZSBjYWNoZSBtaXNoYW5kbGVzIG5ld2xpbmVzIGluIHZhbHVlcywKKygKKyAgZm9yIGFjX3ZhciBp biBgKHNldCkgMj4mMSB8IHNlZCAtbiAnXCcncy9eXChbYS16QS1aX11bYS16QS1aMC05X10qXCk9 LiovXDEvcCdcJydgOyBkbworICAgIGV2YWwgYWNfdmFsPVwkJGFjX3ZhcgorICAgIGNhc2UgJGFj X3ZhbCBpbiAjKAorICAgICoke2FzX25sfSopCisgICAgICBjYXNlICRhY192YXIgaW4gIygKKyAg ICAgICpfY3ZfKikgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBXQVJO SU5HOiBjYWNoZSB2YXJpYWJsZSAkYWNfdmFyIGNvbnRhaW5zIGEgbmV3bGluZSIgPiY1CiskYXNf ZWNobyAiJGFzX21lOiBXQVJOSU5HOiBjYWNoZSB2YXJpYWJsZSAkYWNfdmFyIGNvbnRhaW5zIGEg bmV3bGluZSIgPiYyO30gOzsKKyAgICAgIGVzYWMKKyAgICAgIGNhc2UgJGFjX3ZhciBpbiAjKAor ICAgICAgXyB8IElGUyB8IGFzX25sKSA7OyAjKAorICAgICAgQkFTSF9BUkdWIHwgQkFTSF9TT1VS Q0UpIGV2YWwgJGFjX3Zhcj0gOzsgIygKKyAgICAgICopIHsgZXZhbCAkYWNfdmFyPTsgdW5zZXQg JGFjX3Zhcjt9IDs7CisgICAgICBlc2FjIDs7CisgICAgZXNhYworICBkb25lCisgIChzZXQpIDI+ JjEgfAorICAgIGNhc2UgJGFzX25sYChhY19zcGFjZT0nXCcnICdcJyc7IHNldCkgMj4mMWAgaW4g IygKKyAgICAqJHthc19ubH1hY19zcGFjZT1cICopCisgICAgICBzZWQgLW4gXAorCSJzLydcJycv J1wnJ1xcXFwnXCcnJ1wnJy9nOworCSAgcy9eXFwoW18kYXNfY3JfYWxudW1dKl9jdl9bXyRhc19j cl9hbG51bV0qXFwpPVxcKC4qXFwpL1xcMT0nXCcnXFwyJ1wnJy9wIgorICAgICAgOzsgIygKKyAg ICAqKQorICAgICAgc2VkIC1uICIvXltfJGFzX2NyX2FsbnVtXSpfY3ZfW18kYXNfY3JfYWxudW1d Kj0vcCIKKyAgICAgIDs7CisgICAgZXNhYyB8CisgICAgc29ydAorKQorICAgIGVjaG8KKworICAg ICRhc19lY2hvICIjIyAtLS0tLS0tLS0tLS0tLS0tLSAjIworIyMgT3V0cHV0IHZhcmlhYmxlcy4g IyMKKyMjIC0tLS0tLS0tLS0tLS0tLS0tICMjIgorICAgIGVjaG8KKyAgICBmb3IgYWNfdmFyIGlu ICRhY19zdWJzdF92YXJzCisgICAgZG8KKyAgICAgIGV2YWwgYWNfdmFsPVwkJGFjX3ZhcgorICAg ICAgY2FzZSAkYWNfdmFsIGluCisgICAgICAqXCdcJycqKSBhY192YWw9YCRhc19lY2hvICIkYWNf dmFsIiB8IHNlZCAicy8nXCcnLydcJydcXFxcXFxcXCdcJycnXCcnL2ciYDs7CisgICAgICBlc2Fj CisgICAgICAkYXNfZWNobyAiJGFjX3Zhcj0nXCcnJGFjX3ZhbCdcJyciCisgICAgZG9uZSB8IHNv cnQKKyAgICBlY2hvCisKKyAgICBpZiB0ZXN0IC1uICIkYWNfc3Vic3RfZmlsZXMiOyB0aGVuCisg ICAgICAkYXNfZWNobyAiIyMgLS0tLS0tLS0tLS0tLS0tLS0tLSAjIworIyMgRmlsZSBzdWJzdGl0 dXRpb25zLiAjIworIyMgLS0tLS0tLS0tLS0tLS0tLS0tLSAjIyIKKyAgICAgIGVjaG8KKyAgICAg IGZvciBhY192YXIgaW4gJGFjX3N1YnN0X2ZpbGVzCisgICAgICBkbworCWV2YWwgYWNfdmFsPVwk JGFjX3ZhcgorCWNhc2UgJGFjX3ZhbCBpbgorCSpcJ1wnJyopIGFjX3ZhbD1gJGFzX2VjaG8gIiRh Y192YWwiIHwgc2VkICJzLydcJycvJ1wnJ1xcXFxcXFxcJ1wnJydcJycvZyJgOzsKKwllc2FjCisJ JGFzX2VjaG8gIiRhY192YXI9J1wnJyRhY192YWwnXCcnIgorICAgICAgZG9uZSB8IHNvcnQKKyAg ICAgIGVjaG8KKyAgICBmaQorCisgICAgaWYgdGVzdCAtcyBjb25mZGVmcy5oOyB0aGVuCisgICAg ICAkYXNfZWNobyAiIyMgLS0tLS0tLS0tLS0gIyMKKyMjIGNvbmZkZWZzLmguICMjCisjIyAtLS0t LS0tLS0tLSAjIyIKKyAgICAgIGVjaG8KKyAgICAgIGNhdCBjb25mZGVmcy5oCisgICAgICBlY2hv CisgICAgZmkKKyAgICB0ZXN0ICIkYWNfc2lnbmFsIiAhPSAwICYmCisgICAgICAkYXNfZWNobyAi JGFzX21lOiBjYXVnaHQgc2lnbmFsICRhY19zaWduYWwiCisgICAgJGFzX2VjaG8gIiRhc19tZTog ZXhpdCAkZXhpdF9zdGF0dXMiCisgIH0gPiY1CisgIHJtIC1mIGNvcmUgKi5jb3JlIGNvcmUuY29u ZnRlc3QuKiAmJgorICAgIHJtIC1mIC1yIGNvbmZ0ZXN0KiBjb25mZGVmcyogY29uZiQkKiAkYWNf Y2xlYW5fZmlsZXMgJiYKKyAgICBleGl0ICRleGl0X3N0YXR1cworJyAwCitmb3IgYWNfc2lnbmFs IGluIDEgMiAxMyAxNTsgZG8KKyAgdHJhcCAnYWNfc2lnbmFsPSckYWNfc2lnbmFsJzsgYXNfZm5f ZXhpdCAxJyAkYWNfc2lnbmFsCitkb25lCithY19zaWduYWw9MAorCisjIGNvbmZkZWZzLmggYXZv aWRzIE9TIGNvbW1hbmQgbGluZSBsZW5ndGggbGltaXRzIHRoYXQgREVGUyBjYW4gZXhjZWVkLgor cm0gLWYgLXIgY29uZnRlc3QqIGNvbmZkZWZzLmgKKworJGFzX2VjaG8gIi8qIGNvbmZkZWZzLmgg Ki8iID4gY29uZmRlZnMuaAorCisjIFByZWRlZmluZWQgcHJlcHJvY2Vzc29yIHZhcmlhYmxlcy4K KworY2F0ID4+Y29uZmRlZnMuaCA8PF9BQ0VPRgorI2RlZmluZSBQQUNLQUdFX05BTUUgIiRQQUNL QUdFX05BTUUiCitfQUNFT0YKKworY2F0ID4+Y29uZmRlZnMuaCA8PF9BQ0VPRgorI2RlZmluZSBQ QUNLQUdFX1RBUk5BTUUgIiRQQUNLQUdFX1RBUk5BTUUiCitfQUNFT0YKKworY2F0ID4+Y29uZmRl ZnMuaCA8PF9BQ0VPRgorI2RlZmluZSBQQUNLQUdFX1ZFUlNJT04gIiRQQUNLQUdFX1ZFUlNJT04i CitfQUNFT0YKKworY2F0ID4+Y29uZmRlZnMuaCA8PF9BQ0VPRgorI2RlZmluZSBQQUNLQUdFX1NU UklORyAiJFBBQ0tBR0VfU1RSSU5HIgorX0FDRU9GCisKK2NhdCA+PmNvbmZkZWZzLmggPDxfQUNF T0YKKyNkZWZpbmUgUEFDS0FHRV9CVUdSRVBPUlQgIiRQQUNLQUdFX0JVR1JFUE9SVCIKK19BQ0VP RgorCitjYXQgPj5jb25mZGVmcy5oIDw8X0FDRU9GCisjZGVmaW5lIFBBQ0tBR0VfVVJMICIkUEFD S0FHRV9VUkwiCitfQUNFT0YKKworCisjIExldCB0aGUgc2l0ZSBmaWxlIHNlbGVjdCBhbiBhbHRl cm5hdGUgY2FjaGUgZmlsZSBpZiBpdCB3YW50cyB0by4KKyMgUHJlZmVyIGFuIGV4cGxpY2l0bHkg c2VsZWN0ZWQgZmlsZSB0byBhdXRvbWF0aWNhbGx5IHNlbGVjdGVkIG9uZXMuCithY19zaXRlX2Zp bGUxPU5PTkUKK2FjX3NpdGVfZmlsZTI9Tk9ORQoraWYgdGVzdCAtbiAiJENPTkZJR19TSVRFIjsg dGhlbgorICAjIFdlIGRvIG5vdCB3YW50IGEgUEFUSCBzZWFyY2ggZm9yIGNvbmZpZy5zaXRlLgor ICBjYXNlICRDT05GSUdfU0lURSBpbiAjKCgKKyAgICAtKikgIGFjX3NpdGVfZmlsZTE9Li8kQ09O RklHX1NJVEU7OworICAgICovKikgYWNfc2l0ZV9maWxlMT0kQ09ORklHX1NJVEU7OworICAgICop ICAgYWNfc2l0ZV9maWxlMT0uLyRDT05GSUdfU0lURTs7CisgIGVzYWMKK2VsaWYgdGVzdCAieCRw cmVmaXgiICE9IHhOT05FOyB0aGVuCisgIGFjX3NpdGVfZmlsZTE9JHByZWZpeC9zaGFyZS9jb25m aWcuc2l0ZQorICBhY19zaXRlX2ZpbGUyPSRwcmVmaXgvZXRjL2NvbmZpZy5zaXRlCitlbHNlCisg IGFjX3NpdGVfZmlsZTE9JGFjX2RlZmF1bHRfcHJlZml4L3NoYXJlL2NvbmZpZy5zaXRlCisgIGFj X3NpdGVfZmlsZTI9JGFjX2RlZmF1bHRfcHJlZml4L2V0Yy9jb25maWcuc2l0ZQorZmkKK2ZvciBh Y19zaXRlX2ZpbGUgaW4gIiRhY19zaXRlX2ZpbGUxIiAiJGFjX3NpdGVfZmlsZTIiCitkbworICB0 ZXN0ICJ4JGFjX3NpdGVfZmlsZSIgPSB4Tk9ORSAmJiBjb250aW51ZQorICBpZiB0ZXN0IC9kZXYv bnVsbCAhPSAiJGFjX3NpdGVfZmlsZSIgJiYgdGVzdCAtciAiJGFjX3NpdGVfZmlsZSI7IHRoZW4K KyAgICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGxvYWRpbmcgc2l0 ZSBzY3JpcHQgJGFjX3NpdGVfZmlsZSIgPiY1CiskYXNfZWNobyAiJGFzX21lOiBsb2FkaW5nIHNp dGUgc2NyaXB0ICRhY19zaXRlX2ZpbGUiID4mNjt9CisgICAgc2VkICdzL14vfCAvJyAiJGFjX3Np dGVfZmlsZSIgPiY1CisgICAgLiAiJGFjX3NpdGVfZmlsZSIgXAorICAgICAgfHwgeyB7ICRhc19l Y2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGVycm9yOiBpbiBcYCRhY19wd2QnOiIg PiY1CiskYXNfZWNobyAiJGFzX21lOiBlcnJvcjogaW4gXGAkYWNfcHdkJzoiID4mMjt9Cithc19m bl9lcnJvciAkPyAiZmFpbGVkIHRvIGxvYWQgc2l0ZSBzY3JpcHQgJGFjX3NpdGVfZmlsZQorU2Vl IFxgY29uZmlnLmxvZycgZm9yIG1vcmUgZGV0YWlscyIgIiRMSU5FTk8iIDU7IH0KKyAgZmkKK2Rv bmUKKworaWYgdGVzdCAtciAiJGNhY2hlX2ZpbGUiOyB0aGVuCisgICMgU29tZSB2ZXJzaW9ucyBv ZiBiYXNoIHdpbGwgZmFpbCB0byBzb3VyY2UgL2Rldi9udWxsIChzcGVjaWFsIGZpbGVzCisgICMg YWN0dWFsbHkpLCBzbyB3ZSBhdm9pZCBkb2luZyB0aGF0LiAgREpHUFAgZW11bGF0ZXMgaXQgYXMg YSByZWd1bGFyIGZpbGUuCisgIGlmIHRlc3QgL2Rldi9udWxsICE9ICIkY2FjaGVfZmlsZSIgJiYg dGVzdCAtZiAiJGNhY2hlX2ZpbGUiOyB0aGVuCisgICAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNf bGluZW5vLSRMSU5FTk99OiBsb2FkaW5nIGNhY2hlICRjYWNoZV9maWxlIiA+JjUKKyRhc19lY2hv ICIkYXNfbWU6IGxvYWRpbmcgY2FjaGUgJGNhY2hlX2ZpbGUiID4mNjt9CisgICAgY2FzZSAkY2Fj aGVfZmlsZSBpbgorICAgICAgW1xcL10qIHwgPzpbXFwvXSogKSAuICIkY2FjaGVfZmlsZSI7Owor ICAgICAgKikgICAgICAgICAgICAgICAgICAgICAgLiAiLi8kY2FjaGVfZmlsZSI7OworICAgIGVz YWMKKyAgZmkKK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99 OiBjcmVhdGluZyBjYWNoZSAkY2FjaGVfZmlsZSIgPiY1CiskYXNfZWNobyAiJGFzX21lOiBjcmVh dGluZyBjYWNoZSAkY2FjaGVfZmlsZSIgPiY2O30KKyAgPiRjYWNoZV9maWxlCitmaQorCisjIENo ZWNrIHRoYXQgdGhlIHByZWNpb3VzIHZhcmlhYmxlcyBzYXZlZCBpbiB0aGUgY2FjaGUgaGF2ZSBr ZXB0IHRoZSBzYW1lCisjIHZhbHVlLgorYWNfY2FjaGVfY29ycnVwdGVkPWZhbHNlCitmb3IgYWNf dmFyIGluICRhY19wcmVjaW91c192YXJzOyBkbworICBldmFsIGFjX29sZF9zZXQ9XCRhY19jdl9l bnZfJHthY192YXJ9X3NldAorICBldmFsIGFjX25ld19zZXQ9XCRhY19lbnZfJHthY192YXJ9X3Nl dAorICBldmFsIGFjX29sZF92YWw9XCRhY19jdl9lbnZfJHthY192YXJ9X3ZhbHVlCisgIGV2YWwg YWNfbmV3X3ZhbD1cJGFjX2Vudl8ke2FjX3Zhcn1fdmFsdWUKKyAgY2FzZSAkYWNfb2xkX3NldCwk YWNfbmV3X3NldCBpbgorICAgIHNldCwpCisgICAgICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19s aW5lbm8tJExJTkVOT306IGVycm9yOiBcYCRhY192YXInIHdhcyBzZXQgdG8gXGAkYWNfb2xkX3Zh bCcgaW4gdGhlIHByZXZpb3VzIHJ1biIgPiY1CiskYXNfZWNobyAiJGFzX21lOiBlcnJvcjogXGAk YWNfdmFyJyB3YXMgc2V0IHRvIFxgJGFjX29sZF92YWwnIGluIHRoZSBwcmV2aW91cyBydW4iID4m Mjt9CisgICAgICBhY19jYWNoZV9jb3JydXB0ZWQ9OiA7OworICAgICxzZXQpCisgICAgICB7ICRh c19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGVycm9yOiBcYCRhY192YXInIHdh cyBub3Qgc2V0IGluIHRoZSBwcmV2aW91cyBydW4iID4mNQorJGFzX2VjaG8gIiRhc19tZTogZXJy b3I6IFxgJGFjX3Zhcicgd2FzIG5vdCBzZXQgaW4gdGhlIHByZXZpb3VzIHJ1biIgPiYyO30KKyAg ICAgIGFjX2NhY2hlX2NvcnJ1cHRlZD06IDs7CisgICAgLCk7OworICAgICopCisgICAgICBpZiB0 ZXN0ICJ4JGFjX29sZF92YWwiICE9ICJ4JGFjX25ld192YWwiOyB0aGVuCisJIyBkaWZmZXJlbmNl cyBpbiB3aGl0ZXNwYWNlIGRvIG5vdCBsZWFkIHRvIGZhaWx1cmUuCisJYWNfb2xkX3ZhbF93PWBl Y2hvIHggJGFjX29sZF92YWxgCisJYWNfbmV3X3ZhbF93PWBlY2hvIHggJGFjX25ld192YWxgCisJ aWYgdGVzdCAiJGFjX29sZF92YWxfdyIgIT0gIiRhY19uZXdfdmFsX3ciOyB0aGVuCisJICB7ICRh c19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGVycm9yOiBcYCRhY192YXInIGhh cyBjaGFuZ2VkIHNpbmNlIHRoZSBwcmV2aW91cyBydW46IiA+JjUKKyRhc19lY2hvICIkYXNfbWU6 IGVycm9yOiBcYCRhY192YXInIGhhcyBjaGFuZ2VkIHNpbmNlIHRoZSBwcmV2aW91cyBydW46IiA+ JjI7fQorCSAgYWNfY2FjaGVfY29ycnVwdGVkPToKKwllbHNlCisJICB7ICRhc19lY2hvICIkYXNf bWU6JHthc19saW5lbm8tJExJTkVOT306IHdhcm5pbmc6IGlnbm9yaW5nIHdoaXRlc3BhY2UgY2hh bmdlcyBpbiBcYCRhY192YXInIHNpbmNlIHRoZSBwcmV2aW91cyBydW46IiA+JjUKKyRhc19lY2hv ICIkYXNfbWU6IHdhcm5pbmc6IGlnbm9yaW5nIHdoaXRlc3BhY2UgY2hhbmdlcyBpbiBcYCRhY192 YXInIHNpbmNlIHRoZSBwcmV2aW91cyBydW46IiA+JjI7fQorCSAgZXZhbCAkYWNfdmFyPVwkYWNf b2xkX3ZhbAorCWZpCisJeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiAg IGZvcm1lciB2YWx1ZTogIFxgJGFjX29sZF92YWwnIiA+JjUKKyRhc19lY2hvICIkYXNfbWU6ICAg Zm9ybWVyIHZhbHVlOiAgXGAkYWNfb2xkX3ZhbCciID4mMjt9CisJeyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiAgIGN1cnJlbnQgdmFsdWU6IFxgJGFjX25ld192YWwnIiA+ JjUKKyRhc19lY2hvICIkYXNfbWU6ICAgY3VycmVudCB2YWx1ZTogXGAkYWNfbmV3X3ZhbCciID4m Mjt9CisgICAgICBmaTs7CisgIGVzYWMKKyAgIyBQYXNzIHByZWNpb3VzIHZhcmlhYmxlcyB0byBj b25maWcuc3RhdHVzLgorICBpZiB0ZXN0ICIkYWNfbmV3X3NldCIgPSBzZXQ7IHRoZW4KKyAgICBj YXNlICRhY19uZXdfdmFsIGluCisgICAgKlwnKikgYWNfYXJnPSRhY192YXI9YCRhc19lY2hvICIk YWNfbmV3X3ZhbCIgfCBzZWQgInMvJy8nXFxcXFxcXFwnJy9nImAgOzsKKyAgICAqKSBhY19hcmc9 JGFjX3Zhcj0kYWNfbmV3X3ZhbCA7OworICAgIGVzYWMKKyAgICBjYXNlICIgJGFjX2NvbmZpZ3Vy ZV9hcmdzICIgaW4KKyAgICAgICoiICckYWNfYXJnJyAiKikgOzsgIyBBdm9pZCBkdXBzLiAgVXNl IG9mIHF1b3RlcyBlbnN1cmVzIGFjY3VyYWN5LgorICAgICAgKikgYXNfZm5fYXBwZW5kIGFjX2Nv bmZpZ3VyZV9hcmdzICIgJyRhY19hcmcnIiA7OworICAgIGVzYWMKKyAgZmkKK2RvbmUKK2lmICRh Y19jYWNoZV9jb3JydXB0ZWQ7IHRoZW4KKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5v LSRMSU5FTk99OiBlcnJvcjogaW4gXGAkYWNfcHdkJzoiID4mNQorJGFzX2VjaG8gIiRhc19tZTog ZXJyb3I6IGluIFxgJGFjX3B3ZCc6IiA+JjI7fQorICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19s aW5lbm8tJExJTkVOT306IGVycm9yOiBjaGFuZ2VzIGluIHRoZSBlbnZpcm9ubWVudCBjYW4gY29t cHJvbWlzZSB0aGUgYnVpbGQiID4mNQorJGFzX2VjaG8gIiRhc19tZTogZXJyb3I6IGNoYW5nZXMg aW4gdGhlIGVudmlyb25tZW50IGNhbiBjb21wcm9taXNlIHRoZSBidWlsZCIgPiYyO30KKyAgYXNf Zm5fZXJyb3IgJD8gInJ1biBcYG1ha2UgZGlzdGNsZWFuJyBhbmQvb3IgXGBybSAkY2FjaGVfZmls ZScgYW5kIHN0YXJ0IG92ZXIiICIkTElORU5PIiA1CitmaQorIyMgLS0tLS0tLS0tLS0tLS0tLS0t LS0gIyMKKyMjIE1haW4gYm9keSBvZiBzY3JpcHQuICMjCisjIyAtLS0tLS0tLS0tLS0tLS0tLS0t LSAjIworCithY19leHQ9YworYWNfY3BwPSckQ1BQICRDUFBGTEFHUycKK2FjX2NvbXBpbGU9JyRD QyAtYyAkQ0ZMQUdTICRDUFBGTEFHUyBjb25mdGVzdC4kYWNfZXh0ID4mNScKK2FjX2xpbms9JyRD QyAtbyBjb25mdGVzdCRhY19leGVleHQgJENGTEFHUyAkQ1BQRkxBR1MgJExERkxBR1MgY29uZnRl c3QuJGFjX2V4dCAkTElCUyA+JjUnCithY19jb21waWxlcl9nbnU9JGFjX2N2X2NfY29tcGlsZXJf Z251CisKKworCithY19jb25maWdfZmlsZXM9IiRhY19jb25maWdfZmlsZXMgLi4vY29uZmlnL1N0 dWJkb20ubWsiCisKKworYWNfYXV4X2Rpcj0KK2ZvciBhY19kaXIgaW4gLiAiJHNyY2RpciIvLjsg ZG8KKyAgaWYgdGVzdCAtZiAiJGFjX2Rpci9pbnN0YWxsLXNoIjsgdGhlbgorICAgIGFjX2F1eF9k aXI9JGFjX2RpcgorICAgIGFjX2luc3RhbGxfc2g9IiRhY19hdXhfZGlyL2luc3RhbGwtc2ggLWMi CisgICAgYnJlYWsKKyAgZWxpZiB0ZXN0IC1mICIkYWNfZGlyL2luc3RhbGwuc2giOyB0aGVuCisg ICAgYWNfYXV4X2Rpcj0kYWNfZGlyCisgICAgYWNfaW5zdGFsbF9zaD0iJGFjX2F1eF9kaXIvaW5z dGFsbC5zaCAtYyIKKyAgICBicmVhaworICBlbGlmIHRlc3QgLWYgIiRhY19kaXIvc2h0b29sIjsg dGhlbgorICAgIGFjX2F1eF9kaXI9JGFjX2RpcgorICAgIGFjX2luc3RhbGxfc2g9IiRhY19hdXhf ZGlyL3NodG9vbCBpbnN0YWxsIC1jIgorICAgIGJyZWFrCisgIGZpCitkb25lCitpZiB0ZXN0IC16 ICIkYWNfYXV4X2RpciI7IHRoZW4KKyAgYXNfZm5fZXJyb3IgJD8gImNhbm5vdCBmaW5kIGluc3Rh bGwtc2gsIGluc3RhbGwuc2gsIG9yIHNodG9vbCBpbiAuIFwiJHNyY2RpclwiLy4iICIkTElORU5P IiA1CitmaQorCisjIFRoZXNlIHRocmVlIHZhcmlhYmxlcyBhcmUgdW5kb2N1bWVudGVkIGFuZCB1 bnN1cHBvcnRlZCwKKyMgYW5kIGFyZSBpbnRlbmRlZCB0byBiZSB3aXRoZHJhd24gaW4gYSBmdXR1 cmUgQXV0b2NvbmYgcmVsZWFzZS4KKyMgVGhleSBjYW4gY2F1c2Ugc2VyaW91cyBwcm9ibGVtcyBp ZiBhIGJ1aWxkZXIncyBzb3VyY2UgdHJlZSBpcyBpbiBhIGRpcmVjdG9yeQorIyB3aG9zZSBmdWxs IG5hbWUgY29udGFpbnMgdW51c3VhbCBjaGFyYWN0ZXJzLgorYWNfY29uZmlnX2d1ZXNzPSIkU0hF TEwgJGFjX2F1eF9kaXIvY29uZmlnLmd1ZXNzIiAgIyBQbGVhc2UgZG9uJ3QgdXNlIHRoaXMgdmFy LgorYWNfY29uZmlnX3N1Yj0iJFNIRUxMICRhY19hdXhfZGlyL2NvbmZpZy5zdWIiICAjIFBsZWFz ZSBkb24ndCB1c2UgdGhpcyB2YXIuCithY19jb25maWd1cmU9IiRTSEVMTCAkYWNfYXV4X2Rpci9j b25maWd1cmUiICAjIFBsZWFzZSBkb24ndCB1c2UgdGhpcyB2YXIuCisKKworCisjIE00IE1hY3Jv IGluY2x1ZGVzCisKKworCisKKworCisKKworCisKKworCisKKworCisKKworCisKKworCisKKwor CisjIEVuYWJsZS9kaXNhYmxlIHN0dWIgZG9tYWlucworCitTVFVCRE9NX1RBUkdFVFM9CitTVFVC RE9NX0JVSUxEPQorU1RVQkRPTV9JTlNUQUxMPQorCisKKyMgQ2hlY2sgd2hldGhlciAtLWVuYWJs ZS1pb2VtdS1zdHViZG9tIHdhcyBnaXZlbi4KK2lmIHRlc3QgIiR7ZW5hYmxlX2lvZW11X3N0dWJk b20rc2V0fSIgPSBzZXQ7IHRoZW4gOgorICBlbmFibGV2YWw9JGVuYWJsZV9pb2VtdV9zdHViZG9t OworaW9lbXU9bgorCitlbHNlCisKK2lvZW11PXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01f VEFSR0VUUyBpb2VtdSIKK1NUVUJET01fQlVJTEQ9IiRTVFVCRE9NX0JVSUxEIGlvZW11LXN0dWJk b20iCitTVFVCRE9NX0lOU1RBTEw9IiRTVFVCRE9NX0lOU1RBTEwgaW5zdGFsbC1pb2VtdSIKKwor ZmkKKworCisKKworIyBDaGVjayB3aGV0aGVyIC0tZW5hYmxlLWMtc3R1YmRvbSB3YXMgZ2l2ZW4u CitpZiB0ZXN0ICIke2VuYWJsZV9jX3N0dWJkb20rc2V0fSIgPSBzZXQ7IHRoZW4gOgorICBlbmFi bGV2YWw9JGVuYWJsZV9jX3N0dWJkb207CitjPXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01f VEFSR0VUUyBjIgorU1RVQkRPTV9CVUlMRD0iJFNUVUJET01fQlVJTEQgYy1zdHViZG9tIgorU1RV QkRPTV9JTlNUQUxMPSIkU1RVQkRPTV9JTlNUQUxMIGluc3RhbGwtYyIKKworZWxzZQorCitjPW4K KworZmkKKworCisKKworIyBDaGVjayB3aGV0aGVyIC0tZW5hYmxlLWNhbWwtc3R1YmRvbSB3YXMg Z2l2ZW4uCitpZiB0ZXN0ICIke2VuYWJsZV9jYW1sX3N0dWJkb20rc2V0fSIgPSBzZXQ7IHRoZW4g OgorICBlbmFibGV2YWw9JGVuYWJsZV9jYW1sX3N0dWJkb207CitjYW1sPW4KKworZWxzZQorCitj YW1sPXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01fVEFSR0VUUyBjYW1sIgorU1RVQkRPTV9C VUlMRD0iJFNUVUJET01fQlVJTEQgY2FtbC1zdHViZG9tIgorU1RVQkRPTV9JTlNUQUxMPSIkU1RV QkRPTV9JTlNUQUxMIGluc3RhbGwtY2FtbCIKKworZmkKKworCisKKworIyBDaGVjayB3aGV0aGVy IC0tZW5hYmxlLXB2LWdydWIgd2FzIGdpdmVuLgoraWYgdGVzdCAiJHtlbmFibGVfcHZfZ3J1Yitz ZXR9IiA9IHNldDsgdGhlbiA6CisgIGVuYWJsZXZhbD0kZW5hYmxlX3B2X2dydWI7CitncnViPW4K KworZWxzZQorCitncnViPXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01fVEFSR0VUUyBncnVi IgorU1RVQkRPTV9CVUlMRD0iJFNUVUJET01fQlVJTEQgcHYtZ3J1YiIKK1NUVUJET01fSU5TVEFM TD0iJFNUVUJET01fSU5TVEFMTCBpbnN0YWxsLWdydWIiCisKK2ZpCisKKworCisKKyMgQ2hlY2sg d2hldGhlciAtLWVuYWJsZS14ZW5zdG9yZS1zdHViZG9tIHdhcyBnaXZlbi4KK2lmIHRlc3QgIiR7 ZW5hYmxlX3hlbnN0b3JlX3N0dWJkb20rc2V0fSIgPSBzZXQ7IHRoZW4gOgorICBlbmFibGV2YWw9 JGVuYWJsZV94ZW5zdG9yZV9zdHViZG9tOworeGVuc3RvcmU9bgorCitlbHNlCisKK3hlbnN0b3Jl PXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01fVEFSR0VUUyB4ZW5zdG9yZSIKK1NUVUJET01f QlVJTEQ9IiRTVFVCRE9NX0JVSUxEIHhlbnN0b3JlLXN0dWJkb20iCitTVFVCRE9NX0lOU1RBTEw9 IiRTVFVCRE9NX0lOU1RBTEwgaW5zdGFsbC14ZW5zdG9yZSIKKworZmkKKworCisKKworIyBDaGVj ayB3aGV0aGVyIC0tZW5hYmxlLXZ0cG0tc3R1YmRvbSB3YXMgZ2l2ZW4uCitpZiB0ZXN0ICIke2Vu YWJsZV92dHBtX3N0dWJkb20rc2V0fSIgPSBzZXQ7IHRoZW4gOgorICBlbmFibGV2YWw9JGVuYWJs ZV92dHBtX3N0dWJkb207Cit2dHBtPW4KKworZWxzZQorCit2dHBtPXkKK1NUVUJET01fVEFSR0VU Uz0iJFNUVUJET01fVEFSR0VUUyB2dHBtIgorU1RVQkRPTV9CVUlMRD0iJFNUVUJET01fQlVJTEQg dnRwbS1zdHViZG9tIgorU1RVQkRPTV9JTlNUQUxMPSIkU1RVQkRPTV9JTlNUQUxMIGluc3RhbGwt dnRwbSIKKworZmkKKworCisKKworIyBDaGVjayB3aGV0aGVyIC0tZW5hYmxlLXZ0cG1tZ3Jkb20g d2FzIGdpdmVuLgoraWYgdGVzdCAiJHtlbmFibGVfdnRwbW1ncmRvbStzZXR9IiA9IHNldDsgdGhl biA6CisgIGVuYWJsZXZhbD0kZW5hYmxlX3Z0cG1tZ3Jkb207Cit2dHBtbWdyPW4KKworZWxzZQor Cit2dHBtbWdyPXkKK1NUVUJET01fVEFSR0VUUz0iJFNUVUJET01fVEFSR0VUUyB2dHBtbWdyIgor U1RVQkRPTV9CVUlMRD0iJFNUVUJET01fQlVJTEQgdnRwbW1ncmRvbSIKK1NUVUJET01fSU5TVEFM TD0iJFNUVUJET01fSU5TVEFMTCBpbnN0YWxsLXZ0cG1tZ3IiCisKK2ZpCisKKworCisKKworIyBD aGVjayB3aGV0aGVyIC0tZW5hYmxlLWRlYnVnIHdhcyBnaXZlbi4KK2lmIHRlc3QgIiR7ZW5hYmxl X2RlYnVnK3NldH0iID0gc2V0OyB0aGVuIDoKKyAgZW5hYmxldmFsPSRlbmFibGVfZGVidWc7Citm aQorCisKK2lmIHRlc3QgIngkZW5hYmxlX2RlYnVnIiA9ICJ4bm8iOyB0aGVuIDoKKworICAgIGF4 X2N2X2RlYnVnPSJuIgorCitlbGlmIHRlc3QgIngkZW5hYmxlX2RlYnVnIiA9ICJ4eWVzIjsgdGhl biA6CisKKyAgICBheF9jdl9kZWJ1Zz0ieSIKKworZWxpZiB0ZXN0IC16ICRheF9jdl9kZWJ1Zzsg dGhlbiA6CisKKyAgICBheF9jdl9kZWJ1Zz0ieSIKKworZmkKK2RlYnVnPSRheF9jdl9kZWJ1Zwor CisKKworIyBDaGVjayB3aGV0aGVyIC0tZW5hYmxlLWV4dGZpbGVzIHdhcyBnaXZlbi4KK2lmIHRl c3QgIiR7ZW5hYmxlX2V4dGZpbGVzK3NldH0iID0gc2V0OyB0aGVuIDoKKyAgZW5hYmxldmFsPSRl bmFibGVfZXh0ZmlsZXM7CitmaQorCisKK2lmIHRlc3QgIngkZW5hYmxlX2V4dGZpbGVzIiA9ICJ4 bm8iOyB0aGVuIDoKKworICAgIGF4X2N2X2V4dGZpbGVzPSJuIgorCitlbGlmIHRlc3QgIngkZW5h YmxlX2V4dGZpbGVzIiA9ICJ4eWVzIjsgdGhlbiA6CisKKyAgICBheF9jdl9leHRmaWxlcz0ieSIK KworZWxpZiB0ZXN0IC16ICRheF9jdl9leHRmaWxlczsgdGhlbiA6CisKKyAgICBheF9jdl9leHRm aWxlcz0ieSIKKworZmkKK2V4dGZpbGVzPSRheF9jdl9leHRmaWxlcworCisKKworCisKKworIyBD aGVja3MgZm9yIHByb2dyYW1zLgorYWNfZXh0PWMKK2FjX2NwcD0nJENQUCAkQ1BQRkxBR1MnCith Y19jb21waWxlPSckQ0MgLWMgJENGTEFHUyAkQ1BQRkxBR1MgY29uZnRlc3QuJGFjX2V4dCA+JjUn CithY19saW5rPSckQ0MgLW8gY29uZnRlc3QkYWNfZXhlZXh0ICRDRkxBR1MgJENQUEZMQUdTICRM REZMQUdTIGNvbmZ0ZXN0LiRhY19leHQgJExJQlMgPiY1JworYWNfY29tcGlsZXJfZ251PSRhY19j dl9jX2NvbXBpbGVyX2dudQoraWYgdGVzdCAtbiAiJGFjX3Rvb2xfcHJlZml4IjsgdGhlbgorICAj IEV4dHJhY3QgdGhlIGZpcnN0IHdvcmQgb2YgIiR7YWNfdG9vbF9wcmVmaXh9Z2NjIiwgc28gaXQg Y2FuIGJlIGEgcHJvZ3JhbSBuYW1lIHdpdGggYXJncy4KK3NldCBkdW1teSAke2FjX3Rvb2xfcHJl Zml4fWdjYzsgYWNfd29yZD0kMgoreyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5F Tk99OiBjaGVja2luZyBmb3IgJGFjX3dvcmQiID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9y ICRhY193b3JkLi4uICIgPiY2OyB9CitpZiAke2FjX2N2X3Byb2dfQ0MrOn0gZmFsc2U7IHRoZW4g OgorICAkYXNfZWNob19uICIoY2FjaGVkKSAiID4mNgorZWxzZQorICBpZiB0ZXN0IC1uICIkQ0Mi OyB0aGVuCisgIGFjX2N2X3Byb2dfQ0M9IiRDQyIgIyBMZXQgdGhlIHVzZXIgb3ZlcnJpZGUgdGhl IHRlc3QuCitlbHNlCithc19zYXZlX0lGUz0kSUZTOyBJRlM9JFBBVEhfU0VQQVJBVE9SCitmb3Ig YXNfZGlyIGluICRQQVRICitkbworICBJRlM9JGFzX3NhdmVfSUZTCisgIHRlc3QgLXogIiRhc19k aXIiICYmIGFzX2Rpcj0uCisgICAgZm9yIGFjX2V4ZWNfZXh0IGluICcnICRhY19leGVjdXRhYmxl X2V4dGVuc2lvbnM7IGRvCisgIGlmIGFzX2ZuX2V4ZWN1dGFibGVfcCAiJGFzX2Rpci8kYWNfd29y ZCRhY19leGVjX2V4dCI7IHRoZW4KKyAgICBhY19jdl9wcm9nX0NDPSIke2FjX3Rvb2xfcHJlZml4 fWdjYyIKKyAgICAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBmb3VuZCAk YXNfZGlyLyRhY193b3JkJGFjX2V4ZWNfZXh0IiA+JjUKKyAgICBicmVhayAyCisgIGZpCitkb25l CisgIGRvbmUKK0lGUz0kYXNfc2F2ZV9JRlMKKworZmkKK2ZpCitDQz0kYWNfY3ZfcHJvZ19DQwor aWYgdGVzdCAtbiAiJENDIjsgdGhlbgorICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8t JExJTkVOT306IHJlc3VsdDogJENDIiA+JjUKKyRhc19lY2hvICIkQ0MiID4mNjsgfQorZWxzZQor ICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogbm8iID4m NQorJGFzX2VjaG8gIm5vIiA+JjY7IH0KK2ZpCisKKworZmkKK2lmIHRlc3QgLXogIiRhY19jdl9w cm9nX0NDIjsgdGhlbgorICBhY19jdF9DQz0kQ0MKKyAgIyBFeHRyYWN0IHRoZSBmaXJzdCB3b3Jk IG9mICJnY2MiLCBzbyBpdCBjYW4gYmUgYSBwcm9ncmFtIG5hbWUgd2l0aCBhcmdzLgorc2V0IGR1 bW15IGdjYzsgYWNfd29yZD0kMgoreyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5F Tk99OiBjaGVja2luZyBmb3IgJGFjX3dvcmQiID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9y ICRhY193b3JkLi4uICIgPiY2OyB9CitpZiAke2FjX2N2X3Byb2dfYWNfY3RfQ0MrOn0gZmFsc2U7 IHRoZW4gOgorICAkYXNfZWNob19uICIoY2FjaGVkKSAiID4mNgorZWxzZQorICBpZiB0ZXN0IC1u ICIkYWNfY3RfQ0MiOyB0aGVuCisgIGFjX2N2X3Byb2dfYWNfY3RfQ0M9IiRhY19jdF9DQyIgIyBM ZXQgdGhlIHVzZXIgb3ZlcnJpZGUgdGhlIHRlc3QuCitlbHNlCithc19zYXZlX0lGUz0kSUZTOyBJ RlM9JFBBVEhfU0VQQVJBVE9SCitmb3IgYXNfZGlyIGluICRQQVRICitkbworICBJRlM9JGFzX3Nh dmVfSUZTCisgIHRlc3QgLXogIiRhc19kaXIiICYmIGFzX2Rpcj0uCisgICAgZm9yIGFjX2V4ZWNf ZXh0IGluICcnICRhY19leGVjdXRhYmxlX2V4dGVuc2lvbnM7IGRvCisgIGlmIGFzX2ZuX2V4ZWN1 dGFibGVfcCAiJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCI7IHRoZW4KKyAgICBhY19jdl9w cm9nX2FjX2N0X0NDPSJnY2MiCisgICAgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElO RU5PfTogZm91bmQgJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCIgPiY1CisgICAgYnJlYWsg MgorICBmaQorZG9uZQorICBkb25lCitJRlM9JGFzX3NhdmVfSUZTCisKK2ZpCitmaQorYWNfY3Rf Q0M9JGFjX2N2X3Byb2dfYWNfY3RfQ0MKK2lmIHRlc3QgLW4gIiRhY19jdF9DQyI7IHRoZW4KKyAg eyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6ICRhY19jdF9D QyIgPiY1CiskYXNfZWNobyAiJGFjX2N0X0NDIiA+JjY7IH0KK2Vsc2UKKyAgeyAkYXNfZWNobyAi JGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6IG5vIiA+JjUKKyRhc19lY2hvICJu byIgPiY2OyB9CitmaQorCisgIGlmIHRlc3QgIngkYWNfY3RfQ0MiID0geDsgdGhlbgorICAgIEND PSIiCisgIGVsc2UKKyAgICBjYXNlICRjcm9zc19jb21waWxpbmc6JGFjX3Rvb2xfd2FybmVkIGlu Cit5ZXM6KQoreyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBXQVJOSU5H OiB1c2luZyBjcm9zcyB0b29scyBub3QgcHJlZml4ZWQgd2l0aCBob3N0IHRyaXBsZXQiID4mNQor JGFzX2VjaG8gIiRhc19tZTogV0FSTklORzogdXNpbmcgY3Jvc3MgdG9vbHMgbm90IHByZWZpeGVk IHdpdGggaG9zdCB0cmlwbGV0IiA+JjI7fQorYWNfdG9vbF93YXJuZWQ9eWVzIDs7Citlc2FjCisg ICAgQ0M9JGFjX2N0X0NDCisgIGZpCitlbHNlCisgIENDPSIkYWNfY3ZfcHJvZ19DQyIKK2ZpCisK K2lmIHRlc3QgLXogIiRDQyI7IHRoZW4KKyAgICAgICAgICBpZiB0ZXN0IC1uICIkYWNfdG9vbF9w cmVmaXgiOyB0aGVuCisgICAgIyBFeHRyYWN0IHRoZSBmaXJzdCB3b3JkIG9mICIke2FjX3Rvb2xf cHJlZml4fWNjIiwgc28gaXQgY2FuIGJlIGEgcHJvZ3JhbSBuYW1lIHdpdGggYXJncy4KK3NldCBk dW1teSAke2FjX3Rvb2xfcHJlZml4fWNjOyBhY193b3JkPSQyCit7ICRhc19lY2hvICIkYXNfbWU6 JHthc19saW5lbm8tJExJTkVOT306IGNoZWNraW5nIGZvciAkYWNfd29yZCIgPiY1CiskYXNfZWNo b19uICJjaGVja2luZyBmb3IgJGFjX3dvcmQuLi4gIiA+JjY7IH0KK2lmICR7YWNfY3ZfcHJvZ19D Qys6fSBmYWxzZTsgdGhlbiA6CisgICRhc19lY2hvX24gIihjYWNoZWQpICIgPiY2CitlbHNlCisg IGlmIHRlc3QgLW4gIiRDQyI7IHRoZW4KKyAgYWNfY3ZfcHJvZ19DQz0iJENDIiAjIExldCB0aGUg dXNlciBvdmVycmlkZSB0aGUgdGVzdC4KK2Vsc2UKK2FzX3NhdmVfSUZTPSRJRlM7IElGUz0kUEFU SF9TRVBBUkFUT1IKK2ZvciBhc19kaXIgaW4gJFBBVEgKK2RvCisgIElGUz0kYXNfc2F2ZV9JRlMK KyAgdGVzdCAteiAiJGFzX2RpciIgJiYgYXNfZGlyPS4KKyAgICBmb3IgYWNfZXhlY19leHQgaW4g JycgJGFjX2V4ZWN1dGFibGVfZXh0ZW5zaW9uczsgZG8KKyAgaWYgYXNfZm5fZXhlY3V0YWJsZV9w ICIkYXNfZGlyLyRhY193b3JkJGFjX2V4ZWNfZXh0IjsgdGhlbgorICAgIGFjX2N2X3Byb2dfQ0M9 IiR7YWNfdG9vbF9wcmVmaXh9Y2MiCisgICAgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0k TElORU5PfTogZm91bmQgJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCIgPiY1CisgICAgYnJl YWsgMgorICBmaQorZG9uZQorICBkb25lCitJRlM9JGFzX3NhdmVfSUZTCisKK2ZpCitmaQorQ0M9 JGFjX2N2X3Byb2dfQ0MKK2lmIHRlc3QgLW4gIiRDQyI7IHRoZW4KKyAgeyAkYXNfZWNobyAiJGFz X21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6ICRDQyIgPiY1CiskYXNfZWNobyAiJEND IiA+JjY7IH0KK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99 OiByZXN1bHQ6IG5vIiA+JjUKKyRhc19lY2hvICJubyIgPiY2OyB9CitmaQorCisKKyAgZmkKK2Zp CitpZiB0ZXN0IC16ICIkQ0MiOyB0aGVuCisgICMgRXh0cmFjdCB0aGUgZmlyc3Qgd29yZCBvZiAi Y2MiLCBzbyBpdCBjYW4gYmUgYSBwcm9ncmFtIG5hbWUgd2l0aCBhcmdzLgorc2V0IGR1bW15IGNj OyBhY193b3JkPSQyCit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNo ZWNraW5nIGZvciAkYWNfd29yZCIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyBmb3IgJGFjX3dv cmQuLi4gIiA+JjY7IH0KK2lmICR7YWNfY3ZfcHJvZ19DQys6fSBmYWxzZTsgdGhlbiA6CisgICRh c19lY2hvX24gIihjYWNoZWQpICIgPiY2CitlbHNlCisgIGlmIHRlc3QgLW4gIiRDQyI7IHRoZW4K KyAgYWNfY3ZfcHJvZ19DQz0iJENDIiAjIExldCB0aGUgdXNlciBvdmVycmlkZSB0aGUgdGVzdC4K K2Vsc2UKKyAgYWNfcHJvZ19yZWplY3RlZD1ubworYXNfc2F2ZV9JRlM9JElGUzsgSUZTPSRQQVRI X1NFUEFSQVRPUgorZm9yIGFzX2RpciBpbiAkUEFUSAorZG8KKyAgSUZTPSRhc19zYXZlX0lGUwor ICB0ZXN0IC16ICIkYXNfZGlyIiAmJiBhc19kaXI9LgorICAgIGZvciBhY19leGVjX2V4dCBpbiAn JyAkYWNfZXhlY3V0YWJsZV9leHRlbnNpb25zOyBkbworICBpZiBhc19mbl9leGVjdXRhYmxlX3Ag IiRhc19kaXIvJGFjX3dvcmQkYWNfZXhlY19leHQiOyB0aGVuCisgICAgaWYgdGVzdCAiJGFzX2Rp ci8kYWNfd29yZCRhY19leGVjX2V4dCIgPSAiL3Vzci91Y2IvY2MiOyB0aGVuCisgICAgICAgYWNf cHJvZ19yZWplY3RlZD15ZXMKKyAgICAgICBjb250aW51ZQorICAgICBmaQorICAgIGFjX2N2X3By b2dfQ0M9ImNjIgorICAgICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGZv dW5kICRhc19kaXIvJGFjX3dvcmQkYWNfZXhlY19leHQiID4mNQorICAgIGJyZWFrIDIKKyAgZmkK K2RvbmUKKyAgZG9uZQorSUZTPSRhc19zYXZlX0lGUworCitpZiB0ZXN0ICRhY19wcm9nX3JlamVj dGVkID0geWVzOyB0aGVuCisgICMgV2UgZm91bmQgYSBib2dvbiBpbiB0aGUgcGF0aCwgc28gbWFr ZSBzdXJlIHdlIG5ldmVyIHVzZSBpdC4KKyAgc2V0IGR1bW15ICRhY19jdl9wcm9nX0NDCisgIHNo aWZ0CisgIGlmIHRlc3QgJCMgIT0gMDsgdGhlbgorICAgICMgV2UgY2hvc2UgYSBkaWZmZXJlbnQg Y29tcGlsZXIgZnJvbSB0aGUgYm9ndXMgb25lLgorICAgICMgSG93ZXZlciwgaXQgaGFzIHRoZSBz YW1lIGJhc2VuYW1lLCBzbyB0aGUgYm9nb24gd2lsbCBiZSBjaG9zZW4KKyAgICAjIGZpcnN0IGlm IHdlIHNldCBDQyB0byBqdXN0IHRoZSBiYXNlbmFtZTsgdXNlIHRoZSBmdWxsIGZpbGUgbmFtZS4K KyAgICBzaGlmdAorICAgIGFjX2N2X3Byb2dfQ0M9IiRhc19kaXIvJGFjX3dvcmQkezErJyAnfSRA IgorICBmaQorZmkKK2ZpCitmaQorQ0M9JGFjX2N2X3Byb2dfQ0MKK2lmIHRlc3QgLW4gIiRDQyI7 IHRoZW4KKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6 ICRDQyIgPiY1CiskYXNfZWNobyAiJENDIiA+JjY7IH0KK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFz X21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6IG5vIiA+JjUKKyRhc19lY2hvICJubyIg PiY2OyB9CitmaQorCisKK2ZpCitpZiB0ZXN0IC16ICIkQ0MiOyB0aGVuCisgIGlmIHRlc3QgLW4g IiRhY190b29sX3ByZWZpeCI7IHRoZW4KKyAgZm9yIGFjX3Byb2cgaW4gY2wuZXhlCisgIGRvCisg ICAgIyBFeHRyYWN0IHRoZSBmaXJzdCB3b3JkIG9mICIkYWNfdG9vbF9wcmVmaXgkYWNfcHJvZyIs IHNvIGl0IGNhbiBiZSBhIHByb2dyYW0gbmFtZSB3aXRoIGFyZ3MuCitzZXQgZHVtbXkgJGFjX3Rv b2xfcHJlZml4JGFjX3Byb2c7IGFjX3dvcmQ9JDIKK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xp bmVuby0kTElORU5PfTogY2hlY2tpbmcgZm9yICRhY193b3JkIiA+JjUKKyRhc19lY2hvX24gImNo ZWNraW5nIGZvciAkYWNfd29yZC4uLiAiID4mNjsgfQoraWYgJHthY19jdl9wcm9nX0NDKzp9IGZh bHNlOyB0aGVuIDoKKyAgJGFzX2VjaG9fbiAiKGNhY2hlZCkgIiA+JjYKK2Vsc2UKKyAgaWYgdGVz dCAtbiAiJENDIjsgdGhlbgorICBhY19jdl9wcm9nX0NDPSIkQ0MiICMgTGV0IHRoZSB1c2VyIG92 ZXJyaWRlIHRoZSB0ZXN0LgorZWxzZQorYXNfc2F2ZV9JRlM9JElGUzsgSUZTPSRQQVRIX1NFUEFS QVRPUgorZm9yIGFzX2RpciBpbiAkUEFUSAorZG8KKyAgSUZTPSRhc19zYXZlX0lGUworICB0ZXN0 IC16ICIkYXNfZGlyIiAmJiBhc19kaXI9LgorICAgIGZvciBhY19leGVjX2V4dCBpbiAnJyAkYWNf ZXhlY3V0YWJsZV9leHRlbnNpb25zOyBkbworICBpZiBhc19mbl9leGVjdXRhYmxlX3AgIiRhc19k aXIvJGFjX3dvcmQkYWNfZXhlY19leHQiOyB0aGVuCisgICAgYWNfY3ZfcHJvZ19DQz0iJGFjX3Rv b2xfcHJlZml4JGFjX3Byb2ciCisgICAgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElO RU5PfTogZm91bmQgJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCIgPiY1CisgICAgYnJlYWsg MgorICBmaQorZG9uZQorICBkb25lCitJRlM9JGFzX3NhdmVfSUZTCisKK2ZpCitmaQorQ0M9JGFj X2N2X3Byb2dfQ0MKK2lmIHRlc3QgLW4gIiRDQyI7IHRoZW4KKyAgeyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6ICRDQyIgPiY1CiskYXNfZWNobyAiJENDIiA+ JjY7IH0KK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBy ZXN1bHQ6IG5vIiA+JjUKKyRhc19lY2hvICJubyIgPiY2OyB9CitmaQorCisKKyAgICB0ZXN0IC1u ICIkQ0MiICYmIGJyZWFrCisgIGRvbmUKK2ZpCitpZiB0ZXN0IC16ICIkQ0MiOyB0aGVuCisgIGFj X2N0X0NDPSRDQworICBmb3IgYWNfcHJvZyBpbiBjbC5leGUKK2RvCisgICMgRXh0cmFjdCB0aGUg Zmlyc3Qgd29yZCBvZiAiJGFjX3Byb2ciLCBzbyBpdCBjYW4gYmUgYSBwcm9ncmFtIG5hbWUgd2l0 aCBhcmdzLgorc2V0IGR1bW15ICRhY19wcm9nOyBhY193b3JkPSQyCit7ICRhc19lY2hvICIkYXNf bWU6JHthc19saW5lbm8tJExJTkVOT306IGNoZWNraW5nIGZvciAkYWNfd29yZCIgPiY1CiskYXNf ZWNob19uICJjaGVja2luZyBmb3IgJGFjX3dvcmQuLi4gIiA+JjY7IH0KK2lmICR7YWNfY3ZfcHJv Z19hY19jdF9DQys6fSBmYWxzZTsgdGhlbiA6CisgICRhc19lY2hvX24gIihjYWNoZWQpICIgPiY2 CitlbHNlCisgIGlmIHRlc3QgLW4gIiRhY19jdF9DQyI7IHRoZW4KKyAgYWNfY3ZfcHJvZ19hY19j dF9DQz0iJGFjX2N0X0NDIiAjIExldCB0aGUgdXNlciBvdmVycmlkZSB0aGUgdGVzdC4KK2Vsc2UK K2FzX3NhdmVfSUZTPSRJRlM7IElGUz0kUEFUSF9TRVBBUkFUT1IKK2ZvciBhc19kaXIgaW4gJFBB VEgKK2RvCisgIElGUz0kYXNfc2F2ZV9JRlMKKyAgdGVzdCAteiAiJGFzX2RpciIgJiYgYXNfZGly PS4KKyAgICBmb3IgYWNfZXhlY19leHQgaW4gJycgJGFjX2V4ZWN1dGFibGVfZXh0ZW5zaW9uczsg ZG8KKyAgaWYgYXNfZm5fZXhlY3V0YWJsZV9wICIkYXNfZGlyLyRhY193b3JkJGFjX2V4ZWNfZXh0 IjsgdGhlbgorICAgIGFjX2N2X3Byb2dfYWNfY3RfQ0M9IiRhY19wcm9nIgorICAgICRhc19lY2hv ICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGZvdW5kICRhc19kaXIvJGFjX3dvcmQkYWNf ZXhlY19leHQiID4mNQorICAgIGJyZWFrIDIKKyAgZmkKK2RvbmUKKyAgZG9uZQorSUZTPSRhc19z YXZlX0lGUworCitmaQorZmkKK2FjX2N0X0NDPSRhY19jdl9wcm9nX2FjX2N0X0NDCitpZiB0ZXN0 IC1uICIkYWNfY3RfQ0MiOyB0aGVuCisgIHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0k TElORU5PfTogcmVzdWx0OiAkYWNfY3RfQ0MiID4mNQorJGFzX2VjaG8gIiRhY19jdF9DQyIgPiY2 OyB9CitlbHNlCisgIHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVz dWx0OiBubyIgPiY1CiskYXNfZWNobyAibm8iID4mNjsgfQorZmkKKworCisgIHRlc3QgLW4gIiRh Y19jdF9DQyIgJiYgYnJlYWsKK2RvbmUKKworICBpZiB0ZXN0ICJ4JGFjX2N0X0NDIiA9IHg7IHRo ZW4KKyAgICBDQz0iIgorICBlbHNlCisgICAgY2FzZSAkY3Jvc3NfY29tcGlsaW5nOiRhY190b29s X3dhcm5lZCBpbgoreWVzOikKK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5P fTogV0FSTklORzogdXNpbmcgY3Jvc3MgdG9vbHMgbm90IHByZWZpeGVkIHdpdGggaG9zdCB0cmlw bGV0IiA+JjUKKyRhc19lY2hvICIkYXNfbWU6IFdBUk5JTkc6IHVzaW5nIGNyb3NzIHRvb2xzIG5v dCBwcmVmaXhlZCB3aXRoIGhvc3QgdHJpcGxldCIgPiYyO30KK2FjX3Rvb2xfd2FybmVkPXllcyA7 OworZXNhYworICAgIENDPSRhY19jdF9DQworICBmaQorZmkKKworZmkKKworCit0ZXN0IC16ICIk Q0MiICYmIHsgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBlcnJvcjog aW4gXGAkYWNfcHdkJzoiID4mNQorJGFzX2VjaG8gIiRhc19tZTogZXJyb3I6IGluIFxgJGFjX3B3 ZCc6IiA+JjI7fQorYXNfZm5fZXJyb3IgJD8gIm5vIGFjY2VwdGFibGUgQyBjb21waWxlciBmb3Vu ZCBpbiBcJFBBVEgKK1NlZSBcYGNvbmZpZy5sb2cnIGZvciBtb3JlIGRldGFpbHMiICIkTElORU5P IiA1OyB9CisKKyMgUHJvdmlkZSBzb21lIGluZm9ybWF0aW9uIGFib3V0IHRoZSBjb21waWxlci4K KyRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNoZWNraW5nIGZvciBDIGNv bXBpbGVyIHZlcnNpb24iID4mNQorc2V0IFggJGFjX2NvbXBpbGUKK2FjX2NvbXBpbGVyPSQyCitm b3IgYWNfb3B0aW9uIGluIC0tdmVyc2lvbiAtdiAtViAtcXZlcnNpb247IGRvCisgIHsgeyBhY190 cnk9IiRhY19jb21waWxlciAkYWNfb3B0aW9uID4mNSIKK2Nhc2UgIigoJGFjX3RyeSIgaW4KKyAg KlwiKiB8ICpcYCogfCAqXFwqKSBhY190cnlfZWNobz1cJGFjX3RyeTs7CisgICopIGFjX3RyeV9l Y2hvPSRhY190cnk7OworZXNhYworZXZhbCBhY190cnlfZWNobz0iXCJcJGFzX21lOiR7YXNfbGlu ZW5vLSRMSU5FTk99OiAkYWNfdHJ5X2VjaG9cIiIKKyRhc19lY2hvICIkYWNfdHJ5X2VjaG8iOyB9 ID4mNQorICAoZXZhbCAiJGFjX2NvbXBpbGVyICRhY19vcHRpb24gPiY1IikgMj5jb25mdGVzdC5l cnIKKyAgYWNfc3RhdHVzPSQ/CisgIGlmIHRlc3QgLXMgY29uZnRlc3QuZXJyOyB0aGVuCisgICAg c2VkICcxMGFcCisuLi4gcmVzdCBvZiBzdGRlcnIgb3V0cHV0IGRlbGV0ZWQgLi4uCisgICAgICAg ICAxMHEnIGNvbmZ0ZXN0LmVyciA+Y29uZnRlc3QuZXIxCisgICAgY2F0IGNvbmZ0ZXN0LmVyMSA+ JjUKKyAgZmkKKyAgcm0gLWYgY29uZnRlc3QuZXIxIGNvbmZ0ZXN0LmVycgorICAkYXNfZWNobyAi JGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBcJD8gPSAkYWNfc3RhdHVzIiA+JjUKKyAgdGVz dCAkYWNfc3RhdHVzID0gMDsgfQorZG9uZQorCitjYXQgY29uZmRlZnMuaCAtIDw8X0FDRU9GID5j b25mdGVzdC4kYWNfZXh0CisvKiBlbmQgY29uZmRlZnMuaC4gICovCisKK2ludAorbWFpbiAoKQor eworCisgIDsKKyAgcmV0dXJuIDA7Cit9CitfQUNFT0YKK2FjX2NsZWFuX2ZpbGVzX3NhdmU9JGFj X2NsZWFuX2ZpbGVzCithY19jbGVhbl9maWxlcz0iJGFjX2NsZWFuX2ZpbGVzIGEub3V0IGEub3V0 LmRTWU0gYS5leGUgYi5vdXQiCisjIFRyeSB0byBjcmVhdGUgYW4gZXhlY3V0YWJsZSB3aXRob3V0 IC1vIGZpcnN0LCBkaXNyZWdhcmQgYS5vdXQuCisjIEl0IHdpbGwgaGVscCB1cyBkaWFnbm9zZSBi cm9rZW4gY29tcGlsZXJzLCBhbmQgZmluZGluZyBvdXQgYW4gaW50dWl0aW9uCisjIG9mIGV4ZWV4 dC4KK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tpbmcgd2hl dGhlciB0aGUgQyBjb21waWxlciB3b3JrcyIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyB3aGV0 aGVyIHRoZSBDIGNvbXBpbGVyIHdvcmtzLi4uICIgPiY2OyB9CithY19saW5rX2RlZmF1bHQ9YCRh c19lY2hvICIkYWNfbGluayIgfCBzZWQgJ3MvIC1vICpjb25mdGVzdFteIF0qLy8nYAorCisjIFRo ZSBwb3NzaWJsZSBvdXRwdXQgZmlsZXM6CithY19maWxlcz0iYS5vdXQgY29uZnRlc3QuZXhlIGNv bmZ0ZXN0IGEuZXhlIGFfb3V0LmV4ZSBiLm91dCBjb25mdGVzdC4qIgorCithY19ybWZpbGVzPQor Zm9yIGFjX2ZpbGUgaW4gJGFjX2ZpbGVzCitkbworICBjYXNlICRhY19maWxlIGluCisgICAgKi4k YWNfZXh0IHwgKi54Y29mZiB8ICoudGRzIHwgKi5kIHwgKi5wZGIgfCAqLnhTWU0gfCAqLmJiIHwg Ki5iYmcgfCAqLm1hcCB8ICouaW5mIHwgKi5kU1lNIHwgKi5vIHwgKi5vYmogKSA7OworICAgICog KSBhY19ybWZpbGVzPSIkYWNfcm1maWxlcyAkYWNfZmlsZSI7OworICBlc2FjCitkb25lCitybSAt ZiAkYWNfcm1maWxlcworCitpZiB7IHsgYWNfdHJ5PSIkYWNfbGlua19kZWZhdWx0IgorY2FzZSAi KCgkYWNfdHJ5IiBpbgorICAqXCIqIHwgKlxgKiB8ICpcXCopIGFjX3RyeV9lY2hvPVwkYWNfdHJ5 OzsKKyAgKikgYWNfdHJ5X2VjaG89JGFjX3RyeTs7Citlc2FjCitldmFsIGFjX3RyeV9lY2hvPSJc IlwkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306ICRhY190cnlfZWNob1wiIgorJGFzX2VjaG8g IiRhY190cnlfZWNobyI7IH0gPiY1CisgIChldmFsICIkYWNfbGlua19kZWZhdWx0IikgMj4mNQor ICBhY19zdGF0dXM9JD8KKyAgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTog XCQ/ID0gJGFjX3N0YXR1cyIgPiY1CisgIHRlc3QgJGFjX3N0YXR1cyA9IDA7IH07IHRoZW4gOgor ICAjIEF1dG9jb25mLTIuMTMgY291bGQgc2V0IHRoZSBhY19jdl9leGVleHQgdmFyaWFibGUgdG8g YG5vJy4KKyMgU28gaWdub3JlIGEgdmFsdWUgb2YgYG5vJywgb3RoZXJ3aXNlIHRoaXMgd291bGQg bGVhZCB0byBgRVhFRVhUID0gbm8nCisjIGluIGEgTWFrZWZpbGUuICBXZSBzaG91bGQgbm90IG92 ZXJyaWRlIGFjX2N2X2V4ZWV4dCBpZiBpdCB3YXMgY2FjaGVkLAorIyBzbyB0aGF0IHRoZSB1c2Vy IGNhbiBzaG9ydC1jaXJjdWl0IHRoaXMgdGVzdCBmb3IgY29tcGlsZXJzIHVua25vd24gdG8KKyMg QXV0b2NvbmYuCitmb3IgYWNfZmlsZSBpbiAkYWNfZmlsZXMgJycKK2RvCisgIHRlc3QgLWYgIiRh Y19maWxlIiB8fCBjb250aW51ZQorICBjYXNlICRhY19maWxlIGluCisgICAgKi4kYWNfZXh0IHwg Ki54Y29mZiB8ICoudGRzIHwgKi5kIHwgKi5wZGIgfCAqLnhTWU0gfCAqLmJiIHwgKi5iYmcgfCAq Lm1hcCB8ICouaW5mIHwgKi5kU1lNIHwgKi5vIHwgKi5vYmogKQorCTs7CisgICAgW2FiXS5vdXQg KQorCSMgV2UgZm91bmQgdGhlIGRlZmF1bHQgZXhlY3V0YWJsZSwgYnV0IGV4ZWV4dD0nJyBpcyBt b3N0CisJIyBjZXJ0YWlubHkgcmlnaHQuCisJYnJlYWs7OworICAgICouKiApCisJaWYgdGVzdCAi JHthY19jdl9leGVleHQrc2V0fSIgPSBzZXQgJiYgdGVzdCAiJGFjX2N2X2V4ZWV4dCIgIT0gbm87 CisJdGhlbiA6OyBlbHNlCisJICAgYWNfY3ZfZXhlZXh0PWBleHByICIkYWNfZmlsZSIgOiAnW14u XSpcKFwuLipcKSdgCisJZmkKKwkjIFdlIHNldCBhY19jdl9leGVleHQgaGVyZSBiZWNhdXNlIHRo ZSBsYXRlciB0ZXN0IGZvciBpdCBpcyBub3QKKwkjIHNhZmU6IGNyb3NzIGNvbXBpbGVycyBtYXkg bm90IGFkZCB0aGUgc3VmZml4IGlmIGdpdmVuIGFuIGAtbycKKwkjIGFyZ3VtZW50LCBzbyB3ZSBt YXkgbmVlZCB0byBrbm93IGl0IGF0IHRoYXQgcG9pbnQgYWxyZWFkeS4KKwkjIEV2ZW4gaWYgdGhp cyBzZWN0aW9uIGxvb2tzIGNydWZ0eTogaXQgaGFzIHRoZSBhZHZhbnRhZ2Ugb2YKKwkjIGFjdHVh bGx5IHdvcmtpbmcuCisJYnJlYWs7OworICAgICogKQorCWJyZWFrOzsKKyAgZXNhYworZG9uZQor dGVzdCAiJGFjX2N2X2V4ZWV4dCIgPSBubyAmJiBhY19jdl9leGVleHQ9CisKK2Vsc2UKKyAgYWNf ZmlsZT0nJworZmkKK2lmIHRlc3QgLXogIiRhY19maWxlIjsgdGhlbiA6CisgIHsgJGFzX2VjaG8g IiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVzdWx0OiBubyIgPiY1CiskYXNfZWNobyAi bm8iID4mNjsgfQorJGFzX2VjaG8gIiRhc19tZTogZmFpbGVkIHByb2dyYW0gd2FzOiIgPiY1Citz ZWQgJ3MvXi98IC8nIGNvbmZ0ZXN0LiRhY19leHQgPiY1CisKK3sgeyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiBlcnJvcjogaW4gXGAkYWNfcHdkJzoiID4mNQorJGFzX2Vj aG8gIiRhc19tZTogZXJyb3I6IGluIFxgJGFjX3B3ZCc6IiA+JjI7fQorYXNfZm5fZXJyb3IgNzcg IkMgY29tcGlsZXIgY2Fubm90IGNyZWF0ZSBleGVjdXRhYmxlcworU2VlIFxgY29uZmlnLmxvZycg Zm9yIG1vcmUgZGV0YWlscyIgIiRMSU5FTk8iIDU7IH0KK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFz X21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6IHllcyIgPiY1CiskYXNfZWNobyAieWVz IiA+JjY7IH0KK2ZpCit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNo ZWNraW5nIGZvciBDIGNvbXBpbGVyIGRlZmF1bHQgb3V0cHV0IGZpbGUgbmFtZSIgPiY1CiskYXNf ZWNob19uICJjaGVja2luZyBmb3IgQyBjb21waWxlciBkZWZhdWx0IG91dHB1dCBmaWxlIG5hbWUu Li4gIiA+JjY7IH0KK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVz dWx0OiAkYWNfZmlsZSIgPiY1CiskYXNfZWNobyAiJGFjX2ZpbGUiID4mNjsgfQorYWNfZXhlZXh0 PSRhY19jdl9leGVleHQKKworcm0gLWYgLXIgYS5vdXQgYS5vdXQuZFNZTSBhLmV4ZSBjb25mdGVz dCRhY19jdl9leGVleHQgYi5vdXQKK2FjX2NsZWFuX2ZpbGVzPSRhY19jbGVhbl9maWxlc19zYXZl Cit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNoZWNraW5nIGZvciBz dWZmaXggb2YgZXhlY3V0YWJsZXMiID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9yIHN1ZmZp eCBvZiBleGVjdXRhYmxlcy4uLiAiID4mNjsgfQoraWYgeyB7IGFjX3RyeT0iJGFjX2xpbmsiCitj YXNlICIoKCRhY190cnkiIGluCisgICpcIiogfCAqXGAqIHwgKlxcKikgYWNfdHJ5X2VjaG89XCRh Y190cnk7OworICAqKSBhY190cnlfZWNobz0kYWNfdHJ5OzsKK2VzYWMKK2V2YWwgYWNfdHJ5X2Vj aG89IlwiXCRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogJGFjX3RyeV9lY2hvXCIiCiskYXNf ZWNobyAiJGFjX3RyeV9lY2hvIjsgfSA+JjUKKyAgKGV2YWwgIiRhY19saW5rIikgMj4mNQorICBh Y19zdGF0dXM9JD8KKyAgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogXCQ/ ID0gJGFjX3N0YXR1cyIgPiY1CisgIHRlc3QgJGFjX3N0YXR1cyA9IDA7IH07IHRoZW4gOgorICAj IElmIGJvdGggYGNvbmZ0ZXN0LmV4ZScgYW5kIGBjb25mdGVzdCcgYXJlIGBwcmVzZW50JyAod2Vs bCwgb2JzZXJ2YWJsZSkKKyMgY2F0Y2ggYGNvbmZ0ZXN0LmV4ZScuICBGb3IgaW5zdGFuY2Ugd2l0 aCBDeWd3aW4sIGBscyBjb25mdGVzdCcgd2lsbAorIyB3b3JrIHByb3Blcmx5IChpLmUuLCByZWZl ciB0byBgY29uZnRlc3QuZXhlJyksIHdoaWxlIGl0IHdvbid0IHdpdGgKKyMgYHJtJy4KK2ZvciBh Y19maWxlIGluIGNvbmZ0ZXN0LmV4ZSBjb25mdGVzdCBjb25mdGVzdC4qOyBkbworICB0ZXN0IC1m ICIkYWNfZmlsZSIgfHwgY29udGludWUKKyAgY2FzZSAkYWNfZmlsZSBpbgorICAgICouJGFjX2V4 dCB8ICoueGNvZmYgfCAqLnRkcyB8ICouZCB8ICoucGRiIHwgKi54U1lNIHwgKi5iYiB8ICouYmJn IHwgKi5tYXAgfCAqLmluZiB8ICouZFNZTSB8ICoubyB8ICoub2JqICkgOzsKKyAgICAqLiogKSBh Y19jdl9leGVleHQ9YGV4cHIgIiRhY19maWxlIiA6ICdbXi5dKlwoXC4uKlwpJ2AKKwkgIGJyZWFr OzsKKyAgICAqICkgYnJlYWs7OworICBlc2FjCitkb25lCitlbHNlCisgIHsgeyAkYXNfZWNobyAi JGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBlcnJvcjogaW4gXGAkYWNfcHdkJzoiID4mNQor JGFzX2VjaG8gIiRhc19tZTogZXJyb3I6IGluIFxgJGFjX3B3ZCc6IiA+JjI7fQorYXNfZm5fZXJy b3IgJD8gImNhbm5vdCBjb21wdXRlIHN1ZmZpeCBvZiBleGVjdXRhYmxlczogY2Fubm90IGNvbXBp bGUgYW5kIGxpbmsKK1NlZSBcYGNvbmZpZy5sb2cnIGZvciBtb3JlIGRldGFpbHMiICIkTElORU5P IiA1OyB9CitmaQorcm0gLWYgY29uZnRlc3QgY29uZnRlc3QkYWNfY3ZfZXhlZXh0Cit7ICRhc19l Y2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogJGFjX2N2X2V4ZWV4dCIg PiY1CiskYXNfZWNobyAiJGFjX2N2X2V4ZWV4dCIgPiY2OyB9CisKK3JtIC1mIGNvbmZ0ZXN0LiRh Y19leHQKK0VYRUVYVD0kYWNfY3ZfZXhlZXh0CithY19leGVleHQ9JEVYRUVYVAorY2F0IGNvbmZk ZWZzLmggLSA8PF9BQ0VPRiA+Y29uZnRlc3QuJGFjX2V4dAorLyogZW5kIGNvbmZkZWZzLmguICAq LworI2luY2x1ZGUgPHN0ZGlvLmg+CitpbnQKK21haW4gKCkKK3sKK0ZJTEUgKmYgPSBmb3BlbiAo ImNvbmZ0ZXN0Lm91dCIsICJ3Iik7CisgcmV0dXJuIGZlcnJvciAoZikgfHwgZmNsb3NlIChmKSAh PSAwOworCisgIDsKKyAgcmV0dXJuIDA7Cit9CitfQUNFT0YKK2FjX2NsZWFuX2ZpbGVzPSIkYWNf Y2xlYW5fZmlsZXMgY29uZnRlc3Qub3V0IgorIyBDaGVjayB0aGF0IHRoZSBjb21waWxlciBwcm9k dWNlcyBleGVjdXRhYmxlcyB3ZSBjYW4gcnVuLiAgSWYgbm90LCBlaXRoZXIKKyMgdGhlIGNvbXBp bGVyIGlzIGJyb2tlbiwgb3Igd2UgY3Jvc3MgY29tcGlsZS4KK3sgJGFzX2VjaG8gIiRhc19tZTok e2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tpbmcgd2hldGhlciB3ZSBhcmUgY3Jvc3MgY29tcGls aW5nIiA+JjUKKyRhc19lY2hvX24gImNoZWNraW5nIHdoZXRoZXIgd2UgYXJlIGNyb3NzIGNvbXBp bGluZy4uLiAiID4mNjsgfQoraWYgdGVzdCAiJGNyb3NzX2NvbXBpbGluZyIgIT0geWVzOyB0aGVu CisgIHsgeyBhY190cnk9IiRhY19saW5rIgorY2FzZSAiKCgkYWNfdHJ5IiBpbgorICAqXCIqIHwg KlxgKiB8ICpcXCopIGFjX3RyeV9lY2hvPVwkYWNfdHJ5OzsKKyAgKikgYWNfdHJ5X2VjaG89JGFj X3RyeTs7Citlc2FjCitldmFsIGFjX3RyeV9lY2hvPSJcIlwkYXNfbWU6JHthc19saW5lbm8tJExJ TkVOT306ICRhY190cnlfZWNob1wiIgorJGFzX2VjaG8gIiRhY190cnlfZWNobyI7IH0gPiY1Cisg IChldmFsICIkYWNfbGluayIpIDI+JjUKKyAgYWNfc3RhdHVzPSQ/CisgICRhc19lY2hvICIkYXNf bWU6JHthc19saW5lbm8tJExJTkVOT306IFwkPyA9ICRhY19zdGF0dXMiID4mNQorICB0ZXN0ICRh Y19zdGF0dXMgPSAwOyB9CisgIGlmIHsgYWNfdHJ5PScuL2NvbmZ0ZXN0JGFjX2N2X2V4ZWV4dCcK KyAgeyB7IGNhc2UgIigoJGFjX3RyeSIgaW4KKyAgKlwiKiB8ICpcYCogfCAqXFwqKSBhY190cnlf ZWNobz1cJGFjX3RyeTs7CisgICopIGFjX3RyeV9lY2hvPSRhY190cnk7OworZXNhYworZXZhbCBh Y190cnlfZWNobz0iXCJcJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiAkYWNfdHJ5X2VjaG9c IiIKKyRhc19lY2hvICIkYWNfdHJ5X2VjaG8iOyB9ID4mNQorICAoZXZhbCAiJGFjX3RyeSIpIDI+ JjUKKyAgYWNfc3RhdHVzPSQ/CisgICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVO T306IFwkPyA9ICRhY19zdGF0dXMiID4mNQorICB0ZXN0ICRhY19zdGF0dXMgPSAwOyB9OyB9OyB0 aGVuCisgICAgY3Jvc3NfY29tcGlsaW5nPW5vCisgIGVsc2UKKyAgICBpZiB0ZXN0ICIkY3Jvc3Nf Y29tcGlsaW5nIiA9IG1heWJlOyB0aGVuCisJY3Jvc3NfY29tcGlsaW5nPXllcworICAgIGVsc2UK Kwl7IHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogZXJyb3I6IGluIFxg JGFjX3B3ZCc6IiA+JjUKKyRhc19lY2hvICIkYXNfbWU6IGVycm9yOiBpbiBcYCRhY19wd2QnOiIg PiYyO30KK2FzX2ZuX2Vycm9yICQ/ICJjYW5ub3QgcnVuIEMgY29tcGlsZWQgcHJvZ3JhbXMuCitJ ZiB5b3UgbWVhbnQgdG8gY3Jvc3MgY29tcGlsZSwgdXNlIFxgLS1ob3N0Jy4KK1NlZSBcYGNvbmZp Zy5sb2cnIGZvciBtb3JlIGRldGFpbHMiICIkTElORU5PIiA1OyB9CisgICAgZmkKKyAgZmkKK2Zp Cit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogJGNyb3Nz X2NvbXBpbGluZyIgPiY1CiskYXNfZWNobyAiJGNyb3NzX2NvbXBpbGluZyIgPiY2OyB9CisKK3Jt IC1mIGNvbmZ0ZXN0LiRhY19leHQgY29uZnRlc3QkYWNfY3ZfZXhlZXh0IGNvbmZ0ZXN0Lm91dAor YWNfY2xlYW5fZmlsZXM9JGFjX2NsZWFuX2ZpbGVzX3NhdmUKK3sgJGFzX2VjaG8gIiRhc19tZTok e2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tpbmcgZm9yIHN1ZmZpeCBvZiBvYmplY3QgZmlsZXMi ID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9yIHN1ZmZpeCBvZiBvYmplY3QgZmlsZXMuLi4g IiA+JjY7IH0KK2lmICR7YWNfY3Zfb2JqZXh0Kzp9IGZhbHNlOyB0aGVuIDoKKyAgJGFzX2VjaG9f biAiKGNhY2hlZCkgIiA+JjYKK2Vsc2UKKyAgY2F0IGNvbmZkZWZzLmggLSA8PF9BQ0VPRiA+Y29u ZnRlc3QuJGFjX2V4dAorLyogZW5kIGNvbmZkZWZzLmguICAqLworCitpbnQKK21haW4gKCkKK3sK KworICA7CisgIHJldHVybiAwOworfQorX0FDRU9GCitybSAtZiBjb25mdGVzdC5vIGNvbmZ0ZXN0 Lm9iagoraWYgeyB7IGFjX3RyeT0iJGFjX2NvbXBpbGUiCitjYXNlICIoKCRhY190cnkiIGluCisg ICpcIiogfCAqXGAqIHwgKlxcKikgYWNfdHJ5X2VjaG89XCRhY190cnk7OworICAqKSBhY190cnlf ZWNobz0kYWNfdHJ5OzsKK2VzYWMKK2V2YWwgYWNfdHJ5X2VjaG89IlwiXCRhc19tZToke2FzX2xp bmVuby0kTElORU5PfTogJGFjX3RyeV9lY2hvXCIiCiskYXNfZWNobyAiJGFjX3RyeV9lY2hvIjsg fSA+JjUKKyAgKGV2YWwgIiRhY19jb21waWxlIikgMj4mNQorICBhY19zdGF0dXM9JD8KKyAgJGFz X2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogXCQ/ID0gJGFjX3N0YXR1cyIgPiY1 CisgIHRlc3QgJGFjX3N0YXR1cyA9IDA7IH07IHRoZW4gOgorICBmb3IgYWNfZmlsZSBpbiBjb25m dGVzdC5vIGNvbmZ0ZXN0Lm9iaiBjb25mdGVzdC4qOyBkbworICB0ZXN0IC1mICIkYWNfZmlsZSIg fHwgY29udGludWU7CisgIGNhc2UgJGFjX2ZpbGUgaW4KKyAgICAqLiRhY19leHQgfCAqLnhjb2Zm IHwgKi50ZHMgfCAqLmQgfCAqLnBkYiB8ICoueFNZTSB8ICouYmIgfCAqLmJiZyB8ICoubWFwIHwg Ki5pbmYgfCAqLmRTWU0gKSA7OworICAgICopIGFjX2N2X29iamV4dD1gZXhwciAiJGFjX2ZpbGUi IDogJy4qXC5cKC4qXCknYAorICAgICAgIGJyZWFrOzsKKyAgZXNhYworZG9uZQorZWxzZQorICAk YXNfZWNobyAiJGFzX21lOiBmYWlsZWQgcHJvZ3JhbSB3YXM6IiA+JjUKK3NlZCAncy9eL3wgLycg Y29uZnRlc3QuJGFjX2V4dCA+JjUKKworeyB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8t JExJTkVOT306IGVycm9yOiBpbiBcYCRhY19wd2QnOiIgPiY1CiskYXNfZWNobyAiJGFzX21lOiBl cnJvcjogaW4gXGAkYWNfcHdkJzoiID4mMjt9Cithc19mbl9lcnJvciAkPyAiY2Fubm90IGNvbXB1 dGUgc3VmZml4IG9mIG9iamVjdCBmaWxlczogY2Fubm90IGNvbXBpbGUKK1NlZSBcYGNvbmZpZy5s b2cnIGZvciBtb3JlIGRldGFpbHMiICIkTElORU5PIiA1OyB9CitmaQorcm0gLWYgY29uZnRlc3Qu JGFjX2N2X29iamV4dCBjb25mdGVzdC4kYWNfZXh0CitmaQoreyAkYXNfZWNobyAiJGFzX21lOiR7 YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6ICRhY19jdl9vYmpleHQiID4mNQorJGFzX2VjaG8g IiRhY19jdl9vYmpleHQiID4mNjsgfQorT0JKRVhUPSRhY19jdl9vYmpleHQKK2FjX29iamV4dD0k T0JKRVhUCit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNoZWNraW5n IHdoZXRoZXIgd2UgYXJlIHVzaW5nIHRoZSBHTlUgQyBjb21waWxlciIgPiY1CiskYXNfZWNob19u ICJjaGVja2luZyB3aGV0aGVyIHdlIGFyZSB1c2luZyB0aGUgR05VIEMgY29tcGlsZXIuLi4gIiA+ JjY7IH0KK2lmICR7YWNfY3ZfY19jb21waWxlcl9nbnUrOn0gZmFsc2U7IHRoZW4gOgorICAkYXNf ZWNob19uICIoY2FjaGVkKSAiID4mNgorZWxzZQorICBjYXQgY29uZmRlZnMuaCAtIDw8X0FDRU9G ID5jb25mdGVzdC4kYWNfZXh0CisvKiBlbmQgY29uZmRlZnMuaC4gICovCisKK2ludAorbWFpbiAo KQoreworI2lmbmRlZiBfX0dOVUNfXworICAgICAgIGNob2tlIG1lCisjZW5kaWYKKworICA7Cisg IHJldHVybiAwOworfQorX0FDRU9GCitpZiBhY19mbl9jX3RyeV9jb21waWxlICIkTElORU5PIjsg dGhlbiA6CisgIGFjX2NvbXBpbGVyX2dudT15ZXMKK2Vsc2UKKyAgYWNfY29tcGlsZXJfZ251PW5v CitmaQorcm0gLWYgY29yZSBjb25mdGVzdC5lcnIgY29uZnRlc3QuJGFjX29iamV4dCBjb25mdGVz dC4kYWNfZXh0CithY19jdl9jX2NvbXBpbGVyX2dudT0kYWNfY29tcGlsZXJfZ251CisKK2ZpCit7 ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogJGFjX2N2X2Nf Y29tcGlsZXJfZ251IiA+JjUKKyRhc19lY2hvICIkYWNfY3ZfY19jb21waWxlcl9nbnUiID4mNjsg fQoraWYgdGVzdCAkYWNfY29tcGlsZXJfZ251ID0geWVzOyB0aGVuCisgIEdDQz15ZXMKK2Vsc2UK KyAgR0NDPQorZmkKK2FjX3Rlc3RfQ0ZMQUdTPSR7Q0ZMQUdTK3NldH0KK2FjX3NhdmVfQ0ZMQUdT PSRDRkxBR1MKK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tp bmcgd2hldGhlciAkQ0MgYWNjZXB0cyAtZyIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyB3aGV0 aGVyICRDQyBhY2NlcHRzIC1nLi4uICIgPiY2OyB9CitpZiAke2FjX2N2X3Byb2dfY2NfZys6fSBm YWxzZTsgdGhlbiA6CisgICRhc19lY2hvX24gIihjYWNoZWQpICIgPiY2CitlbHNlCisgIGFjX3Nh dmVfY193ZXJyb3JfZmxhZz0kYWNfY193ZXJyb3JfZmxhZworICAgYWNfY193ZXJyb3JfZmxhZz15 ZXMKKyAgIGFjX2N2X3Byb2dfY2NfZz1ubworICAgQ0ZMQUdTPSItZyIKKyAgIGNhdCBjb25mZGVm cy5oIC0gPDxfQUNFT0YgPmNvbmZ0ZXN0LiRhY19leHQKKy8qIGVuZCBjb25mZGVmcy5oLiAgKi8K KworaW50CittYWluICgpCit7CisKKyAgOworICByZXR1cm4gMDsKK30KK19BQ0VPRgoraWYgYWNf Zm5fY190cnlfY29tcGlsZSAiJExJTkVOTyI7IHRoZW4gOgorICBhY19jdl9wcm9nX2NjX2c9eWVz CitlbHNlCisgIENGTEFHUz0iIgorICAgICAgY2F0IGNvbmZkZWZzLmggLSA8PF9BQ0VPRiA+Y29u ZnRlc3QuJGFjX2V4dAorLyogZW5kIGNvbmZkZWZzLmguICAqLworCitpbnQKK21haW4gKCkKK3sK KworICA7CisgIHJldHVybiAwOworfQorX0FDRU9GCitpZiBhY19mbl9jX3RyeV9jb21waWxlICIk TElORU5PIjsgdGhlbiA6CisKK2Vsc2UKKyAgYWNfY193ZXJyb3JfZmxhZz0kYWNfc2F2ZV9jX3dl cnJvcl9mbGFnCisJIENGTEFHUz0iLWciCisJIGNhdCBjb25mZGVmcy5oIC0gPDxfQUNFT0YgPmNv bmZ0ZXN0LiRhY19leHQKKy8qIGVuZCBjb25mZGVmcy5oLiAgKi8KKworaW50CittYWluICgpCit7 CisKKyAgOworICByZXR1cm4gMDsKK30KK19BQ0VPRgoraWYgYWNfZm5fY190cnlfY29tcGlsZSAi JExJTkVOTyI7IHRoZW4gOgorICBhY19jdl9wcm9nX2NjX2c9eWVzCitmaQorcm0gLWYgY29yZSBj b25mdGVzdC5lcnIgY29uZnRlc3QuJGFjX29iamV4dCBjb25mdGVzdC4kYWNfZXh0CitmaQorcm0g LWYgY29yZSBjb25mdGVzdC5lcnIgY29uZnRlc3QuJGFjX29iamV4dCBjb25mdGVzdC4kYWNfZXh0 CitmaQorcm0gLWYgY29yZSBjb25mdGVzdC5lcnIgY29uZnRlc3QuJGFjX29iamV4dCBjb25mdGVz dC4kYWNfZXh0CisgICBhY19jX3dlcnJvcl9mbGFnPSRhY19zYXZlX2Nfd2Vycm9yX2ZsYWcKK2Zp Cit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogJGFjX2N2 X3Byb2dfY2NfZyIgPiY1CiskYXNfZWNobyAiJGFjX2N2X3Byb2dfY2NfZyIgPiY2OyB9CitpZiB0 ZXN0ICIkYWNfdGVzdF9DRkxBR1MiID0gc2V0OyB0aGVuCisgIENGTEFHUz0kYWNfc2F2ZV9DRkxB R1MKK2VsaWYgdGVzdCAkYWNfY3ZfcHJvZ19jY19nID0geWVzOyB0aGVuCisgIGlmIHRlc3QgIiRH Q0MiID0geWVzOyB0aGVuCisgICAgQ0ZMQUdTPSItZyAtTzIiCisgIGVsc2UKKyAgICBDRkxBR1M9 Ii1nIgorICBmaQorZWxzZQorICBpZiB0ZXN0ICIkR0NDIiA9IHllczsgdGhlbgorICAgIENGTEFH Uz0iLU8yIgorICBlbHNlCisgICAgQ0ZMQUdTPQorICBmaQorZmkKK3sgJGFzX2VjaG8gIiRhc19t ZToke2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tpbmcgZm9yICRDQyBvcHRpb24gdG8gYWNjZXB0 IElTTyBDODkiID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9yICRDQyBvcHRpb24gdG8gYWNj ZXB0IElTTyBDODkuLi4gIiA+JjY7IH0KK2lmICR7YWNfY3ZfcHJvZ19jY19jODkrOn0gZmFsc2U7 IHRoZW4gOgorICAkYXNfZWNob19uICIoY2FjaGVkKSAiID4mNgorZWxzZQorICBhY19jdl9wcm9n X2NjX2M4OT1ubworYWNfc2F2ZV9DQz0kQ0MKK2NhdCBjb25mZGVmcy5oIC0gPDxfQUNFT0YgPmNv bmZ0ZXN0LiRhY19leHQKKy8qIGVuZCBjb25mZGVmcy5oLiAgKi8KKyNpbmNsdWRlIDxzdGRhcmcu aD4KKyNpbmNsdWRlIDxzdGRpby5oPgorc3RydWN0IHN0YXQ7CisvKiBNb3N0IG9mIHRoZSBmb2xs b3dpbmcgdGVzdHMgYXJlIHN0b2xlbiBmcm9tIFJDUyA1LjcncyBzcmMvY29uZi5zaC4gICovCitz dHJ1Y3QgYnVmIHsgaW50IHg7IH07CitGSUxFICogKCpyY3NvcGVuKSAoc3RydWN0IGJ1ZiAqLCBz dHJ1Y3Qgc3RhdCAqLCBpbnQpOworc3RhdGljIGNoYXIgKmUgKHAsIGkpCisgICAgIGNoYXIgKipw OworICAgICBpbnQgaTsKK3sKKyAgcmV0dXJuIHBbaV07Cit9CitzdGF0aWMgY2hhciAqZiAoY2hh ciAqICgqZykgKGNoYXIgKiosIGludCksIGNoYXIgKipwLCAuLi4pCit7CisgIGNoYXIgKnM7Cisg IHZhX2xpc3QgdjsKKyAgdmFfc3RhcnQgKHYscCk7CisgIHMgPSBnIChwLCB2YV9hcmcgKHYsaW50 KSk7CisgIHZhX2VuZCAodik7CisgIHJldHVybiBzOworfQorCisvKiBPU0YgNC4wIENvbXBhcSBj YyBpcyBzb21lIHNvcnQgb2YgYWxtb3N0LUFOU0kgYnkgZGVmYXVsdC4gIEl0IGhhcworICAgZnVu Y3Rpb24gcHJvdG90eXBlcyBhbmQgc3R1ZmYsIGJ1dCBub3QgJ1x4SEgnIGhleCBjaGFyYWN0ZXIg Y29uc3RhbnRzLgorICAgVGhlc2UgZG9uJ3QgcHJvdm9rZSBhbiBlcnJvciB1bmZvcnR1bmF0ZWx5 LCBpbnN0ZWFkIGFyZSBzaWxlbnRseSB0cmVhdGVkCisgICBhcyAneCcuICBUaGUgZm9sbG93aW5n IGluZHVjZXMgYW4gZXJyb3IsIHVudGlsIC1zdGQgaXMgYWRkZWQgdG8gZ2V0CisgICBwcm9wZXIg QU5TSSBtb2RlLiAgQ3VyaW91c2x5ICdceDAwJyE9J3gnIGFsd2F5cyBjb21lcyBvdXQgdHJ1ZSwg Zm9yIGFuCisgICBhcnJheSBzaXplIGF0IGxlYXN0LiAgSXQncyBuZWNlc3NhcnkgdG8gd3JpdGUg J1x4MDAnPT0wIHRvIGdldCBzb21ldGhpbmcKKyAgIHRoYXQncyB0cnVlIG9ubHkgd2l0aCAtc3Rk LiAgKi8KK2ludCBvc2Y0X2NjX2FycmF5IFsnXHgwMCcgPT0gMCA/IDEgOiAtMV07CisKKy8qIElC TSBDIDYgZm9yIEFJWCBpcyBhbG1vc3QtQU5TSSBieSBkZWZhdWx0LCBidXQgaXQgcmVwbGFjZXMg bWFjcm8gcGFyYW1ldGVycworICAgaW5zaWRlIHN0cmluZ3MgYW5kIGNoYXJhY3RlciBjb25zdGFu dHMuICAqLworI2RlZmluZSBGT08oeCkgJ3gnCitpbnQgeGxjNl9jY19hcnJheVtGT08oYSkgPT0g J3gnID8gMSA6IC0xXTsKKworaW50IHRlc3QgKGludCBpLCBkb3VibGUgeCk7CitzdHJ1Y3QgczEg e2ludCAoKmYpIChpbnQgYSk7fTsKK3N0cnVjdCBzMiB7aW50ICgqZikgKGRvdWJsZSBhKTt9Owor aW50IHBhaXJuYW1lcyAoaW50LCBjaGFyICoqLCBGSUxFICooKikoc3RydWN0IGJ1ZiAqLCBzdHJ1 Y3Qgc3RhdCAqLCBpbnQpLCBpbnQsIGludCk7CitpbnQgYXJnYzsKK2NoYXIgKiphcmd2OworaW50 CittYWluICgpCit7CityZXR1cm4gZiAoZSwgYXJndiwgMCkgIT0gYXJndlswXSAgfHwgIGYgKGUs IGFyZ3YsIDEpICE9IGFyZ3ZbMV07CisgIDsKKyAgcmV0dXJuIDA7Cit9CitfQUNFT0YKK2ZvciBh Y19hcmcgaW4gJycgLXFsYW5nbHZsPWV4dGM4OSAtcWxhbmdsdmw9YW5zaSAtc3RkIFwKKwktQWUg Ii1BYSAtRF9IUFVYX1NPVVJDRSIgIi1YYyAtRF9fRVhURU5TSU9OU19fIgorZG8KKyAgQ0M9IiRh Y19zYXZlX0NDICRhY19hcmciCisgIGlmIGFjX2ZuX2NfdHJ5X2NvbXBpbGUgIiRMSU5FTk8iOyB0 aGVuIDoKKyAgYWNfY3ZfcHJvZ19jY19jODk9JGFjX2FyZworZmkKK3JtIC1mIGNvcmUgY29uZnRl c3QuZXJyIGNvbmZ0ZXN0LiRhY19vYmpleHQKKyAgdGVzdCAieCRhY19jdl9wcm9nX2NjX2M4OSIg IT0gInhubyIgJiYgYnJlYWsKK2RvbmUKK3JtIC1mIGNvbmZ0ZXN0LiRhY19leHQKK0NDPSRhY19z YXZlX0NDCisKK2ZpCisjIEFDX0NBQ0hFX1ZBTAorY2FzZSAieCRhY19jdl9wcm9nX2NjX2M4OSIg aW4KKyAgeCkKKyAgICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJl c3VsdDogbm9uZSBuZWVkZWQiID4mNQorJGFzX2VjaG8gIm5vbmUgbmVlZGVkIiA+JjY7IH0gOzsK KyAgeG5vKQorICAgIHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVz dWx0OiB1bnN1cHBvcnRlZCIgPiY1CiskYXNfZWNobyAidW5zdXBwb3J0ZWQiID4mNjsgfSA7Owor ICAqKQorICAgIENDPSIkQ0MgJGFjX2N2X3Byb2dfY2NfYzg5IgorICAgIHsgJGFzX2VjaG8gIiRh c19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVzdWx0OiAkYWNfY3ZfcHJvZ19jY19jODkiID4m NQorJGFzX2VjaG8gIiRhY19jdl9wcm9nX2NjX2M4OSIgPiY2OyB9IDs7Citlc2FjCitpZiB0ZXN0 ICJ4JGFjX2N2X3Byb2dfY2NfYzg5IiAhPSB4bm87IHRoZW4gOgorCitmaQorCithY19leHQ9Ywor YWNfY3BwPSckQ1BQICRDUFBGTEFHUycKK2FjX2NvbXBpbGU9JyRDQyAtYyAkQ0ZMQUdTICRDUFBG TEFHUyBjb25mdGVzdC4kYWNfZXh0ID4mNScKK2FjX2xpbms9JyRDQyAtbyBjb25mdGVzdCRhY19l eGVleHQgJENGTEFHUyAkQ1BQRkxBR1MgJExERkxBR1MgY29uZnRlc3QuJGFjX2V4dCAkTElCUyA+ JjUnCithY19jb21waWxlcl9nbnU9JGFjX2N2X2NfY29tcGlsZXJfZ251CisKK3sgJGFzX2VjaG8g IiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogY2hlY2tpbmcgd2hldGhlciAke01BS0UtbWFr ZX0gc2V0cyBcJChNQUtFKSIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyB3aGV0aGVyICR7TUFL RS1tYWtlfSBzZXRzIFwkKE1BS0UpLi4uICIgPiY2OyB9CitzZXQgeCAke01BS0UtbWFrZX0KK2Fj X21ha2U9YCRhc19lY2hvICIkMiIgfCBzZWQgJ3MvKy9wL2c7IHMvW15hLXpBLVowLTlfXS9fL2cn YAoraWYgZXZhbCBcJHthY19jdl9wcm9nX21ha2VfJHthY19tYWtlfV9zZXQrOn0gZmFsc2U7IHRo ZW4gOgorICAkYXNfZWNob19uICIoY2FjaGVkKSAiID4mNgorZWxzZQorICBjYXQgPmNvbmZ0ZXN0 Lm1ha2UgPDxcX0FDRU9GCitTSEVMTCA9IC9iaW4vc2gKK2FsbDoKKwlAZWNobyAnQEBAJSUlPSQo TUFLRSk9QEBAJSUlJworX0FDRU9GCisjIEdOVSBtYWtlIHNvbWV0aW1lcyBwcmludHMgIm1ha2Vb MV06IEVudGVyaW5nIC4uLiIsIHdoaWNoIHdvdWxkIGNvbmZ1c2UgdXMuCitjYXNlIGAke01BS0Ut bWFrZX0gLWYgY29uZnRlc3QubWFrZSAyPi9kZXYvbnVsbGAgaW4KKyAgKkBAQCUlJT0/Kj1AQEAl JSUqKQorICAgIGV2YWwgYWNfY3ZfcHJvZ19tYWtlXyR7YWNfbWFrZX1fc2V0PXllczs7CisgICop CisgICAgZXZhbCBhY19jdl9wcm9nX21ha2VfJHthY19tYWtlfV9zZXQ9bm87OworZXNhYworcm0g LWYgY29uZnRlc3QubWFrZQorZmkKK2lmIGV2YWwgdGVzdCBcJGFjX2N2X3Byb2dfbWFrZV8ke2Fj X21ha2V9X3NldCA9IHllczsgdGhlbgorICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8t JExJTkVOT306IHJlc3VsdDogeWVzIiA+JjUKKyRhc19lY2hvICJ5ZXMiID4mNjsgfQorICBTRVRf TUFLRT0KK2Vsc2UKKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBy ZXN1bHQ6IG5vIiA+JjUKKyRhc19lY2hvICJubyIgPiY2OyB9CisgIFNFVF9NQUtFPSJNQUtFPSR7 TUFLRS1tYWtlfSIKK2ZpCisKKyMgRmluZCBhIGdvb2QgaW5zdGFsbCBwcm9ncmFtLiAgV2UgcHJl ZmVyIGEgQyBwcm9ncmFtIChmYXN0ZXIpLAorIyBzbyBvbmUgc2NyaXB0IGlzIGFzIGdvb2QgYXMg YW5vdGhlci4gIEJ1dCBhdm9pZCB0aGUgYnJva2VuIG9yCisjIGluY29tcGF0aWJsZSB2ZXJzaW9u czoKKyMgU3lzViAvZXRjL2luc3RhbGwsIC91c3Ivc2Jpbi9pbnN0YWxsCisjIFN1bk9TIC91c3Iv ZXRjL2luc3RhbGwKKyMgSVJJWCAvc2Jpbi9pbnN0YWxsCisjIEFJWCAvYmluL2luc3RhbGwKKyMg QW1pZ2FPUyAvQy9pbnN0YWxsLCB3aGljaCBpbnN0YWxscyBib290YmxvY2tzIG9uIGZsb3BweSBk aXNjcworIyBBSVggNCAvdXNyL2Jpbi9pbnN0YWxsYnNkLCB3aGljaCBkb2Vzbid0IHdvcmsgd2l0 aG91dCBhIC1nIGZsYWcKKyMgQUZTIC91c3IvYWZzd3MvYmluL2luc3RhbGwsIHdoaWNoIG1pc2hh bmRsZXMgbm9uZXhpc3RlbnQgYXJncworIyBTVlI0IC91c3IvdWNiL2luc3RhbGwsIHdoaWNoIHRy aWVzIHRvIHVzZSB0aGUgbm9uZXhpc3RlbnQgZ3JvdXAgInN0YWZmIgorIyBPUy8yJ3Mgc3lzdGVt IGluc3RhbGwsIHdoaWNoIGhhcyBhIGNvbXBsZXRlbHkgZGlmZmVyZW50IHNlbWFudGljCisjIC4v aW5zdGFsbCwgd2hpY2ggY2FuIGJlIGVycm9uZW91c2x5IGNyZWF0ZWQgYnkgbWFrZSBmcm9tIC4v aW5zdGFsbC5zaC4KKyMgUmVqZWN0IGluc3RhbGwgcHJvZ3JhbXMgdGhhdCBjYW5ub3QgaW5zdGFs bCBtdWx0aXBsZSBmaWxlcy4KK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5P fTogY2hlY2tpbmcgZm9yIGEgQlNELWNvbXBhdGlibGUgaW5zdGFsbCIgPiY1CiskYXNfZWNob19u ICJjaGVja2luZyBmb3IgYSBCU0QtY29tcGF0aWJsZSBpbnN0YWxsLi4uICIgPiY2OyB9CitpZiB0 ZXN0IC16ICIkSU5TVEFMTCI7IHRoZW4KK2lmICR7YWNfY3ZfcGF0aF9pbnN0YWxsKzp9IGZhbHNl OyB0aGVuIDoKKyAgJGFzX2VjaG9fbiAiKGNhY2hlZCkgIiA+JjYKK2Vsc2UKKyAgYXNfc2F2ZV9J RlM9JElGUzsgSUZTPSRQQVRIX1NFUEFSQVRPUgorZm9yIGFzX2RpciBpbiAkUEFUSAorZG8KKyAg SUZTPSRhc19zYXZlX0lGUworICB0ZXN0IC16ICIkYXNfZGlyIiAmJiBhc19kaXI9LgorICAgICMg QWNjb3VudCBmb3IgcGVvcGxlIHdobyBwdXQgdHJhaWxpbmcgc2xhc2hlcyBpbiBQQVRIIGVsZW1l bnRzLgorY2FzZSAkYXNfZGlyLyBpbiAjKCgKKyAgLi8gfCAuLy8gfCAvW2NDXS8qIHwgXAorICAv ZXRjLyogfCAvdXNyL3NiaW4vKiB8IC91c3IvZXRjLyogfCAvc2Jpbi8qIHwgL3Vzci9hZnN3cy9i aW4vKiB8IFwKKyAgPzpbXFwvXW9zMltcXC9daW5zdGFsbFtcXC9dKiB8ID86W1xcL11PUzJbXFwv XUlOU1RBTExbXFwvXSogfCBcCisgIC91c3IvdWNiLyogKSA7OworICAqKQorICAgICMgT1NGMSBh bmQgU0NPIE9EVCAzLjAgaGF2ZSB0aGVpciBvd24gbmFtZXMgZm9yIGluc3RhbGwuCisgICAgIyBE b24ndCB1c2UgaW5zdGFsbGJzZCBmcm9tIE9TRiBzaW5jZSBpdCBpbnN0YWxscyBzdHVmZiBhcyBy b290CisgICAgIyBieSBkZWZhdWx0LgorICAgIGZvciBhY19wcm9nIGluIGdpbnN0YWxsIHNjb2lu c3QgaW5zdGFsbDsgZG8KKyAgICAgIGZvciBhY19leGVjX2V4dCBpbiAnJyAkYWNfZXhlY3V0YWJs ZV9leHRlbnNpb25zOyBkbworCWlmIGFzX2ZuX2V4ZWN1dGFibGVfcCAiJGFzX2Rpci8kYWNfcHJv ZyRhY19leGVjX2V4dCI7IHRoZW4KKwkgIGlmIHRlc3QgJGFjX3Byb2cgPSBpbnN0YWxsICYmCisJ ICAgIGdyZXAgZHNwbXNnICIkYXNfZGlyLyRhY19wcm9nJGFjX2V4ZWNfZXh0IiA+L2Rldi9udWxs IDI+JjE7IHRoZW4KKwkgICAgIyBBSVggaW5zdGFsbC4gIEl0IGhhcyBhbiBpbmNvbXBhdGlibGUg Y2FsbGluZyBjb252ZW50aW9uLgorCSAgICA6CisJICBlbGlmIHRlc3QgJGFjX3Byb2cgPSBpbnN0 YWxsICYmCisJICAgIGdyZXAgcHdwbHVzICIkYXNfZGlyLyRhY19wcm9nJGFjX2V4ZWNfZXh0IiA+ L2Rldi9udWxsIDI+JjE7IHRoZW4KKwkgICAgIyBwcm9ncmFtLXNwZWNpZmljIGluc3RhbGwgc2Ny aXB0IHVzZWQgYnkgSFAgcHdwbHVzLS1kb24ndCB1c2UuCisJICAgIDoKKwkgIGVsc2UKKwkgICAg cm0gLXJmIGNvbmZ0ZXN0Lm9uZSBjb25mdGVzdC50d28gY29uZnRlc3QuZGlyCisJICAgIGVjaG8g b25lID4gY29uZnRlc3Qub25lCisJICAgIGVjaG8gdHdvID4gY29uZnRlc3QudHdvCisJICAgIG1r ZGlyIGNvbmZ0ZXN0LmRpcgorCSAgICBpZiAiJGFzX2Rpci8kYWNfcHJvZyRhY19leGVjX2V4dCIg LWMgY29uZnRlc3Qub25lIGNvbmZ0ZXN0LnR3byAiYHB3ZGAvY29uZnRlc3QuZGlyIiAmJgorCSAg ICAgIHRlc3QgLXMgY29uZnRlc3Qub25lICYmIHRlc3QgLXMgY29uZnRlc3QudHdvICYmCisJICAg ICAgdGVzdCAtcyBjb25mdGVzdC5kaXIvY29uZnRlc3Qub25lICYmCisJICAgICAgdGVzdCAtcyBj b25mdGVzdC5kaXIvY29uZnRlc3QudHdvCisJICAgIHRoZW4KKwkgICAgICBhY19jdl9wYXRoX2lu c3RhbGw9IiRhc19kaXIvJGFjX3Byb2ckYWNfZXhlY19leHQgLWMiCisJICAgICAgYnJlYWsgMwor CSAgICBmaQorCSAgZmkKKwlmaQorICAgICAgZG9uZQorICAgIGRvbmUKKyAgICA7OworZXNhYwor CisgIGRvbmUKK0lGUz0kYXNfc2F2ZV9JRlMKKworcm0gLXJmIGNvbmZ0ZXN0Lm9uZSBjb25mdGVz dC50d28gY29uZnRlc3QuZGlyCisKK2ZpCisgIGlmIHRlc3QgIiR7YWNfY3ZfcGF0aF9pbnN0YWxs K3NldH0iID0gc2V0OyB0aGVuCisgICAgSU5TVEFMTD0kYWNfY3ZfcGF0aF9pbnN0YWxsCisgIGVs c2UKKyAgICAjIEFzIGEgbGFzdCByZXNvcnQsIHVzZSB0aGUgc2xvdyBzaGVsbCBzY3JpcHQuICBE b24ndCBjYWNoZSBhCisgICAgIyB2YWx1ZSBmb3IgSU5TVEFMTCB3aXRoaW4gYSBzb3VyY2UgZGly ZWN0b3J5LCBiZWNhdXNlIHRoYXQgd2lsbAorICAgICMgYnJlYWsgb3RoZXIgcGFja2FnZXMgdXNp bmcgdGhlIGNhY2hlIGlmIHRoYXQgZGlyZWN0b3J5IGlzCisgICAgIyByZW1vdmVkLCBvciBpZiB0 aGUgdmFsdWUgaXMgYSByZWxhdGl2ZSBuYW1lLgorICAgIElOU1RBTEw9JGFjX2luc3RhbGxfc2gK KyAgZmkKK2ZpCit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3Vs dDogJElOU1RBTEwiID4mNQorJGFzX2VjaG8gIiRJTlNUQUxMIiA+JjY7IH0KKworIyBVc2UgdGVz dCAteiBiZWNhdXNlIFN1bk9TNCBzaCBtaXNoYW5kbGVzIGJyYWNlcyBpbiAke3Zhci12YWx9Lgor IyBJdCB0aGlua3MgdGhlIGZpcnN0IGNsb3NlIGJyYWNlIGVuZHMgdGhlIHZhcmlhYmxlIHN1YnN0 aXR1dGlvbi4KK3Rlc3QgLXogIiRJTlNUQUxMX1BST0dSQU0iICYmIElOU1RBTExfUFJPR1JBTT0n JHtJTlNUQUxMfScKKwordGVzdCAteiAiJElOU1RBTExfU0NSSVBUIiAmJiBJTlNUQUxMX1NDUklQ VD0nJHtJTlNUQUxMfScKKwordGVzdCAteiAiJElOU1RBTExfREFUQSIgJiYgSU5TVEFMTF9EQVRB PScke0lOU1RBTEx9IC1tIDY0NCcKKworIyBFeHRyYWN0IHRoZSBmaXJzdCB3b3JkIG9mICJ3Z2V0 Iiwgc28gaXQgY2FuIGJlIGEgcHJvZ3JhbSBuYW1lIHdpdGggYXJncy4KK3NldCBkdW1teSB3Z2V0 OyBhY193b3JkPSQyCit7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IGNo ZWNraW5nIGZvciAkYWNfd29yZCIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyBmb3IgJGFjX3dv cmQuLi4gIiA+JjY7IH0KK2lmICR7YWNfY3ZfcGF0aF9XR0VUKzp9IGZhbHNlOyB0aGVuIDoKKyAg JGFzX2VjaG9fbiAiKGNhY2hlZCkgIiA+JjYKK2Vsc2UKKyAgY2FzZSAkV0dFVCBpbgorICBbXFwv XSogfCA/OltcXC9dKikKKyAgYWNfY3ZfcGF0aF9XR0VUPSIkV0dFVCIgIyBMZXQgdGhlIHVzZXIg b3ZlcnJpZGUgdGhlIHRlc3Qgd2l0aCBhIHBhdGguCisgIDs7CisgICopCisgIGFzX3NhdmVfSUZT PSRJRlM7IElGUz0kUEFUSF9TRVBBUkFUT1IKK2ZvciBhc19kaXIgaW4gJFBBVEgKK2RvCisgIElG Uz0kYXNfc2F2ZV9JRlMKKyAgdGVzdCAteiAiJGFzX2RpciIgJiYgYXNfZGlyPS4KKyAgICBmb3Ig YWNfZXhlY19leHQgaW4gJycgJGFjX2V4ZWN1dGFibGVfZXh0ZW5zaW9uczsgZG8KKyAgaWYgYXNf Zm5fZXhlY3V0YWJsZV9wICIkYXNfZGlyLyRhY193b3JkJGFjX2V4ZWNfZXh0IjsgdGhlbgorICAg IGFjX2N2X3BhdGhfV0dFVD0iJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCIKKyAgICAkYXNf ZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBmb3VuZCAkYXNfZGlyLyRhY193b3Jk JGFjX2V4ZWNfZXh0IiA+JjUKKyAgICBicmVhayAyCisgIGZpCitkb25lCisgIGRvbmUKK0lGUz0k YXNfc2F2ZV9JRlMKKworICB0ZXN0IC16ICIkYWNfY3ZfcGF0aF9XR0VUIiAmJiBhY19jdl9wYXRo X1dHRVQ9Im5vIgorICA7OworZXNhYworZmkKK1dHRVQ9JGFjX2N2X3BhdGhfV0dFVAoraWYgdGVz dCAtbiAiJFdHRVQiOyB0aGVuCisgIHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElO RU5PfTogcmVzdWx0OiAkV0dFVCIgPiY1CiskYXNfZWNobyAiJFdHRVQiID4mNjsgfQorZWxzZQor ICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IHJlc3VsdDogbm8iID4m NQorJGFzX2VjaG8gIm5vIiA+JjY7IH0KK2ZpCisKKworaWYgdGVzdCB4IiR7V0dFVH0iID09IHgi bm8iCit0aGVuCisgICAgYXNfZm5fZXJyb3IgJD8gIlVuYWJsZSB0byBmaW5kIHdnZXQsIHBsZWFz ZSBpbnN0YWxsIHdnZXQiICIkTElORU5PIiA1CitmaQorCisjIENoZWNrcyBmb3IgcHJvZ3JhbXMg dGhhdCBkZXBlbmQgb24gYW4gYXJndW1lbnQKKworaWYgdGVzdCAieCR2dHBtIiA9ICJ4eSI7IHRo ZW4gOgorICAjIEV4dHJhY3QgdGhlIGZpcnN0IHdvcmQgb2YgImNtYWtlIiwgc28gaXQgY2FuIGJl IGEgcHJvZ3JhbSBuYW1lIHdpdGggYXJncy4KK3NldCBkdW1teSBjbWFrZTsgYWNfd29yZD0kMgor eyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBjaGVja2luZyBmb3IgJGFj X3dvcmQiID4mNQorJGFzX2VjaG9fbiAiY2hlY2tpbmcgZm9yICRhY193b3JkLi4uICIgPiY2OyB9 CitpZiAke2FjX2N2X3BhdGhfQ01BS0UrOn0gZmFsc2U7IHRoZW4gOgorICAkYXNfZWNob19uICIo Y2FjaGVkKSAiID4mNgorZWxzZQorICBjYXNlICRDTUFLRSBpbgorICBbXFwvXSogfCA/OltcXC9d KikKKyAgYWNfY3ZfcGF0aF9DTUFLRT0iJENNQUtFIiAjIExldCB0aGUgdXNlciBvdmVycmlkZSB0 aGUgdGVzdCB3aXRoIGEgcGF0aC4KKyAgOzsKKyAgKikKKyAgYXNfc2F2ZV9JRlM9JElGUzsgSUZT PSRQQVRIX1NFUEFSQVRPUgorZm9yIGFzX2RpciBpbiAkUEFUSAorZG8KKyAgSUZTPSRhc19zYXZl X0lGUworICB0ZXN0IC16ICIkYXNfZGlyIiAmJiBhc19kaXI9LgorICAgIGZvciBhY19leGVjX2V4 dCBpbiAnJyAkYWNfZXhlY3V0YWJsZV9leHRlbnNpb25zOyBkbworICBpZiBhc19mbl9leGVjdXRh YmxlX3AgIiRhc19kaXIvJGFjX3dvcmQkYWNfZXhlY19leHQiOyB0aGVuCisgICAgYWNfY3ZfcGF0 aF9DTUFLRT0iJGFzX2Rpci8kYWNfd29yZCRhY19leGVjX2V4dCIKKyAgICAkYXNfZWNobyAiJGFz X21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBmb3VuZCAkYXNfZGlyLyRhY193b3JkJGFjX2V4ZWNf ZXh0IiA+JjUKKyAgICBicmVhayAyCisgIGZpCitkb25lCisgIGRvbmUKK0lGUz0kYXNfc2F2ZV9J RlMKKworICB0ZXN0IC16ICIkYWNfY3ZfcGF0aF9DTUFLRSIgJiYgYWNfY3ZfcGF0aF9DTUFLRT0i bm8iCisgIDs7Citlc2FjCitmaQorQ01BS0U9JGFjX2N2X3BhdGhfQ01BS0UKK2lmIHRlc3QgLW4g IiRDTUFLRSI7IHRoZW4KKyAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99 OiByZXN1bHQ6ICRDTUFLRSIgPiY1CiskYXNfZWNobyAiJENNQUtFIiA+JjY7IH0KK2Vsc2UKKyAg eyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiByZXN1bHQ6IG5vIiA+JjUK KyRhc19lY2hvICJubyIgPiY2OyB9CitmaQorCisKK2lmIHRlc3QgeCIke0NNQUtFfSIgPT0geCJu byIKK3RoZW4KKyAgICBhc19mbl9lcnJvciAkPyAiVW5hYmxlIHRvIGZpbmQgY21ha2UsIHBsZWFz ZSBpbnN0YWxsIGNtYWtlIiAiJExJTkVOTyIgNQorZmkKK2Vsc2UKKworQ01BS0U9Ii9jbWFrZS1k aXNhYmxlZC1pbi1jb25maWd1cmUtc2NyaXB0IgorCisKK2ZpCisKKworIyBTdHViZG9tIGxpYnJh cmllcyB2ZXJzaW9uIGFuZCB1cmwgc2V0dXAKKworCitpZiB0ZXN0ICJ4JFpMSUJfVVJMIiA9ICJ4 IjsgdGhlbiA6CisKKwlpZiB0ZXN0ICJ4JGV4dGZpbGVzIiA9ICJ4eSI7IHRoZW4gOgorICBaTElC X1VSTD1cJFwoWEVOX0VYVEZJTEVTX1VSTFwpCitlbHNlCisgIFpMSUJfVVJMPSJodHRwOi8vd3d3 LnpsaWIubmV0IgorZmkKKworZmkKK1pMSUJfVkVSU0lPTj0iMS4yLjMiCisKKworCisKKworaWYg dGVzdCAieCRMSUJQQ0lfVVJMIiA9ICJ4IjsgdGhlbiA6CisKKwlpZiB0ZXN0ICJ4JGV4dGZpbGVz IiA9ICJ4eSI7IHRoZW4gOgorICBMSUJQQ0lfVVJMPVwkXChYRU5fRVhURklMRVNfVVJMXCkKK2Vs c2UKKyAgTElCUENJX1VSTD0iaHR0cDovL3d3dy5rZXJuZWwub3JnL3B1Yi9zb2Z0d2FyZS91dGls cy9wY2l1dGlscyIKK2ZpCisKK2ZpCitMSUJQQ0lfVkVSU0lPTj0iMi4yLjkiCisKKworCisKKwor aWYgdGVzdCAieCRORVdMSUJfVVJMIiA9ICJ4IjsgdGhlbiA6CisKKwlpZiB0ZXN0ICJ4JGV4dGZp bGVzIiA9ICJ4eSI7IHRoZW4gOgorICBORVdMSUJfVVJMPVwkXChYRU5fRVhURklMRVNfVVJMXCkK K2Vsc2UKKyAgTkVXTElCX1VSTD0iZnRwOi8vc291cmNlcy5yZWRoYXQuY29tL3B1Yi9uZXdsaWIi CitmaQorCitmaQorTkVXTElCX1ZFUlNJT049IjEuMTYuMCIKKworCisKKworCitpZiB0ZXN0ICJ4 JExXSVBfVVJMIiA9ICJ4IjsgdGhlbiA6CisKKwlpZiB0ZXN0ICJ4JGV4dGZpbGVzIiA9ICJ4eSI7 IHRoZW4gOgorICBMV0lQX1VSTD1cJFwoWEVOX0VYVEZJTEVTX1VSTFwpCitlbHNlCisgIExXSVBf VVJMPSJodHRwOi8vZG93bmxvYWQuc2F2YW5uYWguZ251Lm9yZy9yZWxlYXNlcy9sd2lwIgorZmkK KworZmkKK0xXSVBfVkVSU0lPTj0iMS4zLjAiCisKKworCisKKworaWYgdGVzdCAieCRHUlVCX1VS TCIgPSAieCI7IHRoZW4gOgorCisJaWYgdGVzdCAieCRleHRmaWxlcyIgPSAieHkiOyB0aGVuIDoK KyAgR1JVQl9VUkw9XCRcKFhFTl9FWFRGSUxFU19VUkxcKQorZWxzZQorICBHUlVCX1VSTD0iaHR0 cDovL2FscGhhLmdudS5vcmcvZ251L2dydWIiCitmaQorCitmaQorR1JVQl9WRVJTSU9OPSIwLjk3 IgorCisKKworCisKK2lmIHRlc3QgIngkT0NBTUxfVVJMIiA9ICJ4IjsgdGhlbiA6CisKKwlPQ0FN TF9VUkw9Imh0dHA6Ly9jYW1sLmlucmlhLmZyL3B1Yi9kaXN0cmliL29jYW1sLTMuMTEiCisKK2Zp CitPQ0FNTF9WRVJTSU9OPSIzLjExLjAiCisKKworCisKKworaWYgdGVzdCAieCRHTVBfVVJMIiA9 ICJ4IjsgdGhlbiA6CisKKwlpZiB0ZXN0ICJ4JGV4dGZpbGVzIiA9ICJ4eSI7IHRoZW4gOgorICBH TVBfVVJMPVwkXChYRU5fRVhURklMRVNfVVJMXCkKK2Vsc2UKKyAgR01QX1VSTD0iZnRwOi8vZnRw LmdtcGxpYi5vcmcvcHViL2dtcC00LjMuMiIKK2ZpCisKK2ZpCitHTVBfVkVSU0lPTj0iNC4zLjIi CisKKworCisKKworaWYgdGVzdCAieCRQT0xBUlNTTF9VUkwiID0gIngiOyB0aGVuIDoKKworCWlm IHRlc3QgIngkZXh0ZmlsZXMiID0gInh5IjsgdGhlbiA6CisgIFBPTEFSU1NMX1VSTD1cJFwoWEVO X0VYVEZJTEVTX1VSTFwpCitlbHNlCisgIFBPTEFSU1NMX1VSTD0iaHR0cDovL3BvbGFyc3NsLm9y Zy9jb2RlL3JlbGVhc2VzIgorZmkKKworZmkKK1BPTEFSU1NMX1ZFUlNJT049IjEuMS40IgorCisK KworCisKK2lmIHRlc3QgIngkVFBNRU1VX1VSTCIgPSAieCI7IHRoZW4gOgorCisJaWYgdGVzdCAi eCRleHRmaWxlcyIgPSAieHkiOyB0aGVuIDoKKyAgVFBNRU1VX1VSTD1cJFwoWEVOX0VYVEZJTEVT X1VSTFwpCitlbHNlCisgIFRQTUVNVV9VUkw9Imh0dHA6Ly9kb3dubG9hZC5iZXJsaW9zLmRlL3Rw bS1lbXVsYXRvciIKK2ZpCisKK2ZpCitUUE1FTVVfVkVSU0lPTj0iMC43LjQiCisKKworCisKKwor CisKKworZWNobyAiV2lsbCBidWlsZCB0aGUgZm9sbG93aW5nIHN0dWIgZG9tYWluczoiCitmb3Ig eCBpbiAkU1RVQkRPTV9CVUlMRDsgZG8KKwllY2hvICIgICR4IgorZG9uZQorCitjYXQgPmNvbmZj YWNoZSA8PFxfQUNFT0YKKyMgVGhpcyBmaWxlIGlzIGEgc2hlbGwgc2NyaXB0IHRoYXQgY2FjaGVz IHRoZSByZXN1bHRzIG9mIGNvbmZpZ3VyZQorIyB0ZXN0cyBydW4gb24gdGhpcyBzeXN0ZW0gc28g dGhleSBjYW4gYmUgc2hhcmVkIGJldHdlZW4gY29uZmlndXJlCisjIHNjcmlwdHMgYW5kIGNvbmZp Z3VyZSBydW5zLCBzZWUgY29uZmlndXJlJ3Mgb3B0aW9uIC0tY29uZmlnLWNhY2hlLgorIyBJdCBp cyBub3QgdXNlZnVsIG9uIG90aGVyIHN5c3RlbXMuICBJZiBpdCBjb250YWlucyByZXN1bHRzIHlv dSBkb24ndAorIyB3YW50IHRvIGtlZXAsIHlvdSBtYXkgcmVtb3ZlIG9yIGVkaXQgaXQuCisjCisj IGNvbmZpZy5zdGF0dXMgb25seSBwYXlzIGF0dGVudGlvbiB0byB0aGUgY2FjaGUgZmlsZSBpZiB5 b3UgZ2l2ZSBpdAorIyB0aGUgLS1yZWNoZWNrIG9wdGlvbiB0byByZXJ1biBjb25maWd1cmUuCisj CisjIGBhY19jdl9lbnZfZm9vJyB2YXJpYWJsZXMgKHNldCBvciB1bnNldCkgd2lsbCBiZSBvdmVy cmlkZGVuIHdoZW4KKyMgbG9hZGluZyB0aGlzIGZpbGUsIG90aGVyICp1bnNldCogYGFjX2N2X2Zv bycgd2lsbCBiZSBhc3NpZ25lZCB0aGUKKyMgZm9sbG93aW5nIHZhbHVlcy4KKworX0FDRU9GCisK KyMgVGhlIGZvbGxvd2luZyB3YXkgb2Ygd3JpdGluZyB0aGUgY2FjaGUgbWlzaGFuZGxlcyBuZXds aW5lcyBpbiB2YWx1ZXMsCisjIGJ1dCB3ZSBrbm93IG9mIG5vIHdvcmthcm91bmQgdGhhdCBpcyBz aW1wbGUsIHBvcnRhYmxlLCBhbmQgZWZmaWNpZW50LgorIyBTbywgd2Uga2lsbCB2YXJpYWJsZXMg Y29udGFpbmluZyBuZXdsaW5lcy4KKyMgVWx0cml4IHNoIHNldCB3cml0ZXMgdG8gc3RkZXJyIGFu ZCBjYW4ndCBiZSByZWRpcmVjdGVkIGRpcmVjdGx5LAorIyBhbmQgc2V0cyB0aGUgaGlnaCBiaXQg aW4gdGhlIGNhY2hlIGZpbGUgdW5sZXNzIHdlIGFzc2lnbiB0byB0aGUgdmFycy4KKygKKyAgZm9y IGFjX3ZhciBpbiBgKHNldCkgMj4mMSB8IHNlZCAtbiAncy9eXChbYS16QS1aX11bYS16QS1aMC05 X10qXCk9LiovXDEvcCdgOyBkbworICAgIGV2YWwgYWNfdmFsPVwkJGFjX3ZhcgorICAgIGNhc2Ug JGFjX3ZhbCBpbiAjKAorICAgICoke2FzX25sfSopCisgICAgICBjYXNlICRhY192YXIgaW4gIygK KyAgICAgICpfY3ZfKikgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBX QVJOSU5HOiBjYWNoZSB2YXJpYWJsZSAkYWNfdmFyIGNvbnRhaW5zIGEgbmV3bGluZSIgPiY1Cisk YXNfZWNobyAiJGFzX21lOiBXQVJOSU5HOiBjYWNoZSB2YXJpYWJsZSAkYWNfdmFyIGNvbnRhaW5z IGEgbmV3bGluZSIgPiYyO30gOzsKKyAgICAgIGVzYWMKKyAgICAgIGNhc2UgJGFjX3ZhciBpbiAj KAorICAgICAgXyB8IElGUyB8IGFzX25sKSA7OyAjKAorICAgICAgQkFTSF9BUkdWIHwgQkFTSF9T T1VSQ0UpIGV2YWwgJGFjX3Zhcj0gOzsgIygKKyAgICAgICopIHsgZXZhbCAkYWNfdmFyPTsgdW5z ZXQgJGFjX3Zhcjt9IDs7CisgICAgICBlc2FjIDs7CisgICAgZXNhYworICBkb25lCisKKyAgKHNl dCkgMj4mMSB8CisgICAgY2FzZSAkYXNfbmxgKGFjX3NwYWNlPScgJzsgc2V0KSAyPiYxYCBpbiAj KAorICAgICoke2FzX25sfWFjX3NwYWNlPVwgKikKKyAgICAgICMgYHNldCcgZG9lcyBub3QgcXVv dGUgY29ycmVjdGx5LCBzbyBhZGQgcXVvdGVzOiBkb3VibGUtcXVvdGUKKyAgICAgICMgc3Vic3Rp dHV0aW9uIHR1cm5zIFxcXFwgaW50byBcXCwgYW5kIHNlZCB0dXJucyBcXCBpbnRvIFwuCisgICAg ICBzZWQgLW4gXAorCSJzLycvJ1xcXFwnJy9nOworCSAgcy9eXFwoW18kYXNfY3JfYWxudW1dKl9j dl9bXyRhc19jcl9hbG51bV0qXFwpPVxcKC4qXFwpL1xcMT0nXFwyJy9wIgorICAgICAgOzsgIygK KyAgICAqKQorICAgICAgIyBgc2V0JyBxdW90ZXMgY29ycmVjdGx5IGFzIHJlcXVpcmVkIGJ5IFBP U0lYLCBzbyBkbyBub3QgYWRkIHF1b3Rlcy4KKyAgICAgIHNlZCAtbiAiL15bXyRhc19jcl9hbG51 bV0qX2N2X1tfJGFzX2NyX2FsbnVtXSo9L3AiCisgICAgICA7OworICAgIGVzYWMgfAorICAgIHNv cnQKKykgfAorICBzZWQgJworICAgICAvXmFjX2N2X2Vudl8vYiBlbmQKKyAgICAgdCBjbGVhcgor ICAgICA6Y2xlYXIKKyAgICAgcy9eXChbXj1dKlwpPVwoLipbe31dLipcKSQvdGVzdCAiJHtcMStz ZXR9IiA9IHNldCB8fCAmLworICAgICB0IGVuZAorICAgICBzL15cKFtePV0qXCk9XCguKlwpJC9c MT0ke1wxPVwyfS8KKyAgICAgOmVuZCcgPj5jb25mY2FjaGUKK2lmIGRpZmYgIiRjYWNoZV9maWxl IiBjb25mY2FjaGUgPi9kZXYvbnVsbCAyPiYxOyB0aGVuIDo7IGVsc2UKKyAgaWYgdGVzdCAtdyAi JGNhY2hlX2ZpbGUiOyB0aGVuCisgICAgaWYgdGVzdCAieCRjYWNoZV9maWxlIiAhPSAieC9kZXYv bnVsbCI7IHRoZW4KKyAgICAgIHsgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5P fTogdXBkYXRpbmcgY2FjaGUgJGNhY2hlX2ZpbGUiID4mNQorJGFzX2VjaG8gIiRhc19tZTogdXBk YXRpbmcgY2FjaGUgJGNhY2hlX2ZpbGUiID4mNjt9CisgICAgICBpZiB0ZXN0ICEgLWYgIiRjYWNo ZV9maWxlIiB8fCB0ZXN0IC1oICIkY2FjaGVfZmlsZSI7IHRoZW4KKwljYXQgY29uZmNhY2hlID4i JGNhY2hlX2ZpbGUiCisgICAgICBlbHNlCisgICAgICAgIGNhc2UgJGNhY2hlX2ZpbGUgaW4gIygK KyAgICAgICAgKi8qIHwgPzoqKQorCSAgbXYgLWYgY29uZmNhY2hlICIkY2FjaGVfZmlsZSIkJCAm JgorCSAgbXYgLWYgIiRjYWNoZV9maWxlIiQkICIkY2FjaGVfZmlsZSIgOzsgIygKKyAgICAgICAg KikKKwkgIG12IC1mIGNvbmZjYWNoZSAiJGNhY2hlX2ZpbGUiIDs7CisJZXNhYworICAgICAgZmkK KyAgICBmaQorICBlbHNlCisgICAgeyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5F Tk99OiBub3QgdXBkYXRpbmcgdW53cml0YWJsZSBjYWNoZSAkY2FjaGVfZmlsZSIgPiY1CiskYXNf ZWNobyAiJGFzX21lOiBub3QgdXBkYXRpbmcgdW53cml0YWJsZSBjYWNoZSAkY2FjaGVfZmlsZSIg PiY2O30KKyAgZmkKK2ZpCitybSAtZiBjb25mY2FjaGUKKwordGVzdCAieCRwcmVmaXgiID0geE5P TkUgJiYgcHJlZml4PSRhY19kZWZhdWx0X3ByZWZpeAorIyBMZXQgbWFrZSBleHBhbmQgZXhlY19w cmVmaXguCit0ZXN0ICJ4JGV4ZWNfcHJlZml4IiA9IHhOT05FICYmIGV4ZWNfcHJlZml4PScke3By ZWZpeH0nCisKKyMgVHJhbnNmb3JtIGNvbmZkZWZzLmggaW50byBERUZTLgorIyBQcm90ZWN0IGFn YWluc3Qgc2hlbGwgZXhwYW5zaW9uIHdoaWxlIGV4ZWN1dGluZyBNYWtlZmlsZSBydWxlcy4KKyMg UHJvdGVjdCBhZ2FpbnN0IE1ha2VmaWxlIG1hY3JvIGV4cGFuc2lvbi4KKyMKKyMgSWYgdGhlIGZp cnN0IHNlZCBzdWJzdGl0dXRpb24gaXMgZXhlY3V0ZWQgKHdoaWNoIGxvb2tzIGZvciBtYWNyb3Mg dGhhdAorIyB0YWtlIGFyZ3VtZW50cyksIHRoZW4gYnJhbmNoIHRvIHRoZSBxdW90ZSBzZWN0aW9u LiAgT3RoZXJ3aXNlLAorIyBsb29rIGZvciBhIG1hY3JvIHRoYXQgZG9lc24ndCB0YWtlIGFyZ3Vt ZW50cy4KK2FjX3NjcmlwdD0nCis6bWxpbmUKKy9cXCQveworIE4KKyBzLFxcXG4sLAorIGIgbWxp bmUKK30KK3QgY2xlYXIKKzpjbGVhcgorcy9eWwkgXSojWwkgXSpkZWZpbmVbCSBdWwkgXSpcKFte CSAoXVteCSAoXSooW14pXSopXClbCSBdKlwoLipcKS8tRFwxPVwyL2cKK3QgcXVvdGUKK3MvXlsJ IF0qI1sJIF0qZGVmaW5lWwkgXVsJIF0qXChbXgkgXVteCSBdKlwpWwkgXSpcKC4qXCkvLURcMT1c Mi9nCit0IHF1b3RlCitiIGFueQorOnF1b3RlCitzL1sJIGB+IyReJiooKXt9XFx8OydcJyciPD4/ XS9cXCYvZworcy9cWy9cXCYvZworcy9cXS9cXCYvZworcy9cJC8kJC9nCitICis6YW55Ciskewor CWcKKwlzL15cbi8vCisJcy9cbi8gL2cKKwlwCit9CisnCitERUZTPWBzZWQgLW4gIiRhY19zY3Jp cHQiIGNvbmZkZWZzLmhgCisKKworYWNfbGlib2Jqcz0KK2FjX2x0bGlib2Jqcz0KK1U9Citmb3Ig YWNfaSBpbiA6ICRMSUJPQkpTOyBkbyB0ZXN0ICJ4JGFjX2kiID0geDogJiYgY29udGludWUKKyAg IyAxLiBSZW1vdmUgdGhlIGV4dGVuc2lvbiwgYW5kICRVIGlmIGFscmVhZHkgaW5zdGFsbGVkLgor ICBhY19zY3JpcHQ9J3MvXCRVXC4vLi87cy9cLm8kLy87cy9cLm9iaiQvLycKKyAgYWNfaT1gJGFz X2VjaG8gIiRhY19pIiB8IHNlZCAiJGFjX3NjcmlwdCJgCisgICMgMi4gUHJlcGVuZCBMSUJPQkpE SVIuICBXaGVuIHVzZWQgd2l0aCBhdXRvbWFrZT49MS4xMCBMSUJPQkpESVIKKyAgIyAgICB3aWxs IGJlIHNldCB0byB0aGUgZGlyZWN0b3J5IHdoZXJlIExJQk9CSlMgb2JqZWN0cyBhcmUgYnVpbHQu CisgIGFzX2ZuX2FwcGVuZCBhY19saWJvYmpzICIgXCR7TElCT0JKRElSfSRhY19pXCRVLiRhY19v YmpleHQiCisgIGFzX2ZuX2FwcGVuZCBhY19sdGxpYm9ianMgIiBcJHtMSUJPQkpESVJ9JGFjX2ki JyRVLmxvJworZG9uZQorTElCT0JKUz0kYWNfbGlib2JqcworCitMVExJQk9CSlM9JGFjX2x0bGli b2JqcworCisKKworOiAiJHtDT05GSUdfU1RBVFVTPS4vY29uZmlnLnN0YXR1c30iCithY193cml0 ZV9mYWlsPTAKK2FjX2NsZWFuX2ZpbGVzX3NhdmU9JGFjX2NsZWFuX2ZpbGVzCithY19jbGVhbl9m aWxlcz0iJGFjX2NsZWFuX2ZpbGVzICRDT05GSUdfU1RBVFVTIgoreyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiBjcmVhdGluZyAkQ09ORklHX1NUQVRVUyIgPiY1CiskYXNf ZWNobyAiJGFzX21lOiBjcmVhdGluZyAkQ09ORklHX1NUQVRVUyIgPiY2O30KK2FzX3dyaXRlX2Zh aWw9MAorY2F0ID4kQ09ORklHX1NUQVRVUyA8PF9BU0VPRiB8fCBhc193cml0ZV9mYWlsPTEKKyMh ICRTSEVMTAorIyBHZW5lcmF0ZWQgYnkgJGFzX21lLgorIyBSdW4gdGhpcyBmaWxlIHRvIHJlY3Jl YXRlIHRoZSBjdXJyZW50IGNvbmZpZ3VyYXRpb24uCisjIENvbXBpbGVyIG91dHB1dCBwcm9kdWNl ZCBieSBjb25maWd1cmUsIHVzZWZ1bCBmb3IgZGVidWdnaW5nCisjIGNvbmZpZ3VyZSwgaXMgaW4g Y29uZmlnLmxvZyBpZiBpdCBleGlzdHMuCisKK2RlYnVnPWZhbHNlCithY19jc19yZWNoZWNrPWZh bHNlCithY19jc19zaWxlbnQ9ZmFsc2UKKworU0hFTEw9XCR7Q09ORklHX1NIRUxMLSRTSEVMTH0K K2V4cG9ydCBTSEVMTAorX0FTRU9GCitjYXQgPj4kQ09ORklHX1NUQVRVUyA8PFxfQVNFT0YgfHwg YXNfd3JpdGVfZmFpbD0xCisjIyAtLS0tLS0tLS0tLS0tLS0tLS0tLSAjIworIyMgTTRzaCBJbml0 aWFsaXphdGlvbi4gIyMKKyMjIC0tLS0tLS0tLS0tLS0tLS0tLS0tICMjCisKKyMgQmUgbW9yZSBC b3VybmUgY29tcGF0aWJsZQorRFVBTENBU0U9MTsgZXhwb3J0IERVQUxDQVNFICMgZm9yIE1LUyBz aAoraWYgdGVzdCAtbiAiJHtaU0hfVkVSU0lPTitzZXR9IiAmJiAoZW11bGF0ZSBzaCkgPi9kZXYv bnVsbCAyPiYxOyB0aGVuIDoKKyAgZW11bGF0ZSBzaAorICBOVUxMQ01EPToKKyAgIyBQcmUtNC4y IHZlcnNpb25zIG9mIFpzaCBkbyB3b3JkIHNwbGl0dGluZyBvbiAkezErIiRAIn0sIHdoaWNoCisg ICMgaXMgY29udHJhcnkgdG8gb3VyIHVzYWdlLiAgRGlzYWJsZSB0aGlzIGZlYXR1cmUuCisgIGFs aWFzIC1nICckezErIiRAIn0nPSciJEAiJworICBzZXRvcHQgTk9fR0xPQl9TVUJTVAorZWxzZQor ICBjYXNlIGAoc2V0IC1vKSAyPi9kZXYvbnVsbGAgaW4gIygKKyAgKnBvc2l4KikgOgorICAgIHNl dCAtbyBwb3NpeCA7OyAjKAorICAqKSA6CisgICAgIDs7Citlc2FjCitmaQorCisKK2FzX25sPScK KycKK2V4cG9ydCBhc19ubAorIyBQcmludGluZyBhIGxvbmcgc3RyaW5nIGNyYXNoZXMgU29sYXJp cyA3IC91c3IvYmluL3ByaW50Zi4KK2FzX2VjaG89J1xcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxc XFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxcXFxc XFxcXFxcXFxcXFxcXFxcXFxcXFwnCithc19lY2hvPSRhc19lY2hvJGFzX2VjaG8kYXNfZWNobyRh c19lY2hvJGFzX2VjaG8KK2FzX2VjaG89JGFzX2VjaG8kYXNfZWNobyRhc19lY2hvJGFzX2VjaG8k YXNfZWNobyRhc19lY2hvCisjIFByZWZlciBhIGtzaCBzaGVsbCBidWlsdGluIG92ZXIgYW4gZXh0 ZXJuYWwgcHJpbnRmIHByb2dyYW0gb24gU29sYXJpcywKKyMgYnV0IHdpdGhvdXQgd2FzdGluZyBm b3JrcyBmb3IgYmFzaCBvciB6c2guCitpZiB0ZXN0IC16ICIkQkFTSF9WRVJTSU9OJFpTSF9WRVJT SU9OIiBcCisgICAgJiYgKHRlc3QgIlhgcHJpbnQgLXIgLS0gJGFzX2VjaG9gIiA9ICJYJGFzX2Vj aG8iKSAyPi9kZXYvbnVsbDsgdGhlbgorICBhc19lY2hvPSdwcmludCAtciAtLScKKyAgYXNfZWNo b19uPSdwcmludCAtcm4gLS0nCitlbGlmICh0ZXN0ICJYYHByaW50ZiAlcyAkYXNfZWNob2AiID0g IlgkYXNfZWNobyIpIDI+L2Rldi9udWxsOyB0aGVuCisgIGFzX2VjaG89J3ByaW50ZiAlc1xuJwor ICBhc19lY2hvX249J3ByaW50ZiAlcycKK2Vsc2UKKyAgaWYgdGVzdCAiWGAoL3Vzci91Y2IvZWNo byAtbiAtbiAkYXNfZWNobykgMj4vZGV2L251bGxgIiA9ICJYLW4gJGFzX2VjaG8iOyB0aGVuCisg ICAgYXNfZWNob19ib2R5PSdldmFsIC91c3IvdWNiL2VjaG8gLW4gIiQxJGFzX25sIicKKyAgICBh c19lY2hvX249Jy91c3IvdWNiL2VjaG8gLW4nCisgIGVsc2UKKyAgICBhc19lY2hvX2JvZHk9J2V2 YWwgZXhwciAiWCQxIiA6ICJYXFwoLipcXCkiJworICAgIGFzX2VjaG9fbl9ib2R5PSdldmFsCisg ICAgICBhcmc9JDE7CisgICAgICBjYXNlICRhcmcgaW4gIygKKyAgICAgICoiJGFzX25sIiopCisJ ZXhwciAiWCRhcmciIDogIlhcXCguKlxcKSRhc19ubCI7CisJYXJnPWBleHByICJYJGFyZyIgOiAi LiokYXNfbmxcXCguKlxcKSJgOzsKKyAgICAgIGVzYWM7CisgICAgICBleHByICJYJGFyZyIgOiAi WFxcKC4qXFwpIiB8IHRyIC1kICIkYXNfbmwiCisgICAgJworICAgIGV4cG9ydCBhc19lY2hvX25f Ym9keQorICAgIGFzX2VjaG9fbj0nc2ggLWMgJGFzX2VjaG9fbl9ib2R5IGFzX2VjaG8nCisgIGZp CisgIGV4cG9ydCBhc19lY2hvX2JvZHkKKyAgYXNfZWNobz0nc2ggLWMgJGFzX2VjaG9fYm9keSBh c19lY2hvJworZmkKKworIyBUaGUgdXNlciBpcyBhbHdheXMgcmlnaHQuCitpZiB0ZXN0ICIke1BB VEhfU0VQQVJBVE9SK3NldH0iICE9IHNldDsgdGhlbgorICBQQVRIX1NFUEFSQVRPUj06CisgIChQ QVRIPScvYmluOy9iaW4nOyBGUEFUSD0kUEFUSDsgc2ggLWMgOikgPi9kZXYvbnVsbCAyPiYxICYm IHsKKyAgICAoUEFUSD0nL2JpbjovYmluJzsgRlBBVEg9JFBBVEg7IHNoIC1jIDopID4vZGV2L251 bGwgMj4mMSB8fAorICAgICAgUEFUSF9TRVBBUkFUT1I9JzsnCisgIH0KK2ZpCisKKworIyBJRlMK KyMgV2UgbmVlZCBzcGFjZSwgdGFiIGFuZCBuZXcgbGluZSwgaW4gcHJlY2lzZWx5IHRoYXQgb3Jk ZXIuICBRdW90aW5nIGlzCisjIHRoZXJlIHRvIHByZXZlbnQgZWRpdG9ycyBmcm9tIGNvbXBsYWlu aW5nIGFib3V0IHNwYWNlLXRhYi4KKyMgKElmIF9BU19QQVRIX1dBTEsgd2VyZSBjYWxsZWQgd2l0 aCBJRlMgdW5zZXQsIGl0IHdvdWxkIGRpc2FibGUgd29yZAorIyBzcGxpdHRpbmcgYnkgc2V0dGlu ZyBJRlMgdG8gZW1wdHkgdmFsdWUuKQorSUZTPSIgIiIJJGFzX25sIgorCisjIEZpbmQgd2hvIHdl IGFyZS4gIExvb2sgaW4gdGhlIHBhdGggaWYgd2UgY29udGFpbiBubyBkaXJlY3Rvcnkgc2VwYXJh dG9yLgorYXNfbXlzZWxmPQorY2FzZSAkMCBpbiAjKCgKKyAgKltcXC9dKiApIGFzX215c2VsZj0k MCA7OworICAqKSBhc19zYXZlX0lGUz0kSUZTOyBJRlM9JFBBVEhfU0VQQVJBVE9SCitmb3IgYXNf ZGlyIGluICRQQVRICitkbworICBJRlM9JGFzX3NhdmVfSUZTCisgIHRlc3QgLXogIiRhc19kaXIi ICYmIGFzX2Rpcj0uCisgICAgdGVzdCAtciAiJGFzX2Rpci8kMCIgJiYgYXNfbXlzZWxmPSRhc19k aXIvJDAgJiYgYnJlYWsKKyAgZG9uZQorSUZTPSRhc19zYXZlX0lGUworCisgICAgIDs7Citlc2Fj CisjIFdlIGRpZCBub3QgZmluZCBvdXJzZWx2ZXMsIG1vc3QgcHJvYmFibHkgd2Ugd2VyZSBydW4g YXMgYHNoIENPTU1BTkQnCisjIGluIHdoaWNoIGNhc2Ugd2UgYXJlIG5vdCB0byBiZSBmb3VuZCBp biB0aGUgcGF0aC4KK2lmIHRlc3QgIngkYXNfbXlzZWxmIiA9IHg7IHRoZW4KKyAgYXNfbXlzZWxm PSQwCitmaQoraWYgdGVzdCAhIC1mICIkYXNfbXlzZWxmIjsgdGhlbgorICAkYXNfZWNobyAiJGFz X215c2VsZjogZXJyb3I6IGNhbm5vdCBmaW5kIG15c2VsZjsgcmVydW4gd2l0aCBhbiBhYnNvbHV0 ZSBmaWxlIG5hbWUiID4mMgorICBleGl0IDEKK2ZpCisKKyMgVW5zZXQgdmFyaWFibGVzIHRoYXQg d2UgZG8gbm90IG5lZWQgYW5kIHdoaWNoIGNhdXNlIGJ1Z3MgKGUuZy4gaW4KKyMgcHJlLTMuMCBV V0lOIGtzaCkuICBCdXQgZG8gbm90IGNhdXNlIGJ1Z3MgaW4gYmFzaCAyLjAxOyB0aGUgInx8IGV4 aXQgMSIKKyMgc3VwcHJlc3NlcyBhbnkgIlNlZ21lbnRhdGlvbiBmYXVsdCIgbWVzc2FnZSB0aGVy ZS4gICcoKCcgY291bGQKKyMgdHJpZ2dlciBhIGJ1ZyBpbiBwZGtzaCA1LjIuMTQuCitmb3IgYXNf dmFyIGluIEJBU0hfRU5WIEVOViBNQUlMIE1BSUxQQVRICitkbyBldmFsIHRlc3QgeFwkeyRhc192 YXIrc2V0fSA9IHhzZXQgXAorICAmJiAoICh1bnNldCAkYXNfdmFyKSB8fCBleGl0IDEpID4vZGV2 L251bGwgMj4mMSAmJiB1bnNldCAkYXNfdmFyIHx8IDoKK2RvbmUKK1BTMT0nJCAnCitQUzI9Jz4g JworUFM0PScrICcKKworIyBOTFMgbnVpc2FuY2VzLgorTENfQUxMPUMKK2V4cG9ydCBMQ19BTEwK K0xBTkdVQUdFPUMKK2V4cG9ydCBMQU5HVUFHRQorCisjIENEUEFUSC4KKyh1bnNldCBDRFBBVEgp ID4vZGV2L251bGwgMj4mMSAmJiB1bnNldCBDRFBBVEgKKworCisjIGFzX2ZuX2Vycm9yIFNUQVRV UyBFUlJPUiBbTElORU5PIExPR19GRF0KKyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorIyBPdXRwdXQgImBiYXNlbmFtZSAkMGA6IGVycm9yOiBFUlJPUiIgdG8gc3Rk ZXJyLiBJZiBMSU5FTk8gYW5kIExPR19GRCBhcmUKKyMgcHJvdmlkZWQsIGFsc28gb3V0cHV0IHRo ZSBlcnJvciB0byBMT0dfRkQsIHJlZmVyZW5jaW5nIExJTkVOTy4gVGhlbiBleGl0IHRoZQorIyBz Y3JpcHQgd2l0aCBTVEFUVVMsIHVzaW5nIDEgaWYgdGhhdCB3YXMgMC4KK2FzX2ZuX2Vycm9yICgp Cit7CisgIGFzX3N0YXR1cz0kMTsgdGVzdCAkYXNfc3RhdHVzIC1lcSAwICYmIGFzX3N0YXR1cz0x CisgIGlmIHRlc3QgIiQ0IjsgdGhlbgorICAgIGFzX2xpbmVubz0ke2FzX2xpbmVuby0iJDMifSBh c19saW5lbm9fc3RhY2s9YXNfbGluZW5vX3N0YWNrPSRhc19saW5lbm9fc3RhY2sKKyAgICAkYXNf ZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBlcnJvcjogJDIiID4mJDQKKyAgZmkK KyAgJGFzX2VjaG8gIiRhc19tZTogZXJyb3I6ICQyIiA+JjIKKyAgYXNfZm5fZXhpdCAkYXNfc3Rh dHVzCit9ICMgYXNfZm5fZXJyb3IKKworCisjIGFzX2ZuX3NldF9zdGF0dXMgU1RBVFVTCisjIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCisjIFNldCAkPyB0byBTVEFUVVMsIHdpdGhvdXQgZm9ya2lu Zy4KK2FzX2ZuX3NldF9zdGF0dXMgKCkKK3sKKyAgcmV0dXJuICQxCit9ICMgYXNfZm5fc2V0X3N0 YXR1cworCisjIGFzX2ZuX2V4aXQgU1RBVFVTCisjIC0tLS0tLS0tLS0tLS0tLS0tCisjIEV4aXQg dGhlIHNoZWxsIHdpdGggU1RBVFVTLCBldmVuIGluIGEgInRyYXAgMCIgb3IgInNldCAtZSIgY29u dGV4dC4KK2FzX2ZuX2V4aXQgKCkKK3sKKyAgc2V0ICtlCisgIGFzX2ZuX3NldF9zdGF0dXMgJDEK KyAgZXhpdCAkMQorfSAjIGFzX2ZuX2V4aXQKKworIyBhc19mbl91bnNldCBWQVIKKyMgLS0tLS0t LS0tLS0tLS0tCisjIFBvcnRhYmx5IHVuc2V0IFZBUi4KK2FzX2ZuX3Vuc2V0ICgpCit7CisgIHsg ZXZhbCAkMT07IHVuc2V0ICQxO30KK30KK2FzX3Vuc2V0PWFzX2ZuX3Vuc2V0CisjIGFzX2ZuX2Fw cGVuZCBWQVIgVkFMVUUKKyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIyBBcHBlbmQgdGhlIHRl eHQgaW4gVkFMVUUgdG8gdGhlIGVuZCBvZiB0aGUgZGVmaW5pdGlvbiBjb250YWluZWQgaW4gVkFS LiBUYWtlCisjIGFkdmFudGFnZSBvZiBhbnkgc2hlbGwgb3B0aW1pemF0aW9ucyB0aGF0IGFsbG93 IGFtb3J0aXplZCBsaW5lYXIgZ3Jvd3RoIG92ZXIKKyMgcmVwZWF0ZWQgYXBwZW5kcywgaW5zdGVh ZCBvZiB0aGUgdHlwaWNhbCBxdWFkcmF0aWMgZ3Jvd3RoIHByZXNlbnQgaW4gbmFpdmUKKyMgaW1w bGVtZW50YXRpb25zLgoraWYgKGV2YWwgImFzX3Zhcj0xOyBhc192YXIrPTI7IHRlc3QgeFwkYXNf dmFyID0geDEyIikgMj4vZGV2L251bGw7IHRoZW4gOgorICBldmFsICdhc19mbl9hcHBlbmQgKCkK KyAgeworICAgIGV2YWwgJDErPVwkMgorICB9JworZWxzZQorICBhc19mbl9hcHBlbmQgKCkKKyAg eworICAgIGV2YWwgJDE9XCQkMVwkMgorICB9CitmaSAjIGFzX2ZuX2FwcGVuZAorCisjIGFzX2Zu X2FyaXRoIEFSRy4uLgorIyAtLS0tLS0tLS0tLS0tLS0tLS0KKyMgUGVyZm9ybSBhcml0aG1ldGlj IGV2YWx1YXRpb24gb24gdGhlIEFSR3MsIGFuZCBzdG9yZSB0aGUgcmVzdWx0IGluIHRoZQorIyBn bG9iYWwgJGFzX3ZhbC4gVGFrZSBhZHZhbnRhZ2Ugb2Ygc2hlbGxzIHRoYXQgY2FuIGF2b2lkIGZv cmtzLiBUaGUgYXJndW1lbnRzCisjIG11c3QgYmUgcG9ydGFibGUgYWNyb3NzICQoKCkpIGFuZCBl eHByLgoraWYgKGV2YWwgInRlc3QgXCQoKCAxICsgMSApKSA9IDIiKSAyPi9kZXYvbnVsbDsgdGhl biA6CisgIGV2YWwgJ2FzX2ZuX2FyaXRoICgpCisgIHsKKyAgICBhc192YWw9JCgoICQqICkpCisg IH0nCitlbHNlCisgIGFzX2ZuX2FyaXRoICgpCisgIHsKKyAgICBhc192YWw9YGV4cHIgIiRAIiB8 fCB0ZXN0ICQ/IC1lcSAxYAorICB9CitmaSAjIGFzX2ZuX2FyaXRoCisKKworaWYgZXhwciBhIDog J1woYVwpJyA+L2Rldi9udWxsIDI+JjEgJiYKKyAgIHRlc3QgIlhgZXhwciAwMDAwMSA6ICcuKlwo Li4uXCknYCIgPSBYMDAxOyB0aGVuCisgIGFzX2V4cHI9ZXhwcgorZWxzZQorICBhc19leHByPWZh bHNlCitmaQorCitpZiAoYmFzZW5hbWUgLS0gLykgPi9kZXYvbnVsbCAyPiYxICYmIHRlc3QgIlhg YmFzZW5hbWUgLS0gLyAyPiYxYCIgPSAiWC8iOyB0aGVuCisgIGFzX2Jhc2VuYW1lPWJhc2VuYW1l CitlbHNlCisgIGFzX2Jhc2VuYW1lPWZhbHNlCitmaQorCitpZiAoYXNfZGlyPWBkaXJuYW1lIC0t IC9gICYmIHRlc3QgIlgkYXNfZGlyIiA9IFgvKSA+L2Rldi9udWxsIDI+JjE7IHRoZW4KKyAgYXNf ZGlybmFtZT1kaXJuYW1lCitlbHNlCisgIGFzX2Rpcm5hbWU9ZmFsc2UKK2ZpCisKK2FzX21lPWAk YXNfYmFzZW5hbWUgLS0gIiQwIiB8fAorJGFzX2V4cHIgWC8iJDAiIDogJy4qL1woW14vXVteL10q XCkvKiQnIFx8IFwKKwkgWCIkMCIgOiAnWFwoLy9cKSQnIFx8IFwKKwkgWCIkMCIgOiAnWFwoL1wp JyBcfCAuIDI+L2Rldi9udWxsIHx8CiskYXNfZWNobyBYLyIkMCIgfAorICAgIHNlZCAnL14uKlwv XChbXi9dW14vXSpcKVwvKiQveworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgL15YXC9c KFwvXC9cKSQveworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgL15YXC9cKFwvXCkuKi97 CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICBzLy4qLy4vOyBxJ2AKKworIyBBdm9pZCBk ZXBlbmRpbmcgdXBvbiBDaGFyYWN0ZXIgUmFuZ2VzLgorYXNfY3JfbGV0dGVycz0nYWJjZGVmZ2hp amtsbW5vcHFyc3R1dnd4eXonCithc19jcl9MRVRURVJTPSdBQkNERUZHSElKS0xNTk9QUVJTVFVW V1hZWicKK2FzX2NyX0xldHRlcnM9JGFzX2NyX2xldHRlcnMkYXNfY3JfTEVUVEVSUworYXNfY3Jf ZGlnaXRzPScwMTIzNDU2Nzg5JworYXNfY3JfYWxudW09JGFzX2NyX0xldHRlcnMkYXNfY3JfZGln aXRzCisKK0VDSE9fQz0gRUNIT19OPSBFQ0hPX1Q9CitjYXNlIGBlY2hvIC1uIHhgIGluICMoKCgo KAorLW4qKQorICBjYXNlIGBlY2hvICd4eVxjJ2AgaW4KKyAgKmMqKSBFQ0hPX1Q9JwknOzsJIyBF Q0hPX1QgaXMgc2luZ2xlIHRhYiBjaGFyYWN0ZXIuCisgIHh5KSAgRUNIT19DPSdcYyc7OworICAq KSAgIGVjaG8gYGVjaG8ga3NoODggYnVnIG9uIEFJWCA2LjFgID4gL2Rldi9udWxsCisgICAgICAg RUNIT19UPScJJzs7CisgIGVzYWM7OworKikKKyAgRUNIT19OPSctbic7OworZXNhYworCitybSAt ZiBjb25mJCQgY29uZiQkLmV4ZSBjb25mJCQuZmlsZQoraWYgdGVzdCAtZCBjb25mJCQuZGlyOyB0 aGVuCisgIHJtIC1mIGNvbmYkJC5kaXIvY29uZiQkLmZpbGUKK2Vsc2UKKyAgcm0gLWYgY29uZiQk LmRpcgorICBta2RpciBjb25mJCQuZGlyIDI+L2Rldi9udWxsCitmaQoraWYgKGVjaG8gPmNvbmYk JC5maWxlKSAyPi9kZXYvbnVsbDsgdGhlbgorICBpZiBsbiAtcyBjb25mJCQuZmlsZSBjb25mJCQg Mj4vZGV2L251bGw7IHRoZW4KKyAgICBhc19sbl9zPSdsbiAtcycKKyAgICAjIC4uLiBidXQgdGhl cmUgYXJlIHR3byBnb3RjaGFzOgorICAgICMgMSkgT24gTVNZUywgYm90aCBgbG4gLXMgZmlsZSBk aXInIGFuZCBgbG4gZmlsZSBkaXInIGZhaWwuCisgICAgIyAyKSBESkdQUCA8IDIuMDQgaGFzIG5v IHN5bWxpbmtzOyBgbG4gLXMnIGNyZWF0ZXMgYSB3cmFwcGVyIGV4ZWN1dGFibGUuCisgICAgIyBJ biBib3RoIGNhc2VzLCB3ZSBoYXZlIHRvIGRlZmF1bHQgdG8gYGNwIC1wUicuCisgICAgbG4gLXMg Y29uZiQkLmZpbGUgY29uZiQkLmRpciAyPi9kZXYvbnVsbCAmJiB0ZXN0ICEgLWYgY29uZiQkLmV4 ZSB8fAorICAgICAgYXNfbG5fcz0nY3AgLXBSJworICBlbGlmIGxuIGNvbmYkJC5maWxlIGNvbmYk JCAyPi9kZXYvbnVsbDsgdGhlbgorICAgIGFzX2xuX3M9bG4KKyAgZWxzZQorICAgIGFzX2xuX3M9 J2NwIC1wUicKKyAgZmkKK2Vsc2UKKyAgYXNfbG5fcz0nY3AgLXBSJworZmkKK3JtIC1mIGNvbmYk JCBjb25mJCQuZXhlIGNvbmYkJC5kaXIvY29uZiQkLmZpbGUgY29uZiQkLmZpbGUKK3JtZGlyIGNv bmYkJC5kaXIgMj4vZGV2L251bGwKKworCisjIGFzX2ZuX21rZGlyX3AKKyMgLS0tLS0tLS0tLS0t LQorIyBDcmVhdGUgIiRhc19kaXIiIGFzIGEgZGlyZWN0b3J5LCBpbmNsdWRpbmcgcGFyZW50cyBp ZiBuZWNlc3NhcnkuCithc19mbl9ta2Rpcl9wICgpCit7CisKKyAgY2FzZSAkYXNfZGlyIGluICMo CisgIC0qKSBhc19kaXI9Li8kYXNfZGlyOzsKKyAgZXNhYworICB0ZXN0IC1kICIkYXNfZGlyIiB8 fCBldmFsICRhc19ta2Rpcl9wIHx8IHsKKyAgICBhc19kaXJzPQorICAgIHdoaWxlIDo7IGRvCisg ICAgICBjYXNlICRhc19kaXIgaW4gIygKKyAgICAgICpcJyopIGFzX3FkaXI9YCRhc19lY2hvICIk YXNfZGlyIiB8IHNlZCAicy8nLydcXFxcXFxcXCcnL2ciYDs7ICMnKAorICAgICAgKikgYXNfcWRp cj0kYXNfZGlyOzsKKyAgICAgIGVzYWMKKyAgICAgIGFzX2RpcnM9IickYXNfcWRpcicgJGFzX2Rp cnMiCisgICAgICBhc19kaXI9YCRhc19kaXJuYW1lIC0tICIkYXNfZGlyIiB8fAorJGFzX2V4cHIg WCIkYXNfZGlyIiA6ICdYXCguKlteL11cKS8vKlteL11bXi9dKi8qJCcgXHwgXAorCSBYIiRhc19k aXIiIDogJ1hcKC8vXClbXi9dJyBcfCBcCisJIFgiJGFzX2RpciIgOiAnWFwoLy9cKSQnIFx8IFwK KwkgWCIkYXNfZGlyIiA6ICdYXCgvXCknIFx8IC4gMj4vZGV2L251bGwgfHwKKyRhc19lY2hvIFgi JGFzX2RpciIgfAorICAgIHNlZCAnL15YXCguKlteL11cKVwvXC8qW14vXVteL10qXC8qJC97CisJ ICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICAvXlhcKFwvXC9cKVteL10uKi97CisJICAgIHMv L1wxLworCSAgICBxCisJICB9CisJICAvXlhcKFwvXC9cKSQveworCSAgICBzLy9cMS8KKwkgICAg cQorCSAgfQorCSAgL15YXChcL1wpLioveworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAg cy8uKi8uLzsgcSdgCisgICAgICB0ZXN0IC1kICIkYXNfZGlyIiAmJiBicmVhaworICAgIGRvbmUK KyAgICB0ZXN0IC16ICIkYXNfZGlycyIgfHwgZXZhbCAibWtkaXIgJGFzX2RpcnMiCisgIH0gfHwg dGVzdCAtZCAiJGFzX2RpciIgfHwgYXNfZm5fZXJyb3IgJD8gImNhbm5vdCBjcmVhdGUgZGlyZWN0 b3J5ICRhc19kaXIiCisKKworfSAjIGFzX2ZuX21rZGlyX3AKK2lmIG1rZGlyIC1wIC4gMj4vZGV2 L251bGw7IHRoZW4KKyAgYXNfbWtkaXJfcD0nbWtkaXIgLXAgIiRhc19kaXIiJworZWxzZQorICB0 ZXN0IC1kIC4vLXAgJiYgcm1kaXIgLi8tcAorICBhc19ta2Rpcl9wPWZhbHNlCitmaQorCisKKyMg YXNfZm5fZXhlY3V0YWJsZV9wIEZJTEUKKyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyMgVGVz dCBpZiBGSUxFIGlzIGFuIGV4ZWN1dGFibGUgcmVndWxhciBmaWxlLgorYXNfZm5fZXhlY3V0YWJs ZV9wICgpCit7CisgIHRlc3QgLWYgIiQxIiAmJiB0ZXN0IC14ICIkMSIKK30gIyBhc19mbl9leGVj dXRhYmxlX3AKK2FzX3Rlc3RfeD0ndGVzdCAteCcKK2FzX2V4ZWN1dGFibGVfcD1hc19mbl9leGVj dXRhYmxlX3AKKworIyBTZWQgZXhwcmVzc2lvbiB0byBtYXAgYSBzdHJpbmcgb250byBhIHZhbGlk IENQUCBuYW1lLgorYXNfdHJfY3BwPSJldmFsIHNlZCAneSUqJGFzX2NyX2xldHRlcnMlUCRhc19j cl9MRVRURVJTJTtzJVteXyRhc19jcl9hbG51bV0lXyVnJyIKKworIyBTZWQgZXhwcmVzc2lvbiB0 byBtYXAgYSBzdHJpbmcgb250byBhIHZhbGlkIHZhcmlhYmxlIG5hbWUuCithc190cl9zaD0iZXZh bCBzZWQgJ3klKislcHAlO3MlW15fJGFzX2NyX2FsbnVtXSVfJWcnIgorCisKK2V4ZWMgNj4mMQor IyMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gIyMKKyMjIE1haW4gYm9keSBv ZiAkQ09ORklHX1NUQVRVUyBzY3JpcHQuICMjCisjIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSAjIworX0FTRU9GCit0ZXN0ICRhc193cml0ZV9mYWlsID0gMCAmJiBjaG1vZCAr eCAkQ09ORklHX1NUQVRVUyB8fCBhY193cml0ZV9mYWlsPTEKKworY2F0ID4+JENPTkZJR19TVEFU VVMgPDxcX0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQorIyBTYXZlIHRoZSBsb2cgbWVzc2FnZSwg dG8ga2VlcCAkMCBhbmQgc28gb24gbWVhbmluZ2Z1bCwgYW5kIHRvCisjIHJlcG9ydCBhY3R1YWwg aW5wdXQgdmFsdWVzIG9mIENPTkZJR19GSUxFUyBldGMuIGluc3RlYWQgb2YgdGhlaXIKKyMgdmFs dWVzIGFmdGVyIG9wdGlvbnMgaGFuZGxpbmcuCithY19sb2c9IgorVGhpcyBmaWxlIHdhcyBleHRl bmRlZCBieSBYZW4gSHlwZXJ2aXNvciBTdHViIERvbWFpbnMgJGFzX21lIDQuMywgd2hpY2ggd2Fz CitnZW5lcmF0ZWQgYnkgR05VIEF1dG9jb25mIDIuNjkuICBJbnZvY2F0aW9uIGNvbW1hbmQgbGlu ZSB3YXMKKworICBDT05GSUdfRklMRVMgICAgPSAkQ09ORklHX0ZJTEVTCisgIENPTkZJR19IRUFE RVJTICA9ICRDT05GSUdfSEVBREVSUworICBDT05GSUdfTElOS1MgICAgPSAkQ09ORklHX0xJTktT CisgIENPTkZJR19DT01NQU5EUyA9ICRDT05GSUdfQ09NTUFORFMKKyAgJCAkMCAkQAorCitvbiBg KGhvc3RuYW1lIHx8IHVuYW1lIC1uKSAyPi9kZXYvbnVsbCB8IHNlZCAxcWAKKyIKKworX0FDRU9G CisKK2Nhc2UgJGFjX2NvbmZpZ19maWxlcyBpbiAqIgorIiopIHNldCB4ICRhY19jb25maWdfZmls ZXM7IHNoaWZ0OyBhY19jb25maWdfZmlsZXM9JCo7OworZXNhYworCisKKworY2F0ID4+JENPTkZJ R19TVEFUVVMgPDxfQUNFT0YgfHwgYWNfd3JpdGVfZmFpbD0xCisjIEZpbGVzIHRoYXQgY29uZmln LnN0YXR1cyB3YXMgbWFkZSBmb3IuCitjb25maWdfZmlsZXM9IiRhY19jb25maWdfZmlsZXMiCisK K19BQ0VPRgorCitjYXQgPj4kQ09ORklHX1NUQVRVUyA8PFxfQUNFT0YgfHwgYWNfd3JpdGVfZmFp bD0xCithY19jc191c2FnZT0iXAorXGAkYXNfbWUnIGluc3RhbnRpYXRlcyBmaWxlcyBhbmQgb3Ro ZXIgY29uZmlndXJhdGlvbiBhY3Rpb25zCitmcm9tIHRlbXBsYXRlcyBhY2NvcmRpbmcgdG8gdGhl IGN1cnJlbnQgY29uZmlndXJhdGlvbi4gIFVubGVzcyB0aGUgZmlsZXMKK2FuZCBhY3Rpb25zIGFy ZSBzcGVjaWZpZWQgYXMgVEFHcywgYWxsIGFyZSBpbnN0YW50aWF0ZWQgYnkgZGVmYXVsdC4KKwor VXNhZ2U6ICQwIFtPUFRJT05dLi4uIFtUQUddLi4uCisKKyAgLWgsIC0taGVscCAgICAgICBwcmlu dCB0aGlzIGhlbHAsIHRoZW4gZXhpdAorICAtViwgLS12ZXJzaW9uICAgIHByaW50IHZlcnNpb24g bnVtYmVyIGFuZCBjb25maWd1cmF0aW9uIHNldHRpbmdzLCB0aGVuIGV4aXQKKyAgICAgIC0tY29u ZmlnICAgICBwcmludCBjb25maWd1cmF0aW9uLCB0aGVuIGV4aXQKKyAgLXEsIC0tcXVpZXQsIC0t c2lsZW50CisgICAgICAgICAgICAgICAgICAgZG8gbm90IHByaW50IHByb2dyZXNzIG1lc3NhZ2Vz CisgIC1kLCAtLWRlYnVnICAgICAgZG9uJ3QgcmVtb3ZlIHRlbXBvcmFyeSBmaWxlcworICAgICAg LS1yZWNoZWNrICAgIHVwZGF0ZSAkYXNfbWUgYnkgcmVjb25maWd1cmluZyBpbiB0aGUgc2FtZSBj b25kaXRpb25zCisgICAgICAtLWZpbGU9RklMRVs6VEVNUExBVEVdCisgICAgICAgICAgICAgICAg ICAgaW5zdGFudGlhdGUgdGhlIGNvbmZpZ3VyYXRpb24gZmlsZSBGSUxFCisKK0NvbmZpZ3VyYXRp b24gZmlsZXM6CiskY29uZmlnX2ZpbGVzCisKK1JlcG9ydCBidWdzIHRvIDx4ZW4tZGV2ZWxAbGlz dHMueGVuLm9yZz4uCitYZW4gSHlwZXJ2aXNvciBTdHViIERvbWFpbnMgaG9tZSBwYWdlOiA8aHR0 cDovL3d3dy54ZW4ub3JnLz4uIgorCitfQUNFT0YKK2NhdCA+PiRDT05GSUdfU1RBVFVTIDw8X0FD RU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQorYWNfY3NfY29uZmlnPSJgJGFzX2VjaG8gIiRhY19jb25m aWd1cmVfYXJncyIgfCBzZWQgJ3MvXiAvLzsgcy9bXFwiIlxgXCRdL1xcXFwmL2cnYCIKK2FjX2Nz X3ZlcnNpb249IlxcCitYZW4gSHlwZXJ2aXNvciBTdHViIERvbWFpbnMgY29uZmlnLnN0YXR1cyA0 LjMKK2NvbmZpZ3VyZWQgYnkgJDAsIGdlbmVyYXRlZCBieSBHTlUgQXV0b2NvbmYgMi42OSwKKyAg d2l0aCBvcHRpb25zIFxcIlwkYWNfY3NfY29uZmlnXFwiCisKK0NvcHlyaWdodCAoQykgMjAxMiBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KK1RoaXMgY29uZmlnLnN0YXR1cyBzY3JpcHQg aXMgZnJlZSBzb2Z0d2FyZTsgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorZ2l2ZXMgdW5s aW1pdGVkIHBlcm1pc3Npb24gdG8gY29weSwgZGlzdHJpYnV0ZSBhbmQgbW9kaWZ5IGl0LiIKKwor YWNfcHdkPSckYWNfcHdkJworc3JjZGlyPSckc3JjZGlyJworSU5TVEFMTD0nJElOU1RBTEwnCit0 ZXN0IC1uICJcJEFXSyIgfHwgQVdLPWF3aworX0FDRU9GCisKK2NhdCA+PiRDT05GSUdfU1RBVFVT IDw8XF9BQ0VPRiB8fCBhY193cml0ZV9mYWlsPTEKKyMgVGhlIGRlZmF1bHQgbGlzdHMgYXBwbHkg aWYgdGhlIHVzZXIgZG9lcyBub3Qgc3BlY2lmeSBhbnkgZmlsZS4KK2FjX25lZWRfZGVmYXVsdHM9 Ogord2hpbGUgdGVzdCAkIyAhPSAwCitkbworICBjYXNlICQxIGluCisgIC0tKj0/KikKKyAgICBh Y19vcHRpb249YGV4cHIgIlgkMSIgOiAnWFwoW149XSpcKT0nYAorICAgIGFjX29wdGFyZz1gZXhw ciAiWCQxIiA6ICdYW149XSo9XCguKlwpJ2AKKyAgICBhY19zaGlmdD06CisgICAgOzsKKyAgLS0q PSkKKyAgICBhY19vcHRpb249YGV4cHIgIlgkMSIgOiAnWFwoW149XSpcKT0nYAorICAgIGFjX29w dGFyZz0KKyAgICBhY19zaGlmdD06CisgICAgOzsKKyAgKikKKyAgICBhY19vcHRpb249JDEKKyAg ICBhY19vcHRhcmc9JDIKKyAgICBhY19zaGlmdD1zaGlmdAorICAgIDs7CisgIGVzYWMKKworICBj YXNlICRhY19vcHRpb24gaW4KKyAgIyBIYW5kbGluZyBvZiB0aGUgb3B0aW9ucy4KKyAgLXJlY2hl Y2sgfCAtLXJlY2hlY2sgfCAtLXJlY2hlYyB8IC0tcmVjaGUgfCAtLXJlY2ggfCAtLXJlYyB8IC0t cmUgfCAtLXIpCisgICAgYWNfY3NfcmVjaGVjaz06IDs7CisgIC0tdmVyc2lvbiB8IC0tdmVyc2lv IHwgLS12ZXJzaSB8IC0tdmVycyB8IC0tdmVyIHwgLS12ZSB8IC0tdiB8IC1WICkKKyAgICAkYXNf ZWNobyAiJGFjX2NzX3ZlcnNpb24iOyBleGl0IDs7CisgIC0tY29uZmlnIHwgLS1jb25maSB8IC0t Y29uZiB8IC0tY29uIHwgLS1jbyB8IC0tYyApCisgICAgJGFzX2VjaG8gIiRhY19jc19jb25maWci OyBleGl0IDs7CisgIC0tZGVidWcgfCAtLWRlYnUgfCAtLWRlYiB8IC0tZGUgfCAtLWQgfCAtZCAp CisgICAgZGVidWc9OiA7OworICAtLWZpbGUgfCAtLWZpbCB8IC0tZmkgfCAtLWYgKQorICAgICRh Y19zaGlmdAorICAgIGNhc2UgJGFjX29wdGFyZyBpbgorICAgICpcJyopIGFjX29wdGFyZz1gJGFz X2VjaG8gIiRhY19vcHRhcmciIHwgc2VkICJzLycvJ1xcXFxcXFxcJycvZyJgIDs7CisgICAgJycp IGFzX2ZuX2Vycm9yICQ/ICJtaXNzaW5nIGZpbGUgYXJndW1lbnQiIDs7CisgICAgZXNhYworICAg IGFzX2ZuX2FwcGVuZCBDT05GSUdfRklMRVMgIiAnJGFjX29wdGFyZyciCisgICAgYWNfbmVlZF9k ZWZhdWx0cz1mYWxzZTs7CisgIC0taGUgfCAtLWggfCAgLS1oZWxwIHwgLS1oZWwgfCAtaCApCisg ICAgJGFzX2VjaG8gIiRhY19jc191c2FnZSI7IGV4aXQgOzsKKyAgLXEgfCAtcXVpZXQgfCAtLXF1 aWV0IHwgLS1xdWllIHwgLS1xdWkgfCAtLXF1IHwgLS1xIFwKKyAgfCAtc2lsZW50IHwgLS1zaWxl bnQgfCAtLXNpbGVuIHwgLS1zaWxlIHwgLS1zaWwgfCAtLXNpIHwgLS1zKQorICAgIGFjX2NzX3Np bGVudD06IDs7CisKKyAgIyBUaGlzIGlzIGFuIGVycm9yLgorICAtKikgYXNfZm5fZXJyb3IgJD8g InVucmVjb2duaXplZCBvcHRpb246IFxgJDEnCitUcnkgXGAkMCAtLWhlbHAnIGZvciBtb3JlIGlu Zm9ybWF0aW9uLiIgOzsKKworICAqKSBhc19mbl9hcHBlbmQgYWNfY29uZmlnX3RhcmdldHMgIiAk MSIKKyAgICAgYWNfbmVlZF9kZWZhdWx0cz1mYWxzZSA7OworCisgIGVzYWMKKyAgc2hpZnQKK2Rv bmUKKworYWNfY29uZmlndXJlX2V4dHJhX2FyZ3M9CisKK2lmICRhY19jc19zaWxlbnQ7IHRoZW4K KyAgZXhlYyA2Pi9kZXYvbnVsbAorICBhY19jb25maWd1cmVfZXh0cmFfYXJncz0iJGFjX2NvbmZp Z3VyZV9leHRyYV9hcmdzIC0tc2lsZW50IgorZmkKKworX0FDRU9GCitjYXQgPj4kQ09ORklHX1NU QVRVUyA8PF9BQ0VPRiB8fCBhY193cml0ZV9mYWlsPTEKK2lmIFwkYWNfY3NfcmVjaGVjazsgdGhl bgorICBzZXQgWCAkU0hFTEwgJyQwJyAkYWNfY29uZmlndXJlX2FyZ3MgXCRhY19jb25maWd1cmVf ZXh0cmFfYXJncyAtLW5vLWNyZWF0ZSAtLW5vLXJlY3Vyc2lvbgorICBzaGlmdAorICBcJGFzX2Vj aG8gInJ1bm5pbmcgQ09ORklHX1NIRUxMPSRTSEVMTCBcJCoiID4mNgorICBDT05GSUdfU0hFTEw9 JyRTSEVMTCcKKyAgZXhwb3J0IENPTkZJR19TSEVMTAorICBleGVjICJcJEAiCitmaQorCitfQUNF T0YKK2NhdCA+PiRDT05GSUdfU1RBVFVTIDw8XF9BQ0VPRiB8fCBhY193cml0ZV9mYWlsPTEKK2V4 ZWMgNT4+Y29uZmlnLmxvZworeworICBlY2hvCisgIHNlZCAnaDtzLy4vLS9nO3MvXi4uLi8jIyAv O3MvLi4uJC8gIyMvO3A7eDtwO3gnIDw8X0FTQk9YCisjIyBSdW5uaW5nICRhc19tZS4gIyMKK19B U0JPWAorICAkYXNfZWNobyAiJGFjX2xvZyIKK30gPiY1CisKK19BQ0VPRgorY2F0ID4+JENPTkZJ R19TVEFUVVMgPDxfQUNFT0YgfHwgYWNfd3JpdGVfZmFpbD0xCitfQUNFT0YKKworY2F0ID4+JENP TkZJR19TVEFUVVMgPDxcX0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQorCisjIEhhbmRsaW5nIG9m IGFyZ3VtZW50cy4KK2ZvciBhY19jb25maWdfdGFyZ2V0IGluICRhY19jb25maWdfdGFyZ2V0cwor ZG8KKyAgY2FzZSAkYWNfY29uZmlnX3RhcmdldCBpbgorICAgICIuLi9jb25maWcvU3R1YmRvbS5t ayIpIENPTkZJR19GSUxFUz0iJENPTkZJR19GSUxFUyAuLi9jb25maWcvU3R1YmRvbS5tayIgOzsK KworICAqKSBhc19mbl9lcnJvciAkPyAiaW52YWxpZCBhcmd1bWVudDogXGAkYWNfY29uZmlnX3Rh cmdldCciICIkTElORU5PIiA1OzsKKyAgZXNhYworZG9uZQorCisKKyMgSWYgdGhlIHVzZXIgZGlk IG5vdCB1c2UgdGhlIGFyZ3VtZW50cyB0byBzcGVjaWZ5IHRoZSBpdGVtcyB0byBpbnN0YW50aWF0 ZSwKKyMgdGhlbiB0aGUgZW52dmFyIGludGVyZmFjZSBpcyB1c2VkLiAgU2V0IG9ubHkgdGhvc2Ug dGhhdCBhcmUgbm90LgorIyBXZSB1c2UgdGhlIGxvbmcgZm9ybSBmb3IgdGhlIGRlZmF1bHQgYXNz aWdubWVudCBiZWNhdXNlIG9mIGFuIGV4dHJlbWVseQorIyBiaXphcnJlIGJ1ZyBvbiBTdW5PUyA0 LjEuMy4KK2lmICRhY19uZWVkX2RlZmF1bHRzOyB0aGVuCisgIHRlc3QgIiR7Q09ORklHX0ZJTEVT K3NldH0iID0gc2V0IHx8IENPTkZJR19GSUxFUz0kY29uZmlnX2ZpbGVzCitmaQorCisjIEhhdmUg YSB0ZW1wb3JhcnkgZGlyZWN0b3J5IGZvciBjb252ZW5pZW5jZS4gIE1ha2UgaXQgaW4gdGhlIGJ1 aWxkIHRyZWUKKyMgc2ltcGx5IGJlY2F1c2UgdGhlcmUgaXMgbm8gcmVhc29uIGFnYWluc3QgaGF2 aW5nIGl0IGhlcmUsIGFuZCBpbiBhZGRpdGlvbiwKKyMgY3JlYXRpbmcgYW5kIG1vdmluZyBmaWxl cyBmcm9tIC90bXAgY2FuIHNvbWV0aW1lcyBjYXVzZSBwcm9ibGVtcy4KKyMgSG9vayBmb3IgaXRz IHJlbW92YWwgdW5sZXNzIGRlYnVnZ2luZy4KKyMgTm90ZSB0aGF0IHRoZXJlIGlzIGEgc21hbGwg d2luZG93IGluIHdoaWNoIHRoZSBkaXJlY3Rvcnkgd2lsbCBub3QgYmUgY2xlYW5lZDoKKyMgYWZ0 ZXIgaXRzIGNyZWF0aW9uIGJ1dCBiZWZvcmUgaXRzIG5hbWUgaGFzIGJlZW4gYXNzaWduZWQgdG8g YCR0bXAnLgorJGRlYnVnIHx8Cit7CisgIHRtcD0gYWNfdG1wPQorICB0cmFwICdleGl0X3N0YXR1 cz0kPworICA6ICIke2FjX3RtcDo9JHRtcH0iCisgIHsgdGVzdCAhIC1kICIkYWNfdG1wIiB8fCBy bSAtZnIgIiRhY190bXAiOyB9ICYmIGV4aXQgJGV4aXRfc3RhdHVzCisnIDAKKyAgdHJhcCAnYXNf Zm5fZXhpdCAxJyAxIDIgMTMgMTUKK30KKyMgQ3JlYXRlIGEgKHNlY3VyZSkgdG1wIGRpcmVjdG9y eSBmb3IgdG1wIGZpbGVzLgorCit7CisgIHRtcD1gKHVtYXNrIDA3NyAmJiBta3RlbXAgLWQgIi4v Y29uZlhYWFhYWCIpIDI+L2Rldi9udWxsYCAmJgorICB0ZXN0IC1kICIkdG1wIgorfSAgfHwKK3sK KyAgdG1wPS4vY29uZiQkLSRSQU5ET00KKyAgKHVtYXNrIDA3NyAmJiBta2RpciAiJHRtcCIpCit9 IHx8IGFzX2ZuX2Vycm9yICQ/ICJjYW5ub3QgY3JlYXRlIGEgdGVtcG9yYXJ5IGRpcmVjdG9yeSBp biAuIiAiJExJTkVOTyIgNQorYWNfdG1wPSR0bXAKKworIyBTZXQgdXAgdGhlIHNjcmlwdHMgZm9y IENPTkZJR19GSUxFUyBzZWN0aW9uLgorIyBObyBuZWVkIHRvIGdlbmVyYXRlIHRoZW0gaWYgdGhl cmUgYXJlIG5vIENPTkZJR19GSUxFUy4KKyMgVGhpcyBoYXBwZW5zIGZvciBpbnN0YW5jZSB3aXRo IGAuL2NvbmZpZy5zdGF0dXMgY29uZmlnLmgnLgoraWYgdGVzdCAtbiAiJENPTkZJR19GSUxFUyI7 IHRoZW4KKworCithY19jcj1gZWNobyBYIHwgdHIgWCAnXDAxNSdgCisjIE9uIGN5Z3dpbiwgYmFz aCBjYW4gZWF0IFxyIGluc2lkZSBgYCBpZiB0aGUgdXNlciByZXF1ZXN0ZWQgaWduY3IuCisjIEJ1 dCB3ZSBrbm93IG9mIG5vIG90aGVyIHNoZWxsIHdoZXJlIGFjX2NyIHdvdWxkIGJlIGVtcHR5IGF0 IHRoaXMKKyMgcG9pbnQsIHNvIHdlIGNhbiB1c2UgYSBiYXNoaXNtIGFzIGEgZmFsbGJhY2suCitp ZiB0ZXN0ICJ4JGFjX2NyIiA9IHg7IHRoZW4KKyAgZXZhbCBhY19jcj1cJFwnXFxyXCcKK2ZpCith Y19jc19hd2tfY3I9YCRBV0sgJ0JFR0lOIHsgcHJpbnQgImFccmIiIH0nIDwvZGV2L251bGwgMj4v ZGV2L251bGxgCitpZiB0ZXN0ICIkYWNfY3NfYXdrX2NyIiA9ICJhJHthY19jcn1iIjsgdGhlbgor ICBhY19jc19hd2tfY3I9J1xccicKK2Vsc2UKKyAgYWNfY3NfYXdrX2NyPSRhY19jcgorZmkKKwor ZWNobyAnQkVHSU4geycgPiIkYWNfdG1wL3N1YnMxLmF3ayIgJiYKK19BQ0VPRgorCisKK3sKKyAg ZWNobyAiY2F0ID5jb25mJCRzdWJzLmF3ayA8PF9BQ0VPRiIgJiYKKyAgZWNobyAiJGFjX3N1YnN0 X3ZhcnMiIHwgc2VkICdzLy4qLyYhJCYkYWNfZGVsaW0vJyAmJgorICBlY2hvICJfQUNFT0YiCit9 ID5jb25mJCRzdWJzLnNoIHx8CisgIGFzX2ZuX2Vycm9yICQ/ICJjb3VsZCBub3QgbWFrZSAkQ09O RklHX1NUQVRVUyIgIiRMSU5FTk8iIDUKK2FjX2RlbGltX251bT1gZWNobyAiJGFjX3N1YnN0X3Zh cnMiIHwgZ3JlcCAtYyAnXidgCithY19kZWxpbT0nJSFfISMgJworZm9yIGFjX2xhc3RfdHJ5IGlu IGZhbHNlIGZhbHNlIGZhbHNlIGZhbHNlIGZhbHNlIDo7IGRvCisgIC4gLi9jb25mJCRzdWJzLnNo IHx8CisgICAgYXNfZm5fZXJyb3IgJD8gImNvdWxkIG5vdCBtYWtlICRDT05GSUdfU1RBVFVTIiAi JExJTkVOTyIgNQorCisgIGFjX2RlbGltX249YHNlZCAtbiAicy8uKiRhY19kZWxpbVwkL1gvcCIg Y29uZiQkc3Vicy5hd2sgfCBncmVwIC1jIFhgCisgIGlmIHRlc3QgJGFjX2RlbGltX24gPSAkYWNf ZGVsaW1fbnVtOyB0aGVuCisgICAgYnJlYWsKKyAgZWxpZiAkYWNfbGFzdF90cnk7IHRoZW4KKyAg ICBhc19mbl9lcnJvciAkPyAiY291bGQgbm90IG1ha2UgJENPTkZJR19TVEFUVVMiICIkTElORU5P IiA1CisgIGVsc2UKKyAgICBhY19kZWxpbT0iJGFjX2RlbGltISRhY19kZWxpbSBfJGFjX2RlbGlt ISEgIgorICBmaQorZG9uZQorcm0gLWYgY29uZiQkc3Vicy5zaAorCitjYXQgPj4kQ09ORklHX1NU QVRVUyA8PF9BQ0VPRiB8fCBhY193cml0ZV9mYWlsPTEKK2NhdCA+PiJcJGFjX3RtcC9zdWJzMS5h d2siIDw8XFxfQUNBV0sgJiYKK19BQ0VPRgorc2VkIC1uICcKK2gKK3MvXi9TWyIvOyBzLyEuKi8i XT0vCitwCitnCitzL15bXiFdKiEvLworOnJlcGwKK3QgcmVwbAorcy8nIiRhY19kZWxpbSInJC8v Cit0IGRlbGltCis6bmwKK2gKK3MvXCguXHsxNDhcfVwpLi4qL1wxLwordCBtb3JlMQorcy9bIlxc XS9cXCYvZzsgcy9eLyIvOyBzLyQvXFxuIlxcLworcAorbgorYiByZXBsCis6bW9yZTEKK3MvWyJc XF0vXFwmL2c7IHMvXi8iLzsgcy8kLyJcXC8KK3AKK2cKK3MvLlx7MTQ4XH0vLwordCBubAorOmRl bGltCitoCitzL1woLlx7MTQ4XH1cKS4uKi9cMS8KK3QgbW9yZTIKK3MvWyJcXF0vXFwmL2c7IHMv Xi8iLzsgcy8kLyIvCitwCitiCis6bW9yZTIKK3MvWyJcXF0vXFwmL2c7IHMvXi8iLzsgcy8kLyJc XC8KK3AKK2cKK3MvLlx7MTQ4XH0vLwordCBkZWxpbQorJyA8Y29uZiQkc3Vicy5hd2sgfCBzZWQg JworL15bXiIiXS97CisgIE4KKyAgcy9cbi8vCit9CisnID4+JENPTkZJR19TVEFUVVMgfHwgYWNf d3JpdGVfZmFpbD0xCitybSAtZiBjb25mJCRzdWJzLmF3aworY2F0ID4+JENPTkZJR19TVEFUVVMg PDxfQUNFT0YgfHwgYWNfd3JpdGVfZmFpbD0xCitfQUNBV0sKK2NhdCA+PiJcJGFjX3RtcC9zdWJz MS5hd2siIDw8X0FDQVdLICYmCisgIGZvciAoa2V5IGluIFMpIFNfaXNfc2V0W2tleV0gPSAxCisg IEZTID0gIgciCisKK30KK3sKKyAgbGluZSA9ICQgMAorICBuZmllbGRzID0gc3BsaXQobGluZSwg ZmllbGQsICJAIikKKyAgc3Vic3RlZCA9IDAKKyAgbGVuID0gbGVuZ3RoKGZpZWxkWzFdKQorICBm b3IgKGkgPSAyOyBpIDwgbmZpZWxkczsgaSsrKSB7CisgICAga2V5ID0gZmllbGRbaV0KKyAgICBr ZXlsZW4gPSBsZW5ndGgoa2V5KQorICAgIGlmIChTX2lzX3NldFtrZXldKSB7CisgICAgICB2YWx1 ZSA9IFNba2V5XQorICAgICAgbGluZSA9IHN1YnN0cihsaW5lLCAxLCBsZW4pICIiIHZhbHVlICIi IHN1YnN0cihsaW5lLCBsZW4gKyBrZXlsZW4gKyAzKQorICAgICAgbGVuICs9IGxlbmd0aCh2YWx1 ZSkgKyBsZW5ndGgoZmllbGRbKytpXSkKKyAgICAgIHN1YnN0ZWQgPSAxCisgICAgfSBlbHNlCisg ICAgICBsZW4gKz0gMSArIGtleWxlbgorICB9CisKKyAgcHJpbnQgbGluZQorfQorCitfQUNBV0sK K19BQ0VPRgorY2F0ID4+JENPTkZJR19TVEFUVVMgPDxcX0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9 MQoraWYgc2VkICJzLyRhY19jci8vIiA8IC9kZXYvbnVsbCA+IC9kZXYvbnVsbCAyPiYxOyB0aGVu CisgIHNlZCAicy8kYWNfY3JcJC8vOyBzLyRhY19jci8kYWNfY3NfYXdrX2NyL2ciCitlbHNlCisg IGNhdAorZmkgPCAiJGFjX3RtcC9zdWJzMS5hd2siID4gIiRhY190bXAvc3Vicy5hd2siIFwKKyAg fHwgYXNfZm5fZXJyb3IgJD8gImNvdWxkIG5vdCBzZXR1cCBjb25maWcgZmlsZXMgbWFjaGluZXJ5 IiAiJExJTkVOTyIgNQorX0FDRU9GCisKKyMgVlBBVEggbWF5IGNhdXNlIHRyb3VibGUgd2l0aCBz b21lIG1ha2VzLCBzbyB3ZSByZW1vdmUgc29sZSAkKHNyY2RpciksCisjICR7c3JjZGlyfSBhbmQg QHNyY2RpckAgZW50cmllcyBmcm9tIFZQQVRIIGlmIHNyY2RpciBpcyAiLiIsIHN0cmlwIGxlYWRp bmcgYW5kCisjIHRyYWlsaW5nIGNvbG9ucyBhbmQgdGhlbiByZW1vdmUgdGhlIHdob2xlIGxpbmUg aWYgVlBBVEggYmVjb21lcyBlbXB0eQorIyAoYWN0dWFsbHkgd2UgbGVhdmUgYW4gZW1wdHkgbGlu ZSB0byBwcmVzZXJ2ZSBsaW5lIG51bWJlcnMpLgoraWYgdGVzdCAieCRzcmNkaXIiID0geC47IHRo ZW4KKyAgYWNfdnBzdWI9Jy9eWwkgXSpWUEFUSFsJIF0qPVsJIF0qL3sKK2gKK3MvLy8KK3MvXi86 Lworcy9bCSBdKiQvOi8KK3MvOlwkKHNyY2Rpcik6LzovZworcy86XCR7c3JjZGlyfTovOi9nCitz LzpAc3JjZGlyQDovOi9nCitzL146Ki8vCitzLzoqJC8vCit4CitzL1woPVsJIF0qXCkuKi9cMS8K K0cKK3MvXG4vLworcy9eW149XSo9WwkgXSokLy8KK30nCitmaQorCitjYXQgPj4kQ09ORklHX1NU QVRVUyA8PFxfQUNFT0YgfHwgYWNfd3JpdGVfZmFpbD0xCitmaSAjIHRlc3QgLW4gIiRDT05GSUdf RklMRVMiCisKKworZXZhbCBzZXQgWCAiICA6RiAkQ09ORklHX0ZJTEVTICAgICAgIgorc2hpZnQK K2ZvciBhY190YWcKK2RvCisgIGNhc2UgJGFjX3RhZyBpbgorICA6W0ZITENdKSBhY19tb2RlPSRh Y190YWc7IGNvbnRpbnVlOzsKKyAgZXNhYworICBjYXNlICRhY19tb2RlJGFjX3RhZyBpbgorICA6 W0ZITF0qOiopOzsKKyAgOkwqIHwgOkMqOiopIGFzX2ZuX2Vycm9yICQ/ICJpbnZhbGlkIHRhZyBc YCRhY190YWcnIiAiJExJTkVOTyIgNTs7CisgIDpbRkhdLSkgYWNfdGFnPS06LTs7CisgIDpbRkhd KikgYWNfdGFnPSRhY190YWc6JGFjX3RhZy5pbjs7CisgIGVzYWMKKyAgYWNfc2F2ZV9JRlM9JElG UworICBJRlM9OgorICBzZXQgeCAkYWNfdGFnCisgIElGUz0kYWNfc2F2ZV9JRlMKKyAgc2hpZnQK KyAgYWNfZmlsZT0kMQorICBzaGlmdAorCisgIGNhc2UgJGFjX21vZGUgaW4KKyAgOkwpIGFjX3Nv dXJjZT0kMTs7CisgIDpbRkhdKQorICAgIGFjX2ZpbGVfaW5wdXRzPQorICAgIGZvciBhY19mCisg ICAgZG8KKyAgICAgIGNhc2UgJGFjX2YgaW4KKyAgICAgIC0pIGFjX2Y9IiRhY190bXAvc3RkaW4i OzsKKyAgICAgICopICMgTG9vayBmb3IgdGhlIGZpbGUgZmlyc3QgaW4gdGhlIGJ1aWxkIHRyZWUs IHRoZW4gaW4gdGhlIHNvdXJjZSB0cmVlCisJICMgKGlmIHRoZSBwYXRoIGlzIG5vdCBhYnNvbHV0 ZSkuICBUaGUgYWJzb2x1dGUgcGF0aCBjYW5ub3QgYmUgRE9TLXN0eWxlLAorCSAjIGJlY2F1c2Ug JGFjX2YgY2Fubm90IGNvbnRhaW4gYDonLgorCSB0ZXN0IC1mICIkYWNfZiIgfHwKKwkgICBjYXNl ICRhY19mIGluCisJICAgW1xcLyRdKikgZmFsc2U7OworCSAgICopIHRlc3QgLWYgIiRzcmNkaXIv JGFjX2YiICYmIGFjX2Y9IiRzcmNkaXIvJGFjX2YiOzsKKwkgICBlc2FjIHx8CisJICAgYXNfZm5f ZXJyb3IgMSAiY2Fubm90IGZpbmQgaW5wdXQgZmlsZTogXGAkYWNfZiciICIkTElORU5PIiA1OzsK KyAgICAgIGVzYWMKKyAgICAgIGNhc2UgJGFjX2YgaW4gKlwnKikgYWNfZj1gJGFzX2VjaG8gIiRh Y19mIiB8IHNlZCAicy8nLydcXFxcXFxcXCcnL2ciYDs7IGVzYWMKKyAgICAgIGFzX2ZuX2FwcGVu ZCBhY19maWxlX2lucHV0cyAiICckYWNfZiciCisgICAgZG9uZQorCisgICAgIyBMZXQncyBzdGls bCBwcmV0ZW5kIGl0IGlzIGBjb25maWd1cmUnIHdoaWNoIGluc3RhbnRpYXRlcyAoaS5lLiwgZG9u J3QKKyAgICAjIHVzZSAkYXNfbWUpLCBwZW9wbGUgd291bGQgYmUgc3VycHJpc2VkIHRvIHJlYWQ6 CisgICAgIyAgICAvKiBjb25maWcuaC4gIEdlbmVyYXRlZCBieSBjb25maWcuc3RhdHVzLiAgKi8K KyAgICBjb25maWd1cmVfaW5wdXQ9J0dlbmVyYXRlZCBmcm9tICdgCisJICAkYXNfZWNobyAiJCoi IHwgc2VkICdzfF5bXjpdKi98fDtzfDpbXjpdKi98LCB8ZycKKwlgJyBieSBjb25maWd1cmUuJwor ICAgIGlmIHRlc3QgeCIkYWNfZmlsZSIgIT0geC07IHRoZW4KKyAgICAgIGNvbmZpZ3VyZV9pbnB1 dD0iJGFjX2ZpbGUuICAkY29uZmlndXJlX2lucHV0IgorICAgICAgeyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiBjcmVhdGluZyAkYWNfZmlsZSIgPiY1CiskYXNfZWNobyAi JGFzX21lOiBjcmVhdGluZyAkYWNfZmlsZSIgPiY2O30KKyAgICBmaQorICAgICMgTmV1dHJhbGl6 ZSBzcGVjaWFsIGNoYXJhY3RlcnMgaW50ZXJwcmV0ZWQgYnkgc2VkIGluIHJlcGxhY2VtZW50IHN0 cmluZ3MuCisgICAgY2FzZSAkY29uZmlndXJlX2lucHV0IGluICMoCisgICAgKlwmKiB8ICpcfCog fCAqXFwqICkKKyAgICAgICBhY19zZWRfY29uZl9pbnB1dD1gJGFzX2VjaG8gIiRjb25maWd1cmVf aW5wdXQiIHwKKyAgICAgICBzZWQgJ3MvW1xcXFwmfF0vXFxcXCYvZydgOzsgIygKKyAgICAqKSBh Y19zZWRfY29uZl9pbnB1dD0kY29uZmlndXJlX2lucHV0OzsKKyAgICBlc2FjCisKKyAgICBjYXNl ICRhY190YWcgaW4KKyAgICAqOi06KiB8ICo6LSkgY2F0ID4iJGFjX3RtcC9zdGRpbiIgXAorICAg ICAgfHwgYXNfZm5fZXJyb3IgJD8gImNvdWxkIG5vdCBjcmVhdGUgJGFjX2ZpbGUiICIkTElORU5P IiA1IDs7CisgICAgZXNhYworICAgIDs7CisgIGVzYWMKKworICBhY19kaXI9YCRhc19kaXJuYW1l IC0tICIkYWNfZmlsZSIgfHwKKyRhc19leHByIFgiJGFjX2ZpbGUiIDogJ1hcKC4qW14vXVwpLy8q W14vXVteL10qLyokJyBcfCBcCisJIFgiJGFjX2ZpbGUiIDogJ1hcKC8vXClbXi9dJyBcfCBcCisJ IFgiJGFjX2ZpbGUiIDogJ1hcKC8vXCkkJyBcfCBcCisJIFgiJGFjX2ZpbGUiIDogJ1hcKC9cKScg XHwgLiAyPi9kZXYvbnVsbCB8fAorJGFzX2VjaG8gWCIkYWNfZmlsZSIgfAorICAgIHNlZCAnL15Y XCguKlteL11cKVwvXC8qW14vXVteL10qXC8qJC97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9 CisJICAvXlhcKFwvXC9cKVteL10uKi97CisJICAgIHMvL1wxLworCSAgICBxCisJICB9CisJICAv XlhcKFwvXC9cKSQveworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgL15YXChcL1wpLiov eworCSAgICBzLy9cMS8KKwkgICAgcQorCSAgfQorCSAgcy8uKi8uLzsgcSdgCisgIGFzX2Rpcj0i JGFjX2RpciI7IGFzX2ZuX21rZGlyX3AKKyAgYWNfYnVpbGRkaXI9LgorCitjYXNlICIkYWNfZGly IiBpbgorLikgYWNfZGlyX3N1ZmZpeD0gYWNfdG9wX2J1aWxkZGlyX3N1Yj0uIGFjX3RvcF9idWls ZF9wcmVmaXg9IDs7CisqKQorICBhY19kaXJfc3VmZml4PS9gJGFzX2VjaG8gIiRhY19kaXIiIHwg c2VkICdzfF5cLltcXC9dfHwnYAorICAjIEEgIi4uIiBmb3IgZWFjaCBkaXJlY3RvcnkgaW4gJGFj X2Rpcl9zdWZmaXguCisgIGFjX3RvcF9idWlsZGRpcl9zdWI9YCRhc19lY2hvICIkYWNfZGlyX3N1 ZmZpeCIgfCBzZWQgJ3N8L1teXFwvXSp8Ly4ufGc7c3wvfHwnYAorICBjYXNlICRhY190b3BfYnVp bGRkaXJfc3ViIGluCisgICIiKSBhY190b3BfYnVpbGRkaXJfc3ViPS4gYWNfdG9wX2J1aWxkX3By ZWZpeD0gOzsKKyAgKikgIGFjX3RvcF9idWlsZF9wcmVmaXg9JGFjX3RvcF9idWlsZGRpcl9zdWIv IDs7CisgIGVzYWMgOzsKK2VzYWMKK2FjX2Fic190b3BfYnVpbGRkaXI9JGFjX3B3ZAorYWNfYWJz X2J1aWxkZGlyPSRhY19wd2QkYWNfZGlyX3N1ZmZpeAorIyBmb3IgYmFja3dhcmQgY29tcGF0aWJp bGl0eToKK2FjX3RvcF9idWlsZGRpcj0kYWNfdG9wX2J1aWxkX3ByZWZpeAorCitjYXNlICRzcmNk aXIgaW4KKyAgLikgICMgV2UgYXJlIGJ1aWxkaW5nIGluIHBsYWNlLgorICAgIGFjX3NyY2Rpcj0u CisgICAgYWNfdG9wX3NyY2Rpcj0kYWNfdG9wX2J1aWxkZGlyX3N1YgorICAgIGFjX2Fic190b3Bf c3JjZGlyPSRhY19wd2QgOzsKKyAgW1xcL10qIHwgPzpbXFwvXSogKSAgIyBBYnNvbHV0ZSBuYW1l LgorICAgIGFjX3NyY2Rpcj0kc3JjZGlyJGFjX2Rpcl9zdWZmaXg7CisgICAgYWNfdG9wX3NyY2Rp cj0kc3JjZGlyCisgICAgYWNfYWJzX3RvcF9zcmNkaXI9JHNyY2RpciA7OworICAqKSAjIFJlbGF0 aXZlIG5hbWUuCisgICAgYWNfc3JjZGlyPSRhY190b3BfYnVpbGRfcHJlZml4JHNyY2RpciRhY19k aXJfc3VmZml4CisgICAgYWNfdG9wX3NyY2Rpcj0kYWNfdG9wX2J1aWxkX3ByZWZpeCRzcmNkaXIK KyAgICBhY19hYnNfdG9wX3NyY2Rpcj0kYWNfcHdkLyRzcmNkaXIgOzsKK2VzYWMKK2FjX2Fic19z cmNkaXI9JGFjX2Fic190b3Bfc3JjZGlyJGFjX2Rpcl9zdWZmaXgKKworCisgIGNhc2UgJGFjX21v ZGUgaW4KKyAgOkYpCisgICMKKyAgIyBDT05GSUdfRklMRQorICAjCisKKyAgY2FzZSAkSU5TVEFM TCBpbgorICBbXFwvJF0qIHwgPzpbXFwvXSogKSBhY19JTlNUQUxMPSRJTlNUQUxMIDs7CisgICop IGFjX0lOU1RBTEw9JGFjX3RvcF9idWlsZF9wcmVmaXgkSU5TVEFMTCA7OworICBlc2FjCitfQUNF T0YKKworY2F0ID4+JENPTkZJR19TVEFUVVMgPDxcX0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQor IyBJZiB0aGUgdGVtcGxhdGUgZG9lcyBub3Qga25vdyBhYm91dCBkYXRhcm9vdGRpciwgZXhwYW5k IGl0LgorIyBGSVhNRTogVGhpcyBoYWNrIHNob3VsZCBiZSByZW1vdmVkIGEgZmV3IHllYXJzIGFm dGVyIDIuNjAuCithY19kYXRhcm9vdGRpcl9oYWNrPTsgYWNfZGF0YXJvb3RkaXJfc2Vlbj0KK2Fj X3NlZF9kYXRhcm9vdD0nCisvZGF0YXJvb3RkaXIvIHsKKyAgcAorICBxCit9CisvQGRhdGFkaXJA L3AKKy9AZG9jZGlyQC9wCisvQGluZm9kaXJAL3AKKy9AbG9jYWxlZGlyQC9wCisvQG1hbmRpckAv cCcKK2Nhc2UgYGV2YWwgInNlZCAtbiBcIlwkYWNfc2VkX2RhdGFyb290XCIgJGFjX2ZpbGVfaW5w dXRzImAgaW4KKypkYXRhcm9vdGRpciopIGFjX2RhdGFyb290ZGlyX3NlZW49eWVzOzsKKypAZGF0 YWRpckAqfCpAZG9jZGlyQCp8KkBpbmZvZGlyQCp8KkBsb2NhbGVkaXJAKnwqQG1hbmRpckAqKQor ICB7ICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IFdBUk5JTkc6ICRhY19m aWxlX2lucHV0cyBzZWVtcyB0byBpZ25vcmUgdGhlIC0tZGF0YXJvb3RkaXIgc2V0dGluZyIgPiY1 CiskYXNfZWNobyAiJGFzX21lOiBXQVJOSU5HOiAkYWNfZmlsZV9pbnB1dHMgc2VlbXMgdG8gaWdu b3JlIHRoZSAtLWRhdGFyb290ZGlyIHNldHRpbmciID4mMjt9CitfQUNFT0YKK2NhdCA+PiRDT05G SUdfU1RBVFVTIDw8X0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQorICBhY19kYXRhcm9vdGRpcl9o YWNrPScKKyAgcyZAZGF0YWRpckAmJGRhdGFkaXImZworICBzJkBkb2NkaXJAJiRkb2NkaXImZwor ICBzJkBpbmZvZGlyQCYkaW5mb2RpciZnCisgIHMmQGxvY2FsZWRpckAmJGxvY2FsZWRpciZnCisg IHMmQG1hbmRpckAmJG1hbmRpciZnCisgIHMmXFxcJHtkYXRhcm9vdGRpcn0mJGRhdGFyb290ZGly JmcnIDs7Citlc2FjCitfQUNFT0YKKworIyBOZXV0cmFsaXplIFZQQVRIIHdoZW4gYCRzcmNkaXIn ID0gYC4nLgorIyBTaGVsbCBjb2RlIGluIGNvbmZpZ3VyZS5hYyBtaWdodCBzZXQgZXh0cmFzdWIu CisjIEZJWE1FOiBkbyB3ZSByZWFsbHkgd2FudCB0byBtYWludGFpbiB0aGlzIGZlYXR1cmU/Citj YXQgPj4kQ09ORklHX1NUQVRVUyA8PF9BQ0VPRiB8fCBhY193cml0ZV9mYWlsPTEKK2FjX3NlZF9l eHRyYT0iJGFjX3Zwc3ViCiskZXh0cmFzdWIKK19BQ0VPRgorY2F0ID4+JENPTkZJR19TVEFUVVMg PDxcX0FDRU9GIHx8IGFjX3dyaXRlX2ZhaWw9MQorOnQKKy9AW2EtekEtWl9dW2EtekEtWl8wLTld KkAvIWIKK3N8QGNvbmZpZ3VyZV9pbnB1dEB8JGFjX3NlZF9jb25mX2lucHV0fDt0IHQKK3MmQHRv cF9idWlsZGRpckAmJGFjX3RvcF9idWlsZGRpcl9zdWImO3QgdAorcyZAdG9wX2J1aWxkX3ByZWZp eEAmJGFjX3RvcF9idWlsZF9wcmVmaXgmO3QgdAorcyZAc3JjZGlyQCYkYWNfc3JjZGlyJjt0IHQK K3MmQGFic19zcmNkaXJAJiRhY19hYnNfc3JjZGlyJjt0IHQKK3MmQHRvcF9zcmNkaXJAJiRhY190 b3Bfc3JjZGlyJjt0IHQKK3MmQGFic190b3Bfc3JjZGlyQCYkYWNfYWJzX3RvcF9zcmNkaXImO3Qg dAorcyZAYnVpbGRkaXJAJiRhY19idWlsZGRpciY7dCB0CitzJkBhYnNfYnVpbGRkaXJAJiRhY19h YnNfYnVpbGRkaXImO3QgdAorcyZAYWJzX3RvcF9idWlsZGRpckAmJGFjX2Fic190b3BfYnVpbGRk aXImO3QgdAorcyZASU5TVEFMTEAmJGFjX0lOU1RBTEwmO3QgdAorJGFjX2RhdGFyb290ZGlyX2hh Y2sKKyIKK2V2YWwgc2VkIFwiXCRhY19zZWRfZXh0cmFcIiAiJGFjX2ZpbGVfaW5wdXRzIiB8ICRB V0sgLWYgIiRhY190bXAvc3Vicy5hd2siIFwKKyAgPiRhY190bXAvb3V0IHx8IGFzX2ZuX2Vycm9y ICQ/ICJjb3VsZCBub3QgY3JlYXRlICRhY19maWxlIiAiJExJTkVOTyIgNQorCit0ZXN0IC16ICIk YWNfZGF0YXJvb3RkaXJfaGFjayRhY19kYXRhcm9vdGRpcl9zZWVuIiAmJgorICB7IGFjX291dD1g c2VkIC1uICcvXCR7ZGF0YXJvb3RkaXJ9L3AnICIkYWNfdG1wL291dCJgOyB0ZXN0IC1uICIkYWNf b3V0IjsgfSAmJgorICB7IGFjX291dD1gc2VkIC1uICcvXlsJIF0qZGF0YXJvb3RkaXJbCSBdKjoq PS9wJyBcCisgICAgICAiJGFjX3RtcC9vdXQiYDsgdGVzdCAteiAiJGFjX291dCI7IH0gJiYKKyAg eyAkYXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBXQVJOSU5HOiAkYWNfZmls ZSBjb250YWlucyBhIHJlZmVyZW5jZSB0byB0aGUgdmFyaWFibGUgXGBkYXRhcm9vdGRpcicKK3do aWNoIHNlZW1zIHRvIGJlIHVuZGVmaW5lZC4gIFBsZWFzZSBtYWtlIHN1cmUgaXQgaXMgZGVmaW5l ZCIgPiY1CiskYXNfZWNobyAiJGFzX21lOiBXQVJOSU5HOiAkYWNfZmlsZSBjb250YWlucyBhIHJl ZmVyZW5jZSB0byB0aGUgdmFyaWFibGUgXGBkYXRhcm9vdGRpcicKK3doaWNoIHNlZW1zIHRvIGJl IHVuZGVmaW5lZC4gIFBsZWFzZSBtYWtlIHN1cmUgaXQgaXMgZGVmaW5lZCIgPiYyO30KKworICBy bSAtZiAiJGFjX3RtcC9zdGRpbiIKKyAgY2FzZSAkYWNfZmlsZSBpbgorICAtKSBjYXQgIiRhY190 bXAvb3V0IiAmJiBybSAtZiAiJGFjX3RtcC9vdXQiOzsKKyAgKikgcm0gLWYgIiRhY19maWxlIiAm JiBtdiAiJGFjX3RtcC9vdXQiICIkYWNfZmlsZSI7OworICBlc2FjIFwKKyAgfHwgYXNfZm5fZXJy b3IgJD8gImNvdWxkIG5vdCBjcmVhdGUgJGFjX2ZpbGUiICIkTElORU5PIiA1CisgOzsKKworCisK KyAgZXNhYworCitkb25lICMgZm9yIGFjX3RhZworCisKK2FzX2ZuX2V4aXQgMAorX0FDRU9GCith Y19jbGVhbl9maWxlcz0kYWNfY2xlYW5fZmlsZXNfc2F2ZQorCit0ZXN0ICRhY193cml0ZV9mYWls ID0gMCB8fAorICBhc19mbl9lcnJvciAkPyAid3JpdGUgZmFpbHVyZSBjcmVhdGluZyAkQ09ORklH X1NUQVRVUyIgIiRMSU5FTk8iIDUKKworCisjIGNvbmZpZ3VyZSBpcyB3cml0aW5nIHRvIGNvbmZp Zy5sb2csIGFuZCB0aGVuIGNhbGxzIGNvbmZpZy5zdGF0dXMuCisjIGNvbmZpZy5zdGF0dXMgZG9l cyBpdHMgb3duIHJlZGlyZWN0aW9uLCBhcHBlbmRpbmcgdG8gY29uZmlnLmxvZy4KKyMgVW5mb3J0 dW5hdGVseSwgb24gRE9TIHRoaXMgZmFpbHMsIGFzIGNvbmZpZy5sb2cgaXMgc3RpbGwga2VwdCBv cGVuCisjIGJ5IGNvbmZpZ3VyZSwgc28gY29uZmlnLnN0YXR1cyB3b24ndCBiZSBhYmxlIHRvIHdy aXRlIHRvIGl0OyBpdHMKKyMgb3V0cHV0IGlzIHNpbXBseSBkaXNjYXJkZWQuICBTbyB3ZSBleGVj IHRoZSBGRCB0byAvZGV2L251bGwsCisjIGVmZmVjdGl2ZWx5IGNsb3NpbmcgY29uZmlnLmxvZywg c28gaXQgY2FuIGJlIHByb3Blcmx5IChyZSlvcGVuZWQgYW5kCisjIGFwcGVuZGVkIHRvIGJ5IGNv bmZpZy5zdGF0dXMuICBXaGVuIGNvbWluZyBiYWNrIHRvIGNvbmZpZ3VyZSwgd2UKKyMgbmVlZCB0 byBtYWtlIHRoZSBGRCBhdmFpbGFibGUgYWdhaW4uCitpZiB0ZXN0ICIkbm9fY3JlYXRlIiAhPSB5 ZXM7IHRoZW4KKyAgYWNfY3Nfc3VjY2Vzcz06CisgIGFjX2NvbmZpZ19zdGF0dXNfYXJncz0KKyAg dGVzdCAiJHNpbGVudCIgPSB5ZXMgJiYKKyAgICBhY19jb25maWdfc3RhdHVzX2FyZ3M9IiRhY19j b25maWdfc3RhdHVzX2FyZ3MgLS1xdWlldCIKKyAgZXhlYyA1Pi9kZXYvbnVsbAorICAkU0hFTEwg JENPTkZJR19TVEFUVVMgJGFjX2NvbmZpZ19zdGF0dXNfYXJncyB8fCBhY19jc19zdWNjZXNzPWZh bHNlCisgIGV4ZWMgNT4+Y29uZmlnLmxvZworICAjIFVzZSB8fCwgbm90ICYmLCB0byBhdm9pZCBl eGl0aW5nIGZyb20gdGhlIGlmIHdpdGggJD8gPSAxLCB3aGljaAorICAjIHdvdWxkIG1ha2UgY29u ZmlndXJlIGZhaWwgaWYgdGhpcyBpcyB0aGUgbGFzdCBpbnN0cnVjdGlvbi4KKyAgJGFjX2NzX3N1 Y2Nlc3MgfHwgYXNfZm5fZXhpdCAxCitmaQoraWYgdGVzdCAtbiAiJGFjX3VucmVjb2duaXplZF9v cHRzIiAmJiB0ZXN0ICIkZW5hYmxlX29wdGlvbl9jaGVja2luZyIgIT0gbm87IHRoZW4KKyAgeyAk YXNfZWNobyAiJGFzX21lOiR7YXNfbGluZW5vLSRMSU5FTk99OiBXQVJOSU5HOiB1bnJlY29nbml6 ZWQgb3B0aW9uczogJGFjX3VucmVjb2duaXplZF9vcHRzIiA+JjUKKyRhc19lY2hvICIkYXNfbWU6 IFdBUk5JTkc6IHVucmVjb2duaXplZCBvcHRpb25zOiAkYWNfdW5yZWNvZ25pemVkX29wdHMiID4m Mjt9CitmaQpkaWZmIC0tZ2l0IGEvc3R1YmRvbS9jb25maWd1cmUuYWMgYi9zdHViZG9tL2NvbmZp Z3VyZS5hYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40YzQwM2VjCi0tLSAv ZGV2L251bGwKKysrIGIvc3R1YmRvbS9jb25maWd1cmUuYWMKQEAgLTAsMCArMSw1NCBAQAorIyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLSotIEF1dG9jb25m IC0qLQorIyBQcm9jZXNzIHRoaXMgZmlsZSB3aXRoIGF1dG9jb25mIHRvIHByb2R1Y2UgYSBjb25m aWd1cmUgc2NyaXB0LgorCitBQ19QUkVSRVEoWzIuNjddKQorQUNfSU5JVChbWGVuIEh5cGVydmlz b3IgU3R1YiBEb21haW5zXSwgbTRfZXN5c2NtZChbLi4vdmVyc2lvbi5zaCAuLi94ZW4vTWFrZWZp bGVdKSwKKyAgICBbeGVuLWRldmVsQGxpc3RzLnhlbi5vcmddLCBbeGVuXSwgW2h0dHA6Ly93d3cu eGVuLm9yZy9dKQorQUNfQ09ORklHX1NSQ0RJUihbLi4vZXh0cmFzL21pbmktb3Mva2VybmVsLmNd KQorQUNfQ09ORklHX0ZJTEVTKFsuLi9jb25maWcvU3R1YmRvbS5ta10pCitBQ19QUkVGSVhfREVG QVVMVChbL3Vzcl0pCitBQ19DT05GSUdfQVVYX0RJUihbLl0pCisKKyMgTTQgTWFjcm8gaW5jbHVk ZXMKK200X2luY2x1ZGUoWy4uL200L3N0dWJkb20ubTRdKQorbTRfaW5jbHVkZShbLi4vbTQvZmVh dHVyZXMubTRdKQorbTRfaW5jbHVkZShbLi4vbTQvcGF0aF9vcl9mYWlsLm00XSkKKworIyBFbmFi bGUvZGlzYWJsZSBzdHViIGRvbWFpbnMKK0FYX1NUVUJET01fSU5JVAorQVhfU1RVQkRPTV9ERUZB VUxUX0VOQUJMRShbaW9lbXUtc3R1YmRvbV0sIFtpb2VtdV0pCitBWF9TVFVCRE9NX0RFRkFVTFRf RElTQUJMRShbYy1zdHViZG9tXSwgW2NdKQorQVhfU1RVQkRPTV9ERUZBVUxUX0VOQUJMRShbY2Ft bC1zdHViZG9tXSwgW2NhbWxdKQorQVhfU1RVQkRPTV9ERUZBVUxUX0VOQUJMRShbcHYtZ3J1Yl0s IFtncnViXSkKK0FYX1NUVUJET01fREVGQVVMVF9FTkFCTEUoW3hlbnN0b3JlLXN0dWJkb21dLCBb eGVuc3RvcmVdKQorQVhfU1RVQkRPTV9ERUZBVUxUX0VOQUJMRShbdnRwbS1zdHViZG9tXSwgW3Z0 cG1dKQorQVhfU1RVQkRPTV9ERUZBVUxUX0VOQUJMRShbdnRwbW1ncmRvbV0sIFt2dHBtbWdyXSkK KworQVhfQVJHX0RFRkFVTFRfRU5BQkxFKFtkZWJ1Z10sIFtEaXNhYmxlIGRlYnVnIGJ1aWxkIG9m IHN0dWJkb21dKQorQVhfQVJHX0RFRkFVTFRfRU5BQkxFKFtleHRmaWxlc10sIFtVc2UgeGVuIGV4 dGZpbGVzIHJlcG9zaXRvcnkgZm9yIGxpYnJhcmllc10pCisKK0FDX0FSR19WQVIoW0NNQUtFXSwg W1BhdGggdG8gdGhlIGNtYWtlIHByb2dyYW1dKQorQUNfQVJHX1ZBUihbV0dFVF0sIFtQYXRoIHRv IHdnZXQgcHJvZ3JhbV0pCisKKyMgQ2hlY2tzIGZvciBwcm9ncmFtcy4KK0FDX1BST0dfQ0MKK0FD X1BST0dfTUFLRV9TRVQKK0FDX1BST0dfSU5TVEFMTAorQVhfUEFUSF9QUk9HX09SX0ZBSUwoW1dH RVRdLCBbd2dldF0pCisKKyMgQ2hlY2tzIGZvciBwcm9ncmFtcyB0aGF0IGRlcGVuZCBvbiBhbiBh cmd1bWVudAorQVhfUEFUSF9QUk9HX09SX0ZBSUxfQVJHKFt2dHBtXSwgW0NNQUtFXSwgW2NtYWtl XSkKKworIyBTdHViZG9tIGxpYnJhcmllcyB2ZXJzaW9uIGFuZCB1cmwgc2V0dXAKK0FYX1NUVUJE T01fTElCKFtaTElCXSwgW3psaWJdLCBbMS4yLjNdLCBbaHR0cDovL3d3dy56bGliLm5ldF0pCitB WF9TVFVCRE9NX0xJQihbTElCUENJXSwgW2xpYnBjaV0sIFsyLjIuOV0sIFtodHRwOi8vd3d3Lmtl cm5lbC5vcmcvcHViL3NvZnR3YXJlL3V0aWxzL3BjaXV0aWxzXSkKK0FYX1NUVUJET01fTElCKFtO RVdMSUJdLCBbbmV3bGliXSwgWzEuMTYuMF0sIFtmdHA6Ly9zb3VyY2VzLnJlZGhhdC5jb20vcHVi L25ld2xpYl0pCitBWF9TVFVCRE9NX0xJQihbTFdJUF0sIFtsd2lwXSwgWzEuMy4wXSwgW2h0dHA6 Ly9kb3dubG9hZC5zYXZhbm5haC5nbnUub3JnL3JlbGVhc2VzL2x3aXBdKQorQVhfU1RVQkRPTV9M SUIoW0dSVUJdLCBbZ3J1Yl0sIFswLjk3XSwgW2h0dHA6Ly9hbHBoYS5nbnUub3JnL2dudS9ncnVi XSkKK0FYX1NUVUJET01fTElCX05PRVhUKFtPQ0FNTF0sIFtvY2FtbF0sIFszLjExLjBdLCBbaHR0 cDovL2NhbWwuaW5yaWEuZnIvcHViL2Rpc3RyaWIvb2NhbWwtMy4xMV0pCitBWF9TVFVCRE9NX0xJ QihbR01QXSwgW2xpYmdtcF0sIFs0LjMuMl0sIFtmdHA6Ly9mdHAuZ21wbGliLm9yZy9wdWIvZ21w LTQuMy4yXSkKK0FYX1NUVUJET01fTElCKFtQT0xBUlNTTF0sIFtwb2xhcnNzbF0sIFsxLjEuNF0s IFtodHRwOi8vcG9sYXJzc2wub3JnL2NvZGUvcmVsZWFzZXNdKQorQVhfU1RVQkRPTV9MSUIoW1RQ TUVNVV0sIFtiZXJsaW9zIHRwbSBlbXVsYXRvcl0sIFswLjcuNF0sIFtodHRwOi8vZG93bmxvYWQu YmVybGlvcy5kZS90cG0tZW11bGF0b3JdKQorCitBWF9TVFVCRE9NX0ZJTklTSAorQUNfT1VUUFVU KCkKZGlmZiAtLWdpdCBhL3N0dWJkb20vaW5zdGFsbC5zaCBiL3N0dWJkb20vaW5zdGFsbC5zaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZjQ0Zjk5Ci0tLSAvZGV2L251bGwK KysrIGIvc3R1YmRvbS9pbnN0YWxsLnNoCkBAIC0wLDAgKzEgQEAKKy4uL2luc3RhbGwuc2gKXCBO byBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS90b29scy9jb25maWd1cmUgYi90 b29scy9jb25maWd1cmUKaW5kZXggZjlkMTkyNS4uMTE2ODQzNiAxMDA3NTUKLS0tIGEvdG9vbHMv Y29uZmlndXJlCisrKyBiL3Rvb2xzL2NvbmZpZ3VyZQpAQCAtMjMwNyw2ICsyMzA3LDggQEAgY2Fz ZSAkaG9zdF9vcyBpbiAqXCAqKSBob3N0X29zPWBlY2hvICIkaG9zdF9vcyIgfCBzZWQgJ3MvIC8t L2cnYDs7IGVzYWMKIAogCiAKKworCiAjIHBrZy5tNCAtIE1hY3JvcyB0byBsb2NhdGUgYW5kIHV0 aWxpc2UgcGtnLWNvbmZpZy4gICAgICAgICAgICAtKi0gQXV0b2NvbmYgLSotCiAjIHNlcmlhbCAx IChwa2ctY29uZmlnLTAuMjQpCiAjCmRpZmYgLS1naXQgYS90b29scy9jb25maWd1cmUuYWMgYi90 b29scy9jb25maWd1cmUuYWMKaW5kZXggNTg2MzEzZC4uOTcxZTNlOSAxMDA2NDQKLS0tIGEvdG9v bHMvY29uZmlndXJlLmFjCisrKyBiL3Rvb2xzL2NvbmZpZ3VyZS5hYwpAQCAtMjIsMjAgKzIyLDIw IEBAIEFQUEVORF9JTkNMVURFUyBhbmQgQVBQRU5EX0xJQiBpbnN0ZWFkIHdoZW4gcG9zc2libGUu XSkKIEFDX0NBTk9OSUNBTF9IT1NUCiAKICMgTTQgTWFjcm8gaW5jbHVkZXMKLW00X2luY2x1ZGUo W200L3NhdmV2YXIubTRdKQotbTRfaW5jbHVkZShbbTQvZmVhdHVyZXMubTRdKQotbTRfaW5jbHVk ZShbbTQvcGF0aF9vcl9mYWlsLm00XSkKLW00X2luY2x1ZGUoW200L3B5dGhvbl92ZXJzaW9uLm00 XSkKLW00X2luY2x1ZGUoW200L3B5dGhvbl9kZXZlbC5tNF0pCi1tNF9pbmNsdWRlKFttNC9vY2Ft bC5tNF0pCi1tNF9pbmNsdWRlKFttNC9zZXRfY2ZsYWdzX2xkZmxhZ3MubTRdKQotbTRfaW5jbHVk ZShbbTQvdXVpZC5tNF0pCi1tNF9pbmNsdWRlKFttNC9wa2cubTRdKQotbTRfaW5jbHVkZShbbTQv Y3Vyc2VzLm00XSkKLW00X2luY2x1ZGUoW200L3B0aHJlYWQubTRdKQotbTRfaW5jbHVkZShbbTQv cHR5ZnVuY3MubTRdKQotbTRfaW5jbHVkZShbbTQvZXh0ZnMubTRdKQotbTRfaW5jbHVkZShbbTQv ZmV0Y2hlci5tNF0pCittNF9pbmNsdWRlKFsuLi9tNC9zYXZldmFyLm00XSkKK200X2luY2x1ZGUo Wy4uL200L2ZlYXR1cmVzLm00XSkKK200X2luY2x1ZGUoWy4uL200L3BhdGhfb3JfZmFpbC5tNF0p CittNF9pbmNsdWRlKFsuLi9tNC9weXRob25fdmVyc2lvbi5tNF0pCittNF9pbmNsdWRlKFsuLi9t NC9weXRob25fZGV2ZWwubTRdKQorbTRfaW5jbHVkZShbLi4vbTQvb2NhbWwubTRdKQorbTRfaW5j bHVkZShbLi4vbTQvc2V0X2NmbGFnc19sZGZsYWdzLm00XSkKK200X2luY2x1ZGUoWy4uL200L3V1 aWQubTRdKQorbTRfaW5jbHVkZShbLi4vbTQvcGtnLm00XSkKK200X2luY2x1ZGUoWy4uL200L2N1 cnNlcy5tNF0pCittNF9pbmNsdWRlKFsuLi9tNC9wdGhyZWFkLm00XSkKK200X2luY2x1ZGUoWy4u L200L3B0eWZ1bmNzLm00XSkKK200X2luY2x1ZGUoWy4uL200L2V4dGZzLm00XSkKK200X2luY2x1 ZGUoWy4uL200L2ZldGNoZXIubTRdKQogCiAjIEVuYWJsZS9kaXNhYmxlIG9wdGlvbnMKIEFYX0FS R19ERUZBVUxUX0RJU0FCTEUoW2dpdGh0dHBdLCBbRG93bmxvYWQgR0lUIHJlcG9zaXRvcmllcyB2 aWEgSFRUUF0pCmRpZmYgLS1naXQgYS90b29scy9tNC9jdXJzZXMubTQgYi90b29scy9tNC9jdXJz ZXMubTQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGMxZTQ4M2YuLjAwMDAwMDAKLS0t IGEvdG9vbHMvbTQvY3Vyc2VzLm00CisrKyAvZGV2L251bGwKQEAgLTEsMjAgKzAsMCBAQAotQUNf REVGVU4oW0FYX0NIRUNLX0NVUlNFU10sIFsKLUFDX0NIRUNLX0hFQURFUihbY3Vyc2VzLmhdLCBb Ci0gICAgQUNfQ0hFQ0tfTElCKFtjdXJzZXNdLCBbY2xlYXJdLCBbY3Vyc2VzPSJ5Il0sIFtjdXJz ZXM9Im4iXSkKLV0sIFtjdXJzZXM9Im4iXSkKLUFDX0NIRUNLX0hFQURFUihbbmN1cnNlcy5oXSwg WwotICAgIEFDX0NIRUNLX0xJQihbbmN1cnNlc10sIFtjbGVhcl0sIFtuY3Vyc2VzPSJ5Il0sIFtu Y3Vyc2VzPSJuIl0pCi1dLCBbbmN1cnNlcz0ibiJdKQotQVNfSUYoW3Rlc3QgIiRjdXJzZXMiID0g Im4iICYmIHRlc3QgIiRuY3Vyc2VzIiA9ICJuIl0sIFsKLSAgICBBQ19NU0dfRVJST1IoW1VuYWJs ZSB0byBmaW5kIGEgc3VpdGFibGUgY3Vyc2VzIGxpYnJhcnldKQotXSkKLSMgUHJlZmVyIG5jdXJz ZXMgb3ZlciBjdXJzZXMgaWYgYm90aCBhcmUgcHJlc2VudAotQVNfSUYoW3Rlc3QgIiRuY3Vyc2Vz IiA9ICJ5Il0sIFsKLSAgICBDVVJTRVNfTElCUz0iLWxuY3Vyc2VzIgotICAgIEFDX0RFRklORShb SU5DTFVERV9DVVJTRVNfSF0sIFs8bmN1cnNlcy5oPl0sIFtEZWZpbmUgY3Vyc2VzIGhlYWRlciB0 byB1c2VdKQotXSwgWwotICAgIENVUlNFU19MSUJTPSItbGN1cnNlcyIKLSAgICBBQ19ERUZJTkUo W0lOQ0xVREVfQ1VSU0VTX0hdLCBbPGN1cnNlcy5oPl0sIFtEZWZpbmUgY3Vyc2VzIGhlYWRlciB0 byB1c2VdKQotXSkKLUFDX1NVQlNUKENVUlNFU19MSUJTKQotXSkKZGlmZiAtLWdpdCBhL3Rvb2xz L200L2V4dGZzLm00IGIvdG9vbHMvbTQvZXh0ZnMubTQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDczMDlkYTkuLjAwMDAwMDAKLS0tIGEvdG9vbHMvbTQvZXh0ZnMubTQKKysrIC9kZXYv bnVsbApAQCAtMSwyMCArMCwwIEBACi1BQ19ERUZVTihbQVhfQ0hFQ0tfRVhURlNdLCBbCi1BQ19D SEVDS19IRUFERVIoW2V4dDJmcy9leHQyZnMuaF0sIFsKLUFDX0NIRUNLX0xJQihbZXh0MmZzXSwg W2V4dDJmc19vcGVuMl0sIFsKLSAgICBBQ19ERUZJTkUoW0lOQ0xVREVfRVhURlNfSF0sIFs8ZXh0 MmZzL2V4dDJmcy5oPl0sCi0gICAgICAgICAgICAgIFtEZWZpbmUgZXh0ZnMgaGVhZGVyIHRvIHVz ZV0pCi0gICAgRVhURlNfTElCUz0iLWxleHQyZnMiCi1dKQotXSkKLWRubCBUaGlzIGlzIGEgdGVt cG9yYXJ5IGhhY2sgZm9yIENlbnRPUyA1LngsIHdoaWNoIHNwbGl0IHRoZSBleHQ0IHN1cHBvcnQK LWRubCBvZiBleHQyZnMgaW4gYSBkaWZmZXJlbnQgcGFja2FnZS4gT25jZSBDZW50T1MgNS54IGlz IG5vIGxvbmdlciBzdXBwb3J0ZWQKLWRubCB3ZSBjYW4gcmVtb3ZlIHRoaXMuCi1BQ19DSEVDS19I RUFERVIoW2V4dDRmcy9leHQyZnMuaF0sIFsKLUFDX0NIRUNLX0xJQihbZXh0NGZzXSwgW2V4dDJm c19vcGVuMl0sIFsKLSAgICBBQ19ERUZJTkUoW0lOQ0xVREVfRVhURlNfSF0sIFs8ZXh0NGZzL2V4 dDJmcy5oPl0sCi0gICAgICAgICAgICAgIFtEZWZpbmUgZXh0ZnMgaGVhZGVyIHRvIHVzZV0pCi0g ICAgRVhURlNfTElCUz0iLWxleHQ0ZnMiCi1dKQotXSkKLUFDX1NVQlNUKEVYVEZTX0xJQlMpCi1d KQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvZmVhdHVyZXMubTQgYi90b29scy9tNC9mZWF0dXJlcy5t NApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmQ2NzJhYi4uMDAwMDAwMAotLS0gYS90 b29scy9tNC9mZWF0dXJlcy5tNAorKysgL2Rldi9udWxsCkBAIC0xLDIxICswLDAgQEAKLUFDX0RF RlVOKFtBWF9BUkdfREVGQVVMVF9FTkFCTEVdLCBbCi1BQ19BUkdfRU5BQkxFKFskMV0sIEFTX0hF TFBfU1RSSU5HKFstLWRpc2FibGUtJDFdLCBbJDIgKGRlZmF1bHQgaXMgRU5BQkxFRCldKSkKLUFY X1BBUlNFX1ZBTFVFKFskMV0sIFt5XSkKLV0pCi0KLUFDX0RFRlVOKFtBWF9BUkdfREVGQVVMVF9E SVNBQkxFXSwgWwotQUNfQVJHX0VOQUJMRShbJDFdLCBBU19IRUxQX1NUUklORyhbLS1lbmFibGUt JDFdLCBbJDIgKGRlZmF1bHQgaXMgRElTQUJMRUQpXSkpCi1BWF9QQVJTRV9WQUxVRShbJDFdLCBb bl0pCi1dKQotCi1kbmwgVGhpcyBmdW5jdGlvbiBzaG91bGQgbm90IGJlIGNhbGxlZCBvdXRzaWRl IG9mIHRoaXMgZmlsZQotQUNfREVGVU4oW0FYX1BBUlNFX1ZBTFVFXSwgWwotQVNfSUYoW3Rlc3Qg IngkZW5hYmxlXyQxIiA9ICJ4bm8iXSwgWwotICAgIGF4X2N2XyQxPSJuIgotXSwgW3Rlc3QgIngk ZW5hYmxlXyQxIiA9ICJ4eWVzIl0sIFsKLSAgICBheF9jdl8kMT0ieSIKLV0sIFt0ZXN0IC16ICRh eF9jdl8kMV0sIFsKLSAgICBheF9jdl8kMT0iJDIiCi1dKQotJDE9JGF4X2N2XyQxCi1BQ19TVUJT VCgkMSldKQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvZmV0Y2hlci5tNCBiL3Rvb2xzL200L2ZldGNo ZXIubTQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg2ZjMzYjMuLjAwMDAwMDAKLS0t IGEvdG9vbHMvbTQvZmV0Y2hlci5tNAorKysgL2Rldi9udWxsCkBAIC0xLDE0ICswLDAgQEAKLUFD X0RFRlVOKFtBWF9DSEVDS19GRVRDSEVSXSwgWwotQUNfUEFUSF9QUk9HKFtXR0VUXSxbd2dldF0s IFtub10pCi1BU19JRihbdGVzdCB4IiRXR0VUIiAhPSB4Im5vIl0sIFsKLSAgICBGRVRDSEVSPSIk V0dFVCAtYyAtTyIKLV0sIFsKLSAgICBBQ19QQVRIX1BST0coW0ZUUF0sW2Z0cF0sIFtub10pCi0g ICAgQVNfSUYoW3Rlc3QgeCIkRlRQIiAhPSB4Im5vIl0sIFsKLSAgICAgICAgRkVUQ0hFUj0iJEZU UCAtbyIKLSAgICBdLCBbCi0gICAgICAgIEFDX01TR19FUlJPUihbY2Fubm90IGZpbmQgd2dldCBv ciBmdHBdKQotICAgIF0pCi1dKQotQUNfU1VCU1QoRkVUQ0hFUikKLV0pCmRpZmYgLS1naXQgYS90 b29scy9tNC9vY2FtbC5tNCBiL3Rvb2xzL200L29jYW1sLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEw MDY0NAppbmRleCBiMDY3ZWU5Li4wMDAwMDAwCi0tLSBhL3Rvb2xzL200L29jYW1sLm00CisrKyAv ZGV2L251bGwKQEAgLTEsMjQxICswLDAgQEAKLWRubCBhdXRvY29uZiBtYWNyb3MgZm9yIE9DYW1s Ci1kbmwgZnJvbSBodHRwOi8vZm9yZ2Uub2NhbWxjb3JlLm9yZy8KLWRubAotZG5sIENvcHlyaWdo dCDCqSAyMDA5ICAgICAgUmljaGFyZCBXLk0uIEpvbmVzCi1kbmwgQ29weXJpZ2h0IMKpIDIwMDkg ICAgICBTdGVmYW5vIFphY2NoaXJvbGkKLWRubCBDb3B5cmlnaHQgwqkgMjAwMC0yMDA1IE9saXZp ZXIgQW5kcmlldQotZG5sIENvcHlyaWdodCDCqSAyMDAwLTIwMDUgSmVhbi1DaHJpc3RvcGhlIEZp bGxpw6J0cmUKLWRubCBDb3B5cmlnaHQgwqkgMjAwMC0yMDA1IEdlb3JnZXMgTWFyaWFubwotZG5s Ci1kbmwgRm9yIGRvY3VtZW50YXRpb24sIHBsZWFzZSByZWFkIHRoZSBvY2FtbC5tNCBtYW4gcGFn ZS4KLQotQUNfREVGVU4oW0FDX1BST0dfT0NBTUxdLAotW2RubAotICAjIGNoZWNraW5nIGZvciBv Y2FtbGMKLSAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxDXSxbb2NhbWxjXSxbbm9dKQotCi0gIGlmIHRl c3QgIiRPQ0FNTEMiICE9ICJubyI7IHRoZW4KLSAgICAgT0NBTUxWRVJTSU9OPWAkT0NBTUxDIC12 IHwgc2VkIC1uIC1lICdzfC4qdmVyc2lvbiogKlwoLipcKSR8XDF8cCdgCi0gICAgIEFDX01TR19S RVNVTFQoW09DYW1sIHZlcnNpb24gaXMgJE9DQU1MVkVSU0lPTl0pCi0gICAgICMgSWYgT0NBTUxM SUIgaXMgc2V0LCB1c2UgaXQKLSAgICAgaWYgdGVzdCAiJE9DQU1MTElCIiA9ICIiOyB0aGVuCi0g ICAgICAgIE9DQU1MTElCPWAkT0NBTUxDIC13aGVyZSAyPi9kZXYvbnVsbCB8fCAkT0NBTUxDIC12 fHRhaWwgLTF8Y3V0IC1kICcgJyAtZiA0YAotICAgICBlbHNlCi0gICAgICAgIEFDX01TR19SRVNV TFQoW09DQU1MTElCIHByZXZpb3VzbHkgc2V0OyBwcmVzZXJ2aW5nIGl0Ll0pCi0gICAgIGZpCi0g ICAgIEFDX01TR19SRVNVTFQoW09DYW1sIGxpYnJhcnkgcGF0aCBpcyAkT0NBTUxMSUJdKQotCi0g ICAgIEFDX1NVQlNUKFtPQ0FNTFZFUlNJT05dKQotICAgICBBQ19TVUJTVChbT0NBTUxMSUJdKQot Ci0gICAgICMgY2hlY2tpbmcgZm9yIG9jYW1sb3B0Ci0gICAgIEFDX0NIRUNLX1RPT0woW09DQU1M T1BUXSxbb2NhbWxvcHRdLFtub10pCi0gICAgIE9DQU1MQkVTVD1ieXRlCi0gICAgIGlmIHRlc3Qg IiRPQ0FNTE9QVCIgPSAibm8iOyB0aGVuCi0JQUNfTVNHX1dBUk4oW0Nhbm5vdCBmaW5kIG9jYW1s b3B0OyBieXRlY29kZSBjb21waWxhdGlvbiBvbmx5Ll0pCi0gICAgIGVsc2UKLQlUTVBWRVJTSU9O PWAkT0NBTUxPUFQgLXYgfCBzZWQgLW4gLWUgJ3N8Lip2ZXJzaW9uKiAqXCguKlwpJHxcMXxwJyBg Ci0JaWYgdGVzdCAiJFRNUFZFUlNJT04iICE9ICIkT0NBTUxWRVJTSU9OIiA7IHRoZW4KLQkgICAg QUNfTVNHX1JFU1VMVChbdmVyc2lvbnMgZGlmZmVycyBmcm9tIG9jYW1sYzsgb2NhbWxvcHQgZGlz Y2FyZGVkLl0pCi0JICAgIE9DQU1MT1BUPW5vCi0JZWxzZQotCSAgICBPQ0FNTEJFU1Q9b3B0Ci0J ZmkKLSAgICAgZmkKLQotICAgICBBQ19TVUJTVChbT0NBTUxCRVNUXSkKLQotICAgICAjIGNoZWNr aW5nIGZvciBvY2FtbGMub3B0Ci0gICAgIEFDX0NIRUNLX1RPT0woW09DQU1MQ0RPVE9QVF0sW29j YW1sYy5vcHRdLFtub10pCi0gICAgIGlmIHRlc3QgIiRPQ0FNTENET1RPUFQiICE9ICJubyI7IHRo ZW4KLQlUTVBWRVJTSU9OPWAkT0NBTUxDRE9UT1BUIC12IHwgc2VkIC1uIC1lICdzfC4qdmVyc2lv biogKlwoLipcKSR8XDF8cCcgYAotCWlmIHRlc3QgIiRUTVBWRVJTSU9OIiAhPSAiJE9DQU1MVkVS U0lPTiIgOyB0aGVuCi0JICAgIEFDX01TR19SRVNVTFQoW3ZlcnNpb25zIGRpZmZlcnMgZnJvbSBv Y2FtbGM7IG9jYW1sYy5vcHQgZGlzY2FyZGVkLl0pCi0JZWxzZQotCSAgICBPQ0FNTEM9JE9DQU1M Q0RPVE9QVAotCWZpCi0gICAgIGZpCi0KLSAgICAgIyBjaGVja2luZyBmb3Igb2NhbWxvcHQub3B0 Ci0gICAgIGlmIHRlc3QgIiRPQ0FNTE9QVCIgIT0gIm5vIiA7IHRoZW4KLQlBQ19DSEVDS19UT09M KFtPQ0FNTE9QVERPVE9QVF0sW29jYW1sb3B0Lm9wdF0sW25vXSkKLQlpZiB0ZXN0ICIkT0NBTUxP UFRET1RPUFQiICE9ICJubyI7IHRoZW4KLQkgICBUTVBWRVJTSU9OPWAkT0NBTUxPUFRET1RPUFQg LXYgfCBzZWQgLW4gLWUgJ3N8Lip2ZXJzaW9uKiAqXCguKlwpJHxcMXxwJyBgCi0JICAgaWYgdGVz dCAiJFRNUFZFUlNJT04iICE9ICIkT0NBTUxWRVJTSU9OIiA7IHRoZW4KLQkgICAgICBBQ19NU0df UkVTVUxUKFt2ZXJzaW9uIGRpZmZlcnMgZnJvbSBvY2FtbGM7IG9jYW1sb3B0Lm9wdCBkaXNjYXJk ZWQuXSkKLQkgICBlbHNlCi0JICAgICAgT0NBTUxPUFQ9JE9DQU1MT1BURE9UT1BUCi0JICAgZmkK LSAgICAgICAgZmkKLSAgICAgZmkKLQotICAgICBBQ19TVUJTVChbT0NBTUxPUFRdKQotICBmaQot Ci0gIEFDX1NVQlNUKFtPQ0FNTENdKQotCi0gICMgY2hlY2tpbmcgZm9yIG9jYW1sIHRvcGxldmVs Ci0gIEFDX0NIRUNLX1RPT0woW09DQU1MXSxbb2NhbWxdLFtub10pCi0KLSAgIyBjaGVja2luZyBm b3Igb2NhbWxkZXAKLSAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxERVBdLFtvY2FtbGRlcF0sW25vXSkK LQotICAjIGNoZWNraW5nIGZvciBvY2FtbG1rdG9wCi0gIEFDX0NIRUNLX1RPT0woW09DQU1MTUtU T1BdLFtvY2FtbG1rdG9wXSxbbm9dKQotCi0gICMgY2hlY2tpbmcgZm9yIG9jYW1sbWtsaWIKLSAg QUNfQ0hFQ0tfVE9PTChbT0NBTUxNS0xJQl0sW29jYW1sbWtsaWJdLFtub10pCi0KLSAgIyBjaGVj a2luZyBmb3Igb2NhbWxkb2MKLSAgQUNfQ0hFQ0tfVE9PTChbT0NBTUxET0NdLFtvY2FtbGRvY10s W25vXSkKLQotICAjIGNoZWNraW5nIGZvciBvY2FtbGJ1aWxkCi0gIEFDX0NIRUNLX1RPT0woW09D QU1MQlVJTERdLFtvY2FtbGJ1aWxkXSxbbm9dKQotXSkKLQotCi1BQ19ERUZVTihbQUNfUFJPR19P Q0FNTExFWF0sCi1bZG5sCi0gICMgY2hlY2tpbmcgZm9yIG9jYW1sbGV4Ci0gIEFDX0NIRUNLX1RP T0woW09DQU1MTEVYXSxbb2NhbWxsZXhdLFtub10pCi0gIGlmIHRlc3QgIiRPQ0FNTExFWCIgIT0g Im5vIjsgdGhlbgotICAgIEFDX0NIRUNLX1RPT0woW09DQU1MTEVYRE9UT1BUXSxbb2NhbWxsZXgu b3B0XSxbbm9dKQotICAgIGlmIHRlc3QgIiRPQ0FNTExFWERPVE9QVCIgIT0gIm5vIjsgdGhlbgot CU9DQU1MTEVYPSRPQ0FNTExFWERPVE9QVAotICAgIGZpCi0gIGZpCi0gIEFDX1NVQlNUKFtPQ0FN TExFWF0pCi1dKQotCi1BQ19ERUZVTihbQUNfUFJPR19PQ0FNTFlBQ0NdLAotW2RubAotICBBQ19D SEVDS19UT09MKFtPQ0FNTFlBQ0NdLFtvY2FtbHlhY2NdLFtub10pCi0gIEFDX1NVQlNUKFtPQ0FN TFlBQ0NdKQotXSkKLQotCi1BQ19ERUZVTihbQUNfUFJPR19DQU1MUDRdLAotW2RubAotICBBQ19S RVFVSVJFKFtBQ19QUk9HX09DQU1MXSlkbmwKLQotICAjIGNoZWNraW5nIGZvciBjYW1scDQKLSAg QUNfQ0hFQ0tfVE9PTChbQ0FNTFA0XSxbY2FtbHA0XSxbbm9dKQotICBpZiB0ZXN0ICIkQ0FNTFA0 IiAhPSAibm8iOyB0aGVuCi0gICAgIFRNUFZFUlNJT049YCRDQU1MUDQgLXYgMj4mMXwgc2VkIC1u IC1lICdzfC4qdmVyc2lvbiAqXCguKlwpJHxcMXxwJ2AKLSAgICAgaWYgdGVzdCAiJFRNUFZFUlNJ T04iICE9ICIkT0NBTUxWRVJTSU9OIiA7IHRoZW4KLQlBQ19NU0dfUkVTVUxUKFt2ZXJzaW9ucyBk aWZmZXJzIGZyb20gb2NhbWxjXSkKLSAgICAgICAgQ0FNTFA0PW5vCi0gICAgIGZpCi0gIGZpCi0g IEFDX1NVQlNUKFtDQU1MUDRdKQotCi0gICMgY2hlY2tpbmcgZm9yIGNvbXBhbmlvbiB0b29scwot ICBBQ19DSEVDS19UT09MKFtDQU1MUDRCT09UXSxbY2FtbHA0Ym9vdF0sW25vXSkKLSAgQUNfQ0hF Q0tfVE9PTChbQ0FNTFA0T10sW2NhbWxwNG9dLFtub10pCi0gIEFDX0NIRUNLX1RPT0woW0NBTUxQ NE9GXSxbY2FtbHA0b2ZdLFtub10pCi0gIEFDX0NIRUNLX1RPT0woW0NBTUxQNE9PRl0sW2NhbWxw NG9vZl0sW25vXSkKLSAgQUNfQ0hFQ0tfVE9PTChbQ0FNTFA0T1JGXSxbY2FtbHA0b3JmXSxbbm9d KQotICBBQ19DSEVDS19UT09MKFtDQU1MUDRQUk9GXSxbY2FtbHA0cHJvZl0sW25vXSkKLSAgQUNf Q0hFQ0tfVE9PTChbQ0FNTFA0Ul0sW2NhbWxwNHJdLFtub10pCi0gIEFDX0NIRUNLX1RPT0woW0NB TUxQNFJGXSxbY2FtbHA0cmZdLFtub10pCi0gIEFDX1NVQlNUKFtDQU1MUDRCT09UXSkKLSAgQUNf U1VCU1QoW0NBTUxQNE9dKQotICBBQ19TVUJTVChbQ0FNTFA0T0ZdKQotICBBQ19TVUJTVChbQ0FN TFA0T09GXSkKLSAgQUNfU1VCU1QoW0NBTUxQNE9SRl0pCi0gIEFDX1NVQlNUKFtDQU1MUDRQUk9G XSkKLSAgQUNfU1VCU1QoW0NBTUxQNFJdKQotICBBQ19TVUJTVChbQ0FNTFA0UkZdKQotXSkKLQot Ci1BQ19ERUZVTihbQUNfUFJPR19GSU5ETElCXSwKLVtkbmwKLSAgQUNfUkVRVUlSRShbQUNfUFJP R19PQ0FNTF0pZG5sCi0KLSAgIyBjaGVja2luZyBmb3Igb2NhbWxmaW5kCi0gIEFDX0NIRUNLX1RP T0woW09DQU1MRklORF0sW29jYW1sZmluZF0sW25vXSkKLSAgQUNfU1VCU1QoW09DQU1MRklORF0p Ci1dKQotCi0KLWRubCBUaGFua3MgdG8gSmltIE1leWVyaW5nIGZvciB3b3JraW5nIHRoaXMgbmV4 dCBiaXQgb3V0IGZvciB1cy4KLWRubCBYWFggV2Ugc2hvdWxkIGRlZmluZSBBU19UUl9TSCBpZiBp dCdzIG5vdCBkZWZpbmVkIGFscmVhZHkKLWRubCAoZWcuIGZvciBvbGQgYXV0b2NvbmYpLgotQUNf REVGVU4oW0FDX0NIRUNLX09DQU1MX1BLR10sCi1bZG5sCi0gIEFDX1JFUVVJUkUoW0FDX1BST0df RklORExJQl0pZG5sCi0KLSAgQUNfTVNHX0NIRUNLSU5HKFtmb3IgT0NhbWwgZmluZGxpYiBwYWNr YWdlICQxXSkKLQotICB1bnNldCBmb3VuZAotICB1bnNldCBwa2cKLSAgZm91bmQ9bm8KLSAgZm9y IHBrZyBpbiAkMSAkMiA7IGRvCi0gICAgaWYgJE9DQU1MRklORCBxdWVyeSAkcGtnID4vZGV2L251 bGwgMj4vZGV2L251bGw7IHRoZW4KLSAgICAgIEFDX01TR19SRVNVTFQoW2ZvdW5kXSkKLSAgICAg IEFTX1RSX1NIKFtPQ0FNTF9QS0dfJDFdKT0kcGtnCi0gICAgICBmb3VuZD15ZXMKLSAgICAgIGJy ZWFrCi0gICAgZmkKLSAgZG9uZQotICBpZiB0ZXN0ICIkZm91bmQiID0gIm5vIiA7IHRoZW4KLSAg ICBBQ19NU0dfUkVTVUxUKFtub3QgZm91bmRdKQotICAgIEFTX1RSX1NIKFtPQ0FNTF9QS0dfJDFd KT1ubwotICBmaQotCi0gIEFDX1NVQlNUKEFTX1RSX1NIKFtPQ0FNTF9QS0dfJDFdKSkKLV0pCi0K LQotQUNfREVGVU4oW0FDX0NIRUNLX09DQU1MX01PRFVMRV0sCi1bZG5sCi0gIEFDX01TR19DSEVD S0lORyhbZm9yIE9DYW1sIG1vZHVsZSAkMl0pCi0KLSAgY2F0ID4gY29uZnRlc3QubWwgPDxFT0YK LW9wZW4gJDMKLUVPRgotICB1bnNldCBmb3VuZAotICBmb3IgJDEgaW4gJCQxICQ0IDsgZG8KLSAg ICBpZiAkT0NBTUxDIC1jIC1JICIkJDEiIGNvbmZ0ZXN0Lm1sID4mNSAyPiY1IDsgdGhlbgotICAg ICAgZm91bmQ9eWVzCi0gICAgICBicmVhawotICAgIGZpCi0gIGRvbmUKLQotICBpZiB0ZXN0ICIk Zm91bmQiIDsgdGhlbgotICAgIEFDX01TR19SRVNVTFQoWyQkMV0pCi0gIGVsc2UKLSAgICBBQ19N U0dfUkVTVUxUKFtub3QgZm91bmRdKQotICAgICQxPW5vCi0gIGZpCi0gIEFDX1NVQlNUKFskMV0p Ci1dKQotCi0KLWRubCBYWFggQ3Jvc3MtY29tcGlsaW5nCi1BQ19ERUZVTihbQUNfQ0hFQ0tfT0NB TUxfV09SRF9TSVpFXSwKLVtkbmwKLSAgQUNfUkVRVUlSRShbQUNfUFJPR19PQ0FNTF0pZG5sCi0g IEFDX01TR19DSEVDS0lORyhbZm9yIE9DYW1sIGNvbXBpbGVyIHdvcmQgc2l6ZV0pCi0gIGNhdCA+ IGNvbmZ0ZXN0Lm1sIDw8RU9GCi0gIHByaW50X2VuZGxpbmUgKHN0cmluZ19vZl9pbnQgU3lzLndv cmRfc2l6ZSkKLSAgRU9GCi0gIE9DQU1MX1dPUkRfU0laRT1gJE9DQU1MIGNvbmZ0ZXN0Lm1sYAot ICBBQ19NU0dfUkVTVUxUKFskT0NBTUxfV09SRF9TSVpFXSkKLSAgQUNfU1VCU1QoW09DQU1MX1dP UkRfU0laRV0pCi1dKQotCi1BQ19ERUZVTihbQUNfQ0hFQ0tfT0NBTUxfT1NfVFlQRV0sCi1bZG5s Ci0gIEFDX1JFUVVJUkUoW0FDX1BST0dfT0NBTUxdKWRubAotICBBQ19NU0dfQ0hFQ0tJTkcoW09D YW1sIFN5cy5vc190eXBlXSkKLQotICBjYXQgPiBjb25mdGVzdC5tbCA8PEVPRgotICBwcmludF9z dHJpbmcoU3lzLm9zX3R5cGUpOzsKLUVPRgotCi0gIE9DQU1MX09TX1RZUEU9YCRPQ0FNTCBjb25m dGVzdC5tbGAKLSAgQUNfTVNHX1JFU1VMVChbJE9DQU1MX09TX1RZUEVdKQotICBBQ19TVUJTVChb T0NBTUxfT1NfVFlQRV0pCi1dKQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvcGF0aF9vcl9mYWlsLm00 IGIvdG9vbHMvbTQvcGF0aF9vcl9mYWlsLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCBlY2U4Y2Q0Li4wMDAwMDAwCi0tLSBhL3Rvb2xzL200L3BhdGhfb3JfZmFpbC5tNAorKysgL2Rl di9udWxsCkBAIC0xLDYgKzAsMCBAQAotQUNfREVGVU4oW0FYX1BBVEhfUFJPR19PUl9GQUlMXSwK LVtBQ19QQVRIX1BST0coWyQxXSwgWyQyXSwgW25vXSkKLWlmIHRlc3QgeCIkeyQxfSIgPT0geCJu byIgCi10aGVuCi0gICAgQUNfTVNHX0VSUk9SKFtVbmFibGUgdG8gZmluZCAkMiwgcGxlYXNlIGlu c3RhbGwgJDJdKQotZmldKQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvcGtnLm00IGIvdG9vbHMvbTQv cGtnLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5YmIzZTA2Li4wMDAwMDAwCi0t LSBhL3Rvb2xzL200L3BrZy5tNAorKysgL2Rldi9udWxsCkBAIC0xLDE1NyArMCwwIEBACi0jIHBr Zy5tNCAtIE1hY3JvcyB0byBsb2NhdGUgYW5kIHV0aWxpc2UgcGtnLWNvbmZpZy4gICAgICAgICAg ICAtKi0gQXV0b2NvbmYgLSotCi0jIHNlcmlhbCAxIChwa2ctY29uZmlnLTAuMjQpCi0jIAotIyBD b3B5cmlnaHQgwqkgMjAwNCBTY290dCBKYW1lcyBSZW1uYW50IDxzY290dEBuZXRzcGxpdC5jb20+ LgotIwotIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yIG1vZGlmeQotIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotIyB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotIyAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotIwotIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0Ci0jIFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSMgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKLSMgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotIwotIyBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZQotIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUg RnJlZSBTb2Z0d2FyZQotIyBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0 ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgotIwotIyBBcyBhIHNwZWNpYWwgZXhj ZXB0aW9uIHRvIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwgaWYgeW91Ci0jIGRpc3Ry aWJ1dGUgdGhpcyBmaWxlIGFzIHBhcnQgb2YgYSBwcm9ncmFtIHRoYXQgY29udGFpbnMgYQotIyBj b25maWd1cmF0aW9uIHNjcmlwdCBnZW5lcmF0ZWQgYnkgQXV0b2NvbmYsIHlvdSBtYXkgaW5jbHVk ZSBpdCB1bmRlcgotIyB0aGUgc2FtZSBkaXN0cmlidXRpb24gdGVybXMgdGhhdCB5b3UgdXNlIGZv ciB0aGUgcmVzdCBvZiB0aGF0IHByb2dyYW0uCi0KLSMgUEtHX1BST0dfUEtHX0NPTkZJRyhbTUlO LVZFUlNJT05dKQotIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi1BQ19ERUZV TihbUEtHX1BST0dfUEtHX0NPTkZJR10sCi1bbTRfcGF0dGVybl9mb3JiaWQoW15fP1BLR19bQS1a X10rJF0pCi1tNF9wYXR0ZXJuX2FsbG93KFteUEtHX0NPTkZJRyhfUEFUSCk/JF0pCi1BQ19BUkdf VkFSKFtQS0dfQ09ORklHXSwgW3BhdGggdG8gcGtnLWNvbmZpZyB1dGlsaXR5XSkKLUFDX0FSR19W QVIoW1BLR19DT05GSUdfUEFUSF0sIFtkaXJlY3RvcmllcyB0byBhZGQgdG8gcGtnLWNvbmZpZydz IHNlYXJjaCBwYXRoXSkKLUFDX0FSR19WQVIoW1BLR19DT05GSUdfTElCRElSXSwgW3BhdGggb3Zl cnJpZGluZyBwa2ctY29uZmlnJ3MgYnVpbHQtaW4gc2VhcmNoIHBhdGhdKQotCi1pZiB0ZXN0ICJ4 JGFjX2N2X2Vudl9QS0dfQ09ORklHX3NldCIgIT0gInhzZXQiOyB0aGVuCi0JQUNfUEFUSF9UT09M KFtQS0dfQ09ORklHXSwgW3BrZy1jb25maWddKQotZmkKLWlmIHRlc3QgLW4gIiRQS0dfQ09ORklH IjsgdGhlbgotCV9wa2dfbWluX3ZlcnNpb249bTRfZGVmYXVsdChbJDFdLCBbMC45LjBdKQotCUFD X01TR19DSEVDS0lORyhbcGtnLWNvbmZpZyBpcyBhdCBsZWFzdCB2ZXJzaW9uICRfcGtnX21pbl92 ZXJzaW9uXSkKLQlpZiAkUEtHX0NPTkZJRyAtLWF0bGVhc3QtcGtnY29uZmlnLXZlcnNpb24gJF9w a2dfbWluX3ZlcnNpb247IHRoZW4KLQkJQUNfTVNHX1JFU1VMVChbeWVzXSkKLQllbHNlCi0JCUFD X01TR19SRVNVTFQoW25vXSkKLQkJUEtHX0NPTkZJRz0iIgotCWZpCi1maVtdZG5sCi1dKSMgUEtH X1BST0dfUEtHX0NPTkZJRwotCi0jIFBLR19DSEVDS19FWElTVFMoTU9EVUxFUywgW0FDVElPTi1J Ri1GT1VORF0sIFtBQ1RJT04tSUYtTk9ULUZPVU5EXSkKLSMKLSMgQ2hlY2sgdG8gc2VlIHdoZXRo ZXIgYSBwYXJ0aWN1bGFyIHNldCBvZiBtb2R1bGVzIGV4aXN0cy4gIFNpbWlsYXIKLSMgdG8gUEtH X0NIRUNLX01PRFVMRVMoKSwgYnV0IGRvZXMgbm90IHNldCB2YXJpYWJsZXMgb3IgcHJpbnQgZXJy b3JzLgotIwotIyBQbGVhc2UgcmVtZW1iZXIgdGhhdCBtNCBleHBhbmRzIEFDX1JFUVVJUkUoW1BL R19QUk9HX1BLR19DT05GSUddKQotIyBvbmx5IGF0IHRoZSBmaXJzdCBvY2N1cmVuY2UgaW4gY29u ZmlndXJlLmFjLCBzbyBpZiB0aGUgZmlyc3QgcGxhY2UKLSMgaXQncyBjYWxsZWQgbWlnaHQgYmUg c2tpcHBlZCAoc3VjaCBhcyBpZiBpdCBpcyB3aXRoaW4gYW4gImlmIiwgeW91Ci0jIGhhdmUgdG8g Y2FsbCBQS0dfQ0hFQ0tfRVhJU1RTIG1hbnVhbGx5Ci0jIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi1BQ19ERUZVTihbUEtHX0NI RUNLX0VYSVNUU10sCi1bQUNfUkVRVUlSRShbUEtHX1BST0dfUEtHX0NPTkZJR10pZG5sCi1pZiB0 ZXN0IC1uICIkUEtHX0NPTkZJRyIgJiYgXAotICAgIEFDX1JVTl9MT0coWyRQS0dfQ09ORklHIC0t ZXhpc3RzIC0tcHJpbnQtZXJyb3JzICIkMSJdKTsgdGhlbgotICBtNF9kZWZhdWx0KFskMl0sIFs6 XSkKLW00X2lmdmFsbihbJDNdLCBbZWxzZQotICAkM10pZG5sCi1maV0pCi0KLSMgX1BLR19DT05G SUcoW1ZBUklBQkxFXSwgW0NPTU1BTkRdLCBbTU9EVUxFU10pCi0jIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotbTRfZGVmaW5lKFtfUEtHX0NPTkZJR10sCi1b aWYgdGVzdCAtbiAiJCQxIjsgdGhlbgotICAgIHBrZ19jdl9bXSQxPSIkJDEiCi0gZWxpZiB0ZXN0 IC1uICIkUEtHX0NPTkZJRyI7IHRoZW4KLSAgICBQS0dfQ0hFQ0tfRVhJU1RTKFskM10sCi0gICAg ICAgICAgICAgICAgICAgICBbcGtnX2N2X1tdJDE9YCRQS0dfQ09ORklHIC0tW10kMiAiJDMiIDI+ L2Rldi9udWxsYF0sCi0JCSAgICAgW3BrZ19mYWlsZWQ9eWVzXSkKLSBlbHNlCi0gICAgcGtnX2Zh aWxlZD11bnRyaWVkCi1maVtdZG5sCi1dKSMgX1BLR19DT05GSUcKLQotIyBfUEtHX1NIT1JUX0VS Uk9SU19TVVBQT1JURUQKLSMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLUFDX0RFRlVO KFtfUEtHX1NIT1JUX0VSUk9SU19TVVBQT1JURURdLAotW0FDX1JFUVVJUkUoW1BLR19QUk9HX1BL R19DT05GSUddKQotaWYgJFBLR19DT05GSUcgLS1hdGxlYXN0LXBrZ2NvbmZpZy12ZXJzaW9uIDAu MjA7IHRoZW4KLSAgICAgICAgX3BrZ19zaG9ydF9lcnJvcnNfc3VwcG9ydGVkPXllcwotZWxzZQot ICAgICAgICBfcGtnX3Nob3J0X2Vycm9yc19zdXBwb3J0ZWQ9bm8KLWZpW11kbmwKLV0pIyBfUEtH X1NIT1JUX0VSUk9SU19TVVBQT1JURUQKLQotCi0jIFBLR19DSEVDS19NT0RVTEVTKFZBUklBQkxF LVBSRUZJWCwgTU9EVUxFUywgW0FDVElPTi1JRi1GT1VORF0sCi0jIFtBQ1RJT04tSUYtTk9ULUZP VU5EXSkKLSMKLSMKLSMgTm90ZSB0aGF0IGlmIHRoZXJlIGlzIGEgcG9zc2liaWxpdHkgdGhlIGZp cnN0IGNhbGwgdG8KLSMgUEtHX0NIRUNLX01PRFVMRVMgbWlnaHQgbm90IGhhcHBlbiwgeW91IHNo b3VsZCBiZSBzdXJlIHRvIGluY2x1ZGUgYW4KLSMgZXhwbGljaXQgY2FsbCB0byBQS0dfUFJPR19Q S0dfQ09ORklHIGluIHlvdXIgY29uZmlndXJlLmFjCi0jCi0jCi0jIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi1BQ19ERUZVTihb UEtHX0NIRUNLX01PRFVMRVNdLAotW0FDX1JFUVVJUkUoW1BLR19QUk9HX1BLR19DT05GSUddKWRu bAotQUNfQVJHX1ZBUihbJDFdW19DRkxBR1NdLCBbQyBjb21waWxlciBmbGFncyBmb3IgJDEsIG92 ZXJyaWRpbmcgcGtnLWNvbmZpZ10pZG5sCi1BQ19BUkdfVkFSKFskMV1bX0xJQlNdLCBbbGlua2Vy IGZsYWdzIGZvciAkMSwgb3ZlcnJpZGluZyBwa2ctY29uZmlnXSlkbmwKLQotcGtnX2ZhaWxlZD1u bwotQUNfTVNHX0NIRUNLSU5HKFtmb3IgJDFdKQotCi1fUEtHX0NPTkZJRyhbJDFdW19DRkxBR1Nd LCBbY2ZsYWdzXSwgWyQyXSkKLV9QS0dfQ09ORklHKFskMV1bX0xJQlNdLCBbbGlic10sIFskMl0p Ci0KLW00X2RlZmluZShbX1BLR19URVhUXSwgW0FsdGVybmF0aXZlbHksIHlvdSBtYXkgc2V0IHRo ZSBlbnZpcm9ubWVudCB2YXJpYWJsZXMgJDFbXV9DRkxBR1MKLWFuZCAkMVtdX0xJQlMgdG8gYXZv aWQgdGhlIG5lZWQgdG8gY2FsbCBwa2ctY29uZmlnLgotU2VlIHRoZSBwa2ctY29uZmlnIG1hbiBw YWdlIGZvciBtb3JlIGRldGFpbHMuXSkKLQotaWYgdGVzdCAkcGtnX2ZhaWxlZCA9IHllczsgdGhl bgotICAgCUFDX01TR19SRVNVTFQoW25vXSkKLSAgICAgICAgX1BLR19TSE9SVF9FUlJPUlNfU1VQ UE9SVEVECi0gICAgICAgIGlmIHRlc3QgJF9wa2dfc2hvcnRfZXJyb3JzX3N1cHBvcnRlZCA9IHll czsgdGhlbgotCSAgICAgICAgJDFbXV9QS0dfRVJST1JTPWAkUEtHX0NPTkZJRyAtLXNob3J0LWVy cm9ycyAtLXByaW50LWVycm9ycyAiJDIiIDI+JjFgCi0gICAgICAgIGVsc2UgCi0JICAgICAgICAk MVtdX1BLR19FUlJPUlM9YCRQS0dfQ09ORklHIC0tcHJpbnQtZXJyb3JzICIkMiIgMj4mMWAKLSAg ICAgICAgZmkKLQkjIFB1dCB0aGUgbmFzdHkgZXJyb3IgbWVzc2FnZSBpbiBjb25maWcubG9nIHdo ZXJlIGl0IGJlbG9uZ3MKLQllY2hvICIkJDFbXV9QS0dfRVJST1JTIiA+JkFTX01FU1NBR0VfTE9H X0ZECi0KLQltNF9kZWZhdWx0KFskNF0sIFtBQ19NU0dfRVJST1IoCi1bUGFja2FnZSByZXF1aXJl bWVudHMgKCQyKSB3ZXJlIG5vdCBtZXQ6Ci0KLSQkMV9QS0dfRVJST1JTCi0KLUNvbnNpZGVyIGFk anVzdGluZyB0aGUgUEtHX0NPTkZJR19QQVRIIGVudmlyb25tZW50IHZhcmlhYmxlIGlmIHlvdQot aW5zdGFsbGVkIHNvZnR3YXJlIGluIGEgbm9uLXN0YW5kYXJkIHByZWZpeC4KLQotX1BLR19URVhU XSlkbmwKLSAgICAgICAgXSkKLWVsaWYgdGVzdCAkcGtnX2ZhaWxlZCA9IHVudHJpZWQ7IHRoZW4K LSAgICAgCUFDX01TR19SRVNVTFQoW25vXSkKLQltNF9kZWZhdWx0KFskNF0sIFtBQ19NU0dfRkFJ TFVSRSgKLVtUaGUgcGtnLWNvbmZpZyBzY3JpcHQgY291bGQgbm90IGJlIGZvdW5kIG9yIGlzIHRv byBvbGQuICBNYWtlIHN1cmUgaXQKLWlzIGluIHlvdXIgUEFUSCBvciBzZXQgdGhlIFBLR19DT05G SUcgZW52aXJvbm1lbnQgdmFyaWFibGUgdG8gdGhlIGZ1bGwKLXBhdGggdG8gcGtnLWNvbmZpZy4K LQotX1BLR19URVhUCi0KLVRvIGdldCBwa2ctY29uZmlnLCBzZWUgPGh0dHA6Ly9wa2ctY29uZmln LmZyZWVkZXNrdG9wLm9yZy8+Ll0pZG5sCi0gICAgICAgIF0pCi1lbHNlCi0JJDFbXV9DRkxBR1M9 JHBrZ19jdl9bXSQxW11fQ0ZMQUdTCi0JJDFbXV9MSUJTPSRwa2dfY3ZfW10kMVtdX0xJQlMKLSAg ICAgICAgQUNfTVNHX1JFU1VMVChbeWVzXSkKLQkkMwotZmlbXWRubAotXSkjIFBLR19DSEVDS19N T0RVTEVTCmRpZmYgLS1naXQgYS90b29scy9tNC9wdGhyZWFkLm00IGIvdG9vbHMvbTQvcHRocmVh ZC5tNApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYzgxODk5OS4uMDAwMDAwMAotLS0g YS90b29scy9tNC9wdGhyZWFkLm00CisrKyAvZGV2L251bGwKQEAgLTEsNDEgKzAsMCBAQAotIyBX ZSBkZWZpbmUsIHNlcGFyYXRlbHksIFBUSFJFQURfQ0ZMQUdTLCBfTERGTEFHUyBhbmQgX0xJQlMK LSMgZXZlbiB0aG91Z2ggY3VycmVudGx5IHdlIGRvbid0IHNldCB0aGVtIHZlcnkgc2VwYXJhdGVs eS4KLSMgVGhpcyBtZWFucyB0aGF0IHRoZSBtYWtlZmlsZXMgd2lsbCBub3QgbmVlZCB0byBjaGFu Z2UgaW4KLSMgdGhlIGZ1dHVyZSBpZiB3ZSBtYWtlIHRoZSB0ZXN0IG1vcmUgc29waGlzdGljYXRl ZC4KLQotQUNfREVGVU4oW0FYX1BUSFJFQURfQ1YyVkFSU10sWwotICAgIFBUSFJFQURfQ0ZMQUdT PSIkYXhfY3ZfcHRocmVhZF9mbGFncyIKLSAgICBQVEhSRUFEX0xERkxBR1M9IiRheF9jdl9wdGhy ZWFkX2ZsYWdzIgotICAgIFBUSFJFQURfTElCUz0iIgotXSkKLQotIyBXZSBpbnZva2UgQVhfUFRI UkVBRF9WQVJTIHdpdGggdGhlIG5hbWUgb2YgYW5vdGhlciBtYWNybwotIyB3aGljaCBpcyB0aGVu IGV4cGFuZGVkIG9uY2UgZm9yIGVhY2ggdmFyaWFibGUuCi1BQ19ERUZVTihbQVhfUFRIUkVBRF9W QVJTXSxbJDEoQ0ZMQUdTKSAkMShMREZMQUdTKSAkMShMSUJTKV0pCi0KLUFDX0RFRlVOKFtBWF9Q VEhSRUFEX1ZBUl9BUFBMWV0sWwotICAgICQxPSIkJDEgJFBUSFJFQURfJDEiCi1dKQotQUNfREVG VU4oW0FYX1BUSFJFQURfVkFSX1NVQlNUXSxbQUNfU1VCU1QoUFRIUkVBRF8kMSldKQotCi1BQ19E RUZVTihbQVhfQ0hFQ0tfUFRIUkVBRF0sWwotICAgIEFDX0NBQ0hFX0NIRUNLKFtmb3IgcHRocmVh ZCBmbGFnXSwgW2F4X2N2X3B0aHJlYWRfZmxhZ3NdLCBbCi0gICAgICAgIGF4X2N2X3B0aHJlYWRf ZmxhZ3M9LXB0aHJlYWQKLSAgICAgICAgQVhfUFRIUkVBRF9DVjJWQVJTCi0gICAgICAgIEFYX1BU SFJFQURfVkFSUyhbQVhfU0FWRVZBUl9TQVZFXSkKLSAgICAgICAgQVhfUFRIUkVBRF9WQVJTKFtB WF9QVEhSRUFEX1ZBUl9BUFBMWV0pCi0gICAgICAgIEFDX0xJTktfSUZFTFNFKFtBQ19MQU5HX1NP VVJDRShbCi0jaW5jbHVkZSA8cHRocmVhZC5oPgotaW50IG1haW4odm9pZCkgewotICBwdGhyZWFk X2F0Zm9yaygwLDAsMCk7Ci0gIHB0aHJlYWRfY3JlYXRlKDAsMCwwLDApOwotfQotXSldLFtdLFth eF9jdl9wdGhyZWFkX2ZsYWdzPWZhaWxlZF0pCi0gICAgICAgIEFYX1BUSFJFQURfVkFSUyhbQVhf U0FWRVZBUl9SRVNUT1JFXSkKLSAgICBdKQotICAgIGlmIHRlc3QgIngkYXhfY3ZfcHRocmVhZF9m bGFncyIgPSB4ZmFpbGVkOyB0aGVuCi0gICAgICAgIEFDX01TR19FUlJPUihbLXB0aHJlYWQgZG9l cyBub3Qgd29ya10pCi0gICAgZmkKLSAgICBBWF9QVEhSRUFEX0NWMlZBUlMKLSAgICBBWF9QVEhS RUFEX1ZBUlMoW0FYX1BUSFJFQURfVkFSX1NVQlNUXSkKLV0pCmRpZmYgLS1naXQgYS90b29scy9t NC9wdHlmdW5jcy5tNCBiL3Rvb2xzL200L3B0eWZ1bmNzLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAzZTM3YjVhLi4wMDAwMDAwCi0tLSBhL3Rvb2xzL200L3B0eWZ1bmNzLm00Cisr KyAvZGV2L251bGwKQEAgLTEsMzUgKzAsMCBAQAotQUNfREVGVU4oW0FYX0NIRUNLX1BUWUZVTkNT XSwgWwotICAgIGRubCBUaGlzIGlzIGEgd29ya2Fyb3VuZCBmb3IgYSBidWcgaW4gRGViaWFuIHBh Y2thZ2UKLSAgICBkbmwgbGliYnNkLWRldi0wLjMuMC0xLiBPbmNlIHdlIG5vIGxvbmdlciBzdXBw b3J0IHRoYXQKLSAgICBkbmwgcGFja2FnZSB3ZSBjYW4gcmVtb3ZlIHRoZSBhZGRpdGlvbiBvZiAt V2Vycm9yIHRvCi0gICAgZG5sIENQUEZMQUdTLgotICAgIEFYX1NBVkVWQVJfU0FWRShDUFBGTEFH UykKLSAgICBDUFBGTEFHUz0iJENQUEZMQUdTIC1XZXJyb3IiCi0gICAgQUNfQ0hFQ0tfSEVBREVS KFtsaWJ1dGlsLmhdLFsKLSAgICAgIEFDX0RFRklORShbSU5DTFVERV9MSUJVVElMX0hdLFs8bGli dXRpbC5oPl0sW2xpYnV0aWwgaGVhZGVyIGZpbGUgbmFtZV0pCi0gICAgXSkKLSAgICBBWF9TQVZF VkFSX1JFU1RPUkUoQ1BQRkxBR1MpCi0gICAgQUNfQ0FDSEVfQ0hFQ0soW2ZvciBvcGVucHR5IGV0 IGFsXSwgW2F4X2N2X3B0eWZ1bmNzX2xpYnNdLCBbCi0gICAgICAgIGZvciBheF9jdl9wdHlmdW5j c19saWJzIGluIC1sdXRpbCAiIiBOT1RfRk9VTkQ7IGRvCi0gICAgICAgICAgICBpZiB0ZXN0ICJ4 JGF4X2N2X3B0eWZ1bmNzX2xpYnMiID0gInhOT1RfRk9VTkQiOyB0aGVuCi0gICAgICAgICAgICAg ICAgQUNfTVNHX0ZBSUxVUkUoW1VuYWJsZSB0byBmaW5kIGxpYnJhcnkgZm9yIG9wZW5wdHkgYW5k IGxvZ2luX3R0eV0pCi0gICAgICAgICAgICBmaQotICAgICAgICAgICAgQVhfU0FWRVZBUl9TQVZF KExJQlMpCi0gICAgICAgICAgICBMSUJTPSIkTElCUyAkYXhfY3ZfcHR5ZnVuY3NfbGlicyIKLSAg ICAgICAgICAgIEFDX0xJTktfSUZFTFNFKFtBQ19MQU5HX1NPVVJDRShbCi0jaWZkZWYgSU5DTFVE RV9MSUJVVElMX0gKLSNpbmNsdWRlIElOQ0xVREVfTElCVVRJTF9ICi0jZW5kaWYKLWludCBtYWlu KHZvaWQpIHsKLSAgb3BlbnB0eSgwLDAsMCwwLDApOwotICBsb2dpbl90dHkoMCk7Ci19Ci1dKV0s WwotICAgICAgICAgICAgICAgIGJyZWFrCi0gICAgICAgICAgICBdLFtdKQotICAgICAgICAgICAg QVhfU0FWRVZBUl9SRVNUT1JFKExJQlMpCi0gICAgICAgIGRvbmUKLSAgICBdKQotICAgIFBUWUZV TkNTX0xJQlM9IiRheF9jdl9wdHlmdW5jc19saWJzIgotICAgIEFDX1NVQlNUKFBUWUZVTkNTX0xJ QlMpCi1dKQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvcHl0aG9uX2RldmVsLm00IGIvdG9vbHMvbTQv cHl0aG9uX2RldmVsLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwYTIyMDJjLi4w MDAwMDAwCi0tLSBhL3Rvb2xzL200L3B5dGhvbl9kZXZlbC5tNAorKysgL2Rldi9udWxsCkBAIC0x LDM2ICswLDAgQEAKLUFDX0RFRlVOKFtBWF9DSEVDS19QWVRIT05fREVWRUxdLCBbCi1hY19wcmV2 aW91c19jcHBmbGFncz0kQ1BQRkxBR1MKLWFjX3ByZXZpb3VzX2xkZmxhZ3M9JExERkxBR1MKLWFj X3B5dGhvbl92ZXJzaW9uPWAkUFlUSE9OIC1jICdpbXBvcnQgZGlzdHV0aWxzLnN5c2NvbmZpZzsg XAotICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIoIlZFUlNJT04i KSdgCi1BQ19QQVRIX1BST0coW3B5Y29uZmlnXSwgWyRQWVRIT04tY29uZmlnXSwgW25vXSkKLUFT X0lGKFt0ZXN0IHgiJHB5Y29uZmlnIiA9PSB4Im5vIl0sIFsKLSAgICBkbmwgRm9yIHRob3NlIHRo YXQgZG9uJ3QgaGF2ZSBweXRob24tY29uZmlnCi0gICAgQ1BQRkxBR1M9IiRDRkxBR1MgYCRQWVRI T04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMuc3lzY29uZmlnOyBcCi0gICAgICAgIHByaW50ICItSSIg KyBkaXN0dXRpbHMuc3lzY29uZmlnLmdldF9jb25maWdfdmFyKCJJTkNMVURFUFkiKSdgIgotICAg IENQUEZMQUdTPSIkQ1BQRkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMuc3lzY29u ZmlnOyBcCi0gICAgICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIo IkNGTEFHUyIpJ2AiCi0gICAgTERGTEFHUz0iJExERkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBk aXN0dXRpbHMuc3lzY29uZmlnOyBcCi0gICAgICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcu Z2V0X2NvbmZpZ192YXIoIkxJQlMiKSdgIgotICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9O IC1jICdpbXBvcnQgZGlzdHV0aWxzLnN5c2NvbmZpZzsgXAotICAgICAgICBwcmludCBkaXN0dXRp bHMuc3lzY29uZmlnLmdldF9jb25maWdfdmFyKCJTWVNMSUJTIiknYCIKLSAgICBMREZMQUdTPSIk TERGTEFHUyBgJFBZVEhPTiAtYyAnaW1wb3J0IGRpc3R1dGlscy5zeXNjb25maWc7IFwKLSAgICAg ICAgcHJpbnQgIi1MIiArIGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X3B5dGhvbl9saWIocGxhdF9z cGVjaWZpYz0xLFwKLSAgICAgICAgc3RhbmRhcmRfbGliPTEpICsgIi9jb25maWciJ2AiCi0gICAg TERGTEFHUz0iJExERkxBR1MgYCRQWVRIT04gLWMgJ2ltcG9ydCBkaXN0dXRpbHMuc3lzY29uZmln OyBcCi0gICAgICAgIHByaW50IGRpc3R1dGlscy5zeXNjb25maWcuZ2V0X2NvbmZpZ192YXIoIkxJ TktGT1JTSEFSRUQiKSdgIgotICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9OIC1jICdpbXBv cnQgZGlzdHV0aWxzLnN5c2NvbmZpZzsgXAotICAgICAgICBwcmludCBkaXN0dXRpbHMuc3lzY29u ZmlnLmdldF9jb25maWdfdmFyKCJMREZMQUdTIiknYCIKLV0sIFsKLSAgICBkbmwgSWYgcHl0aG9u LWNvbmZpZyBpcyBmb3VuZCB1c2UgaXQKLSAgICBDUFBGTEFHUz0iJENGTEFHUyBgJFBZVEhPTi1j b25maWcgLS1jZmxhZ3NgIgotICAgIExERkxBR1M9IiRMREZMQUdTIGAkUFlUSE9OLWNvbmZpZyAt LWxkZmxhZ3NgIgotXSkKLQotQUNfQ0hFQ0tfSEVBREVSKFtQeXRob24uaF0sIFtdLAotICAgIFtB Q19NU0dfRVJST1IoW1VuYWJsZSB0byBmaW5kIFB5dGhvbiBkZXZlbG9wbWVudCBoZWFkZXJzXSld LCkKLUFDX0NIRUNLX0xJQihweXRob24kYWNfcHl0aG9uX3ZlcnNpb24sIFB5QXJnX1BhcnNlVHVw bGUsIFtdLAotICAgIFtBQ19NU0dfRVJST1IoW1VuYWJsZSB0byBmaW5kIGEgc3VpdGFibGUgcHl0 aG9uIGRldmVsb3BtZW50IGxpYnJhcnldKV0pCi1DUFBGTEFHUz0kYWNfcHJldmlvdXNfY3BwZmxh Z3MKLUxETEZBR1M9JGFjX3ByZXZpb3VzX2xkZmxhZ3MKLV0pCmRpZmYgLS1naXQgYS90b29scy9t NC9weXRob25fdmVyc2lvbi5tNCBiL3Rvb2xzL200L3B5dGhvbl92ZXJzaW9uLm00CmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZTJiNTk0Li4wMDAwMDAwCi0tLSBhL3Rvb2xzL200L3B5 dGhvbl92ZXJzaW9uLm00CisrKyAvZGV2L251bGwKQEAgLTEsMTIgKzAsMCBAQAotQUNfREVGVU4o W0FYX0NIRUNLX1BZVEhPTl9WRVJTSU9OXSwKLVtBQ19NU0dfQ0hFQ0tJTkcoW2ZvciBweXRob24g dmVyc2lvbiA+PSAkMS4kMiBdKQotYCRQWVRIT04gLWMgJ2ltcG9ydCBzeXM7IHN5cy5leGl0KGV2 YWwoInN5cy52ZXJzaW9uX2luZm8gPCAoJDEsICQyKSIpKSdgCi1pZiB0ZXN0ICIkPyIgIT0gIjAi Ci10aGVuCi0gICAgcHl0aG9uX3ZlcnNpb249YCRQWVRIT04gLVYgMj4mMWAKLSAgICBBQ19NU0df UkVTVUxUKFtub10pCi0gICAgQUNfTVNHX0VSUk9SKAotICAgICAgICBbJHB5dGhvbl92ZXJzaW9u IGlzIHRvbyBvbGQsIG1pbmltdW0gcmVxdWlyZWQgdmVyc2lvbiBpcyAkMS4kMl0pCi1lbHNlCi0g ICAgQUNfTVNHX1JFU1VMVChbeWVzXSkKLWZpXSkKZGlmZiAtLWdpdCBhL3Rvb2xzL200L3NhdmV2 YXIubTQgYi90b29scy9tNC9zYXZldmFyLm00CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAyMTU2YmVlLi4wMDAwMDAwCi0tLSBhL3Rvb2xzL200L3NhdmV2YXIubTQKKysrIC9kZXYvbnVs bApAQCAtMSw2ICswLDAgQEAKLUFDX0RFRlVOKFtBWF9TQVZFVkFSX1NBVkVdLFsKLSAgICBzYXZl ZF8kMT0iJCQxIgotXSkKLUFDX0RFRlVOKFtBWF9TQVZFVkFSX1JFU1RPUkVdLFsKLSAgICAkMT0i JHNhdmVkXyQxIgotXSkKZGlmZiAtLWdpdCBhL3Rvb2xzL200L3NldF9jZmxhZ3NfbGRmbGFncy5t NCBiL3Rvb2xzL200L3NldF9jZmxhZ3NfbGRmbGFncy5tNApkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggY2JhZDNjMS4uMDAwMDAwMAotLS0gYS90b29scy9tNC9zZXRfY2ZsYWdzX2xkZmxh Z3MubTQKKysrIC9kZXYvbnVsbApAQCAtMSwyMCArMCwwIEBACi1BQ19ERUZVTihbQVhfU0VUX0ZM QUdTXSwKLVtmb3IgY3BwZmxhZyBpbiAkUFJFUEVORF9JTkNMVURFUwotZG8KLSAgICBQUkVQRU5E X0NQUEZMQUdTPSIkUFJFUEVORF9DUFBGTEFHUyAtSSRjcHBmbGFnIgotZG9uZQotZm9yIGxkZmxh ZyBpbiAkUFJFUEVORF9MSUIKLWRvCi0gICAgUFJFUEVORF9MREZMQUdTPSIkUFJFUEVORF9MREZM QUdTIC1MJGxkZmxhZyIKLWRvbmUKLWZvciBjcHBmbGFnIGluICRBUFBFTkRfSU5DTFVERVMKLWRv Ci0gICAgQVBQRU5EX0NQUEZMQUdTPSIkQVBQRU5EX0NQUEZMQUdTIC1JJGNwcGZsYWciCi1kb25l Ci1mb3IgbGRmbGFnIGluICRBUFBFTkRfTElCCi1kbwotICAgIEFQUEVORF9MREZMQUdTPSIkQVBQ RU5EX0xERkxBR1MgLUwkbGRmbGFnIgotZG9uZQotQ1BQRkxBR1M9IiRQUkVQRU5EX0NQUEZMQUdT ICRDUFBGTEFHUyAkQVBQRU5EX0NQUEZMQUdTIgotTERGTEFHUz0iJFBSRVBFTkRfTERGTEFHUyAk TERGTEFHUyAkQVBQRU5EX0xERkxBR1MiXSkKLQpkaWZmIC0tZ2l0IGEvdG9vbHMvbTQvdXVpZC5t NCBiL3Rvb2xzL200L3V1aWQubTQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDExN2Rh NWMuLjAwMDAwMDAKLS0tIGEvdG9vbHMvbTQvdXVpZC5tNAorKysgL2Rldi9udWxsCkBAIC0xLDkg KzAsMCBAQAotQUNfREVGVU4oW0FYX0NIRUNLX1VVSURdLCBbCi1BQ19DSEVDS19IRUFERVIoW3V1 aWQvdXVpZC5oXSxbCi0gICAgQUNfQ0hFQ0tfTElCKFt1dWlkXSwgW3V1aWRfY2xlYXJdLCBbbGli dXVpZD0ieSJdKQotXSkKLUFDX0NIRUNLX0hFQURFUihbdXVpZC5oXSxbbGlidXVpZD0ieSJdKQot QVNfSUYoW3Rlc3QgIiRsaWJ1dWlkIiAhPSAieSJdLCBbCi0gICAgQUNfTVNHX0VSUk9SKFtjYW5u b3QgZmluZCBhIHZhbGlkIHV1aWQgbGlicmFyeV0pCi1dKQotXSkKLS0gCjEuNy4xMC40CgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1h aWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwOi8vbGlzdHMueGVuLm9yZy94 ZW4tZGV2ZWwK From xen-devel-bounces@lists.xen.org Thu Nov 29 18:55:45 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Thu, 29 Nov 2012 18:55:45 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te9Gk-0004xy-4O; Thu, 29 Nov 2012 18:55:30 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1Te9Gh-0004xk-DX for xen-devel@lists.xen.org; Thu, 29 Nov 2012 18:55:28 +0000 Received: from [85.158.143.99:7502] by server-1.bemta-4.messagelabs.com id 1D/A5-27934-E9FA7B05; Thu, 29 Nov 2012 18:55:26 +0000 X-Env-Sender: marmarek@invisiblethingslab.com X-Msg-Ref: server-6.tower-216.messagelabs.com!1354215324!20370402!1 X-Originating-IP: [66.111.4.28] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTExLjQuMjggPT4gNTk5MA==\n X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 7459 invoked from network); 29 Nov 2012 18:55:25 -0000 Received: from out4-smtp.messagingengine.com (HELO out4-smtp.messagingengine.com) (66.111.4.28) by server-6.tower-216.messagelabs.com with DHE-RSA-AES256-SHA encrypted SMTP; 29 Nov 2012 18:55:25 -0000 Received: from compute5.internal (compute5.nyi.mail.srv.osa [10.202.2.45]) by gateway1.nyi.mail.srv.osa (Postfix) with ESMTP id 61F5420CFB for ; Thu, 29 Nov 2012 13:55:24 -0500 (EST) Received: from frontend1.nyi.mail.srv.osa ([10.202.2.160]) by compute5.internal (MEProxy); Thu, 29 Nov 2012 13:55:24 -0500 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d= invisiblethingslab.com; h=message-id:date:from:mime-version:to :subject:content-type; s=mesmtp; bh=HIBktHiZvcR27MBVJfrXttc6Kcs=; b= KyFHzSF6QibWTJ4rAcs3ZAFDCK0pU9kO2c72eYj6nA10Z3+Xql+lhmtpTKvZq3rH hnZMkEtHJmJnG0cNd2Bz2Jg6dCIEXw6/eIgDfv5IhS2bTBmYbWt1AqqYtrJU3Xja E+u6rgpId4ilQP1IhIz/k5Gvs/DK9Qkzjp57J9Gb0/c= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d= messagingengine.com; h=message-id:date:from:mime-version:to :subject:content-type; s=smtpout; bh=HIBktHiZvcR27MBVJfrXttc6Kcs =; b=NNIt70G2Db2AabPKwVBUQ8Zz6uTbKKUa4rC1Sjqo0j5jEyhnBArGVsN3Byq Zu1YVXaMBsjE+xXIVcHnoU1KhsAATe3o7fdXq4KCez+vsMYqepyR1TJT9UfPpXHn VTxkvi2XzSyPGNXBVIqIlXxFdKMKrkUB811HYFPWJy2l7eTc= X-Sasl-enc: GH/NSOLJ78aXBVVQVbdKYyoD13rol7s5gTeWePh2Q2QP 1354215321 Received: from [10.137.1.17] (unknown [93.157.76.159]) by mail.messagingengine.com (Postfix) with ESMTPA id F3BEA8E04CE for ; Thu, 29 Nov 2012 13:55:20 -0500 (EST) Message-ID: <50B7AF8A.5010304@invisiblethingslab.com> Date: Thu, 29 Nov 2012 19:55:06 +0100 From: Marek Marczykowski User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 To: xen-devel X-Enigmail-Version: 1.4.6 Subject: [Xen-devel] Only CPU0 active after ACPI S3, xen 4.1.3 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: multipart/mixed; boundary="===============1945915925389597712==" Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org This is an OpenPGP/MIME signed message (RFC 2440 and 3156) --===============1945915925389597712== Content-Type: multipart/signed; micalg=pgp-sha1; protocol="application/pgp-signature"; boundary="------------enig5230F3E2DC98D5B5654D4AE2" This is an OpenPGP/MIME signed message (RFC 2440 and 3156) --------------enig5230F3E2DC98D5B5654D4AE2 Content-Type: multipart/mixed; boundary="------------050106030504030501010304" This is a multi-part message in MIME format. --------------050106030504030501010304 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Hi all, After resume from ACPI S3 system has only CPU0 enabled, every vCPU from e= very domain works on CPU0 [1]. When trying to pin some vCPU to CPU1 got error= : xl vcpu-pin testvm 1 1 libxl: error: libxl.c:2565:libxl_set_vcpuaffinity setting vcpu affinity: Invalid argument What went wrong? How can I reenable CPU1-CPU3? System info: xen 4.1.3 linux 3.4.18 with acpi-s3 patches from Konrad's git Processor: Intel i5-2520M dmesg from dom0 and hypervisor attached. BTW Are there any plans to upstream acpi-s3 patches? [1] xl vcpu-list: Name ID VCPU CPU State Time(s) CPU Af= finity dom0 0 0 0 r-- 1347.8 any cp= u dom0 0 1 0 -b- 594.4 any cp= u dom0 0 2 0 -b- 421.1 any cp= u dom0 0 3 0 -b- 432.6 any cp= u netvm 1 0 0 -b- 596.6 any cp= u netvm 1 1 0 -b- 363.7 any cp= u firewallvm 2 0 0 -b- 170.5 any cp= u firewallvm 2 1 0 -b- 122.5 any cp= u devel17 3 0 0 -b- 137.0 any cp= u devel17 3 1 0 -b- 112.9 any cp= u devel17 3 2 0 -b- 97.9 any cp= u devel17 3 3 0 -b- 116.0 any cp= u vm2 4 0 0 -b- 418.6 any cp= u vm2 4 1 0 -b- 390.2 any cp= u private 5 0 0 -b- 175.9 any cp= u private 5 1 0 -b- 161.6 any cp= u mail 6 0 0 -b- 1587.1 any cp= u mail 6 1 0 -b- 1717.5 any cp= u testvm 7 0 0 -b- 73.0 any cp= u testvm 7 1 0 -b- 68.9 any cp= u testvm 7 2 0 -b- 51.4 any cp= u testvm 7 3 0 -b- 67.1 any cp= u disp1 8 0 0 -b- 199.9 any cp= u --=20 Best Regards / Pozdrawiam, Marek Marczykowski Invisible Things Lab --------------050106030504030501010304 Content-Type: text/plain; charset=UTF-8; name="dom0-dmesg.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="dom0-dmesg.txt" WyAgICAwLjAwMDAwMF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgY3B1c2V0ClsgICAg MC4wMDAwMDBdIEluaXRpYWxpemluZyBjZ3JvdXAgc3Vic3lzIGNwdQpbICAgIDAuMDAwMDAw XSBMaW51eCB2ZXJzaW9uIDMuNC4xOC0yLnB2b3BzLnF1YmVzLng4Nl82NCAodXNlckBuZW1l emlzLm1hcm1hcmVrLm5ldCkgKGdjYyB2ZXJzaW9uIDQuNC41IDIwMTAxMTEyIChSZWQgSGF0 IDQuNC41LTIpIChHQ0MpICkgIzEgU01QIFdlZCBOb3YgNyAyMjo0NzoyMSBFU1QgMjAxMgpb ICAgIDAuMDAwMDAwXSBDb21tYW5kIGxpbmU6IHJvIHJvb3Q9L2Rldi9tYXBwZXIvdmdfZG9t MC1sdl9yb290IHJkX0xVS1NfVVVJRD1sdWtzLTQwMDMzNmZhLWM3YzQtNGJlMy1hMjQ0LWM5 MDlhYTE2YTE4YyByZF9MVk1fTFY9dmdfZG9tMC9sdl9yb290IHJkX0xWTV9MVj12Z19kb20w L2x2X3N3YXAgcmRfTk9fTUQgcmRfTk9fRE0gTEFORz1lbl9VUy5VVEYtOCBTWVNGT05UPWxh dGFyY3lyaGViLXN1bjE2IEtFWVRBQkxFPXBsMiByaGdiIHF1aWV0IG1heF9sb29wPTI1NQpb ICAgIDAuMDAwMDAwXSBGcmVlaW5nICA5YS0xMDAgcGZuIHJhbmdlOiAxMDIgcGFnZXMgZnJl ZWQKWyAgICAwLjAwMDAwMF0gMS0xIG1hcHBpbmcgb24gOWEtPjEwMApbICAgIDAuMDAwMDAw XSBGcmVlaW5nICA3ZWVhLTdmNjcgcGZuIHJhbmdlOiAxMjUgcGFnZXMgZnJlZWQKWyAgICAw LjAwMDAwMF0gMS0xIG1hcHBpbmcgb24gN2VlYS0+N2Y2NwpbICAgIDAuMDAwMDAwXSBGcmVl aW5nICA3ZjcwLTdmNzYgcGZuIHJhbmdlOiA2IHBhZ2VzIGZyZWVkClsgICAgMC4wMDAwMDBd IDEtMSBtYXBwaW5nIG9uIDdmNzAtPjdmNzYKWyAgICAwLjAwMDAwMF0gRnJlZWluZyAgN2Y3 OC04MDAwIHBmbiByYW5nZTogMTM2IHBhZ2VzIGZyZWVkClsgICAgMC4wMDAwMDBdIDEtMSBt YXBwaW5nIG9uIDdmNzgtPjgwMDAKWyAgICAwLjAwMDAwMF0gRnJlZWluZyAgZGZmZC1lMDAw IHBmbiByYW5nZTogMyBwYWdlcyBmcmVlZApbICAgIDAuMDAwMDAwXSAxLTEgbWFwcGluZyBv biBkZmZkLT5lMDAwClsgICAgMC4wMDAwMDBdIEZyZWVpbmcgIDIwMDAwLTIwMjAwIHBmbiBy YW5nZTogNTEyIHBhZ2VzIGZyZWVkClsgICAgMC4wMDAwMDBdIDEtMSBtYXBwaW5nIG9uIDIw MDAwLT4yMDIwMApbICAgIDAuMDAwMDAwXSBGcmVlaW5nICA0MDAwMC00MDIwMCBwZm4gcmFu Z2U6IDUxMiBwYWdlcyBmcmVlZApbICAgIDAuMDAwMDAwXSAxLTEgbWFwcGluZyBvbiA0MDAw MC0+NDAyMDAKWyAgICAwLjAwMDAwMF0gRnJlZWluZyAgYzgzYjQtYzg0MGEgcGZuIHJhbmdl OiA4NiBwYWdlcyBmcmVlZApbICAgIDAuMDAwMDAwXSAxLTEgbWFwcGluZyBvbiBjODNiNC0+ Yzg0MGEKWyAgICAwLjAwMDAwMF0gRnJlZWluZyAgYzg0MGUtYzg0MGYgcGZuIHJhbmdlOiAx IHBhZ2VzIGZyZWVkClsgICAgMC4wMDAwMDBdIDEtMSBtYXBwaW5nIG9uIGM4NDBlLT5jODQw ZgpbICAgIDAuMDAwMDAwXSBGcmVlaW5nICBjODQxMS1jODQxNCBwZm4gcmFuZ2U6IDMgcGFn ZXMgZnJlZWQKWyAgICAwLjAwMDAwMF0gMS0xIG1hcHBpbmcgb24gYzg0MTEtPmM4NDE0Clsg ICAgMC4wMDAwMDBdIEZyZWVpbmcgIGM4NDFlLWM4NDI4IHBmbiByYW5nZTogMTAgcGFnZXMg ZnJlZWQKWyAgICAwLjAwMDAwMF0gMS0xIG1hcHBpbmcgb24gYzg0MWUtPmM4NDI4ClsgICAg MC4wMDAwMDBdIEZyZWVpbmcgIGM4NDMyLWM4NDM2IHBmbiByYW5nZTogNCBwYWdlcyBmcmVl ZApbICAgIDAuMDAwMDAwXSAxLTEgbWFwcGluZyBvbiBjODQzMi0+Yzg0MzYKWyAgICAwLjAw MDAwMF0gRnJlZWluZyAgY2FjMDAtMTAwMDAwIHBmbiByYW5nZTogMjE4MTEyIHBhZ2VzIGZy ZWVkClsgICAgMC4wMDAwMDBdIDEtMSBtYXBwaW5nIG9uIGNhYzAwLT4xMDAwMDAKWyAgICAw LjAwMDAwMF0gUmVsZWFzZWQgMjE5NjEyIHBhZ2VzIG9mIHVudXNlZCBtZW1vcnkKWyAgICAw LjAwMDAwMF0gU2V0IDIxOTYxMiBwYWdlKHMpIHRvIDEtMSBtYXBwaW5nClsgICAgMC4wMDAw MDBdIEJJT1MtcHJvdmlkZWQgcGh5c2ljYWwgUkFNIG1hcDoKWyAgICAwLjAwMDAwMF0gIFhl bjogMDAwMDAwMDAwMDAwMDAwMCAtIDAwMDAwMDAwMDAwOWEwMDAgKHVzYWJsZSkKWyAgICAw LjAwMDAwMF0gIFhlbjogMDAwMDAwMDAwMDA5YTgwMCAtIDAwMDAwMDAwMDAxMDAwMDAgKHJl c2VydmVkKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMDAwMTAwMDAwIC0gMDAwMDAw MDAwN2VlYTAwMCAodXNhYmxlKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMDA3ZWVh MDAwIC0gMDAwMDAwMDAwN2Y2NzAwMCAoQUNQSSBOVlMpClsgICAgMC4wMDAwMDBdICBYZW46 IDAwMDAwMDAwMDdmNjcwMDAgLSAwMDAwMDAwMDA3ZjcwMDAwICh1c2FibGUpClsgICAgMC4w MDAwMDBdICBYZW46IDAwMDAwMDAwMDdmNzAwMDAgLSAwMDAwMDAwMDA3Zjc2MDAwIChBQ1BJ IE5WUykKWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDAwN2Y3NjAwMCAtIDAwMDAwMDAw MDdmNzgwMDAgKHVzYWJsZSkKWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDAwN2Y3ODAw MCAtIDAwMDAwMDAwMDgwMDAwMDAgKEFDUEkgTlZTKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAw MDAwMDAwMDA4MDAwMDAwIC0gMDAwMDAwMDAwZGZmZDAwMCAodXNhYmxlKQpbICAgIDAuMDAw MDAwXSAgWGVuOiAwMDAwMDAwMDBkZmZkMDAwIC0gMDAwMDAwMDAwZTAwMDAwMCAoQUNQSSBk YXRhKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMDBlMDAwMDAwIC0gMDAwMDAwMDAy MDAwMDAwMCAodXNhYmxlKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMDIwMDAwMDAw IC0gMDAwMDAwMDAyMDIwMDAwMCAocmVzZXJ2ZWQpClsgICAgMC4wMDAwMDBdICBYZW46IDAw MDAwMDAwMjAyMDAwMDAgLSAwMDAwMDAwMDQwMDAwMDAwICh1c2FibGUpClsgICAgMC4wMDAw MDBdICBYZW46IDAwMDAwMDAwNDAwMDAwMDAgLSAwMDAwMDAwMDQwMjAwMDAwIChyZXNlcnZl ZCkKWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDA0MDIwMDAwMCAtIDAwMDAwMDAwYzgz YjQwMDAgKHVzYWJsZSkKWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDBjODNiNDAwMCAt IDAwMDAwMDAwYzg0MGEwMDAgKHJlc2VydmVkKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAw MDAwMGM4NDBhMDAwIC0gMDAwMDAwMDBjODQwZTAwMCAodXNhYmxlKQpbICAgIDAuMDAwMDAw XSAgWGVuOiAwMDAwMDAwMGM4NDBlMDAwIC0gMDAwMDAwMDBjODQwZjAwMCAocmVzZXJ2ZWQp ClsgICAgMC4wMDAwMDBdICBYZW46IDAwMDAwMDAwYzg0MGYwMDAgLSAwMDAwMDAwMGM4NDEx MDAwICh1c2FibGUpClsgICAgMC4wMDAwMDBdICBYZW46IDAwMDAwMDAwYzg0MTEwMDAgLSAw MDAwMDAwMGM4NDE0MDAwIChyZXNlcnZlZCkKWyAgICAwLjAwMDAwMF0gIFhlbjogMDAwMDAw MDBjODQxNDAwMCAtIDAwMDAwMDAwYzg0MWUwMDAgKHVzYWJsZSkKWyAgICAwLjAwMDAwMF0g IFhlbjogMDAwMDAwMDBjODQxZTAwMCAtIDAwMDAwMDAwYzg0MjgwMDAgKHJlc2VydmVkKQpb ICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMGM4NDI4MDAwIC0gMDAwMDAwMDBjODQzMjAw MCAodXNhYmxlKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMGM4NDMyMDAwIC0gMDAw MDAwMDBjODQzNjAwMCAocmVzZXJ2ZWQpClsgICAgMC4wMDAwMDBdICBYZW46IDAwMDAwMDAw Yzg0MzYwMDAgLSAwMDAwMDAwMGNhYzAwMDAwICh1c2FibGUpClsgICAgMC4wMDAwMDBdICBY ZW46IDAwMDAwMDAwY2I4MDAwMDAgLSAwMDAwMDAwMGNmYTAwMDAwIChyZXNlcnZlZCkKWyAg ICAwLjAwMDAwMF0gIFhlbjogMDAwMDAwMDBmZWMwMDAwMCAtIDAwMDAwMDAwZmVjMDEwMDAg KHJlc2VydmVkKQpbICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMGZlZDFjMDAwIC0gMDAw MDAwMDBmZWQyMDAwMCAocmVzZXJ2ZWQpClsgICAgMC4wMDAwMDBdICBYZW46IDAwMDAwMDAw ZmVlMDAwMDAgLSAwMDAwMDAwMGZlZTAxMDAwIChyZXNlcnZlZCkKWyAgICAwLjAwMDAwMF0g IFhlbjogMDAwMDAwMDBmZmMwMDAwMCAtIDAwMDAwMDAwZmZjMjAwMDAgKHJlc2VydmVkKQpb ICAgIDAuMDAwMDAwXSAgWGVuOiAwMDAwMDAwMTAwMDAwMDAwIC0gMDAwMDAwMDQyZTAwMDAw MCAodXNhYmxlKQpbICAgIDAuMDAwMDAwXSBOWCAoRXhlY3V0ZSBEaXNhYmxlKSBwcm90ZWN0 aW9uOiBhY3RpdmUKWyAgICAwLjAwMDAwMF0gRE1JIDIuNiBwcmVzZW50LgpbICAgIDAuMDAw MDAwXSBETUk6IERlbGwgSW5jLiBMYXRpdHVkZSBFNjQyMC8wSzBETlAsIEJJT1MgQTEzIDA1 LzE3LzIwMTIKWyAgICAwLjAwMDAwMF0gZTgyMCB1cGRhdGUgcmFuZ2U6IDAwMDAwMDAwMDAw MDAwMDAgLSAwMDAwMDAwMDAwMDEwMDAwICh1c2FibGUpID09PiAocmVzZXJ2ZWQpClsgICAg MC4wMDAwMDBdIGU4MjAgcmVtb3ZlIHJhbmdlOiAwMDAwMDAwMDAwMGEwMDAwIC0gMDAwMDAw MDAwMDEwMDAwMCAodXNhYmxlKQpbICAgIDAuMDAwMDAwXSBObyBBR1AgYnJpZGdlIGZvdW5k ClsgICAgMC4wMDAwMDBdIGxhc3RfcGZuID0gMHg0MmUwMDAgbWF4X2FyY2hfcGZuID0gMHg0 MDAwMDAwMDAKWyAgICAwLjAwMDAwMF0geDJhcGljIGVuYWJsZWQgYnkgQklPUywgc3dpdGNo aW5nIHRvIHgyYXBpYyBvcHMKWyAgICAwLjAwMDAwMF0gbGFzdF9wZm4gPSAweGNhYzAwIG1h eF9hcmNoX3BmbiA9IDB4NDAwMDAwMDAwClsgICAgMC4wMDAwMDBdIGZvdW5kIFNNUCBNUC10 YWJsZSBhdCBbZmZmZjg4MDAwMDBmMWFkMF0gZjFhZDAKWyAgICAwLjAwMDAwMF0gaW5pdGlh bCBtZW1vcnkgbWFwcGVkIDogMCAtIDA0YWRlMDAwClsgICAgMC4wMDAwMDBdIEJhc2UgbWVt b3J5IHRyYW1wb2xpbmUgYXQgW2ZmZmY4ODAwMDAwOTUwMDBdIDk1MDAwIHNpemUgMjA0ODAK WyAgICAwLjAwMDAwMF0gaW5pdF9tZW1vcnlfbWFwcGluZzogMDAwMDAwMDAwMDAwMDAwMC0w MDAwMDAwMGNhYzAwMDAwClsgICAgMC4wMDAwMDBdICAwMDAwMDAwMDAwIC0gMDBjYWMwMDAw MCBwYWdlIDRrClsgICAgMC4wMDAwMDBdIGtlcm5lbCBkaXJlY3QgbWFwcGluZyB0YWJsZXMg dXAgdG8gMHhjYWJmZmZmZiBAIFttZW0gMHgwMDlhNTAwMC0weDAwZmZmZmZmXQpbICAgIDAu MDAwMDAwXSB4ZW46IHNldHRpbmcgUlcgdGhlIHJhbmdlIGZjNDAwMCAtIDEwMDAwMDAKWyAg ICAwLjAwMDAwMF0gaW5pdF9tZW1vcnlfbWFwcGluZzogMDAwMDAwMDEwMDAwMDAwMC0wMDAw MDAwNDJlMDAwMDAwClsgICAgMC4wMDAwMDBdICAwMTAwMDAwMDAwIC0gMDQyZTAwMDAwMCBw YWdlIDRrClsgICAgMC4wMDAwMDBdIGtlcm5lbCBkaXJlY3QgbWFwcGluZyB0YWJsZXMgdXAg dG8gMHg0MmRmZmZmZmYgQCBbbWVtIDB4YzkyODIwMDAtMHhjYWJmZmZmZl0KWyAgICAwLjAw MDAwMF0geGVuOiBzZXR0aW5nIFJXIHRoZSByYW5nZSBjYWJmZjAwMCAtIGNhYzAwMDAwClsg ICAgMC4wMDAwMDBdIFJBTURJU0s6IDAxZTEzMDAwIC0gMDRhZGUwMDAKWyAgICAwLjAwMDAw MF0gQUNQSTogUlNEUCAwMDAwMDAwMDAwMGZlMzAwIDAwMDI0ICh2MDIgREVMTCAgKQpbICAg IDAuMDAwMDAwXSBBQ1BJOiBYU0RUIDAwMDAwMDAwMGRmZmVlMTggMDAwN0MgKHYwMSBERUxM ICAgIENCWDMgICAgMDYyMjIwMDQgTVNGVCAwMDAxMDAxMykKWyAgICAwLjAwMDAwMF0gQUNQ STogRkFDUCAwMDAwMDAwMDA3ZjkwZDk4IDAwMEY0ICh2MDQgREVMTCAgICBDQlgzICAgIDA2 MjIyMDA0IE1TRlQgMDAwMTAwMTMpClsgICAgMC4wMDAwMDBdIEFDUEkgV2FybmluZzogMzIv NjQgRkFDUyBhZGRyZXNzIG1pc21hdGNoIGluIEZBRFQgLSB0d28gRkFDUyB0YWJsZXMhICgy MDEyMDMyMC90YmZhZHQtMzc4KQpbICAgIDAuMDAwMDAwXSBBQ1BJIFdhcm5pbmc6IDMyLzY0 WCBGQUNTIGFkZHJlc3MgbWlzbWF0Y2ggaW4gRkFEVCAtIDB4MDdGRURFNDAvMHgwMDAwMDAw MDA3RkVERDQwLCB1c2luZyAzMiAoMjAxMjAzMjAvdGJmYWR0LTUwMikKWyAgICAwLjAwMDAw MF0gQUNQSTogRFNEVCAwMDAwMDAwMDA3ZjVlMDE4IDA4ODM0ICh2MDIgSU5UNDMwIFNZU0Zl eHh4IDAwMDAxMDAxIElOVEwgMjAwOTA5MDMpClsgICAgMC4wMDAwMDBdIEFDUEk6IEZBQ1Mg MDAwMDAwMDAwN2ZlZGU0MCAwMDA0MApbICAgIDAuMDAwMDAwXSBBQ1BJOiBBUElDIDAwMDAw MDAwMGRmZmRmMTggMDAwQ0MgKHYwMiBERUxMICAgIENCWDMgICAgMDYyMjIwMDQgTVNGVCAw MDAxMDAxMykKWyAgICAwLjAwMDAwMF0gQUNQSTogVENQQSAwMDAwMDAwMDA3ZmVlZDE4IDAw MDMyICh2MDIgICAgICAgICAgICAgICAgIDAwMDAwMDAwICAgICAgMDAwMDAwMDApClsgICAg MC4wMDAwMDBdIEFDUEk6IFNTRFQgMDAwMDAwMDAwN2Y5MWE5OCAwMDJGOSAodjAxIERFTExU UCAgICAgIFRQTSAwMDAwMzAwMCBJTlRMIDIwMDkwOTAzKQpbICAgIDAuMDAwMDAwXSBBQ1BJ OiBNQ0ZHIDAwMDAwMDAwMDdmZWVjOTggMDAwM0MgKHYwMSBERUxMICAgU05EWUJSREcgMDYy MjIwMDQgTVNGVCAwMDAwMDA5NykKWyAgICAwLjAwMDAwMF0gQUNQSTogSFBFVCAwMDAwMDAw MDA3ZmVlYzE4IDAwMDM4ICh2MDEgQSBNIEkgICBQQ0hIUEVUIDA2MjIyMDA0IEFNSS4gMDAw MDAwMDMpClsgICAgMC4wMDAwMDBdIEFDUEk6IEJPT1QgMDAwMDAwMDAwN2ZlZWI5OCAwMDAy OCAodjAxIERFTEwgICBDQlgzICAgICAwNjIyMjAwNCBBTUkgIDAwMDEwMDEzKQpbICAgIDAu MDAwMDAwXSBBQ1BJOiBTU0RUIDAwMDAwMDAwMDdmNzUwMTggMDA4MDQgKHYwMSAgUG1SZWYg IENwdTBJc3QgMDAwMDMwMDAgSU5UTCAyMDA5MDkwMykKWyAgICAwLjAwMDAwMF0gQUNQSTog U1NEVCAwMDAwMDAwMDA3Zjc0MDE4IDAwOTk2ICh2MDEgIFBtUmVmICAgIENwdVBtIDAwMDAz MDAwIElOVEwgMjAwOTA5MDMpClsgICAgMC4wMDAwMDBdIEFDUEk6IFhNQVIgMDAwMDAwMDAw N2Y5MGMxOCAwMDBFOCAodjAxIElOVEVMICAgICAgU05CICAwMDAwMDAwMSBJTlRMIDAwMDAw MDAxKQpbICAgIDAuMDAwMDAwXSBBQ1BJOiBTTElDIDAwMDAwMDAwMDdmN2VjMTggMDAxNzYg KHYwMyBERUxMICAgIENCWDMgICAgMDYyMjIwMDQgTVNGVCAwMDAxMDAxMykKWyAgICAwLjAw MDAwMF0gQUNQSTogTG9jYWwgQVBJQyBhZGRyZXNzIDB4ZmVlMDAwMDAKWyAgICAwLjAwMDAw MF0gU2V0dGluZyBBUElDIHJvdXRpbmcgdG8gY2x1c3RlciB4MmFwaWMuClsgICAgMC4wMDAw MDBdIFpvbmUgUEZOIHJhbmdlczoKWyAgICAwLjAwMDAwMF0gICBETUEgICAgICAweDAwMDAw MDEwIC0+IDB4MDAwMDEwMDAKWyAgICAwLjAwMDAwMF0gICBETUEzMiAgICAweDAwMDAxMDAw IC0+IDB4MDAxMDAwMDAKWyAgICAwLjAwMDAwMF0gICBOb3JtYWwgICAweDAwMTAwMDAwIC0+ IDB4MDA0MmUwMDAKWyAgICAwLjAwMDAwMF0gTW92YWJsZSB6b25lIHN0YXJ0IFBGTiBmb3Ig ZWFjaCBub2RlClsgICAgMC4wMDAwMDBdIEVhcmx5IG1lbW9yeSBQRk4gcmFuZ2VzClsgICAg MC4wMDAwMDBdICAgICAwOiAweDAwMDAwMDEwIC0+IDB4MDAwMDAwOWEKWyAgICAwLjAwMDAw MF0gICAgIDA6IDB4MDAwMDAxMDAgLT4gMHgwMDAwN2VlYQpbICAgIDAuMDAwMDAwXSAgICAg MDogMHgwMDAwN2Y2NyAtPiAweDAwMDA3ZjcwClsgICAgMC4wMDAwMDBdICAgICAwOiAweDAw MDA3Zjc2IC0+IDB4MDAwMDdmNzgKWyAgICAwLjAwMDAwMF0gICAgIDA6IDB4MDAwMDgwMDAg LT4gMHgwMDAwZGZmZApbICAgIDAuMDAwMDAwXSAgICAgMDogMHgwMDAwZTAwMCAtPiAweDAw MDIwMDAwClsgICAgMC4wMDAwMDBdICAgICAwOiAweDAwMDIwMjAwIC0+IDB4MDAwNDAwMDAK WyAgICAwLjAwMDAwMF0gICAgIDA6IDB4MDAwNDAyMDAgLT4gMHgwMDBjODNiNApbICAgIDAu MDAwMDAwXSAgICAgMDogMHgwMDBjODQwYSAtPiAweDAwMGM4NDBlClsgICAgMC4wMDAwMDBd ICAgICAwOiAweDAwMGM4NDBmIC0+IDB4MDAwYzg0MTEKWyAgICAwLjAwMDAwMF0gICAgIDA6 IDB4MDAwYzg0MTQgLT4gMHgwMDBjODQxZQpbICAgIDAuMDAwMDAwXSAgICAgMDogMHgwMDBj ODQyOCAtPiAweDAwMGM4NDMyClsgICAgMC4wMDAwMDBdICAgICAwOiAweDAwMGM4NDM2IC0+ IDB4MDAwY2FjMDAKWyAgICAwLjAwMDAwMF0gICAgIDA6IDB4MDAxMDAwMDAgLT4gMHgwMDQy ZTAwMApbICAgIDAuMDAwMDAwXSBPbiBub2RlIDAgdG90YWxwYWdlczogNDE2MzA5MgpbICAg IDAuMDAwMDAwXSAgIERNQSB6b25lOiA1NiBwYWdlcyB1c2VkIGZvciBtZW1tYXAKWyAgICAw LjAwMDAwMF0gICBETUEgem9uZTogMTU3MiBwYWdlcyByZXNlcnZlZApbICAgIDAuMDAwMDAw XSAgIERNQSB6b25lOiAyMzUwIHBhZ2VzLCBMSUZPIGJhdGNoOjAKWyAgICAwLjAwMDAwMF0g ICBETUEzMiB6b25lOiAxNDI4MCBwYWdlcyB1c2VkIGZvciBtZW1tYXAKWyAgICAwLjAwMDAw MF0gICBETUEzMiB6b25lOiA4MTA2OTAgcGFnZXMsIExJRk8gYmF0Y2g6MzEKWyAgICAwLjAw MDAwMF0gICBOb3JtYWwgem9uZTogNDU1ODQgcGFnZXMgdXNlZCBmb3IgbWVtbWFwClsgICAg MC4wMDAwMDBdICAgTm9ybWFsIHpvbmU6IDMyODg1NjAgcGFnZXMsIExJRk8gYmF0Y2g6MzEK WyAgICAwLjAwMDAwMF0gQUNQSTogUE0tVGltZXIgSU8gUG9ydDogMHg0MDgKWyAgICAwLjAw MDAwMF0gQUNQSTogTG9jYWwgQVBJQyBhZGRyZXNzIDB4ZmVlMDAwMDAKWyAgICAwLjAwMDAw MF0gQUNQSTogTEFQSUMgKGFjcGlfaWRbMHgwMV0gbGFwaWNfaWRbMHgwMF0gZW5hYmxlZCkK WyAgICAwLjAwMDAwMF0gQUNQSTogTEFQSUMgKGFjcGlfaWRbMHgwMl0gbGFwaWNfaWRbMHgw Ml0gZW5hYmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQSTogTEFQSUMgKGFjcGlfaWRbMHgwM10g bGFwaWNfaWRbMHgwMV0gZW5hYmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQSTogTEFQSUMgKGFj cGlfaWRbMHgwNF0gbGFwaWNfaWRbMHgwM10gZW5hYmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQ STogTEFQSUMgKGFjcGlfaWRbMHgwNV0gbGFwaWNfaWRbMHgwNF0gZGlzYWJsZWQpClsgICAg MC4wMDAwMDBdIEFDUEk6IExBUElDIChhY3BpX2lkWzB4MDZdIGxhcGljX2lkWzB4MDVdIGRp c2FibGVkKQpbICAgIDAuMDAwMDAwXSBBQ1BJOiBMQVBJQyAoYWNwaV9pZFsweDA3XSBsYXBp Y19pZFsweDA2XSBkaXNhYmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQSTogTEFQSUMgKGFjcGlf aWRbMHgwOF0gbGFwaWNfaWRbMHgwN10gZGlzYWJsZWQpClsgICAgMC4wMDAwMDBdIEFDUEk6 IExBUElDIChhY3BpX2lkWzB4MDldIGxhcGljX2lkWzB4MDhdIGRpc2FibGVkKQpbICAgIDAu MDAwMDAwXSBBQ1BJOiBMQVBJQyAoYWNwaV9pZFsweDBhXSBsYXBpY19pZFsweDA5XSBkaXNh YmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQSTogTEFQSUMgKGFjcGlfaWRbMHgwYl0gbGFwaWNf aWRbMHgwYV0gZGlzYWJsZWQpClsgICAgMC4wMDAwMDBdIEFDUEk6IExBUElDIChhY3BpX2lk WzB4MGNdIGxhcGljX2lkWzB4MGJdIGRpc2FibGVkKQpbICAgIDAuMDAwMDAwXSBBQ1BJOiBM QVBJQyAoYWNwaV9pZFsweDBkXSBsYXBpY19pZFsweDBjXSBkaXNhYmxlZCkKWyAgICAwLjAw MDAwMF0gQUNQSTogTEFQSUMgKGFjcGlfaWRbMHgwZV0gbGFwaWNfaWRbMHgwZF0gZGlzYWJs ZWQpClsgICAgMC4wMDAwMDBdIEFDUEk6IExBUElDIChhY3BpX2lkWzB4MGZdIGxhcGljX2lk WzB4MGVdIGRpc2FibGVkKQpbICAgIDAuMDAwMDAwXSBBQ1BJOiBMQVBJQyAoYWNwaV9pZFsw eDEwXSBsYXBpY19pZFsweDBmXSBkaXNhYmxlZCkKWyAgICAwLjAwMDAwMF0gQUNQSTogSU9B UElDIChpZFsweDAyXSBhZGRyZXNzWzB4ZmVjMDAwMDBdIGdzaV9iYXNlWzBdKQpbICAgIDAu MDAwMDAwXSBJT0FQSUNbMF06IGFwaWNfaWQgMiwgdmVyc2lvbiAyNTMsIGFkZHJlc3MgMHhm ZWMwMDAwMCwgR1NJIDAtMjUzClsgICAgMC4wMDAwMDBdIEFDUEk6IElOVF9TUkNfT1ZSIChi dXMgMCBidXNfaXJxIDAgZ2xvYmFsX2lycSAyIGRmbCBkZmwpClsgICAgMC4wMDAwMDBdIEFD UEk6IElOVF9TUkNfT1ZSIChidXMgMCBidXNfaXJxIDkgZ2xvYmFsX2lycSA5IGhpZ2ggbGV2 ZWwpClsgICAgMC4wMDAwMDBdIEFDUEk6IElSUTAgdXNlZCBieSBvdmVycmlkZS4KWyAgICAw LjAwMDAwMF0gQUNQSTogSVJRMiB1c2VkIGJ5IG92ZXJyaWRlLgpbICAgIDAuMDAwMDAwXSBB Q1BJOiBJUlE5IHVzZWQgYnkgb3ZlcnJpZGUuClsgICAgMC4wMDAwMDBdIFVzaW5nIEFDUEkg KE1BRFQpIGZvciBTTVAgY29uZmlndXJhdGlvbiBpbmZvcm1hdGlvbgpbICAgIDAuMDAwMDAw XSBBQ1BJOiBIUEVUIGlkOiAweDgwODZhNzAxIGJhc2U6IDB4ZmVkMDAwMDAKWyAgICAwLjAw MDAwMF0gU01QOiBBbGxvd2luZyAxNiBDUFVzLCAxMiBob3RwbHVnIENQVXMKWyAgICAwLjAw MDAwMF0gbnJfaXJxc19nc2k6IDI3MApbICAgIDAuMDAwMDAwXSBBbGxvY2F0aW5nIFBDSSBy ZXNvdXJjZXMgc3RhcnRpbmcgYXQgY2ZhMDAwMDAgKGdhcDogY2ZhMDAwMDA6MmYyMDAwMDAp ClsgICAgMC4wMDAwMDBdIEJvb3RpbmcgcGFyYXZpcnR1YWxpemVkIGtlcm5lbCBvbiBYZW4K WyAgICAwLjAwMDAwMF0gWGVuIHZlcnNpb246IDQuMS4zIChwcmVzZXJ2ZS1BRCkKWyAgICAw LjAwMDAwMF0gc2V0dXBfcGVyY3B1OiBOUl9DUFVTOjUxMiBucl9jcHVtYXNrX2JpdHM6NTEy IG5yX2NwdV9pZHM6MTYgbnJfbm9kZV9pZHM6MQpbICAgIDAuMDAwMDAwXSBQRVJDUFU6IEVt YmVkZGVkIDI4IHBhZ2VzL2NwdSBAZmZmZjg4MDNlMjgwMDAwMCBzODIxNzYgcjgxOTIgZDI0 MzIwIHUxMzEwNzIKWyAgICAwLjAwMDAwMF0gcGNwdS1hbGxvYzogczgyMTc2IHI4MTkyIGQy NDMyMCB1MTMxMDcyIGFsbG9jPTEqMjA5NzE1MgpbICAgIDAuMDAwMDAwXSBwY3B1LWFsbG9j OiBbMF0gMDAgMDEgMDIgMDMgMDQgMDUgMDYgMDcgMDggMDkgMTAgMTEgMTIgMTMgMTQgMTUg ClsgICAgNC4xMTk4MDVdIEJ1aWx0IDEgem9uZWxpc3RzIGluIFpvbmUgb3JkZXIsIG1vYmls aXR5IGdyb3VwaW5nIG9uLiAgVG90YWwgcGFnZXM6IDQxMDE2MDAKWyAgICA0LjExOTgwOV0g S2VybmVsIGNvbW1hbmQgbGluZTogcm8gcm9vdD0vZGV2L21hcHBlci92Z19kb20wLWx2X3Jv b3QgcmRfTFVLU19VVUlEPWx1a3MtNDAwMzM2ZmEtYzdjNC00YmUzLWEyNDQtYzkwOWFhMTZh MThjIHJkX0xWTV9MVj12Z19kb20wL2x2X3Jvb3QgcmRfTFZNX0xWPXZnX2RvbTAvbHZfc3dh cCByZF9OT19NRCByZF9OT19ETSBMQU5HPWVuX1VTLlVURi04IFNZU0ZPTlQ9bGF0YXJjeXJo ZWItc3VuMTYgS0VZVEFCTEU9cGwyIHJoZ2IgcXVpZXQgbWF4X2xvb3A9MjU1ClsgICAgNC4x MTk5MTVdIFBJRCBoYXNoIHRhYmxlIGVudHJpZXM6IDQwOTYgKG9yZGVyOiAzLCAzMjc2OCBi eXRlcykKWyAgICA0LjEyMDkyOF0gRGVudHJ5IGNhY2hlIGhhc2ggdGFibGUgZW50cmllczog MjA5NzE1MiAob3JkZXI6IDEyLCAxNjc3NzIxNiBieXRlcykKWyAgICA0LjEyNDAxOF0gSW5v ZGUtY2FjaGUgaGFzaCB0YWJsZSBlbnRyaWVzOiAxMDQ4NTc2IChvcmRlcjogMTEsIDgzODg2 MDggYnl0ZXMpClsgICAgNC4xNDcwNjRdIFBsYWNpbmcgNjRNQiBzb2Z0d2FyZSBJTyBUTEIg YmV0d2VlbiBmZmZmODgwM2NlMjAwMDAwIC0gZmZmZjg4MDNkMjIwMDAwMApbICAgIDQuMTQ3 MDY2XSBzb2Z0d2FyZSBJTyBUTEIgYXQgcGh5cyAweDNjZTIwMDAwMCAtIDB4M2QyMjAwMDAw ClsgICAgNC4xODE2NzVdIE1lbW9yeTogMTQ5NzU5NDBrLzE3NTMwODgwayBhdmFpbGFibGUg KDQ1NTdrIGtlcm5lbCBjb2RlLCA4Nzg1MTJrIGFic2VudCwgMTY3NjQyOGsgcmVzZXJ2ZWQs IDQxMTJrIGRhdGEsIDU1MmsgaW5pdCkKWyAgICA0LjE4MTczMF0gSGllcmFyY2hpY2FsIFJD VSBpbXBsZW1lbnRhdGlvbi4KWyAgICA0LjE4MTczMV0gCVJDVSBkeW50aWNrLWlkbGUgZ3Jh Y2UtcGVyaW9kIGFjY2VsZXJhdGlvbiBpcyBlbmFibGVkLgpbICAgIDQuMTgxNzM4XSBOUl9J UlFTOjMzMDI0IG5yX2lycXM6MTAyNCAxNgpbICAgIDQuMTgxNzk5XSB4ZW46IHNjaSBvdmVy cmlkZTogZ2xvYmFsX2lycT05IHRyaWdnZXI9MCBwb2xhcml0eT0wClsgICAgNC4xODE4MDFd IHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDkgdHJpZ2dlcmluZyAwIHBvbGFyaXR5IDAKWyAgICA0 LjE4MTgwOV0geGVuOiAtLT4gcGlycT05IC0+IGlycT05IChnc2k9OSkKWyAgICA0LjE4MTgy OV0geGVuOiBhY3BpIHNjaSA5ClsgICAgNC4xODE4MzFdIHhlbjogLS0+IHBpcnE9MSAtPiBp cnE9MSAoZ3NpPTEpClsgICAgNC4xODE4MzRdIHhlbjogLS0+IHBpcnE9MiAtPiBpcnE9MiAo Z3NpPTIpClsgICAgNC4xODE4MzZdIHhlbjogLS0+IHBpcnE9MyAtPiBpcnE9MyAoZ3NpPTMp ClsgICAgNC4xODE4MzhdIHhlbjogLS0+IHBpcnE9NCAtPiBpcnE9NCAoZ3NpPTQpClsgICAg NC4xODE4NDBdIHhlbjogLS0+IHBpcnE9NSAtPiBpcnE9NSAoZ3NpPTUpClsgICAgNC4xODE4 NDNdIHhlbjogLS0+IHBpcnE9NiAtPiBpcnE9NiAoZ3NpPTYpClsgICAgNC4xODE4NDVdIHhl bjogLS0+IHBpcnE9NyAtPiBpcnE9NyAoZ3NpPTcpClsgICAgNC4xODE4NDddIHhlbjogLS0+ IHBpcnE9OCAtPiBpcnE9OCAoZ3NpPTgpClsgICAgNC4xODE4NDldIHhlbjogLS0+IHBpcnE9 MTAgLT4gaXJxPTEwIChnc2k9MTApClsgICAgNC4xODE4NTFdIHhlbjogLS0+IHBpcnE9MTEg LT4gaXJxPTExIChnc2k9MTEpClsgICAgNC4xODE4NTRdIHhlbjogLS0+IHBpcnE9MTIgLT4g aXJxPTEyIChnc2k9MTIpClsgICAgNC4xODE4NTZdIHhlbjogLS0+IHBpcnE9MTMgLT4gaXJx PTEzIChnc2k9MTMpClsgICAgNC4xODE4NThdIHhlbjogLS0+IHBpcnE9MTQgLT4gaXJxPTE0 IChnc2k9MTQpClsgICAgNC4xODE4NjBdIHhlbjogLS0+IHBpcnE9MTUgLT4gaXJxPTE1IChn c2k9MTUpClsgICAgNC4xODI5ODZdIENvbnNvbGU6IGNvbG91ciBWR0ErIDgweDI1ClsgICAg NC4xODMwMTJdIGNvbnNvbGUgW3R0eTBdIGVuYWJsZWQKWyAgICA0LjE4MzAyNl0gWGVuOiB1 c2luZyB2Y3B1b3AgdGltZXIgaW50ZXJmYWNlClsgICAgNC4xODMwMzBdIGluc3RhbGxpbmcg WGVuIHRpbWVyIGZvciBDUFUgMApbICAgIDQuMTgzMDQ4XSBEZXRlY3RlZCAyNDk0LjQxNiBN SHogcHJvY2Vzc29yLgpbICAgIDQuMTgzMDUyXSBDYWxpYnJhdGluZyBkZWxheSBsb29wIChz a2lwcGVkKSwgdmFsdWUgY2FsY3VsYXRlZCB1c2luZyB0aW1lciBmcmVxdWVuY3kuLiA0OTg4 LjgzIEJvZ29NSVBTIChscGo9OTk3NzY2NCkKWyAgICA0LjE4MzA1NF0gcGlkX21heDogZGVm YXVsdDogMzI3NjggbWluaW11bTogMzAxClsgICAgNC4xODMwOTBdIE1vdW50LWNhY2hlIGhh c2ggdGFibGUgZW50cmllczogMjU2ClsgICAgNC4xODMyMjJdIEluaXRpYWxpemluZyBjZ3Jv dXAgc3Vic3lzIGNwdWFjY3QKWyAgICA0LjE4MzIyNF0gSW5pdGlhbGl6aW5nIGNncm91cCBz dWJzeXMgZGV2aWNlcwpbICAgIDQuMTgzMjI1XSBJbml0aWFsaXppbmcgY2dyb3VwIHN1YnN5 cyBmcmVlemVyClsgICAgNC4xODMyMjddIEluaXRpYWxpemluZyBjZ3JvdXAgc3Vic3lzIG5l dF9jbHMKWyAgICA0LjE4MzIyOF0gSW5pdGlhbGl6aW5nIGNncm91cCBzdWJzeXMgYmxraW8K WyAgICA0LjE4MzI4MF0gRU5FUkdZX1BFUkZfQklBUzogU2V0IHRvICdub3JtYWwnLCB3YXMg J3BlcmZvcm1hbmNlJwpbICAgIDQuMTgzMjgxXSBFTkVSR1lfUEVSRl9CSUFTOiBWaWV3IGFu ZCB1cGRhdGUgd2l0aCB4ODZfZW5lcmd5X3BlcmZfcG9saWN5KDgpClsgICAgNC4xODMyODRd IENQVTogUGh5c2ljYWwgUHJvY2Vzc29yIElEOiAwClsgICAgNC4xODMyODVdIENQVTogUHJv Y2Vzc29yIENvcmUgSUQ6IDAKWyAgICA0LjE4NDQ1NF0gQUNQSTogQ29yZSByZXZpc2lvbiAy MDEyMDMyMApbICAgIDQuMTk0NjU4XSBQZXJmb3JtYW5jZSBFdmVudHM6IHVuc3VwcG9ydGVk IHA2IENQVSBtb2RlbCA0MiBubyBQTVUgZHJpdmVyLCBzb2Z0d2FyZSBldmVudHMgb25seS4K WyAgICA0LjE5NDc5Nl0gaW5zdGFsbGluZyBYZW4gdGltZXIgZm9yIENQVSAxClsgICAgNC4x OTQ5ODhdIGluc3RhbGxpbmcgWGVuIHRpbWVyIGZvciBDUFUgMgpbICAgIDQuMTk1MTQwXSBp bnN0YWxsaW5nIFhlbiB0aW1lciBmb3IgQ1BVIDMKWyAgICA0LjE5NTIzMl0gQnJvdWdodCB1 cCA0IENQVXMKWyAgICA0LjE5NTQ3N10gZGV2dG1wZnM6IGluaXRpYWxpemVkClsgICAgNC4x OTkwNDZdIFBNOiBSZWdpc3RlcmluZyBBQ1BJIE5WUyByZWdpb24gW21lbSAweDA3ZWVhMDAw LTB4MDdmNjZmZmZdICg1MTIwMDAgYnl0ZXMpClsgICAgNC4xOTkwNTZdIFBNOiBSZWdpc3Rl cmluZyBBQ1BJIE5WUyByZWdpb24gW21lbSAweDA3ZjcwMDAwLTB4MDdmNzVmZmZdICgyNDU3 NiBieXRlcykKWyAgICA0LjE5OTA1OF0gUE06IFJlZ2lzdGVyaW5nIEFDUEkgTlZTIHJlZ2lv biBbbWVtIDB4MDdmNzgwMDAtMHgwN2ZmZmZmZl0gKDU1NzA1NiBieXRlcykKWyAgICA0LjE5 OTA2OV0gRGVsbCBMYXRpdHVkZSBFNjQyMCBzZXJpZXMgYm9hcmQgZGV0ZWN0ZWQuIFNlbGVj dGluZyBQQ0ktbWV0aG9kIGZvciByZWJvb3RzLgpbICAgIDQuMTk5MTA0XSBHcmFudCB0YWJs ZXMgdXNpbmcgdmVyc2lvbiAyIGxheW91dC4KWyAgICA0LjE5OTExNF0gR3JhbnQgdGFibGUg aW5pdGlhbGl6ZWQKWyAgICA0LjE5OTE1OF0gZHVtbXk6IApbICAgIDQuMTk5MjA1XSBSVEMg dGltZTogIDE6MTk6MzUsIGRhdGU6IDExLzI5LzEyClsgICAgNC4xOTkyNTZdIE5FVDogUmVn aXN0ZXJlZCBwcm90b2NvbCBmYW1pbHkgMTYKWyAgICA0LjE5OTQ2NV0gQUNQSSBGQURUIGRl Y2xhcmVzIHRoZSBzeXN0ZW0gZG9lc24ndCBzdXBwb3J0IFBDSWUgQVNQTSwgc28gZGlzYWJs ZSBpdApbICAgIDQuMTk5NDY3XSBBQ1BJOiBidXMgdHlwZSBwY2kgcmVnaXN0ZXJlZApbICAg IDQuMTk5NTQ4XSBQQ0k6IE1NQ09ORklHIGZvciBkb21haW4gMDAwMCBbYnVzIDAwLTNmXSBh dCBbbWVtIDB4ZjgwMDAwMDAtMHhmYmZmZmZmZl0gKGJhc2UgMHhmODAwMDAwMCkKWyAgICA0 LjE5OTU1MF0gUENJOiBub3QgdXNpbmcgTU1DT05GSUcKWyAgICA0LjE5OTU1Ml0gUENJOiBV c2luZyBjb25maWd1cmF0aW9uIHR5cGUgMSBmb3IgYmFzZSBhY2Nlc3MKWyAgICA0LjE5OTU1 OV0gZG1pIHR5cGUgMHhCMSByZWNvcmQgLSB1bmtub3duIGZsYWcKWyAgICA0LjIwMDE1NV0g YmlvOiBjcmVhdGUgc2xhYiA8YmlvLTA+IGF0IDAKWyAgICA0LjIwMDI3OV0gQUNQSTogQWRk ZWQgX09TSShNb2R1bGUgRGV2aWNlKQpbICAgIDQuMjAwMjgwXSBBQ1BJOiBBZGRlZCBfT1NJ KFByb2Nlc3NvciBEZXZpY2UpClsgICAgNC4yMDAyODJdIEFDUEk6IEFkZGVkIF9PU0koMy4w IF9TQ1AgRXh0ZW5zaW9ucykKWyAgICA0LjIwMDI4M10gQUNQSTogQWRkZWQgX09TSShQcm9j ZXNzb3IgQWdncmVnYXRvciBEZXZpY2UpClsgICAgNC4yMDE4MTVdIEFDUEk6IEVDOiBMb29r IHVwIEVDIGluIERTRFQKWyAgICA0LjIwNjkzMl0gW0Zpcm13YXJlIEJ1Z106IEFDUEk6IEJJ T1MgX09TSShMaW51eCkgcXVlcnkgaWdub3JlZApbICAgIDQuMjE5MjY2XSBBQ1BJOiBTU0RU IDAwMDAwMDAwYzg0MTI3OTggMDA3MjcgKHYwMSAgUG1SZWYgIENwdTBDc3QgMDAwMDMwMDEg SU5UTCAyMDA5MDkwMykKWyAgICA0LjIxOTY1NF0gQUNQSTogRHluYW1pYyBPRU0gVGFibGUg TG9hZDoKWyAgICA0LjIxOTY1N10gQUNQSTogU1NEVCAgICAgICAgICAgKG51bGwpIDAwNzI3 ICh2MDEgIFBtUmVmICBDcHUwQ3N0IDAwMDAzMDAxIElOVEwgMjAwOTA5MDMpClsgICAgNC4y MjAxMThdIEFDUEk6IFNTRFQgMDAwMDAwMDBjODQxM2E5OCAwMDMwMyAodjAxICBQbVJlZiAg ICBBcElzdCAwMDAwMzAwMCBJTlRMIDIwMDkwOTAzKQpbICAgIDQuMjIwNTU1XSBBQ1BJOiBE eW5hbWljIE9FTSBUYWJsZSBMb2FkOgpbICAgIDQuMjIwNTU4XSBBQ1BJOiBTU0RUICAgICAg ICAgICAobnVsbCkgMDAzMDMgKHYwMSAgUG1SZWYgICAgQXBJc3QgMDAwMDMwMDAgSU5UTCAy MDA5MDkwMykKWyAgICA0LjIyMDc1NF0gQUNQSTogU1NEVCAwMDAwMDAwMGM4NDExZDk4IDAw MTE5ICh2MDEgIFBtUmVmICAgIEFwQ3N0IDAwMDAzMDAwIElOVEwgMjAwOTA5MDMpClsgICAg NC4yMjExMzZdIEFDUEk6IER5bmFtaWMgT0VNIFRhYmxlIExvYWQ6ClsgICAgNC4yMjExMzhd IEFDUEk6IFNTRFQgICAgICAgICAgIChudWxsKSAwMDExOSAodjAxICBQbVJlZiAgICBBcENz dCAwMDAwMzAwMCBJTlRMIDIwMDkwOTAzKQpbICAgIDQuMjIzMjc1XSBBQ1BJOiBJbnRlcnBy ZXRlciBlbmFibGVkClsgICAgNC4yMjMyNzhdIEFDUEk6IChzdXBwb3J0cyBTMCBTMyBTNSkK WyAgICA0LjIyMzI5NF0gQUNQSTogVXNpbmcgSU9BUElDIGZvciBpbnRlcnJ1cHQgcm91dGlu ZwpbICAgIDQuMjIzMzIyXSBQQ0k6IE1NQ09ORklHIGZvciBkb21haW4gMDAwMCBbYnVzIDAw LTNmXSBhdCBbbWVtIDB4ZjgwMDAwMDAtMHhmYmZmZmZmZl0gKGJhc2UgMHhmODAwMDAwMCkK WyAgICA0LjIyMzg0Nl0gUENJOiBNTUNPTkZJRyBhdCBbbWVtIDB4ZjgwMDAwMDAtMHhmYmZm ZmZmZl0gcmVzZXJ2ZWQgaW4gQUNQSSBtb3RoZXJib2FyZCByZXNvdXJjZXMKWyAgICA0LjI3 MTI4M10gQUNQSTogRUM6IEdQRSA9IDB4MTAsIEkvTzogY29tbWFuZC9zdGF0dXMgPSAweDkz NCwgZGF0YSA9IDB4OTMwClsgICAgNC4yNzI0MjRdIEFDUEk6IE5vIGRvY2sgZGV2aWNlcyBm b3VuZC4KWyAgICA0LjI3MjQyOF0gUENJOiBVc2luZyBob3N0IGJyaWRnZSB3aW5kb3dzIGZy b20gQUNQSTsgaWYgbmVjZXNzYXJ5LCB1c2UgInBjaT1ub2NycyIgYW5kIHJlcG9ydCBhIGJ1 ZwpbICAgIDQuMjcyOTg4XSBcX1NCXy5QQ0kwOl9PU0MgaW52YWxpZCBVVUlEClsgICAgNC4y NzI5ODldIF9PU0MgcmVxdWVzdCBkYXRhOjEgOCAxZiAKWyAgICA0LjI3Mjk5Ml0gQUNQSTog UENJIFJvb3QgQnJpZGdlIFtQQ0kwXSAoZG9tYWluIDAwMDAgW2J1cyAwMC0zZV0pClsgICAg NC4yNzM5OTRdIHBjaV9yb290IFBOUDBBMDg6MDA6IGhvc3QgYnJpZGdlIHdpbmRvdyBbaW8g IDB4MDAwMC0weDBjZjddClsgICAgNC4yNzM5OTZdIHBjaV9yb290IFBOUDBBMDg6MDA6IGhv c3QgYnJpZGdlIHdpbmRvdyBbaW8gIDB4MGQwMC0weGZmZmZdClsgICAgNC4yNzM5OThdIHBj aV9yb290IFBOUDBBMDg6MDA6IGhvc3QgYnJpZGdlIHdpbmRvdyBbbWVtIDB4MDAwYTAwMDAt MHgwMDBiZmZmZl0KWyAgICA0LjI3NDAwMV0gcGNpX3Jvb3QgUE5QMEEwODowMDogaG9zdCBi cmlkZ2Ugd2luZG93IFttZW0gMHhjZmEwMDAwMC0weGZlYWZmZmZmXQpbICAgIDQuMjc0MDAz XSBwY2lfcm9vdCBQTlAwQTA4OjAwOiBob3N0IGJyaWRnZSB3aW5kb3cgW21lbSAweGZlZDQw MDAwLTB4ZmVkNDRmZmZdClsgICAgNC4yNzQwMzFdIFBDSSBob3N0IGJyaWRnZSB0byBidXMg MDAwMDowMApbICAgIDQuMjc0MDMzXSBwY2lfYnVzIDAwMDA6MDA6IHJvb3QgYnVzIHJlc291 cmNlIFtpbyAgMHgwMDAwLTB4MGNmN10KWyAgICA0LjI3NDAzNF0gcGNpX2J1cyAwMDAwOjAw OiByb290IGJ1cyByZXNvdXJjZSBbaW8gIDB4MGQwMC0weGZmZmZdClsgICAgNC4yNzQwMzZd IHBjaV9idXMgMDAwMDowMDogcm9vdCBidXMgcmVzb3VyY2UgW21lbSAweDAwMGEwMDAwLTB4 MDAwYmZmZmZdClsgICAgNC4yNzQwMzhdIHBjaV9idXMgMDAwMDowMDogcm9vdCBidXMgcmVz b3VyY2UgW21lbSAweGNmYTAwMDAwLTB4ZmVhZmZmZmZdClsgICAgNC4yNzQwNDBdIHBjaV9i dXMgMDAwMDowMDogcm9vdCBidXMgcmVzb3VyY2UgW21lbSAweGZlZDQwMDAwLTB4ZmVkNDRm ZmZdClsgICAgNC4yNzQwNTRdIHBjaSAwMDAwOjAwOjAwLjA6IFs4MDg2OjAxMDRdIHR5cGUg MDAgY2xhc3MgMHgwNjAwMDAKWyAgICA0LjI3NDE0N10gcGNpIDAwMDA6MDA6MDIuMDogWzgw ODY6MDEyNl0gdHlwZSAwMCBjbGFzcyAweDAzMDAwMApbICAgIDQuMjc0MTc0XSBwY2kgMDAw MDowMDowMi4wOiByZWcgMTA6IFttZW0gMHhlMTQwMDAwMC0weGUxN2ZmZmZmIDY0Yml0XQpb ICAgIDQuMjc0MTg5XSBwY2kgMDAwMDowMDowMi4wOiByZWcgMTg6IFttZW0gMHhkMDAwMDAw MC0weGRmZmZmZmZmIDY0Yml0IHByZWZdClsgICAgNC4yNzQyMDBdIHBjaSAwMDAwOjAwOjAy LjA6IHJlZyAyMDogW2lvICAweDQwMDAtMHg0MDNmXQpbICAgIDQuMjc0MzQ0XSBwY2kgMDAw MDowMDoxNi4wOiBbODA4NjoxYzNhXSB0eXBlIDAwIGNsYXNzIDB4MDc4MDAwClsgICAgNC4y NzQzOTRdIHBjaSAwMDAwOjAwOjE2LjA6IHJlZyAxMDogW21lbSAweGUyZWIwMDAwLTB4ZTJl YjAwMGYgNjRiaXRdClsgICAgNC4yNzQ1NjNdIHBjaSAwMDAwOjAwOjE2LjA6IFBNRSMgc3Vw cG9ydGVkIGZyb20gRDAgRDNob3QgRDNjb2xkClsgICAgNC4yNzQ2MzZdIHBjaSAwMDAwOjAw OjE5LjA6IFs4MDg2OjE1MDJdIHR5cGUgMDAgY2xhc3MgMHgwMjAwMDAKWyAgICA0LjI3NDY4 MV0gcGNpIDAwMDA6MDA6MTkuMDogcmVnIDEwOiBbbWVtIDB4ZTJlMDAwMDAtMHhlMmUxZmZm Zl0KWyAgICA0LjI3NDcwMF0gcGNpIDAwMDA6MDA6MTkuMDogcmVnIDE0OiBbbWVtIDB4ZTJl ODAwMDAtMHhlMmU4MGZmZl0KWyAgICA0LjI3NDcxOV0gcGNpIDAwMDA6MDA6MTkuMDogcmVn IDE4OiBbaW8gIDB4NDA4MC0weDQwOWZdClsgICAgNC4yNzQ4ODNdIHBjaSAwMDAwOjAwOjE5 LjA6IFBNRSMgc3VwcG9ydGVkIGZyb20gRDAgRDNob3QgRDNjb2xkClsgICAgNC4yNzQ5Mzld IHBjaSAwMDAwOjAwOjFhLjA6IFs4MDg2OjFjMmRdIHR5cGUgMDAgY2xhc3MgMHgwYzAzMjAK WyAgICA0LjI3NDk4M10gcGNpIDAwMDA6MDA6MWEuMDogcmVnIDEwOiBbbWVtIDB4ZTJlNzAw MDAtMHhlMmU3MDNmZl0KWyAgICA0LjI3NTE4NV0gcGNpIDAwMDA6MDA6MWEuMDogUE1FIyBz dXBwb3J0ZWQgZnJvbSBEMCBEM2hvdCBEM2NvbGQKWyAgICA0LjI3NTI0M10gcGNpIDAwMDA6 MDA6MWIuMDogWzgwODY6MWMyMF0gdHlwZSAwMCBjbGFzcyAweDA0MDMwMApbICAgIDQuMjc1 Mjc4XSBwY2kgMDAwMDowMDoxYi4wOiByZWcgMTA6IFttZW0gMHhlMmU2MDAwMC0weGUyZTYz ZmZmIDY0Yml0XQpbICAgIDQuMjc1NDU2XSBwY2kgMDAwMDowMDoxYi4wOiBQTUUjIHN1cHBv cnRlZCBmcm9tIEQwIEQzaG90IEQzY29sZApbICAgIDQuMjc1NTA5XSBwY2kgMDAwMDowMDox Yy4wOiBbODA4NjoxYzEwXSB0eXBlIDAxIGNsYXNzIDB4MDYwNDAwClsgICAgNC4yNzU3MDJd IHBjaSAwMDAwOjAwOjFjLjA6IFBNRSMgc3VwcG9ydGVkIGZyb20gRDAgRDNob3QgRDNjb2xk ClsgICAgNC4yNzU3NjBdIHBjaSAwMDAwOjAwOjFjLjE6IFs4MDg2OjFjMTJdIHR5cGUgMDEg Y2xhc3MgMHgwNjA0MDAKWyAgICA0LjI3NTk1M10gcGNpIDAwMDA6MDA6MWMuMTogUE1FIyBz dXBwb3J0ZWQgZnJvbSBEMCBEM2hvdCBEM2NvbGQKWyAgICA0LjI3NjAxMV0gcGNpIDAwMDA6 MDA6MWMuMjogWzgwODY6MWMxNF0gdHlwZSAwMSBjbGFzcyAweDA2MDQwMApbICAgIDQuMjc2 MjA1XSBwY2kgMDAwMDowMDoxYy4yOiBQTUUjIHN1cHBvcnRlZCBmcm9tIEQwIEQzaG90IEQz Y29sZApbICAgIDQuMjc2MjY0XSBwY2kgMDAwMDowMDoxYy4zOiBbODA4NjoxYzE2XSB0eXBl IDAxIGNsYXNzIDB4MDYwNDAwClsgICAgNC4yNzY0NThdIHBjaSAwMDAwOjAwOjFjLjM6IFBN RSMgc3VwcG9ydGVkIGZyb20gRDAgRDNob3QgRDNjb2xkClsgICAgNC4yNzY1MjBdIHBjaSAw MDAwOjAwOjFjLjU6IFs4MDg2OjFjMWFdIHR5cGUgMDEgY2xhc3MgMHgwNjA0MDAKWyAgICA0 LjI3NjcxMV0gcGNpIDAwMDA6MDA6MWMuNTogUE1FIyBzdXBwb3J0ZWQgZnJvbSBEMCBEM2hv dCBEM2NvbGQKWyAgICA0LjI3Njc3OV0gcGNpIDAwMDA6MDA6MWQuMDogWzgwODY6MWMyNl0g dHlwZSAwMCBjbGFzcyAweDBjMDMyMApbICAgIDQuMjc2ODIzXSBwY2kgMDAwMDowMDoxZC4w OiByZWcgMTA6IFttZW0gMHhlMmU1MDAwMC0weGUyZTUwM2ZmXQpbICAgIDQuMjc3MDI1XSBw Y2kgMDAwMDowMDoxZC4wOiBQTUUjIHN1cHBvcnRlZCBmcm9tIEQwIEQzaG90IEQzY29sZApb ICAgIDQuMjc3MDg2XSBwY2kgMDAwMDowMDoxZi4wOiBbODA4NjoxYzRmXSB0eXBlIDAwIGNs YXNzIDB4MDYwMTAwClsgICAgNC4yNzczNDFdIHBjaSAwMDAwOjAwOjFmLjI6IFs4MDg2OjFj MDNdIHR5cGUgMDAgY2xhc3MgMHgwMTA2MDEKWyAgICA0LjI3NzM5MV0gcGNpIDAwMDA6MDA6 MWYuMjogcmVnIDEwOiBbaW8gIDB4NDBkMC0weDQwZDddClsgICAgNC4yNzc0MTBdIHBjaSAw MDAwOjAwOjFmLjI6IHJlZyAxNDogW2lvICAweDQwYzAtMHg0MGMzXQpbICAgIDQuMjc3NDI5 XSBwY2kgMDAwMDowMDoxZi4yOiByZWcgMTg6IFtpbyAgMHg0MGIwLTB4NDBiN10KWyAgICA0 LjI3NzQ0OV0gcGNpIDAwMDA6MDA6MWYuMjogcmVnIDFjOiBbaW8gIDB4NDBhMC0weDQwYTNd ClsgICAgNC4yNzc0NjhdIHBjaSAwMDAwOjAwOjFmLjI6IHJlZyAyMDogW2lvICAweDQwNjAt MHg0MDdmXQpbICAgIDQuMjc3NDg2XSBwY2kgMDAwMDowMDoxZi4yOiByZWcgMjQ6IFttZW0g MHhlMmU0MDAwMC0weGUyZTQwN2ZmXQpbICAgIDQuMjc3NjEzXSBwY2kgMDAwMDowMDoxZi4y OiBQTUUjIHN1cHBvcnRlZCBmcm9tIEQzaG90ClsgICAgNC4yNzc2NTddIHBjaSAwMDAwOjAw OjFmLjM6IFs4MDg2OjFjMjJdIHR5cGUgMDAgY2xhc3MgMHgwYzA1MDAKWyAgICA0LjI3NzY5 NF0gcGNpIDAwMDA6MDA6MWYuMzogcmVnIDEwOiBbbWVtIDB4ZTJlMzAwMDAtMHhlMmUzMDBm ZiA2NGJpdF0KWyAgICA0LjI3Nzc0OV0gcGNpIDAwMDA6MDA6MWYuMzogcmVnIDIwOiBbaW8g IDB4NDA0MC0weDQwNWZdClsgICAgNC4yNzc5MjBdIHBjaSAwMDAwOjAwOjFjLjA6IFBDSSBi cmlkZ2UgdG8gW2J1cyAwMS0wMV0KWyAgICA0LjI3ODM1M10gcGNpIDAwMDA6MDI6MDAuMDog WzgwODY6NDIyYl0gdHlwZSAwMCBjbGFzcyAweDAyODAwMApbICAgIDQuMjc4NzA4XSBwY2kg MDAwMDowMjowMC4wOiByZWcgMTA6IFttZW0gMHhlMmQwMDAwMC0weGUyZDAxZmZmIDY0Yml0 XQpbICAgIDQuMjgwNTA4XSBwY2kgMDAwMDowMjowMC4wOiBQTUUjIHN1cHBvcnRlZCBmcm9t IEQwIEQzaG90IEQzY29sZApbICAgIDQuMjg1MzYxXSBwY2kgMDAwMDowMDoxYy4xOiBQQ0kg YnJpZGdlIHRvIFtidXMgMDItMDJdClsgICAgNC4yODUzNzRdIHBjaSAwMDAwOjAwOjFjLjE6 ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTJkMDAwMDAtMHhlMmRmZmZmZl0KWyAgICA0LjI4 NTQ5MF0gcGNpIDAwMDA6MDA6MWMuMjogUENJIGJyaWRnZSB0byBbYnVzIDAzLTA4XQpbICAg IDQuMjg1NDk4XSBwY2kgMDAwMDowMDoxYy4yOiAgIGJyaWRnZSB3aW5kb3cgW2lvICAweDMw MDAtMHgzZmZmXQpbICAgIDQuMjg1NTA1XSBwY2kgMDAwMDowMDoxYy4yOiAgIGJyaWRnZSB3 aW5kb3cgW21lbSAweGUyMjAwMDAwLTB4ZTJiZmZmZmZdClsgICAgNC4yODU1MTddIHBjaSAw MDAwOjAwOjFjLjI6ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTBhMDAwMDAtMHhlMTNmZmZm ZiA2NGJpdCBwcmVmXQpbICAgIDQuMjg1NjI1XSBwY2kgMDAwMDowMDoxYy4zOiBQQ0kgYnJp ZGdlIHRvIFtidXMgMDktMDldClsgICAgNC4yODU2MzJdIHBjaSAwMDAwOjAwOjFjLjM6ICAg YnJpZGdlIHdpbmRvdyBbaW8gIDB4MjAwMC0weDJmZmZdClsgICAgNC4yODU2MzldIHBjaSAw MDAwOjAwOjFjLjM6ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTE4MDAwMDAtMHhlMjFmZmZm Zl0KWyAgICA0LjI4NTY1MV0gcGNpIDAwMDA6MDA6MWMuMzogICBicmlkZ2Ugd2luZG93IFtt ZW0gMHhlMDAwMDAwMC0weGUwOWZmZmZmIDY0Yml0IHByZWZdClsgICAgNC4yODU4MThdIHBj aSAwMDAwOjBhOjAwLjA6IFsxMjE3OjgyMjFdIHR5cGUgMDAgY2xhc3MgMHgwODA1MDEKWyAg ICA0LjI4NTg3Ml0gcGNpIDAwMDA6MGE6MDAuMDogcmVnIDEwOiBbbWVtIDB4ZTJjMjAwMDAt MHhlMmMyMDFmZl0KWyAgICA0LjI4NjI5NF0gcGNpIDAwMDA6MGE6MDAuMDogc3VwcG9ydHMg RDEgRDIKWyAgICA0LjI4NjI5NV0gcGNpIDAwMDA6MGE6MDAuMDogUE1FIyBzdXBwb3J0ZWQg ZnJvbSBEMCBEMSBEMiBEM2hvdCBEM2NvbGQKWyAgICA0LjI4NjQzMl0gcGNpIDAwMDA6MGE6 MDAuMTogWzEyMTc6ODIzMV0gdHlwZSAwMCBjbGFzcyAweDAxODAwMApbICAgIDQuMjg2NDg2 XSBwY2kgMDAwMDowYTowMC4xOiByZWcgMTA6IFttZW0gMHhlMmMxMDAwMC0weGUyYzEwZmZm XQpbICAgIDQuMjg2NTYzXSBwY2kgMDAwMDowYTowMC4xOiByZWcgMTg6IFttZW0gMHhlMmMw MDAwMC0weGUyYzAwN2ZmXQpbICAgIDQuMjg2OTA4XSBwY2kgMDAwMDowYTowMC4xOiBzdXBw b3J0cyBEMSBEMgpbICAgIDQuMjg2OTA5XSBwY2kgMDAwMDowYTowMC4xOiBQTUUjIHN1cHBv cnRlZCBmcm9tIEQwIEQxIEQyIEQzaG90IEQzY29sZApbICAgIDQuMjkzNDAwXSBwY2kgMDAw MDowMDoxYy41OiBQQ0kgYnJpZGdlIHRvIFtidXMgMGEtMGFdClsgICAgNC4yOTM0MTJdIHBj aSAwMDAwOjAwOjFjLjU6ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTJjMDAwMDAtMHhlMmNm ZmZmZl0KWyAgICA0LjI5MzQ3OV0gcGNpX2J1cyAwMDAwOjAwOiBvbiBOVU1BIG5vZGUgMApb ICAgIDQuMjkzNDgzXSBBQ1BJOiBQQ0kgSW50ZXJydXB0IFJvdXRpbmcgVGFibGUgW1xfU0Jf LlBDSTAuX1BSVF0KWyAgICA0LjI5MzYxMl0gQUNQSTogUENJIEludGVycnVwdCBSb3V0aW5n IFRhYmxlIFtcX1NCXy5QQ0kwLlJQMDEuX1BSVF0KWyAgICA0LjI5MzY0N10gQUNQSTogUENJ IEludGVycnVwdCBSb3V0aW5nIFRhYmxlIFtcX1NCXy5QQ0kwLlJQMDIuX1BSVF0KWyAgICA0 LjI5MzY4Ml0gQUNQSTogUENJIEludGVycnVwdCBSb3V0aW5nIFRhYmxlIFtcX1NCXy5QQ0kw LlJQMDQuX1BSVF0KWyAgICA0LjI5MzcxN10gQUNQSTogUENJIEludGVycnVwdCBSb3V0aW5n IFRhYmxlIFtcX1NCXy5QQ0kwLlJQMDYuX1BSVF0KWyAgICA0LjI5Mzc2Ml0gQUNQSTogUENJ IEludGVycnVwdCBSb3V0aW5nIFRhYmxlIFtcX1NCXy5QQ0kwLlJQMDMuX1BSVF0KWyAgICA0 LjI5Mzg1N10gXF9TQl8uUENJMDpfT1NDIGludmFsaWQgVVVJRApbICAgIDQuMjkzODU4XSBf T1NDIHJlcXVlc3QgZGF0YToxIDFmIDFmIApbICAgIDQuMjkzODYxXSAgcGNpMDAwMDowMDog UmVxdWVzdGluZyBBQ1BJIF9PU0MgY29udHJvbCAoMHgxZCkKWyAgICA0LjI5MzkwNl0gXF9T Ql8uUENJMDpfT1NDIGludmFsaWQgVVVJRApbICAgIDQuMjkzOTA3XSBfT1NDIHJlcXVlc3Qg ZGF0YToxIDAgMWQgClsgICAgNC4yOTM5MTBdICBwY2kwMDAwOjAwOiBBQ1BJIF9PU0MgcmVx dWVzdCBmYWlsZWQgKEFFX0VSUk9SKSwgcmV0dXJuZWQgY29udHJvbCBtYXNrOiAweDFkClsg ICAgNC4yOTM5MTFdIEFDUEkgX09TQyBjb250cm9sIGZvciBQQ0llIG5vdCBncmFudGVkLCBk aXNhYmxpbmcgQVNQTQpbICAgIDQuMjk3NjM5XSBBQ1BJOiBQQ0kgSW50ZXJydXB0IExpbmsg W0xOS0FdIChJUlFzIDEgMyA0IDUgNiA3IDEwIDEyIDE0IDE1KSAqMTEKWyAgICA0LjI5Nzcw Ml0gQUNQSTogUENJIEludGVycnVwdCBMaW5rIFtMTktCXSAoSVJRcyAxIDMgNCA1IDYgNyAx MSAxMiAxNCAxNSkgKjEwClsgICAgNC4yOTc3NjFdIEFDUEk6IFBDSSBJbnRlcnJ1cHQgTGlu ayBbTE5LQ10gKElSUXMgMSAzIDQgNSA2IDcgMTAgMTIgMTQgMTUpICoxMQpbICAgIDQuMjk3 ODIwXSBBQ1BJOiBQQ0kgSW50ZXJydXB0IExpbmsgW0xOS0RdIChJUlFzIDEgMyA0IDUgNiA3 IDExIDEyIDE0IDE1KSAqMTAKWyAgICA0LjI5Nzg3OF0gQUNQSTogUENJIEludGVycnVwdCBM aW5rIFtMTktFXSAoSVJRcyAxIDMgNCAqNSA2IDcgMTAgMTIgMTQgMTUpClsgICAgNC4yOTc5 MzddIEFDUEk6IFBDSSBJbnRlcnJ1cHQgTGluayBbTE5LRl0gKElSUXMgMSAzIDQgNSA2IDcg MTEgMTIgMTQgMTUpICowLCBkaXNhYmxlZC4KWyAgICA0LjI5Nzk5Nl0gQUNQSTogUENJIElu dGVycnVwdCBMaW5rIFtMTktHXSAoSVJRcyAxICozIDQgNSA2IDcgMTAgMTIgMTQgMTUpClsg ICAgNC4yOTgwNTRdIEFDUEk6IFBDSSBJbnRlcnJ1cHQgTGluayBbTE5LSF0gKElSUXMgMSAz IDQgNSA2IDcgMTEgMTIgMTQgMTUpICowLCBkaXNhYmxlZC4KWyAgICA0LjI5ODA4N10geGVu L2JhbGxvb246IEluaXRpYWxpc2luZyBiYWxsb29uIGRyaXZlci4KWyAgICA0LjMwMTAyMl0g eGVuLWJhbGxvb246IEluaXRpYWxpc2luZyBiYWxsb29uIGRyaXZlci4KWyAgICA0LjMwMTA2 Ml0geGVuL2JhbGxvb246IFhlbiBzZWxmYmFsbG9vbmluZyBkcml2ZXIgZGlzYWJsZWQgZm9y IGRvbWFpbjAuClsgICAgNC4zMDExNDhdIHZnYWFyYjogZGV2aWNlIGFkZGVkOiBQQ0k6MDAw MDowMDowMi4wLGRlY29kZXM9aW8rbWVtLG93bnM9aW8rbWVtLGxvY2tzPW5vbmUKWyAgICA0 LjMwMTE1N10gdmdhYXJiOiBsb2FkZWQKWyAgICA0LjMwMTE1N10gdmdhYXJiOiBicmlkZ2Ug Y29udHJvbCBwb3NzaWJsZSAwMDAwOjAwOjAyLjAKWyAgICA0LjMwMTI3OV0gUENJOiBVc2lu ZyBBQ1BJIGZvciBJUlEgcm91dGluZwpbICAgIDQuMzA1OTMwXSBQQ0k6IHBjaV9jYWNoZV9s aW5lX3NpemUgc2V0IHRvIDY0IGJ5dGVzClsgICAgNC4zMDYxMDZdIHJlc2VydmUgUkFNIGJ1 ZmZlcjogMDAwMDAwMDAwMDA5YTAwMCAtIDAwMDAwMDAwMDAwOWZmZmYgClsgICAgNC4zMDYx MDhdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDAwN2VlYTAwMCAtIDAwMDAwMDAwMDdm ZmZmZmYgClsgICAgNC4zMDYxMTBdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDAwN2Y3 MDAwMCAtIDAwMDAwMDAwMDdmZmZmZmYgClsgICAgNC4zMDYxMTJdIHJlc2VydmUgUkFNIGJ1 ZmZlcjogMDAwMDAwMDAwN2Y3ODAwMCAtIDAwMDAwMDAwMDdmZmZmZmYgClsgICAgNC4zMDYx MTNdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDAwZGZmZDAwMCAtIDAwMDAwMDAwMGZm ZmZmZmYgClsgICAgNC4zMDYxMTVdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDBjODNi NDAwMCAtIDAwMDAwMDAwY2JmZmZmZmYgClsgICAgNC4zMDYxMThdIHJlc2VydmUgUkFNIGJ1 ZmZlcjogMDAwMDAwMDBjODQwZTAwMCAtIDAwMDAwMDAwY2JmZmZmZmYgClsgICAgNC4zMDYx MjFdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDBjODQxMTAwMCAtIDAwMDAwMDAwY2Jm ZmZmZmYgClsgICAgNC4zMDYxMjNdIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDBjODQx ZTAwMCAtIDAwMDAwMDAwY2JmZmZmZmYgClsgICAgNC4zMDYxMjVdIHJlc2VydmUgUkFNIGJ1 ZmZlcjogMDAwMDAwMDBjODQzMjAwMCAtIDAwMDAwMDAwY2JmZmZmZmYgClsgICAgNC4zMDYx MjddIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDBjYWMwMDAwMCAtIDAwMDAwMDAwY2Jm ZmZmZmYgClsgICAgNC4zMDYxMjldIHJlc2VydmUgUkFNIGJ1ZmZlcjogMDAwMDAwMDQyZTAw MDAwMCAtIDAwMDAwMDA0MmZmZmZmZmYgClsgICAgNC4zMDYyMzVdIFN3aXRjaGluZyB0byBj bG9ja3NvdXJjZSB4ZW4KWyAgICA0LjMwNzcyNl0gcG5wOiBQblAgQUNQSSBpbml0ClsgICAg NC4zMDc3MzhdIEFDUEk6IGJ1cyB0eXBlIHBucCByZWdpc3RlcmVkClsgICAgNC4zMDgyODdd IHBucCAwMDowMDogW2J1cyAwMC0zZV0KWyAgICA0LjMwODI4OV0gcG5wIDAwOjAwOiBbaW8g IDB4MDAwMC0weDBjZjcgd2luZG93XQpbICAgIDQuMzA4MjkxXSBwbnAgMDA6MDA6IFtpbyAg MHgwY2Y4LTB4MGNmZl0KWyAgICA0LjMwODI5M10gcG5wIDAwOjAwOiBbaW8gIDB4MGQwMC0w eGZmZmYgd2luZG93XQpbICAgIDQuMzA4Mjk1XSBwbnAgMDA6MDA6IFttZW0gMHgwMDBhMDAw MC0weDAwMGJmZmZmIHdpbmRvd10KWyAgICA0LjMwODI5Nl0gcG5wIDAwOjAwOiBbbWVtIDB4 MDAwYzAwMDAtMHgwMDBjM2ZmZiB3aW5kb3ddClsgICAgNC4zMDgyOThdIHBucCAwMDowMDog W21lbSAweDAwMGM0MDAwLTB4MDAwYzdmZmYgd2luZG93XQpbICAgIDQuMzA4MzAwXSBwbnAg MDA6MDA6IFttZW0gMHgwMDBjODAwMC0weDAwMGNiZmZmIHdpbmRvd10KWyAgICA0LjMwODMw MV0gcG5wIDAwOjAwOiBbbWVtIDB4MDAwY2MwMDAtMHgwMDBjZmZmZiB3aW5kb3ddClsgICAg NC4zMDgzMDNdIHBucCAwMDowMDogW21lbSAweDAwMGQwMDAwLTB4MDAwZDNmZmYgd2luZG93 XQpbICAgIDQuMzA4MzA1XSBwbnAgMDA6MDA6IFttZW0gMHgwMDBkNDAwMC0weDAwMGQ3ZmZm IHdpbmRvd10KWyAgICA0LjMwODMwN10gcG5wIDAwOjAwOiBbbWVtIDB4MDAwZDgwMDAtMHgw MDBkYmZmZiB3aW5kb3ddClsgICAgNC4zMDgzMDldIHBucCAwMDowMDogW21lbSAweDAwMGRj MDAwLTB4MDAwZGZmZmYgd2luZG93XQpbICAgIDQuMzA4MzEwXSBwbnAgMDA6MDA6IFttZW0g MHgwMDBlMDAwMC0weDAwMGUzZmZmIHdpbmRvd10KWyAgICA0LjMwODMxMl0gcG5wIDAwOjAw OiBbbWVtIDB4MDAwZTQwMDAtMHgwMDBlN2ZmZiB3aW5kb3ddClsgICAgNC4zMDgzMTRdIHBu cCAwMDowMDogW21lbSAweDAwMGU4MDAwLTB4MDAwZWJmZmYgd2luZG93XQpbICAgIDQuMzA4 MzE1XSBwbnAgMDA6MDA6IFttZW0gMHgwMDBlYzAwMC0weDAwMGVmZmZmIHdpbmRvd10KWyAg ICA0LjMwODMxN10gcG5wIDAwOjAwOiBbbWVtIDB4MDAwZjAwMDAtMHgwMDBmZmZmZiB3aW5k b3ddClsgICAgNC4zMDgzMTldIHBucCAwMDowMDogW21lbSAweGNmYTAwMDAwLTB4ZmVhZmZm ZmYgd2luZG93XQpbICAgIDQuMzA4MzIwXSBwbnAgMDA6MDA6IFttZW0gMHhmZWQ0MDAwMC0w eGZlZDQ0ZmZmIHdpbmRvd10KWyAgICA0LjMwODM4NV0gcG5wIDAwOjAwOiBQbHVnIGFuZCBQ bGF5IEFDUEkgZGV2aWNlLCBJRHMgUE5QMGEwOCBQTlAwYTAzIChhY3RpdmUpClsgICAgNC4z MDgzOThdIHBucCAwMDowMTogW2lvICAweDAwMDAtMHgwMDFmXQpbICAgIDQuMzA4NDAwXSBw bnAgMDA6MDE6IFtpbyAgMHgwMDgxLTB4MDA5MV0KWyAgICA0LjMwODQwMV0gcG5wIDAwOjAx OiBbaW8gIDB4MDA5My0weDAwOWZdClsgICAgNC4zMDg0MDNdIHBucCAwMDowMTogW2lvICAw eDAwYzAtMHgwMGRmXQpbICAgIDQuMzA4NDA0XSBwbnAgMDA6MDE6IFtkbWEgNF0KWyAgICA0 LjMwODQyMl0gcG5wIDAwOjAxOiBQbHVnIGFuZCBQbGF5IEFDUEkgZGV2aWNlLCBJRHMgUE5Q MDIwMCAoYWN0aXZlKQpbICAgIDQuMzA4NDI5XSBwbnAgMDA6MDI6IFttZW0gMHhmZjAwMDAw MC0weGZmZmZmZmZmXQpbICAgIDQuMzA4NDQ1XSBwbnAgMDA6MDI6IFBsdWcgYW5kIFBsYXkg QUNQSSBkZXZpY2UsIElEcyBJTlQwODAwIChhY3RpdmUpClsgICAgNC4zMDg1NDBdIHBucCAw MDowMzogW21lbSAweGZlZDAwMDAwLTB4ZmVkMDAzZmZdClsgICAgNC4zMDg1NzJdIHN5c3Rl bSAwMDowMzogW21lbSAweGZlZDAwMDAwLTB4ZmVkMDAzZmZdIGhhcyBiZWVuIHJlc2VydmVk ClsgICAgNC4zMDg1NzVdIHN5c3RlbSAwMDowMzogUGx1ZyBhbmQgUGxheSBBQ1BJIGRldmlj ZSwgSURzIFBOUDAxMDMgUE5QMGMwMSAoYWN0aXZlKQpbICAgIDQuMzA4NTg0XSBwbnAgMDA6 MDQ6IFtpbyAgMHgwMGYwXQpbICAgIDQuMzA4NTg3XSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAx MyB0cmlnZ2VyaW5nIDEgcG9sYXJpdHkgMApbICAgIDQuMzA4NjA5XSBwbnAgMDA6MDQ6IFtp cnEgMTNdClsgICAgNC4zMDg2MjZdIHBucCAwMDowNDogUGx1ZyBhbmQgUGxheSBBQ1BJIGRl dmljZSwgSURzIFBOUDBjMDQgKGFjdGl2ZSkKWyAgICA0LjMwODYzNl0gcG5wIDAwOjA1OiBb aW8gIDB4MDAyZS0weDAwMmZdClsgICAgNC4zMDg2MzddIHBucCAwMDowNTogW2lvICAweDAw NGUtMHgwMDRmXQpbICAgIDQuMzA4NjM5XSBwbnAgMDA6MDU6IFtpbyAgMHgwMDYxXQpbICAg IDQuMzA4NjQwXSBwbnAgMDA6MDU6IFtpbyAgMHgwMDYzXQpbICAgIDQuMzA4NjQxXSBwbnAg MDA6MDU6IFtpbyAgMHgwMDY1XQpbICAgIDQuMzA4NjQyXSBwbnAgMDA6MDU6IFtpbyAgMHgw MDY3XQpbICAgIDQuMzA4NjQ0XSBwbnAgMDA6MDU6IFtpbyAgMHgwMDcwXQpbICAgIDQuMzA4 NjQ1XSBwbnAgMDA6MDU6IFtpbyAgMHgwMDgwXQpbICAgIDQuMzA4NjQ2XSBwbnAgMDA6MDU6 IFtpbyAgMHgwMDkyXQpbICAgIDQuMzA4NjQ4XSBwbnAgMDA6MDU6IFtpbyAgMHgwMGIyLTB4 MDBiM10KWyAgICA0LjMwODY0OV0gcG5wIDAwOjA1OiBbaW8gIDB4MDY4MC0weDA2OWZdClsg ICAgNC4zMDg2NTFdIHBucCAwMDowNTogW2lvICAweDEwMDAtMHgxMDBmXQpbICAgIDQuMzA4 NjUzXSBwbnAgMDA6MDU6IFtpbyAgMHhmZmZmXQpbICAgIDQuMzA4NjU0XSBwbnAgMDA6MDU6 IFtpbyAgMHhmZmZmXQpbICAgIDQuMzA4NjU1XSBwbnAgMDA6MDU6IFtpbyAgMHgwNDAwLTB4 MDQ3Zl0KWyAgICA0LjMwODY1Nl0gcG5wIDAwOjA1OiBbaW8gIDB4MDUwMC0weDA1N2ZdClsg ICAgNC4zMDg2NThdIHBucCAwMDowNTogW2lvICAweDE2NGUtMHgxNjRmXQpbICAgIDQuMzA4 Njg5XSBzeXN0ZW0gMDA6MDU6IFtpbyAgMHgwNjgwLTB4MDY5Zl0gaGFzIGJlZW4gcmVzZXJ2 ZWQKWyAgICA0LjMwODY5MV0gc3lzdGVtIDAwOjA1OiBbaW8gIDB4MTAwMC0weDEwMGZdIGhh cyBiZWVuIHJlc2VydmVkClsgICAgNC4zMDg2OTNdIHN5c3RlbSAwMDowNTogW2lvICAweGZm ZmZdIGhhcyBiZWVuIHJlc2VydmVkClsgICAgNC4zMDg2OTVdIHN5c3RlbSAwMDowNTogW2lv ICAweGZmZmZdIGhhcyBiZWVuIHJlc2VydmVkClsgICAgNC4zMDg2OTddIHN5c3RlbSAwMDow NTogW2lvICAweDA0MDAtMHgwNDdmXSBoYXMgYmVlbiByZXNlcnZlZApbICAgIDQuMzA4NzAw XSBzeXN0ZW0gMDA6MDU6IFtpbyAgMHgwNTAwLTB4MDU3Zl0gaGFzIGJlZW4gcmVzZXJ2ZWQK WyAgICA0LjMwODcwMV0gc3lzdGVtIDAwOjA1OiBbaW8gIDB4MTY0ZS0weDE2NGZdIGhhcyBi ZWVuIHJlc2VydmVkClsgICAgNC4zMDg3MDRdIHN5c3RlbSAwMDowNTogUGx1ZyBhbmQgUGxh eSBBQ1BJIGRldmljZSwgSURzIFBOUDBjMDIgKGFjdGl2ZSkKWyAgICA0LjMwODcxMV0gcG5w IDAwOjA2OiBbaW8gIDB4MDA3MC0weDAwNzddClsgICAgNC4zMDg3MTNdIHhlbjogcmVnaXN0 ZXJpbmcgZ3NpIDggdHJpZ2dlcmluZyAxIHBvbGFyaXR5IDAKWyAgICA0LjMwODczMF0gcG5w IDAwOjA2OiBbaXJxIDhdClsgICAgNC4zMDg3NDldIHBucCAwMDowNjogUGx1ZyBhbmQgUGxh eSBBQ1BJIGRldmljZSwgSURzIFBOUDBiMDAgKGFjdGl2ZSkKWyAgICA0LjMwODc1OF0gcG5w IDAwOjA3OiBbaW8gIDB4MDA2MF0KWyAgICA0LjMwODc1OV0gcG5wIDAwOjA3OiBbaW8gIDB4 MDA2NF0KWyAgICA0LjMwODc2MV0geGVuOiByZWdpc3RlcmluZyBnc2kgMSB0cmlnZ2VyaW5n IDEgcG9sYXJpdHkgMApbICAgIDQuMzA4Nzc3XSBwbnAgMDA6MDc6IFtpcnEgMV0KWyAgICA0 LjMwODc5NF0gcG5wIDAwOjA3OiBQbHVnIGFuZCBQbGF5IEFDUEkgZGV2aWNlLCBJRHMgUE5Q MDMwMyAoYWN0aXZlKQpbICAgIDQuMzA5OTg0XSBwbnAgMDA6MDg6IFBsdWcgYW5kIFBsYXkg QUNQSSBkZXZpY2UsIElEcyBQTlAwNDAxIChkaXNhYmxlZCkKWyAgICA0LjMwOTk5M10geGVu OiByZWdpc3RlcmluZyBnc2kgMTIgdHJpZ2dlcmluZyAxIHBvbGFyaXR5IDAKWyAgICA0LjMx MDAxMV0gcG5wIDAwOjA5OiBbaXJxIDEyXQpbICAgIDQuMzEwMDMwXSBwbnAgMDA6MDk6IFBs dWcgYW5kIFBsYXkgQUNQSSBkZXZpY2UsIElEcyBETEwwNDkzIFBOUDBmMTMgKGFjdGl2ZSkK WyAgICA0LjMxMDA2NV0gcG5wIDAwOjBhOiBbbWVtIDB4ZmVkNDAwMDAtMHhmZWQ0NGZmZl0K WyAgICA0LjMxMDA4Nl0gcG5wIDAwOjBhOiBQbHVnIGFuZCBQbGF5IEFDUEkgZGV2aWNlLCBJ RHMgQkNNMDEwMiBQTlAwYzMxIChhY3RpdmUpClsgICAgNC4zMTAyOTFdIHBucCAwMDowYjog W21lbSAweGZlZDFjMDAwLTB4ZmVkMWZmZmZdClsgICAgNC4zMTAyOTJdIHBucCAwMDowYjog W21lbSAweGZlZDEwMDAwLTB4ZmVkMTdmZmZdClsgICAgNC4zMTAyOTRdIHBucCAwMDowYjog W21lbSAweGZlZDE4MDAwLTB4ZmVkMThmZmZdClsgICAgNC4zMTAyOTZdIHBucCAwMDowYjog W21lbSAweGZlZDE5MDAwLTB4ZmVkMTlmZmZdClsgICAgNC4zMTAyOThdIHBucCAwMDowYjog W21lbSAweGY4MDAwMDAwLTB4ZmJmZmZmZmZdClsgICAgNC4zMTAzMDldIHBucCAwMDowYjog W21lbSAweGZlZDIwMDAwLTB4ZmVkM2ZmZmZdClsgICAgNC4zMTAzMTBdIHBucCAwMDowYjog W21lbSAweGZlZDkwMDAwLTB4ZmVkOTNmZmZdClsgICAgNC4zMTAzMTJdIHBucCAwMDowYjog W21lbSAweGZlZDQ1MDAwLTB4ZmVkOGZmZmZdClsgICAgNC4zMTAzMTNdIHBucCAwMDowYjog W21lbSAweGZmMDAwMDAwLTB4ZmZmZmZmZmZdClsgICAgNC4zMTAzMTVdIHBucCAwMDowYjog W21lbSAweGZlZTAwMDAwLTB4ZmVlZmZmZmZdClsgICAgNC4zMTAzMTddIHBucCAwMDowYjog W21lbSAweDAwMDAwMDAwLTB4ZmZmZmZmZmZmZmZmZmZmZiBkaXNhYmxlZF0KWyAgICA0LjMx MDMxOF0gcG5wIDAwOjBiOiBbbWVtIDB4MDAwMDAwMDAtMHhmZmZmZmZmZmZmZmZmZmZmIGRp c2FibGVkXQpbICAgIDQuMzEwMzU5XSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhmZWQxYzAwMC0w eGZlZDFmZmZmXSBoYXMgYmVlbiByZXNlcnZlZApbICAgIDQuMzEwMzYxXSBzeXN0ZW0gMDA6 MGI6IFttZW0gMHhmZWQxMDAwMC0weGZlZDE3ZmZmXSBoYXMgYmVlbiByZXNlcnZlZApbICAg IDQuMzEwMzYzXSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhmZWQxODAwMC0weGZlZDE4ZmZmXSBo YXMgYmVlbiByZXNlcnZlZApbICAgIDQuMzEwMzY1XSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhm ZWQxOTAwMC0weGZlZDE5ZmZmXSBoYXMgYmVlbiByZXNlcnZlZApbICAgIDQuMzEwMzY3XSBz eXN0ZW0gMDA6MGI6IFttZW0gMHhmODAwMDAwMC0weGZiZmZmZmZmXSBoYXMgYmVlbiByZXNl cnZlZApbICAgIDQuMzEwMzY5XSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhmZWQyMDAwMC0weGZl ZDNmZmZmXSBoYXMgYmVlbiByZXNlcnZlZApbICAgIDQuMzEwMzcxXSBzeXN0ZW0gMDA6MGI6 IFttZW0gMHhmZWQ5MDAwMC0weGZlZDkzZmZmXSBoYXMgYmVlbiByZXNlcnZlZApbICAgIDQu MzEwMzczXSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhmZWQ0NTAwMC0weGZlZDhmZmZmXSBoYXMg YmVlbiByZXNlcnZlZApbICAgIDQuMzEwMzc1XSBzeXN0ZW0gMDA6MGI6IFttZW0gMHhmZjAw MDAwMC0weGZmZmZmZmZmXSBjb3VsZCBub3QgYmUgcmVzZXJ2ZWQKWyAgICA0LjMxMDM3N10g c3lzdGVtIDAwOjBiOiBbbWVtIDB4ZmVlMDAwMDAtMHhmZWVmZmZmZl0gY291bGQgbm90IGJl IHJlc2VydmVkClsgICAgNC4zMTAzODBdIHN5c3RlbSAwMDowYjogUGx1ZyBhbmQgUGxheSBB Q1BJIGRldmljZSwgSURzIFBOUDBjMDIgKGFjdGl2ZSkKWyAgICA0LjMxMDk1Nl0geGVuOiBy ZWdpc3RlcmluZyBnc2kgMjMgdHJpZ2dlcmluZyAxIHBvbGFyaXR5IDAKWyAgICA0LjMxMDk2 N10geGVuOiAtLT4gcGlycT0yMyAtPiBpcnE9MjMgKGdzaT0yMykKWyAgICA0LjMxMDk4NV0g cG5wIDAwOjBjOiBbaXJxIDIzXQpbICAgIDQuMzExMDE1XSBwbnAgMDA6MGM6IFBsdWcgYW5k IFBsYXkgQUNQSSBkZXZpY2UsIElEcyBTTU84ODAwIChhY3RpdmUpClsgICAgNC4zMTU1Mjhd IHBucCAwMDowZDogW21lbSAweDIwMDAwMDAwLTB4MjAxZmZmZmZdClsgICAgNC4zMTU1MzFd IHBucCAwMDowZDogW21lbSAweDQwMDAwMDAwLTB4NDAxZmZmZmZdClsgICAgNC4zMzk4NTFd IHN5c3RlbSAwMDowZDogW21lbSAweDIwMDAwMDAwLTB4MjAxZmZmZmZdIGhhcyBiZWVuIHJl c2VydmVkClsgICAgNC4zMzk4NTRdIHN5c3RlbSAwMDowZDogW21lbSAweDQwMDAwMDAwLTB4 NDAxZmZmZmZdIGhhcyBiZWVuIHJlc2VydmVkClsgICAgNC4zMzk4NTddIHN5c3RlbSAwMDow ZDogUGx1ZyBhbmQgUGxheSBBQ1BJIGRldmljZSwgSURzIFBOUDBjMDEgKGFjdGl2ZSkKWyAg ICA0LjMzOTg2NV0gcG5wOiBQblAgQUNQSTogZm91bmQgMTQgZGV2aWNlcwpbICAgIDQuMzM5 ODY3XSBBQ1BJOiBBQ1BJIGJ1cyB0eXBlIHBucCB1bnJlZ2lzdGVyZWQKWyAgICA0LjM0NjE3 OF0gUE0tVGltZXIgZmFpbGVkIGNvbnNpc3RlbmN5IGNoZWNrICAoMHgweGZmZmZmZikgLSBh Ym9ydGluZy4KWyAgICA0LjM0NjI3NF0gcGNpIDAwMDA6MDA6MWMuMDogUENJIGJyaWRnZSB0 byBbYnVzIDAxLTAxXQpbICAgIDQuMzQ2MzA2XSBwY2kgMDAwMDowMDoxYy4xOiBQQ0kgYnJp ZGdlIHRvIFtidXMgMDItMDJdClsgICAgNC4zNDYzMTVdIHBjaSAwMDAwOjAwOjFjLjE6ICAg YnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTJkMDAwMDAtMHhlMmRmZmZmZl0KWyAgICA0LjM0NjMz Ml0gcGNpIDAwMDA6MDA6MWMuMjogUENJIGJyaWRnZSB0byBbYnVzIDAzLTA4XQpbICAgIDQu MzQ2MzM2XSBwY2kgMDAwMDowMDoxYy4yOiAgIGJyaWRnZSB3aW5kb3cgW2lvICAweDMwMDAt MHgzZmZmXQpbICAgIDQuMzQ2MzQ3XSBwY2kgMDAwMDowMDoxYy4yOiAgIGJyaWRnZSB3aW5k b3cgW21lbSAweGUyMjAwMDAwLTB4ZTJiZmZmZmZdClsgICAgNC4zNDYzNTRdIHBjaSAwMDAw OjAwOjFjLjI6ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTBhMDAwMDAtMHhlMTNmZmZmZiA2 NGJpdCBwcmVmXQpbICAgIDQuMzQ2MzY2XSBwY2kgMDAwMDowMDoxYy4zOiBQQ0kgYnJpZGdl IHRvIFtidXMgMDktMDldClsgICAgNC4zNDYzNzBdIHBjaSAwMDAwOjAwOjFjLjM6ICAgYnJp ZGdlIHdpbmRvdyBbaW8gIDB4MjAwMC0weDJmZmZdClsgICAgNC4zNDYzNzldIHBjaSAwMDAw OjAwOjFjLjM6ICAgYnJpZGdlIHdpbmRvdyBbbWVtIDB4ZTE4MDAwMDAtMHhlMjFmZmZmZl0K WyAgICA0LjM0NjM4Nl0gcGNpIDAwMDA6MDA6MWMuMzogICBicmlkZ2Ugd2luZG93IFttZW0g MHhlMDAwMDAwMC0weGUwOWZmZmZmIDY0Yml0IHByZWZdClsgICAgNC4zNDYzOTldIHBjaSAw MDAwOjAwOjFjLjU6IFBDSSBicmlkZ2UgdG8gW2J1cyAwYS0wYV0KWyAgICA0LjM0NjQwOF0g cGNpIDAwMDA6MDA6MWMuNTogICBicmlkZ2Ugd2luZG93IFttZW0gMHhlMmMwMDAwMC0weGUy Y2ZmZmZmXQpbICAgIDQuMzQ2NDM0XSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAxNiB0cmlnZ2Vy aW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ2NDQyXSB4ZW46IC0tPiBwaXJxPTE2IC0+IGly cT0xNiAoZ3NpPTE2KQpbICAgIDQuMzQ2NDY5XSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAxNyB0 cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ2NDczXSB4ZW46IC0tPiBwaXJxPTE3 IC0+IGlycT0xNyAoZ3NpPTE3KQpbICAgIDQuMzQ2NDk4XSB4ZW46IHJlZ2lzdGVyaW5nIGdz aSAxOCB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ2NTAyXSB4ZW46IC0tPiBw aXJxPTE4IC0+IGlycT0xOCAoZ3NpPTE4KQpbICAgIDQuMzQ2NTI3XSB4ZW46IHJlZ2lzdGVy aW5nIGdzaSAxOSB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ2NTMxXSB4ZW46 IC0tPiBwaXJxPTE5IC0+IGlycT0xOSAoZ3NpPTE5KQpbICAgIDQuMzQ2NTU2XSB4ZW46IHJl Z2lzdGVyaW5nIGdzaSAxNyB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ2NTU4 XSBBbHJlYWR5IHNldHVwIHRoZSBHU0kgOjE3ClsgICAgNC4zNDY1NjNdIHBjaV9idXMgMDAw MDowMDogcmVzb3VyY2UgNCBbaW8gIDB4MDAwMC0weDBjZjddClsgICAgNC4zNDY1NjVdIHBj aV9idXMgMDAwMDowMDogcmVzb3VyY2UgNSBbaW8gIDB4MGQwMC0weGZmZmZdClsgICAgNC4z NDY1NjZdIHBjaV9idXMgMDAwMDowMDogcmVzb3VyY2UgNiBbbWVtIDB4MDAwYTAwMDAtMHgw MDBiZmZmZl0KWyAgICA0LjM0NjU2OF0gcGNpX2J1cyAwMDAwOjAwOiByZXNvdXJjZSA3IFtt ZW0gMHhjZmEwMDAwMC0weGZlYWZmZmZmXQpbICAgIDQuMzQ2NTcwXSBwY2lfYnVzIDAwMDA6 MDA6IHJlc291cmNlIDggW21lbSAweGZlZDQwMDAwLTB4ZmVkNDRmZmZdClsgICAgNC4zNDY1 NzJdIHBjaV9idXMgMDAwMDowMjogcmVzb3VyY2UgMSBbbWVtIDB4ZTJkMDAwMDAtMHhlMmRm ZmZmZl0KWyAgICA0LjM0NjU3NF0gcGNpX2J1cyAwMDAwOjAzOiByZXNvdXJjZSAwIFtpbyAg MHgzMDAwLTB4M2ZmZl0KWyAgICA0LjM0NjU3NV0gcGNpX2J1cyAwMDAwOjAzOiByZXNvdXJj ZSAxIFttZW0gMHhlMjIwMDAwMC0weGUyYmZmZmZmXQpbICAgIDQuMzQ2NTc3XSBwY2lfYnVz IDAwMDA6MDM6IHJlc291cmNlIDIgW21lbSAweGUwYTAwMDAwLTB4ZTEzZmZmZmYgNjRiaXQg cHJlZl0KWyAgICA0LjM0NjU3OV0gcGNpX2J1cyAwMDAwOjA5OiByZXNvdXJjZSAwIFtpbyAg MHgyMDAwLTB4MmZmZl0KWyAgICA0LjM0NjU4MV0gcGNpX2J1cyAwMDAwOjA5OiByZXNvdXJj ZSAxIFttZW0gMHhlMTgwMDAwMC0weGUyMWZmZmZmXQpbICAgIDQuMzQ2NTgyXSBwY2lfYnVz IDAwMDA6MDk6IHJlc291cmNlIDIgW21lbSAweGUwMDAwMDAwLTB4ZTA5ZmZmZmYgNjRiaXQg cHJlZl0KWyAgICA0LjM0NjU4NF0gcGNpX2J1cyAwMDAwOjBhOiByZXNvdXJjZSAxIFttZW0g MHhlMmMwMDAwMC0weGUyY2ZmZmZmXQpbICAgIDQuMzQ2NjcyXSBORVQ6IFJlZ2lzdGVyZWQg cHJvdG9jb2wgZmFtaWx5IDIKWyAgICA0LjM0NjczMl0gSVAgcm91dGUgY2FjaGUgaGFzaCB0 YWJsZSBlbnRyaWVzOiA1MjQyODggKG9yZGVyOiAxMCwgNDE5NDMwNCBieXRlcykKWyAgICA0 LjM0NzIwN10gVENQIGVzdGFibGlzaGVkIGhhc2ggdGFibGUgZW50cmllczogMjYyMTQ0IChv cmRlcjogMTAsIDQxOTQzMDQgYnl0ZXMpClsgICAgNC4zNDc3NTNdIFRDUCBiaW5kIGhhc2gg dGFibGUgZW50cmllczogNjU1MzYgKG9yZGVyOiA4LCAxMDQ4NTc2IGJ5dGVzKQpbICAgIDQu MzQ3ODcyXSBUQ1A6IEhhc2ggdGFibGVzIGNvbmZpZ3VyZWQgKGVzdGFibGlzaGVkIDI2MjE0 NCBiaW5kIDY1NTM2KQpbICAgIDQuMzQ3ODc0XSBUQ1A6IHJlbm8gcmVnaXN0ZXJlZApbICAg IDQuMzQ3ODc3XSBVRFAgaGFzaCB0YWJsZSBlbnRyaWVzOiA4MTkyIChvcmRlcjogNiwgMjYy MTQ0IGJ5dGVzKQpbICAgIDQuMzQ3OTIxXSBVRFAtTGl0ZSBoYXNoIHRhYmxlIGVudHJpZXM6 IDgxOTIgKG9yZGVyOiA2LCAyNjIxNDQgYnl0ZXMpClsgICAgNC4zNDgwNjddIE5FVDogUmVn aXN0ZXJlZCBwcm90b2NvbCBmYW1pbHkgMQpbICAgIDQuMzQ4MDg1XSBwY2kgMDAwMDowMDow Mi4wOiBCb290IHZpZGVvIGRldmljZQpbICAgIDQuMzQ4MTA4XSB4ZW46IHJlZ2lzdGVyaW5n IGdzaSAxNiB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDQuMzQ4MTEyXSBBbHJlYWR5 IHNldHVwIHRoZSBHU0kgOjE2ClsgICAgNC4zNDgyMDNdIHhlbjogcmVnaXN0ZXJpbmcgZ3Np IDE3IHRyaWdnZXJpbmcgMCBwb2xhcml0eSAxClsgICAgNC4zNDgyMDVdIEFscmVhZHkgc2V0 dXAgdGhlIEdTSSA6MTcKWyAgICA0LjM0ODI5OF0gUENJOiBDTFMgNjQgYnl0ZXMsIGRlZmF1 bHQgNjQKWyAgICA0LjM0ODMzM10gVW5wYWNraW5nIGluaXRyYW1mcy4uLgpbICAgIDQuMzg0 MjY1XSBGcmVlaW5nIGluaXRyZCBtZW1vcnk6IDQ1ODY4ayBmcmVlZApbICAgIDQuMzkyNDQw XSBTaW1wbGUgQm9vdCBGbGFnIGF0IDB4ZjMgc2V0IHRvIDB4MQpbICAgIDQuMzkyOTAwXSBh dWRpdDogaW5pdGlhbGl6aW5nIG5ldGxpbmsgc29ja2V0IChkaXNhYmxlZCkKWyAgICA0LjM5 MjkxMV0gdHlwZT0yMDAwIGF1ZGl0KDEzNTQxNTE5NzUuMzgzOjEpOiBpbml0aWFsaXplZApb ICAgIDQuNDExNjg4XSBWRlM6IERpc2sgcXVvdGFzIGRxdW90XzYuNS4yClsgICAgNC40MTE3 MTVdIERxdW90LWNhY2hlIGhhc2ggdGFibGUgZW50cmllczogNTEyIChvcmRlciAwLCA0MDk2 IGJ5dGVzKQpbICAgIDQuNDExODcwXSBtc2dtbmkgaGFzIGJlZW4gc2V0IHRvIDI5MzM5Clsg ICAgNC40MTIwMTBdIEJsb2NrIGxheWVyIFNDU0kgZ2VuZXJpYyAoYnNnKSBkcml2ZXIgdmVy c2lvbiAwLjQgbG9hZGVkIChtYWpvciAyNTMpClsgICAgNC40MTIwMTNdIGlvIHNjaGVkdWxl ciBub29wIHJlZ2lzdGVyZWQKWyAgICA0LjQxMjAxNV0gaW8gc2NoZWR1bGVyIGRlYWRsaW5l IHJlZ2lzdGVyZWQKWyAgICA0LjQxMjAzNl0gaW8gc2NoZWR1bGVyIGNmcSByZWdpc3RlcmVk IChkZWZhdWx0KQpbICAgIDQuNDEyNjY2XSBpbnRlbF9pZGxlOiBkb2VzIG5vdCBydW4gb24g ZmFtaWx5IDYgbW9kZWwgNDIKWyAgICA0LjQxMjc0MV0gQUNQSTogUmVxdWVzdGluZyBhY3Bp X2NwdWZyZXEKWyAgICA0LjQ1OTY0M10gTm9uLXZvbGF0aWxlIG1lbW9yeSBkcml2ZXIgdjEu MwpbICAgIDQuNDU5NjU0XSByYW1vb3BzOiBwbGF0Zm9ybSBkZXZpY2Ugbm90IGZvdW5kLCB1 c2luZyBtb2R1bGUgcGFyYW1ldGVycwpbICAgIDQuNDU5NjcwXSByYW1vb3BzOiBUaGUgbWVt b3J5IHNpemUgYW5kIHRoZSByZWNvcmQgc2l6ZSBtdXN0IGJlIG5vbi16ZXJvClsgICAgNC40 NTk3MDNdIHJhbW9vcHM6IHByb2JlIG9mIHJhbW9vcHMgZmFpbGVkIHdpdGggZXJyb3IgLTIy ClsgICAgNC40NzQ4OTJdIGxvb3A6IG1vZHVsZSBsb2FkZWQKWyAgICA0LjQ3NDkyMl0gRml4 ZWQgTURJTyBCdXM6IHByb2JlZApbICAgIDQuNDc0OTY1XSBpODA0MjogUE5QOiBQUy8yIENv bnRyb2xsZXIgW1BOUDAzMDM6UFMySyxQTlAwZjEzOlBTMk1dIGF0IDB4NjAsMHg2NCBpcnEg MSwxMgpbICAgIDQuNDc1MTY2XSBpODA0MjogV2FybmluZzogS2V5bG9jayBhY3RpdmUKWyAg ICA0LjQ3NjQzNF0gc2VyaW86IGk4MDQyIEtCRCBwb3J0IGF0IDB4NjAsMHg2NCBpcnEgMQpb ICAgIDQuNDc2NDM5XSBzZXJpbzogaTgwNDIgQVVYIHBvcnQgYXQgMHg2MCwweDY0IGlycSAx MgpbICAgIDQuNDc2NTUxXSBtb3VzZWRldjogUFMvMiBtb3VzZSBkZXZpY2UgY29tbW9uIGZv ciBhbGwgbWljZQpbICAgIDQuNDc2NzA3XSBydGNfY21vcyAwMDowNjogUlRDIGNhbiB3YWtl IGZyb20gUzQKWyAgICA0LjQ3Njk0MF0gcnRjX2Ntb3MgMDA6MDY6IHJ0YyBjb3JlOiByZWdp c3RlcmVkIHJ0Y19jbW9zIGFzIHJ0YzAKWyAgICA0LjQ3Njk5OF0gcnRjMDogYWxhcm1zIHVw IHRvIG9uZSB5ZWFyLCB5M2ssIDI0MiBieXRlcyBudnJhbQpbICAgIDQuNDc3MDg0XSBkZXZp Y2UtbWFwcGVyOiB1ZXZlbnQ6IHZlcnNpb24gMS4wLjMKWyAgICA0LjQ3NzE5M10gZGV2aWNl LW1hcHBlcjogaW9jdGw6IDQuMjIuMC1pb2N0bCAoMjAxMS0xMC0xOSkgaW5pdGlhbGlzZWQ6 IGRtLWRldmVsQHJlZGhhdC5jb20KWyAgICA0LjQ3NzI4MV0gVENQOiBjdWJpYyByZWdpc3Rl cmVkClsgICAgNC40NzczODFdIGlucHV0OiBBVCBUcmFuc2xhdGVkIFNldCAyIGtleWJvYXJk IGFzIC9kZXZpY2VzL3BsYXRmb3JtL2k4MDQyL3NlcmlvMC9pbnB1dC9pbnB1dDAKWyAgICA0 LjQ3NzQwMl0gTkVUOiBSZWdpc3RlcmVkIHByb3RvY29sIGZhbWlseSAxMApbICAgIDQuNDc3 NjQ0XSBSZWdpc3RlcmluZyB0aGUgZG5zX3Jlc29sdmVyIGtleSB0eXBlClsgICAgNC40Nzc3 OTFdIHJlZ2lzdGVyZWQgdGFza3N0YXRzIHZlcnNpb24gMQpbICAgIDQuNDc4MzMwXSAgIE1h Z2ljIG51bWJlcjogNDo1ODQ6MzA3ClsgICAgNC40Nzg0MDNdIHR0eSB0dHkzNjogaGFzaCBt YXRjaGVzClsgICAgNC40Nzg0OTZdIHJ0Y19jbW9zIDAwOjA2OiBzZXR0aW5nIHN5c3RlbSBj bG9jayB0byAyMDEyLTExLTI5IDAxOjE5OjM1IFVUQyAoMTM1NDE1MTk3NSkKWyAgICA0LjQ3 ODgwMV0gRnJlZWluZyB1bnVzZWQga2VybmVsIG1lbW9yeTogNTUyayBmcmVlZApbICAgIDQu NDc4ODQ3XSBXcml0ZSBwcm90ZWN0aW5nIHRoZSBrZXJuZWwgcmVhZC1vbmx5IGRhdGE6IDgx OTJrClsgICAgNC40ODE5MDhdIEZyZWVpbmcgdW51c2VkIGtlcm5lbCBtZW1vcnk6IDE1Njhr IGZyZWVkClsgICAgNC40ODIxMTJdIEZyZWVpbmcgdW51c2VkIGtlcm5lbCBtZW1vcnk6IDI0 ayBmcmVlZApbICAgIDQuNTI0MTI5XSBkcmFjdXQ6IGRyYWN1dC0wMDUtMy5mYzEzClsgICAg NC41NTIzMTFdIHBjaWJhY2sgMDAwMDowMDoxOS4wOiBzZWl6aW5nIGRldmljZQpbICAgIDQu NTUyNDAzXSBwY2liYWNrIDAwMDA6MDI6MDAuMDogc2VpemluZyBkZXZpY2UKWyAgICA0LjU1 Mjk0MV0geGVuOiByZWdpc3RlcmluZyBnc2kgMTcgdHJpZ2dlcmluZyAwIHBvbGFyaXR5IDEK WyAgICA0LjU1Mjk1Ml0gQWxyZWFkeSBzZXR1cCB0aGUgR1NJIDoxNwpbICAgIDQuNTUzOTM0 XSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAyMCB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAg IDQuNTUzOTY0XSB4ZW46IC0tPiBwaXJxPTIwIC0+IGlycT0yMCAoZ3NpPTIwKQpbICAgIDQu NTU0NTc0XSB4ZW4tcGNpYmFjazogYmFja2VuZCBpcyB2cGNpClsgICAgNC42MTc0NzFdIHVk ZXY6IHN0YXJ0aW5nIHZlcnNpb24gMTUxClsgICAgNC42MTc3NzBdIHVkZXZkICg4MCk6IC9w cm9jLzgwL29vbV9hZGogaXMgZGVwcmVjYXRlZCwgcGxlYXNlIHVzZSAvcHJvYy84MC9vb21f c2NvcmVfYWRqIGluc3RlYWQuClsgICAgNC42NTQ5MTZdIExpbnV4IGFncGdhcnQgaW50ZXJm YWNlIHYwLjEwMwpbICAgIDQuNjU1Mzk3XSBpbnB1dDogTGlkIFN3aXRjaCBhcyAvZGV2aWNl cy9MTlhTWVNUTTowMC9kZXZpY2U6MDAvUE5QMEMwRDowMC9pbnB1dC9pbnB1dDEKWyAgICA1 LjA1MTE4NF0gQUNQSTogTGlkIFN3aXRjaCBbTElEXQpbICAgIDUuMDUxNDM2XSBpbnB1dDog UG93ZXIgQnV0dG9uIGFzIC9kZXZpY2VzL0xOWFNZU1RNOjAwL2RldmljZTowMC9QTlAwQzBD OjAwL2lucHV0L2lucHV0MgpbICAgIDUuMDUxNTQ3XSBBQ1BJOiBQb3dlciBCdXR0b24gW1BC VE5dClsgICAgNS4wNTE2ODJdIGlucHV0OiBTbGVlcCBCdXR0b24gYXMgL2RldmljZXMvTE5Y U1lTVE06MDAvZGV2aWNlOjAwL1BOUDBDMEU6MDAvaW5wdXQvaW5wdXQzClsgICAgNS4wNTE3 NjBdIEFDUEk6IFNsZWVwIEJ1dHRvbiBbU0JUTl0KWyAgICA1LjA1NDE0MV0gaW5wdXQ6IFBv d2VyIEJ1dHRvbiBhcyAvZGV2aWNlcy9MTlhTWVNUTTowMC9MTlhQV1JCTjowMC9pbnB1dC9p bnB1dDQKWyAgICA1LjA1NDQyMV0gQUNQSTogUG93ZXIgQnV0dG9uIFtQV1JGXQpbICAgIDUu MDU2ODg3XSBhZ3BnYXJ0LWludGVsIDAwMDA6MDA6MDAuMDogSW50ZWwgU2FuZHlicmlkZ2Ug Q2hpcHNldApbICAgIDUuMDU4MTE4XSBhZ3BnYXJ0LWludGVsIDAwMDA6MDA6MDAuMDogZGV0 ZWN0ZWQgZ3R0IHNpemU6IDIwOTcxNTJLIHRvdGFsLCAyNjIxNDRLIG1hcHBhYmxlClsgICAg NS4wNjQ0MzldIGFncGdhcnQtaW50ZWwgMDAwMDowMDowMC4wOiBkZXRlY3RlZCA2NTUzNksg c3RvbGVuIG1lbW9yeQpbICAgIDUuMDY0OTE2XSBhZ3BnYXJ0LWludGVsIDAwMDA6MDA6MDAu MDogQUdQIGFwZXJ0dXJlIGlzIDI1Nk0gQCAweGQwMDAwMDAwClsgICAgNS4wNzAyOTZdIFtk cm1dIEluaXRpYWxpemVkIGRybSAxLjEuMCAyMDA2MDgxMApbICAgIDUuMDgwMDAyXSB4ZW46 IHJlZ2lzdGVyaW5nIGdzaSAxNiB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgIDUuMDgw MDE1XSBBbHJlYWR5IHNldHVwIHRoZSBHU0kgOjE2ClsgICAgNS4wODAzNjRdIGk5MTUgMDAw MDowMDowMi4wOiBzZXR0aW5nIGxhdGVuY3kgdGltZXIgdG8gNjQKWyAgICA1LjE5MDI5NV0g W2RybV0gTVRSUiBhbGxvY2F0aW9uIGZhaWxlZC4gIEdyYXBoaWNzIHBlcmZvcm1hbmNlIG1h eSBzdWZmZXIuClsgICAgNS4xOTA0OTFdIFtkcm1dIFN1cHBvcnRzIHZibGFuayB0aW1lc3Rh bXAgY2FjaGluZyBSZXYgMSAoMTAuMTAuMjAxMCkuClsgICAgNS4xOTA0OTNdIFtkcm1dIERy aXZlciBzdXBwb3J0cyBwcmVjaXNlIHZibGFuayB0aW1lc3RhbXAgcXVlcnkuClsgICAgNS4x OTA1NTRdIHZnYWFyYjogZGV2aWNlIGNoYW5nZWQgZGVjb2RlczogUENJOjAwMDA6MDA6MDIu MCxvbGRkZWNvZGVzPWlvK21lbSxkZWNvZGVzPWlvK21lbTpvd25zPWlvK21lbQpbICAgIDUu NTQ4MzAxXSBbZHJtXSBFbmFibGluZyBSQzYgc3RhdGVzOiBSQzYgb24sIFJDNnAgb2ZmLCBS QzZwcCBvZmYKWyAgICA1LjU5MTA5M10gaW5wdXQ6IER1YWxQb2ludCBTdGljayBhcyAvZGV2 aWNlcy9wbGF0Zm9ybS9pODA0Mi9zZXJpbzEvaW5wdXQvaW5wdXQ1ClsgICAgNS42MDYyMTJd IGlucHV0OiBBbHBzUFMvMiBBTFBTIER1YWxQb2ludCBUb3VjaFBhZCBhcyAvZGV2aWNlcy9w bGF0Zm9ybS9pODA0Mi9zZXJpbzEvaW5wdXQvaW5wdXQ2ClsgICAgNS44MDY4MTRdIGZiY29u OiBpbnRlbGRybWZiIChmYjApIGlzIHByaW1hcnkgZGV2aWNlClsgICAgNi4wOTU5NjddIENv bnNvbGU6IHN3aXRjaGluZyB0byBjb2xvdXIgZnJhbWUgYnVmZmVyIGRldmljZSAyMDB4NTYK WyAgICA2LjEwMTQ3N10gZmIwOiBpbnRlbGRybWZiIGZyYW1lIGJ1ZmZlciBkZXZpY2UKWyAg ICA2LjEwMTQ3OF0gZHJtOiByZWdpc3RlcmVkIHBhbmljIG5vdGlmaWVyClsgICAgNi4xMzA4 MzNdIGFjcGkgZGV2aWNlOjM4OiByZWdpc3RlcmVkIGFzIGNvb2xpbmdfZGV2aWNlNApbICAg IDYuMTMzNzEzXSBpbnB1dDogVmlkZW8gQnVzIGFzIC9kZXZpY2VzL0xOWFNZU1RNOjAwL2Rl dmljZTowMC9QTlAwQTA4OjAwL0xOWFZJREVPOjAwL2lucHV0L2lucHV0NwpbICAgIDYuMTMz OTE1XSBBQ1BJOiBWaWRlbyBEZXZpY2UgW1ZJRF0gKG11bHRpLWhlYWQ6IHllcyAgcm9tOiBu byAgcG9zdDogbm8pClsgICAgNi4xMzUwODJdIFtkcm1dIEluaXRpYWxpemVkIGk5MTUgMS42 LjAgMjAwODA3MzAgZm9yIDAwMDA6MDA6MDIuMCBvbiBtaW5vciAwClsgICAgNi4xODU5NDZd IGRyYWN1dDogU3RhcnRpbmcgcGx5bW91dGggZGFlbW9uClsgICAgNi40NzkzOTFdIGRyYWN1 dDogcmRfTk9fRE06IHJlbW92aW5nIERNIFJBSUQgYWN0aXZhdGlvbgpbICAgIDYuNDg5MzA5 XSBkcmFjdXQ6IHJkX05PX01EOiByZW1vdmluZyBNRCBSQUlEIGFjdGl2YXRpb24KWyAgICA2 LjU0MjU5Nl0gd21pOiBNYXBwZXIgbG9hZGVkClsgICAgNi41NjQ0MzldIHVzYmNvcmU6IHJl Z2lzdGVyZWQgbmV3IGludGVyZmFjZSBkcml2ZXIgdXNiZnMKWyAgICA2LjU2NDQ2M10gdXNi Y29yZTogcmVnaXN0ZXJlZCBuZXcgaW50ZXJmYWNlIGRyaXZlciBodWIKWyAgICA2LjU2ODkw MV0gU0NTSSBzdWJzeXN0ZW0gaW5pdGlhbGl6ZWQKWyAgICA2LjU2OTU3NF0gdXNiY29yZTog cmVnaXN0ZXJlZCBuZXcgZGV2aWNlIGRyaXZlciB1c2IKWyAgICA2LjU3MDY5Ml0gZWhjaV9o Y2Q6IFVTQiAyLjAgJ0VuaGFuY2VkJyBIb3N0IENvbnRyb2xsZXIgKEVIQ0kpIERyaXZlcgpb ICAgIDYuNTcwNzIzXSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAxNiB0cmlnZ2VyaW5nIDAgcG9s YXJpdHkgMQpbICAgIDYuNTcwNzI4XSBBbHJlYWR5IHNldHVwIHRoZSBHU0kgOjE2ClsgICAg Ni41NzA3NzZdIGVoY2lfaGNkIDAwMDA6MDA6MWEuMDogc2V0dGluZyBsYXRlbmN5IHRpbWVy IHRvIDY0ClsgICAgNi41NzA3ODJdIGVoY2lfaGNkIDAwMDA6MDA6MWEuMDogRUhDSSBIb3N0 IENvbnRyb2xsZXIKWyAgICA2LjU3MDgxNF0gZWhjaV9oY2QgMDAwMDowMDoxYS4wOiBuZXcg VVNCIGJ1cyByZWdpc3RlcmVkLCBhc3NpZ25lZCBidXMgbnVtYmVyIDEKWyAgICA2LjU3MDg3 OV0gZWhjaV9oY2QgMDAwMDowMDoxYS4wOiBkZWJ1ZyBwb3J0IDIKWyAgICA2LjU3MzcyMF0g bGliYXRhIHZlcnNpb24gMy4wMCBsb2FkZWQuClsgICAgNi41NzQ3NzddIGVoY2lfaGNkIDAw MDA6MDA6MWEuMDogY2FjaGUgbGluZSBzaXplIG9mIDY0IGlzIG5vdCBzdXBwb3J0ZWQKWyAg ICA2LjU3NDgzMl0gZWhjaV9oY2QgMDAwMDowMDoxYS4wOiBpcnEgMTYsIGlvIG1lbSAweGUy ZTcwMDAwClsgICAgNi41ODYzNDRdIGVoY2lfaGNkIDAwMDA6MDA6MWEuMDogVVNCIDIuMCBz dGFydGVkLCBFSENJIDEuMDAKWyAgICA2LjU4NjM2OV0gdXNiIHVzYjE6IE5ldyBVU0IgZGV2 aWNlIGZvdW5kLCBpZFZlbmRvcj0xZDZiLCBpZFByb2R1Y3Q9MDAwMgpbICAgIDYuNTg2Mzcy XSB1c2IgdXNiMTogTmV3IFVTQiBkZXZpY2Ugc3RyaW5nczogTWZyPTMsIFByb2R1Y3Q9Miwg U2VyaWFsTnVtYmVyPTEKWyAgICA2LjU4NjM3NV0gdXNiIHVzYjE6IFByb2R1Y3Q6IEVIQ0kg SG9zdCBDb250cm9sbGVyClsgICAgNi41ODYzNzZdIHVzYiB1c2IxOiBNYW51ZmFjdHVyZXI6 IExpbnV4IDMuNC4xOC0yLnB2b3BzLnF1YmVzLng4Nl82NCBlaGNpX2hjZApbICAgIDYuNTg2 Mzc4XSB1c2IgdXNiMTogU2VyaWFsTnVtYmVyOiAwMDAwOjAwOjFhLjAKWyAgICA2LjU4NjUw Nl0gaHViIDEtMDoxLjA6IFVTQiBodWIgZm91bmQKWyAgICA2LjU4NjUxMV0gaHViIDEtMDox LjA6IDIgcG9ydHMgZGV0ZWN0ZWQKWyAgICA2LjU4NjYwNF0geGVuOiByZWdpc3RlcmluZyBn c2kgMTcgdHJpZ2dlcmluZyAwIHBvbGFyaXR5IDEKWyAgICA2LjU4NjYwOV0gQWxyZWFkeSBz ZXR1cCB0aGUgR1NJIDoxNwpbICAgIDYuNTg2NjYzXSBlaGNpX2hjZCAwMDAwOjAwOjFkLjA6 IHNldHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICAgIDYuNTg2NjY4XSBlaGNpX2hjZCAw MDAwOjAwOjFkLjA6IEVIQ0kgSG9zdCBDb250cm9sbGVyClsgICAgNi41ODY2NzhdIGVoY2lf aGNkIDAwMDA6MDA6MWQuMDogbmV3IFVTQiBidXMgcmVnaXN0ZXJlZCwgYXNzaWduZWQgYnVz IG51bWJlciAyClsgICAgNi41ODY3MzRdIGVoY2lfaGNkIDAwMDA6MDA6MWQuMDogZGVidWcg cG9ydCAyClsgICAgNi41OTA2NTBdIGVoY2lfaGNkIDAwMDA6MDA6MWQuMDogY2FjaGUgbGlu ZSBzaXplIG9mIDY0IGlzIG5vdCBzdXBwb3J0ZWQKWyAgICA2LjU5MDcwOV0gZWhjaV9oY2Qg MDAwMDowMDoxZC4wOiBpcnEgMTcsIGlvIG1lbSAweGUyZTUwMDAwClsgICAgNi42MDYzMzVd IGVoY2lfaGNkIDAwMDA6MDA6MWQuMDogVVNCIDIuMCBzdGFydGVkLCBFSENJIDEuMDAKWyAg ICA2LjYwNjM2NF0gdXNiIHVzYjI6IE5ldyBVU0IgZGV2aWNlIGZvdW5kLCBpZFZlbmRvcj0x ZDZiLCBpZFByb2R1Y3Q9MDAwMgpbICAgIDYuNjA2MzY3XSB1c2IgdXNiMjogTmV3IFVTQiBk ZXZpY2Ugc3RyaW5nczogTWZyPTMsIFByb2R1Y3Q9MiwgU2VyaWFsTnVtYmVyPTEKWyAgICA2 LjYwNjM3MF0gdXNiIHVzYjI6IFByb2R1Y3Q6IEVIQ0kgSG9zdCBDb250cm9sbGVyClsgICAg Ni42MDYzNzFdIHVzYiB1c2IyOiBNYW51ZmFjdHVyZXI6IExpbnV4IDMuNC4xOC0yLnB2b3Bz LnF1YmVzLng4Nl82NCBlaGNpX2hjZApbICAgIDYuNjA2MzczXSB1c2IgdXNiMjogU2VyaWFs TnVtYmVyOiAwMDAwOjAwOjFkLjAKWyAgICA2LjYwNjUxOV0gaHViIDItMDoxLjA6IFVTQiBo dWIgZm91bmQKWyAgICA2LjYwNjUyNF0gaHViIDItMDoxLjA6IDIgcG9ydHMgZGV0ZWN0ZWQK WyAgICA2LjYwNjYyMF0gYWhjaSAwMDAwOjAwOjFmLjI6IHZlcnNpb24gMy4wClsgICAgNi42 MDY2NDFdIHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDE4IHRyaWdnZXJpbmcgMCBwb2xhcml0eSAx ClsgICAgNi42MDY2NDddIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6MTgKWyAgICA2LjYwNjg5 Nl0gYWhjaTogU1NTIGZsYWcgc2V0LCBwYXJhbGxlbCBidXMgc2NhbiBkaXNhYmxlZApbICAg IDYuNjI2NDAwXSBhaGNpIDAwMDA6MDA6MWYuMjogQUhDSSAwMDAxLjAzMDAgMzIgc2xvdHMg NiBwb3J0cyA2IEdicHMgMHgzYiBpbXBsIFNBVEEgbW9kZQpbICAgIDYuNjI2NDA1XSBhaGNp IDAwMDA6MDA6MWYuMjogZmxhZ3M6IDY0Yml0IG5jcSBzbnRmIHN0YWcgcG0gbGVkIGNsbyBw aW8gc2x1bSBwYXJ0IGVtcyBzeHMgYXBzdCAKWyAgICA2LjYyNjQxNF0gYWhjaSAwMDAwOjAw OjFmLjI6IHNldHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICAgIDYuNjczNzMyXSBzY3Np MCA6IGFoY2kKWyAgICA2LjY4MzM2M10gc2NzaTEgOiBhaGNpClsgICAgNi42OTcyNjhdIHNj c2kyIDogYWhjaQpbICAgIDYuNzExNTI2XSBzY3NpMyA6IGFoY2kKWyAgICA2LjczMzkzMV0g c2NzaTQgOiBhaGNpClsgICAgNi43Mzk2MDNdIHNjc2k1IDogYWhjaQpbICAgIDYuODQyMTA2 XSBhdGExOiBTQVRBIG1heCBVRE1BLzEzMyBhYmFyIG0yMDQ4QDB4ZTJlNDAwMDAgcG9ydCAw eGUyZTQwMTAwIGlycSAyOTMKWyAgICA2Ljg0MjExOF0gYXRhMjogU0FUQSBtYXggVURNQS8x MzMgYWJhciBtMjA0OEAweGUyZTQwMDAwIHBvcnQgMHhlMmU0MDE4MCBpcnEgMjkzClsgICAg Ni44NDIxMjRdIGF0YTM6IERVTU1ZClsgICAgNi44NDIxMjldIGF0YTQ6IFNBVEEgbWF4IFVE TUEvMTMzIGFiYXIgbTIwNDhAMHhlMmU0MDAwMCBwb3J0IDB4ZTJlNDAyODAgaXJxIDI5Mwpb ICAgIDYuODQyMTM2XSBhdGE1OiBTQVRBIG1heCBVRE1BLzEzMyBhYmFyIG0yMDQ4QDB4ZTJl NDAwMDAgcG9ydCAweGUyZTQwMzAwIGlycSAyOTMKWyAgICA2Ljg0MjE0M10gYXRhNjogU0FU QSBtYXggVURNQS8xMzMgYWJhciBtMjA0OEAweGUyZTQwMDAwIHBvcnQgMHhlMmU0MDM4MCBp cnEgMjkzClsgICAgNi44OTg0ODBdIHVzYiAxLTE6IG5ldyBoaWdoLXNwZWVkIFVTQiBkZXZp Y2UgbnVtYmVyIDIgdXNpbmcgZWhjaV9oY2QKWyAgICA3LjAzMTMxMl0gdXNiIDEtMTogTmV3 IFVTQiBkZXZpY2UgZm91bmQsIGlkVmVuZG9yPTgwODcsIGlkUHJvZHVjdD0wMDI0ClsgICAg Ny4wMzEzMjNdIHVzYiAxLTE6IE5ldyBVU0IgZGV2aWNlIHN0cmluZ3M6IE1mcj0wLCBQcm9k dWN0PTAsIFNlcmlhbE51bWJlcj0wClsgICAgNy4wMzIwNzJdIGh1YiAxLTE6MS4wOiBVU0Ig aHViIGZvdW5kClsgICAgNy4wMzIzNDRdIGh1YiAxLTE6MS4wOiA2IHBvcnRzIGRldGVjdGVk ClsgICAgNy4xNDI1MTVdIHVzYiAyLTE6IG5ldyBoaWdoLXNwZWVkIFVTQiBkZXZpY2UgbnVt YmVyIDIgdXNpbmcgZWhjaV9oY2QKWyAgICA3LjE2MjQ4NF0gYXRhMTogU0FUQSBsaW5rIHVw IDYuMCBHYnBzIChTU3RhdHVzIDEzMyBTQ29udHJvbCAzMDApClsgICAgNy4yNjg1OTRdIGF0 YTEuMDA6IEFDUEkgY21kIDAwLzAwOjAwOjAwOjAwOjAwOmEwIChOT1ApIHJlamVjdGVkIGJ5 IGRldmljZSAoU3RhdD0weDUxIEVycj0weDA0KQpbICAgIDcuMjY4NzcwXSBhdGExLjAwOiBB VEEtOTogS0lOR1NUT04gU1YyMDBTMzI1NkcsIEUxMTEwMDhhLCBtYXggVURNQS8xMDAKWyAg ICA3LjI2ODc3OF0gYXRhMS4wMDogNTAwMTE4MTkyIHNlY3RvcnMsIG11bHRpIDE2OiBMQkE0 OCBOQ1EgKGRlcHRoIDMxLzMyKSwgQUEKWyAgICA3LjI3MjU1NF0gYXRhMS4wMDogQUNQSSBj bWQgMDAvMDA6MDA6MDA6MDA6MDA6YTAgKE5PUCkgcmVqZWN0ZWQgYnkgZGV2aWNlIChTdGF0 PTB4NTEgRXJyPTB4MDQpClsgICAgNy4yNzI3NThdIGF0YTEuMDA6IGNvbmZpZ3VyZWQgZm9y IFVETUEvMTAwClsgICAgNy4yNzMzMTRdIHNjc2kgMDowOjA6MDogRGlyZWN0LUFjY2VzcyAg ICAgQVRBICAgICAgS0lOR1NUT04gU1YyMDBTMyBFMTExIFBROiAwIEFOU0k6IDUKWyAgICA3 LjI3NDg2MV0gdXNiIDItMTogTmV3IFVTQiBkZXZpY2UgZm91bmQsIGlkVmVuZG9yPTgwODcs IGlkUHJvZHVjdD0wMDI0ClsgICAgNy4yNzQ4NzBdIHVzYiAyLTE6IE5ldyBVU0IgZGV2aWNl IHN0cmluZ3M6IE1mcj0wLCBQcm9kdWN0PTAsIFNlcmlhbE51bWJlcj0wClsgICAgNy4yNzUz NThdIGh1YiAyLTE6MS4wOiBVU0IgaHViIGZvdW5kClsgICAgNy4yNzU1MjFdIGh1YiAyLTE6 MS4wOiA4IHBvcnRzIGRldGVjdGVkClsgICAgNy4zNDY3MTddIHVzYiAxLTEuNDogbmV3IGZ1 bGwtc3BlZWQgVVNCIGRldmljZSBudW1iZXIgMyB1c2luZyBlaGNpX2hjZApbICAgIDcuNDQz NTI5XSB1c2IgMS0xLjQ6IE5ldyBVU0IgZGV2aWNlIGZvdW5kLCBpZFZlbmRvcj00MTNjLCBp ZFByb2R1Y3Q9ODE4NwpbICAgIDcuNDQzNTM5XSB1c2IgMS0xLjQ6IE5ldyBVU0IgZGV2aWNl IHN0cmluZ3M6IE1mcj0xLCBQcm9kdWN0PTIsIFNlcmlhbE51bWJlcj0zClsgICAgNy40NDM1 NDZdIHVzYiAxLTEuNDogUHJvZHVjdDogRFczNzUgQmx1ZXRvb3RoIE1vZHVsZQpbICAgIDcu NDQzNTUwXSB1c2IgMS0xLjQ6IE1hbnVmYWN0dXJlcjogRGVsbCBDb21wdXRlciBDb3JwClsg ICAgNy40NDM1NTVdIHVzYiAxLTEuNDogU2VyaWFsTnVtYmVyOiBEMERGOUE0MEZFNjAKWyAg ICA3LjUxNDczNl0gdXNiIDEtMS41OiBuZXcgaGlnaC1zcGVlZCBVU0IgZGV2aWNlIG51bWJl ciA0IHVzaW5nIGVoY2lfaGNkClsgICAgNy41OTA0NDBdIGF0YTI6IFNBVEEgbGluayB1cCAx LjUgR2JwcyAoU1N0YXR1cyAxMTMgU0NvbnRyb2wgMzAwKQpbICAgIDcuNTkzODM1XSBhdGEy LjAwOiBBVEFQSTogSEwtRFQtU1QgRFZEKy8tUlcgR1U2ME4sIEExMDMsIG1heCBVRE1BLzEz MwpbICAgIDcuNjA0MTQ3XSBhdGEyLjAwOiBjb25maWd1cmVkIGZvciBVRE1BLzEzMwpbICAg IDcuNjE0NzQ2XSB1c2IgMS0xLjU6IE5ldyBVU0IgZGV2aWNlIGZvdW5kLCBpZFZlbmRvcj0w NWNhLCBpZFByb2R1Y3Q9MTgxYwpbICAgIDcuNjE0NzU3XSB1c2IgMS0xLjU6IE5ldyBVU0Ig ZGV2aWNlIHN0cmluZ3M6IE1mcj0xLCBQcm9kdWN0PTIsIFNlcmlhbE51bWJlcj0wClsgICAg Ny42MTQ3NjNdIHVzYiAxLTEuNTogUHJvZHVjdDogTGFwdG9wX0ludGVncmF0ZWRfV2ViY2Ft X0ZIRApbICAgIDcuNjE0NzY4XSB1c2IgMS0xLjU6IE1hbnVmYWN0dXJlcjogQ04wQ0ozUDI3 MjQ4NzE3RjA0MFNBMDEKWyAgICA3LjYxODY2Ml0gc2NzaSAxOjA6MDowOiBDRC1ST00gICAg ICAgICAgICBITC1EVC1TVCBEVkQrLVJXIEdVNjBOICAgIEExMDMgUFE6IDAgQU5TSTogNQpb ICAgIDcuNjg2NTgxXSB1c2IgMi0xLjY6IG5ldyBoaWdoLXNwZWVkIFVTQiBkZXZpY2UgbnVt YmVyIDMgdXNpbmcgZWhjaV9oY2QKWyAgICA3Ljc5NTM5OV0gdXNiIDItMS42OiBOZXcgVVNC IGRldmljZSBmb3VuZCwgaWRWZW5kb3I9NDEzYywgaWRQcm9kdWN0PTgxOGQKWyAgICA3Ljc5 NTQxMF0gdXNiIDItMS42OiBOZXcgVVNCIGRldmljZSBzdHJpbmdzOiBNZnI9MSwgUHJvZHVj dD0yLCBTZXJpYWxOdW1iZXI9MwpbICAgIDcuNzk1NDE2XSB1c2IgMi0xLjY6IFByb2R1Y3Q6 IERXNTU1MApbICAgIDcuNzk1NDIwXSB1c2IgMi0xLjY6IE1hbnVmYWN0dXJlcjogRGVsbApb ICAgIDcuNzk1NDI1XSB1c2IgMi0xLjY6IFNlcmlhbE51bWJlcjogODhGQTY1M0ZERjk0NDk3 MApbICAgIDcuOTAyNzcwXSB1c2IgMi0xLjg6IG5ldyBmdWxsLXNwZWVkIFVTQiBkZXZpY2Ug bnVtYmVyIDQgdXNpbmcgZWhjaV9oY2QKWyAgICA3LjkzODQ3OF0gYXRhNDogU0FUQSBsaW5r IGRvd24gKFNTdGF0dXMgMCBTQ29udHJvbCAzMDApClsgICAgOC4wMTczMTldIHVzYiAyLTEu ODogTmV3IFVTQiBkZXZpY2UgZm91bmQsIGlkVmVuZG9yPTBhNWMsIGlkUHJvZHVjdD01ODAx ClsgICAgOC4wMTczMzBdIHVzYiAyLTEuODogTmV3IFVTQiBkZXZpY2Ugc3RyaW5nczogTWZy PTEsIFByb2R1Y3Q9MiwgU2VyaWFsTnVtYmVyPTMKWyAgICA4LjAxNzMzNl0gdXNiIDItMS44 OiBQcm9kdWN0OiA1ODgwClsgICAgOC4wMTczNDBdIHVzYiAyLTEuODogTWFudWZhY3R1cmVy OiBCcm9hZGNvbSBDb3JwClsgICAgOC4wMTczNDRdIHVzYiAyLTEuODogU2VyaWFsTnVtYmVy OiAwMTIzNDU2Nzg5QUJDRApbICAgIDguMDE3Nzk0XSB1c2IgMi0xLjg6IGNvbmZpZyAwIGRl c2NyaXB0b3I/PwpbICAgIDguMjU4NDExXSBhdGE1OiBTQVRBIGxpbmsgZG93biAoU1N0YXR1 cyAwIFNDb250cm9sIDMwMCkKWyAgICA4LjU3ODQ4MF0gYXRhNjogU0FUQSBsaW5rIGRvd24g KFNTdGF0dXMgMCBTQ29udHJvbCAzMDApClsgICAgOC41ODg2MzBdIHNkIDA6MDowOjA6IFtz ZGFdIDUwMDExODE5MiA1MTItYnl0ZSBsb2dpY2FsIGJsb2NrczogKDI1NiBHQi8yMzggR2lC KQpbICAgIDguNTg4ODQ2XSBzZCAwOjA6MDowOiBbc2RhXSBXcml0ZSBQcm90ZWN0IGlzIG9m ZgpbICAgIDguNTg4ODYxXSBzZCAwOjA6MDowOiBbc2RhXSBNb2RlIFNlbnNlOiAwMCAzYSAw MCAwMApbICAgIDguNTg4OTY3XSBzZCAwOjA6MDowOiBbc2RhXSBXcml0ZSBjYWNoZTogZW5h YmxlZCwgcmVhZCBjYWNoZTogZW5hYmxlZCwgZG9lc24ndCBzdXBwb3J0IERQTyBvciBGVUEK WyAgICA4LjU5MDEyMl0gIHNkYTogc2RhMSBzZGEyClsgICAgOC41OTEwNTldIHNkIDA6MDow OjA6IFtzZGFdIEF0dGFjaGVkIFNDU0kgZGlzawpbICAgIDguNjA5NDM4XSBzcjA6IHNjc2kz LW1tYyBkcml2ZTogMjR4Lzh4IHdyaXRlciBkdmQtcmFtIGNkL3J3IHhhL2Zvcm0yIGNkZGEg dHJheQpbICAgIDguNjA5NDUxXSBjZHJvbTogVW5pZm9ybSBDRC1ST00gZHJpdmVyIFJldmlz aW9uOiAzLjIwClsgICAgOC42MDk3MzddIHNyIDE6MDowOjA6IEF0dGFjaGVkIHNjc2kgQ0Qt Uk9NIHNyMApbICAgIDguNzE0NTE1XSBkcmFjdXQ6IGx1a3NPcGVuIC9kZXYvc2RhMiBsdWtz LTQwMDMzNmZhLWM3YzQtNGJlMy1hMjQ0LWM5MDlhYTE2YTE4YwpbICAgMTMuODYyNTY0XSBk cmFjdXQ6IFNjYW5uaW5nIGRldmljZXMgZG0tMCAgZm9yIExWTSBsb2dpY2FsIHZvbHVtZXMg dmdfZG9tMC9sdl9yb290IHZnX2RvbTAvbHZfc3dhcCAKWyAgIDEzLjkwNzYzOV0gZHJhY3V0 OiBpbmFjdGl2ZSAnL2Rldi92Z19kb20wL2x2X3Jvb3QnIFsyMjEuNjIgR2lCXSBpbmhlcml0 ClsgICAxMy45MDc3MDhdIGRyYWN1dDogaW5hY3RpdmUgJy9kZXYvdmdfZG9tMC9sdl9zd2Fw JyBbMTYuMzQgR2lCXSBpbmhlcml0ClsgICAxNC4xNjI2ODRdIEVYVDQtZnMgKGRtLTEpOiBJ TkZPOiByZWNvdmVyeSByZXF1aXJlZCBvbiByZWFkb25seSBmaWxlc3lzdGVtClsgICAxNC4x NjI2OTNdIEVYVDQtZnMgKGRtLTEpOiB3cml0ZSBhY2Nlc3Mgd2lsbCBiZSBlbmFibGVkIGR1 cmluZyByZWNvdmVyeQpbICAgMTQuNzc1Nzc5XSBFWFQ0LWZzIChkbS0xKTogb3JwaGFuIGNs ZWFudXAgb24gcmVhZG9ubHkgZnMKWyAgIDE0Ljc3NTgwMF0gRVhUNC1mcyAoZG0tMSk6IGV4 dDRfb3JwaGFuX2NsZWFudXA6IGRlbGV0aW5nIHVucmVmZXJlbmNlZCBpbm9kZSA1NzY3MjA5 ClsgICAxNC43NzU5MDldIEVYVDQtZnMgKGRtLTEpOiBleHQ0X29ycGhhbl9jbGVhbnVwOiBk ZWxldGluZyB1bnJlZmVyZW5jZWQgaW5vZGUgNTc2NzIwNwpbICAgMTQuNzc2MDA3XSBFWFQ0 LWZzIChkbS0xKTogZXh0NF9vcnBoYW5fY2xlYW51cDogZGVsZXRpbmcgdW5yZWZlcmVuY2Vk IGlub2RlIDU3NjcyMDUKWyAgIDE0Ljc3NjAzNV0gRVhUNC1mcyAoZG0tMSk6IGV4dDRfb3Jw aGFuX2NsZWFudXA6IGRlbGV0aW5nIHVucmVmZXJlbmNlZCBpbm9kZSA1NzY3MjA2ClsgICAx NC43NzYwNjJdIEVYVDQtZnMgKGRtLTEpOiBleHQ0X29ycGhhbl9jbGVhbnVwOiBkZWxldGlu ZyB1bnJlZmVyZW5jZWQgaW5vZGUgNTc2NzIwNApbICAgMTQuNzc2MDg4XSBFWFQ0LWZzIChk bS0xKTogZXh0NF9vcnBoYW5fY2xlYW51cDogZGVsZXRpbmcgdW5yZWZlcmVuY2VkIGlub2Rl IDU3NjcyMDIKWyAgIDE0Ljc3NjExN10gRVhUNC1mcyAoZG0tMSk6IGV4dDRfb3JwaGFuX2Ns ZWFudXA6IGRlbGV0aW5nIHVucmVmZXJlbmNlZCBpbm9kZSA1NzY3MTk4ClsgICAxNC43NzYx NDZdIEVYVDQtZnMgKGRtLTEpOiBleHQ0X29ycGhhbl9jbGVhbnVwOiBkZWxldGluZyB1bnJl ZmVyZW5jZWQgaW5vZGUgNTc2NzE5NgpbICAgMTQuNzc2MTcyXSBFWFQ0LWZzIChkbS0xKTog ZXh0NF9vcnBoYW5fY2xlYW51cDogZGVsZXRpbmcgdW5yZWZlcmVuY2VkIGlub2RlIDU3Njcx OTEKWyAgIDE0Ljc3NjE5OF0gRVhUNC1mcyAoZG0tMSk6IGV4dDRfb3JwaGFuX2NsZWFudXA6 IGRlbGV0aW5nIHVucmVmZXJlbmNlZCBpbm9kZSA1NzY3MTg5ClsgICAxNC43NzYyMjddIEVY VDQtZnMgKGRtLTEpOiBleHQ0X29ycGhhbl9jbGVhbnVwOiBkZWxldGluZyB1bnJlZmVyZW5j ZWQgaW5vZGUgNTc2NzE4OApbICAgMTQuNzc2Mjc0XSBFWFQ0LWZzIChkbS0xKTogZXh0NF9v cnBoYW5fY2xlYW51cDogZGVsZXRpbmcgdW5yZWZlcmVuY2VkIGlub2RlIDU3NjcxODcKWyAg IDE0Ljc3NzAxOF0gRVhUNC1mcyAoZG0tMSk6IGV4dDRfb3JwaGFuX2NsZWFudXA6IGRlbGV0 aW5nIHVucmVmZXJlbmNlZCBpbm9kZSA1NzY3MTg2ClsgICAxNC43NzcwNjBdIEVYVDQtZnMg KGRtLTEpOiBleHQ0X29ycGhhbl9jbGVhbnVwOiBkZWxldGluZyB1bnJlZmVyZW5jZWQgaW5v ZGUgNTc2NzE4NApbICAgMTQuNzc3MDg5XSBFWFQ0LWZzIChkbS0xKTogZXh0NF9vcnBoYW5f Y2xlYW51cDogZGVsZXRpbmcgdW5yZWZlcmVuY2VkIGlub2RlIDU3NjcxODMKWyAgIDE0Ljc3 NzExN10gRVhUNC1mcyAoZG0tMSk6IGV4dDRfb3JwaGFuX2NsZWFudXA6IGRlbGV0aW5nIHVu cmVmZXJlbmNlZCBpbm9kZSA1NzY3MTcxClsgICAxNC43NzcxNDZdIEVYVDQtZnMgKGRtLTEp OiBleHQ0X29ycGhhbl9jbGVhbnVwOiBkZWxldGluZyB1bnJlZmVyZW5jZWQgaW5vZGUgNTc2 NzE3MApbICAgMTQuNzc3MTcyXSBFWFQ0LWZzIChkbS0xKTogMTcgb3JwaGFuIGlub2RlcyBk ZWxldGVkClsgICAxNC43NzcxNzddIEVYVDQtZnMgKGRtLTEpOiByZWNvdmVyeSBjb21wbGV0 ZQpbICAgMTQuNzk3MTI0XSBFWFQ0LWZzIChkbS0xKTogbW91bnRlZCBmaWxlc3lzdGVtIHdp dGggb3JkZXJlZCBkYXRhIG1vZGUuIE9wdHM6IChudWxsKQpbICAgMTQuODA2NzYyXSBkcmFj dXQ6IE1vdW50ZWQgcm9vdCBmaWxlc3lzdGVtIC9kZXYvbWFwcGVyL3ZnX2RvbTAtbHZfcm9v dApbICAgMTQuOTU3MjExXSBkcmFjdXQ6IFN3aXRjaGluZyByb290ClsgICAxNS41OTkyNjFd IHVkZXY6IHN0YXJ0aW5nIHZlcnNpb24gMTUxClsgICAxNS42NzM2NzRdIGlUQ09fdmVuZG9y X3N1cHBvcnQ6IHZlbmRvci1zdXBwb3J0PTAKWyAgIDE1LjY3NjM3NF0gbWVpOiBtb2R1bGUg aXMgZnJvbSB0aGUgc3RhZ2luZyBkaXJlY3RvcnksIHRoZSBxdWFsaXR5IGlzIHVua25vd24s IHlvdSBoYXZlIGJlZW4gd2FybmVkLgpbICAgMTUuNjc2NDg4XSBpVENPX3dkdDogSW50ZWwg VENPIFdhdGNoRG9nIFRpbWVyIERyaXZlciB2MS4wNwpbICAgMTUuNjc2Njc5XSBpVENPX3dk dDogRm91bmQgYSBDb3VnYXIgUG9pbnQgVENPIGRldmljZSAoVmVyc2lvbj0yLCBUQ09CQVNF PTB4MDQ2MCkKWyAgIDE1LjY3NjcxMV0geGVuOiByZWdpc3RlcmluZyBnc2kgMTYgdHJpZ2dl cmluZyAwIHBvbGFyaXR5IDEKWyAgIDE1LjY3NjcxNl0gQWxyZWFkeSBzZXR1cCB0aGUgR1NJ IDoxNgpbICAgMTUuNjc2NzI1XSBtZWkgMDAwMDowMDoxNi4wOiBzZXR0aW5nIGxhdGVuY3kg dGltZXIgdG8gNjQKWyAgIDE1LjY3Njc1NF0gaVRDT193ZHQ6IGluaXRpYWxpemVkLiBoZWFy dGJlYXQ9MzAgc2VjIChub3dheW91dD0wKQpbICAgMTUuNzEyNTgyXSBzZCAwOjA6MDowOiBB dHRhY2hlZCBzY3NpIGdlbmVyaWMgc2cwIHR5cGUgMApbICAgMTUuNzEyNjIwXSBzciAxOjA6 MDowOiBBdHRhY2hlZCBzY3NpIGdlbmVyaWMgc2cxIHR5cGUgNQpbICAgMTUuNzMwNDQ4XSBp bnB1dDogUEMgU3BlYWtlciBhcyAvZGV2aWNlcy9wbGF0Zm9ybS9wY3Nwa3IvaW5wdXQvaW5w dXQ4ClsgICAxNS43MzQ0OTRdIHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDE4IHRyaWdnZXJpbmcg MCBwb2xhcml0eSAxClsgICAxNS43MzQ1MDBdIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6MTgK WyAgIDE1LjczNDUwNl0gQUNQSSBXYXJuaW5nOiAweDAwMDAwMDAwMDAwMDQwNDAtMHgwMDAw MDAwMDAwMDA0MDVmIFN5c3RlbUlPIGNvbmZsaWN0cyB3aXRoIFJlZ2lvbiBcX1NCXy5QQ0kw LlNCVVMuU01CSSAxICgyMDEyMDMyMC91dGFkZHJlc3MtMjUxKQpbICAgMTUuNzM0NTEyXSBB Q1BJOiBJZiBhbiBBQ1BJIGRyaXZlciBpcyBhdmFpbGFibGUgZm9yIHRoaXMgZGV2aWNlLCB5 b3Ugc2hvdWxkIHVzZSBpdCBpbnN0ZWFkIG9mIHRoZSBuYXRpdmUgZHJpdmVyClsgICAxNS43 MzcwMDJdIG1pY3JvY29kZTogQ1BVMCBzaWc9MHgyMDZhNywgcGY9MHgxMCwgcmV2aXNpb249 MHgyMwpbICAgMTUuNzQxNDEyXSB3YXRjaGRvZzogSU5UQ0FNVDogY2Fubm90IHJlZ2lzdGVy IG1pc2NkZXYgb24gbWlub3I9MTMwIChlcnI9LTE2KQpbICAgMTUuNzQxNDE4XSB3YXRjaGRv ZzogZXJyb3IgcmVnaXN0ZXJpbmcgL2Rldi93YXRjaGRvZyAoZXJyPS0xNikKWyAgIDE1Ljc0 MTQyMl0gbWVpIDAwMDA6MDA6MTYuMDogdW5hYmxlIHRvIHJlZ2lzdGVyIHdhdGNoZG9nIGRl dmljZS4KWyAgIDE1Ljc5MDYzN10gdGhlcm1hbCBMTlhUSEVSTTowMDogcmVnaXN0ZXJlZCBh cyB0aGVybWFsX3pvbmUwClsgICAxNS43OTA2NDFdIEFDUEk6IFRoZXJtYWwgWm9uZSBbVEhN XSAoMjUgQykKWyAgIDE1LjgxNDU1MV0gQUNQSTogRGVwcmVjYXRlZCBwcm9jZnMgSS9GIGZv ciBiYXR0ZXJ5IGlzIGxvYWRlZCwgcGxlYXNlIHJldHJ5IHdpdGggQ09ORklHX0FDUElfUFJP Q0ZTX1BPV0VSIGNsZWFyZWQKWyAgIDE1LjgxNDU1OV0gQUNQSTogQmF0dGVyeSBTbG90IFtC QVQwXSAoYmF0dGVyeSBwcmVzZW50KQpbICAgMTUuODE1MDM3XSBBQ1BJOiBEZXByZWNhdGVk IHByb2NmcyBJL0YgZm9yIEFDIGlzIGxvYWRlZCwgcGxlYXNlIHJldHJ5IHdpdGggQ09ORklH X0FDUElfUFJPQ0ZTX1BPV0VSIGNsZWFyZWQKWyAgIDE1LjgxNTUyMV0gQUNQSTogQUMgQWRh cHRlciBbQUNdIChvbi1saW5lKQpbICAgMTUuODY3ODM1XSB1c2Jjb3JlOiByZWdpc3RlcmVk IG5ldyBpbnRlcmZhY2UgZHJpdmVyIHVzYmJhY2sKWyAgIDE1Ljk3NTgyNl0gQUNQSTogRGVw cmVjYXRlZCBwcm9jZnMgSS9GIGZvciBiYXR0ZXJ5IGlzIGxvYWRlZCwgcGxlYXNlIHJldHJ5 IHdpdGggQ09ORklHX0FDUElfUFJPQ0ZTX1BPV0VSIGNsZWFyZWQKWyAgIDE1Ljk3NTgzNl0g QUNQSTogQmF0dGVyeSBTbG90IFtCQVQxXSAoYmF0dGVyeSBhYnNlbnQpClsgICAxNi4xMDI4 NzFdIEFDUEk6IERlcHJlY2F0ZWQgcHJvY2ZzIEkvRiBmb3IgYmF0dGVyeSBpcyBsb2FkZWQs IHBsZWFzZSByZXRyeSB3aXRoIENPTkZJR19BQ1BJX1BST0NGU19QT1dFUiBjbGVhcmVkClsg ICAxNi4xMDI4ODJdIEFDUEk6IEJhdHRlcnkgU2xvdCBbQkFUMl0gKGJhdHRlcnkgYWJzZW50 KQpbICAgMTYuMTA2NzkzXSBzZGhjaTogU2VjdXJlIERpZ2l0YWwgSG9zdCBDb250cm9sbGVy IEludGVyZmFjZSBkcml2ZXIKWyAgIDE2LjEwNjc5N10gc2RoY2k6IENvcHlyaWdodChjKSBQ aWVycmUgT3NzbWFuClsgICAxNi4xMDcxMzFdIHBhcnBvcnRfcGMgMDA6MDg6IFtpbyAgMHgw Mzc4LTB4MDM3Yl0KWyAgIDE2LjEwNzI5Nl0gcGFycG9ydF9wYyAwMDowODogW2lycSA1XQpb ICAgMTYuMTA3NzA5XSBzZGhjaS1wY2kgMDAwMDowYTowMC4wOiBTREhDSSBjb250cm9sbGVy IGZvdW5kIFsxMjE3OjgyMjFdIChyZXYgNSkKWyAgIDE2LjE1OTE0OF0geGVuOiByZWdpc3Rl cmluZyBnc2kgMTcgdHJpZ2dlcmluZyAwIHBvbGFyaXR5IDEKWyAgIDE2LjE1OTE1Nl0gQWxy ZWFkeSBzZXR1cCB0aGUgR1NJIDoxNwpbICAgMTYuMTU5MjQxXSBzZGhjaS1wY2kgMDAwMDow YTowMC4wOiBJbnZhbGlkIGlvbWVtIHNpemUuIFlvdSBtYXkgZXhwZXJpZW5jZSBwcm9ibGVt cy4KWyAgIDE2LjE1OTMxOV0gMDAwMDowYTowMC4wIHN1cHBseSB2bW1jIG5vdCBmb3VuZCwg dXNpbmcgZHVtbXkgcmVndWxhdG9yClsgICAxNi4xNTkzODRdIFJlZ2lzdGVyZWQgbGVkIGRl dmljZTogbW1jMDo6ClsgICAxNi4xNjA0NDJdIG1tYzA6IFNESENJIGNvbnRyb2xsZXIgb24g UENJIFswMDAwOjBhOjAwLjBdIHVzaW5nIERNQQpbICAgMTYuMTYwOTI4XSBzZGhjaS1wY2kg MDAwMDowYTowMC4wOiBjb3VsZCBub3Qgc2V0IHJlZ3VsYXRvciBPQ1IgKC0yMikKWyAgIDE2 LjE3MTczN10gTGludXggdmlkZW8gY2FwdHVyZSBpbnRlcmZhY2U6IHYyLjAwClsgICAxNi4x OTIxNThdIGNkY193ZG0gMi0xLjY6MS41OiBjZGMtd2RtMDogVVNCIFdETSBkZXZpY2UKWyAg IDE2LjE5MjIxMV0gY2RjX3dkbSAyLTEuNjoxLjg6IGNkYy13ZG0xOiBVU0IgV0RNIGRldmlj ZQpbICAgMTYuMTkyMjM0XSB1c2Jjb3JlOiByZWdpc3RlcmVkIG5ldyBpbnRlcmZhY2UgZHJp dmVyIGNkY193ZG0KWyAgIDE2LjE5NTc0NF0gY2RjX2FjbSAyLTEuNjoxLjE6IHR0eUFDTTA6 IFVTQiBBQ00gZGV2aWNlClsgICAxNi4xOTg3MzldIHNkaGNpLXBjaSAwMDAwOjBhOjAwLjA6 IGNvdWxkIG5vdCBzZXQgcmVndWxhdG9yIE9DUiAoLTIyKQpbICAgMTYuMjIwNTMyXSBjZGNf YWNtIDItMS42OjEuMzogdHR5QUNNMTogVVNCIEFDTSBkZXZpY2UKWyAgIDE2LjIyMzcyOF0g Y2RjX2FjbSAyLTEuNjoxLjk6IHR0eUFDTTI6IFVTQiBBQ00gZGV2aWNlClsgICAxNi4yMzUw ODldIHNkaGNpLXBjaSAwMDAwOjBhOjAwLjA6IGNvdWxkIG5vdCBzZXQgcmVndWxhdG9yIE9D UiAoLTIyKQpbICAgMTYuMjM1MjM0XSB1c2Jjb3JlOiByZWdpc3RlcmVkIG5ldyBpbnRlcmZh Y2UgZHJpdmVyIGNkY19hY20KWyAgIDE2LjIzNTIzNl0gY2RjX2FjbTogVVNCIEFic3RyYWN0 IENvbnRyb2wgTW9kZWwgZHJpdmVyIGZvciBVU0IgbW9kZW1zIGFuZCBJU0ROIGFkYXB0ZXJz ClsgICAxNi4yNDAyMzVdIHV2Y3ZpZGVvOiBGb3VuZCBVVkMgMS4wMCBkZXZpY2UgTGFwdG9w X0ludGVncmF0ZWRfV2ViY2FtX0ZIRCAoMDVjYToxODFjKQpbICAgMTYuMjY5NDc0XSBpbnB1 dDogTGFwdG9wX0ludGVncmF0ZWRfV2ViY2FtX0ZIRCBhcyAvZGV2aWNlcy9wY2kwMDAwOjAw LzAwMDA6MDA6MWEuMC91c2IxLzEtMS8xLTEuNS8xLTEuNToxLjAvaW5wdXQvaW5wdXQ5Clsg ICAxNi4yNjk1NzldIHVzYmNvcmU6IHJlZ2lzdGVyZWQgbmV3IGludGVyZmFjZSBkcml2ZXIg dXZjdmlkZW8KWyAgIDE2LjI2OTU4MV0gVVNCIFZpZGVvIENsYXNzIGRyaXZlciAoMS4xLjEp ClsgICAxNi4yNzc0MTVdIHNkaGNpLXBjaSAwMDAwOjBhOjAwLjA6IGNvdWxkIG5vdCBzZXQg cmVndWxhdG9yIE9DUiAoLTIyKQpbICAgMTYuMjk2NjQ2XSB1c2IgMi0xLjY6IE1BQy1BZGRy ZXNzOiAwMjo4MDozNzplYzowMjowMApbICAgMTYuMjk2ODEwXSBjZGNfbmNtIDItMS42OjEu NjogdXNiMDogcmVnaXN0ZXIgJ2NkY19uY20nIGF0IHVzYi0wMDAwOjAwOjFkLjAtMS42LCBD REMgTkNNLCAwMjo4MDozNzplYzowMjowMApbICAgMTYuMjk2ODQ3XSB1c2Jjb3JlOiByZWdp c3RlcmVkIG5ldyBpbnRlcmZhY2UgZHJpdmVyIGNkY19uY20KWyAgIDE2LjMxMDYwNF0gcGFy cG9ydF9wYyAwMDowODogYWN0aXZhdGVkClsgICAxNi4zMTA2MTFdIHBhcnBvcnRfcGMgMDA6 MDg6IHJlcG9ydGVkIGJ5IFBsdWcgYW5kIFBsYXkgQUNQSQpbICAgMTYuMzEwNzgxXSBwYXJw b3J0X3BjIDAwOjA4OiBkaXNhYmxlZApbICAgMTYuMzExNTgzXSB0cG1fdGlzIDAwOjBhOiAx LjIgVFBNIChkZXZpY2UtaWQgMHgyMDAxLCByZXYtaWQgMzIpClsgICAxNi4zOTkyOTZdIEJs dWV0b290aDogQ29yZSB2ZXIgMi4xNgpbICAgMTYuMzk5MzEyXSBORVQ6IFJlZ2lzdGVyZWQg cHJvdG9jb2wgZmFtaWx5IDMxClsgICAxNi4zOTkzMTRdIEJsdWV0b290aDogSENJIGRldmlj ZSBhbmQgY29ubmVjdGlvbiBtYW5hZ2VyIGluaXRpYWxpemVkClsgICAxNi4zOTkzMTddIEJs dWV0b290aDogSENJIHNvY2tldCBsYXllciBpbml0aWFsaXplZApbICAgMTYuMzk5MzE4XSBC bHVldG9vdGg6IEwyQ0FQIHNvY2tldCBsYXllciBpbml0aWFsaXplZApbICAgMTYuMzk5MzI1 XSBCbHVldG9vdGg6IFNDTyBzb2NrZXQgbGF5ZXIgaW5pdGlhbGl6ZWQKWyAgIDE2LjQ1MDU4 M10geGVuOiByZWdpc3RlcmluZyBnc2kgMjIgdHJpZ2dlcmluZyAwIHBvbGFyaXR5IDEKWyAg IDE2LjQ1MDYwMF0geGVuOiAtLT4gcGlycT0yMiAtPiBpcnE9MjIgKGdzaT0yMikKWyAgIDE2 LjU2NzU3N10gdXNiY29yZTogcmVnaXN0ZXJlZCBuZXcgaW50ZXJmYWNlIGRyaXZlciBidHVz YgpbICAgMTYuNzM5MjU5XSBkY2RiYXMgZGNkYmFzOiBEZWxsIFN5c3RlbXMgTWFuYWdlbWVu dCBCYXNlIERyaXZlciAodmVyc2lvbiA1LjYuMC0zLjIpClsgICAxNi44MTkxMjVdIGlucHV0 OiBEZWxsIFdNSSBob3RrZXlzIGFzIC9kZXZpY2VzL3ZpcnR1YWwvaW5wdXQvaW5wdXQxMApb ICAgMTYuOTI1MDAwXSBtaWNyb2NvZGU6IENQVTEgc2lnPTB4MjA2YTcsIHBmPTB4MTAsIHJl dmlzaW9uPTB4MjMKWyAgIDE2LjkyOTI0Nl0gcHBkZXY6IHVzZXItc3BhY2UgcGFyYWxsZWwg cG9ydCBkcml2ZXIKWyAgIDE2Ljk1NDc4M10gbWljcm9jb2RlOiBDUFUyIHNpZz0weDIwNmE3 LCBwZj0weDEwLCByZXZpc2lvbj0weDIzClsgICAxNi45NzUxNzZdIG1pY3JvY29kZTogQ1BV MyBzaWc9MHgyMDZhNywgcGY9MHgxMCwgcmV2aXNpb249MHgyMwpbICAgMTcuMDA0Njk2XSBt aWNyb2NvZGU6IE1pY3JvY29kZSBVcGRhdGUgRHJpdmVyOiB2Mi4wMCA8dGlncmFuQGFpdmF6 aWFuLmZzbmV0LmNvLnVrPiwgUGV0ZXIgT3J1YmEKWyAgIDE3LjA2NzEyM10gQUxTQSBoZGFf Y29kZWMuYzo1MTAxIGF1dG9jb25maWc6IGxpbmVfb3V0cz0xICgweGUvMHgwLzB4MC8weDAv MHgwKSB0eXBlOmxpbmUKWyAgIDE3LjA2NzEyN10gQUxTQSBoZGFfY29kZWMuYzo1MTA1ICAg IHNwZWFrZXJfb3V0cz0xICgweGQvMHgwLzB4MC8weDAvMHgwKQpbICAgMTcuMDY3MTI5XSBB TFNBIGhkYV9jb2RlYy5jOjUxMDkgICAgaHBfb3V0cz0xICgweGIvMHgwLzB4MC8weDAvMHgw KQpbICAgMTcuMDY3MTMxXSBBTFNBIGhkYV9jb2RlYy5jOjUxMTAgICAgbW9ubzogbW9ub19v dXQ9MHgwClsgICAxNy4wNjcxMzNdIEFMU0EgaGRhX2NvZGVjLmM6NTExNCAgICBpbnB1dHM6 ClsgICAxNy4wNjcxMzVdIEFMU0EgaGRhX2NvZGVjLmM6NTExOCAgTWljPTB4YQpbICAgMTcu MDY3MTM3XSBBTFNBIGhkYV9jb2RlYy5jOjUxMTggIERvY2sgTWljPTB4ZgpbICAgMTcuMDY3 MTM5XSBBTFNBIGhkYV9jb2RlYy5jOjUxMjAgClsgICAxNy4wNjc2MzddIEFMU0EgcGF0Y2hf c2lnbWF0ZWwuYzozMTE3IHN0YWM5Mnh4OiBkYWNfbmlkcz0xICgweDEzLzB4MC8weDAvMHgw LzB4MCkKWyAgIDE3LjA4MTEwNF0gaW5wdXQ6IEhEQSBJbnRlbCBQQ0ggSERNSS9EUCxwY209 OCBhcyAvZGV2aWNlcy9wY2kwMDAwOjAwLzAwMDA6MDA6MWIuMC9zb3VuZC9jYXJkMC9pbnB1 dDExClsgICAxNy4wODExOTRdIGlucHV0OiBIREEgSW50ZWwgUENIIEhETUkvRFAscGNtPTcg YXMgL2RldmljZXMvcGNpMDAwMDowMC8wMDAwOjAwOjFiLjAvc291bmQvY2FyZDAvaW5wdXQx MgpbICAgMTcuMDgxMjUwXSBpbnB1dDogSERBIEludGVsIFBDSCBIRE1JL0RQLHBjbT0zIGFz IC9kZXZpY2VzL3BjaTAwMDA6MDAvMDAwMDowMDoxYi4wL3NvdW5kL2NhcmQwL2lucHV0MTMK WyAgIDE3LjA4MTM0Ml0gaW5wdXQ6IEhEQSBJbnRlbCBQQ0ggRG9jayBNaWMgYXMgL2Rldmlj ZXMvcGNpMDAwMDowMC8wMDAwOjAwOjFiLjAvc291bmQvY2FyZDAvaW5wdXQxNApbICAgMTcu MDgxNDMyXSBpbnB1dDogSERBIEludGVsIFBDSCBNaWMgYXMgL2RldmljZXMvcGNpMDAwMDow MC8wMDAwOjAwOjFiLjAvc291bmQvY2FyZDAvaW5wdXQxNQpbICAgMTcuMDgxNTIyXSBpbnB1 dDogSERBIEludGVsIFBDSCBIZWFkcGhvbmUgYXMgL2RldmljZXMvcGNpMDAwMDowMC8wMDAw OjAwOjFiLjAvc291bmQvY2FyZDAvaW5wdXQxNgpbICAgMTcuMDgxNjEwXSBpbnB1dDogSERB IEludGVsIFBDSCBEb2NrIExpbmUgT3V0IGFzIC9kZXZpY2VzL3BjaTAwMDA6MDAvMDAwMDow MDoxYi4wL3NvdW5kL2NhcmQwL2lucHV0MTcKWyAgIDE3LjI2NTQ2Ml0gRXZlbnQtY2hhbm5l bCBkZXZpY2UgaW5zdGFsbGVkLgpbICAgMTcuNjYxNzY0XSBFWFQ0LWZzIChkbS0xKTogcmUt bW91bnRlZC4gT3B0czogKG51bGwpClsgICAxNy44MDI0NDZdIEVYVDQtZnMgKHNkYTEpOiBt b3VudGVkIGZpbGVzeXN0ZW0gd2l0aCBvcmRlcmVkIGRhdGEgbW9kZS4gT3B0czogKG51bGwp ClsgICAxOS4zNjE2MzFdIEFkZGluZyAxNzEzNzY2MGsgc3dhcCBvbiAvZGV2L21hcHBlci92 Z19kb20wLWx2X3N3YXAuICBQcmlvcml0eTotMSBleHRlbnRzOjEgYWNyb3NzOjE3MTM3NjYw ayBTUwpbICAgMjIuNjAyNTQ5XSBlaGNpX2hjZCAwMDAwOjAwOjFhLjA6IHJlbW92ZSwgc3Rh dGUgMQpbICAgMjIuNjAyNTY4XSB1c2IgdXNiMTogVVNCIGRpc2Nvbm5lY3QsIGRldmljZSBu dW1iZXIgMQpbICAgMjIuNjAyNTczXSB1c2IgMS0xOiBVU0IgZGlzY29ubmVjdCwgZGV2aWNl IG51bWJlciAyClsgICAyMi42MDI1NzhdIHVzYiAxLTEuNDogVVNCIGRpc2Nvbm5lY3QsIGRl dmljZSBudW1iZXIgMwpbICAgMjIuNjA1MjM1XSB1c2IgMS0xLjU6IFVTQiBkaXNjb25uZWN0 LCBkZXZpY2UgbnVtYmVyIDQKWyAgIDIyLjYzNjkxMF0gZWhjaV9oY2QgMDAwMDowMDoxYS4w OiBVU0IgYnVzIDEgZGVyZWdpc3RlcmVkClsgICAyMi42MzcxODNdIHBjaWJhY2sgMDAwMDow MDoxYS4wOiBzZWl6aW5nIGRldmljZQpbICAgMjIuNjM3MjM1XSB4ZW46IHJlZ2lzdGVyaW5n IGdzaSAxNiB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgMjIuNjM3MjQxXSBBbHJlYWR5 IHNldHVwIHRoZSBHU0kgOjE2ClsgICAyMi42NjIzNjNdIGVoY2lfaGNkIDAwMDA6MDA6MWQu MDogcmVtb3ZlLCBzdGF0ZSAxClsgICAyMi42NjIzNzFdIHVzYiB1c2IyOiBVU0IgZGlzY29u bmVjdCwgZGV2aWNlIG51bWJlciAxClsgICAyMi42NjIzNzNdIHVzYiAyLTE6IFVTQiBkaXNj b25uZWN0LCBkZXZpY2UgbnVtYmVyIDIKWyAgIDIyLjY2MjM3Nl0gdXNiIDItMS42OiBVU0Ig ZGlzY29ubmVjdCwgZGV2aWNlIG51bWJlciAzClsgICAyMi42Njg1MzFdIGNkY19uY20gMi0x LjY6MS42OiB1c2IwOiB1bnJlZ2lzdGVyICdjZGNfbmNtJyB1c2ItMDAwMDowMDoxZC4wLTEu NiwgQ0RDIE5DTQpbICAgMjIuNjk0Nzk1XSB1c2IgMi0xLjg6IFVTQiBkaXNjb25uZWN0LCBk ZXZpY2UgbnVtYmVyIDQKWyAgIDIyLjY5OTI5OF0gZWhjaV9oY2QgMDAwMDowMDoxZC4wOiBV U0IgYnVzIDIgZGVyZWdpc3RlcmVkClsgICAyMi42OTk1NzddIHBjaWJhY2sgMDAwMDowMDox ZC4wOiBzZWl6aW5nIGRldmljZQpbICAgMjIuNjk5NjMyXSB4ZW46IHJlZ2lzdGVyaW5nIGdz aSAxNyB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkgMQpbICAgMjIuNjk5NjM3XSBBbHJlYWR5IHNl dHVwIHRoZSBHU0kgOjE3ClsgICAyMy42ODQ3MDhdIHhlbi1wY2liYWNrOiB2cGNpOiAwMDAw OjAwOjE5LjA6IGFzc2lnbiB0byB2aXJ0dWFsIHNsb3QgMApbICAgMjMuNjg1MjQwXSB4ZW4t cGNpYmFjazogdnBjaTogMDAwMDowMDoxYS4wOiBhc3NpZ24gdG8gdmlydHVhbCBzbG90IDEK WyAgIDIzLjY4NTcyMl0geGVuLXBjaWJhY2s6IHZwY2k6IDAwMDA6MDA6MWQuMDogYXNzaWdu IHRvIHZpcnR1YWwgc2xvdCAyClsgICAyMy42ODY3NjRdIHhlbi1wY2liYWNrOiB2cGNpOiAw MDAwOjAyOjAwLjA6IGFzc2lnbiB0byB2aXJ0dWFsIHNsb3QgMwpbICAgMjMuOTA5NjM2XSBw Y2liYWNrIDAwMDA6MDA6MTkuMDogRHJpdmVyIHRyaWVkIHRvIHdyaXRlIHRvIGEgcmVhZC1v bmx5IGNvbmZpZ3VyYXRpb24gc3BhY2UgZmllbGQgYXQgb2Zmc2V0IDB4ZDIsIHNpemUgMi4g VGhpcyBtYXkgYmUgaGFybWxlc3MsIGJ1dCBpZiB5b3UgaGF2ZSBwcm9ibGVtcyB3aXRoIHlv dXIgZGV2aWNlOgpbICAgMjMuOTA5NjM4XSAxKSBzZWUgcGVybWlzc2l2ZSBhdHRyaWJ1dGUg aW4gc3lzZnMKWyAgIDIzLjkwOTYzOF0gMikgcmVwb3J0IHByb2JsZW1zIHRvIHRoZSB4ZW4t ZGV2ZWwgbWFpbGluZyBsaXN0IGFsb25nIHdpdGggZGV0YWlscyBvZiB5b3VyIGRldmljZSBv YnRhaW5lZCBmcm9tIGxzcGNpLgpbICAgMjMuOTE3NTIzXSBwY2liYWNrIDAwMDA6MDI6MDAu MDogRHJpdmVyIHRyaWVkIHRvIHdyaXRlIHRvIGEgcmVhZC1vbmx5IGNvbmZpZ3VyYXRpb24g c3BhY2UgZmllbGQgYXQgb2Zmc2V0IDB4ZDIsIHNpemUgMi4gVGhpcyBtYXkgYmUgaGFybWxl c3MsIGJ1dCBpZiB5b3UgaGF2ZSBwcm9ibGVtcyB3aXRoIHlvdXIgZGV2aWNlOgpbICAgMjMu OTE3NTI2XSAxKSBzZWUgcGVybWlzc2l2ZSBhdHRyaWJ1dGUgaW4gc3lzZnMKWyAgIDIzLjkx NzUyNl0gMikgcmVwb3J0IHByb2JsZW1zIHRvIHRoZSB4ZW4tZGV2ZWwgbWFpbGluZyBsaXN0 IGFsb25nIHdpdGggZGV0YWlscyBvZiB5b3VyIGRldmljZSBvYnRhaW5lZCBmcm9tIGxzcGNp LgpbICAgMjQuMTIzNjYzXSB4ZW4tYmxrYmFjazpyaW5nLXJlZiA5LCBldmVudC1jaGFubmVs IDE0LCBwcm90b2NvbCAxICh4ODZfNjQtYWJpKQpbICAgMjQuMTQwNDYwXSB4ZW4tYmxrYmFj azpyaW5nLXJlZiAxMCwgZXZlbnQtY2hhbm5lbCAxNSwgcHJvdG9jb2wgMSAoeDg2XzY0LWFi aSkKWyAgIDI0LjE1MTQyMF0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTEsIGV2ZW50LWNoYW5u ZWwgMTYsIHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgICAyNC4xNTg0MjhdIHhlbi1ibGti YWNrOnJpbmctcmVmIDEyLCBldmVudC1jaGFubmVsIDE3LCBwcm90b2NvbCAxICh4ODZfNjQt YWJpKQpbICAgMjguNjk3NjE1XSBwY2liYWNrIDAwMDA6MDA6MWEuMDogZW5hYmxpbmcgZGV2 aWNlICgwMDAwIC0+IDAwMDIpClsgICAyOC42OTc2MjhdIHhlbjogcmVnaXN0ZXJpbmcgZ3Np IDE2IHRyaWdnZXJpbmcgMCBwb2xhcml0eSAxClsgICAyOC42OTc2MzRdIEFscmVhZHkgc2V0 dXAgdGhlIEdTSSA6MTYKWyAgIDI4LjY5NzgwNV0gcGNpYmFjayAwMDAwOjAwOjFhLjA6IHNl dHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICAgMjguNzEzNTc4XSBwY2liYWNrIDAwMDA6 MDA6MTkuMDogZW5hYmxpbmcgZGV2aWNlICgwMDAwIC0+IDAwMDMpClsgICAyOC43MTM1OTFd IHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDIwIHRyaWdnZXJpbmcgMCBwb2xhcml0eSAxClsgICAy OC43MTM1OThdIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6MjAKWyAgIDI4LjcxMzg1OF0gcGNp YmFjayAwMDAwOjAwOjE5LjA6IHNldHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICAgMjku MDIxMzcxXSBwY2liYWNrIDAwMDA6MDA6MWQuMDogZW5hYmxpbmcgZGV2aWNlICgwMDAwIC0+ IDAwMDIpClsgICAyOS4wMjEzODldIHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDE3IHRyaWdnZXJp bmcgMCBwb2xhcml0eSAxClsgICAyOS4wMjE0MDBdIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6 MTcKWyAgIDI5LjAyMTgwNV0gcGNpYmFjayAwMDAwOjAwOjFkLjA6IHNldHRpbmcgbGF0ZW5j eSB0aW1lciB0byA2NApbICAgMjkuMTUwMDUzXSBwY2liYWNrIDAwMDA6MDI6MDAuMDogZW5h YmxpbmcgZGV2aWNlICgwMDAwIC0+IDAwMDIpClsgICAyOS4xNTAxMjJdIHhlbjogcmVnaXN0 ZXJpbmcgZ3NpIDE3IHRyaWdnZXJpbmcgMCBwb2xhcml0eSAxClsgICAyOS4xNTAxNTBdIEFs cmVhZHkgc2V0dXAgdGhlIEdTSSA6MTcKWyAgIDMzLjYzNTQxNl0geGVuLWJsa2JhY2s6cmlu Zy1yZWYgOSwgZXZlbnQtY2hhbm5lbCAxNCwgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAg IDMzLjY0MzMzMF0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTAsIGV2ZW50LWNoYW5uZWwgMTUs IHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgICAzMy42NTE1NjFdIHhlbi1ibGtiYWNrOnJp bmctcmVmIDExLCBldmVudC1jaGFubmVsIDE2LCBwcm90b2NvbCAxICh4ODZfNjQtYWJpKQpb ICAgMzMuNjcyMTA1XSB4ZW4tYmxrYmFjazpyaW5nLXJlZiAxMiwgZXZlbnQtY2hhbm5lbCAx NywgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAgMTA0LjIzMDkxMV0geGVuLWJsa2JhY2s6 cmluZy1yZWYgOSwgZXZlbnQtY2hhbm5lbCAyNCwgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkK WyAgMTA0LjI1MjQyMV0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTAsIGV2ZW50LWNoYW5uZWwg MjUsIHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgIDEwNC4yNTMxNzddIHhlbi1ibGtiYWNr OnJpbmctcmVmIDExLCBldmVudC1jaGFubmVsIDI2LCBwcm90b2NvbCAxICh4ODZfNjQtYWJp KQpbICAxMDQuMjU0MjIwXSB4ZW4tYmxrYmFjazpyaW5nLXJlZiAxMiwgZXZlbnQtY2hhbm5l bCAyNywgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAgMTA1LjA4NjczMl0geGVuLWJsa2Jh Y2s6cmluZy1yZWYgOSwgZXZlbnQtY2hhbm5lbCAxNCwgcHJvdG9jb2wgMSAoeDg2XzY0LWFi aSkKWyAgMTA1LjEwNTUwNV0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTAsIGV2ZW50LWNoYW5u ZWwgMTUsIHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgIDEwNS4xMTU5NTFdIHhlbi1ibGti YWNrOnJpbmctcmVmIDExLCBldmVudC1jaGFubmVsIDE2LCBwcm90b2NvbCAxICh4ODZfNjQt YWJpKQpbICAxMDUuMTI3Mzg0XSB4ZW4tYmxrYmFjazpyaW5nLXJlZiAxMiwgZXZlbnQtY2hh bm5lbCAxNywgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAgMTA1LjkyOTc2MF0geGVuLWJs a2JhY2s6cmluZy1yZWYgOSwgZXZlbnQtY2hhbm5lbCAxNCwgcHJvdG9jb2wgMSAoeDg2XzY0 LWFiaSkKWyAgMTA1LjkzNDg0MV0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTAsIGV2ZW50LWNo YW5uZWwgMTUsIHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgIDEwNS45NzM5MjBdIHhlbi1i bGtiYWNrOnJpbmctcmVmIDExLCBldmVudC1jaGFubmVsIDE2LCBwcm90b2NvbCAxICh4ODZf NjQtYWJpKQpbICAxMDUuOTc1MzIwXSB4ZW4tYmxrYmFjazpyaW5nLXJlZiAxMiwgZXZlbnQt Y2hhbm5lbCAxNywgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAgMTA3LjE5MTc4MV0geGVu LWJsa2JhY2s6cmluZy1yZWYgOSwgZXZlbnQtY2hhbm5lbCAxNCwgcHJvdG9jb2wgMSAoeDg2 XzY0LWFiaSkKWyAgMTA3LjIwMzcxMV0geGVuLWJsa2JhY2s6cmluZy1yZWYgMTAsIGV2ZW50 LWNoYW5uZWwgMTUsIHByb3RvY29sIDEgKHg4Nl82NC1hYmkpClsgIDEwNy4yMDg0ODFdIHhl bi1ibGtiYWNrOnJpbmctcmVmIDExLCBldmVudC1jaGFubmVsIDE2LCBwcm90b2NvbCAxICh4 ODZfNjQtYWJpKQpbICAxMDcuMjEyMDgxXSB4ZW4tYmxrYmFjazpyaW5nLXJlZiAxMiwgZXZl bnQtY2hhbm5lbCAxNywgcHJvdG9jb2wgMSAoeDg2XzY0LWFiaSkKWyAgNzMzLjQzNDYwOF0g UE06IFN5bmNpbmcgZmlsZXN5c3RlbXMgLi4uIGRvbmUuClsgIDczMy40MzYyMjhdIFBNOiBQ cmVwYXJpbmcgc3lzdGVtIGZvciBtZW0gc2xlZXAKWyAgNzMzLjUxNDgwM10gRnJlZXppbmcg dXNlciBzcGFjZSBwcm9jZXNzZXMgLi4uIChlbGFwc2VkIDAuMDEgc2Vjb25kcykgZG9uZS4K WyAgNzMzLjUzMDU5NF0gRnJlZXppbmcgcmVtYWluaW5nIGZyZWV6YWJsZSB0YXNrcyAuLi4g KGVsYXBzZWQgMC4wMSBzZWNvbmRzKSBkb25lLgpbICA3MzMuNTQ2NTg5XSBQTTogRW50ZXJp bmcgbWVtIHNsZWVwClsgIDczMy41NDY3NDFdIFN1c3BlbmRpbmcgY29uc29sZShzKSAodXNl IG5vX2NvbnNvbGVfc3VzcGVuZCB0byBkZWJ1ZykKWyAgNzMzLjU0NzQzMV0gc2QgMDowOjA6 MDogW3NkYV0gU3luY2hyb25pemluZyBTQ1NJIGNhY2hlClsgIDczMy41NTgzMzZdIHNkIDA6 MDowOjA6IFtzZGFdIFN0b3BwaW5nIGRpc2sKWyAgNzM0LjE5NDY1Nl0gUE06IHN1c3BlbmQg b2YgZGV2aWNlcyBjb21wbGV0ZSBhZnRlciA2NDcuNTA0IG1zZWNzClsgIDczNC4xOTUwMjZd IFBNOiBsYXRlIHN1c3BlbmQgb2YgZGV2aWNlcyBjb21wbGV0ZSBhZnRlciAwLjM1OSBtc2Vj cwpbICA3MzQuMjEwNjU1XSBQTTogbm9pcnEgc3VzcGVuZCBvZiBkZXZpY2VzIGNvbXBsZXRl IGFmdGVyIDE1LjYxNCBtc2VjcwpbICA3MzQuMjExMzI2XSBBQ1BJOiBQcmVwYXJpbmcgdG8g ZW50ZXIgc3lzdGVtIHNsZWVwIHN0YXRlIFMzClsgIDczNC4yMzUwMDhdIFBNOiBTYXZpbmcg cGxhdGZvcm0gTlZTIG1lbW9yeQpbICA3MzQuMzI4MDY2XSBEaXNhYmxpbmcgbm9uLWJvb3Qg Q1BVcyAuLi4KWyAgNzM1Ljk0NTQ5MV0gQUNQSTogTG93LWxldmVsIHJlc3VtZSBjb21wbGV0 ZQpbICA3MzUuOTQ1NTc5XSBQTTogUmVzdG9yaW5nIHBsYXRmb3JtIE5WUyBtZW1vcnkKWyAg NzM2LjAwMDA5NF0gRW5hYmxpbmcgbm9uLWJvb3QgQ1BVcyAuLi4KWyAgNzM2LjAwMDI1Nl0g aW5zdGFsbGluZyBYZW4gdGltZXIgZm9yIENQVSAxClsgIDczNi4wMDQ1OTRdIENQVTEgaXMg dXAKWyAgNzM2LjAwNDgxOV0gaW5zdGFsbGluZyBYZW4gdGltZXIgZm9yIENQVSAyClsgIDcz Ni4wNjc1MTZdIENQVTIgaXMgdXAKWyAgNzM2LjA2Nzc3MF0gaW5zdGFsbGluZyBYZW4gdGlt ZXIgZm9yIENQVSAzClsgIDczNi4xMDE1MzVdIENQVTMgaXMgdXAKWyAgNzM2LjEwMjQ3MF0g QUNQSTogV2FraW5nIHVwIGZyb20gc3lzdGVtIHNsZWVwIHN0YXRlIFMzClsgIDczNi41NTU5 MzJdIFBNOiBub2lycSByZXN1bWUgb2YgZGV2aWNlcyBjb21wbGV0ZSBhZnRlciA3Ljk3MCBt c2VjcwpbICA3MzYuNTU2NTA2XSBQTTogZWFybHkgcmVzdW1lIG9mIGRldmljZXMgY29tcGxl dGUgYWZ0ZXIgMC4zODcgbXNlY3MKWyAgNzM2LjY2MDMzNl0gaTkxNSAwMDAwOjAwOjAyLjA6 IHNldHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICA3MzYuNjYwNDA0XSBwY2liYWNrIDAw MDA6MDA6MTkuMDogc2V0dGluZyBsYXRlbmN5IHRpbWVyIHRvIDY0ClsgIDczNi42NjA0NTNd IHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDE2IHRyaWdnZXJpbmcgMCBwb2xhcml0eSAxClsgIDcz Ni42NjA0NjBdIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6MTYKWyAgNzM2LjY2MDQ5MF0gcGNp YmFjayAwMDAwOjAwOjFhLjA6IHNldHRpbmcgbGF0ZW5jeSB0aW1lciB0byA2NApbICA3MzYu NjYwNjA1XSB4ZW46IHJlZ2lzdGVyaW5nIGdzaSAxNyB0cmlnZ2VyaW5nIDAgcG9sYXJpdHkg MQpbICA3MzYuNjYwNjEwXSBBbHJlYWR5IHNldHVwIHRoZSBHU0kgOjE3ClsgIDczNi42NjA2 NDFdIHBjaWJhY2sgMDAwMDowMDoxZC4wOiBzZXR0aW5nIGxhdGVuY3kgdGltZXIgdG8gNjQK WyAgNzM2LjY2MDY5Nl0geGVuOiByZWdpc3RlcmluZyBnc2kgMjIgdHJpZ2dlcmluZyAwIHBv bGFyaXR5IDEKWyAgNzM2LjY2MDcwMV0gQWxyZWFkeSBzZXR1cCB0aGUgR1NJIDoyMgpbICA3 MzYuNjYxMjIxXSBhaGNpIDAwMDA6MDA6MWYuMjogc2V0dGluZyBsYXRlbmN5IHRpbWVyIHRv IDY0ClsgIDczNi42ODk2MDZdIHhlbjogcmVnaXN0ZXJpbmcgZ3NpIDE4IHRyaWdnZXJpbmcg MCBwb2xhcml0eSAxClsgIDczNi42ODk2MDhdIEFscmVhZHkgc2V0dXAgdGhlIEdTSSA6MTgK WyAgNzM2LjY4OTcwNF0geGVuOiByZWdpc3RlcmluZyBnc2kgMTcgdHJpZ2dlcmluZyAwIHBv bGFyaXR5IDEKWyAgNzM2LjY4OTcwNl0gQWxyZWFkeSBzZXR1cCB0aGUgR1NJIDoxNwpbICA3 MzYuNzExNjIzXSBbZHJtXSBFbmFibGluZyBSQzYgc3RhdGVzOiBSQzYgb24sIFJDNnAgb2Zm LCBSQzZwcCBvZmYKWyAgNzM2LjgwMjY3Nl0gd2F0Y2hkb2c6IElOVENBTVQ6IGNhbm5vdCBy ZWdpc3RlciBtaXNjZGV2IG9uIG1pbm9yPTEzMCAoZXJyPS0xNikKWyAgNzM2LjgwMjY3OF0g d2F0Y2hkb2c6IGVycm9yIHJlZ2lzdGVyaW5nIC9kZXYvd2F0Y2hkb2cgKGVycj0tMTYpClsg IDczNi44MDI2ODBdIG1laSAwMDAwOjAwOjE2LjA6IHVuYWJsZSB0byByZWdpc3RlciB3YXRj aGRvZyBkZXZpY2UuClsgIDczNy4wNjAxMDZdIGF0YTI6IFNBVEEgbGluayB1cCAxLjUgR2Jw cyAoU1N0YXR1cyAxMTMgU0NvbnRyb2wgMzAwKQpbICA3MzcuMDYwMzMwXSBhdGE0OiBTQVRB IGxpbmsgZG93biAoU1N0YXR1cyAwIFNDb250cm9sIDMwMCkKWyAgNzM3LjA2MDM3Ml0gYXRh NTogU0FUQSBsaW5rIGRvd24gKFNTdGF0dXMgMCBTQ29udHJvbCAzMDApClsgIDczNy4wNzQx MjNdIGF0YTIuMDA6IGNvbmZpZ3VyZWQgZm9yIFVETUEvMTMzClsgIDczNy4xMTc2MjldIGF0 YTY6IFNBVEEgbGluayBkb3duIChTU3RhdHVzIDAgU0NvbnRyb2wgMzAwKQpbICA3MzguNjE5 MDM2XSBhdGExOiBTQVRBIGxpbmsgdXAgNi4wIEdicHMgKFNTdGF0dXMgMTMzIFNDb250cm9s IDMwMCkKWyAgNzM4Ljc0MzU2NV0gYXRhMS4wMDogQUNQSSBjbWQgMDAvMDA6MDA6MDA6MDA6 MDA6YTAgKE5PUCkgcmVqZWN0ZWQgYnkgZGV2aWNlIChTdGF0PTB4NTEgRXJyPTB4MDQpClsg IDczOC45MDEwODhdIGF0YTEuMDA6IEFDUEkgY21kIDAwLzAwOjAwOjAwOjAwOjAwOmEwIChO T1ApIHJlamVjdGVkIGJ5IGRldmljZSAoU3RhdD0weDUxIEVycj0weDA0KQpbICA3MzguOTAz NDQxXSBhdGExLjAwOiBjb25maWd1cmVkIGZvciBVRE1BLzEwMApbICA3MzguOTAzODQzXSBz ZCAwOjA6MDowOiBbc2RhXSBTdGFydGluZyBkaXNrClsgIDczOC45MDUzNjddIFBNOiByZXN1 bWUgb2YgZGV2aWNlcyBjb21wbGV0ZSBhZnRlciAyMzQ4Ljg1MSBtc2VjcwpbICA3MzguOTA1 OTIyXSBQTTogRmluaXNoaW5nIHdha2V1cC4KWyAgNzM4LjkwNTkyNl0gUmVzdGFydGluZyB0 YXNrcyAuLi4gZG9uZS4KWyAgNzM4LjkxMTMzNF0gdmlkZW8gTE5YVklERU86MDA6IFJlc3Rv cmluZyBiYWNrbGlnaHQgc3RhdGUKWyAgNzM5LjgzNjI1MF0gZGVsbF93bWk6IFJlY2VpdmVk IHVua25vd24gV01JIGV2ZW50ICgweDApClsgIDc0MC4xODQ3NTldIHNkaGNpLXBjaSAwMDAw OjBhOjAwLjA6IGNvdWxkIG5vdCBzZXQgcmVndWxhdG9yIE9DUiAoLTIyKQpbICA3NDAuMjM5 NzMwXSBzZGhjaS1wY2kgMDAwMDowYTowMC4wOiBjb3VsZCBub3Qgc2V0IHJlZ3VsYXRvciBP Q1IgKC0yMikKWyAgNzQwLjMyNzcxMV0gc2RoY2ktcGNpIDAwMDA6MGE6MDAuMDogY291bGQg bm90IHNldCByZWd1bGF0b3IgT0NSICgtMjIpClsgIDc0MC4zNzM5MzFdIHNkaGNpLXBjaSAw MDAwOjBhOjAwLjA6IGNvdWxkIG5vdCBzZXQgcmVndWxhdG9yIE9DUiAoLTIyKQpbICA3NDIu NTQyMDIyXSBocnRpbWVyOiBpbnRlcnJ1cHQgdG9vayAxMDI5ODAwMzEgbnMKWyAgNzU3LjYw OTAzMV0gW3NjaGVkX2RlbGF5ZWRdIHNjaGVkOiBSVCB0aHJvdHRsaW5nIGFjdGl2YXRlZApb ICA3NjAuMTY0NDI3XSBoZGEtaW50ZWw6IElSUSB0aW1pbmcgd29ya2Fyb3VuZCBpcyBhY3Rp dmF0ZWQgZm9yIGNhcmQgIzAuIFN1Z2dlc3QgYSBiaWdnZXIgYmRsX3Bvc19hZGouCg== --------------050106030504030501010304 Content-Type: text/plain; charset=UTF-8; name="xl-dmesg.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="xl-dmesg.txt" KFhFTikgWGVuIHZlcnNpb24gNC4xLjMgKHVzZXJAbWFybWFyZWsubmV0KSAoZ2NjIHZlcnNp b24gNC40LjUgMjAxMDExMTIgKFJlZCBIYXQgNC40LjUtMikgKEdDQykgKSBNb24gTm92IDI2 IDE1OjI1OjMyIEVTVCAyMDEyCihYRU4pIExhdGVzdCBDaGFuZ2VTZXQ6IHVuYXZhaWxhYmxl CihYRU4pIEJvb3Rsb2FkZXI6IEdOVSBHUlVCIDAuOTcKKFhFTikgQ29tbWFuZCBsaW5lOiBj b25zb2xlPW5vbmUgY3B1ZnJlcT12ZXJib3NlPTEKKFhFTikgVmlkZW8gaW5mb3JtYXRpb246 CihYRU4pICBWR0EgaXMgdGV4dCBtb2RlIDgweDI1LCBmb250IDh4MTYKKFhFTikgIFZCRS9E REMgbWV0aG9kczogVjI7IEVESUQgdHJhbnNmZXIgdGltZTogMSBzZWNvbmRzCihYRU4pIERp c2MgaW5mb3JtYXRpb246CihYRU4pICBGb3VuZCAxIE1CUiBzaWduYXR1cmVzCihYRU4pICBG b3VuZCAxIEVERCBpbmZvcm1hdGlvbiBzdHJ1Y3R1cmVzCihYRU4pIFhlbi1lODIwIFJBTSBt YXA6CihYRU4pICAwMDAwMDAwMDAwMDAwMDAwIC0gMDAwMDAwMDAwMDA5YTgwMCAodXNhYmxl KQooWEVOKSAgMDAwMDAwMDAwMDA5YTgwMCAtIDAwMDAwMDAwMDAwYTAwMDAgKHJlc2VydmVk KQooWEVOKSAgMDAwMDAwMDAwMDBlMDAwMCAtIDAwMDAwMDAwMDAxMDAwMDAgKHJlc2VydmVk KQooWEVOKSAgMDAwMDAwMDAwMDEwMDAwMCAtIDAwMDAwMDAwMDdlZWEwMDAgKHVzYWJsZSkK KFhFTikgIDAwMDAwMDAwMDdlZWEwMDAgLSAwMDAwMDAwMDA3ZjY3MDAwIChBQ1BJIE5WUykK KFhFTikgIDAwMDAwMDAwMDdmNjcwMDAgLSAwMDAwMDAwMDA3ZjcwMDAwICh1c2FibGUpCihY RU4pICAwMDAwMDAwMDA3ZjcwMDAwIC0gMDAwMDAwMDAwN2Y3NjAwMCAoQUNQSSBOVlMpCihY RU4pICAwMDAwMDAwMDA3Zjc2MDAwIC0gMDAwMDAwMDAwN2Y3ODAwMCAodXNhYmxlKQooWEVO KSAgMDAwMDAwMDAwN2Y3ODAwMCAtIDAwMDAwMDAwMDgwMDAwMDAgKEFDUEkgTlZTKQooWEVO KSAgMDAwMDAwMDAwODAwMDAwMCAtIDAwMDAwMDAwMGRmZmQwMDAgKHVzYWJsZSkKKFhFTikg IDAwMDAwMDAwMGRmZmQwMDAgLSAwMDAwMDAwMDBlMDAwMDAwIChBQ1BJIGRhdGEpCihYRU4p ICAwMDAwMDAwMDBlMDAwMDAwIC0gMDAwMDAwMDAyMDAwMDAwMCAodXNhYmxlKQooWEVOKSAg MDAwMDAwMDAyMDAwMDAwMCAtIDAwMDAwMDAwMjAyMDAwMDAgKHJlc2VydmVkKQooWEVOKSAg MDAwMDAwMDAyMDIwMDAwMCAtIDAwMDAwMDAwNDAwMDAwMDAgKHVzYWJsZSkKKFhFTikgIDAw MDAwMDAwNDAwMDAwMDAgLSAwMDAwMDAwMDQwMjAwMDAwIChyZXNlcnZlZCkKKFhFTikgIDAw MDAwMDAwNDAyMDAwMDAgLSAwMDAwMDAwMGM4M2I0MDAwICh1c2FibGUpCihYRU4pICAwMDAw MDAwMGM4M2I0MDAwIC0gMDAwMDAwMDBjODQwYTAwMCAocmVzZXJ2ZWQpCihYRU4pICAwMDAw MDAwMGM4NDBhMDAwIC0gMDAwMDAwMDBjODQwZTAwMCAodXNhYmxlKQooWEVOKSAgMDAwMDAw MDBjODQwZTAwMCAtIDAwMDAwMDAwYzg0MGYwMDAgKHJlc2VydmVkKQooWEVOKSAgMDAwMDAw MDBjODQwZjAwMCAtIDAwMDAwMDAwYzg0MTEwMDAgKHVzYWJsZSkKKFhFTikgIDAwMDAwMDAw Yzg0MTEwMDAgLSAwMDAwMDAwMGM4NDE0MDAwIChyZXNlcnZlZCkKKFhFTikgIDAwMDAwMDAw Yzg0MTQwMDAgLSAwMDAwMDAwMGM4NDFlMDAwICh1c2FibGUpCihYRU4pICAwMDAwMDAwMGM4 NDFlMDAwIC0gMDAwMDAwMDBjODQyODAwMCAocmVzZXJ2ZWQpCihYRU4pICAwMDAwMDAwMGM4 NDI4MDAwIC0gMDAwMDAwMDBjODQzMjAwMCAodXNhYmxlKQooWEVOKSAgMDAwMDAwMDBjODQz MjAwMCAtIDAwMDAwMDAwYzg0MzYwMDAgKHJlc2VydmVkKQooWEVOKSAgMDAwMDAwMDBjODQz NjAwMCAtIDAwMDAwMDAwY2FjMDAwMDAgKHVzYWJsZSkKKFhFTikgIDAwMDAwMDAwY2I4MDAw MDAgLSAwMDAwMDAwMGNmYTAwMDAwIChyZXNlcnZlZCkKKFhFTikgIDAwMDAwMDAwZmVkMWMw MDAgLSAwMDAwMDAwMGZlZDIwMDAwIChyZXNlcnZlZCkKKFhFTikgIDAwMDAwMDAwZmZjMDAw MDAgLSAwMDAwMDAwMGZmYzIwMDAwIChyZXNlcnZlZCkKKFhFTikgIDAwMDAwMDAxMDAwMDAw MDAgLSAwMDAwMDAwNDJlMDAwMDAwICh1c2FibGUpCihYRU4pIEFDUEk6IFJTRFAgMDAwRkUz MDAsIDAwMjQgKHIyIERFTEwgICkKKFhFTikgQUNQSTogWFNEVCAwREZGRUUxOCwgMDA3QyAo cjEgREVMTCAgICBDQlgzICAgICA2MjIyMDA0IE1TRlQgICAgMTAwMTMpCihYRU4pIEFDUEk6 IEZBQ1AgMDdGOTBEOTgsIDAwRjQgKHI0IERFTEwgICAgQ0JYMyAgICAgNjIyMjAwNCBNU0ZU ICAgIDEwMDEzKQooWEVOKSBBQ1BJOiBEU0RUIDA3RjVFMDE4LCA4ODM0IChyMiBJTlQ0MzAg U1lTRmV4eHggICAgIDEwMDEgSU5UTCAyMDA5MDkwMykKKFhFTikgQUNQSTogRkFDUyAwN0ZF REQ0MCwgMDA0MAooWEVOKSBBQ1BJOiBBUElDIDBERkZERjE4LCAwMENDIChyMiBERUxMICAg IENCWDMgICAgIDYyMjIwMDQgTVNGVCAgICAxMDAxMykKKFhFTikgQUNQSTogVENQQSAwN0ZF RUQxOCwgMDAzMiAocjIgICAgICAgICAgICAgICAgICAgICAgICAwICAgICAgICAgICAgIDAp CihYRU4pIEFDUEk6IFNTRFQgMDdGOTFBOTgsIDAyRjkgKHIxIERFTExUUCAgICAgIFRQTSAg ICAgMzAwMCBJTlRMIDIwMDkwOTAzKQooWEVOKSBBQ1BJOiBNQ0ZHIDA3RkVFQzk4LCAwMDND IChyMSBERUxMICAgU05EWUJSREcgIDYyMjIwMDQgTVNGVCAgICAgICA5NykKKFhFTikgQUNQ STogSFBFVCAwN0ZFRUMxOCwgMDAzOCAocjEgQSBNIEkgICBQQ0hIUEVUICA2MjIyMDA0IEFN SS4gICAgICAgIDMpCihYRU4pIEFDUEk6IEJPT1QgMDdGRUVCOTgsIDAwMjggKHIxIERFTEwg ICBDQlgzICAgICAgNjIyMjAwNCBBTUkgICAgIDEwMDEzKQooWEVOKSBBQ1BJOiBTU0RUIDA3 Rjc1MDE4LCAwODA0IChyMSAgUG1SZWYgIENwdTBJc3QgICAgIDMwMDAgSU5UTCAyMDA5MDkw MykKKFhFTikgQUNQSTogU1NEVCAwN0Y3NDAxOCwgMDk5NiAocjEgIFBtUmVmICAgIENwdVBt ICAgICAzMDAwIElOVEwgMjAwOTA5MDMpCihYRU4pIEFDUEk6IERNQVIgMDdGOTBDMTgsIDAw RTggKHIxIElOVEVMICAgICAgU05CICAgICAgICAgMSBJTlRMICAgICAgICAxKQooWEVOKSBB Q1BJOiBTTElDIDA3RjdFQzE4LCAwMTc2IChyMyBERUxMICAgIENCWDMgICAgIDYyMjIwMDQg TVNGVCAgICAxMDAxMykKKFhFTikgU3lzdGVtIFJBTTogMTYyNjJNQiAoMTY2NTI0MzJrQikK KFhFTikgRG9tYWluIGhlYXAgaW5pdGlhbGlzZWQKKFhFTikgQUNQSTogMzIvNjRYIEZBQ1Mg YWRkcmVzcyBtaXNtYXRjaCBpbiBGQURUIC0gMDdmZWRlNDAvMDAwMDAwMDAwN2ZlZGQ0MCwg dXNpbmcgMzIKKFhFTikgUHJvY2Vzc29yICMwIDY6MTAgQVBJQyB2ZXJzaW9uIDIxCihYRU4p IFByb2Nlc3NvciAjMiA2OjEwIEFQSUMgdmVyc2lvbiAyMQooWEVOKSBQcm9jZXNzb3IgIzEg NjoxMCBBUElDIHZlcnNpb24gMjEKKFhFTikgUHJvY2Vzc29yICMzIDY6MTAgQVBJQyB2ZXJz aW9uIDIxCihYRU4pIElPQVBJQ1swXTogYXBpY19pZCAyLCB2ZXJzaW9uIDMyLCBhZGRyZXNz IDB4ZmVjMDAwMDAsIEdTSSAwLTIzCihYRU4pIEVuYWJsaW5nIEFQSUMgbW9kZTogIEZsYXQu ICBVc2luZyAxIEkvTyBBUElDcwooWEVOKSBUYWJsZSBpcyBub3QgZm91bmQhCihYRU4pIFN3 aXRjaGVkIHRvIEFQSUMgZHJpdmVyIHgyYXBpY19jbHVzdGVyLgooWEVOKSBVc2luZyBzY2hl ZHVsZXI6IFNNUCBDcmVkaXQgU2NoZWR1bGVyIChjcmVkaXQpCihYRU4pIERldGVjdGVkIDI0 OTQuNDE2IE1IeiBwcm9jZXNzb3IuCihYRU4pIEluaXRpbmcgbWVtb3J5IHNoYXJpbmcuCihY RU4pIEludGVsIFZULWQgc3VwcG9ydGVkIHBhZ2Ugc2l6ZXM6IDRrQi4KKFhFTikgSW50ZWwg VlQtZCBzdXBwb3J0ZWQgcGFnZSBzaXplczogNGtCLgooWEVOKSBJbnRlbCBWVC1kIFNub29w IENvbnRyb2wgbm90IGVuYWJsZWQuCihYRU4pIEludGVsIFZULWQgRG9tMCBETUEgUGFzc3Ro cm91Z2ggbm90IGVuYWJsZWQuCihYRU4pIEludGVsIFZULWQgUXVldWVkIEludmFsaWRhdGlv biBlbmFibGVkLgooWEVOKSBJbnRlbCBWVC1kIEludGVycnVwdCBSZW1hcHBpbmcgZW5hYmxl ZC4KKFhFTikgSW50ZWwgVlQtZCBTaGFyZWQgRVBUIHRhYmxlcyBub3QgZW5hYmxlZC4KKFhF TikgSS9PIHZpcnR1YWxpc2F0aW9uIGVuYWJsZWQKKFhFTikgIC0gRG9tMCBtb2RlOiBSZWxh eGVkCihYRU4pIEVuYWJsZWQgZGlyZWN0ZWQgRU9JIHdpdGggaW9hcGljX2Fja19vbGQgb24h CihYRU4pIEVOQUJMSU5HIElPLUFQSUMgSVJRcwooWEVOKSAgLT4gVXNpbmcgb2xkIEFDSyBt ZXRob2QKKFhFTikgUGxhdGZvcm0gdGltZXIgYXBwZWFycyB0byBoYXZlIHVuZXhwZWN0ZWRs eSB3cmFwcGVkIDEgdGltZXMuCihYRU4pIFBsYXRmb3JtIHRpbWVyIGlzIDE0LjMxOE1IeiBI UEVUCihYRU4pIEFsbG9jYXRlZCBjb25zb2xlIHJpbmcgb2YgMTYgS2lCLgooWEVOKSBWTVg6 IFN1cHBvcnRlZCBhZHZhbmNlZCBmZWF0dXJlczoKKFhFTikgIC0gQVBJQyBNTUlPIGFjY2Vz cyB2aXJ0dWFsaXNhdGlvbgooWEVOKSAgLSBBUElDIFRQUiBzaGFkb3cKKFhFTikgIC0gRXh0 ZW5kZWQgUGFnZSBUYWJsZXMgKEVQVCkKKFhFTikgIC0gVmlydHVhbC1Qcm9jZXNzb3IgSWRl bnRpZmllcnMgKFZQSUQpCihYRU4pICAtIFZpcnR1YWwgTk1JCihYRU4pICAtIE1TUiBkaXJl Y3QtYWNjZXNzIGJpdG1hcAooWEVOKSAgLSBVbnJlc3RyaWN0ZWQgR3Vlc3QKKFhFTikgSFZN OiBBU0lEcyBlbmFibGVkLgooWEVOKSBIVk06IFZNWCBlbmFibGVkCihYRU4pIEhWTTogSGFy ZHdhcmUgQXNzaXN0ZWQgUGFnaW5nIChIQVApIGRldGVjdGVkCihYRU4pIEhWTTogSEFQIHBh Z2Ugc2l6ZXM6IDRrQiwgMk1CCihYRU4pIEJyb3VnaHQgdXAgNCBDUFVzCihYRU4pICoqKiBM T0FESU5HIERPTUFJTiAwICoqKgooWEVOKSAgWGVuICBrZXJuZWw6IDY0LWJpdCwgbHNiLCBj b21wYXQzMgooWEVOKSAgRG9tMCBrZXJuZWw6IDY0LWJpdCwgUEFFLCBsc2IsIHBhZGRyIDB4 MTAwMDAwMCAtPiAweDFlMTMwMDAKKFhFTikgUEhZU0lDQUwgTUVNT1JZIEFSUkFOR0VNRU5U OgooWEVOKSAgRG9tMCBhbGxvYy46ICAgMDAwMDAwMDQxODAwMDAwMC0+MDAwMDAwMDQxYzAw MDAwMCAoNDA0NjU2NyBwYWdlcyB0byBiZSBhbGxvY2F0ZWQpCihYRU4pICBJbml0LiByYW1k aXNrOiAwMDAwMDAwNDJiMzM1MDAwLT4wMDAwMDAwNDJkZmZmYzAwCihYRU4pIFZJUlRVQUwg TUVNT1JZIEFSUkFOR0VNRU5UOgooWEVOKSAgTG9hZGVkIGtlcm5lbDogZmZmZmZmZmY4MTAw MDAwMC0+ZmZmZmZmZmY4MWUxMzAwMAooWEVOKSAgSW5pdC4gcmFtZGlzazogZmZmZmZmZmY4 MWUxMzAwMC0+ZmZmZmZmZmY4NGFkZGMwMAooWEVOKSAgUGh5cy1NYWNoIG1hcDogZmZmZmZm ZmY4NGFkZTAwMC0+ZmZmZmZmZmY4NjlmM2Q5MAooWEVOKSAgU3RhcnQgaW5mbzogICAgZmZm ZmZmZmY4NjlmNDAwMC0+ZmZmZmZmZmY4NjlmNDRiNAooWEVOKSAgUGFnZSB0YWJsZXM6ICAg ZmZmZmZmZmY4NjlmNTAwMC0+ZmZmZmZmZmY4NmEyZTAwMAooWEVOKSAgQm9vdCBzdGFjazog ICAgZmZmZmZmZmY4NmEyZTAwMC0+ZmZmZmZmZmY4NmEyZjAwMAooWEVOKSAgVE9UQUw6ICAg ICAgICAgZmZmZmZmZmY4MDAwMDAwMC0+ZmZmZmZmZmY4NmMwMDAwMAooWEVOKSAgRU5UUlkg QUREUkVTUzogZmZmZmZmZmY4MTg4ZTIwMAooWEVOKSBEb20wIGhhcyBtYXhpbXVtIDQgVkNQ VXMKKFhFTikgU2NydWJiaW5nIEZyZWUgUkFNOiAuZG9uZS4KKFhFTikgWGVuIHRyYWNlIGJ1 ZmZlcnM6IGRpc2FibGVkCihYRU4pIFN0ZC4gTG9nbGV2ZWw6IEVycm9ycyBhbmQgd2Fybmlu Z3MKKFhFTikgR3Vlc3QgTG9nbGV2ZWw6IE5vdGhpbmcgKFJhdGUtbGltaXRlZDogRXJyb3Jz IGFuZCB3YXJuaW5ncykKKFhFTikgKioqIFNlcmlhbCBpbnB1dCAtPiBET00wICh0eXBlICdD VFJMLWEnIHRocmVlIHRpbWVzIHRvIHN3aXRjaCBpbnB1dCB0byBYZW4pCihYRU4pIEZyZWVk IDIxNmtCIGluaXQgbWVtb3J5LgooWEVOKSBubyBjcHVfaWQgZm9yIGFjcGlfaWQgNQooWEVO KSBubyBjcHVfaWQgZm9yIGFjcGlfaWQgNgooWEVOKSBubyBjcHVfaWQgZm9yIGFjcGlfaWQg NwooWEVOKSBubyBjcHVfaWQgZm9yIGFjcGlfaWQgOAooWEVOKSBwaHlzZGV2LmM6MTcxOiBk b20wOiB3cm9uZyBtYXBfcGlycSB0eXBlIDMKKFhFTikgdHJhcHMuYzoyNDg4OmQxIERvbWFp biBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9tIDB4MDAwMDAwMDAwMDAw MDAwMCB0byAweGZmZmZjOTAwMDA1N2IwMzAuCihYRU4pIHRyYXBzLmM6MjQ4ODpkMSBEb21h aW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJvbSAweDAwMDAwMDAwMDAw MDAwMDAgdG8gMHhmZmZmYzkwMDAwNzE4MDMwLgooWEVOKSB0cmFwcy5jOjI0ODg6ZDIgRG9t YWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZyb20gMHgwMDAwMDAwMDAw MDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDRmMjAzMC4KKFhFTikgdHJhcHMuYzoyNDg4OmQyIERv bWFpbiBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9tIDB4MDAwMDAwMDAw MDAwMDAwMCB0byAweGZmZmZjOTAwMDA0ZmEwMzAuCihYRU4pIHRyYXBzLmM6MjQ4ODpkMyBE b21haW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJvbSAweDAwMDAwMDAw MDAwMDAwMDAgdG8gMHhmZmZmYzkwMDAwMjUxMDMwLgooWEVOKSB0cmFwcy5jOjI0ODg6ZDMg RG9tYWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZyb20gMHgwMDAwMDAw MDAwMDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDI2MzAzMC4KKFhFTikgdHJhcHMuYzoyNDg4OmQz IERvbWFpbiBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9tIDB4MDAwMDAw MDAwMDAwMDAwMCB0byAweGZmZmZjOTAwMDAyNmIwMzAuCihYRU4pIHRyYXBzLmM6MjQ4ODpk MyBEb21haW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJvbSAweDAwMDAw MDAwMDAwMDAwMDAgdG8gMHhmZmZmYzkwMDAwMjczMDMwLgooWEVOKSB0cmFwcy5jOjI0ODg6 ZDQgRG9tYWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZyb20gMHgwMDAw MDAwMDAwMDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDRmMjAzMC4KKFhFTikgdHJhcHMuYzoyNDg4 OmQ0IERvbWFpbiBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9tIDB4MDAw MDAwMDAwMDAwMDAwMCB0byAweGZmZmZjOTAwMDAwMTUwMzAuCihYRU4pIHRyYXBzLmM6MjQ4 ODpkNSBEb21haW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJvbSAweDAw MDAwMDAwMDAwMDAwMDAgdG8gMHhmZmZmYzkwMDAwNGYyMDMwLgooWEVOKSB0cmFwcy5jOjI0 ODg6ZDUgRG9tYWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZyb20gMHgw MDAwMDAwMDAwMDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDAxNTAzMC4KKFhFTikgdHJhcHMuYzoy NDg4OmQ2IERvbWFpbiBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9tIDB4 MDAwMDAwMDAwMDAwMDAwMCB0byAweGZmZmZjOTAwMDA0ZjIwMzAuCihYRU4pIHRyYXBzLmM6 MjQ4ODpkNiBEb21haW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJvbSAw eDAwMDAwMDAwMDAwMDAwMDAgdG8gMHhmZmZmYzkwMDAwNGZhMDMwLgooWEVOKSBEaXNhYmxp bmcgbm9uLWJvb3QgQ1BVcyAuLi4KKFhFTikgQnJva2UgYWZmaW5pdHkgZm9yIGlycSAxCihY RU4pIEJyb2tlIGFmZmluaXR5IGZvciBpcnEgOAooWEVOKSBCcm9rZSBhZmZpbml0eSBmb3Ig aXJxIDkKKFhFTikgQnJva2UgYWZmaW5pdHkgZm9yIGlycSAxMgooWEVOKSBCcm9rZSBhZmZp bml0eSBmb3IgaXJxIDE3CihYRU4pIEJyb2tlIGFmZmluaXR5IGZvciBpcnEgMzEKKFhFTikg QnJva2UgYWZmaW5pdHkgZm9yIGlycSAxNgooWEVOKSBCcm9rZSBhZmZpbml0eSBmb3IgaXJx IDIwCihYRU4pIEVudGVyaW5nIEFDUEkgUzMgc3RhdGUuCihYRU4pIG1jZV9pbnRlbC5jOjEx NjI6IE1DQSBDYXBhYmlsaXR5OiBCQ0FTVCAxIFNFUiAwIENNQ0kgMSBmaXJzdGJhbmsgMCBl eHRlbmRlZCBNQ0UgTVNSIDAKKFhFTikgQ1BVMCBDTUNJIExWVCB2ZWN0b3IgKDB4ZjcpIGFs cmVhZHkgaW5zdGFsbGVkCihYRU4pIENQVTA6IFRoZXJtYWwgTFZUIHZlY3RvciAoMHhmYSkg YWxyZWFkeSBpbnN0YWxsZWQKKFhFTikgRmluaXNoaW5nIHdha2V1cCBmcm9tIEFDUEkgUzMg c3RhdGUuCihYRU4pIEVuYWJsaW5nIG5vbi1ib290IENQVXMgIC4uLgooWEVOKSB0cmFwcy5j OjI0ODg6ZDcgRG9tYWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZyb20g MHgwMDAwMDAwMDAwMDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDUyNDAzMC4KKFhFTikgdHJhcHMu YzoyNDg4OmQ3IERvbWFpbiBhdHRlbXB0ZWQgV1JNU1IgMDAwMDAwMDAwMDAwMDA3OSBmcm9t IDB4MDAwMDAwMDAwMDAwMDAwMCB0byAweGZmZmZjOTAwMDA1MmMwMzAuCihYRU4pIHRyYXBz LmM6MjQ4ODpkNyBEb21haW4gYXR0ZW1wdGVkIFdSTVNSIDAwMDAwMDAwMDAwMDAwNzkgZnJv bSAweDAwMDAwMDAwMDAwMDAwMDAgdG8gMHhmZmZmYzkwMDAwMDE1MDMwLgooWEVOKSB0cmFw cy5jOjI0ODg6ZDcgRG9tYWluIGF0dGVtcHRlZCBXUk1TUiAwMDAwMDAwMDAwMDAwMDc5IGZy b20gMHgwMDAwMDAwMDAwMDAwMDAwIHRvIDB4ZmZmZmM5MDAwMDAxZDAzMC4KKFhFTikgRHVt cGluZyB0aW1lciBxdWV1ZXM6CihYRU4pIENQVTAwOgooWEVOKSAgIGV4PSAgICAgMTI2dXMg dGltZXI9ZmZmZjgzMDBjODNiMDA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwYzgz YjAwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAg ICAxNzc4dXMgdGltZXI9ZmZmZjgzMDQyMjJmOWRlOCBjYj1mZmZmODJjNDgwMTE4MjUwKDAw MDAwMDAwMDAwMDAwMDApIGNzY2hlZF90aWNrKzB4MC8weDJlMAooWEVOKSAgIGV4PSAgICAg MTI2dXMgdGltZXI9ZmZmZjgzMDBjODFmYzA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4 MzAwYzgxZmMwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAg IGV4PSAgIDE3MjI3dXMgdGltZXI9ZmZmZjgyYzQ4MDJiYjk4MCBjYj1mZmZmODJjNDgwMTM4 ZmYwKGZmZmY4MmM0ODAyYmI5NDApIGRvX2Ric190aW1lcisweDAvMHgyNTAKKFhFTikgICBl eD0gICAyMDc0NHVzIHRpbWVyPWZmZmY4MzAwMzAwOTQwNjAgY2I9ZmZmZjgyYzQ4MDExZTQy MChmZmZmODMwMDMwMDk0MDAwKSB2Y3B1X3NpbmdsZXNob3RfdGltZXJfZm4rMHgwLzB4MTAK KFhFTikgICBleD0gICAyNzk0NXVzIHRpbWVyPWZmZmY4MzA0MjIyZmRkZTAgY2I9ZmZmZjgy YzQ4MDExNmYyMChmZmZmODMwNDIyMmZkZGMwKSBjc2NoZWRfYWNjdCsweDAvMHg0NjAKKFhF TikgICBleD0gICAyOTk0OXVzIHRpbWVyPWZmZmY4MmM0ODAyYmI3NjAgY2I9ZmZmZjgyYzQ4 MDExZGVkMCgwMDAwMDAwMDAwMDAwMDAwKSBzX3RpbWVyX2ZuKzB4MC8weDIwCihYRU4pICAg ZXg9ICAgODc3NzR1cyB0aW1lcj1mZmZmODMwMDhkYjZhMDYwIGNiPWZmZmY4MmM0ODAxMWU0 MjAoZmZmZjgzMDA4ZGI2YTAwMCkgdmNwdV9zaW5nbGVzaG90X3RpbWVyX2ZuKzB4MC8weDEw CihYRU4pICAgZXg9ICAgNzkyNTJ1cyB0aW1lcj1mZmZmODJjNDgwMmIzODgwIGNiPWZmZmY4 MmM0ODAxNzcxNjAoMDAwMDAwMDAwMDAwMDAwMCkgdGltZV9jYWxpYnJhdGlvbisweDAvMHg2 MAooWEVOKSAgIGV4PSAgNzAzMTQ2dXMgdGltZXI9ZmZmZjgzMDBhNmI5YzA2MCBjYj1mZmZm ODJjNDgwMTFlNDIwKGZmZmY4MzAwYTZiOWMwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9m bisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDM1NjEydXMgdGltZXI9ZmZmZjgzMDAzMzBkYzA2 MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwMzMwZGMwMDApIHZjcHVfc2luZ2xlc2hv dF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDk3Njg4dXMgdGltZXI9ZmZmZjgz MDBhNmI5ODA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwYTZiOTgwMDApIHZjcHVf c2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDMwMDAzdXMgdGlt ZXI9ZmZmZjgzMDBiMTI5YTA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwYjEyOWEw MDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDky Njc5dXMgdGltZXI9ZmZmZjgzMDBjOTRhNjA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4 MzAwYzk0YTYwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAg IGV4PSA0MTM1MTE4dXMgdGltZXI9ZmZmZjgzMDBiZGNhNjA2MCBjYj1mZmZmODJjNDgwMTFl NDIwKGZmZmY4MzAwYmRjYTYwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgx MAooWEVOKSAgIGV4PSAgIDk2NDExdXMgdGltZXI9ZmZmZjgzMDBiMTI4ZTA2MCBjYj1mZmZm ODJjNDgwMTFlNDIwKGZmZmY4MzAwYjEyOGUwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9m bisweDAvMHgxMAooWEVOKSAgIGV4PSAxMzM3ODY2dXMgdGltZXI9ZmZmZjgzMDBhNmI5NDA2 MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwYTZiOTQwMDApIHZjcHVfc2luZ2xlc2hv dF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDkxMTk0dXMgdGltZXI9ZmZmZjgz MDAzNGI5ODA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwMzRiOTgwMDApIHZjcHVf c2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSAgIDk3OTU1dXMgdGlt ZXI9ZmZmZjgzMDA3ZDk0ODA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4MzAwN2Q5NDgw MDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAgIGV4PSA0MTM1 MTYzdXMgdGltZXI9ZmZmZjgzMDBjNTMzNjA2MCBjYj1mZmZmODJjNDgwMTFlNDIwKGZmZmY4 MzAwYzUzMzYwMDApIHZjcHVfc2luZ2xlc2hvdF90aW1lcl9mbisweDAvMHgxMAooWEVOKSAg IGV4PTEyMzQ2NDQwOXVzIHRpbWVyPWZmZmY4MmM0ODAyYjM5ODAgY2I9ZmZmZjgyYzQ4MDE3 NmVmMCgwMDAwMDAwMDAwMDAwMDAwKSBwbHRfb3ZlcmZsb3crMHgwLzB4MTkwCihYRU4pICAg ZXg9ICAgOTU5Njh1cyB0aW1lcj1mZmZmODMwMGE2Yjk2MDYwIGNiPWZmZmY4MmM0ODAxMWU0 MjAoZmZmZjgzMDBhNmI5NjAwMCkgdmNwdV9zaW5nbGVzaG90X3RpbWVyX2ZuKzB4MC8weDEw CihYRU4pICAgZXg9MTI0MDE3MDF1cyB0aW1lcj1mZmZmODJjNDgwMmI2NWEwIGNiPWZmZmY4 MmM0ODAxOWViMTAoMDAwMDAwMDAwMDAwMDAwMCkgbWNlX3dvcmtfZm4rMHgwLzB4ZDAKKFhF TikgICBleD0gICA5NzgwNHVzIHRpbWVyPWZmZmY4MzAwMzAxYTgwNjAgY2I9ZmZmZjgyYzQ4 MDExZTQyMChmZmZmODMwMDMwMWE4MDAwKSB2Y3B1X3NpbmdsZXNob3RfdGltZXJfZm4rMHgw LzB4MTAKKFhFTikgICBleD0gICA5Nzg0MXVzIHRpbWVyPWZmZmY4MzAwYmQ4MTAwNjAgY2I9 ZmZmZjgyYzQ4MDExZTQyMChmZmZmODMwMGJkODEwMDAwKSB2Y3B1X3NpbmdsZXNob3RfdGlt ZXJfZm4rMHgwLzB4MTAKKFhFTikgICBleD0gICA5ODAzOXVzIHRpbWVyPWZmZmY4MzAwN2Q5 NGMwNjAgY2I9ZmZmZjgyYzQ4MDExZTQyMChmZmZmODMwMDdkOTRjMDAwKSB2Y3B1X3Npbmds ZXNob3RfdGltZXJfZm4rMHgwLzB4MTAKKFhFTikgICBleD0gICA5NDcyN3VzIHRpbWVyPWZm ZmY4MzAwOGRiNmUwNjAgY2I9ZmZmZjgyYzQ4MDExZTQyMChmZmZmODMwMDhkYjZlMDAwKSB2 Y3B1X3NpbmdsZXNob3RfdGltZXJfZm4rMHgwLzB4MTAKKFhFTikgICBleD0gIDMxOTkyN3Vz IHRpbWVyPWZmZmY4MzAwYzg0MGMwNjAgY2I9ZmZmZjgyYzQ4MDExZTQyMChmZmZmODMwMGM4 NDBjMDAwKSB2Y3B1X3NpbmdsZXNob3RfdGltZXJfZm4rMHgwLzB4MTAKKFhFTikgQ1BVMDE6 CihYRU4pIENQVTAyOgooWEVOKSBDUFUwMzoKKFhFTikgJ2MnIHByZXNzZWQgLT4gcHJpbnRp bmcgQUNQSSBDeCBzdHJ1Y3R1cmVzCihYRU4pID09Y3B1MD09CihYRU4pIGFjdGl2ZSBzdGF0 ZToJCUMzCihYRU4pIG1heF9jc3RhdGU6CQlDNwooWEVOKSBzdGF0ZXM6CihYRU4pICAgICBD MToJdHlwZVtDMV0gbGF0ZW5jeVswMDBdIHVzYWdlWzAwMjU0NjY1XSBtZXRob2RbIEhBTFRd IGR1cmF0aW9uWzYyNzIwMDk5ODMzXQooWEVOKSAgICAgQzI6CXR5cGVbQzJdIGxhdGVuY3lb MDgwXSB1c2FnZVswMDA2OTUwNV0gbWV0aG9kW1NZU0lPXSBkdXJhdGlvblszNjQ5OTI1NTE5 NV0KKFhFTikgICAgKkMzOgl0eXBlW0MzXSBsYXRlbmN5WzEwOV0gdXNhZ2VbMDE4Mjg5NTJd IG1ldGhvZFtTWVNJT10gZHVyYXRpb25bNTU2MjEyNjkzMzE3NF0KKFhFTikgICAgIEMwOgl1 c2FnZVswMjE1MzEyMl0gZHVyYXRpb25bMjA0MjUyNjM4OTU5OF0KKFhFTikgUEMzWzBdIFBD NlswXSBQQzdbMF0KKFhFTikgQ0MzWzBdIENDNlswXQooWEVOKSA9PWNwdTE9PQooWEVOKSBh Y3RpdmUgc3RhdGU6CQlDMQooWEVOKSBtYXhfY3N0YXRlOgkJQzcKKFhFTikgc3RhdGVzOgoo WEVOKSAgICAqQzE6CXR5cGVbQzFdIGxhdGVuY3lbMDAwXSB1c2FnZVswMDgwODAyN10gbWV0 aG9kWyBIQUxUXSBkdXJhdGlvbls2OTc4Nzk5MzA2NzUwXQooWEVOKSAgICAgQzA6CXVzYWdl WzAwODA4MDI3XSBkdXJhdGlvbls3MjUwNzMzOTgxMDRdCihYRU4pIFBDM1swXSBQQzZbMF0g UEM3WzBdCihYRU4pIENDM1swXSBDQzZbMF0KKFhFTikgPT1jcHUyPT0KKFhFTikgYWN0aXZl IHN0YXRlOgkJQzEKKFhFTikgbWF4X2NzdGF0ZToJCUM3CihYRU4pIHN0YXRlczoKKFhFTikg ICAgKkMxOgl0eXBlW0MxXSBsYXRlbmN5WzAwMF0gdXNhZ2VbMDA4MjUwMjJdIG1ldGhvZFsg SEFMVF0gZHVyYXRpb25bNjk4MTUyNzQxNjA5N10KKFhFTikgICAgIEMwOgl1c2FnZVswMDgy NTAyMl0gZHVyYXRpb25bNzIyMzQ1MzE5ODgyXQooWEVOKSBQQzNbMF0gUEM2WzBdIFBDN1sw XQooWEVOKSBDQzNbMF0gQ0M2WzBdCihYRU4pID09Y3B1Mz09CihYRU4pIGFjdGl2ZSBzdGF0 ZToJCUMxCihYRU4pIG1heF9jc3RhdGU6CQlDNwooWEVOKSBzdGF0ZXM6CihYRU4pICAgICpD MToJdHlwZVtDMV0gbGF0ZW5jeVswMDBdIHVzYWdlWzAwODEwMjkyXSBtZXRob2RbIEhBTFRd IGR1cmF0aW9uWzY5ODA4MzU5MDc4NTddCihYRU4pICAgICBDMDoJdXNhZ2VbMDA4MTAyOTJd IGR1cmF0aW9uWzcyMzAzNjg0NDc3OV0KKFhFTikgUEMzWzBdIFBDNlswXSBQQzdbMF0KKFhF TikgQ0MzWzBdIENDNlswXQo= --------------050106030504030501010304-- --------------enig5230F3E2DC98D5B5654D4AE2 Content-Type: application/pgp-signature; name="signature.asc" Content-Description: OpenPGP digital signature Content-Disposition: attachment; filename="signature.asc" -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) Comment: Using GnuPG with undefined - http://www.enigmail.net/ iQEcBAEBAgAGBQJQt6+LAAoJENuP0xzK19csMMoH/RoHGgzxN+8awGwLwaP1/xcN BdH8Aq5EONXbuY7yg5MZZHW4npU45FY4i+pmNjq0DZbS3UNfOwOddDvH+eqJRBbG JLl2HpCewxAuXmbOyFCmzR89w4P2CUcfxwQymBj7CnzvBIjUpkNIXZGduc+ZObUb ndChvbcYKPKTSP/au4rrHx7krdaYarNeTwRaVhykg2peTkcRLlOXfWmFw3euuSL2 fsK9JoARSBfUB3UdzamSIXXm+BIf3wRtR0fc3BbBoO/mYvwx0KzAQFe+K3hmTx+u Od3MHlEFNLwz09o4VhlKSYaQ7OpVIHaQOGMXXC0wQZe/cXgdMu0UjPjM/pY//sg= =LuRe -----END PGP SIGNATURE----- --------------enig5230F3E2DC98D5B5654D4AE2-- --===============1945915925389597712== 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 --===============1945915925389597712==-- From xen-api-bounces@lists.xen.org Fri Nov 30 12:02:32 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 30 Nov 2012 12:02:32 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TePIX-0008LY-SV; Fri, 30 Nov 2012 12:02:26 +0000 Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TePHx-0008Is-Mz for xen-api@lists.xen.org; Fri, 30 Nov 2012 12:02:17 +0000 Received: from [85.158.137.99:47274] by server-8.bemta-3.messagelabs.com id 39/6B-07786-720A8B05; Fri, 30 Nov 2012 12:01:43 +0000 X-Env-Sender: pip.chan@gmail.com X-Msg-Ref: server-6.tower-217.messagelabs.com!1354276887!12210091!1 X-Originating-IP: [209.85.212.51] X-SpamReason: No, hits=1.5 required=7.0 tests=HTML_00_10,HTML_MESSAGE, ML_RADAR_SPEW_LINKS_14,RCVD_BY_IP,spamassassin: X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 2654 invoked from network); 30 Nov 2012 12:01:28 -0000 Received: from mail-vb0-f51.google.com (HELO mail-vb0-f51.google.com) (209.85.212.51) by server-6.tower-217.messagelabs.com with RC4-SHA encrypted SMTP; 30 Nov 2012 12:01:28 -0000 Received: by mail-vb0-f51.google.com with SMTP id fq11so11643201vbb.38 for ; Fri, 30 Nov 2012 04:01:27 -0800 (PST) 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=HnaUcXX3IHWHwNl3CqYTsv0aFxb4QaHp47/E5Uc8nJA=; b=iubl2NqQIGAGu4NkD1AgzTx7FzwTtAcO1PH8aaXLX+ALhlevjUn3TgkUxJde9xcpy5 NcFgtdPdnCDwfeSOf6/0Ki4XLV2VYzo+uG0XVJbOBXkdnu81fQTuHyxFrTOfpP/yzh4S GSeYoryD45dOEWgf/DHxy5Re8WTbeg61V5iwfO1R0h3qYKNKewTfdlnsJEf6/N+F6MDs vFldRJaFlIWD1LfFM6wMKgZQYmmfM12tdwEiyUXm1Vs4LmIGM8aQTEmGWfgvk9MTL/RD H3KAQNkHMLmhQTDTYLVHhg941vHH6faJDm0G4DgwWl1kW6NspgVTDB1ST5FGr4JZaAt2 z00w== MIME-Version: 1.0 Received: by 10.52.177.104 with SMTP id cp8mr717166vdc.47.1354276886628; Fri, 30 Nov 2012 04:01:26 -0800 (PST) Received: by 10.221.6.130 with HTTP; Fri, 30 Nov 2012 04:01:25 -0800 (PST) Received: by 10.221.6.130 with HTTP; Fri, 30 Nov 2012 04:01:25 -0800 (PST) Date: Fri, 30 Nov 2012 20:01:25 +0800 Message-ID: From: Philip Chan To: xen-api@lists.xen.org Content-Type: multipart/mixed; boundary=20cf3071c812c14cf504cfb528de Subject: [Xen-API] pool restore database make the pool work function properly pool db will rollback to backup status X-BeenThere: xen-api@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: User and development list for XCP and XAPI List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-api-bounces@lists.xen.org Errors-To: xen-api-bounces@lists.xen.org --20cf3071c812c14cf504cfb528de Content-Type: multipart/alternative; boundary=20cf3071c812c14cf204cfb528dc --20cf3071c812c14cf204cfb528dc Content-Type: text/plain; charset=UTF-8 it is xcp 1.6 release. after upgraded the xcp to xcp 1.6 release. then reboot the master, all slaves have this error. then i need to reinstall the slave and rejoin the pool. but master canot reboot. once it reboots all slaves will need to reinstall. it is also find that the management ip of master cannot be changed. it will rollback to the setting of the backup status. for example if the restored master ip is 192.168.1.2 then it will reset to this ip after reboot. i tried xe pif reconfigure ip, xsconsole, xe-emgerency-reset network are failed to change the ip. once it boot xsconsole will report the newly set ip. but after while it will reset to the backup ip. ctrl-c to resetting the screen will refresh the host ip. so it seems look like the host setting frozen to the restored settings. --20cf3071c812c14cf204cfb528dc Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable

    it is xcp 1.6 release.

    after upgraded the xcp to xcp 1.6 release. then reboot the master, all s= laves have this error. then i need to reinstall the slave and rejoin the po= ol. but master canot reboot. once it reboots all slaves will need to reinst= all. it is also find that the management ip of master cannot be changed. it= will rollback to the setting of the backup status. for example if the rest= ored master ip is 192.168.1.2 then it will reset to this ip after reboot. i= tried xe pif reconfigure ip, xsconsole, xe-emgerency-reset network are fai= led to change the ip. once it boot xsconsole will report the newly set ip. = but after while it will reset to the backup ip. ctrl-c to resetting the scr= een will refresh the host ip. so it seems look like the host setting frozen= to the restored settings.

    --20cf3071c812c14cf204cfb528dc-- --20cf3071c812c14cf504cfb528de Content-Type: image/jpeg; name="20121130_163413.jpg" Content-Disposition: attachment; filename="20121130_163413.jpg" Content-Transfer-Encoding: base64 X-Attachment-Id: 1420061358525788140-1 /9j/4c4ORXhpZgAASUkqAAgAAAAMAAABBAABAAAAwAwAAAEBBAABAAAAkAkAAA8BAgAIAAAAngAA ABABAgAJAAAApgAAABIBAwABAAAAAQAAABoBBQABAAAA0AAAABsBBQABAAAA2AAAACgBAwABAAAA AgAAADEBAgALAAAAsAAAADIBAgAUAAAAvAAAABMCAwABAAAAAQAAAGmHBAABAAAA4AAAANoCAABT QU1TVU5HAEdULUk5MTAwAABJOTEwMFpTTFBHAAAyMDEyOjExOjMwIDE2OjM0OjEzAEgAAAABAAAA SAAAAAEAAAAZAJqCBQABAAAAEgIAAJ2CBQABAAAAGgIAACKIAwABAAAAAwAAACeIAwABAAAAyAAA AACQBwAEAAAAMDIyMAOQAgAUAAAAIgIAAASQAgAUAAAANgIAAAGSCgABAAAASgIAAAKSBQABAAAA UgIAAAOSCgABAAAAWgIAAASSCgABAAAAYgIAAAWSBQABAAAAagIAAAeSAwABAAAAAgAAAAmSAwAB AAAAEAAAAAqSBQABAAAAcgIAAHySBwBCAAAAmAIAAIaSBwAVAAAAegIAAACgBwAEAAAAMDEwMAGg AwABAAAAAQAAAAKgBAABAAAAwAwAAAOgBAABAAAAkAkAAAKkAwABAAAAAAAAAAOkAwABAAAAAAAA AAakAwABAAAAAAAAACCkAgAHAAAAkAIAAAAAAAABAAAAEQAAAAkBAABkAAAAMjAxMjoxMTozMCAx NjozNDoxMwAyMDEyOjExOjMwIDE2OjM0OjEzAJUBAABkAAAAGQEAAGQAAABgAAAAZAAAAAAAAABk AAAAGQEAAGQAAACTAQAAZAAAAEFTQ0lJAAAAVXNlciBjb21tZW50cwBTQ0VGMDIAAAUAAQAHAAQA AAAwMTAwAgAEAAEAAAAAIAEAQAAEAAEAAAAAAAAAUAAEAAEAAAABAAAAAAEDAAEAAAAAAAAAAAAA AAkAAAEEAAEAAABAAQAAAQEEAAEAAADwAAAAAwEDAAEAAAAGAAAAEgEDAAEAAAABAAAAGgEFAAEA AABMAwAAGwEFAAEAAABUAwAAKAEDAAEAAAACAAAAAQIEAAEAAABcAwAAAgIEAAEAAACqygAAAAAA AEgAAAABAAAASAAAAAEAAAD/2P/bAIQAAQEBAQEBAQEBAQEBAQEBAgEBAQEBAgEBAQICAgICAgIC AgMDBAMDAwMDAgIDBAMDBAQEBAQCAwUFBAQFBAQEBAEBAQEBAQECAQECBAMCAwQEBAQEBAQEBAQE BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE/90ABAAE/8AAEQgA8AFAAwEh AAIRAQMRAf/EAaIAAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKCxAAAgEDAwIEAwUFBAQAAAF9 AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6 Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ip qrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6AQADAQEBAQEB AQEBAAAAAAAAAQIDBAUGBwgJCgsRAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKB CBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2Rl ZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJ ytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwDAQACEQMRAD8A/icXwX59xq8huplWLVGt 40jcxkKWJBA77dhXkjqOtaFp4IWZtgvLvdEwG6NgcY2/MTtAwAM+vX2J8xVPdTsaSktrF+LwFHJw L29OOEZTGSN2MdRnvnHB4xzV+P4bWL4B1DUAFJZB5iqCMeu36fnnvU+1a1sLmXYvQfDHStgAvtWT BJwZ1RWBGM8KTnnuMnH41aj+EulOcteaof4txuRtxg4O3Zx0HWp+tVFtb7hc3khy/CPQnQsbjVG/ hUG9x5nTGDjjgHj2HFSR/CbQU4km1NpFyGBv2GwZA5xwOvcnrWbxtdaK33CP/9D+O5fhB4fYAs2o R7RuPmX75XBPB9D2496sx/Bzw5IMf6dhuA51Fwc5JUYz3z26ba8KWYYpLRr7l/kNNX1LUfwR8NFQ pOp7i2wbb9z2579vl/PvWnB8CfCLKzD+1Dg43jUXwOABn6dfwxWf9pYvuvuRolDoaS/s++C2O0nV VIIG5dTkbqMDHB7/AM/wrSt/2bvBThGD62cDqNUZeuBz8uOM8Aeh9az/ALWxnl9xoowejN+2/Zf8 C3LBnuvESj/VnGqgMowMYGz6/nWuP2Svh4zBTqXixFOeI9VjBXnBzmIjsfyrGWd42K2j9xvGhQej P//R/mEg/Y3+GxysmueMwoIVSNRh4H08n9ffmtG2/Yp+H1zgr4n8aRxg7UP9pQFycjP/ACxwePQ9 q+MlxBjYfYj9x60cJhnvcuj9hn4e/vHl8Y+OVXJCmO6tjlhjj/VdPmHSrsH7B/gG7Pl2vj/xujE/ u0lNsxA+uweo/WsXxNjo6+zg/k/8zoWXYV6XZKf+CffhvdtHxH8WlQT/AMu8DMB+QHH9e9XV/wCC fnhYlQnxS8Xf3NgsbYupB5zz3xxWL4sxXWhD8TX+ycLa/M/6+RBJ/wAE/tDVg0XxQ8WDIHDadbNj oeRuzVQ/sERqGNv8UfECsDgG40iDbjoeN/OeOvoapcU1PtYeP4kPKsN0kz//0v5oJP2FtThyF+KO qhiNpD6JDz0wPv579qpyfsUeIYceX8T74svyHHh6EYwOvEmSeD6e5r4P/WeL+PDL7/8AgHuvKaP2 ZfgVl/ZD8aJkW/xVuo127MNoKDO0+0nA4UcVej/ZX+J8aoLX4vXa+WQQo0l4wpzlOkvXvx6/jWb4 kwt7Tw3/AJN/wCHlMEtJfga0P7MPxvQMbb4xXALtgIbC6RSC3JbbP6j36eldDa/svftGO6C1+Nyw krgGU6nGfTJ2zHOeffmsqmfZVZueFf3r9QWVz2jOx0tr+zD+1qgQ2nx00uI48tGm1XXYHJPUZQsR wxGT/QV3en/sp/t5yKp0/wCOXheZQMFT438SWzAHpn/RW5PHQnpXmYjiPhilriMLL5Rg/wA2jelk 2OnpSrL72v8AM//T/E60/ZR/4KR2jE6b8TPCV8yqyhYfiNqIkk3Agn9/Z49Bz/dHfppj9nz/AIKp accWdzo+siMFY3g8faNNuyd3C3SLnnHUfyr8YfFXA1STVWMoesH/AO2Nn1EeG87Tfs5xfz/zRBJ8 Of8AgrHpjK03gKPVEjwF8nxJ4MulbJwOd4bnjAJBxx61E19/wU70FiNQ+BN3ebExtjttGvtnXoba 5De+CDyDxmn/AGnwDiFaGK5X6VF+asS8p4gotvkT/wDAX+Wpmy/F39vvSiBqf7N2rypAoQqvhKV4 xj5dxKXfJwR09Oc1kS/tQftYadPGdU/Zs12CKIN5gHg7UUj2nJ5Ilcjn07E455qo5dwniH/s+PV/ 8Uf1Q3LPMPaNShf5P9GY7/tofGS0jP8AafwF1i3Yrvnafw/q8IyASCT5TDsOD6fSuf1j9vPxDp8Z l1r4R6hp9pCPNnuLiHULNYxwOWkg29+Ce79a7aXDOArPlw2LUr9rP8mZVMdjaceapRa89f1P/9T+ N6OVvtXidVw5i1jeFVgEOfMVcqeh+Y7WBHTvmrEMrZVy4ZlXbtCnOMFRjjPH0PBPSvLUVyoqSs7G 5b7goONjrtQkqWjTJB747H881rmeRkVSufMI+Td5gXpzjsOBjPII5OazaJNmBflOFCEsAzhuq4+X IA+g/wCBDpg1diZREVZPNZV8tjgDkd8dRx/M9KxkrCd7aFgDfJ8+QUGXCMQM9DwTnODwpz0+tW97 A7UQ8/IATuZuSeTnqePbI4rGceoz/9X+VNVC7x84cEM6yEuoI3A5J44ABwcnPtjFu3T++vyeYFPI wScnABB4OBzn888fLga0aHKHkuP3oZWDOcHscdeRx9O/XUsynysUjCgtyRtBA4Ge2Rjnp/KsZRsV G17M1oJYsr92ULFuDjDlsYHLdug468j8dy1vQEC7VyepKhmBB3ZGP/rk5z2rKUbrQ2Xkb9vcqdpV vkD/AChmO1Ocn5vb5q24NTRSFIAHuu0MQOQc9sg4rCSujeMr7H//1vwRsdTZnHmPHsJBUyMWKH3H 09K34dWe1YjzPl4CYY7Xxn2OM89x9e1fnc4XPXhLqaS64zbuVBGUY4GOhxk9O/TPf61p2XiEwF3V 8HaQu44yWBU5wM9sfhXJOjdHZGo9zfXxUyBcNxuGTkEgdNoA6dT/AI4q7beJGKDeR5eNxLEA7s8A d8Zz+Xvxyuhpc6FVvsasPiMOysCArsIz5ihR6ZOfwOenrWwurh1b5o2ZQGLMBztJ5x+P8qh07D9p 5H//1/yqn1HOQpQjo3OEzjkk9+mBj86ovdCQMrLEyo+1ggBUnH8PbGfrX5BOn3Pq+djG2go6hWBb D98kcYP15P5c1JFJEXXbEoAbLxrtJXjhQAeM59D0Nc8o2dh8/kdNZyqPKRUVs/McNkYByR19ceo6 122lzxoyooJIAXgAls5989j/AJ68lSOjRaaex6FZzrdPC6bt0S4xjqep9ST29sV7N4a1AWsUULnL bdz5YAjB+X6HBHBr5vMqd6dj08HL37s//9BdL1tY2jUMYlYFW3EBSeMDtxkk8eld5Z+I4ogpDKwx yu8BcD29sV/HNbC+/ofsdKs7GhN4phO4ZC/wk5CkYHPPoa5/UPFsPl5JBAyo3sMfLkBgMf7P6VMM G9jV1ktTgdS8RWs8fzFBMp2E5ABBPJK9hx/nFea6rrUDB1KBnYbSwAKxEZzkf/X64r0sNh+Vq5zV Kup5TrV9ZfOSsW9E3ZTaVx/ewM8HP4YHpXwp+2Re2kPwU8ahEQTzWCW+VbY7FpogMDGe475619zw 9Tksxot/zR/NHg5jP/Zatn0Z/9H+NoskXiDxQjlgHe3mVVcEuSnXk8gGT6Zq/amNwRhlUkoFZQrq RkbgemMg8E+vbmvLjfkQ3ualtl4isablxuEy53kAkLuHphcknn3Nalu+5QMbXL4yygIoGM/MM9OM dazEbMO1PnYhm2iPZtLhSuO3HdunTvzmrUYJchfnjDBtxUqMhj8pYdOM8exqZRuJuyuaSkKSwQ4A 4B3FWBI24/I8D19sU/YyjEi+W0R/eRyxfPkYyfTqaxJ50f/S/lSVkbGJE8xjztyFPViB8xB6H8B1 4xVhGVl2t5h4JLxNtC/eJK+4yOp7cdePmXFrclST0RciMiHlsOilfm4Y4GO38J9OO31rRiYjJweG Ijj24z1UdTxk4+v4VDV1Yo2YWjRB87bGOHyodsnIwDwB16D2HFW45RsjCySYwMBY8FivIBHcYySf fvmsXFrcqMuXQ1Le+2gAM3AIXgBM4BGD3HHSrX29WV5fnIK4B+6Fx07596iVPS6N4ysz/9P+cVL/ AMp0KyPEpxKZDkEA8gn6cfnUv9uSo3Mpk2jKH7xHBPAPb8T0NfDSpSeqO+M0noXIdeaRlQyYCkFl wBnDDPI46Z744raTXSEGSWO8K2WLFhnsTjpnj8axlSd9ToVS2xeh18kgGUbiwI9CPUHtWxFqz7lW STePuqV5A6kD16j8a56lFo2jU2N+01JDgZYAZVW8wpjcRjj25Ofeugh1TDbSVyxB3DkHgH2wOB9c 1zSh0Zqpvoz/1Pxrj1AnK4+Ugbyyjnnrj1Pr2zVn7XtGBjBITc2VjyNvH8z061+USjbfY+jU31JR clHyWcDYpwCD78cjsSMdfl78Vejm+Xcc7mJL87hnuMf8CPPHFc8o20LUk9EbtneQrsBk2kqNzk7V yTwD36/j/Kut02+zJ8rlgxDFkx5nTB4H0rjqx0NIuz1O/wBO1dInBBbIbLKSGBGBkbQeBnP59a9B 0zWinPmfMTgcklxx1J9ORxXg46neJ6WFlZn/1fCLLxGBtAdyFUMj9jjnGT9Dzn866CPxVJtbDlMK 20n5SByfXrjHsSTX8sSwjlI/UI1lHRDz4nYkjzCpAAKM290IHzcn8+ayb3xMMbXlVslskjgjAIPX AznoPX2rRYOzshqsrHG3fiVV5D7VBDEElgOuQPTnb35zyK4TVfEiushEu4ZwVztz1JPGc4weMevP euihhZKWuwpVItHnOpeIndjmQ7XJC7ASMcnAGccAH8q+If2z9ff/AIVRrVuSzC7vba2zkM2DICTn nJ+Uc5zzX12RU0sfRVvtI8jMX/stX0Z//9b+OLWfMXxlq6RyBEubCKVl3bGIHlp8u4ZIUDn2x6Uy L5CFOcFgdy4Ct94nKE/Mct274yDXnR/hxfkHX+uyNmBuAFLYYYVS4YuWGDnnjq3HXtya14Nyokfm MyEGTYoDKMgAjcO5I5yM8nrxWLWtwNKISAK0YDLLIcu/Lg4JC7epxlsH6/Q6cZLMzAjeBsQGMYz0 BPUZwBnPoTnNIiSdtCyhJSU+ZuOSEXcIxkjBzg5A5zx69OtXI2+W3jyWkKFmKgI2cYOQOOgUnpya xkrMzcWj/9f+Uw/KY1xtLHlfM2hchm3AHqeCfxPNWFlJJ3qDhirFCDwRknPPt3x19q+eaurGUNyy sgOFjY7UJUFkKMVwQRzz/D/LtV6OZ8kBcRhVw2OBt46H1xnk8DFZNWNV5mhHKw3n7q8EqG8kNjA3 YJ54x0z19amW4dSrfxD5QVGVwOnH0HOenpUNJ6MCVbvb5u1iFXu44XHYfXg8e1ON7h/mIYswPykM i/Un6EZ/OhKysVGVmf/Q/mIh1F3eRHJ4j+QMC5OOAoJzjgEDH4VVOpE/vHkcMzA7MbBj5htGc+v/ AKFXybguhumnsXrGa9upUtrSOe5n8tpjBaKbm5MaI7SPsUk4VVZjwcKpJwBmrrXF5aLa/a4buCK9 g860muIzCk6ZZfMjOMFfkPzdMgispQ7m0ZaJWOltNO1+URGDStTkWaPzIWSxkcMnyAsp24IJki+7 /wA9F9RnW064u72eK3tY7ie4dtqwQRGWVig3EAD5s8Dselc04PfsbRlbQ6QPqVk6rfQXFuZVzGLq JoJWxtyQDzjkHkHrn2rfsNQOcCSRU+6CBhScFT9e/T1/GuapTs3ZGilbW5//0fw2j1ElVVX444XP UkDp9T7+lbEd5lQAxz0Y4wxJGFHPQZ7exr8ynT6WPbjPuXI7wsoG3a4G3PHPbkcc8H8hmrv2zzSZ CVOX4UY75HI4x/n1rkqU32NLpl+C8O6NSeE/enYNu44C4zzgZwe1dDa6kG6EA4wGU7QAMcgfn+vv XFVibQeljq7PVnjkDFyFHykA/vBkEjI9MYzx36c5rrLTXWXYHbhRnAXJIwFztzzjnnp+tebVo3ep 2U521P/S+CIPEWSm52A5KxK2WZs5yPbls9sketacfidlEbqXd3U5D4yT8uNpOOmPXrjivwH6slpY +5jN7j5vFTsC3mZVTtBzksAMZ44PQcdj27VjXPimRwV851+82NhVlx/Ew7ZyBz7cnulhVuaKpY5e +8UMFOTjqVJAYAYHzH2OMfU1yE/iVnZlMzlVDP1CEDqNrHjt0HrWkMPboWqt2cle61uB2ylyQwV5 DnI7Z/8Ar+34/FP7YermX4f2UQ8wCbXIVZdyqmBvPK+hyOn9K+hyelbHUrd/8zgzCf8AsdT0P//T /jt1DTLrUPHiWenoLua70TaioUkkkKmRiFJxzhCSQM/L2IArpbfwD4rRlMuiXMGZtgdnU7Wb5VTO c9mHXv3r2Mg4K4l4nwEcTkeFdWEXyt3jFJ6O3vSjfRr7zxsxz7KcpqqjmFZRk9UrSem19E+z+407 PwD4ocx/8SkhASTlkUOQGOeuNxPTnv2rdHw/8SMG8vT3+QEB2KRtkgcY3nnO49OhH0r234R+IT/5 gH/4Mpf/ACZ5r4y4bf8AzE/+Sz/+RNCPwB4mdQqae0c6fvlf7QivMrKVAClsjGwng45wBV2LwB4n QK6aeCYGAKyzKHG7jaTn04I9+vrP/EI/EH/oA/8AKlL/AOTD/XDhz/n/AP8Aks//AJEuReBvEb4i FlBuwsYJuUIbk/dzkZ+X/PNWE8Da+ZY2Ft5jhPnLXEbRsckNtOc5LA8YH9Sn4SeIC/5gP/KlL/5M Fxdw8/8Al/8A+Sz/APkT/9T+XhvAuv8Al+a9qNir8h82NmJDlWBBOBnEhz83GOPSuPBfiEExxWUS bgcN9pRUkbAwD3AOc9+nfjH1MvCTj5f8wP8A5Upf/Jnyy4ryB/8AL/8A8ll/8iWv+EP13EbG1Ty+ MMJApOP7uOPr6ccE1MvhbXo43JtA25/mBuFVPlGQeScfxdcY5+tZPwp48W+B/wDJ6f8A8mWuKMjv pX/CX+RN/wAIvrgaMNalhJGdjrgn5QAoPPoRTj4c1uMljZAKCGCbhwcAElfwPXPJPIrmn4XccU/e eAl8pQf5SNI8R5M9q6+6X+REdC1gAl7WVQUBT7inKnnofr3z3rPudK1kkKbGXcTlxtUBgx+ueuef 9quOfAPGUG4vLqvyi3+R1wzzKGtMRH7z/9X+WZ9L16HaDY3IKqAG4QDGcHrnA5PAqWx8N+L9cvYb XRdC1TUr24B+x2en2zXd5OwUu2yOMFjtAZuAcBfTONavBHFlKDqVMuqpLryO35HnwzbLJSUYV439 TX8GapqnhXxBBql3pGoSQR211ZypZ/up8XNrNbHqMfL5rEg9cV3+teI7zxEdElXwbrFjcQWLWYv7 K1j0q7uYE0qDTEjE6Rbpl8y3mlPmEtiZ4gwA3Vzy4L4rVlLLq3/guX+R0LN8ta93EQ0/vI9R+GHx Wg8C2Wn2kvhDVtWFndR6jLLcWtuvlPHe6RetHtCgSlv7NljW5ly8QnjIVvKUGp8NvHF14T8TabrN zoeqXGnxWd1Z3isv9oXECXE1zPts1xF5S5lQOpdg48zs20ck+FOI4Jwngavn+7l923oa/wBo4KS5 o14378y+8n8Uav8A8JEukXdrp+tXGtL5s2taneaNDpf21nW3EcQjhYq6wGKbE7BWcTfMq45ybWx1 Fnx9hul+U5HksmOSx5x3wOnqfoeKpwzxApNfUatv+vcv8jdY/A2/jR+9H//W/BiCC/XafsdwRnam YWX0zlMY9/wraiivVKZsrnGSd4tWbd7nvjj8OfcV8xV4bz5LXBVl/wBw5/5G6x2Dv7taP/gS/wAy /Hb6m24raXuzltrWzsvQHI4ORhh9M9e9WlhvguEsrj7oCN5DK6gc52kHnAB46/pXn1Mizha/Van/ AIBL/I3WNwvWrH71/mXYI9QAETWt0CMIALdxuIBBB49P5Vo28WoqqFbO9yq4OLV2Cn5eBxyMHt9O lcFXJM1i7SwtRf8AbkunyN4Y3CtX9rH71/ma0T6gjoGs77LtyotpApOSd3Tjg+4rUgursNIjWtwG Sb5AbZicZAAY4457A9CfSvPqZXjoXc6Ml6xa/Q6qeKovRTT+aP/X/J5NQuFY4S4ZtjF9qPnAwzAH v0yemNtOk1qZGkZfNGz5SQvytyBg5GOcYI//AF1+RSwNaDtKm16o+njXg9VJfgNfxDNIdhBi8vJO xW4AJPyjHfqR7elZE+uv5ZIdFySz/PvMhBUuScE++M/w9sZOf1ScVrF/cdCrJ7M5y41qTC5fehDM w6Ak47Y547ngYGa9G8Pp8Mrzwzor+INTuLfxJqep6il15V8tra6Rb21tbS2DXUZjYgXkrXcIdWGw ojHgtSWG95XVlfXTY2pVIuVpPQ6G88L/AAXtdcsYrPxdHrWn3BeAifW4dJiMslpquVkk8sbEimt9 ORZHwr/ac9q+HP2+LH4YaR8PPgta+G9VtL/xFquoNd+JoLG4luEsUSytR5dwxlZS7XS3jghItoZV x8oJ9nKqKWNg4Pa/5P8AQ5sfKH1Op/w99vu/4Hof/9D+Wn4F6domq/tM/Am38R2K3Wgaz4vsNG8S Wkd09rb31jNLsurdXV/MXfG0q+YjKwLHBBA2/f8A8XtZ8KeCvir8SPCWhfBD4X2mneEfHWpeHrFJ ZfEl/N5FjqFxaJv87V3DMUUFj67sYzX9D+AdDEY3KMXh44mdOEZRaUeTVyVm3zQl/KtrbH5N4k1K OFxODrujGcpKablfaPI0tGtPekcBb/E2FWH2f4cfDGBipUr/AMIy14oRSScmaaQ4xkYJ3DjuSa2o Pi1qKBFi8FfClFQICJ/hjo1yqkFA2N8J4O3JODz371/QKyJK7q4mtJ/42v8A0hRX4H51/asnrGjT XT4Iv/0q5rH4t65hHHhH4Sxt5pIZvg94akQhhz96zOe4yPrnph7/ABg8QoJAPDHwhO0qkjf8KV8L lZs/KykGwzx8p/P6VH9h4e9vaVf/AAdV/wDkjSOaVrfDT/8ABdP/AORJn+MPicLGreFPhAhCA5X4 JeEi/AbPytYEf05781GfjB4mGyJPDHwkHldWb4J+ESq5BAyP7P8AUkE5xz7ZqHkOHS/iVf8AwdV/ +TN1mlb+WH/gun/8if/R/FtfjN4ljG8+GvhI3mMCC/wU8I7GGDzgadnsPf8AWoz8Z/Ef3F8L/CX5 F3s3/Cl/CSbQMZVR/Zw5bg9/un8P77lkWH5re0q/+Dav/wAmfzlHM6vKnyw/8Fw/+REb4veIXDo/ hX4TvIjCOJofg14XULkHOP8AQG6H9O1RTfF3X1IH/CJfCZnJH3fhB4aXy+QQcCz+nY/nmuZ5JQUm lOr/AODan/yR0RzGo1tD/wAAh/8AIma3xW1WdvLn8I/Czc43EJ8MdFs2yuPu7LZT3HX+fWi/xCMu Fm8EfDd23At/xSMdsdrdFzEV4GD75zz3GU8kjy2hVqr/ALiSf/pVzSOYz2lGH/gMV+SE/wCFi6Mh j+2/CT4X6kyhVLXCa9aFwoCgHyNUiwOBjHuOOBWnB8W/A9uqSS/sxfA2+b+F7rVPiHHvHcZi8Uxj kNknr0x6VEcixNSVljatu1qXl/06b+9mix8IL+FB/wDgX/yR/9L8QP8AhdHw52OW/ZJ/Z8H99/8A hIvimshY5/h/4TIjnb7cGtT4E/GvwV4E8V/F+51jSb7wFo3xU+H1x4H0jWfhvBc6pqXwjmk1vRda iu9Hjvb03bgx6PLp582+E3k6nKTNJgo/911OHcVLCVaKxE6kpKyU/ZpXvezcKadpfDLR+63ZJn4P SzOiq9Oo6cYxjvy8135+9J6rptqtbn1JoX7RH7Ftrrem614p+F2reM0uY7b+2m1P4d6FPqqXCW2h /wBoXFzcfa/9Omvruy1O8aaQIYhqDxKCjlRheO/2mPgn4o+M/wAPJdDPjHSvgr4J+BOqfDSx0KXw tE1/4ev73QNX0lZLezOoOkimS5015LhZ43YQElGYFn+UpcH8SU5yniqkZx9nNRjzytGbuotJxtbl tHe6u1ax7VfPcpnR9jhqbg3KLbsvhSfMtHfez+XofQY+IP7BHw70f4dX3jfwH4Z1+LxJ4aha50rw 1puheJ9a8Py20PhQY1A22olXM5j8QTB7iVbndI0csMfG3y/w38ef2Gn18W/ib4ZRzeF7D4R2fhXT 73QvC1raavruu3ulWMHiC/1SJtQIV7fUoJrvTrqzeCRIbqaKRSvlLH8NiaOY0Z1IY3H06Vb3mlOo oyvzJRbhKKfK4ptabNadvehXw1SlbD4eThdaxV1b3uZJp76x26q9+8t/+0p8EvEeveGtYmtrjTbO x/Y8k+B+oaJpfhHTdEhXxIujmxNzFJbTKJLe5uWnnaUqjIkxXY2WFenaP8a/2Fl1jWI9Z+HSXWhX sGqwacLTwdaWF9ZWk76uNGtCUulYXFrFPYLLeo3myugdndokNcGLqWjFYbM6CajbWtHW17N738+i baNsNy8z9thptc38r0V9l26/K3Y//9P8hPCmveCrSO8/4SDRv7faWSNrZbbxQ2htaoN+/hYZN+4F ccgjgYbPHZxeL/hGq/P4A1Ubn3L5fxJXABwOpsG9PrzyfT+iK2MwDlzwzKio9nOm/wAeZH55GnXt aWHk36S/yNWHxf8AB0lRP4D8Q7ypDmP4oWw3Y/7hbAAbRjqcdz207fxX8ExIJW8CeLVjxgpH8WbN Sp/vAf2MTyF9e4/DD69hL2/tKh98P/lhfsqv/QPP/wAm/wDkTRXxP8DG+c+BfHuQuGW1+L2nJGTw P4tAYjkY5JAz9K3bfxd+z6Yx5nw/+IUZjT/WJ8adKSTI2jo3h1gO56d/xqoVoVH+7zCg/Tlf/uQz acX72Hn97/8AkTQ/4Sn9n19qSeAfiWoyEAX44aNnOcc/8Uz7ZyfbFX08W/AErI6+B/iWh4ZUk+M2 kGPICqVT/ims7SSxyxJHPPQV0QpYia93FUX/ANu//dDKVSkt6U//AAL/AO1P/9T41Xxl8ClwI/Bf xIUjuvxi0d1jPOcgeHQvfPfk1BJ4h+DU6OkHhH4g22Bwz/EnS7zbuBxtA0VMkY5B/wC+q/pGGExL f8ai/wDtx/8Ayw/MZYmklrCf/gS/+RKS6h8KnBYWnja0AXBZNW06/cc91+zxgnJ9R371pJJ8EWjA uL34mF1UpldL0mZTwOm6ZVGB7Y49Bit5ZfXe0KMvW6/zEsVhlo5VF6NP/Iyb2D4GymOM3vxEkd8/ LL4d0dsFeQAftOBww7k8GuUvdM+Dsin7HeeLSVIJN14b00PyO+25AGMD9fYVnLJVUVq+DoS/H84s tY6nFNwr1V93/wAkTW3hb4J3Cv8AavFXiC1IQlIx8N7S6Ut0xvOpJweRx7V+f3/BTj4WaV8Nb74A 6foesWmsaZ8QvCa/EGzuxoi6DfWsFxcXVmkVxD5sqq4Ni78SEBZ19xXxfGeSZdl3DmIq08vo052V pwUeZe/G+0IvZ236s9nJsZicTjYR+tVJxV7xls/dl/ed9V2/4H//1f5T/hnqQ034tfBTUd8ef+Es 0qEiaNDISWVV2M2cEBo8AY+/jvX6Vftc6Mmn/tTftCWkMJBT4z+ISipFvUhtWugR0PBDY6Dn16V/ R/0dG/YYmn0km/8AwFwX/tx+NeKbXPg9dVzfjy/5Hz8LB4QnnRDhQmDHvABLHoTnI4bHOMj1rWFr IT13KjBI/kC7Sin5e4A+bjGc44x1r+oHT8j8rUrKyLixPM7jDE4G0yR+c3cnDlgeNpyOeGA65qb7 LsXcW+QqcrGzFT/s4Bx0bAAB6/iI9nqaxn0ZpNpl7aWdvLJYTwWrRt5F0IC1pOQDhQwXBxt6ZOMd aoRWEsr2kMMbefJhUghY75GGOECgHcvYY9TUunc1U2mf/9b8Jo9LuJp0tIIZZZnPlNE0BadZAQHw oySR8w9DtGccg1zpstvM8E8cfnw5BjZGWRGAGcr94Hjnv79q/wBJ3R1ufyqqlkkx39m3nliT7NcM km6KF44pNlw3I2DGN/vt6DHBqtPaSCcKMqxXafNJaRDHxweucY69DjrioeHuzRViqtps2b4wSfvE Z6ZBGDz+C+nFUJ7SQZkCPmQlNiAsDyVAOB2JXjOM9aqOET3K+sPdGd9ldd8QCnaolUOnUA4AGM4P TOeO1Z0iLE4Cj5k3RgSL8mAOT6568D0xmtKeFV9ByxGlj//X/nDYbZGkZ2QhihQqANwBA6cA8cj/ ACaLwiTaRsAA/eFS3zDJPp0yTg8gHI71/pjDDJyVu5/LTxGm5RJy0alxhH3EDAzgbQMfn+X569iw SRJUIZQc4IJ3EdRnOcdT0/PrW0sJpt2/NELE2f3/AJHn/wASZ3t7DT5Qy4Go7m2uVWQ+WwAAHHbn k8D8D5tY30nmxny2KBlUbshgD1GfQnkfTrX8F+OVL2fiLjYf3aP/AKZgfvnA0+fhmhLzn/6XI7qy 1LaUCh1J+YcscZwT/I9q6q0v3JBDBicDKfuGAU46+wyfwr8alBa3PsU1dn//0P5uLa88zkSD5QMB SSAB7ge/etSPUQxGw+WuwJ8v7yQ8EMpORjr+uMd6+SlHqdLtc04b1UCkSLICAd3Me4+mCT7dDjFX kuVcsq8ADIlJ+cc8g449ODx1rKcHcRYS72FItrMAu1drjkEHP55wfUZ5q2L1kYBxtWMgbUBB4OeC MdOtcsotJ2ZomnZWJPt0jgb5vMTOx1bkZXI29MdBjPvjtQ+okhlyVOMxtvzgAEN39wR6ZPtjnkn1 ZorI/9H+f9dRYuYg+3y4nkDtIxyRg4JwSe+Cehx05obU5Q/HmeoKyMFj6AYP4Hr7V+cK+yPXVuhW m1SaFIwX3MX8w/Nls5CggcYxj1zwOuaG1t1Hl3MjRtkMyrNsAAztJz3ICnn2/Glzs0jyrRkEmuzG ZpIbx4pnzIR5rRyMGzzwT97oTjGOc8YFWXxJqbFg2r6lFgkhftsiSEbueC3OcE8/3Sewrtw+LxmH blQqyi97xk1r30e4ToUKqtUgmvNJ/mWYfFviF5Vj/wCEh1NZX4ldtVmwGORzls8bRnNdX/wVnmub P4l/sxeH7hpZDoP7Ovhlwksodk+2aXZX+Sck4Y3bt9XJzX3mQ5hmeY5Pmn1/ETqxhRVlOcpWbrUF pzN2+R4+Pw2Fws8OsPTjDmqW91JXXsqz1t00P//S/kn0S5kh8RfCi8aRUNp400+b7SJVQkJcxxry fRTkDAYlF46iv6O9S8Z+Dfg5/wAFZPB/xN+Imt23hz4c+Hv2iPDPxG8fa5qGk3euwR6BNLpeq6uj 2NrBNNOJ7K5uIRFHFIZPOAIwSR+4eCNKvjsDmGV4ePNOphcYoq6V5P6vGKu2kruW7aXdo/NOOnSw eMy7M8Q7U6WIoczteyvOT03ekNuv5fqR8ff2k/8AgjJ8avEXhn4l6h4P+G+s+MfEOteF2+Ij6z4X +Jul6rpYht/D1ndxwwafHb2VxbWsSax9qvHka6kkhR47LUC4DcbZfEP/AIIhWGo6tFqnhj4e63oN 01zo9gfCvw2+JGm6la6jqCxRwa/Gb2ck6NYQ3MyzWzH7Y11YvLb6eI3ijH2OG4e8cqGAhgqFSceR WV6mHskmkkndyaUUrXeln134amc+G1StKvUpxbk0/wCHU9W3dJXvvZa+ZV8VfHb/AII1aLrfgCHw P8Jfhp4m0bxD468X3nijX9S+Hvi9dX+F1rc6ZI3gi4l0+ZVtdQsrO/vbmPUbKPz3eK3t2jS5EMcZ +bv2sfi5/wAE8PFP7MF54Y+Cvgn4WR/HJPFUUk/iDwD8JfEHw7W9n/tS4ubzVdK+23Exg0eewkFq tjeXczpKqeXptooEsf02SZF4rU8zwlbNK1V0vaxlUTq0XFU1OSlBxV3K8OV3TWjatezj4mYZtwVV wNang6MVUcLRtTknz2j73Ney1ura7XvZ2l7J8EP2/f2ctD/ZK/ZJ/Zf+Kk3hPxf4Z0YeO0+L9n4z +GWqeOE8B6lM2s3nw/voraUmxubC3vtRgubuK3hluGitli+aMyW8vsnjb9q7/gkXo3in4eeNfgD4 H0z4Y614F+P/AIQ8YaReaD8KdU0TxRpS6d4uu9S8Va42o7jLLpF5pEsVra6QzO8EkaKljCqhl4sZ wX4jYfNMT/ZE5fU69evUnH2kFFxqVpWXK9fep6vV/FFOzi0uuhxFwtPC0VjIJ16VOlCMuR3ThFXd +ylov8MrXUlf/9P5s+G3x4+EfgX/AIKAfFP4tt4lubL4ZeN/EfxFtfCHxR0Pw9ejVPA//CYafr2n 6F4mh08pHdpJpc2qWl4UiVbgC2fywXCZ/T3w5+0h/wAEgtT8P+HJPjZb6X8YPiFHrtrpXjb4peI/ gbqth428Y6gJ/EL6z4x1CaI+XcafdWdxokFtZylrpbi282SyjIaZf7U4r4Y45r5pHG8NQcZyo0YO oqkYSjyufPTab96OqndfatZ7n4Hkec8PUMAsPm/vWnJ8nLzJ9VO+nK3pG2t4xaktjzL43/tn/sar 4m/4J/eC/wBn7XPDPhX9nf4W/tMJ8ZfjF4P0/wABeJbW/wDB4j8S2WpC9NxdW8l0xW3vtdRYtGlZ ikNurK5gshF73aeE/wDgkPd/s1X/AMYPiNp3wyvdX8ZfEvxd4RsviJca14p1LxvNNfal49l0fxJc 6FBdHUVs0WHwy2yTTxdRBHMlsUljkl+bzDJPEvKcvwMcu9pHFVXONVqVOV61SrVmm9WknC0pPSK9 27TTt62EzThPFVq9TGqLpwcXFNP+HGFOFl3d9End6NrfX5sPjD/givo/jz4ceHtS8I/D3xj8P9W+ JnxI8R+KfHmkx/FvRdV8HaQNQ1y8+HGh61azW0bz2cljqGk2NxLpUU91DLpIZ2mDPLLxPjH4vf8A BNu3tP2d/Cnw81/4VWHhn4Af8FBNU8ZXGo3fw8+Iw8R+Mfhlr2ueHtUtL2fUjGkjppthazafe200 JvTLo9ubOIpLNcXvtVeGPFvF8qxfPOnyzly+0w6alKGIpqLfNZ254N625dnzq64sLnvBdCnaPLGf uJvkm78sqMm1ppflk11v5b7Xg3Uv+CJ1rax3nxIPw+8X3c2v+I4NUvmi+Mth4u1O4SX4kXFnf3C2 xttPXSboRfDeOxS3VL1Pteoi9hjGXi/EH9r+D4BWn7R/xjh/Zivp9Q/Z/l8XTXPwwuG/tJY4dOnC zJbp/aCrfFLaSSSBGvMzFIVLtISZG/QeDMD4gRzvFf6zxtgeWXsk/YNp+0dl+6bl/Dt8Tfm+a58z nuN4YngKEsm0r3XOvf25I3+K6up8y0+V1Zn/1P5ynMTFg0jKCgDSsOV6kkjnr35PUVXJjG5FBZFO 0FSTsUdC3GfY8nkj8P8AVmOCad7H8dfWltcqyGMuSkcak4+Q7iIhzx19RnJpqBIyHyhwB90YPuRx gngDA9frWv1Z7WI+sLuef/FdnbSdIaWaJI7fVD5kjZO4Mny4UjtgnGBwCCeef6NvAXwb/wCCOPiL 4C/AT4TfG39qX4c614u+D3w2vLvUvHfw81+0+Hl5qdj4n8V+NtXu9Uv5X025fVdZ0qyh8I21voUk klwiX0ifZ2wRH/nl9IGi14n4ymna0aL2/wCnMNr6fr+J/THhrUpz4RoyqdXO3/gyV9temnQ4bwn8 G/8Agkx8RPDGlj4w/tC+H/CeraF+xV8Nm8LTeDfHnh/w/PbeNbjw947uvF1hqVta6X/pdzZ6lZ+G Y3W8/wBKJvwj3M24Mvw3+yB8IP2G/iH+yv8AtZ+N/j98dB4L/aJ8H6JdN+zx4C/4SODwvFqVxYaD qurQS3Md1A6anHqd5a2+lrb2skUts4DuSbiBT+ISpvVXe66Lbr0++5903Rvol8Le71etv08vkf/V 8i/4I/eI/wDgnjdfso/tG/D39t3xl8E/CV58SfGLaB4S13xlZaXefEXwlp3/AAj8w1DU9JdrSe+h kSR7RrF4sJ9utYyFkxLG/daf+yx/wRlv11K81j4/af8AD+A+PtAsRYW/7U1n8RtU0TSJ7jRItShk Ft4VjinuHjv7qVLnT31CyhFrdrcXVp9mVrn5WrTduaN7u97W6N2vdddtOi9D1KP1aUbVmla3f8P6 3fq123/DIP8AwRT1Hw/8J9Q0v9qKPTvFd/d+HrP45+Ern9oDSDp3ge6vbnwlJ4hh0nU5tLjj1G2s LTUPEXl3toZ4ZpbFArsY3iPlnw8+BX/BInxvonw08Vav8Q9W+Htvrera9bfEvwV4l/aasJfG2hat pqXMeiaJpHk+GpLSTTtUks45W1y+ltrW2ivY83Mkg8luWcHHq3v2028v8Vu9ka8mDb3S26u27v8A hb01vsz5w+AcH7LPw1/4KUSw2mr+AtS/Zv8ACKeK59KufHfjLS/Hfg3UpIvBmsHT7I63qWlW1jdm XVGtba3uprBYvMMbgSKqyt9ya/8ADn/gkf8AHzRrT42z+MtC+E/xM+J+jf8ACXj4I6J8Z9M8EeEd G1yY+JRqPh6dZNH2aNa2QsfD00V5OVju31GVId2V2y4wbUOl3fa9rK2tu/66GVN0lGUKvTZ/Oz/A /Pj9suy/Zq8KfBH4V+FPgD4x8GeOotJ+P/xQS1120k0yf4mP4Ti1LSLTwsdfe3iiuHWUWepXNu9w oLJdkoFjZEX8y5LzahbdJtdipZxkZA+7x0zjPOPb35ZKPTz/ADZMmpS07L8tT//W/nPluwqlSBub BDIxJUY/l0/X1qJr/LsjNiKP5lIUgAkHjjkngDH064yPzxR1Z6cNxhvQWJKAMWyTv+ZsA49T6dhT PtCqzIJwChaQqQXwTu+XIBzwoAxwAwzjmqiuVWNrFOS7YDaXG5XBba3HXsfoOOfSoY7jcuxpUUqu wujtlgABxkEZ9/fGaZrD4TT0RhNqmnWok3NPeRWpBGOrhegHAP6jjmu8/wCCtt9HdftW/D7T8yL/ AGN+zj4CsJLcMP8AR5U8LaVFInqMGLHOT05Nfd8Lrl4fzeX/AE6iv/K1F/oeTmqTr4Vdp3/8p1V+ p//X/kHzPZ2fhK/UOWtNfgZnjUkti+icAH1wucd8fSv31/4KB6ax/aKhvbMMD4n+D3w21+IRK4Yt feAvDcrMSo3ElnOMc8Hmv6A+jZHnzurJ/ZoYj8amF/yPy/xVtHh2M1v9YoL74Yr/ACPk208EeJ3x JH4f1uQKQGKaVNJtOCFwQmD0wDxwa6iL4e+NnCmHwx4jc/eG3Q55G28LyNpx1z6frX9hPHYGGkqs F6yX+Z+GRwWOatGlJ/8Abr/yNP8A4Vr46ZcR+EfEIHm550O52sMZ4wg5HzZGecjpV1Phb49CqG8G +KSY0YD7PoN1cZbA2hU2jrwDjoPUjBHmGXf8/wCH/gUf8xwweOb/AIUv/AX/AJEo+EfxDldQvgfx UzswLMPDl1hVBIySIzjknnrgj15lPwn+IOYpP+EL8Uu5UKX/AOEfuicgAkLlCefbtVxzDLrJPEQ/ 8CX+ZcsHjltTl/4C/wDI/9D8k0+E3jtcovgjxSQUMbf8SS62svy8bdnvTR8LfHkanzPB3ioK4+4d CuvLz6H5Mc/MP/1V/qXDG5a7p14f+BL/ADP48lhsal/Cl/4C/wDIpP8ADfxwEkX/AIRXxNGCOWGk XK5ycAHC9h+JGaxNQ8F+JtPsprq90LVbW0txiR7nTpbcRZOAfmUce+ON2CemeuhiMuqT5KdeDbdt JK/4MwqUcZCLlKlJJK7dmrHA3QJy6oyqH2Pucc9VyF7AAY/risi4XEaKWAIP7rsG6BefT73X0r6W nhru1jw54hW3OcvGdWVSI1O0FiRiYEdj+JP59Ky51LJ9+TacFsN8zcAAYx1AwP8AOK0eG02FDEX0 uf/R/nVForB93yFgAVYcAZGOvbj1PTpxVB4AXEaLIidIi7g8YbjdgcHJ6V/sJHB3V2j+FJYuztcg aDYQAAQPlDAYJI4XGeQMcYo2phQisCy4O6QOxJJ5VcdhkEH064q/qfkL655nhPx9uDDoWheVGI3O qvh15kK+VkDj684HYV4HZ33lRKFkkFw5G4DMKLheRt7npg56t0r/ADc+kPQ5PFXMI2+zR/8ATNM/ qrwyqc/BWFn51P8A05I3IdQIA/evtKlCsZKYP1I5B7j0PWuhsNYeNAMsA64IDgnk5HHbp+tfhE4a n6HF7n//0v5JYNZkxlmBU4BZVxjPU4GP5Ywa6S11dsqyykEld2G+VCAMZHrz3/XmvBlB8v8AXc2c tf67I6eDVmRTu4xgK38DjoMfrjGeK3rTVPLkVQWyHG9vvtwCOvXjn61xTh2KWqN5dUZgoVnYk7sB CzYwc9OMHAHXrUwvyco24FJNwX5iHOPUDI/xHqa5HF6lpq6GNeyDHzKGwN2OrEZHBHp/hzTGuWUY Rskex2ntwOmeD78GsJxs9DSDuf/T/mn+3YMnmH+ELhwJe+TtzyB0B+vNQ/aUPloFYxDGxBhVTIwC O/4+nFfn9uh6cXqRG52sCqsDtIzuy/HQFuc9QOfU8VXW6aPBOQ5X74bDjA5wM+mM+mD+IbD1mwNo AdSSzcbZeOcAD6k4I5yfQ4ZHLtYFV2RquMbfX0GPY0G0bW0O08D27XXi/wAOxEfO2uWsYiX7wPnJ kcHt6n0ruP8AgsOiW/8AwUl+LvhiDDQ+BbLTPBltHHlViXTbKK3ChSeoZMH6e9fd5FJ0eEMzqL7U 6UPvU5/+4zxMxSnmmGpvpGcvucY/+3H/1P4/r0xweFxNvz5GqpNnLIynO/qOcbgCOgx6ZNf07/Fv xZP4d/aF/YV+LFhpMOv3dr8A/gt4zt9IeSNI9dn0XT9OthatJJ+7USPpnlEyZUcFhgGv3/6PGFeJ jmUE7c1OdO9tvaQcv/cdz8x8ScasHRy9yV0sTRqWfanzp/8Apdr+fmf3VeH7D4j6FrgGhfCqOTwz 4o8d22uyW3iqzOq6nptpqepaJHrdsJ5JyLGHTLa71ee3hCiKU6eY4U2tGG3/AAzcfGDT18IxP8Pd Ilsrn4g+J9O8Vi60eVby20uHx2dO0e/hlmuXdFutFvv7UEfzJGunGNFRGWOP+dlWx8t29O7euifV 9dj9dqUsLzqKkrX37K7V7Ly1PXNa1HxzafE3wroej+CtPf4dywLJ4j8TskVxNI89trW9IY1YNbmz uLLQ1YyK4uU19ym37HM1eZfFnw18VR8WPCXi/wCHE+pjTNC8L3n9saPLdXknhXVrhrHXLWwSWwS5 jglZLjULW5kATzGWwgHmLtjoq1MU4S5b3vdfnbfrYyhCimuZ+v8AX4/kdPqOu/FyxGm/2fp0HiBb vRdRlleDwZLoskVzEl/LZtJFNcnYrCO1iMbOsjSmMqhSWQ2/P6z4s/aBtTqMukeDdN1Gxj0jULjS ZpdHaK9vZ4YPFr2BmtzOrxmaS08JIYiAw/tKc5AVjGKpi1GzG6eHbVmf/9X+3bxLq/xjsbPWk0HT NL1bUY/Ai6r4Wmk8KSJaatq8ja28lpeoboG2FtDFonyFwZ5J5VUrk+XN8TNH8a+If2d/inp+jyXp +JGqfDTxLZ+FdQ8N6fceDNcTUns9QTR5LNPOM9vcK5tCr+YDvG75M7V51UxaTT2t+J0cmHvucdeW fxU8F+GrrTfDOhL43udO8O3GsaMfEekNqGp6lPcw63fJZS3ckwbNnINKsokncyyxkb5GYs9fJP7c /hrxjrv7MPx71XxP4UFhplv+yh8btP1eDT7AweHp5LC70yfwbqlza7mWG7m07T7yeMt+8ja7uEyv 3a9zhmrjY8R5aqMmv9ow/XWyrU79e1/U4c1jhZZVjXWSa9jWsvN0p29Pe5bdj/O31C3VZ5sKpKt5 RG3bnHBwD0Jx/OuauodjvjnuyMMYznOSO3Pc1/sJShp/Xc/gKdV7XMWa3KhgQzZJAChfLYAknPT0 9P6isua3CsGw3QDJX25wBwPw/M10ex5tLGca/K3qf//W/nult85xuXHOCNjY9Pw54qB7JVDtk4Kb g/TI6DGPpn8fYV/tTTw/un+eE8VyysUZ7dTtByWAyQvQ+n86bHa78ncoESbgMNuk5HHueSeey+ta rCGX1zTc+fP2hrdI9E8NeZhN+ryKZWJMaq0Qzn6Y/Wv1a079if8AYU134HfDXS/Gn7SXwl8J/F3w F8PNRTx94i+GHjyyuNL8Xteax8Vr/TvE94t65e4S2svDngaxGnWkdvcuviWJ3VZPvf5lfSPoSXi7 mEFty0P/AExT/U/szwfnSqcA4aVXvUt/4Nl+nlrtoczqX7Hv7DPjHwj4p1xv2gfCXwy8UeDP2Qfh 3458N6R4e8Yabc2HjTxbqHwx8ZeJPEljexTXUsj38WteFtM0yeO3eELN4hiAgjYxo/rXh/8AYL/Y L+L3xJ1nw0P2lPDfwmdNK+E2h+D9O8I+JtM8R2PiC61z4b+H9T8TSpayXM9xcXsWuQ63YTJBKF+2 3qbIYlRbd/wSrSvKOuj/AA2/4J+oU4UOR8z1duv+L/KJ/9f8D/j7+yL8Mvg3+3J4E/ZgufiFfeHP Autaf4D1fxb4z8W39iZvC8fivQdJ1+/RrmMJan7Imp/Zo5GKxyPEHZo0Y7ez8NfCT9mb4af8FJPC HwoPjrw/8Y/2WrDx9pWo6j4v8V6zaaXo+v8Ah280i31bUIr26tbtIUnt1muLZvKnUme1AGCdtcFe ioKUU9ro6qKg5RlP+ZaeXU+8fjd+yP8A8E4dR+JfhK6+HPxo1Cy0D4iXtrqN1F4J8a+EIfhj4FtZ dN1Vvsk0uoavJq0V95mn2d7c29vbXkMK6k8FvPcSCBHf4T/YF/YAv2voPEn7Yek+Gr+2kC6c1v8A Enw34g0nVboap4ittRsbe5SKMFdOs9I0+4N3IqJdjVUMcaEBDy1aNPmspaX/AK+46lQwtvj79V/W upwK/sm/sP2Mknh+L44eJNY8f2/wiX4ladoifEfwfoXg/wAYX0njKLw03hqHXZ3aKwvrawE+uObh HRrdSAV2Zk+Yv2pfhT+zz8LvDfwpuPgv8QPFPjzX/EOk29744u9U1fw1qHhq1nm0jSL6S300WF9L en7LdXt7ZSS3ttbo72T+V5m1jXDUpRjDmTu/+G/zFOnQjFypy1Tstu+rP0O134Pf8E7/AIsX0Hgo +KvCfwUu/hp4A8DX2ueP/CPjaxk0/wAeSeIPAum3/iK+a1nMqztomrWN5FNbwN9oln1wxDYkKLXj Pjv9n79jv4WQ/GmLwn8UvC3xQEf7Nfi3U/B7a14v0+9uYNesvG2i6V4e1HTWtXjAudQ0sajfpYP5 jxws+9WJBGSp0eZN9LfPVJr7tb3NakKFnOl6W9Fv8z//0PyQ/Zs/Zv8A2e/iz8GvF3xG+Jv7Qfhn 4YeJPBOoeJTe+CNU8Q2Wm674otrDwq+peHYNIs3RpZrm/wBVzbueI1htZV3rK8Kv6p8Sfht+zHo1 h+1dbeHpvhjd3Ph34jfB/QPg9dWPive72Woafdt4xuLEC+cTwM6QG7kYusbygqYfuL8VKnTVJTT9 53uvy+89qnCmoqTeuv5O342/A8on+DH7PvxD/wCCgfxR+FsfxA8LfCf9nOy+KfjGTw54qstbi1LR B4d0c6pe6VZ6Pe3EzxTTX8FnbW1m1zNseS5h3y4JNe/+GPgP+yTo+t/ArwdqGs/DTx5aw/tw/Evw H468Zah48Ojv4q+HOgWPh9dBv9RSHUkjtYrxzrtxbXMBjMjDaJJAFU3iKdH67Lka5PaSSS25bSf3 bWs/w33wsKUqXNWetuunWO1mtd73urfeuq8J/wDBOz9kXxp8PfBevwftqfD7wb4x1+XTLzWtI8Xe NdF0/SBp9xpnhLUdWmtmR2uIZbWXXtW0mG3uFZprvSt7vDCJWT8avENvpWm+Ita0/RdSbU9Hs9Uu rPS9SYKhvbeOV0hn2AfLvRVbgnl65eWLpe0T10Vuu1/+B+DNa1GFBpU5KSfb9dWevfs3aNJ4p+PH wj8PwljJrvxC0nTAgAYqZ7uFAeOp+YdfSuR/4Khaz/wkv/BUz9ri4837Tbr8ctT01H6qEh1GZBg8 8YA9uelfdZXBR4Dx83v9Yo/+msR/mfNY2V8+w8H/AM+qn/pdI//R/j3vYEfwnqyhX3w5YtlQRgoe gBz7A4z1r+hL436jJq3wf/YJ8VxXhtZ5/wBlbTbD+0VYg2smleKPEmnxyBkO4GMW4I288D2r+iPo 1ySx2Ih1daC+X1fGN/kj8b8Xuf6jSktlCT+arYdL/wBKZ+vNl43t9b8HaVofjv8A4KJeOdN8a+B/ hVcpd658PP2rl0vQ/EMyXfjy40/XblLi6mfU53h03wdbto9q0F+F1nc6rIrqMpfiZ4Q8YWU8usft 2fGXwTrL/s4eC9f8MvpP7WsEukL4lufA+u3esWOq2wLGa6h1nRdPtp4RJbzBtdjDhXKF/wBBo4DM qeFqYijw1TbhNuEJ4NuU4Talq0kk4JtKystI2bi7+VisRlEKipSzqfvWvKOJVouLlF2V3o3yt3u9 L3tJNfMXwG+Lfi34g/Br4+eI/iJ+3J8YvCHxP8JaJDc/CTwxf/H6+8Oxa9dw211eypcwXk4+2Jdr bNaRLaTI8E7RGQMJ4Uf6V/YV/aO0jxX8Ivil4b/aT/ad8WeHdT1rxXFpHhTxPrnxnvLPxZols/h3 Wru9vIHe7NykcUtnp6wOkbxyXlxBDhhM619dxZw3BZVmUcmyOmq1GtS9jyYaLdSHLCcrWjaXvc8X Z8uijLrf5fIM7pLMMJ/aWaS9lUo1OfmrNKE3KUY7vRqPK1dNq7kulvRUv/gk3iLxlp93+3R8dtA0 TQtR0d01a5/bW0rXntrG4uhDfyWcdkk/9qTGJTcLDZktCJNs/lsq+Zt3C/AxbUtH/wAFAfjBbeI4 LOGbUvCqftpabeaZpdzNqWiKlpBr4jWzvFfTk8R3TXMJMdvK1lBLtkVUuPmKlDiShVVuFsPOnaF2 sDO+tOLm7X5vdm0krX96S3pTt7dOvw7WpOUs9qwmnPR4qO0ZtQ6W95Xd77JPacb/AP/S+kbbxf8A BXUfEmtadp/7bv7SmneGNA+Ma+AfE/iLXf2w9OtZ9C0C2Olw/wDCTaLbxRSP4ht9SaTU3RLEI9ks C+cHULJL4D4y+PniX4cfti/Czw34A/ar+LniT4Ov4w8Mz+Jj4x/adg8b+H4IZtRhj1SC/wBe0+9T S2tmgXznYsohSdkkYNGzV/f2V8PY/FYjE4LNchw0aaoVXGcMG4t1VBOKi5KS6ppWTcpOEbypTZ/K eNz3LKGHwmLwOaVXOVaCnCeIT5aTkk3JLlafxJ7pRipysqkUfYniH40/CH4wfEHxFqLfthfFz4F+ G9A+I8nw+1rUfDH7XsFro6WGmXmhWtt4g07QmaabUYtZivtYYT6ZK1vZjSI5ZgwkavnX9oP4myaF 8D/2n/Bfhn9sDxj8Qzd+FfhxqekaL4l/atg+I2uWM2sNrFr408NWlzZ3cdtrtssLWL3H2S2eOOOd UlAZXLcuQ8N5pQx1HKcZkdJxo1MNavHB8spKOIw3O3JprSnKbk7L3ebVOnM6Mwz3KK2BlmVHM5p1 KdZui8RdQk6NZwjyqzfvqKS115d+ZX+Gf2QdA+AOt6Hbr8Rm8ATeOk/aY+HNvqtv8SdbttA0Wb4f XN/dQeKHtHuporbzFnfTBcfOZUtWkdVWNJpE+nLv9mf9hj45anfeLT8Q/DXwmWL4vyfDK80LQPip 4P8ABWnadpun+JPC2gQai2mXTTtPNfafq2taw2qWc39m/wDEgdFjQShk/R+Kc549yHOq2NyLC1MT SinH2fs6s4O6lKLhyLVtwjTbUmoyqNtdvlciwXCOa5VSw2aYmFGq3fn56cZK3s4tS5unvTmlZNqC 1018x8Ofsa/sL+Ml8Hajpvxv8U+H/Det+NdS8O+MLzxZ8WPAOl674Ek0+Szt7fSG0xyk19/ac0sp t9dtf9Dii2yy2wRJZFh+KP7KP7L/AML/AIPSah8MPG3gb4m/EjVfj94U/szRfHvxR8H3V14S0Vzf Wmo6HqMmnaiI7iNp7nTJby+jkigWCWAr5DRXRXrfFfiB/a1LKMZgGqPPCNStRw+JfKlKTqOHNGcJ xtGNmuZNVErOSaOaOTcH/UZ4/CYtObi3Tp1a1FXvGHKppSjKMryldaW5L3tdn//T/Hr9pTwv8LfD vx/+NGifA/VW134OaT8T9b074Y6u122oDUNEh1CePTpRcMqtMGhWMiUgbxg85yfCHsssyoxILBTw FJHr/Kv9uMop4ypleGqZjHlxEoQc12m4rmWl9pXW5/mpjq+HWLqwwkm6Sk+Vvdxu+VvbVq3b0Kr2 aA+Xltw4PVvb078fnTFsW3Y5B+/jceMcV6aoHJ9Y0u2fMv7T0Zi0XwmCGA/teZWGQGK+UuQPz6V+ xvhz9hX/AIJ+/ET4W/E+40v4i+B/hraeIP2ZPhD44+EPj/WvjJ4c8S+JbLxi/g3XtU8bWU2lrqMU sS3GpaWun3dvdQrJDcq3kIoKIf8AMD6SdNrxizKLWns6PRvX2FK36n9weDDpz8NcJOT95SqW229r UT331tsfPPxZ/YV/ZvT4bfE/4h+H/i14U0LWfh3+y18L/iH4a8N+F/G/hNdJ8Razq3gOHV/Etrqc d3rs19JqSanDPaulpFDDJOtykMaz+RYSx/sLfsm/ssfH/wDZLutf+KPxp8H/AAD+NFj+1lpOjeGP iDd+LdP07X4fDJstGi1BJbG4v4dkMU2ovcw3iopSa0IMnlhwP57lBuCfn2P1mFKl7ZQcla2runZ/ 16/ij//U/Nbx1+wr+ydoGqeF/i58Sf2ote+J9zqvxT8AL8V9L8R/F7wbqfiKys/Eh8KjXdP1LUId RuLye+0xtav1up9keIbDzER447ma2+HfA/wk+A2h/wDBRrwz8GPiveWNr+z1cfH2z8P63Pp3xO0T V9O07QL68Q2y3fiaymlsPLiiuIFupI5Q0QSdGaKVG2xVhNxk5737PuzpnSw8ZQVN3TtfVbO35a/g el/tOfse/Bb4H/Az/hYnh7416P4g+Ig8Y2eh3PgTSfiL4S+IFhGbrVvG1nf6fb3GkXczSzaNB4d0 OW5vVzbXB8SQ+UFCgt9hfsc/sVfsbeKPBfgHxd8Y/jV4Ws4Pid8D/Ec/i2w8T/FbwlpN18PNacWE OkX2lWi3yzCaCW9hYR3bO/7q6S4toNqh+SpTSkluvdv82r/dr9xtSo4d1HFy0Set1ur/AJ/rua+s f8E7f2HvA/hfWfGPiT9tKx8U6N4S+FuqeMteh+GnjDwZreu65qNrrXg60sLfR9KlvknmNzYeJNWu TacyJJ4UvUErhgy/F37Y37P/AMC/gJJ8J7f4M/F2b4rweL9AOpeINcl1/wAN6rpNwwttOlW5tLfT bue7sYnkuruH7PqcaSg2TYaQ71Thqwio38v8i6tGlTXuzu7pdOvz6H6hfEL9nb9gnVvDvj3TP7e+ AXgHx43wHbxP4FfwV+0Bpeo6V4Sni+IFhpl7JcTNeTW+s3MGkQ3uoWUccsF/fWN0ySWEdyqSr5x8 RP2BP2DvB3hXTdSg/bCtote8SfETTfhdpmjp8UPA3jbT/Cc2q6v4psrTxNr1zYS5TRVstA0m+uZL eOR7RPFlsHLG2dJ+ecKc52Xu79+zaX4Jed+5uqOGs6nN8k1316/1bsf/1fEYP+CU/wCxrcXmqazF +1yZvhPa+KtK02/+Jtn408IajoPhJb5fAkS6bqM0cpilnlu/E3iC1GohobW2fw5+/jHnjb+LP7UH gH4efCn4z+KfA/wv8UX/AIv8GaPHYNp2r6hr+heJ70SXGnWtzc27alo9zPp1x5E800Pm27jPlYaO Jw0Y+RnSiqftOrSdvnJfp/Vz269CnQlyxnzNPy7J933PADdYSRU84q6guTJgfxAA8d/8ioILpzIZ GMiNkDfks7BWPB7+vPtXNbWxC1VyRbhjtQySNk8ncR7YyO/C1IkjbhuZm3E4UHO4AZHynrUtbG0N rH3F/wAE7dNbW/22/wBl3TgWlST4yaFNJnBQrFdxyPxnsqmvg39o3xMfHn7bHx28YSOrnxH8YL3W ncncGee589iPUZc8dv0H6FhHGHhvib7vFQ/8lpTv/wClHz2IblxLTj0VJ/jOP/yJ/9b+PoQqdA12 PcrgQu+1SVUF14Jx6bRjPTnHU1+7mtt/bf7F37BGrhmkMfwo17w4HVij77PxTqN8V9cj+1RnnODx 1zX7x9GvE24oeC6ymp+do0MSvzmv8n0/JPFzD8/DVTF6+5Dl8verYf8A+R0+evf9aPGX7LP/AAT7 8XeAfhh4j0nx7ofw58Qp8MNFvfG3hf4d/EvStZ1q/wBcv9E8K3N80lvrGrNCkVlcahqTPsmhd2E0 IjX7Jvku+If+Cff7AujaHpms6D+1/ZeI2vvFQ8PanYf8LE8I21/oGnmCYvrpVZH+0xRyQqTaIEkc XihXBQ7v2aPiD4s5dGOCWTTxHvVV7R0ayk0neDkoRjBRaagmrbcz21+Lq8G+GeNm8Ss2jQ/htwVW m0r2U7OUnJuOsmnf+VeXlqfsj/sLWnw/+IOtf8NMat4i8UQa7qeofDjw94Y1/wANLc33hia0ll8P 6lqkV9cWixXaz2k8N7p0bm6QSwFYcSKG8Z/Yuu/gn/YXx+t/iv8ADv4T+L9W8O/C6Xxp8N734j+K Lzw7NqGr2Wp6XCmh2qxX9tHN9ptZtQfy8PJuhUggKc/dQznjnOuHcznXoVMHXp1aao+zhL2sqbmu Z2nGSfu3+G9le6R8c8s4MyriHAU6WIhicPOlUdV1Jx9nGoqcuVXi1b30kuZq9003ofWXxy/Z5/Yf 0jxr8frz4bfEDwLe+HNX+EmpeK/AejW/j/T7qLwZrmneOdMs/wCzdHuDdZna50gXU0CztK3lGYkS ZVk+UPin8Iv2e/hZ+018HtB8NeJ9N8cfBfWda0bU/FV5qPjrTfE5TT31yW2vrbUrvTisVrILWAed Eskmzc0kdxLG8ch9LhviLjbG4aFLNMHOnL2dfV0pp89KMFTd5JRXtXzSs077LY8TO8n4RwuK9pgs XGonUpXSqQtyVHNzVotv92lGLatbdn//1/afjH+zT/wT717QfDniD4c/EnR/C8dnofiux1/TtK+K Okfa4bjSNf8AHsulX01rdTTPcNqEWm+HtOt0t3iAt72zuHDl3L+L/EX9nj9jvwh8Of2kdL8JeMtH 8WfETRvBfhrx18HdX1D41aReTXFu2ralDr1pDDbRpbzX8VtDZNJp5aWU+cfs7vGVnf8A0cyTi3xQ qOngczwMocte06nsKjcqaxNJNK6UeV0ZTana7gvdtKLkfxTnORcAU6lXE5dioyTo80Ie2hZTdCq1 fVyuqkILlb+KSvfmSPBfhD4Q+Ad9+yt8Q9c8Y6Zomr/FvUPjx4R8F6EbzxrD4f8AEWh+G7u31CTV 7/TrZ7pUwk0NpFLdT288UQuI8gAMy/UWg/safsCeKvF2saLa/tK65oOi6B8RNV8D+IvEHibxv4R0 +DT4tLltxZalpu13Gp2esI0ghuYTGLSQN5iyqm9vp894n4+yPFYqeU4J4qlz1nFck5OKhTh7KMFB LmVSaknK7ac3K7jFpeNk2TcF5xg6CzHFfVqijRv78EpOVT97KXM3yypwldR0uocuknd/Kf7Yf7Of 7NX7PPxl+Ffh/wCFvxqg+Pfw31/SLTXPGup6Lr2lvd6QW1GSO5sPtVkZ4oZDaCJwZELIzMSrDivt O8/Y5/YC8YaP8QtIk+LHgX4Rz2n7Vd/b/D/xNYfGfSPG+o6n8PJl0D7Is8El4IxEEu9SmgkaNbiN owlxLMY33bZtxj4h4fhvLc/y/LpPE1Kc51MKqVST51Pl5Jy5XKCcXzRVoybXxNXRWW5FwPXzjMMo x2OiqNOpGNPEOpCKcGovngm1Gf2lJ3kknsmkz4Bsvg5+z14Z/bl+Efwyi11fGHwD1Pxz4XtvGd/8 QvEulaZbQafqDW39sxXur6VqBto44FkmInS4idNoDqjBlr6j/wCGRf2DvjLBeePvDfxXT4J6W8t7 Zx+A9W+IOgpMdT0ie00ttJgguru5uLc6vIbjUIL2S5ubW3hlCEyhd9e5xFxP4g5VPL8yyvB+3p1c NS9rRjSqTjCtUdSUpRagqvu8kYOEmnHnjeKk7vyshyzg7M6OMwmYYn2NSlXreznKpCMp0qapxhFp ylTfO5SlGcU1K0mpOMdP/9D5G/aH+AfwH+GnwZ8XN4F8S+HvF/jDQf2h7Hw5pevxeNbXVfEs+gX/ AIMs9XubKWytrk208VhqLy2x1G3t1V5UkXfgrEn51S2KO4jA2FWIYEnGewxX+2/BOLzLOeHKOPzi m6eJnKpzRcXBxXtJOCs0nZU+Wzau1Zttts/zD4pnluW53WwOU1FOhCMLSUlJSfs487TV1rO91fRt qySRXksYYmww5JztChtx6gdcjOOcdqbFZgBgMErwPl75xxX1vsEjwVj7wXZ/1/w3c+Tf2sLQf2V4 MVVUodZuCxYYRv3MY5Pp+XU1+3vx8/4J7f8ABKXXPhdcfEb4W/tAaD8OvFfg3wLZadrHwt+GXxK0 XxxqmteIH0PWdUu76SHVtenkms4rnTrKz3WM6s7avGEtw8SJcf5Y/Sdp1I+M+PjS2caF/wDwnp27 n+gPgJ7DEeGGEnW0knWa16+2qK39f8P5r8T/APgkT+xB8O08TWHiL9tSPRvGPhjW/Euh+JfBt54v 8FHxL4Ibw5qGt2dhJe2Ml9C1xL4kGmWgtLVXtzp76mn2qWRVYn508Yfsc/sb/Ce4+OGm6h8UdJ8d 6J4B+IHwYHhzU7L4x6Bc65quieML3WG8XHS5rOQJM1paW2mm4a4sS9g87xvEuBcTfz3GNWcU2rad vl/wfn5H7BWw2GpNqlO9muq8m/8AL5H/0fzhh/4JtfsM+I/GPiOSX9p3RPAnh68+J2rW+iaLpvx1 8B+JU8PaGPE1np2mWQupblTc3P8AY13Lr3nyOsZisGs3xcMZ14P4MfsZ/wDBPf4s+C/7Qb9oLUvB ujyfHjxrp2la9468ReHfCPxk1/w7oXw603xDo2lnRZtVbTrdrvWptQ06LUHBS6e1+R03rAvRUp1F e+uvZ/1p+jOuNDDLli5b77W66fgvv8j5t/a//Zd/Zy+DPw08O+OPgn8a7n4k3uq/EzWvBsml6x4x 8K3niO1stO1DVYYL280TS7m58iKe2ttMlivIbu6hnkuLpWW2Edubr6/+CH/BOv8AYd8Y+Efglrfx I/ba8JeEtb+IPwqHjPxvZWPxF8MRWngvVrrVfh/b2enOlyY543Wz8X601zbzKHim8IX+JHjUyLxV oyjZpdunml+T/AuFDDyqyg5pR73XZv8AS3z6nhn7eXwJ/ZT+CPgD9k7w9+z38SPBPxU8aar4e15/ jf8AEPwz44j1wa5e/atNuNKa402O8nj05I7a9liiQJE0iR5mBmSQJ9+fED/gnd/wTx8C6r4v0D4a /tl+F/jC1z8MdbtvDd3qPjnQJpdB8Qpr3gez0qSwttNvfO1KR7XX9cljtVDGQ6RPiF9uF5KsOVa6 7fmk/l1KjTw7lJOdktteyv8AnoUPjx/wTR/Ym+Butw+EfEH7TviDQfE+v614S8M+FLrX/FHhibSd Lbxe3iKa38Q63BFtul0Gxi0vSUvL60SZojrQkCN5PkyO079iT/gnU+p/Ef4ZSftLeHpja/tCfCzT dA+Muo/GHw3Z3ei+BvEHhLUr7xXNbackn2G+ltNaNvpc0gctC0dtMwghWYXHI4wkk31V/vTa/G1/ kb+wowk1z7NrpdWdn/Xc/9L8ivD3hn9mXwv+2JP8DLv4ieKfEX7LN9oeox6ePiD40stK0F/FF/4L uBocuqXug6lcaakNt4hnsIzfRy7EhtszoirMg+ufEH7NH/BNfxjp/hO20b4k+HPCFn4cuNQ0j4na 74V+LFjL4o1678IfCLRtV1MaPb6vfm2kh1vxbFq9lZ3AiWGaWVTBKkIWNvmZKDkovq3vslyu1/SX 6dz3aVOg0+aVvPrur6X6q9vmeWeEP2Vv2Afi94Q+El54e+N7/DWy1CDVpfFWv+Pvip4b0rxxqxj+ JOn6NAmoeHJJNmmzQ+F7i41gCKWWOR0EaS3BjkZpLv8AY+/Y0+F+qN5/x2+G3xps9Q/Yt8c+O9QR Pijp1lpXh34h2OgW934bttIuLa8t7mZ5LvUYBFp99DvkezuEaObDBOakqcqs1Je6rWvpe71/D/hz plRoRoQq05pye6utNF+p+LjsgZuSgCBkIO5snkrn24HXv09ZoZFwH2g5YpnAIU9M8e/oO9YuDMIv S5+j/wDwS7mit/22vgzrchUQeFL6/wDFcpbAjRdOsLm5LH6eWTz6V+TdzOuo/H7xvekrKz/EG/Xg k8QzOvJHpsAx71944yo+HiUtp4ib+6EV/mfOu0+Ipu+sacV+Lf6n/9P+PfT2DWmsQ+Yw86BQ0RAI ULvyOnoBjB7e9fuh8O1XWv8Agmz+xrqih3Gk/EL4heEpcIfkaD/hEZ0Rs9OZ5jjjqfrX7l9GW3+v vK/+fc/vtGK/Ox+TeMlT2PA9W32pQX/k6l8vhP1vg/Y6/ZH+InwE+B3jMeJx8I/iHqPw506/8QeG /BmrReMfE3xHllFlaX12mlahqK/Z5Lea4F1IUlhh8iRyIwqFl808JfscfBfRte+GBu/HVv4q0z4l /C3xrdXVr4mutNsbXw1rml+D5NS05dljq3mMpvJYVgmEskLSmGOUGVbmyj/o7A+IHGn1TGYLF4Ru pCOI9nV5JKpLkhWnBqCpunpKmqadmm4u6erPyfMeB+EPruFxGDxiUJyo89PnjKEOadKM05Oop7Tc 2rppNWeyfr+p/wDBMj4H+G9H+HOs67+0Zf6bp/xF0E6lomsXmn6VYaNfSG/8F6a5tXkufmiibxY1 04zvWDTpBwcsuUv7D/7NPg6z8V6LdfF7QviV4j8Vfs2ah4p8BXth410bw7o+l+MNL1PRJp7W2upL lIZ0m0+6mmgFz5ZaBbolNyKVuh4qcZZhTtgcq5ItyaqqNSceSlWlGovhd5ONKei1WvVGNXw14QwV W2PzPm92zpynThJTqUeam21JaKU4W25tN09fkr9rj9nj4SfAvxD4Q0r4VfErUPiRo+tRXEd94j1E 6MNIvzbNbiK+09bG+uJ/sc6zEq11FCSYW2GUBtv0V4w/YP8Ahr4e8cQ+HfA/x00Dxv4ZsfgRqfxZ 8V+KNKtbbxYml3WhXUsV/p9iltOPNSa3Nre28kphZ4LuMsM1+oYDjjNXgMsxuOy9f7RDFTqKPOow lQkvZwvOKcfaK9+Zbp8vMkm/ybMeEstWMzPDYLHSXsJYeNPmcHKUa0JOpK0JWlyNKyi+qUuV3S// 1Pnn/hAPgIFw3xP8S7ElJP8AxaVTkDcTj/iZepH4AetR/wDCvPgC3MfxS1/aWUYf4SgIOQe2pZ9P f+n+1VCtxVtHKqf/AIUL/wCVH+QGIxHDKvzZpVW//MP/APdhsnw//Z/woT4o+IlUHC4+EgJJPGDn U+O1U5PAH7PpGz/haniDoT83wiG1sHAz/wATLp1/z19anieLFG39kU3/ANzK/wDlR4lWvwq5tvOK q/7ln/8ALSi/w6/Z7YnHxU1488g/CPduJJJx/wATLHZqhPw1/Z5GVPxY14dAAfhAR0Jz/wAxH04B 9f07qWL4sirf2PT/APClf/KjkqVOFZST/tmr/wCEz7/9fSsfhh+z1k7vi1rbblOAfhEzEcHAI/tD 19KiPww/Z6IP/F2Nc5JUMfhCxzz3/wCJj+ldsMbxav8AmTw/8KY//KjKo+GE0/7Zqbf9Az+/+Kf/ 1fj9vhf+z05APxZ1pVBydvwhf5hkjjOo9aqXHwq/Z6Zi7fFrWmYt82fhBIW6+v8AaJ61/vF9c4re +Tw/8KY//Kj/ABXpVuHoRThnFR/9yz8v+npA/wAKf2eflP8AwtTWWPHP/CoGIHX/AKiPuKb/AMKr /Z8kOP8Aha2t42AE/wDCoWwAOef+Jj74prFcUvT+x4f+FK/+Vj+tZDH4s5qWXT6s/wD5aZWrfAP9 lrxIlvDr3j2+1i3tJDLbR33wZ89YWK7SVB1Hrjv+FY1r+zJ+x9YXMVzZ+J2trq3lWe3uLf4J+TPC 8bbkdHGpAqylVIIIINfL5lwjhM5xc8xzbhDB18RKylUqTpTnKysrylQbdlZK70Vlsj28JxzjcroL AZdxdi6NGN7QhTqRjG7u7JVrK7u3bq292a/in4F/su+OfEOr+LPGvxF1jxd4p1y8Oo614i8SfCOT W9e1idsBp7q8n1RpZXOBl3YscCsX/hmL9jr5T/wkSn5hn/iyEfydBxnUvb8MdK8ifh1kU9HwRgP/ AAKj/wDKDvj4mZ5B/wDJbY7/AMF1H/7nP//W+Bl/Zr/Y7jU7fEkhY4OP+FIxc8/9hIZx+lWY/wBm 79j6MFB4ik3Fs5HwPiG7vwTqXqT9M1/szU8Nshk7vgrAf+B0/wD5Qf5Ew8UM8X/NaY7/AMFT/wDl 5NH+zp+yCDtbxLMxwu0j4HwEHA/7CfHQfpViP9nj9kTd8viG6y2WZx8EbVSx7gg6n/LuTzXJU8N8 jTuuC8Bf/FTv/wCmDX/iJ2cWs+NMdb/r1P8AL25aT9n79kNA3/E9vEc4xt+CNpuU5/7Cntitm0+B P7J1s0bweIL5XhYSpJH8FrSOXK4KsD/anUEZyPSuOXh1kd3fg3L/APwKn/8AM5tHxMza3/JZY/8A 8Fz/APmg6nxT8N/2dPGutXXifxn4/wDFnjDxJqGwXviLxN8L49f1nUPJjWGLzrqbVXkcKkaIu4kh Y1A4GKyU+CH7KAG7+174kDYdvwVsmbJ5wP8AiZEcjjn0NZS8OMilrLg/Lfn7P/5lYl4mZw9P9cMx fpGa/wDdpf1uf//X8K+GX7KX7NXxP+IHg34c+HddaHXPHfiez8K6TJqPwZsorC3mvp47eOWdl1Bm VEaTczKrYAb5TxnF8D/s2/8ABP7xFquijx9rvgDwtFf+BPiZ4K+Jeq6/8X9C8O6r4c8WR6la6N4T vdP0CSaC4thbIY9QikaKS2aOdhL5pVwP64+lXlWRZHleEy/A5JhsDiVOM3LDqK54zVVKMnGlTe9K Ts009Nbo/lb6LmY5nxBiMXmGYZ5iMbh2pQSxHMnCUHScpJSq1FZqrFbpqz0tqfnL+3n+zJ+zP+zh d/DDTv2fPj3L8eZPEttv8S+JoNe8Lah4XuHbTtFvRJYQaffS3toiXGo3to6apBES9g/lySbZNv6V fEf9k3/gmJ8afiZrnhDwz8ZfAf7OGn/Cfw34f8P+J/Gfh34iaLqfg/xle6j4IuNfuNbit7q9la7i h1W2g0d0sJFkWfVvnVFt18z+H/cjZy2cVf138+unlex/ZlKjhZVJ0nLZrlemyvfW9tj4K+Mn7OH7 Nvwx+Hvx407wH8QfCnj/AMS2kHw5fwRea98QtEufE3hq/wBY1rxLa6xbRT2V0tldQiz0/TZ7iQIy 2w1OASMhUsfzV8SaReeEPEeueFNTuNJn1Tw5q11o2ozaFrNp4j0eSe0laCQ2moWskltcRF0by57e SSKRcMjspDVNaMI8qpu+/wCb/SxNSmqVTlg9NO36X/4DP0K/4JgxLJ+0F4p1V8bPD/wC+IOsNJkF YDF4P1l0Y54++q8n2r8hvB10msfEHWNVQqsd94i1DU1PVYxI05AByQc5HcjpzX2+bU40uBMtsvj9 tL/yo1+SPlsJPnz3Gx/lcF/5Imf/0P48NPnAkvFHlkfY3XZjerksBuAPHG735IxX70fsvRjXv+CR vgy5O6a58Dftn+ItBJXloY9X0CK628dATpAx67e/Nftf0bZxp+IEE+sbf+Tw/wAj8j8ZoSlwNV5e kr/dGX9eW55fAknG9CNoRflAO1hwBn6gdf07aMaEDeY2IYhctlmLEAHr055HfocV/pSqaelu36H8 KTry19DuNZ8X+K/FkGjWXiXxZ4l8S2fhvTU0jw5ba5rlzqtpoNohwtpYRzOywRLtyI4dqjj5cAVn CMhMvtYIqEnA3ZPbPrz0x2/LXA4HCYGlHDYKlGnTje0YpRirtt2Ssldtt922+p5uYZhicXOVfF1J TqO15Sbk3ZWV27t2SSXZJIFXah+VtykOPk+8Tjt6fjj86+6v2DpD/wALI+JmmN5mNW/Zu+INnJE6 gLI0XhPVLrkj/atF49s08+h/xj2OdtqVT/0lnn5PiH/b2CjfepBfjY//0fi/7OVkdj+8ViRIYxsD dvf3/X0qrsGRyyliFEjDcyDOOBkZx0/A1/vBhYWs2f4bZhiG04rbUgkUZ4HU/Nk/Ljnpx29O9VpI twwUclSAVIwSemPbP+ele3S2Pla9WzIBbMfvblTsp5PHGR/9b9KBa56eZvxtXjJ449a7IdDhlW95 f11F+xkZ+X7mRjGeD1I9O9RCyz/D1OVA+XPXPOevTiu6Gwp4i6sux//S+CRZ5xhQuHwFK9Dz/QdK hlsxknaQQcNkk5+o/wA9e9f9DSalY/5+linD5MYbQADA56jnO73P4DrTUtCuflwoBGD17HGapWWx m8W27tllbEBQSvAzg42c5A49aDp7sOQxGfTKn/PNCtr2MZYl3u2RrYkMBtbByPlAyDkYH59fSpfs BUr8rjOCTnIPQD8On/16zekrC+stu5//0/gwWTpyd3yjkjv1/Luactk2FO0gg7iMHAz6+hr/AKDp vVn/AD6RxFhUtFZArK2C2SM5YDkDp0/CphbAZ2plRxg54H+QPyrkma+3egrWyhjtO9Y3xvBLDg4/ UfzqaKJPk+UMP4scccjGK4ZL3Wbxr6astpGVZHZlQKnyjBG3n/62c+9WltyvRmKOnyIcErjIP4Dn v368VxVI76HZSxF+p//Ur/sCWME37W3wWMwPl6b4kufEDzvJlFGm6ZqGojjHBH2TPBGNvQ9R/MJ8 c9Wlv/iz8SLshj9p8b6lLuxvL4u5sfkAe/8ADzX9pfTQf/Chh4/3cN+eOP4u+ho3Lh6tNf8AP3E/ +k4I8XadiQxdeucBsj1yB69f0FSNdLGnDMyNxgtvUNznjH9eMV/BXKtj+407IZ5rtjEjFWIZVbnd 8wz9On4VcTAY/MSFUNguTj29u3NZNdzWL0ufqr/wTPtxaaX+2p47Yny/AP7G/irVIp+QI3v/ALPo 4+Y+o1IjrnkV+OXwfjWS/lnIXa8UrLx13yJjqOOCwBxzg+tfc8QK3AuUW/6f/wDpxP8AJo+ewLbz zHXXWm//ACVr9D//1f45IJtszAOGWWJgMoBsJz06Z6ehHNfvf/wT4lOu/wDBLD9p/SXZC3gL9rvw h4giXIXC6loviuyc+2T5QP8A+qv1r6PlRw8RsHHvJL72j8y8W4Rl4f46VtVFv8H/AF8zjUt8lnU7 SGIwWIyTwR0Prgnp+laMEJA2vFHgHqpxnIIY53ZwCDjOa/1GjBbH+ds6zX3GtFbqHQ4KyD5gQfM3 EZxkA45747LxVsRBWAKqQFwQAUCnIzk+nbnPSuylHU8XE1fd3JhDuTcoYjIONvyr3Oe/cflX2z+w HbNcftCQaSmZBrPwv8baGijlpvtXg/XbZcA+vm9PaufP1/xjuYW/581f/SGc2T1G+I8vXX21P/0t H//W+RJQ65UAIxVkXzE+6cgDA6E8/qPwqiFWATCqq8b1YMxJ47+2fav95sOlY/wfx9Rq9yJ7UDCk EMBxtzkZx0/P/wDVUZti7MFx13bnIBOOwz3/AMK9mkj5bEVZCi3YggIDt75yTnJ7fh+VetfAjQPC etfGv4Q6N48jtJfBWrfEvQtM8XR3942n2EumT6nbJfrPOrI0aGBpQ0ispUZIYYzXm8S1swwvC+Y4 rKL/AFuFCrKlaKk/aKnJwtFpqT5rWi07vSzPR4Up5bjeLsswedNfU6mIoRrc0nCPspVYqpeScXFc jd5Jppa3Vj9x/Gn/AAT1/YK8d+HNJ8WeB/jhaeBItP0W/stX0Sw8X6C9xNcWGuapDBPdLqOonbLq EaR2dtsljhH2SOV/9Y+flf8AaC/ZA/Zj+F/wY+PFn8OPGMXjj4n/AA78XeFte0XxHqfxI0K2eXwz qdjcG6Fvpyyx/aJBcOkcsCRNdxyi3CoI97Sfzlwj4t+KmbZ7DIM4y1U4U8TyVKyo1m3TWLhS5Y+4 qfwTT50v4fvWi05H9NcY+EnhHk3D1XiHJM2dapUwvPSouvQSjV+rTq3l77qX5qb/AHd7c/uJyTUT /9f7R+APwe/Y98e/spfBPwj8RdJ8JeGfi98X/ilr3hzWPi0vis6f4n8D6Voh/teOV4Jb77IlzfR2 r6Tax3VqIZWvg7SxtGDJT0n9mL9l3wH4w+Hfhy78Q+AfiXoenft43Hw58Q+KNY8VxWj+JfA0vh/Q 7yyluVgvUijtPMl1Am5jVf3quPOxtiX/AFszbjDxQyvE53lVL204Tniq2HqqlzSp01LFYenh4/u3 G0Z0KVaDknKXtl70oySP8msi4R8I82oZHmmLdGEoU8JRxNKVdRjUqP6jXq4iX7xT5pwxNejNJ8kf YyfLGUWe3fCf9g39gqDx18NvE/i744aZfaO17eeJPF3g7xD4x8NReANVSG/vbX/hHbWZdSTVkmtU jjnllkieJ4YmKziR0Rvzy/Zv+E3wB8W/tB/GX4c/FD7HFoaeEfGVh8LpW8dWfhXw7BrVrHdLoxk1 S4YwNjarQvJL5TOiGTzUJVvSyPxH8T86ynPswxeAeHqYWlQdCKo1ZKo/rFVVpqMoRnOXsVGMoQck pRvC3Mjys98N/CbI854fy3C5lDEUsXUxCxEniKcXT/2al7CDlCbhTj7ZylCc1FuM1GpzcrSg/aw/ Zs+B3wbj+Gi/Cj4rp42Piq5vLXXpLjxDpPiGG2gt4dLe21aL7AM29vcve3qLb3GZl+wMSTmvvD4r /sZfsUJ8JbSSx+N3w6s/iT8K/g0tvr1x8NPG2mSaH461e20vxHqEer3cV3LJNctqFxp+kWSQWXlS RtqSsykfKtZ34meJNHJOHs2wWTVPrdapiHiKKpVHTUKcqlGEZKzq05ybpzhzWjeXM+aMWksh8MfC ivnfE+TZhn1H6pQhQWErutTVRznTjWnKOqo1IK04T5bytDljySkm/Mfjz+yr+xs3hL9oDx/4P+Km heFPFHgfT/Dsfwy+H3h3xbpmq+H/ABZv8G+HrzUZFiZ5bp5W1F9Xhk8ubAm5CKq7CfsKfCn9jfxh 8MvCGt/GRvAh8aaT8edRtfiBb+N/H9toL3XhRvBmoGyFrp0kkZkjGoywsrxZk8+3VmYovlVyY/jj xTxnhvjMfHBVKOYUqns4OFCo6lSnLDy5anI1dS9s4NzjFRj/ACpXR0YHgXwdwHirgsseY0a+V1aK qz58RTVKlVWJjz0+dOziqCmownJzf87lys//0Poz9sf9k39j74M/DaLxL8D/AI4az8TvF03iOzAi HibwvqXhyGzvHv3azNrbzDUjdWqW9qZJxCbZvtC4Kltie5+CvhJ+wt8U/hB8Cvhr46j8LfD/AOKE Pwi0z4i+J/iT4L+IWi+G59dmvNfn0i40rUZLySe3W7tdNNvqs8EqJMfs+xAHd1r/AFpzXjvxdxfB WX8TYbLpUs0p4uftMNCjXcJ4eNKUbVYyXtG4ynGd4SUZOm3FuyR/kpk/APgpg+PMz4Uxmawq5RUw dP2WLniKCqQxMqilzUpRl7LllGnKDVSDnBVIqSSbbhf9lj9hj4bre6lofxd8K/FP+2Pgp41lgtPF /jPRZLS5v7Xw5o91oWr6dBbmGaxuJNRvLu3isbpnnxZtxgNX4gyWaqG2KME8AnlQPQ19/wCFXEfG nFGW4nMuNcJLC4i8VGk6c6cYpcyfKqnvO7XvXlJ3XSLil+a+MPDvAXCeY4TK+AcdHGUEpudZVIVZ Sb5GlJ07QVk/d5YxVn1lzMgEBVigVeflLEE47jH5flUsduPug7M/dbbuOM9cf0r9Nkrux+RRq8qu SrCqttO3joRjHPOPzyatrHtTBdCFIYL0dQeoHbPf8fWsJfCzaFa2p//Rl/YkU2fxvu9cTC/8Ij8H viF4oV2P3GtPA+vuhJHOAccj09a/lI+IV2Lrxv4vmDZafxPfS7WJbf8A6VKw2j8cflX9nfTSknm+ FjH+WivnH6y/ymvvP4r+hUn/AKrYhy61K0lvtL2EfTem/uPO2b55M7QVzgg9Mn9MYHFVVkYbs4B3 cOThcAYBP19P9qv4Rsf3J5DElb5m37l7kc9eScHp0z+ArRivS0WE2N/fBBVlAwMkep579amUU0XB 20P1m/YemGh/sP8A/BU/xjuZXX9nbRPBkchGxlbVPGOhl1Bz1MdtJ6cA1+QHwcXyoXl3KR9jjUAq RnLDcT6fdOea+v4gc48I5dQn0lU+6UKEl997ni4KUJ5tXnB3vCN/VVa8fw5T/9L+NlUlNzCq48r7 qEuSw43cZB9+hHI75r91P+CV92+p/sc/8FCvCiyBhYa/4L8ebN+3iz1e104E9+DrD/mB/FX6V4G1 XQ8Q8umutWkv/AqsI/qfnHipTVXgLMoPpSqv/wABpzl+hoy2qszsESHgKU4Tt09ecHt1NX4LYQFx GXRpIj5hRfL3DJ+XHcdDnODgYzX+rsI6WR/mpVqvYtQwwg4ODKPl+7hVHQYPbOWB5/gq8qFcZK7R 82AoygAOARjHpnv/ADHXTjqePiatk0SLGRnzXC9FwQcqM5BGD9f1r7j/AOCc0St+2N8G7MjEeq6z c6Aw2kK/2uwurXafr5h6dce1YZ/H/jG8ev8ApzV/9IZx5NiOXiXL/wDr9S/9LR//0/l6aItIzuQH 6LCE+eIk56duvX1qsttuD5ijK483G35gc4H06n/PT/ejDLoz/ArMa+6D7Pu2AhTxtBZcYzx9Oh4+ maRbI4IBDFc8AjbwcD/PuK9il0PlMTiCT7Ko+VVYMASM9OAen4f59ZIrUqNuCQBg5AO0n0/IflXV B2gebVxO5KLckcHbuwMgYJ6en1NOMBC7iowUH3jgD8D9K6EzkjifM//U+XjaueuBtyoGeO9MktG3 ln+8Ou0YBJx1Br/oXjsj/m9qYpcz16sU2jcHnK4GSSD3PNKtrJk44x975S3HvSi7IiWJu3r/AFct RWjYyVI+YDgdT71YSz+U9VIGevuef/1UpSWw/rW2v9XGtaMejY6hQxzgjjj0/wDr1GtkyvgjBI4z 0bPJ/wA+9ZSlqDxNoNpn/9X5qktnYAHB5woxhQAeeKctosZwxVQRgEDpycfjX/QNJ2P+cD617u/U ga3yAAwB2glsbt3Xv+FQG0cEKqk9AVBwMc54/OsHszopYjUqvb9wnLNty3yq2B7fQfnSrDIDuU5Z U2AscK2e36Vzy+J/11OtYjRAIRvPmMAAnUuWZeDg/h/KpFXAGFLHIy27Ctx/kfhXO9mbwr7H/9Y/ ZVvY9K1z416qSESy/Zc+IsTMF3iM3vhu70+P5sYHz3iDn1r+STxBeedrmsXIkQ+fqk87SNtGA0rE DPb730/p/Xv0yJ34how71Gv/AAHD0H/7kP4z+hek+DJST15E/wDwLE4lX/8AKf4HJvNsJBKEMhOM hh1yT6cccds1Ukm3bVYgDgjBG08DqfoM/gK/iXlsmf255EJmCgL5iFASDjHzHtwenB6j17VbST7o UHpt2Ow6nPOeo6frUDWh+rvwYvW8Lf8ABJP9u3W42w/i74keC/ApkLsC6LFrF/tLeoexj4P92vyu +FKvDZyynBIjjwzKGVgd3VucdetfZ8W2hw7lVPRN03Ky8+WCfz5PwPm8llKeaY6T2UlFfJylb/yc /9f+MtWY3ECrleSHLkgMcj5eM9fmA/Wv22/4I93M9z4K/wCCiPguEMbnU/2fdK8QLAyiQFLDxPoO oXDgH+7Fp7np+IzX3XhBU9lx1l0+1ai//Aa0H+h8L4h0vbcGZnDvQrr76FRHqDx7JFCJjzGKFhhm 5OeD15549DjrxU8SD50aRkIbOwHauM5VcZ4Gc8devTiv9c4LS5/ltWqNFtI3Cuj7RtO0OVfJyQMA dj3PHQcGrghLElVfGDICgKqp5HHPb1P69K66StY8fFVd0TrbvKJMLgiPKYydgJ5yeOvTvjJ9K+zf +Cf10bD9s79my52kJL8V9Hs5MgKcS3SQkZ9w4rDPFzcO4+P/AE5q/wDpEjz8pq8vEeAl2r0v/S4n /9Cb4QeBfh/qn7TOn+CvikbSLwfD4s1PS9St9R1k+G9PvLm1W++wWN1fqytbw3V3HawPKskZRLhm Dx43DUv/AIyfDOy8NWXhG5/Zo+Hdt4g0TRtS8O6n4lttZv5rvULuSx1nT4r0qZHUtby6hZ3Iwz7p tGtzvw8gb/abEYbibOOI54TC42phcHToYepBwpxcalSbxcK0HNq75IrDy5VJct02nzJr/DqjmPCu S8KU8VjMBSxWPq18TTlGdSalSp01gZ0ZqEZWXNJ4mHM43leSUvcsfove/sp/sG/ET4f+EF8LeNof hz46ih8IS+L7mL4h2WoRaqdZ0Tw++pS2MN7dlI4rJ7/Uby5jdfMWTTp4kdVZY4/Ov+GGv2QbXTLX Wf8Ahpy+8QiTRIbo+HPDeoeFv7dvp7hdIcGJr7ULW2jih+3XZl8+ZG22hIOQy1+RZL4p+NeAoUsB meRvEV+e06kqNemoQcYyjOap02ratSUYt3hOyd4o/YuIvCHwCzLFYjMcn4kjhcOoOUKKr4eo5zjN wdOnKrWTu7Jx55pWnC8laR1nhj9mf9mb9pjwv8NNK8G+G/Dfwm8ZyWFv4n8Tt4G8YXfiXV5tLk1r xTp18t/Fe6jcwQtZ2WlaBfEptc/2lK20phVwPid+wp+yp8JoPF1l4i+OHiufxjpPhiw1jR/BVnqP haz1yX+0NKn1OG9uhf31pGLZSbOBoo2a4bJZI28yMD0sB4q+JWXcSw4DWEWOxEKso1K9SnOE1R9t OKrSp0KaSiqfJZxp/aTfVng5v4PeFeY8IVvEiWO/s/DVKKlSw9OtTqQddYeE3QhUxFWUpTlVc1aV W6UWo3dj85L/AFDwX8VvjRo95qGiaH8IPA/iXxJpOjanZ+GotmleEbBRa2N1drngv5cb3MjlQGle Q7QDivvzxF+zn+yZcfA/xboHg34l+HpvjFpeoReKPBqr4msPEniPXrm5VrGHwoGtykd0ly0UFxFL Cu63lvcSEqGr9N4rzjjXhOrkeU5XSqYrC01S+tYlxk5ONOUKdSVSSvFc0HKpLS91zX5Yyv8AkvBm T8BcaYTiPPM2rUsJjqsq31LCKcIxUqkZ1aUKMJcsnyzUaMLO1nyNc0otf//R/RDxz+yX+x94f0D4 Yr468a6r8O/ijqHw48P3HjzwNF4k0fwzF4V1JtB0aV7fUre/c3gn1C4uLpnuoUaCBg5kSJUIPxv8 WfBHwE0r4FW8vgabSLb4o+H/AI03ul+I7eb4i23jLWtS0O60TSZrH7K1vbxW1xbQ3X9pRmeDhHhf cz+ZGE/2M4M418Ts+xuF+v4ZLA+3S9rChP8Ae4dqrHmc5NQtzexnzUotcst7Rmn/AIlce8CeDvDe W4+eW47mzH6tNxo1MRT/AHOJjPDy5Y04KVS7puvDkryvzRd43lBr6k+H3wR/YT+Jfwv/AGfNQ+JX xj8P/C7xtpvg+PTvibpvhzVrK0ufEZn1PxQ6XFwxjdIL+0toNKllebPmxNFDtEzx7vjr9oH4X/BL wL4Y+G918LvGo8U+IdUS7tfG0H/CW6f4iW3mtorMpc28NpFiG3lkmuEUXEglLW8gERjWO4uPa4a4 q8TMTxlLJM5ytwy1VKqVd053lC9aUGp8/JFJKnDWL5tWmrxT+a4v4P8ACTCcB/6wZBnSq5q6VB/V 1Vp2jO1CFWLp8ntJSbdWpdSio6Jp8smvrSD9nf8A4J9T+CrzWR8fNWsvENvokE8+lSeLrB3smk8M LqtxeRQ/YA920OpzRaYNPg/fSGKRg3Dbfmb4LfDn9nnXPhF8T/F/xP8AHF3p/wARPDN9bXHgjwVb eIbXQP8AhIraAxTXcbpLbyPM1zGbqKJrcgwvbjcr+bEjRlHFfitisoxdfM8njDFU8TQp04qE0nQn UUa1azqtzcKd5JRkrO11KzvfEHBvgtgeIMHhcmz+dTAzwmJq1JucJSWJp0pSoULxopQVSrywblGX Mr2cXJW+wbz4dfsI+ItS+JPhyLxd8PNCtNT/AGkPDWvaRrek+P7i0vNJ8A31tqSXdtpN1c6T9nWa 1a6huLiz+YL5cKPcSPAqyZH7P1r+xTa32nv4kXw7beGpvjnq2j3mlfFXVdG8Ra/H4fX4eaxFBctf JZIRA+vtZmGZFCKxt2KAo7t8fUx3jPW4fzDC1aVRVVRi6b9m41nVqYaTioTp1pQ5adSKVS6UvaT1 dkz7angfo+4fijLMXTxFN4eVZqtH2qnh40qWKhGbnTqUY1FKrTnJ07ScPZU9Fex//9L9BND+FX/B OXwT4y8JX9v8V7b4jaVqGqeI/DmrReMNaez8O6eG8O61FompXNtFpxmVP7WhtEEh3xoJYZmVoyN/ xn+0Z4C/Zw8KeD/hhc/BLxrdeLfEWpabGvjqabxR/a0UlyNM0ua5kg03+y7eSwhW9n1C3jW5uJZp Ba7vKRdryf7J8J8Q+K+Y8RYWPEmXewwlSH77937tOcYVNIP2za552vKUZqyjFO8rr/DTjvhnwTyr hbGz4Qzj6zjaVT9xep71WnOdNOVSPsFF+zhdRjGcHzSnJq0Hzb/wbh/Zy+MPiC8u/wBo/X7P4T6Z 4f8ADnh3wf4Si8DRS6bHrJ0/T5rKSS+jFrdvmZLSKa5vySwuJkHlMszNB9Dr8Gf+CaF74t8UaHef GTxN4X0G3eFfC/iKPxhJ4v8AtKiTU973KR6FCA0kdrpzmCMt5X9oYMzOrRp5nFGceMWSZ1/ZXCmB +s5fRjBRqVIc86zVOLfPU9vDVzvFv2abbb13PV4KyXwH4gyBZ1xvmbwmZYidRzpUZ8lOhzVZqHs6 X1ep7qhyyS9q0kkutir4g/Z2/YZ0f4ea38SLD4ma2Ibj4qad4Y+HEV94pg1qHVoYz4HuNWivIU0w ForaLVPFatduqRt/ZUBVJCxR/kX4n/F3QvC3xS8Uad8MPDnw51PwH4c+Kvi/W/BmrHwtFIviWw16 MabAbiIeXEsMFpb27W0EEUCQyFnCbyxp8KVeNePLLjOlPC06ca9N+xk6SdR06VGSl+8m24SnXcHZ JSimm0rF8bQ8PfDOz4AxEMbXqSwtRfWIqrakqlTERlH93TSjUjDDqpG7bhNxkk3zGz8OtU+G+r/H L4b/ABs+N2rfDdPB3j74gaxrnxT+G+l6AZbDQNFtsC4to9PgWTyGv0e6gsY12TRvDFL5kYZJh8e6 i9m+p6i+nxNbac1/I9jbyDfNDAWJiUnJyyqUGcnp1r9AySOarO8Qq1OpDBU6NKlTVSSfNOlWxMJV Ek27zpqlJyaTlGUN7afmOf18jXD2E9hWpVMxqV61aq6UWuSnWoYScKUrpL93VdaCjFyUZRnqr2P/ 08b4KyGy+Hv7XeuiRojoX7K2q33mL1XzvEnhPTz1HQreOD2x1r+RnULmMz3TtJwZDITGpxu3HdjH v74Oa/rn6YtnxHRd/wDl/W/DC4D/ADP4x+hWv+MJlL/pzS/9S8wMiaUEJlgpCkgAFs/Lkj8Mf5FZ pmaR23yMvG0DPl52gqOAeDwAeOa/i63Q/tlN3Vx6MoXcjjpt8sA7lOeO2ee/frSrcOSSi7SrFSGG d/T7vPUcdcY/nDgrWRqtT9adU3eG/wDgiT4ru1IjPxE/azsbZCnWQaVpsu4HvwuqjPUDf+X5deAW eDTZCih4pZ1j3BPlyqr8vsSCeeuF6ivt+O6Kp5XkSX2sHGX/AJcYiP8A7afKcMzbx2bX6Ym3/lCh L9T/1P4xZQizJI7RHy5Q6xKhYvhxjPPXAAz65x6V+0H/AARK1qVf2gf2pPCiRx3MnjD9hf4imztV cfaby50zw9qV7bxqBli26FcYGRgcEivrvC6pGnxbh6kvsqcv/AIuf/tp8jxk3/q5ioRWsk4f+Bpw /wDbj3ecsHKrJCGEhLsJNwbJG0KcjP3v5dcVIjli2HdAhVRv+YMQQD8owVHsfQ81/sDQScVc/wAn MTUtKxfWOV0hUzoUQFkjRS2SqruXJbjOT6ZHb1tQI7bVBAZEIjXGCQOOucZy3XPr17dtNWPExNTX ctojxxgLIj4XySZOMDIBCEYKjk8HsD7mvpH9kG+OkftU/s9X+9U+xfGLw87vkEqBqlsp5DFf/wBf HrWWbx/4Q8ZH/p1U/wDSGcGWVP8AhfwOv/L6l/6XE//V5j4+2JsPjp8ZLARpF9h+KfiG2Qqg3BY9 XvUBHJPGMY7Y6CvJzEHIMaFXbC+YCOeg6474J/xr/eLL2nh4Nbcq/JH/AD0ZvUccRUT7v82OCP8A cUleDzsK5PIyOnTP+eaf5cgycAYOMleOPY+v9K9ulb3bf1sfGYqrvqbGmaxrmlR6hBpOs6rpUGp2 /wBh1S30++l05NShzzFcIhUOh+b5GBHJpt5e6nq85u9SvrzUblkEJu9Qu3vZ2WMBVXzHOcKOApOB wMVVHCYSnWli4UoqrLeSilJ7LWVrvSMVq9orsjjr5njKuHjgatabow+GDk+Vat6RvZayk9FvJ92V khAztwdqfMFBC845P6cevSpgCOg2/Nuyp4x04PX0rv5keZKp5n//1vG5DLdTPNJI8zH947yMWdvT rz3HWongO5cJ8vTBO7GPbt6/jX/Qgf8AMi57EwhGNsjlODjC7yTg4/oD6Z/OMxZyAB8vOOmfYfl2 FS5JCU3csJAzMB1wQMMcDg8YzxxThDg85B3YUjOf15ob0uJVLXG+UN+CCQMGTaNoGDxj8j+dRlAR t5GTwF6d+uKybuxKpof/1/GGTOCSzEDjjOT+P+eKZ5I3NuDAnAGGB5PXj3xj/Gv+gOckz/mVhN8x E0Z5J4U8kEd+B3/EYqvJGM4XgKeMkDJ7/wCeK55zVtDppyuyu4yAg4I7KQoAA9/p/wDWqvKDJhec DBLg5J68jP1/Sudy10OyL2KoVsFWyHUbNqsFxyR6fQVCVJHX5VzjI2u5OAPl57H8cVnKXc6qbaaR /9DjvDM0+j/so/8ABQHxSuFhsv2Z/wDhH2Ylco954n0G6j68cLpcpx1O04r+Rd5RKW255Zy8iyBY 2UgBeMEjaQTnPOcDb1P9Z/TBnzcVUaT/AOftaX34fAr84s/jj6FUF/xDv2n/AE7hH7sTjXr8pIxp 5zEzfIZOgclC23j1Gef5Y71UE+ejhdpC+X/G4HpnuOuenXiv41asf2fsMVz8wieIMGLlguVYAcDP r14z1OKs20rDaC2BjIY8ducLzjsPwpGsXsj9gv2oHHhj/gjB+xnoY8uKX4h/tK+M/FUqY+WaG0st Ds0PGP44nG7BHy9O9flr4V/cWCR9FklZgmCBjjHJOOxA47Hr1P2/H7/2bJqF78uCpr/wKpWn3f8A MfLcLxftcyrNW58TN/8AgNOlC/8A5J/W5//R/jJkGQd1wC7ZUxk+Yj8gjkjgjHQHp3xX6+f8ELb2 G0/4KT/DDSL5Vay8b/DPxr4CvFdiBP8A2p4d1CzWNgc7tz3CrjnlhX0Hh9V9lxHFp6+yrr/yjNf5 HzXEVH2+V+yte9Sl/wCnY/pufUl8jRXHlFDF5M2ydBEjYkX5X3Dg8MGGGDY9qnii8ouu5kLS7nik QqqF1G457cj5QAcD+7X+yOH+A/yGxkrTafc0Ej83DLEijzMu6kK6YDNwQeB83I6c9wMG5BG7vC8e I9q7G+X92o2HgnuBuA4PUj8fQpx2R4WKqa2LLR4jMuELKjMipnBYHJ2gg5zlsZPb2GfVvgheDRPj B8L9Rk4/s3x1pl6Cclh5V5CdwY8noD8x7k80sxpueUYqMd3Tmvnys8/L60YZ5g5zeiq07/KaP//S 9g+LvhX4ezft3/E/w38VfEGpeD/h3c/H3WIvGPiDSNOOrajpFlPqs0kksUPJ6OmWAYqGZhHIVCN+ ompfs8fsAa38GdDs7xfgz4B8QjVtbude8ReFvj6us6/bWljqWsLokVjNPeTtcTX9tFpnmG4sEiSG 4lkHlzLFAf8AVXxG4i8TMqq5HW4MoVZ4T2cKjVKk63tqnLK9KvZc1OmrUldSjzqrValzUYn+QPhh wv4P5zgM9w3iBiqNLHOrOlF1q/sHQpKUGq2H5mo1ajvWump+zdKjGUOSvK/mUf7M/wDwTjvv+EY0 WP4mxxaf4U1zxdpvijxHp3xW0iPxd8QJbeS2l8OxQ2t2IrOOOaEzBJ0eGFTCUkdmkVl87174Qf8A BOTwp4y+Hfh7TfGPiDxLpeu6Xfal8RPEXibx1Y3Gh+FdLW3vUd7KXS2Mp8QW81tazWlgUu7K5N8U kcKgY45Jxr4+5hjamBxGWxpQ5K81OeGqxk5JTnTpQk70lvCEOe8pclp2cud83FHAH0Zsry6jmOCz epWqueGpunDE0ZQUZOnGtVnFJV9FGpOfIlGLqLkvGPJH5t/Y/l+AemfEHxy/xMPg248Pm40WHw3c fE/TbaS0l0c+KNNXXyIJfMgjvW0Y3rKULTI4YW8nmbWPb/t53n7N+oWvwVf9nr/hV8fl+HJR8Q4v AelrperHWG0nw2k5uvLjWFrQtDL9nCfN9p/tUkYkVm/QHT8Qn400akfrH9h2lz2l/s/+6e7o9/3/ ADXsr8/K3oj8zU/C/wD4l8r05fVf9Zbx5Lx/2m311c2q2fsFG3M7ez50tWfniIFydowW7EY244z7 cDt3xTTD1yM5yOvzHOc8f/W7V+8n8zyhfY//0/KBGS/UhckcNhcc9O/H+elSNH07k4Bx0wf8eK/6 Couz1P8AmQcGPMYB656nkY6/nzxzTfJXLEAgbsKxJYjHTp0/z60nqOMHfYmWHYQF5OBg/eJHODz7 8fhThHuYLlQCuOOcEdMAf0/KkclSThNxHMihnyoZgduVwoIHGccc85+tVHQBhn5UJy2CcnHTntn/ ADmk3ZExl0Z//9TygxbSG2/ID0Ix684/z17UkirgHAVRgtnkfWv9/wB+Z/zFxm+a7IxGo3MuTlAu GXZt7dPwP5/nGYWwo2lR0JwMNjvnr/h71hNJRtc6oTdyrJCpPYHkICo5PXHvgD9KqtGYydi/goCq eee1c53Rl0ZVKMqOUQ84YkA4xg5/kKqeQ8ZTcSGCn+HJXHQn15/pUuNzphOz1P/V5vxaP7I/4Jgf 8FHNcMcZu7m38AeFLbzBtYi+u/EcrJnjAP2IZH+wM1/HpK+ZMIx5kCKcAFAOvT+vTB54r+qPpe1V PjmjCPRTfXe1OH/th/H/ANCunOl4X809rxS9G5z/APbyjNIxLEksWIRsck9hzxweaoEsu/aMsfmy flAznqB36j3xX8jNH9kDg2Oke1slpSSNoXkDIPcjI46Yqe1LO6Rg7vMmwf3pXYQCMjJA/M9+hxWa gVF2P1+/4KOTNoH7C3/BKj4fBJYTP8K9b+Il1buxVxJq3iDVYdzL2Oyyjzyeg5NfmloMbpYxERsW 2nChCpU5JyRu7YHHbNfW+IMZUs1pYKTv7GhQh91KMn+MmfPcKz9tln1q1vaVKsvOzqStf5JH/9b+ MyUCQSeW0YzH5anBLt0JJPUbdoI/lX6G/wDBKrXE8O/8FJv2Kb+WUrb3fxs0bTrtkYP+4mvLU3AP OQpRHyB1FenwVzPibB04/amo/KTUX+Z4mbNRyqtUf2Vzf+A6/mj9Q/HenPpfjXxZpjRtu03xRfWU SIMH/R7qSPHPPG0Djt0Nc/GHkLR7WLhhn5WG4nABIPfIHGRgH8v9l8pqOvl+HrfzQi/vimf4+53H 2GY16FvhnJfdJo0LWFlGPMw0gIKJl/mxglxnOCGXBOBw3PUC5FEilAwjCMVV3EbMqZxgkjnggEYB 4Pfivagup8piZ6lmOBhhXwZMiEkPypB4PJwB27Y5+tdR4auP7O8R6DfA4+yanDcRrEMNH5coORjj r+vtXX7P2lGVPurfejwK1b2NaNb+Vp/dqf/X9W+N3jH4D/GP4u/EH4qf8JD8TNDXx34puvEsmix+ CdPvTpn2mTe0fnHU18zaxb5sLn0FeYppfwJG0t4w+LO5RgGP4f6Spx/s51fqOv8Ann/bjKocYYDL sPgfq2Gk6cIwv7eqr8sVG9vq2l7bXdu7P8B87lwbmGY4jH/WsVBVJymo/VqTspScrX+t62va+ly8 mm/s9JgHxd8ZASp3MPAOixoCe+P7YycH+Zpf7P8A2eV+T/hJ/jE52AMT4H0Vd2Ov/MW/SvUjW46+ zh8Iv+41Z/8AuBHzlfC8ALSWKxj/AO5eiv8A3Zf5jjZ/s8gbf7f+L7AAct4X0WEPyRyP7Rb0p6D9 naFcPL8X7xwQRtGiaWM55H3pcfXt71qpeIMpWjHBwXrXn+Fofmcvs/DWnrKWOm/KOHp/jzVPyJo9 U/ZshAZ/DHxkvj90BPiNoWlozY4/5g02P17VKPEv7Mi4Q/DP4yTksMn/AIXzoVqMHjp/wiT9/fjN bQw3iBO/PjcHD0wtef4/XKf5GP1nw2p2j/Z2On5/XKFP8PqFX8/8z//Q61PE/wCy2pVW+FPxqJUf N/xkX4fCjqOP+KM568Zok8WfstIBn4T/ABmCpnC/8NG6CUTOAcf8UaPSv92fqXHv/Qywf/hDW/8A ngf86v1zw0/6FOO/8OOH/wDnWIfF/wCy4GUD4U/GA4ADb/2itFCEZ6H/AIpACov+Ey/ZiXkfCn4q 7V/v/tDaMwYH+E48KD8cego+o8ev/mZ4T/whrf8AzexfXPDTplOO/wDDjh//AJ1nM6/8Z/2QPCgt j4h8HeIfDxuwwtD4k/aO0myW8KFVfYD4fi3Bd6ZCnjcPauWf9qL9iKHOy18MlVB3Le/tK6dKCRyC dljGMj09/wAa+SzTPMTk+Klg874wwOHrLeEqVKlJXV17tXFSkrrVXvdan1OX8LYfO8NHH8OcAZnj KEl7tWNetVhLl912lRwMIu0k4uz0aa0eizZ/2uP2K4Nm2D4VAbgH+2/tBmVmxng7JEGe+Rjp0qp/ w2T+xdH8i2HwAlII4ufjrqLZ9yE1RB1Hb1ryZcX5PJ+/x7g1/heCX5zkenHw/wCIF8PhbmD9f7Qf 5Uon/9HzZ/20/wBjoBBFo37ND4kOWm+M3iCdW6ZHya+vr2oT9tX9kLawbQf2WHKltrv8X/E7JwQB wPEwz0ORn06V/sdPi7h+1peIGH/8Dy//AORZ/gtHgHixv3PCzF/OOafpJDW/ba/ZGI3ReHf2T87B KW/4W34skVyRyQB4pUjP44yOe9If23P2Rchm8L/smiJSVb/i7Pi5SDjA5/4Sr17emee9Zf64cLR/ i+IFF+lTLV+dJm3/ABD7jhpKj4W4hetPNX+VaJX/AOG3f2R/m3eFv2SjnlA/xT8Xn5ufm/5Gz0BG PUYpv/Dbn7I6HdJ4Q/ZKdQhclPin4xDMBwAf+KtPJz0xn2qJcZcG9eP6a/7jZZ/8oN4+HviC/wDm 2FX/AME5v/8ANJUP7b/7JDNx4N/ZGeMDdt/4Wj4zZkT8PFw6nPOPwqBv23P2SFJY+Bv2SDGAFOfi h41GSAeh/wCEt9x0z061zz414KitfECH/g7LP/mc7aXh34htpLwvqf8AgnN//ms//9L4h/bB/b3+ Eviv9jf4z/An4YQfs+eFLH4h61oXijVrT4f+KNb1/wAVa3d6LNcw2UatqOt3yrEkeq3zukUQYnYd 3ynP80k85M+CQ8jfO0kZJMg4yCx75BHPXFf0T9JrMMgx/GODlw/mscwh7ByqVoypT/eSrVLxboxh TTUVHRRWjT6n8t/RNy7ibLvD/F0eKMleV1FieWlQcK0P3MaFFRklXnUqtOfOryk9U0tjKmkc/MzS EHAOecYAIJPfj9KqySJ98HcM4AYb4uoyAQOOmPxHtX80zSWx/VUXoRxu7870XAwME/MFBJHoOOcd 8kelaFsVaaONWLAttzjJYkkfKSOM5PB4/GosUfrx/wAFfGbRbv8AYJ+HCkJF4I/ZA8ObYhzHAdQS XVuR16aln8Otfm3ojBYIVZpgDGh2SIR0XO0jPbGT6cc9M/XeJ2nGOLj29mvkqVNHy3A91wxhL72n /wClyP/T/jSdQJFYqFkYllYjfNHnbnGfXnp2x9K+if2VvEM/hD9qD9nHxDaFbebTvjDo9vBMqgi2 e5nNusjH2ZwT9B6CvT4IajxZlzlt7an/AOlxPn88bWQ4tx39nP8A9Jkf0P8A7U/h2Hwz+0n8etAt VPkaR8Z/EdhGqKJMQx61drEOnyhkWMrj1FeGA75GjZVCxsqE5EUj7cDDKO+RuJ9WORkkn/YvhVuX D2Ak/wDnzSf/AJJE/wAhuMf3fEmYU10r1V905F+FdgAKlmyScjHAG0+44U8c/pVtEBEbFyVUnO3g 4Hr8xyfQc9j6V9VTjdJHwWIqa6E8aBSzk5LEKVPzBcnnIPQjJ/yatqpUsFcyGJOGjJVDg5PvjgHt 0B9a7YR91nhYmd5JM//U+OFnu3PEswRRtLtIzEA45P6dfQ+tP3TPlPOlznnMzbifb07fnX+9dM/5 38U1zMnV3XqzYwNuGOCePy/yacFc5IaTPT75O4Z5FdkNkeHWeo/95hhubDE5H3gSM5P4E/qKhIkA +YytjCgkllwMjjn0/wA8V0nnzS5OUCMjqeMHOMZGf/r0IgXhcA4Azncfxq1Oysc3s2f/1fkVV+YK SPm+YAt8vt+nt3pjRuTg5wBj73yjjI5r/oF50f8ANT7IRo2TG1iGLEbVP3uh65700qc8bhnj+6T0 4o5la7GqR+Xn/BSNSsfwoKR7zu1YMwOCn/Hhn161+XPmJ5eAZCTyEPBOQRyc5zkdD69RX+UH0mZ2 8ac4t/1D/wDqLQP9rPolQS+j/kCf/UV/6mYguCRfLZeOgOQcSZyfqO/8qh37m2s7hguVIUk/Tt79 K/AJStqz+kOVdj//1v4v4piSc4fOBt6L3HT24+tTibygyNOY2I8sxqNjxnncrdMemB619DKV9WeN ZdhUl8sYIdF24baMrkYBOPXjOOMUrzEKqBsYAJVsKoPQtjr/AAjp6dKwlJvQdktiNfnR9wYxZCo+ TnfggD1weR+dRnzUdQ+TG6n93jbkDHJH9SO/WsZS6I1jFdhkcm1tu5huxzkgMOBz/KmebkBXMi/L uyoADHGQBjof14rmm76I1itT/9f+LOR/3pj4ABxIrdd2c5X8uuaa8wDH8wJEwMEc++Ov5UVVzbGd PsVC4kUo52EEE84PU4JHpgGqRfBYLhlPOQfl79vYYP8A+quZrRm0XbRgQiqAsjb8+XIsiqsa44Qq eSc/N2GNo69us8HWcmpeKPDmnqfM+269aWSq2GLF7iKPGOnOTz7/AIVpgMLPHY6jgqbtKpOMVfa8 ml+pljsVDA4GtjZ6xpwlJ27RTen3H6sf8Fsmm079tfw34CmlbPw4/Z28C+Epk6eXNZ+HdPt5gQT8 hzASR+GO9fnhYEOlqoDuoVW8yQbVbPynbyR1yM556Y4r3PEScqvFmKnLr7P/ANNQPJ4TgqOQ0Kfb n/8AS5H/0P41plZZJASu8zbdgACgc7hyeoO0deR+Y6PwZq8mheLvAXiOOUQyaB8StE1hJzlvLNvq du+RntknP4dMUZDWlh83w1eD1jOL+5r/ACPIxtONfA1aE9pRafzTP6zP299HTRf2qPifNGU8nxOd L8eq6n93K3iHQtO1t3B/2nvn4z/F3r5EhDjep3AfLjIwik4Xg4zjufp0HNf7N8IPm4ay9/8ATil/ 6bif498dXhxZmkO2Irf+nJGnaxptj3fNg+WBzvJbAbGPUAc/XnqKvKvCLGCNwCkkruwAfyPHf0+t fY00fnOIldllFKlkVixb5A3QMDx6Z/8A11YESxvtB344yEIJ5x3Ax/8AXrtpLSx4eKdtT//R+P0Q h+ihA20BCQ2cjIx35qYRqrbeucZdWI79P0x9cV/vVSP+d7ErUlSMEEE7gSRnAwDzgfz605UAIyCF APIUgKfpn612Q+FHkVY3ZOI/vHAyFAUL754wKUxEAYAGeoP3j0HP1rpWqOKUOxG0WB8uT3AI6/56 UxoguCMg4GQuDjr9fWmRyeR//9L5NjHOWByx5BPqP8afKuOpBC+2ACPXt6/jX/QAf83CpvsIVJUI FzuAPDZPQ+9VyNrgjO7PY4HA/wA/nQUqbW5+W3/BSR44x8Kd4Lsq6uSgXA5+wjr9fz/WvyvaUBNp XdIAMF8Hyxx26evr17V/lB9Jj/k9Ocf9y/8A6i0D/aL6KC5fAPIF/wBhP/qXiBySYjDIzMd53Z4U 5+7j6ZOR9KRCDlQuwIOdoOeuM8nnJHQV+BT7H9Fn/9P+LJnXEfzFl5LAqOMY69+P6U83KOgh8v5Y m3RuqFXYnHBB9MHgevOeK96TsjxyZZEKDcjMYzucFwocHgAL14IbOM9QMAU1pIzkIApYkIDkKeuS R9P51iBGJFXczJvDINmSSSSemRxwR3/wpWfcBIhCnftZGQ7RkHJA/HH51zm8VZFaVigw6MDkkhmy OhGR+Q/Kq5YrgAbTH8oJb5lHOR/n0rnKjuj/1P4oHYu52NnkHdtDIM9sfj/nnIzk/LwjLhsl/k4A UAfr1ptWdjGL5WQhmON5VFyQfNVucdv06Z71DMABGwIztGNqkqRn09+nH51lNa3Nk09hgyBjeVCY IVs8HgEg/TH0x2r3j9mzw/8A8JZ8d/g54XjDyz+IfiVomjRIi7lDXGoQRKwHfknOOlevwvGK4my9 z29vS/8AS43PG4lTlw1mFOO7oVUvnCR9y/8ABZ3xCniT/gqr+1zMhH2Tw78Q5fB9oqN5ipHph+xh BjoAE6e9fD2lw8xmT5sEKTJkuMAdQOucY+tcvGdRz4ixbf2Zcv8A4AuX9Dbh5JZTQcdpR5v/AAJu X6n/1f42NTUJe3cTKvmxyuwU/NkByGHsfu5+vTmo55BBYXM4VQ1pdQXZBkJKCKWJ8gnjsOnp2rly xr69Sb/mX5nmVV+5l6foz+wX9tSY654j+BfjZ2E3/Ccfso/DPxBcyfeEs0fhHT7Cdh6kPYnnttNf GqwkSdd29VUSrFtMwAHy9OcA4xX+y/ANZ1uEMtm/+fMPwjb9D/ITxPpuhx1m1J62r1Pz+fc0EjY7 ztXDxZMbLuckMx4I64P9KvRxlUXClTnlsffbBxwPfHf8K++p7H5PiHqW1Ox2AKoGGWBbhsYHIz1y Bx7fjU8efLIPzEcNuGMDHH8v1ruoni4l3R//1vj/AKkDAJxkDbuUZyPy4xn2+lSofmO0kdMfKTtz gD8OOtf71Uj/AJ4MQ9dCwoGOFYtnnPDLn+nOanQ5wGXc2TgkA5xnjH6+ldkPhPKqO44DacYCD72F BAwPw+uP84fvH3QowxyQFHB6Z9fXJroh8JyPdjwcbsDIHy5PLDHbGKrtyFOOCeAVyG/ziqEf/9f5 SJIZicqORkAH9Mf5xTJWXcvIOCcgnGevGTX/AEAH/N+QyPnDE46nIAUDJ7D86qNIGOUQk/xADOen t9KC4bn5Xf8ABSpj/wAWoYkkLFq7Eb8Y5sc9D3wa/KxnzvDg7g33Nudy4+Ueo+lf5PfSadvGnObf 9Q//AKi0D/Z76Kat4CZD/wBzP/qXXLWSFVFCgKoBXA54B6D8f60iyuAuUX73GPu4Xn/HivwA/oc/ /9D+KaSVQDkKpbB/uod3HA6Z+YfnTt8eBgDeoyZM/wCs53f1r2W23qeXCN9WM+0HhIygXoccP2wM 556ipQSys6tgxv8AcznGeMfz9a527stK2iHq/CgSYYDCxlQ3TPPP09BUUkjEmM/cX51Y/MR2yTnj iol8LGVvODOibiBvxMMGVyMjJ5/pTl2biA4z0zkeU+SAVHI5GDWI46NH/9H+JoFWD5QkAlDtBbGO mTznPHGe1QsBiNQEVW4d1c7Tu5z1POPp2qpKzOcjOEKqrAbWzkDJJznJwT6H/CkMgRjswccjdEcF eMsM8dzz7VlPY0pvoNy4+TJmTsp+UEjA9eDnjiv0D/4JbeE38bf8FBP2SPDwjVvO+NOjzurYcbLa b7V06f8ALEHHb3ruyWbpZthqq3jOL+53/Q5czgp5fWpvZxa+/Q87/bK8aSfET9tT9pnx3eSF5fE3 xg1bWJzkthpbpnbPX+Ikc/1xXn+jKv2i3AZ2M0gVzgksS3GeRjgDg9uO2aXHkVHirNYrpXrfhUkj j4WuuHcvv/z5pf8ApET/0v5E/i7pDeG/ih8QPDzJ5R0nxhqGlsAhDKLe9liC/pn6D3GeBdWl0/VI 23KJLFxhkyqHacnjk4xxivMyqac6NT/C/wAUebP+HKLP6vfHuuv4x/Zi/YI8czMHl1v9lmy0/wA1 Mnf/AGVr+uWcalucfuVt8DIxkdq8Di2MEK7mUOVyfu43Nz0+mT3IPHr/ALF+FNf23AuXTf8ALJf+ A1Jx/Q/yV8ZqXsvEfNor/n4n/wCBQhL9S4HJXLKCRk9wx6dsY6kdvXNXY8MMj5jgABuGU5znp7ni v1Kk9LH4liE9idcblA24AHIySxIOc/TjpxVkEcfIT8m1sEHdknoenT+td9E8fEbH/9P4/TDY2kED JbcdrHuCPQdRipRg8nAA+8OGI5xgn8q/3ppux/zwV422FVgNgcZKnoD83oBj3qRXIwvGCOB37d66 4OysebUgSrKjAqQcZJBBB6dOetAYhiMcKflyATnv+lbxly6M5Jx6ocZAeMkY4543Dn+RHt/ipZTt DAlRyMd8cE47dR+VaKSexFrH/9T5OJX5iAVBIzxgEew6/n6VWmbJVT03bVOOB6Z/IV/v9zK9j/nC jC+rIZSOFAIJ4bnpVYoPm4JVSBwduR1+v+RU8+mhpGNtj8q/+ClMgWf4UglhiDVSvGQebIV+WAVQ SfOZHJwzFeBxkc+/TFf5P/SYd/GjOf8AuX/9RaB/s59FVW8BchXlif8A1LxBMuVUDD4LdOBwPf8A E0SS/KApcFAChdAwPLA+2OO9fgT2Z/RSjpZn/9X+JoMQo3gNk4UHjt3A/Age1ODqcnILBcjnAOMD pivYPPtYYmWDBewwS3BPufqBTvMUCNMswHUdsk9Tj+v+NYNWdgHiXyyuE54yGYEIOmfr7+4pVm3P xv8AnbbsB4YZ6e/Tp71MldWQEUjKWDy4VPLJbHKwjPGPf8eM1HIA0TMqYQvkEJtD8fpnBxWFrbgf /9b+IksQSCDtUkOM4bnkEHp+FJJMGPyEYjOAOTnHGeR/+qtpRucy1RMzsRlgq8DsNpXof5evUH2q oAcqqMNpypLDgHdzx7ZPr0rGasmik7bDycIig5KDLgfeBOOQPwHr/Ov1o/4Ip6RLe/t9/CvXLdD5 3gTR9b+IkfsND0u41ByeRz5cDjI/xr1uGKLxGf4XDRdnOXL3+JNW+d7HmcQ1YUMmr4iSuoJS/wDA ZJ/hb9D87vF2qJr3xQ+Jetgu6al481S8jkPJKPezbcnvx9eteo/CvQJ/Ffjrwf4Xs43nvPEHiax0 W2iVCXeS6uY7dFAPXO9encjpXk8YYiOIzzMcUtpVasvvnJnRktBYfKcLhv5acI/dFI//1/5if27f DS+EP2x/2l/D5iaBLL40eIfLhiGHjQ6ncPCcdB8sgIOM84r5TjhJF0pO1JbdlMsnJO4ZwW9xxz+l fPZJV5sJhqneMPyR58l7rTP6c/g/qB8Vf8Ew/wBgvxKQskmjHxt8MpGGMR/2Re6RcxI2ehJvpm9j muJG1N8bMyspy2SuzoM5AGDnB59e1f7B+C9X2nAGC1v72I/9Satvwsf5UePND2XiRmGlrwwz+/C0 W+3W46LJbdGC2ACXXbJgndke315+8K1Y9zsec8ESx5XGRk8/N06+vGefT9lpO1kfgFeLW5ZUlnyM Bt2MZG7068+pxT2Ox2RmZmBO7zFBcc5xz14OcZ7n8O6k7Hj142P/0Pjn5VX5GR+eWXGQfT8Bj86c uSsmSDtwqggAnPsa/wB5qcro/wCeavAd5gUbF+Q9Cc7cHOePy/GmM6g4Vs85+/tB9efzrqhL3Tz6 tNqVkSxyEf7LLgkA4IHbH+e4p4kG4BeOcnPVuMn3rdao5HTdx6sm4YPzDuCRk84/z7Um7BwCSepH fGOv8qabWiFKj7qP/9H5I83nZuZjuwAR15xj+XSonkXeC3HTcCOT7Yr/AH4P+cyNPoRSFD8pHUd8 t69f8+lVCAd4GT/COwOePw6VLkkbKmflT/wUnCi7+FRG4f6LqnQ4XO+y+8PoGHfvX5YyI5w2flz9 4cgjPJA69v1r/KP6SuvjPnNv+of/ANRaB/sp9FhW8CMhXliP/UuuTISSfvBt4JYjcWHA544HTrno KkWMyyiNThgpBEo2pgchR1GcAgD6Yr8Fex/RF9ND/9L+Jjjdz/D91cZK/XI49TSk+WwGc7W2k53K 3br35xjFey1bQ88WTc7vJLMZHkG4s7b3kPfJ6kknPP51Gjb8xIw3Muw7lAGCc8+nc/hU2XUAUwfM C5MysqxjywUdSDuYnqCCEG3ngnpjmHzYpHAcnaFPmKPvOeu0DGe54rFqzAilPzARqCA+4M4JKAdB jkd/Wn4TfISoygCBlUHkdecY6/8AoNS1dWA//9P+IZ1UqzNlQDjO0gc5yR9PTvmowwVlCkjbldhQ nHXP49MfSulq2hwp+60TttYHcSwxxtI45wPU9Rkio2O7LguMEgb+Px/z6VjNamkdhFaQvIXZhkqD I43HjHBPB7AemMelftL/AMEZLZ9F+K37SXxQUjHwn/Y7+IXieWdzhIzdeHb7SUGeuS+oR4HcgV9P 4f0fbcbZZC2ntoP5J3f5HzfGlRUuFMfJr/l1Jffp+p+PvhkNOJrsuzSTyyTMcbnG98kEDkcscgep r9Jv+CbfhJPGv7cv7KPhwQmRbz47eGlmhY7RJFBqdvcyjaOwWIk/j9R+W8RVp0stxdePxRhNr5RZ 9ZBJRS6H/9T8Hf8Agsl4Vfwp/wAFEf2gYxD5Ftr19pHie0UfK8pvtE06WRx7GVp+Rzn8a/MS0G64 RFPyyOyPkDc2ePTk9fb618pw/PmyrCSX8kPwSOGStdH9HX7DupSa/wD8EiNCtSwkn+FX7Zmu6K6k 4a2t9f0cXAGOwL6Z39O9e1fB/wDZm+PXx9iu7r4UfDfX/F9hYzPBeajaCK10rzLeITzwrcSukZkj iKO8asWVXVmCgiv9X/CPiLJuHfDKjmec11Sw8HrKS/nhCpoldvSV9E3a72R/m941cK59xX4rVcry DDyr4mdODUY9qd6bbcrKKXJa7aWy3aRx1/8ACv4kaNqV9p2o+BfFdtd6cbn7WF0G5miP2KUw3bK6 oVaOFyA7glRlfm5re0/4M/FK8+G978XLXwdrEnw8tNftfDDeKJIxDY3Go3fnCC1t9x3TO32a5/1Q cAxOCcggft0eLOHY4ejivrkHTqzhTg01K86jtCOl7OVnva1ne1mfzvU4H4qniq+CWAqKpShOpNSj ytQpfxJLmtzKN18N27q17o73w5+yx+0T4u0G/wDFWgfCTxnqGiaX4psfBF/cSaS9pcxapqUltHZW ZtmKylpHvbJQVXaPtcOSN6k8V47+DXxV+G1rNe+OfAniLwzZW3ijUPBNxe6lYvDYx6rpbql/Y+aM qJYS6kpnJV1YZUg104HjPhbG5k8nwmPpzxN0uRSTbbjzK3SWnZvVNbpo4c08PeM8uylZ5jssrU8L y83PKDSSTUbtPWOrXxJaNS+Fpn//1fG9X/Zu+OekeBvB/wASrn4da9P4J8d263XhPV9LRNYXVInW 9dZPJgZ5Y1YabqOPMVf+PKb+4cYvh34E/GXxTo2q67oXw78UX+maJo1v4iuHXS5Irm8sri8gsIbm xt2Alu0M9zbxk2qyBTMmcBhn/bfDcc8JVcPLEwx9PkjU9i/es1U9p7LlcX73xpq9uWycr8qbX+FG N8NeN6GLjg6uWVfaSpOurRunSVP2rkpK8f4dny35rtRtztRdP4S/B/4mfHPxfF4F+F/hS98V+J50 WRrG1kjt47NGlitxLcXErLFEhlmgiDSOoLzRqMswB9I+JP7In7SHwo0mHxD4x+Eviq28NyaPJ4hk 8SadYnXvDtjax3U1kz3d9beZBARLCw2SurYZDgBlJ6MXx5whlmfQ4XzDH06eOklJQk7Xu0kuZrkU ndWg5KbTTUbNM8/CeG3G2a8Oz4vy3LKlXLoScXUir6xTu+VPncI2alNRcItNOSaaXfWf/BPv9rm+ +GWk/Fay+Ees3+ha3LENP0WzuIJ/G8kM8dpJHdNoob7YtuyX1jJ5rRhQl3Exwrg1wWmfsiftQ6nr l94XsvgR8TpvEGmaYmtXukHwncxXtrZvd3Fgly6FRiJri1uYg54JgfHAJrx8H4v+HGMhiJwzejH2 EpRnzSUfgai5Rv8AFBtrlnG8ZXXK2ezjvBDxRwFXD06uSV268Yyhywcr88XNRdr8s0k+eErSi01J I4/4h/BH4rfCvRvDPiHx14R1DQ9E8VT3un6VqEzRXFvHe6bPJa6hpt0UZvs19bSRsstnPsmjypKY INe0+LP2F/2h/DOlWOtaT4ZsviHpU3gxfHuq3/w41BvFFj4c054nmEl7KI0QqUinZZLdpYn+yzhJ H8qQL6WM8RuFMB9SrV8T+4xU6kIVbfu1Kk+WUZN2abn7kbJ80ttNTysD4W8Y5lDHU8Nhb18JClUn Sv8AvHCtF1IShFXUkqa9pPVcsfNNL//WzIv2If2ktVP2jwN4C1D4kaINE0DXD4k8Exy3mhxr4k0j Tta06AyTpC3nC11OzMibf3ZlHOMMfNvGX7PnxF8C/DT/AIWp4kj8O2vh/wD4TdPAkdrbeKbLVtXm vW09dSEiRQSSKYRDJGS27OZB8uMmv9tst8TeEM4r08HgMS5YicowdNRk5QlK3uzcU4Rcb63lbRpN tWP8I818IuOsjw9bHZlg1DC04SqKq5xUJwi2uempNTmpNWjaF9U2knc8AkuhznoDkAfK3+frUST5 JBztxxjBY+lfctn57Gm7aH5Zf8FILjN98Lfuqxs9UXcAd3L2YwM8cY/l9a/L9WIyWJLMcg+o5xj2 9/Wv8q/pIpPxlzhr/qH/APUaif7E/RdTXgXkS8sR/wCpdcnVVyWy4kD4VQASQSQTn1HHr1qZiBgA ZfB67Q4PGTj8P8a/BWrOx/QKk7M//9f+JwRHO4AAhhlz1zkY57ZJ78Uxw5OCoLHBAB3dOpA7H8q9 2avqjzyCV8RFXxuUEgqxIY8evTj2qpuwXDb90Yzu3ZBwR/nn0rNRexMtEM3/ACHli2zYmPvHsMj8 T+VRFyVzlmKjswwDnup78kVEo3IjJkqyuWCDeqJhjjgdwSR0HpmpXcERl0AHMbbPlZvlA5OO5Hb1 PSsnFrc1P//Q/iCQs2WChipJ3Zxu68dcZpwBGeACTmNj32/wk/jXc4pnng6v8xPmb8hShHQA44GP 84qUwSNsjVZAeCQDuLADj09a55rTUqHxIWKFgFV45QQ4+YuVTAGMHGeeAPqR0zX7Gf8ABPG7m8Ff sjf8FQviND5kE8P7Nel+AbVwwBJ1vxZoq3SAn1t4LjnrgmvpuB5+y4nw1ZfYVSXpy0py/NHh8VR9 pkVana/M6a+TqQT/AAPyV8NBxaW+MAeQruATvH3jnHJr9wf+CFng8+Mf+Cm37M0G2SaPRNf1LxVc EJuWMaZomoXaOxx03RJ9CVr8m4k/5FGL/wAEvyZ9VT3jbuj/0fyr/wCDgLw6um/tpaXr6w4TxV8I tIuDIGCtK9rPe2jlj7C3i9OM9cjH4WglJYZVBDowC5G7AJ+XtuwCeo6/lXxvDVRVMlws4v7KX3af ocMm+Z839W0P37/4JaaneeJv2DP20fAdja3OpXPhr47+DfG1pYWkMk9wqyw6vp9xIEUFsf8AEwgB IH8PpX6f/s0ftufHj9nDQtF8L6Z8HtG8Z2PhCDxDbeE7rxFoOt6bqXhu38U2yW+u28Nxp9zb+Yty YbWXfMJJI3to9jgcV/pl4eZHkvF/hdTyTM8Z7C8oNSUoKSf1SlSbtO6s1KS27NO6P4a8ReI894I8 U/8AWLKMD9ZvRlCScJuLX1utPeFmmnCL320aaZ9Bah/wVU/aK1TwVpXgRvgB4Y0nw9puivoVlBob +OdHu7WGKfT5rSKG4j1RZo4oF02C3EYc+ZCWjdmUADznwX+3d8ZPDF3qMWpfs6+DPFmg22v+HvEX w+8D6p4d8RWvgv4WyeGF1YaPFpVlBdo7LG+sXk8jXUksk0zmSR3YuW+kwHghwXg8uq4Cjnc05yU1 PmoKUZqalzK0Vd2vBXuoqU7fEz5TMfH/AI9xuZ0swq5BBqMXBw5MQ1KDjbkd5Oy5rTfKk5OMVK/K mdZ8X/8AgpV+1J8XZPC1xcfC2Lw1f+DfjLYfGrQL7SrXxPcTQXun2z20dkUnunjNq4kbdGFDbAFV lXIPz78b/wBqT44fGbR/iV4cf4UQeBtG+L3xTPxa8f2XhjQNcuE1nUUiEdqga9luDFDC7XMwEOxm e8fcxRYkT6/hjwx4B4bxWExVDMVJ0HF2c6MVNwlGdNy5YprkmnNKLV27SulZ/FcYeLniTxZl+NwF fKuSOIUo3VOvKUIzj7Ooo80mnzwUYtyUrWbjZtNf/9L1v4Xf8FGv2rPg98P/AIUfDjwt8GfB95pX wctJLfwxea/4C17WNVlZrnULs3EkhvAscu/U7sFrRYQ8TLE4ZF21k2X/AAUB/ai07xF4h8SWHwP8 KNqXi/wS3w88RW1x4Q8XXukajpUsOi2c1slk2pmGAzW+gadbvJbLG7IjncHbeP8AVJeD/hnUzLF5 pUzWftMTVdWa9th7c3tJVbRXsrxSlN2SadtG3eV/8rH45eLtLKsHktLJqfscLSdGm/YYrmcXSjRb m/a+/Jwit01fVK6Vvnj9nr41/tJfs46x4g1D4eeA9TvrPxOtlPqvhzxF4D1DWdAnutMu11DR79YQ EcXGn3SR3FvIr/K6kMHRnQ/oxcf8FS/2qdS+C/iLwBN+zbEfFut+JYWsLyD4dald/D7StFMVyL3T 20a5WaW4ku5bu4d5JbgoFk2CMDFdfHvhpwBxrnlPP8Tm0adVzpupFV4KDhFQU+RJqUaso04QUubl STfLzWZw+G/iv4lcBcNVeFsNksqtBU6ioy+r1HONWUpTh7Ru8Z0oynOThyqTbXvWun4d8OP24/8A gob8O/Dd54c0LwD4i1tdZ8Saz4k8S6x4l+EWqeJNc8TN4hjhTU7W7uXU/wCjSC2tMRRLHt+yxBWA XbXpsn/BST/gqjcafdaengfXvsd3p82kuIv2fH82G2nW5X7Okn2TeI0S5KIGY4EMXJYEt5+O8IfA XMMfPMMTjIKcp87UcVCEE73SUYtJRirRS6Riuur9HLvGn6RuXYGll+Fy+cowgoKUsHUnNpRScpSa u5Sd5SfWUpdGkvin4x6z+2v8e5bcePvhj8ULiwt/Emr+Ml0bR/hVf+H9Ck1fXb2bUNW1WW1htljk uriWbDTuC3lxxRghEVR6Hq3xa/b917wjP8P9S8DeIovB00Bjk8P3HwfstI0hJmt5rd71YntFRblo 5XUzqM5ORyM1+gVsH4Tyy/BYCti6MqWDk6lJLEXam225Plnecr7Xu+i0bT/M8PivGqlmGPx2FwNe FbGwjSqt4WylTiuVQXPTtCNlZqLS2b1Sa//T3NK+In7fOlW2kW1jGdIttAk0uXQBqNn4a006BJo2 nWOj6fLaNckGCVLPTrG2aRCGdIFDE81weuaD+1n4j8NeIfBWp6h8P7Hwn4p1O01rWPDI+IXw+8La W1zZQQW8EkMK3sQgPl21ureSE8zyU37itf7CZdifCfKaqr5ZGTlF8ycIYurZ86qXSUZpPnXNousl tOSf+NWbYLxtzmhLDZxyqEo8rU5YOjePI6dm7wbXI7Wb+zB7wg4+SL+zP8WXTDal8Grf1F3+0n8O bTb7Hfro/wAmg/sz/E+NiH8R/ANAo5LftVfDAlffaNfJ4z6V9n/r3kj1jSxTv1WBxrX/AKjn5/8A 8Q14ijfnqYOPRp5jgE18nibnhPxm/wCCekfxrn0C58dfED4QWcnh6KeK1XQf2ovh6iMJ3jL+Zt1C bcfkXG0jqa8T/wCHS3wgtxm8+Knw4XchBVv2hPD96T8o7wK/6da/B+MvDvwz404kxPEuaYTMp4mt y8yhQr04e5CNNWU6EWvdir6vW5/RnBHiV4tcCcLYThHJ8TlcMLQ5uRzxOGqT9+cqkruniZJ+9N20 WllrYnH/AASy+AUJAuPi78MlA4Jb4uTXmMYGMw2LDv8AlU3/AA7I/Zri3JL8Y/heNmAAfHXiKbPf rFpJBx7dcGvm4+Cfha7ezyLMp+suX85xPpqnjn4wRX77Psrh6Wn/AOkxn/w5/9T8qv8Ah23+y3b5 Mnxl+F+c4GfEXje4ztP+xohB6jp6imP/AME7v2TYcBvi98MnGzKhdQ+IEgz7Y0QDoP8AJr/SWPgd 4b2uuGsa/XEQX/uwj/MuXj34p35ZcT4BemHqP/3VZA3/AAT+/ZCjG5/il8PJDnBMbeP5fM28c50g Y/GmH9g/9jmAYb4i+CpRyG8vTvG0hUA56tYL1x044/Kqfgl4dW9zhjEfPEx/TEkf8R18Tm/f4rwq 9MLN/nhCIfsP/sZR5Evj3wuW6Fl8M+K52HUHG6EdOeOKd/wxb+xXHuEnjPQ2QAnA8EeIpwuMdAzD sP1pw8G+BqN/Z8Ky/wC38Vf/ANyyLl40cf10lW4uhf8AuYRr8qMSQfsefsTxHjxRpMuDkr/wgGs4 OByQTcDPHr9MmlP7Kn7FsC+WNWtJF35aNfhteyKcZwQHvVyfmP8A31XTT8KeEIax4Vo/9vV7/pI5 p+K/GlTSfFtZ/wCHDtf/ACJ//9X8oo/2dP2J7MAPeXGA2SIPhLbXG7bu/wCemqqepGc+g4pT8GP2 HLNAslzrJfd91fgxojjdn1fXB14x+PNf6ef8Q74aoR5afDWBVv5pJ/i8PL8z/L2n4gcU4if73ifH v/BBr8FiI/kVpfAP7E1ofkXVrlEwFST4V+GdOZsDgb/7UlH/AI6evSqwX9izSSxl8M685UZJtb/w r4bOMfKP+PKcr37n6cmvPr8MZBgJqtSy3KcPJbSlCLafry0fzPcwmfZ/mMfY1s0zfEwl0jKST6r7 VVfgwk+Jf7EdihCeDPGRVRhWi+PPhXS42wdpJX/hGH/ujgNxivK/2iv2qPgrpv7K/wAbPhV8JrP+ xp/iWNIXWp9X+KOneOtXvYtPuZfItraC106zCqzXpkkfD4EC4AGa+H41zvJY8LZjg1nWXKSpTap0 FGNSU4rmjCP+0z1cklZQbt26fofA+T5rT4oy/HRyjMnepBe0xEpOlGMvdc5L6vDSMW5L39HZ6n4+ +G0/0KCYjBkgHfeCSobIAPseOpr+nb/g2S8Cr4j/AG8fFXjFoEFv4B+BWsalGwGVtrm9v9L0yMK3 +1FdXX5V/mvxXUUMlxD7q336H9xUdZRv3P/W+G/+Di7Qls/iz+zx4o8ooms/D/VdIabZl/8AiX6h BJtOTj/mIxnn1r+b1i5xt+QLHuxkI7EHOBjnuRgZ5x9R8BwXf/V3DX/vf+lyOOaV5M91/ZX/AGpf Ff7P2o/EvSvD1vqTHxFqkV1LJYeIJtCmXyTIu1vLU7x88ZwSANo69vq2X/gpN8VYSoVfFDOowQ3x G1Hd8wxhmCZ4APT0PNf2ZwR494HhPhrCcP4rIaWJnRUl7WU4pyTnKSunRm/dUlFe89Iq1tl/PXGX gdj+KeI8VnuE4grYWnWcX7KEZcsXGEYOzVWCfM48z91ayfqA/wCCnPxPhXZ/xV6hF3BF+JeofQEk Lx0Awf7v1qL/AIeo/FeIBki8ZlCuzLfE7UFUjI5/1fX6HuK+6p/Sfyl2S4Vof+DIf/M58dL6M2bN /wDJWYn/AMBl/wDLypL/AMFYviuQzCLxpjbliPinqOQACP8Ann2P9apyf8FY/ivvwIPGRx82G+KG oApyQONh9h26n8fQpfSeyvpwtQ/8GQ/+UHPP6L+ZyXvcV4r/AMBl/wDLz//X/nKn/wCCrnxafgxe KFPmY/e/EzUhkANyAF9evPOTweTWLN/wVW+Lh+7b+IGBOA0nxF1MkjoSCR9P15r+4ofSewKXucMU P/A4/wDylH8YP6LWJm258VYr5J//AC1lGT/gqh8X2+Y2Got84KbvHOpEHHY8+9UJP+CoPxbkYN/Z LvzlhJ4s1KRec9QWxjg+tbr6UXJ/B4cw8X/i/wAqaJ/4lRw81y1+JcXJf13myif+Cl3xUmPzaBYb iCBu8QahJnHOeX75/T6VUf8A4KN/FOX5X8P6Mg3kEyajfTJzkcjzP8881s/pWZ7CPLh8ooRX+KX6 JGa+iDwtOXNic3xMv/AU/wAbmS//AAUI+LEjADR/DXt/x9uTxjjMvuOPyqBv2+Pi5KSE03wkgC5A NnPIRx6+b/nNcdT6VPHE3ehgcLGPnGo39/tF+R20vog+HcFatjMXKX/Xyml93sn+Z//Q/lWb9u74 wlsC28Jqo53f2XLIQO4x53OO1Upf27PjPJv8pPCiAHJ/4lDlupHAM2D2r+2Z/Sj8RH8FDDL0pz/W oz+RIfRJ8LYfxJ4mXrVj+lNGVJ+3F8cZAduoeHIWBziPQIyvOeBlj0JNUT+2v8e2OI/EWjxs4JCJ 4csy3tnKH/J/GvLrfSa8Tqn8OpRj6Ul+rZ6VD6KnhBS+PC1Zetap+jRXP7Z/x/QnHi+yUjAKp4a0 7HP1hPvSP+2L8fZBGP8AhN494+9t8M6YBjg9Rb5zwep9eetfPV/pDeLkpOUc1sn0VDD2/Gk3+J7V H6NngxCPI8nvbvXxP/y4Y/7Xn7QbRlR4/wDlBzkeGdJD916m13AcdPcVSP7Vfx8lwZPiFfKqjH7r TLGByemeLcce1edU8f8AxcmrSzd/Kjh1+VI7af0d/Buk7wyWPzq4h/nVZ//R/j+k/aV+OFwX3/Ef Wo8fMBGsMJJBGFG2MDsD6cHr3z5f2hPjWztj4j+KCFGQ39oFcY56Ad8HP+cfvNbxp8Uqz9/Oat/L kX5RR+L0fBXwrw6Sp5HQ07xb/NszJfj38YXKg/EjxrxH8rJrk0RJKkHo39e1Y9x8bfjBKmG+Jnjo 4+YyDxLdpgZAxkSDnORyfzrya/il4jYi6qZ3idf5as4/+ktW26efd39Kj4W+G+Ha9nkeF070Kcu/ 80Xff+rK2ZdfGD4pNvU/EvxxLkfIzeJr6ORT3z+96jGOpHX61Q/4Wj8SJwVn8feM5Du3Hf4oveh4 /wCenHfPfmvKq+IPHkk+bO8W/wDuYrf/ACZ6EPD/AIDpu9PJMIvTDUV/7YU38e+NpS/2jxf4pY7Q G365d7xwB/fz1FRv4w8TzCNpfE/iCRlPQ6vcDoM9S+Ow6D8a8itxZxTWT9tmWIl61qj/ADkevS4V 4Zo29ll1CNu1Kmvyif/S/iJGv685Ik1vVn3/AHC9/M+OQOPmzz3x6d6rf2lqLMWmvL2RchVD3cnz dcDk/T9K9nE43GYuXtMXVlOS6yk27drtnj0MJhcNHkw1OMF2ikl+AG7nMoV5Z3dSuxXkOBnnkE/i P/r1IGmByGlkaQHIBPlnbkkdccevXArzKkpHTGKvYeCSrKGIRVYBSuOOc89ec+v8NYevymSCSJAV +ZNv8TkEjgnjv6DvXNKTWhpFI9T0vbHawRBANrKFck8KMDdx1x+gAr+yH/g1V8JRyeLP2r/HZXd9 j8M+HvCURxuMZubm9vJVDH1NtHxx06V8FxpNxyKtbvD/ANLSOqg/3iX9dT//0/IP+DiTwsNR+EX7 P/j0xlk8M+PtV8NzPs+6NUsre6RS3UZOkH8z7iv5NWuEYIwRThSJCGwU2gkn64GO+Mj6V+c8CT5+ H6Sve0pL8b/qckndyXmcfppW08b6iqZTzrNLghcgACOM/THykY5xjr3rqbxgu4EtvADB2B3OvzEE DORyOfZu9focbX+RD+E5e6c+Wyb1G3BZdxHc9AT24/zzWFNchfMkBJbjdl9uFOD0zj0Gff6V3U7X JMmS5U+Y0YyFAjCyP855HAPH0qj9ol24XbHgFmYkhjnIPQ89O3FejTA//9T+FfzGyMn7oJbsTkjn nt25qKRiwyeyj5hndk5GD/ntX1lPqeTK19Aidhg7sODjg4OR3H4Annp60uec8jHX+ID05H+NdMNr Ek0ZUkggqcHa33eh5zz6CpUYD+MsT8p5+bnIPX6Ct4Nt2YD0kXsFAViA3POOxGfr09/wtRFiJMgM g5fkBV6D+eDj2rqh8Jm785//1f4bg4PyKSQgO7cRjrgYJ5qHe7OWBKr0JyMDuOO5r9DkvePDk3dX QhkwS3IAXjjOR9f0zUwlaTYrjGwbQQoDEZzjIGMDnr6VDWlh80lugRkBXA+UNuOTycfh6VfUogzu LEgyMAn3j0I/n7c1jNbIlWcncEc7tu0IVG0nkEjjGRnHbtz9akE2FGFU7jlCASQQMDPOeK5Wnsa3 P//W/iEViybMEjcyttypXIxg88dD9efSgkFCrNhtpBGSCcnp19f1FfVSTvdnjkTu+xMEhlAVY15P pnPv+lU5YGOWI4Rtpww45PTn269Oayk2gKkg3hmJxuYcEFSePTt/n2poXYGBDgkZVSNysuD39iOm Kwl8LBE6RsoVuSynYA/DHdu/z6irH2feUCqXyMfJ0H49eOetc8vhN03u0f/X/h2eFB+7yitGpYNJ uy3QgcdM5xzx6+tOtEPRwSjHhlPEePvcYPQf5613vZnnkyKgBbLdxuUgt3OPp656VIsWGACsWJBC uNrHjcOv97n656Vxz3Lu3si9Gi/diKEpkSb4gdhB5CjHsvXjmud1G2aRrAsmxZtTWEsoH8OPug+m eePSsJLQuN1oz1yxjIS2RQxLEMsbsSiAnIy3Y9Dk+hr+6z/g1r8Hpp37MX7Q3jkArJ4j+M1p4Y8z aAjLpWi2tzhT7HVvyAOea+A4zdsjqJvdxX/kyOnD/wAaKP/Q0/8AguvpMWt/sRC/YRs/hj4s6LrM al8SLvt9SsD7gf6d1565PSv4sJmVMsqgAPgJLkElj2bGcEH7x64HTg1+XeHjf9huPapL8onLU0k0 YKwQ/wDCXac7ARxyWRQ5cAudr8ZOOvAI5xmtXU2ETvCzIp3cRl9u0LhTj8ckc9++a/TKd3Yysuhy N3Kzu6ROqlX+Z2kyhAIx6+gwOOtYdw9uQ+DwuFwuM+vOemcH8q76V+wiCVfkZkIJPLEc4wOcdx/9 bvWexRhkyqdo48tiwHHHt3r0qZLatqf/0f4VSWbhflJwWXAzxwMZ+v8AnpUHl5U7o2VunIKhev5n rx7H0r6um99DyXboIEw3zMMDLfI/KjJwPx609FQA5wwCj5RwPf8AHn9DXTBNaklhlX1AJIG0gbfT nv2qUxxld2OCpUDIbJ6ZA+gxXRBNO4m0txoQMVH3Tu+VslcdeDjmplcL86koevOd/BPXH9a2i7EO Svc//9L+GMbmwSR5nQY+TJxyAB6e9MwW3bQuAO8nbjj+f6V+htXd7o8BtvccBGN2ZYiFGSNwAyOv Xpj0pR9nBH+kRICdoDsrEZ685/pWTlFbsLPsOj+zESN9oiyqnCrIOOpyT6Crge3bYRcW5CnBIlVs /NnnB/D8aznUp2+JW9Qs+xZT7PmNTcwjfymJAzMMleAOuSCAfUfWr1nYPeuxtILm+UNgmyie5KHn ccKp98/WuSdWitXNBZ9j/9P+K228F+Jn2mHwz4muFdR5fk6BdyGRiSAAoj9enXngVsxfC74g3W42 /wAPvHV07AEi18GanOQSeFG2DjOGx65HrmvelmuV/D9Yhf8AxL/M8KMlHRk//CmPiwFZV+E3xTLs QzKfh7rPydeeLfnofTpUcfwO+Lt0u5PhV8SAFUnbc+BtTtmQhQTgPCD0Dds5+tYyzPL0tK8fvQ+e nffX1LK/AH4yBd3/AArLxbGVIGy50R4JFY4I+RwPQA/735zD4A/F9Cxk+H2una5DPstlUbepLGQB cDn+dcc84y+N4+018k3+KK5o91940fA/4moii48Iahblm8sebJaRnJG7c377jjGWbj61dh+CXxDj jM7eHr6Et8rI13bLKOTnKiU8ccg/X1Fc881wdtJfg/8AIuM6afK3qf/U/j70v9nP4wa80jaD8Ptb 11flj/4lFuL8ytgN8oiR8nGD0PUZ9+kb9kr46mYwt8KvGltIInleFtG1JJkSMqJGIFgThdyk9ACR 0zXLUzrBRVufX0/zPNVSldpy2Nxf2K/2hooUuW+FHiuztfLadpr/AE/UbQeWBl5lMtnGNgG4kk/w k54rd0j9iz4xX8KtB4X1lHc+Usq2Rl3hl/56G4UHOWXb1yGzzkVxVc4oJXW/9epXPRWjZ6Fbf8E9 vjVEkkl54QuJXtID9rjeSHTp+MsVA+0OSVADncFI6dsnyfxb+y/OlhdaiPFXgLRb/wAJWsmszaTq 3jOxsbzVEijLNbW0UjL5lwQrFEDZY/KBuKiuOOcxrNRgr3ZtFXipQi2r7peqPEbK3kXyUaNSqgZU EByBzgn25Oc9yfY/6JH/AAbs+ELXwr/wTb8K6vFH5U/jv4oeJvFN4RkmaSG6j0ZT0HATS0Uem3HO K+M8QJy/s2jB6fvFp39yf9fI6MNZ1Uv6/rU//9n/2wCEAAEBAQEBAQEBAQEBAQEBAQIBAQEBAQIB AQECAgICAgICAgIDAwQDAwMDAwICAwQDAwQEBAQEAgMFBQQEBQQEBAQBAQEBAQEBAgEBAgQDAgME BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBP/dAAQABP/A ABEICZAMwAMBIQACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMC BAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYn KCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeY mZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5 +gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEG EkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpT VFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4 ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AP4gvEmn aTJqV5PpzXF/dzNHJLdSSEW+AgThBwOgOepzXNvNPpWpGzmWNmeMDzYjviUsAwJPYYNHPo0jti7V NCS7u5riy+xqRLbwyl5SBjzWPA/DimrppWJCzyQQXG1WZnK28BBHzMME8c5xzxWF2aOV2xsMC3Fo 3kyh0YtGkm4MxYe3WtDTpJba1az8pUjSQtiZMO5PU1LV1oIsWzRwSssLN5rP5jAD92uetT61az3s Ehzp5itkV0T7pkIB3OzAc4wOPbNYu+zMbrmuz//Q/hjZru7023PnlUwFx96PZnr+P9a3LvWrjUb+ 2tEhsba2tLaKCJrWP57wIgDvIx5ycZx6mvPO9TXKXJEs1BsUvVggZvMYTKYYN+ON3b0Ge1c/eiI5 Rihcfu28iQSI5HYMDgimnZ3Rm5NvQ3fDFzp8GkXFlZmX+1IpnkkkePKwo3Qq3qCelc5Jbx7wb2V5 bjf5kMsZ8v5lORz2pFQk3oylIbe+N1cX7s+p2zLDaxeWQQuMs5b+IcY+pFbFjczxacY1tI5Zt5Yu qlGCnA3HsTx0qo8uzIlJvQ//0f4e9Pk0pIJI5izTSpuSSX5C0hOW49gDVaWOwmtZGgjihVZPLMIy 0RI/jBPfPNcUlHoVK99SgwvFiS1+dbZX88OfuDPHSthLp4LSe3Ev7uRRwgBJ9/btWSgkbLbUhjX7 WsSGaYw2x3GAn5HJHOPSqEVg32giNJY0aQkheEH1rSN/smc4q1zpIrc2kikNG5ij3tJGNx6ZIyPS n7Y4JRdI7PFdf67dJygx2H1rRc3UmMNT/9L+I7TdNjsrrVdQ1y7E3l2Z/smxtgt19sncgRo6f3VB JJH938K5GSNfOeNo/JZWLNGqlcZ56Vzmzp3WiLcEk02ly6HLdSR2rXjX8ARFWRJTgDL9cfL/APWq K5D37RWxTbcRHmVjkSHpkVcXK2hi6Vuhr/Y1tba2hN9LM0n7qaMJgK/UEewGaliUwWZt5r3z5DK8 kLuSQxPQH8qhmXI7lGKSW3nZSvnGfCyQjnk9gPxqv/xLp/MhitBDMJT5q+VhIz0zmsrOTDkZ/9P+ GdLJlkyJ0WCFfm4+ZvTFWIbbdJIIpG3BA7gfeQHgE+ma5oLl3MXFo6JrO5kksLaeRPs/knzy0m0q GHBPY9+prMWGztlna2hDxW0hErhflc92HrnjpWs2miNehXa6dDG8TbIHJP2cDALcYpdklxJfWsMD /wClQA3YClvKTOSfbNQlfRFJtEi29lbmGKK2KLs8ti3O0AYwO9aHlLpRlt9RjeLzIlnsXTBRt4Uq GHUfLzxWqikQ5yUrH//U/iFt5RLfiQTQssMYdzOcRSAHAXJ69uBWPqIZ7lyke0eZzEmSik8gKeci lJ2Rl7SSM9jcWyzeUn76RNpyucAc/hV7RtZ8RWK3DaZfvZz7QZCSCkozz8p4OPpWB0KrJK6NOK9v NVSY3kqx6gjA+c4LrOxPBJ6c1oI19ayul2bVmVwAYG3DaQP88VUXyu4lUbLmpW7iUl1jRYoVkeCJ hIzgjO7Offmq9xfXBAQ7RapGFQINhXjGCPyqnNPQ1hN2P//V/h6hjkku4LqBmils5DNHKp2ncRit Vr+6uJTAAJ5pX+d2bkHvuauc3vK9rDtXsYdMt7qOOaNJp0XdPAN4OcEqpx+f0rIttMxbwSOJgEHB kbPPXrTs72GXUKQxTLLcSOFUvDbpHvG44HHtx+lUfPmsf9IUr5jnhWGfzq1DTUia0LkZsLmFInRo L2efzBBAM24BHK568n19Kgms54pJIAfLC/MoC5XnkAfT+lKUDI//1v4cw8ss+Z0WaOPiSQsRI31H +FaUN1EoX7OsiEHrjGzFc1kgIJrxA2HwZJD8x6lvrTWSwimXzHkZmhDJaxzHaMnlgPX601HqkZXs 9URl2VZAssv2aXhYy3PBwARTDfpY2axQwxNNDNveRydoXpgAdxRa25Sld2sW9L13S7+eONkeOTOL tyn+px/Eo6kfrWmp0i3W/ngvp7qa4TAmuIAkg2nIUKO3TrQEoXd0f//X/hua4kJ823t5CC20n7gJ 6cVeVdOewnRYp/tx+fdMN1u/cj2x7dayUG9yGmo2M62Sdm8uaVM4LIVPGBz+HSrzXfl2251W4eLC Jl8GMZPIHelyyT0MjLuZ472IQMyW0xfzXuXG0kdk54wOv/6q0bYSfYBHLOxt1m3CRsZmbHIH4elS JrSxT1K5juYYrWO0ECwviOQOSJQefmHr9KvLLOYUgDSRlRt3Kdu3PSndrQzpOSuf/9D+IKxjkBRZ 5yokfyd+c+Z9T2q8sDK0xnuVhS3fY5Vx++Bzjb6j3rzyY88YamZdRlYHjj/eKoBVg2SAetYlrDK8 3lo5Cbt0vtQTTvbU2576FBIclti8qg5BHH40xrtotPja2kiMLyGaaF7VVuEYgAESY3YI5Izj2rWF +poXLIxeSLqcHzGO1FIwhHuasPqlrZMd9ulzE3+tyWHl7uBjBH+RRyK4l5H/0f4i7S/hNzIYUHkK mQvIX6e+apXUu0Ncy4AXIjhHp7VzRir6CsrmfaXsL/JAJC5bLeafmA9KsXRlgO+JXhuIpFeJposk DIJGD9K6OVLoMbc6pHPdG4miQFzmQrGAVPsKt+dHJhlKyOR+7J6jA6VEopK6IlG+wR27fZjK0/lx xt++CkAp1xSSS2qWrFJinmLhlZwC2D1qopWRVlax/9L+FyW9uo1eNFxG/wAh2NjzRxxn8OntXQ6T Ooi8mSMmdvukDcR6AmgEuiLN3LFNbvFIQjg/c7vj2rOgvGjsp7UybYpCDtEa+YuOuGxnn+VJySLU bJ8xTimieQ5AjSThkIyeOhrordIo7d38xgP+WZPOajmj2FFJuzILm80q1YD7UE2hWSFeCWPXj6k8 0javb7ZohtMMsex26luhz+lS2n0Fyu9j/9P+GcX1mlwkah5FXHzkYIPfAq9b3Ww3LwuXXcVjLcOp Oa4pqzuaOCSIGvI4DifBLHJ+X5s1UG68uridHCwrENm47QCOME1NmZlrTdSgh+1RzsY5No8tQPlJ H/1jUjamN0dxbzmGeN9i4GDj2/wos+wrMmutRWSJ2umEhZfmZuh6dqqXM1sxTbInl7QA6c7u+TQo saP/1P4dJpVuIYUU+YkSeXG+BtA/rUlusVuuHeLMa/Ic/Pk+g9KwjFsW+xfa/iS0Nw2DIvyMq4BY g/zpq6yk1jJYsYmt5SGdJ0V5QwzghzyPTitoxfUz5GYMEduUni2phZQ28n5kxnAA/wA9KmiiESyo ZG2TyBn3clQPStIpqRLi0EzwmT9yQXjwyK3U4qzdXNrJDbtHHsuWZhdvwzEDGzH/AI9WjinuTy3d 0f/V/ho80SJGXblZN7RniMqOnPr1/OpnmhKGaBfKBOGjPJXmtuSJioSRmefFbybfMO+TlS3X8a1k 1HdKrMMnZsCZwGwOwqHBrYFFst/2jbMypdzxQ7TtYMckegwOfyrMXWY47jauFi38BDlY88ZzS5JD cGloal1FLOr281yFEirLGFAJxwQc+9MWa2tkjWOUee8u1/MG0MAO5+tZyhpsdVFNQ1P/1v4g5NTg ulKHZGqDCwQfcBxgn6nAyazJoVeNpRNwPl2Mfy/lU8ibC1tCh5ywsZIi0jxAZGcY/wD1VvR66kka okeGCjMrsFXP0rVQYFS51ZpDJEmFSVPKaVHw2eh21VSZ0bylbeojClmOSvYGjkYF20ksI1ZjdwzX UjmGS25zAAOpPTnOPwrFu5laVhESoD4JHcetCgxvyP/X/hdleH935ZJOfnYjArXhu45IChKtGo24 HLj6Voody4ble4eLbLNGxG9PLOfTpisYybHBXPlqMY71LSSMZQvqiXPmqXR22oNz+op73SmONdpA z9/oaV9LGEYtbmpZXqxwvbxT7lcjer9x14/z3qKa8sS+zZ8yttZ9uPxFZqK5ndG6inE//9D+F6G4 tRdyF1M8eNqK7bAfc4rZa7D2znzESSNsqgGAR6D/AD2qFFpAZU2pjIhhx5jAK69G5q9LeC3VVIKu VCjeMce5oUNdTVRVr2Eh1QfbI4/NaMoMgIAd5xwPpWxNePcRbZpWRvuqoO0N+FL2fmWZ0MWZImJG 2N8leu4e9bCG1uJZYR8pUYjmYYYGh0+wWuf/0f4fr26lsZdtuu9lcGQyg/OuOcVBJqxMnnSyqiuu EjVdgib3NY20uKcXz3LEd0LoH7S8XkQrtDRLv3fr3qrPBbyMjPKzCJf3Q6Lz7VJfK0NEZhTImZI5 WGFB5HuK2I4ZZ4V8m6VmB6H53PHSgHBpFeeK1ijlgkuUjuIk3FXfaS+RuX2qjbM0J8s7n3gqvOUX 60GXIrn/0v4dZtsQDpMznGHjA+X/AD7U2K9jRVyqZz2rnKjC6DcDNNJ5gjDKWG3BYk+1XbBYHZSW JSNMtu+UsaCZU+5dkmFqJbu24iBAMbsCeuBiqZuzdXHmziO1kaFVsmC+YgcHrIPTvTs3sSopCPLc CbJnjuGjGGu7dsRSv6KfaqzI0qiRyPMU5cAZ2H/Iq4x7jcU1Y//T/h5MqtgHOIxg/L1NMvIZAWu4 jmFQMjdlkOBk0klHY52ujKMmoARBDgMDzIfvMPTFTAyExzIpJIwAvzA/55rVQ7k8sexoi5gNgm+V Wllcp5LkhosHr+PaqsT2sbbSHMhGcMuQT7Vm4rZjVNPoW5Jl8siRwGC8R/w1JZ+S6DzURQVPlyKc yH0GPrSsrWNow5T/1P4dnkMd6fPkOB91z0PpWhNLFI1vqKzTLdxIYNxGE2D0Oef/AK1YyjykciII 7+VWLtL5nmLyrH5sdxSJdRSlxGwG9cMjjoPWlZvYpRSehdt4LeNvOikUyouQGIK/UVNGQjkECYzH c7xnLKfpVRi7DI/7SESXEa2iyXEr83DZDgD1HQ5qxDqkkIQpO0cjjaYxxtP+f50nH3rEtx2Z/9X+ KZL2PykjmZVaTOA3BbHJx+AqlNIsUcj2sq7iobypPlxzzz/SoUdLMSS6FSK8WJGlmVWcHnAwCPQ1 rx6lAn2iRZPnECm0b0bI+U+2M4+lZtWdh77GWt+IzNcXG2e8uWMYwx+Ve2fp6VNbXW8LtiWSQP8A vEVucd/pSDYfcTQvNBulzHkmRAP9Se2fUVpC40pFS2mnErAExNEA6DPY59aLXYrn/9b+I/U5bawc LaxvLvAeRwNqxE/w/gKoGa3gdGYrIJ2zlh/qwDyTWDVtAHNeW0ssuy5dPKXEK42oW9c+lNjubmTc 08aBIwEM0YPzZ6ZrLkZMtFoPF1GzPG4fKgY45/z/AI1oLAoEMkbDypBht4CjdQqfciMnsTxxo8Jy rrL5mElLfJgZ424/Ws90kguS8uJgvQ5yB9B7UcmprF3Vz//X/iUgvo4kMYl2uSdobotW4JVmMK27 oJPMO5nGMn0B6YzXFyMqDSeo2SVJH8wApcK2wsDheKskNwRKX2nekbHgnvVqK6l86HGWWNWk3eSQ QckZT6Vn32pm6kWGezt7uBF3ZK4eEnjOfx/WnZIvRoqswwoj2sqrgB+ij0q7aRRmaCfySYUfITdh icc9KTimLRI//9D+Ji/1O4ZIzbweWkk7QyLODGIwpxkep9KZIjeTH9jlYyBsu64O4d+K4uR3BvU2 7G8jhxLhw33WBG3kcdKZqN3C4ExDC4JILA/KExnH55q3HSxUXysxo7jew8yRgGxgEdvWt2FzbW7x LKxSXg91wefwpxVlYqU/5SC3uYvMltwxlcDcryfdQ9hmsyWN2Zpr6UPhuIVGFxnj60zNtn//0f4m hay3k260/dC2UTY7ADj8TTH+1yGe43SP5LfvXKlQvv8ArXOEXJbjLWJZN9xJIu5RuDznKIfQfj/O pb3VdTeO2keeQypMkEZTJ2oG/h9sVLggLQuIbS8kujLMfOYMpc7mQgdTV+zczyNOlw0eCXEi8uT2 IrJw7on3ubyIbm5nZw858yZ5CqyM5YkcZLVV1DUQ7i2iVcmPy5zncCKmyWxR/9L+Kix1N43jt3TA VSm7oMDpitZb8KSEAAC4RW+XdXByN62E0nuVlnFysslwzQwQODhPm80n+HFU9R1C1u4/KgLRkERx RtzI1Cg+iJ5EFu7pGsTqNw4ywywxUbMTMxUCXf1JGRxSsZNK5pPOypEqrsJOMjhRWfM62966ABmm AE7r8wkwOASOuKpQkyeWPY//0/4spLg3ECRWOy1gikzLDKAJGOMfXHFQNMsTYkBlZk8tV2/LGfUe 9c0Y20RglfRFO6uW5TaVCrtyBwc+tQoAscE8BaKfd+8bGGx6Vqqb6lNyWhOXe3KyQxkpks46Z9Tm tixlkgsJbryYpjcNkEPny8HnI7fjR7MzfoQXeqQCJnCrJ5Z2yRxnL9Kgsr0Sww2cKJ9jDGZRKNwQ sQScnvwPWs5U0tBrY//U/i3nm2pLGqKMphmYA4HrTbG7S3ieIurJEm/zWb54R7c89ent7Vx+ztsc 4yG1IuDMIoRcSMWEqHlk5IOfX2q4NQa5HylQifflVdqnHGAB3rBwXQzd3LQdd36LarCyRuVO9GbJ lwew54H+FUm0+xl8u6jjW3nKBgwcq5cdyRUez8i4xexZgmvXnhmDM5UeTGcZTpgj079autO5QhkE s8QKwMzkLH6/hUypLZo0kuXY/9X+MqzVrhori4kRJIiVEOfmU9yB/nvVmaSxMLxSWsUwaUsVkQbX Pqa8F0vIiLuzN0yKOKS4lSytIIHLYgjjwA3Zs/09q3bPXY5YUtJYnimxuIHK8HgZ/KqjSVtUWQPP dSzlt7PHuHlr91Uxnmo1u11JRZ31mskX2zzBNvKSF0I2seenH/16pUoLdALFPo8Iu9OGmo/nyC5j uZVJRHU/MBnjJ96zLu2kjuZpWIWGcq0aiNcqwwM5xnt60ckOwH//1v42zcb7P7HHzbSAmWOc+eZG bG4knn8KqyT6gl9pDwRW09vavicTu37uMDARBycdeK8d0Y7pE2snqa0dtp6EzLaW1uyzG6ikjhWO RZM5LAgZ9KZLqct013HqU8ksNwVYPNcvgFRtBAzhTjAytZOjB9CYdTCja00eK8jsXuoLq7JW2VLq URKexyGzg8k/SuhHjGWMxhrONpUs/sREz7YZgeCSxPGPfg1lKhBaWKk3dWILHxlqsRMen2zvdQwr YxTE+VFbxE5KISCMDPQVFGZtN1V7XV7m5NvZ2gv7byJzdRMZsnaVznjJ+nas/q9LsSpzTsf/1/43 bu58+C4EMeLmaYOuoTsz3MaAEbEOeBgmhdZ1PTBbodc1nT47WIvFDpmoz28LKuCzOEbDEkjg9a+c +qw2sKUny6mjaeNfFUNtImk+KddsdQRy9veNdNO6q5BdQj5AyMjHvW6nxM8XWOlTRXPiDW3MiDzL 1L97eSIjqyony5P0PWsp4OnazRXM7bmnpfxR8VXllby3fjDxBfWVpG8Vl/aco8+PkjH3QSvpms+x +MnxA063sFvfFuuJb/apLNbeK4Z4J2lZgoRccdsk1zPLaD0UUYOTbu2dTa/EXxZFplzHZ+LtcUys WaAT/urc5z5i5GS3XvgVxl38UvHGn6odXtvFOv3uoQbS8c2rsrEj7rhNpUnjjI7VLyyg73imS9T/ 0P5OfCPx98b2GqzeItN8SeI9F8QSArf3v26QzTllwSGIIHU/KOPau41P9oXx+I7q6tfFusPe6rEF 1DUL9hqN1ct1L5foxx1HbjFfCvKMMlbl0OZJKXPbU46P41fFeZopLbxnJ9/Ki5s4zb2vG0uI+7H1 J7Vup+0f8WrXTodDuNesLi2iuXn8uMHTk1IlMBpWXhGBAwF4/Ws3k+Ee0Ubqo6UrwNDSf2jvjFoW n3ofxTOwupw0PkyNC0EbMMwLIpB2DkgnJ/puw/tFfGxtUbWtL8VXelSWbJm/e+OqMoPV2EnX0Hbi qjlOHh8MSvbuTu9y/r37WX7Qk9qNIn8ZN4ssXmEskBi+wZUjLMxQfMQcYDA47VjRftXfELS7AQ6j d2Vrp1u5lt4YJJJGSRhjewAGTx154q5ZXRb5mtRfWJX8z//R/mSk/bS+L9k2nlfEGo67owsxi1ul juoYHODH5EbqQFz14HTpWho37dvxysZ5NYstS03TtR1DNtco+jQWsa7ThHO1euODt29e9fDrLaXT +vwMJ1G0+YnP7bXxh1C+u9T1WXS/EM32MQLaXV3NAqgnGQW3E8kkdMGuy0v9rHxZFNLc2r26Ry6U izQWuosjyuxBeFyyjgHjIHbpUVstpKHu7k4SpZqNRXj9x7J/w8O8U+GNOkksfhz4Q+22NlHBbR6z eG9ivmIGdilMA8lsOR7Vw+rft4+Mtc8Q6d4j1Hwnp8z2sltcT6ZpM0MGjgxgFoxAyhcNjaeuQetZ 0cG2zqlCLqXsej/8PQfHFhBcLp3wV8CzO4DW8+tKitbsOMKqkk9Ac5HIPFcxrH/BQvxR4sglj1rV IdKMj/aLrw1pGk7bBc8BI32YPzepJ96t4Rp+QSik7JH/0vwhtP24tS8OW91pFr4fsNS/taNbW8mv ZSPs0HL7o2UnDg7emOg59dLwX/wUFu/CCSXmq+GdF8QWcInUwS6Y1/OxJygJ2hsY4OTjrxXwn1d2 LcUo3PYf+Hsnhy40HUINF/Zs0my1yKKJbfUEMf8AZkZJG5zCbZZMquSApOWxk+tYf8FBPhBqNlqm q6lod94c1jU7NIryWy0OVLmWccSRk/MNsg+XIAIB7983h5AuS2px+nf8FKvBFklxo0PgS407w6rF pbvUtBW76f6vncCBuAJZ/u5zxjFbo/be03VRZXdx48u9OspIyyWsllDHbkJyEQkAEDjGB/jUulNa DjyWska1h+3B8NdagRJfHN1Nbx3AimfUiLd/fyl+YAjoA2Ac/hW3b/t0/s6XFm+ka7r/AIvlS3T7 NOkOmC4hlIbGA2Rt3HkDtngmsnTmhJxXQ//T/Oey/a6+CtxeWUeiXktrosds8F2+pOiX0blcLJ9m Gfu5z1wTjisD/hsv4eQwJYL4g0xtMM7JLrk8bLdXKo5xuQfKpBB4XrjGa/NHSmhTdtYneL+3L8M5 byLSj468FG0t9LRbZ7/RJrdZ4mG3ZHtUyh15G4gj3rO1X9qX4bRafPY6frN35t7KJbm5s3W3sVTI Zc71ErEYyAOc49Kh053sY3d7k1z+09+z5qGl2NtP4q8bXDarOLOZ9QtRbaXZsq7TK8ZUsFPOMZPP WvT9M/aM/Zv8PacbXTLs3Fpp+nPJunvRNLLPjMZaLYMIxz8xIwO1S4z6GlpNbmeP2svAvxEtobTU fiFpfww0+zgdUtbO0ymqj7nnXD8k8Y2qxCnuM9eXtviV8MtDns49N+IR8dafeBgt1EYbecuDgIoO 3jJ5ZuOKSjUQrzjqf//U+MrD4t2mlSP9q1mz0OKWR44Z7bVbO8lt1GMs7LIdnGM4/WtvVfjN4E/s y5jvfiBa318gUwi1mW+a5zwSHVsdO5xivy7lmR7Sb901Y/jjbXGj6RHb+I/7Cg0+HyNHni22rXeB lpJSCCM5B3DOc9Tya51/j3rl6pkn8aahfx2szBQrG8gzgBC4AOPY5ye9NKRV5NHReDPipa3+p2ht 7GHxDqV0XNyL+0lgt4VTBMiSkqpbJH3uOR1q94r8VX3iKe9s7nV7i6ktLNmks5p1iig8w4AijByQ OOn5d6tQZUU2cnbQxaQbfSZdSg0PXrqyjF/qlmu+4ETjCxljlWXDHPGOSKbceLpfDOppbal4jjvr lLZRG1uI48LnCoXXq2B90Y7cVMqcjRRdmmf/1fmzT/Hljrzx/btc1Kyi06TzNK0+53mCffwZWHRe mMc+tWf7Qt/FF9deZcX9/bIpjR448WvygjKkcDHUdzX5d7MpU7p3Q9YbbwrZpO+uQIqLlLaS9Et1 IM43Mg6Z79KsWmpeH/Ea30WpSXC6jbjzLWO4tpBp6so+V5H7YyCM8e9O1lY0hBLY5yz02zvEuo7a wj1wF/Kuoo7fzUkLEhXdOu0EZ59K5+Lf4dS08PLa2+ovJfkSS28YabS2BJXLAkAAcHJIGO1YSvfU bS7HtXhCwndbjVLbQrV4XmJlmFmuoWzMMZOSCuTgd/oa2bfwW97NJrU3iOw8NSrdeZHarb7rq4g6 tuXGF5yAq88dqz5XZ3MLq9j/1vGdTa5lea4gu5pVFw0cM1yGRHZOAxTPGRg496q6Npd7f3kumWlz YW8U0iS3s95drbPbICfNkRm64UkgDoQPpX4/y62N0klodTYTfCi0V9GXxTexajDcyo17dILiwvyj YMi3EbEDoSD0AxwKnvdbXVGs/Cuh2trd6dPJsl1yCLdcIgH35nAyEJ/Kj2d3saKdlY5fTvHHib4a Xd/Z6Tc+GR5zF7a81K2F/d2ZGVlMLdFDD8CAKb4f1yy8R+Kp9W1XVlhufsjahPqksQa0do8YUY/j JUcD9abi7kzkr3Ot1/xV4eOp2Vxb3OtX7SKRqOpTGOFicADyYh0XAxljn2rlJr1vEd5nR4bO3tbK /S2kGr6mtklyzIWVfMOAWZQxwM4x7UrAnbQ//9fymS9021U6BYW3hyGSFXlki0ny7iHd0bLjgnJx 6mqqeFrHSdIt9S8bwy28eoXcsWlS3se2zt13ALI4xlR8/X3r8nOlSSRlX2q/DnwqLeTTPiHo63cE mHt9Jaa8urVirbvJcKAwycfjXFW3iLWfEFyNRub/AFnxGkluU09Xty/lFSB50mxfvY7MQM596hwH FxtqMW70e3la21q+vHczefPp6wGW2CHjLgdDkd61rG31e5gex0i8SzaWRpreWGNY3SInCnB/u9M+ /SkoNM1jKCZhXK6t4evtTMOsLPe6g6/b722dXuJcAJiRxzuAHP1qQW2nM8Ra/upIpgrzqq+XIjAZ ZevQnjOe9VKN0V7SG1j/0PmnUJPDlysJS9cHToikVo4K3DhsblXGRt6c+oNT6BenxLbXmjy6jp2g Wa7o5p543k1GYA/IsTKCFJ7kkEds1+Q+y8jvdVMij0zRrW5a1glSO6Rg6GWIFZm6AlvX656mrl5p iWM1tG95b3N8ITdSW0aZ8rGCuM5BBBpcriZVJorRQpbxPc21tLdLqEa3flTDBhYIMqoGCAeTg8jc axJPD8DWbX2mRWelXzN8thFEQnB3Nhe27nJz3PpWDi0c/O73JIvF9tpGjXA1KKXSw8qQS2rIS2oM SNu7nseQOlUb7WDcXEF0Hgimk2wqgjGXRVACH1yAB68VDTNYttan/9H5Y0rVdR3S2ptJVsFlDbm+ VVfHDBfTtmu7hltI9Nvb5zaNPHCRumQvJEAcnyx6nH14r8UcNdz0EkjmZvH/AIPh83SpG1/clsk1 5u0/yFUudo8sseenXH9axtP1K5gvp5rbSbdLpy0WmpqqpdLMhwUkIwQD/Kp5JLYadmb6T3emlBLp GjXV5dZdsyKbm2Jxny2HCDPbitPxTp3hadbb+0NcvdPuDbo50iQLcWiyMAd4K4Y7sjHoOopzvZGq jF7rU5W3kt9Ldkht7G+uIkCRXNxbLevbISCGTdkDPHPWux0rxM+lWslnFcmBdZhaJ4I49/2k/dII 7H3/AP1Vk3ZXHZdj/9L5tjsLTTYJ5mgnsdPhYyzLHIySLMSfmZV56nJ+proIrnR5YEEd5L/acOWK M3ntOH6Fx2U8j/61fhF3ax6/KuxzsNolq80P2a9Se5mzAEgaS2uAOWIfoMcfjxWzJpGtalLaWHhm K207U7qwle11DVbpYbbeoIxkjAOM4HfHemptaFcsbXMbTPCMdp9ntNY8Sxanq0U5TUL+xdJbaRwT kBwArDnGR6VcufGT2tve22jOttbLKujzNDGHgBx5W7Hqeckc9alVW3YVlsjO1SLVJ9B060+XU3sr j7ReWmkgtHOgIJKn+/8ALkZ9Peqs+o3uo+SdPsdTtn8wyNYSWLC9SLOF8xTkjgg5q+eQ+SN9T//T +Vb3WbvTruCK9tZLW3tgXuZjHtvYxgEgIeeR2rWj8Z3d/BFaLdXNzpar59rGyEAB8AEgdzx1yRzX 4R7SSPdlHTREcun6mN97EselPdhbZdQm2tJcx9fLAJ4B9TWbreoNqU8GnukPm2qJbSOi7HVV9x1O BUSqXZPs9dTpNJ0jw/bRveahqNpp91LbuLCG40v+0Iptgwxk9skccnrWdaaRYaHpQvzrkOqXf2iS 4tFsY2jgkUsSERCAVK8jnPSoc30KVGMh9/4ve5aKzs/Cuj6hcrbq7NqbNc3IdBlWC5wORnA447is bQLbWZ5dKttN1e20Ce9maC4mRhbPbvgnYpYjb3yam73BU0j/1PmjUZtS0BE03UtY0+81y4mkUadc ZuftsAYb381cqGO4HgnvXUX/AIfm0Kyt9Z0CSNI9XjHny2c5Uq20blL5wxA7Z7V+AXZ7kopbHHXW ptpNo8ekxnVNTEyQzrKNwDsVOHx0wCSWNbOmweE9cubmx1eS80O4vLfzw9vEHvGkTA2RM3G3684H 1NIIwutSpr934a8JxKtlf6nrd1HH5kGnrpskd3OcgBGYfLk+o4OO1VYtZ8U6xOuqeTaaLp0kMNvb XrN5DQMP9ahiblyFznHc/kSi+ppsejXfh7wy1qT9r1TUtTvbdZLbM8EVtGzqcDYAWHODgkHkV4rd +GvHPhuNLS21LTpIfKYanpQ/0i6ZpMFXLjDFfu/LzjPQE0GkNT//1fl6x8H+IbnTPtcltcSzWlun 20q0ljBdNwWCK2CSORxT9S8Uw29pp+meH9BnfWdRea0ntxCZoLdgMJ5IBLMwxjnnPY1+AxfKfSqD T0Zn2+keNdP1Vr+5VGV7OOOWzvVfSWt327izKw3ADpyOcc1s/bGu9Wa61i7EtlawGJLK0ZZYw4Qk OSDknOBwehNVz6DcH1Yv9jW+v2FjJf2TWNtJK00AS48ySfaxCsfTOenvTprKRWXTLWUAKQdqLwwA 6Y9v6Vm5+9qUl0OYuZrTS7+yu53aSeWb+zoWDuY4CwJLOg4wcEZwe3vVu88Vz20K6fb3Jgs0uftU yw26SvcO3HJK5AbAHbpR7XzNZ6Kx/9b5W0r4o654n8Qal4c1C2vdF0xobdILqKy22d4Yl2sjPjGG AXBHJJbPbG1e6XpNxpV7O9tbtaXMiRTG7yXUs+1AAfU4HI4zX89znzaH0L+IokWmnaa4tLGGzghj 8ieGzVV81u7hB/EwAyf5Zrm9Lisdb05I4rWVYhJIsaX0DQscdF2v9Dj61mbJWVjW0Xw9MkkSWkph lgfdbRvdCJ5W5+SMsRnGegPpV7UNPsftVzba5qbabqj2oWwhkXzZJZD90MM8DHf6Vm6j2RrLVIg1 i08OaFpulQjSrHUvEqIzTvNhLW7L8jzHGSh6YAxnPeua0aa8hiQavYfb1NysV7a2nzwxq0nyLFu6 YwAX9MmspSa1M7XP/9f5x1k6PaOlxJo9rp+mfKJ9Nu2a4hII+brySeTgevFR6rB4KvTFP4R0eDRL KaFMb7M285243cEnhsHnr3r+cE2tj6yEVynn2v6LqsqFNOCu93kWkwQiInPQnpxXP6X5mkahbNrU VtqOt2Uf+jlJGa2VV45PQn2pKpd6MtRWxu6r4stfsqTSW+q3upKoE9pDp7SxW4bP3X6EDnoBVkql 9a21hbx399biFb2SG8tRbS2WwK6qQDn0I5yeprWMr6MynFJ7GzdZFtY3U129jF5e540nAkUdOecj HNJrtu93aWAub22u5liNuksa+XcgZJG44xnB7Ht0FbwfQhJRdz//0Pj6w0/TtI02fV7GW1N5p8jW eoM/l74RIMfITkkkZBK85NctHPpEcSadcQeZBeQSS6XDJC5RHVlJdx0GA3Q+tfgPNI+tfS5098z/ ANiXUmm2UFqW06Oznt2uNqXpjKncF68kBsAHH41yeg3VvHbyajrA1qWd45bO0tLCX7JpqyRnIZ2I OcYwfwq+b3d9Syxf+Khq0Frp5sL60tXmhLmN2mhmlBxkuOByenbNduNBkm0q/vIvNWKxu0guFkiA MWQSTjqeBg4zgmsr2Vmx6s4y58FX+sXNwbW1Oo6WUku7MOQrBIULSlgTgMMMQASfSl0SHQtDjSPV 7Yadp1tC080cY2zSg5I3E+tRKStY1h8J/9H4ml8U6rBcapZeEdOm1Dwp4gtQL69ubCWWPS/LU48q 4yI8t5mCOSM/iMBdT1C0WW2+ywW8F7CEuZ4gGmkVeCqj+EnaMnqce9fzlN62PtpOyOSSTVtX1e5t tNs79rGNXJaJVeVRGOFPGPmx278V2Oh65Houl3Nj/ZtxffaCRdXN+rQLYON7I4wVyRuK5HBzjpWT kk7GSbWxxOo609w0ciz7oS52pFlwSDg5au98OazpsEF/bR27Xtxd2wgtBKm820uUYkD3wQD7+9Yz qRuOEnzWMLVdE8TarZ6bqlwl9pSNcSxXgikWG60/HA3bGJCsApU5zz0olEOn2ywNNPe2cbEyzTuZ LiQZOQWOTzzVwq391HWpNUpH/9L+KjSdHt00G21C8gjjWcNKlxDP5puVyAq7VJ29D27155rIJmEU bGKC4l8yaNQWk+TIBGenDGs0rSmmdFJ81mVb3Tkt7W1FvdPLcXZJVohhUAHyh/Q+uazo9bvYLWLT JpEKeczShk3+YWAUgn047Vmb21GaZO9vcpBAGkcybo1xuIJ7AV0d9PuSEJIJZ2QyXBZgBH7ZzQMy 9N1KWK4dvKDQmMiYnHHI6CtQ3oljt7az2QQvcfvHEYDqM8r9OtTKNzC3Q//T/hhmk8+5cG5ZbeNA i26qFUqv+c0611i2gRoktFQrMSk0i/6QMEcg+nHSuLkd7HVa0bkGoah9tkb+NXPXbjd+FSWmoyaP e6b9n0i11W3MhF1b3JxuDcHDdiM5z6gcVSgupJoxgaabqNd8Es8XnR7OQu45wxPUD+lVG1GC5ljK xjzIlAZcY8xu7YqZR5TWC0NyyfSbx7mG5k8hobXdBdIm8q5ILR4x9efWqGqamtzeqthJ9ks4oliC pGFaYqACxHvjNSld2G4pn//U/hwitlupoiQqWwfmTbtcsfvECkulTT7l7eD99DKcsXXIbniuSUVy 6HRZPcivLqd4xG5xGq4WPbj35/WtCMaYujJqVxctFdJc/ZZrMRny5Yto/ehz/FnjbWai2a8mhXSa 2tkV7SVjBcS4CzLsl2//AKvSrNxduB5bHZBHy7oPmwa2SS2Mmlsxltd3MNpshRJLeaTzXcDM8Y5G B9euParaGGNVOBKu7JjJIyfSmNRvsf/V/h4keESverKEni5ROR5fOBtPrSyWgkWO5LkSSLvJfknP PNc52qCtZmfIQ7oipjYceYv8Qq1aqRJGCgaOFyTLkZXvzW0PhREopaGhIrmKWaINJGvLbeWIqhK0 O9JkieWFU3MHXATHUH3qJRSMuRFqxNrcxTanbyKLpLgK1tKpixt+6yZ6jjmsa41DypZ5GBK3Mo+0 wo2C4Bzwf6VBDSvY/9b+HFsQMt5L5a2yr5kUSuGJ9M1sNq+lXhka1V7OW7to7eSMYZJygGcfUjPN YxjcJWd+xgy37wx3OT567BGYJCQ/pwOvH9KmW8hg02OOSSeKVp90IEQ8qVByRu9Qc8Y/GtHFbHOZ l7drKyuh2pkbcjAHvV2PU3020haK6inmuSYZ0CmSUR8EDPQZOPXoadle4DLjXmktJozAqSY/cuD8 yH1pZfEmoa9FY2U8Vmi6fHtE2zbPMvZSc84zwO1MD//X/hlnuI4htSMkBRukzgA9xVV9SmcMVdFE cYWFFGTu6ZJpPRM5yzJqLRWEZJBuJF2SuqfM4Pb2qoLhks2ZNzzNIEKEY2D1P61gdFuhsxX/AJWx fLjCqoLKBgHHoabcaoLqeBtiKqjDSFsNkdiPSga0ZeOt29pHqOUS5nurdYLN5DxEcjcePpVCOaWS P/SJI0jk4BVsMxFPubrU/9D+IqC5hjglhkVAIFEkewYaUnHBNYU175crSp5caykFiOBkVimk0dAt 3qEt/DtEpcJIHkAOASAQD+RqSLUxIphO9NiA/MflY+wrXmWwFKXUJlZiqMDEOZCdgUHgY9fpVE6j fRbv3aXMRAO5uq/h1pkz+E1ItWjisTNAsX2lnH3/AL6+uKfceIp5YI3dVgndvLJGGyP7y5pPbUxP /9H+FZb4ZuW85k2qBEV5dj34/An8qUXd0yCUTFYlwNpb55G9xWfLFAE0zuIpQAGjbJAGQ/1qJ7+V pHuGK71UL8oxjsKtW2QWXUlimkaJPPlQsX3DHDL74qtJJ9of5ZF+QYYA4DelRNq1hKKWxNBqVxbW 0kMJt44idk4+zobmQHGQJMbgOB0Pr60qajtR4RGFDchifmHvULRjP//S/hLnu5piFid8J1K8KMVr /a5JLYMshYkBTlduzHX65qOdAZM2prGw4dmxhCqYB/3qrRTzHMxY7ifwH4VLm+grLsWb7UUvI7W3 hiVZ43LXEpOMrgDA/U//AKqrRy3MWP3shjUnyoW+6D61Lbe5Moq1yZdRkc+VkBxznGSDRPq9/brM Flw86CLzGUSFACOgPToBR1IpxVz/0/4SbfU5PLV7iUlUIZFJwpbjn9K1W1g3QjMo2CJ9yxD5kcdh XNokC1V+hVkvpIZUB5tgMiPdt+o9qmmknt2NzbriBlDIWPzAnqD7UnyJgo6aGK15LGgkYmSR25Xt +NaKaxcHbNJsuJAgQo65Q4GFBA9Bx+FUUo+7cki1K6uCqT/uV6+WhO1fpTZJJFlmKTBlAG5W6sPa p5o3sHK7XP/U/hONxc/ejcxxnrHnGcd6jvbm4dYnaV3P3cFsnjiueMlfQCOKacOBG3kygZ3fdzin PrN1NOUmupJyuFMkjlx+BPb/AArXnQ0ruxNdys0aFJAZepI+6apQzyRMHLHdu9eh9ahtsGrOxYvL yTaoik3MR86A/wA6zvmRE2OzPK21y5LbB149BTU7Kwj/1f4OUvGt0lgbbKpGFZsnyec7l568Y/E1 owatLA0ZglkDgAl8YzWfONbkkmoeaZJZfNldTuLDnJPp/hQkztGyiTG4ZAPBT/OKi5rJe6Z7TSpL vVz8vy8c5rTk1K6mjiXLbVTGE+X8TU3WxktzNuZkn2xkBpUXKnPzimwTO6lDkcY9h6Uc0V1Nkf/W /g7ggkLu5lLSKeB3YVtW9ykayKSyEJgP6NXHKfY6DOR1nLmaR5HB43Ekj8alnlkhtZEErLG7DCqe CR61PMzGSs7FCNZZOu53IzuPGAKBOnm7J2b7u2MqcbD61fOhxhdXIrmWQSKu5nTuCevSrpnLR7VQ IoPC56D0p88SWrOx/9f+DkX90iSQQM0Zdv4GwV9x+lSOZ/k86aSVhg7l4NZRnZWAiN1LA+xy+xju UEnBJ74qZLtg+4dMfMD0rSM0tgL4uYo1YdXlA2uh+6aRr+X5V3HONrc+n/6qcaiTE9CBJ3aYJzsJ wzqMkU8TP5pWKTIVsb3H3hWiqJmSbcrn/9D+EZ7kxFQzs3zYGOQKa906l1D8sBkA9q05wV+pAQ1x KZQzLKmNvHXHf9KgluZDOrK7ZQ/LjjB9afOgJMNPueVWJVfvDsaZHJuXCYXHyEnjpT54gW7V7mTd LNcuDHkfKxUsAO9LL587b/N4RdxyeWFTKSaNoaRP/9H+DmKSe0kM8bESLyu1uat22oSS7gcrJn58 81p7TyNeVcxVeWdnkiViecnb70xZntyq582Rjymeg96fOimk9yZt3nExtK7sdwH8KfSppJLksYmz FIV4Yko2O9L2nkLkiZcUvlTtJ87sPkU9N3vWgt0csD95+D7VPNYlxS6H/9L+EFpyFMBYJs5U9AfY 1nxX8sZJBZWVsAjuKE9dGaQNaC5dlHnSlUb74HP6U157RJWjdpcGPMLIgZXYY4PpUuaRg52bQeeo 3IshUFfmxwfpUQ3TngvgDCjGAMetUZIZZNJJcNzuA4ODwMU+5djKsYJAB545J+tB0H//0/4OmLoS S2MHgioTd3YkCknY/THXjvRYCdZ2W4SZdqSRc7j97irA1JrxmW53MPuqccp2FBvFWRAFKT/ek+QA xuB6Vo3FzK+39/KWUAgk4xjrilfWwxy6tcN+5AC543qDk1uWVyFRnlMmQvDBckkDgCmNOx//1P4a b3WftJZigJSNUYEYIxwD/KuW1CdmHX5c5x0ApbI3au0XNLlJiZlkwOhB6Gqx1GVZSGlZk3ZAPQUx li5vpZthDngDaq8AU6G5uuRBPLARwSjFS2O+aLWE1pYoXEkweV5XeeRn3s8jli7E8kk96kTUbmBg ofCRj5ATw+R0oMpKzP/V/hLN/PLGDt8tgeR0zmqEszjO923jkEcYoNYKyHRfa5AjrNksc+Yx7elW /tNxK4SN23RfNnorEUF26En2x2jaOWViyNuKA8E+wpr3shAEUhXcNrAnGKNjFRu7DXuZkiERmfyw d+wMQob1x60+2mv1kM0d1LKZE8sxMcIR7/SkmnohNWdj/9b+EWbULyG4DCRlKNlgDnBBp8mozFG3 SEu/zEZx+lNOwnFPcpJe78ocFuo7AVdgu7iFmJldRjgA4Ue49KtT7i5Ikhund03kszHOTxVuW9Ec YkjmIlQbWGMgge1ZlGM2rzytHJM5XsABwQDWpDfs8iDzvlHLFOcAUGsYq2p//9f+Eu41OaRnKMDk 7TvGcinPrkqRJBtUhDkMGJ/Cg05NSpLfTOu7ZgnuDwR6U1b6fcBGzZI2ketBShZ6Fp9Wnh+VHIbb tZT/ABD0/Si11iUkMpdN3ynaSMVcYp7i9muhqDVTnCyq0mA2Dyx+tQSag8b7g+ZMZwKUklsZ2aP/ 0P4XpNeF3bxRThVe0J8tgoMgJ689eazzql0d4ySc7gzHO0CgLdCEapOVb95u+bJy3SrFnq2MPKWb a3+rB6/SpklbUai9kWbbVJfNaWSJTHuO1SDwKSLXrm3lcwiNYWffIuz94/sG7ViEoPqT/wBsyM7S PGVV/uA1F/a7GcYCcc/L1GKqNr6ijFX0P//R/hb/ALfuN+wfMrPu2Effb1P+e9V5717lN4IEivtK DpWcnFmns/Mga8YR+WykEcFl4I961rG8njTzVkEmV2FGUFD2yahW6kOLWjGTajIV8w7JHzsbH32+ vtxVe51aYgLubYVGI8/KuKfu28yeVJ3RctPEjW9rc+cpnuXRUhLPiNMHk4+lI2vvOsgKIjYBMmTl cdhS0vYdj//S/hXbVEIOTnjIYHlag/4SAqFhLv8AK3yFT8wrJKN99AsXl1tMM4Z1lUZKs2PNx/np V46+qm3nhLiXG11YZ2e6+4quWGxShIlu9ffy/KmDyKkwmSWQYa59Cyjp1PemSa3uKeVsSGRSJEHJ k9Bn2NPkRqo20RCNQSNj5rSDdGSFQZBqS11/7LeQSQM+F+dgwyox6j2qJQSWgpJs/9P+HfUNXgvI 1K5JVtw2kqEPQ5FJHqNpYQxbZG3yAFj/ABfiPTtXOBVvNZdiqpISPvIQ2BGfX3qZtUSVRC84DJH9 4DJlPpTasrgUotUW18wsDL2jQ8beeTWkvimKO3kyjHf+74XfIvI5ArSMVa7AbPrEDEyQq8fygFTw WwMFz6fSrMeqRG3MlwxIAHllRu3H3quVdgP/1P4d7XxJdabdNdRSpdW8yqklrcDCqo7ZHOP/AK1X YfFMdzc3H2qNLO1vcQr9mLSJAoI+fB5J9qnlQ0m9jKfVo45pFiUy2SvhFuOXkA7kDp9P/wBdacWp W0ksYklI3gEAAkJ+FHJELMkkvraRjGgWRgSpLn5WHqKqrqwshGIG/dxyYeNR8uB2H/1qzlHlEbB1 exvVcgiPYN2GON2etQWV5bxtOk6piYbUbOCuORt96kD/1f4kbq4s5klvLN3iEMwg8qQ4OcHocDPT t61GdWtWiHmTEtAPM3D7xPTFc4mk9xdKv1uWCyv/AKOshlmUHLAZ5OKs3c0VneteWNnb3EQw8RuJ CNo7jA+lFrbCcb6IpW2rPcXcsjqqoW3gDhEPdR7f4VsfaoRFmJljJYk7ex70rLsZNNDv7RhdIxcT ALEuAFAUt9apI88hYnCDdhQcM2AeDTtYLNn/1v4kk1G3haWWVzJOrhV4+XjOfy4/Wrr3UN4klxDJ uZflTcuzkeoqILS5MY8q1KENxIDNBId4nGSuepHTFaCmC3RFDo87rgLIcAGrCUbkDTwRxxwXF4rT yTlJBgCNFPQ5B+tXlZoJLKPT5V8nzNs/mFRA2eAfT8TQZuLiV7pIPOmdJI9hkIkdSHRz0OCKkknt oIgtsMQK2d5G2Q57YFRJN7GiikrM/9f+KmS5jvFXc7bTF5bsxz0GKWCKNIAQoO0Yc+oHQAVi4tE8 kQS8M8pzMn2VI/LRcAGMgnJDZ/T2qC5gjtlR4Jm2leIgdqfWs3BGai72ZX0x5RqAub1UliAAZRxu Gfuj8q6J1F+5jtdkRVS0YLhQ4AJ6n2HSp5PM2slsVtJe5uyq2xMUUEp86aXEcJ6gqWPGT2Hf3qWW UL5zojK6S+WEkGwtggMRUuNtgP/Q/jAjmt/tE06RguqhDKoJ3gZIAqrqplgZGlSUK4DqIx1B7kV5 nIrgS2yzQN5RBW3x5gVs7kB569+vSnkHzfMjZVDZAb09KpK2iAfbXzGU2ilJGk+TJYZB6cVBdWs4 kkcvJCbOXEpAx35GP0phZPcLpka3a2E5WSTbKrpySeMc0sd07opF4ZJkOyRZEyq4AAAJ4/8A1UrL qB//0f4xYHeOFvm8yRn+QAfLz2q/GLhF2qhZyd27H3QOorzxO9nciS685gfnXrxMphIAzzg/SqEt 2ZZTCYYzCp++W5YVLimtCYKyJSYpQtww2NbnMeBkDt0qMy2v70TwxTiWPYpkz8nIORg9/wCtZShb cs1bfRbuytDLkBROMiBhMFU8/Keh471aW0illnuQZnLqIwZeGCAfdx9cms1GLegrK9z/0v4y7gTR yqYzvi37GQnAGKtMrzIsUSRjzeJGc58tRk8e/FeSoMbRDEkdpLt3CQtjORgip7yRYlNu24PIN6Ky HDA+/SolBtaitoV4xH9jETbvlkyMDqT7fjToJIYrYxzxFpYpvNtrhjkJwQQQePx96z5HcnkRUs76 8heYQTviXpz8hq3p9gskk7XrE3Ug3xNCByf9qjkZLh2P/9P+N+V1srJ3lZGXlZM48wgdyP8ACq8u uRHTJJLWNJ32D7O75UZHAB9M8CvAcDHkkZun669xb7LqI297jDhPmiX3B61XaK7v7iJ5WItkkyys CBJjofpQqfkDi0bN2uqXGnxIk6TRWzsAgf5wmTgAd6taXdapEsrzSNslgEHk7RhgDnP8qtQVrEir LKZkeC5lgmiH7sJIY0GeCCO+B/OktjF9qlhvriG5lXiWGMjEAOdrHnrx9KfIrWM4xP/U/jj/ALXY RSxKmz7M5jjmWHGADwTVO0vbea0R74LPLbzl0KrmOU/7X+e1eIoJHLL4Tds9RtJdKazudPto3F35 9rcYJuYx0ILd1PHB6YPrXOTMJ1S5i5QXJSLzVKmTYegz6dayqRV2mOEVyJJGxZ3EMqS3kjeZMVaK OKYlgzD5c7T6Hv7VJZpcTWzxzS+QGXLR2uYEZweD1rOnT1OprlZpS3b/AGdreRzJJtxHJjeQegNU jq1mTHp8EclzKI1F1+52iDHO4eo45/Him4Jhq2f/1f48Lq3ZyJw7BUUsNvzFzxjP0qpZaleWimOP c80zeXu2gRpnvznFfN+z8zWStGx1lxfzW0NvFAyFpBuuQH9s5P4jOKZ51mwhmuVfcxxIqgnfj/8A VWbik9SYwujN8i1uWn89WaCTdm3ByrDnAOa5tvMlcWnnm1jjLLE+CEGBwM9h2P1rGUCUrl/QdLlh uLiS5kia2uFVHgUgxttz2I9+tdFLdWiTbokGwv5b7FGARxk/TFQ4LZoR/9b+QN9UhilWVZmEuwwl 2fG5eu0+3tT47qO8e1mlSO4MRJtPlzHGehwK+KdMzn2JDqtwmotmPfcRxeSszJlowewPpVSfVL8z AXN7NKIrrz0ExaaPIHC7e2P6Vm4LaxmV7rW7vUdLhkexOnxreCaSJwQzor8EjtuwOvr9KgN9Z38t /DJLMkd/sieZXKPJGmNsZx0UenTk1n7JG0L8uo06VpP9p+bLHNMNqJIDK6QyIn3RgHHH866a2nzu iIn8h5A8aRXMkUcez7nyq2OOKXstRSlbQ//X/kYvNa1ewlENhdXkMF4hhcQTbfJB+8QTyCcckcms S6126I+wR393MCY7e4UXTxEqGzgEenPPXIHNfA+y8iIyuzpU+IfiHR3tCPEGvSh3EawzX7ywIAOn OcCrVj8R9VuL0uniXVo4jL5txbrOVt7hxkAlAMHGTzTVKPU0vpYTWfiD40vru1Fr4p1rS7G0n+0Q W9hObMStjGXx1B6kdDXQWHxn+KmlQXUWk+NNSspLuFEEpjjkn3ofvb8bufTNWoRWgXaNy8/aA+Nc U8Gpal4rtvEM8titqZ9TtfNuICvyh2bJ3HGcdOtT6D+0N4msby6miuLRdTjVZ2uJLQ/Y5m46ZJTd 9Bn61MqSZXOz/9D+ZnxP+2F8edS07+x4des7ZLqFUszHpSJ5GCMq8gAY5HHXHtWDZ/tF/F+F7FX8 TyaZb2y+fcrp+Y7a+nAxmSNiRtHJHOc18B7HyK5mlY3NZ/ai+Kuq6c99plwthZaCokvNTglX7dMS dhkVAuCS2MZJxxwKzYf2t/jLZTWgt/HOvagCUkkkmuPLS6DH54Z16FcAA7R0NZyorqVBtuzO9f8A bF+L13YzqvilnvYEZ0W3tY9PhUdER/KUFgOPvk5/Gp7z9uH4uaLo9hZyNZLZ3FkmnahFoenJa3l4 zcMzybGbGCASpXPORyc4ugr7Eybuxugft1/GjSNPufD+ga/HpGk3k5R47pA8QTnCR8fIeTllwTXd +Gv+Chnxd8JRpY232DU9M8zz1eSJLmazm/jWLerMVPXnoemM1PsVbYk//9H8HrL9vj4m2d3DqetX Ph6W41KSRtPiv7PMiI7FmXyyuMnn0HHFP1D9veHXLOSx1nTdOF8zPbpqNtBdQQxqSc5WOLZx/tcc 4r8v9gbx2RE37aumaPp1vpUHhfSbuK3QXKXcMsiyXYK8ou0DnjcU468Cug0/9v8AvNKTTJ1tbnSd O8S2TWOoRaTBJK0IXozq/IOCwwMEknpzT9iM9P8ABn/BQr4dxfbU1jQLvXp7TT2tLHRk8PwltVMZ 3LNK0yfI56ZDEe3esHU/27/BuqShE8KWPh0yMlwiQWdwt5bN3Rkzs3f8BxkVLojaWxci/bB+G39m 6LqA1+WfVbu9ubO60yVW0uaADhWOeMHnn8MDv0ei/tdeDLjR7yxk08atDDd+YLOPVERZZFXClGVS M+m7pzkio9i+YR//0vynj/as8G3Xk6hpWmx+FGhUw6xcTan/AGu0UaZ3sUCcHjOUJ6dq6HTf2qfh 2LLTptX8e3WvQLqEt0ukDT/7TZ4ZAcLGjyL3x6kAcg1+ZRo6AdVb/tD/AAXvE0k2+jQ6YDJ5k2pa jpxE8BY87kAyQc8gdPetPUf2ofAnh0iy8M63YNbyz5n1q3s/s1lbluHQIxDkjnOVx6ZpOkCOV0/4 1/DrWV1LXz4s0ySCCZbS3VrtPtd3MzAHK5JAyTknOM81z2s/FOO41y2TS9QmstQtmMMM1hqQe0eN 1zuDg7GGD2zz6Gq9maQe92dHpnjPTZXnlv8AWms4548XF5Bbs/2mVQvy4xjLDqW9BXXw+K/DVxLe JYaxbyQx6erz/wBoXsFi0J6kqC2c5wOPUCk6ehDd2f/T+EofE/hW2t/tt/f2szw24EKW17C/lq7B d0hDEjoOMZ5Ham6Nrci61FLbT2z2N0nmW1n9oi8++Un7yc7icA42/lX5Y6a2LUndXOot/E2jNcXs 189/JZwy7Y5xar/o0g4MchzhccdTn+VbWieI7PVLq2ttFm+3XE8vkJa+W63Me7ruyOmO/TAqXTYT dzur28WyT7Bd2F1HepKBvUHCg9sYwfqDWTDNaTyJeWcdxeQ26sbmRIwTEQSG24J4HGc1j7NEJ32M 66m07XJJ59a0rRbfT9OVTaNe6tG15fMoyAkJwdwyemfwrPk1XwmurWMcGpaRZw3kqCK3uopHkhkT 7yk7SFJwcc4pezNYPSx//9TwmXUvCTRLrNxdzSXMDvEJtPLPLJztAaIcYzxyCR+FFpdz6hbRx2ul WVpayI3mai92Zgp3ffdMAL6mvyN0jui01Y5/WbO7xJrGrHTby+02wMVhBC6m0v0jfMZZRzwGzjJ/ GsDTtVu5rSKbW0t0aNt0DRjL7TjMYIHAHPHYDrziodId1sbmjLpMmo3dzmX7KzeZcSM+6WNFH8Iz 1x2FaN7qvw/mT7fp3hy9vr3H2eOTUL1rZZVGQXKkZGewqXR02Li0mjmJ59JutRsYtE0bUbBp4wl8 v2eSeO3fJxukx905wGPH0rpdY8L6JFb2902vSpq9rA7vp0VwiwliPlDD72Rj+dYyomjkkf/V+UdH SbUHCahKbbTpJXgubiQH7Pd/KQdxUFiQD09SK6rVIPBljY6amk6ney6okmJp4IHtx5UfSJmcdCMg 5659a/FPYeR6vOuhiaWfFWv6mv8AaepnTPD1jMyWtpYRiZ0gb72525Bc4BP5VN4qjMl1Yaf9tvxo 8hHnpC21WVSRtODwcEnrzk+lT7BC59DHlHh+x0W1srKxlguLC8llS9eTlInHTBOR79etcVPILdIt v2yK3N0rjyIWntbo7s75GAIBy3cjg/nHsFcOfyOyfXDZH7LpE8t1drs+2GANGkUb4yQfUf3epxx6 1a0y61OzkmubnU7xklhZEZZDFPEGOQGbqcelHsvIfOj/1vk0x4vbq71e7nfTbmRZLkzDdKwPDfOc 53H/ACa6FNFnk0+RtCt9NttItF3xSTSrHcyE8Bc9W7cDOOeK/DPZM9jnVrXMW+8P6zqTada6nqWj 6dbRH7XdzWV497dSYBMaAYAB9QRV641C3s7CL7HYfbNUimQGWU+VII1b52werY5xjBqJUn1NFPuZ Xil7ZvDzNoV1NPr9wyOLdM4iDtyMMOMdx05NbNhf6teaRbaXBDY6TrUUgaW+s0F8+0BeNjgqG4YH r1/PN0mbQkkjF1G2v9P1K3vZQb26BEurX9zCYYfLBwBtTv37Dmt976z1u5S6ttI0+wujhbZ40LSj YuC4JOfm/wAO+aXsmF1rdH//1/mPxIg1y0ggNlZfaLZlhNztInjiZgJeeScgfTOKv3fhrUDpmm3u neJoG03SpRDaaFNfRRHCxBCI7cHd0GSTnpX4C4NHvu2zOh0Lwh4j1tWl0u40vQXv1Ju726fFqm04 DSjIbnGAPyqPXINc8Oa1HHqF94S8RLbwJHBc2elmBIpAuCAwb5jgdfr1pWa3BW6HLeIZtbE2n6xb fYLn7O7zW+myOI0Zx820nrtyOFPeqfh46r4xtbTWdYurKyhjlljudGt/3slvtYhmAPTkde5U0hon kuJXhnt7djEclDKi5bjg49xj9Kq+ZFYJb6rdsk1lGyw3DvNsmgGckt3PC/n3qXzX0HHRn//Q8H1P 4j6lqVr9nwLhg4e1vI4mtz5Q5TAJIOVx715/4f8AEnia2vU1DR7HSjriXckso1SQRQ2b7yVKnBBI +XnjIzX8/a2PqU+qN3WdT8a6s11qHiCayupdRQQyzWFws0dsQR8igdBxgen41maNp15PLdWX9lTW V79oQedKFCXGc4K4POeDz0z9alxla1wb01Nq7vLyxivkts3v9krm4gQeZ9mPTaoB7n9TXHjxC+qr c6jY3V1pmsRy+TqFtLb7Z7KIfMoXkja/zc9cZH0hxlew4vlZqf8ACOXfimW1NtHfGZPme2jG1ZX6 iQNjp1745rB1W4v9Mtr5Z9EsrZobkWvn3wIvZ9jDLHnhcdvftSaa3Km1sj//0flF9Ku/EWoadaSa 1d2elnynvW0yET/Zo3VeVXHy7dwBPsevSuk0vw3qto1/YWuo23iS3Fxstbq6KRbQjbkkYFsZGAe4 BHWv51le2h9E/iPPdLnNvquq6VaXL69eWUs97fXZ/eadAd5Yxb/ugrnhRnOD1rR/4SjT9DFsmqWd 1dy3dk12iwqywRy79ixq4BGSBnBxwOtRLmTNVdrUzb3RZteu7vxDFfQ28On+W2n6BdXDRyyoeZD2 5yR7kD6CtDQfBd54k/s6/wBNv7nUtWm1KS0me5uFtNN0krzHEgILShUHUlecDFQaSTVkal54Tju9 ROm3r3dze2ykzxWXzLdEjcJHbqNuARjjFS2mnPGwg1jVnVVjSNZ9MhRAwXb5aup6kDCtjuKwd72Z KTex/9L5p1m8jkhtHmsZ7uJsRpHOPLliVcqkuO3T9a4W61eaxt7WyeW4u5ZbmXYJdiLaxkbkCgDp xj8q/me3RH16VlY6vRtQabRoBrGqeakV3JHYWFrGodIhgFSw4ByG5PJOa5X7DfbNRk/spY7AzFbW 5nfeS7MWGGHf/OKqMW2M1bLW5rW9gj1axsI2sY40mtpoPNMgQDZuXAPI6+orU8XeIfDEd+lxBbaR pa7Fulgs82QnAUbi6FucHI49Otbx3RjL4mc/fzw2Fxb+I7Cwa+upIPtcemXsbC1eMnBWM9BkHIz1 xinPLc3t9LqEZDRXBiWOxSER21uwyWwvXnIGP9mtwjbmP//T+CtdstZ/tiB47CJLeKR5U01h5JuG Y9VJ67ccA8dfXjokh8P3ktpdXt/d6M1nbmO7jMYntpmcg5UZBDfKO/HNfz23JRR9gbGh2Wl6Dd3G pSeK7e7mv7xp9HGtRCWQ7UGYljRdgHBPOSc8nipp9Q025ltJNU020S0j1Pzb8W07W6NCw5k2jp0O QvrS53sBzU32WW3Ftp4aKwW6ae3giz5UXzEgj8OM1bbxFr0l/pWj26z/AGYW00uqXdvl4b4sFCLJ u53IC3IOCB361Lbe407bFy68UzWNpaR2kEksC3jJcvBA0kgXG1gQOcZGDiuO1LxPo3iDWy+l2mrN o7RrbFpdGmMDyjCygPtIwpBHPvWTnpZGsWmj/9T42u9Q0nw/pK6Nov2m5aBTcQWTo8VkxkP74biS AcsTg/yrk1s5L2J5yfIlkj2gJhlQ/wAu9fzXU6H27kloxsljHZ3Fm58yYui+Y2nyeWVI9fcbff8A WleK41qS7li3yxW7LAglm8yVs52hk/A8isyU4t2scqnhZLa7vZpblrRfJBWwlHmW8LZGdgAJBwc1 d0myu9KuPOhv/NeCZnZlhEWY85Q+oI4/L3rB2voXCKuad941NvBLaSavZw3GsMrC0mVjfHaThiCM AEk9T2rKg07W7+3ntYXOFj+0XITYolCc5+bnj0FXT3OjkXsZH//V/jX8VS3nhSxjY2cEmj6TE8Ml hp8YivLcEKBJuAwytkDuRtOcCvn6TUo72B5pPNS4mcNA5UII0OSRj8vyrljJylJmlKaWxnRalLbL cQI0T+fx5pGXGP7voadYD7Q4+0wRmN3yk333yM9R71R0xldsW2KxGaS2nZNSjcrbcCItzhhu7cZH 4mlupniXyI4gksp3SIo3uSepPt1oLIrJdtvfk5eaSMbFyfkAYEgfXHOavXNzZXllbqsAtrq0+c+S CPMOME5z1yP1oM2vebP/1v4N5bw71ktw4OArkj7xxyau3VrcvNb7mO9wF29F56ZP41z2Om7tYsaj dZey0y1txuizHLNF82WzySemB61tRxWulzhJLiKeZVAMhkB5I4wM0Ct0C6uj9rCTgq5iA4HO08g4 /GqCRH7Zm0iIlJ2Rjhy5PHC+pz0rOp0No3tqT2saWbSGWJlEhJcL69Mn8ulOlthsa6tFjZsZO5/l BqI7oo//1/4WjOS0Ej3MjXYZv9HRf9HVcDo2euc9u3WqVpc6hdTTszllEgJJGBFjoBXPbodihr5G y80PnqJWZkxhmwMjjmkjtk1W4ksY54zaWwN84uZBCuEGSBzjnpUxjymhhXNzNf3XmOqqY1EcEUZ+ SJF4VR9BWzezMmkSRtbs0SxB7i6jyWiyVGSR0Hb8aolxTJtG1ueXfEtgLYW8YjaZ1LmdDxu56E+3 rUwnkt72NY3aS2BaTJQN83UAj2NBVktj/9D+GYvlZJXY7d3KAZJ9KjbV7pQI4bdZYFxlzx5fbJrn PQsaEV6l0BbRqnzHHy8DNZ8h8t7qzjlxGT8xUgsCOoB9Kd2tDOUeqBL64skHlIRC6lXJc8t2OPzq FpbhI/OLMI3HMIOVb6jtSMZRv6jYbucKf3UcFuB99TmTntiorl4W2zR4ZQOUI5agxP/R/hRFyjyr BIgW1lG0d1H51AscMN0svz4QlUXPyc8ZrnE1dWNNSsgDqn3Wx/eLU3UnZLmBLtnaOGEFFkGBGp5w BT1ehjboTanFbi3tHsJDPbSxebJ5keySE57/AOeKxZPkwp28crihaMai3saFjLEdwlhErMfkz0X6 j0qG+jCyxyRrHGH4byuEUDjpWqkhWaP/0v4TYp96GMbmC5JYjioBA8jDy4sgnDOOAv1rFu5ioy3R oWSxCaSNnJfZ8pbkKR2qVpmR5UKKIrjCthQNpXoRUmxCrM4aNs7l+VW9acrRRwXDXARRCAwZuHPO MJ6moUm3YqKd7lR2s7pD9milXysLuYnMrYycf/WrMM81w0EZLotu5ZFzjnpVJ6tGx//T/hUtZ7ts QqA7M20b259h9KlvI4Uk8iR1MhPzqh3xowPTI4Nc7djoKLyyWvAaMYOSE+61SJcEAGVMgjlh1HuK pLUyk/eEjm+0PJFIsh8xB5Tk4RCCMZ/lioftbQRyKMM4OwHGfatFdaNlSfulfmEFiu7ev3fQ1Er7 igduF4G48j2pNXVzI//U/hGZVTDCIGTaQmScMT/kVXhMob/Sf9Yh+aJeQo9KiUeoF6AszeZv2xfx Bx0+lJA9qBOZ+x3AHksB6e/tUKLd0Bctpra8lVQoSLy8b5Fwcnpkdqz2QRSvGAPlYgMv8XNJq24E 80aRpvJADrj7vzbqyDvLHHzE/IAvXHtSjqzRQ01P/9X+DyKVoWjSNzvP3w4x1z1pZ7kI37mYyL0m ULtXPt61ko6opwaHQXTNHLHtV0bllwCcUXNxsTCIsarjAIyTjrUpXdmSMt4pJE+0RQ4Ve5/iqSaV WhcM7i5J/dxxx5Ax1ye1DVnYTV1YzYZW8whf9YBzkc1YPmS4LRs5ztTI4OO1ElZpImMWmz//1v4N pfKWEQsoV+cDqwNFqzFAqncyk5JrhbuhR0jykZZ5JDvDOivt47c10r3w8mKFVK+Ug3jbgE49P89a nyLTsmjnpZd7Y27AxwoIqulzLby4EZI3YbIOfyobtuK7SsbUEkdwkznIePGdv8OelQ+ZN5G6SLzJ Q+zdGuWI6Amo51exf2D/1/4Q7SSd3dBHkqNzlweBSSYZ1JJ+VslelecmnsBE7+dI4GVyNq8cVC0B hTLDAHJbvV8z7gtBvmY3AyALtH3uNme9TGE7MscqO45BqbplSTu7jrG2aaXCDcrHG4c4roGsFijZ THgJ1cjg0X00ZJ//0P4Pp4FU4UbhuAZlGSuT3Hp70wwyeZIiAOsX3nA+X2/OvO5/MqC94egKMo8x lJ4AA4atWaCBbFHgW5e6kZhcAx/uo1427SOfXOaFJdzY5tjNG4jAzuPp6Vr2TNJvgxzsyzgZXHSl zK9jKLVxP7OSBjLLvQMflIHpVJmk8wpbRl9nJ4zmmpJmp//R/hHijlV082F0GM71GMUyS0mmcRhm IJ4wMZ968xytodAkNhIjvjeTEN2zHzuecDFZ8z3MbSH7ypy8f/PLPfFJzfQxl8RZjW6ig/eAqZV3 K2OcHpVBI5WkMaqXlJ6Y5A9aXO+pcL21JxDLbztHdbhIjYZPSrMsbF9hUoB0Ap8/kZvdn//S/g7W 3lgkRmgJwdwJU4b61obJQrskX73O9l+9sH+TXm8ytcDMlaTeqzLufOd2OFq/FZLLGQD8/JAXgvWk ZW2AzUhlhdOGbYxOD1FTyK8jBghGeuO9NTa3Gk3sP8iaI74/lLLg7uKop58p2qpT5umME0+fyGqb P//T/hHitXCEyD5AOTisy9RTIrW8cgwuJWXLBj6n8P5VyKaNPZ+ZfgZvsxfbtZlKo5HNU7a2kaR9 wZ5MbkUqeR61oqnZjUEX4IL1I5JR5otxlZVRMg47E9qp3cEq+UyxybCeSyFN3tT533BxVtCb7Pdx or+U6xN/EykKfxqY2dwW2oTjy933dvHoKbleNi7WP//U/hEWyPls7q6OfkRjwpqNo5LNsmMkuuCM YOPWseeR0WGMs6O6pBJkKGZghIAPfNVBFMXVjGVJPDsOv0pubtZAIrzxXG+N5BKjAkKPuY9vwrQd kuFkuJnkNyORnkH1NQ592BAsZhlIkRg7gMEYYOD3pzxkMW8rocBQM5qHNdAP/9X+DyCGV2MjRFlz j5l+UU0WkouSBCSp+b7uVxXHzlw3sSXERiZgflVhwMY9qqmEBohPKYEznOzccewrKVTRo55qzEmS eORSFLxMOJFHAA9fSp4xceV5ilvJBOW9cV6St1BRZFZS4kIjGIy/LDufSr7lVlIeMhmHy7hyfpRp Y1Ssj//W/g3uGEcO5DvMj7Qo5IP+RRFa3bKXaKQErkMUOBVxUd2NRb2Gi1eML55Ic+owRn1pFgkJ wmdyPhuOag2SsrGhDlnPmsywqCCyplsgHj9KYkoKlShBBzz3pJK7GR+Y8aho4wFVsliOatxXU5Uf MfmbO08J+VMuMbo//9f+EWOaWWd1IEgxgjGcn0FQSwyTL9zA3Y2d6eljs5G0mhhxDEqIJI3BxsK4 3HpwKgjs5d4DJJknJ3LgL+NIPZvoaX2YKu1cNIv8I5Ip0LMCyPES/Y9ClBLi0QbXaRk24QHkt6io 5JdrJuVGEfCMF5GOmaLWIcdbs//Q/g1Ny0zkqSXzlhio3dpHyRwPlK460G6VlYtYlhKqOEYcZGNt WlDLD5yOCVPzxgZLUDIJpI4X37Bv27tp9TVAS5fc6k/xBF4zQJJJ6F8HzU6BGXnaaDLMsYEeFH+y fSiyRM1c/9H+C9pWZwpH6dcVYWEyoXKkHO2MA5J+tA7NblP7MSGLEoQcEdCauQJM4RMBgPlyD0x6 0BZ9CeScoESaNVIfasgHIqB3iRX83LluF296ClB9RtvExLFkDKRwSOgqzb2ZJMhdoYySgHOT68VS jd2NT//S/g5eNEL87sH0wamig2QeeBGWDc7hlhWjh2OixAH3b1xtbrwMgUkP3GZRkLjdxg0Rh3Cx KFhkuUym47eM96d9kKmR1XjoOe/tVKKiFiushS4QhRlBg4H3vrU6RSSSbucsfvNwoqHB9BNaWP/T /hAWBg27qMctjkVG9vKoLBt+4/dJxxTasW4vUW3s+B8nzEZI3fzqJ7eRHLMpjCHGPWpauioJrcf9 oIGCeO46UyKSNnAHBB79DWPK7FNXVjTSZIypkiEygY2seKq+WsbMw6P90jnbmkCVj//U/gvuGaKT 92xLKcqRz6VcsmdYmk2gDOWJ53VznQIszGUsg3gn5x3pHvdkmxHdVYgCMcZPeqiruxE9iNZtkzBc njDBu1TAMYy7A43YyOQKXK9ieVpEX7kxuhDN2RhwQfX+dUVSYrIIwzCqULhF2R//1f4NltnWJXbJ 2KC+KrqYPMHG2TPCkdajkRUZcpcd1ncR7AGC/eA+7Ui7oxz91ehIo5EbDLi5nlKCWVpERdsak5VF 7AVFbyksyqmSx+XP8PNNwVrAW3eTcELfMSF4/KrfkNGhkypPT8an2YH/1v4Qw/Ijd9jE4JHOaiuQ 29l3NKNm1XPGOnT9aycGBWt1dXWMb3ZzhSx+XP1rZLw6eUFynmTMN37tgxX0B54p8jsNb6mcZ/Od scMTxngVLFHtcFucdQehqkmtA3ZbmlVXVN4LsvAA4GKVnHlBQSE6OoqrCP/X/g/MyqGjUeZv+UA/ lS7JY3RUO5VHzE8Bfag3irKwySQK5OTwMA0+Pz4wJA/3wc98UDKnnPvDo5d1OAM1qC5leJYyNp6k Z6H1qZJtWQuVXuRxm4BYtkbRwR0/GtfclxZjcXMyHgY4Hvms3BoOVdj/0P4TZJpggiJIBYcE4B9M 0YMZZlZSrcOoPes1HQ05NSL7Xc2zlkyoxxgVJHqlxISsgZl6AdAP84o9m7EWJvtMsQJKMM/LnPBp q6kygZLDHA2dz+dSou1was7EN5eSGaORZ5GUqMx9EU/1rQ0nWJ7S7M0P76Rl+dZl82NB06H6UONk hJdEf//R/hae5VCY8bS7F2weBk5/x4qmNUmtpBHlvLc4JB44qI3SsVy6XY99amAJVi7K3XGMCoLn UbqQK7SNjAK4P3fTFWJqzsMS+n4uHbL7vmLchhV2PWr1om8yZo4sFY0Q8dgeM8UCsXheslvHDHiO ML8w6ZPeqqaxdWxkUlZ42TaqOD+7x3HNHkWoXVz/0v4U11K7blZXVScqoPH1qZNcvgdpllZ1bPDE Y7UF8jLMWvXUcMqwGKHLZLTQLL830I71ANduuWfMr4wiEnYp9R6d6wsxqD6k0PiC52F3KoV+UoDx T4fEk0S5EjSyFj8jZAFHKx8iKraxfyRSwPLI1vJcLcmBmPlb1OVIHqDitM63dXILXMhiCDK7fvkn 3oash8sT/9P+HFNdurMwiNmlQEsVJzvz71ZXxPdSyq9wztPEwCmUbkAHQY9K5eSJtyxXQ0JvFU82 8MI4mAG0Kh4HTr0rIGtyFjE0rlGOWUtjPrimopbGUlZ2Fudct/Nle3haMhFjiy+XjIIy2fU4P51d tfFM8cV0Lq4a5MjB975YjgDGep7n8aLIRVt/FDI7SmMOyg+VkdPTFObxd51woaFI4lABbncG7nFH Kuw2rOx//9T+JC28SC3cXAAlgHOGOMkd8VPdfEDcLiCxRozKEPmvGBypyVB7A965XGL6BYlvPFFt fqjLIiOkapNAOGiIAy2e4P6c1hNr0YJysjxDOGXjOOlDimBetfEjmJgAWToUfgj6Gqo8RCY3FvOk akjCMpyMf41DhZpIDpofGa2+nwWS3UsiodvlH5RF/wDWqZvHGmRxXBuZJzMYGWC3tV3NvHAJ9Bya FTsB/9X+Jv8A4ShGjTyUlO1MsJQNxb/H61Jb+LYoLeeduLkjEMUg4Rh1yPf8q5ORAZ7eItLljvtU uJNRTVyEjjggINo6A5OFzwQT2rsf+Eps7i0tpbh43yojwD++UAAZI7VPs1sOzW5nR+IrcDfG6ooJ IWTAyB61TfxP4evHht724vUJk+Y20BZNuPqBn2NR7LyKjC+46XxHpgu1t7Bo5ba3jHkySL5bMw6q y98fWrNr4jsUkf7ROyTlS0SIp5/HsP8ACl7K/QHBpH//1v4sZ9SjuZ1ikuoHG0SokTZAB7PnnitO xu7GOK4ty4wOdipkTewNeY6aAifU9H/tNIdqM0dm0jOflRXCkhW7E9BjvVuy1jTZrSa6uLq1iaAK pslk3Tknj5F6kD1qXC2wnsO03VbEySOLmBIA29hJKsUaDPdjgZram1rSHZTbmRYwm3DFWUt3KkdR 9aapNzutjKSszG1XVLC2ijCuvnyuWDAgDH1/pXNxX9o8tzcK6pP5ahyzczAHAx9MmtHTsrMk/9f+ M3Qb+G6tZmk1C1VhOYprWSZUDIOQzZ7cnj61Xk1a3v0kg0eFZESYxFbdQu9xxkD88fjXmKCuzmtf Q6KzhV4LVp7rT4kkgLmeW6UNG442MvUEn19qy59QtldnkltpBHN5aBHAOR3AHb396ynFOVrGkdIx RqSLZRyNcz3VvDKYQjTRKs5UMAVCAZ9un496gm1WBLbz7ZJ5YZcQxPswzS9MY+taxoWZ3NWF0+7S WB1RkmkT964jkDmIHu2Dxye/rVN7iWA3E+wW8U0i21zc7SxhDnJ245Jwp4olRJSsz//Q/j4sZ9Ma 1XT9M8+5wSIJXQo8h3YUEE8EnsT3rnb28ktV1KJrLzLu3mb7bax5ZLbYdrYbvg5H4V5XsVsbvZmn ay3N1p9tfww7IJmCIsxMTDGN2QeeAa15NyrIJNibcAbjgA1m6Iou6MuC48maX5wytyFPKZ9RTLby 7q+cMkJwf3UYO4E4549etYuiYm20lrqNumkR23kzC5EsNzGWiuYygO5OuNp29x6881iajczqsFi0 ccUm84lgByy5wOcAk8D8zU+xA//R/jjaztLi0mRnllVYttwVGHUnPCt6nH1pNIlbTpkuoo5R9nx5 dtd/w46ce9fNvDkTWhv2MN9Lb3msXR80SXDAsR5aoTk7RnrjNYdrFe6lcmSJiwW4IWNF6r25/vZr N0DI1YprWH7Rp+pFriaWUxpM0w8j6dOf0rDGjPDqUBEoWBJGElvGPN+XnGT26VP1fQ3jsjXL3FtF GLsxraLMziOB/MnnUHGOmVOO3860LKbzIiyoyBpCBuPYdPxqXhyZrqf/0v5Bri/sbZJPtExT7NCZ 3AG5iB6Ac5rlcp50WpRKZLG5XzVdh8655GR1H418n9XsZU9zYcp4ggiltIktXtfkZWyGnKkjec56 4+lY0OlS6bfXS/a472YKpMcOPLtQ3IB9/XNNYfQ1NedHujHKzmBoFwyKf3TH2Penb7hIi1wsUcaf ckdtjkZ9/wClUqGgE/nssCzCOK7t2JDQbyA20DPzD6/pXLouoWqab9miRk0++N00Uq/ublW6RuO4 GOPpQ6A7aXP/0/5Dry7fUvsiyBElR/NRom8uOPuF9Nv1rAvJZZg9vcNmB3xKE58xR1H0r5L6v5Ab cDAaNNHYQo8TJskiaTy49g7+4yBx7Vyt3dxiGzgCbJ45/MnlAwoGMbVNZyolRdmdHpeoKsBkt4I4 nGVllf8AdGbbzhievt9aLy9uY72NZommimiWa3VMBEYds9/WspUCSvrNgjwJcSkxGRxOY8/OrHnI Pf8A+vUWmTC2ilaaK5KwoJPO8ne8vb5iMD3qfYk396x//9T+Ou7j/ta9i1GWeeW/tkxbJKxaBIx9 1QOmQOPxq9NYteW6wSKsEi/N8pwGY+/px+tfBugUpNMt6vDFpul6baKn2iVpiyTImWVscg46DAPX 1qWO+uI4FsRbqsagXCuw3MXbOV/z60ewNOeIPdLbxtcWN3c2mqZCyqkaMAoPDDOTnr2/GtBbuW4k ieV3mmjYSPczf66Vsclh0ySST9aiVG3QoydSuI47yR0RPMkgAll8vOQOME1dOtafpmlNJa2yRJu3 SNZJtlIICnAX0GffrUeydwP/1f5D72W+01bS407V5Lqxu4RLLZuvmNCCPfn8O9MfU9eu7B4rCSG2 ujIN4e2GHiyNwKnpxmvgVTaVgJobTTDcWsN1Ldpb20nm3GxiQxI+YBc/jXNW95cq5tLe3uFsINRc JAZnSK4V2+Z255455z0puncDq3/s6V1jt9MtYYIB9oywVI94HLZGBu96vx67NBDANOlnsr+RwqRr O3znoAzZ5HtR7NibS3NiLxX40a8ZT4qu0gMke6yWb7LGFTO/BUjdu9/pmtFfGXi3TtZhvo3uf9Jt ds4+1O9qUUkKzqc5PXt2pSptqxk5s//W/k2vfiv4tjmv7azu7zUrd5yrtM0dsEXaDhQqgsAc4Oe2 K6WP40eJ7C10eVPEOprqEnFtbQKiNAVGW5KEj8e9fnTpPZkRnfRix/Gv4o3i6gIPFOp6Woc3C7XQ PPnOQ/GCSQOQM5713nhn9pL4oRW1lq7+K9TW88o211ezSJFe7UBQBiqjOMfxc1Dp6bDm7Iqax+0T 8UIgLuTxULi402Tz7Rw7+fIScrukR+OfTv71NpH7VnxUVtcu73xGqyDTd80NnE/mupPzxgscHfgE +uOetZ+zfUxWmxqQftKeNruNLo+JL25juMLY2DxpYbyOXDOEJXA6dvzrWj/am8Z2jSWljpugRSYC Sz3F3Jqc7AAHzfLeLaHGSMg9QaapNnRCT3P/1/wD8Oftm/E60tXsraLRXtn4nuZNKt4b7y4lJYj5 Mc46tk1iz/tZ6/qDzu114gtUvZUNxHNchohIGO5oY1GzBHUEcDpX5r7I3Uk9Eav/AA1ZqkGbgG+u rLTk/wBJN5PLbgJnnaVB4578DNbdv+1zeXskM40VL1ZJjHND9uS3tioXhlZV3ZPsTkmodLUnnV7G 3of7UFnHfQT3um3thbPeebdQWJMrQr0bJOS5IHHbOM46jv8ATf23fAoht5/GPg7U9ZgRjBFPo7FE 2xsPJeZVQAEYHUhhgZBxSdLSxsptHVWn/BQHw/Y6dJZaRoJvjcSmK41Npn1C48pm+WMp8vzJ6kjH pWPL+0v4J1fUpb+fWb631G4bN1aQaO4gGeSxkL/NtHAGT0/GsnS6Fc6P/9D8mj+014SS+sLPWdc1 iLwza3uLFNN0iOa8uwxDSmU7RtyEwPmYDcevFd3d/tP/AA3zHe6VaT/2Z5kbJBqF4IZbmPOG3DaW XIz0yRX5S6R187NPTv2qfCj3s4mtdGexSRRaw2129myJkbVdsYYdcnr7jpWnqH7RPh3xJq9pZnVv CujadpbuLrUZLtUs4AcPh25LsMAADg/iTWfsg53Yq/8AC9vhGkJjt9b0/wAUXsjyNPJD9ptVkT+E MXQY787TVzQvjx8OfEmj2+j6TZRW9zJeuv2C81F3RcNsDq6gLjqPmI4qPZalc6udtbeIfBVra6xO NT0q0nsUjd7TR7oXiJngmTBY5yB3NY1l8TNN1qNd6W0Z+0G2FxFJJLNMy8glWAySCM4GAe5pOlqW f//R+KP+FqWuszTaFLBDqKJtieO922u0dEILY5DYGOa7e003xNbzT3k1taQaLp1iLuSD+0Iw7OeW VecH5O+cZHrivx72J6BkrPqmua7NqXhizsbjR45Ujura7uN6QyIoZyZARnsfTpVn+39Ki1SG/mj0 /UruZvKvLG0vgLa0jjf58upIHQ465yKl0mVF2eozUdf8K+JL+4l0ufT/AA7FFsjnnmvUtw3YbOMk gZ6Aj9avad/wj/hmw1XUhd/braxPnXmp2V2k/wA0h2o0rZ4B5A6Cs/Za7G6bWxuakY7C3hkt9Yf/ AImNiLqRY38yOSOVcoCe/XBFVlj/ALTh0qeCztbHOLNLyOVTPO44Z9ucj/PNJ0Rc1lvof//S+T9U s5Ea+tbJ5pLy2kw7ofmcAnPT+nrWhbeEfGVtnXf7Av0i06zGoLJf25t7YoSMne3B4I+7nOTX4lKj qepz66Catf3EtwL67lvLJY4Fiijgdore6fAPygEDqSSeMYNc5feI5kisopWAQTZczHzGiB++d3Wp dE1hMv31zpGmWqyHVptRaZjO8cMTXEkO7HyhRyFHpWxoOreEG0iea1a8sbsX7xrbi3dBOjDcZHDY IyxI4qfYgpPoaOi6l4XutVsLCdL6x0udTb3WryANaQ3DOzFixy2zBHQcUeN/D9t4dlmElzous6dg GaGO/W4liVseXI6A9DkYxn37VEqWupan0Z//0/jez8SWV4Y3tjFNaWC/Z2W2Xdt54z7DJ6cY+ldV Hqfg/WriO0up57TWJbhIB9gtf3dyXGF8xsgZ96/C/Z2Wh9HCSQun+ENRihuruyi8/TUlaG4afUhN cW7kkLhc5HQ9fbrU9vaMtrbxNcP9rFy+/wAuRkKL8vlgHqerZz3FQ6emwpTuULNY/Db3txNvmS4l zeRyKSrKMED35rYnaK9CWOn6fp0UV4wW7Py2rspGTh8dc46kVm6TFGdtiKSbxh5r3GnCGw0W2SHT pDFdPxGmVbyyOpOcnt+Bpus6X4fmsfslxeXF/cSIsszS/I2SclQOv41LpspzZ//U+WmSz061m/sX VZLCHU4BZ3CwzEyyAcGP05/lT9K8P2EMf+kF2sRhgy3L/aUkz97YCNy4znkc1/PrpM91zVzQ1+z8 DQaNcXmhSapaeRbSXOoS2rwQCd9wBlYKCTnAGcnPA96o6ZrUWqeGEtobFNXS3mGp2Qt/3b/ICMSc ZIwcHOMH8qh02jWM+hmaLrFlq2sTQXllZWt1Kh8m0ecRxRgH7oYkDAxjBNdXJ4h1mzk03SLbw/pe nWcd3IVm0aRpFuOpjdlPDOTgHbkcn1rJ0/I2cu7OP1Wwn0bWI9Zs9e1CS3aP7VdtYvuNq7gh4228 sgB2/jxV+3a/jS2l0jTjqbMwuIkKgW45DZfPODnoOTWMqd90XCSSsf/V+VdU1bW717aS9tzbadGs sd35UIVbQsOCrcdDxg+tcqtrK2Lm4ntTBGxVJntJLm5AX2Xnn2HrX83KFndH2BtW+oeFrSGxittQ Jivbhlm3WLxNbyHnc4PIBJ/+tVTxG18smmaFb3H2q1urtb03drLm2haJgyhz27DB7Cq5X2AsWclv Dc3WoXUf2jUSfJd5FDJONpG4kntnj6VdtGutOlsb7WPBml3rtO1vdzzYmFzat86LlhlGHX5fy61S gyXZuw7W9WvdS1S0hi0W+0G1iUjT/tEkQsXRf7hznGPbn0qqwu4II8TRCzkuftbtlftBkTgY745O c/8A1xsk3sZ7SP/W+RL6whurSfXLm/VClxHbQ72GbmSQ42qc9QCD+Iqe30O2WLyCYXu/MwEvZBHb y7uTvYjjbjg5xyK/n1r3bH2Bn6/puprdaXHa2EcljZwv/aM9jCt4ISzAK+9ckA5A4/u9Kr6tok2i W5vvKsNSsr22MtyyXP760YcBWi7k8Dn9ay5X2Au6ddNP4ftvP0X+zGli+0wxiLN1MASBz6Ec446i sJ9b0pbqK7t55YI7eLy5Ft0MjF1Hzlu+etS02rInnRGNc1e8S4i0iS4tdKmiDNP5Ijud5OCQhGdu OM9OcVvDx1r4MWj6RZ6RZ2FtYpaBhb/aJ7mZUxI7KBgO5yc+/wCNY8rXQpO+qP/X/PpNYe681jDc wkF4PMNo8Q3rlTjcPWlsNauNE0zVLO502a6iktc6fqE0h8qKbeGJboQcZ/76r+bJrS59hfWxtafD PeNGbGaS2u3i2GeZwIULZ+YZ6cfzqK/8CanoTwT6V4uFxJf3H2i+gdUETIp/1YxyMnIB7c1zT6CT V7IuWvgPxBqDiVb+0tArb2gmiaSV1HUjtiptWttD0y7h8/UJES5jWJ5BblYGkzgD2x65/Cszopy1 uxlh4U8Lw6tql3qGruLuezhFkpsg9uo3DIEmMr13E9/51vFVtb6WbWPQruPUJ3mUyrbSbJEVSCSM 8EHGD14pp2dzeEr05H//0P5E9d0JNf8ADWszm5exntbQsLKRTBJqMZxvUbsHgc474r5bOm2N1o9p ctfxILd2iVYQJJSvb5eOp9/WvNpT1kkEXbU88lEQneOQNtDEbwMH8v6VoW8n2RAqSvnduXgjafau hSTWp0wdncW1QXV1K0xUK3R84y1aEKzWcM9yHSS6c/Zgw5eBB3XPrjGao15la6LumxWK23yX0sN2 ys0zqm4xA8Ac+vr/AIGqSC3lCQRszmCdopJiML27/nQVY//R/hPXToJbiRRMAkQ3fLhiT6fjVi1k H2hzMrMsa5G4HJA4xXNfodbUU2jLv7uGC9Nxa+batOpXyYAW2g8Y/HHSnnSrqdUcJiQ/MTJ8jp9Q aHJISeyNC3tSbW4nLCbUW/ciIsXlUL0YnGMdsZzWVtvFu4JIWkE0MgdhEcsxH+e1RJp2NtjrYr61 urN4J90EtrIJGZ0xvBH3SKilc21rcGCBLg3ACpCwOFBPLADoaIJbgf/S/hQjluF8xfKQMRt+Udj1 rUiAZXS1Vy8aqXRvl5I5P5g1zncpXMF7HUrrzlgjkLCXawUHqe2a1k8Oatm5sVhVrgW3nTMsuVVO ONwoLZC2kyWSQxz7DMFDSlXyAc8YNbsNzdww3dvGqp9ttxBKjjMbIGVwQOh5QUCMRrvWhJbmGBB5 w+zXSqCq+WvC5P5flWmYJrOJ3k4mc+Wz4wAD3H8qzvaeg3bof//T/hhtbK6uJp4oXJllXO0LlWU8 ZPpUsenmyukSRWaMH/SFLbN2Oork51a56V1axmzxmS7uFs4JYhsPliEMw4wC2ap6eXMjCNfMMX+t cnATHrVOWl2ZyaSsW5b2W7/dRWkwVJB/yyKlgOCwyPxpV+0LJLbxq1yB8x+QlovrWadrK5iIthc4 Q4Lq5+50J/CtOHTIJHP7qSKN8KQ2dsZ/H1p8/u2MZbn/1P4UNUs54JYIbSMPEQ26WR8cgdv1FTWN vNdWyQyxOm+bYnHLv0wK4+fTzG7vVlyWyvrPMkTNFJbTeUbfIMjNkgtj2I/WquqadfG6tzdtNNJc xeamT5m/jOAfQZFOM9RFqw0m5Z47ZN+ZwNy5IUe34U/VPDWpW+rSaSkLXEyS+SHhUshOA2M9M1XO r3uCVloLB4d1L95Bb2l5NctGcW8Vu8jv67ABzwCc+xrNtLeZitu8M8fnNtCzwMjrgnPBGaFKNrBy 63P/1f4gINAjtLfzLkfI4IRSuC5xkYrFktLxIpI4I2hE5IPy7nwD1X/PeuTn18gJNN8PX3k3GoCa CRom8p4Hk2zgnnIX8Pw/GpX0i7u0cJDKywDzXZBkAdCP1/lS9oaxirF2Pw9JHZyPJbXYlOGCyRFA QfumPue/I9KrL4Tv7iBbi7eOC2lkaK2VW3PI64JDZxjgg9+tQqii9R2tZIZe6C0Yt4IVIjRwuV5Z ie9Vrzw5dRW0JX7MgtrgCR92LqYPg8/THT3oVRJ6lbH/1v4dtK8Panq81xFpNm5kt1JFxJ8sbj68 454qa58MaolqUk09YZtOcTXk5Vo3mDEBlGeuDzwO9cHtY6K+ptzRMmTQAxdrsSxQNGZEkXoWP3UB 6f1GajsobCdksZpZbPzHFvaNdReUJHyBgscf5xWiqamcmm7m7P4F1K0uDCZ45recqI50IEEeeMlu v6VEPC9zY3DW8lqlwpj4kV1YZ6cc9vzp+2umDldWGz+BdRuAJIpI4yX2kkExIB33e9MbwKyxu8iz TTquAqDy45D25PHPSj22liT/1/4gk8HarG4e8tHtPLjSVba4jMUqo2MNjHSqt54auJL9lsElkFzG ATGmXdgo3Db/AJyK5ZVlLVbFQXvDrTwXqEt3aw3LJb21x8pcEF1I7Edvx6Vb1DwfDa3M9vCfMMQG 12YMhUnBbPSj21noPl18i2/gHU7C+ispFtri3uIEuYp7STc8ocAhMdVbqDnuO/eD/hEALlkngnga 3b9/C4IkH93j39azddPqaJK1hbrwJdnTRei9tw11eNBa6fK2Z/kCknIHTB4zycH603SfBn/E2Fle wSH7PF59z9mYSSgYyMdh9e1T7ZJbjP/Q/idk8E2cgkup1dY3lC20TgJOF5zk9cf41h6l8OZHgW50 x3kUTEXokj2pFHnrGc5JHqcCvOjX5VudBHp/gaZbiO2gYvBLLtN7OPLVRkcuBnGM11d58NW8sJ9s tb4yEeSoRoYbYjjl2A64z6USrKLuFluOtfA9va2kdrMwXUQ7OyZJhkTgDYe/f8q56y8AXpju7iO8 sibWYvcR3O6GVImcLlTjGRuAxnsaSr3VyJrS5LP8OU0qFLpXnvma6LTXFmvn20MbDI39xgikPhp4 gotnW4d23lJV2+WDnpgdhUyrXSZPK1c//9H+JGDwDa3Lrc3E0iOLjbLF5Q4jI+8Cep5PWrL/AA1j s2uJ45pWtFYABsCRQc8mvMcrISHaZ4HjSBr5llNvFeGN5Dbec8mCMFQB06Z/Wtc/Di8M1tLqMRs7 HUgxsr1IvMaVQdu4p1P0/Ws+Z3ubQScbFG4+HGknULKOKW4nWOdo4rsI0EMnYs6kHbitBfhfG6ag 8l3BDJLEgtcxNL84YBgpA449f60m+rGopKxtah4V07w/pzaDb6RZR3N75d7LqMEhupJMjIUsWOPv dP51yF14IsY/3UeozgI4kdra3BebIzt2n0PApc0drlWVrH//0v4r9O8C/ay10ENuIFCNamMxTXas epQjPb9anufhzp7yM8cl0Jmwz28gHlRj2PXt3rxzblj2M668G6NHdGCW6mim8tYEtyiqjnqCG6kk elWofBdrLJIYNNmu3SHakBLbHKgk5PAz/nNDkurJjDXU3bXwBpl1Zwxy2UW6aPdKscRnkjyxAikG MADg57Z61BcfDjTEeOK7E9iNPSRIorOIS214ZMMDKCc/LwBtPrkUk09ipr3TAsfB+naXNPJbWpmV nLAMxABOegJ/Q10N34TtksYRdjbLcEuYVwFiU4Iyexo5l3MT/9P+Ka28MWun2TatCLK8tWmkVbhZ PMlPG3YAOCB0znr+VLf+GNPvLFTo0EFgpmQXfnORJKD1Pt6Y968TnRpGLT1NqTwLpq3sKWtrc27w 2kUzzSIJbRGYD7pI+bOOme9WbjwhGHmtrZjO864CtGsSnPVlA79cCmpphJysZ9h8NYJnaxjjjhkE hZmnbcIVIw2X7c9jT7T4frYxi02mV2nMYdlwE54J/DvRzRMyz4n8G6YptwnyxWdou/a26S5l43/K B09vamjwdp6W1kkOjsl4zZkukyAI2GQGB44P8+lHPE6D/9T+NK38DWtxdQ2+dzSOAIyokYHoMDpg 1Xv/AAZHpd/PYSWJimigV2iWMgKDyD0zyOeK8a67nQEHhSytr77XewG4iu7YQsts4V7Pj749fpWf aeD9KS9u2aGOZZvllaRMSzoOACOnSk5RQrK9zX1HwXb3UCW+nxRC2iUG3MrCWS36ZUYA/Kq+m+Fd OaGeK705I5jKvnXiqDM6LwVB7CkpoZytp4T07U5729exMjS3JsoA+5HQodgftnpj0rrbf4eQKf8A iYRiCWMeWmxAWIX7uSafPETSe5//1f41h4KtZfMtJkRFMRZZ4ovMkBHIBHSqF94T0Vb+EQBlikRY ZUVNgY7cEZOTnOfzrxeeJ0D1+HPh6eayi+0XUaKc3KRxKzqoPPzHO4e2BVO48BWMkynTIzCgby44 S3UdM5P9KfOtrisuxd1H4d2mjTWthqNqIJ7iISq6sXluMqWBfkgYHbjipLfwDp+lMWjJvYbhVkBm IYKw+8gx2z60udDMS88Fx20oeOBWR3JmVot4iyflweaLDwJby3cjrEXaTiNX+RQSPboKaqdmB//W /jWsPh5DeTpA1rHLLuwbdARyDxn1BrOtfhYbTzVvI/LFxdOXiOVSMK2MHjIyO3WvJU2dA8fD7T9S ns7/AMmG2tLeQwCzt8qjAcbih69COtdJqPgS1s4oLMRW05CefazWYUhgQDtkIHUdNp6VSn3ApHwb DLYCO3SS1NxIY9kaCOKVu/bnk1l6/wDDm+0BrCaSe3vrHUCI7eC3jMjxyhQzox6Z9qfOgNG38C28 uyaSG6gIiEgtJ4VeGIlRkkHrn05xmrln4EiWW3kvLVJrefegAj2fdHQDr6c1qp6Cl8SX9bH/1/41 LnwdE14lpDDtiVtnlyQhBnOQf16/SrEvwqg/tS2Es9otpPFlnuV3SwuBwMf3Sc+9eb7RLY6DQk+G Rh0x2nmtZ/tQaPZZZSSNVOBwfbkfyqtB8JbFLYNJB9qmkQC3Fyxg+yvn7xPf8uKTqAWP+FYxRW9y bldsgVYxNZIskYOeck5yCKs6Z8LNLuY5bWz0+KFpi8jytmSSchc7cseM4PAx1qfaARQ+B9IllkfW 9NVdQFqLFZLe23LFFGMIy9ACQBz/ADrlj8M5b24NxpVsi2sKbQszEyM4OMsMHCnjmp9p5gf/0P40 5PhuWWGEsBMIgWit1PlB+r9vrirw+EV9stprhorawmhaRWKM052nHTGPwOK8ZTSejKT1GX/wk1M2 tndWun2lzbSSu0Vy8ircTohAKrDkkn+f41hX3wxTz2muI5ETZxBHbF1DehzyvI96zlOxnWVnZFqy +EGqWkUyX9oI5buBZLePzMxtG/zrk4+XK9vekT4TtaX0q2qMtnqdqFNpdAyi0kHPysBwCf8APHNx zSGtthRpVJK6Nex+EX2mBIr+Kzlm/wBZtt1MEce3kBZDg84Hoa0Z/hfbLPaQSQxCLIWZpG3/AGNj 6PjJXp2NS80u7LY6VRly+Z//0f4xtT+EjWN5d3FvELqJ4PIhktVe4S3kZj8+3A69M8Ct6y+Eqpay L9ouJp3ti0a3AWOJZgAWXIHTgj64rxP7WSgna7OlUJJmBY/CyPWPOg1CLU7OTJUfutkhZG/hJ4I9 x60yz+GfmaxBZNFcWlvBIBPciLzGYdjj8s03mcOZrpa6fc0VKT3NO7+G76Y7R3FqshupituPJeNZ AfuF8jgkZzgkVTt/hQt9c4MbQRzbVc2ytL9iIPzBQQN30PahZlBR5upSpPlsSt8NtFaZ9LSKW+lg kBIjJt5RngblH5kVPqPwE1FZdKfzYrSzkncOF3SMQqj5XYDgEnpz+FUszhH4luNR5dD/0v4w5/hY 1nL9ohtpQjz/AGe2SMGU5A+YtgdOvPbHOKrp8MJ7lpCGZH83cVEDFQM/MSc/ljivM+v0nT57npTi 4WgaY+D8sskmELRkCS1nY4cYHzZ4+U+g5q3Y/CS4uYJ4Lm7VHnjP2WaNMspx8nXgj1NYvMqSWi1J K1l8GpbeGaZDfSTRxmFzIVlSUk/fyBnOR0HrTF+EGqW8gFxaybJ0O24OHjt9uCWYjAx6VcMyo3ab sQ4yk7GPZfCeXVtQtln+1QW8TusotVZjLj+IrjHP1ovfg5rsFz9ls4Is3UvkwC4DgY55fjj6Dmq/ tKhCXI2W6UmtD//T/jA0j4JX72ziYRyahAN95FAkgSLnAXDKD0//AFVQi+Dl4ZjIyzLNJM0axtEy QRBTkOCRzwDXmxzOhJ7nd7CaV2WpPgzPObe3ub6W7LMTJdWUDItsnoeOo9c4NTxfBi/MptdOs9Tv FWIs0i258yVQCclfXHPHXNaf2hh7XbsONJrSxlWXwjjk8wT3MpnmiI+wvEftkCkffbgbfxrK1H4S atFLZW+n2zTRqpWaeYnzx02nAByM5zgcZpPH0ebluP2D3JW+E2uxLH51neQEz/Z2aWyk2naMsRjn vx6+1B+DWtPZmRGCs0pOWjkB2Djhcctnt2zQ8bSUVJSMpUal7I//1P4jLz4TeJCYja6VcxgpsSSY iNCVHXJ9faq8/wAL/FVpbxSx2Lyz+YFlgDhiAecgjj8K89Y+he3MdMqNRpaFi1+Gur3z72sLxY42 8uSJ7doWkYckAtjj3H507/hAdXSe806PSr2O8gG9YWgMRkRhlWVmwCDkY5qljKTdlIqNKrbYrD4X a9FNJDqlneRosIlguPIIUMTyu0jOQMdsHPelf4W30dzHFLHeNBKvyXJgxHbuBkLKe2ewHPX0rRYq j/MhqnO+qIpfCGo6QsCTWblppxAkrIdoYnChc9c1Z1TwJrcMEVwLS8dmuVtubOVbcFiMkMAScA54 Hato4inpaW5py20sf//V/iR0j4X63e293NqFnd2clrcfu4jD+9uIuAJFHoSaSX4f3yIxeK4t7dWK tJJbkbgDtHPQZ9/WmsRSbsmejy21sUv+EBubu4EVlKizFVyHRv3ykcFPXgHJ6CnH4ea1byXMU9rJ +64QwRGaOTjg7hwPTvT9vST5ZNJhy9kc+nhW+guIIpLWWO4uQxhSRCJAqnDEr2Arch8D6xd2hngj 8zYWAP3Ebb1wCM/570fWKSXNfQpU7qyObk8L6yl00EdsZpSokAg+fcDnv7Y610CaK6x/ZzbOb3bj 7MkbO5xwWb0Ge9DrQRLpO2x//9b+HPS/DepT29wZ48skxRdymNCc4Vc45P0qrJ4TvJ5p0jdGmtfv wK/J9qh1oX3O32TvYrWvhzWS05ewvYzGSEPkMTJg8bRjnOO1Go6beW0CG5s7yNguXV7ZxIvb5lxk VLqxtoXGg30KMegahPAs8Nlcyo8oj+WBsx553EdcfhVxvBOrpGZWt5IxwVYKT1xjp9enWsnVitGx vDvoWZPDt9pdrJJeWl15SQbppmgISME4Ge4PTrzWRcaNqtlavcXMflQInmkPkOqnoSvUdqXtIdyf Ytbn/9f+Ev8A4Rq+aGOVkk8yb5oothD46ikj02aKJhKWiKtsMMiFJCemAD/niuXnj3PSVJEsGh3w aWWONWRRvYK2XjH+0vap7/wrfx/Zria1mQyyeWkirlAcZGT0FOM4pmUqepm/8I/OskgBaSZRuliX kgetaI025Sz2+WyncMKyYZz9OtX7UORFFdC1KWVxFDLxySVwifjVtNOuoGVXhMKF/LDshAkb0B6E 01UWiQuRJH//0P4XX0+aYSPBEQkSfv8AP3fTH1qtN4evXKeXbh5GXcNpG4DHpmp50dKhfVIzreP7 OztNESh+TzGGQrdMZpl0s0fyuhUM2FBUjjsKXOi/Z9xU0+4ljMqQTNFGdu4RnBP+cULZTW7IPKk8 yY437CYo/qfWrunsTJJOyNVbQqRkKWUfNnrmoHDoGR1bZu4OMYoJP//R/g9CeZIWGTt4H4VIXkBU LGZDnlQOTSujbliMSZGdyq/6s/Op48sj19KJrd2G6NSfM/i60xaKVypGro4LjJj4z2rUWNpRuIxh chVFAKzvYrTnad38YXAzSQSXCwsCBuY4UY5rW60TDkVj/9L+DKF8XIWUABDzj1xWvcxlYo22fLIT tI/ixWity2Oi19B8dkZmRiAqBPmB+9mnfZtj43/u1qNLF8jtchg0lHglcS7GiOfMxw5+lVoodjeZ cSKXDYVAeXx6fkaQuVl6a58xNkK7VQYYsvemQySsoiBwMdR3oBQbP//T/g+mSQTbTIcA9+RUsbMs wMQWXYQTGwyr47VSi2dLi0PlcXDFmcJJu+6BhV9qVIwoYMTwOT0FJq2hm4XZHG7NlGbPzELu6D2o SyuIy7MpG7kKRwPpSFyFmOy3IjuzFAcuQuNvrTJIPIZUtyWeT5lx95hRa2hSgkf/1P4U5rPbCJQ5 ZuuCOvrWfutpl5kVZBxs/iH4UHQTmBLZTwrh1+ZSMYqjKuYztHzDnA+6B6CgiULu6KiyyzIIwPl7 hhVyHGCZBt2cLnvQHKuYvFnuAp+XAG0MOBx6/lTMqykMAvYGg0s9z//V/hGJCoFLAFTkOpp1pHsu F3PhZSDluhBp20Oi3QtXrRpJJt+bnDhlwvHQVnKep5AbpxwKSXRFqDKstvvcbCQo5b3qzAIlKK2d xbBPTaKdmHIzc8hdj7yfKTkAD5j9Kzp7tHcKilUUBcMMGly6eQ+TU//W/hNku4wjDLCUACNVX5ce uajhjluFRtzKN3zAjk/Ss/ZnXyMu3MgiiKAnJGBnr9aqZkOHVAzKACw5FCguplKNwRYmSRneQzMd pQr8qY4zQsZVX5LIpwTjH6VMla4KKRHOHt1CbeM7h3IHpTUELbmO7JHAqRTTeqP/1/4SjJuVbdjs BGFPQCqSGVXZGAYg4BHQj1/SsYpN2YWLZaOIKIx8zcyN2+n+fSomeZm+Vz5Y42dBVcmgGukgitQk m5VfkkcH61luxaY7MhB8wPc1Ci73SAc8wkf5Qc4wMdTU9oArFnznOG47Vp7NDW+p/9D+F77RF5eY XcSZwuB8v4iqd7L5qBcAyhcswGCaj2ZsuW+hUs3leVkdT864BP3VxVphIjtHK8iIBhdv3QexIodO zaRVu4yMPO/2XzPnUblkLfLjr1q6LeIW8ksjlHjYCMf3/pWfK10KjFsoJNEsnX5lOQR29zV4vkiY 5lA/iUdKOVjcGj//0f4X31JII48fvCzbVB4P40yPVp2bEhkGfkUKeMVzOHdG0oJ6Eklw8Cuz7w7j Kkc7/XNY8t1g+agJkkGwyjh1HXBNSqZDg+hFJLPNEsRkBgVsyI38foPfFWYJpYViBll8mM/LEJCF x0xjpWsYLltFGcldWHNckSzeTcTMkrghJX3+XjpjPT8KsC+nhUCRRvcYVhwQKU4dyFC6uz//0v4V VKtILuIFgoIViOjdCKnW6KkxxSNbrNgyCFijAj0I6ZrlcdLGclaKSLLRxIgL+bLvcSGRpC0mR0LH NVH1CQ3ZQTHygvc4xx61lOLc0bONoK5of2tdWkKul0WhY4AIBwexB9qi/te/nhUfaZvKiJMa7yAM 9SPrWnMlodU1ojPtdU+zmaO1ia2LMGkeOUxmcjJGSPTn86349XnvLeNvtc8MkcnmSRM/DYHRux60 3JJGZ//T/hvbxFfxiRbS6nhDyI5ijkKqWQ9f51HLrWtslyRql3H9qJe72yZNwWOTv656nr61xKSS tY6BkGrauiRt/bF5c2USeXHDP823uw/Otay8YauI5oprh5reV9jRy8jHHfqcds9KgSSWiJJfFd5G 6+U+9YuBkHae3P0qsPEWrwTJqFndSQXUZypiACr6HHqMVD5L6hyx7DH8ca/cXEE+oyoHUMlw0Efl vd5JIkc5+9z2wKkuPFup3J86K/uZEt0CwxSsBsx0C0WgZuDvof/U/iKsPF19HbPCHAnlw2zdhVPq QeCan/4TS6XzJbkG5ucEJ5jF/MPQZI9OPyrypW6CkrqxNc+P9UutN06zvJRFaafK0phtGYeazfxO uefTHtWp/wALQNh5a6DZPbr5G4iQ5csfvfMRkE57VBlySMm78QSX0drNKrRy581kPIQn0PetC18Z z6chuPsqTSz/AOjrLNNgAcjLDqMc+vWg2SsrGgPGNqjSPdQrJLFh4/skgdXB55JPWl1T4jWz2MS6 bE1nqSXKiYyoJLbyzyWUevGPTmlZCaurH//V/ifk8cvO7XWpHzZFkCt5UCxhVwFAAUYx+tdRJ8QN FhtYobbTJrsNIGLFljR1PquePzrxuVdiYx5dyk3iZ7Rpb622rEHA2ggtDuPGB7VQh8S2yTXE4keN 7pQblhwZcYxkDr0H5U1HTRFGhJ4ktRbxL5rSBnVk25wCezVq+I/FOn6l4eh02axghkjZWjulLGdd nJwc98/kKpQYGLD4vtLfS45Eu1ZLWQ7LVkO9z3wMcj6mrw8Z2d1LABK2ySNWIaARhDjkfhVOmhqL ex//1v4x08S6bPHe2cdyVdlKIzgBGByGw2eMZqyviXTLCw0wAwXwkDQ3cvmEXMLRnoo+6Qy9+2D6 V5PskFrbk+neOtJthcWb3sMUN/KIUimQbmTdu25xwQQOnWp7vxJoN3DbW9vGIDaXTO80qBBLkDof TispUl1KUWylqXibRI22C2WeyWLHkyXAAkfHXjtntW1pnijQrpNOtbrULa3upw6iK6DRQ2gX7uJS MEEfQ1DooHCSHf2lZXs9ywube4+zMIUVpg0hHIBVe447dMikfXII0k04uil0O9Fn2SMPQrntR7FE W1uf/9f+Oy1u7LzFit72wa4Cq6JJeRxpjqVyT97H8NTf21Fc3k6OoysQeOOEbI4scHJ/Kvn3h0wK kuv29+sVhHLLb3Fu7SSHA2sF6FT+tbFrq1jdXVtp9tNNLdSDhpYxGWbHzANnv+FL6ugLHlWsBFx5 sLSchsOGkXBxgjt3qzG8PlSMru8mzO/sM96l4db2N47IzLed5GuI1UMmwpIGQOT6nFTWkdvLZuEg Uvbqz3BACowXvj1x/Ksnh1fUZ//Q/kC0qSWcyCMo0eMh2YAxqDgDH6YrWltbaIBb6/e3nlgcxSRI ZN5X7uQOnJAz718wsOBXsrWExu81xLIxU78Dk8Hb7VQu7ix0+1t1VppXlbaCUzMTyTkdqfsH2AxZ r+G4dLS6luY9OlP+kiFR5uPb3q8i2hiSNLqR4w223ldSJ4/RqTw7M59jaQaXpslrbfbrq+1GePy0 aaEn5uONw4z0refUIWtbmGeURz26CKaFjsmiBzzg8gcGk8O7HPU6H//R/ju08IH1RVnSS5jJe0E7 iONF/ugjryCfxq9bPBIyTYjZiNkJkIVGfpgMenTrXyMsO0YLRleK/uL6advJEMEK4xExYuR2U/hV vUppbibSoNKs54rcxl9QUZeORgMDJ6r1HFZOgOUr6EU2npFA8TQyW9w0u8o2QpH0PPatOxtTNbGM 2omVFLvKPmBUY4b6elR9XZJHNbR3GpXF0dQS2ghswIo7aPEAdQPlxxg+rexrA03StUN9cah9tSTT 7IG8lmSYCVFDAEFc85yB75o9h5GsHpY//9L+RCdm1G1aNNTfTZI4muomhT97ONpGwjHQ57+nWrOn S+Zb2Vje2ztCxSOaZXw0Cnkue/bt618T7DyLhuPvdT0O1sk0OMSTRmR5LhGDEOCRgb+fc4NZz3dt baRp9nJLNYzWt+11A6PsMinAQZ6nofl96h0CXuy1pnix7W7ilvb65h3T74Ung3yTg9unPY8/nST+ Lbi2dtPhlkjsxdtNOYePNWTkhh0yM8D61LoaWGnZoqHUb0GF43ljknfCoXEQRc/K746HAHHvVnVW j1i1lSC+lhuYih8zcR5ci45B7/hUfV2aSdlof//T/lAsdb1Cz8OWGnQamLu5t52/f3A86TawGV6+ oGPTFc/qQm142RubC1W+ssi5u3Ytbsmc8gnaM4JH1r8/eHfUfM+5nrqVtBClnbWv2GaAyZlZv3bg nIK/zFad34u1a0toFtNRlWO5gKvKsKCOZ8AZ6dBjt61l9XHzNKxl6brOsvfSvd3zTTvEjxSW8YjR dvX8T3z6GtmfVdb1O5Xyb2e2excTBre6a1EfZiMHk+x4OaTw7LU09yXSvEuv6drVxeal4v1WFfsO 2EyqHh8wHAb5VxuAHBIwM0umeLPEN1ctqFlr+uKN32jULj7S87zCM7RIwbKgngcDHTisnQsUpJ7H /9T+VfWPiBrd3rGnQ+JPHmo3qqsd5p8E9wDcnb88MaMoBB74HSuoufi34ieZL/8AtzXwsC+TDYza tcXNqqAcLsJ2++MfpX5l7DyOvnZT0v8AaJ8W21nLZpr9xJdXask1pHciOC6Kk7RMg9Pp+BrqNG/a B8WaZpPkQ6vdrGzGW50+KdYFeXr9wLtYjJw+Aefc0vq77D53c0If2h/HVra6fdzamZbS8l8m/F3b p51tE2dp4XcHViPmHbIAqfw/+1X4x0TXDbRx+GNX0CW+E02nX8V1FDqcg3CNnJbJZPvdMEr0rL2D uPnR2XiP9tb4gf27DqUq6Potpp9kUi0zSbYzabcxquFifdjgdeh9zXVaN+29cDVNLj8VR6YukjTJ xfReHdJltry7eZD5E+4/LhOFyrY74GOR0SlL3bn/1fwq8M/t2+JtE0i5u9G0XSBbNcbLWe/Tdch8 7dzyMMkAAEDHXPfmvUvCP/BRTULiGf8A4TrTb7xJIwlgsdP07VBDYZPUysAQNoyAuPyr8mnRsdnO Z/h79uXwPqd483ibw/4xSyR5YNP0RY0f7GeCziTA3KSOx9+cYPP+Kf20/Csp1KGLRmsbG8hS3WaW zf8A0Fg4IJbZv+YDB2Dv1rJ09DaE7bHXaJ+1X8P4F0yW18Kafql8BFa3Utzrs8c8ilPnkRVwvXkL g/pXR3H7TvwvmEnmQ6ra3CuLWCeNUks0Zzl1dz8xAwOg52jpU+z02FzPob+lftPfCK40bUIW1m6t 9YsdUTT9JeCzb+xrgYRjK4bLZIBUgHrtx0rTufjR8HvEzXEMV3qaXNqitLHLZi2s7+bGD++3YC59 c4AqPZaj5n3P/9b8xbT9orwNpEeq+H7e+0Z1SNtOF5pwjWFWOFZfNx8+Oee5HBI5qdPFPwkvEtrS 6+JEGl6rHKdT+0xGSX7YAnEY6A4JJ4z09q/HPZPY9ZVLI1bP44aXpVy2keB9ct9f+0XCy3y39umm 2N+Y9hVAWBYNhTljtPoO9dvb/FPwubm41bUdR086vGhdtHS8jXT7N8/cjn3bWHPrk4qXQ8hOo7Ha t40il09tSt77wnqCS2okvJbHUre8bSkJBBkj3EA/wk4PSsTQtbTxZf3TQahbSqqGSXd5WnW4EeFy DgAZAGKXsH2HCZ3F5q11qPhmK18Myw6Y8d9/psmp6lbhZoUbDSBWIwOCQSDnjn0wYZRq10senXFj e30KMktlHLi92xEbmIIwV+YYYZB3D1o9g+wOaP/X+ZNX1jw7ps3h60utF3WaxNcSDTyv2wTjrE/X DdTjqAfesiHxj4dksf7Tivl0+CW5kt4rKVxNdKVwCpA7cjk4BHr0r8VeHXQ9Tn7Do4rK+gDpaGCz h2RmOJRvuImGQyr6H5sdulchcag2nwyWdulzZWRuTa3N/bERmGJx93aD19h3/Os5YY1i7O5Xjh8K 6jYzajcaNewTaYy20OonVBDNKyncHdVYkow6g8jjPval8aaZJf6Vpt/qkkulyw7ILfS1zcW7sCAS cYOCMZ6D19MXhi3PsdL4U8MeF9KkmaPXNaj0q9h+y21rKY8RTO6l55yASQFAXg9D7c+hzXNhpmlJ Lag3CyXAtI5InDhipA4A79/pWLwrNITP/9D5L8QamdfiltxdPHbWUgF1FLGYlkA+X6dT1+tU4Nek 8MXllFp8WmanLOiqmLlZlgEgKggL/EPQmvwP6sfTKrY5zQr6E63feGb+133V9MEjn1FDGLRjIrbo 2HBUDcO/T2xXoN9oP2GdoJdS0yQFBJDNDeRmDagGQD6nB680fVh+113Of1GawFoJ7a7trhWn8lBH KPNYqM52dccYz0zVrS7PxHe289zcakINOvJFCXMpHlWwjPIlzng4x688U/q/kCld6D30Ya5dBL7x Xcyw6cvm2QsQI7MbTnywXwQhJwQOuTSy6RaTOJ7ya8S1tYCJpdMC3DoHIClxnABbbycVSodBt9Wf /9H448OwfDxfDGrXOqXmo3MlnrbT6XZ6hbySS291uCSSb8APGy7CMAkEH0rPHiCwvNXaWeC6OkrC IxG3+jTTbeGOCOM44r8HdE+q5mizb+Nr3wnp8dn4akjs7jVNV3+dcKLuSJCCArBvl28nPGKp3cM8 8GpJr93FKkMTTNLpSi8lum9Y4kPXPpnpwO1T7GQObaNnRr22UadPqN3fXOmQkLBHdRta3gULkZRs YB6Y68H2rEuLGyfUNSa3eKyiZjNp6BA73bMdxyOnGSTz2NTKgznlUsej6rf+EY49tks11q9v5OnC C2tMXWoZRVEUTj5TuPP+TXDXE8/hqeKa88MmwkkmKy+fMjMc/OrOgOVc+orN0GgjVP/S+FLrUriQ teSqYra8kaRnKBIVA+8V7HGKwtfv/M0o2Wi215rU2pFDaBrXyY4DjLM6EnoBjHXn8v55lh2j6T2u tjpdGtprzTraw1KxeGWMKt6bUsihQRtPPKnj9ayPEFnfLqCTtcssuh7ke0SVTJIkhypKg5blR61z ToNBGrqR6RqOt6kftMz3zWRYok8j+WIGBOUUHBI9+enXrXoN3JYvpMVr9uguriWR0mh+zKxUrgqd xHX6VjKgzrpzOTit7bSA93qF1cfZGk/fMwe5W2XPUKOijPbir9r4g03Sb0+cftGkzMGgvJ9C85X8 z5V2EqWwuQTg4HJqJ0WmbU5fu5JH/9P+R7VfFz31hqd5DZWjyRRvbxJe2rvFHISVRnHG49D6V8l3 MNzbmOC7it7d5ZWaOO2XEAAJ6Dt3OK8GM+WpMuUOU5i9hlE0kkkeFZ87iOT7mtezvibOcS2UMpQK IQibmfHByP1rsi7xNUrKx1emeEbi8tmvVgs1gklWKFFmHneYwz8yAfKPc1ctfBl0mo3n2wC2ttPh 33Fyzg2J4yV8z7pI6cZ59a1jK2hXSx0fhLTNLMuraddaTbz2mtWIt7TVFUS3NoySiTMYJwPu4PsT zgkHGm8GWMguPPjuEsVlaVGUeV5jIQAWYcEcD9Ktuyua3jZH/9T+JK68PaUlvbw29sVnkmBkuYXb fKM9+3Hb6USaRo9pHcNrNzqFvOWEdlFZWH2sFSRt3kHOTn0/GvP1OnqWJPDPhaKT7Wt9q03kWbTw SHTfJUyhRgP8xwAe3X2rPt9O1Ge2EixRSzMWkMbZimSMcgkH25/DpS16horWOx0jw94U1OWW3j1O 6s72K0imuCbRPLZnGHAORxlWAPtVKPwnbWtyJLKGK4vfNYW0rPt2bejHHQf7WKY3K6sXZ/B8U0dx dwJFNdNl5hHMsqyHOWbOecevtXJSaD5oumjkmtb222ocxllZc5IVTj1/GhabCuz/1f4lf7Ms2vkt I7Dd9ot03XG/y3icYySueCefX6Vtx+G7a0ubUQ3kd40rf6VbrHtmTbyAR3Hv7VzJ3VzsgbeqeGtL 1KC4e3kn0kTyZb7MBEsLbhu2E9j059aoXWkWWkSwfZdQmuIBALd7iT5ZbjgFiw/MY9qZad9DlL7S 7Gza2kvTL9l1BnWxZrdnWVgTiMdiePrXaDRdKu1Jnml+0zQLFpEJAWKLYOVbuBjJ/wAmplK2wytc aZe2Op6Bdvpdm2n20LJqFpLIRDqQDff3gbt3JH5U6TT9NNtq1veWkySX9sFtzF+9ezywJ255wQCM 9s+5rED/1v4ptA06Uy3MNvBIqQusbXEgCLLkfKi98jnNXtR0RhqX2GZIVdUV9wYSRuzc7Sw4zz0r z/I7XNdDqLHwtZW0UV7BEftckRt7lQMoMZxhewIPXvXLz+BdIsvtMmoW19alZPtaCGTZE7OSQZc/ w89PpUc626mDkjTs/Dtt5V1f3F3LcXCwoLK2aPMMexguM46bN3Hr+vMJaS6Y+qNp9o8jaoojmIXJ iUHkR+gPORSU+5EpXVi5o2hm+spFmjeC5W5O25Ee9dvTaOxxXQ3fhS2FhZwX2pXV3eSSFftaRiFo QOEXHQjGBzmj2nkQf//X/iw1b4f7Ps6XU7SJGRJILRspJnouR0PrV3/hGxFnTmR4bFVW4tNRTAvY 3GCMIRgj1OfWvHVVvZgQXvhMXV3pcFhPLtvZgl1PeRFLqRurSEdMH9Md666HT7GwgcWzW8/2ac2i TpGJJAw6/L1wetDnLYDAurBItatb6KzEcFqytcRQjy1k3cFyPx7VevrWRzFe6OIZphOFndpNq7fu thxnke/oa0U9NTSn1NTQ7a8tNQjlkniju4JC9tJb3G4IuD3+hOR061MTpTG8vpILO9lkLWls0kuC 0zkgMB/FjnpxmplPX3dzQ//Q/jkudBhm0+3sp7mU3FrOz/Z5IPKEDNgkI2ckEY9P61b07TpJjPaQ 6ZFKqweUHuguYgOjqxxg9TxXj87t2KlpIi0zRUsbqSzvrK2F/q9nLB9sdBJG0eSoaPI4deSM1as/ A+ieGYrS1GqaxesULmS+8uSSTrujLKAAp+mee9KVV7I1jsitLpM18Le0triV9S+1sPsLDdFb23BH lNnk9eK2m8N6R5MMd5otxrOmQz+dKLy0ZYIpduCxIOBg9waylUtpET3uZtx4HXS59E1WExiyW7Mr pb4nhiDA7YzH/sjBxVDTdDX7XqqTlLnTb69+3S3j2u6aFo8qETPHRjx7DrQ599yb20P/0f5GIfDW i6Ta7NLluDFcMZrkysIwpfkFByOMjg9O1ZzWenDWBb3dlNqEC2mwGe4MUTySD+MDqB2H06V8+pzs 2xu3QuP4T8LX+nyWEplhurG4SeNYwDaqqnpuHVs56E1lDwzourailtPpdg1xbxMY72WIFIxwA2f7 31z0pRqVG9ybER0SKMtZSbbmFfknjLbVCg/wt/WtHVf+EUi0g2EOkyPqt/chUvRvkNsM/cTHA4HV vU4rWVSbtyu3cbK0OnyELYP9ol08TLLIsagTxDjJAHJFbOsaX4bh8NarDBdag9gLlJ7ezLBdURwe oxyfu449aydSTlaP9MD/0v5Kp5NJ1eNL+4SdLiDT7e1UXY2/IkYTBU/T8Kwf7I0A3IvHd7dYD80W n4kmYgehORnvXzanOHyGnZmZf6XHan7VGrS2qv8Au2mTacY6sOxxV2PQtNuYku4rNrsxQieSdozi MD5iR7LnqfStPbSsmaXukILK2mu9PtbbKTSv5i6nJlYNpZflLfdA/wAava54cD3UbTXEsZdvJgmS PzEunH8Oe44pOo93uX5mLHoMIupYnWCRI5Vjy0okkicDP4EY7etaw8Mw6dLc6xbAST+QFcltnlIP 15zzROq2rIlu0rH/0/5KLdfDt/oissdtJKZCbqa4Qh0GAMKem3r/AI1fl8IxW72txp+o2dxpUsaH yUlUXAbAyvl5yV6jP6183Gdlys6LXVjh/EiaTpt8tlo0aMQTcTwQKzQRM7ZKIx5IHI5/M1YkSO0s J/Ie6nh1BIxLbXagpaOBy0Y7c5Gc961c/dAmj8OQtNZTX6STXETCdIWkIAUjK9O3OabfeGdIvCVv 2ltVm4uIYW2i5UHhX545HapVVpKyJl8Jdi0+fTUnisbqM6fcQCJkhG6Ngf4GHp0FZlppEaSXkk8U PzRhY2B27TntUTm07BGPuNn/1P5DdNt9Hed9Mvri1t2uImjkM3Mg4LKMDnkgDj1oexn1G0uVigjR Q/lSASjfIq5HT0wK8VzVhR1Ra0xWsNInguM21rCrSRsvzB+eQR6HFVNlnqMUWoSSXdpLbyKLKW3+ fe2cAEZwAeDmo53e5tT2sWdPsbrUTdRLBNMkJPMiFWz3IPU59as6akFzby4mKSWDGM27j5H2kA4b uazlNX1LIodOhvLyWe4glkXb5aeW+0ttGR2PTmo3gtbq70lY9KtvLsJi63NxbmCWUk9HOPm9AD0z S54gf//V/k5jsJr7WJNUnnRLi2XKeZzHcYGAi449PbiqumxHVVv7SONImgzNJNMo/ehCchD1B9BX z7lZas6COXTbW4WK0litFHnGTe+PtEjIBjHfGPwrPs7S4tJ5Ik2JDKSWZT8xABwD/nvWbn2Ak+23 Om29zLY6aYxbHeztGQJ36j6461v6LNaawDc6kkQmkBkmAGQCc7sdPyoU+4HOXdhp76lP/ZZW/tLS UFnuYPJJPoQCRkex/KmDSG1EXDXoWcX7CAwXARLa2X7pCnAxkdSScD0pc7J5Ve5//9b+TI+F9M0y xltn02C1sdMhB/s60IkhiAI/eIoJzk4bjI5rjoJbF9QvBBbx3Md9FiL7RDkxcDLBex/lmvlfaHQb 2h6dePod0moNbXpttRee082ZbW5WLACx8Hcy57c47d6y5LYwv9qXz43uUWGVVHni1HHKDGc5Hbr+ lVGoFuhsava2+kX0d1pyG5gurOOW7llYxyqQvzbk5GQd3T060sd3a6ha298sYiEMhVkztWYg4PvV 87MppLYiurS0vJDdmJI5nciJIx+729enXjFXJY7SWLzpLyb7Sg8sQ+X+7kCgAZbt0/Slzvuan//X /kYh06K5uJokvINP32zlL2WXY0D7Tt2598Yx3rUvwJ9S0iG91ea6vFsY47m4ktiomKqVVC/3ccD3 59q+b9p5HQZtz4XllFzcWqpZTCby3dH85Nm/JwO4xn8+tT3vhy3M0DLja0ON8Q25OO47EGk5voAs WmQ6fGYY41jSXqV/iY8c/XFWrXSDHp8kThJZB+881jtkwP4QO+c/XipVTzAzrHTERXd4mX7VPvgU rt8t19u3UfpUj6dq8kE5IV1c4i3k71Prmn7QD//Q/kYtYNQsvLe8WFbd8bplYncRkEdOKvXFlDPO bqeJCytujijUCPIGAa+ZdRnSrdTT03QLddT06Cxj1Cea/XdLFNaeXHb5HLu/9054zVWSOwXVNQ0m CKNJNMlELskXzNIxJ+Q9/wD69HtGtBF/VdKSO5uL69t7q7lurdbe0N1ISYymBuHTnrx2GPSqN1bz 2lnbRJpVqlqZctJvPnyv3zngDmk6jtuaQinqTwaTEtzGb+3mMUTiS5t0kERdeuxWwevrg1eaysrO 7/tGHTlKTk7EZzIYFBO0Z/xpxmEoa6H/0f5VksLa7a6ubMiK5jjEyoG8tlbI4UevP86WYBLV7q5i kvr2QnfDK33uBnnrmvm+fyOxQ7mJYxWkkjySwhpUPyxAlQo9AO9SwPbahqDwIiwO8RMMQiYYC8Hd 6Z96pVEinFNWOkt/D1xL9mMltHLHpcTXc6CTy8A4LbR1OcnpzjFWXs9L1C3kmgt7mC0luPOjhkRv JhcDGEdueck/j3qlU13JlFJaFG4t5Lm3N1cxFZIo/Lk2HO1Vwq5+nHNGLq/thqaxxT2lgq2xto2X z1Cj+4OcHru7k1p7SyZnUSU0j//S/lXuPsF9qFrthk+1yRiNY44NqKFACjOOvY1ZvPCd94luLW1s EiE8alb03E2xEjGMt+XWvn/a+Z1zVmWhY6RHamyYmG9i+W2+Y+S5QYKgDr6/hUiabaXNlEbjWoIb hI3NyXUr9lC56/XBx9KTq6bkFHw41vdwXtvcBru0eHdZXAJgLMTjcc8kYHGKty2P2W1iuLeyeSHT JjO8cB2tLuBUqeee/wCNRz+QFqzgSZgrWaLHdgPcPIPnUemf6Cr2h2IGqtBpXkRpLG6vCxWJJv8A ZIPUH0o5/ID/0/5d47eSO7uHu7K2troSmBooJRNFtUkAg4HX0pNRdbLWLex8w3dnIivaxeWZigwC xbA24Jbp7V817RmqSUmXtQNlafY30qzxcwQME+Q7NzcnjoBwPyrImkgmttRVjFFPaQpdzW6r50pJ OFK8Z6ms5TbM6qRoaaItS0+W7tohKlmES5F9MtrJvPGFU8nocAA9Kmt7G21SaZY4ks5WBW2icEk9 ABnqM+teXBNc0T0MOo+y1M4A6ZZF7+3eSSAfMlrEZFnfPIBPt6+ldVJp8ertHqEVva2lgyIl/bKm JQEUZcHsRj079atq2pfMu2p//9T+XvSodL1aS4Nszpb2s5iEMsW2c4YhGZSBnOAfx/Cuhura2VoY XjgEyqWjCoquR0LNjk9hzXwLvex63Mkrl5obW2soLuaKKSaJ/KhQqJJUU9SvH3Se1NHh/TZLc3Vv OwuJpBJJ+7ULEq4wo+uD+Z9qqCHdDtRvZQlra+XBeI7bXa4RJjbhRlQoYHAJ+mMVl3sxhs7iK00y O6n1O4jWaSA+XLGVJzyPujk849OlEkkPm08jTttHsZIZIJNPtEklhK/bRbL9uiywY4kxnqB+VLaw x2Mji3Z5UjQwyLIolJ4wcjGKV2/dTBvQ/9X+ce20vSpbO4XzdNhAt3uBBcFIbidiBvijbG7J9ARX NaZ4fsy0ZWxtbKUSl3QSFo4xnux6gf1r4Pmfs+U9qs1KaRqXdpp8KG3tY4ZXlJEs0iD5DyPkXv8A jUFjaW1naLZtp9jKluS1pJJAFMJPbAwCPQHpSk5JmMbJ6Mb4fsLyxnurjU9OQWRVWW7MW+xRixJw xAAIwOPeu7vNK0+5gf7RZ2UyvEzr5wxHJkHkEEc+lZylI0t2OQ03QYtNuk/s35JbgmKW3+X7PcqT gBuO3qT3roX0fTY5HkniWS8UlvOtyrJE2ONhA6g9wawlN3uzaC0P/9b+eDS9PUytGseZbhsE4+eX uPfNXNVslsLVbV9G+3JPcqBBFADIhPWTPBA45r83dSStqfQWvoZKaRoJBjhgc3rhorq0nhAiUHGG DD/Cpl8P21lNE8GYDEpMbxth8EYYEj27VMqs72NIwVtSH+zNKRQ8Gj2hPnBbyc2wJuFIAAbPBwM4 x0qwfC3h1YXWzsYpJWfYjtwYlzkKAPQn3o9tOxXJHsdFa+FtMu9OeO8SFkgG5i7bHPHY9eAOAKpw eDfDF/cLI1rZw2ltGWK3SrtGMAtnue/51arSS0GoxXQ//9f+f7+zNAvNUgttP0bRnt45BJA13bKy xogw0i5B6jnHfNWYvB+iLwljYTfOz7pbNI2kJ45PbGB3GK/NlWaPq7U2tRbHw74de4W2vdLsVFox lw0YVrjd6NnOenvUF54L0O51GS5tbCy8iKXEUTRBFAIwDwM/rS9tJO5fu2Lt54L0q1EVzLZ2IuLm MLFLGiMttGRsIVB04A68/XNc/b+FvC0tzcaalhbXxiYT+ZJbsI1wccA8c5/So9vPuLlgzYuPAOim SGS80HRrpQBNbC506KeOLjAIGMDArX07wN4MQXK3+n2IurgeZYi0tYl+xuvOVVQAB2wc9aSxlaOi k7eovZQ7H//Q/AnWfhn4a1exuI5NL01r64cIb2TemqbASSqspAC568ZqeT4c+DL7fpsmi6O1vJZJ HLZyWoayuJFQKZDuORJ75wfxr8xljq+kVJ6an10aFPVmXp3w98GabY6nos+i2VndLGg0BtPsU+y2 QjYBkboCrA4xyfSrFv8ADLwdbrdapF4ft7p71oo7yykuXKW8sagM8IBUbX54PTGOay+v4q7fO9SH QpdEbd58NPD1pa3E+l6b4dsoNUtlWawuLAX14WB/1nmSKxUn2I6DjOK5a7+HGkSvbLqNhpyW0Uax RHT7KLgE4OQU5PTOaX12t1kyqdNbFtvhL4DsLkXuneHdIgvZLZrM3b2atKFJHzBfug8DPHUfjSWP wY+HCTz3l7bySSqhZ5RZQMJgRloycbgpI6A0SzHFPWU3fbc2VKmlZH//0fwIPwh+H97Yxx2XhzTd PFtK0zyWsRf7RuGMMrkjH+NZUHwc8JxHNrpWnRhG5CWMKgc5CcqSRnnk96/J/wC0MS7pzZ9p7Gn2 NNfg/wCGobhZJdO0++uZrbYkEREfkE/cJKqOR6ZrPuP2d/BdxcQi9hvUuHi/4mKJJFKHLYOxQUGV HQbua2hmVaH2jWFOD0aFP7PvgNEuls9PaSKF41tIZlV7kc8klFUcY/Wreofs/eDrCBJ9NtriBJk/ ewSqkro/BbbkEgHtTea13vK5ssNTtoignwR8MX6Ry6hp9xPpOPJurcXaRNNGeGQgKCCfcH8OtZ// AAz94A2XCjTboWUkhWO0keO5YL/BmV1J444AFR/auJjflmYSwtKTu0f/0v549M/Zt8LzTJNd6Pp8 k4GZL+WeSBfL/hA2nBK8cYyfSq//AAy/4Hsjql7f2NtdRw3ccmm26XMdtPIyuNrqTGzHGM4zxnrX 5XHO8XG/vH2n1Gm3sSD9lv4ex51C3trmGTU7kmaG4aO5N8WXnLBV6HjJBH60D9m3wxdXD2zw6rYp 5ZEEcNnHdRJIOMlztGDjGf0OKzln+Kta/wDX3gsupdh0n7I3w5lS7unt7p9WaaOCJbO2Nv5a7SWm Vl+8VbHGMH6VI/7Jvw1t1geTRhc3kEJDX9zqDNLeyMOHnTb8hHIwuAPel/rLjLcqa+4znllJbIsT fsleAGt9K04s1obotDqYz/yz6qsbgBioPVSR+FJr37F3gSCPRHsdWutZggQytDPH5MttMOFBjyQQ M4B4NaQ4mxUbXsVDKqTTbf8AwdT/0/56NR/ZG8H2cFtp1jNL5s1qtxcKLeBBYsfmkUuBvIxknvXP x/sneBrGRks7S/vrliz/AGxL8RLHu6qqshwPbpX5iuKMUlpv/X9bn2v9l0CR/wBjPwZIrXulWN5A lnCgnluGjkZ5mOWCDgHueBnjnFcVqP7FugX0utTXzLG00Kskt9LNs2qwOYSnAf1A46804cWV4t8y InlUPsGxp37Jnhy2udllZ6newT2yrZQte7irKoBLxlTwSCRjnABz3rP/AOGLk1WGW6YXNjZRXG6N YmKwyzDkiRyvAPcKa3hxZNSvJXMnlN/dKGr/ALEMcFi876hb2rtIoMtpcr9qhz6Aocrx15ot/wBi w3ymS4nt8WUG+3vri8FrbXIGBtRgmC3qCPwrT/XC32fw/wCCZ/2I+5//1P5crz9iS6aWNIbyC3Ks 3nzWuqpNaqrjKSH9wN2O+0nHNXLb9iKeCCyRru1vZ1dW2WerAXVz6lpDHtHrgg496/PI8Yxf2Pw/ 4J9M8ll0kVpf2MJ7C1keWfSprq7uzJdGKWPfGucKjDOCQAAXHX9Kybr9jK91FP3V2tqlgDPPJHdR IbxeyKAuD6cc+pFbx4shbm5fw/4Io5PfdmDqP7IN0Ll5fI+1EwB1isL9Y4rYActKAvPuBk5qla/s g65qNxplsMW0cjN9oW0mlS9K4yCI3QZPHAJGfWtI8WUrXl+pUsoUdLkP/DHmoJcW1u8jqIZHlklv J3KyKC20SskbEH/ZxitLUv2Qb23sLOa8utJeScmeF9MFwLlAp+WN1KAbue/UfwitVxZQ0ja/mTLK tNGf/9X+SBf2NNVtrotfLqEl3GyT3Je1Y20kUnIUAYXkFcMD1ro779jzxAdJR9OWxult5GRVutXj tZrRgcgYCsTkZGPbrXx3+tVBNPofTLK520MmH9jzxk1s7O9rDOkayXAhvvtMCZIC5+T35AxUV7+y H4o0pZ7e7R5ppOYJ4oZHtY965QsQuCo9M57VouK8G3Zf5A8qqpf5F2T9jvxkuiWstro8t2uS3mvd fZi7DlmMRywQHkZ9e9VYv2QvGUcl9AdHW8TT4Fv550vofl83nagPzDAxjk9cUf614PZvUayiu9kW of2SvH2qWzWem6HDdThtm6+YQ+QrkYaXap4HHoPfmotY/Y28d6X54gsbIyizBs/JvVmaSYcPm3UF mXOcbTuP4VUeKsFdRkzRZNiN0j//1v5Arb9k/wAa6lb2VudK1W81e81D7L5+k2E0drBj5sbXXBXA ILZyM9MVftv2SfiFa6lco2h3ltaQsfLkOmy3Msm35XCP0yDnP9a+aXFOCT5XJf1+R9isiqtL+vuJ IP2QdfW/WO6F7ALh/MEP2GS2kRifvSMyng+mB9ak1L9kbWrmFo4vtpadvs6RWsqvIWUjlTt4PTsQ c1L4owjktUU8hko76lW0/ZD8W2+mR272eoEwX+ZJltzNdygEnYzBcDjqOOnFb0f7N3iO705YrLSJ rqa4uGtV86U2US7Vycs6AgjsQO/Wl/rNg9+ZWMf7EqmNa/s/a3p2mR6PdeF9SiubiVrl7x3N3Dbq ucq79dpJ9M84xwaxZf2e/FtvcWs1vaW15f3U/wBnRrZJfslhAxJDyAruyMAHaD17Dmn/AKyYR3tK 6+REslqq39fcf//X/kMg/Zg8d6lE13HaQXF3aIRNplnb3BeNegdgEIAPrjIz071gXv7LGveZpYi0 rVYNU1C6JhDWUs1rI4x8mAo4z0PqRXy74jwadk9fkfRzyirHdD739lPxwIZ3Bl+1K5AtmtArggHK gb8YB6knNUm/Zz12OLZLbXSz2yqkVvHbSs1/K2B97ady59On0rSPEGFl8LOaWV14vXYntf2bNZX5 bi2ubZkyXtmjcSSEjoHK8EGszVf2cdZt763hjXUlikjZme2i/tC3jbgqruqnHX9K2jn2Gls9Cv7N qpXZWh+Ani3ZMtpZNc2tsrNO80UltMSvHG5QACcAGrlt8AfEMVhAdT8Oag0V55ixmEmSRuPUcgD1 wR71pHOsK/tEywVWGltD/9D+LyD4CeIbyZhZWd4YlQ24guoJYApBwSX29fpVu9+AnieOGWG2sZ7i 6jCRWSJbSu8shOCCcbeOMn69K8r+2MNfl5v6+89mODqPVIpXnwT8T2yXVvd2E6XNvIq+Y8Ewglzt BXcFOSCWzt6Y61NpvwY1WczwTE77Zf3whti7ruGUULnIJ9eevSl/bGGteMr+n9eZtHBzXxKw9PgZ 4neylkg0y9inCNJGt9aSocDpuCpjb33ZrCsfgz4lng/teazluNOEojNzZW0rqHXIZNhAZuRjj0rS ObYV6c3kRLDTjq0bF38NdUvFjlsLS6tIgQkkd7ZSpJJgAExptBOefpWBe/C7WWnighsCk7yEfOJI F2hSdzblwDxjHqa1WY4bbmWhhKDWyP/R/iSj+EHiqUyiWDyYon8u3lKM73OQDyo+7jgcmoZvhz4s siyNp8my1dftUiI0kYQ9WH064riWPwz05kd8nyaMnv8A4a69BLaXDpDLYXC+YHRi9wyjqGjHK5/2 sVPYfDjXrpXit4xHGx3qskbtweB8wB2njvT+u0d7r7zGTu7mDfeCtVtbhYJF2zyymGNbQmeQlck5 XbnjFaEPw+8RtDDLbafcywruFwZbd0yR0xkVX1mnbWS1EZ0vw/8AEonuEFpJtjiSYpOwSTLnG1R3 I9qtWPwx8Z3s0oh0mUW1rCZp5WBPA69AQPxI60fWaS1ckNRb2R//0v4eZfh34llggvksJ1tDdm2l kZGDoRnnGOmRxTpvB2q+bDBHp9xskJV7pIzJEuAev5Y/GuZYil0a0OjkaVkik/gTxKrJt0m/njeX ZFLBbl07/e/ujjqePer938P/ABDbWQuYLG4nwwWYLCf3TH1PTFae3pdZIy9nPsU73wtrsNnFd3ls I7dlCARtvfPbgfXFYlhoHiG9lhjTS7uFXRnQXUDQFVBwC2fqDjrjtT9rDuQ1JLYtweD/ABTDdHfp M8qw8SGFC+CeB2GQO5HSmSaFr5mc/YL6MxyGJQtuzJOfY4wR3qo1qd7XuJXtqf/T/hbm0HxFapG3 9mXDq77GmgjLwK3cAn071Wj0nX5JyG0u4aIP5cM6gMszDG4D6Zq/awZpBSubEGg6vlQNMuFdZvKf zFEZVh2APJon8Pa1co8q25RLeQx3HmgxvwBgqD1X1PSq9pDua2aWoy70e+s7W0LaXMWm4SaFGk3H GSDVDUrO9MMSSW7ADhNnzuT3G0c1F6fc0gtAtdAvQGkWwu5UjjE1z5UDyvEpOAWABIBPAOKeY7+3 3xQaVqgeQ7USa0eNR75IoXK+pZ//1P4TZtOvIGke6tnjjiAaR2XCjPQVbt1YQs5jVo1b5ZGYDGeg pu3Q65vWwRWmpXsjBLS4mgRi1wqocwL6kf561jh2JlFtb3EkauyHELMAVOCOnWs7RehFkSR2d1fJ BHbwPHJLlyZFKMAvXg1ZWVIoJPtELxiGTyWaRMBm9AapWSsjOUdNAtbO5vgxtrV5URiN8Q3cjqCa iuGe3nt47iJxLP8Au4YWQ7m+gxTaRPLLsf/V/hZexvjHJ5CqkNvHveP7rfl/npVCztZp85Plshx8 /GamySZThKxZnluIVEZR13JhflLM3YkDv+FUvJli8sTQyBpDlA6FC/sM1E4xdrFyhNxVkbT2vn2s 0UcLebAod48YeLPQ4/A/rVWNE8tbeIkOg+ZM5dT3rgcztdP3DNuLZoCCwKo5+VycAGpLdGeUFjuj A+Y/dwf61HtTJU11P//W/hRnaCGWCGIgyb+T95j+FX7e1DyeYquw/iT+E+9eP7XzO2UOxJdwOirK VCws/l7IzlgR0yO1OW3WSApGuGHVsfNUuqQosyADbNI0uTGnJ8z5CeavNeRzpsYKkYjBBjGCD6VC qXBQbM+aeKZAiuAyHbjualiWGOQr5fIG5W3Ehvwp+08g5JH/1/4TlimLNM68FsKy9KUymOUjALIB kNyM4614TqHTyN9CKKXdKQVOXfBz0q7cXSQwpGeG3YQKM7j61PtSPZeRcTUWitkMoDEcHIxt96z7 q4OotHCVJRWwqjgGqVQp0/IuxSCEmEQAqF2kt0qO4hdoQUAcgdSPnxR7TWxPs0f/0P4UonGw+ZuY DhlXvURdkRgrOjZ+RSMZX/IrxOddTohT7Gok6S20aJIY5M/vFY4Vse9UIJTOWBypRyB6Nij2iG6R a/tSeMbIVB2sN25euO1WZdVknjWKZVw/ygjJ2e1UqvmJUtTHYbH8veVjDZfAyTV57oxjzUUhNuwA DLjHtVe2NVSZ/9H+FZZVfYyxsVZvnDcbq076SOVYliiS3hhX9yIQQgboTzzz3ryFWXU65U3sU7X7 MkciXJUpyUycsG9RUiXU4QwEh0/hIOTzUOqnuCg+pRkmxiJsny+MZ5FTtPNJbeW0ZEQcEMwzkjsD 2+lT7WJXs0LaNeCc3kO4yldjNGdrADp/KqU13KbzzhNL9oA2tKWO/wCmaanFkODP/9L+FeyXywJD HuH2j7QWIyQ4OQ2fUYrYufEt5JcmcKiIoEZjjyqMAAMnrzx+deLzxOhR1tYrG/a9uo5Y2ktyo52S EluMH8/StGDUL1J48TSRvE26KbcVYnsc0c8ROKvsW113Vra2NtbmGO6luMteMDLIVz1OTj9Kmk8V axFqkUkuqSTWqW4WVBhWLj/Dj8qOeJVivb+M9csdTN8b9/JuI2tpYVXLFXBBOfXkc1rQ+KLiKMwx s0cbuZJYvOIEnXBx+Jpc6E4tqx//0/4pdE1uCGC4spxPcRyu1ym2YxSK+d23d/dPp+tZeq/EPVb2 6SzNp9ijs8RrPa/M0S9cHPU+pPHWvGUk9EU4tGvbfFDVHeO0ukiFpGo2PGgScN0yeOQR2z19a1JP F1tGUt3aSRm/eC9jGJYtw6AdPSmRyvmMhdYIC4m89mkKESELMeepH+elSax4pht2gSxYzyRRjDB9 mOASD75/lT0sZyTvclXxrGqWd1PHJ+8kSJ1ik2vBxywbtyP1rUi8aWumy3l3Npwury6tjFA80oO9 uoeRsZOPSm+W2hjNN6o//9T+J+38dxm43GwiVpV8mdC+1YWOPnjx1HHf16VuT+L7PVnS1imYfY0P kxmLagZgN3IOD09c14copK5zrzNuw8aaNpJiMcE915Eqs4IVE3Y+ZmJ4Iz25q/Z/ETTV1Kz0/wAt /PYNfzEjakqqeFJxtBrKy7Aaur+OtMu79ry4srmW7WIYkll/dvnoOmOOOn51D4b8VWM2kziRotP1 Ca7kKWRlLLcRlsZJHAPQ4z3NLkiBUl1GzOpLpH2W08u7tvMkmEwWCc5yFJLYyec9OlI+t6Ub66sb fT7Ox063tY4B9iZp45XHMmGZm7gfdOOaXIjSmj//1f4+9O1TTJ5fOhlthHFHlpppFU7R/Djqfwqb VfEti93CYfIs7e6tmEcschlMzRg8KOvOPwzXzypp6BsYehJJfwy6lOP9EScxPI5wzOP4R9OCfqK2 9S1jTbieAzC1kQukMVxKMRW7KNodFHpgcgZodLWwGzp9qH8iLUTE1xI2LSQAOpRzhDGenTHIqefT dGsI7rT/ADbW7uGkdr2Qyguw6KGPqMEcc8e1HsQMO5Nss0cUuIVkAzcJyBxwWP0/SrWkaZYagrQX 9y0FvcM6tNkNEmBlW9cggd6X1fyA/9b+QKW2gsY0s4p5hIZlZbouPKZOVyfc4HtViLVNwmtHkEw6 Sqh5bGcEj6Zr5x4fsZufYzfssWpXRyzSFcAWkp2RS/T/AArTvdMb+0bLTbfTnltIbYAtBJujhk/i A9senTFY/V0Lndiy1jZSsLOaaSwmh+YeU21pcfwk9v8A61PAgjnYxNuZogoVGyhH940fVkNSb3Mu 5jEsYtZmlfEwkaSSLeGUk/KCMVbtbGO2icRTSW8TL9nMYfAlyc4IrN4fsOMrux//1/5G20fS4WhS bT3vNQVvNS9YbvseOVVTVkT3lwsUO21giA2Pcx/M646Arjn/AHuK+O+rISd9jMisNNVnYWcKXTTM ZLxYts8hPHX0qjPby2M0drGzXAY+YkoO6RcjPzAUfVla9iru9yOWTU9Ssbu0Xe8TMA0MrmASbCB1 xkd+lXlit7ULE0QhngTzxlcs7EDChj16fhzWLw2pfOU55bbWLuRbwCGdbb91aRkmJgcA59KvXMEW oWqaZFp0ET2cCrJqI3CcLn5FU5wAMY4FZvDlcy5bn//Q/kN+wxtZz232iUo0YTDNs8tlOTt9M+1V vB7afHHeXcMkphFwUIKEMCp2khT6kfp1r8+nhtTTn8jRtL23vLrz1upYII5ij7Yd8sKbiDjB5yBy PatCPWtKV7kRsbuVozD5dzGSu0d/TdzWM8Noawn2M/z8YvtqRWqSDzWAwxcZ249/T6Ves5bO+uZ5 J5ZLmNY90paUuUKjAwO2OOlZLDiuL4l8XWGjHTdM08pG8ksctwlpHnzTnKO2Aefu89eKiv8AWb9n +22l1dm5tWMtlJJKwDg/wvGDggjsc0fVyZTsf//R/kofWb6eRbqQw28Hlo7yQy5dZDndk9uuM1oX 2ozOkd5cyG68iMS6dNI5mntmHUrnP5V+ZLD3OrndrHN3PivU0MrRCeyhmhLz6hakW5bkDLOOjZ5z 9a17fxdfS6fZaTq+uag0cjKHaWcgzJj5nZ1AP4e9P6sZynbQ9BsvFWr6dFK2havFbaeIthSyx50x A6kD6dSD7muGm+JHizVr1t2s38emRN9mlsLS8aD7UEP32dcEFjnODij6uVGrob9n8TNU0aSK3s21 C5IOQ13eyzpCpBJVXZiQB6dDV/w78fvFn9qalb3F9qtlcoHhF95rQSrbD5AisMDYVwuO6j2o+rD9 rof/0v5arD9pPxFJfSW+nya5BNDdm3S7kSa1tYB915FfGHyOmD3rYX4v+KrVFitdVmupFc3AkuPv QsTyARyyn0J/wr8wdB22On2uu50sP7XvxP083+n3l5HfWl3aRwHZH9muMQj5IwBkEcYHfnrS6f8A tNePI5rS/n0ixuETF2Le5ZpluOQfLkLDj3Ax3rJ0DaNSzO10z9qbxBZ3j3MukeH5IbhPtU1n5txN Bb5zlVXGcdsDHSoPCH7VOo3mr3FxrelfYLt7pk0p7S9jNjZxtu2l02b8ZJG0g9fvdcQ6BTqeZ6Nc /tf+KGt7XSbbS9La1S8YTPby+RLcIuRhpck88nGOPWtG3/aZlutVS/u7Q6HYWNplNP0/UZvs9w5U qzbixOT1wePSsnQ6FwqeZ//T/BK1/bC06GMNrE91eeHRqPkarLZW/l6lDCX2sPnbLFcjkhq2739q z4P27Q/8IjF4l1jWFuzNG4jWwlsgB8mXYbWxznpX5D7DpY9nmd9zqdU/amW8mGsTy+Q91Zqs1u88 SzWv3eVbbk5x0BydxroLj4/eCLux0y9l1y4t5QFF3pRmkMcJ7S9lO45IXnr9KHhx87vcW/8Ajv8A DyG6k/4RfWTfXkSC3a8urA2asWAZ/K3EMSDx0xkE56Gj/hp3w3L+41PWLm2lgt9v2yVTLYOc7VXa owrDuTk80nQNIyua1z8evDX/AAjfkDVdML5azeK3jZ3ZT8wkkIOQOgG3ke1bngz9ov4d6RaXVtou sWRfXrUWeq3l1M72bOm15oYJHGMgoM4B+71701Q0KlKy1P/U/Llvjr8M7+5tXuPEOlrpkBYXctuZ ZPsxJIUybFI7dSRzVA/FXwffXksFt4ntWgtQwtdQ1GQWlpOi46Z+7jJxnIIHX1/IHQPooz+ZvWnj X4QtL9kuviCl5qKKL2KS1dLpJHKkmD93kLjoOe9RWvxC8NXFreyWmrQNf20e6OEzxlsZ2gnDHoeo zms1Q8glU0OivPiL4XvrcWXiTxVHaTy2UR86Ng8UR2AiJ2yCh6DpjJPNJBrF1f6PIuhXVrOkkYtm nbUIGv406N8ofeu4fxYGR7GiVDTY4p1NSkmp6JCkWqeK9ZvbTRrFvIkTTLmIzy3EY3J5bFgCykZz noPWsu08e+DrvxBrFxJc3WuWt+Y3g1i7nk8+9yuGWRR91lzzjIJXuKxdEUZ9z//V/NnSdXh8htK1 HVBd2LXsk+hPOcxmNzlo2kbhdpHAY/lVm/8AGGh2Juo7WWS6urWP/QorVknErr1UtkY5zzX4m6Gm x6913E1Pxmb22t43urWCDVUjtbh0mCPvRVyAinJIxk9619F8UaZpOnT22oaRZ6q6XQW31KZmt7zD 42oGGCVJXOD05rnnh7DjNJ6Gu3ipopI9Se10iRPPeC60qzuFcQpsKrsxwMZ6nup696ltbi1vknkl ke0li+3eVM26UFyWwknTnPAwTyKwlh+x20qlhttr2oalphvHtnttFhvSlxJJGD5ihtuC3oRgj/er tNfttLItb+wniisjaqkEEt0vlMxAyyAnqTzgetRVw9uhrTqpRkkf/9b+RvVrbULvSodRt7i3ig1e x86K2mXbGY8bvMkDAFSMcKcGvBPFbwnw/pr21jI+ozag6G4gbzonROjMP4f/AK4r5r2idSTOitsp HE3QhuZLe3kSUXLQhpk4KFhxgY55qj+8tY1gNukUvmZeSNsttyCBjpXZTnpoK/vWPS9BOo6lFeJa wLFY+ZEt7cQkvJbx8jcB6k8flzXT61Akd0nh3TJbjUvD91As9yl/H5ETSFQCCM4yCDz/APWJ1jOz FfWxm2dt4esVvoPst/eXWpXUcMFrFdtDZ6PCsZD7CD/F6VSl1KPTtNXTbe+uYbSG5ZBbGRpo5ADk 7yxPU49+BzWl7oo//9f+Kmxd7m6S4yixJMsqW0PIAB4GDkkH39a3Il07xVfyXOm6p9m1C2vWivsI Eht2TBOGJPP4dq85uxXN71ytq2rL9mSKa/hkkj1VUtPIg+e9YhllWfnk5xjIqCeW7g8g3QhdRPIJ ZLaPyzErDAU+uP61nz2bG5O3mEttouoWcukraGRmhSXzwzQsvlnO0lfvA47/AONZM2t3FglxPaW0 gBiW1D28TyW9rHkRv8wyAMZzzVRlfcOfSx2GhavoHhu1hMkIjZoZbci3jeaWMzgusgH3c7iDgH+H nrWbpRudSdEllZkgkLxCfYk0ju2Q7gDJC7eg4Gau62Hzn//Q/jbtLEGe8v7xPtE0+4CZEJmkIyAT WAmjGw1Qzvbyw3LqvmOXLbEY56+9cUZW3OiMrPQ6u60i4l020EV80cL3LzNBcTCOFtvOEyc84Gfy rBtbjWLaRYNS0vSbhJwYreeAO7WanILHtnHOT7U5S7F85d1ixtrzS9FTTtWW5s9Jllv2e7t1QxTN 8pA64HAPXHB9TUVxeXtr/Y8BsIJRbxO1xdRkqCzZw2D1znH0FZhz9zQnmvb2CZ0j09Hsrb7QDdXi WflgdNisfnPqFyarJf6hYX9jLcQWVyJLXDIpLht42jn2z07YFD2J5nqj/9H+NY20lnczXQ3XElyc y26uPJgwuAVx+GahuLm1ns4YdRTyf35lM1sCs0nK4VvYY/U815jnbY2lLlNRp7gXEdhDeqQ1qbg3 1nKJLdBsDeWWxjf82MHoRjmrEkFpqMEEnn3NwsieXJFfI0MxccHg8leODWbdzHU0bHS79Li70eYw 2832RLyxE7hBOrA4Cn344qnBpbWl1KBMkE9vA/mb8zQBiCrDIB65YD60t9AMmOSexls7C3MpsRKX LbdxQs2X689s1uXpimSO21SFv3C+ctxCGiYgnKlsHnpj8aAP/9L+Oq7vLvfJDEroJlVIk8vfISOh X6+lW4oTepbyFJAqkRzTIC4QZ5IX14PFeDe0roq0rWsbsiafOtnBBNc+TAWtlvIox9rhLHglMnaC ffiqSeGrfQ1ZIxI7ySma4ugSyzPJ3Pp+P6Uk2roTNKbRLPyjcfa45FRFilRmAfLAngemeM1myWv2 b7NZWNtax26MRNHHhdwYZyAPr2qlLSzLginJbtakXk+mQx2Eb/Z/NldorgheXVF4yvTJp1zo8F/F cT6daQQJdRRjRobItI9oRt+fa3fIIA/GhyfQ0P/T/kEl0/xBd31pDqmnw2jaaoMUqSn7Tdjbj98D wOPQ1s2n+kDbaSRxuZCs3mnYi7c5wfwr58CrHqcsd8i3SRzR2yMLc7i4QnPRT0GTn60s1rc6pc2M cjnNxc7YVBCh25wp9qBqTWxHpuqR2d6bpoYpL0uLa3VJNjRFMDPvgDpV7UNdDXcmjvfahFaahGJj HACtuzj727sCD3PXArOe4m+5Wa8j022bRtPkeXWb91S3/tI4tY1+VvNyTkHpjGM5rXv7W9sLS9Nn tvJDZFifL2oxK/MCO3PGfpUN3YH/1P5EI9RsrB49N1ASyTz26MsT4dOVyWJHQjsPYfSpY7OOdLhf tUjzxfMs08e0Efw5PT24r52TshpN7DIriLTisNxIG3yBdqDcxLHjin3uq3CalLa6PB8v2U7JrywJ t2bClvn5C455Bz1rNay1CzMu9uIJdXjW3knhjkswHRgMLIAPNYH0znGfWrFsLVbkxI8kogjV1kK/ vJH9WHY/Stgtpc6C4gmQeYqSpK8QKyAFWbP+Nc/JoPiIu15G+nzpDAbtoJbpY5FAPdc5yOOOvNQo qOoj/9X+S+1ntLtLWLVfL+1ToSvl27KkZUdFHoBjFefaprOm6J9p8+K7kuFuJJEubC0aWSVQRsiY D5QOPvHmvmL222A9StJNJ1GC2hLIs0trHNcW86ERRMwyAW/D8M1RtdaCW99ZWyx7Jt0Fyqxgqigk EBvQ+1IfQoyajpNqmkR6lM5sYrvaLaKMs7qfvKuB3/pVi91SC5eSNmeOxRj9mVz8sefu/jjGaBxd mkYlounWrXmoTSlpDlxBHEPLl4ADkjnIwBz1q6dOla3uZLW6mmnnt95tnIVJF5ZgT644A9qC22pa H//W/kFtcAT2ktsQirseML+747DtV9bW+l1fSdRsy9tFYoUW2SPfCMKFJ5zgcZweK+X2N5aLQ0r6 zs4YhGkkcl7O+5ZWTe0JyTtz29KS1MccCwT6Z/a97PG6pbCXyolIxhge/UdfWtLWhqTDYtTxtGEm kvY7nUPIVjp9tuWSx+YKN7MACAOOOPesjVZdLgntZtWvZIVuJFg3YLgHBwxA+lSpWsOXwsv6DqGh j+0rSS+NxdpEssGnG1bZguAzFxwPvZwev4Vk6hotzrNzKY5bq0tiAfLtZWgUBTn5W64NTUa5kNfw T//X/kguknZhd3drax3FtAIreYReYJdigLu4zk45z1NWNIEfkzXETKzSNkxLz5ZAIbPp2/Kvm+d2 sZQbukNJPmXFtJ5bwTR+W8brvMYbqcVYS0s9OsBbQR7LMEFpI03MAO+38OlRdo1jPsaEFxN/ZUc8 Rkt902+3mVSssiLxyD0z6VyLubTT1ltIJ7iSfU906CPabeN2GWHTPJJ56UhqTOp09rvTrfbLbSlZ 5Q0LeWf4ujfqKztRuNRk1C206KxZllPmzTMpSEr0wrf3vYUFqemp/9D+S7z5oyiRbhanKSb1B3Fc Ywe1RQtcWcz3NuwT7SDFIdu4IrcEgdvrXzF31NedGZa6W9nPPch3uFbeQzkySoXOSw+nYfStW3uI HKW6s7S2oCTvIu12LAEHOMH6j3qW7K6I5mndE+q3F3HZpptp58j3Lb3CIfIXHQlumfY+lZsYeCKy sG8iGW8kMF1KX2pEpB+bHr0z+NCu1qap3VyxYwyQqy2s6NaeaVc7SqsVOCentSarJY3zLpFtJIXi KXE0agoXYFWDZ9OMDB6E1nJy2Yz/0f5J7az1GfVFuLKW4hiFr9lntpJMiQqf4ePun5vz71bvNGgE vn28Cx3e0xean3xu+9j618edBiSTX9vBtgGJYpfs7Pcr129Tj8q7aws472WJLV0kkkUB1YhFLY+v GaCeZFW9sPsN/e22oq9xNPAIkheRXit+MgKV/Pqe1crY6I8MsFrtYWiytJK7gnr0/p+VBk92XdQg t4pY4bOfzJYjuXHIIPUE9P8A9VWZbRYrQXEi5UMqOVGdrN7fnQI//9L+S660/SFeykvYEu7R3zMr ISxHcY9fSq8rXsc00ttbNd6eCrWYkj3PGVzgNgcYGMV8lGTvYNjorXUXbNykSrjCui8R7sYI/Q1a eeFIpi6SG7lZdkccRm5PACgZP5VU29kVzSRz0sN6L62+0w3ESRyBliaMoHbtuBGfwpNQvLs3sjtE LeMSfN9nyR17p/8ArrIFJouTx37XFgzypFYJJ5wt1jxJMSuMs3p6D2qXWXvpbdItKuPK81v9Y0e5 ox3GPfp6UGqd1c//0/5UdOa1AjglninuvIDNblMn05HTmsXULJxfxWV4txbyx3iyNHCvCFcOgz0I PFfHnQdjMbyQpMs95bqEWF7iFTNckcAADryfyrlfs63F6txJbS20qtlrmVPLeYjPzMp547ZoAtax p+6y+13N9cmG4uY4FZZAGQswTeD1U7ivWtSe3jgh+xG8GoRWlvGskvklJI5tmWz69RyAM0GtPY56 61SWyjkkntb/AFKdfKiWCAbpYY2YKHMZ5wOK34IlktvPimkdpDhIcbvLxnJb0+ntRsWf/9T+VS2S PSbea8kMhvZbppHBQnzUPK/l0/Gqc+pXStLefZ/NjnVQqIGJtlzyR/XNfIXfc9Arp9rhvLfULPT4 pLZQA8l0jjAOM4wuOcdCR0ropZJUuV8SQwxaS00Zt2gtCGgkTAXJXBKn2HrTUmjVwVi7Kl0JUkN7 vFzCZI2MnTj7mfoCMGqthbal9tL3mopFY6epuRbtD5i3jHjaVxgYOD7gU1N31I5fduJqC3v2C6TT r+UfaQQS0W6GUE52+4HGB9aq+EoD4en164vtZ83z9MWGK3+zbV3t97BJ46/+O8Zq4zu7GFSP7yPY /9X+W2S2l0qIalcSwPHdxhEnt5Vllj3jltqkleuORxzTQLhkt720uZxaCQRyyW7fPMCMFW/rXyPP I7ZrQuQQ2+mX0MkiTThmNxGZUMkaN1wD6Z7E1TisVNzquqXhmnmvomDII1FvIedh247DjijnlsZG rZxXNxYxK9skTWMABCARlYyflHbpu4+veq95ZvZxwpLqMc5vAZYlhVmazH91/lAyPqaV2NK5Yvb5 ZUt7XTLW4R7aJFubmVGKz9ic42881mpfoNTguPskSXGnTLHGA7RpdOUB+Y++e3p0ou9hH//W/l9D tq7XgSBkutgkugGMMceeD5chxux0GOaljt7fToQizTyuF2Ga4xJKvJ+UHuK+POixo3U+y0SSMKqB cyFk+ZRWXLYWrGGZhEk95EEBT/Wt1Iz+efxoTujKtZIsWHhe3sbpNRuriS/IXEcJG2FG/hbaP4l7 E1rS3OmR/ZJ9MhuvthLCZ8eZbFlOQVIHHQ9e9c7+JnTQ/hspX19NJAIpYpg7Dz47eKFnRnI55xyc A+/tS6RqErCVrvy7OC5Hl+UFaN4uxEinpn07UNX0ZottT//X/mPvnSwNlNp9m99ILxd+zjAJGCT6 A+taOopc3WopcWXlYuQEvBcx7yq8lljI6c9D718DHWR6BQvE1iETWFpbW5h+zhYXkJTyzn+EgcYF P0eTUS00GrWpt4VlFtBJCxZp8LkuRjA/+sa0jGwGlIDFa3Ysobe4upn8vzpycwx8htq9C3p6VQsp vskPn2I+0zRT7blIBh1YY3Y7Z59aiSsO7SsdvDfLdMUS1cBrdSHlQI2T97gf19apkQWE/wC9UYnU eYI8FyPQ+/HQ1Bbu43R//9D+a22tpri7kjaySJ42M8MsyjJQjIIJ6Z9q3f7Pk3Bp5o0+XnaeG9q/ PHKysj1au6M7UYCi2j/LAqyGNnGT53p7Z5/z1raGmi+04IkhaQEurCPZJGcY5PU9Oh4qyYq0kMu7 TVb7QotPkv7qOw069F2IkYFJMfeR0I5VgCPxpyX8N3DALWMJa26iOCKMnylAHRQenfiobV7I2jpK 7Oi0+zgkYOykHZtVicDJ9Pypba4jinul+ySyxWjAOAhG84yADj+VZHQnZn//0f565RcT3Md7YQXF vPcOVRJIGhtbXbyDk9j7+nFa0WtajFFKB5sV8i+S8rxnym6Z2Meo47etfmskmj6ZSTZTtbiGWcb4 DGCcSSPwzdiRWrcQR2u0bGlhmQmJyp2YHv2rJ6OxS1MebLlII8KHPC9C2KbZ3Nl5rQRM5uUb95Ey FMY4zz16UhSlbY6yK2W5sbtLiOOWKaMqkav8wx13Dt3rHa+02RI1giC2awfZbjzMsJJFJV8DHTg1 pFXi0Qp9z//S/Aa9vDbNp9xpEVuRFEYLppFFv5URBD445OOg45ArQlv4pTGtu7eUYwxlcBc8c8An 3r8y5GfSuatoVPNW+XekJMkZISYr6ZGf8+tbMcc0lk0rMluYV2kZ+Vz6moGpJ6FK1825HyOJSvEj fw9O1Ps1m017omLcskTeWv3d+DkKCfcVnPQrbY1NPd4oPMkkZnuPmS3c7kg/2Rn/ABqxpUkVreyT zwndjCMV5U+gHvWZvHY//9P8TJSby5cwRKkoHT+JV7mqVvZyR3sbyMfIU/vUA+c/Q1+Ry+I+xTa2 LrPY33+jS2kkckUxcTKd5Kjpn06UkNxGsVxFbKpCsDKzoS4A5yBWYNWdjVvGh1C4L2TSNbw2aGaA R4aDAAJz1xnjJrmTay3Eym1lEqI+1otw3qQeQRmgcNJItXDQpCBBZXck0aHzdy5O/vsA7Vh3F5fp EyQBkLgGaJl6gdiPzrGT1LU9Ln//1Pw+0/WdMtIo7eG4M009tvkhEW2OFlOGGfbI9KU3n2d1WRT5 d0dyMB1xz1r8XPs4v3tTYVLJXjvbW8KTRrvlgxlt3YDv2/WmJPcXc0tzNM9vI4y08+UCAD8x0NBs nZ3LGjXB0qSWOW5uLh7q4WSHEfmKevfsBnv6mt2cXGqJMomCZBIZWAcYznGe9J36GynpuYAtPKhO 9nGG2gddxPA/Gr0cxsNOt7K+tt91E7SyTqu5HVsbRn1GOnvUzTsZubvof//V/HHT7kXvmpOHjtYk 3rhcoSOg/wDrUFYr6WVrqBfKt4820jthkI7getfhsk2j72Mm3YrJE6NDcG4eNI33KmMqR/nvWxLf TxPC6nzI5wRFxw2OuKwlFvQ0U7dTX0bXzp8rXJhMskLklR8pIxggf571s2OoM+/V7LTbJ47q4xIb m3S5eLbwfvAken4Vk4NXB1E7Ii1Ax6leq6RQ2yg8OF2iHI+bb6VXmuI7CRY4rj7W0X3ZUOd3uaXK 1oaxqWP/1vyzKW/2abUZUMs08JjLAZYbuozWdpctmIbqcROqxLiSRozjA54J+lfgvLpZn6WpprYS LVbd7iUwNItup8wLLgKq9P8AD863oLm01lVjZIpYLWE8MojIGeh4zyW/XisnB3saRlHYp6czaRcz PahYbgMGju42zLAuDlB2AIIz3rbN6LqBzqM5JdsI4Hz/AEA6UONmDlFHPTR2xmZbj5oRwN44o1K5 WKC3tDiXT2O4QrjHQfdH0NRJXWgJp7H/1/yn0wtLqFugUxWySh5EuVxAI++7PB+nemT2/wBjKy70 BJICgYGCMV/O+x+lzvezLX2e6kNpYQ6KGa6ieeS98sFZIyAQNx4z6LVW/htvsqRywOsdhllWD907 H+7nB4+orbmWiIIbO/so9GNpc2OmyzTqCJDbJLcw8hv9bgH6/XFRwWNvF/pu/c24AkHlQBwAfb+t Er30E0mWNHSG81G4gEcVtazWjzNcSxiMu0fzBckZyecetS6jplggEvkjMgDBQx2vtyAxGfr+tVdp hyRR/9D8kUY3yXNrtmi3RCKJl5jG0jA+g54rJsbaXS7maFUy7RFmjePEcq+xIxmvwJNtO5+nQhHR nX6PeX95pepWFnYrZIZkU3Zwd6AgnAx3JI/CnibUZILmw1adr6EXQa0iIyqoFUAEexzj61m20ro3 5EW7jQmjgjAgRsL52FJ+QMBx+Hf8avaR4bsLq5S4untbG2JWI/u8mUqoGdg6njn61lzSWprCKehs Xltp8tzbpbRRi2V/st9NHELeSVF+6SBwWGB71nPDY6bNFMsrNfWc29DOir5ETcLsI5BPP59aycqh sf/R/NF3sUFrbQaZb20dpM87SwSvFcO0uN7MQepwOlYxayhiFrE1zfPI0kdva3SkW9uHbJIYH5en XA+pr+b+aonofsSlZWR0lrY6ZaWjNDo9p9pnt2iuLss73Bz0wSccfTtWdZ+H7aWwnuZLWOQae5lX ChbiTJGVX34quep3M3NLQhW30PVLy6XSYbuGAotyYpUEflyr1JHsQSD1qFvB9teTPczSSTTtks0h DYz/AI0c8+5lez0Ltr4WjW5n0p5F083WnAWuydYjftuGY2AB+8gbg47VLJ4YttLKz3NrbwySWf8A Z6iJFjljjyARxhsHnk9cmrhOd9wbuf/S/Nu+0zRmtYGttPis5oovLee2yks/GMsO5rnr5Le1QwXy TRTSxL9meRmLSDjaAewI9K/n2Mqh+rOCbuZP9jXElzHcWNvAiWtqTcH7KshVSQMkkepHWunXTbPV 7cm+hsZFSAeWZLKOKRnXhWHygitPazihqMbHP+INKsEOhtd6NaTxRMUgX7MphkP8RfGCeg4/TmqM unaVYSkWGi2VnvCyzXOnWSgKMgYLc7eSOmKuNefLboJwg90ahsrWa3u7JJHS3uYMSWrANHtJ3YK4 7kVUi06O2az83TLKTyF8uBpbRV8uLaQMDH+c9aPbTRzSjFJ6H//T/KW58MWF9HEotLBLeMlo4Et0 gjX+8TjGc89awrrwnHa2ZuTb6fLppnzHbSIskaHPPlxnJA55I/OvwH6zPa5+lwimtiW38KaDLp11 Z3dvdJZ3YL2CW8SrbJMduTnHYceuDVSLwD4O0m6gD+HLFWBW7uNRltBc3N+6ghVfJAI6YGOmOtWs XWTcYyav2CdGErabFw+CfDmosZrzTVluJpOHU7AIz/DgDoPr0NZ938NvDdvdAabaQtZQx7JLUfvb d+MH5T2HtjpVLEVUuVPQwlSUndnNa18LfB10PI0uwSPEgaVruPa8J7iMKeB7VSk+FHhK1W5ebwtp FxDcRJb/AG1bLE1vIoB81ZDkgkjvkdsVosbiYqyk/vMXg6Mt0f/U/E9vh/ZWdtax+XDLDIRNa2tl Zx+U7HC5nYDrgd81SvvhhoE945u9MgNrNCqzQwgQrE2AGYDB9+Olfh0MVXXvKR9vPBUpP3lsZ8/w M8MTXAksdMtdQtnUWsAuG8q7t2JGNqJjPf29qyrr4PWGlzpHFaQWsSo0EsNvGFLc4JOck59PeulZ hX2cjB5dQj70UTH4LeG7WxDWtlYrLkOLm1hWC6Q4wUZcYx15GPrV2/8AhN4Whh+yyaXEI2jSYRCN brdImHDDcDhtwB5zg9OlVHMsTzfE7kPBUU7WMyb4UeGjf6TdxaE2pxXEqNdWmpQRF3f6qoYZP4il n+EnhuJNWa1spYfNyxt4MbYDnlSuOR0GetbLMcQvtGsMFRtsf//V/n0X4W6HLJaxzWeyzidSiMQq qwG1jgcjvx06VrH4CeD52mkuYxKkhPlsMpIWA+Rmx8uMcYFfkizSvHZn231OjtYvWvwT+wpboLHT ms3XzGt1tV2TKmcc8MRwe30NVLb4P6NfTat/ZaJplvLuQwSwbbGDHJQAg9SepyTxzVf2lWetzP6n ST5bHMp8AdE1GxudNv0tFKkTRQw232dWAbJ2uM+gOMD2qef4HeEY5Yp5bW/ilSIQ7LOTdDMqjAP7 wEgj09zV/wBq4hq3NoZ/UMO3ZouQ/BLQbi0s750uL/UYWN2BcxiCSAkkbGXkSDB/i/Kib4VQwTSG C3sYpJ4DGLryFKxb/vAqFAHcHjoaf9o1m7XG8BRi72P/1v51Zvgja3aWtnuTdb3bTQ2lnBsRwV2u QwUgZOOCOcVak/Z38Nw2NtPpUeq215BJJNO0k0Twec5Uhoz5eR056Y4wOK/L45tiVopH139n0Urt FLUf2ftKsorHUNVu7Zp9z3C3cSG4mhcjB3BdoY4OOeKdH8EbG+0ySD7Pb/ZZIX+2G5jRJXTqDkru yfQHNXLNcU7a7CWX030MZPgX4bs9Pt4bayia6gmLrDAWZpVx0JPHX26d6YnwF0SZ7qe30iwtr+6L O/8AxL0MLF+pdsFuMDH0rRZxi73cmV/Z9LsX9O+ANtbpeWsVvExuLf8AfTIBBb4UhiSCM5yOPT1r IT4Haas6PPLeLDCMRxm2W4WMg8hckZHfrT/t3ELW4v7Pha1j/9f+aqP4A2l/qV7bT3Gntp1shufP EDQrMhCnBQoSWycFQDz3rQX4GaDb2L2Z8L6Ney6jCHs55dHVzY4OMq235WbjIYH2Ffnf9tYiS5Yt r5n1v9n00tTn9G+CWjwGeDyI45JgUvEjT5GUcHAwP19qy7r4Ew27MdLht7wm4DeTLEFMIGMBlwcj qfw5NbxzuvduT0Zm8BBbblv/AIZyRYQ9xNpW+GV3htWtGuJGcjPEy/LjnAOT0NUrn9nnTLlNPiTw 2GuI7j7RcSQwRQRPyNjncpxtwfmwTzT/ALdqxl7pjLBwa2I7/wCANtZaf9nt4VsYo7v7XPth8m7u ZXwJA2FII46nBx0PanaX+zfoUdjf6lcSwDUYo/PshdqxZWdgu2B8ZXaM8EEda1WeVOXTdmLwkb27 H//Q/lu1H4C2NyZ7W6DY8jEk9m3nN84GNnygMecHnjB+lY3/AAzD4YlsLWSCxubfUoHK7prmQRTj JO5wc4J6cYAAr4n+3ai0R7M6Eb6Ivv8As82XmWzM1j9piUKphhkk+yAjBw4OG9+KqX3wNOlzXEnk WmpQunlxyyo0zRqOrxR7cqf97JqZZ5NyV9hxpwVOUmtgi/ZsadNNnjXUpU1GPyJGtoYn1L13eVgE +gwO5GBioNQ+A9hFA/2WK6EzEQyySWsazhVIG8EAncOuDxx6V6TrJmk42gkZdj+z3YRxXcWoO91A qNJAs8Q+13Ls/DSKV2rgdlq1d/syaXe2UGofYnjxmFQLgPCMYxhUIxgdjnOe1Z+3Oflj2P/R/k2u f2atLWe2uobPU7g27/8AExu7a3EaQI2FjLRYOBnIyW544HJptl8BNRtWurtoPNeUeWqNBIsKoDj7 mzAJHUg18n7c9ScexnS/s8TwRTzQWE9wlxceaqESJCGJ6R5GTg9hWfH+zzqVsAZXlgmuLpnuYPsk j/ZIzgKykjLdTxwOOvNT7ZE8suxSt/2aJdYtXXUWuZ3hvXR5lJsInCH5QCMjOOoOcGqcf7O18Hjs 5rKeZd7GKW2lXy9uSF5U7gwAGQ1L2yKVPTUWT9mmXSDBPPbXksmpqUtbdJfNERBKgkjJDEg8NjPp UD/sz6pG8W/+1dPkiLLNDeKplZieMqRz7baPbIPZ+Z//0v48G/Zv8WjUfL0kw3mjxtHcX66iW057 fABb7KSp83P8+Kmu/gJJeRS2tnJ59444lijLTwy/3ThcELjGOOlfHuskep7PuZepfs36xbwXNwDc 7orYMbZSEufMHBAUrznrgHiudvvglrVjpthayT+XqN4zNb+dB9okd8btmFPBxgYGTx0qfb9mP2aF n+C3il5B5Fo0iW1qplgSyeRGbHLP3HOP605PgzrwtxcLZzpIEEjpFAZijdxgc4+lUq4vZl5fg34n EMc11ZiGCVWKSRo8krkEAcbcZ5+71qvd/CvUhqdva2drq4mW3Es6vpsn2c5yPlfGB+NP2wuRn//T /i5tPgn4qeG5N1vhU3pMDxWMjzCPPAIxjIHU9Kr6l8Jdet01C4FhdultGGtGit2d7gAc4XHJznIF fIe2R60aepyUXw88W3Utyg0q5tHtokfzZrOQwyBh/sjg8HjrW7b/AAp8TQTWttPCIJrhyxlnt3jt kTA+Zs8jr2zT9ulsaeyIX+HXiVryRI9Pmazh+U3ENs8omb/ZwOnqx6Yqna+AfElymovYaTdTSWj7 WMiGOPOcYBP4ZPTnrQ6/QapajE8E68tpLdaho9xaPZsftbuheNV7MhGQw+nrWHF4Z1e7gubqCzux HauFH+iyB5skAYGPpUfWFsaexP/U/h0l8JeJoLf7QdOuECuB5nksU5HOeOMdDnvVu40HWjJFCNPu NxiEkswtJFt2z2DEcn1/nXxvtz25UijdeFdYlEsNrZSS3cYG6AqUbngEZ7e9Vl0HX7eAQxaJqr3e 9k3Czdo2IOCA3Tj1qfrIlSQlr4f1wOTc6LqMeSRJI9qzRKV65IrXXTbxLBLm4sbgW/nFI4RATPKB kZ8vGcdefao+s62uX7J2I7qzv47OKfSrC7lSQ7TDb2rSP+PfPt1rlpbS5kkZ5NMv4Lq3izPDJaSI wGfQjqfQVf1kydE//9X+GAxGCOBFini85dzLIhUqSM/p70tvo1zOkpGxokOW2ksfWvlKOLp25Znp SoSvdDxboAphIKouCyjjI9TWfcXJCvKXIKJwD/Fjjj6Yr0FKMloYOEk7CWTzzusbTr5k0ZkRGPzE Yz8o/wAKV4JRJGko/eSNtjA5LE9APemuXYOSQ6S2aPHmsxbPyqVwVxnj9KvLbJcuMzMJmULhmwDj j+lLk0sTqtD/1v4YbaS4W7ihgBwJSm/oARweanugUmlR2MLs2ZSp3B68VQSOgrW8CFJmLLhVykjZ 3OCcYH86iE5gdBL8qZ+R++R0xVKnF6i1uWY7x5pXcqRgY3AdD61D5GG3rnzX5293osZz3J5JIhGs UlvuBGHjB+6PpUL3KiJRh5ShwnOAq+hp8jOeSd3of//X/hetreGRTLgooJLHO4j1pkzxWk+IC53L uUqDkfU14koO5EEraosx3MjwKJEMaqSxHeT0zRJeTgKc5KnK8cj2zWdmi7GmuqXLWr/apVIwFXdn eoHpWfDNcvcq8e5ynzBz2B461DjK+4KKLN4j3c1uwnnRo8/JFIVX8QOo9qqpqV7ArWqQ3ARXAZzl Qc0WkkaxgktT/9D+HMQXTJbytdPAkEvmskZ5J/r16VYN/cF470o9z9nVo4ySQsYbgkgd+B1r5+PM vU6nBJeRKuu6jFbyxW8r/Z5OZ487U57cd+OvtUR1a9n2h5toiTKADgVfNNbmTgrliPWtQLBLa4kk mijPkxSzEopznIBNWrbWpYLie7l81pbiMLMrAknGeR781UZSfQORFWfXdXSV1N7dS2TqT5DqFEh6 jdgdR0qjZaves03n3M/kzSjMAchIlGOBjn1qr9LCdPsf/9H+JG98TXclzHKk0/2K1VUt7FXOyUjI yzfifzpU8Za9o1x9qggsk/tCIp5ssXn+SAcjAPBI6fnXj7AqetrGtbeJ9QvbKZku7Rrm2nWaJWgM UgJxkbh14z3/ADq8PH+oW05E7yswTzBcbzw/TAxU88SvZu1jKn8crFPcXjRyzywpvQOxbziwwenP GfzFaVt8VLkWNtcN4YheZZNhAu3SW7X1LZwvPYCqBU2alp8QJbi2F1fRwWLDdI9up8wQgE4G7ueB T5PiDoas8l9qU10sCG7nsobdYZZgfupDLggseDz0wazly/MSptbI/9L+NW2+JcflXN2AJbeO0VBb zgpNEWBw5IHJQY9RkVR07x5PNY3SajcQ26ySebaywQbZwOyevTrXgWVt9SuVroX9O+JcbRyaZqGn WccV0fs8Wqz7nmjXP32wflzj0NdEniPQ9PFrA0zkS3GZruGBpnVDjGzOAR9cVcYxcdTNp81ye68Z aEb0W8Woz3jCYJLvtfJSJCMjD5Ofp2qbWdW0zV4mWK8i86wQLBCq4aZc45OPxyaycVcUua+hUk1W 00SbS9RF7b3017gTWiRC4jgx0DkdO+R7Vcgv9LF7cRpqF0BqRBXy4iIogOTgHAGPQk9KnkRZ/9P+ QO21XTrCS0+1XguGS4PmTvEDAuCSBIg9uMYrZs9ZtY5ri7tI7QNdJta3mgH2dAxOcKRgV806SDqY ulzaPZPqlnZrDZ3OoMI55ZJCrwE5+WPcdq5z6e1bWn22jx6dfC6uIJpLJDO14sygyOSFCkg84z0F ZToI0po5+S7gntL0aVqNlPFa3KTT2jXKtHKQxV9nP3gT26Zq5aC302KW4hh8iW6izcIH8zqMkKfQ +/rWaw66GlrGbEXkvC0WxlubcbYpEG6DPUA9ecVtWAuYRLa3DRliNw3kbl9h7UpYdGMlZ2P/1P5E NIjUS6hbzuk8ksJKoq5hDZyCfQjmrUyOkUZEjSSRRlUi4CyHoc/Wvjvq6RbnpYyrmxkeCDTIIDcw qGvZmbDRLJnPIPpxj3BpLQCQNDdwrHHDDhJJMFCTkEDPetPYIyk7Iy9SuNQs1tk0VUszPL9nuYoG O24hPylyTyDg5wKgubTUIdQiewkFr9ltkSUQYSKfaoXfg/xHknHU5o+rkxk3c6CeRrTSrHUXiluv NYojQxkrIVwHGegwcfnVe4ntrrUkuxYrbSSwiJYdxwABklvc4yaSodBc7P/V/kC1me5WzsrCCUQg s7K5/wCXccE49Mk5qGGX7KqzXd1MJGUQwpGpdJWzxx/Wvj3hvIyc3e6ItUWaWe3ezilF8V8qN41O 5SR1GKnsb/xJb6Tcz3F3ZNbae4QxSSD7dfF/l2qo4Ayeen+OEsMaxl1iNsr7WLu8ea9hg0uzMCyb LeUzFSMYJHXkZ4z1Nc9a6rf3smp3ESJZXcV8VgF4piN2isqhgmMnPJ496zeHKdRrc6fVJ47mJUnR vOJDxpHwoPfA61m2via4eyNxeaVd2ljE5sbW7urd47iRkIGFTH3ccg+n51m8LrsXTqXP/9b+Nq9m hmEwtbZv9PkV7h5EwLgp0J/IVJPq/mT28UmntYiAqm62V5XmOMAhcknmvz36skzujNNnZXmpXWnW sdpqmt2msQ3cCNCthaMk+nqQABIwQfMvHXup5Naem3FvFBAsupnUI5F8t3ubofaXXrtLdO/YYpPD o152cvqOti6FxawSzRiNzHB9l/eeWyngxt6jjr0q1ealcwaUslxfXMSRRAMIdqyXhJABlBHv0GPe p+rlRlfRkEmstp11YububfFAzRzS5kWRivzqzJ8oJ649a0LPxYt8qRXNva3SYM6s8RwsmQAcdAeT zT+r6BKdtj//1/5F7XxZqFnNLpdlawmwv38y9tVTEb4GFJ7dR3HaoPEWsaqsMUVrHZiLAMstwCy2 iZyURBwc+/oK/N5UD1FUaG6fcQWUp1rTrqBJZI/KL2Y8oxnux7bhz2re0z4l61aPBMtw0y6cpc6o FMV05APBjUBWPqcfhULD6ilUOgtvG8utCEw31xdmc/apPts7LazrICwVg/v0HUcVzcfxC8U2N8sk tzJZW3m+S62Fujske75Rkgk9utOWGsjjnNk5+L3iFZntbm8v2srK8W5Fy9y0CqJRgqFxtdRyDnkf gKvXPxM8V6sxG+8jj0m2ENhNYbIzcrIWZmcgAbge+M4xyetYvDPsEJn/0P5OF+LHinTyZotSvWtp YdggvZnnihkHVogThcnqaux/GrxpJbzWo1q+snZMCe3kAaM9dwOOOOOOPrX5asNpsdfOyfR/jR42 sbLUry71u/1ya3zLplvPFDY3cLqeQsgXaQ+AQxXIx1Ndkv7Smv6nBb6bqNzrkWpSwLJZaZfTpc20 z4yWWUAg7Rk/MMEY6ZrKeGI9rZluL9o/xjC+qWlp4o1OURQKkP2i08hbKWIbSjvsw4JPHOeOO1Qv +0z8SZrKOO7vWvUtbnfav/aLxxwjbhm2Mjc57dKxeGOqnWJ/Dfx3+Is1pdaXceJry1tbu9+2eY9w 5idmyX8zDDIXgA4zgfSrs/xk8YzxwW1trsepy2Fz++lV8xzo55jOc445z6isq1CyFDEatH//0f5S NUuPD0t0bDU7S71DRVtWt7uDTh+8CupVQgz+OBXyxd2UNjqs2meH4LxoFZ2tYJVby0jUkjcMkA46 496+Si26kux04hRlGFt/0MXV9NuPOg1ZFjtzs8lApIVpFHJPvgiufnmuMyQGzjFyFHntICeTg5B9 PpXXB6aGUnaSPc/D+p6J/Z+n2tjp02l38el/adVjsla5tbpxwjSk9Ax5/AkCr/2W91i0kk0nTZLj VIoPOlKSiK3t9p+bOevFa029mW7Slp5HM2OnTXb3s1nCyXi48yZFPlK44+c/w9+ema1fFqaJFYWd rp+mIbqGPffysMvfSnAc9xxjpWo7pXTP/9L+LXTJUtbiK4htYrOJdsaF+kZ4DM3oCRnFdGiaav2u 90myEDST7rmK3iEdtescb5EOc5Oe/vXjgZN1Z6HczJb22nRRXYuHmjlBJk3Nhg7HoMEHketR3Fre NAIlWMeYd0rmQL5jD+9n6fyoAxI4dXs1W5O2O3t5fNvpEIMnkg4KbTn72cZFdYuu6O9pdaPo9m+n 6VqCh5bTyXigukb5hncOTk5IHQnmgTkojbjRLCT7JZ20kWYow/lWoHmfMMBDkdsVm6Rp11b381ve r9nuTLstWR/mmPZW98A8VcHZ2FzxP//T/jduby/gtZ0jby5redYxG8ReNjuCk4HPOea15pLnVFkZ 4+diwXAKFF4ULwfQgcGvPBPsZuuaTZw2mmvHPtuYEaIRtIZAOwXr3UD361v+GIo1ikF/czwWUls8 RtlUNDO4GEznB68ZzxnpQaKfc5oFNF1O5066eztnkuiAjLlZVJ42Hox9xnoetdJfRTxSGymSGf7S qTKYMShkblcDt9KDQ4uXToxfPLqto89pZ3oU2tzE0YQqBjqOcZ/MVtLJFdXtvBJEY7OMHynWPOwK CRgfkMdqmWkWSpXuf//U/jp1HUtLsLE3U9vdxrPcxwJJDEfOjG/G+QEcKcfN7U1LLTtQvLiVLW4X TbfHm3Tv8kqkDDp6ZyPxrxxtt7kNjp1vo9sv2q5Q2F5dN9kgtwZpgwO4FgOi+5461s2N7ZXLmK4C Q26SZW7uE2iHbkEbvw/SgQ7UoLY6zZ3P25yVi8uyleXzCFAOzK546Y46A1buZ7yXQ7q3ihiEoZ5G kxm6YDjcB/F2IFAHPS6pbXMUWoqzrIlqIp45ITHvaPCnAxjOFHXHU11tvBFr2LtzcW8K2ccdkkS4 BbC/M4PbHb3oLjHZn//V/kKihvWu3tLezkimt5hbw3DIQZGYD5oyfXIHFczay65Y6rJo1zZf2VHa vLciKTKPeoejMCOM9QOOteBbsdGpuRzWphlnt50tpkYNLgbXP9P/ANdGm6td3N47yTzzx3KfNGy4 jJQ8b/z6fWkJrSxoX++5aS1S1sSs1swkkZiApA4UKO56ZJ/A1zFvFrOjahZR30Vokk8ANvbo5Voy f4fcED/61AoL3T0bU4Y7tA9+yzm5sfIiSNsCwzwTGB3GO/rXHiK6szBbxzstjbRiG1UHEq8ks5b1 OaBy0R//1v5A7G1vU0jVdZh1x7422pAR6fcTqSiD7+WIyF6jufpjnoILRCLK4UqLZ2E9ysbZBDck DHbkivnzOUmnoc200aaxdQSQ7Q12wg8k+crRkZBP8j6AV0Ms9tM1lPKEjOnPvVLYs0bhcjAI4BOe fpQPnRj65eaNZ21pqelKyNd3jC6hWJWlgJx8zHrg7scjtXQf8I7YzTW2oyXkvmJsZItgEEikZIfP QqT0H9Kyn2E5odd+GFutVmubq9t7m9SURWRtpBOoiKjYMDoQePyrS0iPWbP7YboCfYrQywvJuh8p WATd3ByF6dKg0P/X/ke8QW8mmytd20MGpLeLEGt0hTfal2VXKuRkbRzxzx+NL9ttI7my0iG3u0We KOOSe5hJjuHA+4r4x9MnNfNyvyq407Fq+0m2sr+W2vLSN72JFnt0adeD1BOM9AOP/rVcb7fBYxyM BBBdRsY1OMtn5W98cYNRHdG110Of1nde6PbWulWFsmp2l40NzdNuja4D7SNx9FHTHrUEdvdaTGiQ R21xc5Es8q5Ij9RnHXpxW5k2mkkakN5coNUj1Ge6jb7EtzaFVV4pZN3AOegwWye2KpG40S7htdSs bpjc6hZiG9WRgXikBOVjPoeKVkiT/9D+T4OjLbxboY5Xj3CaQbSi9Ny/kePasLRtBvLa+u5S9jq9 o1wPsbTkh7vaWJMq4wPwPevmLWdgKtgt7c3l3JdWH9lgXTKIUl8yF1zwU749M10VsDHDfrcwwrbB SkRxsULgAcetIdtDA/s9mgbzZrdTG++BnPYnv26VsTWe6y1STT7OHU206wF2q7g0MpwBtJ52kE9+ nJ7UDiveRFZ6fp99LCkULwySxDzIlG5GYDJXPrTYLS7hg/0wRxgXDiIK4MsqBsKWHUfSg1trc//R /kyiCLK/kYxIuyYBQ/HT8O3NSX0stlZq8LJveQRQxs2wyd2H5Zr5c6CO2LSNvitop0kXbKHyPIPU hW74x3rY0rT0sHl1KSSWWchvJgTH7heMgd+q55/pWjl7lhJJKyKp1HS4Zr/ULiPzZHsJbdJIYFlu RI2Bgt1A4wRWB515fiyhSxsSltI07TXEReaVDjAIPHGO/qazKaXJqXobSMzX1whht5bxQkvkxhIw B/DgdB7VqRQrFMtnZPtmQbBCoDJtCg5B6YrKo7NWFa1E/9L+S9mlbUZLeW5DCKAzGIYMb84A+oNV Ix/Zhlihghil1EnysLjc/J6Cvl0znT95EmjafJOJjqUkkE88m0lk8tgF4HB5x/hW3d2s1ro14NPe OWX7O8QZsFRnPJ/T86SdwUrbGEtpd2+iabPNr099fb9l3bGJI4rUD7iRr3BGeR3q/dWxtfJuChaG 5iSQRtwSWA9KY7tFtb+9gaOaKRVdJFJjbB8kL90gH0wKr39y99qCalqd3KthFDgwwjBLDO98Y/Tt Qawd1qf/0/5KwCdyW5kex3Fo3kXoT6e+BUL3dvBHdRbZJCkYJLH7mTyVA64x09xXzUnFqyAuafqN lBdDzvMMawBWCoRncMA9MZ6U2OK2ubv7Y4mgSByDbRoBFeDHyBiemCc5HSoAsXJvLW0WG3DszuHB YAeV16H0xx+NVH0mee1ivpQCUn243fMf72O+RQaQaSsW5kvXiit7dYY7Nd0m2RsTA8Z7e36VnSRy kQW0SxxyXEmftsafvscAAt0wMeneonsaH//U/lMsNI1OW6MYkh8qS1aKFPNEc8kijcH5GAMVk+Zd 3dlDkm1u7S5AuFTLxThc7gHPXPHavjzoJ7zRlt5NE1a/QrZ6nPJENkm6ScpgEhB6HOc1e+w2uy4j 064e3luV2tIgCSpxgMDzgjt6UEKOruRlYLG1htIWfUL+GTN9dzks/lnpg888H9Ku6dqVtIJ2ER8r JRLeVwQ4x1LDFBm92ctps4muZre20uIQS30kUjkFXh2MRlOxU4z+VaWpX4hSLTILeSeEzg+csJaW VyflBAzgKeM0CP/V/kl1zT5WWBmlniIHmXNvkCNSB1Heug0hoNsccsc5j8oSRYfyw54GW45r48C2 bGCGYXCQz+XuB8qPMi7ieuBV+3a/S7uZbxfIvEnR7W4A2zEYBXI7ED+dbLUBviJNXu7v7VFdvPd2 +JVjuTgPIOm706fhiueSxubTfcXNz5k8uWuA8o3MzHOFHUgetZ296wGtYSIYhHcgPKz7LcOCuwng Y/M1VvXvNH1cafEqHZbmX7ZDNvClwMrkdD8x49jV+zRurW0P/9b+VjS1jsZbm7nVrmSa2MkRRA7S N/dB7H/Cskl3lsb22VZHu5hDd2stx5T2pz1GevXHHcV8pKN9joOqju54LiWDfLGqqAZFzhfbNZep iRrHzXdN4mADlwHYfT3qJKzsgCaXSjp8Uc8WYvLWVkmG5Q4III+hAx9KljuYJo5ilwrSyIscjFgz OBjbn6cVJcZW0ZLYtNGkNzMElv7ddplkVWDKOgPtgdOlV/t11eLc3X2CLT2acxyfZF22z46bcAAd OlApSuz/1/5bIpRdfYBqjm3s1mEInKZUrnGzP1aluokXzjYDzITvUmMblx7jr/8Aqr487ou6J9N1 CS1t2icSNZ3arDLGIy4Jz6VqPbbIZF8loYIV81i0Xlgg85XjHOe1Bo5O1jFd1uEmmcwW8UXEEkoG yPHQ/icf40/Upp9JszchP7QuHWLMKH55PNKqDnkD72aaV3YnyJdOvYLgRaNq8OoaB9nZpzOLcTQs pAICk8YbjpjqKpT2uk6jLFHDcTeVI7MjSReTJcAAjlc1cVaVuxE90f/Q/l2TSrtY1tbaMM8ShIlu RtiYEDkcfyqS+0qexMdoZDbG6QOkkRWWM9MgMMgfQ818eehONrofY2+qXCG3edZYoX+aSUjeo54W ultLO0RLiG/82TER+zpAQhZ+ANxOeBz09uaDCzRk3WkanZ3DzzyyGOdFKK7ZCqBhQMdgAKxnbUWg vU3QpKCwt5WQOigDjOevPWgErnY6Wt/Nodst7do1w0C+f5QH7xhx6Y/Dt7VjXulXoeItp1vc287F ndrsLKxx8pAGcHPrikla4j//0f5gdGaeK+ayv49iKQGdMkrn7uf89q6CJrKO6lS7tXuvJQyLDGnm KxHC5I/zxXx7XQ0i2wiFzMPNNkiwDORI2C/opHp9Oazvl3LHeTWtrcO5MTSHEcI9Aev/AOuiKtZE 1vhNe3vW0+7jS6ihlgK+Wu1iwdipwSemDkVWlmsNK0y8hkv5tM1KVSbB7SBZIypbBBB+vOAeM1zf 8vJI6aErQaIdNbU47qKO6ORbbHS9kKhHP3sqnbHHtVvxHBcRyLd21utxuYGcIQmeevtmhuz5TRPS 7P/S/m6Ns9vBFFGsNlPJb73eE+eu4rngnrj+lJpkNxbWhUSx3V+xZ95wFX0A+lfBwR33SVylbJeS SnzhuwuGcjbuPsKydT/t6JraCw1N7X7TIIHdINxTJyOO3fmtBnUW+ju0sVs77mbCtIuDvPT9ahht LPTNSl02ETyK4+0NL5ZEOWPzAnoCD2qJrQC9MRGxaGZBs4J3dCOxrMvL/wC0GJY7WFbsLhG3FvtD emO34VkVzO3Kf//T/m1MWroRdXckiwyQqIIDgmHGQcHrjNdDpZF88cDgPIg3FM7N4HvX5tfWx6k3 d2H3MUkoMSIv7mQ/u2P3SD6/hVi0naNvIACxuRFLsYFvfFaSlqymtUzQURkNCFZRnbsfOW96zbOy ayubcLCEtlnYOgiDx4YN/D2GTUFpNuyNe8khtSWtt85Vc7EHTHYCrD6tcy6cBAZbZWIklUAbn4+6 wIqZX0sbpdEf/9T8AbPU7qaNYfMkWDf/AKnJEZb6Vqam2+xt3gVGRlI8t5AJI3Bwwx1Ar8wbb3Pp ox5WZ620VzaOUTZdRYKAnCdOe30rStYZ0to7Xa1yCpZXc5Ck9selJ7aFFGa3uLMJewwQSzxPtUtJ taItwCo9v6d6jslu7aec6tBFE7RlC7x/O4JyGB/qKDOp0JxZxXdrcJbXVzY+YoiCQEILhc8qzdvw /SlubaKKwihkMEaWy7o1gxIZGzzvPXPH6U02tEZn/9X8ApDGsSs0WYSuGRxkGtnSvIlBX7NEAsO4 I6chcYyB+NfmGvQ96UuU142tzZ3MVmIycgttGSNvY+lYQ1F9os5FjdXkxIy8Koz0FIFJPQ6l0skh WDTLQQxhRLIyKPMkJHI/PP51TuoGuo4Led7iNIX3KT8pCnqAPrz+FYyvfU6IyvoyK4W30+5tLeCa W9IAJ8yMbkP4fzrYuZ0DC4EflggLz91SeKzle2hrGXLoz//W/EeO2lWEXwl27nMYcHHPpWtbWiPY Syzzwi6hlCiJJAzyBs4IA9AOTX5A731Pr07q6IdPmW3llt5DGktwxZVcDccZPBNSsI7WZ7gfu2kQ xyIFBRwe9IZiwXJtLi7vYp2MqnbCAg2qMYKn29c5q7ptxHe20gWGxtpomLfaUkIvbksedy+g4xj0 qJSa0QFjffQPHJE0YnQh4pTh1yDxkfgODSOkt1dK1w6+deNsuJFi2ROT14A9ulZAf//X/DLUtBi0 64maNVQXIOfLG3BPVs+pq7p+nzW0Fut3Hc6kIsbSVwFXt06Yr8XPsFoXbbR7wXMuowZiG4FUBwSB 04rfvEubq3kimiZJGtwdpi+9kAgH6j+dBrGd3ZlDw5NdSTxfZrdJ47dWhmN0hVUGCvy+47Vpz6bL 50YhkMCG7WT/AEdtqjDZbPbB5z9aCzUuLW7V8KYXgM22N1cbXI/vHt1qtNZ6nduIrh4I7eNy7LF8 7+gwenbtQS5JH//Q/GuR7mG6sbWGF0SS4AARMrIBnJY/nVbVrlheSWsrBXZS2YzkHnHb61+IH26a ewtxbSx2UNvHP5zKo2lzl8VejXzLKNQ7gWsYebP/ACzPc/TNZTSGWYmaA2syoZIp3EcvykkA9yPT 3rcl1OWJ0t/mtoJziJoYzsZuhD47fWswLD3H2doR5Au0zmTYxVJAMZG7sTXJXjNFOyWkbWZldjjz d7orfw9Of/r0WLU7LU//0fyUtne3hU3DSyvtA2kjYPwqx9ra4gS3jkWKFpcvFuwm7pub/wCvX4Ro ffp3V0ZzWenQNqdze3rK1na77WKAeZFcSblG0nsMEnPt+ddPNtr61mYQvbzW6vvtZxJGWI5Qnvjv 70jWDb0ZtLbXkJ+2xBJLebKpbGUFnYf3hncB/iafY3iSXbQ3hkiktojcwoIy0TsGA2Z6dz1osaGl M1pdo7FgJJW27F5K/h2qiun3cMiSyyJ5cWDCwOWx/SsJJJ2Q03F6H//S/KPULtVuIZJWaeEFd7AF 9pHTI74onka51CM3KLLYrApiWBvLkYEdjjAbnuK/n7lXY/SpNsLLUruBWt7fzFQyB9rOcZ6ZK9AR U9zDfYQmZjFO++aILlJSM4B+maLIkzFsELtIEK+Y3O1ePT+laFrYbpI4QyiIElmY/KPrTATUY3hm txEvmNOTBCFG2NXGMZIqMaVrEM/l6j5TOi/uxFL5kRHXANAep//T/J/T/wC1bL7SkXlBHckLNEHW IEYIX61owW7BfMvv3zgEpgABa/AYrRn6XGdkkRLNPCZJIp0VJx8sewR+UPp/SpYY7txuQFmQb3OM lu+ah7M1jO2xoDU5NRS1AuZYjZo0U0LICJxk46jI/CoPs7zRRTyXZt7b7WyRJHkXAdVDFgp4xyOf rWL3NYyu7Mtz3U9nYlSs5g8zd5sh/wCPhs849SM/rVyCBbi6jubt0vB5aGOKZTzt6ZPXj+lI1Umj /9T81NcgVZGlVI7Q3AyWi5RTjGWGfbp7VXe0gsI3UyJMuFzcAY3MR0HsOa/m+x+tub6DhfMTa2EC uVWLcJACzNj3+n8qoshbUTIdSvVhk2ZjDARoF6jbjvz1PetIx7kCnUbWXUbmCAsqQoFmnjTyyARx nHfAratbm0kljj097l5rkCGRJf48cbk59/8A69XZIHojLnvrZtfGnWYFzqduf36sWUoq5+dTjBOe w9K2ZNSimuYbjWC/2eGRWujEpmnZVPOFHJPHQVcFeRnKTWx//9X8ytUvdT1G7utYmmjOmX1yI7Ly 0ED2oVFHlsvY8jAPPvT9RC3VnF9olaS4t9rwSABi+zore2OOK/n9KysfqXNIdpl7eRrdOzFo72H7 PPt4wAwbGP8AgI/KsS91BDd+RbyyN5eVkTyyoUj3oDml3IZXuZfJ81ne3jk+SMt9wNjcR+X6Vp3E thaQvbWxnijmKu6yLxcMTnnHHB/KgTm7akFxqduiY8vMzRhGkCcgKAAKoWF9e3kUtvqcjqwjZIJ0 UeYvXYMHjAyP/r0uVdjCUr6dD//W/MGG2layis9xZkQo044lkz3PbP09awFsYrS/WxuriRolX7hP mSsD13DseK/nrkdz9LjOyLcdzJpjxrK5uLBbgH7PcP5aQp0OCOnT9akk1KK7leSCRZbYFo440bfG oB6A+1UotO4+fcu2d6sfnPGojk8owjK5ZQeCR6d/zrFj1B4LljaxtGgYo7P/ABHGG/OtEm3Yi7C1 Ed5qMKTSQied8wpnCyY/vewA70uq3F4s81rGkptmj3PDEn7gnJHbjjFILn//1/ybntZbS0t4Y5fJ a5lUvJ9+OHcepwCeB2HORTbpYzLHBDJmQgrvPDy474r8Fhsfocr3ZdsdPntpGmD+W+NyHftII7jn rXPavPeTzSqkcjyR8iVo2KsTz97p/wDqqiGmiS3TU44zNBFCxSBZ2+YNITnlSv8Ak9eKs6RcXNxa 3emS2UF3emd7uG8nb7Oyblz5QZuNq4//AF0GDTvqQeXeXZg33H2VbdiVEXduOQ3Xj1HpTLCyj0+5 u5vtU0szgLcGTA8zr2FbqzQJtbH/0PyCuzpd1PE1xGqYYJjGNxzwD9au3MX2uUGC1FrbxquyJFIR goAHPfOM/jX4effor391qCETRzuXKCBMn/UqOML/AIVmX41W1tmsUm8z7VEJWWJuJ8DOTitYpOKH ZXJINl5phmaGa2vLcBAqrgkjGT1qWSG7vLe2ld2ZrZdoVfmCjPSiGjaC2txjm4W+dzsybRREpPzl lzyw9McVekW2vNNlnk2W10LdpBbIMtM6/wAI+tWtBrex/9H8bdLv7izu7eNIzG9yhRpvu+TkHv69 q35l+w6c0T3KyqrlnAbgEnPA78fyr8YW+p+gtWRiXMOkTRr5d7JdzNErrFJEEt426sgPXj16Uy7u ojaFYI41dCFaMDGR3NF3e7JbsjnooGdvPRT53KjYvbnNats0kOFnjSOUr5kYR9zOvI5Hb6Vq/hFG V1qNguFnvP8ASYphan5XWEhXP0zx1qgX/cROkO9kuijQyKQCAecGsuV2uTz9j//S/GKH7PdXT28P kWs0C+bJG/ys47Ln0q5Z6vcR3SQLOtmGJUTDkLgc4r8ahufeOemhjXGn2q3ZkjAOSd8qchyTyab/ AGXaWN+ZI5Vl+0QiOTKgLyOQP8a1I0vqbNzbLo8I2QwmIwhQrKCsSkdcdhiuSu5w14EWEiyjtC5n j6NKTkAeoA644pNa3M5pWNuysP7RtI4Ww1ufnOUG8kjrnr07dKS50G1jgl82A3MigJBEz4RBnlsd /pVxk1oc7hdn/9P8PSxsxa2FtYxXMkMxkbz3LIFPJ3fiMYrWurbSLyx8yJriPUWk8tYhbrFYxEH5 lyfmwADyBivyC7PppQ1ZmLphtrW8S3s4bi6eLyoJZCRBAdwyxwPQH86is9Gs7qLfcy5lQ7WECh4g 3cDPvUzbtcyVJqnJHZWdhHYWsE7RgSR/LbyEYmQHqQ3Xvmiew0Kwk2usLz3S5huFOZmB+8MDoTkg 8Zr6J1xVfhM290TSJpTLb2QtjHGCDt3FmwNxJP8Ae9KxNqgC2LLG5fdsAwqjpms3X6GXI+h//9T8 UW0W4umNtZXVuQIFlupJJihmHy/IAOpXPT/ZqnLo2t2l9bPE9lJaFtl3LNcETKhPOxR3+uBX506/ mey4taFjU4wsL2OnaisbzEcxfMIRuG5iO2QMVftJ47jSws4NxdxMtnEVjEqpHE2VHtzS9vbZjUGy CfRYlLMQptGfzvIK4RXP3iF6dapWmi6bb6hJJbWcM73JL7Nnyw59v0/Gj277msaehovp8Q1C1mns LS0ktWLWkEFqqlyOQ5GM5HGPSmm1W6l+2vZC6jjucslzy8p6sefX1qfb2KVN9j//1fxl1HS49RS1 t7DR7K3htGMslw52vgnkEdD+Iqpc6Lp73LCzsbEO6gNBbRLAiHjJBHTOMnPrX5q6/mfR8jI28Mwa vJcRf2fDPhhIyxwrK0SoMDDYJ7dcn61QPhLSBb+cmk2jS2l2LiC4kskeSCRcgbTjGOec5/nUuuJ0 2a1j4O0+e0jY2kUMcRb7XLGFje7DkEpjuOOg6Z5qGLSdDtb27bTdIhslkg+wSqYhKdvfluefaqVf uQ6Vuhq6X8PvD9tdpd3+nJewXNsrQLAwzaNnIfBBG4env1qVvB3hqW7vtRvtLm1O2giMYiklNu4P 3VZ9vpzx70/rCEqZ/9b8abDwj4bu9OjsYdCtLJLS6a4+0/ZQ5uQ/8DbgQR16fjTR4K0vTIEtJylz YuxcBIUjSJmyABkHGBjpivzlV9Nz6WFO71JG8BeGVtNU0+TRhGut2C2v2uORmvJpN4cHjAByoxgZ 9zVKT4WaLLPaTS6ZbamsemJbyXFztjnt9gWNFiVQMFVUDkH7opPEW0uaqlYW0+Gmhw21zpseiQWM hnLregbJyjfNs2kEAE4O4DJ9afY/AnTxcqGsbYy3bmVczQpHcQ8gvu2YB4brn6VLxOlrlqmupvr8 AfCNvbyabH4fha02GOVrm9iOnebLn98SiLypOcHI4GQa5eX4N+FI0e0ksNKmvoM26fZrRWinYN9/ cRzgcDj0rKWJ8zRU79D/1/xYtv2efCqW6h7J7YtKz3aLbwpG4Y5JX5N2fqcUj/s0eEdYuLrT7ee0 82K0a6sZL5jBFJtxwSFIUkZGMY461+X/AFrzPrZUtbEmn/sxeENR+yWEkUEetxIV+2xrCYogMkqC VAIIHXjmqll+zL4NmubhImle2EMsSCXToIxBcx/LhpEXBUn0GfrUvFabgqY+7/ZGhlSe2tdT0ZbS S18yQx3uWhLDldhh+9+Y6Vh6b+xxp+qGBBqltZ/Zy0WZrE7p9uPusEKlm464xnpWP1rXcv2PkWdO /Yu0KATn7YqXXneZDZXjSRxpKcjO5flIP4fQVlH9k4xxh9Zn+y2d1N9jkOjQR3AVgcDdvGffeeKa xfcl0O6P/9D8Iov2DtLtY0tE8QW7wz3Mk8moHybh41I3AYaM5J79hjisx/2D9Yv7eGbR5Ehg8zZM 8sCR2JRDtLs3l9WJPcdOBX5LPGxju7H18aD6IzLr9gP+x2mTTvGXhtXkcG405hOVjLD5wv8Aox+X OT1I61z0X7B0N7bg3yWOpxwMR9t0ywYXK7SThUMa7vfgZNKOa8mkatvmU8FzO7h+BPD/AME7/E94 jXuhW93OtsAbe1ntIrWW3SQ4D+W0e9VOP4jj3ptz/wAE6/FFpaQ37tp1/fxNuluZb6FrXTMtgAqm Cpzxnn69q6YZzVSvGovwJlgIPRx/M5qb/gnv8TophdeINCspVKGWxudDk+3xbH+7IzAHkgDHBH6V jP8AsGeLfs9zFpvhoXP2NvOu5r+RraeFCQGcOFJHpgcc10rPq8Xytq/9eZzvLab96zP/0f5cY/2H 9fM1xpdtpN7a3NvdKzRQas5gdWPXzDGSqk54xk+tX77/AIJ/ePreK71GbQLl7u4uI4HH2ieayijc hUxhByQOgXBPevzqOfVk/eS/H/M+k/s2n0v+Bzc/7DHxOhumTUIrK0soWxDa2+6aUFTgo4C8DFUL 79jDx00slnNoDpYNbBklllZZ/MzlWhAQfKenPT3raOfu/vxVvUzlli+yzGX9iz4oxG0it/Dt5ZkF 2nXUZHljlTH7tlcJnk54OKzNQ/ZG8badqaXc+n6t5kVuJJYvsjS28IPAVCBjO7k5zx6VvHiGl9qL MJZdLZM5HVf2a/iRardX6+FdRFpuMC391i208v1O1+c4yM49azX/AGbfiFEGF7oc8AaBfKmtpBcw +YRk7jgcdOa3hnuCd+Z29V/lcwll1VbK5//S/jbm/Z18b2dpCfOt7Jkf7Rd/aYyybQMld2RjJwAS Kxp/gR48gFzcnTbiWVLIXsVtHZTCCRAcNibb1IxgY5+lfKRzbAy2qL53X5nbLA147xf5mbqPwq8b 6fp7XR8MazdzwwfaDZ2+nvJhewfbkgnnHFN074R+PNYsU1Kz0V2juIw8EDxSWsoIOGjZXUEMvPQE HFX/AGlg3oqsfvX+ZP1St/I/uIdc+GXiyzhSKHQtXe4inEM8B06USLkdRxjHv3pmlfDPxmUeNtK1 WO1U4mubq1MEsZ6sqocE46Z6Var0WtJIfsKi05SsfBni7RNUuIH0OS9tXtzNDeuCyRr3LKpJXHPX jgVPFoV/f25t2imtriUCRbaeE2zSY5UgNg47jvihVoNtJmkaM92j/9P+JSTQ9StkmikhYPFH5jKz DDAd1OecYNM07Rb26tJo7OK5F05+a1uYmt7edcbs7j244OCOK+djUj0Z6vsZW1Oam0j7CzsReB5b go4mJMauODGp6YyOK0Xs7idJ1+w3NuLZEZpvJJTkdOPSrjNN3IdJrSxTXTZZ5DLYIs0igKQpyR3J 9uAfypbS5k1O4lt4Y5HFkpWR4rc5j9ycc81rGV3YHS0LJle2dFuF3wo43SsuIhk8ZbtVifS3tIrm 7uFQQMnmhYm87ap5BOOh9qtJvRGTpNH/1P4a7cTyDyo7W6dJuYk8ht/rnp6UyWPUtReKzTBt7JCq lzhY3ZssPr/hXkuKW7Orkka9pp/l2t3GLh2aMjcYhhyRndj8sVzP2mWV2j3s4BOCeSajQfs5JGgt kksQKyt5nQoQOKJbQwIqliMDaBmm7E8rtcaYWt1DPEs9suHdHOd5PbHpxUscMN3C00VvHEpb/Vqu REB0GetRLlS1QrH/1f4cLS7+zmWBIjKuPmJXhcd/pTLl1aKKFNu9pPlOfm57fSvAtpc6LFPd54Fq 33d+x5e2O4qZ9XnXyoVeQR248uFCSQoXgDn+VCi3sDVmaFjfwO0khZtzfM4IOFI61LLeu9wDDdXF uxxlkHQD1qWpXsJxTIUv1tDPaWUIMADXMryk7rl25cjnvWraa9fraPcQMR+78uC3ZgUtAueRxms1 KV7GnslY/9b+IPTtavg1xbNEkqXsvnXV0w/exYHUenb8quaj4gu1WOW1vbgb1+zCLOEl2HrjHUe1 fNOUk7HV7JbnLXdxeyBZJDKsnnrOxBZVBU8bjVuXXNRdZcIzrLgMsClsY44HNZyqPZlez8zfsdYt tJtLSKDTN32omOd0BMylslmI4AwR3qc+KNbE0sFqwgSM/wCjJPGHUggDJPX8DRGqkHs/MdF4i8Va Z9nv7OSyuJI3CsbxA+4jqyr3x2yMVt3PjjVL6OQmOyiujED8gJnQjqw5AGfQCq9pdESpt7o//9f+ LJvG2ox21oI5ltr+Bw8jRxBTOhyGLnucfnUB8a6nbXdpERHNp7n5yMLdgkHkdse3PWvllJPQ6JU3 a1gsPiR4pSUaYBbrbNfH7Wrwqs11EPukOBkfTpW1qnieW4jaGZBEm3bbyI42ufUgdSK3UkzFwaM2 38RXUFpa/aJzcfZpdqEKBLtJGfw46V2LfE3yY4NJk8O6RfIBsjvYWddSkDc5I3BcjOPoKd13Fytb Iran4uFrqGk20d413pkcQnltGUpFDIcMybO+Ome/5Vmaj490OfWpcwS/axMrWamBo7MK2cnf2IGO nv0qla+pnKHY/9D+NvUPF3h5biFWgvJxIo+3RzOEAbbx5TDI4OOa1LPxZ4YFtBbX0E0rxzedE8cg DRZGPlHfHpmvEcY2uc9raEEfie0nun/ePaRQHzFnYESupGV+UdDjHfHvWfF4t02WC9iQo0jNgW80 Zw7A5DfnjNYuMblKLaujUi8S2Munqb61WwmCszNHMzfbccBVyOOf51esL/w5NptvdXCG31JZHdJJ 1DgJjhBjOCcd+vtS5ES7ovWE9heXkWsySwTTR4S3hmwk8KoODswMDgYzzx3q3c3ei6jdWthqOrvb W7zM4R28xE3csAvJBPHPb3xS9grbFUm+p//R/j8ezhsXMclysqoxihkDeYm3PykHHTH86WT+z7ee xnk1KBpXlJt5UAcow42OBnYASOv4V8z7GJop9GdBZ3ei2cflXMiX13KjSPCIVkRQ2cDd0wMDisqa 18P3ME8tsP38bb0tPLAh3ex7N+lS6JUp2dmO07SLSKCSe0tDmWQy+TGMsHP3tvbmtTUdNu30xry2 0mXUY4SovINyolqhPV2PGOMVPsF2N4Sb0ZUutPhubS0ghgt7aJz/AKuJx50fHBIyfpnpWRFoZsN2 95LmBW/etGoSZjzwMcUOhpsObsj/0v5ELGCe01e7mtNk1vLDGI/OG2e3Ycn5SMdhyfQ1Fqlvqt3e 38MohkhvYVIeEguxzlsrjAIwOnvXyDonSm47GHYz6bpklxp/7y6aaLDxeSzBWJGMsBheR1q9ZWYW O4QoWhKNMSvzPyCT+AxSjQSBtvczNLQMStxdXEltErfZUU7XhO7O0DjABz71YRruXU76OK7lttPF gGmBfDKwY4JJ4Iwc81ToqxyTk0MuRGloPP2TWsj7WbG9WI5BNMttfksj5VjbMbV7doJ5Zcqjs3Aw O2O59RUfV0KMujP/0/477qK5/ski5htZbTP2VcTiQZxuYJ3I96raTdafcpcApHAuwW9usQzFGwGM MckjAA/Ovjlh12HdlyK60u3svKuJy08xI8yE740OcAfh/OuitY7G0k0+XzIr+aS1862lQK88AGQw K9VPy/lWUsNoY87TIJr5Lx9z2wSJ2YM7gogKZG736frXE6rqtveSLp9ms0djHOv2udoypk28uEBx kE/oKweGNoT00L6a5dyQrFbWollU7Y0yfmA7n04FbFv4htY7Oa8lgFpeFzmNRstVAAAO4nrk96wr 4XS5EJ2kz//U/lCsdZ8NWWl38lxp9xrc9uEtm8tzCtuRgEK653ckE+mO1fONzcXFvrs93bz3Mc0d yyyQzIqxqmdwA45xnH4V8hRXvSZrVnaFNLcw9Q33j/ZbP7ROZJD5CRpuxK3XC9Bzj8qxtQXXoI/t 2u2pWTy/7PD2qIxcQ4Xc4HfG3k9cV10+pEviZ65pusWMukwJY2k0bQaYPtM8VofPvHGTGhUH5lPH 064rpPCVpqVm88usOLS1voi9vaJ/x8MG6O46qP8AZ71rG90OPxHMSQ3US6xc6YrRw29wTcIS0Edx gjaADjd15Iz3rN1W4u9TQWmmacsd3aWP2hY2ODO3O5s+9blc3vWP/9X+NlfD80WnhLi2Mk13bf8A HvdEwqZGXgBvTPf+dUrW11PTNMtdLM1oXt5GYiICZ41bkp5vcZA/L3rxwsdBpfh2B/JnkljjubgC NFMm5N743ZPoPX+VObTYTDIJShaKQqCjbgCDzzQRN6WOd1VbBQIboXBjYeWBaxGUu3YMAMgZ71LO 1q6Wf2hDEtjA0KERfOdx3Luz6f1oMhllPaWetwXcMN5qKCFbeRkh8gxNIMBieQVVuc57dqtarfIv iFrK2hu31a0tor+O2W1OZC5ONp6Z4JP1FAH/1v477mK5FpcTQNH9vADuly4TyznDZHUnr071Rv8A RtVFpf6xHrV1EYdOR4IxbhokYkA7+uBluD7e/HnRd1ciC0uZOqQXuk2Vm2qk3DxrHcm4dfmkLgFW UDqDng121n9nsrVNUvZEurTYogs1YyBi3JbauSMcDPb86ZZg6x4isp2uZRZxtJAm+ASjKqRyOevY DpWhYXsF/bQ6kzMtxlEnhtxvX7uThvQE46cUeRpLSKsRTTXN/PDcwO7WzXTRyxXEZLtjIxzz2pg8 57m4kaOOIJxFBDnOMdcUpaRZmf/X/jjtXl1G8hiv5Fn06VGjtoW48schuPrVi6Gn2Xl6dDZ3TWlu +1o0JO0McZYntkjH4V44Gt4csppGaW5tTarbo0NlcPjKRknIA7buM/SpCsdpeTw3FnZ6naEMn2c7 hHICMAkDn8PagEr6HK2eiJe3ZvZla3nmYx5hkM6QopOFXOMDiu1s4rqCMwwtNHcRrhbhhsIGOque M8UFuDWxhWWh3+paksEF6Vsy5kktJAqpI/QsCeecCuuivrfSYnhkVt8WUUQjzAxU4IHNJuyNErKx /9D+Ra31mbVILuN2NqtpC9zFM8vyoBngeh6cVTaynv7Cx1Y3DPe3UjR3F1OfM2RgDYQx5JPv7elf PnQadtJaWiRx3UFrcJDudYSgxO3YsepxjpmrmnNpUVvFqtrpUcMc7hb20MxbEjZ3MmeeMcdulAGE 2mKt/f3GivfTafcSgxJeoFaKXGZVDDg8np7VPY2q395Dc3UUoltVKRrcRZliIyNwBoJjtoVbXUbi S8MHkyX1uxbLwoTLFgjGT0A6j8KvppcVxqTahLPcxrFD5aae7DyEY8fdABOeTkk9KCJvWx//0f5H LSy062F7Ft3SNcMtzbmIqj5RWyvGCCG6jvn0rJaW4trmO10qB5LWZgJ7fnbbgdAnp+HpXz5lPcvQ QQw20OqKnnXH2lo7mGIbiU6YwOe/86k097e+/tXR9MuJrFbvb9pZrYKkbZ3BQ2MDGOcdqCCra+Go xaSPcIDOC0UjysRBcAN8uFPQ8ZzW5NqkNto1zDfWaXY8lo5ELBDCMY3Ke/HOD6Umk9GBzlg3lR23 2Rp4RM2222Eh24zjPXoO9Xha6nKWzdzxohJUvOc5PY5PI+tJwVy1PSx//9L+TG0t7fyLC3ImntrW R5Lm8mbF1jjcqr0IGGwTT7W7i1E272/lTwRziW0eTCxMQeCfTpzXzzV1YUfhRGb6wuo5ZNaIt9Qh um23MB3xuMkKMnoM8596jlhunlnl1K4+1NBbpHYRxPvhWM4YKeeCOM+9Yx3RrBXi0T2dyQgt5LZ7 ZpYSHeIH7OT0BLH+IZFXZrSe1sEthGBbXEo+2zn/AF0q9TtOO3Ht+lbmZWhsHewlS5W1ljYNDESw +eP0JPtWBPFocX2ax+wy4gVl8mzthuwMkHJ4wDQB/9P+SOzia6Ikura7RJrc21rIxwsewgcD6VuS ahJb262elLbedaoI1kuR0YcNnH4185b3zflSWhlNqcMSGS+KxzwcSsIX8tScfd4yQcjitm31GIRi LUI457Yw+fCzxYRxkHDe315rNqzsZyVkirfXWns/9nSw27+evnpBszESwyhLe3BxntWFBaS6G0lr LPLFPqDmaWO3OI3BUAK4HBGFHWkTHdEF7qD202nolve+XDunf7NEyquMYLMOAPQfWpbNxNdz6jcN PMmo3S4vXDTR2CEbdqqOApPJPUnvQaylbQ//1P5JXWbS55niSWWWZPsysiEh1JyAM8DPqa0zNEdP ikmjxcY4ST5mToK+XKc2X9GNvb25eSZFDMX2Aj5fWr89m100V1by3djBZXRMtyg/4+Ay/Km3NNJt XCM7LQxbfw9NHaarqdxcaJYWQuG+y21xcMmoag7ffZIwuDjPr+NS2ME2m3UbGWO/ZIEAZo9gZWXn PGRgH8xSLlJcpmTSRxaxNHPYSJYTyKzMrCMOvft17c+lXNZtHsLwX9ikojvgrWw80SRJGvXL+vH3 euaymrySHe9E/9X+TWyt5Gme6ks4XRYTtlkJjkjJ7qO/0oS5Md1b4kV5IRkbgC4I/i/nXy+xwx+J DJ9ZtRq6lWk1W3msg6gI0U6nbhjjrlWwOewqZRO0LRkPHBM3KDlmB7f59KiGxUHqyCHTtGulvLOd rltl0k9n9pbaR8pJVCD24+lX4ruaK1+zSRrdQxSFVuNhMiKOils47fWhzS0NDBvL3Mv26NIzNcsN 8W/CryM571flkFyhW3RA0IHlx9InBGcE+9UndXQJ9Uf/1v5PJ47q10WeeOO3e7VGmtrNJAYmZQcA +lZem2DT2KaxqEItrldkFwsTl40dgWAI6Z4OPQd6+XBaq5eW2uLiRZ3ithYIu24kaT/SDt5Gxcci t3Svtmr3F7C2mRz24X7Np0MDFJAqoCJX46ghjj261Dmk7AULhru3njtkjmu5mnVpjdIFjgjzjg45 xg8H86dNOdIinF1CuqyNOZ4RaL5bQqRwiqeM8859KpNPYqCuyxIx87SbtRHBHcN+/wAp5/kRsrcM B3B+vXpUkNqZdPvpBCjzGQ/2e+SqIq4zuHqeePSs572Nj//X/lZs7O4u7QCdpVvbflJhzwRggnqP x9KsaYY5rT+xrpYPtFi7XjwxJvkdixw5J64x+H618edBzeryzmfSH8mWWa1eeGJWfy7S3RsEYboG ySQPrUQaUWLLCZxOl0iTyRIXZslSVBx93nkjoCelAFyfQ9SilIs72CGO8QeaqzpMqAjlQ4zg5655 q5FpTaVZwTzeTIJ5fJjCSq+9hjd8vXuODQZT3LUkDB0miCQo0Zi2xIIyT0/xzVD7BNaS293BM1wD JvlSRwGtfZfUdPzpWd7kH//Q/ktmuGv9ZeC7muNzkJErKSkg7BfpW0ba4BdEhLxphVYvj6/lXx4G 1oSaih855cwRtiNZQMpj+7+IqK6kZHubhmeZzLuZnPOSQM/59KabWwGbZnUJrq9lhd7q5vmBBlG9 sqPvH8Bz9KludI+13cN3eWsNwtsoyJVyFdTkYHrmkBaj8qKfNyj5kAYpt+dVBwCnbtUDWWo3Ul2s VtApijF1PPJIRIYiQA31A7VrzWjc0p9j/9H+Ve2jniCRQyu8UaFVfHzLnrVO70KeRPKsPs013FIL tprxvK8vB4HcccYAGeK+Uc7bHQdTGs9mFjvJI5rgxq0rxsHj3bRkKaydUgt7+NVuI2aBZ1kRoI95 DxsGXc3YAjms229zKTXMmR6ZbaRqF9d/arqGWLT4FcW8hKoj5POfXOPyNFvpdjeQ/aLGB1upZn+Y gCORw20bePas5StoaXV7FW3LxTSm8eYORtjhjjAww/v+xx+FaVlcQ32mazpVxHc2N9E2+zhkgaO2 nDH5n3dOhOMZ5HOOKlTa0DmR/9L+V3TLRLWC4huWS/MuIo7S4zLbR5581V67lIB//VV3TbeazURS XCC5MrtNsOMxvkImO2Oee9fFOb6HXCVtBL2W5s7pLV0byo8sI4xuGT/UcVs2Mt9ewNBLMstttEMc bsWLrgdQemDkYqoyvozUqT2Vj513YXdtO0kQRDG8TfY177gcbW9MqTzWlGfszNGIYLm3ktvmeXIN uwK4VR+B5rWOkkBs3Ua6jJbqoaeSK3RR5wwiYGAo7YGK5/U7eH7al2YEtpk/dRJjAD9ygz/EB0Hp VN2kKpGzR//T/mWubm5u5IbeKRFlEaYe5fyyy9Cc/nUlpotjcLd28E0k0ceHuPPYq7Hgkxkn1PGP 6V8eei3d3Lvm2elW8sccDvcTuEt0P3yOf6c/hVZLGRpftVvPMxizJLBOVSNQR0B46fWgzlFvRGXN r/mx3CX0UkE0M5ihjGZRcIcYZSPXPTtUcFypntVmtEltJ2MbrOCgH+8ODjrQCi0mjX08SXT3NsyJ b2aSGOIW6sg9cKc8jnqPSi1gNzciys7iMtBL/pPnZUIuOMH16Ub7GR//1P5oJhA9zDEzGNopvmlj wd7L/DjuKnizpP8AaM/nQi3udrksuJCc4IP6flXx5ok4xZfhubfbGWyVYZIHI5rntdtLC8uLPz9z WwlVZkhXfIQzgZI9vy4pp2FV/hheW0FzG2mRNJ5DSbXuMFXwDwcnp2re1q1trq90qzttO+2SWNoz XkyYVlIx82O+RnntjpWCS57oKT0sPjt4pI4YP3ZVjsUO4zkc4Oak1Ty4dJZp4XkkjcARRNglQeo9 Tx0pNe8b8y5LH//V/mpdEv73T7+S8u4oLeA23kQYWNlYAHcuOSMdz1q0ljHZRsts7SJIxkeQvuIy Sf8A61fDnTd7GlBDcXFtJLCrbIsBpMZCE9OfenpptzLbvOjxeZAoYmQgbjkDAFFuhq2+W5YJlSNZ YvvqPmI7MPT9Kp/ZLq9guQo8qfymlMkMgD4UZyM9++KmS90TkraEdtHZ3NlaXESu0QQPMxG3zvc+ /rWkIbYxL9m8tSzBxwPM47A+nrWJSd1c/9b+de7nF1BFanaWQ8MPvLnqM+nerlpbiyliuY7VFd18 vJztfAx/n6/hX5o/jR6Ld2X4Ug3MssSw3FxIerhQWPpWFNps9jqqCLTn5mPnXEShMnH3if4vStHu bmnqFrdQiO5MzxMHV1aPEjAE4wRz1/SukEls1ogSORp9oaUuMBPx6HNIuG5VFjC8cjwSzwXlx+7k CqPI2Y+8Tnr7Y7VUTTp/JY280y+dmJnx8rFSM4H1A4+lBvBpPU//1/wOtlEsDx7C9xbgCeRVxzx8 xx68VmtBercAeWPJlBJfzPmU5GPl96/MG09j6e6ex1Wnra2FpJNcxR3N0sqiCKQZHfJxnmoLwTxx JJHsDTuSEQ48of4DpSDmRzbxXbvLFesTAfmHl8NH+P4ituS8026tnlurq7ubmOEQRW+wYi28Llye mPSgyk7mGZyFt42eSDbOGURZKsCeh4710UWhwNInkxgHcZdsQ4kzycirhuYOTTdj/9D8Dob+1ure aOG2W4UO1vtkQhomRsZH5frW5H5v7ueJE2pGIpOAHwcjmvzc9duyuX9JktbRpDBbxiQDbKpTKvnr u/OszVoNPtrNpbawje/huTPCHO2CTI5XH1PUeprGSsxj4ri4hggnuokszLGHMUUm8IccgE8nmpZ9 Tk1CUKdyJgKWPDNgAZzU2N1saq/ZLUm4nRRmNY2lVPMkKjPP4ZNV5rpbt/ItlLWytvy64L4PGR7V lKNtUbwd0f/R/Em5spNQtLeEHEFpKJ2EZwxbjGR+FUHjEVybuBdjxqI2fPPHY1+SuKZ9VF2Ztx3W mGA30217lE2NIBkx4z+WfWsOTU5JgN+7y87eFzgE4rJxa3NiNfnt5rO3gMXmr8tyxO4HsADxiqcW nXtvNZyHYjGMmRI5N+DkjP6GpaT3A6i6lSC0SZxjIycHLceo/wAaqaZqwkla0VGeTHmo2SfK55OK j2YH/9L8XpZLq9kMojkkS3/drLJGVjB9BnrWjp89zbLcSai7XMwTbbW8ahYYADxj14r8Yas7H2Bs RX9sEImVY5rqPZGrDBBHOR7ispdT1CSe7sZAFRFWOKYjLOuMjaf0otcClMtzaQRLaBi7ThXjDeWj 7jg5NdNdwzQTW6tElvDbW2b1C+75sAltx7Ui3O+hz1nZzaipWXzobRpt88sQLRoN2eD71ZOr2ttK 9rbu0oicwLI4wGPTANBCP//T/HO3nuhcRtM8e6P95GRwG74x+HT61XlMVzqUaqp2TH/WMPu98H0r 8RlGx9rFW6m/NoWdt7AWWSFMAqcE45FZ1rZIZWnnn8uaUmEqX4fp1XNQ0nuKa6j7hi5jjsWJ8hiJ mA3q2MjHtVi7d2t0jR9szofL8wfKpHGf5VLgnsTD4kQ6bfS6Ul2+pyBrZYg9rGil5ZH4yDnoPf2N VXu4NSR5pYTDdK2UuI/4o+eD9OKlwZtsf//U/HFdZBMEYSU5/dlZF2jaOA1bcv8AZdtbSSyhjLJj aY+h9a/DeRWsfcJ3WhR1C8srOBWt4WmZ4wZYyu5nHdcH1561E8+j6k9ktrc3NsbVVmng8v7IqHOd iKRyPWlyK+htTkzq7e7s5NzRFmRFwSQUYf5xT4Xi8tkgXcqjf5knzMce/Ws2rOxq5voV7B1l1MSs CCgLspT91IfQ+lXY7W/nN4m5JIywfZvCsmTjgdSMY6DispQ6ouMr6H//1fyz/suDyDaAHzAN3mZ6 E85rViSxMa2SQ+ZLCgd32YeQgc7TX8/n6QZNitoJ5bYxfv5H3qznlQPU/wBa04h5s80Wov5cCJsQ W6hixHQDtz6/WgB0xsdOmdJpgzGFZYIVXcRkgfN6dentVYOipc7wAJVLQzR84J5FAFFFDbHabHlH uepzUz6ykN5bhwdkRBZmG5ef8/rQDt1P/9b8v9WuUZAYSUjZvMEa/dyepH+e1VtPhn1C3LDdCkEw Eh43lTnGAfXBr+f7H6QvIqXmjXIvPs0TNIzATKXPEYPIJParRW5spooTfRiREBlWE5d8gjHt3/Wk 1dWGnZl+K3tFLTmMJdSpsVxwhPUkjv1NTLBGwcebNdW8JKiXy9uwnk4HbnNY2d7G0ZJ7GZfTwWV1 YxahOk1rdS7dPV33lXH3gU6jtzXoOn6XaSQrcSYRVbdG7DhWA4pGkZ9z/9f83rq7gKO1zZC7mt5x /orZaOdOxxwT+FZusrFcPamNYo7dn3G3bP7gc4UDvjgc1/Ofsz9Uc30NO2lXT3XC7ZBH80JAxgjr 68j+dchrd5mctBBsjeXC7AQkY9/pWiVlYIz11Ol0ixgbTftdx5PlufKkG5fOfAxuKjnmltLUW1w8 yymGH7MwgeMfvVyCMYzx0AosEpdEYca29teS3NmzpcyxCF5ycyYHPB7Z56U+WaMzwG4kYK75cpy7 gHnFaQi07szb7n//0PzEZLOCCcGSdklnEsYxuHpggfQfrUFrePbzCS6smuLNomw5JXyiOFyBz/8A qr+fz9O54lm28mBpmEbxtK29lbIQg56CpBY2cUJfzIlNxI2RvBm/L8eKBc6Mv+z5VmKzTBEDExn1 XqPxpl68kqrGEL4+WNyOBj3oJm9bGjpekz3cDrNbqGhi8yR1PyMKlh/s9Ul+0Oj3SnNuTgBQMqc8 +9Bm9mf/0fy3vJT5ST29zFlX2mOOTJ+vHas+eyaKeS7dENzcMG82Ni3Bxjr0x0x7V/P5+jRVooR0 a4lls7q3NwJY/NYSAuJgecn9KzhB9gmEUeEKkEIOFA96CjfvZbeziW9ljZJLkCGJVQkSkDnH9ajF tO9tGzW7gytuBddowe9V7zEnctwaL+/M9qI2dU8uPDYYls/kDgVL9svWtLC2n020hlhLx3F1C7PP O2c4YH+EdjgVIz//0vzKRZpLQg20EkKybhG3CvjodwGR36VQh0+WJm1c2a/akBiDsm9FUcgL29/W vwBNrY/Qm7soQyz6g8F3PYr9kjumR97fu5mQ88j0z26Zqst1PYvc4BEbE7do5xzgCtIt7CbvuVPD EDpayXl1uWa4nNx9nc5MIbBCn0x0xS61PK1/pz2sQvIEn2Xdux8v5GHJBHPGDx71ZjNWZpXp0ufy jAGtN4/eqz7xER1298d65q5eO2upJbQveWpBVZmXAPHXrimm47EtWdj/0/x3trSWadboQtOu8fJK mIl5GWzjqOcf5Na95rdrFeHT7aO6u5kQb1hgLeVnruxwB171+Gxd0ffpWJmj85kV4mA+8QB/Oqks CDUbdlnMduU8qVFj3nr1B7elWnZWC2tzRswJJbiMRhUj4yVwGBz/AIGsqV5bS4kEMyRwKd80LkKX HPOKcXyjI4Tb3Mb3sc+/aSOMHvVI2F1cyLLbzKhL7FB689DWkZcw0ruyP//U/JEW9ysMULG0xA+6 RcdT0LZ69q56Waxj1pbQRNLuIlmjizIjZ6liOma/Fz9DlGyNF9ItoY5ZPLihErlYtjHdFjBzj9Oc 96pXFvBHbymNI5ZWiKCRcEjPGf8APpQQW9NsLaDSoRH9qmu/+Xy4kx5OD9BxVa7sdNnWNoHU3UWY w+cNGPQfWtOZcpKjZWRmfYbpSY5QVSN/9ajA78VeiQOg+UZjf5ExncP8eKX2DE//1fxmltYbi6lZ MwXQUK0R+9isxxJDKYAA7REtCZFz5Z6E49+lfjUGlofcFmYC8sFUD7FcZ2SbHJjbGOefWrEmmzRW L8RzXjRf6M5YhoyDxn2OK1AsRx3F3Zs8pgEkEQilHmDLED+7WdHZyzsrT7CkY8oJEgjUDnjAoM5r qa0ZFrG0MB8jau0ZHIHtTbeP7Wsaz3ZiaEndK/R8jqaDM//W/GiOxsrYhlkTzFk33N7yVYE/KT1x j2puoSo08dtFJBNGr7DNCcq+e4P51+Pn1s49hkVtdQLLGl2/2VzueMnIb2PsKbp9vF5zWhYxwM25 zEuXye4FTNXQnF+z1NW/KpatbG5upoYXysoCh07AY6f561zi3LTTRxtbRlbIloZ2Ba6YHruGcDoO ld/tNDlqRulc0bp7u4MVnavH9oumyDI4QqO5Of61dbSmm3L9kg+0RxeU0ynrjuSDWTqtMfIz/9f8 ZY7G7sHiuFIYwNlxgEccdPStKS/tYraYzWYuJLqFliVmKIjn+NsdcY6V+RuofRODOS0z7T/aD2qW 0UUtxbk3EygNuXIwh4yAfX/Guo+zixht0WGOCW5DnCsGwVPJ/Os3WNY010KQS9lEkFuDLJChd/MG Iz15z+FXrS0imilMsxsTBbkmQLua4k9vSn7bQ1jBJakNjFYon2y6ur+e/t5iscsqkqV4HUYxjnt2 re1W3aOKzMMYXznG/wAscAYyWIH9fWp9syuSJ//Q/I5VMg+yW22QyptG4hGkA+9n8M+tOvvD+nWM P2u33xRzpsIZh5hcAb/1PHtX486zPr1CN9jFgu49NtXitvNE8hKRuxxy3GWP49K0bK2fyFFy6LvX kIcrnFL2rsU6duhbnTVdO0K0kuorWO2Mjx2cscyFpRuJ+5ncAOmSMdKZpVmt1aX818qSySBYwFP7 +Mt0cY+mKXtnsRyIS8uZdG0/y7Ked/sAEsl1Kn7zrk4PfHt6VSt47vVI5JVnlYXWJJJCSrOG65/+ vR7ewlTVz//R/LOCCS3s4LOUKrIxWDJ5Oex+tLHbGYC3uYo4wh3SOpO0nPTn6V+N/WND7ONOx1Qs E+e90q7SS+gRWSGeIBZigyNuc8g/yrAtv9KlaUSeV5hLSFiWJfJJx+NQ8TruaqHZGhdOpnWe4zKF jWN3VQHKqMdPXj9OtVtGt7uZpbqyguLmWLdbwxP8mFyDlRn2z+FTLFablezdzaSWe4McE0lz5Dt+ /wDMCpHC/occ4GDyc0t2kVlqtpBBbRX8KESJfIN0e4jJH4dOveuaWLt1LUF1P//S/O69vL7V71DP aCGG0hFt5iReWs69cA9+vNW1W3t7BfJMS3RYqbNVI2IMYO/39K/CHiz7uVO7Mu3TVbG6N/BZW9wZ mEYSZykmw8MUGDkjnGRjPeuhlkdIliht23tkkbMNk9SR6+tJ4vQFTsReHbKe01S5vby4dUnA82KR AyfKMDjHtWtcMNN1pmsbySfTvJSSJQvllJG5cY68dPwrF4vUvkiXNW1qwFu93HeQXcrACdI+Z7Zh jKsO3p6VTt7o3Fojvbvc27uDJEo3KM98f5601i7dRqmrbH//0/jy5ZLizAtLCG0EJAWMyEkjGAMk 9x2xWvaWepXESx2F1a281vAPK02aQxmXnnb29eK/nbEVnPVH6NTio7oRtMlbWYtQQRwXD2xtmmbA jdsAMWyOOn4bjW5pS31ks0It0tZBL+7ltrjeZR65HFeXUnK+h203Gxradf8A26a5ugwhniBDvvMZ m2DDcnr0NU3a2uceVDFNHI21llG1SM8gj+lZOtPY2VlqdDZLDaWx+y28cUFvEzG3RC32hiMEEdxg YA6ACta1txJE8r2Glr9ptliMKWcSlUByBwOvT8qj2k77l2Vmf//U8+ld9000kFkJL6BbKef7HEku 0YCgYXI6Dn2psOmqZ5ZnSCZpYkhkEoDxsIiDH8p4yCBg9a/lr2tSOzP15JW2NWzsNBttPu7i+0nS LyWWVysl3ai4uPMbnO7rj6e9c1p+j2iCbVLfToLeOKVorZIhgW5JySik5AP5c03jK6Wk395lKjFu /KjurFpLqOKOOWYQPHi68yNCrccqFI4Hb8azE8DaJZrazSaDYQxNeG6lmtoQb69XPzREsWO1uRgj vQ8yxkdPaP7zmeGot3cV9xozfDfwbJbiP/hH4bKzXUPtk1nHbpJa7H6xmN1IGR/9bHSqtz8Pvhvc Qy2sfh3S47gDBzaQ3H7osduYmBQdMZArKWc42Ca9oylhKEn8KP/V4k/DXwDci902fwVoE8eoRJbQ xx6Pb2xjC9WVo0DAtjkZxzWtdfCj4dyw/wBkz+BvD7QAJFHvslD28a4yiFcEA98HPPWv5P8A7ezC C0kfqbwGFb+Eenwq+G1lqF2tp4K8KTR3MAtpIn0oK7p0KK2cjI65znHNcZbfs7fC3+0JZda8G6Vq GixTySaPZSWyLJpc0hB3KBguFGRhyR+NSuIsw6v8Eawy/CtWaZlW/wCyz4AvEkEGl+HY4raaS0ZT aeRqOqo4OyQDYyq6E/LggAjkHuy1/ZC+D8epWF8+jNqK29m9rfW2o3buXlJJEhMYVXXoNny/dHXn Oq4mxWzS/r5miyvD9G/w/wAhNI/Ya+BTJeNdxahHd3ly00gtrCGOxt4yf9V8wZ2GO2R1rIl/4J3/ ALOl7I9vqNjFqk7TyXsbajdvY2vlDIRFjRSQUPRchfat4cYYqKUW3p2bX6h/Y1Bu6/FI/9b4uvf+ CcXwIWR3g0y4e78mS2VLOGGdnVzhdrOoYEdweOOlEf8AwTO+E9pYxyXMFleSJHE9s1xstNQhQfeR 40XGee3pX82UePK8H70vy/yufq8uH6b2MO7/AOCTHw3ufNMOuaLFbX5N4LHUG32kDBtyMNqkKf8A dORiub1L/gklp93Z3x8P6vodhcXMSlnXVR+7VCADHEYcfOAfm6kHrXo0/ENx0k193+TRzz4d/l/r 8DndL/4JM/2wY47bUbPTxdytpzqJHtxJ5YO5srEAzc8Z5596w7z/AIJM3HhuOTdJJFPcyS2X2W4k WdSEBxMTjALc4Pf0rqp+I9OPxW+7/gkPh2Vnqed3f/BLy6j8Oy22pm4FrqUr2817c6cyWlsytlMM kbM2No6Y6da5mP8A4JbeIrWZLLRJbGWZ7N5xcWcZZLoAfxhhxgdAwHNd1LxFwn2lr/Xkznnw5UWz /r7z/9f8L9I/4JceO7K4164mla9WIxbYfMxLbs+dxjU4YAdxgjmuB1j/AIJh/FWyvoNNtLXR1tNS vA41AaqPtqI5OSihCA49X+Xk1+R0+P8ALqmj/r70j7qeQYiD2OTvP+CZXxC8OhoLvTPEaRLqAjfU En/tOa7Ay537FVNp54GPrXGzf8E4fH9i2pSaZDdXceoXQk01tQ0ycxWxY4ZI2j56EnBBxwMnrXdR 4yyyT+K3zX+ZzTyXEpfD+Zh6/wDsEfG3w/qEBtPAVze6LHIqXM9jI9xdZIw7qWUIwyeFL5yK46f9 iv4o6GL62vfB3iq51L7c1zBFqOlPbRrFKcortkhdoOPTpz6dkeKsrqac9v68rnNLKMSvsl8fsc/E yFLiZPClxfC1txN9jgJEwbHIcHoBkcg15F/wyx8U9PuL61/4RfVrbUrwhpElLR6ZZKGJDbyCAcZG D1rs/t3LZRT9ov68raHL/Z2ITfun/9D+P67/AGY/i5bwXRg0G1FsLctBds0kjTMOGVyqEADHXOK5 XUf2bvG91FHayW97YzR7EkuoLKV4pJWUNsUtt+Uf31yM8djXxqzbL3/y9j96Pa+pV9uV/cSW3wK8 QaOgtr6HUZYYsefcz2UhaB+gAYLhh79BWLN8IvFti91cXGmyXNvA4AnfTp94VvuttVGBHOMg44ro hmmC5dKkfvRjLBV+b4X9zOZPw68SSz30VtaXlz9nt/OLWti8NvGTn5QzYDH6dKND8AeLplvYLjSL 43ixoxilAjLK3A2Z4NP67QqLmhNNeqF9UqLdFa+8EeJtOQmbSrpi8/2dXQCRYx3LEHgDB5rF1Lw7 rGloQbLU2Fu0bzfZLJ7pWD9DlQQPxpfWKT0TRp7CS3P/0f4iLfSblrkHybhLaWHypVkiZZNw77eu D39PWreoaJfb7S2EM0MYk/dR+QVnZsdl6gdK+WdSF9z1/ZMrwWZS9Nld3UE9/wCSWk0jcpdwmSNy 5zn5fwqGDVLDT9Mtb2S3+yTXJbzYyhP2Uhj8hNYuXM9y/ZF7TC2sTi4eMRWc3/HvK8ZjWU55254I 69Kl1HT5Jb4SQuxbd9mEHl8uy+h9Mfypx+LQJU/d1M26WW2nS0mJZpQBGqqW2Enk8frVGV47PzZJ gRLHkLIRjj1rVq6MfZ6n/9L+HmN5L9GcJJJJHBuUhCx2/wAP4dKp2dpdTz7CJHVGxjps79a+RtG5 63snrY0r2zIZXV2hli43HljVaFtYSzjEunxSyRyPGs8shzKp+623IxWqtbQwnTZl6Wlzd33k3El3 lTuihGWSQjr9Pwrfv9O1cRG7gdC1vcIIoTGY/U4Ljp0OO/FS5q2hPsyzaxXc9xN5cEUl5PbNujnk C8KpOE3EAEYOMcmsIap9siWGaNdsa7FVVCsjDgkn17UoTaduplOm7H//0/4fpbd2t7dCjK5X5Jhy eMYFUZrZxv8AJErtBGGmLDCKM4yD9a+a53YHGz1RVc3em2tzc2t876hKAWspY/NjdAMLh+xGMY/n Vy01WSSwhuLmzaO4kwcMNqKMfNj3zjijnZcY8yIp7+4uZbeMyTLGi7YoRkqueT+HJ/OtIS6oLcj7 Qgh+4vAbYR7flTVR7ETp9ya11R7LUbK1F5c6jeaiFSQEBIrbbwqjHTr3rcvdQihkeVoRHKuI3kPM iMp4PtzVe2stS6dI/9T+Iu21/U4Li/ZtS3W08XkpHIw78MFz2Pt+FYbX13G4eKSRCkwbKjcDk9Px r5v2sDr9mzobPUb2GR5lu54pbkeVkSEBeOgGe/cd+9dH/aOozvIlolxE0MBmuZ4iAAFH3seoo9pE UqTMVPHGv2cFvaDUr2RYJ2kSR8IJSx+bOPQcY+tT6l8RvEt0r29nq13aWbxiC5jQBhdgY5kBoVRM 0hBosWHjTW9LaSeD7HfKsOyN76NmDs3G4j29gOaR/iVq8lqbOdnF3bsLlTp9tujkJbABPfHvVc8R yi2j/9X+La6+IutsXubi1YyTQxpePanZMypgbiuMA4HtUTeP7pbm1ktZ5SqgDh87D/fI9Rjoa+Zk 03odfIzX0vxbqUtpcT/YLYxW92w1LULhgZpY2H7sKvqW9OefzxW8ZSm9QpayW9o4KPbqx8yTceXz 2GOMc9e9EWk9SWmtzSsfFMdrdz7o1khS4BiaVdsbxnpv56596taz8TpYdTjgh022jWaz+yy20ent JbXOOd8jk454+70xWt0c84LY4+Xxo0GlyW6+alzLckpavEZbeIcYIweB1447VqWviu3v9PKxpPDm TyJ0mAQR4GA2Aec9vrQlHoQopH//1v4pJvFMFhqOnIdOnk08qINQbzi8Y2nJbHbf046Vvaf4w0Sy 1u6itNCjt9Mlk8yG3EpWTdjO8t/Fu79eePevBhFPQCxLq+mapY3sUdmml3MchmEMJ85oyxOJN3TH /wCr3rjI9TvNNuft7XUjyK21Z4ztbGMHp2Iz+dOcFYxkrSZ01n8QpzBJBdxyyQ20bnS4kUNGzyYz uU84GM1ii9fypbzzJ2mNwvlL8qwxgD5lI/75x+PtWPs4lxso3Oh+0PaeTPp2peZKIhPKYF2+Sx/h yeuP61T8q41yCa1vpneyvZQLpEP7xsHOT6c1z16aaMFK1Sx//9f+UIiLw/4P0zSreJZIJdSkvJfI gM99L8gUeYgywBLHr059K+X/ABeraXciaOab7ZeSNJLA8DwxwLuOAGbqcEHkA18ph4rlbQTacYJd LFDR9WNuz5ka3cIZEmjP7zcByPxrO1u7udXuJLqyjVLG3tkNwgLbiwADvtP9484remipfEz2Lw/J 5WkGZkRorG1+0BdyoYoxtHJPuwwP9qu0vLO3juLPVzHIsh0aJ4VL+YMSAMxYZwD2rWO6HB6nFa7r Zs7crPbDZNOJUmxshjC54Y+nP6VJ4ZgufEepX2sXC6daadp8EUEM0NzvlJC/3Dgsfl7Zrdaolas/ /9D+OLVL+/1XWdO0eG4lUxyJ5d1JLvkYb+VweinuPc1Pf6bGkssFpJKl/MHf7MUCoHGPu9yDxnp1 ryErgUWsNbXSr27uvElj4dvLZBJ9mnh8+SXOB+74Ax0HPTNTWpntoL2SOQ6ofsqvHAxCBnIxuUDq Se3tVOFkYybvYwLGO9NnJcarF9iFu5ViX2yE564P5VpbLeWD590gQfNuOd3HeoJG297c6KrQxYkt bm1Dx7wJdvzZ5PYjAwOtWdYk8P3Ol2uqtrzR6ylzEP7OSN4ri5BJHl+djHGM7fQUCeh//9H+MOHU PIhuLq9cyRwnfkKWcDuCe/T9a2dXvhd3ulfYNS1Fv7Q0tLqDTlj/ANEuChw4zjAx8pGTn24zXlqV omCbjsd3shs7DR5tTgiv7O0VnubKTh4A+S5IHJ+btV0aJpVpY2l496kK30wENicKI17nnkbvT/Cj nuzVSVjl7nQ7C81i7mt9N2qqYYwMTHOi5JZkOfzqpolno9lcXstpHPb21zIZzHbnK27g4Lqnvj+V Qr3Kvc6m205AhZL2SPZmYNKgMr7v4hgfSuTltLrTvOu5djk3Gwb32u6n7pAPf2rWXwsD/9L+Pf7W b7UbXS7fToTNBai5S4PE5JONqj1/DnIroTZrJcKhlVbyJSlzbXClXlXHBOeMAjoTXjgN0m2jupP7 NllawlaUs87zBokjB5OD14xgA/401LO5UfZytos8N/JDbzs2WkiyoWRiOOVzgex6UDW5kTQXWl3b JA6yQBig2phWPf6ZroBJdTWpEE0IaGPeYrmcRowHLAE9/pQbmD5kYlhM0rwSiTYpt34DEHAz6VoW VpaQ2sj3Bt7iaxuvtEd8Zs3h3Ehk69MdaUldWDyP/9P+QVor2+vNQu9Jt9Lt7FHacQXc5jVkUZYE ngnJ4HetvRkutT0m4aOW0JtWO6yaQxoGyNyq2MHPb6dK8BqzsdnJoRQ6BqEVytzNA0sFwdtvCwzG pHUKR1PI45qour2dm82nasv9mss7qN0ZdYwhO58dc9KQoxumO8M+JJby3lgtM3NlBdSXlm8sJhjm fheT24UevtWlaXOo6k0+o7IbAK+ybY+HGc8L3/Gpk7ExV1dbHQRW+m2emBbMrvjZppyyBGkLkfxd 8Y6Vx95rl8lpqQstBinuXaMW088pjmZEb94dv8PfGc5A7Z4d7mc4vpuf/9T+RlbuK202W+nSX7dJ EfLWbiL0AU4yD7+lZvhltRu3juvPvo3F/wD6XZRWwWB0UZBEpzkHnnHavnyJRuzeW+ttO1OxniRf JfVE882sfmLuyfvY6cjqe9UWL2hvpI45nmv9Qe789z8r7ieD6dRQ9DNpxNPVLrUZLa0geNZiJBst o3zBFnBLd+gFczrl5YwEWlzBfyxyrtkljtWeHJGcBhwT7UCOg0BpVsLZLeF5pJZM4li+eBTwu3PP POen6V0N3YNpzmG9eKeVwJFEYKomQCAc+maiUmtEbKCW5//V/k1nulZJIrNgt2Y2QCPopIwR+pFU tDt7TSbeaxZW81pPMMCo0hG7q2eoGc183z6Ba2g688OHWp8RC2FuyCLy55RCGcnOSScfn7VWD3+n SRweRCI4p1trsRS/aIzsODtYcHpWexulbQ6i3t01C1vJoJMlEMlrY/e8+TIGwdxxWJe6xFZTRRvq DzG0EYuoo1M8Fuz43R8jJ64NbKSaMnvY2LYaJrct7apOzQWSpOFVCkchPIBOeAcGldNPudTl1GC7 8kNaJasVRkWPylYcfXgH6U07q4o7o//W/kw0Ce/tbS7gu9t5HJcyS2rM5YWu45+Q8E8fh0psujQR FdZilmCTOY7tTzBuBwQD0z0r523vXNpaRZuXdnb3U4laGOK0t9PDyTSP+8nkGCrDt/ke9V5orrUb ZLc7XtzEYWJXDBewyO31qJrUxETRp4EUy20cyxwl9xHQdAQOvpWRo17ZNPqsDQtdlwtrDcTxksrB wxKH0GCP8mptpcFodM8q6TOVv4LO+t3QNH5M4m3cfdcL6Hsai066LJcyy2Ygs1nwilQokXjO32Gc U+Vob1dz/9f+TtpIklthZSXVwXldpJJOUj5yo3dFx07dKkilSeW/t9fieOaWQxWcsS+bFPuOF3OD x+FfMWfYzk23ZEkPhb7Dva1u2uIYFCNDPNGuM/MCBjORjGMnrTL3VJrDTg7p9o825CC1t5A0uAcZ x2x15qlKy5Rw2NGKytNQtrSW+Lq2lzme3lkk+UFh3J+uOag1Jb+GKS90aN9SnUqotQyhpF6HDHjj 6dqgtrQoWd0viW1Fs1xEk8TGK4sGHlzR4+/ljwRngYNQ2b3Vm8mn3dtcz6XZSbLUbzJBAGwdwOMD 059Kwe9y9qdj/9D+UTVrkQWcBhk3J5gdNrKd4z91/T2qO4s0hSPUQF2tGGuJEAwidTzXyz2PPIrx tNvJ49W8PRtbNBaJazhULecuMEkep56deanW702ztTcXgupZIkLxw2+TI5HG0rg0oL3RR0uWNNsY 7ub+13YvpscJItmt/KkErjgsWwwx0x9a5rS9S1Kxn1KCK7EmmXErGNNoZImyVbaev61nKKWwyK20 yCW4eKd2IQg793Mhbue3Fb0lnNpwXTGtBM7D7clzb5kOz5cKzDjPI4+tXB6WNaex/9H+VfRRFLFf Rrag3KwG7aW6nGIsYXYsZ4565P8AjXB2VzM13qJ1eYiOW5EYtrCP/R933UHPBI3fhuPrXyrmkZwv t0Ogmt7fTJ7bT7U3DwNApUyIRhmJLD/6/vXTi8sNIMhhvpUlsIlLz20DLG7yDBQHuBnk/pWJoU7e 7kuxLeXTtIsjHyNqjdjoM1ky2jMoVr6Qz3DuwkKBWhCYJI9aBp2ZpWbQW9hOrIlw06bYpGfLRgHl tvYnFRWzXLW91Jp8lwUs08+e2cFbZjnAySOCeBx6imzSUlayP//S/ljtNJ1S5lilhvbfztU4ks2c xNF3Rs9Oe3+c5kU39lX08N3chZm3J5juGIx1QEfSvjwI9yTOkRure7tJsTwxLOGJfkfOnUEe/Y1V E90b+/hcRWotCv2ZIH3JLkfOp9wfrQVzS2ualhq2m20Vw13o0rXupBrKzuDKY1gcZO8RgEHhWPJH aqTS4QWqxIZPvwSTAkqwOcj/AD3oJvrY17edHuYZLuNiYh5QjQkIwxjgep6/jUV7FC4udu6GLaSc sQQO+D696DJTfU//0/5XXit7dtO1CGCOdkdQs+4JPGrD7wHX8K6PZbrKQCkgZc7VOGAPRiK+PDpc yLnUIrcyhIneOOHajI2FDetYmbjUorG/gjitbS3Jubk384hW7+U4jEbAE84456UJX0RDlomjW0TP 2GKeT93qM0jIIYo8JtyQMNnnI9qszajZidbNRdLdFMLaS2brE7rjJ8wjGKtQZUdVc0WjEo3SRiaG NQzMqZELZ7+gzXNXOpT3HntprZgkzbvNEu5nCnBx6rkGr5VblKTcT//U/lnsbi1MXkxFnuSoWYvF sVW9PpUbme5nlwAm3EQWNtoyvBya+SmrMbbe5NeoREGL7JMAEZyFxjOPamW135SyINzbRlVP3GJG M4qBGONEvbe6hngENpbXcoa48z5/OQH5jtHOfTNdfDeW8sb2NohnRJCjSopjcEZGAPf07VzgZ2m6 ahu/tVzdkJI/kJayIGZCOrHuc5HGe1bBae7nv/7X1NFWy05ksIfIzvVD+7jz13YJ6nHFAk03Y//V /lk0+PR/PttZk1SWGW3uhELO2VZXl/vB1IOVPQgc/TrXTXtvDczvMsMcAuh5ikDbtHbB9vavhzSE vsmBa29yLqS5LsyxH93b7A6nb6k+vpWgoutPvSyIBYXZRoG4Z4pCSHU4/h9PSg2UmjoZkmunjM1x NbRqoLrCiyC5C9EOegOOcYNUNVbR7yPytz6fPPKkXyxlY3ePD5LHsQoyfTNdBqmnsOeS6ku7XUUm WFI18ue2tBvs5flCjnGeCM5FLqyyyNBLbzxSMJFZ1b5vLHfB9cUDqP4bn//W/mEMUd3K7xkvcoQB vOAPp+daxg+y2Lp5rrNO3zT7seX6Y+lfHnoGtKxeKKQoZZY02i52AlDjGc9qx5ri6igm3Qm4JBxD HlmmHpj1rOV7gFjbabqWoi/hbyZ9OjjIsbhTHvYrh8q3J2nNWZtLmuJUVMec8gWJF6de1Rd9wHf2 Z9tXU1stUisbizj8vyblhFskHXYT16+/QVm6VBHYm7RZpprsOv2iRjuVsgnIPTnnpV0+xDas7H// 1/5nBHbLdSuJSXcb/LzklvWiG9uJ7i+0mfRRPb3dmY7a/dmxHIePlAPBHXng4r42T2SNpOyKemW0 qy3FuXnBtIEgQOCsEjDg8+vr1rQuLeO3ubZbW2LzuhmvLrd8hOQFQL34zVEVn+5ujX88fZJxLbW7 ERgsYz+/k5HAHc+3tUFtDHJJGlxKRAZMu+MTbT2/DpXLCXUVILjS9OtJLd7m7Mv73zYHcBNjE4QD 35Aq61g90THI8jRJlhtPI4P8vSqNkmkf/9D+b97GwbTbmJbyYE2++GW0h3zRMcY3L2HXn6UkMKC3 gs4mNwJrRJRcMCm/cOcn196+HOg3r7Q10SC3WC/N2bizR544n3wxyckDcOpGearNdtcxxRxxRwOs axyRxnHmEcFsepoNmvdsVmW6s5WtvIklllHETZXBPrV1bK5RAt9bLEHiaOWMTFZFYjjA645zn2FD IlFLVFEyw6ZaQ2ZBhtY0EKSyfNgDAAJ/KrtnZ28l9ETIv2eI73w23Ixjg/lXOVBaJn//0f54I9Ot NNiLRpHc5lLurHkDOc1Wle7lupdQ06VV0+Mrssp23eRKuN6hj1VsdDkj8a/OXFKZ22981w1vdzHU rzL3Es3mR25AMMB64Qfn1zVptVe5uzaIPLlEG9HAOV5xkcUrG821YmQ3P2Y2V6qG6kbzluYwV2Jz jK9OcD8qpNNc2cJmuZvOjP7sQjAckdAo6kUioyvob8TyG1aWHaqzxhGE68x9/lPY9azfm2SxCeeG K0w7yO22Ji3dSeCRgZx04oNVNrc//9L8EVu7i1sZGh/dtdARyMOfNAOQaWSJEjt555yhkGXRf9Z+ Ar8xUU20e7zoq/bZme1aKBQttKW/0qF1a4A7c/TtV+3s7q9kimuGa32t5pi3kevBHcc9KbhaNxKf chvFMjS28I82OQ7SVHzcHoRUaabZ21zII2kmD2qlmddirJgZ/Xipas7ClK+gqW6XGYwB5yfdGMAe lSx6nIZWsyZIY0AS4dR+9UfxH8s1VNakH//T/BqWyisbcz2sbTC4wYDkIACQS+PU/wBamhWCaRpJ Lm6gkSEr5SjfCT1yR17etfm57DV1YsWbfaIZWs5grk7UMv7sTckY59amMIltG+27kktm3bdp+Yg1 lPcCnqdtLqX2MhDGlspiDKCoYE5yf5VryWN0bFHWPzFgXYqqvLE8gFvfB61BulZWK9lexPBdWtyr KVQQsAhCqowcA+2F6VajkWI4tNjxEbc+v19KTV1YuL5dT//U/ElbeaJ57lrloIxGGijiBZZGB5yf 89K52/uJWjl273IG7K8bq/KXFo+nTT2H+HltonlmudqmdWguFLZ8wFcLkHrg4I+lbtrp9tDEwE08 zNJhWMYCqDn/AD0qSk2tjTlSK2CwsE2gB0bOeSO/51WiEUdz9omGEjOSPvL7ZrOUeqNFNdTOu57O a5vYLNp7gSopLyKY4ocjkIPTj9ahtdPWyurW7hlkW6MbQzqvCyRn+E+vU1mE3ZWP/9X8arZ2vLR7 ewklaa1DT3VtJ8kQUY5Tnk9cirdnc2Tlkl8+OdV2KssLIj46kMRg/hX49JXR9dD4UYdxqk63DW4s hdxsjrBM0piktXBBXgDnPNdGBOIY7jy4twjAYv1U1jrHQoLBXufNE5HOPL+UBVI75/KpT9oMk6TH ztyFJGdt4ccLzk89qL2VgH2txqunW/2BJ7qLTbk4FovywYIx9304qj50EMv2YWVtMkcnnyCVxExP +zxz/wDWq3G6ugP/1vyPSKwls5ZLiOGO6iBniVmBIA6bfeuXuIljz5cxWSZw64+YL9PT6e5r8Xt0 PsU7O6Ou0+8mmlayn/0S3FpvS5k+WN2HG0e+Kr3OnW86utneWs9wpJVnkC7GHsTUciE31Zkw3lxp 8c2nQW0UjzTiW7us5D47DHHXn8ua07kxXMUKRnZJEwebK+gzgex45ocF0EpK+hzt6Jbx9z5WEsYw o4xj0rQuWtrDTY4Iiy3M2Y2bIO5SO3HBH9aXs/Mtyb3P/9f8bJEu20qzl/0WWa2k8ra2IpZlLEgn AyetaN1LNahIr+2gjleMSRrEwkSNWwRtYE+1fiap9z7KMnHQbDFBcETglySEAbgKf8kVG2hob572 XJdYwqlWwowfT86HDsb05K4sIa2nfaXeOWQF0hJdY88DdVq/ub+zWN7NSI7hvJZRgmIcHcR2z61k 4p7o3NHTNSKSra3Dw+dKu4sGHygf3sdK27S6txdvJvMKn92u4Ebsd8HoDz+dZOLRUPiP/9D8w4j9 pkKQDblS288Zx/npVlbX7O32nzY1eMbT3mOeOB6etfgzinufo7dlcvu9oYtn2aC3kPEk6JteUduf Wsu4/syRkRZGmWyYTzPDnzSF5wR/nmonHqhS+EqmSykgu5EaT/SJUANzFiRVAOck9P4elMsnjK/Z FUGCIkK5GAM+lE0khc+4rWelyw3kNyzCRHjdApwrANlgfqAPyrKv7i2vbySS3tBYwQ3YSFeWEkaY APP94DJ+tRZkSlc//9H8u57mKaBIoYUKB9xkx+8HGMD2q1aNKkGLaJ7nC8nZ5ZA6Zb07V+CRj7p+ hKTWiJYYHhcM8zSBzlsjlT3FUdY08TXaXkSKqrGI/PiGHT13Vm1Z2DnkaNxPYm0jCmV5kKqkoQJG w24I29c+/eoref7HNcCDzpLW4t4+ZDhVkwDIAPTOR9AKnlXNzGkJNkGryaXeLZSTWUCz2nMb7csD 6/jSw6zeu9jZXMrRWrzFrYR8CXGM7yPp37CpcLu5pGTif//S/OGT7JqOqTakALOJYlt0s0fci7Vx u55yTz+NZGpXtg5jtIYJpNQWb5HMB2bTwdp9c4r+e+TufpTm2atmHWPY9vHJfuwQTuxEiIoOFxnF YlpIb1blbuwECRyHZKzfNJg4OF9O9UopFwk27MgR4xHcR6dcLKUILrglIcnuehPWtqN1TagcXHmo GZs+3Ip2Sdxy0RlxwLJeCNisKZO9nB4GOuOtVYtOsdODyF5ppZpCkQcb44wTnK+h7fSqiruzMm29 z//T/NG3tpBB9sEbSRCcQRuyZjD4B256ZxzirT2bS2Urm5S3mDhtqqGVxnJUj047e1fz+fpBRvpI tRiispYI41tgJRcoSJtwGOfUUsNlpY07Sbq7nsryG9kdQltK32qEKRjzAR8uexGehoAgu5orid0J ERik3Ns/1YQ9Mk9K0JbCGzjB1Al4jEJ7c2zj5QQCC319KuCT3E2luc7BPqcTTS/bCkcymOOEABMH oM1Sjtrax+WRpbm6mJZxN/qbdWPG1vwPHtVciIc1ayP/1PyrWx+xSQXlnHBPEsglltp2K28gzyOP X071s6oA0hcxmy86INHEkfyLwCAATxX4FyOx+iKaSIbGNbeR3ZXllljC75Cd59Kyb2JjczLcKDGX URqh2tGMDOT+dEYN7kuT1N/VrOUWunWltZSXyWNwZldWLEjAGAPwP51RvPElwsqo8ImMe2FlnJXa oAG3A6YH8q1Em1sbtjJBZym4KiaLyMCNW+VSRwRj+VUzdwypOs22GUtm1jRc+YCecknrisGrOxpz Jo//1fzHXVHhQaebaTbtDwkptRic5+b8K1ZV1K0t7G4DQOsEolnsDMkiTq4498V+AxtfU/QLFTU5 11KziitrVrD7NM8jxRrtjy2Mn9P0rljpV6XBnunuVV0khjZAixp1KZ7g5/U1omruI1Fs32s7EgyQ xMCpxOE/1fPT6dKyrhIoyYrdI2mQkeazDn2z6cdqolpPcitNCt7opNcyNK0beYxwNoOOw/OtINpl vb/Y2tMYuSybxhJlIGQfbIH61UFd6icE3c//1vzF1aSCO1tobRxFuO65gRfl9sf41i6bFpVpNPcy A+YzZkOzBHGDlv8AGvw2C90/QC3e/Z96mLftYZ8yMfKoPYn8aqw6eruWKEoFLhgMiqsBkJqoWO4g FsYijny5AdwbGcZ9M/jUkdjpM9t9v1KJri6niXZH5QaJQ3qe/H4UALBp9rlYLOGKCB+NgURLgZOB 2qWCO1CSRJIkbrxuc7QtaU+oH//X/J2JreyfyGtJrm4uX2SzeWWt4UGCDu9TzxV5baznuXFnbxWz yLh5UhCytgdSfU9a/Fz9AK95b2lpssZ97zMd5mk44PTHasW6sza3LQW9tM8JtftbTNGRBjOCN3TP 9KCXLlJNplsZYoQy27rl4oW4kP8AtDrx2qpYaTbT2/zlCyNlVRvnjI9R+dOztchz0sWC3lCW2hh8 yZEZlDc7sA5/lWKiXAR51jWOR/uxSNgKfTP51XK+Uzk7I//Q/F2JduuW01xFdeasbmAwRl7eY4GR I2OMds/rWve3aK3kT6ewuZW82K+Q4VU6eWy/rmvxmziz7TnK0+nwvabTLLCzt5gaP7xOen0qWeeU vAEyY40zJuTOfxrboOD0sZ1hJFcpfxRCSHLHzJVBUg+x/GtfSvs506OaQTDLmKOWUf63acZJ9en4 GgU2rWLF3ZRyJ9p3Sz7NqoiL05Az9P6CpFeygtri11DT4J2lj3RESbmXI4BAOPWgII//0fxyt7GM WTWiRoLa5kyykdPTn8aifw7KLS/XTzbNJYKJPMeYRq3IAA9c57V+PPY+0muptXcNjPZWwS2WxvFh WOVYZmmWYgfM5LdMnsPWsyCyjsYJZ43eS7eTEYc5RQBzz25qZuysEo2pl+FNKSJ57+eWR57cpHbR chJezN6AHH5Vh20axSNKsUcsp4yRtZwK2UvcVjlq2skaLWkDs2oRQyBXXYvmL8yHoRn8KsaeXjWS KeO5t2I3hmjISQHkFT3GD+tQLS2p/9L8gZZP3rLKsggkIjjbbneT2outLZYmn2MY44vMVUXeygZz kde3Svxqd9Ln1KV3Ys6XpVq0TajEBFcXgUzCZDHcMAOCVI6VTu7m1jvIo7e3+0BQ0UsznPltgfd9 un5VBulbRBdJdRtZRwxN5Us+bmaNd2BjgN6DjrV1YrBzLFduAv3QsY3Mc9MDv0FJuyuB0Gi6bZvp 94rI0s1vB+8d8I0aswVZDxjBJAx71Tt0VljtbmSQzLlfM2fe9CPb/CoU9dSuWR//0/ybXSXKubdg lyuQrk7SP938qbDbXzRsdTilIU/IsibSMZGcdOa/EXJtn2kYO+pD5SmNmktVEDMBvZeU5GD+dbEG kPeafO9ssJEfyEXDbUJPTP8AntSuy2jPhsFWSCy1FzJHAcyxREGJsEEop9DWxHDDayFoIhAjvgJg umf4V5/rSE4prQfHYyX7PD9jkCOcSbkKuxU5wBjocVo6Vby6feJb3umz20AJl2kDdKuOPoD/ACrO UmnZEQWtz//U/Mzz7R9RkdJI3kt23i3dThD2H4ZqvcWup38ssiPAUZcT/KEbBIAKgcZ6V+EOTW7P uYq7sPtdFvLEq088rWsMTSyfOG2r3J+g6D3pUS3KpeWZYweWGid0wMHocVhKZuaYt/tccdxcgRyu CoEHELeh2/hWhaSRWmy2tpZLe5hTz2uFibL46c428njArCVR2AsWN1a3EU9pfRtBKyswdhvW7bPG fTjP0qe5RrG1DWsKMi4zswNuenFcsqjRrGPVn//V/PzRJ9Rk8/8AtBlFrGfMtYS26ME4zwOhPv6V Nb6UJLu8hJmZp285McJFnACqR9CfXmv5qlUe7P0Rwd9DQNtLDKrmbDWiYDscOg9FPb8PStd5IFtI XjhVrjJae6JJlcduP/1daz9roP2auY32l5Y4buCFriF7ho5HYFEGw/MPXNPn+zxTS3PkzFJ2BQRk s0fTAx6Vk6rT1ZVkYGu2aECSG2jiSVt8nlIcykkA7h3P+Nb9pejS9LtrexV98g2TGRflIz/D+VL2 7XUdj//W+Kra1uWH2uSScMRvhhAzEzA9T/hW7Z6k14kN5NpbW+qW5a3cxQmOW5UEFcKfXrkcc1/L brSP0uMU9zrAk1+6sVW2jjTe8U7bHYjqv1/wqvaPOJZbWQLHFPIY7ctnYnp8x9KxdeXU2hHoWbWx a3jMJU71YjLPv75OD3FakRtbaCWOaJt0uBFKiZMTev8ASpdbubJW2NixhnMYKkOuwqeMEcdSK1dH gmQyT3UMzW0YkAxwzOAdmPUZIP0FR7ZXNFB9T//X8suJ7iSJ5YoiZEUskT5U5xxxTrSZo76dTJ5s clpGUwfuykBpF/DkfhX8oOtGx+wxi9kbscFrexRwxS7JlG9LXoJscMc+voPeoY7eK4uTam4mtvsj 7ZYY+PObGdv9axlVjYbhI6sxTwR28UTKpRwSjfwqeuan+R9Uie2lnYwsD5W/CTkdMDtz6VjKorbm PI+byK8eoXdxdSC8V4EVyhm3+ZuOfSr1jb2M073MSeZMg8lpSPnPcj6VzTncuyR//9DTcxRtA6TG 2CuVuJT/AMs0PGR3qIXbMrvGz3AT5UlYYZwOAT6Zr+Mpy+4/YLWNQW8P2CwvZEP2p3MrDzNuUPA6 fjW1FNbpCszQSTTLOF8tvliVQASc9+tY86NoLQZHEGid4pTbyhvl8sYfB9PTpj8aS1tbq1ha5nKx 2zkGLecSydQfl61m9zpWxvR3EMSuCSsKjJlIxnPXvnP+NZtxf3G/7DaRwGCeUCK9YGS7QZyS4PAG OMLXO3dnRFWVj//R9IvNP8q5tpdJvkmRGJuXdWSQY64H5960fsE5jguZJYhHIcSK8gM0YPdo/vD8 RX8MXd7n9AJdEMj1OzbzI7eI6h5L7LdWhYQs/Tdzjp14rV0YahDcSC2uLmCS5jEE8KuQkmDkceuf Sk7sclZ2L9xfz26XUVzeyvC7FJbZJvnQsCCUA5zweRWQ8EUMlsCZru1Q4AuMq4U9yMnnNZ3a3ZSg zVt9Z1K0doYbhUgkO0QvEs0bDpnawIz9BUdusmnXRKIBd3//AC0EOZcdckgcChOTloyZQstT/9L2 Zrmy0vU5JG3pqV0AHXlvMVcEkZ6fw9K621uLfU7o37W1rLbqv2cSzaVEjxZHKk7enBr+E3OpF6M/ fZQTRal1hbGe4iUxXFijhIbd7ZRF90qB5Y7cn6CuU0/SfDZs5bUaRp+nrJIZZ5NNs44pUZmydpxj GOOg4NX7eqn7rZHsla1iqtnoaWM2gQWVu2n3TPLceZY+V5+w7lyOzAgYIxzVZLfSNOmYyWtk6arb fNHNpi3bMIztALOCRjA6nv0rZ4rEQ2kzP2UZK1h+o+EvDWsxM0/hzQEklt/KluItMS3upgejOy4O eAKzm+GPw81CGC1vtE/seJIPss91pEcLXF6nC7JBKrZX2ranmWLitJsmVCn1ij//0+2f4TfDuDT7 jSp/DY1O0guDJbX1yy2rwpnJxGFKcjr1FTN8FPhRfSQiz8FeGWtzHtkfUdPjEgYjBkV4wOfYjHtX 8Y0c9x8bJTZ+0vAYeTd4o4O//Zt+DOoXO3UfC1qYrCTyDaQ82d3tJ+dgeQenQ+lTn9lT4FXrXAv/ AAXDZ2kluo054oneV8jLNNvOGUcYCD8a7o8R4+OnN+C/yM3luF5uXl/FnmN/+xn8FLi4t7iJNG1S wjYxajp9tp8VldwoWOdm5GJfHfcM4qhJ+xl8C9Q0uXSH8HR3skMss9nq92UhltozxEoVF+QghQWJ bknA5xXZS4lxKVp2f9eRjWyuh9ltHNeIf2Efg1Z+HtIih0m0XVtQRjqLWd151nDtcbGkDK2CQei4 +6etcnrn/BPT4T3F1cDRreZrc2Mck+pzywx28LqBvbyVh+6fu4zu5716MOJ4Jr3bfP8A4BwvLHay f4H/1Pg+f/gnD8K7y/nvLe7XTrkWAR57u0eG1uMcN5bBSuTx95c1xWp/8E2/Alhrkcui295eSy6a XjuZJReuXwWcKMDEZwCucfQ9a/m6lxTB7VJff/wT9LeWSvsvuOW1L/gmdYSpba1caSnzErHqENjC 1xGegSYkmQY9Djt1rnNQ/wCCXr2tqIluNKv7TW5nN28ggMWm7Rn5htPI4wWyOK9OlxN7qtW++3/B MpZar6wOd1L/AIJhXN+NJin1Wxs0t7jybS2GpLBbW5AOySVQmVQjnK5/3a564/4JuaxBqkOn3mow R31uGc3CyGPSEjA+V/tCxlSWBHHOc9OuPUpcRVvi9omvO36WOeeXU/h5bHFa5/wTT8VR295J5sYW O42W1xojQXrT+d/F/f7c4Udulcnef8E0PHVlKlnBpN9qUBCi4t7ll+0XBxkvuJ5bp8gx9a6Y8R1J PljKN/L/AIcz/sunHWzP/9X+ca+/4J+fE6C6tzF4e163gLtBcFtKeVpccJGCi4yP0964qb9gT4ka B9qnv9M12PyrR76G2jRXuXYliC64PPA+XHpxX5FDOa1+h908vpoW5/Yg8fXdvpkNz4f1qSWZUmj1 T7INNAWQZUTb0IC8gblzmsnUP2SfFunTy22oaZKJoEEXkW7PcR7lJBJfyxk8DjAB7GtlnNXaVjmn gIPY88H7MfxBt7ptWj0NvtOiq1ybJGeNpYnYKjopX5m/2Oe/1rOb9mTx7ezme4a9t7S8PnJpMJdL xHT+8uw7Vxn356Vcc3V/eRk8v00Zzkn7PPiH+0RdTvJFPuaCCKN2Ebhf4ijKCSMckcVRh+Bmvt9s eTQbrTp7KQi0jjsjfWurOMlmmkBBQHtgHOa6aWbUL+9dHNVwFRarU//W/jxufhN4ovZ9KkubYw6j LZNdT2WmRn7NCgZoliIYLtcFQcEchgfXGBN4Au4LiWwvo7myeSb7IsV7F5Ulw467OzD3HFfCQzHD Tjzc6/I9KeDqp2USi/ge7ltNTW0sL28lsonjcWkPmYZTjanqRXLt4E123gVEtru4WWcLbrPC0bRl vVcZAz3NdKr07cykRHDzV7o09O8J6pZ2EX9oWYfUWdw5RdxQA4AGB0wOtUB4X1pdPuJrvS7+1kXd KqyRHypQOn7zp8w9TR9bpPRSQSw010NVfCVjp2L+7sdSEjwBo1htmluFm2g4AHUZz+lUtP0EyT6r BewvcPqFsktpBclo72xZskgoPXHQ8/lWVTFUWuVzRrTw807tH//X/hZmtLuLUWsLof6Qv7mS0AP7 o5rsNOt4ENtGWRHn/dqJGG1z049a+BeLpWSiz3lRnYv6zprxQqmnvJPbWtyskt3FDnyWXkkkjhQe Dn8qzV1O6WwR5Lpo5Z7polvAAsVwMtgBunbH1Wo+teY3R8jGWyvpXllSY3UbEskjAEM2eRUlvbzy kCLKzTuYPKlHlrIwPQE9vetI4nQaomsY5bJ54dRiVYLeLLyLjyR1wd3Qjg81qaG+oaXLDfQW2mXu nTJvunx5rhScqF4x+INaLEpbCdHTY//Q/iYfZf3M5WJrPz5GZ4o33fKxPT29qoiws7eKe7TYsMQH mTyHBTnAPPr7V8N9YTPc9j0/QtvsFpDhAs5m/wCWRJSYclSf/r1zl3c3V1ftcNKShTHkBABHgYwv t1q41jKVGxctJF8mK0RHvGlm+bzRuXdnK89eD/Kqd9qGrS6ld3epxLaFG8u3tochLYKMALntxWvt +xzOk76FlLSM6XJfs8jtMSpjI8oxgAYbJ65/pWXbWckyRThssJMgI2FG3n5h3rWFW/Ul0n1P/9H+ Hm+nWdY7dVFuThWZ3wHYdWJPQe1UpkLsg3SgwghJeivXzkZ9GbunZbGW2p3NrLJCs8m2X5Jx2cZ6 H24FaD6q8KQ2zJuWVd8JUFnwfX0A5rRtvRnLKDuWdOtZ77ULV0uvI8iToSERs55Y+1RyGRL6a1a7 iI8xkjdW3pkE4+n40RV3YTjaJ1+km7ik09UsAUd/L1Of7RsQgfxhMc+g9xXfOYUkht9BSKRZW23b 3K+TIxHJxjPt+VZVkublOVL3z//S/lc8H6VbX+v3smt6qNJsbS0eawuWJlP2sMGWN4/7u0Hpz09a +dPiLctqeupdXDwTiS6eV7VYyttMfl2A9CMAYIGOpr5nDrlpESvzK+x5+NKjleGTzoIozLlliBkE fPQ+q/maj1RQrTCyvLZIJion+y4JmAPPHYcVqlbRFnoOg24ntv8ATNOtNVsxEscrysSki8FUwMZ6 DI68CvQBqWoQvd6fNZRiGPT45TdHrbI+AsKj0xt9+a0jHZlwWph3YtpkjLTRxtuDRiaLzFfHVQvr j/Jpg1i1a4ZbjTwII5FuGOnr9nK7QQ6+UvBDA9PUD8dbW0E1Y//T/jGKnUp59a0oyvZrcE2skqm2 niiyQuVPOc5zj1rdlv5rO0GtoXuNTOLUymJjcwqMfc9ck/pXl0+oEF3cWeoraNr2kvDqEsP2YmVC 0ro53KzDoCeOnHT61Y1CARXejJpVwBAif6dCYtiA4wuG6/LgYx61b2M5rqN8SJEJJZptQuLlJBFE q3QyrlRkkc8c+uegrmrWePz50YyLiLLbRlCvr9awMy/d3EGsSraWchtobNERmjiCyHA5yDnOf8+l dVDoXhBHh83S7y+mubYLPPcPmK1lVSdyheg4HXrQB//U/kB0ix/tIz2v/CO6Za2hj+zm2hnaQOc4 DkNzzjJIP4UyytF027uQbVp7GziEUFxbAPb2rD70eR9O3HPtXjnOVI9VTU5r9gLmKJV+yzRyrhFC nhx2yaikfULqFNXzbtplr/osBuSxldojhgD05GMfSqgrsDX1MapdQ3L2COszxgq9u6xyiMpg4T0G P5VxWh6bfWt9Mtvql9NAtuZbr7Qi/vCxG5C3oCOnvVxXvMd2jsor2z0S3vbhtUEmpuUK6VdQnykh PAkRs9zxj0rDnvZ9YnhvdSw0EMoMcJOEUKMDyx7U5L3Wawd1qf/V/kbtrzSrO3kv7l3ia0i/0OSF FV/MyCgbvjqSeoxXO3Bn1dZp7eK6U3DtbXGpudqkupOFPXI56V45nFa3bKmnF9GR7OWD7QPsQtYD O5bYAABn8BXVWdtCNNtkVHa5gjMiEsd6sM8D2AoNYrUqvLIUZrmDGfmYjnZiqV1HqF20H9nRZa4k WJZOqSEEcY+nFBuSNZ3e++W4tYotQs4XjhWTizujsIG1+m5evHcfhVnS7OFhb2kggglkh83UGRWk Ejn+L29PwrOUr6ItJJXZ/9b+R07La0awLKkRzGziMeZgknOcZ71UmhbT0i/s+cSh2XzIJHKoCBz0 7818+d/Mu5YXxFfgppUs01tdWuZre3cHy7VmI3Oj49QOKx9f0W7k+x3WoytJDelne5Zd8hwcNkZ7 +pqJStohmhHLHY28VtaTiK0txsjSJRswep+vvUzNJaXJMcfmQ3FozSFnwqkqQDj1Gc/WocrqxKlH ZGboV3qLR3FrcC4YRxpI8s8WyGdmLHEZ9V7+xHJrZuJnj2y2y+XPIvljvkemKqn1MpNbn//X/kss bua5W3i1Owgvbe23PHazptjLejkckE89eMVlNbausswikj0qzvEz9ltbgtCnJBA78cgZ7V8+XPct 2dhewieGzEE0v2UyuHUGSTZz8mSOevA5PNXobmb+xP7SvtPW3REKG3lfyp0bdgN5R+bn+tBhU6FK ykUXdpqKzLCkL+ZIkpzFKB0BBq/dXzQWly93ZK9ijtKMY82RXx/D/hQRZ2uW7a9+zSLJpcsltFAV MVyU2uVPVSPplfxqrLFO3mTXN3eXSEMYZboYVAWJwCAPXgVlN6mkpNH/0P5HhcvazRtawLLcZGHd SsagnBJbH149q6XxBbXNjJYzKsFtfaigjJgkVjNGVOMlSeOv618uRGV9Gc3rtjrmnQ2ijfJ5cwnu ktyJlEeM9Rnnpge9SxLJeyzwR3Utg6W0dx9geMJK5Yja+1hnoT7YNK5qpNKxc020m0TV7C8ivri2 bT7kao6tllkLZwWz97nPy/pxXXeLtBsdWghv7G3t45b66F/cS6WgjjuCeqMv1xx7/SnsLpY51dJi sIZpLcNCImxfCMfvW2jocenIrMj1Ka71GGwtFSKHy2miaYARDGMmTuScjj8KuMuXQS0P/9H+UjTY 75tSzJFZyQx27BYY2CpGdpydvTryKjbSb2aySA3My6eL03SxpIPJmkLZzIMYr53mV7FzetjQvLWR QIZpYxalArIoDZA4x9KS61AaXbPOiIY1jx5Qwudo4xmqIFlluI5ILq/f7Xb6hpw+yPaSiSOLA+QM o79iOvFcRJcWjSyXCfareS1Up9n2+WrSZHQcE8dO3NFgNiO7a4uiz24tUEeGTZublccgnnPrV61e U2UNok0lyII5YT5pVYogMtuOfr29fxoA/9L+UHSrazmtzbi4lhGWMkkABzycgdq0dI00T39xa2ep LLLGnmRtqrpBbow+6ucYxxzmvnyE46kdhDJEuute+V9tlXzUisp/tUNuU4OCOoODXKmdI/Kubm2S a0kYjBODlSMlgOn/AOuplFDja2hr3Gvx30S29lpaW9nLB5UimZi6sMdiDkHnnPaqWn6beWV48q3c ywK3m2qpxIr45Uj0OOtZNWKbstTWjQtHaXk+kwvIJHi86CPbMD/FuI5OM4rVutRaHS7nTvNeITBW a0j4WYAnBb6Vz296xS1gf//T/kug0VNRtJEvY4VgilWSGKQ7WyDlWVfUGtfQW82+ufCs8qS6ZPbs t3c3K7YkV+QqEclsqeB6V8pNtaI5VFJ3Mmzt1027Wwt8vDZO0UMwGzz1XjJ/AdD6VsXF1pauIoRC 93OwkkdOCMj5s+/T8qFpAyjG7sUtTguW0+RbW5Lq1wBHbGby1/22YjJHHT8Kg0AJJBPZ3yRP9lDx g23zbGIOzcfrgmsjblV7mtElnFG0YDS3JTeQi71UL+FMQQ35srqTURp9skhM8kvA28jA/HtQNK2i P//U/kdu31JNWurOK5kt5WK7LmPB+2xdQCemCO3UV0VnFcw2bW2oWEEMUd550PkuJWmfHEhOPX69 K+PFFNKzG6dBeXMskU5eSWF963Tn93GhOPmPbGRWzpyWv27xBpepSvd6e8YSymtgNpZT1bnocHoe 9K9pcoyFZrfTbdpPKKwJP5flurFnGcZOO3vTvKtdRiF5HbRRShXitbrO5og/B2+mcCmS5JOzJLOG 1tLZbSdBFKq4JI5bOMsT7nn8aJrqS3guLO0nYW9yFW5QdJtpzg/iKAcrXP/V/lbkupLZVutMhxLI qW+6ZmZdy9cHt3PHSsHVrFjKES2Em8me5bO7ypG5ZfXk18eYczTuVYltNNjjklt4o5mP7sIoEqnp nHH+TVoQW1lb3F4Lnd5vzgzYPlljyFPp9aDVysrlm6ury+t7aytkijs4zk3SDM0e77zHP4DituUm 1hSeQCSOI7UYjhBz/n8aCY6zZlm6k1HJsctHbPmR9uEbPAx+XUelNj1AXzy2TIYzC/lybk2yBh6n 0PaghrWx/9b+VaONg/lRRLcS3AWDdkl4VB6qM4rWu0GnxwRu0f2mS5+zSBjgsApI5/DFfHkS0jY4 uBLmw8QT2epC4uEuz51rFGd9nawkAoOOQxJzyTmus8T6PFDHpenXa+a8aGaJWJCwseQP/Hs/jWsF pciMWyKGWRIrWO5KmeCIJHHEuEj2jkj9a0L03DaZHIJS90GMsJ8wOz/MflbuP8/WrK1jEzLmbX4L Uz2iQxXoZcMnMJGQXVkPBBAIx71sx3sdzDC8OnwWrdGitY/JijIznC9snNBof//X/lslniV2MoAY NufC4ZjV/TZrW8eR1SC1jhYFhKCvnYABI9Sfyr5GTuwF1W0tJIxNDchvNQr5SfNx6g1z8EDtcRPB LvhCbDCcc44yT14qdgLmpQwWENvfJeC6keR/N09GCG324AGe+eeK0rW8iW1Kx2sVlJcLhbjd86s3 Jb0B5rnb6sCex0+7itHvbeS3e/tYSIZb0/6PK46EjuTwSB71Subm7stRsNS8RR20NtqcsMcn2SBp beVl4fHGAGxzuAAz2yKXMtgsf//Q/lXgZIk1GCPw/HeXVzqhGkXKzGBrdGPJbqCMevcd66xL7Trd YdM1S3c3Nu6wwqH+dyvGM+oIr4ccd0IZFe3n0+Nre3kWYS7HbFw5bgAnr2PFZca3M7PZlnURAeY6 n5VPYfrWkEjc3Q867YDLczXJQOV8nMIX7oCuOCeOR1/Co20h9WkTfApaE+YGmcRFdo5wSR27Vqt9 RptPQ0bZZRaT5XyINhQwqMoAv3f5CsWHTrS0gKwQtAA+7CEvG+7kk/ia0lG+rLk04o//0f5foWjL TLAWDRt+9+UrkkA8H/CnXV4t5Gto3mYGC52nyzjopbpnocV8ed7aSuXND1fUI2n0i4jMcTyYiuSc QyJn5Qx7YrXh1BYnaSBVkeOTyzIoOAR6UGUpXKlnLjWorhkgYMGEqTf6xgeMjHOAcVpa7BOscU+n 62dMeNirPDGGuAWGBsJGOOelRKKtdBzu1jFSGMz2ryXb6jBJhbqa5j8iWRujEqODn1469K2Lq2lj mCaRBbpYS/vp982HTaOi5HP59u9KCIeiP//S/maltDcBnscSXsBHyA4LH+7S3aa1NhLO6OnyIwaR l++rDrgY+o/GvipJpJDbb0Ze0C4nt5Xj1K3a8IJMtxNGUVvXBHBNSzX9tLFdXSCOOzCMYZmfDAgk dCPatHsKprSaMjyriWyR0kkV1kDmQEbnHvWjZX5FqYrq3VwJt5ZF3TEDjr6d8f8A165qcXqOm0lq bqf2LPb3S3qTXJHz2UbRqVhYD5c8djWdYz6/FqCCSxto9MMBPmed5kxJBHK8Y/8ArU7WZ0J3jY// 0/50La6ls5po4oUhF1beU7AArKhzkD0pFvo0ZYVtVPlDyoVVf3Q/w/lXw50C+be3MqrchYDEwJjh G4yqPr64qne6lYQ3sS2llfeSW/eXMkXzwscYDD0JHGKDXm2RqWq3FxcXDb4jEUVoGIZWzj5gSff6 dOtQ2Y1Ni8uoZmkWUhW27SyjgH/64ot0Cew9lknbzTEkiF/LAlTdGGI4/EdavSWkl1eS2K2cKhYE QgTjMjjAPHuR29awas7AmoxVz//U/nYX7TDLJNFAzTwxiERM21QAec/TmtESWt5bXCyorbHVmiXA KvkEEj3r89a9656DVmy4JrFLQ3jRi3MRCiFugJ7Lnr9a2bdI7q1S92iyKEBoVjAMi4+8T7/nWJpU 6GZc311fXRRY0trZIxALhGJeQLz8wx/XtUqJYFmuNWSR49OgM8LW2BtOMK78dM8UEbbEC3IlKsCz QL84RT8v1605li1JUgto2eFGP2gsCDHg9SPTpzQVzyP/1fwSWSe6sBZj93JbymSJlUNInQAn2+Xo fWo7y8CiyMyxXGpxybJLqWMbNgA2kehBH0r8yprU9dO6uWm1G41A2TXIgle23gTxjZwTwPf/APXW je3MUFncFZ4FvWhXyYs75hu53bR7Dv61qJSujN0GS5uLOfVFRFa1H+kZAjCEHbnaeucZ4ogs9QlN /qUs1v8AZ5iJI7coE2DOPkPf1xQNNMzmNzb3SCIrscjcQNxI9j+VbNuS0peLT1nuQvO4lBKvv9KB n//W/BTULy8uBY21uiJNFPskVm2xIh/wx+tadpaTQ35F5z+6OCrApIxHU/TH61+d+z7HsFjVEvFt YItOitSYpy8jSZSRg2BgY5wMZ6d6u2uWtpGviyuyBFSMbgT05PHHXmsnFMDNv47l0tLOzujCC6xG Q8tj8ePzrTEl7os39lTtMsEkoeSQt+7aQjAc/nj05rJwaVzaLujSnisSrWAeOSSIM7SJ91y38Qbv wBx+nNZMX9l2ySWgiKIYypkjb94z9mYn/wCtxQotlH//1/w7fVJU05dL8uOaN7jzYrkIWnjAHzKW 6BT6etNjsri7Ma20PmxyjYU2Zzj1P51+YNNbn0EZK90TppMckDyyoLbGVYE4Hy+h9/60w6xPaLJG bYlHi8qNnHEeOjA568VLinoa86K1vfy3Fq8cjC4nU5aRk2sPwFbdpNDPpVxLIdnk4Mozy4XsR1qJ Q0uhqSZc0pLWaO4nUQRxOgEcDg7/AFJBPOelTTSQqlvcNbRLGvyxyAAl9vc+/NYOCexR/9D8Y5HW OYX9vIY5HBaVANvmFuuauJfm5CPcr5io2Iw3RMdxX4+fWR1gynr0ENkjXkO7zPlkEROdx4BPTpnm qt5q811aQMo8uCQBRtPysR1yaTinuVGPKjYtWuHtY2jy5EeNsY3HI/yaYpnlgjLl4LxJ9wQr1APA P1rPkZRqXF9PIqSBsv0dWHAxxj2pqRRXto2+OJZt+6KYriVSAQQPb/P11tbQzjGSZ//R/GqCyaRn hlmgiYZLPJMIx9ASamhltYlSORUkaOURh2cBAM4zur8ccL7H1bckzs7yOO2j+1Xzo1vbRqYYo8yS S8cL6Y9MGudfTDKkV9G3kxXAMnlj7yj3HX/9VKMO5BlWqWySNFJfSwo7fMFj8449vrV4bbMT3Adv LC7Y1kflgOnHrVuKejDY0ILiyvNNgdI0iubd3SWOQkNIG5Dr7D/Cscw2sUKQoWuJI2YqZeZOTn+u KnkQ3Jvc/9L8Wbme7a6iQoIDHzFs+YLjuRXR2KLqwa31aZmKRnyGtxtORjH0r8d5In1sGyRrZraG OJmBbzyCEXoOgJP5fkaeWMEc6i7Zi7AlSflX0GKmUUldG9PsPtp1tg6KiKLhg03ljgkdDUF5G0ty 0sV1K8LxgSxPgMSOcj/Pasmro6Iy6Fuw+wTQOUhWN8kSGVQsz4OPyroZk0x4LVCzykHEsith1BHA PoOvPvWBon1R/9P8rJIJhCsdsxJQ5DE7cAVe0t7+5vVnWVrmRAAIWRWQlOSeeOg78V+Fyh2P0Jyb Vmal3ObmOSWWMZBJkKDCoeT249a52xZm1BDasslm6tHcBRlt2RgZ71m10ZJ0euW9ubC6itB5M42F d/LLhlLZH0rI066t4otkq+aWXado5BoM3N7FmC3DJcXk8KxxREFQxAkmycKAO+efyqKZCbbi0Xy/ N2h3iyUJ7A/lQTzyP//U/LKOBrWU7nDKqbgD1DelbNxqc1hpUl7brHNO2IJbaF9smGwS2P7vAr8H Pu4uTZLDfR3VjAzQi3cruZkO4u3oe3txW1NY6i+kyXVhbwBSVN0LuUQqkS/M0i55Oegx61LtdIcZ SvZnKahHO8cRhB3JICqIu5Jc8cnsOc5qGCPV572W3W03wwQrK7KcBQTg/XHGfrWJvDcsyRQyuPPj B2rtbuGNYscNxM108EnltZMREJOERc4yPrn86DU//9X8uRavdrHLBcSW22EGaQsrec3Q4GOKLyW4 K2zfa3Mlkm1JgApI6jJFfgcIprU/SDb0vUpL/wAm3mSxt5YEZ/tskpjkkHUhieDnjGBniophK5+0 WkkMvzHcgI4I9R6U+RDWj0Hy3clzC8K2i2MEKDzJLdAI39z7/WobWyJt45oWeREO0MerepoUEty5 voPlVo7hHlTzcqAQDk/T9OlWpLICJZImWVZIxJIu7mAE8cflmqUUtjGXwn//1vy41GS9EaxWpmHl z+aEyQrnGAdvQ8VqWUN0umR3N+xieWRh5UmMhRwDx61+ANWdj9CU2ivbvbyvdomSLaHzZ5X4UKeO v5D8amQQyQ2hMUCQQQCO0eEdRz8z+5yfwApBzS7jJrOO6tmlIKncUaMjAmA4Bz6Vm29zNbX+n2Ag jewWMi7gfOZVGAFDdq0gnuZylZmg6W11qI8y1D2vmZS2+9DEB0B7kdvWr8ul213FIlwVinVv3EEf KBMnGT1HGOPrWhKk2rH/1/zNbyJXi0y5hNvhQiPBCfKIXoxI71n3tpqd1OnnXdxPBAoiV5+QFHAx 34xX4Off6qIsTPZXflgSXKzxYRiPlhYd+tXBYSNObi7ZCz/vGRk+SQAcA/Wgjn8iWLXNWnkFt5Ud okM5kDWibHmAztGepwKyLqMasbiW3jDTLy8r8t1A3H8T+tAKfcsRWk0NmkUWZJ1kUvKrfu2AI3KA R9eails55rgbwpkgmDfN8qAAdARWMlaTLbS3P//Q/Lp7fVJpUkuGmKW6ldsRMoiTPAGeg5/Wpb6y uJraK4haBXspVBdpDHcSK2QeOhxjpj0r+fz79SXc0FuJhbMgn+0SyoAEMe1QARzx3GfxqjNHdCR7 mGS4n/ciN7ZQGUY6EDGR6dapNuVyrtFqPSdYtVSeVvItrwCVoEkWQOBn7w7de9Z9xawz3MsDBrcA ZBiUhF9gea2EZ93PLZN/Z8TApc4jZyMFQT6/zqytwNRtktbhWRdNlLxzo2d+OoPqOKunuB//0fyk +2h7svCHM5xHCNgZD2Gc9O1Wms3ttPnkvDGkgnCTDeDnccAD6Y5r8PP0ArzXcNshLybLfbtOe2K2 bDWp7TTxALGHdeyGSG7b5pQmNu0DsD6471T+FAVbixtRugsvK811DzRMMbS3J4pYNNfSIpZLuE39 kLTZbxQy+S8LdAxyDkL6dPenDcCBb2F4uYkiiRv3QzuZuOSay3REmlcW6tDPgbiPvHsa1tbYD//S /K+2leAAiMEq2542OBIex/XFVvtk9veHNv5Xmp52IiZQvsT2r8XP0AZraPOlld3FvMIpJRBM8Yz5 acneD9cfTNUYY5XxZNeXIsgW2zN8ysP+eWT9Rx71cVrqZT+Iv6faXFleujRxfZ0jEisz4WVSP5+3 tVpfKLCOLT4LeWKdpJriEHfdKegbnHGD0HetbWIexjy6hbreuF2xSPmJSFyASCMfrVGRGVyJYyz4 3KAP3bD6+tBzyk92f//T/IW0gvLuMyrDsEbEFV+YjkgfnT49OubW9dry3S4s7iDCTSk7oHB5GB/X 1r8fPr07o0kcEC0fS0niA3wXYD+ardNoAOMcdwaaFu4sT2ls0qxI73kckBKQR/dyxPHJYDB9aTaS 1KTa2MexvYXeS0is5xlyskvknySOnWrDQQIxtnUeVGdyHOCpI7UxbC2rHTysZuReRTS5UOoXyVPY nHarl/Hp007PDGi3DRqrInK4AIBz/T3rObd7An2P/9T8ktEs7tL26D/Z57VbVgbeXAkQ92TuSBnj 2pLq3S+lltIlMVrhXM8bGN5sYyrY9PSvxi72PsW7u7FbTZo2SJ4n3hPMUlTkoQCG+hHP41Rj1W3t VuY3sHkS2OJR5e5wDxv2/jRJ3Y5t+yKdjc2eqalJFaxt5agACWExYbHIA/Cm3lnJayzPBG0k8b5S BfmV/wDZ/H+tbR2RwVZbI6izE5s4/tNnFBOVBa2Ry4zx04/P8afe3qx2SRCJXvVbaM8bFHRQew60 9i47an//1fydFzpyQbbVHlmjgSS5WciTbKw+YofTPQdqltTd2k0Fx5xMNx+7ORhVc9V9+or8ak7p H0sW2ybV1vrfUtQub9XnfCxLBAu4xbVA2gLx6dKbpGmRzNK+qWbWjTIJLKKRNrkZ5b+dQdS2Iry8 8i9SzgtZltZZPKncqWiGzoSfr6etO0+DTp9RSOa0aP8AfELJEm44xklR059TUz+EZtanYNdQXkNi Vg8lQX2MCzLuGAR35xxWPIl2J7Qm8ljNuOZDGGMoAxt+nbjtWcVd6mykm7H/1vy+a6hjhkOz/SJU xC+04RvX+dWIJZdUfyJg5ZIQmVGQuBt/pX4k4NbH3AXmnSQmKD7UjW0B86a22ZaTI+7nsf8ACs7T 5XubmUxvBa2012Y0jDHZb7cAb1PuT6nioA0pNGvbWeNrq0jMFwSI5hMCWYchl9uhz71thRbwxRyW se+GMudjAtI3OGY9OOPyoAlsJNQ1C8t4pNQaGYqW82PaAvHQk8+1EVw7XCRTu8ixuYp5vvMVz2rO a6kQTS1P/9f865NPgC3EsVrbSsVAjuWcrIoJzwAf8aoCJ4omO4qAcsRwOOf6V+CTdlY+5TsyW31i 1u/OtwcvENsqOMEjpn6Vqx2R023gjZURrq3aa0RVG3yhheMcDGQMda5pvoac1nYjzdppnmPbQmWD LHy227gW469cD0FO0abxBO8qXkVqLNo/LsxDhpHDHJLDGf1rnm+hd09joNK0a51OO/LaVutrKVBF qKMZJXZgSVKDoOOvuKoRWpurzZLDPFFbTGOVFOFmAypIz19fwrkk7u5rB3Vj/9D4Y/s+O0Z3hLTQ R/OIZPmf8TV+F3IWUKIwxyqn5W96/mGUrn6QRWqRvdmO58yVZlYgAA4IHQ8dKuWNzpd0rQeayXUW We1Zdk0QBIUsvUA4qQNARm4iW0Q4jEpdYx91mIGcDuSAKoLNp93CI7RjaTQy+RctdrtYOGxhVPY8 VE11AjfSLeSZ7iS5kaMIwjUphZD9M8Vbs7F3SGe7ijawiR4Ilmb94rf30UEdM554zj6VlYD/0fkC GPy/tEFpeSzywqJ7VXh2/ITjJweOlaGnPczXMHnSu8wkwzO2ZB6DPt2r+VJ7bH6Sm1sdQwmu4ti2 Ynt47gQ3bzMY1GckEeo4PStqR/3sYntXW1hAKqnzKq8dK557GtOTKc01tcNFNbuMLIVjzxjqMfpV yNzEzR3ca+VKPL81uFB45VumR/WsjpTuro6Cw0u6ja4mWVDbCNCnz5c9f0963IRcSKeY/KKgRBOg IHJ/lWcm09DaMr6M/9LkrmGG2KG5DLcOgeHycHdk4554qzb2umaPcQtHC7tcyfaZYJVEh+bknPoe fpmv5Bl8R+yU97AbazubiSWO1EZL5jVMkxD0BosbLyLzCQs3nsXkllHzqf59sYrGbd7Gh1d7arci 4ujAkMgt1iaWM+WAqKFH4n+dY9rfXJfZpLot3bxBJJriMCFA5IPqTxn0rCei0Mre/ZnQNA6xLp4S 3uwkwlaeJMCRiACR/hVW5t5bHUnuLLfBA9okVzbCP5XYcswz6+3pWE20jSyP/9PRm+w6gggt5AS8 f+lRMNu05AAFaMeiPFbLHHIICso3RkhmcDPb+tfxHOTTP2guTWMyQKfNMjqm3AGNo5+WootQvZJL KwMTTxglT8vMAA/qeMVDk0i4WvqdAiQW88cWCWnXLhl/1IGORROi3N8siB5I7YFLdZuAQf4imcA/ 41l7WRvBK9mSz2qk2tn9oiP2s7pW3bUtzzw57f8A16TEMDWpe1ClpTbuu4F1C5+bj14x9azdVrc3 irux/9T0hop7O2ksbazlinWQ3fnJuke5y4PlnP3Rg/kfStE2k0uoSatNCqXd1bmKWNVxFgnOcex6 V/CqqLsfv9tdy19s8PJE0dydSL2i+ZIttbPFFvJwB5oGME8fjTftj3EcV/Zq9lbtBh7aTJkibox8 zPPQ+nWk6i7DKU22MQXFuS0yg+dkbiuOQR7H056Vs6ZqdvPG0koa4lmj8sGRNoQ564PsP1pc0ew0 2i4tuEke6W4t8w/Mbfb5kygd9pBz07Vpx3ptj5lu6XzTwErIx/eRbhg5A6Hr+dNSimJts//V941e 1k1JbS8YW8Yt42tEuFKi6TcdxGOuOOvsKasE1olpDJf7YDKJzEsmTNsBGXUcA+9fwfKSuf0AXby5 thGtulrGbqbBF23XacbVU9B7/WqU1rd2MEa28tpPJdsFmWCZZHt265IP9KfmgLNxqcxu4CIEvWEy WTwRIG2qSFZuPTrV+fTo4Jmt5i93MU3WsgcGNQTnZjHUZxj19a1ja1iHKXYpG3AdX2ztcJA8cQJx FGwwQrdsZArHm1GS3ia81GOBTAyQ+W02EjDsI96njpnNOMEJy0sz/9b6As9WkhjR4nhvYnZo182I SwlecqasxYi86byY4lRhi3T5I09gvUV/DcIrc/dPtPQo3IuL2O/unsLO3aO3Uh4JDEJH3qownrjq fxrNgmubKIi6muXVEZQzHeYAQcLj0rWUGtSbvm2H2kFgmWuBbJLcIWS4RCJd38OVHUevpUL641xH dWggjtzGgiZYFEYnCY2yNjr3pWa3HPzMVZ7K7ZbK4CRSIpljWVyTc7fb/Iq83ltCkmVbMphewKNC JVxkbX/z0q1GTW5i1bdH/9f1W7j03UbURRRyrb2FuqWUUcm7ynEod0kZvvKcuMe4qbR7azSZoLjT 7cebA0s12C0bQIg3fez0HPFfxLHmjuftySfQoTX9hLEbMxBity0kbKpETAjapb1IA7+tZs723kmz NuVWRSIbvHywt3JHfvWsZT2TFyxvYrS2EbT287vBM1tEqNdohX7VgAAlSByOmcdBTri4uYYJrIQN Ja3zLuJBaQYOQU+p64rpvKMbpkqKcrGUtr9h1AJJak3MluUaRo+YlIGOfXpjuKrx2EUOoL/aZllh mDNHC7skl2djFMNkHjGcj+6a1pVJrW5pyx2sf//Q2rLSYkNx5149pYwh7xGeRmjR1HQDP3j0B61A 7xXipJKzQG6jCy3D6THcybO29XAP581/JtHGV4RVpbn7TOhCS2OdsrMxTXdssoa1un2zZtkbein5 R5Zyq+vHT1rL8QeBdFv4/tsmkKpYCD7TK/2gTsvOSrZGcenSutZjiY2fOzklhab6IxbvwtojPBMd E0prmFETcNPQRLHGBsG3GBjuQOeM1fnsdKltWmttD8MLcyY/04aBbSO5HHJ2/hXTHNqi1k7mbwUH ojgdd8C+AnsSt54E0vUL5p2K3tojWktuX/uCMr8oPbp68VTT4O+A451P/CIaROPKjmSSRJHkRgo3 IQGCtk9SRn3raOdWVznq4Doj/9H5Nh+AXgADUrNPDVjB9s1KXUPtMpaeVA5B2DPzKARjIOcYGaZq H7PHwoFvBPceFLHVLyK6Ev8AxMY0mHy8qEJG8DrznPvX8zxz5LSUT9L/ALNbejOK1D9mL4UXi3s1 j4Z/sRb2Tz50giDbJM/8s3OHUH1zn3rm9X/ZP+Gsko1CHw7ZGf7OILS9jvTOYhkEkwkZ3tjnkYzw SK6aee0m7NMHl01HQzpv2QPAV1a3M2n6JNpt/boEuZp380XikAFVhbAUk84HHrXL65+yd4PnurbT bO2McN1b28Xk+TFLLvwokPKthcg8YOBXfRzelN21/r5nLVwM1qzmZ/2K/C6zyzXBWBLm8/s+9uLi 03QWoiJKFIVJ3H7zZUDOPpXCzfsaeCbPVZ3W5nZ7pTHc+IG0aCGW42fLGiRrJuxgLyTxkZFehSx0 J/C9Tm+quL1R/9L8TNW/Yf026S1v7W70K4MFwC09+v2DUbiHYdqFQpOAe4Prz6chbfsReG31G3Ya VYxXEly727XKK9vabsbTGxG8HOevr3r8YWJ13Pt5UbRM6f8AY0urq/udPtp9Ps7e1zcXUpt0js5M naD0PBJA4BNcuv7CuuPq+j6JqWm6RFG9215FZSyCDSNSCrIQqsN2MgZwV3ZxwOK0WII9j5fgcfpv 7F0ltb3Rmuf7Pinnli0rQLa1a4iSQsWYJLhWAXk4ye4wMVq3f7GV5qbTT6dptzevaWieXvVLVLZ1 GWKnJJGeODkgD6VssToCo2TOC1H9lPxtdWG6bTbCO2km/swz7ZJoWYjcikMgXGByCSD0ptx+yp4w 05YNKuLK10/SL20S3v8AbY/vpFyNxiZGGzOMjIzxWqxPS5n7HyP/0/5WdS/ZM13S54ZtMhvr/TLq 8fTJL9beeRre2Ckssfyj9590YYg8/e4ri7/9mvV1vLlVGqnRLWLAtW010urwhsAPuBUfgx+tflSx B9f7E1tX/Z98Rp9nhtraW0RIUuYnVY3hJK/6piMsMjBOBx061FY/s/8AizULjyNN8ITv5ZSA3MKF ICzH77jBYBiD25x0FbRr+ZM6BSn+AGv2d/eQJp8ljcwXJa4k+wzN9jK/ekU7drdOx4rlZPgZ4su4 7m6Fle38sTsksl9bi1jnGfldTzx0wenNaxr3OV0FcrwfBTxHHLHb30ryWqREyRSWxSOz3dP1B56c 1ja38Ktc0ex+0TIbeCIF1ZLY7mUHG7b/AHT2IPrxXXRrEypI/9T+MmD4L+JtUuWkuhNaWSWqzWdz b2rXqzl0LKJAD8nIA6k8/hWZN4D1iOAJq1vJZyRJ58JaB4heqr7cQgjLnHUD/CvkYT7nrypHnuta W0F1JELN4WiTdiWBoZOeR8pAPOKxIXkS3LSW7K7Hb5zodyqO3sM/yro5mcc6RetZIrWaCaedlBO7 bEQ28c8ED/PSs+GFbJp7toyltdTsUd/mG4tn863pu7TMZwXLsen+HPtOp2/2gTFoYJVhkbPJG3gB foMV29jpuim0up0vL6DUo5xH5bptjjJP3/dT6is6+5xxjaZ//9X+ULQLY3el3s2oyNY30EL3ss6j Ml4yKF2gd92Bz2rwDV7VNTubee/W402xs7mWWO3kZC87uQoZz1H+77183SVoImehUmtINEa31HS7 qw1eSOdZDYRkuxOfnVlIwe4255NZ2ox6dr1x/a1ppo0ZEttt/ZlRCxfeRu254X/Gt4LW5R0nhLdB b2Wl2e2REvHmkM83loUfkg/QA4/CvSodJhu4riZWnhkllMNwsynaoXp5eeo7g9MmrelioNJmJqqR aVcuEC3NnFB5Ye4HlyEsvIz6+mKxbKGTzhPawvcpOgkuUPfPCxqAdx4HPvVDlK+iP//W/jgsVvnE 5mhgs7OK5ZIrZHyQM52hTyB65rb1CDU7lFudPsZbXTLaIC41GKMtb6bJgfMzHgljjC+pryE2thu7 ZxV419Pe3SaleyyrHGpt9XMgeS5JH3nU/dx37DPtWvYaXcfZre4vdQikV4vMS6jkDGUcjccHHatJ P3dDCT1sXNd0SbVNAjureNr2G2bzEnjK7ZcYAXd2bI4H6VmaVYR6jKIwZbO6sLdVuwluPLJ6hWyO QRjJHTNZEmhq0ljpM8bz28AudSQRwNFhYht9Md+CMH1PtXQW9zbR3ulw+RM0ZCDVHiIURBlySWOR 0wAeeTQB/9f+QnxCvh+OKRNKh1Fr4zrcwwm6AgiQ5Vsk4zjJ46VzI1O20A26rHKY7u7EUphPmDLd SU/Hn615LjZXOc7S61XR7Tw9qFkbVY7nzFu2EdvunuVKnjpkVzOk6lr+uStaw2KjTWMMNjYMv2OO NhhWfkHLHOST1PetIx5QNHT3vp7u7sJLZLa/t7h7CCX7SpadV64PAAPI/DrWPdxNYwyQ+TtUzFnE fzOCeoPPSqAml0u716GKCONS9jCJi5TcwiPG3f6Z6ZPBq6+kpb2n2STzZrq2VZo7VHHlRFiDyfoO cUnsyovlP//Q/kGu9P065tTGt1eOzFDcWptttujgZZFbJyP8az4NSttNv7K41NLmHw+t15dytm+6 6VxhQqQY5DD+InjHTivHMYt8xsavqWkNrUy6PazppRcNBNdr/pLKVB5B7g+9ZcF8l8kzWUl3xcmO SMoba8G04KqrDgEDr05605W5ny7G1+qNnUPtPl2y24d22ZCrzIF9ZAOh4p2nXSiK3NvbTWjWasjT FWiQMSSxGe/044rGbd7HQtS9qerRDT7GJfIeZbg7rrHzTMwG1X7dQfzrB8PJqMer63ZXzTWskUCX aCOLzbW6h42ASZwBnOevOKgD/9H+S2STTIzELp7mTVLhfkigQGzjVBlvm6luR2H41ynkJqN6HjvT b2QikcKsLRXbTKwCgZGMYDc8fjXz50HT2NiINKD6gP7TvHkY2t3MQhkbdlQzY5x8o/XHNRXEPiK5 urKDxDp11HZRr5N3JbASRRR7sFVkxtzg8EeorKasUm0mkVINOsH1e40xWkt7KCUy28sgK70H3SxP fpketb17p9vFp+o2dysxvZo4/wCz7+KZWRI/42z0B6ADmosLS5iWd9GoEErmSKFdsbuwYOc4IHvx U0NreX1wZbSAFEOy2MoO1pMZxx26VcGluS9j/9L+SjRrLVPMlttTni+1SuUB5hTcSSchumK0k02G e4uPtU/lR6fa73vChe2kbJAVfc8fmK+euthu/UqSyJPDD9ivCjJ8wPl7HBU+pHQ1MV07W9Kkh1VD JfRStKmorKTkDhVx04PJNLmWxLV1YyrGwspFSJ7rzbMBnacASNuHAwPwIqazFotk1pNLPfySystv bsMGFAQeT6c8emaOdbEyuoo6ZrS1tre3huJ2to9QZIocjgtz/LBrGfRdUlc2kmovcI8jiwt9uQcd x659KxM229z/0/5M4/DWvQm8u4xHJYaZZ/adUZ3CPEmQuQh68kDA59qzYJA832y3SQxQ2okWOUlm AJBHynkH0FfLmUE+Y3LS5CW73Ny5SEuJNmC25s5IYdu9W5ZLSWa21qOKFriRDZyS7gbhIk5A9dvI x/8AWqZNI1KmpXbXimzhtvNkUA+axKxRhxwQw4J9var8drrc2jWlla3UlobacNLG4Xy7gA84btx0 Yc8U009gKenWU0UepG9ebbIxZmjuNxmGAPwJ71R0iaw+1R28lk0bwyOj3UEZeQR8HByegxweM8Ux rRn/1P5QY9LluYdRvLON0eXMHmB9ocqMDP0HpSaabmx0OWx1W4WWYKZIrWNsZOeFz/7N9a+YW6Kk 7s2ba+0+4R4Z0+yXRtlkSFG8+FDgdWPTPNcjqWsRXGEtrf7TDb3As7lwhOxmcId3HA57+lbkNpbk E0mpafq0elSI1pp+nxK1p9ljFxLMMZOzHQZ4/DNdDdXEOsy6dJa2ls72kbS31y8ZimkJ4VmU9SCQ Mmh+RPOri6dayX08/wBrRozBJtgKt+6mQAYOMZ9QRTb6wVX3tHJbmNjI00ceYvulQWI47Dg+tBMp X0R//9X+T7TI/KSSVJPP3HcXVdu8dgFH+ea0LG5trRrudrYS3EpEIieLEbIc8Ng5GM/rXz5y8yC0 spLO1uhpzrZSSxnYsKBY0BO4qPY1Fb6VDPYXMV9ePb5hZzM0SncxHr2PpUyjfUqE+xQ0+C1hH7gp PLbrhY1YSKOcZf0JrdgVbeZp7qZF2IHEa4OR1xUuDHKTtqU31uW48xLa0kji3MbeZ0/dOeAQPXGB 7VNd3dlFFE8ys9w5ERCx7ynuT2H+NYcvvXNIS9w//9b+UG8C3BtLhLtkS0dmkt1UKsgZSAWPXjJ/ Knx3rpPZf2fYRNdC4z5hIUMRyGYkEcfT1618pUi1YwSbM/xHpl7Ya7aTtqMc+m31tmd1URpHcnlo 19euPwqSw0NHd7iRYhuk2RRiUKWJGASOD/SlyNKyJjDXQu3umNHHGyXMaeSx8+O3YTuwUcrnoDn0 9KvaLbwvpUl3JcJBPNJ5X2VIwkjlTgM59x+NRZ7GvJqMniL38ENh5liYLcC+AG9p1YHnkcA1QW2s fPAE8s8anmCRR5cZJwDj0470iox5dz//1/5U00nT5riyllvmsILS4a5v7hIhMGQKRjHX0Bx/9eum vdTs49HtbaCw/dXqfaLLUZYWWZ17Ng9M9Mexr48DkZp7trC90uCSWC1vFH2ueEBXOPugt1AzVjS7 C1gjt7NbxImkiYszZe4BQdxjv7etZydpXDYyri4vdQiC2+I1Dm3uPtkBjyqkjK8dTj8jVm2j2odP je4a3UhoiqgJE2ACAOuMiqk2loYyd2asuny28t39qgiuYLaCFo5fPGZmc/MNvfaAM4z1rNSLT5NR iHlvbK4OCke8fQDpxVDcrqx//9D+WUl47RLSclHgci3O0LM0rfdO3g84H5D2rjbaC71FQUuri11S 0vX/ALRkk4huPL4AZcdD/hXx5zm9qekWko0uS6ija5EDedPA7bXOehGePp7VE1lbSy3EMZcWAIaG GQbpCehHpx/Sgd3awDSIrea3mmncIVMQQcAA4wCM4PSrdyTFZyMSt0ueLVm4dR2/GgcPiHWunRLB 9s0S8u4UYo8MKxKkdvIuN8SdSVB9f0q5byXOsqI7qG3a8V5JZLqCERtOf9rHfj+dAN+9c//R/lIn nk3tJpCT3Etog+3W8sZtp7dicDbnqMY545OPrfn3atEElEquq+Y0UqGNwe5r48xlK5U0rS547y4m kmAdIQkaMMq4XGCT2Pauln02aaJdT1CQgyfuYpJJQ5DLzt6+9bQ+FApNaGQ80ayxN5hCn92wC8H3 PftWmAhjSF0UA3KtHLCDvcdcH2PfiqFd7GhcI93b3U1pLElvZSCCeN+J9xGcAYwcDB49axvtk1zc RWtqqJ5YBeVB5byfUdKT2ZrH4Uf/0v5Y7qGK1kMzvPczQnfIso/dH0GO/cUunXkg1qCUxxy+cpKW twMWSoRwPbGRjnvXx4GzN5McRaKzihSKUlFt/wDVrnqOvQUWtvCcsvlvLO2fMi4PT7oH40pLQaV7 mVcafpLX8cmpG5ZIlzawxFRE03RDJnnGfrSywmKSVy7LMjhhFJzBMMYyvb0z/wDWrnkrqxtyx7HS DS5DpUYkupJ5xcMxRABBGCMgDHtxk9cVQiM2rSWGh3kiQaZYM15eTbgWSPADBQfvEY4A5596hQaZ ha2h/9P+XGCG6kuUhsLSd0mmZLWa7g+zBlU4UkdjjnBrM13Q7XVGgW3vg+q2kguWSOVo3Cjglsce mBXw5cXbQvnTLHS5rW4lVLqbCyy3FywM6vxjbjovX6V0ctxD5lpJbWc3k6hMIpIoGAnUYG488+mD z19q2grIu+thPt9pbI9lYXEwaCUsi3jgzWpJ9fTgYq9asdrxTStO837zI52+vNUO+thEuRZmTyZJ Zre6PlTW8qAxxleMrxnnHeqkd3FNftboHJaAt5ajIOO3p/8AWrScraA+x//U/mIa0ubW5V4YWmjc 7JwWCmIf3j6kYx+NT4tZS8RQkDDFQmxlOepx64/SvjzoNCSyF3blIVyWIUtnBA78j2qcQ/Y5RBcR x2pVVWOEDaSAAMke+PxoAfd/ZlYXahGYJtwq4Ye2fqK5+4Mt7Gr4COv30Rt6oPY45oaXUDYtESWx WFoy6wqd7FcSkZOSTVCa8LRR2MIjgRH3xLGxFxIOMbh16545o8gP/9X+aW31FgkW6Nra7iUNIyIV 2EYzgiqDT3oeV2mkk3oX3lQHJJPzE9zXxsuhq4pR0NVdbNvZJGrmRp3XdAEMmGHQsAOD1596nezg uNOu4zFG7yp5kccn/LJzzmq2E4+5Ym0/TJ4IUgmLiP7OZZLhl3IoAzlsdM8D8aq2c9hDC88mBGpK vKeEUA9vyrOmYQb2ZrWdpFJcSRRuxtpo/M+0z4R0KjOAPfJ/IUF7pHgMKNLErN9qJGAIwDz+YH51 mdUdkf/W/nPtL20EjE6dNcLcQkWk+D5KMeh3D8+asXemywTWs000Vtp8jKbh2OZlBGTtXOcD1r4c 3uti6mrRy8LGktuvyxX0SDkLwAW9OnvVC8mmFoZrGO0laWYK8dy2zevILAgHkdqCk7O4kh1CG2Wz int5fMIfbvOyPI+YqQOo/L3q3BdTR28dqJmknhcGaWVeVTJyox7AjJoBu7JdR+wWksV7GxWI4CwG TCK3c7ay7t9PvL6G/iilhZUVZZDIWLsM/Njgf561jJWYj//X/nailmubm7s4L6SG3ULOLp4cJKf7 i+p69fzrSe1EFpI8swcNjzJVHlhh2B96/P5K0bnovc00tbW9s7e3lijCQcBdg59z6/j6VUub1VX7 N9reBoV2KFXKMpyOf1rLkdtAbbMhQIInspNRZbOXlJAwWaInsD/n8a6bVbuG4NpaRW/kWy2EdrNJ GwL3W3GS475PP4Cpaa3EWdOsIoSvzKYymQHIVcDtk1TuLqC3a5FhGirMNkixt8zYPQH0yKQH/9D8 A9O1EW8t/NbRSiSe1W2umkXeka+3bOT+tAks7vAyzvCA7Fxjd6g1+bJJbHo3srGlLMJjFBDHFHHA AIvLTy1GcZ571dhgsrF5zHFBNfMgkuJygkIyMBSxHQdMdqdug47MwNO3wSTg+Ztkc7lb7uzPGMVf urq4klgMLO1pb/L5C8JJnse/erUGaQVol+zhFwIt9uYiGPyg8+9Na98l3i8xlaJiVG3AYdOT/Smo WepR/9H8E9TlthEt1AWSSSICWYqEKOM8DnoPWr+mtK8dvLeXXnmGIktKAvJ4r8/PWlLlRpWzeY8u 6Q4PCHaAPwrRe3jFm5eZ3aPkkDc7Z6DA/nWc11Ep9zKnmja3iQJH5irsZkz85B6/Xtx6UtsZSv72 VrlIPmPntuYY7flWZaemhZj07ztQg1RpGW2hB8uBTxnGCWHcfyqbVItNktmQpE0kr7mZeuff8h+V AH//0vwsS9itpEjhiR8KEZSMA9vzreWXKBIJ3id1O5EO0rnjivzZpNWZ7UPiMx9Vm02KGwu43u7W OUNLdyDMr7iBj8CB1pZrmC4AKMZAucR+n0FR7PubCWNrFvWWItG8y4eOVdjY+hpJNqyM9s7PayN5 Tt5fzFzgYA9jnmiUEldBsWIbZrKEvJd+fIsjGQEBVRc/KBj8q0H1GNLB2mgV4oxvRQOPeuaaSZ0L U//T/GbS5rbVkgZokiaOMRlUOAw7NWzc29jBBM8ReW5t1VoiSI4FPVt2Rngen51+Tcq7H1KbSsZU hh1KZi9z9pcxhHjJBii28EAjr2qZbK0vHg0hLcv5DedEdp2s2DWUlbQ2WqCC5udLgnitLWBpFkLD zGKE+uamEyXeoWcsh2OrCRokO4NgY/HrUluVyhcavPNczqdPkgt1uTCuUIc4bBIHp7065uN1/ZJp 9yGSFCt7DImw/MBjbz2Pegk//9T8drmwsvsoaTFzO8m8qyBlQexNMabSLDSLqD+zYrya6iGfMO0w nIJK+/Ffj59XPc0YNXF1CmlCKIBWXdNLjLKBkAMfu47+vFMlnWbMUEpIA2sifMqgelCV9CBtzZad 9mtr3TriO4uJYciDOSHUlSH9MkVlXLJcRPHc7VuCNrxKxCxn1rVwVtAIbJDYo9stwbmaLAiJbzEk 6n7469qZJfTtFBdm3NpqCSFJYcboeDjdn39KhxaGt9T/1fxrkP2iGW5CCSdVGdvBHt9K1hGtlBBJ AkjM8e5mblV455/z0r8fPsEuiKH7+S4nmN2ZYpVCxxFQvlsM7v8AJ9KgWzjBcNdSTP5mHAIwh9BS aurG6XKrGvcwG2jV4kEj+XlVP07iqkNwlzuNwXt5raIvGLaMMzt2BB5x16Vha2hSdi41zamyQ/ZQ szggybSszDuCM/0rS0HTILlLu4WZY4kCKbbOJHBP3QPasXFo2Wx//9b8vtMNhLNdqZJXWJ/IkjlQ xgY64z9e2acwWycpYqTbg7QQcFV9K/Dz9AMs6jY2yS/M/wBndjFGjLt3vnkY/OrNlqH2LymGkF7a RcK6fuyhPGQoHNRNXFJ2RPd6PJFOJ7fV3X7QftDxOiyNgj7jL26AD6VDbXekaJFPDcx4kvbhPJuJ wdsJySfoD6mplFJaGBcv7iw1BgIbuKeGJkWZ7Vv3eFweOOvHNXjrVm90IlybZ5gyxysDgjpUAf/X /MnWbjT4LtL1FhlF3Ic28c+THt65A6d6ZHd2F0sFzHZRxvCXEi7y8Mw7Ar+B/Ovwc+6i7Mr6dcXE 9ttubKK08piYEi5G3JxngdvSqep3F/dqw+0zbti26rkvGEXgIF6YxStrctSWxpadfFIore4jEEUI VMwR7mYA9SM9fpTb2/gkvy+nNcxW6yYjaQbJTjjken+eamUbyRtB62M8zXEt5FaoyqlwxHms2MED P61dtLGNWvoL+Vo0aBjC0fJaTjG70HWqUUlY1P/Q/KyOz+x2LJENsSMcBD973p1nJbhHS6MmWXMY Pc/4V+EJNq5+kF10QxxwGCONZQVEyEmZjyVAGcYqrawzaREUdZJHkuCzEfcUHAHP4UgWhq3Wpxix Fv8AZ5VmLZKw/OZge7emPb3qa01qS3sIbOdMiKVjCIosAK5GA3fj1oKk7sp3dyl5JP8AZmZAD+7U n5l571JaRNYQyoQzvcru8wn5lY45/IUGM30P/9H8z/tqRpBHIFd4RtDlR5h+v69u9Z+oSoRCDOXk uZjCsGOE4yGz+BFfgzinufoBUjiuNMa6Z5I5ILmIRSwcOZFJz+XAq39rtxFCsMMlvbxx7CrD5ZD6 qe2OlHKuxXK7XJIbp5bSRYpk2xyARq2Sec549sVpH7EkzIlzFdhQAZIlICtgZHPpTJa6MW5XTbeV JYLi5EIiUztLGqBXx8wXB5Gen1rHubjOpqLV8x7AbhwMNIuPlGO2M/pTtbRiSS0R/9L8y7+5uZrc eTuVVIQSKBuH40631nMq21+rxKEVTNHCXVu3OOO3c1+GxSsfoBDfeY6GexkjCLwS/wApZc9qnV2v WBNx+8wsaW3GOB1z+AFR7vJYxkrSZYeGxhmMF0t2t1bxGV3gfbFHnhcnBB6jvTbdrQIBDKlq4Qq0 ijBf6/XpU6WJKUd0k93IlrM4t4vkdXTZubufb2q3v8uG93Msjwx5tBt3ebJkDBPpjP5VLSe4H//T /MdptY/s66uWu2sbhcI9uFyk0TdB/wDW96rfaRqFr5MA2zt8iEDcC3bI/KvwXkR9wOlv7fRW+yXV wY5mIDRhRI+QRuA4PB6VsRXMaOk4t1hN1hR5eWL4AGT9ff1qrGkOpbnnVLO68ssSsbIOoeMkfw/5 71xcT3Ngg8yRZUuZcBXbM+e1BoagtbeaRXuyxYKCrIcr9DT9QitFeH7JHHFA8eycK+SCOpx2zWsI 21A//9T8zbjTILeOJBbqjBRIXHWQEAg1nrcWV3FPpptwf3ytuZckFDkY/HH5V+Hn6AVNYs44mDpb tLGFA8lU8zd0GSP1NNhu1d0gNsx2IDHIFyEPTGaAvcoPNPHqsitasiLCrLeq2SSTyu36V0c+tb43 tVuoQyWIjVZ7fG8scFQcckZPPt17VcNyHNJ2MK3OnTiXDpJLbt5MpQEIrgAkDseo6Zq1PbRPAka5 JUh1PoRWpSknsf/V/KqO4EF1uvBJNO4CIwj/AHajp1HGeKvXq7UNxF9+QYJPJ6dBX4uffSlymPa3 Mkt1EkrMIh13dB9BVzWZIHeGExxxguJWlVBGCegPHHGKuL1SMZS7kN/MYoLe0nuZDkf6Mm3cy7vm zn0OM81NHqttBFtmLK6IFUkf6wjjk1qBlfaYrq/mlu4rePy4h5ccUQiD4H3iB3/nVjTh/aBuEkGT GSY41ORH/nFBz1UktD//1vyWgjnsrj7bDeusaN+8ssKYJccc8Z/DNZd5qmpz6n5EXFmpVmB5Vsjn 6EdK/Hz6m7RsyXEiy2z6XqEts1ofM8jr9n/3T9eay5dR1ZkujC817IzeZcIZNn2k5/iPTjNJrVGk NVqa1ssMM+6J2SJkXz1P3Cw5II+tV9a+wXssdvHbwLKZ45hOpOQyMCBjOMHGD9fSmQ5NmikUAZo5 7eIbfmUqAV+gFYsliLtb2S0eWG4iywKjA+XooFZzXUIb2P/X/IfQb3bm+1B7iAgOsaGPDO3IywPb 6VHf6jOFUWg2KzgybVyx5r8ahG+rPsLF+PVbtr6Gaa8m8ho1tpTGpZ/LwIwGA5wAOn51rypHZ3rr IIgs8YDyIoZnj6qabjeZpa8DOhktbG4kMER3Sty/ljJB96uPcWyPHcbCkyAlz3atDyZLRIltryO7 ieUHbsfAxjefoKY0MbOo8vzJXOTvHKVLdro6UrKx/9D8nJ4NIlt7y2+1z2NyiFvNgjBTOcncx6en 40QaZK9nLdF5J7a3tvt0AjjLrgYyWPQHHT6fSvxpL3Gz6ZWj7pPpWpRO+3EkRlXzvtEqnZkDgk9j x9amS9Mt15tzNvEZ8uBN24kVB0x2RrMYMyiGZpBPFsl8yLyymQCyD6HjPtWvY3FppyQxtCdzqYxK sRdgO4LdvxrBu7GR3ItAqy24WFBIz3TL96TPt61l3EE1/ALiwZpxYbn8pAG3e2PrVwfQD//R/LVo Z44dPknR3nu5zF5aDcluFCli7f8AAq6uxu7fT3nSJnXzotheGPezHsCPrX4rKVj7aMr7nNxzSSax dW8/mQn5WTehUEMOua1f7Mgs8wXMUaJOGaKQMGkZj/GVHTnHWsShdKtle4iW+na9hjlwvmPsRMcB Qewq1NYR6fdw2KzqZblZpS3miRFBIOwMCfX9fagG0ty1Jp0WnxwaliSeW2bcyo2wsO4PqDzxVRbt JdVmkuilhp+oII44UTeQx56n1/pWc3bQSknsf//S/OqCSW2jkhuihtIv3UUirtLr/CPc9Bmi4i8/ 7NDbyIscoKyI5AkXpg/T3/wr8Cn8R9wamlaDpNl9rg1KYQs8ZSS6MfnHg9Djt1/WptWR7FbOOMxv FLGJIZU/eHZnoPQnHQ81xylbUDSt7SeZ7FoPsb73G+C9mENuFIPLnI9uKmsdP8SQWGqXV9YQ6dfS 3slvbfY5Rc29rGvGY3HZvX09Oa55OyHHcjRdQs5YrTS9Su4UkMb3E1vLhXbGWBHfBJH4VY0djJNe Nc/axJaPtVZLYok5Pfceo9xmuWbsrHTF2Z//0/i60spribUL2a4RbXcuIg4Xb0BATr1yamudIjmu rRrJ5bmJoDJvX7sRA+bjPf8ApX8vn6PfYtQQ21tdQeWzee/yqP4s/wA63Lm2sYpb68GlWwuruNLW 5uDHi4Qp0YEYweD1zQZ87ucothfWs0T28UxiR90dyzksXyT/AFqtdRXGoLHfz2lvcxPqXkkB0LrI mH37OuQSDwOveg0Turm4NJ1K8eyuNNjvtQW1jaSWOKNfs64wzRkscHP4cmm2F7fwzGa6s7RJ/OeR rUxGW2tUYkKnPBwMD61Mo3FJ2Vj/1Pkcx3GnSTX7Ll7o/P5CfIkbnAH05PHatUWRsQJ4Jo5GulDS B+fLJxgLnoRX8r2P0JSaLVtFdSyLBLctFa3DBZCucKf75x6V2unX9m63YinWSGztwtnNKQou9uFO Qe/GcVyzXunRTepBZ2kN0XRo0xnzVO0EKc8EfnVu7Pk+RZtKtzHG3mS2+zfAgOOT7+1YnRFtOx0e lW83D2RaY+Wcw/6uBF/XtW/NAsFlHDBEsLeXsYRNuIJJJIH4/pWDvfU2P//V4yaWM2ztcBiYf4iM GtDT7VbmMXcbiZ8CIOzZcAdsfTFfx+fsEHazNWNobGaFyD5hbDr6e9XHubSHULtId8wgAfdIhjxn rj15yKwbuzoJm1G0ebyvIluY54Qv2YxkxFjjl/QA1XksLmyivILSKI3AO6WGIcY4OAaym+hP2zYs Ip1ghuI/P3eXlYnXZPu9MU1f7Ve7nTUCY1VQyCdds4J5wR+IrCe1ij//1tZvDPhy8nW5vFa0uA4k /tG0Pl3EbAYU+h7cGt63tEsDHBLem8+UJDdygJLIPVwOAeOcV/EM/iP2gvxLJLO1mTEkiHekhfBk GBgD39qfbIIbliys0jMQzlTye+TUmsLWJLia3E/kzP5VywDW/T95zyo98DOKkN3p1iFbF1JeXUwR g0X7pMA5wc+3UisZKzsaxaT1GXRs79/IdVh+zbZ541YpLc5GFDe3Q8elWWd7gQCOGNY4IfKyAd7A HOSc9f8A61ZuKZsf/9f2h3up7MXJijt2X9wm1iry7QBg/h/OqEF5cPMqRv5kMeY5w/Pln0H41/Cn Ij96Une7N8pYW7wi5gkcPGLiWRSpto14IBHUnocVdVbC4s2njuol2SBPsjJsaRTn5lHTFRJWdjYo XGmwW0SXKTRNAs/kzKBtjIc4j2/yzwKs6lZW90kMtpEtvJDhFghOHuST19zUjVupB/ZS6TfPf3cz RTQ2RkaC5nDH5hjGwd8nODUdj5qqscRRNzl/OcYLbuSD7dfzosO0bH//0PoUWkEvmPNd2trGGyd4 kaQYHJAVT9PwpZYkt445UHnKqbY3ZMll+h/yK/gmSsz+h+VFKUQhVFwhEjKJIBGymNBn+IdR06U2 3tRLMJvNZVAOE/hzjFOMWmZSVnYvWsun6fcb1gnWaQ5eSM4ETY4f8f8APrT7rUrYLAjT4uJZmjhc dCQCdo9+D+VakNpbh9qsI7eOzF5tubi6DXSTtmYZB2uo6leCDj0rEbTX1K4sba6jgltZ9TijuYgn nAxpIGBIPTov607tbESn0R//0fo7+xrIas9pFcvbxNeYgjskVkHzH1zjt/OsdLmf+yJb8QRzXXnK TC8oS6u0eQRrKw/2Rgniv4ThJn7tzLYtWFysm23uXCDaPNZV3FD3YD86opZTStdTXN01womyHK7D jqNw7E/1FauT2Epq9i1p1pa3Hnz3WVtzAyQLt2OW/mKgmt9NFrFNb3GzzD9nELRMkjknG3nk8A/r TU5IprSzKLaLZPJBNA4a6OYJFdBvQdlVu3NV9Tt51WG3nKGORWjAfiQhMYH05/StI1WlZmB//9L1 Ar9njBeFYlUD95ExZKUySTWZZGxby5jFyG+XA+8P8RX8Rqo0fuCV9jnYYzci4itonkmhYSKxJjVw Dyo/StzUHtLW1hW4kASQ5WNEZtpPBUtjg/X9a0hUVx8juY0fkzlbeOF7iBXAMYPM3P3fr2ouZdQu TLbm2vrdYQYoJVKM1svOEI5PAz2711KaaWglC0tNyNk+yxIyl3AQF2lXLg96d4ZeO41O4uL+W6eK CHbbmUbljJyMRqRjpnrVKaWli1B9T//T2NStzNqt4CkiWkUwkhRSF3KvIYqOB0zj2ohvJYTdQzhP s8kQ8mUEFmB6g/lX8dwqR0P3Nwa2MKS6itUuJYiXdBnCckj2qWC5M62UUjKi3SNPGtyfKyF+9wf4 h6Vt7WLMfZu7Ibi5hsJIjFLumucpHsTdtGDnPoMetYespMtnbK0Sx2wRngijQBDlyWbA75/kKmVR N7i5ZK1iC3VFsYrplkVQ2VDIRvx25q/JevaWTyS2++S5IkhJTY0SHjA/XrnpTTi1ozGomtGf/9Ti maS9ifyQgvGISNmAUdeatXlnNZpCl1DG0+3fGDjP5+hr+PlufskN7GPq8k5NrI+6EDAuYgA6SADG G44AqhaxWLfab2QHy9wNvDEAIkcH7wHXpmqinsjTpYsXs9paRRujTzXFyxbDJ8qnHI/rz6msm3kM qT3lsscEkcptZbmSPMsJIzsQ+/H5V20lLuYTinIc97B89uYlkaYbCz/MWYjk/XrWAuj6SL6S01mw mjeNt1vdfZfMngcjPAbA2kdc4rvpTnB3i7HO6SbtY//V+eNYstNQrEo8+CNRHGk0Qjzg5AwCR+va qK21tqEkM924juLMqtqioqBQoIA/Cv5tp4madnI/UalGDjoitPoome51O3t4GgQiF41IEanBAwuc 5ySeO9YFpFd6DFcajrgMt0so/sS4VwWhKsMbweBwcV2rF2Zz+xRsm7kk05rSTTLa7aS6N3FMyL9o geRQrsrd+O36Vgww6SZAq+fFNbgk3EZDLGSCMY4xkn1rZYtW3I9nboVxHpV1pZ0u4sHknhuPPtHa XbDGehbYODkVnX2lJJb2UbslvcpOUikMe2QoRyN3UgY6dq3WK8zN09T/1vg8aNpllrH2WF47kW0Y vHib97DKQOd46dQeKx9R0LS9cu2sY41trG7dftFt5hNvFtbJKqeBznp0/AV+GRxHmfofsifU9C0m y1C9t7Gwt4bSBY1tBZMDFLsQDJ4yCSMk5zk0PAl4l091bWttFcbJr2C1iWzhkKLtDvtAywH8R5zX RHEK2pMqVzEk0HS4jMdThMdq1q0BWKZladXB2liTweR+QrmrPRtJadorS1t5xbL5f2S+3NG654OM 84rWOIZy+ydyKLQ/A1r4mWTxPp8F40loRaRTWmdFeVlIXziMHEfZB1JHpXK3/gWwvfOmS3SVmbZa QDE0CDP3QjZG3pgeld+Hr66GM6R//9f8ev8AhXuhXWnHzrSFZYJnM1laadHbibj+MqB3GBwcZOK4 Hxf4A8IP4c8P2Fr4bs7LWtPupZpL+C03SiEY8sox+46+3ZR71+f0qx9JOFuh8B/GPwnpb3c8ssl3 car9pZ5XvoP38ysBIsm7O7OCPl5BDDHSvkrWrOSS8iWCb5d2J4ZDt80DAH4cdK7Y1EcFWNmYz+Hr YRysBLE0QaYxRt5u88kADOefxrNm8yOFY2Q/Ou5UcYP5V20pX0OeorwPRPh5aSR6dPDDEFV5gSjy fvWck4IBPQ7scelerT6IlnJpmrQyF5grrPA6hrSfttK98Aj86dR2scKj76Z//9D+V77H/ZymO9a4 juPJ3xNJFhpcjIJHGAa8G8dzag8E91HpcSrfoVs5WZfKk8ohWbav3Tkd/rXzsXaNmVWj71vM4/Rh oax21xb6fJa6tfAW0iXM+2yDg4MpbOFJPrgVgeMrNba4d3vLYSswikNpIHilUcnaQcEZ7itqfYVt Lm34Ysp3R9XFyEjsow20NvkkAIOAvoRz+FfQGh3EN8mnXc95BBFqEPmhpSIooVBIJYdjlSAKcmr2 Ihsc94isYNSurTUI9SgmhtHaRo0+e3l2gquexx6dsVxms2Uc9p9vttUmgjVvMmTTJds67TwTgYwS eg9Ksb0R/9H+PLRdDN/cWj6fdX9zM6CW4S5AlkmPVhgg9fwNVdc1eBSdBu9Zv9KsXnjuJ7S1Vmt7 5gdqApnDYPvxXjicuVXRSnjUQqkFjhrYuYp5iVivkK8qw59/zq9a21ikWnQPYRLb2kWyO15+zoTn gAemePpWsU+WzMd2bup2cmo6fpOmQxDT9Osbv7b5ds5tnlIOSGC/eBIHX0ps9sDPttr+XTQYdtxs UvuQcnd35xUKNzVxTVjkbu1spPLLXtxqFx5rM8ckHlw26g/LtPX/APVTre8lgvodNsLbUG8qAXd/ OUaSwdQ3yoWx15/CqUHfUXIkf//S/jruY7bVfEFvdPNJFZWVr5cltDFiK4Lgbgx68EHHPesSK1ih 1aS1+zNFFFL5lm7PuE6HnOO2On4V59uhLgrHXrefPcRpZLdTyQYeeWMtsA6fNVbTNfuI5UtMrZ6j bsLiLyyXjRQwwVJ79sUGNraDvFYupopLuGMC6uC0jSMBG/mHkEdMgmsHTY7+JtNhuTcl/LD6vM5G 9wwwYlz3Hv6UAadvqepaXq15pljLKvh6WVbxy0YSWYA8ozc4x1AyQK2ZdZhRbi4tLaDZMgWGSV8y Nz2pPZgf/9P+PCyuNWu5RGbmSC1F0t1LsGBwCMBT7Vr+dY3V15bNuEr+W0jJlyAeW29j/hXjmCdn c1JNJKxy3bxfarVf3FhOJcgMME7gPQdveszzbK3kl1Am3t7kRJbMq5Mr44yR6+poNIyu7Gq5Ro5J rRSJHCxMxGJWHc7vTk9elV18m2nex1Gea5to7oG0a1iaaIsR8xfBwMfl71lPc6YO6I7+8s9HiSV9 OmktJpH2mSLZE2PvMT0yM9K1b7xBpE2nWVvpcNwl7dW+GumQgIowSuMdORwcHioKP//U/kduYXjS 21JoZGaBVJ2RncwOBwPy/Ksy9uc6hFLBM7GCJVubNofkiJO7cG98/wA6+fOg2X1hrhYJnt1xZjzI IC2FZh0yO2f61aN3qDRrqh+0B0DRzaQLgtaNnBz15I7Gk0noxpXMp57bWyXjtrmymU+UTMCQ57kc DI+ldPqo0ptBg0mOO5S+srlJZbhkeFJEIA8sE9QcZI96maVtAS1OfmsrCG0+yxxQy3cyfu7Vz5cK bsbSrrk7ud2Mdu9N02x1uy0N7SHVDp1ySSuoJKuyFg2WZAxJJA45HpxWQpaXP//V/j/ifXr3Xbc6 lrUl99kgd7iSaVRLqG4DDtgZLDHA46muggttfksJ5pdRgj0m5uwW00RsJWSPIDZ9eTwfwr5hu7v1 C7buy3/Zk97Bc3KXFraWlu6wC2eYJqLKRkOU64NUb7dptzDNpclrcQ2o3XNs/wC/hvARjbj6nn6U gF0/Th5K3FtDAq3CtO6WzEujliCGGODwevt61lGzj0vU5tTgi1Ez3UarcRoC/wD4524HtxRfoRNa GxrUN5Ne2UdzK9vZmATWmfmZZSpbk9gQP/rVrQyXflQPFdMJbdflmH7skDHzA+vHaolKzsgcfdt1 P//W/lElubm5AggnWVbyPybtZCwVuRjJ6HkA/Wqcen2kd1lZhbsrBbs5MiKR1OOv4Y/CvkudiSsr DRexx3o027tJWt5XLPLbxeYyJtB3SKcAEngc88VXsLO71O+j/s5S9qkrW1xEIiZGx0wnqBnNS23u M6xobC2tJ/slzJcNbTFLj7REtt5AAHyKAenX/GqWn6oFtrxxMJUVQYfn3CMk44x1HrRHcDK0yWS2 W/ljQ3cFxKWmSdTtVmIJEfp+FFpBO11dTfbbqxWeLEMFtCrK4HVXJ5GfxrcD/9f+U57m0jslWMtb SBHSeVGPmBj3I6cVkxabczW9xGsqXV/cqoju7sbUiUHPAHTOK+XAvTaSIoUZrmOO7aMNdSWyiQyA DA61krLpG+PSbm5utPhNz9uuJbeyLy32BgebgYIGPXI55rSCZMk2tDbGqC1v2u4HtrrTTZKkUX2B Zbt3U9yclRjHA9Oal1LUktiLq70e8jubuNMXNpCItPjjY4BdMZz7g9+9XJaWMmmtyxoM32mSXyXW VvuoHAVVJ6Amn6jJeW0V6Ht45ysPly2kkpjDBuu4/Q5xjtTE1pY//9D+TWCBrNLZluLceem2K0gf zRaYwB0A4/w6VsW1/BY6fb3WoRGPfcm3nQIzvNIOjBeuMH8q8BK5yKCSszM1bW4nvw1vcXrWyQAN Zw2XA3fxE4z+GfwqtrF5L5axr/pNtGyzeXIgyxAHGPY80ilFRLmganbQ+cbWwihMiMjTyxCQTFup wcjIzgfSn2cd2I9Sl1VUuBPKUtVRfkhjAG3gdzg8c0DcbolsJ7q7VPMsRbIB5MEaMSrgcZ56E8Vp LZ2t0lxCsE0d6kojkZVDeYoGfrx/jWDVnY1grRsf/9H+VaZNLhiljuAgRsI0gALM3YZrLh1CO3nK QWivMkb+QChdQAMFvqAc4r5eo/hQlDl1KiR6lrGni0lkS6tYrlpYpjGBJEzt8qqR3GMfhVy6W3ij ja/tfJFjGYVeMuZZ2AOSw7H1xxxQTBaXLkMcdqba+8JaZFNYPpO3WtN1GYwTTzHJZ4c8jccY6Hir tvEqaMLq+ghtJrsf6LbRzCUl92SGJAyRz070uW7uaNWK8d/J9rlnT5LmS2SxnwMqUTGARU40h5HN xYwQNqFw4MFvPcC3trogfMJJD93oAPrQ4q92I//S/lX0qK+vL3V9N1G3t4nkAt4BZyjYHb7yhjxg dMjr9Kg1e9uI7w6PdXRleCyQQQ+aWigjQkFEfoOSTgH1xXyTg76AVpbe1kinuVmZRBEu6KKUzuSB kEqOxNSaVdW+pXENkLYwXhXbHcAkT3GTnv0xwMD9ah3M5S0sWd13KWiuXi8qLKW4TO9ectu7dcmu Zh1A6LrDxXlxLO00fmQRwRGSNj6OQMcA4HuDUtNqxhKVtEbNx4rN3KI7nT47e3ACKEYs6YP3jnua t39zctA32RkjdIllhl8oSKRnp9SBj2zVFXSVz//T/k6Meo3039oTSNPOmJ/JL4lhPTAJ/SrF3Y6p JeaQLLxBNpF5qN09tLMloHLKV3EGQgjpk856V8ecfOXZ9IvtOgH2u9e9KyBJrpwMsTwGYgAdcdhU pZ9PjYuu+Y8KCPlVT3+tBUXdGALqa9uRC0sk1vG/yyL99j7D2rW22VqrC+dlh80BLh8q+TwOM89a CjV2XS6BexWF2JXs3kmt2DAMd7ZxGP4iOOPanaHdwraW8zSmGPOZnC4cc/OcfXNWo3jcD//U/lsW 4gt9XuDp1/cXCXyiJEjhUeWg7uw55460tzaXr3xeK5iaRVG15chZAOW/TOK+POcyAt5cXbREyRIF bdJAwUKV/h59as6fo7Xsd7NPeTstuymKKcb0Zumfy6VrT2AjsNEv5b5oWeK6jK/uVT5ZUwCTuHfg dvSprbVlgS9ZPIms7XMMs0pxNE4OFCj6g5P0qwNjw3qlrr9hGoEyXNqpkvpCNkE5JIAHGOmOM1W1 GS9s8Pp0FmUWfEy3LbDtweVx34FJ7M1i0o6n/9X+VfeupyiwnlvbWKdts11a2/nTQ45JUHg9O5HW taKyZFktrRp5Uc7be6niEd0y9iV/h9do6V8eG49/tyJ9gLssSv5hTaCGOMZ6d6qtFqtpHDb2sSJG sbyRTM4E7N9MdBg9/wAKAUktEUGsPEF2Yvts9nFJKRM03lEYwVKLs6ZOOTXVXlneXlpa2tybUakZ DzaruEgP8IA74HbPWs5R6otTfUm+3DTNI/syxstQGozz7bt533QbVPyhTjgHv9K5y40m7kf5JPLn fJAh+dY889jyKmKuyXuf/9b+XqH7Tp8iPNeT3JRNn2OTHl567gcZ5oa2gxcajaQiGUqTIkefmAyc c88c/rXxvJE05bWZe0/T7DVpNNugY0uvLZg0Lb5jGfvKynqO4FGqJE2qx3enh1tbNF8hyTG4cZBG PwzVF2RnXMFvrk8l00Ty3MT5lhVQivt5yfX1rVS6SOCJrWRhOYioMQ+dgQVIUfSk9AtrcoWcgXVr G0nupI7RrV1zJES7SEqV3nHB+91x16cVqeRZW97eXOnTPK8A3GJD5s+/+Lp0zzgH0qZtrQZ//9f+ ZS1kku2aeQTxBT88ciGNvyNbUVvbpsZSu2UfNn7x+tfHXSdjoMq61STTNQMFsmYUAklLDCAH/Oa1 b3yJraXUJIg7xqJHldd0qDsF7/lUSlrZAUbRIb2PMe9I50BHmqUdTgdQelPg0W5sre+kk2SStLm2 SIkqY8Dr6N14FF/cAyb2KQEM1zcaekA8yWeNtvGDkMO4NS6bDNNFEtvF597cQvJbX3k8FUAbhugJ HOO/PFQnZ3KUU43P/9D+avSHmv7OK9voZIJ7lMPazRlJYccHcCM1JqUMKWawSMyo83yyodsideh9 OK+Iu73Oi3QisU0pLhFgkaZgoEjsAeeh/wAnmp9QtLoSvPZTBlGFKnKJIoOfzrfyHpy2Y06/DNay 6XG8sc17H9ib9yXJOQSBx6qD+FVP7NlaGG2E0VxDAR51nLDuklYY5PbHHSsYvlephytOxo6he397 bqsSzWItIcJFJB5aRgcYJ79PXNR2Op3LSxwEfwlJg6lDJ8v8PqOamxqlZWP/0f52LOFmtRYW5aGB B/qo/ljU+oHSsvVrSfT4omume6hlcRfuG8+RFPG516jB618Oa8nvXNC1sI9Pt7e0thJO9yCy4yIo gTkg/mKi1LSLl7WWNXCyxyLNGH+RVIIyvvnnj+lBZs38VnHZ/aIYJRLbW6ukoG1AwXDAgcnJ71i6 ReRLCtzepM93cSlZ4cZQL22t75NA2mtwklhf7eDZzGVD5tvbZ899oBIwPXjI6U3SbjTNRh+xzedZ yySK6STRmIHPBUZ79OOtZTTvcR//0v54XuJdKWTTzpcOpCK6U+U0vlPjgEhwf09q2dYVbfTtt7bo be4VXNvFIHbY+CMc54Br4Jr3Fc65NptIbLcQeY32MOsDRAxxMNxjAGOT/npWGIheLPG3zidtm/OH j/3SKhKysS5N6EzaJazxLbXHmsI1CySA5kkA9R/+qnPNKsAOnQvcSRuLdfP3RKmCFLHIyQOv4VE9 hqTWhvzTafNB9guNR8uExKbqe0i+0SxMBkoo4J544IzXO2wii+0SxsWiX5LZpU8qQhmxll5xnjIr IrnZ/9P+fSZHiWJFJJmOHK9R15qhdwzKTJE7KgGZAn3jivzmMeY7ou61N20AuobdWVot4++zeUVx nkn/AD1q9dLbizaRWuUTJXzlUksR6/571UYdWXexXjBWCOKKUtIU5lYYbB65qxbmS0GyZS6ldwkA yhrQE7bEgnbT7Z5ZGklEj+YDGwk27v5Y/SnS2ttcuUd5RMyB0CDKuT0BP60D55H/1PwVuPD1/cWt zZ36wGOJlUx+aX2pkMCPf6ZHI5ouDHZKLh4pJlMYiAYEqgHAxjt/hX5+elJ3ZdsruO/MI3JD5Zy6 g7VHUAn6VVl1drG/aCb5on+WOdQSjEn7o45qZfCyTbt4bG1vManCAJ4C1nK0hjETkZBA7+4PrWXJ dOqTRqNylyQwGCR2rE3jsibT5TdSJHdTTwRxqWHlEhWPoTVq6SySGyEIka7e4aNoXf5HXghye2Oa Bn//1fwuuLB5cmOJUIXIwe9UpmutOWLe++WQfJsbft+vp+Nfm57kEatvfGSw3yxplCUnkkX7wIHP P86WEKkLzxoinOyNSAOKV0tDQoyXVzODD8qPGSY22gFc479fwz61Npn22NZIrhUWzT54Jd2S7tks CPypSXusCtJfzTXEtnDbfuHcea5I5HcjvXVMILTT1QosqSLt55xmuWaLjLof/9b8TNNnitllIO1n jwoBwFP+c1oSX1w1oiJHFdxPKFuDHKC8A9cdSPXHqK/Jz6gbJp0AlhS3X7NgGeNrcbFLYxhwOOff +la8TXml+UzgswTKv0k71lKLTuaQb2Hpdx/vpmSOXzEMbiXIKE85HuKgtHsEll1GNg1zaLsTcQWX cRlV/Qn6VBoaFxfwzyQyzoseQFGB8v4VWT7HD9tjgh8yW5wWnnXDxAf3CDWkEtRPRH//1/xfgn1C Btsbh4ifLk81A25fQeh4p9/FN/ZtzNEERkdXaSXKhVyAcfn+lfkUo22PqCpaxXEsYgV1drgAxygc gdc1dtoDbOsX2lo5E5klPyeYRk4/H+tVBaXAlRYYpTJB5ke8+YQE2R7s8lfr1praNJ9qfU47mRIr tFS4t3Xcsm3jcD1HT9KslyS0NCM2EIhe3ZdtrIyy5X5dxAz+WagvZFnuLdoEZ4WcCQCM4JP60mrq xSfVH//Q/GS+hnsZVeNfLNyxEcSEnfxnB/Crmn6ozWs9nds0R270jYfcJ4/CvyT2aPsE+qKsKXGm iN0tfta3MzDDEqgznLEjp+dRWMARmkdfIH2guEhfOWz1b9Klwsrmqmup1cNz88byQxboiWWRVLNN 0wGBOOMenesp5RfXDyxBoZPOKyOU8rkHt7fSsJQ6opO+xsxx2cZ3z4mwMKSRuDEVfgklh2G3iaOT zN5dRgfj+VZtaWNIztoz/9H8qftgla5eSYtNO3yIigJu6kk/nWTbX2oXN7FpqJMI1l3yun3htOdv 0PSvxFxa3PvedG9rWjvNBHfuI4oIGRxbxSCX5tpUsRyRnBP41JY+YtvvnujtDbLa3cFjjvg9sVDV yZS0sR3SvEPOQtK7PubnJB96NUnt7vSle+ijbCCJ1MfzsBnkcdcelTJNrQgbY2VktuEs7WC2jli3 7I18sKcfeI9TjvTra0tpTcRyRLM4TYFkB8vryQfXj9az5XewH//S/K2+06xtpdNEVutlAW8uWRFa RZTjnvx2P4Vfsns45fLblVQ4jPy5/GvwtQ7n3Bo3V3JBbQxyRwyJcMVtzHKrSxKD3A5GSeh9apTS WkGnzrcrcR3srxtp/ljPRv3gbnoVOfwpKDvqNb6Ga9y4h3lJGY9ESMszH/Iq5ZG2uFhBdluZG2qp GBk8AfWpkrOx0R0aK7fJeFCi74TmMsPwyK1Li3ae3LKrAt8s0ijJX0J/LH41ShdXNz//0/yxUPEI yZPPRAFSDO1SAa2EtW1W8afVlNvZpERp8Vkq74uMANkdMg8da/Doqysz9IF2x2kVqpje5e2vjMrO AEZSMbSRzjr+dUprqSZpkXDqCWGQPl9hWfI72QEEatDbtqNxcGPyhny3Q73Xnp6fSnwTC5uFK5Ec sXGVwB3zQoPqBFeW0FpNvgeVmZ12ttCoST8wNXribU5rC4FzDHYNp6+b9ptT9qkmQ4KgAjH6VLVn Yynuf//U/MC6fTby3tZLJrkyCFWnaVQrTEjqB0FF1Z2jSQSW7SzJDFG9ysgwyuRl1X2HTNfg5+gE F1Lp1xi9YNbOjiCKOJC73Azjae/GOtWJI3862Sdy1ojZWAnaecZOPXir5GbJrlubC21uIy/lYJH7 sBdgI9SKx47Jra6vLhAjxTR5itcbFDjrz/jmjkZEmnoi4jR3UKQrC0S8ExM/mjeOvP16VBd2k6XT fuY7eaaMDEYzHxxjNKzukyU7H//V/ODT0Nm0E9/arcW6oxEKzbDIwBAzxwM4Pviq8c0KxqkNqjQz yl5o515JJyf59K/DUrRsfoBMP7PmlnW6079z5Qjhit28uKMDgADn071mvpsMMsUttGXlJBjDdYay aa3IlG5Dq+i65b6mkVtLLd28tiGuZ43D22xgHZSQeNp7e1O07SIlso7qea2nWO6MLW/nFLqXbznb 2HOM57GizSuJQ7m1LZ2lws0sYFrF5JlVWJD8DIA9a5uwuwy3EMqyIkZKRuYSGkPbGe1IfIj/1vzL tZ5ZormGVfOUL5LiVdpAGMN/LpVvTtC1A3SLpiol23zRb5Fh2jH3lJNfg597yIw9R01rS+M15aQy zB9rzKod5SOzMPetezF7c3lveSGOJoBujtocCNdg+Vj78AmgpJLYqXN7eXs9xNdBZZBO0ihP3auc nBPvUFzZyzslwiR4UYbc4DZOeVFAyC3ujB5iXB3i25LonmbjnGMDr26U61a5uncx2jKbyXy4Y5E8 txzwcHp+NdAH/9f8xru6vLaz8yS7ilKgwfLiR4wvyhcHjj+hrGtxM1ql7azOt6udxEYXzePTtmvw 8/QDYF88yW8RQNcMF8yIclTgZU1WuN8cjJDD5UIl3MMYMXrn054/KgLCSj94iDBDjlsZzVbULW1d YxIz5DgM0Sb37CtILqc5FNYTieL7GIorAceZMBHLKexbsOOv86tiVVnWEkBF4Z0IdfwxWgbbH//Q /KWS8iju2imDgE/JuXbtzyD9OlXGBuE2XN08clrF5saW8W+GVGJx83r/AIV+NQinufbSlZGUo2Tf OTKEXcN+Mt7kU/V7OfU7aEkRxw7SNvmbS2OuRnNaWSMm77lAtdmdf7ScbIYlW3EafdRQAFHrjFPu 7C1vZrZopZJDFKspx8icdiO4pj5vd5S7NpER8uVLos/mbZo2XaI046H/AD0pYbNbK7kGnTCWOVvn uU4LcY6fpQRN+6f/0fygg0WC2kliVpJ552aQFjllLnOAB29qpyaZqKXCGOOMQRAi4LZ3qe1fj59Q Md4rdXaVfnfhGB+UHPOauaZJCu4iNYHYYkcDAkFBcZcqsLc21pqUyWKSmHafNZYmCFvdj25rIlsY 7VZY5mdYjmNbjPPvgj+lBm2luXLcCCxtxCWuZJpdi3DNuMSqD15+nX1qeG2NvIUF0Z7i7HnJaqoB gA+U5x6nnn1qZK+gRn71kf/S/J22trSW/jiutjZba6Slkijz1bI7jk49qNX0lU1A29ndK9ojEx3C w7TMOxIPT/61fjtuVWPq1N31K32OUWl2LWOIT+WYo5pDhQ3v7VONOuvJtpdUni8yOEEmOUOgwOOf 6HFJfFqa894aFIzFZA6fvkzjcoyq496lEYnXaZlDPzuYgZHoKpao81ar5lxIIoo4IF2wOsvm+Yn+ skPv27eneluWkaVWicKV+81TK2ptKTTsj//T/Jf+zZ5ZY2OyWMoTcNJgJJ7Y962YZb+aGa1tYRaW jwi38iBysVwE7EZx6H8a/GLvlsfQp2dyN9Pu7CwuvtETm2kjPluy8QPgfKpH9fWqmgaXtaSdY0uL kpmNJDiSPvlFzyeueuKR0qTSsMv5WY3DWS+bNAuWhdvKVWyASpqzZy6ldgbJ5EitYg8r4HyEkDAz 161jJWZom2jYdTBuLQymPIS4ZlIiUn+EnpkgHirlpHbsSbBfs/mD7sbnaR+dJWTK16n/1PzTgjgU NeXgcR2ecxg8SfXHasxLmVJpxZRZfd5iNjdtzyDX4i3Fn2SdtixqE1/dSNqV3KHlaBIWLAZAXAG0 9uw/CmRRW8lrcXTzk3SrshiDYfPXJ/2fpUibux1rDBfNaJZvK5WVU1jewSGPPJ8tsYz9e9Stp8z6 hLdxLcG0gdreBZMHkHgsw46YoG3c0tUuWt9L09GnzLJqEVpcHymIUSsF3ADnC9T7CmadFd3ywh4A +xyoZgP3YBIDEf561lPck//V+BbmyxFsDxlUUEwEjLHsQPY1zs9jfNqEaWNpF9tkh2vcTSCPy1Hz KM/j0FfgEnq2fZqbSsXtRvzFLa2sqFVIC3VzGuRH6k5P8vWtHS7JJ5Yku5naV2/0FXiw8ie4z1rk mvdHzmhcWtkLmGGSPzFiuRLGzph0fpnHPSrUt7crf3uixeaTbJl5GffGd2cjrwfb3rmntYcZ3Y9C loiJGoV1bOYx3/yK03muIbbz7lxJJOSQWbMh5wM/oPwrCUb7HXCWzP/W+OLmO1bSka505LWaSHFx 9ndrjzQcneeOuPTgfrV3QPtFjoyX2nXEENu4MdmyyJJK3tsOSB9ccV/MDTTsz9G5la42K4ZfKne1 VLuKMiVmG9ck9j6dPyqe3vWe2vlH2qSS7bfcbhujULjpnkZIpWMTGtr29ew1SS4junNjN5VparCT JMGIG9AOoHf8Kwba3uiiFVZIo7trgTAESSM/UP27npT5Xa5anZWN+G6vYI7u0juLmC2kgEmwZW3k bOCS3qOOD7VsW+kanc2iLeXro8VuLgSwENFcoPuocgjvyByCD0osyJS6s//X+VbS1eFvLe9ldJh8 0MmAiY6AY5I785xTbsmaFYLiJHtJH8qSQjMQUdSeO3pX8uSitWffRknobFjLBpUU8VkpvYoZlaJ3 jIiZOmAD0Xpwa3ZraAJHMqRNK6+YsSj5IyewrknGx0U3Y3dNVVuSJYQkZt1VY4JNrM2PTn0H5+1S Qto/nSBPtzXpUrciQD7InJwEI6n1zWEo2eh1x3Rq2d01rC/kr5sqtuQfcGCcdemcVftReu0rJOd7 HzT5nWPPb9P0rml8TNz/0MCWxhu7OCK5BMluS07xDas2f7/tUdklvCWe3/d+S3yohyoxX8fPRH6+ lZWKk13Jd3ayC3kG1wPm+4QMfN9D1ropLKWeaK+E8jySRFZY8fI3I5/SsDoj8KNK3tmjM8hlCQtC PN6Bhgg8H/PSrd7e/aLy3CuIFMSowSPG7AxuZqxn8Rmn75oSwyXJhWCSUyxOH2Qjc8/oMCqSpdXU 5urpjGqMVjt93mF8EYdyRnPHQHj+WMypTs7I/9Hels7gTwyfv1gm+ZpPLJj+UjIB6dx+tI08NtMW umlaKSQRRgrgY+vO0+9fxFNan7QdNJbWd4Bd27yNEo8yOXeJWQdB8wAHFQi9lEDvaq9xj5GbbuJ/ 2z6VACx20V21ncbke4tpvMuNwz5foAO/1/8ArVs3zwBIp1TLwTmQbsbJAQPl2/n37j0rKe5vHZGJ Ha2/mTXNnGz3FxKBJFuLSKvHTPb29q6W3itbW4dY/tckM0QZXuNqeUwAyMAkYzmoNobH/9L2CS6E qeQgbckn+r5wAf4l7dqrOxs3+9sAOZIiuBIex9c1/C5+7OSTsSW0pvJ5FdC1rNKsJVDuZc8Hj0rZ n0K8e6Wytre2lt7Oby5ri6byvLG3OUB+8celZT+ItO2qC2ubMWN9YR2bSfaJxtLnAj2kZKj3wKuv bCeJYNvmSoBIsfcFfmGPoRkfSoSvojRTXUztOl0i7murpYZLubaIbq3kBjZJVOATn6fp+Na0lqyR Ay7PNbDJKrgwxA9higOfU//T+g4EWL5rpQ+Rw2SPy/KlxMj+f9+J5dqqvPlrgcn/AOtX8HNJ7n9B KTRPf2djdTWpS3jmKnEkjfKy+gx9f51TnEkGUgiIK/dUd/bNUot7EN2VyW2sVnDXF7NLEwUN5UOH ViOef/rUya1WSdGigH2dVMvnbOVOAM/U/wBK0UF1MAj0uOdX1MJG81uhDyyMA6Lnpjrzz0qnZ6kL eWK6kt28oSjEUWQxUEdc9P6VXKrWA//U93ninl1Bpobk21qziS2CEeY/f5sjjB9Pzpq6XGZrdWWU yhWWAxklWzjIx7kDAPpX8LJKKsfuLTW5BqE620lutjGryMVjvGkG0R9c7T3wcfrVxrWVrQ3SKi7n 2n5wHcgDkrnPQDnHaqtYVitFM9/bXFnEvltbTqPPGdo4BI9O4qpY/wBoWt9DLHavfXNukklsrReY kmAchR0J9PpQk3ojWMWo2Y6wi1HUNOgvpLCezS6dnSV0MTrg42lT90+x5qLUHuVVWunMrRxmNc8s o9BmtIxXLqZtNbn/1fTjeiK3jtmBWGdykbNksvy/MCfcevpVi9jinsobeC3ZYlCRxra582Z9wwx+ pxX8Pn7nB62IF0y5gme33C0u4o/MkM+UikJJG0ydM+2ab9vvLQPDc29hPHGxHlvCs0PXlt38R7jt WlNa3NNEyPS9H0+KCe7n1WO1indZobI7pZJkK8sQBmMgk4BzxWD/AGg1o9y2nM5hvQ8aNOweQqTj PXgnb9cV1xVkhk1sl7dxSWyvCWliwPPcRRA/7xpuhQXi2jeesH2iac2bsr7kt2QgttbuORzjpR1B H//W66SO0uxdLdRPbXH+rieKUJ9qwMZIxnP09K5u1srKwkaF5Z5Q0hJDyeYy+ijPb/Gv4wu0fvBa Swtbx2NnCFO4q4cdCvXNUQlxqlwBHLFdXVu728UUrhEiJHzHf06Y4q+azZPLrcy20x7RpY7253SR xb5WCbljPohGeMc03VUtVENpFdCTdAskb7g7rkcgj6/zrNt7sOVFO7tobe2s1jNy8TvukD8IrAc9 KbJOqyIvlzywToIYVki3+RjPcdB9apSaM6kEf//X5S/s2W3WW3ikMNtl7q7VCqRl8AK7dsf1NY9l cSzutvtMhZtkLsxO3nHWv4yU2mftqgi++mqsrLc3Ec1sFKyxxNl19fy9KxnsY5Ga3gcpAxKwSKQk vHTKjp2/WuiEndFci7F54olgh8yImW2ch3I/duDzn/8AVUBuIrezuoY7NLh7w7o+wjYfx8dDxXXT m0Yzgupxl9HeI0Mccce1iTJ8p3KeOc1caK+jty15Ncu0ijbJcffx/Dg+g7fWuqM2zPk1P//Q8FbT ZrjabxMx7dyMMcgdCfx/lWdLolhdXMBA8ww8EXABRW6Zyfb1r+VYzZ+vTjpZkdxp8z6cI9IVrfUb m5EVlBHb/wCgMEI3STMOAW6Ae59KpoXiimOtQWcl0pa1W0upRLCz5Iz79OMZ/GtvayMOVdiHWRd6 ebH7VpzRvlJpY7ZtluYSv3Q/uCOmSPTisGxsdMm+0mzR4FvJmknglm3lTnPEh/HHFaKu0Q4djOuL C4tboXSR3k/2aNklW3jM0Khjje2AfTjnuaVxfXssQVTKQAIpH5Mfsc9K6I13Yx5FfY//0fj1tLso re7utQWWzuQu3fbruRgOCZO/5dM1iWGh2y6m1+V81/JMKA/cjUnJYD1461/NkK7P1AdrE0VrfQz2 MCNZzwNghfMeF1wpL+meSO/FQWf2DyRuMlxLdoR03Rqoxnjp/wDrrrjXaQ5Q01MifTIdQuotOs4X nJvvtMclyCNvy/d9No6456e1YOoxHT4p9Tjjs5ZLCdY7lZGEEgR3Ct5fHJHoK2jXZzunZ7E+o29h NYwXEMdtdXLEXMKXQysZ5A3Lg15/No2taBGZy5uJFnF05Zt4tw53YUDOAOgBr0cPWdznqQVtD//S /L6O4vJLSbyoJo5rnJaWIHzju9QexP8AOuE8SxS6dplzI9yEud5tnjnXJBYEEKRxnAP5V+VUKrPs KsOx+aXxRvYI9UuLm3lWeWC4kMYuU8z92NioM9DlQCAfevi3V5bZdde4NuVtopcZT5Zc85xn3716 tKV3Y82rGzLl3dJFLHLBtlD44Qh1Ckd8d/rWJPGbu5Bjf5zhdrDAA9B+tenR+E5Ksfdsj0HRJHtr CLT7W1h+2i4Mj3LBmcocYHXsc4+tdtp0PiTVbq70U2jNY2MZvY9T+0eUkG8KHVgRnkqOvArSp8UT hUPeP//T/lLmHiHUrgDVtZTZZDyJbCZFS9kXjbsyOAOOR2NeeePdR0a0lj0zyTbC2t0jkkjQsh8z LZPYdevTivmddUXVdmjzG+uNDvbeODT4JWFkM3U6/u1kzkZUkY/HnrXJW+kaVOLifU7yaWVXNraa dtMQRCM+b5vQ5yRj1FdVNC+ya3grW7jQ7m406C0sdQ0udJbaRpXPn2ZA/dt0xuyex/CvT7nz7CHS 2SORvtRVFtYWD+QjHJkkXqFHP+Hersr3MofDY3Fnht4kRRDco0e4g4bbnnBHb6Vxeo6bponklgnu 4muId0VrEB5MTggYC/jnP6cVXK7XLP/U/j70V9S003LW6S3skdp9ow8oiYKgJPfuOD+FcjeajY+J TFcx6ZCL53FuURtsVqUblicn0xn9K8uC6hboaWpWizxWU8GoXERsXaK+tTJ/oUwYYGW9j2q7JMyJ cW3mmeZYg8ZAPyL0AXjjkHr71oJJdCvc+J9V017JV02K/uXYWjPLmRo0b+PA7rgfX+dS4vr6UXWp gslyI3hdryJkhjBHOVOMoOMHpxRYY/wwLjS57W51JTdjUULGTIazxgspGOij371ckmeK5v7ezuZt 1yAzhHBgEYPQY9D0znrQB//V/jtFpdy2NwdPQySqgVihxt9Cfy61Dpmm3l1aO0scjarJ+5hldizJ g4C46YyBXngbukyahZ+Zp2uQQ2l3aztBebWy5K/3fUf402a706cTvZaYHMX7t7sRFGXoQU/vD9Oa CXBN3Ma+OvasbOMah9us7L7lpcwYlgzjaN/HAx07YrV0gXd1Zz299bpBdxu7QkSCWQkHClm9CB09 6DNr3rI3reXS7D7NLqVjFfLFzeWzSFFufVQRyK5eeG3m1u21O2sZFs47ovb2bgfZLFCeVUnkgjA5 yaAcWkf/1v5AHinWe9uLZY5rSJd81vEwEqB+MAdcD2rNNld6o6RaW/2O8hOUk+VQfUHPHTNeQ1Z2 MeV3sbfhnU/EiWviDTI9Nj8+0dfsr3hETynaC7oh+91I4/SmXNvZmXS1vYkj1G4UoYYTxM4yzZx1 xzSFF2ZNLHq0DPbwShLWdhHtBGVb1K9SBVyK3uYp/KupFht3QOk+dqswzkE9qynudEbpkV5jX4rD F+Wt7FyVtz863a5AwG6Ad/pWs9nbRTy3BW3MQw7RwrtjhyB8oHsf5VBuf//X/kmfUdZuQ9lHbQxv GPPhEj+WkqtwrnIz0I4Ga5/WbPVrXW7DTZ5fMuJLZbm9a32uqLIuVye4wa+fOg1LHRZXuCEy8hkC GJG4kA53N6YqS5l+26hNZfavJuo0AeMAxIVJ+UjjB6dqALtpdazbxxXGvWWnanDpkxXSjp8hF5tP ygzqF5wD6/jxVHWL/UtZUTqskcN2oCocxNAemcdQcfyot0At6PY6bZzLftNI11a27TN58n7jzAfl CL3J4681nxaglxey29/bMXVt1rIoOyQNyfb149hWfIZSl0P/0P5B9U0ZZb231DSbwDUbYlY7aSNo dhPQ7+47V09xqLWkFvY3Fk6XcEfm3LIxkgkYnqG6Y+lfN8hPNEyxd/2xc/Z5be30m4vCsC6lDhZX Vf7xbI5xjGO4xW9JbSpKuhaTa6fZqtmZF1K9KwCcnOQWOcHjoPWs9iiGSW40PTraeeF2doy089ix lhd0PUjtgnj6ipUsNQuNPi8RMsjx3svkubtirsyjcAE64I71PLZtgVLrUtTaS3ivbO2i0ucmJ2ji Z59y4wsfpjI6nNT3Vu18bO0sr4xWSxOLm3jhLTyLt6jPK4749ahwa2A//9H+StWvNNhimtzIPs0q GK5KgqSh75GCeOlXrCDVr2aX7KkNzqZka+1CeUgoiDncV6E/zJr5BpoLdCxeTvZiz1G7MVwdYvXs 52hxHcxNEoYkR9x8wxiprLVn0by7uwLQ3UE32triJeV5H3l9++etCTexPMkcTFqfiDUrjXY760nN hfXTFLhNpimQ4OBjo2f51txw2hW1/su3lt2SD7I1rN+7WQkrvLcZGdvHb862jFLRDWp0cTaat7qF qsz2YjjVksriJikbAYyDjOCc85P3aZbWr22jxsb2O7umu5JXmjyQq7uFz0A5xwTyDWqp9xn/0v5T o7CEW0jzKHe4BkyXyMkYHFQadqH2fy0nia6VSV/dxlYpAMgDOfpXzKj73KxtWHTapCqpcS6dBDHE pildpWyQTwT9OMAY6Vhx21zrt6bxL6X7NDbhIIlQBFAPC9MjNbCLnlw2LZkypBx8vTj1q3Y67YeJ 9SvNBu9TltjDZ4825lCrAAuVIXuOn50EySa1HW8t9Z6Y9jposHkDlH1KVhCxH9+NT1PFZ91Lq+n3 dlYtK+prqUDXl/eShQ1uR92I4A69f8aDJqzsf//T/k4Ni93crBbWsn2sxl4PLOHJUZOD3HB4putx 6s0UU9wZtsMWAzJ/pMBHzErxhj098+tfP7GKaSdy3oayvawwyziVr9hI9xKB9okGTgyADII64x+F ZGveTHKtvZ38s/nlkWSK1ZY43B27W4PB9T059KCTRsLSaxsbNZo4kES7VRBgHHseecVNdea9pLqU czxwRLtktlXcjkHlsdeOelA72Vist1e24MN0siqYt0EikbVJ6c98VoxSssMlxdyNbi4gMCzltpDn gP8AWue/v+QQnqkf/9T+TxdNkRE3lrqGUA+ZMmWfH8WPfrWzaR6o7j7K9q0MUbW88E0INwqspxsO M818jVlqkbyXuNmfBeRtu0mWGe0ukjWVdilNrBs59jnB59a2Lmxk1i3jsJDuuJH/AOPmRxEzH3PT tVqa6mCXQSx0+5sLw20kLT2SRETzINriMYGTkcc45HtVewexkv7C2uUubq1srviy3nO0nJ2E9PqK 1XT1NZWuky4YY7O5nJjleK+n3fJHu8s4woY+gx1q1JHGqqsxzGrCQLjOCOh/CqaXPYa5VdH/1f5Q 9Wnhj077TZ3HkyTs6rGow7Hpk+hPasC2lv5rQRSqs4tYcs7kidcYA+vGe9fMuLTA0tA+w6e1/dG2 uZWvIhkxEkI45wRzwakn1KGyeyuBFHDIXxDLHmRo2YkfP/d/Gs3FN6kTt8zQ+17F2hBh8u7sMM2e c1Hd2u61iubKUQXxPyXMeFu1Hp9D/I1nKLRyzVncr22jzalJby3CT/Y8mC6Zx5byOh+Yh+vPTiru rapNFE2lwW7WkAl2SXKptlcDjapPGOlSa2VrH//W/lUtnjhEUzMUedMIrjEk20dx7Zoe4lna2kvF VZrdzLBH9zyMhl3YHfB5r485rK1jbul8hhLNcLcR3cSOxBDKMeo9Rn9KydYtZJ7v+yUvVZbp9gub XDblHOVPOOKASS0RK2mNa3NzY24ihVVVLe+hAiuQAPvKMYye+c1QvYVtLaH7fJNdhJQ0k0kas8mM noABn/CgZlWGo+dDAdIjltrQ6qwvDPGUbYr/ADlFPXODyOPy46nXoLSeUQacgjtJTtdc/LJu5JYn pk5z9a2h8KA//9f+VKxl01ryYW8q2RgRbWfs7MgwSA3UE55HrxV037TP5EERkkVs+a7bSgHcDvmv kJKzsc5cjZNHsbye58l5p5VkOCzNlyFXAHfoMeuKxp317Rp9lylumnaiUngdrndOcHP3RwOGxg4I 4qou1xtJLQvz3F/pms2V4kbxLtUhJFIEue2f7pFWYrCwgttVjttMtnh1GY3MsNyWeMuzFm5PT/61 ahbS5iWj6tp9+beyjjh0+aUPIsBxbRoAeh9uwP51r6TdWt9f+VOTcwNIykSj5CVJyPccEVE9jWCV j//Q/mWcWtlHdz2McKMyNHHGyjOSMEYPIHv+tYurXDLBpr6RLJDLaSxz6g1wo3XGTiSNMdAM8H26 V8eFjSu76ynupxDbuskdqmGZtvzYORjuOv5j0rmrm5+WOScHKsVRlOGIPUD8qCeVJ3Ly3FtqlqYI 7m4Sa3ZGmbZg4HIXcfXGOKpya5d6dfWk9qbiJxeoiXMcDOYz6rxz/wDrpNaWLiruxfl1uW+inluJ Z2uGuvKkZF2ySgEE7x2BwKv28k9tcxmG3BtpIP3mG3OoOO1EVZGqhFH/0f5htR0zVb15J9OiWT7N EbiTcwjdVXnGD1+lUojG1jNY3zT2y3VqXDop875gPkx275Pavj7HTZ2uTSaY+mx2E8J/fwxbEQso 8yMYCq5H0qcl5LX7WI7mW4diGtYk8yLA6FT2PWm01uWoLqEbyG4SSztDabji4THRiMEd8jt1NWr+ 6kgk0y2S3tjKoeSO4jAE0AHJDHtn39KRLjrYy13T3BuZC8Mzt5awsoZZTn7+7qM9hWzps0Gn3zta WipPcRkTXcY/fO5GOfSontYho//S/mi826RZGvR9ruJnUK0ClfQEtnr+lV3nE11cWlusYntIw94t w3lJbqen1Jx0r4ye6OgxbeWK5uZ7m9upISCsVtbNASkwUkHa+O3XnqDW/ewxXbQBbhxboAJ8vtkP QDYueaze4FO5t2QzQWMrGGQbEkufkkQHjJA7j611NtNNDbxQyrNII4grTlc7sDHJ9TVpXgK6vYzL 1IJFJYiVZH2SwkFyc8dPSrH9qrshjjgFtb2kQhhCIYlXbwSKhq2gz//T/msmk1W5Fpc6fefYra6i YXRntg0vGNqAe+M596dq8V1O1nG8SGJAN8mAjMPUL+Gc18ObvYsXFhBHCj6cEhjSXdJNGqiaU4H3 l6duv69KfDcPciK3MTJITsBVSS/ua1UrtGXM9jNmhfRZxqUaGb7PMCSkZeSPJ7D1roLmdcfbYxtc qJXk2bZVJ56f0omtLmxp2LahfW1jbYjuftCNJDNOwRZkJPDnoOQRzisfUJwLi1tbq2sba8tpCYja tvaMfdyG70RinHUD/9T+cjz5LBWl+0NKGJeQbfmXPQAAfrVn7PK0nnvuZplHysfl29QPxz+tfFTi lsdBftNSunv5luLNUhSNVjZV2BDznH4AfnUeoat9rnNlaw3DGOQAyNFsVuD931qWmtzSMdmMsM38 N3Bcy3cf8H2UEJHxnkn3qa2uoNLKr9jgu4owRMkzMp24IypHO78fzpFSV0VLIXGrTXGp6dL5IsoD JKUkG54/u7Q3qM9B70RrCFRH2NIs3nxsyjzEYYwc9aLdCJqySR//1f5543XeiPJGJ7iQL5kp4Yn3 /wA9KXUb9ITsZFmeBNmfvqvbNfBS2UTrqfEYNtdXEs6PIPs5YEGON/NRx064HrW5FZS2oa6kwlui 7kT7rFuxx6VBLtZWBpbu4je6jf7OCQsLL1kwcNUM8872ckAma3VgPNeJcOcdgcZqJ7CJLPSvtKT3 MLuzQxB5FXGeoGW/OtGJYE8u2xi5b5huHBrIqKu7M//W/AueGP8AtaI3E1rGh8lpo7Vt8UAGMnHY 8EketRaxq1jNq80On2RjtoyIopfKKrMD1Yf1r87p9TuiuXQpThPKQXJcRM/PlqSfbpWnZXEU6CCO csofytjHjPYfXkVoUT6lBNpcjh9lvPfxjyF2hti9cbewOD1oivx9mWxu4mjmLbdkfzxHg9aAsNIn hglQQhrZmAV9uCmB93+tUI4p45xdC6ZQgwI+g4PBz1oA/9f8Ere/mijkv7q8c2skv2dPNYESPkce vcVfkivNQjVZpjHbMh8ohcq3cAV+fnoGQtn9nuUQMVVhsfBxkexptvY30U4tbu4FxaC48+0GAZY1 IGcn2x+gpNXVgNKeSKRxC7vIElwrP1Az+lQ3EE9lqMDCWG4s2hWRkVjvBJB2nt0z+lYGsZKxq216 wuPOgs45IQx/0dwXU+xP9aNPFjcmS7kkna8iuGWO3ePCoMHoe4HTFBZ//9D8NLe/jty3mxyzZJKo G2u3oPaiKNbtOY9rSfMRnOD6V+bO9tD2oySJ2t4FhaG8Ro0Me9EZMBxyOe/Y9q0rY2zWximhV5Ix mKcZD4H8O3pWBamnuY3lG6MjwK4MJ/fEodsQzjJ9PSi+s3nt1hW5C7G3L9nlDPx1yOx+tbfZG5Ja Ec+irb2cD295PI8yFpzKm14+ezd+PypItRCQ/ZVH2oxJtBlJ64796waurFJ9Uf/R/DWGB5bdLYlZ Lq6k8vyV4IyRj8+R+FatrYT2115SBVuIVKyqW2rgfeFflDVnY+kjNt2Zfa+E5khtUYvCo84spBUe v096g+1a3PqLfaJHmtdiJbO4C+UAMFc/hn8aLNK5qm4kFw9tFf29m11NJfXk3k29okJZQR947hx3 6GtLUooNFiiijtmeK6nzLPKcPE6AbvzJ6dsVDhE3J5JbZharbu1xKTlMJmNSB1/XFJp93K63drdi FbiGTz47kgrLKDgFOuD2wMZ600ktETL4Wf/S/Gy5aOzWPbIZ5ZhuMfl7RFnoKRxNdQTW8rBo54SD HIPkiI/i9/pX5OfUE1rMIjaw2sEDm3hEbs0gHmFRz16ZHaqMktozTXF2xW5SOSSGCQEByvOzd2B4 AppXdg62M621W+vIohLmIjoh/eRoP7qmuisbmd547Tf5yspCRO3yhj6c9/6VqoJbmMviZF8ttdCH UE8uI7tiRAYZuSM/lVW/n1C1gjbTYvtEjTBo4ScKgz8xPXHArOUeUuGx/9P8Z7zUdQmktnMUEcry 4TzVJhQtwcfTP6U/VJRE1orxRNdyweRM8KfKSpJH8/0r8nProfCSwXNwbfyGc7U+VVbnHsKpTST2 wKWqxvIWDMsnAUeuKLdCjQs57u4IlPyCE4KKMhsdRVi5v45miEahTFJtkQjGO5xWMo8rNKfYfpR8 y5vpL5AtvbASQfONsxLY5HXjv65q5c61eXEdza6WwjEyGOQkAoMHueorGUdNDQ//1PyP02dAiC4Y C4hX5DAu5HfjrntV1riCMxxRXINzfsYZPLH7yI59a/Fmrqx9ykbs9tcrZJbx/bLaO2AguLi5iLQy sRnk47eg54rmHuCixKzuCv3STjce5H1rFqzsaOKtoS6fdzhppFLShRtMUikOCO4J61fkdtYjVVRI 5IiS6KPlwTwaRm48pY2yWe57i4ijVEBfeQCQcAc9O/f0qhcPMtzLFaSyiOQbg4G059KBH//V/LC2 u7qO3NnJcNduwLi3nVVj39iMDr0qnbxSreR3Gpr5Akk2rbBCJI0GP3jcdDk4Az0r8PSvoj7gXVrt bqSOSxgkghtXAYkNHJKYzyxzxhsdu1WoL4CeC7nVZwoEqwSNvBPvQXBXZjXPiS+vNTuJ2SO3jI+Q RDaYnGQQPbGMUyHUgD++Cs7OWM3Qn3pNJvU2juhn9pR3U6lbiVjbuAjquQMnlfp61pw315FeyO90 620qqiQDlWxksSPf+lM2aurH/9b8t9ZlitjaLHNaSTXUSzotvMsrAMOAQOh45BrRiumt7WJ5/lJ+ 8CMBRX4efpBO94t5ZtMhjgtYBtJkO1nY8dDzXO2e+FpdxDktlFPHHagA1W5u722+zrAEx8qpAC7z HsT7062EsKKcs2yIKAy7WzgcH6GgBIVu7qEwXbxQyyOSpViY19MdOlXodH1GJ9Oju9WR/ObyDbQL /rVUYjDg9PXgnoamUbsGr6M//9f8yFjknzEUjV4TsQoAq4GQB79qlhTU9Lvmju7VZJWmEPlKnmlQ /CEr36ivw1RSP0SdloYGqMILtbT7O3+jzMZriPO5GONoC+g5596slp5NrFzPNHjO4lnIA/8ArVRF 3axZt7me/urdDcvD5RxKJFwAOnPfjrWtbSRv54uCFWAkK4GN/pgUCKFpcopu0hjlZoRuSQjMY69D 3+lJYTo80a3bzlWcqZVTec9fpxRYFrsf/9D8zPMEly8LTSxhAcPLE0cbgcgBumT7E1IdUtZIDZwR M8jLnzNpAgwf73qc9K/Dz76TsitpMmqTXLW1p9nmVSUuElnRJkBVipVScnkdulWzNeIk8skLQTZM VsQ+9JCMDPt1pNXVjNyuXdO2tZrbTXQtp5rn93iT5CTnO4n+XNczaXsU1/eW1xa3SyRz+TaXMSh4 nz/F9DyKTjdWLhflN+8EJnaIzysjWyIIjhXiO3D4I7Zzj2AqK3szJ5SW8mWjbCu3DA54P8uays1o EZX3P//R/MYQ3Yilk1FRFIsrLIhbIcBjhs+45/GpJ7oyXS6xaW129jZxhPKMx8sMRty+McFgcZr8 HP0C9yCS+e9hjmZjFmQedEnzGI/4e9XtMeLFylw0pk8/dESu1ShAzk/UdvegCMxB55wGO7zB5QVP lcdAPrTnh37RubkHcOy4oE2luLb6bDPHPDAypJGDMwfP73HYcde9D3eq2KlUsJnmEe2C4mjJhAYY yG56fQ10E86P/9L8vrDT/MsTESDcJI0knGIME5wvvknr7U9oGs5I3gmUG2dbhlU/Kcc7ea/Dz7zn 7ED6tbT3W5bXy72cmW4mRNsbEEBfxH17VTvdaQtJp5NxcG44nAiJMvfbnvk00r6IXOySw0+5vbeW eQy2CwxlYLeZCkqkdFx2wKg8P3rwWtwNUkhubpHkVZI/mU4zs3A4xjit0rKxm2luTWurWd8l3b3K FxAMrHFgmXPueB+tQrp8ttpMuo2xjEckjCCzd99whXk5GcgdODWkIq12M//T/KVtNvNSMGo3MhYP Cu1T1UKMBSPbFTW1zNNFPbtbGI2YOMfeZQcDP6fnX4/ax9pPoMtT5/nzyWqGZkWO3G4ooI6k+/H6 0y6kaeCS2khZcqY/LkG0jt0oOeb1RPbuk0NvbXAVZoD8kwTJYcDafypl09tb7BENsmf4F+9igtO6 uT2UdvcZMx8l5VzvkOxWAB9e/pXO28LvqT2FtqEkVzLK1xGETAjiBHQkY496BS+Fn//U/KKORopb gXjySlIykMiMBIzAYBPGMcdBVXTJXNs91eSSi5eQr5O7cqj/AGj2Nfj59QQlFuGmiuo1MDjILDgH PWrnkgwqtuyyOW2kD5QF9aAMiaKHTpptTW6X7K0CxzhlIbfuwQO5HTr0xWrdR6ZqFtGLS7kd4Y/N ktvL/wBGTI4EZzznHX2oM59CGzdrS0lsbS3h2z7f3rpl49pPCnsDnmop7aaG5jleYxTsoVTG3Lj0 oJjoz//V/K54oI7cOoJlQbmc/ezjmprSKWKzhmut05mkfy5GAyuD0wOwGK/HZfCz6JNuVyylk17m 1jhFnuVpndx/AoLGTHU5welY0NtFfxm3uNhgZsLcTZRY8ZHPt61lHdHVH4GFt9gtIZCYY7QQr5fk wIDHcnO3dnPcc1QuLMIjXFpDkupZEOdrHt/SmpWOJJp2Lls4gtvP1WIC6VNsMMLbxK3GMnsPz6VZ trdLy1mmdXikJAVQvyd8nPtx2pN3dzWa6n//1vyhgkhlnj0uC4YzNIDcGdgiRLt/5ZjGSM+vTNW5 NOuIp7i5ttWksUgUNbxhQ6lhwSfrxX4x0sfSKK5H3L0Ovam9hNYX4iuJLxQ0h8rdCjKchlPY/wA+ apPpE8uo6VqEu2NYIZBatHOEaVmwrKR+Hf1pGha0m1tp7u/ikVo5kGNmOHz2FL/ZYdbi2lW7sUim SdbrZ5YkCsGCjI5+7z9aia0N47It3WoSald20DSyyQNOPtCupaG4Kgjc3uBnn61qLDZ2sV/JptoT HBNs226/dBz/AA1kM//X/NjTjb3MFwJbprQzRE2++EyRXDD+BjkY59c9Kz9KhvBfXFsJY4oo0H2u RW4Kk8YHU89vY1+Hn2UWk9S1+5meZHAl8kHZG3ChsfK34HBpNIti1k9zcLCl7ZMEaGSIul6uSd2R x0xkUFT6FrS7ESSahDeWTRabfEeW0ZaPySDlvLGf5nvWklylrbT6VZSXNrpyX/7s3cuTMcAKSPTt +FTKVnYz2Mi6kdZSL1ZY7OB/9InhTzCo6Er2NdPZzWYhgktHm8oxja06eVI/vj3xmsXqTzq1z//Q /Pr7JPNem7e5cReUY1tVUAMTzuLdeMdPenyi3glSWVWnKx7ZQpJIPTAx+HNfz/JaNH2C1RUjgdQX uH3yyuWiUrkKvYZ9hW5dahNcJHctbR+ZaKFi2AIQQMDHHHp+NcsldAaen+ZqcaXN3HFBc8h8uNiY 7lsD0yaZoEVxqOq6wkVzY28M8Qkubq6mCG42MOBweeB064rBpPcFoShbVLtFNwqp5hVc4XzCM+v0 z+FaNzFaajY389lPO1zp0G5LZIS/2l8jKr2+nWsWnF2OynvY/9H440aXURapNcRCLA5Sfb5gOOQV /nTzbRNffaI1Mcce0CHcfKiOOSo/PAPtX8yyjc/QC7eXeotbatb6RbQ3Fx9lSWG5uoWYELIFZVAz yQf5VRgsNSs7i1a8nntzc2qzS20bDyiHGV3D+h9aaWlhKSexo3+otaAC1lkiu0UJE8KfKMdQ34Z6 9a5PTNTQ2mtf2hd/vYtWxGFjOHDRoSQAMcE/rTsJSVrnSW18s1tBHKAbGSfyvMWMNJnpj9ehrUtH a3g/s/zp3RZGMZmblcnJ47UNXViJST0R/9L5jKNZROz3EM8kj7V8j95LbDAGCPfPWksPsFlDapql 01wrFgkUScyOScCQfw5/oK/mBqzsfdwWtwhlNpNCJbe5nga4XMEGIzcRlvuEnoMd+1dPctnUhFbW s9lbIiyItyPM4J4AIx0HqK5JrSx2UonQi1YSHVYHjeQYYxuwRZWXkfzpzvKYXkjjgDFi0iKmW59D XLNHbCPU17GUW1vFJNGj8CXyXboSBkHH+eK2oBLcpLcxBRI54RRgtjoK5ZfEzZR1SP/TwpbWVbBL qadYS8ghkt428ySQHp8o564rmre/uLHXJ0iKtZLGqskkW5iGX5hg8gjsa/j+3Q/YDsraCK7lh+yG OQychAdu0AE8/l0rWtNXsLeS4tZzukjQeWiJuUZPT+f5VjKLiUpNKyLKiGe4JtpQRIoUh+Ioz1Oc +9RRKZUu5JYwIVl8mMq4Ylh1/kaylFt6ElRtQ/s+JJonkF6lysdvtyrbWOGww6etbdqiX7vK15Os yjcIpUHlTHHzDfnr7d/0rFq6sB//1OognngX+z3u7iSDzzN5Urb/ACiewHHH9KS6jcTxKB9oVDmS JP4h3wR9K/iWcOnU/ZVJKJLY65NfvPYiySy0qNFtbS2XMUkQBO8j13df8itYJBGHS2IVIoxkMcE4 xn61k01uWV7uGKSLzILnEbqu5LculxuwN3OOnXpWxapYXUNqlxM7nDGURAM8IBKjIJ68VlNdTSMu jI7fTL63vo5tMmVzG2+OaRhCAQNwBzx+B/WoLzWruBjYGVZbcyo3m+SHlEjYDorYyRnjj0zWZqpN KyP/1fWmmW2B2RLHIVPlQzZYjcOvrxnI/Csae1vdQukjvdSummj2ylJSscLYBCkgDtX8Ln7e5JaM 09Phn00S/aIUDSvmO5U5V8DGAfXpV6P7XJOm5iyy8GTf/q155P5Yx71lKL5i1JrYv2Fu9tqUkMlx DcQTukdu8afNHnGST/nvzVqGUXs9wGulRlDRRGNdo2rxyfpxTjFp3ZUZN6MuWgdbuezEtpLOABIt viMoNgIJ57jnNJHFGsZZHItEbYr53KWBO4fgc1dtblxba1P/1voW4fdKmJ5rhVhAiiZQsMYA7cZ5 +tVpLu7a2ijtoWZnfyzhf3aNwXAbHOBz+NfwryxP3+OyIGkuNOginnEnkNcoHkwWYguquWPYYJ/K ti/wWeaOWKOBv9TEsnmT7eucDmqJlJaoqWe8XK3L3Egt40DNGygKw4zkHnJHbiqF9cz+adrvFYyS F7ZV4LITwW96DIuQKYQLsH7TFGFma1Y7Ekwfu5zznpVLUdVfVLIq0MVtdxT+akMA8qMIWGUB68AY 5NAH/9f2K5u7S7vo4LdZo44JMRxu+HOQOvrWp9mvZxFFbyiPdJtVrg7IkA5Y59hk1/C5+8Do10kT TK1zHcvGFCKQcs2QdwX2x/nFD3ZljuI0ifZbEhS0flmQkDhc9RxWnK3YLFeCeSSBtKtniiuLqTzI 5HwGMgUhQSev096l0q1vInlaeULe2sXmOssotigPQ7SRjnNWklsBiR6pqNlcOlzdSSx/aWMA8wTJ DkkkDHGOv5U65niubaYy3LCQTgBjgo2eo3Z9cfnVxi2TKSTR/9DvLq6CXEllMpiS2ga4iKoX+2MC oKqencc5xxXQwXcwtbd4SIZY2EsRABKOOQT9MV/EvJE/cDNle9utNvBrt/bXMSX4kljkkCsxJypA 7jp371nSXLK1xGn+kRH5Y5NuMDjj/PrVxj0Q229yszJvizb+TLGuTJtOWyMZYnrx2qeOyBWMQ2n7 mBvO+0Bchy2QVPYD/Gt7W0HF2uOjjUOizW6GS3PmQqwzs68/kagi1GS6vZtKhh2yTO1wBgQCNlGD jOODn9BQXDY//9HW1W6FnJAt1DJKJEK29zGhfa/AZeOhGQefWsuNYrO9t5XmuUVV86e7lTKx4PBA 7kdf6V/F5+8FyO5uYUvDFcJMl0+YriLMcrowyQ31zz9KlsxdW9vKF2JCxMj7VAKk8Nz755prfUqG 5kPZ3a3bnSbxne9ASZbkgo4ONy46dOlZNpo07yS2dnk380zrEtwVRIm6hI2J6DBwD9OelRZttGcm 0Xoba8SFWv2EbRStaPA+N5ZQNx2+lUpZwlvfLJNDDIQkemh8hncsN2T0AAzWsY33M5Suf//SxlS7 dpw11JDb3ESxT2sRzBcbOhI7896yL/T3tru2tLdjaS7VnBRQCynkY9K/jOMdbn7ffWxh6leWIW/0 pZ3tryexfZcwIWYS9NxOR69R6CpYIo5EjdnENxDGhSGJCRcE8Ekkkg45rphF7jv0NVAZZAlzMkVs y4lRlzt9Cf8AA1hiGNrl2gm+78oiByrDscV1wgZzWyLcEPnM4MSs0CmRhwTgd/5VBe3UZhUEeYm7 ACjfn1roSS2FyM//0/G7lpLUC4gdvNYBEiK5UAc89v8A9VY1v9u1G+unv2twl5cNJJDHFt2A9c/j niv5RXT1P2WUbrQsX1teWxtbfTJyyrMGVYR8gUAgqBjj8KdDaQ6s0Fi2lWQfzt7XEqFpEcfxZPp1 9q2OdwT2OMnlu9Ua/C3L3EWmyGJ7dju+4dv7v1Hf8az5bcJCFUBGl5A6FD6UGResbzUtIsZrcX0r TXKtFPbW8jJbTKc4384PHHemaSo0+1uLaRVmuLm6Nybhv3hizn93GR/D+fSndrRGD3Z//9T5dt5v tIu4bxWgBUx28uQFc9s57f1xWXJDqEWnarFpl/ZRXPyRAMqvc3OG3eWmegYDkgjg96/l2Db3P1A5 vUJo7XSby6vTNA7RCDy7aLznld8LsT8T1P41oW1tt0KAW1yltN/Zv2SJZZB9tzgks2BwSSefY/j1 RbSRfNpZkENrJp8ugQ3l0trcxr5tpdRt50lxI6nluee/FcbcxXmnS3X9paZaa/avOIZBdBo4oiXG GdVxnbjIz+VdUN0QWbvR7HzZtQt4VT7RGrfZ4SVUADHBY/h3rDutInt9MlltL62u7i8kMnky3IWW wyejL1PTj616WHOWdrM//9X8tri88Qr5DyStKbNvL8uVQsTY6EeuK47xLa30mn36QR3EjhBNIFUS Bmb+Ig9uSM+9fkmHPuKiWp+Yvxg0+TT9X1WXf59leQxG3gEQg8lgm1toHXkfmpr4w8QxyNeyKH8q SMDzRJxuUj5WFezRXvHl10rkGm2s1lGyyliJDvA69at7k3nysB1PLAZIr1KPwnDL4WereHv7PS9g MVxFLLFDHPeRZBmiDA4JA9wcfSvRbHVLWPUWmjuI0gvHW1lFyRFHMA2fmz2Pf6VpPdHCnaSR/9b+ SREkm1JbyeWSUPELZpyxedE9Ac/Sq3i3wrqkWn6hrEcdpd21tYZW7nuVkkuYQABvGOCCcEDJAr5t JXd+501YczR47odppeqRmzv4mEbW+biOzbC7sD7reme9c7rxji1ODTksjZmJzb2EzTNJFIAvV89/ r6d66KfUhpcti94JS3EN1BrOqWa28dw8qWkcZj1CWRQMttHXI49se9ertPpsgkuJr25SW0tAtmIi D5qdCjDuCP61oY2KviKe3/se1uPDa2Ueq3qgrDNlI5fLGWDH+9gHj1NYllbGS1tJ7yeZbrPmXAI8 to2z93PTHb6VrB6WA//X/j4uIoeLqFYxKkIRleXMjqSM8emfyqko8OSQppFvFBpmrwyG4uDaoRDJ AeCznOA270A615sVZWMnP7htnYadZJJHFfFo5JjclrmTcoY8kle1R3N075NuFxIQxeNQ6tjuD6fS q9SVoWhfSQXsTwW9sl1aQi+iXzt0twBgZIOccjp71QbxLPe3epW2qaZbavZXlqY1tmka3aKVu4x/ InmnFXdi+cRLO8stLtdPe2aCN2DwpGTcKiEYVQ/pgfhVuG+gtIJpRpUMps4VhupYgzToD93CZySf SqcH0Ji3e6P/0P45YrCM/adRtb27ivGdJLdJGIRVH3kCDjB9/wCdSPqd/ZfvLcEYHmSyhCZIgOuP Tt/SuJwfQS2GWdtJqMkOsXmoX0ZEjyTRSgMdpPLN3Yn3P41fsPE8dhqa6bHI0EUcfBSE4AOdykgd CO31qWmtxjxeavHdXfiCV4nsZoittDZ7VicKcDzuBtY4xj3zVi4h1e7bS9Vj020sJruPKeVeb9yM QG8wlvr2ApBYsC80W2t7zSLjTr06tHMbu1uIENzDI7ctHIxOFHOQR6jtWVYahqWr3kcM+mtpFvCv l3TKTKSOfmxnBPsMCgD/0f46tWji0tZP7Bvrm7lkOGubuMWszMD90qMjb6VtSzPbLpkjpBJqdzaL dNDDkRDDFcOwHHT9a8lxaAuQy299qD3syyxTQxskK27nZGzDacg9R161FqtxqMP9nXegWlidSsrt THd35y1rg/M+DnJODxUmLTTNW6mnEksl20FxdFvMnks8LASRk7FAwPwrkdW1y61WyjttIiu7hYnK 3itAfLhydmXY9Bkis5RbehstDotJ0q5XRLd7Zrbz4QLVbdD80YRV+Yr15zx64q5ONQtEa2fYlzPh VC/OZO5BHb/Gm4LobJ+7c//S/kag1WzWCe2vAya5HtFiSSVeMZBB9OBwKp2d7bavdo1vHLHfwWvl 3BcFml2EkhXwM7QenavDcOxfPI39LsZts0yTuchpmWZhDtA4xk4/LrWVFqN/eXUlrbaDp9zeyr/Z sV9NMwljbcTvU9DjOOmP1oUO5ondXLb2+p6Ky2t7cSZuH/ePE4ZApPKsRwOhByarahFrsN7JCbG4 tivlSWlzLDvgnVgCGVP4hjiiceqM5XTL88mnQxtbRJJFNIFW4kvwruXwN5RcfKMg8cnFZ0F0s9yb VGi+zRnZ9rRcyAnqQfT2rMxnsf/T/kvs9DmvNYi0+S6tnSWBZYbg3PlkqASy+zAA8etZmsXQuFsY 7KOc2dpO9rJO0RAmcEgKzHn3A+hr5857E+paZuu9Nf8As1omtdP2gCdma6kc5ZtvToqgAeldZKdO u9PtJ5Z5o9QWMFLeSIwuvGMSA9v8Kwe7OgxUF9EPschEhkJdFibzYucc8cemaWSDxbA0DXVtAdMk YwW0q3Id5NvQGPHB7HmkHoVVuHiluHuopXkll3LLl5Ba7F6hegzg5z3qtb300Uh1We+hsbZCY3kd xG+GGMEdcHOP0oE9j//U/k01vWodRjsrC3tHttLilWSIRswN9IVG9nJ6ZIyBx1/PqLPwpPdWdxNH 4h0zTpXiEr2z38dvOyDB8sMeMn0r5Z2SFTjJyUb2v3OBvIZdJ1eC2u76O+utpuIHQiQQg/wkrxkD v71VimmQzRxRyTzXUvlzM+dgTdxnHYentTMDu7Oxs4iBIkiKyL5mOkZxzgVi2V8i+KLOwNg11Hcz GIM7eVExX5lLP/D7ZNVHSSNIX2Jby/8AD2j63L/wkd7dtdiL7RFa2q/abaRcnMYkXI/njFbVxNGm iQypYSKlx8lmkanBLdPujHQgn0zWxZ//1f5PbH7VNGbJVYXUR3mORSPlPp79ePatmzsIXyrTkIq/ MVUMVbHQDI4zXzDd3cCFprax3W9za210JlKRtOWcRMeAwUdcdecjIFR6Otrbyv5M0X2OwZpNRk25 muwRkIBwM5Ixjmq52Bn6XdWep21zcSrKoa5aOG3dclir4y2egx2rQ1XRtPxHLb6NpsUr2/8ApWow IWvYozhcMwJHpwemelJybVhPYz7u08pIZvsS3cNrAFiW2lLy88BmjzndwPy6Vr6fb/aLSC/lWcWt yxiE5iJYbRyBnHI4zQpNIwP/1v5Sbqd7JbCMXdwo06Vru1lf5W56jOOfp7VLcaxPdRQBiXjaXzAQ QTk/eGD6gYr52Mk9DnKqxWC6nHcXImtoiT9mZW3SlipG0DgZ/pViSxRInlhdfNQ712nEgHTj+uKO ZXsZybTFsL2O8ilgmurSSXzuszgtDtGNpx0P+Nadgl9dP5TWarbwsYFZUB+1lsNn1OAcUlK44KyM 7xDf6VHHaSW0iSpEpja3CEMJEJyCvUdMY4rG00PrAjuHlZ9Pil3iCeHy9jg8YBx0I9McVl5E0/4i R//X/lnFvd6kqQW7mKaeYWls+FAdzwuAeMV0Ph24sPD9zDb+PJIbBmMgnurVTcTSIh2ooXHUnGfr Xyc1eyNOa8WY+oX9pNf3l5pNlMtq2WgnvIRHctFuO0SAdCRg47Vz9xeWdw9rLJdFCkq3SwrlXUqe Ax7c0ct5Mxi7o3Zb+5uEWXazoyeWyg53Dt9axmUy3tvKsM8BSVNk8beRNGobJK9vXr+laJPmTKb7 lG0u7y51TVomvbue0W4ZLT7REqyEA4zkAZJ9a1AZ4GitrkS7ZGJF22DgAfdwO9aN++JO9z//0P5W m01IGtpreVLmOcSPd28w5gOdqKgx365JofT7nS4blzY+X9qAMKPzLLkcjH06Yr51v3kjKUmpaHOx XMEQkt7S6mgN9J84xj7McYIUH6fhmtGaO1ttPgimglvPs8hla4jiH2mckDO8gYxx6cZqGryaJeru Ytnc3qu2pPZwziGTyhbPKJvKBPyhlBz09u9b881s6tqa2kjTD5YljbYIyewBOMDJqLdGYzTuXBfQ jYkltePdhAbSKF9iOzYwcd/p71BqN3ceKbO2tLk3FkNFnLwQtH5Em7+Iv6g+h64FSopO6NT/0f5M bqLU0uFkF3tnUBLFyMRq4/vD04rvY7aS5S3iuDbS3ZjXzZRKpizgdGz0/HtXy5zmBgzGSJ2hMkcj pIttL50IAYgLu9fWt+zsAxaKA7buCyaeNj80cYA5LH9Me9KyC1tCKKCeKCCfUZoZbrc0RIcEY9B3 H/1qy9Q1C0ntbvTbpZYbmSIpp81s+Q2CM5yOpGelJxTVioK7LWl2ltc297ctmJLa3VTbkDAPAyo6 9iaztQv7OGK3jgmSZ2cJ5KNiRceo61SVtEJ7n//S/lek0nw3eWVlq11CYdTglZLn5sM8eMJu9gRV aOVLWe61AnTrWFbby4bm4Z2R8AkgbQcH9OTXyc0c5aiWa+axdnMEcwEyLMwMUrEgq6uR90Y4+tVN Z0+CSdFa4Zm3LJuZsYYHk/TtzWYGxJeXyyW5MbTSNb+Qplj86ONVXA5PH096pGS9jgtY7mJCLpXa WSNSYvl+XB9M+h9K2h8IE8lrdppL/Y58W963l3MEcgR1CHKgjtnsaVLWO2+yTwwhtiqXXG4xtjk8 fjUzfQabTP/T/lwvo4blDfXlwZbu2uhN59ufKQxociIjrgccfyrOe71K7vrKewjT+z/tfkyAgOzA 9CR7V8eTF33JL37dFfKYbYyW5G03SvyXJPybfYZ/OtjU9KvhCUCRG2ltgYbyH7sbHqrHsee/vQUc 5phvtODpcokseTlo5AWJBxituPVojbObceakM/mosiYRHOO+OOgzSexUXZkEUks115kkKebN+8dI QdmW7k4qO81G/t75UtZ2hZtu5fKyqBePlPftQttTY//U/l8R2mknkt9Tn1AK22a4nTyihwCVx7E4 rThcz2tlHOokubcsgmdQryLnIzgex/OvjzuUU4pEyR3F/KU8vMaZBJYq4xj+HHI61as0uLf7RDBE fLC7QWUgZ9Bx0oBxurGTfy3WPMWOa0YlY9qD5XZcAsPzqgA9pdy3CWsl09yoUgDmRgB8zHoO4o2H ym+LfUbiJEtrW2NxJMFh86TykUd8t071qyWl7oe5m+xvdvEV/cyrcKhYYPIPbJrGo7MyStKx/9X+ bKNjDaRTzKTKcbgB374zXOa7Np1yb4ww3aXlxbxx3FykRHmEZxh+hIyffmviZO7Nkmm7jBHFIkzi 4icW1shFrM6R3BIXBwB3/wA9arqYJ/stzEzSRRHLOrblDAkFT9OlSUdRahLgAiRZgX3szJgrnn9K 03ubiJZoY5AytHtEZOIzjp/k+lNNpWIs+c51GSG4kMzmaXhSkab5D25xVySU3r/ZwpQQ8RxkYJ7n j3pF2P/W/mpl1azitII7rzljhuACIoWldDkD5QBk9quzfaXjZ7YidFyYhL+7YDqAfT6e9fDnTZ2K VrPcSzwobY20Xl7rthJvG/0UcZ+vt78NkutVTWLa40ltunICZJLiDyp9oBySCeD6Uk/fSIlG6sjV uLgzF1iMWVhMrM77VZh0H86gW9WO2kkDo8iDeUlztY/Wt6j0sXGPRFxvFstzHG2nW6TK0OLaBR+4 QhQrYfHGT2PP5VsppC3QhubogSbQXOc7O+0H61MZJRNVFI//1/52YTYq8glDc8R/LkcVbQxRoIJp PLeZt9q8uFwOwHt/hXxTn2O3kQl/c3EZ8uEebOVGWYHbjgZJ/Diqcm1rlZZZHJigwqRjAzzjPtSc m9yyncPdskjFgsAIcIjmMswPBJFXvtyJaGWJYi80Ztpw8SyOBxnbkHB9xz19akC5ZS2trY/JEsCB du2JdrSE+3rXNSWqy3VvJcRlp1uA6KT5akE9j68cUGUnd2P/0P51NTkDQgxRMLiI5iQHkH60kVvd xyxTSxsRcLsZQM7fr6dK+Dn0aNqkveaRMNmjBmbzJHmckKyZ2BiCAPQcUt9qsmqQW9nFDPMJkeC6 nX5UtQFO3B7546dMisyhNHeSO4tLaYtNa2S7VjkO7eO5PrmtERK8zxshKNMdoA4xnj+lJq4GxLDb QkIrG1V03yyJ8gYIMgH8uBWPrNy5SxaHzy4lGJIYsrgFSAxwcZ6c9qxejaOhKysf/9H+exLK6uLu 4kltUj+02qNJJAegAA3Njofc+tbrmWSCKCSOIS2oC7oCCJlHcnHX/CvzyLSiegUr+4gZ47KMsVA3 sxGHTg8EVFo0MS3bgyEgzq0Qf7rkHg+nBAqlqi4LU3Ndkm1TUWgubh/PU7ZZ4yAqlcD72MDtVX7W lvcxRJ5btJhPMbnb7n/61M1SS0RFe3WpW126XixjJEg8tt0Lo33T9f8AGormeS4jeK3tP3hH7sF9 qMQOhPbv1oMWkpWP/9L8EbPT40sYLAwK7yhp3hz5uCSWJ9iP6Vba6uIYIrNJmMY+WNOdkeP5f/Wr 8/PRe5VuYUuUMdzO1vxhZYxlk9z+VXrGOJYpI47gSGGPEdxMcvcduB+RpN2QjEUTWN2Y5EWVS3nD eSDg+taEttdXVqstqqxO8jBQ3zfj9KwAq2D3tirwXV19mEw8sSKMlGPy5710VnJZW8mYpPMKLs+Z dpY/3v8APrRYNj//0/w01BbCKWK7cnz9m3HIVQf0prX5+0WlrGUjVVMmdm0kEjOT3r83PRTa2NW/ uvNgSUnzpVUQRE89OAP51Xt98bL9oyqgbmCclcdRWLi+axrBtrUowSzXFxfbpFSK5cI0SMVUov3d w9c80+60qxntYxDPKlzayb3XJQAeu7POemD6Vpa0bFDVvnINqSzJCvyMRlcelRw3VuZAyIFccPuG A1YgtNj/1PwvvI4rmSArJLbM0ioZIW2upJAGPxrRNtfW04JncOGIeQv85xwdxr8usj3Yz7mbdztF fxvE0odIyWCnbFKCcYPr/wDXreXUDexo8aSQeQCCgO4Me7D/ADxTN1PuY8Ntc3d7Hd27STSJLukk ZgslqDnBx16jH41172v2yxSC8mkS6WZnWJyG3Ad/xqJK6ubxnYzWCRxOtsNtxA/l/e2AY7Crf2RD Al7OTHKSob5sqGJxk/U4rKwOV9D/1fxOP9pHWlkaVLi2DIjRZAWNQo5BFS6nLe3F6kKRGGIShgqA /vAQePpz+lfk59QOsDGJixBZoZfukH5COKuX08V1M6GJXCLtYAZpxWoGNPeKi2yWUZDLNskV/kAU enf8KvQziUyJHGYrsEOlwuR5RHTB6VuYy+Imtr2SS6kS+VLmWKT/AFpfcH49frUP9rzW11NwYkRi o7HB4/r+tRNaFwWlz//W/FCa4S6GUlcyfei3cbD1AxTri91EvZM9jHMQR52xzlivt6Gvyc+tp7WE j1a6hnKT26IQ2HVicJ6itWQjUZ47iDyocKI2YHCqBTatoNST0RVn1KWJBb2p+zyRyYaTHzSY7j0/ +tVWC4mlaZZZA524Vj99mz1NRNe6XF2Z0CSWcMTQy/aXlSFZFIHJJ6556df0p9oHkmU2uE7sG4B9 c1ibJp7H/9f8rrHTbS4a3gW4tbSQ8TyvxHjBySBzXK67ZGxlxalpXVt6TopG7nsO2MfrX4zJWZ9y nYoR6zfIFs2SSeSVt8ruSSSfb1qZYLqWZjsMrxLlU7r7Cs5LQ050W1vWsJ2heB4yIsyh+N2egH6V Nomu79Slgh3xsISHXy+HyR6/0rPldrim0amoXUF272+oQJKhKyyER53FSCpI/AflWppkcN7CupSy P9maVoUCrtZxHgYweh6UJa2Zmf/Q/JHxJc2l1dWIaJ4BpkonHlHYk7KcqW7kjn2q3NG92k2rLeFI 1RUtkmbLsR1BBOeK/FYxUT7gVHle1bzWWTcuMYAL+uao2kcsIUldnJUI3VR2xS5Fe4LTYS1unlub 21nsVniEW8zhdrwcjkH64H4iktrWCeNppItpBKiIPnHoc1ElZmsZ3dmEcdnZxoscQtzFIXkyPlkB AwB+OafPch5IJFttyA5+9jI9gKrk08zXmdrH/9H8d7W+tbDVWcWSwW+7e8qqXlxznr712Wo6qbm2 TnZA2CiqMBz2OPWvxBxa3P0ZSTWplRSjy/IvBn5t6tkhdvpj1rZnaJVimtnLRAbQSuN/1HY0ieck t5HREly0UjfNDv8AkYYz269qY51CO4EwniECg+YsigmUtxhc9e/Facmg1NdSTH2mVIkU+YVJBAx5 XGc/zqE3Gq2YVWmF1NFxBOEw4xwuR2IwKztbQakm7I//0vyr0Z7p4pJLmRiIZSFLsA6nknA9P0q7 JdztcSapBM87k/NIs5ySODg+o9q/EYxbZ+hSd2WLaG+1Ozub82nlWkEwie6eUM7sRnp1x7+9c/Je LDetHbF/OWMPLMqErjOAM+1UoLqTYeutKj/bHFzd6tPJ9kEa7fsvlcFWIPRgQQT6VauJ57a5lW4X KSIrxrEQ0bEgZXPtn86ThbYmTsjetXQ2iRRIqTOCz56evP5Gue1LWVsb60tIJPKuHYNCoTcZmyfb H4VFrbmadk0f/9P8ujPd6l5glWZhbwYmyhBj9z6ckVn2Cy2sRggTMbMEJkOX46Zr8PPvmuZaGo09 tZSbFh/0uSQRtcxQ/vh65bsPr6Vo3kkcdxbrHM8sEkQ8tjjAYgbhj60GTVjNu7Ow+0pNNe3Fvc28 fmrH5ZME4bjlug6Gr1kfskf2q3mRApzuAHygUGsFZFmaYRJ52RKxG4ybeuex/lWVbXskc0jsT5bD 93t4xjrmpcd2HLZ3P//U/MOXUI7uMJPIXgUlcscjjgilM93p7GzSzjl0zVlTzX3nfAq5dWA6c4X3 r8MjGyaZ97FOL1ILI2caXkoBVjKPIiwf3nXcT+lSx3r3EpdkSOTds8uNdqD6fpUuKjuWWZomEcy7 2iKfe52lT0x7VjW93cJZmH941zHOXSVfmUoc8H+h+tS92YyvfUm0+e+kiuVt5RHLKvIGC8eOhGfw rTj1DVbuylj1HUJ1eNNgWNgA/wDeJHQZA9DW5J//1fyzW/BKQ2LkgH96zHGMVFPG7ThpDIrgZK5I Rwe+K/Dz7aTsinaT4u5hdswhQl4fLiyQuPun8ckfWr6WC3brLHMyBcOpj+V4+4J4yCKqLUXqRzu1 jSn8+1tLqKS/NxO4JS5mYM2COB7kVy2kaZe3GorZCFSt4yiCUNte5diRt2kcdB3PWtiG+5aa3gge ZrSzJ+zyFLvaNsoK8H8aYZXa1e4czrDbRnzI4xt39MZHrxjt96toq0UUpNaH/9b8so9VSe0tWsJS baaMPFG5HnAgYYEA8DPSoEl1Ce582IxW4UFZw65NxkYAI9sd6/Hz7BvqyQW2oQw2iv5aMtz5gcHL YDZzj/GpdRv0ur2eW5bzJ2XzZ2+6ee+P6VUY8xg3d3Ma9vorSa1jsIZ7g3MJ8xpVwsbjH3cfhjPo adYxK0oGo3P2VJ5NqSFf3gPfr1/CtOVGsfhRLqFw0Qnhhgjns7NAbW68wma6Y8ncpHy4IGDnvVCw K3UZvDugvUj2gJypHfJ/CsbW0G2ktT//1/ybgt5pUeWSNfMVsRs7YQ+/FV3kMdwyNEcld2YxkSsO mR6V+PpX0R9Texvkx3NhBNLAlvKIh50KNvWM+gNc3EzwmQ27iMjLLubKkc8GtORiOuEWh3tlaw3F hPDP5DTvcwyqbe5Zh/GpHA+lc5qiPDbxGKO3tobZRbt5ICBien1//VU8kjKe5z8H2+4voI1kaOxi YTXboB5jKCPlAPHOetX21SG1vLl53dY7VN9pLKu4yAkLtPoef0qbWJjZPU//0Py2sxf6gn2NLOBZ bhQ5mfKFfQLzjn3pkcU1nHLBO8cskTEOR91MHnH+e1fjzWh9LypSRSW/ubXxHZX8l0kllHpj2a27 HnfIR8ufTavT3p17pM1zBNOtxIsUztN5bMI4EwCTg8fl71k1aKZ0Q0iznbp5Db2qMpAjdQdg3Pwe Ca6O3OoySRrGkCWkAEpO8tK4wMgLjA/M1NuhzQjdlC7j+3XlvdW048uObNzC/wB2YZwQGHIOP1rp Y0bSmV5dQh+w38ZiWFcNNCNw+8CMg/Trig3lG2x//9H8nNVGj21xJPZ/aJ7qZ1SF1XJh4+YnGcKc Z5NU1t59Qj+zHbLbj/WqSc9c8/lX4xbS59WovlbOtt7d3mtbEFTPIqgL1OD939KzLvSJ7nUYkluX t1sbjzAUbqRkYJ9OaXWxKWjZfEzW2oBIIldIiBJcb8h89SOK3bnUJ5dOkguZZhbzTCOC4MP2iS3Y j7idsHIyD6Cpkm1obR2RW0yRrKyFqcOoYsWkjXzGbu273x0pftFzbSGWBlEcw2SqvcY5FQ4WVx7H /9L8z7l42t2VrZ5LfZwE4KSZyG/Sp9Og86CW5iDGeYBZCwIIC9K/EoK7sfYF63tLCPNuWm88r509 zO25Sxz8igemO/qKklsri10/zkk8h5Zd9qZR/rFBwfw/xpuFl5gQiTUZHV7nMCwjO2NzJvyM7vx9 Kr61ZLfQrbxuxSWIOkkse10fHXHqDWEkrXE10LNkl42nvZXoDyy2v2WUx5xIAMAj06A1X0LSr2G+ jstZupbi2iO+NvMHkJCP72OMgZ4HesiFT7n/0/z9u55tJuGMal7Zf3sFxMNwKbjwU+nr61Rt7iGW 5kuIY5YknkK7ZYzEGJxyAegPFfgU9z7C1tDR+3PcH7KIYlmhysbA4Vh1GT61PZ3EV1b/AGadHttQ 83L7iDDs7bT3Oc/nXJ5ATXl6LZ2srdHlVrcsJSv7sHgYP55FM8O6bcrFJb2xt/tDRAmaZxEoC5J5 JAFYJX0As3NrPO32aWzHmREyxTIMytkYJB9PcV1dt9pMFpcxXA0/7LH5U+1FgE4C4AJ656E9zUSj c7Ka6n//1PjVtW2siR2s99JLOWnZQSqpxyT256k1Neia61m81qVGs4JLWCC00yzDXFupjUISRjJJ 65x7e9fzVKNtUfoBuRXF5plrdNawrcSeVuktnk8qQjIJwD39qx/7Yh1Ob7S5dHYBX3A7vl46GqUV ykKFtxFuprZ7qPTUs47m/hKJc30auq4H31UnG7gAVykk1pbzWOnIkh1CHF5dCY7xe4bB4wAF6ce9 U1dWHyq1jrwy2doun/2bNA+oTtqHnht0MZIAAHYf59Kc1qyfY7174pc2M3mw2jH91fttIxL6gZJx 6iocLRMmrOx//9X5A0lHt7meaSJbXUrjc8ki/Or5yV68HrUFtPeymSO6jiRjMWRVO+4nIPGPTjnF fzFNWZ99BJI7SC+Dw2CzRLEY4/KJc4wST8xPtn9KkOq3ImnhjvDdRqxiUE7lAHGB7Vzzijtg1exd t5FghSaaWdEt1LyGTIiXcfXv7fXpXS2M0U2HTcoZRw5wGx3x/SuWcbaHVBq1jTthLMxkli8uJWKK xbJwp6n6/wBau29zs1K2hS8khtWIBuQdsbN3QD6Z/KuKcXe6NeZ3uf/WxpLfy5IhA7sEO75myzEn NR3W28Vhbwx/bGYCWUj5mUfh9a/kFxtG7P13nVjLhs7q3m8x5xGoOAqEg+9bU7WcIjBV1eVflIj+ dzjnnFZy+FhGV3Zmrpd9/ZtxHKLSG8TjdDcDMbj3A61JvBSedI4LOIlnEcMXlQggfdAH4Dn2rEce pEtwGtraQWsdwt1N5cdwsmETbySe2fUVbtrouLm0gUSBJw8chXjcvQA/gOlYNW0ZR//X27jUHCzy 3EFtGwjVJ7iUmNoAvG4Y6/jUUV/G8cK2Us4uLndAGC4PzAjKkcg4zX8VTWp+xKLZJp1rFZLIs1zM 5hzsZj5rStnnccitm2zLCZIpIZmdyuFyZkPAIPGKxmm9jYbbpcIn2e5gktbhss8TEHYuSFAx6jn8 aktrO4tjci0XYyr5zeYxAYngYz68GsJL3QLdjBamAxXNxeteSzmeW3lYG2YHhdvOcjnjGMVpzNBZ mCBrVNwAaFpFxszyrY79iKOVNWY02kf/0PTrxbloYpbl0LglYJSR5n1+hqr5Op300XMUkUag3Db9 s4XgA4/Sv4ZkrOx+0W6G9ftbQ6ez3jpIlooKF5/JWBj3Az82OcgZ71k2+pzXMiQxMn2BIhmVY/Ll lYnJB9QOgNSdB0DLFZQSPbXtq8u/y3VX3yqGAOfQZB9axba30u4uY/NuLqzvLXdJDLDjymVh8ybS cHOBweKCofEOt7FkvHhgV4XWTzZN6mOWbf8AddznoRjA6YrUkCs9vave3UKh9rRrHviTplvx/Cg2 P//R9vsL8WEUsV/AL4vO62wjco4jXONx7AjFWNC1C6lgvYlRjPKZD9lt5P3USt8hIB53KuRnrz7V /DCTex+982lh8l/Fc2S6XIkiwRN5YMg3PLjGDn68ilJ89rSIxRRpZHyhdGP5/n6liOvHp6dKRA21 nie5uow00ttudElC7FZx8o4PbijUrJGtb20uJ2RprfZBJbur+SW6nP0z0oAfarHBZWsL3q3TCMBW Gd6gfL83v/jWbcxQrIYngeb7Sf3UoJQIQckjHX0xQTJtLQ//0vZ7yWKKa3iuo7ONbeMv5xizcBwP k3Pnp0+lVNSuI7eKCb+0muzewCZrONzN5JzgdOnrz61/C9uh+7rVENqBCLO8mULPDKzWr7d0sJkG 3DAdVOehyB+Fap1O5Fy8M0Rk2MFMjKFjXjAXj/PNbpWVhmRPbTJcPbyyGeKVhNJNAu0qOpCv1yPU elS6cES9up0nMs13F9nWec7/AC0XoO+CMda1jDqyZOydhlpJC0l1Z7Q8k7mNyyZZDuGSvpnH5GqN zDb2Ntf2stq9wqEIFiBkwwbA6ds9SelbRjcxP//T9IsltXkjEqRhzAF8wN5zR5wxX8wAfpV+3hMl 3FDcmW0tJE3CRIj8ygkd/cfofSv4uaT0Z+3vQz7oiG8urZ1i1CC3dWmX7mY9wAPtnt71m309l/aM Nrpa3BjZDcKs5GV2hd4ZhxgFuKqEVsiedXK8t/czkwvFGCSUDIMADsPwqvZXMqCWKKU7Fba7ZJA9 K1sloUmnsSLO1okpnEsk0kmLaRPnRQM53enrUaajG0mJkMd2y7VlZcEjPY9e3T2qOR3LjLlP/9Tb /s1L/c81xNHFG4Z2RN7ckDv09Kybm2MLNBPM7mN+N4Cs6HoSPcV/GThbc/duZXsjPmae1hcWoYqx zsb9MZ6U9ZLqXS7m4LuJrcoBbnAEisQpI75Hp6VD93YHK2xg26XLKvm3jSRmXeZYv3TQgHhRj0x3 roWktI5YPsTTO8AE6yzkOWfr1osZt3RQuL2eyuILq7K3b6jI5lgDb1hAHLNnoTkYrCvrOHy4DcM1 3PLIfL2cpAvUZHTPvW0F7plN2Vj/1eet7otPZwTSzvFFA2EjTO0L0BbGByRjP64rJuruG0uLjUtT aSN2iNvYcNJEGzhcDuOeT2r+OYR1P2m7vczXhtYbWOPYl5fbvM+1R8bw+CUwfT/GtuxtD58kkdqT cQwiSI7vu45OB37cV1QXUcXZmEZEuZ5V8xgQ373cCME9qpwWzWeptcO2xUwkYI3iQHB+b8a6oq24 5S1E8QySo1ttheL7SrMGRSqMoPJJ6e1YifaY4/tiNJPbxcDyyGXI64z3GMVVhueuh//W8VWd7+JZ oZYRCp3ymVvLKAHBGT3HpVe2ngBkkjkUuwI3g7hyO1fylFXP2aTsjPA1aBYIrGWXz4WZ4fKABmGD kE+pFNl8SmOOOa/ha1uLoC3KW6HLMVI5A9cHJ961MJOyMqzZbeWZ9LXy7m7RhKSg2xFgQSozySOv Tv8AWpreOOCYqYIL6Xy9siXTlBCeodcEcjHfikncwK155UrpKES3iZNjvuyWYdWxWD/pEMnl2Zle 3TdcshiZ0mUZBKuTgHPv2pmMviZ//9f5MnvYdQDwzxuq28S5+UqG6kfr1rmr/ULg3drAtsjR31x9 n82FdjWu1C29+cYwuK/l5bH6ga1oS1mZTA9wUldEjIGZmQ9h0weMH3rKjvRqkslxJC8EnmbpU2eX 5e08qR7EV0LYB9zd6Lu8yeWcTJNGbW7WMSCILncgHuccj0PNWtRlsrjTZjJekXM+13hZcCVT0OfX vzXVT6Cd+hyQaUlobm5Mdjb22YpYYzNdpgk7Fj6NuJPfueKy7p/DUrXVzpVncRXcyqiSXhaK5LoA HZ4SBjPPA/OvVoLRHHPc/9D8zNaULFaO8kwFwhCl08tWKnBC+vavKdc1K8h0rVLyYTMVtSnlcxvG AQibfTtn1r8kwyPtaj7n5ufF26ubjUitzFc7NmbZ5mVbYnkEDB3YBzxj8a+IdbaS5kluvKZHkuTZ AMNxOxyAc+hxkfWvZo/EeXXlcZHcXFrcfYLrzfNjVdySA7kGOAfT6VciUw3skFpGZIplBWaVcEZx kfn/ACr1qVlE4JT91nouhWV7FpNxPaLYxyy3y297MX3XYiUE4UdcE4zj0611Gj+HItUW5tNS1KMm aBpLcFMRI6/dXPG3PrzWnU47rnif/9H+S7QGsrriG5XyrYuGeU7AdgJbGevHQCsPxtrc8HhbUrKz upktJXW4tTbQ+dDGpyrgt3Jypx0GD9a+bjtZ9ztfxJHzakHirTbKU6bfNpbXM3lx3i/M92p2lk5z jHt6fStWaUeWk2o3FxczQ26vNKIw7CUDCuc9gRnPpmuiHYya6EukkWHibStQijsZpLk5kkkCzecp XLAryMsMj8fWvadJ0KybzbpoFlEspbynBG3vt9QAOAK0Oe1tDntZM0F2sB0uVLa0mN3bfZ/34x0w oHOcDFaBuNPvNMZGE9veMm5IJLcxsORwc9M960prqKSurH//0v4zpGnFtcxXli9tcW8hTyrh9r7F AKvxxhhyOtX4poV0y2nupLOEX8W6C5LhnKnjapHOAR3HavPOeUejKGliO2mubfVbeNbKd9sMysWm ulIOW2kcAc9c55rpNGktk+wwWaBFjuHhtFCgbl5wWB6VUFdgl0OevTbQ6u80LCa8mb7NcXDSZ8lB jgAccEZPr61b/wCEcsNJluNW0nWJdTN9GDfRO4CiTGDhO2MDoOwrVRS2N1FLQl0J3e/ltp9Sns76 1gF9BpjwGeGVCSFbzTgrlsY4PSqF0kF3qL3UUVzaX8lx9n1Cd5tsMsgOAxBwCBzgnrTBRS2P/9P+ N+W+g0ud7K4v47qSPO0rjfKcZKrjrWZpXiSXUba7XTp5oUe7EMqXNmRBKUyWQseQVOMgetc4Hf28 ax6dBPIrC8ljedVRCbYonyk7uxz2PUfQ1z87LcwpLawROZ7r7PJLEw3RbAc/gNw4HrWcwLlpaKdL OlyZKzSt+6LErknJYn3qvpbNBK9nC7P8+ZS7bjCG4+X06VmBdtrHybuQWtxKk0YLIC/3u+G7muht 7xDb7PtMMM8RImtufPCnox46H+lJ3toFj//U/j81OWC0WMGOJ2mkClnHyAZ61M1rqM1sjabbpPMD uvLsN/x5QDO5/oOBj1YV5kk+U0cEloUZWvLGOKOxdylyqyR3kQ8yM4IOWPTPXH1ro9TWK4lt7eG4 MjTos0rsNuW4Jye+D3rOzW5mYWpmXStam0t52uH8lJwdhTIkHGPb/wCtVjSL/UbS4bStMj8i51WT yl8ptwuAOSGXHcn6+9IDpfCOpyeGvEn2+WG3eSNxhZohIhIHUoRjr1GDW3q+sWuq6tJqkEVqJ1cb 4YWGy2JAJAAGBnqBjvStrc1+zc//1f5L5bN3km1m1mS2uum54RKhPYgHv/niuWmeLRF05oHuLi7u b8rfzRQfMkbjk4HQHkV44HRanfx2Vs0sEa3UPlj902cyt2G3qDkisG5m8SQbbq1thp7HyJbK6ZDC GYsN3JGCNo7c0Du0rHSa89xaXMNtcNFdtKw3SwOLiKXcAeo4zzzSavcTTWcULXt1vt0yjTSFfIXs q+gHFKSurCOVvrm5udOsp1njkna7+zym8ffKYxk7174I7+9H2+6EMX2DTRst7hUuJowZYypYDzZG GdqknA6Vha2hlN62P//W/kmW3lvZ7y5hKWrvEIbeFcyxIyA7ir8k7vUURWEERtXuZlR94M0wyVj5 xnH618+c5ddb+HUvLu74XcTSKdGQTKIISAAWLZ/i9CRjiqerprCv9ru7C6jtnO5bqGMtb7QwUkyf d6kZrFq8rI3TujX0zxHPB9mjsrP7HdRyPGuoHEokVgBuKkYA5P8AkVd1q2tbCe3t4Nae5ntmWdpR JlWLfMwX1HJ7dqXK9hlCSfUPtRure5ijimBZgsQlkPY8HgZ5965yC6srvXFtb23hu7eKdTd2ksf+ sPDDjoAfUdKGmtwP/9f+Te9m1TXbjUrq00uztIHlFu6IgaCKFcKrovO1sKOR+PWoNR8I6Rff2T9t vLi52zDKJkFXC8hlByQPWvl0ugGdq1ncadvFrA00NttbdGhYQgnbg9wBwarfb7rSpV8pbdWjm+0G bd5iTA4IUdsf40GXL71js9O1TU4bS9vNStYnjaL7ZDGseSyudqrkck9OO350W2RBcSRW6+ZqKxtL vjy8Wzn5Cfu57+tBolZWC60eG4kt/tgTyYIDJDGsKk7mHQt1I9u1VrbxBBatbQXszppsELxxnYX8 o5G3an4EGqi2mhn/0P5S2vEuY1ls1kSUEuswG13HbH61Hp6rbLE1u13eRn9/fOISyhiOVJ7duvNf L2toBmac1rNJIdm2aFiJ43JMkTE8ZzxyM1pQj7LHcRJCvlyNvWOPgyMfX396AK0UARGZl+zM253D AAbhk4GOuf60um+KGuLTU9B2PCmuhLDcqETvtbcAGP3Tlf0o2M5Ss7HRmzuvCluvnWMgnMSSx3Mi meRwQdqt/UV12katpPiCGHRY/Mjz++lijOxWk5JZScYJxSehmf/R/lW1aGG8uJ1RoZ7OOQiEE7nj KnBB+hFc6Liz06ZYw7yTzSj/AEZV34JwAVx245+lfLnOaf2KW5tbi+nuC02nzmUW0pEar6YXrkfn zVXSNUttdm8xJYbfCmTyQ+75h/AMf1oM5tXQq6eLe+1S4n021T7cojSO1PHHAkz6nv8AWrj63qcN gYVlMUGjRYs5LVP3zOSSRkctg4OTQaJ6aFURJNbRzLoy3GpBv9Lnkk8trgsRl2Y8DC+nXFVdNtb6 48y92TjToJD+8K5jlYE5XPQ49qDCH8WJ/9L+WfQ73RrpL2Sd3m/dq2jyQKVuLKUEBgecc89RkVje IbrRtc1FdU1VL63t9JjjiaOBfOS4kQLy65BJYjJA9e/NfKqSY5+7exoX2tWmq6C19pUElvp8t6LT zZ4nguC6cBFDAEhuemR71yEMKyi6WSNlWeLyg3eM5GWBxweMfjTTTuZ09jehe8s4LC2tVnmhijCS zW8X2jYnAHmHt1rUurhEuHh8wuLRgGO0r94ZqlukVu2jD1a9uw9tPYxKGt8/PEmOM5Bb161fu78a vp9tPDItreKCrh2CRlkB3Mc+uOPX8au15ij1P//T/lbvP7Tv/D9o1lFa2AnhV5dThZXvCy4B2oSR g8+nFXYda2WrLq1/I13aRoLSWaPesrEhSM9iBk4xivnzGXxMy5VjnNl9lhhmkWfzZJhFliWwCx9O ldBb3FvrOq3FrBB/Z+nW0IT7RcDAdlX5wo6n29zQPkdjAe107SJbqG0hjYzyfaluSCJ5c5G1+cYH Y9cd62/DU2mavq9wNVdbXSRZMVleNmfzlB4VVHTI4J9amSuieVroYi3sUE76paXq2v8AYl4vksYD I0jhvlCnBxt4OO9O+3X11Pd61d3Ubm4k3tZtb+VPdFs5kkOBtbOOOOtYmij7lj//1P5S4p0u1CX2 m+ZMJcJbGNpEcZ+VsjHB9eMUtrIljPJfX0MMWkq5iaG2mImhbHyoVPOzOPm9K+agk9zFL3WSxW8J iudVtHWxspgVEUZ/0NWJ3ZJ65J55NFjqUlos0DtP50qEGVEJDKSOCR0BoUbtokyLv7dfT/ZdkBVX 8yGdpiksR7EA8fjmr+lPe3d5JFLDLqFtbIVguvs/yRPEdr5I4yP5A1A0+XY6fatnaXtxGsWWQIzu +10Oc/KP/rd6xYZ9JfyZYLZBeeaZRPLanzTxjByMY4/GgR//1f5WLH+19SnuLWK2a5hu5lgWGGNU dlB546jv0rVm06xYCF5I7S1s9zW6TKXwwBG3AHU9PSvlJrQ5yuh3i3+0fv2VxDAlsmTDGMBQB0HF WdWsoLecXEaSS2zsECTEZOBntWQFzQrqK4triW+drRvm8lJosHCnAHuCORVc31ndpd3Vk8tyNOB2 QtbEW9wR1Bz6e2etO7WxXK7XK0cu+NPIt3mNwdrIASit7ntz61dubI232VNIuFe8SUvqMMo/dKP7 qsc555xUylZXY1B9T//W/l1jjnl1UW1za200Dw+ZcxSMYBM391BwDkZ4HNRrawJd6tJaiGz063lV rO1Z8TybsbgB/snv7V8Yp9yYx5dy1Neae7K9llnW2VwG42SgDd9RkHp61SD396konmMcc5w8akiI n+8RT543sO24zQ44rh5pG3JHaSGJi+PLmOcZWtLUre2kkik897aBHWOS2i/5e2PA3cdvb/8AVSae wzQt7VbL7MNkckUcjTecWLSAEfKpGecelM81dREs8dsVNg7MsmzaSuOW+gzj8KDaDuj/1/5ckjaf bHA5hWWTcyRgDzDTrjULyeS30m2lhgu5JVS1uJUAjibeBh3/ALrZwc9O1fHndD4UbralbaZqM1jq V/p8FwkotxLZ3AnhnPcKw9Mmtv8AtKOG4EVsfNhj+ZLtBuVz260FHI6lqmoSXly0kLywyYFlOf3V sj7l8wcA5IXtx1FammySeTE83mmN32hpBznPXjj05HrRboAXN7f6PLJfQulzaqoRLZgC4cnk464x 3xV8Lb30lrfaXPLHILjGo2k0Hlo7YBbBPXr1HpXNJNkysj//0P5tdRiacm3eZIIShUSI2JI2x2Fc zbzXunz6daxBJ4o7hmlmmUGQ5HU+xIH0r4c3vrYxr3+zbZEv7RUkglvza3FxCA5jOTv3Ee/FdlpW l2qQ3RjnW3s3hLQxLGAzFj2HvnP4U0ruwxYFt7W7itNMS7vVW3Ely0q/KGA+YFs+vT+lWLpVlJZZ DbBTvfaMnjqOc+mK0ULaAPsLu2l0q+1K0kVRDcfZZW2bZomHIJyM1x6TzHW2mbVJJE2KzI+P3rty SWx16dMVElZlRV2f/9H+a2FUe+nWylUmOBXJuYSkbMw5CZ+8RyODxipw6pM0DRyrL5e9uD5Z98/j Xw53Ne6XrCC3njea4mW3S3OZCpBIx14rKvpbe5dmWZo41kHksrbS2OmfY+nvWL0qGTdoXK2vK+og JFFBbQzFSUtBw4UAcjtkjP4VPYaestsscpzxhnPynHvXTPZGy20LcdpbaesVlaEmF5gsHlJhlZjk jH55rVubS8kiW0i+2/ZWm3yzIpYWrDkbj2BIxUFJXdj/0v5vpY76SOZEaGKeIbUY58vI9e//AOus CKe+v7rN2d97Fb4ht0kPlhU7Anp25NfDnoHoOkT3t1axiaOM3S24hO87YxhccsfT19qz5bqMNJbx SN57LulLL8o54Cn8M0FKLauUZ2u1ijEWyRhMpdTyu0n5q2Ps0EFwqQoJssGMaD5WJxkAfWgTVnYt wW9y8wikt12qDIAeNuMnpVe8WK51SwunUTQ2SnMfRI3XO1qCJRuf/9P+dVLK4u55TE+XlkL+ZPII 0T8TTrW+miuRYXEyTBDxMD80bZxg46/n2r4PqkbVFrbzNWaayaYNey7olI83+KQjpxVJtSjt9PuR p2lMWN9iGdV2mVWChiWHHHB6djUy+JlWLNlCjRSOx8u4bGJRjfGM5K88c8flTprgRP8Auw7oJNhc psPvj6e3pUjSu7GhI8fyjf5kcqBVEgGBTEldVvITOEiEQZVIzuxmsHubn//U/nmtrq4VJEbzhDJm I3A4Vx128enFXLWWa3VpY5j5UWGLSAOuByc569O9fnC0PQEvIxdTvrSH55Y+VhAWKccHO0cZ9Met WoVS5tlubUCMxLvKOdjAjr15raOyLhvYjR1l8wxyMssku64iI+82MBs9+n6VMLS2tTJPcxrLLJHs jckgpzx+tM1HagJJoITPtMzIGiTdklR93j8sU6wku4N5DtFhNzArlXI6Aj86COX3rs//1fwCNx5s h8stBdOuA47E5FTapJJZeTaiJ3uXC7xEhcc9TuHAH41+ey0iem4O+hYZU0fT7Wa9imkW5mIiEa+c eOWyM9BmrMmoWErm6aWGwttu6LzjsA9AfT8azcrqxLVtGc880qS3Us8kF0srbY5FbPydVA+gNbA1 kWFirPEhRY+Ei+Zgcdh3qSXe2hYsZUvlSQo0gukDqkseJYs89OoqKWOKPUnigcuMLtz0Q4GR+BzV KLtcTlZXP//W/AiU31zdopY3EUasksKDaVcEbe3PG7qe4rqZZBFDaW7RR5UEqSoEik4yM9f1r83O 6LuixL5tnpypIsbXLOZY44+qg9Cf8+tYFpf3kckplLzh5CWSUYUeynHSg0jJx0JWvbeKNgIA19cy YAJ2xhQOB+eatiaVrcpPHjcPnVTnn60F86IrpZ1iikh2jzV+bPOwe9S2MFi0Ly3MzeaDtjWPHJ4J LDrjHpWDVnYakr2P/9f8FTI63v2oq+E4iVuYgVPBIrpFlkuI5pXcyCWXcWBwckAH+Vfl566dyLWb X7RDbNbxGMRIIyEzuJOMmtbT18mySN18uTB3yOpHmD2oNYSfwlZ4vsjQGGUx/anJEykZk2npj2rU XUY7CcXGp3E0qiPZG0EJuZEYcqMDntSa0sbRk1oY818LqSWaESMkfzuI0LSEHjO0c1sLFdpGiSSl YZAHMTDJYYyD7daLK1iufQ//0PxPtob1pTNprRXNihYXTswW4iYdgo6jPc4qWG41W6mmCeXu2+TE WYNKygDgA9MYxx2r8tUUlY+jjLl0MSyvbuwuJQ6E+Y5WfI4IBzz+QretrrzRcXFsViuEXeseP9co +8Py4/GiMeUpzstDCUGfUVuHgK7Y2JiO5UOSDyAe2KvXE12IXe0wIiwEwxnGD2NUZFu8027trOK+ tVSQQyI10N+RtbqQR3HFZl+RqcKs7NECRiRjmQkY4z+FTJe6aw2P/9H8SAIIbdGQTTzltu1I924D vmtO6Mtn5FwEZ4So88qpZ0Y9BivylRd1c+oM7UF+0osobYWOWDDD06z85Ij5O4rHxIfX/OKuUbq4 D7eRbjVIra6hZIJELGXHII6fj0q9e6ZElzBLaSBYR8spZuPrWLV1Y1g9LF66srh4TLFMjMiBBiQF iO3HWq2hWtyiyPcXxaYykJA+NwHc9O1ZuFti0+qP/9L8foCbWVpXkMjKx+YngUmqaxLKIUt7hbby 2zcMUDNKvIKgnp+Ffjso3Ps1NrRjo57gTWskdvDLb7dr3JbEqnB6Ljn3Na3npbrPOpbLcOUXc6ds j6ZrKzRqc7ZfZdSZ2W5luQzMvnMNrIykgnHY8VqR6QiMlxFLm4j+V5cje6+/5UWaVwILizuRfQah b3E4kt0KvEH/AHMoIIw471fstauHafT5EMFtajzV2rhCzj5iPyFK2oH/0/x6nnin4mOyYP8Au3Jw rjn/AApVWeWW1hn+W1aQssy5MceO5x7fyr8bjDufb9bFa7v2ivVt7VpNhTCkHcue9SWWq3wvgk0E FzFGoUbHZvmH94D/ABpODWwxbt9RluWnnmOnWxBF3DCu9SMgoB6gHHJrSs7iOWNxG+BGOoGTL71F kBWuZnkmSBxGAU3B5W2YPbNWpkltYI7gHzURRGHj+dF3cfzppN7Du1pc/9T8fvIgRfOuZXd2lGUV ASoJ4ra/0We3UxzK7xtjy2BBHH0r8XaT0Z93zs5/UZPtd1Ak0z28UA2ExIF830yev5dq2JbW5kQW 0d0YoAolV1fDxyDgcdCMetKy7C55Gq1tcTNA91eyXl9CipJdNx5m0YAx04AxTNX+0QxQCYebFuLw Fgf3L46iqs7XNIu6H6a810rtGSZreLMrgbTjpVjTpzaXyLKyyNNKP+PgZijHPLe1TZGtPc//1fy6 ilsnmuYzAZJLkGOKWNivlHPVV7596p2ds8a3FrAiqkZaQqTtyM8sa/F7W0P0DYzlmeKUok8gDtsa HOFf6j60mn391Zahf2du0cpurURTK0eTErEE4PqcY+lAXRNJai3mZikZjKAoyn5y5PII7dKz7ua6 WdkdkjjgUMAp8w9M9R/Kgwbu7mzp9+LizTUhNAFEvlJFu2zNgckr1HXFQ2ky3urGaaJc2JDW7GMZ DHqVapkriP/W/LXWbxnXU4EuZg0yZIgypm7gNg9u3XkVjabNehB5wdgQCpkGHQjjmvxFxdz76Hwm hOLyMM5idjMPM3Dpt9as6WJJXS4lkdI4VwtuwHlhs8yfU4qSrFzWJ5btFtl8mSKFfMmZVHmhTjGT 6Zxx71mKHhS2t1BkV8uzDkN6AjtigfQ1UvfKjCXELSoX2OEX7g7Z+vSlnSG9+zNbq1vFbMWeFSG3 jBGDx9PyoEf/1/y6n/ssi4ktjNEgfa9tNhoMdGKN15Pai0vI5QFt5JAscm0owITGO3rX4efoBR1Z ntAbmGS12eeoFsWw+M/NtGc9Ks2d21xGsogUeZJhSAd0fXkVMotgX/s5wUuZHZs5BP35fc1TEklv K7RExHGyLBIYZBB/r+dZ8rbMZO7MtI7uxhl1FJIzJ5nlGLd+9HQ7selQwpe3j/aridhCM/u0IUSZ /vfStiT/0PyyR/D9lDDDePewSTTF1mtIDcDOMhXHQL7k1oMGuA0s1ys2AqRyKu0xrj5VIPoMV+Hn 2c2nsYV4Y4bhUtG8+V8Zyu1Qe4H61LZtKztC7eTK5w2TsH40EGbPdTxzy2jxtK6/OrS5Crk449en 61a0bUVj1W2S4lSWSL57WJnACsOmPcZzW0PhRLvZmrq11KXMWnQTRXcjFtWkkizFNk/KyPjk8DPX pWFCCk9ylzeTyCZVSKLaPKznndXRH4UKN+U//9H8qtPs7eKbYdkYTnKLhV49KrXN9++mgtsyO6lc 4I8v/aHvX4+fVSvfU0dHvraW7jgvroLJJi3R5mwqsBxu/LrWL4qkGAYZ4IgZQrvCgeWUIykpn0I4 rWGxI6wjlv5ci4W32AS+ZkIABzgE0+4tjfWpaYForebEMpOCSOePbirGm1oinBPPcW72zWlzA6OV E7R4glVTgFWPU06KQKrNFG0X/LN9ylQ2O/Pr/WucLvY//9L8t7ZTNABtGAvToOlZAW22XYuTJDdG XybQgDAHUv8AywK/Iobn07dnYZDGkSPGZXdpOruQDJx1rOayLyRrtcQtMFuGRsOFzzitSIyvIdNe 39vdvZSiNbLaFt2jbL7B0z6fSppry0EcUM8m7dINiuM8jofwoFNaksNmZZGWOSNXY4iYsEQ+nWqc 1o8C/wCmQJKrtjlQwyD/APqpNXIP/9P8p47+/jhjkW5a28vOydh8wAGFUHHbik82e0bzbuI3E1zt ZpCMGQNznHpg5981+ST2sfTN+8iqLPRo9P1Bi9z9pF4lxDBgyDcxGVB6jt+tPn0vUmjit7q9CW24 XEYSffCeDjOOPWuWT9xGif7ttFt9MSHZAJBLOYhKSWBGD0A/DFPsr+O0uZYZo4sxRAJ5mQJM9QPp x3qY7oMPG+hQmMXnq9tEsUbEBgpIiHqfb6VPeR3Fzp8z2rQ3V5bKcRyfIqISOc/Tn8Ktw00Nj//U /KXw9ERayurMszu0VwhXhk44yeoJzU9411pNqs1hbIkeoSm3uJY082UAYPTHA6c9q/HIppW8z7JL 3WaNlpkl9aSXtnfm1vIivluMeZ3+YfTA496LWT+y1WHU4xPPOCDKmSWP/PQn3xj8ayJK88irOjaa +9LdzM4MYdpuOVKnPfsPSorPUtRW+m0+5M9vaTFJxC6funcglSB1HUD8aAOgRJUuJra8X96U/dRq N0hYjI/PNMJWGwuLqVGRbRx5gIzwxxn88UmtLAf/1fzCW4urz9zah/LkIxCgO5+/StJzfWFk6Wsq rLLgeXLkJkev61+JU9z7AoW91ctLbyTRNDcXAKGNwCmRxkE+/Q0qteXV5LZk3EkgGY1yXVAM/d7D oa0ewG1ZrqN9CwBWLbMLSOW4ITcV4OfQYHBNXbiOSOeS3nnSRrJfkZG84Nx0XFc7V1YTdldlWyS5 mkuPtF41ncFGMI7svYAHgZB5+tWkS+u5FiSXKrG7FQo3lVG5jn2HOKwEpJ6H/9b88IlvLaeHzXW4 Thx9oUShxnG3H4d+1awkurnUZLq+tvtFpMMI1ltgW3YLwpBB6YxwO1fgk1pc+vur2KF3f28CxWtt pFvA8UklxeahFM3n3W7BAdTwuMHkdc1aiOlzwiSa1uEuPs/mW1yJPlYt93Axj61ySVmM1NOtU+xS sEaS8ncKS534QdMDsfp6U2OzYKsSsXUkySqCdw68VkoWldAPaG6aX+0bLUJImtoDbfZzOFQjPUDq fw9aXTri91Zk0a5LzzRk3MU83EEeDzx69/wrOSs2dlPsf//X+JGj1K2naOzu2sPtUZhnaJ9oKjk9 fXHetrTLjXImiew1DyzZxs0jXEQmDDgHK4xk8/nX82ydkfoBpNf3lzfy3syx3ZuVEVyHQKMAYyMY x+FcjPbEarNd24aOOAGFopAVjwcN8vqenIz0qYzSVmA+axt2RbpZyJYP3sSJltzE8j/PFbVjeWu2 W9v7ZLi8aIwJN5W+85Hyog6nlRxjt9KrmV7AQLdqsa2M9zLO8k32ma0mT99bYJ2vt7DJI/CrsaW0 0kVmZW8rzgiXN0AGTceWOM8DPb0qHPojB7n/0PkyzWOxudZtrq8j1QxXTW+mXFsuLUIMA5frlTnA 561bh0ozzxNhRJ1VmYIFzz1PSv5jn2PvKb6F7ULQefps7SxrLbqbZbU3I+y3JZh976Y46d6u2MNr b3E8TabDp4snzOASyXTHBLKQTkZ9D2rGXwnVCXQ66eOeO1UrAs5cBBaAAMwJBBGeOOv4VcsLBPLW 8v3FnBbPudSy+aw5HC5z+Vc817p1weqZcgAkuLlLO8lltZ1G2IgLHgcg4xn9a0TrQ03T7nSJLKG4 hmuEneVlDS2zICAyHtkHBrjl8TNz/9Hzuyme7EkjNJEjHbDkHDbSOh7da6WCCbaqws0bTrt83Hzg HgkfXmv5En8J+sFgQBGZFkWUpJ9nZ5D8iE8ZYnpSt9tso3N6bO9S2kMdsInDmQMSeMHp75rK3QqO kkX8h+JYvIePHlxrwOnUirkcaR2UzSbmM8g8t2JxHjqAPes3DsaRknoXrWBZLM2+xUitpzGyLgMX ZQen0xVIQX1leSxRxvBAiJKTNtEgb0UdT2P41k0nuO93Y//S1ZRJciaWZkKld024cP8AhVXTgIkv bpF+zfYrqILPIQqyK6kllHsQB+Ffxm4O+h+xqdlYvWtqyWN3PPPJNI1yzoduPlboMD0rb0iMwQP5 ShhvDuSMbcnk5we38qwnC2popJ7Fe917TTfwxo15NPcMymRoPmjWPaGZjnpkjg461LDdXN5NOkDj y4kDNNK4R3A44X0HHeuWatqF09EaMlzEjQTtCkkq4UluA+O9R394dSaCW4bMiILd/LO1diDCKMeg yCfpUFdLH//T9FvLuydUkLeTHGBEAvKR4wBTtKfypZVDM1yhDySlMLIuTsA4wcc1/Dc11P2lOzuV rmz/ALWW8+1QM1vDKFZHxtfoRkenFadtpF/PdwNGYLe0ntsxMrYQkcfN7/L09TUJX0RoprqI9rGs k8VrBEks8SxPtGWYrj5vqSD+ZqHS9JuYrqaS6KyxqS8jSDLJgjChccYx+lNQd7Fp9UdUssBlKW00 aiQh5TKArnAwDn9PoKyri8uDEZLXdZ6lZ3SvFcMo8iUKRkH1BGfzrRQS3KUmj//U9tGy+1QX0SRQ +a+Z/tE/7t8jJbb7nPT1qLT7GWA6jPd+WNzMsLQ8Op5wAc8g/pX8PJJaI/d7q1yhaTX8jf6SVtbC LeYEnwZHYYOcjuQvTPen/wBpK80TRmbLnZ5ZTaMDoxH4VE+wlJN2JlNvLO2JZEeMbtisU3Z7mr11 FBdxxQm7a0+UF5SfmY55AH+elZlEV1DFb2jm3uopHj/1ZJw7Adyvb6VhO19MtszXmyAyYBHzmPJ5 wO2aBNJ7n//V9auINNJNpKZJJ5ELBmPEvbJH06Clt7G2tUUC1hQ+WIldU+bAOetfwzBe8fvBNNCg l/dO0oCjCY4Vqz57XW7i1leK/bTraSU2spgKtJMOpPIJHH863SbA0obd3SKCK4ubpbWEIJLgjdgd eBxz1OPWs/MumzySNAgRW3R7h8rt1OR/nrW4pK6siw15ZXKR3UaC3v5ZCJEj4jAABBB7c5rMjjEp unEtwhkLGViSSxxz36GtIX2MWrOx/9brb2e60Szi1W3iS9jN0sBhy6Sks6rkcHGAc/QGtdvEup6g tuLiQTbVaOE3LZZdxJA3ZBOPc1/F5+3taWES4zNJc3kFvvmhEExjPlDCjAIx3+tc+0+nnUlSJmNx KGSINlBtAz9M8dB6VUXZmLTW5l6vLJFdJaGZ2jEYl/dEqMsOQSO/FX9LVWhujbRpb2q48+PzSQw7 cE54q1JdQV1sTz32yN7aOVLeSRMRvs3OR6D61JcjT5tNtLu8ublrxPlLbQptwhwvXsRnjFEW3dGy 2P/X665kh/s7UvLMUsNrbrNvZmiYMxCK6KD820tnnjiuRRJQ9t9tuJLhY1VZrxk+eTgDJ6AdOntX 8Yylc/cC3cW0MwLQXKHau5BnGazLm3k8gvCHa4QYgT70ZftuHeoew7nOxPejT7hbuBYnOfNljHyr 7g9qt6YHnsdwljZpYzslQYZMZwcfrQrpaiKN3FezKq5BYDYTgB5MdwKg0yacK0aBnkhUpukG8kdO vqa6acdkRNq1j//Q41GvpGmaC2S1lRcSSyoVSY4+978ccelV9QSVoY5JU8+2EgjWVTlI325YYNfy BGN2fs6M/TmhlmlE1s7eW3k2l3yrkntsHHXH5VrNPHPE1pMzRu8ewsjlJQR3GK6acUh7GfLO1pfR JGVDXI2bWQOgCLkk8deOtJq0sICxbxvKb2DfKx+gzXXGFnqRKetkc+IxL5khmdj5QQrKxcAL0xng fhVVLwLFdRNGwtbSLzC4+6mSB/hxVNJkub6H/9HwWUW02nXMbRt9nI2zEDbDtbOSx7f/AF6bp+n6 XAy2wjnaIW53Rq4RUIGAA3PHSv5XStoj9gb7mwAtvZyR/aYYPsiAQxSPtlYPx+77nHU1yt9bNIEe N1leM7yjrkKf60GU3rYzLdpbdzewFYrgSkyIgygI7DPYf0qynlRWs2o38rRieQpEzjL3cndVGeg7 noKzel7mbukyNYbWOdZmWS3tHhCt5rb0hIXnHYZPbtx1rPjT+zZC0l7dqjxmCO2MgNjtZskjuCT2 6c1cXdGB/9L5iu5JVszF9mt4hcIAJIcMzIOR7jt71zFveQRT32m/YYp476BNl5K5E1pKCB+7A7EZ z+Ffy3B9D9OclHQghi/sC3lsnE8bo7eUGJyu4liQScj73FYMt3PrF3Lo6wTQn7G1xcanEhWABWA8 t36BmGRg810wk3oSp9ybUYBDDbRWMKiILsmTPyKfVePbpUNlZ21trBttZWWRdPXzbiyikUiVmU7A xGeARnj+fTtprYTmyK90m9F5aagYDFpslwVxDcLHcR45DKDyR0GecH1rB1XydP1CbUJHaTJBF7cu DKNxI2n39++a9fDo5572P//T/NzVNIe0ls9Tl+x6rYuiGa0S7DNHEzBiVwPlkHX8K8f+IcsUMMws GkcXQkgt1aMF5F2ttDjpnp+X0r8mwyPs6q90/NX4nvCBqrXbzm6gna0sbUxbXnb5n+TcQADg/NnH PoDXyTJI/h+18QW2oC31O81tw0CvEBDpKKweJoSDxJjg/wD669qirHl1jiLX7bdG6cBp3wGZsbnO PQ/hWjZ3ckE1qbneFlfykBXdJGTkDI6/4V69KNos82T0aPXtLtrWOK5GluLicIJT5n7oyMVHBHOB wRmrn/E4tjYTjTZJFF1m7MZzDCmDks3TnOBzQcjkudI//9T+UrVxoOmTyw6jp91f2LIUAsgA0Z/v 4A9O1efeO9QWx0aysoYJP7NZGms7MMNrQtwWbHoBwO/NfPOFrJHal7x4fdwR3QjuReSJbKAbSP8A 5ZRN3IPYn+lUWeJYL23Dm68wYcROBgkjk56gitYJp6imranQ6HpLxTRpOy2V3dAJYhlwoGODuONv Y17HZ6jqGhDT7e7kJ1O2RjfP9mBs5c8KwJyCCDz781qld2MOX3rmmb610uO2iN3cSXl9G07lYyUi WQllTcD0wRwcdq83uvENtd6nIzK1ykMnlK0I+Viv8Jb1raEehDjY/9X+Nm4uYdXghuZIZbbU/tTe YCfNRoVG1UJ/D8jWXqt9bD7Is6JDbWsi7WijK9wSMfh2rlUUlZkTWhJ4gaGxkSawmk1GKS3jMcdx mGSHPVNvPTJ6elQWeq2d1NYssrxeUf3kYQx7iBgrnHIHPSqtbYiOkia4ghW4+0WtuiRSzZWOJS2e cgt3+tdVpVnp+n6bI8Wkpd39ws15CqKY5YHO4GTPcYGfyoNjItbvVtRu7TVbm+0soLSPSnuYpVS/ u5kJALL/ABfLhc/7IpmpJLJrmp6JcwzmZLGOZ3aIwrAzMfmLfxZAB/Gm1Z2A/9b+OePw9pay6fpd jod1danYF7ybW7qQObhWX5QqE8bcN0zjPXgUurpfi3traDybSzhujNeosOTcyOCA5xzkDjIrnAyd FubjF8sctwbeaYwXiXodYI1Q43Rrjpn0496rSQyeF7Xdo0y3hMrXUcVw5IiLtksRg5XHb2pPZglf Q6GG2/tjT4Llr6ZLmNPNure0fZGAc+nJ+mKW31LTV+021nFLDcxxqbiV4yGbjAbJ7cVgW4PoOgt7 281W2v01GSLVFt1tLCWCKNFk7BJOMEYHUjPFdNduqWzXus3FlBeQlLG4+VLWSQYIVh0z06+pFBUY WZ//1/5BLiexmgaye0E/7ncsrE9eg/EYNWbOIaPaWcSsqRXLF3LzbmmUnp19uhrzzaWkS3qN5La2 wtohEsckIeOGEhodvYNjoRjp7UXMAXR2V/LgvJgFtrrdsePIxtGeKDExLO1Mt1C9+PtN3YwLDezS TbzKobCscY28ED8KsapZTprNvc2MZthFGJbaSC5L+XuGQCQeP580nFMDct7C8u9pFl9oukiWFZIl aa5d27BQOc47flXNyW/9m6tIotZbGcuTqEKwmIzPjG9wf4hjH4UuWK0G5aan/9D+Rq41FEsrxfMl UrGph8sb0DFgOfSpLSVoLcHf9tndI1keNVclH2tt5xgpkA/Q15bh2MnPXQq6tEHubZLW4lFkkxku C0KmaQEDI69f8KxrjUNQNn/Yk0kk9pLfCaIs/MCknI9gMnpz0o5Ac3sjqpNJGmWMpRBJc3brEl2s u+SBQ3zMmTge/fiotMvbNpJzqq3pnsi0srXNiz2eoANtXDfdxjk5PQVDVnYXO7WDWbW1lj01Fit7 VkndmiWIxSiBgCCGx0IIIHt9DXDwJJa3Op2dvfXqaffymDCtiYJuypwOo6EDsaxlG2pDP//R/k9g hn0hYUjbzIooEMbbQS21R8p9+MGmNr3hu40+6s77Rnmvp5BdNPBIYp4Bxt+ToeR9a+fMFZbnMtpd m1lqS2ozLIftgmupGV7dgPlKnPH3QPwroLO6vNQ0ua0llUxJDvlguZ8WkKp9517FjxwfWpUXzczN lsOtJHi0WWO2topJlYOt8pMjLACSYwPu85znrUWqWNpqF3pr2MDOUsl+2SyNgM5/u47AYqrWFza2 LMcFzHBNp8EMSTL80VwdwXHcuewGPyrnm1G91W106d9MtLKWwu5LR5oAiNcrnaZnkH3+MEA9M1E9 ht2Vz//S/kyKNpQaOyuZZSX8wS8guTjjB7dvwqlOZXW3vI7lI7kEtcRK5Qxnv+fpXzUFqLrY6GG4 nNldWsmy5Nzbnajv5azEDgF65e3hM+nhJ9Gmtrjc1utsD5wkVeAB6cCtEktCL++Sx6ReTxvEmoS2 ckChorMHeJQe2cHGPrXTzXg00wMjT3kMZS0nmktixVmXByq54GTz7UuWPY0IFbzLgxJcO8W/fGs6 8se3056Yqe7hieW0hWKCGTcUjWONSAzdWkPpx1PrT5UK6R//0/5RZbW7h1GWJZFMNvCFkwowHycl SO3StiLXby3057NCtsLwiCZbThbra2VZ8jk/4V81PcnnQzUbq+sbCe3Z7T+zr+RLqZVhie6SRVCh mf72Me4xk1zFpe3ciJJCEkWF/nbG7co65rPRamfM+hvzmw1HTbee3nlF35rxzwp/q0C7drg49dwx z0rGvxoJgl0i4aSC8YC6g1CyybyUsBlO/PHpn60ySe7tr62ltLZL68ubb7OkqLcMwbdjaS+eCcYx WNp+nStfyPHczNOkhkRi+xlIBJJxjPrzSaurAf/U/k/tfs9pZmJZDM0lzJvGPnQliev4/pSf2Zp5 CXL+dFdNIRGynaGC+/r9K+Vj19TlcrOxvSaZJayoL9XB1O1F1DIYzMlwpXguw4BPP3sHisY6dYWV v5On2Npp98gWSVrVD+85xjnt17CqM57k819CImlhdjNb4DBhkZ4yMVp+H7e3uZNUm1C5t9PuJLdJ NMssFhMCfmZ3JwvsPbrQJNrYiuS62VwtvK058/8AeQqA9ttB2sSR6f41uaffW+paDZWNvPFDDDcO h8h1MDngDcB/d6fhTSIg/wB6j//V/lFvLzTfDF0NKjsbiK7uWN5JfGTzraTJKnYAPlPGcZPFLLqv hiCK1ZIL37bLI0l4kqbrW5kZsLsGPTrmvkIpu6HU1uOv7u4nnjs7SJY9OGJ5/tBMcaED7yjoCPbn itaeKG0sZNTvriAxRWyRvDEAy3A4AKgDOQByf6mnF2ZnT2Etbq9u7SGHSXisbVmLXgmY20syFTtX aeeuDzWW1tL++eWQnD4lZn64P97pxVKfvJjjb3pMj0yz1Bre8H2tWhafdEUAbAX+E/571lCC81S9 uH8tERH+zCC3Uuk20AFvqe+O9ap21RnGVmf/1v5Mov7Q0+7ELtNJYg4i24zbgY2xhB2znntXc3r6 PcWEtw1sF1CONfs2TmB3GAcp9Dxivm+cxl8TOTs729soLlrawilnEojkV5vKeNW6nGD2JP41dfVb OziD20SLdxgK9jkwJsGAWRiCM/X8+9WmmjWOqItc1qRrqFBp8kMS26ul15eBMGGNue+O596XQ1Zb PVgZZGkii+02SIm/fjG5COvPP5U3tqM2tKW2ltRc/Z42nyJ5LCcbckYOWHfp9eKrXh82Sdr24trM XUvyIuMAkE8Hpx6Vzgf/1/5f7a7aJodOuWiNxbWfmJqCqIzKuBsUEd8dB71g3dtbvHcefJBbRFDJ Nc3LhcAZPI98dK+Yi+VhboYos2U2xgaSPSpIRfKWkDW1xjIB8sd+D1H41eUSXcNyuIbad48wvAQy EA4AI/D9aadrmU1Zm1pumafA9tdahEt4YxvdMlMjHTd1FQ2N1BCt5JocbWdlFM8ksdoNsSbieD+f frUkHPTwtdR5e5keF5TLmQ52knOCPSs25fV3v47LTGst10qhLm6m8pIGTgkewFAH/9D+WzVItStA bnRdTghntmSKa484L5rsMO0fdgCGGR2I9aiN7p72qi5/eyQ3HmXDZ2qF24xn3yeRXy9uhzkHh8W1 jdCVN8dtFvNvbp8zeYcspYnJAzW5HZzajK32hlJMmYQnCxg44981z2toXBaljWLbTre7WyCtHcJC HKOcS7D0OPQmsR7yDT0itrVorWO4mMJt5/3SM453c4681MvhNSaGzvlR4Swt1nXzot0nlQzcnlW6 Y61RtWuNkw4G+bBZxvZXQ8MPbv8AlUz2TGld2P/R/mEZWuJma5uZbpkiBilxsdCFGffjn/GsqJhb GS4mRJIEbc8kuS+B1HpyK+HKcWtzMsU+1apqVylpJZaUk3l2gfqEblVA6jGMVvapItjarJECz8Ri Ptg9D+tBKV9EZ1rGoiSN0fyj+8aTmMRuTkgDuPer9xcpGJHMs90UYC3CwGaTGANqgc9R+vpWtPYp xaJZJryW4mkttiw2VktzPazsFMwJVGIJ9ycDqaoQ6nG0s6bZcPGPlRSYhzzu4qzWKsj/0v5g4f7M Wzkwk7XskoEJRwsMY43ZXrWbeWyLKzQYkAwHVz82cc4/HNfIRV3ZndBq1hkOl6Y1vDcf2ckeoPdu 7sU/ennCn6nBOevNb9obmCCRY1T5xtAlTcEHTI96bVm0EnZDTcJbxNFd4e1jyyRs+0Ru2MsB74Ga V7+6kNmybYrOwRtkDRh0nJYEE/TFSNO6KEsks95JcCQRXJYS+akWViwckhBx+FdNcXtpE4lCz+VG qzG/8wIkgK5fdHgEEHPcjHr2ykvfM57n/9P+Zx7dbzUJZ7edpVWJSPm+QA5IOM9eozTUuEknns8E 3cUe5CVIX2zXw5TbTZeisbMQm3aKBS6bp7ZcCFG/vgevfNXdFmRTcQSrGrQNmKR2yHAHoR19quC1 uap3VzLvTFpEkk1pdSxfbLgPcRhjIpHBIA7A4P0zxWjDfWl/EZLfay7tmerAjqCPX/GtRlOKazuf 7QtYEEe248iQr9yVgi7iR6jIHP8AdqhBoenQzeZbpdXE/V0uTuijYZ5TP+eKia0NKfY//9T+Zt7a 8e8TzJrlIox51sIYgIo2Awys3YEZ61o6bPHPqNutzJc2cEERM0ros8MxGcRnI6H2596+KktEd70R HeazYNquoWtrbxNA+0NbYI8kkZ3H2PYHpVa/Aklht4UXe4JLKPkTGMD8c1zS+O5hP+ExEvls7uK1 vIQjhMQi3JnEvByWx0rpoIPNyUmj2yxZj2NgoT2bPTpW7dyoVLxRUe6tLDypL64lt41n4mgiM8wK /NkIOvT2rX0jxXpmsWV2bC5vI0nLJNPPA9pM7DlWMbDJB45561N9bG1+x//V/nAMzgxpGVfdIDMz dSPp+VF5YQxXQ1SOzurWaZBCZHnPlTKAPmC4/ke9fDnoE7XTkCOIE7hj5DwaokXFuzpMjGZ+EIXJ UZ71POje6JW+1+QwiTZcocFJBjI9QP8AGq1pqV5PdNerBNZpBII/s7KQGKAKWBPUEgn8aXOjOTTe hv3ut6hJMjxxmN3TaHP3umDVa3uZ1UwzsU88/vCvAOM4Joc10IP/1v5zIBcW949ssz3VvOMgjgQA 9QKrG3ttK1Ew3pWKO+dEtLhXLSROefmUdAemT7dK+ATd7nZUir3Nz+zTDO63KrIQoZQTwwPIz9Ri o5P+JeDHGFiilJlMIYkA9MgGkW4pqxHFvljS7jWQOH2tG67cDjkH8P5VJfapCsdrBeNcQxvLnybZ DKzEDGcfSok2nYzS5Z2K+r7Xa1+wSPcWUB8wxbP3kjEKRkf7JBrctLm3uLdo5LcvKQAQDhzxgrms rGp//9f+eOJ/LddPnd4bVT5nlg78Z7/Wug/sz7RO1vpTTzQLGGk86Ly4145JPI/Wvzc9Aq31vc5s rRJhbraMMCLCRMB1DcdKp288bxXB3bMlokI6sRx0q46SSZcNxYVuGX/RuJRwxKhhir8M7pDHp+p+ W8yb5IpBHtkkJxgE+gwP1rU3ik9zOh0bU7TUn1KYLLaG2DhWk3MhZvl49On6Vek1aS5aOJLdt6OI ikUZDSHPGPX8KCT/0PwXvE08LbYdYr5Y/wB8hBQk56fUU3UNSjsLS6s3kibUvLAt3VhIqEjjd7c1 +fNXVj2DLtoJWskN3eHUJCgYTn5EhJ5Khfbp+FZd3bwmGSGQiWNgQEflTntisWrOxnPoQ6XZJcPH dvvNpBL5U8UfyAqowAvp9aW4QJckp5rQhvlSUZ47CqjG6MJStojXsdQiR5ljKwvgYjTO2P25706K ZEuftAk+6wKqBzmtLWjZGbbe5//R/BmTUHnu7d7C2hyzZuFLmJRgZP54qK5kh1JVjeSSO6WTejId uzHoa/Nzo8i073JTBLSSooUM5wCB61SvGuTbfbQGZLQhZoU6kE8svqf8BQUpNaGrst5bcSRxx5t0 85pZCI24Az1P6dadHeQQxOLyF3W4QKmEOUyR835fzoNU09ia7bdD5dsVEJj+Vv4z+lY1hdWi3n2M xlb6ZNqSzN5cIAPOCeAfr2NZyWqGf//S/CO8k8uExRhWJ5dv8DVLT769tyI3iX7Ih3o4GQ5YnOf0 /OvzRwXQ9Onuat3fXrJ5q4SKP5hheOPWtEa59vCJIim4aAO8Tgx+WuAM4qJR5TZbmQLIxNJdwSkx +YNxeTcsRJ4CjsM9h61YvJWt2bzZFFtKq73YAKjZ6g/kPxqTc0Bpt7ZiCS2ZF+1Q5EqTgNKrdBge voaSC+ktYWVrp7h0clZuC0YyQV4/u4x68UCbS3P/0/w3Y+S7XmmySREoTMVOzzCc5475qKK6uElt L6EuJgcojrt2t64/Kvy89+66GtJelj++i3zt8xbjk+/rnmo7q5BhNxHB5cqkARwxhAM+gHFAyMXR jR8HzWKfNzhs+matWOoQ/Ymtr23KSTjHlBs4JPX34quWXYC3azqLSaDewgD7vLJPzfWufmlNw0sM VvsWKTMZPTHtSaa0ZcG72P/U/E+GBo9KMlvdsk/3gANwBByVI960opdV10JBHb2sFwIdzwW52JII wTuwT1wM8elfl59QZDOySul2hHljAJX7xHQVd0y7toyXl3bScFRjaPQ4otYDJQX9/NMrXc1wLWVr vztqxFF3fdyB9B6mtIubpETaxIbdgeoqHDsXDc0LNprdv3qlQw2g9zTmnihmE0ysrA4U4wSOO3+e lZuLW5qrdD//1fxajmvH1CZUAFu0W+Is2EfAyRnsfasy5v8AeSy2rTzJwbfOFfHbNfkkoNn2fL7t zZsb+5nEFwtts2c/Z95Ma9iPfHIqT+0rzfM9rJIkiMVlteFWXPQN7VHK0aNpOwy3uLfSjbJvCm5k LXDY+WAuTwfx7+9aVtqVtaXLEtNckHdJHCfMSQegP59PWk42Wo9jTi1eeUXJhsZreH7/ANnmHLDn HzVn2dxHew30BlktZQv7xVABBPTJqOVXuTJ2R//W/G1bVJHCyzfaljXaIxhgpHQmnTSzx2j20DAS MM7Wk2LGuecn3xX5Ald2Psoys7sqSzizjEasjTSRbS64Y8jBxWl4bvrWFHtpLOEuxwtxuImJJ6nt x/Wla2hqmnsZviPViNUiSW5b7HOY7Rkjj3cg7RyOvAHHtV2CzubS7i8hjJD95kYbCVwecfkaxl8T GSarbXd9J58YijtYrcrIDnzpn3dB2AAplndCG1eykRobP5WAI27gPUVrFWRlJ+8f/9f8fJ0WaYXF o/8AqgrmI/NCwH+yfWo1umZ5T5awBR8qoMA/Svxqasz7dO6uY0Wr29xI9rNM4kt5yQJISnJ4xkjk DHv9a7e1SyXT5zdwlrm7xHBcqx3LzwnsDyaghz7FafUbnT41VRC21sEs483HbC/hUb31/qj20F3K Y44omuVheTZuRcEhWx1OR+dbJe7Zlxlf1NmGYWttG+/azEIdnBbPGKp31teTaizSXE8byQCF4z8v lqoGB6jtWbi0zohK6P/Q/JUWtzbqEF04ZTu8wHDpz0B/xpqXwU3t0LjMUeY8txISvB4r8YSu7I+8 m/smXJdJb3drI0z4mbYGl4w7HCqMdvrWjeXN/a6rDcadJDHcxPH83DQyqCN27j0zR6mZevpP9IuJ fMjAnbzXQviNT3Ke3tUEWn3P/H0ESVJ2BDeZuyAAMn+WKQGPezTzXJ863WDM4GII/KjbZgDgewXN dElzbqY5LZXMgAEsZ7nuKA8j/9H8oJrorck+T5IZR94evTFWoYry88yOOQKsKeb/AHTJj/Dk1+Ln 3KbWxatZGhbOX3smxmU5z2x/OpSLr7JcTJY3EcOTELgqVUt/n1rnNk7oqJCEtUmt2E1w/EytxwPf 25q1A0cbWk1z8kUlyIZgnPlr1Y0DF1cm4muH043Frpv2gyCMtxKingFu5APHPf8AGl88QLO1kGS3 EShn3b5DlQGJ/HtQB//S/J0xzPbRRMA0ELl0k24kYn+8e+K0kjitlizIFfbuKg9iO9fh9j9AK9zp 0E5E6PudH3bCcr9f1pYXvYysdukTpGdxfdjHtinZ9gNqa/8AtPlRRxF7oryIxgIFHJP+e9R3dxpu qWUMVrBtmgP+l3BmJcOPboFx/wDrpGDVnYw2+1JHcS2ccN7axDZJMkvyKOnA69quJNHexWtnY2Rt 5CqxSBCWQt3dvTPHsKDOSfMj/9P8nPKuYp7qGWJid4ifcu5eO4/+tUt9ffZY/sO0pd8MQBycjjdX 4jyux9gZNndNJIwuU8s28oYDu+DkHP4ZxV25kiu5dT1K61M2sDBYbLTxzdoDwWVgv1PzHj34o5Xe zJk7LQsPPopt1H2jUru+hhAje5hCiQDjlgev+FZLQWkUKXrxolwJcoxGXHpj/Pet4rWxmpNKx0dj rCuv2G5uzI3kbolJBI9v8+lZUlrcO7JHctGpbeGIBYY+oNb2toXBrl9D/9T8k7G5gt476S6unFyr DyotgJYYxwPqDTLS8jKJeSq0azZAMilHGDjpX4/Y+tvGTIIbO31LWoYjIsUSRSSSPLnaJMZjJ+pO KpONUsLt/wC3dLt5LF2ZrGaCUyxlR8u7JA+bPb0raHwmbTT5UdTHak2EF+FSO2lJRCp+Vsev6fnU dxcpHHFCgjuIGIBWNhiqNFDSzLGra9f3s9vaRQW72OlW6eXsURyAEgEEY55K0y3sHnlZppRDFO4Y eYfkjz/Ss5RbkRJNbn//1fyrKzwtJEJAqRgtvQ58zHTArDUXNxL/AMTBPJaRQ0JOVO09DgivySMX Hc+naRq+XCVaLzIhPBHyN/CjHBptok1xlI9mE5dz1A9vyqyFFc10YhtmW8lkuC23IAzkk4q3c3en 319HHb6d5IUR2xlRvMyAPnbB6c9f60BNCajHHAUjjaT5pNkSEfvHHuBVq9Nxd6bHcRkpPbZPlrhj Nj1HrxQZn//W/IjTla9iuTcSSIsihZkkbGCPQdvwrcF2J2ht7l96xIsMEiJkYQBVB/AD8q/Ipu70 PoXfqNSUK00LoCDJuVivQjjrVG+v1ne2tGPmxQKUnjVNsbAnIGfbnp61z1Fsik7QaGajFcz31lca TcLb20O1JUZslwOoJrVu7D+1JrGQKVlgb94wPyyk8c0oq7Oqi0pFaMNpUl1Y3IaXdcfIhIkZTnB5 9On5Vt6mukW0Etvp6i4nkgSKeRpNrqzAbsY9MnGfStJuyLP/1/yq0bT7yK2tba3Al8kC3hV2LOR2 LnrW9qP2W3s0tbeUoDGVmi352MeG2+1fkHQ+yWzsZNjbX+maZE1pbKbJJham8af5xkFzuU8nIBPF Zt9qd3qc6wBJBbWg8l7nytmwtz8p79TzXO92SWdMieFleEvI6PlpDwxI6GtULa3N/FJe3Etpvfa0 yJ5kmeeQuRmkAQNdDV7G3s3YCa9ESXk43SMOoOO3T3p9182rXWnXWpJGkW9fKZd8d3KucDd19SM9 OaCZOysf/9D8wIDKkdosaBLt3ZJTCd0cYGdrZrqWs0mtooLiYm9VN29B8zHBx8vvX4gm0fXc0TkR GyxmC+3TSiUyQvnDLzwAPT2q7YRajLHNds7W0Vq4TekgjlbORjB5OelIXOi8l4LmBBEGW2WQhpMl XYqcZ9+lXBY20MM1xau1sZAX3Aea0rnjnP0/ACgJaxuaWmSwSqkeoW0d9dtD5MNwGMbWz/3+Pp0P FU7a5li1W+it5TFJbARRPC27duByQfQg1g1Z2KUUtj//0fz706JLK7trq/CyoZxI8IzI0zcEgj0w Mc8VNd35mup4FtJ9PUudg8v5ec4wfyPNfg9uh9dypu7LFvbxy201m1ubiRtqvK0eJJgBkhSOOc84 qzGtoZLZ/s0scEDYmtJlKDA6BT1x0rmlG+hQ1NShiv4kic21vkiWYcxwL65zn8qrXklxBPM9q0ss MkW6YqMMgyAOB65FYAXtLt2k/wBIuLUqXQEQsxDKAOGP+9nNWYjdLqC3ETm1tzEUW3hjxK7g/wB8 nOOAOKzn0Omm3dH/0viEzSXmoTb5DNPFGqPGWw6Y6Aj1/Wuh0+QQQXtx9jNsNRXy5wysVbGBuC54 xgcV/Nk9j9ALixXFpa2pSOHNzDk8ld23gsR1HTAFTXS6bdW32K8YCSaBmi8sbZFKkc/59azTsZc7 OetIbYSSwmRYlt4y0XBZ2YfdGO2fU1t2kyObXe1vFPDwjogjdzknd9f/AK1D3NGm1ZDbtri3upLx t8t0Rse7EPmSMvoxweKjik8oC48pJpYnDLDImY5fXNIy5Gf/0/kd2TyWFtGkBFx57wRj91Ickkdy O/51rRyRzCG8RRNNMHjuoclYrTGcbTnnn8q/mBu7Pvox5dyCCOBpoheWEE1tGxawMqkhXGcsnuPb 1rUS4a4v1htyY4UKrP5y7WB45X2GTzWc9johG3qb1lc6pbOlw3myxRztFDNOcBjnOxfXG4DHpitd 4W1Bml1B1ZI9ri0bIEmDzj/69c0+x1xWqR0kV1YmRn/d2cYjATyISyZAA2gevqSazvNtzJM7usu3 IwwwHrll8TNz/9TzyzJQRwwTFbR3M32ZuUibGOM8ir1jd38GoPC3+qRPMibPzbgeABX8iyjdWR+s GhFqoWS5tL6AG3uW3SOMb5G5HORjHNZsUkcNwipNMY5LkDGDIFHQ49hWTVnZgbFze3CXN+7hWUn9 3OWyrZwAcdq0oze3OlgXAWKK0fzSyt8z7gOfXHHApDV1sSwsIYI5bN2UzrvlfbtldugPPoAPyqW5 OoyyiWGTzBAN1yr/ADMw7sT1yKiUOxpFNSbP/9XThvIF8+ONRcK9qVSSQGNRIwBGB3xzzVJAWVIr loZIycTWxGVkPuOtfxxJWZ+xqHu3NTVda0u3Wy0/TBcxzJZiXUYrm1dYN+TgxS/cK4I4zkfrUmjm XZLcnUGWG4U7VRsrwOQQPX3rCoiNh8NtC7m8tlWRDEyRXO3s2N6g+/GR7U/TrmGGW6S9sYstH5KX ks3l/I3JCjPXjv7VytX0YGxFPpkM09paRNqVtFGkUM11vjMbYVmCEHBwcjNZNwXtZN2xVUyeYV5+ RTUuC6GvNeLP/9b02C308WUV4s8MpvHIa1OJNg6ZcdskcCrEjgSC8RbeIA7EiiwEYjjgZ9s1/D7X Rn7FGTT1MY3N1aXTSt8scibDGTx83Vj9B0rS+3zW1uZI5o5UnbyiokAliUDPC9RnpmiMOiNjLsb1 5w7vJ9lu4wVQx8btvIw3rjpTrSbWJjITPGsDzEoJ3AllYdTknvnv603Fo2h8JGLuQyyBiI2c4O3o xHYVdhv/ACI/LuIJ3XBZRIAyv7AHmlYo/9f1AzAzWM0SSiOdNxVozGIx/EvpkcV0E0a+VcTLMJIx aHyUL7QGPQ/UZ6e1fw+fuN7KxlaDOdThurSSKeUWcm2WZozsGQDwcVO0yQyXUVpHHNIYjFC7jDq3 f+WPxNRNaXFsUU0+9+0S3iq0sSqqT3TnhZHB+UA8noatW9ntWWCzVby4nOZTc3ASUE9BGM+2O/ao jG+5op66mXG7x3S297amzdTieCWT9+B2JHU1Ta+h069gtkVo7a5WRnXaHUvkMCAfu9+nqfpTcOxo f//Q9Dme/F5bJZw2t22oDESSXIjaEAZ3E87enf1qc6hNiNECqsQO/cdxd/qe3Wv4ejFJn7wTmV48 TymVFkTCLChMpPP6GqN3LeW8JFvbvJ5ilkmwWjh5A+Y+pJxg10pdEVGz0YmnahqNtOsskyK7qIpI Pux7e5z1yRn8vxou50nv/sgv7m6gOLhlni8uKFznIQ98dOfSr5HbQknurSOAPFapLcXkKCQpGwkD bsFduPqO/esu+1W90ksZXjttsXlXLBguwjA2k9O351olbQia0P/R2n1Ke808+VKzRCYOH+9CcHqB 0PHGfenaleXN1EwQRwSeSFjkiiCCM4+8F6Z71/GTg0j9wIoLidLZYLlxO8iELP0IPuM1mXMV1bgb rmR5GbdAcAiJfqOnsD69aFBvcTVxlrFcXEUwnluHuEG8XU0HlQy+ig46/nVBtTVI/s0AEs8sgSVV kCQxDp8x61SgkTBaF6+dLO60mB3E9xPbCabyHE8NsTn5S34DqB1q/v8AtG77RvWAjYQo3DjpxRGP LuWf/9KC1Oo3EsloWCW5IiHmfIdvBCg9+1bLx4tmsw25YslsnJYj1P4V/GnIj9wOfnKPLEUmK3EI /wCPZeAV4G4/iK04DJLBIs7xW8eCRNuzt4P3vfjgVLg+hEpW0Ry0FzJKtzbXMs5huFMUOQPLGG65 7ZpnlSWqxww7mEaFmkXldvvjvVRhbVkuelik8cmobpZ5n/cr+5w+zdjjGO9Y1rqD2UscMIdityzy AA5k7EE9q64Q6GTmkf/TwJL4XQjiu0e0eeEkyL+9wOi59/6VyNwIxJNbI8kkNsx2yn5NxH3jj3xX 8jRilsfsHPbqRvqErR7Jm3W8Jykanbz659all1CyluTMFhhKW42hnAeMADJyT1J7VvCNtGJSTdkZ OoG7nvrVrTa8JVT5u/aY2IyTn0pt/MgmD6lcITEPISRWHzem31+6PyrqIlLWyMu5mkcrDAp8sryV BJf61UuD+6FtGCHuEKyo3BbB5A/SgTndWR//1PnR7O7nuLK03+VbTx+VdW0s3lrJjOCB0I68Vpz3 ml2Nm9pO7R3cr7EuUPzH0UHp2r+Vz9d6Ix7y2e9tzIWWZbaHeRIu6XggKQPx/wA4rPtb6SNU09ZY pb+ACaeSZTloySB8oIGeD/8AWoCaLVxc2E9lLArTRNcSjypoBhgUzvJPYdawbQXeqTSvNaSG1si1 rYPIcRygYLOE7fX3pNJmVuhY1XWUt4rWLXBaxM1mATbfvLRtp2KDnudvOfQ1Xv1ttS0+1G5JUL7k SJzhCp4II/p6U4x6Iwas7H//1fkVmvrG5sLQ6fPcLeyrGbhZF8q2Vhw0hJ46cA81navBplpNqsF9 DfRa7bXKLZvFOPsNzwGDgjqQM8V/L0Ia2R+lz+IqXN4/iG3d7tftF5ZwbLVpn2Sq33QFI6nkVzGl nUPD2kXVrqD3DTvO93qcSMzMVzuj3D2DdD04rphBXsQW/td1NLKkaNF9ohSCBQpYRsp++Qcjnv2o ttJ1jwY+r6tqs+n3N/fw4s7J5F1CSZmOFkKrnAAzzmu2nECsb8oqjVPKeBv3jEgu0RY5Ow57Z4Br kNU1CS8kuEmtY0sWkC2ouB5tywX7rEA7QG4ODyOK9bDoynuf/9b80Wu7sabcrcRWFkVti6xQ3QnB 7AAEZz0OK8F8XatcQ6NqM0flefZp50RkbEkqnCvsP97BJA9q/J8Mtj7Wts0fnl8T72K8jbzhALpr tkibzMyRggZY/wB0Y4H418WalJNLJODuKWsrB2Ylg5B7ete1Q3R49Z6medWltVtZrJQJY5C1wMYW QdAB6f8A6q1oprK+ijuoEupLmM+ZeRqgdE4GAuOQQe/0r2aWx5s9mz2LwnpNzc+dcWht4isSh4Zp 0W5mwMgYPJ711Njfz/2mumGWSO3ZCbodLdiOApbsRSS3OPTnR//X/lEv9QGo3jxxqsdqIDBKy/eV iCGO7/63euB1vTbLw/FpqwWlze2kgEd1Hfjz5MEEiRX7KeMEdM14zXvHatX6Hkl9b2drmFWSKGWd pEiAwgDEnbXE3UsUOpINOjjkYHbKJX2IcckZ/PFMJrSx3sGpWdzdtP4g1e7sxc2UcGj21rZfaNk6 kKNzfwrjHJ9K7+4m1ay0W1jur2SazeZGjuZo1kEoXjyiw+6OnHaqi7MyLE81obeDTVQjUmjM0hJO ApwAoPTjn3rJt/tXhzWX0K80jTrvw5eWQu47uymA1K0uXTghccYzjHI4PrXRFisf/9D+NyGPQtJj ttKOuXc0k8zSiS5iMssCnklyM8Z49cCn3trc/aNAjI0aTzGkMcLzKY5CG/dtM2RsJyOG7fmeVSWw SV7ons9PudRlvxrH9n6fqIVmisypcRqnC+XtGMHAweOO9ZraDNd28hs7mxlSAld6MDKso64HX8Ko XKieSx1SFNMlhurKPfbSJf2sZJ5HAO48g5GcdwacFnuobeGdJlnSKS33KxDXCsfujHTI4z7U1oWo tmVYabZWVzbQSaU8Vja3YuY7YHcwfPyyZ68Hv2/Cu9vrkXds8oWKa9FuUiIflyOArP1OOnNIOV2u f//R/j7m1C6SSzFzBFEiW/lPexsxmfPAB7HGcfpUl5FBZ28Ul3cNKsyEqXGSO6/iK5zWEbLU5uFY rzz5j50VuSRKIwQWC/7P5VHcWbT26X9pBLApUxoswMe4DPXP+eaUtIslRadzV8NwW1uJbhjJFd3U RE0Uh2jamTt9M9ceuaw55Z7qa4ngd991K1lI83yCNUIGB+QrA12OrhstHJkkuL28l+z2yFzZjbPp 0iDOY1zzu6ZJ6VXley8ST24zGY4p8i7vVEMny9A+44yOv1+tDA//0v5DZo9PSW2tln+WbMSyR/vG JAJJ/Sm2Om2jpPcXDpfyRKyRi6/1EYX+FfQivPNJvoUo9JurlYr6OeSGya48tCvzByBkqAeCOnPv W9qy3V/Y21rpkNjNqMdwhjN47KoxwdpGefqKhzs7GZy9ppAXVL8487aE/tNtxUynkAY6HGSOK1Ix PaQSCZn/ANHJdZCMb1JO38gQKsDoPD+pTPL9oi1W4sXhbypZrVvLuIXYZTaQQe45HTNcrPfXMlzq qy/ar3U/trxG8uiZDK+SWdm/iz6/WgmXws//0/5EtNlWMy3oRWtDIILwMuUkkHVCvXsfypY7VEuL ieCQQwzPkhTtYnAHT6AflXnnPaxcexeS1b7Gxubsn91bo4Dyc4/OsZoJ/NuLe8giW4QLGVjkCzRE Y5x+HP1oJk7Immnmsrqxtru7e5gjZvsyyHZG4YcjHtTJNZ1NVmtne2/sy4BjdJZBviwcgxrjvzms 59ATVtRplF9bb4LubajKoZ1zLsBwVweQOwq3Fo6Ws89xZSrdysEa2NxhYoiuN3H51mDauj//1P5P tMS/1O0vIILhZptOK3F7GgB3RkkAA/iK53xDANNGmywSskjPi6mC/aDOjHHlhQPlIPc14MviOc2F mtL61OnLb+fOUCeSiKA5ODlu56dP8nDg0dyJ4Z5t1rc7ozFHu/cqOxHQfh6VJpzWjobr3X2Czh0v RLSNYVjEU0c05SNz/E446n0/WmeGbjVI5TcatplvbxyM0UUMFybgRANwo4HBGDjqM96DM2Lp3knn 3mSFJUZFt1UhGB4IJ69Oxrgb2XULY22nJPDaaUzvE0U5G1N+MMp9flHHaomtBrqf/9X+S/THQbDb XUl1fwR4W1aASWQ242O79cnnilQQT3cyyx+XLIxLpIvkjceCQO4+nFfMx0MrSvYluFmiVLbeqQo4 kjZAPMDA56+nA4rbt7ovIJtQvZmj8sq2wjzQcHp9en41rfS4RT5jk7e/1i21O5jlspLiwW1823kT AlLEnHGNxyOa6awuTK8k/wBplswI/ns8DG8Zw5HXJBx1xz0qJT7GtjHk+1tcRfZvLdYJTPcbm2S+ WM/d9WyBx35qSyl0tvtGu3+o3giWRoHs4YNk8eBhWcMMgbsVF2ZS0Z//1v5PYtQt3fa9wwlY4aIx khlxnOR+H51cs723hZfNtmWJJAI45VCxnb2B9xXzDbb1OZuyuRC1GpRahC1zbRQJH87ecBKw6Fce tc9bJfWNnd22mjbNDG4t3lOYZgQccnqD6deaxne5m5t7G95hm0fTZLP/AEOYxCLVoCN7iZR84Vum DuByKzI7e4jke/aBIms8MJZOCx6AnPrkDiiHNfQIytoaGqXV7DpMeo6izyyGYMsMKNJNHF046k9R xWUI2S5lfeYIrlF8pY3DbCePm7gk1qEW+Y//1/5IAZbTWbRGkYWy8SKE3ZLA/Nn8q6ue6sb37Nak medH+/OgRIiSRx2I9TXysd2jilZyKbalrFzew6bFeRWlhp48uWMupj2Bstt98+npWlNcWk3mXG5B cRLxIuS0iD144qvIl7jLWLTppfLmlaBZENw88cBkAIHCntzx+ftUPhqax1W7minsUllZ5LYRxM0k h2Zxux0BxnFANNIjt7m60kSI1o0NnNdtBAypsilIOGz68EHv1HrVvw89hZzldRtv7Ktbm8IWaCLM IU8K5X0IH/66LdDOEb1Ln//Q/lJ8TX+nfaw8URu7e3lLRLL8rFR39efSuf1Bp3Gm27Rk3V1i4tJI l82OwGOSxAIVsEda+Upx1diZux0thfz21qdJ1DS7O9UuJft18rPdyDHGcELtPXGKrxQiQmSaM/Z4 pAIyRvjiHoo9BVcqTuTDRMvK1gZme2u2MYbG9yEkIHGCO30qWWK08u8uyJbu1jQeZa7PMVz67epz 049RmpjGzYR+CXyK9vqdlJAf7Ns5bKRUxIkkLRb8nn5SOMdKrT5iuI4tKufMmVfPWPcLdYZGAPDd zkUKVo37GZ//0f5U4Yrm1uzLf3H2idELGCRFaMsR03AZIqO3WDUrlpo1H2iyySm07B6jHvXyyelz B3vqUrfVb1tWgsrawslj1C++zm4nk2SIQP7pH3TwOTVHWwNO1670+88iSJ0XMpYCKJs4Kx9MjjH4 00+qLhK2jNG9vJ9Vura3W3ENtaWkcCMDlAFGOPryfxq5pUJg1WO2hfiYZZGIheUY5UEmqcm1Y0Na SIJfYhkCZb5lK+ZHweQT/Si6urS31xUn02O8sLi2VcKhdIXH3yo7E+tRdLQD/9L+Vu/ubSwvo4mg mVZG8+GB+XRf4TjrjpXJ66b6/hN3LD9ktEcl4Zs75o0Jy4A6jjIr5ZSTA1UmWPSrOdBPLp1232a2 eFfMnABBI2A5A5/Wuck/tgeJovtlvcWls0awQMIGiiXao5kXGB65xz70yZK6sjsE1iS2v107zYNS cQFjHECscqfxc4Bzz9afH5r2U9/Y7bSyluDaTW0b7BI3Ybe+MfrQZWa3JbO+toIprW4gj8xyP3so +UcdvrU1va6K8+y7tYftNwhihlbOfLJGUU9ge/0oFax//9P+VHVNLvlkntbUWvll1S1hDgLbIMFc HpwR39qp6ddCx0m2N4sd3P8Aangu4ozubeMc59DmvlznNJdQt7J53ZUQQoGmjKlmjLdMj04rXS+i gMl08z+TIgKIo+VfcAetZyj1RUPiRPO6G7TXJRLdSSRJbK10+8rGoGOD6en86zmbw/qOrRaZrkd2 1m/zLfLb7WVzkoIz93jvz096za6M2Hy2L+WunWmoXD29iT5Eso3SeWzH7o6Z9qsLbtvT7K0pht49 22ZBHLL90bmHY+3vSaurGkEz/9T+YGT7LMVWO4ZGaLEjSL5ZVsfMB149DRpr6ebK7iN3I0u1niDx 7kcg42hh7g18U4PoazT6Gaf7RSFI4rYxm5CzsJFKkIQcfiM/pTtLsr633HU7p9Q/fbooyo2oD0Xt 0pcrTSFG6dmbGtlg8SSPEjzqBHCpAHTpgdx6VkyxyW8kMtt+6mtYTF5asUVd3Bb1BrVJR0RUnZWM +5TUrmK3mZbeO0tJQLpnm23V6OSg29wDzkeldLoN+thHdLbwI8t7ayWUysm75JBj5ffv+FML8sUf /9X+XRIHubx7SGMwyKPM82bMcPHJUMeMnGOveodR06UPFcwyiCcHbJbIxy4/vZ/AV8jD4kdMZW1R Kba+DwzSrKgjHybmKhxjGcd614dRW3leKYNIq7VZgPlXcOOfbPNa2QXb3LviLRrGRtJv/LeBtPRn 1VPNMtvdI3zRNs5OeRnHoKztWv8ATLmWz/sp7mNJAGnWWPbGR0Plk9f51k0lKwhuq3ljo8sEyAi7 mISLenms/TA2gfnT47q81NbmK+tBa+cSpJAVGVh/d7dahK87CT1aP//W/mgs47Tw3O/2crNFeWyg yEZRSFX5UHbHP61cTWNNYRSxwSrI8e6ZhGyowyRw5GAfY8+1fG8q2NJrY5q5upLaa7aFDOJJN0c0 zEFB6celWDe3duqRiNLlnHmpsAUhjjCk8Z/pSgrbmhIltfXbSz6hYRW0bSYQB95yQM8dulLa2P8A Yu4RwuLZ2aWXgySF2bO44HTqPyqwNVJbeUxrC8KvyTGAEdjnJJ9zn9Ksi/gQI4C/I+1ivzBQMg5H 4Gk1dWGnys//1/5xG8Q7p9Ns7XSra+0+7uWGoTznypI18s/mCQBjipdSt7aby4bS1igEYCLFbcg+ gxk/lXxko3sjq5tLM5KfTLlbh1ESrIepYbWyOgPfirty1rZKssikSBQpYZZVI61yzTUmRO3s7F+R 4oWt7u1dJGaFZCzIGIyMng1jPf8A2V4gpWSedjJKIz8gHZVXtj/IrVK+hNKLUNTZhsLbW2i893tU hBCyJjzDu+9kHtwOPao7TT0017obvNt2mzbswAZE2KMHAH8QY9+vWspfE0dMU0tT/9D+bi1tXjDS vPE6SsfLIceYoHZl6j8asXEly1lLucMYlYxozblXHT/Ir4ON7NHoHJWWpRPMkzfaIQ0nkTCPOUI7 kfl+ddk092LVSihpYl3R3DL/AKwMeMn1ArMCBpmEq3815KGVNsyfe3nGPr09KvWJW/OyBpDsPmAC M7JM5HLY/TrRYCzJIBIFuDEiWh3SxH7/APnilvbRZIpJEeIebErW6RN5hTPY88fQ80Bsf//R/nGj hvbCKK5CPOHO1+RmPA6jvjp+dZ9y81wwnYPgkKBIpDDPQAGvz1bs75r3Gzp7W3vDOw/eSBYRIXIy qgDvSXc4cbPs4kmIx5xH3AOwptaWB3toW9NmCEJPEDGOMHv7/hUFzeWkur/YZGiMUFn5sM74Qk5J KkH8eTWbi76GbXvmdPdOkkiWwgTY26KeFg49c5HFa1kBbwrcNJvaVvndVJCk9zRFPVI1P//S/ngk t4JriS5keXKKVZk7jOc49q6NdduLexZIpg1u8AtwwA3MB7jvxX51KNmegYtnqMzRPG1u0ySQ7RPK DvjAI5+v196gjgsoBPNNdNGVHnEyH5TzjAFO1pouDSepoCS4hnhe1Y4ZNxV8IrggcnNMW8lvLiTZ A93dRL8qRj5iPQflWhqT3dtfXlssMM8lpMOFZzkcdnHerunMLGV0dRJMIdqSkYZG4yyj8D+dAH// 0/5772wnu7iObzJCZJMxkgkgjrz71RvdPjJQ3SkOsu5XA5JA4JP+Nfn56zkk7FxGeygDhmaGYjh2 xt6D8KeTDdyLbLtB2+aCThxj0qVGzbM5O7Nm13Wli0UGGjDlygAy7dDk1WlL2+ya5t2S3mY7JGXC HnnB/GqMJ7kQs0cPdxSLJGZNxBAAjxgY4+nf1qKK5Se+lhe2VEO14XiOUB759KrldrkH/9T8C3s0 tJLmW1Mkkc5VnBwTGQoBx7cfrWtZeWsRMtmjxMQQSf3h9/Y5+tfn1kdBBcXC207RqWmRzkDGJMfS untoBNCytAsaSLmJIzuYKQOvv1pcqvcDPu9JhawuLZGLSSZCyMdpjz6YqiLgQLFZXkYmkhiVBIhD uF7bsHH+FTNaGtPaw64+zxQQCEkgSE792do9D9DWFeFpZvNBiVUIB28PIOgxWTV2mWf/1fwMv7oP HbWuVjcgAlhtygq9dzzm1gsYJwbdgvltGAenHHHvX5uejF8ruaimWS2gsZvLRF/1lzG26fGeAR07 darXVqN7iORvni2R3OR5oHTHfpxWc0aRld2J7Bba1McF4zywH74LcuR0J/HFWNW023v4TPJcv9jt fn+xdUkOD8xGMnGOlZmqk0rEA1BWhs/LjmVIohHtuF2mMDj5R2z/AFqza2ltE3yJtjdzIy/wkk5P 5807Mlu2rP/W/DTyHkuXFuw+zRt/ql5/P+lTSlBfG4ceXEqbUt14UH1/n+dfmCTex7C8hkxv3d7q WBYrWMiO3lVsm43ddwxxg8d6WS4Yr5TKytnDDHT1q4x11N07q5bWC2Fs6ncBIP8AWKcOvHrUltAs MXnFxetHgeZLjzhjgD/69aCj1L+pwhIEexhYLJEplMhyzH+LH9PpWNYzWp37/usmxCrDCt05/HrU yV1obQP/1/wwljvrZ5RJIqv0EUTB0HuCOvajS9TNnqNteTLILmEEK244QHg5HQj61+Y8j0Pp7q9j odVSCexOqQXyTNPLsjtwwwv94j2Hf3rnYxcRpPHI20mHfEvOJD2rS3uu/mMv6TLLj7M0/lu0ZYsy 4ViB3/z3rRt5WtYzlxI4O5nPBA/CsR7bDrq7eTypEdtqfPgDGT6Gp7jdq8tmV8i0tgipPM0uSCPv Nt9KCoStoz//0PxLs7tHaVFfzoopTEHHQ4OP8irO1I3mj8sTBhmOdcq5z6j1HSvyyUb6n2Kl7tgt 57qEIIYYnSN901tPKbd5ADyFbB5rTtwWD3f2cRNc/NJEFJeP0B78VPIxFW/ggaykljCGUcgvxg5x zUUaulnFNa3EcUsYDu7LkHH3hScHYDorTxDDPE8Eq+bdSgLv/uEd/wAazLoF0byNkblsykcF8VDi r6obbejP/9H8aLOZbKKe5+QMybV3nCE+p/KsrWZ1cQuQ7idtkoCEoAfp/nmvyZJLY+ucrOxatfsR iVdrI+3ZHvGTGPb8quWQigmmlnjjZIE3K56j3AqJRd9CiqUmvvMnWBEWOTfa7+kmMEH2qxLqcltd 2jPMd7ny3kJJ4xzkelZOKbux3aNM3ciyTAmE2LR5Url5nfOcAYwBx61WivLO6kDuSRGmxVkBUqPT B+lMTfc//9L8bXmmEhMMYjjU4K9FIq7KzuLWGIxq8mCCeoz29q/HnFPc+xu0rHPXck1xqMUciIqw EPKQgzJjsfrXoKgy2SsfKjVwCIkP+rx7Z4/GlyRFsYWoWaXDxHYkjAgM5ALAA96sJp5mKDz23cBN jdfY+xqiFNEDLqsF2uPJBt3/AHKEeYOP4vbB+taby3jXKXN/PiR2LmUniYkH7xoaT0Z0QqdLn//T /JN7vf5zxqrERnaxbCE/4VQj0+W2toJ7qe2uJZx9odLWUSRqST8rehGOh9a/HYxUT7ZzVxCyNI6v auqxxiUF0DITyfl+mKGF5fo11bDYkWIridlxtHQcetOytYXOiddPihEctzIl8rgoFuFBVQfQUk17 HZW0Wn2d5Fay3D7LUOB5aZPJx0AFLlVrFJ3LBgeawDzX8k94l6jxK+GhWMH94AR/ewBV9rG5vLiP 7MkVsi/OywglmI9vTj1rOUeULa3P/9T8l/s081zMty0zsp27pF2qAOmK0vtq2UTxh1R9mGkP3UXo SfbFfizv0PuLGNFqMk6LNbM8casMMqFPxAI6V1D6hPdaelnJcytEsnng7iAxPHzY6j2rA2UbGFDM 6zXEDyCOGIYV7fnf1zg/561csrW5ezlvGSSW1ifDFfmC47kduo/MUGii3saCmTUdPg0y2jiWKKdr kTPKY2XIG4Ek4xx0+lRRXEGnwzRHc0pXaERd5k9sfh+lXDcUotLU/9X8q3ulubVQfMtVIyVZNrL+ FZwsEjjmuUu57pz8o85gdg7AAdBX4ufoCVlYWG5dIIIBE63U1ysRWEGWJFOQWJxkD1OOK0Jwlm8t tZypHJksxJ3Ruf4sfWgDQWVxbKtvZwCUIRLdSMfMm3YG3HTA9BXNot1bPNbxRRxpc/LcSqAzTL/d PpyKTimYPdlvTrBl3RwgRx/cCqMAD6f56U6HUW0rULuzLeSWTyJSCDuGQf6dqTiroltLc//W/KjU 72BLUzi7bejBjDGMmRcE5z7Y/Wp7xLbVBY30EDR+TbKt7JswWZf4ufXAFfi59dN22MBI0M87swiW Y7VRW3AY4DH3qGW2Qhpkfz0U+X5qpwSB0PpRYxlJ2uyAXEyRtJ9jLhTtV+xIrbn095ra0efEMN58 kbnlUcAEg+mM96qHxIy52UY9Je0LXZSOQwtsM8ZDHI6Ae3FTxRS6i5V7k27RRtJu6K2BxnvjtWxS mran/9f8d1iub2SJIYSGimJluXBUkDGOOhB5rduI7rUr+D7XKHW1jwluEEaAewHFfkF3ax9TF21R uzXlrcXsEAs44JFtQrz28HlxvswvzHux/pWFqIF5K8KswhQf8tSQM8Dj0PSrjKy1Gn712U9l9bCO 2CySWuDIqHLQxngE+gJ4+tTxxjCbYzDk7gQOM561onfY2KlxDLEGY3MkG8bGkQ4dh3/lVu2jungK ecZIVIK3Mrfcwc/j0oMpvWx//9D8gZb/AFA3ySToY9rCNVjH7uZFwA349a39Tn1a/MHm2yyLDAI4 ZVbMiAYwm3H9a/Jz6Sb6FRI5r2zSVofJEf7pl6TOR1JHXHXn0rU06abTIXmjtoLi4OPJiuGKxKQe rYByOvGKDMxrhmvLhbprnnDtcxLGPLZyeAvsMe3X2rOtoorKfz4HnVhkklzhc5oD1LdyZnlF8d8r xJwoG449qtwfabq1M8SmCPOMg7WB+hosTGVz/9H8l5rC2ZSJmMTmMMGBwWqC0gzdbfMaFYR8rOdq tx1FfkTg0e+aemeRqF6+nzPHEGRtkkziJG993rx/Kq1toTzJcmCV2SCfy5LgLmMc9CehrOUbjV7F rX44w9l9hRLe1itEju9i7FM3dt3vjvUs0iWtlFcRysY1hUyMFwAcDJ+nvRGNmbwlabMCWbNle3lt ie5jhNxErNnzDwAB+dT6MReGW9msTY3KYhld1OGAVWLKT1Bz+lVKPQvml3P/0vy5E+YP9Dna1aME y3C4HnKQeFbsa5LUYmtLmNUnZgYldXZ9zybgDl/evx8+tjLRrzOisL03GmSLcvIbdf4IgC7Og4IH 6VA2oZtorEqIWnIVkHBlweMj2rGStJlrYuyXDaZANymNCQCxjLFe2TgZxW7Pc6XaWWnyyywzy3hM sVzGhKR8fcIIyDwakT0QjzabDa21zHdPFdR3G9GMRZehwQ31NZLmO2H9pyww6jdEs8dt96be2QHZ fT5j1NJO7aMD/9P8srK4nhkSaYpFub97Huwkda+rRyS2SanZ3kUN48otooZSwEo9eOmADX4efUDL qyuNM0/Trqa7TULu5JkZ4EIjj7hGJ7jvVu1uku1hWREa4D5uSzZjjUc5HHJ9qAJNXm002UUJaeKW G4zAtvEcNu4Ocf8A1+taNtZatb2wFulje29xCSsdxLtntwoJaRgMnoDj3FBqkuSzMnQL63sr+7ik WeF3sJIYHhGUYvx9B9fer2mxNZCaLKTXTL5iTTvtnmA/vH24HAqJrQs//9T887eG/Ly+bcxJJLDm OSNhNFE3bGP/ANdc9qTeJP8AhIlg/tK5ZY4la4XcLi3mQ9AG56jH4V+Dn2B22mXd5E4Kzl7q1Uzw xsdmwDk7T+Fc3aeIdb1NriyvYY0BmciYf65ASccnrWMlaTK0tYvaQ8D3k1nNbXk8CQyB5Wh2wPKo +XLnuDg49K1Z7Oa1gtp4njaWaMO0LyhlhbONhI9MelYzXUk0mubhVR2mMVxsWPMaeZGxAAx9OKl1 maeW8sxDGIBbWKAyQ5VZHIBYkZ61k0mdcF7x/9X4e0eG6ge7vbtI/OuJhItyjbnKBRt3ns3Dcewr a/tK5u1nj84PiNks2C5WN/8AaA9/Sv5vnGyaZ+gFqxvWu7XTrjW9tnd20ElrNEsm6BccJICPXqAe gqWTUI2CRF7LEaEC9ACs6HnqfoOnPFc5zlWG1uxIt1cC2fT7nItri3kEkzbcZDr26jGainiheVkj iEQAxG+csmevPv1oLUndIuNPqNhpZ02d2jIk8yS8D5eVWxtQnpgD/wBCqezea8SKCNIolzhWHAc/ 3iaCnJ62P//W+UpzdQ21wI7O33p+4W4GWCkkkHPTJx70zS4pIEvbae4lkhuIxJCkEQ82J9vOCex6 1/MD3P0BbajtHsr+7sTBdRxy28F2zRSyS7LkFiO2c4wo6V0moraWd9afa3knvkjVIIrUh02lQPnI /hAx+NZz2N4vRM6Fb65+yxQPJutYJftEVueVic9TipZtZ065uAnlzo0q4lIhPlocc4PTqDWEl7pt GVyLTrg2cyDZ58JkyEl5XGehHce1adpYEzXplI2Syb7ZAMGMccVzTWlzpi7o/9fzOZ7eyjRFRnuN +5/4VQCr8F4jklkGWX5G71/I5+sLUfcoYVS4uI/Oi4CCMl33HjnHpkU9rkWl1aQLAzGZf3hK4EC4 zk/Wk0nuBrXtxbNsjsd07KQJ5P8AlmCOoB9RV83cSaeDI+FQEyBuFYeufb3pcitY3SS2HOmo281v cxTRiGa1VoLd0V1dW6Fccg/4VYsb27vI7+EW6J5MXmrLjEsgPyv9QMrx9ayaa0Yz/9CrNbppGiR4 ZpLmI8KWO4qTx19M9KghtkuoIbi3uSLlWDtIeeO64Nfx7KN/U/Z4u6OrsbAvYyyX0SShJTFHKj/K xK5GayZFns4o7a1VFLnegADRhVblTjoDyK55xdrGLdzqEurNhB5ONzoA8Ma4SFhwV5+lY08gu7ny sKIkfDkjdtIrCSurAot7HQWHnNayB4leODMnmJjftHHSobcC8g/tTaY4HdooFmcGT5fVQeM9aycG jTkR/9HqJNUjgguY/s2+bYDC8Z+VTnnI+lJHLcWZNwYRcRiISbJWKurcdPSv4nsrn7IoWeoyeRZ5 jeyJsklI+RWIj9BxmrIjNvLb/aISHkk324mTMLYGcenr+FFjaKu7G5DAq/vViiLO5LlTtWLqflXv WPcSpDK80u4xwyHZhT1Pf8aGujNiW0E1zN5tsoZof3wBQOgx6g8fnV6S3L2tvcah58V0qgzB8GNV x/CB0HXj6UJJaID/0vSNO1eFTc2pKTWwfEUu0M6genofpSh5LktCZI4YgGk8138tRjkKfrX8SOCt ofuBE93eWtnb/Yr77NG115k8ceN0oXGdw9+lMF7tmF7HLGWuIxsV3DTRurEOcdt3B564FRyPsBFI msySu1vfzyW0uzNtGdsKuM849RkjP1qJNQ8hp4JYWkvIhsmfLbou/wArd+/NJReyQFiFYI4Y7qV5 HfO2PzG8yQjqck81I7x3Hlu8SyBXBBGC6jpk/nTcWnY2g7o//9P0aezjimhlim8uRclXTlMNjg/5 9aq3kiiRLaBWumJw0luhPJx0HH41/Eqgkz92lJx2LNql2pfzbqeRIiNiu2fKYHqO46VSu7m4trhJ PPIsGbdLaySf65gOGYdwM8V0Rjyoa2M8mS+mjkgn8gQybpNwX96OwGaW4mmMjNIkaxFdhwST6ZHb FVYZdFzB9hhitYpLe5UFWn83e0g7cEcd6qkIcfbTDPuHMTgSIfTIrRQadzKb1sf/1NKe9ee7i0m0 g+XJLFF+RR+H+eKz0Ny95qMSz+ZDa3QtfLA+8FVTlfUc/rX8bn7gat/aG2SJrUtcR4VpPl+eHdgE sOwBNZl5eTxwzQJ5M7x7ZspgkDHIz2OD0PcCmlfRAXYdS22CKx3gJkpIDgZ9vasG1XQoLt2ljihu JgZBKAAOOpb8/wCdIwTcdguZ4JJftlksUjqhVWiJZJOvXk1ZsGub2F3UtHhGGyYbArDIyc+4qoxu Upu+p//VoXg1NraNp7qN3R1hR3kykDYyvfvjj6VOLfUrO3jh1Ce0g1GQ+dE8MhdZV42kjqDiv47j DXU/a5S10MOUX8El28jQxtZQrI0UylZrnccARn8QfpVpZ2VQJER/OCzTP5nyKcABAO/H8qbhfYyl ojInunhN7ZRh/JvArsAOICD8pQ9u/wCdNvTd2dsm2RxuVXDOu1mBHzA+x55pRhbVk7wMxGuxNEss TNEyeZE0XzKgIJ5x0qpJMYyyx+VvL/uy529+pP4V1Q+Eyex//9biJr6zjt4jNvmuv9W0e392RjAO QfXPGKyZp/JaFgikTtsdcYaMe4r+SYfEj9YEa0V2eZBENo3fZjwJMEcCsbU9Eso7qDVEW3mlMqT/ AGe4Xz4Ito5QJkY981sBWbVwYfJ+ywW3lykh7bO1sn7pU9APT61T1KyivI4Lk3MUsMiMhjU7jGQR /niugTdkWLWG7uLlJIriKJbO1Mq27BYUuNuAMt346D61TFpe6pqE96IxZDTsSxvG4YTZIDKB2yP/ AK1AlKJ//9f5+1Cxmv5re68wLJayZRN2N4IIP5ZrK1UW4vIINk88iL5km63IgiYcj5+nOf07V/LE Y3P1nmexUgaaO7uJod3nXaLF5bEmJAucBVzxya6TTrrS/JtVvdO0uS6+0vslF1m5kZVwyFAwPABI BHY8HmtORWBybMvUNYsgs1rY2yQKrPEoWEIZCw5P61kaXa381nceUwgRCVTzZQu5j1GM5oUF1M3P oiha6cDOIrp4ZJbYtctNcRCWBTHl1+Qg9CBxzVTVNaiVbXUoR5VnFdrDLctCPKlZs5CxgcY64Ixg VcY9EZtn/9D4pkg/0tp0mvHS/fLIsr7bnsCUzwfpTLoSpKfPt3gSxTzFkuRu4AxuJPse/rX8zwh0 R+muLcir/bMNxY+QlmqMZ/MiuFBDFcYwPY8HmoNOjCS3k05ZRKBJgZLXDcDDegwP0rohDoiZQsrl 4xXN3KkNh5SOYzKwBDNhewHrxXOWcEN3qUV/fXEkkdo0ltMImB3gkcEH0x7V0wWqRKTYzXPLCpDb RgRSyCNh95o0Ocvz1PSuem0+3gubdbu9E9qrB5nt8PNFH6lT/nivXoKysYz3P//R/LrVIrSXUr6P TXYadHApt2lGx2zkEfXvgeteK+Mv7Nh2PMIpTEmJrRmKGTJPLfXn/vmvynDK1kfZ13a6Pzu+JSaT BNr8SqsM2pWdwySCHzfKOf3UqgkYOVAyD0zXyZdWNqdGaWz1Ay3q3DrcyXi+S1xggARJ17HPpmvY o6Hi13rocnIYIlMMw8uYttf5Tla6bRZrXTiy2pkzcoEdo4yVm5HDEdBxXrU3ZHnT6o9T0wGPUjdw q4s1hxC//LxG+07gMds4NddZx28mjhLhGOpTTM1xMw2ZBPBzSUrNnFq5n//S/kug02/1K7utN01B cvLN5cqM/k5B+8EJ6nBP+NYfiSW8uxFpt9eyWkunSpZ/6dCVjEUKbUTgfdxjkA9PxrwJT1RrQqJu R8+3V3PeT3sD/ZE8iRgczcbd2AyevB6CnS6Zp19dwW1pZLZGOJFkmSZp31CQgZds8A+gHArZdzVy bNq9VrPS5oI2C3lrIIoo2i3s+ByRjryMfjXpGk3k6aRE8NtHb3McMc1zpt+DcWysVH7xR6Efzqkr uwrHUSXukTW66jcaTFNe4GVgXyEg28ZXjjNchpl39u1i41O3eG1tdJk377wCWYnPyJyMZ74xXTGN 9BWtof/T/jfurKyGtX95qB0+7injFxBJaTIAu8ksCF44/u8HNc1renSHUzLpd61xpaT287o5Edw8 mFKxhfXjaT/jXLyq9zWULu6Ozi8Q2UfidJpZI9Fe0gCYvYw01om3Hzoc5GQRyK6CxtLS7a/l0kWz +S4ku1hCwSXAkziZY+pHHJAwMjNUCp9LnM3V0+o3yLJplla/2cDbWkmnTM7Xq93lHTce+MjiotXR 4b22gSSSyfCiOaY+XCjHHJbp6n6UFJcqNDUIpJZoZ5DboyKLQrbSiRHYKAx6nO4jOfU1Mly0IOn2 K20YntNkrzoJ5IpOMydsZ5Ax0GKBn//U/jim1/7OJ7GC9sJZ7dRLBbXB+XzFHIUda1tO1S/8ReHJ 4b6z0cXV3N/oLE7Dbuh7OOQrdCDnj0rmTT2Oiw64gXRJItNnms5b+W3WS5itJQ8cBI+7npmpoWBs I7a5jM9q7tLhn2ANnA/Dj9KYmSf2RcR6nas4gtrGe0i2BQbgKzH/AFhUfnWcbBZ0lZby2MNncsrR sGWR2B+YgYx26k1g1Z2Jfw2Nu0uoZbW4MEEEtzcQi0USp5e8Dp6fWsGz8JR/ZGuNbazNxFP5tpJY XSzOjIQVDrnjPfP4Uiou6uf/1f5Bl0q9itd6Pb2uoi5R9LjfIE8bqSWbj5eeuM8HrU1640l7HRUM d0TK8l/5EB8tWfkqZAfXnngZNec3ZXNJoqaYk2n2zWW2UW8Ez+WJDuYqxLAKfQZo03V1jhXz2a2v oLxwxddkbjd+72t0OR6VjJ3ZHoPlvdTjuku2S3ng1F3RPszByqrk/MATgj39a07Z5NTtry1nnlCt CHEAXzNhRvlwPQ/0re+lxqDZmaeX0y+lk1Iz/Y5Cq2cVpajzWOAu5j2z1/CtXU9Z0uwvoLLT7aa/ vWnzC4j45GWLgZA5yTn0oIktGf/W/kBv7KRbu3u4tUW5OpZm/s2xt2SK1cfeEny4DD2Pap7W3nWy mvLf/SZrScxyR3p+zu5yRgDA4464xXnnOblrdHT7nT3s/wCzzqkoEt5HHh/sylWA2jHJB9fSuU1P QFsr6a+tdQmSK6nN7fXdzAypbsTmTH+yv9KDKe5pyJaapLY2SzS31qSoGr2kJMcWRnOSAecEdKfd af4ajuHs72ae6tLONgl4UEMhkxhck+/Bx6VjJ3ZBJp0MccV7HqNgbBCwSG9MgR5oQAwdBwDkH8Kx tHur2KTVQ+xoYrsrbtKSztHsBV0525JyPwFQ9Cl0SP/X/ki0iWK4EsFqo0+4VRPLdlin2ok9PdsA DHoa0LfQ7+8uXjg1CwIUPcPFqN+lsZT1CRlvx47CvnzljtqYT2c9rLcvpUsBuI7tCJUmLeQSwDlC M7tvJAHXFaclpqeliGC7miuIpJvMF7FIvm3AzkgoOB/Wg1S90nhVJ5JWzt3cEHooHAIq4jSWTxCP UbG9mjcs0cBaOQqO2GHUDuOuKCLdC/fajbz6XI1lJFPeb/KMbNslt/f34z+NcfdWN1fqqXSI0AH3 XQMcn+8fwFJ7MuKtK39bn//Q/lA8HRWNlGtpe3ZsZ575URpogIEQHbkN36k49M10Xjy8uduh3Wm6 FZanaaf59tqOpSuYpLhXGYduMHgjjnPP5fMrZjVlfQ42xtrm4mtHms5YTqNuLm3gCsyKc7WUN7MC OfQ1q32kwW0crXfmAQt5pwvMbL2x7YpXdrCMO01u71EHWJNkXk3DabAzH7NcSxKAqkp7gAZ7/jV+ SyR5fti7o3xmaNfmT/ZzSG1YuR38Ol2UmrSCJvs1yIm2MHlVz9wlOvbuMVF4kt724FlJBIk13qto t6E+ztHEATyGOANxH60GU11P/9H+SzS9Ht4ZW1U3l3aX1su+KCRRJYwOvQ7epJx0NMuon1e2htHl u7eaa+E13Kh8xAq85Tvknr7V8vY5ZfCw0V7Ozt7m2vDJE/2gLcNJCSSvcn8P/wBdbOpzWsU0Frp1 zb6jEVJt40BUz85yoPOcfwj1oMnGxnaDfCNprebTUtYDcmaSWV2Nw3GDkY4HJ4Nbur28UcMsIur3 V7fUiiSYRIxYofuqmOSi4HJ5APWgRR050eZ4p7nMdsAkySD92oxkFWPTHtXQ3dla2QuE014NRRlE j3CYaNyQDkH1U8fUUDitUf/S/lGuGjmsxdMio5XyxvQjdg4+tZZtomhkhaFjN5iSEtmMDjPyt6dK +XtY4ZfESyabEyfaNxSWUeRLEThdvqD6mtu5e5tVlTT7G0GbBSgYiR2YAYyPfHr3PFBJm2d9Pf2j Pdxpa4doJ2iA3xFMZ2oetP0lr631KSe1EtvAUO2e1t/JuJccZPIwSvXvQEpPRFy8udX1W00G1/s1 rK2h1G6ne5vpw0kgwg+RB04UHk9WplrPYa5dNptzdCK3sZQ88jRHzVBHy5XjOQM9e1VHSSJpys7n /9P+UiDTLRdbkheWO508BlhuLlCPNGSFyg5GBgjPfFbt1pun2Qia0ullimYmJmXy3fH3l29eD+lf LRdpSFOD2KqSWsDN5qTzK+EL7NzAdPyqk19bWsEiC3AeKTZHbvJ5LSqcfd4xVK1hQg+VlTULPSbt xJEwsZplWIBEaRCzAYyO5B6mrxlfTNNWSSWCWWMiExchnHZsYprZlKKUWl5EEmrTuGnKtKptxA6m MBUX+EA+x7+tZizWay2pms5D5j71kEJMKOOhLjgHPTPrWSV4WIikm0f/1P5Uo737Tq9lp/lQyPdx s0QEoMi7Ao6H1zWnaz29vqM9u621kpiY+dIfLdyv8JPfP9a+WSvGxlNWdzOvoYZ57eaIJJI+Skke GK8/Mcjp0q7Fo2k63Pez3EEGqXVpZCG4gmO9LTBJVzg/e+v5UnpHQUdyrDZwssiQlwyNj5ARj8xz Wffwu4FwIRJLGwUDPlu2O9PdaG3kXdPu21GzlijiW3vbW7U3MchIJjyCHQ98gYIqe8d5bmGSJUaR SIn6RKOOD6f/AK6wJlLlP//V/k91O4kv7lb1TJcXEKi2aVvmVlT+EN7YrfsVS9tIridngk5ha325 8kDHz7j688e3NfIJtbCTT2HarcW1jJANNcoVfy4ZCmOdpO4A9DxmoRcXtx5cd7cm7u3jDG4ny8gX 3/CnD4i200V2gs7eaFoXNpOsrSpdSA7gGwMY6gZB496kWJ2u0to/ns5Jt0TJGSnm4yx2j1/wrRSu 7GM2rWNyEaNqc1zF4iiFnDb2pit4bY73vGUBYy3HGeTg+lY1tp11e3TSwtGEtyVhglmVF6DO5u3f HtQ5JbkK19T/1v5aNJ0ye/kuEg3i7cOEScYjO0YDKehB+tYU+kxaJd2Ec7rPe38pE8Fuv3WXh2JP YcfnXyrlbQxS0bOlOl2U5TY5RJRsllcB3yAT2/IViabd28TrCxN/MrsvkmH5YtpK4fPpjvU8+g4L W5NNGNVtG08XVxbbLxJDdwbvMiYEHZwCNhHXitOwMDwy22oKtl9kctHcYDLMOcY/L8M1Dep0wi1q yQ3UkM0B8gGzMZInBxIxBHb0/Gob57O5mFxHLM8xQ2y26OY1Tv5mAOvI/KkbxhdXZ//X/l5WzNxb t5K5uUXfJuOQRwPw5rOIEJSKTmRo8gAFYw3fmvj7HXKNti9O2otbQJBeIkqrlUlbOAP4R7VoW155 jpHKEWIocyRjL7+39aCCrFErXd2mqwRq1rAtxpd/C++aff1WRSPlxg9Ce1R3VzHBGGnaFHklUPIW DOM9M4/CqUWxSWjJ0a0nMcE+NjH5WC7wMdCRT1htdOjjRpZHYylVdyFkfPIGR+P5U/ZszmrJI//Q /lt1S/v1lV7G3UxxuGSOWYR7xnDc49K2U08ahLDJN87+UJ4yJBGid+Tnsexr5SMbas1hsNknUXgS 4kLrbL5YQSblyOAODgiq13M8V8JZIpLSykVVKeUXQv7k9hwM9s1ZZXv3vEvV1A3TTxFAJreRtsUK cAFcDkgDgH6V0MCQXUemGSe2liVzLZFoQhiLH5g3GT6c9qnl964G9qCxXF9aw3FrBDfRA+WY48/K cYOffrxUeoWTrFJH5ivdtwnmcgEdM/Ss4r3xWs7n/9H+ZO+02awNjcyPDPDN+7aJCfNiPdiO1a0M 1sIHjVEKMMNuQENj/wDVXx5rJoxoZUltUvbZEkgu5Xig8392PkOCSD0H1FXbbTdTurdrtYLbYmBk XAxnPITjJI+lBXMkrl+BokeP7VeNDK+YooZB8pYc5x14x1HHNSLd30lpNHGiyvnyJp5l8p5QMbmH GOfpQNNPY5yOw0qwEc1juku2lb7f5ku5Vdj94d8jnP14qlqdpcjPlPMiBhODEcLcA5zn25/QVUlZ 2A//0v5kNIdijJcySRxr95oQJJF9wPWtC1iNleErfzyIeEnl4mf0yAcA/SvjzoSvoQ3Op6raTSSx xNdqMv5zr5vlknBLDqc5qtqOqJFFHDcWMszTsFCQwtKTu7kAZA9TWMkrtE1NFYgsdSt765uHignt iEWBYJSTs2gj5R9f51K7J9q0+Oxs2aNHaK+mjBLQM2SC4/u+9EF7w4u0Doba4t7SeRmnkYSJiJWA UKQOgGM+tRabf3V5eSQ3kAisypMMjnaWwxGSPT396TVpM2jK+jP/0/5uVgsYpbu8t4opriVFiPly YHy/oD1zUOpR3gWQRwJFHIqvGGlJWQYzk8cd/XpXxPK7XPQHWtnp8kMdygjRkH+kJH92V+Mlu+eK vpqMsiS2tvFGY2jKF3OGQAg/L+WKlR7IT0RmvFJI4Tblf0Jrp7S3uLOCMjNvvXcFHyls9x696Gtd RRvbUyZLiFLi/W5hZXa0Gy4eMsmQ44yO+N3511Nvf+Hp9PtrZfLttSVjHE6xki+4yFwehGD04pNX HbSx/9T+eIXLmFreJEkuE4J3Hah7f596hlubOB4rbUbQTXJQSfMCERuzZ+tfnsep6bj7mpWfUJ3l aK1maJZVMUm07Q6+n6Vo2CXEMfl+XHcgHZmTqqnOQKogbKxN0tsNkWzOWkYIqY7En6VmXog1SM28 0NuVuIjbm4RgJSMkbSR2NAWE0/wzc2AuDboHs4bURrZrzMzKTyvqcHp7VqaVc6hDbNbWtnbyR3Ck tFeMUkj3c9OuRnpWcFa6A//V/nihVYABKGeQnDpEC4PsBVh5EuIlt4YMxxcrEkeHXueOtfnzV7Ho Ga19cWi7JBHDBIf3C7syNjgkjtzRLFb3JC3bIFjAliGf3hYdOKmSfMgOjUS3sayFvOwgQdmAAxiu ZW4kt7i68mIBUcqFViSo9/cVZrB+6W4rq4nmguLaXbMjAPHM58qQZ9Oma3Ly7jDGWTYJTwQmAo+g oI5ne5//1vwNsri9itkbClkQvC0ibgA2SDj8a4a71DVLs3ljJHA8iPiOdcoMnDDP4Y/Ovz89Alji ufI+yaksNx5LrMtzG+9QRjH4itKOWI3UMixLIQmPOVR8o4oA1o7ppBcCOCQLH8rF12o2eODRaxTy 2kyzRqtqV8tUkHmBcHsT9KDOa1uJFDKLd4oI2kSFDI8UY3EqOuBTI44DEJrY+WrDcVIKnn2rdq0b GZ//1/wRso2uIp1juIlmVdxDt8qj3/pSpPeLbnIwwO0sfujtX5+dFjR09ZBMTL9nkSRQskvDY6HH tWxFqebh5ookjihTyvNiJbOOP8/WgCGNpLu58r/lm5wkm7G9j0H86zm064S8Y/KdpK4JHzD61E9i 6e4W2nRl7klxGkR3eScKCScnA+tY/wBmS3uJJpFKW2cIz8Rg1kan/9D8DJFNzfW0VxGPsNta4+1B B50khYnbn+7j8q0RF5c4ltokTYP3UU5zGCO/9cV+bnoGtYWaXks0guk8yNS1yoYCOMgZ49M9h71F fWloscNzHPOZJ5fJCqC6DHpjp70mrqwLQpXdncTXNpHA+8MRG2wjaB/ef0xj9alaYaaZonb7WDGy o5baqP2z9KhQ7nQU7Um406ZbyQnVIowSsK5t3J/uv7fTtTbae7AENzIyKxCjLY46Dn8quytYwbuz /9H8KdNuDYLOtvJbyXE1w2xGG7oAAS3+B7dKffT24b967q7EF4wCdhPXJx0r82SUdEetFbE8cc19 G8ZLfZbULOMvhSdwwcd8HFOkNys8ZkZH8wZ3jlzzjBpmnM7WQy/ubqC2dDGqBvusnfHv61Xg1KWF ZXWJXEFtv+ZsFm9Px4oKp3NV9TvNRtwxxHBHH8sScgjHNcxp8UslysNmypGhJeOVhHkd8Z7+w5NB tC99D//S/DeeNY1JLAFem88E8DiqyGQyKyxrKSfLztyORj/P0r83PobtO6D7FeWIePy4xahvMjVX 3YZiS2B6VGdQcSRs0SugHluVOCoA7fjSa0sVGTvZlqGV0JMhPlMeQE7VrQx+a7G1i3RKucEZ4Has C5OyI57jE6xypsDLnIX5eKtW1tsjdc/6w4UMcAmgzUmnqf/T/ExLRtOnSO3t408p99xA3yZOckY9 6kiKXl28zN9meAlhbhtsZz6E9QK/MZfEz6tSaVitc6i32rMqku743Accdz+VdEuozRS28EcIG6IS +bx2xjI96SVyW29yC7kMwBmCNLJnzUij8uFT2xiqCNBBE0TldqZzFnAP1+tPldk0axvbUitmgdpJ kiESKMbgeMD3pbUWuqPMkWoJEFB2LOfKV2XqAeh71DSe5R//1PxG02+gvdQudNvdqRw2Ly2uwg75 owcKc8cnH51cspYple3urgxKVZlGRkFQccE9c8fjX5aoRR9VLVj7aKWQtgrKqoTvyNxxnsKqW+qy xG6tlQNBNJ5MssicrtPRSex9RWTVnYqMtLFy7vr4PZxxOpSADy0QAptPqOn1z+NQXZhRVllfzZd2 ZFC8xA/5/SsZRtqi003Yv6cFVFg83/R0OYXuGCySjtk//XqWDSlnvprwXAYGPyFtkkzABuzuI/vd qhK+gpRvY//V/Fi6Eom+zySMXR8ZU/KAOBTJZvJvFs5Z5AFVZ0khXerkYZQT2GetfkMo8rPsB73V 7NcFdqszfNvQZJz2xWlaPPb3UqtI7xyoGdpG4jIHQCpE1pYs211bj7U7s4CnA8wlAwHGVz/SrS31 tBFDtkJkZ/3Y6kH3oMeV9ihq+ry6fqtjEGQm6gLsByceuenGRS3d2LuKJJXmKrJysfAbPqf8PSg1 gnax/9b8f7KW0/0oHIjWHZbwZ+bjjJ/z2qK3uLVnhZZQYiC4Qf7PGP0r8fPslF3sdFbXkDQz5T5m XYgCg8Vz00ksUssf2iGO3kYFEB2FTjkN+OaB+zfQo/vI1Aurl5d7EwRgYQDPUUs9lFNbxBYzJKz5 UFcGPrkig0SUSzb7LaFoELARnDSEHYW781qWOuLH5pjndbi3jOHUHHHbPT8KmSurDsf/1/yotJbq 4sorq5kcSEmZ4+HedWHy5GO3XiojsWK7ggAuHuY/LkaVctEMg4B7dMV+L2tufcbGfAXEWFixGD5T RL8xlx6fj6Vvx3NtYqqTRoCy4EbDcPoaXKl0NYzvozCjgtr65lg0+VorhRveO5PlxnJz+7J64FaN tq8uhWuqWiW6SSXMXki7Kkx5fAb26KBzU8iNLtCabcNp8SyTFH85AxCnKJntVvTLm2hkufMWO4a5 lM8dww3mIHJ2p6Dn9KpJLYbk2rM//9D8qLuYTThdpEbNtBPANNje3VJRyFDeS3px3r8XP0Agn820 jjubSSLaz7DIzAngjK49+mfrWxeLbbUu/s6K8kKbo0bzIlyoy340AOu7qG4ntLG3t0VktVMUinCO f4txPRvb0FYqailvPsePbceb5Y3rujegwe5uNOLK3+0SRs8k8mWjgTewJ9Frnry3tmM000W8ygBp ZBljzwOah350jnaadmf/0fyPVIkiZILbzJ8bjvO0NnpzTrq3uoITbXE63EM8SyFIXIEW4Z2kdiO9 fi59XP4jPs4UjaONo5ZZN/lCQSZVU9WX2robW2htvtItpshzmWMn927AelBjPawRXC3MQEAa3Fq4 a4t1QG2b/aBqy11bsyveO4tGYsUgXeM+wHTp2qofEjLYrasgtLfFhJu835kQ/dJP94VyclyTMI4p Ck7r5U+0cD6VsB//0vyn0u5tdLsYbeWLzZDMZ3dnLSTR4A2k9sHOPrUYmM00l1tURMfkVByvtX4+ fTrYfckxW8k9uQSoyuR/F2FYFhqSs3l3kcbTvKHlkkjwA2flIB/Dn2oHbodBdSXUgYQLHHb7QGiU 8S455rFe88u8jSUMbdhwIwNykdQO1aRlZWZ0JWVi8lgNTkVI/MlAOY4s5x9aWCeytFe3lwyQyeV5 IXKgjtj0+lEH0Zg1Z2P/0/yZEZvhLNGUC2fRU5kjPG1Svoa6iy1A2kcck0MEkjRlo0k+dVbGM4B7 HtX5OfQvdmXbM8U893cuZXZ90cTjAf8A2eMcVn6tcTzXCR/JaidsjZ/CO6j8KBFFxHBJHGxKx/cB VSR+NU5bhEvPLJMkTjDpt+Vh70ESlbRGq5nmSaS2tZHjiTLqkZIjHTJ9BnFR2l8jW0iSmQGF8rCP ljUMRlz79qCIy5T/1PyF1S+8qazEFtPeSXUy248hDIIwSBubHAHP86nur2H7WLJI5JbiO3M0ieU2 xVBxlj04PvX5Oe3KWtkEE0UiGR4lM8TfLIhxsBHIxUyXd/N5mm6e0UKDE7+cSoY55x7kZrFtc6Rc G+WxHLJZCX+z5pFuDIoLwld0Ycc4weP/ANVPmuZbOIW8ygWUow0cfzNgHgFR2Hp7U7pNmkX+8aQ+ zsUe4maMFrcxgRjbtAGM9KSa91XUEezRoooAQPNA2SyqowAT6Y7UpyNb6tH/1fyXs7q6lWSwWG3d oDvm/ejbGq9Tk/UcGmgwXORNtwGxvzgfhX4/fQ+pukkvNFsRQ2rx/ZJFEMjYdCc4z1P9avGwtkK3 pcmWNv3Uh/gPotRypt3OiEbxQ4ahLcw3MF2AzMu2K4Y7pgexwaksIo5reCG9iilit3Jjc5X5jxk4 NZCknFNMvCx27VeXK7shSMAY6Csi7tZTftMrq8kUYzbxyjy3BHAGD3zzRYwSbP/W/K7Ulk0uwDGB JJWAlWOfJjHtmqdrqN3qSRGG0SNcZaMzbkQ+2a/Dz6uUbPQ6uHUy1l9knjhWSNPkiLYjUjjr6cCt RksRpQfTbTFygaS5X7kcrcdDjJ+tJtLcgwrG5lTypTGyyxybovMT7uD2B7V0olMlvbyWLtBdyyND ey3FyCGDcEKuBtXGep70x3drDksYraVmtwrgRBBhRhSOuPaobwx2rCeURtcyQGAKPn2hup9j3H0q ZfCy4zsrM//X/ODQ/Lj/ANHgQw2+SyGV8GQ9WIyfWpZYrkXnm2Myb2JF1Gcf6QB0BPbGBzX4OfXK V3Yrf2leXVysKQpZCKILNLHIZH3dM4I5/D06VtaTa20DYld3lLEi4nUpvIGSF7H8OlQ4Xdyi7qWv CwtLi0ayhigvZUtftxP793ZlwsePw596NLLTtM91bsosEWe1uZJAxut3Byme3uO9YyjdWFdFfTZD c3l49xfXSx2knmxwrb/KgJwD24HAzXRzW6xRjUP7SS4dpfKNpIQZTkE7h7cAfjWLVnY3U0f/0PiO 0jN1HJb21yySvJve3mYRxnjjDE/WueE9/ZapPZxRzWyQzBmUMHVnIG5hj3zX85VEfcuT6s7SDTY7 lbeO6niWO9BaUXDZ35B468Hgf55qKGOzS91SNNEjm0202QQm5YmLYRh+B3zXPyO5HMiCCSxjfztN VrfT8HyLZPliQZzgD6062g1HVWa4hhS3soyGnYyHzJedoYD/ADxUWtoWtGad5f3EcVvbhbee1ErL dTXClvMVV2hVbtg4qxaLdws00cEctyqA2IWTekpYDsOPbGazm+hsndH/0flqW1v7yF7mNraFAm9k aULgjg4UnJ6niqdvFexwSeffRzzyEgGFDG4ToFPvjjg1/Lspcp+hKLZYtZ7mK3aNiYI9wFvHK3zS Njklvf8ATFbdqEEX2toJLiRRkRqB5r46qpPFZylc1irKxNEk63W5WlRbjgRyIV+Uc4I9RitBEykl qqp5jN+7uGypT0BHtWMpK1kaQWpaMPkcPIG8sbA6/cJ9q2bORpo95ciaIghBzkc85/AfnWTtbU6I J3uf/9Lyy/liFstzLGzN5wV0UkyuGIGcVLff2bHHbmymlVolDTbhhDlfu+vH9K/kc/WEuiJ4ryaG 0yiNKxOYiRkqScDj09/QVcnvdQv7qUalNJDdqqLCZEwkiledrDj1/P8AMNVBdSezuPsdpFpFujvA Gae5vpdoJkOAWOOTx/KrEktpLYrBC4uohnzJWQ/vD0Iweo4osWU7G6vb1WtkTCw5itmZvKUBAflA PGBjitWy+1xW9pdzXsSuo2Na4BllJBOc47HNS4pgf//TpTXUF8oe6hjuxbxsEiyYixIIwWHPp09K xLPXILVILZdMK3ckjK8CKxtIhjO4yD/Jr+QZR5T9iUmlY6m1jQQmUyiOFj58ymT92D+PpV+NJHmL RGLy413NI75jUYyPX8qymtLk3RlwX88k7Ty2j2HnnMcUqGMN23KD2PUVts9tDBKAhWWT5gemD1rn 5EaQlb3WZVs90s0k6k7ng8qMliq4BJII966iFFktipnitISpd5JSUjBHXGB/LNZtWdjQ/9TZsY7h rhjHGZY1z5uUO5fRq2n8iUi2LFNy/OxOdpPrX8WOGuh+0Fcll8yIGOaC1QohL7mDZ4Cj9c1BBqbm ENqEsskoJQpIpLLjoPpzxTjFRGtwNxdTmR4ytm0PEVshJR14/HnHf3qeS7M6PbBIjG8PnvKXxICr BdoXvnd+lNpNWNk7kbeZBZTNE7RyrH1jk8thk4GPzFdO8E8mmW0U8w+0CIEN99JOOQT1qVBW1In0 P//V7hIbaFUjVYo2BywVQNx/rUxubHznWe3aS3MbJ5Jl2MxKkA7h6Eg9O1fxVyM/bIS6Mxiq6bat JseWEZMUS/Oyj2HWq1iiSs9x5Tb1wyrImCoIxwD9ai1jQ6azmlhgmZHEYJHkxv0lbPIHuOtZH9oy W8l0t5Esk5YiJ0OQx7A//r7U0m9EAlrqNu4mlvWSKOEZC87SfSq80y6h9mu443sIkzJsiYybzhgA RnOMlT7Yp8rvY2i1bQ//1u3FyyabaLPLCbuVmDIhO9gDgDnocc1jLc3Vg7F3aSR5yJUibZ5cZ4AG P61/Fyilsfu8krE0usPaPGeVEh+XfzG3saydQu765Q28ttBlpCwnUkyIvQAdueDz0I4rVQ7ii1Yv 2V3p3lSJBOZZYAIp2ZSrISMkVcF5bmVLVIftUfkgPLdMEUueSAAe3rWiSWiFz2diC6uBC1wjGFds IkSJGy/Jxgf57GsTS47AWOozpPK93Fd+bcQSBlkVGAAIBwTzxxQZN9Wf/9eq+ofZry2ktDdwyyOU Z4lbEaspU72HQHOKnfULrTPOnFst61wgjjif92sTZGWVgPT1zX8bn7emnsRnXJob+MRTMtxJGJhb OuEVR2b1B9O9YZF1NK7wTFPtcrPcmAAIG3cryDwOn4UbbDNNQtvLGk5kKOhIIxg7e2PxH51Uv0jT bepZLcQIwHzrlFzwMnt1FBm4asr6fqWpwtfJbT2tpHPGI4sWiSyxdyQWB9unpWhf6h4gt7Jv7RnM kV/Eq2byW8cYmEZO5k2gdDj86uF9TM//0OQS8laRLhpZXgON8DL+6BUkBsfnW7qd0l+ElnHkXEcX +jX2MyucYCt/s4AGRX8exberP2gxTdTTRql7b4+yjdIYRuabPv1xVW+up2twltBAiRkssru3mk9l x09KtJvYylK+iKY1l3/0UWjPcvCAXjhaRUx3yOB07024F7e2rO91LLJbuFdCvyxjaAFHp1/+vT5Z dhczSsY8c93psUmN8XnMchzwQOM498CpbiGKeOC8gK+U67Jd0g3JIMZG3075NbRi7WRJ/9HyOeNL eKG7aVZghDRxo2T9Mf41BqjXVwJJ7WIW6+WDFEWMkhOOTn39K/k5JLY/WpNN6DA5nhijjmeGWdPL ke6YIFbB3H6frWa1zZrMY47qOS927Yg6krIF6kD29+tMkqg2Dm4NvIrSBd8queGfowUDvn+VZttd y3EZVojGgJHkOMMMHFbrbUib0sWr/U74op0+1tWvIFBWO4BNuuOBuUckcdO/NZ0GrazFFueS3hvy xMgjhLWqNz0QnOB6E0zI/9L5eiW6kikvNRvc3VtH5kSQrshdy2C23PoTxU17cFIY5bd0uHMYkKq2 SxPUH0I5r+XIJp6n6nJ3SQ+KS5txHfeUyebGGVJMGTdjt6fSsEW1qNTm1AWCC+dOLlvlWEMcMcdA T0J96sOd2syxcypGfIbYrO+TcgB1jx0OR/Ssex1PVSZdMljiVo282K5j+/KGJAP/AI6OO1BGxQu3 u/tV0kq3EMmdkrTgqM1Yms/ItYNHvo4rWbUIvtr6jtNwbVAMR7V6HOc+vFXGL3YH/9P4zhudL0+d DBfvf3lqAuyKJkcquCHVTxk+3pSXEks89xPqdwWhblQB5xdWxgMPXnkdq/mqC1ufpyldmGbLzPEV jYRB47G92Q/aUQSQ2xJGWYduDwM1UvLubTJtUsnSG6jjuGt9PvfM2NOoJ+ZUB46dOeMV0011CTsi rYx3r/YtXtmngltg8UxjYhWZsjaW/DpWbBf3SXWs2a6cIBFGtws8o8tSxJLs36cdea6KcXuTB9Cz E329ZJFB3rGSoPCyYBOF/wA96r6ZNp0WlXes3ejrcTP+4AdmimjZWI2sARkex/CvWoO1jnqWvof/ 1Pyo1jUbd70TC2FpYOT5bxBjFC2Oeuce2TXj3xIsbaXQEvnkRdl4xXe4Fw2IydwHUjj6ZIr8poPV H2NZ7n5g/E69udZgmuI7wiGHi2DJ5chTd8yHvjqcV83XumXYcXUzGOAHfaKW+bOOWA7Zr2KR4tbe xVt4ILzdb3TYa5LBLpgDKG+prZs7Yae8UP2mTyLZ1dxsysg7/icdq9OGxwT6nsmmNb3dvbQ2pdlu HCjykw656nB6Vv6g0Tfa7aylMc0EagQTrtZtvDsT+uPyqW2pNI5IKzZ//9X+Ta+FrpT6NLYardx6 jqEK3MyRWpxbSBifKWQjAYAZ7cHjNYXit7qOb+0TbnUZ53EEdtdoZ4pMq3zsOxz3r5yXxJeZlhpW 5r9z59k0eeWZmuNOhglAPmw284mkjXJJOQB+XaotIjubZzAvlNMkxlgn3kzBQeAR29q6o7I629jX tBdapqkls05W5nlCQSsixxxMeue3vXp2mXupXUypdKW1CyQRG4hXdbXEScK0h6AjgdeQPbJ2jG2r NYNJ2Y2TU21PUTax2c0LxIfKCKQl6f4mwOpH9ay7uytNQ0zUNRt5m82zuBb3dooEMqspJ3oDgvxg cV12NHa+p//W/jftfDNjef6TYTWZtrqJftN1qaeRwPvDGeGz09cc1G1oJNQQPptlc6ZHGVg+z3Dw Mk6ZCzuxzuXIHH8u3Odc7XM67eO81C71DVbJbi71KJbUbdohhMf3ZHPfOOnfNWLG3uNOa51awnlt 759PkstzEtAyOGQrtHQbXbkepoavoyNixpEdlFZr5TSSX0xLXFwrbTIc8FMHjHNbsWqXWopcWcN3 aTRS/uympxLLGTHlWRXIyrZBGc+vtTJcrK5hN/Z+j+Vf6sY4LNpAs8VmzOImJCAgAHAyy/MRjHXv W/5V5p6ny0tXtZpReJPOA7MjcjkHpjsaRnzvY//X/jfns31DXrO+hs7B9MjgkmvCsCxM7HAADDkH 9MVaj0iNpIo4QIlt5BLaqrGOKFucscexP51wJtbFqVtCpOonvWWO4inMSlZ2BwGI9Ceciqx1TyTD by+aYxIIYXhUsd3JG72J4/GtyHKy1NrTdUvbyQre7tnl7FVR+7jx23DpketQ3l/PoeoR6dqFwlra axOGtYJbUEpgAF1kxnHPb1+tc4rrcXU4byGCK4Ebx288hitpgMqSOuPzH51n6anmNLBeu4EuUaSM 7JGB9ff6UG8PhP/Q/j/mW/kuoHnmS4gsrURWrSf65FXoAcegH5VUayup7qW5sN8Ms6hHLP8ALKQP fjHavLm+hpPoalm98YGS6hNvfBWWJF/eRuo4Lbh0Pt71k6pZ3s0FtDMQbdZCyRA8Rk4+bHqcVmKG 5Y08alZSxW1qbOEbGDXL58+PeNpA/A9a3bG61HRJnfyotk0bWtxNxIqqwxux+me1XzO1jUWY3Wrx A2skUU1nPm1e5YG01FflLQp2DDLEkn/68OmX0FnqqzXU0dqjBojIAA0TNxnJPTnB9iacZXdmYyVp M//R/kzvF03RJnaGa0nFxMJ/tFrMJg+4AZ46EcZHtVXU20+9094d8kNxdTKDLGNrnbljz7nbzXnm c4u90Z+n6XY6Y02r+RFcXkOJESWUq1yQMBBz371pX97dSN5UaxBXRX2H96EyMlG7Y5xQ2luYyjdE ENysHmXCwrvRQRFGoCqVx/AOoNcrDHf6j/agljtTJJdvcRW4xvWIEEHB98k1g9yORlWG0uNUvEk1 WKW+TSVKCG5c7YVb5dpH930HbtWhqUcdpB9rjiSDTlkjSQQsXEOCOB3xSLjFRP/S/k1uzNd2x1GB oYQtxGW0tV2+bH0LqQOoGfxPvmqF1o2naiTe6ikcsNmfNiiWby+egL9zg9q+fOcsW+jW+nQPLGiR tPMJFgP7sfMBlv0qZWihii/tGXM73ZSDZibbHng5Hpxx9aB9LFMQ2NxLcZuJvOimyIEGBxyC2Ofw NVZ1C3y+ZA5uY9vll4TGpDDHBxjp1oFY13tlt5JZPK3o0ayebB84Rj1Vh1z0qeSGZpbNJbvyLa5O 2S2jVWmcD+LPb8aylJ7FqLbZ/9P+SqVruZ7myvLdfLtXH2SV5Pl2DJB/z610d3di40HTUxGttLdG N/scvmOhUgbSOwPqRxzXzC6oSvuzGu7++Sdo9MYyJbkRWDyyZ8nJy2fTBJOB6GrMrXt7bINY1KIT PMUmljBVXGePl+mBjrxSGUoTYL51t5zTWQkKq/lhZBIowCPQe9asM2nedLMbiUQW9qN0fAM7HAGQ OvPTHvQNu5jaLp9jEl5HehbtL6+N3NJGCrSJuyqEE44GB/wGuv1+XxFqVpc3NmYbS2igWPStwyY0 Q42Lxzx6UGM3rY//1P5TLHXNLvNLvNMFvKupQzxyXU9xbtHBswQQj4xuz2FRWlukN2sCwSIkoOy4 JyuQM7snivmG7nLL4Rmo26taXkBkRwVDfaNn707c5X8awNLsdRspLLVVtvJtID5VmoIzGSMlyexI xgdqEm9iZRaRqT3UF1572pedposPOi/IrEYIJ9QeKnspJLWG3XPmsDtZnUABRweKOV3sQk3sXpdL d4xNb+UyffliYbd69MA+1R+HL/T21K5sL67bS7KCFmlmcEs2AcoqD+uOKbi0Fmj/1f5WhLLqHhyx 0zX7uwE0N3cx2M1g4Lz2jyb4mkHZ+vHNZ6QW0WmTtc3SSyQHZFDuJmlA+7+nPtivmVC60OBtt6mf Zz2up2V3EFkkltoWnkVUJCKvAbd09K1PD84TYIIZNTncCG3jly3msTgLkdx/nNSI1rjw3DBeJNM0 lpcMzM0DgrFKerLt9e9YczX328xWzhbeWTyFgK5eVxkHb+tNOxM9Ctb289ldSQi6dbUuZ4zL0t2I G9U9jtqzbWkDLePbKJTdnbPMMmWFlGNw/BcYNCeqJpo//9b+Uawgd0t4jNvdJTKlzxF5i9QGzxjF Qzrez6nbPaQrdhS0QhGNyseCUI6g/wBB1r5a1mzSTTNOaHUbfzYJo5YJXXABTlT24rM1Pw7qJSzu XvhcXTtuKSsAkJB+7RHYUWkmi7PCbKO3mu2SEeaEjmA3KTxwKztStbu7v3trUT3ct1KrIiKq7QF5 4/An8aE3rcS+FmgIxrVsUjdLJrGNFMS4iikxhc/7WeTwetawzp1i1jaQx3EN7se5l1EC3X5Ocwnn nPHbOamN1Exi7yP/1/5SrS0sJNRuru2SWQWkmy2e5UCeIkDzACOPb8KuTW9tq/mf2lZvBBbloY9p /eykZxIMnqf5CvlW7RM6nQg0SytLGI2trO/l5aWMyS+ZN15wO2KuRapZ6QLyBVnkudRnhiMkUGd6 JuLmUjgH7mB7VLleNjPYsG+zOqwBY9vzHI4Yf0qlqjXNuft01zbRWtvKpSKF1nVjIMASDB7578d6 XM7WLlK7VjJttTe4iutWhEUCSyCyitLd13grw7spOV9a24VjvYJFhmSYQLm4VplFwobPRc5P4VBL be5//9D+UPS3kmubqyeForZEJiKRkcg4GO3PfvWhNZ6jZWsGolGEElyIHt2O18ZHQY+pzzjmvjzG Lsy2gttQi1SW0s7m1hRQLBb5hMzyAgNhsDAHPao5Ltbe9stItnuY3v7YefqBtg6QHH7wK3TI549K uMXdM0k7LQ0JrLS7mVonea7jtY/KinljEEtww6nA4ByOcVz94b3TYvtELzOY7keXbRkICD1OT6AD p6VcYqJiNuL3SFtzNDp0E97fDcDcIzB1UgksfXJGM+nFXBBb2Ujrpqy30FxbpdajDckiGNto3woe 4BzzUzTvoB//0f5dY0uL0LcxIto/yPbW9m5dU6fLnOfbnr7VzVzZ313qEl1fR/ZyXKweUxbZkjnc fXGSK+U9mjC9lY0JpLjTwLJZJkkZF8ubyS6MW6EtjAPGfyq/NbXWo2+n20d5YweWTFeXW0RXLl8f NuHUZz14A/VOGppTeli/o8U2jStbWhhvTHlXHyyx3I/i+b368VQ1KL7SJYnto1W5Xy9vO2AEg/KP /wBdS48rOhTT3L1haWmni5tr/bNAIAtvOjEsjMB1H+etSnR5dMvrfUIhaXUEOyV4p5/KkO7phRyR yKuMUjaEuh//0v5hLa3kjnv7zyYbRpf3e+O43+YvoAR/LPbmqCRXj3Ek14tsbWP5beJV3O2CCHJx weMY5+tfKyV1Y65vWw+KeyspdYvzZpcQzwraWbXJPmWxJHCqD/nIp1haveNdN56Wi2dt52x1wDyA MURjZamXNEbrVw9xaRQCWCIsBEZHQEzL3UHP0pNCt83Nw8ltBcxyRLbLDtJQFOjDHfpVESlfQydQ nuIZp0s4fOcDasa/L5LZ9fQCtVp0MUYuiNykPE8owpI9Ce/+NBN3sf/T/lummWUCQQgyFxH5SNkM Onc9/wCtS3Lm0hiRozbFlwkEZ3tkdsevtXy402tjZ0fT0ubFpNgia9RZXlvIijxlTnjvnjn8qsXN 3KkN3a3V0t1blg6tjAIACgLnk9/fmm00NSaKWnj+0bqawWO2aytoPOlvPNwUx/yzcYx9O+ay5dPv IroW9sBOl1L5dnbI/ERzyxbt/n60g5naxdS3m0sx3UmqXE1xbTEXH2ohnCgYADdNoP48Vs/v72aK 9dT8v+rZv4cjk/jU2965Sk9Wf//U/mkuGYFVkZJADg4YECq9+kVpaRXpcCLzhBsiO5i7YCjYOTnO K+PAzbmVpLaysFtzErSMBHEvILZPQew7VYs1vI4JYLdHhtoEG14kJaPHU7e/t60AdHrFrDfGzOnb ryQIm6SWPE5yBv2gdPp7VlzyTx+akZdYsDaWxjJHIH5fqKCovlMaKSwQzzTXiTvbuI5bYgxOWYcY PfGRUWkTJc3EdlFeXUiIzSzxzwOAyk4wHIA6kdPSm23qa3R//9X+aCewezvb1WiksIwymCEKWlG4 AgnPPccmqmk2kt6b4XDXYSBzFBNJEIhI4PO32Hr7V8edCfVD3+1210IRJGEjIaVywYsuMgY9+Kub Z7iWC/tJ7VoYpSkzfaFWdCP7q9ev8qmUVa5nN30LDQrJNJdrFGsjgK0ojClgPX396g1XV5V0/wAn Tils6ybpXhhy0oB+ZXx17jnpU0/jRN7wsVotN1C7kiuWgW4uPKMkMEzbExg9MdOmen+Fbv2t7iHT YJYoA1vC0D+SNxALu7fN1PLEfgKuyvc1jsj/1v5sSIdODyFkitd2+7m2/vIwerY71G1reObvFxv0 yVtunXOwpKynIZiDkDnGMZ96+POm7I7GymikSyVmkVhkSkYab1OAMc4PStFoIrZjJGd+0YKk4BNA Nt7lbUV8ywlEdzJZXJ+beAFSMDDZP1x+VWbnUrzfpTXlyRp+nOJZZ7ZcTXCYOUOeo56Y+lROyWpc G3obE1zZ6gP7RSCf7PKQgjkj8k7RnqCODiudWO2a7jSJzHcW8/2iIsQrwjGMLx0IPP1rItuyuf/X /nRs5Yog9z5mQ77nbvn3/Kl1O4WeMRRq0jPllmC58vnpX58up6aleDKyQ/ZnjMgLFMFfl/1efX/6 /rUsNxM0kkcchG1gWKnn1pmTkk7DLo28ltdSrMLmflJIDkyD1Yj1471T0tnRjEkEUjFR5X2hCY4m BBVgM9QQKATvc7Oz1XV7Jns3dEDoC7xIrbyeOH+8MfXjJqFhEWnETmG7dQxmSLGccDkjB4oKP//Q /nOml1BZYnsbmWC6t7hZlkiAJbaclSCCMNyD9eKuR6uIrhLktLZ3txJiUr8ojYnkL9cmvz89An1n SNKe6ik1E3K3Cw7otjEtF5mCHKA9enX1rKbTIPPjljuLiYxLx5nyseMdBQBp6feyiV4QxtY1O0SZ 5ORycdsVHNZxRXFxPAVjWQBpBH92ZgANx9zgZ+lNprcd2tDPadbmSBAixOr4jC8byAen4ZrUhtZL ydYdwJBA4biq5Ha4vI//0f594he28x02G73W6bZ7pLn7sIyRtQ9jwTg+tUL+BozJ9kKyl8srgcuf rXwihpqehdLcWzD2drBFcJHcfaZDLOXb99H1wgHYc1PG5Qyae0awsXEsblezDjn0rIC7PHLHEoLj B/iXpx/n9KvWrPKHtJGCJFGZGZiFjIAJ6+vH6igLdCC3uWjuftMUhSErtiKnB54z+tadtYIHjdgh jZ87ZG2q345rSb0QlFLQ/9L8A7u30+HUbh7c+XPjMvkjEcvPALd8Y461OuoEKElgzbufKZycKCeB k1+fndKNy5pqW1nbXMKECHrA4GXUn1/P9Ks6dFPYxJDNciWGaXzlBIPyntx7etAuRG3KXkMnkrGi IMrtODx7VkWzXDzMkkoZ0yyIG6gVnPsEY8pca1N9JEnnC2kU73IG4uB1HX8MiqF5bWd7qdtpV1cu LPzA8sqD/VhCGYAZ69se9Zln/9P8HrmY21okCRAwtMTvmTbOqj7v9Kzna5nMQ88Km7JKjcdo6D8q /Nz0BGghiWeYTuDcEJIEk252jA+X8etTxjUEEK2xAiX503MDI7fQ0ATaPY6pFdXl9dMIft2JGjDj KOvy5AHTgUXqxK5t445GM586W4PTfkDA5/zig6Lo2LfTk/s928x43yMyqB8v1zWJcaY7XHmSXsst uqYWFQAN2Rznrg0HOf/U/BlY4NPWGWKEKI5PMBz8p56H/PerS3bTteycEXR5j/hPcD+Vfm560Xoi uPtZEcaviASfvWAxtHOB+lRT3xjYbJC+w/eORjFFijRee4urVVlQSQS/KVOOfp+FSSi2NuthCUS5 RPNmCqS7ITjkn6U0m9jWnsWNIuLeIXFuxO502whvlAIPP6Z496ivLWK3KXmDtjBOUXLdOQKGmtzW L5T/1fwot2j1VIp/MAg3DaNw38dQV6jrU11I0EoFvKY1AwQoGxxx1r84s7XPoCrfXTRzQwLdRvPN EDtVw4iH+PNWVaKOxvv3WZEtsROPmfzMjLMPTGelICK0nlcJBK6KWj++cAdK2RqS6fFBbQo8rSZ3 zKBhMdz9fak4p9AJZI2uDJPuVoUQM65GVycDH44qK4lCwqWcuQcxZ/gPrS5YoNj/1vw7+2f6OyES XFyz5Dg5ZvY/4+1RyJIzqdpj+XkA8ivzOSfNofULVXNZdOt5rMTrN/pEbbmR/lXA56/hVG3muJLr 7Wbgkbtu0Nldo4C/QYqoxsgOik1aJI44Pslu7NkFskS89D17f0rnrqwXfdPcF4wSoj7uxOMnHoOa o0U0lY19KtLOwAbcL+1L75Ibv5FfI5B2nOPxrIvLW2juwywCCKSXzIFiBMUHOcDvx7molHqhuaWx /9f8QpIdPgRnAkScclwuEkz/AJNKLaG6gEdtFtES5+0sTvJPUH24r8vPqDEFxf6cQsMEkyf6twuS CM10TCzWW2WWZYIz89wCN6ng4A/HHvWcoNu6AW1lhlllCswSM7UwOO3H8ulLfNFO0MVvbhL3O2Rw STOo5GR+f51DVtGVD4kVJpLieRIcMTbpiKNEBVznkMe3fmtyxtSiMod4bksJUBOFyOoJz9PzqOXV NGx//9D8VQ7SXErXAaQg5JjXIBrU22lwDEtu32kYdLjBCtnhkPbjAr8maT3PsDQtbS1s5YZJZTDL nywwPPPFZ13FNDcsiFJFVvMO48sPz96OVJWLlFJXRBqCy3U/2iSMQWzqqRLGuIoioGcevQVVRiSk abZFPKyqcjikopKxBchT7XMWuItwhHlxyyjGOhwp9OnSq0F7svHeXJTOyO1JHlx47jvmp5NCofEj /9H8Wo49l+LpHd+G8w5BCqe2P89K0vPRnuJFWJLW3iEny/LIf73HfqK/I4x7n2zaTHPrUKoBARG2 0MJHG1UHfP61IbmykeGCS3S63OGkc5fcx7fSpcWhpp7FWeyub7ULO2M4sg9wI4MthBk+/b/Ct6ZL a2KW63TvexKUfAAjjHTO7v0NJK7sMySTAsqNdRzwyLufoShzwOB7Vv6J4dTV7O5hivbC1UgO7yyh ZGz6L97selDTiQ5WlY//0vynS0uoLVLeS5zJH+6jmUYOF4A/LisSOf7NqMqy3bKs8bJuZMoSOmfT PT/9Vfjso3Psud3LVqwi/cxyxtcQqWVC2EHp+dV47TUNRuVutRkgtobccWsGZTc4H32YgYPsKxKU 31EumAudPeBQGeQpI3TYig4P58VsS/v7WS3CLK05CqVBZgQeMe/FBfPfS5GdOuJoIYF+aWM/vNvA CjrVpoY4LW3WARo5YokZIDMVxnIoNFNpWP/T/KmWK5gdBKsbGQ7V2kMo+lNvTa2lo1qs9uZbwbWQ kbyR/CPy7V+Ln361VzDhsA4htriXYWJKpngj2/SuqS3eG2WERM9pFFgz53FCDgA/WgZmgRKZL6+z b2dsvBRt1xLjPCrWXfXkKILqcJFFGokDy/KG9z6UGD3Y6PVJr6Y+XO1hLbxLJZSKCySyZAwfQYyc 1c1W9Fu9vDfwo7TkSIyOApPOGxSsYzVpH//U/KDzhIsd1iNIFzGRkCT5T3HpVDVo5Y0co724kiEv nou87OuQPpX4ufVS+JjLQJNc272pdoAylnceV5/qDnpmnXVi8V2Zra4k4yr2wYGBeeo4zn8afK+x jU6FO3ku4Y7pFle3MmYigYhJl9DXQwaaLnw0lysvk3Ed4UfDAnaMk7lPb0NaRhZ3ZnboZmoTx3ar bwmQXUcQRJAg2MQMA4rJl0qFFiuZL2db1m/eqIwITgYwD15q7Af/1fyB0NF+3JHfXLR2bygSyKnm NGmfmwO5qZIpY5blrW+kMXmnZDKi4Vc8H2OMcV+Pn1UVd2OkubeGDS7d4pzOWbcVIxubjO76VmjT dN1G2N1LcoLiJlkijVdwkKnpx0xjNBooJCXQnt7VJbfy2Odg3HCr7kVh2sc1rbOuoSrJcTOZImUZ ViTk7TQXbS5p2TX6pNPZ/u2hTJkJ2he3NTraWjSCRQ73Mg3uCuIw3cigzlG+p//W/JJJFtsyE+S0 rlXA+Tz8Ajn1xj9KuabZ3cVpHPJdQzs0zuV8wNJGhYlSw9D0/CvyZO59NJKzLN7eSTStCVjeNYBG rLnzYv8Adwf881larpt0Gs44Dd30spCwmGFpZgewwB17UzEumJ2tBbF7hFkwl9bTReS+5eeh5rCl smJKxswNuwdYz1mGcYz/AJ6Um0txOKe5o291fW8lwRdzQxXVr9mezVwIWwc7umS3GOuMdqdY2Nve i48mTMqqUkT+JcYOT3pSlbYxas7H/9f8kEsrmK4tpLNpbZ7Ni0krHIkPIGOOO1IkUti7w3s8oW4k aUugHmFHOdmepU+ma/ILs9qUbBbQeVFeT2iJcwiZIss2xo9x5JHsP5e9aunwB5mMqYMagDaMM341 C/iI0grIg1WS0s4ri8WCC3MUe6QkgSTNnA2j1/8Ar1BeW3lPp1zDLFeCSBJ5kHzJEx52n19CKt/E 0QpNVBwE6EmOVoV25kAOBiksrJrl3iikeW6yZlRBn5ec9OwqJPRo0bsrn//Q/KCPQdNN3LNLLJay Sw+WzRfMhfjLOOpB56c81kWckEk0tlHPHPZxSmKAqm0qV+Ug/Qg1+PLZH0TbSj6mhDZGG5RZcSRh w0qE4JUHPHp061oW2nfbHab7QpLXQhhs0kPyg9CR3p2PQg7QRq32n2tvCUkEy6hJIIHlChhGoIxt 445/SmPLPoLWs7xwXkKzKfKklVbiYLyf3eOc+nTnrWDVnYiTvdM1447q60465fhIVuS6WtrEFWGD 5vlVwDwcY/OsP+y4xJa3FvqF3DM6kXHlQKY4snC7WJOePUDr3qZXSdjFNrY//9H8xtR3rZo13+/E EQjSZ/vykYHI/KudsLhYDDMyxAYKSIpIRmz2r8PPq+d3NTUdFeYWmowySBZZPJmQkGMIepx14x+O a6C0mu472ErdGKK1h2RJER5b5GMtxWDbb1IGyzo0iRADeuccYJoWNC87RxkgoFl/DP8AjVqdlYtQ bVyzCbu1CuQDHK20ITnaM4z7GkitIrieTy5RI2DvHZT6E+tDknGw/Z6aH//S/OD7C8V1Z2kYE96o aWK4kKoLVSCThunSoWQNdZQyLHGQzzRAFm6ZH41+ExfK7n1sY8rNOK2EU9pLJEzpM/mRqjeWzL90 lvXGDx64rf1CbzIIlt4k8tJG8oMw3w564+vFSU9mc+3lxy2qXtrDqEsUv2u3t7ptsZweCMcgj1Fd aE2RfbljhiuGTeLeOTzEVc/cAPvWU9zGzWpn3Fxbxk3mot9ktl2rI9vHl1XPJCjr16VliKc3Ecnk XctpfTqlpcxwENGh/jZT06jOaxnbqbn/0/iO4t7RJbY2N5JK8qtGIJYvKuMpjkqCeOex7010kMkV 5GrifH2a4Qru8wDhT/n/APV/Ok1ofYFXVJ43u5Y4yIbZIxt+ctOhwAW9uc1tmGNLSzSW8RrS7QNN JBON54+ZX9GGf14rICo+lsf9IskJQKIEEkhEYAyRgdM+/wBK3LZr21txZy2j291BH5l027MeGI25 Hbg/jkVlJWZ0R1sR/wBnteRq88iKsMnmmJ/9XOO649/6Uqu15LJp+n2c1ulminfBwkI7Ec5GKxmr o6oRT0P/1PkT+ybezUrZ6vqTzXChbpb9hKkD9W8vB4HPSrVhZGxUJLdPeMJTJ5zLsJGeBgV/L5+k xjfRG5dyWEjWd5qTb7a0XIgUbRx0zgc/nWo10n9m2V3aJ5cM0xMJZPm+X6846e1YyVnoWodWXJJN SFi11bvayakn+oa4lCRAE4z35AOcU22SdUt2vPLnZiI5jC4+YgDc2B0FcppCOyE1EKieRDvMRYlY mbcI88f0/Sl05HsInlaSSaVSWRCc4yfu/QA0mrqx0JW0R//V8dsL1dRmW6aIkxyfJFLGViyp7Kev StmKTS53lnnCW00l1hLZRuRySSx9vp71/JDi1ufrMd0XLy3mWMNbQSTKW27o1+7ml0sC4jcsBLCg 8oMxz5Z69expG5N9guZbmP7OrJaSJhmfo5zgkHpinRzASbINjrbEoyrggkdR6VrPSNgJGvvPa1iF vDEYJ/MkeOLEjL3yPwpySWt6N+nzFQkwaKRkKo4yQcf4VkJKysf/1uIZ9SsNQubaaMG1mVZLaVgE OCuMevUE/j7VsQWoJDbTwoaVyABz1x61/IU2noj9gJjEA00Usge2IKxBDtJz3INW9J2WqvatKwR1 OwM3r9axm9LGUX7zZ1VnKiy2iM8F01tjy0nKyq2DkLzVTVxbhmWaVUYnewicfuuc4yPp0rI1JLWS yiWE6hAt8nkMtgoOGhZgdr5+vaqf9n6iIGjvd00qMVEA6Sc5AUDjnis59DeOx//X3oJdRlhglmtz ZmeEPsjYYCqSo3Y7nb35zTGfyZNxV8Fclz8wf6V/GCV3Y/aErDVhaB0jtzEpv7rzZJJpcbFwASF/ AUwXEvnzxGA7I2wkzciX1NbKKiFug6GW5DSFIpPNkyjIp2vg5B/Aj+dVpY1vLqzKQCGeyDj7Qz4I HBxt/A1Eo9SotxZo3Nv5vlSTOJIt+VZHxuK4+8B/I1p2M9xfyX9uoCLFGPskpbAlwoLEZ9OfyrMJ O7P/0O6t1SSzkOqRWsdzallsrlBmYKfvAtjv/SuU1Sziv7CWVbiQ7ZFkt2iOV3o4IDHPTiv4vP2g s/2lJJAhaJP3UYUqhxvIGOp/nVtZbx1tr2VGhSU+WzxsJMADG36YAFFlsUpNaG0mmJrGmXNwmpLa f2ZKrRwpcJFcTtJlXIB5IUAAgD+IVkC3gaWK3E7NJCnJkAO/0I9+KSSWiLUruxSuLeLTI7c3U9tc RPet5tuw2Od3IGff056VeEYS4+2adJGYz/qEB3rHkYZfw5HNacvvWZtB2dmf/9Hd+z/ZpR5zkruL Had20n3q2j2G1huIuDlmRhkbexz9c1/G3Kl0P3ZtWKdzbrdxRvHMJLRATsMZXa46jJ7jjiqW6OSa K2kuBaiRWPnFgGXapPGe/H8qtRbeplbQqQi3lgtJNLvTcG5doZo/L+dyjbQzKOmeTyBT7mN7WTzZ mYSx/IB0A/D1/wAKp0+wirdRSLtu2vIIGkdY8yjc+D0wOmOa2NUe3kUvLdLDdyxrbb1TkBRgN6Un B9CJ7WP/0qsphlUWazuEthgXJ2+cfVj2NNButQvjbWMi3DylbWzNziGNGX5cnsMnH/16/j1RSWp+ 1RfKzOkttTvNRkvLp986qtkyjaEGwbQBjjsORVe3u3tZrjT1tIVCSNIZBN+9diSWyOnXPSlKN9TR TTK8Aa41SPzprqOe2gdLWSSQLZrvKl/MHc/JwPc8c1Hqkt7LKoY/6NFIkoWI7RKVOeR07VkO6GyI 6zeeAsccmWKocKvsPpmpzC1zbRv9qBit58Mjtudd24gKOwODnHpWsFoYtq+h/9PDDWNvbYc7nB4G ODVe4mhuE81JYVliiZESVtsagDOcZAJ9B7V/ICWtj9mk7IzFmvL60uZra4ileK03tM2IwduFA29y PT2qSzk0k6fNcRNLdyS2gdxPKBsk6EoOgHPFbpJaIwloihbw3kaXEltdXNo0kG4JC5XfzkBsHpg9 6gha8InjmZ1Vx87KxBY1cYX3MuZpWKOp2txdCG6kY/Z7d0hcnC78ghRj3xjNUodPKMbhgIbeSQhV TCrI+B179MCtEkthXZ//1PIZNMubpIxb4thAWkkjfCCRRnp+JH5VQkuri1ZfO+WZIw6LncPbmv5P P1i+tindfvY4WmYW8lxgspkDSAtzwKt2+lW2iRt9nnW/vLuPzPNMyOsRYH5GXkgj8OtBm52djFk0 5LXy547SOO4jDCeRWO2ckkhfbGKowPfmCG91K0itbppGYRW85uYEGSB8+1c8eo71pB9CG7snup7i K/tIltixvEDNcQ4aGIYBAc54Jz0+tUZonhvZA5yM/OG+6Poa0sI//9X5lmCmeNESWWMJl2VMxJ/v HrRp2mSz39vNb3lra2kMjNKbiA3ALLyAV6dRznP0r+X7H6gaC39zf+fHfi2a4jkKrcW8flJKv8J2 fwmuX157eO1ms3UxOUK+cWIkOR/9c00m9EBFqUGjSWNnbw3TyMlhHNfyO4igiKjLDcfpgn8qitc6 4bW5sJok3RmIx2yh22xjCkH3xnPWtVBW1Jkm1ZDb+6AheXV5hJ9svI7NGdPkLhSFVvfpyfWqWrTX cyCK8aMtFCIrV4Tu/drwqt6YrSMGyVB9T//W+E8WGn3kE32i6lSW28qULCrnziQf3Y64AypPcE+l aOqzwxRWyW0xlmnl5RjsKD35/wA4r+cIwvtsfpkY7ldZbtIHbyjGqqyLeQt86vjgc8ZxVXR9MuDY PdTRLOY5mKvKAxhc5O9s92yfrn3xXTCCsVy6WZjf8TYWl7p73IaK/m/0aK3l8pYD93cT/e/+tWNb 2Yktp4vtZN3axFn89wPNCjpnux7CumEdfIFFRdxLBNQt9LkSS5aaRHZ4No8tbfcc4GPw/Kqk2o6j bQSafaW4vo7l45ZpJYwpXHLbGxkEcjA6g16VFa2RzVFZn//X/J/WIbuFJbSZJbWKeXzfsUqEAbuQ SDyK8S+I99GbJrOTbFBbofMvGjYI2xSXCZ7jofXpX5Zh0tGfY1lZtH5o+JbvTdW1G50qS3QTGZ57 aGNhAJIiflJPrwOOxJrwbxNdxm1EEEIacXDRiR5MiMKQARjuec/WvYoxurI8SvZSRlRaRqs2n2mo Q2iNbyztay3RcoIWjUOQM9z+uK6vQjqNyt7BZQWt3NDaNLCb2MKISoJZ93QdOnPSvQprQ4ZdWjs/ DTT2Szy+e7TTLteSJTKtm7AL+6UD1Genc13E+j2N9GbieRmv0hCtcMcyFu529MHByP8ACna8jlgt Wf/Q/kq03WbP7O32+NbhYjHdWc9wNkcbqR+8KkcZBPFXNS1SC90e4vEubV4vLczXBdQVXkMU/Xmv npyW5lTVnJeZ8s6pp39nzrLo+pS3WnpMdu51SeNWOcZBORyR3xxVa6vIY8Sae8sc7ReXK2ctk5zt rrppW17HQ5aJFSK7vkFhdxM7RLMPtUcyeVPGEPzZxzz2Ne8aJqMcUC3VzHLHpNwq/bDESWaIkFiP Ugc49q2LjK50l5oummVRp95NHHPJ5sM8i5cxHlFHHDY6iuUvJRY8Sxme2gLAxxRFppieMEjk4x0N dLtd8uxpJ3eh/9H+Mi/S6msrqBba58tykqWpPkMQpDBVBxwf6nmt+2hu7/T7v7NKltdFFslss4jP GS2eoJ4B571znQQpNb5+xano7xfZ5BE0aqWimVQBuD9M55xS6obKe4shaPLbLFEYXsw5ZZ92OW9+ O1AFWOezsFu1gtbmO6tQEs08ow20pwCSGPbnHHfNW9H+wXFqmoajKdOjjuMz2u3aQXbBAJ45Jzz6 9aDBpp6lvV5NNs0uvOsopLK6UxNEgMhdfUepI/nWO2pTzQQWVvYRx6fcW4t5Ipso9vGuCpVDnnjB x2NTL4WZyk07I//S/jks2FlGY5nASSUseMsVwAFH+e9TG9LWd28BmhABVeQrsPbt2rijFPcC/BBo z2MNyXkk1GYiP7PgBwMcnOce1QT6VbaYY5JT50MjmRIpSDKjDByfxIrW1tDKb1sX7c6bZxvPIAkd w254gdoLkYBx3/8Ar0/VfDt7rdxpM19eJLBpsJfTrQMPLRXO7Jb+naucmLswlmLQRwwwgOCyJk4i Xb1PJx2rmBG7SzX0ssccduh/cxjc8hHXao5OOaTV2jqi1ytH/9P+RBbqw0/TY55Jl1O4vtNMdsFO 2S23fL+8H8LDsPcVb0iGO6jsYba0lc2yIwV3MhyBgEn6+teXNdS526FiW9f+0dQtY/JjaOyZU8lg 3kuQwyc8dR2rJtd5ksbKaSW+mZSZbq4iCKGHPzADHPQfSswp7kGq2EV9cG/N3PZXW8KYbOJUibYM fMD0HsKo22oSXFpJCl080ssrQ4dDFJCoIXp6Hmg1LJsrK1sfJ1hZ5rCwf7XbeQrSRxPkZ2KvPPUn 0FW5rTRNSa1N3YxT2+zzFYxgv0yoOfwoMZ/Ez//U/kU0w6Zd26q1t9mdpTAFCYlVUJ29uhHaknWK zvpQy3axyBRCLwfL0A3Jx0PX8a8nnkBXurlUSJywni87a6jA2Y9PyqRHnuC5hiMVsFwSWIkJ7ECp Ocr6bc6jHNfWxtj5OxXhu/LO/wBGBz+P5U5dDn09Z9du1RrW4+WBllDXDFSQ4WPrjPegW5feFJ9N N1pgMUk/7q8e5RomZR3AI7ZxzVRba5t7aRAkN3DLCUYSMTtDHOVPr9fWguMbn//V/krtxqU9vbWt tCktz5LE+fJ5EaheQu7BHQ9/SotMs7CZmj1JlutVmfzYI4ifJtFjOHTHccg8+v4V4D3MGrM3dVeK 8kW2uOPIjQKwTagCqFAJ9cDmsQtYXEVzpfySakJPI0+eL5xbk8Eqw4J6DFacseXUqMO5Ws7CbTFu 7yWT7JPI4LXLsGEjL8oLA/hXVXh1S/s9KmuJ45ra0Lp/qQszE9Bu9Aexz+FZC5bOxUttQ+y+ckVs kjSOFk89Sqx7T1/+vTb/AEfUr5F1XSYF+2SySSPBCslza2caAfOWHIB5H+NQ4LcpO10f/9b+S23n 1C4aKG6hsvNgIS927h5g78E9/Tit3ytL0i3WZmhEBDSQQW0R2iY54cenrj0r5nlZmp9zMmtgIo7q yk3PLIZJ4GQLFgn+A9c+30ot7iJLW7S5iS5kuh5Nm7IytZOCuXb+Fu4GfepKU0Yq6dJGs+L5xNcH aD5Xmqp6DA7fjxWpPHY6fp9z/aA8x7i18qy+fyyZMqNxA64G7jgc0C50TWEUbWywoHRmAG77rY/p V3fe2W+FXadIF3x2rTffJGRknpmgzeruf//X/lQjj+1K9zcRRWe91VbWUgrvPOF/vdM1YvpwgVZA qqg8vaBhi3Q8dq+XOSafQziRLNHZxR5ZGAmaRSsIUjnDdDWz4nS0sRYaTp93HezT2QvBFB8kNrjC vu+mQAOvNaQsyzm7O0aGGSGAPHGwJulHyRkk8ba6Sxk0uOyuYZ7W4uZDB5FvJHCWVZiRgs3pgHNa WBJLYzxcBzHDNc/Y28zywyLvZMdDg9ax7rSdHtJ5S1499fXJ/eXEmN7ZOVAAPfODSa0sJrSx/9D+ Ry3t7Kw1a2N9eXcjvcZhtFhDRICPuq+eCfcc1pXdtDqTXkaNNbWzZjaXIilc5xsX3APavnmrqxwt WR1OkaNZ6PZJK6ljeMtsJSfvL2z6896r6lLdadPpw8Ow2mnz2moiaWZCX3AckhOmcjORWBJY1GW6 nki1Wa5nMkUmZ5Wclfm67h75NPN7IIktontTGkpuPN2KLmIsoGUfGecD8qAktbGZHLNNZ3cdtA9z c2u6SV3XciqePlPc5YCtfSjJpltPa2V2Hi1KdG1RCoM6HZkR8/MF5PT1684oSu7FQjqf/9H+VvUk tTPLa+Q9rGAPlQEeXxyAOv4VSbTIktZI4bhobOytR5Lx5WZiW6KMZ43d/SvmnHVlz0aRNHd2UP8A ZdsNVa5v75Xjgt3XFwrRjJy3ToMjOPpVfUEuoLOKe9uxcSMrrHZ9Jy47gfQUlG6uRexn20F9qelX UiveXlxYqZpILxVS1tQWURlCBnqwGT0rpbWFI7W5lkhimaOxKR3JYrcrKQfTqKIq4k/iOStbS6il 8uX7Q8Nvb/a5JJFJt49rDA3dN2cYFbckVjqVnav9puZ5objz3kuMJEmOgVfzHNJqzszFNH//0v5c NNWK5ikMIG6NvnUDrWvfavaR+FX0y80a3027upvtMV5cw51KaPoEQjOBgE4X/GvmHG25lN3djzfS bOHSLy1igfzUuomuIppEbK7jllORnjP0471sxiedbxPsyuufMSaVCszEEjKg+nNS4q1iDn5oYmcR +dM7eXi4h2FXP5fnjioJNCwIo4bqeOBphNPblyRJ6A5pKKtZgaEen5l8oW8VraQzx+fI0m1J1wNz KR37fhW9dwWpAbTUjtJIWYpcJHseZTjh/wAB+tNRSVhOSjuf/9P+V2wt5EcNcXX2aKRSVuGA4K8k AEY56fjWjNqoub5VufOuIo4lSBGyd2OMD618qoRRznPavqzJHa6Yk0So0zv5Ucg8zBI+U9+MdDWh JqU1nEkUtmLK6t28syq/mSTLgc+nI7iqNNHFIqa5fW9zZ6UbCK4S4hkMtzKThdwyAcdehNaccsU1 tZvJEHH/AC1V8lHIHUng/hQQ1Z2KEdqjXsMcSx3Ydtv2WIcoM4yB6gc49q6fUbPTrC3ebS7l5Eu4 xBOZMJKrLjehTJ28+nUCgR//1P5c7M/2aLaNGYh/3/7vnaTzz6GrN/GTIki/Om0M0eeCTjn9K+XO coy6hcqJVlEbwugt9khByP4QO4IxwRVMR2VvCltbGWRip83zpPNOSc/1oNoqyLTiS1spDaom84yR wzH/AB4/SszzbhLRr+8S6XdcJZ2zOpSLdIQApB5J5FDVyjWjt9X1GzJt4bYfZUJnb7RtmcDodh+o 6U6N/tNnBJe71cv5EyzjCJtICqKF5mtM/9X+Xi60+e9bTpY2mi06zu/NuWt2wXAUgJ9Du5z6Cr8t o4to2Vv3byGJAjbnJAHb8a+Zdtbms5qVw+36FbaL59yyXBWWSP7PHn7XKwACgDHZhxn0rM07VLhA Zbmx88PEY5NkwjeJSflJ4wTwM9s1JkaMj6aumanbxW0lzFckGEXEAMkZJ3EK/bHPIqpHdT2tur6b EiyxJuRWbY24dATzge9BLbSZU8Nxve22oXM0uy/iuGW5VTvhOTwA3fAwKluns5dJvbTUIIr4lysB ZSssD9imKBSbWx//1v5abazS206S+DqyQxKvkSzjzsgDICnk9qfbX8NxcW73eI4X4UE/MMcHH618 uJO52GmvHNfkQJkhfLSGSTMbAc7eeMn8+lcvbWl/cagZtYt47KxSZglrDJ5ku0PgHcenA4BFbNXa GdK8VkNM1BNDiEUYnw89yCjSOwz87Ac8A9PSotKW3tNPtYb65S+vNpNxcW7Lsj/ugY7jvWSV3Ylt 2ZU2S3UrwRWUkoRGlMxO5NqDc2foAetXxqG6BYmG1Y4vLbAwWNDXvWFBtrU//9f+X15SHhhiQRxH OWLbUix1J7n8M0WY0+2h1CW6kMksG2WGWXLIcNkEZ9Ov4V8eJO6uMg8Qpb6hAodo5ZEeSNpoS28g dj0q1Z6xd2c7TzeYIb8CMxBQ/k9ck/XjIpPYG7K4+31GZNbs9RtpJEispBJNGSxW7QE5QRjg+v4V u2Fpd6s1xFIPLR53lt1ZTbsqEZGd3QjmmTCVzkLiGKx16bR7wpLHdIr288JEy716jcOPlx1rcsNL ubdnnh+3SxW7L5k6wlt/oBgfhxQWf//Q/m2WKW5uYLu4undJpA00lxkyMmMY55GOB7YqAzxPPIba 6hNlEzK0Sy+YVckDC8+3P0FfHlQu9jC+zwL9oZnnmuZZy0jMf3aJ2AHbFTQNYWL28VnZQzB3Msj4 +UuRjJ9x60Eajs62LmNbY29yiEiaJhtc5+7tA9Oh+lTm0HkzFhHbuS07EfdB6mpiv3hVvdFRkubS O6hmnhnjjP7ouYg4PHTvxRYXUEEcccaFLlgZGV+q884Hp/WqtZ2NkrKx/9H+aQxPeNdCaVWg8rDA nmTOQVx06VahVltUtY2KWccXlxoGOUHQ49Pwr5BJtXOgZbf2boVmJkvNQupUJMLTqZZOf4F5z9M1 b05re9X7QXkLO2RGw2KPqPakBp3hggWUSp5w2r/q181ZSf4fqKqSyKqh5EVIcBVRhhSegqZRuVF8 rG2s73BSEKyxjO5lUlVxjv8AjWHJpou9WnW3umtb6OAok0sRaN0JyAvbJx+lZNNDlK6sj//S/m6t 47yz8u3uzBLJIBvMfET+mM9K2IJFhkb7QqwMsm1YW49SMfhXwSjabO6nK8LMqyB72/dLaeWNJMbh L8oJ44+ma2bWyhsppm8wTGNBlwMxq3cn1AqnC7uZy+IqP5KTSSwvDIJk2SOijcc9VB+uenvSafFF aiWW5md8ZaBSuAcnpn2H8qFBLcqKaTBmS6uHv4p5hbxRbSjcRhgOTU9rr9jbNELyCa7DMYmSLEPX gMWwcY9hQoILNR1P/9P+dO1juRcXpbdtlYPbhlA8tSOgPes+5it/thS6Nw0skDCAIm6MSfwsx9j2 zXwvJE73e2htW2lCOb+0JjI0xtljkedyzSImccdO56Cqc5uhd+dZ7lhZtqk8lAeP5d6dkZqUrM1Y oIljLynkn5i3UGq8BxNMLpEaylhMdqIZsS78EbnHYdMD2p2BTaMVZIpLmGzmTfFaXBliZPl8tyNu R74/pWzp5W1SRIozI7SmSS4ZiXPoB2AFBN3e5//U/nYuruUAlUdI55gkpZcNMRxk1c02/hdb2zBR xblZd44mi7Djrg5H+RXwspW0Olt31Mi3t5b69i1hPtYiRHgiidyiSgHlnTsc8/lW/HPDLZm6kkRZ FYhmB4UKfWsTWKdlcctzC9vJILgOAgCRKQQGz94n6VE7zmONoJEKscTo4JJXvj+VBRdVLea1aMzS 2kwGLNIoVeJ2HZiT8oAHvUtu1wzSwXjuZxD5dvnjaMDp7VctkB//1f58bBJQsp1Z0g8qQoXT5sID w3WteC0lhguPPYXVizb0icZK4OQdvTP51+fnoFO61cWamMWoNnIVSdhHulUE44+pNW7W4srmdmgW SKOMDbEc/LgcdfpQBbiviAHdvKWaQxIhkHmZXk5HXHvWjaRQSXkcijY23azj7zVE1oBae5W2uvs0 LJHPMjBZj+8Ma9C23rxWbP8AYrcJM0kss8bmJ3aDbkccg+hOO2KyA//W/BiaU30gg3hQVO3A4bHb Pal0m2W6RJAHjIZogrLtDEcZ/r+NfnMY3uegQajpSwSlHkMYPzAg5yT0zXK7dStrxEMziEglnHO4 fw89qOWSA6qG73W6gSvLdFyrqT8oXAwf5/lUV3qU0c9rCbMopJUSdQSvPI96cYN7h5Fq4kneKELc NbqW5jBwj+xFXHillkisI5VOAv70EZywGBj05rTlS0M+fU//1/wR1FL6ylutMu0C3EbiORQwkQ9C pDA49OnrSWEny+VKu10PBHevzzkienDSVjY8kC3w0jIjyCRwp646ZqvHaLdSNHELdlyN/muELDPO B3PtVJJbGpoXcdrZyyRQXLN5EK74mUABiOcfQgisbUbqa1tvtSBZL58QwQjCZjPUlvyplwetiwNN VrWK9luEEwTc8XmY8tvb1qZEuLm3WOKf5V/eFWOQQBnAqJ7Gp//Q/CaC3tGjBtlZLnf+8UZ2Ff4j n1zVKe4C3P2RgcSDy0GMqfavzx/Ae7KVmQ2ek28Wt293LIVhCCByBv8AKXOSQtaesSI00kNhcD7F FjzZ/K8qWZgAdvPRayLKdqqPtjZi0pG5dpz6cVrxtIgAMLER/wAbDigmWiMhg7S3a206CVzu2Mfu tx2rZcSppq3FyYj9lI8/yiQpX+9g0EqfRn//0fwzuHUW8d1H8kbgSBUXJkX2pks8yJbRrkSXL43E /IgPTP5V+bn0kHoPle8W3eFOj/IzAcEHrWhb6TFY2aO8irFKvmIqN93B5J9KB86GlLZnjeCWSZ0P mSb+B16A/wCetZ1vq17e32oi90+SLF0wjeSXerx/w7fT19qAU09C3c/aIrVjbRtIy4KwKcEjOP0r QHmvarHHdRzXb/vRYyDPkAcFhjnBoKur2P/S/EhzK1s4uipONsUe3Ai4/wAmi2ulTTo4FEf2gSMr lfvPnoNvt/WvzWUbn0jn2Ma4uTZeYt20okjBmCxRFy4/usO1JaXUWozfvY5EgI+R2XEiEf7JxWbi 0KMncv2Ml5a3DLMIpbYyfuiIdpAAwcnufaprucRXaXMTqTH1hHEje4qGk9zZaO5btbtY3+yw7Gkn kEjOPmkXI6Cr9zqChvs6I7S7f3hCHA7AA1m4NbG61P/T/EmI3NtBcz/vJEiAacqPnRScA7euPf3r btZojbEeYwLEFXIwTn/P61+VcjPsDPvrS4upVRZA4tmW4AdscoQw/wD1U7z7PUr+G21KSa1L/I95 bfK6KMZVeeDwMZpOLS1AXULuOwmSdeLGDAjW4Jl34wAz+pPeoZJr23gtWktFW21F2mjvgc/Kp2le Dxzz69Kkz2qGrc3SC4FhayJcC4jVYfkKs7EAkD164rKTT0mjkNz8lzE/VD8q4znn1oND/9T8aNMs ls/tN/YtIYb6L7JK9wN5iK9dvGAev4VngLbXLxyfvIpRtU92P0r8nPsW7u7NK4htJrm0V4UhiChJ oucTYAwSe3fNXGg0uz829LSwJHyI44/MWQnA7c8Umrqwhl1Ppl9Gt3HeSOyLsVZIyrI3TA96oRWy SxpEJGhaOUy7lcmSTJyQ2c8HJ4/+tQlbQ1UvdK89uLRpBHEhM5DBwTlz71et7htFmGoxQiSYJ9w/ dlH91sHpQ0nuYtpH/9X8bLPWppnZnZ/nb5Y2YkQ57D2rduLYT20NxsCyqhZlByX7ivyFxcT6lu7u Z9nERPHeXS/ZSzFOW+WQDIBJrZ+2R3NxaZ3JDAHV2gGfN9CR3NZSWjsCbjsZMFvBM0kr3N3lXJhV FUJjPRu4wK0LCe2ghlEN1KpV2KxmIvlunXsMg1kbKSItNvLuyuZWjMk8l3JhkZiUi9Meg6/nXWa7 o9reaTbaja6k8Go20mbq3LruYEADyx16n9KDZTXU/9b8mrh5xZ6bcC8eXy4HS5t3ixMpBG0k+/Jr m5rWOYLcTTObhZ/ORXTdsHbFfi59ypNKyNjU2aSKOW0DOsagspX990GdoHvV6z1KXyYtOeabypU8 8w47gD7w9Rnv70Fc7tYo6xOrLCY0nZFwoRUJYZ7lfwpiWkWrRraXBDpsy0UikbhWklHUhvqaE1tZ x2RgiiMc9ugjhReSxHAAPpVE2cLtL9rULerEDG05wLY46qOxP9ahqzsYN3Z//9f8itNtluVlhu0l ZNxUZBCPjuD/AJ6Vp3WIFG5fNiBCSIPmZV+npX45BK1z6l6u5kx6tE9ybdYT5aLmMjgA9MH8qkNx eT/uTBFayI5YshJeQds1ZlNbGJe30hhYRRPePaXA82ON9pPIDYPsCTjvitSG+vI7Uu0ckVrMcRIQ dzAgfeGMjuKDMkljESwTxkysU3ygA5jJPCgd+OSePT3pyRxyxtPeXE6pjEcIjXZnHUnr/OtoxtqB /9D8eftUH22Kzt4meQxea2FIULnGSauNEyXtvFGixR3TbZ7p87E7ZIAJOOOgJr8hkrM+ohLS5tfY pUaWzs7i1u44PmllMjRrKmQCUDAEkZ6Y/wAayriCGxCTWbyFQSGQpsRTnBAHp1qTXnRI5E0SCNmz IBvU9jUkem4VJ3uJHigUpFDJgxRZOSRxkd+/egrmVvIpNa3huWWOU/ZZiobLYVMVdsbkWF5dLeyL NEo8u3aI/KuDyT65oE5JLQ//0fyX1B7O92pJap5ltJ5sV4zEMgKkFdvTv161ztlCxu2tbebCXamL zxJujj5/i9B/hX5DF2Z9O3ozrLS3dLq3K+WIYV2XD8sZcDgqKm1TVriGaKXTLtrQwzARXKY3pg9O Pbg4rYwNia8sdTu/tplWV541a4ZP+Wsm0BnPuTnPrWVfwraz5SWP7O6bjkfvfYYrKXM3dgczcDy5 jJI4YOgaBUO5jyRgjt+NTTWyWs8lzaTzW0txbrvcYEhO0AjH51TjdJBbof/S/Je7tr6OxCzzyMw2 uFcYEqk5IP4VQbUrdy6SxzbY4giv5LMgPTG7GBX5DytI96SuiN7gRWnkZEEMjEykts3k8DJrbt5b phBmSNEt4tofjdJ6bvWhQ99LqVa2hzWpM9/cXyT+VPAgWBMN1baCTxwfr/8AWqTTrmSA/ZzGfLEe 1Gb7qGlJWkzJx986CWxa+s1MV1slSUeawwSyHqAPeqLarf6NI9na6Zb+aYhF9sR2W6kQ8hV5wM8Z rOUd2bODs7n/0/yYu7y3t54TJ5q3TlZD5KlzuGDhuOB2q7Bb2lyBqFultazx3QlMSJlZW6lnU8fh 0r8eWyPo7fCW9QtvttzDNOo5JZ2RfKWTj0H8qxBBNDdl4Vl2xvuXaSGwv/6quK3OyOyOpkuVdBcy SMZlXlXOfzFYM8h1S4+2XIIu4nC2zhAYyuMH6HpWUkrXI+3Y6DMbWa2WQhZ/NZI+EY9Sx9+KbbXM W+W3iZ0dEzyf3UmCPlA9RjNYvaxPLoz/1Py71GDUNQt7a8YRJawyGzbynG7cozymc9Mc4xWZpWjJ G8kl1A3kpMxiLHKOTzn9elfh59QddYQXGsPNa2zwolhavcyedIIFKr2BOAW9F6mq8ttLbmDbE7CU sP3I8x2YDgEdunesZJJ6D5WW7e6gnto5hbpBNtAlRySyv0bk9+vtVuVjD5ckWGLgbkIwD9ak3Ssr GXqM14lxNEVNv5qAbO0Zx2zTvN1q10y3ePTnvPLulE5tUDXCozbS7d8d/bmgD//V/OS5v9PjhJuf tMkgIBNvH5hVe/vUNrf2wklit0kkAYD94nlkA9M/4A1+Dn2BYW71B/t8Swec1luW3wwBKZx+HJo+ 1SRIySxONke8k8DJzz70CezLdiLe8dUuJfIuI4zLGQm/ag65PYHAHNa32q0eOMQE3LucRyxtmOML nPT14/Ksp7mai2i9aXgwhureJmichNyblYdtwPWp31NBayW3mSFmbbCQ217TplkyMetYyi2zU//W +FrK0lSSO+uLx/IUqyzRoBcN/eDjtn8KWLxZY6dJex2ksrxtckrLcwh5E5ICrgHAGa/nZrSx9gQR 2YluTPcm48q4QytL5ecA52nsOSfWrmm+G7m/vLpYpYF0mGJZXkmkEeGyeCM8k8dPWsba2AtzC6tr pYobkiPAXbIOOP7n510V+puLRbk3bx3VxGlvK0YHmNswF3A8enNS1fc6FokUIbyS2b7PIkk8pUMA yHbgDHUV0WnNe2tzJNb7bcXcRjki8vax3d93XgdKxlG2h109z//X+WYL/QdOu73TLvfPrFzbbrJW iL5YONzv6cBgK04rFLlVC9SMEL/D9RX8v2tofptPYzbjZA6aXc214kkDh/MltyguVJBGMDkdjn1r qnzdweWFDeQmTEFwEAHp0FZzXUsy4vtNwkrIBi3OZIS4Dbc4yq9T9BTonAmljfz4JYkDRq6FUkz2 Brla0uXT8zXtJGubMR3MSfaUleTzIydzKcbVP0x+ZNRpcJbOvnxFXOeBllkHQfjUmytfU//Q8lE1 rdQiyhg+zy7g7XPmFSc54x0AyKyUheO/ulJRxprbluQcwyjpuU9Dz2FfyXJNn69FJLQ6VZpLmxms J72eCCfEy+SFMZYdNxPI/CpLLSoS6xwThg+GyJNgJAyeaSVpItK7saFtJfJZytZyymC3lZZHmJ2W +4kEAe/PSl0wafEs1/I0kkiEFLXyyI3J4YnHOfrVT2sVOKWw+WW1mkaTc8FxcP5P7tTkAjHX/Ird kaKw0NbNYVYRzCKHfFuYPwx2Hv6msiD/0ee12/n1ma2nKJC1rbLC+ATlUAAGfrk/jUCStBEZbycR R8LHvcIuPb8q/kKasz9ecktBwa3eUG2uY7tFADNGwYgkc8U640yZRd3ltK7rHbeYLaU4ZsdcHpXN JWdkZJ2J9JltzFC99E8byWzJFH5pUwuwAXdj0P06VdjgSEN54R23ldgfcqgev1qbW0NYbE8k0M8k cSyJaRxrnc3yxoAO35dKvfbZgyW15cO++NmtWiHzysBwv48c+1BtBq1mf//S09LvhbW1yskok+0W 6xyW7/P5TBsk7s5z0/XrVaW8RUV95G0nf3DAjCqPTk9a/jWKS2P2gr21lc3N39se6AmMeyGNj8rc ghQOn4+1XbfU1uE1LTSzWd3EohmjlUbwSeCp+ozmqDYsWgktLRy9ybi7UEhwu0jH3cD8qqWaAo9z LdJJcb8NADh23ZycUW6ALP5NsPJiumZmHmNG0ZHlMTnGe9V9P1KV2mtz5h+zx5R44iqFSxzvb1/x FQoWYpN2dz//0+jm1m1kgtrSbT0vPMzGFclSDgneTnt2FU7b7HarNEsjxQoh2Rbd/mP/AHTz0r+M /Z+Z+xxn3KY0S5ke1jtpYvNvw81pa7zvZI2VZSfTG4YFVb/7bZTqIi6QWw8sojb2z0JPb6Yp8iNL okmmfTUtrm4DOl26hTApl8vd03Y6d6upNGHa4CsxYfu2z8zbevHr7Uoxs9Rli6jgvg0MkcMhe2+0 I7MRLCVPBC9Q3HQ1Qs47i2tHuEkQRAFlVhg56cj3rVK7saQbbsz/1G3GpSFYcrJsLbm2jJbNWJ9Q s7IQXJVke5TBEq4c4J4CntX8fcq7H7gSzaiUg/cKpLnzBGCFaRsdPTPFZmp+YqQTPbMZlAkMRAJR WHX24ppX0AvQpZQxW76fBFGTDmWOIbWkc9yfUf1qa38y8i1GXVJRFFbFXWTA3kNgAKucnBHJ9615 EZybvZHPQa4t3K9g8OYwvlrdSxYA29gff+lWpHtBao8zmWR5CjQqM4ToDnt3qHFozb6s/9Xj72O2 fUF/4+fJEJby45CijkY3EdelaFxqVxd2uwIYEWNfsrqvlNkdCwxnjHf1r+Pz9l50RrqTWdtGbr/V L8pmC4APck+tZUUkF7d3csBYfZiHMrAqJd3cUAp3dmW4J7S/Fzv82OeNsI2NsbjuapSRSb2h+1hZ Y1EiQ53eardP8fwrAptLcljsZHQzPcpuAwYXPl7ePvEnisqGWWGZ5Y9soGQecxnFXGSSsyHPsf/W 8m0+6N1dSR3xlWON95nQAEqSeAPbGKuCCC4ljnEUVykM4wJzt288kdcHGen51/H0ZX1P2Fu+rJ7q 4ey1AQaXbK0E52Klx8yNuHzFiMe+PwrDe2gS8m/eoHWHKYHlq4ByUXP48V0p9UYz6C/2m1uxa0S4 k3t+8iXLbF6cjNXNR12BQYbWMySPECAeGVsDOce+eK1g9yCnY3ZvXWKe9eVImBltX4EJxwMf1rN1 mRFtoormCVhLdhYXiyGQg/eOD0Gc/jVgf//X8IujJYJgX1xdkqDuLkpjAwoOe1U43j1K5m81mg2w RrbKjbjI4P7wN6ZHNfykoNq5+sWLlzc6PAYrK8jBnuJh5MwgaV0lUcfOBhfxPaksrJFNxMllbpcs eZ3iCyuR0O/qanlfYmST1ZzTWWtT6jKrRJFdyRi9uJoXLWckIbaDjPBwcdPStK4muLO5jspoplWW PczNETAy9D81XCLWrMSisz7rjTpRHdW9yzQpKAbf7Kh4BVgc8DjPuaqmGGN47S2umn8siMtM5LZA AyzHt7muiEWtWB//0PlKHXtVtNYlsbMRaXPMNjS3AV9OXaQQX3Hbg9Rk9+Kk0rUNaAvrObWLS9jF y2p3cSWqQjc+EAUjnH49q/l8/UCpLeQLNJI07WyiQKdqExuzY+UH8RWW0dib3xBr2os2oGw0xLfT dPuvMW2EuMecXQgkDK/L6jrWlPqK6ONiupdZ0i8k1eyhC3qm1FtFcfKQoG7GMcEfz61raZYHRbBJ tMjhsrKxg826aNygtwP4mPTn6/nXTCPVickhbbUoNWEE8DF7KRzIZLg+dFPKudrouOMc46455rq7 27tLS3WPUrSGa2urQJ50f3yWO0HHbng/StYq7sTzn//R+IvEtvY6jZ+Hl0cDT7mzujBdXav5sdzH 2EhJwoHIzz/KuSv7hYlURSLeXVvcrHJCpGQMj58+nBr+eYq7sfpkZJXubBla40fVFi8tbiOL7Ra7 WEZDAYIJJ6ZK8e35usEfWYZbS7OxlVGtYFjKQXRXpk56gjIznJrqhFNGiaexmapZ36xCC68myzIA oWcNMeerdwD2rHK22lF0H2eeYSZklik81psfwtg9ufzrWC1SAr2t3e3F3dym3H9myTrI4gXYluPQ noOuB9ayPEmuy21/cx2dtbw6c8QjtUVibu3fd8zs38QYdB25r0aK1OOq7LU//9L8jpbi8lvr4X80 lw00Ktb3YkMwD4Byc+g4PvXiHxTv4bqz/smS6EkiRO8YYiJLdiPmLZ6ghf8AOK/MKC2R9bXlufmZ 4vtre1uJ9Ru5ys08bSNghZJMDICHsW6jPFePWJ0W8mispoJ4oWkLfbSN5Dscndg4/GvZor3Tw8S/ eL1xrdzYrdaDFOlxpS3IkjaFz5bSIpQHHToSM1HodxcQm6ZLq6hikKpf/Zk3sImYbj+Jxx7Cu2ls zjk7Kx7HaQ2VuIJNLt1t7ezzPLHKQJ74jG1W7Fj/AE61tX+o2HmGHSrQxSXFsr3VzMd0tvJ3WMZw VHqR2pWs2zmpSbuj/9P+SO9toYrVVu5T5pAVQyiSFwB0Df0rMEEOt+GtV0nTdMjS7iB8mWdvIgUE /Mu3oQecDrz0r5apO1NMIx1sfP8AqOiapZn+ydJt5Lq6VWkaCHDFVXltgPJxg/lWTpKSWjyXEis+ oWilEs7yMiKNiDhh7g8jtn1rupP3EaTjZKxsxCaZEuZwi8/6Sinc8rdSxJ/LjjivV/C8M3iKO8CI unWdvGJYtOEplBHC7lPPXqc+tdEXokVCNjqre7u4Y5rGa4tZRYRiRWlmVpY07Ln88D61g3ySy6kk loskaJH50yAARlieTnrnvx611mklZn//1P48bm+mtprW61FTqUEDnzhLKfOKHPC45OOwFczf30EN ytzpscq3V25RxFlliQD5D169q5zoL6TicxpqsuoLcXCmC0it13yllBwVXr6k/Sudk1PUbXVbYWNm Lm8hiaJHuo/3ZIzy45wwJ447UAbo/tJ59K1C8edYF/0poGlEgBU/PGPqR174FRQ3g1GC8bULeUK0 xkiTyxtfD5BZT0wQCKDnk+po28ESWpsdQkmuChe5t5FUAq0mGX6rtwKzbW8W7vLp7uGWZYQsFvNc RtHNZEAA7fYgd6TV1Ywbb3P/1f41DKEvkMDLcxwxkssq/uiWyOD0yPamatFcrZ2oSdUh87zrhFfc MY6D9K4YOzMVJol0NrqWdbeJheK7hlHl/vVXqcH2/pXUzNZzyyaXcjbdR/I100gEcDEAhCT0Pr2r VuyM5OyGTaXpr6ZcJfzSSTREC0hQn5sn5mZh2x2FV1uJZyul2yyo0sIiikVuBzjaD+FYBDVJF4x+ VYJFPdAGKfyo1OcMzcf4VhSRWthcSNKpuGtXFzP5YKnBXG4+vH8vai6W51wjdH//1v4/ZIrG5gin jVA0wDjZ8sjKR14rXj0nVBZwR6Vd7DcXADQhwXwuD8/dQc8H2NeddGzirWKV/pMNtbSyNJdf2pcX Iy9tKDvZRlcnrgY5+tPt/wC0mt2uL0JC4f8AcyAENJgDJbjrmokoijFxZajivntmu7izO1maO2md tgnxjcyjvjIrHiWCx1B5buPZH9nM8spXCIOcZbp1FS0lsaWaND+17EyW9ujyTGQkgKm6PB56+9Ml 1FdMuUvjp8FxaNDJA1rOz5DkEKTgj7vXA7ipMJfEf//X/kHum1LTbCHWLaC3SzkvFS/WXBmjRwT+ 7T73UAZ6CslpNZ169sLxbe4nthcCOdRKDL5accg52qRjkDivJcWkKWi0Ok1uCzl8hNPhNvb+eiFA NjLyAWyeuB370y3e/s2vrWW4+0rPOFtpk2tEYhxvbHRs5qTA12vr4aYtnZrEl15zIL8gF1BAXbt6 ep59apeHtKl1a0vIbzWEF7p2ZAJoz+8XdnYq9j+nNAoroSS3UItr+3mnliIgxGFi8xi2QOeeBgnn 2qxp93YzWMgmlQXMEOyKyiUAkjgOTUy+FnRFcqsf/9D+S+znvH+zKVS3WZjDK7DKuMEHB7dRWPJf R6NqO+0ic7XKS3Ua/wCpI6Aev0r58lxTepW1vULi7uHcXU2y+QK25BGUyMMQcZrZ0nStHv5rOwln kzAFvrwQxnzoFT5lJI/v7T19T6Vq9IFW6FF5JZ9Q+xgqluWYhZT5kjpk7fbPAq3qV4dOht7e6vb8 27XSG2WOYYjbIG3AHIIHQ/rWRnJO+gl5ealLctaaYrE3MIDzCMSCTJBCgde2Se2K7XTvEWpaetst usNsPI8q4K3PlwcD51cd8+ntQ1dWZGqeh//R/k0n8QxLrtzNdNY3sTYaeGyiMGzI4yfpgdO3enrP Ff8A7tEjihRt6oOFzz3/AD/OvBjG6Oc3NFCFZJUtI5rW2Q5Ej7pM5xzGOcc/yqnqTiyNu80a/Z5Z 9tvCQVIbHIPscYz7VFkA+RbNtDudQt5bZNRtVJbT15aTP93u34VmarLY3eifZPsLC8ktFa1u55Mz Qy4BO0dOenPSsWrOwFC4aWzW0hsXee5t7TMk0cgEJYjJG77pIwBiootQuZtT0oy3qPLc6e+oXvkj bLbNE4jEb9gT8pHruFID/9L+T+5Ww1aeZL2KYLDi4s5mlzcRyZ4kx6j9c1Vu41t71Li71K4uJBEu IQQFcKQQSP7x6ZNfLnOa15K9zqLalHBBY6LLbxLcwAedIm1cMVXgZbqfqafP9ivL24ntlZUaNYo5 B8kwAAHHp0H5VtBaAYd3PNavGJ7tXuoiHkjt2UJMhHyqy9mxjOPxqfw3aeINf1i3Nq0ltp7ys0ls 8wRQqj5pCp69Dyaq3QTkk7F/WraJ5ZfKLNO07RQfMCUVMgs4688dPeuRktJ9Mf7Q9sZ5YyHRTIXh LMeCD+PQUGbk3of/0/5TbiwKAWhjVL+5tkuTLIufs7MAyjPqM9KzNWg0/Tra3spgb68eRbjckLnD nrhu+P6V8+ef5FmK8gkuIra+vvltYQsVpI+1Gyc5Ge+e1W7e2juLy6ez1BUiSIkSnEnlSHjCnp+f YVg9wN029jNHbWE18qBSHeTAxcNjnP8A9bpWR4g8P2OkSLbr9qNzcbLiNxIXQAjcrewxSLktEZ9j NHZysoZ/Onwrnd8o2j06DPf1rYVre6uS9uqR3KIHuHXrKV6M3v0oTtJI0pq1j//U/lLnheTUpr67 1O6jNzjfIjAhcDB6+tXrM2Nzb3PmanDFapC4hYjzpLh14VAoPGT3PAr5qT1NKlrqxy2nWy6IJGvJ vPm+2tPE8ab2tkY8Be4IH86311y2iEjXsIvXkYpax3KmIjd3P8QOKIv3WZlG1u7G5kvreW31NJZE UlkVl09EBPRx1PTitOOctHcfZpXukjBIxHtYbR0I9fanT1/r0Dls2Yh1O/vbe7haNIYcF53OYnK4 +6B/nkVFZRz/AOjwRt9pF0Qixg7s5OABRJe8jGMGz//V/lntVayWby3MbrH9wDILeh/z2ovL26vX srWYgw2yfLK58yQEg5+npxXz3Jz312E4K9mQ2OpW8F1LYS2/nItq5iuphhIWB3EKx7noBVVNemvx FIlwytbEwwL0aDDHjH1zWTjYwG3nmxtb30cUdxcTS7Lsh1R/Xdt61cmNukKTtJH500nlR27nYxOM 0lFsCjqOm3F9LpdvPJb/ANn3Ck3KRThpIAp6lRzxjOOKtCK/UmEXa3Nmx22ZdFMqKvB34OR9D6Dk 1Sg+pnPex//W/lgvXTyIIrxIRDbZV8RYlk3Edj+H4VXuLiJ5gLaYofLC7o1CNbejKfXFfOciOOLV ymtrplhZ3CNBbyPITMlyUDXG8/xFvUnrTY1uJljtHTeyx+alzL+7QKO2emfamoJI0T6otaEsh1c2 rHzoZIWYyTny41YAYC/if0qW4nuFlS18tVt0mYMUOFTtnPfOBVcvQb3L0FlBpV2t3C0kVzLtLzRS MxBAyCDnAp010i3E940CTtzzICYkLAguR696zcLCP//X/l4ttS0ufSIl8lWvo4gJrxGKqXzztHQj tWdqEhtrZ5Pta71iDKhOJ5OcAKo/zwa+ZcbHOYKSXZurZ7m1in08Q+fdFn23ETdivBHFVrfSLhl1 DWrK6MiEhT84CnacEN9AMD6VJsrrQ7Gy0e51O3gktbptyHzXhLCO5JQZ3YPbtVW71iTUbmHQxbkx aQ4vLremYSScLn0YEA5/xoHdG35UiWl7d2Elv9qMYWOKSTYrHJ4x6fT2rGvLrVZrZvtyxwacu1Tb SMItjjrIoP388c0Cm3GLlE//0P5bdL1BI/tXl3U8cJt8C0ZcLM2Rg49f8a1IwVggCYRopmuRGJfJ UFutfK31SMozk+W/U5me0Tc81uUG+bzZYTznJ+Zh71pQPJc3C2lpbzOJEwWRM4470+uhq9iyq366 xp+lTmWLTXfEwjQl0Y9WYEYHHQ8cmuo8QaJb6TdPHp8ly8EsKlRIRJMQygkkDgDOaZP2zm4RdJax izuIYbONmNxbhcNcsOhH+0vzfnisuyvItRuYlto0mtROGupwN8hHQgKP4gcdaatfUaP/0f5W/EWk jzJoraacuzBrSCdPIiHoH/Snq76Stgda0a8S2u5PIjvGizbQyKMgnB+6cda+amlGbiu44xSuux1I WX+0IHtWjS2CGSYgn95wCpU9MjFN1CWUXPlOhdbhg+9G2vCAO4z0P5/hTk7RQibUZJLHS7e1F0j6 XqF19rk+zMJDvRQHRz1UgHBHoa5aFJoBdXen2gbSi4n+SQB1Rj1VerYqL9iItSTsdAh8yK2mtLh0 dSdzRS42BlIIZc9CCRj3+tQ3VxDCUt13vJO/loEBZj6n2x1JqZS99Cp9T//S/mimtoGSyhYonkAZ eSPc2Dn5uOe+fpWTeR2FwJ1upEIXcjMoHlyYyBx0x0r4851oc6tkguIriaQyqjeXaCQYfPOFXPbG elb+oMkRtZntmht5nEbiMGUwe5Hpn+dA229xukrbXX2a1e5e3njvGdZ5lEUeMjHOOmOK1PtOqjWL iO8kJiVB5ZgcSpOpHBZ8dT6Dt60eooO1rGZfwHS7kXd1BHDBD86i2w0Sp247YHUD3rYi1C8n0u8+ x6g9rbuqtKqS7FmTIyMd+PSlHRI6Frsf/9P+Z7TLhGheO4kcpy6vj5to7YpksGmTWKm1d7O9a9yo g2JE8aqPvKB1OOa+PsXQjePN2M21ligu7/Tppry5FzbpIXEXlwoQQCu4duvGc8itGa2eyFo2nxx3 F3KxLxXD4i2HjK47jmgJRtqFwJ1urO802Tybm1UtcfNlc5G0MO4GK2Lm6P2R7q4VJXKmSRVGNx9M e/P51rCPv2HdcquRJeWLxW7GErdXMipDZQ5lzx83PbB/r7VS1WJkvbiN7V7cRQKQFBWRc5Jz39Kp wV3cttLc/9T+aCHTna1iktLtvPacM0KpuZkxzz2/DmtGzSXTUb+0gNwcvECeq56MK+WsrWOgo31/ G724gs0ljkuVGEJI2tjj2xk/l1rUtYo7aG7ZBueNTKkRONvoufwrJxtqBFHdToY7k7HtY0DuD9xT 6E1ZSZb0IzTF0eTPlooMJHYD/GpApXtxq8AeDR5rVBKwjmS6Q+Uo/vLjuOPapLYCWMNKZEnjOZXX qx9Qazm+gH//1f5xY2S6kja4hZDasJYmD53kZHI/GrU8cF7MlzKDJJE5ZJH+8O38q+HslUdzopS6 FNtQhilbc3lkIzRR7CzSkduOnXPPbNW5ruF7SNkmLGb/AI+IFyMY5HPfr+lBTfvXK6PbwvZwrBPI k8uzNvEXEWeQzeg6fnW9qFxLAYdLukhltUjEsJjVWdGcAklh+H0xQbFO6urKzsobYMBHIxZyeFOP X86wbq5tLi7+z/ZpDaDDxSqNxJGOuOlJO7aA/9b+edruKdVmy2yGIKDINh+UAYA9jWWsC3N3NdPL KI3TbCpwPLI6MOK+F5lezPQLDSLe/wDHzczr5UgV9p2iQL6n34pLzVF08i9tXRIrUbg0qhwMfxEd KoTStZmTc6neX0iTTPzIwZnGF80n+IgdOpq9ZskSuscCnJMjsB1J6mgwM6d0luUjVGDs2dyLnHuc VY8250+VlVw6SgKzvxj6UAf/1/52LeKXVbuzjYWxjgclZJbjyipx0A6Go53KXe62srWBopys0xYk 3CqcYJ9OP/118A23qzpbvoSX+qT2vmxwWbGKJPPmVAWWIH0HX0rU0aCyubcQbI2jePc8RGcbjkgi kaqSZlQJZ2z3kd3HsYPsiWNvlIB4Y/h2p9xepGitCN6ZALjmgot2127ufJVXDAZ8wY2DjOKfObiz l89GEvmKcSMeUHXCj6j9KbdwP//Q/nZuLqSaMSvHL0/fIxyAfaujS+vtO0zSJmezu7fV7p4WlacC W1CAnG315A561+fnoCXl0lwkdtulhiklDu6RdduR3+p6+tX4oI4rhJUkEsLsMM5wxx3emuoGlfDR 1We8tkWS7kwjiI70Qr/dGeD61nW13OjeYqFkXqPun/61K3QCOK5ZJ1mjSJpnZkndzuk2nkAfj/Or dw90VvXwEhkt/JA2CRImyPmz+FYqN5WA/9H+f6/tZbKzthHIroYRko/zdBkH0rX0Ocx20mXKvGnm xhmGIzxk1+fJWVkegULjUkn87eWlcHO5j96qkElxOyNL5X2VuRIxwy+lMC1LaRW88F7GsqkkxsyZ 8qUenpkVekuYJXVJEzKDvR2/g69fzoE1oRXLLLcRQL/pEwTKiNT5S9Opxiq+oTXNrMfJSP7S0IQs XwBxxyM0+V2uZRjdn//S/ASEl4rYXksZlVt8rxt/rT3Jz6VSvxLJepDaXrQL/wA9IgpDexJB9O1f n56cFqa1mupRK63VwJFdgQDgAgd6W+ijjRJYvmKtvDKeVI/+vQNtqYf2taiTT4b+N4m1E7YbhYy3 mbeufpzWpf6TLI1rcefvSNtsKkczKvTA/AUbG0PiRTvrq3it1imYctsYIdxXtVcyTRQh7Yl4yMLt OTWLlfc22P/T/Ci0YWtrKFuHSW6gxKu0bEI5XnrnPWufs3892nuJNphYOQzDccEDj1zX58leNme1 J3ZfnB8z7UFeNHUAnoGA6VcVYr61aBVJDxspWL/WNkHJrAanbRmRZyHTHjhVEnZkMMJL5ljI6HFb 1pdX8khS4HyFtmAOCOxP+e1BUn7ugy7tw90kkDhQoKYjH3jTZIzdLJZMJFeJdxDKVV/TnvQZH//U /CB/tdvFumwsFumVLHsOoANSz3lxc2trqAt41tpFzbPEfkZV4ye45Hevzc96OsS9Nqm7To7q3ijm IQB4onG5WHDDn0waptrUklrDJJaqYIwXKMx5I9QOw9qq3u3KEs7i5lZp/JRBIpIiiB/d1bg1CeSO ULbRM0coUTNnOB94elaRSsBpxtdyxjzJ44QzYRlwJI17g/r+dRzpc2lrPJp9whm27ftGAWHPQH8+ lYgf/9X8M7e/klaNrgo0idEk+5J2OaS3FtE5vnQgRv5YdfuZPOCa/Nz6AdeGK4ujcJMCZl8yZWXg 4447elaOhW9rqM8TSMbe1ikLTSkbMhc9vfAFA47otTuJbW4+zGJNlxiNX+78pIJyPb+lZVrChuJb i5KuoUrFt9SP8aynubjE094I/tomClZSVZXw+Rz061u6TqF0vnEx/wCjy8S7hzKF5B/PmoN47I// 1vxB1XWZIpvNW3EcMifZA0C7d2T/AB+op9pNdSQPMqIbe3UPJKzgGM8YwK/Lz7AkbUle4jVS3mTn B2LuX8fSp7++tkuLKztbEG68zF9IzDyFA/iBPfPUdKTSasx20uMnu4pJSjRpIq8OWwyj6CnO8T2o tyJUhYEbCdpP+77YpckRHOPJJA9htu5IJrOfEE/SY+xP4V1Annm3sxQw/el2YCgnvQ4q2w7PY//X /FKfULuKI6dFeFYGkEjQRyboyccHjvV2ysgrRXdxMzJuwi8HawwcYr8oS0Z9h5M2pfJLqGXIxu3E dKzRH9qfyxcCO3D/ADhjuYD2FIDPuIZMywkl7e3cyLIsfzP6HHX8O1T2Elnci2ldZ4rgoQ8U0bQs p5x169qAC7niWJbYEzXUUhBCjpu6c1KVvH8iFIzK4GNndqPIwk9Wz//Q/GC4dIo8GA29wDskU8EE U6PUbiARiKViwG3dnmP0Ir8mlG+jPpudJ2HT6je6gkdvdzfaTCMJ8oXZzkHHrV6zvZ7W1g8pFS7i usne+XdAeMDp7/jWFraAppmjO01mmQpiSY+bIAcGTJztqiwuBercWzRW1tP880DvuAAHRRnr9aia 0uUvI0radHuYpA2xYmMjgkIZMZFTW0b3lxdzQyRlI8vIyuN6EEYBH49KyNoyvof/0fyKluhGxMr8 McEnkknjP5mnafZW9zO0xudxyY/LVgyK31r8XPsuZpWNFvKj88qA3kERtt5254FZ8t5ax2107TC2 u7cKY1K7pJgxxwPb+lAczMfWri/0+4tUuo5omnhW6ie3jafCkAgnAOOvTt+FWLa8dJobjzFLBeWk HzOCOhFBcNVdm9CI7yCTVJZI/Ls5djQiQBicZDD6VgQQJf3F8Z5GlhkOBFJ1cEnPNBMo22P/0vyw mW1sJoEZ/wDRo0QDauwklQSAO+OR74rlpr0xXcoQMd+5QWGThsjkfjX43B9D6pqzsU7XS4BM11cX ckKBMRoigjd23H0PFaEF1a+arvMI3U7JCvz+alaEk+p2unIwl0lFh3xhp4ywJd+7/wDAvT2qrLlI Y5In82QjYIMjgj+XUU1uRKHVD9Ne7klfzESBVOxwG3Ocj6D3qe8hmfZGkgSOIliWGFI71uZH/9P8 f49SgiaQQIGfiGaXGBgHOAa07jU9PncfYvtSw24VGuCgI34+cIcckH61+RzXU+nirKwxnRbljDO0 kZHyT42Sc9MjsfX6VKJL+RoLeRY5YVZpWdVzNj0rO1tBiysioI7bNrO2WjlxiRT64NZ9kZ41lSSd 5I4zuKv/ABn1qnFpXYE91JKtojRH7x+Zh0APTFY5khgncOk1zOsBkkt0+Y4AJHH51IH/1PyB069s /EmjSu1vdafLIDBPAzYnjIPBHoD9KLXT7fT3UJIqRAcBsKc96/IqavqfSx1ub1lc20F5GkjhlYbl gB5lA6hT0rD1bSNWmuluRDHb6RdSFYxuKucH5yK1MrdC5pn2DRpRA2XiJEayHgpk9h0p17HMt4zh vMikG6KNzg+w+hoKlGxV0q0hO033+sSQtIqyEqQTkDPXjpWjLPBf3jIilPK4TPG7FBNraH//1fyw lu7CaxNu9xJJeIcAGPcgA4K7s/SsO6hmSzaygFwkl222QxABCvBXj2POa/Jz6AiuNPW2lhjulS4a JEl8t13Jkc8j8KxoJ3u5L5hbtbGe4ZmjBIUgAL8o7DCj8qmSamrbibs0jb0GwsYfNtLWygeRwbh9 y5dto+Y7ic8YHeqBCJfbZNphlbb5a/w1zVX+8NLe9fzNgRR2kymyLtG75KO5Zse9ZuqNeXNxiCMh gQGkDBdij6mrsdCXutn/1vyLFkmm2k9zLI9zLKwxu52E4GFH61XawvRaZjkeRp/lZV/dkA9uK/Hk tEfU31sbSG+W5gJn3wW0CxtBj7pXNSS6oZLx4cQp5konkKHa0f8Asj2P+FVdlQmuUXUvKlkKW7OC EzImP3fthvXrx71XsQFjcSTktyETqEPPFRe9k+px1sQ6K57Xu7fgzStpFKkhszhsFGOTj1qhDayT 3M2D5Jil8yFkY8D0P61nOPK2gp4mVTRq3U//1/ywKFZo5WkMSpH+8ZTwx78e9bsGoWM0Rmsh51tb ndJFI2JSejcfX0r8Qaa0Z9NGd3YoWWreVIrRxuI7k7nbGAQPu8enX8q6ZRcXMV3fxNb2VuWCx2qS 5uHJ6lcnJ6ZrKcepvF30MCSUp5qWjRXDNgEvkLC3G7p3FaElyzWarvikvBDn5chSwHaosadCWyRL mykN7CZLiSMGLLkC3dSCCSPYYra0zVL+B2bTpPs80URSeXaGTYflOQeO4pE3sf/Q/NszRw3Ulsqs 84BEhRdyZPbcOOciobDV3iunsrnT7RIrZm23VtIZZJGborDpxx0r8HPsNi1pzJPcfaF8wTC4YXe4 ENIB2P8AntXTJr63MzRPo4vlgtfsdvHN+5aQ5OAMHPGeCfWp5leyE9mQPomox2U3lQRpqFwQptw+ LlUJ5XZ1IA7eoqhpenapp2oQfa0tRpUUgm8qB2S9U8AoybeM4PU8enes5O7Emr2Rv6qGkt7aa22x M99mUB8b4tvCqMdc8/hWbeRu15pkC2DNI8oFrOQGLE8E/rWblZ2KP//R+GLfVNIuEv7d3aaWHd5U aDa0xjcK2V7c9qzr1TIibVhigZ/NdfLC4GP73Xj3Nfzw9Xc+xe+h1lp5c1otg3mJI0C/Z7mcFbWN MHAHHPr171lwZi1GTS5GfzEiEyXESk28nOGAfpkencVEEvbJPY0hBJ3kbOvXDS2th58UDS2i/ZrS WNf3xGSRvPtkge3rVS1SRZUVtTF7b/LJNH5ZSWByBkZ7j39qzkrSaN4xWhtm6V7/AG/N5bRhTcTE b4wMY9fT9K2JvEGmLdpHLIdpj3C82ko4AA+Y9u1YT3OmmveP/9L5oSx0yeZtRjEMs0yKElUBpCAc gZ64+lWERwLu+tZVtpbYbHCy7SoPYKTz1r+YD9Ogkojl1i7iis4bl4bjyi0sV6qBpzu2nbI3oMcD 3NStHLLGLpLp1DMZLoRHmcY74qJLZMvS5U+yI+pw3URWCLyViE7ylWDZ+bcOwzzWreXAv5YHkKF4 YhAZkyTKAeCeevb8KxqJK6RcdJDzdf2erSRxvNgbSiR+YxzxkD2/pUb2F7dND9vmNm1uyXgNvIJF Zc7trHtkdR1Ga5zQ/9Py6Jnup9R8m1lnF8y3SS+WU8oICMn6g8/WseaOCwso9MgjaOGJjsiVfuAn kZ9Pav5OXU/Xr8qVyUNBPZ3SStIizwCBwh2mHH8S+9QaRaXUsYhFxLLaQEFLo/LIw7bj+FDstWUd WBJHLK/yNZpErkmT5pXGcgj0/wAa0dLnitra5uNSWNYbw+ZZNEgJTB5GM9DUzatYb3HT69a3ySaX b6E0UaujHWJJCsjbeT5a9g3cirw+zzQs8bhFjyVUtuKnH6VmxH//1OAie4ti7uH8hiVXyzuL+ox+ PT3pLmzivUUO4kdfnjt3Q8fhX8itKSP1yrFwm4s1tJkjtY2cRIBANn3RgVevru7ES3cbA2bsIZhG u77x43HsP8KwaurGZAJLd/3kirLFgDy0OZM+uKlt98qGdYpUhEnlJJJGVjkYDOBkYPFZSVmOnKys wuZjc3EyvEjfLh4oVxGMDBAAoGuW8jRC9ijjht0EUBRcMMfKAT684zUm0Xpc/9XMuUS6XT10phaQ vKy6lcyHJBJ449MHr2pWtruKB7UTieJLzzGuNodIuoHOOV4PFfxqtG0fsyl7updTUorOwdbgpcXW MRsP3fPtWMLn97EiIXubiTbHtGOT0B/KqKJbjUrq1Yw3CPDO52IM/O3+FaCWlrd3Gn3DTNAlm6yT W0JO+4I7k/nn8KBX1sWLzU7Q3rSRWcwgSTy1RuJHAIBOaR7pVjaG2LQxzt5rq2AGwTgE+xNNJt2R lVmoR16H/9aezLJbPMxQv91cnJXJ/hqCOwvrqd7m2DSiGEzzo7hAFXlm/L8a/jpQfU/XVK7sackV 09pBcFngmjX/AEd0YFo1b7y+wbAyKqm3iuYWN5JNEyLvtXUkJK4YBgx9ME/jSitHfoa6xauWFnh0 /TQJrmN/OLLGSQ2V9D+eKztJmjtx/aT+a6wN5wjVRIUbrhc8Z64+lJRbNhr6haS3txqltBLC11KS RdYE2PTHboDxTV1tS80LGFQc5En3QTxkitIxs2VBpPU//9eC3hdbCO2eaNvIJdXThfoD6YGOvany tFf23nzbLqWFhBbeYeYQPvha/j8/cCO6NtcNp0VqjJtYpffw7MD5SoPqaS9kS2n+y2UzhJYgrl8F j/eX9KqK2fmBdaCOxeOSJ4xFLEJUxIHlUnrkduRVK+MV1FsuCG+bzFIbaQa2MHuZkD4tJIIFEsQm ID7M+W/QkH9Kx7qQW/kpJcwRGe6W2heVwgaRugxnP5UGU30P/9Dj2S6tY457ny8zMwUod8ciqSNw NQDWi0F5aS2qlM+VFI6jIwyneh6r0IxnvX8gyXvH7AZ88VzOsm8SyRRYzCvMa56E1TuZL2OM2diA LieJhEccI2OP8mpALY6jFNaWahZYJ5oxevu2FscHnHufzqK/uLe11KKWAzC4bKIEG9ZMcgcelYy+ IB51FbmG+t54hPPMo8pZCUERyDjA9QO/rU1vIJLWJHhS3dBtcRuSrY45qRNpLU//0fIzfRW2oRwa l5Nvp6IqW08WZGYMSWQqBnOT096n/tjTJ7iSKxtZYreJ+XuRh5PovYf496/j2C0sfrjknEj1G9nE C30IeRozi3iHyjAzkA9v/r1hQXwu2Es0K48zhd+5uAM5HYg5GOenXtXRFcqsZmjdma1jM9rApkdS yjG0TYHA3Vn2UxW8gkkENq8oDTPIN4hyOccdQT6etdKSWwnJLQ0X0pLFUuBfNOJJTMSU2OeeMnp9 KyZb+3kvQl1DLKijKAOApPbnmtoRsrkuaP/S8PuJY5z5dtbiFZGCpAWL7fxPvWHPaC2BnKkS+b8j DiPI68+vIr+Vz9T53fQozX4eOUW6brnGA7EgRMPSn6rrOsXEcUYuY7eCKLexSH5ixABJb8D1z3oE 5NmHcpPNMI7jU9QtfttgLOK7sh+/RMh/lJ+UEtjn24q/IurWtolg9/LqUNjKFjlvGBupFPBJI4xg Z4/+vVQV2SULrxHPYRTRWWnLf3JlREVAo2huCSzdhmrskthbW8t2ISt3LF5M6Svyh65ReP1rYLpH /9P4ze9iitbsyaVFq9rfoYplmchISvSQY6lcdPc1X0XWtFhuIvKFwZZ9sdvdSWMkdg5z9xnxzjGf Sv5fP02bsrHTzXclv9osLyOxdbxjdWt1DFtcKCAQD9eDjj2FZg3xOyWbrLb3H7u+huVwkqH7wHX0 rWCMiosOkRXN5b3UP2KBiG0lSnmlyBuKkDtgdaS4vkS0uLVI7WAXoAntchpJVXhWdf7px+ldUb21 A4ubV9ZgtLZLp7KCwguHsbW1jtkjSDcuN/ygE4GCM960YtVhm0OUm5S4lsGERjkYi7lABx5aHG7J 9PWtadxJ3P/U+ArfVLj95bNFKiuoVl8vCEH5hk9Ow6Gra2UUMzSf2Zme5iG65MXLL2wevav58p7H 6QUbCfTUvit3Di337LqBTteRM4OB9M0pmit53WyeWMRDdDHI37wIx+Rvyrph8I02lZGTcQzyzwtq ExSeOQXUKRPlJF/h3Z+tM1Kz02Bnv4LcNMWNzJFCoBz3J/z3raCVwuzDm/sdmGpRzzxzXOIo7RQ3 kOSNzM4PTGMCsyWJGASc2rPExdZYW3E5wQDz2rvo/EjmrH//1fyJ1jVDp7yWyW8cmUEsUgbhsk5H 6frXzn8brax1SCVrW2la7k0dRIbGTfdyNGC2Ix2bgjFfmNDdH1NY/NDxtBBcxKksNzZTW0zKsV1L uLychl78gZ4zxXkcdtK0iWNsqiQv8jGYRB+M8k4A7969ij8J42I+M2odOtIbQfZ8JJtbzctvG/2N a3hzTjHJOxvYRJeSITBcybE+UYwPyzg967qK0scsldHr7pcXPkXAsYdOgIVPJim+8qKB5mCc/N1r B8UademXTrrTpBK4YwTwAFGCNj5tw+nek9mc2Hj7zuf/1v5RNa8Iz2+laJcXcsk8KgwRJ5qpkFR+ /I74/rWM9nHZWf2iKFZFtwPMKS7HY9A5Xv8AWvkKmtI2lBwnZo8P8WyLPqS3FtJ9lvyFSOVT5II7 gn8T9c1wl3fNBqSJeAM8qjcVPyyEd93IzXfQl7mpRS1HUIrYy+bJ5SocROH3J8xC4yO/Ir1zwVFq FjpjNFDPJdsoii+zE4RTkspP4j8jXTcqLszuLTw7ZWMF9Newu8WokzPcyks4ZeXz2OMj161T1TVd KthYHTjcXS3YWJXjtX8tRjJ8w/w4966OZ7oqdkrH/9f+N6e3aK6vLgut3DCqrDFI/lOGYkucHsB7 Vq6Doswlm1m2litbSPKzXpxMbYMMYH0zjPvXHzux0GTDq2tW19am0AvmW4KpdIFS7tFfIJ/2sZ/n xV5lmd47/Sb62iu/NcSzPGJJ8qCrZz35x370lNgVNt3Ja2ttctJeZmZHITymUn5skLjA4A4rbks5 7NI/7RhWDz4t1sgKl2ToCQOnQ9apTTOd63MaSCaS4eUXcgaMxiCLblY0X7wB69Og96lg0tvtk3nT Swxao3kbQPOuOejAnjcMZ59Klzd9Dmbsrn//0P5BY9A0S20C50S1S5uL23uvNg1aaXdLGzZ3B06c nP8AkVxd1pywzjTpBPdNgyGLyi+8rjLZAxxxXB6HPsja0+1mt9I8yAxW2p28rNbB4yrAOQBuYc8K o4+tVo4WuTNY3Cxtq15Jvle2+SNiBhSzH/ZUdacpXVjKTbNbUiLHw1JdpPEupWMHkQ2bQMxlIwi8 e5rGh1+wsoEE+/7fEI3mVYyGR3APBPBHpUO6Q6fY2yfLt5zc2wlUMt7G8LtLcHC5xtHAPPvWLZXV mXbWryOf7TLEbKOwnjIgEZDYkJBByCRgVgdkHax//9H+O20NwJRLbpb3FlBATIhYxMhb7oHuKnt9 de2VNSBmWOeY2csLZRwFO3cB+Bx6ivJir3SNuZG7btp2mh4LltQvImZ5lcpvmRZGL/J+J9zSeakG n+Y88xSTc6xahjMO77pBBz+B6VIKSbsQXWrPM2jG+1CX7LpkTmWOGMSC4LLjgZzjv+PsK1H1FNag ktfIjW3Nv5WWhEb7euWB/rQU3ZanIrClvG9xogN2sUvlhrqMwxiRDhljbGCPcV0k11F4iltUv7eO xurHY0NuEEL+YowXPZgwLZ+tBg3d3P/S/kA1OTU47mJDHFe2l8vk2Z84OLdEOH3AH5ec4z1zU3lv bKln5j2apIFub+xl3vJGWBKjPHY/XNeOGjM+XWobi3EF7DLsNwY1jZcvLhsLjHXOK3bnTmkSKCMv pt9PD5tvHMvl7UK5V+eKjnRnNJIuW9nBYaXaxzX87KZmd7xFEjSSnrzjA56fSksRutmtTdRmWadp JLqIGC7uR2Q9uBjpQp66hBa3KarfQaiTbwwS+XauHnnAcJ22lTwSQT1q/pOm6esEMlvCPtJmJuZC Rlgf4T+X605fCdFNan//0/5IXEMGpzoGleSOMKqmQmHnJwO2ffrWgjWzwQ2UkcltN5pml2LuVt3+ 13PWvny5rUy4tCivtWntbm+u47NY2ezYwhjuz8quf4QfXJx710+haRfTX8h0q4aaSa2/s6+uXK7E hXgeY3QYwBVN3SRBzniDS7zSLkrbPaXN2x8tWS4WWMKDkuSD2x0qvpj2eqxlrmKC9hVioMpO1JQC u5CD1UniiK1AntXh0WayF3fvBeTyNFbxx/6p1AyRu7cH2rob260fUvD8+grBHZXUmope2+pWabJm kUlyHJyMHkcdc+tEdJEtKzZ//9T+R6HT5zcTtNFbojosa3A/1k4HXIx26UOzxzyW+lxy3FwjCFlu YzawdP4T3HvXiQWlznJdK1+3067uNO1BLyLVGgxDDHAxikfOAu88EcHke1TXb6s+oWt9qiM0Y2ss E2VUIv3QQahwaLgk9x9mm92ke1tTGbhpLe5iGZolYcr6Yqe/0y7v4ZJLNlkm2lLKAnEZcDjdjnk4 rGa1uCcU2O0nRdUsbGfTtWWKCKGYXCWcWGKyOMuxYdumB7mpktY40lW2trUMj75Jlg/0q46YXd+H Q+lZkH//1f5MII5mv5GAy1yFjAdMTAjPy/QcYqTWRkW9u1tmeZ/s8cqqcM4BIAPbgV8uc4v237JY TWcgkM8kXlYVdzJ/tAHnjHFVtJkuYp7exV4Ht4LVrq8vriXEpJ4CEdsf1raGyAksbC11PVp5Lu3u 7ONLd5lvUQSW9wUB2pnPVjjt3rXtlvoJLC3V54/tj5VUjDEIATgnqM4qhNXIrzSLSzu7nVXubiW6 niREWOUtAgDYYMpOAcDsM1a0+eOeKW0wrJNJHKryJ8qNGSR83bk9KHsRKKSP/9b+U64vDNdItwJb eVp/LZ1UuV5wG47Hr+VY1mmoTKYtQuRO0F7J5M0gAlWPd8ucD9P/AK9fPnnmetjFrl9FZT6cjR21 x9oub66l2yFExgRAcfe56en0rp49BsbKSS1sJXtonk+1OQTIs5bPG49emD6VjKLTuXCOtyncFTeW kVzD5ieeFkjcY2ooJLD6cfnWl9sillkMgeXziLeAOxYx9FQKP0qSpLVIp6pp19ou+8vLUbXhE6xn KuoB+UnPTNTxR6fb3cd7LLNG14gtBFAheFyecn09MmhxfMjSOjR//9f+T7U0ud8US2/mWxyGdH+d PTK984rO0U2ZuGspIijyTGSEvHtQ4AGAMcEY718zP4gcrs3NRiitLqAZRpXU7FX53IH94dqYLP7X Kb4wPNLAM+Zt3rk8Y/IVGqiyHKzSLVlqM9gk8RuDZGdvIKMuBImOcj16+/NUjd31ujJp82IJJfMm KcFwM55/pVUm9EU3aLHC6jRHtPIkke9UCX5Mjb1Ofr/WuXfWNNS7gtbRbhJY7kQB44y0KsDgLkDj BBBzx/XSXxJBBe6mf//Q/lOa4vLK9ezn/eTrP5F1CGDGJsdMjPPI6etW7ewupYLe2tbqCzuJpmWK SUbwxJOAxPc8V4L0djWS1I4LD7LbSrf3sU9yrskixrtYMCRggcflWNp+nqs9zE4MKSkyxyw8yuze 31xWUHqzmjBOxLHp81jDLNcG6luJB5Uc1xmMSgNk4GAPyq/eFr1bTUJpRIfNKxhkMc6FVAztx6cZ 9jV2SLnHoPW5hjDyRszYGdzg7gfSiCY4FxCpRXbMjbflJPH9KtRT6mXImrN7n//R/lZvoXuApEqS ylVARzgDnOT9O30pyadp1pBcXd1ceXI0e0ZUCOQjop5614GljjcLXKUOhyGe3vI44XSVRJLEHLhh joCPpz0Nbcdub+DzZUS0sY4nKxRSiSYSr9yMr1Cnpk8/XFG2iNIxsvQwAk1owmaYROhLLFtyE7gZ 71dsZGaFbu6YXKyyMrB/kLtz830qeZvXsNq1jSCq0FxPlnV9u3Dfu4cHBJ/Wsu6dzOsAkD29xHsf EWOR0yPT3rNy5tAduh//0v5YIrTBt7Y2hhhtuLqJXDb+pBUDjHT8qLiOF5I5bi2g3f6m3nI2ucfw /hn9a+YvJq7M1CLdrmiLEQmSFvss6zp5RMj4iQMOcH1Ge/HFYkenjw19u0/Sr201NNRu1W7ju5As EQBB+RgOPr3FIcn7prz74FS4WZNPvGxDHsk379pztDDgg4JrFja7XxBzA2dX2oWRSA5VeoH1B4pP Qxbs7HYJZRQzi04e4eMus7MFt0/2Wc4AI9D6Vz1+lrdtJe6reiQ2EAht3kmMgJ3Kqqq5wce1N7FX Z//T/l1mtIXtn1GC4t0ZIkRreWRUJPALKOpxVLy2nYlpEdQoCqG6Y9q+V2s/Iyh0Rzt0uoLfrH5L hAS0RAJRlHUk1pRXWpWSXDxCaNkjE0cyY2pyQw/L+dZt2duhra+hfD6tLCJUmlij1BTE04+WQDgk qSMjkCuu0e6BF1HdvK02wQoxPzOAuAc+3Fa31sgt1MOG3uZSsN2lq9nDdNLDPGgeViTyGHsB+p9a W6s4tNnNzpVw+jGSQGT+zLZEDFjjcRggZOMmheYJb3P/1P5bdV1K71KW0tbmMvdxR5Oosxlec9Ar KeMADOfetmDTJtUhk0+6vpBC7gpGoDJkduTjnnntmvmZu82OkrNkCx+RdSWcjSRx2IKxoq/KzAY2 5H0FU9OE2uGSeQvp5WNhDEP3s+5cj5weACRRJ3Yqnu3sLo/h27sYtQ1Azi4t3m/fWryeYsJII8wL 2zn86LpJhFbxxS/ZlWYFkhjBDoMjZg9B06elZRlrZ9zCmuWMl/WpBo+lRxXkrX17JZwzEj5FDIe6 lh/nFbVvY2iyLN9paeT5hHsXKlRjv9e1TP40Zwm07H//1f5ebltQk1ea4u7qS30kWqWyQRxkyOVB GT0x24FS22mWN8yyXF1PHGqhordId0RKnI3HP6e1fHmFjUS5ghvo2S3hvpNLkScGVCEDYOMjj34r Im1GS/lMV5HIuZTLLtjKwEsxwFPTjPSs5J3Yi3eeH7e8vbOJ5ZZoY4nlQyExj5QNo2g+prc+wzWs UCooRVTKTq+95cHocnt0/wA5q3sVpFtGJbadPfWkkeoyXHnG5d5BKPkKliUUewHH4CjWtEuJ7K2X S7l4vs8oeZYx/rwB9z2ojsjWlqmf/9b+YyDUfPa0ij09YmWJbZwzY8wqMFznoSf6VdhtmxIotFQx zeYJU5Z89Rjp+n418h0NsP8Aw2P3iOa48yLYGwN3TGaisgv9oNLJKWWCEosZwYzk9jUrVaBL4QtI YWurq3STyZHVrtVRN3m8gZPP0pI1le6KSySvDgLJEoGxAD1HGc/jXSnaSZzx+FGnYWM4u4ZLVLhY rZhP523ErdSAM9Dx+GKpm61G5luoo3D3VwXTLjeMHgZ/ShvdlttvU//X/m28K2OqiZxLPBHLboWk lR9u8KME49fpmtqW7gllMd7Yi6thlMO/lmU4xkEc9a+UU7lqTRxUiQ2F7aWNii20MMbyPGoBDlm+ XB6jGT0rYX7T9g1G4ig8wRRbpBkIz84AH1JA9s1m22U5roZaS3FzHHpzWYhhuYgmWOYk9d7HitK2 iS1e4sIXjc6dGpZ4iDDjkAKT16VLdh88SMy/aVm8vduzhm67D04FbfktFbRt8jOVG/ZyDWXK22Ck mf/Q/m1W7ljkZJEEYY7Ubrge9XVB2uBLlAeGHG76V8VZe0HTmti00Nuka7Ig56sW5Y568VWhsrS3 kT7ZNJbWpLMxgh86WFQOgTIySeMZHWk4tPQ38iRb5IJES0EptpUBjlkTy5pFb+8v8J9q3QbFZbe5 lcBbcgS7cOZz6FTUqPRGkH0MaS9g1B7jzLdYdjHbvQYXngqPSpNM0oXcZaG62yRvlXKDaRn2/Ki1 jQ//0f519QS584LcKzBFAVlXPmAcdB1qm8Y+1K5u2jWNArQn5VOa+G5Vc7efVoe9hd3cDtZXKJEJ A0hZgN23kqPfGfzqu2izXdtkSRyJGN86FhgoDg59/SmRzO1ik8tm9x9jtd5SLAdm52HAzyPetb7P GSoWaXaFwSPl5/Om01uRJ2RLZ2Fvazq0F48zbt5+0AAxqfp260XN5AIWNxaxMskwWOUkl+CMEeh/ OkZcz5rn/9L+dAGxllthBGiXSvvkcckDACn+dalwLVRPbtIJJGUFJF4IORk18M0nudBWjk8i52bp JlMKiVyMFhjp+GP0FRrMIlmazUqxOSw4YAVk4tPQDMGm/aZnuZ7qRGmA3jO4ADPalsGuop3tmSNr QYNvOowzY4wy9sUuV3saKfc0QLm1uGnhYtbzRGOSPZudTkcgYp8s8ELWNiGmlmu3ZUDqWAwNx57f jQ4tbj51Y//T/nvt7URo0c7M6lTjIyx9jWdqMtnHaWVqumQxvBc5W4EpIBZsBtp4B5wcV+fnendX R17SWEawCY+eIo9qgPgMSMDJ/X8KrOfscEtxOsa2rf6jDDBPfPp1FAXV7GPHLNHG9naeXCJJDcLK VBZCTk8k1twlbe05dnL/AH26igTta6IYJbJt8cMkZmQhm2HLE57+/wBauahPJaolpHOkn2y3WWeA MHCYbjPv0/OlazuNpXR//9T+f2B/Miltb2OOaCZdodshoMdMH8KZLc21kpRdzqo2KI1Llu2MDmvg oxvud8nZHOXVzcW9zFIYHjST5kXYcnP94Y47dfWt5byS68m1+zRoJiMEE7n4yRg8dqSXvWYRd0L9 vkhleKSaZ7ct+5tG/wBVDjglR1/E1PbWNxfTRXKPKImPzxgYkOOgxWtktBlm2uxHqDwIhXyxg545 9KztbbfDPKty1tMnCNt3Z7dDTEkk9D//1f5/tO0WZ9OivZ5U/fgrCxYCR8HDHb25FXItOskAiuZj vAKpIoCsGPTv64r4CVr6HpwaW5FqCXFnHACfNVX8sFmy5464p1tOZYWjbCODnaf4vpSK93nHTXAu fsySRLKdOy0LbeYQ3X9fWm3WsbodyuySQsIxInSP6+lTJ2Ra02M0xQygr9sSWZF826BO3yc5IGT3 IH61csL9JN8dswKhRHEcc+hOKxG23uf/1vwdMfyuVO59mHAOQPwrNmtbOQNEQ5vICskcavsUc8lj /Svzvm92yPYOsS5TyVje3iuIFwrqzcOvcfpWNdShbnOjQpaR+XsEcTkIpxgjPUA85/GswMuaQ6cy S3lvFFdycW5jfzQc++OM46VtQ3k0LwXM8DOsuFYxfMkfGcGqjG71AsX15avJbPZIbaSEtK5Dcux9 h6dfqapQS6vcSC7uUIgk3RQXBbc77T82fTqK0lFMLdD/1/wavJUmlBu3aWKONkZUfaMkce3Wk0zd Fp8FhsXakruqMc7g2CAPy6e9fnCV9Ee7BWWpEWkjSQQoSrHCqBgE+mK6LTrUCw/0uGJZlB2ADJXP OB/WtorlVirojW9t7RvLhLq//LQFMDBz0NK1+ZP9Hi2xx+Z5mdoDMe5JpickiO9JQwNKGSGdwrSA fd9SB/SsvM/21rSGRyiYkKtkKy9Ace9Q4K4ufXyP/9D8LpLKN3j3fLIw4x0H1qr/AGfIZZLSaZ0s yvmkD5lZhnBI/wA9a/OXBo+gIpG+1Qrp1sfIdH2+eercjqT+P51bN26kafCQjwjDvHyjDpjI+hND i0OLSepblWK5tLbT43+ysk5lmuY2+eXOPvZ7cH86rzQrJZE20omjWTYNrjeXU+mc9RUNXVja6vYU gpaxJcnYz/wBsMM+vvWqjyw6fiQn7NGdpJBY4PalyRN4tW1P/9H8QJbWSaEruV7QESLEwwVYdCKy 9k0oaNJPLEZ2+Ww4kr82UUtkfX80V1LVrtjdkX5ZgNrA/eFQzweXc5M7SM43ccnNJwTBNNXM4pLB IV37QW3tng10NndSGV5sCZYoRtaUf6sggZA9+nNT7MFJPYxJ7mR5nLQ72aTPT7vP/wBetqA/bPs9 qY/3ZYM6j5d/TJP5Gs7WNYyXU//S/EXV7e0+12sdjB9nMYBmljO5iQR94n19K0NPuIby5aETgvbE M8YOdh+n4V+Wy+Fn2Mmr3LWpQs80brfgQvGQbQLzx33e/pXMpeSrqSW8W3yQuyNVyzM3cGsSbo25 Zbp2MKlolK7XkU4YA8EGpdQuXaS0tRMT9mtgqkxhcj3IHP8A9eqjHmE2rbk1jaR3ckjrN5ctuo3x sCDJ7g1ejmcTlop0jW35aQN8wI7CrUEnc5JvWx//0/xma0GpXMZM7tPJKSwb7smfc1pXek2lr5Ag l8+48svdBFO2I54X3IHf3r8qmtT37q9jGS2jtrv7c/nsZ8b/AJWKLj1Hbr3qGa6ke4/1aDDfun3c j8K5WtRll7u/v7qI3cskq2iCFEYZKeh/nS35tEdHky0g5Q9hj3qJ/CXGTvYlitrq/ie8jkS3jjQs q78u4XqAvcmr+gyfacsUe0Am2uGwJ5sYy5X3/pWJstGf/9T8f9Zuli+0y3durW0CoIDbqEkl55Lq Bgcf/rqAT2drbtdWI8pZvmGwZ2/Wvxc+wKkUMk5dxqUkRCGSS3jhy27ORlvfFat1aS3iw3cKiKdU UsSMHA56ev8AjTSbdgKN/qOqzSxQNaB0K+Qbp5OQoGNqjB/KqZ0+8065xd28kpZPNAjcPGUB/vAk D6da25UXGSirFuFEBlkVhDHMf9VnHP8AkVbt4RbrIxcsWOAF61nKKWqCUrqx/9X8lTObqKIyqZXg GIvM+bZjPSsu/uMyQSPHFAoG2Rt3LHoOtfjdNdT7DYmvIJI7BhG6l5iCC46DOcA/nXNiMou1Vdnd tgZFJwa0Ji09UWbeznikWCR2XccszMSVz+NXJ7Z7YSPaXDLcA/u5XG5GNVFe8iJ7lmO5ukidzGJb iVQruBt3kYyR79fzq5f/AG2SOCd2VbNomtzECPM8wbTnHXoefqK6Iq+hB//W/GiaEC2khkdlVzhR GPnJPArYnt1tdItlQSeehVVtkjPJOAWI/rX5OfUrfUn0uB2id5FZJc4COuM+9aFu91FcedHKqMgI yOxrPlfOVO19Dm72PU2LXrQRRzpOfMuVlDSiIN057NxwB37VrWMtvjF06s0qEJDHy7HHBPtmqmrr QgrWrXK232N4w8pkPCjEajOQOfSmafFd3U9y/lm3bHlG4iGSAvGAaxA//9f8ktP+wK1w1q3nkMVu bh12YI/hA9s1gX8xZyIl89Wl27+iqM1+R0+p9DdosSXEGmQWVl5Lm5uHLxzr+8W1zknJ6DOSK1Yt QnaFLG8upJvIyYGc/IoY5IU9KrVRu9xFOdcuu+PPzAAn7pHrWmsF5dtACsYiL+WjB8vxjgjtnoKo ueyKtxbxrdtNEskSF9vkq5YcevrWhZ2TSPLMA26JdyoBy/qB70EH/9D8jbudEWciMDcQh2j5wTxz VuxN2io8920ojUBNxDgqegz7D0r8mbsfRKN1crySXV1qE0UaxrG1vlLiSQIgOTncT04xirWi6RNc TXa3Dw24gQYdpV2ysTjCn+L8KG7zTYpLlsVC66VeS3DkNAkhTemQSvQ8dadOtlJcmcRnawDoxH3T j09f8a5Jq9Ro3cdLmgscCxkIfMnlT90BxsPcmo3sjZ2QncPLIzEtwcRj3P4VoaqN6Z//0fyMt3+3 T2MiuGS0uRO0YG6OULkYb25/StW+inWdZo7qOCOVi4iVdqqcnAHpX4+lZWPpvt/IzppJkPlxyb53 PLIc1esLFJLe4lvoIjNdDyl2HEyBcYbPqcU0ib+5YRUWG7MEwSIRpkJM4BfGMfX6VFdPIb55ba3S G3ESkgJ+7aTuF9uM/jRGyaucs481OV+4ljbXK3st5cIY/OXaDGpxj0ArRkZyzSwBYVjTD5bDy54z g9evapqLczp/En2X6H//0vytS7aF7ZxBHeK7bJIpM7B6Hgjv2q1aWLx3gaApGCS7J0Tn1Ffiko31 PoISd9UOaGdryGCRwMqyW6Z2IqrliPbr+tOhvPsVxb3kgE8NvMGMEnAcA8jHvzx71nKGmp0weuiL 9m1s7SX5sdlrNI7GBBsLn8Oe45qzp0RebbEqxx5JVpF3Knp1qGtHY362L8cWoP51tbxhwh8ySQ4U enJNYlxNJHA1rcJsW6fypmRtpYc/KD+uPpWPLboTdH//0/y2S4v7B7WOxiNqts28kx7pLxTwDIDn tj8K6a0zfXMBjt4baZ5Apx8qu3r9c1+DpWuj66TsjY0e2dpbtLqcI5kKWluirlyD1Y+4/pWJdWtx dXM8EdzLbRGUCZoHBkiKnBKH8D+ZrN3TRk3c2bLfbzyIbySY2kQeK5lb9/KcgAAdscflUHh6bVDc amuo3LXkAl8+3kkULKoJ+ZDjt0/OokrN2CLsdgzWN7awJFCirZjbH5I27SAV6e2SMVWSyCpE81xN vtSZYjGcyt14Hpn2rGTT2NVK7sf/1Pz7t9Ft47h5IldZ55GkzHlz8x3Nn6nFa8E0kcnlyaemo26u IhCwLyyg9V2e/Sv53PsoWktS/bX++4hszbeRbW43PDbjCW8ZOAi54BA6D2rSna3TTlvYGSOaC4ME VkELT3AG47vT0ApL+JE1eiMu7ub6a2tsW8UcxYO8QJk3qD0bPQ8duldHNd2xdVjtIoWcDeFz+6GP 8/TNYy+J2NabukvIL6xZIo5FCzB1yQrDdjpUNrYG4d0uUjVApBSXC9O2PwrKa6GilKN2f//V+Qry xuNJS3vHuGkS4l8qziH3YGOQCwHY+prV02Ro1v7ZY7afVmAilTklTjuBz6c81/Mjhdn6PGbvZFSG +lt7ia0eJo3EflTxvEfLQsOQrEYOPat3SwlnAo85djyFY4Sfn9TgenJ/Ksmu4JtrXzM/UdRtormO 2mj+0Q3UotvKOY8llzgf41qwTeUz7bJkt44vlVMnyiowAfYmsJK2h0qV7Mjh1Ce4aGRRLDJu2SJL CYSuOmM9RjHP1roLe6b7Xcr9l8wWi7LiUvmOU4zle3GR+lYzVmXGST1P/9bwkeI74TpPunS0ZFtl SKImaNi23tzt5HsMZreEiq3mSjfOrYdZEyMe9fycnq0frc3dIBboYHbyTGjyfI56Njr/AEqlBOY5 4LVruW2tJLpVnhGAsig/MfXNZz3KjK+jNJ9QjtbpbO4ikkspVYLcR/dj4+XI96r3kAuYYIzdTeXE eET5dydlB7VBTaSuTXVxNFbwra7vLRRHJIzFmQDhev8AWr+nvJCnkkrNLcrvMpQoo+vbuKBKStqf /9fz3TWlguLsalLA8wQG0jhfzYkbI7/TNaEuoxCPzF2ZhUmeTAUIOh5r+Q4JtH67Wd53M64uYoLY xxozee4ZGj+YEEZbIx79c9qXT7tD5sTnbCU5y+1SRz8w9qzkmlYyLFlLAZ1ZGVkZyqsh3KOxzWtr h1LTxbxvMHsXYvZLbz+dEMAEllHCHJPB5rKe+pENv67sh0dZgxvGeJHAIiJYBuev54FOvYYWmGIt wTbu2Luj+Y4/MVBtTuf/0IhJFGsEXlxY2rCsaJ5azkDAyOpJqlGki2VxaXUkkUF4GIcjDR4zjafb pX8brex+wEFzp9xaC0lNslwAiyxtNh0kHr7n2qe5jtVktGgIeVYvtLADY3PG0r1GD/OguLauOuFG pTRuGC3Cp5exzhCAPXPWltoYYCTDO0uoMu0Ww+ZRz8oA7kmrUGyb63Gz6na6jqFtZwSwQSxqiXJZ dgd9uWUZ7jHJHpS3F5b2pewuIDMsbEpIyfI+c8ZHIHSqjHlepEvhZ//Ry4LqxKNaR4t5Y4ldII2L opbng/gasw3d1cxyETqn2ZNpUOFaRT8uPf3r+QErn65BWepHe6qltaxR3cpikmTYGiQyBj2XHvjG awI7q7vLaWI31xJHHLiC1I+SBT97Hpkjv61MU1c0HFJroCDedgHQ9VPqD+dXmVbe1RIL5mliGZbc AjzMDGSelPlsrFwTuU7WVpZN0iPhTuCseuOTiptVisr2aZ7aQrbpapJJGYzG6/KN3HXg5/KnbS40 2pWZ/9Ln4zsitFjlmaG3TABfKEYptpd/aJv9GTbAjMHdhsBI67R9a/kBn7VTltcsNYzvdCeO5aUy KFYIMNGB0FQGLZdqjy7zHLmUuckDuK0gtNSpS6IZeOq7xBcqpdsBpASi4/z2qvarcX1uBdKFMUmV nhc7SM8DB+nerMJ6ItLqpspFs+TBvPQc5IwTj8BWBqdh9pmRorf7XtfzhKwBS1IOd7fn2oMj/9Pj bg2kkM9rBJOsS2+yDJDTRuy4JA/3iSPwrFGnztYmC4DRso2+dvzJJ0wc++P1r+Rmk9z9fa0sTJd6 jpjp9sWNrWZAU8o53qvB3e/8qzZ9QEsiXFshhbziqI/3iOaycWnYzTaaVym806TqHYiInDovBbt1 p0sl5YKt0P3BD7rWZsMy+n+FRKGupqKLyd7yTUNUtIrAakUMlvbR+bDGU481c85bGevGagvHhniS KCeUO7sJJMGMKvG0/Xr+lJQSMG7s/9TyFLGOCO2u5lhuJYP9UZHEqseOSuev1rFvTJas90rxXEl1 nEQyDGc/N04z7fWv5Dgup+sElpqiiSOGQ7sEM0b8p9MVoSW2myi7jsc+Z/rJ5gTFEQRyqdMNz2re MW3cLdCnbsY4Ut/tG9YvlVS27aB2qtcyWcgdnKx+V92Vm+XP1reKu9SHBdBLpVeGEG7nbYuPsx4g /wB7P9Kw5Bb7Ri4lgu0kDjaAVdR2JPStjNpo/9X5oWS4mvEVJ2MkmFHYe+PrU+oteXG2wijleeKT fHC3yfMRg9u4H6V/K5+oGXdajpOn3NpHFaX00jBYLoRKJkkkGd+0ZyBwafqM76pdxyvBHp+lXFmY ra1Rx5qFOCX7jJ9eadrmc272CeS3EFvBMjXkRt/Jwz7SmM456/8A66W3nRSxuVZLcfeaIGTy09h9 K0gtLkXaMJ7jTZBe6jps813bRZt4Abc2shkB6lW5x2z04HNY6w3t9C/k7ZJ40MkrTOFwuct+P862 gruwNvqf/9b5D02KGyjLu8XlpG0nlTkGMk8N8p471L59hY6JLBbPHKb+bZ9k8sYhCjIKegx/hX8z WR+lSd7HO311e6wuhSNpttDa6FbyW808svlzW4LswbAyDyfXsDSWV/ax3ciw3y36SSmF9qg+Tx2/ n1q4K71JM3U5La81u1TT9Qj+06aj3Ekc0hW2cDIKHrgk8DvntXQQ3mma1bW6zaQ+kX0RMd1cmX7Q 8oB4K5/h6kfWt4q7sBzOqmwhlubKztHvledPsLysYpPNLAMTweozx703Wp/DVja2wu7qWLU0n8u+ S1txPDZooG1mkHHJyP8ACt0raID/1/gyd2uopJHvI7ayWFdkqKqtJjhTjoT05+tZWuQ+ILaCwlsH uoonAkP2jIN5GoxheO/Xiv5+irKx+kDdN8N3epSWmuPcadDbzRSxQw3EpW6ndOCMD7oB9e4rFtrO 8eW6jEF1GdNvPI82ZlC3G4btqnPKjPH0roSsrFRjc2bozOrDy/Olt1CyN0KgcdfyrjrqdbMS3c9z IqXA8p0aQ4RV7Y9OfxramgcGi/Hb2MmkNcxuGaQjyd2Aw4yeOvT+dcxZ29nqDhJYzG1uXkfymKyP /tOM8/8A169GjHUwqx5kf//Q/IDX4bD7LdLZGcyA4hknx51vzzj9eua+VvHFhqDvKkVzcNfzKI7S aMhZUY4CtgfQV+a0Fax9dWgj88fiPpdzYXRjvZnnkhmea5CyGRfPUks2c8nmvIxauyLdS3AbcC3l dGix6+3+FevQWljxMRH3kMttR8tJbbaEWRiUlJxtJGK7Pw9EtrKLiaUSOIWVPPUNHhu+exHrmu6m rHJNcqaO3l1F7eZkt83izWgMk9s26KI4GBu6cdOPeur0a8s1sQbyO6mlZfLhbokbA8lyQcjHHFE1 dSZzUN2f/9H+RbUdc1PWNBFnp2nahFeSMtsfNLwhY+MrDuUAkjgnt2qfSdOvkib+076C2BiWKC0J KuuMghm6H6dq+N5v9nuejOCbueH+M9W+0vfW1pplvK+nsFEsgMTv84+dWzhuD+Fcaitd+WlzG7NC d4JjznPTHvXdSfuaGU0kkWdRi021thbz2Csl3IgjlMO8rICMFvpxXsmj6reaf5F1pMou9K+yR213 EECNZuVyxiHVskc+tdSasjM6PxFfvqem2kdnprT+ewhhczmCW1fjfKy8EA4xg+vtXLXFjrMUdsRI Yo4Sft0UYyuSMK27147etdEPhFJ2Vz//0v4759Fs7a0/tCK/kuJbhVE8V0QpGRyE5yQMc1BZRQ21 rNaJcRRWe4usQf5SW5bP6/nXnm697Upwag3mWd5p1vIY/tTW0j7CudmRvXjkZH+c1u/Y4Lc3FzhF nmUysqIAAxxk/WgZmWd1P9oW1PmzSTylo8IB07AgenrVa9+1yz7Lhru3YswjeRSXwpOBnpj+hoI5 FcfAs0UsczXCyT5wYX4STJwCW7Guxgupbea4gvXjt5rGPfaxsnmxzvwQdw6fxAduKDCVNXP/0/44 tSsZ7jTbq60q+tzqtxct5mmyXXlu3Q7tuc4HPGK39KldtL23CzPqkFsLeLapa0gHVlJPbk8CvOTT 2MnC2xzZ1i6YXgWazDSFY4woxcbUwCw427s8e/fqalsbmV52nut011LCFkunURyHZgAnGKZPK2tj e82O7iiiubRRLLcgC4ByWVegfPABxjJ9RXKeKYfEx8QCzn0bRJbWGwTU7PzJBbXcrbiMZAO7gAj0 ApMIw00O5srxdObSXabTf7W1SJw1hbzCa3hK8NHvPr74OKzbxHvb5LW5sorO2lLSpKjl4bcD7wz6 57VgbxWyP//U/j0sNLSHUibOS8kM06xCG4gwjbeFITpg+vStzXI7S63WcdtHDcptUW4iJiDngH8+ 3bNeYo6WNOTWxpadFI73GhzxRR3Hk9bkbBA6jrk9DwRisS0ik1OSS2uAUms4jII4MyBwOOnp9ama 1Bxs7o5lTFf6lFZwymKIBneef9xHC0bAGMkjGTg8deK7ZbWKBpBEyOTH/r1OYm47UlBsc9jF0YNp pm0pp5jYvcm6tluTvjQsTuZD257fT0rcfS7G91i4Wa6G42Cta+e5WSV8jeN/QZGQOR0FV7PzOWb1 sf/V/kRuntLfXdNks9NmW3gt/LeA5+zztgAnPQYxkU1rH7Pp89ghCrdXn2qRrr95LuJPG70GTx2r yJKzsTD4SldWVyrRq5065gs22gwR7JZWxjPmcE4/zmuggkvZNSjGq6dFeJbWYWMTXBdEBUhcMDnA HQA9qz9mjJ7jVsok0+5hlmjt7WNi6QB/3aknOQPaqdsltBvmhEkpCgMxyFXGQMZ6ZzScOxdPqXtH v4fMnllWO5twSuFc/vH7AkdhmqGUs7+S4s3kT7RDtFkDmENnjbnp6U5K0LHXHY//1v5Hp9OuYlNw ZfIn8wNKjIJFdTy3PYjtTrGdUvfIu5maOYbYwyAgHr1/xr580n0N5rW5Ybo5jISCAcAZPYZFcFoF xfpqjaVdW0j20sspv7GGZrdpSScDIySc0GZvWdnAsl3F9nWK2trfLNJMWkUFsbcH5u4/OtbR7bSJ gIb21ksrEgxothESFbBxx2yeST6mtYK24n2MXU7U3EqBrdJjACIipzOnbge4HNWNClFzHPDGlzHG wHnJcW3yxupx+7kx9eAe9U1fQUn7rsf/1/5KriwkQBru4d4YTviti+Gmwc4z/T3rUtprO5uGkTzI kWTeiORvhXHC574714yVlY5y3PEYkaYJBcyswl8zYJWB7HPUfQVXgS/uL+M380d8HiJcXDYbPYde B170wT6o5e7mltZLu1tVETTXCwRrnZbiMff2tVu1i1MmCGzvQ3mSiGZ4GGYV5+63ck4H41zuPRgb 8rXkKSRLKoS7/wBFu5Q++5i24wyggjPFV9NS/wDtvkW2pMbWGPbLPdhI9+3ucDGRjFZSjy6oibsr H//Q/k6vLWO21nTdQu47h2guFkZYZ8wyoeGKgcA8nnntWxqNw4tDcLbb0MwdXA3OgPAbH49a+XOZ ao5O5uLhL62ujGIHjiX7K/KCXbnPPc9ajn0s3+oXGsG3kgglUNeGIlInxwxbHbP86qLadhnWalqV ppdlJpS3K2ZWJGt4TiTzpGUbTnv170+wuLmC3N3eXBklihGGYbWAA7f4VsFjlLu5k1Aqi+Ym+Ys6 RD93g9z9MipYlu9NeG4SZntITtltGIES7sDzPUkelBMldWP/0f5Ob63v11SHUI7ovaNEpeFuu4dP wPT8KltrubV7ooIEsiQySfLjeVGevTnAr584ZRaJhaE/Z7qRBZm1nbzY4ZvnuFGVJb1zkYHT8a0z rOnoLPVrjTxd6DZzGGUx5N3A4yoZ4wMkAnpxjH1wGqSWiMyG2vbi3uiAsrGVpEmZwsscTHj/ACPQ VXtraOTTZLISefKl4s321mMdxb7W3Bcr6HGPpUOCvoOxu3OqS307SaxKfLeGO2hZvmAWJdvT1OM0 y4sLe2v4nsLo3tsCsocsBFyoONvtmr5feRpFWjqj/9L+Vxr60hmM93Kirv2kAbic+1ZF2bWXVJns i6CMHaj4SNcjIOe/FfNuN5HMpatEEgY7J1lPnMCZMffTGRmug0u1Waxdkuws9rEZY0aTyzNyARj6 H86XK1FpkuXvWGvJG9uk80MUkZJBLKGcY4JA7VWhk020nihR0WC5HzMoz5RJ6vVU1aKNKknysW2t 7mGaTUbqCaNI5WjtfMIMVyuARjHtjj3qlbaQvlTXllZyR+e5lmiUBWdsnkAn1P61U0+ZWN4p+zR/ /9P+VJtDlu/tFyb+TTL7a0sc7KGkuZAPuMT6gYyfzq3De6Tc6VBYajaTJd2l0sj3Vi5llLAjovsR kfWvAe5q9/kVZrSK1le7HnPDISgSXC53EBXYddwGO9Uo1igvUSSSUtGfNSRkYIevCnGPasoL3rGU FaxtahezapAlp9r/AHSIwtC0bSeTJ0AUfXrVG2MjeHvsdw8banBLJG9wkY83fu9+SAAMZ9at6FS+ JlXw/JLqEN2LiMYs3aF5JVETS7SBwuOev6VYjvo/MXTCwESSbtsfG3tmmZOOi8j/1P5Tb1jZoCgj mkL7t+cS8dMjpVq1mnvbbyrq1inw3nJEYcsccZUnj1r58wktWiW4lk+zmKxknsQ8ZjaNR5Ei54Zf bvxVTfBpsJkQSeWz+ZcuFJeV8AFmx1PFBMb8upa1XRvEGqOl3psMUkQClbEcTTnH8HHXjofWs23s 9Q8r7BqcMlnLDI2YGwZYD3BI70tCr3NtEtLOGK3kuN9srB7mX7vuCwxjg/hUF01r/aTXFvL5yPGu 0BRHa+xQdqVoxEf/1f5ZHlKRhoyEkZDvuQ/yDngf4/Suf1CK/nlhNxsgFrKMG3kEySjjJB6HP9K+ ZT92xkotSsajWcrG3SK4MkW8lYy+ZNxx/Oq9lNpc017bLblTbjM5eHbCzHrtJ6kY7VmviY5KyMvU b2aaF7CGFJIYZBskmHlhycfdb/ZFdPNeXRh0kWDeU+kqNl0QS248kA/lRJ2MWtURyLJcWEkWoMGh uZCZNsmJpOeTxyPpTLvRoDZGCxgtTMsizQi5kChCMZx/P1yKe8S7O9j/1v5UL+5aw8iO3iTVZiB9 stiCqxHuue+B3rUFra2cstxp8iyJdRJ5qscmB8fNtHbHSvk5aRTM4xaauX4L29QiCOAXMEsRgeRj ie2yc5Qe/I/GjxAyCOyXTbOW3mht997G1xvMzY+8Aex5+WpmrSaNk3zXKOlXtzJLDG6GS1+/ESwA iYcsGU9uDVmPV2knvZyhmW9mMOnm3gZjG2cENjgdDyelNaRug+zbzIdPtrm1u1Exbzh+8ubULym7 oSDyM1pa15E8TQN5kZkAWPqu5s5AOPpmqg73Ktoz/9f+XBJLW3sDcXQkluodwaNB8rDGFxjnIPPp Vy28+IRRC4jd5FEzSbwiR5GVXPTI4/Gvl95MqlqrlI3F0mqTh42njdRsuAcqZcnOPXgCrFs93pk9 3eJCHhe0aPyo48kvI2Wc+/p9aAqRuUNP1We+S4At57YLJ+8EqGPzD2wPwrdvHRooi6i3YoArKvoA PzOOazha7OanqpJmPFDc3TSNOytbwtmLg7mA67v0qeL7dL5MtpM0Vsk/lF/JAEXPVgRkj0pN3qJG NNXZ/9D+ZjWTaC8jsIW+2mZxFazwodtwxGeBjj05qaYGx0a8shFbQXts/myLMv76I52nPfHB4r45 EcqtcxLa7vYYpxZWCXdxfQr5u7BaBRzvGfQZ4qvZXV2NQjWe3R7NULM7Z8wOCNp2Y6daLXbQ4pLY 6Oaa1+2NcT3LQJFCZFRU2xnP8IPTn0rG0e+kvv7Qu7557ddMvGSyt0JMV2pAw+TxnmhrRhJLY1YZ 7XVYJPJ1Z7drvMKOBseE4/hBHbGT171dtFj0qQxpfvqEK4EcsqqhJAweAPX+VEfhRpSjZan/0f5s 7aPS5bj/AE391BNkTOse5wD6D1p+nvAmmape3P2hJNNLNbRQRecbqNThS3PGcivkre4zahpTaMaL UrfVLKO6ljeJZlMiK0e1yCDtyvbtWJZ2V5M89xKstvboCYZRna+OuR9Ox9azirWQ68bJotaLey2N 7eB0e8+YFJGg8tY0PREI+nrnNdNus4VmntonbzDvlHJw2ABnP9PWuiz5jmpCebeTWkk7YtYVTc+6 QKxHbjP1/KqekW8UE8eoG0ZIZYPLWMOVF11Bcn61i73Zb3Z//9L+aw6ilqZIowTNkkIMk7feoQ9+ Unu1l3PJH5MFvKqmKAnuBjPU+tfHgUriJ7dIGcG4vHIXzApPzHqB6Dih9SGlLPc3k5SyEQSfcpZQ WYAcDPfj8aANrzBPbQCTckMhEiFeOnv74qxCbW4v/s1msQuzbebPC4KLKkYALlj16+veol8SE9EQ XWnrZ6k9rpztLIseb+W3Ae0kY4YJu68Ajp+vFR3l/NZxJLPA8KsAvloC43fWpWjYLVH/0/5t4AL7 ymVGffgLkYx9alnK6c6/anjKl9mwyBcf/W9/evjGrVDKDs7GlHcrDbyTuqgJ/GeAv0qssh1GIkcs +du3uKs6k7yK8Ec8ET2pVnbz/NSaVdxC/wBxT6Dn9PSlhtEa3m+0PJK4ujNEzH5IhkkD8CeKSSWx vTXUs24SZGUbGySpY4Ib1q5pVybSJ0t7cbIyVVC+zGScnFM0P//U/nYmury6kjBXaYeFOPkcZz+m f1qLULOyu0hkmQfb4Jg8ZYhLcjaRyPXNfEySTsjvaMi0nNvFdGX5YkJ2LGQyk98AdasPeC2s5vIj ZvNXMrD7zg9vWtJNLchQ01M3R0FtI7yRACX5mIGQB2HtWzqE0flxFBPEyPl1A2pIMY4PcUpSVrGb XRiie6eJLfRktJ5XbzGub9/s6KhByCx445AH61Uuf3UCR3MIleOTczREOinocH8TWRnya+R//9X+ cy3mt5zCFzbeUN7Ept3jnrWda3Bk19WIllz8kULqVinx+lfDnRYt2t8oF9O5nCwzvDIZk2INp/h9 RxxVe1nMrtKp+XduHbIoKcWie7ksbqQKbh7PzPktNqmSR5OmMcce9aVjB9hKwPOt3vjJeQrsRDj8 /wAqBRV3YqrdbftULSTJIU/dDyiIl+j9M+3tSJPfabFDPJF9ok80YkI5iB/iOf5UWNeRWsf/1v50 bu8nS4hure8klgKbpLdwBGWI5x34q0Jf7UBZYVh+XcSGyQR7fhXwjhfY9C1tDGvbue2hlVpmaZji M/wpjvn/ABroNNme80qOG4uBhwdiN80e7/ZJ6/8A1qFBIzn0HCC5t2TzEEmBtODgdOorTXUUt0hg S0Elu6sJJS23y36n5e45IocE9hJpRsc08yWdyz20UYaSbe8qKN7eoNaLapEC0kx4C5ZyPu1PJIm5 /9f+eqS+t/MhjZx5Wd8zr95U74FVJNS06BriOzEt3cIomeOZf9SrElGU55JCnjtXwyVlZHQaMk9v eyWCSO6pMw86XZuaIdzt749KmkxbTwkT4MD7rZx8rHrg4oskNNrYq3UsiTfbLvypQZAI/syZcKcD kD8+K249en05lEdvFIWZDESSrxZI+b04680xbbFWGAi6v7t3aS4uJjKsmcr749ajmjEyOZAWK5zh c5PpUSlbRFQ3P//Q/n+tdOuVhjZ1khiLb0aUkIv+72H4VDey2ygWt/cwrcSZaJd3zMB0bBr8/O+L utQm1fTY1sopnkukVc3Nyv3A3ACf/X961kksJpVaIhTs+Qe1JuyuMYbhLZ7mS0ihmcwmB/NGUBI/ mM5FYZkvobdn3W8dnM5W9dsBm2gFcD29T2rFu7uWpNRHyXdg2lwbYWluGnJk8iIusiYAXIH4/hU9 vAkMqzoBE4G4IBgflSNFsf/R/n5h1S7jnniX5WmBU4GSFJzx+VXtPu0M9zFJH50ssXyls7g3Yj6e lfm57BVi1l1XyZ0USo5X9yrENz3+n9KtRXFxG0kuNvmYCoDwBn/9VAFi782a2iupiF8pioikGCR2 b0//AF1cimnW3jkmBWFx8n9xjW0f0K5GrXM2eYLfwhRxgEpgkMfer5mkiilZXKh2x5Q6D6ClNtbF uKTSR//S/A+yhW+N1Dd28kUMbhg4b/WAEHIPbkUy4kh/eRRSPlWxG+MEGvzfY9uWjsa1ha3ws1vI pYsRMQCwzIGGDnb6U2fUr2aXLkhlGyQKoAc8c/8A6q1U1bUjyKstw0gdJ4ZU8sj94UKZ+lEdl9pG 9bh2DEKqRnDCrDyNa5vY0eG3vIi/lgbBtJUben0qATwz6k08UsnyW4SSMLlSRnApXRHOr2P/0/wr lW4NvcXe/asePKj6Oxz0/Q0yylMkgeWVgrja4J4T3/Wvz+6Z7cJW0ZDMVWSQGMJESQHU5Zvekt4C qGWPPlZwxxyamVramiaexNLG8SiSAjbIuBv/ACot3htTHAYwjrmd5lUrCSeMZ6dqxGXQjXoZ1jSV rYCWQxZcKCcKatm7u7e1nS5QeTcR7lVlBxgkZH5VrGKsaqatqf/U/C+3uZLgIgcosZ4OdoPsaiu1 vftlolssPlu+ZpJX2qcYxjH581+fn0jn2NiC9iuiTfR2tvPAhh8y3QLJKoJ2lz6/4CqMksNvMXyS M/JI3I9qymrMamrajrsxSBJJERjjAbo1Uo7i4LSRtE32cKBuRcACs3ohxknsaNlNEGQFUaOQ7Vdl 6fWnTtPYmEwvE2blnQj76L6H/wCv71gbxld2P//V/DO9ulmKFHkWYHcwTgPj8eRW/YpCtuL6GKCK e4gAlMQxKV9X75OK/LJSVrH1cpX0RRMjyfLCsmVYorBSw96qDT4LI4a7P2yRTIqKu0wrnGc+tTBJ 7kEEJkJKzXkrbXLAl9pcnsT3rXje1SXN28rt5JEYjIO09s+1apW0A1JrqOS2jZJFgHKLg7ZZGXrk ZzXNwzTWd9dSJGbmCRVeVUUllzwc9uaDCSs2f//W/FGa9v2AmtYYEcKC0WTmMdMituG9ez02G7kL rLcXH2dlKEuxOMYHofevyya0Pfsk7mhJqlhHZBWdzcPuWZJYdqoOMYPfNcubuIXG77OGZhiMMCVB Hce/+Nc011GaVosouH1CaV4ABt8uMDbOcY+YdQMdxVj7NHczbbqIxo43KQPlPtWY1oy608FgqWxj BDjy4UiBIAHc+lZ1nGhu45gXjJlMaPIpXbzg/wAqmUbm61P/1/xovZftWpPbLdy/YATDNOYSodhj gKSM4I/WpbS2NtbGxtZVllLFw15IIUY5z944Axjj6V+MqLvZn1Sk1oLCPKubqVG3yPCIXIO6Fdp4 I960tP1AOJULqTH8sgLYZffFbWtoXzq4sZaSUvGguUicMEYExsQcjp/MVcjmuY7iKaSOMDHMWd8Y 9ifTrQWmnsZl00M0skfkxht4kUgdCM/5/CopYbuAxyxSxzebFzbry0PJGT9f6Umr6Af/0PyJtGdh NBKwiaGATEscb8nGB71IptjIEnijlKruUyKGH1H5V+PJW0PsLdDTubGG/t2Z7mC0WJMqk0gi832X 3rlI/tdpetDbmKaKCI7X3CSMkjqW9a0jG+rElZWGvcxljDOzPMw4kVcgN9R0q1au1vFJ50n2gK+/ ymGSgPA4/CtFFLYznuWp5v3UU8fybZcsNvBHof0qk0M9xcJcLdIEtwX8pH3GQt2IHTHv6VrTRHkf /9H8d/tEunXUVw1rb3CzPtWOeTYi/wC1n1GKv3eqfa78RTCC1lnhHkhMBMYwD/8AXr8tlG6PqCKF NSgaSB7zcyE7Q4DRjn+Ej/GnC7mS8gjUR7J22ylyQc/7P/16xAvahalFLPICvBSHPMnrWbEiyKbt W+yvC2PLA3EAen+NBm/hI11KOaVEjc7zlZXUc4qSyg164vJodMvrS309B5lwt0dhkQde/f2yazlH qhS0Ssf/0vx2sb+D7PLsUszys0ygYB5xwKtQi1W2aWVQIG/eFCNuxR1zn2zX5JBNbn0Bp6zbadMs ctsPKj8pTGiNvCjA7/rXK21y4vDHcs7xR58lQnyEDHf/ABqwNmVb68khukYCytkMZiKYkY84x+vP vVXUJdVISNGezUgMrrwAO1AFrzpNkcLSGOYj5JAm7OON2Pyq2mrXNvd2VraFpL9YiElxtSR+AAVH c/0oKcm1Zn//0/yGkvszFLy1BLzB5cKVCnPzY78VpX0nmCC206NNh5lblSoPoMdea/Jmrn0sHdWM K5s5opds0kgEq+WYzkZHf86knurMSQpZvLthYI8bNgqV45puNnqTNp6I1BayX9vNcxvAotwpaOWU RtIC2PkB6kdeKyjusLiTzpGngcgBBgE9OFP4VzNWqM63G6saOmTrMtxM6MjxNgDOSB2/r+VdLZGT Vop7JHMELwMgkz1OOAfY9Pxq+V35SqavGx//1PyHsbaTT2a2QMkcZMRkb7oOcEZoukv4WSKVA1qJ c+cW3defz5r8iivdbPp9PaNeRctzbQSNJKzN+6zGYv3nPGM8+lC35tr4R+T5trMdqySOVMZPcip2 djFNaodc6S2pXUdzL80cXAVeYz6HFao0qU2zIskpUZYsf4Pp6UW0uZq7i7f1uaEV7LKhW4dRuUQx zP1YKNufwx+lc3eC+HmGzt2vBFIEWVgY4+cck49Mn8KU+plDSyP/1fyu077XJctpwsospF9rmu5X 2GMKGyqDocjk/wC6K09JlS6muZY4pyFbYhdSqyFeu0V+Ln0CV9CeedLuKO7kjhgERMaOnM7KCPvD tzXO6lfQLdQLGA8CAfPgglj1yP0/CpkrxOmF4sfaXOsPfzS2kccmnNaBoo2YRu0ikkjnjkCujt9Z lvoBdNarYyoPKmhD71yvf0yfasmrJGyd20Qz31w726W2TLO+VWSTyojjHVug6966+0uFuNKuIJrK KZrXF3HII1lO9eDt7nsOfUVDW5ntyn//1vzQTzdQuJLu5EkFyzl3hmAEkozwcdvpV/UpHksNMeys X0+WRT++uAYrh5FOGYA+gHGPevwpr8EfUy3KEU9zDNbk3MomUH964C5PGST6/wCNdTfW9tp0DzJc xXMwQXEjWreeCCMnkd/asZXdkiJbE0Bs4Gh1eeG1uWkhzHbpMCcHoHUHI5HQ4rCR7ye+lISKyhkz hVmJjPcLz/WsndsIbGqwvoNNF3p37sxAmZQd0i5ODkDsc/rV/QIZ7rTZrwTztJDL5ksdwpxhs8Bj 6Ht+tYNW0NE+XU//1/gS3+0vqb3lrO9tDHGI5bcNkTHPUDsfp2Aq1aajcaPq8l9bTXD3ZlHlQLCH dZSoT5RjPI/rX86Tutj66DbRau7XV/C+syQKjeRqVhFczG4OGQyAMU8s9CDkHPpT5bhzc6b5e12i lEjxoPuEZxn1qbtTL5mWbjU7WDU9t+t1DbvmSSS2iLvCOec9BzxT9MbTI4n1C0me5t55GO2Te8qg EgZ/HtUvdm0dEi/p1y9xHJK0XmNLIGRSSPs6qeSB9Bnn0/Grs0sV3cXaTXskgvIis0hwzoNuMJ6d Bz7/AIVl2uac+tz/0PktJ98/2cAXVklqkMfn5MkTrj5hjjtmpgklsbm4trxrG8KYjvII1a5J6Dk8 fn2r+Zz79S10MZ7fxJf3UdxF50qK+bmF13RsM/64tjdux+HzfjW5rU83k6alrbWz3E8xXchy9ltG GZl7Z7euaxk7suEraM3b4Wl2bCae3t/MsIV8pjGPP37cMxb35+lZSSanJJeILk29pcKI4mhGXyOS WB464rGfU3T2Zr2sc1zcX7TulxBDGsaSNKIZs7QBtU8kcZ9s1oWs9pPaSae8kdmVbdJMpInf6nnP HHArnlFt6Fxl3P/R8LhghkEksBEcUBDNh8MxHGapm9kt5ZYvKaWO4biUDcY+5JPbpX8nI/V5Sso+ ht2120NoFzJOI2JRZSWTP+cVzF5qd0160hgE82coEQRxADgDA6dqiaFGV1dmhe6jPf39vplpbqkE UAlubpnJZyf4dv59PStyxkkZ4IJlIgRwHdFzIV9KzKctbM1LzT7OATWsN+19FPiU4BjaHPIU/T2o tdRtLeSKG7cwgnyt8gyABwDmgnmVrn//0vNJ5LVN0cZEpeQ+VIF5J55z+FSxWitbpbpDull+Wd3P 7uTJ7jt1r+RqS0Z+r1371htxZ3VpLLGHDW8UJjDoR8wI52n/ADwarQ2e2JmdXeOQ4I28hT7VnUVt SYSvoaEdvZWtuY7dordoZQyqBiSTcT29OD+dXRd213AbOEq1xJcbVjU4VWPBJ/Os5Q97UVLVP+uo S3ZtrWWzkity9qoNzcRZkaED6HH6Zq/ZXEapE6fvbSRN/wDt8Dg7e1ROPKzohof/0+Ykvbe7kQQv KJoT5rI0RTyx0B3dP/1Vn3CX0jRINUuDasxDrcIpigyeSCF3f56V/HMVd2P1+6vY0I728S3TRft0 V19lYvHcQuJDIuAAfbvx7mpIxPLLGkZjSfy9pLtgsB2zVchS6l9ZxZW2y5g26hExzsfKY7ZyOtRK 3mN9pt38i5xlShw0bdiD7Hp9K0S6CMmDR72+lmma58y8h3Sk7QshIBO70yf50unzXYt757+ZS5mV FDfNNJnIwF644JJ+lPlZMl7p/9Tj72SLzmk+x2dnELWO3Rrd5FJIzktuJHOR0OPYVX1Fza21u8bl C8oiJAYgjnqfWv5FjGx+vx0ui8Zor2SCOdJMCI7Whi3BCB8pPYZOOvvV60u10wNILZLonh1dc7/r UxXcu1rNlOJpVuJTLGsZzvWMHoDyB+VQkvcG4kaWO0SPnEhwWHTgU+XRv1NI6aF6zaBIJI5Y0lIx LDKeGj28mmpqUEaSvBHE9xNEYZQyhgq56Z/DtQo3gr9yLpSVj//V4u+vbaVra1guvssrIZZbeFcq 6rhWBJ6ZyOnqa17ALHG0UtlFKJI820ryMjwk/wAWAcHg9DX8iU/hTZ+x05J2JIDqFnffZraV4bid eGzt257ZNYFy8mnTtPPCF+Y73QGRpST94+/Pb0qzXYvWkaXDxxbHlNwcqhQnOenH+NZXiC6vdKEw swsQdwRHEWYELgkEHjk5HetIxTRlJp7DbZpL5re5dHjSQYYkYKHHvVi0W6jefTIrlXkudxDzuEUL ndyT0A6Zq1FLYg//1vOGW7eJruOCG2nR/LlCZ8sFeAQx6ggZz/Kn3F7/AGonkK0iJAo82Rl2iQjs D3FfyRJWdj9gGiZjbFLmLzUhOVkIJZFHtVCaayWN50AOzBRNh3c8DikYNNOzMf7Xc3vn+XbpF9mU lfNYIZgMcrzz17VHJcySSx286u/lw5UPlkUEkjH45NTKNwbb3L2x7rTUu5XAMTtEwc4KBTgYHp6V z41G0j1NdPeWOUvGGkReThh29T7VHIyJNpaH/9fwp7eS2kEsQcwR/KsPTI/HvWhei2uH05jDJZQi INdeXh5pD1HyngZzg1/JVOKSP1LmdrGOqW0Uk7jJAkwrOuMDjp/n1qS+NzGVhtHRkLK6zRDhgcZz n2yK1t0NFLWxlJGLeSXzLjfJPJwG469gKvXei3Lra2sgVrZ5BcuFOAvdd47jIHFbRjyic10FSGIz NHcyCBApRmlB8pceuAaoRSWMktzas8VwUykbxsQg5xmtFFszbb3P/9D5ouo0sXhEE3nwrhmjUnNv +P6d6oX2q27lWeSdZ2PkhFUyNwOOn+Ffy4oK2p+ntqKLOmw6Zpy22oSyoblJy8an5/K773Xr1PT2 rmpb9545nNncYSZnN+i/utufuKB+B9aIxtcy3uzWsLqxgsBNLEskcyEJE5ImXvkfyrHt21O5t7yI 74onzulgf5hHuJUEeuMA9a0syS1Hf6PFpghS0+1X1xL5SXKyFVhA5+ZfwasO6nj05ovLiklvLiQK EJMdqicBnYjuM5C9/pWsY8oS/wAj/9H4tkxKsU0kYZATF8y/Kex4/wA9KfbSWwvTGtt54SDdGUyY 4ye2PXiv5o5Xa5+kGXFqunTXFyh83dcXRto7CS3YQtsByc+nHenweILPwtbTQaf4d0i58Q3l6Xju p1eREVVzGSnTI5yevHfqNIJrcDFt7izvIJ9S1Y2tnqvmuHTT4SkUh5289AOgwTxiorS8+zNLIzSy qPnyXJOPQV0QjoBTbVbq5mivDbJbIkgkkEZLrbgN1z19Kctqmo3lxe2gm/sxZSZNlv8A6I2TyXkI yGyR8ue9bRi76gf/0vz/ANUsLG30tL23nhuNPW8KmNpP9Itsc7iOgGcjjvVG5NxqNqUn1S4itvJX yp/N2vaKMEeWT0HSvwCO6P0gztcutQsk8MSw6ourSW2hSw3cllClsjO91I6+Yo/5asoyzDruH1rR sp94a7aNrZ7mNTPamQyRxEKB+Y55FdCTew02mY5v7pWvLC2hYQS7fPlmyXkGdwCN169eeOlV7qzj lhiM9qjytLlZZBvGB0wOnH581tTTWhpKWlkY0kM1rN5LiRY4nO1G+6G9j/nrWTqt2tkIVtViiubl yjvkK49z+J716NA5ptNaH//T/HF5be4ElvJKGvw5E2WI+Xscepya8C+LV/B4bvpTbWjPqNvZRSoW O+OTcM/TIOTt9Metfm1BH2NY/Pv4p+J7DUNIgistGjF01xLBe6gxb7RKZM7WMXRdp79+K+fStzb+ W07pgKMfLlGI9RXrUDxcQvfMWZBeSCLA+dsBV4Br1vR5ZbjRoIruCBpLE+UFgjDAo+FAI79yc+pr vp9Tz660Z65pljpWmaZZWdulnJHLE0TwwxFXt8jJZhjHJ44J5Bq/LFFFYw3C5FvaOY/JTGWOOAw6 9uKl/BI58Pu7n//U/lTstXuLK/0sXKA/YrtJL5Exc2rBT8yq3QrkDkdhXF3FxqniG/l1HUtPtW+y X0lwsduxMVyu4jOwAYUrjI75NfCpP2Fz1t4XPLvG1pox82B457fVd4ljigQRxeWeSH9xkYFcTb3N rbskpUyCJdpTpzjA/pXqUL+zVzmlHQrtDHd6dfyzO8s0Mw+y26AlmVsguO+VweAO4rqfA8kLWFxK WuH+z3Bt5TcfuoosbRkjAJJOQPw610paL1M0rux3t1qcmoRSraFrO4XbHFPGn7kbQAWYepx+tXmS 71We3aSeVHghSKZgNtrJtAA2rj0Hua6oLS4SjbRn/9X+OnWbD+07u3spBbZtLj91LJJ5SL/tFiQC PTNZc0UsTK1oLaazCq8t0cskgzzj0/lXnnQbOn3umRaXe33mIZdNuytxZl1iiAPTA68njI4rOivr zXP3WmRea3KySRuCF7EZ6DFAEqQ2nhm40/Q9X1aK58R3UbXLW0WZY7OMEEl5RkAjcvB68+lWX8SW 09u0IjEsIvmtbm42f6SyoB/qs8de/wBaNgRyFnBq1vbznV2ZLK71VmtJ7ZhLdJbqylV2ZzznkfTm u1l1CC4uXQgfJGqopISSQYwD3pW0szJxaV2f/9b+MuwsJbKa4uhpq3F9JcGCGe5lImQF/mw/uPUc YrsreHXJrTUpktntLLyxG9sHM1s20jLu+OpPIHUV5UdJ2AzLiz0lra0GmxpcaxDOEdC37mGLhSTj PIP8uadBAlxqf2W53WcSgB7lpAYsqMliR2OMcVqBbnisrq0MYu3e3lmXaiSDa5Rs/eHuO1V7+z23 R1NUmv3SKOJ5JpCsqxDjykGSBj+Xes5PWwEv9jaZq2p2eq3ED2iafKsiW0TFEjCrjnuTj8zWfL4j iQqrPcSxPKwtVeArsQdD0yM9eazHHRo//9f+RPS9Sje1S/kfdiHEfmfLJhcgA+nTgV0D/wBh3uhS +I5NStoLyxvLcppm4i/vWWQfKEHPHHOPxFeQ6jhG6V9l+P6LU0c+V/ccj45v9Rl1NNetHle3uTHN coF/fqmADhByT7e1VrD7XYmXX01DyXdl8t2YwSPH3XZ69c59armSsOU3co3P27UNQtHmlgj0aO68 +aO2YRy3BYDezZHDHkA9BinHU5JLo6XaQPHBBmRJlkDIQWICFuOSOfStRTeiNm/gmjkstQnuo5Ig qwQQRkL5TIMFWQdu+e9bB829EUi3aW8IKiVUhR92OoBPI/CqUbq5yy+Jn//Q/kSGoLZTzWhlkuSk ztDeNgIFycBR7e9Y8Uuo305uJZjLZxZdsYWVwpIya86S0dyYfCjSufNNn5mlBJzw4gbq/I3AH1wD WlBcyyGeZLdljhiHmozcoAMdfrWLTQOKZQ/tLS9aWWyuIWtjOhS3kgUsqN0BBP8AX1rVunljjtLY rA9ikIglndR5khHRSMc9Ov4UhpJbDNbSS1kih0uG2t9Nmton8uJRhJSPnwTyee9U45rebzYRIgv4 Yxgv97HT5fpUSkrWOk//0f5JCt5aaOzSIbhvMY7w2/aGJK4z/KsqTfdHTb2/05rNBb7JmglIaTbn Dlc4yeM4x933r580n2OkF2slutpaTTCMx4LQMPMRjwGbOemc44qCPTNTsrqK7uoZYViYeTfSZSe8 JAbcBxg5/CgzMXWjaR3DalLG0d5NNslkWTAuMfcZ19R6+9WdM1+8Hm2c8MUNumGjI5MpI5PPQjj8 61jK7MpvWw+4EjQSSl5NpyFdOHQnjip/CetwuV8MNftZpvDwrdDKu+cO0zDkZ7GrIP/S/lYk0m1v r+GxlvI9ytvV3lWCMKOMgnjmuPnit7e+udyG6jDGBooJhtYqcfKc4zXjnIk1Jtm1BqMVvbIkw8so 2QhTdIM9AcVmXuoPcSLNbI0kznaQVMSpg9aBqNio+n6ndXaF7eP+zYAHkCOWYHGN2Mcc+9TiJLC5 VrTfsZcSQovyA564rGXxMoTzp55/JZRBGW3eYhyPx9DRa2yXb3mnJepFp6ApeSM215PQp6556VNu hM17p//T/lHGmWthpsEnm3NygUlLidt28eg7cVBDdy27rHZXWbGWL5r64xIIZCQCmwAjAyeevHTm vmnCyuc0dkYl1ovizTJbq4nMeo2ESeZAnnxzIFcfLIiD36fhWpp/idr/AEFLKYtaB1a3ngu18qCI k4bB9CR7UKLTRWnU2rjQ7JtNitFsrW7vYykkV9eNny+BgK3QAZ4qrfeabVbO0McxUbbqUdFOMEKe /vWoilbJa2djdyXTNHMjJDFDs2yPzjcvr9K0HliIRBBGEuF8lRJwSwweB3PWgD//1P5Vk1W0XUIL DUoLVmj087IIhtkmwSFeQDv82M98Cm6bb3Fxe3MVnFK0Vgqz3JMR22ySlguDjkcY/Kvnznsc1rRv j4jFgjPBClp5z7hhX/iUj0OB09xV6ynFzY3GnRbIne6FzdOU/eXZ6bR24+lA07E6Sf2fd+W8AmjK 7ZCN2cY4wBW3ptpFdWtwY1AZ+UEv7pV+vc/hQC0dytrFxaJZywC0jdoQNzr87kjqVHv0xXIWV8Yi ssHmrGoESwCIFF9PoK1ktUaydo3P/9X+T7UUS5jhEc0CXG/5wwHmhgM8DuK03uLCW2uS0EbTRW6q ZU+RXYDCjd6j+tfPnHe7ZmW2j30EX2ydyFvMrG/3jtA+6f8AZ96itNOvQyCWU7llJEqgEqpOdo9u KmTsh3Tsbkd3tcRXIhROV39I/wASax8RC/uIY3t54VYYaN9yx9zn160ou0fQ0qr3EP8ALmS7ijt7 qWSKSUvLb/fgU7doweo9eMdKnv7vXVmtra1nihtIhtadfmYfNnAGPr19aqV9zrtaB//W/lb1PUIG ljWMmWeOFXjSR/mYkAMxPbnNWtItrKBzM0Kb3ycqckE9/wAPSvnzaa0G+JJ7NYIGu2L285+eQDDQ MpBUAd8gCsmJZLhorwsrLFKslpEy7lZQP4lPUHng1jGXK9TCFkkmXGNzNN9ouZIbX7PJ5ogRRD5h JztRf84rpLmaC6MN+sAbEQlkVYQp4A++oHXj9arnKe7OWs9Us0vBYCSGN5p2DpKfLVCefm9Oveqk 2i3dteT3ha0uI/nW3CqwKSfw5PRlxnp6UKaW4j//1/5PrCx1Se5sjdJbp5sjPcQo3zN124B7Hitm +1WfT4mubWRo5LBgoEX/ACy7c+g55r5vn1MZ3uWdTuIrqKwMU8FzfzxiZGQjaT1YHHfGfzqKyvUv Uns5rVhC8gTeg3NuAxkAc9zSk7u3QleZ2Op+Mp/CdnNaaTZWN9eXdmixTXa75rRmGGMfowyeDnp0 rjfD8l7Jo+rXt0sct/LcmS3XcZZ3OD8pU8gcdvaqV31C5R/tCU2bWV/a28d7fp5bKflK8/MBnnpw R71Uvd0LW9vDDG6wBYUjV8RsDheCPQcinKNxpXZ//9D+Usiwt/t9jdRlbeW1VUJl2wwncMk9jkAj 8aspNb3ZisrG5Me4bC7pkQqOjN6DgV8y4tEaqRae0it7a5eUBblowqyW5xvPQ/jjoaQLbvEizRKH KgwPnZJkg8H86hbsU2tjOe38iEx3CSG3gcy7wM9e2fWn6dfpcyIsMzRWxbEcc3yJkcEnPT6/rWc3 rYzNK/eO2sIreysLW9uY7ppZftc7x21xGw+6Spz19KyIfPNrHONOsNOuGG3yrIv5Z5+6GZiT9eM4 pOTtZGn2z//R/lkudIjtpLZ47nz2mt1nvGhTDxk5+Rs9cCqtla2p/thrLy7yC5tgQJwVe3lRwQTg 4Gfun618he6E0lOyNNZp44Y7mPNvIEAcH7qnuR/SiVjeqWnlKTOuxZQRuAxwRQ3d3NrRTuys1tpu m2MrT6hcP5zAT7odxTPBKBckk/Sr+n3lh4VS20yL7fKmozvc2srwZ8rOCRkcgZOcmrV2mhOzLzXs 91qkmyKzgaRFluL+9nELSRg42p6tznrWTfFtZvrzN8YvsUqmNkZd05XAOB3BwefenBWuU9Is/9L+ W+R0aKPzoVj2Phyv8f1rWIsI7dVK2t4l1FnYzbnt8HABHY5Gea+Vj1LpWSsUo7qK2jlil8zaimRE iTzDkdgKviG6lha5gDS2TKu5SNrxk+o9P8Koc97FKG/gLXttIkcUljCJyCuPOVjjOenXP5Go/Na7 LRFWZVUP90gR56f1rFJxnJIxSSjJE1rem2k8oq7eX+7G9QfzFRTJPa29ugvZFhvbwohaP5FJOQo9 wOOfShboypw966P/0/5j7mebS7KRbFYb6TzFeG7nYwXUG05ymOnXv6dah1a5t9VZdRmuLiKYwqL6 SNQC+3gc9+/518ctgMS68RSW1heXcGgzbVtvJjkmR45HOcbwPTnPp+VW9GkuXXzXBO5Bl5AAWOM8 flTsNLqXpL7XNQkW30e20cw2LMLyLW4Wj+0HgDZ3Ix6Ve1D/AEiK3s7i3s7aRVHmQaed1qMcHa3X 8DQKdo7Gba6WkE8RD7YkkynfYD1x+f61oy2kkMz7BGbWN9wkQ5BzzVRVoF0fhsf/1P5epNVnF/DG sSXCwyb/AC2JAZenGOc8iusudRxDLFbs9sbqAJJGp5AbGVPtxXyyiuR3N6P8OS8xt1bPJYqtusUd ysQChvkTjviuct9Q8R2UyWt1OosJAVu4QhdkxypUYHH1rGO6DGy5GrFu+mNvJZRWV3Lm9lKtapH+ 6YqMhmOOozV8Pe21gzx2v226QYvFhb5VJ43H6cfpXVNWZz0YvlRBp9vqLFJr+R2tpAZIiw2wyKxP y++MYrbkVJCrpctGltF5cSKQsEQHPA7Vz6a38zSS94//1f5ppbh2ljgt44Z3mG2S4Ur8mAeT+WPx pXItbJ5JJNxRt/yex6Yr480UFbUozXcjW8VwrSIwBmBQZUqBjBP49OvH1qXTtW0iXRr2PUNOM7Sz 5eS5AMaonfaeuev5Um7K4ezZe/te1lsSxtjFahd0DSqFU45XH6VmWOqWd/BN9mmZLsM9s84AWSFD gMqHrzjr06dajnM2raHRXmqzHTPJsYCPsIO268nyrq7fGMu34YHamyXl5qujw2l4FM8Z84yn7xyo GD/PjvUX1dhJWVj/1v5oJdQ1Oyt1g0uBZnB8lpJJPLwuMEg96yZtI1HW9SAljlaCG082Rosyx7lY H5z2AGP1r4uT9+5zx+I6YanBs1BNRt44ILGzBi+fEVwQAC+Ovy8nA9DxipdCaKdzIWkUpB8sIOEU N0P6U4yvudUXZmpK8zzr5MzpFGCMKMAk5prWd7pukxPdZlju9/lzPtHm7WwxwOmOBRGTejOqm+hj aWk9kl1AqiSCY77RgSDEWx+HHQVpM7QRPESwuzGHUYyrD1z+NHOr2ND/1/51bGae5td21QqHZ1G/ IHPFNt5tK1uyvnkvnsZ9PuRbxwyRFHuzkhsD0GBz718Q3d3PQOdnht4ZC6tcycbBAU2w5z98HGSe 2M4q7K4t4lvLnMcK7UWNV3FyTtGR9SKXqBUj1Bm+1TWluJS5ERik+WOPkEsPfH8q31uAxie7jMts E/ebT8y4GBQYy+JlJrkTRoYyIcN/o8cYHlzYP3WP0P6VNDO8RMFzHGrueVU71j9s/lQSf//Q/m8l guN0pRleNBw33Q3bGPyqWK5KfZ4JyqZbdGxIBBPUA/hXw6V9EdkGktS7e3dvOBFBAJ4lAjnSH942 7pkgc1ghJYJZUCsFIxEiqdw453elNqzsW7dS/ayKrWxeWEXSgrGrxgsw/H6D8q0Q0koIQfv2flic LjnOaQK3QdcwS21i0txKr/PkL3XPp+VSy6jd6hbC3uFQfuxGoRdoYAYBPvT5WPY//9H+bqDT5PN8 qSUIE4ij/vc9AP1/Ct6b7HpqRos0jM6BmbYQA2BlfwPFfEyXKzubWxnNc2c8hwgkxhZFHLKT3P1r Rjngj+yRRRs1vA53eVHuEe7jP6AVINK1mWrWbytkmrXhImldLaKGPAUZJUN6ccZ9qzZppvtaiUqs DSYQRtkH0zQRO26JktfNkckxxBMsS7Y3Adh6mlgubNvtdmYRLNABM0mw5dTkBc9McUEH/9L+dCxl hmmuLRLNU82BiblmBSJVI+QZPBqwmm28CybJXeabCsYmHlhB2J+v86+HOpJcrYRJFFI0hkB8pSFL HhfWkVGuIlZmzzmOQPkj3NBJEIbqRJI4ZWecHfF5n+qz2z7VoeZJay2txewvI06+VcpG27ZgclSf rx+FBcFqQWmsok7WtvI09rbAqJ5crMvX5SP84xWomtwrC8iAMSucMMEGs5rqa2P/0/59bnVLm9sr aFpJWgDiVIFJWMEHOT+Wahu0huNpe3jaYL8sjL8yfQ1+fnoGfGoiiez8iFlkcOZSMtGc+nvnn6UX Onz2dwzWd8txCrb0kHGVI+6R2PtRboBc024nmgu4pUMDSHd9wEI3cg++BTbqOOa18t8yQj5Jgy5R 6ylG2qHfSwlnd/Z3hggaOBgnlxKqAB1HRT/SthYZQskrsmYo/MyzBQ/sPfnpUFc+lj//1P59bJRd S3t4AsPkQYlzyFXdwB9SapG+l06WGeBTudzG0qLudN2Rx6fX2r875NEeopvqSW6bFmuVBlY9Y2HT 1OfetvTrS3mt1uD58txvckO+PLzjaoHTjmplGxaaexrzjFrGJbeSdIVyYl++4z93+f51kyag92Co tprOCCXbDbvllBAGSD3B9a1jsim29yxb2zXTidrqOEW43F5gczY/gBHf/Cn3k4h2tHCZ93UDp9aY Xd7n/9X8DoLqaO5CSDZC0e5nI+UU20EtzPNN5A2oc4AymB3z+VfnXI7nst31Yr6rKitaw7YlaTy5 TKxTylzzt+v5c1pKVtlgSGaS5huJQDcud6jr8xx/nmnGHcm6SuO1C7Rop7UkuwB/0kqRvznBGap6 LdfZ2H2chpIVyZJCNwI71bSZlKWuhZur/wA1mjZBG5yTLjIaix1CztIJ4ZwNzkBZAhLD8fyqHT7E n//W/Bd72YRsNqyFn4j3YV1B4yexqlqs8MF3DJbSTW6tFuubRQJICcf3jyOx61+cNNaHrR+FFlL6 BbJHlnGETbuYdD2HvTl1G5nSK3gCLExITdhASe5J47d6G76Fp8ruRJc3CwyeekZKOU8tJQ+Md/pV 6z1CKfyba7crAsm7y2+6SeD9M0ilL3rstRFrC/nk01jbWl2v76NWJSQen5gflRf310fJdI/NiZyk gAyRgcYrSMklZmvof//X/Bb7ZKG+RFw7cqfk2j602W9uEmI8wLBDKDtGJPNGBuwe3Ofyr8/PfbUS 410txZzSxxgRtLtE7KRux95cdKsQSW93FNKkRltFUMEjG5oguOv4j9aiaugi7opjU4pXETQyIAuU cr8q89P8+la+jSGaaW3WSN5HcJHDkBzn/wCuTWLV1YpaO5a1hVjkSyU+XeQyK7DblW55Q/l+FJqs Ue6KG3YrI0CtlyMqxHI/P+VYG6fY/9D8JHtr6FYg6JI6HO+BvM46c1YhurhJ3jiwcJtnUHt1xX5Q 1Z2PqDrdPuw1uyROInBG9ccOO9U725ibzUmSJ1xtjmVcOCTzz6dKE+UDKms3VUdYw/mcKT0UetWY bTyYZjs3SKmVBOfyrRTXUDatrex2MZWZn8kFNoywbgkAfmKq6lrjC2h0yCyghhyFnnhh23bAHP7z ueaswluz/9H8VbCWO3bynBEsyALKy4yPQ1ryXaiG7sbhl/dqJkkQqzow+7tH4/5xX5e0noz6KOj1 MRJGvyJLlHjuO0ZIIf3Puf60qO7T7VjBeA5TIwp/p2rna6MT3LTXc0d0gIVk6sDwgHTFb7wX2qSw +RJDFbp0VOSeP0xUOCEYKyS2+oFL0F0jH7qRHwd/I59ulXb3Ulgtkt2fYgnE27IV1Oe3sen4UvZl xk1oz//S/G658s30F1LOiWkkPFtGoIV+7HuM8ZpLyxhv3iRJ38tfnJifCvkYwa/H7dD6daonjgtr fbAj+WqDG3PDY7Gsaa5tvtCyNGsDiPymaIYDgHPNAzSguL50me1dbdFUBNh+Zxxk4963NQRLrTER WlgnGJJGjOfNH90+g+lFi4PocxZRgHzZHfM3H7wnKgdOO1bEjSWwjkhUuj/KWPWg1R//0/xvGp27 XZjZmZyQpVxsGcZwPXpV0vLM7CEDbHwSR9wV+Pn2BoTWizQRm4ZHwMoGPyg+3+e1YEa3Mkn2MyxR xXcnljDgscd+uehNVDewGfbW39mr5MWG2THMczFymD0BOeK1mmllnDxxxqrrtkPTaQMA1sRKN9Te sY1t9PljvWFxE0pkkldwJWySdo7Y/CuOt2kt77UxptvEtlPkxB3LTRknOf8A69aU+plbW5//1Px0 tUMqrHe2kV0UIYRSDegb1H61rHTZ72ZVuGis4CuN8RGUQDoMdDX5efUFpJLGWFrOCNluLZdsbyMS 04HfNY0cyMTb6jG1uyMV+0Q4kI9x0rHld7Gcm72Re+0Q3UYdCZD92N3G04Ht2+lSKmUbCDzNpTkf IPrVSjaOg38BjXFnFYr50IaSWX5QitwfXB/GnyWzz6WT5dzFceftWQnYCmOeMc81mQ/hR//V/G/T rR1kKLHlNpDSMdoBFUPtUUryrOxWAkwbM8S5OMD3r8nPoDZWOS4EdvGCgjUIqbtqbR0zVTy5Pt1p alCcszXGwZiiUD+99cUAafnXEchtkmwOgZOvPrTLyF2dI5Jg+FG4M/ykelAm7OxaufmtllR0XyVx vz0HtUVhHb3c3n3LSHYnyvEApBA+Xn8qBcyvY//W/IO3sbu7mLAjKscg87vTFWreK/gLy7GRPN8t y+MDae1fk59CnZkWu3eoXsls8cEErWyhEmZ9koA/hHt3z6gU3yYJbeZ2so4dXuMPL5ZLIAP61rLd C3Ldv9nuY4tNgma2uY1Ek3TzGwckAEdOMH61FLKGlQXEPELbUUJuRyD94nHWuZr3zveiHrPCksnl +VBvGSm7BPHpWzpt2kMR8iYI7hhOwUNsHTofX2rSwoP3T//X/IaXUFImDys0cc3HH3snHT8qimsX mnS8i1SRraVBHLYyoBEh6bg2eK/Ins/67H0blapd9v1L0LQafNbpbpE8sTgGFjtRh1IP4fzrWuLa z1SSaWK38m2xgQA7wD35PvUHPHZmFFeamZJII3e1trKfy1V4xm4UDHX09K6aDVnSHYh3s6ndESdr 9aPI1obNv+tGO0TU4J9Hk0TUNNtbfVLm+K2urrO7mKPOQpUjavu3v9KbLLf6TfLo0/nJCr+ZIF+a FzjhgehzxyO1FtAhFbs//9D8uLjVw8jLLABKYjGkiYBGBgZ/wqr9pnj0gWilormHlbxRgnPXI9/6 1+MuOh9MopO4wQ32pPBaKiW0EMYkuZzIAJSc/Lj24PFOg0XzYWt08iRxKWLk5cD1YUmtDWGhrXlw llPZ2EqQRRSIIlm4RdwHH8qgvLqK1U2UbB2L7mZPmUj+8D0NZSjZadDUnknsLdbO/ne8n+yqYxZo mYZQe5I5GD6etXtPvY001riLU0s2nZ4UikjcTMDz0xjr2J5xWTQmj//R/M201W1hvYru6X+0JVH2 bzCCTGTgBj6YwDiun1fWnv7mzWLOoKkYLvP+7isABj5evOTgAda/DeXc+qne5n6lbC0V7lnS4M6j ZGCrBCeWOaz9O1q4SORoLeEzW1wFdJ18yOXgEAj3FZNWdiGrqxPLZ313qDvp9jY2Ut+VkuGMhihi AG5yoPXjOFz3q5d3FnYpbwXwE3z+akUefNbb1Jx29zxXPJWdgTk3oWbO+iuLWaaIPbi6+Xy4mLCR VbhSc8YI7+lTWb6rd+ILWJfIisLqJYpM3AtraAxjarOncnuepyTWfLaT00KcZX0Vz//S+BY7e4tL q5eaeJgZm2+X/qwO2KrwCKBr66v7m4kmkvVuYLqE7WiAI4Jz7Dkc1/PDVj7ClH3WpCLBqGsX8rx6 jc3hVGvXMsvmOEUfdBParfkzNHHMqmL7K3nTgjDsmQMH05I/OokuprKOjtudEJIb+2ea2jTylTy3 QPvb3yCaSG6i0WyhMOyAyTlHWWRWEhfhdkZGfX1/Cona+g6UJcmo8yp9lT7NI7MVxIzoEIJ6gY6j 3q5YxaNb6bfXV9+6vIoQbZo2LIxLDIIA9M1lZaIbuf/T+RNLmTaWUquQD8/APvWxqFjdJMRKsaGM hfskHOVYA72J7j29a/me1j7uKe5jz+IbrTwtsyGSRDtMxYhkQcKMeg6VPbHTriSHWraK8j1Fozay 2sMrSxXYHzLJjoGzkYHtntUSiraFU00tTVtdRg1CxgdrL7PfQ7yy3JMYc843enH86bp97CoQl1kB BKhDuQH0/SsZw3RrCTtFMtz3sm6N4rO2aRCdsjod5DYyNwOew49qzxL59y8vmIkqN+9iUc/SspR5 WaRdz//U8DtZoDaNhWWbdhgeFI/z/KoyYFguPOuJLd5EKQmFA5z7/p6/jX8pODvofpqqJxSfQdFc N9mji+0Fo4lw24hXY+uPwpbZYFifYyyl3z5xbeyEdv1xWM4NsamnoaFrdS28s3lQ2+65iFs8joAV UHqD6/X1NTzteCFTbqpmHyqpOxWz6n8alQdtSm+pbe5tbDy7QSrNLIv+kSxKHWEnkgGopLSGe2f7 QQ0T/PuztbA569qUk+Zeg01Y/9XyO11SzMZghhQSjhJA+87fb34pi+IJ4Lp4hBJL5G1yTHthwxIA 3fga/kikrNo/VarvI147qa+VnliAhA3YBwrewpx1PcggiSMZJQqGzLF6EjvSqxu7ImCd7lSKKJYp WlVZrgYBlZcSRgHPHpmpoYEKyyRxlZBFlGUDr7/rWU/iLpq11/W5Z01WjhmSeICW5lBco24yY4+Y /wCelXMpDeW80bbooG2XVsDt3DHSoqq9zeMbOzP/1uXeYsZWt4cZTO0NgsBk4NYdlqTz3H2Z4Siv kM7j92vbGfWv4+jFudz9dbimaEKxaYZriFYy0pEUjvjcfp+Xapmu7U31vHaytEXQSTzSDhH9Afat VC/xFtpLcr3E8tzMyv5kqOT5kxbLv75q/CywbHi/eSKuQH5/OrUUtjNNO5R+3GODUr+4kmtXto3c W6Jg3e0ZwvPvUFoby8tYLlUKSzwiUwY+7uGcHuCKproNyu7H/9fjGCXMSwBEkdB/pcdxgKAD1Xrn oOvpW5NbWb2ccmwGCSJX2SfKYyO+O3Qnn1r+SEj9eirIzrtyjr/Zlw1put1DumGExHXIrMn1CYx7 ECJcY5Ut9/HU0vJG0otJFaW68t42N00cxH7xvQ9K1biS3SOzLMruzLDMjsE8wscbwPYdqa1RrGm7 vsRXckayyWIfbgcTRYIxVV7eGCQNbuDvXa395sd/xpXSiYunbU//0PLZJ/JPnRWizs7G2d5BtMQz g7foRVyW9EMqRNO0xiVS0cbkGDPIGf8AD3r+R/I/YoRUbIs3U9zJO94ksjxTYNuvRkUcAHvnikh1 RkV0v4xMzfJE0mcxfT9evrQXN20J5Li7aFZrRngffgPGQGjx3FQXNxe3tvNBcvBLdkBhII1YqE+Y 4brnGc1cHZ2M1bqaVukcelxySTRyzv8ALDHAc+Sg6Fx2PtXLzB0lacqzTgGNJUHzEZB2/TitRH// 0fLJYbt5Ckl2HiZFaWFHV0Q9e3f602e4e0s4PtcyfYftB+z5xHyMEjPU9q/k+ye5+wEsN4WikuIy PssnC5IINV0tB5xM0zxW9zFho43UbxnIOD3GP1pcqTImr6oSDT7eJ3lnnf7P5jJA+BvOBnGM/TNZ U1wn+kzQwmaQR+Smei4PB5+pH40nFMHBW0I4wY1uI7gtvMH7hY2V4ixwcvz0AzwOc1iHSpDsgW0R r0/6TBcvJscKM8qffBpezRk1pY//0vAl1X7K8enzRvLIU3yvtJVVzjOfqKLmWZL1ommE6mNfLZX8 xMbQVAPsCB7V/KdOKSufqsYW3K/2OWdJVmlMLDJVByE9D700vcxrtSVXhSPG9sB2Ix3rSxdtbl61 trXU4HZVjj1O2jzFIJQonJYfLz3HtVGS61Q7YNQkVDG5TfuyAB0O7vjFaRh1ZzmZJeSsWhtys24f vCx3EgdTWe95Dp1zHDZ2sS+dDvuS0WWcE4LA9Ac56c1oZc7P/9P5ZlngdI4IPlUtuZMZ89vQ/TsK LOXTpjLe3LJaz2zrYu8XzOshH3cdenU+9fy+fo8pO1ypM9jc3At9iIN48+7EZDRrjH4/Sq7Rw6Xf 30NhPPqGmzxFIYZ2xGjMvLfgT+lBEG7My41la3gS7kJlgJVSBtQAsTgfnT5NYsdI85maa8Ij4SAF i54+XHOOtWmrr+u4lKyKV9c35uLGKPS47bT9Tie6fU4mE09u0RAEOzoN2Tk8fd9way7m8v8A+0rZ kbfawELAZGw6SZ/u9MH610QSbJlJs//U+OZWkv7OPT769t7S70+R7i7LSKst4zkAbQPwyR71zk06 R20llDKI7NZSsl5bOFYsnIVZOvOD3r+bz9Bbb3IJro215bXNumRhJIWiXzWWT1Ppzg4NWrPUbW41 h1n+yQ3IQu5mhLwqSMEvwRyeo7elaxilqNTZSuIJtQtru1S2sobW1JvlkOyDz2yAQGPXnBx7mueg milzbSY85/kmt0bJQDv9Pf2rogla4+eSYt3OdKuU09oHms7qPzoruFGa3VVHKu/QNk9KrXN59lju v7HvZbZZ4xMdLV/9HuWHCmRT3681Y+c//9X8849VRdGC6haWscTuXvBCxlncY7L3H4duprNivLF7 S4iSG8vJIY826yR+WVXJITBwPQflX4DD4j9INGA6ReWFu0bpZ6qvy3WnsN8q84jcgcDdgjk/w9Kh 1G6+x2wYxFZLc/vgq/My+pFbptbAZdxeiYCU+WI2A+WJdpAOP5f0rF1N282BLR5CsfyxZJXI78Zr opu7QFSeSTY81zchG8xVih2tvbjrnGO31rInFjN5nmQ/6auXExcbMe2a9Oj0+Rz37n//1vxn16x8 2xg1Wykj8q3nzdSxczgAHjA684r43+OOsatqsttc20N3ZWbxi3nW6KyOwiUIJBt6bgB15G6vzmit Ln2NY+Itf066na8ns7losESNIzKNwUjIIOeTg8dea8z1SQ+SkMjLuWTcSw2tnp/U16dFWZ5NdXuY ymOCZ3iTOUxG4+YAnuK9H8OWNxfWrmzuBbX+1SUL7HuM9Qv5AfSu+mjz6qTidHZ3F1ZQj7NJdTXa XOZvkM3lcgBQB9D2r0q1jinHm3U8sbu6lVVcgsCD8wpyXuNI5aUeW5//1/5KbLVhe2t7p5hkgimj a1c3MbQzoc87QeoIxhh1zVm3a20/Rvs8vmz6tMxs7C1t0O6QA4TAHqMV8XGP7txR6q+A8G8eWFl4 cv5b+4muhqeo2ytcaZNN5z2km5/k29ULZ34boCOK4vyzFckIxaVo1mkK8hd4DbAPYfqK9KmmopGR oW+o2kIjdQTgiRZXUxSI+OcjqMc9a7bT79ZreG1uJ7P+x7uUXOorG6NcEqflJA+YkHsf/r11RXum D+JnYWMtqxt9UsbmG+01hJDd6dzBJAY2GGZsYw2cAgnkH0ql/bVxqWp6sbRo4Y4CoaK0ZPKg4HCj r169f510JWVipO7P/9D+ONbOK785Li4M0ka+ZLEfuBTnl29eOlMtGs7a0isI7kIq5L28y/KsYJ2j Ocfn6VwaWOi6GXIt7+OZoYbLZcoIpMRhVkCY4P4iqmo3Gkafokml6ZbnTL2Wbck2nxSM0jMw3EYO M8frSM+fsXvG2m6FaNpuo6TJetIujp9s2xGYzysAWGe2W7Z45qnaS6SkFjJPYNYW93Dut4ozv2y4 +djnJB3ZJHvQUneWnY6CW1t5bK2ltIJJL5pdrzlxGoQDALDp1/nXKaeot7jU7jU0S7ulYxRvGxeV PmB+XsenbPWgzl8R/9H+Pe1eP7RA8znym+Vh1d/ZfetTWHlGmgJNJBbRzCaKJCVNwCMNuHoMc/Sv LStMTV1YxtIMLTwrBYwWOYywaNv319n78h+vHTirl1NZNqmmxNCNhmK3IlBTeg649T/jWhSTexzM GnjUpbpLO7ihht3aV1jkWPaQ33QPXjp7V0Fpq8elwSmaKe8lb5AWQztJu4+Ydh3JHSs5rqJaEFpe 3c+oIiRbImz5pzkLx3rZaC3tJZLto4r37UhsTFKoP9ng8+evI6E++PSsxrRn/9L+OS8lTTtNgms4 Z9Rt4bjZPNaHzZ7pWbG4L6qSOnb6Gu11nw3CrWT+XAols4rweQ4ONyhhu/2l6exzXkWdrldbkCmZ Lm3UqGltGV1yNyH0yfyrpbiyVtPiDJaS4uTOWUAzR5AAH0z+XNIT3OUa50jT7lk1SyTy5x5ULBG2 IxPXC9D9aNZ0DTZ7W3urG+uNMlguVuPMgKhLlR/ARjvk1rC9in8KZBPcJcQIltaNdyxje6Bt7gKD ubHbHJqBLRZbe9VL24EMsSGNosoUPBZAe3cE+1dENI6mXLE//9P+O37YHO2yiQWtrCkTDJfLAgMS fpz+Fb0cbtZyWDqilyWFyhKySI3IXrjj1Fee9QSsrElsY4ZIbABIkVsJyQ5Y/wCNasfmI81tGm5J htcZwH+tZzWgFe5h0q0WEW8BjljjAuhj92p7bfw/lT9Rv9O1K3tLTT3kgkEWX8yLktjBCnHSs3sA /bJpunQRP5F2Xt/JtmlO90I4yT/CRiuf0q1liu5ZtZENxes2Eltz+4iHog78YrBprRmsZaWZ/9T+ SNdUeW8uLWZGttPtLXzGkkjIWVueAfXvjtii38QxpMlu0Ns9gRtSe4VZknZvlMfqo6cn1r58cndl iyitY5b/AFK1eOwSxjLvaxkz2zNuG1mByR147c1pzasmpQWs93dvPPCQrNJnzCB1+X0PPFNK7sYu V00c5qUumapeNeWaMscX7lklBUblOCQp6U+LR7G4iFxJdPC80wiO5h5Y9CK0jGzHJNyOk8k2VrDa XL2soOVSWFlkDKDxk9j0rnLbR4bTUdQuvtMQsLi4Qr5qBrxTnGwc/d71YnBo/9X+S+41ey05LxpI bm5R51t1m8h5rlc4wAB26ZIrLgOnxakuk20a2ZWD+0HeQFGkDnnGfTt9a8cwSu7I6r7NoFyYY7W/ ml8+I+ZcOojMcgz/AAHsOMkHvWbLdf2fE6siXsjP5SyNJsK88sMdcDnvQK1tClb+IJ7bTNRvo58Q JL5EwQbmZCcY29T8w4PvVdZRcLFfyXUlhMkmwWip5j3ynP5dsjjrWMviYE1/e201rPFarOssY/es 0ezcMZz69qm022hNv5q2cNzOsQbbKxGen4/hUkT2sf/W/kzl1hnW4jvf9FsLCEFw8oQxsxCqqRnq OeSOg/Cont/O01lhjxbREzyG1TAnJ7DHXPrXz5yw+EsRtbQ2sQWVmiiVY2R5CsqnGMYPNLa6Rb3b zFtksTrtMFwA0QJ6HHr6VMtEUalrBNp9lcW+p6ik5XP2V3IXfk8IMegyPwqKzhZY47e3jKsH4UAs pyT/AI01sVFXdiaeSx4N3LvlilEPmsAEjPTH51kanb39tqclrHqFndtaxrOGg+4VfGNuepHIP0NM TVnY/9f+Ua+srJLqLxG13IrzQR2c8GP9J6Lk4x7fjn2rd17X7nT7lp7HUfsmn39mllcwzBUkuvu4 H1+UfrXz5jKNnYwpNW0O3iZJ4Hu7yeHyYbkMECMRnLcevpijT4Y7SzF3P5DTCNmaaN/3UA68Z9B6 1Si2C0iyC2V3M063hlmvI82pjAkiSMYxnjgknoc1rwEpEltcTrHLI2wP90AnpmiUeUViWXTvtDtE jxjav76dWBdccbh61nXiWy5Fi6B7SQFlkXaLrPBz/Orn0ZdS1uU//9D+SzUWae9s7uKC3iVGY3DA kSONuMen/wCquk1FtOuvDkdndwABZluYpICVyCBw+PoK+fPPh8Uiqt3qBjjSJY5Y3QJAzyERqB1B wDgY6Vou6SKlr5jwXaRLKyxjcjLnDDcRUT2KWlmUtZOhx6Hdy313cw38MqJa20Vv5v2jd1H+fWuY 0m++wWkkd/YW9vLcS/aIPJYyFIW+6GA5DdzUrSDNpu8Dq9MmitmZjGsjN8wIOcqf5dainZPOiQSK iTMdq5xznpnsauL0OxNcup//0f5SHtrKa/S/llkMUCCJ4lx8hAC5BHqeaswyx2dyESa4cMdyjy/M UKx6HA4B9/zr556rQubvsR+KBZ3yRNFDcR2lq/3JG3ozkZ3EAfl6UmnapbtHHaI9xJPBHsjM0BTG OmD6Vg4taJkp2IjZi4E15NqEU15HdKsNlP8AKyptJ3g98EY9aurcSQ4hRjFITmdo23qx6de/19qS VlYluxV1S30e00y/iGl2Gs6pqsCylg7LJAQwwGkHAbAAx711FnJ5draPdhIreSyDTRq3m7XCgbQe xyDzSafRhdbH/9L+VF9ObV9VSS1+1M8Cq6yK22FVHy7c+2O9V7iIm2u0jUSR+b5F3sG4yDOCpI9c fpXyyTW5nMls9Q8MW8d1Nc2zWE1k8UNpCsG4TZAXhuuAOOBVeLUbLTbkfvZQ95cNJYiNDKJGPJXA 6DFUk3oiZWS0I9TW2udUVtSluYp41W9t4okIjl2/Lhj0AOen6Vo6PGL3XpL2wM1tB5QUWyy4t1IO dxz3HPNXG97EnS6nZWrPJ9qsrZpjFuttQRt1yh77e2Djn61ywNol0iXltcGMrugkhTKo4zgn8a0G t7H/0/5i/CGg6X45t7zRbia2t5oUMv8ApJ2lyGG0Hvk9vpWRrnhe20DWLvTbSezkt/s6q8jXQBDH O8MxOAuemTxzXzk9gsJ4dls5L+S1m+yXHkjyMNMstqAuRlSDtPT7wPP5Va8RWmmag00tjGkARwYH RsCFl4I+h5496w2kYNWdjFvHhdfsUsnlzLEsgDDb5g4BPv8A/XrL1Gw2RwRwCJGk/dtKTyinBOD7 1nL4mDViaK02W6WtwGcI5WMxyHHU4z7c9Kd5V3bOixiN44mMhDgySIP9kVNuhdvfP//U/lesdSFm k2o3EySxpeCGb7SgVIvMztBH506Y21ikN7YWP7qZpFvTG7Frl3y0bFPQc18eK3vGO1zJqa+TqBe3 t7UGYCNyqZByMkH9K6K5hD2lupUfNENhXgFSOP0oGZuo/Z3ezKW8wljITbbHO0AfeOevSumiuo9U 0+W/v7mONtIsvsoDEecY84AC9SefritYAZUqQT28crqTAyBQJk2bgPUH6VGLaxllMtt/o0zgJ+6X 5VVe3PY81a1K5nax/9X+XuC2leGSd/Kmt4m2fvGCsW/3euPeudFnBaXsj28gJuTvZM7iD9a+XFSd jqlt4lsZZJCDdFAqsOmPWsPS59TXXmuLq+lnsDaiCWy3iJdowAyqB14Az7d6hvdFN3dye4+wTvdR PbG0jb9wZ1OXdRyh/M/hTNTvPLhlFnLIbgRqWUNw4X7v5YGKp2tqS9mamnW9vfxC6l3RzWihnMxM bSEgAkDOCP8ACnWmq6Ys98uqPexwQ7YNPxZNJBcTs6hTu7DGRkeoqYJOLuKlbmsf/9b+YDxBe21s n2dIGmmu4fkgiVtxxhck9q0LPSJXjEN/qEAlW0WaCz8n7ufmAJHXOR1/Gvj0raFpK6LF3qN2FEF1 EiTJAYI/KXMbRgYA6Y6HpVLTrizJtYpxdCGCUkw20e+IZHVj26e3QUDsuVsl1aeJbe1ube7Fu/2s JLFFF50+wAZOMcDnr2xWjc6OLaOTULX/AEieSON5EZ8cMBhsduD/ACppbmU1e6RzF1ePaJPayqZz KmYkgUyTLuPAAUnp3z79Kux/bYtPht1nUWfmBXgZh8px1Pvj+tVHWLiELqJ//9f+ZOTQrOK6tbuS 3lgmjTfBJLlfNJHO0dx/jVmxaIyTPe2yRxpOBHMX+aYcD8Oa+ZhacJdDam0oNdS3Lfx3N8tuTHBD GmDLvw2c9/w/lXMXFxHc3hkhvpHjUlFdj8rKvy/kPasbKMkkY5lJS/h+Rr20LCKG6tJxMGBMVxgB InHTnpUmkyyWmoyXDzyL9oQxXdurDypgcg5FaTe7NKceVWI9cgvryFpoRLc2cDgx2wbbHDg8Y7Dn rS2CSS6a6yXAW5ZyWtgCQOwx61hcq3vn/9D+Xs/aJGFlFA08cxaOe9MvlGAjgDbxnJ7itSCzvra2 soyI7mQny5I1Yndjvjr6frXx50Gs06lI0az2xOfLk2n5I/pnmo5raK4LxxRIyhNhjf5UxxWc+xKd 20MWBBbtaTCNog26OJxlAfYGqsUUdtdQfZ4o45I3LKhhWQPnrwQR+FRaxk1Zs3dTW81OG8a+luEk mjAQ2xFvKCAANuMY4HbHWqWlwz2kC3UodA2PNtZZRK0eAAM896Qj/9H+bF5ILkxLG/lru4RV/Slv IZ4n8jTr9tPWdQt4RzJKhADAfX3r4ebaqWMlG0ilf6BJNaPcXJZtOinS1Lsm4ylhlcjv0/A1sabb R2sMkMDq0csflK2drKOMfQ9KDWwfZ5I4JTb3Ek0y8LDIwAJX3A7+pzWqrXE1tEuounlwoF8sv8ke 49Fz6k9q0prU3g2kmUWntrJriJypiiTeXY48juOfTFZ7XG5jOskbbkwm44GO1JL3zZTT3P/S/nGh mlt7UKFWOa4CSv8AxCM4G4A/p+FVLjULC0ElzPAZGAA/dLukYg+g/Gvi3H3jq15nYjuXOosPsBZL ZYVkWSQYlVyORt9AahTVZWSS3mjinihYIznkkg85HTjFVKNzSKa3Ni3bT44fN8oqLhsAIMDdg/4V LaXSoZ4tiPlT94blGeKmUUloZyVmZyPZyoLa2SMBHO/DbhEQc8en07V0Gm6bazXW1tss0hGHLgLk Dg+lEYJq7JP/0/5xNZM9rqX2KOOL5X2ygyeWqg9GptpdaXIki6my2txE4EazLvjm5wNp6CvjYx5T pszWaLToplubGM2k0gBmmhXaGx05/wAfU0oeFxMwffcEbfNYfvGA/wAaHFMRgxQx3V4sQxE0bbgS fmAHp/ntXS3Ucemxx3SOtw0j7ZYAOYwBwfxpKCuXC9zHj1jT72RReQ3sJjnZREsBkikC9Dk8YPvU 8Nzb3EsjKjQqMrCzLgSkfw47GrHM/9T+ceKW3N3ja5mIOCB8qkVFazx6jfyWzPuFuf3isCuwZ6/p XxzSejOi3Q6JYbDT7v8A0NYBNLjc7KGjOMAbs1m6JNeWKajDfRwrHLcyMrRvuMke7K8evsKlw1uj VxfLYhlvPNnePavkBflbq5PYn0rBtZrq8uyqwvDb290YxJKCjSbT8zKPT0NDguhDi1udPcNE4QSl WSOQMVQ/vTj2qnPILfcyhlEwAZejMKhxaJP/1f5v44A8kYhcxSFwVeRsRKc/xe1a9jeNp9wGuI7d 1T7ycyRzHp0HWvhzqu+Wxa1P7LfIhgVUTkzxhdqHPYVS09ILOMW5tnNq7YfYcBevP0otYk0LS5it bpD5bTQ7grIpC4HPftTdVvCf38SZWM/KpOFoLhvYwbaSyuVa4t5YmufNMUtqHyI265OBWrHY2aqb V5WklcCRijjC55xik1dWNT//1v57bee0SZ7SF3eSJFL7k2qpPQCql5qAgkeTK78bBldwGOnFfn9r aHdzIzdLnUmVZ/NvY3O+4uYQEkj5xjP8OMgCnXDQwyTtaC5Nov8Aq2uDuuJOOd2PoelA1JPYs2Go pe2M4jF3GYG2So9o8RZD/FkjOM4A9c1diu9sMunQKGt502RiVf3kXup7Ghq6sNu25zpsm0jzZtSv ZZEikBjkETSsoJACjaCTjPWux+0wzQCAsZIpAGV3HlyEHB5Hb6VlyO9iedWuf//X/n/06SO2a7jz iOaDy2Cru83kEA/l1rFnvbgzxW5jQW8UhcHytu/I6Z79B9K/PzvTujs9O1TSJ7P7DJpzR3jtn7X/ AKuMAcbSP1z71AoSyBlRtpVsgAj9KLFJtbFx9Qie13B1WR+CpOTmskapYWkUTXkinz5TCQiGQw+j H/Pai1tAbb3InuEmAt/N/dJKSrp8u4Z4/wAcVfS5EVvkr+7L+TGzD5WI54NBUZO6TP/Q/n+1DU1t rq1Vbdb61DbbkRt8uMc5I/pV7TtVjaGWC1R40ztIY5yOuM1+fnqVOhRuUM11GPJVlKkEkZD9B0/O tK0kkty0EO2SC0QM0Kp8sfTjHYUGZAb5rictIioTnEYGEA+lZ9zdNp6SzWtu05XG9F4bBIDEfTk/ hQAyLURcSbJV2Db8jEY+tWj9naI/vUlyduB8wODzSbS3A//R/ALzJgIUjhJRv3QkUfLFwevoOKtW W+K2YapbQ3lte6g1rbCFhFNHtUNudjyRhug4zX5w3d3PVhsJNZRb440GI5CA0bDaAMjtWvPNZQOI beBTGvyrlskEDHX3x+tIshit7IWVzczkQCCNpC2QXfHRR+NYktqL1PLy9szphHB2nBoAtaBZXWl/ a7SS6F1aAj7EJF3tAgX5huPOM9Parcl08eUAxuOAeoNA+ZpWP//S/n+urmxvJTaC7aO8iKvNCmUO OvXv+Fb2nw26JtdN7Zyp6/pX58tj2PUbrKs8aWdswSKLnEIAwSOeMYq/o0jaVo96ISJ766tTaqJl wqZx85x3OPbrSk7Kw02lZDdPgOzN2ibmXLhOimse5jsmnV7G4dLuK6PmGE4KY2kZPvk/lWJcZdGb 1rLF58Tzlpp+S8jc/nTp4oru7m8iYCfG6Npmxt9h7cVzm0PiP//T/D60hu7a1mhg8uW4dGTL/OAT n0/DpVbTvJRGa7AWY/63aNu4jg4r8slG+qPo5N8xr3sFvH5F3ZXHlxvDho3+Xr60+8mtrG3ga4EW 91DoMgiTPQ0lDual+FVvNNkS2u4woKtLGGwex6d/TijEcHkLsxKww6suYiBgDmq5EBjR2+oteRx2 TJmW4ykjZKoM9ue3A/CtuaFDNcNNcWwupF2mYgESEc8n/PemlZWRjJWZ/9T8WEZJZYVuWUIh/wBZ EAScen1xVW8kgLLJEkmGbazqvOB61+Xn0Fiy6CV4VVvJCx7d7A89eta0FhYtapKl4WudxEkSqAqj oMnrzis5R6oDOiEMN3dC4TePL2Kp7H1P61YW7a0YFXMMZXCFGwhGO5qOV9gKf9qafehUVGkkilKy zJzGBxjH607Up457TLWUMrRSKXklBClAR0/z1FHK0rgf/9X8WpL2C4uGMVqsUXlKI1V2dAcDPJ56 g/nWqZoJLKNbONba4t1zIVJ/e9ulfk59JCT+Eoz39vPGy6hGLa4DqIPsxLebyByMdT6U++s4i8cM x+y7lDEsMMfT86lxTNCeS2FnAjW0ks2AFXjcW46H8qsLf3BghLIIZkfJTGcJ0596FH3bBdIiuZrP cFaX5wR+6TJ5Jq6kyFBA3+rRd+Ou01k007GkZ6WZ/9b8d7W6s21O1JtYpzbSCU+dHuj44wfwzRrk sqXdwumxxW9rORLuhfeTkZKgdsV+QJN7H1zmraDvNeTTonlBjPMSbhguR1/P+tVtLMMUKSy2kS3i ucuOcZ9P8962SUSOd2sSMlhJcme6eQAZOyMDDt789KntNQsllAjslvUcY8ictGh5x2OelMSk0Qzv ZWmozObiee0liQDSpVHk2hBOVQjk9uvPFZV7dR2+pQvaQtAkh3CJgSMehzWlPsSf/9f8e7WaB2kZ 7qKFlUMEZgrnnHH0qxeXyW7JElyJH2ZOz59vBIz2r8v2PpZ6IzNK1Gzt55H1AMZBJmCTH3c9sfQ9 a1bqOw1O7ltrW7k8uZVxdhRGsWcE9c47j8KzUnzESab0K8Uelqpsbe5kdrNtklyRlJck8Ke+P61r fZFa38o3EiRMAsiJJteQfzBrQpv3EitPb2dpcW1vPKyB0Eqo/wA0yp0Dn64P5VVluxcNF9nJkaOT Z5Tt5aAZ7/8A6qwkrOxF9LH/0PyaaATQsltEwkRS0o4WPjuDXLSW9v5Vu4RkllckxGPDRNuwAB69 /wAa/Jz6Au6fAYIpmvZ3muzKUMCD5IgOQSfWst5bgX4nUKkCPsaPk+YvGTn168UASXN3AtyktrAw Ut++H9/PWtV7S31Lyty4hj/eEE4PHY0bE8vvXKrz2V19tsbZJP8ARwFdZlKISRnCnv0qRLtrcYjV oMx+WY42z5vGCG9j1pN2VwUUnc//0fx3tNRe3hnuCZV+yMVaIKfNYjpgd+3NOs9bmMMf2iMSG4bd Mgf5I8/h1GcV+TcyPoLFuORppJZWURpHgKVPGDUsU7LfbVxDztS4c7c8df6VTbe5cNE2advGTNPc RtHfS26llkgTDOP60+3urExS2d4zR3m3zFhIw4yfvHNPkXPZHTJ3jcwJNI2t58sk2FBkUD78w7D/ AArftbO1hsLozTfZLkRBoopELNNuGRyPrmjld+UxhJ25T//S/I/+xYbmAXKzosqYMtv/AAzEHIx7 jFWI9QsXeJo7ZYprZ980RHmW9wQerKenYEV+SyWh70/5jIu9PFncfbZJQRfH7YiLL5ixKxPy4ySA MdDWnHrEUCTQLbrJHNEI1Ykq0XI5GD6ZHNTGLvqKK91o0ylxO6zQW0Mtq9tHGkYJUu6gBgfrgZ9z TLN1XUIJvsMUBiO1lBaWIf72SfyquVFxXLEuXWjONUmud0TFkD+ZZtmCNDjjA4BycfWp9UL3D2qC QyCCPYS/LD8fSplFJaGsWtEz/9P8rAYY7OSGK2aXUWlzFO8hWNVx6d/WljmuLe2WzmKEs257iRQD z15/pX41Pc+piruxtWyQhDdrJB5ETiF9si+ZIcdAvWrb6xoFjY6lPNbvaMbbEb2sImmuZC64VjwQ Dnn0qDoppaJmRcCz1SxjcsWuQyvB5nSPjoatz2drbRwKXV3ESqXccM2ORj60pfCxtRtoSSXtrbWv 2aeDN66b4/L5iiHY59/So4pLe+hhkkiAkjfEkbrhfl4z+NYDajbQ/9T8uftFuqyRWaN5Qn3Nui2C ZhkEAnqK1rG4tIpQ5txI7tmdJHOxR/dUV+IdD61xRspPpsgmWZAWKBgXYiOEAkjHY9KYv9mW5jEU 9u8l8DgD5SduByfwHesqi1uQoOxS1T+04zEbRHaRZQCqD51A6j8cYrR0601a/ZZrmS1QPE0JjnZI sqBllB6bj+fPWueaHCnbcvW5t2tWitYBBECYh8mCpU84Puc/nUUAglnjsoZG86R9oml+Ta2eP8+1 Z26GnLaTZ//V+BNRhltysMuWZflcj+LHXimHSJL63kcX0SQJD5ogALecQ2Cj46euPav56mktj7Ne 5cv6cbWH7MwKxy3UhtBHCPlYIoLZPQd+voa6LUodON3Fp9qt2k89qDcJIPNEw3DhCFx1weeTmot0 Em27GeBpdnBNBaxuNQlZUhEHKFFzu3j15GKSztIbzbe3Fslz5GUEFwh2g/3gOCCCOOay5bbmqvGN iE3uyV7ZoFClPkcNjaR6ilub+0g8mJbW6driFEm8mNpljboxLAcDr16VA9z/1vj1oLcQxeYu6F1D spOGOD/iP0q5Dfu1210sMly0hUTqj7XZV4wpOQDjiv5qmtT7habFXWHW58y4gsBC6YA38kjPQnvj +lVdLnns/KlibyirBkwu0ofaspaRZrBNI2REJPMeVsrMCG4yZM9f51etILWySFIYFFsP3ajowIHp WTTTsyya81uG0dS9naiOOQFUaUhnA9eucmqVhexyXH2+e3tgj3O/yUOFdA2QPXkfzrKY02tj/9fw Ey215KIbVEgMqmSFC2c/7INUp4Hl2RIcXGCqf3/wr+Vz9Fhtczo9NWPNkLwzo1s02oT3sogmhYnH lRgdQfXg+1btlFpscAS1iS0WJMBI+I5D3bHqaykne5ew6OJ47hVyx85sgucJnoOT0qWbUl2tA0br IrbQ3QCosOUnZpFWxhlS7edn82IspjjaImPI5YM3oeP8ea6Ce4WdUtlVVZjjYnAXPYUrK9yoSeiP /9DxT+yhajakXl7mAXYMeZ3wK34TNNFdy3trZxOlqYBb7jIrBcKGHAw5PP4c1/JtkpH6erpWbHW0 8CWDQTwPHKyBoVPCgZ6fzqkiafYhZxJ/pEznECKcx4wdzE9jnHFJq7t5G0Nh7X8SyeZFERvUCYMA d5HpWjbXtu6FRIu9uCvQD2rBpa3NYW5Zf11IJr3yGeAAI6ko5b7wI64qnDeEeaQDITxu61VZL2to 7GjknM//0eD064dhs3oHZtq7mAH0yfyqFg/nvE1t5TA72VRjA9jX8jRVkfrN9LEM+nGdri8WUNKz LujQkMqqAM1bsGtQ0rNH5iiE7Nxx5bDjn1FW1ZILl7S5bcRyyzkyGInyoQcBs559eKguLhkWNPl/ fSFAU6g8nFNRfQRjXtlcXSzzpcu6QqsDBpBthDHHH4jpW6lzLaWIt5raAM+0x3kdwWnkXnIKg7V/ nxQou1zaC0P/0vPHuDaTXcNmizwyW8axMRvn8w8uoP5L+daVop+yvHdM2WUkQlvmA+lfyRex+wxW 5jJqL2M4Vo45IhkKz88/SswXEEt22HRrrl0RmwduecfnWXNa5UETQWv2q5khneO3VEMplkYuH6YA AB5P5e9dLa3Wkp5oSIzvbQLHay3Q3tE+F3Mo9DhsenHWld8hSlpdmPJqNrFfF7i32wLA8ks0akyv jkd/X+VPgF2l7Z6jPEsOnH9/DLE6zTEA/dKZwO3U8U0rrUU30P/T4j7Xot7JHFcWwtVRXkS4LEsH bJzj69qzYbm1nt5ojZRRSpKR9pBZppVH3c84A9gK/khK+x+w31uUZ7q6tngNrC10Sdhj3bFTPGT9 P6VaYIbxXvoRLZkjf5b7Hbn5gD2+tNQbBu7uag1exs7y7h0zLWTxGOIXXMgDLzk+oJ4+lc/FrdqN REEbvFM5Me0jy4pgfvbT34z0960jHlES6pqdtaXDRQCSHzo03MqN5eQMEFvrWXa3AD6hGmoTl7t0 lSEDdC+0BTg9s4Bx9a0ik3Zgf//U8Q0m60+11WWC5W7VJFw/kxbt5/uqSce9beq21k2m3P24CSzt ITPFG6/e5GOOx5z+Ffyg4tH7AYUN3HFb20cKwNAVDRBH/dlew9vpVmXVopCyyWa2zLLsiiAMnHqC ckdO9EVd2IlJrRFC+u2j2yyoGXzkijUDay7sLkj8aczWkc6BHaIPhZF5c54zx9fyq3DUXP5D7+NE me3hkLxun7qUjYxHGc/nWGlpdw3y3d3cxNDBCYrNPMO9AeoK+nHFPkRlKVtz/9XwCDU7PzfJulVn mgkhhfHzIxGQf51Rglu4LSQafoyXoa9EE011cvbyxBiclCcjAxnp09OK/lmEPuP1LndyvqV9aW92 1v8AbIpbq3jBuoIJfMSAt/CTjBPFZ9xdPPAyWVszxxSI8kjy4jQE85/GtrW2K59TVsmtY5EaR4oh KdrMG+5/Wsq41OW8MwCkRIxhiaQcAA/e4/GrjG71M2+pWurbTr1o0t7ieGWzTy5ZrOYrFcOeufp7 UzU9QFxbW8cUxj/s22Nu0soALncxxkD/AGv51XIrnOf/1vkbT4AloZZZDJe7DJDvkEaRvjsQO/OP rWY0ZeO2OBHq125+173H2YOT8rbj7cEn+6K/mT2aP0eS90ltLuCYXWly6lHcXIzJKsaZMcoO3CuO oIJOTSXMknh/T3uktpr+IzBVgCGWU56hcc4HJqYxve46MbxY0Xd3eX+n6fZ6e7nUH2h5cQwW+QcB 3bABPAwTWZb/AGHTde1HT7mGzkilsZIY5bSQMFvCRtZn+7gc5OcdavktYz5fdJzq1xb2UsMsdlKi SGG3m3Z2EkrkEHBP5is29SG1s7eYNNNdzOyGPYWG48rj8AevpXRGPKZNH//X+CLe2063ddWv9KfU DLB5csMkjI1vkHLDaecenT1rJvmtLvRpoFmNifODWNukOElkDKSewBUYPOa/nKMLq7P0C3QuRr9j 022SCe7kuvNjeSeSFUYAkbgAOmOmf5Vk6zImm3L3sT+fp90yxbLnb9qEh+9nHJBz+hraMb6Ilb29 SWPVJ9TRtPmjdYYoClvBEvyjPO8tj9Pasuzt4ItZSKJ4nup4t0ivJsmjwSAMdDkD9fatkrKw073O hlTTJbyye/1S7GnwljPplum6Kdh93J/hyeM9vSsvUFtJb3dDZRsnl7LKO3mLTAue/rjjA74p26FN a2P/0PzYezl0+4jjv3dDNGZ7eIj95IMdME9j1psetGxjhMlpJcPe3aQtDByYVL7SzkcDHX8K/AYp qR+kWtobl9LYafPebfsqTTyARs+BduqFtgHrjP8AnmuM1DV9k5mKyykYDoyko46CtrAWLabTtQu2 F082nxxW+/MERljk7bQCRzx61zuo3Lq7C1aSUxg/Z1P7t8DoTyce/pXTTVrIUtIsk0vUkIWC5iS4 mYeW63akRAt6NkevXtVFry009o7VtEkWSOVwkrZntpBkkAEZ/IkV6lA45vof/9H8YdZ1Gwt1JsLb yIpHZri0ZsRKevy+2c9a+SPipbxXkE17bXi2pc7GtTKVuZQ2RmIYPTHPsK/PKOyPrqrPhvxVawWC NHDO8Za82yR3EhG5OTvB+oA/HrXCXenrccTjfIBhG6ECvRp7aHlVXuZYihsQ6S+WyocbuGC10nhb UzpuoR39rbQXVw6m1aW7G9LRGP8ArI16bl6jIrtg9bHBXdoHqSy6RpMX2q0gu912/mXrTL99mPVF 54PbtWhLemUGHTp47e++0RTwy3Q82NQHXcjD1Iz+dJPRo5YTdj//0v5KoBa3OoRSQhFVEQrJglSw Xlhnv7ds1oJp91q+sK2gzIb3TGW5XzSsRgMZBLgk4PPpXxtNe62ek5Pl5UfPHi3SbE6/q93dLNNd X+rNf6oHlM6vOcA4JycDAwBwBXOzMsLtHbQCSa4HlxSZKzQ4PGMflzXr09VfqZJ2hocpqC6k8srX 1pHZiNfs5aEljcAdGdfXjn6V3Pw9tNHvrCRb7T4mvkuvMhuzcktCEICq0fT1P410QWmpzuVpWPdb 7SrHTrMy2EEcFzNbqz2zJujcEAs4PYNnP41w+nwW8c0Go24g04wSN9rhi63j7jgkHsPb0reMe4Td kf/T/j7tZLAXup2t/ZPDbXtm88N1bhRD52SfLYZ4AGDz6+1Ykej2bRo7XDTseZnjIw+Dxj8q43Ds BftraztgDNGwtJDseTG5oh3IHHIqLR7awnuJoopZLkQ3BVWmjKID2JY9ODUuDSI5zUl0v7bc6hZP eC10Nwk9lZxyGaeOReH+f0J7eg/CsvXtBsdN0+0Zr5k8qd7y7miiJe0hXGAAeMkAnipLT6oil1H7 BDbmBpJ7DVQEtnRC7SKxwHbGdpz6ntVltMicpDuSMqw3tEAWXH86BvVn/9T+Nu6sbl9yxswCgvGQ xRn28ZWtfTLy6ggikvybqe1G1kujlHQscDHpg9K88DoLw6ZLGmp2k9jCiSrbx2gkWKaMiPJKITna MYz6kVnXcdjLElzKdtzAxkhdjggkdB9aDWmtLmOIlhMk9raRm5dt00iLt8wE/wAWK3PDum6zfatJ e240qTTLDT5JLyEyeddRy8bTsxyMbunQ4zwaUtmZta2RkC+i+1T2vnQ2d6cyLZvJtknG7jH88Vc1 2/8AtdgbW3jWxmsLR5JJosGScuuHBPUggY2+mfek4JiSvof/1f48dNFtY6VbRWa75niEkpkbILNy eO1OmuGa42fbfNxCNiQsVMRP3lPr6fhXn26FuNldkp1aeG+h3AR7YQEQjJnx1znrkCukl1dNa0uW KxiuLHyphumUbZEKfejD91z7VLimrEGB/aX2mSzs70zXFohZpJIod8xYkYwQPQHk1R1TTNYvLjU5 7CaFNP06xR1065u1jvLg5+8icZwD0HofbNRSWhX2PmasVhBpqfbZ7Ca6gurKOSFJWKx2rkZZjg5O eeDx0qWzv1EkFu8YQXCny441+QAD+VdBJ//W/ke/tm3tpvsj2rvbPZNazRxRbI7qViTFITj+DIGR 0rPtpbv7dbWI0zzRLCIYGhJd0cngfTpzXn2toBQvXMV7qDXSqklkiJNIikgsF4VexOAM+5rZ0eS3 FzbvqRuZYLjYfKs3AkjQ9znIVvXIoAl8Rx2tvqKrpst5JYS2zzypOokdCpXarOowW68cdenFRwQW kcCXMF0UE1qGVJYwESQ9TnuOn+ekOCsN2vpsQapPPp9xC98IPsrxhIU8wOZZSM5wDxxg1Yiu1vrd DcWcWmSW+JlmgLSvc4IODnjkDoB0NZNdGI//1/5FjeSXt+sTWzbJVBjIGxSzEg/L68A1JBa2NxLd WMsDRzafd+SwlTbHOdoyynocE4wO6mvF5IgXJIYrKOSysx5C3cflXEm355OhPPXqB+VZt299BdaN Jpmn2qvayESTyPvNy2dwLoeAAOOOKqMf5RcqLa2dw8rC4fT0Nw+/KkRAeozwOufSr+mtFJp2p6X9 iSWJ5mxdXZ2mJhzmN8/d9KBmZeQW86QaXbTXME6Rq7G3JkDYPOCfXvWqlmIbe3XypJJpXKy4wAmP utn6DvQI/9D+TJf9A3/bMXClSqOyBpVJ7jHGfwrEuNJnutQnv5J2VWtRFB5qkumOefyHFeLJ8qJS 5bs01gi8uC+09mlgt7Y28sMyKsnmDh3BHUZBxUmn6NHLFbXJDCSKV52iVtqy7xjD9+OeKyuzJu7u UrbSrCwtHhhi/etcFpFclgGDZA/D0qz5aNqVrdPp6RCOMMJt25GkGQflPTIJ9qRjKWtkaur6vo0t qyGyeLU7icBbqGB4h5S5whXG33znJ/OsPT7qxinkeK5le+VR+4KkDYCeT757UEt31Z//0f5KZr/S ri8mm1W1jvJmixHBJHlS38JbHp1pbdtbzbzabGWtg7ZhVhFFAFXgk46AkV8+cMZOJLcBI0EWpRW8 t3PFtPlsTCGzkNnuRg1WWfUry/jtrXyEt8fv3+5LGBgDYOjc+tFjVO6ubU9vcma30vTZY/7VVTKI L6PLXaf8tPL9GGcjrW0I5LZVBZC4TnB+YH6UGkNzNZYZ8vNZq93HJ8hJ3QOo6Er61Q0qKxn1O4vZ nmYXKraIqD93ahCSdnHIzn1+tNWvqO6cz//S/lKs7aS+1C5YyLbPasEiiMYaO4ZAoRnH071LreiX AtbjU7+5s0laYSJbyMHkhwM7wnXB7EeteFHltqJq5zOr2gvSl5bpHGssaRbdvkmDC/fVcdTjnPrW /pdtcz30FlaRQrEsSSQvLKG+1Mv3lKEY5wevrV80R2RoX10Jr57a2hghuicNb2cQjQYGPlA6CuVu ZZdXieNr0RPaXH2eaSJAsr7Tyv4YwT1qZSXQTVy5b297NKJoZg1paKF8tW2uxwQQeeRjFV9oZsli GEnAb5d2DilOS0RnPc//0/5QrixlvUBQRxmBDIjSNsikAGdpP4YqaO+W705YleNfOC/awqqUiZOC inuPfgnNeAkccIq8gtkgzHMbgi3VjG5jXco5xkD25qrbX7C6y9pJds8htrYoSuC2QjN7Dipkrqxo o2Q3U9DudNtrQ3E63l1cl5buAgyeSwbjaeenA+lZkaXsJ8+30+xjup5R5skxJMka/KAGxwcD8KhL 3Gipw0t/XQ7O9/0NUhh0q3ma9t0uI7i0ufNlTg7k2An07+9cxFFHe3NnGyMqs5dwX8sr3AIP05+l EfhZq3ZH/9T+Uu80vCyTwytHbbwJI0BkcHOMKnXHHXtVLzWsNRk3PKVumAtxKmPPIQAqAP8AdJ/E 188lZWAqxyML+d7uSdHkfKWjjMaqOhXjv1PvWtp1pqH9px3mn2aX542WpUlZB6cd/QVi92BbOl6b qu24a0FhqNpK8vlr8qTtnlSfQf0qC3iulcqwW3K5UiJvMLg5HUj3pEyStqTNaCKxl/s+ylurh3aR BCgU3B9ye/rmrV5b3kmnfZoflvIrcSKk6ERox/vAdcHNAtOY/9X+U7TvL0iNpG1O6jLIyXEccRaC 5Y8lCB0Gfft0NMkcRwPc2sTgzvvWOMbFck9T/nvXy4WRCLGG7iuJp4j9qkAhXemRAR3+o6U7S4Ej njLbvNs9wiLx7ssOP8a1grakSSsTzTfaZgJUV5GfGBxtA7CoLCQebceRwROYtiHGMdSR26mrMjd1 JtLtI4pIri5vLueMQQxxHbFARy5kJ7dveqjP/osP2ySCLzpBDAc7WjJx+JoKh8R//9b+ViO0lsp3 NjcHTdUnjBa4jOXKL0I/P9fpVTWxbvYXSLJi9vVW0N9IdxQ5w3HcnnA9TXzs/hAvaTaWthbLCjAy IArTcAsAMZP16/jV6G80+FprJXVpJHDyKDlwW5Bx+H6VgYN3dyrPF5txb+ajXrQAqk0wy9uhzgKf QdMVR1FZPJENnbtNO0oUFmx5a81lJWkyviaRsWCWgjtQ8kpAcLOEHzRj+I9a1FjuI5/OsJ4ILYny VlEym4RD/EU61Jqf/9f+VWS2jlu721EwuVe5EkhnQD7WU+ZZMHr/AEwfSr6RXFxcrbxwMUDfO2MI gPTH+FfHXs7AZV+tvaXEkUMiykHZMqnzMk/St2yspZrcMSwcD7g4VfTimTyu7Ks9pcR3dsYthk3/ ADl2wu0cnj1x2py2sTSSyYURvje65UyY7Eegp3aKHamwa/sIZlkubS7spd0bJ+5jePAjJbt+PoK0 LKxxDEoChwNxJ4JB6D8q2Turik7I/9D+XS/lNnLsfftG2JoIV3YLfxHHbnOazJ4/snm3UdqZ0EeF CnnJxyD/AEr5czp9h+lpql7DPIYXhyMrHJnagHAx9cn8qnttHntJY9R1JYDfSRvbxCOXMvlFwy5T tkAdvWs9HK5oTHTJbmC4uI4ZHhSTy5PM+RQfQd+cVG+jC6tRqBtXguBELd4c7bhhnqo9OAah7kuN 3c0IZ4xFPZzLLA4h8pSVxzjHJPoM/jWjpt3C1zHHbQ21xHbQbUSdiu2Xrv8Ac8d/brV0+pdKKVRI /9H+YrXbe6vNWFyqJaf6CoNvn5xIAMuDgcEZ496LFZIo/OuZHWVBtjQjg4/vHt04r5KFr6lp2iaG n2Mt+5vmMpQPgxH50yB0H1yO9OsNPjhivnKR2ybypiRtpPJP8605VtYpP3WZn2Bn1OCCCCQWSW7T Xt3jJAz0yepqxa3MTKPsc013aygkXBBMLAcYDDjp2+tJQSMiG2+W9lItohHcxjy7pfmLYP3fXjHq eKjvdKikV7cTSJK8nnmEJlCezE565B/Kp5WnoB//0v5WFOvnWba1uNRuLtLS6LAXTEBEYFdoHsCP yr0W5iS4s5Ldo4rmRQCkLEBS6kMvPbkV8pJWhYqCd9DPW2sIZYbK+toRe3IJnSV8tF7DPX06Crt3 pljFD5ziGCCzXClV28EgFQB/nisoN25jKpFv4mY8wWS4ndVuYNP8tVhiaQeXJzknA6fjVyMoRE8a GUKwUjknnj8K2l8LN4SvY1PslxpNoVlunuFZ2uPKPBG8khCe+M4qPTYrS4SeaXek+/EKx48uMHqD 39KxNLH/0/5uYbnTbBFhez3M2S8ggM546sTg4PNZP2ho9Rgk0+eN7Etl5QhWaLscfnXx50Fa2F35 99bTvI1tHMZrZ2j2+aGJI9uBxmkmvfs91FbwQSMDHuuZGO1Y+oG316dKxmveM1pOxUjeSeWSUxOY oWHzMuFqzFcQi6gErSxKRvaRUyVAxwKTViZfEay6u9zcnZH+4KbELcHjAH59aR7Y3kM0c0ktrvYq rxvh+vGD74pEn//U/mygs0s4ndHaVoo97O33lxxz79PzqpHeeZJHLPbtJIOFcpjC57fXFfET+Mq3 vG4urRzpNCsmII8F7duNrAcHHfvzXEpqUgvYo4omWOa6InkAO5BkgFVA5z/KkVNK6N2SG8huUKXD IrDcFAHzfX0osWa+vZ11hQ0VuFkgjKllYhuv4cH8KqLsWlZWQuo2zXtxqVqyxy6fOixwsBnzV6sG 7jkdvWqkjPaNa2o0mxnjjKzf6RK6lRGeBtGR2yOn8qI6yGf/1f5tYdQuL6eXba+cOsqkNHb26YIx G3qPSoL6GMoHtlhaQ5Hlj7zMBxu9u1fHNO50p2dzS00u0UaTwJbTFcFY3LISPf39KdNaWMchaJik 2wtdwsQEc54ZR1PGKznvY3JFile3Ty7aNYUcyByfmJHGMdPXnrVYP5iH7GF+0G48qbz1IjwMbgMd +tTd7EztbUmGlRaZPM72drFPeLu32wITHBJP+1z3zTDDMAkkEnlAEqrbsbcc9KcXbQmn1P/W/m6u pIpbuF5iZruaDbJLgnaEJABPT3/GnxW0KCG4vpYCtxK0durEbpNv+znP/wCo18cne6PQNUz2soNv G7rJH98NGVX2we9UBD9kbzvMO4vkd1PtT2M3DsJPs82OfYis7D59vynFXNUlDReZaq5jwN6ucsSB /j/SgqMVEr2K3LpbXqHyniXcUeMbj6Ag0qACT7U20yRS+YYtm2LOfTpRYbSasz//1/5upryEzPMx WIs2cpwqn2p0XkW6SuhPmStvZu7fWvkOV9jv5UgsxPJP5soKxs2FZuAcVrXaODvhVZY0UFiW2hR3 /EUhmZp9ykF4XntUlt5gVZJHMZJ7YI/zitOPdHFPJJFEjTPuiRCT5S54AJ5P45NANXVh0VjbxwT3 z31nG8Kb1SZ9kjDqQARz/wDWrKij+3A3Mjued0TBdqhewxSaT0ZCjZn/0P5wLqB7iL7PazGGYsrF wBuIDAkfiBj8agdJluHjYjaCArNyRgD/AOvXxDVnY72tLGkgmCtgBo8ZOeM08tdG2cNJJEj4LBPl DAHpSMCtYyynz/IUSsq4CucD05rPuf7TtVmtpFBhmbzU5LBGbqB7UDTs7luK2W3SGZMINoEoQAtn gE1o20YgG4SbpAcvK2A7knqaC4vR3P/R/m0u7rVluJoopI/NNws0lzsO9oz82AP72DW+8tpqKwMz TWojIMrvEQ5I6/L1r4XlV7nQSx29ukch0+bzI7lw06KDEzY45H4VcmnswnChQF27OuKiULbFRdmQ w3bIHh80gyAZXopA+6KuWZhLNPJGWaH+EjGMcZpcki5OLVileG6ubCYxmNbjzCYkf5o1wSAT+FOs IFCIk8he5K5JzhR6kD2pNNbmR//S/nwkkaJ1htzHIywbpHT5seufQ+1ZS3N15gaS3luldvKg+UiG DGSzEj+R9a/Pzug7qxqG7iiUeWxlBUZ+XbtPGR+ByKe6Tzp5qybY1T5Ys/exQUP0uJJhI7Fvvc78 gKfQVK9tbRznzULqcEBPmxnoaAKN4likZgZphPKS1rFsLJJtIJy2eMZFZj3l7PaoksTRQRuUG5j8 p6bh7nigD//T/nrt0jt7Kzso7lWZV8ycMoU5JI+p4xzWnE8Nooa3EchdwsmX2soI6gYr8/PR1sIk 1vCbcW0krXe5/OhblMZ4w3X/AAqrJcanY3dwGRYDKu9njIMTg9j+nWpT95oQlve75jcTwvKEXDBP vH3A9a1LyeF2t3R/IRUx5bAAnP8AeH41Qk77FG5/s8ywwoT57fMyBCI1XoDnoM89asz6bZ2jW0Vv CiPGhdgr7gd53Zx079Kzm+hPN71j/9T8D0ukMXkxOq4GxlIC/N0rJazkgmhYksYZTMobJCnn/wCv X5uegtNia5vp9RlYlPKn3lFONuT0yPrT9Nni8u4tb2KdLq3kCrLIhjWTrnk8EfSgrmkTXpWSExhQ Y1xlMZDe5qO1tHcsbmd41jTfEFGWkOOFPoP8KBXd7mRBd3wmnAnKBXIVEAPGehP4VNNftCii4gnf e4VJIEMqqOhLelXyp2sXz6eZ/9X+fx2tYpbZjEhnuf3SOU/eN3PPXA612r6QNN0vTtUfULVri+aR DZRXCvPbhOgKg5G4EnkdPrXwFj1FOy1Muxa2ke4eaYo6nMaEZJPPFV4pWglaaUmRGkIVYxlVHpWU +g1NdTaSX5ZWRV2umDv6/hWZLbRQBZrdFMjMWniwBgYHzA+v+FZlRknsVTLqInJskthE+FYXIJbG eSDXQwafmznuy6eaAASTzk8YFc50RlfU/9b8LdPvLixmYI3myBchJsrC4ORhj6H+tPj1CTVGkuLr TYtH8o+U1rFL50OF43oxOSG681+Xn0Ld3ctRm1mXzZC9xaBlQxoN236fzp8sdsTInk+a8YzGXXJA I7UGkZLYy7Lz4Jt0O9fMfawb5VUZOM57V0M8l3EzQTobhnwh2fOVDYHB/Ggs09jWEEcUYMYVfkC8 EZrnV8hZ9l1cDzZ3Plxu21gAM4AoE7dT/9f8RYNjMwgibapwp/hA/wA4qZbuWymjtJ4Y83M/lxsz hQowTk5+lfmLi0rn00bNaFg38M12lkrRhf4pD198CpY7+0sLq5geKY748W0jDCuT3J5xipM5b6FA Trb3OySTzjN8/mfeznsPp0qa/maQR6ekImkmxhFwzAHoMepz0oJFtbWZRIkdqqsyhFjYGKIEDByc cdOavLp8s8W6VjheiL92gD//0PxZtLO5eWRdgEMeAJT90k9qlnkFm7xOFIkTakkYOF6cmvyyUVa6 Poo6SRhpJexX6XLww3NtbOk0ImU5cg7gGHpxXZ+eNdufPvbeNXmOSqLmNfpn0rI1vYkkntdPaW1h dnlOFWI/dB+tVbq8Mbx2phSSe4AE7x4byl5YZPpkUGc3qF0unrFbnToi9yH/ANIJOQeg4+mDQlx5 N5AYrYTOUImjb7hHqR1//VQaRd1c/9H8bL6aLe11YJHbpI2yZQdzLjrVeIQSKl3A8q2/m58uVSpO Dhs56V+TJJbH1BJfPLeBFhVxGpzFjhCRW3p+n7IY5rt8ME3NH2amSndXM2+tLF5o2EtzmZwiJGC0 cfXlhjj6mprfTZ4rg/vUXy2HlSK+Gz6j8qBp3EktFuL+S8mZpLmJ8s5PErdct6//AF6feQG7JAjj +0DHlbvl789Pxq6e5m5Pm0P/0vx0g0ixS8W6e3EphwZpW+YEjGQPbrTI9MtUjmntLibzZLhpfMcb ggP8IHoMV+XS0R9C5N7lS48uC5/0l47mGWMDfn94p4yD6Yq7ZWxhU7o9tq8ZkDKcqw7Z9+v5VEEr ktpaMyNSxp7efbRySiTaI4BwpO4Z5x+P4VY33r2omt5GVrh8OwbLoeO3Yf4VoPZGhfTX8yQrelpL hYUSJtoG4KMKPw5qGaZreBJ1hzPv2ylyUL5xj/PvSaT3EndXP//T/IayvTcbostuMYk9EQAjr+Yo 1GaEDKtj7KBI0h46d/8APpX5Q1Z2PoCxYeTdW8c8ARRdEnzJCI0lI6ksfQY/SuNvvNzMyTFXtt0n 2dSD5+OMAd6QFnT7Se4RJZvkRlDbcYc5HTFbjXENrDHbkMbiaTb8pxsXsSKTV9CYu7aKjLGs5gU4 kZt+SNu84FFtau+rQ29xJFG7KWI80GMDsSe3/wBelJXVij//1PyGitVnuZo3YttkILY+RsdgfSqG o2UdvPHAAoiOGLochc9j6GvySMdNT6Atwm3Qm3heSbdjaXTb+H6VbmtLrVZEtobeOMwgKWJESYHG 4k/zqyk/daKmiX914c1K5ttVW1DyqYbVIZDIV924AxgdelaeoXkM8kN0lpbJKz7ZpgvzsvJGfYf1 re1ncvnfIW45QnlRFd+fmDMPlRSeQKoahDPFLHKqj7OzZCqeO4yTSS95mXN72h//1fyU0SaCC+hu b23a9igLsbVZTGGYowTJ9MkVkRpvvLibyBC7AvLBGdwUfXvivyqouh78l7rJ7OeO4nCqreWsRQoy 7lPIrYliNlZ3MkVvBPN5O5YnALD0wD3qBR2Myzv7pbAJ55iuSNzJb8lsn7n9Kv2F8GspEjQiSfIm L8vnufagryLLWs9nZQy/axHGzhTEpzK6jGeOn51LJFckC6hAeLcFOxsjHTn9aznc0ik0f//W/LhJ rWweKOW4W7nmj8xfLXAjJ/gPHUcVNBp/2sM93Mq2yHzHRmw5B6BR3NfjU9z6qHxFf7DYRRbIJ8iK UzPH/Fz3P1/pRPp1vHa21ykilZpXaa1xnGMYD56ZyTwe1QbRfVFKaeWxlhMFkZIyQzD+FBnPK+nF X5rVtWCXpuDFGso3Qo2AhHPA7Vk5XVgLz+VNm42RGeSTyRBEhIYBeHz07fzqZGEFvhY08wg7C/3A 3SoDyP/X/LhrlpI47O6+Se2OV8tQu/Jzwf8APWrDC1v7qe08yTTrpLdFZtu0YxyWB6ZweR61+Hn2 BYiijuIySxFtExQM4xvxU93b2bQQKyRN5xCR3AXcYPceh4pOKe4GoNSv7JI0WGGVLUHN7FITcyg9 2UjnAB6etPaCz1ixsrXdcIIr1tRFxC5XzMYPlv6cg/5FYyVnYa30NdkjgWORzIttAfMkEQJZwK5x zFdPdIfOguXJexCf61vp3B5rOUOxrFau5//Q+ENLhF9Z2895Pc27Q25jml1FDHvkQH7vHIPHPqT1 qjooR572d5YvLkjdGitJN/mkZAHPfPX6V/P0o30Z9rNN7Euk2ySMkkcbW0SSESeaMNDyeMfWt2RU mEvlXSpdRxgkscPIvTaD2+nsaxs0ZrRkVzeadpT2V9blLe7UiNQvA3dCW7HPXn1NUYtbuoL5h9lK q5DTKHxGwJ528e1RJXRtuiMol9dGcJtSKQ/M5+fqePpW/YNBbCaWWaRIjwqRxGQSHpg4OQPzrEEr Kx//0fivU5UFxb7lktrcopjkDfJL2KgfhnHvV6FkQtA0sawOytDMoKOp7h/bpX82zWh9tC7Rr39s bNorWWSKR5oBcR+TKs6svrlSR6ViTx3cn2a3tXtY5Z7yOMSXb7IVBYbgT7jP+RWNuh0rY2jeT2mp PbxQWs0Wx4Gc/PFG3TdFz2wcE8c1m3d/++txDCXaNhG+JehJOXx9D0rOa6j8jd1XVL1LWGBLGzub MwqrXCQKs6bR8xBxuJP1qNdJVNE83YGuZZGkhjJKbQeQHHUdfSs7J7jSu7M//9L5XsE1SwhN1c3W nX8kqKttbwT5ktlUYCsOoPGDU0L30t3BcAos4kPmtkssSjJG0/XFfy64po/SLW0NS4isTbzfbnZp pH5k4dJc9QR6+9N0qe0t9Puk2m6e2+SKRm+aLJyBjvxgc+lYtdGBpQPiz82eRmA+ZmkC5T0HAp0y tfrtCfOFGJQMMoA7/hSskBW88RiWxt5pCm0K8pXaWI+8CM9jWtoBWKa4uJlNzGsBSJgeEfPWocHu gP/T8Vm1ZJLjAZgUf93u4x9Ks3b3gKrBNb207ypFdQXbbBIhywIyRjsc1/KFmj9Mc9NDPmNzPdJI 9xcKLT928ceGt5PoSOcexqYSpdXJhcNGVXdHIVysmOx9KVtS4N2J97W1o9/dRbbeK4+zMxYHb6MR 1xV8JBcSpHcMkEGfNzCg3noVPb2rCUbaM2hqiKeC1kmcpOHYHcJJmAOO+awr/XLjSpvsVlY/alu5 NjNbwCV0XB3FCTgcke+Km2txwba1P//U8ktIwLRdqt94ySkkgx56gj61Uub27Amli3XBij2wuZSG Jz93HpwK/kc/WBt6NXsr60ihlt5luYY57jErKYlkQOF6feGRkGr3mXEDxI0UUSSHZLPvyWHoew57 1rNaCvZ2ZbtVtJXlntbiQzxpxbMMIwGdxFZDX7SXrxwsxeLDsQOFyacVYZf2TRQyLcS/6FLKjyxR fK8wGDtLYOOc9KnT9+PLjVneRv3aZLMPQe9Uawelj//V81e7t9PkjWYG2lT5YyVJLP6Z7HNW7OWS aKWeSaMuAQcHaXB9q/khprc/X+azepR2W0VuNsImcSltkzlgPTnqKzksIVl3ny4JXYu5DEgZ5IH+ FRy+9c0g7OwXgjjuI5UYxpsCE85bb7VEbuxhaWRJpRGUzK9x+72EDog9Dyc9eadlaxo7Jal95DLa xOWjMix5iAA+ZScgZH171U/tGKGJ4jIsSthpC7cDHoKdjKTTeh//1vJLVPtf79VWUE7Yx1xjiprS 1vnmO0QiBpQhDkg47n061/JkFpc/YCvd3yLePEVeK3hkwSq5cgdSB371BLrEMsR/dsUjOFKjJPuf /rVYDZdgtjdFH2qPuqp3vn0FVYYLmSWzkurUK5OLcNyACTjHvzQBc1Ri4HmFJBuxJn5mOBjA/wA9 qzUKWzLPAPL8sb22r8i9wFHtW0FZagf/1/BrG9uLq9FwqxGFU+RDF5ciHnkipbu5ur1boNHI9tag ZRcOJ25BUD2x39a/le3c/YCvPYpJEjLFHaoFBVIxjB9fxrMW5EN2lsztLgqhl2Z2kjNFrGMtWXLu O4v7e52XHkzquI3Zd+COhx7dfwotbSGB42inmubpoQlxJcAbA3cqO31ppXdiTTuWmmZEYZaOLYro uMgev5/pWBeeYX8wpHIYF4gdvLM3P3c+9a8qtZmU9z//0PnC/sJ4Tp13EkRS4jFw8JcO0YPGAR6c 9auTXqMipAs0YBDMp7HHP1r+Yowuj9QOUvtM8h7y9DwIZyjbAN0s477vTGOvvVPRpUluHiaGcrdM VQpKNg2qeME8ZIx9atRSE2luWoUBSRXjYIG2+px9c1py6hZTWUVtHZxRfZ08vKAh5Dk5LZP+c1pF XdjKUrlK4+w22nrdKkdtLKSkNshOZXAyxPPHB/8ArVjy3umItqJZAwmkxLHt2+U2eMnpg+tNwd9D JTu7M//R+UL/AExfN0ybTIrW4srpma/ty5eUOuPLJHbJUfpWNO1zNeam80EcLW8wMMESFgUI5wO2 DkYr+aVF3sz9Gk7I52yntrbUbozGZdRlg/dhbUrF5YPAZug7/UmtiLXZYJ4o7y3ur6wmt2zJaEM0 bDoCuPxqbWNcK04SCDV7u+s7izSKSKxE32gqU2TNxtBJ6jFcjrOjtdwrC0ktvbOdxubdtkzjI3KW /n9a6ZQslYyb926H6lcWtvAIvDltDex2gjisbS5GE3qFBJz1Oct16+lb1xqtpchIjAWeQrujgzAW PGQuOh+nr0q1DXUxP//S+FZdSlQ3A07bbzwzeVtn2uYs/wAJVuDwcfhXCxWDw3cnmXclxEQcBiG8 lsnJBHav53SsrI/QDYnOoW8cZk1GOd+VNqkyvK4I4Zh9KddR2VzpkInjE8yy+aJHHzRtgjao9s9a 0hFrVmafvWOSS6vbDqbpwhKBnBO1f7oPpz0962xpTXk6XNuNt7FALj7RGnKjGSGz6fp+tbwWo4bs zr+4luZWEUcCwqR5hgO5mKjDH8Tmue1K5ubPU4Whhnt4UVCskz4bDfeP9R9a1saX1uf/0/zFiu7v V5pXvGvp73T9v2WVoy0UULDGAx7ZA/E1eFtNa29zFCEjkmcSylxvZmGOQTz+Vfg5+kC2JsyVmnhE tzbZXzLtfkBbuPoMVWkj0pprid7qXyvI3LA6oY1dRyw4zgnpk9K0pkylynJR3QW+nZrWeWCKAsuw +V5znIVRkdB1NW490a+fPbyJPMjLAm35HPB25PfkV0U0ROenkZF69vdS2XlSSWhwVvgVDGHph0PQ nrwaf/bEmjabNFDciQM223musF5mJ6c5wT7V6dHU45St6n//1PxNvY5WtLx9Xs7ZHunaaySC5y2x eSWPbOehr40+MTajc2uoajpSQWMNjKipDEftd88f8fB5UcckZ5Ix6D87o9PkfUVZdj4n8Xu/2KSa 6lW9mkO1Y423OpyMDn0/pXB22oTOyxsyrmLaSxwFAGAK9Gm7HnVHdMcLeS3nig1FRFDfYPnkebGi knBOP5V6D4Ts9LazNxIFkdbhlikEpEbBDjBHfmuxO2xw19Y2PR768h/s5vOmCTsoWJ3XeoVQME57 DAFS2lpY3CreWjqrmFS1xkPFvAGSB04I/Sha6HEk1F3P/9X+SO8uWuLRHsbOCJofLM0eTHJsxt3b exOMkH0NUdQttftZRDaXNrDLLZq1nMko2xM43/OfXBHB5zXytKF1Y6asraHJ+NtMlbT9Pmge2j1i 9kkBknf7OnyKvzH8c/5FeKxyzWps2vLkJfxSYuWJCxMc8BG755r1aUVyoa+Fl7UZEln+0C7kn80f v4zGAIu2Q3qff0rp/AOnW9pFrHl2cc9xDCbuXUopV3IoJO1lzyeR0rqjHR3Obqet6TqkeqaVpU/2 ppVtjKrmSNRPCysBsdcdMDIB9ax9Ws7S6n3teSJ56GRBp9gsbxKemV4VSf6e1WOTukf/1v45rOLV 7C21hLKOF47zTwhF8Uubi8ZNuCu4fIx2jJXGRmqek+JdPlt10250q30bWoYHncS3LeReLgkhM8Bv l6DGc1zieiJtM1U63pD7bdoGmme2hMi48so3LY79DxVqze+to7KK8mtorK5vXguZuI3GAMODxxgj I7c9KDAxtMvLGaW71vRb6S5NjfHTUtJIv9FaRDlmZWGPQdxzXRat4oZhFZ6jDaINVIt5riZN0aKT 2UDr/nFYyerNYO6sEmlvBpKPbXJkVrkt5YUGGNcDgdx0J2+9JZy3sTpeW8cV0ICYZbK4t3WWUkHD KTgYzjn1NSU3bQ//1/5BYdD1CNIHmuFhjkZp5WvbkBLHzOQgPZQfXtXIx2OvSDUrq7msH8hxDa2d vcbklUMcvnqeOeMiuCztcWpo2FtBcWl7czaYk506EzyyzAbYACBuBPuR09a17jzb7T7eYwx+c6qo ESYXgcHP0xQ1bYpNrYNBsvE8mn6nqOrWVpY+VdtBa2dvMuLtABsZPqOuQKtW3iODSGurOydLO9uE O5RGYnl3L82WHXIolFWsxOXK9DBsbGTU5pLqOOCa6ibcVlIVpB/dHfHsK2EtdzTzCytoDekoH3s0 FsU6gHk+2Dk0hp2dz//Q/jk8+wh1K3sRMz35jO+ERlYyc9j+HSp5pInt57i1WHfb3P2e52kK6HAJ 69eD+nPbPB0KcrqzL+n3In1azsNVs1CvCJ451GS8ZG4bDngkflmtnU578XF//ZmmWB06Kz8uKE33 2cjcdvyg8sRnk5JOelIkqaJLcWlurn7IZdrWsrRKCkRbqF78DjPfFR6lpkcF/dxQSNcsp3ySbsIC RyFYHBA6de1CARnURRWUstzHazJi6kjOXRR94Ak0k3kxXpksrmU27p9ngdsKWAHQY4GfaugfQ//R /kMgzczJYeYN/l7w0hPlxtznnHGeK1YZp7DYLrzY540AWcLhGPbBzXnibsh1lf2Wp2It5rFY2aZr h5Hg5kOcfe79M496orbhdUjjWUJazfI8YX5YQP4+OenagiN3uad3aabbqjQ3MkNrbo2IVI8pyQcl ieuee/esK6gvrqTTzK1sbAL5SxoAoK5yM4+vek3ZXNBby3trVXilZXWRi6hjuw2OAeuOgqPw9Zav 5FhJq8kV0l3GJWFs4AQcnA4yOAO1YEt8rP/S/kvhs2lzbWyPLLNcbIHlwvkMTgdq5ySWWwnt7Vor ie7urx1ubknfHCgAIIABO7IbqecivHJjK5tJqsF1bSzXSyqykRxu8XlSKwbaNyYyAcdazf7RdWuo Y1WS9hAJt94LIPb6/rWlNFDLrTrq6gitPIjghJWWS7uAf9EGcjYvqP0wK19atYLBbbR9Gvl1KZ4I 7iaaRDGuCNzK2e/078VMlZgdp4Kez0qxvRrMVsutzWsl1oN1GDFthVcSROW4VupHfiuP0zxL50+o KLZWjtwVSWWNgjyAkOq+uOKkbtZWP//T/k70i5+0yy/6BGllERuf7wV2J4xjpxmtm9vbmQ/Yv7Pt 1tv+PiS8fmaTAwiIMcDBJP0FeJPa4HNxL5uoNYSRNYp5X2m0ndvKtZXyAVc9B9K19Ii0e4tNQ1aT V7hNSspmsl062smltrlwFJPmZAxk9QD0/CsjCSs9CneyXMlkzwxxm5UZkTqEJHPPfFQzXMmraZY2 I2Wclu433doo+0SsuP8AWZyPXjHQ0GEviZIsUxcR3SgxGEy/aCQxyoIGe/UViwtbuXngj8hmGI0Z ChlOeSc/iaCJK6sj/9T+SSS0fU5FXTWtEmCiK4LqXkLAgYGO/Xr6Vc0bSNYttYvdFkvtOv5YYPtE flzGMom3L5yQMg8ADqVNfPnnpWVi7caXdTWP2kFGfzHhVZGBeML3K56GqFvdwWa2c93Zi2+TyWMQ JVJNpAbJ6jI9qLG0PhNCz1m4svE2m6zeyQSzWqG2sVmjGzDqVI/2j7VZ1172Mpc2HlfOcxQO4Vp3 wTtGRjoM/hQWt9Rba1vxBDLMzorS4meAApkg5Uk8kY4prT6fECkBdXgyrokQAXHYCgcXZ6n/1f5P NHu9Y2XUjN8x3CUmMRyhM5VgD34HT0pNkuoRH7XcO83mK5uXIEiqpB2Y6YOMV8+TzROgg0z7TaXJ gxKhiJd55FEkQXH3enpXMWLXVhI8NjNiaONpHuWP7wKeMZ98EcUm7bmcpX0NXTriYObkmOOZSIjL wJX4zj1xSWxtre2uZ3ihW5N1I08bAPHGhJIf6tyc9qmT00G5PQq3tzcM+nW2kWYQM7S3k0bYyOcY X1yBxTLM290Zre9hCTROWjuHyHP0H41lKbuhOVz/1v5VpryGG0Sw/wBFMNvGxYEgTSBsfLt7/wCF YlvBZTyGSNdluyExoibEBI6Y7c18/wCRzKL5my3PGtjbpGsLgEEMoXOPTj3qh9luXknW3u5rSS3t 0uIPJiBCMWxg5H+cUGqV4WNuzmhuYZYZXma6tYxhHj3tO7EdG4HPX2qK5ufKuGubyOI2Fnb+SLSM MXTOcscc8Zz36UrLlkKzbaGnw83h26sr1NXvppb2D+0LMvJxBG5+VMAcbemM1UgspVma8muTIfN3 rvAV2PXJA+lOMUlY1sf/1/5Vp55bVY3kjmVJxujcL8jewNZWoS3Mps5LJXnu7KZZY7g4jYHGGHTH QmvnwtY3prtL2aK8uxBFOFEZijXIOBzn/wCvW3Hc/wBm2UUmkwhOkp2RFXibJBVMdsYNS4pgYC3N zfayIltnBmG5SI9sKEddzdB361ciezhuJkN4m9omjiCqJxv749cc8+1ZtJdSZfCyWK4mtzDBHIwf O0Sr8vXqQKyL25v9PuEimuHuZ/mEsjYDkHpnHselSY7H/9D+Vm2tbgxrcXEQZV5W3jG5ZFPOW79O w9aka5U/aLQwoFZA0KuuPJI5GD/jXy5nBtvUls7xYUlW9bIijMsromS/qAPWqbXFxcf8eokkhlm8 pQ8QgnRfXFbpWVhyd4gkttJMbeDy1ubOIxvIsgk29jz60BEET3VnFGswxDeyDh5gCRuc/kMjimZF uytbK6Se1Cym4uGT54zlYvUj1PHSqc+mWuYpL2TcNPujHZxu2JLjIILEegx6+lBUN7H/0f5W3tZI Zxe28j3AVfJMTLuVQ+MgH8vyqhNYT3d5Gt1OkdmQBDZoARLIPmDEkZyMcYr5yewDpbS1ka5hUslw qbHLHBwPUdK0dD0SKO4+1SssjbQCSNpdR05rKxzmpboINWvQLnz7XC+VGwAaLg5GB/M0y8YeTdwh YzJMoBaNdzRHIIKHHBqJR0uaJpNWOTgtNRgtxDZS3s4nR/tNw0O6VFUk9AMHHuPWtb7PfJpUmpWU UF1cxbYW8xxCXJPAJ/pWRof/0v5cBpyG4stU+yw3mowWvlTWcM29VYHJAYfNzgEmrv8AaglsJlnh i004Mo3PulbbkFQR2r423vXA5qxzexXV9p8dtJNazYEcjbTPgdehHtz7VsaXfy6jZ+bbzyQXtw7K 0ATkFTghh9QePaqIXxtELm9l8oxxxyXMMhJydmQBzyelSzRrE0El1IFjP7zyUAZWPYMR0Gev0oLI XkuL3VIol+z2kVq5lLeby6snC4bsM+pPFdJBYyGy+2G5jK+YyooPzYX1q4b2M5vof//T/l4gm02b X57nUPO3SaeLW1hhBW3aRBgO/p0yfpTUeSSSNIpx9lgkcy2wUETk4AJ78Y7V8uZRdrkx8Q61oaXq R21obfVHSFU8kXJiUMfm5Hynrgis6AefqltJcx3D8FxOHAlZf7vPTpxxWU7XsjRNNaGnZOV1GQeZ J5W4FrZ23IccK2O34Vr38rwxvnCI2MzdPJA/z+lQEnZHNavfzSw3BgnS6v5gvlXcieYoCgDGCO/A J68Vd0hM2rXIsfsr28YLlpNwmYcMwPbJPT3ov0KoyXtVY//U/lz1PVNTkntrnzINp3Q3SvzOOF8r YPRcMM/Sp7LU7R1uoNRcyfaGUo7fdhCjBUAf1r5CO6AuadfSbGWzDR2gASN14D4yBhfbtWhObt2l 2rvDQZYMdqEg9Sa1i21qUn7rRJbtcFJY2ciNlAdRyso9DUFxqtnp9nFpUVultZuwCwwplj/eIHb8 Kokl3WF1FDa2kr2kdmfN+0IgS4YAZCFTkYOMfiaI7i51W+kEOyI2tt500kwKh1XjavqTSbSGld2R /9X+ZgS2S3H7+xtZp5DmK8Mh+0R+oC9MZ9c1HNY3st3bzWU0cQt5/OMZba03BAB/E5/CvkpST2NY Ky1Ou/4RywXTIvEOtXkA1K7ne2tUUiWZnUhnB7gYOc471yuoXtsbo2SkYMO8hvuDHHP1NTH3YcpL jztocv2M2jC+uVgd28tVVC457j2qW2t7TTgZYrie9WYhEjjCmJc8bicZ4961la2o6atEn16zivrW 3DX7wTiYK8GQPMUjHX29PcVn2enf2UskltHJdBSGnQsQrDNYmh//1v5qblr1omn0/bHP5RVfNA8n nqG/DNc3pc2oGVlEKhvNKSDG1CPUZ/zxXx50HXW8vLLfq6SQttUhwysnbHpU+ovpxlg2vEquQqFj tOTwMn61lPcWlygUm06SWJnVReYDwo/mRpt54/xpUit5N6TnHmJiJsAYbI4/Q0pJq1zOa1uU5Lcq QYnOyI44GQQKk0bWra4eSxnjuhN5v7stA+wDkZLYwMnpk1D2IP/X/nAmjhj3P85L5Roiecev+fWq kbyTOYVhCxQEBJSQS2eoA9v618PL+Ixv4iGWBYbt3kd388DdGAAqepHHU+9XTp1ojC7wItsQjVSR l8/xY9aSd20DbbGy6ZJd3D/ZtQjIiti6K4MYdgMkZ9eMYrNtrXWbCS2fUJIY01COQQiM7y6qSDnj I6HrTLg+hGNRe1uZl8nz024jQL9wgHLf59Kjj1GCaJ7zLTbCUkUId2R/CB/hTWjuWnfY/9D+b2JJ f7Me6t5ra1ZohstZpVik5POUznI9BU9oLSKISCGN5QMFyAGYnrXx19bG6km7Iy9QvJrW1uXgjeW6 zm2iRd24mteS0tzBFPcCO4vBEpNyB80YIzsH6ZHtWc073LjJxIBqstvbq9v5KbHDkTqHRsHoVPHb oanTW5L+4nuWgtocurhbaFYE3f7KjgVNnYTbY7Ub66lnRpkuN7RhllkhYQsBwMPjBNVRIhge3mYh 5ZNxmz9z8u1Pll2Kg7PU/9H+aqWO5hvCYL6F1MGyONogZc5OW55xjA4q89vptzJayHzZb23ixulU eXGxPzGPsOg96+Mgmtz0DQW4Qy/Z0aLIQsWZghBFVbmdJ4Crs4iLbMxJvdc8bgKtrSxlKXYdbalb zW1vo9qZ1ZZ9gkvrYwNcSdAFJAyMD+dRvZajIZxJcIVhJ/d2/wBxMZzg55oKjPuV9PvpNqFHDqem 8cuK0bq9LMGjhCluJYgMKe2a0p9SpOyP/9L+bN44orbyoLTa32hpZJmzwXwcAHgjPP41pW1oBHHL cSQskjgSRLIDcBeudvb2zXy2lzr52azSefp8UABZLeU7XCgOFOByR6VIbJVtpbZ3YxzLxOnyuhI6 fh/SsWtWarUzbqwhjjheNzI8bgjPOccc9ualurhYo1llBCKAG2qflyQB+tIDIlSV7kW89nFcxSMr KJeQoPzA49f8anl1eWW/ubaG0FtbLbKiOM4yBghfwHJ9zQB//9P+aH/Sv7SF3AAJ44zCHflduckb enpWlFK0q7JpVWRnKlj1B/lXxD3Z6BovLLaJMFZW8tcfNyD71Li9vEULcf6M4AVBgeX64+tI5xUA sEEEZLNI3zsB6dMmlvtTskeKOXfuVN2SmVcjtmgqKTdmMhvtPuokFvavAQzGUuctI2T8306YqaRf tFrNHDL5E5XETLhjn3FBVkos/9T+bd5HsYvMnXbIP9a+C2ccVNJqS3EkbO29nQcquFk4xmvhzoLN lcXVpcyTJEJBs2qMH5M1M5+1od2YJX7A9KAHLYTQ8Qym9usAJGxALnpgU7WbiWGyCuhilmQCeGNy M9MjP4UAMs5bzbbeWkbWzOBK8jkFQPT3roZZraAgIBlkx0yT/n+lZ1OgH//V/nKgv3e4nNoplRH8 t9qnGRxj8MV0Av7yAQzR7VEec25GU5HJHvx/nrX5+dUNJGPZxyYl+ckOxJzyyd+K12WVEhA8yRpT sXywT9aDYZ5txawMocszMc5TGzmmiW7LQi2RvtEpCuX4jQdyfbFAGpcGBS0nnxSNH8gjOGZieMr9 OawLtCjIkvCt8wRh9/uD9elUotgf/9b+dUW6XFz5shZmKhVBOMY6flWxbWEVqDK1xHc3rfdQcRwj sGr4BxaPR6WG2c8TCaWeOOO7t2LYzyw6Dbnr17VUutQa+kChGjQJh45MFmP+HtU2SdxW6Fy1v8RO 8sSqsabFC8u31H+elVUc3BVkZWfd1c5GM96ZMYuO5tyzwyI+xUjZcRyErsLY7VFZKY5/NLiRWfL7 zkjjHH5CsprUXJrc/9f+fjV4obw+XFI1tMsgk82IgYI5zWnG+oyzCwleO5by0+zXSx/vLlmHRj6j gZr83PQMV7xg5+32stsYZjDGI1MqHHVywHGfSp2uhfOqPLIPLGElfOzHpmgCZYpzv8qVhhcN6Gqe jLqjG6gvGhkdbhvJkQkK0ROVLA9CAcUBa2htm2sLONpZHESjq5IwM1BZ2cdxHI0UpeIZZZJMDf3A ApptaID/0P59dtwZo3U48vI2MuM4p818sSwvFpzSSxSkzvEplkwxAJA7f/Xr8/uegb12EWzeVIQd 8QYshw8fT/P41W05n+VlRTGqGR/MO1eB0Hv7UgLlnqENzC00OComaNkYY5U4I/SrM9x5qnyIlEjH DqOwzWUlZ2Lp7j7loYrWN84kBwVxT1vf9GaNWUKfnIz8xPqKxcN2dVPY/9H8IopZrqyYRIyMJifO K4Jxxg5HTj171deYRoxMSMmzY6Pyp4xX5glfRH0BQsvNt7OXyl+UuTsU7VA9amhe+nEbI0iFfm8w jbnbnqfwoaa0ZUdGNW8VGjZmeYM2HLoQJDnBGO9dlFcwoyTuSrbN23byxxwKRsZt1qt0VSacNJ5r kOOP3Ht9KgfTxeeXcyrGY0O5mdcHbj17UGMndn//0vxG2bvKZHENuo2QmM4R/wDGo59Nuby3McLe ZODmNpDjvz+lfmbXuH0KbQy3iismiguY0SfcU8/BLnuR+lW7i6D5l8hJQkZhCuuT0IyPcdR9KlK6 YjKs4JbgpLPGwMTEgA8oP84q/bxw6bctrF5chY0dBbRA+Y7Nu6sByMH+lSBs3mpai0ks0EUWyUAo pbqT196iOoajFKioyJG8QLhfmznqKAP/0/xZg1C6gjktl3vDJJ5rIPu55Gf1NRDUIZbnyJX2xZ+X eu1vxFflk9j6As/YpZryRftonQqPLVsKFA/Wrkkl7p0JSONGJX7+Ow9D68VkNtvcz1SS7uU1CeKK DavkrFHKXMoAHzn0JrX1S5EKRtbWKLcPGkUhXkkL1bnufSgGVrbU4be6WVbVDEi4ZJiQXOOen4n8 KRNRMuoCaEi0EimMhM/KCMN+maB81lY//9T8Uri3iE8ixzM8BfzEMfU+o/nU0Nzb/wBnsV82TM5h EXl4jJGA2T/9avylRb2Po4N31Ole422SKUCPtCrxwPTFZsF7cx3rpNcGaARr5aHO5GHUAeh/pTlC yNI6IuXtxGZ96RiJpVy6KMIp46fWkto9UuPMkhjg+xxLiSZ5wsie+09agyUrXL1kRKwiTZuLfNKW CqfxqlcNfW13cOkSTpt/0YD5SMDnJ9zV09yT/9X8dIru8ntvPeEWiyjBhZuT2JqUFU2RRTRsxXc2 0/KM1+WT2se+3ZXKt3a28quHxu27WVDy3apNLYRvcadcLPDBEipbuwyHyMtz7Zx9amDszFu7G6hA s4CWU4kWF8tCy5dxg4PHSs+1up4Yj5MUbTLJxHOSkfB56c+talc3u2NLULp9Ylt1tMWjwRjCM2Nz D72PbNM/18Li93FlUKCq5RSOtBUHpY//1vxgG1/+PW4+aIjft+9j0PpWvLMtxbNHcQoySJ5br0Dj HTNflcou+h7zdpJENstszW8UAkgtLKPCWhYmIv3cfkPyq5JaaapGoyJGJUypcD5mBxx79BWYa62L I1K3BV4IQ/l9IpU2qSPX2rIVTKJLqWRPN3k7j8oT0/KgiMZLVF+KBGexvPMiuSjESYbjGParVze2 rb47Z4RIr7pQoBlHbGeuKCrzP//X/JSGdzao7pGI4wQjqoErZ55P+NcvcvNd3EqJnZnLYr8nPeu+ XU2dKWERS5OHT5QWHH51HLd3NtLs+0jZJ0jjI34471UVaVghflLlvKLo7ruKJo4/lWduZSPQ1LNe 2okjigtoyqfLu6MQT1/z6V0ONi1rG6Keo3s7ACDZEsJDSufvEegp1jeXN3bMJYfNhJ8osTjA4GRU 2s2Ra07H/9D8hjZNp8jsjzyROdySMM4B6D8KsI8cDyTPG0+YiXYDG3IIGT9a/LJLoe/L4GOjNrp1 vaSKo8y4jZjuPyyEE9P0/KqMN1dTO8jRho2O1mB+ZT9KiK94Iq0Ujc0vSrSDzrtpFjKr5ihssc9w MetSKLNI4p2Ur9tyPLX5WQZ60mrOxTLYSJkWcurxWQ2xtcYOQT0/H2qmFu/LEtnGjWse5pLeEgyO 3BGFHOPvZPripktC4Pof/9H8ppLzTC1sIfmuAM3RdRmE+gHp7mkXVrVZboRi6uVji81liQuwwMdB /IZNfjc1qfVRdnqXNLks4bETuktxq0920kxlAgtba2wCjMOu7JYbfbtmroMGoXbxXCSNAAZ1W2+S Et2GfT2rM1TTWhDJLAHdiDHIvytn7pAzim2Qu55bqILbJbyDMDxuRk45D54B61hZopWvqb2mSDTI YWuEgmMspjlh/wCWy47g+me/1p+pJp80KLIBvZsxLu27TSNIWcbH/9L8w7g2MGnoZdEkvL8zYgu4 LoqbMkYUsmOR1yc1RgtpJkllmkP2gx+XNO3EkmOxr8PPt+Vdia18tYoo5oWnt2nwdr7eUIPI9Ola MN29zPqMZW1jgtIlkgt8bWOTjA55OT+lAWWxsSxyWVlb3JVJjNxJHFKrSRgjqwzkUkUCW+nyXKXR U3TGH7JbS7Jsn+Ir6e9JxTEopG7vjgt4I2m80iJfNZgBg45B9/61Ykv0S7s7+C3FzLbxhhmPghQB tz06VgaRV3Y//9P4V1m/SfR3ENwv7sb47PzAgYnkgZ/pXN6ZJZ6HGL+3tVFzLIsuSnmYYnnj64r8 FlFNH3UopbFp0v8AUbrdalrRnPmSAJtgcde/A6HvVovayqiPcFSHMcgRvLmYr1wOvrj1rBq6sZ2j fzKUphuTsIcxI+MyqQT+ddKzRXq2MKLmeGEW5Ix+8A+6cY644/CsWrOxRfstOjeVIBNbo0xKKLiZ Yfm9MmsuKK4U3jEeZbWrbHkQhgmSQOnrg9K55KzsGx//1Ph+Z9Pjt4YL+9RYUPmpNO3yRZ9+3WtW O01DTmWe5jt5LSZP9GYuJRMD3x2yMV/NzV1Y+3ptFCE3NnKjwKkEKDyiWX5EjPDADtxmteFoZbiB pBFPYqjvKrJlnfgxFW7bSCfxrA6VrsV7CHULrU5ZLWRXt4YCzRkhSmCOcHrxW2ulRzqJk8tWV9pY yAEkj0z0oGnZ3FMN1bRx/bXiW1hnEhKjzGVScBjjnGR7jitaC+g1JJ7e8WWwikiKJPbgO/8AvKCc Z696wkrOw0/euf/V+Wbi2gs4PNsLV/JhAiW4ddplPuR3OM9aRJ7hkVgkcSRjcQow0ueuT1r+Xz9I JpJxcRiM+ZnG5VdcRjIxnPrwKlD6ZZ6eLWMqxkfNysg+ZXJznPpzxScU9wNRJFihSORdqsAVz93H GDWql80KlozEyLwZI8EEgdqOVLQDJa/tId6lE8yYkAsOpPJNaVrcRW9k4DiPzjtIHyrgc/r/AErC 1tAP/9b5xltje295dRSpFc2w8uCJn2vcFj95R046/hVjTmuLvUIXvVimdIPL8+5c7wVXA4Ax29a/ lc/SDrlLKVWY7rcfKwQDcg/2axmufLLALwOGYLyP84qJrS5cZWViOWd57aSEhZYXILKehxmrOmPL IHn1NrVIA+y2ihkw5RQAA3of881zTRrGTa0NGA6HdXcqXLARZEc/lSbcKep564/pWRBJdQaw0MEN tJpwYm3vJHK3cRXJBHbB+tKML6sabTuf/9fyaa4MpuFX93LMCy4TMbsOu70rPuZ45Y7GyS2FkXJF 9dGQvvIxjA7Yr+SbWlY/UuZ3KTefYSBt0l3htq8cvz1Y9q270SSxOJ4fIaVFkVU5QDAA/PjmtJOy JIdNIt47vYYBdOgWJp32bFHJ25OMmq1n9ouLgTqix5by59vRwPp9AapG0PhReuruZUW2RUVVchyw yXHb+VRXl9Lo9tHJAzRzSsoiuIl3OpzyVz6d6Cj/0PGL95dWggm89C8UvmurnLucEZ+vvTrO1uCp eFypK7S7HK8V/JrimfrBbSeRCd2JzGM8cA46k/kaVZlvnUSqlu+C6yA/KwHP9Peo5HexpBvYq3kk MclqrwvJ5zbRcAfuogOu4++ePpT7y3s1QHy0m+YfKehFW4prQ0GWkM8sU5g+d1YFeP3cKDqD70jW 0PlyQqkcs5+d5JRwPb2FZuNlcD//0fILe61CzeCGWz0y0eECQrYXjXcM3OQWJ6Ejt2qPSNYvEa9S +ukWKS4D29lHETtbkEB+Tz1596/k+1tD9gL8zwuJkljTzHH3mGHT6VhxsbOFiY9yO5Thc5oAfEJL qSGMXPlqp/1LAeWc9OT0q5LKnlMPtKrLEdsbY3qPpz7ULQatrcSO1gtkjDBZUSZrhgDv85nO47j6 Emq1yyxD95D5MM+du0Fgo9Rn/PFbp3VxH//S+ddN1SG0eXyjvuskAGMMki5IAP054rR0i2uJUlDr HbESM8ke/qWYsTz65Jx71/K5+vN6pEl4t0qqPL/0b/nuG+8QegFUrdN8klxbIHaECSU8HaBgZqoJ X1MnuUtRvZ7fEMUR3XWD5u07YwG5IPTtik0+YhZRu+aRiSzcHPT+lbWRLaW46XWZbK4iifHkyfI0 rdEz/jWRf3KG9WAvOzTSfuDFA7Bsf3sAgD64600ruxi3d3P/0/k8393p9+gktnlgkXy2IfmPnqF9 f8at6l4qazs759MsoL2aFBiG4T94TwcHHTg9s1/M5+oDtQU3FnZ3JJzON720Jw8YxzuyOnPbJ4rm oHt/P+zwERNbLvnU/Kp3FsHPrxVKLexg3dm6ZYZ0tbI3M1nDPulcq4U3BTJOCfbA45pFS089zAhL uoTb94tt/rWijaRL2Mi2li1LVobR54beK5Y2qyOjTRRSKDtXIJA3HgntUl1p+mRSSWj7TIgZXeXE aRygkZU+2BzVGB//1PivRtev28yxcq6aXKEiuWhW1kuwqhicjBbGcZHpXQWuswQXAuLyFpYLybZK seBJFnofcZIr+b7a3P0SaaSKeqXzackNzDa/atO1a6OnSyrHm4hPVRjHA7nn061niF7W4jgFpKkR +dWYAbh14Gc1ly2lY1wy5YtFXXpr+yjtr3TbmyXdmN7QoXnz/CzjptP+etYUzX66Zczt5DXbRb1t WJSJ2PGFOOPxr0JQ92KRg29jCs3vYxbxz2SSwMplVlGNsgIyuf5Vuam9vLc22qC3eJbJEEVlb8Y2 qFKEgZOTzk889aap9yT/1fz0kt57sy3whWKN5vPMEj4wSc7eTk46VHcTRWl9cMln5IliANszF8YU dCeeTz+Nfz8lZWPv7Eb3Oi3eiQXJ02aHVFmkb7Qsf+kKMYUH24I/GsnS2uonmvdkXkRDcnm8urtx uC+uB+lMEktjQtry9u54tLgEUkV9MBcs7KksBx8pGffH51n31/rOhz30QvILqJ7OTThGwEa7CCuQ 45yO1aU+pUVd2MGJraxttIW2eaS4njW2uhKf3MLMRyCOT0yTj+tX7zTNO02KW5v7671S+n/497GB NljCnfzGPJ9AB1x1rQqb1sf/1vzQ0XV5bFZL2OaS3d1EQtgdyS9cbl6EDnr+VF1ey3MssjeUsklv sWUDawb1IHH/AOuvwc/RZStaxCslxd2sFtdy4t7RWEaoAu5n5LE4yTx69zWXHepa2503ZbyRRZVp JIVN1tJz970yKqHxESlcsHZDGkyAPGyEwsyZRmHY1y2pNe3Zt55L+Oby3INvv23JY/wlem0evvXV T6mFSVtDDuJbqGVAIFfzJNsiFgNg/vY744q3qcgvILFJoLVfstx58cKQhRnAGf0+vWvRoO1kcc3p c//X/EXxSJ7fTbvUZjHFbtci3iA42GToF/L9a+IPHmorq11ezadbPBdJMNPcMMy6gIiQSEzxzk5/ xr87o9PkfQ1JWPjzxTmKaZLm3ZGNywV5AUaNsnIxXFRNFcvFbzW8SPayGUMi8yjIwXPtxxXpU0rH DN62Lt3ZTSMWkuy0UkeIdo3GH1GK73QNLtYtP0+O7a4jiiuSxnwAiBsdu5JP/jwrsj8Rxz1TPQtZ t9MDw3QaSayt0RZEyqFm4HHXrkdRQIre3sZ7OwsJ99xKD5az+Y0ak5LlcDPOeBVtJSRha2h//9D+ R7xJqy6dcv8AZ1eRpJ/sV3J5QMgXftG1TyMNj8K5i48Qm2vrfz9N1C6gQqYSbKSSylYcrvcdD0Oc /jXydCd7JGtV2qu/QqeNl0/VrdBcm7tClr/o/wAo+0QmVQxMZzxz39K8E1aOOGDygr3b2wXyXmO7 BGACT69817FBqyRb0iy5p6PEtvNdRiRJFxc2vO3nODkVq6KILG9kjQpAly2BCj9T1zt/CuqLu2c5 7l4Z0W1vtK1JdLcWkhuBcS3M1wEuLktwdqNx/CQcdhXLautyl5dW1xroeWNkSOCzhRDCgHQuvXOM ZPWqG3c//9H+M2zGsaldPbWcEzvGpIMr7fPAHGwdyR2FPvvDVtPc/ap2mnvLcKtvZOBELVlzubce evY/0rmuloKXws3NGl8T6zZXlpePpNncxTyFdOihjgneOMfI28LwWA/hx16Vyl+3nTSabqIuopbB ftEcTruSMsOWznoR3oWqMDQ0K4ludJfSrHyI7GC5a7x5SxSTTScBy3Vh14HrWNrU50y7hi1B0823 AiknkwAG6F9nTBPbp71lL4joSsdD4fhv44Df6pqM0tu77baAxiI3b8HCqOWOOa75Li1kjMpmlLSI oClNskIHAXB5FSB//9L+QC+EbiaGa4E1rJyWcbmO3lBg+hArmpdTfRIdHWC0W1uYpze3Lynz4pIy coGB4x34ric7qwHQAx3f2hW1FDBqUI/tCK0QQxLGSGKhOBgYqnFY31veW9ppNw93p5ceVKz7d6jP LZztAA/wqAJdRm1u01W5tIryGZJ4E/fRsJkwTk4PZhj+dVfFrW2maOl/HC15exbXDLCXwDgEADkn mqvdq5nN9CzpM9vYW1pqeoQajZC4iE8SPb4lkWQfKSnUd6qhdChlml8PkzQfbCstytw5KyMAZA6k 4B5+70pFQeh//9P+O4JbJbyXUCtcXSSCeKV1xskB4Ge6k81p6dpV9cQS2upLbSPeSC4QxKFIMg5V j6HIGP5V54ne2gq+HbnSLaa8uVj88S+Vp6LPgqnQ7h16elNiuUe0uojAlw9uNk8ExKsu4jDD6flQ NbamYtiY5LprGWORQyPPb+YdxzjhFz83fOP1rah1KzaRomiMQB24K7NxHoKAKNykmpTtaWN2LMsf 3cMiCSW7/wCmYHXn27Corhb3Rw9pdIkUllL5Wy6iw8RI5ATr78+vvVKTSsVb3T//1P47vt0tvLlb a5ljl4+1RRlY27nB7cdM+ta2mXcN+bpBFKbezRTG00nmSPk4x+HHWvPA2JJJbKCO4jIktV3NOZjx AmD9wAckHH61Vis2uovt9jdPBLO4RPtQZWcA/OqoeeVz+BpNXViWtVYtTJdQrdWE7Wc1rNbhYfMh INuxPOOfw/OqniDyo7SwGmxyCW3gEUyI+IgVHBHvxTavoyiKxhmkhkmnHmPFB54aQbtx6lSK6LR7 1L9jHBY3UNxAxEm9D5RUKDuU/nWfIzOp0P/V/k+luIkRzBKsrxgtKI+TDzj5vTqPzFZFpLcQXH2y 0mNtdB8xzFd2ATycHr1ryuRmcF1L97oy3GoPHPrMKtq1qJGnhUBEbknqOG9jWLaaCml6quvJI0zQ HYyzwhJdS8o7VVl6Y689+Oe9FPc1UW9jropI9ciuIiEspUXz/I80hpsMPlXj3PX0NcxcI8N2zZRV DAK7Da8WBgjP1yaJvWwNWdi/fO0jWzTSTTrOhidhy0WB978f6VFbxWiW/k3JaOKPLQ7fUD098DNQ Ci2f/9b+SOz1O3ukJsnkiUTm1uo9pCoVAyQe/Uc9BzzS6hqep7oEi82a1jcRSTryYh0Ut7V4k9ip R5TQZTc2UyTzqBje73GApHGQDjiluJp9DttPlcW+zVhJZW1vEu/y/LAxIf7uc8E+lZGM1rcsRR3U dtJA8Cie7t8iYgiORuBuDD6Y47VkLaQWc8FqksgeR/MnMY2gn0+lPlZyz+I6I21i8Bt7S8ne5jjM oRowenJX3HWucuXhjaCKV3G4DaGTy5M454qlB9SHe2h//9f+ROOy1e1W71rTr2GJLKZSLYgGS43H pWzp1jYbhrgub2W/1GMQ3Qu4/J8kqegHpnP/ANevDcUkeZJtOyLMszRSS2kMv2kwHe3l7vKk74J7 1dsjcyWLTCGENbtvlSX5Et1DAA4P4Yqre7YtE8Ys/wC07S41a1intYLqOQNtKrsYgPh/4T9Patvx NDEs8slo0UdtYsZUEjCVmVsBNhHXg5z6Vja2hrC9jirKbWLq982W4mi06Mqpt44PlZeSWJPcnH4C tS4tZ5J/MZLOO3dgySpMI5CR03knA/Hmgs//0P5SVv47W3nnuJYMxSCIJHIJht4AGR/L3qNYLa6e Dy2aHYxlIAOH4PBr58wSu7Fe3jlubv7Nby3DZYjy1z5bZGMYFOsJzDc3MclvvVGMSs/3mIPP+TUT 2FYsTxme7Fy4QuMLHGFCou0ADp9OtSSW0izST7FRHXDRFt+fqe4qLe4Pldrjn060kMU0M3ku4xJt BXy36ZBqrmNNR+wzW0Nyj2+y2unl2GKU9N2f61jL4kgirux//9H+T+y8ONNdpdfa4ru5g3SXXlcL EEyRGuc5yOv1raZ4bxLif7KttaRMkU08Q2+S2OGIH94gmvn9nYnlWplQ6rFNeJbTzH538qKXyWli DDpvIHAq9ftNZSJLeaxLNJcgw3E+xU8wAg7QoHIAwPwoHFWVjSGveG7e1Mdtpt1c3Mzqs0ix+UI1 UY3hz69xz+NZrJpUzxTPdSpbMXR2iUSx3TAHCMx44PoRSa0Yo61LMS/uLjV/s1rpu+6v7IBY4VAk AiB+7gc88/pVCJZ5tSRhFII4xtkif7sbAckVrBXTLas7H//S/lYvglwlrDcTmBJLgCJuQMjtj04q nFZX0TmQkCJn2qc4TA75r58CC7gkAwy586Ty42Rs/Un0/GuoguNUl06GziuEgSybJMWGVRnqB3P5 4yazlJ3sBUczI86LdSSyzR+VtONzDuSBzz/Ss3SrC00+8tpJLJrlYmYtKz5aJTy469/b0rMTV1Yr ya00OqAWu7cs5kgUjLRAHKjHersVld6vdtJJPEktwWYmT5DuPIz6ZPegz5HfU//T/l4WCRIFja8F pPGypJEuJI5EyOFbp/nrXO63JDFfLAcGWIhneIcsCMc+vH8q+XFZLYrQ2s5ImyZlf5gAcF1zyK1V 1tBq1hEtqkjWhG+zWDbE4A+7Jj17810DMiy0+J79r27gaFZJnDWlqTHGcsflJ5JXofwrpLiaAMTB b/Z/OgNtIqjCoo4GAfp1oFyo56dr/Spo5tHa52kAMypuKgD5iW6jPI/GoSs+t2k0Em60dBvS9x80 DA87c9/rQOyP/9T+Ui11C2htzbxXt1cuZRb4WLIOOCx98+2K6u+t2WWytrOKCSe3QTGfeGmOVz8y ngEfhXzktdAOXurdnimkuHC3AclscF8H+KrVu11JHG8crKR1QN8qnpx6g1kS4pmdpwuG1m/I+0gx W4M2VJQZbAJ/z3rdtrW6gebM7xs2bxGuWy+D0VQe3oKLdB2RZtdT1RraOV/PsXWVpIyh8qTHQ84z ggZxXNymeW4e2triWETMS8kI3bG9dvTNYWa0Gf/V/lCutDmh1Gxv7O9uY7q1iMkkobyzIScEcHBz 1/yK2I4YokSXUDct5rn7K8kJkjIJAdVbHTNfHgdbDqVnodjFdaVpVhcv9rDz200ISJlPytn1x6Hr j8azbjWba6183a6alhbTRriPS4CsNu4XAOO2cUGLfvXRly6LqF95hbUJ4EkJJFvhJOTnk4yKfHYz WZMWq3U0gX5rVlTKsuBtDH8OtJO4+d28yGWS31ya5jcNbPYrGobPlNOp4+X1AwM1taS91IPsturS wRkquPmLY68de1XF8r1Jbuz/1v5dmswJWkckuHJC/wAQznIrPtoZoNVkaztpL1fKaW4/vWaev0yB XyjnZ2RlFXuan725Yqu3d94k9AB2xWWtlqcuoNP9oQRxgLHCn8ajjA9DWRoko7G9ILCKANK9wl48 yxFoY/MbaeAwHXg+vHNVxaz3gWyuJmuEIIKqmXnxyNyj+lA7EenRCQTxSW0P2lm8q1iLbY1A/vHH XjHGetX9alvyLaKBIdPhs1CXFqse83DcA5J5HQ1na0xU9K6R/9f+V+7tYL7V7SAHMnk7ywyAjDO3 2Iol057W8trS4RkkupiiFYzvPcnHqQPxr5BaO4HT3FxHDaWNva2WpTztP5Ei29vt3KmMle5PHPHf vVlNQjeR9Pt7PUJVnkCJczEYjUg/K4HPbB9M1cZJKzGkadvcwNZTyyI0UluzxyQBclQhI3Y684zj FY97GLgWWpWsAuYCpZHZflBBwV/QUOfRFRjfVmlb+QHtZZ9PjMs3IwpO0DqpYdu1K1zBbLqE7KRM B/o0EfCFe4Zj074rMtR5Xc//0P5h4tOWby7iRFMqt50Db9/kFlwQD+PetKyJM0qyiVGi4EjqQsnX 7tfHPY6CnqV55csMvkyXDR/IQrErBn+IDvx34qD7dbKu+Sx+1TzDyBsTcUU87mPYCpje7RUErNoj e4KxyRGNGuJwI4AwO1ef0P8A9etawha3KRscK3zFR0BqzOHwo1U022u7h7ifazx7WhL/ADeXt6EC sufUfsjXcs0dzHbwEBpPKPlzDGflxknp6dqBtpbn/9H+Ziy1NL8FrWSb7Ix+Rpomg3gexp8EkMdz PNHIz78Rop+VFYA5x+Yr4825lbQsQvunuJLoF1TKRj1yv8J781kmzFyUkDt5DN5k0dxxLFySoVfr WU73M2/euXkjea3n866YXrzJ5MuwYWNcZHPHOP1qrqqzwLHOzfaLZXXCRk+YOeSB3x1onfQJO7L1 y+VX7OJ0zEAyyR+Wpb2Pcf405oLuwhtLyBFm85yj2yOGZ2AHJXqBz1qLW0JP/9L+ZW8vL+SWMq5g cNiSPA2kHrnNXlufKXzFLfKmSByCa+Ikn7QqStIoprIkhSdxI3mLuACHKj3roLSeHVNOiuInLoCQ CwKsNvByDyO9Ty2k2JqzsZ2bqN3dXCMuRGeqn6+3tUqRvFYQyXd211NAxaPjaIwScBR6cmmOC94p xQT30cshdraUgiPAB3c9D9RWja20NvEsMiqjD5nIHGacVd2G1yq3qf/T/ml1Hw2msIs7ZQQSAw3a MQUIIPrUl9cLpe22ik85eMO3B6c18eBSklS9aICaWNg2P3fBP14rVY3ltbbcvcsASm8YLe3pQdBk XwuHs54IrVUkuV3M/O5G7EY+nWr2kQTRxbJl5gj3OxbCgDqSf89aBXS0Z0Mutg288Mz/AGwogWOB j5gjx02/WsOeIzTpDHuRJFBUIdgUD0NAz//U/mweOP7aXWJElEHkbymcDv8Arz9ayIJYoLiWNbuV /JQgjhsE8j39RXx51JvY07C4guYEnmthFMm6PfgiSUZOCfritCyxHFOBkMrllDjHHXigks3KQS6b HeXCqsJUvGqkGVWIwCMdzxioBcR2NvFOtxNHJOREsTj5Gz69/QUFRjfUp3NrNJcwIALUx/OV8va/ PzA+nIP5GrRurW+kvbW2lH2m0ULJlSoLFQQAfoRVK9nY1krqx//V/nAvGIsoobmUq0MeQAeC3Gf5 Vn6a0Ukgf5ywUqNozu9q+QV76HYoWep0UUzpCDHsSWRyhSUbQFHcflV2USzwtC0zCHcHwh28j0/z 3q4RfUvQxZcxTeWXk2LyAB8p981NqtyGsJbSPgTqoZlwSMHg1mZuTuczqN/dzW4UzTIIIlgWeLmX C9AOOtbOkwJcrLJLIXwuVZgAE4xyaA52f//W/nJW2h2NawELKxwsrYJQk8nJ+tZF3Z2lvbS2wkle NHPnSplp+TlirdcnNfGSjfVHUpNIrW180+lOr2syPasR5j5aW5UcKfTJABx71LDJfyWiyWkE7lyA sUZUSxdySCaytYUVfQllhukjaXz3WaUqfIYBvKxjd+dU3WbzYUuGFxJIGFvE+Bsxk8D2yaCoxalY zLC5uHv3tLSK4KLDLNcSTwmCKIpj5VJGDnkjucGt/ToJ1eS7NyAyMGKTEeV16Yx+dQ3LmstinHR2 P//X/mw1fVJLqCM29qJsTFZlRdoYZwSPbitLTYLTURGkEqC+t8+ZaS/uvLAAIOTx/wDqr4c6LW0J 3BZJlaVoWUHJhIznB6Vn+XK8G9ppVEUgHnLxn2PGOaANfQL23h1NWvN00YyMqcEHBx/T8qm1uR7y ZjHCP7sfHBB5yTQBg3bXNrLp9uGRRcv5eA2fnxnGPzrZsPMhvpJbt/MhWLb5R4APOTn8vyqZJPcD /9D+ecSadB9oe2I8pY/tMrLHtA4Bbj29aoW97ZXMPnJK0kMmWEg5XPPAr8/OqKuxYrkAFooGEKPn zgCXfHUDHap5bmaOO1nhLrDJcYAf90y+uAeR2/MUGwsl2wlZnYy7n+YKu4g/lWirfaHxc+dDAi4V UTGD6/yoElZtmBcXNsl2Y41lkUEAkjDe4rQ1CRZ7Pz44X2q/lJMy8qRyRn6CtYLQZ//R/nFivDHN tkV2IXej/wALeozUts9/OWurdMQySlZd52iPHoe546V8Oei01uXIfOu3uFEDf6OP3lyDgx8gZx6c gc1oWWmSXqajeRPHjTYFaXznEW7ccYXP3ic9B6etYyXvWEW7NLd7Z9xUPJwC42YPQVg20SxyyvJI y+W+4KDhDg1IFu4RdRaCOPzAS+4gdyOnfmrmkOXsr2CSKU3dtIUjAHD4PGTn0rOp0A//0v58JUnh jVkXfO5CtGedmSB19v6Vt2bXdv5U7sQ8P+rYDkdq/N0r6HqKHczpmuLuQQ/NOkshHy/ciPfNQ28V oNzMZpY0yMQ4IDD1/Wi1tDS2tzWhLlJXjgm2Z2ruQg/jU1jp32iN3muBasj5fDAMyfQmgzlB3ujP vdMQ28iw3kl5CZmLyS4KAZxtGO1Ptg1vEtvDKhb5WGGBUDuPyq1BtXIaa3P/0/5/Z5wsrrsLMB26 Zq/Yo11uit75bJGAjvAzCNpVJ6An3HbNfnLTjoejZvYindUluYS0h8v9whc7YyfXH41Jp15DHH5U mHiEvllwflGeOtCk0UoNo0ZdOZTLNblEgDZUAbd5zyf1qkEmhbcjcyHBDGk3fc0hFLQmlleVI+Ay qwDHbxjPJqOZQ52xBo8AYYjC0joSSVkf/9T8HhcSWts9vLN8vUFDhSexqFIrhbU/a5TcysfNUxsA CM5Gcelfm1le59AXLO7tbuLarSxyqDuhaIxjHqM9fwqKKe5t3hhuZppLcOVCAdQx7dqUo3LhuWZr cTm3jgIaWKXeingDPBz/AJ7VYn+1xXECzcg4QZIUKO5JqORmpPdumx7eG7LNcDDSR/Mo5BGe3XHW taK6lttFGnbY7yWSbzZruRAkxGMBAR0Ht61XITyK9z//1fxZn82z0gWbWkUjeesytICstqCP4Pww eaxrTU2i3SNIXijdo1V/3bKwyDgen86/NWvdsj6Rw7Et/ewX0A8u4LXIXzUiYYVecHB/CsuCaS2j O9jIGbcQx78cCoimyHFrcvQX4u0liiIgmQAsg6sOnH5VVltZpFdJMbRhlJPzcd6i1tBG9ZXsKwTe ZGnm/ZGgiMozjIxke9Z0YdhG0ruqdTgfORQB/9b8PNKv/InuA9w7o0mY0nUBgPQD+laE0DSXKXUk UJidgw29QvXn/Cvyya0PoC/dXNusSPaW7wyRn55jJuWT0wO2OfzqCK6vr4P5tyywceVbovcdSf5V kPTqMFwtvHPHcQrD5f8Ax7srYDdySPXrToLyZ8XExZhMq+QeihRx0/AflQOVr6F2SGKeTzLpzHFF bnyBHF8rOP7x/GqsgZbWNvLTzk+YsucH6UEn/9f8WrWNNttMrOJHhaVoTHsSPDY4Pc9Dx61chiWK M742wG3IjcBye4r8pjLl3PodjUubzT5FtIsTQzbBlJk2RhuwBrKmaSXVftWVfLbWt4UG3cvGRj6e /StW0lqXzLlsWb6d50KR2yqjD/j43ndkdsdqLK8gS22XsDBpR5TxDkOOmTWBmSk21nZMYRLvDEon UgdgOaW0vpbmF4lXM6ruAbqfYmjbYD//0PxXv7i/lBURhZoVISJmwrfl2oS2uLWG0mWOH7RN81xb wkhYsde3Oa/KG7nvS+Fj4xJfPLdWtx5Lr80MTLuVCB0bv17VofbrtzHvfeQm24AGQW74P1oW5iPj T7MxvVt2heUbBcDIYgfw/wAqs2OnxTSNJNLjd8yq3HWtwFewFpcXTidJ4reQeWeA2D1H6ZqlcXEl jcLfPFcXFqXDx2keNvUZ356jFBUXZn//0fyS0bw/FqdxqMsNslufsZv2IUIgHBIP0B71zuq+YsUt nHExhlxtuoz80ZGeh7ZzX5ee3de0MzT4ZRKkctyZAx2gAbd3tn6VY1GzvrSWBY2llt3lzIoTdsX3 9P8A61ZTWpqSX0TRvbeVcAJkGfs6DHAHero0u3ulwzyhtmdg+43ufeoApSW72AEVvI2x/usRgKR2 qqlktvdtdNMZXlgCuvTZySaAP//S/HEak8IFssLyRyDJkAyi/Wp3t2toUkjbb5xDPgDLj3r8nPoU lZj4ZnwLeNc7jzu4pg05TfxvLK4jXPyqOpx0PtVQ+JF8tqdy7c2cFtb3NzYSzbjgfZPL8yIsP7vP fNRC0uI/KnljDFY1eVlOVXd2+vtXU3a/qTCPuJEOsJCUM0cqRkxgbQc7j0qLR9TdLZbGZSuCSkxX bvyfyqJbsmUf3lz/0/yRF8LaJUmO8O21A3IJ71Pbaqj7rGOOMCSM8uQgGMcc/Wvy2TSPoXFuDM29 gSS7V76RvItYQsKxOHC56ADpjOM/jU8kdvFbERs0TTfMrjByPx+lZx+K7M5aRsadhI4tzHIiurcK 5NN1SJRf2dkBczTbPMjjgRpFVWGcnHA71JoxqpulLHZPaiMpJaP8pRuf3gPUkccHiqGmJHFfNNY3 t3BcQ7o0kE3kkoeoODjnFJ7MqG5//9T8nFvbWe5kia3ihZ3/AHhCBfMxxuJ96rRX1xZ6mtrpkKKr N85XIDLkbmPc9uK/HJpvY+oNu9khF35NyjmSYAzKq7A3fFXxdfZ2NnZWssULYkGV37QOMGTH6Vla xcHrYu+RZySlpYDexyExywo/lGJsAhice4rPvrKTSbRorSaN5p2FwDFiUxZA4b3A4IqJ7Go03kly bSznQQvARLJfxRkM2eqt2xVpZLSVpXeRZxBMEjgIwzjkhh+XX3rIuG9j/9X8xJ5dQktludNSQETm KdVQuQBnjHvgVnLHeXLqPMjjkERP2fIhEh9T7+3vX4efcGzbaTPELF5HRYUQtekKfNkY9cDpj39q jurSyuZ5bG3uZkvmhWSV4gPIMTEjGf7wwfzoA250toI3csyN5QDx8sXKjHT1NMtVR7b7XEm9A375 ZfkaI9BtB79KAIPtNu6STXc3k2SofNmC7wg9SPrTdKutQhsLloJjJaGTELSABduRwnrXPYadj//W /NwefqMsbNCssKjbsVSZd/8Au1p22o2rJcW728sT25EdsQg2THjj8Pb0r8Gex9vKVtWOl1O/WJ7W KX9zKoLA9YyDx9KvaBoVzqWq21vfy20dqw86a/kYJDZgDIZ2zx2H1NYGN9bkl9bC8vMWsxjW3YxS JHF+6k2/xB+/4UmoQT2dna3LNdNObkRlLK2Zwqr/ABMwzgHHPH41jNe8U5voMuI4tRhDyyNBAZzH HcMu+QOFyFC568jPXGa17KWAaVaoquLtYtl6Mn/SGUnDn6jHH+zWE007ilK6R//X+Bl1C1vFubO+ shJbeb5brJGCzKMZ2n0Of0rRl1S1nsYLqWGe1h0q7L2YWMupiAwuUA6Lzxg1/N59nT3NqPUv7QST TQ0ZXUIw0l0dpiUEgglv4euTin6MtvBbzWd6T9rFwYo0hw0DxjIDBuxPFc50U97CCwaIvNBcrHmT GY+WZR/e9qvWywBZXaN/OmG0XMTYPHqO/wCYoNSjGDcSR297eywWtmu6dE/11wgIIRc9Ca35ZYrv zZdNluvscMQFvZ3IAWMEjLE4znPHXHNZTWoH/9D5LupJo4bWB7wSKSJRBDJvVcj+P0PPT61aMkrf Zo3jSS2DYmCcSheuffp39a/l8/SBJLyJLBZD5u/7Q0ePKLZUYA6Z9/0pl7NFHaQbwGluGEdtuQ4l c9FP0oA2ry+FrYW6Tqk94yLBtjjIjjcfKFXHbpyf/r1dtoTBC9rO3llpBLNChBw2MYzQZ8+mhRvL S2W4V1AdUB8tmALrnrUFtpt/qKG3hZbq380SEx/62PB3Y29eMdaxknzFKSZ//9H5z0+0jgkluLmW 4axjAQpBH5sgPcj39vrTbWWFzMLaWdgJ22NdQmCUDORwe3P09zX8s8sux+iylbRGo+ry21neaeLd bq6nVXjkLbZbdVOSy/hn8qdZ6ja3GlvG7SSXCOuWjg3PJ2bcAPUDoOMnpUSTs0Ln8jHtJSri3v8A zE80sMwocD2Hpj3qOeye60+409JXjuUuVlSdwQ6x88D/AB56VyTXU0hLZljT4Ht0dDknaE/e8s2O pJ96uxPa3P2d2mKmK4/1S/Jyh9Tx1zx7VUU0rM3Tvsf/0vBxeS+a0cfzYJky3GAP/wBRpb2K7kjh 86Bi0yfaIjCNykDPQ/gfyr+S5Rbeh+oGbL5nnQ3lzqd5a2MOJLmKOITJLtB2grjIOSOh6V0EWsQ3 E0VtcbgVi3W7MvLqegz+HSk1KwGZcJNLqcjzzf6MyKkcKx7TGAMHnvWnaW6W9wZLK5MvnjcscrcJ tHIwa1inZI1UbRuytql0zSqHLmUjAEUfAx1zgYqgf9Jt3SaWQyBsW4c8RZPOB+FOzKumf//T8Lkd bRYhboZi0ixMrMEZQep/+tU7XUkMiwO7LbycscHC5OM1/J5+sEV88kb+RaNH5L5SSYSEB1IwQKbb sYoI4YP3twpyZXl/dKv90cfWi3QqL5XqWrvUYVgSC4mXEhy0QU7V7HmliFtkRrOZolbKuv3WHPFN prctzXQvSxW9osMlvOrR3MbG7iBKlMH5c9jnGaz/AO1TExh+x+akq7JGXG0Dtuz2PtSDnR//1PFQ 8azsPsywSyLuMS8lE/hJ/A1n3GofZZ4m+zlbVdxa7VMhH+Xhm7cdOf51/KKi2fsBqwSfaoZHjV7h xmaWYKXYL2AA6AdzWRdPGtpNKHbEY3O2/wCRR05H4/rRySB6K5BZ3EVxE6HasSRAg5/eOx4/L+VE UcayBYQFiEgMpP8AEO/8qbg+gk7q5uPNAtuUiyoRS4LD5gB7e9YVzetc26N5jMuNoUg5T/PpWkVZ WBtI/9X5isf3W/ywySsC6F48cZPIyKaklzEzQRyACV903zFmfI7HPHb8q/lizex+st31Zs2MU0Vs 1tJcSSpkuPNbccn0/Ss947q1EvlybBJlPmGevfFOKuzNzS2Ekv7y2jgt0eGVlXaRMofcCPmKjse9 YN8t5DPDfwZkTAiuLYPtBBYZYdgR/StEvebIlJvQ6KRI4yikiScqHSHIkCjGQSR36cVXlupXvYLi 5uJI/wB35MTwxjaNo9f0rSMXuRdI/9b5Tvb43XlSLZeTsumtnup5NkrjvIqdSOOCPUVBqlvocUcl rHeaiZZYhi7gtlVi3TLDnH17V/M5+n8ytcoQ3GoPfWFpB9ovXhhW0iaWIOGzwAccZ/x7VpXCWljq FwZoVMZRY9j/ACESgYfOOMA5wK1gtDArXZW8e0VnjWO0DG3CIC6lup3fpiucuH1Br+GKw1WXS3Le VJMgTcoYgEgsCM4/nVgOs9FtIb65is9ZuXt5n3SyzorE3Cj7wVeBn/Iq3qNvYS2c91M4utUSUeUj OQsIHJcdiT0x1osKyTuf/9f4Y0bTLWYXGpy30iSKvlw2rIGVmJ529weOT0xXP+I/tjIYo0llUOGj ijYhpSh3Y4+lfzlFe9qfpDV9GdDpYv8AULS0trm/u0hiYTxWO4hInIxkrj73OKsXx09bNhps98+o xko811JmNXGQQij+Go5ffRvRhozJt72SKB5LiIGMEr9oYcBl6rn9ap3k2qT3FtHGIzDcHmWSM+XG i4wPY/8A169RwfLE43HV2NK5XVQIJwIV021URxYZVcN3O3645rLuWv7SI3DRQG2mbbEWfdMWIJOU 9OnNQ1Z2BQuj/9D84HmuN0N1cyF/sDGZFTKQrnIIK98A9D3pYbu3u45JUeWVXYtukyG5JOAe3Xiv 5/P0RQ7mnaJY3sN19kKpNZ23nXUUkoZ1xxnHbOeBXOwTC7xHGfIDIW9cN2GKCXBoYLTybhLuZyBM xjLBsO0gA6jr0NTXsemRQSJcp9sup4yscMgIW3yeJAQeSOwqouzLjC2rOSikUak9vE8yTQRfakby WMXy/wC1jbnjpWzaPe6qyNcI0onJDXhXbH/wL0PTitiZRdz/0fzD1HTprKRLLynL20YkaZiCkmeV 5HHTmsqKeScSLIscQjOZM3CrKf8AdU8n8K/Bz9AtbQkS4WQqjSBTI20EnAzVCe4KpLbzIqbGy023 LlfQVUF7wbFD7Tc29nJMru9uvzrA3UdsgflTbawnZ/tN4I4oLkeZGY1C3WQMDJ9K66aOaeqbKt1d 2LweWYwl/FKQ16rbn2DHyY6Y4+vvWLOty5hdXEiMCU2ckYJzkfhXoUU0cs9j/9L8PfHbSXulpZxS l2SMvIrxkRwMCPmX+8cDPtX59fFFbuw1yS+0q4v7OeW1WCW5tWMU0RGQ7+mDzyfWvzuj0+R7tRan yzr+pXWpXVzD5sk8UL+Y1zOf3rv0OR68ZrkoJTAXDKSZDtY4xx6g/n+VejT2ON7svWzK87AtIiRk by3Jx7CvVNHhvL/T7aKwmikgF15i/aGwkTcBmb24xz+lda1MJKzsdSJ7K0WayBj1Wa3cGWR4z5RO eg7HHbrXTaPPNe3RM2ni1aQKFEIPmhccbQeffFDetmZTWlz/0/5Mb+0tZtRkvdauIltoQoeRSN0p XgbvX+vepLiLUNTubr7NNAujyvGlvbIAhdVXAZwRjJ9ia+KoXVkaz/ito8j+Kelz6RozqbuOSUTC zQwuJ7o+YcFcL02Dj8PavJ2idYIoyArRQiPawwXAHG734r28PqkVLZnReGLO5msL3cIzFcEI93cL iO22noHPQ8Unhu2th4imhVorqRz5DSCPfsCn5irHp2/KupXMD3batmkkH2ZYQsIk2MwjYrwAVHcn 2rzzULjTNMm1e+dLy7ungWRFa3HlQqo+ZSRyeBxjJq+dlculz//U/jU0bW5dT0o3VtCInjlBhu4w 0Tnnkc9cYwCOlXbe5vb0Xtjd6b5gvLPzP7RW4P2uB1YElfUkA5PavPE1dGL9k1GPVdM1V42iaxiJ v4oHMsl5Dgr1PcfKfqKdrUd7qS3Gq6dayQwc203nEwXU6lcpEM4yDgn2p3drGCV3YgOqazq1zoGh 2ujPbfYbbyJLiKNYRlQT8+B83ue2Ca3zHAt3bQ3lhb6u1sd11FKv+lshIOI26YJH4YpHQlZDdQub i+1eS7e1e0jsZQ9npcJ8w2qkbcADuR3rY1BJNPkSUmITXtvuCzSiM425Ug+vfHvQB//V/jg+y6hq 9sYro/YZbXbLHPYsJY7xQ2dsgYcZHBxz9K2ZdE86w2bHkKRjcXHCD0/+tXngctf6UFeNrXzkMA/d kSnLggAggYB+hHFd9oQaxsY7iePAYbIlJzJx94kdhyKaTewHNavcfbFv7ryE09VlaK1e33MkqqB8 5B78ngHtVe7uZH0Sytrt5LiArmGSRDHubADHPXoD3oaa0ZnM149RTV5Ldp7iLTLKwtY4j5x87IjU KTg9cnoB/iajuLa00WO5gS5hudIvL3zkuYbFojIZOjuMZyNxHPbv3qlHTUtLlVj/1v48Vlht5ooo GAgKFQmcF25OSD/nNaaR3Ut1i3vmtnxFIbfKmdATwyjHIb3rjUOjA29fsjqMES3WyGe0ctaXUx8s CULyM9PqK423ub2Ww1GCwFu+oTW7WzSyDEUZBHU9uRWYFjSppNHuUuL2GOS9+xiNmRt8AbsRz+P4 VeubdrmAXaSRvdSTNIol556nOOR1oAz30B5buyv45GF5aypcxXEMvMLqc/L2/wDrVu32n+f4gF5q Sf2hqE1uJZLq6yscasBuYsSAOmM0DvpY/9f+QjWL02G3bN5tq5CmFMNbwgA8rjv/AIVSh023vLS5 vIbm5guIWSUWsZ8qKZSeS/f/APXXngalnJI1vJbNqK3Cyt5i6fGw2WygAfjkgnnNUki+1XMyB7gX 2nuLq3dWCRrkY+73xx+dAr6j5Ly4lWUXgEbHjMx2yNjqw96f4YaCS5ube9e4+y+Q728simYyvggL ntzinYaV9EbrXdrpUEduYbi6aVgnmhd3ljPV/btn2qXU7t5VGogTwtGwgNvZqEW4+UDew/D+dIUo 30P/0P5GYotQiNwYAIxfRDesjBPMXIOOfcA/hVC9N48qpOTGkMflr5Q35bsOPfrXngJfzXdvFp15 OJJfs86tKiocTEDgPjoOtasuq3GovbQiRVnEQkto1kDwgHkIfTHoaSSWxsnFLQ0Bq9st4kxKW86N s8xYygYgD5RgcdKd4isPtMVjewN5huosyRowYAl9u4gdOlZzWpk3d3FklW206zikgjSW2kx5iOWe ZeMbs9MY7Vh3l7dSShlijktZZtsezO9MKOD9TmoNISXwn//R/kkikjht76ZLf5khPl20K43k9QOc 561U0bU5JLua3SCe3e5thbGFo90cxJyQD+H8ua8Sexc3rY1xDc30ctk9tCskTYRWPySqoBy3HUHt 7VWk0gvcu7pNKgQfaFVifKX7u5Rnjr2rIwnvY6CXULnUDbxRzGOO2tFsYMKAsarkAknuffvXLXGn ajBdrNG7zAthjuLMB6n2rWLWiMZRurlqS5tbOH7cTPHqKJ9mgmWbETFiCdyfh1HpVnTrKyvYWu9R vJbm9YbkiuFBW2weAjYGRwcZ5GasxP/S/kWubFXums2muLeK5cFJojtmjH95c8H8a6hLMxi1+3al /oEbFFubgqkk7AYG8DgZJH5149jzra3Jo4IllMsEiMT8rIhDB8ev6VO0vmQXMLxx7J4/LlJGWYA9 KDSMLq7NKKcXNhPbiKOaKKLzZPtC+WG2j7oyK57Tr0XsVrFdW66PBLcP5Yu8u7gcdRzxjIHXFRKP VGsY2VjWvr2GaCSLTpTLbxj7OtwqGI8dfl9PrXPWljNEYLa8RJtPvS9yZBL5qJtO072H3STn5Sc4 5xWRSi2tD//T/kzuLDTU861tbSCIsNr/AGduHIzg5GckVpaZDdBLXT2ubdbgkq1xcuLeIL23EnAw MfX9K8G65bGUFqZml3ep23iGWKzujFNp12ryQRKsiX/JKhTzw3bHWtCaKTXNe1zWUs76yt7x/NuI M7ktiBtJBxgZIzWU9iZr37kqSRRx5W5idB+7G1wenHNZAGqyvqiW0ts3k2/nRedcbYAcgDvk8kZA yalfAzWKtFFvQ4bh/tJnuEik2I8qglkL9Dsz/wDW6VduU3mY3AS4zJ5kk44kHPX61jJe8jOHxI// 1P5Tvs5vLcy26y2yo4/ekeUswx+v0NZa3Utst3by27SQSMjF4kZnkKFuCBxzuH5V8/UT9poCau0y miTyarFcoxtrYvuFhEg8twQAck8g8ZrpbyRbu2iE1hbGWJpIUnfLTIrYHHbsPegpLRnMJJfWt2IL GKK6g2BJo9Sl8iLB+9tYAnIycGuvmltzZJpEcMKQxp5scQUGEOTndkdyRT6GcdaiMzS4757lpoUG mXMUnlTMiiIyoABlGAGQcnn61rahcLZyqiiZo1TIkSIsXPfOO/etYK0SpytOx//V/lJ1gPObeaES SJCRKkIGH3d+K2ob21KLp99dtBJ8sklq0RWSFDgCX3zyB9K+fAfeQWtqGtIwXiZN4uZBtZs9GA9+ v41gXMgXYqTOhX+JflbA9RWMviYGjZWxuIW1aR/LeKX7MjxOFcjqMjrUi3AxOU+6H8ppG4J9wO/f mpAwpoPJ1Szv45EPlyb9yOOMZ6+nJrVvdSnfUFuEjgiDRhGEX7tMjjP1PeplK2wH/9b+VOeG8le3 dLxAirsdVGUx2wB0xipYop/s8sE7xSNISzTCICX0wG6jjsK+XFfXlILIy2drbQ3T+ZLbDy4psYYj JwT74qo2Jb43dtctFJEd1wqnl/r9a2g7rUZtx6xHCY2YIEzhsjG41O5bVrK4ZUS2ljdtm05baDwW 9M44FUBmxnUWSRTJtQoItynlwO/6VWSaaytvsmwSFiTublyT6/lWTk+YD//X/lWXRr2KxGqXBtUj RDLLIJNrRqCQOP0qjbvO6vrNtCnmYMbs8mzztv8ACx9cdK+ZTdmBPmG4uUu74TwRRbZHjtYxdSzI 2Cybee/HHbvVyyv4p7iWJLN4od37jPGVzgAjt/8AWqQGz291/aEt1DE0aOfKccmJNp4wfX/CrU39 ozyRzTRxsImVYWVz5jgD7pHpx05oAv3mqCeGOK8t0S4t14SAfMFY8bh7YrJa2ezuY5bIK4uE8x5l B/dbh0xj/wCtWSvdoD//0P5ZGhklWQS+a6BChwCCoPX6dauQv89jGxeW1tEEUMMrFgMcnj3PJr5C zW5nNuxRnlWa4ns4FaLMoH74GCAknsx4wPX6VrRXVtBP9kje3W4X5Gmd1EOVByQ/QgYpGZjrqdys V8PtI8+eUiCYrtAUc4/HGeau6PqlheJNdaokl9DHE8BilcwBGjyAQfZhkdjWaerQGPpznUJ5AsZ8 1UYiQofLCg/d349O3WpZop4lljSWS2J5LWr4kOfp39ua0A//0f5YZtYisrG2jBu7meKMSXLyLtmC kkD6ng+9SaRPeS3N49i82yW3BlCko8qjO7dzyAMcV8eRDYmhTVLeeaefyI7Nl3RMXw6gEht3brWn DcrAytLAApBQOPmJ3YHHp2oLKkdhIJJ7z7W0hzvME0iqEHQbV6n8Ku2cl55iTWjyRXwbZayRHDAn jHv9KcVd2BaFSH+1ZprqSWySF7NitwpOZGZT8z46+/rTFuri4mmMlx5xkJYIxGI2xg4PXsOtK2on pWTP/9L+YW0tbW4tYLiSZI71GbNu6GJ/l6kE9f6+9JeR3d5eWbzSuLe1O4ho/M8zH3fnPTB9K+PA hvtQ+2ahbR6a88U9q2Aqy4VmPoRip7HzQk9qI2iuxPvmKHdKCp6Z54oAIpLrT76e5lSS7OpjyrgT v/qAB8pA+vJye9S21qfs06C4ezhSXzFhjIIkyckYII//AFUG0PhJJZ7l7m2s4WLxRR+c8qnasa/X 1yOlSXNvJbooWVbiOabzXaRAHVT/AAg/0oBX5n2P/9P+ZWNLi1lgnju99jtbzLARgqSRwd3UEe1Q z3auBJkpJJ92LvH6E/Wvjzd6ILO8sED2t+kjtLlo5FUlicdz0H40JbmzS5kt3CrcqULHDEg9gPwF JJc1luOl8DKtisYw00m9k+6WHOR3qeS9lNp9pjjkC+f9nJx8yk57VTVnYwhJuDLmmzG4tzifcVcx MyEGRcdQR61zuo6+0d0toxkDNGYTFNGcMN2Qyg/zFIufQ//U/mThljjW0tJyymRuDGu8gtjNVNQ8 O219cKsd7JvtXFz5Yk8tiOgG0ep/kea+PGadxLHZ6fItzOlt9nUDzAwd88cAYPOO2Kh3pcRxXUjb 2kUEEnBYDgEjt2qJ7CK13NLLtgUqs64d8HAROcH64qWxkhlEVu/2hvJYyndExVsejkYP09qqOq1D yL0d2ZlR5GBiZzHFuOw5HbB5/wD1VfmtWDWuoJLJE1ruVAjbQ24YIx+FKSuB/9X+YzUpLi5vYlgt 0kkmypd3EaoBgk+5qOxe8vobpYU85bdSSYzjgfKefrXx1le4OXvJFswNEkOxGRzHtkTg7Pb+la2n Rm30+ZbWI5uN2TMTCqkjlueh9qXKr3G3dklrFEYooLqYyOq43nG5zjk+lRtZNJLss2RbK3QmXeNj Ag49cYpqKSsODs9S3CrQwTBFLFF378EqPSsq4jvZrq1uIbmPCSKLm2lXKSx5w2D1B54PtQklsEnd n//W/mf1PUYraeS0sTJHtkDmPPA3ZPJNQSh3t2nkjW4IXaqAkb8jrXx4GpocVpavIZdhkVQDC5BM Xpx2NWpPE1rcNbxR2io0M8ls2c7XZTzlvft7UFRk46DZLuSR2eSGOIE4AjO7j8abcWs97A8SktAP meFR8zY557ke1BJSOmTJbLFp9o8ZlOZXKkNF1y2Pyp8UeogpEwaSVQEWeQbenFBpTfQ//9f+auRd SjubmS6NtHBZwhkdW/12OoPv0rNso7K0lWeZEQXZPyLypJOc/hXyC3OguSXenpdLAjsZQBIiKPlA zjmr9vI0rSyYbk7CrjAP0+tU1aIE4mZYFt/Lja1UZGMARFcYAGP84qjdia4ezeaHbbRsXV2UhHwM Db75quWzZalZWBrzUri7dg2HkIBmmUuPLACYHocYxUyWux9kSJnfu80fLnPUn16VSVlY12P/0P5s bqNRNvkLOxTbjcSmPp0ploWt2DxusMUR3s7cBa+WSSdzu5kWBI12omErvsk3GVxtRgSePyrVkk3R K0Uh+UflTIT91plO21DeCsijynOVkYFWqOfy5JcKTsbpgdax+0SlfRDDDFGRa26CVU+aUddlUjC9 lNL9lnkKzAboWOUTB6j0q4pboR//0f5rI71jOLS4SVE2hpJkGMg9s+taFxc6e7FbScTpH+6dyCpy OoI9RXyD3OuMU1qNHkXP7pZdhXjCjv8ASm3F1HpoEW9lwu+QhTzj3/pUtK2pcY8rHma2ltGufMkV dgaNnTaxz6jtWRArTylnKSzWoMkbnCsATjj8MDispRSKNGa8aSeGR0SIeWFdUQIr4GMmla7hjcWs iKouCW27MjHqakD/0v5wbWNZDJAFjtIoULwu7ACQDqB/hXOXtvFBq0d3DJsnK4nkX70g7ZNfDnXN am6wfyuVcJKuTIwxwe4rBddYaCa2gluV08T4k8shvMxyC3Xjj+dBFuhrwo1pZrIgNxNk99pB9M4r TjuZRYWz3W2G5MYEg3Bgzd8UFcrKju93d2zhQsds2/cBls4I4P41qxoBuLs825s+4HYUCs2f/9P+ dEtbWSyXVyXkQLt+zRLnzAT0NPnNnYafFDFZbI5MyW9mgCFS53HHb19q+CcGtTuhG2nUq+bPZyW9 vbPPZidd7FvnSPOSTn3z05qCWK7luyhuDJYQIOZZfnVmPJVegB68UklozVQfU6DTrJLWNpY5cEuJ PMPPTH+FS3GtIGVJHHmM+0tjP45H+eKc7XBR1sznGW5F40u1HhOX3ZxLnJ7Yxj8av3hliseJJQs4 3LBu2xueRn69quHwmnKj/9T+cm1tprhPIuI1iiK4e5VsyI3ZQOh78n0FaW/+z4k0mO7uLuDzDc5l jSPa5XbnA9gBXw560ldEczZwkYfdJxKU4Ujvn9KlnuLc27w280y+Xhijps3Y698etYS3ZiUIbhVj aW6nP2dV3RKq8hmIGWPXHepNZgSzks/st/bXXmQCe6t4zueMN0z6EEGkBmrfO80axuYFQhWkOfkH fpXXaVrFpBDdZeOZxIBFcRnoVznPrnP6VlN62A//1f53LHV501DUbi7umuo7qYSoDEgW1XaFIXjn kFsnpuxU9nrt3E2onadRtutomNs6g/eyBxx2HNfnC0Z6sJN6FJZJoZpLiCWaOGU7pLd/kAJ6jHbq a6SMSQ2UckdutujrvIHO7nr/ADptpu7RZp2viG6yVcui+UEWbj58DH6f1rEluWj3OXeQSMVXdyzZ P8qTt0AnsZ5Wjl0hx5KYMyIGxwwHIH5VGkZs1IOS27AJOd1bmMndn//W/n6n3J5TlcB+Se/+elZM 1n9olLgMTG25Rk7c9j6V+d1Oh6KbSsi7HZtcRT2l07TG4ydztuZT7GiXT5dJ022tEClC5YIX+Zuc 7j3zn19KzK52lY19KuroWscE8zTnJdtx+5k8AU24uZJObdDI0fVOjGg0i9mWLHVEhiSXyAbjbu8m aPhcj+JT35pb26aeymigZo2uU2zFcJIhOfuntRqdCd0f/9f8B9OUQWMcN8zzurbYpJm3MR2B9a2r aBbSWESfaCt0u2H920keB6nGB+Nfm59AT3enr9rhljcwoieW23gP3FVLqVkljgb5gg3KD1b3H+e1 A4uzuTyxXFo8WoQlwWUBFOGXOev9KvpDc3ys9y+2PytzSjh1PoF96DVTVtSO1QWMIcxSzRudoXac vzj/AD6VNY6gftkcE1uGgwZH6cYIIAB75/lRYXOj/9D8T7qZb2dp0nmLMo/dTDbtwMdO1VbixiiK TzeVI7DdtQhgM9jjvX5ufTc6KnmQ3LqIrdYZUXy1VflDdsk+/FCWbG3Czw/v9xLFTvUDPrQRKSew 5YoYrkzYaPEWwRqMI5HGTUa/aZpCzK3kB+W9Pb9KiUdLkBdhWfiRoti4jYcjPbirWjGaWKaDUCol iTzIpgmEk64FZAf/0fxENjFJumlVQR0eMY7/AP1qvadILhruB0ZbaCJTHISCHYnBHtwDX5bL4WfQ DbtUWVm8wiMIAISfl4HX8aBexS2witIBBcAFXuQSJW54AB4xjPIrGwFaYz6lb2sdxEIHtnZc7f3s 3P8AFV61tpVt2ExDv/A/90DgKPyoE3ZXIE/tK4juLMXJ+zNz9nkYKkZHBYVZndX+x20MsY+zR4nB H+tHYCgzcnax/9L8XzcXMlzEojC28MYRCBhV9f8APvVm6uzEQjYkfqOcjNfk57sZX0KE0vmTRNcI SnXO4HH0FKLbVGfdp80ccA4eVm23ChgQdo78da2l8JZe81YYhCDv2DJ3ckn1NUlk865QkYAwCey1 iZczTL2pKGktbYvJDHxJJJCAXK56AGmND9gWe80wtLLIuHE79cDAwOlBpF3Vz//T/F+xSe8nUYKy FvnllPyp64/Wr063Su0P+sMLl1uI027FHuPSvyc92btoYZs5Y4x9gkZPMuRLMYcZkOec5/8A18Vu aTKIJJUlCSFVJ8uQZDMMDH86DIN+r6lLcCJbRfKO23jeTCKPTBqnZzTbTA0oadSQSfl3HPIX2roW quBOzWchMSNLFet800jDMT46DNS2NxLIbuG+Mcz+WBAVQ+WgBAA+vBoA/9T8ebK6vIYp45JWZL0m Bo4nKsqccDkfjRLbzLZbIVYWxBjVm54HYH8q/Lz2DMskjgMQchZIZfMhkfsw6devetKzu7jzZkup hKxlLCV2BLAnt9KTSe403F6GDf2GpQ39zcrFELUlXt387dM5AH3kxgD05NdBpmpySDzblIxczL++ WJNsan2HbtWLVnY2i7op307XUvklCio2fl6fWmW1lAZYQ90w3tiR+Cyj2HtSGf/V/F91u7Qxr9pS SJrgqC68AEnGP0/KtW5mkhjgLYkjZtm4HBB+lfk59JDqT72s42uZEZ40xkqMlcmp3iklYXSShAEy A77FOaaai0azj+7Nq00+6kspJo8TQlv9bCRIVPoQOmfeo5IBFAzXMjRJEhaRcbu3oK3b7mVJ+5Yw Li1tksZLz5Qk0g2qy88j72O3b86l05DewC2mfzVt1Zw23aYl/wABxUOdnYTV52P/1vx2v40FrDPZ 3Mc0aSiPdvDng4OMHnoaniihaJZHinaSdDGZYn27OOGxjtX5Q3d3PqLXdihHALeR5JLiSdCR9o8w YkCr1A7dM1ZuVsNSmjttKeWWCLa1vJtMJCbQWDD2OQe3FJNHNWVpWNhTLJbRJDN5JtpAHRFBMoAP GD0zxyPSr1ldPKGF+z71iYWsijY4xgbSevAzxQMhuWikVJNPJ81iI5HBJxg8/Qjms140td8SYlnm O55SNpWgD//X/JW3s1c28jMu0nErtyQKstOkd9HHZJ5kyRuiXcCHysZGQzepyOPQGvx+1tD6WDb3 GIZJ7h47+X/SbcmaJ8ZD88K3pxWv/aE7QbVCjH3juwDjOKymrFmhp91DEhmacguu5HUqyRuOcYPX vx9PpVa7MxaS7guDIJFLOVRVRM8EKAMYrGextF3WpTe5vk0i3R1t3kTIkaEYklyfvMPXFNjhQSxS qzYEe6VpF2MrccDk/rWRadnc/9D8wYtbv7KSJIbaSW0mlVSYYy7Kx4DN2x79qS5miS+l+1xol1Cd 53AHyyeeD/hX4efbxd0X7bUpri3kR4m2lSAQMFh0qrBBcrbfa7JI0MJXzUk+R0j6dO+P60A2luLf 3s4jW4hiaS4lZI/NWPfDAGOCxX0GTVy3eSawaNn3SxgneF2oT7rQHUszw2Ntp0VxL5dx5ymBdP3h Ynxj7wHTPJGa0LXy74JbymaC3tITJbRR8Qqx6Lj04/lScUyNeex//9H87gAtxAlvK1qd+ZJVXknG ATj+ftVJ/tdpe29xd2qXNjbt5sk+4qZSn3uQMDrj8a/CZKzsfYFa2vodQ8yQOLOVpt02myKQ8keT tKn06GujuZrSaw8qMymJQBMxUhSRzhccnH9K5QJbSeXZi3MscKpuEpUrtzxkg/h1qreat4htbyFL J4pdEDKt00pYTtnO4BRxj/69ZT3Aba2rM8mqWcqW1vFctLPbXbD7PKDgcE9Xx0Xvjp6dHbPZsUaG WMzMokKsNhUHPBz9KxnsO2lz/9L8/ZRNdX8kUERjIYtgD5SB1NdFHPH/AGYbSCSKUtKDdoTu8kKT kH6iv5vPtKZWne2gtvs9ujK8u1UmjbaY8dABVi20mcCG5v8AUHXdNgFUCOygDj071jKPLsbQ+JFu e6sYpvsenNeNEsXnTXEi4IDHBUe/J+uas6VHP5BewndE064X5Jx85D8hgp64IHHuKk2G3k0RmuYV hYah/rBemIrb3GRj26Vct7g6fbTeZdedKxWERqVyd3YY7AgdfWs59AP/0/jFzLazCSWJZLfyi7sZ MOrdsLjpjnOa23vbcWUF5ZyKJ3kEZs5eJGA6sB6e9fy+foV2lZEer6D4h1JYo7fUn0a1gkW7u47Z llFwGAwsq56HI45rRvoYIZLNBLI21AzhYSx6YOcfdHSqja9ha2sTXk0NpLFKkm6QxhVgVw+0EAiQ +5yMc/hWPY3l/dag64IgALO0mQxIPT61rZWaQjbkUQywyXDS7blzFEqoX2nHBb0FVrO1XS3mWPzC 087TS/NnO45OPQVgSpXdj//U+SVbUbLUGgguZ5NFPzyopCEc5AbqeCeK0GP2qQrulBRd8si54Xgf 5+tfy+ffSk47Eka373cMxERsoY/9c0h8yUdNoHpx71q2dxPBqCyIohjcYjCj5gPX9OtZzXUXOjTv 2ESRtIu2F5CRLt6ucZ/pVGO8DTgzsF2jarE9R0FcklZ2NqclaxFdaq9yNv2ZIfs5KIygR+eBzknv WPpuowXMF21zZ3NmVBjsVlTy2kkEgD5Hpt3Eeppxjc6IPWx//9X5i0+5mujdjyLr/RX8t3MDeTtI +9v6d8Yz2rRlu5Li1tdHimeNLZt6tvO9kGMKD6DH61/KXs2fp99bG+ZoLO3hKNumQksHQMsnsc8V kPM920U8kTrd7hKuYvLKkdOBwKXLJDLPnvLMWkxxjd6570rW9lLem5iC28gTc2xiEJAAPPr9a0jG xfN7ti39pjVVlkMYDSfZwCuWk4zkVlzxPNcNJZlZI4GPmbn2uM/d+X/PWqIP/9b530+W9uLwT/Yz NBp85FwkikRtxlTn8RV69WSQCXccDqnpX8q8kT9Ru1sRRNBKdjuFRIyylhj5sHjP4fzqpYf2SPtF vA1wZTL5jmHPll8gMN3Y8DgU+VX0RcZNuzNO/toLjEXDB02yLjLJ+NU4ootMiWO3ZvLjTbhm3ket Nq2jL5lexZkk8218yM+ejcMAOVPofaomluFhkjh4kaE+WSu6NWA+Xd9PShx7oZ//1/BNIvXsPs8m o7Lou2ydokxuPrjnGPep7a4fTBe6bPLb38FwwuLWaNvMSMvhiGHc4O01/K5+v2sVraRoJ74xeavm x+WI1kKxjPXA/PimQW4No8Tx7hLlXVv3iEZPBz1zQDV1YzlgnSbdaW0KrDExnQ/JuRVOT14x1/Co YIL+5so7lGSOZJGMluJx8ydiPw5puLW5KdoE9tq1mXNtqN6tlMRtt2ZCyz/7PHQn+pqG81ubTn0+ BfDmnX9jcs6T3bajLFfRZ+UMsa/L1559Ohos7XM276s//9D53hlk8g73OZ4PJUIN7QrnoPTpVOHS o9PluJ5pZSlwRLCXXGR93146V/LsFZH6k3dkVxewqwEEsh8tMtvjKAZ7Ang/hVpBJqVpbTwkSARs 8ygYeAAkfN9cD86qxjKTTsjlpbm9bV3hSzV7a1tDcz3MsgjbAbbhB/ER1IFX21CyvmFmrrDCw2yy D5nXI4yO1VFXZDbe5T0oXFjBb3T3MTXdrdFBbzgvHLFllyW7kgjj+VUUljtNTi01xHCsn76BGfKK jHPXt16VsI//0fjTW9Tt/tqQBGmMPyxlEJSIEk/exgZNQLrt7DDDC9ja211bztJNKwLPNDIP3WQe MY5Bxzk1/NqgkfpAi+cVJh1BraaF/tZXzAh2ryUXP0P5VbszfXi3Vxc6fLPZwMP9NLeZDuPd/Q5P eqtoBXuXNmJWWRJGKDyxEwcDODg+hqjZafJLqKX2q3Ek0BTItsgBCRgFmHJx2FUotuxlFtyFikTT zf6alw5V91wj3UYMqs3KnjnHtnvWZYwRNeK97dzBFyUCL8jnpgj0PNaqKjsan//S+HYZkikkeONB scvEpQkKf85rIbzmvLbUTqE8c1ldNcXMaouJ4yrDafqT6dq/nex+kCz30rP9rRmhH3o8J5fmHjI4 9M5/CrVrZXF5EbiCC4lDBifKiMgUqMs2B1A4qZLY2pStoVrzypvKja8gFlBEQ8MzqiO5weh6kYP+ cVVF3feQY22NbLn7OxGACeuP0r1H8EfQ5L++ZaaobSOW21DQr/WoLdBKZbXcjsxPHzk7TzjjHFSf bFay+0bbiKaSUgWF2wa4tQMcMOn0xUWV7ltuMT//0/zm0+8FzJPEAg3qUn8wDAz0wD/niqSRxWaS WyTZDSlyDztJz09P/rV+COC6H6QUI7e+s7+7g8xJDIglaeNSiyB/mRAT1IBA+tQW1zJIxSOGZb1Z mVI9uPMVcncP501FICHUL37ERc3G11XDFWYLtOepz09ah1DUX1e5tpEWytItgilmhUkEAfKcgnP/ ANemopbAVbTU5gj2luUPmSGJpWA3kAkEDuMmqesXF7Zvp9vbXNzZzzTFb1UGYJo8DaSp79cH2pgf /9T8v59UMtvbact4WZ8Ao8YDtjsD1xk9Olc1quh63puqec06WgtokvFguIgHnAwcLu4bdxx7Gvwi Ku7H6JO3zHWaXutX9uGiEdxexm5t42jEWCvJyg6Y5P4VqatbtdXgS6lMSogSaW3hD4Cgj5UBGfzq oLUzMeJ7ScECWY26lrZt0RjEu3ggg/SlndrUwWG3zIgoX7RcSH9wh5BJ6mu2mtkc1RWTRxupwHzJ RG4SSOTDxIQyyZ7gjqO+R1zWZfXz28kdpE224ijDOR8u0N0Ge+QK9Cijlnsf/9X8JvFF9qMVqY44 pVuQN8ZVwiJhWJMnfGO1fDPxE1m0mMly+pKsExazZIFHnI8ZyWKnqGJA/Cvzykj3qp8h6issmqXU sOW34J3EIJD3Yj/PSs29KNcpE4CGHAKgY2130+pyT3I7qWeFRPZwu89yfJIC74/QEjt9a918G+Vp kUemam1s011AJ3/s+YXEJYoM7nHAIJIIBrrSsrHNK3Nob/8AZyw3BS3jTy2bIeP5lPpk10GhXdjp GrMb+VpWtCzTMsmfLDoQBjuOnFDWqZFZWSR//9b+TPVH0qbU7mwGmG7t2tI5oLy6X5YJQR5gC9CR yAT7U7XNY097Cz82KHT7Ez29tH9n3+VcTxsNrMRnDE9unP418fSitEbxV5yPNvGxlklhh01lu3e8 W3uUc+WbcEbtxPTnHT2rxrULS7uL0LbbCPO2SqThXHOcHOBz3PYGvUw/wobXQdo+raha2V3pj+cu nRXjXUkQ+e13Ebd5Prye9aei3UWjT+bFbfbDMpK+X80sQJ3Mwx1OAfrXYQoaWZ6rLcwSQQS381zJ 58YNkxVlm+nqOOx9Kox2P9paxBZW8sslsrq99LJEFfZjkBicdcD1+lBdj//X/jf1l7ifW7S30sWN lpNtGEuLZebqZkUgop6c8Me9XG1GO0Ee+Yqrq8MMD5V04PAOP4iSPzrzy5Qtqh1vqsVhDbWrQSS3 F6PJU+XuYJ6Z6YHrSX7PCskpZzAzCQoFMvluD98gcmgx5LNFKL+0YLiDX9IvIvMW78i9s7iU+cI2 H759uCSHUlR75rRxHqNnFqFoPIaQeaqbGTYM8LhuemDz+tOzW5fkRRWt4rte2t2Yzc4gvnhXdPGo OeAexwASeKzr3RLee6jmvJLm/eziaaJomEkkBcHoo4PXG2izTswP/9D+PG0klspbS0eSYw3Fm9wj vx5e3G1GBx8xz09qpXGseILeyvLO3kk2yHztkygo7Lnb74+lcns0Bd8P3K31k9w3lzXds/lXO2Ir axMFGVVm64J/DFawUwl5TK0ixxZ8kMFBz7VSSS0A5a48+9W7jaRraCRzGkarhlxghgD/ADFPjjlm KJf3Xn2FkobypHCFFHUL6e9ZSd2BYXS4tXtJ7ya0s7WK6kMOmzxzDfCI8Y4z3BBOfUc11dhNZy6f p9rInmpZyEeYSHkmIOPmPfG38M0rsD//0f49PEGmQLqEmoXE8duplMkcGPKigyOuPeoLWzW5W21N 2mjvrWLBjtt26ZUYEZGOV64x1PauC7A1YXtfEdtq1heajf24066+3aXFd2xhaadtu/fuxxgAZ56+ 2azbPWdO0rXpzd24vbO6gSO506ybZcxhQA5iUdcnnODSA6690SMy3c9iX/s0wJPavejbcxFuSCD1 K5HT3qFrOCCGxadHmivJCvmwEebHtBywHp2/GgBml+TBbx7pg/mzPtkUZYhTgkj24571l6xrAnQi OWa5uYJvKZvK+VAMjafX6Yxx1oA//9L+PnTLaS3gtpJ4mNtPMWaNl2gp3x7cfrTJ7KS4vmnja6it V3JGYm2xE4+VZDjBxjpXn7CSsrHS2Gl2VnavcJABdSbUe7YBHcj+HjA96oavpFwY0n3PG7kbpYDl toPQ/iB+VZufYdh9zYSNEq4a5Xy96HG6RuOce/FabCPR7ax22txJbS3HlTXG3zBBkZw+OnPftVpp q5rBJFq406XU7GG709GmuJJ2S1tkf927JjhyP4Tnv0xWcby+h0eO0vNP26uL50vFguBJDbIDgBX6 N06+9LnRm92f/9P+SW7urO8mt4kBlu7SHYFDHKo3QE/hV3TZNKjlL6lDPGI4pH2BNyGXbtRs+gOD 68V5vMnog9TMNzm2kLTNJb3RILGIqTnJwFx0xTtH0a01HS21CGQx3X2lolh2bGCqSofPrx0ojK7s JtLct3GlbJUtYQLmBYxJK7LtkaTALflzz7Vl2Or/AGK9NjexNbwLIqWrynBmz/Co/lWcndmbm+hs X0aXskiW0MgRkyCQeCPSl00JBGLaUQeYrkqJCF7d8/jUmkXdXP/U/ksup7ZoWWCMs8kgjDRZbknB 6U5tG1SSFrvT4UElnGJ3leTysDIXI9eSK8SewmrqwQl0dp7i4aP92dxXmRW7Mw9M/wA6lvNPE5jm S7lmER2y75hEHyvJ2A8jg/pWRnNWY63TyIliiDta3LgyOB80GM5I9eeMVpW1tcpaQu820she2kbA kIGdu4dQeO+KunuQc8uiJfLAb+4Nw6ktNtUBZGJzn2q1c6TrkFpEdMexm3b02zSbXiAIwMdelamb h2P/1f5Q7PwjrsMtrqH2Iamk4KxNMzQ+UAP3hQ9Dt54rL1qxtr26WxvbX7RboVcRSJvt2k6rke2P 1ryNU7o5VDlsyCTRblHVdJmmtrmdlVTCw2Q4PI2kc8Zrav8ATorYWMVrPIZhEDcrKwyZP4mGPWkX ZpXM8TPpFuZdXu7mSzVmDtDCGeXJ4QdgBkVObpLmGyD2FtMsd159q7Z8xhgfePQf09aibtoXTR08 1mboIbWGO1iunIWJG5JA5Az1rGi0qGxjjtr5We1eVn+xiUwRyjJzuI7c1kOC0P/W/lB0rT7P5rey kQPbu7iNT5mxSxIA6nv3qu1hI2oaydQgSe0eGM6fBJMUVmGN+3Hf6/0r58yg0tzQt5tNN5CLaxmj vpLcCYCEovycA7sdsithNV1qws9Qs8wQ6ZeYaYRRBrib2L9R06ConsS3d3Ode0tZYDJHbCMowURh fKDHOd2On41DaaasZvHWNCd2UUMSAT9725qUvcZab5CHT1lF/cXF4LuGFv3AimwsbbQCrqoPC9s1 1ExhuVdYLaCJJCFBj+Z3IHcnk9M1NtURHRo//9f+Um6a5tbaGPzLq4CEjYVJ8oD0ApLS7vbVJJLa EyS3g2RGddphJ9B27/nXgy+Ii/K3crmO7CuZolS53bVCHOD6V0OhWG2IXOp3EsreWRNbQsPLB/h6 jOc8Z/nQ1ZIqMrqxzOtQSxSySxeWsII2h3G5M9f5da07cwPpdlLavJdPLKYZAQFkQAqN36n8qhkU neoy1fC4sRA7BwJ5BDCyrubOONw7D36Vmxwa0lxPNeXEf2dfmEKsrbR0HPQ/hWidoM0nG9S5/9D+ UBtQnj1CKONIZFlj3s6ybBFjJAxjHY55pkV8NSvbnc++YKEYgl5ABx972/Svm4yvItwtFtlyaEyI 255iI49pJbLYHpV9/C2rvKuowi2FgluGujPMFuI8j5Nq+jcVMlZmSkmLb2Qs1cbxtlcyTjJKpjA/ pTvttlCXW50+SUtA5tLiN9hRgP4uxB/ofpWLi7lLUoRyWeoaf5kkEVofNYF4XDTOf4dw7Z4/PvVe 6tILewMpY8DdKJGAKen+RUNNPUbVtD//0f5VdBuLB72K1uJWNqYfNnu1GYk+XO0H1q7vs5/tBsWk +0qTFFbTHYZVydsmemDwR3xXycE9yW431LdzpF1YeVHqotwx2uphkEu3cAQDjpUd7pllBbW9xZZl mnLC8dVwqEHC5P0rQaaa0OZngVd/mcmP5vl52/hVm2aGzhuJJWmP2xVJGSQdoIHH41tH4TXkVtxy zXzeULZUwJQgjJwXye1bP9jXFxMNTuLu1hKg20unKhWaQjG1gcbR3B5zWbTuxqCuf//S/l0aW4+x Cwm8qQPEYyhAaM5PA59OlY99prxWazNxIxyLdDtTjjJr5mKvdG/Kk9g047HjO5I7mMBSV+UxEgHG e3anxyTQanePe+a3lTgCYnfHOpVWyh7gEkfWm4W2HKKtZmvJqV4+nSRaPaxagtzfK3k3B8i4jHPI HX3IqVnt7MWnmjzGBMoVhlQy8nPr1xUGUopFaeG2uUutf1BTBcLvNv5BLK59ZhwACM+uMViQX+oH UIoZrRmivflTyB8tvgZ3N7VEYtPUzckj/9P+V/U5b2zt5JdLvo7qNJFNxHKfLG0HkYH0NMstThu3 Vp45YGeTEghT5IFPRlGefevl7HPKfciup0nslF2I7gW8hbzGXbKewwB1IFWpNG0i6ht1tBKsBOA1 y4+TcOTn8TWTg+hzOauZ02mujtZCTzLayIe2uFXMTopxgnsfr61d0vSrvVLmGCKCWa1d/kMGdrED ox7A+prLkSZak+pryW0VlYhrO6jVvPMU9qxEYQeoPJPQ8euKrrYp8kokbY6Zc9Sren0qrGyV9j// 1P5XJYmMMzTXlokTuEMcuDOigjLD9K2rCyTTppWiuZJoGVSJHAVgNo3AAds5r5FK9yIrl0e4+9Av ZIYYGBTcJJ4pBkSIO38qn1QrqBga0C2dpYNG06Mx/wBKIGCqjHQdfwpWb2NuRLdla7t9Mutl9Z3b z3AQRTWiB1hiweuT3FQLaX8vmL5LJDHtIlL7lII7jtjH6VUFqNwSsXYIYtJs71Wt1lvLxP3UscrE AdCxH0449KwrKS1s1fNk8E65aREXKyt2I9zxScGYVXavE//V/l7ib+0Lb7ZbjyTH8rRzMFlT1GOv btWxHKJPs8RIIIIZTya+PK0XUghsLaC780AOEcgqRnk+/qK0dM1DS5by+WGIRtaBVuJJU8qVn9Bk fN9fSpba6BH4jP1R7d78Xscsi20UIiVJDtUOfvMQOOvT2qt52CJGV5UiyV2Lnrx0700290bF37HJ eWd1FbSLBMsJkLM22RCeF469f5VWWHW9Rube2jiZ441WCeRmAiiUL94N26dD60yVJN2R/9b+ZhrZ 4pEiglDxJwzSAAHjHTPrWJPC4umADjjJm2ZjHbrXx+xvLSLNFkgliiihuENw7bSB1OOwqN7F7Rra WIyJdpMRljuVe44/DvUxV6oUXelJlO0tru6lk0+28u4vnl3LLdyiBncnJAPAyc8DFO0u0uZbmf7Q r74J2hmhVSCm08bh6d8+9aS+JmFOD5DbmtUsC9xaJEjzndII8Akj5QSB/nisy4VX8rULq38+8Vdq si+dKucZAPXH+FJs0mnc/9f+ZpJ7NY1eVJIrkrnZKgUAH05zmqWm2kz3Gpy2cLb5EH2WYj5otvY9 iCe1fH3S3KcGldmdY6fe3E99HrsyxXG3fAR8/muCMgn0x0rTOk+UgV3cdHyvCkContYkti0ihiad VEoKZLRfOxA7fWm3txHNFZmymmhjt4wNwxHIXOSVx6cmmpRsS/iQ6K1trm18lhG0iyCZJn+9GRyc c46/jxSSE6bZzzXFw935UZeJB0bngYHtSc0F3y3R/9D+ZKG1mu7VIEuBFMsv2hJsBnjDkHb9Mceo pttZx2VtF5DEzRSskpL7IpCzk/d7d6+PM9bo1Lm2ka5yZTGGTP7lg0eDzweemapLJcThbIXUk0Vv K0qRTPt3Z+8NwHsaDQfLLHbvHcb8x4KSIn7xlcfwgdatWd8hMyfNkqN8TptKgj6UAOt9TmklurUZ ijaIKpIxvGc4/NQahME0bcbxMcSOWyNq8YP05/WmlrZgf//R/mNfZe38/nuwEKgnChfMbHA+laFu /wBlHkuWkbf5iZ4wDyAK+PAGkkk+3mOCNLiZw32mXIc4AHJ/xz0qPT7K2aSWJnV8TC4dA27D+o/K nZWGotmo6N5zKiSKkR3An5tw9qu6dqb6XcSeawXzExlh90dsVryxW4rW0JhqTzFrhWPlBtxb1Hqa je9F7HIbWVWdXPlSD5RvHY+n1rJ2voaQTT1P/9L+aqyh1C8s5ba+gWRo3PnzBvMByeAT0xxxVSXT oEmty+791lBGp+QZx2/AV8hHdHQFxaCO9iMcatFIhMk+7DxEYwuMdDz3rThVgzxb9zeXlAOC3vWk 1pYCG4try0tooIbdZGuZzK7yy+Usa8lsHBzn09aXZcXdukLzSxxxTrIFRvugYyCD68irGLf3hgCR W4Ei/dL9No/z2qubi4CM8I8xgoPl525/H/PShag5O1j/0/5rLcTTXJachFKfcbhqle2gnjeOWNpI C2HAJXp05/CvlzoWuxDaKUs57CW8eW3jkMkIZtu3nOMjrUVzdSHyvs52bDtZCfkkHcnvxQBOq3d3 cQW8CxuJGEfzuIypOOh6fnVy3xAbiKdUU26lIwOUkK9gR29x6Vg92C02M3+yjLYM81zc2d7I/mh7 SYFFBJODSxXVvD58NxIHyoSOST5JGb1/H2rWKsgP/9T+aOdpYGhlQ29zbTRn545Q8qOpxggdPoaj 0eF72aaEhbd9xaNpnEcTZ5GWPSvkZfEzuja2hNdWk1lPBPb3qcP+/hjUSI5HGN3b8PSpFS4v5DJP hkY7QmchMd6zktLFFm9tJBbGCO4LnbkIxwvsCP0/GqOmiGG4eF08zU2t8xRBSyAcgnPse1ZWdgLN 05gNhusnu5VkVbvbOI4lXPLYP5cc1LdzgOIY0QST4ESHk464H4UgP//V/maMk97PLZRvKtzbEJ5R Vhj2HqOvSoZY5GlEKqWmcBN54C+9fDnXNamu1/JaeZZXTNKFiCjHzBR2wf6U2O5eKL91I6LJw64O 4gnOMUWCEb6klufsIuljaYxSyec6bcqzNjn/AD05pJ4YtQW23zODaziRccEkKRt+nNBqdDawuiFB EoAXl801nSLA34z980WCx//W/nHtVi82WNfMmWeYOHfLN6YA/AcU+/ixe+bA8qQw7f3coAcY6j2/ +tXw9uh6kF1FaOS4PHLNxGP4qzry0vIAm+GZI5dwE4UmMlcZGfUZHFTy7WNC9pspezj2vIMn/VzA oR25B6dKnkt7VJ0mmdjKv3YwRt+v4VE1rcmLTvYtSxpanznPmrNHjYTgxZ6cflWYIJXniMkzPb7P Lt0MhKLk5zVxXKrFH//X/nSe7isrlNPMpzM2UJB2tjp/9am3FiTceZLIxfGxdp+Va+Gbsj2CR5pI 28vMKx28RDODy+Mn8T2rJtZ2vLY30DJLby5CHIzx1yO30NYvczcNdDe046DOYYLi0vZkWPy7tEcQ ouR95Gwc49Kv3Nh4bguby8tprgQfZAqRSlGupWUEKvHbJ/KkKUVFHPw2CshLZjkZw0SYG3b/ALX6 VLdWUMLSWcUMZRkwzRN+7GeoGD71lJPmIP/Q/nO060toT5DFy0o8qCMAkN7Z9asGNdPcG2Q+YrbG Bf8Ad8f57V+bnpw0uzRa3a4EU+4qC+6Rcbt/tmpg32m6aMTNGIwMwr9w+36dqaTbsjRNNEsjPHDz ASonMYO4EOAOoxmoRHJLAsyLsWM4AbAYfhTcWtCW23aJZsooI7n7Q53TFCjf3gCQSBWqk1tmNJ1J jMm5NwyQRWxkf//R/Ay9MMoK428cZ4wKWEWb2y/YW8xgNsgc/vMjrX581dWPQMyVvKKyBZPNHWJA Wk/AVT1WS8k1DS7OG2ldrghpTJhNikgc56fjS5Y9gNe5aW0vvLitbeG1jjVR5MhkLEDDkn6/zp0N 1ZwTTvmZ1+zl43hXB83Awh74yeSKTgraG0FZalO1t5trXM7lmkUu/O8oPQ1p2cUM1pMzArJuXYXG HI+bPH5VkbwR/9L8DvsNxFBNesn2iG0O+3D/AC72HIWmt4kurq3XzFS0mkBVY0G5YfoOwFfnCtfU +gW2pcsTeSANcF5ouihhxkc5FFxch7stJGhZF2RZAyB/kUgBJ7yGMq7+Zvk3JHJwEBPIFW5xcmJ5 Elfyyo/dggbCPTv+dANpbmZBqF6tyIjJLMmzPzj5Ycdgffmugsbc3YMgYLdH7i7u/aglST0P/9P8 QrRbhYJHvUSK6WVgfmySPftn86xftMZYxm4bDTMxQHJU+368e1fm59AW4pUUli4xu28jknrU6ag0 rZCyeYG8sJ/CwpJ6tASTq1zGk4byTDLxn7shHVfyNU729Z0EVsrqqsC6/dViO+O9Zybd0A9Lm1mt TDdsElU/eH3lq3D5kMIt/OW4QkEXO3aSPSoA/9T8RjJgFFceWvDYPSp7eSG0iuZY0leeQLtQHMJx nJI7fhX5bJO2h7qfv2MuK5N9LI6JGzo+xoWk2AE+v861PsPkyhpiFkCj/VtuUA+g6UlG0Wiy6ZrZ 72O2R9z3XyJKw5J25/oa1Y3s7CF/tP7xgDsIPJP0rKwpLRmFc2zXgt7+FRElxM1uu1wokZcdcntk c021sJf3ySrEXikJ89H3vt4GPT8vzoMD/9X8YVa4dEtIGjZUcyu0o25HcA9c8cU21gN5fuiJxFHu KHOFxwTk1+TnvpJaIr6raTweZK+VigIkLx8uMc9P0wKZo013MWlnlbyD8ybhhmz1z3/OnfSwzSuJ Ldkk2YV87T3Y/Sm2umQ29vGs13JJI/O98Kxz06UjB7lq7NrbPDIzAzyx/Z43b7mPTPTvUCtMJXiQ Q/u4vMkFxMsKtjk7SSKDWDVrH//W/F/SRcXwubiFvKjSQr1OAR2FaMVtdOpU3k8EbvidoSNzA9Rz /Kvyc9922ZVMUdsfscTNCHmOxmyATzyT2ouYY9It0kDNNcyYUtIwPPOce1BgPMtvbh7xR5Uwtv30 ivnefp69KXQ9O094pLqfVoN8jbovtKNHLECCWUnbj8a0p9jRQViNfJS4WferIxKLnBD+hpzXoiYP FGBHn51CZd/pTUvesylBWsz/1/x1ZLa5025gQTRapcjdYFDsEZzyCp9c/hWPDfagbTTrCNi5tp2F y8j/ADOCMfoQPrX5e2lue64LobaRw3iSW9yuxk5BZDhz1B/Xr7VRg01LKUGSYvGXzHlyQCe2T6VD mifZvqat/NB9ik/ekTkBFOQdoz1H61mMyaeloEkiuFmi82dgP3kXJXBHrxnn1rNu7uaJcqsTQPbi 4XcGPn8Rt2B961LrTLfCS2m83B+Vlc4i5xyDmkM//9D8ZrvT7w3CWcypFFF+93s2U4/ukcGtW3tY LhPKnJjbOEJHGPWvyc+kplqdxbxPZpsZihjR25TPY5qgFgNhOkty4mtoR5aqm4M2Rxjt3rOXxo2l NOI3TtRutNhj2TTQNOwQwxRmSGQnP+sx2HXJ71u3En2hHErOsjqCjqBtH1FdEtjKnsRJErRvA0hQ smEfhgD7CormCKBxqHmfZWjyHKH93JkYO5Twf/11Dv1E2lK5/9H8fYdKkS0eW3CmND5sSZAjYHng VdtruOK3hlvIXiSaby9qj5/w9O/WvyN3jFo+oTSaKNxp9x5XmLKJoixG84VyPcD24p9v4b1RtOkv bJnSMBkeeMcQfU9PwqebllZHNiHaTRd0+EW8a+Y4muE4Lg7g5HqPWrSyfa7tXZEjlJ2kbsRpnr7U 4yd1EUnbUpXEkOn/AGu3sm86YndtibEYkPJ+aqFlbXtneyC8LXb3kasiudyw+wxwOvet5bjTTP/S /I6RxYywPOJjBcS+WYoxu8vjk+3TqalIayj2RBSGPmGWEh1O7nJI78jNfkU1Z3PpYtehJNYNcwo7 zOplIdmAIYge9Z4R7iGRLabyxG3lBmbC7jkAfpWE+xV09jcSwj020AuWcGRRuZslHJ6lRitA3dlJ pyWtnFuQ/K8qv90gZP6/zrJq6sbLlUbMzNGiu5kuJJXjjRGMaOfmYED06Ec1o+UwhdZZRMx+d5B8 hcZ9KxcXEuDjJ6n/0/zItC8zxWQma0hvoBG0THbGxHKvnsc5x/vGsl4YyJ7d0R7j7tvI7kcjpmvw 1OXU+3VktDbtUNtBHbykLJt2yDOSD9Pyq4LSeZxHGNjHhgWCLj/aJ4/OqIlZq6IodRe0muYTEskU sBtn2qrIy99vbPyggim2d3bpBcQmEEyggSrncg7j0qZStsLnSYjrItvBEbaV7eSTaZ9hby8AnP8A n1rRsZFhtJhHcri3YbBcN++fJ/X/AAqHNmUpq5//1PzpuLuLTrRbyW3ubySVjj7OnmAjr+n9amnc 31ulva3Ulna3qYETkoYw2MBgf6+lfhEn1PrPaJOwy+0w2q27XkEbXcdssMd2iBTLHxgqR1BwPyqC +1J7OxsrKMhIppWuNqgGSQqApz6YzXPpbzK54mpJd3l5pIEMrRTyAQziT7s8WUKY9GBUnPp+NS2c UaD7NcSMsghL8jzCcDPIqJRuhpp7EDaT/ay22mu0ktksjXoihcomQOWbH0HX0oW3uLbWrcxrHJpq wssyvKRMGGNu3j6//XrGUejN04tWP//V+GEkGZTEQwk+WMEYZT0xmobGCfSp2njtreSb7Sftlncf 6iUdCSR3r+cGmtz7dJLYsSRrPIJbZFia3PmBMfuZCedvt/8AWpirNeSpLMxaO3BCQbv3anucev8A jUtJlRaTuxfPYXKmS3LiJlDgMFEqZ6A/QVugyNKskPlpuHO0iOMADgHPt+dYWtoW5LoTx+U9tqNz dXUZvoolW1ilkAibDYPPXpngfhVCzuNOvYC89nBbXEblg8TFlz9T19aTSe5XMkf/1vjfUZBp63BC JffY7YXDwqxPmBlDKvHPOQPzrIvL+0ubWzvri2ms7i6gSe7MMRhj09RyIwevQ8kgV/MnIj73nR01 4Jrew828S5tXBjltRExUzx8FcrgHnj2x+dXZ7u4eNru7BjXyVESRxbSRgDLfUU4xURxneJmQ2tpe H7fbpcW7g+XJJNJlJMdNo7VbtRcR3iR72VZeRN0SQA9z74qhOa6GodSLag1rK6EwSKkCvgQyFlB4 zx1/lVGWfUTHPcPAIvKdh8h3LgEgHP8AnrWTj71iFPVs/9f5INjqLWlpN5Qck/aJSsm8uhJIb2xx wauadcLAuozMZpHeIQtbou3EfJYD3OB/kV/MNrPc+6k7kBu3eDZG8zW0ZCrJKux0HUKw7Hr+taln KI7tJJw7xzxDMgfcyAcABT/niom9GTYtXtwJMRLLJLHGd6Mw25PuPWo0t7e4jWaa6aG9gkKtZyQn OFAx83TH+Fck11OmnpYgvLNpJjqWo/bGsp5Rbj7Gu4QSZGDsHbkfStUQ/wBpSQ/aZN0Nq48hfu4x wCcVUVZG6fU//9D52u4HtJ75dJ1CW2jmizcqSwt7sIudhXPc5/Oq1zcJBb2MUP2dr28IaJiDuhwP m54wcdq/lZO5+ktpy0K76tJbwX8c8ENyZNn2ZuUktCMZPHXJzwfUVoWGuTvpyzQWKy6gjEhJpCEl wcLu44A60y1O7SFV2neNJo1ivLhd00Ub7lLYy20kAkD1Ipkdvsu32yu9s642OB8pqoq7NC3LJ50Z giQKsD4Ys3Xoc/rTbDybWeRfK2yzAb5B0x2z+HStWkxN2R//0fC3nlSMx27Ku4ktn5VcDn+lYceo SXUAOwpMR8gx+6Yfzr+WeV3sfp61Vy+Hgjt/LmiO6RtuwJn6mqIEFirSWYYZyHhjC4YnB3H3/wAf yqEWndj2LsLSNbjUAwj/AHR/dTuEZ2xyB/hVXTyt7cISILWGR8ztcy+SkHPzNjBzj0HWpl8QE2u3 a2C4huUaCJcNJYnzYrnrg8cnr7dPrUNhcT2dhJDtlhhvIWCXcjby4ZssBnv/AI1W8kmaQl0Z/9L5 6srOG3t0tVd5omJZ5ZTucFjk/qTVWS0MMkckrSLCJCE8s7UfHb8sV/L3Kj9b52NuDdnzRDOsUQXy 2fup+v8AnpVjTbeS3uRD9rLzrFuljD5glzjDsD06GojFOzFzPYfKZIpBaO8clxLIRvjI+cMcBfy4 rLu7WRonAnFvMkgXafl24PTHv0rQkqXmmxzKk0uxpYyMKwGzI6H/AOvVe2+1NIftcCxmFd8itkwx qeAQ/TP1/KgmTS0P/9P5ckuUstSt4oriXyXUPcbR5mwEdQc8cg8VVvNTuDLIss8Zso1/cIoZrknv kdOT2Ffy+l0P1DYbLCr2zwi8USqvmFJmEbDPUKD1NULPU7m0jjt7GV4sPi4mLFvMAPQrW0Y8rMp2 voXdSt1vdNg8twLu4kby7hHzJalTjkA8bvesmSO20UGN7aWa8JMd3Ike6MYGNxI98+1JJKWhBXl+ y+KY2Fk72tpaWjwzxspSSeeN1+dG9MZ/yKe0VvbRRuSzXQU7oipkkIXHT1+laLRgf//U+KrdIJom mkZhHJkhduGLDsR1GM0u8Xtos8UqyyQzm0NrPlJVVMAEeo64/D1r+bz9IKyWsryy3jrI6xReS0ca 9F5z09eKsRpp95ZT2NtdX9vG/wAtxZs5t4jgZGWByQMnFXGXKrAZUdrp0LiCzeeS2GGkcy8s4xuC nJ4yKsl0uz5LmSAJJ5ix5z5mzO0kd6tTTdjONuZk17BZxWc2sanFdXd+f3dtPG+CQo2gMMc4BA/D tWHE13qdqHgtltWjTc06nclufWQnjrVFtaWP/9X4Elmu9MltVWeG/wB8e64ZEWSONiDkDjnHB/H2 rLhlEmoysftPkyxgzO0ZAAHYA9+tfzufo0U1uT2ciS3Rt5nXyidsCk8MDxznpWst7/YryC2LqfsT adaQxufKhDDaWAB6gE9KmovdRrDfQ5S8ttCa2k0+/muH1OHEkKfZ2Vctg5Z+gyM8VRupWuI7fT7Z ZJI7ZlDkjakBIyqj616j+CJzpe+bn9ox+WBcJcRTJF5MSxoUiLKMAlsY7fqa5C8uoJsIbi5j1JkO 1YBuLYPX0H5VJpJXVj//1vzDutXtYrewkjV4dRuZfskx2f8AHwydGI9x1NS39pfQX8kckkTCW3Rn WJkmRMjflSuRnkA49K/Bz9IHW+69gcLK7tEPLJJO9QvA+gquUu7S9sr6WWSPylYQ+YnyTAjbwfQZ 7VSg2rgM1Ox07UUW31BWT7T8pPIBBHXj8a5uS5s/DUf2UW7NEdsa/uGkgRQcBmfoD9akNjoEuNKu IZZLW3+1XEUWWkiPlRszDK4fGOPT6Vy0j6oWiQ2qXc4cu5jmDtChweT0OB6UWMXN30P/1/ystrMM s0tyAWtovMTyVzMMkcZ4746d63NZu9c1WCxbUp/tUNpxZTzurPswMhn74x0JNfhkFbU/QDJttQs7 3VpZnKafqljp4RHgDBAv3QxOcAtgemcdOtJMAkMt3NKzFOVYHhqslu2wlpZ295bLM08cbPukKswR hjnkHv0/OucjEt3O8boqQuzQfaZZPlDrjIzXVSOao2c/LCtxKfszgRRnZ5oGd7A/MPwqtfafaz28 hM6pcKm0yn70eeBx/jXqUYrY557H/9D8G9eMQ8+zguGviICrecMEErgnr2Pf26V8L+PNNjebUbiw t4JRpaNPdwZWPyu/PIzliAFGTyK+Aoo96qfIVzcia5vYLoGC5Vi7CHJVATkYPrz0rnLTz2uJYrhJ pYrjAM7liYcEYYH8OldsFokcclZndoDYiEQxecikHzCeOOtdzoL2F/crJC7wRg7XBXG3+/j2611H I1c9RtmjtfMSJzcwLzFIw2nA6GpPD8Xhm61ib+21uGe5hLW62y7vOkjIZBJ/s/5FFh11sf/R/ksG ka1FqmrRTlLOdnlAlvxt2lt2U2EcbQcD+dZJGtLDaaZBp9jeWUDCV5PtpS2kdej+Xt5Ydj+tfIL3 eVPc7IWtoc14s0tU+y6zFcCyA3Ga0t0/10igKHkzz6Y+leN29tHG9y8sUsrOXdsOY1Gcn/IrvoSu h/zWKn22GKCS0ZpU+3AwhGUhHI6D61l6bZax/aNrDFcShvOVRHDJ5Tsu4ZXkHtXbGTbsKMNNT6D+ yfav+Jo1rN9iXbBbQJIZY7QqNufUsepJqK80uPTd89rf3ztNGHl85R+7kAOCoHUDPH8qsrlSvY// 0v43J9L0640+3vbZrQ6lOpkfULck3Zfp86k4UjHYd6ryTS6XcafdLZjVPKmSG5iux5iFcENJ/L86 41DVXOh7D21vR7m8ufNu7hLmywdPs4oWmkBkPEIYYAz796yrrWtTGk3QtxJb35dktPMhKzySHjyx nAwvJJ9AeatJJWOci0TWZlihGpxQxzGPZdyhiSz8dB0wea662uUjkgiy8dtMvyMUKxBR6duKHFMP Up/aE1XT9RTTL37NIYpIJCreWGCHOM5wfu9O9JZ3rabJYWRgdJ5rLek6RHZMFADF26AjIwDSt7wH /9P+Na7utVv4p2s7G4mg05jMZ2hKgEYBIarlvq4cQvNDK7yRqAZlGw4AGzr+lcre6AuNGv2BCIxY yifzhayPhZMnnOOOetV76++1Qz2dvdWkOqC38+2tVBkSXDACPrkDvyf4ajmdrAVls7q6v7jVL1p3 tBGttMYRtiibaQqgdOSOfYVZl0WaFHJML28ibGWXIeVTnjGMdz1qCuVmfci0t7eFQnkG03ykWUZL TkrgKUB2j612PhB/7RtBqUAtdK+wSLs08yj7Qh7MsZ5I4yc560Ct0P/U/jj1Zku55rXxDfSX99eX H7qRYv3N3l92Dg/KFG316ckV3WmQy6akcpmInEflbwd+2MjhR9K88DL1PZLq1pqF5dloEIWaJ4wI nAGAzY545/Kn6Xf6MLk6ja2AN3DLtt3khV0kUnngg4GQPyoA6y+ltPEUNvHf7raOynMkE9shikIf hlwOqjJOK5KOWC1uLixDNcRW7MlrNcLsuJAe+O3rigltbHN3Dy2OtaUunveC6uS1qmkNF5sfJBMh 65Vs4Hp+tbmoWeqaXcBnsgs0qtBcRlA0Kbhw3fBHagcdj//V/j+sp7y4maCWCO3SIbYmLGRJPVnH UY9KuS2cUM1qt1ctNG2Ha2h3RRyvz8pPocV57WlgJzpdxMYYUknijLNJ9lDbiABk5+g5rTW1uGja GKRzGE/dvI33fwrnGiG0sdSWNC03lXFpG7TOsgjtnTIxwec+3vUd7dXqWtzeyzR+QItlzZqQsBwB hgfXr19TQjZXtqZOgXrXBV7Ai3tyhUxLOYIkQj58e5GeMZrQjtJhqaGVporFrfzbWLd/rRkrlz36 UGc1Z3P/1v5EriaLS7e+1GSCGJ1wguETLqC2Px61sXV1bHQ2i2tNePLHL9pkAQiL+ID35/KvKigJ dO02zkguZrm+WMxxhoLWVT0AOSGA78dfSsjRZ7rTXvbNTNNb+e1zbpjdEN+OAepxj6806fUzkm2y 1canLAhmmuYrd7WYC95yPmGdo6Z4I6etRatbxzvp00cdtqEst6ssJmQxmzB+6wyOD7Z49ah2voS4 tK5HdT6jLbzRW1xPaahFMsdpcMA1uApy6he/GeB61dgFg14kupSF3MYRWI2iR8YJOPqTSLhfY//X /kma/gtb6ey022hdNyyec0flgkH7w9Mjr9K6LVbq5OI18tYRCnnwW43KQMMMflnIrxJ7WA5uefGq RmG1Dxy24eWeVdqqRjKD9evalv5Y5ZEhSGVfOiYJKisAh7jOMD2z1pPlsrkTTexiJNq0dubaC4uE EOIw93GVAUNyQcD3rbs9UurwPEbqBrZPkkJQM7Y9Hzx2qo26GfKzXtY7w2tzNsgigjYJHIZR5r7v Rf8A9dV7S4mId0Ms0luhWRYm+XHqQOPTmqEf/9D+U7RvEusILiyu9Xv4rPYdlozhooc9Qox3/rTC oNvGgn3sF/du5G5sdM+9eQ23uRFNpczK1vcXcMLzTWaW+cx+ajmaOTHQhiOD9KxnhS7uI9UuGaK/ tw0CeTKTG0ZORkHvxmkVZbG5bLEyyiZFuPMUokMudqt/eIpllJFDEba+tAm/cIpUlG2Mc/549azq dDNPl0Ihv82NrNWdU+VA5LFF6M1dhpej6TqNzaQanqtxC0srW6MxX7Iu4ZG49VwQe9Zlw2P/0f5f L7wDrXhdJNUspdIaO4laO3ll1OIGWNTyVAzx74zXBp9sVZotQWO5uBcNLHLaktFGp6KPX6189GUZ x5o97HOa+kuQDLLhbkK0TRlcNtJ4/MCs65uJW+2TTrHY29s+5IVkLGUA4LYPc9cVbjZIBhJ1DzFt 2WaHbvWXmKVmPUFfT1NTWGbZfLDRhS22fLcoRwQvqaTjeJsl7ljSOmf2jDNBNLCqMh8uSZtikeme tXNOtoNE0XTkmuLeTVYppJZ5EX7gyPLXJ64GazkrNGUd0f/S/k/uNZuZNWsvsU0ePtJM3mLjOzJY c/jWprd9BJHptrpwiivXuGN2fMZXCkfKwzx14wK+fCdndopW6qcRm4c3MUvm89JMdefQZA79anTV Yl+0wmN7dFOJb6NN4k/H1HpTbb3M6fYxrqWGLZqslvPq+nBo2EQGyW7AI+Tb2J/TNa9hfWcwRkt5 9OtQfuSMrXEeeSTgAH04FRJ21HTSU2/Mm1iG4mFvLBfvMFPmRSRjEUowVAYY44/pWdfTzXqLZmJU uIRzJESqMOxJJ5NF/cdzVtc1z//T/lKXSVxZh3iikeMeYwl3+X7vjp64rPuLaCy1i0trB7mOdEb+ 0LyOMixdWGFCNjk564Pevmobm9R2oSZmWcOsJd3H26aaOwgPnTzS4VZk3EBUPfHHA9K2ru4NxHd3 dpPcfZZiitG7t8yoeMDoPXihptXR5Lq2ZaD3AhnaVBIjxDzAH4VCOuPxrG1mGCwW1hS/a8a4sv3c AdXhQv8AxNjngADr68UnFp6F+0tsie20G0QILghLVo43b7MSxLLhgOvrjv61pyWh1W71B0hbCwCJ bbB8tUVTyCepI6/SoknbYftD/9T+TnSjDbadPb6gPssyu7W72+ZI7oZwkbg4x9RWhZRL8rwwGCRU WPCEhdo7Ka+WSaVjlc+rHSai9u9/Hcq6iVlSG6uJ9kcD4XlFPXABGOmTUXh/UNYvVlsb2WWTSGn+ ZkiFvMSMgvj6dKZpGVi7daZJFcXl7bzh7OMraCFuZXDE7XZf5446VVnt5kSLYyXLAb0G4bDz3x07 0Fqd9DoLjR9Ol0Fbxr5v7Ytn8+CztyY1YEEbRJ0br0rP0e4a5SCyut3mrKC/ngmMnOcBsc4p20uW mz//1f5WdUM8V9dTRLtithtmcHaGORs2nqcdKYZ5dUhsZftFxafYpcz+Yg8q4BOeAfTPXpXzcFpc pSa3NeS7inea0WJWIladL9kKtKpAHJ6Dp0PrTY7V5dwc+eyr8qKMj2ogkUp30ZHcR3Fjaq9uFilm myrAkMeBuH4DFQxWn2aKXUby7s5oJCEhgkuCLmCUnJ+UnJX9P0qXF32Ik9dDUlvQYngmlWL5AFWM blYGq220W4tobW5laZYvMnL4VnBBDKMdqmxhJ36H/9b+WbTrTSJdQnbWJJbK3bdHC1vIFV2b7qkH qanuPD9pazQS6RqX2ks5a7DjJiXnCAe9fLnI1bZGbPZQGZyZhFGp4iX59h9SfSrtrNbQKqzzxzlM ZVARGc9qlxTMWun6FxUit2+WJRDN8rwkYUj3H+FYUF/qenyX1jaSNaWrgwvKqMFRCeo9sf561Lh2 KSvohlvY2kEs0gma4gly8v2jK5YjBbBJ+v8AStK3ksbG0uBH5zS3ZC2kY5gUr29hgHpVWdrWNIKx /9f+WKWGzvNPcXUCw3EYEkhSPz3yTtAz+ZrVkhuDHA0Z2RkiNHk+VGx618va2iMPUbb6l/o97CYL b7aXENvKznYvOM8USTRWMe53e6jyYXtljKlXAyfm/wA9DT5WtLGyelynDLdC2uLuztxM8X7wW7Hy /OUYyCT071ux6hcwILmCQx/daWKNfNQnjgjHI5/KqUG1czc5Xuh9xqcmsNcT/ZYYRbKFbyIxFEwA 6AevqBWG1zFb3CGaFi03yxtg7Qe+PepcXpZmVSc3JSP/0P5cy0UBWWMbneQlogOAOtdPaeW0aXok SBEiMwKMCyqAeT6V8xKnFEc+tjI07T2uZoJ11e4SwF21ybYKMnccljkdOT+VVdXS6ub10tLlLGFL gR3LbAzXMfALCT+FsdDUezg9xxnqM1LVLBdffQlhF1p726iF5RuLHHzu2OB7dua6HbbxwxJEqJs5 BX7rAevamqcF1N1NWsyuZ7N7mCV5ZUgRssYX3+dx3HTr9ak1C4kElvBY3KwxzvmQO22QgcgU3CPQ l2WqP//R/mJ+yyQ/bYxLLJFO2LfLEbePmIPYGna6kkdlF5DBEuP3W4PuKcfeI69f518oqd2ayd4F XTtPkstOhkLi5ull4JH73H972rUnvRFE9zLIJZgwVIWOGY9/yqHT5atzSCVOml3Mj7NHd6lDePvX ypFuAqOUJdenTt7V0wgutQ1tTaxR24MZlncy+W74/vFuuQaT3Ih8JJe21i8kltLeJC4U+YYTuKjH oPpXL6JY3txfy29j/aLxWEJkWdTlSF5JU+3fikNuzSP/0v5l7uCK6luLi4SaaOwtRcNchz13bdoX v1H51BaX5t0ItLyVRMwYrjayg8BcEex6+pr4yavsbS+FlCeHU7m/eYPEIYEEgU8yT46/THHHtXSW 99i0R7lXWMSeTuKkt1A/mf1olHS5iQx3trpN00Elr5enSqWWWNAAznoNo/U1z889jlrxFljkt7rc sUsZjikGecg9fy9aztpcC5dnzbBRZwbZnlzlyUU5xk/hz+dWpYoWhjtnDEPGEfJyWOOaEruwH//T /mkt7Ix7tmAFQMNvy5H0/Ksi4kWKdonhdlYeYCRgAg/1r48EtEbGmfY72VYp55LQzx7RAxBWFu+H 649+1VZrpLO9iSaLfHH+6/0eIZZQfUDGfc0FzSWxlahHNLvvLWOC2CPvTfL87Hryv5c1t/bbeSxg v/kaWU7ZDjAL9GH55oHCK3IU1GFpU2w4mZSyNt3AgYrPsVvHNw8sztI5JZ5DtyMkhceg/pVxVpWY Sh2P/9T+ZGS3S5hc3AEDviOSaL5GbHHFT6nLBDZRP5s1w1vCoSWJPMmcgAbcDr7/AEr5BqzsU4tE NnfWt4phud/nSnlXTaDwc7u3pV1HtrTbBbwRRO8nzSlismADwPUd8f8A6q0UVY1SsrF+21RH8/YV YIuI3I5PUHI/KoobU3xd5CHJOMMRn8BVNX0Zm4tO5IrmzjltEUNFOnkuWG4AZHA/Kqc8sVnazFUL RRD5lQfez/jWLVnYu75rH//V/l/k1jU7TTBBZ3brGNSS5ngID3MysSpjjB5xj8RXR3VjL5NpcLdO ktwnmiNcHysEj8c46V8eaSk07IF1CIH5Y9+w7Zd42E4/u1dnvLVUN0sBt5oLdgrxoZ5DgH+Hv9Kd 3ohOV7H6Bap+wxrsX7Jl/wDtU2Xxo+GereGJPDNrrmgaO2rRf2jcXHnxxX+m/u8lLqE+ehglVcSR 7SVJBr88HmltmWS1Cu0jKbhc7A4IAOD7DH5VnhsT9Y9ppblk4/d1+ZwZdmazCpiKSpuLpTcLvZ26 p/mummupSvLm2vblINN+1Oykx3TSxeTBbt1+WToev4YNXrKYoCJXDPANhwM7sdzXTF3R6bV1Y//W /m3E9jITc3qshMe5HYFTxzj15qjCyC4eW0kxaXTHfA2WTnpjJ4/+tXy5ulZWRSuEW2eSHyGupF/f xLIpVAedpDYxxUYgnvLiJ4YvLzCHEc0ohjJXrjPvQCVid2unaRhGIDbERgRvu8wjB3A9Pyqw8l5P bq6RLKxz5gkkEbKAD7c0uVXuMfo+rQ3aS28cEqmzn8i4S4jMan3X1BHQ+1GrDT5btJDAggiwZUj4 c46hT70wP//X/mQ05LWOVmhtZIoLuVvKiRi0cJzknn9frXXXGhCKCO5juZmjuYjFgRhRGQeTnuf8 4r5SUb6o7KZyGrXv2CCO0h3NFE3GyPfK7sR6ckn0rY08yyRI4EqeYgIWWMxt+RrI0NV5LO3bzbh2 LpEU2AFifw79K563NwurtdRTPCZYBHECPLYAk/iOuKLdAJhqSXVxe6SkRlmjj8q7mlBVYt+eQ3fo eh9apSxGARxRZeSHiO4BywxxwT9BWDTW4H//0P5l3SZLmO7klnEnk7W28GbIHzGra/Z/tMMhlkTy xkgEbZD/ALVfEqLZ2zWlyWS4tLiVxjErfxE8cYAIpIrKJJ1uZY5bmRVIiWNsbM+g/nWjirWQ4q0S Rb2J5fsp4lcZwf4RUUtrd2lxHLBi6RmBMZfZsHfB6ce9JR0syjrIrpEjdCVaR0+UE8DFYEkU0sdw 4yxQFz6cVXKgP//R/mstLiSJA9wHDADy0HA+tXZ7gF1uWleNUUmXIyrDHU/SviGrOx6sNi1aFb2O WUzT2+BtgaNBl/Qjnp71LbebYRy2dxLcXguM+Ws53PAxIJbp3AxzSCbsrEaMsEpWY7cfdHqabLDc O32vcNiEdTxjtmgVPewy6uoZG8xchggQoWyoAHYVH9utT9maUPGkcmxiuceg/Wk2luW3ZXP/0v5s 9QQXdxAPOkZILgTtJGoyBzhc+n+FXbHUWLz293FK6In7qXG1W+p9q+Abb3PUc9dB06xMmyIAKW3e /wCNU5LKa101k05YYi0u4oCVDZPzHikHOrmjZq+m20bs2S5w7yHO4nqOahvI0kKGLzHLELhVLYP+ FBMpXLCMUt5JA8jFBsk8zIx7Amq1vJLLHtRgI8ncR1+lBJ//0/5t47oHU4rIMwaGNroSspKjaQAP qS1aE8t1M7zNt2oNxIG1B9a/PrI9AS0u55BdW8kl3GihXQomI+epDdM8frVozwzP5NsLs22BE90y 7WLhRuGfr/OhJLYDcgnjEUD2mZmtDgxOTiTH97NXneC6laa1zHD5YYxSkIVcDLD6Zzj2pl09zNnl eBRMoXcw6IdwHaqUWoQ3dykCu73VqwkbZwI8jPI6cigc49Uf/9T+frULW4aO2nhnjdnzujRvnUcj BXsa5q0a7i1OJs3cBicllKlIJe3Pr7V+fnpSVnY7Ka1zNHeKzYVdwbpn1rNnuGmummaUyTEbSTyQ BwKC4wW7GCWdX2ToFjjG/If/AFo6f5FbMJ08WChDtuWcuwYDnPcn17UW6Gi7kVtEjecMuINp83+6 c9TVaZp0mit7ATNFxGHZMFQO7VzmkHdan//V/A5ri9ZPsks5MA58onCs3TIrLurTY4aBA82z5EPB yO2fyr83Pfje2p1Nhqcmj28Xn2RvxJHtaBWw6Ejsw9DXP3M8UjpdThlJf5LYId+fcYoGbaTxzvHJ KCrMAoDj5l7dKZFNm6aJ5OP7meCM+lBjJ3ZFfzRvdzQxxFEWEYWM4c8YOM+4/WrFlGLSd5IZWuxL bAWySOUkjkH94e1Aluf/1vwgSPWVVmnllnViZJQ+1UjLdQpAye3rWXFqGnbponElvPFciNd6ZEg5 zgj8P1r83PoDs9NeG4tJmnj3ZJESspXYR0aqcQe3SUSRnduOGz90ZNAFW6umS3W/kiSOyjnEC/OP mcAZwM56YOfftVyB4LqdY5y8SKolj2gEPnnB5ot0ArXmn2sLb5GAad8Y6Z7CrkaPBFEhUvGOpTLB PrWUoqOwH//X/D2KHcs01vFI+w5cIM7jVqaGf7OsqxyIVGJE6EY61+Xntr4yhZW1tHcCSK3O933S kcbsdzWzezw/aY5EEoCAByF+X6UGojJYSzm5jDhoYwY2IA+Y8Nj9fzqdIHvj8yrgfLnf82PpSaui ZaRM69tDpcCRPcvLEZibaHPKFsZVR+A/KpLa9NleGEwSyNJbB0dYyyiQnG1hWFjE/9D8UkvW+0CI p5ckjYJb5Qpp8JmW6lHntHGuCZVYpnvX5Oe656aFx5pr5zbpsnEmA4IGeOQVP4VFHE9rG4mJHPHa gnnexnxXLR3sSJEsyzK7BmzhMYzjt/FW5b7Zg63DYcDdEM8Ng9B/ntQQZ9+73aC0lCNbQlZVikAB gI7/AKfpUS2Nnqk9vPqFo9yts25NspVJ0GPlOPp70F09z//R/GqPWbCyhuoLbTxZNJDvEMbFhGeh OOSeBj61IupRuqWyK5Tb5lxIwwqHsPfpX5Tyu1z3eW8rlS5lNzb5gBaVpQdzE7Qo4P6CrDSaY5sL O7ZpHfJWQoW8kjjknpSSb2F7Mxo0M7XMUSmREYqxI+XFRCxlMM0U4MSxyAhXGGZCODj0rSGxoaqf ZoLRY2JYY4ZR0x0pbEukwuJlGwA+XER064bPrUWvKyA//9L8b3ujLJKrnLhP3JXjb/nmsi3ZGd1i GXRiGK9CQea/KGrOx9AdGZZ5tJuBFHH9ohYK05O2UKeMAd6xbC3vLmBvNLFLbLGSVtgH09T7CkAp t4ppV8yeN2QfLH1Zfeo7mHdMIEDq7gASAZGB60AR3NndsZFtw08tqu7zIv6d60ra8vp7C3tbiMJ5 eWYEZkY9tx9uKAP/0/x5iMj2oSQZkEhUFjnA7YpLa01P7ZHJfSTi2UhViZMtsB4257Yr8nsfSwVk bGqQw7vlRUiAzHMWwfoRXMx4kmkjZAsZX5ZVOS/6VEtJIuSvGxekju9Oto7gxtPb3EnlI0a+YU+o 6ipW1CGNwlxHPsaAlX2YVTjAzz61vPTQzhpFiQHydPlaU7prjUYzZuxIMUQV/NB57kpj6Va1Eoul T3ClZmtxuWDODKal7IzP/9T8g9N1pp7eOYROhMfliCWP90x6Yx7U+BVWF1f58MWctyFOeR/T8K/I 6jskfSr7LKqakfLK7N7K2HjToR7U9dav0jmsLeWeK2mAMluCVjkwcjIrF6Ns5K79/wCZm2U81vcX xK5jXBnQcleOCB2q+bmJooprErcMrbriKVjG+D1AojKyTNJ6RYMkLQtLp0S2wG6Z4ncIN3cDJ5/z xUuhtd3cV3fzQ3Mf2G7itZ45lAlBmJCeWucsDhuR6Vcarkc6leSij//V/JTUyltcOXkyhxvR+Mfh Wa9zHbIPKDvBKdxA6A1+P3fU93m97lL9rqsstpIJI1ATKhWX5to6Y9DxWWsJljjZ8xfapSFjTLbC ORz64BP4VjzXuaRfKzUkuYJYUspLmeedRsSRhlExwahgs5rON0SaQRzH5gq4Xk9akr2j7F+RrywS 3t7VY2juGw8kkm3yx/eP/wBel8rzohLKZ22PsUwOwRWPGWA6jrxUTWge0knoj//W/KTWIJ7SytWW aRZiwVVPL4HOamtpMhpbkmSVU3MzdX75r8Q06n0rrz2sY0d6r3Eh81j5rHZlsnPoP89q6qwuH8on fNMh/duRlhH259KpQuri9p5EN3PLbs22UAOAoVyFVfx981u6Nrlhbsg1DQmurSO3IkaC98l5ZD3b Knj2GKlprRh7SXQ1rTUILv7SluxaGKLzXgLAmJMgA4784rLjgmS8aaOC3n0+4tyHd2JljbsQtZST b0KjJy3P/9f82Q4thJd+coEUZHkZLPjnJAHtVJXGowSpc3YiQAyW8SIRLNn+HPYDrzX4U4yfQ+mV 76msP7Yj0u0e8XfaiFk0+4kl82R0V2Vs/RgwqN7OGDSUvbx0kmRiiOzDzyG9F9PlGce1S4WWpTbZ UilvfspmSf7qhLZZslBj7ox/hW5a215NO2rl3DyRNCQh2owHLAD6HH0rJwu9AV7l5rgm0lYXL6fE 8BFy6DEyrxkevOOlN0qyga32QXbTwJEXErt++lH+zn6/kKicEbe+f//Q/PxYfKieCO8Zn3FRvwko z0IH9fWpLO/e3ElvJEzzwAAiQbRLkcEfl1FfzvOmr6n2kY3VwbVbiO4s9NjilEbuZZI4YdyIDxuZ 8fzrTIuDczxQlPKTBEin/WeuQen0rNwSRoaditgYWuboN50EoWOMsUD8HJOO3TrSzT20729sU2Z5 ZW+5JyentjFYuCbAo6hax3Vx5Kq8COcAglkGPersKnTIGgjto51RsxShy24ev/66lwsrgf/R+IIt Z3M8qwrLKx2rG/yhiOAD7VYu9Ttrx7XRlaC21q8HniAD7RbqqgN8rdCfQGv5ntbY+0lJrSxsyXUl /bwfammQWuYzNcZG0Lx1PYY4rNm1ufVLSKzt5XFtau0cc6rgXKk8891HQYx0rK7UmiFUlbYx7+4O lxA3F262JAjO3O1WYjoeoPOK6sIlomjLYX02qxKw+0xXKGKWOMDJyw4z7j0o5ilOUuhdnvYpLqKW eBGjWQKETCtEozjnv6Z60zXriU6clvbRtLNKxAVpdkIBA69+tLXcPei72P/S+VNLeSxubKx1ixuL d1g/0xbWQTRxtt3LknoG+Xn3rTbUoomupISIo58RNbBN21VPUMefSv5g9T7mKvozEvrRbgyLCZ7e CddtwFkCLIezgdiM8VNbQ2kFoluJLuWVflM8jgkj3wM+nNU4862OlUk0rmncrpt5p1xbLOBdRqkw 2koxIYFRuHTpk/SqTakYFmtpNPu57i8hH2G7WFmhgkDDcXYYBXGcjPGRzU+xsX7OJsWVvPZrepPq H2uJrdLlbdV4BIGVGe/P6d6qWl8llMtqWFy04aVRyNucnB4/hzj8O9VKhZXNmoxjZH//0/mS4vIn kkZlOUXiIN36fzp1nNFdwW0VxFHazCcmKaU7JFU9Mg8AY7+hr+WIQR+hS3Zf86zBgW2exmF3K0Lv NGHbfGedjngH1qlf3shvvPgFs0ywiJIoiEDMo6ug/Dmq5HexqthhSS6uTqt2zytFAtn5a4Cw5OeB 74/SpTqUFts3xTMjsE/dRmR1zwDgVolZWRtzPlTKV5cz8/ZowrzPtRycBOOrD8quaTbSx+ZFeXxu 5WYuZgvlZJ7Aeg6UwmnY/9TwETW0V3bWtyZI7efcpuVjMiQkDjcPfP6GsKN7dZJI4rhriNnby5Wj 8oOM8cdvSv5fP06HwoleHUhcWrWOrW9ibdGcmZVnDgjGCDyO/Tnmswf2jEFkJV7tQS7xjbHMc9cU D6mlAs0uy2lRQzqHQbs596tXlustytrLGYVWIZ2n5mbGAQO4OSaycZNmXNZ3RWgtFtYpbRcRKwJO 7gMM5x+lU4bvT726/smeW7aFIvMkV7d4dozj5ScDk46GtLa3NYu6uf/V+dbi5gF15Nq8kMYVRhzk seM/yNO1STz7eKy80okRMzOmNwLAAkfl+lfy+fqqmupkwRyssJScqGdSrMAVmAxkMCMc96tXNxbQ 6k0MVwJr9oVMoh+dAueF3DjgnpQl0Qc6Mm+Z4JAAHExmUgAEvnI7VPLcuzTjUIyXfEolKjJcE8Ed vyrVQXUfNEupaPfW8NuIyXkkEqvk8bTxgfUfpXO3kt2Yb3T5eYJgIgQxSVwD3A6fSk4aaGcndn// 1vkFm2HbLNG1y0a7AODtAwAfcY/nUkNr5l3bzIDIFYEIfv7hjt9e9fzJGFtWfp03ZFPUNNurjUTf SzXgjhkxNFvG2bJGNx6+3UdKXUMpqUf9kJ5ct1F9nk2uNirtIbJPHOSP/wBVWYlTQ52+03Gn7kDt J8rNJgbs88k45p2pzalZXqpcOyzytmBXT5GxwGY45H16+9FgEuxd6OumeXYj7Lf7xJdRScq4YY/d +nJBPbHvUFzcPHLDM0jxSRPuE0TFJY/XB600ruwH/9f4ZvD5pt00hbvUdRnmLuGUINvVm3cjgZ9+ B7ms6R5kvorqMG18tlW58lMyzKowykep71/N5+kW6G/b6wBNbtZi4jd2YuSmBgA5BHb8etQ3ttDI b28Fzb2ohtzO8bEoWxxwPxP5U1FvYbVnY57TLyC4SSGBC42b47hOIV59emfatfT5L1TdCKW2e4MD RQLdFUQAggHJ9f8A9VUoMyivfZmRJf3zpZmZY5J5tkkjqfs9uDj7o7io5dGmsXubP7W1wjSkPIMo j89h6Vqk7WRof//Q/PdUluZ0tLOO4cwMHYwoWD7ckqfbA5FBmn1L5LSEWcbPt3yjCjBwTz1HHrX8 8cr2sfpBV1/TPsFzHNEkn2KUKkUzTKPNkCjeQBzjOSMdiKrRSyGSNWRAI13pub5mI9D61c4e6ioO zbIE0qG/1Ka4udSlhlkiDx28mDEWU8kt1HXv/hUMUMj3E0vnvHIs4nYxsNsuw8b/ANa7paRjfsZR V5stXutQzsbaWMh7gEMVX5VYDO79D+dZNjDbRxX13BDO13Bm1zJGTJPnspP8OD1qSz//0fzetrN7 jSbwW+laXd6sbiI2895deTJpyLnzSnoWBAJI7Y78Yl3pkrW8OowXckckV15UsMDA78/xD6Ec4r8H P0gntbO8xqE9sXea2t99+dwEmzOACCfUgfjVXFtqeg3UlwZbO/tZWt4PKfzBKuCRIQcd/l+X2+p3 jshNpbmML+10/S2kukvJ7pE8qIKhkDkenf8ApSRzS6nbpA8ZFq5DyCZNpY9MH6ZoaT3M5SvojZv4 bXS9IS2imAkv4GaWIw+XHH8xVMNnkkDd2xnvWDavdW/kgQwqjqd8m4l2xnmsofEQf//S/Ju+u/t0 V09lIIpdOjDXARuGycc/XPSuhvntLj7DYpdMqW1vFLcN2DSLnp3xn9K/Dz9AMA3K7JbKWwtonW4Z 1u0jCXFwCAoLt3GAMA9KluEmEEduIxNhRMqJ82Ocg0C5UYuo3lzbWcptLNZbuRPLUOSvk8gkr2zx 3461ZsrXWG02We/tbKSAQBoUDYniboZWXOSfc8YrqpGMoW0ZzVrYXtxJdjSPL88RFvIcjy1x1IXj nntUK3qNp0m+KIMX8ueQ8sGXgr+detRRyzjZNH//0/wC1+G3lvbidLlrd/K8mV48rCq8859RzXxT 8RZNLuDcfZWWARXLu77/AC2kZcrukOec46H0FfBUlofQVkfJt5bXi6xcvDEskXlB5ZEGUOTktj24 /Oopblobmc/61DAsajGDzjPFd9NHDOX4F2zuHuCIWEqRDBDMMIh9M+9d9pNpEGSI70DgNGsK7zKc jI+nJ5rot7tzjk+U9OSC6sLeS1kWMfaYlW2c/M4Qgc49ua0PC9nNPqsVu8CrFHKhjuy2WkdWBYYx 0IHWk3aFh15JJH//1P5WriC+TUriHWpra7UqbgXFrPv85XG5WLe+R/8AWrn9Ku7fTrkk28d3bxYk jgztVgDwo+v9K+SqU+VpnQnpoZXxH/0yynu4NLttNimtxHHbI7OGYgnec+vXj0r51eDV7CC2vbyC L7LcLkjeGZQvB3DqB9fSurDL3S46vUiiji1cpdR7IBYz+cvmY8gqOmM9T7D1qLTiXvI9SaD7VPDd 7wiSbGj5xk49s8V3U9yoy09D2jQHuEtEinnaNJ7hpGUffKk8KR7HOPbFWNY03Tgt5e32q3UNpY7Z oIigQSAY3KxXnn05z0rUq9lqf//V/j7uLi0jtrq4stP04vewo1thWiEOAMFgOeR1zk8npVR4/tFn Zia6he8dS11a2ihLe3CgbBu6ktz154965zeT0ZBZ6PDGrXESBnM3mlI0Db8evfjH6Umu6vay29uk Yja5WTASKItL83DO56jPH/1qDA5OXRVUwta3GH8wSN5w+VyeSvtyePpXe2j3j6fDomr6bD5ke6VL w3GDGrDKhBnBB65PXNJtJ2M5PojDlhisEMNskTxqSAoITDdckVdimCQQfaGe6nmthJDFEuJLd2Yr 5ePYc/8AAql3exCbWx//1v48NRn1G10k2zC4s9PmBw5YgvKTjG37v68dq5/7RZ6MVt721uZbiYwz 2SMPMhfd1JODjsR0rkcbsxUpXOj+zz61dwo0aW8aw7lYuIXY9ctnjp/Son0qxsLlruC28qcgKZZS Hd2AwWDY71MoW2NiK71TUXsr+zhjiWKS3aNFDGMFz1Yj1HGKdb63K1hBYTRrcy6bbpCWX960/GSc 9z1FJRbRtFNasl+yqbW31G5TYlzOsS26OrvhzgbwOVP19O+KsWrWVhemb7N95PJKodrN6D86vkVg lG5//9f+PazktZmmP8RlMeXTLR89K6CZV0+zNzJKZSkRaCMDjA7f59K4eV35TRQ01MNpbbU4XguF nQNHiSRAFxnBAGR+BoUtb2lq/mxb4o2hH2OPb5q7jgt6nB5PfFSZ2NdNaKQ2qgCYtkXKR8XKDoGA 6Gsd4tMbVHkeW8kuEiVjJcjCuc5G36UGDTT1LN9dzS65oWoxXrRz6UjfZbWMIjSgdh3O3Oe/WtB9 SWZ53uLhsTN583nvkg+1BUHbQ//Q/kItmk0vULoSyC6ivdPZIYZQFltmZhh8emOh9qg1RI0S1Rbp wZFXeImEjqcjqR0xivOezA1ILu1RJXDXFvqQxFbOmJluV7/7rdPXOK0oLmbW9NbVod+nSWOLeS1v JVt5bxwcbli6kHGeMgVgNaPUpDUbS+muNHmPlyi386ZeWQBvl+d+g3c4BNT2t5b2scuj+XFI0j7N ilXjOwHaQ3+FBuX7O2juH8qeKCN0T5SqCMHHABI6/jXPakzx6zE95NN5EFq0cEKH90jZGDu6H6UE T2sf/9H+SK5t4Li0iBuIGPEyQh1lPsXXPGOODU1kIJLe1ivJIvMuH+ztJKBHGGOcY/T8q8hOwm7I iubK7s0mcmJ0TdCyiUM4wcdKZZXeqGbTE0xbfz7dXT7MkYM0ylSdxHcnJB9quHUzc30K+p21/e2B ub3THEW4mTykEnkMvfI4GOtWNJ1O2nudNhuspbLKryqybLmVVH8I65OKhqzsJybViomoxalqGorZ wyQXIkdLeKVC/kDJAbB6jkfMOtXb7S2S7t55pWu2WCMSw+WIlikXIYIOvPHJpFQP/9L+Ti1ihA1G 2eAWckUCbpJ498oZuQoPZenPvVLwxM95eNHfyLbbpTAZH+6yqSNw9vSvCnuBYvI/7J1S7trjVLW8 h1ED7DGwi8wBTnamOc8D39+aT7XdSFphZyLaCb7OtqwUP0+WQnHQkZH61ADNSuLm8tWgMflSGDyV ONyxg9efYZxRp+gadoml3d35jTzmDz3gePKMACeMd8Y7fjTTtsFuhW0V21CznuJVjOmWkvn3UMkh UXCMdqxxnOck4yewFOu9R03wzDEsRtNOtNXmRIUMn2hxvbKxhhk/XPTFawblp1MnGyP/0/5NdTnS a5VbFIDbrBtkvOQ5IAwVU9RyQeR0rL0rzFtmQ3D3soLBi6gRIS2RjHpyK8XnQo7I2rewOq2txCbq VDbOziHaY4147Z64/GsywjW5WaygmQz6bGFnlnbYbp+nyt0OB1A9DWd/eGdTbAOYfMWGOZYG8xmJ wrD+LPfOKwb+SGC5EcsciHyhPuALRZJIIz+GcU5tPYwe7J47e7vYHk0m6S1ZMK05OAueNv8AOrGn 2eoOl19pk8s2a751aRAkqjALoenOR0qCozsrH//U/k9n1O1S2ltpJ0iRo9kAeUmVRuz+7/Edv6Ul o0kkSSpK8sb9JADlsf1rwb+7Ywb1H2c8MUt3qck8hjtk8l4mBO0g9TU91NBfxRzwLHJF5m6RThtw x39McU5PRIRDZ6paaTdLIumyXc0jrHa4TNvFz8+/jgcD8qt6je21yW/0D7PLvM+6M7UBb0XHA6/n UN2NYyVrMzd91NCi5haSN8MrMdu3Pb9PyqfULbUpJrVfLaISRidjMSI3GPlZfXPr7VnPoZJ2Z//V /lOaOaK3hElohIbdI8abpBx1zWPfJqE07+QFNsigREIBMeOc/wCeK+abfKhuLs0ag08adYw38063 E32Hzp0RcyQ7m5T1z8orov7Z0++ghsrbTrOyt0t1ikt4IRLM7YA8xpCCwJ570nJsxprU565tVn86 y09Lh3tsCRI490YJ6An3+veqlrp17ZqJ5ljEu7aJHmD+V6qF7/8A16lvZCV+d9jW8+QqA0T7GOBh MDJ9Kfa2sayTSTyB95CiMKS6D1Hriqv7ti1dyX9dD//W/la026s0v7iHUFWexntj5DRg+fE/IG5f w6elWdUvDbw21pAHkt3G1PMQBbcdd2TznJ6V81T3NJ+7h3c5/XZ1eyjh86WUwwMwj2/J65x9f51h +FjfQT39vqLmSynWP7LDtw0ZIO/KnkDpW6jaJ5E9Zo6PUWsLOX7NZuGvZY/mRsEmPuo9qlj0q2F1 a31zZwbJNP8AssUYXcIgOnsMdRiiSs7Flq3higRmnkItQ+wZ5IHrir11cTz20cemLEllcyrby35I R4uDwfb1rKew0nex/9f+UHVEjhKWOyORrd/s6yxL8khBwNp9Per1mk6wwl43DJnc7LhVPYA96+XO Zq+4s4tNVnS2uLVJzColVJEyAehwPy/Ote/u5LfzJBbIhZQDHBGFIAGBtUdOgoLiuZ2K893FPo0B gh8mdGYS78hpAT8oYeorMtINPit3nN/dJqEh8pbJYg1rIDj5mbOR3HSguMLbkttcR2dpOs7HzJGA ggZgIrbHGFwMncf51rR3CDTd/wBjmS7WUIZgP3MKt3J7NQUlZWP/0P5U7uGTyma3klut8oEhlXHX BJ+gqeCIzSrIXcwxJgwjiJsEck9a+divdsJfEwSxur65vEtZRawlyxtFbzVlUDIwfY/yqS1u77Tr qKG3lcTmBsyhPufw8ZzRGPKMyZLS5toje3d3dvCJjulnuNyKWOSFU/06cVFbx6jBqUxuhaXuk3Y3 WcobF1bHA2FkHGeO549PR2VzOUZbm/BtKXMV5HHJcFSkLRlsoB0b6+3NPtLK4uWgfTy8kyfKCkfm yvt9R+eawIs7XP/R/lqNrLdX4lvFZZbMgyJNELe1duxwABkYOSOabLqiB5WhtY7aMfLmMn943Q9f XivlzHkdrmbeo6TySLFmJol3bu+7g5H5VZg0hX2hGjURgO0YOAPpQYyjroaE5uFMmYGfbF5kM7Hd HI2SDnv2/WrOmyXDxia4jhfKlGGcmLsMe2B3oLiuVWMy5sbWW4ljuLh4TCGuPLSPdG+chQX6D2rP gnigd7d2WXywCgJw31oKSb2P/9L+WVIb3zIhp9zGgu5UFwJ3CRsgIOCTwP6V1GvT29pdWujJdK0c wXyWSRZkRmRfNIYehH6V8zHWSMFocfb6edKnaYM90kV2Wjkk+cISflyPT61qm6PmbrgxxLKxYeUu E5OelaSbS0NYKyLlq9qI/PkuG8x2ZHhZNroBjBP1/pUWnarEt7ew2cls8tmoMttKitGFccDBGDnP bNUZyVmX7NdTO63iskeGZN0YztkbrnAx0rKlt3EazXrRwvBMFjtg4JLc8jvxwPxqJ7pGc02tD//T /l9gtQ8Qv7qXyUimAFqp2Sy5yMcjpVeIol1cGGWSNZ0ZFtmO+NE9B/8AXr5hu5z+pIbgjZFFLhm+ VQoyePas1dQuZ0NrHaNuF+Lea4uYmRyvA3oO4569PekBo6fZvDe3ctyIxbiERQyMN80jE8g+mO34 1r3N1FZW0rC2W43qERHydvI5oOheZmQw+ddQXLmO3t5XBS3UfIPb9K6OWDTZ7ozSQwSO3CoIwSCK AP/U/mT1S5SbzrJGaKT7PnbCCsiLyuVPY9aZb2dteQWlrJcNAy4WOWWQKc4x8xP9a+YW5ovgYl45 s45DE4LxYTzFIbIU9c1z1vbwXdwLu/llgVyYlMa78E8KSPc4rOT6Dm7xVjcgjQGa2W+htbhID5Qm Qu7kYx0HU4pNSWS7sxLPAbq6i/1R8wxlzjGMjmsgp7WLFxbS/ZB9oZLK7WMMUILMWGMqfr0qXTYb 9LB57aURzXJNo0NpckXIDja3AwcHPPrQWf/V/mGv7fUbO2e3aRvMRCFhlPQ9wT71dtUjFhbSFES5 cZeMYbZx3Pevjzd7EVpvW6d7qRUQZREHQ54Gc1ZnZ0cWwDyrO+1FHGPXAoMC27W8FrBbzKCYzhfm 3SMR3x3P0rG17TknsrSWTUodhnOy1ikHnY7KR+uOvFKytYCb7ZdywRxyPG0EeEijAVZAVGMnHP8A +qq8d2L6ednkjtX02IfKcILxsgBRnqfmzx6fWiyA/9b+aBJjaRRzzEFZNufm3KpbHFMlvLW7d3m/ dbsRQl1CKxHHHrXyFtBc2yCCaG2kcogMzL5QkmiJRd3ccVmWZ1G7e8W5WIxJL5QktcyNjJG7JH/1 qOhTbe5t2elxyRySSRxXUEbKgM6hmkKncCw7EEDp3qjqWn2WoXsenOz2qzLughjzHbQknDMh7njJ yTxQvMcXZls2tvpd1ZwPOPJt4Ws7YIN8j8ltzfqPxp7p5zsUXgfe29R7VqpRubH/1/5nXXSJJbey 1KG+Ek+fswijk25wAu/AwByDknpV28sktl+xRLHE8Sfu2zv25GQT69q+POixzmxnvI7q7ZY5oztk EXEU+OAx44OPSrsslq0r3qW811HZuNxiiLtHuIXp+NbrYC7c2EbxuyMI1ddz7eAKrQ2phmt7pihw pUK0+2THqI89+eaG0gIr+7eSMqkcg2zBg6E7T7GgLceSryLiKX5cA53EY4xWL3Jad7o//9D+YrV4 y0lvqhsxc3FsojEcChFhjACjavTOBj39a6ad4DbW93Zq8kbwo0cdwNkkbMo3A+mCW/KvjwMt7S6t 83F6ii1kYGCaL59xxkhscA+1FzeWAtoG3uWecxBVHUAc5Pv0/OgB9nFeLoctrMipp8moG8Syt9Qn Nrc7OI3mtt2wsAAMleigDisywe9E06zRifbK06rKfLyuchR68enNXTik20JJRbcVa+/5fojX03Up taR3isbeztLe+kW4jAMUp28E9z+GeM1V1DzP9TpUcQuJpQB03yE8cA8E1qkloirs/9H+apop7mwK XW1ruEeSQOI/lGMY/Cq8Ng0c8BecACAkW6jau7+8T/Svly4yezItUvdQv4oLKAvEY5CpfgAL7H86 hvZbuSa0Vp3nNmq26hsbYowcsAR+J/Gg1NRSLuCOA4ESy+YNoMb7hjknrjirNxCUV0WRXfZwN23c ccAntQNO2hhSXLWrw2Ukb2ksiCeVoj5sTAEcbsYzyRg81buPs11btLBKBPu8ry3UjcPUetAj/9L+ ZKxjv4JZIZyJomJeCSOPYsPQEHk+ldKuqXCxxW0kjPCuQFP8OeuBXy53pKOiOUusHVrVluNlmkha 9LQ7pgw5TYDxjPJzW+Lu8aTzZpDJGg/dszZ/Ciw9jJnv5P7SRHtXdXXcs0alwrZ/i9Pr71NfF2Rp EUiXbhHI5H0pcq7Gbn2ILe5CQLbRvJNJgmdnhCSZPXkdRx+protOsraWwImfcUyAR/rPX9KylHlY 4tvc/9P+Yy8aYW91BbtO87OI4JXbY1uoPO0Yx+NPmVJJo7OQRrK8QXcZQEYEDeSemea+Qs0dk30L bCx+ytHEpjITYXA6AccGtG1u2WO3dZdhgACsnBGKHFrcqDuhl2scsou12+Zn5nI+YeuDUsV5GseW kI/gIxnGeKRRs2mn2vlNeLdtLM5wkDgBIxj+AjqDjJz3NVb6WKxiDecsT3LrA0IJYOT0/WgSd9j/ 1P5qWknFxZrdwOIbmUxRyAhNoUZJOfy/EUtxq4t7a+QQNIIwYiUQOzcAgj9K+MmtLnqQaSsx8V1e 29vBI6/L5Kkp8oZeOvHGa0bLUWvoxPjYySFc5ySQayIbvuVruKe01O3lvFaUo25oh1ZZADz6DpzU t3f7o7qOLDR25U3MQYExbvuZ/OgcHZle3+zzW03l24llIBzu2yDGeM1n5FwjWaI8l4ZNqWm0bZAR 0Zu3bsazm+hc30P/1f5yYoWtP9Ekg8qRFHmKfmAOOme9ZVxNlXh+ZGRi25BlMD1Nfn56AWUQuxCE uAvnReau9hFke2aiFxemdbWOLdbhigmBJH1JqZOyAuXzRyQpZysJArBmGMqpBBH6gflWpYXn2ZXw gwYwhZhk8Y5FZqTSsBTkzqYuLeOR4Q6lN6YDL7jt+lZ1lZyabus7u4d2jcmOUEb35/i4x+VXB6WA /9b+cMtJHd3FxdESJcIBFIsW6TI/hPtwKnijlaC4jc+Wsi4O44Mo9AK/Pk7to9AktdXV0/sshhHC ckIm2NmPG4n1HSqcZudIFwp2zRF/9HheQlHyANxx0PXp2FCd7gbGml/n8oeS5G8/3QT2z9amitUL MlxIrS7ixdW5UN6fpTKi7PU2ltdNksWQ3CWrw4WIEEh896wxZRWEkt8LnzJ2bLNCmElGOhoNHJJX P//X/n0e7EKQTJEyzPGGlkU/KpBOPoefzrNiv/Lv/Mvt94ZyTFGW2nAHIDfU55r8/PTnualhPM8k ttF5ko+/tfkJnsKdcrHa/vJozGw5kHpQXGSZm3lxDfLDGgxtO4EEhn9q0La0VghnkxyHUI/zAA4w R+HegryNWSe0+0/ZgJPIKhnQqUD+x7fhW404vVjIZUESCFRtCnaOnNTyq1g22P/Q/BO6gEOqQwTK HFriVuepI6H8P50y+lKCSeJVHmZClRnyxntX524antwetiOBbqKaKUyBrcxiQySErtPoKbqONTMb oqQeT+7aZBh5cc5P+elChrZhJvmHo4lKK8p3LiPzMZPHH9KvNp7/AGtSMbYwG3tw2OmSKh7mbdlc lv7URGK4gdZLvO0KThNnGcntnn8qpTQTx3kcsfl+SEDcN+8Q9+KatZ3Gf//R/B2TUGjQpl/m4O49 agZLONYroRI0ivkMygkE8Z//AF1+dNJRue1zS2Em1C9S6iit5QqRsHc7Q8bZHT0roptQiktiwPmb vvsg+Zj3wKgFJo5v+xr2S1W8eCd9PEwOJwyxvk+p78V0cV3YvfRvPCQghEKQ2vzSIAAAcHr05NOz tc0jJvczL+6hn1V7OFZPLjgWYSScHOcY9PfitpLyGzt42l+ZGwjg85qWk9GQ5vY//9L8VXubGwii j0zP2ZyH2N94EjnP51HeaqRa3Ex2oIkGRkbpM+gr815Fax7cX7xhw3/mTRJas+wx5m3R7fLPua1l mcRSK6I+OUx/Wm0rWNXojNVi1ux2sNr/ADCMZLYPpXTaWBa3kZlTfHLFlTn2yAfTpWBg22RX0ctx dNNeJArRzF7NEG/yRjHB9SOv1qpFqyWV35sAE9zFIJGhf+Ig8ZPuRUuKbuI//9P8ZNdex1Gzg1CS E2GohmNxFAQc8dCD65HNcvpdw947rcyKqphCykEnsoI+gr8rUNdT2Doo7WOFZJlkjiigAZ3eQRsR nHy56n6U17ua9ZYoIVdQfldjy/b9avlXYy53sZ89xcWKILuICUbkSNRhFBJyM/jRDGk0EU0V0x8o 5NsBgRD2+vNLkiVDY0Hdbi3uBAiTTiErFHI+yNiOxPPvRY3bJAv7kQHyxviX5ghA5AP1qrdDWDSe p//U/GWK2s7O5fUbyRDc3VsqRowDNHFyRgdsknr7VVtUVIri4e5EizzMBG3+sVeCDjFfl57V7yuR QTNFaytGu6HzcsxPzITnitkWcMlus0sTF1XcCODESOp/z3pWtsap3IxcfYo0KRq0ZOW2AbjWTcXc 1/dPOzCKCOILIMdFUYFYD2LliiX0Mot8GGE4y4CuxHfH+FW7CKOaWRbiVS8I2R+3t/n1px3QH//V /HFbNbe7mldlEZT5Gz1xnjFZmbVDsgZIJJHJIHAGT1/Ek1+WOF3dn0A63W+tr42r4uPtLbY5chIS M9cn6960rm+eylj094UWJ22SThwRESccgdR7j9afJEzlJp2MfUbFbSdbhQHl83y0aI5DgnH5e9Wo 7i6iuCv7tkZMSZGSw68elDgmOLkzQku9sY8i3BZl4ZOkh9zUcd3FELolf39sgYpJ8mSTjA9SPQel S4diz//W/Gu3jutTkZ/tkdtbryYwQkpP48/lXUXL6hKsQDy3TpEIFdjv2hRgAV+WRjZ6n0cHZ2OM 1WfxLeTWcDWNraWtgdt0XkY3NzjOGIxj06VqyybrZbeCOGK4lCrn+FTx1btmsKnxIvm1sWrWW5hJ 00PuuIWLxrF8yN3yPyrJk1Ka6uDHLHl0H3MdAD3rbediItIkuLzz/I3nAjPl7W4AH+RUMl9EvmIT uRAMj+DnpUyTTJe5/9f8co/PLLOJFjEMYMcPCqccjP19as2t1cXXmySxFYyxDIcIuB3Ar8gnHY+m i1ZGetsGuZJ7CcQS28ySS2zrzKpPIAPr61pz3Imu5bmdI7ZIwMIgz6ACs27N+hy10nU0NMultbTR oFDXOGlfaNxA6DPWse00yJLgTnq4yIlbIOfbNL7CHLaxZura182LcshkhmEkdup/dyEdN/sPSp5b 2a51Bp2QWh3CSQqd28r90nPpz1z1NbU4aEU4vnP/0Px28QtdPPDcHzb93UNcxnl/QkHv602N0MIR g4DYIXGSn4V+QNWdj3rPmuaH2tY7do4o1kk4UFhggZGa1UuopLW3W3ttl1u8qSIn5ZDnhl9yM8e1 RyrqUSTWtmrxSvG32iMbkVPuBv8AaHfvUmq3txNBbyIpXYgjYBQFQLQoq1gILdZLtk3TZL8bCPu4 61sXEos5UFq0SadCu2VXGyeV+cMVGR+XrWTVhXs7H//R/LCa5ed4E1CKF2SQy20sZ3nawG0Pzjgc Y96i3RLMc7toOHCjIUV+JezZ9AZdz9khuEkhWNP328JHz5fPYH8fzrrYLFXuLu4jmS2MlskzQGXE MpAHCD+8d2SPatdtAFOm21wJLi9a1ktoQJHhmcFsgjGB1/EdKdf3iwW5NrZQqk+FZACUJYevXA61 nNdQOcs7DTNOkhmimvp9R+42UEcFrH18tCDlgeM5HpW3b69EzTRuQAnA2n8KzLp7n//S/MzTrmGF pLsxq8GSJFmXKjI6mo7mxNnKr3UiyJexi4s5YBhSrDIGO2Oh/wA5/Drn00d3oXdOa4hS6DXTXqLA fs1tO48qHJJOweuWJ4+tadtpslyHla5S6juEEKaaYfntyu4u+73+XA7bTWcm3coo217BDPdQzoFt rVN+9l+R+vC+uMCtfTLq1aCdmu3gKfNbRbC0cmTyCe3FQaw2GI2mTTrLdygqQYpEVSx2nBPHTmtS z1HwzbIvki+tbeP5FFwi+YxBwMKOg46n1qHB9Cz/0/gC4jR75DcRwLcyRGa1WKTewg4wx9D7fzpj zi2t/tmy4lcTGKMTwHLKvGT6Djj8K/n6Ub6M+3jsi1ZatLbyR39tApTYyliNytkEEfqafa6oYw8i xIGbJAYjOR/eFZOLW5pB2dhLVzfOZjtAB3yk/LCvWiG5kum+V3YISsYcfcAJ5A9O4+tZShfYUm76 nWJFNNYqF8ob3GWYgYx6n8TRHI2ntZy25tZyZj5ltIPNX5ezL6E/oKyJP//U+HnhnuZ5RNaW0Xzs yPCwQndyQB2xjoKsWXhlLaOG+N6yywz4jKkfaI+c8ew4r+bXGLPtZ7Gnd2gnaZt0kluRyXHy475H TPTNUbSG1t/3RPlxgbYo1GMADoB/npWLWpkC3GikTxXlteKhmKMbiMSxzFTwEU8YOM59ulUZL6+t pJTp5VvNzGilgAiHrupcq7GlPqdLI3kW1lcyeTKZxtkWKQb1xwSR2NQyP5+wpJEtvh38+eQRQxiM EsCT346dc8UzS3Q//9X5IgndpYZ3u5BBcMEuJ4/3sjLjB4zyMY/Kobi5tmRnikzscpD8m0uAT2z1 46V/NDTWjPuoLUS4u1h8O3mpX8koSyUzS5X94yAEngdxik06SO90OG+sUNtauoOGlLPOCNwYg8jq OKuMU1dnUo3jYWNZ4oGnhTzN+TJEwyRjvUj61crp+nvcSPDi7dBbKpe2OQMfNjg5P4fzlxSdkGqi WjPdOpljjZsLuIztBA681PLeWV3qEbW1o9hLDbrvnLGS3YAYJDY4OQSQfWqqP3NAm9kf/9b5Iuki tppXMr3Q2/aXVOZEHp+lVbq6S4t7a/W7ZLm6by7qNwZZ7cIQqggnuDX8uUbPRn6G5XiXh/Z09yLK xjnjs7WQT2/nKEPmMo3kAepz+GKqfZtVg1qCaEW255uFIOZB/Cn4960as7Gq8jYbVLn7atl/Z4H2 lWLPEGIidecY7fj+VI/2sSpOkfyq+1CBuViPWtIpcupaeiRLZ2zXMxa6lkxCxaZYwA5znjB/KmSQ 3aBiEeN5X+QF9rRx9MkY4PU/lUNLVo0l8Luf/9f5mj1OcJcw3lsZlVUQXMkWFIAGNp9eME1c0qbS b61NqsMq3wnPlLKu2OVPqehzjA96/l8/SlJpWRSk/s6e5ke7t/sd1ta1E1sGdsKflLjv0FU1vbmR UiWJbQpII45ZRuaRVPJK+4yPWixJcml+xSTTWQV5kOIppFJQ++P6VmW+o3N3raanelp/KKiaNMiJ tuOAv04oA6LVb6C5jaZI2jAB2gL+8QfSuc857K5tZleGeEx+Z5zYZhnqrL2watQb3KUnFWR//9D5 Jknkub1ZbWVbjeCVCH5Xbn/9VWWvpJlijkt/KvXiCyQqSdpHHJr+Y+TU/TlJMk8me3gZS7BVUtvb 7sY74zWWlzb20bPZkRyE5E0ZzISM5NUoqIKSexaa0P2oajfXl1JMlsPJEi8lm2ksTnPQDBqzbXdr dTyfayJJreAzMQ+wtngHnvn+RrRRbKJxfNp8lrKWeJp3xDtUlUGMgsegzg024CwSyXJEF1LMcSXM cnn7SecZ9ar2ZlKTvof/0fjS/kS7+1lZ7m0niA8l3tDmUhhuCgj03c89PpV+xIkNvPpryrqKRNHb XFzH5LgkDJKZwMFf0r+bIwtufpDbsRzajLqF9LawXEDEDyr+YEJHlQGYqTxnIycVVvb+wtLKfy0a R4V3RvHy7EdQB3J7VTSYGPbf2ZMZCTJHvt/tbTBSPNcZPl9chsjH+eLDKbi3+27pW8vAMLLnygem fT0qPZgVob2W/u7aLULe9jgtH2xvA4KlOTu64wc9D0qtrUrSPKYLdwjvsgjJLlvcn371pa2gH//S +D57qeCFLWz3W15bW4V5I12eWXzgbscmpLVXhMcjSGcxBXkdjkn3Nfzmodz9Kgrslju7XTYMRSNd 3k+4RpKMiHcckk+3b8K52PUZIr4Q3kQ2zblYRguFXvuOOh9DVpWViqnQ2vsMEVrNa6VJHDaxK10r M2xN2MngnJOTgD8sVjpNdzQq9zBHCMkb4JTIJgP4ugx64+lO3QytrcYNWmjeaUqIoIriK0M/8CST nbGp9M9MnitW4XVPtV/YyTWSrp9qLq8nWVZ85YKoRlyDksOhrdKysM//0/gO0mvLHPk3BXzoireW 2GcEFSDj8ePerPnaleQNGgtFkgthBAXgVY1jDZwMD73J561/P5+hczTuZWqJbp9kV5zKShA3DKRN ySB6f/rrFu/MuVikt1ULCdspH7vO0dR+VXJe4kXzq3mZA1mB7s20sM6KU8vzo4md93PAFXDtiR3s Gku44kxJHcAWdzKRyVRS3zDjqv5V0VmlGK8kVSXvsjfUNJjbT1eG6W/uo2Iikg+RSBu27h0IHY96 b/aU8V7ayzQuNMeVkuGhZVuogo+Uoh65OKgpqzsf/9T8uxPai4u5L+3vo3f/AFZizudyPlLn+6Ry T2zT7eVba3iij3+SzlRIxz5XJPA9s1+Dn6QVE1NrJdTD2X2tb9PszsxIkkAIbfx3yO/tVvToY9RC NBPFBBJiNVlzG6N0K7fbFbpWVjKe5ga4sqStp0zy20tvIXhnWHCzDH3kJHPb8qk0gSiwjFzfdEZ2 luyI3PJIBwAM80yNhiXRuIn+1TK9na5ZZJHGyMZ5wamWeyjtLtTMM2ifahJc8FVPGIzjkc0Af//V /I61XbvW0soJJriIzM4HzXAPO0//AKu9W5ZJbpY3EUSPGAjRJlfMI6ZPp2r8SUG9z9BSb2Ode5un vJXlkkV8bPIjj3woB/t+2KsJfX9u4uUZkgJ+zmXPt0A6/jT9mFjRjnmfkgTh1yGXkjHqKy5/tMty GE88aTIsZiV8RkKc4IrqppWRlPoY2rxW0t/LLHO9tMCoiMBKiMr7dD/9eqlxdyWqN5UEc8uCwhZB mdsccepr1aK0OOr1P//W/AHxSupm3muLqxhtorl8Cz89d3+1wPmwBk9MZr4K+IU2mS6hdOkbRiKS RsRLshmf/lmXB5YkAe3XrXw1JX0Z71d6HhmuaVdHTJZfNghS4jwn2a+i+0qGJwDGG3jp3FcHFbPZ mIzNKG4Dq/zSFf8A9VdtNHnT2sekQ2MB0V7u0SR4YnHnOwAugW+7lOuO3Fem+CLO5h0q+c6eftEq gRNc/vpY0XDFlOPkDHHH16V0JPkscct2WJJb3UNWiWe3jtXstMlgXJMUDDKMP3jcbjtPFel+CdH1 S8vdHD3ElpDe6h5dq7qI7dlQZkO7HUANzWVRNU7jqLmij//X/lS1l7uwuL20sYLO6v7dPs95DcM0 cSk9VjbHJHasCaa0smxdW053IqyvGuBChxkA9uTXymKfLY3itLGf4o0k6rYJbjX73R4b+LMV9OBD EoVflUAg5zgAkHuK+b9WtHWKIW9xJcFh5NzMrZikVR1I6ZJrfCN8qNYIytCv7CNbi2lknt7dUwkX k5V2BwAuTxnH/wBY1c06e3ttQma0GJbptzRfxkD/AOtXfT3EvdTR6/oUU95bm8aeNRC2FjaQC4JH T5M5x79KYt7Z3UM1vPNMIpJhcNDKpczPGTjAPpzxxW8Vd2BybVj/0P48dJW0u7a+m1C6MD3NwYdM ijK72UcNuHbjOKz7+3TRl26DZ3OpTuymW3diWOeCd/JxjNc5pKXQrac2rS3guLDUbiy02ORmvITG I3Zn+Uqh69ckEdcelJ4b8N26+INZkub8vFb273Vvf6jNHCmVH3AmcNyc7RyeKpRdrmTaW5p6Jpqm WY6jdRGMRu8jlcGT5uBGvr0/Kl1DRrOOxe7i8SmS4vrsW0Nix3TWyRj+Afwk89c1JlJ3MXXtLuYd Oh1aO2a8SC4EUkJn8nzE43sMdSPT6c1Y0OO+1W8nuxDPZrAVu7cbsPDEANoY49j+FBJ//9H+PLxJ Ha6k7xrqEzwrAjmx8wSR+dxufjkH/PvRbQ6ZLBbTR+cLy2/0a4W8TCIy4IK569etc5nCPVlyx+xL 5t1eX6yQ28heVSR+6UddoHXFMstQ0++me31K1mns5HElvcS2jAwKDuV1BxzwMZ9KTdkarcwba1uj M8txqK3AS6kK6fLCoUQ5/dgMME9sj2rVttKhSKQWyLbeYWeScqWQOegz2+ntUwempuZ9zpzJM8Wm 30xVFVmmIMcby4z8ynspJx+daWl3ENrZTLdRmW7t5DJJcP8AvcnkNlh71YH/0v4+YI0vbSW5TFsk UZuJ7qb91bxp/eLH+XWo7O4LIbKWczuXIicNvUZ7Vxt2kzo2Onjs1iE6XBHm+QAkbL87E8fh3Ncl rUv2SW2gtwERovLEfA+YdWzWZjJ3Zd0+O30q3QGP7VdSAiS4Yea6ljkjPp7D0qR7Brm9tzLeLLqM 4/cWxdVS3ix8gHPfJ4PSgynsRRWiW1/HeXEImktQyxkrnZuGGKnryKw9Wurm4cT6dAjW3mHznVjv iKcbce/PX0pN2QQ2sf/T/kJ0tJdT0+PUr1k/tCVzEEVg7IiAKMkewAx7VaGkMJRJLar8w/dBWLSt gclh2Ga8qUuiAWKOy8m8uPsc0E0iAGOMGI7kxg4PqM9PWr8L6ZdaIs1zbSw6hIMQKZBiDBwMkeuO n8+lZSfLsBJe6lo0GmalZ6wFimv9OMcElvYh5HMe3HzAcN155Jz3rnNH0WaW5sLmJ52iSHKRONrS jarBpFIyCMHjjqc1HOzaK91F95Zw0t1BBHMyuIgqSYZhkZOQD06/hVW8sb2+txOfs6vBN88MkrKk ik9mA6rVKTYTWh//1P5HH0y0juvPsrWCNpUUzfZ38yN8KOrZJ/Ampr3T7W6sp2uVjMkKCS0L5CQy BgQygdwM4rxk7q5E1oc8txcJHHaTSI0nzeZcFiGYY4GPX39q2NLZLG7+3pLHdGKxMME6HcxJBUkk dxz0rWn1MrHQWl5ftp89pLGqWMis7YLebKznuO4/GuYguprK48oW0W5hxcyxeYbfBP3CemelQ1bR gbNrZzOk16+2G9GEVlIyEyemPrn8av2qOJNs8skrzMSbqeLbCcHoD6jIz3pGkH0P/9X+TnU7Jmuh cl3lEyKk9wsnyRhR169wB+VVDZxXWoBWj8+OAmCylSY/vDkgEjsO/wCNeA23uBiCEWupCzEEdzNZ yeci3EH2gRlTnhvUfXvXVxStaTCKaIP9oi8xWbhjkfLge3PFIDv49W8Jx+AdQ0218NrN4vf5or67 mRotxlyz7h8wIQYC+w5rzuwmD2LWk7M948xEjuojVE7KMfl+FF7uyWw2rEQ0+3gWS0tjEw3FZo1Y Ern2HrWzpcOmwpFa3Vlps6W8vnbLi3W5lDYwoXIJ/KgiSuf/1v5QfFvhvU7i3sH8K3EdhcQy+ZPG AMyxg5KkEcLtzyPSuShi1TTtaWKIRS2zQm4uoFUmMKp+dwfX9K8DS1iUmtz1BNSs4Y2v2eB7SOzb fAqYlJx1wO4riMWvl/abcFA84kZQmxiGPcfj0qHJLQo0Fkd+XYKAQJccMqnvU93JDJbGzGy4EJID ouSxPQ7utUc7krmCtnLa3LG3aSKN0CzW4fEBIOQ+PXtx61sTxu9s1u9wMXUZXJ/hyMYP+fSonJrR CTT2P//X/kk1W1i0mKVJ4Ptz6XGkrGFfNIUgc/Tnn6V3kl3mxtrfT7O3FvcQJJHdQZfJ25beDwpy fx/n88ndXOSUktEZyACyvbeaGOONULSzsmxZScnBPfPSsHS1tluJbe3jeNnUOW+9GwPp+XNDdlcz TsSX32+3vYhpcf2xHwlxalvLV+eShx26/wCFa2oyyB76O9RrKGO08yNkgL3UWATtHHzDp+tTJ3jo bRd1c5IQ3dnbxzXGoRDzJQtvGAPtUitwGePqPxroLY3VvBJ58ss7AARqzhkjGeMfnWFSTaM5NKaP /9D+UifVEAR2muWvGQQeRGDIbleFAPpj1q7DNbKqySh4wi8rL8j5xyPzr5m+iRpJb/IzZL6zgM09 5aT3cJRsxW7He/B2ngE8Hnp2q1o1tb2sST/MEv1DRtIdsmBk4x1//VSejaMILQ08zxs32JslnzcR 7tokA6Fvp/Wud1qR4JRAULtPsaML86xOTkmhqwtrmhZ38ElvnVL6aGCBts05x5cW1eFBPHpSxapo v2fzRNczLcRb7S7ij37OejY6Djvipkny3Naa2Z//0f5PbWWK7vEe3jkMzuEAYctzge3Na3iGeYGO S7JJaTyFCISm5cZGAO3FfNU9zWr/AAH6lX7FqAEExmjcvAYZUfbHGI25Bye44796saTGLiVWh09L lokaEygnzfXIA9MfpXXbSx5c17xBeaVKHR7sBpI1LLPt8tgmScE+w4p1pqMirNZSsBGMeThd2cjs 3b6VE1qWoWfkQt58Fs88jr9jjP7wyNuYA9dvc4qWPbJb2skc2bcEzIBxG49x6jggfSs2rqxdtbn/ 0v5RHjMtw2VlKhNyyw4ZUz3I/GtBricMlm01ydsPmjy0EsZbAxkjgE9x+lfMNNHOQ+dc6VqtoZ7O 78vUx+8v3h4g4yuF67Sc/N04rWvHWZ57gXCyTOm5UXnds4JwOhosaU11MrfBcJbR3lwbHz8rF8hO G7buOM9qbf6BeaTJuZ47reoZWtphOuMZzgcj6daRotBI9I+0y6dc3Vt5sAcXIhlXkkHkn0IK/mK2 5ryAtNbrPI+nTPukspeI5gOhb3FAH//T/lVhK27CJI7lrXBjRo8skPoMeg4+lQyJMkKNM7CNJCyx Rtt8wc4B/wADXzSlZWJT1ZuLF/YVoNUae4tXnGyzhMXEoI5Ksf6e9UrXUEgkmuLueRbl/wDj2EMQ Y7WGCOvv+ppKTRRQk161bTZtPfzruO3uMTsbXzp0LHLFABzjI6dvxqvCpuLmK3SZorOGRZGljQGS QdQhXnA9cfnSAuarcy2F1ClvGSZz80rIfKRehJPTPSte2vrLSJIrhba+E17KCk1mG2RuRgyOR0HA /KkKyWh//9T+XtkluLeW4uNQX7NG3msxkXfOc8j171jhJGnSW2tWksxcGOaRVJCttym0d+evPFfL hboN1ax1W6MkqXbwImz7W0iA7Y1Zcqpx3HHt+tXGt0icOl7I4eMKNyiNACMY/wAmg57Fm0aSKxeJ kSTb+5Dh9+30PvwKyLqNvJmXzZICMFWQ43HOcf0ppN7AGqtZz6TaG1dl1SJcalFERJBMM/IAevHX 8KcujQSvayYZWA3S7fvNgdD+VPkkgP/V/lr+zxXCyRr5TWqIWnaSTaE28+vtV1YLNriCaeO3kubV fNhIO8gEcZAPQ4/SvnYx5TnIikky3FtAiQy38m4noJCBxjPQgCqNjaXUVlnU1R2ilaDLECZiCcEL 16d+lVa5pGVtGXY5reSJpBG6qX8sNLGyySEccLjOPeq/2YIhvbbS1MolzdXu0gBTjap446Hr+lBM pXZHJdX7tazWU8kkIdlnVCAWyMYVvb+tdXdWmnfZ7VIIHacBZLqe5fcwcDqg+v8An1ndK5Ox/9b+ Xdpp5jKJZWumZgDLKeY8YA/Qd6tW2nW1pFMYmaQsucv1XPXH+e1fLman7xnRXFrYTC4ltpLxV3Er G210LAgEHtgn+lbsZku4vtsUEyhBuhkcAKxGeM0Ccle6RgyT3uoPJYWn2dLqSQTGeWQIigcEkkgf n6CtOaOSBVVpEneIBJCrBgxHU8cflQarVXLDlYIXWRVDlQ8fcRnrnH9KhkgmaFbywviJFYFlZANp 9F/I9fWgD//X/mBgM9682pOqq8W20lCNlmOM5/HB/OojDb6jaXcc0yQyWExngkxvlV16YA7DJ4+t fMxXvI0irxaRoWsUl3p01xHF5i2LKl2ZlMSuCAd4HdTn+fpVeCZYITIdM328p2oJHLKD2ZeegPNT NJXJq3ULIxL5BDex3EaSrdyReWoCfu5eQec9xj8jWw9xefYITKiQzly6+VJvBCnH4GuZ7pFwstDU uWtp9KivZjdNeBD52359xY4B9eO/41l2MLj/AI9rhoFt1EhYviaQ5HC/n29KZZ//0P5mprm2hil8 +QX1zd2XmHeWL265xkg8gjHX374rOg+yWlhDcwl7iK4bajCQMiY9e9fHnRsRTqkqG4uikVvHhkLc bSDwSavadHGzSX+oO5lghf7OsILeaSDtY5P06UGD1I9Nmt7WCwnls/tlyJWS1Sdd81uMHJkHUA9K 0I9LiCNM8VtCFnNzudh8rtnJXdz3PSgRRt3sbTzri7Uyskm5NynY3qT36Y6VlTTabJt8mzea4uJG eMmJvKjGPvZ/xoM94pH/0f5ibZ0ksza3ymMDna/CJg5H5YBrNkZdea0jhc+RpUxPmSqUt+h5Ugcn 6V8eDjZpnRW9xHcKizyKPKBTkAEDuT60tv5NjdQmCUXH29CPmlCbF52nZ6k4P0xQW4NbEsRlhmnZ 3/eKfniDfuo/p/8AXqK+vHktxObSKeKzukInzm6ic527F9ODk/5IKMXczr64uRqFsFeNknC4n8zb 5RJ57dqtaRZXK3GstPqk8cdwwGlzQ7BLbEAAkhhjB5POcUGx/9L+ZrSJ9c+1an9tuPtUUyiFZrjE tyQhBGGx7dv/ANUkFzE08qF3cwKCzyrjzPXBxjt2r486CC9WPUWxaqLYrjaUGU4x2Pr/AFqsomsI 50aQlWAMoU7Ukx6j8K3irLUB66uILXz7mIG3lUo0cf76degxtHPNbT+H7P7Xb3zs3mi2+RRJjCyA EEj8B1rOSady4xTWpMILUwNbRNmaNt0nfcOw/nWTMQS9pFJ5U2AYzKpEeM849SBnj6VKTZLVnY// 0/5nlsZYwZBKHIXGJG4OOenT9KlsmvZLRnvraK1jySiQzCd3AJGcAcdOlfINNaM2cEyhf31xBcQR CAy2IYCdZNwDA+lUGtZJ542gg8wITIYlBPB6UiORk1lqF1Ld/ZWa30+K1Rn3RngYU7VI+uKmeV7d YBqTQNPs3F4CMc9DjqMj/wDVWsFpcmzNe3lT7ORGvyOvL7dpbI71kzWcpewNoI4pLe58/wA4D7uO gX3z/nirEf/U/m2sLfyrfYWJlZyzbyTuySepqjcXKxXrxTJIUMRWPyVy0cmCV3f7J45r5ccd0L9s iW0BO1XBO/PbHWqIkhDOsGSrvvI/iI9aDclLRm7gQK/2fAeSVTwjKRwR/npWmCjwzKsK7kcuku7i RR6j8Kzm3sBhiym1FnuLv/RxuKwLGwLADIBJqydPbSraM3E4lDn5TI6rM2cnhRzj3xVX5YoD/9X+ Y9L6/ju/9CkjaxIO9ZATMT29qtSSkh7pj/qx9w4GDz0FfLnemmtCO5Fld6XBdJK6332nLxtH+72D 1P50iymUAMSYNuDtbBJx2oFJ2RPb3TQySlo2TagMe1dzyCh3klQS3O6CGXPl4GXPoSO1BiMjhkiH mwyHJyNykbiPQ0abuh86IySKHYvsd8jJPOKzmtkVGXKf/9b+ZCW8jEjCPZJIGwYtwDn6ZpNSsbic WV0irbxwg+ehIMsmcBR7Y7/SvlXFPQ6pO7GGN7oRW8KqwdwpydjKeQatW9pKvmwMjmJflckHcSe1 EldGkHdCSw3c8UsMELebFKp3ltqQpnBJ9etML2tgf45VI/fMy8lu+APoMViVsai3Sx6et7pwmeOG PetuY2DE9wB161SnkbVLaV5JDaTood4id0qe49+9Ala2h//X/mgjsrO9lsbybVdRaCz5uI3RQZRj 7vvz34+lbFteaVeNJBFEqLE22SVlwO2C/uOK+Lm+h6ATWl7ZvNvXT7ixbDW88N55spUjk7R7579q yrcNb3MaweWsMyMZEwQ7Pxgj9c1mBozx3bslzGvmMsgicsxwqn/6wrN1e6miuPs0drF5YRfNuY3y ZWHQEew70DjuiSzuFhC4TaSvznoBToQGuxf24URycR3CvtmLKcH5ew6c5rB3uOXxH//Q/mt1C7uG kiiSWRp/mkABwJAOCGOP9oU1CqwvBITHI67m/HqAa/Pz0CPVWjmk0u7jiURRWB0ySHGIyrNuyR65 qzZ3zW6rGVV7WH5UijQKUX0/wFTJXVgHw3EF3eELDMsQjLlmjK4Pbr+dQTXW6WSKJyVB2E9MYqVD uAtrdfY5luZmRI4HUiMNlrjPBG3v3q9cWa3VxcXKXMri5l3IshCrGOyrirSUVZAf/9H+c0Sx23l2 7qXkCDgDcv51Bqt/a2iwXDqzoCE+WItLGWwoAUV+f2segTaZFFcRSSSw+WQSd/IaTOeCPbj86huI 7iS2ay8tFQ3Aljl27pxjIwG7Dnp7U0ruwG4WS1tI44v3szrhgi9MDv79awre6WZpJVR1kVyh3IVY 4OCOfpV+zAuRMl9JKikho1+5mtm2uYorVLeWFBbwsTLOF3zgccAd8VDVnYd1azP/0v53biVsv5Zc 2zHCl12lh2yKfA0e2JRG7Ox2oQhPPYH0r4KEU9z02k5JIuxjVbd1MQjhcSgSxPzgA4bBA69anuBL L5kt5yXJwpPX3/z6USjbVFqKiYU7ta/Zvslu008k3kmXyvMEAbjI64HHJPoK1bJ47EuzASzepGcn PXFQUNuA8uoRziWVVljCGEgCJTnIYcZz2rWiuY7eURzTgYTJGcAY5yaAP//T/AMahDLMtzA4nikT aZVYOrAcdenH9Kprq/kzyxGMyo/MYbufQV+eydkeytGWpJJrkRxygC3lIL2sTlgoz601bOO3mkmS 6uDG64jtmIaNSO+ayu73Bu7EhQMJHOcdMgkYNXVZ4fnM7OzLglzngdKRnPYnmeOaGQi7aGSKMOpC /wCtORlR+v5VUFwNwbY2ZIxHuP8ACc9apQbKjsj/1PwSCLMpW4JDLjyyB+FRR2iQ3dzFeSzMzxJL EdpEO3phT0z6981+dyjokj2DZgtrOMRSx4kiXllbqcdQaqNbi2QTwSbkknb9zvz5fAPT05qVBvcC 9Jq9xc2EFhMZGjjctFCW+WInuBVURSWN3DdxMyyxdJE5IB6qT6GtHH3bGkOxpzhb2L92FR8gu4A3 Y9M9fWoo7eZFWM4KkdH5Bx39qxKfKtz/1fw/0wI1xJbXUKYKO63G/ATauQPqaqXSvc4GxERDjk9e eK/Nz3LxU7lzyEtg0seAJowhjH3RjvULwTvBstpHinDhiwUMNvfNFuhaaexa0tIrNhDLKJ5ZX43E bUz/APXrVuJpbaZ4ZUBSP7rhhzkdjWDi1uYvcoWUhuZHuLguwBOzzF2mMdPw6UTtpbW07xMRLdfu VlQgTQlTyQO34+tIR//W/EHRvKeS6XU0kuUICQiY/LM+Rhm9f/r1LDpCRXl5cRRsFYhhAM+XEM8k Z/Cvy89gv6s1r9ie2lTzBJFgKR8pPv8A57VDpOnP9hjuY72aS652WLKES3Ck4y3Xmg5y1f2YuFlg nJDou4bwevcA1W0OSzspZrcwKzlRH5xP3Oen+fWg0jJJWZdtooBfPIdqwoflRfuE9zUrzadbw3B3 sZWlyoA3MB6AelBof//X/D9xDqFzG5jmEgk2AOhCqBjDV0s1jDawh/vOFG4D/Cvy89ZSuPtdKi1C BiZvs0KESSheHcA5wvvkVHdTRQC1gS4e4eW48ld+FJHbP8qC07bFz7NvuBbsViZflKswAyKqWcP2 WW+Vnjmimb5w+GIxwNo7f4mocEy1PuIjtaFvssY8koQUjXLsxPGB+f6VUQXBnBA2EnqeMetKMWnq S5Nn/9D8eZbJDEru7kbchiOGxUMdhFEWumsonE6LFHdmQr5ODk/L/nrX5ee5GWyZd8kXYW1gaOdx IEjkB2qTnA5P171y99sMbtcxlzbykHaeMqTj+VGwSkmrF62Z5oRPOFjhijDYZsH/AD7VHcNB5ZlG /awyuBtYCgpOzUS7balpslv9ktg++3hCRqmAImPQNn8entVl7TfEWk8oyOAx2yBzk9Cf/r1MpcpR /9H8bntsRljaJ9pRfmnjJBkQZ6jp/wDqrd0XUr6z0uV5ZGmhF0TFDIcR24wPuj3+avypNuWh9FHR mm2t6derJd3sbTXhjCRjdsR8EDnjnjOBx0qldQaVNFC9gs6S7y135rKyLnGAgA9j1qWryt5kKXvH KzXc1lfbwTLKTsTHVVAwKs3OnvPG9zZqwubllVizY8kAcngf5zWrVqjCTsiNtH2QRDUTFcSO+5gY wEjx0znvVaS0ila6gD7JAg+zIBlJuRnce2P6USXusy5mf//S/H/ybXPkTmIPDbRqBAd4kJAJ3HPa qt3tluIIrJNrnERMjYWPsSfrX5JNbI96L93Uj0+xupb64hYyeeP3cahc+afb2qyLd7G4C3EqTyqQ zFPmQnrj8KwlFqTT7GU5L2hqSTidJnlSNI5DhAvA+gFZsUkNpG12sxedXw1uyneFHRs9MdR1os1Z I2eiKf2mOe+XUZJJUjwFECfMD716DZWunXtu/lxPNNOgjCuvzA57CumKsrCor3j/0/ydlNla3b2M 29bmI7CrphF74B/zisWYfaLrFpGPIiyZpegwO9fkko31R9C1Z2HtEsdvNcqhZUwPl56kCmR6jbTR qs4WOaEg2si4jKEcZzjk4J9+ayt0EbOn3CNIpuLhHVjjcqEtHzjOMdvarVrqNtPBc2jQySzRTMFd UwJF6jI9R7VMY2A29E0lZX3SM0O/5l+XJUeuP6Vhy5kv3gkgkKbiUOOu3/8AVWctAP/U/LBIYXdX jXbx86OfmzU9tpjCSedJA0ZXLROwB+gz1r8XPoUm9jnprS1klM6WrW6GT983mFnfHT6Vu28NrcyQ tFcSyXAUokABG0Y6k0AotlKSS3sWa7uFFwnnCJ4DIFdhnnrWlK02ryXLWHlW1rFF5scNxcAPwOVU kck9hjNRPYfLoilaXDJAs0lvmVYCyQv8ruwByp9+34VHD5U/kTJaOI2cGdNvK88isjWMeU//1fzb uNMn1jRbzStOluLaFkZw6KqZbHVvwBFYuhPBNEtjflIZNNtWHnzybkh8sEhj6BgOnqa/D9D6lK7s XopLGOFLwHzIGXzEYHH44/oavxT2rSRanAbi1fyiHMpKRovXPX86LI15IjJ4YUntn+0wXCT/ADSx wZbyge/pnvWVqNzA6SwaaSMsY2Yrnbg88fh2/OsppLYo1dHjh1S5g01EZL6cCO2lkXZas/Qgv0Hr jPaty80i0sJYpLyCO6m8z7NEjZMIIPUMPcVBvZH/1vg6XSJNVvJ9at1s4o9M0uO3lgjbyoyA2ME5 5z1/A9azrrVXkvBbW8YuIzaqQS2bePnBGR368V+CTWlz7gNSlvrOxXZb4TGYYwdolOKqaRIbnw7P eS2051ebUJIGglAWO2SMYUKw9fxrnntYuDSepastQfTraCKWxW4ilmBl27jsP8SgjsfX2qeB7aTU GkjSa3ukTb5BRvs2xjkYY/KT1GOuKxexMndnRPIUtrlpZ44FgiMrNI4jjIUdAfesU3MkSgQnY858 2NwvQnuPyrAR/9f4eSezfaJFmklQBwN2xww4JH60WgvLh5LpY5oBbN8krnZvHQ/L+XWv5u5dLM+3 aurFF4YvtE4t5NRub64lRSxnYW8G4ZYhWJGBn+HHT8ukupbCz0+MzfvbqKQMl4zbdy/dKhfXpWbg +hCp9yO6gM8fnykqkMQlWM4UvkjGB361z0gZlDWwaIGRfNErb3PTcF9jzj0zj3qeV9i4RtojoZL+ 3e2jtvsCRQtKEW5Rme5jLcdM4xnviopdPu4njsXmFzZ+b5r2rgNGScc57Z4zVqD6jP/Q+PkuA8tx mNbeRSI7OKBSI8EYKj/Paq888C2sVuulBr9LmTzrqWQhoCeF2p26n8/wr+bJRb2Pu4O2hetdMvNV 0c6JNMbS/R3kuJjl5LyIjcIwpB6Y9OR9KkSMWWk6bps0igiR4YFkCrvRcElyOAOuKqKsrG12lZFn T7yLz1Jnjs0KsFbBYL8pGMe9YSW7zBkNyzQpMXjinbbGWY8n0Hb9KzlF8wXdrGxHBqYla1mhS0t1 wd7zjEo7Mo7jrU51PSbdYrcNvSKTZcmEF2l5x09qJ/wyZu8tD//R+Q7aW2uL9lkupLK3nRonlhXc 20jhSM8jp+dZdxbLpUP2qGOW9upJthjVApn6BefXBx07V/LNHS9u599L4TfjtWF7HeyH7PHHCA9u eTux/F34x2qK41Lzb63tpoWEsymazkj5QBTtJ9citjaMrKzN67s0E++11CcwxSEC7SERvcjaQcqe mc889KozXlvDbm1BPmuCQ6ttlUHgnFBakmUre3lkZLttR+waaJDb3l08RdM4zgMB97ocVorqEQQo j3Fy07bre4mH7yUHkbh2J4NHkXzO1j//0vlGbUL/AGCO6mYQovlvZIuY0frknHb1PrRaQ6ijWs1n Zm6N3IUiQNgnHfA56+lfy+fpBGbm+tJhcXtusd1FdGR4S5mDlTwCTj05qd3kv0Mrxxs8b+fGrAJ8 w9KuCu7ASLeSbQBEp8r55IymUz3x/WmJcQxIb3zLMRTtsCRzI1xE2TktGDuA464xVxiogU9SluYb +5WUxXlmiqyzWchDTqygsOR8p5x0PNYmmajbasbpLSKazit5niEN2cyEKQOMDv2yB0qgP//T+Qkt 7PSkaezinuXCZeOUYjtSSNxjwfr1+lTC+aRvtTIhmIC4J/hHTJ/pX8zn6UnY3pLqabTZZruxtPsU 6D7JO10A8/l4WUbCMH8M59q4LxLd6bHpOp3MFrNZSRFfs8tuc+nLL1Pfp704q7sJOzuaejXl9qOj Weo6kkgkmtgsaydHRQFBHp06dqp2Go2M6Xby2F5iKYw3EaxhZbhV4wnX1PJ9a3NL3krEUurWcE8F rP8AbIoNQk+zWrshe3t2Csy+aw4XIBGa0IzeWPlK8CtbyEmJoZBKkm04OMZ/yaCJ/Ef/1PjDUry7 1MRXhuXjk0pmltrYYVLgEFQvT3B/CoLS5vry28iOOM3cpLqZH2shPXnOK/nKMb7n6QUr6D7JDjzV W5D7JYgpD56lvTHXvUcS2kipHskuSQi5HyFGyCSR3A56VTgugWNO4gtLONGGx0z9x/4G6HFZFxOL NYXjuZpP7Rby/KRf3MCgdyOucdKzaa0YFexkkbU/s8xdrBSJLh4jiWJM84H0BxXV3a2uYsIqwCPA YDMo54YjPXHb2/GkB//V+IxcQfZ7hXQs2cB3Xl8Vk3H2Ox05pIVnu9QuZVVrdFxFEmdvX15z6YFf zrF3R+mwWlyrBLY6ddRzanFK7ZwkSZMbMcYDkdPrTbq5gVg5/dR3TbdwUsseTxuPYe5qkOSTRLfl 7KFIo4ortcjzt5KR7SM56c9vzqukk80UX2DyTqUsggSxRCbWBcAF2Y89CePari1zamJS1Dzh9o0y CJHM0sb3sCqHDmLJXI74ySPcCq6xOI5r63mEVuIRbXMlxJ5auw+by19TxkCtQP/W/OGx1HT9k8pY i68soJnU7IyD/LFX11N1EdjZJLMyw+bPO6/UnBr+fz9DmrMzbkIhVgMKeqE8D1IqjPcJb/cLyLLn yk27o0I69P8APFbJe6hNe5cgsdXuPJkt2jOz7R/rWiAkXsQDjOBx+VRalGIdl9BulaA7cfdIDEZA H4Cir0N4SXQku7iHULe3uG3Wn2Z/LVVT5mI5yfrk02W4SaNi0KubdMgomZG/CnHZA3d3P//X/LCy 1Y3N0u/d5brtZLgdQOAD9Kdd3UEU0dsgxvk+U9I/wr8Iirux+jsv6hEttsA8t3CA7Y2D9ee1Zxu7 YwLB9ka5vTJmHy5fINse8hPfjIxW5lLcszXd9cNbQapdrd29mB9nMrZlsYzwVTPbJxj3rn5bNJYJ IZ3HkeYxhcrlmDHIBGe3SqjG+5lPYx2sYfs7aY0LzwSj958haNuc8nt2rYZbeOO3adTKkh8hBtDK AoywP04/OrULMa6I/9D8mLa7ih1C6Fsf3UcG22kmXZlyCD37VALacRvF50bT7gzqkmSoPXmvxc+/ Uk9izFJbwxvaRqk8WzbMrfNIP7x/z61yF61ulzHGwMYUlbcbuCOnT6UDNCzuD5/lwyNGUGd8ZKhs 5Bz/AJ71qJbtBLJJxJAo3jzOM9M5ramZT3sUZNPsZvLuDKRJvbZHgEhu351xcsTNrcqXAiVEsxLl JFea3yTzjPtnFenQZyVep//R/nj8cK1gbq9TUZblImKr9pOJnU5JcY4A4GR2yMV8HeLl0i2tb+S7 vFCvqDXElwWLNaBmLfcHO0ZAr4ajvY92urJnj97c2BmdbS8jvf4IbhcpER2JJ6dehrBgM73ctvcx iVzA5ju43E0ETqOBnoc8Cu6nsefNaFvRL3XLbULeHTrWbVpxxcwxgBFgzhic4GM44yPqK9Xt77xJ FCbZJra0jubhY5A0pgljRTyHH8J54zjg5rrSsrHJL4mdDAL+6iTT7jTLq/llV032qG4SMcjc7D+H nnGa9i+EOma7DcGyktZbkWzeZAiTGYgBlbIj+8BgEc1liFakVJ+6j//S/lWvpr6ScXF9E8kc7F2u VGW8wklt56D1yawJ4bufUo7cKZdPdtkwYZM4K5UAnvux+VfJ4p3sdMUuRs4nxPdx3lrHZX1sdRgg aRbIXSmeztpIyMqD0DDPA9q8K1PUptFjkit1Wa3u3JeEnasRQ5wox0/lW2D+GxSfLHQj1G40/VbS xIsxaXEDee1ymd8gIGFIzjj1FZ2navc6N4k0jU4baO6gtbtZrkSxhkZF6oQf7w4z2r0ae4pO+p7J pE1xbm41GVEttkpnRRhlCnkDb6dunar1xqBGzTZ9Itoob2QXUesx5a+tACc7RkDnuprohuQ9D//T /jRn8P3z2byLeQxqWJiRG/0h+eSP7uRTNO0u/uLy3nuNTukKRGKLbcgM+wcBs9FrnFKVvUuXd1q0 V5Clvp0F9bSyLFIjTGOaI5bdJjowxjAHf1rN1LZePZ6eIDFPI5lE0r7EcDC8scAAHPWtb+4Yt3NT SQZJTZzqFu7aPA8uXzoyucbt/TnHStBtLsf7bSea2VtLiiaWcnKzTSbCOgIxzjnNZCMSWMXmgXFv Zi5C29w80QRmQKpP3R3/AMis+zn1bRNL8jS7p7kanEIdS+1SZaKPdyEJ5HAHvzWbn2A//9T+Mq4F ha2RtbMyWM4u4r0TooeRivLjzCPuse3pVjUNJ1S+tY9asBqErSSGO+lWbzLdSBkyMP4Sc/r37cft PIUVojH8PMZrqO3u/PCJORODDiR1Q5IK8cHArtJr+K/u5NN06a7aGVwiuIhG5IHA289OlTKVyo7o ry6PtuChnkaTaANhBeRuw4757VYSx1mS1aK8vJrcW826LTPNVBORxk99w9vWl0sbluHTbrVb+EWa iBLa3H22B5DK21RzKcAY57e9LDbS6QdUFv8AaLq11WQR30rLmGAAjAC44yV6fWtIbAf/1f5ANStI 3tJIYt95p5QOtnIdkcxUD7y/dz6A1hSCSMRP/wAeu0hiUA4APA9vSuLlbbsbSdkdXHM+o2v2r7dC 92gVVhc/vJQuB+fFZMqy3JmWWOJ/L+Rg/M24ZxtXqagx8iDRbW+GnFPsMh1L7YzSQm5EgaMn7wGD ggDIA+nFMuNPj+1LKzGLzDjeeJITkZAoInsb5stahisnW2F7YXFyYnvdwBj2rwMe/GR1rKuPD93e zx2Ojai8dyspvJ7PKiKc/N8rnsMZ596ia0Jg7M//1v4+7Z7u01KSzazg09oVz5Vvv2FwTvc7ievX g49qt/8ACSXC3DJGwF0uY97sVU44xx2rxwKy6/LJsBc+e2UaBE3RMf4huxwOKnvLxVsW8iFYp3yU jYkoD/e/rWDbe4FFNRuryK1sJYml2s07XSwBXDBVUjd6ZHC/Wt2Ka4tbYETPJHMhjdShS49yT05/ pSNYXsUYb42Dw3KyQQybxi0fHluAecj6VrXQh1Rrq80hZILKTYJoGkyqyY/ebfbOcfQUFPZn/9f+ Ra0j+xsscSskROdkY4LdyfrVTU5LrNxYKZkecebA5T90G9M+1eJB6WAr6OlncFIntXuNXjLRXDyM REccKUUHqOfXtTvksI7q4t5Ztmn7lNtLDt+1yEjJXIGcZ+h5xWidlYxb3SN2w1S/bT7Rr6KSNZkw i4G9gTnGR6Zq3PbW986iBtsqIEKZ4bnPI6fjSJDbKlyLRZJxcIvlToqboEx3LAdseveqZe9We58+ /aW3sInWG0M4itgGIHmAH+IE54/Gs53uNaM//9D+S3w1dXCaTPp2oC2itR5ty2qy7mluyWPyY5BH +1VgNZWphXSoJXiigDOxbzcyEncUOemMfSvAcWlcnmSJIWWzvL7VJQhe8XaseAEgyCGx35zWVq9t LLcQ6jYXLySW67/sYy0TjHTjn8PrSKJLHWopoZYy0cUkDHz1I/eBu4P+Fa9tZS3ttdyWrgztGXiL H5pW9Pbr+lTFWbKl0MK/tJtPjmunuTZPC+6dwgUz8bduffI5q/4dh1K6uDqFlD5lxZR+dOGKgyRn AA2n1PfmqJP/0f5Mr7W9XsZLjzboRy3E4iGU/dwqQAY0I7cHn3pUliXTI9WmuFkaR5rJEIxIAMF1 GO3NfPi62KVrevCw3WMos2gGIZH/AHjArk9uB/St7Ska9gtr9beC106WV1aaWUMwKfwEDoR71jJW bM5vWxqXp0ia3jvbWMyQzFrNhCPM37MBicdsnrWdZX2nym9WK3WY2gEZjJMWwkcdK1WxzS+JlaeO CP7KyuTdTMRLETlQM8c/402a0m1azuItPhne9XKxrECGJT5jj14H060NJ6sk/9L+R/TtestNEF/b 2d9e3t3CYNWs9UBSJCpICoB83Ufp1NWJvHOrHe9voFnZQXdkVtbY+YixSqcKcnnDc89vQ18+lbRH nivNrN472E8w+yXFhHJc2icxJMRknOOSMlavXM13ZWukwaTaRjUI3MNzMuArIRgbx3AAIwPWpktL AbNnLd+fDBNClvcQnK3QYKcnnA+h9fWr0l2uoahK1zdvNdRwrGoJDCWNSQf5jmoaajZmlPqc3rmj WEuoRXiAztbgHDJsbA529ex5FRzalvjBjWNVUCMqRjkevpXLK97Mxqv94rH/0/5V4ZtNWO3EsMcV 87f6LI7bXJI+ZRk/yqpqktj+7hnZzdTZCN5Z2oR1O7p09a+XNZdQuLD+z4rVRqEcn2nCLNbOs06B +CNo+uOa2NR0zTLGKzhjguHnhAKzzMZJGLdWwOFH44oOeGxy1+2pyCR7aHyYrc586KTfJMewK4GO h4yaisnW/Lre6hdWoWEoI1gDMZM8MT1yOe9aJJtGc5WTL76fo/8AZTw38l3NGHaV2jVSOBjcQe/W q2l29t9lkFpGyQKm1GUfJtx+VOUdLI1pT2uf/9T+UeG2t54GELSD5fJJUFQ2CQSPSqg0G5tY7q9h vZ8eXi1tHl8+EyL3IY5GQTXzySWiFOd6XJ5nTJZldKP2iUvLJGsjI7D5TgHC4/SqFgZ9Pmj+zXJt 4pHzOBwxGOgPauppLY5ZK7TH3byXxeEbp/MJjSJv+WgJ9KwzHPHHcEWsheNTIgRS6uB0GQODWMtZ WKur2LcWoWFo8WmXyu7XtgbxflJW0AYL87dA3PQ/0qqNFlieK7hvJrm3jnMrwYGZFIIGMDHp+VQM /9X+Ue8uYtPjMiRXFnayLi5kcEISSOWP5VvrDF/ZVuLGWESPIHYgFgy+x7cZr56yZzmERdXZnlvd UkcwuyW6yMH4/hX6CtLR41tRBdzJGbqWFlFwiiQrgn5Sf6fSs52VkbQ+Eq3tteGWBmjTyre78+eW RCJAADgAYwOcdelWVv8AywzB4pcLkqW3yL6Y5qCjoNHlW/mT7RMlpGEIVuobj061z3iGwsodj280 ziKQh3SMlzz0VRkkUGK6I//W/l/t/sNtolzePEJpUtybOAP5LTyY4JPt3rjbHVF1qPybyL7LNEf3 8RAk8sZxkeuK+XM4NXYttaan4iurSG91mf8As6xmaC1ivGIhj28fKCOBj09KustjYCSMHzrqNiGk d96Rg8Aqew44oNCvp9rdW8n2m2WJgjlhHMoZbgMPmLA/U8Vf0nQ5NOiN5dy2slzO7yCG1fdsVmyq sPbigNg1GUXFvLbPJ5SzrtMSnJzzgVXs9OvNL061fUJy1q3yxSTtkADAOB2HT/69AH//1/5UMW0d 1LaCNXswcxqhIt5sk/dH+etdhZvDFYpDFNLEDIS8RXESgAYIOcZ6/lXy4EriK6illiljMUI2OrSA bj0/H+lcvNA1yuy4BFr5nLAZyF5x/Kgxl8TGRXE9rbpa2cQMdxc7VYJgnbyRn1/+tUOpXsrQmMqq MBt3yHYsZ9DVJtISV3Ym0yI2do99ciNsnynXoI3PTGeuRnntW1d+bbRiUbkEkQlV8cOp6Ee30o5n awNWdj//0P5V4NP8u2lSzR3807ZoZJMxDcSchfxrpNLX7LC088LrqEki25RY8wLEucYP1Oa+cU11 Och1SW2lvbfyLjy7uOdJkiXkPjgjHuaxdS1C6v8AVJ/PRIZhM3meXwsRzj5fy/8A10Oa6Aa0V2Fh Bi33U1tj5du51z1AH5mrtvfXcIuCxKQ3sItpbK4wIDk8t0zuHUe4oc10DYyF861vhYqPItz+8j8t cRljzkdua252MzxRbmu7or5j5XOzb0P4YFJO9kRe/Mf/0f5cpnjimSKRNkToZbmRBuG4EbR/n0pZ tRDII4wzeXIFBA2K4x2P4ivlr2OccfM/dxW1lb3nnsEuBPMYVVevB+uPStSO51tv+JXb2NlZWUcR DTwXRfnpgZG39aG0twMaDwvdXQvLU6hbQLOpJneJ5Lg55IOOPp9KvtZpp0AtRcN50SbY59okmmbj qD2OP1qXPsaQvYR4ri5uYSZITAYxG458wv6DtjGauvot4La7vbKQCCFNru2Wgjfsox1Oe1WaH//S /lzsJ7maMabhEvS3mNdW8TcsQMbx05xWssFhZyPaSiJb2cbpZYmDOcfpxnvXzMXZ6mtPYox3OoaM Ly4iluLjT2jYTqx3edzkBv1/OobnWPPghcEwRlcQqo3Bc89Papnrcc1ob9lf2d7GdN1uWVBLE0lp qEKD7XCwABVSRjkHPzZ6cU/VLHw2jyPo8mpsI7ZY0+33QkaR1A3HaAAMn0rmafMn0M6cl1ZlQTSX cPmNCdPit4vJkhWTzATx8+ffafbmrEcD20X2+0uI5JflARwHwOxUHiteTTzNbo//0/5h9Mj1qa6v rvWYkt47uRoPM8pEVoQFIC4HBOMnFLYWHk77F1gtNJlXz9MvBIXkdmL7gY8cDcODk9a+SUHfU1cl Zo2YtPntldtS2zQypiOPgxtjof5cVy1zfzT3ciWryKqJ5PkFTGpwegH+etVybmRYs01Um1nS0cXg Mn2mAqGjjjUE5B9cAmrMupXF8IIBCgiDlmuMkSLxjAXpg/nWQEL208spMgLW/wB2PYwKyHvkdsf1 qe1lFqzxzQZkWPfbbgMdeaqMXdGbVmkf/9T+YyU215ERKZA8gPmkjOAR0x+dV9GsLtdPXSrKWxBS R3Se8uFtYowTnLuSB0A47npXyDWrKl0NC10to5hG7I0oGGnjIdX9dvtxTrsWkf8Ay6ZktzuWQAh+ PTH8hRbS5qtUUoJPtc76j9oEdpcRLBEjNt3Mo54PPvUTX3k3aWapvZ2wNg3D2Le1ILpkMiSjU43l jRoIpgxgViUOOvI9/TNbG6OWWR41CRAkiPOQhz6+1Az/1f5oZNJ1S+tbe70+5kjFpm4mhj2mKRR1 3EjOMentVGKONpRuYqWPzqnevkYq7OgluY0s2do5/MRh8iIOYzzwT6/4VjySXMziXyxPb/dmjMmy TBGMitgK7wTabol5DDmW+Z2ubeeaMOyqQfLTI5wMjitDTLi7jiMjx/aLwwLGzklTKQOSB25ycUDT a2J45pIY55IA4lU5mU5yvr/OmWt2JpkaUh2DbgvUr9fyoEf/1v5nLkPc3RMRWNXIKJE2NpGc9+n/ ANeoIx5Uw8iRmDSEybmJXryK+UmtLnQWtUmFxaX07XdvZ29va73JcCSQqRgKvftms0zS2emWMizf aHuSPJeFgXbrgnBrICSDRboh7i52RPKN+/IdiDz81Y0NtuZjfu/lvK628kynMzR84UfgD7VtD4UQ 9mXZSzW4R5pYwww32dirMAe36VvpjybOVFKRpGMoeHLe4/GqMj//1/5sBeyS4WONVKc/NyxNUL68 f7TNdLYQzTOgEgU7N5UYBOPSvlxx3RhSS3EErx3hgxMgeONCHChh0J9fY1o2sIaNbhjt2viMJ3x1 obS3NIt8zQ4sxlfywgt5BnBJ8zd3PpVaG5lLNEHkUBtmTlVNZSlfQsJrue0uZLaWdFjlQLGcZ2EH lx3PUcc1zM2nySv9rlvJJkLAxG6k3MGU8YUdBScrxsB//9D+YaApBiO4kSNpSMSj/VITjAqtcxXE d5e2k9xHOqKHga2YSRMOM5I7818tHZHVF2uVp55YrAWjTOqPLvUKgJT157duKuWqoYYWEmTCflAP t0I/GmVJ+6i4t/cxWhuhbq0plMcbFgskag88fkaoS6tcG7tB9ne489yJF2nykwM5J7UGYoF7Ytcy RSny5lxJCxzg5zken4U2SW8SOFmjLmUZR+hQd8+lFiU7to//0f5dJdJSVobsSNHIrB3V/lBwQQR3 ror2Y3MaESvFFEwlbyyGZwvODkHrXy50Gf8Abbi6+zSwQiBE/eQzgHdJno1bK3Nw8gka5cyOQXXI Ckii3QqMuUo3GoXNnHfXdxPuQAyPxjgenrTrCZNSiJWHbmLzHa4xAG+m7GfpXOX8V7PQWzuri0t5 YY72WELJnyo2BjbnkEGqto1/I8pvFh3zsdssecyAk4zn60FpWVj/0v5kozcw77VmSNHbBY4JJzVD UHmiWfT4ZjFFeSILqSBR5jBePvY9OK+KmrM9A0LRzZwxiSTFureV87gPjtx71PPEqzi6jnkjKLhE zgeucVBLdnYlttWkSK4w01wEYGWGOPLP6AduKS+njMrOikLI2Vhz5jJxzk0FrRk9m1u9vcyXClYh GPJ2/fkO4AjH51JHLEHEMBBERUMgBXy1PX/9VKy2B7n/0/5pJtRigvtsMIkAjK+bIMYY8YA/XNRX sKz3VhcXF5ciSfdbIm0vbwYUsoPYA469sd6+CcLbHoFqOIS2QEih3Eu0oW+Q4PGD7VIwmjAEUMZb /lpvbYMf4+1QawXuj4dRHnxxSRERL8sr9Co7Acf/AKqkutFDut1FKUhkBbqGU4/kfagyMqSKwi+W 4Ym5AJhOPmwMA/0q5DeFTBEshIXmI5yidxRboB//1P5uop5IpBJM6O8bbgueWOeOKqNqMkjylIZL Xy3yhuo8CdgfnCZ6j0NfANWdj0CxDrMZMyxuvnDAeLbtCmpl1S/zM3lRROm37M7DcpwOpFXT6i6i vqEs0MqW/wAl0E/dsOhbpzT5rvXLOTSJZNPspP3SvcIp2bkbOJPr3wa0GacMtsBJKqbJnOXkXjAH an22pLLcXNuts4VIgwcKQkh6fnWMviYH/9X+dhbzy7Oae4hkkggbLrGpP0H1PNOsruK7tWuFjkhh xujLjbnjjPoa+Cg7aHrJLQt6bNdTrLLI0W2NysYDcuOxqvcvNM53zcKTtHTb7VU3bQoIZ7uMB7ck RxH5m6Mp7fyp9y0sVpDdeQ/zv8zEY3D1H+e9ZAEF4LhkeTckaKeQuTkDgVS1BmvVkWJdiuhSSRjh sYxx+tAH/9b+dzS4T9hhjtolhhiG0RiPyVwPbt1rYkhsdsV06h5Lc7kH8SEjBr87qdD11JN2REl4 v2hZQNsYXBIPLirD6zYC6+e0lkhmbZHCsxRkJ77sex7Vna+gXS0JpmlQq1vGfLb+Bjgj2zV+e2Z4 441XIkTc2374PtVRjd2ZE30RkosovYlmtybOJhzvx5+OoOOR/wDXrV8xALhpYxFsbdCv/LMDn/63 5Vta2hcfhR//1/wLtD9pkLM+MjHsPerReaMSi7cSRJxCy8sq4Ffn57A2ee2jt0likYxKNxUcbvXi qhS7a3a8hAjZcBIpGwHB6kfTFOztcC3YoWhIlaRpVXCSMfmU5+nPersV1I5MAtyxXgueSw9aQD0U qzCKUo7DCx9iaWU3QtEDXDGeJ8yHaEzyeMf56VnNdQP/0Pww08sx/ezY83j5jtx+NT3dqxKSMrNC ThSB8r47ivzc9gihuXluvse5fkUNgnlR2z+VXTdMJZxG3zGMR7U6DHU/jQA2x0d5bOWcSBpJCSBI +XQ9Rx1xUEI1BrJBfW8sMqkxsd29HK91buD/AFot0A0LQlYWuJQY4UwpQ/fk69BVe5mgnQiC1SNo 5N3mY2+Znrn/AD2qFC24rrY//9H8T7O8tEJWVVklUYSIj7rEcHj8MVm3t5PCwRxcqbh9itBCXQDg /NjoPrX5k4M9Sb6G/PpsskFnGI3dpFDLKeN+frXPXSzaVeSSXMuy2jRVQxvkZzzkj8qixk3ZXJ7j VrgNGjxskTRrMJ5FK71PTb65/rV+5WyuNPS9tJYomkmKS2658+MgD5m46Htz2oBO6uOmtEJiitZN xaMAOH4ckDg1n6nY3FpcRxMAtxFLsvNriRUK8EZBxSeiNIJ3P//S/FNYZUeO4Yu6yAByxJLAYqxN cXNzNcMtoIUwqQ/Pu8wKMZPoc1+XJ3R6cFqQJrMFlLDa3AKSyghFz8r7Rk07VorXU3trrT9yyodq WrtiNXAxuz7+9M1C0umYFbv5bsDadzbvu8cH8KqymWO4Z43GJV24PWgCKG+uYZljO/CtujdMhw3a tiEW08Lzec8DW6F2ikX55n6BB7HIOfagD//T/G628QXPkQi4ginFsP8AVD7n0zgZ/GsF7q6u2Zka SRbdi7RDO1c+or8vPYNPTJDEpkmkALvuSP7oX8a1CyRxTOkcbktlkPO4nJpNXVgMyZ5bqKPYlsrp ndHLL5Sy8cAZ78VVs5y0/wDpUHyxRGNkOSmD6GhKysa7yRcgt4oZJXtbeJElXcWUck1dtbW489sr tBXcSTkkf/WocU9yz//U/G6S0ja8EV7q0sVrOpWP7OMtuXJIPOO1R6POLpb+0vFl8lJPLQSrtjZV PDZ7+tfl1ktD3vtWC5itVRbaG4bz/MDqUcEKox2/CrskkqKI4EVBnCuzfPN7kdB36VntMzi/euzN nt47/wApoLryr1JP3sKqGeQDsc9s1tWl49pZ7mjzO0mzDnARQcE8d8dq1fxNjm+hSur6C7S4inMs aiM/MY2UP7KcYzSWGkwTxrd+axFqokiSSQqWPTGO/XpUy0iyD//V/F3UIy9tL9mlaKSK4DzESFSR nOA3bn9K6SPVvPtoY5ok8yCNVWRV5cr3PfPvX5PJXPZ1SI7qG+vIlvLUsGhcN5UZ2TOBkcDv9Kuy WYtdOja/DRTuftLZyZdh6Aj88VLjeWpjOVqiMiS7F1CRBHIIoW+UvGUYn8aohL2S8XKlLcxbSAmd xPHJ/wA9aIwV0dad4ml/Z5iKKPujnd611Fo89pavcW7FHiAXKvtfkHJX9fzrVrlsOjoz/9b8g76W z1B42csZYXy+35WzwcE1Qv55rcYtmMUbrhl6bvUV+Tn0UviZFp8108U73M7x6epAeHdhZW7ZHXit G70q2ihgeA+bHOBMckGRWHrj6DFYPdkliCWRCCqpGVACnbg8VethKGM9oGDjksoxk+lStgL7avqF rNb/AGASpcKomd7sb7eMhjkLjrn+p9KW4ur7Wbt5nSK3VMyXMgYRszsRkIvfr2rF7gf/1/yauLO7 tCLtp3ZQNuAeACepHrVFZbq5uPsyXCtbEBy24q6kc4zX4ufTQStoX2gmhicNvnZ8sVjG6Qgeg/Cl sbYOqXVpMTAy8MD82ehB/XiixRNqdpDc2kT9biKUmRG6YGMEfrxVAXl1arFDZW8ss9w6xORHvwue 1ZzQ7O1zR+YkJM3mMBgMzYMRzyMf56mtuxvY5raWyW0a3eyO4yplluc8gnPQ9eB61mPlkf/Q/MGf Wt8CWce6Bkk/eBTtYA+pH8qux2ttJAXkHySptkcKMsQeM+or8NdrXPqNjKjiW6kjitgxtrOQ7ig2 xyDp9K6KSBoWjvLRmurQqIRaOucuy4YkA8gZ4/rScrXRrBt7lENa2Flql7c3khu1iH9nWkMYXYw6 hj6Y79aoeH0e+gBbYJsGeRiwUzc9h6+3tWcndlnRLA8kltCGFrHBMbhdreU8j428evHb2rWmWWRo lmlkeSCMiIs2EGfakaOTtof/0fzkgOp2ouRJckWsz7ri1j5a4IHAI9scVPZTLGJ5Ujdd4CFNnyxg HqfTsK/BZL3Wfbxd0RPfXk0otpVa42uWj2D+Htx6/wCFdXpjw2yXUF95hgktGZIYPviU/dP68/Q/ SueUb7DM57iOyiVFZnj2j5iOd2MDcOOf8aZo2o3F1KY76z8po2LJP1jkXJC475xisbEt2aRL4k1C 2t7SR4YTqDJMgW3mULC3I3Z69O1SW0F3e73SVTGsfnRI42iE45AHp09+KxkrMo//0vgiKK9QKLma Nr0PuXyVKBh6Lnk44/OtvT9XjSKU3AefBNukacqrZwd3oBzX83n3BWvtU8mdJkgiiURfZ0KL1Ug5 Zvfnr9KtwXHh/UjNYalIiLLYCOzedDHGsuVJVGHfqMe+RVqGlwKupSQWM8OnLJNKFRfMcHzNu7lc c9MY5PpWxa6L9o05NU8zFobg2qFht3uoyy+uQCPzqUruw07O5Suo4I7pnjZzAI1URcEhwOTn3NFg ZXlvpLiWVvOKizt1VRFFgAHnr+HvWvJEqL94/9P4qW/tYLpYp1lV0yXOAMEfd+lT281uJZCZXle5 lMpkkfeRn09hX85zj1R901ZlywWWbU4pYb6SCeAsI50crImVIC8dM8Cs1obq109n1PWPtt7Jcyx2 j3JWS4I6hWChRjnrgd8dKzNlqP05bG209724umvdTjk8v+yJYWSJgRjeJAePTHWqcVtrpS4E+neV GFW5izJuQRsfkbHXHSkyZaIty3V9I1rdNI32iydD5fWJ1XgqR6YrN1GLM91qkQW1aY5SzgO6IDnP HbrWc1eCRR//1PhGze4dbVZEd2kkLxs6bVXBz19uK6OyvXh1mCW9uWurOBdwhIA+zvxypx6ZH5V/ LdOLV0foTjeBr6pfR33lXOntcRkbo5obyEwlyG+8B1IwOD7mqUdzFHIsz2pufLIUENsaMEgNg1qo t6IfJpoRarqEUGY4mdGlO9Y/My6g9xT4plvZI5ZEVUSMIqJ8rtgck/X3rRQVtQUGmgjml3ixZ5It OMxknt4+Y5jg/MQe4yealguGt7pIDJ5vnk+XIynbbKMHGfw/WiMWndmp/9X5Curya2u57aXy5bVw JFuQ2Q5GcjB571Nper3Ut1C0LfZxaMEtps+RHHjPJPTHNfzI4Xeh+kGjdOL23D3Xkfbra6kkE8Uv mM+7IU/l1xxzWGzwhIzJeTRyWwMkshbak7dACoH86cY8oF5LrfaK8Xmm7aZ/M5G2OPACnPv835Vk Jax3c0VpBG0V9PIY/NQBYiTnBJ7H61RMVuxZv7d0yU2Eb20WoLMuXuEE4ZBgnGDjOPqKk0ySzsLj VYLuC4mur+Dz4L0QiOCCbjKA8cYFUotlH//W+PIPtEK5kBukZg88ccgVgmecf/XrKmu/KuLizigA hLCSOVpN0zZGcY9s/pX81qDUj9HbsrmxAL7xBZ6ZaNPCYNHupbm2V9vmsWXmPGckZGenUms68kjv L+O0vPstnJc4PH+pABCs+PzNUopO6Mot3I5pJLW+axila9trYkeapIh2AkAj2J/nSRXU1t56RLmO dt7ooG/AzwGPIqjYt28D3tnfjyrcGSLy7e3vGC7yWAOG6ZH+RWZbWR02MxRi7exLCMIZPmiOB5qr J7knHoMda1gtAP/X+Kp57ZrlI9JWWK1jj8kC/KyyFioDFyAAQCTisW2tpYWS1aZ5b9pXEYjO5ZlJ yDjrke3GD7V/O5+kCXF1Ig8jZ5kbYDzqu5kIJ4Df56VYiv8ATUKpC0pby/Ll3LsKvz0Pp05oH0sU bySK5sC0CT7VuGjmFwPlOMfdPv1q/Y3VnHZ3UtzBLaxwRl7O1RfODEEd+uCMn1pNJ6MRlQ63eWmv WWs6JqOmxzX6G01fSb62WS2uIcg556Nxng9jU51a8v57m3igQQR/v550X5IPm29eoUZH6VnKFtgP /9D4CutdsbK2YzCSR0YJvjjLR/XGM1WOprckR2glEM0YYB02OzkdMfnjvX86QTSP09KysRLcyWks 1ldlWmVgXWMh2j9s9+ppby6tVtZYYULGQf6+cbTEo54Xpn8SOapKysNrSw6LVhJZWrTI3mSt5KyN hkdFwqH15A/UVVuL1raZpI2WOZVyDDhCOOOlUk27GDTW5l2d5bWK3EkSTi+vwzXTTLvD5PBV8nGB jjjrVb+zr6SymhjZ5oJ5fts9uHJgQrnDEdOMnn3rojG+gj//0fzVt7USWZtwyo5fc7AfMh7ZrnTP caOgNxc3bPcXDwJIVwmB2Ujtj/PNfgvKj9Cl8TNdIsWCXM8h+zvJ5avvyzk8kDv0NXP7T0+CKwkt bIItjMJAXyzyDjhweO361vGHcU3y0ilrGo2d6Y/sMRgaeTcx8wMR64GKa08ItJIzG8spXZkAkpjq 36VnVj70V5FUupgRtNNDNA2RNHJ59ud+AABj5x+dWdG88wXeoXdyFvbi6MaRg4ljQLySOmCf60rd Ean/0vyn1xJ7i+jurGGFW8gRylG8sOw43bemW71z909yoSOcEqjb2Zhgowr8LjFp3P0gfLd3Ns9o 87Fbe8wsEoO9pCCQRjtitJG8lrmKA27XhGY5Z5fKjB6/ePAz71qk3sRPYhjlhW7S+vdtyIh5Rhzs Bz1G4Hnt09KZAskly9tdLKLaQfaIZpVxEVBAGz3Gf/r1ulbRGElsiJ9RjiupLS0l3vAuSQvztnIH 0zVq0tJ53lgaBormFN00TjBTOMduM1cYX3HZH//T/IudrXTrsrexy7IgDtiiMqsevOO30zVS51Fd Uv7h9Otks4IY18mQtsluM4z8p549K/HORXPvYK1yJr60sRLdtKkCpGVndOQSBhs+5qW1FndPK9xb RyRi3JjknyH3t0Kj2HPWplGz0LMR7RbKZ5oHuJpcbAiy/IOR2qxqV9dSW4jMpSWJQAgGDJ04z/np W1OLVkYPdnOXVvrUlsYmSa1MsHnb+jKpH3lP+elcsg+xPEioLi7Zwkt9KSJBGByPfJ7epr0aKsjk qO6P/9T+crx9fTRXkkUNkZ3u0NskJjaRFwpIZfdux9SK+CvGl4sV/egW0gdZWF5GU8t1YfdGCPQD mvhaKse7Xas0eLWt1GJppLuOJFvZB+4TCrEpyAD9M10OjR20CkymMWfniKBVceYT3+XrjjrXfT2s eZJtsks9X1HTtRvBplvHbR3ky20tyJcssZPzME/L64rvYrSLIkjvpbp7oLu3DDFgPmJFda1OeXxM 7vRIW02R/wDiZXMpng8tUYiIRqTkqoH15yT0r0f4dXh0PxNY3Iv75NQup2ghvFLqqxkMXUlOgCZG e+a58VK1IqKuvvP/1f5ivFOqT6Ba3fh6PTYdTtIpI5om2bINTjkVWUlxk42kHj6ZryLxHeyXEUDW FwdHZ5F3s65hiAPzbFPXC7uc18diH7qsXSbaaKF9qWjX+kmGyMkmlW8YvXumtDBM7sQrMF64Y4+t fOWvS2Oos9zDE9qkEjZLxlQ4DbSzKeV5xwfWunB9DS75UWEitWjiKMhyPlROVY4rmZVlkuHZI5UE ZO9GTAABAz9On516MXZ3FLSLPZdIglbTllUqw8sHByUbp978a2buK/vYjp9/aR6Zc20IkjmtSZ/t G4DBJPG3GORXTB21Ik0z/9b+OzUrIJD59lcoZbC23yR3N0lmrjgNsyeSOwGTXCHUJJp0jliOXBQe WxIQDk4Yf55rnM5rU6C4u782zTWMrtcQQYtogpMse0YySB05rbks4rqxglN3byX9nErfYJ5fLurz d96OIexJ9hR5EuNrGLaX7abfixurRbW9MPmyQYJkhBwVVz7g5ArVl1c3t1ZW9ulxI92fJkDwFIoc cDLHt0pPZiS1sM06e/0W9ubV57a50m7U7QCJFjY8H+X6fnZs7BNdvDYRRRwQxNukuGZYRJxnMZJ5 xWAj/9f+O3XvD+neXb2TTPIzyiRGjfY6eWQdrEdm7j3/ABqhBFrlkNQuYtRuRoO4Wtzp1uu2COUr 8jHHJztPXjk/h54o7Iu2F9bJFcfZbO2knlAimlfi4jwBk5+nas2xmhj1SdHklguIo1uYWVCoZnbG 3d2+Xcf0oKjujr1sbCaGOSS6urdi/nr5QEjSsCflOeg5POa5BLR9PNxHDe3M0rXUksVzdyec0TMS VT6DoB2oNza0y/1WHWZXhW1DanYJY3sm7yXmZCCMduT1yafqc2tO2qaTYLtumXbfSSy+UlsVIbIH RiOxHHNaQelgP//Q/kD0q1mtvD5jvbiW9uopGN1OVCsEJ4wB6ZIz7U19Q0+4glsbS3huZpUG+SVt xAxkFOeDnv7VznQcQltqdldhHV9qneOOCPXIrfha7jupbx3keaSVbiBgNpj+UdPx5/GsZK0mc5uN PPaRS64ksiz7TPL+8KPF6tj3P86pabqdvcRQzSH7Y9wTe+XKvBy3Q/n09KkiexbuYtT+ziW2uJbW MSpPbWtsp8uPbnO7PqDj6VQsmujeG5EssN7cgpJJH+7mAPU/ln8KmXwsFBaH/9H+QTVri4Cl4H2K 5W2nkyFmmcgDK+o47dKyk0Y6U093eT74xOLeNj91Xbjb9Tg8V44FjTIGttSjjt7cytGjXE6TD5TG wbJ/nxWq1/YX088T2ohlh2lPLy6qBwc+n0rF8vQtx925am0iW3MUs9wtvZXMf2mGeNxukUddvvkY xU1zcILKC4UN5Mr/AGeF5Fw0hUc5Hr3/ABqTRbJGNHp1tqAaa5Dr5ZKqQANpHceldXJZxxWVtDYT IIkT97DGASXYfeY9c8VpTQpOysf/0v5HJk+wttuDJMgxlYgSxz6UatqNhdKtvFdrHep80UEQ3Xj4 HVI8bjjPXGM+teCpNaARWqSaHcQ3kTfaLm4cM95dhUntxwRhMYGehrmfEmragupzQSWFxqkbyeZ5 lnGCiFjhSrZAPPPXge1aJ+7dmElZ2N3Sbq/trgQXsCzW6Ki6bGv7xpJD95JM9u3FaM8lxaQreLFG 8nn4kgVimxc84/z2ptpLURJda1e2d1NfaROAuroLF7SRVRdPUDLPvIyc9B3+Wmajo1lJp8Dy3Dvf /MwJb5JN2Mgjuazc2B//0/5Ibe61EW1tbSwJLbQIbaK43BZAOSFZBzgcjNSaVbyW13C8krLErEPA JQkGzrsVcdfevDveBztlPXL6CXUjDpXmPpz/AL1fOf8AewnoQR35zj6jitvRbz7MbkQKvm+T5ayT R5MbEA8en+BrM05ypeaNpzXc+qxxpYRLaoLmKOcf6XMPvSEH164H9Kh0Ke/e61IjU7VJoLNZNMtG kVHAJx84xyD19aWzZobGsvLeyWNvqEcaIbPzLqSJhJC5XpkZ6nkc+lVoZ54IY57IpESwiFwBtcIp 5X6H096xuwP/1P5OfE2jq2mafez38b7bhpJ8qVEJZeBnjOcj/vmrWkrpwgitfs51CKOESi5uITGA 5HYdj1r5nmaVhdTPkjmv73yLNN7xzEXf2k+RGsYU/cZsAnjisoxsGuNOt544RvDeVuIjBY8lhmld g1dE4v8ATtOulgXUQtssKQyRABra3lbqxI5wT3H60ySWOG5SGzmjaaSYx3hjbclwTjHPsMY+laxd 0csobsn1G4ih0+eCVZYpmUx/aYVLyMSflC+hH+fdNC8QXNmrxW93eafghGWTMfmDGNxb8/zNURGN 3qf/1f5RZdIsrmKPVLa9tlMkwUozbpVI++5QZIx/Sq2m6hY3dl9pmuE1Ge0u5LWO1uVwIwhIUL7d eP8AGvnzk5EXAl1NIRAsa/2i+zygQWyMEDnkYrOsTcSXjyBsLbOUeQ9MqcYH4igzas7EhdzcSRsk jgEu8h6de1WrX+y/tBn01ri2vZ08i6u5o/3eF4KR56Dk/WonsaQWhoW8Nncw3EUl3/x7wvJNcSOq swXPQ9CT0rgLPSzqOoLIl9MiJONlrGV8qQZPzPkE9B2Irll8Rzz/AIh//9b+Uy5tl8uCJgly1tIW tyQJHhbvg9ulVNQt7rUHtwDA0IUfaVZvnB/3a+Ys72KdyM208bImnW6TXUDL9msxlFuMEfIuBx7C tm71uZ41knsY7WdR5b2xY/uz0Kk89MU3FozgmlZkVvcxiFFmgSzUoBJFZ7pEk54Y57+uMAUt5pkU Vq94SJJE5ihtyDO/qWXrjGfxqoK10c89mZ11HOYjZxIcMgmmjZcvIh64/nXTaW2lRaVKkZurdyQk cZgwo4wQe/pVfaLp9D//1/5Q7c3VrfSytMrWe05iOAPbAxVtbiFkkMhY715gPAAzyQffP6V883Y5 mWtRe1uYrC0tLvaunyq8ywSBpPu8pIepHI6+nFZsk6Sbwh+6PvHjHvXTN2GtVoQi5lX5njJVVAWR DlmA6nHWu70q/wBDh8PXcdpqF3FNBAZ9QaVeFLDK7iT909OmKiKUm5MhfGzjtQs962r2b215HdHE 4f5Hi91xnIxzWobq3t4orOJlhkkYQiSXhIjjqazasWf/0P5UpL60lWSC71IX0gl8prURlgSOhx0+ lXBbJp1hJMl2EgvY/JEXk/8AHrhupY+4HSvnznOdt7SGSVWl82RVcu20EtL1xx6VuWEiTQfapplQ GTy4oI1CFVXjLL2PHfk81Mo3RrDYiurrUpb6FLMxvpbDOowyZ23AHRSPbrTI4NM3tNpmnQWC5MMq xMZEkYdySev8sViWSWskf2nY8hRoV2iTtzjORU1y4AaV38wpwFTlR70HOf/R/lSneFYPLivJ5meM SSoyBUt85+7+Pr6VRs/s0befBteaRvKkcLgOAecj6ivlzGHxI0JpJRNZIkyxk3GRGy4VwRyOvt+l al7dWd75FlHCivHEyyKItu4Jlic+3X8KDZ6K5gT6pDFOktvDezWUKh3kK7wGXg4wOmfb8627Yu2b u5AgSWMtiI7nRcnbuHr7GgiT93Q52ZRFN9sjle5ngfMYLAJIvufbjiuijvx4gk0+ytop3RwUlRF8 x1bHKhaC1qj/0v5WpoIZUWGVZbV7OcxDKlXcADGP8asaal3M2yYiS1dvKRSc/ia+XJckjXngsbOH yIlX7xMiLgIDjHSuOdNQsbH9207RJIwgVU3HJPB2+nv7VcUjEzLC+86WJJbt7URzlGUxkl3x0GfU 45FdtZ3SwiWCdbJ/trqhaW2WSYKOu1jyM98U5K0bDTtsT6vYWM0SW1xmW2Q58mLIEuce1UdOKrJc WjXM1wluAluksarb2sYGBEhxkgdec9azBtt6n//T/lsivra0uY43mMcV45W4dIDI0CqCc8cdvWtO 4uLqPSreSWVvJZ3e0YOGTB65PoeDj3r5c5/I5jTbSG8nu5HeMGaISxXa8klc/J7dqtvo1xDEiSqu bhTL5yOAzLkjI/I0C5o9yXSJINGiu4za/apro7EuGkbzI8HOB2P0qW+ga6VTdXE1skbq6IifK/qP 0oIlJNWRp6Pd6XcXklteSI6qAlncTtsELDgMR14Hb/Cp59AksXS7g125ke9k/wBPZFWPEfI2BcdC K1p7ArKLP//U/lvubjajWXlEjzdoZ0xM5JwCRWdO0sLwxW6mTyJQzHj5R1KkHjn3r5GTuzlUk3Y0 9Ov57gyww6dJJc/aNvlwxlwyHByvY45+mKvW8l9aytYmzmhts+YTIWQdem0+napLsxlxqjCO8jtW kt5G3W6zPFtkXHG5M/oayrkH7HbajdXc0klihEjrGfMkyOSUUE9u1BcHpYuw28krrJLKiWxAuAgO ySZjxj2OD3otWvLhtS0y3umMVsn2yaIT7RCHONwHrya6DQ//1f5i5Z7m2tPtVlCGkit/IkES43HG M57E5rJhsPLH22Rmku7gb5Y5AP3Gf4QR1HWvmYrU2h8Js7Yfswtp/ONkVLNHbsF3nBwOeMdM+wqv DaaWYUHkBTCMukj53jPGB29Dg1MlvYVT4GZN0LhrmSWC3hfCbgrT+Vtx0AyCOnFMW5jvLmNzZGFo PlBjlJ3nGGPXocH9Kzt7ySOSno0i8kxkHyK6JIvzqwwx9iKS0t7yMy2yxxmFwBGWcq8HPYDj+daG x//W/mFvtP1mKSzgnnkMNqplw7fPIGQgDHTHIP4U+xms5USwu5J4oYbfyo3hwTFgds9utfLgWNQ1 aztLaxgiuZLiLcIIN3zO7Hqf0yaqYieJtSkeOFYT8zEgYx0J/KgCGe8vJ7iB7aV1igLSXbKctMCp GOnuc1Ha3EtwscdscWisVZ50MDk9yMgelRZc4F66hltLaC7t3hmLS4liWYF40yMttH44q1d7/szX McZkZI87gMsB9KsTV2mf/9f+YRwkVq8s7fwbnCcuPoBzVW6tLEadBNvllhujkgqWRyCDg/hjP1r5 RL3mVLojYtDdxRC5jjdoIwF6fu4+2AfSmSCa5hu726lhiEjeVaW8L4kB/nj3+lJq0LAptKxWuI2v 0tkNosclhGFS4CbRITk5+vuK04ILOCzE1zBHHqTEoJlffvXnA9vX8azJMqSWQSRCGNZELbXffhl/ Tn86nms4TJqkdql/IiaeJ7eQJhY5P4tzDjA56e1Bam1of//Q/mM03XdUh0dNILQiC4nCSSOohuGz xtD9ew49utWrWKHTIks4d0slqv2cNMQzhV45P4CvkYfEaOehnt5qmcySJsaUSM/AYZOMAfh2q/sg WLYSAjjdnO1m6VsVD4UDXNtb2iPGA7XTtCsbDP3cf5/CqlnDPawNPql35MzMZY4rOEuygHIX6Yxk 9eTQUKskcKmaSdmikm43MEaXdwq46+n6Vmb7exa8ltYv9KuTtZpBkJ7gUAf/0f5h9FnvJzctcwQo I0yjiXc784+6f6Z71Y1CBjp7pE7W7yklZY/lYEnJyffn86+XOgzLaxkXSpI2k+2KPkkMuHHzZ+Uj 07c1oaVaraQQwgLhCSoPzIo9F9BWbh2AhXUbywuWS5lZradSrJEnEXB2gZ7VNa3lp5T+ek7yujGF ZUG2LcMcenXpVpWVhNXVjPjcRW4SUuSuVSRh84yeP6Vq6RdEEi5mlulTnc+A5HQDp27UzGzR/9L+ ZZJLuW8E1mRCYJQE3MFYMc7eO44py2U6z3JuNYNnd2uIp7dEH2lpH5BAIPynHJr5C7QEd/YWiSWw kQT3KLiSUOMyBueccflWddy3+mw3E6Wpls4/maVMt9kU9Pl70Nt7jTs7ly41ZLy10eCGzt4oY4uZ Ybdkncnn5z2/GopmTzkt1lCKxDMHGBkep/H9aRqpplTU7y1eS33qhmY+TEQMkcc47/wiiGCBLK4Z WnmVQXBlB/dHqcH0GDgUFH//0/5drGYTM0MiiRG6JIucH1robXT4Yoj5WDIeSX6/T6V8nB/ZOlO1 zN1GHyo7qGdPJkRVKB8Ayg4PyisS0uAuZPLIZDwEyFcgYyff/GtAbvoW7lL8x7YXQtLym75liz1O B1x6VZtre4hhjFzIokDbd/8AeyeP50Gblq0XtasZltiFulDgKTLCVd1HB5BzweR+NYcF/PfRhVDI sLBVkHzB8df5VEm1sZp2d0f/1P5e/tcM18LScF5oFEql0IRs8fKcYNXZ5kik2IoPyhpEJ5A+navl yr3aIJ3aGACyA8t/vK7bfKHHA46D+lWPtNoDbR3CsCi7y8JKtMfQ9uKT0RsSXMUFxH5pKtbpkyBu n41LNJaRJZRzBovOfEW3ChgAcEeo4P6VnFXVjSmhlxbRxJcCQSMufklj6datG3WaKCSObCxYWZ2P C5zjA/A1Bof/1f5i2tGMV3cvMsqxS+VA0JLqxzgkfkaW0tAFxczudzFxLIAxTPYDjj9a+OaurHoF USy3SRWXkwubiQx3E1yDELZFOQyD1OB+FbB0+yZX/wBMknayiDqWGGfBC+vQc/lWBP2iGF5IxIUV AgG4hT8ze+KmW3tyryCOUSTsBLJyVjGMZx2/Cgoh0W9sBc6paM15JFAUhgS4tiqBgQWZGPXIPvXS MlrGrm3fa8owS3agV9bH/9b+aiOC2uW2eSjTwKT5oJ35PfGaorPdlbm1+ZFgbMhdfkYdiD6/Svhz 0CFNRswYUT7S0tuTvSONniO4jDcDt7+tPa4vLh5lSKRY4wCGYYD59Pas5Qu7o115BLaSa4Z1lUxl flGORj1zWpJeTwBLVCrROAWJbp2zj8azMrBG1i1yIrqMyp5TEybcDp0B+uPyrOs7Nrcl1G6JjlYw SVQA9MHpVQ+JAf/X/m2eO0nVJiiiRDyRyRio5UgvpYI5y8n2U5g35IjPPT8z0r4OS1bPQJ9T0dLX TzeW8kRvZG2xoRk4HUt6Y7DvWLa6hNcQvBLGWeIY3KOAOmSaKfYVtbgZhpFtFPdzMZJJdqvs2oQS SAefT+Vdrb3Ntc2IklaQy7QE+XII+taDK5ktreKUoN5QDzF+tWVZ1h+1QmPylUsQCC64Gc7eprBu 7Cx//9D+dWHSrh7GDVrmaKK2uHJW2eUCWXjrs9sms6Jb6MmFrtpdPaVj9l+VY8HpxjqBxmvz9aHq xi07s0TJb26x+VlFQ4Cg4Hp0quA815gS4hb5i7dvXpWkldcxZpRukSOobhjzngcetJb3qX5jilvE +xW0zKys25XIyCgPbkdvSsw23K9y/wBmXEKnyw3IAzu9hWraukkYWSJY2ZflUjkUGMndn//R/n2W PyYJo1YSDBPX7vtXNW1rLc3j3csskMCw+TJApG1yGyCT+Nfn9uh6BuJaWvllvM+VBv8AnO3GB/8A W/Ws+C+sftKYwwRtxwvIAqYx5QNW5vopJo7iykke2+4I5F2nIODx9c/lWvaLdyPDNayiMg8rKSWG fT86oC4wgla5tpx9murdsbMgrIeMkfnVR7dbuNopCrBRyVOCcetBpB9D/9L8CLQxrI1tD8zkYAHJ 9sVHcNNazIjYlaUFQp58vt83pXwFna57BI1vbRWds2oTeTM86rBHEDsds5APscdK0luYbuRki2iK 3Qbhu5HY5FaRXu2ZMXcV/JjKpFMrKwzxwAfSqYu3ieYQmRJl+RjgrkEdqjlaKH2ktzZ5ktRJfyu/ JuEwkR6kA+gqzFqz3LzteWmx2kOfJBcHnqABUNXVgP/T/B+4FjcoFl+0RjaAjQg+YDkdV4p0l3bW zQ2tlNMT5uMT/MSg6Ac8d6/OZKzsewWRewWdzLcSRDziuXIHzNj/ACaIdRsZEF3bGOFTJhoVUsxP fj3/AK1I1azLD3l9+6kgtHijklKyybgJIVAOGCHrk4/OpLe/vY0WC9upLsqHW384Ku3cc4CgAcUE S0iSW95KSYpId6ZwVbOTT7to1RUCtHtO5sDrQZLRo//U/DyTZCI7jygZWUDKL+9Ydqi1i8aU20EC zxyPGcyFSqR4wMs3QewzX5uejJ3dzTS6vb+0RVnk3wRBGkJ2Bto7GqPmPKjJcnz42+Ug87jWc0TJ e6xJkRkQbDtxhfl4XFVIZRFHKAC8SnEigFsfgPrWYRVoo2YfO+yyS26hCozGXO0DHNVxcjynZSJZ GbzLhiN7Ox4LE/hSlojdSSVj/9X8UbPVEuozaTBhKhHkqBkNn/8AVWyt0ltbSi9XLeWVtgMAg9s+ 1flkHpY9dNPVGOjWd2yLLapJPBmWGRhhskYxmkTT72cxmJIYJZJ9qxiYYVff0NWMnuNLijuHd7hm k2hdoHDMOOPSqcgcX1rBeKlpELUJ50Sl0U5wC/uc/pQBLJAVZQCCVbqep96fd2rRRJNvjZZjt2Ry gydPSnFXdg8j/9b8ZbSJfLS3WM7kX5nc5L+lJp7Swar9kWNAbnIJY7A4AJxX5tyx7HrtqO5NqkOn taeXHBHBJazr5EibjK5clSuAcYJI/IVTsYry0iuRNCJ1aXfHK8h3xrj7oHTGcn8KUopoa12IreGN pVnncOFYkkr93PpWgwKTqTBi2kXIEgKbwen4daxtY1trEy5dQnsCYUBuFDZRVG3y1znH4c1fsdaN 5JmdEWKKM4w215DnoaBy0if/1/xHnvTbv5Yi8uPzS2xlxt3d/wCv410zXkiaSquGEJcldqZBJ7g1 +Xnt09zEhSJWUw/efh3c4EfPT6VfN0S0cZYNJEMqfSsWmpGcpcu5rJbWsssl3BBFbTzoFdo85BA5 IJ55PNUrk3VszRgCWGMb1JOVz35/AVqjdJWIGnn1JESSV/LhbKxn7q9BwKsSz2MQS0S6ng1FxkqI sw7B3DdAevB9aUvhJ5NbH//Q/Gi6FsltLDP+9hk2qsqdXkbHy/hkU5U8pEijfJAxuPavyiO6Pcna MbFqPUZLWVUZ9pA4ccfSqN5d3c93K8t1JM0mDmVt+OAAPpTgk3qc9aPvpl+01C5tYHiuWWe33h0j 8vABxjr+P61p2F1axI9xesoE7FYoRykfXbn9KtLZM1p3cP68ysszzySLG6ui8LGBlhV+ENAu6WUF HBQxE9/51Uo3Vjaif//R/He8hliP2i1JCjktjIU+pppDzW6tMyySFMDgAk+wr8oas7H0DepLYac7 wK9wCvmSFVifgnB9K1HhitGViuJTGQig5LY7AVhJWYrq9jHttdvNTSONbO2c2l8/2qfymed0HCoO 3GBkn3rTtdSvFvI4lBS1dwsrjAEQPBbHU49BUJWBpPc1Yb2KKZ1uJFmiUloyy7ePeoIrq1mklnQN jOYmyQu36Vi1Z2Gf/9L8k7rUjPF5qSNIqTLE9qE/eSDPUD0GP1qQwxWFwjSWZRZR5hI+VcsODkfh +Vfi59NH4UaNqYfMEkjuPNbylUN8xB7Crf26xguZoLO0W2tI1y8MZ34b+L8zk/jQbQj1ZQmnW/u3 jh/dQhBhjxnHWtCynW3nhFs4klAwF/ibHXFZz7GljIvUP29vIDHe2+RT1B7k10MNxIbZYYLWOZ2Y ZlVtrrgc+xrMD//T/LCeLzZZJmthBJ5Bicg5MjAnDH9PyqGxkuPtYDXs8sKQeStiWH2fqTnpkdT0 r8MkrR0Pqo2bszeubj7ONttGqROMbY/uL3IptrrFvp8Ug1CSWOCWMqjQqHO7txn+XPNZ3NrJFASW l3NBmaF7cyiR3kJZXXOSrqORx261dNxaR3N0+jWEsUMjtLbKrM0MCL/ApPPfvz7mkBN9suPEkBvJ 7ny7m0i+z2x2BE81SMbsY4xk59RXayWn2htEibULW2mdFS4kz5nmN0LEDkc+3Aq0lyvuaJx6n//U /OS4gaS4+1mWSWXzSglgJELkZGdv9azpTLJKLd5Z4o5XH2hIgR8gOc+55OBX4Ofb3RrRyQQssaTO 0gT5XddkjoOMkDjPTiobG9ha7uY7y8+zxRJvjlKZAbsuenPv0rnC63N5Z0LbDCrK6FlLfxbRnP6V CNSjMW1QBIzFcMhDHHYHpWMlqQ5JyRnyvBJpMrCW4tp3uBKsLQcKVY5ZsnoR6djUup6oLPTEa0Mv 26UjckSARxjuR14rCe5bt1P/1fz7s9Ru7lLa2iJjvoSLuO6MXzqRj5c9Pw960rbUjNd6g2qQW8d7 eZfba/ulifcuXYY5JwR/wKv5vPuCWe90hxFaFWN4h+ck5WRT04xx0NPtxps0YRIw8qzFSsyho0xj G3PfrzWqi+WwEGtWd1DqihxEqGCN/tMLiRXGPuZHHyjHSqE140d7GY3uhH5W0pFIfsyuMfMw6ZOf 0qYxaZSStdmnFq1tbQSveRTFI1MjtHA0pHBIJwOmetNsVv8AV4ra7s7670xGAlt3giG2YsOVywP3 cjIH41qOG5//1vgm502dbuGSW5nvLi8P2bfId/msoOST0Bq1HatFAJnR4xFIYlkYYGR1ANfzrL4T 76V7GnpczfaZDDfS2kyRGRJYk3MhHeswSwWcztfNNLArtI11Id8xZv7o6AZxWJKk20kbIexSR0S3 nm8+1DBmHkiLnr/P86zrK3f7bdPNe3U1zOQlhbRKXDhQPlIz2HoDUybS0CTdrFh557hy6p5K7RE+ FKhscZPvxmrcVvGv2iOVJHghYeZK+CHzjhTWUr2RMW5N2P/X+LZb2Y3HkNaLZ6fari2Utu3DHzMf Tt+VTJHFJJmPncMjC81/MEE09D9Dv7liCafVZblpjeobWK3FrbKsQaSEqCuATx/UVj6dqF3ayvpm pXCf2k0hjK7fJUHOBvJ4B6cHHU1om1ctysjoLdbS4a5sru4t3vbNRMIGIIkUnB2uDjPHQVrodL06 3/tNWjlKyhLjT2k/etgfwdeCB19cdapaolT1OcsriGSG7vJriZI1leUmVc+UMnA+grW+z+fBM8Jl iE9uqwXTQjAfqSuf8/WpTfM0xuaWx//Q+I5l1FL3T4rsiYSR/ZrdZAIxISTgkjHocVuwXlq0VzYi BSYCYJRja6upGfqMcV/MqTTbZ+hubvoVXMBvHkthIkXkqhZxjcwHzZHbnP51jarNG1rs3oQJ1W4h X/XSqSeB6fUf1qhufY6C1u9L826Np58cpkijEcxyCNmW9upXp70+9mxm5h8iIiYQyRI2JFG0/Njr ycfnVwjfcqHwoz9OuoxqMdxOd0lhL5scUmR5hPBXPpgn8qtxXktwZLKSCa5geXzldVULE3Qf0Fap W0QpStoj/9H4wljkjvo2it5ZJGYQFI3A4B5zk9uemaq3KRpfSzxhWktP3h3SKV+XqF55/Cv5vP0F tvcNGAfT2u5F+xyyyMI4mXbsGThs+/WnTyWtyEMjxXL2i481AM++KbVhbFBdUcFbexhSWDUGME96 xCi3Kc4z9eCe1Ot9VFhLcI0MN0iQvHI5PmDBUjchHUjjFaOC6F87KNpc3d1bedcbxZKCY45uGQse Djt06Vbt3Xy7YWk8ly3mObtQS62afwsT7nj24qwcmf/S+F9RsDdyWNna332CwQSXepXWFM24AnC5 65x/9aoVvtPhCqZohIV+XUG/18cZG1gCDwGyCfpX88xjd6n6OrtamfM8dndyaYGCLEguIkCMIXV+ jIcYIPtVaaJYLmCORirXFt5rEJiLk9Q34fr7USjyjsL9glkWQvfwJbWjrK8KyfPOM9vp1qe0vn1C 8ktYUQWscHmtdyOFHHAUL37VIm0tzOlEenTTLd2Fo7u3+iHpK4I4weME5pLi3NrFHFqAWCWdROqw TbvlYZADA8j1oHFrc//T/OWO8g1G1uN0DQyxKsFvELfYZgDgsx9cDOe+azml+y7AokZYwGjXdiZn H8I9ie386/nhJt2R+n8yNl/Mh8qW4hjtrieJZJU/ij3cqpzyMA45qlqtxe28wgsnidni23aoFkBj YA9ex47ehrSMLbiUkzF0/XWkuJ7W5sgI7TEkczyY885A2BccY65zWqbhNblmkFmdPnuZ3mliaVds aKAARjoPlJ6n7w6Vold2QSa5Rj+W0BRoiIyPLU+uOOtYWozXu+1gtb2S0gilBkQD5HHQ7u/TFbwg tjE//9T8xjerHbyskTfai4XevBkUD/69Yd7cTakvk+SixQzJuMj7SMkBmUdc/wCFfh3Kux9/J2Vz TNkjRrCLlTFHJtgjJLPEcffAqq99aW4ubK6DuWiKRzxLmMtnA5/A5xWsErXJqt8ljAtXNneRNaob l0J80zAtH82eM+4/Kr73mv217I9otvFa3W2F3Eg8yBSfnCoQeuO5rH4qhtTsoshi2Lq1z5k8omeJ SiCPah9j7f4VvPbyT6dPaWqxLqLN5rXON/lx8HAGeuKdkaJp7H//1fyuvFt7MwNLeI5jCmQJICUJ 7N/nrWbqBF4jxbBiRcIH4JHtX4jGLZ+kPQxbaCYyPAmZFixEomXiADDER+mT/OtG+aJNOmjay+0X OwNDtPzoVOc1pBWWpE9rDbFLV4LdZ8iUMJUilULg4Ga6GS5eWRrlo4rye0h+WKZd6Qx8A4XsOnHS tYLW5zz0SOKt7EC4u9Tic5uCIzkBHj5Oz5asaZLq9lNeG8a4zckyT3UgKrdHjJyevQe3FbxV3qJT SVj/1vx7XXDfXEtu6CKKM7UuvvFh3JHWskqElkkLFosko44xX5FyrnsfdxlbcrQTR/ZL1G0xb+3l O9Ukz5oOc59PwNdHdXTmxt91jJMZ4wqSQguLVlHAbHsMc+1E0lsHO+hza3hjt5J532urFdg5K88Y 9aS2h1C9uImWES2skJZTJEyyRsOhB/GtYRV0kYSnbQZrE955VnZ3l5Iiu5jMiHfNBGMdAe2Cfyrn tYl0HTIJ2kubuSWK2aaBYrYypIq9y3r6jnFehSj3OOpLQ//X/m4+IerarbafPLY6jcWbyweX9qdA ZYY1AYbc/dIx09M18e+KtPkuLOTUbmc3In/dTXJw07sRne3rmvhqJ61aR81LYgXF1MVaaOOQ+WxH JA7kdqs/aS0cRSPhWIUgcg120zz3Kz1NqwEpZsq73RYPBGozvbP3f5V7Fp8wtobUz2CWkkfzTsn7 ySJuARz36/TFa8ztYxb1La3wz9pKMIlYgyt8qKF6n8BzXvHwY0dPFeqRq2qx6cuyZ0uLthEI9uNo X1DKGZcnn36Vy4r4EXSldWP/0P5XNHS8htLW11OOW31JpSkxv5gtsiYAV4y3UEhvbGKzr230m2hm staZL3UEuWuI1WMPYpbNnGZAeuOMDtmvjq23zKo2fNcra3p9u3hxNdt7+0S3sHS2tbOC1B3qD8kc cYBBCjkk+59q+UtTGs3ni6+lvlkMN85a4WKyFjYwQZ/dll+7n7uSPvHmunCKzszZx0VilJbW1ldy yxXjzrED5UYjPkhgcEE9vrWVK88+rLcCSd1aHy/LdgIoAD2FelD4kRNOx7DpWpW+m+Hby3lE0d1K B9lmjiEkSs3BabnIA46VqC51FobJfPlv7k2oV58bRDjoiD+7jnjpXTBakSjyn//R/jTmgMqym/Hm 7lw8BGV4Ofz/AMKns7vTgiWyW0dzHHzJFCu2cc+uMk8AVzmU9xdKMUc89y0N1DdXMrrbafMxZbH+ 5uOPukDp7/hWFPFqd1c2eqxwG3uWynzx7JEK8fuiOhBx+dBBspp1zexNJqF60mqqypPcGMefKqYA Jbp0GDTntb+5u4YjJiCFTtAO3AHJx6dDz1qJtrRAW20e8L/uIGltPs5fzEQlYNp5zjsfX61HZ3Fz bySR2yW8jLGVjMjZi3EEAsPQGsW7K4JX0P/S/jjs9Saef7FOliJ7VV+1SM7NI7H+FFHQdwfQVVvN Wms7hIHvru3tL2QRyWlpCZEuCnIZwOu3qMkD3rzOdAtCPSPMS4ury1mbzbhmjdp02GVQSDkH19R+ dbuoaQ0kNnewRxyX1zOYZ4IJVYhQAEcjjucf/qqxx3GJHHDZxi91C+sBasXmvwVm8vGPkVcc59Pc VNZWFvNOv2WQ31ldNvtnkXy7lznOWXsTj3oNlbZDtWvbbWNQ0jR4bCzhtNHl36nPbhobuYtgpnsW HPoKYsAttQmKzNIjNnMzbpOeACPYULQHJH//0/5ApLn93c2yu8Pmp5TMvJYHrWE0YsZlEFojSRRK sTBtgbrx+Arj5zSUuiN4wvqUDxxs0ciYLErhWP8AdzS20MybYpg07Qrs8x+UiA6KPaobu7mZLPda aTK+oXEkjyR/ZjHHabrVxjCqzDgeh+tVYrNAFhjt/sgDAqbdcyFW+6APyxU3V7CaurDYLm9j/cf2 79qmtpjF9jukWKZozyFwB1Ax0rZmubG1tZb0WKXOoHbHG7N5boGOGx6/eqZuysM//9T+QvUbeS7t 4Eu4TZx2UvmWhVwG6Z3AdR94/nWdp9pd27XTvdS6pJdSGWyjvYwbS1IHBx3I9T614zdlcDojPcSx fvRGlwU8uS4iAQgEYI+h9KxYre/tlu7a3KxC7kWQXUSqZJguN6MSMcjIx6YrA25dOU07zTrm50dZ Lq6EBtiVtlEZl2g9gB0rJs5GvntdOmuWmNocpHJny4/9v275ppXdhK90jospHA1lN9nea6/deXCx DwjP3l+vTPsaiXfo0U0UqyNPIcxlRn5RwM/n+taxjylWP//V/kFt7u5uYZfPm3TxEsskoCEL1XP8 q1NL1DUNZml1D7NothfaXCLW21a0to4LvZxhCQPm+6K8Ll9+w2tWPa1e/eaK6uS1+x82QsCI5d3I ZSe3rUVvpF/bqbe72urvtijiYtGQPuge9aW0szGa1NS3luoIkGnSQQi1uMtFfWIeXIOCcnoePX0r P1JdXXT7jUreym1C2jmCzpEQuwnqee3U55xn6UpL3SCwYYb6C3UfZAVUSY6ToG6gjvir2sWUVtYa bJbS+ZPaylriGVgrOp5HHXj+lYhtuf/W/kTuLa9vi19Y3Rt2VQI4OMSEEZZs+2RUXmahPKbt1EZV fKMIXbGSOCwHvXixXunDOS+Q6wfSrYvLqLIJwMWcMuAZpdw2qM9+p49K3lF9cW93c3RFoZASLoRB FjYg7Tt6HHFZNatFwkmrHP6hplxc6TY28k39pzXt48Nw9y32NYUK/KyqOfxrRS2bw/Z2lnDptrcz bFt5LwT4lhjGOrHOcYH50jqjqjU1HbLpYC28XnGMMJkc+Y47Iwzj9KtaBa2b2OzWHSDTo4nbOCEi cL2I/i6HHtWD3H6H/9f+SeK6gNnNpU+oXGtQJMLiOa6iUSjDFok2gAfKMe/Ardt7mXyJJHOzzpN5 VBgLjoMdu/518uOKu7FoYuICCpAI2sRwRjp/n3rnp9OW6S4itkf7aytucLhGGAFJOM5HNBcoq10Q nwna29qFeZJTO2Z0kXL7hg5Pbtx9K3IotOsXinezszHEqhpYo2klkYYAYjnngdK0p9TlkrNmDFcm fUtRjubK+fTo0Mq3cY25kz8sYQgkjnkjpWgujI8rxXBmtOs1sjoHVSwGAcnIBGDWhJ//0P5O9N0G XSorqZ5Uke5JmeclSu0AAKCOmMdO2aqJpun3FpNJGkCXpzJCFGMv74H618+Ycr2NbT7y4tY/MeCJ XceUkn3miYYyyemattZSy2kmJVthO2TNwCpPO7n/AOvUTvYznG+pl2l9N513p81tE5t7gJ9qjfe8 0eODxwO/H0q1r2mm1ZbmG4MdqYle0VOBKx+/kduD+lSototKy0OXdjcRvp6IQ7phlDbSQ3U/rW1Z Qw6Tcac8UU00sqMszCItbjHZyOlYte+c0173zP/R/k9na7ine4tLeOCJ2/fBTtSMdSwGDzVdYZ76 58zT5Ft7y6xCJpU2xu33UZ/bpzXzdv3hd1zM7jxH8P8Axh4Ns9Dm8VRjTnuo3nguNNuEvZ73BXJD JlR/rFI78j61i39vZTxm4tJbi9NoFmn+1xeVKxOA25QT3PWtLDtaBReU3s6xQzRabHJAw+Q7thCk 8bvUgfnVJpJrK8S6JmuJvLEbfIdhUZA9vWpirSZg4aNmnpeoO2qx3Gp2vnxvGYXbf5flqo+Ue3QC pLrUoWvY4lkis7Tccu4DI+M5X/PrVtWKUFGx/9L+Tu41PSZ5bmO1UllUBjKpEXTIf6cdj6USPJNb 7raaDeAsZwM7lz82Md6+Zk3c5zV0/T00+3jneKwEdwp/1bgzu3JxIM5496SysE1a7lsljSO6KPNC icrIsYLnnpnAPFdVR3saQXuJlDUXFvJZQ6YI2vH/AHN2lxJiNQe69v8AJq4975PlTXlmyxhkjnit BvLqMDOO4GSfzpRaW5ja02S6rENGWG5kS5it7u4A0yYwMv2wMcAY7HtgZrHR5L2SaJYZNkbrJIWi IZGXoQT1HzDp3HtUu19DSTuf/9P+VSK/tdOj8ibTWuJ2belzEg3AkABT6j/GrV615PpVw0JiEkUQ mW1J+chyADj8q8BW6nLq4mbFpniVmsDpZhu7xIvtt2BkOYwDuUDHJA6jp9aYTdOJpI0SNoTsmt9u xtx5/KspvoaxaW5PMsdnaQ3lpqMk00reTe6c1uY4x6/NnJHbtVLS7G00uO6mu4zZfa52nW0spPMj WRzkNk8896yvZ2NLxaLk6W1ugNjFmR8yTecxzI7Ek5PbtTpILpB+6WKeWVQVjD7UbOMjPtn9Ka1M D//U/lU0lZYrmSSewhkhnHks/mbllZSRsIH90nPXvWdqtne2sy3dq8cS2zCWa22cSoD8wX0OK+Tc m9EZwUb6s14b+3RkiksnvVvYwbe4eFh/Z5KbiT6f3ec8njim232ZRLK80sE8XmIzSRfKQVIKg+hB x9KcL2Kq/C7F+GaYWsMktsZLKG3KxNbxhSBywXgc9c4pisJba6uI3ljimg8qSFoSki9eoPNWZ6uK iZejC0u4pA1vJGIAY1MimMtj1B5qzHFc2JZrMrpt003mQzRttd1OAT7bhkU0m9EbH//V/lfttB1j XwsNhMqXMUvnSSSuoDqPvcsR61LBc/ZPMtFMSm2k8swH7kxydxBH+ea+Z5ZbGU9zEvEfz3uHRZDE TIQHxsz6+4/pW9LdxxaUlyZWYNIkKERlo03HGWPaqcWlaJBkavHeaffRNLbR3tsYw8bRIQIG2gg+ p6j8Qa0Lexu0so7u4kjE7F3EYHyxqD8mD64qXCQCebdyvEIjvmPA/d71Huew/GrL6Xcac8DXojlt rj5/tCy8Fj1XjoQex9KynzLYD//W/lhuy1tf23kPBNEx2NGLcuX9vYDuSKmu9QebT7jTW8hVQFUt owrID0zn6Y+lfJ80uxwehTsngj2xRKx8iNTKFBEe5geB9MEf/WqW5+0gpcLLloQ2xJeVRTyQKXNJ MhyS0ILO+tI3iS4kDE3HmtswzqT94gfSulfUYrpJ4oreXZAu22nmj8sPnvjvwKOeXUzdTdI5l4tP he4nNm8tyApSVT0IOTtXpnip1v59eS4tLpri0QOs1s1sTDMmMEA/l+Rq6cpIHUtof//X/lr0hboy 3V3Ow+02LqYuMM4Uffx0PAFbFgDrMD6u4txaSXbRsmfJeXb1wvYe4r49pnBC900Ylxf/AGe7ji0h 5LWa3ZvL8gEDacqVVu45/SptKuLy1bUdQ1OSZ4Gg8oxysSy7Dnfg/wD6zj2oO6xXur+3vnVrUEmL kMyEKSccZ6HoKlA1CKG3l2xSuXDTqFOEXPQDoT09qST6jhB2sjSsLG4v7xo1VVTHmEHCHeT6dPyq Ewmz1S4tBAyXEijzpVjwSASAGPetotJJG0Y8u5//0P5h0BtIpzK5JcgRIDjdz3qKbUktz5lwygyL 5IRo88AAYxjrxXzMfiOlK4q39rAIFuHXZPIqomDvG7hRjHes/U7txOStuAjOFQxnjGOrfSnCzkxT jeEojLWeKaC6S5UF3jwhLY5z0+hGR+VFh9ne4SHAikZgixJ7/wB0d6LJz0OBb6GxcW0kFyWSWPEU fl+SQRLEwJ+Zvr6e1TSSyFFdgFmePcsmM7yOx7881c1dGzaTsf/R/mDe5uIoTe3YdTdt5KxyTbwm wAYA7cEH8atw2NnJdWs0rCJANz84STII/XNfLk81pcpBqVpp0SW/72NwJWEOR+9iJPOPQHP6VlqN sUsUjIyeZ8iMQwx7igadzSieFYmRbeWF8fPdcCE/3QoqNEN46wNIqyv8vHCn3rK75xm3pmhyW0kr yw2bzGMwQzK27Cn64Axj1NZV9fLuksEkkSSQYZkQhRgj+Lp2rUD/0v5hoLaWSyuHubeBJYRtW7Rj JLMvZcfr0/GktdPhiijRbxpwD5oVlyEZuSuMdq+WSs2y3rFMNt/aTSQi4Z7CaPbLDkqikH/6/f0o k+028E/9nwxSyGM+TFcklUPUc9R0oa0siUrmrp17Lc26pqFn9nk8kb3j4hVhgHnv0NUtZZnMS20U NzCPmbdLtYEccDB9az5XGLuIpwwRRW6yMHitRdLcTSxLulyCAyr9c81I9/dgXQtGubeGSQwecvys U67G7cjqKgD/0/5dTqdnaWk63MEMqRsJ0klG5o3TJBX0P51FIl1qmmRuHfT7q5RLqJklw45yMkDk EV8jH4kbJLlsNMd9HbE3MqyhSWZxxgDrWtFo0EscWoyuZHkAEEbMQ8CgDkr2z7+lbFbFW4ecX0EC IkcEJEiynuf7uK35Xvp2RLlLaNZOQ8LbkUE9KqKd0G+xTivrMJBBPpNleTQXhaK6kV5ZIyp4IGdo xg9vxput2sl0Y5okRHkl8ySZRgDrlcdOapwYH//U/mQsUlVJIrfy45njKF3UOV+gP+eatLDI0fkS OJG6MWGOfpXzUo8tje6W5SntJrGGYy3EcEM42+WPvk5zn/PpULTWwmjSDz2tYo1VGK7C5wAT3754 qAuindK1zL5aPv8Al8xY8fc285J/xp9otxOiT3AKEHBDHLAjjk/hQDaW5PeSQllRmUdAc8jHvWTa yXcUrR20W9EutkjudgZCB8y+uP6GghzVrH//1f5mW0ya4hguo8ri4VzISQu5GVsfhgVa8QSSXE9t eXCwLdhgj3TRnzZkGPkyPpkfjXyUkuYDHS6Fxe+XNGqIPmVlb73sPTFStqF41/JY2sMV0s9syyKz YijXHBIPfvn1FS1YCncSR6fb5Epmn28Iq52t2GfTpyaoyWl1OfMeYAsu5y4yRn0I9KQJX0MtrJWn QpO8hWTEc7IdjY4xXT28k0ENzZyuk0dygwdoDIMZ2qR685oOg//W/l2tpPsmyLaqsZGIeVSWIHRQ fYVorexXs1z9leS3XyESORT5sZcDDkD65NfKQjbU6AvtOuJ7yFXeSaRYVy0hwAuBjPoMc01rWGGJ vJDPNyRHgCLAGWOfX2qwGafcMqsqwjydhYOeW68/SrFy4uoVSNkilSdGUlsMwBO4Y9CM0C5URzW5 HnpbyBpOBM7klV4/z0qr9phi3WimHzI1wSuFQn3qJrS5m4NH/9f+XFb+0M/7+AyyKdsLgHbG46N/ P866Gyu4IbO51BbZLkSz/Z7ma5iL7D6A9cdOa+XNYwS3KkahJEmQIYwwOwrujA9MUyWOG4u/3IAA HzOxwE45wPSgsrQWDIlzYR3U0lu7tM0rNzHuzjb9OcVUubXfd6fHP/pclpiK0lmOOfUnoOefSph8 JvFWRvfaL1y0M8UYA4HkEvGQOOSaoQR3DXUsUUQWFl/eMWwGOfSsnuM//9D+YqWzuYZbdY40+xs/ zlHMflkdTiteVYZCjvG0kSMGATCvxnpXx56BjXNtepqaTW9sFsLtQIYpZcS2xGcsTjkHj06UwQXK SbZy3lmbYzxAvtHrWM1Ziur2LUtzFDIJoI/NaBdnlfc+0AdN3p/9er1peu8RuGjWPzIt7W7MAYiB ytNq9h7GDfedJKs1i7xyBtzRwqNzjnKj61sw+YLKOWTzpPkDusi7ZVJ5wR1/OrUUlYhSvKx//9H+ ZNZms52nVSGePPnDkbfSrNvqEVwtwpRWXbifzF+Vs18OenT3M6yne2W5jVpYPtR8sALmNgD0+nHf 1rUtL+ezuVsJ2ilkuVMfmnKxiMj5gp55GRxQal5hEv8AosKBF+4shG0HFZtzEIX2ydWXAfOOnv8A 561LgieVKRYiVURGdgqsdq545pGkkQYgcgFxhuoH0ppWVkJxVtD/0v5qgWsS7MFw0e4iQEckdf1B FWtMmR7WWa54nWTcuwZiVOep656frXwzSZ6BBcXZFqbgCe4jkOY40Qs5+g/xqnA+xp5QHgt5sRsr MEZsEHgcHPAP4ChJLYDeuFtdQtRA8aOgwF8xQ2Md/rViz8uH924WSLYUBVtuzAxkfSpmnYCvi3gM rLmTecMTzxT454LeMCIEO3/LNO2e5rIadnc//9P+b9bCe7kWNMxo4IyGwRnrj3q1PY3ttDssxB9q T5ma5cqzgEdh1+nvXwMFdnqqSehFcLbyyW6s22YD5oyeQehqzaaTqU93HBAAFlYFN7hQRjJyT0rV q6sNNtlu5gZWEa/OFOHPY06L+zYLVLf7KquH3ynZwpJ7D9c4rC1tDOV76l5kiuCsqFUVMYCdDjv+ lZdw5muYz5siwxH0xn3NGxJ//9T+dcHDM0DO6N1Pf0qS5M4ijt0G1t4kZsc496/PztafOT3N1bMs FoUZ1l4dlXBTg8GsiWwhhkU2gKZPzsSSTn1oLNmKxliKSCWMjYG2E8D61diuLlN+yU+bE4aMxKGU 4OSDQA5opbkSzyM4lLby245zTdNuxbK1sRuYyFzK5JZiTyDTiruxpBdT/9X8CmghQxXUFx5Fy8u7 C/KFI/i3du1RuYZJnH2mS4kD/vJ5FxuY4JC+3vXwyVlY9g1J4/ttrHawxCeaEiQswGUx3z2rHt4f JS4k2LiQ7JTxuzz1/WnsJJLYz0jurq4lSKKcJbDzhtUmMKv8R9umfrXSXGyOC1kz5s8qZl53YI4x +lZOb2GXl1Ly7ZILZP3EjBmyv3W6Mf51fiVreK2nMK5lnIhKY35GOfb/AOtUA10P/9b8KZrOCXUW uiHDkZfHIY96jm0+zuZJZWSe1ljXZGRF8zntgenPWvzqe57AyCA28ouJ1N26RFI1lUMOmOQaq2rx hyhiUKW+Q/dKnNQB013JK0BZpiGcAF93zH8akZoIlh80RyPtBBQhwpPoaDKe4+SeKGH7S6hQpJzj nHfgVmNNLNE1ygWSGVv3bO2w8+1BB//X/ECGa2ksxJJIqTJkFs7u+BxTN/8AaSwoZATCdoOdpxnO K/Nz0Ce/uHtkS3ghJDfuyI1+X0yfSsF7m7RjALcMqkYkQ8k85H8qxn8RLaszXkncRmyIfypgssjB RtJUnADdjz+tO002V3JPbC4jgEK5kbaWyR2471I4u6JzmRZIkfdFHx6F+3Sqkdp9ggkaDLSTNlYn 4VB7frUyTa0Gf//Q/FCw1J/sBVNEhjuYrkia/kkLM644C9gOvbn8K02trTU4RdRzu13H+7eCWMqs XfKtnnP0r8pSex6tPYwbn7RbfuFwDJkPMn+sQD0qkolkMBLNJJFIGVpid6f7X1rVX6lnVWLRQ3Tt cs0+85iyflzx1/nSavJvEmIN3G7AH3qZEm9bHMQXc8kn70bVX5TnsPSuhjs4Z186MIs6RAwqV+aY ZGR/X8KuK94Ix1uz/9H8TI/EF7b3VzHBp6zJEmPtEjb8DABwmOMZ6k1TaS9ZjeTO+0HCluBFnnGe 1fm56s1oaM2r29g1rC6vPcznJES+bjPc46AV0N032i0YJtURoDLhwDg8dKTdlcqOxhR3FrDAEeL7 T5fCwOSm/wBMken9Kf8A2pczSxLduRHjYjsMrEB0UD0HpWN3azNY2bXoXGe2muGEKxrbldvmAfvW Pc+1LL4bEUaTBmktpOJimVli9xSHPY//0vxd1e2t9Qkgtkkd3TZCsh+Rtq4wCfoMfia39XBjsILN I0t8BI13vuUlQASp98frX5ee3T3MeKFI7LzShkZWzIfvAVVvJ1THlxRgPGGWVBmRvUf/AFqVveuc 9X4mQLqcphiDRrCASrMjHLAdDjtVvzVMUc3nNLFOcGNuMY7+vOaz1Tv6nTFtU0y5DEokhezARA48 zzd2GxzgZ6/yqXUEiLi5ZAAHCMsa8D24qW9LE3adz//T/GS3vbS0jms0s2eSa4E4kmUsiHHUZ6Hp 09Kf9kuI4JLwuH+YLhPVjhBj68V+UR3R7FX4SrewXsLpDc26pL5YaRd28DIBH86YLdPsjXd3PFbO rhI41cFpPbHUYxWkI6/IyrNqzNPTcXKOI2E8WNhJHf2rUhtbcLNDMc7lyq7ehFVbU0pytGxjWVol jcXf2WeQXUhLSea2V2sMYHpU1rKZPOjuZAzwuQnl/Nt9zRfWxtTahoj/1PyE0/UY1iminWNlLYAb sKof2e8jSrHdHcz77VgAqryMKT6e9fkjm1Jo95yS0K7avf22p2UFx5UwhAMaKd8TYOSD71f1a8W8 vYplUwvCmFEbEKhOM9+egrN7kXvJF/RLu10SQ3bGJcIxbf8AdO4YJP4ZpYp7e+jN3CvlLPloVGAS MnBx6Uin8aITYxSqjl3ZgcOh6H2pqi4kWeIRRQQqwWBYuGQDFZTSuaRSbsz/1fyQ+ysrQxx+Q0zI pH7zIGfWtu4mj1C2j0d5kW4iTMT4yqEdifQ+9fjMUm7M+tjCNkiCW18izhR0H2mE7S6ksu09/btS 2UEEKTDlLgtvkUrwwx97NElZ2NkoJ2bJ3n0yC38uTIupJSd5AVVUjp+dULYukvnxMFKHbGRwfwrK a0NuWCjuXJCGBaWNy0n32U7Tj61Yh+y2iGS1+0KYlJYTnII67i1Z2a3MaiVj/9b8sb+WaSNPKcES IG3R/McUaa9t9sik8to4XULkp+9AON2Qe/tX4fY+ovZonvsmSWOBG8sS/JvHls4zwcfTFVfI+3qV ktrhLaBcySSRFehxkcVnKPVFRlbS5FpdrarczJt3QRrl2H3h2Bq01xew2ciaZ5ZkjnKxyyEqzI3B DY6dT09etZ2d9Q5nc29MtI2kVCxj2LkqPliBPeunutPt98MIaN5Ifm+0RHcPmAyAf509bGikrbn/ 1/zyu7m3shbwRHbJnbt24Q+5btWGdXjm1E2kUZZ4DteRF/dNnggN0P4etfgk720PsC1cWX2aO/vt Q1Ao8MINnYJbgk5IyN2cj1yfyqpoSWup2l6k6kZYfJJEVaRgQcZx0wa51z31H0saq2bi7jlBZ2SM xKjH92gOMkD14q+HtYZNkiAuOWDjchOcj6Y4pTXVErUv28UZXfOImMgPl7sYHUZx7Vka5bR6TPpr 6ZcW15K8e++iOHW1BzhQehyMZ/Guae5cro//0Pz6jmeD7NdRoRO7hW8sYCHqCPpiq135LtJdO8q3 Af8AeSqSZGLEAZH4/rX84xSvqfZRk0XGtVcpqTR7LdNsdxsP76QAZJA6+vbvU+YyzWroYdqeeMg7 2Q9AfzFbD53Yk8PXX9pLLoi2V3NLC7SW906kxFACfLVzwSB2z2pn/EttVeGR2tXaRpFeZGcMwPIY 849vxqVJN2RpzPlN/T9Ssre9X7dO/wBkniMFwbQBSyshUY4wRyOK5+OyltraG3Go3s0SX73FtBEx jSLd14HHIGD64q2rJFJ2P//R+HTeX1xLCbcLGYn2QRnoD079zisO7e8tDIl1vvCZC8tpvDeV2xxx zX87PY+65pPQktJw+q24MM0NttDThOMrjkAnv6fhW85tJb6eFoJJ7CWErEkpAngYAkOccHB7VgTe zC58QyQx21rcLBdysg0+1j2+S8mAQpLqOo9T6d6gEX9lXVuZroLf2TeefKl3SQFs/LkcnGcfhQOc 72I7vVInlnS1Z7qzZA8pJ2MzkfMpHXj1q2Emls7JylxJbGfrH8gJ6gEHngYomkuUyw8r1Zo//9L5 Ia1uLuykaWAxWUyMkdxOnoSOG7/Qe9cnNPFpcml20N3cSyROZHiUbUhQHAAbuO/b8a/mZJLY/RJR tE0tX1iS4sYNLs4IIPLuRdPerH/pMnopOen+Ncvc2Fxdm51GV1u5YCoujI/7yYsThnGcnpg49R60 yZb2NZtP0SK00uXTLdl1AF5dQVTtV3LDZt9gO30qTUo7kpbBIzG8pDbcbml7Yx60EkAeNJit6Ft4 JI8xhehbkYIzxmtJLrcPsyXBjWzQDySx2nPQgHvj0oA//9P4pGoQ213aw3LGWRgXtnkGSSuNwB9t 361LfNKXnuIEjxcuPMGdkqZ/iB79P88V/M5+gEdpcyRW8qTyQzJ9o3HoJEXGMD1qtG9hvu7mG0R3 2lUkli+YejY7mmk3sWoPqYkMUsl2xiumtLhv3iXES/vCwHUqRz26+lbC3M8N08c0kTQtbebNcSJm eaQHuAOM4/X0rWKsrM0irKxi3mvQajfta2dnPbm3tFDXAQiGZxwxz0BPWo4JbyDTRazzmWeQFROZ WAhyeCB1zzVCklbU/9T4gZbew1Cz+zma7e78tYSrEyuSilgF/wB7I/CsHV2iM8960V1st53EcCW8 jTeZnayhAMt+AI69q/nBRb2P0JqxpRTXmopbxkzQQW8RciY+Up44Taec+1Qq8Ol3AiuPLkE6iQxC QcKT1IHI78HFOS2JsXr2xgs2g+wRwW9rdh5I9L3bzb7/AOIZ5w2cgnmsSCzns53gUlFliKRE8hcn pzWkrq1irWsy7eWl4gggmkWW3Q7Z/LGzzOMZ/CmQGfTYbqO2uDEl3F5UsSfKJB7/AJCqNHJI/9X8 9YLZorRY2En2ZiUYlWYlgfm+uc81Nf6dpqRR28MUCTtDh2h+V5EI6Edu9fzwnZ3P0aMuYc91qFxF bwwR21xaeato9q0Ya+gK4wyORnaf7o96oX6XFvczSvcRosKC3it72RV8rr0U4J6nPp7Vc29im7Ie kcsVvcRRR27z3MflKZ2PyZP8P+TUFzA1oV0qFHtbuGIPNcEYJyeOvA4HT3qbe6YN3ZoRavbWGopJ eWserWzWS2jrcRb2hJA3suOhBAAI9KzZNHu7m4SQmJWI/cQSyeUoQ8qCx4HGPzqQi7O5/9b89raO 5hEh8iHzbc4uGYgxrzg4PQ+3rWNO1vqUl2JLeaKa3KmN4zsWPP8AEPbtX89wT3P0e6tct/ZbuS2j jWZJUB+fzxvlb3L9aNQa3s4vJVbZJIxvnvIyTI4x90nOMD2rQSkmchLqdlJc4tLa4uIigJuHtzD5 rdwnc49asz28MDGXz50meICOJlwoz94VUVqh3Qlu1xFZzpvEjuS0CvnGe3NV4rK8BP8Aa3lQyEh0 MMolQg8jPp9K6YbkOfY//9f8wJrbyQ08t6jHaFtVb7irjp9SRWGkkMl388bLIOpH3F+v1wK/Dz72 b0sa1u80swl0+xjee2DNK91j7O6jgt9MHH4Viao6yneyqkqSf6lCTEuewzz+dPVJoiclyBGUtURp IyskibzGTlqmF/b7ok09vtexw8zzL5ZRjtLLjnhecZ60oRftDZX5bluGW51bVzvMT3LYUBUCIqgY AIH0/Q0l9D/ZupXqR7zbhgziJjIN2MHB9OOK1cNS46RbP//Q/KO3tNKu0kVNNthqM8gkF3MW+0Nt +6NpO0flmqUt6LS7Cyr9turZQwhkJ8tl6AD24I4r8YhHoj9CvZoV9VkvJoStpFYyygvPFHyowP4T 6f4VFI5sJY2h3zyXEm0nG9ifTFVGN3qEpGPd6rI2uLpd5ZSx+WjFZ1HBJGVAxxjPerX+nQTOLe6E CyR7ZOMyMpz/APXqoJrc55yRhSpdefEjEriXBk83ahx3/HpXTPPd3ssdm7AhIRwX+Q8dq0je+hlz o//R/H+9tYbHTrjyYwbknEu1NzCMg5x+Q6VkwW+7T7fDBbaSPjP+vRh1DDr+dfkTUua59jzPXUt2 lk0MF1cRSCdLeEukedjzE8AbfqabaaxqiQW0N4LWzhmnkP2Wxzv8vH3ZWOT17+1Oadwu3oZssaJq qW7Qw3FvcW5ud6yrIkTZAVWx0PU4NWn1xoNQXSjfvAUKu9skW+OWM5yQ3Tit4J3M5ytoiveS6dNq U0kDrdeTblWa5g2oDg8YJP4H3Fccl5DeQQxXYS1tbV2VXh/fFkJyxA49xj2969Gmck5Kx//S/nw+ MuieGk8Hwav4d8Uabf3891FC9lc28lpe25IJK+SSdwwDuYcDAwTmvgbxVZTPbX8Kt5kltCbqXY+1 FCkZ2jpivhaeiPUqPufNLanPK93boxto5nK70OXb2NdVBb+XFEI1BiVBmQjlj3bH+FdsN7HDJpaM nsAVvohEdu6TbGehBr2We18vTVtWlRNTvV2RocOMBcl1OeSevHYVqc7dpJGU4lsYJ7W4i8yCWAQz TnGxwfvDHY8dfevob4RR+TJN5UEhxFF9nmUbYgoBwgI+9gZ+m4Vz4hXikVBqzP/T/ki8Rya1rVpF ZwPZ/aLHdZx36zlv3YJ2kD+8OmOnvXM3ur6zpUFzAbR9eu7WxEbRXEDQxuoGCUYcEnHQetfGt3tf uXTTTnbb/gnQm+vNZ0zSre005dEt4LETyWsO6SaSVl+bdu6Y9q8W8U/8JBN4hEt/cpeWNusUUyvI EjjWMfLz3CggcHrmuuiuWpY1V3Tjc4ZZYLy9msWmmjgSRpS8KjbMxPUE9RVO8EllceXEWkJwA54O 3jnH9K9DZhJXVj1nTL7T9UtZtJtnaVRbokpmt/JuXG0ZOOeM55BrttOiW2jgt1chsiNZZ257AZJr qhuTJXR//9T+OHWFmUNbSM6XyXJ8zy4wbWROduHz16ZxVzTdAnFrNd293ZLfwwea1vdssYX5uSvO X4HaufYmcWybU/Ea2skMH2K0up7iMRmCfKwuVxukUryDgf0qiLhJJLK+2xwrFP5sloVZkIGchBnP UCgxGak1jqFzJc6Reaml07BIrWSwEVvLzzkn5s8YAGc0abqc9i2rLqNks89vA0VukUh3xuQRlh+f H8qmVragVdE1q4toLjSxrUqRPGWO+QmSXzesPA464wePlpBpjWmNR+0z+RH/AK6NV3AjPUgDNYS2 YLyP/9X+POSfS7ISXilXtbmNc+RH5sqn/aPr0/M1lNcibUoXiTyY7OTfG5TLkFeAT3PTOK8e3QS2 IdXuGslaSNZbma4kEcCQoWyWPViOmM5ra0CRyGhltJmulBJcqy7QOTgngj6eldAxk1vY2VzfxS25 Fhe2/mOArXA84kM7H+7yOMetVPtszXEEWnWVw9pbWonkuIUbdEN2AT6dqBptbG9FNbpdpKzjOzed yZd27Fqzbu5keZ28uIZwJ0QhWI/2WPQ0CP/W/j10yO2u7mS2kuXinAAQ4HBbpuY8fzp/imKTQ1iM Kw6zfQMm+GCYCKRj23Dt9K88T0RPBe3cWnfb714BHLCXfQ7PLzB+2Gz0PTr9aWXxFfQaYumWujta XMs0ctxcagNrMjAEIp9FHPbORzRsKDbWpK97azWTxRfMiL+8UIEilx1A9vf3qO6u7jUZtOmto4rK QWcTXVtasZFTBxtZsnDYUciucoztRsF1PUr+9ncaddKFd7u1AkEzAAISOzDqT/Oq99qg0/T4LO4f 7bdEEtP5X7whQPmJHAB/pTbuwP/X/jpjuHlje7g86QtEjHzVLR9Bx1/CvQ9KtrS5hiW5uFthjMsq fMEz3x6V4zV1YCtcRwStLp8cZVgweO7wRHKnORn16cHmqt7qNpaxRWN3eDzIlzZxDBVmPbNYuLR0 EFtLqF3cS2jzPBF5CTGNU3RyK2cHP51n2vhy8g1DUNTUXBSBgrtEC6Y6cAdQfx604bkydtTQm1K2 DY0z7Sb+KaNt93ZG2X5WBdVJyG4yMj1re8R+ITfX63EtvDBK0YIiSMIr7VAY4HrjNbAp3P/Q/j+1 F7m7SeWC0jBurfyjLu3GI9eB/nrV/StLvLexi3ESyTBWcRJ8w9vx6145vbU2tQtisEZUYeLnzACW PHTHtUN1cahJZ6Pa3N6ylZvMluwAJFQn5VAxjig5aisW9QulMdwiXZvLmQgLKECOFHGSMcE4zz71 n3+l31rZW15dMn9nXGUiZ7kPKCvJCoDkcnv60W6GRy8bLPePeRRTy25xbSuiMwQAkArj0JznpxW8 fDGpHQYNZGqxXSXd60PmhlPlRrj5Xx32msuTUiadj//R/kdhudMghEFjOtybdioQY8x2A+bAHbji pYLl7y1+228RTywcLMm1Cw7Nx6ivHtbQ8yexFeRJrFyt1Npum2TWuHjnt0dpp2IGchuF6cFa6WNz expZ3EqxxhcCJBw+AeCKLFQeiZnJJaz3VpG9rObhbnyfMlO2GFfuj8QR+VVdWubdLidIIpbpElMS yxgupwcA49DisGrOx0rVG4k9ittHZyRQSXnkRyNaODHIqnBEmOvB7+tZ39jxNKqJc3ZAlN3JEPmi kPICn2Ge1ZShrdGkJdGf/9L+UXT7PT3uJ0+z2ySrF5hlI2SNt569+lVLiP7FM08tzHcQyFXihicf IMkYYjofavmlB9SofEiOa9uSTFFF9nCP5h3N85BA2/pUV1ql9aWym0lNvNOAi3W3hSevHQ8U+SyZ pLSLDS/PF9DcX12LqMRFJLaQDy5mJBDsB06EYHrXR6qE0uxuvECQQzKxCWemW5/djAO5uSSCDjg0 U+pjYxNO1u7uWvLiJZIvthDTW80JjQH7w2gj+VU7ua4uJ7qX7ZcCRIgDADkDjt36D3rQlRSdz//T /lTt/wCzrbR7B7TdJBuxdWk8gWR5Dy5KZ3bTnqP0rBYytqdxLBbpbRRFJIYoAxiIIyeSSeox1r55 u2gGxJDHq2YvMFneQr5yhfuupzxj8KqWSapJFJb6qy3S20pW1B+6FB44pTWhhJWZdmnRYxqUOl2t uscn2W5iilyzEZ2naSTzjNZ2oX9xO9ssyRtbMflxyIsdABimlYdvdOS1qKaXWfNs5HivrRV5tgGt 2jOMg9sHjPvXU2d/LHCtvIh8psl5w2cNxx/Os5L31Y5ZLW/mf//U/lNmguI4lMrwyRzgMqqQGVD0 yPfr+VX44LTTGa3vQk0lzD5csbjcIlcZB9j2rwZR94cdZWLV1quqm0063vtVur3TdPONNtXbfFZo AVSJFPAA/PisDULkJBIyb4zKpR2UcnJpcrvY1krRsc9PC/kxPasl1NH+8ltgTv2+nPc8102oXdxa rHHcRPbLMqPDiM+WN33QP8frSsZpe60ZMMs011LLcztHChzswFRyOrflXR6ZY+HYtdtdevrRNW8N T2rk2NyxaSC4VdoZoxwUzz1Gcd+aGwktj//V/lNbxDDc69Ldr4fsLW2vYxbQxCxEFrCseFXbGehw Acj+8fWqF9cyNq/2kxW9lY7PLdLS1ChZMj59v0B/OvmpLVmLjZ2LGnva3b3Ajt5bqSOQkSBWUNx1 Ap6WkM8Msmn3k1heQSbTFENplU53qWPZuQR79adNuV1c0aUY2KFtprNqttNdQzlXcCfA5RB169P/ ANVaguUDuJljEEM0kcD7v3jqGIVmPTP+FKU3GViUotXNqyjm1axe51W/ilgtLv7Pptlcs0kkCgbl kj7AdPyrldVW6Mv2o6hK8lrKcleFkB4G49eM9KqEnIJJW0P/1v5N2u7GO20y7ttUkurmWGSHUNPM JLRSrJ8siv0IK479c1Ygs4lSa4jnuZLq6H7xn5Jx0GenH0r5vmblZHK/hOkjFykMV7DKd1jb+cyl hHIoxhh79elZltrFjPE4uIJbZ5fv3e3J4zgbfWr5W1e5jzSVlEqzBLdIk3yziRtqO6YaTPPIHAql G6yyTIspLR4xCwyy57j8u9RyX6lvnsac21Akcs5ad0XyoFTkherZ/EU/UHX7FNdxo8RgQBcfM0xH 3gB6/wCFaqDaMnKS0R//1/5XtPnm/wCEdxayuNxaa0gng2uZ2656HqMdTVZotb+wx6hrNldQBiUB kj/u/Lx7V884RTPPhzc6TJRdym0McIGF/ejPXIGB/OoJpX+xp9vmhVXUtvWIGRjzwe+TWLjaTsdk 9Fd9CXS9adLN4zBmFwPs4YNGY9uQTj3961bGRdYktrJRdC8u5RbrBawNNK2SB0APGSOvrVJJWuOm 0pWl1LWt+G9T8O6lZ6Zd2V7pn2yM3Cy3drJEXUHlmBHFM1TT4L+3szFckSxSMjxomS4Xpkn1P/oN aR5VOzR2umrXP//Q/l0s3a3g88TpCsUnk5DAMT9OtYt6SXc2kEc/8M7ysRJuJzuSvE9xs0cYyRDZ 2jWw3TwR3ELkpOZGOVJ5HA69DVyNHkLN5iC3inDx2qD92wUYUMPzoXIYzioqxLrOr6hcxwW16SiK pW3WKEDyvqcc9OKot510GjMss0QQL5Z+QkAemcVM+XoKPLY3rS3ggb7ZcSyafb+VtgzmSO5cAZzx xznp0rPVIrrNtcSNcW7XH2i3YHGDu3BTz0yOKzauZu3Jqf/R/l+0ySCzkvJTIhYL8qSKGwCNpVeO B16/nWBI+mZdceVIZMLOrZCn0P8AL8a+a9mzgZZsYjcRkxYQHLZ/iYDPNI1u8kqxtIhUgly3QjGK lprUIwvrc5aeygtZ0eMmNg2SV5BweAK6S8N0wh+zSzNblFkWZ08recZIYc/59K15UkZ+zvexFFBc XKGOODz5gSdsOWY8ZOPXpS20V+IiyR/Z76NvKKz8Eqew/Orpxjy2a0KhT/mVz//S/lxvZjpEUMzZ e52CK4iQb94IwxB/E0D7Df2T+UpSxmTbGoBRX55Jx05Ga+ckkomcYxiloWLeSziRE2+ZOnMWxfk4 xnJ/Gpr2X7TMMjeLkBXhKfKT0xj3rhUk9LG1rRRREKWd/wCXJCptfJCqI0I8tyM/MAOMce1JfXLS rDb2ky26wz+bJIVO+UEY2fT/ABNaOz1RTkuxo6dJPBJ5jyqV6gk4bPc5qq7TtqV1eefukd+qsW+T AOD9Tk/jUGnOm9uh/9P+Wy5Dav58cUzwTwH9xIRhA3QnHce1RWAvoICmrokkqy7IZQhkAx/ED2z6 e9fIpPlujSpPSy7l+7jtjLbyxhiqqA4OCSccn88/pV9La1uyolSZ4V5dY38uQ+2e1XC9zamlJ6lO 80+zhtmdG/eeZvFjcvn5B6sP88UyaHTbfVdJv/tirPCqzeVbN+9XOQV59P5jrXVCFkecnsaNzHfa jq7mGJnhvNzFywRkxyMnpzzUCWV5dW4vrV3toNNlaKcSMrLdY+XBz07EYpjb965//9T+XDU4VvJY /NjZA6qAisflx3/GoYo5ZZhZK80ixELtn+SBQenznjHua+dUUjBu7uWZLpJ3EN3FaGW3HljySHVc E8g9z71Cml281wirLIk0063Kx5wJQmODnPHArJqzsaU9rG19oaGaZNSto47NRiJbeQu7duQRx2qQ 2cyLv06SCRz80bXE4iVQecE47dKyafOWLaahepbSh1Erb8OB0gI9D3FUpElv4ZC0ihXwcqoQrjp+ NaAf/9X+ZGzWYWNwkk8cVvCpaR2kBdwOVG08kk+lZ0UptfIuSmROofynbbgHpn0r5mPUtfw0izZX 0t3NJOkcJgiP7yCaYI0gzjcBnJ9eP0rLae8u767gtsJHDEJPNEgVmBOCAvsakSdk0aCJq40yOGeR pbcXJImWTlD1AYf41VTz715LO2RUmjjx5rn5SeckDPP4elFugnboJfX8+kT2tvEhuM4aXzUxHjow 9KjM8ssjPEvkxk7zk5Vhjt+dYuLQj//W/lze0QTQzvbJc2+/MscgJQ/UflWqLQSsJYYgpQbYol+6 vooH6V8rBWRtG1rIy5Jr+5eWIiAKWA2KNhAUc57dqnjuLq5R1gnydvlCXIYIV+UZ9hjGPaqFN6WL e5p41SVFeRE2yHbjcehpPNcxtEjqpiGAp6R+lbRkmZptbDY0uknBtmjaQnJkYfJj+I4+lOvNSubc 3FiSHS5VSiBMlShzuB9eaHJJ2Kk1ZH//1/5jYprTT7Kyu2uTcXl1K/mxDl4gDgFvTPNLPckg3KEg OeMDOK+ak09gM7Ub83CQxzxLKN33zjMeO9TWqkxglTsBIDHv71AGfJAllcNewyuZJ1MbQowKPjvj rnqKuR6hHDEiSpkXDFI8dQwBJz6cZo2AoRpHetIY2ZSpOWk+ULt9PyqnZTyyzbIyyiGUpKCMEgcf l3oA/9D+ZK7nmNxb6bYXh2on2s7o2WCY7Tjr3BGMDnpW7qMhvdKgt3EMdyiAOyjJZh1/ma+Qe4HL TQx29sspDI8TYGc7m/z/AFrPgnEsonyVGNjqowx96QE0sH2mdTG21CeWbgcUhkcsod2WNDjI/joA hvcTqotBcW8SybgMb5R68Y7/AEp+o2c8J0xrGYyEOsl00g8tmJBDD8M/TiqSujWMr6M//9H+Yy+j 8hCkn2eWSMja0brIucdQR169qhtJbaNIRCEG852xpgA+/FfLrRWOgszvNPcyQIGQqv8ApDOSkhOO FA+mawftM1vB9mdVWO3dmWMnkg8devQCgCCK8u3tEitlt7QpIbhUUgtMucFST/Dx29a1njilt4Zb kKksoziNuF7dvpQA25vre2tI7ONlhlXCyTTMWe7ZjhRnpnGKqT6ZHFbJfI6cArMp5IJ/iNTL4SJ3 3R//0v5eILFY4nY/viYchpAFySOcD/PSoba8mhtJbW2mcRTE/aI5BlCeRwD0r5c1g20XdPvltrK4 sZ7dpJZVzFOq85z39O9Lp8UEU58xWcNzIZDuBHp9KCzoNRuAYl+wWENvbBNryxqdpPuTmuE1KZvM MMYZnxukmDAx/QfSkklojeLujq/DdoZII7c3Qdi25mk5EYPb14rQ1JfsVy0QhGxwENyj7gCO+Kjk beuwz//T/mEOoRmee1Sd5BEBhpF8pmOMnj/CprW6l2SFmAjT5cetfIyi0dspW0Hw3n2mSSOBZWaD G9mQhBnsD/hWlPqU9zaPbwQ28Msf3pI0/fSjHOeenWspRb2M02nc47N99p2RQhiF3MCfvd+T6Vsz NHuhlZUMskRBWPO2E55H8jVJWVgbbH2YmhDSxtvYEkIRtx+P4VJ/aEsivC6Mgf72wZVCOxNME7O5 /9T+Yi+mh07Sbi9uZUMERCmPfmbJ4yF645HPvRaW9ybFJgn7u6hWYRtlOGGRkEA5GehFfFuOjZ6c Nya2tp2BeLYzq2CsjgbAvJwOvStyC8t4o7qGa2Rp/laN3j4jxnO0+/H5URj1ZqQXZW5ggMm0JE/m YV8ZYcCsO+eZzDFIPtDEbo0K54B6UnC2wuptpDBebI7naqptYwqflUjBH6irFxcJb3ltDCqfP91G TcnHfB4pKLYz/9X+aO8tJW8ya7umnNxIcqRgQL2Gep7/AJVNpcAS31S2e/dbK6hCSQPcLGh9075G M96+K5Hc9C1tBbe9to0jhjeSWK1jADOD84AHOe/4VQukttWP2i0CzJGweNJDhQw/D1ocGtiZNpaG sscyxA3A8oOvKx5x+FFtEgRQpkaKR8/McYzUWtoUX7q2Fony7pBIch8HGKo27yxXm2GEyM8WW3Id qqDjO7pnnpUygnsB/9b+dC1lkSQqykuF3FVHJA64qxA8bTi4O903DepP7wDjjmvhYKyPQK91dO7z 3Bs4UfO2CVjuZlxwT6f/AFqkjvJFsSvmg3O3IAOcg9jVGsL6iW5n+wNcXG0SxtgoG+cAk4461Snu rhi0VraLL5se3zWk2FGz6elZNe+RL4iRLh7WKK3Mm6WFd1wAMKCfQ96jstTt7y4ntsMRG4VnC5GT ycUNWnZEn//X/nmWzlFt5MOIt0nzTFeQPpVcxR2kjrcXLS4+8wwxH0r4Oa6noEYmt3ZZImYpnALL tcgeorXjmsZkZljw8ZxknnHeswKtveWUN2t0yfaYZowvkM22N17VpQeY0EtxBDbwwxsQsXmork9h jrz+NOLS3AkkuJWibciRJ5YZsNudj3z+Y6elZMgSSC4ERxc+SWgJIChu2a0jJbWKjJxP/9D+eu2k le1VbnLTog3FOjHHOPyq0QwWMtGVXIZD3yOhr4ZuyPVU09zTtIzJCLh7iSK6W4INqUMaugBw2ehF aE8kMtlwsUQikJkOQGkJ74/z1qZSXKTzu+piwFizyxyuEkXaVRiAynnH06flVq2uo1lijmBKqSAw GSvWsjVa7G5O4FqixRRcDCA/Jx6niqaXcrJBbTThnU/Kc4VT7UmtLCk7LQ//0fw0t5VLLuBREGCx OS59RVu71KNEkbyhPPFHhCSN7ZOBX5y4tHrxd1czdMubtbuWS/s7fynO2CIlm+Vlwd3T14qtqFpA mqlbQuYnRWSLaFWE45A9s55PpUjJruQw2kjXiYWMcbRu4HqBVHTl8+Jpo5Atvt3q0j4Z89NoPJoM ZfEy9b3n2iQIZGjS3YxsrR4WTjrz9eopLmSWSZoI4z9mVQ6t2B5z/KghtJH/0vwjDJmOEQqYgcDb 8oX61pWdrDFIboOEj3bGZnwinuK/Nzqk7suT3MdrITIyskrAIWOT26f570+WyiS3luY5G+dg4jJy BxjApNX0YJXuivD/AKUVheb7KrcNMV3+X+FXoVgk+XbswdgdsKW7ZNYWtoOnuVIJpIrx7fyg0bqQ ZBy64OQR9eaddXkkSlWi+XdtXcOeO9Bqf//T/D20ukmaWECRnEeDEFwm7GVOcY9KvaVdNpyG61WG WOJ8oREm8qMnk4+lfl568Vy6FW8lu/PZtPmXyblTGzSR4k2nk7euDSPcyQLErwqWhGBKBhpvUtQM ltJy0b3E7HJbEaqudv4f56Veup5BDGitvJXLNjmgmSVmZ9vaiTdcMo3qMKuetMubue2VHjUvMr/L htmPamnZ3CLuj//U/EyGeJpTPsCuyjzi38XrxVy3l3yvHDh4biQAxyAGMY7kf561+ZpuzPUn2Kuo W5sp7eOGNMNITK7HAQeid+v8qbc+YLqMRQlZJEUyOo5YL0GPzqEm1oRdoguXkwzW1uHeWQKzsSCv qav2yy3SJDNET5fBwOeKfLI2jK70HXVjJasrxNjcM7epx6e3Srgu9TFmjveyhrh8G2bhl4xn3z70 rNbhKTtqf//V/FeTKSKSBHKR82flz6Gtqe0M9qs9xu2mLERiO4MRjvmvy+x6sJPmuY8etGwtL/Sk gjkXUFRfMfJki2nPy+mc1US0AcKGKrGP3is3zD6D+lO1nqY1nrY17ays7q13Mof95nDJhhjBGM1n 3t5a20piSFw0PUunDfRay+z/AF5nXF/u7Fi1uLm4Zd4cQhcoWG0IPYVegnFhMId/nRSHzB5jZaQk /p9KjpYclZn/1vxq1jVoXks4ILWUTO58yZYiUiXtlulZ/wBvae5a2tFBeIrIwdCIM9stjHUeueK/ KFuj2JrRI2IdSt555lmKG6hHluWG4A47ZrHuDpckNut7YxtPHOzb29G44/WuinrNmdSN4mlp0cGm zRLbI0aM2+GGQ4Zu/wDn610d69lBpU+qNPF9qjnCGyUMbl93QqMYx+NIuKsrHKPN548+OMrI5Ak4 +bAHGatNCRafabdvLljb94gA/eezexpNX0FLRXP/1/xUayu7m/8ANa4SC0iVXMEfLTnPIJ9B7V01 zfRW4RE8pSsYxGjAkZH1r8in8SR7EVeN7lWzCpI8kixXCuN6q55T8RyMVpwWUcjfbA/mB2MDQAZ2 9OTULW/ka8ltjMv7KCS4kspPOETLguBggEc4q6ot7S4tYoE2wwKESNc4wMDpRa2gkn0Zom5C3gRA MMPMYN8qMM8jPrUeoiWW8WGxRtzKGAX+KlZPc1pK25//0Px+i02+tf3WpPJFeCXc5V/nj5yBn0rQ aS3id9kYhupFCl4ssJMDGc/rX49yrsfUdbGtp94y288MhLzTfu5TLypQFSChPQ5Haob/AHCQTQ3f noluEREGRHjJKk+35VUrPoJTakzPD29/9maZF+0RHdsfhWx64p/2a/uoZPsv2SB9PAupEnulikmU MAUiB+8epwPSo5FqbxndXRetNTdziaMMqMBImdpxnnB/Or39oTnUsIFTT1UeVFtOXA+8JfY8VlUj bRDnK8Ln/9H8sZbqOdJjHHHaqpIjjiG6OLHRRk5wKzYReP5Yci2nbEsbZBGM5B9OcdDX4k4LmsfS uVrXOpnnS7hTUGuRc3UR2hVAMR2ccnpnIxiqUOpTLHOl3O8bXCFN+c7M9vpSdJ3szD2jvZGBepC8 sH2G7eOSL7yxscT8YJYGrcEEjWvkKztN5gldxx90ggfTIrGVJ3LcndI6Gw1yGdnhkhktC0gtt0sR EZwMFw3PGcnj1q/eCaztLX7LcmfzXKq207crx1/KqjT09Bwcr2P/0vzRvJWma1j3M8zDbNtjwkXJ 755GP51JDDa2hRkZ2ujkSRFQsY54KkHJzX4NKm7s+sjPTUhN1NfXsovIpMudjKVLIw9BVuxvbS/n nFmptvs0n2d4jlCCgwD+PXPvWfKozBTiT3V5NahZVkjfD4ILjd+IzmsyO9kvZXkZ8pM53BvkaMjA KgY6Hk5/yJltaxpT5Gxl9AZbyDN1PBCi8NE5Cr6/X8a2UswokW2m/tFbb5vNb5Wc9cfriueaTlY2 fI46H//T/PbTbiS4uoorlfsWECrHIn7lBn7xfnp9e9XLgT3M8oeS3nSE+Xbm3t1gLKOm/H3j7nmv 50jBn191sWtBR5XuRd5jiQt5aSjOSvYAeuK5rxL4gl027+zppqvJelYVufM+SBRy349MfjWij1Bt JFrT9UkhSCJNxZgWWRGwI84zz6nP6Ve1HTReQQC7uGgTzfMV1YGW5K8+X9Dxn2quTR3HTadmUykJ t4Jp2WJ2ZRFC2AYyBwPr/hW5b3ggjjPmqkob7zDKqOlVZcrRsmrXP//U/PfUbd5LdsSpcQrOHlWO UrIOcqSBzg8VVt7ScPDBHKgtZVM4aN8yIcn92wPbrX88tq1kfewStc6+7hSO0tzHvjv5FUMkiYRV GOc9TkdKxNSmaL7DG1wBeHKI0a7DJk/cP4DH41k2mvdQVIqMrM2zp17ELC7KRSvcfvIEtsyeWR/D 67hnpWVqcsV3E0rITfI5DSsdki+350klzWM7e6pIytLMzR3oea2jdcGKNn/fSDnOPf8Ap610lvqk dtB5MrEfN8smfljJ4/wqpw7eRy0KrlOVPt+v9M//1fiG8v72y0j7KL66njjn+0RW6yGaNd5+bjOO 9ZUIlEMl08bTRyOsRbbnaSe35V/Nrij9ClK9ky1dgw2jTRq7bELkAcnAzgflWFoNw88jvJbOkt6m 0eb98YOVBGcc/wBalQbSSIrTUNTr4pY7J47ieKNJEGWiYZXI45rm7jVLltRNwqCC2yWjnEp8xWGO 2OB6c8YrRU+dWQr3hzr1NJ9QgdI7ya1kuo4p1ikkWPIhY9GPt9Kvs0JN5dyxo0s8IVWj+VY8cqQB xx/WplRcNyKdVVJNJbH/1vz/ANJvHvJ2i1SZbcWpeS3kkAKKDxsDDscZ59a6K/vpI4pRbJBfzKoU lpGijQED5sgZ9O3ev5qcOx+hW2MTc32dhgrITljkkZ9vamm/uLMWkUdxcl2bBuUhVSwHVehA6/pV RjYuMnZ3GR3Us2o3koUCS1gEzvIFj3fh7+grTk1GKUTX00UAlkQK8ca4VsgjKj25P41ZZj2FzeJp 97bx2SSJ/aJuzflN0qqy7VjJ7KDng9629FfTpxdWmr2sMbyopttQkDsIjk8AD6c8HqKpr3UZSl2P /9f4Vh1TU7ARWVxLbSW1vI7W0sUCifBbghyNw6Dg1V1LVYkeacXMswQq0cpxHIjnGSB65r+c4aJs /QJS01NYyLdQwMyic7N8mG3iUHn5v1rj7y5ju7u5ljszFLFIIVwDyFAwMn6n8qIVIyfKuhEajb5G PttV/s68Ooala/a5VQRW6BGlYDGMEDJAHPSr0V49/cKyRyNNJJ5cWV4iz0A9KrmV+UaqpydNdP8A Is2+oXbyvpmqSG3Ns5a3uPKDCXHXzRgYyeO/HSqt3aajeXs85ktrfTrO2WaSSH940rk4AwOg6Zx0 zVGkuh//0PghdWXUNPlhje6Wa3w0CRx5s4vU4Pr6j8+c1iRThLm9unAuisUb/OpjEB6MSx6/59a/ nc/QofEjTZrS9mabSLudYIiBMxXbLG2AWA/HofSufmg0RLqSa5W6kurm5CrcXkpltoCT94g5646+ 9Ntvcqb6E1xPAZETzWMIl8lJY1JLMM4Knt0zmlu9VD3cQu33xtAI3lPM7MBhSf0ra142MzE1C5ZG Q2gG1AXLkEcnp9cYqJL3V9UTddO4KLscFtvnALjj61jyu9iVGzuf/9H80dPhura2nlkuZxayfLBb MNwiZM/MT1IOeKbNeQ/YlaKKZb9nKvcZ/dOAPlXH+Nfz8lZWP0Cw3TtQ1Syt3lvDbtalsSKpDzRE nC+4HsBSpLFetPLv82BjsPy4A9uaqz2Gk2rkFvcCO5hEksdpDC4CMyFgoz2A/Orc+r2l+sxljnlW A+Qs7ph0C/x4z09s962iuVWFYytN1JJhIJYmhZZmhXK7yUH8Y/OufjubxzeLGhkt4vNuWuJ22E7c naF69Aa1hHqB/9L8nEZ7/RoZ5pgUuws9uI3BZCOQD3H0rej0u6ubMXUclnZ2cVo8t3Pd3IjMzRjI QD1PIA71+Hn3BhWd5cXupiDI02GCHbCxbdHMVXrtH94jjPrV+a90eO1Q6vHOl7Jc+Ra7LYtHNJ0j JP8ADzzzxWrjuRU+B2CVZGDROkfnQOUCqAXJzzk/gBWDeXjWV7YKLbb5uTcRrw0gUjn+la04Ln0O 5R9xJCX91dadqclzoM6JJdxKsgmLJGoP3wcc5xkYrcttRRg4ZA3HzAcBj6Vo4LmuxPS8T//T/Icb 7nVFY4jfdw8bEhATzz/npWpdMiXc3mJER5QiNxjaY1H+T19a/H1HTQ/QDNufC17PHbX0HiSAFD5i KjDzUQk5Qxnrweoq3c3Nva+Y1rKZpYIAZRs3EhsjIX168UGc3pYz49VmsA88cCtcNH5bRFBKzK3B 4I4OPT86zf7dha6Ects7tdZQqkZGzA70GE9rGebm3kln3KJgD5Yincps6ZK49OvpVy01Ozs7iW/u i8kkVv8AZ0gT5lYA5BIHfjqKqDSepi3ZH//U/GX+1TcmSSQTGFmLN5fA/wB0Z/8Ar1iQTXn2iZJI nEbNvUpx8hJwACeoGK/J7o+pSbOksb+FbiWHJ87yfKCyR4UKeQc9MnFUtQlNs0kjxxyrIhRSSdoO P6UF3agcnBe2lk7hkaBj+9XYMI5zz+NdJDrGl6zpE2sWMggnicWssD27RXD7RtJBI7n+ddFJbGE3 0CxmsjYXLXbjzWhYeTEN07kjiuBk0/7LZSTMwW3gHlxQuPKYdSWbPbj9a74R6HJJ3dj/1f5iPixd 3WnoRbGzZ9qXLzgGbiQArEo7EZGc9MV8ga9e35lni8+dxeLtfy+I4u5DH06ceor4dabHfUe545cW pF3Ifs4jgDfeXo+Dyfb6Vo3GpvHZqsO2JEcBcEAnHYn3rqi7M4pO7Nbwy41nVo7TWhPpFhcs0Ut7 DCTBAFTIYEEfeOBx616poNxJC8MNzHCtvAmyyKsZZgFyBuPbjp7Vo5JOxzy+JmnrXiM2sX2K3gEs F2RGyCEF5Wz/AHj0xx+dfVPwDs/EE8N3E0NlM8FtFKywwiX7JA3y5b6naCV7msK71saU9mf/1v5g 9c0LRU0/R3sktYZrrS4Z5ZbKLYbg9TvB7noSK4O7EtqZHS/nsEkmjEseFFu0aH5wT1+YZ656/hXx k0udJF2cKkomc2b0XqaTNHPHCHl89H8tdi/eAI7kdvU183+Nbq9jedfmktlPzxwwkzIMfxjrjI6/ Su2l/ERt0RyXhyzS5Et/OQYYzut3Y4SM8g5+mO9bDy6dcyERyyKCCiSCPcxI+8fYdcGu5LoD2R0s cUFhNaXNheGVzbpGt8lsV8jPVSense1drdwC+jMV5fSaaTHhJljMmHI+XI64PcjJ5roEf//X/jQi t7yawdpbgvHA3khl5MpXg7fatTRrsOkkMpzJBFtt2dN5J/uZ+g5rlimlZmk11Mm6t7XU0g1G0N9b aipLalZzurwxAcLHDxkA4LHua3oLIf6PMgZVjjDFd29t3fiiK5VYwcE9ijf3d55tvcyW8mnmKZwZ 43McRQegxwfX6/nm3t3pMdxDd6RAFur9liuJXfzftIQYUufz/T0omvdEob3GX9laSWy3t5a2Vrev ODGdPG55zGwYeZzx7mtiTWra+kht7GOdYZrQLfxDhYJFGWGP4kOM+2Kxt0KUEj//0P4x729j0yG1 gsY1iguHaTAXbF1+Y89ySOtJp1y11cfZkikYzjKuBkqevA715yilsB2kcflwvBGoOU3PJOu/p1AP UH6U3S9VgSQwy3DSSKu6IL86BAcEZ7cnp9auMU9wM3XvEbwypFpqqi3WLO6U4lEqvncOny9B0q3F I81nEIUcLbnbEEby0Gc8MO/U8VpyICldSmLzWnWOLy03u5YKFXoSfQVeh/s6K2U3kiwiVg6OBvIP 8II+tSoLqB//0f45biy1GO8g1HS5InjinR54Z+GlToSPX6VoaZdRrqcVze2cN2kM/mPZ3TMtvOAe eQc/ke1cDtZCurXLMpstZ+3GKwOnoXaOJQWUQnOV8tjzjI/SmRX01+8tpdxSzm0Pkma5UlpcDA2k 9hjFTLZihsZWss8NvaaX9kMDXcLS+bbuXeRScDeM8dCOBRoHn2V4u+RBbeQI3Xcd/XALe3FYFHT6 uYJEu7GEi3EbqTewr8lzkZBDHg4yRge3euesdPgMk0c67pZogsd2XO8YPTb6YzQU1ZJn/9L+RiCx eC38nCkGLazDguO35f0qCz1CNLx7JLGUYYRtdudsAAGSOeTj2ryLNK4W6E9pqEk1tOL22S0NrdNu R2xcGMEiNsZzhhg+2aq3X9la3qNiILCBXQ7YSoeQBgfmdixOCcjjpxSOgGvtYgluwLfbax5iE8mG nlCDAKj044re0RZ59Nj1q51K3t4FiLiCO7AuFfAHMYOee1KyBpPcoJeRPfxXUtvFLHjMMjhllVj/ ABYIzkVja/YL4inS4s7i8XyH8uYREwiREHQd/bj86ZlFa2Z//9P+RCK+totOhgigYPE5S4cg4Zgc Hr6Y61t2D6ja3CahZ3iIhQBEGCIjgjd+Oa8Rv3zoLN4Z4iDKkccrLl1B3bj13fj/AErIFuNYaQ79 gsosJk7YCzcZc9sY4FVHZGFSPQSyhtxJIqAidYwk8rjMcw5Ax9MitGyXTJpUs7iwe8XTCZwjsTHd NJ0UD2w35j0pmKhrqVLzV4dPRl+xG3Rpfs/2aOPYUVj0wKzrY6XdmTRYI0tYNn/INwYIzuJLsoA6 kkk+9BMo2dj/1P5DrDQf7Bb7eLNbOBJyFKfvTOScYyc9vx9q6m51KD7OiR7vIXJjgRQqOx7tgdeM c1455849CtJqmmtb+fp0VxLPbr5VzFcQeQgmHIUNyCOnIqdVuoIo7h1sF1KQq6wC48wIG5AJxnPq KBRVlYxb2S/GvPZahHcIX5maGMC3tio6D1z68/WsGw15bvU3s9LjlbbOyFp4GjQsmVYc9uM1lPc6 Fsjr44LiCQ3EirLdeV5TTMvzMOy5646Vt6fNqemQRapcbJYZXa3JjwggfBxk9+o461BS0Z//1f5S 48MbmN/LhldPnw2Su4dj361l/YVK3TRRylUkVbh5RtAKgYZQeo9xkcV8+VD4kKbGSS5NwytcRldz x5xkKOSe/QfpVPVZbu6k06GawtV0+J82vltuLEdGceuRxyelJ7M1aurFgx2kqmaG3eKaA+VLNINh HH8GRyKhfTjfRouoXksaRyA7rZtjSjsSnQnA5qKfUzUO5rKzJma4kUW6fKs0x2MwUdPwAH0oE0Gp tONPtSWe14m8ooRt/iB/P860LUEj/9b+Re1nu9Pudv2RLjexiEjkkxkH5hxnqRXUCe/upUvkZLIW yC3FrHjaSQfvdyOG7V81N62NpRWrL2lzhFnmlhw0H3yv7yRyc4GPzqxDdhVlkmDwNLko0ybYYs9M n0qk246mDSe5mQWzS3U1srvcS3EJnltoR5iOwxlkAyTgfzrltV1Ka3iFrawPcSGQKse0iVeSCenH 19q0S1sNq6Oj0fRZLtmm/e/Z7WEJePBEXePjI3H8+tZ2pWCaHbXjWJv9ZguV82KG52qkLk5IPHTH HXv7VUornRzzhaLZ/9f+R6G7a+sbK4iF7bXsTs09owzboABtKjqcHd1rfMl/fNBeNHfXEnmYunuo iFK4AVgfyryGtSKT9+5p3Ev2azjMiI0Ty9ANzK30/KqW+5uGWNbZJYjl2LkrIODxt9KVjpkvdZNp lhFJOqKym4LZkRThsdvfippYoJri40+J3+02yeZKLhsfKf4sngdMVk9FK4oLTUovDaBY40nHmk7Z Q3KL75H8vaixvTYSyQSCR7SZfL8vYRFkc5Bx7fpWMnawqy5Ypn//0P5TVSC4vLe7BeQ2riWONBvG R0G3+YpsN40jXnnRfZt85jRbhFZJi2DkDtycCvm4u92KydmUtcfVtO1CyGhSG0tN6PqUbJuE0TD9 4qn2OSD7068W5Iv763QogiDW4PyZAPDHvzkVVOHK2KWqaE1m/v4o7W7sXEhlRY7lXfbyAAQB17Vr 6a9pePC99bI0W3Y8agBWIGFz9TjJ+tS4JyMetguJkgVrMWwtzEzNmEloEwSOG96gnntp9Gu7MQxN fzZMMrk5Xjt+tWoqOxUvdikf/9H+SuwspHgt7dYoFkExjzGckgYxkY4+ldK4t4gkCGSOSKLNy/VU YHnb+nX1r5qMb6mMEnCzK1o7TRPFNdiQTSbRLImBEueFAHWpvsEENts3MsQnV2PdsH3/AJVV3zWJ WGfs+dfZ/wAy6lzNNexJp0kfktMIkkuUGYk6biOcGsWSyvYUmllMfzXTFriNTiQDsD+RxScbJg1o RWdytzcCSSWVYrUbG8pf3pXPO3Pfj9a6lZo7WCJ7a2nnWSUyQyXCZYADIVl9T1xWkW+VamTpJwc+ 3+R//9L+Va6t31ZYr6eb+z/7Ika8NhE/l/bRjGF9CM/d9q56w1rW9RtJnubi5NmGMsVrOcyAc4JH qB2HevnXL3rM4KcXpdF21cIkcLySiTBclxncPRj260yRLu+AhERESsGDL8wIJ4x71nL4md1SNqb9 CeIyWqRW8oaVkfykZxknHc+neuv0O9hg1TTX0y8bRtRj3lb9bjyJYzjllbtjiqeiRj9qNyxrHxH8 XeM9WT+2P39poitpcN3dMJpr9VIKyABQBnueSeK5241G4MxtbiDyo5mDowTy9xORge1KT9819o7W P//T/lJl06xtZ4/tFxMkfnCWXB8yTBPzYB/Hj2qfTLa71WZntrhneBpFtZIV2tJGvQuo4DYHTJ5r 57rYy9o+ayQtraSWkF1NcS6neGW5MjWx2scdCRxkEdAPerlze2lnEsgbyNyGSOKUYkYf7XpT02Cb ukyoTNP5HnLtjljMiT7uV9OPQ/0rUtp4re4RTGrs8ZBypKtgYz+GaaV9EZ30FW2t3sS1zqssttFO Y7eBsMbVWPIT1545z0FZ9shMoNvHILW2bBaTj5RxnjP5UtkZN62P/9T+WcXlu8LmIIwcmORXXDDt gj1rEmt4JkjthBDFBuI3/d3k8YPbtXzzm+VaHkPRl5beaOE2+9olK+UhVthYdMA09vtGn28b3URZ 5RttwW2NIAewrBz05bbG8U0kynYwCR7hL77igSfvOoyeMfjj8q0jfvf3g0m3mL28YCJkkRxk+o7E VpKdo3HFOzaNDTnSCKZo45DJbvsabZtfP+z65pLnU7ZdIuJVijVoWaX7Q6ESBh0BP17VpQlzwaXo Xe0Ln//V/lot7o30EcsrIwdAfMUMrHI5HNNluY44ZIYyfJjP7uFQcDtwK+ak3exjze6i7IgFuqRK Ybh0DQ/ZxvLN1IH6/nVN7y6ae0dtryrLmYSjYydQfxrjatodkEvcvtY1tQupLmFQqtDJKm37QhBd 8H0I9utVrLT4lF213OZnlgDosuAWZTzg/Qn8qd1sS0m+VdLiwXU1wtzKtrEkFum0BnEeQMKCi9TW XG4Waf7OpiknYPI2z92ccc0tdn3L5o3+R//W/l3EkkrSR6fYZuJLcATHJKso5OCe/XFVrXU7m5ub e3luvLFvG7TW7wjyHYDgkkcEkED6ivkYO94hUaTUfMtvJDZyQrKVdrhC3lKrMsQ5GWx05xjPtV22 e5WNpo/KKq/Bjblx6keta0o3ujSlNe0sRTxS3iSSFY1lYEfIOvWsptNlMsGEhacr8u5tr7R1wcZ4 weK7I7NHMl7xPLe3BkSztp2EsVuZXIboM7fw71I8V9b6asC3TN5yltoPIbJ6rUCafNY//9f+Y2w0 43enxyLcZubeQR3Szp5ZCjBLKSf6elZ19fRQSyWttLb3FpcLtWeMfvCynkD8eOPSvnzBqzsZcBhb KCEeaGyHIyT7Vtw65NbidBBDJcrb/Z08yMMYwcEFT26fqaznuaQWlyjNcSyFZZhkuOFHQetaFpbw S6c89oSZdPlEUkDv5cYDYxt7nGfesyyFLloWldN3muvlSRL8iOCcHP0qql4EuJ4IlkdNoIlVMQbi MlQ3cjvQB//Q/l6a8tI2iku40i58ss0h2sc/54rT1CCx1r+zoooIrFVYxXE00jRvIuPvce4z9K+a StFsmGsEzm9On017u9077T9lv4YC8EdzGypcBSRkY7HnmtG1FutnJPtj+2ySeWGVssir1H0JPf0q Cgtby4uXlsFgcSRL5rY/1cq8/Nn/ABrQjNvFKk1nGY504Mm7LB+hx+lAEdxaTSNMb8tNdOu8jBLK gGc47cD9KrxXlvcOtpaWyRG3tlV2UEBiM5OO3Ao2BK+iP//R/l7ithFJe3X2yS5nwkVnbLlbVD1c ke2AOlTTagLRkjfJbZlnQfIDgcV8utTWMbasrW0W6VJlJ5JYqeS+asyIYPLhihhgVm8wGHAZ8k5D en/16AlFvVFWeaZUnhXl87JNh2x4J6bv8KtRWsUMQNxOoLkFnU70xjPX160GaRW/tWJWdLdjjOwM wx07irVrA+osW853uNwWE8A8Ywv06CgR/9L+WovbrLqENwJEvLB1UxRxboZHJG4b+nA54z+Fai3D 3i4WNoxGgypi2Dbjgjsa+XJm7LQzrqKTKbkQKQRuBO7r3FSys0enRxx3EqkkhxgYAPA560FLUoRx ReVgzSO8R3Fx8pGegpB+5hR/mnYZba6E7Ocf1pNXVgNSOG1lks5UnliijI86JcKJyRgqRjpnFXbz 7NYXDx6ahm+1WzNLKy4EDAr8v4g/oadrAf/T/mGstTkQW8c1nE8lrIXtZAP3i7hgrnuParNun2u9 d2kkjWEl5oSp3tkcY/GvkuS8mgEuh5sLHKtE2VIIwRT7SbQZFEEc1sHLeVLcNjFu6jlWI+tVyK1m Jq5iTb7OZ0kuYrlQ58j7Ofk2n0rLurm8WWF7WH7T+8w8W7HljucegpuN1ZETN+7liFsCsxim25Pl gM4PsCP6VHd38U/2ZWynlxLGpjXAlOere/vRGPKXF3R//9T+W14Ei1KzmnWabcSkW1C0cO4c7iOg NbGqXlpEsIiCWXkp8zoPmlY9yfwr5c3jsjMttTfzpXkd5WCDfPISWbsP5VU1JpXeJo4MiUEPuGCQ e/vQMjtrZ47doTDkc+W2zaYgeqqfStOHFm1ukkQKMAmS33DxjH5UAZ2qM9/BNDBEXtfMAuZ1xtiK tlMntkg4rasyspa2UHy5IVWOKT5txA+bk+pqZRuGx//V/lym1Jri8uoo0NrFahI9rAmOZsAEqe3c 1UMd7cXMLWNoJAJFM2x+wPzufw9K+WSsrGsHpY09TmuYmVFklEG4v9lUjyoe2R3rOhuHDswLsANz Uyk9Wixe3OopaWzwwMLWeYxEo5ZEcDPK4/U1Pp8ULwOJUj8wnJbHT2oKTsEt3Npzia1/eMsn76KJ dzBD3AFXry5v4kt2kUr9oUzCOVPMIU9M46fjQWp66n//1v5hxamTTvNa2tnkLl1lKCSUADkZ7D6i ufm88xiQStbJ5mDDExwwH+f1r5Z7M6DWtNXe0tOIUa2dtjFhmZG5wWOf09/yqXOppNE6xAwyyjyx LENsifQ+lYDSu7DdT1CFLdIbWTy74xbEbb88re59/b0qt4fW8OnB766ilubeZvPVTyWY5HFANWdj o0u5CkPkeWGZ9kqv8q46cH/GrEVyA0sTpEHVypdWBV/oenbtQI//1/5h7J7aa9kjmi8+KNhLhlJD YPTPTrUs97q17qM9xBbwQ2MDrHHbGQbGHQe/Y8CvjHszupvQbNBL5s+orJb25jKwtbrcbXkD/wB1 D1wR+GatvNK0G0hWcjDZGWAqzdTVtShAkkiKpZT5T/KmTn2NbUUs9p5UhTnG3cv30zkZoLK7wRwy Ca3iLB5QZAv3myeSfzrorvUdDnaCZLb7PNGi2yJ80hDgBWOcdyM0Af/Q/mhvppJz+7jYxk+W646d gcfhWbY6ZYy3HlXSTSSRqd3nEiIA8gc8V8eepNdTYg8q3lwI4hAF2IOw+grQ/dW63LQRxuZE+THy orA5/wAR+ND0VzMdBdPfOq3WyPyAF2gYVxgc/wCfSpp3AO23AZQeSvIFYy+JgVWkuZJY4SzBV5ZS OD6f5FXvNa1ZklLRtIfKZQpB69PzFSB//9H+cu6WC1ktLmO6vY9RikLqkSYjKbcfMffJGDWUmtxi 68hree2lBxvliZYpvcMRjvXw56BZvbySWPyvLU5HJXqKXT0VYBLuAlLbVJ+/jr0oGm1sW9Sm2bdR uUUb5D5i2seXYgADKjsc/wA6uJCjW/2mLIEi78dMZpcqvcRJb2qXUbyARjaBvZyAWA/nUbWqafZR PZWKi4N80zyq2Q6nGPl9ip/76ocU3cdna5//0v55F1FpLQtdmJZAMtHHwgxyAP0qraxJeRSTMm2Q vuJJwQo4AA/L8q+EnsegWVtoUR5cqNi7VTv3/wAKbZtFFbuUgQyGUs0uSHcY4HXHHP51kBC1rA08 dwzlUzjaD8qc+lbd5pdsYI5I5og0Ey3SqH2yTMOBwOuPf0HpVqN1cCBLizsY2uL43B804ZUUy7QB 2XOM1NZW0F3NvUoA+Fy52AKeRkdqILUD/9P8AtQW2028too0ildl5cMCmB1y39KuC+juraTNorFJ tsbq5+UKO4/z/h8A1Z2Z6Fr7FM3wlkijEREhB+bb8iY7k+9QOqfaRt3O2PLeNSSj59vWkBK15aCZ oIree3KQ7mxGWQkcFR+nBq4s2nSWy2+6Pz9+4T/cnQ+mPSg1g9LEMGqwR3EtlNIryRpvUtwzKDjd +lW2ax1FlltkiMlvySoJVTzz9f8ACgpq6sf/1PwV+0uHSycTiV8MsohbyQAez421dubC4CPPDKFl lAALruT5a/Pz2ErKxfs5IRJtvXYEJgYGVY+tVJpwl2qjf5rfLC+3K/n0FYtWYFgR3dzcyQXIjEfQ jduDetWLmzi+wxWMCrAYJd6zgfOBwAn04/WpMZfEyGPR5UYie8WSPZvh8qLGWOD8x/DtWGb65jee zlgAbfsjnDEHHqB70GM97H//1fwq0y1UQp5juJTKTyPlxnirsly6GWFBtijf9+uz/WcdV9frX5ud Nna5TnjsZ3DRh7q1TD/P8jL0zgdsHNSvqAZcNG2xDhEIyDjof5UGsY23LiXMLW6bU2ysTvyMADt/ n2qlCLs3EpkKLb8BMHDZ78fl+VS4p7AoqOxupPb6UovLravm4txJjcCzZCrWTqBb7RHHM7Ykbccf MsQOCOR9aSgupS0P/9b8ULdBbxRwxKoWU/65hz+J9KrXN5e3GLf7LizE4tvtgcGBxjcWz2Pt6V+Z TSR7BZgsnh8wveNdxlgLWDaFhtVHUA9Tnr/hVm5G+NYyiYT5xuG0H8agChaXDWcxEUKvCimWSQ/M oPcEelMuJmvr23eIwxi6mCytxFBEp/i46dB0oIk9GjTuFtdMMkfnCdidsbJ/q2P+c1n3Ci6iR2AQ oflXGN3fmgUYyTP/1/w8lt/NaNVbZIwwyRHOMdf5VMJHt4sQSEENhiRyuK/M4dT0pfEzYQRahZ5v GXghRzh3PXI/KhdUs4Lkxxu0l0gwUK8KMAiqirKxJMl0yn7SfKK4IKMuRyDVNtVFtdBFAkeYZypG 1B2qi4X5kTyz+XMHlkE8M0YYqvPkv6Zqe2KTndI29F+4x52+mP0oCUr6H//Q/E/UL61m1KOO/Lwx sVtonUZI42rn8hWhNc/ZT9hS53pEflZBlGzjua/NXFJHpQdmZCWKw6nNPNK72wQShoF88bj1FQXN vJHcNcFvPLtuty/+sQ+9Jw0MKsrysbyzzW8MLLE5uR+8kycLn2qbUI7i9kjd4vs175ayRuV/eIcZ Un9DXPLSNj0FG0UmRPPeKq2xczTcGeVkAZyBVC5SW5ulaQBWReijAH0qYLUupF3SR//R/GPciwKg diW4+fohHeorGJ4Zmh89Gt5XAmZV34AP3h9PbFflNlGVj26kfd0L8thbTxy+Sw+0hMttyh9iTVW5 0y1LWX2kGaS3AYKeRuGRmtqWj/rsTU0gjXuxIzpfSqrCGIIkj8iEAAbQewwP0rJS9iumks0UzOzh 5Jcfu4+eAD/QUAtDWtJLazW5E6ANs2AsM4HOSB+VZEN1JN9sgtVaSIYdzImwRKOuD3pxh7zRhVk7 WP/S/FV7pA6W0O57hjjODsQe5xWxBc2dp/o81kl5KV3SOFLXAzxhfpX5RUguZSPSVVx9wlkByY/s ohjIDJIpO9/94dsVoadNNbiXaACi/ug4BDZ6n8P61Hs1FSOqMm9+w3+0rqScyzWsKMg2Eq27zAD9 4+/0owLiY3C/KdvIxjGKbSKj1K4lkYjeMxxvmSQcvgdRitDS5ZNSjuLyK2a2ih+VZZnCSyqCQML1 xWMmrpI0gpWi2f/T/HSe4vFvHWRvMSQ5Vix3D2rW0yLBxcjzSGJRsfMoPb8K/Hz6qH8SQy8lVpGg RlWBHBSTOJT7E1ZguGixJCit8mxo2G5W4xnFKrLkdkiVBOTXUrrFvnEwj2uTloew9wa0vsEV05nD +W6/Ku5vki96E1JaG0FyxsyZYIXRGiXcsZxJMOkrA9fpWk6WzWTMqMk+CkkpfPH8JA7Ec1E1qJ/w z//U/JhIzaQjGTETmR35Lk8ZNXornT1TySfnA3YOcEH3r8WaXN6H0vVI0bm6DCxt9Kgs7VXlBnWI fKiEHJxk98fnXP3NteRyT3VwJJIYzgqqHJA9B1ocnL3hJK700NjRYtPZGSe32XhzN5YUtIU+vQe4 rTljhVzMP3ERHCL8uR6Conf5FNRbsRNJbXCQmZ7hbW3myIYhlyehOPf1qoJLma/KW6S/ZpZdkcUj DEIHf6+tRd7Cikf/1fzGW3u1ScxyhpHBSN8A+We35VdghhgtPPu5PtN8zFJckqenDAdu/wClfhji 273PqVbqclc6tNNepZWcjNOz+WI17sPf8K6VLaS1USx26+aQDeyR8yZ6Akj8vxrOz3CMU5WXn+bR oPZWAtkur6CQkHzjuyC47MP8axnvbS5ti+mt5TBmjSTbjcORn370pUla6ZUXyb7MsI6/Y7PTpGWa ZbUM0oUBm7fMR36cVo2kx05IYY7gIZzgQjgOff6D+dc06Wu5rZrU/9b86bi5vYnFmhibzwGYcF2H XCn64qv4fur+2l1UNHFCt065WfDyLs43Ic8cAcCv54d4Kx9XKld3uXpPEIh1OKziZXikQmSZBkIR jr+dc1cfbPEeotblHgtrQl5bwrwuCNqqvcHu1OF2yZRstDYW1ihsr6ZXVL+JVaGCJSyTgfKT9cAV eRrGW2ik1SO8ae2HmWyWzAMGxgbuvHrSu1pcKd9ENuLb7RDYrF5Uzz3W8Enc8WwknI9eMVYa3dWU lkKA/MSeRj2qeZ8rOiKbeh//1/z0uxdzXHmadZx+V5Q+0xoSFfaANx/Kr1vDHbW+wwATt+8XLHbk 8n9a/nZO+nU+357Ihv8AUr4TfaLuUTRRQLG0Z5aPbnBDfTHFWWnSUW888kLi3xdqjBXLngBfU49P rVRS2SIqVm3cYSbaK71gapNHKGEsdiXKoCOAYsdDSafcWmoRXt20wKKoGZ/3crux7KeT/FyPStOR X8hxnenbsYCwI+vacba3nnFnOJ51ER2zJg5Rexz6Vr2Vzb2jKbq1Pkmcs8Uw5kAY59+2aJr3Ys5c Hriaq9P1P//Q+GfLkMkt/G0X9n7xGiAbguemT+lRSajFJEbKNlVsggKcFuuK/nXkV9T7lP37PcqJ rUhMtv5KlQTCUcdBnG4f0qbR7ZJ7nbAQGkYqiSMEjBGf4j0zjFaUFyxm+vQK0eZqPQy3v5XmaxuV iEwdm3JJvUgHGAelP1G2RoIoEG+O7gOTIu0I2cHn8OopU42ehbdm4j4rXW9KsEtbrUYDYXKhzHb3 CSW5CDo2D1HvzV7TDbeVdi7mby1h3w4O5ZOgI/LPSspJq1MdNL2vMj//0fiO0TS9MS4vbKwtpDMP Lliv5vPWNGwNyKeQw5wR+lZWoTafdWc0U93JYtJhontfluJCpyVTtyPUHpX84ShLofos7rQrX1pc tEk9lej7PFa7pJLsqMqgz8wzgNnjA65+lEOp3DQQxvapcKHDQbABJg8H6Z96mKlezBRly+pqyWn2 m4P2q0gFlc2kiQS3AZZDIFO0Ajg4OOvHqO9cs1vcQ3UMY2LBkxMGU4TPGR+VVytN3G/d97odAUm0 uBgrRlbpNs8btxsOcHA7g4Irm9Wv2sk0+7RFli+2KuGYeWg3YLN7DPQ9c1ooPQlU27n/0vhCS0KX zXtwg/0iKNoreJ99sV5JIOT1zjj0rKlsrdJ7iSNS8LTmZIZjuER7DP4V/PKpNppH6FOm1ZSNBLuC CdhZ77dZYgXiDHYw4DYPoSM4qHWdRhg8m4mls4Gjt1RLSPAec54dsclqyhR5akmjDlca7i+hVsp4 72W5njEccyR+a5LCPA6YTP16DmsqLVP7On2yuYndyY3Y/KvIAxWrpparcbSVRNdTXeVPK+03VzFf yrGS84yscu7v17cflWMNWmyiRfu4XBWV9xUspGMY9KtQS3OrlR//0/zhdpbKG/e3kl8jy/Nk2kgE ZxnA+v61BpN3IljctNbT3P2khNsrBIkGfvYA549a/nqULbH6PZJ3NI38tri1gWKIXrKs7EYjiwOG Y/hVbUJYLhI7eCJX2OYbl2+cyOPTtjpjHrTUNdSJozxcQadC9tM+67L/ALuEDAyTjk9un6U1rKK7 uLRFiMct5Itu8qtuKsehPoP/AK1aGZUm1q2h+22F9aPb29vJ9lhdY1kuLhxjaz+gLHnB4pINRgiR vOwsjpmJVYfKAcc0rWA//9T8xrrULmxW3R7QXkV5GwhjL537gQOnT159Kz9J1potPGjXdmypBM00 VzkuqZwoXPXgCvwOC6n6FfSxn6jdLp9zKZBLLbFAXcREhQehx9ar6ZqDzH9w8gyxBjKlVb0OPatB XaVjbls1vZI2muHQRL80Yxg+/rkc1TurrToZodN06aX96cTM33gepU+ucVpGF1dkuST1H3In0qaA OrxTXH+pONjMOmfXB5FUNXv10+3jYI5u7kMYIYgHZ2A547g5x+NbKF1dGbm+h//V/IvSdOnt7JJ5 YmhH/HwYCPliLdiPbPSr63L3MVyJIZJYIYyyxIRmZxngKfoPzr8UjDTU+2cktDMEsscSXctvJFK3 Igbl09ORVSR9V1ZF+1SeTaRy+YICp8846Ee3FXa2hEnfRHQWWl60Baag89tb2t3GbqymFwJLpwGK lpYsZXkHGeTtrn4rK/e5ee/u5Lu7WUkTHliuTj9K3pq1Sx6adoouSLb3LkRtholOQx2lj6VjXN79 lmhjJkAfKu4U+WuBn5j0FaSXvGcviZ//1vyDtb59P+yS26xSRXMmB5sQlEhIPc/nUuoTq0QmVWkU sUmPRYzX5LFWR95KVtEZ1pFNeRFWxFIrkRfvPkVQxK59OMGmadqc1lNMs9oTLHNt3su6Gb6n0pKG uphOVtEP+02Us73EkREpQyBghAYE/dB/pVGS4jl3vHDtkAJSQ8MvvWRhJ2REs1ilo0zQpcXSrt5X BJ6HB9sVdgW1itprhbKF5dm1y42ylX4bHuOfpQZNt7n/1/xNgae3j2qzzWkcxkw7Z6nnmtyCBbiG 1ujIgupJmT7O7BcAY2knOMfWvyBJ9D6gp60YFt4RBNG8824tFH9+Ig45Pv2rOTVphbva6pbw+e8O yGGUkIGwAHyO5Hf3rZbah5FFbKG9t7qGBrRr2GMOqyShWQ9gvP8AkCrEHnWkT2riHY6gyNsGQcdA a7KTsZTWpl6k1vpMMeq23n+cjAymAkn0BAHpVS71MajaSx6k7yZtWdNyDc+ASi4xzzgc16VO1jil 8LP/0P5Z/itrEWnxAzgRtdSfZoiRuYEjn5e4xxntXyN4hubhzdW1g5WF4f3jv8j4PJAb2OcY5r4i O6OyaPN7S6ZrMRyN5qwyMpZnG8H6dazJbO5vm8ljstZBvZQ3zBc4rc4pJpNHosM4uIobC3ubpLVZ o1VXj2GIJgE+mcZFehGMW8sX2Vvl+yjfvwyMcnoee2PStJJtowIZpbcxww6lMZbdrrcqbCSGbAx8 vP8ACK+yfg5pFvrQuUMb6fC9tFFb3nmSW10k0OSECtjdG4JyR0I4PUHGuveNYxa3P//R/lONxqeo Xdvf2+sRDSINP+zafJABktuxlTjjC+vqaqalrWmIdPs4oodTvbK9YXUtxG1xDfptHyYGFGGHXnIJ HFfE3tVa8zrlH3pSRFc6/ptrZ3Jt9ONvqV1+4txpsITTbZSMHeg5Hp+NfPniHVp3/tKSwtltdUlj Nqwu3FspIIDNluqsoP8A31XdQd6n3GsopRPPdNkyq2V/LbKZpCJordt9s2T0yP8APNdbYJZ6Vc3c cNtbzQeQEw6eYY1J6qO3TrXpxXvWMpfCkdf4X15bjSptP0+wkvLeS+8qS1WxHnRksByxGVXoSc4x XXX0Wmw2ssWtXEqTWw8wtalZIgc/u1JB6A4B+lbR30FurH//0v40bn7ZJb2k2m3LC0+1hZpYQWaE Nw2V7E8fhWzDpF7pr2tuvkWzPOZriW5dlfYw3BgPy4rli7tm07WZDe6pvi32Wmxqok2TTu5jaboC w/U4NRwNe2Wox6lZ3AtBbQAiC2y7TPwQzZz0x0Hqaox2Kct5darBc3FxbXdy6zF9khGbjcfmIB+v fFWrCGymvvsY04S3Uy+VZgNtWJ2IAJA/zzUyWlhJp7Ghf6PDY3ZstR2rLAu6aDdtdAw4z3FZlisC xyw6U32ibczyzFgAsR4KKRWIz//T/ji1Lw1b31tYxmXzJ7i4xcRSw7rWGIAFSW9c547YrL1bRrq3 ihGnTwie1K2mneQ/kq7FsMxGOQACce/4V54Gt5N/Ezag+utHKY1sJ9LjjCw3AI+8oxwfXnnH52J5 bWa3jFraRWEkMP2adkO17h8t+8Yduo6elNOwHP6U9mYlmvJrWKW2vwJY5QMcH5XIPUGuhvbsrIZt geF5CziIbFz1B2jt/hWimrahYvW8dhqtncteWRaaeH7O3nZA2E5xt9+31qq+kyTXqRG0kWCKBSSq Hyiq8DP+19aSlZA1bRn/1P5AdYkW28oCNl+z2i2lsFbYFBwST69z681nLlwY4WDSR4VmPy8mvPIs 0mjWtr2xD2Fhqd0bWG7nNrDcyIRawSnlSzDgdua072IaKZwZIbp8+QssO24R93I29RzjqOaPIqKt GzOfIuri8JjtTb6pbACKV1MYcNkCMN7jOR2zVfVormwvPJnis4QsRiuXjcSzK5wQnpj1B71nKPYp K+iLzyNe2tskjx+TbDLKqYYAe3r7+1amlx2t7bXRlt4kYpthmcFcYOevbvUuNlc1cbqzP//V/kZ1 m6utJtUW6hV/3Ydvsbi64OMHcOnrVqBoIovtd4kstvdQhIjKnlMSfusD2bOPyry5fAjSMVzehz01 vJe3ciwwkTOggDzfKJVQbvvegzTfl0yCS5R2hljIb5AZFGDzz1rJuyNC/a6ldzRXrfZXvILW189W kBELlsgKD9cfnUtnBp39jSzXwFhMZU8mJFLJFznPb2qYO9wHXc1ssM9zCwubSHCJLCu4y9un1Bpd NvYNNMl+krxxyQBDBIPkB5ycHuelU3ZEXVz/1v5H7qO1m0W9u5ZUXULe6BmgZhDGYXBO7GM54Pt+ tUlvLOaB5LISeQEVYYmlDs5AGQGGB16fSvBjrI6B0U1wZHSIrJIAHMUhLOuemBVmO7ujcSQzBbOB iHlhUbFlZfUdc8n6VsZT3sOtrm2i1X7PKwENwC0CoNztgZ2/XIP5Uus2lxf2d7Z2EV5AZkKGaNCj Rnrnd/hQQLa+HNQ03StNhnxdefHuSUtkowJyrE/xccDryKZYppqw3E51Qw6izELZtal7kgEYYvyB nnr6UEte7Y//1/5Iy95AyxSiae2kbePMfdsJHUj/AD1p0kMTp5UWRn5nK5UgnrXk8rtc5JrQcLe7 ito5IJIksbeUeesx8y4kUDqB9e5zVbXrS3urS2mtZZkd4Bc3csRZLnGTmNfQjAOeozUmcVd2Ne3m hk057zT0kuNQjOZYZJA88fAB2n3AJxVa1to4U/tOCFRaygl53HllXHVSp5B/wqJRu9DcWPVzMmfs 6mLaSHVsuG7DGOnXmqyouoQtBqkLmxFyJ1Fu5ViyHKg/QipUJID/0P5GrnVp7S8EX2R5IZZUgs5B mSa6dh93AHFdXZ61qOnZtb7SCJJlaNxJGWa39CfT8a+ftbQqHxGLqmpPugWDbbyTMUCtnbLjk4Pb A/lUujPqpuEmEdtJFbkBAyeY5b0Cnik1pY2L9yGeYxyoyqXy+1doQ/T+lXFsSyRgyQyeW5lQOwjk C4+vPTpUU0QlozDurc6k7xPKr2R/dlFfDJ1yR+Va8Vw1jbGGxuDbzQWxsoQBv2xupU/ln9a0Kje2 p//R/lG03Rwmj3c88iTNbzGWSQHErFsk7R3FVHjQmOSJZGdcOBzz7GvmZfEzdtLRl2y1L7NqltM8 EaQSRsk0bQmeB2AGGbvxzjnv7Vpx2UuvtsFxHJZyRvJlpFjtokQMzbvQ8Hg96tfCYHI2NumjXyax pzpFIkxt4IgzLM2ck4HTBA6CrVla65H4hS+UacsF1blJpZ8tPDuznZwRxn681pH4itOQ7LSry20y PUYre9uLK9lylzBAAba9BBAJOeeBjGOK85nudZ1i7uPsaPFZ2L4uPNHl+awJA2r3+o9acn+8SIqp KDR//9L+S9Jn0+a0vIkLNPJm6jcf6snIYDHXP+Nda8+pXgEluyQWgIE8JbIkwPlAX255ry6keVnN Sm+crYlN7GmyE2XltLJO7fMsi9EC9888+1PikSd5bpZIwFJUogxgjrmsztc1Yxr0F7Zbq1u2sp2l DSOgHmbQckDPTOOvvUVitrc3t5PeShWktMG8dmJGDu5x+X/AqyqK0WyqbXLYntbmxurG/uUhlM9o p8vdGRFPs7qR6gVof8JGmpWeihrRhbTWqm4jjZUa3GOQWIzuP0rnfw/12IxD91RP/9P+Uubyobea DTVa1eRseZBHufHGTnHORxmsW3iuU8wXErzxpJ5sYdRuQjnj9Pyr5yC0ElZI3XtmvjazS3kkMNsR KUY485DwUI/HPtV3U4LN57DzLy4uGMCxC3K7YVC5CKOeeAPStaerY5x5Yq5n6/olq01rexqrt5ar OYpNjQgZwNgOD9cU2wtVvWtI7LrLJ5e1nCOpB7/X3rGT95RObls7jNVSdrn+yblJraE4zcxP+8GC MnHpx75q1d6bLJbbbaWI2URUo0yCK57An17dK1drIdXSCP/U/lOgt7SzurOWKWdRDh5NmBlh6Gpb xJNXl1jUh/ok+o3ZlZIxhlVj823Prjn6185BaGMFomV7O2cBnEaPHZyBAjnDTcckfSp1iGp7pomc JbsUaMAhFIpJXSPVVJKNZL+VfkURa3hkuXjXZHEfuwne7fQCrF2t6NPT91KqWrmRkkOxiGxuOD9B +VaNK2p5TVtCxbWsd0lulihlvpEaY20ce92RACTx16n8qvSXVyyW09zcCygSYRxIuFDSLjlh2Iq4 pezua+yjGipz+1/w3+Z//9X+VuLTzfXFxq4v7WaGaYRRx/af9ILDPmM8ecAZPWpbyxSDT5JrAMZU bczLHvjUZxz7CvmuZX1MNIzsRzrZ22krLu8+4uQdyMo+bA4C9x3zmqOheeLeOOVk3hiVRONoz0pS +Jm9XWnYuSXf2i+a2lsI7UWhCtcIxZ5mI53DP8vWk1Q2ECWslqEnuBPtmScbEjUnBKOOc45qui/r oczdpK5XhklsJTJbzIYid6xyIJEz9D1rGn8T2lxe7buaaa4tpvKjiEDN5TEjGM/w+m3NRKVpcxrJ qEUf/9b+UXU5bmS8s74wwJa23+sD7is7DH3s5/Kp9G1O3guLq3s91vMUEkrx/uhFnOCD0Oa+ZUuW Vjmu+Y0LSTUIJpTdbbkzsZlkUnmPJAL+9VNWXT7tJVugpZoSEYjLJnkqB2zTjPXU0m10NLQLKG90 mTUZYZktopjapczZjiIjH3VXpgY61SnvUsrnyiXaJ5tiMISVx/vY9u9awl73oQttWal5ZWWImW3j t9qI+yNiiSZAYMwz1xzWdd6jDZ2VzI135UY2xC3Rfkkye3qc44pPZnPfWx//1/5T4pY7uwmYR+Rd KRLGkEZd58Edfw607XImltLOLTmiSSOWO4m87uAQXUY7nBFfM6tHky1TRv6m4vLGBriKK38uEJAY xsWLHf8APnmqzTec1nc3SRTNCGjhkOGKkAAkenaso/E0dkI2hFmfDAiNdyXM1zNGPmhkVRvDE9GH oPb2qeUR2lvvs9sl2580pnbKw7sff/CtqkbxtEulD93JvoalrdFYEjghBkWQPOJlKoc/e5wc/Sqj xRNFdQtGPLnfzXD8ruHcdq2owdOm099yKj/d8p//0P5ZoI5J7eTyRuWEF5FUcqBgbv1qOzihfEjv l9x4Zdo/KvmHuzmWyNj7QkkCIkSsYydkw6D3FZ20XjvMpVZD8p3ghm9TisHFt7HVUqclKDjuI/mm KOKxuLcm2m2XPmPu9imc8EHHWqp+3vBI1yona1kZwIRuCrngCohrUa/rYx59Ujf0uFb02qThbe1Y b5mYYlA64C+v9akvNLW3cS2sr3VnLIXed0xJFjgLgduP1q3C00VzJ7H/0f5lhZLd2kRiEYjTO8wO BOCP4nwc/wBKwLzRzczD7OzRqrfvMceYB3P+e9fKwh70mYN++mx7Xk9oYLRYFuXnzCySqWBGO57Z 45zV+wt4bXzTcllLHcbYPhQfQVdPRs1h/HZnC5lt57pbmRYlkbNi0I5A4+9n8aimtZdPniu7iY3U qR+ZFJkEorDvjgDB/StYyvcuMb3sQR2t0xmvJ0SNLhF8loT++YAnIbjgVct75mnJ8hQYE8uOQAsy +vJ78Clzoi3vtn//0v5eFvNQkS6jEUcdqhw08rbWm3HG0CmXGiC3L3iQRm1skCyMjDbCz9NvYjg8 jvXzPM73FZXuS6WsMs8MrqixI26RW+V3GPSpLlLKBZpIUVric5Dg5bj3pN3dxmctrcXUluJLiWNC hJWPEnl9e3uav+RLBLDA8bujuDuX5AuO/wClICxMlsyOwMhkjl2sWXYmAMfj/wDWrO1CbyraARbY 3QnyYwNqTkk53f8A1vSgD//T/lptbCTUo1uJYoWSxlE80U0oR4mx8uwH73Pb0rTe+t73T5QJZrbU FmKRAwqybRkZJJ9umK+Z+wRT+BCWaoLiOeeC2lla3+yiZowJVXtg/h3qyNMisp5ELR+XJhoUjIPX JPA4qSyRYnghlaJ0Pn/KjYz909M/zrNsLcWV3ILdMJcT/amTJKrIcbvwOM0AaGqXixym6mY+dIPL d1+Xg5GPpyePeqFxHDGEmt/llaPEpjGGHtx1/wDr0mrqxpCOtz//1P5gNF8+e9nkjmh+yWdsZPJn Ta8koIOAe+RWkmnx3LvcziNHmU7LfH7qFyT3PavlkrKxvsjHa21LT0mSZrcXCPsZIJhNGDzj3q61 /Zx2Aintne7lkVC8W5pIS2AWx6e/amZOTZk/cke33swiAJLD16ZP+etXpp1SNIHjDxsuVjZTsUsM ZHof8KCTDuNKtZCN8sokBAjgXhD9TWjbR3GmvDKuNu7aCGwy+lAH/9X+XWa0mnunky7xshaSNV++ eMHPXI56etbDOZNPjbKRSRRhCn/LVvr718uYy+Iw3CQ2ct5LcF7iNtxt2TcsinoFx3HvxUSS2uo6 fZTWkpeW8lkie0C7ZrQx8/MPf+dBpFWihlmfs06oFLSN8srkBk46cfSrV9HGsiMCI/NTbwdsY9yO 1BQ+zH+hlo4leMSkeefvBhkY/wA+lVWuEtxcRzyMqSx485W2yRE+nvQB/9b+YOwm0oWcH7ydpxIQ xlQNkY4ORznrW/p9xG08rxbS+AS0nRgOmM/yr5cCa5e2kMhnVTG+Q+z5Tk+leeapbS28dna2drHt vNQYyIkQVpUIK5J9sDj60AOjshbrH8qIiApH24GMgD24qwZUtUEsSFS4ZXJPI7cfXmglxuZkzvL5 c0cKea2FkUNhwmeT9R6e1aCNbRLEhnjllIJCbCHQDjJGMfkT0oKSsrH/1/5amlvYrn7RvjFmiKix niRm5+asvUJZdQv7awgUiSbDmSUFYEwehbp0r5c2i0lY6C7s7eKz8pF3vIRFmM8A+nHrThcPFBBD NbgPCdkwLE7B6Digzi3zal83lv5SJGN8fT5cErWNfCxRFBvZri6ZyVhcDai9eCOv5U0m3ZGxXkth bw2K2wRvtdwDPETsy2epGOSB/wDrqS8trqK4ilAIWH5Aobnkc4/Khpp2ZMnZH//Q/lujtLy+MZhP l2bnF3F93eR90/z/ADrsrzRbjQtNtbmBvJN1C0kTlsYI4IJ6kdOvrXzFmXT3sc5Ym5v4o4pzCLps qz52w5+p7VWs4BFIIrlc/MVUx8qx55NNQbRqeo+H/A2peKtJu7bSIprn7LIZp7eKeOBmyCQMsRjI GMivNpoV097i2d0jW2domIkEoYg44YEhunYnpWalFzdNPVbhurow1EqRHU4JZIDJcfZ2aJQ0sgXj kYPHI/OtabUIMmFGLy7ESZmGMnggegqgP//R/l6jtbkSXF87hEKIn2aJyseBn7qE9T3PerMMUE0k 0eBtC7gk3yqfoenFfLNaWOmz6GVc6eI7i5tvOJtXw58ttyKR/cNNiaK3RDJE8iyYWFlTcQTwD9K5 paSt0C13Yme2iF7HJJErbNr/AOySOxHtV6VYg84t4QGuDvkaNNoU+uPaqK5CK++xw6da7bmQT+b/ AKQHUBcD0NS2kMUsEzxyITEgKru2s4JAwvr1oDkdz//S/mIhvRGscRZoZQ3l7okzKgPRgO5GaWJZ bSdIZWlmUN87soRmB9cDGa+PO9JR0Q6/tY7SCW7P+lpFm6BADyKOu0VsxxLJp6ahDDL5JiBkZ02h cgcE9B1/lQUlczrOTThA9zOzCUOVeWJNw/2QB+VWoLxnzCY3kUoZEk2fLjt9P/rU2mtzcNMkWZrn fIIjG4RoX+SQe4Hp71IRDdXM1ulxBG1ofmJ+87YBGPzpWEz/0/5m2lzP9lDusxXeX2/K2SeQTwa0 zEpRVlBMkh+cnqfrXyCTbsj1+hSuLN3KJHJsVOV9T7VYjiNtatCFIZiXfuxJ6n8aTVtGYvfQyLK/ kWQQ3EJacFgJFGERc/xe+MV0emabZQQ3MVneSBmbzxCi5hV269/fgVnNEOSWhD/pbypFI6JtbDOw wfw9afdpcR7h9oEpD70mA3ZHXj/69Sotq6Fzrqf/1P5sVvvmTz/NaViF37S2avanEzQRSXu5reCP cpUGVgvXAUV8Q1ZHoLVXI9Jhjkj+0pKog4EQc7SRj0PNaFxEsCGeJlzJ93JyM/T8aQGnbRvNbZkW N90eWViAp496hikWOJkmkz5j48pRwg6AD9aBxV3YW7ZrSBSFRYbeA452sVyW5/P9BT9Nv4Z7JJXE iBycJIPnXFJuxcHpyn//1f5xbi1tJ74BVMSXc4EjOpKKVHVvbjrXS3EAt28uFhMoAVJIlIVhjsK+ FktD0pJJ2RRuU88CBFkQPhWYfe5rUubG1ghjigeYARhWZ/vqcUrJwJMmGaC3kaOTzJNhGcoQvPTB xg/h0rRkhc3kVykfmBYQoCjIVevOP1pQegEstwI5kjnsHliuI22yswSOMjgH35qHTobtprgR+WRE 5J55ZRg7h+eKIb2A/9b+fHUY5LyJwZBaiMZE2NzACn20qwRKkTGRSn+sbjefWvhJWsz04PWw60nC O1w6+arKd0ZyhHH0yKkgmRGjMLYZnyG6spzWRBqXkMdxcm5glKl4wJIxwM4+bj3OfyrK2vJLIVCN LDwMDBH+cCg0g1sSQWTSyNdXMUSyyKIwFXkAZ4+lbNkltDHLEoS12DJjjTlvy+lBof/X/BWNpmtX kZ3ZIZSsSyArkE8lf0q0Z76SMLFl4YhwDxuJ6jFfn72PYK8j3BjAuFCSZ+XYcjFIPNEUCvLukjfI kfkouc4/Wso3dgNmOUD97vARBy7cFvpVaSc3B3RN/Fgkn5agxl8TLAup0+TzFJUZUN90+2akwl0y yyRgSKv7zjIB9qDGa6n/0PwvtZpXbdIjxorlEyPl64qa9C+W587MrDC7BkjtX5udlnyqxgr59rZq YlRsPiVnbazZOelbcMqmG1hmt/3s4MqS8lQo4x+JoLTuF3IoCRxwkAffkxwKLiFlto3Vm+fG0jof UUDNK2u5YIGtJ18yOQAIcZxjp+VRNa20Tu1xLhQu4gfNt4zQB//R/E63vIpoBBtyg+4c8YNV7tU0 20gs47h1iklaX7NuJQk87v1P5V+aySaPW5la7EilubWxYCNXUvvU/wAaCmpeLcTRpKpfK8Jnbn2r Jq2427K4/V7c20EK48r7eSqw78fL19c44/SsyyRUYwchEUDCfwDoKRinZNGzc29u+PNYsMYTBwR7 1VvvKtreLMu4qQyqG546UG90z//S/EKytJzdQXsU0kTOOFzhOe/NQmx8m+uljuzOhm8qRHGFjbvj 86/ME+VnqTtcvuVg2IDtTGA+MgGmRpJNcBk8sSMMBsYJHqTRdmZaSCObfa3EBcr8yjqpPY5rFsdM ea8mlkEsckH7sociNe/41utUaKaSSNaK3u/ImG2J0LkIAw3nHr6VLbs9tmBl2huCCO9BEnd3P//T /Eu+tWeZPNj3tgMNy9MdKrp5csjRszeco3OvQkdK/Nnsd91excnvpHfT7SAGCG2c+cI4siTd/HJ3 OP0oZdrsyHzVV+HUccd/5VcVuYzX71IsvqF/eJKJIlXzMRpMq8qB0+nSs+6vNeN2Joh9ou3iWCLf 91tqhQW/AfpXFPY9ZpWsdakM7WQvbu3IvYyHuYYeWP049vSufiuje+dcJBMipKY3SZDE6j15H61M Vqi5bn//1PxiuYrGS1nubeScNbpt2BQwZ+OPWm2ge1ieaWGOWSSLYkZk2sjHnmvymXxM99q6sWNM snmmiivJgEuCI7lkbGVJHBNbWdOkmnkjkiYxs0QYSh0BXIIBz1rSGi/rsRUV6SSMq6nD2zLI+UDc Bc4PXFR6VbQqjyQrtRWwxwQM1Rl1sU5rh5b6a3WJ3jiABmZCkZJ5AB7/ANK1bfy7dZOMyt8pCruX HfJrfkcWm+pzyakj/9X8YvsFtFcC5SY53GQxL/B6/r29qntpbPzEv0m33MUhKwygjcvuPSvy6dNv XsdySVRS/rqOutWma8jEduGtycOy87Tjp9BV4ktG0m6STPKjH+rA4omrQudyaTRUh80y5bBiZSGD 8EccGrNvdS2jmOQQzxyghGTKvHgnAPbpWLVtGaR0HR25uDebSYMqSuWG18c1cjuWjWAxojxKvlyB eEG0e34Vk6fvJdjeLVl5/wCR/9b8drp4LgiF8qXJJkjO0xY/un1raeCewtTPprvcmSDyybhQsj5A yfTP0r8gaadj6hO1RtBbWtqEWS4QM5TJQtjDHrTJbeC1ulijv45JZYvPFuHG+Jc45FOvFWuzRxUY Kq3qzUtAjIWJw/3fNwM4HYUXKwqjPg5xtKjhSKyp6QSLk002v60ItNgS3sJkiuAIlka4dHk+6WI+ VB/npUdveW80cpkkZNpI2v8AL+lOcdNTFNuCP//X/J50t7jSpg9yVOzMZ8sgKcjH0xwefSq89jFH C0hw5S1VGnxyxIGcV+MztCadtz6Xl1SJ9LgSOEMVCSbTickhh6KB0xW7Hqt9fOUuQotwiwSzYwZd o+UnsTwKikueCHGnb3WJFCiXHmC52MPkwDt3g8Y/HpiorqyGqPcWbXklv9nAZfLypViAQCR6jsaq UVew1GPMigkWq6ZjzIEuWnbykO4xptzw3PfGK0Jkm4EIT7TImdpkAUe5P51DXQUINOXN0P/Q/Lhb qPS/JuZSjlWHmgsdh5xg/Wte28jWDEyRiCdmYRKD1yfX8q/FEmmon1FNc0yMfY9MlciyWK6gY+bc iPc0me+Px7U++MiW0/2N1S9uIyyeYcKW2/LnP4ce1YtaNFJO7fr+bMfTr7VtRght9RM0kkP7iVZw U3Y7L/s89qnt9OnQTRw2MKWSkxmQybGiJOR5a9znr6ZrOqmopI66EOeDv1udJY6LFH5e+USQJEJm kY4lQ9wR2p9ydHm0uZEgJ1e2u0ltL4ylY0jHEiMmO46e/wCuFSLVrijFxVump//R/NwXMGo6gkVs fJ+QeSJG5JA55+opzyBSVmVWlPy7kOMCv56qLVWPrKnOmlHuUoLSG3uTcSEbD8xZ/wDV496qCd7O SSS1lMqyHpJxvGedmBzxTjBxlzFys1ynUaa9iTc6jHFOlpdW4hEdyhR4ZgMPjPq2Tj0xVGEyyPMj F4gFO1weGHt+VQ1qyYKyuXdO8uyWVraVLicIXecHe1v2bjoCKfZNa/ZJ57m9lkhikwZnKiV2OTja McfyqadndFRqqMrH/9L89YZQpN1aO25laOGMybYpfcj/AD1NJqF9cWKQySx+ekmAyIQZIjzkjPUV /OlJXqSXmvyR9i5WVmQruurY6h8w055PJkYLunQ/7S8fn7VjMktxaRyaYYp5jc+SFdjvRAw3tge3 QZ5206SfNr5/oY1HecLGpFbSTxq0l3FcIV2SQqCTAQcYJx19vaqb6RatrMVxcXV0sVku02aSAQM2 DhiO5575rqs09SoS91l67vZ4jCNMfypy4H2g/KIgDzz79KW5m+3qjxkPNGcSKB370ON0Y4NuOJqP uf/T/OoapJa6VPYRyuIjO08kZ52k8nipNIWzvZPPhdZjFEpNyw2FWIBZQfQHI98V/PMY3Pt1/ELw uYbOcz3ESmIndK0ZDvtXjOPXA6Ukt5LL5TwboLd3Eyyqg8x0P8ulVBe7IdafLOMe7Gy2+m6lYanZ qzQ3TR+Wb0nyZYVX5sKSOCc9R60zThJHYW1pJcNc20DEW7yN5j89Ru7jiiCaZa+Jf10LV9b2t7Et jJ5kSysEeaKTYUXPPH+etOuLrTdAtnEltc3sawiCA2iM8lmdyhZHQAkrgEH03Z7VEv5maUk1OyP/ 1PgVbjfCPtiG3lvbbzrUlMCVc4ViPwP41kQWsuo31laCd2kjlIsY1G6IMeCW7ADNfz446v0P0Oq7 Ssy3/ZjMy2moSNdCO5zPHE2wEg4wMZHt3FU1u7CC8EAuDDCbjyVIYM0RBPH1GOlZxXvHTCqqUVKW xtveXAgCPO91HaszxvKwDruPbp6YpEmlvbi1YqYc4Ty5E4cHgH+tLSxle0YoTxHaSW7C1lbzklym +B9wcDhhkdKTTdP0IWn+kmOYJEyRWTkuC3YuPQdapNcyjLr/AMMEKl5yj/XY/9X8+ptUXT7WVDEq xWy7bZo5N7OOgUD+HBwMVzplZi895dFba8+V41fcEAGMgA5Ffg9Llfw9D7/GV1BRfnYuxf2fa6fA EummnmX7NZW7OWlfjg57DJ/nWFpbNFaqdUtYL2/3iGKZifLhYtjJJHp39ulc0U3NmKlzV3/XQ6LU NNCXLWcjR+SYl89IJQwBIB4dT71nTqLRYtMmgurqOKDe1xcfM5R8jbu47foRVypuyNXG8k+xsahb IbdFiEMVu8avBFanesaYGE7kY6YPPFc/PeW9tcxW13GYyYx5ZRSysOOT6ZqTaUmkrH//1vzhklhS 2vru9uWh05bUxTC3+afawOTtHJHAzipdO1e1j0mK2t7KOGwuoI/s8txFuunVONyueQCVIx7Yr+fz 9D530DCJbNITbXNvNIIoLwzjzWI+8GUYAx/nFY++T5ooUY/vhjZzknuOeaaTexLbe5nO0/2kMYIp JorjZJFcMVIAPJ45q3fXSvODawXOzyl82SJd0du5ODg5yBn1puLSuxFRrW0M0lqJGktJRzNMnzMR 0b259+lVvsdtpcaf6FDeGXdBHcyOxe3PXIwf58fWmoPqB//X/MKwSdi6XEiGNov3KmPLsQQcA9v/ AK3XmqklrZvO8T3t1aqRnMCK7huM8Ht1r8HP0AoX95NZ26tdh5IZJfKRGO4yhcfeH0I/OpNGEN3c 3BX/AEWQRl1P3UkHUqD9Bimld2E3ZEuqtJGu6zdfOZWTy2J8sHsWIzik0Dw3LLJDd3NxZ/aJ2JV/ tKlFfv7j8R3FdMYtmBQuIbmGeS5upZLhHlMcNzNL5jKV6qPQLuFV9Rj3SW12k2ZkxsfGVQZ657Gt kraIzcndpH//0Pyg1HUrySRbQFPspt1jaVVCrHgfexj1rnhfXOnRNPPlo7dv9ZjLSr2O0c/XA71+ MqLZ9gTjX7gzzrdW9usElvsgdiFCE8lvXcAOPr+FXtFW11CK6tlmuTq8sm+0aV447IooyQWJ+9we PpQ1qxrR3KU1x/Z12sTyu1yi+W8W4lFXJIGM/jxVxZZBIHT/AFsoyi/xL7/pWq0nc9PaEfkYV9cG 2nHnRkOJghYKVDE9v6ZqaaK4t4cuC4mlW4+ysBl1IPft/wDXrRvU5pt8x//R/IR7uxu54ftW2A6e A0VtbgKRwdo29x6nk1maneXcN40bxZtJY1eHy0JjUkZO/wB6/JYO6sfbSlbRGXNdXiS2EtuskiyA reskJSJSvTHJ6DH+ea20SK9R45ZnheVdsRRQQHPTd6Dk8807rYxb6kbozBNMbyzPagqZIGDeec8c 9PypQr6faxOyQSyK5SRnPzg88AeoxWBzuXcgVtPmltFum+yyS3B8yQAC3VTgAt6Y5zSXuq6epsI7 RWkCXMkF4zHaGC/KuPr1+lBHOj//0vyOmtrS1iw7W/2WSL93GFWYdjww4BH+NcfdQhC/lkvCVLM0 eSVHv9K/JY7aH0sZczsUYrbTbaQM90XNwvmDDbvyHbpWFczNcSCzk+zvA1wXWRYdt0g4G0P1wccj p7VRad9jctYNNjvH3WCwHyxIl1tzkjOFJ69hz71nzu8lyxnmDwSMfLEShBF2APPP/wBeuqm7Mym9 bEreVHAyAebhSRHjl/pXHT2o1vVXgbVLyBbCy+0Isq+XbxsFOIs914/XpXpU30OS3Q//0/5b/jDd S6zb6e2oRx/arK/W2kFtbrIACCnzMACe3zGvmT4kWUvhIQXEVtZ3JvVVILRnIQMV3Fm79OcdMjvX xsUrI7qqseEW22e7kmKRobiTLRqdqRk9ce1dVaHSrPz4ZJBNcyH5iibkUDoA3pW8YqyZxy+JmzYQ g3sU0twsdtjGxx+7UnuTjPH9a9M0b7FqFv5oZJLeKRo0mQEK5U4YD6e/rVnLa2gC3W1miuFjilRZ w67m2tGAe9fW3wuv7rWNUkikv7qWRLGEWEFwUFkgBYuUlODkYGF6HPr15a+jRvHZH//U/kkgTUoP tVprFoLSKNlh+zzKY/LJIABB4HJFdPNZW+h2McmmXYeV5QkkbxA71ccup9QePxFfC83+0WO9aXTK NhDZ3OqalZ/2PqDXMemLNDeQXaC1mdu8iEHGOOOPrzXzz4uto73XH/tCHz4rOeNgPLMYlwuHUN6f w/UZ5ruwz/fW9Ak9DmH020kV10+2htlDsyBuWRck43e361M88sNh9ijnWKWU7JplUGaRBgkEnp04 r2IfEyJL3UdL4M8Z3nhxNYstO06W3a6t1innljKxzc/8s5OgJHDYr1TTk0zXdHkmvLiBWmkEUlmv MrnqxBP4Eda1iveHBe7Zn//V/j7vNG0/TNSnaxkuYbO7dY4rMTedBIyRlhnAwDwxOOlZMQ1e5e4m 1nxBCGtyIrDSVtjI6x5J+WQ8kcjrXPa2h1VIaaFSayWXzRcXk+5V3wQIoEcpHXdz2HoOao/aLiAn deRwTMpRfIPmOV6Df6ZBwR9aaV9DlcWtGdYQTp2mw6cI47hSZppgPOeUnB2+wGOOtciZ5pbx7pGY yxE+dIg2EkH26c0iYx5WdYLe3vRbastgzSXlsLa+jvGLvIuCGKn3OT7E1njQ9J8J2ry2TvJHdQtN BYtc+dc2jq3zJjGdp7DjrmocNSkraH//1v44otSuJLdbsgxiQZFuBlo/Y571vTY/s/zVtE+12sX2 xWLgA454BOCT2xXJyIV/escqL64vfsZt7eKGYTCdZ5uHQgdP7tbdsiXqSysYbqaRGHmqwIYk84Ye /wDKokrPQZydtpx0/UWnvLOOeG7ge1uVlyQkvGwr69+faukhEkN1FFdJiB086B/LPlMo4/T+lCjd XNlZo1767aSVbqG2gv47RVup98oRAIiMfjwOnNZ9t4wuPEJur2PZAs100U0VsxaBNp4QH24/xpLZ kTWp/9f+P/WJbDUILW8WO4F9p9uYRAiFU6fe981mRXMVrb2k11BLG91MEYIhaRz2DY6cV54m0kdd c2umT2n2e4QlC3nRpNgvCTz0PHYVxkWk6hq2tR6f/a9pJb2d9HeWkxdbRCildybiRnHTucg9aATT VzoLo6lHqcl1bzIltDukFvMFZkdDkPv78D9BS2NzHeSxXN1bxBJZxcX77Ns9zjj5iep4xnFBSbWx b1We3vb6fUNOtkt9PeTy/ITomOOT71iTXk9raXj2IW4liX91a78K5J6n6UFc7P/Q/jtOvy3lmi2d jIhlLLqE91ujnidCAVVCMYJJ/AdTWrDZaprQsbdtUvvskEihLPbvUEDIEYPQ5/yK85q6sXF+8aUy XMskSRvun0+1eOK3Y+X57SEYZsdx0HYZOakazgl3aPdXVkt3LAJHhluFhjbOAR5mcd+5rBroy+ZJ XLEGm6jZxLpj3CxWUsmZ4Le4E6SKOAVZSR9KqHT5JzNYlZrm1hkMYeVMF1OcE/nzSSS2M5Svp0I5 EhhsjpUEWxoG3Hb8vuBisLR1nOopBqQjubYSF83CbIlKjcqoenoM+9O3Qk//0f5Inv5dTuNRv20v SIre5s20pLWBjOHhU8uQfuvxx+PWqVrpcSWyi2ijto7Qeb5K4VGQHn8favBh8SNlJPQswaXE99ca vb3KCeSFY3hViWTBJBGOB/8AWrRezN2JZ5lFy+wlt7fh6/pWxM2tijDpt3YNE13FHEZiz26xyb5g B03DqPxrrl1ZrW2WzluY7X7Qn7hYAGld24+bn6cHp6UWsZmLNJqC6fBBNeT3FxBdNcTNAqxREEAR 8DoQP5CsWyt7S1nnmvXM804DTSOQXUDJXp6f1oA//9L+TS1utM1I+c940UWfKi8uPzM4/vLwar28 qXN22nSxzWYdsNNLCVYo3CyL3IPUGvJUmlY52tLFzSdDdZn06GX7WokYyyNIANq5bOT2471TvrSW ZnS0ld44wSzkcEdMcVJmotSF0C6W0lysI+XKzFB8/pnNS6i7B7O8jgiu7C8vQt/aO+x2jzgnHUEc fkaV9bGhXg1DR31eXTI5BbtG/SSMrFGOqqzn5c4xW1c3NtsawjiWOCWQOGiUlcjOSD2HJpgf/9P+ Ti7iSWS3trR2jWFxJJvO5CwH3hV2eeWO0aIgAsSd4X94xxjr6V4ko32FGXVGNYCGeKa2uzLPI0uy JhAXWL1+YdCOPzrZgSSzXfvlEMD/ALp0G1UPqfwFZWtoac7IxqRlkmy3miU7izjJz6/59azGQTXo l859yffIXARQehPp1ppN7E3a0L3k2FhZySqIyskxkLB9o55NVom8opOPs3kSY8xrgkYB6bTQ01uF 2j//1P5QrC/ayd42YyxtIRFaxnfGy/X37U43i27Ofs/70ncIxxsU9Cf5V864pu5Mp2ZHZNJJqyaj HcyrFb7dkLBTEhA+cMpGCp56+tVpJLi2iuYILhngnfcUxsRTk88fU/nVEc7L1rotxBpzXH+j3BMm 0RzyFJIs4+ZePrURt7uWdYILvc0bCQlGC/L/AHf1+tVFe9Zhzt6IuSlLGcvdJHK7ptUM+NhI68dx Vb7SIUd4Xwc5cKP1ppJ1ERWl9k//1f5NLhGuYzD5ggJbzFm2hnVvXBq5aXsljHHYTXY8yWTMM8wA E2f4SegxivNrfEefTb9oQ6peXSwOLYKwh5k2/MkoPHBHvUzxmws7GK4hurSe4thdO5AMOG5Uj1/X p7VidspK1kZ+6LVbaFon8qFJQzTy5gAA4+YHpnrzWmsNvpNxA89xBJbynb+4dZ4SWGARjvnFRO3L ZjhPSx0Lo0NtLdeXEsHG1FIVnz6D/Cs3Sm0hrswS291MWjN3FbW0e5PlOD5x/h5IHNc28behnWne SS8j/9b+VNrsPNLEmnzwbJDkNHtWNee2aRYYI0eWe4VCXAjRhgSA/wCFeHCK5bCk3oS3CSXASNY7 cpGfLVdwxOvqcfj69Kbc2Hnx/aVkKNa4UoW2qvsPerVops1lBThe/wDSMG4uLG0a5n3zW9wIl2Rz PhJscNz+eKRJHCq8Z8h3GWXvg81jNJO7OFvl1Y+0nluNVWESSzyxRD50yyoDwFJ9OvFFz9v+23tv cXDyguNltI48uMjgEY9KcmnawVGnBWP/1/5RrPSL1rONVvFvpQ/7xgw82ME/xYAHHT8K0UjurZwl xs8qJswSBvmOBzv7V88rR0MqbXKVbrUJYrS4lhtS5MoQqpwSCeW+mM1Zg1Zbazk2lkSaHbMBH820 c9Me1Wknc71XSc491Yv6bdWyB/IO0Txibeq4cDHUjrnpWNeTeZdFJr+5v06wibCKqHqpx1rOWzOG UepFa3X2G5M+nXb2F4sTxQPH96MPwcV0TaXC+kpPe3j3TMCssrxoiySHkOR2x7etOKk6bt/XQ1TU 6Kg+n/Dn/9D+UpIk02J2W2trqKSQDHSOQ9SeOpwP5VtQQXeoxTrAwggS3O63WRYiq4zgKeT06Cvl kmtGROKc/dM/SItKtDHHqMlxdxRBwjxr9ouAefvYxxnGfpTPMiAEtuxUkkpEYymPTIPI/GqktWjV x0uMsb3zDM0lqomL7XJ53gDAP1/Ona5A91axXdrYxrHDIsTRwlnkJPVsEkmkkc1RLmuPmtJf7IEq 2wmmhjM1qrjy3ZsdPXJ5HPqazre5hzp63dtGt44HyRQh2t+NxDNjtz1pSWqRLWiUj//R/lQ1zX/s Wnuv9nR3URnWV3MRZtqkghQPXPP0FSiytJ45bmBI7Y3cKg+WuCuBwOfTNfLa8zucmqkak9tPGsVz AzbIoRGw2jaRxyf896597EXMtzeQIk1zIP8ASzLJsAOcAj3ximm0xy5jo9P1q9tbR9BESpp0ah4i CGeSVid5IxxjA/Oq11qDwW13ai1SXegZWlj+SKT+Ftw54GeM9+9XGVrsLtqxk2djesfOkle5kkiU PvlGyNVGD5ajgfT6VtaPaaVbm6GpF5gsnmxq8Ycox6Mvup5oUvdaZz8rcz//0v5XrO/sTPIiSsiX DPBDcFQBHgndz0zx+lV47NTPNd2Fy17p0UhWQ3KG2nZhwdo+vcV8zf3LHBGKcrFpr8TCGxezlkmv ZfIjt5I8qp7Fjnjnv64qlY6ZLp15qCTtd3HnECNZjm3smHB8vA/Q5z61EV7zN4rRRZv28tiJYoZE nmglU+dNHHt2EDv+NUktCJD/AGXbSTtG+ZZLo4BGeSO9bVHaxpFXTRp+IZIja20emwvazpGEuvJf c0jZ5YZ6f/XqoLS6KrAwadpY/nIG/cccjitKbclY56nwyR//0/5aNFa3QeXbgmS1lZHjkBAdQeR9 Ki1e3Fs/2qJ5ZZnlCrBHGHgjViB8x7YJr5h7s45fAicrJYy28Us0kqsCyrtxHH6gU63ElzcyvAFU wnEiP8p59qn7RrVlenFFttMtJIm8sohEhnkMTbWkbOTn1/nV7S51guLm2u4Stpc25UlPusQp2Z/H FSoJSbQWWmpWmmjhi8tVfzQNiyHkBe4Aq/pmrz3MTWG5XBBURiMYX0P6dfanNNNW7ltpOyP/1P5i JdKOlSr9puJZLmfEsRtpC8A3fwnHGMZ696dFffZblbW5jcSzcp8p2nqa+ZpNNtGNSNkl5mNrTyxX kN3azSQSWgMiRKmVmbPGW7Y5p0Gqw3Fv9puYZEfZv2jDEkHDE/rVwXTqTTk1Xa8ia+itrr7NPDIs sbRh1MZ3MvqMetT6cHumm8tJmS2+WUTRMhVRyc57e9OMeU66b3RNczwFv9GbMBbnHIVan/suTYk9 qxUbDIykYMgPcfrUKG5L3P/V/lnuXulkO2JpUjcMEYZG4HA49jW9axebaSPeXEEdzAit9iR9zSg5 BOPbBNfMNNaMDK8uC8ldUkVNilwoPzbR3xV7TrPTNRtZVF5MsyqHt28s7SVYAg0NWCw1LeKz1Z3h kjJmRVkbBTzCo4GD9TWsJvtF9BBeFIUjkCrK52pGCep/MmkBHr0sQluILZMWliQrXJOVvCT95fbp WDK1mTbXVxG0v2WTzfJztBAHIB96AP/W/l1E9vdJPLY27WqSPv5ydx7j3wABmqLSKoLEIADmRj0Q dya+batAmkrRSZeFtHdIjwSHZgbpFOQR6irMwFrcRtAolMAzuk58zgcYrMoS3jtrKBr2G5kUPK0j 2Dr5ixseWKLjgE849T0psdy+0TL/AMtOcEfMv+FBorONitcOWdZB5EsWNrRychMd/r0/Gmwtar+9 JnhkBKtKGBSaPHAC+3zfXPbuGh//1/5c9Mu5PMdVRVt3P+jyc+bLg87h2rTvNSlFrIoiAeJSQU4Z /rXy5tJpKxh6JeGeBrqeyNqWfE+9SW3A43E9+BVjUbu2ju7U28ez7Q+wzyY8olV/i9OnFZzfQxJ4 hCt3M0kYc3ESiUB+MqDtI/P9KrrqMLmSBoJGuEbI3LtAHYc0oztuBGsDzXT72K+XH5m9vlUden5V LdxQiASLcXMxJXKRp/q/7xJ69O1HOwP/0P5gElnhgU2+fkPJcYc56U1GltoLme/tHYbCkZfIOSAQ Vx1r5NT7kuKZk2pS8jkbypIgR88cnIH0NGlpFZ3dyzIFyhWB0GWbI5z6GtCkuiJzHNFIS6AMB8yg d6Y2nteRukxcb+QpJxjOcZoG1Z2LVxaLaottDPGxjRQfs7ZEZIBx+FUUtoLrT9QN3Y3O5LpI7a5n XbbSsOQORxknA+nFAj//0f5bbO2nECTJD5TgHzoEG8Z9FNatrclZrdDDIrbgZoQQsu309BXy4Ghr Ekdvbx+UjGWeYIvGTH7n8KzdWtZi63/EVrHbr5J7IwBDtntnAoE3ZXObuYJLqWymaQRxQZYRoxzI zDBJ9varIldoiGt3ljt5PMlmH3YF6BmHpn+dA1qTW+m20CtdwYBnbc0vUuD7mq2owvazQzowZQMb AOWpdwP/0v5U3nnmhlEwd1d94VV+dQOwrVcCWCBVeRpVj2r8nIUYxyO/tXy4EVrY3Fk/2i5muIrW UG4xPGUZ2A45PXHSm3mpzvdNbi1heBlyLhHJeXjq30oGnZ3G5n8mS3g/dGdcb4yCY896iS3MxWBh FLNA4dHkba529Rx6960gnuaOfY2gUlLFMrLFxnHC9jilE7vIBIVYjo3VTVtXIk7s/9P+XeXfNsso nkW5nYoEi+RQuPvbs9fasueLVmngtZ7y9nt7A+V5VxIQikDovr1/Ovn7dAT7FiQTQKcSCBo2w8bH n3wenb9abBqqXcVwlogmuYl3KuTGSR1wf1/Cgbbe5rW2r65brdS2OpXVlbzWX2a6is5jDPdB/lZC F+8pGeO/esi5sbd106O3tJDHE22S35U5GSCB2+lZziviS1HGXKrHs3hb4Xan4q0tbvSbGXEcS3bw TKYpNrdimMjn2riL34fa/wCDL++XxMtpAk98Rbx/MlzFkblV1YDtjBHXFRTi5zbjstzolTlCEakt mf/U/l/1O7ttq7GKoh2q44BPSqgheaPZumnYtuckZdQe3T+dfLtdDuSVrHY+EdM/tG/gs5LBZSZD FbROpJk2qSeBzxXqN18EPEN5c2P2aL7GTKEjWaGQQIG4PmHHAHqelZxpSlqkdFKhOsm49Dy/xN4Y fwhq9/aa3MZr6Ith7eB5LPCcAK/3eSfqeeOK4oXVxJb3Elm7BpkMbLkx5B6qf0qJRcZOL6HNPmjN x7GfZ2lzPFIuoJC8Cr5bRKTvHbP6V0NvZ2ltafabSVQII/LS3w2WIx7YpC5pXfkf/9X+XqK7UpBq bQmFJAUyRiVGGARjrWiNTijSS4mm81iu8GQ72PpXx533V7FO01fzNPv1u1jgckm3dQXjZc9x2OD/ AOO+9XNLS51Ce3tRPNJZH5ZIIz8khOB0px3Q07bHoun/AAX8UyW6T6RaS3ltez/6NDMWVW6ZVMK3 qcDvV6DwB4hilltI0eGSI4kTyz5kZBwVOcDr61o0r2Z0KM7c1tybUfhnrUkUWpTafefbWQofLQyL Iq/3yuRn6+tebT2dpBcPFBFsuGIeaQj945AwCcdeBxUxi1PlFO0Y6n//1v5oNOtbq41GBGiDwgnE jfejx6D0PPevSE8FanqDx3tna3r26hlDOgjiYgYyM4z36Zr5JWU7Hqt2hoYw8G+J2jlu49C1meGG 8Nq80envsGeQVOMFenIqbUPDGsWCtJdxJARB5w+Yl1U9C3GBUzlHmsmYJu12cTLpzvFO8IkSbdtu JGHA7ArVi0gTT7Z1jupTO0nnytIBtAwARnt0/nSsc8p+95C3CMRHdLcecJVDxqMEJ1HGP/r9apyN NvjVpthPBUjJxz2/Kgad3Y//1/5vls2eCII6PIMDLkKxq9aRztMYLmFjaRIDLKhDyOOchB04A/Wv jmrqx1RbTsc89srIYg0iweZ8+7mR1B7474FaDT2zQxC3Bkij4XI2gY46Vlys2L7s7W8VtvcS3TrH HHEpaRixGAAO/wDKtSy8H6zAl1etuuc3QMSyfKYkCL8m3HUEMffI5qS02mkUoLa5n1Wey1GZVSSU DDHd5SYBII9jmtIeH/KuVhsmurmOW5+zr5UJmSMt0yFBx+NE7ReoU9z/0P57LrRLqITjyZCYB+8l aMqq44IHfIx0+laGnaRe2ywqwu7ieUZih+zl9g69hnH1r4c9KXxM1H0DU1MAisbqUzMwadbdhHBg E/MccelcxevfWEkkN/bT7mP7uZk+Q89M9KLdCG7K5Qn8mS3lme4FvBAqyzzFgoUBhwTWit2j+Tc2 U8gZo8Sqh/dMOx/GklYUXdFie2uru0371aKJSwVjh+cZA/wqjDdCzgtsGVZJHZJ92AqLjgZ/Okop O5EpO9kf/9H+eqV5X4L4XORgZDD0NK8uIUCpzH1Cjgc18PY7oyuU3MzXAWPiJ8Dnge9a8Fg0bO29 vu4B/hP0qeSJRpQW6WbxuzsyEZbPSpVghFxI1oCyz/Ox9CAP8P0rPkkNOzuSWjy3dyYII2YwDDMB kiqrTBnmeGXEyOV3MuQ+DggUnFrc1Ukz/9L8Fldr6KKKafyTGcgZAX3ptvJKsknlvvhRyDtHDAd6 /Pz05STVkaMZtL7zPNkkjVBldi5LEdvasPXZZVihMMcirHKC/kIXacA/dI54+lJbFRkrWZbsp4Jo g13vKSDCQZ8tV9Pf860VtAriJJAluqg8HLfT+VRyqzZm3d3Ip0WPEzh9kXC84B9yPwqtPqMeEjik lU4y3loSBnoSemDWZEo3P//T/Cm2upYbHzJysm08leAR2zV2Ca2uJkSAEmVcluAoPpX5ud6VlYyr qN4ppI3QG3+8zk5Ax2xV4yzyQRqEbgbYz3QdqBifa5TB5UhViCdvHWpLFDK4FzO620ZJWIHOCcZI BoA0SbYrlWaUNxG3TFVpbZGTyHdl3/MzkZV/YmgD/9T8LJLhEJt4VKxrxkdTinP5l+ojldxjG1gd rYHoa/Nm0tz0DbtoZGt5kQySxRLs3uMFTjpSW9oLbEryK7N2I/1dRO1rju9ivezQ77VZohMVkOyV lDtFkdvTpVm2n+yy3EcEasZ49rMyZyKzEOspwR5upWziORisIyUdR6kdvpS6hodtdxGa3umQxDzI 4gN3nEfw57cUAtNj/9X8TLDWIrdDBdBJELADtLERkcfXJzU0kLwvIHgULPMZlk/iGR/hj8q/MEm9 EegVGsLiXKSyqh58lUIZWx0JOPb9aWya4s5pXuo1YmMJGvUe/wDIY/GrUNNSZNpaFuK7l3PciBog 5xFG338e4/OrMeqRzCZZ4VEgXaCnylyBwSP89K0G2krmTC08PmTSSDDTcRLkNjj5j2/L0rU+1IxR BEJSSCC/egGtLH//1vxX1GTUh5E0cKu8TiO5jlYhUTkDFLb3drBcZkgTzWTltuduK/Nnszs2qFO7 njt42vZbqBI5wcNHIFIQnjcOoHSn2Uqx2Exd1toXTMEjDO4A+vbvRGWlwkveTNu3SVbUCWVTGV8x EBB3DHWs6S7uGvUcRg+WoGQMbgOBzXO1odt9LF99VZpCoAEhXHl55/Kq00z3PmQxoYmUDzAernqT SjFLUqUux//X/FhL57SAxGBOOdzqQW9OKppDLehro7t4G4xDocdOK/KprU97mVtC3pwmuhOzs0Kp 8mD+P+FMe3jiIgh/dM2XkRF2p6Z49auKsrEt3pJi288cVtNE26aRWIA6568/yqa3i1ae28i1WZB9 pS4KRLy6qRuUjHcZqjO2ptyTWclq1rJcm1YgyKrKWMjqvA49a560uNSt5GkhLGJwYZAQGVgfrXUp 3UZPp/kcDhNOUUt3+p//0PxbsLSOH7Y7NtMxMpmfJaMnnA/SqlmkkksheEq5+XdjsM8/59a/M3O6 aW17nfGDbRvKs32doEg2ALuNwuCXz7e2P1qq1xd2ynYPMjRcvnhvyqHa1jrtZo0Y7iw+zGZXlmfy 90saRHKk9h61SVkZgkaSZUZJCk7RWU1axo2kOmjmCvCshIKhsNwcGrVj9ktLTypVKo0hMhQfMpPf 6VzyTbTR0KVNWV+h/9H8Z7+3uLRRd2mJ7fzeGbjb7mtuHXPNFuzFDHEmJI04XOMHj8K/JrK9z6aN nJjbueIzIVnQ+Yu5WDjaM9j/AJ4qAxRSETQqHuNuxpsZIHpn0zWFZS5tNhzneHJ2NaF3ht/Lblxg jnNKhN423MwIzk7D5Z46ZpRi1GxalGNNKPYqxwvbu6SsUBzkfwn3otdLGoTMPMdEt2EjMvy7h/LH WtJ72M6bSSTZ/9L8rItQtYZDp9rAJI7cZkupUAWQngrj2x+tSJ9qgW7kVPtkpUvBbKg2IAPX8K/H 3FPc+n9rHnutjNmc3s8UDulvL5SyPFDIJVJIGVY+/pwadJMVH2WaN42VshU6N6VjGMoR5EU5875i fR7hYdetorjRBrenyIJZVeUxpBsdSWyAfmAGV/Gur1/xHBPFcRaXo1npVg85n3RMZL2VkBjVpWOc EDdgA8DFEk0yb+8jloZfMjNxJNPIw5CyD90mcDaPT1pw0woVuLeR3RssVU7wuTg59OalbalKfNe2 lz//0/yunyNluIQ4PJ3pkDHfNTw3En2iP7P8k0TLuz8qj6V+L2Pq6cuVmlOzPJco9zLHewsGmyoK yKQSdxP4dPz9cRrG6uI3naeVViO+NQPkmIPQntgVMkkmatRV1Hr+Z02mW0cscV55jMQm2RMY2kf5 /SryfY5bhJpp2ihgfexRdzjr/DxmsJJux00HFR5b6owtY1maLz7mSNoLSWTNvI/7lpk9SvQHrxk0 yMTOEQoyPKAVYrjcD0P5YqaiWhi5NNLpqf/U/NpdLlhmhDFIxtAEx4xnrzTnhhUMqPvdSdz9jX4J KN43SPs2t0tjEmuLv7JdQXaQywtMDbPCrGYD0P5//qpkzXc9rE1p5Mf2GICJZn8suxPIB6n+lTGN 3ZmLvuat3qFyIrVZ5kEhGBZwqBGnA+fHTJ9a07GD7TELzzQrxxERxzTrGcjg4XPOfQA1nypNjh8J hT6Xc2wZ7FRb28zs96Vbb5meScdPTvWxHZWNrAsQna5kmjD4Zdmz8M9a56KanK60/wCCczi+dvof /9X84reIx3iOjttwI2jf/VjBPT0NSeILqWV4USzhEa5ihuIn3KxGN4LZPTj9K/nqMOSTl3PqpTXJ Ytadf202nPZLFMjQMfOldhhyR0VfbnmsTSYHtGQQyPAgZm3IdzLnOR19/wD9db0431YJqUkvkaN7 r11MkdrBa2sb26CKeVIjGZAP4z6t71zKaPqFtdXUizOr3kglYSOdnIH3vatJNW5SrpQaXc6HVpBE iJhAsbjLQHcpIA6HvUtgyG83W8cxSdF2HG1sgc/L2z7elRa8SqMbNyP/1vz5uVtxd29vbR7GuXWO QyqOp+9uPpxVvUNImghtZbdoFguZWgmtIm/0rOFKyFf7pyRn2/Gv5/sfZqXvpmLc6VL9vbS5ZHjS KHzrxwu8QqeACexyRV+wjMMENtHD9pCN5cau+1p9o6bu2eOnrUS5lBqO50OMZzTlstSDU7ozzXAa ygtYhGEkhhU+RkDbjk89OSevNSWN1brZ2YMWzyZDIyOo2qOm1R6YH61TunZBZKsora42Ga31U/aL ObbBk4LxtFISDg/K2D1FadmtzZT3MizgrqFobG4Uxgs0ZOcD057isbXdjaj7tZdT/9f88tTaCG8Q vdTStb2axIkhJSJck4QelMt5IkuFlmnWztUtvtEM8J3vcNyCnH3T3561/PikveVvI/Q6q5qjbNlJ 9Ie1judIublpbmSRZYLzPnRYIG8HoM5OAPQ1yWqWE1sYxZ6bBfolz5xleTygufUE+uf8amK9+yCv GUcOieSO7dUZsqV4O0nHNW2u75YbO1jAkltfmeV1IMik5257Y7U40rp9zWMHUhvsQm8uZWV5oXt5 FcpKjHdjnGR9ayJNRtI9WuoY45ES0gjdp5FKiQuOQD07frTjScpRkuhMKb5nqf/Q/OC5kglSHy4E x5gZ1APz+uR07VFHYyXqXYESJCoztx8qc9c54GcCvwenFW0Z99iMO5JQfqZ0dldJK8Lwwt5XywrA /mu3TgHp6cZpbm0mgl8iSC62YLEtGUCuB0P0zTUN2TGjKMnV6L/hibS7a+E5LwursmQm7KBexPap iLnfcrfXYaGWQxswIEcKYChdw9MZ61aVo6fM2VPm17Fpbi2j02HTbWaWS8tLgsly0ymKeJV+6xPf I4rnLuR9Tuo0t0hEpYIzTSCJI+3LHgAVkkk7oTv1P//R/OpfDsT6dc2GpEGe8tx9lltb1JBEdwyT tJBBGR2rPsdDNjZyWs17Lc2lt8ltHcSB2tlJZmCn0yc/jX4M0nufoNmZOpy27aemnw2qG2iZgwww aYknkk+3AxxSoZr9rS30u9bSms7ZUht02mG4ZFAIdiMjdg89s0x8rvYhVpbOaWS8t/PmMTZK5KMS CPvdc55qtHfzWmlzXFlJIILlG+3RA5kwCSQF69sfnQUoa6kSWs9yICCy2scqE4Q4Qbh1/KrmoobC cRxqbyJZdo+XBcD2oG4a6H//0vy0GqvOWki+zxGMeWF4DIuOuKzbS6tJ7sQz3AjuZ2ItJWBMMzDn BbsOpzX4TFXdj9CcbIuXtnuaKe6bzVbMYC/PErL6H8ayZob+3vLKJNkVvehs3KNk2gXuwPrTimpE PZldTIruiODNlmcMflm2570xLzYqXcaEKrFQVBBXqGIFdVPYwK88r31vMbe4ZI40LIZVZUcjqBnu adZSNOsNvLuVVIyW43H2raMLq4H/0/yO1T7E8ptd8y5IVOdh7cfT/Gue1Cwu5ZmuvtRRrJR5Nu3+ rnweUPb86/HkrKx9ny+80S6suk6mbSdojbG2IldYzuy2NpIX+lNhO9SUVlQHbEVUl8dOcfhRYuUN jShg02F3vr0q93hYEt9m+U85DewFXoWIlmltUMkyxmZMnCgDt/Kpv752aKCSGXF/bXriXUFVZUAL pFGCUI5BrnbTULy41OMgrdwyyFIo5B8429A3PQ4xVnLOSUmf/9T8YtZg+0PFcaZEPtqzbriKMYJj HUbv89KvrewanaW1us7afftKI5oJQGt2C9Pm9P5V+RQdnqfYGppLrFDPBekPHHIyq0LBgxI49uw5 9KyL26axTbHbRNPJc/MvO4qT/OmoGLk3oUriOezh/tAu8U4XdFEv3pDkdKbp2pXV+syXNvA0KYKu GLXCt34/CpS96zIaurGbcQI/myyyM4VjGIS20p/dNbWlWiR2YFxHbsrtlQeS5PTd+lXyIy5fe5Wf /9X8X/s073MMTlo4baQ+ZGrH5gcg5/z2qjNqCWNxNa2r3EqysUEkqhCV9MA9OnrX5Pa2h9OklsRP aRu8czxKskUeQSOWzVG4MEMguJ4Y4IlIVJBxub/E+1A7dDbmngeSC2u9txa3umE5UkGInKqoPUEE c1z8tlCsAsbdipiJMc7sxdvTPPbFdNPoYNWdgF/dJbR2K29oH3c3smd+AOg/yK5+7a6me6vLR4Cy x+VJGAsRcggYx+AzxXfS6GMotO5//9b+W34x293aJdNYxzRTzRrcBig2PLuG8KvPY9/Wvlf4gTT6 1Zab/aJMBsMj7VuyzZGMMPYdK+MhsehWR4lbRxrMzozGFMhXZdrMBwDjtWrZlnuFIVVDrhGf5c++ f610w+FHDJWZ3Wh6cLyOayiEouWO6PZ+8Ck4BYj04r0qLw5N4Xs1iguri4tmmE18biPCmRhg7PQV RhKNtRkctlN9nRJ5Lllu2EIEfyPjIIbHbg9fSvt/4KafY6j4f09JvK0vUJJpEne+dIEiWMlV8vnB BCk888gVx4jdG1NXsf/X/lg07W/7Y0KRfEMum69vsooLlru0VZpljwFTIGVbjJYnnHU9DxRvmtnS FLa3toI+IwzZtrYA9x6Ac18HKPLiG0dUpOTbZ0txZSaVp8+r2k6xQ3+1rpx0kUDKnjt7V8z+P5Jd QupbrT74abNHIvmab9nISVCo2ujNyd+STzxXdhP4pct0jjrOTVWhk/0dGSzgMkjMPLSXHUfX2Fc1 cTXqkXc6yxpMCGTGCOeMj+VezT3KsejaI+pXlroVpfXUf9ktMXWWPbJO38IDKDxzxzj8a9X/ALCW wsRF5LWNxaXRnzcoVabcBnA7cE4+tdELcxcUm9T/0P45n126jmaCAIpgO1HMeHOR94H9KpzRieeK 9h8+SRMhvkJiyMFhu9enFc56NRLVItx3EF1L5Tp+/A+VQCHx0YK3qas3ejacjxNFbQafbwRhVt43 aQXJzyXdiSW57cVUXZnM1dWINRv00aO2k0+dkmDrKXhQuUHdR78YIrBuLuWe4Fyo3eYRuwuzzATk 5A6d6kwas7HUL4mt9Ptngi0xbtkiUW7PIymMn7yhR2BP5j8Kzru2gu7q1v7kg3ccLRvGTjCsOgx7 gdu1JtJ2Jur2P//R/jf054WeWCQFSrbAJFwAD0NXrqx0/TYktbm9iunmkb5ZJQ8RB5UHPcfl0rlk 7Ixb966Jri0ke1sGtI7WOOGTy3uA21HAHIA6Hg9BVu1gtLNNkaKsSfOixqIVA6kYHA5/nWTbe5rd GJquopLqGm2EMI/0lHu4WJzE6xnDP9RkAAelaDXFpaws2oXciBABD52PIiBPILfwgZ96Q9jB+zwz tqAR7draSXy2Ms2LabnqD0wcj867QpCdO8i2s7WxFlMEdLMKLLp8zcElskcHJ70Fz3P/0v5BjqS3 en39zKqiVoVjtjHtULsxzj6CqNmbl9PTUb/7MUjlxCiyrLczNzlinUdOvvXnmc9DH1C9u5Lu71Eu 7R3U0VtBYbt7Rgnbu+nPJ9PpVLVtL1Ca5s4bdxbW7So8t1ZvunRF5bCkADOKCor3S9eak097FNZQ eVYQxLbTZYnzdnEjMD0Y4zgV2UFo8trBcxGOWBoQ4VDjKnp9KCivJfQRwOFBhYttMG3bEw75NPis 9NKPcwCO0LgFxHgIxPXJz/nNAH//0/5B72ySEWkfmechmzO6NuklJGeAO3vUr3kgukaSZYreCNTF FEu+QvkcsO/AHH8685tLccVqi7INNsrq2upLuO5nWHLyK/zQiT+F1HTGB1rndX03T7uUXDurwFwj sF3SIAd2EPesXuDVnY2I9SsLK7ilt1uZoiBHHCMvsz0Zh0HTn0zVS88TX15dXMotHtSvAihOxX2f KD0HXGfxpCOq0y3/ALVuUEey1dbfzpZ7thC0IC5JPvUA0rUdRklunngfw/oVs8jxxtsM0skigOSf pjIPfpQB/9T+QVtGvdMmW+aeSCwkLT3EUMfmyhG5+5nv61u2xtp7e2t0uB9t1CRoUE37qKKPaMSM eoxk9emK8OC1uBLZG00HTls7PF1Kblg9wEEj3JPAA46DDHJP8qYb4xq7tcpZtADK3AIcjqp9K1Su 7CcktGJHc2GohbpZrm71OUl4bjO6CBVGDz71dtJdPiuLe61K3t7u4aTy7QSIG2MvPDdjx2qp7k86 TsZdgmo6UZr27mDx319N5dpIfMSRc8A/h2HTFEVo91BdO+yJ3fdEzHJA9MfSoE59j//V/kcFlFYP E9tPDkplgRtZieOR61rJLBBPEk3nz30tvuWVYz5MSrgBS3tkADjt2rxznLdvcywyzBYSnnJsaQDh s9RmqOl+VYzSWxneeKSR3ZJW+RCxJHToATQBXi0y/sr25VPIMTuLgtFIGgm3nc4HuB/PrUl84lug 1nHLFZL+9eOQfvBgc/LjPXNZRbcrgUXt7a5E00aBY5ZVI+X77IMZ9a1ZReeUBaeVFKqBdh4Crkbg B7jP51qB/9b+T20ifz8OqhyoDY+70qKfUriC8nt72GE2tpAJftDy/NCMnKhcdO/4145grrYfbILe WGcPGlveP58UynMbgnp9R0NadxZrdoqytMtsknmbkbart2470mk3diMm3ikJvSUjQLcCJYg2TheA R355rRnitvIZJGNr5kYaZUYI8i/1yaaSWiNOZqBhH+z7q2utKggiuJfJxiUMI4s8jHbJx71pJYQm yjtHjgaJFQISwKIV4x6cUmk9GU3aNz//1/5LI5re2vGtkx9ptfmlCndGqtwpVhwRwentWg9zcSvf adayJJLfWQV5JIgzwYYMrIeoOV9eefw8Hl96xzmTb2V9pMLC4uWn82TLSkbNuP4cVo2t9ZXSPDgA v8pIHyj6VoopFQV3qTx+JY7SSa1aFLlETy43uHKK56ZOD1FRwqH8q5QRxCSbZcNG3yhjypY+/Skl 77ZfJrcfqqCVolunCB5keIIQXYxkMAfY459RVqSKzkVT9rSIyHa24fxdgB3NStJmc4XeqP/Q/k8e wW4SRpC8UXMcErfIkrL1PsOlI2mW91axpcSBpbeXzlbjcNvTB968ye1jzFK0y89gyW0zLL5aSwnd Gh5IH/6qzWvw0QtZZHuzBbiCNGcv9mX+E+3f2rI3c+xTnvnW0GmRRWJikfzZPNULK4HAG49h6VeF npr2+mwoklvDHK0t19miDLAABt2jIGScntWc30JUmmU77U7+7uLaCFpl0qCdZrhlT98djAgFT0HH SvTPDnxA0jSmMNtoFnf39/bTW8t79i8q7tXIRfNLbcEDauBxzxnrnCSsmXe80/I//9H+WmeCTUnj gtb5bOa4OZbi4dYjkZLbmPGCKp3FgGYwytbThSYkkV1kRsYBIIrxYfCjN/ArEa6Z9hliYlQIl3R7 G/dsD0I9aDLJKkkF3JHHHcXyyo6J8qBTnDH0J6/hQ2luX8SsXUt01EfaINOF0LaXy8+UGzt4LLxk /UelZdxNa3WrOq6dGlpDAElSGQrKXxhsZHHIz+OKhtWaMdLWKml2t5YljFLFHJcXIiJZf+We/wCV c+w9e9ZV1rNguoX5kjjCITFNcGUESsvy5BHvUEVLWVj/0v5S7UyWvkzQsPLliEm5G3AK3QH0OMcV eee3uPNiF1HIyJh0DDehPQkV89a7ucySWxJFd6bZvbxOr3F1agSXSugFo69sDqehzmqSX0F5fuGS MSPkJGkYEeCTjAxx9KS5mjOMrWHXsH2eV3gaNbiEj7RHwshTkH+RrEuLyCWZX8vyYXjAjdRw5xjP 402rqxs5N7k8UkBIgCvNcfeXC5Cj1JrT+wX0ieUwMsSjIVs7F9c+w60RVlYSn7zR/9P+UmCG1jbN 07TSWzeZbxgDyIz0+Ue2e9aD39pFBHLbRkzyEq5K7WYemfzr5hu7uRBom3WVxAZbGKK1cgKyrwSw 6k+5PNUr3dbujOql2OXOcn2OPeqm7O5tN/um/Ip2+p2TXclusD7TGp89kKhXI+YeuOvX0ro3vIBF HaW+ZDG5mVvKKM5xg5Y9uOlTdnNF2auZv9pyfuI7+TYzOwgQZI98VllXttUJSNplugFbjmPryKQS 5fsn/9T+VL+0rqBprVbaO5ilia3WG4QjyS2dzZzx24x+eaS32W0sUd1kI67mjQ5UY/pmvmEruxzx 10ZN9vu3kkWOZUtNm14cgA4ORz+FVoo5X814NqPIfl2/dP1q1CzASUXtldIkwC7Qr+ZndHg45yOv U1tQzqIpkLmaK5w7xMoKKfX9afIkrBsZscKx3ReRGWFUIi2EkOcjqO1RIltetJGr3AcuyXG98JEu AF2fX5j+IqZRa1J1tp/Wp//V/lY0mzaxvBaG3jvLCNCttHduPILueXYdcjA7/WryX00ss1pcQwxT I5+WEboQAThlPSvmVAwcbJWGa/dTS2iyxbIL+CMLazqu/OzABKj2rZhkuL6DTZ5obaFZIxbu0T4B K8F3BzjrRFXdi4xVkyqDHby3KWcoJyY3kc7h77T/AIVAt1c2EazGSW3inkEMU9uRJcMwPP7vngep 960cU7FRVkTSzIqpKc3Blyu9l27Dz8xFZ51C9tbhY2VR5kamFMnziWOBgeh4xWtPcxqpO6P/1v5b oLWUS7ZNtjPKxVzIP3uc8grVS01mxFlfxy2zXFxG5RCZtr5RsHC9w2Pwr5h7nJo4Fm31hdY+xSLb qmyQJIkw2fc4HHrx+NdEjz2Yu9S+yRP5zNC3mJ+7bcp6EdMZOPTFIzbb0ZyV1LJZmGVHQW0j48tR /qjwMD2o1D+07gJHa3qQ3KEeX56gxYHY00r6A5vRMsSyTI5ku3DT7QgEQCRLgYJA96zLWKa3jnub O5eKWR9m8/O20nLKT6HkVSjqWp3P/9f+WmfUzbW8Pm+eVf5VyCzEjrgmoDqs947C0hLukRlkmkUg xAECvBilqc8felyks8s9yio25jt+6n8R7VZ0rRVmtZbaAv8Aabg4iNzLhomJ+ZeuCDyMGko2aZpT a5mu1ybTrSSKcwptQ2zklU4AKnpn61p/aNQuBqVpbMsNy8TNdxQygMU77W60O19B05WkUrXTYoNO 8qSdYJw5iADghEA4Jz0qHSJb4TXFpc3Q8t5TbWc1s3mrGvQEg5GR+VZw1Q7+9Y//0P5jY4HjE1qD 9ouVTE6nCvKF5/Dp+lcxrcUVzqcN5aQ/ZJJbcWojVixj2gZ3Hpycnivmp7gVra01K3k8yCWO5BjE MkciiLcCfnO7BPTsPQVtQXK2IVGQRD7gULyM98VBrBK1yWa0uba5iGoxr5zPvjI5Qr1Uj3xjp0NJ e2vnSNcecskRIja3kYFMDuBjPatIq8WRJWeheWeAWzoVV9zbiz/w4H8v8KgEVnJKqkRvEy73aQfI OORxyR9KzEk3oj//0f5aI1uhLcmDIt42LxQrHxEpABx3IyM8+ta1lpyNYyT26rd3axvILeV9ibuc AmvnZfCxRVkjZRoNH8Oy20ujpP4hmKyO/wBt8uyt0fafkAHJALHk46VixQpIHZpv3xwSvUY7fyrE ZCllLLfxyCfZGi4khQDa2AeSf5irks1vBcGJYVcyAqikEoOvf/H0oLgtShY2ljc5893ibzSUwmIW KnlWP1FWtXthboPKWNmIBVTwo445oNT/0v5bVjlSL7Q7bJVTagjzjJ9KyLW7lmku4LoyxC3csTMh VSvse/UV8rJ2Vhvc6RLeRgN8ioCgZYlGAQOhqnf2aOlra3CyESzb49q5Rcdz/ntWIht9bCAp9nuC jpgEBgWFXJdLYNb3C3fmSmMNK3SQn0P1/rQAs8ZmjKB9jOMM2dhUD0rGj1KOKKZphLbRRXBt988Z QORjkexoA//T/lqmu0u7F5ob5olP7tW24BboDz6dqtpJd6jpstjcXiy3USK8fmviSbbxkY6V8eBP ptnJYwPDN5TIpD5aT5hnqAOv86fLA0kF2LVY44rvhZ9oM8DL/cz/ADreOyGnZ3Mmza62yJLIJJoz 5atIwVWI459KWHU7+5kdZVht7eJ9sWyTzd4HDED3Ipg3crSSBL2RLQLbylBNI23d5wPG768V0E2p KmmQadcSSTCeYTRHZlEdcEscD/OKBH//1P5b7aW9ku7u2N0i2SRCS1uAdkynnfuBH0xVK0tvsl3c Xsk8l5cMdsMkr52YPUV8uBtrPdXm03CbXVtpYjbn3rYuzJLo0ulR3BZpYyqmQjeM9cUET2scy1jH EyRys8cgQYjYYYDHBFNvIfKsbhBKw3xfvQv3nQHJH6dKCYuT90gh1O0SxwxbEaKwjVeQOi8elPhs tW1CeIx2kjwy5+zjk+ZgZYqTwce1NK7sjU//1f5WppI7WYqzMpRtsisuck8YFaC6lbsYI444oVAO 8rxLIe2BXzah3B6IpXttLcXFxcS3NxMjW4jjt5H+SPAIyo/L8qqfY/Os47Sf9yI0IM8U212XA2r+ HTiq5YoiMm3YLG4EM0JWOU2zTC1JlBBBHGf0/WtIaUYJ2nUuSkhZN3yjBqiyH7ZLc7/sTYVfluAB nzBzwPxGfwqVLmHyERnXzA21UC4IPpn8KCJuysf/1v5X/wDSYLmKdA0yxg4t34Qkjgkjmq8epXdw 83mxPEFclndhgnPRa+fMYfEXrtY7uBsv+9ljwQDgrWTBb2sDxhUEbKuxnRsFx3zTW5o3Zo07CSIW r3bq8VpbOIo5yTt+ZtoBz74r3X4Z+AdS8WX5imiEcE9zHHbTltgxxn88/wD16zqPlg5djalBzqKC 6n7C/DD4c2/wzs0t1u7dZhabvtMUCtNdZQ+WQMEDGR0OPrXwx+2Zpbt4gnVbe0juLy3tbqW7kKLL cZhR90hUcE7ORx96qy5TWGqc/W7/ABZ15j7k6VNbI//X/lslV5Lry2QKkfcj5fwrq/DemXGo6zBa WJL3Uy7fKkB8qXPHGATx14zwDxXy8visd0U5SUUfoP8ACH4Naf4S07SfE3ifUrWO/wBVcz289wRb WcMysD9nQuNxSNRkkgZPtxXE/Fv9pfxppviS88OeHdV0YeGbdmilvJ9Ojunv2DYKxEDITgYJOT2O OK9CFT2GFdkm3ovxZ2TcsPzUk7N7nyX8QvGepeNtSF1qJsjBtRkjtbUWwV14yMHocA4PfPJrgHti ChjlKoTmVYxhh2Gf515dRylLnl1OLlSasNumjsoZZmS4uRHIkVytsoaSEP0ZgTx2P41btbu309wY maeJgdySoGXng8VmU1of/9D+Xu7t7+9FpJb28UliSWG/Pm5PoO31PvSizinTfc2ItuoSEkjGOK+P O9pb9RYbOJUxIAE3bWB6AdK+ofgn8JLXxvr8FrHcyaRbQWv9oXqWkKG9vYV24SIt0LkqC3o3HanK XJTc+y/UKEeeahJ2R9VfEfxr4U+EWjaNYadotydZiuWimFxYtlgkYEZA3qoAyCW9RXzndftLT2up xTHwf4W1ySecF3v4PMlkYjnzAoUYHuTzXW3D2UYpa2VynVlOOj0R9mfCnx6/xb0bVfC+leCvDiif THXU4dFs3VnjZQrZVjkbWbAOTyABzXxR8afgRq/w91tbuXTJ9I0y6/5BZlt3to7mFV4QqwG1lz2z xj1zVwXOm+qMsTUUeSc3vp8z/9H8KPg58J9S8b6nb21u32sTXbRTyeV/o9mBghpCOdqgjOOea+z/ AIo63oXwO8MaNHr+k2GuRNcrpsNlMqwrYlQoWSPAyFcsTubnjnqa+UpQ9tKUY/1qduJco009j5pt f2ndGuYr3RrXwPEmmyXT3F3AL6TZMc/KY2zzjAxjPSvd/hl4m+FnxqsLrw5L4bs7LVY9Hl8tH02S bUbF0kRciXoVO4EAn+EjnmuWph1SqR5Nkc9NSlB+8z5F+OXwa1n4Yavqc99cEWSai8GmSENbR3MT hWgLRHuQeoY9Oea8FaeJzbbWRmEf+lQSKcEkkflx+tdc42djkpVfaXXVafMrzi4DRi3j3BSFCA4R R9Pb0ptnpNzNdx3ZV5NshDuynGO4rE6G3zOx/9L+aO9F9Fe4Em1YJdy5GEZPT6/yrcs9Q1CJ2kP2 Y2rxNGCxPmAkY4/WvjzeLuiC0WZPMkmkVgXJjwNo5PSrkEK3UqQJH80pAIQdPfFKxtzWimfVfwW+ Cdx4hvbXVbm2M9ml1tX7UhL5Xb8iADGDuznr+dffXxZ+EfgTw38PLVrLRHh1O/WM3Wqm6DWtlKVB aPAHPG4gHkYHJxgrl5K0U1udTglg51FufjxrQubDXb6Ui2n8vU2S5kSXdgjkISOhx1r9Nf2WPhl4 U1/wHrevXtuo1i91ISxraRLNYx7YlaNA5GWLLjduPb61FXSovUxTsnY//9P4c+Id98MfBN41pr3h W0+0xXYluooV2yyK4O5mU/OR8uAOnJ6d/JbP4xfs+RzQ3KaLq32e63wKoiKy25U8bN+Q2MHg47da +MxNPl91btfoVSq1pSc+lyV/jj+z/bGOKHQruSC4b7Pf/bm+yXLKeki7FX5vXG0e9fOXxf8AF3gT V9Qa08MWt5YwlBK5vARFk8jBwQTggde/fvzQp8iSuXOeIqVFzNcv/DnjttpH2qNLM/6as7h3t5OI pschSPT2qeO3dZHhhKRREbEijGPLx/D16CtDop7GlMLpbBwkgBClQFODkdKiWAXtmrFLciCP9+u7 JdhyWGT9enpQZH//1P58raWxS0Dzq4K8eX0c+1NAjZC0bbI2XhMcH0GPyr4c64OzsUvMhmxb7mEm cBl4wetdFZSGONLVkMm0fK59cc5oNRrhTFPDJPKDv8yGJcFSe4+nFVLm6urWxJtbcPIHCMAx835i AOPQck0CbS3NC11FlZ2kjS1Z4hHIyfKGOApJPvUlvCgkzIgNvF+8xjJfHOP0pPZjP//V/BV1SaQ+ VEPLfJ255UemKjij8hhJEcIG/eQk8MB2/Svz89Ac8jREyRR/K5/1ajIGaa9/e2u54o0kI+ZYZANr Y7H/AD3oAhsIZmiea+SEGaUyKkR/cxHrtX6URpcC5mjEjFJWyjD+DAAwPyqG7K3qBfkuZ3cWcUaz qqiO4eYndnA+6OnemSCO0jkFwfJg2YlKr91QQen4A/hWQH//1vwftIbe5h2wy+bDjcrZ4YdQajWD 7TELe3Y2si3OBIH8rkMMZPp/jX5uegawljtLW5F0sdxcfcXc25Mg+tQR6m9jJHeRrJcbx+8tZId8 IHIIGOTnNADrc2qqkdtvKyrvkWeLyvsrHJ2RjPK+5weelSz2U2+OGzkM02PNYIhYso5YYoAlnlgR oo4lkebyN4Rk24PcDmnyzSJZQmZCJHQO0ZHzRZ7VEr8yA//X/DKylglWVzGAI/UbSTSWsn2kvJCT IsT7cKOcjrX5eegdLA5ihSDzGhkkYtJHJ8oB4Gf8+lYsl5HdzxwKwGGMUwIwHIPagCtlriefblBb v5cauMbiADketWLZ9QQSXC+WZFYr94eYMf7PXn1oEncV4L66jUrkhT8xxlR+NbFlK+mwIG2STINw 8w5RD6//AFqpRbGf/9D8LrbSoJr64dUkku712uhGGJU7OpHp24ro/wC12kt/sd2qsR8u9V3TxYHA 3V+aQTW56AwhFtY3hkMskRxlzgD61oLErNGXlilcIHKqwYrkd6sGr6MZdSRzWrlMJdI/7tWfb5ig 8498VnmYSTh5Bnd80kqgFs/SgLWRnxTyot0jq07vdL5TED5IwDnAHuR/3zWnEGiZJihaIsAGxyjd AB+tAH//0fxa+1sIpXlwxY4Kt1/+tVBDK+o258rzMW43JF8wQk42n8D+tfmkpaaHdb3riX9lbXN0 luYIlgMm2WKf7kbcbevHBqCWHCyQyukscbbCqANGADxjtWd2lYErVEx9tccvGJCYx+7jdvur6qP0 4rSZJ1tzMkim3ixvZmxzzj+RpW6HWk2tClZ2stxKdShVCFkCmU/eO3GR+Va832prk3FusJkK5bz5 BGjdjz/npQFnsf/S/FO+851QXIXfHKC5iIfIHYY61tQG3tjPPbOHjkh8oicASLuHUD8eor8tfxI9 zksrmLa3cMZljQlmLbiCdynHQ1pyPd3cq30qRLHFCINkShQVXgZ9T71dtbGVR8tBMyllCeZepbSx Jby7WldP3JPbnp+Fb32q7FtJLZXZhe4h27kwGjJHP4UlvYmDvG5j2zs3nROVkltwAZeXjZiM8H/P WrNtqhgZ7JUd0uHBkiRAQSM4IPY1DveUUNPTzP/T/F+1UXE08E77Nh3lHBCkduvWtC2+1QSSiOCK 6jlJERXGcYxgjPUV+Wq+jPVduS6J11CVLc77f7IY8gq/zvL+HaqMUdwFu7+NpZtsfmi22g5HoBjN EVuKD1syRdRiuYTHbmO3nZwXgAyqe2axoJ5bB7kSyEySzblLNwq9wB6VE1ZlRldXY+We4eQyyTNi WIJGQOYyOB+mK2Fa3ktxKJFmjjIV5E6Occg/4VLTW5SldJo//9T8hLQrqGneZZwSSxC8NnKjr5eC OvWsbWdGube5iW28q2jB/wBIjwdy47L1BB9TX5OfQQnabuPFrFNHn7pVNpQdR2JFaOj6d5MZVmeO 2bn97kM30zQVJpsfPut7n/RiZ/MOFjYffFWZNRu1VBBGECnDx4z9axad2kPmtGxn6hDqUjQOBLGz ASBXXaki+3+NXtJur6H7VFC3mKBuli6AnkDP9PqaLtyVzK1oH//V/IKCS4vJ54mjWJVw0sn8Iycf N/nvWlazXUd2vl3s8IiBV/Kk2FlIwV+hzX5Ly7nuxaSVzOgmddW8qCLyhuaeW4I+9jjr3PSup+wX FzGuoK8cymQwkbwZAQAc7euORWSRad9jKtbnXNPfUtPguBA9yA0d4FUyLHx8g9Oc5z7Vd0ZLhIb2 C8ggvULIxaSQ+Zx3/Hv16DpSCV2ixq9/pt6gshMbF2G77NaxHYxQADL9ucdaek81tbpHbTNvKD7Q vKqSOnGee3Wpa3HHoj//1vy2tNXURS2MwguHuIs277d7RMGwenQ8Hr2rLs7C7a6eaCXzUMhUyAjo ev5Yx+Ffi59Mr2ZqXVnHYSF7eSe5muSDIWYsoPdc+2T+dWJrqWB4oDGxgyDtU/LnvUz2NI6SSNtb ww20kFusUccxDP8AKNyjrgHtmuWup83m2KXZ8uw8/IazkrM1w8m5SuN1XScfZxNcpcQvCCFLh2JI 6DB9v0raiikW0h28yRRgIo7AAAfyqJRezLcr6H//1/zHt9XVbGSee8M0yTGNrGQ+WsIHAZT3z0/C n2erwufJFq9w7kDiJ9iBs5YsOOMV+GezXU+xTVmmXopY1R4ls0KnKRc7WhYn749R7Vj3SXFujCT9 4VO4EjAqHFozm9LFiJRaW9vfyItz5wKKPveX6/lx+dRb/ttxA6gQrFJud1OHQegHvWXLuQ3okjpV vVhgeGeOOaMrnbIclgRXJW80t3eoI4ysmXCnODGoBOR/3zUuNo3Jla6sf//Q/MpYr6OCV7i4ka0D kBJGx5h7le/HtVK1ura90mzh0u3e28q8kklSYtgs3G9T/Fkfh1r8EjBbn0s20rGnbwX6TvjyoUSI rIjk5lbjGPSrSC5iWSbm1l28KCccjt/nvVuPRhTTb1ItK+027pqLmOby5/mEwDhgMHDL6HitC58Q 6bdnVontbm6u72YPesWPkRRsP9XCo6EkZNZTVnc6Ixs2Z+sW8CJbf2a8rWd7ENkO0+ZaSRjDIffk fnVmwS7AVbspE8Y2xMrdVx8u739aLStrsaQT57n/0fzjtL8Weo4v7U3ENvIs46mOdVIJXcPXpxzV 631m+1y9fVGsP7Ft5rhltrfzGlaCME7WBPPvivwBK+iPteX37lY3Fxb3Wo7Lnz0ux9nnmkOWADh9 wHqSo61kPb3EBub57m4uLa2DNH5JChCM7Sy+9Fnexrd62LWl6qL2w+0eW7owyUkGFcjPfvWVFdXZ uJZLm3Mc8jEKq58kqCcY/CnFczsTeyZr2F7bG6ZLpntpI1LxoF3K+O3Wren65dXeo3a3LozmApZq y7IowMAEn1wen/16iycuUuOkec//0vzbu5x5M/2x/OMYbLIAGPU4H5VUuIrgRp50DxRSoFhByOMA 5Ffz+1Z2P0BTf3mrpP2KA3Sail1a/Z4ysW1QGLcEE56r9Oav39jPClgdPv5NRmubgyT2TlUitUIG w5Az0zweaSjqTJ+60VdZa5tI08s/6r5pVQbi/HQfzrNFzdm8tLixu5plEYNxbNEqKX9O5IH4fSmU nZk0819Ekb6lbywz3EjhdsRK5BJAJ7cbetNlv5fmitbVb7Siqx3MrWsYu4n4LEt1xnIwDVp2iVzt H//T/OGe8l0PUmlj0nTvs95pJjt2kl8xyHGMoOQp/lnpWZDfXdx9qgRzBBc24juLY4xw27+ePyr8 HhI/QXV1b7F/w/BJA13sliEFnH55uZJgJAQei985xgCtZNRk1NmM1wJWwSWlcAyADrk9elbpWVjn vdWOf1CaQuksFy1vCpMZAYKsnsT/AErKa5iiChiJEmcCTYCwbPHOKqys0zWMnflKNxOY3aztlCuy 7oZHBEcxOeN3bFVYEngsnilFvJJdSsWj84O6AcMD3+gNYqDe5ctLH//U/MOHTpZZ7Gx8PXeo74rQ 3EqCIHD/AN3PJx1wOv5U8WGsPJPb6o0mntGgJaR/9YCeAB6+xr8M5EfpBojTbw2sdm720m0+f9r2 gzKvocHgex54rnTp8q6h9qhmKiEl0hiO2N355Ptz0o5F0Ae81zcIWubqC3CpubzJBGF7c1UNveae ks0Enkoql3KnaVGMlh+FZ8r7APOoatMkhSXfJPIqvGRguSOGwMen606fUbm28pUjIux1nTJlYnrn P17UOLRLkkf/1fyedlthcSy25jCLmR9hDse4x/T1NIiRzKkayiGFV8xMrjyc9T+nT2r8LgrNn6G5 XViva6hLaRXtjNPJetPdrJauygRwRgcle+ScVe1G4PkQrHmUd5MbduO1aGM3ZWMfUZ/s8dnEtsA+ oEww3CYaSMhST0PHT9azLfUTb2aac0aTP558u7Rc59VJ+v8AWtYLQxbS3No/Z71JrS9IijiCw3oi IJt3Q5baeM9j74rLvNRT7Sgt7fMKMqxMx5mAP3iOx9h7V0w+FDP/1vyA1eE3l5DcRbYkMYBZpCSG A/lULyNDPDDIrSrIcEsuUJ9P0r8gs2fbRa5maUVnYXEZk+yiKYHbsZiVHbI5xz1rMlnGn6h5CK32 YwiR5cDCMf4al3tobT6E6pJdTrDZPaRpK2bqe6T7q9cq3UH271UuWgluF0yyuzLLGAJrhAVaP1x+ WayXuvUhSfQytZkeyk+z2kRk8xlieQnDY6FqkfTlyBbXLBmjBaTbtaM4GcfQ5/KtU7q5hP4mf//X /FSKe708TvI0wGDb+cvScEDPNVoBLLFJ5eFJ+ZXYDc3rX4+fYF+Gy1H7IbuSWOG1ZykJll8tpXXq NvXA456Ut/IsdtDcq0bFNqz4kBwx9O5HFbQVkYNWdjTs1/tO2hubwJJDbT7EG8GV8KD8o69DjPvV S21bTNPj1CCztguqT3BMRcbl2YIIPv0/z1Si1K4jFFtJNdzTPC8cbgPuYkB3Iwf6U26vHt/s8WWE cWTubgbieMf571YWP//Q/F6OzmtkvNS88GxAVrq48zd5XHJIrh5pmvLnEAkZDJmObGCR2Nfk59Qb lzezRpbQbROfNQTXTkiRV6Mv+fT8K6dkOr2v2a2s7OJeJGedwqoF7gn6mmk3sBzKSW8RZ7hgZLdj bwJnK4Hp+OahguhLPI7FTEFJfd8uR6f/AKq6Kas0jOa6mDpUN3q17NbQwhVgR7hT5wQRIDzjPTHu ax7yU+fc2VlHJPMoO54lLvkA5PHXoefau+l0Mmrqx//R/lr+J2oW6SQPJcTxXIdhub7gA6sSeOuB XyF48tr9S6N4iF9o8oWSSDyPLnEsn3uQOcdM18bD4UerOPU4NIrOaH7KJBFtYKXC8OP6fWq+oW01 sqRqZJiilER/lVR7H/PWtYytocco20Z1Xhm11OFftkF9Np8ptz5s8PzSKp4K9xjnnPpXrMms3JtY tJvhc3NzDZiZ5l2+TdD+E7Qcq2O3vxWrWljnas7FGzuJ5hE+jRqJZJAp8xdrwDqSVP6j3r7F+FE1 9PYOZopbxYIA0/nQkGzXPVAOoOD6/eriqq1kXRXvn//S/kd8Lv4kgsI9YOkRHTL3TkjS0ukaK5YO fkl5+7nGQT6+9bF/bxRRxXqmCS7Ey/8AEvfd5UuBlgxwAV7YBr4Sf+8NGkZWbuQWs+qaxYNb3vk2 WbhisUH7u0jjU4VT26V4V8V4ZtJ1DT3NwnlyOILd4lWVJ1VSEDY5Ujb0PYCuzB/xWauWqucD9u1a 8DyXN7KqPGFghABWPH3VX6nn8aqXFve+Raveyz3Mtw7Owl+aRAP7x+le1TWpbnp5nT6HBJcRCOK4 PmZxBHGOYyMc57Y4r1k65qWpOun6s9zdTWlvEPt0ifJdNgAKzHrjGc+preCuy4yuf//T/jvuTZzX EdteG10jULG5TNvGxml1S3DZaTIyORxx+tU9QgvrWytriwkP2Zb2VoreCcM7Z4AYZyOCPyrnO+Wz K0N7DbWq3L2kkN0H3SO8gDxjB/g7/wD16s6v9i17RzFa3rxtdorojqHmtmVgWYDtnGOveg55aJla 61mz0+WyuLKyv7x9NulmNp/ZzuL7y0w6biNpyT2qrb6kNbuo7Oy0+6s57e3N3fQ3CCBrJnOQhX1w M/hQYEV1bpBLZLHLcPJLIVacRbk+XGQ57E5/StC4EXnEoxaYxjcpI3bugP04rKWkrnOf/9T+MkQy 29w1zqVy8p+6luyhIoVHRsjnP49ql8UWNxFaWEenWP2yaaITtJDci+kjR2Hzvg4UcnryOOlcU3rY 5y+zz3M9gyWGpWvh7S/+Pg2cYn07zBGgbex5ViRng8bh1xWykn9owXD6dEzII3IBPZQSee+OfyrN uyNUrxRi6XGjRQCDErWoKLJIN0kIJywz2z3FXNReKbb9pgjuEY7SCPlGP7w6HoODUKfcu3QzYbuw lDWUqW6wEgIiqDCcEYyOnBq/pmt2vh9byHV9I+0RFt8Bs7hme4jA4QcYU59Rx6mnGTbsXNWP/9X+ OJLe9mRbyeya0guRvjgk/hU8jGevHetLS9Phu5IYHUEvcAQRZ4UjGDXnkTV0JqFtbaZcXkm95ZDI GEMhwIzwpA9OhP51asrx2+zTiBPJJKCTO5lK+ooEpKKszM1+ILf6XY6a0TW96j3dwEG1o5M4CuB1 J5rT8N3OqXss1va5n06BvKlhjjJSJgMEMew4zg0FtpK5PJFFPdT2jgZt186RSOi5wMUy+tJW0y5S ysF1KUAFLdZfLMeWALHtgA96ATuro//W/kBsBMzJLK3lNCdjIfl24GOPark62+8KuFdsFZgnzg+l eXPsNO2xWuINJfVP7Iis4nmntg8r7yS+Rkrk8n6e9SHR/tqG0VktfKOLdPMEWQOB7Y9qzESWttdW k1zEyWbx/Y9rM7AbdnzFt3QcD+dZ0drcPBdTBo2fzcxqJAAxz/eoIlK2iL1vqt/rVvcy3NtBps+n xi0l2Ozy3u3C71GOTjHp0rn5L7VbNJdHgljlsJIkDuzsjy4bdhhkYI6fjQPm925//9f+SXSTqGpQ XRltpW/djzXiRmiCAAcjsBx19Kju7yyeLFpZpbzWMP2Zr2Jd5nOclu+D0HHpXixXLoYNt7j44Tou l6ddecl/cXchHlxkK9qGbrjt1ziopLfTke5hvtga7iZlJOxSzYG70PGeDWkXZ6iKzfZ9NtbWysFe EDcJriGLcSD0HPAxz+dXtKOnqt1JNAt0seDYvPkPFICQZNvqBkfjRJ3egF/UNb0y2tRFqVoZ4UBa FwnzQORgOK5KOyeWX7XpSS+SsfnFISWLIOWPNSB//9D+SqJRdQ6dc2ixNubzHaRvmwM43IenI79j W1HPcTzT3b2EQhhJefyshGOeQo9PYeteSrWdzlk+VFJryNdJnv5/tUSSXX2e1iFu0mWJwR8uccc/ zIrKH7iGaEIHkuoS0Dg/OXIOFbPcelSRze9cvWxlaxiaf9wYCE87OW3Djbn3/rTIrkXIbNvLbzMx TcMHAQnk+zenvRY1C5uh5KeU1qjJIAkC/wCtfA5Y/wCe9VpLm4sJ2vriJZIRDudDIdkY/vHoc9Ti gSd0j//R/k8srlJAoilsmN0PMQ/aVSRe+WBPBwOhrF1y3huIr8JOgbyNomLbGcng4Hfr+Wa8cwTs 7lnRPKubXT9DYsPsdmbm5maMspVecgdB07elXWvJLm3EVtcM8asUQ/wjHHH5UA3d3MKcXmm+TNEJ isswhuJdpdId2fnx6Z70+/uL1LiFJEOoKqbfNPHsB9BQF9LGvpElzpl5dSxWEkqXdiYmSWLcsRYf fBPcA5FJDp808tuscsNuBKz/ACjYs/X5frQI/9L+UKfTrODULW8fSECW8JjnnhZlEx5xlcnnkHj8 qas32CYSABnKjeGXbJt67T9K8c5zQuH0m90ma/utQa3iinVBZzx7ZWZxgbV6nkVxh0K8aV4rWVY4 A3mKyn5iO3HXNJuyBabFZdFmvnjspGEc0kuwzOfLSHBwGc9h9a3Fim0e1/s+LTrHWftd0kd88t0R 5SoceavGGwBkD6VmpWbZpGV3qExWWWciKTLEeSmMGEDoAavW+nJd2SvdeaZI5PuiPbvKn19enSs1 J81im1Zn/9P+TWVLsI0DHbbOdikjeUXPH41ZtwyOQrho0xkucMR7CvFlKyPIe5a1G9tp5VjlhNvD cQLa7olYI+Bhix7dzWhYy2LtONK0GDVytstu1rbzNHcO0YxkkZ56kg+9TKXY1crSscvJPpgc3F1b LE3MZs9nmzxH1yMjHpg9qtwyxTGKGFvI89wm4r+Q21EpXZF/fBJ0trl7DAnvPKL3JK/ulUH5M/UY 4rX0i5tIZbvUFt9z2kDeaXiby41YEFs+3+FZSe6OmnrVt/Wx/9T+T77Yl3PbwyvcBZ3/AHEsNuW3 8Z247Agc56Cpk8M3iRS3Fu8SY3uuyYmVRz/D6n0PrXiwVopGb0hZjNKGqXl/CtzHNcxWkXlRqh+V kBySQBx35rQu5I7o3drbFUdF/dpH86I3bP8AWola7bYS5kl2NnSZNcfTRNJaRLLZKIphZyfu41zt DDgHnv8AXk1yN/efYDMtsJXvm+dlkiIiAz83NLlfLdGaTS1LbXzSwQOUQSugYQk8EHGf51kyroUL fZbzRoYmvLlYrd5Rst5WI3MAOgqSZLQ//9X+UL7DPCqW9jJBFDbuR5OdwI/2TzkfXis+PS5lnaRn NqE/eNLHFulbBy2c9uK+dimlZnLJ2Vi1Lewm4C7AHkAQFhtyue9RwFrDWLyO4ikybVLqB4k8yFFG R98cA9+tNGNidL20mmmuIHRblEG6WRMttzyoB6/T3qneBbuF3u5vLkhUvaFEHlr6AjtkVSTkxt3Z ZtNTtdNispFUu6LtuJ5FG+Rsk8r0x2ruory21eJ5Jr62gmaMiOOIeTIy7c7UAGCeKRpGzfmf/9b+ TW3sjZ6hJc/vjbPKY4/PkJweBkDPT0HvW6RHGpRI1X5vMLHk5PpXzTjqzBaM1dMg0qCOaHyZZNSu 7lZo3j5iUYwRIPfA/KqmsQTMxu0jibdhMLgZ2jHT8KJ2vdmsn7jiY9v9nlDRzhkzhwI1GVZTxn6V ZtdQthcSR5mmdDk5X+dJRb1jqKMfd2KV9e3L6xb28VkGs2InS6ciM2hIwV29cHjmuj2fZ5I5Gkhk uF+bMb5BweNv+NN03FXZEZQfu9j/1/5X38u4kErAowO0k8KSfU025tJ0ZEP2WWWRhGB5oHlqehJ6 Yr5mMW3ZHG5KEtdkZL/Z7RxLKRMBJ5SwDOyRs8DPvXVW0EQtJ76O2htI4wJLiBDhI88cZ61tZrcc ZJ630OT17WIzcixh85rdVVvOMWwydyBnsKtadqEX2dWlR4kOVDMpUSAUCnJbI3FuYijWaQC4mul3 QMmWMSjkk46dO9UbCa3g+0veWzwQwSmPesLMJmyBkjGce4zUyV0OMr6H/9D+W3UJRG8MlqoKnBPm HZyfb8qyb2e7guYZLV0DupWX92JMKeoAPHr2r5mKk7pmabckn0LFtC1sIrkWf2i5kYqJZTmNAQck qeOOTyKnuJ/JjcW08UsM1oQ0TR7Vgc5ywPXP6UKLUrM1aadmZXhqGRLW5F1cTTyLISglADBefxOf 6VfmF9DfWfm2MywMjNHPJERHgjqv+e1aWajYRZuZgFRHBcA8cYxVnXbxtWnt2lhtBDbWsflSQx+X MjoMckdcACqp6bmFTqf/0f5Vo5p5XmkeSZsKQkmC7Ejv1/WsKxtjpjKiQfvorozC7kJdirHO0Z4x nmvmWve1ON2Scep0VrY3MPmN8xSSQyIOCVz2GP8APFdDKl62mvYzajIhEvnQw48zr2wfQZH0NVKy joZmRHPbCKS2uYzcSoQUBGNhHOa0Lee1eFylrG7Kow7AmVfYUoNK9ykk07mbLItwCoJEpJzHgjaB VmytA4IDwJAgLSrM+Msoypx+f44qoyu7GsUktD//0v5cmkt/EVrHdfZliSOU/ZYsFViZMozYz0Iz x7064hh060a4tp3WbyWiuYAuIXBx3rwVpdnPs7ozjMLe3jknV8tgqkP7xwSeOlXLk3EqC4tLoWjR YZmAUtj1Ge9C6IqCVmyna6m9hHcMuZROvzzbd8o5BLD34ok1oQSNPY2vnTra4mZ/lkbceVX/AOvU J3uOnox6W9rdpLeS3RhZ8Ga1LnnC4Bx7YpdHX7FbzQQtHcRTXf2mO4CbZEOMbc/56VCUkmhXtK5/ /9P+Xy2iN1NdTpvN5ImGuMnO1c9fzqlKZoQyzBHnBHlqThuSOfyr5h36iTurk1xcwWiRSMxtyCMy 4yCxps8DiAPKWlYx7o7iXgP1IzgAcUi4y5dB7axdvp6pe2hlFtD5avEpdkGQM56/SqFjOt9EblYZ rdN5hZZkKOSvBOPTuKuDtdCbvuWMiRy8BLRocMgUjgYHT0/xqWDU7OG9lsbuNlmWDz7dI0IBB4HJ 4/DOagE2tj//1P5dIJ4rm4uDaXVwpkAST5QsadiFI6570yO8fS76K1MB8mUNNNcn93ABkDk+p9Pa vnJ7AlZWL4vobyWfzkZNPj4W438yAckADnpWx46udEt5dNfSITHBd6dCt1JEhCWzogB349cdR3NY 3A5iNbiW1jZd6pOpcTEGJtuOnPNV3nS2h2S+bdyRjBBYIz/jUT3sVF2THsJLq3MTLLpqzDfGmfMd e4APvjrUlzqCRrHBcrLLOzhUWOFnROMAsRwB9eOaqN7alqd9z//V/lzSK+ilUzxeaj4ZEH3Fz/tY 96p6tL9n1GGCRQ1wV3MyYePaO5boa+TlF3ugNebV1ur5PMWEFI0jZ4lCJgKB0HQ8Utws8dyd8kZi 274WVtwIxnFZgcuwsr64uHkma3mVwyJGvMxU9/yrrnH2e2SaT55ZoRKGPL7Tx/jRYDnpdRAdU2u0 Z/5abcA+1TjybvTXdoHmYT7Rbyx7MAHAdge2f0oA/9b+V+IW/NkY4pRG4kaNlyik89KpXGoTtqcF qyx2DsTHFPbqTEo7FmIwD9a+Rja+oEk8zxX89s0xuo7dV864jbzOvXH+e9dPaXkLQkwyeb5YwsQX nnua29BXV7Gd5UIivNlusUtxwCp+dDnO4e556+tQtYR6fpltc+bEHiBiEcv+ubGMsw6fN/SgTklo VrCOa5mdrSRLi7urN0+zkFBAsbeYWJ9MD16CtW0vGUvHLbq9t9nwHbDKjk847+4NAnJW0P/X/lhJ 8ydk+6vTcOjD1qcYjYqhzt6V8uTzq1zVsXMrGN2Awc5Y7QKdeFXcSWMyeYg+WXb5ixnOCD09KDNy uZmt3t08E2pXL7jBGvmeUg3BUAUYH4CofMmljh1dJ1jg+y7TaOu9pAV++eOPTFNK7sXT2OavIZJ0 FzFE0P2mLYzbSr7Owx+NdFbazfR2dtE9xMIbVSlsrceVnrj06VpCNiz/0P5WRb/2jcIGkzmMsZdu SMDOTissW7fb2Y7Y4oFEYbdnzST1A7dq+fDY12ivlinkceb5QDBdwEhUkAcVALi1hdd25w7hc4O1 fX/PtQG+pfku1hP2qBQQGAijdN6k+pBrd0eW68R2cunXZt0uIw0iPbDyifQeuOB+tAm7Iw7ixn0t jHerBaKHBaGFjlscAngdaqDULGS5ljjA8yFA4by/3Zz6Hoce1VJWdjKTuz//0f5ZPtUOoO6T3Bh2 x5cxLgtwcAfWsQWk0ssaJLI0Svu24wo9zXz5lBamhepFZ2k88ruGTG/y0LkD1wOazlSFXt5VMlyk eDtD7TNxypPr2qofEjWx63eN4evNEsYjp7wqiRteaXcvucuCH3EjGVJUH04xX1F8JPjX8LdCjsbS +8OXk+sxXIt4bS1vGtbR2KqollLRkjaw4wduMZ6UTitbq6NaEuSfMfo18KPG1v47twttp82/TIVe 6lmbzo4YWbywQB2U4H4V8B/tuXE978StatbJY7qztrC2NirIRb3QjhCN7BsjGD0wK3w0lUp1OVaL /hjXM2/bUW+q/Q//0v5dJmaSFHkTy7hn8qODG0oQOA3619/fsefD7QfFWsIdUsFuGg0b+0Y7pZhH JKQ6eYqsVPRRJ8vGTjnrn5qyVROXc9ClP2NWFXtZ/celftgQXHh+z8M6PoM0UdtpfnT2slyRJMEl yCuwcBvuZ9s+tflwzXb3U63N3PdzOzSSG7bc5Ynnb6D0A4HQV1YqGsVHsYzrzr1Z1JdWZ4LFJWW5 jmeCXZJGWBZT6cdMVpWd8WjkjjgjDFxI0mCZMAEYHt0/IVw20sxqTvqYWpv9ourqZYWzI+6Q4IVi Bj+lT6dj5FIJkdwAhb7gyOR/P8KnkRqf/9P8jP2Uvgz4F8eWtynjK3ec39rLBpgIG6B4jHh9rKVy 2XKg5Hy814l+1T8LfDvgPxXJB4bu7q10mFxCyzSokg8pF3FNoAwzgjGBwMdq+VjGDT7r/gHf7SPN 7LrufMMc0H2ImMiR5hkBjt3Dp/L+VbGgeIvFOi3lsuha1qFhcxMTaXNrIDewFuqxuckDrxTSsrDs WfEfjTxFrk8S6xqN5rN87lLi/wBQn8272E8jdj9PauLWxa0vb2/gmkk+1JGgt5D8nmDIz6jPApnP ZJWR+k37BFv4kbxNrUOoySpDJpjx+dBP5Hlxl0YKMckAKvXue9e0ft0WutX/AIXsbW4cM2my5tLy 5LFJ45WjKkDrlR1I9DWmH1lNdl/kc+OjeFHm/m/U/9T85v2JLnT4MebAUmt7n+zryK3iLrfqYSJG DdcEtFnv8p9K86/bp0+TTNRisLlAIHPnxrsZoFDxI4YZ5YDhSc8Fa+UwH8eovQ7Myly4eFux+d+j 2t2Tp7GOJbq5i3Ri2JYBW/u/pn6V+n/7GuiXek+JLbWtd0aNo7iKOwlueWknjyxGIxxzlc9cn9Ix icGl5mODbdLmfY2v26DFc3cFqI7M2160s9lZXWUkiVVhVAo68Hc/tg1+VqrPBH9k1byXn87HnImF IJO1R9OOfauirdQV+x51GS9rO212aEc7287KltIywoJCWGIpR6BvWv0D+AH7M9n8Sfh9qXiy58Wp b3TJLNZaNp9lHPv8qNX2s7kA/fVMjjOfQiuCrV9lyq17u34N/od1NpS94//V/Aj4yfDk+CfEt7oh nEk8bn50JaMgBSBj+E84IHcHk14ibnyoxBwiQHEydl9ea+SqR5J8nY0pTjOmpx2ZfEu6azhgDym5 O1ERMhDjvX0h8FvhTfeJrq6uryQWcZJhtnlSQQhCIm3PuUBGyxAJOMDrzThG8lc6GvcR+p/gqy8I +BjDocV/bTX1pDbx7rYrdBy0eHYMnG0nABx9a6v4y3f2z4Y6np9xE7Wd08Oq2uDsZzblmcp3OULg gVkuZ1Yyn3OivPlw0o9ND8PvEGmaVe3d9c6WGW3u7mS4YQRnezPwWI/vcAfhX6//ALGtpDB8MUsb B2aOaZ5zcK674/LgjJZwegLZXI9MUV1aqvU57v2cmf/W/Kb9r7XU1Pxzqkk8dvHe3Uy+SqykFoo4 1Vju+uVx3xmvjiSWNLVMxRlE+ZUIypOeK+Sxf8Rei/I0otclii09vcPE11bo6DiRc4/LIqy9ulyk kkbIqR/89GA2+lcnkaOyITdTW1pDDbp+9efDSseVQj+H34/WrFpBdSSSxnMO1dyyM4y4PcCgqEkk WJZphG6YwsXy7hz5nvTtGEOQXk+Vm5QnCj60Ce5//9f+e66szDd3CZDozblVTlBxxt9qj+aMIrEA ngV8Qld2OqLsysrW8MuwoXlLruaNc7ATjcf89q6ETizVixzuGBx0pGt0c3f312LyCWGMC3ibczc5 cYPSumsrxrqDz44CsTAqZ8kMSOq7cdKDOTT2MYalp+uWlxb2rTRytM0TCWIwtmNscZ5wSPyq5DcX 0T2yJKPlBWS3CBhNxwMn0pPZhGVtGf/Q/nunu7u1nnvAJZm8va1qjAIpHPyjHWp31C+hltgbSTbc gONykFRjODX5+d6kjSF7fSlQ8MEO19vlxschexOR19v1pl1DJJiZRKcHBbkKD6elAytqN5DHaW/2 ZbozJxdKyjGfVMcn8a2rWyDQqz3LxsFEiJsy0nTj2rNJN69wLd3PIkaS26rh2ChgQrEjG4n6A02e 3a6spTu3MmJJJOPmHdefWswP/9H8GLPFs0G1AFxgonC4HTpUl39pJElsUUGXc5OeB6Cvzc9AWQH7 JsmCNJJJkuMgqPzrXR7dLZeVmm2gbBzgDjmgaV3YoQXUn2pMxKYFb5weCK0rd7q01Bb6INGzgpAV JI2+goEQxzTalq0sTSwQywAu7zOsMZPJIyeM+3vUs1751uciLzGcptVg547/AK0WA//S/B9LtE3W xUmUn0wmK1tMv7e0l2oqRd22/czX5i4tHoEmpXv2mRr+V5vNQBEiQbomUd8f3qS8097tY7y2xDLG BldpG8D096ag2gHafdWyqPtzKblJtqknGfQmrV8IYJxPAHRQm6Y5yhq1FR2ElYZb6siWsro0wjbn YVIDc9cVmyWt3qjpLb3AQwsGeCSQxl19j6j0qhn/0/xKtbl470fYbcCeMfZiHQ5JI2t19c544qtI kelXkyyWjEySATDqQTj5hX5uenG3MiXUIr63tkvdHMU0Tv5N5FLscovXdtPOfT6UugWMzyNePFO7 SERP5eSrAHIB/PNAT3Oi1W309YiYoWWckBWL5ZcdeP8APWsG1dcSwlRuAyJT2x2x/npQDtyJDUjQ IZvOQScrtXPT/wCvUsOqo1sbd1cCOTJO3APoaw2bKmlY/9T8NZ72NGdXkyHcDB5bk9MVc+3z6fLF eQpgCPaQ2QJc+o/z0r8yaXLuegZ/2uTUyy3AZDMcHYSDnPUGtu3ju4LW9SQiWIxhpHhh82YKpBye Cc9OlRsS1qh9tbLMoiRo1gLbxuAiYsfUHufrUup2Syoltvzb7d8qJINj45Gef0ppXOujLR3K1tqE UMaWlnjyA+CnUJ2xSy3F3PcLbwWguDHKpy7bV54I4+tFm9ioysz/1fxVkl2pcQrCXuYW8qU4yqHv g9DjHaqwDK0qq4upJIgAiuQi8Z/qRX5fbU997DRo/wBn/wBKEhEkq7Uj37tuDzxUf9q3UaC1ZQhD Z8xu/tjv0qlo+ZnLVf8As6Raitl1K3a3knd0ml3PBkqmR3OKuzpLZrHCI12giNDnCHHUflWSdpip r3LFeUOb+OOyQpbCQPNHn5RnPHv1raurmwgu4poYFWQIOIwcRkAAiqS1bRdOzjbqf//W/HCaeCeR HljVGcYjxwwOOprLkub6xuBGEcRKwYTofnBPTI6ge/vX5cmmrnrtK1i0X+13EcVw7gkbw3Xcewz0 5NXJRLpl2YpriSwkSPEZXLM+RwDj1zRdGOz0MTzBaXJQ24Dv+93lcNJnkH8aaLyHUbqa2eySNlt8 JO4wjkeh7H/GomPZWK6faJ5QymNEt0wu5cqSvYjHtWzpct3fabembTxbRCbyobiPiFnXkkADGcdv elJ6tAm0tD//1/xsg1CfTbfyUjyTJvwOFY9MmoJLzUL+TzZPliXueW47V+SybS0PVctLovwzrawr JMN753occe2ary6zq2syr9vuJpYYwZba1djiNSeSB26VRtzOxsW99IJERIhvRPMikAyUI4PP5flW fI+qTXMkcUyxyXAKu7DeEz359MUdRXb0NKzursQR2epTC4lto9kV24EW4DOBjpWXCDNqFzNpcn72 OPdMrOP3m0c7QTz16DNRJr7jV7M//9D8ebLVNzySpCYbqaFrWaNoyMA8Hg988irEdmLEs8iky3GG lctl34GCe3THSvx/2t3ynsLX4SzDDFJcAnzF2YIyMKQewNatrfS2eoqkLQTwKFl+zu2DgHBBx64o i+b4TSzj1NF7lbuSWX7NbJIXIR4+MZ7Z/wA9Kq2q3sckyXESRgnIeI7lwOOT60nuVFrmsZlwFhl+ 1QsVmjmDpuUEcHOTn+VaFnqTXLBzArSq26Sb7wlyc8g8etJt8ppBq5//0fypttSGm30kS2dsq3IZ nZYwHG8EH6dc0kV/Y6U6RZuLeBo9vGZXU89R79zX4ufUCfbFSQTqWYs37sYyHNPae4MT3EwO0EsF UbpFA9B1rKe41o7khht/Jt7t7gYnO1Y2fbOpAH3kPI60zZaxrL5sYkaU7CrEgEf3hjvWsrdTSOkn Yisru0Mk7G2ab7JEVsVDAIGPBz37UqatfwPHcxRhtjEvHtycemKUo6akyT1Z/9L8m0sft00BnDw/ aH8wM3ykZ9f/AK9dQZZ9AmvbZJ7W4tpYk+zzxtuZx1Ib057c1+IRV3Zn1a+FopXd02+NJX2qyeas kLDKEjirkOpxStFp1y3mPNAfL8zCGTA4JJ4560mlsQaKWsoiSKPy/LVtiMXAhBHUBunp+dZ9zMlk GAjhJ5BYn7xPfr2rKSsk0NQlbmexkWwuL6+htVuBGt2wiEkjbIo/ct7Ut1pWqWuoMkcitc2iMsZj kBWQDncSOCCBWC96LQRi2f/T/Mqzv7u8gjvNajEzaePsUdqvzW8qBRlsDGCTmnx3ceoWMstroyaX Z2dx9kiMfGVUZDcdM/pgV+D8yjH3j6aorNJlhr+VDb27WxP2hPMQsNsuB0J9jTbRrrWHeFkkhmSU xCGR+ML0wfTFVay1NqUVoWhcWdpbC2uiQZJdgaNTJjHB4Hb3qvBaywSTSQSQIC26N1YbiOCM5rN7 o15XeyK1q8cdyJy3m7nK8nIVu+asXV7cAyKLcSjH7sLyGPvRdWsjRRs00f/U/MM6yJ4JInjMLR85 OCD7fp+ta637yabb7lmtldA6OAdj84BX1H/16/AlaLsfcHK3l3cwveW5hlCSzRytOj8uBjI+hHWt WG+mk8u3tLKF4nP7tZXMe/OAd2B2px96VwNea982XT9Ot0jjubNlgngt7dRAqqePmAwxPQ5pr3US 6p9mu45JPMuwn2iBM29qo3Fun0/Pijla1QmtLEV3bqzPNIxhXJCyY5UetUTbyW2oW5S6RreaIOXV CWIPqD06Vk4tJtmkXaHK9z//1fzJjvJ5NRmjutNiFuIitvLHK2HKngsvqR15qpqF7e6gxgWKXzY3 EUKZIJAxjHpX8/RTtqfoEIte7Lc6/TpIdRDxamFjkMSW6TM22OHaAM/kMU9YbHSftTDUVlujL5k8 TA7myqomwgYIIUfrVLfQVSL2MmSea682SBGcEZeJju2Y6kVyseqyQ6mLeJLiJx83mqhwpFauKNFG 6TOwl1q+Nq6XhedHbzfNl5J6jIPX15rDW5nCyxWglDXODhB8smDnmnKEuXREcqlLk6n/1vzRnt47 iOK5aJJWgfZGdw3qcc4HWoHtNRdVvbcW3kQSM+oTvL/pOzaAqlD2yRyPU9a/BYKyP0GpQnTupqzY yGzluI3Nvl4pFLXAAIVFGMk1hTHzmMaAotv+6Q42jj0FdSVjl5bO5FeKs9klvKx3I4cHPyrjuRU9 vOkcNvCwhjaRtqSn5RIQAOew6dTQbxSTumdBY2El7DJHHLbXjQOXkhhkV/IwOcnPHGa5xtLlN79q isIEDSlIppphCFA+8QT2P5UopuN7aFWTevQ//9f8xE1GbThZaxpepJa3NrdAssEmZcqcYZfQ5Iqb xjr9/wCJp4NRvbp3nGyGRTiKOSMdSQBjI9hzmvw8/RuaJg3uoIlzYm3vHW4ljaOdY1KCaMDoxPpm i3vpvtEhiO3Hy5cfd96Bpp7E6WmlzzSmeJZ5JFPmiQ5WQ46kd8VknxTPDeTQxRQzRWy/ZlE0QeNc d/Q9e9BLklojOOs7EjW3RXbefN+ZmkJY8Y54xV6O9ui4e5iHmkDYUHT/AOvQZH//0PyX1O8vXS3i dCYjIZX3qMuTjqep6Vg3c+sRQz3MdnFdRk+WIi5SYDHDBe/Svw1KzZ99J8qLls0AtLa7kSZbg/NO 0oCRoOMqPp3rcn1K0ki+zRMGtiwkEW393Iw6HH51VuhnJ3Zzd/LbzRw4EiSwztuYE45wBgfi1WYf sBt4reY7bSMPKska75EkIzgD3IAx71ulZWOZxaKWn3enzQXJtwyi0k3XiKhEi57sPfFY89/o93JK ukPfq0M5Z7a4tijrzkkEnofat4fCbJe7Zn//0fxjW5a52vHK7JDy+04Trjn8c1pDVL6ymSVbdbuO XEMkDKMBSPvKcda/I4/Az7SEWpWI5vENi8MsUME0LmXydzPyjDr2GOfWo7pl87zy/wBoWeJdsasN qHGM5/pWauzoqGdLdxxwJHvktp5CUdQdxA7EEfjRo7Mxv1tJwtweGujEfMAHBQH0bPP0rKS95oxj pHUh1B5Lp4go2mLInYtzIQeCKDq0cHli3V7kTIILmQqR9kI6n9P1qU2tjJu7P//S/Fa+WO4jhSOW ZVlddxkXYwAPXB9f604JGsjxxFppbcAQKp2owP3i/wCH86/HYyufXN2jcZM0rCeORBdRCLaIWPy2 +TksoHcn1rIiFsRK99aLNCMokMxIKHpu4NXdmestTU02ymtZ4f3rIltGbuBHfHBXIA98Gs3U9Zgm uLeS1s4fM3ES3MRxnt8y+vFawd1qSW5JrsiKNy+9cHLjCgHkVMYLu8uoLH7ELiaZRKyKAVReuT6V RKTvdn//0/xgu5wLaXTY7V0iDGK7nV1WLbjkEd+RXGm4+wu0NoLljKCkciRnywB2JAwM+9fk59Sk 27It6fe77cia3xNtJkEp+WPHcHPNXbq7kWzQblt4wcSS7tocZ4z/AC49a1g1axXIzLn09Lp4h9oY lSshaPtnkc1cuYLaG1Mq2jXFsriKc4+VWA6k+xwa2gveIatoytbItnbyXcUSSXLLsKA4MqjJCN7c n8686GpC2Go3StJHdeadiKhRY+u8A9cYwOPzrtpdCXFNH//U/lQ+Jptte1CKIohsoLZTOsibUM25 iSPUDivmr4k6daxGzkt7nyZRBtaCH97HdoCPn/2Tz3+ntXxsPhR7VRK+p5Or28ULN5jZ6n5CSCPS tfT7ufWRb2K24Lrkm4dtjAAfxZ6dOtaqKtdnBPc9G0Kx1CCGO1D2wimJWFo5BI8RzjLjqOn3TXpd wumWltJItpuu1tli3bMySlR1yPcE1qZy2ZU03T4lijvbUyWl49x58paIJHJwPlbvgjg197/Cyeaw 0OzuZ1snjlt2t5vLjXyywA3FsdweRntiuTEWTQqDSnc//9X+VCw1DT9S8D3jw3uq2+r6dcuF0ya3 MVm6RKvkqHbgrlcgjoOKx7bWNMu7SGO4gF3q0cW+WGNSkEJZeQHxnd14OOlfCSX+1tMwnJqo0zMN lLqWn3GnxNLDby7WFu0hjmjZWJyG/wA/jXkfxCs7jQJViks3ne42li3zeQGUFXYdRnnB9veu3CK1 Zo0Um3Y8kjuwJhBIkryIfMiYDIz6MPauhW9N2jW8q5lt1/dtn7ynqPzr2YPWx0Ru0dL4V06WJ5Z0 t7eG1bCT3BbbcYJztVe/TNd0YhdWkhvPMSG4drS1MbFpQFyB0Oef5Gt43vobU9z/1v4+tK8MTalE mqW09hb6hYWz2zQatKsUrRx8hWZuACRxz3rjZWvtLh+0a0n9nn7R50FpBmZLpMkEq2ORkdvWuc73 8Nya6vbTxPO66P5sl9Bbp8l9btZiU9G5x93gYPU02AWVnHYQXcR0vVzO1u8TcxTbjlQGP044oOaf wmrN4m1mw8zRk0+JxDqG5JjCJJdwAAZWHoeo5rP0uTWry9vdQFvYQ3f2ozzy7gl1eBQcbycAnrxQ Yj9j398jsZIhLuBCgujyk549OAelUxot6b2WSXzJVLiK1VcyS7geMgdBn19KynuZSjY//9f+OOa3 lkW3k1C3USW48qSN8gTY4y2aim07Tfs/9o6Wl1pqsywTR2Ds9vIQD156EjoPfnivPOcl0u7W402b TJ7mSOHc0kcQ3bJ37hl6fifSq9i8ttBcWKD7NAxKoIj90Hrz796T2ZrBpKxuWcFtFADNctZocqrQ xh2YnjLL6e9Vbq3twBEshPmHBHJ2/wC1ntWBewyw0LRo3vvKjN9LDKI4mdDHHA2AzFSDhuox2/lU stsb6QaaNKjeVpVW3ujMwIJI4PIUD61dPcbdz//Q/jxuNRuLiO4tltL2T+y0EYlm+WOQjOURs9OM Cnpb2fyXunTXXmMEll8wbFikAG5F57Eda88iUktCtdXKtJL9stVlkkXy95z5gHetawuILjSZbuC1 ktTaK0LwPA0URxnY/wBWwen5UGbdyLT4re4aG5ijtYb824knvISS4cHsT6dvoKhuoNYsIbh7C7lQ atOXv5YJvLLNgcsP60FN+7YWNZbCMXc07XNzMPJLN8xYDGMnp/8AqqW3kvJkW6t1MbhisoZSjsoy PlH1/rQKMuU//9H+PpLeSZ3KO4kX5n3dDnPA/KrJMgaGzkZfMkb5CR8/sAa82UbmUZO9iw9neWd3 ZTxRQNLZym4BnjPnOSMEbvwH4E1jmS4a6juLsTJIgZSFy8QyecnH5VHIxOTYwme7kMcUrLA8oQsT 5e5cjcPx5/OutuDY6XY5S188RpiGKKMyruHQnH860UUlYkfb3dtbyRajHao1xNAI54pgVQEA7Tt6 ZGf0rm9EWR9TvJNW02OWynkeK1Zpz56sW4faOMHPH+cYtNaGvL7tj//S/kTm33E1zaadq2p6R9ot 2QEJuhm2jG1sAjueCRxVPw7o+p6MVtjeW99pwR3uv7Qfy26ZLR9tw9M9K8cxUJM05NQtLzVI7LS7 ee9j8kGaeWE28Fs4IyqnJB/zxWKzQ3M8n2xPMW3vdvlynCsEYY49CRQJq2hpyXjarfTW1hHBZCJh gTTAMQ3QID2HT3qjGbtdTutPgt5mlhjWR5ZF/dKOQT6ZzmgRU1Oa7uXe0uhKysoU/JwMccH0+lbH 9m+InhdtJt7cWVhYKUQ3iW0pUcNhWOSx9Bk80Af/0/5F0tr5DBeJOtvaTALPbyjEloQBk8djn3yR W1aa+r2F5A9yN1uCbOeGIhJ8kY3H8/yrxzmaurHK6bqXiJbx7ORpr21nm82KO3QtBCSOZGGeO6+t OaZ9RvJLlbmaySxv/s8UHl5aVlB3HOOhx29etBKVpG7BZpdWUt4bvzjFcgRWYbCtIozlj26D1rQu YPLtLu4SeBbuVdyLC4k+Y/wn0xjvzQWZmn2VnplvZyzvJNPc3LlsjcInckkE+men1rQvIjI4lvIH FjJJ9nuFSPJAHXighqySP//U/kXvdGsJoglg7rFby77eR0+Z17Z9MY/nVu2u3iKC40+yuFjUrKZG LgqOjEevevItpc5b+9ymxa+dJbu+nGMCYG2unZTE5jPJRAPTj8Khjght51tJLqRHmU+R5cPJcYwg HI5/yKQJ+80bd3pdrqtmbO31l/tMTJ9qtp4T+7XGeMH14/OudaymEgsEuGLnJEjKWO0HkmnZ2uUa E8jwyTWllI8TNCIDJJ/ASB0z9aeAbCFI7gYCsCWIwrMOpH480gP/1f5SjdyvDeXMN7E8qKrW0L/M m4HuK5/zbu4mNx5IlupJR+7l/wBU5HXp29hXj2Oa2tzREMscYluEicKfO2hPMEZXoVHXIrR0uGa9 f7RaLKWaTzLnz4miZgcn5AQP8momtLjI7yePzMbGUElWZeN2O1Y1zLBbrFexLIuF8pl3ZAJPJI7V kNXvoadlLcECWWBHUtgyEYMWf/1Vs3GsSl7eG4AEEEflQpGuF55LfU9zUL42Fnuf/9b+Tm71K5gn mMNmL23R8rCFJDKcYLY6YJx6VDPOVhhvbmMxICJPLRTuBHO0DqfpXhSd0jzeSzuW3v3vba3ultpB BGzDyLqJoAVIGDtYA9qi02C8jvp7nTJms4bu3ENzAjbUUAHlceuam2hTWo+NLWCOa4mlt1u7f/Rl L4MkpOeg98HNGnruv7O+sfL3q3+kRuM4dem0dCDxSsSo+/dnbeHhoFzYXltr9nJp81xdSSDULHEl wnUDce4OAfxPrWLNq7xwXenaTdXFvp1w/lXCvEqzXKqeN3GRnAP41HL7514eLdVOx//X/lWguZY9 OSCyhimnt3b7PFKQhJYDq2OM4rHWa5jjuZrdzaXcsfkXSKxaNSM5xn6nnvXixTSSFUj7pfsb6XT4 4LiciQBCmF+RGHQ7sfnWYj2lncSXNkI4XuT84fgtn+Ksqi5nZlSpKVFX6M6Z4X0qO3uLK9a9tbxl E8RkEcyHq4288Dtnjiudvr4atqUkNrciJkBQLdYP7oAkjjoTjH1ra3KrGUlZcqNURwRJZPNHAJcF EVSGMOOOvuBWdqcenXl3aS3V7JJ5UgEVtOoNrE4+6y8deM59qyUdbMia5dEf/9D+US/tPtKJNply 8V3EqgxphmlVWy2c9iPSpdTvtTitbaW3tSWnUxhHTAQd2YdeMGvD5EcUr9UZsGj6xODeslk6suds 8whMY7nB54rXtb0W0scasT5kJhljaMMB24Pcd/8A9VL2ck7GUk1FmFe6THaJcXpmlzLLvBkG1VHo oprxJHGrt/qflKxythtzDjrVRg4vUEmtzRSxtJ/OiubbzY47beEQ5CnPU+vHashZle4eO2JUQDep A5z7CodKq/hWxcZRi9Wf/9H+VrTNGjuAs1+ZH3KJ44pDhQVBOQD0/wARVG4Dt88ZHlJldo6596+b V7O5jGL5tSe0uJFi81Wi3K2PKJxM3rUj6rHLmKaN4xMCpVM/uu1RNXVn2Kl7skzHvEeOS2ihjuI0 b5vOCbsgf3/rRpkbm9nAt1jzjyXQljIxyMY9+K0jemrLoUrximbctpc+YyTSpNdwymJ40wWTJzsO DxiqF5YSi+EyOjWttbq8jAlTAxxux64ya3lecNOpzxjerJo//9L+Va48wWiTrE0tlI5jiBUbpyuC SR+IrJYfaJX3xyLIwATcCGAHTivnIXU9Tz8RFSg4tmhNY/ZUjfKebnY7OMhPw/Krcdlcz2qG9vAq mUmW2gBEMyrnaGz6960k/eYQVoqK7HP3b2N/fJ5jElD+5+TKx7RtC+3YVs3MJkt7QQIJEtlPnxSp s24+7s9RQtxXV7FfT55tPu5L+6m8lJdsG9ciOEEhVAHvn9a6PUnEs9tBCEcDDT3Cy5DKRkYXHUHG c0rGtNan/9P+VDVluIrlHklaSKQJHH8hZRt9fT/61atvcWjTXaXcV1bp5Bkt5Ui3h8j5V3dvxr5q ne7TOePN7aTYmnaxam5Ol3Ek7qqCadvKCyoh4A6Y5wfyqrfC18xooYmt7ZvkMw5fGeMDpWlru7Oi UusizZWthZ3ZmElwZJIwI93yK+OfmXOO/at3UNcn1KaOK+nyyQbLWMIFWNV44A/DNVZoUZ2u2ZEh KDAKyjHI6lfrRZKsjs0yMsEbYZWBXzeOgOKai72MqkubRH//1P5ZryeK0h8u3t1ZGU5dSfkweg/W se4nMsMSpbnEzeXEFXiPHr+VfMNS5nc4ZpRqNddPwNO2lvVdZpHjiWOMRwwj5eRj5iPXitS3nmWa O4nkVUyftF3cKWUA8bsY5/CkHK7XMqUM89xqEYt57S2TaJhKfNkBbAITHTn8qqoJ7eN7iMSTfaZF DKgyYgcD5R6VF76MnlfOvma0YUxuNuyR+DI3DAD1p6RxbNlwWFseHMY+dh3ramrFwXsocstr6H// 1f5ZjqCpI32MHyUl2RxOnlfKO3v9R61agnEwYTqqs6fNHjKdORXgLZnJGale3Qoais9ssMscebd3 CGRBuCnOMY7dRUlzLDFEJ1i85I2RZoc8DJGfrxzimnzSuXTrU7SVya+ZLedbjT44pdNuE+X5v38L d0YdhzVqytrGNPtV00cTTtsjR2CgnnH/AOqiMVZkRqagGtLSZ5fJhnwQ8cbcq3sR6GotOiXzppWb YJ33LAB+6i6/d796kFNM/9b+X64l+zrImSsq4KSDhZAa5+K4WbULiW4jdm+yCNJCcNkdOPzr52Xw syg+hPeXUX2WGOUedA0uyOOU5IPcj8qmtNSjvUTTIbKKRBOturzuY1h5G7rwfx/OsTSLujWu1Tct o8b+XHJscpGdkhH3cH0z3p8C3625uZ3t7eLTbnFukKZZlfdtLAj259wKq6TYr+9ymPdpPayxSgxI ks2ZDI5RgGPbHGM0X9rdrcwxSxRLKFE0JY/JMjDIwR7fyqSj/9f+YnWVg0KKG3t7GG4mls45EmS8 RIkL4YsQOSQMjHT+dZUcL6808EuwWkVsZZtkm3ftx8qZ9a+ak3ewGOsKWcgSISRWwb5Uc7vL9s10 cksSQxC5QTRzDcrK/wAyHovHpnrWaAqwXguoLqyeKSPywUtp8ExMR1/I/wAqx7OCJ1SS5eWe4ikZ QgGyM9snmonr7oHSXFxZqLeeSA2cZhSBo5Zd25xhSR/vHkDnrVaeVre5K/u5LaSPaWjcP056/lVx 2QH/0P5gNI1C5eO6tQvnxkGKBZkDGHJJyn0qJ9i7Y9ShSS6GIGbZlsMcbvYd/wAK+XAz10OJLyVo JpJYpn+45xGcDAKjtVyRJZdtuXQxx/IpzyuOOawe7AyfsSWjRmRI3n3s8cu3gk56fhUKSXckrsJX JPyhT90AdsdqQF1XB8m0itVlunlzJ5p2RRgd81AP7Y0iW8u5LeK8urzNsDM/7uFecHH+znj60Af/ 0f5Ww+3azbPtAwZdmdrH/CqurzKIGaTMcDMoZwnIPYA18eBPNpkQskNvqt1b3FxGUkt0jQRyoQOd xBP4VfgRLaa2SJx+7twkjtxJKwBzkdK1g7qxziGZlcSMzF3k+QqvyriqN7O2oxTwsj3M8so3Sy5T ycHoo9/61YFbTI7lGklnJtlijMESWrZlkA4wxJ4BrVt7eRbdZGnVdxJaJzu2jPGfr1oA/9L+WM3E KuwbAUDAZPmrGma689IrdmEO4tkHLV8uc5sQ3Zso3MnlyNKu0hztA47YPWprW+b7E62nlJdyExET ruiXccE+vQnHv3p8rC62Nm0tLY2l1ZarveaeHygANowR97P+etYWqfZ7KxNvDI0zbhGEUfdXod1C V3YqMuUpNqM8kFvahUYQR+XECoDRj0z37/nU8trK8PmFTJkYcbeFraKaVi+dH//T/lIBvLVzHBcS W6zIYmMLFZGVuCp9j6VE7vDNErI7bMfOeenc14DTW5HMm7dDSN5MWZ2kz5g+UA/MBwMH8u9RosRJ Lhx3BCEoDSLJppkSJScFMfIcdafol3a26zTxtI9wZiIiHwgJzvB9MYGB7mgmUbobfQPqdwr3Ts0s LYjO7DKp6j3H+FZz6VcQToy7djIY0jDD5uRgkfn19abdyORn/9T+VeS0FjtaLN22xWkiI24bHIHX PJq/o9+32e+W706bbcI0BjUmIhv4ZFOP8818+TGPKVrKKSVGguoyu3hVDlyFHTLVRVIopZVWKVhG 5CLsIGR3HtVQdmW01ozYVI2uBdKzSTSQiNpSSWIGeKp3N7eQTQywq/l206vOsJ/eyID8yjHPTPSq qW5TSCP2h/Y9von8OXri2kv7nXdPgGnZlb9zDCxd1ZVIOScEZ9K8L/bnmuk+IEq2radZWUtlaTLY WuGuI5GgjMjE+hOV553IaeB0oVGv61NM30xWHj/dX5H/1f5eWtrq+uHSR8iaQhmBww6859f8K/Sr 9g+WKPVZtQg1G9njstEn0yfTAB9lUROIzhzyGbr+HSvnKukl6/qdtrpI+hv2h/BNv8QWKj7DpeyT y4pr9wsoCqrBmk467DwOwA96+Sp/2YPDsj293f8AifTkmuXIs4bKSO4mQEZZtpGVDEY+bNaY+u6a jyrXTcihCn7F1JvW+hjan+yXKdNudT0jTrT7LaI+pX13dXccLw4BxJIDjdnqFXJ6cdK+LPGHhzU/ BGvTabOq3Ic48y3PmpESAcZHUc8N04rHlkoxqf1/WhpUtBqPWxzjo5TfIzZJ+4f4amsrG2m23Lp+ 9tZQyMw+cDjp/nvUERkluf/W/B34QftFap8NHezsrq2W4lidreG7tBcAjADFSRwR14PPOQRXjnxY +Iur/EDUZr6+1Eyzec01zcyJvacMx3D0XluB9fWvl1Hlu11O5xXMp+VjzWfT/Jt4V81HkRRKNj7t wPODj9fpUjO+zzLWYxXkce6J05eBgOCPoaBvbQ6rwN4Uv/GNybeIXUlxEd812ybJrhsgEgHggEjn pz3r3Of9mzxqkC3Upht7YSYDpIskjDg7nHUfljmlLTQcaUnTbR9wfAX4X6t8JftHifVJY7qG5hhm jVbxZRsKHc5QHI2g8KeP6fP/AO018ebrxb4hEVwY/Jjhl07Tbe4jFvZxIP3ayMoOd6qAwB7+vSqw 95VZ27HHjFGcaa7M/9f4O/Yyso4tH1GOFyqppSakLqCJQ01xuXew5zja2MD19q8k/b2vG17xDpGn m5u4bHSrFVDF1CSRSxq0iF+u4sVJHUAj8PlMB/vFS3c7M20w1O/Y8c+A/wAF9R8SXsFxHYCWCxlQ sWTdBbRKUL7nIxuKkce9fqfo2l6LoTix0K2itbjT4o4IFtU2TMI1C5ODjJzzj9aeLV5c0un+Zjhp xhRjR+1L9D40/bbENxfeDYbmCe11KDTZGuo58klm/eI7MeRkEHH+0BX5oXrt5skspHy5698d/wBK 2rxvCPoeXhlecr9GzAtdWuZrtLd1JLuREEBAbGcZHfNfop+z5+1Hp/ww8Ez6RrHhK2vo45GCCy1D 7NLZBtu5S2w/K20Hpn1Pp59SmpuLfR3PRhFOVpbH/9D8B/ip4+j8e+JrnxDDbXNnDdXE8ywOV8oC STcidydg4Ddwa8W1CXYYwlqbuS8nEIiQAjJ7t6AY618lUlzzch06ao0fZrofS3wZ+C/iTxRf6Trt vptuNLGoxWd7d37j7Jb/AMZ8sdSwAzgA5BGQM198eKfHfgv4T+Abjwz4e8KxHXr6N4dR1aW5S0up 2LfJM0RB3bgpUKMBdq9etYqTeIhGL2uelFR+rOL+J7dz5J+EWqz638WPDd9cN9gSa92XwjuC898p KqqOOAQvBHHBUelfqj8V9NmvPhqYbRbqa50uxlt5XLLseEeY0rx56YHynHbNbySU4vzMMX7mG1Pw vvEhh1GaaCeSxsRK7zQKnmvu3MGAzk4zmv1q/YqudPPgS/Nqrzxi1lh+zy27rPu3Jkn2Yk/gKjFL 95F+aFdKlK/Y/9H8xP2mPhhqfiXx1fTrZXP2HRLqS5aI20yySeaiqNm0HKr39CK+RZvhj48u7xLX TNEElnbESeZMJY0SMnGWbYfToa+XxUNU+jSHRajSTfUd4q+FPi3QQLi40m6+zRIslzMIX8pA2MEH Hcnj8K4LUIEgtlVo5VA4uFYEk846fTrXEornaNqi5fc6liz1CGSRFugr2ttbeXYxhQm1/Rvbkn1z UVwsn2qK5QsiAeWg3/Lz7fjTcUkEVZWLTyyMnkAZkbjeBmq9lby2UrjEknmn5S5+4c9sVDVnYZ// 0v5+baJo4mlusvLnJAPRe341C7RzpL91F25RnGOe1fEp2aOlK7MV5ZLKONIzI890p8/ahMURU8Dc f0qWVtQuIIGdliRHy7BQWkxxgg9BSe+hbh2NR4TNFtBTZjGP4j+FQ20sloNhkcpHk5BxH75HSkZ2 toWHs7LU7Q3EM0tjqcc24eQF8vaDwfx+lT2yGHUILo7JoFUpKjk4PB5HvSezA//T/AC9mtElQRjD btxPr7Gol1m4tUnFzDIJYpVihcoZVKuRtccepxjnFfn50FbTrlbi+u4y8sksh81yxLBD0/DpW+vm iMxE7kDZPoT9Ppmk2luO7GwaZ5rPcs25FcYXbwuPerzyXEdwzAJ5CRBQ7HK4A56+lY3Y4trRDQIL i3WZJVeOTLKyNleDjH6VXsvMneRJJ3js4PmZABg9Bkn8PWkbH//U/AQ3UlxeyJpjRSaahMZkJIlJ HBwOR+tacbG1VxIzY++Sw4Ue1fm56KV3YtQkXchaQYjCADH8XFT2yRwNMkamSVkxGT1oKgtdSs+T FIqqS5+9tHPvipvOu3igjhJ/cbeJGIIHHSgcoditMv2u6lZIxAYgI5MEtvcKMt+P9Kv6dp0aQvcS uCUz5jZ4AA70ENW0Z//V/DHTLexudSZLmZIbaSMtHP5ZkJPYDHrUup6PHFlbTEkTHzAAm1hjnkfr X5u1pY9AzRJOwjjAAcH51A3Zx6V0EN+rJHbt+5LnZ5hHyj9OMc0JW0Ajn0GAITJPbuSDIk0UwYqB 3PoeOhqGG4W4UxofMEZMbGQFQccd/pQA+1D/AGswyQrsZTgbfkA7EVBMtzbXEqwxyAsnySYwpJ7f hQB//9b8PWkuooQ0rH7U6AO6D2qjPdPFbr5qyzuuASo3SfjX5ueitGRM14tzapbpI8M3MrAfKhHY 12FsdTt4n+xztCkf7x4gdqt25/T8qBHOS3+qSXVzNcujhNphjSPYy4zu+varolllmTyUVYiN80rD De4pNpASwG2814yGdnbCAD37Cpy0eWjaNEiIyjH72RnrWBd/cP/X/Eae10yK4spyWmZ18yYBOEZS QBnp0ANVvEF3/o63kcXnCIiJNyhevYj8K/Lz0COyaRIo7mWBUBG4xqPmjB9q6mwubiDS7i+gjkhh dvKnnIKPgnCj6HGfxpXtcTWljmvMieAyLITukyARToZo0kjDR70yY5opHKk5HBXHp164479K3jHQ 2pN8prjTVtFS5VUO9tyDHUe9Zcts9zdvDHcPbvKNiujBFU/WlBaFn//Q/HKSxisNOREuIpZGJ8ye JhJ83Qj9K5O0j8qV5EY7wSAc4/GvzOaSPYlKyRLHJIs22Qs0UTZVlbcWJOaseILSG1+zu6rIXVZo mGGPzDGBz/nFDXuHLKV6eosMksVspt4oS6gsspX5wSOBn04q9NuljRJpYpJZEEnyEYzj07Eelcy+ M1g7QuFpbkPteRITtJ3scKAPX8qRY5Y1eTaGUudpAz5mO/8AKnzSjexMHJTsj//R/Em+DJaJqcsx jiNysC5BG0swQD8yB+NaUi3OnyOJTHNHLH5RIJLKfX/PpX5YleFv66npRk3F8z6kmyQW0ZJQSqd6 b/u5/hqxLc26eZLfSK9wIQY92SCegBPp/hWdnsZp6tFGK1uXmN9qNwJ24MMSjauzHyr9AMUzyJxI wSMLJvIUKMqoz3qpdGitiZ3MEkUYgiC7iJpFON2eSa0P7VuooVsYXeSyeYSNbq2EQjPI9PwqASbV z//S/GxYmupgGY7EzhCeFB7VRdZEvxCJgqOQAmce+cV+RzatY9KacIK/U0IbUXUc9peK7PFNvtZV O3oOKz4Ly7tpjpdxcefNkxxStGsbJESDsyMDA9a0N7O1+hqTwzwgvE/zIQSYzmMj2bvUUM1yku4S KFkUiU43Nj29KLWZTi4ySZotZm7jEzOxRvlVeg/GnaHAY7yYMqgQZ/edGU44/wA+9ZyV1I2Vr67H /9P8ep50W4ZeTLJIf36rlXPU5PbpUNvdGW4EcjnbnaHAJUV+O6c6bPcSUZq2xcmhvNoAuN0CzExJ kYTIAJ9ccCpvKtY/LYzAXW3lgDtb2JqoNRlJsc430RRiea4jlgJMcbOQGQ9Dnrn9a101HVILG7sI mEscjIZA2Cz+WSVw3bqelNq9n3M6V07A09vNDuuRPlgIlWCPzHDHjn296riQ6Perb2LSzIu1iWXG CRk/zpTtGnc2ukj/1PybmglNtLcRrD9olnDwOZC0kSgfMCvuT19qoWySX944uFjXyUzKCdm8Djgf 4V+MOLWvQ+nScdJbnVxX1mY2DWNtbGAlYUhYyZAGA3zHgn0rIW+hs7s3bZxxkIpdyPTb+NTUh71h 2LGoahFql3DPFbwxyZC5ji2LgDqR2NXRHBO68qxHEgzkUoxu2n2/zOqTi7SXciudLC3Pm6XbyJBH CGlIYyLuH3zz2/xqOzt5DPJN5bKDhQrkhX69BWkrK9zmnLldmf/V/LCYDSdSsLjUjJc28p3JbQKG VB8x+f0B24/GkaXRmvomWB00vDNLap8hVjk4+gJ/SvxSMbSsfT8yWhWnltPKto4bV1EsxhMyuZFx 1GR2x0/EV0itZ26Rpd2dvqtlCdpJUo4GMHDdR9KUoWdkS521Oai1rTjHHZRwTLpyXTiGEsVa1OSM jP0qxdyW9pCXMcV0k4BiaR8mDJI5HTJ561DpONNrte5VOrzQ+8nh5gidUjhSDAYKOxJwT6en4Vej lhAlupHY5Uoq5AcYzg/nXMkkaU3e6P/W/Muxv9NtLdIb+V8TMQjovmNk7iNy1m2slm0k80DuAZMC EMXQkHnIzx1NfhairJs+tcVKab6XNe6ZZBHcElolAUyeWfMhI6j3+lUGkmS4uJYp2lglUeVMw2TD GeCMnHatatqmsTohGHP7uxVCK8A8xvKjiYhJMcDJyf8AGiy1SyeN7NxC88kq+XcFm8yIL1wM4wc9 SDWE6dlqUnFtpGvCUGofYdu+FJBmSP8A1fzfxA1a1GNrTYsc8O4TmJwsytIo7nAJrL2bTv0IUot3 P//X/Lhms4p7+JhHMJohAm9tvRgcr7np+NW9WubjS5LSCJ5ZI7fbboo/exQEclV6gDJNfgbg7n2k KsJ3UXsUXu7mdHN3GsZnlMgYDAxk44pA8RWTyZmW5hGFkUfNGD3HpVwhaTXY0Turo6BZrf7LbSWD Ol2q7LpmIPnHueOhqi9u0rp5c89qocvcAYZJznPGRx17VtRhzVEuhUIuU1fZa/cWru8a+MMhe1Fu EWxgSABXkcEj5lz198VM0c8OLLUtiXMOEdumzHb9aitDWSsFTSV7aH//0Pzgl8hUMdsjyOMZlZcB eOQOxrKnj2FLu3muGO7dcPLCYiGB5Ck8ke/FfgkEz9CppzqX/rY6ORRb6La3V3axxm/d/szGTLzB Ovy54/Ef41zha2vrC7uYbgvc2159nltZVMe1cZ3Ke4/P60S1krBVT9oool0q4AMkMbFsL8zdQp9K ZMI1llyoWQ8dOWz/APronsVF2SRn30N9dLJD9o8kWVv/AKFbsSYpySD17dTVeFr2O2tBdSLbOW8s hGyGxnIB+lazbSSXkZQX+1Rb7n//0fzFs7u0LPGkwb7Of3kH8RJ/xqe+n03UJ7QiS6sbS3QrKiIA 10cHhhxxkDBr8G0i0ktz9QxtZVsPTqv49V/X9dSDUJ7C1giutM+1z3UhED2w+V4l6FuuNvJrnLi4 TEc0Usafvh5sUjYYnPQfWui+tjyXF8t2MudQtFvI5fJ2pdXIgbB4hycD5fxreuNFihmEmprqMVvN EfIliiDLCyjKqF4yCcZPv+ZzRva5rCDd+VXM+DSrfToZ7i1JjW5H7+Vcpv68H9fzp9ho8CMbuS9u pXl+X7PLKTGi9BtHpWtGbjScehphkpTnKW6i/wAmf//S/KG8sTG8hsg7IjqyxghBIRzg54xVm5kS G1029vmtwtwxjubON/Ne2fdtVT2weoNfh5+gFY2sDTQ3uMSnMEcTNyB14X+tGpD7JbRvGGWSdtjx HiWI9eccUAVbSK4Be4IY7Fz8vKn61Vt7m3vLK802W3EE7329ZJAqROoUjlj05P0oE2ktSCLTYkUy Kdj4KyHghiDwacvnTPGsMjlYV33DE7BgHBx69vxNBmps/9P8jdVWS0mW4kvjPpksQe2jk5mtSSAQ QP5/0pZtRj+wqC0s90xEURKl1A6DJ9BX4efctt7medNu4zLBPeRyoka3E9sWyy7+y44x/hVETvbO 7bFiiDbbb+LC44/rVJWVzOUraI0ZJbe60wTNA8JlYxbpB5UkjL3HfHv71jaesgkKOPsyq2AgG9ev WtIu6M7vY6a4XTLW2mWAFZbn78w+V5fZhXOok2lxNdabIBNIDFJK0YJwe2fz6VrB2dmbn//U/Hy3 l04WpjWARErtZW6FuCxz7n+dWYL0zpEnkhRE2EkVdp4PBr8fT7H3MV7xj3NvLNdztHbCZZCXeWQf NuPUmoJ54LG0K+UklwJgrFASI1PGD24zThK0fmb1I30IJNPgi8641C4TLRedHHERKFGMjoetX4dH 1eKwgvLeYNZ3P72OMKIyqkcZ/LvUOD5mziv7linBDZRzRzahNcCLJ8xYkBYnnsahjeyuZJBbXMUM UEnmNbyriSf0x79zWSi3sQf/1fxiuYzeSi4lMYRAAYw+HbsP5VpWunW/mSOrLa5j2xo77jMwx8qn 1PJr8bjFpn19laxzjPp1tcO7ytFctJsktwpzgdz/AIU29uoLvyzb2qJLFxuXOJAO7g8ZrQdrGkLK YwQ6pLeveSxHzbiNUKrGOcJj2z9Kw4xZysxEEUJllLSOOFbnqf601o9DPk1JtRv7SOPyUuPMntj+ /ZRlEAHygN3/APrVX0+ey1HUrJrjUmshdWziKeMF8OucBwOmcflW4lB31P/W/ELT7WVRqFj5pke6 uTMGZyYw33Rj9Kr3cd/pDwWhu4fKuJiAjvmN5MYYAccjpX5OfYJdijqFlvuYZkedIYU3SxROQJm7 5Hp0xW39ptZdM+yahp8Fz5gG2GVPM2YOV9uMDr3FC02L5GZ8b21nbJZ2izJeXcrOkYgLoEUc4f8A hAz04HvVrTk1fyrlYI3+zyRsks0iCRBnjKg9666e5jNaXMFLi7sYpjdxeYtt88syRlVlUng7fp1r hfEgBtft1sRtmclUjw4AA5yOwrtpdDJ6K5//1/5K/GV7al3hiuZGMc7Ipmi8ti4yDke2fxr518Sy yRX46SGSDy3ZX3rtzkLjt1Oa+Mhse1U6nMpY24jllunWKMDcke3759Kdpkjx6hE1l5SyyERokgCx MPQnt0Fb29w86W7PYtK0j7Tafb4fJsbwMXuLf7kb4ONyHuTj+VdPNcvJpv26WP7O0ZKCBhullwSN wX36/Q0m5JJHO3dmNYReLtTuITp1zEdPN0ok0+dvmEYHzsAOcnsDX6LfDgaWvgyztb5WtZLmdZQk IDz242KuPLHrjdg/0rkxF7IVFPmsf//Q/kc8HeJoLuc+FreSb7RJZtPcWt6CzttUnd0+9kAYHr35 pblbGJVk0iWKW9vJj9rhKmFYdnygvnnP+FfCzusVdmFVR+sSS6af1952Fo5+zGQeV9pWJY5ApwuA BuOevrj1rwnx/qNo8epNrdxcR3LRpFpSF/8Aj6ZGGyIHqeMkD/Zrro/Hp3N4xV0eKhEgVJWlUTzD Kxj5iPr6fjW95JuIoPKwt/JOqRxQ/wDLUkH5R6npwPevZh8SOi1jsNMju4Ci3kUwy3lGLbgJyR83 5frXZTSXln9nMclzaRwASNFHbedKAQCHVcZ6AHit42vqaU7H/9H+NuPUba/lvV1K5uoXvbYssRgb bdFedpPBVm3c59KwrqO61G/02VQyW+mRNbpbSzGTAONoweCAdx9s9651qd7dlc7+DQJI7qDX7Wee MQoiSRoFETMflDbOpGRz2BArAuok1HxQp8Qi7lEEwe0t3Xy45GjGVw/uccdaPUwet7lTxLq15aad ZG3tkEseqSRlN4jkgEhRT+8z0+UHnpVxLuCCJk+0WcV1bQmecySAK23n5s8E9sCgXKuw7TtXh8qP UZJhYSIfMhSGEi3becY2kZB5/WtnUdUuLKxe7towDdfJJ5ZHnxgAHdjqM9BnrWc7XRhJdD//0v45 LeWfUxDHcyeUkqBl+1f8tOxHHTPPtWhqlzZWUVjpWl2gsrCPabtYZTIm4AjcoPbkkDk81wO19Dnt bQp3eiFIbe5sr+LMN4EZ7aeOcTggkggHt7dD6U37JeC3ubu2t3uUtgGlONo56AnoM1L2YFNvEVrq 1udOjsrjTdYt5x9nkmjKWl4o+8jM34cr61qbbCOS2tdTuZYr6/by4EijElrIoXLZf1/wrAak1oi1 ++0O2htpoDLM87LALUq0aQksY2bJ9MA4zzWp9lEkUM0gkgk4kmBfAIPTIxnHeqi+Vjc2f//T/j4e 4MKSx4by5WOY1bKye4NZlxrEls1tYS2JMBcyG8ib5lBXADdhyPSvM59TnI1NzLCZGhWW4gcsRH+8 CjPB+uMfnWymoX9/DcaJpDzR3zWy3Vyr27JFGgPJJI2k4BGM5zUSlfQBgtbs2Jjs2i89WCyAkISe uWxzimxpP9imtZ5ZPNm+V1ibKrj0NUp23G9hs/8AaK2tnDstlW1nMkRkO2eboSHH4ccdzWjBqb6h CxtoRG0cv2WR9uyMODgjJ69Dz7VoI//U/kW+yvYwW8k0yyXabRKsLBhNjkFj7+gqA2st9ONQu5Vs o5rlvJMIErwFeQoTORk46+teeYxV2bo1cLciz1COK8keLYjRrvuU3J8hZgeOccn8jT9N0u81TVn0 dbORSioZ5pUIhgEnCnOMkep7UFOGmhyepSC2kitEWNvJnZggG0qy/K31Bx+lW9EWe9kuoopZo7eR S20tiNyByh/KglRb3HW+owX9jPHd2qQLZSS2EN7CDmbD/KXx154yOcYrLhvbfZJlS12vyW7EkIrA 9Se/0qZLQ2P/1f5DoNTktoJIfIDyzL85H3iBy2O/NVLLWrzUtUdItNKWiwfZUi8hjBIT8pbJ6t3r xwPS5ra30rRrS1g0kW1xGjXFzcSkiSUueAB2AHGD19q85XSwtxM8ys8LuGAdsEdz+v8AKgynubMd jpjebfKQL2KMCOZSCse0knI9eK19OVFzeTsrCY4Zi2GfPJOKCDB1ky/2wRELezsbbLSvK++Q4B7/ AOFUrbVre+jjiaaZGW4zFLH93A5GSOxxQHkf/9b+SyAL5UzSMWi43tKu6Hk45P6VBr9jDDbwW7ab aW9taxhzLDOSsjMchuDgDnoD17V5Li0jmbsZ0Ctb3KG3uiJHh+aFTgD196u+RHlnnYsuc7AOSfUG pFf3iheW8UYeK3vJFhnUCW7sx8yMVGRg8Fl+6fpVHRNNvrW4uLZ5ftUcaK3ntNvZg3IbHvnke9BR 1NxZNKLZ57koscykwqoQ8cZwOtX1KH7Xa313JboDugcjzBcEgbCwzxnOO9BD2R//1/5LbdY1t5Ld rm3guUOy2iIL/aMnqOMdOTzUktitgftFwAybN8wh5jfA/SvLUbxszge5n6Jd28E5vRNcwJlljt2H 7uQ54bB+mO1b1lFq13dHU1jRlkcC1t3QeZG6sT5mO4PHX0rMqD94kW31K3sr7WL2TbNY6k8V8Awj CqwJUkdx/LbWHoGrl/EGot5kN1vtvkhnRo0HsG459Pce9aWtBo1Oin+030cd3eWlnbu0XkCG3nEp Gw8Fx1BPHOOalaFb+GJpcSpH8uM+nFZjSb2P/9D+UGfSHSMyeTJYRRuZFklYRiZD8oIU9RnPSopL e1sEUW15JMsiB5JJk2mJz94rntz+leOZqHcvzWJGjz6lBeQSzRFY4LIP/pEjseDt/u+pqAXNzqET aTeXK2clrD5gghYIkz8ZxJ1yOSMnjn1pS+F3NIw6JFK4jtba0TMkoki3b13b9wA4J75zmqTpNJYC a0uI8TEYilTdGxBx8w6+tRCyuwjDV2LRvbqLdbLAkojUHy1bc7kd8+nSrV5dwx7Syu08/BhdNkMT YGAjdTjr9ax0U7F+yXs2z//R/kxtXm0231gzTuJ9Vslhs3icSeWQ4b5l6DIABH0q3pH229gjtL1o 7qO1m+0RTPEFeEkYIyO3Ga8BvRI45L3US3Wsq8N5/a4RZYGYLLuCw7BkRsTjHQDNcnBcX4miNnfO 9s8xKvGQ5k/uqABgg8j1FHSxMVdnQQ28V7JlEhuJEOJl3eZFG/Y5HcVaGnTWCG4nlgAZNzC3fARg SMY6+nWpe6QW975lK+tdfv2tJLC4SOzRvMkh84RvJjruGM9K1rC5sdNK/bkWeMSb5hIDk+vPaqb9 9M7qC1v/AFsf/9L+Wa1gstU1CC80mQWyTyPCbK6+WJdvRix984x6VgXAivp7iyR4470tudUbO5Qc Z/QV4yaewql/Ztj7i2MVoLInzGLAGZvlVMH/ACKqNAkkMaskb+QOX2jpx1P4VlL4jWN/ZJDI7rzY nVckjLxRjpgdaes+nQtDJFpaC4vYhHNMtufPhwc7z7+1XKVmjPui5cbmiQYyjSEAyLtlI5AyO1TW cOn3bXFlcotxJaW3mRw7AVTcTzu9etOLJlruf//T/lPSwVs29js0/wCyRYS4RsyJz3z07YrKvvEr m+TR/st5IsTqsV75O4OSMvhgMBc+vf0ryL2dznlZN9jWn8q8gkk+2C1gt0Pm27r893nC7fY857Vj lL2aNYNIsVZwojiuZn2hccbc9+3HWrTfNZkytbU11njaIQaj5c00WCVJ3BCv92oNRg069MUkACMY QJQ5OzcuSCAe/wDWqnF2RnJp6LoNs76dZIz5OyFWKzbf9bMcY4HvVmy8PK7yz6fLKt1PFnyZyqoh 5I69Cc9/StYWUG2Q7SWm6P/U/lCku9SmZ4xcSNNYp5MyqMcY6D269KgV5fsYitUVZnmM119ok2OR 3VB6968GpGMVaPmTFyesi20EkETyRP5itGGfC5dD3I9v8Kq2t0hO28hikW8jeONVl2zxEDh/Y5A6 9s8Vja00vIit8Fh9pcahDLp73V1LO9rKw8oKDC6HIVGBGcAfSpddlmeeP7NHFAzRq6xWr4RfbOTh vbtVyWhpJONNJmXpK3umTzzTOZLjUJAHn375FYZwzN344rqbSBZReRTXE/k3sPkXCsFO0dynHGeO /aumi7OJy0l7x//V/lM1KK6azMEd5cYgHkxyQRhpY1HHAwRk4GTim+ZNLDb4yv8ADPOcCZdvtjv+ leC7KuzgqPRofb20csk0d3ezTi6YFHkAVbUg8Y9exzU7Wi2t9PEb+e7tFjzHIV/dg98emc9/Sk/4 jsSloiXTbSxuDJOBDBAqNMJJ12M7A44GOp561HezSR3EcbI5Rh8zRr8qqO5PvQ97Boi3byWy7ku7 ZL+03+YLaVjHkj7rAjkEcGsPS4NTsb6aWYxNZXMzuWmc+bbL/CFGMY9vajY0g7XP/9b+XW8tluIE ikkYQum6PnAGe6/l+lYcMc1zeXNjB+6e1hQIXOYnDZ5LHoRivnI7tGSa5rsZPe2ttIxURjB8maVg AzMnBGfbmrq3dtciPkMCB1Hy1tF9DWyasyS+lhKRtNiMqcI6jGe1aEdvC9uWSeFblVKQy7gZUJ4y o6//AKq0b5YjdOLj/XQyRBcwRyRxzjzIiD57oCZ+csGHuMjj1rPv766VUns4fOSN9rxh8eXk4O31 xnpQnaVmctWPLDmW5//X/lRsRdwW/l30scuJGlTDhgof5tpI446Vahgvbi6hELsqRneVC5Uk9Pyx Xzk3q7nmxjzTY1ba7u765tr6AwSQH5J0O6PI9P8AD2rbvLyN1hgvQtxarD5CRKgVQf7zAdfWs7NK 51Fa9sn09G8mJE+12qukQYMHTnacZ4z74NZI1KSwSSZIWmEK8xoMtn6e2ahKzIcXz3NmaS1Nq1xK WxKoyYhuK8e1RWVq5jFxe6lOtoX8q1tXiGFBHXpn9e9b0tx1orSJ/9D+WBYGtZ5nn2ylf3dnzjgn Jz6ZNaU8W23DO8XnyYOI3D7PxFeBFJXucNGiuV2ZVDKkYjYtdc5kWM5bHoB+BqKC3tJJLm1YvCHc MA/Dc5x+PAFTFe7ZGdOhFrmR0mmeHppkunAi+zQR7rcq++WQjrvX+ECoZrOCW2iF5HBK1o5ePCfL u6f/AFqqEtGTTba1Od017SeB2mcwN57R7WOGGDgdfWryQot0zx3WY0Ty9pPyDPf60i4ttan/0f5a 7u3SK3WOKWWeQH5WLb8ew/z2oht2HE4aF4wCdy7d9fOz+E5IPSxXvLCC4utPDBtkcxlTyz8vPXd7 Vqzx2ytGtviN0YNleCSKxNoy5dCWW9uZZBJBcpGjL5LwxgEOV/PuDUVpNLIJob66WWKWXeMx7dij sfXvzQLm965HqTyyNc/Z3jkt4o9sACYZiO/P8sVzFut9dS6fqFxNIy20x220oZSwUY2sp6L83HPY 0Gikm7H/0v5ULhReXRmLDK/I7dwv90VrSxw2m37DfXDRi3CfZyix7jjk45PX37dK+XIUtGzmHvdR lD2xfbKTujjkUbsnpmuk0uzultFNzLLciCXdIqfdAPVQcdaLWJi3fUsjVp2nW1ihJtI3KRrOvltC pOGxx/8ArxSalbjTpMwSo/Hm/I+5XyM9ex9u1K2tzVamd/aEWossVwoW6jxsLjcpYHjB9asCMtMl iztGsqkyTqpPlDoTn19B7UwP/9P+XLyorOSEw3UhiQ7fPxtMhAxkj3qvlWt5mkmVrhZWkLNIA7KS do/AYHHSvlxXWxJZyygROzxsmPvF8bPX61VuZI/tQgtplXzxuYhht684/wA96xmveGWReWsGnPFc HzdRhkJtZBgo3qGHUcCqn2uaaZDFHEoYDc+dpB+mKTTQm7Ip3qX9nfbkuElT5ZQsfzZBHQn61ofa 5bmB5LhpCYhjaRtyfQHvSM5Svoj/1P5WoAl1bOwheBo5THLMRt3DgjGfx5rtdI1TSrfSbizudPtb 5liLRyTRAys/A5b0xnjpXx5MWuXU4G8u1uJRfi3htDaNlrMSHYUzgEZP6CobFpp4ZdQk2Sr5rNGc 8IBxj8OgrWmtDEja/iuLKaSBJmmWTbFIkgEaYOGBGM5/GprBJfs6ySSMZn4wferAklcaZCWaQPJJ NgRs26Q85bH0/pV55bZi1wjGRbi3UPk5VGUHAK9uvNAH/9X+UaeyuES3ZHjEci52RyhuBx+HTviu n0y2t7e3RsNLdSD94Mbo1A9DXzUI31OcpXFlavOZXZQgbeqt/Cfasu5eO3V0RLi5mnfKhV2iNfYj /wDXxWpEY2bLdrd3USKtwGZlXIzzIPTPerlsRvkmmijkM0g3Ajouf50rK9yype28JkP2KNzIxyOc g+wFU4NQ1a0M1tcMVgucBU38/Kec1rBdQt0P/9b+Ua7neJwI1BmK+aM527QQGP61DPcefcJLaMCF iCuJCELHo3A9zXjNJqzJUEmOaWO28pFUSTySL8+77qd61UvLq1u4WiQTR3H7iaPICKp6k1i1Z2LU W9itq8qfbYrafZbqCFUxMJEXjOQeh+lYVzNc2awyR/OizHdtGJmyQASO/vTSuI02uZvtMV0h4cAS DHy4H+TU91ftLdi3t2ijnIBjkkbaT64okrOwH//X/lIuWuoImlicTSjl/KYMU7Zx/nrUVjqOtbGD 3V0qsDstZTsUj0x2zXz5cI66nQ21zMsSJcReVOy7mkVvkbI6Cq0VxcZE0e5NshTeRg9cc0GtiW3L ymWOPaXh+aQ9NoNX7QQ+ZFKB8yPvfI3eYB14/Ck9i4J3ufsp+wzPZQ+H3vfszQ2MFl9peRGysLTS gD36yN8o/Livnv8Abg1XSLbx0l1HYfZJbnNvcxyhrlrkRgfvVbHy5Y7gPRuK1wP8Gr/XUyzdP65h 3/d/Q//Q/mGuJLnT4oLx3t7hJz56G3O5kTJwGXruHcGv1J/YUuWsdSuriPTrHUPtscVpFYzpmJJZ 3j3SOo6gDcT1A6mvmMRsvU7ddDZ/bP8AiJrPgkW+li6S1a6kaSCNU3S2cYl2EQrjJGXAHUYr8zX+ JniB5ZbhfEDXbvd7FiVdk0C5A+cDr3688GvQxFCM4xk1fQ83CVXJzg+jZ9zfsdeLNY8Warr3hfxT q1zqml3sEymye3X7LbI6gxgHv91eucFqP2v/AILaN4f0q08SaMk1ne3FkT9oUIkP7k7QrLjB/hBP HDjpjNThoKbnSa0SuvkdONqOKp1Or0fofmNc3izoYWjPnxOJC1vkq+OzN+HSq0t+12xW2JtiuCY1 BKDHbnr071wWtoVBaH//0f5ZH1OHfHlDLcKPnO0CNGGRkGiG9tkjlgj2NNIxMq43EluefevnHZQO ty05S5ZtuZ1kjdTGQCGBXPA6VoPNp/n7xEonVNgZUwSB2ziskjRbFnSvEmraPffaraRoo4WDQCJz HJjHO7HIzz0r2O//AGn/ABdJYwQ6hMYpYgIWkEBuBMg4G5hjrx196icfeiyr2TXc/QP9lLxQvxU0 6Xw9rkUVu9pFc30l0spCXiMgxCuTnKAZHscV4J+1L8CNH8J38Gtw6mdTGreYi6bMnk4Uv8rEZJHB xuU9+/FLD6V5QRzYumo06UV3P//S+DP2GpIZtI1q5mWNZNKtW01bIAmFXC7Fx6ja2c/T0r0z45fB bw/8SYd9wLiyu7Y+dKYwrWk0aheCDyD8vv1r5TA6Yqojp4in7HBRkukTxH4iaj4f+A/g2LR9DmN1 4lFqtzctcM9tELdoy3ARsbiGX8B24xp/sp/Em4+I/iW4Nza/aY9K0cyCbTgzTTGWVCsL7ssSpjPO e3TmtsxsoJRXVfmcuVL29KGJ7J/qjJ/bjttP1G807VkW/iupLN4b43sirwkq+SVQcghUbp/Ci1+T tzfG/cxwmZFx5nnPGQEGRgEHufQ1pVXuR9DlwUeadT1NRrmxggSdIA8w+RiiDdxxUFjexw/bBEZ9 13+9lgbKrLjsAeM1xySTO1PlbP/T/mvurmf+y0nSOaZ4ov3dsgBcZ6AD+tZNhqVtDcLHcxPDI2Cq OdxSRiMg+2T+FfItaJmrfuH60/sleNvA1lpWp6brOnKuo2jx6jYGSci11ExwIGVEPylizHr1x276 /wAbvA/hX4ixtc6Zqq2OpSTrqN6bq03xWixcmKOYN3JA2kdjg1w0VJZhJyelv8zGdStLFrlXuxSO G+Enwb0XRfEy+Jb+7We5FxbQ2Cq5EcaqxzIi9ueuQeo5r7x8XQnWNAm0a3e6t4ZrCOzW+hlIeBSg R5ORg7wWyD/e713KV6ke2o8bXlPC2kutj8aPir4DtPhh4q1G1tvE9v4hsLmQ3NvdoCHtlY4KOcBc ht3TPTrWl8Pfjt4p+Hz3S+H9Y1PTo5IhCTazJ5EqkckIVPzKc8gfxdarEL3rlQcq+Eu1Zs//1Px0 l/a98VW16l7Lqes3i3ifZ7v7SryrMQSd7KQGUk5+YEDmn6R+074kN7cX0NxcG1vbnedOjbhIxjco LZ2n7x688ZNfKyk+Sxn9XTspNn3R4H3/ALQuhazpv2aO0tprGJJZb8qmwJsdCj4OTyG45xX5ofG3 wJrHw01DVIdVto5TaakbKZrZhcxKpbajBl6g/L+dcNKMo1JJm2JtRxVODfxJfetTwKNzErF4SMYZ Q3CnPTFaulz3FxeMrQsyAbUMgxHnHGP5U73OqMU1dmlBd7ZDH5aqyvktjPSrouLe6Lr9o+zSwkMj tGWRj6cA0i3FM//V/nwtnnupjMs+9BGVkjPKsfWs+4uVa5ezuoUNo+PmEm3dk8qRjjt+dfDnoJJb DWuWklWGKNQIm24xwR2xVm6lZkSNmEZHYfxGgmTshDczLF5McCpMDt88MTvH8qmQtHGI541lEh+Z GG5Wx6ik2ktTEjtrrzGLLa/Z2jJidVGY+PQ+hq61zutSI4XEnneWqgZOP71ZOTegH//W/nqVZJp4 jsJETZm8xTgj2P5VrmKe/hlJlETK43REgllU/L7Y4/Cvz57HQUYW+w3C72RfO+9t6tjsa0Yr1Uut +BJCGGIyMK/1qWm4oaTeiLV3eTKA8RESyNgQK21DTZJpVtlLQS8/NIo+cAVkaxjymdHeXKQ/Zokl aGSceXFHDmSPPHbnFatrbykzQu7Q9A6MdpY89RQUf//X/A1bEae5EZG2R/MkZU2qKvXLxXAWMtvj kASXf/dr83PTgrSsW7Z7UN5EXG1NsarwnFA6M0u2N4yQTGcDHP8ASgq/v2KyC4+2wGG6iW12FZtw wZCcbfm/P861mMAu0AcBmGOOVGKCyCURQXUsySfu3+Rkz0I6mmwgOZYkcmKXv1U59f8AJoMZfEz/ 0Pw5vcxJaxwmEMijKooGRjvjvVlJNTgVpbVEnklTYyu2FA6EdD2r83PQMOe/bTJ1lktpXNw+xGhi LJC3XJPYfWhFvppobiJojb7ts8bDBAI4I/KgDSj0903so+/8zqD94e9LZlZrh41jwiLgK+A0hHt2 oA1jeSRxLHPGiFptqELygHU5p0zSwW7zMvnJuCBuBt7/ANDQB//R/DeW5jkkjjV+o+Ut933zVa9h aIBo7qB3DkMkb7yp7E+x9q/Mp/EegOsLsxqvmHLB8Ngd+taE+sPvmhiKFggyR/D/APX9qXM7WAy3 muJYXEsaowH7uVRiU5HIP5Ve09Z47NQ052uuJRIQmcdC1SBHcDy5PMT55Lf5x5Lbz+GK0Yrm2urF XRXIxg+YNsiuOG4+tAH/0vxESxuXt8u6qeqgcgegzUmmTlJDb3UQljSTdtlHy5Hevy89Anubm1kl dUiMMbNtOxcKR7Cp9Qu2GlPbCGT7Lc4W2O8xGM5xu+oGazX2hPYwYLD7Hp0drEDKVcvuY7mAPOc9 6kitX3JJccsw3Lu6AjpXYtDWl8Brw6mktrHavCI7hSRhpNxz7VDFHElx5EzZaboQeUoRof/T/DbW LaWx3f2fLcyBp8tEjFlPufT3qRnm+wwSIFWdpfLuEdtsh46genvX5nPoevKLaFt9QtbTbDOJhKGA 2eSxj5/2ulF1JNdXEgCmQIA6nb8iA8AD8jTfwHLL4WaEV2IbeSBlKuEG1ypABq1Z20M8cWpvJDtt pDE0ZlAlLEcHZnOPfpXJD4kbxf7lIbPOWd4wRIxHLHpihftjgPbSozw8rEx+XPuKL2bMY352j//U /GW1sr/Xba6nvRbD7PKqLawkKzkchtg6YI6+tMvXCabcyy+dPcphIUii85myQpJHXgc1+TqdkjuV /Zu3cwtMkh3z2moy3EqSw+XESdrRMf4uP5Vo3Gbt1tzAnkxLs83O5pceoolO61M7yVywUX7KER97 occH5kx61XW6+xxCTf5js2HjAwVH5e1JNNXJlJ2KouP7Qumtyjxx+X5gk6DJ4x9a1FjghIhics6L kjOSaOptSk+Q/9X8XreR1uCd5EecPkH1xx+tWp4IEuYp4zHKpfK3AHzEHsfTGK/JaluVW3O+s24p PoWmuSkjTAApGCWA6H/OKzheW17I8oI88nKqoyNv+9+X610KKSidvN+5SfkX5rvybeNPL8oCLy1h 24jbjqKzLSeSWRAbdo0BKSlh+6I9QfypVeW+g5NymjZWOdrYmxvGzFcb5opgNmzgDZznv+FSfOGC rJsmk4J/hPbmsXszRq25/9b8eL0QxWcgmbyJEBBZRuz75qAJBFYWaWG+aUAG4dgAp79a/Hteax9B OOtkaFgr3EUstwksCwk+aGU4ABxkeoORis0ql/LuheSMF/KgidSkkp9cfh+tUlrJGSvzWGXV6LeC 30q2jQXSXJkvp8nJDYwg9xjNbVnJKsDGTaDvEYY+nHJH5/lVaqKYQTVRpjo4XgleWWX5GbIAUbVH +efxqSWVpJkESosjghZXO1JPxpST5C3dQTP/1/ybgvbK2hFnPlbqT5llMmdx6sqj0/wqlcBWZXkI Dg7Yjjbx/Wvxyd7pM+lhJT1KkKNILtzPt8ldxOQGOePlHfqOmaZbTJKfOZy2w7ACu0n3xUz3NWrJ GnYwma7SG3u/KeaYLIk6bINpHVW9uTxn+lJdKljKUguWmmW58t2Rf3UgB/Tp3qVBt3KlTbhFp21O nuWuDbRxRM0AeFZHCt8rEjI/nVKLV5WtgswQvATHG5GJCPeqULu72MqsHdSe3/DH/9D8ntMkv9Qk kWYwXb4ICRvlosdFUd+Aahmm0+HS5pkglW8MjPKLh/KSIICNo574zn2GK/F1Gex9JKLcrGrpcZGm WV+DG8N4nmIFfcEOeQferEs+6QRR4RiNxB/i/ClODW5VRWkosz7rTIQWkkcAffIAwV7nFXNPurB9 PhuQ63No1xg2+zfIXiOBuQ+54J965026cvVlwgoxa9TNsb3zZLtW3xrLOUNm8ZXaqn5Tn/69atxN ZneCPmWPCIp+8VrJLRsdNWbP/9H8pbSX7RdQRSWsTbm2oknG0ngYPatCC3t4L7zFX7OhJRoYzuik bP3vr9D3r8L1vE+zik1YsS6ha21xLc3UX2ey0+MGZnuAPtBJxgIfwH4VQhhjCSG2muJHlfzN0uNu DyAv8qpvliKp7sZWLU+2eylsRKY7g43BRgAH0Pr7e9UY/DkL6hagKyzRRh/O3bYRj1PqfSlOXu67 HLKNRR9rF6WJnnIumhl3MpPlyrH144qxY2EUyyXKoyRLlQ7qVOR6k1hz68o037GM09T/0vylvbW1 KZllYBpQqSKPnjOeGFb0upw2mlRATrMVk2yKADLIcAbm+tfhLaUlY+gpVOWq3fQpz31kyxS+T++A wwkOUYdQMVnSalczNcTiztYIC4j8uzJDTDjqp6fhkVVPVux6OHnzw9DRVLu1SS6tYi6wxeZNCgLv EvA3t2C5I5rMh10/ZL25lkkW4tjuhhAEqDH+yeOcVtTVqiaNq0nGCt/Whl6TfSwpaMkIllS9N3KL j5Qqsdw2+4ya7PdHrV6ZLi9ERP72Z2YkHdxlvxpVt2+wlJ35Wf/T/Oz7JFo0MCi6S6lkOyCKBxOg /uliM4z71onUrWG1/exQ/byX3wzoJY9uBgj8Sfyr8HhLTU+5jVafKjkr/WrWTS9P06SLzLqG6lkh ldtrQiTGQvtwOKybtDbWrLbnzA3zMhPMrHqPpWFGXu8yXUqnVl7a0loXdM1Szskik0iyNjewp/pD SsHWeQcE7SMBT6c9aYs0LXc8skn764Idgx+VG7j6f4Vv6nR1Vu5V1G/u7ZlttwmgLB9qr944xwcZ qnbPabZbhrmWaRnx5LnKRfQfjWst0ZRd669T/9T8n3SBLvzLVzGysHmK84zz+RrQvD5pgId5VdhE 2flKnB6V+HxlCc9Foj72pPmTT6Fq2vLaymkljt1ubpkFuzkgrbrzyRntn9ay9StUHl3IhhaJH3TB xjr0K++e1awj7TcqetFvohluFlDlolQkZR9vNW9Vn1DT7J7ySTzYVUssSvv3YHZc/SuWrTSlZLUr CzbpO/YxbTU7q+tzbH95FKFuZv7sfX5atNLewhVEoA/glPLoAOOPSt6cf3buVTaTlbsz/9X8mvDV 7p8yagNYlvL2SRZEs0BEEav0DMRg4HX3xVWWB0l+zPNHsQ5EJ5JHUH1r8S5Ha5+gdDRGye1leK4h iuIF+Xzuen90epp0Jt50LXl4YpYYy6q43CZgOFz2z60oxuJySVzJh1V/njt+Iw+6VOdnHr7Vzd9P NdrdSF1smb99DErbYztPC7uvP9ar2fcylK5pTwXN1pVvdQ+bZKUGdsu5QwGG+ozng1LHc6da2lxG Lm6ku5GTymMPygH7wb05+vSk4a6HNd9z/9b8eoszyxQylnizmUFsFRye/SoYbm0RJpVkn86G4MUS GIeRhTjIPf8AlX4g1Z2PsCsut798EMYLFsXEnUye2fatGJonKGZV+zQxmRhz8rYwvA9CR/8AXrXl 92wGZe3EbTCJ18oiPcuW3LgHqPyq5Dd2UdoFknzcuxwVXKBf4Tn1600ktEBQ1K+ZYIZCoc+Z5e1P vAf3iKu7Y7rTllMnkqzALEHw7kdeO1M3WqP/1/xoi05rmWOQsVjhUrw5wx+mcVq6fIbUrB8kmW4j bLMuMnr7/wBK/GU7Jo+6jpJFeXU76a7+yokNtHu3lUbBlx3JP8vemzLIwaDakdu7iV1XH7x+7H9f zrWn0R0N+8zNNgJLpWgDtErYJ5wAPWugbUrgRWll5sa2tsZBLtX5rkEDYp9NuD065rpkrJo4ZRtE 4TULiZr6eRw5jc4WMHKIB2UVbnhlaSBJLW3hgWBXhljA8+XIzueuZEKLex//0Pw6vJ7yG8ECo0jJ B50ca8K4x1z/AJxWxLYFrGKa/uRJ5QS+giik3Lby9hnjkZOa/Hz7Axo2Z5Dc3qGVSSXfJckd+fWt bUEsreSOG1nmiNxGG3MuNoP+1/Sqt7ty1B31EmS902H7PHPHdw3EKus8c4eQHurAdKyfsrQLFbzR LEsknmM0hwX3YPOeMdTVQXUOR30Ll5e2BRrZYrYiBdjvGv3z7t3qPR7fTYI3V7YJ5g3xOSXMeeeB z+lbKLauTZn/0fzB+FnwcbxFq1ld3RuVsTIsk6RnflCw6DHBx37fXp6d+058P/DnhQ+GJ4LKzujN ZyTWYtbBdPexkUCKMyY5fcM/MT1BPvX5S4tLU+25Ve6PjCS4SJpIVMf2ny/MZM9AKv8AhaS11ScT sySwzSG2hlCllMq4JRT0LY7DmlFXdij9A/hd+z74eg8L3/i/xbbJfm5jFta6Ndu9sLJWCN5z7QCO C2ee2D0rvbP4EfAxopD/AGxZ2mnXYUx2z6uLCYFm+dGgkAO0dm78da7qUbmFVdiXVP2P/hZrGmeI H8G6jBqRghWAOb4Pbys+A1uWU4ACsWDcDK9a/LP41/Cy9+HOs6x4YgtPI+wWvmxqk32i2ljIOTBJ /F+BPX1yK66UdbI5Z/D/AF3P/9L+STxvClxqV3FKgEttGDgQk8HPz4xyfXHpXzN4itxb6qNPF95s rOZi8YPllfQEjjuMdiK+OiraI9mp1M+2thd3Xk3EU19GjBvIi/1+B6Dv0rob7RYNRvtPuPDSXimS TFxpjxAGzVQMFHySxJBOP/110W0see1Zs9EttRexgEV1CSbZcynncCOoC/0qzq18LqbT/sYNvEOs i5aQyBc8r2H/ANaolHqjGK1aLegarHb6m41GWa1ktCL6a7tvnVgGzxjrxzjHevv34f6jAtpaXUEU KeeqyJcXC7PKB6sAe5GPvDPFceIXuoKfxo//0/5PNMiskkn1eztTHfnd9nvTt+0IuSD05+bjPesB rSJdd1KDUY1tFvdG/tDT9Re3f7PLdB+YpGxySoPHv1r4J3eJaJqxvVvbctQx3DS3F9FdvZyxWsdp HahAlncLgh3A9RXKfEKxsNR0jRGu7eO9vdNZt8jAbVJc7XKjuAzdP8K76KtJIq9mj50v9Ji0+e58 omYNJ5isWJxnHTNXEvVsobG9wBJYTrdwbl+cOv3ePxNeulqjVztojuIfFWo6zpQ1L7B9o1LU7wWT 28C5ltGBUiXAxhCON2Ox+tdRpnibxhp0j3ZEWo3VhCYriWSMSJaxMoiVT6gBuvXmt7aWHB+7b5H/ 1P449TSa8uBqUyRGcKs0zQYNug2jooHaiC3tZtVtoold4LhFkmmts7UPBYbeori5mo6HS5N6Fy8s rK01C5vbW6u7qzR0jtUMhBt/L6qoXHcnOfStG61MalaySCWwRrWdFmjkhxfMxX5WViM4A6nNXH4S JWtY891+WKaVNL5vJVxdzCJTJC4yCg39N2eoHpV+2SbUJvP1PT7eSQWyRWjzJ5UlqUXaCVGATgDO 7OcVQ47I7vQYVks9Q0rULWzl3ASW9wnzOnfgj04rJi8PXFmmuE3Msw1jZBLDI3m/Zwm3aIPQHYCf rWbTcjOa1P/V/jfsoWsr0NPFJd24J8+Iy+W8CoOqjH51rpbaZdQzXDgAzkx+SH/eR4xg45GD2/Gu KSskjGSszk7fRY9Lv90KQW0YkaaJbVv3Sl+p2jjJ4zWjFqVyI7mwhnlEdzMGlh3E7sdB9M9qzexf Ii7qSRixsriSNI7iO5+YyAs0igYxz24H51Xg1D7Rb/Y5Ioxtl8xJOEeIng4bqAeM/SslFt2M2rOx FbwpbCWS6ubu5udQuUtooDOXS1QZ/wBUvb3xW9eFE+bMjSmDyI9xx0x1ocWnYR//1v47dO1WKGbb NELi1hhPnHdhYWJwCfbNa9zaWM0VxdlCXEIFtaRjmdjwu33+vHSvHMoxT3Jo3ttBtjKZ5BcTKB9l SEiSFsYOT0OP61nXAUQi/N5MzS/KGbHmM54APT0xRYgneyvoLU3cRhjeWIecUO7PHf1q9YRxzBGi 8kTXeLYNM+Ft2yMye368ZptNbgQWq3Aguru+0m2vprWd7O2mefcTxjzRgjHermmwW9vAlxI7QNJl GtjiSCR85DDjORyM/WtFH3bMD//X/j61WK8iZHcSCJ23b4ZCgXHqRV2PVGjSGWMrhZAT+73rIMbc cfhzzXnJWFHZEsupxr5xFkLdn/eSXqIfPGBjHoR+FdTp+rX9i0Vw0txbTXVuAtwJcPLH91BjqOB/ KmM5bVrf7a8p3wKhkAMoINwccn9c1c0yNoQlpGERWBIJbDPnqSSelAEsZgRpYfLVVjDTnCYhbnk5 xiubvRafbrbKNC8zAghQkAH94noKiewH/9D+SLVLSPTYoGkaKaSaFSotmExO7gAYz7VctrZoodyi az8hBJlDiRW4JIyOM/1FeOTrzNGXBfwi8jjSG6Mszsshurg7ZcdGCngYH+RT3iurmR0haJy7lkDy 7UAz0z24zQZyTT1PQfCHhK0uTewSWdra20sQknv5AXYvz8hxwSc8k+9ZHiLw/DYK8cOpwXkcEuVS 1BY269mc/pil1sPkfLc5xBBo+k6veXkUWvwyWL/LcKFu4XP3BCBjdj8eOtY9hbo9npUi2UtjZmMT KjoUXnrj8ePwpkWsf//R/ktk2WVs5khe4t5pFZIkI+VScbsf56U3VdVivbUW8tvCttGQ5LYJYLyA fx5ryW7qxyTWlzN0bUoprmbdah7TZtd+ksYz1WugtVjuSfKTBdWhhBGwSA8c/WpMtjFjaI6jqGj3 0k1lDYHzFihhEkZdlGQOfSs6yt5JtQQ2t3HZ4uVhe7mUt5KEjJdR9enPBzQVdrQ6++tJbm3ltLWS GS8BLw3Ik8rCjOTg9AevTtWdHZiSD7O8LyXd1BiK/abaImj4LN29cAjtVRvfQTbZ/9L+SaztYrSG K0Mh1C6EvmveTKN+TkbVxxgf0q/ezGWC4sJcP5Y8udc7JocjoeeOvevPPPI7rSbRIoLaCWOUm1jY sH+ZGKgkfUZx+FaTalLpdskoBUQoqEKC5ToMgdf8KlRs7jjo0Zha+uR9pkRRHISUh37nl6/O69jg 9K1NJ02Ka5UXCxRtJhI5ZBsaPB6j1qZJs3LbK2mzrNeSwyKjkLEELLIo6FwfX0FOhuC+ZIFyjtu2 gYAHasy4Ozsf/9P+TDUr3Vb+QWyyvcW8yC2SOdcrAEbPyk8r6fTNbmoCKO0RGiia4EKxIAcqxGOf evHASwto2ivfPJjmKqYJFcCBNowQQf8APFYI01Y5ormS6Z2TJeBmD+YCT1PUdOKynvY0g7Jlq+t4 JZVmYkR+XhouznHeoDp9zHoMksUCN9nzJHbvN5PmfNnhiO/9aldRxd5MmsruykvLW7toJbW/Fogm QzebEpA+dSO4JrQ1e70i9MK22nXUl1EB8zAIoboQnr35rO3vlTdqTR//1P5TtSstOQ2cFozMDZrJ MpQq0UvO5c55xxzTLPTtatAZZLdItOlY4uA+fNULx1GAc9ga8BqzsYOOmpnl9PvJLq1kt4r+1ZNx M8QfBU/Nx7H1pG0+zkihitPJt4bVTLaeQgt40cjkEADcMZGPXpSM4Kw23/cCfTdOuLfT9Quk3PO6 KyqM5ZwDxk/1osphfaZcHVB5AtrjPnpzcXO3HVemMjP+RUy0aLsXIr63tZbf7Q8ltbXJ8tJ1gaaO QEcFsDrx0zV4RebKxGy4s8nY8sJjZ/QhTz+dW1dnVh9Ez//V/lbFvGqQzi6hgAuPLa3DqJHGM/d6 46c/WoYvsMepyzQIpuXt9hk8vhF6Hn15rwoK0rCk/csLqWwxhUk3q7YyF2joaoWttPZwOkYSZLmQ i4R2wLaPrlT+H60vt6msGvZ8pcXSYdMga8vpd4ul32P2bD7EPGJBnIPDVXiDfaEeJm8tF6kDAHNa VJK7SMeZWaZXurt5ppY3gkt40Aa3nYfupxj5jntg5GKr6XqwtpCyKBfSlopWi+eExDoC2O/pUQ0Z nJ3Z/9b+TfXHeWQmzjMDzIDJGHKrcDI3ZOOnU/WnoXgSOcjY/wB1JUy0qtkAYH4nn2rxr6tHK9GE qWvlqszXDAuiFAmVlOckkduR/wDqrUl1vFwtjDDJp9jbgNEy2/lpNIVALs3VjwB1OKuN7iklZrqW IdPN0Ymht1My5fzfLPmT59vwNU7fSrpZHa9gCrvZo2Vidq9him59Hsi3QkrW6ondY7KFZ32h2UmK CTKyL23Y9s5H05pgu4LK1uoHjuJbi+Cg3Zz5uAQc+mfpTdTmpyijGFOSaP/X/lamY2MKeSTG4G4y SJuLgjqc1hz2xaJbu4VEcNviCtlmPTJHbOa+efwjceX3WaEMkktpdhI44LmO3BgLsR9ozgbTx7k1 jQwRx3MUUpUXEH77c/X5s9/eotaaOWq7M0J5JFcGIBXC7kPQE+1S6ZB9psQ8qyrey3DI6sgEEa54 JbOc1pK6ivU3m7xS8jrbvQrHT4LBlBuLhI/N8xvmhLknBH09O1c69xeTTtG1sqFiWMyNxnPTb29a 2pPVepjSVnF+aP/Q/le8xNOgKvliQWeUjOPrVXRZ9P1m7u7aK6hiETDzZHbawJ+teDL+OzkqpOq1 0/4BMBZW1z9kgF5rF+10IDsiD20CAHe2VAHp27dazY7m4vZ7iCGJAqSFdyEquF6KQe/Has73mLlS ly/cXr6CcWtmikeVHmSWJTlFburD1OKhtbq8kd3kUPZuoSNUTLNjqPeht89glTaTlItwzx3Ek9xH ZpFEoAghExd3wOS/oc9uaeHEUMr3qREyMCYJm8xWHAwBVWFTWp//0f5U9RkvftMAhjWZGZQfJbdb Wy8dH5HH1PIrtLB9N0WaZr+NL4XNnsilyV2yY3DODyB836185HdmShJanOtBp+oWV5N5FqZFmaaK wktXDKhycqcY3fX3rKjhdbVWWAwiNd5U/IQAM4FaKyKi38TL0Epu4o7c2/2hMGRY2G2QEgZHr26U RiaK7tfIEbuz7VicZVew/mKt3aZopOxI955d7DFcKqxGUpN3OfRe2etZ8cc63d7BHbS/ZIzxLIm0 OXyc/UU1rNHLUcnBrof/0v5aLbQ5bexjMiI6O7EEHzV9QCfXkZqO01J9N1GOWJ32xId1qEDJP6Z7 8H0r5ycGnojgd4SvbcWS5mVLq6ullSER+a/yHzUz7dc+1VLYwXZXeJijIMy7SmR6ezc0ptbGj+Al eRbfYmJGaIAKGfdI2Bxk981dklNyUtzYWun3V/Mvn3XnAQeUvAG3HDcZz7Vi4tyTRcetyCW1g0yP Ed2JYoZCxUkfvASccfjT9TmRraEAjczfNtblVx2H5V00FeVialktT//T/lptkDxqGleXj+NcEY7Z qO4tbxFlnt41aGQYtyWwQRwQfxrwZR+JHnxvyO3Yoac97aOj3Nk6SyHaVY8oM9fyrVvY/tt2l0rp C8fzkOwRZNo/irKGit1Mqc/3Vn0K0F5q8wB0a6SMurRagS5VUjJAyuOp6cHjmte7urlY1gMKRRxE M84G5p+PX0Oegop7G0IWjqca0NpPe3zXjkJsEsIXhg+ckAf561tW8eYMxjEZXcN3BPvVjUW1of/U /ljlaZbYvDsVkYL8/II7kD2FV/tDuuN5kKD5+c9elfPNXVjlirI2bCG5dI3tLeK6m8zaIJJdh5/M 1iyLqS6lHBPE0RkkZnVUOYwvUD+X41i1Z2KOhtxYyyQNHCIks5MsQ/zys2d2ajv4YDPLNarKQpJj VwMn8BQ9wKMjOqJsUtITnGMD6VXjgvHvFDbUSVhlf7o9cfnSA//V/lk1h9ItGuZ55posIvlyRIAi sCAdwAP6Vq2lvHZ2dtd3bwSrcr+5kI/fLzkbvTPavlzBbMw7yyS91CJwgIV/MUqNhQY+bn8Ca6e1 Lw2c/kReVDC4Z5MZ81jx+dAjLlsJrm7h1FZnWINia2wFSbA7HGRRcWrz3a70KRou3yy2QOfT8aDS EklZlxtOWOV7tLaJUhgTdtG52IGN2P8APWs9btJ58RKUjxuZSmMn0oKU1Y//1v5Y7mFlSXLMzM26 3gcBYl445xnr9aoXGkXK2yzXIjS5uoCv+jyCYxqe1fLmMX7wkDRQaSYV8yW5hdIgrgszoSAzN9Ot aU2l6WZraBrGNBaxLNDdQsxZn/iyM9Ce2KLdDYbMtr5LT4xO2UijkG0SEDj6VmwoyyRzvP5TJlnh I4IxyP8APpStpYynuR/brd7hNsgBkyVUnBOOoFP1GbUZbWJLVU8oSFQy8SAE8/X0rJx1aIP/1/5Q Y5nZBaSyMvm/I5bIx2I+ta7bLWPyIWZlWMbz1ya+QSu7HOZNxNFvR/LRiBscsudw9D7c/rW1bX2n GIQvAWjiXCW0B8uMnI5b24NaQtqkBWsLGzWGZYdsafaGlMLsQzFiWO327VK8M02xItsCLxGWO1fb mrAzHsLy5hd7yCSExSFIZiDiUZwSp/CrC2KxWckEO5QyHcGbLHPBoHZn/9D+TGK7D/6HZqZJbdfL G7IQY4G70GRXVw2+p26wLY3LBnfMsbOEVM9cN7enT3r5yC0Ocxx9sSSeHUSPPEr/AGfa2d6g8bu2 fpUtte3NtLG9yimzkzGZQPniPTH489asDZZrW5vY2gURARAMrPkScfebPQnHSrk0cizjy4YthIaY oMDAwGPHfA/SgDItrq1k1y6ms5pha28BRILmML846tj1/wAKiluo7mXddqVSJS0kwXGz1Kj+lbQ+ Ea30P//R/lctI7Z4/N/duqkoGkIDEEZ6dR/9auZltLSWcTQqqvCW2GL+Pd1/lXjgV4Jnle68y1cR RJshkdWjlDg8jafp16Vs6W3lqJJwXKNgRFiCfw69qxk7s0g+hKbYPOpuFAlVy8ccuA2Oo4qo0W17 iSRXaNGLv8mfKUeg/wAKSbWhD3NJbcXEHnQuv2faNjn5S564AotrWyaCSSVA93bHzLdioJbPBGT0 /Chu7uOK95H/0v5RXimSYy2oiBkcPLFjJb2x+Ap08cxuI3lbyXmXBQHO3HOB6V8+dCV9DVKbki3z hnj+5Acnv/Wrplit0zNEGQ/JsXI2E9G49KTuVKPKV7aYSRtEkOGDESXABHnDtntxUMFxcaXcSOLd 79JcJFCASImJwSSO319KHszSmtLH7NfsNx2Y8BatcXKRPEuq29i9lZ3O8yko0nnMOwBxhe/NfOv7 cF7JrviCHV5opIpIbiGJlgU4lLIyksvYD5ef9mtcD/DqoxzVqWLoLyX5H//T/lztDFqllc2W2aCa KYoknKlcE5yD25r9VP8Agn59oj8RoiXTG6iMkE0ikOQjRBUyvQZ+bnsc18zily0bs9CCug/b+Fnp +qeHL17pNRn1HSMWyXW1bjRYlmIcE453tCRjg8/n+SVoHtiSLdFuZpS0pbr1JyT3Ir0alT9zC3Y8 PAu9Wp6s+/P2G7LWLrxlefYrieKe9eTy2mQrbQpF5W45x/Eu/H0FfWv7cUk9t4at9Ikc3dlNYGBV 2mOHzzGksjRv3HLDPr9KWEkvayb3s/0NMxbiqXr+p+JLsNPv2FoWFvMAdkgwD16A81oWctvE7C5j PnTtsjXysrjtXDy+/Y7abZ//1P5zvhx+z/4z+J9vd3PhC3huvsa+dqc0yGNUhU4cREkZYZwBzk1y XjT4Y3/hTUEhewkt7mCcxXJwYd7KOrhuc8V84oc0ZS7HRJpSs+pxly8sX7ttz3LfKpGSB9TUAd7c xtJy5YRhxH5iRs/yjd2HXFTFXvY3W2psT6YUlSQOGuEh+aNWyrjuRVK9thd2kkKosMrKVWVxwKxq aaFK2tz9MP2FILV9ej0u6uBBJNDErvayZY+Y0ajcD0By3PoK9o/brkt9P17SrSS1j+wabBqFgt7A oKyrbSRnc5HQsG6f7NPDRftpPyIxlk6fqf/V+FP2H7a2bS9WvY79YNMe2lvZCqhnkWSAtFFg9SSo Oe3SvW/jz8UPDngTw9fjVJJVv76yRNGghj8xpXkJLOQDnaoB5Ixn6V8lgdMTO56GfUlWoU6X80T8 TvHHiDXvEPiaTV4dfe/tbuUKbS6fMCQ5GEUdBj8+BX6Z/sFyxx3sk2nrBbJ9qeyvCFVJGLOoVQO/ 3Af+BitMe3KCl5/qZZdTjRoOjHZRsvuLX7dy2cN9pcM0zfbGgKyE232cLlnCnqctgqpIr8q7rSVt rW9kT/XzOZ3MjYRjjGPYcCuqskoxt2/zPLwWntPVnM20sk2p2kSZjEEiswC7o2PbBPU5r2rS/hZr 3iO2l1i0sd0drGXLyTrB5w6gRqT8x68Dpx61xVOh1uypyk+mp//W/m51WwutPF1ZMZLe5gbynVxh 4T7j8q5yLRYtb1OOa9nlE6sqKkPyyT7ffvkDp1r5F/CjRtcmh0UGqeI9DZntNXuktbS43W1qkpgb CggLkfTvXSt8UPFhtEfStSuYr25TyXjllEkVu3Uljj5iO3r6Vhyvn5kVHSTa3Pqj9nbxh4j1Dxr4 dS81l9blXVIbe+stUC/vYGwDHHtA4LbTyDjnniv0q+PUyaZ8NtMudIkuIr2+0+G7n1GNUmsbQROx nt0ZgVLjao55A5Fb01++j6nFms/9mV+5+GOv+I9b1+/vl8R6i9+LQCGGN4gEdASynAGMnJJA4znj msuxdFmW4MYkiWPEcZG0J+FXUu9TvptKm0j/1/51Wlg1J57p4I4hGCoijyVYqMd/pVLTbmWB54nc JZMdzhUAMePR8ZHGa+TlJOJu2rpH7N/sb6VcQeG3n+0KmlRWst9NcriUswit44VUAcg4b8u9fKH7 adtH/bmo3GlLHE1wwgmt2cFJDD87Ng/dLFsD6DvWSau7GWYxf13DS8n+TPgmH7ZfG3SaBIrWSEMt weGQjsy4/Wrdm8yie1OQsPzblHzEHgfh/jWB2x2QjWl86742RI4zzuYLI2eOnU/hV+KF/wB2qqZH fg7Rnn3oGf/Q/nvsJhseGeJbd43Kg9Gk6c1DJbxtM8jIHA5U4z09RXw70R6A9Ta/KRIGl6lVGGSq Nzp8c1xFMJGfDYxn5hnrkVhd3uZT3sdFcSWsVpa2VnCskkK7pA3DoD6Hn0rJjcALI6Ou5ioDDlcH FNxkQSv5rcr8hD48oDHmjH3jVmwMdu7IQyu58wsQcZJ9akD/0f587v7TFcCVDttsgSEHAAzjmr1l 5UU52rlnbzFV+Q1fnzWljoH3EW1WEsY3M3yE8flUMsMEtvAoka1aKQNuQAh/UHNNK2hUZcpdfT4D AdRklEkULrCSzjCsenHvTl1WRJpIjb4jSMCI4zvOMGuc2WuxYs7mOWM5RIbgnPm9DH6ClWKQSeW8 qTHdu86LJD55wfcUAf/S/B28njYmKM5k2eWR0U4qrbWUkO+W4cMv8Kc/LX5uenB2lqW7Wa1iGZQU cNgbBuXHYVNcTpcfuI0AJUndnBP1oGmnO5STTpJIiDIEVRk7W61qlLS0s94B+0YUZJ59Oau65LGh Hstp7UK4Ecrucvu+/Vo2UtrbAxDEOMCZj1NCcOpnNLc//9P8LLW3Vh5rsWLtxg9+ma00nurOeNTI jRt96LHI9DX57ZNaHpRjcdfQ/bIpx5hjWVNr7PlI9/61y9nKqSA+f5cUD+XLuORgdzSilYtQVtTr rXXLL7PPJ5MssK5tjK0TJkkDBQ9x7jjg1mXl1E09t/Z0LxBFDyXRJy7emKze5LhZXJZ3uoWjS7iJ jljEkEpYfMW54H5f5FN/0m4ilsRIIhOVYknCgqeCf5VLdlcUVdn/1PwttLGMTRRXdyIQ8u0SFS6q OMnj061Nc2UNrd3C21xHdx52JIowr4/iHf8A/VX5g23uei1Z2AQQwQ5lYmZnAhQYAfrnP6VYjiVb czzwJ5it5kiR/M59D6ngUXEZkck80jtKhVN37gFShI7ZFbsdmtxGsdzNHDG6HbucKrnnANIDMslQ K1pDbiKQSmNW2kyS84Hf24x61K8sFnIyFiZIsJJEo3Fn44xQB//V/EKWcpYkxvKskxLeVKMeUeBh fbjP41kWlzfXEO64374yYUkbjeF9K/LmtLHoHQ6TK1uDLeWxnVWIKqcN6dT0NaniW/i1WwtbSO3W 3tYYiAijMxPds4//AFVnHZkVNIM51UuruC1UMtttj8oMi4kkA6FvfFWLRZFuFs7lg2043MePrXZH ZGlJ7Fu70+2t5YjHEtwVX5bg8ujA81QktY2uYrmeSW024ErKAxlUZwMHtTSsauSR/9b8TwsCyn7L c74lb70i7SQfY1la1OsNzBGih53GUC8j5R1/Wvzdq6serN6WKYjmkaN74SRxsQ7PgO6D1HODx71p RvJaeetnf/aLefGGkhUPIgORkdjkVD/g3OZtOLNK1YX1i7XT2/mRTFNi/K7J2OP0qKXSrnEd7Gsa 6fJbmeKRJAQQp24wDwc9jXFGSUrGkX7iRVWGYNFIg3ITtcZ6A96vW7R2Uku07Xnf964O4YHapnqm TBXm2f/X/FS0upYpZLi1naJzlC0bYJHOR/Pioob64e4eERsfw69ea/JIKyR3RlJQafcne1WGeO8u sBXYRhUPIPb86VLeUPJIpZY2OT3xQo2ViX1SRGqS/bt0ZWGJ1CsS33zjrj86p31uzXRUGTCAMwVM g89jQorl5WRKMuWxo2s9tbwu7w/vZF2Ijj5/w/KtBMW6LcS26xG4G2N2GDIO+Ku2hrTSULH/0Pxp a+tGjmtlYSXBdWRRCNqLjBAbr7/jUGUjhZY7Zwin5lUfKg/vV+TWT0PVqwfs4pDrK83wXdv9m+y3 SN+4ld8l4yuOV6c7uh7D3rMm0ma1sLeNJd94bpp5ZIE8vbG2MIO/+Ga1T0XkapSdNI6iaG+bRVvX tnv1gTy3i3ZmgTkbgOprPs3cWTwJK5il/esky7Xj7hSOvHvSmrM2nSdJxuJCiQpKJw4KjMRQZBOR yf1q9bzLL8knlqi/ICzYduKzezLnuf/R/H1o9PuknjubneZR5IhVc7Bg/NnvnP6VHYxommG0jDgx zGMuw2SnbwBn8K/IE7NNn0Li2lIZdXD3MKtG/kmBfKlhQhBKFAAYjv0z71PYzWflxXTuqXNrIJI1 kX75Xpgd605XzMzX8RmPqEy3ktw0yR2jyEyKIh5bDJ6qOa19NvDuhtY4pJln/ds5XcFAHJJqoxaa gQrtt9TRvbjT7GJ4biXy0lk2u23e7N2UD8KqW9zFcxPAlu7GJw0DsuNvrtP86covZGkrqCS7n//S /JqzigmuoItSsoZBbkmFyRH5ZYD5ncDOBjpmlcRXkjxyECKFm2S7cgEdMEV+QtWdj6GnpJpbCpbW D6fLuty1zGxNvdbiGj7HjoQRxWRp0DSiZN8blXOP4cexrKpB8xrN6FiwvI5mEbxANDIdpGCwxkZB +lWmZLi5jtIUD3E77cd29/X/APVVJWOmVROlG3Q2I9FvrWQqt4sunW8YBWXKToScBUXuBk9Txis9 oLVDOwkZy0nzbhwo4/KmrcugqjUrw80/yP/T/JC5srbSLuBra9a2mcGRoosGKTIBXB+vNUWT7XKb e6RZoZDudZRlJB9K/HktNT6eWlRHWwadHp+nCazYyRKdyWhb91ABxgenfilkaznMU7OsdxEnyfNg jPbFZTW5VTS0XuY721690rvdSSh0yufmjZc+meDxU5zHJKIkihjjG6QZCnP0rFU2oNfMVPS6ZE0+ yTfIeXX5HUc/WrlpYWQhMtzqRjlVt/lvAzkqe4I9PQ/nWSikrI0pn//U/KZVs7lJY47kNcb9qKqe W23sRVFy0csQVpisTFZEZdu055x6jFfh/KfZKShFyZDdKl1KI3BubeNg8w6g85A/SrP26GdIzpk2 Jy7WotJl8tY2UgZP+e1DhzrlFVdoSuazXK2osoZIGmuWfMkw+YI+P5Z4qzZ3dw0sksjfvjIRGhXC fjTnTsuUhStS5XsKbW/F6JbqKPTzO5mFx5ZFu+ehBx9PpUUs2ty+fYwTpJpkIZpZgf3YfIVVU45B 5rCNHbTQ5pa0eSPc/9X8qLmGeH7MtwBIHQfKhzk+oq2YbW1MdxJaJN5zBZoiSmFXuSPyr8Kt76ie /Clerr3KIiSWRZJY2+ypJghPlz1IUGr9tYyJNHOERIJmJhjDcgjsef51rQWjO6ivZllhHdR6gZWM bSR+V8jFEbB4HH5/hXNPZW8F3aq5BtpEL3Bzk9SAMfga0hF8yRvU1cUb91ZRT2sb2qbAPlWfGEIH Y1z89vcxRPbJJC7hg4jdgrSZ43epAx9BTnBNSXUdRNS5o7H/1vy88N63BpRvrWTRxdS3enfZ4pxM FeOYEEP05xhuP9rrWfcX8s1+4KeRsgVmaeYFl7EY9M+n5nFfhHsdLH2UE3O/Y37aysZ4o5pJYXnA 3ny5A7p17Z4zVGeSFJmhkHOAY2BwKihQag4ep1cjnLmjsNsJCt55Vyy3ckjsst1NiNFUdAPoMD3r GleJ9SuUt5CYIJTtZgR5g9s/l+FW1bRlRelmKZ/NmbzZShjA+zAnqc84+nX8avLp0ESSzSv5eRvY 4AUt/tVc78yJpa19ejP/1/yZtDdwrdXMi2WHb92vmEvIoOFB7578elTNeSmW2JtwsKEtJJvzvPG3 C9sc96/C6Ud/U+2leU3DzI79FuLuGWFWSOeRRczRHZK2Dnbj0ODk1r3tla3al7vaNPs5FufJMu2W Qq3AX1I/pThJwqG84NUnBmbDeI99cR2ysbaRdqbwC8YB6/Wn3SXUwa3tgJMsEy5wAvc0Sm3r5kYa LdFxXRFGK1lsJpI5IliLHypljlDpMvGG/wA+lMvFMH+qB2vwM8gD2rS7UbIunrzPyZ//0PyPtzBa hE2Kxb5wAPu/jVee/aa4eVdKijjaMR/brh2S4iKk5Ea9CD7/AIV+Ln3d/csVYszEptaQO+GIHIqW 9Bhlht4VO2RQPMY5w3fPtQZydkNlP2OSPyVhcmPfdpncGHOARXNhZ9RhkjMAe2850lndSEiIIKqp Ax+tBk5N6Gs1zJDZLEJPOMabVUnCj04qtYoL6xlla8mi1SJzDJbrB5cXIJDBieQBx75oJP/R/F5P tECNCcykqyySF/nY56YHbGartPeyW+EjSNFYIEZwpHYkjqO9fizVz7AsQwRWbxeeqqXbPlxn7/cn +f51qRm3uNSuxFM0LTW5ltLRYv3eI8A8DgZLDmmBDeabd2xUXsa/NEszSNlcK67htyPf9KmTTbG5 tI4bQqspGJA52MmM4xQBjXFk+7yhvd7dCzDqWA60yK7hvGiWBn8wLh7bYUdQOD8p5+p6U4q7szdK ysf/0vx1SCa1t3eEttc4Ac4Kkj0r1z4F/CjUPijrMNjDqmkWV7HqYtEs7u5Mdy4ZC6SuuCSp2uPl ycr0ORX464q2x9zHdHpnxm/Zy1r4a3lvcav9jmbUZGi099MDvHLLGA0gUlQ2Sp+7gdDUHgv9k3xb 8SNGj13QPENnZr9vER025thFfBNgIlAdgCpbcv8AwE1vh43iaVG4zdibxr+zP4+8B+G73Xp7FrmD T5DFdwqI4pX5wZUwTleevTkc18ea+txpl7a6YLK4a+ulFwxijLxIHOPmboDn1raUH7yJqx5aR1Xg rw1qvi27urGDRJ3XTF/0m6aMx+a5I2LHnhh8wyQcD3r3q9/Zs+Jlpon9q/8ACNC/tzCLjz1uRGkE WQOcbiMdDnp7VzKOjaM11P/T/M5fgH8QrizuNQj8JaiktrIBPHK2yKOFsAy+YVA2k89xjvXlviPw T4j8Eanquja7ZyW1zasFXchW3uY5EV1ZAwBONxBI444NfkTjZH29kczaWUxiW3ZQoaQbA3UknAH8 q7+x+GGu67brdvZ3VxbxSLbv5MDz+ThcgHAyPXFOzcEhmbP8J9aD3baauo3NvZEtNE9hJa3LMOSq hhhj24rJ1bwjq8UVna6lZ3FtqTW5uoo5o2+SMZALN0zgcjORThdaBY5uPSJQjrLCAqnDgr8598de 1bV/o2qaLDZGw02/nkvWI+2xWLvbWYC7g0rkYUf4GupJpWYW6H//1Mb9iTTvE1j4esofEllpourz SJTdrNZxQpFGrGUSl3XcCEB4PVmPA4A8a/bR8Malb3FlcR26T6feXZvYr0ymSS2gGYgi9hhjkqcY yOua/KpX5UfeuCufmHeaBqNnBcTXsBTzrqS0huLlPJ8wIQTtPQ/KVOB6ivpX9kbStCvfHWi6bNos Nzo7TTXayTWAubY3EWBuCtx98Kc+gqY6NFWWx+t3xtGkaJ8MdJXQoLO2uW019R1pkcQyX7AMNjsT yWJ4UdMV+EnjPxTf6v4r1K4vNTn+0y262TW/mAw2ip8oRMccdM9TivSpLQ5qkbH3v+xIurazqWo6 RBbQJc6zPDpc9oNyQ3Xlsk3mhT8qtsUksOSAa9H/AG7PBfhnwx4UsdTi0D7BdazO8TXEpVk01dwj /cv1Afa24HgDb711UbcxyVVaJ//V/k2+KV8NO1C6uUacXy3H2OC5sY9yRxFmY+YT6Hg/U18va9AN Q1P7be30s808nmyGNFEkfGflAAAGefxr5SmtLns1bK5TtXis9RF8kAE0kAhilWRiyrnn5fU4/Wu5 06Wf+1LabSNPvoba3s1e91MSjZBKepK+meBjpx610W9yxwS+Jm8NMv5LjVEghleUQrNEJpA73GQC do7c/wA6t6TpkyjzL+3+y3MD7pYZnBc9MDb+v41lboZL42a2i+HdNuvE+j3dzd3sMcOoLcy21lHv jugvIjkB42k43e2a/QG2tEuND027WaEpdsElSOMRyQkHDLgDjtj61wV9IoVP40f/1v5Wfhzb6Lda NNPNdNI9t5iyBipncniMhe+CcfQCrV1atd3S2kssl9F8xjtp9oEHdAvAwARnn0r4OL/2l3Npw/eR PPL+PUNRj0eynsY4m064mmv9QhkYRXQbIRWHTIPAx/Suc8Z2qWMFzZ/2hH9oNgJZRbTJOkAYMVBx 3OP5V3Qdpohx9+x4E9wkrrEEMu9tolcbdmPrWXPBJukSdhgt8q4wuM17UEtBzjbU6PwNqMdhqGpS zi5YRwokbJlwjBscL7ru6e1e9u9vDaTxG2W4TUbPeURCVbpjJH8QJ6deDWg4LQ//1/46o45LWG5t V37YYsyz3A2LsP8ADnoai027lsb63ngmih2qRHt27WyOpz+P51yxtynQSz3dnBPscMzuxkYouVkZ j147k0y7Fjb31gXZp47mP7SIFbZ5u3AkjODkfj6inHZGSTcmZN1dXAtpZ7TQrW0it7vEVvFd77md C2AS5yRgEnBq/tkfZNFFvjmQiTBB8sgdP50zRKysatnfXltdWAtYLJ1CmK5jnYoSO3P1/kKL/Vbi DUpbYxyxXFlGbqRMERR5zgBj3wCRQTNaH//Q/jcjltdREV6srRT3mU86U8lM8lvxq/ZWdnYW1xNd 3byrNcLGQB+8AP8AdHp0Fck1dBYY9lC7CaMtFGpLCJTnf7n69eKq2KxwXKaoyF44LgxpHICEnI4Y H6A9fesgGandw6hbS2s++DybjzrdEffv54y30xx7VWsLa7jAu5bXcASIYJTxcEYwDj8OPegnlVjr dI0fU9W1G7ntLEuttbpPBEqE3EZLBGxGMnAJHPYZrmru1vLm8Au43uI7RxidvuxFs8jn1J4o0uQ4 SSuf/9H+Nyz0C5t9SW/W4hu9Pn36a9mZCoRuGWZh1IOQAPVc1009wbMFGtl+027CNo2HCbT2+leV y+/YiCa3JL+aW8glu7iZfLeXzI4/JCsrkfN83Uj2rnbW4W9nktgJVWJBM7vC3kMQTjB6Z4+taJJC 9m7nVadOjRSeZbSvFtKfZ5CRETyBgjp61kwT/uVM1o9jLvc/eDRsoOAd3rxyaUr6WJcGiGC3lvEe USPG0E5KMrcTD0PqMYOPYVZvLrURZ3GnW6IpWKOe3vJYQcMxYOoJ9MD86E9bCSb2P//S/kGeSQwr ZO0klwYsiAr8hOOST26Hiq9rqECWaIbGXStRic2ioxEtpJtBIdee/H/1q88SVlY0tMbWtceS1TyJ ZvLKj92sKNj5ievHQ5Nczrdxe21xFeQ3t1qMFggt7jSYoVPlsDtIUjlgD7+vSgZow2l00Ms9vbFJ 2Xe0e4+WDjoT689K1pLSSO0gvTI8V9GABanH2aXj5gW645x0/Gk2luJEWmRXT2klxc3hZZZG8q2O PKjAPRTjpWH4g33umXcl3JDZiyvIoRbbWK3cR5LIe2DtBz6ms5voM//T/kJ0qQalb2kaKFlt3GAp wWKkHj68cVd1TXILOaaTWbq4tLGbKTXUEIeW2OONikjPOBye/wCB8cWi1ZqJdaHdaIt7bSzTsRuZ p7XY+zGRIMc8+mBXLF5obaOZHeNJiWE0YLNsB+8F9cdqLEuzkjsLXxJ4gitY7DQrnzNKu2EN43me Vdtux8xUgjC+mRnJ7V6D4aNtBDPYanJHeRFFjlvZFUSna2XwQMHNFi7vZnL6nceH7yW9jjiM0EDP bxqkXlnd0A6Yx0yRmuAS4nDHS4Hmnt4pC0aSDmMDPAPpQZpRuz//1P5A9lzNqls6xzGNYGhCmUgK 5P3iPTsB2puo+H9TtWuLeTfGruTdw3En7xT1Xb2x9D6V5FmtzGVrmlpFtbwxxMkskU4Xy5YjHmNy O+ffg1vx38kcHl+ShaKRiixtkuOwH5UiLK9ypeSxpcmJokF7cRLPIWA8zH3QCfXp17VesobPzTHF awSSRIbm/Uv5dxIgX7x554Xt2HtQTNaGTdS3b6pusrV0tZ0EbO8mDEOnI6mhnXTof9MnKWxcgMwL KvqM1pDqKUOx/9X+Ra1vrGztZJbQymO2ZpxK7FiMksWYk8e1aeI72QyC9g+1ai2XmPyyy7gP3rnv t/HpXnrU4Em9hNQ0/RrPUXGj61qeqPb26wzGWNRavLwWKDrgdP8AOatF5LnTLa3uwTdrMTcXCjaX TI2DHTjHNBqoJFx4F85NhlHlwFlnUkAnHK/U1i/bNQvpUkM8kEEcnlQeWcyIAeeOcZ/xoLatuSax c6lIsCeUz7XCgOFRpV5+YH/PSr1gdSt5DEsZUeUCGDcgMPT6VlNamkYpan//1v5S55pRI0cbNFbo gMkUkYzv7tn61g3jXVy9vL58jC0G2I5wq89T/nvXjlRjc1onkjt7a3u4CdwbzbhPnikPXB/A06Nb eO4aZUgjjKCOR5vlVVHQ+2M1Eo31QLZlSO/sZr1YZInEQYb5CmNwOeUB6j3o1q7S1tgs9zN9j88C 2khj3MQTja0fPHrU8khJtbHRQaIvmK0EEYmNsJ2cqIAF25Jb8D1rI1O4vLy7t4IpFiGkIJLYW8Co 0ueGDsB8wyR16Y61Li09S5O9Nn//1/5WZ3E9qiRwol2xG64z90cAjH61tarp0s0GjpaaxcDT7S3D 3Vg7ja8uMdPTrk9/1rxpwdjGq+WEbHEy6c0Go3NxaRhohHtu1ibJwQchBnGefqakayjmtLWVkmth BJ5tupjwzkAjDDr3rPkdrmUOxFFpitf/AG+S18wmHyfNzt8o9mA/Oob7TYYJJhFeXFxbPgmN4xGF PcgDn9anle1ir6Oxv6fBAP7Ot5NQvvssE8dy1pCEkacqfugMCBnpkY781peJ9eTUZQmlKIlgdo97 w/KiAnIJHfJ6/WrUXzHVRaS1P//Q/lHs4LZoUmmtUnnWQkMwBcnP3h6VAYL6K6kmiKpExztT/WEE cjH514sVbV7ky+FloNdLZym4iaBM5RmTIHPHX86bcwX8VqJoHjdWjEoMb7jg9Qfy5FZz0ncicpRa USG31WW+R7a7iWMIgVFgJk5Xv/8AWFWgk8EWFwRnCk8YHuKSTexnG9lcddW7ala/YcGOBotrc/dJ PO2oJbK306GOCzt1jMoEU0w4VMAcn64p8sl0K0vqf//R/lAWG5unstRdsTaNELURQnMNwjPk4z71 Y1R4o3tXAL7wSiomAhA5B/CvBu07mDS3RNoscGpQNc3Mq2hjkIWBmUyyAEjOM57CjUpLVLi1gWa4 lVnSFpbhBiME8kBc4Veen5VtdpXRo1BamjI17Z3CPa6gbuGDKQXMZIjK87QAenfimR6xcNch7kYK fK56ZYeg6Vk5yTaHOTfXUh1Kazv5dqMGmCExiQBCG5460lhDFd6S7TJP9viuwoYtmOJFBHHrnrzW cJO1xPlcdD//0v5ZZZ+LNRsvbe2hJvIZF/eXjZPDegHtisrWpYbyJLmG2W3mtoQrWtuSRPg8YBJ5 wcfhXzstFZGPO73Y2FIiIZZWaN3YEI3BGOSMfhUHkR31+7EghDgjO0uAcYz6UrNSRhPcsarIYHWy gSCe5YBY0VwURj33dOKz9Lnu7O5ntdRSRoJcMssSF0TrnJ7e1a7xszdyT93sdGdSurUebuje1QhL eOQ7mGOo2+h/pWZNqKXV1JMsL22xd/kxZCt/ur6Vauo6GKbWnY//0/5U49Z043dvaMs08cqgzSiP AhPdTnv1qvqFvYWNxNNp8bAzrsYIAvmf3WZR3A4zXhRu53Zxt3fOynoun6pot9Lq8WrXMq3sHkyQ q+1YATx8oHX1JqSFItL1gTzQSvBOvmzSRPthQkkc+/0FJx97QpJPU2rzVtPYxpbQztcli7qigxle AGNN1C6nisJrkQSKFAjLxRf6st36fjU21B+9KzZV8KyWlxdXsts9zNbLCbedyvyq/Zj6VHq0CNDJ B57zxJ+7E/V8HjqK0gu5UIJXP//U/lG+13dhZWmiQ3DR2xPmkxAeWzdMNnrwB1rReUTW7wmG4muI 1LW6bGQAjr82MDr2r5+wo35VcztN1LVZCIri1eznTgxMCiOM4xyO+K66Wd5YQZbeIOEwwHKgAcAf SnFXY9tERqVigEkUawzFSNyjBkpFt4Xjgb50vMbnJfKn0CjHatkrAV5ra7uF2Ols3/LRAsg83cvf 1GKmuDciC3t9PvsyXB3X8E0WclehVs0pRSaaMJK9KR//1f5ddNvksNRh0ySB7rzHDyQlisDuRxlu gBPFVTEv228aUrC2P3EajHksDgj6V4MkrJnPJJ2uQ3GoalbJKtzBDPGxAWYsd7deCP8APSq1rqk1 wi3Btwksk/ltEsW3zewYDt06+1comrqxHJm8upPlMTxEKSDncy4yMfkKo3K3nnSNLH5lpbxhhNyG U5OauC0Yabdxlxbx31rFFEXZJD+8lkOSuewrT0/RIxcx/wClSS2kUflzh+Zg2OMDPTg1VO61Qqlp R1P/1v5Y1gvoZVhljkCRlwXIwoXqpHfpjpRA8rO0pkJgj+UREYRSp7D1rwbtp3OKmrKyGyX95PPJ FZwSXEhj3rCib3wo/lVd7OS/UNOzR5XnHGw0lFK7IqUFytILC2l0uFLOcpLe+a0puUHliZCfkyvQ HAGcVreVcXMU3zbAo3IhOS/qP/rGsYStobQ+Ex7SzLOZbqIKVb5WOCV7dPWrV87SCNTcTWwRhGJI 4w2RnleRxnpntWoQXun/1/5bFbTYLad5mM/noYoYIm3TQHu2B6+9Zmk6bGpREdgiJuKP99j2z9K+ bc+iOc128ywJuUyBD87beDgda1I/EgmdvJtVe5uoPJtjKcZBGGfdjg4/nWZSjdXOU1Kwns1mezkX zFfzJVWQFC2ex6c1oJf3v2SFlhiV7g+TGxfcC4xnjr3/AE9qBW1sVYrq+YTWV5u8uJg0VwmFkznk A49uvvVmS3u2miuzKsUEYOYWB82Q44PHb61nLm2Hy+9yn//Q/lltRM1vci+KiCR95glTLkA8EKRm pNQlubsWyibytNhAHkLEP3m1cY9vrXyt3zWMGrOxQVrsywGJFhtlJDuSfN29BitOwjcq8k08oiEp aBCcKxHGcVQJX2IImn1KWWBbyKJrG6UvA0myRwechfpjr6iqzwX1tf3bRzTXFjcqseJ2JNu4J3eX joGoNIRsri2t7eWMl28CurFvKlhkcvHKvqB075/CoEfdLI3mzRLOwDtH8rLzn5fTNBXKrWP/0f5f byayntIopots6fPFOpO84HQ9sVy1v9snlD/aJbYROTCoI3PjgZz/AEr5cwiveFvI2smF0paJpBmS Rlz5hHX61ZtnvLy0S4ICTvMVs3gf5+Om8fw0G5t6fbBQf7RS2e+tS9x5bt5wJXJH1ziuJeR764uX LAbcumyPy1Gc9vbpQYy+JjUUSgMxDeT9zK4Oa0LmW5VYBAV+zgBmCHMin+Ljtn/Cp5dWyT//0v5V rqazms1ukjEzh9kLvEYm3L97A9RUdltu8OzeTtG1ozghvc9//wBdfIWd7Iy5NNNyndWnlzCBp4Wk 88MwQdYuuCemf8KkkGydWMMED28flf6Ocicc4Lc4JIxnHpTh8QcjsammCFpjI65Mal8EYC1n6peX M10kCp5AEhdQpBWUe5PT6V0KLexUFbVj7O6upSY7lpmjjAwsj8Q44AAqm15Jb3DRf65JGw5kyGTP TGPrVOGuhZ//0/5QdKsorO5uAFtovOiJMk3BY5zyQK1mlMQdYZo5EiIKiIlVb8xnH4V8+l0RHIr3 K0l2ouPMEZkiUDcWOCCfSobe82Ws9vJsSF7vz1aTGc4IwD+NW4NK5Lg76Fm5urezSGbKM0uFzGd7 ge4HP51tpeSCwhmsQJZppAibyUAycH349KhK+g3DSyKF/awW8twsVzHclgJJJolKgsQCyn6Hj8Ky pLsNEIEiVmPJfPDegreK5VYShK5//9T+T+3fA2OPm5+lRxxC2dWhb7O8UgkQr1Ug9q8Ob6AacrGR 4huRldCxCkFx65HrxUVpDc2purlIY5I1gZjNM/zxYxgqv4n9OKzt0RUU2zMuLy4u7mHU75zLdRBY 8scxlU4GT+Aq1fXk63sU8SOIp4ldUK/uzxz7YNOzW43Bpl8arLc2Fnp7LbJNHK53xJsOD0B9gKoy 3gt3+ymF2keMnz1/1S44OT/npSHCNtWf/9X+TCC4mkuGECtGbaRJBNG/zjHUY9+lSXDXWp6mZ3nk j8x/nWJNyKezYr586Y7o1YIZ2cySGNWgPzzmQeZMQcDjvS6jfSSszbSigBW8sYHAx0o2NZWtqWtL usSwwMXc3KHy0RdznA9BXcWPhjV55Q66fqcts8Yfz7a2LlST0Hqfwo23KpRcrKKP1y/Y58Lx+E/C mrWWoyy2ceqXtrfeVcwkTZwxbdj7rAH8M814l+2NpGravqMuo+GtOae2SzPnLvLvdSRk7dg6bsEn bkZrXBpxhUucuYq2MpKXY//W/mB1Cw1Hw0LB7zT7l/7Uk8zzY4yfJBHO9eq4IPB7V99fsG/EjQfC Xj+0jub6xtZdVmmglTUZvs6SbgTwW/iHJXGecCvncXD2tH2a6noRdo6Hqv7cVv8A8JpqOlaloun6 jrRGgzW0E2nW32iKSU3AO2UgYDemTwDX5Uv4Q8WR3EzX9q1tJK3lIIYWuEtiMjLgdDnHB9K7Ky5a cY+R4eATjUqKe92feP7I9hr+haz/AG+l/qFjZI0VlrMKxlrKKNXCyMpAPLKxO0enqK9p/ba8d+FP +Ee0vwZDrtpqWoKj3zJZ3H2q4VXwIi7DhQoGRzk8/iYany81V9mPMOaVajCPR3PyEni+26d9snZI dQs7wwRxK24yoCSrEfr+NSWxmeaAySKvRRuOSp+lcTkue53U79T/1/z6/Yo8a+D/AA/4RSz13VfD 2jXzSFpL661GOCWQIAQiRuQGBDEn37dK+af2yPE+j694xvLnS9W0+9tJI0lA0lBGd3IAcr0cDGc9 z1r5uhUivbRvq7FYmMvrdFx+Hlf32Pg+KaOduFKlsruYZK+9fTPwN+Efh7x9IukprNn/AG1NqaLC budIo5VKv5hkUjkrtACgHtxnFTTkuaz2PQoRU5KMtEaXxq+B3iH4f63DawwaTLpAt3mfV7WdmYpn aFHy4AypyGIIx0PBr57Tw9fOgTUYo2COS7wEtAyE8HJHp3orpQkkZq3PJLo7H6PfsWaS+k69Jf6n Yw/2fK8LWt1/qZTHFsbaM44ygGenJxXe/tweIbTxBJPYaXHptrLLA981qt7GzIJ5tsvIJ+YxqTge q9uanDVLV5W2s1+DDGQvKlH5n//Q/P39hLUtA/szUdBurq1Goo0lhp6TyqBbFhjzZRn7u1QAccGS vOv26YdZg8SabZI1yLGzjW1ke1h8y3AEauAHA4DFm47hjXyWFlbEVGv60PUzO1SeHiv5T85Et1ul toNOCRSi8Am81CsoXdhlC+vHT3r9Vf2JltrK41OOS32zzXkAs1aPyBvR4nd1JwMnyzn6U8a/3Ka7 r8xYWCTlfaz/ACKf7fGo6FJql0NPv2ub2ysYHMqkXP2acn96gHdcEnPQE1+YE9wtyBaXD+bD5JSQ OArTkgAMcccYPA45rqledONu3+Z42BhaNTtzP9CfS9EtbGaxKJHcebMkdvACAsJL7QT9BzX7bfss Q/DuTwVpOia1Y+GdT8R3OmXIfzYI7rcyRrs2y8hWO0kDhsA49/Lxyly01H+Zfqezg8PTqxqxqPRR f36H/9H8Pf2oxp0XjC/iSw02J1Uadqz2YRXM0fRnZTgnAAJHc/Wvm2w8q1EUyMUwflYtlwfY9a+V rpKq0hUouNCMWSzFZW8rcZY3YnLDDCkj0+K1glhj3SPLceeoOGKsOmKxW1jZx0bPpz9mWDXLT4ka Fqz6VDcWMV/bQ3nnShWSHzMyP7FcqQO9frL+0JY20nwqisrfzZLKK1OpBVysEkR4U+x+fn61dO3t 4I8zM/8AdEutz8JdRW9n1TUM6fJbiC8NoJGO6OVhxkEcY6fl9a92+HXwA8Z+P7a4m0exvLpcMZrl YysanjLeYxCA/NgKTk4JxVT1sj0o6UpeR//S/BLxL4Fv/Ct9d6VqkItrq1uWs3jJxJlDjLjHBODx XIw6RLJcSWSiPy3j2lRy2ScY+hr5SUVbQqOtmfs1+xetinw1ltr+aHTbmC/FjdIzF0tYEQmI8ZyM c468V8Qftrajos/jG+utPEBgsJPOe62PA2rlY48SsrfcJEmMEfwDjrWNODSlJm2ZRf1rCtfy/oz4 zjvEurPZEFCnDhgMFfbNVmLSyM0e6FtgRni7YrA1itiRpppJ47QoQPL3C6kflgONuPXimw6nHpt2 YHuSwmcJFuj5VvTI6UFn/9P+eRjK8hJhV4gQxnLZbcc8Y/z1qeTz45FZCPJZcc8EnP8A+qvhnsz0 DLvLdraQXEUiefKRlVIIYdMEdqv74EEAnEiSzKRGyjKqwGcH8qwsZz3BZbjfdSDZMqjCnJEpPesy WS5ubhYF81V6bkXhK6DM6MxiHY8hYypEREAfmY4x/hS2sLS2im5b/SbhipjjOGtemGPr3FYNWdh2 bVz/1P5+tUhufsMkEVo10srKjXJyEjAPr0zVuxNrHEIrifbcqo8vHzOPp/8AXr8/OgddOJ5YIDKM QgndnDPxj/69QtA4icMq7Vb5ST94ev8AP8qzlLogE822j064gd2kSU7sA8RkcA49sVmwXgu47W2h lDOsgzO5AaQZAO7oB3/OszWGxqyRNsKwsjvvxw3BwcHkVbybcwLbMRMU/wBIMh+VTz90fjQHNrY/ /9X8CfIZp7VUuIi0shEhY8g5xye2OePStDVI3heOBJxIVwXMZyrHHrX5w1Y9Apq7xumYy6E5ZwuQ uOx+taEjJPuuo40jLEhkjyAMegpDi7O5my3M8MiRqGVZW3AspwcdqnmdrswmZHBTJABwGOMZPrVX XLYpzvsFrN5iTRSMB9nYNGhGGk56D6VpS6nLJBHEgyIznyyenrUlT2P/1vwqspPKBdVyC3zRtxGn uP8APaqM9zIt+84VQ8524HzYA6AZ9K/O4NJanrQXum5bzeWu6TDA/KVY8N161iXHkStKiRLGmcAo MBsdqfOii1G1y6WkUUai2jBDRH5cnHBFM89rhXRFMTDjjGRj0rIGrqxLYyXOoxMBtje1kIUzEkyq ONwFadxbyqkUluHkd3EZwPlBPqe1RN2ViYx5T//X/Ey5sDb2iyTeUrFSERTuKnv+tcPaQ3EJdjKu 1ZOOpJH0r8vPTmtTbbzplDxbHdMKvmj5I/c/nVCG9v7a9uoZtkighcAcJg4JVu+cUEGqzLcblZnR ymYyuNwxWYltbXCfaLkzuFm2jJIxtPOB+FAHSedE86XFrHt8lFCyqmNuMAE+mcVkXliPtYuiZ2a7 fzHJ5RSBgt+OKAP/0PwwuLeS8ibbcMRGeCDls1dtUCWZg3klQWGeqt6gfgK/Lm0tz0DO0+5urKW5 jnYSRSNviOcknGDu/wDrVa+2MGYSuAAm5QR1+lRH4WyZq8Wi/Ek72scspFu7ANGBznPT86knJtJt s8MrXPlB8FNq+2D3rti/ct/XQ0grcokU9zNGHQFGwGML8uvTtUUlnPPcK0kjEMACh7Uip2P/0fxN vrKwQ2r25kFwYvKmQn5FGRz+P9KxF3QXux4/PhMeFkYZaLBHGa/OD0pbm3cLbzW0Qjbc6cOpbAUH 2rNAityV8s7WOPu5PPHFYt/uWkZONkw1U2ejWnmwzT3NyzbkUoMYIyV4/DrU1hewXVlBamBrOORf PQ/d3FsEoRngA59q4bPmTE1aBZKXKPJFC3yIPmI7YpAfLkt7lQJwsmJIMkl8YyPx6fnQ2tUzenFJ Nn//0vxBtWuZ7yUpZC0hMhZkYEbAeQc1rNqEYjeC2dV1CDLMyr8jL0Az+dflForY9bkWxHYtPqMk VtLJGgW4SVnlbZCoVgSSx6YGaJ5JDcTqs4aDzSq5ON4B4bHXmo10CNNX0LebJreM3CRtcpJ/onmY DKwB+anIHMLygB26cdfStYpPcv2WlrFJbgxMYni3SHkSEZCUpiDxK8siSSI5+Vm5T6DtUvcShZ2S P//T/FuKLTiyFT/pbnGAegGOn51oXf8AqQi3JiZQflVgrSfWvyfY9uolsYdhZy4xcXEks4Y/vXHz sM8A49BgZ9q1zdTaZIshi+1EERtG7Y2j69q1g1azNHpGyNu41KeIWd9bzRQm4QwtZxvvDA8YIrl4 47+7upkhVY9zhVBOPM9eKiTuynKUtZG7qYbSkjt47kSSywiKcgYx0yvuOBXN3DMJrfzxKy4xmFMj 16f41IN3Z//U/GXT7UXO9kkWGWFxKUbgkAiplj1Btaj+bcl1nIT5URhyGPoOoz2r8ma90+itd8qN HVNIuNMF4jCR7y3O6WGQeXtzggKT1GCMHvWVbrut4lutvmIxkidV5UnPH61RCj7zNCE2rQSGaIXD wr8vmDG8+5H9Kbp8lza2xmZiqyviNFX7p9Ae9F3e5Vl7a3QYIpNQDyzCKNLdtzecQJG5xla2LbUL OCJYHg8iWDJWZclLgE8Z7Aii7Llo0uh//9X8n4L7EU8tm0LyXMD27+YA+3epU49DgnFZ+mNMsc8Z jAECncr8L6cfnX5M0mfTaJXRDqU2qWH2G4tmX7FLljbIFkaXcdu/d1GCp4rPRruZ3it/MEjJgtGv z898etKUUyJX5Vch0ovZz3lvPbsIGHmW+otP+9kkJwysnatOGxePWbC7kvVRVcMWtm8yWIE4zgHt 1x1qeRdGa293lO4uL6xgiv4ku5rqRs/vJV2NHn/Z9/c965mw1HTkkdbxZJI5j5Z2Lkgd6lxSWjI5 ZXTZ/9b8i2Sa/W4kNs0MKO0do0mA8gXjOPSs2206+u1VpHYokhVTkpgA9K/IXG1j6PXnNW8u9Sst 1nEkosWjDykDEAP19aqW5ABZg7AnIPTn/P8AKolH3blu/Mjaa5O1fLYxyCPBOe2P8/nWfMrXTxEx ByMiSbkM3TAqJK8C01qTpdxWsJN3ENwQqqsAXTHQj8v1rRjvLa80X7ZCrC9BwsJAELr2OTzk/wBa z5bR8hxdmf/X/JaGUy3MpNkIgkSMs6nvk5Hv/wDXqTUJroXFnKFSO1wNwJyzHoT+NfirjpZH16cX o9iSUCKVXiUKkmNyj7hzUwSJ7zyIbK1Fu8YeW+kO2WEk/NtAHtUtcusRu0rpkjtp/nPHb31w+wCO PzYQhDLwSeeh7Us94Idj5BYHbhOpoaenciyULFTUL/VZZbczXLi0UbUt2ciFevO3pmnTSXJs1+zS IGnJC+W4YgjjOO34+tZ3aloEVGx//9D8ldMM0s9ut+ZI7mGYpNGJBiRR3U45z16V0viBtS2LItrF BY29nvh8j97cXWCT8w9T7V+KqMXq0fWtKPvRRm2twt/FbNJm2tYhumiMf77PXp61WttTZ3uVKkJG THGz5RsjjinbW44ty1ZMNRFrY5ljEsaycbnwy7iASzdwM/pUF3ZrNd27m62Jj94iKHTB6c/4UlpP Q0ne0bEF7NdSR/Y7W4ke1jPzQpIQVYfxYroJ2XULSwluraAX9rZjT1l+4yRBi27j+Lkmnyptsz5p 3dz/0fyOu2Sy1ER21yZ4k/e+fjCkcFgD+lWZBaveTajeeexazEUSA7Y8DJBP4k1+JStF2R9em1LQ 0tNtWlVZYvI+0LDveWE5YgDJB+lZt3eJJPbyBWleN8nOdpxUOUo6pmkZTjpFmp800kAQrHvb5y5w EHeoUjM0Md5IqW9uGeLzD8nCE8n0/wDr1m4alxempSt7y1PnWkltHcyM3mQ3vmHdCARwo6c0l2Lu 8UxXWwW7YxGshdnxwM8YpzbVrBJN6rc//9L8mLeDbNBZldrSsDEJDwpP9KbNcTqhjjjRpUfaoB+V u3NfhkLpXR9o9aljGvdS1KMFrdI42iBEivwH55wexHatazaVdPsH1IyK07lpI7g7HkVju49OtPlR q23uSanYSQXVt/ZEkW66iMgXzwTCPRvqB0q8upW9iVW5dfOVfmEQ3ufcjP1q07aIIydNvk6lCbzJ 1a+YCPzG/dwo4LuBgZI7dqrXmtxRtb2V7pz27ookhucfupgwxjPqP610UoprUiLauj//0/yHFzGN 0xUfK24KfusP/rVY1RkvnhR2WNXAKrA4+UcdOtfjCTZ9xFPluVr27+y29w2nxIkcAWNw7g3EgPG4 ZPX2rNtoiPKubjUYr032XMCI0bacoOAjEjBPU5Gen0JcYu6ZMldWMuB9j3aiczIJGiR433MVyRgH 2/pV6ynl0+2ks4vLms5JDMtu7HcjsBlj39qTVnYycWtyKaUWzrK1qJhtPmx+bs2ehx3rPtJPJme6 ZvOlnUBgHwNoztGPbdSEf//U/GUQSTnzoHWIk4y7hFB9M1U+z3KwMHNrKkbf6S6TEzewUdPevxc+ wJrG3tZhtlmfzYhuVmOZApPT9APwpt9IYJY5La5NmExF9oaIhNpPzEEc5/OgTdjbv/Ec3iURl5Zm nsbeO1t/tNsVR1hUIMZxkHGe/WsSa+n3xSpGkLxkLKFQRh8dRgcCtOX3RlNri5e+mv8AzSbcxeUI BxGuCCSD/So4/tD3seq2SQpf2kUkVvcuuREHXY3HfsfwpQWp0H//1fxntdZMm61uxG1zbxBpGibG /PG7bXoXwy1/XfD/AIvtr/RrttOu5pIrSKSdBtuFkkGY+u5SQeCD3PPNfjz2Z93TXvo/a/TfBumf En4ceHpvGEM1zrEF60+kyLMTc20yHYRz95ZFI/IeleJ/Gb4geHPgt4FsrLwvE19rjv8AYLe3jvh5 sDySHzZSVBIUAEAdgD9a6MJrTNKitNI7b4C+Jb34z+Gbb+09Ct3kskmZrHXoGu0u0Cou1ccEZcFW OOMccc/C3x2+EvhnwR8SodHeG5S41e8N2ulxzC4hsGUNJ5MT5LKhADAN0L4xitYzbjN9C8TFcqR9 ifAL4NaFbeHofF97ApifS5Lmy0+VURo50PVs+jAY5znPpz4V8Q/2ltf8Oa5PaPAbxIbB5Q9vLHbW kZWVgsZG3DH5TzWMFoYRgmtT/9bwT4dftY33iHWESXTHuRqLx2Ed3OVW7sHYjrHgZi5KjOeSPevd v2lPgLdeNfC4+IC3ekzJFo8V3dMDC11ZShFG2MDhsleh5PPXNfk0k+U+55dbH5vfDv4Raz8QPE1t p9nafao7WcSFUuRaEyxyqo35BwvXPOc4FfpTqn9nfAzwafsVrZSajaQC71uM6XHPJrFxtSEJvxlz gDb04BORTSsjSMNT5hX9rb4aXkVpdx6XZ292NQOtX9nZ6ZLb+YQpUxvu+TfnPyYxnvX03ofifwj8 WtANnb+FtGJ1iwa0ivLjTVsr23E65SQkAMjITzgj7o6URjd2NJU9mz87vjd8INZ+Fuv3X2xP9Hn1 WO4VyQ6zwXLSFRB8xLKoQ5JHr34r1r4UfGXwVZ6NbeH/ABB4Q0HVLyC5BtpFiNjdXjFmIMk5zuIX avYfLXQ9iORJn//X9b+Fms6L4gaxn0y3TT49Ruja3SwS+fNYLs3Nu4wBwwGOu0dK85+KPiX4YWKT 2Xj0xajYQStB9t1UeVaGMYZnaI7cEEZ44+uK/KpP3Uj9ElB7n5r/AB11j4XeIJ4bTwLo5jS1mGo2 99LfSpalmDDasD5JUq3B4Az0OMn0j9krTy/jbw5FuhtFju2eS3gXfFco4ClQSBt3MWGamO6E4NH3 P+1ZDbWXgQWaCG3lh0sXVxZzt8vy+YWAbrubGSD/AHa/EZfB19rGo3d7YaBfalLNepKLO1iMj2pP 3fm+6BwWyTzzXo0djhqN3sfrL+xJ4S1fSfEV9qd3Ddaeum6U5tGvE+zrdXJi8kBCQCz/ADE4PX9K 4v8A4KP3+p2Xg+zs73Ug/wBgMrWMO3erlgs0aSKf4gd64+ortox10OKq5cquf//Q/kd8Z6nfX95P p9+1nDO6vG5yE85gxJbJwBk49s182T6deWeq3l1Nm6hgmxcqk29Uz8oA9j7cV8vTpu1j1qkZF2xs +l0Cm1cyeW7BWQA4IwfTNegpq2n6joy6DpVpdwTXj+ReXInMUcoGPYEjPQr7c118jscc46mvpOnQ 6ZaTC5uGSUAoxlkOXAwPz+taNpHGR5YB8pFBVy2Wb255rCVN2ZnGFnoaemSx2niDTpVM7bJVzDbj epzwN49Pp0r9CdAawstDQpm4uBLCIkMatbyFc+a3XGMkED3rza8bxsEIP2p//9H+QXwfp8b668tm ky/ZnVJWVyqjgNz2PQH8PavR7C4ilutUu5m2jbm4urh/KzsPIUk8/eJ4r4FL97c7JfEmVbt7bXbW 3ex1dltIGktIrDyRbWl5g5ZyWXLbCCAVOOT1wMeb+M9Nhs9L1jUbaErdtAqrMYwVfaCo3fTIOa7k nzRZNk5nzteQ3cB3R/6U2ELFW4JOCT7da6G/sreOd/Mmim3W8ZiRD8yEqC/45OK92CtFDnuQ6dEL cyXVuSYcASoG5OD3H4V694e1O+1CC00e0VIvKm89L5wEmfeRtiZjngEHp69a1irszjorH//S/kAu LXUDDqlnqs8N5HqANsyyoGkQqc/KR2AGAfrXKeRo1mlldX0T2wst0N0POLSOCwAZUHHTGOv4VzJW Vi5PWxRuNNIulv7W/u5NJV2uLuK+gAkgRvuhWHQDggfWteHVdBmh046EzybLSS0kvLmMEZJIZlyS RkAD8KtQYoysyrNqEUheK0TcxQKVB3+cwwDg/XtU8cl7akSLE8cCjLowKjpzj370+SRXOU0W0ne5 jku7tHulMsc6viW3b/Y4yMYrSvLaysrW3s4ri71SW+iBkvJ8z3uHzxIR0x26cYoVOTJlO+h//9P+ MuHQ9XgvYYr2X7Ta2MW2FFT7NNJjkLtUYHXr79K3ZoYEwsm6WVCrz25battnHC+pHce9Z+ymK6Rc jjjvfPsmlaKd0CoImCyxg8bgPWtbX9HTS7bTtFs9Sj1S1Fql9FcMo+0W8kgUTI2OeqDIPoOBWTpd gujG/ssFg08KwpaEF5ZHCZ3D5Qcn6mpbtdQjaCKwiiulD7281yiRDqxGB1wOB7VPsmTzrYilkxHH Mt9dNcFs3AdPI25IwoIPI7c/rVK7vr0bLZ7RhHKxcyojHcBwAzdPUgUpU3EOddD/1P449Js00yO4 k1e+vJo3JktERV852zuRT0xj168Vd3yaoEktC++aRXvGvN0ciLnnbxncR61xcjJU0xus3tyZFs5z v0kO0emrgkIy4ZiffPIqTS5HMywQSyDzk2MigbZMckevOKap9xpp7GtBd3SWtxZSyTW1rdOASY/L lgJyCyg9x1/Cs/T9IN3Fqlg8z3kaWzpYTSyhZptoBUkcc5ycd80uTWyE5WVzf0Oy0gWWnNc6rcSz wzGO5sYbcqJB0JaToOc8CmanZusse64823aZvslmG+VsdBnqSPyo9mzNScdD/9X+Qe80rV9Ma11C 5laCyv7ZmVgQ7xkHaV29cH1NF6r3NvZw2+1GuZRCJ5MAqrZJIJ4Hbj3rk9mrbkc6HaLZa7pt5cpe hDEcwQNbuWYjpk4749D3qPVLe8tLm1tiILSGR/3ty4OArYOGxnp19eank8xuVka1n/Z9ratcXd/P GZXCwRsAIZMcFh7nHTnpV/xFpukzwW4triW8s/swaeWRDC0buvzKpBzgZ60nTe7M1N6lO3srG00K IadbXN/NBI32VfM80RjYRtPGfxPrWTZXN21zbvqej2moabcobS5tWY/a7dsZLBBz3xlvyODUygrt ClN2P//W/kcvYfDuhQWD/ar60kkmIsLCGyLpcH0kfORjOc9OKo63oiX0aXpvYpjcYEdkzLLEQDku euM+/XivMVNPQ4/aMvWVpDKn2BJXhVYjJO9vHvaKMcFselNtpomt4bKRfMFh/o8MjKA5UHuR1z1/ Gt1TtoHtDShFlb3iFZxaRzjKiNd43AZ6dskfrTGudTkhKIuydbppFjbiORASFGcdSMfnR7M0VRtb lez/ALUvJvLuLWG0u5ZMm1SXeFBPGSQOa62CHSbG01CdrJtRaKIK9xbOUNtlsMQcYOTxURgtDLnd 9D//1/5Lbm1MsySxxvGp4jwdxI7dO9RTq6tLPqMlzLE4Kv5rZcsAQpweT2rjdNPQ4udmbMlzA1tP aJHLb3GMLK3l4BGcjj07Vu6XYzxFTci1+0vNuxHLvCoeVyO3vWbpRSI9o72KWtz6RJrFuvlvbXt9 Ni9eCbdbrs5Plg8gAZ9fTtWX/ZtvNfy3Wm3N0jxk2pdztLA8kHHsR+dCpx5rCc77nSWVpd6cVguJ IbksBKrxS+cAD/CfQj096qXdj9tSVLpI1bzSUTOYXXOV3KR1rZUo2Nedn//Q/kjstEtruSazSyEM kuI2kjchZsD+7mmRrp+nl3ubLzZrYGO1eSMrE7YH+rYdxxWMaMTijLl0KOmw3N19puLcNZzykyv3 MZ7j8elbl050nT7W6u4brUZDEXkit0YqhJOAWHQcjrUxpx1bNb2KmlNrs8DX15BElkzMY41kxsB4 XrySO9XLIhrxGiKhYIy86FdsbEk9P8+tTyRWlh3b3Ld/i+v4J7U7DBEIrhZWO1e4KDoc046qumGX 7WBIZfkiIbDFjwCfx/lRyRGpNH//0f5L/sGtz2T3d7LdQQXMwiaPzBsljU8EH0PBxV+COwMjxXyu to8AhVbcYww+6Se2e9cns4hGT5dBl3HdgRLbuogV8yxs4BIHfnr/APqpDcWEsYhmt2ljuz5E8Uqb oSBwCKmUI21C6I7yKKO7WQpuggtwtvCg4hHPA9jzx71bW6aWSCyhsI7ppwshE52vb57qOQT04qVT i29BNpbk96buNkTVzd74V2iMyFFVMfKCp59MA9Ky7i/WwQ2wb5eHSXB85s/wfypyox0YSbUbH//S /lcW501tMtWtEuZbmYGKRpoDGitjPr26e9Y0GrS/6DaPIWuZJyJGlUJEUHRfQHn9K5Zwirpo5q8v 3asdBdrPYLO0LQxtOu11UiRQR379KhsrCeSx+zterczL+9inZcAFvmxj0GcfhWPIlHVGEJ2Whlz2 GpwT3M9xfoUAREijZShI7IvXHrVe/j1u2axuYYbV9Pv8wXayMBNHjncvXHQVKjG4+a0WXba0u5Az 2mRLEC2+ElnUDqfas4TXMNwsUYlUTy+TcIcqPqwHbvWns6akzenN2P/T/lWZYYElKzAzRD7QobMa tjoBn1I6UqSLNNZTvLJHLeEvdoIwFgbktz0K9OeOtcsKUHA54SvdDS93fRT2pmL2qzkW6g/Ljvio dQsLuz065i09nupJbZh5BbbsODnFclVQi7FczObsMW0unKWb7asIluIVYEKzEjacdvSummuwVkIC lo/vrnG3joaSteXkQtihfalcXMunvb2xtY7MjeLY4a6ABB8z165/CtYww6rcwaa1zJYG4WORb58P EGP3kcdh9e1OCTdmKTaWh//U/lle2ttMupNAF2l1cWrgTXMDB7Y7skHfjFUb+80/TZBp90wfy8TC 4CZRg3G0t/hXjRknLlOZ7GdcaXbLcQXNn8u3dIoXlQXPJz71HdQtbxyXPMz425brz2HtTm1GXKil 5i2UF4unTXUyypZbgbfYu0RsOSF/LpStd28uyXBDYIJk4kY9Dx2rCvdPQRRlgRwlww+VXOXzhhke n51fsZ2NmWtNT8top2hkVYsbj3yT1x0pRXuXe9xN2P/V/k8mu5rX5WcRPIcGQc5HqKuWL5m85Y/P 8kEq0q+XvB449D3/AAFeHTgpOzOJz1ujofEg0DTtI0w6Vcyvqk0YkvJLo7yxY5ZFXsePyxWLY3Ms 9ktw1lAIZUltnyGRs9M56jseODRTgpT5GS23uZWo3TW7w3EUI+TbbqyAyuhOF3Een8q37Yx3Qe3d 2wsGbh8ANwOw9zSUPf5GNP3rmVBDJLFvW4aWOOUqu6PkckAH8K1V0mV7KS/Qo0xk+zj5tpUYBOP6 1s1yuyBPVn//1v5UbfTLHdBdzSSq8UTeagQDc2SOR9P51aW2t5AslrEBGW3HC8sD6+ledSpKauzh eyQ6e9tbGaWecPDaw26tKiRHYVHGc+vFYVpcW+r+bepJO1is5jEEsRhPynIzkDtj2qnQipNDjJqy F2W88ct7aRyQeXkbCrB2wcdDz2FbVtqE95b3UV5OVHlp5cQPDEfLhse3T6VzqHvWe5o7LUo2unXK s8dneXFpHK4a5hhOxLnGcBh371bm0xEtri3SaVJJhnIPIyO1aezQoybuf//X/lVcBDCjxxmKJFBn Y5kZh/Ew/LpTvtyl9ls8uSMO6j7uPevL9mZKbSsXts91H9pln+0II/lkLbpJDwBz6YqfR5orqW7O piGzsLMhCZpf3l0uOfLHOPqeOKFTS0Hz+Qt+1qLhhazNNZIAUnYbcrgHH4dKpxypc5EDCRklEYYs P3ZPTP4U+RC53YypMWsoe8mddSt7qTbbQnMAV+MFu5AA4960BqzzYiW3RXhXmQLseUHBOTmtJUld GMp6WR//0P5RTdar57tdASG6m/0NYlLrBEmFwW9eD1rSWC8AMshd3bkO5JC+ma8iUFflZyyk0a9z cRpp8EN55gvZo/Jkn2b0Y/3wPbiqWmWF7ClxdfaLuQ6a4MIii8xrsY64HQjPasXSiQ5voaXmW16F ubqVrdIAfM2oEcn1Yd/zqs7RSt5SXEc0LQ8JHhgVOfvY6H296FSSJcm3cqz3Gm2Gly30ck8k7XQs /sKxBWIUN8yg4JGRjjNSxWimO21SKZo5riHEkI+UlQflEg6Ag5qvZocpXP/R/lw+073M1xdcKoUC RslscYH0q4tr553xkeRKoLIRtx6HHWvG5UcUHrYyNTtLlHeC0PkPMPJE0b7WYEYOP/r1Yls5LKOG 2aSRvLRTNKVLb2Yc8/WqcVY2erIRaxXcsb3k7loWDJJ0aMKMDHsKet1b2ziI3BLE/KzEYkrl9i1u Z09iCC7tZLicu75iIJjjUnzPw/wqXUJPJdLyIM8ToYxDJGskC8ddpB5571p7KVrWLP/S/lOso4rS VpjEyPcNwWfeW55IGeOtbapcwP5turOJBhtiFs1886LMFvqacd0sm2znWRFngJchPmlxjK49uKy2 nFxcbLOKZktFZWmEREcQUHI/+tS9jIqMlHcz8EPC8MZka+Xd5THDD6jsfr6VdEsLPBby27RSWx81 FibcT6k/n0qfZSJbL9xbJOIysjRCNi3K4LZqW3JnkSOC8hhuUQyW5lwRIyDIXHTn3o9lMG9bn//T /lludWlluHk1VTNPMR5t0RsKleBgDt7U+WCSaOGSC932ryhzAijYVXjrXzvsm2cyerRESmWV2kVQ dqrj5asRW20I3nNsjO5Vxmh0mXGXKNurKOe4S5jUR3TSiaSSMBfPIGAG+lG2/wDPktmkWNU+8uRt cjkUvZSNVqrle4sb2G0u71pY90MZnCDhWUHHetCzOnNaPc3ILpPEhhjwPLY9T1/zwKTptaDP/9T+ Vm7l8x98CFYicKH4Kj0qF5YreMNcF9oBLvFlig9sV81ySWgk49DW1DT7TUrRIdF1I3SxW8VyRePt njBI8xAuTk8H8Kzred7OQ25DYYfKQMDPTH6UcjGWkW28wme5nKTjyZ4FIRNncg9c8nvWeLawEj/Z RMsFvmKJe5QdM/hj8qXJIxla+hnTPGSUhO5S+0kD7vrS2kcMUrMsjfMcsu7KnFPkkSf/1f5SL5Ny BnmZIE5j+bEUTEgEke+B+VS2jafDZ3UwS5Yg7cunySMMZIPp7818zyMnmVrjAkM6o8aMzzEpwhcA YyckdOnenw2kJlZ9siP/AKt/4Q2KqMHfUoed1tIyAl8thQMDH1pJoEl1GG5ubh1tooTG8CIH3EkE P9Vwf++q25JAT+ZDO+YXJQAlmkIXfj/9XSufv4ruTM9rhvmIYsMcDuKOWXYqKu7H/9b+UmzhF3Zw Q+U1tdMdrPKwJkz0PsKrPDPZm6s7nH2hHMKG2/fDI9SPxrxox5UNK7sZrPMipE29WDgSu69B71oX It1t40zJcpuK+akDbWwe350was7D7qKGK2tFtAVuWZhMztyynG0AfnVqwgdNqXEjLH5gfYrYUHsa iMLPURr3kkCwuIwAyrzuGEzz1NcTZyqySxiZ5JQzExhfkjGeAG7/ANMVYH//1/5LI0maQNI5jCcj BxxSC5SYzFW2/ZjiTPU+4/KvCknzAaGnNEt0jzeXxzAzHAJIIP6GrF6txP5gWRFtZ1EU6h/uj1FE YtO5tD4TAvHaL7TaxszxmLZCxTG/jipbOS6hiiS4na5VYgmHGfKA6KvsKqab2KL2mvbwT6hCYJA1 0iyR3jgnYRwUTt05waiNqYESCGSSaOOQtJJO+JAOvH+FZAf/0P5NLX/RpZpbUsnnxlHKj16/nzVe K5SCR2hmkWdcrNCVKkD1+hr586o6PUtmeS4EW1/K2NuOOkn1ppmWBJGkR5ufmCYLAfjWc73RU5dE X7bVLfTb+HULO28547cxQCWTDjcoDDIHf6V9keBP2mNA0nw9p+n6v4IMut6baR29vd29wkkVyicb WyuARkknvntW0HGMk5K5tQqOl70T27R/25NP0KOS503wjpolZFtp0kBu442XALmMMAMDGSM9Kqv+ 2PpN1/aFxrPgvwpdR3M+6Gd714LQk9MRfMo+g/WtlWjdyjHc4sTSqVq6rN7H/9H8APiz8adP8TpY 6fpfgvw1ZX4gKyNBlLV1mwSTMB1AKsoIPPcZNfOemapc6LqFlNFLGl9a3/2hZ43GbX5skIfTgA57 V4VWSm1ZWsddFOnG8nc+8vDX7bXh6z8LTaH480Bb2aa1WxmayumtxO0YCiRZNgBZh1xzx35qC6/a Q+Clte28cXwoOpT30IYSXOsug6DO4FSRj+9xTrzlUqKUeh5k6E5Yn2lPRam5b/tYeDtD8Oapo/gz whZeHLvU7lnkjhvnurT5AVDyHbywBOAT17V+ffjTxFfeLNevdUmmmhnlvhO/my72nQYBUc8KR2qn ibU/ZJdV+v8AmX9Wlz+1m7v/AIb/ACOX2kOLmFpNgkw4eMjkccAjp056VntOkeoAZm81nyg2FlUn qT6CuE6afU//0v5a9NlcPZz/AG+5E+mSNNBKJdrKzZB46Eexq+theyWk+qyX0Mt3d3W2+cNmS56k My9BxgcdK+YSbOgyYJ/scz28aNNLIuATnYuTit3QrzV/CHiaw1LRJru3FoftWuW4Y5Y5z8i9M89T /hUJWbubKTUbrofpxaftRfDDx14Q0LTviJb3N8dEtvJV9MtBu1GMR7NtwM53rjkDgnJxmuGh8c/s 8x6PqFp/Y2rJdvCz6fLdSwLiAf6sEKiAFuQylTjJ5qa8XOcWr2L9pH2kpx0udlafHn4TaJoV22kv fW1y+kiztLPMckH2jAwquMEr8ozgAgZ64r89vGXjW/8AGWsapdajf3YEt4Xs2WQxS4GBs9QvBx7e ldEKNKOsbnNiqkqlWLT9T//T/m9+HnizVfBmv2Os6dJLC9vOskzQSlJXUHkjnBOPX+fNfpJqXx8+ C3izR9Pj1yXxLcQQlJNZe/to7d7pxHtWUknAIY9j36mvlqMLTk+501rzqKUuh5xY6t+zq2rvdy6R qk9o0YFjfyQxG8ikB3A4+7gDoentXZal8dPhJ4b8L62/hu71mPUo7TzrVH0gMzODtPQ5zjPOBgZx noc6+HdWUdTqjVpwoShF+8/8rH59eJvH17rNxcO01xc21xKZYZppWeecPgnzFIGzHTaOgArzqfSv 7SuPttnqs8cm5I59PkUJEVBJYoepz9c12rRJHDTShHlX9f1Y2Li1kzEreYx3YR0cq0eRjgg59vxr rfDHizXtA02ewsr7UY0t2Mlq1veNE7MxOVLZ9+9YVIo0Ta2P/9T+afW/El3rQhXVbB7dml3yfvPP Nw4PDFvU4zk1mWUvm27B1kWRJSuyRCgUA8Y9Qf618rbnV5HR5CRy3L3aouEReQw6kD2q8Lae81K3 jlvbizhR/tBkhYosmznYW7Z6Y71lytuwnsfon+z74k+DOg20Oq+JfFTaXcw3MUd5BPpjfNIu12CO eqkBRu47+1fY/iH4/fCHxF4en0a91gW8M08kNniAm3W3Y5V5fmJC5AO1c9BWip+9zLoeRUjXqqUa sfdT0t2PzD+O194Ji17Z4F1xtSsUuY5b2ZbYQRGRQCVHQnpjJHryeta3we+PepeCddjuLbXLj7Lb PF/aWnyXLJaXEf8AdkH+7uHPTsRSnZfCz0qNSUY3luf/1fhHxQvwG+JVho2v6l4us/DtzrM880ll cquozKzSFgHPLrggFeeQ2cda4fSvhx+zx9uvtN1Hx3E9tEonl1TTraSO5d88KSQSCPUDHvXyk4uN PmunI3w6pKovafCepeLPiz8Pfhj4FHh74ba1b3ctvL9su7+1tDbXjRiIqu5iQzMSBg4OcHp0r80f F19P42vNRv8AV7ubVf7TmM7RXvzhA2GIx1JyN2Tk571km1h05PV3+R3ZhOlUrR9mtIpJHGxW1tZw taKyqgGFC/w1YtEjiAiWd2SUguzDH4VxzdtDnj0KV1NNbXShIVnjY7eGwVyOv0rPg2LqcQm2vK0+ 8GT5okIOeT0x/hWi1RV9bH//1v5zPtclz9o8ndbPHclU4/dzAc5X29KniW9MaPcSO679qrgKE6Ak flXwTm3oegKtvNFLL56/uozmKVmBJB/lWxEkLR7pZA7AZUY6+9KLszGTuyGG4TzJbd18vAzG458w 1AtzItysIhJErgecv8PXNbEm9PHcvEhQKGj+6x4bHTNYhfVoxcGK1edYxmS4TlYVJxub88VjL4mV F2TR/9f+fTSbp3tVs4Li6nIPm3P2z5GZ+SSg9B0FOuHKBpWG1lPAUfN6c1+fnQVVIVg8g/eN86Y/ rWyiz3NqiI8G+R8MrP8AOijrx/jSa0ZcEm9SvJpksbFIkL55OeFJ+tUkitIbiPKBJV4CL93Pc/59 azUXdo1BTLbyytYRpKQ+54c7AMnBNaASQq084bk8lR09qmz2JsuY/9D8B9NhhRZWjxEdxlwQRlj1 P41WVLkGSWa5BkaUlIyMEjsPw/rX5uegXhJdXMbvE6xnZtWM/LG5XsR7kVZW8trmGKUoLK+iQRz2 cbFkkI4L8+uKB9B0sjzNELqxeBo8YAyyOB0bpxmrSPBcEqAQqDB2DnjrQIzLayUSTyLcrE0XzxrM 33hkcD3xnj2pxh2yNIkm5WHzAfeU0F7wt2P/0fwdjlEibIpdqIMM7DHNWLyzhs2tp5DLl13INp2v z97PpX5uepBpLURH+1yI4YRRQNuOf4+OBj0qtIytKqKBs8z95gfK49vSg0Wp24lsjdXDtYO1h9h3 QxwsWlgYDHHc9OnvWDGbOIuCqJIyHAkGHw3XAPQ9OPagCAo0CK9tuOflUgZz9a6PTPE+ow6faJca XYzpFfZlVhteZAMfMQMkdwP1ot0A/9L8R9T1yO+ecT2y2MLuWgSEGQL7Ada5y4nht7l7aONndUEh yhAwef6V+aOHY9Oe5vC5huNMjhjQRSeYsjqvHKcjnvSWENm7s16jbemUwGFRJWdiCkxUXF1Laxsq 2r4hkYgyOOo4/OoLSB10/wA+aRHmklbfEowIx2/Q1IDUYWgecSymILukT7yqBzwK29SvbS7ttPGm Ndh5Yf8ASvtACqgwPlTvj60Af//T/DMQy27xNkrCSd+RuLCm6dFeakLu58k21rZ3nkEuQDOOxGf6 V+VTetj0Y7ovnS/tE3GEjPGM449qzdXgS2niId3EZ2qAOce4qo/A0TPRNCSSXt4VjiDWyI6sGT94 Hxg8gjir9zc6lORFMlwQi4S6ZSyj2Dc9K6o7IrmulYjjErOzmdi+flfOHU0t7ePZNEUlklmDZk2j hc9P50wbvuf/1Pwtl1O7N2qRReZHJDuZghYrz39KvrcSJullt9xSLEcbDaj8cV+bndKVipo1u9zc SfbHNs5f5Tj5CDyP8KnnneHfKxGIjiPPfFYyVoSSKdrWJ5NGa5WAwytdSXEf2mQlfliZiSEX1wMV RitmmjaP54p4Ztn3SvQ9q5bFNJwUTTmmeGErDhpkTJVmwG9cmqVtPdxNGyKq72zIc5Iz2FJxT3Em 1sf/1fxJk8QbLlrCSOWW4MG2BXhYwnOerD0pYLOCC8SCd0t2nUSnLfK5YZ2g/pX5RoevFj7pbix3 loFW2nZkRlPUADk/n0pLMpc7H8mRmLmNJyP3SADJyfypFxdmE11bSXKfuFZB8m/GcEDqPTNLc6xb 20cEESuoeXbJ8mQPTB6/n6VtpZ2NU01cEKmQsJS/mcjPAX2FRx2cc87qLgjJwV9DWIaH/9b8bIrC zsLYTW4+23hG12kXZ9nHfbzznHes5fIuJVkmCearEBiM7a/Jz37lGct5s0ovpkcONggRCigdRkj/ AD7Vo291b3NukSxzySSTFLiXZ8vAwGz+BFOzeg7EtyY7LE6ooji+8WJJPbgVLK72scWpbR82DGoO W59RSB6FONJL+5MsjkhseXGex7nNbP2Ca3ut7OkwXb+4GGTjk8/zptieiP/X/GXypYL27u3iMk1x L5jBRgKPTH41NcauNLllMPmH7bEBO7R+Y0agg4XrgZHWvyR336WPoE2pGnH4hHiR4XmuA0lsgj8x m/eXCgbVDZ9AB+VUWiZNSkkW4kEIwUtgq+TH8uDjjPPXk1S2BSd7gshWSRFjV1ZsbXHymrEwY72u ZXSCCMtEiD5FP0/z0p7Dm7NXG3c1la2llczymWK7HEcaF5CB03KBnml1GODVbdJopZbZLckxQ/6p JRjADDr+FA27o//Q/GvSm2K75bMZwRn5RXdaFd2N3Z6lp17KYZr50+z3SxZjtwvBDn3J/n6V+Tn0 UPiMq8Is4JolIuEsc4cfMhAOOPrn9a5U6j9nma/UzsWjKgQOVZD24FBpJe6S6RdW+p3VomqRslqs nmsJmMLYwevvz0rWdU0+5uxbxxC1JBtGyXn9WJPTnj9aLFFaa9mbYrqIftjhRIBlsjt+P9K6G40G wmhhmS+ltrhcl7faBDIABjJ6/lUT2A//0fyUsr23uJoLMEh4G8p2zhQccA/p+dbd1biJdkbxoVJY sjjbnrX5Dd2Pp7I5F/P1O2mtrq6uYI1kIBXjBHG5V6fSremwW15NHpdteXMqW8RInliHmOFGWIHT jB79qnpyg1qZNqVEskbSyMbeQhnZgxlx3PbnHQVv2V8I1VIoHdQ5LBxnueRRa2hnK6baKc1nNNqE N6T58O7y5rZclMdunT0NbUulMLdbiVorVJFby7dmwXVWwAgGeT1pW0sVHWR//9L8kZ4rxkSKORY4 gNp6Bhno3r2P51XX/TorixMksstnEGnkYbMqe4PT24r8Yas7H1KvfQ0rW6hlWO2KYZfl+bqMUy4s r93X7JnYZVDHbuUDOcY7nAOB60i4XuW9Ra1uJENpDJDHGqqkkqiOaUgDczgdCT27UqQ2MrWk9xKY mR9rBT8h4xlv89qBybirDbq38+VlV0miV8xvGcrgd/50FhFbC3hgR5N2fMHBSsGtSrH/0/yDnk+z XMctwzvJvACoCyp7n0xWw+p3LCNA0j8bk2jKY96/FlsfX6WK9212IUEEkSu7ZlLKX2jtgDv/AI1T QSzh47g+R8oDyR/u2ye+O1XFJ3uZqSjoiVfKS2k095zOhGGeTBk2nsf5VqSOnkhYgU8uNRHtG8sQ AOaSt1NU7oz9twrPcuiQvIoZWUbS+OOR+VSWc5kdknuQGbs7YOPQVcI9RXR//9T8mrkLboY4LNZC cKoQZAyeTx+dZc2qEyRQy7lhi+WeOROo9Aa/F5RV7M+vW5Db3jfarhdNdpI4ZVeQqxji2nGVJxWr HGv2uG+cxjTmcgIMfKw6/XHH61jKNnYuLs9R17K6yvLb4COwCjOM54zj8KxLpNRvrq10nKpFdcSM z7YlH098U4wb3KdrqxHG0enyS2CLvvEQEocgRKOPpz/StiD7Y8YljTeV52twPwpTitjQ/9X8mVvY p9WSN12Sqg3Nj5IyBg89qestos0piKyM0pMYzgg554/Gvw9K2iPs72ndmdql7BEJvPgjG1cgrhRn qS3r3rIutQm1K3t9SnQyWrcW0zKRH8gA+XNBomnsaen/AGOZ47x5pY5mj8qAEZhYZ55/CqWpMzPm BBlZMOx7j/OK1grLUZC0z7oxdytEp+SIgcZPRfxNT3mJo4U1B38tPkhb7+30+nSrWgH/1vx3Mcax pbwytMZCEk3x8BcjlT61Leafa6SvkXRkcSrmCWPc2wkZDMe341+Nwtax97FXjZnPQq1756SrNGqH aspO13x3HtWqbeZ7ZYLOALhdokKnJx1JNaWtoJxtEpWMFrFPsVJYnt4ybgt/qZ3JJ3Lx24H4VFFd /wCkTMIwwMm1Zn+Xfj6/U1nNamY2NI9Yka782RYY3KSNGfvEfKVx+FaUdlbWkIIWScfxv3UHgZ7C syeWJ//X/GOWwcnyoJjtQ7vv/IPc4rnoGm33IkieMwzGIqflMu3ow9j2r8XPsWmh1pcSzXP2cbbS eUmMMxBKgdP8+9bMgv1sBFqZe5MChIpHJ4APGFHA+lVGKe4iNLy4jilkjRJZJLcwhp1LGPPdfcdj VK38gWUz3Fywud22ON/lznpz9a2AWa0vI41tnQRsyg5DZQZ5GT3q/H9mihNtCwE6pvmiAxjrz7g4 P5GnFK9jduyuf//Q/EaKC3kujP8AKrA7Cy8biO2a9L8PwR317pNjavGuqS30bachkwfNQ7gTjnop /SvyKpFcraPuYPVNH9DmjXNh/wAK5W6Xyxc6N8PbfyHH7iRLiK2UfKh+8ynOT7V+Fnxsu7i28U3M x1HUpVjvJmfzXEltmQK7BR/CFJICgY61rhF7jNqvxo9z/Zp/aisfhg9vY67eaxJoOrBrH7RHCJL7 SM9WQbchSVB5B69e1cj40+I0HxQ8ewazDe3MpN99g+3tB517eFptoeVgfvBcZIwBwMcZrSNoqUX1 OmUYVopbWP1Y8NPHonwk0sRb4ZLjw680Qvbb5EaRAwIHqDnHqRX4nfHOKW41i7tY5J7aGC4kVmgI UPucsX/PjHbmtIwgoJmEoqL5Ef/R/Mf4AaUl9410yBpBPAx8w722fZ2hIky7epxwPXFftj8Q7C6X 4Nh2tlh02VU1GMn9zKUhhYfvR6IzD64r8yUYzXKj76dJx1TPhv8AZFhtZvEniuRpXur6W8MVjbRp vW08yZJNvHU9D9BXpv7bdpLb+HIUUiG3ay8iVp3+zTGWRcyFscgLjKn0FDppRMJTlF3R+Nmo30sN 3ZRWLW/kzOFxN8kbJ36D07V+vH7FjSTaVqk99JYajIlsl1YTvb74baMYDoh5+ZcD5uuc1jCDuOWI krWR5r+29f2cuuaLFHqEj29tEzWltFEptJG8ibKKzEbShz69W49PzL0MapJeyRR3NwZrt2UGEiT7 IeSu0D09qpxlawRrPmvY/9Lof2X5riz+HOnpdwQnVbfTYY1mRcrCv3JXZ/7+WQjPb2r4O/bA1CST x0tlqUl7eLFFPZXcsibrQOjbMt2JIBr8oVOSSR+hKvKcm2fAs11pttremxbr9knZrPdaxGTyFCk8 84A4HJr9Jv2KtOTWfGVraXE6Wlna+WrzL80rMElMCBvc7c+hK+tWqd2kaqzR9VftkXMX/CDPBf8A kvf3FzFpllNA4MlxgMZBJjOMYGc+prJ/Za0/w3N4Ue1vILa8S48qJrm0tVlYTIuWXPBwhyCM5HPv XpRUaaVzl9j7R2ufX9hpem2EhFs0Nti4BR7W2WIZOMMVGOelfl5/wUgm1sadd6bCkV/rETLIl5qb hEULFmB+AQdzHtzzXbQcb6I4q9O0T//T/kT8aeHNQS7d9VWB9XdZZPNdwqwbiWwp6AH09q+ar4XM F1eTBhIJNpdVPAZcg5b8B+VfNQqbWPerRUdUbHlCa3SRIll3IEKrzkGuwi0G9l0BdStLltO1JZng toJFCLblANrhvQ/pW8qllsedKWpoWmi6qbYnXUlmIRJ1afDJcN1LoehB6g1sXepRWscItI8y7fmL N8px2rB1H8NiJVFCN7anV+HI0m1/w/aPAss2rEzQXCvuW2OOAxHQ89PavuXwyltp1vDpkv24uLRS k97JueSQEElRjgYzx79TXDX5r8prCzip9T//1P5SPAGjrc6tcRtJbSrcQq0cE8wtkJIYZxwT2wBR qmkRw3E+nrJFMiOVa1TayHrgfp+lfDqPvXN4zvyIz7b7RGyabqmn2dpHpsz/AGJoVJvCGwCGOMcD oKwPiMtsNGnhVv8ARo7czXO75cLwWHr2/Wu+K1iVf3rI+WJ7uSMxPZpG8LHjzSQv41LdNO0LXLSR mRJflMf3I88Yz+f5V71OP7tMic9WkM0KzmXUJbO7mXy7q0MgWOXEZHXJ9CQcDvXs2g2k6GCTSryF be2jjEm5flcYGAjE4ypHWtqUPe0M+eyZ/9X+Pa61nWPNuv7HtrK5S2t/Kv7y9tfPjg3ELmPPAOcY Yc1TPh271KOJYL20MkkYa4lvogqOoG5wOQFJwRz71Ek7qweRqQXSyzRxWskcbJbi38iJftFuxRQp z167ehrhrc263EsunaaNM8i5czQz24NtcEk7mVScYPXmrV7akRSTdjU0rT7OA3Wp6b5s0F6A4huh 5cVpIOGKdwCQeD0zWlcm+1HVNOhlubS008BbaZyC7IvQMD0+tBZkXsljaXqw2sC3F5DNsjuxld4P BCKeCD1zXT6LosEN5cX+s6iHtb1Ft1s4JRHdaaQCTIFx8wOenGMdaabT0C2quf/W/jhmv2nvbpdL vzN9jl8lJZx5M4VTgMV9+1MTR9Vu1k1G5vvsbQyhpYSFlOpIehGRkHofpmr55bDdJblvT7RIr+1u TN5l8JHkjJODOOm1h1OAelbfkwLdNcahO1nGvDNs3AFiO3+FRyvoHImrMju4YI55rVJ0u7YSrcFJ R5qyYOVPrgY49MVSl1u42Tyabb2+Z7rZdLLug+yICd4jH0xx6DrSd0ttSXR1sg06ezvmSKRDawgk zXly37qYgk/IOvGOPXjFX1NlqNpJcaRqUVwi3gS52NvEmz5Tg9PY4rOd7IPZW1P/1/5CpbayTTZ5 Jbnbfo4aKF0yrehRh3Hp+tUrFLSxtP7Sur+e5R7qO0miSHMs5lk2thQDgqev1rnFGFi5qunQ2d55 cDSyW8Tl4VmQh1DDjAPpnH4VDEsdi4ujGCIBvK7OmOTjHemot6Ao2Wh0E8tje3mm2jJFqMWojF7G nMloGJChuMc9vrWB4vhbQ/LHh+WBZlRprDdC3lOVbAEo5CkEdD196HFp+YcicSnoT3ej2j6hdSw6 nMitNqDX0QWzjlcZKxAdVGePfPpWpb29mLW61S9vY4Gknj+yWZDG5JkzuKAZ4HFZNPmM3G3U/9D+ RltMd7fyVkZ7dpAXaWRpcr1wvPHNWdRs9Ls9JY3F1Pb3IbzLfAV4lyMAD3/Oua0+VuxmowMWy1u8 hgg8sm6SLMc8zYJHy8NxxycfnTRL9rufNvnDxyKUa3cYjk9DnqD9DWK5krly5di9oehRXWn29pcy 5mtbqWaPdmVY1dyURSecAdq27yGWNDpdtNbCcASM0zBIigPIUkj5uOB/9ask53tYw0RSs11C1E00 T/Y440wXt2Jkcd9q98/1pkcWvaXdJru+C2tpUNvbz7B58zkbWBQ/7JwTjvWmqZnOzVj/0f5GIZp7 iVm8xZLhNzRtKgkI3cHgjAqC6tMGGQSRRm2XBt8hCNwxhV7j6elcCTvoeZNtbCS6TfXVo0dhqv8A ZFze27WzX6hWaFSykgKRyDtHX0HpWnp1jKsW+ctceT+6EiKDJcMOCxA6ZPPHStyOZ3uZN6/k3LXE sTQpD+7EkSGTbn6fhk1q6fdXNy0qIXe1V1ZWmXHPTK+9Oz6I1bSVySTSxFfyajLqFyZZVCCGUjbt HbHUcU+SW+iSawiubWPRriUCNY5g9yGHVD2wSeMelTyW0RKmj//S/k0tL4NcJHDPHtsztlQ4ZmbH AwfTGT+FZmpapZy6rZpfbZFjuhvtWfy47rPVTjnHfisHFrRnm88S1qGonU5LfTo9Mt4rezPmwTxE q0ZyePU9B+dQWIuLC5N1cIJ52kzl13+cN3CfQZ71jKLuClEt2mj2c0jXF5K8Zd5J3uCoaaIMSdiD pxwBVazguobvZbpG1q8mdwTbJKf77enA/SqhCV72JlLojoLuF1doY32vJGCkqD5Y264B/nWdYaXq 0088NyYXk37bcxyby4x3PTOc1tyyaska6WP/0/5MdQtf7OmQXFxLD+7LPIhIRB0OT60l1E+pwaTp 63xisLBy/wBqaPzCwkOWZj1z05rOKnHocULdSYlLa4TTNPDXN1Oh8tYVLyzqvGcDpmo9M1tbmyuI 3DosaMZPNQ4Ug4wx7c549qcU1uXKy3KZkvLu4FooKReUEG07YgM9evFad3pk9pZRzuEjjkYxLKsg LMV7bQc/nUOMr7BzRMyG8+zW/wBidGElzKGV5IzmQrkgKfz/ACq0um213avdXmpJbhYiJJHdeHU8 bAeQcjHNTyyT2BTi9j//1P5N7/UbB9ItYLu9u53hOMlsJGgxtZAO/f0qK3SxmaaGC6lu7dLb/TTL H5BG8gDA74yOR61z8j5rkJpRNlrMY3RmIWlvEsaBpMSEYAxg/hVo6cn2ZGVQWt1JRe5ycnH5UpU5 NaGd+hWvtNlmsLfJbZJKs8iqCHTYSVUnHfrVWytJZiZUlYTopMI5V1CZ9emMdPap9lUvp/W5cmmt DZ07V7k3jSX2kWl5DGSvn6iWl89sfexx05A5xx3qjf6Pb65cx3cxaGaJyUjt1CRR/T8u/pVTp1HG MbbMc3FxSR//1f5YYNLlNmtssfnXTT4hlEhUp2wB09DzXLXWkTyNJI08sUls53RXEZUAgkM4b046 /rSdGb96SPNxE7RUUPhkS3Eum3V64ur9D9gkmQyjgfOSR09s+lZF5qmp6d9kwu6COcrJOhO35RwD 9f0rJ0Z2tYiDVmaTvqF2v2sxMI44hIoiPmu5PcD0rZtbW7OnxXV66s0pZVt4iXZCSMFs+mf51EaE 76ji7p3HWU2taRdQ3Wj/AGeOHD2+oG4cNJKJOrIMHlR7YqvM4F47wT+XdR8kocuCeQaf1aq5Ssuh 0RklaLP/1v5SbuF7t7fzmlLuQjMF++cE8/lV6PTb4soV0mhiQtO0rBJMdgvrU0cNWVJOSOWi1KUk jKma5tlW5jhYqk+VRB8xAPOF/CrdhqiX2oRRmc2sEr+W88qmPaOmMfpmsYYSrJyk43Rz4zGU8Hyu XW50P/CNXNjNLqUdhEIxMvmX8REjNgZVj6isK4uJr27uY2sEgM0xcyRf6uXHGcepx0rP6tUSlKSt /maUq0Jw0KxgeG5Xy2ZPl2FWHyfWrunC8uL6fSII7eJprc3H2+7lFvbw4z8m9vlG7sM0UqEru6B1 Y3sj/9f+UIaSEa5gvrq7sEYsXu7ApP5hGfutnBGe4P0qle6e2rLaSR7pIID5fz/LM23uwOOuK8xU pqWxxOouU1NFnuJdJlDovmpLJDBGTj7jEKD6cAVotAsm3zXjKgDLAYjz3HPvxSxFCuqsJUl119C4 1qfspRnv/wABkV7BqXkR21rPtt2nDeTIcQMDwzfUCsibSyEe53b5YR+8RDlEAOMj61jiaNRzskc6 qpbD2RikcLKGQ4ZQv3iTSlpYgyC3VRjACgnIA5OPXiiNGahdrqVKomf/0P5I9UR4zHcsoCzALCSc KWz0x7iuqtI3u7NBGzRuQC6rxtA9K8zD0pc7Vuh5E5q4HRbZXDsWubqAbowRlkDe1RSTXdjciG4l UQzRl7aAgFUJG1j9f/rUqVKUa2o3NsnxCtrb2+nbEkcn7RLMNyxNk5AqymmNvCwXcMVzIu1JJ32h iOo9PXrXdSw79hOo49UdbUVRi1vrcxbGDU9PbVbZ50FvdMhhRFO4Ffv78993IxW6LkwW8W+XbArd 22puPHr1NccqU3NqKMj/0f5Y7eGzubm3iuXuIlEnmXM8QypjJxwMYyACcfSuUvp7rTfEc8un3Tto Lr5SxzN87ENxJtHHI9K5aFOoo6I4ZpJnpdtPoOvaHLb3k8AvYirqMBVZQeQff69xWTNY2TG5tjco kItEaGCVABJIh5xjjOMHn+76mtfZz7FRUbamVNNt3XEMcBjiUQtAi7UBUAdPXgVDZ2xvIJ3SJbVZ SdzxncQ4+vFctOlPns0bTUOU6K0ZGjMZK+emEjdSN5A65FVZ7G6uJJ5mUBdPXzHJlCMR05B5PJ6V coNPQziktj//0v5WIokMUszRtJI7ZaIAtux0FWJY/stpO9pAn229tf3MGBuyhztz6njivPaZgld2 MbT57xXjikt5IY/LzImNnk57Y61tx2a7f3kmVLfJEnJYHPJot1G42RoXllby28FpHMBHcDMoibDr yRsJ/DP409obawtxaWunQJJLIGa4J2SsVH5Hp39OtJiSbOaudiSSF4A8iyb2ldCCvrzV+OzE1tPe QbHWParDeNyhs44/CrlslYh20P/T/lIW/EXkW8/mQxh/KMkcRfygTxwBxz/OuqjtJDFHuu3MajaY yoHn9+fpXkWl1OWSutR+q2Oq+IrSAaXPpVlLpaKSt2wga6jXqgPcmo0udY0Z0me5htkddgEcyvKC Rg5Hp9am9jEbdR2cul3LyD52bMjdEcDk+5q5pFjoYjMt7crYwx23nhvKZjIy4KJgdM+p44pgc5qW nCW6WSeFi7AT2isf3ag5wV/WrkN7GrrZsozbp++CnOCDjGaAP//U/lpmNrIkl5JERJjBghXdHEoP 3l9z6+1dDuslSGWSZ4mjTdJg5DDHUj0rxzhgveM1zA2+Zs5OPs792PbirL3l7Bazr80y3Eah1lAz Ht5XZxkd/wAzTex0RXvWOSmLfunikeWVh+/h6RIc9Aeta7aTpphaGeJ01BUSe3lKZjQHsM8fiOfz qp3uJJXsNtbOCznaWaZJG4CJIBGMDrg568V0mnaj4RvvMtJtQjhmbPkkxeZCzj7ynHP5UOTjHYvk XVn/1f5b5ba3iuVvWjjEMKuEbPAB4yP0pdK1OCe7X7JNMkKMFeYxlBGc4LL6ge1eS3oZOKT3BLpN Xa+tvtFvYXOlPIsV1HLte9QkbeCOGOT+XWtW31aDSNAdLi4ht57qVo7RhHma6Odp3H2z0PXmod+h NlfcqWEulW9tf2txM1xdzRCVbi2QAxBskLu6qenT0pPO017VGiCxX8crLJIhLySxkfLn6HNCvuwa SMWe6dRGLiXyTJN5cCsARN+Pr3xU+n2iQzC6kEU0iTF7dGBBXIwcn0PP50xH/9b+Wa4YXO8TwxF2 YxtGOY1HtUcOmz20JuUZoNPtWCBYsBOhJ+Xr0BrzJvlmcnKm2ie5Qzxx3MLgx4DZK4Le+MVNbG8m 3nahxgRqo5f146VCcr3RRYs7kWlzcG9jJjRRlJFaKMZyMq/qPxqKICNLyaS5huJmfNvD5ZSWFWzj JHHGOtSbQWlzHYs9xsnkkkhktnEyO37tTngAe4P6VKmyeBbRg7wWy4hULgp6YosKSP/X/lhaNzFE 7LmEHk4+YgeuKzp5baQm3QBepZCPX/GvHMEm3YsaVZw6czymICdwR52P3gTsn0709izCWby3JU/u wy7Q/wBKqWishqN1crReXcRSgTRxyk5AlfauT2FRWBvnjdHEMEUbsjOGw8wzjA9c+gqFsYyvdWKt xbmNXS2Dt82THjqfX9agitpYlaSbCSquUhDZZj7fSq30SBKSerP/0P5ULacPCVwDKDiRCcgD6fnU jRP5UojO+Fh8yYwi44NeQot7HOJZL5CgWz5x2B6UxLqWcXAMTAw/K7hSAD7GtIwtuHkQx3tuYd3P mD5GyMMCPUVRZpDuMUzJwfMJGSwPatFT8jSMklqVra2kZJI/Pby0OVGMdauW93cWttGhV5TaluvK yZOQAPpgVfso9S4u+p//0f5PZrx54428sBi+Rn5TH7VV06e8j1GaJZJZXWT7UZpG3SDec7c+nOMe lcrpxsF2mJNcSreXLSTNIkhG2ExhfL9Rnr1559K6u21PRRoD4uJZdTtrzZ9ikhKQhCBlgxGOvp/S pUE9wdzk1kje7Bjk+0MHMiqx3+Wecj8Oa2VuVjheWeNiiOPNZRu2AnA4pKlFGTlItT+TcwS28bqU mT7xOCPfFYtlp6WUk0EkgEOQ4nUZHpg/Sk6UbXByZ//S/k6EH2iZkDBlQnDjgMKrRWUNldx+bI7R zy7ETZ8u488/lXmckdjHnkXri3WbKmGPbG44PAI9qJJI0U2/klmONm3I201TT0RrF6XLa2kJCrtT BXIMuAVIGeKrSWyK2xcRkLumKruX8PyNL2aWhpzSsR2xJGWYs4JVdy88cA4qeUNKVUxliB85OFzj 2o9lG4uaSP/T/kuuI7pHSSCd7cI2BtUMh+oNOjSFizyEyzMcPKR8zV5kqKtqaRm72Y+a3WONiJwZ N37uIDBx1zVm21fR7QbdQiZ98XktshMmWYbQWx05Oc1HsYlt2MaXTLyNomtDGbSL5Y/Lk3SAHplR 0rbgeVUXKlJkH8QwWx60OiugnO0SC8uRLOssFvFHJ5mLqJV8uM5GOc8/zrZjgiubVbaaK3eArhIg oKpnqB7VDpWE6rtY/9T+VKRpLR0iZT5TJtj7bdvGKwb15vOJhJ/c/NIw5znjB/8ArV46pJxNlPSx cuZItTsbfTrqCDyI3EqNszOGHUg9atwExTpcIzTS26bd7fMUXp06UOiu5mpNO4QR+XM3lPt8wmQo o+XJySSKbaQwx3UrXdxNNeSSbIY/KLRovPGR0/GsPZx5xuV1Yu6hfNFKtvI0gZE+WF1IC98iore0 lufLuCkcWfkLs3v3ojTi3oKMuU//1f5Y4bXzNr2yK20bZGDYWTB781YEUtlF5sinyNxQwRtuO5uh 2jJx714SpdDVTTdimRIroF2l87vm4x3H9Kz7ESw38t7dzThrmXayNKSvfgAnH4VHsVqkzS9lY6O6 M8i2xsXW0i3FblnmISQc9FA47etTWt0RamKR5CRu3zSn963PX/D2o9k2kiHJLRmElmEtHt/tEmZL xriNicCDJyAh7YNXiI4tzyfvGiUASZ+dvrWnspGUpK5//9b+XXT767RSY2wMEEMOOfpVn7bdyo6X AiSOU+UUYHbjp0r55UpI3c1fUtQavdRwrbLcuTCdsUQOEcDoT+lXvtU00RimmdXk5OODjI4qlSls kTzoypLRo3MglUhR8299rMCccA9fwquoxJiFiY3GDs4de3Bq/ZTM5T6nV2s0N0VhkZ28tQBx989O apXzT6cghtvkiMxfYxy+Sck81EqT6mkZqx//1/5ibz7TehI4rtI59vyuy7ljOMj26+ta8LB440vf LE3lLA8iYVXIGOK+c9lIpv3rokMJikVo4tyBcGXdwnoTUE7ugCSt8znqhxj6VKpyvaxTmrWRZDTW cltNFMZoEO947ol8kDt7g8V0WnXskEM86yBRc8yIo+X6UOnJIFGPLdjbkx3MM05kXzG+cpj5mPA4 rHicxZ+zxKs0hCykJhnxwNxqZUnyk6JNH//Q/m/SXUrYea91GbdZQ8UDJueJyMZTPTp2p0mp3rLL bHe6u4lKyOTG7Z6kdulfLOm3q0ONk9STVPEZ0wWX2r7VczXyeW0cMbSIgU4xnOMd+3Wo3ljuLz7S J57doLf9zHESFn3Y6g+nrUOEmuVlK3NqYLJc2t1CzPM9vIzGcNHufJ5BB7d+K6C1gFw8TJO+xZQ+ xsIoAxxXNKlK2p0wfQtXd5p/2y60ZklF/JbCaG6gw8cQyQcnkZrLW3jtikLmSVsYMh++fc0uSQcy 5rn/0f5yJNsDoI2LIqblBHNatrLLc26oybX6hQfujtmvh/ZeR3OSSKw+2vvgZWR85KTLjA7H8RyK umKWzltVucxxz5EbFTsPuT+FSqVmc8tLErCxE32iUgOV8uNi2FX/APXT1vIbXMb/AHW+ZHC5fPpW ihLsEWmZxurs/vRI24N80eTwtbVvqF7M7bo447Oa2EUscQKNKy927dvzrKVN3KP/0v59bSJY7oSJ bN5zqVMmMiNAc/h+FXHmjmLkKnlbNoccl2Gck/jXwXIzo8iG2tIJjJmQGcrtAJ+79BUlvELAbHXc ycmTOTRySGnZ3J1vZXmheNn8hX/exMMBweDg9fSs2/08peJJCzOHYOR/dzjgUuSRfOaFjC0ss8Pl iFivzS5Cg+2fwq35/wBnUqV3RrxtAzuxRyPsRd3uf//T/BAS27p5ioU6ZGMYpl9ZIhhlLxyI8QkS WNw6jI5U+hGORX53KDvodsZ3dmUBdtagYRWV3yGyRj1q+YRtFxtTzJORjGcVPJIs6iC6Bt0uLmNp k2eUwcHcrAYHvxinRPZtHJ+5igfySFEa4DNjg0csuwHNh9ly9t5G6R49wkkQ+UuTjr60tvIypNFM gWXoQvzDHtSs+wz/1PwQuLS3lt0hSV0M2RIcY2+mKtK0sWEvnkezjjCRjPKAZzjPTr0r85UGz0F5 kEdtK10hgJjhmcYSY4IXHU+nrU15LDZN5KbpG81QJEG6MEnHWnySN7xWheudUuQIoo51t/mVZJcb wq98Dv8ArTWih1S4+0xzvfRwv5a3Utu1u5K/LnaeR0pckgTT2LkdzbQQT2jytM8YLeYq8rnPH4e1 ZcDyWUyxxy3E6OuSJsNt9xQ4tDP/1fwpe7IMM7zMrQNm3jC8A5zuPHtTbny3Z7555GupYm3op5cH HP8AMfjX5xyvses4p7lXS45IIpZpZppQOVjcDCAVsWuo27Qyoy5lZgQc8KBnt61EoNmJWfz18w2z j5+u4cEVZsvKEDRXLBHyd2z5ip7Z/Ss+SRTilsyaQxw+VD8sm8cgDqPeobi2w8XlyGIRnJHTj0pc r7CdtLH/1vxGS7jWArKI5wD+6Y9B7VXctb209xM4SNMSCKAEqMnp68V+VOm0ejHdFG6vzFALmSR4 rd/ljcKTubjj9aS1geeUTSzeaHXCq3zY9yacIuzRNRas6/TtNR9PuLj7VDG9uT5sT8NgdCD0rBh1 GS62QpKTAXKqzfKq545z0rtjB7BHZFNmW1F2QryuGDBYxuOOhPWkdECkMR9olTerPxhT04p8kr2G f//X/BvfqFu4eCXy4cFJmA5ccYH0ratTc3L7LiUkygMu89gO1fnsYJHZPc0L5oYbeNYWDR2x3s6p +/JIGQSOSOOBVCea2uo0ieNTIn70x9SwHqPSsZQfK00aHQQ6tO8EUdtGlnsjwNg2uWHfOetYMGlT /aJ759QuTPkyLbyPvhfJ5Ht+tclOD5hp6olRIyzM7MzucOCMBPapVAu2ligYRyxR/wCjgDkkVhio yUdC4P3rn//Q/DZZ5pp3UXCS6lbR7b1WHyxkAchu/sBWzY263cbnUirOiZgOBujfPDD07/nX5Jh7 zi4z3Wh68ZRlJ+pZvYp5YooxNHJFFHhVZuck9vrUBWe3hSGDbsYZClsKp/iP6VryvQ1jZNsrRwxI HWYYPUY5A96zbt9skcUIErucEHoO+TWnJypouytZHRabDbO0Qud8W37u1cliKumTRraW43xzSzKP kMXAVz0LVUYxjCV9zaHs+W8uzsf/0fxXs9Sk88yINyKxXYfuH2P+FQ3cRTM8SFcsSxHA561+U8rv Y9yOrQadHamOS3hjE01zJudSMbSeOD70t0L+0ElhbEI4PmRRhgA7joMj/PNVG97s16WL815NdRwQ 3UcBvbOP9/FGoCOeOp7+n4VPGwuIGNwWDkYSNVynJ57+npUyVmQ+xOkHkohQCPaODnk0iXMsUu4v gy8EuBik46WKm7U2z//S/HRrp53AtIxLMPlKgZD1JHu8r7RJEsbSZhbgF8cZH6/rX5Vb9zax9SnF 4NWetzHhsrOxuJ5A/wA0gBihAwFIP+fyq9LDc72uchFkUeWrDqeh/pWUX0Oem4xgmzSNnJbyRi5M QWaESq6yB15GcZHf2rl77UZ7dpbeTY+9z5eDyFzxmm9mjOtJXVyaw0+2e0tpTPdfbGunklifH2dU wNoB69zx7fns3EaWyR5iFxu+YRt90/XFEVZWHGXNof/T/GC1t7i3inS3Yxw3chO0nKQt/s+mPT3r Wt5JrYEN5TW4UBgykMzexr8nWux9CrxldlKa31ed2g8xFt5f3yqrZU/3QR/jVabTZYraASTJDcRy kyLDkhwDxkn1/pTaa0NN+Ys6RZT3kc140L7bdsNvXBJycH9K1IrC4uLaW8luIlMUmFgGfMcZwBj6 fyos1uWKJUka3to1DSF8sc/6r3q85uxdpBlWTZhd5AJ9yamUboD/1Px/iijSHbCu6aO6MryN9+Q5 Gc/TFLPfTTXq20ayvbhAXk2Har/3c+30r8l5Vax9QQXou3VBazFD53zSkbmJOfWpvs1tpJaGS4LM toQ9zC28+Y4+dSR0HJBrEC7pWn2qW7IiqC48xvNPzOB9a2LGGK1ldvNUovC7eSD6UGD3ZmNdNDvj solihErFsgcsTkk/XrUeppHctaXX2nM0C52xE7F3DlWHqPagqMraH//V/IWLybi4WK8u3tYnQkTR jeyEDI49yMfjTHKmB5FnCRIctITtLY96/HJRb1R9QWrq3+y26ahFOl1uVMJAd7KWIGT6Yzk/SpUj 1k206LcMEJFwF4QJyCu31IqHCSKi7FO+bUozPcykujx+a5k7NzuJPv1qpp6akqiTUBB/Zxj80KZM S8+4/lSs1uUo8yu2aljp8ekyyvb6i9zb3CCSOJl/1JPJUfTNWbV455pbRZZreaRw8k04xFg9NpPb 6VLV1Zg4Xe5//9b8d7qFvt3lxXHmKrkSOF4cZ7Vo2lnf3V432e8ZLBEIhiuGSNj8oDDOBxkHAz37 1+L2tofXOOliSzt7q3mllkmUujbkx8pGDxirbv5ksaTxRSFm85lMQYyMMEEkjPGAR6VXK0ZNWdit NYtP5piQ7SMsij071nfa5lubXypSIxxOj8KRjv70km9i4dUautPLJFDKshMgQKUXBV17CueMLeas 8r7FVPlAGSCeK0ipLcFF2aP/1/yL02ea2jWZpW3QzE7tu5CCflGPbvUGqTjUbkQuqm4Zg/7tex6d P5V+My+J3PrIpqVmU7PT7i3LWrymESXAuJEHyj5cgD34z+Zq/fLFDFtedUjydhZvlB7j8azlG5ql d2IZ7eIpp9z9onkmD+Q0AH7sI23DZz657U+KKR9Wtnjn8tLdgRJN8vzDpj2qja1iTUNq3bXFwQr5 xNMR8zgdDUthNJcK5ViYeqMP8/5xUyjdaDP/0Pyk1G2tZbUfZD5sq2omuGAwyMAd4+nFZNhbLbwi 6lt0jjkTIdhhtw96/E+Q+3sr3Oev4zqErpFuJJG5D1PPerclqjWItLkExJwgViscPrgflScOwJWM LRbUpcbTqE0sPnsVSXmOEDsg7c9a6calp73X9nXUUsUQG43cMfmOe3Ofp+prRKysXyu9irbi1udH N2bqOSWK4dFtHB3HYcBgw4/A88VHaPBc6a0F20ksnmsQD0UEngEflTGoO+p//9H8dWt7uN7VbDco QcN90xhRT9Qt9TjtrSbVJHuBcyMPlIJUKeC3t2H0r8YTaP0BK2iBpLGG2Ij3STKPmx9wenNXrK9a C23zSK0yjdHFGv3VOcZrZKysFuhkvBMri4vZ4mt7qUm3jhIA56hjnjpVXWoraa3OmqXVZgGWCPI3 EfxD3qZRvqZrktczxPPBAltYW8EUSgKqdEyMZJx64JqfXr6D7HDaQNcBrnC3aj5IyBzgHOetZ2Yp ONtD/9L8XrDUlWw+xyRqIxL5vmLxcAhdoG7uMdjWL5eoPfKJpVNtJID5sYLTbe+R0Jr8aaSaR9tK 1h1jppvL6QqJA8cpSMyDa7Ed1rp4hKf9FlcGQOIwZm+XHTJP5/lWiSRDldWObF/HFfzwO27ykJi8 sBldh2P41kX8T36oFb7LN5XnTCZsANzgL6jpTIG2Ooa/cNbW2ozRiGBvKidI/wDlmOmSeTW9O8UT yAurSFAAw+8RVwWpTk2rH//T/DyUJpsVrIInaKVy6KCWZvmwfy5H4V7V8LNHt5vFfh3WsypnVkS3 KxcpLIvlrvGM7edvsSK/JpRvFo+0pt8yR++E1hrE3wn0+9uUsLaKXw4dPilhmCyW0Kbt0hT+9nfg HqfrX89fxMur7/hMPEFvfOZZ11R1eCOQytCoAMTSDsWTafx9q1wkbQaNMQ3zKx5/PeCS3mHlMkli N8kwyoRSOBnp6cfSvUvg3aTzeI9FvX1CSz06a9itZbVYla4keaRdjDPIBZVBI4+alKDUW7nbReup +/Oo2M4+HOjQqmpa5aSWR014YwkF9amFSw8sNkZGBgHPDV+BvxbTX7Lx14rgudRur62/tD/Rbe5g FulsrKG2sQM5BznJ7VpTd6Eb7kTXLXk1sf/U/Nz9mzQZ08Yae2oGHztz3afYrkvHKWMahHTqcLuH oCRX7C/tAXLXfwsfSpLi8MRims5ZXkwMSwFWTA4xk5z2xX5hB+/ZH6HWbjSc/Jnx1+wjaIniGeG4 l+w2dvNJcWt7ZKWluJovlwAeoIwc/X8O2/bql2afFI7TxwT38VtbXV5EXN3K0ZRsr2XDHkcdPpXQ 3pynG21FNn4+vaxq/k3EMjrC22Py1LSr2yor9mP2LvDa6N4Je4s7m5uorxjblFUTXBKJvMe3pjPB /Gso6aESknofM37clwlxJpMdwqCXT9TMhiRRBJApEkal192LjjtXwr4K+x2+q21yfM/dTB3iHLuS 2AoHv2ock00Xy33P/9Xu/wBnKysh8OvEqRXzxvfwpdQ2V0OVFsYl+WTgYOOB15Nflj+1m2qa58Tp 72w1S6bRftE8VzbTxhYIZC2QSw5/vYyTX5dGSex97BW1PlaPRrgOssjYXzeJoQCSoIyOa/TH9iW3 sI9VmnWzmTdcxyandb9qyxRYKqoJ+Vlyuc4JyPSq2dzshFbH0F+2ZLpdlpkUuhqv2Z7qS1imumYh 0fYDMoPPG2VRjqK7D9jy1tZfhtJO8lvpiQxoYizFf7UZ2OZQmMruxJ2xhhXRUleOndEUo/vGl2f5 H1Ffmz0fTGlmEKC+ul2Tt94OMKACeBnP6Gvx3/4KFfGzw3OsWlwaXoN/eaWr2NzPa6oL+e+kiJXa uPlLqQ+eeNq4Nejhfjdzw8RUaif/1v5FvH2tJrk1zdzedZziU7bJlIYISc7h9f5+1fO+qSWq/wCq /cxG58h0J2qW5BJ9MkH86+X20ParVNNTd0BpUvEtrZ4reRY2cSTD5MYIA9DXdai8ttb/AGO9CcIG ROkUjH36Y6U6k/dsjzm9dSeyOpDTYIpmiTD8IAzxqmeAOeuKl8Rafanw/e3FurDU1hWSz8pf3ecj cCo9jWHM73YmoyhZna/DJba/8Q6dbme2t206ySYt5paXzcBQNnJBb5uenFfeUHmXMVjEyyXF0kSW abows6MBt+v49TmuDF13CrFHdRjB0lE//9f+SPwvLqk2s6dLL9kEdttubmS5AV1WMr5boD1w2OB7 11fiBLGzvZV1O9DQQPHdpLbXCtcAE7hwDz0PymvinpZjjui8/wBg1ae41eAmcSRqlpJdEREMg27u f4iMg15740s01bRLy0vEu1VHVYpNOxDOWJ6Mx6pjIIPqa7I7xRpH4z5h1LSYtLvZdOuNQWRHUTQw nAeEkA4bnj/61WdOjt4rGSC4Rnnt5vNmMfz28kJxtU+4Pf8A2vavoYfAZTdrsrJqNr/a17OlrJIJ IVS2VsJuwQNmD2wD+Yr6GtLYXXhLUT9jkiuYrUSWdtaR/JAuFIXjuRnGO5FdWHi6k4047szqTUab l0P/0P46tPS4Phy48ia8SPVGa1w9t5dyrDj5VIwcMDg88g1Rh8OaxdWMNkbrWWktW2pLNDsjvF/i BfhT6ED3ruWBrSS0f3HDPE07u7NWHSLrQbJ206CaN1J3fZ0MlyD0JC9fWsy803UraAQqt60Fy63U oni2zOygt93GT1PQd66YZfW25WY/W4R6nSjQLuVYbhlms9Nu4vPwsJUsSDtEi8beo680tl4avmMs LW80sROIAQpIGOowc/T6Vp/ZlfZxBY+mtLlG48PajZrcz32lTSDT4zJZSxqJZlY5BLKOVGPXsfas jF7HeTXo03E5txbfbJyWjTnLKij09TjrVQymvdRcXcpY6D15tD//0f444dAurqO+1Cys1S9KCESl cea2MKv54+vFdjDpWr3N1b2d1YXkAjtkibZB8krYAyn5V9RHh/HSSlGlK3ezPMea4WN4ymrrzRDe eC9Yt45Gs/MDRXGzz7lBHNEGO44B64Fa9t4auru2caiz3kUakOTGNkvHc9OuOKr/AFdxq2pS+5i/ tfDP7a+8y7bw9LPe3CwmMzRonmKh3SquThSPzqO30XxHJqMlmNND2yzefBeNHiHaNgaNmxgPk52k 8jNS+Hse7ctKX3MP7Wwt7Oa+80rnwPPJdGO/2rbqpD26rvS5zjdlhxjnt19a3X8N32otpvhjTPD2 naNoWn2wCasgS1hnP32TaPmJJwM44rWPCea13yU6Mt7bPQxln2CpLmlNd90f/9L+Rv8A4RS7/tB1 1JLyCAQNLZNAAyxSxnjf6g/1/OceGPEF/FBNYQLNpgd4nmWLYrSDkDf0LdeDX1v+p+cPRYed/wDC zwv7ewCV3Uj96HpoGuK6nWpJn3PuhZcyszKPuyN24Fb8mhTtYRyDS7lopMlCybfPwcEg56V2UOA8 +mlL2D+dk/ubuYT4my6Lt7RfK7PQPBXwf1D4malHoGhotjdhRI8sbrayptGcKT97J4IGT81UPHPw V+InhKBtP8Q6RLp4eJ3tbponMWoor4BcsAVOccEA9OMEVrLgLOfbxoez95+a6ee3Rh/rHhPqzrp+ 4na+u+n+aOI0zwbrdjFHPdxJcp5YWW0WHz7NOCAcnn/64q5/wjSvLtAj8yNTvUR7p4SR90DqBW78 Nc+TV6S/8Cj/AJnD/rXlz+3+DP/T/lJg8P65fXEOk6No8t1dXCOY7h3McCugJIcdegzgcmpL7w2f EthpmnXlgttHYzPLeywIY7qfkfLu7bSpx7E1+nU/DXOptqcEltutT4aXFmCitJX+RSvPhtDZyxSe H9XmkivbpHggnjBmtGIAw5+6wOOv1+lSXPw01y8vIru2vhfWNvF5moFbcRlZBwcHOPTp+FavwrzW /LBr+v8AIyXF+GkveTLGneH9Ri+3TWcaD+y1Wab7TE4EqFgDgdckHirWt+B/PFnqsN09y00ga4iN v5QgG3hY+fXPNRT8K83mubT733t2FLijDJ21Ib7wBrmpWgGm317aW6wBRJHb+Q1vJk/fJBJBAGMY qbTfh7rdlpTJf3bXV0iu2JtzeaxPABPr1rrp+EuZN3qVIpfO/wCSMpcUUH8Kf4H/1P5V9J8A6jse xu2m0q5Cm5kFxCTNkj5UXA+hB6VX/wCFXahcoJ9UutrpeLALhMssqKcqOOnHX61+wR8Jcc0nKok+ qs9P62PzifE9JO6iy/qfw9ltIXtUuQ7MgMM1mftCg9enb0wa0dJ8F6omk2ssO9r1Lhklg2ESKgON zY9QT/3zWsvCfGJWjUT+T36GP+tVFauLL2s+BC+nNDCJYWx5imRC3mMTjj06/Sqdv4AuVUkvI0Fs IQI2URhpAOFbHpt7VUfCrFp3lVX3MmXF1DlsoP7zoJvhbFe6rZW9zfvHbhs3fkoHONuWX/gJ/lUt v8NtCsry5srby5oo1Yh7nKyM2ThsEnDV0/8AEKZ/E63l8P8AwTJcWw25PxP/1f5cLT4dw6PcS2yM l0LiRppruWXzJVLHjoMZx6VVk+FVneXLy3tr9qZJAdMvbw+QLdwQSFdRg56YPr1r9tXhRiW+X2sb ej/rf+uh+V/63UV9lnUQfCzXbGHzrixjEUwM8UkQ+0RRoOu6QdM4yM+tZg8HXd1eWUMVhcEz3Plo 2QYyRx+p/I1UfCWuo/vKqv5Rv+qCXGNO/ux/E2H+G6wXSzXhaOCIsstt5+wlh3HX361Zg8FW1hpl 1fNPvSS5EX2YrslCYJBVvY8H6iuyn4Spxs62v+H/AIIv9b+qhp6nOxaBL5Um+3uWgk3GKR5ORk9B xnA9a29N0CySS3aab7OsTAGBuRLngl36jB75704eEkuZ89ZW9DZ8ZQcVFQ1P/9b+aXU/BMlxbSSC 3iubWSYRssrjbN32gd+lVpfBFtaMkM9t5EbYSaEJw47rz+Ff0HHwlpJ61Xb0Py9cZWWkBLvwJpDf ZrrTmmtpVcoi+SPugcLu4PBAP4Uad8OojHqEl+qtprRiCdAwilmZycMqdTtx15HrWz8JsIpe5VfL 2aX5hHjCcviirlQ/Da1gt5LyPVvOM84h+yf6qe3CgYYHGMHOK2dJ+Fnnok0cl1eK9w0j/bAPs8WA MIjcD+tZvwlwt9KsvuRL4sqP7CLtl4KtNRuYt9vBssLpjDHKVDOyDkdc8A1k6l8O9Hm+1TyNAcsv 2e1eMeTLKWx836/jipfhVgkv4j+5ER4rrp35Uf/X/mSHhjw5ZyNZ6kscAEAMJkTEKEcsN3bOKqX3 g6C/u21KGO1sLC4sVNt9jYtbXOwYTeOSGbAPXHPoa/oD/iF+FitJv7v+CfmMOLq0lZxRu6b8O9Nm sIb2+nIvmcxS20TN9mkjxwee/UdK0LrwhEVFppkYlkhhYwQoMeaFXJTce/HAqP8AiGWFW039xf8A rTVfRGt4c0+0Fo1rqdkplMR2IgBaOQjC5PcAjp7Vzmo+DrGGW5vLyZrYKvkeWWMblmPBx/KnLw4w qpqEXrrd2No8TVXG+mhqW/hrR20ueCC3ZpDEoinlYu0ZBBOM+uKpWnhKJchpkiVvusF+97e1cy8P Kd/Zu1l+JvLiNylFn//Q/m7uPCkVtLCIpPLdCWjkMg8tiOTz0NWbjSLG/tVjazByNry7du7HUZ9K /o7/AIhtgJUFdWn87fmfktbiTEfWXBP3UcreeDYYv9Je3BeYmNATynXp/dpbrwN4dvY4IbS3vVj8 0SXltNdi4inOBux8oIBOTj371jPw2wFrr9f/AJIqnxHXu4t/l/kaVl4UtrSCeZYJI441/c25iYMA OAB37dKvWGgR36SqiJHPZZkdFXMsKt/E3tWNTw2wsknF7eT/AMzop8RVkrGXZeEbO5N/JFNF5qOI pImy454yo6fhWm3w00a7lQGRBLcRoXkhP2aSBhx8xA5x+NE/DzCwcOX0f3+prS4gqzlJM//R/myt vh7Dbaj51zqckyWsBVISwaOVgcZIA649Kvz+DreSc3WWtreFvMWOCQ5dsH5ShPKn36V/ROI4Bw0+ VUdF5/P+v1PznA5/Vg5qTMX/AIRfSp7i4e7mnhYMGikYb4owRtKhffAPfkmsWDwa15ex2puLZI4J vMimNudpUkZMmOa6KfAOXYeCpxjzaXd/07Hj4rP6+LfNJ7PQ76bQRpaXelz61BfNlfIW0t2SHaRx kk8ge9Vx4K06OVJVmke42gSRgAQoefums/8AUHATUI1Keid3vr077bP5HfHO61NSUXvcrw/D2wu7 fUJbia6g1DTL9oUtpkMSXAYA5B7gZ/TrnNUbjwTDaRv9vnj3rLH5FmsPmiVTyCz8rhTtIx6+1Otw Jl9Wm6UKaW1nbVeXfr3XTsc1POq9KopuWn5n/9L+a5vB8d6iW0626wlwViuGCRSEcg/p3qabwnpx uRK1mkLC1W2bE7LHKwz8wAPU1/Rc+BstrUpUlRSut0rNPvprofk0s6r06qnzv9P8irB4Mg0nzrmO 3ZbafcCZAZo3ZuWIJzz9KrHw88wLRxKIlOFDJjf9Kzo8A4DD4blnBOT6tJ29LlvPa9Ws0n7qRZuP CL3OnO8ktvB9lcE27PtnPbIHQ9fXiucn8C2e57c3N3DK+J3G/wCUrjhdvof61phOBcvpU7yp3k2r v06W2XX7yambVqkrt6L9ToNG+HtvrE/l/b002eNAYZZm2xShT8yAHI3EZ6+nWq2q/D+2ikvbiO7u mnt18u2jVsRSA/eIA79+c9aupwXlc6vI6MeTl5bWXon3vbS+/ma08zxDhdTd73/4Hof/0/5nYvBl vPY21rqciny490cptw3zDOAenP0psPgi9t2SdGPlOpVDs2RkL0P9K/f8fwBhasOfCwUaib9Gn0sv lbsu5+c4fM5qXvu6L9t4beAQzxCOSeUFLyGQEMy57e//ANerbfD611i6Wa4is4Rbxl1+1DOenC8H njNLGcCYSvh3KFK1Va2T+TV3/wADVI2hmlSEmnK69B0vgXT/ADXWNI5YYVy6RgIvYZPHf3ptz4Sj ttHa5kFkwWcRWltGPOvIun7wrjgdec9q87/UZ0qLgqTcn0uvx6Hoyzt06fO2rbambF4a06eM29xJ KuQCZEwx34HUjHGR2p114QsZEeG9tVeGJRLHvQKgI/iq6HAOFw+EXNF+0e/X9OxjTzydZLltyn// 1P5vrfwvol5p0kUpubYSwmITWjDLDHTB6D6GuXn8CW13cMJxHNANu3eBAEEY4x23cfjX7cuAoKXt acb33u7a/wDDeZ8Hic8tPlbsN1HwIl0sNrbO1uhYbtqgSyDtz3rWuPBIayM8EsCXMUYjggmV2eU9 CS2MDNVU4FUYRqwhFyutHe2/Xvfr+DOVZ7+9cHJ28rGTeeEo1gtreHety8m+5OP3We+O/T1qs/hC +s5B9ieNrV/ml8xW35xzivSzTgrB4imuSmlJa/o9d7W7dUjZZ3WVFTm9Fp59/wAx0Xhn7FeXF/LO xjeyEMSrkKkm4sTg/gMj0py6LLPHNGyTlZxteQqQSCMcH0xXzFfw6qVakfY8qit03LXyWnkx0uI4 RvCab7aL/M//1f5ok8GyRT7PtBAiX5HjIZZARxn6fX1pj+HNV0lYriKxXW7kvvtYEA8xGBwGCgk8 eh7Gv1Op4dSvol97/wDkX+Z8P/rEoRu/6/EzpNCudecJFE8WuXF1/p0bfuliU9cEDqDu9BWnb+E7 uC+abchQwCxn8zB8nIYb1x1OMjj25rJ+HdXZb+r/APkClxPTnp+n/BKepeGodInSKxM+oiWVj9p2 +XGhHzZI7Z7Vfl0w3tlbYtWW4hDAsq7+TwWz249KS8PJprn29b/+2IUuJYR0T/D/AIJAPCNxJAft GBbyQMlxvG1rhfUEHjoaz4fB+/zILZ5Y4SFJWE7WATnAPvj9aqn4e1G2mr/N6f8Akpf9uKpFSi7W 8v8Agn//1v5pm02wVRZk24ndPljkALrtPBHfis7U7CWGO0jZBOyyrHHKy/MCQR8v1yeK/Rf9QHtZ /f8A/anwv+sSl1/D/gkyaJeLdoxtdgEOxI2ypL9M8ng1kz/De7eWW7meSS/jywIlIMgY7thXO0dc cVMvD1u907+v/AJlxBFO9/w/4Jtw+D7z/SHvITFZQ/LBbovtyCSc/wCFV4/CP2+3nhRJDLgt+5XD 4XjJ9en5Vl/xD9xavf7/APgC/wBYIvT9P+CZ0nhS5nUW9oZGmtx8wKncirxjHWq+leDbuCG4kmtp lmnkfLzcH269uOKh8BzenJ8+Z/8AyJus7i7Xf4f8E//X/mHTQLqytPJWMFZyzX779rFQDg8deQvH pUltoH2uCeNfMchfLl3ggbDwAD9CelfbPgKqviT+/wD4H6nyEM8pqSX6D5vDSRtaraPOzwLtWNhl RgDHOfatNNI1O7lt01CNkLjLuCHYKOAD74xXFPgnEc3Kn+H9f1qddLOafNcybvwPNFcPPaSXAWNu F4KSZzgMP8Kl/wCEeu32XlzLcyGzTyzFKNofHAB9h6Vi+E5qOs/wOiWYpz0RnXfhyXVFzE7K0bZ2 umIwTxgHqeBU8Xge90y1GoWtjaNJagvaifrO/cEYOB7nipXCGInezulrs/8AIcs0hfVH/9D+ZDUf Dray8DaqWsInCtLa6egEGcAYA4/zmsw+G5NBSex0qQyWsjLKBOhTDY6HBJxknoe9e++EsVvFpv5/ 5Hhf2pSvqV7vw4kNwJzbRzyyhXlMR/dEkA/MO+OnPpV6bSbLUdLjt5ogskFwJrcv8hUrxsHsaxnw njUtkH9p0e5WtdPWKOYiOMyNKU2xHIQ+h78e9XF8Mpa3NrcOrSPOrDc4IVDwcED9PpWP+quOXQ0W Z0GrXKVzpVy0Z835reKYyx5jyinoGB/CqVtZ6h9pyF+WI5xsDxyrjjr0/H0qXwzjrfD+KH/aNDv+ DP/R/lzjsDaorXiKXnuCilAcHJO38cCuiGgala26tJA7xTYkiiRwWkHrtz6GvRnw7jbKbg/zPGjj qDnKPMZF1DeAGOazeKE8LIV2hccYx/WkW0ktoI47e4k8yIb/ADsZduvH4VisixcX8D+4tYyje/Mi iltfXF5HZ3K/6GUab7Qfnl3AHjH1x+dSJp86T+bdmZbNBsVo4cmU+pB/Dp61nLJManpTf3HRDGUf 5195E9m09zLbNaSoGQtFcEYjPPH496gXTrq2mbbvf5NuwjAbHvUrJMev+Xb+5i+t0H9pH//S/l7h ihubMSQIY4wPLm+cSfOM5PHaqMWgNc4u440CgkPhjkgd+K0eTY9f8u39zPPWKoL7SC7tp5gsNkd9 yjBsHABAzlR70u6OxVIbyZzK6knMeSDzwQO3aj+xse1/Df3Mv65RX2kc9pGkyNfalJJaJJiEi3a6 X7pbnfH9K0HsZLS2hhuCtxPEfNS4kQLsY5HQfXFQ8lxlv4cvuM3iqN9JIZpSXDSXYuwGuYxu2wjK lD0x+VRzLZ/axK9qXngXMSTIY2+b0z64pxyrE7cj+4l4in8XMj//0/5TopZru8kuFso7eJR5M2wF G3jj7p6ipro31ti2SMNby8mVUy6k9qtZTjNvZy+5nnrE0usl95mWpubKW42xl/s8fmIg4kfPbFWL CDVBJ57NLItx+8eFmULAfReORjrms/qNZOzizX2kO5eGhx3y3aITb3UoVhJnavByfbIrJFvcPc/Y mDrKg6GPaJAONwPTFbRwVXblY+aPctxWU6XDwvtSDA6nq1WrmxaNBCFDyFh0bAQdyfwqpYCrHVxZ dOpHZH//1P5Mb+11CCaJ1tZxYCQq9yEyjHjg+lWbJLi0uL6S5CmedFSGR/vAD7v6YFOWGqJ2SJUo vqSG1W6jYSFvtTyfNt6sPrUFrGJppUkIeG3JiWILjLd9x9qlYara1jOVWK6ixWqWs8ixqluPvDau Ac81EL9vtE4ILWsLKbhDlUlA5NL6rVStYzdVPqTrepaPuv7WWG3uF32U3ktsyThQD3HbNacaw6kp jVh5efnOOnvWSoVEnGzG5xP/1f5U0sBpUdxLNIWspFwlwygsrcDbj0yRz2zUPkSPPEZj5kMXzQhh /q27muKNCrzPQ5FUixmoWzyqTArugxuI+UqSeKyxctaPuuBkt8mSMsB7U/ZTWtjeM42sX2dpwrQZ dV5bPynBqgy3qzfupVMY+8mzczewqXCp0RtGcVGxStNUSXUkiZpIFhnKXKvFhsAEcfzFXj/aN3Ki 2vl3EpujsQt5ZZBnCg+w/lQqdXsKU4vRH//W/lLtrWK6QGVmifnarDGCODx+Fc1dQTxSM5k2pG5O 1Bw4zxxXNKE+XYabWw77U0o3EAlRtYjqKbDCIS4WMGGY7pFYZVm9ay5JLoPmfU37C2AWTyCFLfvJ NzYBIGP6CsmT7XJdO7TpsSbO5DuLAYyD79RmnyStcUmmy1cCHyri7uWkjJwIhGNwkbIGW7+vSr1p Mqxg7G4UYJ4/Sp5X1Qj/1/5P7nUBK7rnzGiTlc7WXNVYbVHidreS6k53yeauBGePlB9q8+MXrYG7 ItW0RI819oMZ6ZwaS3RpZLkypJGucqY3xvGc/wBKbpO9yFO5djvmu5bhfJWMxoscUuzy95A5z78C suWz1q0hfUoZzcSxyg2yu4Hf7gwOg56+vWueUGlqUpJmlcO97a/b7qwntruJEjKpmTzjuwzN6dc/ Sr6W9xKkbLNsDEBlYkBx359aFGVthn//0P5b7eE242RAxpu+cAcVYv54LdrS33OZtWP2WKRYjKIW AJBwPpXmqGgGRNa30FyLVuZsHeccqF9fT/69D5ZooHXe8fKyMPu/55qfZJbFOTIlE1sboXCF4oxv QdGOecKO9TG5s2+yrJ56rKo8yMrslix2569qtRSJJbu3hhtyJXYI5BQOcOB24p4sjOgaJsebjgfe qrGNm2f/0f5eLrTb7TbUXO1JIv4UjkDTY/vFeoomFyy26SxoIiMiQDgn6/jXnWViJNpeZC9ojTbk fFzDwiA4WTr1P+eta9yVs4gJnjEioC8ivuCZGcE+2cUr8qvYzT1VzmbjUVvbuDzY1EsMflQPFw04 zySPyrrLMWgiZw8kc6AYh2jb9c/hRFp3aHJtuwafLbrM9wZnWRH2KoJQI3v61avoXv1kYNuuVBMe D94+h9qHFMuDex//0v5h7K2FvIkd3JFNJdIHuIIvmaIAkBWJGMnHatSKKOSX96hfyZAwgdTsA7e9 eTyvojO757DbuaKWeS3eV44Hj2Mq8iLOev1qBsW32eCSVrp/K3BnjwsYBwBnpnjNTyWd7GhYt75W VYZI3lkdzHFGqn5iOeO1aUxnghZUieRyQscEYy5JIA/n+GKco6AXH/0aIQ+SWvCv3mU7Yexqlby3 lqG8+VJW3F1kAw5781lZX5egpNpH/9P+aC0u9Sm1HfdeWLN2xlBuMeM/Mf8AAVpXDbHkWFvPy5ZS RhjzXhqyTF0KBSXVZILl72cPbkQTWLQKIoQvGFPXrzmtsWsDXUcrNLG9vHhFjHyyZ42kenvUJ2BK 25Ykk88eSTwjZ246VTljkkd4jHLCItpR+FEuRkEe1c7dzePwjxHsuBPExjmCbJQR98e561tCKO9k VIkKOib5J8cHn7v1qnJdEUf/1P52rfTriWTDINifcLDrVqdGs4mmYhEUcAcdO1fMbs6Bkd8l0kc0 jOSqiNNxztA7Z9Kv3ktvc2w8y5KmBcou3cH/ANkelKKjd3RnM5FIm1W8RcyRW1q3mMGUqrEdO3Nd ARayqmQUeFsPnGCOxq0k17qMx10lrnz4WcBlCszcKwHtVYzuIJIo7oxoSuH24JYnAUfiaicUrWQ7 6Wuf/9X8Do9D1fTrKyu7+SBWul/dBZFYTKAMng+4rOvHmibbZWsNwGOJTLIYREOMkYU5+lfLez93 RBsVmuBArpFEC+4SF9vzgjt/n0q61zHfRKWASULkgHaG+tZckjSG4xnW08nziwErbYwqllz746fj Vv8AtCAjKlX427/4R24NHJIptJEdvvBDGXc8jlxjgEZ4H8qmu1mEW8p5Shs5xndQ4NamV2f/1vwC 81YY4pZsm3ZsTbB8+B1wKZFc2lzNIIJQmmSMfslsFEciAk49eRXxc49jdbEl1GlrFGbdIr3DZlST OE7YP/66u2cS3Hk/P5UmfmP/ACziHFZtdyrvYvTCbCIJmba3zHGN3vWKsl9B9rdSk5ib9zGSUDez UNdw5n3NAapLJCzvAqyuAu2NQqr/AJxTzDICgZwry8c8YNKyNz//1/wcFm9uscsk8TPIxCx5+dce o981Lcl5xGHwEj4k4+8BXwyVj0CuLkO7hUcIg2b8dKkjxKjqjoFPy5NMDOu7Ty7iFYlkvjgtK8T4 jt19SK6OO8mubVI7a8WyMMPkvEsK5mXpz780DV+hloi225CymRzjeerfWr0fO+RhiXbtGeQAKfLp ewXZ/9D8IjEJo8Z39twHCnpUcUU1ssj3SCNVjzEzn/WL7f57V8SoQtqeg33GLPFCPtEdzO8Fwv76 GTasEeMD5e/bPNbFtpccqM1vKEeRPMXI3ZAGcYqHGNw8itM6qyxq6qxXaBwDkUzTLd4VmE4DeZIX Mmfn9KznBXSE3ZXJC8qpMUMcksbZjBO0sKj2TXpWSSdoike1oQflPrz1rPlV9gW2p//R/DGGNbVo g2WDndtbmp9SVpkdUHl28zAzKo+8O4r87aV9D0DI1KYssFrH+9heRY1iC/OB24rZggms4w6xjy9m XDffPTpSpqLT0M6i99jUZ7iCVxJiCTIKbueOxHpUH2VLex37jLM0586IfLiPjaR79fyrthFIm7SV mPmRr9J4rISWzJbeYX6h9vUfXjNUheSxtb+aEnlRlRVk4WQA9Py7UuVbWE79T//S/FrUILW4to3i t7WxWbAzGxCueASck471yV1azW+oCKGWO58khfMhYtD+B4zXxijG1rG02y1cSG3VDMEWSU9P71SW xhnn3MqQlo9nmqm4jH97v+VRKkuV3X9a/wCRrdrS41IRdk2xdSWfYCzbUX3J7etWdMEkjX9hdssB tYcxXKSgI456E+mK4Kcby0RSVkrsqRxXEro8E4e1aMozlRlmB+8D9O1TxXK2g3yD7p2mRRzUYqCj CzQRb5mf/9P8UNNjtvtJvooo3LfM8cq4WTA43dCaxtQvoZrmYRiZLkHbLsVhFs7c9K/LYxSbUTtn zKDHQzyWyGWUqINvyyu3f6e1TwX63OyElSI38wTdGPbBHp1/Otox5W12NabeiOqma0jtAfJtpxOA GmLEXEJHPyjPv3rmlsJtQv4bazjVJHb75+8xPAGP5VTT5feRq79DStHMM0ougyz2bG28l1I+Ycbs e39arzPDarcAL5k1y/mMzE5B55rakm4NNHSrKlof/9T8U4IT/ZVl5ki27yzm5aCGUbJTuK75FByC AGAB7H8Tr6hPE9tFp67C0iF43SPY2ARnJr83jFJ2a7Hs03p/XczLWG0guQQfKeNBvUE/OR3qo0lx cX6tcRsIllIUxrvbGeD+XrVVIxv/AF3NHdL5mg1zDaCWVreRix2INhMjdufaq8OoqzoHIiOcbSOP zqPZR5b9TKbk42juF5d3ASO9Rbm5gtJguyBN/wB49x+dXr2WC+s5ZynkxI3meX/GoHI49qJ0ouLa Cd402z//1fxMsJrxLlBpz3kUs4wk3lkBTzkrV6Sa6FwI5pJBtUksVyrH+8T+f51+YxhFUH2Pdi5P CpoqtNFDJHdmZmdXC7voetbDym/vfNlugcxDaoGFQnqaHSjGP9eRyqbSUfMiuHuZFig84yJBKXDD jrx/n6ViPEPtk0s8ZkbA8uZzheT0odKPLczqVLs6iwEc9tKNgby0+dB1x0zWedSdLjY4CWYjESDb llwe1NxhGHMdGHk3USR//9b8avNhvRHHbs8McFxueTO7cvHJXsa13+y71UNvgIyGPY+9flmFpRtO /c+rnyqjyvchuryGwJ5BUrwx6CshxdTXCs4Zo3G7JXaAOtdLpxSTOWLaco+hZGotZiOOFZFR38qX LbFbsOO44q1DeL+9gjdY5GUtzyCeSeKVoMcvc6lXRZLO9dYvNnTVYZiWQBVimA6A55HQ9Pbmrtlf Nd6tC9y7eXDOYpY5FIUgAhQvt0rCUY9EJPmR/9f8idUZtOVZGQRrcOfKbs/Paqun3F41w1wIAY4g Bu2/Lk9M/ka/KmtNj6H2utkxZrGa8gMbACaK6N2scJ2swHTd09akVYrSCSJ413ysHkb7zHjHX/PS ueWi2E5tmHqOrz/6MsaqLO3cxo0a7pd5IyD37DA7c1v28cv2VMsVnZi/PoelZRk29vx/4BPM+xm3 B1GBZZZWSIXU3kMwYMWCkEH9OoqIagq3nlosbW+AJyw3EHvj0z/WtE1bYdz/0Px0ea0mvEjjxuUb 9jZC4/z/ACqa4UXCC1FuVjdtiuSFT8ew61+QXj2PodVqX4IfIlFvHJGVWLDbXBUe2Ku2+slW+yal aSxRW3KXlvGZPPTJPzDPUdOOooVuqHCp3NObV7bUtLv7GK0idbmDyEZyRNMre3b8Oa420uLJbv7H Osgs3QQlMbwhUY/nUy7JGvN2R0SpDDCf3sIiJ8u2iHVPeq0wvntxieHzFO1ZTHk7B/D/ACGazt0s LnlfY//R/H+6iMc6sh2kKDIvcVJ58t3Zi3itHM3mbAWbahHPzZ9K/GbpdD6f2s10M+8lltPlkkIn WMRqofev0q/JqkcIsblpF82WH99COXiIOOfrWnPEiU5roSNqEsrfu7uS0edfK3RfcZT61k3lrHZP I0s0k8dw3lxnGFlI7KPx5ovFFwnJlnyNQ8yKO2kVYQytIJxgBB1A9DTlmzerEU3q7+WjDmNPdj2p e0jszeKdtD//0vyWlshHaxOl3EQ9wyXMUfOFUKc7+gOT0/2a5+a3Md15UMjwTsQ8MpADEHG1vx4r 8c5os+p96DNHW2uw+nQzQGaKTAuLu3kxONvXJ6etZWtf8e0sdjKqRNMrAzRh7nCnuegzx0qLx7G8 JdStY37RQs05YttxG235D2rTkvLWWWARlvkiWQuw2IzEfMM/WraitGOdS2xLJbDUbkG6vRHHGvEK gMsmeAD6fWot0en37WttMzWiQjbIoIVmP3l+g6UcsXsYPEyT2P/T/HIXNzPMws5gIGDR3I3FWPp/ Loap3FzMtgtpPdSlI5j5ZRzkE8cfp+Vfjcodj6+nXclsa2ngwIqPFJ9sWIbJ5F2lweQW96jumkhs JXmbc0km0kAlVY8dalRbRoptbkem2cMNxc2TyRm4+yR3UeDkL5g3AE/TP5VmatLqBW2sIFhtUFwD qGoIpeUxZ5UD35HHrTUJPQ0jWs9UbFtpi/2e1tEoRWlM0kuOZBjAz+A7etULW6gguWh8gyJt8tIl faVcDGc+mRnFV7GZXt12P//U/IWCbZFm5BguVJzACGQDtzVW91aX7M7liUZDE0G0bVA7g+9fj0aE r6n20sVCPQ5j7bA9gVgiFvICBGkR3GXnoc/09Kjg8/yZNQ+1IPKIRbYuPMkJ9B9K29jMwljop2sJ JqgkixHAzrGd5jPO1uuV+prZ0bULm4jbULqGHT7iD91HD54m3oQQW5A5POQPWl7Kdg+tQ7GDdahY yXk62W6NSM+Xu3eV6kDsM1PY2mn6lFGy6lNcTNmPdIgjjtiD2/8Ar1HJK+xqqsbH/9X8WxbafcTv Haz/APHufKlLHauR1x61ZijjiuEZZUcRdMdOK/IpUdj7Fyi3uPuLmK3kkvJpSruf3QjTJZiec46D 3rMOqWwy7Hhm2qxBy7HtR7PS1yoxg1uUBJALgr5MTTuCybhy2evFSzuupWclnJBHFKRsW4iBEsQ7 4o5EluTLkj1JJp4oI4IvLN0tpAYolJIJ4OMkc9eawrS4imN3cX4NrtO2HYmTgdc5P5VUOVdTKVWC 0TP/1vw4tJ0kb7PNOZ/KQtbrL95QT2HbvX6N/sz/AAg0TxFcaXqt14y063t7GeOOTT45Y4pY5JMs 5mLkYAwAjA4yTz0r8m9orNH10Ksb3P1oS48M3Gkat4eE8N+tlpzafBatqMKS427UmdgwVVZgDkHj mvw3/aO+FV14L8Z3PinTYfsza6z2t8lxMk9peOoKh0bLLlUCjPQiQemamjioRbibykpNM+Q7kNbG 5tS0U6B/3m1w6lu4z09Rmu+8D68NI1XQtTnixHYX0F8tu5/dzvA4dUYjnadp/MVftoyTSOym0knc /cH4bfGvSfjF8PdJEE82kTSMwjzEYpkuH+Qq38SuAq4LDoPbn4Y8b/stfEa91TW5Jri8v9Ju76a9 vLuWAmTkkjaOAQM4DZ4HYdKzw+IhOjGSWn+TsdFShas1f+rH/9f57+CHwM8SeAfiHbeJdS0nzTE0 Eml2d0rR27whf3jSk4AZudoGegJ9B6/+1P8AHvQdK8M6Z4Ut0u7bX71ZobxY4vPWzEgMe1QATgDB LsMYI96/LqervE/SKlDmhytngf7GXxH8O6Df6hpfiK9u/wC1YAb7SoVVUVk3quzeOucvx/tewFe/ /tI6DL8RYVk029vL2QWexPPgeG2t3bdsdV5yUVuuOq++a6oxvdJ6nLUw7UU76H5q2/wM8c2s8dvr s1/e6gHxC+hWLyWkyqc7ppnVdhIA6DHXnvX6ufs8ajb/AA38Mabovin7X4PlbzL6zumiF3KPOwDL Mc/xhVIA4Gaz9lMxdB9GfA37UfijSPG/jCSfTdVm1ezsftMDX0sPkrqLeaAshj5IICE+2TXx5oF1 DZ3wv0gkIe6FuhkXn5JB8yr3I+8B34odGa3NFTb1Wx//0O5/ZzvfCusfD43elajDrmkQLNtt2Zbb V4N0a5WSPOQA42kZIBQ+tfDvj34b694u+JEujLbW9rFdNLNBHKyy2d7LJISkZU8syjJCjqT1Nflq hNSskfoEabjvf7ir4+/ZmbwjpB1QnToRaxLNfPPdpp0AO3kRQsRyOh4y2Rj39Z/YXk8OW0mpaVqS 3Q1Jrh5H2xxvpU8f3WkkkZgVQZiwQOuRjvRJuFrrQ2jzXtv8juf2yI7vULGS10PSbm5tbSVLBJmb cIMbna4Q9CpeXtnhgegr5T+CX7V+pfDbRLyPXNC03xE+kRC3s45rgwHMblVjMWQoPPJPpniumN5L VHLKs6TckdT8X/27PFHjLR9P0XTPAS6Ai2zLZXqan5Vqs0jAvvILbsLnHpnivyK+JmqT6xfapqmp Xs0txqk7+YUb7X9mlJO4KT0X29hXo0m4tKx49WpGV0f/0f44/H+pXtj4j1OaJFvNOWD7Aks5+z3k Tbdjfuv7oz6njBrwLUL2ea4kikWIRllcgEMBjGD9a+QdXl0sd9eojodP1C8+0KjTwHT4LfcrMpW4 B7YPp9eldHc6xcS21oot2vNsoWQs+0sM8N+FTKqnokcV3KWx1mhC6vlBu7zywk52We4ptUgcjt/k 1rHzNIuwh1GS4S4O+BZW3hOuUB7Vk6tnaw2pN2sel/DYaPFrwvEtY4tYuI/K3iIFnjjIcMrdCQeo PY19z2SmOCzvjLLeakyebJDF+/kd8/JjH3ieDgdK8/FVE6uvQ9LCUXUsk9j/0v49fD0EkXxDsbC4 vbW+s4rCO6uxqsr2yyQSuu6OJgcbwATg4+5XsHjC28MjUrx9NtLS7W+liIaNS8kaKAqhSewwMk5P HWvjpweisJO0jA1ZYZbdbOWPdBkOHBPyt0AAHp6+9VPEmmtJ4buLz7a1vFbWzBdgLTSMoGMJ1/HF dUY25WzaMvev5Hybflr+VJ57Yx3Eqq+XjxMwHClu/arGlppv2+7t72/lsp5bMJbKyE2xbcM+Z3xg Hp0r26b9w5Ks7p2IbeyluNSZYTDJBBJgSq2Vb6cf5zX1t8KoLdri0s7/AFGYRXUf76GMByhHCEqf 4R1JPavZyRRqZthqc/hc4p+jkjzswqyjl9Vx3UX+R//T/mwOi2N/caXFqFssaSTfYYpLS0UxlQCQ cAYz159+5qh/ZVpZ3lnpbJKILC5a4BCgsS2B908EjAIr+68NkuDeHjHkVrW2VtbH8y1MdXUnNyd7 l+y8F6KBdX179rJjZzaMm2EE8kMwxjAyPlqGbwpGtppN4IYbrzblnjkjuAH2rxudOwB6Dv6VK4ew EFzxpxUnu7JbbB/aeKa5HN2XmWNS0bTtVh8i+giKxMDmBFgKnPXKj2+lYsHhiz02Se7hnmljU7YV wNpUdM+/+FayybC7tL7iVjq62ZatdPtILO9ub2L7VLd3ZlaKVt5lTaBsx9R0qabQfBmuT2tlp10b G4TTJJ5bGWwOIZAMnDHqD0zz16cYrN5PhLW5V9xpHMK6d7s//9T+Y630xNKkghh0xVhGTPKwDo7q cqQPfP6VvQ39pdatpWoahokcttp11HbixcFjMgbG8kc4G4sB0GK/upZXQjHljFJeh/NDx1W95PUS /wBKstT1W/gtZCtm9750EjDYiR7uUVevIxz2zV+10/RlxbQxWvkiUxPEY9kLMDyG/wAaayqj2Nfr s+7M+Twvpdlfi5ihUzXZK3CWrDLc9hWhp9lprafLaWf22W4N15k9tKnlogxgOQec4zye1OOV0IX5 UKWNm9WyL+xXSSeeCOKa2iYq0M/7wqGB4Ht71WsLGC9MFl/Z4hvopXka5V23yI23YpHTA5/76qf7 PpRewvrcmtGf/9X+b9gLWS4tns7HzJYmh826jULg8MUYjhsdDWBGt/DBaQW1rGbOK+Z7iGEfKRyA Rjp2yfev7tWDprSyP5shiJvqdVqmiw281hJdW7PKqpcRWQCvATKoKswHXAPfjn2FQT6NfalcgwRw PaQBTcLG+1kHfC9/T/Cq+rQT0RXt5330KQ1PUdA1GCXQbn+zrmCdHEsMYZ4tjA5XuGBAIPUV6Lr3 izXPE0Ed5q/iDUNXkurYWeb+48zaqghsL0BO5s47kmn9Wp8vNyK6D6zUUXSUnyvdd7dzi3WKOaHT 7UDyEgBkZvvKOgGPY1PEtvb3tzo7Cyju4oxKsxVBLclgCqiTr6cZ71rGjFrYyc3e5//W/nY0jVbV NNRPIaC8W+mBvI5Nslsv3DjGMg7c5rItNIs55porlpIrSQuxuUwJW3E5Nf3q6MUlZH81qb6kEdlp 9hZy6dKhmGBDDegYmdV4UketSWFtFpk32eaWR45SvlxKuCrE4G71JqVRXNZIqNSx2+o2kVvZS28N kJriQCWVpRtbp0zj9Kp2o03UNOt9PksbVLqP94yRgl48HkbuODkdv610ewgtLFe1ZYlFzZGMRRxi 0SXfNbsMI/8Aj+NUbzy57dZEtWWMvn5W5TGcY7/hUezilZo0jWe5/9f+dq10zWr+11DUECSW6TqF a6ZY5YsKFOW5YjuOKxlgu9Pkt4N0t8LvUBIYZZAsEA4Xhuw6/wCPp/e8qavex/Okqxfu0i0+5kuE tvNh3GOZIyX8ot8uVxngE5/CremBp7O3haNrKeVy/mbdszrnvn2H5GqVO/Q5Z1HYfr11KgjtnEhV cDei5UADA5qtBdpNYyWRB+zhtwlRB5rucck9eMDHpWbpxasc6n3N7R2t/tCme3gS5MRK6jFk+cVw AJB2bnt15NZeq6DIZnjuPlmnG9pBJ5RxyRyT7UKlBdC4z1dj/9D+drRrLyrWKz1W3hk1C4jeQRqh niIVsAh8em3g9zWvdRWN/pkNjCDby290TK9vJgAj+EjtX98+ySWiP5gu7jTZ6wwkt4J/s0N0oh3G 48mOVehyOnHPWq1ppl5aTyJFNHNDC2UuAwZ4nBwwDDgjjIIpcluhaV0htzbNd3QaZ/OHl7YivKk+ p/lVaa08uCR9SfyLRDsLSDaqc4H59qcVFbo7VTvGxkx2kw1R/JgupLKe3UwO8DeUFAPKDtnHX9au WNraapPeJ/Zd3FFbARO/lnG4ceYM/wAJIJq7pK6Q1SV9T//R/AOytYBbrZu8D7XHlxnrx93r3FUJ 4INSjuUikfzLeUxK2OhXH3fUdq/vvm7I/nSNKKTOZ+2XNqzQ3NuxhsQZTKsZbec4x9eK6Wdo7qGO RC6K8QYjbtIyBkVSbtqPkTdjlbjThAQQ8ku9+Ceimuns7nULTS/7Ma7nEZmN2kQkDQ4YDgL69Rn3 NZClDTQ5hdEhv797uSSdpYEZEhSUpGrNjLEd+1XdPtdQhuZZLsq1rC6/ZQUy+V65/SodOL6Gd3sf /9L+d/UILK4vp/P02GaCS0QCaYB03Zyw2fh+RqrcnY0MARPs0MeIbGJQI2XGBx2xjiv7u5I9j+ca badhXlnut4QYhsLTzXjVQGVAeWOOp5rZ05rEeULNnJKiRQ5zIOMn+tc86aejOmMuXQrzG0lhi1aO 4Yyz3T27WcIzIoQAb2A6DJ4HfFQrYy3l7ZrLIZlmuN0qTDBZW6de44rOVJcptCasb8Wl2umm8R5N vl/P5UjjEY5Hf/PFY7LHO5UumAf3aqeSB6Vi6KU7s6edcsUf/9P+dm+t5rVF2AF1fzB5xLIq55x+ tO0vUrfXJJLJF+zm0JhYwsRg45wPy9etf3O1aNj+eJO1cu3NhZRfZoXvrm48+T7PciSPItgMbXDD rnJ+hFZUdobLUL/7Gst3FA/+j8FfNUKDnB/GsErGkVqzto9ZvbXSfsf/ABLrq4mIkSaSBJLi1QnO zdjtzwa5fSdYvo7+7neyhWWdGtZ5SAjuhz/Dj/Oankbd0axlZo1boWEbLcZt4iqgzww7vMkIGNzD pzxwPQcVVE0+m65Ff29uJhJb+W4uF3W6qcn7h/iyf5U/ZJ8tzSE7SlY//9T+em0hu7q8llWFlgjk LNK6EQAnnANXb9hHJDcF3dSGBEY3Rn3IGfSv7jdGLR+EUpuNRnIXMtjPDa3MbXizz3bCe18gHgEb T34POfT2q7LexW9pcQW8PlPPgPNKhWUbc9PzrOpT5ZWOFT5YNtdToNPSK+sopZlj86FNsk5Gc4qp Z3X+lyxLtj/dFwZk3DjsDjrx2qUv3iXT/hz04Tp8qbLsuoI9zFE7SKtygMl03zqR0AA65HpS/ZJJ ZFSV4zbRRAW7k/vC24n5h6fjTqRgkmtzDeVuh//V/n51KwFzBLbHb88f31A3KRzlf8965a4025u7 yHFw5jijVI1kbCDZndz69MD2r+2bxjVco7M/CasVKPL1RcvjcNbmEMQ0J+VSflJ4B4/z0rRsIVuG jibdHHGgdpCuVz+H0rOvaMIpmWE1q1PQybuKfULi4gmRFjR9rSFSpnAPGP51b1KO2uL20uVgPmrb rbTCIYRxGuAze/H404csUr+ZV20/66mW9/bQahGixSGMLlJAv7tGHHXt1x+ddDbbLidJZY3ySB5b 5Ct6cVgklU5v63Z1UG+VI//W/nq1W7urO4n0WbSZ4prdxODJH+7lUqMFD04z+tPsIZ2BRWJaQfJH K2FQ/wBOtf2vBrmXax+KJzT02GOLxPJvY7cLcW7YaFUBMmDjJ9ajvL+8uJ4otOt45nk/17NJ5McA IPPTkjjj9ax91y5bf1c1lOepZsZWsrWaSQRG8uEaCdym5CpGBjPcZ4rnNTaZGjt7f5o8LK7buWzw dxNOaUZPQzr1msO4Pv8A5GlBYWkCf6OkvkNjYjyBhGcDOPbOeKknga5aaG5O6MRjcrtguvQUQlSl aMlsRCrNU1GOh//X/nUgivbSKZIZFOnQEypbMMMjdOPUYHSozewXMRnHmCO3fbcogIkzgHGP6+9f 2leDlaC0Pwtc8nebuVJ01OVLS8WR4o1cPbz7CwdFI4HvjFdVeXtjbvBbwSG9WVFaKUp5Tl8AsCvJ 65FTFxUrdP8AgA7QbmynlPtkc4XkkfuyuUU9O9WmtUl1CMSSMtqw/ewRAKev8PpxXJOUpVrPa36n rS5HgXbe6Mi9hSwaYNDJcW8SmSJ/L3s2MkqB61bTUdJvLSzurAXLm4t8TW91D5UkDqcMPpxx6VMl aSseWmlVSZ//0P52raCS488BXQbgibDlYyexP4Vrq2RHZLviulzi5jIO0jjIPSv7JhSjON2tj8Qu 3uI1vp9vcO/y/a2GGMY5Y55JqO6EJMnluJGVAzJCd5PqP0xVrDweyHslawiWNuQUgjkdmUSyLJyU J7DPTpVm4jj0wxIwhBeHeqKwYnI71aw1O2qQNprUxrK8OowC2nslBnl8tYXbhecYzwCDwasWUcUV 5dJ5TQqgaP8AdHdEO2FOf8ipeGimnFakKrOLavof/9H+eWOHSSwtvskbXNwxiM0kYa4BY9Q3Y1Tv 7BtPEcUcazxW8vmAyDMqkchuntX9ifU6d9kfh8JSSFjvzqCTSTJGkgmV41HBY5JyPxrRgtZ2FzJM zQyfZ/Ot1dSsU+M8Buxx61MsLTW0UNtvclXU1tdNk+0oxT77ZG8Lxg1VsRtkaeEhUdcgDgYNQ8LT 7AnZ3G3yWkT/AGi2CC5Ef7xmYolZWoaq175VtBbzvJ5IQvDhot2eSTnI7VLwcNLxOyNRWuf/0v56 3tBHp0VtJGDcMm3ytm7zDjnn1rCsbO7ieaC7D2/lsCqbShIH3cg+x/Wv67eGpJaxPx1VFe5rr5ao QECLnczEcmlsn89myisAcpJ13DtRHA0Nbx2LjiJqWjG2t9b3st3DJFcRfYLnD+ZE0CyleeCeoNa1 /qemalbm1g0pbH5TvCymcE56hjz271zSw1K7TjqdDrSb1ZQtAgjgW5EUk0GEVxCqKwX7pKjjIxya h8y7nvTp6kfZSrSFypKArjjp3zR9Xp22MnVl3P/T/nzsrOGQylZrSZrEA3FuZF8+JWzglPQ4P5VE bWxu9TWSaMCxlRVeSHadigdQDx7+9f1tHC0t2j8dnVnfc5rVrH+zonNqRNG055Zedpzg/lWpJY2N lp0WqNo0V3LbMJPNe3FwOOi4PGM849qcsJS/lE61S1rmRYDRpbaSaWyuLW984zPEqAocnrgf/XNL cXMSttfKtK2LfMe7b2HFSsHS6xD20+5p2d+kkl1Z39nE9uqpBFMFG2Rhgk4xjA6Z9zVmeysppZWM SRqUCiVFCIv4dO1Estoy3givrFVKyZ//1P50b3TLCZ4NPEcNxG7qwuQpYRE/xEgZGPUVd1LTWsVM GnXEepFAuybY9umO/DDIxz+Vf1W8kwSi4qmreh+QrF1ebmcmY2oak0qR6MSZXtoxIW8vOBJklFP1 zxVyLTtPktYJfsogeNNkoKkGQjqxz61jLJMHNrmprovu0X4GyxlVbSEjs4lnFxLFC1soCxxRoFLg djU81it7YeVKVgjM5dFixuXB4zx7VbyDA8v8JfcR9dr/AMxFfadaxwW77VMhYiSQHOcYxx2rOun0 dVg06Qf8TG4ctExXh0C9Pzz+VZSyLA/8+19w446tfWR//9X+afStBt7K5EMccVrZL5ha2iU/vCxL bv1NXhbwrNJBaLshCiMRsAFU9Dz75r+m5cP4B2Xs0rH5T/aNZa3KJ0SC3v4izsrI++RUbMTd8ZqX WdGEz28thb4a4uDGwdt0EKgZzk88f1FTHh7AxdlBfj/mP+0a8na5T/shbRzI3zz7PLcxjEZ59Ksn TLSdA91arPGyATW7/MOOe3+eKyfDmBv8H4v/ADD+0q3Vlm102wtneeSJVj2YjwfmHBwCfbiufltv MvRHcgXe2UTRTsi7UAHC8dOw5596zfDOE6L8S/7Rq31P/9b+amS3ttaukuVgh0uOJhDPaWaCSORV wA4z3PXg4raj0nSFi2KZJpoTlncqMA8KdoHFf0i+GsI3e1vn/wAOfmKzCokVLbQrSS4aW6jR1AJj 8pAJWIyVBJ7ZxmqQ0gNHMn2dRLy7SRdB6KB/WpfC2HezaNVmU+yEg8OBIDdKrbZAFkz8wVhnI/Wp U0GDzFmTY0ijD8c4PasnwrFPSf4G8cxbWxlavokUtuttFCsUgkaVZoky+44wD7Ajp7moYdBt44o2 ubom4kHliEJjPGSSf0xWf+qze0/w/wCCaLMbbxP/1/5pm0iE2P2BpCsJcuOdxD9mwazpPA8E4t7a a7F1ESJJ3QGCQ98A9iOma/oOXB8KjvKz9Y6/mfB/2rKOiv8AeTT+CLS0i05bSORGiD+dN9oMjS7s 4z9PSsZ9I0jRpZPtIQNNl5NyDBJwOPf6VnLg+jH3IWtp9m/T+v8AgkrNJPWX5lDU/BNvqaXt+928 AjgX7LbpKULtkDIHqAc/hVq08I20mnJbXcc1m8ab3lmGZJ12jH1yMdfWolwjG97x/wDASv7SfZ/e WtQ8PWF9b6Vb6Xc3P2y3hZ54blVa2lAxtZT1GAB75+tU5tJt4p0tiwS4SLzZdq7FbnHT6isZ8IJS XIo281r/AF8w/tKTVne/qf/Q/mes9EWaC2YYKP2kHyJ7sKa3h+G/v0t4AkeELfKchiqkkgfriv3N 8I+a/wDAT4OOZNdH947SvDps7hJpFDJHLukjl+64HQVzmu+B7tJP7SNg7WqFriBYyxN2n8WF71y4 rhCrWpummu+3Y6qeZKLvY7TQ/Bdhr+h/atPuEhnWPZJbpC3noOgPPUcHI7VTh8FLa36Mk0BeBPnU x9+gOOcV59Tgio7TUlf0/X/gG0c4SfLZ2OUm8MwNqN1Eba1jluD5bzSEKr4PB3HoeOtZ6eDpY7k3 UEsqCQ+REgcGKJl6sB15yOTXXR4LtT961/uv3Xp+ZDzi0ra2P//R/mCfwyEnSRZJJWT5FknAjwSB u4HvVe68KKE82VoBK0hVYhISzgdz2xX7P/qWvh5Ifj/kfIPN1a/MymfAFqltJdx+TGxkHmx+cUEp 6g+vY5/lTT4XF8vkLE0aY5ktmI56YB6j8KynwOr/AMOPybRUc4fSb/Arx+FDbNLEouTbMMF5JGdy w4xTrPwW8rXF6ylIHAiSJX2/Nzhsetc8uCrO3sL/APb3/BLeb3Xx/h/wCpqvhy8kt5bW3QC6tpkz KylkhCnlTjjByMn6VNBoN08jW7MDNsDhxjymJ9DWH+pTUnejpp19fP0+4X9re78ev9eR/9L+Wu88 IvbxXVz5ccsxEaE27b5OP4sdwM80LpUqrFjd86+Wdke3dx0OOvSv1CpwWkrqj9z/AOCfLrNLq/P+ BSt/C1+LkRwRz3ce1sB23SuxIwuO59K2FsJLHyVmsyty53LDMm5VK4yh7cd68ipwnifaOMaTt6/8 Ev8AtSmo6zI7bQdX1Vibu2a2jMm9p1hKRIuf5Ypw8M3sKGzgWW/Y3W2BYAeVZsKB6da1o8GVKt41 KevqZzzeMNeY6efwfrEEkEDW0trJ5B861uF5Y4BB/Q/nVax0ea/he3ns54biCU7JI1DowXqV46d6 qXA7grOm/kwhnXM7KR//0/5px4YuZ4XRZCjBhjjZjHXn/PWnwaWbto49OtPtF7bOQoZDGqlR8xBI 6AZ5/WvrVwtWjJQdJ6njQzODV+ZGbFZI9xNLcJKkofypOpic9CQfbpWVc6ZBaXroFnu/tL+Yjspx BjHyqB0HQ85PNdL4TVvhZCzN36F+TTZJ2QtA4MfYp+tVH8Lu8keoS+W0fPl7W3OMccjt/wDWrnfC qUm/0L/tNbNEkfh2e/zeTQtJbx/fSVSpkxwoX8s/hW9b6PIuby3i8tWXytojzHH1/LjNT/qveXxa ehUcxVtj/9T+aVNNu5Z44fMWRgmJE2Z3njoO3etKLwzJ5apIjPyXXd0Tk/yr6ufCkX9p/d/wTx/7 Ra2X4mBd+FHjuJb6z8ye8t4mEVuvAlY9ATVC60KO7Se3vPOX7aiLcxY5iK9dvfsKznwnFaObXy/4 JCzFX0X4mofBJhggubO4W5WCXKR7DvSPH3R7ZPPfrUw01ZDI5iEeeCkY49OPypw4VowV5ybfyX+Y nmEm9Eie28PXxieK10/zLYE3Et1jc8R6BWPUA9RVZNHv7X7RJh5PNQeSW+UQt3H4+9OXDVFK0ZNf d/kUsc1uj//V/m0l8IT6rpNw0VxLp8sMYla4T5ZpMEbgpNO0/Rr0oskcn2hSoKGQYYAKMZJr6B8M a39pp6f8E8hZjFaKP4j5dGkmXfNahY2bbOI13eZ25xz0Fa03h+G5tksBDIgCB7Zo0DSErggZ69qT 4Z6c/wCH/BKWY/3fxM6z8P3EMc3mMXy/7qPytjRY4PPU561YnguYIXeJJI5oUykgQnJ7Y/8ArUnw z2n+H/BK/tH+6VtM06+lUEpNJ3eVlJDknkA+x7Vfu9IlgdHML4HzNJtyo6cGueXC1Sz99fcN5jHp E//W/nFjgiuXlt0t2jYAFSFwmfapYrFYJoftNrKoORngBcA4z9e1bVOHqsJ8iZxRxsHG7RZ+xPLA 88CAJv2BwODjI/pVu00uZlLlWOOCcc5qv9WMR1mvx/4AfXodmObRZGEpV1SRuVA+8az/AOztYhuh cE4RIfJEUseTkdDz7cYrGrw1UhFyjPVb6fl/SN4Y2L0cSddEugomuXDzS/vCqdOp4q5bWd1byBPI kEjjcQVIAX1zWNHI6k58vNb5f8E1liYxV7H/1/wAeyvDCBFvAT5yBwVHqaxLrSJtTYQzSzwwJhvk GRcEHp9PX+tdEeHHFe9P8DF41dEX18Lai1jcXlnAz2doyxyOxCAE9B9eP5VkS6Fq10irZtFGUbdI Zjt4HUD1PtSnw5JPmjKye118vzRk8am9UPdJg0Fhb25Ewy00gjKgj13fUdPerdtpM+HaRCTnA46C n/YHTmJ+uLsXv7Ka9MFqJlSCFmeSPyhvkyMY3dcZA/zmobvQP9LBjBjiSNQLZeURh1cE88+hrnq8 P1XL921+JaxUbao//9D8Ao9JvZHtmllmaO3ysIDkhQx+YAVriBV3RKWZOpYj5jWCyLFuL5rL5/1+ ZzfWqd7GS+l3ZEk6BfILFA3Xn3FZqWuLkx5laQj5FRMIcdSaj/V/GLdfiawxNFGlPDJLaBVtriYK 4j/dxEuuTt6enqauWvhiOG1WwNu0aKhkkWVvm7sSc048P4tvVK3qKWMpWJFsMLHJsmBgbOwKcAKe Dx61cnQXEDQy5XcOPlxir/1exKvqvv8A+AYrGU72P//R/Ar+zYoo7e3VJHhVwUcqXye9aiaFbSOZ I4zHIvCjbs2n1Fcj4exL3a/H/Iw+uQWyf9fMoxaVMjXETIzNICwZuBWiNMuYrTCjYxxuKkEkelYy 4dxT6L7y1jKfUo3dteSrbG2kKeUSsyAZZzjj8M5qzBpt4whMkQQvIA287RjPJrmqZFjIySUblrFU Wrt2Lxt7VZJcDzBDKVGwcNj2qGG0n1q9dIleACIGEumzAPAPP0pf2BjXtH8S1jqK0bP/0vwpvfDt 9YTR/boJmSFwJpVHDf8AAunNLf8AlyKptI2TzHwBIdqqOgx3NeE8hxyduRlrG0X1JY9IuJRsAIG3 LEdDxXPCFLK5aLDuPMOVd8uW71X9g4xpPlE8fQi7NkkEczSS3CpKo3GNYwp9cdOuK1EijtrctdQN 9pCkxyxKSue4Naw4exbWtr+oLH0WVLeKPUEWYFwATt3AqeOOlXbeF3mC4J2/L/vYqZZFjYJJxH9d pPZn/9P8PDG0cMluU8r7QQCdvz8HPFZl1CyWhtmtXvolAQb0MrH2P1rw3keKf2TT65TT3Klvpt5f ARXemyWllt2ebAhMAfnCEnv0rXXTr21SNVzJHEACemV6f5+lS8hxl/hH9co33IZo7a2ltJXtHuWe UgfIW8vjkj9a277w9qV3ZWl9BYTRWwcyJe8xrJ0BjYe2CcEd6xnkOOvaMGxPG0UtWZk8baakYa1F 7Jcny3VFO6LH8Qx1x/Wo5rG/gMEpgZrdzw68FD3DDqKxWR4+U3BQ/wAg+u0Ur3P/1Pw2uIPPliKl 1fgKo7fQU++S70+LMu66RVMiwKvzDA54/Cvlf9XsxUuXk/FGyx2Htdv8xkKSH7Hd/ZhFLLFtXzVw 8JYDj2/+tWiscsE8kdzMblhHtEa48seh4/CsqeR49Sf7tini6F78xmR6fIPMK+YiF+EPIYiuk0jR rjVJvJjgkk4AwkZduvoAT6V1LLsVzSSpu68mT7eikm5KxBqdlDY3TpFJ+7iXZn7oJ6HIP0ql/ZcE yETRFXjXfDKDjaePzz6e9Ecsxl9Kcvuf+QniaDfxL7z/1fxCmt5DbRFkZ1DFGyvyjFSW0OXSKNS0 jnAXHLH0r53+zMbv7KX3MJYiha3MvvK2o6Sb2RA4KT277lDZAXAIpbLT7m3B85SxQlmKjKlc8Dn2 revk+OVOnaDej2XW73Lp4mjdtssQahY3FzJDb2LwhD5SXJXLzN379M8cfrUCaZqVx51xPp8yQJKY XdmUxv1xjnODj9eayweSYunNucdLP+vv/IzeLpSSSety08+6G2tHshaxQDyne2HG0H5SV45+lS3k drPAIbeFgcjbITy2PUe5rzczyzFwknOPu3/r8jopYildq+p//9b8O7eO9ivTGm8ReTtk+bCD0AX8 atvJHaxSGdVAIydw4NfncMHXTlJRbSdvzO2NSDjJNkP/ABL7m2UTxTT29zETCDC0aBh15I7dK0Es 9Lhgt/sUEolK7Zg3KD029x+Nd9PLa02rdV5f0gWIppNdRyabMZlumjkECjDZUhGH1oad0uGdm+z4 OLcJ8rZHofwzVTwNSySj/mWqsL3vqRtLcSXCvGpuJpWJO/JMh7kn+tVtQZkIuZLfbHv8t1ZsbDyO D35/nXVUyvE4aKdWO6NKGKpVINJn/9f8N4LrdMkPlSjLZR8ER/nXU3cOyOCUqSIU3NIOkY7818jP K8Uq3Kodjvw+JpeyTb6v8ynKkccMl9bRtdzyIDEvTaPf04rX0HUkk3ymzaKeLiRJoyF+gz1FTicu rUlzNaaL57m8cRCU+Xrv+g+e/nlvbyc2q3UbweSsAGPL7YX0AFYcNo9xKwFucnkKRyv41isJPZrs P2sPzJ7SSfTriWGRHME6gSxAZTAOcmor69S4mkgtE+ywFAZSwKgL3P6H6Vm8PNq1iKtRLDTP/9D8 b7S8iZEjtGUNEg8uRPUDjFY+ovcpG7yAAEbiWG10HvXwKw07OLW56lGtF4BK+pXs7OKZIftu/wCy zEEyAZOPUVoTQwWMUzxEtFHyXxkqorN0KntHF7GE3bC88dZXM+z1HG65WPfZyqArqhLvzjPT2HNS 6o6ywRgQt5byhVYjBDDnml7KTdl3OeVRKKu9Su8c8CRPDJLCekwB4lX+6R9cH8KkYibyxMJBk7gC m3OOwNFbDSguVr+rnThavvqUWf/R/GaKe1uopYobUWkcahJXiJ3MQOTk9+taf9mJcq1tamSS0MCj 7R8ySM5ALce3Tr2r81oUZxnbofQzm5Tt0KmoWsdlHDa7PNVMfKRkRH1P5UT6m0UUETrud+FH8WBx W9TDVpSjyrb9NzL20IOdytfxyzW8PlxRCQyAgS8BRnr9RWTPFPaMJIZCZAQzyOmVA4yAM+lbrCvl vy6ehhLEe9a5rx2IvoP7RjmEMiclhiPOO/HT/wCtVPaTdJJ9plMiDy7dY03xbieWf8B9KwdBt6If trLc/9L8env7VI2tLx0lkyFViu5t2eNvcc1lQ3t3a3F0rxTRrFhv3oKRyLglSOx4/nX5y6TW6PZh Uje7Z0F1e6ZLHZXiq1pNPGAqK7N9pYDkmqM1wssg2JiQp8+T1x/n9a5XTe1jRVI30ZL9m09LLzX8 4Xfm7kiSMPHISfzGPWtOee2VYZjOFBXY6/3T0wT7HjmsY0Xf4fwHzp9TNlKXDLEYDciE74zuG0Hp xzTJdMjijG2IRvPJ5kj7uDgYA9K2VB9vwIlUSa1P/9P8fEtLOSRJokA8k7HjYkZIGM/SqVzMLSCV JWZ4XbOW6A+gr8v+qu/NZfce26t9EzOSYDF1ahhOXVCH+4VHXH5100t/LFaJJNbyO4Ub/KXczKen H+elafVtNErjjNRWrKMt1HZ3VveRReZs5QyAhYyRgjg1HazWMkjMxUMzlpD2Uk9qSw6fT8ClWXc0 biGFkJiXzFj/AHhcchay47yG7gmgiuQ0bEq3PCsD6/56VnKjyrZHQpxf2mf/1Px10+T7Na/Z7hEu Jp2IilabfKqgnqP8a1UuzboVaIsWYIvljJUepr8pcF1ivuPqPc6Mwr64sb24iUQtAIDteVuZHcev bFEWnxXV00yL5gRAshbO1gM4A9KXsV2QpWe7OgtdPgTSrmFIJZroP5kU24kRDPp+J/SqM8MlzZQw XEEkj2snm24wVaNuAT+IA/Kq9hFbpfcC2Ky3c8sMsMqujfdSb+eTUOn3sCW15pyXK75FMckh/eEd wAfXPNL2NP8AlX3CjFrQ/9X8ZbXS9TkRbeGR5ctvKDKpcngZPvx0qYwai9yxu49txEn2eGONiUVV wBn34r8pjQgtLL7j6azvoX5HuYokgupv3wUbY0+duRkdPwrKmb7SBDFG4aMbpWbuen9a0VKK+z+B au3ZEwuYYoIrF7RSpOTNnDAk/Wlm02VCrS7UhAEkWT970FTKEV9lFTTsixZyKEcXIEJQ8OeAR2ou 4ILcRNbyl4ynJXrEef06UnBNWjElWuf/1vxmtI4beVmV38m8fBlk+U7sAH14FUbqJ7MPKkivPa3A e3VIiyNhvlHOQcflX5b7NdY/gfXRSSNuyuNTuolkR3EivvuYWj8yO5U54LdQR2Ip4vJVeKyYebHJ Lu5+6ue34Vi4QUnZBF3Rai02xik1C9SAyXkgVA4lIHyg4wPx/SsqWaKGXdcRuqhdwbgh/wDPFJcq drG8Ffcmtb43drJIl5JaLFMT5ZTLyjBwoHv61TsIo4bma7kWSSMoWfILSJ6kD1pyklsi3FJ2P//X /F/TXu76e8mW3Frp6Ods93MIbmQc9Yzz+tSRW8EyyNcXgWDcY/KVsE9s7vf0HPFflkbPfc+ynGO1 l9xljSbPz7iOwk22lt+/tnd8yE85A9+f1rNmaK0X/VPIzNykYy8h6dK6VG6vqYyjT6pX9Ean+i/Z FKjyndgDuGHJPY1HDpr3EUrvKkckT7Yo5CckdCVo9mnoTeCWyIU09NN8wQiBmdCi7QNzEe9JCbqO WKI27IGiEshxsIY9iKzdFXaFzp7JH//Q/FVDBNMIPI8qVWLloxtJJ4yfWq+o3TaPqGlaedNk26pF I8dxPc7Gl28F0XHIBPTP41+Vyhbdn1KkuljO1aS4uESwsyr3MswRSvzFRyWUHpnArFTUXti0IjZH gOwi4jILYHJwaxcUx8zWiNTTr95p02Qs7XAKqfL3MoHp6dBV65iv443lshH53Ty5OBjvwOaSpoTl 1ZzupaheQwvFDExuWXJKjlSParlqgZIZ51Z9yAvG4wue+RWsaSZk5R2sf//R/DS9eFJEvltVSSBR tUZ/fAHvXX6Z8R9a0nzr/TEfS0niCvJG5AYZyqumD909DnvX5hHDLokfUxaWqNa5+NXifSbSI6ld 3mrzXk+9mN08un7cZSMxZ2r/APW6Vk+KPi1q3iaz0+y1RBcLayGbTLF7l1j/ANoIvQEbjyB/jTp4 Wn/KvuN+e+zOMkWEzzOiBPtCiVkjO5IiwGRn1H9KjSWS1hSL7R55iGQ4G1wfce2QKHhkrpRX3G0J rqey+Bvil45+H8Njc+HNVuNNOoTGY2bysLe7dUaMPtB5xuP617Jd/tV/E7TbiKNfEurWl+IRJczQ zvPbA45J8xyvUfdA4BqIUFCKSijb2r527n//0vz3/wCG3Pi2LO/tLnXNP1W3uQmy/lhS0vLQRnLi PCEc4xzz718+eI/ibfeP9Uu9ZvbiSd5VPmzyymVnYnPfn5eme+enFfmMYuLt0PvalVuO5zVvr39m ahpur6bJcDVLJ2kBM7QoCPu4284PcGvuXwb+3J4vh0rTE17RtOu47GFrS6h1O0EskhCBVfeACwx/ ECPdetNc6ehhKrJxSuyzb/ttf2rHbQav4Y8Jac0d1KLOHSbG5SJoTngyFsA467cZPOO1cV8Wf2uZ PGXh2XQvDuh6NpNykYtLK+ljuGvjxtcrLkcY3YXHYc0uaV9xe0la12fJOsanqV67yz6mWmngXeWl 3qxxkj15JORWBBPcQIkjoyxrJti+bdlhjOPzFF5vZs09rJL4mf/T/Nb9nr4wRfD/AFq/u9WguILS 4gEYv7a7M8ltg7jIluSFPOQy/wAQIOeK+3v+GmfhDfzrqOraRbrcNMn2e+S4e2vIePmdYsZUtnoP XGa/Meaa0uz7mNWTe7Pg/wCPvx7T4ma7q9lpcN6nhmWWSyhguZhciNUZSGDZLLuZdwGTgEcmvOPh /wDFK+8C6hb6vaW6TNoUySfYo7/yZ7+Mt80Ow8EHHvjANNJyVnsa+2kne7P02T9pj4LeL/DGn2Hj Nb7RNSXEVpK93FIsbYG6OUllUqMkDaSCMdxVS8v/ANl6+hlktNL0JFvZRm6n0yF7eHaAGnlffhtx yflJPXIrrpp20OWU7t3Pn39oCT4Ga34WtdP8E6rp1vqehxPPcz6eG02KWMRk/ut4x5jNgBR1BfuF r8qPHWn292iSaarw29vuvrrd+7fKjO3HfPJPfP512w3PKqvex//U/jV+I9wNV1C/u53LXRu8WwXA EEe3GOOTnA/E18775/PmWRPutg7lwBz0r5JRTaujtq72aOw0hxLdGKZFETQjYCoKkg8jP0/lXXXl lbTRFZbyS1R1Cbrf5XU57H+ftTnFW2OX7ex29no0dpZRPbS3F6igNvnYNJKDjPNa0VjbWsy/aoWZ tqsqTcYBGcevOawnFWKUtrnpnw30i4u9ZjudMhNxLZMJZoCcSNCXHmBe54447fjX3N4V1W1tD51t bNZ3tr8ieYNxjDZ+6SPwrzsRDmqI7cNNxqJJ2P/V/jy0lklu0ubqeG2VJEiWa8IjEca4UIBjngY9 cmvUTBDEZ5raCOdo0228crGJWAPyjjpXysl76MY33KRtdRQR6lJYLMirgwpMzRWrdcjJ+Y9ufWq+ sXMwsbiaLzW3QMkkTgfJvGDtJ+vbpW+jSN4PT5HzA3lRSyTxJc3EtlcGC4a7jIMoUg4U4GR7ioDL Fq13c301nHbQocwxxKRuIGNu7/PevapxXszz5t6lbTtYvNE1mzurPTrSWNpfLmhuEDwxxkEbgp7j t719GeCNVe+1OzMFkUuL1liQWberDhmPK5yePevYyOK/tbDP+/H/ANKRwZg28trL+7L8j//W/nPu LmeDV7Pw40UlvrFrCLm4tYlZ4lb/AKZPyGxjnBOKW6t2i1JJLvzGuIsTShBskIYnAJOeuO/rX9/Y VtYWPovyP5Vqy9+XqVdavVtLG4g+17re5thLOksZT7DKGPCHOGG0Ak8feI7VoXN5HHp/mw+W0Npp aEOsJXd+7BkCjGSQSfriuiT/AHaSM1JKTOespUvLW02w3NuZIPMk86N4d4JypO7kEgjj2p2rDbpw tNPfFw5wkLPt3kc53/nUSd0jYsXFvp+mX2i2moXM6w3UMT3VxJHtgiLqCwyOw5A+lKNO0e2F1cxX V0t+qn+zr2C2FwoUsNyMccK2Fz9PaoZcH0P/1/5xtdjjjtbS4P2mG8tJA7QQH5LoEZG8dscHGe9Y 6XsU1zHHZxXEh8gPO0sG1Y3PUBhkbenJx9Olf3+720P5dtFlB59YuZVW3tI7R4fn87BUrhuN2a1r XSTbW62900jTXFy17G7McSLjDKPxrJ863N4JWNOLTd80LRNLY7m2qYVBic45UkjgdMkcgH8K5u7b UodVntNJuYoL44WYlt6bSdhz2/PirSkZyirk+myTX73lnHqEz3Vqohnjjj2FSOrFSO9aNrY3unzw z+ekhB2SB3xIq46ken071DUgsf/Q/nE1KSK7vLUsg8qHDMwGdxzz/n3rfs7S1XY0GS0nJjXg4x2F f3wfzLTiY76kY7oRxRzr5EhQ210POlOD/EfQ+nvRFdDSZ1P2d0Oob5bshwGRsALx1x0/Iigq3QZB YC5uRctt5bJbHBx61qX0FveQRJc3EKW2kS/aLaOJdjNLnB3sOo9mParXwOxD+MojWreGSWL+z0lk mtzAjLJ5UoJPUHH6VMfDNmYxqMRuVVysj+c+7JGMpk9uvT1rUqx//9H+db+zLdIZmhVpI2+cIxIY DjgYrIkubmQSLFGh8o7PLQHeuPb1r/QGzstD+ZzQspNL1H7HcOJraOzmP2qC4jxJdAEj5Vx0P49K 2PIe8nW8Mapayt5cBlj8uWLac/8A16LPsJKxZ1ETLblLG+h1G7Q+XJb3M4WUkjIBwMgd8kf41n6L o+pWlrea1fvHBCGEQij+aZHbOM85wTgdKtwdyh/9tM8qwyCKQrxdRE4liB6E/XB/I81tLGbaD7Yd ptp5iIUU704Ayo9x/WodOTVjaK5VY//S/nYfVJ7pxbW9q1n50nzmcEyEDPAUHvj1NbOn2897Fc2t 7p+1MZiu2jZJE9SjA4/Ov79cGmz+bZLQLXThbuY5dskEj7fncZYZ4461ceEQ6hLcs7zxbNkYk48k gYGD37da2UXbY5aiujL1O5jkhe2upE+0TRbElhh8tUAPDP25xg/WsLRY9kV1cu0f2e0G+cElt46d ulYOD2Mia1vI5Yr14g0UT5uIGmfBQYzgL/T3p0WpPNZLLeLK6lj5U5J3MBxz+tHJKxcep//T/n+C x6bBbkBXW5i8xZFbc/zc/XvWTYXEEkz28iSRLcSEvOyMFX1zx1r/AEBs7XZ/L9rGzdQrOjxws5iW DHm54QjvVe01PT7CwjjAhliZDBII084SPjDNn1zS1RtD4TGe9/sm6tbeR/LtNSQ/Z3KZLsDwB+AP NWL+X7VpN1Fdx+YrHzIYwc+eUOVB9yRwKnle51rfUdBe37adbyGJ1+zWwTYkZ3RrjmPHfGSMVYPl XtrB9okvYdswlMdrGYpnA5GccnnsfSqeujNb2drH/9T+enygTtFzOh37og8WJn55U56cVs6ffWFv expaIHlVgJrcnfJnjJ/HOfav7+jTad0fzxeysY+ptd6dcamyMbmOWc/ZomiXaque569DnmrELlY1 SdkDuuQFPA4qrMqOnQS6gK+WIVllaWPKL5fygjjjiqVkyteQtKjoyAqQ4ypPI6e1JwvqKW+xDHc3 cOpoluVFrLLslHl5cjPY1tzLLHeCdEW6j3DFpIdg465I9alw7GfLHsf/1f569Qs557h5UuLe0tWQ kQkMfmJ4UHn9fSsfQ4TI94syyxypP5YlmGVYDHI9v8K/veUD+dIqzZs6jokkpD2F79hkeLyLlwu5 bxN36dvyqHVNMMFtCYICs9s3lPcQ5Vpl2/eNYTpmit1RneH1uraDVLlolvhZksixHE8W4cBh3781 sWlxBrMEaCGeC9dsouNjfKR8tZuGlkVFpJl6LTLd/wC1LfU1nM13bi3eab96sYBzjZ1BGCM/7R61 jJotvaXKvZtJI23zBmTdGMDB6cVnKL2NdFZn/9b+eq6vLwylHjSS3ktjEzlAdnYj8RVXw/JE8l5a Wdp9lNlEsYcr80q4zuLf481/dkoK1rn86Jt1bmnbnSlmEV3L+9mZikayDzZGAzhc9P6VVsoNQaWZ 75jbtEZIYBa4YSoeEL8deazVNOO5spNN6E+naSdP2mQtcXBk3tNLII0ABzknucdvXim38Ur37SyM IQ0WVjH+sbn7/wBOacY9EVe0b2KDGRYLqSCHz5o03K0o2s5HIx78d6uLM09nBNI8wuCMTecB8pHY USjaSFCWsj//1/wEl1SeLRZtHMjW9rf5aaSFP3pIGM7u3bFY+mql3YTRW16YbvTyohhMZZ2A5yT0 HT61/dLhy6I/n6nUfM7mess6q0hs4EdXKnYuTu7mpWgN9JbStHFGicTREkliB1qvZc0ndmMY+0XK 11OnNjDDaJ9k2xwy5DLGRsLDqcevNZKWkUE0UcrGV5MkNjlfrTVOEVrudKUlotkaLWNpeoYGCkqc LIDggj3rPvdMlaZdpdUSMEOz/u+OT+P/ANasZUY35uqNddLH/9D+eX+0buO6iXyZWhIx9pUAxYAH B9K1H1G0ZJR9nLbRuXy0xsb1Nf3C8NHnvc/CJOSjy21MO4QhnmnElvE0e6MyrtSQnpjPY/1q/oAv wJEvlt4ARmBI5TI0y+pBAxU1cMqtrvY5qbcKjcS8mmXV5c3LQxtGYwIVY4Ee5uQwz16/pTotNuLe EW97NapqRlaKRImD5I6dOnGKJUoKKvuaqTTaMEiS2nKvFFIgkBYHHODW9qasoV41UtJEHQpIHCAj gHBqKNCEruRVGs1DmXof/9H+eH+0dTsHiiuPNnW4QqHOH8tOVI3HkDrTY79YX3RSByowEY96/uOW GhpZ+R+GKvJbouSalqFva2l26osksnlMU5HOcnHXoadbRGIlY2V0kYu8r/JuzzxUfVIRV09Svbym 7tGdHcSXupiCaNY9Ot4iN6HLSvnjJ6Y/pUut2s8EcUdzE1raT4ktbxANk46YDY6Z4wKqdNOPmjOq +Zyi9mUpY76WC1MH7u1hn8u5OSjEYyu3j1rVv7aW4tP3kqoxtxsuInEciqOnPqKhUYtJ9RxV48r2 2P/S/Abw/ZadFYyQajcfaHFqAVmlEcjMfusMdaryWEUTCRbUG0dixl6rKBwQP5V/bk6Eee6Pwy7g rEr3UWrWpgtfs5tY12RoiBBHtGMKP85rils8X8dzPA0UlqzQxIXBWVSRhyOnbj0rD2K5miG+Zm9c W0zMJX2RLw6JG+4ke/8AhVI6vbyuqrGYlg+Y3D/eP4e3P51TpLl3Lc5pOHRj5NZuoE23qie1Zz9n SFPmjBHJbPrgVBpUy3c12IoSskYEkkezG0NnB/SuadO04owf8SPzP//T/nukv0so5dLh8xUuSk8/ ZiykkHP1LfnVa1e4muAFjaL5zsyOo9a/tinSSVkfhilLsJPHFDLJLy7dJhHyc9/xqhpchs7uQ2EN 2zQSC4ZbhNpm3HkZ6f8A6xWns/Mp36HVXl3cfujHbeVNc5DOqfuwew//AF+lUtVthLEsUbA3YTDS yDfGG9gCOKaguoa22Mqa32zWce2OaW1K3HyAom7Bz/M8e9XN7RyHaEE7tvEUgyoPHUUnBOyuY3aZ /9T+eXVE1CO8i1G0tbZYmm825Cq3yHHGz8R3qteX82sxy2Zt5bZlYeZKYzk/7pIAxX9teyinqz8L hLoyCDSmjlsLfebg28m8yTJl4upBA+pro5/OR1gkffzgehFYzpr5Fc2tieO2ltU8u5tQ0PJWNxkA HvipIxp88ixWqGMsmG3nI3f0FJ0oPYetzlL6zFxfwwyiQ25YeYY+B1xTjYS6bfm2hiMz3RHkhPvA eoFDhZGsZpKzP//V/nzklnspRb3XE6YbGQSv5VDbmS7e6u7ncIkHlqzfez2z+Vf2c4p7n4pzxQ63 +y3j+RJIoypCdlOPU1PZ3MFrIG8uLZ5hiQkDYGQ45HTtVQgnoLnFlhgmNwZpUZZ3Jcxtg5PXpVDS tKt9MsRFHJPdoLgp5jv5ky72JGSewz+QriqU7vY6HPsN1e0eKa0jtbko3nK8rrhlKd0I7E1biluT OfIVPLijzIOBv7Z/H29KXI1pYhyb1Z//1v52bm7mhv5b57GKKWSNYJ9keFkRegJGM+v41Ys9T0+4 KLbwCOFP3ZjQfu8jgjH51/YkYO+qPxVysW7hoIyY2jWSNlwFfkdKqDW/JtJdOuJ2+z7i4QrlV9q1 afYael2ZCNJ9oiktxviU5I2feArWeH7WwX7OpuN37hCN28+i+9K19gTuR2KzyG5WePyDC2xo3AUp g4/pUrzqYntVz8wKhmHykmnZ9hn/1/50tLhuNO1YWrOtw6MrDcAUOcHHX8Pwro7u4nmurpVtkhji IUyD/VknJwD+Br+y3pc/FmtTIuI4oypWJVlB3SS9yP8AP86yri7uJ53s40ciO0e7kPlnYkaEBjn8 c1FhmeqXsbRGKdp4doYf3RmuuaC2MAntpJJJNqhrfGWZsc4HpQBzM8t2l89rJHtIAe5hYnzIgR8p 2++Ksi5Vb77PJZRmRYhHFM6ZKhiGyvfPAH0qWlZgf//Q/nMuJLRNWjLeZ5ccGXkVcru28gj61qS6 dbz2sF3HPFFHc2zSyQ4/eowJChh2yBn8a/sF7s/GL2KVvBa39qhUvC0DtHJvXDNjgEH0rHnV7aVP JlkkCPxGD8jn6VkkuZo0hY1AbmOaZDYwvHIokmlc4MG08hRjvVSN7oXaSWMEZt0O+eR3H7vg7cA8 HJFZpjcUyqwe4M/2hVVFbcAg+XuTxiori1UWpSKMneolLbdxYAdM9e9acy6onkd9Gf/R/m68PQxp FfvdzwJMjAW9pCjF1jx9+Rjxyc4A9KybCOW5v728CtGxXYyICEcKSFB98Zr+ubn4/bobUF5PDp0o Kwm9LFVZyyxxDd/MD9a0tFhD2Ml3NqEHnOHbyWBjEarnoTwScHAGa2ui4xd9SK3DKzKj7UkOW38K M9zUE1xHGSkTJu3YdlGN+PSmarTYhHnSxN+7CIH+WQnJNOKQbNk7rDKw3JcMD5agDvRYbbe5/9L+ aKOCS2tImluJryW4kLLN5BSL1B4yBxjrWmt3ceasOyN4Fh3GXlZVf0A6Yr+xYxTifksnLdFyaO6N u3kzMJNp27uims6N4n8pL+wNzcTA23mmIvFbnGRIx7YIH403CKdjNSkkY88dxABBqSwyQtJt/wBG diuA3y56Edq1bq5uLpUZ5d4VBFGOPlUDA/IYqVT7luTSuivaRNZyJI7vKHGzdtyfXnHA6Vb1O90y GGGS6024lllkCQzW8WbiLrgv/sZ6j3rFwWxabT0P/9P+bp7lbmCKO2BU7Au1V25x6imwxyK9lPHC ttfQyeUCG3ZVmGfzAH6e9f1w4bn5QnY03hkmlMmd0f8AEQeFxX0f+z58DPE/xq8X2vhHQrSe4ubm GIwultJeeWk0oiDMoBCLls5YjgMa8ytiqODpSxNTaKu76f1dnqYPD1MXWjh4LV6aK/qfp7pH/BGX 4wWF3Bqr6lawXWnyuvleQynUoyOghjBRl/3ueBW3qX/BJD4jXtlql5BoNuj2luZDc2NhPbXc7ewK kHn+HPevj5cZ4SS92NlfqevVyh0aM53vJH42/Gz4Kar8L/FT6Dqdwkt/Hn7RZTWxs7y2YO6A7PQ7 c/UGvIGS6trhLX+z7fy1g8wTvOFYN6bMdepzmvvaShOjGrT1i0n958pSrqulNqz1VvQ//9T+bNLp bqYJKUjVWxtAGDj/APVVOWAtqAD4EY4UvwSOowK/riMFc/LOdFO+t7O7mtbe686S2hkLTxIMpIRj aW+hH05+la8bmyjYRp5Q4MTAdB6/zpuFmNPm2Gz3EWnRQpMLm8+2yfOqxEpATk5J6ACqNokk0ztM RHEj7oVRidwHTP68UuVWuFn1ZItyNRF1Eiqka/LIV4MpGQRj2pLm12xia2SJJliVcN8qDGBx7nH6 0nTi1sPrY//V/mztZ0k/eS/uSq/MEUtu46Y9/wCtUVvJ/NaY2ltDZ7SqBjiRR/eK44z168V/Wjox cdj8wbly+h7V8Hfg94q+K+plPC9lc6lHG4QQ2sXmm4kJwqRkdyT619maj/wTe/aIWJ2Twy1zbiNJ pVEZluNOL9QyhN2e2MH614mNzTL8DWeHrP3kr6L/ADa8jqwuWY7GUfb0rKPn1tv8unqfLfxQ+CXj 74M3dzpvjvRdT0J4CI5I7+yaAygjcGQfewQQQCOhrxO2geG7ae1Z1h3B8um0kH0B5Fd2GdHFU4Ym hZwkro8utKUJypT0knY1Lu8nn8x4rx0uSv8ArfvuOMd/aq+jS2umSQL593eS3sgjKImHXewQqPXr +ver9mxU5apH/9b8kfB37K3xt+IWmf2h4Q+G2tazE5ba4ZECqvVlVclsgHgc81594x+GPin4T6tf 6J4m019GvoAsc9pdI8FwwkTcUw6qWxyDgdQRX9NU8VgquN+o05L2sdWux+d1sNicLRU68bJ7HhV7 BHNdSlRH9nc7iirQ1vbSOZVhSFWOAqD7oHp+Vd6oQ2a0Of2iIfJbZcP5mUAK84Bwe36Uum/ZVsZU khSIqdiRFfkwDwVPSrWFh2IdX3h0STpH8gaSCSbAHVUJ7D8q1LWErDKkgJKk/KBj8Kr6tSXTU1VX uz//1/54oYUWbbzHMp3nIww/zitWKBbiR/LlIjHZjjJr+rpUILpqfms6j2Jo7FLefO4KjjkkcfnX NyxXT3ssssMflCUxRkJt3KOMmk6VJdDNOV7JmggnQH7ODHEig8dC30/z1pbOwLFnkRQfvHI61hUo 0X7ribw59rloLFFdiKJ7mOCXYJlX5w5XGeBxjOcCr0sTSSMjLut4TtiGMYXrz781xfU8KnrBfcaO dVWVz//Q/BOGCKe3SBcIFYnBH+sGOh/KhLK5t3kk2WzWyLh0UgAD6V/Tv1DCJ39mr+iPzl1KvRj4 Dbwx7fIQ7juHy8MOwx+FVma6a5RraNIBHyrjKup7AVlLLcI3fkX3CVWstGydYQN4unJnk+7wAcnv VG4EM67bZvnUbX4yCQTT/s7CJfAvuQ/b1ObluT2UzWwSCSFI9uXLqOpPcVpRWst/LDErwJBI5Lea Qu444p/U8PyqLgrehDq1OfRn/9H8JdM0SC9v5LaGELcxITIiJwApwSR9Tj8RW3ruhXGiN5OoaI8S ugj867tSrIxzjIIB6Ywelf0hPAYGckqkIt9LpbLtftf5H5yq1dSfK3ZGXFpkDpGsKr5IQAgAKi/Q f56VDPbiGWOGML5anOFHGayllWB2VJfcdccRWtuZ81hcwXIuTaf6LORH9pAwUPUD/Oa3LTRbvU9T tNMs4jP5ifaJ5JV3pCucc/U4H9K5p5VgWnH2S+5GscTWTtzM69fh7rl0WU6JqUSW928CltOkQSrG MtIjlcbfr6Vx7Q3Md5cWLTqUVNsSd3CttP5f0rhp5TldualCLXlqdEq+IirTdmf/0vw/exhCIFnz n5bhVHzDjpVB4jFEkcvlgRsRGVXoua/c6mUYGW1P7j49Yqra1zURHj010iZhDcNvYH5Q+OAcVUQW 0SbduZCMHA5/KsJZNhGldOy8yViaidi8bW0QcxAybRtbACmoZ5HtbUD7GshkkCkOMFV67lrP+xMJ fqX9ZmETJqjM8UUds6IEIjiCRjaMZ+p6n61bksHiHmMFMTL5e/byW9M1P9gYST3ZX1qVrH//0/xO tVFiJmlyi7Mq3l72Xvx3546VD/Z0C3ESMUhe/jF3EZWEayK3G7k8dOlfsr4coKXxOx8ksU7aorZs o1kspZXA3l08mLzFz0J6+wqSG20yFhNuKmNflAAy/wBfrW64dwL2v94liqiZeEsUy+XBgBhxgbQa ha009op3u3kVkT9465Jkx0C+nWn/AKu4JR6g8VUF0exkVJLoYns7g+VHHIwLx4/X/wDVV6/0+1dh tQAquGHrU/6vYNL/AIJm8XV6H//U/FW2AjiaJI15bOCORioJYjMRCBskc/K/3Rn3NftEshwWnu/i /wDM+K+uVTQtdOS2ZhqMTu4jzEsZAMrdsk9BUJjaBEa5s5IkkbhCDIcZwKTyHBreOnq/8x/XatrE psLQswVTFJnceOv1qWS2ZkSRk8xUOwccHFSsgwNn7v4v/MiWMrLYtLbLEyvHYQO5A81dgKspxkt7 4IrQWPTJIET7P9llgJZnj48/6n2pwyLAdaf4v/MTxdb+b8j/1fxsmkaV2R5pmhwFCO+YiB6iqU1v BKYo5YUchx5QVBkntX7THIcvf/Lv8X/mfDrF12t/wRpXiRWsKoinzWwpCfwj/P8AKqGoaHoytZ6m 0e44VS0YzIXxtIY47nn8azeQ4G+kPxf+YPGVlu/wRctbWytroSFA8jchWAeP8quTWUdyJEigQYOQ gA2n6Cj+wsA9ofi/8y4Yyuuv4IwodLtJI2kaMxyREq6DoQDwanGiwy3dveQs0CQYleNQAsmBjGMd 6znw9hWtLr+vM2WNqLdn/9b8fxZWl6rTj5pkypV+ACAK0bK1tra282IDfIpQjYHVj0Nfq/8Aq9RT +N29EfKfXJ9UZcFnOzG1mVks5CXzggAgdfT8auG2s7SOAxl5Tkq4cB0YVceHsJs5Sf8AXoS8ZUvp Ypx2jyXnnRJEtlExRY/uyqDnp/L+tas148Fm9s0s8Vgr5Y4JgizwWPYfjW0eH8Ik7N/f/kYzxdVn QW+jeFn0KW7+0iTVLciSBJWUQ3Az8xDdenb1FctNHbXMkqMYwiJvbA4H+f6VS4ewEUrQv82ZrG4n VN27fd/mf//X/HiTRl+0RzmNRAEGwA45HHNW9R+z2f2e4isoZQMJNlPMZeOM9+pr9njkeXqz9mtP 67nws8VXs/eLkKaQ9sJLyCVbue7SO1BQCDnPG3HXOMVSfSbVb2+l8rypDJhkP8OOMAfp+FX/AGDl 8pufJ92i/AUsXXjQV5Etnawxzwv5CTxxSB/s7HAkAIyCffmrBt5lW4ltVksZZmYmGFuNpP3ciuSX DOE0fM/w/wAjKOZVuXRL8f8AMo22hQXJL3pHmOOFlHynHI/lU96kE1qUS2Q3MYCBQAv3eAM/gKzj w1hL/FL8P8i4ZjWb1S/E/9D8lRpQe3inu7RYhcRLiAcRjbwWH1xzVK70/T5J7NbaCSKeOQnzoUI2 gY6+4r9cXDWG9orSdvl/kfDPH1WrNIt2+mszsr4mCuX8x0yc+/6VO2hwm082S4Rpo491xHFGdgbn Kj2op8PYOXtFd6f5X7HS8bWVOL0uUo9Fs5H+0Q2Miy+WoVVJwGAwTtx39Kba6NhpGvZ2NxkiO0J2 xRL7epPeuSeQ4WGsF+PyJjja19WNi8PJdyXDvPDbiLAMcp2K/rg1YttEs55LpCPIeJgIViw8bAZz z+XrWL4RwmMi41279H2/qxcsyq06ilHZfif/0fyJfREgmlumbzJU2r5JUkMPUfTirEmj6ZdW8y3k TvdSENA+0BYduMAV+qUOD8BhsLPB1FzObbk7JO7VlbR2tut7O7PkJZpWnPnholsv67jYdPtbu0gs ps7LZiULAKxJ+9n8h+Va1paWdq4EKW5dl2ttUYIHHIrnpcH4HDe8k3y/jutfv8i/7Tryk7vce+nm 7hm3XU9ptkBS3giT7PIM8hsjgf7vrVK60W1lWONYY5XYbWZFHmE44Oa0p8E5cp8072WttPufdfj5 jlnGJeiYzTtMgSNYpbdA8bkGQxjdgn+91rSu9JtFVrVo4jaXC7miYB2bHQg9eveujF8LYLMFFSTj y7W/ryIoZpXw17O9+5//0vyhl8FRRBVGHVAJlG0IyBhnBPfjFad3o1tFpYLpELYnyJ23jLbuACM5 +lfp1ThnCShCM1aSvqra6bbP/gany9DHV024aq639RsPhvTUgb7GifuYgwVnyqgAZ6nmoTplhfkT mYxvEvkzYwsOBgDH4Vz4fhHB4mlPD172UtGt9l5W79DXG5rVw1aM6fZb7dSW40G0gtHTT4o/PlTE MmeHYYBLDuOe1N06w0xLyCG4kFnBkQ3F1ImGJP3iB+eBXQ+CcvlKMpX91cttLNK6V9E767p9Njj/ ALcxCbStrr8/vtYdd6BaWGpzwx3iXduZSLSdYiN64yM/5/PrVOXw9pUduZcSTajLOSB8v2dU9CuO TXPHgHA0oScZNyveO2y6Pvfv6ed95Z9XmuRpJWs/8z//0/zDsvDGm28C306QeZK2EiUKAD/uis7U /Dtvcu88saBTHsMZUAkDpX6RW4JwmJoxUvdqRvqktb99OnTtqfJU86rUoulvF976empSt9Hs7iK6 fUEYpbwiOyig+VQRjBb2xngd6tWHh7TNiW11FJ5eoDy5nL+S0QPILHBGMH/PWsKvBOFrUYp6TjeL a6q7te/Vd/zVi1nFWCcPsvX5lLVPDFrpUywJLFcxgDb9mKuoXoq5HAOB/wDWpqeGYE06W9ae0WUO W+wzpJJNnAAfIG0Y+vaueXA9Omowoxi0lq2k23d+XbQzlmsp6yb+WxZtPClrfxwC8uoYZHQEBcqC 2OAPb+lXR4XxbNGII7oWu6eQLwyIMAnP/wBfvSjwlGtUUcQk4fj/AMD5Mulm0qHvUm0z/9T8xb3Q tGW2jktktoQ4AMKy77gcDLMPQnOM1k2mnxmYMLsxWafJNsjD7B6jnrX2r4AwFKm/Zt897pvt2atb Xr6dNjwf9Zq86ickuW1tPzNq78J2N/YQSJKzPJljhcCSMjg565HWuYn8DWUN3bXFnc3N1KE6MmTE R1wB/OtaXCcaUZNWW1rL8/vFHNHVlrd/MisvCoubuZby9nVCS8J8sZBHO0+oNXbzRIraFUNsJ5Sf LV9vGO/HeiXDvJFU1FW7LYxjj7u7bKVhorrLb2r20X2S8nFtM05KQQbwQGkPYA/yrXtfB+mWcF7E /wAl3FceSF+8pHOWRhwQMDmo/wBVKb96VKP3I1jmTTtzM//V/Lafwum1E8qKaTA8meNcNgfhUWpe GZsxDgbVXI6nHcV9pLgvDzV3TX4r8jwnm04qyl+RO/hdXW01jV7XyrJro2OnyKpWNpNqgqPpkZ/n VPV/CtvCzbIyUBzuhk80+uRjNc8uBcN/z7X3yCOcz7/ght94aFhp1veLPIwZQFZgI5Uc/wAJXr+P FYdt4cub+G7trzcrTYe0eNfmByD8w/P86z/1Fw7lf2a+9miziaT1NnTvDt5LdxW9taygRMFLMMq5 7c+9W9Z8L3tverHcF1dIxm2Vg0YzyGGOtN8D4eDuqS+9k/2tOXX8j//W/KePwJcvFeO9zdWU5iEu nqyhred1YZUnGcEZ59cU6z8CTarbRm7kmgkaUiWxkiABC8DHGTkjP5V9JPg2jFWVFHkwzOTlfmLz fDu8TyIb2MweXma1W2O5XTkZbj2PHbFSW3hG7mvIIXnghsPKZpTcDDfKPlwc+xFYS4QpP/lzb0Nn mTS+IoX3g2a5kNrbZCKhle4lASJQM8A8c4HTOelY7eB7uxEUXlzTG5fEEnlFBMc9F/MfnXJU4Qop NKDT+8UM0d/eZrx6QdD0wktF5czmBto3lGOQV6euelc9J4RukNmkViXi1G4yGjx5QGSd0n90cd/W uV8F3dkn9x0/2vG3T7z/1/yQ1PwfqcUyyWoeCdGHllF/1eMcqc+3ar9r4V1S3f7XNc3LTPFhoTEs sUhPUsR92oq8B15yvTv9xhHPYR0kVZvDlzeSSJLBFCISJGaMjzZN2B/n61aGk3lrCttBCMMdg4w/ PBJNcr4JxcNl+DOlZ3SdtSWaHUNL8q2FpKbZ1B88x5XcTjG7/Gl1HTdRgtvtdu8oyoV/KX5kz6D+ tNcE4ycfd/J/5F/2zSXxGTJo2oalpssCSGOEAvIsfEikD7547Vz9r4Qvrd4biOYtGg3MjxiQzHtn /PeuGtwdjqcrNfp+djannNFrQ//Q/I3SYr9VmHlXSzx3BVd8BjRR22H09KsM1/p8zyXFi9xHcxMV ndfkVs4+92OTXzT4axlP3eRs9NZpQkr8xkLbXsIm1BbZ3muDmAHLQ7hwQD2+lQ2GlXkt1LczK0Ll dvk/wg9TgVP+r+N/59v7hxzKgpW5kRzaNe3NwwaORIQfk3LtV/pWylvdWkQS4jV4DjaZFBIC+mel YVMixkHd05fcarH0JaKSMbVVMwX7KRKrDc6hcBMdvxq9plubtIpJ7eWMPAqrbvEYmyAOcVksoxf8 jNHjKKt7yP/R/HrVdHs0a2OoO0Vm7FPKbhQevy+/FV20u8EMFy8brYz/AC20pTEc23H3fXGa+MeU Yq1nB/cz3Fi6b6ouXtxe6XbtFbwSSLMi7lUYbGc4rn7i9C3qzGB444AgNu2QS2Bn3+Y5+lcNTLKq lZpm9PELlGw6tcW80ssiSwiJhIVKkI2ScDn1ravYLrxBc2TQSQ2lpp9m8slmttue8Zzks0vUYxx2 4qFl81o0WsVZ6GW15p8ojsnhFtdQ/cjJx5pBO0+//wBaoJr0oszb2MkZ2TY+8p9c0PAuO6L+sM// 0vxOkurq6m3TIygKABjG/AAzj8BWrZac100kc7pDCkZlG+Tbvx1Ue9fnkcI09UfSyxDKF1pbrHNP psszlM74Qu7bj27isMQzu8NyrSxTeXyjrt2Z5yR68V1KlZaowdabZckuXukiSWEq8TkOSu3zCP4q ljuv38cLh1y2wkDIHvWTpOL2BVLqzLD2t28xlh+ZYvnLZxjGOeaa98JVlzI5ulGJWJy31/Sspwnf Yakr2R//0/xNg1MyAMUb7RDhd7A7mHaqesRNqRj1DUpJYk06B/skqAyyoG+8qr6HA6V+YShK1mfT Q9SrpUEyQw3mn7WWNv3byZwW6nPcGnypZXV3cG6Mst4ihmRVyEP09DWDhJFPR2NIzNbwo8NukMqR 7GaP5SwHAyOx4/WseGfVLmeE2kRliU/vZC+XPPTHcU1CSeotGVZbrZqX2iUu7Rt90AYJHr9MVt2c 1jqNzcJeyS2sQi3wtDEGJb0IzwDW8FqYtbn/1Pwsk2uzwtukDny1k/uAdCOfarUMlrDbiyvZbl4p VMUKRRb2uHAyqnt6f/Xr87pn0kOphaXLKYp47uxxYvNtDyEPKpU87R24x3q15U8M1rGkYcPKBAxA BUHuT9K3hvoaGtqAtY4YntnmM0bbrhUj3oAPfk9evFZV28ccS3EKPIZGG1VG3cffPSod2aQT3CWa 4mltzNKVhgQpGCSzJk5wOeByfzprTSeVIsolulJ6ucsfYVldx0N4xTWp/9X8GtEsS1xLcyr5MLSE x2LMDt7c896kdWghljtPMtLlZ8r5aCRGBJDKydwcn86/O5bJn2UlrY0na3iNtcvFKHC4kDxmMJ68 fnVq6luHVWijDQOMIB1JqebyM5Xtoc1IuoRyypeOii2YqkMf8Iz09z/jWgYs20VxG7hz/wAspF+Z eD3qoqLWo1sRz3PlwPDcQu0rDdG4Py/nUd5M7xQT7ZEgiiCEQnd8wUAkj3Iz+NVyx7DP/9b8IItQ utOWJrKxlvw8agpdyGJcv1LN2x6Vr+IYdOP2e4htrZLsYEn2abzwWwNx35556Cvz7lj2PrYNstWW rafaS2ttJYwXMVwmZkZTGwbAGRjnPvmuT1CKCXUJ7yzZY4WbEVuVO9yCep9v6VUKcWU5NSLH9o6h bRf6TPJ5rkPHHK2fKwMLj/PetO28Q3kmkGG7upr1omIitLgb7dQSeQOnU5rqpU1exzVKjRweoXuu X7SWsuoeRFahpgYokSJ/lO0EEHleg9zXjvieXU7fTmikvXvXBeRpJmMWTzhTjjHP8q6vZq9jinPQ /9f+NTxRaAasgeN0hEBlmmZCNhYnCLnrjGfxrx7UmhW5cACZPMIwANox3NfMcrTsd1Roj03VZ/Ph tYoo5EFxja4wQD1wfw4ro5UutRkBtFleWGZVS3hI3ucgEEHsazmrrQxseyWSX0dlHppSK12KGLup E0ZxkgZ/E4NV7uG7laYW8qyiDDEg4YjOCfzxWco20YrI9v8Ag1pmuHxNYnTYTqNyYHuzNHMFkslR TvGBxhs4wefrX2PF5uookz29rpska7ZEhHlLx/EeeSfX29a4pxvOx0UI3mmz/9D+QODSpIrDQ9Rm gguN2rLBKJofMt4WTBEh4PcjHHevX59KsmtbN5HuU1LTWc3aCTba3hcZDDIzgZxXylV2kreYoRWi ORvru61C6tNO1DU5NO0rT5PtE8Gnxq013zvAY9QCflxnpV+O3GswXOx7Wzt0b7N9t1Itb2wJBILt gnGBnKg8irg72C1j5EluL8atfPG/9o2vmPFEsMZNpuBIOGHPHP4jpSWsOoz2lvb29yGiFw73FrK3 llWb7rA9MD1Ne9F3p2RwT6lGWBxqFvbvIkD+d5UhkG9F5wenH4jNfTXwpsNPj8UaJpV9JeM6XEd1 mG1kEUhB3APj2yRzzgfj6+UPlzDDyf8APH8zhxSvg6sf7rP/0f54NQXTkvzO88v23PmWrR4F1bHP bJyBxz9Kp3Gr7bq6vdRuJL+GFAks9vEbqQsAOCBySOnGenev79wr/wBkj6L8j+VaqtKS82Y80+n6 lcpC0MN5FeQrJGswaPCn5hlOCD9RTdZ1G8tpwuyJ7fEcUEEAAjgVVCkEHqBg+9dXIuVXOdNXZveH 0W6v0vtUb7XZS2skcdmP3ZWTpGSf7oOeBWM0MCajcSbXifT5S0haIy7Vz1Udxx2pcsdrHTF3iilq bDU4VuIJYdQgMoZlf905A4AAxx9OOlbtvp9tBpjR3G+0uAivbJbgSxOrDIJOeMZHHNTKKS0Ljqz/ 0v5vnsmgke7e4MlxcKsUhd+ZlAwuR6gZ5HY1A9rcRNHJYyhZJGAmg5AkXPI9z6A1/oLGKcdT+WWr M2Z7Ozlmsh9qYm6g86WKE4aMKcFT6HpVK4kukgS4iUyQQu1ujSNlosdvb1xRyI2LGmauk08MFxNt iQ5P90EkDJ/IVa12ztFCalprWbSNL9meCBwZpCNuCR7An8jTUUtAJBBb2q21xqUkFvc3bqkbRwqJ DGR95yO3Heqbw2l1PdXlncXF5bySeRHuj8sIY2Ktx+HX9aiUbLQD/9P+cSG3mZ5Ld2ije5l8qAv8 rIOm3n155qawsXczTTSSQ3NhcfZbZ45PMSZWA+Y4PYjv0r/QA/mWC0J9OWWDV5NFsfs99e3gMz3n KqxwOC7AcjoB7Ua5Zy2lq93eztNeSOtuiBS7senB9AB7VK+JjeiL2kWsiROHd3XygwVhhUOOf8+1 WPtVy1rd2hW3aF2UqfLHmIQf73WqJg9LGVZ+H4o9Rtr/AFXzktGUvE0Sg5I9Qew4/Oi7vtTMr2cN w0ttI7CBANkUYHQH3+vNaRV0ikf/1P54Lew1G3gTzb2MPcHeIUfeVC44xT4Lcx3yCaMKJTzLjBY1 /oRY/mcvT6RDHfRXbRYBzC06rllHXp36U+/DQMNNt5xfT3A86yhJEc0W7j5gOgHPNVGNw8jKg8Px 6Duu0lgi1a4uPMluMAtIey57gY/nWg1lqd1aTG5kjkKnzx5IYDAw2CCTk8Z4rTkQ7u5yt7EHeOCw jlZ5G/0m6RMRzcDaPUbeetalvBJbvDaz3V0ttbq08UEeGgMpwCSOuD7e3FZuLRSm0f/V/nUNhfXm o2cMTyWGpTShbdJisKuSNyEFvUc49K7VF1PTbS5N/q8txPOFgaAR5RSDnIPav9CLI/mlzZwWpWd+ upWeqLOZrXaUayUbHVw2d4Y8ZI/lXS3EojNrG8VyiX6kYmYMY3IyASOu7nH0oOeUnr2OfnN5Y3Ee mzQrDFJOI5Le4izdSKSCGBPzAd6uX1kTcQ2is2nWV2UiuRAg8u5C4+Vj0GSMn69qiUeplF6ssasm mJbR2kEcduEcRiQffPGMe/8A9aqo+yNpxUbriB3+xblH+rbGAenHNSk0l6mvMtb9j//W/nptWdLd kvPPD2qLGjyR4EigDB//AFVXTU2nWOLyo/3Mm+5jhIDmPOBzjqRiv9CHG6ufy9F6uxox+IbrThD9 gFkIRL+/hvLaO6l2EY4DA+np1qVFXU55JiYEh2HZDb26QKJG53EAAfh71DirnTTeiVipBGi3dkmr NLLawym2jQRiVyz5CgDsM457DJqK9W+0O0S0SLz2E/ko5AkmViSVAwOc+3pQo3ja52Rkr2sINU1y 5spLZoGjlaTck0ibUjPcbcc1r3GpSvcWNulo6mOBVMqJwSo5LHt0qVF8pof/1/5+IpruXVJ7qR44 7e3izErp87v09Oe35VNp+mTwGfWRbeaEYh5mIjBLDgZ/EV/oNFWP57Wm6LF5C08EMszQI0rENFHK JpEAwfmx0znj6VkzaRNdxzJbzeS0ce6ORh7gUuRXNFqid5b3QrvTkkvNOv0jKExRu5jXODyWAOfU D0NN1Wci5iuIrSOMyAxiOLLhM85BOfX9KaikTJXWhRUSeaEjjQsrAt0BJPqa6R48bXddsqJkhPWn KKtYw5XzH//Q/n1mgtZrTMk0z6nLcMxs5IwIoFUAqykHuc/lVG0sHmnfz7uS2YxH5t2d5XkKAeMs eM1/oA46H87KL5mX4rG9EscFxO2zIkiydu0HoCf89a17qy1a4tnMDxsEYRzLJ8rqOi4H4VjKNh2s cjb6de6dfXME7m2ku2CStDJ+7mHHVh+v0rpV0W50uZ1uJ7dygBia3feGBGQdw49OlZuKegLQzru7 1SO5jEapIkhb7TMTucDbgbRjGTnnNVLW0nYSW5nNnCkbyrdMhk85iTlOOcnPfjmsmkVOVkl5H//R /n6tXhlhe2JSV0jITPDdMZ9eOKzNPV7WW7mQ5jMYjl2rlpTnqB2r+66jtOz/AK0P52p62ZbuNKdU jvbW0W5kVsyuyYMKdWwfwFaUHmzNCwjkkhnPkj7OQzo3Ay3oBWd0dOxDd+GxZneuoGfdNlrPeWkT vnHpnjrXO6ybmG/gu9zi8CeWsWwmJ0XGP5VUVe9hN2jcsf2ha3EgLb0eRgqwkYcE1sXQi+zRJEUk lkT7oP3cHHPpVTVpcphTkmpH/9L+fPIuLi3sbkNBGU3C425gXHGGbsantzFZTRSK0MpY+XLAp2yb RjB6d/6V/dUuXofz3F2nY1NdtbBC11YCe2W5RZJLaf5/JOOcH61x1lBeqqPLPFcHz22+UvlkjJwG X9Pwqk4ps0p+49TYlknt0RRaylZnLNMg/cwY65+uR+VRmWUkGL5t52tIRkRjvUSlFvRnRvsTaNod 9Et9OLjNnBKJh9oYq2HPzBD0464J71YlnvRqMELlGtdn7pccuP4ifpU+7bVjW5//0/5/ddCRxQ/Z WiklDAtbRHLlT3GOmKx3+1EfZdLuJBPcZhuovJ4jHBGfX1/Cv7nbiup+GTTexpXiNNpxEhe9ntYl RY8biwTACr9MVRkN/Kfthby2iCq2UAjiCqqhVwAMYHX3qE4q6uc8VaUhJJr4J5rSMI92doOEaq8i LCbe6jYGSS5zG38WSu3bn8KtQhKPK2U4Sl8Jq2dnaxlX1GaV3mJaVXG5IV7cjr3/ACrd1K3021tb P7Pf2TtqC/6IgdizAZznIGD3xnpT5YRlypijCVKHKf/U/nyvYIxE3+kJJJCm0R9NpOSAPr/WqFrY 2VukN3dWjzfvNzxo2D7gV/c75T8KirvUsJc3Erh4rdIYGlK28UuV2jtnP860haXE+pQRztGsTfKV j5QEdzjtxzUuyi3c1sth1z4dnS/cK9rHaOQ0YgfIzzuFUNTtb1UVJ5TdRWn+oiZi6W68ZCjtzz+N ZOStuFiOS5txBBazvNBayyAKY13YJHHB45qFrDS7u2NvNPPdooMMgZvIZG6jp6cGp5kNOx//1fwB a3sbDS0k/dXM8SFEL/60A4A569KoJPKtmwDPGGO4LjhRxwP896/txyXMtT8QaurmNPqt5b3Eai0C qhBd4+kw9fb3pdSmGpyW8yWKSiJ90jLKYRFnjA9fxrLmjfcmyXQ000bUT5TRz2zQv8jJHOsu36kH Ax3ql9gS2uXglADs2IyOjU076kc+vkWbsxWiJ9rTcjfLllPH+f6Uy/EyWkV9ZskUMKqgSALuvOuN 3ckVz1VL2kUn3Jbiqq7/APDH/9b+fG2cXdnbQXa20OoIDMrddynkB29umKp22sRXWoTRxXdnJJaJ su47MCVULZUDjoeDxX9rRTtufiGlye2sFklkSB/LyxUCU/Pu9Tmp7y01WznEcBjLxwBTLnEUgHJB Pf0q4p23LvDYiF9ealbiG3Ob60jJe26KpOeR7HHWnW6G4tVQy5u3yu1j9xh2z3ou+40otFMWN2sp MsyAp3D8jHqfwqgLkwX0Yty9zNLJsaSRQY0z6fSocl3M0n0P/9f8AvIvmhS3mlTZMvmB4zwpHrST SSwW9vC7KVikLEpGN7Z4Puelf2u2kfh9rFETahDqIv7ZQ4UbWlkQFgB0ODxxxxVK7sdRmnuJYdQd p5T5sJmAIjc/Tt7VlN2erGlroStPrMI8m4kN9OBtaVk2o/pUVva3jzXreQyzR2e9JY/mJ5+6BWd9 dynGyRDCtz5KfaJkXcSS5UqU6/jxU1qgHlkZkkbI+0OfmUH0NPm0tctRVtj/0P55L+G1ctaiZ0uS MQz43hn9DWNcw3cS24e8dAuRLEuNk+cAbj7f1r+y3NrQ/FuVW2NuzhWONXjRw3l7vmU4Pqc1cucT aU6mJ53WQmMRr/Fjiri29wsuxkaLpE92803mzRGKLzJ4d2VwMDOD9ccVdeA2pmaOQvnlNxwFqpwd rExnd6mbDdCVvJyzyMSxlZfkX2q5PczJG8FqQZFGC5Gfes+Qlyvof//R/nRjvbq6nhgu7jCn5WR1 4yBwePpVsRR2xkgMaqpYvFKi8Me9f2fGKWx+I3XUrM12xXzoz5Zb93KO+Klu9LjuZrcpMqScCRHA VWJBxya0cbA9kM1SW+0y2ltbdAtwy+WWiUTKoBByD07dq2dLnha1tZZUdLyIiVmJx5ZwOB9DmpSb 2JM69hlu5ibOZgzz4uXblwDzkf8A169Ih0DSRaWs0l2rjyl81XHllX/iAPQ9OKrkaG79T//S/n0v LDT7S5u7p7qX5eLV4I9wuWJUKHBOV4PbPTvWRm9neSFtwiJ3xKD95ug4r+1eRH4hd7me0d3bArcA vvfDZ5wPetCKO7uIysUqwpJGbRpWGE2Nwyn2PesuVX2L5/d8yS5tUs7WCKIrMZm8nepwFx6e1QPY m3jZrG7ktrx4jE9wBiSMH+72p2dhpvlbJhatF5k1xIs96bcPJdXAC3FztAwM45JHQVk26m4nMx3R k9S/XI7VPKuw47H/0/5zpLWFtwDbWlOWLdQfUVXuoZLWBl+0syN8iDoMd+a/spwtufi5HYXEo3xb d6hcKwGMcc5qGOUPNJ8mDG2QehHPWo5V2Lgrsn/tkRSmFpFYSnZIG+6QexqKW+jt74WESM1xLa/a vkGYQmcffHGcnp1qeRdS5LQhunkXZjamOTgcP7GtLRJ5L2WaFEI8qHMgZOCDngH1GOafJEye5//U /nNu73TbW3kjjtyLreVeXOFIHQY9uap2N3E8AwEjlkHzKvOPYmv7G5In47B3Q+NreSf7LIg+ZSc4 wD2qK4t1tY0t4seXE2VPZOtNQV9EXdoHWT7Mz+YMNwuDya5s2F+bq3uTIrWsTEyfNh8EEcD2rX2U S4ybepv2uoW9xbSrbrI0AJUPJGULEHBwPr/KmRXtpeWybJDcQuzW5eRDGIypIbGcHg01SjskaH// 1f5t4n1GVJtHa6nnt1Ym0QH90jH0qOTT76xkbzyUkgOPKQCQSk44bjjFf2eqStoj8n2NZbmOKx2z gpMQCxUZx/npWQbuVvMjjkUb1/doQM8d/wBR+dN0bu5z+RQW0nub/wAn7REVEW5oSRuY+orUS2Nv FseJVCt94n5selL2JXM9iG5a2sU32s02ogr55tNojaBj98Z9Biqun3lpqtxY3ro8NujlZUZCsuOR g+mDWToIqEm3Zn//1v5s4bD7JevKs9wILm4HG0zeTuIGRgZx9ePem3ImgvFjMnnR7shsbT19K/sd 0dGfkXO+p9G/B34b6l4/1ax0/Q4pZfMuFW6nhhM0w37QiRIV2lm+fJz8oU5r+uz9ib9jTwX8E/CG leNNTvIbfX9SsEuri9nhW1ezEcYZULDqV+99SeK/HePcx9nyZbhn7zbcl+X5fifpXDVGGDwk80rr RpRi357/AH7Hx3+3d/wUw8d/BPx7p/hv4Q6//ac1tHMl/fXSx3lijwkbwvmAqThhk56jAB7esf8A BPv/AIKjXH7R+onwN8WPE2naB4lAcQ74xZQamCRtC/wA4JyM/wAPfIFZZhwp7Dhb69TV6yipNW/r bd+Vz5PJc0nis2qVKzXs5ykl6LS/ztp8hf8Agp1+wL4c+JvgO5+M/hnV00zWdC0176R0tV+1Sssc kgY7RtYODxkY465wa/kPnR1N7DdyzTXMEz27XUlv9nD7CVzt4weDkV9bwPj5Y/IYQm/eg+X5dDx8 bQq4PP8AEYeS/d2jKP8A28nf8Vdep//X/mnjso7yWSaGbYLViGI+4SOuT2pDLcXl1JqlxcxJb7BE YYwCsRQY3BuvI/lX9hRptbn5KpJliRoopQ0bFXlUMkirlJRkfKT079O9WWnt7WIz3UgVo+GVlyVz 7fiKcqV2XGVthsMN3dWzyS+TPCzl4Xi5kVO24dQetVrZPs8bjbJNcI+I14AIJ6n6f0ohSfKjVSiL p9glnI4CEeZIZpM84LHJqzJZrcyySCUOI/l+zqCHGehz/SodGysUf//Q/nAbRjai1jjuRcvNCZJY ipEsJyeMd66L4ceDH8ZeK9L8ON9m8zXr8aLDdXwP2W181sbnQcnHoOuO1f1ziIOnh3V7Jv7j83w0 XVxKo23aX36H9kn7Bn/BPqD4M+DPCHi/UrLRl2aXb6sE020hzcSIFK5UjAG1FPTOD9K9D+If7evg j4dfHC0+FWpabpsU2otDbrNcWqGF9zsFTkgduuD1H1H8/wBTGYjiLMsXVpXvG7t5Rv8AkvwR+oYq eDyOpg8vcVZrl26u1383+LNH9u79iHw9+1F8PpPE+m6XpNhrFrpZvBqthIsdwY44iygEHYRkgE4J xxzxX8Yvxf8AhfqXwo8Y6z4e1nUp5dV0iU6fewsuLUbAGR1wNvzKQd3fJr7rw7zKpjsNUwFR609j 844ypU8JnajSWk1f0a/zPNdOhhuVSfAcMu4vG25H/GtjTNIim1u2vUEiG1HmRxGXZEGUbs/U4/X8 a/Q50JRi30Pn6Ek5pH//0f2Y/wCCa1r4R1f9m/wvq0GnaFPPLpqRyhYEMypEojO4ZyS20Nz6+9fj d/wWo03QrTUNF1HRPD+h2F1JqMkVvetB5UkyR25O5sfMSvmxgZ7Cv1XhWGKlxziHX7SX3aHzPHuJ pSy3BSw/WcE7dro/nVFt51vbTC4jaQIFmEXQsAM4HYE/pUcMUx3pnManlvQ1+xypu9rHycUuW4lx pl5MV8mVo40UmRdvyyenPtzVl7CJ7Nokm/exRDeD8rEk4O36VfIzB3UtzBtrbUjeSQR3UgtFUM0J H8X94V2AzFDH5Ln91zIrYJkPTms3CSgbxt0P/9L+eq7Ml01tc7kU8q8UI+cEeprXs9OU2/m5kj8l zKwHG/2I/wA9K/rWUJJI/LXJLchvbkx2odXi3eZgo7YkA9f5VREd79k3OWaKaY+SeynA3Y/SoUJN XNE1GRLbyNHE0MlwTAj5yeFz0qwIJ0mQyO5gkwIxEhLHPSsnSk5mtOerLcFpJ+8RCu6OMuN55O0E 4z68frVVNSYxeWUKyFiCT1GOKhUJKVypS01P/9P8B4vPkaJVkMWcYcjpWlLMBE8EZJkZSrNj2xX9 Wqk72Z+ZymlsUrCOea4gt3mVFQYMp5AA6E4/CrkKPG0guJUJEp8tlOCw7VHJK7QKWiuUp38y/jin LfPkRHacOR2zWs2nqke5FVM8uQBn60OE7bC5lzXIZY4SQUYPtHPHK4rNnt7jUD5VkZVkBACRv5TP g9A3aoSm0XLk59D/1PB/+Cen7EniP4leNtO8fazo81z4b0G8t7fUJpIDNpl1llkaNcj5wvALgFd3 HuPuf/gqj8EPhd4G+E1hr/h7QdNsPEUer2+mNILeOzllR4yJH46hQiEntkDp1/Wq2bzxPHVLCUXe EFyu3fd3876P0Pm8xy9YPh2lUkrTnNSfkr2Xya1+Z/OpOiJM8bELZxz4aaJgC4z/APWrNeOIag7e Yzx+XmNQv7tcdDn+lfo/LLsfPXUXbyJAkt5nfOXjikzsLYRe3A/z1r7A/YV+HOgfEb9pDwh4f8Tt eXmnO5ukt3ZINPuvLlhKROp+8yZJ5PdT1ANeJm8q2HyzE16ekowk15NJtHflkYV8dQpT2c4p+jaR /YF4q/ZS+CR+FWo2Fx4I063ubXQppFmtbKIXSNs2gpIoByWAxz374r+Kn9o3w9F4Z+K+uRafp9va R6Zf3OiCBHMM8H2eZs5h6ANu5x0wK+A8NcdiMXl1eniNWpXX3nfxO40M7jh6e1m/yR//1fwwSfrN 5LK8rgSIBk5JAzTL+aV1EMCYdedzDtX9FOnJu1j4GM0kyvbPd3SCAucofutkMAOuBWy8bWywv5TX E7DBKfMY8eo/Cl7KSVmiedb3LsivLbHcuGHr2qBptyrDhmYLty5zjHApOi0rNF87G6ZaXEUF0Z2M W9yY0284+tW9Lu3S48q9mf7Mz4j8xf3cRH8WKcYSirGl0f/W/FK5vLfUZbm3guA/8LFsx7VXptJx 6UySzhIgjnYylcFGc/NGMcAe1f0XKLvofDlmw8PkXctxLPFJaKMrgEOPUHNJqmmW1xazTW00MQ8x UZHfZKVB52jvwKaU1sNWvqWQlpHDafZ441UxjzDkgp1yTnnPHT3qB7OSVbiMoTDnAkXnHoc9KLTe lhOyJrTaGFu4aM2+FJ27VI9aWeON5dsBZxuyT6fhS5JdSeZI/9f8brrT/Ls1m/1UgG5eDl6zriOJ rNVQ5kkXDsOHjPtX9Fcsux8A3dmnYwGWRZPtLyssARldgY1x0PqDxjrVeS5+2TQwy3IW3EvlkE7i mOuBmqlBcuwiZ9PMc4WOeMxE7mndvk249al09prqBoowzqhZ1XHT3H5Cp5Eomc2/hMd7q6iMsMcz CSZCGVeq46ZH1rRt72WSCITwBWC7X4yuRweahJLREPY//9D8Zn0/7UhQSsE8wMVjkKSDByBxzjir 8FlKksc6h2kjBCRoflHua/oqEVsfnScloi3cWsuBLMqZYBhsIIA9DWQk0ttqCptWe2cBijfPChx7 dxWU4e87Eu9rtmtbRxXDXEcca/K2RMcoBx0GemKhtorh7Z3XesiTNHnqrKOAaUYdzaGiRREVzG7J 2Y5LEYNdHa2qSMmJli2x4ZJDtSQ4960augd1sf/R/JeSbTItMntxHI97LLuidFGxQMBgx96xrS4u QRBbgCOFThGXKr6nFf0LyLofn2typ/a2oXMTWqkyLHKwMuwLgZw3H4fpV2K5sdlnaRs6FmO6WUHY hz3P40vZ+ZXM+40s8dxcLvA2vtUoco/owrSh84wT2TMkq3BDyJJgggcDimoJaGU272IptPVI/Imh k3lBJb87Yjk//Wp720SxczLA2ANueWocEloVBto//9L8g5JVk8uziLu0hwxPCLVm1AiWWOKUGVG8 mdSdwGetf0JZNJWPzuTewBJPN27t0cbB4zzgEYPH0/pUnkXF5c3M1xKSjDezj7ynPJatoWinYyrK 9IjliMJT7O4ky20lOSvTmtRTDI6Kb6a1uY13RsIBJBKQCcNn1xjj1rOSTivIxjaMbEOq396jW11J C94JGWGWSGEB4cgKpEajp6nt7017NId87Ha/3zHnJ5rOKuVDc//T/J6OKK4tV1Gd5vPtjtiXzT5a IePudOv8qYkM926SQXGSDubsWB9a/oOKanY/NzopLeI2US2lz/pYybmN1CRkdMKc5NYDwT2T+Rb3 GSyhpYyPlIPOB+lTCHLz+f8Awx0OV4JF6GadEMiBlmX7vG0UkVj9suN0l7Z2twieZm5cgNjsAAaw 9kpKzOdzakVNRNqYpJLmMsiL8yRgkMR0bH1FRWUwk3JHlCI8dMNiuvDQURVJu5//1Pyv0u0kZWh1 K/BQbnW+eIZRQMopVfyzUEd5ZzXSxCYMzNiNiMB+vTtX9E1F76PzaE20yzf3SQX0cbxxShod7kHA BPTOPxP4VjWNhMb93cotrt86Il+rZORjtipnFKGxabubTJcXB8pZ/IC/P93cJMdvxrPmmlXP2ZzF LC/LfxYHP61slaBN7MuWMt7KkjsitA6mMHbyWHU1JBFcROJrxA0YfbHgZ3DPasqHU0k9mj//1fzK kvmSGdWlVklK/wCuUeZAo7K3XFYhdLt5LWPcUOC5YHYR6+9f0LGgqqcX3Pz6FadJ3iJcwTxWQkiL bY5RFdbD2J4bHfirlq8TxXNvaKJEaPa4khGRnByM9Dx1Bp0qEcPNUoba/mRVqSr+9U3K8dhf6c6R 3E7yICJ7c53hC/JVvTFX7iEX3l+XbtJIX2skabgD2x1qmtX6mDj7yXkS2mZoLmGS0lMiMYY2wRLC UPJx6HvmsqwtZY553uZmbY5MKhQUP+zn9a0knZFRXKrH/9b8vIxqNxcQtGBHbRz/ADqwIcjnGPxr otQimuJWF5JI5AWKObGVfsOa/oWG7PzOfQrXdl/ZUrWkvE0SrJKMhlQMNy8jjpUFtIuotLIhaXa3 lnKEAYAHHt9KmEVrcJtpk11ps32K7gVIkkmizGduZc9Bg9R1B/Cp7bTFht4hJOhlVBE8RYtOcDGW pS+Jgo3juRTrFCSSiLHbjJZ2AYsSQMD/AA9KrJduFk8tiiyrskAOFdfQ/pWEI/gW720P/9f8xpIY 7aL7TCInkUgmPgpJj+EmtGxulismuEtbc7jmW2cYEZGDk8cj3H6V/QVSKtofmsLLY0rzWxrMwaK1 t7ZFjC+VbJ5cS4GDgVUiwtwIlMisIyVaLkKeMbiOlc8qbcNN/wDgno4dpSLBKxR5jjjeWF90kj8g fhT/ALbGy/vLUzOSGjZSFiBz0rCUbyMU+Vkeoy28TstosotrjZ58DgNGjgc4/M9fWpIrZJGbyQxV FDxhwNz4HI61vCPRj5ne5//Q/O19QG1X8sKbb5WQLjpV95Y761a4ijVGVRhGUjfX9CxiuU/Ppydr mZqM0GspDpskd2sduqyKsIK2qMuFbnPBPWmatPpujpCLe3uHZxHF5Kn7R5bFRnn3IJxWfK72JjK+ jLk9xbX9raWYgSJlVpZpn48wHBCt6EY4rMSBPtkZSbbsBDBcbWH+f51UaaSRrz30OvknsIIo4rWC RWlTfuDBpsAfMW+mDWU1/pd5M8QLs9tlA4T5gfQn/CqlSTWxHMl1P//R/P8AVGtpUNzcq9tJgwRl fmjz15rpZHtHtmuoysL2u2MOE2gg98/hX726KcrWPg4zscje31xdXotFuJgSu0Spn5V7gdu/etq1 0+zmNsitLcXMKF2jZQEwvOSfwzihUIvQ0lVdtC9cSWWmWH9p6tbQXOm3kzWiW4J2iRsDZhenUHHo K4u7u/JvIrTcT9nRZreAEjYhx09PSl9XjzJSRze1t1LcEbPsa+iJtbqYmQgBjGOuazyxieRYZVZF JaK2XgnHcj/PWreGh2BVPM//0vz5003eqTXJuVBkhj85Rs2xgD+FT7AVfEsFzaILGdSZwReRxuWA 2twGH4ZANf0DGhTSPzqUm2MbTUvp7eCzghS4Eb7p0O1jsUsd/PYAmslLQ29q0k7NLcLMfkhTzNyd AR3zSeGg3silWlEtyXUiIthGsOJ2X/j4jD4Oe2eh461Ct20TCNvsi72MLq0YKv8A7O0/TtWkcJBd C3WbW5iRibT5J3W23RSOElCrlQCe3tWrJHZSRRiARWy7xHs2bYgCOApz/jSlg6b0sR7aUVc//9P8 +Rp0Vwv2JXiaS3QSh0YMckj5c+h5/Wsi5tbcyG2uI0wRsbncnHf61+9TyrD1HecE/kj89WMqRj7s mWrHS7bd9nnn8yGMloVyDHGD6DpTbnSPJnWHbBI6ZcTwsrhlbG0ZBPT096n+x8Ht7JfcgWOrfzMp /YoreYtc7WCYKJsypOf8/lUmopb3d7FeXc/mQx26WyxGFYra2OcZIA/Dn0JrKWSYHZ019yNIY6v/ ADM6Kfwp4Xv9N1K90a909zptiJZFaSOKZ5APmVUHJyc44ziuf0vTZ7uztp7mVpGaMRICPmRVAwoH tnH1rnXD2Xx2gvxf5m39pYjqz//U/Oe8ttNmt4dI1eC3nhgn+0xkxgSlhxknr07Uy+uNFTatlp8s z25CWcQO+GEdPube3Wv2V8NYD+X8X/mfHQzOs1uVbvTFuSCIhNeSfMYUhxjHfA+h7U61ttCkWWS7 sILvUURRFLcoDboynq/rjHHvT/1Vy6a96N/m/wDM0ebVoPRiXGl6Fe2MdtfLA8Ny5MYWJXkiccDn GdvtnFQaT4ZgiKI80dvA8nlmXYcKnTOP6VhLgrK5v+GilnmIj9tlq+8O6XZWN+IptHv7zer2Qm0/ zJ48HOd7Llc88DrXLWHh2zvrm489rVZZP3jrsAVsY4UAYB/LpWEvD7K6j5lH8zSPEmKT5eb8Ef/V /MyGwsrYXlnLpdq8dwfs5lmjDSryCGibqrZHUfTpmqy+EdClgvLaSWcTwReZId29sk/KgXqOAeR6 V+qT8OcutaKd/mfNf6yYj+b8jHuPComu3uNPuEt7WBI7eZB8gjbacs3OTnB4H9aqr4SF3JHE7RxN cS+VbtuGCfWTA4XrXDU8OKLsos3hxLPZmjc+CEjnEVzPbxXcKDEOwhpwMAFOPoeewrM1TwNaQW6q m5L+7LMvq6qAMr6HrweOlZvw7opXUV98v8zWGfTkt3+Boap8P7O40mwlsbvVNPaxRZNRMio63Q2j OT9Rn8ay7bwJY+aZ40bdcxiPLpgSbe+a56nh7Ta0hH75Giz2S3b+5H//1vycl8C39pE91p+2JHHk akly4YTxk8FTzgggdPWs+fwtG5jgmvEQ43GJUywX1H+FfUT8NuZt/r/9qeeuIuXT9P8AgmePBUzS S3FpqEcFqgLQ2silHkIOCWAzyetN0nwVqtxqJmeBReXCmODenlxyg8BmDYAH1rll4Zzd7Nff/wDa jfEkVrb+vvKf/CN6jYx3UskK3l5JPsEJc+SEXI5Pbv06+tJb+GdatnkiiWG1idBI0YQuuG+YKh6j rzXLU8M8SleEk2EeKKV7NMdL8N9V8mXVLiNkhRtzMPuR5x944xz7mqsPhO/muAQu1Nu1Gk/dLIBx wx4rgqeHuYUXzW0/rtc3hxHhpOzP/9f8V5PCOoxXGI1byxIxl81cKAAcBW78+lPg+HXiLV5oJYcf 6MTc2dtHciFyy9zuIA/E9u/FZvgzMouyg/uZcc9wjWsitL4I1HT7i4t50ulvJTukt5sOkTY7Y4xy OcnNM1HwxfGG3t7a3na6kO3zosFIWx3PYVhPhPMYLWDNqed4VuykRabot5aDyLsXSvcgQzS26CSQ DoXUHI/PisXUtN1L7XDp+l211OtrJvmeZPn8rBHmuB9B0rzqnD+NjJr2b+47IZphpW95FLUNE11Z 2EqJboNpjbduDZ5J446dq66DwrKbHzHmdH4wDHzjHX9a5pZDjv8An2/uZ1RzPDLTnX3n/9D8LdW0 oW6mGRryIuymO5swXfOemADxxyfej+zrzas1pI6yxfPG2P3m4etfJ1cmxsNJQf3H0f8AaGHlqpIv Kl/d2zSaijg28XmTbx9zuSB+tN2TtbQeU58r7yOvIb2rkeW4hfZZqsRTezKtvp8lw90bhSZGl8yO TPzHgZJHv/Sp3iunjkt0XJiAx8uC30rP6jWS1RarU3omY8+m67GoS/eGa3eTciQgZt0PZj1z6+9W dKktodSk0PZdsiQ+c88dq0lpkYKqJDhScn+dCwlaO6K9pC25/9H8OLxdRa4MUhE4kHmEldrKqDqT 7DFYMjbbgA/dL7AG6Z6Yr4X6vV7H1UJxWhZ1SxuLN1YIHvWCT2wjYOoDKGUfXkcVgPHfzvE80ot5 E+WeJE3YP9MVXsKi2H7SLZr2scF9vdszpbn7NM5zuDgdPXj2qtfTDS3a0hhluIjB9olnCZa1+YgK cdjnr9K6aUJLVnJVkmmjjtV8xGR1D5nk4U+uCen4V5x46uFj0O8upEkaaEKggtwvmMufmc/7uP1r tpRbrRi+5xVdItn/0v46Pins0qwtpf7T069Op6eJIrWC4E0sG8ZCSD+BupxXzo8spg8qHOydwsrd XA7AmvAcfffc65bIv2GbOW3NuqmdX3mV0yq/X27V1uhX9yt8JLMwxzzykiDzxDGCM8lj0A9aynFL VGaaeh6wovYCqXqrK7RhpJoZBPErMAfvjg9alZPL2zeaqBwVMe0729+lYzV1oNtLc9R+DEN7p3jG fWre51aG3WwKzW9lMYI7oN8vD4IVugxjkE8Gvsm3vZNtu5tJfs7QiWYO++WIEDhsDk5rzqt1M2oS Tkrdz//T/kY04ahZWdlcRNLfq0Ebm3bEShhjecdA3B/Ku48Saxe6pcSXccLjzdPR2YN8k02NrEkD j7o4HHNfIVHeokwp2bT8jCtrC3aNZdQtPtkrwf6QLXJZiB93PXAq9dRXEmnXNuL62i0yFVuYrIxM svmEEMS4zu+XAxgY9a2grK6G92fNfiJLPRJS1mWtJbmQvb6fH+7t4CxJkbf2BJ6H1qpo91AQ2Tav u+eOFyBM5A5Gete7S+A4pRu2c9rgkNxbTiMwNcMWiRuAm0gDBr6O+B2o6lc+NNPsrbUJk1mfSi0U VyVis5BGwO4ytwCMBQCeQe/FexlsbY2iv7y/M8/ERk6M4rsz/9T+dHT3jutVMeqWVs8tpC11e3i3 G4YJw+wA87c5yOKi0qO2g1K+kto4JLC8mN5YbvmWVeBuPY5AWv72wc/9ip/4V+h/K2Ijdyf94Y1v EdeiuzBAsiJsjRAEaRR1XHpgfpVvUdObWUjuYkSD7KW81PL2YGcDPrzXfz2gjkSbbRQubW+mtrO0 UxQpGjxb4cpO+WLZ3DvyfyFVdviCxEUGnTKssO1riV4VnnuIx1GeOTj6e1LnN1zcvunO6dFqNstz cpbR3EjTbYrMblklDHrj+8Oa72JtQ1nR9kkSWF9Ayxtbgbcxq3JBAznaO/c1MpJlwc1uf//V/m71 gXCWKTwW7XklrcZQBtm04wfm/wA9a5a7sbvWJ7ZJyIro3kNxbRwyNbCNo2VuuR6HrxzzjrX+g0Gf yrJtyszudJsp7y/1eRGjii+0M1mrN80aKPmTOeTndWnLYXEVsqsRLb3E5Z4UII3gY598ZpuSTsdU VdXOFsrbF1PMLdriwW7eBoUGxkCnDK3f2/EV09tEHlNwunxQLO4t1aN9kcEvyhQV6nIBGfWr92wW N3UtBe8WH7Q/lPBEBJsAJiA6D+fWs97m4sFWPT1DRj5CqwiWQryCVH94+3XNS+Ww7H//1v54tVgj vIYUSISXULecWVCJwWXGCO3B6GstGvbC5sNKNsrC/uAqyx5kChlyd+Bxtxk/T8v9AHy7H80U46Gy mn3NrOkUcxWaOfdFNEv+tA+9zwR0relks2tIdNvtJlu7mSVyt6l2I/JHBxtIPPoRWXMuZg423IpL L5I1tPMsY2HlvGZhPO3UcYHpWAmipZTy3EeoSXVhJchkebDFQMAjI65P5E1XOupkoNvQsXMNtOhv r97m4sNPf93HGxgNopIU59s88+tLqo0+W8MemQ3ENi9qJre4chvmUDeM9yOuPetIzdlY0jTlsj// 1/57rPT5ZbeC6tYbnVJLiMSpeJAY0gTkbCD0/Hng1JeaVqV/JbtJGkT2PyxiQ7CCTn8yema/0FUz +aPZTuh02i6m1ydRaa+ea0s8/ZSCIlbHUDuTjAJqhcafrFs1my2/2WSRjPNM+TdShxkDk5IHoK1j O2g/Yz5rmtLay6qlvE8cEgitftUVyWVZJCG24/3s549jxxW5pdpq8cLR3tk+n+WNiGQDYwOdrM3T Jx0NNzsmWqUk9UUE0qG6upbaApbvyZQgwSe7D6nv70PZT6VaGdbS81HYjNPJFCsyogIGWHYZIGfc UuaXcv2XSx//0P5+ZtOTU7jTtQuAsF9ZTrPbQzzqEt5ePLd1yc7cZB7ZroL+1uXuAJp4TLcL55zK v7zJwXwPU5r/AEFc7bH83SpW6FW+0V10yRryTMaHYBGArMx44+nHAqGz0KeWz8gzxXbRxiSCGGVZ 7pQoyCFPORjpzU+1SMZ0HbYv2fhPUby9Oq3sVzJJFZea9xqY+zrBGg6sz4xnp79q57UNCv7hngsb 5Ht4pjPJbsTJJGX6FcdvSs3XV7XEsLOMdUaFt4dv7tYhLZSLNFItsktxGoDsRx8pPI756VSg8IeJ 7PSbi7hto72WG+eCS2t3KRugAzIhYYbHcjuMDkUlXit2XHCzfwq5/9H8Hbjw9qBikiSw1O6ls7KO 6u44NPmmIjkAKnhcd/wzUVholrZ3Ev2rTJ1kurZdqXVlLBJtPdMgZP51/f8A9Zhbl5tT+aVhZpcz i7d7f13HT+CLaWOG8tkMcVzeR588NGxjWQCXk9ABnrxSR6O6311bWIQJbuWj+1/6FvixlX54ORjo T144qXiIvS5vTotK1tR2n6RcXUVxe2u+V0QzYMX3SOCiZAyeDwOeOKrlZJ0lkksNT32480f8S6UH qQeq8e+an28Xpc6lGSa0EsTrOoy3kD6dcmGwhEkQW2Zo9pPXfjAOSPpTtStr2w8t3tbibzhj/RYv tIhwOc7en40nXjayZTUr3sf/0vwWk0XWHs7i4g0++vxDAtwltZWDzzYJwQSOmDjg4rWtPD2rD7DH Pa3wj1BFRtKawlW7PG7BUrx6fiOtf3xHEU0+VyV/xPwBRm1e2hVufDd1DdXTGyn09UUTOXtZCJQO NoABO4Yxg81malourpqNpeQxzXGxB5gjhlIjTA/5ZbeuMAqRniqVeD1TuaqLWjWpdHhfVNWvYvsf hptRAZfNF6kunOQTyYtygsR1wCOlTSeHNYs7ucyaDrdtp4drdGewlm2yDtkKeMZwT1qHjKEJcs5p P1X+ZoqFWceaMHb0Lx8GajiN7aw1MrOgkSWbSLqETHA3KjGMAsPQfhmqjeFtdU7Z9L1aOWNf9ZNp 0tqmDyAQ4B7elN43DtqCmr9roX1WtrJxdl5M/9P8KNF8K61qM299PukvYpzbm2WxnKEj7rebs2FW 7Hd2q1P8ONZuXOoSWt7FCjeWLV9Lm/fTKQ2I2KgEjIPHHQ5r+8auPw1OXJKok+10mfhMcDXneUIO 3ezJ9V+H3iy/32NvomvF5lRVu5NNktrccjd8zYIwP/103VvCPjvQ8Rt4W1q5t5CkFvc2lt51qB0L yyZ+XngA88VzvMsFL3Y1Y39UW8sxluZ0paeTJdQ+F/im90tpbjR9d06dGVmJ0qeUpkjnKKeCO4Pe l0/4a/EW9uru1sdDm1K1leKK2+2wS6ddbQoy0TuoQrkHgnP6YylmOCS1qx+9f5i/snGyfIqTv6Mn l+FnjK2kn0rWPDPirQ7iSNmguG0d5oHC945RlTnH3uQK4u6+H3jaweIQeHPF98HBleP+xpJBtyOV fA3Z68VnLMcE7v2sbeqIrZTj6cP4T+52P//U/Bi28CeIZXl1A6PrunPDsMMM+kyAzAna2wL8xI7j Fb1r4H8QJcbl8M6+y3lv5isdFuSybSRuZAhIHBr+2qmLpyejP55w9CcbuQ5vBfiiezu7O70nWbRV JVHj0a9hZsj7oPl8HvzVTTfhT4vsZd9ppHit9KdUg+2TWTwB5X+8Igy7n24OW7URxcFFK51OjLqa 0fg/XLS9mtYfDXiG/njkFul0NOeZpn/iQYGe3pzV3U/g9421S/glg8N6tb20WntM1zPp80cUsh2n y/mUYYYOR/PrVRxcE7pjdF8nKyt4a+AnjPxBYXdyNEkl1DTVN5LDbq0sqx5bkrwR0xjB69qrxfDD xNPOumweH9Sspvs7XBnvbWS2aMLn+Bly2cHgc+1KpjIOpa+pjSw0uSTP/9X8Ix8P/G6KlhL4W1p9 QkJkYSaZPbW6RgEiQO6DIwOuMVd0b4WeKJfKvLrw7rlrctKI7cy6TJKkrHO1FYcc9c9K/tmWJp6O 5/P0aMlK7N1/hr42vriYXPhfWY4rUE+aLOS4FwR/BtUbsk8dKxl+E3xAFxbwL4O1y0N5m4DPbkxw IMZMmM7OmNrYNP6xT7mqpSexch+Gnj/y/s0+lao0gn2H7Hpc0qCMkgMwxWbc/C7xhpMhB8MeKpYi zStNHoc/kv6N8wyAe3Ss3iYdDWNNpWFm8F/ESJVjtvAvjZFVBNdCbQZVtGQg8Fgc5PGDjHvXRHwD 4sl0+38jwvrUGqXEDbLKbw9cXMkaYzx8uCG2gZUmpeKh1NIU3c//1vxF0r4X+JWtzqMXhfWZTbsT qFwdMlhgsdvLLIXAwF9/Q1Fp/gHWNdvNTkt7DUrGa3O0Jbae88F4WO3KugIUcY9Dn8v7U+tRtb9D 8R5JA/w+1/ToJol0LXWmEvkRiHSpZxKxPJJA478Hmov+EO8RSQFH0TVgYozHEsui3MRuXHXrHgc5 75pKvB7Mz9k09ENj8AXyWDxXVjqBuS2JnttJujEJCM4UMnQYxkccVmt8Pb+6s5DJp+sqlhIslvC1 k8Ukjk4ztx2rX61TWrZtSpSaaIZ/D+vfvkTw/rqS2a4lhbTHR5B0+XPXr1qzF8O/EOorp8T+GtVv 7u0H9pWlskIUIAf4pMhQeemaaxMHqKpSadj/1/wov/A3iFLc6lLot15Ed4IWtYreV5c8HG4KQcem T0q1p3g7xHqf2WX+wrywR5vIt1vIjbpc46CMtgE+x9a/tj20GrNn4fGm09CCfwvq2oGT7PZbYrSc wTCdGE8bjjO1QePes7SvDuvSNeSXdneW4Sd47O4a1kQSKMBgPl//AFg0SrU2ty1TmzYsPDGtyZiT T9Qu59zfZibVraFiPQvjP4Z61zt1pOvn7THqOh3to0ZAcRKboOM4P3eh9jzWTrU11B05LoX4vDWs axcQGz0HUWggiVZo47CSd1K4AcgA9SKzNRs2ZjbPpmrW0sLZkmfTJkjbBxtHy+1L21O90wUJNn// 0PwQl0eJoLZ3+1YkjJkt1tZWnjx0Zl25HQ/nWkmg3EqpbJY3zqUB8/7FK0G0jIO4A9O/pX9nyq02 9GfirhOzViG48L/YopLZkaS5ETSIixySFlwcLkjr7Vnx6Fc2tsLJdK1GW5mRZWQWcibA/wB3OQOW yMDqazdamtLkckloWtL0Z9NtUjWxv4PtE0jyQ3NrJHJA6n5g5YcHpgZqvLo0t9eLLJa3cT20ZdTJ C0Y2nr+P1qPrEb7iVNkF/oT3sLJObs2ch8uK4FrLbqrgZ4kYBWPXp71Sg0G5SO0tiNsMJLqQ3muQ Pp3PpSdaLmpJ7XIlRk6sf67H/9H8D7XRZYry6hgs5Lkw2pnvHaJp5YkYEAKgUnPPTqOKz/DPhnw7 pls1hYJLb3d7dtPJPd27QTE5OFJKjGMnrX9krEQXU/FPZMltvD0M+oTxm/zcLIzMyyguxHUknvWv Pouqn7JOkytaSzCFYp08suvQsCefp2rSOJj0ZXstNihPptzb3KT2UBigaX7LcyRIS0jrkY46jkjP TrV+z0PUfnvJdBu47VQ8Mc9xF5UW885GDknvQ8RB6NjjTa2MbRhBOLjTr20NvfktIlvcbhMUySCm eoI6jnpUlp4eltY7i8t418mQDZ56kSQ887B1PasJVoN3THytdD//0vwPsNPu9TiuILbz5Ht7j7NM VUpKHHUAEe/NYWspc2l00MMF7PPBaGS6lSAvBEFbaFYjgMSeAeTzjoa/sl14J6M/FVGotLG9YWGp SpAGt8JKm6SOZTFLEMZB2kZqW68O30kqzRQzI8a5YIG2svYn296xqVoNWbCEZN7GZFpGrteNHKrl kTe0CIXkQEgBsAZx7mpYE1+yvo7nT/3sQO2XfEXjkUfeUnoOlRz+Zo4tEyS+faX8r2kphQlpbgWn 7lCOoV8dvaqMOnvPA7W+11EQcIrjdj14p877k2P/0/5+rnR3siL67Yt5sSstqAfMhX+8wI9/wxSa hpD6lYxf2eUlaFy88UZDSHt+npX9fOUujPxuPcqR22uOotLhCi2oBkZFJMMR6bj2zzirlvpMml+d AZL6Zr1zdwC4QhUUgD5eOncc961pzsrXFJdbGdYaFqd1PdXCXhghjRnWVmKxzOp+aM47/wCNTRwC S4ngMNwPKQCQk7ixI6g+/Nd856aHIk9h1pYQXEq/ZxKEikKMZY/LBPfnofwq3LpMthJe3jQyXFvt VbdomDDeeGBGO3H51kprqDTR/9T+fqbw5IQjhYVuWk/eZBMiLjPH+fWuajh1X7VJBdQTKIZTEjPE VjkAPBU9+lf2fGau0fiCizeghmluYIFjJBbAST5N2OWxn0q7q2nSzXNojzwqwG1IT8smF9PWtOdj cWlqZM/22wL+aoWGYiFF2CWV/TAwT19KfFpeoNCCIm3HLlVXLsB3x24FJSaVkSZ9tLKWlSJS5DYf ZzjHr6V1WlapfTWS6fLpxSZ52cFh5p2jgYPYY5/Gq5/ID//V/Aa6jmubueyS3wzMEtewBIHOfr61 z0NvfadcJJcyBj5m1A4C7WHXFf2rzqx+HkmqkS7G5CoMyOeM5P8An86ktk821eyUDDc5I5A/+vWa dncrldthk8e0CBFCtFwgP3eKyZp55dxEJRoWwxXlPzq+fuWoySJ0mbzLW3nQyySKZvOwSsSrwVP5 /pWfJFeLdXEyyI9oz4ttg+7gck/X3pOTsUlZWZ//1v50F8jUVSMAx3Ua/vHU/K30p8ljNcw2OnyW wkjtd8i3Wf3hbIwG9e/5V/Zzkkfi5bitUjV4W2xsVKpKOSD9KoXKW1iZLe3s5J7i5tvJlvJU2sjE Z3KR6c4rJvW5pT3Oe0uxMM89lPAbsSp8s1xFvZfbpitxbea0hYGCIThmiWRG6JwNu3HBqbrY0sVx ZW9+kRkuJorqByBChHlyD/aHetS2068sUkezI3uD8o+8wPXNMhwW6P/X/nDjthLd3EepYVA2+3SK PfuOBksfr2rPOnJYHzIEeSOSQyIcEKOcnP51/ZB+OxVkX47iOV1cW65TgAAZBFNlvYmjulkibCR7 ldeWz6Y/D9aqHxFpXdjPsMX9u7sHhiEm2PPDNg4PH4Vp3lnJaojQqzxkDnrkfQVsUly6voV5lW1j TCMrONyrtwKp2/78ZMLCMMeCMBSPb8KuGl2ap3R//9D+cizjSW4wkqQlEJVnbYCQOmemTVe8vQZH An3P0bHzbj9fWv7XSstD8kcblBv9LjeKGRhIy7SrDv6imPpGqwhbaJreVmtt3nmXlCRnB9/8KZnZ lXTdLuGuYnuEVLqJlLTRNlvlPKgnseas6nBqM+orNFOZLVFYTQsApDjjKnv36/rTSu7ETdotlu2e BAVuYkRmTkgfOfaq1xcBI5I7NYN2QXDDLqpzg469qHD3rDhLsf/R/mstruZLm3eZ5VhjGJBGo2/U 59Pb1pLe6SbWk89Z2gh/fmaNN27B+7iv7VnCyZ+OOWtkf1H/APBELwl4T8baR4i1TWtB0TWi6tc6 ZNeWaSvp4h/d8AjgncjHvkV+n3/BQ++1r4b/AAS8U6h4IubrR76bS3WBtOjMUEUS2+X24+7nbgle wr+Z8c5YrxPeFq/w+e1ulrn6jxFUngvDqniaHxqF/nY/h28V+Lde+IOuDWvEt9Lqmq2okYzvLIss fntvYMCcHjaDjj5a1vB3xA1T4ea3Z+LPC+pXdpqmksrC2tWVY7jDZxIpHPGR16Gv6Hr4WjUw0sNJ e41a3k1ax+YZdP2NGE4OzWv3H9F0X/BTnwB44/YsudG8UX6f8JXH4fewm0P+00i1O4mSNlRWUtkp uHX0I4z8p/m9+0X3ivXtSnjsLoy6jqb/AGey2B42aYmTCMB0yxHPoa+W4dyeeSPE0pfBzXjfS6On HYr+0s9eKimv3cY/PW/3W/zWp//S/MXwF/wTm/aV8d+GrLXdE8A3MGg6xiWVRa3E9/NGefMQIh2q exYZwRxXU23/AASm/aLhiuNP0/w/E0Ul60ssk1neStACMlHzCCxyMcep6V/UFbi3KaT+K/TS3+aP ztcP49S5Jxs1v/S6lG+/4Je/tR6fZLff8Iibt7dnnksYdFvITLHFltkLuvDEAY3DkkYzXwj8RfA2 qeEfEM2h+INNl0y4RVeSG9ga3uI26FJAwGGBUjHtXblGfYXOZThhnrHf06behhjMsr4JKdZWT/pn tHwN/Zb+KvxlS9b4ceH7nU7eC3cGJbV2N7Kp+6jj5VHbLHr2NS/FT9lX4w/B2K21Pxr4C1zS472Z 4mhNtI8lvsCksCyKGGDk7ScZHrWyzrBwzJZXzfvNF5XsNYOpHBU8XU0jL9dvvOu+GX7F/wAavivY X+peDvDg1LToxHJb3KebKX3IpeNo1jLF1J/h4GRya6jV/wDgnv8AtI+FNJ1S/wBS8BeIIFtIzdzX b6FIWgROSGAAwMA8kVzYjiXLMPi54OrJqcXZ7W/M9SlkeLlSlWt7tr9f8j//0/55/GOj6/4e11tP uI73T3s2WK8N1aNE8alOUjcjDZyBkZA59MV6R+z/AB6dL8Wfht+7lYN4tt7sTo+EASQblYH1OBX9 gYpqeAdWL0cW19zPzjLZ06mY01HbmV/vR/oOfByU3PwR0L5TamXwhaXEPloR5UkiNnDHqAAo/Cv4 +v8AgrFf6hoP7Tza3pzT2mpaRolrdWf2YCLzZYnJ3ls/L8wj5/2q/BfDWmp8R4mP+I+v8Sly18NV T05v/bWfpL/wTb/4KLad8QPhlrPgL4tXUltrmhaZK8d/e3scsTqIgjoSWDdcYBBHzdQBX4N/tqeI NO1v40ePNYsBLqOga5rksltHblHmEQPlwyYz91lGcA4571+hcLZFPJOJsZRt+7kk4+j1+/o/PY+D z3HxzLFYWu3eahJS9b/rY+SYkGlwRx2kswtGYAkxA+UD6gdAPavYfh38NfF3xL1q20bw5o2qarJc Bju0qHz3jVULbnHGBxj64r73GypYfDTrVXaMdWziwNOpXxSpU1eTeiP/1Pm74I+Pf24P2cfD93pX hjwX4uttFXT1hRbzSJlMihDEjCNFxnGBuUZ4FfD37T/xa+N/xH8QWd58TrXWbSCxf54tZklMzyMP nASQBlUE/qM1/SWTQyjE59LMcHO9SS1XruflubwxNPkwmN0UNYrvpo+vTU+TYLVDczyQSbYZSDHb hMFHP3gB6Hr+dbS6B4h1INY6LFbC4ZfOmkuGKxxheruRnoOK+xxDjTab21f5CgpewbXl+p7tY/s+ /FG70S3L+CvFsaXMCSR3EcMcDTxyDKyQhxuIPY47iuN8S/Az4heFZ7mS88M+I7MJponEuo2QEb4z wXU4z36d64YZngatT2MJpy2t6HPUUqd3V0SXUq+E/hJ8QvEMunyaL4bu9Yt7iIXF5d2yYjiXI+Qg ZYE8Y4qfxN8Jta0rWvI1y11DQr2G2w2n3o+zDBY7XCsOc4PI/un0pfXcLKq8NGa9olt1/r9NTVwq RjGo17rZ/9X8W/B3wZ8ReKbe7n8PaDrF3DZym3kki0+RojIoUth8bTwwPBOc964/xL4a13wr9v0v V7S70rUoI3kMVzCYjtJYIwB5w2DjPoa/rSGOwtXEPCRmnUW6PyqtSqUqXtJqyd7fI4zSvCWq+JJT Z22mz6reQ2wnkto42aWRWIUkKO+TkDv0r0K4+FvjLQbCL+19H8QWWnpIYhc6ppE1kIjtyApKgEcc EmiWKoU37GckpdFfV69jp9hOX72MXbTXpscDbwRwX39k6pFJBNMhlt5ZE2xXI/h289SMHFeweGvh n4t1qCO60nRNVvYzxGY9PmJjGMhiwUgduvrRXq0cOlUrNRVupWEpTrTlThq9fwOR1vwV4g0TWbTS dQhmtdTu51LacQUvNjElMoRu+bHYd66DTvhJ42vyLtfBviBbeSZozK9kRGAgzv4z97tn1qZ4nDU4 qc5pJ7XaV/TubRw1Wb9nGLbWmiP/1vxT8SfDjxDpUEGo6hpWs6TZIVxcSWDpCuOzNjHOD+tedRSu s2oB0kga2ka3wyECZCv3h9Qe3rX9a0KtGvd0pJpdtbH5ni6U6KamrO3oWtD066vbtbXTbae8vLrP lW9uhkYgdSfQDIyTwM16ZD8NtclSCNrC5e9kdQLZLWQYzwcsQB6/lWFTE4ejLlqzSfm7CpUpypxa RU1b4c+LDDKbfw34gsTayeWl7daNILVyDglWxyODXCf2TeQXDGTU3Lwk297ZzRFXWVDzjPIrWnXo Vov2UlLTo7mdSEoVFGSszPuEkMkyIsqKqF5ZSpEePrXfeE/Avia9W1mh0PUNQs9Udora6htXWBUx tJDgckE569qwqVKWHp89aSS7t2Q6anVnHkTb8j//1/2i/wCCZXh2Hwx+z34a0qWIJdGyie/gltyk rTKmGdiR227T/u18P/8ABZfR77xF4ZS2s9MkuLS3uIgj2Z2ruAQvnthgjA+u6vreHK6q8d1MTVej nJ/e2cfG0fZ5LhqdLXl5F91v0R/MTq+geINOtt+raLc6ZbSZaAMoMZQd+M4/H1rnRPHb27SFTKmw qgX7ykjAPriv6BioyjzR1R+dKbcvkO09ZVWVowXnmTMMOa91/Z58X+OPhh4x0n4m6XpGpapJoV2w ga0t2aCwYyRswZSPnGEww4wSOeDXmZnRpVMJUo1XaMk43/xK36nThatSlVjVpauL5l8tf0P3Y8Vf 8Fd/GU/gK802Pw3cabJLo32eWW7sma4EgUD92uSTnqdxHXqa/n3+Ifi+/wDGnirXvFmozPqGoa7q 1xqbzTDD5uHDkH0wQB+frXynC2RUsnpVVTd7vdO6IzDEVsXmCxlffbt5/of/0PwtVrpbyNGUr9qO xSsZKcY46cV6TY+Fpb+6jtWltsvbebCioWfA/ibsBkgetf0xK0XZn5zBt3RHY+GddtL29g/sxxdI DA0bWzbhz8uCwGN3GCcVLaeF/FJF/wCboFzCtnh3ebbGxycHjPQdz0qHUpJczkrCjGUr2Wxkaol/ ZTrpN1YiyklHnRT3MRT7WABkQP0cDIzjOKzfIt42UzEG43bYV/ikb+6q9yfSraTihxvdI6BtG1qJ k+1adeRwqqvP5kBiaIHkZB5z7Vg6tEwuDE8gjjlIMYVBvVeOgFNOEkmnobNOLsz/0fxy/wCEXvru CC6Gi6g1mIghvItOkFvsH8bMByPcZNYWpaLNH5Nw32mNJIwYJpInSLaCAMEjHXiv6W5qbk4pp20P gnGaipNNJmjaoY7SW3mEtxvgI3RnyyrY4J9vas1LRY4w0xmeRRuWHYXcj6CtVC6MVN81i4jQXNn5 ctmAS3mYddsvsD9MdKsqrWZgklYeTLwqq4bOMZyOvf8AWrUEVctXciXasVCRrHHk4AUsB/M1nWro JlG4qE+YtjIPPINHJESlc//S/Ie8ubV4YRaLmVgMGU/Iw4z8uOKzZLaBbiOAoYxIMtN95FPfiv6b cNj85le+pUAFvZTRsWUvIdrxDDsvqfes610l1tku7ciRZ53VQxIkG3HJH4/oaJQsiS0t0yhbGdAA W2sD1I71bh1CCxa6kt45S6YSOKIHp04rLkVmiZOyLiWKPM9ygyZkGVYcr6/rSSQvAjo7owJzHkYJ z2rJporof//T/Gawu47bUYknmMMUv7o7Y97tnjC849a6mC2WIMBNvcDOM8mv6UjFNXZ+bmXdwzxs xWRnEy8ruz5eOOB2pmlSR25kt3QyXM4+RnTcABzgUOHYC6ZPLYxGLYx5K4xn8KZZQXryTNAWhUrl 1J3R4+hqVHWzNKZZ+yyOAzfMynkgYq3NGs/leayWqwRbSFTiQgYBOOc1pyRJlqz/1PyNiiiUyMmX dELtt5Uj1qrDkq10q4KsQUzzjmv6SlBLU/OE7O5FJHFcoWjfyyTkheM46g/liq8Vr5kDwkvkSh4m wNqAdR+NRyraxo5aaGxZ2ShZfNK7l4Q+1W7dbeCQvKruyDCkdPpWkYXRm3d3Hz39tcSqvMQgX5FZ snGe3t1rL1KwnumjmiYmCNdxC/x0vZiP/9X8eLBRDcPHKjmaVcRHnaoB5wavmzeKZvLRv3v35F4I +tf0nyM/N2tLG0LOZIvNix5YXkMOfrWNNqUtmfLtmEhu/wBzcID8oQnkn6f1pqGmplVdqVi1bQxR YLFt0h3sV52iobxFjnkMcjtbugEZYYkDc5ORWN4OJHJLlNXR7LURHciS7woi3IGOx2U44znkjrUS o5mmWRxPKMMWB3bR/tf57VN4FRjJH//W/KKBftCSWrYRX+UMvAqRLKLTLiREkdpEUeYd2Y1BGRj8 6/o28D8zcZkDl4p4pVJeKU4DDqM1I5SK/wAECbcoCSK2V57UouOpu01EstDfwFZ9m+yWQCeZiPl3 Z4xWfq9za2k87wQ+fdSFCZ4pMxIoHKqPXkZ+lK0OY5pJ31GJcPcQhvK2jH8QxmtbT0tJIZ7qSWJH t02uu4KG5/zwKtcq2E01uf/X/KOe6lVPPtox5Lq0ezG9RkYHX0rI0e6tUihtbmwSa7tZdzz7Dt3t yCo6DGeCOlf0a3G9+x+ZwTR0FzLaNbNGtqHvZZPluNxygxjBFRWf+iRO8q7nQbvLY8cdamUr6GhN cavDdTq9vZm2VlCKsZLKSBgt+JB4rRj0+0jksJBcw3husme3BKywYbBD/UcjFVzRtYaV3oXrbVII 2vrBbe1+zh90TAH92e5B7GsuTUQ14kCPuEAJjiIyhJ9P0pKUVsUoPqf/0Pyxk8u+aSK7ieJlUiNV OCX6DPtWhp9u6QvlUYxR+SoXg5HpX9HxlFao/OuRkNwlwyhQhYj5zH347/hiqEdwY0M0PyEffxxj HvTcot3Js0dZpu+8tpZp2VSEyI3HL46/jWbG91aPJ9lne2jkzlo+CrHgMPpzUPl2uRZ81wggMbjf dPO7rua4PyszEc7veqsTlbtlxujQnpzmm3HuUf/R/MhNUsLW5hWV5jNcOU8tIiyKAMgk/XIq9NqZ nJhjk25+4D7V/RFknofmT5nuie/EmohkvC1qHs1zLtJ81VATI/75zzVCG9g0j7NBpVxdzW8Sh7kz QCNpW5ymM8jpyaSSWxLbejL9pqbvObxwLWbb50MbDJ+U/KAvTP6Vz0Nx5d1eSPd5up5zcmIHEozx x7DGKrki9WNSa0RSv7Y60JbSO/uFuARK5t5P36ZJ4Pseamt9H1mygNsssWzdvuIZ5ALjavfHXJHa s/ZxDnkf/9L8tr+FbW2EMtwU83G0J95j7CuotbWKbRETePtUa4LqMecMdH9Gz6etf0RY/M4bDdPt oraItIqqQpUHOCMn/wCtUt/ILSA/YiYJXRXYAB/M6ZPPr1pezjY6qUmpIntZrd7dXJDFlAlRvlZv X+tUbC5hbUpoLlDFBEAYohwDkH7p/L8qzdGLZnzyLpNq8rW7xyiDd/rQcKeueeoxVhA0cANmY38t tqq8n3sdcnk9K0hRj0Kc2nax/9P84tRb7W8hulSwRIwFNo28nA6nPripLaV7q0aGz84vF8jlYyxI wMGv6N9mkrH5y5N6EcGq3VoZLdYJLaBgPOd2K+ft6fKfcGtSCZmQX0UQ+d9qyGMOjFfY8HGRSVG7 0MudbMy1gId3neUKXLSSsOFyfSqluG+1O5C+QoCqw++wyatUWy0+qNq6sZZkt9Qt2eARsbcTgbkI I5Q89xUkjRw2484eYXwkbxIQQepzj8afsdCXJJ2P/9T8+k8QWtzBc2t5po82O2EGntCRt3Lj95Ie vvgdadpU11baTNHPM2pMJWuNjxKgC9147KAcZ/Ov6LdFX3PzlT0Rzs/iDToktEsy0moXEzMz4ZDb ooHHIxnr+Vb9uDIscgbcJgGdQ2HI7/Q9aSpcuzG56G3Z3lmsF5oF+Wt9Pu2SaORl81raVTuV/wAc jJHtWVdPZfY7iH7CslzPMP8ATyP3pCZwAQehyevNP2buY86KbNLdRsDMsCQQgMOAkYAxmsWeyspp NJurCS6SGAulxdSPv+1FjztHoMDHNV7PoCn3P//V/PqBbmFN8RkRNuQSCjHtz3rOguJITPHDCsBV g0mIwvnZ5yD/ADr+j4wsrH5i3dliCaWO4M4DGVkaMGN2XKsMHI9etaulX1tbSLci2JaAEMl2pCgg HBIPX1p8nkSYV81w++5ieNTdygPMyblj54Kf571pW0MD+Ws8cSHO77QY98nuw/8ArVTg1qjoWpUk nl0UyXDyJdWd85tASwZCGwvTsRkH8KlvltVtkjRXabzMNsAMcfcHOaVn2I0d1c//1vzs0yw1C7mu PsLEC0XzLy5LbY4F9Wbp34FZN3peoPJbtaXSNHHK7XRmUlmBORjHpz+df0ildH5e10LsVwJpzaWy kSW0Q+0O6lQ59s/0qfZcLC8CqYJ1kyCTnKkAg+3f86QDtZFzBb6c0jQHcCWdSC+PfHfPrWfp08Mk +yXLozgEEbg/4f560mk9yrNK50V2lhYxyiC1tLd76RTLOkYilyThVYjgjp1zWTb3F6skdncBIxbT ExG2f5ZxnuR1/CpcF0BybP/X/Pm4gj1C6M00aRyJHhWC4zgD+eKS1jsbd/NtAIZoSG+chw79z+Pp X9H+y0PzWE9TRvLiyt4E1JZnj1GdjDJC0Y8rgNgq+e47Y9a5XS77QbWTyUuYbp3laS44JS2ckko2 fSt4UdLBOXQ6q50+3WXzFWKSO4jWQOqgBScE4+nT86wbh4d5Dv5qRviJIvl5HAJrohTMG0tym87g yJ9nR2dNgaQH5fcYP860NEgt5GjhhAa7hJkuI9u2NlwDlT3/AIs49q6IxstTFK7sf//Q/OjUDaXN 1byW6ThndgUuIjHDFJGxXOTz9M47/WpYo4tNKXkwgV7hiHCkP5hUY5z1xngGv6otfRn5ORyR6XfW hsfLZXe6E+9H2GYjGFPtxWzqVvp+m2gltLFzfmFVGX8xYWHUgf0pcqT2Li9UihYPDfx28+sFr3Ur ZmYXRXZLKhACAjoNuMe+fYVRuZxFqsE+rTRG5mbYvkkNDCg+5x0BAC5yM561ly2VzvhOy0LkWrJE JbW1uDfWYdvOywdZiedpxxgdhUaX0xxNNbwRwoSsMCnAXHGcfTFQ4p7lc+h//9H869Ye5uRLFBHO NK8uMs8cRRFfHzFj9ax5raxt1t7tyHV5DCjnk5UZYAV/Tjpx6H5u567lu2g0twbweY904/dJKAIU AJydvfPvVu31Ox0y3lvbm1mnmtB5kCD/AFbYPQ9z3qVSXVGU6ja0MNZIL22cskEDXl0W2jiaBf6Z z+la/m2ljLDBAkF3JaKNxGWDjGeSetV7KBySqNMxZNXur7zLYRyW9vJNuezD7hJtJAJH8qo3U9rA WjhhnlliG2RDAQYfYCs/q8G7W0H7Vwd7n//S/MjTpbK8tmlN0he2UyPZyxsrMg4JDdAc9utSaXeG bVJDCCLSGBRIjLkA56bv7v8AXFf0wsLTtax+TrETQ29uLnUdTPmRRRpOoSOKNQEjCcZz9MU2SWOC Ge2it42wwcSOuZMgEfe9Dn+VR9SpdUH1iY3SdQeOxv7KSysjLOyyxSS26yzRbf7jkZXPtWdbI8l4 17c28Fq6qbcmJQJJY+mGPv6Vk8uw7dnEccVWi73ILiGDzwkEbyC4PlPFEBmQHsKrXhiuJBbx2Mtj EuIzHI/mHjg81nUyvCtfAvuNo46rHS5//9P8q5NK0GWdtPjS6kumjjaJpIwUZifmC4GevArWg8Ia LbPKk4bzBGSI4JkJRx/C+QcY9Otfv88kwMt6cfuR+aRzKun8b+8x2sLXT5/NlVJIjOoIQASNGOoJ 7HtUmmHTNR/tNb7SreGWC5SXSFjUG3ljyd4mXqT09q5Z8N5fU3pr8vyZ2082rxXxkC6FosKT3kSJ dXtum62hTDIx/uFfTjAOO1ar+FbawmjvtTtEVb62S5VLfCwxKy8FQOOuevpXBPg3K5S0p2/rzudk M/xUVZzf3mA2j2ksV48cSPBfxG2DvHtIAbPynscjt71nReG7byFuEuXthZsVkWNVDybR245/D1rC XBeWy0ULfJf5FLiLFJ/H+L/zP//U/KSDwlp2s6BLcTanpllqMEv2mzYRyreuBjIYAbSCONjEfhWb ceDdPluxJbqzbokWKBgNpcAZI78nnFfrT8Pstk/hZ8kuJ8XG9pFGDwglvLfT3ds0M0qLsN5G6umw gAxg8DoefTPNZN/4ahubwvDGkTPEp3ttQSlEAZj6k4PvzWcvDjBNe5dfiNcWYmL1sTR+Boo1XUYZ jBHCC09lHAv+nMw+96gjAOfeqtx4Ne6luLqFhE8yJGYyDtcL/DXn1PDZN2pS/T9GbLix2vJf195h 3PhPyXunWCSeaGBoZWWAyrblgVzxxnnj8K+aviR4at9P8N6vLc3F1bTRAyPMQdzR5wwz0XJI6jGK 8qt4fY3BYerjqmipq9tNfxe2+vyOmlxNh8RVhh47ydv69T//1f4utY8LWkvkaxa6neagTcmR9Ku4 GCyAA42N37ent615rc2raTeztPC8Mc8g22oUlYsn35FeO4NVGdk17qZOrptkRUEYIwTjO6rmjSWs VwxlCmQDy4kPyuSemPXtxWVSOmhzR+M9lg1S4ksrAXNvHaSMgUKhw0gHTcvrjrWhbG0unuFuReQf ZwpUiHKzu2DhSe3qe1cgT3Ppr4L2f2i7h2CJsXKMkcvzRsI8f6wdOSfyr6Pnuo4LuVYDEhuQVeGM gIACCVUZ6dPyrzcR/EZth9z/1v4+ND1XUrOaBtQeaDRpCIYUliz9okUYaQnqvYAe/SvebnWdPutO 03S7fSLTT7VVDRXdsrTXdyW65+vJz/KvkKi95MypSat6GB9u1PwVNa6p5SrHPcvHBbzoHa5A4wVP Zsjr6dq57U7+/wBVuLgWsZ09Cq3M629qEt15zsUYxg+3St6VuT+u5rrZpnz7rXhPVLy8kc373klx c+XsuXDeWCc/KAOBzXLSaPf6XcMnlwMluCN+4tPEQcMQOmOK92n/AA0jKEdXctTrHqkkbyTS74E8 sRSDOzpyv+Fe7fDOayGoaa5P2y7tbuK1e4uOESMMjeS44z/DyD/Kvcy/TFUv8S/M4sVTSpVPRn// 1/57dFtbeVtRvLazghlv4m01oo4w628RxuCMcnHPX619S/A/9lD4lfG2dfD3w88NQ31xp9jGReiZ BaMzsRtD84OAfble5r+2MVmdLLMop4yq7Qilf7j+ecmyavneMq4DDRTqPVfJq/4XPs2X/gjx+0/B bxTXY8NiR4hLqEdpJBPcWRB4XzHILMB2Qe2TWhD/AMEiv2jPKvY5tDsr+waIz2sst9DYXNwQOI5F 34UE59+lfJLxPyyd4xWi63v/AF959D/xD3Gqv7Kb166bdP8AhtOnQrS/8EbPj/c/ZdT0210yw1C3 iFydL1K83RBtuCpcyKCh55AzkdaX/h0j+0VsS7vNL0SzgLLHNLpOpW8qE5wSoO4tz2zgetaf8RMy 3l1Xveun5HQvDzFxfKpaen/BJtM/4I+fHXeHE3hKC5a5kuNVeDV1vriygGFjYxBTyec7T3HFba/8 Ebfj7M19qthq/hWOPyBYW1ld3oV7wDJZrcBQVbI/jPccVj/xE3L1ry/jb9DaPh3XentEn6X/AFP/ 0PHLD/gjf8aIdOsoB4p8FRSzjdOuoXC211aZ5MZIjYMRzgnH1NSx/wDBEj4jyT39+/jrw1BcLCN1 1FcLrNwMHLgQvCVHbG0A1/Uc/FHCxu6MPvd/8j8wp+HN1epWu/JW/wAyXS/+CN/izVoNW0zTfF2g 2NzYbYItSEU+myXithnZEEbAbiGUquMGt/R/+CMvjF7WZdV8X6Bbot1uVLW9ubVbML8u4hoNzf7x J/GsJeKkXe0F5Xv/AMC51UfD2Mox5p27/LTTTQ2Jv+CKviqxsoodL8beCUtYZ/Nu7m6u5pb2RHbc 5Enl43HJxuHfqKH/AOCHF9f7biy+JlvDPJfpMyQ6nJf20RVPlbJgTacgevQde2f/ABFSyvyJv5/h qdEvDqhL4qll5Nfjp+Vjr7X/AIIlz3Exsbv4uQ20n2UHUVDjzZWPAAbyeF46DnmqWn/8EMrGLU7K aT4t/wBnxW13I/kW1jJcveDGFB3KB1GcsDjtUf8AEVUt4L7n/mX/AMQ7wiWtV/ev8j//0eqk/wCC IOnG4sJr7xnb3otLjzL+eyZrdr4HhAypEpO3gHPoea3H/wCCI3hUymWHx/8A2fezHZHbWYmitbkK fkEh2HacZ6cnNf0XV8U3zJpL0t/wb/ifHrgLLoQa59e9/wDgWKR/4In+F7jVbubVfibrGj20FssM cOleHJIn889T9pZT5yEAc8EE11L/APBFr4dQ2tg8PjnVGvbaEyTyv4dW3Wd1+VWkMu9XyD3A+lcd TxSxNkqUV62ev9eRC4Jyu7dSfyvt/Xnc62f/AIIofC5IrS7t/iLr0d7cWyQzRPokPlXIIy4VY0Xa cHrj8a56D/giJ8LNGZLmy8X+IZzBNxYz6I1vBKmTujJztIOehbnHWuN+KGZJ6L8P80N8G5Nf4vx/ ysamh/8ABFn4XtP59v4p8QRt9tae4sjo1l/Z33gUQLKjPgc87z1GMd9qP/gip8D4dTkfUPE/jyS4 kuGYtp2nWtvpitJnJZQjfLz/AAlRx0FYvxPzhy5o6P0/Ta5rHhTJFDklLr31+/ex/9L61sv+CMXw Ls10+HUPFPjl5rdnwIEgS0vNzMUXZg42j1zmpbD/AIIt/s8R2dzYahfeLZJdS33U101vBbOroSYx kHaDg9W6+1fuK8Ts7asv/SV/kfKx4WyBO7/9KfodVo//AASE/Z20MZ2eJvNnsBaO13PBev8AKAN6 jO3Pt27Vcf8A4JB/s8zW8Bhj8QXt3GyyLfapdWwW3TOSqJglOh6YPvUy8S89lun8k1+R0Q4eyGlB KMIu3fX8Xv8Aoalt/wAEnP2ZpRY6fqug6rdC0u5DbeVd2QSNHOSSAP7wzznr07VYT/gkb+y5vui2 m6idNsphMkc3iKyAuXwVdZFAUjGBwR3780peJGe3vG/4/wCY55Nkct4R+5GrF/wSc/ZWeyha80K6 tZgrgyjU7GKKGMZ2KeOcccj36VXsP+CW37I1veNFL4Vsb29W1Btre816yg3nON+4L6d2OKh+Iuf2 s+b8f8zKWVZEvsQ/8BR//9P9L77/AIJX/sYaTqkUj+CtH1NrmIK9vceLLf8AeuQc7Ezn5T2XA46V Pff8Ex/2NXsZNJ/4Q3RLMMI2Edv4ks4NRyr7x5cjl2A4wSACRX7R/wARDz57c34nyjynIr6wj9y/ yJI/+CYf7HdoXvrrwp4duNPji/dy3PiyNWsnPDY6R46fMOa0E/4Jy/sVLZyGLw94Umi3AyXN1r9i 625I6JJt3Y6fxZrN8fcQPZy+9/5lLKchvblj/wCAr/I0LP8A4J/fsRx+clv4R8GzyXNkYZfM8dGe F9uPnwXYKR/s4ArL0z/gnv8AsO6M12H8O+D9VjmfdLLrXi+K5gXn/VnrsA6ALiud8bcQNP4tfN/5 mqyvIm02o6eS/wAjasP2BP2FrFTK3hP4bQXTTtNcWtr4z2iBMfu/lLZ5GOAB+NVm/Yq/YCtg9xF4 e+EtmbnNvLFP4yIDkHkK4xg55IFZPi7iOd9Zaq271RssvyKEVaMVbVaLfutD/9T9c7D9lD9gi70+ 7tJ7b4Xx2kMPkXMVt4yaNY16Bd3HHGMZrJh/ZG/YDtZ1WDQfhLJFcMLazvJvGbSb2XGUzuwD9CT7 V+pf6xcRXfK5XfmzwnQyWSSlZpbaIkv/ANmH/gnrZK0Gr6Z8Ho20pvtM0Y8S/ao7ZX4O4MrcHvn0 9qv2n7Nv/BPa105oI7D4ASWzRi7toJfEccseGHfc27GDwAB9KX9vcSSjy80t+73/AKb+8ydPIk7t K+3TYueHfgV/wTt0aCX+yNC+BUF8sbBWn1aCa3tmccuscmDj3/Ws+L4Rf8E+NSin0nUv+GeRa6XI WmaCe3t5WL5J3TI6sR14LsOOlTPN+I6s+abbfd3IUsjprkjFJdtCQfAv/gnNbzxXOj6L8FbmCCIs 0qanHMkR/vlDncDnHFU9V+H3/BNpoJrTVrP9m2FlcSOgvrTSLgHjCybWV+fQ4+lV/afEb1u799SX UyFLk5Vb5H//1f14Pgb/AIJ86ZYAJB8ArSxmg2XSrdQbpItuQBIPmPHTqfStNfD/APwT7a2it7Bf ga0UkIMTrFHEiqFwP3nHOPU5r9S+u8R9f1Pnliskg0rfkZsOh/8ABPOMQxSN8HJYmmaJYoNOF0qS KuSS542juWO2n2sf7ALTSLbP8BnuVZ1NzPp1uJfLXrtfnG0dg1J4jiVlLH5ItF+hfv8AV/2ALG1t 7u88R/BFdLHz26xWFveMxi+8RjcxI9MZrIfxR/wT2hj09z4i+CslpfkmGW602EvKM7grREnGPRlF VGpxNv8A5l/2jk60t+RHc+Kf+Ccty8kk998K9XCSCOBovDizQ6ewyDtwmAPw49a17XVP+CdtrYTu 8/wVsprM/brq51Hw1CsixY4O9wpHtyT6Ck58St6/qNZnlC2R/9b9cZfiF/wTwltTJp3iX4KQ5YK5 /wCEVWB3RSCxQnDnA/iXIHtTl+MP/BOa4lkhXWvgo408CXJ8NrcFGBxuBAOSCe3T1r9Lf+srvv8A ieDLOMpWyRe1f4nfsCL9nutX8Q/BlreKJJY5Ljwg1xKQemQQdoHAwcVU1D4lf8E8nltbaPV/hSzx 7ZFsR4REumzGQAq7IMqRzkE8Cs1/rLfVv8RQzzKlpZf18ijc/F7/AIJ3Oxil8QfCO2ubKQzXLWXh FLYhVG07uFUryPUHtWpH8Z/+Ce0CtbjVPhM7PAJldfCcMbOhHyt93FKceJtrv8Qee5Qnay+4oWHx 1/4J62MkulXOs/CKeSdZAIrjwd515sYn5fMKHj0G7FW7T47/ALB8F8PI1H4Z2ljYxbW1C48Bsqx4 PKxSbeCMk4rOMOJeXW97+Zp/rBkap2mo39P+Af/X/Xmb46/8E/JZbq61LxP8L9Shij86J73wNDJJ Epb73+rJYfhkVVuf2iv+CdqwtdjWvhFLAYxtjtfApinKjhhxGCfTB/Wv2J5Xxkq14KXLbo3Y+Np5 tkU6bVSKvft+o+x+N/8AwT41MQTWGvfDmS3upjL/AGdJ4HL42rtwf3ahQPcnOT709Pj3+wjFeLY6 ff8AwxMbuVWzt/AESrkfxHCbuMZyOK6oZXxnJ29777fmyHmfD6VuVfd/wDDtv2h/2AY9Te2uNf8A hfLd294125T4dyW7xBSN481YtuR6k5P4VYT9on9gDULpPL8X/DSeL7U72kN/4INytujNlkj+U5x3 JINWss4zvytyt6v/ADCOY8P/AMsfuLl38cv2CoZElh8bfCq5iuYGItrbwFC8qoGw2cIXUexAqnq3 x+/4J9RPbH7f8N7xpIkVbSw8GRySKFO7fgrlCc98H608Pk3F0cZOd5LTe9v1/JieZ5C6bi4px9P+ Af/Q/X25/aJ/YP2LM+u+Eigh+xwWLfDaW5miEke1RhYg3AHQ5U4xzWfYfHD9gc6X9p1TXvh+9uiM qLdfDtNDvFA5P7ho1cHHpX7NPDcaur7OU5t+rf6nwv1zh6MbxpxXyS/Q4m5/aa/4JvwmR7fxv4Ei gZBaGH/hBHu7pCSCpQrCWGPY475rqdP/AGhv+CfSRXiWGv8AgWVmh8u6li+Hk00pK8kSN5W1D65x XWst43UObnlb/E/8zn/tLIOa3s4/cv8AIrWn7SX/AATqkvElbxX8Nprox+TaWx8JM7h1ySchDkei npzVib9ov9gUWm+98T/D6WO7fzklk8GmCyZYm4TYYwGwfalHLuNZSs5y/wDAn/mOWZ5JFe7SX3L/ ACKc37UH/BP25jay/wCE9+F5upZhlb3wdHE/l4+WJF2KWXjqN3ua2bX9on9gyMuF8V/DqDydtusm meDC0sJYjb5brGeuf4TireWcaJW9pL/wL/JhDM8l/wCfUfuX+R//0f1xf9oj9gOO5UDxz8P55ruZ 7e5jm8AlvtDKucPJ5YGR15Jz6Vkj9oT/AIJ5x3kwPif4RqwIaSNvBDR/mwQ8/Qiv3H+y+NFpzv8A 8Df+Z8QszyXpSX3ItQfHv/gnnNNLaWmt/CqOSV/tQA8JrcZbH3guwsvtkDrVyH4sfsH3Wb+38UfC aSJJlaWG88OrFYOf4v3TDl8Z7Vl/ZvGie8v/AAJ/5lrHZE1rBfd/wCjefG7/AIJ3XFpqFu3ib4OR s58xRH4TS3MRiB+RQwXJ69Bk/hSaZ8XP+CddxbC1Oo/CWa8vIhKklt4LVrkDbwSmzd261o8v41e6 l9//AAS4Y3IltFfd/wAAm0H4of8ABOywiuA3iH4VXZaZg08/hBnlTP8ADv8AL+UegyQKz73x9/wT 1laOaXVPhLBa3jmCDPgiazknYHnY4Q569R+dbxwfHNrJy/8AAv8AginieH27ygv/AAFf5H//0v1h 034if8E8rOHyYr/4OxWaXWIkn8PhpfM6kqHXOe/FZ/iH4mf8E5H1eymm8T/B2K6VlJh/sm3vGnzx t8v5ivTn5civ32GG46hJNN385Jr8XY+DlW4flo4q3krfidDe+IP+CfNppd1LDH8Dbe0jlE909x4c t40ctzu8tgCx56gGs+08T/sASWksd1dfAZ7WFVuWEenQLcJE3KkIQGA/StVT47u5frH8gdbh5R5V D8yKXWv+Cdl88skOo/s/b4SjLO9lb2LRK2FHII59+3fFOt4/+CcH9oT2Sat+zc/nESyx3klm8rO4 BzvL4YHjODxR/wAZ097f+Smc6nD38v5/5mqmkf8ABPC8uUsrW/8A2cmuN3kXCaW1jbyS7hlVVozu BAHXJ/Cs270b/gn/ADXFmqa78B2jtpBpi276jFJOqPJhgDvZi+eAWHbGQBxPJxzLt/5KEa3DkWny /mf/0/1vvfBf7A1vex2Rh+A0+oxIZo11aaCXZD/f2vkN1HqKWTw3+wX/AGTdPLd/AW2+xhmNzai1 srZE6ElMhTj249q/oKX+vUVZpf8Akn/DnwLnw5J7P75GCngb/gnhbJaxrqnwLlktz5oW81GBobgy DIyWbnrnBJHsKlsvg9+wDdyLd2s3wRtEnvPOW807XoJImlGcAAOAu09MHAxWUanHHM4qG3+D9SJf 6u76/wDkxcl+DX7Bmozy20Y+CupKJvMvHuPFlt50kuRtJXJHb144qpq3wH/YSu7wRXWj/AOONOPP l12H+0VI+8ocZyv48UlX43a/h/hD9V+YcvD1/wD9oybj4Af8E8byT7I0HwKItUwtvdeMlBj3H5mC ByBn2H41cX9l7/gn1bxmbTtA+B5ymY2Gvwi3fA5ynVx9Kxr47i6npXpNXXRL5/Ct/U3w1Dh9uUlL 3lsnf9T/1P1dh/ZO/YNtLJtY0zw38I7aWb95HeWvi5dPiDr97a/CjHJxVXRv2T/2HLqSae68O/Cu 6S7Y+bqk/jS3uS7t02ucYOf7pr92WacYWv8AV5f+Af8AAPgfq2Rpr3/xZAn7D/7FJvbq0tfA3wiM lynmRmXxSZ7qYZzlWBLrnvgikH7Cf7Et9MlsnhzwBJaxMVextPFkTxCRjjA3lmyDnuDW1POuK3dR wrf/AG4xvCZKv+Xn4lW+/wCCff7EmmWy2cHgzwkpvGkR5L3xRG4gYnIA3Md2PTHas66/4J7/ALHm o2dgsXhnwndNYkubzSvFENikOBglkRth4HJZT0rV51xRTg5VMHp5wl/mR9TyeTsqz+//AIBEf+Cd /wCxRAkTx+DvDNzI5Msl7L4wgllk9BkkDAJ4wBTh/wAE4f2R7zT7q1g8KafazXNyjmUeI7RmjQYO FJIwpx0wTW9DNOJ60YzjhFbzTX5yMauGyeHMlWd/68j/1f1Ek/4Jkfsis6XSaFb2Moi2mSw8VW8K gjHzlMYJOOWznmudf/gmF+yRNJcxRaFLOZH8ySOPxDZOkLdmyo3Enr8xPWv31cQcRWT+p/8Aksv8 z88+oZVeyrP71/kH/Drz9kczG/ayvLG9EQgee08RWhaRTwWYvkbu3bpWHrX/AASZ/ZMnld7WHWRe FRIkb69aTK4PX5BjGfbiqWf55vVwTt/hkv1Yf2flrdo1/wAV/kVI/wDgk1+yteXS6gLTWbe7t1EV x/xNrP7RKm3aUQggKPqDWb/w6B/Zma4cW+k+IrTTzlld9ZtvPzz0VXGQeOv5U1xJmKajLAyv8/8A IbyvBauOIX4f5kX/AA6J/Zsa422N148sEUAPFHqNkYLj1B+Tdg9wDmmXP/BHX9nLUJrNYk1q3ls7 Y/6S08VpBJJx5ZCAHdjvzye9dS4ixa0qYCf3P/5EzeWYV/DiY/18z//W+t7r/gjX8DbqN7TULvWt ZMchkhaGVEMT5/hcHGB/cHHrVa//AOCLnwQu9QiuJfFHj20ilCNJDFb2eE2DBR3QEhTjoFz71/Rs eJWny1cHNP0/zSPziWU0+W8cRF/16j5/+CL3wKt7GS3t/GPi1lvbsSm1/s9GLKB92dmxuUY4HGKc 3/BFr4QSwz3EfifXbcC2FpYk2jySwoByR8x4/wBkCoq8Vwp6PDS+en6GtLJFVV1Xj/Xz9DkrL/gi L8IVtXjn8Y+IZFe4NxKg0Z4XfJxzjgevHNQy/wDBDf4Si4uLiP4g+MLQy7Uto7TTDdQAE9CroxP4 9PWvmafiJj42dRX8mv8AKx6/+rmWS91St6S/zuOuf+CKvgiKT+z7v4g+IL20lt/JgxoC+bagdWba gAY44OPWsK4/4Im/DS0Nq+leNtX/ALQ+0AxQXOkXFv5uThgx56DkfKD70/8AiIGKbelvl/w458PZ YrRun8/8rI//1/ZL/wD4IheGSZRa/EfVVZGMjsYJrUwlucElSxHYBTVeX/giZoV7aWtpB8TbppBP lln01wW2KcFZigPtyTX7VDxCraKSX3HyT4cwKfNGX4/8OU5v+CH3h0WUVyfixfxTh3WSSPTZJobf IwB0UndyCdwx2zXNj/giXpmpW8KTfEKCKeB3FnKsFyscChufvRv16ncxxnrWy8Q6jfwr7v8Ag/1f 0MHw5hbtKX4lSf8A4Iq27B/M+Kjz3aT4tWsNJkdUVRtx5uwMc9McAetZU3/BFTXYbh7x/ifp9hBD kxSahZTRzDI6OmPmU8c8Yroh4hu/vQX3P/M55cNUV8E/y/yOdi/4Iha2d8a/EnSPs88e4XVlPNYr kkkfL5ecZ4PtViP/AII0fEXTUJsviLotwwjMNq6xrKI3HYNIgO045OT9a3XiHDaUVb5/5mb4a6xl +R//0OUP/BFr4m3urRS3Pj7QIZWjaWWCG+228DKAASFjPDZzj2NSW3/BGr4pixWC+1fwRqFjPPJE b8SNNdW7A/IwZkwASOcc1/QsvEHD/CkkfnVDhycrOocxf/8ABFv4vosJHi3wasEYzJaFTceYQxK5 bd3IHUHFVJP+CMPxnt5Irq/8beF9Oub2FhFb2Xlw2cUi/wCrQu4Ytx1+UVp/xELB20hr6/8AAG+H MQnZy/Ar3X/BGD4/riSHxDoV1E0PzXdnJa3PmPjsHCnAwM5HasOL/gjh+0rdwSROPC8acqrfb44I ZAOpdgOCfRc1X/EQcC9OT/yb/gDXDdb+b8P+COtv+CPH7SVxbXENvL8P4I4VWN7hNX86VQCM+V+7 2scZzv2j3rBv/wDgjt+0rp2pMkK+F7+Exq9tJc3qJCScbsxo2MHnk8+lUuPsA38P4/8AAKXDlfv+ H/BP/9H5jn/4I+ftJyxpbRaboML3Lh7u5sLyAuCOfKjX+7wMkkHk9aoX3/BI39q2yngUaZ4St7VA d9nb6usUrj++SwOOh59e1f0jDjjLZfEmvxPz2XDWJfwS/B/8Exj/AMEf/wBprUcFvBQBQefFcjxr Gtq+DkLt8oE59R+dUn/4JV/tXM7+b8OI4EhZjJHBq0d55ypwCjDoT2Bwfato8ZZVK/vP7kv1Yf6t Y1Nctvvf/wAijm7f/glZ+17ZX0l23hQ2sdvcC4jjuLUzgjOVQsvYcZxT7v8A4Jb/ALU17LqiP4Zh W8Mi3fm21pcR73k64G0gj3FNcXZT3f4f5lf6uY7y/H/Ix9S/4JlftIeHfIN74GlubkxG3SS3s55Z pJCAd6hU4B9/eqEf/BOP9o+T7RLc+CfEKTRIohjt7Z7SKXn5jIrISMDuCK0/1vyzo3+H+Zm+Hsb8 Mrfj/kf/0vzoX/gm3+0vPNPPF4K160sEXDtHo0l0nviUpjnis+f/AIJ6/tGgw6TL8L/GMMMIkubz U5dGlk3dSgUBQuDwOuR6da/p7/W3LNdT87XD+MikjEuv+Cen7SMN1ANN+EetnbbBmJsLyJLiRj1d djbTjj0/nXM3n7AP7Sn2ueLUPAOo2ZZlmntrLR7q4vrbkfKw2AHOMjPBz1rSHFuVJXu/uX+Y1w/j m9Evx/yM+T9gn9pM3Mi6d8KvE0lpbwGdUudHmh+0bOXcN0U4ySpB6Gpm/Yw/aObIl+HV5ag2QntY 57O7eW75wyxBImGVOQdxA966f9a8o5U+fXt/w9loKOQZhKTio/1+Zn3n7GX7SUcVtMvws17UoGJV jFp03lwEdfm2n+VZ7/skfHnTbLUZtW+H9+j2ygm1ttIvoLiHdjYCGhw2cj5l45rVcUZRypqpvpa2 36fmP+wMyV046Lr0P//T/FW5/ZI+OU1i32nwBrWmuskNxA8EUkzyqxBbcuzpjtmm6n+yp8VLeOA/ 8K61vBdmE4tZVXcoyDjZyT1wDmv64jxJlF+X2v4P/I/Onk+YRV3T/FGGf2dviZGkbQ+DPElzfhAG j/sS4gWNh1GCvzY46U+z/Zw+L99qaIfB3ia2URfPGdKlBlPdxuUYA/Ot/wC38pS96svxOZZXjHtB lqL9n74m2RvWPgbxLew5xZyQ6e8dyGBAw0bKDtJzzkV5n4p8J6x4R8//AISrTL3RHWZYoUvbdrbz mYE7RkckYOceldeCzTAY2qqWGqqUu3U4MZhq+GpN1o2T2ODj0+Eytd72cOgVI3b5PqB61J/ZVtDu uXliQyJuYBfmbBwAT+J616/L73KcsHZXP//U/m0vYHk/0Up5AkGVkThypHBq5plnb2LCS4Esqxrj I5fAHWv7cqK25+LxabP6l/8AggYlh/wiPjYJDDJH/aTCBgxju2t5SpZyPyH/AAH2r9N/+CoNrpsX 7O/xDae41OBoNHmstOWyYyyhDbgt8np+95Pav5lx6t4qO386/NH6xn6T8N4Rkvsfofwi6lLDcrC1 mXhkjYq5xtlCcgB/fGKwAslvIyqokRxlmJKuPev6OasfluDjeikXLC6gtJ7QToZ4Z7tbaRMhHVJD hiDjjHXvX7X/APBLv9hLQfj94lu/E9xrOtRW3g+8Emm2F0yT2E6okZwTgHOT1ySQ3bAr5fjXMf7M ySriY9rfej6fgrLVjM+pKW0W5f8AgNrJ+Vz/1f24+L/jS3/ZS+G91cz2Mz6X4a0hvKisLgwqqwxh sIuOeMgdADgZxX4o6r/wW18I3t2S3gbxu8kMrJG2n6rFJaTJuOGdSCx4HTjFfqfDPDtXiHKZY2nJ J3e9/XomfP51nssJnNTCJXad/wCvuP04/Yj/AGzdO/a4sm0jStL1XTxATFPFcXkdw8wYNgA43DAG Wz03Ac9vjH/gqf8A8E87zUNOv/i5ol9ov2i026pqFr9nVJZliQBpNqKN5UK248k4J5qOHMe+HeLZ ZdU6+4/v/wCCd/E2DqYrhmGYp6xXOvT+l/w5+ZP/AATS/bUH7PnxEbwj4m04anpOsamUtI7W6CS2 vmunJRlPUK4Hfp0r+mz4/wDwH0D9r34WR3Gn3R0+W+0f7bZSCBFkzIQCjFVJyAGVsfwk9Cc16XGi eScTYbNYbSaf4a/qznyPCSzfhiUJ29xKK+TuvyR+QXhr9o/Tf+CeeuX3w98fadNJG12baK+sIUuJ ltoSUikCtkfKCoPUng4r9X/2S/2vfCH7WXhzU00VXugTLDLa3mnxxusSqAf4cHIIJB/vY7EDl4zy nEPBf6yR0hUS/JfM14TxqzCrWy6/vU739Ef/1rv/AAU6/wCCb+u+HYNf+N3hGW0vdPtHMw0a1t2h kaNh5r+ZAqbTgF/uk4IznFfHf/BN79jO1/aB8Zab4tW5QS+FdQh+12M8osrK0Uyby2zaWYr5bHg8 kDPav6ApcUVHwH/aMIXnFKD8r6X/AK7p+R+f5ZlsMBxMstb91Scl6b/193mf2d+C9HHhfwZB4XuJ I5f7N02LTbV7fDbliTYCe3YHH1r+eT/gqZ+wvrPiue5+LUU8cpsdDe0uXWcO8EaPJMkk0X3mXlgS vTg+hr848OMwjQ4hc3/y8lZfPU+u8SKEqmG9t0px5n+C/V/cfy66rFq/h67lhhuVsL+OcpNfaNM6 IWTgqW4b2Kt6EVWd77U1M091K57mRi5btkk1/U7oKD5mtdj8loLnam3dNGdFqDWkrwyRtJHHjcz/ AHTn0r9Lv+CeH7SPgz9n74hXTfEDf/YniVo00m+SzF7badISmVl9FyM46AEn2r5riXBVsbkeJwmH +OS06ap33+X/AAx7OSV1hcyp4hrRP800f//X/ou+DV94G+L3hC38S2umxX8U1kIbiQ6ckUZjCBoy vrkEH8a/nI/4LSeCdL0qcXejaRp2mXf2yC2S7tYlE6rdKIyjt2yCMdTyPSv0rw1qV1xQ6NST0T0P m/EKjCGX4XEcqU3KKbXZva/9aH8+mRYtGiqxubc9UGWyvVj9Mc1+4n7AH/BPXV/iTdaZ8Q9St7fX tHvrmCWW33+TbKisJisvmEhhjCgIOSOpyMfqHHebyybKp14fFK8V5X/4CJ4RyynmNeSrfBBczXe2 34v9D9+PjN8Uvg3+zN4M01vF2naPYSWqx2i2b+HEmhtYVi2gRkDPAUYxknnpzX5nfFn45fAL9s17 vwD8J9NsL3xRJYJcQXZ0p9Pklf8A1RjVwMqw3DkntxnGT+dcMYfGxpf2/Wk/ZxTf9fO55Oe4elmW ZwyjCJc7kr+Svf02sfZn7G37Iui/syeEbnVPHOnWd2xs3nnTUEXUI7clxIXUgbdoLHHfkdO35Q/8 FSfjX8F/iTrdv4O8FaPoU2qWd0kc+qJYw2l0rQyfPGjjsPTIwScc5zlwtWxeecRVs2i704tt9vL9 TbjKDy36pltDSTcU/RP3j//Q/YD/AIJt/CH4dW/wV0kX3hTw9LdzIL7ULprRZDev5KJH5jjktt2Y J7L0yTn8rP8Ags38PPh94X1/TNa0PR7LSLjUpo9MvGi07yYrhFZXCB8Y6leRyAvPUGv03g/FYitx vWhUk2rvT5nynH+FhgcpwcqKs3KCdvNanyX/AMEsPhvofiz9oJLrxDo9jqFhYXkMSwXroLW5cgPb sA3DbHAO31I4r+o39pf4DfBm9+D3iP8At/wTpc6HTfMvpraxT7TI/wB2NlY9+QAQf60+LcyxlDjS lhqc7RvHT1sz18Ph6dPg+eKt71m7+l0fwlfFnQ9Gs/iBr+j6aW+w6L4quLe3j/1k8SpKHjXOcgKp A49CK/p9/wCCXvxG/Zt8VfCay8JppuhSeIdNtTbazHqVojapfzPlJWJwS46DLdAvA9ft+P4Yt5HG eH2i05d9t/Tv6o+Y4Qk6+Kpzb95q69WUf2qP+CeEPxF+JWh+LfCOm6bDpL35JMVh9lnhChFVE2AZ I2g4J6gZJGa+1LLwV8Evgh8ONDPjrwX4PSbTNLhsLi71fR4mmuBGiREu+0Dc5wcdyT3r83xOe4rN cuwmDw0nzx0829L/ANeZ9vLC4fLalSdrS5vwd7f1uf/R/ZXxz8Afgx+0J8G71Phv4K8MLeXFm7ef psSQfZjIhCiNwOQ2B14PIxX8ln7Sn7L3j74DeKNT0nxJpjWcLT7LSKTO+VpCzJtkbG5SoGCABx+F fsnAmb1KePrZXi5Xk9u9/wCrnxfFlCVOVPERXuy0+f8AwdP1Oh/Yo174YeFPjBpZ+K2k2FxpdxaL a3M9xIyRwM0y7UXgh8jJKtgHHfiv6WJfiR+wvpFhohubf4bTWmpcujzRTz25QjHmwJllI9CB+NLj HC5nVzSM8NJ8jVvSz/p/M6cojh3l/PVWqZ7p4Q8OfsrfHbwxf3fgPwr4R1l7a2l0wSaXbLbzwFM5 xkccEkHuPav5/wD/AIKHfsMeK/hT4wt/GXg3wz5vhjXrTyleZDFFa3J+f55AuGO3cqjA7deo4OEM 4q4POamXY+XxLS/c5eLsB9Uo4bNqKajFtTt2dkvuf9Xsfk14U1LQYNb019fuY49Nh1a3g15I4vPe 2QTIJ4yuOCBkfMOBX9T3wA8W/sQr4DsTZaV4fvNStrO3QrcXqJeguBuEbM2d3dsA57mvrONqOLq4 Ck8Hum7/AHL/AIP4nPkVWlSqN1Oyt+J//9L+mf4PSeELnw9C/gmKKw0QWyOkUYBfkEAkjk8DH4V4 38dtc+DqWt7pPxN03wvd2V2fIZ/EUq26MAM8HIPRcgD+6PSu3LYYiWbVo0f4ll990TxBUp08DhZ4 j4f+A7fofht+3gf2TLvwZawfD+y0KHXbfEujXGg3ySiQyHbLEyhmZoyivu38DA9K/npv5JJnmMaR QmKZ4dsBzEQrFQR+Wa/onhini6WUxhjL8yb/ADPyWpWjUx9edK/srrlv6a2/D+rlOzM0d1YTGeSJ IryJp5I/mMcYcbyV7gDORX9XX/BPjwD+yt8VPhrp9teaZ4Y8S+J9PjWbWFN6xuBNN8wbaSNwz8pG NqlenPPh8d1MTQyv21BaRep9Fw4qdXGqlU3drfqfoL8U/wBib4BX/wAOfE1xe/DvQ4oU0qS4ik0y CO1uYCiH51YY+bjgj/6x/jD+MOi6P4d+I/ijw9o0Cw6Xp2ry2tjFJKGu0VSVIcAdQwavnfDfMcXj 8HiFiZc1mjHiymsLn0MPS0jyt2+aP//T/Ibwp4V1nWr2203SbSO/v5pw0EDrlYkGNzuBycYwAOSS AOtf0M/sH/sV6NcaUnif4q+DYPs+pWAjC32lNAViyrDY7cqzfKxPXkjjkV+3cVZr9Qwzpwfvy0/A +XyPL/rEnWqL3FF/fdn2B4k+Ef7EnhfXdR0HU/DXhSz1IICzajPFNPcBWwo8xiwHI4z2xW74d+D3 7IniHV4NLtfDPgfXZ763NtDb2F7bTJCAvzBgh5PHv0NfAutmk6Htm3y7/I9rCU8HFSoJ3le3mfF/ 7ff7BHhNfDUWs/C7wF5a2MSXtrNGn2tbNkO6aK33Bgm5QCemdqjpzX4l/s/eBtE0/wCM/hvSfixa adbadaaxANYS/lFrcw5lG10Vu2wMd3rgA56fe8P508yyDlTvXgpbd0nb9D5TNcNPC5tLD2tCTVvn v93qf1Ia7+xd+zL4t+Hjnwl4L0+/1XVNHBg1XSZBeJuKBkl2ZKjkdV55PWvx8+CX7KPgvwH8WvFd j8WvDctlokniGd7RNatGktp7VZCI40kY7AhJJz1xtBxXzGQZxi5rF4WUvf6Lsz2M5yn2GIwtWKtC StLtfv8Acf/U/Xnw5+zv+yp4kli0yx8O6FNGLKFntdLe2MXlnI6JliOxz+tfmt/wUT/YItvC2jz+ KvhD4buobODM91odsnmwLHGRI0sQxjOASAOeO9foOTZtiMLnlPDY5tKd737nj59Qm8ojXw60ptXt 26/ofhbrOnz6FutzI0lyu2KdxE0e0uivhgQMHnBB6EVkQxXAeWVLjbciDBXf99f7o/z2r9fWuqPj qM1N8yKnnh0ldSDKPlZByAe9Qj7UZbNpYW+zvJ5O/YSCT0/Wg354nVXOmT/YJr0PEqW7LC0PCvz0 wPwrm4EnfzlAEaMmFcdWfsMenSm1Z2Jp9j//1fxu0jS7w+bc30kjGIhIIhjyyO546VanR3mCyJtG 7EQ7A1/UB+cN33IZtMvmmiEbIy5+ZDzxSyvqG0R28LRTWzYEU0ZSKTGMkfX19qBDHt1uZY5ruAR3 C871GAPp+dS2ul6le60jW8tra6fDbMZHnXb5r84Xd7j+dZSkrWRE9gmuLu2EplhYTFiqoh3IcHA6 VeBS4j8u8g8ubyBJC/Uo3Qgn0xXPPyLP/9b8ZHgZ7xdrYSLJDkfIWHqe1dLp9vIVmupt3zL/AKz7 wFf0tD4T83HC2lM7fuZc43B2+649hSOtypGFEaR8q+zDE8Z5qgLMTL5/nXkbFpIwqyt82MetV7qe 5eZBZ2bNHJKIS0fyqB/E5J9MGlbW5rF+6Tn7chXYY/KUYZf+WhNXZLY+WDM5QOuWY9Bx0FUkZPW9 j//X/Iuzt7WGB2tJ5/NkciSNzmAL6Kc9PanRwefEfKIU7vujgOR1Ff0rPY/NFGSe5LBp0siTJEqe cAC6ltpQdM1PDZ3WEiNuyLECz8feA7/yrPZl2KssVzdErbkKEIYbf4sHkfoavxR3MsDtFGNzOI3V gBtGeSBW0VZWE02tC1fWca26oqxtJwXlWMbh7Z61SLfZYljJc5wPL2k4z6+lDdhxT2P/0PyikWFr KNvIUXCMfKdPvjg8n+VRaclxKJI7nKyHJjUDJYZ6n0r+luY/NzQ2Txg2rv8AIw4zVSLS7WNJHnRc sdgZvUntU89osyqr93ZlVrVLDdNJMArDywM/eB7VauES1uYI7q2Wexu7J5YWtnzcW0i8LuHTHOa8 ynUUo6nTKHue6OtNPurZcTXUlzHOreVKi/NDuyVU/TpmmQaXJawyhLuVDOzLKP8AnqeCBuPUf57V nKeug4xtqz//0fyge9NnJBDPBtONkWFwzHrnHerJfzZAjgK0xwC3fNfvrl7tz88t722hXu9J1CZP mBtrC2lAWeJtxnYDO32xUttpoZYlZiieZ8jZ7k9z9azjOWiNbe42a15YzbXspy4jiwTg8MMZzXNI llayvarblUPzmR2L5yT0FdSm4uxyVIqTujVNiNhCTuFX5pgwCpEp6Z9PxqxdaDHbWkJ8pJI5XLmW Jv8AW5wWBNJVG3sKVNI//9L8tYreQRJbwW6GFSdzO4VVXBPJPfjGKqvCqssNvb4dssZeAn0JzX9A yqtbH5xCC2MdLXUYZ5DPs2+aVTy23r+f+FdBb25u7j7LMTFJEgd8jBZSTzjv0rL29/dsXyW2Zp6n a21tDFHaRxo6SgC4IKlh34+lZElrPcXMf2Ftk+wuDnah2jceemcCn7RLYtK3Ut6bp5vZbexaOIy3 twIcSMEVnY9yffvVaSOySeSZIGidWKp8xfG3g49s+tCrW3NIxuf/0/y6t7Z7tlY5yzZ8wnGPrSSy XNhcPIsX7iQfZ8q+8RMOc498H86/oJTaVj4Vx03Llvdx3rLFLbsuOTOSUkcd1/yKvx2djEfJlfMs rf6KqqAinrlifpQ5NmSV+hWl8+285Y4JPL2bxKvzLuyMjHfjNJH5jeUXX92nMgYfMx7Vk6r6FKCu xsTRK8zrHI287FJyFUg4NQR2qieRQQjSDzGC8Z9/5UnVkhShFNH/1PzRNgyeXHbrmV4zKoYhQ4Az 1NE1qkJN4YFW4mtvI+y4/d2x4BcHPX/OK/enWetz8/lTSLIurmGyhCoCLePylLLmJF7D9aSRobyB p2cRSJBuVhHkMVHAwPWo9syORENjG09p/aMNu8mw+SxkTavz8LwRkHg/lWfN4Xu5rgSJIsFyHD70 JLMh+8p/DNbRrPlsL2UbmtHFcRWskVvaxo9pLiS4gjBuJCRxuPXt0p0enYE2rajevJNI+0GRNxPb H4cdfWo9v5j5Ef/V/Nm6sTfRx3flW+bHG2ThZGBPAA74/pU0Nt5lrcCG5jEzYcoTtRfp/wDWr999 s7H54qaK7uGj8ptspxtBh5DjpRpkEmpsLFQ4ZDtRT99QDz+FE6yUddy4qzT6XL76VCkgtppZEjIK SPEPnTqOKyZ9jXjwwSec1uBGX24bA6Vo6mwrJHRWtlJOqQwxvNLJhXj2/Nz39qfd+HW8Myxs93Fc w3ZLXWyYS/YpD0Tjgj39auM31LlGx//W/OeVYJ7eWMr84JKv13egrV8LpriWxtbZ1hS+uj5xeQW6 ogGPv9TgDpnua/oj2ul7n584p7iau0N/YwxXxWe2s5W3M0eZRt6jI5xxnHtSadBaDTmt7G4YwM3n Q5GFiYgZAU9OnSnCrd6mUoWNSC60nV7G60lImj1C1QC4mmGyG4Jzkxn6dqzo7XSdNSATO0zO/wBn SJzhmYjjB/z0rTnRKXYct5Zxi40yB7jykxPLbyowhVznoeh/z6Vhy6vbwXC2ahvOmG/y1QlD269P zq+buxP0P//X/Oq70uOZFmhMtuhbzMIBkE9c+oppnuYEhjiO5lHluFO3ep4P6V/R3Mr7n5q3boMb QktNatjf2q3VvOglU2swVNpAO0kchuorej0u2trmR4TJbW8kpdEeRpDGD2FLmSWgbq1iUW1uZXZ3 Z16B5Byat20cdyXtbVCWRSSCMYCjJNNTRk010Obu0nitbt7SHzEn+WQuM8AgnA+gq/ZGzW2ilJaS 3SMPGqrhUbAJGPY5/KrUtdBH/9D4OunuFQDywkcyrKhx99T0wfxNZSzCOUtNaM1uODK3CvkcgH1H Wv6RUmtmfl43zLZQxt0nVPuI06hXJP8ASomaVZSLrMgkXG7HysOgB/CrjJ3swLCQou55HCQQw58n blBjocYqrJsiK3LyO8Xl7kQL9wd/z4qpS5TSCRBcxr9lJgX/AEdT9ojt24iLdd2PXn0qx55ubTzz amJmjxMkXzIxHQr9euKd9LicVsmf/9H88dKtryW0bTJLnyHnB+1iDgzMx+Tf67e3pXT6nfaHo1va 2pimWRI0tL2MATSXDg8uG/hzxwenvX9LKV1c/MGraMztTsfs01tPDEwjuFD2zdS6nBAz+VRXSXMc ztcW4UqQrDcCzDA7ilzoag2rmHcI1xJCsn+qjJLqeSPpUtlo6XztLZXf2MW77pJSmVOOqj39MUua N9gcWtzb1XTDqKRl5mVTGVjMke+ORxjBPckYH50kmnQ28dkjXamWGLDjb5abickc/T9auy7En//S +AZb7+zrgXVrA13L5LW0cAjE6zmQbD8h4yM9c1kx6cIf+Pu4kjuCxDo6bGXPIHt19K/ppcttUfmC vfQkmubKL7HYFWvEaUieWUbip5K/y7U29ubWS3W2XT7CEqzGR4YAs0+eBvPfGK1jy20Jm5EC3upg NF5SRpbWe2yjkT5WLbiDjuOetW5LD7ZHpcok8jULeMS3jW/3Jsk5DIf5/T0rWKj0MuZlHVZba3v0 hjaURNCqIzpu8yQjkHHTnOK1dDbS9Pv4b++WcvFGUgjifYoYjAJHcDHStVa+oloz/9P4B1SZ9U1t 2jSMW7W6NAYV2QKcchvRuRn3zWXq1pbrbCGeItqdvMssAL4jjx1BHuP5V/VvJE/JxszWPnWV3brL bQ+dseLZvyQMEBjyMEetX9TuUljjkitbmB0l8lMuXjnYjjdxxU8q7gm+qMwahPbIYxZtNPINrSLw YTkcAd+9XZdLRRaXVw8MkpbzXgdfMGOwb6+lJwTVrnRGTtdEwW0jtlhtrS3tI5ZWlVYbdY9zHCnD AZI4HU+veoxpv2ghYoxK9unnSD/nmB3NQ6cUU5ux/9T85bjUbvULaG1hlZYhcM0sKjbG207R/Wq1 9ZAtDAoik8tAyiMhlyep479q/qT2fY/LzWu7uyKWlhHbRLBbwjzD5SrNM+0btzgZIznA9DWbdXFs kX+kh1t414WCPex9sU1DSzMpO+hgSsLe6huUjJgdgq5XdjPA4/GtLUrMx+XJYgm4nAEqocO2eMf0 4pKGupzStfQybIzwahAZIJrV1cZnbDhChB5x6enXmu8127t9Qmtv7PaNLvfia+jjMJnBAGGHqOef ek4O+hUYpq5//9X83j4ftkj1HTojbveIhmn8mUbmXJyV9QSO3pXLy3z6RMtkkU0guY9pMWRHLtO4 qzdARgHmv6nSsrH5BY0rOKGZ5b1JpVniiAlgzlLVW/xPHNKLq1ntp4vOaO9SIgFoiyZzxg9wRk1M 720KjC6uyJLVhbQXKziK5WULIFjDRzL+PTmrv2e2a2vN0iSXccYeKJn8vfmhRVtSWrMoWNlC2Hme WOcDK7SFVSfekfS5bCxuL3ULm0S3t3Iil+0KzvnoNuc+grJroDTW5//W/K+2d5rO5munuLe7vIgd KvLAIiWwzhmYkHDY5HvirX9hXFtLaLp2qz6it2FuLm6usCSRnzu3H8jur+nuVbH4+JqsKyILNmiM lpMZTPESfNzgY3dxxx9TWZah/N5QrGyFGK8HuDU8lnoax+DQ0oIbSzt98U+wFDvklibI9F7n0/Ot bTrt5o7YStuWMfKZlzEOcjKnPHsa0CGxv2l7osllLa+JCLeNS3kajYIGFm2eGMR4K464/CuTfS49 9zquns1/awxkxmKLEcqHKq+z1OQcetNBG92f/9f8qrLTbfSlhbzrppJf3gM5LlgTuZT6YyPwrcWc TXG0lWcjerKnlqB0G30r+p42a0PyCV72ZtWemNfSAmQ3At4/NuVYb/KQcc8/T86ytXtU1W8vS+nw WLxmNbBLZRbxAqFVmI6AMAScdzmuiLvHUwk3zFPSniaeSCZjL9lcxTxRn5kOP5fzo1DzdPmtLoRI bCVWdd/3tykDaV/Gk0lZpEybszOs9US0bVP7RspYE1O2e6tXWMlXIyYsD0JwM18dfG6eDUvDExln vI4taiMWoWjwmGS6CuCsaAjcM4yf9z8a4c+knkmJXeLX3qx0ZSn/AGhRv/Mn9zP/0P489Zk/sKzi lT5IbNCYbRvnmB42j05xXnOo36eI7h9c1GSJL64Ag+xeXsTaiqqyYHGeMde1cdSnarJI6nLmhFnH O8UV3ELiOS4hWYJIISFG3n8jVrT9MXVbsNcGOJ7abzYGgDEFVP7veOxHftxXJVVloYR+M9v042tm ws9RTz3SNZ49UaMmQlskrj09/f8AOC71yObUSEaaUwIsAjkjKRkdiCRg/gTXI1G2pUo31PoL4NX2 najNYSXBuoJrC4nS8gs5vLN0pB2Lg8MAOT6celfU9ydCmgsB9na2uk3NJeozCZs/dGM9QODXj4h2 m0XQP//R/kJt7SC506yWe8tXaTDNbiYOUYYB8xeoPHevoG5bwLpvhnw8UR/tyz7biaOfa4G0AKvb HoDxxzXx2IbSi49zGhy3fN2PPtYuNM8R2cbvf3v9q2WpMul2jkC3cRLwWc9j7Z6Vp2D6loDSrfSC a/ns9kZUh4FEq4OcZ5UHjPpWtJ3hZmydzyu+0xrG7it7u5W2nclkunUCOc4LDGPXqPrXDeJdPtrK FpbSaWW7uF8uSQqMc5JA/DOK96jLZBBJNtnmc12UlRxG8SgDDOuxpMV6j4Pv1j1S1ikkiktnnhnC I5DuQQR05z0r28A/9rpx80cuOhajO3b9D//S/n00OeWTRbK30m6WylvNMhEjSRbDkou7j65r+iP/ AIIiixtdZ1jw7dh7u2Utb380kZihkEr7lSKTOc5wT7Mtf1hxm3/qPOS/lR+ZeFUIPjJwntaS/A/o x+Mq2nhLwzeXen+HdCWWxsHvo4ILUSRyiFdwjx3bABJPJxX8+fiz/gst/wAIN4n1DwZd/C3RLnV7 fVHsUuRFPcwxMr7Ssyg4DKMfdJ47V+GcAcO1eJ/a0ub3o63f9eh9Nx9nsuHs2Sor3Zfhb/hzPvf+ Cz19aBDf+B/C9nA0fmyXjaJdXaWMWSAZAsnTPHAzz0rnNY/4LL+I/s8A0nQPh+yzZazmi8P3oSTg tnyQ24Lgck8mv0mn4X4rmtKOne6/zPjZ8ey5G4vX5nC2P/Bav4hFZ5LHwN4DXWZ1aBNQttFuYLUo rdcyMCVwOhPUCob/AP4LL/FC31nTtSu/BmjT2MMO+YaVbJdLlsg8MQQeAdwHSvTp+FsUtZr5/r8+ x5/+veMbP//T4DUf+C13xHt4rjzfCnhtEu1861trDS1vdZXByplik2hQ2Oo3Edu1UYf+Cz/xUvYx caVZ6To1v9mL3tpLoEVw1uz5HCYEgIPOdzD2r+n14XwWsZRfff8A4J+Kz44xT2RgQf8ABan4yQQQ G81fw7FFLO9jI9v4e8nU4TuIiZ4MlSD6rjr93NTal/wWX+NVnLLbQan9uNtLAY2j8ORf6YspG/G6 E4C5PBb8a0j4X0U0nJW66efTvpr07eYocbY2zfVGDqP/AAWW+ODXV5cMIxZQzmKe1SwtVE6Y+UQo UHI7kk8d65yL/gs3+0Fd2Eq6dc309wt/5enWum6RbQWs6kZ3XVy8QK7TwVTIJ7962Xhdhra1O3T7 +v3d/IHxzjui/H/gG2v/AAVp/acvlux/wktg2ox2aXMdpa2EKRKcYdGl8sMCpA6A/WqVt/wWF/aY tDE91ez3N/Ehe2tLNrNEJIxiVpYjkZHuR6Vf/ELsE00qnp7v569/Uh8cZgto/wBfcf/U+Yo/+Cs3 7XlxbSSjxNpumR3cklzcS/ZY9UuNNAH3Qvl42kjAAzjPQDFcdL/wVc/ajg1KVLn4gTiDUII7ixuI 3iktWYAliyiISLkjO1VbANf1h/xC/KbW5nfvZflf16/lr+GvjLMZtXtbyOfuP+Cq/wC0vrEkc9x8 QPE0tvPNJBdW2k6ktmbIouA8byJjrgjC9+RVvR/+CnX7Vjwz7viLrV5bKCkVl4maDVRJhsrIXUDG MD/CtoeGOTxjabbXXo/k+npr6nLLifMefnUte19PuMrUv+CmH7Wzz2El347mkBuPJt2hu5NOn2nI kkVoxgqBwAwPTpUrf8FGP2mprW6jX4u+JpTHKZreCPWZltmYjiOR9m7joQGxnnmumPhrkcPhUn6t P9DL/WPMr+9L8zPf/go1+1TJZyvd+LdaE8sOxrdvEs8Nom3hXZkwT67SefWsVf8Ago3+0tcazJa6 l8XNftWGnrJbWWnX1xeiIkAAvLKdpGT0ByPTit4+HOSpO0X5LT8dDSPEGP0u/wAz/9X857v9vz9q iFNPmj8f61DHZX8S3Fx/acsiXETn5mwxYIDzlVAz2Iqnf/8ABQr9qi51STzfiPdabFkrCtrqdzie A9pI3Zg2QRnBAr+06fh7kMd4P7/+B/kfgT4izKOilv6/5kGp/t2ftJQnSpI/iZql+1u/+jpDeSWC xRsMbE2k7V9QPSuS1D9uH9o+O7ur248Z6ktyt3BIkUOuvJZ3sQbLxywlPmG3PORz3rohwDkUdfZv Tpf/ACs/xInxJmT05yaP9tf9oHUvE0k8Xju7022kZ7zT7G1Jmi+UbUR14+bkncSTnpVfWf2pPjdq NnDp0njLVbMBvO1BrfVLiOeWbdkuBu25+o71rHgbIocr9jqrX319dfyOerxBj6jknPR307X8yjqX 7T/xvYNpP/Cx7y5uNShSO3t7i0gjuIURQSxMQUs2Mct+Oa5h/wBpf4zQRWU9p4svL+/guil1qGp3 BeG9TjCJEgBTbgjqc9eK2XBHD/8A0Dr75f5nNLOcb/P+R//W/ITXP2kfH4invpNWvL+9ubiOWyaW /khbTyuCwRlwcdcHr83WqUX7RXxH1W4vLhNYvdCEtmEa+E1xJcM2eqNJKyn8AO3Ff3FHgjIof8uv 6/4dX079tD+bv7axktefUnl/aI+LVxZrZ3njO5+zXyHT7hLi8kl8/jhokyMNjn09RUen/Hv4rafa x6VZeNp41jeVHuBZxx3UiOpAYuuBuXIx2+XoaHwZkC/5h197/wAzSGc41fDP8v8AIW3+LXxFv7Sd 7zxvr9+NLuVjaWef7DZr5i5AYR7WbcAckt/DXP6j8UPHoQppXjG+04o226t0ZL5Jg/UxK4O0jH3s k81p/qtkqXIsPG3pr9+/p2No5rjd/aP+vIz7b4n/ABL3w+T4vv5FW4Fy8l1IRNJs52naQCPYirt/ 8W/iTOyNP8QdZt7VbvzreOCOKNIXchdoYKWxzjngfrTfDWTyavh43Xkl+XoT/amOSa9rL7z/1/xW ufib8TdM8Py3Ft4w8QwRWt2WmvBM1y+x8ZSRiACOpx9a09X+K/jrXdPsLJNbmgaELJpt7bKkEhfA 3O3HLHGetf3VPhrJ52m8PG67K34LT7z+dFmeNScVUZgXnxH8fwGK517Up9VvVP2W3uLyZXgdRjh0 28kZ755pJPHnjW/tba2tvFt5p17FmK4khjj+0KjdI12AbQM8EDOCOlUuHsqTTVCNl0tp16bPcxeY Yt7zd/6/yNG7+I/iyGxk0xdf1ExPZC1unhuybqc55ZpDlhn0zxXJ6d4z8W2iXtraaxrckd/D5IZb 6QS25zyVcHqeeua2p5Dl0INKjGzd37q/rTojOeNxMpJuo9PMqW3jXxVb6lBbt4l8SRNaDd9pOrS7 wx6AZOBj0AroZ/FWuaqxF1rt9dTld8l3LKJpZmXoJGOT7cYrSOUYKi/aUaUU+6il+RH1qu9JTbXq f//Q/C631nWraAtJc3c14zu7eZdSNbhnyMrGG2jA6Y6VlTeLvFNnpd1o9jrV95UhB8t5PNwxbLHc 2WHHHykdK/vh5fh5rknFNb/dsfzF9aqJ3UmXB4x8QxRSWlvq95ZLc26w/upi0ibeCdxJznPJPPPW qknii60xbfy9Z1OdJR9o3famkMbdP4vmHTpR/Z9Byd4K730Wttr+hccTUtZPYtW3iXXXLSx399cy XMhZJb2USwwZHVUxj/IqhrPiHVLOz2nVrqO+ik89p2umw4z9xUzgDHYDtVLBUY+7GCsi1iZrdsua F4q1zVNKeBLzVrSGBy63lreSxLIX5Pzg5yMAc9jWk3iK8a5i1W9a4nvoZUXzJbhne6WIBcOHyp3B cEkZ5z15oeDoRfMoq/e2v9aI1hiZtWbP/9H8Q/8AhMrqOOe5MsouZIiII4X4gHZFPtn/AOtWBY+I L64vrq5nXMtzF+/mmAeWQngjOOO2MdPWv72WCpfHyq+17H86qtfS5XfUL8z29rHJdXNqxdJP7QvX vzbqPmVYt5O0bvTnnk1XuNRmtPNs5bnUJI764yUF3Iihj2ABHH+z0FWsHTSso/gP2nmTpNq00Unl pqOn2F8osvOeZhLcxQsDgbiSBkAcc9Kq674g1uSa2hsdT1S11FQsEN5aIsDWyIAFw+zjgdevvUyw dN7r8CZT916hPrWvxTXtxLqurXsslusayPeNJdZwNzCQ/Nu46g06x1LWdR86S/1HU4xPEqXUEN5L GL4rjDTfNksAAM57VDwFHkS5Fb0/rsvwM25P3VI//9L8CdRkbYlmZ7y4jlm8zyft0xeErjB3sScY LDAPGfWtJ7/UEgkulaTEKFYzJPI8VsuMdN2fXnr71/dtHDUpJ2R/N96lNfETR+Idbu9Mgi+230MT AwyBdQn2PjgcbuR9ayhPfRKyzXOpXNzj93/p0yAZ+7tw3b0q3hYJ2sJVp9ZGjb6zqum6Y1q1/dXC Sr863Vw0zqx5ypJyOh4HFZOk+ItRmVYLqa6thaXk32YxzeX9oSQADLL82B2GeKawitsOVeSe/wCI R6nq1vPPbTuv2WJ3jY4JmkQ/3nB6+uKhhkit7v7Rb/aIUcZE0epTpLuB4wA/ArV4SH1dtpXuOlVd 9z//0/wsbxF4kSy81tbuBErhHiluJJprtCcFdxbjA71z13f67FHLfWDefFcSBG+0TPK9vHjDbAWO T9cgZr+7VhI722P5tlNqV0VrDULrUbl/MtJYltY8C8jf7OYh/slcEnOeeoz1pRrdxZySWtvJfFpn aWS5F/MblmPVmO7nPfNVLCKyjYaq21uMttb1REt7G7WeY6e7S2k80hEg8w5OT1P4+lTtr+uWVrYw y3d3fRw6i92BLdM62at8xWOI5BBOBg1H1JW+E1ddLqa0/iC81Uy6zc3cu2zhPkr5i24VsbTjaFJP QDOcVzlnr+t6aGu7S/1PSIJZVlVLfUJZSpT7rjJOCTzxxWcsEn0KhX8z/9T8GbT4l+K45Q8esamZ 5d0huBfModiMFtnQMR/F1ptn4zvbXUbphfXV9eXcJub2DUZjfJcAcANvz0J49K/udYKx/PX1h9wk 12/vP3hurtZplNvJFDdvGgjc4dQc8YBOMYrL1iKWKN7MT302n71ltit9LFLC+3no3J7ZOauODhtJ B9Yktbi3Gval9lle1uprK8WOOJLxJmE8OwgI3JIOMdTz71u33iXWJrwaq2q6mupGzW1lvYrx/wB+ oHBKnjP4Vq8JTtsa06809zMsPFHiGGxlsZNX1W9sbz/XxXV2d0WMk+Ww+YAk9M//AF4G1nWbaSBo tV1m4ktRts7W4v5LuCIE5wiOSBjsR0/CsvqkL6I6Pbytuf/V/CCHUtaYxvdalqFwltIbqFbyY3Lx SNy2N2eOPu9OBT5dYguP9GkeS0ldvOaWJRHM7d/nA4+lf3U8JBbo/BlWmnuT6rrOvatMGi8Q3s9z b2yQYvgt3EEU5VUBHB65NZ114lub2K7jj1DUtJuYrf7JcyWLvak9OQGyD09xWNTCweyFGq0x2kxe JbTTJZ5L3VGtplBS4umG9s/8tBwMZ46VqWl5q1vMLy51eeVBbeQFBKo44ILHP3hzzWLwcVq0KpWa 6mh/bt3cSMY7+7kmMYRS12wj46EAcZ/Cs3+1r9IbiG71C+Lg+YVN2/mRkdAjZ3AZ7A49qpYWEd0Q q0n1P//W/CbTvF2vTLDYDWdSkgiUySi7vWlnwSC0SSHlV68A1d1fxZqQlt1tb+7gKrynnvP5q9MP kkda/t54aDdlE/B1WkluWNI1TxH4hTUPt0z2t3aWpNvfwXDJmFeB8jHG8cD3zxVRPE/iG2t3sYtW uLmNSyI8sUZulDcE7yOvpxxWTwkL3sP20u5lW+s6zaRqT4g1exMYbfci/kWZu4LEHnHbiprX4jeK ruJYrnVr/UZBAYlnvJZWlkJ6O77s5qJYanG90XTqyve5qW3ibxfZSRanYar9kcxrHd283+nxNxg7 fM7EZ4wOlU5fFviS2CrZeJNbhukMlzF5WoyQqHYfw4PCg4+UcV0YTBU6kmmti/byjJu/Q//X/EOw 8c+KHgMEnifX3ma3eJ53vgZJGkGH8z5cMDzjGDwMk1Qg8W+M4ZlSLxt4pXyIyhjh1p7TK9wpHQds Cv7VeDpn4lGvJpamivxS8faelr9n8RXVhdCQgT3WrzXTyDooYsRk/wAs02f4qfEC4vpI9O8b6uJZ Yt0sU175r2xXBdo5ABgk8r3HTNR9UgtS1WequVYvin8RYZbK8j8d+JLm90+7aVjdakLuOWPj926M pzkjndkEEjHpvwfGPx3rUUSajr9zYSWm8b9JxbK+5iQxQ5XkdRj6VP1eF2huq7aMjuvi34za9sRD 4r162Fsohie11Ap5pXJJc44HUbRgVci+L/xCjkb7F491izRt6kpdur5PB+YMB+GMVEsNFaEe1kf/ 0PxoT43fGDSbky6X4w1Bo/sXki8mvJGKSEkMRGDjGOxJHtUY/aM+M12RGfH+qW80EikLAwtI7jaR uZlQDPHQV/Zjw8UfiXOx8v7SvxHs5NSh1Txx4gu4r4I8Ukc8zvaFDnG1WxjJHbtWhN+0l8bNRVmg +JOvLi3jjik+1yR5VOQuN2V479axnhrsuNXlGy/tOfGS3KZ+JWvwXVzKUMQ1C4u4sgHHBcBfx9av ab+1Z8dre7e6n+KfiV7swG3jli1aeyMYVcL5YVwMjAOefoal4VpXD6w7mnF+1p+0TbpY6ifit4p1 C7hkZLW+vNSmu57ZGOWVJC3OPet65/bh/aLFjrAX4reM7zUJvLO6TW7gsEUDKxjfhCefuYHSs/Ye ZpGrc//R/KqH9uj9qCG8Euj/ABP8YafALYFZYvFl38koGC0kTfI2ecj9a2ov29f2n4baxN98a/Hb yxzsDJa6tcSvIXPCsC5BH14r+w1hbrc/GHWSH3H/AAUS/azt5b2zn+M3iNIpY1i0syTGMOSRkPtA xxxk565rRh/4KCftc6VamI/F3x7czQ2m62e019DbOzDOxiRvK/ifSn9ST95vVfgH1hpWS0NHS/8A gol+1rdpBBqHxl8Y2j3DBzdw6oySW4A+aNgBuOccfMBntWrJ/wAFKP2v7MRwaV8cPEl1HbzM8b31 sl06MOiy+YPmB9M456V5E+DMlk9aXW//AACYY7EpWU397Kp/4KV/tlzNcNqPxU8S/wBo5X7K9peR WumzKTkkxAfJjkfJx0roZv8AgqL+2qLdJ5PiZdAWd0qrFEIbeOSMLj55BESckdGzXO+BcmevK/v/ AOATLH4mCspP7z//0vh7Uv8Agqz+1rHHBaL8TfEqpLF5mUtLSOK1JHzEyCEl8c4DH6YqeH/grJ+2 Jp5srK1+I95e6a0Kxy3U4tZJ8k/MSGg3557MMfhX9QPgPKH0f4f5H4vHM8Uuv4m+v/BWD9svT7K4 jTx9GrbzLYT3VhbTyTDsu4oRtPfKk+9Zdj/wWG/bNtri2hufG9q8l27pMx0ezuo7VufLJBgHyt7Z xUPgLKH/ADfev8jSOb4uGzOuh/4LDftrQpBEPFmgFLb97Pef2LaNJc46R7TCAAeOcA+/q+1/4LI/ tXz38S6j4pt7ia4jMckUfhWzeGNs/IF/hOO5CjilLgHKnFqnzX6Xt/kDzzGKW6t6Cn/gsv8AtbwT CCTXLIOsu1Gbw5p0EBCk/LwpOCO5HaukuP8Agth+0jc6TEmlz2cuoxXBW8OsaHZtbMV4KxGKNPlz nGQDgVhU8OsE2nGenW66ff8A18jSPEOLimj/0/n+2/4LXftIiya51C88O2GoyXHlJE3h+JYYFXuG 2OWD9s9K6zTP+C237RjyrJfeGdDuIIbXIgDW8NvdsD94hlYjI5wCK/o6p4cYKU21Oy/w3/VH45Tz /GwacpNpfIRv+C3vx9ZVuX8G+Dx9su8Wml/2aJZoUTqZJ8hRk8jIqzrX/BcH4wRgX03gvwRbxPJB EmlXWiz3147DIfZMjiMFv9oduPSsX4bYbmbjUX/gPp5+un4ne+I8VLXX7zVt/wDguV8R7wRWV34G 8F2r5cLC8crS8LwWSNdu0+m4Gltf+C5HxG021ZZfhv4MuB56xzRpHOcBj/c4Izj1PWol4bUE3+87 fZ379f8Ah/IuHEWI8/vNe3/4LeeNkkmmtPhl4Djso3yse1orqVyBu6scD6jPvV6f/gtz4tR57jUP hP4EuEjtxcwyfapokJyBjdhgevTj61y/8Q3ivtr8dy/9ZMT0bP/Uzh/wXY8RWcMsMvwT8Khypypa WCAO3IdH53LtI9OtW2/4LhazL5lnL8BPDct4LcSiQ65IgLMOAo8okZ57mv3l+HTS0qL8T80jxPi1 omTQf8FyXgiL3vwN0hJIbUppwg16a7KzdCJEEQyvXgYIqXTP+C7mkSSETfCTTZL+0QRSLHr13psK uxGRtNuwOB23Vn/xDitfSovxNI8V4qLtJmxD/wAF2tDlvpIr74MWoit5yZJo9bupjLEMfMjG3IJ9 BwPeugvP+C3HgC7heJPgxd3yoiSBV8SXETx5ww3j7Pxj2JFL/iHde6XOvv8A6/C5r/rVWfxXuWbX /guN4DeOBIPg9NGzt9nz/wAJDJczM6jgBBCGI981YH/Bb/4cag+5Pgpqr3iILZ7p9X+zpuzgjJjD EdT1rReHmIbcVNL5sqPFVXs/wP/V9Uf/AILa/DGyhnD/AAo1u8jtZkWSKDWyI9xxwDjdx/u9qSH/ AILf/BK9u2eT4VeMGllm8iY/8JDJbRxMRwuDHwOcZyK/dv8AiHmL5bqZ8D/rbLZR/H/gG8v/AAWw +Bcd3awXnw68TWUCuftM7+IDOsJGcjcAc9B2Fdpdf8Fpf2aI7Jb2Lw54hf7TKsMVnc6gLcznoSh8 tgVwc5OK558A5jH4Y3/7eX+ZceKk0+Z2a8ivZ/8ABZ39mq0+0rZ+BvEsVwzFnjtriOZt3dvMOFIP Yrmr8P8AwWa/ZclS2XUtD8W28hzHmOC3eeL1GRjI465rN8BZu1eKf/gSN6fFq+1+Qsf/AAWH/ZIR jHa6H40uIblzGki2ttK/+023een51bk/4LCfslwiNktPHbtLGYbaKDQLW7nmI44UnOR3B59qlcC5 0kkk/vRX+tdPZL8D/9b7L0f/AIKyfseX/wBpji/4Sc3ckZW4XUdEhtRGyg5G+QLHnjoDn2qex/4K jfsgXsKg6trVtb22+5QHSrAh1QYbBGCQCCOM1+yS4KzyEuWz+Wv4o+NlxRFK+hJpv/BUv9iK++SP XZ7W8JeVpdT8PWtmkmOMeYygFsdB+tXF/wCCm/7GUMkM13rl3Al7ERazL4TgkYoD1WQKwIJ7DNTU 4Kz5e7aVzJcUQcLOKNaH/gpJ+wxeFvM8ftFLHB882r+FViYgfwL+66+yjmvxI/4KcftA/s/fGC3s YPhBqlrrK3Or213NFYaINO+z+TuaSV5XVXBcEDbgjrzxz9Fwdw3nWXZzDEYxS5LNar+ux8pxVj6m Z4ajSwyXu1ISf+GMk3+H+XU/G66S+kntIovK+yvkTZYh4u6sOxHUHvTgt/asEIhlsFUh258zI6Yr 9k5fe8zmi00f/9f+aaLVf7Vij+x4KoSizlSHJBxgg+mK6eN3F3bWErxiWb5N+QyZx09M1/cdWN9D 8TpvU/qJ/wCCClvJHoXxFWO5339pfxaPYRNbYheFNpl5HoQpB9zX6s/8FN5rOx+CnjCO5KwrqGi6 jaG92F54C2mkYUDsSUye272r+Yc0g4+KTS/mR+wZ1Z+HFKX9z8j+DPXIrXR5WijeK/mCKpW1wzvk ZH8+tYvzG9NpJbypi2EzSsMBQTwM9/Wv6N5bn5XgV+7XzFGn7ZUeMqYs5SQjdsb1x7V/WP8A8EI7 +a6+G3ixrgfadRg1eCG4kWP7PJmNGTcqjjDL5ZI9fpXwPiZH/jGar9D7zgKcY54v8Mv0P//Q/Xb/ AIKthT8C/Hl+F8y+sdCnsEgMbmPypLcF5OOjAuTk/wByv4b9UuNO0/UrG0W5S0e7uEWzNuvDllU8 sQepbJJ9a/ojwnhzcNS8mfnfEllxXWv1S/8Abj+i3/giFJJbeMdf1KJL2QxTzWknPlQKI40jMoxx k7s5HrX7rf8ABRCf7H+zR4huBFPHL/ZmwGCHzblQbeYy5B7EHH51+c5tFLxA/wC34/ofoeayl/qS 4/8ATp/qfwefDye7/wCF+eHZoEsYYT4htLeS5IK3czOVkCsvQHGQR7Gv9EH9mu0t9K+FnhezWFbo WugpcpKRkXI8pJDkDuxY/lX0fi5Hlr4JeX+Rz8AtPhyt/i/Rn8gX/BaSWSL482V5BdNFHqFtcNLD cReUtlIt5bx7CSOEIm/ACvtT/ghCDb6V46lmIlmt/Efk2gDmS2jUBWkH0xnBr6XjGmo+GWFkv5Y/ lE+Q8Nq0qnFWZQeyc/zZ/9H9zf8AgpDcXlr8BNZuLe4u7bbYTYkicKkoeEJjGOcBnNfyB/sPftS/ Fj9nv4ywaZ4U1TzLXxL4mS01fSpo1likkEoV9mR3XgsOmPxr964HwVHH8CV8PX+F3v8AKzX4nw2Y V+TjuMV/d/HQ/uw8AapceIPh9o2u3luserSWMd1P5aArP5gVsntlc4I9q/mU/wCCr37aXxK+H/if W/hXoWoNJo13pYGozlAbmMTXDwlnY9MY2qgxwSDwa+K8MMDSxHE1SE1pCTkvke/4n154enTor4ai 5H6aP79PxP52NbvWvr64uJ3idLs+a7hQrzSNlmdgOMknPFYcTYSSESEKjZITliM9K/qCKcndn5lR UYpRWyQw2FrfWEjhZ1cSkSCZDExA6bfatLQpJo9U0Ww0/wA24kmvkhlt4/ujccKG9s4P41xY2NqD b8zrwVvrMUu6P//S/fX/AIJ2afLF+zD4NsbkP/bDeHYm1CR5xIVZUChQfQ4Bz71+Gn/BbqzuVvtE aFnl8rxRbWYhjAVJZYYPOVXfociPjPoK/TfDp342q/8Abx4fiarZZhEv54H83ltbXTy6hdSDdJJC RIT8rkHIIA7cV/ct/wAEqdPgk/Zw8JaddWwKrpFvPbyzKI5AQmEUHuRtJJ9SK+t8X1bJKf8AjX5M 6uA464h/9O/1R8af8Fvbj7D4Ct/sjO2pzxw7raWISWwU5CMTngrtBPrvr8lP+CRVkdf/AGj9L0to p4JoJZVu5YPktdRMbQE7ieBgPgAeprjyqfJ4d1Zf3ZHz+TpS4/lGX8y/JH9kHxb0K1T4ZatYWwEk qabJHbjYX89AVVlP5g/hX8Df7T8kVv8AH3xxPb+TNZWXjsRzOsrt5W673NEufTO0kd68fwoS+qYy 3b/MPEKaXEeHgtrv80f/0/3K/wCCbqq/7PHh54rW3KXEccsVzGSWki8lQoyeu0jGR6V+Sn/Bbkpf Weh2sdxDPcHxBHKftY2fZYVRVLA/7RUn6Ia/RuCXbjyrf+9+Z894lyvkeD/xQ/I+Rf8Agj3Kmo/G O8hXy9Vjt7qHehRltEZd+2QN0+U4yO+0Cv6sf2mLe0uPg5ew3kzTJqOkwWyQQRtt8xVJGCD1J4rD jG8uPaT6c0D1H/yQU0v5Jfqf5/HxpurSw+IfiKWCCaG5v/EWo3V2jkmaIrctGUYdfl2gD/8AXX3t /wAEmIb67/aLIa8ltVWNZbO3EX+tQSQMc54wxyOeufYV+zcTqP8AYOIb/wCff6Hyfh2080wqfl+C P7PvHl3ZeHfCL6zJEx/s61OpiEx4SRVK5PHQ89vWv5Lv+CiP/BQq6+JHiO/+GukaS9rFpmpNa3aW 8zSJbGCUSIxzwCcEAg5OBxmvyPw1yujj688TV/5d3/H/AIY9Tj/M6uDzejg6C0qNNvyj/nc//9T9 lv8AgljrvhrVf2aPDF3qOpLd3epWsMF7DG+y4t18sMRKoO5SCenGAwNfmf8A8FsdX0mKXwpcaY0B b7esUFvEvmSqg+WRnBGTiN3BJ55r9NyLC1KXH1fmVknL8L2PmuN6tKeU4RQfvOVK6+7+mflB+x3+ y/q37S/juzW+t76w0K2vY/LPlNaRXCs5HntJ3XAO1Ryx6HrX7VXX/BIXwPpHlfa/HetRvIvmQrHZ h0t+e4O7PXuc16vEPE9XDZm8PhbPl0fXX+vxOjDZZCjlGHq4le9U17e70+/f0+8+/f2O/wBlfSv2 e7uWHS/ENzq9jeT/AGieaWMRT3IZdm3ZgdAOT6H6Y7D/AIKLGC0/Z68aJMIt66PObeSePekZEeI+ MfKcnG7tXwWAxFTE8YUKktG2r/gd/Gfs6vCNWMUrKPQ/hW1z+z1uXu7Oxs7a51GWS61IWkHlRXEu 7YzsO5O3HPpSaLcta6jaXkN5f6YxbAOnysgmkBGzeoODX9I+zvRat0PzPC/DTUT/1f3j/wCCbYu7 j4C+HrS+ka4uG0aGOK7dcny4IY4xj0z8zfjX5Zf8FoNZfw1pliy2l2ltdXPkteibaCSPLiwByBuO TjrkV9twhTU+Opxe12eV4hy5ckw9u8fzR/MxBqt7qOm+UdQ1IwOjKkUl47qokPz7cngN1wKxb6a4 ht1trZYVRD87ycSYx2PWv6HqQUFZH5kpXSLGnMCuEBnb7r7f1FfrJ/wSek1C4/aCttOtFWz06O2j mljguPJWVkJY+YucEMqHnHVB618Xxkk+H8Un/L+p9LwlrnmH9f0Z/X38TSbX4X38rwSQpe6b9mjM Z82GMFhvJ9j2+tfwV/tAB5fjD47le0gS5tfF00bTqmWKhVKk57kn9a+F8KopZfifVC45XLxTTt/I /wAz/9b5C/4J9zQ6j8fdL0y8t4bv7SIYkiuI9yIpceYQP91ycDn8q/tI1nTo9J+FviKGys7a1jtP D7y6cMbCS0YCHPqASQK+48QZS/t2hSvpyr82bcPRiuFJT680vyR/Eb+2D4r1q++PPiiGHxPrFp5F 20jW0crIoEZVNobuAVPHufarP7Hev6pp/wAfvBCx+INTZNU1HCxwXEm+MD/WKSDnbznHqK/ScxoU 8PwzNxil+7b28nr6n55w1OVbH0nJ/bX5n9uKaVp8nwmFndrvePRgBLcDe92Ta5ZmXpnBYYr+Kv8A b60aPQP2i/E1roiLDZ2OkJKLoRorB45i67AOmMDkdcn15/OfDhydfEJ7W/Rn0vG8YQzHCyS11/NH 9GH/AASt1fV/E3wu0e+1q7F3bvpkdtaQu5EP3Aw2oecDb+ZNcX/wVwsToHwxvdT0CzS21GwsPtkl yqBAU3bnWRuOPlyMf1rgydqPGsqa+Hmke1xhU/4xyFVfFyw/Q//X8F/4Jn+KPFUn7QGmWl14lvYE mtk1aOzWYtaXaljuhZR244X2B7Zr+wHxl4fj1b4a6teXUEcwuNHdYLSULsVmTp8w6dQfqRX2fHDj Diej7NW2/MnKIe24RnOprdP8kfwz/tPwW2gfHD4laIbOS3sbPxDJC+lwFTEJAdpZT6BsjI7fWvm9 WkmvNhTZEcY2H5gvev2ulH91BeS/I/LMFK1CK8kXE0GJGvbyzllW0ZvkF02JXwSOFH1z6VkP9plu I4FldIogX3s22FcCum1lY6Odk7ajNeWkItrh23XQSZMZDBTjP45PP+NfYf7NP7KPiL9oLVpfD+j3 /wBlv/PN39pkdfs9jBEUDlyFb724AA5PI4rizHExwODnjJK6ir/ideBpfWq6oX3v+V/0P//Q7/Tv +CPnjaSFUuNfWGfzZHku4dR8izlGOAytkcDptI57VRH/AAR+8TRLKk3xChl1C5IS1sVkVxAnGSZC nDdR079a/XY8cxle8V+P+Z8w8jdrxb/r5FQ/8Eg/GUt+fsvjCazZXSO4jmuxHCqKMFkYxc59sk5r om/4JCeJprNLa+8ZaXZTTI6JenU3e5U8lSQE47cEEe1ZT446OK/r5h/Ylt2/6+Rz0H/BHnxLfKI5 fEq3tyYRDLey6n5NiCrH50RQB2HXn3rUs/8Agk14qbVGsp9Zss6fHsMsUrW1pc/Ljcqdyf7w7ilL jaDuopfiZf2M+7IZf+CQXjYak4TxNYPHdusiWhufkSNOoJA745Ix9Kqn/gkZ47uxffZ/Efhq5leZ /wCz/tfnzSWSgYKKMoCM55JJ9qhcZ0r6pf1/T/4Ni1kra3P/0dc/8EfPHp1MWbXuhX2mz2irc2lh qhiggkx88jkcjPp0479a6LTP+CRPjizh2WfirRrUCN7aCym1iOW3TsoC7GJI+or9W/10gtkj5pZN BbtlG4/4JGfFe1hjns/FemzXVuwiuDcXdvNazB+copUFSOOtaC/8Ekfik9zCdT8S6FJpwi+TTRcQ yOXIy+9lUZU9tpBFXDjak7pw79fu/rT5C/sV9H+BFL/wSV8b3VtdNBr+hzNbYi+zOjFVUnAWILnc V7k+lUj/AMEpPinpqtapqmj3K3ToYHTbEtr8uCCTyFzyQRnJPWn/AK507ax19TWORN6qX4GYn/BJ D4jpPZvfatZsA/8ApYstSBhZs5B8vhunXAA96sP/AMEkfildC4uZfEfh6808Fmsbcan9guwAejq3 A6Y4JP0qv9dKevuL7w/1fvtI/9Ldt/8Agkr8QpLmQTa7piwG2jlubWO4EnksD8qrgZHTn1qW6/4J T/Fq2KeTqfguazSRriAX0b2ssnXKrsB59Gz17V+uLjKg/jj+J83/AGBK9lL8CVf+CUnxP1C2lvZt V0qyMcAktprO/W2XecgCUuMsOgyQaLP/AIJa/GC2hgkS40G+d42S9fVNbWBEHqiBNre2cD2pf64U Oxf9hSStcz4/+CUnxulv4LeK58KwW+zzrIw3cKucfeVtud35D6UXf/BJv4spFcsNaFpNep8iQ3sJ ELq3zcMCMHHRccGr/wBdMMvs/iZyySpHTm/Ajl/4JS/GO1s7iyl1TSrqe8iR11G41BIZbMKMApEi geucgk981Ttv+CVfxeaWztE8Q6fqUVxlJ5UuYIY1xgbhKyDBznjFH+umE6r8f+AYLKKi2Z//07b/ APBJf46tcpb3L6dDEku5Lo6xAkKRhuPMWEEsSPpn2rV1D/gl58a7GZFdtAuYHUrbLYP5lxGvGT8x 6nGelfr3+uuFX2fx/wCAfISyeolv+BWP/BKP4tz3j3q37SW7qHispL6GBoyq/Mu4IScnt2pr/wDB K34lHFuLi6tLzUYzLLBJOt7a6c8b/K25h8gOAcHrnj0rF8Z4e2iIeS1JLczl/wCCTnx5to7ubTdQ 0LVDJeq0MWrtAqoON2x1BYAYHAH8zUl5/wAErfj9Ppy3Ru/BNndQzNGES5lmW6RsDjjClcHg4+pr 34zoJKMpq/qjljGbp6Rf3FHTf+CW/wC0MZrfTZJ/C8kETnN8kpg3gjhVBzkj6VrR/wDBLn42PCjS paXM1u58m1Oow20HmgkfO20l1xg5G2tXBdCL3SR//9SvrP8AwS7/AGhL1w8Wl6Uuo2ERjgaxnhur Vg4GDKxYbDx2Bx6UD/glf8dJFt7fVdGjTUkjEsZsfEEOy6IGDtXbgc88k9elfvigj8/Ld7/wSr+N 1ralIbm9izcJKtrf3dvMkrfddFdB6fXpViD/AIJc/Hqx8xG0/Tbm0Y74JV1GO5ugwGTGwUBV59ah xtJXBPSSKSf8Ev8A9oq2nzDpcOr3xiZJIrrVLe2s0ByyZZc8gcdKyIf+CWnx61ScwX+j6Dp2o526 e6688sEMoPLHCYK8fdIPbFKVSMZayVzPlm9om5L/AMEw/wBoiwhEE+l6HLm5A1C7cny7pFH3SR0B 4Gffr2rKT/gmb+0SjXcJ0KwmuWH2oQJI81vZo+RGIhj5hjB571S5lsQ092f/1eZP/BLT9pi5vIYg sGm2H2XZcxTIuy5kGSHYHJUc4+U9ulMsf+CYH7Qck4ia2i1QTiW1H2CJ7aG1kQffMhyCBxjnFfvF 7s/O46botD/gmB+0GqPax2un3N8Cixqb6N5YXU8YVUwQcc5/Oorz/gmj+0RNfqL6zWG6EAja+tZE EcQQfMHBU56cDNS4p6lcyvYzrz/gmf8AtJjbH9h0m+trtgukO10RdSHqfPiVcrx+HuK2tT/4Jrft O6DaI9r4WsrqxuoRHdS2lyJJbaXGSqgEsQOxx1zUS5U9ZGkObeKK0/8AwTa+PSXmk3Nj4Ou0hsIj PemLUzeyX5ZDj5WjHltuPXHHp3rAvP8AgnT+0oIluLz4byQmWUtF9m1IyTWqs3HnR+XnB9R+QpJ0 tnJfeaxU3vF/cf/WwbP/AIJ0fHyCCezbwoLN3Ie1lkd3znli/wAjHGeOMdazx/wTv/aHhhurd/h/ qKos7SLcWsn2k3wB52Axgj1GRmv3iNnpE+Hem5nQ/wDBPH43OmmSR+EfEMF4biRRFqKmKO6AzhXC pwQcY5HSqjfsG/H6AW6ap4PNvJBcNuESTMe4ADbNp/A9qtQbRHOiyn7B/wC0ntSBPh9qavcSlYLm 2iaYSoP48EAcDGRVJf8Agn9+0kkl2LnwTrd3dIN9qltYsYrhuTlv4sdjjNDgx80UZz/sF/tMmO+N 54NudL8myNxbW76ZcsJpiQACSo2rzyT69arx/sEftKFB9p+HWpW8yWwmmuxaySpcR8Z8pgcA99pB PSlyy7ESknoj/9fyaf8AYk/aA0ySNl+Hl3ftNCkdshuZVkiXuzjy8Bj6dqpax+xx8eUSGc/DzVYk nvY7K38uKW4Ck/feQhAoUH3zzX7y4yPz9tIPE/7HXx2sbW2srfwVdNbTYj8uOGVBfTgElOmVA5wT WJpn7HHx5+1/ZtV+G2q6NppVXtzCZNSlkdsfIDt4zk9QcdOetZumLmXcni/Y3+ONhduf+EU1n9/e 7IdPuLSWOK3QZCl8KST36CnN+zZ8eIZ2upfhtrEn2S4FkEtrGWUXZU4BICcD61cYtLQXPErzfssf G3T5ta1DUvB2sKL6Qz29jpdifNRj94kN94qD26Vny/so/Gi3s7CceC/FB+23bSm1k08zStGwIXds ztxx1x0PFDit2hq3Q//Q+YD+yd8c9MME/wDwrXxpdh3YXE+maeL2GfeSQnk7t4K8c1Tb9nL4t2Da pNL4E8RO7PHbQ28ugz280GTzu6g47kHgZr94tY/PzVtPgd8ULTfZH4aeIbeSRxG1zJpx8oKeRJG2 Oc+g9awNM+AvxVS5kx4F1wyNeNCZGgeF5lG4oVynUgY4yKirF8txOfLyrzKyfs+/HHTLu28/wZq1 xZzRSNeW9/ZtZXtpIGO1Vd8BwRjkA1q2fwW8bpZ3Wo6n4SvtKkijP+j3tlOXZgf4WjRuSOgIrR3s kytCU/BP4gXLQXNxouu2FveusMRtNIulcoRgM5ZBtGMckVia58BfH1vCTpulajrEYn8u7hiimlli HVd0ewEZx15z2pq6eppK1j//0fii/wDhp47037Db/wDCEeJI7i7dV40iW4jhTIDSNsBIA9MZ9u1a Fp8OPGymWK48KeJtNtoozMLi70W5iSfnjaCmeT64+lfvvNLsfB+6ndMfD8M/EqS/ZL3StVt5Lq2+ 2W6Po10jsM8LymMn+tVLj4ReLBb2eqXdhqmi21xI3l/uGkt7hkOMEYyp4zlsCrjVVrWMJRd27lA+ Bdet1lTyBcziRUX7GRKsQY8M/OSR1wPTFWLLwRrirc3V9pz3VpaSLb20zWUqXM0r8ZjQgZ255K56 VHOhpSWhUi8BeLn1AqNInNnI5CTmF41Y9NrZGQffpSw+Hryz1BdLvPD2oyXULrbXVxHps8Vh5knO fNI6Lntwdvfmn7Qhxe7P/9L4wv8AwbqcUiQB5vIwZ5bmFU8mBF5Ikz6dKtWvgyURI0thEjTI00F/ NHuiZf4GyfUcjFfv3tOVpo/OXHRHLSaXd6bqUP2iGe+vEUy+VZrLNYsm75GMgG3n2OR3q7eaBrkk 7Xeow/2XcIATa3M2Ldg5PliMAZJI56D8aftbqzDlb2MjVYLlkuLe0uYorrSir3sBs5ZhMSB+7iIA yRkkkdMYNWP7GuncyILgTNBHcXKeU7BI24Bxjjk4NXB31TFyvaxsxWq2dgzPZXe4uAqtEczZ4yg7 5P8AOuclgaH/AEaeMWRmnYLaNEVlGOxXsea0Ts9yfZ+R/9P8/Hi1a5tUEcUrabBc7J7uJTIsa/wp kZK7j1zVkS3X2HUre7s2NnCyRWTqGR4WG0syKep6r+Pev6H5o9z80lTsrpGjaWPmsscsEkm6JWgZ oiyFuysf4SMdDzVe5srm5VrS0iZbpXKkFCAB6g+o9Kal0TFCPdG3YQPeWEml3WkKbjTIitvrFvEy tIWIJErdH44x1GKxX0rUZJY4YrfZCVInMsRxjHAHbNKcpW3NoJN2Y6WxI0uCGeCZLmeaQW0y2bhd qgn3zwAcH8KfKt+mmpb29oDJbwrPkwmPzwx+8ffANK7ezK+FvQ//1Pzy062ubRLuQSXEF3PKbh5J R+8jPbHHTA7VJceHI9QTzftVxPO8wuZSZt3m8gfka/oynJxR+cygm1oaUwCSpbyNJAkEW2MSt+7Y gAttP+etT2mJvLWLZKkhKCV3xH6Dmlzyvcv2aRLqOh6hBLAohtC0i4kMUpKP16HGMj8OlYENneR6 i1hCJlCRGeWPH7vGcbv07U41LPUmVO60NiGyvN5K3ImhUh4mQFVU4GQM9weD9KyL0SSzXBmkcspw SQQoJHTPrW7qNbmDp2Wh/9X86Fm+zafPG8bSvCDI03LTRg5OOD0rI8y8ubeK42syFcDJzIcdBiv6 ahUi4q5+XqDTZqm01eW0sks7a2Yks7mQETyscbFwBkY54460+IS38su6ykGoRHyrrCfIhTA+n1Pv WylFKxMou+4SLNbgPOJJApxhBucAnoB3xn+dbbWpsZ4HVwRcReYJ1kDlAeMcdO+QfSnCfYn2fmRx mNYpbWRbeS5LF/NZAZSuePoBTIbGK4CJJn/WbVnVCUjPPXHtmuiLjcPZs//W/O5N9nHewNI96PtH li8gBgjtRnGfw/PmmXdhc2ky3cs0d2srZ3KSCoAGA2Rn1/Wv6u54n5Q4tBfSprN7DsX7BaxRKsq2 /wAyxv08xc9zjp7/AI1ctYNQS3nNrq9vixuFeR76LfLdYztZUAI3YPPp+tJcr2M22mZ9gZ729iDy +SRMVMrHyzjkZ6irbQTX12kNrJLcLb27mUAZXC/edm6cYqbRWlzVSaVkY0Ftqsa3ctu++AYFrJKD L5Zxz+Zreg+2XLGSGQRtJGEkMQ27h06DtUy5Vsx87sf/1/zqTTTbvLEsixuxOyPGdxPP86zLOLUr ecPb2izXAl8skc457j+6ea/qdtLRn5VzSsP1aI3F5Czolq6Hy7uJOY1YHrU8Olv51t5rrJYTy/Zy y8vk45X6Z/WqSTV7kN9SQaUsU2oNp0qapaabIYZZpP3QiyM52nnI9s8gVl3d79lutPkgCXBm5V4T 5iwkZzv9OlCSejMne+xmA6g7SBnk8uSYmKONS+4jIBx9K0rZLyezkxKLPy3Ilmm/dkYzginyq+5q r2vY/9D8w7e3vxfLc3E5VyMwTIxyeoIz3HBrUsNPnjvrq3v/ACZ41nLxYfAVMcH6kg8D2r+reRdG fkau3qjRuTaCWGPyfJhlbZNIiZaUcAnHfjH5VjDQVh1Q2sN9HL5o3W6zyLGJEJzubuDjHHbFZyjy 6GiVloQX9sumw+bNdFoclSkSlvLYHqT6H2qHTrePULyBYJF8+4KxIznYDk4H060rEuCLP2K5n1CX TQFm3SGBZIm+VyCQcHpj3qlf6TNAi2sUEV3GsmJIbo+ZEhH908859aCJJJ2R/9H8yYVSYLZiEFnH lmIDoemBRDqgt4prKz09J5WCwxTGZgyYPzfLjHtX9SPR2sfj5Xmhe5icMv74HgKuAPbFWtMhWIRP JGrfZQxeGRTtlOSRu9qOXXVFXtG1xq2cEkc9zJOFuCzTNbKuIMZ4UemOT+FUnW4l0ia/jgmeEt5T Sx5+zQkNjaX6ZJI796rkj2CMmizcoslk1pLBscwDzVC5OCOD/OoodRmsI1htgwRohAqsCY8cdR+A o5Y9hp+9uf/S/OGUW0dhbRSItxcmZy06DBCsFwPpwawY7y1tTcQzR+bOhHlSx/eQZyQVHXI7etf1 VGNz8ge5FcamzveHQ/tyWOpKsEyOjW1xLsAV2I7cqcEVraPc2SFIr+IyIq7YPPkbcWwQMt1NbpPW xhL4mYn+nWdxqJ3WyTzS7LeVAVjlTgL5nc471Nfwi5tIknnju3jYNJJGhjjBzk+WDyPxpWbdiZW5 NDF8RahDp9qLm7kll2QhbZYh5zg9FQc8D+VfIX7QmvXa22mR3f2Ux3Vl5jQK48yFXZ0jHHAO5NxA 9c1zZ1C+T179jXLH/t1Nruj/0/4yPGtzfXrWQlljhhs90Nx5QObjkkM3ckE4B9K8ya5gMksTuwPQ HpkGs6v8afqy7tQj6EV8qaYY4rcvNDKgZWmXOxz95c9+elaeix3st29rFI9mbiMQl41LH5ucEevG R9K4a6smTHdHtMltqm2ATyx3a2VkttIJnWMxqoAUqFHUZ6U+3VbhQpCMIO4GSPavPlbl1LlJp2Po 34IBre+t72O0037PG8ka3Pnh7j5iyOvl9AeWP1xX1HPb2KtBcxWf2siQoqsc7T2+UYP414eL0qM0 odT/1P41LWwjtprqeC2wZZ993NIxPmk/xZyePQcfSvYbGIa54alhAWy1Cw3yWzyR4e+DY+VmJ4AA O3b618hUV4pHJGdptGVY6Xqs95pkEjxXIh+T5cReSX9x154JPau5u/D2u6db2y6wlrp4uLmQxfY9 QTU2kiXGWbAG0/N09utXC0Y2OiD3PDrq3u7PxHdw3hW9sw6m0mkZnePacgqvTA9ajvL3SkvebpfK kbbtcDbuPUDPGRzx7V7FFtNFQs5HmGrx3OtX0S2Rjh0yxuXRnceWLrIIBfuMd+fSui8J+H5be7tL i91H7Jf6dcpd2z2rq1s77vlTecjA4z6+te1gZP65C/dGeOV6E15H/9X+d7RWmXSLK4tEmvLi2sYr jUZJW3AnA3CPHbkAV/Qp/wAEUPFRm8dXSagkU9k9o86QRrsMcixkRZU9XxHtx1yoPev6x4pTnwDU m/5EfmHhk/Z8bpf4vyZ/Sh+0WC/wT8T3NrAF1T+zJ5dHnExtZEZI95DHrtKBgfrX8Gnxo02+tPiT 8RTqskNxI/ieaS38ohgFniik++AMkbgD1wQa/PPAnllicVTe6X6o08ZU1mdJrzPnmX7Shs5ri9jW SJWtpCwLHb8uCM8YGP8APfH+2zwSG1h8i5jtoBbWchk2QldoA3KoG3twPT8K/qOnRjZn4r7VpcpF Ne3O21hadUd+biOPiLPcAnnHXFaukGeK4klW7SLTooSbhQS0uCRhUXPcnt6VPsEtCo1Gmf/W/nn1 Ka2v9Pa+tolw8n7i7EbRXWV4IYHn8xxXOKLwJEbLbKS2b1ribayBRkkYHfjA96/0N9mlofyk5suX rQTPBPZfeSNftcBOWV16Mv1xn2Iq5FqdzErM6TNGB5krNGcxL3NLkVmXGV72JNStYLhLW4tLrz0n jExOwopJzleevGDn3pLe6njzptpaR+V5ZVnU7Hyw55HTFNQTuUXdFQ2wmihYpceWIoZV5kB6H8f8 KTWkn8iW4m0+4u1tCsE0lsvzIzHADegz1pqCM3O2iP/X/notri72oLZ5YkSAwfJKVUgjBVhnkEet VLOSRd11dQ2tz9mkZIBKpGwdDs9uK/0M9nG5/KMarTJ9MvtL/eW14im4mLMoRCpzzt56dKuabN4e WbXrJL2SC+lgWWPAYR2xVQuAPcener9lpc29toO00DULKZNQuFg8iIrbzXCmROOvy+/65rM+3XFj amxTyntS4ZLi2iMRTk9c+pqlTTTQvaWZrS6jIuntZXc/npcKMysxViCPusfYHFU/L0cWglTa88uY YbdGIZQF++X6YzxgenanGGisawqn/9D+eO78bXawPotvau37iOGS4C+cEwQN4yOvvV65ljurBNPt dLae9hRZJbmdTO3l8b9jY4z6ew7V/ouklsfy3z3e5kwSPEdxW6t+MLbXKeW6AcZx/I1YOl3U1lPf ySM0b5W3P9zaBuye/UGtNlZoxkm3e4vh9k3rlFaKMjLr0fHfIq3qDzT3N41ipSKWf9yGYliQAABn 6Y/Clbcyd0c2ksjktNLdW95ZTbBKYzDLu6HaSOhz24Ndtp15DLpihjZf6O5f5TtnJ7hs9Sfai10Q 0+5//9H+fWGWS51W4hltils9stxaKy5UDO1sHvzj866Pfc21zHp1xHE0FzCskBxvMOee3TjFf6NO J/J0b2OVudHvE1yeRbqUxRxCSKOQYCg88D/PFWIrpfKtxIkaOs7CeTeTJIme47Ef1rCULbGkW76l 25ubKzmuo4Lu6uNPmI3xjISc4+TKexP6mqaWOpMjahbJb5edEltpbgoyrkAtjB6DP41nyrc6ov3T obfQr3UTmDdCkS7tyDejYOCARx+NR6tZXumRywMlvswPJYyZ356kjHUfj9ajlSWpZ//S/B65vv7Q 0qPTRcRwIVzctNdFrFmxgMyAduRnmuW1x7vS4tInmZkVE8yBIeLeYgABh/MfXNf6HKPu2Z/MF2OT ULu+gWaGGa5GxbiaMx4aLJ6rnqBwSeDTGnvYrxLyGae3uRuHmxHckxcdZPcYx/8ArostRE2gSTS/ aLfU/Mhup2dpmHMg7KQD+Fam68trZrECOW6E4ddkmd6HODgZ5/rmqtbQyalqUp2SHTRLdWpa6u7o wZU/LbqOQ2fXpx70ljFeR2KkJH5pZ5Y44m+cqP7x6/w9/epkvdJasf/T/n9s/EmfKFxHLGFJWSMr yh6D86i1C9ti9tOLeSzW6bCwuDnPQkexwa/0MUbM/lZO5KkyM8f+jxSkgqoL+XIQc8Z/KudaIXMb tczRWsUTsxaZyAAuTg4BPOKmOjLi7M2LDU5ZII/3gBUHy40O44yQvv0x+dV4be5l1e6uddjlkiCB Y4nXDR46Lj34z9KJKzNE27HSRW62yvLpcvkSTxMotkPykgDB2flmsqS/1WGzt7W8sSbwSBWyNnXu D79aktbn/9T+fiGHVFvWtdRgazt2i8+G5yGiyeig5wf6Vt/a2jt5I2jiP2ZeJVXEsoPdiOp9AK/0 IP5nMhLlhNbTTQ3cMUoEkRkjMZYZxkA/54rbuQ092kM+6BkUSossJOcjKFT6ng0DuzFMviMakftj y+Tb/wCpSXHlqPb68HHvU/27UDf3dw9rDcs2BC0eEjgIGMhe9JrSyJk2kBhu7eJbq8WTJG6VI+jn 0BxVafVrTTmutVnjvYbKVEht7dfnWFmIAZyB75NKSbVik3F6H//V/n+Wea6WW9trOW4hsHU3ALiI SFhnA78+1NsZ5LwxS37EWt5J5fkwnfHGB94E9zjGa/v/AAsOWDVj+a6km2JPrCf2io05WMCXJtkt DAUiQIcZPHp1PTivRHv9Lk023Weyggv7iTYkwkLJG3dRnt707dDO6vY5PV0sla3D3EKs8pRSwAjg IA/j6c8/ka5vThY3cU1xsmnlS5a1txE/7kMpHzkY/EVtFNKxlP4i6q3OkriaQzJcMVkyMKc/dG32 559R70sVottJHJejNnOdtvJE4xGeM7h274p8rdK3mVTdtj//1v55NYnmm1G907y7qGxiGbKeJt4l AwPndcAHJ6fzq3pNxdW3+iyRk2aR7g7vyCT/AFr/AEGqJLQ/mON5TubU2rGIy2xtVSE2/mNcYKqo BIx6dq5+K7tp38+Akh1xG7rtLDPb2qZR00NUr6IW+1Fm8m5S1MgsiI51in2+YO5q/FJHdRI8e75v mXcOQPSspNpaFqCtqQ6hJLJYPIlk2yznEDW8I3Nc7sYcj8/yrTvJ0/0WJxbi2mjRS4TlDtBxjBxj oT9azfM1ZoajHdH/1/wWt9C0qa2lud1vBcKNsJGAzdM8dRnAqG0sNM09765uo4vPms2SEuQHL9F5 /wA9K/vnVbH85RjFrVnNaaN/noXdlFyHGyUzMrgj5VP9329667UZrcJDDBciQyKDLE8Xzo4HIz7Z pxlJaIfLDuYd5HbXEBhlxl8BwON+MH+laCXMM/2a2YxI0EW3AUKzr7+v1quafYuPKtEWBYRRW8s0 SeYkX7za7BjjPbNVBJalVlVGS9HzAM2FX0AxU+92NeZctj//0PwX064kuJ5ftbqq7eFzlmc9B/ia pajZb5bmMzKHZNqGLh4Oo596/vu0n0P53vYq2xm014ts7vKBjdN8zSY9aS5ijubl2umeCwuQovCi 7pMg87T+FKcdmQpu9kOm1y1juFeKe4ktI3+zG0IZ4/LHI/GsA6ve/YLtFu7qK2e6YQW0kYMatnPX GePqahxT3JlJ3CH7TPBBOl1LbNA+4tHzu+oNbMiS3NzDdy39s1xdQ+XDErhmkaMf8tB24qXTRKk+ jP/R/nvtFlsLa4vbiN/tMjlBHj5eDxg/hSm8ubtLaa1Me7AaaBjmYeoH0P8AKv70VKK3P51VRvQ6 jTtQurZBJc2jlfJ3Rs+YxJ14I9sU+21KPUEj+0WsGnzTTTM9wkh8lUUEx5yOpxjv1rOVLuWpNbFa S1gvITPPJJIkaEp5ZAUnBxn1FOsls4YI3YYkJ2kYGAKzdKL1ZcJuOhLPpv8AaUy7mu4jG4e0PmGK N8d8DqOnWsjVtNeykYl2+3JGY4UBygJ7kfhXXheWk5NF35215H//0v5+Y554UjiLiOR1yW+6vbOD +dOu2dbWKNYhM08oh80ybGAPBJNf3c4Rd7I/AIydkLNpz3Bgk3KWgQRmMnKsB6Gry29kvlQyOtlI 7M4uNud7Y4DY5wcAe1Jwi0VGVnqzIsNJnjvbndsjtZYmBYHksT94f571KITCZIFcncCjTIcMOwrO MIczTRpKbtdMq2EkVkktszecwJbMi45PpRPYrNA377yXH7xc+pPcVMoRu9DNyl3P/9P8A7I6p9gk tT5dwu7cFjISUjGM4znjnpxXI2d35lzcRzQlPIlxbSFssw6HNf3I4Rb2PwHmkiw32ppBJFCpkMgV mc4Tbnnj6Vpz3AtrxRb8W8qqiq/B3kDOPxzUSpx2sPnntciMMT3DRkzRl3EnmbflTH8IOO+P1NT3 UEAEPmWguAp2qsRDTjtu9R9fao5F2MvaS5rNlyKMwWojBEaRnesfY/8A16hgljSY3TAK5Hlfdzn2 NRKmn0OiNRrQ/9T+e1HljN1Em5objkljnYfb0qdWe1sPs9vJ5tzjdGZvnbNf20qSsfgzqtaIaZZL p1tNRgiM6BZGfYFcZ5HHb1/Gt5DbxIgXflVKlS3yv7kU/ZK1gVWTdjmbrULq1m3CzkuVLbQsRCla viWWxkRLuNWhvB++abIaDIzx656c9q6HTVrERlK5TuJrd72O7huHls4R5cUWNoQjghQO+fX0rR1K C2a22rc3U6yMspieMxwIRzwc801TSVjOcpWdz//V/AiBFmhkuZrjAEQjEI+ZVwOMD/PQVzd7bx3m nXIjmMHz43FcSR4PDAH6V/cfso3ufz/CUuXUuX07/Z7a3+1TT/ZoVX98fmBwN3HQcg+lUrK9tlmR HKiUHgNgVm4K+iHdnR3cd1G8UmzdCw3OhyoIrlWtr1r1bgAhlk/dMjY2nsBVQgr7CLspunRpispm icrLHKpBbBwT/wDXoxbhRbxzslzcMGSAjbGPU7vr2rZQWpMW2f/W/nq1WCMCKNxskEYVuuG96qy3 QjtuXLGPCgA88V/cUklZo/n8sy34W2hW3J85l3NlcbPQ+9RTTeVHpc7zi5eOUy3cTxYDEbgq/rni ojBXNVNNalK6S2lv9sgks9yCaKTbhWbrjjn0/OpLW4+1XWyQZCjBZeGbHT5fzNaumrWK9pbRE1xe QQRSTj93AnEjuNh44y2fpSQ6hKLNJ3iElvIcW+9TsbAztx9Mce9ZOj0J9q7n/9f+dpr5nDJPCtvN cR7QAuUC57DtUF7OZYxAJWkZFx8jcMR6mv7eVC+5+D82ugliUS2J8uZLh22BscHsTj8KsbUQo5kJ ZXxIgHLVfsQbshbqJZ1Yqx3Muz5hwB9KaVEIjSF0DZy/ljYCRjk/Wj2IXvYiubi+tjDKJUeMuS6A EkADt+lZ9xfT6ipuLeU26wn5Mt1I+9mqVGKHc//Q/m+02QQSMpkkDXcu+dpZCyA9iuf5V1V8gaza NLhW8zBLLyRgg8/kK/ueVJKx+Cqe5zrCTEiOI5YyoCq8Y+v9Kzre8u/t0yCdf3aDZAiAMnv680KE WLnXQvPFPPItzdSSsQMBC7BcZ6fT2pyI9olwUKxwTgeZbJ8olI6Ej9KpUlctPmRWtrm5ys1u7WUs L5jVOFXqM46Hj1rbttPCRG4tbt4p4mM5lebb8xB3Ee5z0qlTSexV/dsf/9H+cppZnhjfKTQW0jRS yM+8ySPk/OCeTw1Zs0dqksQFtGk7xmKJzHwFYkkKOgzz096/u6NNbJH4XzheNp8hgsryzgHlp+6d Yhgnv05z0p422stnds14Et18uGEXcptgeikxbtvQADIq1S8g50NOoXM8xuooQJCxAJ+bb7gHjNTF IfIleRI0uXGWuFH7xvQMe+KfsrbGUn7rbG3Ud/cwwRxRpC+weU3ljc2RwSR1FXGtbrTIooLy7ga7 G1LmMrhwSufu+/6ZpOn75tGasf/S/m1tdsurNbxmONCuWwuFX3z0pl/LYtqNvp7TvHcpNHOhBMbS bGDfK3Q/d5x2r+66sOh+IQkr6H9TX/BCW60lNN8aaXe61apraeIGuYo4L2MXMNvPFhD5eQxBbg/U DrX68f8ABR3Qk8R/BDxDI5nKw+H76cXMUPnbGism6j/aKqPpmv5g4hUsP4oOdrK6/Q/ZMbFV/Dun STu+V/8AAP4LNSsJrXXtWN5YJbiydbVdiEBTGu1sqehBFaGm+H5NXvoC7TzzykWlnbrEzgAnkEDn A/L6V/Qk5qEFUvpY/LssSqQUV3P1ks/+CWfia8+CF18RZ4Wt0j0dNVhhiLyanKdod/nGFTAI4xk9 M9K/Sj/ghBbQ2Gj+PdIe51K6MmqYhSdQEilQoqbn65Gec+vQd/yPirPY53wrjZRs1CSR9/wthVg+ J44fW/K3r9x//9P9oP8AgqPmD4BfEKC6JMesaRPA1wnzInk2p3hvQYxyK/hR1ez0UXVrK8Md5LBa xhBCvmtGxQYA98mv6K8JU/8AVqdu/wCh+ecScr4qrJ9l+bP6Kf8Agh00cWpXcbzMxsr9oL8Pw8nm RllUj2wvHsK/fH9ve9kufgB4jme3ys2lNGPLfAO+1lXJ9sM4xX5vmiv4gpP/AJ+R/OJ+iZpb/U6y 29k/1P4LvDIa2+O3gOZY1gkvvEUN89i8W2MSRzmNdxPvjr2Nf6FX7NsJg+EPhKG4ENvPB4Zt4Jo7 W4MsgYIjZDcjBDMBz2r6rxgjy4nBr+uhwcANvhqt5Nfkz+Qn/gtXeSy/tG6Wmr+UyXMuoiSGR9++ GaW2CEcYG1kHpglcd8faH/BBK4SHTvENnBaJFb6Zq1zZzFAZ2u3dY1RpG9AshA/3DX0fGa/41fhV /cj+SPj/AAxf/GXZml1lP82f/9T9zf8AgpPZIv7PvjSzvbu6SI2c0UEwX92hFqZFx6ZZSM1/Dt8F 401L4y/DC+LpbHTfHkSOYhvkvGEwbOepDGMA/wC9X9CeHllwXVkunN/6SfneY+94hRg+rh+Z/oYf BgXE/wAJvCd00awyNpcMl06ThoZlYbiw9OSR+Ffxh/8ABXm2vLz9ovVZ7m5N3bXNnNDcWg+Rr4wX Af8Ad88lMr+dfGeFOnFGIf8Ai/M9/wAWL+0wkOnP/wC2yPyHe6W4SGa3t5raAkAx3XyzLg4O4dvp UzNbW+pQiBJJpXt9880T5gC8YBHr19a/pqC1Pzim9dex0iz21zpqtAJo7h5GR4Jk2Y2ngg+hpmkH ULfxZ4Yl0yMs8GoRz3USfIs4V1yjH075rizBWwsvmduAf+2wXmj/1f3y/wCCcdvIvwB8PXN153m6 tCUg2SealrHHEhYAdhuDfnX4rf8ABb61iFz4WnW7ns4IvELXl58u9C8FtIkOVHTdjafTzK/TPDz/ AJLiol5nh+J1/wCysM+vNH9D+aqC5juoPNt1a6Uw+bcqpNuXGeSpI46Zx7V/cx/wSaEkn7OHhK+v JJpVTTIoNP8AtoUGIPCrHaOrEFWOfVjX2Pi+v+EWH+P9Ga8A1NcQv7n6o+IP+C2+lCDwDp+oxvea lc3mr2OlALtjGH83afbLpGnp84r8qv8AgkFczt+0xDZIIrHz501Npo33NbeU6q8Z9N3yZz2FeVll /wDiHVXyT/M8PKLPxAlb+b9Ef2UfGZIbH4fPrLXgh+x2Hm3aRpuiO5v3h3A8bvl49BX+ft+0jLZ6 r8Y/GqL51pKfiHM95Gifu5EN6Srr7kHPv/Pg8Jo/7FjH5f5mPiBK/E+Gi/61R//W/d//AIJqWIh/ Zy8NpDFPJBbReTZROuxbOAxo4HPPBJz9a/Hn/gtuRY28tvHp4kvU1a1trR2YOzo7v5knHQqGTHs1 fovBCvx5UXm/zPnfEyHLkGEX96H5Hyn/AMEV7eeb4z6lplq1zBDDLFNKskKoyS+YWbPfBQDryK/q w/aj8/TvhLqF3pULPdabZRS2kWA8beXz93pnms+NVy8d0Y/3o/mepFf8YLUl/dl+R/n5fGUfa/ib 4/drjz2TxjexJJMAZlBlMjZ9tzmv0C/4JTCK9/aV0zTxLPLHf2kVpvt1xNBJDcRvkccg8jI9a/Zu Kov/AFdrP/p3+h8h4dNLMsM/62P7JvjMJv8AhUviZo7d/tEWjNFbJIPMZwWUEEj+9xx71/A1+0vB bj42fFTTjFbrcr4macNGAjkPuIQjvtIIzX5n4S39nibeR0eIa/4yHD36KX4NH//X/Jn4b/tS/G34 I+HbjQ/h14vvNGmvtQE9zClw628ShBGOnIwFHc+mOKdqnxZ+IP7QXxP8IL8R/E15r51O6t9Kvmvb 12EaNKvm+WGPGQWAx/er+tY5RhKdeeYxj+9af5H5TjalTE1Kaqu6g9PxP7VP2NP2c/h34H+GXhy9 0LRraNbiyQmaWNXbI2lX3nkMmPl7DPSvx9/4Kgfta/GX4QfE5PDPw+17VLazCTSALKLdbxVkCbiS CMIG4A9+vb8B4Ris84pxFPG6pSk/xP0njyosFSoYfDqyXLFW7JfhsfSv/BJX9o74ofH2xvrX4hav BqMmhs7wahMV+1oWIQwsi/eA3xnGOo6dK+8f+CjM+nWvwL16C9hjmGoabNZ3sk8fmW6qI9qSEdir MG+gpYrDQwniBDDU1aKkrfgcudy9pwPKq+sPx2P4PfEenf2VqWqW6C5SzW9MVmLtCsqhgGXAP8Jz ke1N8O28DappsUl6YnN2kgcjIUg4C4+pFf0ZyXoN+R+cZdLmpUm/I//Q/fD/AIJwSu/7NfgaZpVl uz4eSxkmj+XzNwyrFexwf1r8lP8AgttY3TaPoAMp+xnVplug8eIoxAsJBRjwTu24+lfd8HX/ANe6 nrI8nxDS/sXDrzifzRWFtam6txNNdCG2XcsVvx5nGAGHpz3/AFqre2i3VzOJo5Ut5FKRDO0ofUnF f0JVk2j8wtyQi+pr26QWFvFEwX5BiN/uvzxkmv1T/wCCTH2Ff2gJNPjeaW9nnspIUWAyhkLMZvm6 8Kw46fXnHxfGXu5BiX/d/VH1HCTtnWHb7v8AI/sI+L93Z2fwymvpQDaafpsc0dtO3lRzBQGAIPYh Tke9fwSftJ3bf8LZ8eXk7+S9z4uvZ5IVGy3tleVfJQnvhWXHpmvhvCqLeBxPqhcfPl4mpf4H+Z// 0fl7/gmlCzftE+HpbrT4LsPfRCS4lPlNbhsKCnrn5cj39K/tK8fC40z4Ya7A8KTpNocn2ebIkmjC LmNlX2HP4V9xx+v+Mkpf4V+bN8iXLwlK/eX5H8JH7WV0W+PHj24jZ5NMt72aySaSLatzPHKA7Rt3 HPI9TWr+xGGvv2jfA7eekKwrO0QVczFxsLKB3+U5GPSv03OnbhmS/wCnT/8AST804SdsbSX9/wDU /ukvEik+E6CIvvl8OpG0jj9+rmNYuPcgn86/iC/bvmSH9oX4mPNPK62l5NpLo74kZkVQoQdxyc46 Yr8+8NI3eLfl/mfScdtRzPBfP9D+lD/gkvY3Nv8ABXRjcBG/snS7ZYBGwaEttHmjPc8/ka8x/wCC x2oXsnw6vvOuII0FmwihhO0yKU+USD+6BuB/3jXh5JG/G8v8Uj2uL3bhmnfrGH6H/9L5k/4JgyNq X7Sml29u00TR6fbRHykDqhjdunfrgfia/tD+JtxBbfDHULu6Eixz6L9ntY4GwYpGK7ip/AtX1vHS a4poR9PzDKX/AMYVK3aX5I/hB/auW8Hx++I+wJPbReJ7mGS4ll/ep9z7o7qSDz6j3r5/tp54JvNt /JZsFH8xA2E74z07V+70Y/uafflX5H5Hgf4CQkl7eBZimybecJAW8tPz5x3qpa2kzPcrPsVUUk/O Co9QD3rq5VZJm92pD7BoUuY7eFACJNxAAyea+n/gN+1F4+/Zn8VXes+DRb3Gk6nGG1OyliVpROo+ VlYnlWAUEdRjIzyK5MdgoY7DTws3pJWOjDVpUZe1huj/08iX/gsj+0PeWkKW+m+GdLZHDeVbFZXu 14+Qqythscljt6VNF/wVw+OzxyahLD4XsL9Ti2/tK3SWc44PCps9+Tk1+7PgbBx05vw/4J8Ms3xD Vi/cf8Fdf2gbeL/Sb6znnW381l03RIVt4Xb7ucoGZBx6GsyL/gr78ekvLUamPDOo2xCiWSbTI4Zl Z+AfKHzbV74rGXBGE6v8P+CQ82xC1ubMH/BXn4xOwt5NO8N2UkcrwxyRWARbhT0dMAkfQgVFc/8A BYL4xQX4htdM8ORpDtija/hdEumxzhtgOCff6CueXA2G/n/D/gh/auJ7kS/8Fgfj/bzyu+heEZn8 /HmLHLKYkPJCHCgge+auW/8AwV/+MZmtbhdCsZYLWRvPtbKCK2WRiesilASPYMKy/wBRsL/P+H/B H/auItuf/9R8X/BZT44W1xebfBvhy4tfNBa2gslgu1U5O4t36f561X/4fE/GWW6s7lPDGkafGXJu LP8Asa3uElA53CYncpPfIr9j/wBRsL/P+H/BPh45xiI6Gtc/8Fj/AIuxWUM0Hg3QZbi4uQ9xbLYp FIsfQfMCQc/Tip4f+CxPxiguL0T+GdBt1k2eRNGqyo4/uKQu1W9Tg/1qocC4a2s//Jf+CaRziu1Y 1ZP+CwHxijilvbTw3oMzqpt3jYReejAAgr8mGPPQcUyL/gsT8YDHIdR8O+GILiRUby2tGupmjXqS EG3cT/D7VX+pGGTsp/8Akv8AwR/2ziYoiH/BY74oxask0fhLTDps0OHMmkx2yoxz8xGPM+nzenFQ z/8ABX/4rJ5j2lt4IvlgPmJp2oeHp7cDJ/1ckgUZz6qR061P+pWHdrv10/4If27WV1c//9Xuo/8A gsR8S7NvK1Dwx4TtfOg8+WTTLN57aMgY2N1IA65Jz70y3/4LH/FKR5Z4PCHg/UYPswhjD29xpUKt k4dFcZPBweQPSv2N8EUL6T072/S/6nxbzyu9FuOs/wDgsf8AEmK1Wxk+G/hZ7oSthnlE0TAnPP0z 1HYU7/h8l8VxqEFrceAfCjWinNwbeESybR04AOAf69aiXA2Hf/Lz8P8Agi/tvEIst/wWH8axXf2m Xwt4Zg8t/wDRdGk0h5JZARgyLcjaqjnO05PFQX3/AAWN+JYhj+zfDXwjqNzDKf30MjvHGCeNw6Z5 /h44rKPAlJ356lvRf8FFPPa97I17T/gsJ47S3v73UfBWlXTWUhMMFzaRQLJkAKEVcNt5P8TEe9Lp f/BY7x1qct3FF8MPAztaIHaFfN+0qufvAsNnHoDmo/1Dpfan+F/1JedV+h//1vVpf+Cx/jiK7+zW PgDwbLcqvnXMD2tytwu77ofGRj3z+FMk/wCCxvxEjSa6b4WeDJWgUN5yPN5bnjIUEggDnOfSv1aP AVNpOdT7l/wV+R8S86r7Me3/AAWV+Jlq7ufhR4JngiUTJdWt5M6OCBkIu3JIyeCw6Vab/gsp43vr eKS2+Gnhua0mLJdXE8cyNbOmCVbpuGT0XpWVXgSgou0391v1YPPalmmtfX/gFyD/AILI+NJ4Db2v w/8ABtleInmFns7i5tpwR92FQdxJx1NTQf8ABXfxux0+3ufh/wCBpLiZWkmyb3TLeHA3DIaM5JHb /I+hWXYLlt7NakRxWIsvfZStv+Cyvixop7ofDHQ2BnMJhWGdwgX5Q8W7acH3ANVW/wCCy2uvfRMn wk07yYpBuVoJY5ZP73AyBnn1q/7PwcbxUPxf+YPE13vL8j//1/a4/wDgsn4ihMF7cfDfwxYxT3Ml ulstpe3CYXkGUqoJJ9sDNWLH/gsvJqT2ss/we0i4MjSW8NxZXU0H2eVSch4CN5BAznNfusMuwcZc 8aSv83/wD4V4ms1yuRb/AOHw/iXUNR/s+w+Evh20hs4xcqbwzSNJztyWPHuB14oj/wCCyHiCHUTp /wDwgPgdgFzMH84vIwGWTbnr+QqnluFknSnD3Xe6u/8AMzeJqxfMmMj/AOCx11ez2scXwq0iFpWY SrDDO0VuFOCx28AH610+l/8ABXuzkv7eL/hEPB8bsCBbNBfXF8SOw2RsOuOT0rk/sbL/AIeR27Xd vzN4ZjjOkvnZGfq3/BZK6sZo4J/hJo+om5DJHcwXl3Da5VsDLbWwPX5c1Ztv+Cx7zQySyfC/RBew 7IoxDd3Mlk2TgIJPlzj3x9KueU4CceWVPT1l/mZrH4yErqevov8AI//Q+npP+Cxzx3t7Zr8GdHmu ILZboyP4gkt0bOASow2QCegOatSf8Fj/ALDaPb3HwbsluARKLuPV5JbEK2O/BBycYr9thk2XQ0jT /GX+Z8Q8wxc1ac/wX+RHc/8ABYrQbRJnb4Tafaat9kWZFuppreO6c/wxMu5m98quPepbX/gsLAxs kg+FugrNeSiKSzHiGWQEldxYBkUgDvnpUvKcv2dL8Zf5kxx+J3c/wX+Q3/h8R4Vi1KeG9+EhvblL jybW4stU22PmKD5q+axA4OeACeCKu23/AAWH8P3kUjSfDfRrazt7jC20t3c2942DjcGyQceuK5pZ Hl7dkpf+BM2WY4la3X3I37f/AILAeGJILhLH4ZaU4B/eR3fiV4ZJz/sggEj0xmmj/grvoN1FfXEX wl06QWkQEuzxyfNwPvJ5Rhzxz0p/2Hl6kn7N6ecv87h/aeK2U/wR/9H69T/gsJ4dgDSz/DDRzCkI WG2i165muDu6R71j2Z9c4xXQJ/wWS+GcFjtl+GtzpLiAyzRx67LOyPkBtshG0+oBOcdq/aY5Plsd PZv/AMCl/wDJHx/9oYyS+P8ACP8AkX7D/gr34Rvby3s7D4ZNdxzoXa5n19oJwpGTtQjBbHYGrkv/ AAV0+HNs02n6h8PEmnt4fMhtG10xyRZBI87gjBx24q1k+XrWMWv+3pf5kPMMU95L7l/kV2/4LFfC O3S0iuPhnfwSTxlGhstYkaKNiMKBLs24Y8c0tp/wVv8AhbHb3cj/AAp8R281qgiS3ttYee7UMc8b sBlPJyOnoa0eWYXl5Y3X/bz/AFb/AAIWMrXu7P5L9LFSx/4K/wDwkWa0lu/hvr4tbx5IFivNZ3RK yEfNIoVsdwMmuotP+CtnwWEmo4+GnjWyuTF9pSOO88yy8tf4znOwH1AOc0v7MoqKipzsv7wni6jl flX3H//S/RSD/gq/8F5kRk+H3iC4iJBuXTVwk9tI5O0lGCnBxweRUUn/AAVj+EB0lrh/ht4hOn20 7RXETarsa1dTgyOqpyvfIr9teVUGtZz/APAj4X67VTtyx+4jh/4KxfBa2v7fTtV+H+uRxakQbO6T V4LtJmZcgAY3Lx6r2rpP+HpPwWjh/f6HrliDJ9mtrOPVbe48sjoxYKMH2wcHvWTynRWqu/X+r/5l fXXu4Kxa0b/gqb8GEju4Lnwp4pTMhdzBrFtdyTDB+dhww/3cGqZ/4Ks/s7aNb3VyfDfjGO8ul8tl iSIwxgHj5scE+pH40v7Il/z+f3f8Eax6St7Nf18jft/+CmX7NLWs9/d2viuxuIohKj3mnwzLbpIO TkHk9eBmq9h/wU4/Zn1KQzWekeJ74MRapdSaWLaSdkBOM7QAD1/pR/ZVRfDWf3f8EtY6Et6e3n/w D//T/US0/wCCkn7NVnELn/hEPF8jXivKZLOWK/urIhiG+UH5c9hxmtjU/wDgor+zTcTxRSXviq98 i3jlgsrTSUdh5mMNO2MAryCDwOa/av7Pxa0jiZfd/wAE+JWMobuivvHah/wUE/ZbnFte6pbeJIkt 5USKeLToLmIunIXAIBP1FXh/wUQ/ZB1C2S+jTXkjtJxJJcQaDC+0rxuKZxke1VDCYilNTq13Jdmv T+u/mc2JxNGqoRhTUXff5M1I/wBvr9mHU7iPd/b2oWMai+W5k8NQo0BPTzA/C9McntWDe/8ABQH9 kWaSSC9m1WRmJBjufCMJjPOADIvy9vWs1luaqXMsXp/hX/DHe8Xg2kvYfizoE/by/Y2LG7vTqACx x2VxDL4TW7tbcDG1tgBVRyBuFVH/AG4P2Kwr2+n3i+ZNMJJBaeFYY7nhuFJYcY9Ca0lgc20UMUl/ 24ncSr4HaVH/AMmZ/9T9j2/bH/ZJvbdJbrVrGCfUd0cO/wAN2k91sQ9mVsD+ftVyb9rP9kS+lilv 9UgZ7e08mCS88DfvbhcfdVivzHuK/a1h83T/AN4i/wDtz/gnxrq4Bqyotf8Ab3/AHy/tPfsZMlnc 3GtaWGt02wDUvCBiEGRxGVYDGfStiL9oH9imUR20ur+FZ7tYxctb23hAmSJG5IIK4IHcLmsZUc+U uaFWD8rNfoxuplfLacJL5kMnxo/YkunSY3/gO8srh1t1i/4RVQ8Z3cAxhQ2eevWra/GL9jS5Vo49 T+HKW1neGKGJfCokBI+8hfaQPcMc8VE1n+8Y0/x/zJj/AGRe0nP8CuvxQ/YrmnVn1X4WXEkv+hCG 2so0CeZx8wHCsPfBqlJ4w/YSvb5Y31/4V6le6e3lwWl1EEaFs8jeDtcg545NQqnEi3hB/wBepcoZ L9mc/wCvkf/V/c2CT9i3VWvbKzn+Fwa7jVbsJBGiyY5G1myoxzzxWff6D+xNmKTUNe+F7wWzGJ7b WjFJZsAMbAVIU59MnOOlfr8q+fqPvUYN+V/8/wBT4z2WUt/xJJfL/Ihm8L/sZXyfZLWf4MnT5oVk trSGSOGH5ef3eTyP9kflTbX4UfsTzpOp074Ql5VEsl3NrVvAIpeg2u53AjGeelc0MwzyLtUwqf3r 9WbLCZY1enXf5lu2+Bv7GeyVLeH4ReZcNie7tdetbuZOcs53NjJ9RUd98Cf2O57yC3gt/BrzMwtX MmsWqRSoRwcg7gD1A75NX/amedMF+JSwmW/9BP4EF3+y9+x3re2yuP8AhX8JsXD+fbeIYbaeMZyA rMcDHHTpTz+yZ+zHepeCG2+H97ZRrzNLr1vLeR/7XmKwCn3xRPOs0p/Hgn9//AKjgMFLbEfh/wAE /9b9t4f2O/2TJlS5Hh7wZLZPA1qWg8S2nk3M3dy2fvr/ALJH0rn7/wDYW/ZRuDFNHo3hS1mg/fi8 XWLKaWZx/qy5ZuSPWv1GXEuNitcHL73/APInzX9lYZ/8xC+5f5i3H/BO/wDZjlnSe1N0uoKovpbe x1u3CK7Kfm8tWA2n0xiq1v8AsH/s83KzW19FqslxbMs1nHa6laLM5+7uLckfp+NVT4lxL/iYSXyv /kZvKaK+Cuv6+ZFcf8E2/wBnS7s28x9T0yWe433UiXtus7+2QRkHvmsy7/4Jk/s9xyz/AGOPxTPH Milrf+0owhJ43Eg5H4YrshxFTm7Sw84/K5m8rlFaVYsqL/wTP+B/mE6Ze+JvDY5hhSG9adLiRhhm y7NzkVzep/8ABLr4WRXbL/bOtTN9nWGS6khe7aU9dxy4QHnqFo/1jwq0dOd/Qayms/tI/9f9ObX/ AIJZfDK4LmbVvE0MiJ5f2hYY5NynjlME4/EVmn/gk38LoITDo2s+JEFoP3c9uPL89i2W8+KRWHqP lIxX67LifAU3ytS+4+Wjk+JavdGHqv8AwSP+HLJCbnxDqN8WujK0D2U12E3LzucsDgei8e1Zdx/w SI8BLpwTSte1yxP21L0zWiyGzm2ZGGhYkLjOeOuBVx4iy13bnb5M0eVYqytH8UTR/wDBK/T5JLlb vx5Hdaez7raae0aPUrMgchV8vZ+efrWTd/8ABKrR9QlMC6qnmQxeTHrE9y6yAHkEqkYz67VwOec1 pDiHK0veqfgyZZVjX8MPxMqf/glLcpbQSS+J7LVJhM0VvDYSGwFqoGPMmG3n2GT9KxJv+CVPis2n kr4w0YxSSESQmzVyVz8pzjaWH94811LP8pn/AMv/AMH/AJHLLK8dHT2f4r/M/9D6hj/4JMeLpoNQ lsfFGlNbOB9re3ZILifaeYv3igcEZ+XHI61zNz/wSJ8bSSWqWXjW10cRFpreymj85bjOSV8w5Geu MnHPSv3WGeZXflVdfO/+R8VLLMWld03/AF8zLj/4JbfE+ITWkXiHSclkEclxd+RdHB+fG3cAfyHP as65/wCCX3xosdRe+tryYSTS+Ttintp7WdDxyOu71P0rop55gZScfbx+bSRnPLMSt6bLlz/wS2+M zXKXX9lwalfwxi3JbUEtLdY2+ZiEHybuetcQ3/BL/wCNP2i4smjOmp5rPYG6czRQkknDSjggen/6 66I5rhPs4iH/AIFH/My+oVr29lL7mLef8E0/jxbM0EOh6DqcMFqgu71tQ+ySzE/eKqqEYzjgGubk /wCCdf7Suh3aRSeHdFm0uYfJZ2t1cM8zc7M7Vb5xk9PWj+2sNGX8WP3r/M2jllWS+CX3P/I//9Gq 3/BPn45vpl3HL4f1O3mMTSrY/wBmTyPcSAkom8JhQP7z/nWLP+wj+0BcWNuL/wAMnTr4OSNPitZL yV4wPvSKOgPsc/Wv6MhnWGkrqcf/AAJHwVTKq0XyuEv/AAFlS0/YW+O5tYIr74eaoltCzTLLbPIY CqjgtuiDDJGeMnHauVs/2MfjjZQ6jFH8PtX1C+l1BpJ/s9xJcQwKUXaQDEGUAKo28+vtWkc1ot25 l96OV5dVT1i/uZxOmfsiftDu4n1PwDrdnuupN6SaVMihAcAKx6fUilb9k74p3b6lY634f8Q6TaeS VslsdJuklmbPDM6YJHHYjr3rSOYwq6xRE8DKno2X7n9m3x9pmnKkHh3xBdzWVoZpFt9PliDhAAQw Yc9OgOa4bRvhj8T7Jn1C38A+KWeGfc0c+kyWbopOAFDgBj7A96qOYUpvlMpYSpFczP/S+QF+E/xD 1K+N8fBni3SbMXhNxNNo8ss9vgZ3uoHCnAAI9KIvhr4oS9vC+i66qrExtntrNplumIO0N027jX9L SxFN7XPzL2U4pXPM5PAXi2FtVupfDnie0mO64kMmkTz2x2kLtXC9elQWPgrxVcWWmQXiXVvaW0gl UBpbOayRm3FZIyhYk9Ao9s4qo4mnGOrBUZSdkjpZPCGp6K2p3VxZ3R2qly088TLEfMIQdv8A0L1r M1PwZ4g0iULa6BNKqW39oLJbPG8RB5yDux1NaU8RTbumZyoTTasUrPQvEdjatJqml6pDMp85o4bV p0tlc/KRKmVIIwcg+tRwaJJcyXLS3Ua2ocJNb3DCB4GwcZDYJ3c/lT9rBa3NY0pPQ//T/OAQXEGo y6bsRpURJbCNlOJEbpke5/Q1rz6ZrXiK8+z6bZC1uIIxbSXC2skOnqyjOGlwRu5Oea/p6VeO8Wfm fsGtGh+oaHquks1xfW9zeC1tQ9wlrYTSQAqAAI327ST6Zz3NYF7oV7LqGnyWlpf/AGvVLTzYDfWT 2sVjtALjeeBgMOvOSeKj2y6spU1Faoybm2m1Q3miBnkMbhHaJWDSOh6occjIwce9RW2mX8GpCCa3 giu7KCNriC1lMpjjfISRhgEZ2kkY421sqiS3MZQ6M17i4+x6rHpyO32mWISFTCy/Kf7rdM/jWf8A 2nqFre3VpHZz3Ecsy7lktWV7ZcH5mZhjnk+9XSmpOzOetTcbWP/U/ODH/Evjkhw2pTXkkc8qgjZC FXZjH8Wd4P0+lc9ZWt3pFzHcXET/ANm3bOvniEyLuHzbQ/Rc+9f1JOa5rRPyNQ01NgHz1e4jEaBp CIwpwoHuayINU1GyW9iktRcPLlhcpbkxIu47Qp55FVFt2E4WVyvFJdm3uZoLYyyiMn5+Qxx0NW/D cEV1YSWcjXQea+Ek9n5bCxDLnax5+8Dnt360Sko6MIwclcl1HUPsesRWl9HcNZwwnfJaxAMeyZc8 EcY9gald7eeGeW28uRkwyRvlQAec7sUOaGqeup//1fzTmnlgmhVZogl3aJGIYVDhcD5ufU45+lc9 c2kcdw1wvmLtcM7IMtKO45r+qIVYrQ/JJUmtjaa782GKazjFtDDJuSVBk7gR1J9MVYEuo7ZZr2CK Tzh50cgjCu3owA6dDXTGS5WcvI+blY9tNlvfs0E9nM01wnmxhoiCB/Cfxzx+NY90jziaztbaR7m0 fypIIkJuVOcDMfXB9aznLS5NSLUWn5nIa3DDa7Y7+VS0a7zFklzgcqQO/bFfDH7QuqC6hV2txawW 0arZOygXFy3m5VF/IjJ9WqM8fLklf0DKE/7QpR80f//W/ip8TTarFb3DXESwsrmVzkM8gfBUjP17 Vw9hHb6jayrcKxaBC0snRlUH7xPb/wCtTmv30/UuTvCPoTWQd/JgaeSW0c7EEqbiR0Urn8PyrqfD 9xf6RqunRpatfXcupKkFvKpVZifukkdB0P4V5+ISV0Qj1+306+N7cS388Id5iJ4I5AQp/u7R2HNa jx2elQXMttbLNPJ+8aNTjeR/KvMn8JpKL1Z9PfCjXPDk+iC1/wCES06HULQJJ9oZnfzyWz5nl7sF gTjIA5r2m21W0gu5PtMLwXEg+RGBVBjnIHYDmvAxOs3c6KMVqf/X/jx/s20a+svNnvbaRHEtzbsw a3uMA7UKkcc4yK9wu7PRbfwpaXUOoedqcUjXM8c2IRHEU+VVx1xz17GvlZx91Hnq3PI4yzurGYXV t/ZjziaFcSNlIrfceWU9z/jXUQWdwlrZXCWtxcWVnM9teRq42bHUEEscnI7f1q4Q0sdEHax5Lrl1 aRamouBf209qsj6XLbQNOJJOMrKBwFwByc9uK8u8SC3S1truW3nlLXSyoI4TIykE4Yjt9a9KkveS NKegRTw6ZcWxu7c3MFwxAtP9Wm4r99iOe3r6V2GiTrdrb2MOnRB/7YgvWuC24RRRMGKYI4zjp7D0 r1MI2sVD1RpiY81GXof/0P5yfDt7c6lYR6jbrNb2t7GMLHHtt9gVSrJ24yOPav3o/wCCNZOnfEaS 0udSkEup6lGti8cS/ubhYml80+3y7Sv/AE0r+ts9j7Xw5nOPWCPyzw+kqXH3s33kj+sX4oLcz/Cj Xdavltbo23ha4u1tZEUxZNu24j64P51/A9+0xbf2b8RfFqAXEqSa9cz24MisltlYicAclW3ZGc9/ SvzPwG1zDFx8jbxsbWa4dLrc+Nbu+W0lkW43zNK/yLK3C57AelaLTae1ssUdpBbzMeJIZ96uxxw4 9vav6ugny7H4dyPUy5oIoFWW4killGUKo/Ax2q/aQ6cOZpSpfbMltFLhxjqW9ugx70GsU0tT/9H+ cuwkuobq7mCSwweYzQrMuRIM4GFPHTFYA8QNZ21+8tjvd7hjBkG2+1DOAFYg59u3Wv8AReUbn8mw +E37SG0No93saAuoeRVJ83JA4Pfj+lXbfVJrDfbRiS6s54wlwP8AWMqbgevqO1Zcj2LTa2KU12DA rwXMix2Fwzw202I5GVuNu0deAOmeaf8AbpZrkXVoWt1uo1xG8ZDR5Azkde/1pqDC7NnWbSPTbbS7 ix1m2vLu7LG+SK3kt0tHBG1VLY3E8/TaazNQu/EGm6YILkR3kOoXBnnlilCygIRgMQeW57+gquTo ZOWh/9L+c221O4u1sbOw025W4nlKNs/eJKoP3iex5xx1qxrOoCIfY7exa1lhASaUsXVif4dpHBz3 r/RP2bP5ITsynY3W2GQGEO3Cu7Q5aI9iG7U9ZLeANc3dsII3YxpfAHMhGCQxxwAcVr7OTjZG+6NS 5sJfKhfz90U/76NWwF9OPXp+taNnp0ptA7NmNm2EBdxXnr/n0quR2ANT0b7THHFYXoOxPn8+LGH7 9D/nNYltDcLdRafcQwxys2G8nKxoO5Ge3f8AGlGm0rGkGlof/9P+eKcWNtFqE9vIxFvMbYyOgVZ0 xyx9MZAxz9a2PDt/Y6XYadJcPf3E+oXZtZjHCBtjc4Vic/dAHPHTHFf6OKn3P5V50nobOpQ2ccs0 U6ieSD5C6RmRwhPGSPqa53UdOENuYo3As/JxHBC+Dg5yT9eK09m7cpLnrYg0AWdvb/YwptyHwAV+ RVwAABWzDbw3jM9uwkgtpiHKEq+UPf0+ho9m1czcl1M241C1udRmhdQksKBVDrhm/Pr16jiqUlrK wc2trHl+XYjarbelL2L2E5I//9T+fUSTNNaxP5we5/cfuRiG3CjOGfsvp35+tXVuHiMd5JKrSwts CA7g+TgZr/SDke1j+TyhrWq6ut59tsILeAzQC2mjmbzVdfYEcevHI9ay5oWut7qJPtG3McSKVjlY dRu7fWsXFoSaexpWei3xS2QFLdNQkRmWVlZrdk4c59Bkj/8AVXSQXNlo0uo6ekCXURuA7XryHzHw MMVPpx09hWbim7m8JOxjjxLqKXthBpFnNNHPd/NJEwb5FIyFz1J6VqeIr6XUXkuNSkCyAY81QE8g YG4Y6dh+VL2cbmqm1of/1f5+9U8Px/2NLJYn7YI9jOqN5c90p5JHTOMUWmhS6nBEZFkls4f30UBk 3CLpn6D2Ff6LckT+XuaPcv6vpT3UPk2zz2QUCMSW/wAgix0wTn0prRy2+mPp7sZMTJK92oBdwowQ 2OOfUetHJEG7K5Rt2tbaWSRzIUJW3CKp+0JvP3gOuB3PaqcsUU+uxHSVmH2BVtY70yNEt0c/f2k+ mB+FVGCaE2rmtdIP7Qh0698vNpJm7i8wGNw2SHB6EnjjtUjR6it5c2QsJVuILcTCCIFzsYfKR7Yx ycdRR7JWvYibu7H/1v5+NLhjkW5jk0+7W88wySmSMhh64GO2DUWq2JuEt3SaVhCuVDtnauc8Dt3N f6KunE/lVSuY8Wn3bXZkuJJEtUUNHEE2tn1z6VqT6bHsYQzW9zbX1uEkEigmCQEEjJ6Y4z7exqFD WxSfYvWvh3UrCyfUYbZb1IZhEzWzeaBn7pA6496WwvZbvUDbXDK9xPlY1mcDB6Y5PbPf0pSp9x3a LbaDqEQvHkuI4bmKU/Zp43DlVyOD29eBTr2K5kuoil8b5EhQMzx7VjIHKj2GcVm4Lobxb0Z//9f+ fHX7r7dBNELWY26Roq5kwA3AJB4PXnntS2zTHTGFu6zXHyw+W5Kl2Iz8vGTj19cV/obyLY/mckl1 PVNTuLOGdpktrKP7HbQTxbGkIwS2T1HpitO8lvXPnEtLPaxiKETN8pwMKufQY49K0VLTYlySdjOh 1C4dxBqFwZLyQlhDjGwDkAd8fWprbX9Pt5hGgWSXf5EsZ5Ge30NS6SS1REpXVjema41FY7U4lM37 qCNG/dxscYArPhZre3ubG5tX88XIbfM2Y9oBGAnt1605Uly2FB+8f//Q/BG61WLMFmlt5ZdB5lzG gWNiMDBUd/pTbDTJdUvY7XT5EMsBaYoziIFcHLYJ7cH8K/0RpU1yn80NWdhzB9O86T7Mskgl2k8B d3PBPI9fyrPlWKSaBJjuKA4jVzsXcBzx3HapcI3sZKPvsyLGCGyRdOupG1SBbppIlfG+AMcjPfj1 qzNusPMfR7ItKrGaaGNtgjGOXwefT86uMOpEt2XLOSXURbJPsu4Yf9JaVQR5RYAYPHbOPr3NVtTj hF1FbC6O3adsBI29jux14x+tJR9zl8y6ezZ//9H+fi1tXMbCTmLb8rqwYzAdcj04qzaJFeRape3V 4F0+zt1V41VS0ToSFyM5x0z6AV/ojUppSsfzLSV0ZslyLolbcSXUdwqrCI03DHqPY1antVnihikQ wTQsFwF2soHGD+VHJdF2d7DE0yGK4USRMq3PymVRkSY9a6CW0s9PjRZFfzhwUA2qBgY4rPkRpZ8l mZBulS7jkYqsUimIwFuD749RU13cWrSIptWFvB964jYlZCc8nPQdulS6S6E01qf/0vwJtbiGeBzE CHYkRv2yPSsO8e0nkltLqKOW5jjDqrSdW6ZNf6EOmk7WP5vC0a90+DKiDznO6BoQVEPbk06yjnaS dpSHmZj+8Vy+/POcduanliugF4Wreajn5gBhixwOOlNmtI7e6S+bb+7TJP8Af/2f1p2XYC5HqNtc +ZbrHcxZiBXC/IWPXn86pJpV1BOXy83mYZDM2wRr3wAOaain0NHLSx//0/5/YbW+urmW0aGWJFj3 s4VlLg5A2t65H6Utjp+tt9oMVvMtuFMTXLYd1Pb15r/QjkXY/m8hubqdwbVZYibX+NolExbuGIGc exqU2U+piPEzAxKSLYYCzN256/8A66lxTIU9bMjguB9nlt7eFILpUKsCNw3gYz+dQQWs5sfIuoox c8lTncGPPzY/pRyRIlJtklppV+m+F1RrWMb1ZCFL8Zbr16VJoMWn3d5e2qQCGaKPz0vZhgLjIZQf y/KolBWEm1sf/9T+fnUbmWGJ4LX/AEwPkMD/AKskHjB/CoLHSrsIl6u2CcEFoi3ysP7ua/0AUL7I /mxTXU2rtdS2TRmdP9UBEgIYDPOM9uvaqNw9wI445QqwrGVaPy/nkPrn+lNU7q6RXMiGJZHjit4U NtAnLx52lyP89qv2kZvPNtI4ShDbYWaQBnOOo+lEqaSHGVtUVGleBlhllKzxPlC8mCMcVKY7meSW 8nuRNKUGEGCFA9T61VKEbnTSleUvRn//1f57beOTUrhA67vJk44wE7ZrYudJdoW+x3WRE5bZccyI x5GO2PbtX9/umlo0fztGSexFfRzWNvaTPPGGxuliVsnp39qv2klpqNkks4TzB8yOGDonvmo9nG1h qWrSKjvJZNMLqRZImUGBkblgewHtUItOIpLSQypKpkkHLPHk9/wrJwSZfOyO60q3l8uUXLK44cDB U+xqldWsieWiHzU2gFifmFLkiLmZ/9b+ezUg9sIkj3iYrkyhuo7D9TVeCwhaSN55mjbbuKKAQT6E 1/eTpLofzxd9yyJ7a3lRZxIVdtqqn8WOvPOOKfcyxva26xQhwZ2JkJBdMdP8+9J0vILvuLdsqQQx q5V2w5VuGYL3H8vxpjagltIl4hjADAE8FYyenX+VJUr9CFK8mmPnviuny3bhZniBkIhXBfqeFH8h VTShdXhDyqU3LvKEY2+xpOguxrGVtz//1/56dQvPIuks4oyzGLc75/dqQSBn+dXtHbzljlufLjlD FUcEEjHHSv7s9lE/nyUrbE94kRuGdW8ySRsGbPzN14zTRcQQjbKzecDgDHb3o9lHoOMpNmBez3OG ltpopQJcCNpNmMEZJ4PTmtWBzeQzG/n3siL5WTuz2xmh0y07O6KzWTeUfsqDIbIAHA55NXRPcPbx 2zb/AJVKOgGenf8Az60vZsiXwn//0P55pkltDtRn3Fd4i6kg+1TII1ijLyFmlyTxjkdR+Ff3X7N9 T+fYfCVmlt57y1Ry5tZHxPLDgsFHp+tOk0rSGmuLmOWVpImxaGRdoAB+8R64+vJ7VPs2ndFF20vZ 3tYojeTaiYgzNNLkhPmztz6c1Tv9Qtp4YxYRzxTwAvN5gxHI2eMcdKFTabAqzy6tafZ55bpSmoAK 6RuJGTpwR1FLOI/tEAy6ncN7hclB9KrkkCWtj//R/njubWe7muJF1AXq28pMUko8jC9lQd8enXrW TNA22UGN/nbaxXqPQ1/c0odD8AasWbWG7BVJiJCoC5A/hHA/HFX7lI0GEjDynC+SwHzc9R6U4wYj EuoLp722eWMsIx5bxq2DCnU4/EVWZGs74XYjlliZBF+7PzRnPUj0561ryytYC7JPp10TZzYeKY4x Im5WI56exGfwqO6Bhe0TzJpTG5EUUSlo1Bx8zY7jH61PJLYD/9L+di3EYdvtKtvcbVZgRsNVXW0t pikG4svOQMp15r+6uWR/P5dacLCZyyqQMhT8oJAqpa6hbyxJcXEWzzU3pIeAD6MKOSSBaENtqDXi mSMcNI0SyAfu32nBx9KtJahC7SSFgV3ALxt60OLR0LVGLb6pJJI8bwFPLuTCqs2fk3Y3/wBce1as sMAQWltApLf88xtBJ9KfJIG0tz//0/5w723uLWCMx28c8sJyI26/gaqpfyzsIJFkTA3eWoPbsa/u +y6n4EpWuPuLtIto5bK4WMD5zj0qpa3oS5Vra2UyMwDtKmXwOopKKjsQazak1xd+SUVFHJUdPpUO teYkNvJGpMgkA2j7jLkA5/DkfSqBabGXd/NaTbpY4fKTzcspPTkjjvwar6LPdzWbp55a3llDqrff Yr098cn60G0Xc//U/m1kWTiFCwUyebKF4RnxgEj1HP51ctLWRjmc7pBwgPVQK/vSEbas/ByScW2V dl3SK23JXpVO6aVPKRSGEh+Zc8IPatAJVm25ATYV4HGMVFeXYSANLHlCNhKrnk8dKCXqnEZa3oTY huHGWxGSfmHoB9P6U7UZFvZkV1kaVRiS8Zv3kvHQ9+OTn3otrcaVlY//1f5r7K8W3d43DLtYKkkh BL+9LFGupaifNsdxtgZIbvhiq4G4+o7/AJV/eVWN7H4TF2Z778FfjN4n+AvjbRPFXgua503U7Wd5 Lm4h1B4F1GAqAYGUEcEgHdnggcccf2s/sS/tQ/Dr9p/4I6do/inxLYap4n1HSZLfV9IuIRdbsjYV Dc5IUjPfO7pivxHxNySaqYfPcOvei3GW3duPnfdX8ktD9F4fzD2mHnls37rSa+5J/wCfzPyE/wCC gX/BOm8i8S6p4s+DOj6rvF5I09kLBJ9NuYSF2YjUAo2ec7ud2MHqMH/gnL+wL4om+IQ1v4v6Q8Fu yFJrCCzH2q2ijbcDlvueYVCnHOB+XHieLoVuEp07v29lHT5Xvr6mOQ5LLCZnH2lvZRk3+bX4n7Gf to/E/wCFHwO+CGr+B7fV4tPuNc019N0qxuQI7i3V4nhDGKMk98gY5PY4r8s/+CLH7RfgPwR478f+ CfE+qR6e+pX/APbOkPdWwiilQkRYz1BJwcN6DntXzuW5Ni58CY2s461HdfJr/gndg84w647lOM/d hFJ37tSf+R//1v23/wCCgeiy/F74PeI/DngNJJ724tLgwXEluxjkE9uVHy8/7PI7A9q/kG1v9in4 8XcmqLJ4Yj0OaOcQWJt7OVmkMeFLvhTGA2Ouc5zxX734Z5vgspyGeGxkrTvt/Xoz4nN8ur4/iipV w9uVpavbqz9t/wDgkV8DPiJ8HvFWu3fjvRoo7DUrm3uV8pyViMUTo0ijAP8AEM+pFfqN+338ZPhz a/B/xToc+uabDNe+HZItLtmleOaWXZJGiqmMhtzDr0CH618fiaf9p8fxq4RXTnF/LT/I+pz7E0ct 4TdCvNcyg499fL7/ALj+GzwzqE2q/GnwhZwoix6b4vt4rm9kJuZ5THJ5kxLD+H5G49a/0OP2WZor 74J+DX8mIXLeHLVl+Uwi4xCuxlPpgivqfGSn++wMl/Wxy+H1S2RYim+6/U/j8/4LgTKn7SHhe+1O XNhfWMsMNtp0eVjEd8pZy3f50IYeij3r7c/4INtpsVz4yt7TUNT8u81WS7lCxgWMwJRVX1/ukH3N e7xmr+F2Gt/JH8kfKeGDa4xzDm/mqf8ApTP/1/3V/wCClVxZr+z14tgvJ3P220kgsz5bOwYW7EyN 6DazDFfxd/s2/DrW/G3xm8ITeHvDt3dwaN4ltzdXcMTLZbV2ASHb1IGCW9jmv6F8P6lLD8B16tZ2 jaV/usfnGZy5vESChunD82f32/CSeytPhh4Ysry1dbg6NaQSWQYosCRD7p7jncSD2Ir+Qr/gr94B 8S2fxpufGQ8NX91YedO8dzZW7vbWUE0jDecDH8Iyfr6V8N4Y4ilh+J6rqOyk2l82fR+KMJ1nRqR1 UHd+lmv1Pw+1m5iaHMSFTcHJOMDB7/59axluPslqhUh3jGJJGGCR3/lX9QQTWp+Zwso28jQF+PLg kVzn7yMp6k+9ei+BtC1zxFruk22kxXk+pXtykFlbWkbPNct5keQuB6A5z23Vw5rOFLA1KlR2ik23 2SWp25dFyxtOMVq2l+J//9D99f8Agn1Z6hpPwA8IWd/bzWmp6do3+korkb8qpYsD0IO4fhX4wf8A BbDwtrk+kLqnkXd7ptpqpvGurceYYPNjVSr46ICM+gzX6N4d1oLjaU76O9vnseL4oUpzy/DqK2lF v5bn802maZfWVqLHULcRSSxCKLbKGZ9wwhz78H6V/bj/AMEmPHPhjUf2dvBGlT61pFxqulaLEl1p hvEOpx3AB3EjPIOMjH+1X3vi1SlUyHmir8sk/kcnAeIhTr1oTlZSi0vW6sfK3/BZ/wAK674l8C21 n4fi1S8tb0WtyoghMsEVzDKwUbhyFAUHI7vX5nf8EoPAXiTTPjdLqF5oK6d5kkVql+InjMbrKpZH JGDkKzHv8oHOOPn8uxVH/iHFai5Lns9L6/ccmS0KkePXXs+Xm3tpsj+t74/Y/wCFQ+JYLZ0j8zR2 Kh03xbQg2gD6kfrX8BHx6P2P4x/EG/Ty/wDQvFrTxCaUbFMcwx+ORkc9wKy8IU3gsWzg4/lbiqgv L9T/0f3a/wCCXXivR9d/Zu0lbPUrSW6sdPe01CD7ck5mmKKzMpB4wCOK/JD/AILPeFL/AFG+0q+t Ip76CXVYpxdwW7yQW4hQeajOOATsU4PYH0r9A4QqfUuO6ssR7tm730t95894iz+t8PYSrQ1XNH8F qfJf/BG3VZ9B/aGvhqrQaZa3s3mRG7/cRXTiNkbDH228e4r+rD9p2GS9+DWuSaR5Ukq6Sbi2Knzo ZCkLNtGDknIA49avji8eOKFZrTmj+aPRw1SNbgWpST95Rkf583xh8L+I9O+IXjg3FmYLibxFLqUy 3AZZSk+PL2+wKsOfQ1+kv/BITQL0/tDaN4ku7qWO202OW0leys3lt7WMtGSPO24LFwOnvX7LxbVh DhitUW3s1+KSPhvD5yjmOGg91+iP7FPiyyxfDS6ktrea5A0rzJYkYss2QCTjqSMHA96/ga/a7uJ9 L+NvxMuH0trdBrMxsblbMl1QTuEEr9eQydfQ1+ZeETvHER9D1fEN3z2lL+6/zR//0v581uDHHtlu ZJ55mM7SsAWXPO0YHQdO9eofCprBfiB4HuZdPGo6gfElrbWafaTbPbeZKoeUj+IKB0Pev7OnTfsW l2f5H5Dz/vItq+ux/oRfszmC8+D+iXdoVW1u9BtI4LVpP3iyIFDvtzxnH6iv5hv+Cw2i+Irr4tNq 1nbXN5YWljcafbukRXynMqSPgdTjcy8eh9K/mzw6tQ4uxPtnZXlv56H6P4gKdWOHcN7q/wBzPov/ AIIYwqt9r39qQx6ZqB/0n7HKTGtxB8kc0mezFolxn3r9aP8Ago+ZNX+AnjqOzijlkh0K6e0dDuPm pGhQAdyeVA966M5SXiVB9Lx/QyxycuApw68rP4ZfG2q3Ta9fmaykuL575TqNjI5CaWhAAY55A2jI HesfREjm1/RZ7Zrf7N/a8XmzXDhYrb94Fyc8Y696/opxXsND81y1clCnHsj/0/34/wCCaMWmWX7O GgpFI80VpZNawMpBeco2139vm9P6V+SP/BYTw7rXjTW9A8K6dcXJg1PVGjltpP3sBbKMxA9QSucd fwr7zg1qnxzXlU2TZ5viDSliMswdGjq24r5njXw+/wCCP2reLvBFj4wvL5Le7vraOe1t/tbwzJEs YOCqgKCeu0gnsWr8kf2lv2f/ABP+zr4sv/CHiAme3triSew1O5IDXMZf5dxHBIyB+nUV+pZHxL/a +ZV8JbSO3y/rz1PzvO8vllVaFCfVadz5qiVbt43mkeQsVhiQHCEk/wD16/YD/gk5pU2m/tBHVLIt PM6wQrOv72zhfiIxqB/EBuyc4FHGMU8gxN/5f1PV4Tu86oeT/Rn9cXx6W11b4Wappssfz2+hGe3Z 8rvkVQqjA6jmv4Hvjvpl7F8SPGcGsWE8bXviG6me5uGEkU0nnFQoXqAAEx9BXxXhTaOCxEOt0acf wT4khLtB/mf/1Plv/gmDaTH9pnw/d6jIw0XTI4wE+0BPMnfd5fyHluRj2wK/tB8eSGH4S6gqxu5T Q2+yysd8gDjJz7YPT6V914gWfE1KPaK++7YZHJrhGS85W+5I/hX/AGsrW6tvjJ4tgv3nTTlvbiTT yYiIVleUtIpAHB7jNeh/sAaVqL/tHeF2hie4s7FDcNPHGBPZPOFQR8/89AmPYMfSv07PXBcMyctv Z/8Atp+ccHtvG0bfz/qf27vJa6R8LZILl5rq6l0uTyWKmQQssat976txmv4S/wBteKeb43eOru5j 87UrvxjfFmWUyXEIKQAFl7BwPwINfBeGEHbGei/U+k4/kv7Twdul/wBD+p3/AIJR2dzp3wA8MB2W UWmlRS3sO/fI8rQqh4xkYy2M9gK+cv8AgsdqVpL4SsraJoVdrf5xODDEcKJCrMeCMLgj3968DI7P jqol0nI9fjCd+F6Xflh+h//V8I/4JUW2m/8ADT32oyraSLc28k1rEhMMCsWCqH9ORx7j0r+xT4pR 3Fp8JzcMiXFtBaCURxsCWO07Tj619fx87cV0IvyDJ7Lgao/KX5H8HH7TVv8AaPjz46vXkjmD63Pb TXNtMTuYMpfKHpzkZ9q8JmtZoS7RNvhBwOzn61+94eH7mm/7q/I/IsDpQVyjNLI+1I4yjJ1Ye1Qi W9lSISofs/mlHlVSPMK/wk/lXXyKxqadqsEUrXLRPEyAK0vcAc8VBqa2V1eyf2e9wbV1VmMp+eRg o3H86FCzuNPRn//W/Eyznb7ULaSxMJg/1F3kl7nPqOgI9vWugtYUmlkXUbcyoH3AFumOlf1xKMbn 5dHbUlvYIEuJJbeWZIZAC3mNuK4GP0/pRZ2MEsouWk3bVxkjg8VhJJOxnO/UkmuIpd8MVuYruLkS kcFfaqbwXd1AZo/mninVCkgwjjuQanlTVjSLdtSeUG4s/JDyrewyLMAAVjwhyQT/AEqGz1WaD7RC iR7WYPJuGZFI4O09R2/KodNNWLv7p//X/Ga3vJo7i5kikdoLlQCG+bYODgH8K3knhkhQMoHGM/3u tf1WqdtD8sc7OxWlmVZ4RbxDaqlZGY56e2Kj+1rGktvdFpSWMsC7QRHk8c/hVqncuEuqKD3VzC0d zFKzbFxJEBkSenH51rQ3U17E8BiLNINxI+8gHYGk6UbinJpXJYoAsDxbpHUdyxJU+341NlxYrAvl +a0wMkr8HaARjOeOtR7N7GDeup//0Px1htzCZRkoHkLEBsq+T1pk0DjZJbsQqHbJknIHXAr+qXTd j8oTa2HwTgzlAR5m3CNnk+1Wkl1KF55PMS3mLBEDDcJUyMg+hPNJwSWqDmdrGlNcwyQyJNnATlgC Sv0p4nayUMjYt9gJIHIHuKTgkrMOZjriS7ayiuEYzRCUDaCBJJu6ZXrgetMe61S2eIWsETWzqfOl D7ZgeMDHp/KpcEVzs//R/JRRcb5blgqTOvzbTuLfU4qGx13ZP9nvkkEDnyw/lllJziv6k5D8q55E 15qEMl3Fb6XGzw2BBlhLeWZc4P3fxqyyysRHGd8j/vPJQ/d4yR/n0rnlFWdznnJ3bJbdJQonJ2FH 5UnjFTTXVxcsI0Ztp42qMhfxrlWFVos9CNWVkUdOtrjTry9i1GZ5o2UyWssThuSchT7Cs2PUZrDU LiVWmuY5D8iOflQD0HY05YdJ7GntNFdn/9L8mY57vU5WkUGKOT5SSpUAd6vxWzQSAIdtuh82Rzw7 MOhz1r+kfq6jsj82U7snu5buVUgSMtAreZLcr8shBIAB78Y/Ws2SPySsVoSqmTcxx+8wTzmqdF6v sJzXwk016loUiTcoYbQ/dvbFX4NRRCXgADKg8x85cnjOay9hzLmsRTnytxuVf7XaO7RpOEPzDHPT sRV5757nfKsZCxnzFVfkVjzj2qXQcdUVKaP/0/yxiupFA1P7NEJ8NbxPJhifXI9s/SovtVyxYeY0 sjsHZH5zjsPSv6M9nK9j8051Yu3EKnydShjeGZEEbRSSeYGbHzEcY9ePfvVBHuJZ0kZ3j8p96gdS cY5P51Ps3fYzUmie/VWjS5WUtLFITHCMqQ3dzngg5PTvSWTXMo/fwgKB5plPMSHpWioLeVg9q2Tp NcGZIhFG9xJKEjnI+dFORtXtzkZ/pzTZbqbQJSfKgha8nEErFQfvHkk/h+lHsYtXSBVbSsz/1PzM lubd4DBHAkXlKAYl+5I3XcP89qyrzSS1rZXjR25E7OJY1IP2cqR29wRX9F8jvsfmyq92TW99f28T RWzhE+6rtkomOoGCP0pJ7KPU98dxFHJJKh80RpzIB78mnGDtqh+0v1E0+OWHyY7K3cQQIIlMiFBh eMD6YrXuPEEsPlRPEBJnymlAZnkB6A+lVGHRlOfUpXd/O3lWaRLDHE3mosUew7uvJHX1xWzaS6jd 2hlklMV1bqXaVFO+WMEcN1q1S97VEcy7n//V/MnWb03scllKpMoRQ2Rs8xTyMn07/WqtrcXtmsdo ssn2dQPK+YkcEHBzn6V/S3sY9j8zctSzd38cs7+bCJzIgDE/ehYAD5fy/WmWUmlw5kTT4UuEJXzm hCuT656/SrdBX2J5mUNP0+3S91G/hZJdWl3yAszLJg9Tz1GBiteEX7WRtriU7JcZjKgDAOcZ/Dr7 0/YJLYlytuzZn1GSG2gtrEYvWyJC42QIONp3jrnuKX7XeG0tl3IrwH7Q6hsLHIfvFT/L61Loxt8J HM1ezP/W/OWzaTVF1B3mlcGMRzw7sLjjnI56/wA6w50vbrfZR301jEFNsHt5WgYp0+Yg5I4/nX9I ulHsfl/M7biWepnTHeGxRJ5YAsMrvyyBRwccg57+tbOhul1BHb22nafY+XfNc3d3MGiuJ93UKM7S PoO1cuKoxVK+2pEp+/Fef6M3JdfsFu106RL17m+X7P58MrLAVXJCMAfY1Bb6n/Z8c9pCNkUuSSHI ZSepznNdSpLlSSNlWd9zLur+Ce1uJJZrm4vIysyySXDyvKVwoBGf4R0+lMObewTfNPPqM53y3rEo VGc7VIOcdOtDpeRp7TzP/9f870vb3Vp9KilvZFttOdmigeYmFWYbScE4xyTjpzV2LxTfW2mS6fDq Go2lwsx+yyRRCdZR5nIZjnGB0/pX9HexT2R+b+18zO1hNVvYkmfWdTmVSGVJLxguexx2on1PVYo7 Wa4v0b7NGQblmxdwjH3hIOcfXjipeGMpVn1IX16+uYNOaDVbvy7Of7ZbSxTGOZnPdmGCfoau6LrO qPdai11O7QmMvbGOd0YSNneWXODnuetZxou9hOo0huka7qtlHOk3m+WJZImSRlkguFZsg7ecY+uf etBNdh1WF7WKCGCOyuCBtHkbWIGSGGCfx9Kp4doj2x//0Pz9sNZ1LS7jVns/El8v2jZDxcefGi4A wpIxjPOT+dQnWPEM19Ml2sUMTx+UbiCdlM23BEhUfKSeORiv6HdB9z8uda6saL+I9Se8hMmsalFF p9uba0hhuXQQFgNz7+XY4OBknHaotP1jUbltSivPFOuPbSwEJBdX7+TKRjaFAwc+5qlhZWSRnGsu Ydp2vSacdoe62GXaxubo3LXGBgMM52nvx+VdRY/ELWR5duuvX1oIZXYu6RtJtPQBtucD1Bq1he7N PbvsPb4geJ4YY4LDWtUuEaXdPKt48E10d2Qu5cHHNU9R8da1f3byTeKPEZAIEtumqSlVKjheW6D0 yaqOGd9C/apbn//R+Jofif410yaBdO8R6y0Sxm3+zpd5SRG6hyc5P4ZrotA+Kvi/fOdZ13UNVmmI MEck7WqWwT7qxqhA788c4r+kY4R825+YOtZXRZtvjD8S7W9uZ7bxdrFtIDsjhutQeW2WMfdAXIwB zVy++PnxXtb2zudP8a6tFClv5WpJDdEG9B67GH3B6Y/E1pLCW2YlW7i2/wC0X8a0t5H0v4l+Ibaz WJjDDcEXV2zZJOXbBz24qvH+1x8fUnure78d68YriSJAzpIysEUEBsv0JA6dDisZ4JPVpP5GkcS1 om0db4d/a7+OumyiwufG+vu8CGa3v0vDYx23mMSVQYbJwe/51qw/tbfGywuJ7zTfif4yZWJiuIpL 77XuAJJKhyQOcfcxWf8AZ9OWnIvuRp9bmvtv72f/0vKtI/bc/aRiK29r8SPEdhd3czzzXltqRE9x wAiOm3HHHIrpJP28v2i7ezKWfxM8eS6hDHIjLLq0cSXEuMAAYwV9D/Ov6GlkuHqaVKUWfnlPMa0X aM2Og/4KB/tI2unabNP8QfG3265maK4L6grGzUggMI8bSAR/ESORxWta/wDBQP8AadsYruez+Jvi jUIGjGIbm6igdJucFSihcd9prz/9XaUpz5qSe9tPuPX/ALQmoRtN30v+p0Nj/wAFIf2r4ys1z4g1 KJEhWSK7vZLWSCQ4wdy7T8p9wa0T/wAFLv2mVtbKRPF2pQNHctNdCR7O9SX/AGQBEgCegOamPDFG StVopv7vyCea1U/cmwi/4Ki/tJ2q27WXiW2vby5lZALvS4oYSrchnAJIxjt+QrorP/gqV+0TaTv9 rvbCa3ZNkrpbR+csyjOEQrjZ7j1pPhfAQWuH/GX+YSzPESWlT8F/kf/T9d0//grT8eJUR9ThshbR QvPLv023mGVOFjYBOp65/WtC5/4KvfHS3jATR/BGrQ3TrJZNqcDNdQZXcwULtXgDvnHrX7c+Gcve ro6+Tf8AmfJLM8StOfT0Jf8Ah7j8UbK6ne58M+C7j7LZpKVg045DscMqMfvEHtW5Yf8ABX74j6l9 kt5/BHhFLZZXa5vtY0+SxhKhdyhcOqj6gnpXFT4Vw05uM1K39eR0SzetFXi1fz/4c0IP+CtvjPT0 nll8DeCZZApu7m1t5Z2F7GcASRu0nYdFB7Vux/8ABYnVIoDaxfD3wolzNLvEU93eorpgdBjgnnvi tP8AVDBq/LOV/l/kZRz6t1iv6+Z0A/4K93UckNk/wm0i6gvwqWsdveG1BbGWLMW3Afh+Nbln/wAF afD0OsS6fqfwwsY5oIhcCG1vbmV45NmVzL90fTGea8mvwzyTcYzbt1setRzZzhGbjof/1P0SP/BW DwdHfWxv/AWpNfi2Rrq1sby4jjmPXALDkf4VaT/grT4Ll+23ep/DO906CNhBaXI1JJJDGxx86IWZ SPQ8fqK/Rv8AVis48yqW+84/7Zp83K4F61/4KvfA+2v44J/CfiF9RvlEb29xdtaWqkLzJvkQBlOO NoJ6V02mf8FOvgHqWz7NYS6TdzXTPNaJextcpszgsQMgnGRnrmpjw3jop+znf52/MzeeYT2lqit8 h0n/AAVD/ZzTzk8Qad4zjhuTst3uoF+zXQU8+Scck5B+hrq7j/go9+zGlpa3t1cXmnQTRLFpUUdj bzzz8dG3Ec/hXJRyPNpKXsXt52/U3xGbZdBr2i/D/gCwf8FBv2Z7+G3F5N4mWa7haK12eHoPPlAP UKp5BA61qW37dH7KsVj5gjvLcMDBbz3Xg9VuZCpy4PB4zyWOB7msaWBz+lVcKEmpK+ztt8xzxeUV KfNVimvNH//V/X7U/wBtL9j2NEubnxGY5NWlFpLC3hoXUkmCGy3AG0EDpk5xW+/7R37HN3CIV1Xw 3bbEV/tDeD4o7eZh8wJfH3h785Nfe8vE8Xfnf/gRwSnkLjbkX3f8Afa/Gv8AY9u7S9WHVvDltdXE wecPpPkLe54fBHHI5IPNOtviD+xtK4kQ/DrcyCRLrUdAKQWyrwXOVwSPU/nVVa3FEUlUbt8go08i b5oJC3+rfsbeI9N1Jf7R+GOq2A/c3yW+nfY/tRJ+6sm0Z/4AcVnW/wAP/wBjE3aTpD8J9t3ZLAYJ NVRLi2jwMeUAcntkfWuiGO4mpxTSbXTRP9CPq2RSk+a1/V/5mkPhN+yM9vLb6fL8MomlJeUyanEI XwDsDCQlfaswfAb9lDVvsz6lo/w2f7JCrhl1W3a3G44xndzn3rpnnXECi41KX/kth08uye6dOf4n /9b9iT+yN+yY+oSxWEfgcFfkaxt9csUazPZVXhhzn6elVLn9j/8AZhuHtrS1sNGhe2d4nksvEMFw S7D7pOdo79eRX6fR4hzeMbTo3+TPOq5VlspfxLfMxV/YK/ZuubS706ylVLCcl303+3bO8naUnPMr MWK5GQO3rVO4/wCCfHwG1mWGw1S11qRQnlQNaeII7a4AA5+YP93/AGQPzqv9acTTl++w7/FfoYTy TDOP7utp6L/NGWf+CbPwSsJtPMX9pyja9ndTTXCSCaE52xAA4z2Lc/SuKvv+CYnwov7lUhu77SGa Y2nl6fB58E0YJZRcqGBbHXcMEc1quL4bSoP7/wDgGD4fTVlW/D/gmfJ/wS+8DXGnXcF14j1uWCdj Co/sxoWsVB27YXDb1HHUkn61y8n/AASr8BrJqkt14i8SGxa3j+zXs+oza1cQkcEJH8q4YnPzk47G pqcaUqVmqTS9f+AOPDnMnzVE/l/wT//X+rk/4JPfDKKyEUHjbxNeXYlle4w82nQoCBsj8sDBGc5O 4fSpbb/gmPGbVLeHWkvtNtoxCv2y9+yBsH5V5iYnbjqea/WafGeGklOakr+j/U+cnw1WT5YuNvuP PtY/4JOalqOt3Rk8W293aakiLZ6baao1taWpUYIyqR5Jx97Hfqaz7j/gkz4n8OgQW3iKCW3WLzor fUL77SLMOSphGPvAdQWBxmuxcaYKKTTldeS/zM1w1iHLl923z/yMlP8AglR44awvdO0nV9Lsbu1C 3surz3yp5rk4VG3D5hjqMY4FYF5/wS/+MUXnxP4k02VrFfMVdLMW27z0bJG4/RQa2/1vwNSHMpu/ oT/qzi4y5XFW9f8AgHI/8Ox/jrM8/wDaNvo9156C3tzBq5ga6RjjaItuVfk8nmpG/wCCbvxRtrNt CufDOuWpmjezjuCFuLc7egNwEBA9G64rehxTgajalUt6r/IzqcO4umuaML+j/wA7H//Q5a7/AOCb Hxi0a4GrWVqVs9OtGL2kl42qW0CY2lpSiF1Jz0PT0NUrz/gnr8cdU0u5vV0e0eGSILbz6dfSRPbN jO5ofKLlcYyccV++Rz/Ba/vl87nxM8mxnWk7eVjkdT/Yn+O1lp8VpH4NEd3aTKXImkS1kiC4U5MW WLcf41Hb/sY/tAwSsk3w4vYGFl58F1fXgis7knBGyMKSPofzrqpcRYKcVTjUXMznnkGMhJ1HTfKj D0z9lz46aWo1PWvAGtT3Nu0jx21u0lwZ2Q7IlWNB9zGOp9K8W+IXwa+KXgNI/GHifwP4g8PM1yYt S1CSyZLS2jI3O8k3BAAwSCMgewrpo5xhq7WHpzTlomr/ACZx4/J8VhqUsRWpuMHdp207ngXieMi/ wwgaDy1Yzo3mpJkZOD+VfB/7Sbafql9oLWeUntre5s3jKiC2QAA+a4zy24rjv85r3M9v/YVa66Hh ZQ4vH02tz//R/in8T6ZcT6J9vi1i0H2J3iuVEg+0ZHG1VPXn096830q9kWCZYi+2aPZP285euGHp 0OKqtdV5+rHT2V+iOv0qCWaItKqyQwoDDHnbJGM5+Xnp7V1uhm2gluJ5I7qS5SPdaOr/ADW754/D g9PWvNxTUU5S2KhHmlZHdQMMrq13MjTvtUQBMSnjDEkcZI/rWlBe6ddToq/6RBcTeSxTlwQcbSOu QeD9a8uUotWTNfI+p/h78PtQ1LytW0vWLfTY7WyEj27jE84jb7gB6HkkZxgjrXs1zpN5b30Mmtma KEoCbuVfMZVI4OM88HoD3rwq9pN2OyjCzbR//9L+N+3tZNT1+1thrRtLV7hroXl4VXasQDFMf7W3 GOpzjqa9Jt7SPWLPxFPokkOo3GmbJhbx74I2twdrku/G49ACfX618rN+4jilFKUmdk8unWPhhdWh 0Z2vxCkS29wRGrerYA6p1xzUejaq1nA0t1dm7/tO08q5t4B9ljtyc7WYYxkcfUVVOTNI/CjzLxTL qFtqtnJFCGL5AmifJiBHy8d84Oc1xM9ndyW1xbpKJJlJkiDxgFTzwtenS+JFxlynk80pttQX7bNd TSSNl5HH7u3xxhR2HtXofhaO+1DUtLNpeG3tftYFyEAzcr02nPI5+nWvRwyf1iLZ01Hek/Q//9P+ d74bP/wj3h2HTPtKCA7xJpk0RZwCq7XiyDz2OCMY96/aD/gkTrWt6T8epUhsYbnSZ547ny/MWZoD InlCTy+WB6sTwAIvev69xNNVfDRxk7J01+CPyLhGUoeIseTfnf8AwT+xfx3Yz3XwsuYTt80eFzbX FrKAIpGaBkKnPBHJP4V/Ax+13ZX9p8X/ABrpOoW0VrEbszadd2bgSPChC/vM5+ZmDHp90ge9flng Jb+1cXF9j0PG+0c1wsX5nxZcJYrcFtUk+2P5vnIkp2ueMY9fWs+30yKa6+1W9wpXcfLs34i3Aghi evbpX9aQXun4cp6uxXgtzdpcmS2jt5HuWRn6FyOTisdYWivnIvhBETiNZ8HyxgZAIG45IHA7mqsX zo//1P507O5i1C2kgWG6t7q1Kt9plkDxXAzgqBt4BweCc1LqKpe3On2d7MhtrZFktbOCAubdgS27 I6BiMkGv9H2tD+SoStozm72W+1OVLe2WCwu7WeQSW837uGVequ3oQBwOnJrY0ae7060eaOVZLqR/ LlhdPMiT8e444FYFuaRkapbTSXfnXbRQ2sro8rLlZY2VgQVHTHHSui8iW2uJre5eRZ2gWezk8ktJ MpAPuPunPNaQStcz5pC/2ZFd28ZutRt3We2LWSxvi5yM7i/90ntS2/h+CO2+1Xc80MDOGVpZi4k/ hOFJ5xjHHpWlkTsf/9X+eaTUNO0qWRIopptPbatnOo8qSBwR8+0ZJVsc/wBKhtxqd61zfFbSTTrp 9pDNm5UIOXfI4yemPXvX+j7imfyG566BDI0dqLaZGhiuHZWlwvBBIUj2wevarc0unm1utKYRyNMv kg5EqseDuUjjPH61qoaGqk7WRgxWEsMiOsRmEfyx7mKpH2zj6Vv2Gv6toguGieFYZiFW3mijmMhx zgOCOafIuhqpbWLOk3HmqBqE8NrcSBpUVjhW5JCjGc8Ulr50moTX5lt7reTFHJ1wB8v04xWdmtC0 rux//9b+feCOCZ50Ko1rtYzqI929uOvbHXOazIdegmlkht4IhDBMEhZ22YVeHbBH5D2r/SJJ3sfy gld2NDUb2dod9tKixKv7xnBG/wBBn61ltcpJaylrkRTmEuCmRwuOP6fjWxXI7ksepWVhEl2zGRnY Lc70+SHAGAvqecnFdedXeDSx9gtoJodQjN1IkaAyyAPsywxnOQeMjpSbS0ZnKGupj634Z0W9g0rV 7O6u313TbZ4JWuP3UU4kYcBV6lcYye1L+8S0WPz2Qu2HjjXE4x0IJGAD04PbpTIlDXQ//9f+ezWJ 7+aOHToYY4Z93nfaQuGIPQnPH4VPqWnzaNPFEXmuH2wm42jGGZVLYHQda/0oP5M5dLEcltNqV15j R+THbP8AMZG2FzwcYqzrtxqNvPb23m2otIIldvJIfIYZ5I+lYyST0FGLT1Kdrq8WlOJUtzcx3bLv kklYNFzyUzwMjtXUaleabcrapp2lQQJcIIJmkmL7s/xFen5VFka007WMxtPTTEIsUSKV4gnyj92g BH3f7vTHFUdSsdUjsLW7ntrS5sL6d4ZFMyyybVXPzR47+/pScUzZXtqf/9D8DfDuo25hFq7Rq7DE ds6hHiQAAADsP5VrKUtGKWo8u3uJThYuWLE5OB+Nf6P8qWlj+VzPlZWhaa7fyovP2WuSWaQj1A6V LYPNGcbQY2f5kYZLdcf0o5V2G23uc1r9yLHUnnbTZXmvMwCaObC22BnhOc5wa0/C9xbXTRxTIkd4 oMsMU6bZl5xnBGR1oSS2EbXjLw7aCFL0yh1aNPO8hiJ4XOB29P0rh/Cd5PbXlx9lvZppHwkc9zIW LY4UHP8ACMdM0xSdvU//0fwa1DU76G6u5FnF3d2EeL825GBuAzgfjj8arJf7JHu/s4EclgB9ncZd 3Yck+nXpX+jco21R/KF2jNur20h3QXRmV5Id5Mce4pnIGO3UetU7CPyWXzYjLBMf9YOCAe+PWoNK ex1OmpLa2lzJp2rSQZbZJYHKAjoCp7965mxs4I5r1L6OGSZZRLDdB8zAMDu47e/4UW6Fi2d3NLqF va2km6zMh80tk4HQ7fyrobq4sbG4eFFdwRu3RgHb7NzWXs30NYN2sf/S/BGa1sr6weSGUCKRikm1 wjoQfz6iltdOsokjd5lle3wyhWxtI45r/RaMUvU/mFSaIp5pZboOxjZ4gHULhtoPT+tVJYb9LiLU 8xzWRfy1tn+XfIME5Oc1Qm7u4+8WS5llkuIra21SQsg+ynzDGD90Zx2/p1rLtba0srO8sFsrb+0b iRZrq+2k3G9eN3PTOOlFiW0lcsW1/cw+Ttlt4lgO9pHQlpnGAAPT19OKux/bMm6tGGoujb1iZg+4 5JKAHjjnj2ptWFHY/9P+faS/gubOKfDi6kkK3CGDy0tnB5VfUe+BWtbRS6ddwzCRkleECGWBSzku OUb09/pX+i8VZWP5klUFvLO8uLe5tyQ5SMzSsJAqnPQdffFYVu8ontIpIUjMVsIppeeTk5Y/nj8K jkdyIz1bN8aZaeHZZ9V0+9tNQ87E4R0HEj43KityxHPbtWbqEsGpRQv5YBusN5hBVk39z371etyW +pa0CCDTzdwM3mD7J5cKKeFbOQx7npisuRYr4z3UOnyx63ZgraC7jMEM5I6E4PBxU2skn3Lg/dZ/ /9T+fPSL1rmeRFtZYmi+S5+bfGknQheOh/StO7sU095A9qIzfANIp5EoIxkr9M9a/wBFaq1ufzNR 0SuVrmZIPJjiEVoYUEatFxu545/GpQRZQvLqczvk+asjL86A85b2pxVlZmt0pMl1mLU4rW0a2ltD ZFlnWZG8ySTjIA44GOuap6eF1MgXOptHqAmaSO3CgJIoHCYx36VnytFcytcpQt5usXFsbYGSy/dy pMhGCf7v+NbQaB454r3dbWQBE7R/KQMfWlyvsZxlZ6n/1fwCtxaWKRWdpIbqBQGjnb76g88/TNc9 rkFu1wrASnYwdpIWMbnnO3I5Of61/oc43dz+bk09jZe4IsoyIBG8oxG8qlQw74qKGN4BHMGA2ncd pyDntUODGbUUsLqTeK3zfd8pS7j/AICKy76JbmSK3eSQbiRFEgxnA6tRyMnmiUFi1e2uFkkeI2ka 7SduJCF6fpThrF68w43pv2gOTlQO4qow7hzxP//W/AGTxDrNzdR2U1zdpZ+SEiuI0A8kIDtUHPPJ qpa6neW1xb2l7csrzSbVmY7POPOCQO4GTX+hvIfzVzsfcW0dtPPOx+R23tMesp/qen51PbSq1tIb N8yuCsDSnYrN6Z7c1Lg0QZyQ3enT+dMEjuJ2MUiB959Tg9OSO1b9y0MWnRuY5pb938u2Cj92xP8A ePYe9HI7XDyKUaXEN0DdyyOfLA8r7qJnk/X0qXUdZ01ZLey0/TXhutg+33Pm7UlUA4KDHXJ5qZRt ozKD1sf/1/56NO0+/EjOZ5FgjlaVEJDA5zwewrbvzOpsgZmt3Pz+SEGyZSODnHTuK/0HSUVZH8zk 8cy+cj3MQeJCFZ1OHYZBIB7dK2L2yj+xfarqcmCP97Glugafn+EjrmnYDlIr5tRuollt7iFIVASR 4RBvHb8fc03XdX3zRWujWTQPYqDPOQQ90x6gHoR1/OiUe5UZcuhG1xay3FpLdRTCUxYdGXe7NjkL +nFdZDp8KPE8c6pbsmZ0ePaRn+HOexpRioyVu510nbm9Gf/Q/A25dLC5kbT4kmljjM3kkFYnAznn 8DVJtVe4kebYsRcZMEZyoPoK/wBBZ7H83J3Q8wLe28n2qIoWGNj/AHgOnNMEWnaMgs0CyR3EeRIR 8pyPu/hyMVkVdp3M2QmWK3MVurxWz7ERht2gcYHsQPypp1BY7curPFOCU2BTgjnPOamS0saRlfRl fRmmN69uxlnNwrzKjqTEmATwe2fSlvbi4iLSqrLP/wAs4idy5FTNWsirrY//0f575y95NDuhaNlh VpSh3puwAee2SelWbrTJXt1axcT3qRGW6iA2xwIOrbu/HNf3wfzuZBsbrzI9skbFQcGQ5jQkYOf8 9qz97xXVrpxnAklfe8kPMYwcnaT60E86OuubKzmDTteP5kNsYomYE+nygD6fSsGx3yF7WNILm2lI EzSjlNueVOODn6UJX0Rmn71yxe2w0y13qZJZZZAoiUZRQehP0q+ID9nGJ4YpXQEZfap46Z/z0ptN aM1TT2P/0v51J4JLa5dzumVF8yZ0+eMD0FatjalgxBKiQeYpzjaD0xX98NX3P54vcvxRSvdRRwyo yqrBoz1J9RWfLp9/PNuBCYlKN5hxgAnkf571PJEqMrPUrXNnbWqm2ulZpiQ2F6EHofoaujbbnCW7 uGjyExzj2o5Imiaexr2F1JYul4beO4tp7djFbyDOSQQG/AnP4VVgiulM88dwoE7DMTDBUeg/KlyI ibvoj//T/nkvrh47uOVkYDiEvjcW5q1fpFbT2k0wmBuh5cKqhK55JJHbpX98Rj0R/PdPqUJr1coF s0byQY0dBjdyTkj8aZJbTbvtDToqTR7VtlHIbPXP0qXFbGhYLXthbeTbMmxgHfzVyo6ZA7irtjbL eTLJM6QwvhWYLuVT9Kyas7ARalD9jlWcxq0MXIZ+SMHGVprzW169vKFkaNjkvH8pA7/19aVhp2Z/ /9T8CpNO0VNOg+ztcR3Cu0pDSB0cZzn1796yLoQSMiLl8gK5T5Sx4r+8D8Bl0KkdzHbSyRhGBQ4V 25OeOKqRPdTTgSCNgHJV2+VsH0+lBPkaDQPsllLhGK7Q3pWCzXcLsV2zlBuVCg2P/vVrGK5dSeZX sRyz2q3VqIrV/NK+a25QI1J4YA/jmtae4igildAqyINzqo3MKORCUrysf//V/m3ln1e3X7c7yXUd 1cCCC3ZECR5I3SE43cA561oG8s5pBaCRortYgZGWMojg+/Sv70UO5/P11sW7Sxa40+6uJGLR20wt 2ywLHOdp4PfFVJy2bWDCvbqCDngJgcYHuf50+RDLMZSC2eW2tQPL4wUwqc5yBVGbxPpxu/sXkzm+ TYmyC3Zw4YdTjjjjJqHBp2Gm1sWp4oBIJFiIeXhgq8LjvV9IG8sSJujdBlNw2k49Kag3uDbe5//W /nEvm1a2ihuLqCA21xdC2tXS6BmmPcsnUY/pUvlYEsoliVIRiQqw3qT/AJFf3u4pqx/P5Q06KFna 4eXdLHISBIMqB2Ip7SLZSySwxrI5UkMU+XnP61Ch3Jc0iGz/ANMgEh/4+BIdrIpUcE8Y9v6VoHIj RrlvM2nAFWklsCknoVL+z+3BIoFCQuC88w6qBjA/HP6Vn2sIgYJCVZ7cgsgPO3sSPfBplp22P//X /m8ubp4rWeSKLMki4RugRv72O+PSksY9TjtoJJMTtJnzCRtlj59P6V/fB+Bc7sXL6aCwjJumWXEe /YvJzjpWdbq2obZmKojr+7Ckgqvb6H/Ggan3LhRXnMaMC6j+P+dRXe15VgYDhMjb0FAnJ30OYnX7 PPucnah4GODW5A32gL84TzABuY8LQDldWP/Q/mQupHfVF8ol7eJTFJGMHdICPm3enXiuhFvdi6tQ sS+XNblnO8bk6YGPfB/Kv72lG5+CKa2JbzW7fTntoJmD3kxMUVuqGZ2XGM4x0/wr6O/ZW/af1j9l f4t+FvGFo2vpoMN2kusWml3f+g2qZySY+4PIKgV5+Y5dHMMDVwU7PnTWu1+j+TszupYueHrQqx+y 0/l/wx/RpD/wXP8AgheIjiyM18lrHJdte6BcefuIBMnGRxkY3AZyK3Zf+C4X7PttYhtNgu01W4Vh c3B8PSWYXIyOedwJ+lfjNXwzzD2Xs4rW/df59j6hcSU9XF/gfhV+27+09qn7RvxAk8R2mtTw6Zbw oIrGxdjZMoYshwTw4GMnr0r478IeLdf8HeINM8V6Vqt9p2raTcCSC7spNlxNEGDGJz0KnAzn0r9S wWTUsLk1PK5x0UXFp9bqzPkaVSX1yeIlL3pS5m/mf//R9R/Z7/4LOfCnwz8N9N8P/FfVjdeI4bGI y3l5o5uoWXaI2RXVhuIxyGPc161c/wDBYv8AY/kuHiuItJvYEVXiuH8LSbJnY52Km1zkE9c9u9fv 1bw1zRV39XfuXdtUuvqfA0eJqSxXNbTvb5HXJ/wV4/ZptbGXU9L1Dwnp2yyMqfZbQ2epMqg5hMDD eD/vLj2r+fT9sT9q7WPj/wCPL698LeLL+38L20Qt1gC+RZQMW83ECH5W4Yhj0BJ79Pf4L4Mr5XnN TH49bKy/H+vl5nDxVm8MzoUsPCV4ptv8LL5W69/LX4r8O6+fDWs2fiFJzBc2F6l9NcpF5ktxggSc epBPX0696/rI/Zt/4LF/s5+C/hBoeieM/EEGn6v4e0O202GCSwvJbq/CxoN0YjjZQCRg5xgg9ua7 ePuFcRxJ7H6t8VO34/d5nRw5n1PKsFOlUfx309D8Jf8AgpR+0t4B/aT+K0WoeFGsQmnW63ulQLM4 d4J7gT3OAR8u5mfC57DmvWP+CYf7cHhL9lLxXqOj+KIIXh8QZubKSWf7PbqAwZo9xG0MBnAJBOK9 DOOHquYcG0ciXxKKW3VLt+B4XCObf2PnmMzKqtJSk7eUm7fnc//S93/b0/4Kufs9/FL4Qaj4H8D6 lpd9r+r2k1gFOoyL9idovnkIK87V8zhGbkAex+D/APgl7+1p8Dfg1p93P8S9I0Afa3NtB4ieRori KHzAzJL5mNrHJwVGflGT2X+lsLwdjcNwTVyXmftJNPRW8rM/JKGZwr8aSzequWnbRvuoy9O6P3Ti /wCCsH7KNlDO2l+MvDds8BER02bUmle7TIARGCkIeB16etfKf7Z/7dH7G3xZ+G66LNd+H9Qvhayq tqdWEd0vmQyHbF0aQMSQFA6kccV8hw/wDm2V5pTxNWMuVSTej6f8Bn0XEvEGGzLLasKdpScXFd/J /ern8lWvXen3M7TLFbrazE+TDbktHbruO1QTycDA/CuQn3OsrQxM9uiEsygkof4ePfmv6KUXsfAx m4wSfRDIV+0aVFMEkuJWjE0USfuypByP0FfrH/wTR+KnwU8DeMZtU+KulWN9qxljg0yTUZVtG0z9 2FdYg/ysWBzkcg/XjwOKMLVxmQ4nDUb80otK2/n+B6mT4mFHMaVWo9Iu/wB234n/0/2D8O/8FE/2 Z/CNjNo/hzVvD1glg8dsJn1gJayB4gGXYQCMHI5JGR1PBry741ftj/smfFH4aeLtC8T3Ph/UpTol yt6LjVoFluRIhGIH4JJUnGDnpX6Vw5wtmmV5vSxFnpJP5Lpc+L4h4kpZlg3R3smr9m9L2/rzP5Hf ipJoA8ceJJ/DSt/wjTamBoaS3C3TQxLGoVPlUDK4PIFe9/sc/tWeJ/2ffiZok1peA+E7vUVOtRXV x5ccDCQE7Xbhd2MYxj6dR+4cSZdHMcDUwjV7xdvXS34nyeVY2rhI0aiet43+53P6uG/bB/Zg+LHg fR7nxje+Hns2t4ruZbzVbeRbMhP3iyLuDoytnjBBwK6v4E+Mf2XvFviqH/hVUekSzxTLG15pM8Ul tLJuwmVGeQc//Xr+esbkuaZfl1RXfs0ffZdm2GrZzGhhvjb/AFufZ3xu0+8Hw11aO2Nu00VgMW0/ 3piJAWiI/wBoKf1r/Po/aQjW6+LHxFtzHE0Np461KKV4U/dufNBYKx5wWHHsK+x8HoXwmLifN8fS /wCMrpd+X9T/1PiH/gnh+2j4k/Zp+I9lY6rr0Ol/DnX50GsQyOUtbZtyp5rA8D5MZ5A49M1/VDqf x5/ZN+KvhfS9X1rxF4e1C3uIlvAftEAUiZAPMcMQSreh6fhX7hxrwxiKWbxzDLoW5171u9/L79er PhsDm2FjlscJjXezdr9mtP8AL+tfya/bn8efs+/CDTNM8bfs73Xhmy8W218szHw79nXdGCDO8gQE AgA5Lfe3EdRmvsn9hX9v34U/FX4V6V4b+KnjTTbnxVO7wm3SQz7h5Q3B2YBc5LDae6nGQRWeZcJ4 vGcL0cVb/aIS19O552SZ5GGYYvC1H+4t7q79bfiflP8A8FP4f2cfD/jLw5qvhO8fUbjVbiO1n0rS 0CWkkcbfOZpFIA++dqYyCrHIAr9DP+CcHxH/AGTtE+FMWtaXJYeHdW0dJZtQspJIvtu4k53M+N2S MLjAyce59TiLL80xvB1CnrzrRrz1X9f8EvhrNMLgcfVq2Vm/d6WV7/1/kfqVc/tR/Bm4sLS013xT pun2kqfLHJfW1088ZGBlY3O3g9xX873/AAVX8H/s46lod/rfgCS2h8R6pqEU0d5agRLqEy7nOTnB V1whAB6D0zXy/h5lWZ5XmUY1FaDep08Y5jhszhHFYX47xt0dr6r5o//V/nhs5ZVWFnhSMrCFYE7w DjDcmtmNLvTLyz1SGaP7QHWWzmgkZLmxcHhwwwVIznINf206d4WPxlPWL7H9CX/BML/goVfaHqdt 8LPiv4l1CfSdNO7Sr2/fzIoY2wAd5OQinqO2c9AcftT8V9P/AGUfijdxT+Ltb0tr2CwOptMLi1mC xy4Lkls4B9h3Hsa/AeK+GsXlGfVMVl0fdqaq3m3f+vI++pZxRx2Bp1K+soK3zX/A18j8i/2h/iD4 R/ZM+JNj4l/Z9v8Aedtk97bWzpHA1uwkklVYsDcpAi6DrKeT1r9Xfgz+0r8C/wBqX4LWj+Mdb07+ 0NT01n1CwuD9mkG0AsQD0ZQOSO69BilnGRYyODwmeRX75Oz77XX439LHmZdndOvlWJweK+Hmuk+q 2f6H8z3/AAUS8FfCXw/8VotR+FOowTabcWs51zaUXdIjhYVyDyAMsAcn5s57D83oki1GF4oiI4ZC V/d/I2exX8s1+zZRKrUyahOt8bgrnzcOX2jcNru33n//1vNP+Caf7ffjj4QeIrD4TeM/EMV14Re5 j02xk1TUGivLdZnGCigHoC5OPQ+px/Qx4ysPgZ8WoNE1/XNZ0LUZYLz7R9sjcS+RJwfnkGSDgYJz jj2Br9Z4myatkvENTH4CLXtU3ts29Urb/h+r+KwGdPFRo4fGO/spXXXZO33WTPn/APbK/bC8PfAT 4fHTPCGu2DS22leXHHpUru9jGqqkKeYvyqJCcZJBAB6da/kn+Mfxn8Z/HPx5rfi7xbeTSSaknlWu nvfPf2trFvZ8R7ugy55IyRjJr6bgHI3hcJPMa6/eTb/r+u58xxHj5ZnnjrX/AHcFyrzb3fy2OR8N XNtYalZS31r5lvbyKrOtsJkgAYZkZB1wM569a/rc/YU8B/s0eCPA+k+LtL8X6dNf2un20t8bm1h0 /wAqRlRjKUjGSG5PBxnJJJqPEanjJ5MqeFV05an03BuIoYXFVK9V6pJL5vX9PQ/TvWviv8IvFOmv pV5420MxS2XlWkkD7pHDZxlScA89xX8zn/BTb4Q/Bnw1eNr3gjxJDe+Jbu+jtJrYOgTE4Zy/HdSM 45yM9hXxvh7RxmDzFYWrFxTu/nYw42rUMdiKePwkrvmiv+3Xo/66H//X/H7wN8SPFPwn8Y6T4v8A Cl41trmkZNtHG+I7wK6yMjD0bYM/hX9an7DX7cei/tC/CrRIviLff2JrF3C2jXVo87PpzMrFdi5+ YNwfqMGv3HjvJViaEMxpx/ewkl8v6v8AefI5HmE6dOpgpP3HG/lfb8dPuO08Zfse/s3+MPEmp6/q lyrDUrhrmfNjBcQbz8u7OS2OAeah+Gv7Mv7NHw812bWfDXim1m1WB1e6mW1jtI4VRuEDAbQeMZzn BNfDYvFZxi8MsNOLslqd+XRyzB1VWoSSaZ4p+3l+3gfgb4UXwv4B1mLVdd1ueS20+zsnkEVsoRVl drjBQna/yr32HOByP5avHfxG1zxr4u1fxJ4ivzPq2rXUk17dQQhpWGCC7kD5mPUn1zgY4r9F4GyJ 5dk7xNVNVKiu15f10Pl+IMwlmObyqXvCErRP66/+CWPxS+GVl8FNK0i58XWCalDoNtfXty8vlySs qeXKGjJ3AhhyCOrV8n/8FlfH3hnXfCel6DpF7pV9cSa9b6tJHLdhWeJU2tGO/wAwO4juMe1fB5Bl WKjx5UrTptQ55O9tLXPruLcRCXDeGpQd5Wp/p/TP/9DwD/gmV4k0bw5+0Zpuo6/FZafpWrXKhrmW cGWNoNsUEWzptZpAc/7Ff11fF/4q+ArT4Zb9Q1/TreyGnrbnzZNwUjBJXZnPZhj0P1r9A48yrF1e LMNXoxcovl6aKzt/wfmedl+Oo0eCasKkkmuZeun9I/hX+N+qpr3xM8aazAIHWXXLiG3dCQHSORh5 mCP4vf0rxoi4a3MhY891+7n2r92w9JxoU4vpFfkfmOElfDRfdIx0aUT4yQCOeM7jW3arNcMsEgxF E/mf7IyRzj/PSupw0V0VzNMkub1Le5aNY1mjQ7VWTkOPcCo4UCsztHsUjdjGDU8kTRWsf//R/HCz 0+9vba71GCzuGhsBl5lhLIo7NkD361PZzebAwk3LIDksybBtP9a/ruSd2z8pU7aFe5m8sMsLK25C u5l3Bcjnim2rzGIMpDwK2xyOMc45rGUb6oly6s0Yrf7Ncte7hOJIfL8tjlVxWa0kln9pu/NfbLzH Z8bFIzyO/NTyM0g+hAl2BmSdwvnJk7OcZoSyPmfaIXVo9uGLc7h6UuSRd1a5/9L8b7PyxIy4AUAg rt+QVZgsxI/DsduQE7c9/wBK/rNQkflDd3cmMP2K4it5IW8vd5kxIO4g89+BweOKW4FlH8sskLyy SYijU5kK+pHtWiVlY0htYJrODZhBtYDcCDwfas6QTWsUkqIZWVSyoo5OAaTjd3FO2w7T9RmlsVuT GVy5EkfRsDg/Q02GZ7o7RHIsaSZyOlLl1ZnY/9P8dJLkxo6FQzbsrnjAq1alrmB44FzKwwwbgD6V /WPK+x+TWV7lddOurOaJmt2jcvxK33fqK2rjT47gzSG62TFN4flkZhjt2p8suwpNWK1skUUci3k0 iStH+7dY8ru7D8eaurqFo9o0ltIk00TiN1dNwbrkn8unvUtdw5la5NHI8lsjkqAxIx06deKasjur ruSPyl3/ADsFLY4wPzqHC4udLY//1PyKe4dyxhV152kshAb6VNBZSO7CSRCgXcuOoNf1ZyH5Gpq1 mW7awg09zdGZfNc7yTjgDpVWcW8Vys9m5MsnVixHl7j81YOn7rRlN6OxLfw3EdqjWlxvyN0pkHX1 /r+VZtpqCyboXeSLcfLEmCqs2OQDW8aFkjo5vdVy/J5vlMoUhfuo45xWlbaCDEZ5ZkICjYGIV3Pf iqdFotTdtD//1fyclvY4tlhAxFwTvIC8BFIBOfqRxV2Gaa0Sa93rJwENucO2Mc7V/Dr71/VcaPRH 5Vzs07HVEWbzpl2RTQkTQ4ADZ5/DkCqN8iDdJp4WW6lBYAchcdB/9al7F2Yc12myAiCKFJY3NxNM P3sT8tEwABH0/wAaqxQebKILe2lheZi8jCIiM/jWCovlYlNc7JLOygjuXnuFLMsTQyI3IPOent/W rsxEyiK3OxD02jGAO36VLo3Y3Poj/9b8qbWydFdXkZ080sFc5HXoKbPqDRXojSECQJtLsmFxX9Qe wPyrnY/fetghGlUDeWQZUc0I7yXAAUpt+8jDBb2/z60ewM20tyzqiadMsImvjbXKEP8AZ4hvbb0I b296pQyR+W1pveVZhtjQsdzfSq9m3uTzo3YY7IRwohnW+RNsol+VUweAP/r1l6xAblvJuJCHGJI3 Zcgnsfel7HSwc6uf/9f8tVn228JmiWKdQUZ9+Y5T2PtWjZWE15Ayy3KQZVpcuSI+Bnj8uK/p/wBi z8nvylFrUWemT3MdxGyW8mHjd/3hycZA74/pVrSLr7OGu3/fIkZYQpyzAj+tL2LK5nszdstRguY5 EV1tY4lMyLO2yPJHbP0FULaJWhklud0Ms2WtZdu+Bhzg5759qfsZalc/cy1M5k4CNOi5xnCNj39K ty6ncpqEV3Z3clk62gtJrVMNBcKBg7ge+RmtFB9Q5z//0Py+ukTUYVllaUXwk/ezhtuVGNqge3NP a5aNIcgOu0IGAAOB3r+pvYyPyrn94q2txFLLJIEdJFl2gFCoJHGavxmZvMaWONAWzlvk4Ga09k77 kuSSSZUjVopftCbXRztEi4AHtmtOS/dJJwkP21BEBAInAVWyCdpPt60/ZsnmXcry3scNu73B2M7h Ymb74J/hx/npT44rme38razecRIjN29Of1qfZvsLmij/0fzCkh1TTrcyZzGW8ua4gBYAnoOM1Yt4 rmSNQ6feUu8k7CJiFBPfHJx079q/qN0pdUfknOitqMzyiOa3t4bOONf3y20Pzy49RySTVdLiVozO JZFQgeUnI59AKzr0FKlaxjKfvLXqTWc09zK7bD5ikIGYENGc9R+VassUsYPm5aQdlH1rpUNErD5/ MhgiO9pGt1VmGxXHJI+lXrNbi9DRr5rxwuYwskbRY57A449xxT9l5FKcraM//9L85bi2azmigFtI C4J80fcTAyfequqXK2f2CS2gNz5mSVjfOAOCxzwPxr+p/ZJdD8i55Gpdlb8WcSkWscgCTSyNgAc8 gAfnUVz4RurM2jyWk09m03yNMxFveDrsJJ5yOetQ6N3toOU3fQztUvIdPuYyNJdTcSZhtYI2aGMH gAkdB9cdPanXCzxPbmJY4pnhErxwOZY0z2J9famqEF9khydtyG8mHkLFBbXD3hJaTHKcdNgHt1zV W3RZXS1EiRXMhDGNjjzPXj86fsY7WI52o6M//9P83jYC2lAJIVSC6quWcelT3D+VCphl8xZGwExh 4MdAa/qV0YrWx+NOpJiW8kkd3HJeeTcOuCIiQY26Y3889qzXuWkldFiWNo5WIwTkD0601Rg1sTzy TsMaK5kt31CGaImG4ESQSElwQMlsenb600yTXJUxOsjSnEhI2LC3cZ9O/wCNCpRWxftZD5479oLW 3hvPIMdyGlKEqcD0+vH5VchgunjZZRGJULOro3mPKv8Ate9XGlHdle1ex//U/NC2juDJKizfLKdq /wB6M9+a3LSJba/UmfM8cBiimlbYkLNglj+Vf1b7OJ+Qcz7hK7bnhu72Ga4nY7JoyViK+mfwzVeC 4S106CxS1gWRZmBumlfz5FPbbnbx7AdetDhF6EKTUkE1rqpSMrIqWqAtAqkB3OTkH2qlDdajcyRw 6hcO0VvceZBFjoTgc/SksOnqN1ZJ2NLWHvbR3u3Iv5JCu0NIWyCAOWHpWNYvfR+cZlG6RCVFu5wg PY1p7FKNzP2jP//V/Nm0v7hLq2kVGSa2JcDPJxnqP89KuQ3ryGdrmSSW4eQvG4ITBJJ5r+s6dBX1 PxunVlz2E26lcSK0cu7yISrRStucqOcj9TWxYzXFvYBZbNkS+DZfIeNwpwD7EEV3KCfImtE1/wAH 7+p2UrU67m+u/wDXl08tDOazmmSSQ3vyo3MPmEbxnpj+dUb9NSd4bewumVcAyKR+7lGMFc9j7ipx a9riXM9CpGMEqkepbsLeOIrCkEpnADSzDJQfj9alnvyl75F3vCvyswQvn1JIrhlRS1N5OPKlE//W /O2Wedk2W8piQnPJ+SQe9WXkSTTZmkvjBdWkieVF5RkWYENuAOcjGB+df1b7JuXKj84nOKjdsp27 xXVlC9zbpHIcuBgqZOT8zZ9qv/bZbaGOC5ZtS0uRz/oSqMW44yQSOeRXqZhgaOHo03SXvbO3V21f 3oyjUVSDkttiu1hLcwJdiJBaSAxKNwLgDtt6gCqtsZ/tBguLmJYQ/mJLgeYqj+H9OleTGk5Satse fCuuZ6mpctCDFLDPJE8Mysj8Zmwf0zVdb2/sdUvtTh0+C1i1SBYbiVgXM20rhgWzycdQa7cQoOjD kjZJf8P97O6OPlTpKCdkf//X/P8A1XVtRkFrc20hlkdhEwD+WYlVQo/ADAFQwXEljb3E2yTzLs7s odyyOO7e3X9K/p5YaU1dI/OpY6NSaTetjLtb6W6P+nSpdXPmHHmESsvPQDtjHFb63N35El/bFISq mEA7UeQjgE9z/gawjgG6rutDjjjIKry31Ryz6j57R2N+Zbu4sZlmtJLhvOSIfMTtJ98flWk+pajG 93HAbS4tLqzFrILmBS8IyGzEcZU5HUYOO/Nd2LwtNpckUYLH1KtS9STbRX0zXtTWC3iB+zy2Erx3 GFJZVIwNsh57g9e9WpI7+V7W4t9Uu2S33GR1uX84K2SwAB/D8qj+zsKqTrKn71t/w1OWji6zqulz 6a/5n//Q/O5tRu7NWs9MknSw3mWS2uCcTs2Nzt3Bz79hUVhrmq2t1cF7+a1QYmgihlkkjZx8oVlJ I6Hr7V/SEcti6bk4/gfk9bMOWSipepVhubq0lu7v7dJPdTRs6LIFaUyNnJBPXr3zW3pvi7V47aCy t7q8sFuLU2shiunclXJ8xVDEjBOfl6V6eUYSi6zc4JpL/IFj61OpGVKo0zM1i7vdLUaXa6refZhK Zbx7O+kSSSTAxHJggNjnjnHFRt4iuYU068fV9Zs5LAqbffqM1xvfjBdSTxkZ4wK7q2AoRnKNONlf Zee5nXxtV1HKo7vzOhtfFviudrhLTW9VuxcwCSXbKzThgQSyd8diDmrUXjzXrXy9Ql1HVGnhuC0X malLaTkkbcBlOBjqOMCsnlFHEOFOa03fyOuhja8ZLkZ//9H4Ji8eeLEhL3eva7dzLK00cx1Vo7lc nP7yTHz4GBzT7f4vfFRra/tbTxjf6baLMJYJIFaKdD3Z3DAse3PFf07jcpwtOTpUFZOzsttuh+a/ X6yleTu1odHa/HL4qTNZxp48UzxgQx3MmkxWSzMDgSM8ZVsgdST71qXH7SPxViMulXvie6e7iiaC TVdI1iaGctn5W2tuXkdCp7dK8qrk7p8smnbzXmzX+0ny2e5bsf2rvjVaaZ/Y0vjfxBstys2kah/a Bae1kBJO7I5yfqK00/bN/aP06Zpk+K3iOIxsLgW1tdCB7humPN25AIzkc/WumeWYeSvKCfyRz/2h VjopP7zq739vn9oq3t7KGL4h+Kri5ZWuH8rW9sqKcHytzIUJ56kdq3tI/wCChX7QsWm3Djxp4ks1 jiCssl/Fdm8ZXGVWMIV3f7Qx9K4f9V8BjHKVemtF2t2/I1r59iMLGMYSd9/Sx//S5Ky/4KR/Hi2u 2hbxt4mvhcrgeRaQFbFWwPnBQZI55IxW0P8AgpL8ftPtGjh8WXFzNp9yUTe8KG9jcgq7xbThlz2O OOnav2tcLUUpRpUrxWnX0R8PSz6rXUZ1J2k9SST/AIKm/tF6bDEFuV1KUTJFm70u2kGxj85dx0Hu Oa6zSf8Agqf8ZTJPbQWOioYJ/NlQyi583/aAaPlT/d/WiHBeEq+/Vi1f7vx1O2XEWIotKEkzroP+ CrvxdNzLp0HhnRJYFiDS3uppBbWZZh82xQN+Bzxz/itt/wAFePHNvNdWM/gi0nunCx2d7daQi2uV OMRFG3FT97LLkAdqnFcGYTD0+TDxbd/W34GlPibEYis51pJL+kup02k/8FZfEktzJPqfw10HULm3 kTyTBHNbq+0Ycq+VVeeMEGuwi/4KyazGNDkvvh34Xik1K6kNzYR6pPJdW6KcA54BPqPcVy0OFaKr JYiEuV/Lodk8+qypv2M1df5+p//T+y7X/gqfobXdtHq3w+e3sbiVotS3TlXYL02lGYYJxgEZ9anl /wCCqvw+ZWspvAd3o7CYwzXKtctcJD/eUBcdOmGJP90Zr9jq8KYSbtSm0+nX/I+ehxBiov8AeJNf 16mrpn/BVz4UG/W20vQ9Q1ZLm0H2SS6lmsUJB2PnfGRkYPVhxyTWof8Agp18KwzyXvh7VJg0xSQW utWl/DYoOu8K24L2zXm0uCMZSxn1qtP9zvpe9ul+3mej/rbhcVg/q9GPv3t0t8vXofaf7Ov7SXw4 +O8ccPhDS1tIbQeat48ynEnzEJyA2CVI2t3IrT/bR8L6JcfBzxKb6whQ32nSTOrxIy3TsNu3aRkZ Azn6V8Rh8RWw3G6pU5Oyn+rPrc6oxxPBrco3vBW+4/jZ8bWekw6nrtrabWg0zUp7OHZH5JjRT2Xt X59/HHSLGwhuZJHtbW+8zdajU2E0jtLgxnA65G0kDrX9D8R15U+HKs3pdL9D+f8AJaHNmVJRe3/B P//U/iJ8TxTR332WWWBnJMtwtrEyRhskHIPQmsuzhtIYZxsZGaLy4pUbjJP8Q7/hSdRVak5LuycO +ZfI6nQJRxbXERlR0bbLAvzttHCnnpxXR6ddNO90DY/ZGRwkbK28Bcfez7+nbFcOMinSkjeDdPU2 rXzGcW6TTW8iSiQu9uZA46lRnjn61dSRNGv4ZSgeaS6VoIzAW356uwGdp6cmvm4SSjo9UznrzlDE WX9f1ufa/wAMr19Rs2srq+awcWEkrOzhLkBQSFUD17V7DZWp1bS5rZr1ormOPNrI/wC+WQD+8c9a 8mo2727nu4KUaqnFO7SP/9X+OrTtNuWmnmfT7W7FmrTLEzYjwCduD2JxyK9dspL688PrAVfS9Omh W7lhihCMSnzFC4GWGQRz0618u4e4cs/tepUETasNLfU7m8tbS0uA7iGQxpJHtK7CvQg5B5zyBSsm 6zltbGymdpQTNcyY2AgYX9PT0q4x6hSZ5nd2Op6pcG3jvri2YsIDPHtP2XBzkA8HOCO/WovEcFjZ wW86XGpRSWan7UyFd0rAEEg9h716VNJWZR5Zbpp97atdzSzyK9wZ1eZN0iYyMEjGQT1PX+Vdh4W0 TbqtrcafqEK27r59ws2UjJUFtoP4DHvXo0HarE6H/Dkj/9b+cP4Z6tBeaLZtrc8ge2iJtL2KDzjF EckRkjkjGPx9sV+rn/BJ3X4ZP2k7qbR5dSsrC80+dg8ETRyX00BiVoxnuQy8Dpvr+w6SU/DPX/n1 +h+QcMxcPESFt/aP8z+3bxM8uqfC2KSC2uCtxodvdRi4mMjviPEhZxjIwWPQc44r+FL9t3wzb6P8 f/EzPdiaK4hkiXTbybEsMsLxqxjbup3Mw9DxX5B4CVEs5xkHv/w56njxTl/bGBktrSv92h+durIb a9uGnhS6RH/dyId7qB1H1HI49KoTz2Maia381nk2/uVQ+apIGF29Qa/reEr2R+FuDjJm7caWP9Dj t77y0uAGuI5UyIHPBPH4fhSQaZopurexu7qNks4i9wqQkySN94EE+vY/h2rRPWwrW0P/1/53vtOm Cwu3sDdpENTFsDdReSsgIA+Ude4/Wo0u7eG7e/s9q74zaSJKxkLbD8zD0Yn8s1/pAfyLFNLUxm06 51G8vbuMR2yKvmSzKRuIHAyD36CodNS8tY4nuZ2kySgcx7A59f17Vmoa6lG9DCdShmtZFBa3kEn2 nYDyQcL7CpNSv7i2CBJHaaRfILk7mUY29fpxWkYrZEybSujBGlopt3klWRZZcbIhtZRxkEfnWiiw kPprrcSRCQ/YDKCxUZJAPoK2cExWcon/0P54YNOe6spC8yJLbyGFFfA2bRxj1pZRcQW68o6EBLoD ase0cFimcY71/pK4LofyDGN3ZkRSw1K5ZRHPaJptuotpY5d9tdKyrvZh0XBGABkYwabZ+H7Z9Qg1 BriVkgbMUe7EZP09/wDCrNkraCXE14NTPkxsbQSZ2AYP45/KtLUG097S5mmihfUFZBaWbwsyxo3D uG7EYGAeuaDdbaEcunGWe3uNOjuJfsluET7XDiIlhzsHp+dQHTNVN1EIHwbY7riPOM7ge350mm9m VF8rP//R/nphumKrb4kti1wUvIceXJMAcYx707VvDVldb5AskVs0ZjEcR2LnHPP6n69q/wBJbPmV z+UU7MiSG6Gm/ZIh5sFvCsa2/kiScqMYJfqe3U/jT9M0uW7lEUcDIkSF78zxshhQclhxjHI/HiiP N1NItWshNPjGoG5029tWtmT50DJhgMkKwPvxUCWeoaQ7+VcM8dwptzGjlWVQc4Hsfaq1vYxqS6mv p72t25kvbz7EbeMD7LGxdi+Ofr2reURSRFShzEm4OFyzD6f0pmLk2z//0v58I5zeH7TFGxiyVKlS rxkHHzA9OnSqsV5Pc3V1byRXIuIGG83KlFbI+XBPXp2r/Sg/k86pil+UivTEsvlBC8fyEYGAc/19 qq3lvHCEjeVHVFCkk5YjpSaTM+bVopPaQXBgtJ5IEsXJ8jzPlkZwN21T1xgVVaK4vLlEs3ZRaMMo gATC8c/z/Cp5EXCTtc2Lq8khRYFiEx+VXkkfZsG4Bj+Aycd8Y96mu4RPFaHcwG/5IgdpkOMcDuKH BdDZTWx//9P+f+WysjM19EuLpXAMcBG7aOWH8uOlaEstmkkW6Vo5YQsrLGwaRAc9R74Ir/Sbkify uVbu6sIUujCkr2RZfIN6pWVWcjJ2npkkjHoatadqNzI5R7RP3UqpAu/b9oXav5HOR+FLkQEd/cXs erXYvbW0j04xKbeCNjcXML4/jb7uM+nNXPtumyaomqXNvDFqNzEyyzQRiHOQue3PKr19KhxajqBg ztfK08P9qXFzDczs5imVcAHoAQOwqlpC2WkJJHLHJ/ry+dpZiPY/nx70kr6Iynuf/9T8FYreE2cO oxxxR3l4rfaYWI+RFPy7z3yDV2AWNxby3bIsbv8AujE3+r2jOCOf/r1/pBax/J/qcuRDd73mJjtr aXZHkYdz3/Cr11cQW8ECopYM4jiZRkE1LgmdMIrYbJep5LNL+7RcIzx/LtIx1/KqukyRLeHVDHDc WBjktwsyERs5G0tnjOAc/XFRKFth8rubDaNBaWc15ZXsUcqqsifNhnLHJCZH5/zq9ptr5Vo87W8Y nmlLSySEMzZH909O9QbU49D/1fwX1HTLVbC5BwZmT93CrbVJ98f0o0ewt47Mz3avFM8Y2jO7AxyO R/nFf6M2aVz+XzEEyW0rv5RyxK/NxkDoTSmW5njgaSK4+xkmTfGnCD+9j8KREpW0RRs7+Ga8lm0x nufs7lGklTrt4ya096F5dQhto7qWVCgSEbi+4bePcdfwp2djNydtShFpW6zgjAeO5gd5JluMgyMW J5GOPpV8WE4a3jaeWBkJdGtW2bs5+8evetHezuJT0uf/1vwRttMMcbRrMry7yxMxA689f8fzqrea yunpbqkU0sssxiMwBMWAOee2OfrkV/ozZn8rKXNqPtpJri68z+C4jCYLYXjvj86siztLH+2Z7yZb yH7IGtVYCP7KRjJP5E80hp22MDTwz3IkhWCWGTLv5nzbMgYK/wCNXNatDaWpvbCIRxn920TTeYzP jPyjHGewoLjsyTS7u4gs4Z7u2IkYhhb7czEnAw3p09eK0rzzYJkubuWFIZ/ksYVPMnHOT7HPFKxv Ffuz/9f8E7VBZs7O0iO0rO6QxFiAORx69qpwa7pGqtHJdCWKYXDWMLTJsZ89SQeh4GBX+jMknFXP 5iU7NIyLnT4DJdQ6gsklvLgW7bjGyYIOR7jFb2bSOx/fBp4duxVmy7sCMYNIOfUzYoLgmCIZSxMv COSwiU5p1vpb6bqk97ZXySouJbYtCTIGzk9eMDjigTm7GxHJDcXjXM7ob6Zcyvt2kgnluPes7UpW eK7hWOKaOP5JIX4+0KcZZeOw7d6AjNo//9D+e+weF57W2s5VSB28u9d12eVyMKPp6V1erQ6TZX1p bRsLm0kTBuVw+4jqSB06/pX+i7inufzMnfVGPc3umSW1rYyXDsLGdxFuVnZFbBzn/PWrD2ljNbo1 nJH9kiiTBjfLliMksOx9qzcHfQLohtCPMZ33RJbnAd/lV+Oxqlba8tpqDy3VuJ2ickRq2Q6nvmn7 PQnnRd1ARXaNPZXSyrKAwhzkIe6kdQRnGT6VnwqoeQNA0YhiD5IyDxyc/UHj3pcjsJz7H//R/n0m f7XbPD5rIQS0TKP9WcdQKueRstLO4mSK/wBSQBYpZP8AWAfdz7YGa/0QtbQ/l9y7sova3c95JLch hCI9gt93yD1OPWrkVpaadaoIoZJDIxlMUh3Mj+2fwoGpNLQrq8N9fwM5KSxMMRseFwelbup3lxd6 oGEUNvaxwhPs9qg8oOoALDHrjP1NAJtO5NPbC4aCUtJcXDR7LeOOUlfQBl7/AErAhhsy8w1CCdLq NiiugAUY7c84zj8qiewJ2dz/0v5+7F7sXk0ThorUw9W+5Jg+vv8A0p00KXTFoWysaiNVHRcehr/Q yMbx1P5jU+5JAsUVxb2EQeZnhMpIIMURUgYJ9Tn9KsXN3cgz2s0RLJ8qNEwZMj9KtJJWBz7GNaNq F0hQmaS9thvmMke0bASeB6basTtCUVgCZR84OOmPUVM1oXF8yIbK6jnmj81ArI/7uZgNgOcde1Wb 68nlnkt43UQKv7x1OSzZ/lWaXvK5vSejj5H/0/59rUySrHbHfLMGw0nZhVmOwjju5VBwluoeTg7f w/I1/oO1dWP5qjpKxPceSyLOl0eX2C2AO8+5OMY/GqGsWtzqNpbwWhiZoZfNKsvz++D17CsWrOxf Mk7EEFtdpEI5maIY4z0NPGk/aRKkG554Y/NkckCMj0z+H60n5DumVba5niSIrGqO/wC63xnhe3Wl /s6SW5BWdp23bSM79h44/WpkroSlFn//1P5/rhntYPs8cYj25+0MM739m5/SktoXnRpFuTB56eQw RwpOeze3Ff3wfzhdjJreWw32c0P+kQ/MSr796nlT+WKzZI7R0Fw9ugm3BMDqcHoD2qlFshzS0NRQ IbgR3JWJQiSoudzbXUMM/gRSzWYiErWWxfMJbLDC5PrWkYqJHOzOmt72eeC2mEkhBCqIzhfUY9iT 79aW1t5IpJrTVjiQzt5KDjEY6A+/Bqi4zvsf/9X8AftltbyhLeBfMWMFiybkPUD2PTpUFyb24jRL QQPO+SWP7tFB+melf3+4p7n83t66kVrA8W6YsBNFGd4UcZ74/Kr1jcGd9siMC/OSNuKXJEpSaKdz aLDevJI28Yyisd2AOmKdJfyhvPWIDau3BGQR0p8qeyNYyvqiG0guJVLs5TJ47bfYD86X7DAZvOuN Ve2aGJjFEE8xJGAOFwOcnp6UuSIpS5dD/9b+eRLxBNElwjY6+YV6nPpWpqkwWK3lEclxECFQKPug 9foK/wBAFHokfzrGVyk89tLcxJCggicCNztyUHQkirkUS2wKzypOFkJRwnlgL2GO/wBamUUzojK6 Jo/st9uygcIflUkgH6iqyv8AZLWWZ4iERjvH90D2H0rG1tCh8zRapaNbEfuZYwSRkOB7VSlm0+1i gs7WSaG4J8tD5bJkYORn6HtUyV0B/9f+eiDzolkWQsIkI2GRiXbuTSWyzgy3CxNJDHwjKcAkjvX9 58vvWPwKdtLGZqAe8cqJXjcAE+WmDkY7d/r7Vd0WzmkiMl7JiRXPkHGCFA/i/HP6VSgupzybTaNB vLmtZRdFoXRzsKPhcA8dqwbQvLPJEjsYs7ZXwQCO2DVpdEQXmtVa48u3wVjGQ7YLKaoXcSaSyTyN Pc3ckhEmFzAiE4AI9vWtPZvqB//Q/ni8qFwZrny2it4/OKsflQev61iLbW1+zyQR5IbcJFbb8oyc V/fns31P53LdusNmJnBYx3DDcpOVG3j/ABqvfHaqyKuFJwpH+faj2fc3i7oljmmjiMbuyRTJ8oAy GzWf9tNks6IkIaRxmURjzmA7Z/Ok4NDNHTdQZZfOnhDIgzlxx9fwp97cyaxqNqUu5TEh2Mp+RcHp n2HP50lBgf/R/nJv7VDK0TsmyNh5L53EkfxVPAtmsaRyxLIVOZd2cTemfpX99uDR/Pzdkc5eJ5a3 Fs6NsmLMjINqhc8A++Kr2gmfyk86QQxkAooB347Gps2YGlLLqKSh9OlgjEBDMsqZ8z6HtV2VkEZZ 2ZC64IHzkN7fjVqHcClbibTLORpZZpYXDSSCT95IvrgAZxxnFa2k6aZp4o4QZhPBvR2YKTwDg5x2 z+VPkXQpSaP/0v55b3QrtxaDZHHbxzCR+nz456VUkv4bZ2hFsz4faZFPCccV/fyjZ3P5/Wqucbq8 nnut1M5jSGTymCRlkYE8E1biaCzXdvZXkwVQ9GHsKHBagIdW00XRtjNi9aPzUiUZYgetZ02owXYZ JIrmJ0cSgodrMFPQ9+eKXs0HkXvMtBETIBJ5yBkhyN7D+n41CsUYTYrEHOYxn7v1ocLu4H//0/5o 5YZv3ckckYhiY+eGT5s46g/41E2qGCRDHukzw8gPKDHGBX9+8iP5/ur2FWe3Sdri4jU3Ekflo7j9 9Eu4Nx9eK3rCWN5ELRIyYPMi7sH1GaqMUpGrl7hNFf2VnJewtb+ZMwVllIwre2e+PQ9OKd/bcEhS 1h+0CSV90giTMa/U/hWsoK9zJPoSSXFx55U8q/B56+5pk7ta2pZslwSFA5Az61zVFqmi6bs7H//U /m72Q3VhZrewRyG2+eMSRBvJJ/u+n4VeRbgxq1vapPZW7/6RIQM25YHB2474xX9/tJ6M/AoyaZnN plpcXAZraPIbO5ogA31NN1O11y3uMFP9GeIMqk7ApGNo+hBBrPktZIl6u5o23mToEm+Rtnzgcp07 GqVzocNw2wSrGbfa8Uq8vEVO5fyPTNYxXvv5FzvKnFLpf9DI1SG7m1CG9vLhJ7tSkTXhQRylV4HT +VTx3CziRFjjuHhJCl1Em0+uD0PFXKDur9DGmnGVS/kf/9X+bDTY5YLk5jhSEISZCgVyWPI6fWrV 0v2lvsgRRbDDmNXKI2DnoPwr++HHuj+fl8a9H+hPtjYGOKK0tsjBzECm4DhvrTrgwpbt9vlju2AG ZDCpORjoAOP50+V7NG0U1GxjEXJS5YbJ4sZtUZTG8OOmeeas6fLbq8L3KovI89M7Yi3Tk+nShqxk m2jWuNJljl2KfKV185APlXaRnIp1vqFkYRFtSYRPkM4B+YcZweh4/Ssq0OaNmVRnaqf/1v517ZLq S7a5juZVjdFj8qNtqtt6M3qetbyhJYJI9TkklaOfzo8StubHQcHkf41/d8qUU9j8GduVkceqLcC5 trmXyLC1/exSQQbp1LcMW9SO341+/X7E/wDwTM+EH7R3wr8O+Jte1XU49ReGOe5vt8bOWJYMPLU8 HC9Svfvivz7j3NMTkmTvMMN8SkltfR3737H0nDOBo5pjHha/w8re9tV/w54P+3X/AME5tR/Znlh8 Q+E9bufEXhy+mFpZ6WJpYL23kGJHLFVG8eWH2gY5jJ6V13/BInQ/Efh/43SXN1Dr8GhG5SC2a+id YWZnWRjz3DRpk9x1yRXy2Mz3DZvwHWxM2lUcbNdW7rW337dj3uF8qxGH4rpxkvcjJ6ra1na/5H9a 3xy8QWkHw6uJbvUrawm/s03dxcNgKoWMjDHsTk4r/Pf/AGjXudP+OPxI81ZJrGfxZdT+bb4MUu9t yNt7Ejk+pNeT4N0pfVsU2v6uedx9Z8UU3f7P6n//1/59nv7fyA0sW2I/KsciAr07jpVaLXrhJLex l1G7dIMvaWq30qpapuOFRA2FHpiv7eSi4r3T8OrRvLcz9Y8S3MQkt4p7uSeWJoIzcXT3LRq5yypu J25IGcYzW7pE91ZOJ4tQvLeee2RLj7LcNaDAA5+XBz+NOK9zlcTNx966Zs694g1K5s7O3mvJr0W6 mOB7mVriaAcH7zZJzVKx1bXo7WG3g13V7CEE5hsbxreNiTwTj0JyO3tWfJBy5XFcva2hpTjywcSy mueK4YzbjxXr15JDMs26TVJVlYA+x/zxSXOteItXikTUdY1TUUaYStb6hfPdx5HAIDHgj161UqNC CThTSe+iRUadlc//0PwNvUgW2he4toYVRdsp+4zj3rPmxOB9l5iiXCt14Ff262+XY/F1ZJXZHZal Jpl6skL3IuJU8nz7edoJIgDnCsDkEnuK9CX4k+K47qIweMvGFlNdRi3kS11qSIyogHytJgseOOv+ NZVqdKrpWgpW2ur/AJlxUleKdjE1XxLfT3v2q61DVL+SXCym+1CW8a4I6Fy7HJ/wq/YeMfFOkWjH Q/E3ibTwBJi1sNduLKIGQYYYVhgHpxWE6dCcFSnBOPZpW+4JU73XQytU1G81Zkl1C6ub5pFUubu6 e6nQgYxuYknOO/XNQQ2iMjgXJsZdh+zNGOhxxjtn/CiU1GHLFeRVGPIkj//R/A61eW31GC6kmllv bN1kS8DlJldeVYMOhzyK9B0z4q/FvRjbtb/EXxO9tHdGZrKbVpWtApzkbM89uDxxX9h1KdDEL9/B St3Sdu9j8Vampe67Gdr3jfxd4rsby01vxTr/AIh0+6vFvZNN1HUDPal42JQBegCk5ArmoIGWVrpi ElkwBFn7uPSlGFOhD2dGKS8jGUXKXM92bcV2IghMjxOzhWMf3sZxXc2/xQ8eaGLrSbbxfr2n6eyx S6ba2F8UtlVFwCydO/T3rnq06df3KsU0tdUd1PmjT91+RsD4zfFXVJlMvxK8WhVjEMcMV95EMYGB wBxjjn+dc54x8f8AiTX44LTxPr1/qkSXKJbGWQ5WQKyBmK4yeTyc9ayhgsHh2p0aaTXXr95EnPl5 JO6XQ//S/DuFGYwShyGjGze/LOMYruPC/jrxl4ImkXwt4s1zw8ks3n3FrpN6EhnJ6uAQwV+SNy9M 1/XHJTrRlTqq8X0PyZSnFqUHZo6lvjl8Vza3CN8SfFxaUMlst9qkk625Pfgj07Y61BbfH746WYXZ 8RvElqy2/wBnklsr6SGOQdiUzhs+5rGeAwD+KkvuN6NSpDaT+8xNe8a6/wCMGS41/wAQ6vqF9DDh ppjvknc9SxPHzcBjnOOO1cZDa2rXR1JriR5GCrJCrZiQpxkflXR+7p0vZ01ojKcPesl1PTfDXxO+ JfgpdSl8C+Lb3w6upQGEpFEskbg7d+c8jdtGccZA4NYHjLxn4t8f3Fnd+MvEOq6/c2xXYb6cGKFl ABKqoAwTzj6VNDDYWm1iVG1S1r+iOitWq1Iuk5e6r2R//9P8b9D1jU9Fv7bUdOv7iyurKXzraa2k 8t1Pce4Pce1em3f7Q/xp1FJbfWfiZ4nv7CKIpYaVLftHpcOcj5oR8p4JGRg1/XP1bCYhKdeCbV91 /X/A3PzJVqqofV03yPp0PLLyS4vRc6hcyq15dkusgYlZCTl889az1crbmNScD72PWtXKKdkcsYJR dtLEMoZBE8Z3OeAMdfrVqC5lJkEYXzFOHjHLenSqlPSzM+TUpJPC97dSNEy4k3ANGyKOnAzWqjm8 ZSsZ+TqM/KwqOdF2P//U/LnTvigPC/hu/wBK0bTbe11zU7X7Nb3roJooQnJLwsGVhhmBAx1/GvHU 1G5nhaFjvl4WeULsMjd2x2zjNf1veMJSl1l/kfkdLDqNSdVbyt+Csl+ZuWNhPJJFHJtKNg8nANR6 ju0oTuhaQREK9nGBubJ44qHUSNnB2szQt723fYsg8kSKAE5P1q7daZDPC8bSAKI90JVQcdwOafOu pcY8u5hPpYJRYU84t8rDuv58VYGnusi2rym2tyMyN95l46AetLn7Fcqs0f/V/IXT4bO1glEpEig7 gx4djWI91dSXAkiYQIJDGuBkNg4BzX9aKomflXI7mrDdCFpnv51l3IQXlbk+1c+lnE2+9j8zJkJT zM5Iz6HpVKa2HGDTuzSSd8IsqsiHgMenFWFuZgHaHG21/etlPMd/bbg/5FLnQpRtqJbT6cAkSZQ3 ILvHIuyNWJ5A9M/1pzQPGrT220Qbivlq2XyMZOPSlz+RPK7XP//W/HUWjTsGlDZC7gcfL+fT8Kta eJY5meXfG0LYjIx5Uq4IGf8ACv6ydWx+TmveX11KIlvHc25UxwMTxH7D86xwGSUwCR8r+8RW6v6c 0OqZcjJVvchY5FbzFbkYzVh7aOK3ZogqNK24/wAOCepNR7RWtcHB9CurCCIeY8jrG25SM8Z+naq7 E311HGudoG59v92kpJktNaM//9f8nJZfISJDGGjVduTyyYqjK7FWNswBHLE9vav6u5tL2PyBK5At u+oRtuYq8YwXB6etU9oT9whzMDtV8cZqJT916Eyi1F3NfT/9JiWO9mkWCFgLkxKBuOOgz2z71Ilm xYWT20LQvPvV84bB4BB65rpjUjY0cXZF69VrR/ssIBRTjZIM59M1Y1aVYYIDDKJZUiHnrGpEaEgH AJxnrg9vrTdRLYtJ2P/Q/JXTLiG2jleeSMtcSFQHQM6K2PlBxnAx+tWFuLOW7a181YnHKAn/AFgP oK/rH2qTsfkyvbUs3tt51wgt49sccWMBt2/A5J/X6CmW8yIJAM7hxgdRUqa5XYqMWysrWVjIbrzX WTaxKEbskjsK0bLVry4jgiaNGQMT50ce2Qgnofpz+dZ86sxKD52XNV+xm8zZfaJLaKEfaZGXaSTj cSPqQKzra4ihYBG3x53fNxj2rNzTepbgz//R/KC4lJ3COVojM3Aznae2KJN8tvGLuEFkGHlQkMRj tX9S88dj8p5JGyNQjsNPMliJBIbYqyM4ZWz2HHTpwc1gW+oRXs1uks729xKhlPlpzGB1zT54kSjf RliQRSTl5oTJuQxGTBQPjgEn8az2gW3nt2iDFE52jsR05puaepCh3NkvK1tJcYCur7Vbk/hWfNe6 vP5EUyLNb2+TFiMeadxGRuxkjgUueI1Czuf/0vyyeW3GnMLkTCVSDHGEyo9ST2q3paQ3WlmOGa9k fJkeST5FC9lHGeP0r+pueJ+TtJ7kc4c28cDRCRx+7Bxy/PU+9TW6JZqZVj/fImDGwzgjtj61LqRW gFYXhkiYTpHKZCVAC7VXJ7j9MVqi5RooLeaQSW0KgKijiMdcAe2P5Ue1j1AoXc9iNTza3KvAAI43 I2kEjJX/AD6UyTEcyXMsXm25VlQK3ztJtOzj0zgn2zVKcd0xW1uf/9P8vYJjMqLJG0UvVozyBj0p LmR5mURhA0Y2JgenHIr+rVUiz8k5XzXNW0njFrLFPH/piqPL2j5D71Tit7+4lluJ5o5IcqoVsIU4 xjHfpWkZxuJ0+xB9mSDd5pKxFjtjUfKx5wDWhYyB4ZE8tIsAiPA2jjtVOcbaicH0I5o4pbWJLjyp WExlR0/5Z/w4NVRdtGstjHO8qg+ZG+3acAHjP49KjmiLkZ//1PzV0GbzLGQTvcl5ZmVoZIyqgKfl IBqlBe7p9QgvRfM6xl7ZXjwA4wBz6evev6v5l3Px+xnaVqbsbiG8QLLBL/rY1O117YXk1t3l5FK1 uqoCqjeH8sRgdOoxntRNx9mYWakl2KllK/nXVw7rGrH5VXquBV975Wg5bMyuBkjII7n/AD61opQH JWkwmuWSWFbOQuSQyOvG0jBrXt725tyt1MpLup4kOSGHU/59a05l3Khe5//V+Ab7xPcajajz7e1t XWEQCSCELJIF4Ls3XJHHFclpwkml1B55Y0sVhLWjy/K0hA+6PTmv61vA/HyPSriC4aY3LvEsHFuM 7/tBHGFPtzk+1X7ixvJkiN5c3U9gshubSMzttiY5DAYPtjB7UvcFJO2g37BO482Nj9ljwskzHd5G c4Ld8cdqrfb4IbeMs6Bd20zsQFPtn+lUlHoY2ZZnvovsMv2ZpUvXAW1khUM7eox3yOOPWq0E8VzP ibT5rLVLS3G83Shc4BJYE9M4zinZdiXe2h//1vzisLyabUGNwWubUwGNix/eJxgFT7Z7+lZbXEhn vrFIgVttrtM528Ejp6kZFf1vyrsfiDvfUt+T5DKyzRSMEViSwkQkjODj9RTIYLSFp7iTcJ7iVQzf wKAOg9O1Llj2ErrY05JrO2TbHGHyPlhHQeuaddTQwi1jS13K0Jkj2/Ku5h1JHJ57f7NHJErmkjl2 FwJJIpboRu7FgdhARfoK0NOvpbqNJLWN0eFvJmfaVBxkZOfXB+tHJEfOz//X/OKRBcXYuYo4rIrE VmhiG1bhhgbyCTzx24rKks7kuPMuS7SMdrswGPdq/rqNOLPxeMm0UorC+vWYxEySK/lrbKpeXIyQ y46jj61tL5Ut3BqzxQzPp0Yi+zjPkuQMHeueenNV7KHYTlZmhb3IuHXAI5PGflX6VDDDi9ka5JMQ c8g4an7OK2J9prqW2e2muGtnucBY90arglj2B54rKjup7N7xLdVkaTCEqMlI152j6kc1apLluL2n kf/Q/M5ryzuriG/uIGsLhFKTyRP+5uB0BZcdf8a6W5gsJbKKyDeRfzyiSO+R1eNI2UbcgdMHn8a/ sGnSTlZH4lTqfvGi/JHYIsPn3KxlAbZriPAEoHGR655NYem6itgUs2meWGKdkge4/eicN6g1q3yy UEevGn7Sad+lyPULeeK3WW0WBUSXaWM377DHccL1P8hUIklgitb+VGvUjuoo5bG3cxzsrOFZunQD Jz7VpNXnyjxE3GC5n7qOqmRY5r0aezuA6lAF3R7GYHBI9Kqaut3YM1qY0kt54FuPNjYFRnse/wD+ qp9klJy6rQ2pwcoI/9H80LXURLOLZ7gROkJkiR0xvI6AD3PamXVzfTyTO7h3yDKdgAjHAyQBwOn5 1/ZlTDO8aj2/pH5JW0k0n8vz/A2bW1PkxzM5lj28EfdOOcD/AD3ph1eJrtLG6huEgVPMMkcf7lOQ D83qcdOa0xcG4Wb2OyUFTovl2GLcTwzW9raTRR2ckhklknzIwB6YP1/lUVnpuqXyT3U1n9lgN01t bSSzDZdgcKydODj8MV5cI2k9D56Ml7V6lwr9lne0v0G+2BRGiYNEpHHX29vzq7BBa6xLbR3Et5Gk W8RLCTtdscEr3HFLE2jT+R32Xs4s/9L88ltEidonnA5xGDwW96EkESrBLHIZY2Z41DZFxkYGPyr+ tKL5LN7H5HaDbl5nP3GjWVxOb2yVrO92YbadiKeeqjg//Wq/b2M6Qt9qkLyMNpcsQG75A7d6uajz qUTidFe3c/5kUXhCr56K0js/lb/+WYA6/UjIpLNna5ZZZyojjLrFtB39uDU1Y3p3IpRUahYhZZrm Qeau08yAnBIrZQHSAJmlVIbm3yhQ7yyHgk4z1x0rrw9OM8Pyvy/Mqkkqs2vM/9P86rrU9Nu4pEt/ ORmtwY5liK72GARz07/pWdp8aRafc7Gadkx9ouLiUFoGLcH1Ixxj3r+zlRpqnyo/D40lJjLiOOC9 H71vtUO0RhUV4ZAy53E56YIx9ayprf7TdHyWkR7dPkk3HYMHO0e5NFDCUsPS9ze9xqDjVlJ+n4kk moWktu9nNDLBdfalZZsf60gYIP14pz2jXcUpLyGQphC3IJA4H6VjU5edlYhOTuUrZ7vSrKJopSL8 RfvPLkJKMcgjNb8drq9/4dmh+zQ3P2iI3EdzLIpvI3jBLeWM8554wegxVX5JRS6nRQqci94//9T8 sLSW7uXEDSyeXEAxjJKkkeo9a3vtP+jlAgBjyjIDy/oa/rypShOo291qfjfM3J66GRcRG7jlgmEl vGIx5ZjbYck+vUdO1UkVoLja6yssajdK+WJ/Hv0rZUo4iEoz2X5kVYVOVSi+x0GpXNtH/ZrzSWqw /ZU81rYEsCP7/wDtViWtxd6tdJZGEJbM7bLyYCJVBOF571yqjCUEjmnVmloQ31hPHMILd5NlsxzL MgEko7j279KriO9tUeRUkiQnzI0CnaBnHy1vOlThRk0raGWL9tOcXJaW/wAj/9X8zojCsFtcJOft ZDLebhiRiMEMe3IJ468GrlrFpDwzm1il1DVbvAeXyuLUIdxwM8g9M/8A66/rjCU1Gk3Lq/10PxvC YR00pLzZzFxqrC62OW+fEaIiYi+XucVcW6t/tEYQeXcJbGQvjYFycFV55zwa7J0o25v66F15TUo0 7dWQx3awSl7p5LlXUoTIdoXOcdPTg9O1a9uzzyi4hl2tCMpg/P8A55pU6CdS9tbfkYU6kueVLsQT maEpHI8yGQ74wpYBj7kfjV1NKtLxraW2shaXEdvsnnjkJdmyS0me2eOBWGNop0npsVhK1WFZx6M/ /9b8zdS1iVL9NEEl1NDDGkkrhzFO2Sccg9Bg96rX99dKUt5Lu5kdpcphNqlMcgt3/wA81/U31O0u RdT8klXnWdSE9rW+9FzTVhsLR2ku4gEUtYwOx87JPzFfpmrGkW1g0d1L5UUNtK2+/IUIkoHzEP7H Bz+NeviqSjhJRtql/wAAjJcKlVim9Iu/3H9An/BJ63sPEVjq0Vhoi2Vw00OqRTnMFnZrkfLgjqVT H4n1r9BP+Cj+tXWn/BPUZrOVYJprRdiiPLTp5qq4DAfKABkt2Ar+X8I4S8Q4xl/P+rP33OedcGXp /wAq/JH8ani62stS1XxFqWnXNysupazJcG3LDYgcBZUOeRyCR2wa/Or47X2gR+IL2100Weo2sVuk VlrGpjfdRyxlfNUEADar7gPoPrX9F8fxjHhapCK6L/M/BuGKfsM4VR9T/9f+JjxjcvrE0lyjvZXp 1BvtkEaKI5ov4WX3P5VzMEiIpG0SYONrDJz9K56XuykuhtGMbKpHr+ljsbALFD9uikZtyYW1A2SI fb1z7V0/h2Rb6cpC2EmXd5MylHjxnJI69awxbfs5ry/VCqK6R27LILeHbITLHJ5jrOMRrtGBgj2p l1fRx2l9epaTX1z5WxIbZN9xKdw4j9/pXzEaclFyexnZPEWkuh9GeCNHmTTLS81q11W1GowqzXRt G320LICisex+pr6a8P6J4fstEsr6DXoGjdGkgtIRIZFK8ATswGCe4Ge3UV49aLU5HTgJzpynKP8A XQ//0P5AtM1C5jguYZrSOFJ5FkmMbbpJdufy65r2/QLZbvwvf3Ntqtrb/wBhxfaJbC6lzdPHIPmd M9V4xgZ5HbIz83JPk0RyxTfNc4fUdchuIILKLyi1wxSISrjbux849cYHH6VZ0W01u30q5trdpb2z 04ja12PIVAxA4bHI+bg81rFa2KjFdDiNQnGlaizrBMZpZ/LHlx+ZbxHucdMZ79KxNblnQfZFtmlc kiWG7gZEJYZzk4yOfXiu6OxpGKs7nk9/a3YSVIV8uKFcMEG2OPsPp6Vs6BrcdvaRFnWPYVtpWkjP lQjOMt3wfUcc12Un76Zq9ISP/9H+bD4Lz2tloQWa2jtIIrlY4LeRxLHcRPCpZv8AZHIwD/e+lfq5 /wAEzr2Hw/8AtH6Ba20NxDY3erSXFtbTbkBS5NvHcFGHb5VP/AvrX9iZevaeGcV/06/Q/J+H48vi JD/r5+p/c9fPDe+AZjp/mRadPpsdlaKis3khtqsdvoMt0r+G3/gpLYLa/HDULCKKwub3+2bwwrdo 63EEKuUmVZV75CEZ7H2r8X8CZW4jxUF5nv8AjpTTxuEn5v8AFf8AAPzW1SKC1KQpHtKthlJLsPxP JrISCBb43mCJCmxHA+U4B6+mBxX9fU9on4HOLT1LWpPAtpFc/aBkjfiM5bg9Mf4VjCW6jffFbcTx BpCyZkUduOvpWxm4K5//0v53dG1nVoLKe3tbbTr1i58xb20WeONW43BSD8w4wTWZJbXtvGLP/Ro7 XzfNMgj2KhfkgHAPU/nmv9JVBLc/kcr3FsYXwl4SHTEiw8qPx/AVHd/2sNNEjGW4jjAVIEG84BA6 dqFCz1JcrF2FLu2V9QCyJbNGluIIjmWJsZMjeo6/T8alR4IFtna8OoXssoENpdRgCXHLZYDGTVKK Wxm5Nqw+6uXR5JLfTfLeOXzJIy2fKQ/3fUcjmtyzaK7iiWZUhEhHzFsMOnOR2qmrOw1Oysf/0/51 b+3gF3vs9RjWO3IlaN2ADkNgqPXPp1AzVmGz+13Es7bl85RDKVfdEQAcjH9fev8ASlprRn8g8zvc R9Nt7PTZ7S0aVmZiCjymUuhJJBbOeO1UbxA+mWMFpFcQzR3iyGRpwyBgRx0+vrSLjPozro43SZo2 RYiU+bnfuKjnmuctzdC6u2lVTvlKWoc5UA9ST6/yp8rtc1UnEs2N/rVzeJbT3JFpbx/6N5DYhwDy D71di/tKDUnngykMmGuLl3Dmcg8KF6/j70ipS7H/1P594xZTa9NDcSE3Xmxvb3DxFoolYEEtjp2+ laGq2unzTJHa316sq2uyRC6yQeZn5iijHHAxnJr/AEoP5KUmrlbR7MWNpfq93fF5bcxJKMSO59Tn oO+OnFc9J/bNruNxM7pON0bLIBNIFOOmc9qDU3RqH2iJbny5IrgQqvmFAZSFHCn24pLxpNXga5hV IbiKPmKEYQOB+mTigyn8RkXmjyH7KwvFj1FFWSZPL3RuO4K5BGexrpLTVrO2nhsGMibjvZ9mTx1w f89KCD//1f59FWZrq+it5Vt7e6lWSTb8uW5wT/P61q3K3VxbSfbI4Z718JLOVDPtjOEwfUhV5r/S g/ktz7GVpumXrNdTTmIvdXBkUICJVUAAZH4VXbT7qS4G45RJvLds5Tg4xQZnWT6alrFG119nkeGT dEqYJwV/hP59KqaZaTizu9WRlEb3ZgS1CgPERnO70zTtoUpOJcumiktnklt0iV0COUXhsYGe/PSq M+nl1s7j7Q9wI9vlxt83kKB29P8A69FmPnZ//9b8AIbR4Lye4jn+RzlkmAAQd8ce2a0dINvcXkxK LJibKnALsQOMd6/0r5GfyaqiM7U5JnMgvbQz2s14ZCsC4dI0OVxjuMfjV6FoZ7WK8s0u8KwkgkeI xBk56g854pOLQc66leK+t769eA+XFNjbL5p2J+JNZ80L3k9zA/lJHbwmSRmPlxso42qR1J5xWcot qyNFJolN4t4La2htFt0s8MgTJ87jGOTk9a3J7dl062WC5QyOrPcwtEWkgO7jjpyB0FKMLBJ3Z//X /Aq4RLF4Y7pw9vdxhlZAQQejBh27VstaxSwFYNzbVyAvGAB6Cv8ASGSs7H8oLocbfyW9iREXMgck eUqlmjIPer8f2q5srC0hRd0V15sRJITDEZBGPQH6+3WkdUNy9r9jNqbxWVhaPHeWzn7ZZ2YKpKwX hmXPpnoe1UbDTr7TIYHurTKTSlTGRuKOemR/npQamlc3FxO8dtc2kMLwOdpQHZIv8JYf3hWfJd6m 6TW8aAEgrbyZyoP+HSpUEiotLc//0PwNtrfVBc29rNIJpCFe5ugvmKM4OAB+Xt6Vva0LhtOkNo8c 0ls8aTqrjzIEyMnH0r/SC2m2h/L5lwxWt3DAZCjhSUYkAuCOxH+NM8Uyto+lJK0sc22NQxaUbkjP YKOnGevqKLWM57k+hDTjpsMljZW9sZWFwZIlAD8DgjoeepNZ2ppDZHz3MrNdT422sJIi7/dUcDg0 WMmtLAbi0YO8UrSMq8pKpjZj75qJ76/eGEvayQKzHypFXcpA7/Sr5LRdzNJWP//R/APLPJDJPJIo icPuRsb8DkN7USXkF9HLZSSRWdlHP5kW6MuSx4L8DgfWv9Hb+8/I/lSnsYsj3lrc2phuxNb2jsYj GcxzA5+Ug9jknFWtSu7iZf8Aj0EavFi6h3b9xHYeoPvUSbe5olfY09Itkij8+5DQBogyx45X2b0r S2PeXKWcMUk0RHmCONdxOOd36VJpBaFeW2mjgDykxStysbj5k9Misy3srvV7eHSLq6jaWyna+S5U iGaQjoh9vYU0rmjfLT+Z/9L8B4r28sYYke0lkcXBjvH37YlXBwVbrk46e9ZWmWcTT3s9zA01uLj7 Vbjr5D5yDn8K/wBG0m6aP5blpNFjVdVlN3FE0CSW2Bsb+POe/tTLW5e5uQkkWEVgm3HX6U4p2Yub VsW/1eS3UCygRo1uPIllmz5fBwQvvU7atPCwgtpbdvtkDIgWAu6HHOCRxx6fnU8kibszU1KS2Nrb 30Sm4ljZFXJjZ9mNzD6ZH51JcXcjK0yrG5UYCnh2pqLV7lRlyqx//9P+ehrgzRlli2uF8yYIMsg6 ZJFXorqwEFvbwQvDLLCXYyoQzEEdF7cEenWv9GbM/l9Pqi09uD5Xl3NvYJK6ieaaISLx7ehqna6R qCao8drFb32n6g2ZZraTGWXp8noR6UrW0A3PEcV7eW1pYtbRxLa/uvKRAjSqOxPfJ9a4+50v+0bl GgLW8kbqjxxru2heCMH6UCTudXY6fomnQzSRzXg1mRv3sTwg2UkQGFwc/e57f0rNeeSOVlnBEDrj IGNxoM5Sdz//1P55RdF5ZIvJeBFztJGWYdjW/onlWcam+n+1OD+7kcbcE5OAK/0Yt0P5XNmVHuLu F7dS73MixwxxrvaRiQo471X1aC40q4EGr/LqshIjgi2x7cAHdgdsY6fnWLg0NNrYzbWzWQtOQFYz AvMVydzHuf8APSszU9SvdL1We3sHhvHhiME0BQSxhiR8+evTpik01uawd1qb+jT3UhinCvCytu+7 gg9Sfw61Wvp4Zpbq1tW3yQYczbcB25yvP+eRUtJ6Mo//1f5521G7ige3RDNI2cRsccnrz2rSsor4 RGNLdhI0XnSJD+82dNxyOwz1r/RBK2iP5fH+THaXOmJFcGJhKRezMASEZSMfnim29wdS1QWFmC4W cRl92zc2emc1SjcmV1axo32m3Bmn3SPaNFhGMf8ArSFPI/pWRLJE828G5V1YII3hIaUdzjH6+9El Z2KNAWNvOZnijNvEzF0hUHj8arpE7SF7JFjiRTFP50O7IAxwT+Jz71ny+9c7cP8AF8j/1v5/YY7q G3nkhuWYzMV8qJeQR0Ofz4rW0N702KNqQEbTkxJJKoVpAODx+XP1r/Qlqx/NM/iZmanayJeLb2Uk MgRy8rKwO4AHhf8APaq0Ueow3MM1jMYpY5Q07SRCTKjOVGeBWUlo2SaFzNPe4iaIxuH2O2NqqT0/ Onxyx6HNN9oVyFXyp1JO0kYPOPSswM+WFn8mSKOP7NMTIhiHyr17dqxz9ptpZWgJAlky4UcKQOp/ KgD/1/57Y2uHtFhc7rieQ/MFOD3A/lVwfZBZxJMh85ZQXMZJG/t/Kv8AQCye5/NkOo+80uexmg1W xuZJ5poQrWcmWiGCcfL/AJ61dezt3l829iNrcSxi4ns0/diEkcnHUD0ot2JcbM5uSC3S6me3MzIW C+ZcPuLn0Xnge1TS3jrsgCsQ/wAhbGcHPGBTirsmzTsaUcrwomAZrj7kYJwecVhXdhqJvX1CScSr EB5oRt8a88KB69j9K0UEncqmtT//0P5/tPEOpQ3L7Vi+bYqB/njPJ6elQR3qWN6Lbyweuf73HtX+ g0o3Wh/N1tbkpuxc3HmWcbOkRzcxBDjHQknp1IpsdvqDF5DJthDFkyArKM/dH50uRDMQyRi/d55p JDIojKsuNuD0J/z1ravPIjsk8vc8886xICPlVedxP5Vaj2RcGluTaWbWO+kt9Suja7VCxpkEPjqR 9c/oKryNHpl9O09gmoWpBa3ad/KZQ38XB4IH4UJdkKTuz//R/nbacTykQRvNuySFQskWPVsYzWpY JcXsLWUt19kSNzL+8IIIGPlUepr/AEJs0fzgnbYq6lCtvqSW4yhjVS2F2sMg7c/X+tTXsqz2q/Z1 ke5VvLMRIUHngn8OazcEzZO6uFkBBMI5naMuCqlYy6s2M49ulX51gMDy+YCGBSSNuAMdz/ntWUoJ OzNOd2sZMU4E2ICPKiUNIynIUHpSzTwz6lbRQIZ5OgkVMLGSvJ6ccVDgugc7P//S/nuu0nYG22xA ykB55yyrEMjOABknrxVWX7TZ7reG682CE7lZVPzA9Rg81/fihrqfz1Op5lG/vJNJcXM0TSRzbY4i gy0bH6VJBeXO1mUFt/zLxgCq5ImEpu7LNtCbqGS3nl/0mZyU3kKi/j7VJaxzWFnJbTmB388vujHz Y6LzTSUdEZt66kUssVjuch2LoJMJy2PWq91Kk0BvBvkDIFjVl2jj8Krld7FwbvY//9P+b+7jlZPt lqrGQxCGRC5w4BJ6dO9aWn27pD9qa1HzRlWi38g45IwffNf6A2aP53Hkvd27xbDCi8RyNFgg56Go ns5WtDEzmUoAsQ6FfYCkNNrYt/ZHjto45RiWNcHdz+FUPsQnQ71+cH72Pu0Fqfcma3SZYLOJWV0Q iWXdlZeeMD17VHZ2k1neGeT/AFWNixlO+etApSvoj//U/nPkimurj5IlkjjPmSIDhgB3prweRIyy naZV/cqRgj8O9f6AH87mPqDyW9vCLmUsEkO1ioXcT2/TpUSRXN6gn01YVYY80TSC3O3pwD1PSgDT SC7EAlhES3EWDJuHmRHHXI71lmS6b7TAWUShw8MkiYRT6fSiwFs2Wpoq3byK23rGej9Og9K2hM08 Vqrg291CRMoiyqsOm0noRz3otfYD/9X+c+8XWri4NxHdT2FsbbyniQ5F1jowznHfp1/CueudQvLU 5WGOYEEyNITktjA+Udf/AK1f6ApNux/PF3blK+kXF9JpZN+kSstxJI833cqW+X8AOBU17Cs32ZoI lYpzubnB/wAmizTsILfTokk+2va2/wBsCGMyFQzBTxjPXiqWqeY0ipZQqzFd0xUfOoXn+lDTWhSd ncp27SSHzJhhI2CEoCdowOSO1bMc1s0LSQkSquQHRgeRnjPSnKNiufsf/9b+bK0txeW8kTbkkchW Az5Y47EjmsHUdPu7DUv7JGFu4wkpQ8koccn9a/0FUFbU/nc0Zo0WW5NwZPNjjGC0ZAc46D6f0qnY y3SJvKOyqCwJXarden5VXKi1PSxdfZeKPLb97IvCgdPrUNgbq1d/sMpIZfLkLpjPPzcfgadhRdma GpavDZiyW4R082cI8qAsqHBIDY6Z6VoPOXt3Qx7hJgqzdV+lZyppmsWr3W5//9f+cDdMRCGjjWFV +d2OXcjGMD86uWN8Vmuow8RhnURShMcEHPbiv9BeRWP5/JpWQP5YIK549DUmq6zc2Nvb20tlBfWs jAL5spD2rAjBCjkg/XjArIDmxc3LNMpOyKbooGPL+hqrLcPbPbwW7yhjzcSumVlwcbR+GKhQtK47 s0ljgbmdQDMMbiuTkdMVj6ej2920Eaf6TdufIQAlCc8D1z0/KqtqJaNvuf/Q/ngutLNpaCLUIfIv BEHdCD8xK9PpWTHpF4qjUGtW8jG3zdhwcEnGcdPxr+/7an8/9bo5m7v5hetClvlZHLboz+6jHpn1 qPdulQFsIG3bT0c+9Md2a43XzxQxbLdtwCyMdqemT7Vi38JiszaXPlyzrOSsijrhiR9aLJ7it0L0 GpXos49weQxLsDP1x25/KrFpYvdNDLIUgQnfOMfMwx0H44qJq6JirI//0f51NL2vdywQSPHb23Mh mALyKcgY/Sq7yOb6f9/IsaDy1Zhuj4zziv73cfeuz+fnsy5aQmNnDy7o5WIaVBjcDnnFfpD+wJ+2 j8R/2c/iLp+hwePL+P4eX8sdve2WrSK+m6YzMqh0UjO0LlWZSPlcg54I+c4hyelnOWVsvrK/NF29 Vt/Xa57GS4yWBzCliL2Slr6dfwP6w/EXxx/Zk+NHgizPjHxp8N5oYl8+ZNQ1qJUUhOTndyASW4JG R+fGfDHWv2N/Bmotc+D/ABx8M7G6tF82FbbX7eQTO2ewYAnjjrX81f2Pm1CjPL4p8qe2p+k1s7w+ FxSnSWt9WvI/If8A4KX/APBRPxDp+v3XgT4TeLLDUoUhmto7LTrsahYyZClJHGMKVYyAfMRhT65H 87eqa7rOoXk+qa9qTavqN3KbnUZ5wPOup3++7YwOOAAAMAV+68A5IspyGEZxtUlq/wCvU/Lcxxdb M86r5lW2cnGH+BN206f13P/S/nbkliIjW4l2CQ7416dATV+xisb+SGaM5ljzGWYYKHJ4+nQ1/b9N 2hbzf5s/EKivL5GPfaY8OqytNI02G3BmXaQD2ArZmaH7BctLFcQytGEt9wC7v9o89MZq5NK68jKM HczLaW4cYkIeEKP3jn581qxzSRrGUwE6A5yay50b8j2Kl7eXKzQw2ciJKzgzO5wVTvj3rQMl4k6N CgdQys0xOFUE85Faqaav5GqptRsf/9P8GpYode8u0zGxK/NyEzxyAelUTaW9kH02GRyYwEK4w6eo B7/Wv7ebWh+MqDUbFF7VVlhC8MsgO8jLVFqMkYne2BVZYW/1g5P5f561hOV15m6i90XN1rcR28oY sIVBbdwGI65oguoXd4rf53dshD0H+cVgIngja4naF9qzIhYKpyDgZIqGa+a4V7Ty5bd7SThjFtD/ APAu/SonsZyk07I//9T8AYBIiOJWP3t5J6tV+EM4DZLR/wAQNf2Kla5+LsugPCS8agJ6kYFVvtH2 mYRofmU9e9Eo32MrO6JmuVt5khlASQcAMOQavWxguQ5dnkmQ7Q7DAI9qysrnRF9yx9ldkYWbyLNE PMcquQFHX+X61K6M8ERG2dx823g5I9aLdCmkz//V/D5IrmRA0skaBOAqIEA+p70ob7POjbkLgcdG zX9fxilPyPyHdeg+e0mu94YrG5+aIrwmO2aqRLqlvDIJrgSlGABjUCMrngY/rWkuW3Kbwh0LUl3B 9juZJJjby7NiqF+9nOcH8abpsKw24MbYiI4yfvk9653B7LY05UmzWt7tUJg3sUUZGRwCcVH5bRRT OsLXhT538o4EYzgZz+HetkkocpLV5M//1vxJju0jO6X5OO/QHpipp4TIPPBLDbuAHQCv6/jGyZ+X LRJEQikaCIxsy4flM8MT/n9KtReXJbsqSqGR9rgMOvpQoRbIbsmvMnbyY7c28jP9pI3IijGAe9UN M2afMwZlHmnG+U5c9TgGlUgkZcyvY2r9BdIkrPhhw4VcZAwATUUdyYQoteAvyM3XH1rEd7aH/9f8 ebJ9IdJY7xDLqbuDbTOMxQpghwOwJ+XrVldMsbdi64Mh524zxX9bSinufkvtHHRGK1zfJdlrWFn8 uTCIR8u0fT2qzrOrNrMxvjZW9qoCxSLaowDsvHIJPoKx6WKu2YZvZRNHC0IAzkPzvxWvdXUr28T2 07DbxIhG1hjpimrX1NIydrEsWp3FraKojBubpCYZGG5sjgsait3FzIsc07vcKR54bIUHGeD3pyST 0DmltY//0Px8ubeNj5fzJs4ZlbG+qSJ5jvCoyLX5kGODn0/IV/WB+Vxk72Y2SGCcKLmMlS2NrDjI qe6nZRa29lbK4DfvpHfYiLx09aDQfqpjsvswlBLSRedCoPBzxxVXRJI18+4dpfOkYqI2GEVfagTW li2fsd1dobpPJih/eMyLlm288e5xipLG+DyOIvnhb7iFcE9eaXXcErxsf//R/IyOctuLKFT7u0cV lTXLrOEXmMNlh6gV/Vzkkz8qcH0JJbldRC2twzxBJB9lUDIJBycD6ZrZnijdLedAiPbRGKTcQH25 HTuaHZ6EGbOLWOVLqOTdEI9s+4Z2kc5FZAvFcykvKsZcsrt0xUcqSYG/agNCpBV4nTr1J7VDE1q+ 4W8628gYjygSJJCDg4+lXFq2hg99T//S/I1mdEkedh+7jyqgFi/+fSq1hG8vmltzHbvbKlcLX9X6 W1Px/bYij1GOCaSCINtJOQBUy2rNvuSCExkN0xWeii4kyd0yBb2+eSCALH9nSYsxPDsPet0TmS6t zdSukUZ+9GMsg9q2UVs+x0K7irEt1qDJ+6sUin8+ULPcXA+eNBydvv7VdnurSaC3tpDtYyBHuT9x VOByKRR//9P8mdQ0vyZo4oUWQROTJMkgZSMcbfXOaozGOGZXkgEU23akrDHy/Wv6uaSuz8nNOzsr +Rp5Y7t2QxZaIDiNe7fyFU0t5IJZZoJwhI/fkjeCMY6dqz0UGy6PvJsn2217tikAAXqx4z+NJDJd WMk0oeNreN9qhfvj61m5LVFRi+a5dUSX0Us0EjrHKNsm043n0xUD20UFtHFKGckEO2efqazk7s0a sf/U/KGN4VT5+SrYiZ+M+makMxa0lhlRBJO4jikVtwweCAPfiv6g02Py8Z5UlhCLWaMlPLG3nc4H bvUSwQyLHLJ+5aJSsbr8hAPOD6/jWsEt0YyVmWBcwPB5YzIVyNwH61FHewLD5ECF5MlcsMkZPOKi TuxJN6Iq3V3PFam1BljjZ98iEbdzDoTWvo8V1MiSLIHCrlvNXZtA9PWpEf/V/K61hkMl1JcztMHu /LhtiMrGp6n6f41tTFbAeXEybSvyqp4Ar+oD8oaa3MhVurmUbLmFETLsZm8vp1wf6VY065d5dtzG drS7FkUZx2yaxla+gcrtc0b3SxaIkiEurHzSQmAcmubeVft8YzsgZMMU5OemMUlFvQR0unQaSIWs tUWD7LcT+cZZ1/1Bx1UjpVnSzBfxyWul2EcrQl4UMh56EBl569xWsE0rMD//1vzHs2NtJi9YJcIC rfJuAPTGD/WqV00NtOJIGd8LtZdvyknpjvx049TX9SctrNH5Mmm7I0BeTO8EUyJAxUYdkBU5xgni ovMMLtHPIm5Dy8R/dvjuK1XYTkk7FNtUw8iMv7kc5dePrn8KluJ5ltDLFECgXOFHJ96L6WKKls7S WscMpNvcFTKHKkpJ3C+x/wAasGKFliiY7JUO4kDDH8aQH//X/M6wurhoZbiK3kFvbNsExQ7SR3yP eltCl1fS3M5c+aDvAbDH2XP0r+qLH5DLcrCQJdw3Kp5RibYqRwgs4B/i45616Ifh9fXPhx/GWm6z pDW6xu1zZTN5t1AFO0rs6Bj6Ng88A8VU7qmvU5/tnlEouvNiiRY2ttx8+QPtaPA447g9KtzxxtsE bYXGGI65rVaoc1aTRatXtAUJkSOO3cLMdw3tn0H+e1S3upQ27zSiZrgOmLe3Zd5GflB457g5quV7 jg9LH//Q/NFbfUp9IQ3oRCflkMeQFBz909e/60xfsypBpatIYfJ3bd25kUYDEZPuDX9YH4+U9mqW rp5TWl7ZQzFVW5XyZYIznlMd8/1rdgu57jbbho27+XHIGKj1x24oAT7Z5aXVnBBNPPIwiQREITkj JOePf8Kie4tbS3ltb3ToJ5sAQO5yknPzbh7dK1jFrViauiO21xLW6M0el281v9nMZjUlTAeACme/ vSXJGsKJQkkIkOJGkOHjA6DI/wA4qnFGLTR//9H85NJ091TznulgSOT92GQt5uAc9u3FYepmRruW SMnbK+6ZiPvc5OK/rflj2PxCTd9SO0ispDcy2kcskauJCXmIRSow2R0z9K2Gliksm3wJNEXBkg27 mTaRgkfj19jS5IiKN3dWmxrmNPLu3YKluDujRQDnn6n/ADxVzSrS6v8Ay5budbdGVltEX94XYchc dgTxn+dZyjyuwF5tNea8a0balxFxJJjcsYBAOSOKW7jbTIzLHGPlHltMV+STJ6/rxUjTsf/S/Mhp ZJC8g8xjjKr059quobVYba9uZGikkTy5IZRzGSeOPfiv64S0sfi5HpBvIdZS7tLqS0mt599rKmGV uejL3BHBHvW1dPC1zcCXC3MkheZAuxSzEk8duaqKl0Ant4rNJIi0kSpGhbh9pVuQARVHWriCBEaJ JJLsEukUbABx0/z9a0UWt2TZc1jFUpcoGFqbeSRczFm+bPJ5+n9Kt29/pViJZlHzqBFKZFyGccfl zVqMuV6i5V2P/9P81ktbgzJdagLW5guG8+C1t8ZCYGA208ZqtFKzI8qRGJVJReyqFOBg/hX9g01N Suz8RpxvVaLzanbfZFjkt5bvyhukUoHwQc5A9uvNQwLb+I4I57cy6dcWlxvAdALSZFHGO+488Vvb lfMelKqrwiun6GrKWlREs4pLj7Ov+mvj5IgM/N9On51z8F6737RwMskSNhwB932+tEWlVi2c+Ory 5eSJ0cWomCNim+FmON+N3T2rIS4vXcKbtnbeWV36gZzjH+etPETbvydzojiJcsYI/9T8ybhLj7RL q16ga5zttwIlEZKYA4AxzxWi2nSXs0mqm6itpb0eTPYQ/u1xgHOz0/qK/siVScoRsfkNayquLsyO ESwQPZiV1t1l3CNDtGR3H1rXSKK4umtp8xkWwMbxoHik4HDHPH19TXRipucU0b+0bpcjOcv4BZ3M LCSYCOXLQ9IivGAT/StiK/Eg2FpHgjBMMbvnyvp+PPFeZCUrs+fjb2zRJLZxyWp8u/Bu5wzhJctt 9j6VzrP4isZ4ZIk2Q22JDI2dp3dOnY1dSMZr3up04idSGGvT3uj/1fzqnjF5ZPPLLsuXU48kcISO AOeP/rVlWUoeOUy3DSTwR7EVz8yAHnH6/nX9dSp/upQS16H4nzzj56FqyurKCzvr15WZwwYBhlcL kMfwAqMavZ3+9eJI0VWaEZiE4I/hPapjF00lItzUuTl8/wCvwJbe6tV02a0a3kjfZixyf9Q2RkZ7 gj9cVYjtLOHT7UwK0l3ki4up5NpQN1VfbgflVySjDU54yvVsjKulsrK3ijt4dpklaa7mj/eSTsTn knoMZGKUbdUt7rZKUkQKtvEo2wxoODzzz7V14aKVNS6XX5l0pXrSgtz/1vzISFbdI4HujGYzu3SI dpGecH86xpNolnS0dtksrSrv+/KRxz6duK/tRQetj8HjVUalnewumXAtrWR7gEXf2pi26TeoBxgD P+fao7zU7pblGhgdbViMyRAshIPI9q6bKNPle5kq7lV93v8A5nQRXMdnd21yILe5XaJStzHvj3EZ wR7f0q1rGoWrOG09njdlE09r5YWCMnOQhzyPyrzppKVmd9Zc3vIwluUuSDsCFuHIHLE960WuZbPy bcSmOJf9XJuIKnpmislJxS3KSeiZ/9f8wENrpCR30n+kxNdYv5Hf5sN0VcdMnip9M061vre5v4rp LedneVIpXK7lUZUBjwT2xX9hOlJ3aR+M2RSg+03UN55aF5baTaY2+VpD6jPYetT2eoTRTuJ7IShI DHhlBjcEEdfUda0pJwpStuW6jVJPfYztQ0kahZ2zo9zCjZEsYIVgQeoP+e9Onkt4LaKEbzJEQq9u g7/pWcaacUedMuWk13fzLALWQkx5SUAeXke5PXimS3E5c284k2W4MirgsuSe35dqqvRfs5QNcTiV NRkl0/yP/9D8skv7OSG5VvtX9qXkhMCJF+6LgdHPYEDt0p66TfpbiWaWBUuYjG5t5g8luwPIOOh4 r+v8PRm6Kj2d/udz8aoYtThHtqiUQBbhoNqNCsQeOWUCNweueuOlVYnt7u+NrLPHHEmUM0Q3qSM9 D3recXpFiqVV7VNDNZtIjFbKkpCxShsRtgyEZ+97e1FnPd28ywxDZ5o5kY4VR7100k41FzbWMI1E 68mjfaeaYxRSSgvZKfNVAGTnnr6ZqvBqz25lEkpwjFg+3HB7fQcVGJ5J05RRqpqNSyP/0fzRe7t7 q9SZI4Z7mQqkszttnSMDj8PY+lNv4Z0u4pIkF1FC4bbs2+YueRX9dQpv2up+OOduYzwVk1K8EVvH PbiNhaGQEm3L9VA65Xpn2rU0HT7u4dbIxmG1N3HPcxzxCRJAjBh8p6j68c1146Vqc29rHoZUpykm urt+KP6Sf+CVUNxceHtYNoHuLLWNZhszIVAaCOARqVGP4Q2Tz/er6i/4KRX8+nfC3xBaxWxlgsbA WFtp5y9w7OjsTH/vHb+FfyphEqniLGUdvaX/ABZ+85glDhHll/Jb8D+NXx5qLNrb65p8VzYXV1bH zrRiq2kkrZR3aPuV2kA9x2r8zvjmsml61faO1krKllFd2xiACzNLksYwccBuPwNf0txyoT4UqSl0 X6H8+8MKc+IZQn8P/Dn/0v4g9UXU4dWvTcSLKA48vcoQRIAAEOeeO9P06HZcvM8UMqFcbicoSe4H tXPJp1Hy7G8aMqK5JHQQ7JpoJfK8o2qmJGH3Tk5z6Z7fhXX6BOukbtRsd1y15IbG+aaFH+zL1+UY JAzjnv61xYqahB83XT+vuM2222uh3dj9punnh26fM0ilovtJEcUoxwgJOMntXPWkXiDQLae3u7gS t9oe5WCNI5I4lLfdVzz0AFeLGaUH2HirNwfU/QLwxqt/qHhyyhlmElq9olx5KMJQ+0bAzHk54/UV o2yXdmhSa3X7PJKHSMjjb7/zrw6tZKq79yqLUm4Loj//0/49murawma3edTLcJshjkG6TI5LL+Fd H4WlsdQM1nNBJe30+nOkd5JmAx8gbcADr1A6cV4EP4aMIfBL1LkOlRpdW3mLIZtOGFZl3NgDac+9 dU2pteRfYdMhnV0b7OwZXRrok5UlehAyAMZHFKL9+xUdmjg9dtr27vhpupzf2Lbwossz2sokmkJX s38LHjj+Vcp4kv8A7NZxQQC71F7ULbw3kgbKp0+cn16nHeu+OyBP3WeeamZ2jeblIZEBEQJJYjrk VQ8OzzG+aCWwM8B2+eTb+ZEVLcA+nI/Ku+khNvkaP//U/m5+E0Pn+EbeGVNNjbUriMm6jm3DQ/KD BftHHDSDoo7J0NfqB+wrqtvoX7QPgu/vbqO6ubS/Ol2OnWyh3v8AfH5vmrz0zHtJx12n6/2DlCc/ DOMU9fYv8j8ryK0PEKlOW3tP1P7sfCdrs+HOlxm7kVbLSEvMXi9VYGV0Yd8bv0r+K3/gp9pKQftA ahe3clpaR6ZeapPabzsa9FzPbbcZ67Vctz2r8V8EJKHFmIj/AIj6Xx0i1PCz8/0Py31TTLUzC9tf Ou7yRGM8ExxAoHOVPPb2rz1ze315JJbtEscjeW9vEARFtHZe3168V/Y1OKsfzpUqJM0/MhttOht7 u2iF87FBMwylsoxgAdMnvWdpl1Cslwiz+e0UWx3Yb8ZPAB6Z47Vot9TGVROVmf/V/ncW9ttJhnFr s+1XOEZnUNhc5/pVp4765iWUBrh540aaCOFVEa7hyo+mMkc81/pQfx/7TTcsxvpc9tPBBamG5f5x LncAFGMYqnZOQj2z/dclSem49v6U0ruwuZN2HanPdW1rJb2dzGHii2PGYNyXIYdCcDlea5zT4bV/ Kfzle5QhiHG0K/pRbWwS2Zf1vTrO3RLg3MhvJRslkSQ+TGrFcIv1xzgf41tKP7MsbJJLQvOFVyyn c0yPgjIPTrz/ACrWUbmcZWjY/9b+d8WXha6FzHHpd/BcSs0oK3qPb5bl8oY+mSehFZcOq2+g2vkX 8YhiubpY4SHOVBYqAuOMnjr6V/pdKNz+OeazuzXg1Szvr9bPT5InaTAlLsR5Qxyar3lj5cgacrGq TYg2Pl5OxyvpzTSsrGiknoaV9qLabY+Wj+ZLOgEIZCFJ7/N7elZuyS50h/InK3aTJIACD8u/5gw+ mf8AGh6LU6IO61NKAWcEPlvPh40V5SAVKZ7fnWnczzyy2llpwjuZWKqsMLCQ4IzkkH8+9ZSaexu4 +7Y//9f+fyW80+zur2GR91+sIWaJUyif7zdqyFNhbzyTODEki7v3eXwev6+1f6UH8mxikad3PLZ2 dnJAzTW91JgRsGE0ZC55Hof6VyL3Ul06CcZuI5mLORhlQj5VA7YoNFFtXNbSmluftKpLujt22qG+ 8zDqp+mR1rf06MStE2YbdxNu6hFcjHDZ47CldXsYTWol/OFuJrhL2OzvEjYA+WJo7jg4jxjHPauf urmS7tIWjiUXIcp9qUfLIQBxjtjr170yD//Q/nsivbNntNPmt5PtCwG6e+QnYWDACM479eD29auX /iCG2VEiRneUiGKONN0sjdB9M1/pQfyOdAlxcKlrcizW2lnsVtrpUcSorAHLE+p4Bx3rJsrwm6lt lG1I33ODwGPrigC3e6jG0zqbd2AjAWXGFU5zj/PrVnTp7mCBzKYYLW4mErh127/eqUW1dAWNTjtr mdbUyTW1jsEss6AYVsdlz05zWFe6vp2jQ/uLkXduVH71V3SHtjHrVKD6kuSWh//R/Bm9jmigghub eICWBZ1P3ZisihlB/Ajg81xljd21o7iSPYI5mkSRcqw5xjH51/pgfyNdPY7LSdSsr7zlhm3ug4cj aozwVP8AnpWs+oSlBp93eJBZgCMpEscUhXdn5WxknPc5qZL3WSppuxQk0LQPMSSGS4Z+Xllnkyzn sWI6/SsPUxA8PkeaiSRvvYR8CUA5AY/lWJqpNaFaWUSx2cunK8jOwikMMRIhP1HpjrWtpcU+nIbm 8upZPPcswuP3kigenfFBoppux//S/n/8QX0U1nObB5JryaMrp6eViGF+cM3+FOe31SLR9PYXCHUm iiDCBsPK4KiQKCMdm49DX+kUviZ/JzaW5eSzs7xr436SWl3Zxo0XyZE4bqZCenToPSrwudOto1lT 5JIogkqEjYcH7w9KVnextCWlmZg1L7Pf+bZyyS3lyxcfvCrYI6A/4Vah1PUL1JY9QhCyq5X9z1Xk j8/etJRvsaJtbGrc20MFzEfLuPsuwFJ5QNznHIP48/SqumJP5979psXFuvFlKq/un4GefUenuKFB W1KjK2jP/9P8JUuRazLKEJI+eRc4OB2Ncws8dxfXOoTWhs2u59wDtxOBwOM9ulf6T7I/l5ST2Eu4 FhklvbWREWQhZo4zjJ6A4/TIq9Fp8d2iSXckU32gi1aKX778E4C9wOaTaSuRPoSSrPpUx0xNMguL JoVNldl2T7JKG5OBx09e/NWpFuRNJL5yPHFACWHAzjkVLkrWsZlmK0tRaRa3qcEX2ZGKGaTiMY9c fhSXCxSCOO1UPAvPDZCqe/tTk7xCx//U/BBLVEvpbRZTcpPgRRIu5VKjLY7/AP6qsXMFjp8NtJcW cBtZyYY9sn72cg46ZJ/HgcV/o6vjZ/KcXaLaMe/s7dDJePDNBbwxeZDZQr5jAgcZ5z0qzp8+n3On iZjHIjETZCH7Rblc/IwPT1I+lKfRFRlfQlt9SttSkZPKk2yMUzJEUBx9e1WYJ72zv5xbyxJ5MHlm JVGcHsT+A/KszRScdBlvDcTB5L55HaWQ7GK7fLGTgAe1YN3pqi4v1sHupL60sluFLA+W2WAwe2T1 x9K0a5b27CnL3Vfuf//V/n9tLPWNTgnmkjEdrZhUklLffdh0x+FQ6TeR4lR2CtD806Fso4zgY9T7 V/pBSV6KP5VnP96kh93Dc3eoCa2t4xaREeTIOUJwCc9u/ArYayk0vE99GqpNHiCNeJnY8ZI9OlFr BfVpmNf6ZPdWbTOiwx2z/aH2/L8mRgle55HTPrS/2awa0lhldZYWEgEeAWHcfjQTz+RV1hVlu7K8 mgC39rxDA4CuFwASAPUYz+FXrizuIhFO1ja3EF7GWik+2ESoR1OwdweOTQVze7dn/9b+fCyLwMka t5E7q0c0S/MJMHPJPpjp7Ve1Hybm9srhgILmKD7KoQ7fOHGWYdz8v5V/pAfyyptKyGXwg8oNdybY lGCH4ViePzqppDOZYG026ltksZs7e8oA5z7HNJpPcSm9dTc1K4ktYRLDN9qM2dyFW3W7f3RkcgY7 VjaLNeiKbXLOOZbSYGGS9WImF89fmxwee/NFl1M/aLY045LaWCWea4VSpGOcs30FNmhsLyMf8TGB THEXkt5WMUnoNv5dqLInndz/1/57AYrfUY0LG6CxhUlY+YqjHAx04xSXOnAETx3VzIRcec0TuRHG e20dl9q/0clDsfylzsvxteQKksM8kc0XzRvC3K561LGXkna4uzvIUgvcZMw3dfmPPPB/CszValCx uZLSWXTJLx5Y5nMoOAQvPyg/yq8bqC0vI4ltsy3Hy3FwoHAA4ye/Sk1dWKi2mTal4lj00Ro3mMsi keekZZbZRzk1iEmREnt2Lrd4kE443Bud361Dh2Nj/9D+fCK2fT7lRcxmeKdd32g8uvrgV0kU0H9n mSCeS3kkURRqwKvMpznPft0PXNf6Kcmh/L4lhYWU8bGeEC4mx5siEknbx/L9KhvLCSyvs2/lx274 8iR/kbI6g/jirSsrITt1KiSXH2xY5jJ5xkG7cS28egzV6+mWORLiNdskDghGTKvj60pRuzSCT3Es pZrppZmbaHb5I9oXbVS4tdZmEsFhfy2f2v8AcMkUCyiUZBGc8A5rOUbHTSdpn//R/n8sL5rR5rWR t95ZsILiCWIxSMwAO4rjv7etatpcTX1vI2omFY7Pc9u6cOuSSFCfj1zX+hbWisfzXVVqjRh3kgiZ L63iZpbdi0mRkOvA+Ueo5zVo+JNM1cMbCVi0KCC7lih8qPzNuSAehI4zioMxk0s8sCRoC5Ugh+8h HQt70zzr22Z4dV8m+e6AdJZG3SoD1Bx1I96nliA2F7hQ0KPGbdSSiKPnX/OKqvL9hZr64ilmDIYz bsu1GIzggHHPP6U7LYD/0v5+NMtry6snuJ7q2V5pG8uzSFluIlP3fn6cCqh0M6eCHuJlYkuokyTK fav9BuWPY/mhNx2JrObVGt3E0jRXilktlP7wygH5SPTimTXN/ds0chUvIAl1PIf3jKDyM9atRdtE Dd3ct3NvGIn8iISJCoZSwyA3qfxrNjujYlprxRKgZdogXcwBwOnt3+lFnewrrYjeK31C9ju7WWVR Cx45XH1FS6ZomnG5uZrnVbuNvO82OCAh+Tz8wPOM9Rmnyy7DT5T/0/52prS4iu/NsJwLlpjI6OxA l7Gt3UIi9p57xJFe7VjfyyWIGQCQfzNf6FOLR/NvMh+kBLUPtulkjZdhRB/rBkHLfl0q9LqFnqiy 2ul3B+0Wi4diAFLjOVx6UKDY20tzCaYI+25iBcL87EY2/wC1VmF/tEd3bONgjAMUkfzscjIPPStV FRGtVcyZobt7YRq8Rut+AzDl1GehPQ9KvvFcExxXLhgIhudmyeg4pkydkf/U/nztMWcM8VpHGwmO 5yByp4yRUJt0ubu2Z32BMK/GMcjJx+Ar/RA/mpTfUvXJQX0sTtEYvMAtriU4LgcAsT0rDvrmeC4u XCRGSEjatvh0k/EcYqXFM0hPsWpdfaxa2ktY42lkjOVYB9pI7jt1/So5GtpodsZkWS7bzZ4iSUyO uP8A61Zyg0a8+nmMjs5YELwW7La7ts02w7GPoT/SrkPkxTrNEYx5f3mB+6cdP5VnyRJ52f/V/nou 9Ztbi6W2mybkgyRARkgqvGQcY7+tZl5cQt8sbyrIi72ljyCik45PTv3r/QXkVz+cJSvuWZniu7Xy ZlIgQDEsmNzdMEU+3doLaFEiWWFGPzH7wHr+n86fLG1iOZE0NtDPmcTOku7JVh8qgYqhfxBpo3Ly +WzBZPJl2M3tS5NSHK8kx97pkdpH9ptJLhpW2ARSnzECD72fwzUTz263FnYy3oa3eMzRw7dm3puB 9Dn19as2Ts7n/9b+dZIrQuhin8+MMfNto2CuvYHP1/lVayvJze3FmgZ47dlYsyn+IdPSv9CLdD+d FNN2N2VHk2hpHHO5YuiE/SqqKJZRCi75TKAqnjJyKj2aBztojTvdLutl5OAUjtgGlV3A2nhTj/Cs Rp1eyuAhIcDyy46Zx0o5ECnfcy7G6lLGNiA0PQ96sX1/ItxBC0mYwy+bKFyrFuAvT1NHIhylyn// 1/50Gdob+K7tXkVEi2SkLmFic4GaZreqSX/kIYYYbiMhftONoC57e/Wv9BfZrofzlKV1Yi1W3DRW wkAuk3DIb50Xrhh6VSvYooFg+y5EpGHCHCjtT5IlQelibTVe3eSG9MwtyPN3qcic4JwMn1FZNxeR 3t2Yng8swyfuU78Hgn/69Uo9EizetprqQBbtvMGO3QAdB+WKne8aVRGxCrGuxGxhgBVckhWsz//Q /nDOoSk+T5zSLCMLubKr1OB+OaoRul7LuZeFbDEdCRX+hKi+x/O4XuHaSJSqQOmwwNyrnGM/z/Oq 0Sy20KMuPLVtoz/CPalYCsuoi2nuQGupnDKoiEZaPJGRtz2wck1DpK3Q1e6vjNcLDJG0VxCYx5Zy vAXPbnBx/SiwHVrFZtDIsSom/PnYHzEe/wCVcnc2+laRazx6Vb+ULqfzLllLOVfoSBzjOOcCiwH/ 0f5obCfUCI2VtgBwXdMqqit2O9tdSka8eaKa4tnEErMwFwxXpnuQK/0JSb2P53JGaK7mlaYu7YBd pOdoAHQ/561mahdRQJGGdFjiGBt+6oJ7/nWkYW1YFa908RSWksV2sXmMs37uQESA+mPWhZPJvCTO ix+XgREAbmHf6mqaurAV7qNrxlIkCEuCcruGAc8Vauri6VmYPBcx52rGswjlX32fhU8itYqGjP/S /mqlma5sFFrcRtICYmIbcYWHBVh6jjisV9J1KFg9rPvVkJnCkiRm69Pwr/Q32aP59TvdGnZT37Rq 88Txf7DKQVx9fpT3muricJefPFvwnlnD4qOSRRoTIjwtEgePbwpPLMPrUUdv5i4z/qzxn7xqeTXY UXdBPCvnRFt4VD8vOMHFJcTQq0cohcyW8qyJJEuWDA+369qTp+REpWdkf//T/nEn1WW7ZXnLTSld plZiWHTj9B+VVY9RvLm+jsJtUuBa29uzLaK29EUZ24Tjgk4yfXrX+hHIl0P57U+5jyRvfXEkSsI4 7bDSAuEfk4BxnJ7dM1r3FtawWSwhVnnYZD/xRnsRU8kSudXKMQeMBnfoAAO4qPbDcT7WzIyjerDh QemDzS5EJzXQvWQlN28KiNkRfnViABnvXSCKzaEbZEhijP7x9wRiR1Cjvzx9aXsyVNrQ/9T+dizG nxzNJJdyZlUpHGUwYgBwCe+T61nSk2KuZFWRWkJjCfvH5+7X9/Shrqfz056WLWnXaXlsZ43UojmN wDkoynBB+laIkt3hkjBAeSIxbkO2RQeoB7ZwPyrL2d52NacrIhn1rUUuIUju7vTrcbYjb2biGGbb xlsDqcfjW9F4k1C1AhivrpDNIp+0SXLyfZcd0BOBnp0PWonQTeiNFNJaEUuqST3huZbmSe5kkHmX U582WfHGWJ61i6kLRLl2Qnyc+YSxAYt1JNZxo+zurWS6FSadmf/V/md8R+LbPR7qySTzJzMjOIFU KMKezZ5zxVGz8d2VpZi5Ec8F/LKWEbMptljwfmc54Pt7/Wv6azbjjAZPj62BxF+aLe3nql8779PU /LsNk1bF0IV6ezK8Xju5vZvOuJSoPCSFQVfHTnrnH4VeT4nTXBudP1K0ind2EdjfQyGJbdR2dOh4 7jua8KXijhOVctPfR67ee3e3yO2PDNVO7l/X3lWb4gQ2TSWZgad1g3qAdqgnjOfUelS23jsSRQCJ xmVsKknDE+g9/asf+In4VOzjt6mseHam6Yi+NrNbqW3vll+0oOWUBVx2UHpn2rSg8cI0awKxAJ2j 5gSnoDWn/ET8LKPuqz+f+RqsgqxdpH//1v5rrPx9pmnXkdpP5zlkL3MyOFVE9Q2MA+1I3xBtrSO9 uJ4bu7ZRvsLlZIx5m452Y64H4dB1r95fihg4q0lt2vr+B8N/YFS5FbePkadZLkSlT826PHU9AM9M cdavQ+LbO/u5WcLDd24XaIju3Dr8+e9Zx8SsPLql63/CyK/sKa0X6EUXimGG4mjLkI7Y27flUmtH TfGFtaXEsElqrygLNb3plwnXlCOc8Y9Kt+I+GX2l/wCTf5ESyKp2/L/Mjm8cadpV1Jd3V28UpzIG jUybfXOOnWtaTxzDe2TXQu4Xt4lEgKADzOCcnHoM8msZeIuFXuykv/Jv/kTJ5BU3t+R//9f+chPF 8V40SF13MQrSR8IPT+ldSviCytnjPMwW2KMobHz4IDcehxx7V+3LxFwndfj/APIn53/q/V/q3+ZR bxiojZXeLYhwxZsFSemat2viWx+0Kh8uOR0BUhtucU14i4Tq/wAX/wDIh/q9V/q3+ZHd6/pk95Gb iVkkyQpHLPgdSPSkHi+xHyRXKMI2PmiP76EcYY+vtSfiRgl2/H/5E0jw7V3f6f5liLxxaNHPPZzz xsmYZkkG3HAz7EEEH8aNO8ZR2sqyzhzArbmCnAx1OevpU/8AERsG9V+cv/kTT/V6t/Vv8z//0PwI XxtBqMjbGSKBvnVACoAzxyfwpZtahkmtjbThRE264VgG8wY6D0r9uXiLgpbW+9//ACJ8IshrR7/1 8xL3x7bxwJDes9tGrmCGSFPMZgScbjxj+lRnxZYQ7BHPK0bgD5wWySK0XiDg5e6rf+BW/OJayWrH o/uHHxzpLW5gmMMrRvtzGR5sfPIYDrn3rTg8UWCQDbIjRRjeseCW69Mf41suP8El9n/wNf5B/ZFX z+4qXfjS0VZG+0rEskilYwP3gJ4HQcDmlsfFsEXmC8MmSTiRWCqw7DHrU/8AEQMHzci5f/A/+AZv J6t7u/3f8E//0fwDg8VJcZkC7o1cg72Bbg45xWpb+PbR0ljhbzSqGNx5QZR2xk/zH51+8f6/4Rb8 v/ga/rofCrKKr7/cS2/iSK4s5WnmUeU2Y4w20L9T7f1qtF4m0axgw7s9zJOXLK6tbqOPvdwc1f8A r/l8dZSX/gS/zIeSV3t+TNaDxvprTyTmFruZkEYWBl3nA4wTxisy88W6be3MUVxC8Rb5oFyN6sO5 6VzvxDy+cuSLX3pfnsEsjrLV/kXR4mt43iC6hIschMci3SKi5XsvPOf6VFa6ta2ssri8Zorm5Mzw bshTgDj8vfvSjx7g+f33G3lNP8NBf2PVS0v9x//S/DiPxBp8hlle+ggeJN4R5MYA/r7H0q4/i2OD ywCZpGGdwPAHSv3Wpx7l0V8Sv6r8T4OOS13uvzI7vxTbFMK7JIcPuHyqfbNVIvH9pAkduYIJ3kYo xDFVOf4iR0PFc1TjzCp2io2/xotZNUS1T+46Oz1rTLK0W5J+03Ks0jfaFyyAklVX1AqlNrGns3nR yrGZPmNuTtAPcAGk+OsOtUl/4Gv8mVDKqm1n9xFDr9pHLH58jALkKBnco74qCTXrKKZHMjQ2/mbn mY4ZcH071g+P8NflfL/4F/wDT+x6l72f3H//0/xhtdZt5LaacN9rjC7k8s4IHYnrWAniiKEzgyxx zMSYwpy3Ga/ZFx3hpLTl0/vW/NHxTyiadmn9xWsvFlr50dpPKJZJGO12cDDHnP6c1ur4msolaOUx OTkRN5gU7h6+vHaqXHdBdY/+BoP7Kltr9xjzeJdKS6NxNJ9oYjEcJc+VEf6VNbeIIJQGEiB+u0Ha hFH+vdFae7/4Gv8AIHlUt3f7gXxFDdMIgdxLEBg3y8e9SDxXpenL5jETRRyCKUWjB5AxIGBjPem+ OaEY+0aVl/eX+Q1lUmuVX+4//9T8SX8ZW/mKxkWFHbCxk5Yeg96gPiOCTHmSbRJJ8zHjyx7/AFr9 m/13wsdfd/8AAkj4f+yp36/czXbxJosUtqIj5ksSbGlLhskgFtox8o7d6ytQ8TCzvIo728UPe8Wo PEcS4OM4/r1o/wBe8K+kf/A1/kT/AGRO+z+41Y9SsHsVimu284PvyiZWQEdzVe+8QWVrZLDI2RkS kIuXC+vrR/r7g0vs/wDga/yE8mq20T+5mhY+KfD0FqqQviS4PmNK4bdLgYIVfbH6VbbW9JXe8U8Z Mg2q7rsbPXgHvUrxBy9K0rX/AMV/0I/sKs+j+4//1fxmg8Q6bak/a7kAYLRhstvI7CmDxLaXgku4 JXitWcRyMXCywr0Jx36V+xrxCy/ZpX9f/tT4J5DWstPw/wCCNtvE+iJd5yZIR/rAcLNKAeo64zU5 8R2d1LFA12La3luQrKPmVVz1P0zVYnjzARXLG339L6bJ/wDA/EyjktXXRlM6/bRGdBNCXRsKVYHj OOlWX8QWiIhd/Mk2jdIp+XGOmK9WPGmB5YOzs13X4a6hHLKqg49v67E2na/Yyx3LyXEVsIwXVp8o GC+nH5Vmz+N9NiW5IZmeaIRW42+ZFuBGW9s8/pWU+OMsjO0unnH/ADJWV12tP1/yP//W/GG3+IOl mSG2a4jEjjbs5CoQM4Y4wKfeeLrK6kWNZFYqPl3fMq/lX7jLjrLd09LfzR/zPzv+yq9td/R/5Fr/ AITK2dGhnuSZnjERMbkMi8dcD0HfFTr4jsgY4YrtLMXMZtriaSQSLMrdcDHH61muOMDJ+7ZwW75o /l/wTajlVaMGnu12MqHxVpiRS2/2lA8DmNnZ8+44/rXRW2uaNqVlZxR6ra+ekBfUBhoooWXJ2hj9 7IAxj1xzSnxtgJPmja3+KI4ZRXT5f0Ma28c6ek3lQyNBF5hSOOSMq8gU4L4x/nNaZ8XQXJKReXIs fzSMTtJ44znpWL41wab00/xL+vxNnlNZ6fof/9f8dLPxTphk3TmG4QDd9n3YVvQZqS58WWUN1EEd YvMcCOHadiZ6AGv2V8bZf8XT1X+Z8N/ZFe9jSm8UW4le4lmQkRBW8wgDGMDA9vaqEfiPSbhVUzrL HLlQwbMYOcHJ7fjVx43yxLf8Y/8AyRnLKMRtb8/8jTj1bSbaNjbsJCi5ZWOd59AayYfE1mbzJhSN lGAUYgMfcdq2XGGDlH3Yt/d/mZrLKsdG0W7jxNpU21Jrm3EhbDIZAHX6imDxNBn7LY36RIPlacrl Y/XIIPFXHizB2s4S/D/May6rfdH/0Px4tvEnlPs+1RSRp1csM9eta7eIrO8utjSRtLDGrl0cbHB6 /wAq/cf9asC5WcZfcv8AM/PZZfW6WIH8SacwMRmSKRW2tk7SRmrz6/osoiRNQMXy7HcfdDdSMjPp SfFGA5uv3C/s+u0OuPiHZJevDqF9P/ZltZrFE8MHmvIyggZ6VjW/inSLpUaNTC4JOHBDNycHkcU3 xVl63v8AcQssrvZFe/8AFEFxENPkKFZ2JP8AeYDHGcVp6X4ktjPHp9veWsZiUM7LMBjju2cA+xqv 9a8Atbv7hf2ZX2t+J//R/KIa5piXpiu7pTCOWeP94xJ4G09OuKsS6lp0TcXcec4COwB56HGfTFfu 1Pi/LJe7z/18j83/ALKxK1sZc3iG2EhW4uY4jEdkbJlxMSeAMVHDrVpdXTRXN3HawxKW8yQ4V8DP 61p/rflKnyupqP8AsjE78pffxToUME0cV3HPHHt3NJGFXI6gE88U8+O9BgsZxlZ3lURQSRgsiN1O ABg+lbri3K5ae0/B/wCRnPK8Sl8P5GbZ6zDN5J1G8t45bhw1tvcRiOMnCu/p/wDWrQ/t+0uHmthN beVYu2LxZVZbn12nuOOMZznirXFOU/z/AIP/ACM/7MxTfw/ij//S/KODxZpiwskV9HmUeW0QYgZH TI+tZL+IQXMZukhTdw2QpTHvX9ER4pytLSf4P/I/LpZZirfD+KOqHijT4ZYPt7RFpIlUiJlXeFUA N6DOOfeoovEdrfTCW0l+zAsVkSCRvJuVxjLDox/WlU4ryunSc+e/3r80FHKsTKqoqI22v7Y3MhmH lxxnjJGx19auahcxbWvQYoomkyViUKjDHX69KuhxRltSmpOVvJk18srxquy0M25u7S1tvt9vcWzl plT7Mzbn6ZJI9O31oTV9MuobeeXEdzFKQu0YH/6jXQ+Isu5b+1X3kRy/EX5eVn//0/y0/twXx+xx SmRc8onA4/nUVnf2Jfe9yAYwVeZ85QZr+ko8Q5c3b2qPy3+z8Qt4mra3mlXiPDNeGOBA0oZATJPj +FT0BPvxWJY3Vnpd29xbTQxXYYp5kybsoeMZ981ss7wDf8WP3obwVbrE3LfV4LC7uIL24haUMjxN CvmRzBlDcvnI4btxWemq6abubeZZN4PlMACu/soz610PO8DFXdWP3oz+p1r2SC2V7pkliISEzFJT uG1cdQauWmoWn+kxC7yQcKGOyNSOOpq45zgJbVY/eZVMJWTs4s//1PzCi1MPtiknP2e3PmMY5cbc 8Zx7/lSWWo6a96I724KW2SfMCeacdeV71/UyzPB7+1VvVH41PD1duUupr2iSW7QWySQF52EcAh8s yYJwSB0z/Ws3+0VhMkiXSrFIhieJSMjnvVLM8DLRVFf1QlhqiWsWVNLnS4vJVeSNljQvGjcvceqo Ppz9BXSW0lswt/7OlMju+02m3DWzggAKfQ8H86FjcNPVTT+YpUJpP3TTvgdKvp4r+88u+kiCTQxz iQMjYOWwT6Dj3rmrzWxcwyQpeTvY2bn91JnamON2OatYig3bmMlSm9LH/9X8vrDVI7rcZJgq26eX CvlhWkx3z36100l5pF3pMWImXVEnKStIwEPlYGD9Sc1/W8K9C3xH40qU7bHGNNcRNusoriSOCUK3 2fLMgz1z2raW5Ek4uJWknmK7ZXlJyuBgfXtVrEUnpcUqU+iJFawVvtV6qSxKCF8x9uTg459jimQR yXMwuxJHcQBTb+ZFINq55Cjrzx79KpVqb2ZjyVE72LENklnNNc3N67K0G2CzI3Luz94/p1qlF/Z5 nEN2whM/76RdpcqvQkCtPrEO5XJN7n//1vy606e8juWFofLJlaO283C56jv25rXnt0htbhJr49Uk WK3OYGcdh9MkZ+tf2BCqnLc/E4RcZ7EMOoxRQs0SG2wnkyuTxJng8n19Kt6UEknitUlKwk7UOdsU ZJPX2+la1KtOUeVSs0bNSbjJx2FW+vbHUby3tLhUZH2RNE+Y5ccFh/eBPY8cVmafpt5aaoX3fvZm d5VuMAEkEk89/SrjXwzWrd/l/mKpRnOpdbduprajLN5Qgh2blUZlx1PUn9f0qDztKU2U0u5yy+RP ck+XFbEnGSo5OMZOOaznOnOygzXk5ZK2yP/X/NG61OS5ntUglzb2mWUMA6Sk4P4DimyS5udyzKjT ngdEhJ6/hX9jVK1LlUYP3j8aqxbnzx2LUS2NvbFG1Q3135xYLHHth2ntk88fT8arQT+VPI87OkaD hV4JqI4qEYqL3X3F8znSVN7ofIYb50SQuC4IRwpZRj1pYdHu7BP3chuEu5We3eRsbOxQe2f51yxm udtnl8jVZtFu3gkhLfbI/KkKkABvmQ1FcTeXC0CTMEb/AFke7iU54J+n9a1q1OdJLdHo80FR5JK/ 9ep//9D8wHu47RBLdTzLs+V1jJMZz0G3v9RV6OytXuWnhulihMBeJ5gR5rbc7QBnqeBX9dwk4yvJ n4tOLloi6unz30dhp139mtPtqGNpARErjkFjk+2AD7VlQJZWE8axoZreABF8wn5wMDnHSidRNqyE 6aUlK+q0Lt6k0Txy3AjignHnW6RSiR0Q/dJ5yM+/pTZtQhXyoJvNCy4h8pojuLMcAkDsfyoqS54c hhTaVXmRUvZ0htpLXyjERII1IyZOuCPxqtHc2tgz2H2meO6kRZljERZCCccnp/Pr2rSNWTpcltSI r/anVT2u/mf/0fzU8SJbSGxhsZZLpzCjmIRkLAxHzKfx71z1+GlmiSO3e1aJV8zA27io5/l+tf2J 9Yny8jWp+Cyhzyb0RjSXsMN0trLZzzJdj5LiNC6RsDjBI6H3PauijtDBBLbRzlpAweSENkAEcYHf pjPqKuOJqcq5t0FHDqMtGWbeykkjjMzDGeMdV/CpFiRp/wBwQsqqV3yAYwB70rpy5krXPRafslHs ZckUkssBPyBJf3bn5Edh/npTbvM00cTySSl33SSKoCp9Oa0nUlTlFroJw5o8p//S/KSeF5Y5LYSG SCWQKYj0ZlztP1qhCL3TneG9jmtVR/kEny4B6EH3r+yvrEduXQ/DZYead5Sd/LQvCW4tClxDIyI2 Qz5xuU8NzW9ZXNtKfLlkIjAwdg+c56Yz71k5c11fQ1u40uRq/wDX/AKsb3cEyQea0kZf92JCCWHp 6Ci0vWma+a70+GJLW7NoPMYOJSRkEZ5wQD09OtRBrlsZ1Uy0XVLaR4rxo/KbbFajIKA5J2n09ves ES6kIby6upvtKRjMUKAKVQdOfxrodaLleW5zzjGcFTSsf//T/KvTLu12q8kMnnkZQlRtwfeqN5rN tpaXEbzGNZJdzhssASc5/Gv7KWKhSjy8p+FUkklBLRBby3D3MLySxzadPDxIOS+exHbjtXT2+lW4 2sLQ2lhKS8ciR4RsdcHvz1rnlWUpc72NVezuc1HDdzauVcqlspK29urZQkdWYmrkt1nKJHvYOETY clu3FW8S2k1pYypUHCbl1epZv9JvYfs119qMIkXhYpBlwOoYd6itcajei1t8vLF/rl2FT0z39hmo 53I2hh3GftJM/9T8uQlqbuUpM9sfIwssfKs6jgH2PNacN5e2Nnb2t+5MUJIimKAS7X56jkj/ABNf 2FflnqfjapfEynb7o3ubi1kAWJSzFmxnPH9al03xAVvtJtSdTvb1tRRA1jAHcRFxhG7bTgg57Gni HGpRnTfU9DL8S8K4pK/Y/qZ/4JSWpb4d3N+lkulG6mlvFAKxvb7JioVl6AkYyP8ACut/4Kn6wmnf DfxBqcWqT/LBCGSNRKLoeW6bo/psr+VsopuPiJNdFUsvvZ+65zUS4Oi1u4Xf3H8gWuytqMqzSwNd RbflRz5PB+7kjoPevzU+Ll5b3fi/Ujdzv9nsVEMEyp5wESgnYhz8wBB56fNX9F+JWI+qcK+zS0k0 u39bH4XwVD2uczlJ6q7P/9X+IjxLe31/qF1O8EJilmZY2ibErAYClkxwcYzVLSS8flLc5eJZDlAM kD0Fc6jZyO2tU55XZ2amFJoY3cIjnIXpx6fzroLI2un2V3DFZr9pu5xJFf8A2lsKOhDIeD1/CvOx msGjhm5W906SSxa+0Z7W6n2zeWIleI+TLlidpXBzkev0rT8MWot7kWdyz6nAgQQvI3mvMxI3IQ3p yOeOa8OqvcsjHEylKEL9D7q0iGDSvD1hJYSQpNJONPgtAALuJVVW3PGP4ecfhXW3k0rLp8EtxE8c u0PNFGVRSeuc8jFeNiaUdZX3Kwjmqja6n//W/jZuLKZtX0zUYb1r2JZSdsiiE2geMqVx6fiTkn2r 33wXc2NxHDNpVlFc63FGNPuWkZIIVWPIDBP4nwfx4rwor90jljL93JF650TVdMlBuoJ5RrEk0thd SoLeC1KsOHPcAkj15B6Ul3ow8ONpy6jqli2oajZNPGLWdSqZPzIW9eBx71NOznp/VjSzieWeLWt7 YpKrStJOxV/kyGPQZPsKzTbapFpNk0t9pc9heI8klqbhJL2MBuEdByOmcH1rvpq6SJPLNemllm/0 cBbeMFSu3azHjHH51l+HtUvrJp40u7ry7or5kCcQu+75Cw7gZP0rugrJCTvBvyP/1/5m/gZHpV94 MinlbC32pudXtDDhPOgCx+Y2fvNjJHsRX6LfsnXNj4f+OXgDWrRItTtJNehhs5rqMqrM7iOHDDnG W5A7DtX9gcKWqeHUIp/8u2flGEkocdU1L+dH99vw3Qv8Por7U2864m09oLqyZt32V/JVvIUH22jm v49P+CxOgWN3451HUY7B7fUJdVGiS+WS13BG88T4QZxzlWOOir1xX4Z4Ntw41rQi+r+7Y+u8c3aj hm+5+N9yW0e40yC6vJX3FYX8qfc0MbDHX17HPrXL6hLa6FqTwwXfnmScnz0XPm7+QDj2ODX9p0o3 Wh/MlZ/mXr3UdP1K1KNAqz7QjM0ZwuB1B71zNveQ39hHCYW0u3huQLeW3j8l74o2MyZ555GPQmtF B9TM/9D+dNrdGuI3jCtGmc+Ynzng4I/Grdrq9pZ3nmajJczQhNixwnOMcACv9KVFvY/jcu3Udzfy fZ9AhS3863klSWSURNIChIUt0GQCOPWuS02G6mjhjkeaK4tsiVZJBI6Ferbh1HGaqMXfUqC946O6 u0hEUADTRMgDO64Ykgd/zrBu4IltruW0KRyJNHMWlXJLZAG324p8rUrmr2Zv6fpupa3bwpZ2bX58 2OK5WMbjbs3RiP5Dvim67Z3+mXrWNyZoriK1DRJJlGweAp9GPoe1aeRnFe62f//R/nZsIrmGx8p1 8u4mQ3ASQ/OoHB59sGsy7gtLyJIri3W4lgmEqCUZVWHRhX+l72Z/HCSk7M0vD0MenQX2YIxLPMJF lEYMmAMYB9Pp7Uim31TUpJbyc2sVnAZZI4fvyMowoOTwCep9jWTm2bxir2Q2bVJ9Qk0zQwqM5mcw yONkYXOVAJ7+nrVm5s59N1ZodQgWDzVjYzQcPtPcqMAD1FJybVjeKWyNeLTtNuJ721uHaSGSLEc6 fu1kwcrnuOP51Bo+nWVhftLZvKyecX8wuX8kHsp9KR0n/9L8ANUihlN55sVs7TYjVo4gPNVejMfX 3rFNgLeNru+SSG22ZjGMlgOM/T3r/Sezvc/lKMbouXrPf2dg1tIGEXyiNRnI7MT0pul2lg73+oXc Uhu7SPy5LVXASQ8Yb8sfnUKHcuOkTYiJkimlWzWMLFvghtUCbznox78Z965/7LaXPn38/lRzW7bj bXEmCpJxhEPU801Czuc8kmjSmWxuhazCB1ndFSCCJDt4AGcdj9ags9ONrJeG1iV7W6kEl07j5PMI xlQehGCOPerMT//T/Aa3sfsyKv2UuXJKyyDCnHv+IrGvLO3a8jWOOVrjztsZETLhhyfbiv8ASg/k c6iS3vlNjBJLFBCGZ2aTh5MLyo45HB+hrkvKZNdiumkuQsn7lbdSBbyHOc9Mk8evegDvbXTree2n vL+/s2TdxZhZFuI2BG1WG0Aj6Eior7U7If6GUVlWPZ5oODFnsP0rWGwHLSXs5eZX3rBFtjQ7dwlL Yx/PFNk06yYxPj96gw+5MJESe36c1ZlP4j//1PwE/s+dp4oJro3DRKJXu433g8cDPtwPbFKPDdpd SC4iuvPkCb7gSuYURc/3SPvdPzr/AEwP5FgrJosXOkxadbv9m+WIjM7RHLZxjJNZ39nQ3cVsUne8 +fy/LnxutwoGPqM/jQ9jOSsy7C7C01G1kdUlgIFsEOWVTn5mH1HT3FWrHTYZreGfUAsbwgl3j/5e cZwXznrx0rnCMmmMtZbixleaOAw28jCWyZk2xuCSDj1wRWvcb9qrMImnmk4ZfugHsKDY/9X8G7+K GKIxJbM80fLbEzIT2GP89awpVmg1C1uCJplso97QYKPz1VDzz8or/Sey5rn8kXex2dqt5r1le3Or 2TLptvJHbSSpGIp4C4Jj8xhyfu9T9O4rntV0rT/InubN3uFZfKQOSynAOCB/OnY1g9LGXoKaUqC8 1KSRNRhjZo4WiIjixwAOe/PapLTUbC4v44YLowPNO3mvcEiHLHjnBPHPSg1gnrY2r69kWWKxEk8i M2/7paIY4znp34q7Dqc1pb3STIXjSMG2VGzlj1JHsKBJyjc//9b8H7ZY7mD7TBKN05KSMzgsueq4 rGudFuA8pRmdI13hzkgD0/nX+lB/K0ZXLuizRPbH7TYFslolUnaz4yAWPb1p4tJIIY5LlV8yC4Mk SpltnJCgH1x/WpaWw2+5furhmhtTfQTWsMshj3yR5MX+0wHrj9arrZqYvKE3nRykqCOC4OccfSsT OU+xROiRJYXNtcPcXcZl8ySGaUPDGONoCnsCBVazvNsctpDEC0Pyv5eT24X8KuS0SHJ2P//X/ANI 7kSrJYWwW7wS9xJ8hjGBwe9VYYzJDbx3UnnTmQwx+YwGXB556AZz9K/0fcbSZ/KFP+HY2rq7hk0p 7eS0Frc28vkfaUuPOS8GByByB3HH92svTbB47c3v2ZlIY/KQQk3A5x3p2T3BNrYZHbapqMhe1KpB EGFxEq/vAeAu0/nmtmDTr+Fbi4njT9yVT90CZSuOGk/Wlyq1h88ivb3MkMzySyu8EjYELHaBjoRT LWHUH1GS4lleOG5UDA+66jhR7jjPNDtysUpS5D//0Pwnl0/XbK3ufOtxFpmoRFYvtCtH9qAwfMiI 449ff0rAtNBtUtrjyfMnu5G3wxytlWb+6T6fn1r/AEloRXJY/kyL5qiZQtswKEeOW3uVk+eMyb4w c9F9P/r069lme/gutSlCxyyBAN/Ax93OfXilGHc3cXqzdvLe9+XbjypI1kRQc/Ifu5qW0lazVYFt BNLNkGY8iLPpVOKZPJIzLjT42un1J/KnntsI8LNmQDqBjsD0p1jIIory41TTVw0Ui2IjkJkgYg7X A9R6GmopF8nu2P/R/AhLTTZo4kgv5Zr8Qh5WWBoHgbvkng59vWkvH8ySxaeKJ2tcql5GoDkE4+b1 9P51/pLyI/ldKysaWo6Vb36wpnz4RiWXaPl4xyfxNcy+njSNZtPKch7tcPHF80aIDgF/T+maHGK3 MLNHbajZJJawm1FuJQ4LyM52qe+f15rHaOBLJ7Wa5Ece4+Za274RyO4HQ/WshHOJooM6pHLIiuu9 Ii3zc85JrcTQ7G6ktTIjs1uCszIdrOD15/xoA//S/ACz0kwah5U80flPMSjkFFiQdATz/k1f1Gaw tpLm0guo3nwMwqfmIPQkfhX+kB/J5j2thfzsh+1qsUCb5gYwrTkkAAHnHXpWhqMlnHsh85VkB2ur jb09D3rKS96yNoppWZE+iOyG6jRARhN4bnkcEj8DU6WcUUJnkHnFE5IPJxVOC6FpNvQdFc2eq2Jt hYxbsFSwTBlBPc9/SmzaLCXszb74EsoSDbq+0MAPuqOnIA9enFZtNbm5/9P8DYblJIjFdRG2ZCfL EhDnHY0t6bC7+zXCqz3FqmxEOFi3jIDcd8etf6MH8vl2RJIbVDDI0F2yqzyNHuhUk8qpPB44P1rG mtm1iKRrhyzWs6z27xOUkDx8qwHp7fpWsY2WpnN9h0dvrE7/AGm3dJL7qXuPnKjp274q3fwXgjUT oA8a7nZVKocVMo2ZUHdamMNVijUiNvKeH5JW5xWzp8t1dWbPC7MGy3m8B15/hHrWVVWi0a0ZJ1FY /9T8FNKt459QYXKebcEYaSX/AFsx+vc9/wATV6bR5IrtlxJaFGzsmXaH9M5r/RFq1j+a6v8AEl6n Kam1xFcNLcO77m2COMfIFHHAHtQuipcWZ+yzpbQ3DnfHb4jMPHXj6n9a52rOxmLfOmlImmWc32me RQpuZQSkRHXae+KqPaQpL57nzZ9mxZGyAO/yjtmmotuwFq1aKBPtaweXcM/lOSmUY9Bx6e9TX8zi yjj1aNPKkmPlTxKY0c8EAH244Bq+REOdnZH/1fwEsCwdhEhbCZ4H3QO5/SpHupXcx3W5jEC0ZYfK B6Cv9D1FLY/mHmle5BNJHK0N3Y3DRTBfKcB8EnkELj1/rU76YtzAjysm1iRMCf3g7g07A5NsrI3n W8tnp95F5kc4juSx3MFByQfrjH51Ql0WeZ5PmIBcSZJwiAKBj9CfxoJLAurW1ljhQW8aooSaVsKn pkmrMGiWenyzIk8M11JIZnkEgcybzkc+nOPwoLhJp2P/1v5+DFJa37AxDlchypxz6VZvo5JIGkBE bZCe/wCVf6IWP5nM5Y1Cxx2q+XKh+Z24ye/FaNlGlpI0pgiSWT5ZZhGFkk7cmm01uBDNYl3kaNla MryZW5Pr1qPTY5IbhoreLz5HIWUZxtHOD79elCV9EaQ7Fq7htLd3W4CpcxHhXHzoc4yP/rVnyTWi MiTO02APtAQYZQcf06Cmotuw57H/1/56bG4tbdVS38xdzkRJKMfLk+/HarkkLgxSxKZC7EttPyrX +iLVnY/mfYgubT7S6CcNIi9Y14z9f1posGhKokZIlOxnP8Ax3/KkEZdUKLW2gYq8KNID8sgAJqO7 uUjkhayCh0IV96DZu44xTcWtzXnVhl1eX6wvFLJEIpZdzW8Lfu0PsB1p0kMUVv5TuqlofOKocliB wD75wKVuhm3rqf/Q/no0Jbe+uHNwfKEC4i3JhVJ46+lVtZtXtJNpw27rcrgRyDsMfr+Vf6Hciufz Q5N7lO8E1xFHaMggcxho15Bk7hgPy/KkgiuYbX7MJGMo7t3FJwVtCW0typaT30l0iSKI4IlZZ3DZ Yn+Hj881pXcMckS+aSRGd3XBb8qyFzxNVLsSlVaERxSRYQnlXxweawLvTJYojcXEalyp8oKc8Zxw fw/Sg2hJLRn/0f5vrGxFvJuuJfknAKyRA7ojjPP8q6pfKs4Zp0leQMmW+T52xX+hPKz+bxsGoXcI SZtkr+WUiimhSQIGB6jpxmsk3bfbYXkQphzucDABHt2pAb76pJfXUemR2txcJPHmS4QARAjsxP0z WNKYobWSBnCsGMhRTlSQMD6//Xq+RjVr6mJY7ILuOaSJ239ecJgdAR71disWa+kW/EkdpcHdGkZB mHoRnt0qeVmso3P/0v54JJHt7GPR7RTcx/aDPM8m3zIc9BnuOn5VnSael0zw3YWCONMpLw2444BH +etf6EH85uHYrRXHlO1vMreTGu3JHynHpT5I1ugDbQjdjaoU4JxVxjfVlpWVkSWM5uLeaCZV8yAY TPBB9q5S4iljuZrl32yy/IjYz06VoklsM1bL7XlOSxVPnfGFNW1iMshEgxuP8HGaYtrs/9P+bfU7 ExxIbQxrKT91zk4z3qfTrYpC7NHsk/i7ZPrX+iB/O91sRzaej5mj3FwP3gdiR7YFVbOO+urqa0nC mC1txNJPHF5Kk8ZAHP8AkUWW4GXql81pcRGKIs0fMYEZfzB6jFXbG7luXMjb4c4SSBlwy46gj8f1 pOKe4Fy4mCXUMcakrM+yQoPucZy35fqKvyaaz7xGoiMqDZcxttljI45B7EcVLgugH//U/mutUktp p7eR45ETkbDlj65FNiMXnLJb2qEtJlo3+QOemSfyr/Q9Kysj+dzQuID++jIKSD/WKpwyexrD+wGS V2lAktygQxMMhuuc+3TiqSb2Agh0+e2eYyiK3sBJ/oil/lhTA4OfTtTDHaNKS8pJ/hPXfRZrQdjS s4PN354jjXPmZwR2/rVmOxt7eJngRZpJHwsrt8yZPOMn6/lV+zYj/9X+Zp4Y9Llk8re73DmSSLAM ZYn73TOf8a2IWRIgynZIzDfIT97PRf8APrX+iyhFH87mmokmikW4uEZFAWGFQfMT1yff8K5y6t57 RxNa3MaFU2pBKnmZJ/i654+tRyO5bn7thLu5lV7adnaHMRBXGY3bqDj8P1NWdPu5LjfM22OUdFIC qfQ7e1HIybtbDb1pYUM1229cFyY1+7+FFvdQzRRLCcCQZXI5NLll2JlK25//1v5t5FRUAkVt8ucM uQc/0rNRHt7h7mNf3kiG3aYD5tvpn8a/0QP52TT2KbJC1432mMIwdW3ZwZQOVz/hW3PAjkT25fZ3 jHzEUDGCBXfIc7wu1lNPt4LOxd3mlYtMOSDyh5xj/Ck4pgVzbbWmlaRtjkAyL0I7D/PrWy0NveJD btCFNsQ8MgJVs/5FS4LoFrH/1/53zpMEIzOyPMyAgI+4Ade3f/CokhjxjacJ8p7kiv8AQhx11P53 MxrdLINFaxiOGRyzIvGSTkmo5F2qVAZJiAyENwB7j8qz5LS0NI/AylDHqE93cfbHjezwiwRKuJFP O5mb3rTu7u0sbaQllklVeUc4Ce9Q9xSTi1qI9vepBpt/IjRQXKbxCWAlx7r2/H0pwtft2Y5SyQuc EnsPrWM435max3R//9D+Uvx49nD4igs0glv1id4rSZlINqB94s3v+tYC/eeBwCGxgnkD2NfacfO/ EuKa/mt91kfP5JBLLqS8jXhjjhiDSZIX7q9Bn/69SRW7b2keEh9oKn1GO1fCarQ9i2ljP+zq85lJ cEdnPLVZE1msAD2ysVkyrLn5O2cD61lOUmy4QVjHuLe7yzW+y4y2WMr7Tgn6f5xWjbxXFmNwhJQn Ib0rKMp63Y5rsf/R/lKa7Fr5M9zbxzw3xazO9QxjJGScdscU28tbBIQlrcSSQtCB5ZG0RHnKryen rXmVHK5ziwW8cscWZOrDKF85K46/kK0niVbt76JvLkcBZVjO1HxwOP0ojKbZcUnuMkvHCrKwK7zh i46AVsCORA0nmwyKIxJ+6lD9fStU5dAmktESwaark3c0ud/BV2+UD0H1qfT5FS5u7OayaMbVWB2I ELq3Qj8O3vUznLlFFLqf/9L+XS8t45ozawu6FGyDE+xs8961VvBZWiRzFz5MIQuzFixAA69a8nmk tmc+nUns7m11OPcXUxKCHAG4lh0BH1FOlMtvKH8pPNA2xFzgH05odSaV7myjEzne4ub5bu42oUh8 t1Tu2Rg+nGCOPWrtrYRTbzK0mMl8I/llm6gn1x6Vg6kn1KSRNa2r2bXDu5uLWZtzoByowAV9O1aO lXC3E0onUxwKSFG3OB/+qkpzXUuSjY//0/5qbm5ggmWCBVmZMuZgdhToAMfn+VRRz30snnzvGquQ kQhXaFAAHPv0/H1rwvaT7isuxcvJUu1FrKMgYJJ6EimzTLCsarGzBeMquaXPPuFl2M5rmJ5HeAJJ IpKlG4QtjgE/lVp7qdIUZl27hh0iJf8ALv8ApWkZzfUZLaRM24xh3xyDKDkHr3psT3OoyS2Wxle3 kxKQdufTHtU+0n3MpWvax//U/myt0mim+zhwI8/Pg8it5LaZHea0UJD5QjcR/dkAxwR9R+leF7Wa W5nCPVlUNbyRSxklQp/eL0z/AJxWY9tBv8yCNUR+CR0PvWbrSva5uqRb2Np6xPapmV36A43E8VrX UUUzWd1cW4jubbPCOeM9c1kqs3qmRKGtmVr3bMscsuRsbMfZM4qvCWuJVKSSbkOFUH5PxputNO9y VGKP/9X+bC9uLtZWs7q2jdJZMtIrEgqp4/Hp9K7yy1O3+zoGY+csYyG++BXzUqsm9y3C0bFa9vZG tYZikYjMjCVUfc6rnGSOv+TSG1hQRSQRukSIGdpORk9cH60KrN7MzaT0ZLcarPANkr72ZtkCxrz6 DjvTGPnLA9w7NPAC8cp+RlyPShVZ9xWVykmoXRkUybniDYVhwUrXlMlxaNOAHgt0MhSRhGZMHHAP U0vazvy3KP/W/nptNUuvsm2xuLjTxcR+W/Ztp4K/Q9KjkeUubbeodvlWQNye3WvlniKnQGl1KsVj 5DySyuWkHEWD9z3zRC1416m4b4VBLSO3TPpQ69QSjHqWbqXO6OJFlc9V/h/E1tfZriys7driEf6R EJI1VgQynOCD+B4pKvUvuFl2M65mECkxusciJhYA20sPpVSyQRxAQhVV3LuDxtOc9P8APStfbVOX cdo2P//X/nw8s3N2VeRI4o4t6SMpG888D0/+vVxj5cb7WDYGcOcGTFfI+2qSdmxcqXQjt3W4gBuX itZMnYC+ScDp9aoLFHdXG5nbyweSfvAj0FCnNdQsuxMbiO2mEdvJcZmJ+ZiSi47e2angGZpJp2ZU bAPJOccVLnKz12HawXEkbvGYUdY0bbGUHAxUMlxa3t/b2093NbJEfMhfGFLgcbwD0/OsHUq31YWs f//Q/n2nt5oyb0CW5liQgrGS6yDsMU2S7l8gv5AthKcm3jbKpntkmvi41aiaSKsuXUS0uGj/ANHF vGyuuTO7srW+BwFAODnPf0rNVtcRVRJBLGLgrJKVxLyTtAx29/pROtVvdPsYTSStY2HcoYlJKO3D Hsa1FugJEzICIhyAcg1rGvUdkmOMIptFSXUXedWXiFWw3oaHkS6Z57cxlFbZMD8jL1HA9azdWom1 czcYp2sf/9H+fuNrONnWaN3YjMUgHyE55B/CpLwSTWqCziWzCkgtGSXk985r49zq7JnPyxsFrHNZ bHMgdljzIHYN5gx396dp2p2AvruG6s0lKR5tnDFSCynB49DWlOc/Z7laR27EVtNDdDz3WSBhIyPH KvlswBIB/HmlmuXt2yj/ACO2Dg9KmVScW1fY2itU2XYbiIQSpJkXGzNnPt3Nuzyp9jz+VS2WoSiz +zzhUu2kxMYgQrL25PrU+0kle5ppzWsf/9L8BwqW0rmJXRFG7A9e/wCuaniup5wt5JgojYXccsCP QV8b7aaRvyxXQrXdw2oXVsTcOqqSPJBxuJGP0q3p9ulpLcr5k3lM5lVGHG44B+nf8qzeIn3ZLhDq h82pPZ3RaJ2YgfcJ+T8afPqUcyrKriGVjzs4UfWrjial9GzHkT0sVLaF1E1zO8RDLlMPliQeCaRf PuAUilePcCGaM/MB7VSxVZS0kX7GLVmf/9P8BT55RZI5HOBzvBUmrBvJrcpdKxjcLsZycAj3r5D6 7iEr87+9k+wjtYJzJqlvcfuzKqgMwU4LYIP8xUsM/kW0c1vuLkbLi3PVCO4POc0pY6u42c3b1Y44 aF9UTW4mkRpbmOdYp8iKRzhVIxxSiYQk5JJJ2hs8CsPrNS+7N44dLdDoG3akqOxYNFtUg7uvXHpj irKWMUWoGOymEPntmZpflycfNk+1P61U7sPYLsf/1PwoCPbSurs8qucFgSR+HpVqEziGeWA7zEPl 81z8w9M8818N9ZrX3OiFFFSx1CS5V0Z908MhDq33k7gVFdSzyRTFoJJpY5AscakDfnvz9f0o+s1u 5p7KBYuLWW1hRCuPMQMwByMkdvzql5TCDyWdotoyuBgLTWKr7cxlKnG9rDRaIyRQzXAuQ4wzSDbg /wBPwqdbe300l4pHSFUIaONvkX1IHTtWn1qst5CVOHY//9X8Gzr1mbfbaxeTcBdqSYyJR2z6VJBK 9zNDI6qxCbS+Qceo/GvjIYqs/tGvs4di7q2rGN4n+yx3KbBb7DJs8sYwTn8OnvUKXEqW9u9kWtLa 0kDyLCM+YDn5Pp06egq1iK0moKRvSpwhLna7mxL4ov5yDIUZFiCIAuD8vGTj8Khn8Y6immy2j3Uq 2rPva3ZtyKw7gnkfhW88ZXpycOYwVGE3zWMe1m1OSGAyXxmQgvuV+xPGce1X7e/NtBdw3U7pJIQl nIrfd/vZ96cc1xcfcjJ6eYpYWl8TWp//1vwcOv6npKKdPtvtyJ/rE84xzuoBztY8Z+vpS3GvTXiQ SW0V3YSMP36NOH8zOOoHH86+cjnOYR2qP72KWEoP7K+4uRazqP2qOOVZo7WJFLMrlPNLAjIPqMVN LeybSz3l1IgjMeGuGbIPrz1960jn2Yt/xX97M3gqC+z+BmG9uLeNJFnmMTDCybizJ+OfpUFhdX73 Yjku7mVj+83vKypx0J6DinLPcxejqP72X9Uw+6ivuNRL+7hledLidXhbIy7bCfXGcVWbULiVGhl1 G8Jncu+yZgATz26Uln2ZRVo1ZfezCphMPL7K+4//1/wuk1O8IEcM8iOY8Gckcgdj65qVNcvIsTks fKXlYySeOuBXgviDNGre2l97OKOAwy3gvuMa/wBWvbnVbS+tDeQiNf3jLK6xvnOQy/41tSahczxB GneJgMh9+GTPU+1R/b+Zxd/bS+9/5lfUcN/IvuMubWtUs54ZINQuZ2XMYKtlcEbTz7jNWz4l1Swc i2NxEZodr7JGjT8CK1p8U5vT+GqzCWWYab1gWdE1L7VcMbi/mhu3G1rl3a4dM5xk5yB/nFbWq6tr GnP9hsliLW8qvqF9JJ58N1GwBCxqMYIOCS3HIxXSuMs6vrWf4f5EwyfB3tyo/9D8Mx4g1aVsRyLH HG2Y3Byc+mK0YvE2pIVa4uGeWNdwdeFfA6ba5I8aZ1bSs7fL/I4XlOCX2BI/G+uwu1xbtHbzHB8t dzR5BzgjIzSr478RXjSXBv8A7EMk3EQQNuPTArVceZ3H/l/L7xf2LgusEI/jObyHARr252ZEStsS Qe5PANWh4p1KxkjmtL6WBW2yiNUX92w56HP+RVR4/wA9j73t5X9TRZFl8l71NDrr4k6xe3kUMQt5 5Pv3Nw0fliEDj7q4BJpdT8catLMlwXhWQRCIMI/LRFAAHA4rpp+JOexl71Zv7v8AIzfDuXvaB//R /FK88bavOLcolpHDCoEhEZLPx94Y6H86a3xA1KBfLaWLY+CjPArIvsa9SHijnkXdTX3I8xcLYBvR fiJP4y1Br+3ju3RYpIsskZHkqcDBA9+TXSReMRHbGK3n/eDghuXkBB6H2oXibnDqOc6nfSytqaz4 awajyxRjN4x1I281/bvbzxSZtUwMtGyn5iTkkHt07Glj+IGqBIraT54ooi6ySShSrH+HpnsO/wCF bx8T8fbk0/H/ADMHw3hi63xVvJ3021v1iggtoPKkubS3WSSbk48xeM9eW496yofHa6lc6hby2l4L KGUR4MipHdjbneMZwATjketdMPE3HqPLp+P+Ynwxh3rqf//S/GeLxhDEoWEKNqAeRHNuC+mas33i 15XT7DavpluIVe9PnCdb2QDBckrlegwAfbJr6ql4oY2nPmkotfP/ADPDqcLUGrJv8P8AIzk8epbl kgtZrm4Cq0Nyjr5RYNypXHTHfIrpdT+JOlzz3ZexubeU28c91ChVlhcjB2dyPlJx1GeprppeKVaM +apFP0uR/qpT5bQY+2+JsDW9tYwb5DEWWAzILZyG5JORnr61QuvifaySadps0V/cC3Zp/Nt5haxW 7knbnuw9eO/TvXq0/Feh9qk//Al/kedU4MqKTkp/h/wTch+JWnyJN9thunuoV3JJEN0Ug+p/lVSX x1Z6nI7w2slskKBWWSQM0h7nPbPpjitY+KdF1buFo37/AH9A/wBVZKHLzan/0/yBfx3peyKP+zri Qw4DbpVEUgBxgHHt+tW28e6NewuJFbTptOl8z5mLK6YBBB6YByO34Yr9gl4n5W7crf3dT4dcL4m2 qX3lq88faVe2s17cXsbTwQj7PapIDPMenyqOOgJ9OlVofGWm2ts0twN0cqglCMzqDj7o79666HiL llW7enrZfqc2I4bxEbKP6/5Eo8Q6Uwg1KErd2TytFCxcZh2HpIoztOccH/69aE3jmwn8xZpbSc3L xuzpnfb7GDFVb14wa78Lx5ldWTjKVjz5cPYmnZxVyrfeMNPSYSzNAwkOUImUInPBbr2qKTxdo0tx aG4ViXYI19BIssaJ/tLncPbH5V3UuOMpm+VVF96Mf7AxUG5Sgz//1Pyil8bafZG6kWeAwbdkd6XB OQRtO3qD/jUkOprqCm8l1COeSdPNEZkVHC9AQuc4Nf0ZHjLK5yS9ovvR+Tf2HiIq/I/uLLaroQSI 2ZVbiIEzpKd8MjDpsPXPrUemeJPD63kxneSa5u4ZIoBDIBIJgh8sFDyVHfH6130+KcrbUVUjf1X+ ZMcoxC15H9xXs/EM9s3k3U0QK8SoVzJ15Vc/l61sXOv6TboLjzVminX92zDZJGRjdwCen9RXfTz/ AAFXVVF96NJZfWglFxMy81Cx1CSN7Dz5LON90Up+RpGwCfl9s4702W405IYLrT76eeeaL/So5Y2h W2PdQCe3rXRUzXDTXNGaYvqlRS5Wj//V/KG1W2mjjkjuo5yWLbVfLIQcfpWjPH5vmwTOZjHafaH3 MJDHGD1PXABxX9XwzLDNP30fk1TCzutDEurOa0mglub5zavFm0twB5UmeSc1fjEJu9NkbbLAJQoS J8ec3GEJH1H5imsfhvh5vxInhpKGw+612zlupLW4tk0y+Exgswr+YLgLnp74GahQT3k/kwN9omXd KI92GbaMk/gM1pHFU9ro5alKy8xbO5ku7O4uLq18q0Vmt4Z4mw7uB1b8xUUNtK9u0slyi24PKM4W RwO4FT9cpuVrkKgrbH//1vyctJHuZRDtSPEpSEI2Qyfw5960rvRINPlSS7WPfcSAIswDjJGQAp/O v6ylXjfc/FYUrO6LNpFGtrJZeUpEj7nIGSgXO0qeoz6Cp5NUmmVLWS+mlEaC2tomYBYQOyj3/pU8 8XFWZq4WFEEcUSxxskcoYs0s2WOT1z+VVRZJc/ZzpsgFyxZ7p2KiHaBuHl56Hg5z1reM4yjYmMXz gZFklVrwmaS2+6x6DtmszW5jqdrdW1qJrCKW3FtPPbSbLmZT1KMOV/DmuiLWjNJaRP/X/K/Q9Jv9 Vt7Wy0+1RLPSYFSa8nk+cKOPmP05JPp61o6uDII42lMjIAgbOeBxgc1/YKfNI/IF8LMiFJoZNkSG WNyA4Jxx3yfzrv7dbKKWC8gtU0420iTo8DNgtHgoJBzxkc49aio/eqa7R/zLowbUX5/5H9Un/BMb T2vvhNpUxtFSC9eGWwESNH5xYFrtie65wwz/AErgf+Csd61l8KtQtJYv+PaSTyJLcebPIsQJDEDs Mng+hr+YcgkqviDKSWntX+bP3PPYShwlGD/kX5H8lvjBZbqBbqzje1jTTQjomYiwCghivQELkfTF fmN8UtWh0bx1q+iW+iwT6E1j/wAS/UGuvMVZ3AMgO3pjdkDp/T928WJNcOQh/eX6n43wLT/4V6j8 mf/Q/iGmjh8+WRggk+0vlYpDJtG44zn+VJFPCk5YdR8pX+574rDZS7m9Z2kjol8kG2MkLXO9gdiJ vaP0b269a7T+woofOW5guhvgWeaL5leJDgqQOwII5968vEO8WYt3NCSc3Kr5UYitwoFvyRIQOOf0 q3oaeTqFlI11PA0kwRIOrSMDwWPpXkVI+60zCsrpI/QTw3Zw6hp8awiD+1rcJNc3ch/1ykAA+54I I65/Gux1fw9dpHCNRt5re2v4vMspkzClxnjMZ9OQOPWvIxKbR1YZWvc//9H+Puey0iKKzuYr2cWa ENKWULNuUEFZB06812HhrTxbfbNRtI45bmVo0WYSlRHtyQSP89PpXz6l7iOSC92x22p63qFpHdI7 nULiwsWvJNNjn8xNvTdGMnlsHpXjmoR2fim4ttZu2uUeGw2waerlo4GkKmQHvuG3HH5cVVGWtxyX Q6LWLSwil01Eu5rqS4tATbTwbI4iuMhT/FjPJrG1bwlbajqOlDRbxbXUWt2V45X8q3ZiM4BHOflG B7130Sjyq706+ltbhWLPqVnM322JUJDLnOV78cZPvVfQtMuL28MdvFJcXSpmG2iiJDH3NehFfu7m cV7zR//S/mC+BkFxBY6jDFFmGN/OvI2XeInZQhKnqCSR+lfop+zNNHB8R/hjHMZbe3s/F9vdTSSA KbSK3lDdAcFT1z6V/XPAr9r4eJdoS/U/H68vZceUbdZx/NH9/HwcuJvEHgOxa5hiS6v9PiuTchg4 dmgCo23pn5cmv5V/+CtehTWPxWu3uYYohFZXGo290XV7afLRIzDnAl3RDHfbxX4j4Sv2PiDUg+sm fb+Od5Zfhqr7p/gfz9ztalbi9uriSUzSGZbm6PlqoOAqhT0HA496rJpNtcOl15pmfcHljVwRGMDG OOh5r+2aMfd0P5frTV0V7t4Une1t3RZjgpExBlIzjO3rjrWo1lKmlpBI5lS2ZriNPJBdGbbuCkDO OAce1aGXNaV0f//T/nLl1F4DpsnlL5NxGyuGBWUsCMBfwJJFSTaFc6xef6I0UFrZRrNqEks6xyEM QFEaHqTnnHpX+l8VZWZ/GKnI6Gxs2w+mWUgWRpVihnuXEcWTwQW9OR+tZt/oeo2nnNtG1GKXE1pN 5sIHQ/OO1M2jLqijYWkcgkEl1tigAMayZZpTkDGfYc8+lah0lD59ndSQFZYhLHskDKDt3gZ9f5UD uyHT9QvvDD+fp95Osc8iz+bZyHJZAQASPTtVi0iv/EGoXuq3U95dneHluL0MNznG0liOfqKBqUku VPQ//9T+fPxboNxZRWl1azw3t1KixpHbzFxEhKlwRjqMjpmuNEd9JdW8EMEnmM+JSYz8474/z2r/ AEwt0P44i7M6zTmltYjFepBPBOJIoh/y8RHHDNjoATx9Klt7edNy/YLWQzRM11dqMmGJAeSOvPH5 1g1Z2N9jmJbAXEjXUs97b/YpFltDbpuAKOHAxgk57gevSusvNOfW3M0Vxc5SKOSa5ZP3sZJB2MDn qARzWnIrG67lRbS4a4ltoIHIMZj3yArG3brVzRNJutPty1/IxkSQjykPmRsjH19j0+tS4NI3Tukf /9X8CNfSzvNPa3W3mtTColadZio2j+EnAouPsd1Z2SSSNiKLyokkfkjvle//ANev9KD+VI6RuJNF bvPGsdzCgSERxJEBEz7RjcV6+nJrY0mPTIre6XUInuLi4JVWhZUwMBcvkZOMdKCFKysPu/stikX2 GSTY67D55GQR/k1zGrwLc29mmnm2ubqWcG9ZnxLAFbJ4HqB/Ogxle9kbVxpAEIZppbGYRA2wjXHX 69sVhliiS2qzCVFBSUluNw4+h703e5mf/9b8AbIX9lAskvmXMRJSNJHJEfHBH0xVZvFd5aX8STMH sbScPPGgBe3BA3c9sgjiv9KbM/kTm96x1Gs6it7NBdWx86BIwlksoG+NGP6ZznArPmaSzVLKeKyu 7m8ZbyxMZ3XFpjjAX1Oec+opWLJLSdygt55o0klc5lkUqWJ7cA/Sql7pitN58BR2j4lRmIIwOGI6 VpB9BSdkFqLidjEIrZnjH7xUJLD047Grd1ZwvNKbNptiwKC1yNm5xwygD3B/DFWndGB//9f8GZ4W srQEjY7QZLHOxmx0BrB01bi5ty0jBpifLmMQOxu1f6YH8iQ1R0A32MJtbuI7XPXHEgI6Vm2sTpqM m1VighHmrGTgx+h/lQTPc1vJtJ55GV4VZwDcMU+aXHQZH9anZYVQwyII44/nHmcIwwen1rKasyY7 oq3Fxb31itrPILWMjzIQHAaMr/LOMY461SurmMahplo19FLO8Hm20kfEKbFz8xxgsB65+tQdEUr2 Z//Q/AiLWNUsLovtiuxeboZWlXIGcHOe3IHNX5bqZAv2yKO3l6lYz5mcngZ/EV/pQfyVNJWsSyTZ E6JLc2sc4Sa4it52WC6KggK65wQAeM+tZEbXUAZ7VFmRuYoi2UXB9B070Ci7Mi1fUbG5tVR4o7F7 fP2ieVTGzN/dJI6elWNM0rRrzTVu4d32l5mQHdlDgA5H4k0HTB2dmTW4YpcRX00sKo22PEeZSV6c +nvWquyaaG3jjaWSWLfGhG3eBnNAm7tn/9H8HbayWFJpY7LyikjOfJTmVu/PcnFR3MWsSxy/Zpnt 4bmNQsLjy2znktkds9K/0oP5TpkEU01rLJZLGZPJIYzKQ6lhweR16VYtr8yXUkTRyTCM+Y+RhUI6 0FyV1Y3NWjl1qGPDb9karFEuFzt6DFVo7yJreKa4tWjuI1CbFj8gZUYBx+Az+NKyMnFoi1CeCDST dlBuupQs1zggW6rk5x+GKrxeH7VLX+07fVhbTXdstzbiVgsU54wApHUjnH8qGloTK6TP/9L8GL3U 76zvkS401TFIqJJcRHlif4iB7YOaddxWsKoPs0YjVTOoVcgFgeeO/Jr/AEolBXZ/JkJWiZsFoupf ZbKCJbceYRl22IdxJJJNaqJcaZbMi3DvDE5YCVVkAyfujjp6dahwXQq6vYpWstzC093bzKGuOiKg jVOx6etZl2+pttK3aQuZVMzSMcbc89KzasCaexp/2bFNdx/aLneThmRWAU/l2qtf3A0q6v8ASElW a3v7YLaif93JafNkuj9un86Vrpoq/wC7aP/T/AyHWrt7G00iQtfJGfKi85+EB6n6HFWdG82JXt7y 4QyxySeQqYjKRAkqoPTIBIr/AEpw8bwaP5QpR91MkmSwSFLuS8SUrJ+8KqfNh+bHzjH61D4g0gve zRW3l3FmVXZK2G84FRkgdutCWtmdSjeNzE0GSfR9VvWvJLmex8jyLSBXM+cA8ex7cV0doZJXjVYp vNugZojIm1yPQj17fhTlFLYfs9Rsa29pqM11Fp4kknjVbmeaQkSFRjIAx0OeD+tQapvCRyujiJeS UUkenP8AnvUlOKasf//U/AxrN08qX7SUVhuWER7Wz/velVrK8tbmaWyuQbeeMljCVOCM4DA9K/0o P5clBW0KF/ZXtreRrDe3JtC+4tH1GOdvuOKfpF+qeIfMuh5ljNGUeO6txMOFxxnkZOD+FJq6sZF2 G4ubffYCYzvLNti83gopbufYcc1m38c7E20EaLdCUxBnbgPzgE+nf6Vha2hDgrNmnZW5sl8rVpAt 4kIy6fMm7jI68DOfypq397LO9tZR4jDDNwo3ZzTSvojI/9X+fs2moy3ytcNcmwDmO5mWIKkTYOMN jvg8U6fw1bnUormK488yxh3uSP3isOApPfFf6RSjys/lOCW5ZGnzRRSBZ/3qy/dz8rj/AD/OpLOK WEST6ja2soaTZAMmV48DnPpnjn9ak0NaxiS8MyNL9mjmGCFb5owO5qdbS10+1PkO93IJMH+62e9B cNyBVVriT7LDFCzxgxR7jiSTnv2BP86z7u3uo7hBeM8MwGJYYZNyA9gKTV1Y1P/W/BhLVLpxvQbl GPm4J/rVWx07TzrL295MlnCsfmpMzs/zdgVHYmv9GlFpq5/L5q6vfWiQW2nxyPJNHOfMmCEQsCON p71WS0htI2nklKowyPmweR0H862MZKzL+mvBpEUt3IC6Xn72OWQ/NxgfTHHSrI8QW93bySwC1l+z y5aOSNX3EY4IPUdOOlTJN2sVTOD1WM3Mo8m1tSl8+24Ecg323OchR0yc8V1NhdWlpapbxiPz4Iwo jJwzdtxrKrFtM0w38Rep/9f8J/kee1nEcXmpIG+0N0tieNw4zxmq+o+JU1O3eORpb64Rzbx3SDai hSeeetf6LyjrZ9D+Zq0mqkkZ9pIt6gVIgZrdv3pmGdw74H0rOlne2urhYoFhtd+6JUOS2ckj8Kwl Gz1Jg9LFvTfLvJZEuIY1T72f4mPp7Ut7bRK8Uez93vGXA3BAO9UoSZSdzRu0jNqY4NkI8sKd5G48 fe/rXNK0piWwDC+EL/u/PkDRoc53HP07egqvZ+Zi9z//0PwGa7u7dJPIKxSvHiZ0UIhA7Y9DWZI1 zLscOHMo+aH7x+oNf6LckT+Xye2tIgqpGrxyxt5j5GFJPPH5VcuJXWPYpG/OHVjhqq2miAoj7Lp0 c8irh3wScEDJPrWuVmkgj+1t9m+XdJHG3LqRkZ/DFSoJAYkWl6POHiQy3DSTEtFPwAQcgAf56Ut5 ETqMawwmK5YYilMeUXbwKdkjSC6n/9H+f1bq9tZXiuMXt1bW6tG4KpDNIME5HTnH0Gao+UdSb7Xe /aLNYOXt1bAfHIyw7deBX+jB/NsYpK5pQT2l9cxpgRzOoSOREIjfaMAEjvj+tPuJGuJEjXbvgOAA MKRjHIpNXVh2RNFpn9oT2WLlYVWfE4dtkTDBAyfrULRz2UrylkYKWASFt5YA46+9CSWwJJKyMEQi 9a0vklaO5uLoqsVwNpBz0Oex5qPULa7kaaYTLAUlH2mJVAiO09OO1OxM9rH/0v5+bOC0a1iluYEl GRIvYjHp9eKkgkjVbjyIWSLB8mJVyMk+tf6Kyjc/mObtoWrg2lvbxTpMVYxr55fC+W/dR+lZs9+q qYYZMbgpdHAeRvdTjIGc9P1pKGuooy5dDNhgvEnlmyCrxbV8zOVbIx+HFGo29zAi3rBG8pQWhDAK /wD9etDS6tcrLG1zBuKKivhg56girtpbpP8AaVaZJDBEDsY7XkJOPlFQ4K2hlzO9z//T/noWxaaE wxSpFdbd7xhwDjrjmsp5XtiYr8vNGMBVI3quOBiv9FPZn8wNts1rCee4RZJoEOx8QMwwyDoBVm4s pYrlZJCGEo6L2PYCpcWg31KsA+xJfhbRLmZoj5Rc4554z74rJstRjulQTwD7T/q5Ys4jjzwT749/ SpshFy4d4gkcDKscZzgjg/4U8JcXxbG0xwR/OQ2cDpgD8aVle5tB3R//1P52JbeOOONml+YvhYCp LMAOtUp2ub7ctkwdIEJdAccDGSfp/jX+iB/NCfK7mza20jQRssiFki+cMcEEdazJZfNbEqou04kC fNjGef0osPnd7mnNbRT2sMcE7KXcYKHaygH7v4/1rmZLbLyXEV480lpOYmV0K254B7/e60GikmW7 O1lvVCcIxbLyZ4UD0FWoBeW86wyN5m0bfOk5bH1oNOeR/9X+dGWVob7zY0MglQK8qj5fl7U4Gacz O4Xyx0Tq2fWv9DuRH85c7JZrcyWiOVVDsO8Htj0rG01pbqy82E/IszIWUf3WIOfxFUl0RXOjL1G5 k0+e3MEc0gncwzPENyxZwdzdwOOtLeXlvLJHF5RYABIrgDCPIT/dPNWoN7ic+xrwXcaRw2r7mlCA E42knv8ArUK3IiuTDtkVuWWUr8vHbNVyIhtvc//W/m/u4ZrtVaOUxmNgxdThutaGUEqLHOGYKPNT pzj0r/RZQSP5vITOhnaAZLLgtgfKM9P5VaSQRZZV527W/wBoelPlV9hqTWiKbJFJd/a/MzHBEFSE IFWPHJ98/wCNZ7alaarf3UsQRJg/lyRovl5IAySPU9T9aTgmaQbejJXi06CIkXLLdSuCYZMlz/un p+FPKTX8d5DJMttFFCNjbyGk45x6GpcLLQtao//X/mt03TYrVLi+Zy88zBHaQ5IVeAB7U3VEtYYh NhmXcDJs5CnOQa/0UjHufzuTW2oSXsGWROE8tZ1OJHA/vj1/wpsataxMpkaUMcgO25h7Zq0lFWQE F8t1PajzAgjPAHYfWlso7L7MkYRZJGXBmODk+gp2ArwJGbhYmZlSJyTycNjPBrbmhjktonUBFL7E CtgkDr9KAP/Q/m5hht5pZo3Z4xBFv/eREiQgZwG6c1z329vtskbxqtsgDrgAFMH/ACfwr/RtRvHz P52uk7HX20FvLHNfwS7gyqZd3y9cgELWc9rDK5kSTzsnhshhn0/CoGUrwRpbSC6j8+SP57ROAC4I wCe3Gar2QgabzntRbLcAKx8zfIpAHA9s9qA2NEQbI50lull3YCCUjJB6KBT4NORD5o5aBS2F+706 UGM3d6H/0f5pr+4vFiVYpfk8wuFVRlMjHX8KbYSyRxrBPLlm+YK5+c/5xX+izinufznB9CS/SB9p f/WsQileMD1Jp3mzRbCjfKODj7r/AFocU1Y0Kctxcbgg/wBYz8MB1Fa0SeWqmbEhfrkdDUODvoJN PRFl7j7KgQxiRWO4xgZbj0qza6hbSwSLNDNBK5AjYj7nOMEYqeVpXHtuf//S/nbtbYMhLO2YfmLE /e+lR6aZ1Z/MG9S2Dnk/Wv8AQ6Ubn87cyLM9q1xKpjcKu7G09z6Vnz28EcwLON6rjnqfYVDg76C5 4lK7Nz5bRRwPCv3/AD9u1iBnofT/AAqgum2rJb3U8yXEaYlUuQ4fHQn+dZ8qbuOUrHTBjOIpruYs I49saluFXtx6VlTXsscbrGNkZyvHOB65rOUFyspT9+J//9P+VDxXci41bKQfZ7dPlMrY8y5I6sef 8iuURoi0hjdiTJhgf4QOhH1r6vjqafE2LXab/M8XJY/8J1K38q/Itf2tHJOsE4wrDYGYbVGMAVfS 6feEQ7o8YD54GP6V8W5xuz1uR2sQXLswYdGPyhgemKoozR8cvjgt/DWE5q5UVZWNVJ4sIhVYW6MR yGHY10Vr5f2YmbBUZVWPRqUakV0HKLeh/9T+Tu6Z5QwiJeKMlmKjITPGf5UqRxqoiD5yMqSeteXO rFmTg+gy1t7iJXZztbzSEBbdle3NbNoXmPlOpTHGc9aI1o3uNQ01Ll4m6NIA+2P+OTGcAdqpW5jg AMf7zPyEDsB6Vq6y7CcGtjQtbmUM4kLPBkboyMhcdx71cW+tbzdIDLAsPy75UMYkx1PPp0rCpVjI SjJn/9X+WOWTmSeHhQN27OR2Ga0ru83wLCYRcmSNUDKcBc4GT6Yrw/aRMeSRPCI4Y1hhZExgFBjJ q5OolSIXipL5ZLxF8EpjgGplUi1YtRkivZx3V3LM1sYmNqPO2EjBUEDoetbDTC4d7dQsE5HmN5fA AHX+VYurFOzNYpt6Ftp4o4TGmyXIK8EdRxzVWG51CxinItbN4yw2vu34PcE4xij2sCnGR//W/mUu jJhLtFTLjEuBgY9KsWsgkCBACqnnvtPoP896+d54hY1PKkZd8kfGPkOOeKSFJmQiRBjaeByRj0o5 4gZ8lsI4/NUEs7fdxtYmpoRsGwjDAfxdj1q4zigL9jPM7SQLkMnzDK4VgeODWi8cVuGuCuxjhWfp k9ADUucOhm4Nu5//1/5uJEEKzXYRnYoSsY4BwKWy8R3MNrND5NunmDJJ/eMAM5Azj8/pXzjnEUIu 1iBLwX1pMFwjPlRIBggnuasW0ckcUcSojRxoC0jt9885/Gs70+50K9tTRhZJRsZA7Id0bHnyz7Va tjdz/bC8cRjRdn7378h4OV+n+NYtxuRNN7Fdo2S3EU6HBO8KeVQ1E7C3iQwpwzAMV5Ye9VzR2Is3 sf/Q/m/mbyJRdzYdI13GJuS1JNfNN5V2saq0hAk+XYQOcDFfKNxatc6C1eOSkTQtsWUhW3Hiuy0W S2EE+n6hIn2OW2bymcfOrgfKM9un0pKUYLcwaadmc/fQhLhJQvnrGcxbeCDgjP60yB5Lx5NoGIly 4Y7Wx0wB3pKpBCFmktZo5YopMGHhyvO0jt+FV4Z5/swV5WuY4vkaPGWxnPA/oKPaQvcdna5//9H+ fG6gjh05b0DMYwqQ9Wcn2rmnnnmlU/ZgjKBtkB618g50wN1Y3RSs3MhHQckGqbwX8qMLZEDK2G3y eWuPrScodGNJvYuWzRQTiyZo2YAGdk+cL9DVi/vrlVjRZmeONdlur/MsQ9APTviiM4J6gk27GDJb yPL58zF5pMBpDx+n+etWpbSdTHiQxoeoU4Y1bqQtYfLLsf/S/nie5uVHlxRRynG0BztPHQ/pT7RL 0sv9oJGuRkBTlUPoDj9a+Mc4odmMeOC4dgrg7HyOehHX+tXpoWW0iMICy+YNwAyzil7WAWYyJkM6 xTlNyDJ2n7vsfy/SrUke2EE7mWWUpGF+bkYPOPwqJVIvQfLIa92bSa0tTIIoTMv24bRvCc5Hsef0 qRbWGSK4MkUE6TPmO4GQ8QB4xz/OsedXDkkf/9P8CLe9W3X7GIxNHcDeZFwWj2/jx3qrNbxQxZDm RZG3DPJFfCxqRua8vu2M7aVjmQuB5vCKeelIHvVeKBJ4oUkISSaUEADsfw4pupFOxhKN9Bt7OZG8 iFkuRbt5b3Ef3S34ir8FqYo2kzwy8jvWsZQWw4xbkyO3S2QLbsZEjjXhypJPGcn1pbddPVTPPcGO M5aQp935ehI/Cp546mfI7s//1PwE1CG2t7eKVLmJt4B25ywz9386gt5GuU8rOxgcLjjNfGe0iiOT QrTA26ussjO/mbFjxlif/rVWhlsYZxHMwjupuY1C8tj1Pbj19KaqQ5EjPlaNYiGRdgwXTnHTNV44 bgASSweXGclQeTwe1ZSknJs6V8SRdt5g7RLKB0+XI2kCn3TxRncCMY6gVLmtjS2tz//V/BWzTzEf c6YccGQbQo9yaxbmLyZprWKRXnLb/LV8ome/HY4r4XnidBUiFzFc28qxEGKT5jnPTv8ASukTWPtN wY7vyoEB3NMRgse5NYtq+4nFPcyZrZL+eXypSgT5VYdTmpbfQjFEIzKSu7LSMcls81pCUUiIxaep G0caZt1d9obbu67hU+2XTriZ9ODSxC3LKGGHDY5GPzquaJof/9b8EI01SawtZ71IY2ljzHHBjJwc fMBz+dAjZ9puY49p+Xy1+ZfTkGvhHKLVrnQSfbFtg6wQpGUXAEfyrgD/AOtVndaYjkDAF0DuMcEn kgVnaKWrGk3sZ2rB7qKOPT7iaPyG8zd0TPcbe9UrhxDcRweaJjKFXenKBtuSP6VN49zZX2aNO1k+ xyC4mJRsbY2HJz+FJbXHn3TTySFfmAUdqfu9xNu2x//X/DKS5QoVVcQnq55x+NZkxurS3mNrO0qy NuCS8JGen44Ffn1433OqN76GXYyXDS+YVXzN2Z5Nu1ZPXFdH9sjuLrfGgjgiQBhzlm759s1paPcp ylfYx9T1Ge51S0sbS5iuJTGZhErE+TGv3t3bj0qxeF4/K8udXZxtZR0HTP5U/cuQ276iSWe63M7p IAo2HBwMn/8AVVKJF8sxwTbW4WeBjudkz/I4/Sqbh1FY/9D8C5IIVO/yx8o4CLwoFPtY41EkqTtG uBkbjk+2K+Di4o6bMdqdvMlpHPHIJVxuYEHKdhWdKdSewtmLtYLdAhQwDSkKew6dqFNRqJo1kvdZ rWbrKDbZkieOLLX7LlN3YYq1DBpsunT2t5A2oNISnmlypfdwc44x3xTrT5qkmKn8CM6GSLT7mOx2 ShDGfs6xr8sQXGAfQVa1axMV3BHLIN0cMd4QCCrLIgbbn6MOlc7lqkiz/9H8B7i/g8htsbh+dqoh YqPp1rRt0+1vZ7HSCFUxNLMpC8DgAdfSvz87pK6LE0N6JJFuJbc26nA2tguvQcGq8coUyI0sS25O xnP3QM1UXZ3MQuGhtPKjt5IpJHJ2oJFlD+4GaqWlyjXMkb7QdvIXggdP8/SqupMZr3CAW5SNwQw4 BOWqlDZXEMe8opec7IxjJobUXoZzWlz/0vwlW0Bt5nuJEtpLVAWidtryEsAcD8f0qlYXkT+fhcxw nBdTncK+AcmbpJbDxflAbiG1Etqx2B3BAJPtwePas+K5kDyvcQq0G4LgyBSxPYL6e/ahtsLI6CBN 9m7yQwQOSfsybuD6E9/50txB9ntovtV1FeEsJiTgICe2PpWHNJCUY9jDjhlieVLGJN0/LT4yEHrm p7j91bkSTs0yLhiW4binzsqMFzaH/9P+fr7U4fyULqMiRmH8WDnH6Vbglm+e6njlliicKo+7GhPq f89K/PVOyudUo8ptvJaixlv/AOGFdzbiAPp9azZZ1RYZDGhSQCRvnwAPf/PrUqbb94klDWzIs0T8 dQ0fKn2z0p8V0l2JFZJdtqN7sikhhyAPzq2tLG0L2Muwlhhnvbq0IeVTvkRx/q/QEenFXX1X+0Lf bNDDFGsgkIjXJbA9fT2rJwki229z/9T8DVvxO/2eJ8CRcDA7CriWouIpUTy98EZbbK2DJ24HrX58 tEeim1sc9cwXR+yKxVZ2n8tl8zCqByCtakfmx3sEMJE8xIjMSneWPoMdfpScdLI39S1G01jFfWK2 zWgluvOl3rhg3fAPT/61D2xuoV2mMGM7suwVBgZyazivesS43dyhDpbQiW5lnVlnO6Nd248cE/Tj 9Kij0wi6Wdb6XyyvMCkCNuo5711RjZlLY//V/AyO20yyuY2E32d7uRYpXclkXGcEAegJPFa0cl1L a6pBfTrJAjiOwRWw8icY4646k/Wvhm0tz12tLFS1khWMniOVSFI9B6ird/FbxakBYSx3wliTz7jB QrxnBz7k1DnpoMqXtjJuimYIY3OBkchhjG2qb2dzvSBUxISP3kh2KAfc/wBaUZW0YGxbagbON7a5 tPOLqY/NDfLEf72e/Ss/7QFmyLjyjM3lxox+VzzxVTly6IhwT2P/1vwjNzaHfbtIElhQMxYZRyfR qqalbGW2SaCVJVmjMEkCyDcwbAzjr647V8FzyWzPV5EZqfZdLs41jTzbtQAssnzMgxgg1VMk1xdW U0s87NbsREgcshDdVI6YJrtp1J23Mp0Ys6WW11SKxuLTS5zp0urTCSeO3USJuGPvZGMYGDmucWwv 7ovZXMrs9qTP9ojlWMfJ1Iwe2K0deot5GP1eL6Ek1u10yyxhJ2jXZh2ypA5NYuoWOozxx3CXMkEd pMNsEUhiWTjGCO4Hp0qfrVRPct4WNkf/1/56LSYyRW+lyMItlw11LslP+k5x8rZPODzXV7LdpLd7 eF5Lu1fzFnDNkAe3TjrXybxtRLRnU8NBaNENrrN/aXU19BdPGIZPMcSHfFJjgjaeO1Nl8Q2C3GnX kLy2uoXQZ49ittYofvBh0PQ49qy/tCune5pTw1NLYu3WvXCRmaaeWVpG3SSzuSx9fmNMe9uJYkkh YSH76gt0rSOa4pW95l/VqPYtWXi67hljQu9uLZv3ijMbMcdVbPFZ114ku5LuaSE7BPwSZ2GQP9np 6/WuuOf5hHaq/vMPqFBvWKP/0PwSttf13RrxL/T9RlAuIvIngO141Qg8oCOCTjJ9Kf8A8JNrVsL2 VnKqUwk73JErbsls+wz09q8eHEeYx052dTy7DS3iaGjazI1nIdR1e5nn+e4t2djMCxwBHjOFHH6V j6rrt+HtpvtWWt3LL6njB4ziuunxRmNNaVHf5HPVyrDS+yQWHjmWW6ScTCO5tPnQyQ4J9DlgentV u98ZXwuIF8yZ3ZjI8lu3lovpkjtz0raPGubwVlWf3tfqc8siwcteRfcieXxfrIhSAXzLaEH/AEVe AWbq2evaqFt4lvtOtly9xckuVLySbnTqVJz1HrXVS8QM4pu7q39bGMuG8FJW5T//0fwxs/iPPp+m i+86H+0VXyrVvs4ktopfuqWX2PPPGRWc/wAStU1CfTSZ4p7uBt8zRP5wlkQElyDkA9Rj2/P1afiZ mlrTs36f5HlPhTB3vG6NyD4q3kMV1cziFppQYjM0ZhVMnH3OBuH4DPasVfG13LdyT7EdDGFt51kK yW75zu29DxkfjXZDxQxyXLyL8TP/AFSw+/MzYl8f6jIgit71IpHURXBnQNuU/wB3pz7ir0PxHbQx bWMUEbtcxNF5tw+UjyfvLxnPNethPFKqpWrU9PL/AIJhW4Tp6cktfMSTxxeLKHnhH2UHzTdxyB4+ Byp/wrsJfirYeRDbroVu872wR7+P93Cw6BjGMYcDuOvcV7NPxSo6c1NnNLhSeyaP/9L8ZYvilbWk ksenSsWuAIb5FA2DDbsHnsQKqz/FWG9ubvZaRrHC2xIw+ZIwAOeOv481+x0vEjCTipSVvLW/5Hya 4ZrRdlqdf4U8Zf2hNlLJ5neEhpTgQWyjHzyDOeSQB7kV7Hpt9cT3KQwLaW1yrRvFcsP9HiYMNu5T kcnHWvsskz2lnuX4jG0vhScfuV/1PLxOXzy/FU8PNb6/e7fof18f8E4bG4s/g14Sv75CijRxJaCL GwlSElZwOhYu2Pb6V8d/8FY/EGlr4YuNF828eK51KcwtaczIzAYUHupyRg1+E8IpVOPv+4jP1Tia bhwwl/cR/LL44v3OiXzPuRGt2juQAI2ReByT0wRz9DX5S/FuKGz1a/lE8MkLSDyVtR5shYqNxf8A Hn2zX7r4uS/4Qqcf736M/I+BY/8ACjOXkz//0/4fNThmtLoSW4SSF5d8xZvL4Pt61diC3Dbo1Ukn djbyQPU1g1aMjWs/fsXVmvU4haW2NwPsyvCNpIOMgHoO1ehWDTSTxPDcXOY7ZbeVZn3+ZhVDBm7j I4HYYry62zMjcea085t7KojUZj7jHpT9Nc3GoWhtU2sdStkRmUusYMihycdsZJ+lebVWhMo3P0Ut YdNtNAs1srie11NreG4MsKrJFLuRWKsrDI/+vWi8V9rtk66vqUtqbe1CCSZ2jzEmdiRDnHXPyjnn rXkV/hZ1UYNM/9T+N23M+oQszvaG0uGLQbWB8tePmZRyCfcV7R8MWsItUkjvNRt/7GtbYko0HmC+ kYgA7evyBCOP7x64FfLJ2jymLXLDQu+JYLdL77VBNJbvLLJFpd7DAf3S5GVP+zjBIPrXNanpYae0 kiKWluEKmO1UO07t1dvQ559q2oS0uxSRP4onUPawwRNL/Z+mxosxj8tzkENz9c/hiuRjSO70yS6u 5LmwukfdbR7g0qAZG4yZ4zwcda9GjK9gaseIBNRsPEVxqMepXC2ssTWjJJNuSJ8jlfQHnPpmk8N+ KtQ0vxBGtul3IpujDcXFirO0Sk4y23oD6nivVX8IhJ89z//V/lv+CuueXH4ntlvnCGSKaXTvsoe4 ugHiZZNx5UAqB1r9BPglqkuofEzw1pliWstPS5ifUWjQzXuwTRF/LPIO4BuPTNf1n4bz5+Amn0U/ 1Px/M4qHHFD/ABQ/Q/0Bf2blitPgv4Z81p54bSxiLz3TKL6TfCoAZRyo+XgHj0r+bL/gsxo2lW/i P7JeW90qzXVrHp9rHbm4lmMkiShuOfvRoQfY+lfinhrJx8SpW6zf5n33jVFSybDt9LfkfzuXlzDq b3FtdWKmK3DWqxXEGDFtY4yOxyMjPtXK2dlNaN5cTqzIMS5Oxn+g9P5V/b9DSDR/KFaRZ1GwsppP tsFqIr0IpZg2+SEAcKD6ZJPuag00363z3Et3eGWW2Fraw8iCAcndsx1PqfpVGXM73P/W/nVvY1S6 eOVx9qj+cmRDkj2HbvWUty1w7Q2+oNEzjMjQ/I7BSDgZr/TA/iuD6Fyzv7uW3jsTmcwTm5HmHKyH j5mPXI7VoT3d4izW8Vq8MPk70jDZWTcMkgemaDop9hdJvYre3AksVmlIKsXXeFbu1LpugSz3dxJe 6tZ28sheaBCWaMJjPlqRnLY/Cg0KFhpj2l8WtpHudP8AtO0QXELRrnPzDaegzW5cC9kVtPlvpIUe UXBS2JiEijPyGqitbMaV0f/X/nksVs7O6+0+TeT3UyG3h+cyRwgc42n+8QvTngVfsNW0/Uvtt1HO bdbJmtryF4tmJc8BD398V/pnNWZ/HMU3qZV/p11aahCVuoSsyrN5ayZIzyFYdzjt71JPrA07zC0d yzywtAzwJuG3jKHnof8AGosbHRaVfLqekrb/ANnGGRf9JVmx5jbcjafY9RVSOa2tL24vxDJE168c dzbrN5vk7fk3YzjgdcdhQbr4UbN7E0F08v8AaUX2KW7WKxSFlaSdNmSx+uCcf4HFO0kuHuJvMuDH EkZdY5TtNxt6hPf64pNaWN4fCj//0Pwh07Vo7u3SLT4ba4uNQszE9teoCLdycAMxGARjqOlc6+mp F515qcsX2+wUlYUJ8hQSAdvrxX+lFraH8qppRuW7eW1nQtc2dvY7ZBDFdmUbpgccLnofan6i9vaw yT20hl2TLHHDHmSaXOeRjg9Bz7imk3sYjLnzf3cjopQEM6scFKqXkttDOn2aGP5v9bJ/q2IPvQ01 uZOXvXL1vrNlJdjTQZZBJAWWe6BaKEDAxv7Hnge1ah0XT7bTxF/o0avGbjz3U5kAOSo9zQr30IP/ 0fwdjuT9ks43k8mEv5kUci5yOgyPwqpquiib7SyogmuAHmCKIw44/D0/Kv8AS1puNj+QL63I9N0e Q7nhyEtLcs4Zx8u30zWFLpVzdXsN2ZHCvdA3FyG/0iJM9EHTHHT60NPlsbrVG5eRomoMgJMEU4W2 n2YLgdN3v71u2ehXM8lze/aI0VoGZQhHGBzkZpwVlqTP4SLTYr+yuXlAtiHQoH8rdIx6ZbtwKTVb ee+FuYLyCCe2uEMsKqPMliJ+fj+pqjE//9L8Kr0rfl7K3eKaxWMnz5H8trcjGCB3yAec/nXLW9ob XMMc8kqMSd8WRjHuK/0wP5Fhax0Tyi4j06/lHmwaZK0klqELTBVGMt6+3XpXOpq2pXt/DqsUMdzZ s+y4sxBslliOMHPZhxxQTNKyFiuUE0l6luywEt5kE6tFtwe4OCK6Gylj1CFx5QYFeHDbhHjtmplG 6M9ihNaWV9Z+SlvKmo/afLACYEiDI5NZN/NIn2fT0sYkktF2rexIFO3HRvftS5Fax0J9Uf/T/ACz kEsa2txE4aU7WMi7GB9vr2q/caVqN0Y4wg8mM7YSrbpmIxjn/Gv9KbNOx/I0pW3KUj3Vm8D6lDJD 53yGIFXaMA47f55ronheyjhm0yBnmli3Kzx4tlbnbu/TtmqUHfUmMruzMzWopIIonng0/UZJub23 KC4gjfqfY4PIHtTPDqwRy4KCWJ16Rny1iPoAPTP6VbimrHRB6WNnUbeFrYwxHbK75R2OWHzAn/Cs +O1uZPJiilZruM+XazNII44QT84+nt61k1Z2LP/U/C201PV9PtjZXrC6td3mRrCu4o2efxNM1HVb uW1Lw2qNIpURrM5jO0MN3Y9s4HqK/wBK0k4tn8p0+pl3MjS6ta29nF5Nu1qtxcvs2sz/AMS4P4nP rWdeX8Ni0yJDcSO8nk+ZHHwhPGW9vpUGhe0DUJ4ZZku2lKiItHInDxEdD/8AWq5aTTagkiTKRC53 yXLkq0fPGfc/0oFdGjfmOfSHgmkiNpHIkCQ5AmlPJzxyRxya5HWEuNSSOFzE0FvGEsAwwYiM8f8A 16TvzJIxqytFo//V/AuGa53x21yNztEP3vVSR6flRdX+o2lydObTfOimhL/acHzIiMYBX0Oa/wBM HG25/JCsqSYBZ4kUllbJDFcZCH6+1MkkvZI7maeRIbRVwqEnDqByWJ756AelZuD6AnZ3KW5Lq2mj hlkhZApiAhJ3bxkE56cDPNNmt7iSxjiWIyXDzoJbqVtpdFI3cdKzcejEdJffYhPaSW0L24kxG5I3 OML1z9Qfzqk+jWlzcG8v90vkjEY3EEgc4/nUKGlmbp3g7H//1vwOtLIo5mUGHZJ8sbj95sPIx65F QarIs89rHZWzhiTHJNIRGm78a/0rw+ikfypQ1oJj9LFvbC5GpxwSQXR+zInBZ3ORwfyqZ7uKwtEh haWe9MpEayLuiRRjBY/piq5feudUdkT3DvYxWt3GF87zVmYKmSTuH+FQXV/HqWol4LuOzt7a2KmO 4PzTHhmAwODnOBTlFMZf064tishnWSSIR/umT5skZ7f560nl3eoanZ2puooNHILXEU8nlru/hbPT j0NSqfcNj//X/Ca5lcRfZ5kiZ7a4KJLCfMV16Kcj1GKzoUsxNd3M8au5O5TBHge4J6nnPSv9K3Cx /LfP2JpLg28bTBUCKQCCRuGemB17VlzpcjU/7TvXS6hmtgLWJVCLCQMAkj09Klxa3Mxtr9pmkN3L BFE/VFc7lGP6cVrWctlcB4ZbeP7SsvmmXytqjqAQfXgflSsiJStoVb6OG4nlmUpcxbvJkZeFOOKt QPBajZFsjm27o4yMr7ZpWSMvI//Q/CS/1K4mQ6fECLScebdgJwzL0x6dTWGs99aRN9lskmQMMF5N jKM8jOcfz6V/pPJaH8rR2R0Uccc0O9dm9sb9p6H2qhevbWibBhyxyyL1zWAzDt2nlmkaCykjiCF/ MJIV2HB+tX4mke1dGbyRj5ju5XPbNaQimrsunvYZatBZOksz3DzwjYgjJaF93QsO2PX3pLC0M081 yzl5LiYrGNxIGMc8/WpkrM1P/9H8F1crLJE+9ZIn2bh0P+f6Vab+yZ3zeTC3uUX5iB98dsH+lf6Q H8vlXXJI4orOP7M1xaKnz3CHy5EHtx1PPPasy7fTdSitoLe4ubVFQtBFcMHdmUYwTxn/AOvRYwbb JbnTJE0yCA6mt3MWLOkSMPI6FRg+vPT0qGPS5oY4QyMjRP5hB48wEDjjqDQF2tiK3sb+3DXqRQr5 coDRM4YnJyDjvwKluI7aa9e6UBbpxvlaP5eP7uOw56Umr6M1w75aqP/S/AWe6ksEVFErvLzt2Egg nHWtmaCzgt7XMKRMYwSiDC5PP9a/0dqQanZH8yV/4rHx3htrW5+z2kDuiYSR8gjOfT6e9ZNpNAwm a8RVl2gx/wB0HPOKxcddSIuz1M6Mr9sYxykB3y4BwEGOw/z1rRlb7HbsXnSdZGOMnLjJ4BpgpcpF CjyJu8svEAC5J4UdOasR2LPKTEipGqhgw43fSqUWyG0tz//T/BU2kd19qNzKLa3WFViC9WYcH8+t Zs0MKtFDZIS8X3pScnHtX+jygkfy6ppleBb1Lttzu4LZ2bBlCM5/D2qneGOS7uJpZ/ImuG6N8quf p6/SqsthuSW5qTw2w0xZJRHOquFkRj90DncfxApY1nuJIGEOI7gbEbGBIB056f5NTyRBNPYbdaet q0c8oj83d8jxnBUA8Z96tl5bpxscDaOWPUn61Ps+xvD4Uf/U/n+m03UFb92u/wA0ZjZT8x5x/Sr9 tEFtVe+PlBGKT70y2AepFf6O8iP5sjLSz6CLbQRxxyWQUxMxCEcAVMLZbcyOuGM+NxxwMVm01uHO ijqYeexmt7SUxXHCxMBlQD94kfliq2mJNFd21m5VjHCZGaYFYpQo+bOO5pWvsS5voZc2qJ9smlFq Y4oJ2XyTzjaSOO/OD+dTQus0kkGwLJdnzSHOEPHAq+RkOXVn/9X+fyxWS8+0xIse2xiLyxiQByB1 2jvj0FRL9peIyxSi3iGWGV5wAeMY/Cv9GWmnY/mKbTehhy3mGmllX7QXQqY87UU44cgdxRplsJZ/ 7Qlt2luQnliVVJAXPAIHHFVyMg66SOKeDBZIJoss2WwpH+Nc9dTwTXFvbuSY0ceduGVk54GK0cU1 YtSSjYs6h/Z6wKlqjqY3Dhc/KDVGxtPNvraV2jheSQIJmGBGDxzjtzWLi1uQf//W/n1ube0i1GWN 1luJo2wk0B2NJ6YPoao3mp2Elu1qkDm/kwREy7pI9pyc/wCNf6MH8vkcbvPbxlEYvtKzxqCrJjuP WpTePKq2skriSMAqrf6zjuaC7rlt1JHhmlRXiuvJIBSXKbvM4/SuUgaS0nlnubG4khIZt0TASMcn Jxg96ycLE20udFpqXUkBuri3h+y3EB8lWbMic4G4Z4P+FXDp15JbgWWIpGYDAYJ5gHJUe9NQ1NYK yP/X/nijnWJI0n2+bHLgGRQRmsm5tpLa8YWmAJPmbyRtXnqe3HWv9F0klY/mc2rOO5+zyIqp5x+6 zH5CKgmS2kk2QxGN1+WaTPyO4OD/AEpOKYEEi26Mba5MitNEwt5IDxG2ActxioREBaJZxu0rR4SY tgMx9T+f607IB1tE+mecrBmmXlUPBXP/AOuul0eOLVmitmRIriSbyzKzBVOcAdelS4I1c10P/9D8 A9V0hNFlewmhWPymw+JA5fPOc1zU9tN5N7NAFVbWAzL5jY8wDt+tf6JqD6n83NpPle5Xh1qzbRdN S43y6hIxWUhNkYBGRxUmk65bKbvTZ7FreJHLpcRoC8hZc9OMgnr3FXGKiMxb+GALdiIeXHICyBjl 9x7j8a5zSNQVJnt3gZ3TmFmX5SQetaKLYGvdXDSXMl6IljZQEMca7Y1KjGRU1jqUGpfaUVyhtsLI zxkKWxnAP9a1UUgP/9H+biS8ZT5Sr8i/ecdCaqQbpbsyqrlvu5X7y+hr/R+y2P5vL62s9rdOkk5l huJP3crqEYFugY+uePxrWvoZ7EXlrPxe2OYpY1IbLrxgnOBnj8xQ4p7hYoWclwy5e0G2RMOTyoJ6 Y9+KzrC1giu5POheOYzF3k27d/0H4VDhd6FwNW9ubDTbiN7sFhJIEgRYTPLIx6AKASayVvFiN1cX cUy282DgqRKuOBheoz6UuRlrZH//0v5xTpv2+ziurZj9nEux1ZgM4BOCK506fO815KS3kSbYliz+ 7GByQPX/AOtX+jagz+dyxYxw2m6AbQCMgnjFS7rYyCCRzy+4Op6/SmodwLlykZt5ExujQcZ6mstU tYEdYS0rQoJJo4Bu8oHHUduop+zQF0R2phuLq3wot4x5vnOAS5xwPzzUGNyJHK5jz867ehNPliB/ /9P+bPzZEKxs+4EbQx5GPSk+yQIsjPCssjKVXsa/0gtfY/nGXxDcTmJyR5ageWOxA6Yqid+nQxW6 BkEpL25CfK/OT7dalwTJHvOotVuLt0Ty+GUsDn/OKt6fGszIsjCOF13xs3Re4pezQ7u1jAuXWyup WucPKZduWyGIHQgfTFXYtSa4y1tHOINxQB0KF8fofwqXBrYltLc//9T+a+L7LfW7pPHc2jIM7+N5 I9Oe9V9MWWVWd/kWFjiSYbSAOK/0YP5vDW7WbbaPaDzAZttztxgIf4s+3J96W3tYTtitZ5SAdp+0 vvKkHkZp2Y7s27y1tfsy2zZWcYbzI/lPHqfeqNrHOt1cuHR4RGoSOVdxUjgkH1PFIE2tjTjhi/eX tx5Z2L5YRm+4SDyB+FQQ2/8ApGz94Y9m8SyYIJ9M0W6Bdvc//9X+dqzmnuYyrQ/ZxGxRt5U+YAeG GD0IrTgiAG5CNp646HFf6JuD6H83lG6TfeRyQo5EXYHGSeOlVLpbeeNpZDiaOQGJMEMxHv8A40uW W1gGG6eeMWs7iAsmwrL1ZT2H51UmtrWwhjiIVrUYRI1H3fbHpxWfJ71wIrjZEkq7SDsB+XrjnFQW ccV1ZSRL5i3EbfNuPyMpz/LAqJw92XoaQ1nE/9b+U3xh/olxcrdookhcqqxHco5xgH+dcHZPM8pk SMlScOp4VhX0vHGvE+M/xy/M8vIo/wDCbRT/AJV+R0tsmnzolte2MbmRypuN5EkQHII7cVTggFuH ghe4dEY4LDJwT2r4tqzZ6gSMzJtCsmx8Dd1akYSlBHhl8zgELwDWEviZpBK1yF7e4iZFmJYEDDY4 AHYVow3zpC0AKyRISpUHDjPrUjmrtI//1/5Q4XhSAhI2V24cn7qiobaGPCQhi5UZVmO5q8GXxMCP Vrm6ttOu2giLSxRbopQpYr2zgfWrGg300kMIlAZtoMsp4YNj096kLHR3N1b/AGbyJkCgvkSKuSOO h9uP1qtYxpMjYUBc7d2OtO72A2IrVrRfKlQiRwJED9cMMg/Qjms28RHQ2xUTOrZWIj5Qx7/yrObs rDSuf//Q/lj0+MxrLG+D2II4XrxWioiSP90rlmyrr0Br5cdtxtpbH7SHKMsaNufIwxxj/DrUeo+d DcSSyzBoOkMYH+rBAySR9KmV0tAW+prxacLS0t5objE04OSo+4OgA9qneN4BJ9qjlQqgWOZcFpiR 7cisTfyIrZ7bT0drvcilMQRoMsWzwDVm2MkpwV2I3zeWehFBEpW0W5//0f5tYo7UWuJAnlrwY8YB 9qqWcFtbu8kCxiMMX8odASa+QuwJJ9Vb7mwKM4XJ+U02PVYreRp7iMywRrtMcbEOWOQMdaQEQuYp Y/MnkWMGQlQeq+lWIlJfKxhgwzuPQitoaoDWtmiRgoILBeSB+lRXer6SlpJYXcReeR/MgYnAfH8P 4YJpT2A//9L+bAzLMsCLKfLlUvHt5HHZvSq1vYs88sk+zyFyIljOZGPv6V8eaU0W5rjTLa3js41l S4Y4kwnyjPCjirrW6fZ7ZQzptIYRqducdj7UGqV3Ym3CDY+3gnnnoank1MRmNVIy3Jbp+FZNtS1B qzsZWs3k06xRW4Ys5DMpGA2O1Ps8thWUiRRgxsflJqbu9xWsf//T/m9uLe48gecFLu3IQ7goycCp mWA2sRH8IAAxjPbpXxLk2dBZBgS2UlXbPIUryG6dKYyysrK+4BkxsHQ1IpK6sQR3DWkCnzQro2Ik zhkA9BT4LgGT7QwIkZdpKnAJ45oMYrXU12trNLaOW3kdmlXdcI67W3ZOTx17dasRWEz2qTafB5kT EiRgMBcDLfl1xQbn/9T+d1YZ5Ua3kmLCJt52n7o9Kitd3mNn51jfCkDAHbmvg3J3sjT3eZtm20A2 xsJYw8r8mRsbO1UprhUEijJIPJXpxVu/QtNPYhRUbdGu6NpVyHA+Ye5qJneCUxzMsqQjMZJyFPtT C6vYsfbIw9tKbD7Z8xLRF8IMA8jHOfSn2spuLb7Y3ygymNIX+WQY6/L+FJ6IZ//V/ngmMbt5kX7t 05PYGpbnUY0sFu7uU3WwFURBlxge3+eK/PzoMCK3Dqk5821llbzlUfLvz0PSun8Oarawa5p8ur2m o3MMAaK4hRNts0XBJBPAbjg0AW9cv49T1aSeys4LOwIKwxxp5Uz4OA7KOBx6d/rVBJGXe0bvHjGy MjcuR1Oe1RN20ElZWZbNpHdx/aJSHd+HYnk/jUJUWyiztpn8pmBwRgHuR+eayGf/1v5/ooFtMyxn 5gMHJxVSS9M1xtkwIQgCqo5yOpNfm68jqUW1dFC8SWZCsW8TFgI2UZCD1NalnBbPAx1GZ0aMDyyE BUsOmcmnLcwmtSd7fyohFHEo8yQOzYwW96sNAxjGSxljT7iriPHT86uMujKStNpFL7UyRyoyLO8s RgjJGTDkg5Hpjn86rvpRS0MyyiWULn7MRgS57f59auLuh8q1P//X/nm+aIxC6QA/eVODs9q01aFQ bxpDHIgySM4/AV+fm/KkrGaZCt200s4ljP7xHfh8mopI7d7mO8GWlClcjpzVS0gjBp3NeIGwjPmh bqefLRCFw6xAj5dxGeRxkVXtrzUYFBvpWugoyxx90egHtRJa3NkvfLb5uUF3a/Ig5wR82D2/lTIo zKF3SDasmdh5LVhPcu2qR//Q/AaeQRRSKFJz2A4qqJYot9xFBGZpkCPI4+ePHp+vX1r83O7kV7kz +W0EbC88q7mDIqRqOmOvP48U620lbh4rWXE8uwtmTG446nH50EODvoMja3jeQwyLmHg47/5/pUj3 krRh8ttiy7qoyHGDQSk3sV42llZTFGXJOeBnFacFtdMzTyORGPkKfXpn9aDWMUlZn//R/CBRJG21 WxxkHPAqnHKjG5ESHiT76j5Cw+8c+tfm56A4WcdwhVi8chG5yRtBFSW0thDH9ha1hkMQKpMzNvjJ 7jnH50DSb0RUjto4pnMjuI3bPXKj8KmvLjSY7VB9iZXjkLboVBLj6f560k09DRQXUzTO88xKQyvZ xENDu5dgeuQKbJcRxXki+V5MTYZI85YevWmZtWdj/9L8C5bmaWEw5It3PI7N2q3dXkbLY2kaGVUb ddz5K8Y+6B7Yr83PQHvfWty7HT0FosZA+Zd6ZHB9KqXd6ftBtY598LxgTIyBHY4ySvfHJoE2luJZ xW1tdfa0jMUxjMG89SvOR+NWLtre22TBJN7sFAAyAD3zTuzKTV9CK91Msy2sBd0CBncrtUEjoKo6 cD/aQdYN0txGYXdxwqjng/5/Sl6mkGuU/9P8KYcRM6FVdXIDxsMjjpWPqNrLYzT3Sxgwuu4wIfu9 egr83eiud6d9hLaaW5hRHU+WwBeJ1yMeladxY2KR2rXEjqkJIREGCMggKBWSk+ZFv+FIx5ZngXyX BjXdk4GC3pmryTRoqsh+RlAKgfdqq02psdFWppE8mIJY5m2HMLBnzliGGNuPesiO3iJa5mM291EU UO7MagE44rLnempo0nuf/9T8CWVoZ1mKIoUDYBgbSOASPw/GrEYZI5JWkLFm3hMcCvzFTkj1JRSV 0Qy3cLpsaR55VGZHPBjz2IFSR2B1GBYlTyYBkM7dH+taRqvqZWXUxm0SwsLiMgOssc5cyRjAwRgc /j0rctEtvOIgtzOchp5FG5wB6DtWjqvqw5UbKPZSExwIS/ct1XHanT6xFd2x0mK2jSRHwL1SfMBB IOO3YflUurbqYuPRn//V/AmdJoZmS6lMinhX5O8e9Wbe1ChkWQBJBkKvavzRVNdTrVPQLiZI7SS3 WQkH5AU4aPPXFNgsYbiRZ7cyiKBAGEjb2HAySPc/z603V0sP2fmQ6nLewqGj/e4IGCSMr7VUh8+5 iLzsqIo4iY4JGeQBWbmyVFs3rW4XDxwgwDycREjflhgd/wATUNwBLINyAZPzDGAaFN9C1BdT/9b8 BL57S0BiAjWSUgQyt1VjwMVPHPf2dv8AYblkkWRxK4jA2txxketfmXtHax3ciG313Dc2yabDZsFe USDHO9gDnj8aZZxW16r27StEYpRCxZSVQ8cEfiKj22ockS9exixDaf5apsXcoXDEgjIII9ev41T0 q5Kw3SgzRRSOFWFlx5m0nlvbnjitlWklYuMb6GgVjMM8m0JIV2thcbx6VmNaW0ggit2aErk3K5G1 /THpR7aRfs/M/9f8EbS1s4H8yWRljU4EgXJX8O9Z1nqx+13cLlWCTFUZF2kr2yK/OY1G0esoJF11 ImjvB5UggcFlkGWIPB21QvoNKvZ5Hs2urVvtMd0txFKYJkdCGI4J4yMfSq5/Io6a7a51JhNJ8ylF Rm3ZdyOM4/CuZnlu4JLqBUPlgeXyO2Pm4rLnSkA2Mho1Xz5AISJBFtIQgfwntj2qxutJyfJxb7vm Bi5Ut3610RqJPUD/0PwJuSr2bRS2qzwO43TZ2zAr2BHODmizS4vbx5TsiQQiNBjGQvGP896/PXOJ 67WljqtP0zw6bC9HiDULrR7zzdmnyxRi6guOOjKPmB75z/8AX5yzWWKK4KxlYmbHmE/M5H8R9OtH PEErKzHWlxOtxGk582IPuXf90egqHVr2SFnDyD5uig9BVxcOpSTexi2+tiZ2tt4IUBfcVuQ2wLRt OVUEboy3f0I+uKVSUHuZ8sk9D//R/AK6nUXce7asa/69D8okUY79u/50+4u7GU6V9njFvIszLbSR MTGx2nr2wADX57FxWiPYSew2JJPNl+1LFLETjg8j3FX2m0+3dVdWUSDbFtGSp9c11Qmk9wa6M1rO 9/sq9tIkk+0WsgBuRefeAbsD/nisHVY0e/mZCFSSQsFtwVUp/dJ/xock2KK5VYySJ7G3luoVeSEO E8pD8w9wM/WpLS/+0pJYF42nnYmBpcJyf4fT0/KsZSbZrZcp/9L+e+fSLeJ3+3TOrRco1pELmdW9 F5/lV231F9OOy0luHSSEgyzxeTIwIwQQCcV8C4tansu3QzWvTDHm5i+WUkhUBk4JO2qdwGt7tSiN LGyB41ZdojNZyjfYcUr6mo15cR6dLNPFNeQKwxbxoCePTPeoG1xdyeVbSW6kKNsjDd2z0/Gkoysr mvKl0Jb+xun+1ajY3AuIp7VBMknEsLcAbV7/AP1vymOlQm2sYZzHJKiB5bnGwsSOR17f41tCOt2T FJXP/9P+flp1iYRoA8cKhAvVsD0p7Xlpcb87UdY8JDOc7z6Y6E18Oe5OKSujJsWzdSIzeSqgnywp 259qbdx3Elyo3KVAz1wV/Ck5JE8rMbUhbW5jiKSSST/K7RDiP685q7aStFEymHeAoWMZy2OOn+FY t3d0TYGXzD99jsIJX7rR/h+FS2qWstxcLfX00NnHGWjZIN/mEcAdeM9eTxisZNpmyStY/9T+dyS4 igtYlgSPy3mXbLNEZI2BI6jp+frTXsYluIZ7NXgumly/kjaHz6D35r84TaPfsi1fXh2xDMbwDCTo 8YEoxn7tQWsavdMYWm8tRvjjYBCw6YI5H4A1rByaeoKKQycziWSSWzuIvKlCsJUIA9xRdSiYLLIH eFGAl8obpQvfArWM3EiUbsi/tAxGcedJc28202kc0XkGIDH3hz9c1vR3LzW0MQ3pMh3Stj5HXsB+ uT9K6oVpWVjFxTdz/9X+d2SaDS55LqG0MomYJKoOMtwGb696s+Wks++wCmV/nKgbA5x096+aWIcU u9j14wVzvvB9ijXcF3PPJDJHKpl8ucooAOQp7Ed8V9k+HrG51t9Nu4FguXfV7WO7tjiKG5h81Fcn GBwO1f0B4Z1f+MUxlR9HJ/8Akp8RxDFf23Qgutl+J/Zn+wFo9vo/wk0BJzNm7sksraKQM8MyLySp PAxuXgY4r8wP+CuV1aHUNI0i4mhsFt72Uo0Uqxq6QmRkK45YlkJNfC+H69pxwn/eZ9fxlL2eQcq/ lR/Mv4+gur/Rr77KfLtGjmaR5vkeXCM4Vj74PHfIr8kviPZaRe6xcRXGrahpt5a3LrKIICba4wer Z6gHjgGv2rxebWVUY9OY/LOBXfGz9Gf/1v4dNSV/tspS6M6SHaQU2bAOANvbpWjpSFXAjbc2NrZH QVg/gaKqv95Y6qOwWWSGG4lnt4WUPbyxYKqwOOR+HNegWUtlawzfbZJFaHGJRDtSYnoNx/DpnrXm YjZiSvojLvpoZLi2Gmp9pa5YecJV8kRcndgnOcAD0616Z4It4odWjS5iV1cowYZCw4+8D371507W 1C2lz7rm0u4V7S+0c/b7JrRMS3A2OqqgXAA4BBGOfSjW77UdRltVu48usawJ5EXlxgKMDdjj868m p1Oyluz/1/43b7SdO0yQyaHbOXSGKC4kkkJMmT8zY6Dkk8eldz4Wkkt9Qt7c21tcPMywxlJdoBY4 wPrnFfJNuMmZ25oWNy/1OOTUJ1TzNkEptzHICoRl4IGfQ96uabY6g0Yvrq3RYUmbyn3nEqk/KNvt jnHrXTSVoD5feRm+Jtau74m0ntHkt7SLdBNCgjZCDgpkAHHAxkmuKvA9zpmoF7aeOOOzDzF5QsZB OOe+4d/qK7qC0sU4pu7PMZ7GCWSQWkbeS0KymTfuQMRgkfp+YrE8M6zd6B4r2afLK0hYwTRRYENw T6jvivWbcaasZyS5kj//0P5avgxa6jeXN1qcAsNjw3Nhe+cypeHcIHhVE7/MH3f3SF9a+5fhCG0f x/oMV9rL6Ddyuhj8qNpZmYMroOOmSuD7Ma/qrwqXtOC5L/Efj+eyUONaFu8fzP8AQK/ZX1GW9+Cv g+PWLyW6mvvDtol9O0O25M0UYRXOBghwpJ+tfgr/AMFltNZNZ03WdPWbUJNKs0ubi0u4WaO4+yzL hVlA4fbMcA8HBr8V4DlGh4my093na/Gx+i+MsL8P0X1938j+b7V7b7Rc3s5kMMU8a3FxCozPNMAd xJ6EjOM+xrgbWeKNLz7SqR3cbHyfMkyZFz+hHU/Sv7loysj+Tq1PWxnalL5d3ZJDdD7VdYje2VSG bOMZP9a1Ldp4dQjkvH3JINjSN1jKjAGK1T2MeRJ6n//R/ArWV0RFd7VxNeAD7XLFGZN3A2p07VwJ S2kuhHEYTdXClIVRcSxgYyD7Hj8q/wBMD+LklHYvf2bNaT21210qxlBBLbwQhY5WYBQM9evf86p3 Rv7LEri5SOEmKCNfnIGeM+3Xg+vSrgk9zWn1LtvBdwSWVy+5kv4WKhUDRhlJB3Y6H5e9QwWt9Zyy OU+1QxlpFiY4dCTnIPb2quWNzQvTXt/LbOqbLdHRGIZAZkOQePfn+dSXLzC5huR5c8L2zNOBnz4p BjaPTGM5/CiKW6NILQ//0v54NPQ3U2y8kliYsJI5Yl2iLngg/wD16s3Wh/YxC9uJJElut85VAEbg /Mw/r71/pu0nufx8lZWOggXQbyxXSBceTr8vmTWmoSoJLSE4+UOe2CcVi/adUh046XNpNhfBJFTU r+Niy6e/QyK2OckEc+vSsWrOxpyMtpZ63pNqNR0m8tZNp2vDIokdwRzsUg9s8msu31Szuvshlt54 r2C5cXKRQHypumN3Hbk0KLexqS+IYFL2r6b50bbQ4TG3ypAT8y/gf0rOiv8AXoYyLR4p71PnkN9b LdRPFuG8KvZuuD15p8tvi2DVbH//0/wctWhlhF/awLayzqGkjMewp6gCsmR4pNRihlHnxzSBZY+m egxmv9K3B30P5O5la5h+JNPhuZ0tI90kSziVUb/VW5UgqfwI710VjpFtp+mwyRXpk1F590ySqfIR eMFD7Yq4qyMuZ3uWtd0p1itpmnDmRVmaNX4dWGecVyjWaXblIHaWZl2yxJuLQ4zhce454ole6sRz K9iM+Zp628rwKY95hYg4YgDjAq9b3qTM9rczyXSqPtcbyttEQLcLtwMbf6U0DaW5/9T8BbOzuRLm /vY51C7bfHOwZJHt+XrWu0U8YSVrkeXkIpY4BPQA1/pgfx+Zj376VNdTNCXklG48kiQ9B/KsZr2/ 1S+QQPJZQBA0kSAGKUDA5cjg55xx1+tBrC51l8sFvEphuds/khXgkQP1By+fqOnvWjaS2kuk2yCU W11DYGSTUHiIW7blgDzgA4AwP/r00hzXumFa67dn5ra3knMhCi4C7Yohnl8Ec8fqKs2NhI93daqZ hJNP+7Z2Yc9yAopGNj//1fwD13SZ4p7NUknWK7JWZrd90ar33gHjvwcdK24ZtL0zTJrby7qW6SHz IjFGGMpyeOT1PYetf6YrfU/kJQZmRpe3drL9kuDZ4Akn3rluMN5ZGSMnAHf+tbltcC0019Subd1S 3O+5S3T73OAeOlaSirpA4tIrx6hDc3FtttIxHdKXmS+j2sy7c42nv7H1q1e3yQ2y22lW9tayq5Zi sYj87kcYHHbGfes2rOxBl3s2uwzW7paW8DqEeGYzDLHqd+OnpW/b6ppUks7X1msgtVWWZCmwyMRk qpxjv16cUjWCaWp//9b8CNQvbiS+BSxTncwVG37CfujgcgD3q9pur3KQm2njZ5iD+8249fyr/TCy P5Emm9iS0057mY313a4hEuYhMS3mAdwv1H6VsC5uJUljhUxr5Z8ppF+VeuMigmC1OdV5ILcWV8iN vYoZ4R8zc53VtaRHY+HpY711N3MyMEt50/ccqfyOCevpQdVPYhult2WK7EkeXUyFI2LCPJ5ANNuL uwuE8qGMKYoxs2ZDGTux9yTWMlZmltLn/9f8JLTVLi38qymtY2RvleWT55mHrz0PHbtWxbC11bTV mhikjmR2jVJBtZipwMflX+lqjZNH8owdmU55yiRIDCtwy+WcKDwo5Gfw61i21n9sa7W6k2MTlAig MvXkfTis2rOxbmrWQ6OxY3QWNpMgeWfNGwS44z6VsXE8tjZ3dhHZGWFh+9jjj3iUjvuAycc04xuY uXVnGpZG81BZ0ja30/apcO5JUDhvpzn86v3NhDZOskkpMS4e3BbPmAn/AOsfyojBuoc9apamz//Q /B759Wgt5bcQRLZTbo1YBTIe4yOe3es5Hmk1AytK8cMYKSxNgiZhxk9+MEAD1r/TWUG9j+Q1K9FI 1LmK78mTyLeI2zAzNJJgYPovfP6UmnQXbnzLiOKaHYC8Fwo8gAcjC9z3/CsjTS2hnahex/ZLjUEu LVFhbe1s0LQybc4yEC4454yDxUVtKL6GK4im83ZtlQxDCsSOgGPwrNw6oDcOoyXN7b2t1YIFhQMT AoSRs859M9qqXV7FC0kaQsu6QhDKeTz6e1Ty2SNrpXiux//R/CmzIurgy3DMl3agQ+XIvG1QMH6D AFUdems4/s8Mc7SXsrNNKFQGJFBAABHfnp71/pZTVkz+VMKv9naY9reze8hs44kEot0vTCo+ZAwz u+vXJqWbQ470I8M8q3Rm2tGExwO+fqK0OtW5VYo6gRYShbuYPHGQNxGAp6EYrEWxga+mvViLx53B du0DPUge9AHSSS+ZbrLBGE24QqFwMdKqyWstxsMyyR24I82RVOOoxg/56UCezP/S/CKIXNrJJDpc 7Qm6XZiZBJFIBnG5SME/41VsI9RTbFqUXlrGvmJmLyt+epx6cd81/pgfyuS/adNuZJQ9u6RwrsmO 4FJAc9B249aydOvF1C9mtSiC1jysTb8kjnAIqZfCZU97FmKASXyeU0sjRSbUi3f6OCPUd/xq/dWs 8V3JdT4iLsWljC7U+ijsPQVMY3iKXxMoJe+ZbX9lZQwSXMpBCOMNHlgN36H8qvSWcdjaT5dLi8tw oMQYM4YjODjpUNWdiba3P//T/BWO4MUNvNI3lXc2f3IBzGMd6ZKRHF5bSE+acfSv9KD+V0rKxqaV pN7dZgso4kkjOUSS4WI3RwMhQxGW9uprMRFF1epqEW2eBiDGeqc4I/MdKnkje4G/p13Aokjl28qB bxOoAXGc478/0rAvdto5jWENBcSZbIGBk5OD2qhp2ZLHbkRFQ4UuuCAMEj0NULORVlntxcsl1bv8 sJG1VBBzjP4dKTinuaOaWx//1PwSTTnnmSJrvYJG3OwziMZ5P/1qp3FmjSywxq0rq+PNZeeDwfav 9JOTU/lnndrHQZmlFqlyUeCR/KniSMEkDHUdBVvWND0XC3MLx2ot0DED5iB0Iz2+taW6GU21axz2 4R3XnRxt9nRFUiPLlh6nrWw0vkW98bnM7zSI1k+NptowuGU+vIzUuKbJU3YydOga4SYpO8vznzmI 4Hse3FPis5LO6M08INrcIUjflWcqeQD7cVCg7mtFvmT8z//V/BDVL2a3hVEs2udnKZH+rH5Vatpr u90u2vL60WLYzRrErZDqG6njr/Kv9Ja0WqjP5fqtuuxl1NZRECyknkmuECyRCP5E9Rz6evtWa9jZ TAR3KSSDzARIZDHGv4D8K55Rbd0A5LVDeXDxlPIBxAoH7w44ANIiedFLF5IZlfezdWGPT/Pap5GB NaTsYdkkUkKFjGccb+a0JJ2tZIlVVRXQKsYHJGMAgflWlraGMviZ/9b+fnV5p4UEEIaeZpA5AONo OTUwuI7KzzcsRIVDKI0LM2fQde9f6QH8rk1ld3kSssUgiMhDGWSISFPbmp57a1laJ50R9km4MUHX 1oLnuTXUdlIRYsmVmAyCMRc8delZuq6jJpukJp1tHNN5MpaOZ8fKMcIrY4HvQEW1YqoktzFbpKzl mCyEs2VOecZrTlsxEkkdjdqZEXa5xuRGx04+tBvGTif/1/wV0OK8E9pBeanCMozS4jIUMc4A546f qKbevN5t3aybGglARd8YDr6kH3r/AEgP5ljK4QWdva2oxKGVTjGfmJPt/npVbUbuU20EVo8SSiT9 6ZMklfp+VA7ogkjm8lJoUMx3AOkQywyQCalneKC3ivruWO3CTeXGWkCOCADyPTn9KSVlYiU9bIrR rbTG5R4vIWVPOE8ibfO7gKcZzxVSG3WaYFVceSPvDqPSmQ3dn//Q/nmF4bW5dZY9hycSqpCkdsmt yx/4mMHmLPbRxM5iG58jPqcdq/0gP5dlpFmDDYaZp9zcvf3vmNcnyFlXmEt6IPfFbNhdTwq9lb27 Q2sD79x58/cBkmglStHUq6hPHcRv9mOJoJCJyOg46frWNZ+aQ1wzRtsXeyvxv9Me/NARk7WYnnPf SlI4RGiHLljjPNaUvl2kakKZJM/K2cIo55/PFYyTW44Sbdmf/9H+efT7658q4vbxLYCN9iOHAlIH qP61AHtp5bu/hMJl8jMe35XJOMjPf/61f6MH8tKT5hugXupxXRaKKMPv+YTpnCnrtrQuprO31NHe LzDKcTMMZ+goNSONJbhp1QPHCGzEP4mJ9P8APaoi7RN5EYfzSCjsV4TsQf60AWLnU1t44Y2i814s byq7YSQBxWHqn2jU7mFrdpbZxMlzEN5i8nbjge3Xj3oNISSVmf/S/nbW2Z5D9pnBbPCj1p5vVtp/ ImiZgflEyLkBT61/owfzObOhaxpkNzcLq8EslmEwgt1Lz5PcAV1GtDwhNHp0uky3bpdbhNFc220Q 7RnlvXg8GgDzfUrq1UecgIRJCuNvzHBx0/CmxyIo+1+UUWVdxYDD5AwOKdna4DreSAO88qOrS4I3 5yw7VY+3tAJJLSAtjrtBwMUgP//T/nEa+1KX7TfXCyzqf3UcIB8tCBnJb2z60WN7fBBJeJIySkW7 QRfOEDMF3N7AHn8a/wBGUmz+ZxmoKBIEs7QzSghig4GB1P5CtW4kR5FeK2jTbbqMoSy7gOd3481U YPdl81mjBmvZI3Sae3V5kbiMjKADufamlZrhvt9raxcjeNoCA57AVqTdldbprmQ2/lF5s5eNFJ2D pzSm2kUTNBwyDdJCeFkI6D600m9iudn/1P5mre/mtom/tKF0f7QFiJAKsp6FvTsPzrsLNpPNLx20 SFlEkZGHRRj06fhX+kfI7H81c7NCBknE1teBJAhEnmEBcEcjH04riNRhu7i+nit55RDOjGZCcPKc jDb/AFGDV8iHz9zYiNylpDH55ieM7cIQzZ6ZrRt8ymN2YSvCduSBnI7mpcHfQ0XkUr+No9UtNRW7 O60YNDFtXYr5BB59wOPan3Y/tATm8JEkjGViwwXLHOfz5qXFod2j/9X+bcGWBUiViI1+9GuRn/OK aGYO+5wqOcKM8V/pBY/nWMkzNu4FnLxB2E0eG+Q/K6nOfxptskKqqqhVo+NuPSnbS5Q5rm68+W0j ZRIyZZHTI2/0+tXLO1+ztLdTRxx3MseyRVbcXUH5c/zpEOa6Ecp+22skMcaoxb5lf5AwBwf0FQjW I7KOeBLKG4VLYwwq3IiYAAFTnIP8q0UL7gpq2p//1v5nbaYXUFpcwq7IFxID92NuRj8OKuXFx9nt xOGeRjMqCNFyTuYAfz/Sv9KD+bpytqSC/s7qc2LmdJAoZF2MEkOeRmqur2xS4tXkuJniU5CAYVB0 2/rmsZJJ6GXM73MzUIoUlhPmrLbTxZeI84wcYrZtGiMUTYZ7YEBnjGdiipKc01oVTc6ddySyQ/6S W3LGZE+ZB0xyODUVrdzm5USWzR2UeERn4J9SB2GaCG29z//X/nJRtPUypMRIWTeioMFTzXIpDPPe SxSyObbed0f3Uweg9+1f6MtWdj+a4y6M6A/IHiWRPJKgKh+9GR/jSorBIxIVGzlXChW/GtkrFpp7 GffTPKxzKflXnHG4elXtKczsUjXe6x+ZLFjMrLzyB17VnJNO4JplVYQmoO4Erhm81reZz5YA7bfw /Wr6XN7cvcNcQw2tuG/0by2JDDng+lRYmbtoj//Q/nKY3axW6JGWDSfvxkjKdyD7VpkywqUidtrL 90fw1/owfzUptbgTc28ccm9AA2ZC/pz0qpc3SO/JVkc/wjgGgrnVjFFgxmuJTLLOGAeNS3EX0Par F0pYom7duUbQ3GD3qeVJjlJW0JJ2+yoon2vFIgEkp4CnjHP6U0x+ZYyf2eUbchcyMCikqDj+VTOK cJWCnK9SKP/R/kw8STXUl9NFfAOGff5p+8u7OR+HFZVrJ5RCRkBE5+fkmvpeOFbijGp/8/J/+lM8 7Imv7Nor+6vyRoCZmcfIN4ztI7VNDDdxvgYIlOwA/eB9QP8APWvjZq0j0SZkVMJMSJEfDbsdQcU6 K4VJWLEEA4Ix0xXNNe8VFtaIiu7nzVeZYpHKc4RNxb0AAqhaRB9skq+VLMcsrDZt9AR61JrbW5// 0v5QzmSLZEAPlIXdxnFRQxSQsrYLMFIyK8Bu7uXJe9YhlMkxaJ5HijlGHA4U456VW0aKeG4uluXA i3hreUrsO30x9QfzpFqPu2ZvOpuZxDC5b5QeR+7IP+10rUtZP7PhbMXmMpLEY9OwpN2V2HJEvrcG 4uI2JIUJu2nliT/npTZIpIJhNEG87PysB61jJ3ZMVy3uf//T/lmS1mXChzvkf58D7tXI4ZICm5wZ Y23KOob6j+lfLlJrlaEl1G+YtFbopmddqgZVTUtxp03k2pnuMs8mJEON3TOMenv7UnsyS+kzRxok jglB8oJ5IHtS3BkKx3EUkkqNw+8YEbdwB6e9YDTadyq08c9zFEy+cQoJJXKrWjHeKk5QnKbdsbHg 8dvyx+VAj//U/mAn1MfbWs1QSNIAsisSi/MOP51rNbxWyJAZ8TSE8Bsge1fHiaelim806RtDMI2M OfL5+ZqkmgWS1W6STYyQ+YiOpHmHj5fr1/KgZDaTeag86L5ScAMNoyK3YtRtxeQWynYZITGqH5YQ RjnJ78evrW0FZASxC5FxOSyiPHyN1zVG6sTdCGSUxO8bkw+W2Sp6H6U2r6MLdD//1f5tIJBFDFbP aQxSRgqJUB3SA925x+VQwy/Z7nyyCdzfKFHHvmvkZLlZukkrI2JIbR5DJIArle45yOlV7l5P3DxR qyx5ErBgMLzjj1yakpaMjE32hRGRgg5HvSFE3IZI1LA/KO4qJrQc3qPubm0aWHcGSWJMfu1HOO5/ QVBPHJfeVLbTfZzG+ZSqg+YBQoK2pJ//1v5wre3mcFml/cx8EtnOe1U3mKwzI5VXXIiJ6exxXxXL u0dA3TbuY2wjuH8yaMfO+3YXxxkCtWPUxJJBBEMtKdo3Lg1LVgNCe10+VTJcQRzl4jGVVf3i4rMs rcyoVjRgA5WMvwRtz1pEqCRYu7LXbSCC7MUBtpXZWKuTIFXoVXueufpxXQ2l82l2XlNNJDDcR/vl Xvv6nFA3sz//1/5ybmFIA4025mbzv9a8jk7+e9OH9pQRII5R5TffUjr7j8q+FcdbgSQvcapO1mfL QiItueQRq20ZI578U+zv7aKN7dtolPyRgnOTmqNYJW0Nie1twlvPZ3cg3xKbiGSIAKwHzBT1xnvX JNJJJdMrYaIuVAf+LFAkvfZspKg2oz7V6DHr6VK8p85DasskqKcIwwIz6gUmtLFNNtH/0P534l3y /N8z/euN4wgFRG2tX3oqsELfLCBhM+or4FxaV2b2dkrl02Et5A19N5wFqotowQRjaMKMemB1pLW5 lhVWuGZZtuwbjkqDxj8qkZSnluBcMQqlUUeVNtw3P3sU+zUvMIriVtrd+m31rKe5UVzOx0V1JGiR w2UKbEjwGQ7V445rJgvY7mZV8ti4ypkAzGhHvUFqCW5//9H8ACsjQtu5/unpWBcMY1Pl4MobBHX6 ivzhaM9BLsPur5IjbNbMyuuDPvHGe4rVuGvpIbiSGJBPPD+6S4TCfNghunHqMU5WvoZShuLBcSxo kdy264WMIZMHBOAM4rTtrqZpmiDqxSLEuzHAPA3DtUR2IhDWxj3az2tzGGKFZ3OwKcgDnr6fStu0 VcbHIEn8LHooNWpOKsgP/9L+fzUiocSLEryH5HYj92PcVVmaN4lgEZY/xuvX/P8AjX55zo6Urlca Zbm8t7iUSmBI9pXfnPuB25qxLDFG0jYAiUZwepqpSvTsZzQwXQikjFralVKbpiwwpz3FXEVLuFjG wWVeCmflY0nLS5rBe9cfEklvbfN8pZcFeoSqEkqIDjzfkG+QheG9h+RrOTuyrp29T//T/n0tJnki V5iVaTpGwxgdv6Vd3QJ+4KfvpV+TOcGvzc9ApOfs7rJLZ73ifbHIvO3I6+1XBLJJcxzW7nzCNpbp s+hoFdXsJcwC3j8u1ije6lbLSknJyemPzqWy3yghlVQB5bLjHIHP50DsXGuDbKsNuFt5ApUSKu5s 84JB9Pasex1e9/st4bzc032hwlw0XkiQqSM474GDQB//1PwHfV0WNJG2nEQ+6cbsZGT6HrVa3vDa ys0t0y2s7+YsRP7oMepx71+bnpxjdM3LiZ3iXY6uJV2K6t84x0GKybeMx+YLk7QTtaXblkoLhGy1 NLSbi3vmkt1y4hbypGIIxwP8arXemvZ3IgluoJJf9YsEMiyqE7bsdD7UWKLcc8iIgtx5QPyOqjh8 dqglkgedfNWNnztm8z5Sg7UGMlZn/9X8ErprdUREZEjZh93sO34VUvrYWQJjuYX81A2A4IBIzjPr X5uegUBJJasny5EpClVGcE/061rLbW9qZtTleJrhLfMaS4dY+MDaPXnP4U1a+pjK/NqYX9pTSSwx SqZFLhJSvyiMc84/pWxdzQlIxFKZEjbaVXn/AD/9eqkkloSVDNGsgilVk3DKsF/LNXGjeBRdO4SJ Bv3ew/8A1VAH/9b+f034kuceY3lnDibB2gVpXczxTbvtf2xXjUqpQgJx05r81nax209hsd6ylmMB VRgfX6VYu2luAVJYRMOo6p15rG9mvU1t+7aMWeQSoSSxdTs6HoKsWF4JYXjWEtFGdpm6iQ9wPp/W liP4rNIK0UjZktzqVsFVfJ8rBMiZy+D359u1NjjWJUNxcnbE2xFA5X3FZJaoo//X/AjUdOjnLlpJ HJYSBskdDkHH4U+zlWB2W63vGVCo6DdtPuK/Lz2LdBh1GNkukW0CDzQBKqfvZAPb0rSiuGigQRyg RsOYz/CeO1Bi1aVjHuby5uZzHJFCkRUJGUJ3NjufrxURaWzRvJleKWRShaNypx74oE1Z2E0y8vrV xJvThioPJmYn3z6E+9ahikk86VV8idRmMdQze9Aj/9D8EpILiaLfM8MuEBOzhk9Qff2rOu5GtjFH byHcBuU5wc+n86/Lz0CglwQT5z7pAcsAOKsWt5LFcbot4jkXbIjAgNjBoAmudR/0hVCu4Zdm0jhe vP8An0pNP824ujE0JkVVZhIvG0Dkgj6D9KzmncDRkkby3aEbTGMIMYDH0qWSYmx2qm67ZfmZuEjP t61ntsaRhsz/0f5+vJjlUSSmKVraZSUdh5oznkKeoHr2yK0BNIZEihjiIlBBkkbDDpj2r8obb3PW 5Ij4I1jkCykfagdsfOAD6rVr7CunRtcKyTGZy8ipncp6c/lSIcGVZRG8hvfL/fmMRZJydo5Aqsf7 SRRNFBEQZAkbyHZET1IJxW8dkOCa1Zat7szTvazjbGyZd1+VVx71jaxBdaQkWoxQvcWcr7JbiJtw jUZOT/h70zQ//9L8EvtdtcadZrks0mDnGAq44rmp2hfUHiikWOS1AMjqu0FWBxu/z2r81j8KPaiu Z2NSOQp5SmI3CIwDneI2I7kdqqajFaWOoGOzuZZkuwJoIpI9rRtjLgfTjPOOKok045rpUjQM2QMg elPjmtTJLDdy7JWXAkH3QfesHuwKLRtHGlq84mBZmRwNp5PfH4flUN3Fd2dvEIbUy+Y5CzLhVGPv fzH51smmrjdk9D//0/5/Y3X7OYfMO8thsKSEOO9OuJZbT7O1rIPL8vDp95gR05/CvzNz7HsltXvL gRPO8LI8W9R5odlIPT26Hg81sR39pPFaWRCW11I7JJM0oS3ZQuVznoeCPyojPX3hFe8tY4FA3Pz8 ysDnJ9axGtraZXf95M8bYwy8sO/WtFqa09rF+28M6ZcrcTRW7xm6iWMXJYo8WOuF6dzV+4ghtI40 3s4t0ESsQeAB2ob7kWvKx//U/ARTbzyNFKu+aYYjynykZ5FVIrKRLuWOcBbex+aHIxgkYbH8q/Nz 6BKysWtOMd7NfumQkWBFtORIwwWz6cVmSavp1/bwbJlhkjvWgSKRTHOzKcZXjGDj1z7VcZNaDaa3 NeO8gvLyC3lYNLbqqSY+Ut6c/QfpW3cR2sMV7MkgD28JdI3Xc0g6EZ9qTk2TyK+iMmCxk1C3uLm2 /erFbeYbbhWA7kA8nqPpisSKGzCwpdx3Fv8AaGxK6IVnjA64OeDUc9na5p7PQ//V/ntkkeJ13k5b Jtw4PzAcZaovJvp4UR5F2xs0jyLGFDZHQn0+lfnPPI+hcWtwASKHMrb3Tj5ecn2FdDb2+n3UMTXt 9DCxXpISXUegGD0o5nbcSj0Ri3cTLte3kW4s42KLPASYJMZ4z68dKgitFuHDsikJ8yxsMnI7ihTa G007E6NMnnRodsbR4wRnDDpUH2+SeFraaCRXQ+WkrLtRyAOQT6ZFbqT7isf/1v547dfIxJcSbmP3 mJxn6Vnz3n27U7WOztlihgUyXNw54LDgY7AHP6Gvz6U2lqfQ8rtsaCyN5g27fMST5sHIIFPlureO SSa/doIh8pkSMvt/Co530G4PYx7WKLUdTupLEtNa/ZwscjfdDg8kdufTrWra23kxTXs0gWKFthVi FJIzkge2KylVktET7LyIrLV7fVESZIvKiNw8BlZdrSKrbRn26H8ag1RktZ3dBBJbxjaY4XDA+49T 7VHtGaKnZWP/1/557I2l1CEFxNby+UZoVNvmGUr/AAFs8Hn9KybqeSd1uoZ2gns2EizRnCsQcFVA 46H9K/NFUtuj6NwfQfc21vcQDUBc7jGNzbuCrH73+FNtrxtvlIzAnjfnDfnWsJq2hFraF2+1hktJ TfXGYbaMysApkkcAe3PTNUtEubq7tEvBbRJp9wpninllCTOBwAEPUGtFNbEuN2XrhrKfBlDFnUpk Dhe3FUFur1U8iONhEhMcc6jO8ADjPqB/OumMo6GXK07H/9D+dNLTUfsd1dCN2WJMMzR71QNlcn+d QWM9lo+n2y6tq1xNqd1uW1ZbcNEu0ZG7b90+3418kpwaSPc5Gtmek/D3Sry6uNAtb6+F9aTzm5vn gjaG7mWQnCyZHG0Y45HHvX3d4N0me31Gx0mzluRJbXcMqQWqBZ50jmRiFQ+wyQK/oPw+kocF42cd kpfkz4TOIc3EGHi/L8z+079jJYJPhB4aWS5a2gTTYJrRZYzHNHI6bZRk8dQwx/s1+GX/AAWJvJ4/ E2i2cEdnd3ulajIsMxB3JHeFlYHHVgUyAenNfG+F8facaRfmz6bjqXLknL5I/n38ZXcdlo2pW8jv Lb3O13IGWt/LyWVfXP8AQivx6+KRFz4pv7y3uZ5441ZYLWbEcbZJYHHXOe5z1NfsfjDLly2j/iZ+ a8CQaxlSXkf/0f4aJpTPPLHgC5Ex8wKeFbPNadmbhXPynzCm0sBjA45H5Vyy+FmtRL2ljrdOacR7 /Mkcu2N8oyI8elegaRMbuOSMRpqIswLh0ZTLb5GMEj2OK8uu9NRqCTuaFnaTbLZJZx+5kYvCY8jn H3T17CvRPAc9ve+IzaW1xHazwtFFLL5Rncl2wqBfQ5OT2+tedUe5SXZH2JECok01bvU4J7GFYWhb 9xHNk84GeBwTXQRatpaPJY3lx/pcUKtAu0sGJ/hz/hXj1pdDaCtJo//S/jqttVhuI4Uh8kxz8BpO GPbOPb+ldt4a06K01m01G8nju4YrWSeC2VTskkwVQN3BDYPP618tUS9oZUvhOg1kS3Ci7nhdljcS SLGAsswPXHv/AI1radeX0tlFHLYT2sflBreO5YO+1hkEY4wQcj610wsqZqYOt3Q0/TLy4nlihgiY SSBl+cdRux3xz+dcEqz/AGORpdQW8guuSFQIrK2SM44PGPyrso6RQ4q7scLr+y2mtprFoIYzH9nk t9vy7QMBh6c/hXD6VZ2X9vm4+1zQ3MEv2m2FsodmlPB3n+7z1HTNenJ/ukjKSamf/9P+W74O31xC tnpgthayf2h5lxMiYkZZDGWfPXB25I9c193/AA6ton8f6YdPtZdQ1W61e3vL+e6uAbIxIQuVU8jY qu2B1LfhX9WeElnwfNP++fj/ABFBrjKjbvD8z+8/9h68Or/BLwXei5mmN9ZfaLWGX5IkTKrhCeTg MMZ9/Svyd/4LYaNFbaCJNJ1i40vyrmF7gtNuTUXDPDKHXPRC7kge3avwvhb3PEzltde12/7eP1Dx eipcNUp+n5H8oetLquk3Mk1mi6k1xcAt5r+XGkTc5QjPbFc1cWw/4+7+za2Eh86ZGGRszkEnpg9f xr+66S90/lCslzts1IJDqVz/AGnJ9ngiggEdrIVCsiqoACkDOTj8Sa5e7u59Qmi0+xvo7mOOZnnO wJPExONrHAPAH6+tdMbJJnK0nuf/1P589KttSshfS2EyyTRxF5kuyvlgEBcKMdzz36/Ss+60e+sD baszJZ733GdFD7s/fCg8kc89q/0wP4was7FPXPtllL9h02+S4hRo74K0PzElchj3H3iMdOtdBbTR 3OliacSFo/ln2xl9x9q1g1axUHrYwLu+urW4+zaewxNHj95FuEYJwW56VqjWpUtpLCRGa7uSEa8G FTy8dNoHcjkmrNTn45NQS4c3vlmIMbeCSBzLnB6E+vtXVxW6y25R/MjSaHLSxna5B+8ue3vRaxpB 9D//1fwCkitF09lSSOMxqEQO483jgYHU9KwLDxLqOnLc2d9ELyGUHypl27lGflX6465r/Tg/j/Y1 mtXt5I7x4lhdo1mWMgZCuAwOPcEH8az76CE2U8lve3ls7zCe6hU7UmAHoR646fnS5Ve5pz6aDNNv Lq2jj8663xuwMKx/Myf7w7Gt6W6mniiYRJHEkm3dHEN75+8zH2+tMOfuV7qcC2SWUqiiUwxy8Dfj Bzj6GpdItESe8ZczxyY8maT5CEOAMDoCeuPTvSaurCc9ND//1vwaufJR47YSgNFkOEOUGB0Nc472 sM8UxZvMjlLKEYhWJzyfzP6V/pi4tH8ixknualh5d158NxCU+0A/MRt8wEdQfzrLe5t43WyYM1nE 3lyTF23Lk47c455NIzbd2jfu/KvYJY1JXy8fZwDu81Rg8+nI6c1jabrt9ZakZXt4LCVYvJdoDu8/ A2q5yOpFBF9bC6LDc6vNfJcWrXEkF8Uiimj3LLuG5WTt0PbpV0waVHPMLi3No5tzAxMRYTtu5Gew x/KgZ//X/Ba401SbdrctlgqRxIchQOBgU6SIBjaXZkdw67IGTiE9Qfz55r/THQ/j/wAiDVLSeySG a8DPFKdkAEbSSTeygAk4HX6Vk3UV8LqGN7QRaW6CeNof3cjkkBhj1GOtaRinHUqLszR0q5W/upba eNJLqzhN0sTNgzRqwXHPfkVo3N1DKqiRGS180lYsnO0H7v0qlFR2Lck4j7fXo0VbSOICycbSEQAx 46cf0rNfWYLWykfT7OWeRCSikFHlbPcHGOtLkiZrc//Q/BK2ur6QSSXGl3tvaqizT3sq/umJ7ewF Z99qdtJvkCvBP5wit0MYETg55znjtxX+mig09T+RzbE0UekO0e0TyJmVc4O4cZ/TIqiElt9PnuJ7 y4ME0KK9sB/rDnP3R1GcdscCtLIDXG02byzKAWCmBdmPujAyetZ1pcQ3F0Y5FSZZEKu+zKRYxyrd jmspqzFypdC3JBZS2s0JJkiV9zYOdzDkfkQPyptjfbIZI5Y0j3r5ZLoJMjPHUcfhUWGf/9H8KrPU l81LWVI5IQ/BjiUMg9yBk/jVue70KF72eWK4K28fmqUARpdoyVAPrj88V/pgfyPboOj1C0e6SO3m e5snw9qzJtkCuASv4ZxUOql2toIra5aAC4LyxhQWlHTbn8vyppN6IVrMxWg8t47iRJGiiwzqVwa0 IdcnkhjjtLaN5Hm2rHMAyPwQA2R0pGsGloTs8cGnj7XawyFWCTyQAlIy3YZ7dffirFlJahzblIuQ JIzsAzjpis5Rd9DW+lj/0vxKn0OS/wBOfUYmtkeyYgqSUnlY4AA7Hj8qxJoxDNaWN2lzHaTId9xa sA0WRnOPfP61/pgj+TyKdIxL/oFoVhtsRxhwS0gAALZPrzV+xS2uLmBJ0jtpifmz0OM4P19qiUW3 oBjLPqjas8UXkXEUe4YcAgkEBduPTmrcWpXaswimeG4icrLlChA6HB/GqirKzMJbspxtbObq2MqB JFMjKf4mz6fnVa5EWpWkUc9snk6eMRtGTHLKATzn25pwVpuRjXV6bR//0/wc0yTZZQwxxodpO4gY ZQSevqat3WmoYMxzx+eG8wNkgMMcr9c/yr/Trl7H8eRvylmye5kENtdiQ2zqUk3DaY+4ZB36frVX UZ5NMmRbe5e9uAv+jxfe2ohGfl9gRwc1m4pnQrtKxh6kzNdw3Elsr21yg82Ep5e71GMcZ/xqdE8m WzFja3EULyHzB5WVQdRnNQ4NFRWiQvnXvnT3qv5Y+0+XAyrg/KOM575B/Kqt5pzXlrfXrXNzNqKn zYIWceSxGAy9M5PX6mo5ehul7zP/1PwT0C3U2yS3H2iOZ32yiYHII4IHtx24q5rtlp1vFFc213K9 z9uBhgMWAEC85PQgnsf8K/0whG0GfyvTSp0LbFZEvH1Oy1aOYRT2ypEXXhpI+N0be2OPTit5byWC 8MseF3tnYQGRQfQfjTas7F89kkh11/Z2p/afMiEsluPPnR4+MAjLfgaxzdtZXMYht457WdPnZxgb COMUglK+iKVzdjJVAiqx+4PlVRWzYr9sktVmlzasAAkTZAwcHP0x0oE5Nqx//9X8EdVuZ47q5giV pDBOYLaeLhAF+6fyqpaanqcrQWd/IDKU87zfNEzhN2Cjehzn8DX+l7v0P5WTTNG406zjuJhA0skM yDeJBwGx8w+mc1g2VtDZz3D21qkqQScNGx3KOeg7ZqHGTZnT3NW11qCFkleF4txJYOMsmM8nFWZ9 Vl1OFxIgigj+dS3yyDPAyMe/SriuVWFL4mTt9ks7q0W2t1m822D3U0TATEDkqfQ8nAp6sm15YoDE JcyCd8KTjA+b1/8ArUnFMk//1vwHhuEaUM/7xlf5VYc4rofISa1iu7PYI7S6PmJ5atucgkg+4xmv 9K/ZvofyhzPuV5iLxoPLhEkiuHOVwUI5yPTpmmLdW5nuYgoe4jGZBIf3rFj3B55NLld7Bdvcpqlx AxuJWU4JIRjl1zngCnQzC5lU3Vu32ZAQoz1POM8f5xSas7DjJonuoLlokktRmBgcyLyVx2rmYLQp fvfN5txeuPL3yZ2qO/H9abi0XKdtEf/X/Af+1dlxBZSkx3EzERZGAccmuumktLe0jY7DI7ZkYD5u OMf59a/0oP5Vi7rUzGmCs/kyZQqG3EFcMQMgZ9KrXNvLcWrRyXDKZXBjUjhznofbrVcrtcib1sa2 nRS2E4R41OLYIz7Q0UgIxjHrxUE0tqGkhu22BzgEjCj/AAqbW3J6WMya4h0dWtndo94EkQC4NwSR 39cEfkKVpdSu54pIPLl02zUCJZyRMSeXx2/D65pxWqOmglzxP//Q/Beeyvb2+ilFyyQBcSwOgJPp z/npTrXT79ZbiCK5ja137zvyMeoxX+lUtZO5/LtbSs7i6jBHZW7ThlXaQqnpuJIGP51mXrWzW1vc +dJJEbiNTbR538uqlm9hnP4VzOLRLl71ya6W3N481ruSGSXcqA/LGO39PzqzpgiRb5zmaWSQrHg7 UQf1pFp3RkvqbRXa2F5CI0dTJbSK338MNwPoeRUer3jSXVj5ESR+XHsMu4lyM9gabi1uYy3Z/9H8 D41huXTc580qPNbGT9apauqSkLCheWIiJZHTaYxjr78AV/pDbS5/LKStdjra9itU8uXEkkhCEEc5 GegqxHPJdSmNIgI155HAp8to3Lbuminc77y4EIuFiZW2YPyKD05q9Y2MkUTRaixuoTN8quAfl9Ac c9O9JprcUl7qZPcyWd1dmCxheMK3lpCRhl9P6VWupbaK2XTrKQLqMMjTXvyZ+Un5Rn8/ela2hof/ 0vwCsS6OZ5wAgfapPByD2q6zXuqahBAm6SMYit4kUvIxJJwPx7epr/SFJvY/mBNrYsXFq6P5aofk G5kYc8deP6Vj3djcBvtsiMny4+YbVX0B/wA5qnBoQul315CsrRQ+YJIijuUJjjHHPt0/Ws7VrR9V RN0aSGB/NjHYEdf5U1BW1Al8+6C2M1/aFImfy40jbPT5eB3x6VsvNa285jgdfMaPc6kYLD3FXZLQ ylLWyP/T/nuuoDKzJuVjK3CsB8vtSwQNptnLaPGEjdsLLgsFLHt+df6SOGuh/LDbejLimz2JCRHu iG5TIAOR3BNadpqEIyNscsqjYA3IOBwCKXs2IyjfbJZoIY4xKXzcR+SGDA8nGR+orNM9pNL9nijK hic4HCEHof8APapas7AJp1uiajIlwzTQNEcbcLtxiqN5PBavcQlZmg8wCAg72wMenT6VLV1YuC1P /9T+eOG1julUxf6rAZsjA/L1p32C3UxrGkmDMcyoV2oMdMdTzX+jsY6an8rkpto2vV2zSCCEdWXy 9xHao9Xeygmhkl3fKQVx905OOfpQ4J7Fa82pJd3rwWpkspQpA4lXkpnpVK3lkhDs8pknUBp2x/e5 5pez8zZXtqOtrmO5klVbhCikbogu7JHv7U82cs+qQSeYWtgvzjHzcdP8+1P2aA//1f5475YTeKnl PCEwiOina2T1/wA+lOurG5l8uSEOsYOxwU3F/Q57dDX+j3JE/mWOy1IlENrJGzxMGVtp3Dh62Tqc ZtWh+zoQW4dRgL+FPlj2KOentjInngLJEWyuOQOauNJA9rh+N6GPYBsK8YBFO1tgMrdLcmG1UySt AixCRx85C9v8+taMEqwebaO3ljGZs/LjHrSaT3A//9b+da7Fp5ai3cNlsFA3BzVOHMIkjMvzl+FA 6DsK/wBIFG2x/MnOiLTXnh12OaZS8UWVeHdiORG4JJ9cVq6lfWVrE4jDhnlwgC7s5Pc0C59THktR eRxT4IKcEA4Dg+tXYjDbwlZZ0QKMbQcY9qaV3YFK8rEH9qp4eu7a+Syguxcv9n2yqWLZyRkYzjr9 MVT1W/aQTTw+XZvc/MHMe6OM5zwK3StojQ//1/5rJpDrG2B3t/PMQBJGwMqDGQPyH41v6bZta2jJ NNjy0Ece4kuw6AV/pTZo/mcrzXMdvvincRqcEzD5gufXH4VZsbJHHkLc+bJIuY3bCM1UoPqBi3D2 8bOYC8rI3z7eQMVNZXqyQNMrbF37ACMM5yRx+VN0+xSk4kU0MtwXDYBT5sHqO44qb7T9jRLu5GYl TySXHynPA/E1Di1ox87P/9D+bW4vY3gjkRBtc4JPylR0oSx3ZZJCyuN+Sc81/pQ13P5tjJMpfYAJ TK1w6vBlzGjY3j/a9qHuvItBOjxPlh5QVgXyTxxRYu76jbZLq9aZw2ZHUl9/Dk/X0qxDpFz5dtPc O9o6qPNAkEkcvque4pWWwgnS3uo8o/71ThHxhQO/9KpTWFrHcW1xEJVmSIxy5c+VLngnb/SmB//R /mwlfT47NbRmaNWUs/lDG3HOK57TJL+bcoLtbrLlGkjHzLngA9en86/0oP5qnude0lsHZ2WO3mCh tqJjcelVbq/s5F8t/NZ/L3M3lMEB9Ax4Pb9aznF7ogw2Rbi5d1jSK2jhCxocvJIccknoPWpUuhHb C2tnMab9hjSPI3E+mPeswH/2deRhoxcCFpVxvCAuvPJ/z+taYheSCCDdkQjYGkI+bHc/X+tBnN20 R//S/mstljMhnaTMgby3hJGY8cce1bMiWrWBEeyOYuT5jMOc4wK/0gsj+ZYu6KWk2E6RtcXarLcI S7Nn93xngUtxOl18i/u5Cx8ogcHAzj9KC02tjL4JZnU7kbYy4wMj/wDVW3Z3tptIkUxMi7RMgGR7 HvQNScdjPiv4mu50kV9pUokx4eTPTHp+NSmPzI4YWuyscjj5Xba/ynI+ucdKLWJlNX1P/9P+dxZp YxG80isEULHnByB6irwaCbMu0xxhfmP8K4HJ/rX+jnJqfzNdHKapeg3TQ2k73VmcZ3rtAPqvtVGK WRQU8vg/6s46GhQ7i54mjbvMuxTcxru4kiUcuPXHUVqW1lY3ru0twkTWzY3sCWjJH+BqOV3sNv3W VpLNWjntpLqG82zCW2LAMkWMFePqM888VFqOozCOUIkasibna2iCR4A5AA4HvinUjy05PyHQl+8j 5H//1P5LvEjjU9Ru712kgUfKI418tfkyMkevrWHF5flAiQs/8OeN1fScdv8A4yjGv/p5L/0pnmZE rZfR/wAMfyJZboq0DB/KeFvnVQCrdsf1rWS8+1MyxvgoM56E/Svj5rqemSQyksxdN4Xox5BpREvn OxBxIPlBG0Amuae5UbX1LsEptx5eBtUHc4++M88VWujbIDtcyZO5txBZTWUl7rNj/9X+SY3TSSxQ iUrGRjevLR8dqsrrdrFL9mlNwWRAkDiLzPPfgfMe31r586C82Zl8yYiMAcYHerEU8cgWFcSJ912c Y5oAnXbp21SzcfcwCWOex/OtvmGIXd4D9mMe6NVXcWOcf/WrKTu7ARPM06rd2xKBOBGUwSPf/CrC X0sgSASRhi4EspIBiXv+OKgTWjP/1v5irz7Pb2wuI5FlbHzeUhaQ4HpXLSSTvLIrSeX5qjySVw8Z PqK+XNIJNam9ZMkCwlWDywqP3pHzMe5qASC81WKRpkjSFWdUkOA2Ac8foKiexmTXxgmkWSL5ZRxn HGM1FPKRAyibkHGwHIz/AJFZAQWgu7Sa6kD5iaACRQvGD2zWjYDegd024JIZ+etAH//X/mIuLFpZ I5ZDELmEhi8ZDgr2GfTFT3vlRJBIXRpWGSqnLAdia+PJk7WM621Ge5KQzlWltm2BnTaSM8fhWzG8 rSxyuYmWWX5opSFEYHA2qB0OM8+/NBQ+aaFJvIkaPaDvAyM/h61VkjhFzbyOvmRl/wB2MblBAzk1 0LbUDWmnUxS7GVn2hDCPvKDnn9KxdPSczDeRCQ2MZ+Uc0FwWp//Q/myvn+xtbpPL5pkbahVOmPU/ 40sqFXjuI+pGF4zmvlZRudASPNKcSBEfbjINUra1nUx/bpWhUzlV8jcwKE8FlPfHP9azUGwNkWIh 4guxMqqSrsuCfqPWq8cjBAZwBKpK5H8X+FSBXhMNxNJG58vLbPMlOwA9M/Sks5JYHmikEaxxSFYm STeJF9e39aAP/9H+bCOSSS72tI0cNwwjiViFjB5/n/Sp/wCz4Jr63nuSzraN5kUJ/wBU7AdSO9fH 2sdBeuPJnuZJooVgZhjanCr9PashrMyrcPDexwXNoykDq7ZP8IrGSswOkgl81EllYRSNGsJZfunA xux0yeprTU/vEjVk8lU4lAw7HvUgWZmlnjfY25I/kTecbifQVyv2jy3kjvHaTzG2eUwyE9hQFuh/ /9L+ctCiq6QjKDoXG0mrMN0vl7Lnyo2iXaqocjrxXwz7FuFkZlxAIisgL5kyxbpjNVIbWeCB7ie3 BbzGkt5+5A6D296draDUGQ6X4gmvr2506cqDAQTOqnahcn5W+lbLWRli4bMyMWBUYDdf8/hQWibT 7e3a1aU5+0Ws5zHIhGScknHf+VW7jU/srpO0cML43/6OgVj25Xp2oGf/0/5z4NR86B3uP3PmsSh4 BUZxVprpYlQwEO4GG3Dg/Svh7HRY0bHV5J0uLBtyQoyzt5g2qWwfu+vTtWfdSJdyndIRt+XI9awa s7F+zZYYTw2ytGhuZIlwi4AaU88HtUtnHIIllvoVhnYbmjVtwj9s+tZTWpcY8pFJdXFr+9SAvFcO Y4z95Pl6/wBKjshMb3A2xQSDlQvO49/p1rMo/9T+faaO9tbxbFnSaMDzVuPMURANyB9RnH4VYs7e CdyWKKVbCsWAGfrX5ueim0Y2pW8IuREpjDO+1irBgGyAORW7Y/6PJDFqT3MpSPyw44BAAxwfpxz0 NKWkbonq7iXRglmGCFWM8sBiQCqUQs7OWaYXyzTuwAWNcMR1wR2xTiny3M6e5evI0ukiniKl0TeQ Dkp2/CooLjCYGWbkN3K0DirxaP/V/n3DC5jdY+cMevXIzVaO3kjmDyT+Wig7+cZ9q/NzsgtGXLiW OFUPL7hwMcU+1XSr+xu7W8d4b4kS2rrIVUheWXHvxVvSmZNXIN8RC+bIQBiOPccE7cAD6YAFSW0P lFgirEpOQRwKlP3C4q9wuZprfzEG2Uvgqn8VVgzbg0oCpnngZFFtLis1of/W/A5ns7K1a6ntDMij bA5BHzNwCPz6VB5cM4ku2+U8BUH3hX5udXNIR54/LOQzI3BB71e0DQfttpdzNqFray2qGZI7mUQS XA5wsYP3jjtQSVtTRbREdfmmiP7udOcN6A/hUMIZ4llC43MPOcj7zev1p20uaqTtqQs832x0VRKg QFXXJbPf+lWpjcPGsU2JIYWLxx45Utjd/Lp9fWkWf//X/nytLK008T/aC8sVxIZFU5bYTjg+3FW7 h9NvjGIoAiRKFMSn5SQMZr83PSjLlFum+z27Oo4t03xohy2AKbbFJ4Q32jBlXzCj8Z/A/wCeaDVO 6ubFjd6clpKsFykdxFNtlVEOZSPfHUdKr3EIhvPtgiCyzxggkYJUf481EVq2Mje4url4GTNsLJsl 0XbvBJJBPfrUl3ptpc2r332ovc3D4eMt8xA/iPp/n0qyJNbH/9D8CI7aC0snjuFMxAzEQ3zD0FZM NtcSWv2m4hMIaUJEsp2k+49eP6V+bnoGvdfZ4IbZoD5kpOyRX42juRTo2guYidh3I3y7hgce35UG c11EvFjkYuY7eFyuMKBErEDsPXis2zjU3KRRqS7yZIA+/wD/AF6DMs6otpJO0ck1wvChVjTofTd2 HrT4pYxbtG4aZUGzbnPFZyn2NIJPU//R/n5itjdErbBPLQfOuMbB0rUWwcJF5jhTFn/gWeOa/Lz0 LWGL5sKmO5UMWJYMv3QOcfpirRlkeIpbqA2zGCM7sdql6SRV7QZiwvMBJLdQLDGJPLIzktzjP41d GrWlwW0y1L+XZxh2CxbI1ZxnAPfoKVbWo7jpyXIrnQ6ZqsdnY+TLZi4uZSVCSkpHGOxJByT7Vg6p Z39xCZ2aOFhL5kMdtJk4U5AIPPb3qI6yVzS6R//S/A3SdRF5YG5O2Zt7CSQqVJwSMY/A0s08MkLm N1Ta2eO+DyP0xX5eeundFKGaB4mmKtHliib1wz44yBVSS9WK3+yQ2c13ePP5scjHagGPuk4wOtBn GzkaksYSOCWeALdAYaEnd5bY7GqE0E1xMgfKKDyq9aCXuPinFi7+ShaVD8uBnHviuoe7sY7WS41C WWO+uVHkKkQkDMefn54H4d6qSSSEf//T/AK9Z4ra5vYZkiDlY/JzlmbGFbZ1PIHSqVruv1SS4Tyr gLtI27M444+tfmEVd2O9uyuXTYJDMFkQFmTeGA4wPU/j0rRQLPtSBPNeNTmNFy2Bz0H0rXkiD2uY c4llnjuYGjjSJT5kLx7nbPb2xWhElxHEt6kUscci7kk2lQw6HFRKFthRd1qL9na/jVkmeHyW8wqo x5pHOD361TNzcCQJcHa+cH3H41HLpexak0f/1P572giWWSYbt0hAznkCliLfb4DB5km91jCAFgP/ AK1flc49UevF3Rv6oUtAbq4UC4RP3KrgqOxJrM0nURc/abedLg4TzEcoVj3Hp82Mfh71mMbPPdRv EqxHDttIB3Hv0qZokuooor2+lS3Wf7QsMZKhXX7ox+ArdKysBaN1bqohjTe0ymFyRlk7Zz61CrXN lpk+mXEi3drK2QGOZGTGMMOgPPP0FMD/1f594ZrcskXyx7FASPocDjgVqR22nmUvdbI1kwJHChnk A4HHc1+Zw5vkewMuky/7khkT/VBVw4HbI/Kp7PTZbzazBRcqjeTvHzt7A++P0rQAe6OmQpb30EKz zsFV0fzHjJz8pxwOnese/thciEB/LaN/MZ0wN+exPpx0rntbQhTTdjHmmlglt7ou8r24ZXgjjLqy 8cketa8uoLdTQbR9kj8nDh2JAcdwOoz6VSTabHKVnY//1v574ridVaOOFdqSl7tgedpyNw9T04+t XbfUrEOw8j7Rb4K+a4wVYHnjPXrX5eevfS468fTpFh+xRPbOjMTiYsrg+oxxVFnEkifIj7W2Yb7w Jzg0AndXReXUZwG3P5kYQRRJgEIRkEg/l+VJb3JgTz2yJN24hgOPwraPwo2grI25tYMFn5pf5dm4 8YyOelVp9XN3DCxiUQrEGDYxgdcfjnOfaqsCi1K5/9f8ILW6tL2G2lFrFZZjPlyR5YMRzkkk89Kw 5oFu5JVNyQJDswzbQxNfm59ALp2nXtndRJBqFvHbq26ZEBkBHTkjv+dbl1baXeQm2trdXSCUyG4M IBD9SVPbnJ+tBspaJnOLpk9o7Pavz98yP97IrNuLyeO4WZJ5LgMnlzRP90Hnn1zzWcpX0RMdJ2NT SdXuLcpDF++vPMwTt2gK3RcD2pl5O5Nz9vEUE4kbAUHYMZwoGOD2rM0P/9D+d+2upLxkhuC6+Wfl YLlQM849KvXl3DBE8Cyu0SSDcoQ7nA6HHJ7/AM6/Nz6eyehE3lOiSDKrgfL/ABH3IrPvpAzW+6Ei FD5fnKDuGT1NKKsrAklsWrWO2tt1tYK7wH96WXKxFj1+XPBqdmdlchZICmAswGAx64H+e9Mdidbk hNrFdz8FyKZPLst8TldqNmLBwcnAOPyH5Vt8IrJH/9H+de4mSZzBkIdgKDqX6c1btbW1W1Khx5jZ EkTjaSR0OfSvzc+ptZXKiXMFnGwME01yswQIowpU9wfapri6Mt8baa3liRVXacApIGGc/wCNRN2Q NNbhG0sci2ySeTaRymVticEkY+vpQ0kbQFWkYozMSsnGM1m3cRjpp12JgLO6hazkjxKj/u/JbIww P44/Kp3sPsdw1qZbW524ZvJmEyDOSCSPxpDVup//0v52Li8NnbyF8CFl2MEj3EAeg65+lZ9p5NxK Ut5QIduSjDBO7uR1Ffl59QJf28jLDAk6xRQyZbj7yj1q6mjm4S2mErx2rPxIBiSQDqcf56VrT2MZ vUiOnxWxeRBNNvnKbpVy8ic9R26Yx71bjSOKNUMRhgTiMAfLGB/KrJLUnkywzuBDbeRabIDGpbzH HQtknk/lx0qh4fXUVuGlSfKmbzEEiBoogFAY7T1zg1vDoJrVM//T/n3knvLK1u5odQSGIRnzraQf LKD8pO3GOMmuY0u401rcExiW4jViT1znoQO1fDdbH0jgkeufCua9W9Rp3kSPztysoCyYUkgD34Br 7s+DjR6p8S/C91eW+rTXCTyxw3UJJt7R5E2Cads/dxuAznlhkdx/RHA/NT8P8bUf978j4DMnzcU4 en6H9rH7Mdp9j+Efh7SroyXE+l2EMD26gfvC0YdHDD13ZP8AvV/PX/wVduNQuPidpM1rqMUy6bcm K+sbxvLSbPmDYv8AeZN5I/3j6V8z4RR5+Mb9rnt+Ik1DJbeh+A3xPjfSNH1W3Z0W+jR57ZGmDxMG JLknnPyk4+tfkd8SLq1Oo/bXA86YYdYkLiFcAryB93JPXvmv1fxjf+wYZebPhOB0vbzfkf/U/hea WK2vpXt1Y+e5dw/zEnJrvLaB/sAubzbbo4UJHICkrFuhT2IrjqtqGhrJfvToJJFRLVbi4uI4LWMp HaxRq0cu7143Zzzwee/Suok0zUba2ig03WBYpKizTvAgWRVkAbYX6nqM9favKxD0LJbHDfamle5M 0TLF9qDlopvUg+vXOPavUfAMC2msTXVqsU0t5aKhG3M8ZjYOzjHOQBj8/rXl1XpoXHRan1xp3jWP TLaztrrQn1G+uIV/tC4uY2W5ZGYuux88MBgevr7691qtk92Li1tluNLcA+VJCpvbcnG7DdeOmM9q 8morysdEVq0f/9X+MOHSrOzttOvbuK7gWBlnEJcNcGRfmZQRxjPrx7969qezsZE0STRNWd/tVhHe 3bquZbOVvvI30P8AOvlaifOrdzKnvY6jzrpdKsrG/mW8mjupPInlQRmRDgiM4+hrpbLzIrJzHABC HUyshDi3OOEA6464+lbwfu6HZyq9zlPGV3BbPFc2tl50LI0ltFd2+S+cAiVQOmT0PbPvXk1vG97Y rc8W7NOyy2qKQluQcFVz27CuunKyFGGuh5xr9pc70+1wRpFeTm2gjL/67tg+hPpWBY6XFb6vcaQk V3bLFB5dxJbDzZoSecISeenXNehKfupmcviZ/9b+TD4LalBHr+lW019d3N3HI7eY2YTJa/LG+9Rx gAgdOSB61+iPh291OTWrDVdNuRp15b3sCoLRhbxsiMgZW9tgav6r8G7vhaaa0vL8j8h4p04npTT1 Tj+Z/d1/wTu1uy8R/BLwTrGmTwyadbaJHYQWwiZFjlQqTsz1VvMVs+tfAH/BaXTtN1TwcLC9s7sX Nu0t299p8fnrYOLqMvuj6sWUgYz0YHHUj8KyZTw/igo9VW/9ubP1bxZinwxTdukPyR/Jb4ma4sL0 2zKGtITm3IiMTlCfl3qehwBxWSbb7eDdzytAkEBWOFh+6u8HPzfTJ/Kv7xpWUV6H8j4he9cyy1te 3HlOpQQkSpFDlY3xxkHp+dZX2O0tW1Cf7LDYefP5ovEB82VyAAJPTJAFbxtZHM0f/9f+fy5tZ7ew /tCSW3hnkUR+U8qrNMuCVYL3HWqd5a3erafa3V0w86O1NtasrZigGQWVQPUgV/pgfxjL4mYwaaza W7kBmdI1iljVR8yqABgewH6Vbk1hLZYBFp1zJpqgz3LW4+dd3Qt1wM8VcOXvqKO6K1vexLpd3cXL Mbh5xMisqqsMXOBuHcAj8qtQ6fI8UV3NLE6XUO4tHgyBT0x+Fam43TzpVpapEZbo3P2llHngCML2 JJ5yTkc+1XLmW4SBHtWKMrEGN0yH5x0oDY//0P59tN0Y31nOdUmkRXB8qa2+R4T1XP5c+xpo0fSr +Gz/ALPcuHlZrl3kIExUYHHUdPx+lf6cH8dxehQa1ng16LT5hOftUSyoAdybAM/hit/UNMFxN9uu bovCZ2idFby95AHb0H6UFSdkcudJt49WhZL2WG0uZkicD94sIJxuX8K6d7XxAJxAbjT5tMj/ANHg k2eS0i4PJUDg+pOSe5oGnfYzbjQkjs4bPVbv7TdxXUk6yOqiGNZDwi46gDjn0rXMM9paOLeN7U+W Io5ZUD/dx8wXgY/zk0A9j//R/n4lL20U87y5luECISuRKT39j+VKlhcRWrS3MA2FAvmYyA3B4PrX +nB/H5PZziWzDXQnga1nNvEJePOUjOV56dqgs5NNGqmwtxgXMPmyy3DhUU55UMTjnPApOKYG/DcW sH2mCGMvPbfw+XvDKehXsaLfw1MWkv8AWXiKNDvstq/Z1GcnLc9umKn2aIldO5mW2py2oTZIsZkm aKFCMCVQMnb64p2pW99qUUDS3CxQRzMsMkCDy2JAJyDgkj644pcmo5NpaH//0v5+oL+OzvZW+2vK bV1i82QYLHgDPoT6V1NzPpq3j6jcSzeZNZqBHkMS4HBI/H9BX+m3JE/jlykXInku41zcOixIWgkc fLFkc49KwLe7hsI5JbwSXEiz7YUDb12MSDn65H0ppWVi4Sb0Zbt5YLe8N9DbQu5j2G3IG8oSCRn0 /wAKmvIPtd6Jm2RwBNojRMAcdMfj9aY+dbDIdMayuVQQ+ZG4zlztYZ78/wAqvSafA6XUdp5f2+ND couAUJxwD6UEqbbsf//T/Ce9sL2Kxt5bmeS1iuYgZF3h4mCtzlQeOckZqK5i0z91HbqZWWNWMkiA 5OBnBHvmv9OD+QVOSLlnYWmoFEaW2tI0UvLNK+xSF7DrknoBisXVyfMazijlh8tdiGddofH8Qx2x jmgfPKxZ097m9gNpKsFwsEQRXhk3cgc54zUdnFZItxbRxNDHCSx+XaF5OQG6ZqZRuPn8jd0fTrOW 6gjuZVtLCRT9suLjOIhkHeMc5Azxzk1gJLptze3ltHPK0TSeVYO9s0YuMHBAPbufelyaWLTurn// 1PwZksBZxMsEzRSSMP3zgNjBzjGMe341TC3l/dJDZrBA8fLvqEnlwSgdeccZ5xX+mko6Kx/IkpW0 NK7u7eK4W2aCKHyIxGs0M3nKzdyTUs1vZ+bbXs97P5llbtJ5ca5hdjjbkevT8+hqFdPQhybJ4NT/ ALVDLI25WjIxs2lMf3h2rOVrO3t4uRMcGKOSMbdpY53t6jtRZ7mkXdalqGBGGyR9xk+eNEbKP6Zr GbUkgvmi+z3EyQQlpLuECS3hYHGxsHIP+c0jRSaP/9X8J11DVYLJoIIpJCGMh35EcoY5HP44/Cj+ 1VeSCGaJuTh3HzbPav8ATA/kyM76M1XuWilQearptBhtwQWVScEgenU1jeINKutSa2a3ulspbO7F y7ocFlVWBXI9fxoHJpLUj8KzwG5llkDz3KMYFjb5EYHjcp780zzLnWLy6KWkummCQxHJ3CYA43t/ ven86DLRyKt/pi208U6wOwVS0kwOEGO3+fSudXU9T1G5iiWWVfKLQmDylSN0yeM4zjvn3o6k1lGK SP/W/CKS6h061VLZEkkd+d3GPXNNd7p7i5cW8U+ni2VyyMVKyHHAGOg9v/r1/p3f8j+Q/Z6GxHqi f8S9wLWUziSGaMbg9qQMKzAgDvxgmqZitv7TBsJC95bIZZZSQmwMRlUz19/5VBaXKrF15YPtX2mV IZ/KiO60Jw2cYD+vB/DisybUBBqmnYu5LO1u51RgQGCfh6npQ1pYZU8RanYssq2RczBjGDKuyIMO N34/5NWtMWy06z06ycXU19c2pmmubhw0SuTkKPX0BpJWWo7s/9f8KN11JcbrpwsIQII0UKox3z74 p1o1rPd7UkE0sasTAxDQ7eDkjOc8frX+mVrQ+Z/KfN7nKS2zQWxkF8qwo0hWOQnCYzgE+ldJf+Fp rBIrpdRsbplC3DxW8u8wq+CnseCKkTeiOR1K5RYL91ZbZhblJ7hCFcIeCTjnjNaSxWRtrYwO1zGt qgDSgZYbR09v8aC5bpHO6pplvdQFGi8raTIlwjkOQeOR0xWZDeQabIlta+dI2A+9+FJ2gNj8qaTe wpuysf/Q/COW8sruTTY3t5LUbsXzZB3f7XPc4rlNak+yQSTWf2eNZbsKm+U+e67wvykDrgk9s4/G v9MLW0P5POvsod8ciTXAWT7MsmW+ZzkLhR+f6VRsLi00vUFS9g8y3mYicxLliNpxQOL5R8UcYKan cWixwpG/kQORulJPyFl9OP1qO6YX+nu4szHcyyFnWIjDqpyoxj2J69DWsY2WplKeuhQsJvLW5u3D soO4xRpllGMbVXrjg/nW2LqHybf7ei20b4+zpKQMg5KnH61Mo21RF3e5/9H8EtT0yKGWG8sZJJSw y0CoFTOeNverULXunIRIrGKYiYowO1mx1PuM1/pgfyW59Ea9vdwxpvEXkvL94gZxXPzDytVLwW0V xcXxEYunXEkCjnA+uO9Aud6JC33mwSQeakkssz+XtVflHuaW7ma0lWwkt5ImkXzJLqXCRRgDO0e/ epcU2bRLmkakotLq2Bi8uQMPNPOB6/WmWZt3aRI5BLKAUXI4bPGaoR//0vwXi8qO/sV1C3tHnilJ iAOAQe2eOwrZ1G1t72C48l4bWeOMyoxOFO3nbjvnp+Nf6X2R/KlPY5+21i3iuRa31u0iMmyNohzu Hcj0zSvcz6hcRQQxEPE+8IOihec5pkS+JmwL4zuqsf3kI2sv3Qfeqot7rVLoDYjJHIA0f8Uw5wBz 9KLEN2VyHxJHDHLapNHcfbIm8llaMlVPGOPbA61p6XFFBbMzSGYJ+88rGBn0H5Ukop3N6Ev3kV5o /9P8Eb3V7yBvPS18tZXKJFySvYVq2V6piVRHIbuQYmXZtVffOea/0pk7yZ/LOJdsTIqa5DOtvFAr qxkc7Ek4YZxnH4dqzbLSUufJtEleCZZA0ssgzG/09Kl7MzlK2hoXH9nWlvdQG5hjfyzueU4yQMcH 19qoaTMDalbYxuysS0oO1ee/+fSp5Fe5dN/uzE1S5VhEwhL3Xn+XvXnj2/LP4UPZXOoLbMkDtJbs CWZjGu3Izz+B4puN3clvsf/U/Bu3FiVK2wKToAkm455HWoLpDHKI/MR9yhpAOQOOOfXmv9JuRWsf yupbpFGCCDz/ALRGhcRnJ3HP1x+tX/7UtIVkvrW0P7uRoTDcAhZCQRlRxn1H0p20sOk+ZyMvT4Rq Ukt2xxAUIAePDBgevPuK2YrpmkhiwiOh587iPj3pOzVxu+iLslnZtHc3M8skV0V8y1iiQFbl9wJV myMDGea525S2OoyXotmsHlKtJawObhI9qgcE8kcdyTWckk9DSMuY/9X8AJLkS224W5EORIqyDY5J 56Hoas6Vq6x3+ny2vmWuo28xlt3XkKyYPfg9RwfWv9KD+XeZI3LvUtWutWfVbuSFHhTHl/Z0QyMe CSoAXue1c3dPqF7fvmRjbk7lUABF4GRj65/OgnnfQnaW8hglsoSzIzb5MLtMmBwD+tVLa+tYSNPl iljuEV5jMIiyNnnaWrRQuiXJvYktbOK+nhkZJkZD5qu4YIOccnp3rN1C3i+3T3ao5FufJWRDgzjg 8enX9KbgraEn/9b+dnzL2acSyxeXCuAMnBJrsbmzuEtTGz7t9usybSJA2QGAz/nrX+lFraH8sr4W jB8iDU4IklSS2u7aUP8AK/K4HKn1zWfcCeO5RbQrGgBR5CSW3djTcWibF/SlnjjZ7mZpbhSVaRow pcdgCP8APNXUihU7lgdnlm+do13Fdx5Y+w71nNaXAt3mh2LSLcHU444LUbrluY5Ju2FFcw8EUs8w snEkH3x5h3Sbc9RWRSbWh//X/nrtrXy4W8qQ7pFOCpyBxzVCxtL5Zfts8rqy5hS1R8wquepHcn1r /SA/lc1LsvNui3iOMrgMi/OW96bPax3Fi0V0vmygDy3PHI6HFFrblcz08ijb2/2SwH2aNbxzI0d0 jtzFg8deta1tFEiGS6jVPOH7zAHPGORRY0UkzFj/ALKsxN9ki+ZZPmRRjAqSXUY3aEQ78KMFUUKT nsarl925R//Q/ASzaC4snzJudH2mJxgrgDB/WqcuqxWAaJzLNI5LRoFyDgdBj+vvX+kkI9WfzBdr Qx9RnN5ZpdRxlXZAVib5dpI6H0NRaP5qypDc/wCplPKdSDz3q1FLY1g21qdJNa+c1ybQ2sVtb7Qb cMEYZ6hVPJ9T6ZFZOo2xnjbYVinCBU2gLgdBgUcq7EOb6GdCxt2AYMxCbZJFGCvuPyqvIIi0sS3A 8+b5h5vBf2JpcsexB//R/m9g014bqZnuklhbAWJR9wjuDnvUttDv1B7aMFRjO5+AuPev9J1FJaI/ lznRovp88EzTNJ5hHAAHGK5zUVvW1CEMV+yOCSMHKY70cq7Fj4bm5ecW0Ct5BHzTAZVO1a6QKkRa eFpghBkfsOeCfQZphsRbpRIZZ0jkQcow5Tb2xTngFw0g8tntSDIkLrvEY7jNbRjym61R/9L+cW1t rRN0mxYEgjyiheQR0UVespo713j8wHjP3eF/ziv9MD+ZzO/s+OWW6jwpZnH7wfx44GfoAPyqWcW2 mwOpEkspXLkdfoKqMbvUHormdp6wW8RheHa8hyspbOR6GrNtcwzlraFY9sMhG/GCDzmm4a2QLVXM ++uXt7q4m3JJNNgMzAKvHqBVya7ja3jguEWWMjfHGR8m7HDfh1qWrOwH/9P+adbbz447ebYPKUks g2B89eKmhl+ww/YoXeQbifMk5cA/w/Qdq/0wa7n80J2dxsVy4njjuLceVMWHnnggjoPx5qlf2cUz vaxQskGVYSKNpXudmOnIqORG4+CVbC4WKV5PJb5UkVSc/X/69dKbpJpo4vKklt9pcSoCY0A9T0yc j/Io5FYym9bGLPdiC4MMFnHJEp4V+F69cD/GrMyyXIjdhjcMBBwqgelJw00BTaVj/9T+aW7Fo0ht WkW3lWMAbwQ8hJwAO3vU4ZrC3SJ5EJAIiXvj1Ir/AEpUWz+ZpydrkNpdYDy3kZkk7BeeKsA+a6yF cgKWMWz5P/10+WXYxuznL2VzcxtasyI5xLEF6jufbFbOm2eyM7HLAEtuY5bmsnDUam7aGl9riicx SsWmAymR2+tEcscx3EkBGwyH5SKSp66kn//V/mx1GK0guoJLFcNNEUmjL/Jv/vfr+lMjms9v2O7d ZbyFEkdoCRbhiDkc/Tiv9JeRH8wJtbGst0wtQqeWkbP5ESBgXbA9KhFpNbxSOmGZV3kBcmiUOxUH Z2YlrYLrMGXnFlPFl3dhtU7c5BHfNVWsoIIARMLhZSyqsTEurDufaocWjW6G6dbC4uAxjVngUqCe i55/pWi1iXTN2kQlSQtEEO7bjP8AT+dSYy3P/9b+dFZYEiRZWBf7oU8k1Ykvo44fK8vdCw2Njjjp X+kB/L5zrRLNcEQYEajoBgqPStyGFigXZEUVeXHJ9Oaai3sBi29tpjX090sJaYZWTEnz4XoMZ45/ pUF3MyxPJGZYI5xteNhhuOxpWuwbaTKVikUaN9nLL8v7wux5+lW1tykFy7SXC7lLIMZQ8c/h/jU1 YtQaZeGlZn//1/5FvEGpzfamYRBLRm2p5nE5bndvHpxx+tVbaEyAFHAB5QZ+7X0nHCvxPjU/+fk/ /SmeZkvu5bQf92P5EzWBWUGVty7cjHr6mo8um5Co2ZwrqOcV8jJe6emXILreiRQY2wnDjPzN7Yq+ ZS6RsWJKPlozwcelcs11AsC5jYvKXATbgRfxMfesm+CKUlhPys26TBwEFZm0XdH/0P5Eo/LjmBLf u3AKuB2Petf7PAAsqNuVDlCBnJNeBJWdjoNK3vI5RcW80XPl5iYjlCCOaSNogjOo6cOAME470jOm +gwalb3KH7PJI1xG/lhGiIHBwcGtmKWaeExSyf6uE/ffaq/59Kxk7s0IrN5VZvLlBWPl/THQfSrs sjQwB5YhEXfG8Dg+nP8AnrUky+Fn/9H+VmO6kHzJKQAAAM8DHpUbJe3moJPbkzujCSdJDw47818u aQ2ZsXNysMgWCNo88Mj8lTUcmnvczrPhgQATKq/eA7H2pNaMzH3BxiFdzMpALdMfWpre3ihLBstv wAT0T8KwsAs95Is5ijjZ4lUKyKMlyOv/AOqr6NJBatLOVVHbMa+gzjFNqzsB/9L+YVfMjJwzqrfK zEYDD/OKgkiIuopcI6x/MAeckdMj0r48TVySWJ5ZvtMqITK2ZFAHzH6elWmiSe5ebY6vFEiIqD91 x3I9eP1pxXvDJtRhhuB5eyMywxAtLyNxP8PPpipbFpF0ScyWsRuAp8vy38yRWHTH147d63ASzvbV YHivIrhbx4cJIkBMbY6At0HfvTREZbQpJI8Nw7HbIg+4Ox+tBtBWR//T/mauNRAkt4rlWmAQRmWM DcMDAJFWleVLRnt5EadQfIW5Y+WpOcZ74r5c6CxbrLNbyvdurXG0Y8sYRTjnHtUqywiJjLcSSuFC xx+WAoPc5/z0oAWxu0ilZZTgS8IzHAWqk7st2XdtyiXZsjbzEA6KePwzWD3AknichiI9kgXcgb5F f0pIrc6ha/OoiaJyG2vjBGR1HNKwH//U/m6trS2l8trz94lu25FLEFSM4NWrlICFmimaOOM/d6nH pXx50FKQPP5ZgmaOPcC7bcsR6fjUqwRIXfKt5oC5A+YfWolG+qAcrm1QQJsZWOQo5ZavC4O1FVCG 28egrICCXfMkZupJFaNiYo0cxlfQnHbPY1UwFR5thneJ8A4zz6k4pN2VwP/V/mva4maYeajxwFgW 2DjjtUd0wF1AkIEonbaCeCBjJzXwTnrdG0vhOscwvZxnYU+Xbs7rt44/KoIJILhfs/mNlW2tuPyj PQe1arUIJpakj6G9q6FofLDHfnby4PQ/ypzF43kQOqnbmPj8s0FDlDTyxLGCqkfOxPDtVE6U095d Nfu6SxZWCOJt0XB43D6frQXBK+p//9b+dWPRUkRW88yH7vk9CuPSm3emTjyTFG6lRggjGAPUV8Oe gLFOsUGZQu5W2hieSKnsbdZrl9pjEcq7wWYKOmeDmsZfEwLTSNCzxpl8HgrzmqbajHLJJGwZCBsZ W/iOOtYT3AW0lkR44PszNbnIjnXBCn0I/rWrbwGJ2Z5SWzvBOMqPQVAH/9f+ee7ubdpg85xLH8sT ZwfQj8as27pPHvKEQK20yfwk46Zr83PRSu7Ipaitmo8m3RNw+ZXHzbW9c1vuZLzTrVGuBEECncFB uS6gbgf9k8cUdLENWuYcyPvkHm+ZxtUqPunvWXawxi8m2sZH27WDDbg/SrivcsZxfKdFbzC02xbY keZMXUx46dPy/pVyw8krezmWIbE3QwqmWlPfPb1pqGmpdPY//9D+es38A3ypmJVfc4IxuOeeKq3F 5PczCNII2tJIhmR2IySfT/PWvz1xurI9BJLY1J4pZ4oVSUeTAuA38KE9acbaM7GRQJVXbvAyT61E lakxKKWwhgtriRI5VbehyGI+WpdQ1MRIllBFBJbxJu+0mLZOzYGVJzyAan7ERxjaNyna3KysjzEB l/h/iYU65AaSSWEs0bLhUxwp5yf8+lXb3DOPxs//0f5/7K5HkNZ3OZoFUPE5bcVfnjFVyZbZ5HkT C7jhAc8dq/O4pWR0szklnnl3KG2BuUAzityaIt9lllwkcZPktuw27HPH4itLCKVwXN4kbzN9nxkx seCf7wqheS6nDZ3Wn2eqTGCe5E0kkcasvyk7QMjtnGfb6VMklGweRBpF7dxXEhuJpHwm0ttAD+me 3atyG7uAXLlZVkB+6drKewFYlc0j/9L+fecP8qygEkbyB8yj2zispY0ju3uFLBWTbtUnauPavzc7 07q5rW0xmIifCkn5HJxkehFWJ9O3RvMikBAV81OqfT/Pak3ZGkZW0IYILW0gt5A8kgRAZXmAVi3d jUt1p6Tra3MOp3clyJGDgbQYw3IGcYx7Y7VFPsNS1uzejuJIrdbef5lUYLso3P8AXFc/eTWsU22J cO3LY7CtAlFuWh//0/wAjuQ9yI7jACoGVM43DsRU8WqJcK9ldRtNJFJi0VvmEYzwVr83PScWnYgf TzLL9oIMewbAC2AR9M/5xT71obK2t3jlWe6mdkS3DDMW0Dlh15/pQS10ZkXIW/mt3vZiZokG2KOP EaEcH8fzrbjeDAuYyEFthl7E4/z+lTLSIWRmSTSXDvM67jK5dAoyACcj+lXpTBFAPldJJFC7UUkN 25rEEraI/9T+fKzF/HPLHJEIrfOVmV/3mPcVblvbqcT2MCJJJMPLjeRvLxzyc5xnGa/Lz0BcXUdk 6StudU2ruPce9OjuLm2tInnjeN5iGRUUu4GcdR61Li3JWKirpl2W5EkWxwhyAWGMtVW2kjR3jS1D SbS+1V4OO5xVVYNzM4fCQw6tcXCYntjEY3KRqDk8E45/z1q39mvJ4zKW8uRVJBk+Xg8YA/z0qOSz Vij/1fwX01P3UtqVRolUs+AEwB2B/wA9aoXVrZFNqqiLCd6Z+Uq3Iz+pr8vPSTSTRmxRQPIGSd5/ LPzIv3FI6itCa+sxPH5YTzUTLonJHpn8qAh8RS1HUFF7BIsTssmefvLBx6+9X7OVS7mWVW3/AHH7 AUk09hS3dipLKsN0zgAlhgjGN+O9XrhobqATEKJIwBjOGrTmVrWBqx//1v58lu5bmaQrGjLDhFDx mNAwA5Pr2ORUkOpS3F2I3WEXAOHdCFhHvmvzGHxHbJN6Iu3SXkv7xZVES8MpPzNnpj2qtBEsdvNO J5ra5VgyvDgBgOuT9K2FNWKKXhtl+1RQ/aQ7eUVJ+UbuC34cmn2ur3H2poLy5P2KGM+RACJIt3XH tk+nHNJ7MKa6mha37yXO+NBFvAQIpyhA781NrLwxTwOjxziSAO5Tgo2eh/L1rJPRo0P/1/5/IpYW jdmZHMfWNW5HpmtLTb3S7cSx+SgubgZhmXOY2HX2wRmvy89ensVNV0uWW6iuvtrRQyxhJRsDxpg8 kZ74NUBdOrO+mD7XawEcTJ5XmY6j2796y5dbDNfT7s29oL2+CQ3Jdmtol+Yj0H6/pWbcvDcos8kf lyZyUj5EZ9q3gk3ZjatYhtHRZsybgIzn5hjdmteZYkCvuV2lG5Tndt9j6dKuKjsI/9D+eyaWNNtz BbwXFyknl7Zn8tQDwSCATVjzkng2yIpmDK6ckCMg9jX5uewWpLmG3VjETLMAFkIwSCcfpzU9rr0d m6qJyLg5VHH8OQc/j1pX1sgbS3K1y25JZcqyn5yx6sfU/lWBb3xuLlLFHUyk75SWwEUZ5x+FRNGM NZWNZ7ybTr4/ZQNhi2HIWRJAy4Of896hkgeb9+wGB1A4LU4u0RS3Z//R/nnidTG8dqNru+ZS2fof 5Vekjs9PMQvJY0iY7tyn5WLf/XNfl560XdWEvWh02A6jJZPeWKny2+yyD7QxPTbwfXOfaubXVrK4 uY4IluIN752mMvOo6kMPp64qorWxUY9EbiRAxyxWFw10DOfKdofL2jOG3DPGCO+aS6hTy3jiuGe6 hX/WbflPqMH6VpD4UdBa068a9szDqShZbOMJA3lY84Z6H0wCefar1xdTvHbRQwWypEvlmVh5bPno W7HFUB//0v59r2eWKHyWkaSSBg6Q25whB6nOf0pbUWFxKhvFeZYx5zRxH5kx0J9K/OLaXPoC9ZEK 0s9ltaEMBNGcZGfUfh+laS3cdqYkgchZ8yTK0ZEcfPIJ6elJroUm3ZFe6vNsMkkQDBjsw5wyZHXF Y0EAmWNLeFXuBISzHJJU4yPwANYuLihpWnYdfq+nXkdzboIn4YjHoB/hVUBNVlZGdoDK+TIxyVJ6 nmlaxstz/9P8BfsENmPLbrEdplbGX9+OOapXFrBLm4iGWjG5yRgECvzOM3fU+pas7HOXupNGzlY0 AHKbW3bx64xxyDT7C/ivzLFeTwWtskBkO5S5YgcAYrQEruxYtjHaRyCMkx3agB9xBYA5BXmqep3s w+zR4Yo7eUdvRAATn9P1q42uip7m7YNDfaW8saIfIl2PMW2zEjjBUn2POKxbu7hilhRrc3mJQrxI +0nJA6+39K0aurErc//U/nQtrCzOoLf3JMe392I/MO1BnI696uagsMMk0rG4SKL5kKLvaVcZ4A6n pX5y4tK59U173KY8RvElt7uSSR2IJhtXjGFXORv9/UZqeCWZizSY8wP2Oce1YzKlHqazFJEBYtC2 MYIxu96rx2lozJ58xaFXCzIpw5HfFZO/Qhxa3KV/p/lz+THLIkUh+RTwzIeR+lVE06KS9+fMDuqx mRTh5FGeD+tMR//V/nNvDHabYnbzF37SSM7frVCL+z4NRg+zM/m3S4eHqg2BmJz+P6/jX5efTp3u bs93pDMzGJo2SMC53nfxz83sOD+tVLptYt4YJSmbKGUravGxIZSM/NwBxzxzXRFN6GSS5rMZFq89 zGVaApu3fOxGF2tj174yK0bPUUnQwE7kYeXIGGVkqY6zaHyO/kZmqyS2ybbfyFjDrGLYOVLrxk98 Y6/lVu0mkjVHiYNgfNGOM+2K6o250iXFrRo//9b+dW7ubm9eWNoTbbhsEWOAo4yPXPWktDolrJLD b27C9jt1WVn3Ix9SB0PQ18Ppc+ocXax7r8Mby1uB9lWFVuYZPMBkXE208ZHtkH/Jr79+B1jG3jXQ Y0maOQ3SG6tck/aEcMAAByeVxx3Ir+huE3yeHWLh/i/I/PsZTT4ow8uuh/aL8BIba3+Emgah5dza Xdto6pdLFCfNYqihG564UJ+tfzO/8FUWgf4uXMjefOtvPcy2t4J1MbSAbwrx99yowyORmvA8GWpc WXjruev4mU3HJ0pK2q3Pwr+L1tdzeFtTmSJLG/vEaZLniYWyqNoVVbrgsufZe/Nfjn4rlWW41C4i vrstpUz6dNbyRBfOZDhmYDoD1znv0r9M8ZZ3wmGS7s+E4Fg/az9D/9f+Ga0lZvNn+yxpPIxMYJ3m Mg9RXV2erXktsiXp82eIYCbclV7Y+n9a460JOCS3NZO1R3Nd5n8j97KoJHII556D610/h+UqsL3c lw8MiMIovL3Fio43Z7cda8bEXtYpfEzoluldSBEEhkPyxYxtHoRXqnwvlx4uguILdoEhtJESQyBw SVAYBfcZ5968qu+VNlrVcp9faadCuL2CfVJpCtoPtKwxsM3DKNu1+/QnH4VX1O606ZrmXQ7Zbe3l lLJGclh2bOffNeTKfvI6opqVj//Q/jauIr7+0jDGbdbL7EUnkKi5WZ2IPynnaygYyK6LwuJdGgVY TIbC03XF1Kw3zTKx+6D7cAV81PcxpayR6TEseu+QBemDERkVcFZlXAK7VP8AFnrWdG0+mwS26ahc QXEtwczlg8kfQBsHgY569M1UV7uh3EGs6jc6dbtb3N43iG4iYsNSbiGYHOAMDkDIHA7VkxTWGtaF cyvA+my2V7GiTQOYxLIeWUDoR710wWg4NJpni/ivV7WTVJdMZbi6ls3SeRBEUVB95WU9Nx4NaGj6 rFNqv9oRWlw8oUr9kI27I1HHmP7iu2WyMJfEz//R/lR+Beq+G7fxy1zNpWom1n0ubSbp3to777I8 oVlkhIxjBwMdfmNfaelyWkGoCLR0vLqQ3cU6R3eFkcsypwucAAHpX9V+C9RT4YqUrfC5fc0n/mfk fGUVSz2lVW7cfw0P7mf+CW+rC4+Den6aYkj+xWIVbOO3KwwNHFEQsLDjaCR+Qrwf/grv4b+1+ALv XZ717OOPzGu4LM+Vf7jbqTMvqV+UA47V+F0n7LxNut/afqfqniovacHRn5R/A/jz1f7RGbm71u7k 1RZsrayyhBPcIAfLBA+UE8cD1NeZt4i1FLua1vbFoNOlhV4bfasgtmPbd3BGD+Ar+7qetNH8l1le TTOjsHtxaPa2luZI2UNPfzxeXGCDuKwseeOBkccEVy17d6pNqWpqbpZNLuJEms7IQDzBhfn8w47n OAMj860iruyOM//S/nitp7fVZZLvVbGZhYQf8S6FJfmuDgKQxP3QAOPp2pbS7uXtJLO0ZFeLM6RT OBsBx8uenH64r/TA/jKe462lsbkGOe5htWybW9e4nCiORh8mB6HPH9a3oUsdK0+9ebVra0jtIC8x eX/XqGC+WoGd2eBigcF1OckjiuJbiVxbtZMyymIReTFHGwyuV9Ota7XMep6emp2iW9vAoaCO2tlO f3YC5KnoDjj8a2je2pr0OZtsXF07XSARkYPmfKGPbit22s9RlvppZ2nS2uF/cCQYiiUABdi45zyS cmkpPlbY4q7sf//T/n01DVZdLt5rW2uHeCVo47lYVEkzuGwPlHIxuPTsTU1hpEljBNMl2yXU5LwI 7Y37gScjPoeg9a/03i7q5/HsY8pQF3Pa3LxSwMmoSDNrqcTnNuMEMNp9cj8veuxQWE2jRW90Xm1C acjeowsgK9wOneqW+op7HG/YxBcSRWsLmBiAycsIGHQ59DW000jhYUDEwgGUR5KZ9qRkVbG2fUYt TtbkzwP8otLqcZBHX5T6A1W09rmKf7HcyzXKRSYkeSbduXgYTPT19Ke7sh3aVj//1PwffRraWxtZ JA7Wy3BUlPl2YwdufXBrI1mwhljskt7u4XRluWmWIyl2kdOMN7DPP0Ff6dyjy7H8dwfQpWVrdS+a A4uEjZjAZQAR14/z61mXWn/ZEN08cnmv/wAs0AzuB5OOv4VBd9bHbbn/ALKsVkhWwlgJcyI4kkuF bHDDqOn61HNJc6xJDZq93LaxDarsCBgDoewFBi229SGDw4uqyLbR+WG0wyTRvvCSAqpyB9cYx71m G5svNC3tyLSUEQxQtLsRyOmAeMnv3oLs3a5//9X8EYtMnlSeR1gijZjM1yE3u4HTPvUul2enRROl 5efb5izyqrFUkQZOBgenFf6cH8cyVnYf/aNnLC1ksjKjKVkaNsbPYH8KzntLe+tNunXo+1WkwSa3 ZSzTj+9miwk7bHQw2xtLb7ZeIN6L8z4/eMD1/OtvT9S0q7S6uLRPsSWqB4Xvl3GQ5H59z+FBUFqW rnULe+R0ukhaV+FmiXy+f7y46Vw8trPp098Y7snzDkMp3SxggZB/woJa1P/W/CW11Bk0rfcxfaoS 5aSKX5nlHdfof61n3sUxtxNp3l28U/3YtxYR55AP51/pzZvQ/jyLbdmMktxZWcUf2uNn2h5pQ/3C 3JX2qawltZQEkY3C+WY03n5zgHp/OrcH0NEm9DR0HT7LQ2uI8yBbpvODyNux1HP8qW6ubSLzypEk zHcFRflc1ma8itYbc3El/BGoCi028wlQp69PX86sNYajJbxXlusaiKUBCTtMR/vAfgf0oGttD//X /DD+zGNnLe+VmK1YPcyyycuWIUEDuSSB+NV5Z7SSOOIxshQggry756niv9OD+RZrQzB4euzcNuub dIWYSKzPlwh55HrVm6jKF/szLLFDhXd+Fm7cen41kk27mclZlr+zbW3j89dQQi6jHn2lqf8ASWXg sPbnAqlNp1rfF3tHkhtooy3lM43IoHQn1rSN7aiu0P0m3gm3WLytBcIgESODgA8DDHjnGB9KgsbO zt7uQi4OyRyZkdwI2I/+v6+ppcuhcZa6n//Q/DifUFybaJBLdwE7YgcK/HHPpXH3s8tnNtmVRdTN 5zbfm2gnke1f6ZpNOzR/I/oWWvgk8cqxs3mRCFN3JjOc8Guh+wR3NuBNd3EEhQmQIBhvYUTWpMpc pZ0jQkFm7yNgM7CMxsGuNqjq3oep+lc/b2F/DNcebe74Ln908SgqxUfdJ56ilBe8QptMtQ3Uenzw 2AgaezjDf6LeTF/tZPJLP19RgdvWoprG2t54pLdRC826aOJWMqQjP3Sx54zgbuTihq09TOpK7ij/ 0fwY1WC/uXUpBDHiAHdECI3YcfrV3T7bUoLWKS8Ro4JhtEIwZPQk47dcZr/TqWjaP5H20KQskiku nZ5CuMRoMKwPOD/Ki2sLVUt7m6tvtRthxtYpM2SCfm/L8hULYC3pNvdXWp3qQ2s02YRIBDbtI8aD jGee/WsfTbKN9Vmub8K212KxuctGc8Y+nt6UwDV2Ms+YLLz1lGyJIz83HBLCrbWE8kVjO0+2SJhE 0BO5owMHj8zSezGlrZn/0vwi1BpYEVSVCt8rSMDtVf4ufUDP5Vn2+q6fpkxis3L3FwNhuJI8Oqnj 34r/AE3kl7FM/k56T5TTvo2vYpPtczPHDHlPIAIJHPTv3rKa4v4RHNBdzeRMERPODFpBxkFTzgdO 1YFN7E+o2VrcyC0lNylzKoaYqp2GPOCM4xzz+daV9dWdlp4SNd8sKLHCQ+1EUcYI+lN7sLt7lW33 ajay3D5jjQZx0CAAZGe/IJ/Gn2Gh2ogdrcSTyk77fznLeUe+OOnsc1rBWiRKVj//0/wiaCBYhbTg G5jZmab/AJ65xxj2wenrTY9CgmRLd1eaJ8MvlL80P06j0r/TOe5/JTk2jSg8MypM8ySO0JAB39Ux 0yat6rodm8UTm4jhuhxjeA2R6+/+FTHdCUnHQo6jaQC2gSR2EyKNh7vjANLBm2+zsDhmQovHYjB/ nW5Iy6tI9++PAZuXA4xVG9FrKhu5Zi4hxD5cn+syvTaPeonewH//1PwRW5ae1fbA63CPiOQPiLb2 AHr681a0i51DVLgWEgmuGSNpGTb5iqFHX2r/AExSb0R/JbinG5q38SaZBaSRSJMZV3S7hnyXDHqP TAFUQbcTfabWRZ7qAiZoMgZJ5Ax2B5os0VFJJDLWz1m6upLjUrN7ORGMsUEzg/IOdyjpjAzVO5jG q6lLZM0N3a7FMjAlvLJHIYfUY/P60jSL5XcVoLa1uRZ3NsYLVBgPEu2KRRgdv5UxrO4gvYZ9Miee 13FZscmPP3W4+hoJP//V/By60hXaK9uJsyq3nOHGCmOR+VZt39smlUwRbYFUuxY4Lgf061/pgfyr BWiRWkkOoS28MsX2aCGbzWuYVDbxx8u49un6810F9a6dHKrQz3TSXCmEMF+UY5AyPb19KtQbsZy+ JlZImEys+V2jaG9aNRjvrFxLbF43kTdBOMiNiADgH2yPpV8kSGtGV7C9nvsHWbky6lOxYyuu1X9A p74rTtLe7glaNH80uMDcvDDr/Ss5R5S6Wk4vzR//1vwd1C5QXCNIAht1xnbuBI9qqI17cyx3dqR5 aHLErw4z82e/TNf6Tw5bSv3P5QxM7120a+r+XNbJdQSeem7bvYYeJu4+vGKw5rprWzke6uEg3jEL t8rA46fU4p26EN++ieztdCv9JlbVrqKKVoFMLeQ0oklPQDHTkd/Wo7Swh00v/pKNbmNSLZImDAd8 n1rnnVUa8aXc2oTpzpyhJ2a/r8yVorVp4mGFty3yOF+ZQfb8avw2kx/dQXMKLKTtLsFJA5we1dbX uK25qpU1RUWtd7/P/I//1/wfNsljJOZHUkKVfaQ+T68VkZ3HEZMiOWOT97qa/wBMGnC90fylCcW7 x7fqzOtDNYNdRNHKUkXNu5bfuYnnrzVyO437IZoj5qnd82Bj8Kx5W5cqOb2tSFo092zbsJidgjjj ZJZxHJI4O1Bn58Y74p+rWVxNqa2Wm6fe3WJfkmhgLxuuM7sj0/pRiKcqEoqWz/pHfK3slJ/Fcilu iiR25B8yIFcH1zUAtL+bzpY1Alt0xOjja+D8owD68/lWbSauXBPRn//Q/A2RYxYra3EVwLls722b VI7Yx3+lXNLtoLS0ikS2ANquIZZxunck5LFjyeg/Kv8ASg/lrklcdcy/bEJx+96Nt+6ay1ju2ZUj LWxRipfhsjp69/eqUW1oTZlPUbueGcDcUQHGUXBcjikEEclrcTs7pcTxlQ5P+rIzg1sI19CuLua2 nd1gukt4vKJEg3scbQSvp7+orOW2v5FjEkaR+ZKSUX5yg9/rQB//0fwXn0lvsrx3Nv5sHlebIMch euT6Vzf2uYuqwySPbxDbkDcqgcAV/pfyq9z+VyvceY8hNsfLeQAPJ901LPELWONVAklkGBvPf1p2 DyLyXun29nIlwWE8eGLLHlWJ4wKgguJZikNtl2lYYXH3qxlG3oA2O6RLtrYxCQo37yBhuyc9D+IN T3g/ekW0It1YgsyKASB1X/PrS5XbYD//0vwEgXAZSgVSOGxWDqMV9EyGG5RLeCRpJo9uXlVhgAfT +lf6TKFnofys3ZXIYr2GbzEjk8wJ+7ZlGATjPfvzUc73Ms9jawOgaSYRnfJs8zPAA96px6MLrY7S Dw5qUWnz3iW7tBDJi5eFN4iPffjp9TXPRyLerKhD+WjFY5CMDPvSstkMadOZbV2SNXcHOY1yzUlr a2crmJIpIJtoKksGyw6jHv8A1pl87P/T/nzUpBGzSb4iGKDK/fI7jHamKkVxbGV48TZzG7DDL16f hX+lB/LyaexmTxMyFLebeobMwHRT6VNZg71J5EZ546U0m3ZDT7Bql+ltJCLK28+4nnjiuCCF8uPP zM30Hao9Wvbl4luEC74wsGUTapA4/wAabi0BRsGmeN2kjYh++cY96TULT9z5kcSyzKN0RJxg/WrU FbUlyS0P/9T+b6ESSRurbomUfM4HMZFbVqP9HEhQGXG3f3PvX+mFtLH8sJ2dyNpZlliSSQsJH4Ho Biq+tSvZiH7IAS0gE4K5yhyG61PJE0U0QWCRQRMjDyo3O8BeWyee9PnUzxT2bXNz5V3FsZIX8skd ucfjVWXQsx4rC4s5dL0iGaaWFYhB50wDgBcBd59TxXS6i7WE32UGNpQgQpEwdAfwquSSRam1of/V /nBghvnDmRIzGzFWXrn6VZhkFkzD5UBGPTH1r/TNQZ/MjkraE0BzNuGAOoI5BrMnkWS6ZMOXDYbI +Q1oklojNtvRg0Q/5afLtPyj1x2qulu1sTMsSoMl89jnrTBNrYrzWZupkMbwzCRN75fiI84BHrTr m2uIblYbu38ucW6ugRvMi+YA/Kfy6+tJq4cz7n//1v5uWZbOx86S1e4mUGQlPvIq5J/TtSwNDdIL kFFiMPmkMMOA2COPzr/TaUbn8xRlbRiIhnh8uPHBOGYZK1HDDesvlSNDE2/aJZSdijPVqxsa+g+b THGIJCk8hJO+3O+EY77vpVmCS4srCWzs58RmbNwrIH3sMd+o/CgmUmjNdJri8EccG1gBvdvlVgfe ppJ1QGIw7TavhXU5DcdquUbEufY//9f+aSSa31AEyhkaI5TjY4I71cgtbdljEhaUg8Fuq5r/AEwP 5gbb3LE1nBauXVwXmG1hnIGM4wPxrKuLgogjgeTdHMC7gDpnkD2qlBtXMG3t0E+zxSs0x4P3iQNt SWkksd2I49ptsbmYvyT6Vm4K4k2thXvbCS7kYI/mW7bW3RkDI9DjB/D1pVjuLosyqsYmbdEyjB2j jp+Bo5EI/9D+bwacJy7s+zylAz/G59qcunQxgyviVt37xWGwkCv9LuWJ/LF2lYrfZYbq/wDMhBt7 e2zJFsG7aSMEUttd3Mk8sC3DQmceQuSAMZzk9vzpOHYuEujL0twI4xZXEUYncFGaI8SY4zVJ7dbT yFixDtwiRjgEY6YqOSRoXkPko4UHczjKp97JOM/41rZtvLMUqYmGGSfdyP8AZ21NtQP/0f5xrm1l ULPGEf5sYbqfwqa3hVoN12cYJO0HBr/SdJLY/l8zICIle6tWV7feVfncVOen4YrWtkcZj34MqCTC 8+XuGQT/ADpik7IorafYR84je5ldmJj/AIwOhP8A9enzxRz2oZ+fm2kY+7UctrW6EOfQowW4tpI4 4iJ3Y52sMKR6cVp3bahBA3mQwR2hOxJ87wxxypXHHH1qKy9xvyHSlyySP//S/lB8V6PaXM17d2ka SMrETJvAhjcdvY57V5vZTTW0mDxHjGDnapr6Tjh/8ZRjX/08n/6Uzyslf/CZh0/5I/kX7y6aNQA+ ZW5GemM0f2k/lSvttGiMYRMygO5P90dePxr5M9UZYyJDGGjRTPy0rls4z2xWyr+arysNrFQfXdXP USd0gM+aVly4BEYHzACs+5vEEUQeU5nOxEjUsMe5/Oue1tDSn1P/0/5FbOASRLGUIRR8pIxWnBcn SrmOV0WaCUhfKlI2ZFeHNdUbyfKjSuJreUiRFQbz5j7OiD0qgb5k3okS4AyrN1x61mZQdmOtJliO VPzyEs+5cKhNb9vZxywtHPLuZzubacLgdqxkrM2G3ZsFJj/e2/2hfLZoIy0Y2jOWPb8a6l9TjvtC TToYoZYn2yx3DRgScAYOfcVJlKV9D//U/lbtbZRHiRRhOpXq1WY4XHmSwzSRB0KMFA/OvlwIZZtp RZSzov3n/jJ96049Xkt4xF5oWKUbBHySQMc0nomJuyuVA20S3GSwkcHa3BwOKvRTyTMJih8sR7UG MEdayh8SIUveKzzNHJmIkZ4bu3uKtzTNe2qRJjYknzEAbgRzjH1xRK19DQ//1f5iYmle3VJiSiAK W/iwOOPwq1arb6gs0ttEzWkURKSSKTPHIhwQR0wfWvk4WAoxYmu/tLyNuMXkgHhVCnsP89K0rWe3 jnaJpfn272XnbjPr/Srsr3Aq6hGWlmlErTRyuPLUqEATAGMD1x6nrV+wmjijWNIo0Cps2rwD70wG vqAt5zDklCdnl8bMH7xz7frRKzhf9dD5c7FbdmI3dOhHbpQbx2R//9b+YSSCaCPe4jLrMH80EjI7 gjpW2tvBLEJxI2+RMLxhQfavlm7HQWYpGgXAXLYwV7moJ1aGdEkXYJCPmxjOemKYEVzaxQKVnkkb Fx5qunOc8Bfp9K3LC2s7a3a5T/XTnc8ci47cEf1rnAsSIl9ZrI26O4SUDysgrhegyOe35VC9vvjR SxicNuKxHaJP979KpRfKB//X/mwEE28hmYR56evatW2s0gaS4mDzq8O1IXYiND/eA9a+R5ZdjoKT M8e/AKRgZUEdahsiTc4LhgPnIPIX2qQJbyyK3SXcEjKrNmRMZixnkCpTqkPnmLJ8yKINEix4Q84y zVlKOrYA122957go7NyI0X5Rx6VoQyrdW8UsUUtpFI5DxyJtLYOM/jis2rqwm7K5/9D+caZUZzao pZuNuB9/PQAVVs1mBljeEL5UmOR85A4+v4V8DJWdjWMr7my+MIzZzswF7LWeJLeaOYBDuBKuMbSS OOKcNyzrrHVo5vDssM8SCWyBwzkNPsOQMHrjv+NcfHcwkzvIJZHc4RSMKMdhWoE8l1E1uRGWt5YS PlJ27SO571rkE7Jhks8Yc++Rnn60FRjzH//R/nZn81djoh3hty7Typ9a2p9VuLvSXSK1Q6lbtj7R PMVW5TA4I7Hr+lfDnoJWVjJa2AjVzGrhlBYA7lU+1VpInkX5MKFGPTArGXxARWb3ZkWSCSNoFyuX ODlTjv8AT9KvrbG6WW8nETM0nllVGCDj0/CsJ7gBmnSXy1QIsabgegOAeP0p9tLNdMXUblT72D/n 0qAP/9L+dproeVcb7WNzHId0hP7zbnHAzUaPHbqsOniZrW4n8+RZX+WEkfMev1x9a/Nz0YuzuPMB a8wjCSFjww4WrFzNJDmKMsC3AGcbe2RQ0D1jJkltOlrFGtrAGZB98ucluTuP50yPc05lIVW6sB94 10Qj7rOW9lcrxMbya6D71X7se8bGXscVftLK6sbmIs0Ytdg/eM+4kVXLIcZW1R//0/5/NU0i3uDF JFATGuHLgkBj747VnTQMxS2ZdqNwAoxn2r8/tbQ7Izu7MEhjsg9oeIyd2zPGe9Ne9FpEUiYbjygf lU9qma9xmhZiuJpUVmCglecdKbdQqyJgg/xSgj9B+lcilokbWtRMNk8q9jcLIkbIWjOcjjAIrUjv raJJGmbZEgyT2NdS+A5Fuz//1P5640S7WJ4HIg3hmK8Hb14/StP7ZaQiS1EEt7cXDAG4Ub/LAzwe 3NfnMPiR0GUl1tLRQKsbMduDgcd/5VFcW1xcSRXJBf7MflG8qB26d62Ar6jFLMuWMrbl25QkEDpg GtjSbKe2tEWRjc2xO4xzkpIhI6gfgPyqJ7AU52W3LqFDiVvvA8x1cs7fdEGyzYfdjPP0rID/1fwF JiceVJmJVbLNjLAVhGaBI2jDFnMhEbBcZwe9fm53Q+FE66fcy24vJoWWKGQKjh8ckHHf61d0yeHy 5YY5pBlyJI3YlCe/X+lTJNrQtWRpzraR2MvmGOTjPlrhmP8AnFc017PC7PDCzA4ISMenrSgmtxGg 9/dyzJGvln5QZUPJT6flUjbJQwmQI7fJk+ueP8+9Waqae5//1v5+PIkyDPCMRrsR8fMBU9rFHFM9 yY98gTZvHzMwznAFfm5614tmrqdnJctp1zZXaxwNAxuIZCEljkHG0+3Uj61g2ltaz6nHc3FqGuLV DicDGeoxu/zxQZytfQnjiRpXZmVQG44pbmB0w8Y2wS5HT5XIx/iKmekRWdrlW03WcxkZfNjZdoQr lI+vNdHm3kiJC5dlyuP4TmsQsz//1/wLhuIUM0lyWk2rtVRyc/5/lUM6LJbSz2oRZ0XcisCAcduK /Lz0CG01K0W1b7QRLICV2L8zK47H0qNtUjk3NKRGFH7v2oWhVrQuVJJZIsT2/lziRecNyCOxHar1 tdypHJdwobd2iKSGJjk8YIz3rSavKxnFdEZ0c81zaEwkpMkxZlcZA7ZFaNx4gluFsrTYqmNPLllH DPg8Z/lScbNJGko8p//Q/nytJZVv5VuJHSFk/deWu7JAPX0ofzLgllkd0zt2lcZA9q/Lqt4R5kru 9j1qFONSE3N2tsL5yRRSrbsIpYoy5DggMabZwRyyrcyQW8LGPMkkJYmU++f6flRO7jGy0V7lUZXk qfT/AIJYvIbcrviO84wFWqkMtvC6BxKzDgLtworqaUq6lHt/wCanLCu/UluLrLKJI1UocxEjpmpk JaMpPlHY9F44rmnBuVoaWYSkt1sf/9H+fi7kup3ZLcRmHy1jjRRsLYXHOP8APWs02KzROw8q1EK4 lQN87tnqP1Jr80oUpuXKzvqS968djX0qLULy9+wyGCOw+yZju5iQxl5wCR7VpQ+HdYuLiCwgMV3I 7bdq/KrD+I9+mDWrjYhyTVmZuqaDq2gTtaaosH2aYl7R7dt4ZMkfMezDHSskaUTbhLaKCMLubc0w jZs85Of6VLWlwg+hXtUmeMRqxWQE7ZE5UYqQzW8TziS58x0UDySBlSOoH+e1SlFqyNV2P//S/n20 qWwSzIuYIS7MWUhT+93cYJ74qmbO5RWewtpbj97hEQZYDP8AQfyr8uqJxs47Hu0YKdPfX/hzdfX0 ntRp81sFRf3gcR4kLYCn5/y47VRtrsIPJ2h0kO3IG0qM+lRUltJdGl97SKfJF8q3J573THhngj81 7mEDKeWSgz71gSvOsRaMF03ASf7IyB/Wt6a3v0bIqu3KWZNRa8uljS0jggS3XMgkG1mUc4B5zxn6 mnTTNKpti5UTKVRoxiRTg9KuyTMk77H/0/55NOtXWTdMrywwxkDPV2/yP1q4Xe4leSXyoN2VSIff HPWvzhppXPTk3cmsLNUEuzEssv3dxx07Cs2TSp5ptqQsLl33Iigk89K5a2IhRrU4y6v8rGNeEqlN Qi9dRUtJoLVkvDPFHGxN05U4POflq7Bp9krjULNNvmRBCjPuc7e5HbOTVydzWn8TM25uRLceVGrN IgGSikjPpUQ1BrWdRdLOkcUoWb92WYc8jb1z7VcV7tiKjcdj/9T+ei9nt3eeS0d41mxgbNjR49qh jnttSK/vvOWNdg4z8w4OfpzX5etJanpqL5XbqbCws3lwj5R6McIfSqIP2WeR0VVAIAkQZcnp2rap FKMWt9fwOhYdUZ8q2LojjtYt0bEPKxaQfdAz6VSlZlZAkX7knMkqjlBxzipje3zNo6yUQjmSWRjb yK8UHDNINjeg4qC6vI5m+zyBWUAARlch+etbTS5vd2BRkleR/9X+d+9juQn2qKUBQgQRsOM8nk/l xWZptw1lf3U8d1IpvrcQXQUeZgDIIUduvavztJct2e+3Z2N8Sy6VHayJMmbtyV3/ADFgMnp+fX3r Kl1nVbm+t7dZ2+xWk7TPEqDE+Rggn9fwrOXcU5csXJGvd3gn2KmMsMiPo3pzVOa5vtMjWWzLxFRv lmA5hAx0+vSuaK9x36s25nOrr5fkSzanPqHlm9O5mxsZuN+BxUWZLZ0ljR3ZZQ0gCbvlyM4HX1qm /dNVe5//1v5/r67sFuZEie4kTCOY5I/LYZHIxnrnPrTbpo54nig3xJt+TPBI9K/HsHCUa9SMdV/l /TPs66dWTqoxI9Fs7O0TYJrq4eMq4lUuqY75pNI0G6mnuVh09FURCUscLvXHJOen6160b2TZlCk5 SSWoy/sbmPZENpy+Vw4PkhScjjoKZMIXg8h3AC9JFXLoaqF3G/RFzp2lZkMdnBHFb5kfdLKVRhJt 85l7YB5+lSRi2jumWNWkuo137ByUx1Y1q5WMnFKzXc//1/5zb1Irm3uEUjzJpPNkZT+9DDgY/T8h SW15J/ottczNKqr5a7k+ckfT/PNfn0k2rI+tatM1ZpL9TCukafJeEc3UwAY2o/vbT2rDt7qO1n23 Nu6COdnuQ3BPPP06GuacGlzMJyS06mpqd6Lt4bbT4dr7DNFfmMtEvoGGevt7msj7LPbFfMn80Pk7 1bDA59Kl05WutjKc1B2m7epJfzSxx2095K7+RGEjf0UcDgVDaxtJKZpZGUAh0cnB/wA8VSghpH// 0P50J/sxnXzWMvm8cfNimW8Vv9puG0ySBJY1/eK+1nVsYOQf5V+ZuKvyrc+hv7ziiQPNHE7SW0Mp b5H+XDqfWrkfnz2pWeSRrNGLRxRtwHxjkdB2/Wtlo7GlGfs539TkZ50bTrWWQSgTXjRCO3c+a204 wcc+ufpXXNYCzjs5t0aRkBxGzYEg649e1efSqOpFuG/9I3ik6luhhNDBcavNckSbZpMJGWMiRAcD HsBWitzbQ301hbhiw/1VxtxFIRngV6FBqM1DqiHeScrdT//R/nsnhlumglikMVyiKscZIK5HU/Sq VzG9xIs4ZZHY+Wzjpkdia+D505tI+va0fke8fDy1SCOJZGhWa9jFvNNGQXgQEHcG6j19a/Qb9mq9 +1/EnwjaiBJs65Bp8EipsuJA6uWY+qgR4z6sK/o/IIuHhrWk/P8Ay/M/NXKNXjGjGL1Vk/vuf2u/ DSzOm/D+0095XPlWO1plfe+zyEOD7g5r+Rf/AIKVXtyf2hBFMlw1lHbXemQpCTKiXETp87/7yqTn 3rx/Aminntd21V/Xqer4w1JrLqTi9/u6f0j8gfitrdl/Y97YzWl1LeQrvhvFfbAqOrho9vqCqMa/ HvxnrJs7i+02ayaKa6HmajcGAATM21/vdwcqQfcfSvvPGayw+Hp3967duu58TwG3y1Kr+Huf/9L+ HiKwgeZ5I5gqA5C9NtXLCRba5/eSKdp3FgOX7AZrNRm4czXQms25t9L/AOR21vDbaobK4u9Kt/Kj u/mdGxLKuQc89CMcHHGK7i7shaG3MSjbIvmxoGEjBD0BI7/X0rwMTGbk1bW50U5xc2y0sFoJLZrl ZSZCY4whIVSRnJHsAa7v4XrNpXimyUx6pdQ3188dvc20AnWxfGQXB/hJCjvjNeLjFOFJ8250KPLZ S3PsOPQ4Ev4r5xAJZI92FxlyexHbp0ratrOKa5VJltoYxJudT+7VxnpnjGfavA53zI7uW1RM/9P+ PLV9V0/TdFms7G1srVJ12koSzxknllXJIOf51T8M62s1xYaRBfytApVLxZ13O2QSAwHbIzwODXzV RJamMPdase8TW2n6JLp+oRzQX0txE0NvFbjm3cD78iEAjtg964Z7W+1K31GS80q7SC8uGsZLsR/6 hAwy4Y8AHPH14zTpSvE65SstDt59C8Nr4Wi0mBLmS/hDG0a1w8qNgEKyE8q2MdeM15RZLCUng8to BbuZJEuFKSMT2x7f57V0QdlYIf1+Bw3ia2l+2TJaR2aSXlqpmniwZZYkwx3n1G3H4VwlsmptcPDZ SOoYfvEPypKo5wfy/OvSjrFGUutj/9T+R74DLqEWr6a880umpFqTy3Min7VIwZhgEdNnqOwGOlff 9kqrqUWsSl5jp4e4nKy7fNCo2VLe9f1J4HyUskxFPs//AG1H4/x3JxzPDyfl+Z/bt/wSBvI9R/Zz 8N3c/mLca1bSS6czuJWgiARWQ46EmM/gRT/+CpGgwXXwyvby/aV1jSeCSZEDeUrQ5VVGeSxjT8zX 4pX93xQf/X39T9W8Qv3nANN/3Iv8Ln8QWu3Fssf9m2dtcRWFrcmWC8vJA8t2srB422D7pG4n/gQr HewiupLIOqsbeYPP8xC3arnKke+K/u2jFumrdkfyPUm+a5BqH9qRy/8AEqWLTLUOwjtlj8yNY2xl Bn/dHNRWUsV3qE0JKtfxQ+Zsx5MchIxtUgY9OB610KCic0nax//V/nwLW0twLGfbZwW6NNOYFImm BzlGfHHPAPpUVjYi3u3n0yze7jdC1w0swc7FOcKMenX8a/0wP4x0ctQtItOuHu9MvYoGjvQGkieJ ZCu05GCeRzjkelGtW0N5aWtnZaNa3EVgf385AyIwVCnGMZU559wKNja3QS+1X+1Gs9PvY9tvPFHY XbWkASSSOPHUjoxwBmul0630mwXyP3trC78FyHWGPoOP61utI3LXLazNAaBp2p6fGZGhnNtcNNE0 I2KQRhcnPI9unJrIuLS/trm3eW/lNvCClvaoA0Y7YJ6j1wKnmbg7mitbQ//W/n/1DTbSygW4iMIu biTzWSNgzA+rDPB6VlDUpdshNlKGtz5Qvp4ysCsRuwPXgH8jX+m0H7p/H5qXVxBceRLdpGhNuEjk jAUsQOGP14qva6taJJHA0dwZXnEETCEtHkjufy56dataMie1jcs/NF+dMsbK5vGvmNxcCGPzPI/2 z6KP61oefZaXerbMIbm5SIrMhPypnOCcH15/CkZFBreSUNZJ9onTJkRIAS4zgkZHOD6UQ2tsLizj uykJlYCRFbEkS/7Xoacd0B//1/wTtxBb3UsF1dSNADhIoyFJUcDjtWXeny7d7aCXdH5zTRQY27d2 M5OPb9K/0/aurH8dQ3NXRxPb2jC4hUtON9vIJQojAJBDDPf+lTPpY+0wzyyIZHxMIlYOxUcYx2rC 1tDUo67fQwSx2tpaahObkBInSIbFYdmOe1R6fq2oPvggCyyIvlsY1wy4HQ4q4wvqJrRjrWe9t83L fJl/LuZFbAJIJwM/QmsCaKWW+WZ7f7Qgk3xuRuyR6Cn7MUpWdj//0Pw00K9tFgma/wDKe2RCskSt yvGOf8K41tP019YuJrP9/fRn9zIrFT5ZyQpXPvjn0r/TlxaP45k7vQtT2qD7LutXhnupSkoAyqAH G7A7defpRODY3FrHDKsQUHeUjA+0Hrzn0/pVKDJNxJba7IN7NNJEFysY6jj+Ed+f51ymjXs7TXcF yrCOO7ZEgeMxkBTxn1B4/Opaa3NINfCdDqE7TPA11aywSTXQXybFSY4F/hZiMYGOvpWPrU15ptqL mzikla5lW3EzKWQ7iByaLO9guuY//9H8FdLXVyoMtn59qoAuHXGyEH37/St2O1hmilKRlLdGwkYO fLx0x9P6V/p+lY/kBb6nKyW2n29zNJes7QAFyA3cev5dq66zt7cgyWNvGiW6JKwlQozgjoO5ofkb XXQpy2L69Pdm6ddMhSPbtViu/HQKfU1mXugyW8KQRSSTpcZga4EmJI8jA5HP41i9wbsi94e0iTRw 9tfyx3RCCOEbjIg29Gye4q/qWrvBbPaGB2RQSCvysSDkY9RSIU0lZn//0vwVjtUe50/UpZrqMuRH JYTF/IlVuRuQevqKJraQarfzxvFaxebvtLLzTJuUemeQK/04P5Bcm9CewF5fkebGluY1Zpf3ucgd s96j+zywpLaLcO9vPN53msclfbPpzQJtsz73+zbeSBxIXuijPEygs7hMbgMfUfnWzpNqmpWAure3 v7mG9UJOsds+IDkjDHt/9egEm9jd+xafqNndfao1to7MpiVWaO4mZSANuB1HU54rEv8AQ7Czs2WF JJre7mxIZLnddx9CSp44/Dii66FKDvqf/9P8I3065jgM9sAzRgFZmYrPIvTjHf1qGHTpLzdLII1n 8vGXGWYjoM1/pq5pOx/I6XRFiOJ47yS0kgjWWzRSVkPzEnGOPxBqhqN3cpLJbNIsYC7g65XaCOgN TKV9iJxdzesrW7tdOt7vzJdkilTlyZCOmT9az4Xml1C58yREtE2pauflebg7iw7dsU4NJWM+V9i2 Hhe9VAiSxRrtkfoyHHasmS6gg1T96HkhVvLVwGTaD3K98ZpSa5kieW7R/9T8Nde1qy0y2gt7f/Sz IqhUt42ZxuI46ZGCefTFXf7YimsgskSxHywoQDD5GOfrX+n00tWj+RNVJmQ6pHLI80c3mjaUVl/d MuM5z+X60iSSFJRtWDepMR2/uvQg1nK2liou61Oeg/tqIxj7VvLybY3i/dZJ47fgK19W0WK6u9Nm iWS2mtyHmKOdkjDuR61Iy7PbOJBNBtadvlkcnBUc5wPrT7eJliuLp8LJFPHCkGNzXAZW3SD2Uqv/ AH1TsnoVFXkf/9X8Lby2uXsJXlALsGKR5yOM1zmk6fetp6tc29kyyTtEsYIaYquPy6j8c1/py9KV j+R67ammb1tbSJqDh7lINJEADEpvkRh7dxUlvPbXF5tMQntYmwlyV/dNgjj8ayilZA5bG3qWoNey C2MVvClugSCaIfMFPUE/lXParYJLBbxpAXjd8TTxnD+uT+XWiS97YrmkTLCtjYNbF/NSVPlRmDYH Iwfyo0e71C82xaUltbRxRubhr0+VJtHG1Af4uuK0Kabnqf/W/C+Cewt5ZGu0LGNvljKbkJzzn0q6 L4Tae8ttMthdPM6xGM7TEq/dYkjHPoPSv9M5/EfydZWsUX1bVk0VLJLtLy98wTylVEaTtnAJI9j+ dU5rea4s0F/OqO0mdiOSwPJyG/l9KlaMOVIpjy2kFsZpZLi3G1Gc7sjr16e/FWryadbeMOR5yMNp U42gev5VuS4a6D1SX9zI6sxYfMoPNRxQyMP9KssIZTsLKQT75qJ7WCSSjY//1/wqaztrp0hjlEfl BsrE4VWJ6E+vT9abJZvbxooiaMzKY5ZomMcky9+R069q/wBNILqfyZG3LqRXFvcSWkMQR0iJwGkJ kcqMjOT3471p6LoltDBdai0uLhICeEDbthwFb0Pv71TjdNFLYS71NZbBBfCWK+80LbPCS0axkNvV m6/3fbrVazOnWy7bWRgyr585aPDcnJX36dayas7FJFv/AEPVERJUOQ3moq/u3YehPXFUIpHtLhlt 5fKhAIaIcg/WhK7sKx//0PwyuZbhrWaNbMTPcMoLt/yzXOTg+460+eeG6G4WkVu8dv8AZ2hjJ8sj YEJ/HGa/0ylGzP5WirKxzVpp9umy0gDgrukmiQHaozn8K6KSSCIRRfZynlx5RlGI35/nWkdkZS+J lZXnu7vy3iWNBHvD/dXisvXlukW3jgkEkGTFN+9w9ux5BVfQ4OTx0FUZy0iyrYwNqCxXEwEVrpMh 2yu+XdvTHf8ApXWW1wuHnLFvl/dqe9YTWrQUX76TP//R/CGOOK7LLtiVmYkI3yL3qC307VdNuHBv o/7PkG4W4THlkDn5s85r/SiEGon8lV5Wqsk1C/s4rEW7qyySSjYsQ5Xrlz+f61Us7OHWwbdl8wQD cu5Qd2O/tj+tUo3TZDepPYxWWmNNBcqZVC4jZgCiEkc/pUE88hvsM8SwzL5aEHmRcCuGnFzxjcvs nN7kayXVv/hvyJHs0hkQswcA5Qf88/c/nSXsUbCBw6h4W3KByCccV6Dg3NSWyPQ9pH2c6T3drM// 0v5/0sJl1NbhpZCLhAJ0dtsJUdwOgregFiiXEnlrCIQQHcgIB3P04r/TOUnKMk+p/IuEvSXvu+/9 f19xlxQyG2+12kyzTM52SOMqAc4IFKlg0zEPI32splnxtRjXO01OKibYaKlOz6M1dOji0sLBcXOw ynAU/Mjsf6/410Wn+Ir7w40+JIru1l3G3W4kwI3YYIGOfwzSxHPWgk9z1ZRp+3jHorHH306MIJ4Q kU1xOTGB83zZycDr3P5VpnUboxTymDbKDmR3+TPsM9etZKnJxcUzaXLBOSif/9P8Dra7u7l3ec+Z Mi52gYC+gFKNRZ2l82Nyc7GBXaqnpX+l8IRduZH8u0Ze0pKf9f10H2W9ZHV1VVzw7dxTBdLDc7Rl o2POK0io7WJqRdOPNLqVL1YUIeaUNufMY6lM9KimtGbyY13m3nTfNL91cZxt/wA+lLl925kk7mmu mW2m+VNZAFXj2oBLkYPr+VXLaaQwTRtDsdE3JK3KrQotjP/U/ABb2T9+txJK4m/dSYY7ZB0wRT4I oIT9mt4fs1qkYwW4DE5zg1/plyu9j+Vw1GCCwjiuAUdnHyqDl5BzzioGt1uhFM4QlSJIo3XO0jBy a05IgWLiGzd0ufISFVJLxwA7CT6Zz3rKm2XMiRpti2tyc4LVm4NAPht54b2OOHyiX6zScFPc/lUd zeXG+T7zhOFMa4BIqvZuwH//1f597Z9QvIEYRhAOqfx4+nrVS5uLC1bbNLJJMfleNkICH61/pglr ofys1pYhi1KxS2lMul+VMxIWToJT2Y/hj8qz7bSxrtzAwljja3JkRQ2Jd/QBPehrowdlqzq7ex16 KC9sbbxHdaTDPCVvLdpWiW42gjBx944PAPelsIIbOORGxJbKgWTzW3yu2MZPucZpWRjLcUzskaSK u2KTonR19MisG7EKzxlHKyE7kIOAfUVLgraFKb6n/9b+fG4ljuIJAhHnRRbtjHCA+/5VTe5k+zKh UIQvGDwa/wBLFDufytzR7lG3jFu73E5CwMpkLDlcjoCKt2k3nSsy/wCrdc8Lgev+RVqKWxSk1sUH JjuWkEIljkJjZmOCv0qxqVxYpa21hbm5U4824LHOWySAM59/zp2G5NiW/wBphh82K1d4NvMrD92O 3eo4l1GaNI7YRyFZN7CVtvHcE/0q4wvuJu+5/9f+eK9tZ4YoVkhWAyrvlP8Ayzk+hqFrW7aFmiQe Qke8lW544OBX+m9lax/K5jm5kklht0hxKzBRvG3b2/Cm3vmxzNDcMrFRj5SGUH61PIgIrm5js7ZZ 3RpEAxgDGa1YrmJooJY4WRZE3EuwOzI9ev8A+qqSS2Oghk+ymNEjkkkk83dKzH5mHopqL7GqTfaI YiWz91zubHrmqs9gP//Q/nRgaSAvLyYo281lxlsdW4qs8dre+Y6SDMmWVT/APpX+nSgz+XzMshI9 wYd7xzx5SON32xk8de3arGJYpfKkkiNwTghWyPwNUoW3FdIWUbY1MwD7ZAJFJ4I+ta3l2t3DIkbZ Ii2CHqB7n8KHDXQz53cyo7SG32p5Tp5fDAHhwOmKsTzNcSIy91C4YcgAAD+VS4NFKfc//9H+dIbP LaHK7yvRuhPSqNhocUYvbyeJpMKXChjiPHOQB9Olf6cWP5eTT2I7ee3GRvCozEgHjOO1SuyXgeFC qx84c9WFLlRcZWepChe3Tyo5MQqMNjn9arLDHEfPiPlQTESE8gOcAZqeRBKVyxLf2rKsEjNHIz7I 3jjLlj6HHQe/apre0Ak2fK7N82Sapq6sSf/S/mkvTK12PLjjGHKsV9uxqtJdXMhlRYjbBJBGrs20 ykdcAf54r/TZRS0P5dckiC++1RtGysdgAMpOSce1WLKRLhXh2sN68OVIb8O/YVVraGTZpD90uxoy QF2HIxntms2SPyCZcNHETlWZiefQVLgm7iJdOjMwvGYxTs7BZQWzLH3Bx+dRadbXMF/L9lkuJnhX zAJFxEoJ+6DjH4cninyq9zNzadkf/9P+b28kvEhjFtC0sp+ebaDiMKMkn2FV21JL5YyHGAmHlQ/I ccde/T3r/TdpPc/lPn0J7ctbQfKpcS5w/Y1Vtra0Z0ja7KXk+SrTLhOPfp36VLguhad9UXNbOnRN Z3NpZ3Larb25gSaJWdJTnOfQduD6Vzyz3d3Mt1dMHkRw2cABW9RWai2dJ1TXLI1vmNZZJjhmU8r6 E043ttLcuqbZpIhtdQcBTUuKe4H/1P5zvOiYQSSB4yhI2j7j/hUc85ut3kiNFX5UTPzMR1zX+lrg uh/L5m2dl5P2pCMfai0rKh25kYYz+lQ6fb3WmXzB/PktfK3tI8u585+6c8n1qOSQmrqxvMYGZrhW BZ16E8gVnmZmQxxhZFYkEngVImkkytDbSNKoVyZIzn5ecYqTUL/zFtolVgIpSLhpuUOOny4/nmoq K9NoimvfR//V/lX8RW9leaxO28jM0h/0GPFvI+0AeYBx0A681xU2jzqty7xQpHAwV8yAMxbptU8n pzivoOOdeJsbb/n5P/0pnnZTG2W4f/BH8kYf2YOczHacbUA6YrPl021gCPIm9oZC0O4btue1fJ39 w9JqzsTxshkLJEIlPRVO7itu22sMFsqOAM9OKyYiK4WOIZYghm2hV5A+tVrXSZpZfOiYKYlyEchU f6Z9qzlGzuaU+p//1v5LmcDYIogCvDc4AqOaH7YQFRZFUdBhsGvHLnvYx7eTyxcRKpADENvGHODj OPoKvwWlxPNGGX92yhoiHADgDPP+FZTSWxK0ZdeHdIViO7HDRgAKnrVmHzonaG3kVjbqJZVkbYoB 4P8AXpWUldG70Vy150IlMTTtmePOGGFHqKt6b5qK6Kf3R6KeAPesTnP/1/5VxcsNxZQoXhj0FQXV 9MyFbWVhsXdIq8BxXy4kRRz/AGmEb0IJG1iOOlXfvwqPk3xcqW7DpUyXusbV1YuxOJY23KAY1zjH FWLFjMG8wyRNuKJGRgMPWsTNQs9SR7PyCZd37zPRug9as2LW6CYmJUkfkNnAfAIoND//0P5iftEZ jYKxLIvKgfKah0y6xNJbQhlyDIWjOE56gj86+VglYDYt57V5CLmKNvLH7vIwSajMCR/6RJtjXeQF BySM8c+9UBnvOZHYMAqp0zwKcreTiViCG+6O9ADY7yCCfN3YfbpZMJBaMWTzSxAB4weM5rTGmxGW C3aFmNuTcqiofLXnoTjA69DzQaJ8sD//0f5pdU8iS1M81otuV2xiFELRk5Cg4561mi5d2tiUDJa2 rQQxg7MFjkHj0NfJz3sbcySuXF+03XQxqyx5JL7WB7ADvSxW9w06rMTPL5XyO7FoIAOgz68/pVcy sNO6uDpc2cE0lwz3I3bwioCIzwML3x16561A17cfunKEI3yqGGKzTSeoy/aT3AEhkHyMcJtzgdOt XoVmkVmTJKN17mtl5Af/0v5y4CrkCUAlRk8Yp5Nw0hEalkYbY1VcnPavlzpbVyI2N/cv5JSMSCIu iMdm/HUA+vWs+OznibPllOTuOMNke3+elc4ixK92kBZ0d4IzgoBjyy3GcenFVpBJNHlxAgVdsISM Ix92IHJ9zUtaMTdlcigtCx2AqCPmyTnv0FblxdXht7a1bLJEdqMFAwCRkViZOTZ//9P+b/U/3Frv WIrOpDpKHKvnsPTrVaG7kgiS4m+aVhukRG3Anvya+Dmnca0J55Lh2SeCTfbXA2beN0bd6lewWwRJ DJJI0nAQDIJPNVGPKjaLurix3IKZMWwt+7Ixg4Hb6UrO0LBlRScjC44HSqGvMkuGhuWnllgCtKdz gDAJxgU63v7mxhWS22XJV9vku2Mgnp+H9KDaLWqR/9T+dZpQsbXEr4uZRgQhsqn/ANbmp7dmELRy lSrDcxB45r4c9FK7saCqY4tny+U6/Kc1lXDxwMFDjdjDc4UVnPexThYmspYlYxXUceHb9zg8n3+t WL11jSPytoTzPmSMj8zXPPoQNa0urt900ZeMqFjEa8EDjk1Vt5YtKeSONFEQB+VTtIPNZhY//9X+ c6JpLh3k2CPzG4QnORWjHHJChQhdknByOfwr82eiPQJt8EEoiQKp2g7GPJ96pSqbyV4lkAcLuYA4 2jGaZS+Fpk9vParD5KRSbzJtMwycYyDxSvEt4wS2gYTRMQkrNsLY7kdvwrsj8LOV7XMqX7S0V3dX VzlYPllIk2zEc/dHXjHXtWhp8Nzd2Tw2rm4kELOvnvu3ADue/WrWxENj/9b8DLLXg+h2dvPbQ2cs WbeQbw8spQ4yeenSqV6fngkT7vXcvO6vgZb6HStGZ6wwyzO8ryMWT5Ux0P8An61T1GxhhS3DYZSS ZC2SSDjj0xWU17jNy4kU3kRG3jDg4SNUIUAdPwx/SrFzZ3Fs6wzFSzIJMIwduemcdPpXHayuazla mZ6wZu8zblVEKonG1s4wT34x29aq3Vm8fBjWaE/NgjcCRk811Q6o4j//1/554ryBbApHBL5x+XEA 3Be3Ttisq3uHjZ4oBKuyTJxlW3Hk/wA6/POW0lY6Cd5Nl0FMXG0O0ituJz2xUN7dTXDPHbzSwW+9 UJCjdgHOfrVhY1p2DwJEkjIkeJBORguRzg+1XEmunRxK6xqYwkAUfNwMZP6flSaT0YEUtuEMRljc K54f+Enn/CnQ3qeXNHBztYp5hHHHHFJxW7A//9D+epr15A8BhLFgQkg4DH0NU0tJTaAyRyBmYqHj GSh5wfp71+eWhex3Q+E1rieO9sIkkJiubdBFsVTGjbBgNx61PYtBNpqX80S26Rv5DtHIJXZx0LL1 Gc+mMVkUPmkEsflwqHJ746VRRpNPuw8luZIWXEgVxhhjH4f/AFqqK11C6L9nHFLYtfKCoeUoEkYC VCvquc9+KkiMMuAQQ6HLHOQf881crJAf/9H8DY2lleZiQ0UUXGFx14rPF1GkiW24K5OcdAB0/qK/ Nz0CS4tVS480SMZGXbtRjs2/T1qZXWIxCOJjk4kY8bevNA9WyOe1Xc06z8Opbyz9xCP8apJJO0IS V1Zgx+7naPp+n5VE9jaytY2LG1mkUcCTdx5a/MT/AJ5qSfbaNsWAItuSJAG3ZOfXpWQJJKx//9L+ foToXaYRFhuJYJmrFjdhGkjkiBjlX5WIwYuck/0xX5eenNJbEI8t57pPKgUBtySRsGZwR39/zrn9 RjWLcygyADewHLgZHQd+1D0QS0pMR4mtvLVfMVpUEiGNd+8Y/i9OPWtWxunKbNqpBnAyeW65raWk 0YUHeKZaiNtE7wncpKl1cjauOeh9aq/2bYbvP+2zqSu5YmAyx9eRkfSk37yOip0P/9P+fyHbK/lK oZcfLKfvL9aSK3vlkkihSKTCnyFQ4Z27A/pX55UpxdJPsr/PY9RXsrdyOIXenuyXlpbzSXKmOZJH 3mAZ/hI78VVcMbhArLGg42D5VxWHL7nL5hCNrSW5Y8k2ryyRIrEtujjMmQxOP8f0rSaFTbq726ec o3kJyWPoDUrni2xShzTu35mTFsvoY3lTZIHJ8o4ZkwTjNPREmjWO7uWufsc5eO3J8vAfruI64AHH /wCurVlG7NOVONj/1P58JryBY2Nm5S4jlEaps+VQBngn04/OqNk09w0yNAyEcmQ9JPWvzalVtVlP p/wD2KlK8lFdUa8M8hjlhDNHs7H5c1LFqJ0+MzveXdtdJKpsXtz3/iVsc4Pr2zU1qttbbnPLDuUr Re39alaS7n1Oeee8u5ZXmbf5bEeUhxj5R/U+tS2cYDkXBDwtlSpJGPeso1W6WpssPaaS6/1p5hqM UEOVtJkWFYx935StRQaJpl9tvXeSFoRyYxzcnphvasakmleJ1xw0IVLbn//V/ABBFYk/6LHdIRtT Jx5fP3sfn+dJBfX9vMZLO5lgjY5lihGMjnjPUV+ZxalQu+h79OHs66gZ/wDaiJLOWtsRSgxSJJHt c4IJKHt06j1qC3WO4uXlMrsuwbYC+BGvbj1/wrzpz5ZHPVTliVE2rBRFau8VrHOIpSZZGbbgNnHP XtVLykuxNFFIEWQb2RX+8Pb16100ar53F7aP77nVWpaRXYzClvbKsQlMm35Sw5cHP9K0LKJba2lN 4yysD5kE4cb4hycY7df0Fd1KVN1OSSMFSa3P/9b+fK3vGkilitjjymLHemA2cd6oXeLmSP7PIFuI Tudc4Rh0INfn8kuVM92UKfI0bNxbXC2MO5PIhIyLhlKbjwMA/WqVjJdaVPFK92SokJiLEBkPUVw4 jDwlOM5LWO3zOSMW4Rl1Qup6pql5ayWkt8JWmZjCrDauCc8genFUdPtbnTbItI2+8kf94v8AAB2K /rTcWFLdjtMRVlMzJJtM2HKfeTv+FFxcyQXdxJAxkeaUzF5QJFBPbn/PNawg+V+X+ZnNq6v3P//X /nOgu5pvP8wBZg2zJH3s5HFXMSaaLeNbQKzyl7hx8rPkdT+Q/OvyqnG+Icn1PailUvJK1jdk1eCS xdXhRJI85O4l3HpWHNdLIkdrYpmSRd3mEhY4cds+/wCld8Z2XLLZm9ef2OtvyIbe9ncvDqawwbU2 KIZjIgIGMliBmtGC+vdPhv1uvJC3EIW18tvMDKSCN3v1rCppTfKJNxmvJGXpkP2pZ7tw4ZRgleIs A+n9aJbaWYiWMqjxtymcO4z2rOStJNFc8pUbH//Q/nmiaa78u1aDNui5ABzJIf4v5frWXNpz8XFh DEIvOaFjvw6leTx1OM96/NKk5uCp3PZnHmqc2+lh97b3johhKsBt2+ednXAbNOuIYIpmNvIHeIiO UxP5qAjrgjj8qwVOVNVE+v6HS7SglLdEV7Mm4SrIsDpCA5UY5Her39oTXdmoBWeaMYkaU8beg4pU o2p81yoL98peQ9IUuxpwvERHt7gSxlThIyARz7cnj3rc+0QrJdzpPbNNZSriKLHzA9MVdtDfT2h/ /9H+fC7ubXUr9dQuSyRsxkmVOCT1OPxpdJ1Vb65jspLGdR5uxLncDCiep9K/K8JOFONZvf8A4J9c nK7S2NcTCxnuoJJitpLIYWaN8JIoP97p/wDrrdsdf8KtI9qIb63sTD5Ml5HMLiVJBxkcDIPOcDj1 NJV4u3mbe9RabOKv7uzS7nt7Ng8QJEE0hyW9z/8Ar7Vy+6S+klTo+PmKLtU474H0rWlV/cSduv8A n/kTi5ydRRXUge1FlKk8gdp4lPlSD5gmeuPeprSfynluWIkuLkFDLnDlT/DmtKMuakm0ZQg43i+h /9L+b6aUadO8k1sI9yKxkdSG2tyD+PHr1p7Pd3O1NJktoL93V7W4ucCBSGBO7J9M9+9fBwupKx9f Wj7ySNW+d4nEqzNE8SH7VsYFJTg5Ix271nFZZkhWCEs0zgKcbmYZ6/lmoxUn7NRexzTi3USNO9up dLj+zmCMoWGPlzLu5GM0eRaxyrJPPHOjxCZooJgZIyRnaR2I71zTrqCjD+v61FiU6rcX0/4cy2lh 1aF4kALRZKxP8hfGeOfpUNo0l/NLDLa/YpbVI38hvmikxgAg9DypOK0UfeZqrJn/0/5y9QMn9qx7 UtYIo4RLO0B27DtBAC9s9+eo6d6zl+zyahJdKgjaVy25flDHGBn/AOvX5dOryVoroe3UTjUZYtY9 QtmuAJfNhuZzLKG+YJjgY9P/AK9a728NnEl6ZWia8ykcRYBJmUc8etd89Zs1i21FGQEjR3knUQq5 3eYy7sFuhUf4VLNeIDAEzemNCUjugYt5xjtyK8XDR5Ksn3f/AAP0OyMUpJ9bEGkyahslvLvTrO0Q kwxQpc+bIuf4ivX8sitONUWWASRqBJIWR+mGxzj3wf1r1sJBSxtp9bfgaU1zJR/rY//U/nK1YXcm o2xtpD9ntwTIpJJ5HIz/AE9619KufPY2n+j/AGcsWc4HmFu4/nX5uoWx0uyf+Z9jKag5Rb1Z9GfD nSY/slxc21lMFVhaPcP+9CcAnH90E/y71+gf7F+jM/xr8M6fd276pbxbJoHmuBFOjGXawiAHOFc9 s5xX9SZa+Xwwk/7r/wDSmflOCjbj1QS0cr/+So/tI8JWj2PwwsnhlaFodNlvJ3ILSOWUgAuew4+m K/j2/wCCgd/eTfG/xPFqKs7aHfS3scsHMpF1nG8d8jkGuH6PlKNXiDE+Sb/M7vGqu6WXUIL7Tt+R +OvxY1f7Bpl1ZXIAW5jlvoWKA3O5EIBXvjJA54Nfj340julv79L/AM5iJ3uRKZDLJOrEsD16AcBe 23FfTeNUl/aFG3SJ894crmyaSn8XMf/V/hRS5JnlfMnlHA2ng8e1dTpqwyIPNLRx58xZGHb0NVKd 6fJ5HJNtVOW+l/8AM7W11KPa0EcJhdYxtjyV6Yw2K6mz8QhpbO2mhhQQREz3RcRbgOcEE4J9h+te LUqK0nLy/UmtONCUJN9Tb/t063LDdaTBaQW8Mii3lAKmTB+ZmRuQcg+1e9fAK1t59bSC0Nq19b6o 95LHNdFIpTgHcWY+pIwO+OK8TMpQlhNN7nbQxH1mo5rZH1FqVskMqXF5bXbzW8xWFLOJpM8HPTOP qaoaXqsOs2v2iSC5sbmK6kheO8iEO0K2Ac5PXr+NfMQinJM9/mWh/9b+OXQrbToLiXUdXtI7rTpX +xwzTDc6SEHYwGQMhsfrT/Dq2KeIbf7G9tFd21+W1GCaHICqCUDH3OPwr5qrfYxt7ikj126gE90l 5M09pM0gtkhxug2u3DAe2fyNS65q1zHbf2M109zZIog82E+WrbGyAAOprCi24o6LPlHW2oQRCe4z EqW9h5kTxOUldwuAD3z/APXrg55hqENxc2NrJJdPEW3ooJkAzgfnmumDbvcuKseX3E2pqbp4rYGS e1NsJXXMkXOWwvrjIz7mubiuPsvk/f8AOlfykJXcWbHr2/GvVpvZGdrK5//X/kY+EupWtr4g0tZ7 mOMzq5u4yWfhXUhivsO3cE19+acbG/s3kywj+zNMIbbdC99jJP4HocDpX9P+BTvleKXW/wCiPxrx FbjmOHS/rU/tB/4I9XMv/Cm/DMGn3FnHYNYGWy0rzhJLYmSNDIgJ5J+Vjnvur3//AIKqpep+z/qt 3b6LNqkNvYSSajDbvGu0G3kUO3OQRs+96kc81+N5qvZeKN9l7T9T9Y41XtPDaDX/AD6X5fofwu6/ pSafOJAyTTHS4Y8uoEioyiSNivOODgH/AGa5yHyZ4obie7is5oZ85wALrAAEaoB1P5V/d2HX7qL8 kfyJukWg39py3lp5TxSQpvtwBvMv+z7GvNLG/wDK8RifQ8XOrW6OJbS7bZbKE9DzhuO4/OuhrWxn NdT/0P55Lk63dzQm92NPdMq3UVrtkWN2A3qCACQMnkgVpX9jcWl3ZaFpz+a9/m2lvo5SotGIGNwx 15PTpiv9MD+MlH3rGDZWflzXEaO09zFJ5DzyZ35Xg9f8811yx/YbItncTlLiIj5lHqT75/Sg2ato c+m2a8YRRvGwXcEZNrsPUD09615LCSaNHudyBlIjkyQye5/Knd2sIu6K13a2rKiyRmMEtA6ZV0BP zg+hwTVq6kkubRksvsyXzygpLdbjHEOQxAHBOOgPHFCfRG8VZWP/0fwB/wCEestItxc3V1Jf6neT 7p7ph5SFVHB29sdPWpLKzn1Q3yxTRBLa3NytpI+BeMo4VF6FsZ69q/00g+h/H9i7Dp+n6nYWGoJc WcsFxFh4EOZ7OROGikQjgqRjj0qm4tNLnEjmNcnCsSO/HH15rVW6mcou90Vhc3lvLPqOl3TRzsdj 7ZCCUOAyHB9Ox9qalz5Lot1pZM2pp5P2l0YmKPlg6eg4xnPekRyvsPd4bCxKaVd302oQvhGjfHlr 6ZxknPTtxWro+mSy2enXV2268nG+7aY7JDn+Jgehxjiqirsai2f/0vwGa3kHiKbMK+WIxGi7sq+A Pm9PWqiWl1dy6hKqrHa2UotxJn5zKckLj6A1/qAfx6opHQR2TxiET8HYHVc4DCoLOWK3v2PnQhoA XWKV9pOeNgP0PSsWvesUbZkZ7G8mtry0guLYC7ihu4y8hkzx5YA5P4isLw7f2Ud3M93psiX2p3LW 00sOYhK5X5ZgMY5P8q1SsrCTui8NLhluLu3JLy2zfMgbiPOc7h68VZtUQBrGPEcsK9SMFAe9Mia1 P//T/BqCzs7R5YftBnu/J3pG0Z8qXJwWJ6ZyP51HosMT6hI6Rql2ykuAB0XrX+ncua9j+NzV1yS3 sbW41F2eWSztywSEZfsTgd+AfxNVY9YttT022kSGNRt2n9zskU4GS59TVLmUQCW3Ja2jhiJVgXEy ckEAnH0qPSvKuPnuLdHu2lOJBymBnrWbbe40ruxo/aJYr/z2kywjMIgIDL6AjvnGR+Na17dw3FrC s4+zxr8ssZT5CPUCltsK1tD/1PwnP2+zktvJ2mxuJChV3IEyg4PTuODzW1aaeLlHme8khWIEJBHz 5zf7Xt0r/T6Mr6H8fdTj/srtdMt7bOTzIGRd8KlT0J6f/qro7Z9Uublbq5eGG0WPyTIq7fKRRgLj pjrSlJrRD2M3Vo5nnDW9020fKsanEb+5ArRtZTFFGk8irIMKN5x+WayLm7pMuywrAjaheEMkKFEf lVUsOOM8nj9KJdMk12zQ2lwoEa+eMYxPgcKPXr+lBKTex//V/Bya41YSwSSEtcRRrCSRkoIwFUfh it0WQvI0v5olWVuJHxhjX+nB/H5SkmtrK8ENzFsgEe/z45AwOc9R2xV641TRrezVo4POypEaGPMb ZHfNBq4K3mc8HM0dhJHYWqM9z5CShQAm7Jyx9OAK7TTrhrEXSvelYY1zMsJKRtjr8o+lJpbMqCdk i9IxRRJYw+c06FSgQHIYEFsewOawptI82EzBJHmQfPG/yquTxj9OtZWvKxpyNI//1vwzGntYxKI2 k3dViHzAe1T2csSyrM7hFRsSqRgqfp+Vf6YtNOx/JyVjI1W7ih1eO4t182S7P7wg42bAAAfrUl3L aosEtzEpllfYFZflUntzSM5fFY0p/tBt7cW88qJu3NEy7htI6D0/+tVC4s/Nmt4S4LZG2UptwTxV x2YnFpXM5BLYajJCsUsvkjdM23dsPbP88irgulvjGzxSGa1cwmSVdpYcH09+tTLScWYKN5adD//X /CiFYJdQikCRTfZnDOCOEYYIyT24PFaurmAzwtDa25mnJDMBhkBwWC+gzjj2Ff6eOSaaP5Jmldlg 2kscKRX90y25G+GNR80Yb0571nXyTx2cUsdut5ZPKbaVRJsmjyBhsenWsyUrKyMDz77zopEsv9A0 xy8ZdeACMk+p25612FuVurS2laQSSszSspXZtUhdvPfOTx2xQBjT2jS3BnkuprWFQVQQgEMwPVs1 P5kLMUtpZ2kjiDP5i/I3Xv0zUt22N6Ub9D//0Pw4RJ75CJBmMDbwcAf5/rUDWmlC2t5Z9Ul02K3B LCzUF42+6N2eufw61/prJ8tO72P5JxF5TSG7rd9MKacs92/mYNzcoUD9sEVn6ZHdRW8y3NvFbFJC ww/yn6flRBpxRHLaxoWvkXUcsk5dGU7UCdyCOfpTZr3aqRALGYSVbHSYdjz0qy4RuypFbmc7YARu lEjAc855xmruotfaSSDblZZQAqmMqXBHpQbH/9H8JlhlmjaW4gaLjmPb1Pc1UFkZz5UzOiMM/KML GK/0ynufymopq5PYaRc2lyIIm3C4xHGGHI9MVqXliYoPKP71487nHJPXJxUlPl0RDp2nWN6I5rZ8 SIdrOTkZHBzU89nBZCSSWRLg7i5LD5DjpgfgKcZu2hlJWdivFM8sjMIwoK70VBlFHv6VsWb2+2YX TeYCuVUchR0IqufSxLV1Y//S/CTULUR5GmgosrbtzHeyDIJFaMF1DHErSL5jINuW4I9eK/03i7o/ k1RSVgk1CJYWWP5ol/iYYIJ7CqgvpEjZDi3h27pG/il+g/z0plFCC/guWfcZvso3LGZo9jE9AcVq wGKeNmhbc0MWDhOw/DFYzWptGKSuVbI3M8+XhHyA7Lk4QjHQAVn6qmpPLFcC3kR3by9qoFiwvG44 4545qRpJbH//0/wistZW2imtLqUIUAmMTnBPUA/zrXjvILGFZLnSrm6nuoyYUtsLksMqX3dByK/0 vTufy1yO1yeKRZ4MxRR2r+VtkCYLrnqpI69xWc0UjIXyGVDt3njNQ52fKZygrsuwafEyStdlvKMe A0R+dTjg/nisGUafAS1uj3UgfbcfIQmQcDJ/TitL9TC3QzdS1y5Q+Vb6XFbwTykk2/yxJ9cknP8A OtdEkmsoZ0JzswUxwT3qXJpXFBRUrdT/1PwhuClvaBblcTZEkTDhVHPX9Kz5DfXdms0kiNEkh2pG ecD1Ff6WQfus/kmqm2mWLO0gv4zMZVLR/KY+FdVA/u/1qWztfsty4tcuh5ZCeEFOGxD0kiXVreKK 0eYyAPJhRHtOTmseK0tWtrTbv+0RuSjGMny16nn3rClG2JqX8v0POlJrHQT6/wDBLd7ctt2lkRFx vcLjIHH9KfaWFssy3P2qR4pRuVJAGiyB2+pr0HGJ6KV5n//V/CW8t5EgLllJLDbEuTJt9azzboYT DO7pFOpBwOT6DHvX+mvLdNeZ/IqSu0X4XhjtUggdCYx8ysACAKLaxN1aSXazvNLO7IkSJhYcEgAH v9az5bzSNcCm6rMF7X7VDHG8rG8tp98TlcAjnj/PpVq0somhYXkxk/eNKFmOSW7inUh+8SRpRrTl UlJ9yzC8KpGkcabYH+RiM+X9KytSfUNS1CziUGOHzt89wchQFHTHfNCppWPTnVTouK3/AOHP/9b8 CrPzzfEO2x1bauwAfKOn6Ctm6tbPz43lnlaEsPO8tQHPqec9K/0zlDkcWmfyzl9vqdpd/wBTJuJy VH2WRZ7ZWO1zgEr06iix0uFLZ72KfzojKDOwlMpQt/Dz06Yq/dWp3Y9xUY+hDqcFsjrLEolSTBKE 5ZMev5VDqSXD2ol05XaHYouICecjqV/wpNWizz/IrWsV7EtuJh5VsThvmwYh9O1dHJMlzCbe1lXY GAaXpGcdyaI2uvQD/9f8B5w7l47KBJZIwAqlsxSMAMkkdjg1pIV1CHZPDEsoGHSEkrGcYwDX+msp WZ/K5z7iS3lYXLJNBE21A3LLzgD0rL1S+vkeJILZ443G4y7M4Ge1U2krgaNpMzWBEcqNuJXcfmCt 0OfxpJrGKOON2ffcxvyw/wBW/wDu9/WldNACbgRuYbiMA+lXreCSOItdRCJtx7hgy9m/EYOKozlJ rRH/0PwasZIUiaNI1jVckuP4s+tcw8dteyzJcqMlswybf5V/pqrc2h/Kkn7uhn3VjcGSOGMgxxjG cZBHrioY9N8iApafu5o5DI02Tls+2e3P51TSe4N3gXorqaS2Nuz7pUOJZBkOR64pLbSnXz7qG+fy 4h5s0UzZeQZwAPp1xUOHYyL1tqDTEwNbLKqj/XHj06D2p90untCsMpWGRmykpO0L9T/Sos0tQP/R /nYWBLiW4tJLkLbTsEt5lJWR8c7s9vpTZNLIkdWudrKoSM8ky44r/TFJvY/k81oET7F9muUDpG3z qBtY+4PrVFdQsY1e0hidHWQlZXUgHj7oPQ/hWkY21Y7vYdaRtcRGW7TyIowxXYu+Rj24rKdm86My IjIylU3D97k9MirsEdGW447m2jKzgiCRtyhXO71Gamt7iVzIYyqwxnDHGCgHvVxhfc2ex//S/nS1 S8mlit9rl0DkpuJ5x7UDVEhgCySmGRj5aBedxPGAK/0+cEz+VYL3SZfs10iSZMtwP3c2V2np/wDq rMurZ4ZBBEAseOWc7j14AzS9mii60c0tps2IvlABVK8MB1P1rOn2gQJcEiOLgRx5QP7tVKKjsNNr YpvFLLdxvbMUiTBcYzkDr+da0txKZl8l8oE6MuHHsRTDmex//9P+bzVLmV7ULCzxSq/74Y2rKMdO nvWZbzyQrGYoZfMkYICFJRfqfzr/AFAsfyzzS2Nqeztp0eWGRoryN1DyBCFlwB/9YVmvaQQiO4e4 D3AkyFAJwR0596CG0i3Lue1UTKpZ5MAxg89ev5VDHvtJAdzIX+U9wKDPnZLNem3ZCQJUc4Zs8iqq ahFNeLHb42RrukORlaDU/9T+b4TxSSqAzbs8svb8a7azube2gRQ5lLpiVR1T2P8AnvX+n32z+WYu 25gXlpp89xc3loPNS1XdJDIw+ViPm/DNYWn3KzNcKbfHBRRu+UHsTUqHc1TT2K8sc9vmTcWGSXU8 gVKJ31G18s4WKJSAF4APaq5IickihpaQFzbvPi4jfL8EE/Sta7uBaxyiHdJMFym3jmhxTdyJT7H/ 1f5mNJad5VM6C3XJklBfzJCxP+e9b1zeW8aRxpCJo5JOZgBlCf4v/wBXNf6eez8z+VeeJmXkNzE+ MebGWAKr8rKPemWVpc+YXlZoCWwkZUApj/GqUEtyXPsaeq3wihit5LQSorbmuIGPnPnHBHoMGrV1 FZXVl5aykFIwXIHMfoalw10FGVtGZlnBYQSkW7SHzAFeZwA8mBjJxUslzNZyv5EqlCCChAw54wSf bB/OnyK5L3P/1v5pv7RvZLaSOWVVmmVkZocqNrZGPyqrCkUduLaMKjRKOg2qSe/4/wBa/wBPuSJ/ J5ZjupFaKCJto+7K0nKsT12jtWldQRKFETgtwSSOQ30qXDTQ0pvoa0cTXVptRhK8YDOU+8BwOlQv pcCbW8nEZOXhb5dx7g1nY15naxRnmkWWWOC0UOU2xMG+RP8ADFXreyeC0Ms0GUlQp5qDG5xjdz/n rScU9ylNo//X/nMgK3WC8ZiEA2IDwGx3qKOKG1mmMwBeVflIJHl+496/0zcLbH8u80S1EgZYYYgC iMWyeXYnHU9T07+tXLuImKWN3i2uu0EH94T3FQKUlaxgNpdyXgMRfywdgHO0+xNaP2OSFxDLGY5F GSjfKRnvUyjdaEczMS51aO0uvLtBLFKjeW0hXCucc4/lUUEIvPtX2yYRq6nyyBghz0J9u5rF/wAO XoENJo//0P5TJ7qHRtSvLW9ulaGBiGu0UNHMc/eb3/z7VxGr6jm6eWF/OtpDvhlB4PvivoONV/xk 2OX/AE9qf+ls4Mqt/ZmH/wAEfyRnPMtxErHII+9jvTFiCAySSM8R+4h+Y59zXyclaNj0GhxiRkyo MTd80+3L+W6D7397pn/OK55voIjLSeZHH5TyDO04GcGtWFzCpkYMNpysZP3azLinc//R/kX+1SyD dgqM5OK2LS7gjtyMmPJ+YKNrV443e+pBcQxXcvnxRkZ+Teo6jpg064jNr5YMrRRwDd+J7VnNpiIb S5dr4qEVAygli2Cea0m8y8vJwIvs2yNRuVfklxwDnvWZu1dWLDw/aLi3TDSske2SXbiOLGeAa0A3 lKyxhiRwxI4qJKN9TA//0v5T7fbMjblZsHkgfLinfZ4rcPght4wR0xXzD3ElbRFq3jhZREDgbc4A xj8apHam/Ebrszy3B49qzm7aDLFvcMVLmNlKDL/LnIq4IftCtIs0sBDBhjAI9BWQFaPUru7Rre6j WOe3YqCmWVxn5ST6kYp8scrRqZCUEf3WXjFAH//T/lnthKu5fOLq45Cn5Tj3pDbzQMWjLRqTvLxH LtXykNrAW4rxD5ZlV8p0LfKzY/rWgb03SbCwSOIARKo+d/UGrAgVizssisqbT5ZA6tjA/DPWr0EM 81jc/aCkV1EA9owYkMQehBHegudnZo2b64j1C0tLq6gihurWMZlQfvYzgA4I+lN0/VTayZU+aHHz I45fms5voD+BH//U/m6vtQtb+F4vs6x5QY2tkhsda5ezjia4njdZUljwMshVHHsenrXx429EjWkt VRQ0WN4GCe7VRjvEgJiDFWJJbJ6+tBrD4R6rdXPnBLl1jcAeUR8vB/OtNkP2eGGX9+8AwuRnaPag ojiuUWFolB2o/KMpHPtUK6n9llQ/wOcbcZzWlPqB/9X+b2XUbeTaLdTvIBYEjI9aZb6u9tMSkc6y QsuyUfc59Oe3v618s3ZXOgbq2oajeKiQSMoZcC6LkyxHr8q4q7b3E6ov2iQyS4+Z36ue5P161ztp bgEupQQyvFcxecXhJSIcq56YNZ29oIwLtGXzGxEEUyInoM9hUykrNIznokiPZc2umJM7wyX0rM4S NiYoh0XPfH1pqXuoIibJWmiaQFoi4CRk9SKyMz//1v5xbqKSe2jM7QyBsEbHDe/I9RVG4FvFHDAp XzGO3Geo9a+HAsWubWS2jWFHh3/MjHapHP8A9b86nku7me8aCWFVjV8xeWSwx70G6eiKE115dyPM hdV8zy1OwsufetWUCWyLxeW0rMQnOCCD3oGQXDkAAouUjG7H8RxVWA/vTuTyRgMFJzQVDSR//9f+ cS4g8+RMSFM+h+9ViDTzIwt1udio5nmeVuOBwF/oK+FcktD0NhtmNSnlkiBV23kQbcjK54zU0luj CWK6I/eAxlwfut7Vk3d3Kcm9B32QAJFu3sg+STOMU6F4YhtlIJDYcjnNZz2DTlJZtQ1GJfs+nzyr avkPyRwegqeGLSZ7VEvI5DdKSxmBJ3cfkP8A69ZAlo2f/9D+dn7L++jaJS8QOAAfmXt0pvmxXE6h JxiFyCAcjPvX5vboegaFhb2s2rxtfWf2iCOMssyPhlbBC/kSD+FRW1kG1R4SggDDdNMxCbx2HXnj n8aBPY0XgghYrEw27sA44OKoyXf2K6iXAYS8AKOTjg/0ropt8jMGnYbdiKP7XdQWMU8s8AjCsTs6 5Jx0z1/OiymiYbXH2YrGSnl8AEDgY9O340EwVon/0f534bX7UHmaZd24g8ECMDpVIDVI5oZHvftE NtMRGkMWxCOwIyfXr7V+fnSt9TdsL1J7xnnhKMxOVxtC57ipr20t3uZVa+aWCWENFGQFkiIyG6dK yqv3bG0nZaCLfeRCLeO2EcUKgRtnMj/X0qazYR/aLieNzJIB5Zfq2Dx+GK55aR5Spu9JMp6rMJbp ZD8g8pVyvAGBj+gohuTbxzZxKHhMatjd5QYYyPfn9a6YKzOY/9L+eeCP7FDvKrI7jJfGD+ApJpIM WkipKklx97EeABjrX5+dA2IQiRwF3kH5l6mnzwurRCaERxyrvTsxGe4/CgC5aw/aVdCFCoflj67h UhthPdJJGNhhXynL/JGo65zQBJ9rWS32FFkjglI3MM5PH+H86qKYXby1QKAdzEDA57AUW6Af/9P+ fB7V5d8VpCWZVyOdq/8AfVaW5dOtUHmAt5X75G5CHkHk1+c2s0dXM0rIpRkXStMyALnCgDGR61DY mKKS7ijgIily2Ix8pbGOR+AqQ5pdySVzpqeaxbZjDlVJIzx0/GleX90zsG8thncRyM1pTFdlS5ng SADzZLeJRslKJkSnjH9ORUUMl1seOIFvMXAdV3MB605tWsbRd0f/1P5/rC5NtA0czhmK4wQNzVny yQcOyFZCchSPmPNfm56A641C3tntpZpHjjOPMCLvKj2Hf6VpXl3DJJ51kk3klFRYpF2sMDliPUnN A4uzuMgZLgS+YjKqIdySfJ04yM9ahdrGJDtLMQvRhtCn0HPSomtDa6ItL1QrdXcqxSOVh8pMH92n Xt+J/Sn3N1ds0PlIqQyHdOJCd7DsMf56VlYTkkrn/9X+f2GLykk8ldyzrlhGdwTB7/57VmXFu89p cQqzhipAIbDJnj61+Y8jtc9Ftt6ljRYLPTBA0iF40QLJu/1kmOuefr+dZywW9xqNxqN/dmzsoXZb WCGBpJGB9eenA/SiUHYmo37JpdmX4YFjt47mKZLkTuQrKwIRO2KjjgiZ5IBIvnxnzQr8bM52n6da 2qK7jYwwi/dJI3r1YrnS7SN47dZLUlpZom2TsTjHfJHHFZJSG92NDEAkZ2Tsz8k+uPwqXH3kzsqd D//W/n5tVIa4hjziNQVcDHtUNvdGPz4UlHn/AHfnJ+XPfP8AnrX5/K3s1Hy/U9hNKlH1J5J4ZZ4i UNykWPM+fJyO+frWXNbtJLLKz7IG5WIHqw71hpYx1S8iX7WkYijdVbJGZQSSD0Aqy0l68iMriOND nGfmYY4xSFdkSXFtDMv2ZpQ0beZM0i7CD3A55FRXV2mpz3j2ELW0EYESb2xJOVA3FsDjmhq6sXdu Nkf/1/54JLlInghZUV+CXxkE98V09lf6bNDPaxnN4JFUuBhVGPX34r85jSUYWR7GHqXqxjLoc7rV xdW0s7xxNPMExGn+qWTjgA9K1dJt3ntoYr6IJNjzGYne0W4A7QfauOvCVo27P9Damv8AaHHoR39v b2TRRRLJI7PtD45Pft/nirCSoohXyQ8bH963SQevNZunKFBpdDpi4qul/WzIt9gzSxRRLcNCu6aB 8ptU5w36cfSo2u4Yn8uEN5IUPzxz3GM9qnlcqaitzaVlUckf/9D+eyWbLO6TKyyKDsXnb7VJYG7W WZLfPmGAnbIp8vByOuO9fl+Hd4OJ9DBy+sxc9zP1DVFmkhtJiCbUmNflAAJOSPzqWzSKVnkiUBx+ 73kYZgOfyrlnT5p+n/BOao/9pTt1LE9xJZRSC3mUJLE0UtsYyzsx/iyePw61g6U80Usdz9i+zxLm BCxxjkZ4HTPXFKkm8RO3ZfqddSTbSZrLpSvI8sblPMm848/ImeSPpRHbpOkuyXbIz4kCH5XxwM13 0o2r6GLfu6n/0f5+LU3EFsqtZQSOrbG8sbC6luGYnqQP5ViXmn6SupTy2JvopZURbxC2yEnGTsI5 49vWvzuup04xUdj1qjcY2R2/2y21G0i0yZzIwAGGUv5I7H8MZ/CuS1O1ju5Ws5sxrZnalxuw10eh 249s9QO9ZVG2rsiN1TVggS2RfIgDyeQMCSU/vAQOmaQ3dx5U000IjCpsjBbO8/5xTFSVpMja5k+y xNaJumDD7SrjamD12n9fwqtFbqpke4ldFdvMJQeYcn2zWdaTjTduoRpOpUUV01P/0v50IZhI0MUc ODLclXkMREkYAOCfbj9asNfAQeXeyzSTAsA8ke3GCQAMfQV+UKM/bQS8rnvU4yjF9itbS7mdvI82 PYQUcEAAjGalsId0ojVY40DYO5wgQe3+FdFbmUlGIqilzps6288OiSyXUIrdFjj+V5M4Ep/PmuDl t53lYyuXjUkBVJ2itqkP3TZdT+Ite/5ktkkqFrUXIihuG2xbjhUPufc1es0uoVlbUIonmt8hJYX8 yN0HuOlKlFNqUjCMpKDXmf/T/nE+3TteF3DxQxKWVlYrt57f57V0NjJFFKPKmBV1DlZCATxzx9a/ O3FJc0u56lJSVVt9v8yxfOJbc3AEbQ+Z5LxhgCPXj8/yrHgtYIZ5ZbX93DI2/wAotlEHoDUyhd2f 9XOtOzsyOa2tY7iQyzbzIv7pAM/Uf59KiS3SIu9sArk/OdvJAFcqTV4dEdSpu6mZtxNfqyiIuGD5 Ysv8NaNlIoimklRowzZlKgktnAzVdLf10KS/eH//1P52EgjidYWzOhyQWPTOcflmpbQ3dpfKkUbC KVWjfcflUEdTX5FSpuUprufaUVZa+Q/Urf7OyPHuuEY5urdpPkZCTkjqQaz57vToARYGRYIoS7W3 BSNj1GfXiipSUJQiiar56luxR0xTPY3F35KRbSVgtpJf375OQVHvz9M1dR7lLVHgVbe4eMpKq/MO eOtbUNKMoPu/zY6iTlGb7foVDZ3lsY4ry4FwjKJGdD0Dc7cdiM4+tcjKNUXUJl2pDAkv+jfxmRez HB4NdFDSPL0Ih/DV+7P/1f5zU1ddT0i3stRt0vdTs0FtJOoKq8f8CEf7PPPWqcVpb21ik0ksRu/M ZIrYNlomH3TjuK/P5S5Epf1ufX1X75e0+6iu1uF1FDbCOMrG5G9LhgPu9cj8aqWlwVlXyHaGUHbA pbaoHTNdDlCcLNHLJydWCjuOeZNYvGtFWUfZDtmvZ1MFuzc7vLJ+8BjkjNNfT2hZHiVGc5E0i8Fv Qn1I968txjOsl2/4BtGnOSk2t2Z9tiHVFhImbK7s8Lbq2eCTjr7ZroLnUVg2GFIvN3YLkbgxHYiu wmz2P//W/nOuWfUfMnP2Uz3OHuTbqE8sjK4KgDHSsxLOKMIrTsIA581wP3p/3RX5jVjCVXRao95x cpu/9WZrveQR2IjjCqhPoDIxHGSax54rW6lsrhpxMLZmC2lwP3ak8ZX612S3ZvCNppE2oX893PEr kbYYlgUKoVQqjAAAqS0NldahFBLdoZ4oAEjk48hSxBbHXHB6V5lGFqri9zpuvb2a0RrPp0brKNjz RQnzDMRwOcA+3/16oNbuzYiJcIQUA/gr06NOft/aIuc40Ix7v/I//9f+dCK4muA5ddoiYwLLsCqz ADIz3I4zWp4d02O2YTSnzpGudyttyi+gx3r86pJxxFn3/U+sclOTkfT/AML4oLWW9kudSu0TUSqx 6bs/cMYs5PbA796/UT9hi2tLz47+G4THaxtC8dzZXFxlmaRXA8lcf3s5Of7hr+pMGmvC9QS+y/zb PzbLablx03bVO/ysj+wbV/tOnfDW/sJY1t2XQd1xEDhYw8ZLBD9Tx74r+KT9tHXXb4++MXEcssOr J59w8xLCEROUi2k9crnP/wBaub6PNOSzzFNfyv8AUnxrlF4PDt/Zl+qPyx+O9ro2o6dp62+rafaa sk7W9xFes8R8tlyDGwBzhC5wfQfh+VfjOGDzWvLeaCdbYyQKgcZl5+8RnOBj9a9XxrVSnmdKnLe3 6nkeHdWjUyydam/dbP/Q/hsFnGA0zhfv5kboqA+1dDaWw+zNsUSFR5qLIdiOByF/GsqkraeR5+Ik 1JNrr/mbtglpFMl19lmMtwojmV5M/d64HYf5zW3FoMFyRcNduiO5JiVN2cdic8V5deNN4e0fiOHE ueIcU+50unwwWuqLaJEht5rbYwL7dpCnDA5wM9fxr3b4G20jpe3L2L2jlnslu40E09m0c26Nwx4y 6g4HXB7189jqMaWFTv7zZ7mArSrTdNrRH1ZH488SeEY7/VYL24nt5RHZyWJsY7yR1JIZ1V1PUYBx g++M1Nqwt7uyW+sLZWs74qJUUCKWF2QM26Pqvp0r5+m/esfROCVj/9H+OGzGn3kFwLj/AEq2tOWt 2lMJdiOGX3HBrE0+1+w6hBLH5oN1cq5lZtzyc4G5u/HFfP1ombv7CJ9E+IL6aErcSSQ6h9nt42jN mhVZWZBiPbgHcudp46is+Gc6k9qkuli2uNoZ9reaqtjkkHv9KwpR0TNVK8bFu0sbWKK9WS38sRM0 heRCI5j125P+ea53UbpP7Eme4ghs742xa0s9MVYoVYHgFsDjAOSeprojDUtyVjy24mu5tHa/tbGV jbhknJG/Z0DdPTPX3Fecao+99PutPlPlbWM6tERLvz1VfzFelSjZEv4Uf//S/ji+Feu2+p+JNPsZ dO2SC4jgndIyt3OS4USRxYyduRnB79K/UzRYra1imms9kNrZFLK3e6kXeU2kMNvfheRX9M+BD/2P FQ81+R+PeJCSx2Gl5fqf1q/8ESPEdpqnw2tvsjF007UnaDUWtmMEkUwXbBtPKlG3Lz/dOOlffv8A wUltri3+A/ia9tYU1Fkto7jULOViBJCdySR+WAcg9fwr8p4mgqXigk9vaL80fqXFFT2vhYqn/To/ hN1y7XVdZ1WabT47K3WFdPgtEk87CwpsjIcdgOMeoNeZDRraeaOa7mHkWj/aIvLbCbl6Hiv7nwya oxj5I/kWldwhfsjQ/tMverHp9kkjEqHl37XkPqW7Y/GuY1rQEttYnntUjsZ5l826aI+YG3cn5h0z 7e9daT1Qqllof//T/n40u0giMkp86a4aDKmJ8xqQe4rVsrKaeQpG62926+dCZTgu47Kfw4+lf6ZK LcrM/jmK1RQ1TTNXvp9L8uyutMtkuA+rahGGLX7q/ESnpyMZHfHvWxbhALjT7q0lCTS4uZ5lKmXA GCo79ualbXNajjGbJn1PTUtriOOyle6U/Z0mERW4kGRlYwwHoOQe3tUGi3EeszXUKQlILYCAxucN A+B3xye+KLEc0b2KOu6Vf2Ujr50iKUBQhynyH0qhHJLDpkAkmC20V2oM0Y3XMYJUHc3Uj6+pqVpJ nRTs1c//1PwX1iKx1NLOIS3kaRzYVUBG/Ixl8cY749hVm8TRdAs4rVbgutz8iSFM3M7KM4GeRjr1 r/TSKV9D+RkrM5XSLBgl7JemRkupttoYIyFSQsMKQAc8EknjGc9AaojTbcXEsd5OzO0oW3jlYBUY HgAevHStVbqZOLubljY3sT3yWsEDfa4AgQjaXKcjnoM4HSo7W31nVnaWVTBLb2/kPbNKv7pFJyUy fr09qdtEKzW5paXeWVutosEUS30TsPO2iR2GckMD9KfrFxILiOaVyn2h/L8tfkTOc8KK0jFLYR// 1fwdW5iMRkjhknu4/wB2XKYXgA4DflwK5+6luopkmkd4bOS4Vry2CiNZGH3GLHnIA4z24r/T96I/ kPk0Ovh8qYpKwkm3LkSMckcVy+qaTEb7YqtFvYSTTx84yBhh78fpWN9bkuDR0lvZz2USR7lvk2Ye 4nILEEcDgDkdPwqhPJL9qa5t0jihtmUOsTbimeOO/rWkZX0JSstCZ5bq2uZLiF3MT/emY580tyQR /jUskc0ck1wpRHmUKHc8DsR/n0olK2iG4N6NH//W/DmFgsJH2GJmkQAyk7iMenpXLS20+nz+cBHF HM5z5Pyuue5/z2r/AE5uz+PfZ6s0FvXttqC1hvY/LLSG5cl5OemO/XNUIYmEkWnwwLFJq0xS0gjB ZpJHPQVfPoT7M1ZrWaFbWwlmdJ9PkKTRrjcxGVKn6Y/Skia5j89bKFGMI3bCpLY7njp3/Ksy1FbI h0ywuNV1Bru7gnjWznA8xQVXaQP58jn0rU8RyS+dbNHJ+4hj8loimXAB4x/nvQKULs//1/wm0oyT XFwbqTzHaUyxoFx5YPTityN2tN7FeHOMY4wa/wBPFNJWP4/sVmiiiiLhyUds+V1Y/wC6euBWZJdX Nxq0GlR2zG1ubV2nkIIiG3jaT079Khu7NIxTV2OFlOJXiGxPJzsA+ZfaohBNfsTfZh8qVfLj28OE YMSOc4OOPr+aKcVaxo3F7DrVlLowtrgOswf7bCcCPZ/Cewzn8RmtG2hj0a0+zLcMY1QN5hBKxkrk hQOetA4x6I//0PwcN9LcysoUkJnEoXBcgnrWqsz3NotxFLPEI1zJA0JDyY/hweQa/wBOD+RrK9zB j1W1uJhNcad5EUkX2aSW6VllByMYQjGCCfpWhdFL2RYLOMQwQIAkk3yRsAnzHPTB5/OguMWwtYbi XQtQ+ywyu1srSggbnRh0K+3I/OrGkTRDS47y7bCyIPNhc/venQiguCsrnS6hql8265t7ECaSOK2t yMxx4JVAAo74/PP4jRGk36QeYbtbK1klD3N3cyb1hfA2qAeMdeK5Zz5KljthS5qSbR//0fx7GnR3 R8+3uI7giMedJE4cDPG/jOATSnwutjfyWN9EkF+sK3MayHaJEf7rrngjscdCK/0qdZKXK92fy8sP JxcktEchqmk2TTzxPYzSvvVWu7IhYUOcEtIBge/Ss+bToJb6KJw8sMSh4i2CoI+7n1I/pTVToctS lZ7Elms7XkkchMEcTeXiUZAwevHPam6pdpLb3FlFGHnOHSZE+ZSv+11x1rek+aLMvIyTGVvILqyD RvPCkUsQywUgfMxzzknJ/H0rdvIriCFJltImiOfPlZxHzjIGO5qWlzI44L3pep//0vwusYLm7M6q Y40VchQPmznjn0qs8Us8k8EUyx3FtbvcMSSdmxSfl69ccV/py7W8z+Rm27l2w1CC4t7N54Hu7h3E CyuMLwOWx696uX8LlIlsriRdzZmhwAre3NI1jFOOpEI79LZmSWKKIcNkBmk/vDrWDbaqXuLS1jsr m4FzcmBigysP91mA6Anv70bDUO5q3Dy3l/Jp8lsLRLcmNhBJv3npuPJ71etNOv7GUPN9lfToQZJy 8hEoXoOPc9eaznLllF+p1wpvlb/rqf/T/FSw0mSOER2bv5F7cyXY3EnqcsBnoB2rK1LwvKt2oaNl jIExjZThh649D+Vf6X4madGSi9rP8T+Ta9GUZJ22uTQwT2MBtWZkSRy6LtwmOOBXOL5Vxqh+0GV7 eFeIs7Qhx97H1/lVUNUZN3SJU0p2uXMMzJaZysaHGT3z+nFW7myafaWQJ5K7dx6tirbu0VGVtGZT RSiQraXTQyP8qgnaQfUd63LWa6eWze8u3uxaDYhmTcAR6f5xWmxqf//U/FG6vrYxxxXcy2sYJEJe PIYnoOBnnFOsbDT2tfJjWaa7nnZzkEoykDoMZr/S2T1uj+VoxtHUvR+Hru4VJ1Una2yFV+bG3ryO 49Ktw6F9pi8qASXM7KXEVuDLKTz1Tr1/Kpu07XDlXY5Keyns2g+ypJE7J532cR+WrbjyGPY8nipd c0m4e3ivo1dIGXYIwN6s46knt3qFPlkkKUbrQ5ZZ7q1R1l3bZiMMgIQBQeP1p0oullspoCxjKMZM MF64GGHb2rXnRm42jc//1fwludQESJHDFLv3DLeUST+PpVi9xOsJ8lFuY1A3QgqhBB/X1r/TKEkv Q/k8ZcaM0+mRJaTGOdpGeZSdyJjBHPXnNaLWNjdWkMTZWe3AR8Nu3kDk+30rTmiA65gsgkKkrK2M Om3aR25qkbm206Gd4YZXTOBboMgn1/WolK+iKXMldFyyY3KCWSMwISCozhjVlLYX2qW9sq3Lw433 EkK7khHQFue5wKzbsjaOs+U//9b8Rdd8JwLqdjOipdtNiKeGH52CjON3oR6c1o6noF5qOnTWmlRX FvqdrNHFBJcxko6YBOR1zjuOOtf6WQaS1P5bm3sYa6RNpvm2txLsvEH76MPmQe5Hv61NOEj8lW2/ Z0hLSjptI9fr/WuWtLlaZnN2TbGW95vyojbyHTayjgAf5FQtZwXNnMYcqh+Vip2Sg54PrXRNtRsu xjFczSJ7bSLW6e2sCAJVTzJGkBITBABY+pzkZ9DUselwxXZsHuXxazCZkifaoU9sd8is6kr0n6fo KMVGdz//1/w21W3huAYGTzIUn3wk4Lrjpk/hXPQKsCyQiVnTzCwXHKj0Ff6SUW3Si/I/ky3NSUvX 8yfVLWCBLW509ZJGPyuQuxhxznFXtKmggn/ePslmIi2seGPXA/8AreldUFZGTTTF15UNrdK7gOg/ dKmGJbtWPBeuLW3N4oQpH5YSNNu/3rppxhFub6qwewh9Zp1p6pXT+ZE0sdxc/ZTEpgZcOrLgjjsf xreg0tIrVEyqxwL5kaFtpwPSlFNKzKivesz/0PwjlluXRjG0UcEIy8jngD1z7UltC8j+XLh2YZR/ 4Meor/TdLVn8j8tmzndR0u+Wdoy7iCRjG0kRKkr35rotP/4lNq6iaSOJYsIJG3AcY4+uaiUW5qxr hZKlU52trj4PIa2luFHnMFyka8OapWsb3siyPEqKhJQHt65/WrUJSk5BD3W+VdWa0dlbRvHOzbY9 +H43L+Xf6VnOjyzXKxOV+c+U5Tacdvl7euKFBcqu9T0PaUXC6ep//9H8FrcvZsTdIJXc/vLgDa31 x/npUl9d21rbef5nmNcN9nj3IT987fwPNf6cON9j+VMOvZUVSXf9RlqlrDEbIxhQwJyFztJ7fSor fQo4bacR3UlsPNVzbxcRTYORurKdKSVkdOKqRrQt2sUNT8y204XC20swl1AWisinfGv98jpir+ml 5ovIUlQg3Fn+UHHJqp/Dqc8Uw1a0W9tpLeO5eASIEZ4sb1GecZ9RkVTk0hrXTEs7C6kiiCqI43O5 AQNpP5VnGVpWLtaNz//S/A2OBdJs5JLt5ViEe5XjXzJGbpyPT6VJodnAitcyXTrDdP8AM5G51Hrj 8TX+mU2uZH8quXK9Se5tdNtjcG2nkvYs8SyxCF89ThMnAFYtq1vPKDH58yxt+8MiYUYPRT0PepFz 6pI6U2llcp80IBVt7LGAm/04+vNZF8zQi3iXT/MRp8CfOCBj8uB2681tD4SmrleNUE+Cg2ycOHHT 1xViS/t47xLF0MUDRgeY67s+pH0qjDyP/9P8ErW0hvVu44LtLdYYjMxkcLuGccfX0rk5btRL9njb fLESzPsPlkDr82Mc1/pwfyf5FttRAtROAGdRkbcYlHoO1aGm6hpt/iWKCeJJPkuY7jl4WAxxjt0p pXdirS5fI07jSLGR0uLVXiuY/wCKLH7xeu0jHt9apXPkW8TpIrrMWwSQfn5pEmKo/evIpARBt2Zw frVyKwivmjgkKjzmCq8n3OfWgD//1P5/Nd8L3GntGwTP2cblKMNp46isWeaCSxiu4o5ReW7eXMqj zEIH8Q79hxX+nB/J5SW5vtSfMMctokRHmtcxGFpfUhTyRjoa0pb60ntrO22QOltKWExiCuSepJxn t+GKpRbAp38ktrHLcRsxiB2hUXeFzgdBUq28eyJ5XBk2jBbhicA5x71ahbcCpdS3ctvJYxK7Xc8q pFOoBEaZ+YY+nAIqe0h+zrcwOrpbww5a4cZErYJwPyH51Y7u1j//1f50bXUrPUbeWBYSklo5ik8x MBG68Hv1HIpiLGlvJJ9lSWeE74Wc/gTX+oB/KKk1oie2j8q3e8mb558eXEg5cms29uQs9st0hQSE Kuex7VfIwUmjRS9EbBJMmMD+Hk4rDuA9/My7mhTdlCOuO1aKKSsapprQ1UmtbKPY8gVuFww+Zqik tYrq4jkS4FoyQs+5mwjcZBI/DFS4IUnZH//W/m/v7iF444d/mzquZJFTCtisyxuna1AbdEfMKsu3 awweOPyr/UflSVj+U3PTQu/boI7d1JAmhJcux+8OOCPwNU7KZZ28whXDDcpHK8+lZuD6ENt7l9pk s3tWUmVTcDzomGVIPbPbH9Kc1zDJdpCIxsnyCS+SmPQVAjEm06dtVEEUsYshAWd3c7wwbGMdMYq+ NKsdPSS6i3zSiM741+9IBzgfX60GkJW0Z//X/mlklt9OjF0sUyQuQywsN0kIPbHtWhBqqXkUJiZk Zm+ZwSrFfcV/qAfyuaNlCY7mXzHDQ3A+f1Ppmo47SO1lfYNqoeT6igPIz9QnR9yQyfLINjHup74q tBZLDsMHmMrgKxznOO5oE2krkwsIBcrKHCPCpyABl8jufb+tU5dTtpBIieZHPbym3lEqbVYjoVPc c9a0jDqzFtvc/9D+aGOYrJHtAZj0wuc1eaCSVWCoFCMGbPHU8n+df6jckT+TVJN2IoNWiS4mtjat OkC7HuJt0Y3EZUqe+3HPXqKy5Lu8uNQklMrfZHIEUez/AFeBg8+h96OVDbsrjrq8WW4jtYsll+WV mPc+n6VJOjCIwx7ndRnKnHT/AD0qXDXQE7oLVD5SNExYv1JHII4Ix9c1LG9mdzSyO7pL5Lx7GyDx /iKTg+gz/9H+Zd4oraeMhyyNNhUfhmBNdNeCwjtXaxBbAG/z0HmHjnb6f/Wr/UPkZ/Jyaexz9leB 3aJoySH4KoTir7BIJhPJOMlgqIx+UexocGik2ti8C9nexXK3qBp0wbGPhgAfvEEfyrW1G/jJtkU+ dPKu8BCcKfRqgbm2V/OhM5jAXeEwRnv6VZj1Gb7Mts2xEPAYqdqepxUShfVGkXdH/9L+cwzO0aqC JUY4Eg4zUht5fJ3SJv8A7relf6cWtofyuUrrCPDNbSzRRAgSAckeppNQuoY0+0W0dxcLGQVKxkux /wB0ZqeSIGhb37zo0dypt0MZbfgqFwOMd80WupWv2eQpDcTXCgwK9yp3H/bBzyPSsbGjhZHOtawT XhMk0kcsjDemMr16461tz6fBBAVfjb9+Qclx64o5bwlYErTR/9P+SbxcY7bUbi08t5I5JTgsvMik 8bvfH8q5CQgFEAMUWNoXGcduK+k43VuKMd/19qf+lyODKV/wl4f/AAR/JFlF8vqpMZxgd/rU8geJ QEBCEZVsV8jKNz0p26EEE8cpO59/O0546VrgRyW7GEfOjhV2Dg8ck/pXJNWYQSvqNtbeS13z3Myi WRjsTquCePxqyXSQDEWZN20D198VBqf/1P5JprRgioow79SBnFJHZ+eTa7445Ei8z94dm8DsPc14 Dbe5c1Zlm2ia1/dmTA3cEHK5qe9KzqYuGlKZJHzYNIlaMzbC2+ZzLmWST5F5wIAPT3NdHbRfufLV iT90bjyRQblx7aWygSaRdkMr+Uj4zuYAZGfyqqUuApKpvVuSNwHFZyi27ozmla5//9X+U2WGWGE/ Z3YHAbMYyOeCD+dWA8ZdEeIEqBuIckZ9a+XAmeMBXZG8sEcEcH8KgiYuWJG5hxuY5yBWU1qaShpo WBLJABLB5c1wrAPakhQV45/nT5ruCKSM3MiWqTyBcDnBPaoMx8X2cy5YggkcE4PtV65CtGUGAD2x 2qlFsD//1v5bnjtoolYSFNgCqiHLP2q4k6RmHbEzngEenbNfKxVlqBVvLGPWpraRXaA2VySXQ7Hb jDA+oPQ5q7LZCICdWWNV4PHGB1qgCG7S7VvKUhoyRh12n61Jl0fMkmQeMdAKANm1sLu8ieSO2nuo UH7wxRl1jHvisJ5Iba7eNFlZzxkpgD2+grGfxDu7WP/X/mGs1D3MbXF1PbmLLjy13LKQOFb2Natx I8j+cru0uQAuMqfqetfHgOku8ReYQy8EEkYwR1rFAadvOwcbs5PGaDaCsjU/tGK2gIfqvHHLelUp rq9XAhf5GcN5jjgDOSPy4our2KsakU48zdI+9XUE7uNp71X1O6tbaNnb5V28yKN3l54BxQnbYLW3 P//Q/m00i3ElluRVZ4Bvklb70g6ZNSSbQS0SqXl+XDHCL7mvkXJvQ6CnCXTcsrB23Zyowo9hVy1B uZ2hb5cL9522D8zxWM30Ao+eq3QRYiwifaX+8BitH7dBcYR1ZfKJ2qV+ViO9ZidramPPcyCeUeWT G4wCvaoBNJFEcL3wExnP0oMD/9H+amxs5WAuNrxn7zrjapzQLJZZhcT7oyH+TDcpz3/KvhmtLIC2 93FHKgk3uIXBTZlj14ziry3SfaWMqtHCcOJY1DMT16f/AF6Zu2upBJetdSvbiPYw+aMY5cZxmrP2 O4S3DIfmDcKTjJ9KB77GRbBGvMas/kWkT79yDzJFYfdwPr796liu1llk3gKkTcMeC47H2pPYa3P/ 0v5vrW4glkDb9w/hIOVNblt5k4nkMCLbxkJ5qyZPTqR2r8/O9Wa0KbPJBcCS2faYs4K9weKeh+1K W27nQ7mHcUDENwI8RvG2/PYdKheJHOQM5H5Gsp72AbJfmyt0RgN8knlBSOfb/PtVq2uwsbWyW7SS XLBjM+cx46hfrUDvbQ//0/52V82I4ThfuvnrUUcFjbLMFSQXO/zck/I2eo+tfm/kegaNjqVubeay KypqGwSw7BuBXIBye1NdhJkzxDz05WTIyRQA2O9h4SUMgjPJ7enWozKl1fxmGBnUAxiJlO05GN2f X6VrTejRE1aNiNfNsHaN3JVz86mrkcdldp5gciSJuABtK+oP1qm7GR//1P5+HvbWJbODZFiZzGxZ NoXjuR+HWqHzpcSQwxRrCSSXVhnOevofzr86lK+iOghmYo64IDgYXIwGq9JcRRwJI8fmSbh8o6nn ms6ktDRyTjYtW8SzTSmaFo1wMBhgc88d6rjxBb2OrW+mNYfbkEWczfcIORjPXPHHvisXuynK9KxZ 1Z7e8jkls7NIBEmDAXzux3ye9ctcSeQ9rHuTypsea27aYznAUiuhOzJcbyZ//9X+eO6uEbNsFnBj QHzI4i6e4J7Gls/lyuGuQRtt9x2tHznp+fHvX52pNtHaoLqEsF7BJOkmja3bXR2yW9+LM/YWQnGd /PPTFWEW4dRFfyO7oMrM/v1rQfJEnDx2uIo5Cssq4EqjJAqLfb3Uc2kzTXbMB5hmEZ6nnBPAoGop bE9ppQjtywnkkjc749/Qj2qExRr5vzDzMBQFOMfhQS4Lof/W/n8srlrZhsJbC4Y5wenNZ11Dc3E7 3NxBu0lJUSfy5182UMTlSvUdD2P9K/PrI6LW0Lsl1aSXAjtN8USHCQsMEL2B/wDrUigW863EJLqw MboB8uPX61Moq10A+SeGbzMruRTtYHkAg9Kqiaa7ml3MhiAWMKo2gBQBziot7twEuZ4TGYmijeFS AAO5/wA4qyI2UoIUEUZTEmOWXjHBFSaQfQ//1/57XWN8SQ5lKZ2471ky3Fw20TwGJnOFJ5xX5m5t OyPQLUMCmSJ5iWGQi5Hy5rpIJILMsrKzPJ86N5ZZCQBwT0HSpTk2gEllimjYzARyZK5HygjtiqNj FpsEri/mMiEMUJXcvQ7QcfhWrV9AKeiX1xpJkuBCjwXW+KeNl8yEr0Bf06A1o2e2/tbm43LI8UgV BHyNp7+2KSjZWYH/0P58ra7nspXEWE4KjnGPwq5AiQQCS5l82Qj5pGwpJPoAPevzc9AwLi4xM6E/ uy2QccCrdyj7beSNk8pB+9Rxg+x/Sk9mOX8KSKzBFS1WGURRrOJCkQCrjqR+PNXZL6zkuG8tSrld rSNjzCBnGTVv4Ysxwcfc1BooZo5T5pE239zk/Kcc81V0/wA2OOa0mif7RIf9fu2r9cVK8ztaT3P/ 0f55YUuEvzZxyuzywtK2CSCqdaseTAQJm/1hPlMQMV+ZVlV5+em/L+v1PVk0/d7GDqCT2TwyWd19 mhjbM8arlp1OQV9h3Nb9zFGkEBXMk5jEmwN8rZGR/OtRT7EcVnbTrGl2ZbbnJ8jDMfXGarWlyTO1 m/nObdzGjyLhpAOh/L+VBmXgFM+VtnkBfZO3Tywe/vWjdTadbWbRRW7C4aVfJlHC4wwYMvv8tNO1 zSm0m7n/0v52r7zLqe2AhhjS2jKMVG1sEljn37fQU/T/ACI5C6HaS2OPavz6nKChaT1PTjze257a GyzzXjoJmBSEYRSc7R14q/BKtsN7t8rHaFNYyqRsqb2R1XgrtbkOp6w1tLEbYQQysBGJGXzS2709 D7iqafaokkkZWS3dg0sgGck9R+Wahyik4oSm+dSGRzWztHc2ikQSDE+5SrTbeDz7GmPb26BJoy5w xcx55frwa5uWSer0OhVZKTZ//9P+et4LRpJ9Sjj8qIRhRDF8+8jjnPU1pWF1PKriBT5MyAyEL852 5wP1/SvzGMUk7H0HPespszrV9LuyiS2zfaZJJC6OvlzQnpux9c/nU1rp02nh4po5nfLSq7psO3OR x7D+VZU4pz12Y4+zeITt3JY4kvWZQqKycjcdrsc+lUprdgXh2mPYSADwrEd60jCMb28ztq04cqlE rQ3EMUElrcXLi4mlEduqqMN6ruz6A+tWoLdLW3Hl7pZ5ZTGsMIMkueP4R/niqw1aN3dGEI0uaMp7 H//U/nn0y8uI1EU8812CDtlZBuJyTt4HGOabCbJLu6nuZ5F3JmKDAKkjAGK/Ofby0jJaH0MpUk5K RtwXUa232638y2bcba4SVfLLrg9PXPPNRXc+lQWkUrEyXUs+VXB/dLjH657elZVGr6HK0mrLYwnl 2y3T20ZZMeYPVvXA/wA9aRby1vtlhO8okkgZ4HRfkjYYwHPQAk/zpx21Igt2LFIYo5rHieVIcPNG TtjIxlv5iqTNNFkyyMkMaZaTG7b703BTXIzSEnSqe0if/9X+cyLVreeOPyXnnuIZCkt2yALIMDAz gZI9q1LWL+1CxZWX7Phz8uM56dulfnlNKM3JdrHv+2cocjRpm1tYZEBMgBjbzIYgGZz2/wD1Vn6J baPeaU8+ox3sF0L11hSZdqSonT5evfucYpyhFzT6BKq3NRS0GXGqSzCSyFxOsEB3wRZIhJxjIHSu bj1L+z3NuUVjcOfnc7gWY9BmubFVfY6S+GS09diXJ8rdtTUluI3W3i+yJGVG+Y5O6Q5J3Y7dRUkG o+XcyJHCrxeSdyux2scHt7da2pzh7KF0Z0nei3Lr/wAMf//W/nAlkmnjRbZkLCT5w4xge1E0MMlx aSrJcQSL8rKHwrsDySMdOP1r88lU5tEtD2qUUqnP1HanrKqyaetjPKioZpbyMbogRxsI9fwq5byo yxwghUaLcA7bNjemSfbNZSac7o6pTUpXSKWn3aXt41vHFJKUypm25jUjjbn19q3I4ZI5DJEwVkbL gruBA9qjkXRlwqWSppaFy51CJo2Y26TiRcgv+7YH2PUD2qjoGrW1i8y6nZrdxyxuqoDtVWP3fcjt TaVmDlebP//X/nOiuZ7y6u3W1e2ht5NkXdTxnA+mcVFDeXck8hlV0YJgIp3R9+hxX5lGmoq63Z9P GtKKaREZrjE0sYl80jyVZckIDx09Kjgj0+2RNM1GOaJrxHDyINsrblJDfy6dqTopzUpFNty5mSWc QighgieRzCmwu7b3YDgZ/DFTTCWECRTIFC5JxkD6il7FcrimW7zsuxOltNeaeNQjmj+R/LlhB3Sy +6j0BHNVopbKC+tIrmLzppW4JTKxLg5LVdOHJHlL2Vkf/9D+dK08lZXhkKxuJWYvHFkbcnH6VHqw sla1eGIySQsZGn6fQY9Pavz2dnCx9i0ueNzDW7kZ3P2Z/KYkkuhUH8K0Ib2GQF3j2tHiNmAxwKyi 3FJJlNxT0RdmvoZYx5Mf+rXZGpGGwD/n86rxXc8+YzBJbkIWeIHfsUdyffr+NZqgo1OdbmjxM2nC y+4y55JyyXVmFurQFo7mRDhrVlyOR3yRj6/pAul3Mdml2qlhLumjgB+ZCWJJYe+TXYjlcVuf/9H+ cO0tVt3Wb5k3Jgq2QCPp0qCa4tVuQjklmyQm046HNfm86N5c63PqLJa21KOpajbafBbJLDMsU0jI bw4MMPQgN6d6cyQR23nbWuBFH56lAHZ8DIK+p9hVSjO176kKfL7yIrHUIrsWxKGIzuRCJVKSyEZ+ UKec8dParcVyLvU55ZLGNp0t1iguNgjKYONowPQZ+prnjTak2aSndczNWaS7FtcWcEjm7lQiCDJ8 uRyPlzjtnFN0yVYLWdL8Nb6xIFicg5thgY6devf862pc8J8yepMqspwtJ7H/0v5zBPHZ211GZhJC MzOygYDAclfc4x71Pp/iDbaWLoXjiWcHyXixIoYgbm/T8q/P6UU8Smz6aCS1j1Pq3wNcHVEhjjWP 7VBFsgkACfJyzMw9Rzn2Ar9hP+Cc1hp0/wAYtMvzD5yWDpcyTQ7ZjK0CkrnPQB+w96/qaE1T8JE1 vovk2z80ynml4gz10V/0P6xPG8rT/DLVri4lV3Php7y/ncBY12R71QHscqBjvmv4bf2s/tI+N+ra 9dXE89rcw3VmdOcKIrcRXBCFMdC2Wfn161r9HeUY5hialtUjk8Z6TrYWFPzZ+VXxpe10yFp9Qs/N 85t2nCZdpkH3XO/GBwOfp7V+bXihdNurm8vIIjayxSNEI1BEbg9Sv145rTx3q3zely9I/qcnhbhu XJ5Qn3/Q/9P+HVZUjf7iSR7sOrDcprt1vbbUFa4kxFKqKsNvGm2MquFwPwFedWqNwU+ppUw8PrEq TWhNGwB3gcAdP4gPYV0MM0OrWEb6ZI0NsQ0YKoQQy8H8QQfxNeJWnLe+pccJQa9m46GfZ3ZtLnde ea6GTyVaNTJLx/G3HHII/KvrT4EltevdZk0O6t7DS7GCH7RZ3d2YptQvM7cLnCsQMtx0zjvXl42c 50+WRrhsPRw91SVr/wBdT32W91zSL21vIYEZWkMBWa3FxESflPBBHGeT2z1qzLBqWkXbR3UeI7v/ AEiCSND9nYEAnBIxj0x6V4tKD5j2JtcqZ//U/jxt7JbLTYLM2im6ECu13E25Lndjarr2K85ron0K 3uLNLv8AdWdrY+WxeKUNtcHIDA8gNtPoK8KtqrGM5f7PFI715oJtBW+do4795zLE4X/R7lR8pyR0 IIP51m3yan9uXXLmaY2H9nG3j8nEUYmC/IxOMFQAue/Wsqa0SNIfCWLKTUNT0q487ZNFPgTNjbbK enX65ryzV7O5hncQXN3cQcxN5zFyPUA9x2/CuqKvKw27IxLiymCRWh8qOBjvNz5rCZTx8gToQepP tXF3MX2O8ihAUt5uxHj6RjPJFejSWmom3oj/1f47/BumSLrGh6hp1z9g1HT9S+0W15H+7Z8rtdHb P3SpP5V+lvh6KzvPMe8mtobQ2sMkitJ5lm9x5SiY7zxy2T6c1/SfgPNtYmkfj3iOv9qoy7I/qy/4 IUssXw7vNBa7Zfsl9BGqwODBdrFO8rOp78TKN3Xmv1s/4KAx3V18C9VvYIlVri2NncvgqJ4DKgIP HBUOx/GvzHjiPsfE6z2dRH6hnVp+E6a6Un+B/Bj8ZkttN8Wa4PDk3+jnVpWSNLUxRoCxEkKAj+Hp nuea8ysxp1zE0hkaJIhkxSr+89gRX9x5Y28FRb/kj+SP5JhD3YpbWIra3tTBcahpF5FKZXMaQfdg LL2DYz1qAwSOJG1uOGC+kRkitopfvBRgN6nsa9F26GcoNs//1vwH02COJhAzXFtbmJjPKkRdiByB +JA/yKuaDoT3SLKs2JPtRUxGUtKqk8bTz+Ff6b6XP475WrH2F8Av2Hf2g/2jpRcfCrwVrGoW0WoS C18Tarpt1Dptw8So7RqQpDYDgcAjj16fZZ/4Isftv6l9nQ+EYrW4+0FvtD6bcfZumNobYTjOe2el fkuf+JuV5Dmk8sqq7g9XzJfLXqj9Mw3hvmOYYClmSlyqouZK19Oj9Hv9xPP/AMENf21mmnkn8GzP cbRAswtrlbL5v+Wo+TtjsPwrok/4Ihftm29tZiz8HMRBaMlzPLptzaI8ijcXKyIhYdACCc14s/Gf JoySjC+v8y/rf7i4+GGPTtKovkvvPzS/aE/Zs+J3wF8TweH/AIp6a+mXk0Un7qKCbdbPCwVgSVA2 sDn25+teKNoEVxDNaW+2GMWwkjkABjdhz/T9a/UsqzWlm+Ajj8N8Eu++9tbN/mfF4vLZZdi5YSr8 UX02P//X/BkRT20am6dXe2GCIzuPy9P5VTnWy1iD7Ss6hrFuIZ0aOX5sZK59Mc1/phFn8ncq2O+0 vV7ezsWtoTas0kIea6nRWkSUD5HQYwCMmvMNQ0y6e/g1Bma9uraQyRswBRnwcO69CT/OrU31JcF0 Jku/ECeTDepCxkQ3UjRIFkUscAcdeh/Ktuz33Vte281iYZSUWS6YfOVHzfIw7EkZ+n1p87vYHTsh sWl2EdzHe2iql7bxjzCy4UgnjKn0purwW0qo93Nv8hhNDs4w3Gen8qqE2Zumkz//0Pwmku5ruO1F uyw20KLLFHGu0bguMsO5PvWTeabDrKW7XV60Zsr0XDhFHlzqpzsYdOw/Kv8ATN1WnZn8nqjzI1Wn toW8iylM8WQqsiFVU45GD6dPwq3dQsxR4Xjcl13K/G4cbsfgDRzszlFJXRLNIksRjhZEZDwm7OT0 5/Kqek+GbqEXN9fRzrHI3z7siF8cLgmrlLl1JjDmKtrY6leaxJGZRHpAhIS2OC5kU8N+WfzNQanZ rdb9NaeS3CXKvFNJwMoeY/xxgZ9apvS4ODvbof/R/DfTNOns4+JXk3ZADsWROMHHp9KvjTodTlQy FEaGIR7FXashXoW9+2a/00U7q5/JTg1KyM3VbO0lKRLC0LxOFEnTPA3c+mfWs7+ybkzQyQypIFlC hpvlFuB1ZT+tOM7vlIcNG0W7XRnGqTX06ExAeVBPFPlZh/edfrXWxxG1ilW2Zle5jKSbBy4PXPtw KpO7sSopPQ5rS31TT5tQZb0JtQJHbOodLthyCwPHQnqPWqmntfbrrUdRlhmSYEGBow4ix3zSvaVh uNz/0vw703S722uJZLkRxi8jE8Eyd0JyqYyegx+dXdaF3FDby+T5zTTqnyqEQgdScfh+df6bKV3Y /kRw5Y67lW5kMH2aKS1cNNE0wfqgUEKcH69vanXV8be3gitoiBKwMrhA0gGD0P8AkVMviRUdkMsA Z5WmfdC0q7UWQbWkx3wfpSyWjXt+ktveGWKNfLIYBFVxww75AORWSlrZHQqadPmNzT7i3sxrWkJp 0L61dxwzW0kxFvAV+cGTf65AAHf9K5qD5HvI9TLNJG4ErxNhN4HUAjpwK1e1mRBH/9P8O9Jt11G5 msrDbPNcHdGEUFhsXB/DjJq03h7VpLS6jRmhlWIkNbyDcrA46EZPftX+msdND+S5plexE6XiQ3tt byG1hCLbXFuG3dTuPqOT/jVfU9IkvHlk88WyB9+2NRHDgfwDFWXTV4mLFNe2EF2LZJUeNcBzGSHX /ZGOfpXQabqGntp6yXUKi6VDKUePaxI9j/nmgpqyueo/CmCbxh4w8I6BO9lb6Vc64ljfSzxAqTOC sasc9yAM9uK/sb/Z9/4IH/s5+Jvh54e8VfEXXb/WNQ8QWMeqNFo0iLYpvUZTjjggjHUY5I6D8U8X eLcdwvSwywLalUvqvLp/Xc/XvD7h7AZpl+IxOMabg0lHqrrd+T6eaP/U/o3t/wDggv8AsfWEoksG 1y3DErNiJPMdCMFN248fhVuf/gg/+x1JFbRr/wAJITAf3jSzq/mjkhcZwBk9hX6vPxUz6cnN1JX/ AMT8/wDN/ezwnw1lUWoRhG19fdX9dF9x5/46/wCDfj9lHU/D+pQ+DLrWNK16SEyWUt86yWjSgZ2u V5CsRg4AwDX8nH7VP7GPiz9m74x+KPBGo6HeRQ6XJI0LWx3WCLHIQWyfvLx8rDGQTkccfqHhf4j1 c0zB5Vms7yl8Lbv26/hbzPheOOHqeHVPE4KCUOtlb+v+AfFOo6Q1rJezXFwYt0pwdny8nkc/WsOW 3uLNwbMxTPcgQhW4AViMsfp7V/QWHmpRdu5+XKHYXUbSdJIRZhV8lh5ku3lvUEen+NRXWlNrBhiu riZVjdZxHAwXz9pzsb24zTk0pcxxODU53P/V/D9JNKhluG024mKTEKfMIZEK5BC4989ac6QsQ9lB M06ri4ZPmV1Pf/62e9f6Xxm2rH8lpe62tie3toWITYyuo3R4XAU+/pU1ppkV79qW5uGtz5TrCisu JHHQMSeB16c1V2awaSV0c3/Zdx9k+wWbvCjTku8TbvKBJycnORWyml22ixwPDObm7jiPnDYFRSeh GOpxn6ZpVZckUbQs4tmxodvp8MgvtoN5ekwzvKuEgTp1PHOetf0Y/wDBJX/glV8Kv2tvBms/Ev4n a1Fe+RcNZLpVvJFcrZwiZlULGMn59pOXIxt/P4jj7iCrw7w+8bR+OUlBPs5J6/h/w59twXk9LOM5 WFr/AARi5td0mlb53P/W/pOv/wDghH+xXfW0UH9mazbyRABprby7fzMDjKrgfzr8Zv8Agpl/wR08 Ffsz+BdW+MHgLxB4in8OwGOB7e2niWbT41Zd6OjIcq/yqSnTeDxX9DcFeJGe5lnscux9TmhVutkr NK91pfVJq3n6H5rx5wzluX5ZUxGDhaUXHXum0tfv/A/moN1b6hb2tyqOCrEoGbggMQQR9Qaxbj7P LJPJDbfZmGI3YptEhHfnr1r+p8K7wR+JNWskYjQ6lDdn7OpeAgbucdR2zU9xb6hJdwSwKXe1txNd wtIDHwc42+47e1a9UOy5bjL6ygv9Qe5muILGWcg2mnRoVlQdSRxjGc966d9Pma3tGUQqVz5wf5Mg D+Efl+tVVdoNnVTjpqf/1/xUVYdRmtrM2xk1DzQljH5Rk82Q8KBgV/QR/wAEw/8AglFD+1RaXvib 4gPL4f0fR0MktvcI63MjSsgVo3C8gfOFUHHBye4/uvxB4zjwll0Z0lfEVG1BO9tN5O3RXWl022ui Z+B8LcOSz3FT9q7UYK8n112S9bPWztb0P2vtf+Df39luzZJrbxN4qtrhn8y6aBYgk57AdwOT3J5q rrX/AAb+/s0X+nT2ll4n8QWkzMZIGEYgCMR1MiNvGTyQDg+lfh+A8Ws8wmJ58RL2ivqpWSeutrWs 7aJ62vsz7+rwTltfDuMFyvo16ab+fp6o/my/4KNf8E6vEf7FPjWztEtdT1PwlqKy3Wn6zb772z8j escagBcL829sM27BPHFfljeaZJBPLFFdTzlwP3BO6KLcMjaMdxiv6HyvOaOb4TDY/Du8akb2unba 6duqd010aaPyjMMFPBYiphau8ZW/PX0a2OWvoljtzZs5cu5ZUY9Dx0/KptOspLx0g+ys0wVVkIQh OnXPevf5nfc86SXIj//Q/FJ/s0W21uWVo1bYdgy/XotYkkN6bqaL7N9mtEcNayM+97hDz07Y6V/p Op8sbn8rWRcju/sTbjDHP5jLGImbyguSBkn/AA69KkeS3M/ksYoXYbioIWt7vlv1C0TPuLB4p/Oe QOvUmP5gB2zWh/oUkcjKmQIMqdo+ZwOBj61Dkx20K2ZruOMLE4lKgKgHzE+lX9D0jUvtjX07yKhI hFshKlf4cn86wlUdlE0jC1Q//9H50/YX/Yb8dftW/FCz8OaDBaDSrm3ke81Se+a3+zhJNp8sBWHm YEh56BDmv6CdJ/4N0fCSW9s2pfEuT7Wy7bvMsjyDuSHWPGfoK/qPjvxKzLAcQPKckq8sKWkmlGV5 7tXd9I7W0alzJ30PzDh3hDCVcpjmGZ07yqaxTurR6dvi366WsfMv7T//AAb1634J8L6348+GfiSP xhc6dpDi90i3tWudbu9iny3RnAJ2lUHyjIA644r+Y/xr4Qv/AA1dXWga5a3NnrljLJay2j27RyzN CQjl12gIckgoehB4r7nhLiv/AFly36zUsqsJKMkvlZpXvZp/emuh8Rxbk8ckxToU78klzRf5rbdf lbucPLY3MVqJ1k2xqoQxAfOM55qbRbWN7yJEkaT7Y6pOXYBY1B5YA9Mcn8K/R69Tlj8j5vCL2kYn 7o/sEf8ABIXxZ+2T4Qf4iQX2m+H/AAfq8xgbUPNktr69SMBFmlYqyhgMKqqpPyenNfUfx9/4N4vG 3w78Kax4m8B+K5fEq2Wnqpgs2F1fW2DmSRkKKWHTlVyB+n4X/wARWnV4heQ+yXsnL2aknd3b5VLt Z6adO7P0bH8DRwuSrNFUftLc7TVlbe1t7rX/ACR//9L8bPGHgqbwNrOreCNYaW28T6FO9tfrOrAs wYhZBn+Fhg8gEE4IriodLje3eVDHJPD8jbW/1h55r/SOk0sNTfkj+UcJH2uFj6v8yun2qxtfIlSC bOXV+cpyTg1m300Nve2D7AQ6l9wTJhJGCM+tdEZPYJU1zWNR7SC7hiuirK4uRIdx+RgvqP8AGpLi P7LIjPAJgMO6KA2B9Kv2rsX7NC67HZCO3vNNhWKVwFbcuCxA5H1yK5WcNq0sBvhc27CQRoRut+n8 P0PP51ftGL2auf/T/DpY7Xy3RF/dMPLaNuR6Hr+NaKpYfZIkgcCRW2tgcfT2r/TKE3LY/lKUFa5k ahdW9vuaVlFvFgO4G7Han6vp6x2Qn86O8ikiEyRxgiRFPb69eKl1GpW6mcYpbGRDFFE1s1nIXlZC WgAOyIEfxe/Xj2qrJZX1tAzpMisWIKxsS2339M+lXGpJIErG1p0kc1obe7jZzD86sjeXID2z6jrx WVK/lTrJghQ/I/vVpexpGN0f/9T8HYBFcXBaXckbkkxu2Qo9vQdKsTJZyyxW8ZDKfmRcfIMd6/03 T1sj+Voq0UFxYTGUuQW8xSfOBG3I7Y/+tVaBJXBSYSQkj94CcFal1FccopxROtysBg0/cLmHfmSS XhQDn9egqO9s45ZJ3t5JLf8Ad4SJDtiJ+g6ZpSfuXNqULtEmn6duSNJmfzH44HysfavdPhX+zn8V /jlq0+g/Dnwpeavc2VobwyRwSzxuFPIXy1bnHOGx1rycfmWFyvCVMdjJWpxV3/kvN7HbhsvxOYYm GDwsbzl93q/JH//V/Jj4xfs7fFL4QrDD8S/B2saD9onjtYY2tpdjszbQeVB6kd+Pzrw69soUiiFt EYhbodwD5DY7kduK/wBHcBmeEzbCQx2ClenLbv6M/lrE4eeGxU8LV+OLs7d0ZMD2MsCSxIzyeYd7 B90b+mB2qcyXDNEkMapCHBkyvyEex9a9N6K7OazU7HtHw7+G+t/FPVrXwt4E0jVNe8XXo2W2k6Vp zX77RgFpCDhByOW45r6H8af8E9P2qPCOkX2ran8LPEsui2Fol3PeRafKZLYFN0jFCgLY54UHp1Nf MY/jHJsnxsMtxtS1SXbWybteWvroruy22v8AQUsgzLFYGeY4eP7qP46XdtH+NkfDms6QLe0uftNn e2l7YHbNa3UDW13Gw/gZCMgnHANUptOSa2E7oyNsBSN+sQwOBxmvqadaNSMZwd4vW62fax89BXk7 n//W/nwkFlGrRNuE0gKSeij6/nV3+zrQwLKGGGTZIAMHHSv9NuZWufyuoJsSe0t/Lto4LeaZMiJ/ KVQsI7Mckccc49auTW8el20CSxiFLhwqyKuQSem4j+tXF2dyuTS5Gl1LYXKSrcLJE5VIwiklT3zV u/gl1t4IheyQxrcCSSRFyXPowPJHOaQvZaCN4djtJJRJdeZtyuBwr+4/z3rNwLTdL5m5UbCx+lbK Sehm6dtD/9f8BUvluY7g3M8iq0exE+8SccYrnLGS3tJCk4lRbqTZuSMncTwBj36Z9K/09k1y2P5P tY09QJ3xcgsI9qANu2rzgGqk1lax2auRuMxJcAcqfWrStoJ36GZZ3fmJd2zKECttjIOS3UE/oK63 QdO0e9tJPPluf7TdjbwWpKiJsEHzCT9cAD86uMb6sxe+pUvLWKzuVZJUikgXCuz4h54zn1GP1rOe YQSeVKyyK3O0jhx7Vagkawd0f//Q/nac2tuzKkPMx3YA6U+K7gt45SEjZ5BtHmLvZRnkL6Zr/UdR Sd0fyeQ+XNfJBqBmEVo8f7q0wEktyDg7l6g8d6z7v/SGEi4kEPGRyP8APFMmMr6MimijSDDO+WXd 5oONlN0x0lQyQOk5STaVPDcdadmjSMuU2DoMWpTmSeBmdlAADFdoHQ4B9q5TWLU2V15SPJIFb5OO 3pSHJ30R/9H+a+zaKWbypSEm2ZCn5Swq/Dpdw95AIyqIZB/rQPLbnpzx371/qUotq5/J5f1bTNK0 x/OmUYlLCcREMHO3H9Onsaw7WCztX8yKQ/ZWA8qFcBEGOAPapAkmRLtJPs4fKHIyOv0qSHTZYIhJ IQJF5WVh9wHGRmlZdjLnd9NiRbN47x5mPmxSW/lhf4cnHP4YrOuLOdzA0M03+isY5I2yEZOMEnvk /wAvek4JmkZJn//S/nCmtILuySX55XB8qRdn3D2//XS2ljaLE6QxAMnyyE8lSP8A9df6hONpWP5Q uzU0uBZGni3JI0KmVhkEgDqce1YN5ck3ThJMxFtvHeq9n5iGPYLJC65CyY3Iem2jT2e2ZknnQojA YAxt9yauy7DvpYr6lZf8TCdLWaZhI4Z5VBeNMKuQD0AwB+dUDp26ZhKwdN3XGGGO5pkSdkf/0/5q 1sWglDBxtRsIe+KsTTyZMJOxD96Tu1f6kWP5HKsU9pAotnCXEchPmMcE5qzFNaiJxCo8k5XcRjGP /wBVAHPx6fbTznyJSxdizc5Ix3+ldDBHiD9yiSNENuc5BxxQNNrYrR3m5iD5aPD8wXZ1OehAqaPb PmaZIIpTIXZYzlOpwRkenagG23c//9T+b1Ta3CsieU8q/dGAXU+o71n3MkcYkspoZJXMZ8xkbYIc jgk9fXpX+pKTex/JUb8rsQRxqEja1k2Rg4cjlzjqM+tZd5aJdX6tDK2DMF2FtzY9KOVpXLi29zfW ZGSSNVM11ANigdOO2ad5KtEs6q8Uw+cgj7re9TyrsUZwPmO+1ttw3LspIBHqK07a4md4bIwlmkYg TH7uAM8/lWco21Q07M//1f5tp7tbTML722nOFHAPtWrDJP8AZQASfNHy5/hzX+nc1qfyqpK1wNqb cCK5kXMg3AA9sVbsZFtrSaIOhjB2txk888/nUFEq2kVx+7nkCwTRMibhgRsRwxxz1xWTa6fdwzwR mdXKvtYYwjqP/rVLgmXze7bqaV1pyRzC5d0T+EqBzkVQuzBNIsdzcm3stpDziNpdvBxlRzzgDj1p WtTkvJmkVeol5n//1v5H/FFwz6nMu0hInZd2wruIPJ555/pXOxfvmUbF+VsgmvquOl/xk+O/6+1P /S5Hm5Q75Xh3/cj+SFdmlJjLg+U3UcfhVg3AWHa7H+4uBkjPAr409Ij+zq8XASID+MLjdn+dXtNS SLMZk3IoyoIxvJ6Vy1viA3Rpssjjz13bhzCwJdMjg496lsfC+qT+bLEXRon3JuPp2A61ySb+E6Yx bimf/9f+TlxPbzyW97HJbXCS/Zx5oCiZsAjb9aj8rG4yhtw+VmxjFfPlzTV5EICbnVjlc/Kx6VYa 3WFiVkXOMqcdfWnbQgrqiyuQsoVQdwUDbkj3p8M8o3Yk2up288j2pHQdGmsajqGn6fp9+losGnbv La2j2NcM5yXkPrwB9B+bYrUzzPNCkjJbw75YY3G8gEDjPuR+dBE1aJ//0P5V2gukcM2ViYYHPy/j ViPTx/rYmBjZNxLDaRjrivmHboaqFitcK6bUcs4I9OTinRgRLlgcN90d6GuhS1WpTeOK3vDdIzIz oIw3TGOakdYrh1wRKVO8t159vSp5Uuhha2hNaQN50gISQSDYglJBU+tWb77RaGOB2RzHzMyHeE9B /n0pgf/R/litYDd4lV938Q7Yx/Kr8lwlsh80EOOAB3+lfLgJBJGsW+33qzuWZcEDJqQw3bqpaVFR 3w/mHGwew/z1oE1cvPaRaaQUdZ/PUfvEOVx9aqO4WQABnyd2M5x7Um7K4zd0Lxbe6QLu1t41MGq/ 6NKJCQUUAg7BVSeF57oOjwoQcuHYLx7e9Yt3dxuNlc//0v5h5YGgYSSuoUnCr609Ll7eUiVGIdSB zjbkfKf1Br48BgsZ3kP2i4lKooxGflBB5GR7isnUdRvrO7t447WMWV0fs63CMdsLADlhjjPag3js jTggih/1jmRi25nfufWtaKPbvSVI5oZV4ds4hPbGP61NvfLh8SIgsbOqxDcFJWTI646YrRi0j7bA 8RA2SfKAoy4//VQviYVE+ZH/0/5u49OuLKRYcsGdcYx94VvDw+ZYxdAiPyUBljD4jc8evOfpXxzd lc6Um9jB1awkshHNCjMGbhV578n8Kq21/FM0tvLFLG6AfvNhUP34Pes005aisLI4ziCH7x+VsdMd aRwsaNIckhMvsUsV/AVBFS60IrVPPyCoUZxzyTUsyqABCA77toIGdlBkf//U/mzhvriLMFwRsRcR sOpz2NN8xjkMMI/3s8Y9xXw4DVgCShkYNHnqe4rRnlELRyqqyJgAxnjNNK47u1ge7QPHcJAADgFV 5xXRztbfZ7SWMuWkTNwhAVYjnjac88UNWdhxdmc41lbTmRlUyMJNxDfMFI6EVKmnwshLxoVdSjq+ ApHvUvZmx//V/m5htoAxW1CqsLcoowo9qqfZjHJcRIk0a3B3SSrkLGT3P5V8A7HUpNGnbKGDy7y/ lpsZ1yQ2PQVpRSKIFe1cFyMsCvzL7EUjYzRdT/azGyiRpDjcx2gfjV9Y5YCyTFPMU4HlsHVge+RS cU9x9Bywx3DKspRtvzAY5zWjbnY2C4Hlf6tR1B9qnkQj/9b+da6juIgZHfbGW3lz0H1pI7cXISWN y+8hcryD7ivzmUeVnoF26jOmKAqbZVUhpSMSAemapNOrRpK7EvIdqqOp9aVu4EkkjSgwQRoYyo8x nj+ft09KtIWjEBErRSRcx44JNOMrEyV0ZrQXQkDzl5Udi284wvsa0NFtluJJ5GLrbryzFCu0A4Jx SuyOR3P/1/50dXmRL/7H5cpgCiWK42FVf5jx7H2rUs9SEUixGx+0+ZhU3OUC56scdeMmvzc63B9C XULKaP7M+SxmuNoi8snYuAc5HHqPwrM1g3OkXtojRFop0VymRJnIyOnQ96iewuWybZu2kxkUXRlZ YnUHyJl2OuMjv+FUblLR7xbm4leKCMErJCgaZTg4xz6gfhUO1m/ME/daKl1f21rarcGSRovMAaZs k5JwAQKvG20u4iEzBxJKwJDD/VHGMgf41saRel2f/9D+ee1t5/KuLdJmPBPmP0kxnGRUVsDZlnx5 85BULgjaf/r1+fJJHoG3Dc6zNbyxvPcrbuFzbM5MS7eQAKsx2r6kzm6cKCuwgD7oAx0oTXNy9TZr lhsY95pd1M1t5BFubSXY3BaOVMgHP4DiuqNubW4gmEUTQyxYAA+bcAM8enWna24qexj6nNNHJDcq ha2ZzAY4+TGe7EDtyOfaqCwwSeY671boGIq+TS5m9z//0f55ZF8seRFOwlcFCY/vDI6+341qxaJN HZQv50txGjK0szjDyMOcHAxX5+dkou90Z9yiG7YodgPUtxip47y2E0VssgLsdu0dD260EqDZo6vB bWtqIoYPIkR2e4nJwGZj+XHP51kzIyXEPkx+VG9uj5U58w7VDE/U8/jUtLlaCUeUsWtpatJ5dxu8 t/mCqOh9fbmnG/SwYWkkiEks8PdWUdvr0rEqEep//9L+eoXESzwSOwjjvHKKqDPQZJx+Fa7W63Ma Rkb44zkNgBxn/wDVX5tyrqegOCxNmAR7ktiGIUbmX0q8lk97IbW3O5wN20kKRgEnk/jWdJp6lSTT 1MufTWk+ZnDRodj4YHH61WGnKkAjRAI1b+Lg+5rZprckq4lhgvLDAFnM42yhsSOO4Ppz29qLINpy SfZGVo5Ii8iFgnmkdKfI0rgf/9P+e20W3u2aSYlJfv7WbhfXmmt9nu2a3jBn+zNn5gcI3OCP6V+c qDZ6BLo9zEk93aXlnBcI7qqORukTackA9v14q5fxRyyyCJHjhGQUbqB6UpqysTe8XY59LmwicwrI wiDYlcxFvKCn5sewwaJI4QZZkzNCV3IyriRgOhA9/T3qpfBD0IwrtGT8yaOBJE+1M7wqEyd/ykAD 0PSh4pJLdJra53vIxVI1/i6YOfxrJN8zR2n/1P547UT2E1t513HJczW7RllGHiByrKc+386247G1 SNYzfxPJIpYhzs2H3zxX5ueo0+c5aW7SaW5SOMyCFxCx2/TpV21eODBmLNxtBbkJ7CgqUblhppGv o1QC4EhCqykZQ44qvPbuLuSQsIrhJMNGOGjxxz/ntQZNWdi6YbhiZUkbdENxRPuyD3FYs1802YJe WU7wcbWx6UndLQrl5dWf/9X+eHTzFdrIk4+z4JKvnc0mOn51ZS0jt2TMQKOS6MOoPOc+nfrX5nzO 6PUjK25L9ojjQusbSbWwcdQM81Vu9QjuZhborRose/eRhRg/zqLNuw4yuyhKYw0bqHlfcBnuB6/h WxdXFzPAq2rt5CxYk42liO2KbTuyr62Mu0knkYI0n7qMHKH8OlXp32om3CoM+Yzkj8qfIzWM+jP/ 1v527e8uSxhtkR4jkOm3gLjqPyruvCOoaYZd1zPttlJjlaFBKRjqAPw/SvzNRsnc9qHxGTf2dtb6 hPfWgSTzmLQ3QGN2CcKR1BHHHvWLBqF2PNkv7+4ubuQ7DGxzGBzjb3A5xUuDlCydv+HKjL3m0Uo4 5ZrhLpi8bwSkxorEB+COQP5GrV9dzT7NvCocSdiPU/pURhJOz6FU5z5WpMzUt0aaC4WQf6PIJFDD epYdDzV46ndWl5FqVvdfZZreXzAyAdeR06d6mFFQm2QpyS5T/9f+eqATWs1uFu4La2LefO9wpKcj dgDHU9M1k3sNnNeb1mVABvJDfMcn07CvzVrVI9iS5h2qzTGyie4YSQQS7oltl3zZ4wcDk9qe8v2Z St5FwsSzru++FYZH5giiSuhJWVilIDdxpPbs6KCWC/dJHIOR6VnRT7ZZFiH7yEjO8EBs1SXQE1do v6gbeaAu7SwsABi3+Vm9iRzz/Wp4JPK0+X7Wm7z4dhVmLGE56g9+Bj8aqLsxn//Q/nbsbLSY9Nt1 t7i5F205eSOWFVg2k/cQ5zke4H6VdllnssSRxD7Oqnf2LnHFfnkbansFC2W6aCTUIGKysfnO/Mke fSmJLYR6W0cxunv2nPl3G8FAG5ORjtzVlxa5tSvbyR2jP5kqThwNvy8p681YuE0qS0hl+xRs5cmO d8sUZT1Udsf1rGrCFRWmr2NZPT0KkX7/AGpLcQx3DLgIT+8YAdF9uKmmtYIEiJkRZpTsjiY4eU+g /CpStojOCTjY/9H+cJdPlF15pRVkSNoXjZiFGT1GO4IH5U55Q84hlYI+PL+0EZCgcCvzW1otH0EI K9jT+wCOTZHKJFkTDTKOGqglvaraT2t+jXDSjCzITG8JBzlce3FZxe5q4IuWsOnaasL6YkscTKGl 80fvGfozZ9/erLanZ2x82VJAZXCs6KXCjnqKcHrYcY8pXvnDzxCAq8UiB3Z12CM9MEVT1GK2ecWc NxDLJCyO0ltKdq5weSOfw9qcpNNoLe9c/9L+dZS9lNKPtEsRvYwdp/1cg6ce59faobR0iugko3Lk hgxxnIwMfzr8wu9D6eyRdXT76wE195vnWFyyxmNVGImGTwOpP+FUZzNeXfmXUjXBjHlxGRfniUDC r+HSrUm3qMit0t9OmleSeVGfKooTI+Y9D6Dn9K1SUG2OeZRHKMCVAXjyR3qLuxalZFVjNYobL/Rn ghbdHPbH5H3fNyPbOKrSYkn3pChcxgBk5ZsZ4rSCa3LlKy0P/9P+cKWecxMiRCOXkb1OSRnvVK2j nV3mnuI3ZmUC3ZdjNjrg9K/OpPRJH10papmjqSB1tpF3RsikMkZ/dtnH3h7dqoWphcywTIrCReY2 4fr94D8KglTbdjoJjZKsS24ikMUeDKmeeM4YHuOn4VzOh20v9tvfRajc26CVvtUaHzY5gRgIQeMc D8sVUbxBWcrmrc2CWP2v7Kzzx3sm8RhcIp759u9WEnbZDCYypwFfbzgew/z0rXmXcJvof//U/nTu zb27iKNWuEUBmboWA9KpA2t0I5I1wGbAyMEYODX57zK1z6gS/tRcMlniB4yefMw0RI6ZHShDagx2 3l7BCvlzBRtQHAxs45GKHNJ2JaV7dA1K10u5tntIy8VyqbleA7Z4s5AZW7HrS2DfZ5YpmjBZANyS KGzx3FZtrmuh26Fp2ghvxe3DSIkUReN4D8wYjjjNU0ezviHJdkmbJbHJHOa2i1ozGKu7H//V/nXl OhxWkUFu6M88hgeMRFY4iO2T34PSqzw2Nr5aHz5UnlQMlspd8g5GcdB1z9a+Dg/9oR9TGKUGj6q8 A6XcLpsV9bbYgJETzY3BlHQumOnIODn86/cX/gl3YaJffHdbDTxftZoVuoo3th5aSbSRFu6EM4Un k96/pvEpQ8JIf9u/mz8wybXj6bW13+h/Th8YrK5b4W6jCjrB5sCzalb3EhhQwopyCRz6nA9K/h1/ aS1aaLxzrFhqNvas7+ItQmjvjn90m9HKRHqy/vAMnsvFdv0fIr2mKkuyOHxgqyiqS7tn5ZftPTRX HhvU0tr+RY7WeGK2MCtK0jTsEkSIY4K8bj2BNflxrGsIgMKoZkjfEk7nLP25981x+N84vOoQT1Uf 1K8NudZY29rn/9b+Huxihu1IP7uRzmMD7tb9pptxp9wJLlW+zsuVEnDRn0FeRUf7pI6p6V22dVbe Q0yQzeSfPUSwbXHmsByRgV2IeC3+yqxMcKtlRGu05PU4rx6xtTacht5psV5q6yJIXibY0flwiHzT jGCO/wD9avpn4FzImk+JtB1S30qw0uHUotR0rULOP/icGWRNk6EA8rtAPPGea83EL3bj62R7kthv sH1K11O+1HRbUsttcXS8ZB+YexyMYJJ6Vpx+MH1/TLPS9SeKNrMG3tUkUJKVTIXDd+MdPSuClC0r nVe8Gj//1/47riLUvssnlXUf2gZjjKg+WqE8A57gfrV+2fVoLuy2bbeG/wBlld3UjboQgwJGxjnG c8c9K8Cb9+xyS96lE9G17QJdGsotP0nVbjxHa3DNdJNfKln9jL8FQijGw4GO/rU9rbXGl2lpE0US 2O0GNQfPjEhzuBXoM8cGlBWsjphflVy/JAz6bLBp0kZs7aX7ReWvmhDET1cr178CvJpr22tNSP8A aGoXkmlbmQRQ26u0bn7m5eoXPBPbPPSuumtSvU5Hxw13YWCapaQ/bCHWOG0hcJ5Stj58844J6+lc FLFd3sFtNZzR7mbfJLIcqFX7ylux9uv516ENyJL3kj//0P40/hzqGo3WuvYXeYLWEYi3NujdePmQ dc5znrX6SeGXl0/QNPvI1V7eS23rFMu6MsgwUIJ/P61/RHgLP/bMVDyX5n5P4lQ5FRm+7P6kf+CH 3iie9tIr2XR4tHs7mQW9paRoxe2ZhBGZSuAQGb1HGBX73/thaC+ufDTWNMWWUxiyuFkn8tnhQ4Vv ujt3J9vavhfE6Ps/Eem49ZL82fouuJ8LFFr7Fj+Cr4/zRp4w15LRTqMVpqcrXUwRIViDOzEAd2BJ z9a+c5LJLqOe8s9qOwPmRXOVhlQA7lGOhNf2tk//ACLaC/uR/JH8qR5bu5yemKmnXkI2CK235ljT lYc/3VrW1G+gd3ntYTcXTSC0haSLKxpuB3ZByCcYx9ea9NuyuZ2i76H/0fwkGoXemWpPkIYp4djb 0BJYgDHPPeuftpNXyDNYyacr3KzRz2sheSaNCGAx/Dn86/00i7zdj+QZ7RP6xP8Aggt/wUO+EPws 8OQfAn4rnVdB8RXGqTW+g6vqNqdQjeK8n3xhZFy0ahgQ3G3Dk5wDj+yazu7a/tba9s5luLW7gS5t 5k+7KjgMrD6g1/B/i1g8Tg+OsVOq/dqPmj6M/sbIav1rgjLcVRXuxoqD780ZWf5Hlfxh+OPw7+BX h4+KPiNq0+laQDgzW9m17IozjJVe2ep7dTwCay/gl+0V8Kf2hNIuta+F/iBtcsbNttw0tq1rInOM 4OeM+/8AI4/OatOsoxrW93a/mRhKjr1Z0Y6uOr8l/TPgb/gpR/wTR8H/ALZ3hufX7JtO0jxro9lJ crcSxGFb/wAuPHJQZY4ySGPJA5zgj+Cf4+fBPxZ8JfiH4l8F38dnZDwZqp0+b7FJm1vkicpujb0I UZU9z3r+mfBXjDmoT4exsvhV4X67aL0X4LufifH+UKljY4ujvN/d1f8AXqf/0vxIj8JSX9z5l1qF pZRSqXMTsRK4AJwoAOT7VT/4Rm2iLqgARAZcyuNrhRnbj1OOnfIr/SqNWDtZ6H8q/V5xd5FC6s/O Yu0BitgUeRLZRG3yEHA64zj9axVvwguZbYb1A/dl+sw9PfH9K0U4vYl05FyXUYmktLkRtbAJtd87 lzj5hn61r6vbPa2llfLNIv26YR/Im+MM33VJ9+tXFxNa1OSt6Eml6HJeJqD6jJLabEBidISwuCR9 0msB9OuZ8LeRLbPFKVjWN/MR0B+U5wOowcVpGS2MHSldH//T/DG2gk06J5xBbX4WQKsTy7Nx6/dz nH6U5NBknxtxb/aDukUAlY2brnHYV/pZNr2p/LlOk+Vo0NM8Npb/AG0Lf28sNvBJPJJg4ZlUnYoI zk4xziszS7Se8sPtF8HhfeXgWJS8mwnjcB149K0ujnlRkjpX8NaZP9luLIPHM6A3qbDH0J2Lzznu c+tMl0F7ktB5hjQAgJKxC++efrSlsKNJ6INO0ySC5VpYSVsnGAzELIMDv6HJFQxJbate63c3NpIn 2iUxaY0I2WCShlLYLZOE5Xj86015BqlK9rH/1PxFjkuNKt5rY/ZZZbqTdiWQh1KgD93+GM/WmWzy xXSbVmWVxhUcYilbuAa/0tpu8T+VJUpcxpX1u0s8bOgUkeXLbsCrIcfe/Gn2dheXaTwWUO9YTtkR wF3gAMSM+x7VMZ/vpRXZfqRKlLkbt1/yLUVhJ5KLBE7gPsbaNwH+c1LNZTwW0kinddhhFDbxkNM5 bgAKDnmtL68pz+zmmcrJ4dublCdrLeKTJIpQ73P93rxUraXe2tjc3Edt9otrNQt1EHVWXPHQ9+KF NKWo3Bo//9X8SbA6fNF+/WeGXgrIAQIwehPauo1K0vpGiW5srkWFvAJYrj7OUtJT0wJOm7/Oa/0v 51c/keUZOOhjz2K3ZkiWKfzrSAHlT8ytkjYOpHHUcUxND1OBoPJjIZx91kIkb22kelKVWN9QhCVk SpoV49/BePFMJYYjHFavGNi/7QH4H/vqpmsksbeTUpgVS0cmfcdsCNyTn1/OsVUXPY74070Wy/Zx faWFwURhJD5sbZHKEZBB9OhqlPpMd4CZY2eEuG3gYD8gcHoa6faR1MKdNn//1vxxk0h4YUm0iK5t 7m2dsyxQGK4Kkcr0Bx79Oa5/+03s72G5Y6iZIyYgwVhbIQMt5g6Z+tf6ZKaasj+UXFoo3Ot2+ry3 FxYXJlurSTyrkImSPVSSP5VYmgW502RHLpLOQyiM5LMMbf1FJSlazKpxvsZN290JIrOUT+ZCqPLL JGUZFB4GD2IFWLia11IObeMSXAAztXChQOSD6AVcG29QcbRsbWiXMluotLG5nsrkTR3EV1AxjeGS NgySKR3UgV/ZL/wQ2/4KBfGP4tSR/AH4kT2PiTS/Dtuljo+tT4j1uAIhAZ2UAMHCZwwJG08ktx+K +N2VU8dw2sXL46Mrr/t7R/ofrvhfXazCpgn8M4N/OOq/U//X/v4r8cf+Chn/AAUP+I/7JvxA8M+F vBuheHb/AE7U9O+2Xs+rWUl3OSshVwCJFA6qAB75PIr1Mqwn17E/V/JnNj8SsJOMns5W+8/R79nT 4r3Pxs+EPhL4jXljb6dda9ZCS4trRma2DgLuKZ5AySOp6Z4zgfMH/BQr9lX4W/G74FfEbWtX8M2U PjXSvDlxqWneKLCFLbWFaCFmAeTGHBCKPnByFA7DHRlWMrZPnFPE0HaUJL5q+pycXYaMsrxNBavk dvW11+J/nm+KPCD/ANparFaS3F3Da37RXK30i+ZbMvDcAfxEFsds15/f6Hql3eRRWMUaNAFLylCR jOAAAOuQK/vvIcbTxmXU8TL7ST080mfznSozdota2Fht70iewdtPmvN2y42yBZoSDxuU9M9Ko6vo N5YkWqRM97cjy4oM+WZjjJVc+2a75VqKm43OKtRnCU2z/9D8U77w/badYQx2Vg6Tg/6TB5mdrNyS D271NpmnavZW0k6RQLHOPJjt2m82Y47niv8ASWGIpXP5OjRmqdrG7otlFra3YjkRXtm8m5eM7Vib H3d3QH29qzL7w7a2TNcKbqFkl8uSSbc0c+TgY4xj3FafWKa3ZtToya2Llpo0ksga1ijZYYsFY5Mm XnLEqD9Oaw5oDFcndA3l5/fH7rbfxrPE1ounZHVClKMPmb50uFtMaaO4LOzqiQgYYJg7jkfh+Zr9 NP8AgmH+3H8Y/wBkj4oWPhXwVqaXvgzxVfo2q+GtVtRfWG3dGGKsAHjyxK/Kw/1nrgj4zjXD0cx4 XrQrJPljzrycdb/mfacGVamF4goSh9p8r9H0f4M//9H+9vwvrQ8SeGvD/iBYhCNc0S11fyQ24Qm4 gSUpnvt3Y/Cvze/4K66G+tfsYePliWN5rRlnRHYKX4YnGfp+eK+y4Mq+y4nw0/8Ap41990fP+JMP +EnEw7cr/FH+eJrOk2umRFIWMwhb7OhnXydjhmD/AHeGGckexFcVq1vLJZW9r+7dppfNkmjlGUUc gYHvX96ZfPmpX8j+aHqULvWVtNK2rbmWeFlhEgPzDovP5g021nfQY5bkxrfy6rMnnebIf3GcA+Wf QAHg11Xsy59jbkt9OvL0XMbgxMBHbTlRujcfeB9Oc1sTaHqF9sW2khbySHQSyiIcEZAJ4qK38GUj soayUWf/0r//AATY/wCCfnxL+NvxC8J+JtY8Au/gO31mOe6vZoxOtwiAbk8wjYiHBJJwQD164/um +Gfwu8F/Cbwvp/hbwToGn6Fp9naxwvHZRBTOyKFLM3U9OPQY4r9h8SeIJcQcU1KdObdCk1CC9Lcz t/elfXdrlT2SPneHcqWS8PU+eNqs4uUvO97L5RsrbXv3ufEv/BQ79uuX9izwFZeJNF0LQfEus3F3 HFcWWs3zRw2kcm4KTHG6vkkKc5PDDjvXNf8ABO3/AIKP+HP22dE1e01i08P+FPHujyKRoWn3zAal Cd3zxQyOz7htOQCQQpPHIHk4vhnHYfKI51Jfu5S76re112f9dDbL83wuIxU8uXxpL0Psj9oL9nP4 XftIeCrvwf8AErw3Z63D9nlXTbuSJftlg7rzscg/KSFypyMgEYIBr/OX/bU+G1j8Hf2lPil8M9LW /uLTQ/E93a2ZNqqJbwW5SNQ23nI6Z71+m+EOY1XHEYOb9yDTXlzXT/8ASUfB+IGEhGrRqxVpNNP5 bfmz5jg0q2ujbRSWsU00s3l25KiRmcc4A55H5ioNRs7+zuEisBKZJQ0flxYVnUDDDr26V+/KvFtW Z+cSoTVNNH//0/xufwtfR6W1/LayPcRIJJIwnmmPPb8B1Ipmnwu/mQTW6GV4x88oy0OfT0Nf6Oyq xcOVH8uKjPcH8KQM6JdmW7gV90syKIiy5yAcYxjpn2qrq+nRXV1K0NgkEkEAhQouZXA6FvU/zrqV VcuhnKnJSVy3ZaIRZKkjILg8yq3ykqc84NNm0YWVxCir5+9dyRCEziXPsBj1qPaxRp7KXKRyaROz iSSRrKKA75JFUqYlA54HP4V6n8GPC3/CY+NvD+hNHBqOlal4gh0m/uryR7KNIJHXMqLkbio9M8jF eHnWNlgctxGOp/FTpykr7XjFtX+49HLMPHFZjQwlT4ZyjF283Zn/1P7Cf2Iv2Rvg/wDAD4a+DdY8 F6Ru1vUPDkMkmqzlC6iWMbygUAZf5iWOSd3sDX0t8ZvizpPwa8HTeMdZtZLqygvIrSVUkESRCRgp ZmPpngd/UV9JSxFXF494ivJynKTbb1bbvdtvdvqPMo06NNUaStGKSSWiSXRHbeHNe0bxz4W0nxDp csN/ofibSI762dT5kU8NxHkqfwJUj1Br+VH/AILef8E6PhX8LfAF/wDtHfDKzTRbq6v47XXNIlO2 0Z5ZAJHhK4ALBsgFScqOcCv0nw0zCpguJv7Nu+SqmrdLw95N/JNfM/PfEPBQrZD9cS96Fn8pafm1 9x/KJFFFHYR5hWdPssYgvGm+aUFc5K9zWNBZxzreR/Yri4mMTIv2V9pG4FTuHpzX9VYyV6L5ex+O 5ZH4Uz+7n/g378deG9c/ZLuPCmmXLjVfDmrCPUtPmyj27AMCVB/hO4EY9a/dbX2t00PWGu2VLYaX cCdpOEVDEwbP4Gv4jpKVPi1KejVZfhI/ovO7TyCTjqvZv8j/1fgb9tjRbV/2t/jFdp512tp4yu7J vIHlWJjLl1XHXcoUL7ZNfJfkPa3s8MdqsNuTuUoud57iv9F8JW9pgaf+FH8r5RHnwfMv5n+Zb/sx b6a2RVVN7fvVbICAd/xqlrPh6S2a7kaENDC/mRtChcbemMe38q9GNrJFzi+ZsqWU8cM8MaW0sseA wEkDNanHYt0z7ZzVy/hN5JNOIGRV5kghUhgP9kdaFZlpaLQz5rSaWytE8iVVhn85EkUmZTzjcPar 0v2a2NlDf2T3UDyjzSgCmDPG7PtT5k0rEONlqf/W/E6bST9pukjlxBES0cuQVZAMjp3/AK1W0rTn kSW7jDsrZESSAqJOTzg89uK/0lwlS6km9tD+WfZtp+rJZILCWOf91tdD5TxkfJv46/Wm2tpNJMr6 gQlsUMdqsJB3so4DjsP8ampV5cUqfl/mSqdpctuhP9i09Y3MIEMgfYQiZGc+tPk0O7FsrLGNrtkN 0LY7sK64u61IdKzI7fSgttP5sflSFgpK8M/HUVz1/GwBe1QyR2+VImj8tlI6k+1XOTs7Fwg7H//X /CKxtZriNiqr582GR8/Io78enNbkGk/vlWSMIYVwzDnf7/59K/0to1VKpy+X5H8uQgnT9DYOmSIi you6JeqMDk9uMf54rmdUsmvJkRG8uzwGcDlnZehB9K15dWglD3dEIEs96WqpvEYDMzgbs1qW8ELy BZo32sdsT8YGPX24pVXal8/1OnDxvUS9fyPWvhj4BuPGnjrwx4RgNv8AatduzBbsy7xB0A+TuTuU f8Cr+8T/AIJWf8E47f8AZE8GSeIPF0Gk6p4g8UaTHPbQSj7bPpazMJjyw2jOegJ7H0A/nLxv4grY PB0snouzqe8/xX4fr5H7h4bZTh6WAxWeVled/Zx8tpN/128z/9D9/P8Agv18KPAl5+yOPGh8I6N/ buneJYLH+1oLRLW8hhZJGADKB1YLnOeg+tfwdPBfiHfLHCIYoFM8qyZWRCOCo6k9MjtX9ieC+JrV eFVGo7qMtP6+R/OHFFJ0uK8bFfC+V/NrX9DnBG9vb3BgRfsyEGN9u1fmrSs7ea+jt4EkOxDvABCL 82Mkn8B+Vfs1Sdqav0PGjDmmj+nf/g268A+FfEnxl+Lmp+JNG0m71DRLCJtN+0KJZifn5APUfJG2 OnzH1r+0G/8ADmgapYSaZqOi6XeafNEYJLK4sYpLcqRgjbjA49K/iDxQxWKXiDirydo8tvKyVvyP 6UyrDUafBmEowXxQbfzP877/AILW/C7wV8GP20/FWheDbD+xtLv797xtLtov9EVpUjdFXuAGaVgC cKGAHAAH5JXF59pmEAi2PgsnBK4HqenfpX9gcLYmVfh3B1JbuC/yP5iy2EpUHz7qUv8A0pn/0fwX udPhaTc6qrN97AxuPrVCX9yzRIpdV546V/pdTfun8utNO6LFtPqdtbzAxKi3KlEkZcPtJ6D24xV7 SrUeTenUsXMV26mKG6X/AI92UYDR+nT9a6Y7FRi2rDLzTLmxkhjS0KWV0pmD7PlkGcZDfWlgWYGO NInLCXAlH3dv0pU7NFuLSRduo0NvPIud23AkHzEmuTuoJ3htDbtEJHnxOrqW3J32+5raC6mUo3R/ /9L+f260vbcROztFtAYRdAT6mquoJEtzbedA5A+aB9pAJxzzX+oB/KMlZmbL510sjRI0UsbmLLY4 APUexqO0+3PbsZJMvExAjkX5evWrjG+rJIv7Pk8tnjZEnQEyMT8rg962YrOW0tYoxIs8pTeXHyMC a1S6IxkrSZltM8u6Odl8xThc/wAQFZep3oDwFdhNsMBs/mP0rRU+5UGloz//0/5yp5YpmtzGsq7o wXb39vas3eS2xlbzRISnY4r/AFLUHezP5PNmEh4HhVyS6kNt/hqS3iLQ/Z7ZQVJw7cBj7k1qY3ak 7GTqK7ovKaYKEfDqi7gR7+n/ANerthbxQ2i+Rt81wSxPDfWi3Q1TuiGC71aKWOG0jlaVshpgcoOx 3egqzPEQypfShn+9kAYB9SalQSFJ2Wh//9T+b94IWmypyf4HA4P41vmeGCJInO94wCSMbh0xmv8A VA/kc5a8vFu5mhMLyAk7ARlRUAURwfZniMeBujLnAHsKTigGWt2UdYlDLEn3pP71dC90LmN5yyCB UCKF43EVCh3Ar2d1tUyvjCNujyoZcjpkHgiqd1eyjRrieMeZe4YJFjy0lbJwM9h/hUyjYqMuU//V /mu06a5MLxySCJpo8kKc7Gx/StqHfbQBVEjs/wB44yDjvX+pFj+TynNdR24lnt2KTKhEvPykdwaz USeaRXRAUOGYjgflTs72A27yScxeb5UbeQqxcHDnPTP+e1Yk0dgLu4WSSbElov7pk+VWJ6/ofyrT 2aAvWstwnmpb5MLwbHyPnbHv74qAuY0JKEsxwB3+tNRSMZO7P//W/mojmlkcxyq2Mfw8EVo3Vmxt 0R1B82MMnPO01/qgfyOYzaU6FZf+WYbO5OeRUhYi3mUpvXHyxhcsfb9KVl2AZa2sbHZGPKkVR8o+ RlH07VpyRS2sUKwrvRpMSsr7ShAJHHfkY/Gon0LjC+5WUxWryyyKn7z74xkmq16vmOot1JEi8uo+ 6PelCPVmjSe5/9f+Z+3tH0m2lvYLSS4lbI80MctggkKen4VNvuLoie5UxGZRlWHYAYB/Kv8AVA/k +1ti3cyZQQoo5i2BkQKF4xVWwthbSxSBlM6vkyN0GeORRboGxC8U+n3f2gurpJMXIQ/MFJ5BH41q LqqE7pB5UHTcycEk4H6ms/Z+ZlKV9ER3ts1va/a5LKa1hYkxXLDAmB7j86itjNbeUwcyx/eVmHT2 NRKLWjBTezP/0P5t5rCXUd90W8iOPBbYcBsVoJPGI12A5XA56cd6/wBP5R6M/k66tctiSGf5Lgq7 Y+U9CPoanWF5UEMEYwG3EDqfrU8iuVGTWxacIrInDOPlOP4aur9lMsTSfIduEbHU9KyNuZWuVHWM pMhV5HDHBbJNczqccq2dw0JVZIk34bg49v0qre5Js2pv3kj/0f5H/Fl7e3WqPNdRKnmpneAAJSOO MVxiX0cLlWJR1HGATivreOv+Sox//X2p/wClyPFyZuWVYdf3I/kggcEiR5NxZuR3bmtTBDLKUDRq eUPR6+KPaK7TzTmSBWWLbyEz0FacTsUjGCTCuXZRgtjviuWt8Q0m9j7d/Yd/ZE+JH7Z3xWsPA3w1 jvLku8IvNSt2Qranfgl42ViVUMoJAzlwO1f0c6X/AMGvf7SFnaR6jB418OzXtyFkmjvLt4JrXP3g Itm1iMnjA6V8tj8zqxzD+zsNa9k27ary7bfmfWZdlNKeVrMcU2k21HXR2389/TY//9LoPEf/AAa9 ftGNZ3d7aeLPCOoXEUJdba7giubm9IXGEAjJVuBjLdhX87v7YX7I/wAU/wBj74oXPwr+I/hu8sLw xP8A2bdT2xggu1iBDMjYwRlSMZyDxzXx2Fr4udd08RFLTon+OrR6WY0sNh3FUW3d9fn5I+NI7a4C ebKu0K2QD3x04qiLm4mmRVAykmDuHHWvRdzz5K1i2YWld1iAjZMliP6CrttpszRM+x2AO15NpCA9 gTQbEkUd1DuyBsLbR2wKtQxXS3CSLgKBk8k7h9BzUybWwWvof//T/KP9gz/gmd+0L+3Pb6vqPgPw FLP4ZtpRaW3iC6ne1sGkTaXC7gAxXcN237uQMnkD6o/al/4IVftZ/s0eBtX+Inivw5b+KvC1naNc 6kvhO7a4n0yNU3sSohU4VQSxUkrj2Jr4anjZ1cbPDUY3jGybvs+p7WKwlHCZdHGV24yd3Z/y3dn+ vofhRqGmSWUDSl2WORDtWTm5i2sVZGHqpGCe+OlYSq0iqm7O3B3MNpOP8a9Kel/I82K0uPkg80fN teLdkhfvpj0rtdJ8JRSafHPb3EbSZLyROmGCnkZbpx/SpjsjJpas591W1ucS2/mRLKV3xHBUc4Oe 3QetVbya2ht2RXeS5lOQu3k+g/nTHBLc/9T+WHSWkWKWYxSQCL5XWT5GI6AhTzikbfcM8hyVAyCx +7Xy5tyxZbhmVLYyKpYqcPhcge9JcSO8TLuKmReMcFfcUGTVnYhtJLi1t4bWeZpo1yY2lwH564ps sszt+4lwq5JY8H8Kzm+htGNtiWzv7aJZEnSS5ntwGPkx7gu7oVralmhkRGjzvOH+YYK49qzG1fRn /9X+XOWK4upY3kcssbZUY4UDsKsXiTs1tJI6HeBGFDfMoHABFfHm7ithB54fIeSSWRtirIeFAGBj 2p8hGz7HMhZBL5w44Dc8n/Pek2o7lKLZehg82OR5nxs7KOQB7Vd093Vbq2kCzwFg0TMMEA8Y/wA+ tSnebKgne50/hrwpq3jDWNK8KeFrae68Qa/qcWlaXa2dqby4nmlYBVWMdfU+wNfvX8Nf+CBf7YHj XwnpOv6Xoc1klxHFdyLfJ9ku7pXQNlMoyjrypHXvXkY7MZYXEwoU4805X0vsr2v83ovQ9jBZb9co zqzdoxtrbrq/y/Q//9bl1/4N/P22BK5GhS3DiRkSO4thFFFz/f8ALGRgdq3B/wAG+H7Z97DBbXOj 22nkz7J2sbtXGxsc7NhAxyecD3r84eLxip80qNvn/wAA+koYDCzqODqaen/BPlb9qD/gkN+1J+y3 4bn1zxb4M1XxJ4etIWlOuaZbm5kt+h2SYUBRjv3xwTX5Gvp6ASs9u8H2aV4ZIZ08uSNlOGDDtXdh /a1KCr1I8vkefi6VOhWdKD5l3Mue9trSByIfMm+7HGoAZvpXNSXF4YI3RpLOa4k2TQAhjtBB56gg 0zkqRTlqa8MbSQgpEomByzAYLnAHNWrGzuYt8vlALy7b8AH6UEqKR//X/mhW6jSaVdR2AmQmFlyc DnqK0LNo9QMsilmhClEwNoGMivhzbkRG9vLCIkjdtoOCzdvc1sxLAYEhlAlm3ZV84K9sVSTVmgcY 2LQtreA4LBgy9Ouw1mNcSxyeQRK6EnDY+VR6e1J33Y1BbJE0d8UiYW8bIxOx3Ix7U1jLLGoDcA54 OM1nN20Gf//Q/nJWb7PGo8pSCRu8sZYZ71enldoTbwQxHzR88jrlwBnpxX5+dUVd2MmF1gIs4yyS NwyKh29fyq48hjTyIo1DpJ+/kHXAxkYqZP3dDdLWxcRbYqSsYkaUYDDO9DUr28cDJAXPnFPMAc5O DWabuaOHLEpi0kVjKoCyZwD6ir8ltm0mlQ4mhTzM4JyeB/n6VsZWsf/R/nQP+mWxSZncOvK7cKR7 itBI47OOKK3+RVUFXUbQtfnsviR6A+cuUc3TPM8vIJ5LZ71l21tmYOpVkgG8hm27fb/61DVyZ6RJ ZdRfc5ghG4rjAX7v0rTFl9qtbVpkaSdWDzI524HGMfrXOt2aKDL8n2SKaFpxItorBniT52OPYnmq M8st2kgtJZIot55QbUYc4BFUV7Nn/9L+di5kZ0VJFDOgEfmOAQe3H+e9S3M7w2FrGjkyW7MftCxA OC2Dt9wMd/U1+bnpOLR1Vr4st57W2t7vT40kjjWFbqJGLPt4yV5G49zxms25mF1doYVBdW+Xd1qJ rQhr3TmL2/uL/VEhldBGkgiiCgKoI4ycdea3Z7M2+9niMwhX95tGUjJ4BP44rGS2OdO9yiJCoRZ4 USFzvT5eGweuPbH6VM86C3d1I5bbluMfSuvlaVzaHwn/0/54LGWVJWjkYog+bkYz9DW1aCFp/NUK 655zX58ndXPSim3ofU/wF/Zx+MH7Snim18D/AAd8FXPijVp4/Pnu0QjTbABghWWThQxLKApYHLDA POP1Z0D/AIIEftuXkCXdx4W0q2lIUkS3Bt48EZIVDGWz6kk1jTkniXBPX/gK35HZOD+rqbWn+T/4 YXUP+CB/7aTRkN4QhtninL7rV5LzzVBwP4NvPWobz/ggn+29bRRS2/hyXUJrSbe0UkUcMLR7f4SI 8n3Uc8da6K7ceX1M8PDm5vJH5r/tPfsZ/G39l/UbK3+LfgfVtBTULySG3uUs5Hs5nUhVjDbdoLA7 tp5+U+hr5AntpIJJFtbRZyfkVHyCCDjGPWt7aXOdxfNY/9T+e/ymtJWSeN4rknfIHQjr7/hWl597 HCSpPkOOE6Lkdz+tfAPc9FpoxMySb7qeFRaxA795wc5wOPSltfsDvb/ZrVN0LmTcQSAPc+n+NJ6I RsTJPqEU32qSN5Jpi/khf3YAPy/jWN5GuWs8SyDzLd8R2gcYHX7tZ8900Jq6saj3UUcakcyhylwM fdx2qrILK7eHzIUD4LIWTczDjP4/4VmEVZI//9X+f+4tLQyQGCTiNFdVdNrL74rVignaG7mh8s+V EWbbhYyce1fm56B90/ss/wDBP39pH9pW3utX+GngLU72wWCNxqs2j3E8d0zY/dQADB4YEsxxg9+a +1dd/wCCF37cUtnJdjwYljMAJC9vYSG6LKvCudhUqQO351y4OSdWcU72Z3Yqny06cmrXv+Z+YXxu /Zq+KPwA8TTeDfid4UuPDGux5kg3Kws79ckHYW6MSOhrwd4Ps+5ZVHsD2r0jhRzl1pUt9ayyWtwY hFJtmAIJHHoayZre5iW3e4MYhiiKL5a4kOD1OPX+lAH/1v54pLKKdGT7Q8NvJDkTr8kpbHCgfXFb dhYWUEVpF9qeW5lz577QDgd8D25/Gvz5tI7mnysbqFta6bcvHZuJHL+cZwcs2fUdvpVVxNcsZ1u5 F2qd4XkMfUj8/wA6ibT0RMFoylb2yeayK6RyScKZTgOT1/rV14rS1kbz5XbPA8v5kXHUD6+tS3eM Qpw5LoH8meDahxjpng1DbCWyZVjCfId6K3Tis9pnVB6H/9f+eq+t3jKzSeX5jrvVkYNgHtxWLHLC 16WuUaWMR48oSbASOh6H/Ir83PVi7yZ0unBY1LXtrB5L5NuyudxyOC3HsKkaW2uLd4/IiUCQgMgB d/qfz4oHJ2Rydrcyrf3KmFYoIZNsTq2fNAAy3t6fhW5uiKS3smZVm+VSvIJHBzQZN3I4L9vLd0DK GJXaRgjFUSbcs02ze+7lc7c0PbUuLbTP/9D+c6a/iDrDDFvuVH7tVBVV+ta1jqcnmMLlY/sygAFf 9Yp5z+HSvzK65vI9K3ulS8vA80X2Pe1veyNHHNt/dKVBJ3N0FNWF44UM7R/vCQxUjJA68dqpW5mO CfMLc2832dmtJYwMZjlxuOfQimwS6gpFr5cqxMQftHl4Vzjnn2qm0tWaJWbY2aZbW4Q3EUu0yCND CuTIW45ArRvLmLy/sstq8rvhY9qklDnOfw560xn/0f55bGCCC6Uh3iuCMCMnapXByevXnFLMYNOM 0dlYxWqM5keVPledmOSxXoOp/Ovzc9mLs7l2zv3eOKIW6TtyzR4JduueB3rAjuIWaeUq2EkYKJF2 sOemKEraIE7F+xvDcum2FIlY+WxkOB6bv61mzKHNxarcBxDcFZJlRhHKMk7VY9cAjn2pWV7hd7Gp Y2zbSkcQkQ4CBlyxbPaoru2W3kuI7u22lCGUSDG0gg5xQopO4j//0v51bW5uNUFwRbhra1AZ5LkG JuDgbQ2M+1VLe0le/eS4SM26ruRGGCfTPPQ1+bnsFyWa8S4AhtYvIyMguRt+gxWffp582ZnkMzKE 2ZzkDAUD6YwBQ9FciSb2I7CO5QATrJbrnaVf77D0ArpZILRCqrbAkxZeTblmwc8n+lBm1Z2MO5tT MjEArk5U9AMVcguY47SSKdVZ3jMW4jOO2aDV3UT/0/5ybBbq3mTzYjLb9fOTGzArUnu1ijlAYTJI TtVz93PGPw/pX5wnys9gyoLh44mSJcO3EahsLj3qu0TiJllfacnjHINXzgV7ZTHJ5MgL5TejsOCO RWmIjCYGkG6It8sf9/2H/wBaobu7m17x0LpisJQ0rQhJ4n32yuA6oRnH9KpT6qzt9nubJAIVDxXQ O4k9+O2PX3pE030P/9T+cpjNP5TQsZHOOh7f/qp0tlbTiOUtIIJP3b7ly6OODuA6An9K/Nz6FOzu S2tzPb70liDqmFhZTk49xj+tNuEYyCUkANyFxgVzlSlfYryecYyrqBGD1XoKmhJuIHhjQsoPJwMn FNO2wlJp6hf3L+VDZW9on2hziSdyU2jFPg0C+CrJFCMyDdLNswuRx1xzSNj/1f5xNfjNmIZ57uaa 3tIArQeXjY5YdOSSM/Tqaoamt9c3EEzMscHkCOVUXDkBQFI5/Ovy8+oJNOmuLaOK0k1CeRLWQy28 ckpLIG4wO/8A+oVt3F7NbeVcIizSu3mEyDd5uD0NAGNc6jd6lcNdXdtbQSySH9zbsfKVRwCOOuB0 /Wrr3kYEFsUI8z5QxHyg+p9P/rU+gGRvlhvJba4MbYk/dGF98b5GevTNaEEUEjEy3M0UfQG2x5ik HnGeK3Hd7H//1v5wTHFZ2xEUt3dyGYsZZyrHaeg4A6elKjtKshSIGQLwWHAr83PqBlrcpJOlnNIg uQm8gfdxkDJ9B9atW15a2k8u6zWW5dNkdweiAHkfjmgPQYslvb7gIXUOcttTKnJ5+v4VnXmoTWwM FlFFAZDzIIw7EZ7CgNjVb7VdG1SBQCU2yYzub3x6/lVeG41DT7mW5TZIj25tDFN9zBJ3HHvnr7UC cktz/9f+ayXVrrcHis/tEisIzGHCLIuecnt3rQj3iU73j+ysqtCqJtniPO9W5wecYxivzc+jlLXQ W5Ed1jzJHt0h/eo8R/fbhkbSOhB6H61FHDII5XO53ZcxZOOe3+fegfOUbO7l+0Mb9obN/IbbvODI UBIA+vp71s6ZNJFawtdW/nXVwWk+ZuAoJAL46fz6UWLTurlCdjcXSCSYiDHzogDI56Y59Pauihht 7SwSONFB6I2MEA+ldEI2aRnBa3P/0P5yzp/2G0ezMyTi/kFwJyRLcwE/3Tj5evSpbDTXs3kna9ku YgwIEiAOgA9q+Gpr96fV2tTZ9d/DSOCTwytzarIVgujCYm+XcMne2fQMD+dfuj/wSG0V/wDhPNcv Lq78sXt+XtHLbhZxIEVArfwli8gx2H1r+k82l7Pwqpx/w/qfl/D3v8aVZdmz+j39p+6Gl/BrXmim WOQ6e+G5Ms8ZhZVX2BJAJ9K/hd+N1283xE8WWN9DLqVzZ6jc29tfRjfYWm1IFaMnn5mBUnkdDXrf R7haniZeh4/jDO86MT8sv2pbDUdM0C9GmyadJdwxKTYSXbo8sJMbyHeAVDYbb1B/U1+Zmq7p7GF4 bWKzjUlJooGLjHUYPevB8aJt8R8r/lPS8PEo5R8z/9H+HfTY2giicSiQqcoc4K+x967CKe7miRp9 pDD5wx3j8DXh1XaNjqm7ybOg0SyXfJJZwwz6jbQs8IfDSjPHydx+HpWtqUU9vDp3mTeZPbWzNdIw IzIzZwvHQY6+9eXV6mlNLQij1maWNo3ZY5Y4/wB1JySpx0I9BX2H8HvCBu9C07xToUhubq3mkl1W 1upf9ftUfM0ZO4qNxxxjpj1rhrbGkF7yPbdMs9Sljm0m2YQaG0pu7ixjOFaR2O8gd85/Ws19B019 RmtDFc2k1tI01nLfQGWGJhwrDAyRn0OenHFcaXLdnXFWif/S/jWXWLeK2dGuZpZ3vGtVSOEvC5Db fmYdCCCORjjrWxpN7DrF3d6et3BFd6QEW7tZGKTJvC4wvc4IP/6q+fn/ABDkbsop9z1vSpW0jS3X UNt9Dcj7LatKf9Jhwy8gA84zgZ7H2rdtbC3tbe+lku/tAKLcCzlvkMynGd209PTb14px3OpKysZ2 9bi3m1AWot5LtSbm2i5LLHwpz3zya8VfSrvUfEMjIzos84jmDnMUQ6R/J3/nXXSaaGc/4rW5tL24 0gxuYI4sjcN0c3UF9w6cjp2wK4mOKPTYHha8S7W6XeLKPPn2h+mO+K9GnrG5jN2mj//T/jR8FavY 3GsaRbN5UOokLaWweMRzoZGxnB6nHr6V+kPhWFr7TYNOLeZZjTVaa/ncRokm3DKeOpIbAH0xX9Be AUr5tio/3f1PyzxNX+xUZ+f6H9Jv/BC7WbpdZ0qG4Ehie7mF4s0vnXVgBEiRpLzwGMaMN399evBr +l79p3T9vws8QwS3l01xqGk3aQPajei4iyM88A55Ppmvk/FiPJ4i09OsT9Aye1bwuj25WfwE/tDa TdeFvjX8QfDV1cWkenJqQeLTrZfOuZfM+Ujg5wxXd9GXpXg2todJtIIYI2NvcAys86eXJ5Z3AfQ5 A4r+y8imquUYaq93CP5I/kxT/eSttdnGQ2yvNPPPHOzSxottnHk/KMEvgcZ9q1/D+ktYrcym+lV7 y7N3Np3nedaQAcR7CeRjnjoMn1r1nbqZ86d7n//U/Bu4TU7vUbiK3WGS2eD92rfM24ckc9OnUc1s aNqYnaxuLu0jaOBvKkt0YmOTaSrZPUfT2r/TSKtNpH8c1Knuq57z8A7vU7P4y+BptJnkgSPXEkg8 htssa5GVD9RjqK/09/gfqcur/B/4a6jcMz3F14NsWndvvM6wIjn8Spr+RvHqlCObYWol7zTv9/8A wD+tvDutOt4fSUto1Wl9ydvvZ+e//BXrT5Z/2X9Su4ZIlkguthidTvlUvGx2kDHABOCa+Mf+CE2r l9N+IOhnzS1vYR3VwGm3oshkCHA7ZCrX5XSpwnwtWlb3lJHZkEG8+x66eyv6aL+vQ/oivEWS0uo3 BKPbujgdSCpBr/P/AP8AgpB8M9Wv/wBp/wAZaLY6fZO+sazjT9M80r9oEylGZ9oLBt6kjH90V6Xh 3joZfxFSxE3ZJP8AL/I+U4ny6eY4zDUIK92/x0/U/9Wh8Nf+COn7YPjvwzpniXTfh8r6bqUPm2iO 2+6tYWCsigPEdrMOd5PRhW7af8EGP2y7+W6uLzw9qmmrHdGWCymLXTuoBOPMVQCPQd6/q9+LuBw1 edOSUrab21X3/l2Pgsy8PvZ2oxclNPXRP9E+3XQuN/wQb/bWn0y/gtfC6Q3xtPNt5L7ymt5CTjaA MMrgc9/cd6/MP48/sgfE39nHxLH4C+Jfg6fSPGNtblrO2lt5LeDVFTAJtpCdjHGCa+l4U8RsDxJj /qEbRlv8V9F/S/rf43iTht5Dgo4qd3dpbdf+Gv8AceceEvhLrPj3UNL8HaVYWdjrd/cDOn6nK0F0 uZEQ4VQSWO7IHHAr9nPAP/BCT9s3xd4dh1WHR/B9hbX1ss+nDVroRbUYZUlC2S2MH5vlr0+LeN8H wnZYh8zfS9vTvf7juy7g3FZrgVmENIX5fn+B1Vv/AMG+f7Ztv5dsJ/DssKo3mSrrNsfML8nO/BGM kDHSrlr/AMG6n7TMVo99PqVrJemFpG0651mK7h8wH5duGzz6ds18LLxqwvIpUqaV973f6I9ej4d8 13Vm9tLWWvnqz//W/Ob9o79kPxl+yn4vvvCPxVttY0nW7jUWSwe4shPpO1WUBbadR0G5CWbs3bBr hvhl8KfFXxS8beHfAfg7zb3xDrF/HAgVVW0jiLYJdiGxxz0P0r+98BxBHMMn/thSSp2vo76L+vxR +EYXJa+Izf8AsijB+0bsvv8A06n71eG/+Ddv9o/W9Mi1qbxn4Qso76wju7awmRLW5RyocK8bjYc7 sFmHNX4v+DcD9oeye2it/Gvhq4W4DXF3PNrkcUdg5yfKjQAkrn046cV+VVvGqFOrKjGktG09W9j7 J+HUYzdOc3p6L9Wal1/wblfH2PSWvrHxl4Zh8TQt5kzPrpms79OyCMIQCo6fLzmvxp/aC/Zb+JP7 PXxMb4dfETQbuzupr/7Ba6lblFtbgxyFHYEE44UMenDdBX0HDXijRz/GywNS0Wk2mr7Lyf6eSseN nfB7yudH6unPnaXTf5f1ufpB+yn/AMEP/j7+0f4HtviHceMfDPhbw3rNwTpSXM/nST2oJCuQsTfM SGG3Lcc8ZFUv2sv+CJvx2/Zp8Caz4wOuaB4s8G6Pp91rF/qOjLHDLYRwQtPIWDiMhgIz0znsDnjm p+L2HlnkcnUbRcuXmemu2/rtp8zuzTgN5XhJV607zirtLof/1/jb9kn9jfxx+1p8TtF8HeAdP0GK 4Cix1TVNcKyw2aOQZCIijMX2oxHAzt696/bzVP8Ag2t8eDShPYfFfwrJqIKXclklqbK4V0BOyGUR FF9OnYV/XvFXipDhvHrLKUeaS+K6emultVpbff8AA/KMq4JePy5ZjW0jJe7ZrWys779Ufg7+1J+y x4z/AGZ/iZqXwv8AFlyr+IbWTydM224vBeOZPKAZ0xnJwQDg8+tfsP8Asrf8EJfid8a/hho/jnUP H/hPwzp/iOOPVIBcWl1JqVnuRWMSlRyDnDKSQMe9b5/4jwyvJMPnNJXlVtaz003+/a3Z7nmcN8Px zjG4mjNWp0207rVPZfNNXMv9o/8A4Ii/FL9nPTrfxLpviHQfG2g3l/5dy9rbjdAQARmNolIH3vlH p1r6K+EX/BvXN498JaR438TeKvC2ganr/k65bYtZ0vbeKRVJjdFR1+ikjp718dX8aa88FDE0vdm3 ZpL9G2fZYTw5wiwlXEYl3ipKK73s30S/yO41/wD4Nt4Bpl3DoHxft/tRke7hy01oHmI+UsRBk+gy 3GfrX89X7Tn7G3jj9mn4q3nwt19pZZ7Mea0zyQvFfrGGDHe2Cc7AcYyd3bBr6vgHxQhxFmsstzCy fK2nte3pp8rffqfK8UcHRy+hCvgE3dpf1/mf/9D5T/ZF/Y2139p34qeH/Aeh3llptveXfk6rJFIk 7zZO1IY12nHIYs30AHOa/on0P/g3T0mDQraDUfjXcrqUkR+1wGCS6tYCw5VG25yvTI4Pav67498T FkGPWBwNm3v/AFf08z8uybw7ccphjsybU5N8q/V6d/N6NeZpSf8ABub4Qjt1Wy+N15BdMBHPcHSi SyZ5UHBP05FZuu/8G5Xhy0tpdQ8J/HHVJNbS1MSJqenkpMMZKeZzkE9iAPevgv8AiMuP5tVdddF/ mepLgHL1h06cveW177n87X7U37LvjL9mX4qa14A8UvapBZqx0+9t7GVY7tI2WLyyQoRGyH68MEz1 OK1/2Lv2OIP2xfifL8MnutV02y1FIkS7Fl5lhM3nJlQSDg9+2QDyMV+yrivCLhyOe05391dftW9f u1PluHeGJ5zmrymrHl1d7bpL1P6QPDn/AAbp/CDTLeyW++Jd1IbO28i3g/4R+C4WyDLhghPGQemQ 2McVtyf8G7nwQa2S2j+KniK3iiVgkMOkwKhZjlmJOev0r8LxHjDnc6rnRk1H5efT5/l2VvtKfBGV UnytJr0/r+r9z//R/ZXxZ/wbk/DKbRb4+FPi9rsXiKaxe2juNSg220hIPl5Cehxx0+lfzN/thfsn +MP2TPiRL8KfFlxBrC2MQdNZtIWSC6aclVUFgDlDG6kn0r+uvDjxNq8RZi8rzPSbV4vRbdNEvx/E /FOMOGVlKhiMFG9J6PfR/jpv+vQ+FLfSp9EkumEPlx3EhVfK+5cAHIZ8d/rV+W/0uCa0tZDJa3Mg NwmVJjYDG5uB2yOO9fucJOUUz4WlG0bkFtqWnX15J5t3Lc7lZUYry2PUnp/9Y1IG0q3nuZFjmssw ZiWQ70nIHGPY4NdEFa5lKL5rG5Z2WYkvAggjeIJGyjAJPP6V++n/AAQE1b7H+1k9jFeNKbu3EV0k luFBYQsuFP0ZTx6n05/MvFmHPwhivRH6l4Y/8lDTg+sZfij/0v7+K/mZ/wCC3ng3Wda+KXw4v9M0 24u7a20BluWtgZGjLzxPkoB3MJHfqa9/hmvGhmkKktrP8jzc8w7xEVTjv7Rfmfsd/wAE9JGP7KPw ztpEaKexsntJ4JIjFLAwIbaynnIDCvfPj3D9o+CvxTg2q3meBtRXDHaCDbSA8/TNcOJ5VjqjW3Me hntH+LSvvHf1R/C/+zJ+yA37RHx/ufAl2bzTdGu7p59XvEt2nDTGcLEFHTDbskk54PFf0G2X/BAb 9nBtNtoL7xr4sguWTN7LZ20RmlJ5C+YzEgL6V+y5j4g4zKsJhsHhJfZV0tFol/w1ttD4vJuE8NDL YY7FfHJyS20Sf/BLC/8ABv8A/sriERP4j8QTFVZRMulQWkzg9DIUf52H9481y3iD/g3e/Ze1O0Rb Hxl4ot72Da0EktnFgMGznzCzlenVFBrw14r5vzuad36v/hjrrcH5XXXs7L7v8rH/0/GP2/P2FfE/ 7HXxSXwNA97rehX9xNLpdxBo/m+dDuQwqJxglwCBjJyM1Q/ZE/ZLl/aX+Lfhz4agz6cjX8Lzavps BmW0ikCq0MyugKSK2/cBnoORg1/VGacW4nC8N4TN8Hi26kvdlFqD1s238KtyvS3VWfdv8qyXIcPi c5xWXYrDpQjrFpy26LfqtfJ3Xp/Tp4V/4N8v2V9K0Gax1bX/ABFdaneFZbi9jhQjdncwZd4VjnPN Xf8AhwB+zTG6LH438Uy2yMwNte6dFdQsjDGwoZcADoMY6V8RQ8S89q3daq9XZWUf8kfSVuE8op1l CnHRLW7f+ZT1X/g31/ZiudKlh0zxVrljrJgaCLU49Kjt1VSTwUEjAjt61/NL+3p/wT18V/sg/ELx Dot5exeINMnt1m0eW3hNtDNaJKY42Xr85QgsTjJDYPFfY8F+IGOzjMqmXZtUXLytxekXdNaaWT0u 9r6XPC4t4dwuWZfDEZfF3urrfR9evW33n5165Y3dhLBbwW4tjHb7H8oZRiMAHr169OPavVP2e4ry x8ceFrizVEkTW7e3uZ7iXDsJZ4wuFPU7iOPTNfpWfVHU4XxDX/Pt/keFwtH/AIXMN/iX5n//1P7r PgxcNdfCf4dTv96TwfYE++LdBn9K+ZP+Cj2npf8A7IPxcVoo5Xj0JhEZMDyC3HmA+qgEivpeFanL xDQfaqeL4jx/4ScX/hj+aP8AOa8XRaVZadDFemN5BdyJdzRAyAMZXbJxnDAEfTOK8hn03y9W2Q3P nQy24uIvNUou1iQFP5Zr+98rb9ivQ/mCOsUSvYaXDFNayQutlt3zI0uZS/c7sdMk/hWY39m3FxCj Ty/uAwS2jA8otj5S/r09e5r0J7lyVmbemJYRmVZgoOxvKgA+SQknJz2x1rdsNXj3TWfllJoCtza3 MsZ+yvIjoVh39Nx7A1NV2wsr+Z34aP7xfI//1f6t/wDgkRHan9jXwNdRwJDeyuY9QbZ5czyLHGx3 jqCGkYfhX6O+MXuYvCfiSa0uJLS5h0O6mguIjtkhZIXYMp7Hjg19Rip2zqu/7/6muYxtgIdvZ/of 5xX7cHxW8eeNvi/4u0Pxbreo69ptn4juY2S6vpXtI5beXaFEedo7EcdAAOFryH4S/GXxV8FPFXhz x54I1eTw/qnh29GotPb3Usct2ibCIcJz8pXIOfwr+mo5T/aHCX1OK96UFbteyevzPxXAYr6tnU8Q 3opP7rtfkf2afs0/8Fw/2TPH3wi0HUPiZ4t1Hwl8SLDQkXW9GvNIuLuPU7iJFRpIrlE2fvG5w+04 OcdQP5iP2gtU0r9pz9tv4heMPA1vJq3h7x3478nSp2RBFEriCKSYrznlG+Ud3618Bwo58L4DGYjF x5HFy0e7atFL05nZNXS18z6HiKms8xuGo4bVO135atv7lsfuL8PP+DfbwD4m8MaFrfirx3JpNzex rq0dvZ6PAbyETosnzNsHOWOMliK7KX/g3X+DiTF7b4jX0wEe2OS8sdlxAcnJUoMHOeciuLD+Jeae 1nVqyuuitorfP/g+Z6Ffg/AKEaMLprd/1+h//9b9sn/4N4PhnBpskOmfFbVLPUSCY7pInjUZH+rO F+5wD0Jr8VP2/wD/AIJU/Ez9jCaw8SnVdP8AGfgvVr6JNO1WxkaG/a4O5jBKhQErhHJ47DkZr+nM h8ScRjc1p5dj3GNN3XNqtbabu2r0+Z+YZzwlTwmWyxeDvKas7aPS+uy7Hof/AAT5/wCCXk/7ZEU3 jWXVovC1lbRJDdS3KrfxxLGSh2QBfLG5gxO4E8KM5Jr7k+L/APwbmyaZpereKPAXxaj1vULfTZ7i 80u/tTpXmBFaQiAqu0DjG3IHTGK89eK+Y4bEfV5RjKO3Xfve/p/wDpXBmDr4f2yk1JPy+7Y+bP2T f+CKWrfG6+13UNb8SWWhTeFZjod6ZQtxGuHZf3Z2Mc5QkccYHHp93t/wbv6OzvcD4vQRT29sYNMC RTBITg8yAQgNk9RjpWeK8WczdTmpRSSa7u669evlZm1DgnB25KjbbX49On/APyA/bo/4JT/Fj9i3 TpvGusT6f8QPB2q30NmmrWOoCCCwad3BeS38vzG2+X0CjG9ee4/Oz4V6VdQ/EDwFc2FtNMi+IIo5 HUHyogHUsuBxnKrx2Ar6/NeLVmfA7x6aUqqlBxvd63X5a+jR85gMmeE4qjhbNqm4yTtp0f56ep// 1/7nvgOCPg38NgQAR4TtAQOxCc14B/wUP0ttS/ZK+K7Rllk07R/7QjZE8x0MZO1gPZirf8Br28HJ xxMUu7HmmvO/Q/ns/wCCT/8AwU1/4VV461T4JfHXxrrsngHUVZfDM2pv/aOneG51LOzBmPmRI3K7 Vyp3rkcLt+x/+C2/7Wv7P/i/9jPWfBnhPxjo3jbX9e1axutPs9LikuzApmWPe3AKFTIHyRgBDkiv 1rhPKcRhuPaMpJ8q5nt0cWk/R3XzPz3i7McPieCXyPVqMd+qkrr8GfxEm4RPssV5bkG2gjTZbgIq eWixjIXgnCjPrX0/+zl8ItW+Ovj3RPhz4LtrB/EfiPJgkvrsWNoI0ZRIzSgFgyDcwUDLYx1r+m81 qRw+Cq1ZaKMW38lc/JMnpurWpQju2l97P6n/ANkn/gk3+2F+zREfFXw8+OWl+EtX1dFvbzR7XUJ/ ssrkZxIpjMbA9MsgO019E/tB/DH/AIKwL4F1oad8U9B8QaZDpDvqFj4aj0611O7WP52UbrZXJZVI IUjOcZ5yP4r+tQ/1t9vJ+77VNvy5r3P6CzvDT/1dlQive9k0l58rR//Q/N740aP410Xxt47PxJfU 28R3uuvcatql5P52oPcySETmUEZUh9wxjABHNeb2lo91c6Zb6XtPnXkdms+oxlWuGJxkKOpPXA7V /fmExcKOSxxMpWjGDbb0Vl1d9D+YuFaMsVQ9jFXbnb7z9lf2av8Agi78af2kPC+j/EfQbqy0bRtS tEuLQT3i6fbbgSSZw4yd3TYADx6V9La9/wAG9f7Sm251LTfEnhJrqBRPFpsWpwtaXJAAZNuVJzjv xzxX5TR8XalTEOE6SVNdnrb7rfkfpuM4EhShaM7yfl/wT86/Gf8AwTB/aD8L/Fr/AIVDeeE76x1b VdSgtdOeS2NhbSPIokcwOQwlRs9QfXnivtN/+CA37WV5pU+uwWXg6xvP7N8u2tP7ZU6rKoXcimPB QNk8E4PNelX8WsvvCnh4Sbe7dlb8Xd/cvNnBT4HxSoTq1mly7Le/9f1Y+K7P/gnB8bdY+KI+D3/C MX+neMbZPskjzxxwpPLG6pIwfZ0LEYGMnP419QeIv+CAX7W+k6Hc+JBaad4muFhaZ/D0F6ouZI1Q tsVAFKv2HUZHJ61rPxXy3CTjhqyk31ata337p6Nfc2c8ODMViMH9Zhby33Xy+4//0fzT+KHwp8R/ BzxbP4G8d+E9e8M69pzxw3Wn6np5tZnjkcIsiAkllwQd3ckiv0z+DH/BIr9pD47eGdJ8XeCvD1n/ AGVPD/oVxeXEdvZyRMoEZZtpUMOuM456nmv7UzrjzDcNKDrR5/aq8bWS87v7u/yPwzh7hupnUazg +X2bad9/63/4J4X+0p/wS9/af/Zg0ibxH4y8AX0+iWbvLe6vDtvdLnX7zuHRMDaOgJI4PTHHyN8F fgD4j+Pfj3QPAfgO1udW1fVrovBb2cbSyQ7WUHcMYAAY53EYxzWmF42weYYGrntJP2VOy6X6edt5 dzjxOQ18Pn9HKZNc84X8t5eXl2P041T/AIIgftladpi6kfB8ctg8rXCNp9rJLewRlSyGSMJz26Z+ tfMXh39gf48+IfFWofDi08J67L4qtibNoX0plaR9+zcqYBHPHGensa82j4vZNKPO4Tuulo//ACX6 HvT4CzCM/ZqUX83/AJH1FJ/wRL/bEltVP/CC3lyZbNILdV025PkucZl+VBgjkjLdTXyb+0X/AME2 f2jv2etFGqeM/AfiKSzmkk83UH0F7CxtEiTc3mvjBLKGbjn5e9dmWeKeWZliqeBnCUalSSitmtdF fW/ls/Xtz43g3FYLCVMXFqUIRbfR6Xvb/hz/0vxdt9CurW7jF5EkMLARIIX3lgcYIHpj8a+wPgz+ xH+0F8eolu/hj4Hv9ZsXkNr5y28ty4bqrLsUryMnBOQAMjmv71zjinB8N0vruMvyuUo6f8Fo/nnh /J8RnM6lCha6s9fn6n1ZF/wSG/bbt0mH/CpfEcs0+1LWO50WT7JAAOX3DGc9MGvOfHn/AASQ/bT8 LaBd6tefDjVLV7ZDeADQJzZGJQSyeYPusMZ5HY/h4OD8WcgxOIhRblDmdrySSXa9pO3rtrrpdnt4 zg3MaGHlUhZ8vRXv8rpf1sfn/r/gtvCuoyaVrdg9j4ggQ2t3a3Fu1rMskfEilWGQQQeDzSeAvCOp eO/ENt4Y0DSb7WtX1GcWtrpenQvPNcKGxIU2g8gHp64r9Kr4yhLK1jeb938V/Le58zl8XiMZSo01 eUnZLzelvvP1p/ZM/wCCe/7R+h/F7wL4wvfhP4l0zS7TUoWtn1q1lafyElVjvQ5EW4DqxyK/v08P RSw6BocU0BtpotHtYprcgqbdlhQMmO205H4V/GPixn2Gz7O6dXCu8YK1/vP6UyHA/wBmcMRwc/j5 22v68mkf/9P+rT/grl8HPFvxr/ZN1Pwv4M0a+1zVrfxHbX72NhbNdXBiEcqswUAngsnPav4Mvi1+ x78e/hVZRXXiT4aeKLDRN87veT2MqzOgYnIjZRyuTwDyBwK/pvwb4hwOCy7+ysVO0py93/g/M/G+ Lskr1cxxObU17iST+R8rG0V4/siEmEN/pEU8ZR1x/eUgEEe9Q2Wi6hLeSx6PFPdSMP3drHz09PQV /R+KXLhrs+BopurBI/bv/gl14l/aO/ZP+KsHxg8PfCbVPF3h3VrOG38Raa0V5pkU1vIqbmjk8s5c AHB2spx17j+qu8/4Kr+BdI8KS+INc+DXxM067itDK1kEge1EgUnBmfyyFyOu3OO1fxj4gU8DnXF8 8Vg5qzfK2tU2na++2m5+8YHF4jB8Nww9ZO8IXS1+7Z9eh/F3/wAFLv2gn/ap/aA1/wCIX/CMJoX2 adFDXV8Lu+nBUEM4CqowwcKAOECgnOa/Nkw7JJYFXdORkIRg89MV/VmQUFg8owmGg7pQX5XPwPKY 8uFqN929rbu+3zP/1Pxz+Hnwc8Y/EW+ii0HQ9c1qQqwFrpsHmhHX+B2API9PQ5r2Nv2QfjZbweY/ wq8QIrSeXNILeaSQt06eXkfXtX9+4zjHJMtxDwWKqpTW67ev9bH4NgOHMfjsH9aowvG/Us6/+yJ8 YbK1tvP+HniqYhttmbS2e+tyNvR2RRtOT0YdzXlOtfBjxjoFnIvifQtc8P3luzMYtV0ua0UqD0BZ RnA79u9dWW8YZNmMlSw9Zc99r2f3f5XHjOH8bl8eavHRdehzmheF9WvdPuLZZrzxFDaSO0NtbRed cQIzD5EQHsT14zXbXHwN+KUWk3Op2Pw/8R3Gki3DfbfsDQSQAgHGxwCT7rke9d+J4gy7La3scdUU G2rJ6PXy/XY56OU4vF0vaYaDkkt1t167fqcXYeCNaVJ4P7IvHkQFFs5IG+2GQZypixnNbTfBHxrc tpHl+CPEYd5VupSulyKLcOp6ep5ziuqrxFlOES+s14xurq7Wq7ry8zmjlGOrX9lSbtpt17ep/9X8 Wdb+GnibRZrybV7K5021SZo7SXU7d7d5NuNxwQBtHr+deb3+l6k15NDdLGsUBH2dkcOjjH3siv8A TLBZhhsfRWIwslKHdO62ufy3j8PUwlV0qytJX0ZgXV1cQSJBJDbQgAANE24zDJGT70y4KyPsaTyz NGFbaNgXt6da9SHwnDKVloYt9NJC5Nm5MIjEZZ/mYsOprS0c6tPBdGa3iSRUHkPI+RIPbH4V0QVk YkV9aSpOL6UQwqoCyIvGB0JxUWq6HaSrG0YXkBsBjhj159qoD//W/nG2SwybZCFjRcIAMZ9AKiv0 EJhnZmjuC2FwNwcehFf6opNuyP5JU2lYuWdvcSyp5ckaFovNwzAA8dD6ZqbJlDoAYGj4k2nAbHX+ VXyaklG0l+yamkD20c1tcI3nM5wAeO3r1/KtSaxtp7grbSMoUZTAwo9Rj/PSpcXfQ0g1sUIL6XTr qaNrgJDsInXP38cjn2qvbahBqUkzljJCr48wrhH9lPelZltLqf/X/nLmkQyJEkapCgwhUY24/wAi oZHjBO2QSrLjE6fMD04z7dPwr/VLklY/kcqwFYZJHDh5SRsJHT1waZq19pyQBLhyJ3Plqm0gBj93 mjkYGNp808S3G+3OzG2ItwH/AM/0rUSZY7RWuImSIyYd+kSk4wM+v+NNQb3DbcZLbrfadcPC0kdr byB5mUleAw4J7Z6fjW2thBdafDcC5hRIk3Nb85xgcg/571Li1uB//9D+bi3tYpZVMbEc8E8A1t3K usbBH8vy0wX/APrV/qfyq9z+S1PTUyPstvJFlG/fFfnB4DmqEETCSRDJIjdgp+Xg9xTtbQHPsXYo R5hDM7ySsAACTu9sVFfQm4kJtYUDquZFLjeqjPT1p2aVyeb3bEdldwaejme5jQSfIFkYLyOwq9ds i2qzRESEfMoUfMB6/lVcvu3RF0nY/9H+bV7Fn8nVlumitzEYprYxhS78YIPX1H41RktLqMCa2lfc Xyyvllx/+qv9VHBJH8jjI9Xhhuvs5sb7zSpBuXBWwfjsfUVp29nO8TS/K3nHMXl43IKzAS6sbi2u IZwR8ycZwMgZB/lTUmjfZwzO2c46fjSaT0Y02tiu0UEVwkt3KqxS5UIT+8fjqB7VIEjW5iWB3a3d QipsOc/730FMpzbP/9L+b+5tIYYo4bGaXy1+eW3ZjJlvbJP+eKqRM0rkuMY6I64PFf6pqDP5Hbtu Dxt5TlMLsz7kVFb26MRcSzGNQuCp6N71XIreYBq2nQMbe8KNLLHxEVcgAN3xnFQXksq2pjA8zanB UcLjv+FTyOwGlZXjXmjRWFyzT+RHtjlnJLIeuaEh81VhB2CPCMwG0P7ispK6A//T/nJjuY7S1utP VlVTGCJrjlPf5u3cVG0bziCJjGqmPzC0BByvQdPpX+os4t6o/kraDJpYIWiCxn54/mLdGGP/ANVO 083LebMlwiSRphGkfbGn+NZ2excHoPlM9sFLTRXlww3NLCNqHPbGaeuoyywxRbAWLbSxHK/SptqU bYikEK879owzAcmsTX7SE2bGJl8ydCjyByAhxU8rVNmsJvmR/9T+RvVbWDUtcurW8uLqGGyQytKF wilM/u15wd2PXvXCCW1eWYhXaWKTCmVCqcdMHoelfYcfrl4qzD/r7U/9KZ8/w7LmyjDN/wAsfyRZ iYTy5+QvjOIxwtdhp2nnU4hHFGzSKSECDJOB3r4c+gMnUdJexvDHNCI5UAG4OGz36gmrtpI0aYiA LFSpyOemDXPVXvGlPqfp5/wSe/bFvf2G/wBpTw78U47OfVPD15MNO8R2yXIt5IQ0uflT+LjkdOc8 81/qg/s8/HPwj+0f8IfBvxh8EG4Hh/xfpwu4IbuPyri2ccSRsPY8j2IyAcgfLVaEMPn0a8v+XiS+ cXb8rH2WFviuFJpS1oSen92a0frzX+4//9X+8j4geONB+GngvxL488TzSwaB4V0mXWNUkhQSTCKI ZIRSQCScAZIHPJFf5t//AAXY/b08AftwfGywuPA0d7pWj+ALKWwtr6TSUiluWW6jDBplJJykSkhs Hk8Z4GUqVKlg54iW7XKtOr/LQ8/FKWIxcKS+zLmfkkl+uh+EUdnJfCJrWTz45V42oSRjjp+FVf7E e3dpbwpHiQKgAO5z6/yrw5u0UepJapmhpnh0XN+qq52TfeOcY9eK9hTwWYdPlg0+5tJfOQPdWouF EgwODgnnGO2cVDmapaHmGs6Q9qwjdlj2ybBnufSpNPslu5YFkla3lLeTFNFHgvtB6Dp2zmlOVopm lKPNdH//1v2Y/wCDYy+0mX9jLU7O0vkutQg8SXTahGHDSwMHhG0gcjBP5sfav6CvjoNM/wCFNfFB 9Xihm0+DwJqlxNHOgkjby7OVlBB45YAfjXwnC1OnVrYzm39rJfiz3uMVNZXRh09hH8mf5GnxfgsU +IXjaSyhtIdNHim6isbOFcfZU37to/2fmAA9q8kns47hJN4KF4yqbBhxwcYr18VHkruHqjxsuhfL 6XlGP5Ihj0qQRgCNgyDAVxhifU0n2q80wvbRTlpZoWV7dZMkDsdv+elTTinG7HJWTRZ02zunsS1w WlkKFmLgBz19Kx4dNS7uYZWQi6hkZYI5G2oCeMmiUbK5KVos/9f+VZElGqAX86iOKfyy8bl0dTgN n6HPT0rSvMfZrg2SpvTkbnIGM4B/z71804WVzWGxBZpdQWsU4JZbhjFPAcbccYYd+MceuaQhZjIy TANAQksZPK9wKi3RD2Vy0YDOq5AXC4DYy49vpVcwSRRsnkSXJmfy444U3St1rKr0N6cbp/P8jf06 1s5tNS7thMssgMc9rJamF4tpIwc/e6f/AK6IdIF07zPNPai3bbHEUIWc98j0H86zbsjPladj/9D+ YuXTpTNbrBMzRS/uxGkZ3lupyP5VsjRB+6aZ1DIN6x5/eDBxyO1fFt81uU7FG25DqttEQkUbWwmi XezGZUaJSO3Pf2rnUGCzPITkYAPenNaGlraIWO4lXCoxRScMc5Lj0/z6VuW7fujIwQFDyq4BIqYp qVhpXdj2v4DfFEfCL4sfDX4mW1ld3Q8I+K4NelhghDTTLCfnQq2Byu4ckflzX+o1+wd+198N/wBs P4F+F/HfgK5dZ7LSrew13TJoTDLYTxxojjGAOvXHfPuB4+IpUaed0cRV3kuRLz5ub8r/AHH02XKd TKK9CDtyPnfmnFp/c7fef//R/v2dlRWdyFRFLMx4CgDJJr4i0v8A4KJfsoar8VP+FN2/xGjj8cNq 39iQ2Vxp8sNtNcbihUSemQQSRxg5xg48evDD0qDrVUuVHo4WFWvW9jSfvNflc+rfH3gnQPiV4M8Q +CfEdtDeaL4l0mbS7kPEs4jE0bIJUB/iXduBB/Hmv88D/grx/wAE35v2KfiXZX1pqseo+FPHksv9 mypaeWswMuIy7LwjqHQHgZweP7vPVjH6jHlXQyrS5cRZ97H4gXmmSpclJon3oTFGyodgxz1pLfTv OWQywOxgJCyhTwRXjRu3YdbSZWjtbyTLQg7dxVWHUEcdKvJNdW8MkOoyAqnIxwAO/wDKq5Xa5kf/ 0v5vdVsdJ1C9jOmWWZDCu6Vky7nA3ZPfmi3t9QgtzD9njSTqpVcD0Ar4nlu7HZNJRiWzDFMyRu7L KyZ8oDrjvSf8I5Lcot6JJg8GTFDGSokHqR+HA961tYxkm1ZFUx3YkdZldYokGzCkMxPUGtK3RMBg M5GPmHNRJWRrSWtn2LMOn7PNibzCJiXX5PlNQWummb7RFbtvkjONp6J9a5ZXvqJxaP/T/nNvLO6s MGOLzHPykPlYyfY1pWFtJL+8mIRtuAuOpr8/Oymnzpkz2i2zxO0iRyl844y2OwqrbWas15crG6q0 jK4JBEg7kVk5e7ym1vfFsY5F8qJUVkdiHnJ2FOeOP0q7NZyPccKXkQbVI5DfQ1KaT1Na+ll5Igul lhiMpidjH95F/hPvUytdwwsEdDbXSAysoDEDOcZ6/wD6q26mVvdP/9T+faXTHe3jeHCgrhuMH60t vZCZHt3QFQu3eRkZ/wDrV+f2O9tLcDpdwPLLuHRRsAPaqzaVFHqIbzv3Plr5qx4ZXJwf0pqLTuYu XcqxWJt7uXzpIFgZ/wDRyXw3fg57+1XFtZPOyXcoXG4IDwO1c9CPM2z1KkVFpISaCe4uWhEbCPHy 5H3R6k/56UqWV1YqI3ZZYpPmJQEbPQY9q39nfSxm01uf/9X+eu7smgKyqrMpw7ZHIotolvXKt5kd uGHmBRw+OM4/E1+dOHvpHtqPuuRYlsJnEYgCxBGGxiMHH0plvbi21QxoZ4ZI1WeSYLlSTgHH+HvV TpdDNxbTGX+nWcdobxI4LeWGYPELbCzy4YMdykd+fz61kie6vpVNuGj65idf9d6A+lZyp9ThgtJI 0dOgWe1v4Lp4RdQJ5irLOE8sggFY+mT7VTltjcCGB+Y4Msig/Kx9/Wrk7RSNYL3T/9b+eE+dP94F BEvlZYbcgcfjWlYW/lgiSXCkYULxtr8+irKx6tNaXP2r/wCCMX7YOg/sjftBJL40tNWuvBnikJaz XduouFs5cA+e6cdf3iZX7u/OCBkf6Gfg7xdoXjvw1o/izw1di+0XXLKO/sLnYYy6SKGGVPIIBGR6 14ODXs+J8Qr35oU36W5l/wAE+kxEefhyhL+Wc1635WY3xO+J3gz4P+DNW8fePtVGjeGdFRWvbzym nfLHCqiDkk8+gABJIArx39n79sT4DftOTavbfCHxVNrlxokfm30F1pz2EqruKkqGJzgj+eM4OPoM atYeqPJwULKb8jzr9vX9jDw3+2f8G9T8A6hcRaZrUKm70m++zo3nSoPkR3xuGMHaQcDewPUMv+dD +0T8DfE37Nvxh8X/AAm8X6eDqXhrUp4bDU7eXzrfVYklYfaHPZiCvHHDDgYrqqPlpnNCnzVLH//X /CvWrZ9Qt1u7eEzMr7G3fcJHXk9xWDPBcrAipDKy7v3gKkbB618G43SPZktWiobNlZoJ0YRsA23H y80yO0ii3Q2yhWR8uwGfwNKUeqMvZ+ZqR2apPEZAdhILshw4+lXWtp3YeYN6q37snsP85rGMXzvs OceWCMmSxhkmcLH+8lk27RxvP+RVazSSz1Ly7yGN4bNGgiiAGATk5J77SScfrRye9oZJWR//0PwB 1JvKmURHzBIvzuEOIgT0JrQksJnt/sGn6gIbl0SW5ljAkxG2Mj8elfAezt0PRS1sf2V/8EE/2/vh 6dBh/Zx8ZG40fX0MGjeHtVltiYL+RSwRZmGdpbI5PHzDsDj+rsdP8818hwrhq+FqYrB15NuNSbTb u2pO6f8AXc+x4sq0MVTweMoJJSpxTSVknFWa+W3oj+TT/g5P0LQI4/hFfWujadDrtzG95c6qFS2u Z1EskbIz8E/djOff1r+RDULGyd1unmKSBv38TMWjiP8As+vevr2rOx8bS1Zxut31tIkVjZHyIXY/ aJYxhpvb2rnXjvNOulk3/arFotvlTqCI+o3Kf8aQ2rOx/9H+d1ZUnmkZ0Aht180M5wE5xx+dbscy Wdo93bfLNLC0Rk2iRlRuDj0z7V+cz+I9CxzNrLFKWW2uPtMyMFlIbcc+hPqKuwXkxuI7PyIY7llG 9IiXznpyevftUha2wkVuLy4ctJDJFanKhTlomwQSfpnikdVgTy4UMgDlyXYsfXAqIO9JMuatJpEP 2h76NGjt5LZA7wPPLG0ZJU4O3I57dK1GgkkSMoxYIMM3dqbXvXJjoz//0v58ra0UwPHch33Nvgz8 vlr6Y+tQTWNkGW4wj+T1QnBP1H4V+bnorR6GfeXks9i9pHCqKjb4ZAMNHjt9PaqUUlykUKuSJG5X sMjvQU1JkzWBW6EjXTDEf+qiAZJGIHBPtz0/Wp5ipiSNJQgQ/MqkcnvxUybWxNnexG00u39woZQM EY5aq0EIMuWyrM24oTUNtx1Limro/9P+eW4h0+CVZlZEMw27P4gfb8qge0QPvL5jPRfX6ivzBK+i PTfwIisLUQwyWkbb40keVUPWMuSx/wA+1UJLqWJmX7MkjHKIkwPHPUYPFaRi09SlpJLyNPzDDC8c cEEAkRWdc5G4dznmtCxv2mjNsHWTySXJHRR/hxV2LIr94rp7dHJSTdhCi8DHPbp+NQzTLA5Il3sP lz3/ABoA/9T+ea2jXVLy3llnWKOBgnmhMlMHv3I9qv6to99LcrCk9lLCiiRbn7QqJtzzn0I9DzX5 uewZz2ktkZR5m4qdsU9u26InpwakubOOSxyURpQRKzjjG3nkfgKCeZXsYdvezIlw8kcZRR8vlggp 9P5VUs724vXlUWjJF1BYYOB3NA4u6Ogtb6/iEUluwjFvMCW2BgCOn+faqerahPGyG6Q3M10+95o3 EgAY8bhnIPr/ACoBux//1f54ntFv4IlSVlZ8edsIjjwOwA+lMv7S1j2xtP8AvZE8p2LHbGo6f5Hp X5uesndtGbZRTNICty1yV+UZ5JxwM1XuUaa6MUsbo+CFbpzUT2KG2cNi1/bx3l1PapbuMzYMhkxx sx3/ABro7e9guYph5qMyMwDHCswGeBUqTWhDspXOfvLq4dhBErYVstgdBUjW7TMkdvHMVSMNdOyE Kp9B69qfOXbof//W/ncifyLBrd925ZC6vu4wRwMVjwo107Q7AcKXJzgKFBP9K/NINvc9ixc228cS 3UJUlB5bcY5HB4rI1O+UIsdo8c086gICSNrH+En61YFmJNQa0SHUVt0+zL+6uIiN3PbPsaSWO6gg EjO0gH3Gxwv0oNYr3LGzpqaf5am7uZeVDtI0e4Bieh56VBsgnmuUkZfKCny5E5VgOn4GgUFZn//X /nXtjFbLIYPm+XaOcD04qvDdBYnkkhcrOdpKjK7h0z/nvX5ufQFmJIrgH/SoxI3G1eXj9Mj3pJpY UtpoDC93Nt2QyRyhBG2euMc/TIrOULK6Ai06ULb31rqDRqhgxbODmR37D2x/KoNOnXTYdjdUckSu +Wce/wDnvWYLzM3WJb+91KC8im8u0SIRvBjJyOjKffuK9O8PeN7qDRpNM1aO1v7fTbOT+zGnxBcI 7vn5iBhhzn8KdmtzoP/Q/nSmlj1jzniQqUYvsc9VGc4H8qSMQ+Sksu4DmMI3y5xxX5efUGDe2sVr I2oZ3tcAW6ICCVAJOQPx6+1Sfa/LjCfNtHIDcnBoAjluLO3c3CwXU80yKipGvmJEe5YenJ/Srkkb ukXzRqXBZeRuX8K2UVypA9EZL2V/Bbst1LCWZy9tMuGkYE8bh2PHStrRdMvp4ITO1ozlnMmJNoZQ TgnPQ1RPMrXP/9H+bxrm1s777LIHMCHLeQm9BnOMY9+vpXSafpaapZz39vcRQxxv5R8yZY0PHPU9 uK/Nz6e+lzh7TTbywnu3vHjmmdyqzJyWQE7QD+PanB3InBcctmE9SgwMigzhuadtqUsiLBqJjSOJ BDDKMeY4A/i4qrfww211Fdx3COuxWYMSV255GOxoKi/eaLaPO9wLy0kIgUbkCtjZz1zVbVrz/QXt 1ilea7bylu4wZGtWOTuIHY+9BM9z/9L+amxskikikFzNJKseyWJsLEW55A/z+lTtNp1rq1pJcams YIZLi0B34B+6WXt9a/Nz6AbqUKIftoeSRAeEh5MgJGMCtCyuFZVV8ncuI16FfWgDl9XsINRm8xoE n8mfNo9wQPszcDIbt0/zxXW2kEtrtRgJZiAGdTuU49KqLs9TaHwovxvpkssiNaukqrjG0oqN7HvV dnWRNrY3W8pwoPLr2GK6I6MmCtdH/9P+cCC5FxJJGE5hHyBR8y89xXUeHnja6YOGkZ22pCVz81fE 0GnViz62Vo0Wz63+Hi5sktdghDsm+MjZtUk7sjv3/Gv6Ff8AgknY6VdeLL61h/0ixW4EhjSLBglA VHG4dPmjU49CK/o3ib914ZUI/wCH9T8t4SXtOLK8vNn7hftb+defCTV7C2VrWS20efzTcFYisYjy XOfZTj3Nfw3fFgTR+P8AWbm6a2srTUNSeF7qGU3EWYwFlkbAzzy2OuBivpPo+Qtg8TJ+R874wTax dCHqflx+07qonvLiVWju7C4RbWOMbYlu9qj5zEfm4VQc9M+9fnFrzrayPb20CQ2s8m5UiG2OLHOB 718f4xS5uKpx7RR9BwJBwyaPm2f/1P4b7OSNNqb1IV8lXOAa7FLnbalRuILbhD0Tp1zXiVY20N+b 32jY8OuUuFvJFVbtIfJFwuQCpOSB+QruNQuLk2TokUMzSYgEroDLEH53jjJ6Dj9a86oro1puzscr ZwC2nltb6zubK4kufJ8zUIzapMcDBUnseOa+2PhrpN7oVpFe2epNFeahpwtzKk2YYQGP7tPrgZOM kEVwVY9GbRfvant2nQeKbC2invILeSSOHzpmgBY/N93j0xXQad4rs5lls9ZtTuuLUw2t0YcyWrZB 4z268da5+RHYmlG5/9X+OO21lLjxJfLLoulaXpUUcC211BO1xKJF4lYqfUjOR6d88Wntrf8Atae9 tpv9LuLkzSXUcYSW9AzgyHHPHPtXgSf7xo5U+Zqx3em6g97pQu9RlSX7DdNBCFAB25wM+/Sup059 CMksTaJaXWoX0IjuNQuA4uYlUZ2qQQCMcc5qV1OtqyOi842KQW1udNt7eUGMR3YUKmBgYPUf1rza ea9TUrl8W6x7PnSFVIYjgMpAwBj9a66OxLPPvGVze6fp2j6oqWdw+pX0ttLBFODJDAvymRu4PJGC OfxBrzHxHBY28MV/ot4xurhkhRpovLbsWCnocZPSvQor3bnPU0rI/9b+Nr4f2NlDLp0+oy2k9/8A 2hHGGlQG5gO8BX9Byeo9K/Q3TjI0mn2Vvd25itPLnk/s+QS2l8VXHzHkHO7r1Hav33wBt/bmJX93 9T8n8Tp2yykv736M/oQ/4IrapcaX8RL+38hkXV5Io9XLQj7VvVEETonTYFgjye+Gr+s742pbRfDP VJbh5oYJtJmiWRYvNjKvAVG09uDmvn/GJNeIdJv+7+h+g8MxT8L1Fbcs3+f6n+fd+1loN7pv7R3j +G0iiXT59Tiaz1u4uBLfyQrHGqQlP4DujfJJGQF44GfCdRhur+OVbqf+1pyxO2Vv3qYPZj+hr+v+ HfeyTCT/AOncf/SUfyTTk587/vNfc/8AM51DBEggijvDPE22WGaHG8ekZ7//AFqrXP2CXeAtwJLf D+ZE+xUxnKHPrx9K9qafKQf/1/wc00uLW6u57u4tYUVWit1RZCzY5O/g46Y/Sn6f5jiZLUksE+0r vG1ZR0JHvn+df6ZQ+I/i6s7U0z134O6ne6L4o8C6s4jS+tvGFttlnJVtjz4+YcYPIGOnAr/UB/Zg 1GTVPgD8K7yd0a7bwlbLeCP7kcu3LqPYE1/Kf0g4RjjMFNb2f5n9Y+FFeVTgCvR6Krf/AMlS/Uzv 2mvgDZftGfDq78A3+pnS4LhJdsxTegd1VQSME8AN/wB9H6jwP9ij9hLSv2QP+EguLHxQuuXniBRF ceTZm2jWNSSqnJ5wTnp1Hft+ERx7p5fUwP8AM7n12UuOFr4is9XUXJ6dP+CfSPx//aA+H/7PXgi+ 8XePL+S2thbutpbwAfaLp9rbQuSO47ZPtX8+f7Nv7MOj/tyfHzVPjhc6hqUPhyyv21C6fU7ZLqS1 kikPlxrhgPmO0hMg/M2SMHE4adXC4eWLhvol89zky+lSrZ1HESV/YJt9NdJJfOyP/9D+9XRtK0zw Z4bs9LtF8rS9C00RIQnzlIUJZiB3IUnAr4f8T/8ABR34FeFdY1PRtRtPFDy6ZcG3kurfTw9nKQcc NncPxH41cKU66bT18zfFYuVTFuc/im29PXX8/M+hPgR+0f8ADz9oPTtUv/A016f7IkVbuC9gMThX 4VlJ4PIIOPTqecfHv/BRf/gnT4E/bK8Iy6811LoXxB8LafLd6RqNtbJIb3yo2cQk8MpJVeRnOMYz gj2MkzLE8P5tSxtJ6wa26r+vyPOz3J6OY4SWDxWtrNeq6/dofjn/AMEy/wDglL4N1L4man4/8Y61 rn9o/DfVHtbjTrqK3Zbt3J8hgGUyAKIzg5/jPAIBH9WN1cWfhbw+85jmex0TTlURwp5kzRxKFGFA 5OAOgr2eN+Ja/Eea+1qPRLQ9XDUaWByehgcO/d+J+v8AwP1PzD8b/wDBW79n/wABave6Lr2m6rZ3 VnK0Ieed0RyvcgQHAP1J9q+uv2Yv2sfhb+1V4YvvEXw61KOWTS5/J1LTHm8y5tweFk5VWKk8Z2jB 4+niYrJcZhsHDGtNwflscGCxUcZOpCm9Yn//0f6pP+Ck3/BPP4W/tXfDfxN4q1LztI8Y+G9EudWg v7aOJxeCCMSsvzDIZhFt+8A27sQCPgr/AIJWf8EyvhlpX2v4y+J57y81rw5r/wDZmiLbPGiyGDbz KSpP3cA9/m4OcEfo2V8cY/LuFcRk8HfWy9H/AJfiY5NlmHwfEFTOYQXtIwbV+7XK3+X4n9DXjfxZ pvw98Ga94t1KOWTTvDWkyX80UIzLIsS8IvbngV+Mmuf8FzfgNoOqT6PeeFNUF5FP5QaS8NvCq8fO T5TA9RxkH+VfL5NkWLz2pKnhd0cWPzelg8ZDDVH70v6R+o/7OH7RHhL9pHwKnjXwptjgEgjntxMJ vL3btpz1/hYc+n4D5X/b0/YU+F37QfhPV/H02ltZ+PPDOnS6lb3Nn5SRaqyFHczB1OX2oRwVyDjg 4NRg8XishzRuLtOL5X6df80e3jMLGE6Sra8tpfr+TPSf+CeVu+n/ALM/hvRn2r/YmtXukRRquwRJ AYlVcfga9S/a50u11j9nX4qWV3apeI3hS7eOCWETRs6wSbQw9D0z/tVk8TOWb/WYv3udP8bmfE/7 2nXctnB/kf/S+0f+CIdtFo37Xut2UEa29neW88htUKiHzAJVQonouOMdK/snr67jOtKvmyqzd24R 1+RWBpqlkGEjHblf/pTR/Gp/wX68O/2B+0b4L1y20r7TLqWnrrizafGBeztFKny5UFgQUYs3XGD2 r66/4JA/8FJ/EGrXPhz9mb4o276jPfXar4V1lpY5NQsVmU4gmKABlQoBlhkZ646feTyxZx4c06l/ eo3a9NL+mx8dwTOP+s+YZanpVlLX+8nJq/XfT8eh/Sl4k8MaD4v0qfRfEemWuq6bPzJa3Ue9Mjow 9CKLufSfBvhq5uSsVlo3hzSXn8syCKKGG3jLBQzHA4XAz6ivxmMm48nQ+7rVZQvRb93mbt5nnXwU +MOkfGfw3feIdIt5IIrDV5dLkyCYJChO1kbvwOfQn64+LP8Agof+xF8Gfj78PPEXxC1nwpYL8QPD mnrcQa/CzWtxcRo6qRJtOGPzDkjLYAJ4FehleZYjKMfDF4d2lF/0jkznBxhTdDELZX/yP//T/qO/ 4Jlfse/CD4ZfDew+KNp4V0t/HOp6jPHDqnkFZdPW3fyxtGfvEjOTxwp6gEfop8bfiV/wqD4YeLvi J/Zp1c+GdKk1BdPVyhuCilsccnp0GM9MjrXs5hmNbOsz9vXd3JpLy/4c1zjFTo4RTltTgmlslpf8 Xuz+eC6/4OF7C3n1Gwb4XQSXlndraRyWssiWg3vtUyuzOd2AcAKATX7i/sjftYeBv2rPhjpfjXQL 2wstbZmttY8Nm6UajZSLn5vKJ3bWwcEZ+6enQe5n/B+OyLA08fWSdOfb+vQ8fh7N6Ge4WrVp6Sha 68tv07ngP/BRn9lT4IfGP4Wav4y8a6R4dsfFOiCKSDXtQcWst9EhO639CxyCDjJ8sAnoRL/wTs/Z e+Enwt+Enh3xtoPhDR7PxTq4aU6hBaeU1nGmUjWP1JU5LnJyRjGK4Y55jo5A8u5n7O9reX9aeh15 bSo0MZisRRjaUo2bt8n9/X79z70+IeueIPDfg7XNZ8L6JJ4h12ys2k0/So+s7gHGQOSBjoK/MCb9 rX9tKHUdsn7PmqHTmclZofC975aqDjO/YwP4kV41OEHS55b3sPnnLEqmttLn/9T+674SeKPFfjHw No+veNPDUnhTxBdoTeaRKjRtGBja21vmGQeQehyODkD4+/b8/Y3+Df7RXwl8Zax4q8G6DeeL9I0C a4sNdu4GjmQpGwR2deQ0bFXEmM4jAOQAB9BkmY1spzeljMPKzi1rc8XimhSnleJjbmSg2tOqVz/P A+IGg3fhK41HT5LK3urvSL6ewubS1y1puikKHy2wCR9APoK4OLSVuIY5b6FEl8rcEYAvEGAJAP5f lX9/ZZiVisDRxML2nFSV97NXV/M/nek1OKcdmcTJpENrrMyXN0q2s6K6TQ52wrjBAPZvX3rUWTTd QaCWyTz7O3U2MLtli21jknPfOelerGVtyJr3rI7ZNDuYtOa5t5VeCNhK0dxOsRXOARGvUge2a/bL /ghTeXVj+1/4agkigZL2WS4WSMfOsZ8tFz6kNn8GxX514oLn4Qxn+E/TPDN/8ZRRj3UvyP/V/v4r hvGPw9+HnjcWv/Cc+E/DPiP7NmOzbX9NgvGizglUZxnsDgelXQnKEXKL1/4JWKahi7y6Sf6m5oul +HfDWmxaZoVppej6Va5EVpYrHbWsWAB0HHQAc9lA7V+DH/BUv/go5P8AD3WF/Z++GWrRB9YgSDxh 4g0O8t7q9ggllMUsEeQwG7ZKhPHQ4OT8vs5Hl1XNsf7FdFd9du/5/I8bP8TUqUo4enK1Wq1FO+qX V99vubWp9z/8E6P2e/h58P8A4G+EvGdpZWeueL/EMT3134mu7KNb1QJG8tUxwDjDFh3IxjFfaXxj 8dT/AA0+GHjfx1a2f2658MeH59Ut7ZlLRyPGhI3AckDqQOuMd656lSpiseoT72Xlqd+PjLAZc6O6 pw/Hd/ifza3n/BdP4o6frF7ZSeDNOurO2ufLlvEt4oLa2HHAYxHd155JHFfvt+yD+0BL+0t8E9B+ KU+n2+mz6lczWktvbSb4yYto3Edic9Pp9K93iDhStkWDp4uolae1nf7/AJar8THh2tHMqFTFR1UV 2+X6n//W/tE/a+/Zx+Gfx8+FPiW18Z+HdMu9Y0jTX1DQtflgxf6XNCCVYSDDFcFvlJ9OmK8R/wCC d/7PXw2+H3wui8W6d4d0SXxVearPYyayulRpd26WzKqqkhG8kk5LnBJ54r6mWIqPDui5Ximc2GpR jWlNLW3+Z91/EnxXN4G8A+LvF9vai9n8O6Bc6rBasDtmeGNmUNjnAIycdga/mH8U/wDBfb4g+G/E U2ix+C9J1F7S9eC9j8pLdLZFbarb/LOd3vivf4ZypZlGo3b93eX3Hz2cY76pmFOm7+/p+Z+/P7GP 7SU37UPwc034j3elxaTe3EzQ3FtACIWwWCsuT6KPzHrx0f7Sn7M3wn/aL8F6ppPxB8I6PrOo2+kz w6TrN1b41DTgyEsqyr8204BK9MgHtXgUK08PmSnB2lGa/M+gzOgqmCcZbOD/ACP87j4/fDXT/AHx I8b+FLOH+z7bwv4vvtLjSOd5hdKkzkZMmWG0FV9MAV5v8K5rrUvHXhp4LK6kjttTtFkTyjaqGadA nmHj0xn1brX9b4uftOFK/wD16f5H45wxO2f4btz/AKn/1/7if2bdU/tj4F/DG9wFY+FbaB1XO1TG uzA/ACvOf257MXv7KvxiiO3C+F5HYOMoRkK24emGNe7kD5c+pS/6e/qef4hR5ssxa/ur9D/Ni8e6 fFJe3cKSptivriOOGFNiTFZiu7J5IwFPbr+Xkt3HLZOqyMcMMFyxDLj7q1/oFlMebDRfkfytD7KQ 9JtHv2l0+4lle5aEG4jX5GtyW+Rs/QZx1rprXwz4eg33D6ja2iQ2u8yXjMTM2ONoAJzXoTgy5vWx grbWToFsJrd2+0s8l2pYKQeMfQdc10+mW8dstzHcyxS2lvOskc9qCS8gYEORjkBgD9BWGJTWHl6H p4Nc0o+qP//Q/qd/4I3381/+xt4ZafUY9Ukh1J4zeRpsMv7uMjcPUDAP+761+oniCNZNC1qNxuRt JuFZSMhh5T8f59a+lxitn9aHap+ptmz/ANgh/wBev0P82D9r3QEtP2gPH8N9cKGXxJJdS2mQGtCG dXUjuQcc18lXawMkzSSjy4iUkUNkf5/xr+xsh5VgKV1okvyP5/kmq0+93+bLmnanaCwWIyWIZ5Ba WcMiK1xJ93aAeo5AHX+tf2Hf8EWv2TPgn4z+GjfFDxR4M0HU/E+jaoiRLJG1xJbzRnckhk3ZxuUM P9pPz/L/ABgkqVClClpzPXz3PuuAkqlepUlq0n+iP6TAIraAKiLHDbxbUjjUKkaovAAHQADAFfgV +0F/wXG8MfAz4m+Ivh/dfDlLxvDmuTaRc+dLMb1/JcozfK4A6cHBBHOO1fjeV5VXzKnUhhVecdbd z6rMcxpYLEQVd2jLS/mf/9H+un9hf9v7wx+2pb+ITovh5tCudCs479lSfzopEeRo9pySdwIB9OnX Jx9afGn4I/Dz4+eCL/wF8SNDg1rRbxSYi/yXFlIVKiSJ+oPPT6HqAR9NiaUqGInSk7Si0vmjNtTw 8JPVO5/ML4b+Nni7/glt+2BrXwi0N1vPhZ4h1SGwv/DGpub6CGKRl8u5tpAquhVnY/LgEHDc8j+r rw5rdr4n8PaN4gtEK2mt6XDqUMbneVSaMOFJ7/exnv6V1ZjQdCvSv9pXRwZXU9thajXSVj5W+Mlx pP7KvhDxt8afBGhQtavIdR8V+H3nMWnXbu+4zIOseCWOE7kAcHFeV/sU/wDBQfwx+2DrPiLw/p3h iXw/qOg2K3pdbg3FtcDcVYDPPQZz7d+duc4NYSVS3VL8GaQnfHql/dufXfxt+B/w8/aB8C3/AMPf iVo0es6DeuJ0U/LNayrnbJGfUZ6H2PBAI/BD9nr/AIJ6/BDw9+2N4s+GXiXSLCDT/DCNrOjafdXa LNqzIUZGt1bliwO7gHHlk47Dry/G4j2E8An+6vzW89Ff7jkxVGlHFU8S17/w38tz/9L++TRdG07w 9pNhomk24tdN0y2W0s7dTkRIowBWd4x8IeH/AB74Y1vwf4q0+PVPD/iGwfTdVsZSVWeJxggEcgjq COhFezgf98jf+YnNrezqNdj+Hv8A4LA/sfeB/wBkX4qaZrXw41OXQ7LxKpWB0lW4mhSXAaMR9Vkj 8yH5wBxIDzjj8SdR8S+IdVeex1PVdT1yxKxxJHqV688cflHKsq525zznHav7S4foRrZHhMbNe/aD +/lP5jznEyjXxGEi/dUpfg2YM1rHKkjeUiyf8tCcA4Ar1j9nf4w+KvgF8VvCnxX8E21pfy+FrsTT 6bMhYXmJFZlCggkkKe+cV9Pm1COJwdbDz2nFxfzVicjrOjWpVY7xaf3O/wCh/ohfsH/tneGv2zvh DpnjjS9IbQNatrGIa3pAuPtUET8xsyMQCBvRxgjoAc84X7gkRJEeKRQ8cimN0YZVgQQQfqK/hrMK f1fPqtL+WTX3H9OY1+1y6nLvH8z/0/Iv+CnPh9YP23vi/o1ohisIfFt/NcadtKQWYd43iwDwco8Z 9t2O1fQf/BK79iLwx+1v8T103xJqD2+heEL59T1KxWxhkM/lf6spMfnGNj9D3PHSv6w43zSvl/h/ TWHbTq8tNtfyu7f3qNn5Nn4R4Q4SGJxdR1Ffkk5L10S+69z+4/4XfDHwt8IPBumeB/B9q1roulRh YUcLvYhFTPygAcIMAcCvmz4+ft5/Az9nTxnbeBPH2oXy67cW8dx5NnGpEQlxt3biMdevSv58wVN1 HPvyt/hc/acxm4VIeckv0PSNJ8G+A/jhqvgT44myLHToo9S8LzHaZpYyvBl9OccdR7EZr2fxl4u0 TwH4Y1nxd4iuGtdG0Kya/v5kQyOqL6D398AdzXNhVKeIjHzt+JeYP2WDqv8Auv8AI/E/9mn9prwX +1j+3lrWveEdCi07RvCkE9rZXMk4nutTEKMRdSgfKGdwxAQtjauTngfuv0/Ctc8oyw+Zzo3vbT8T kymTq5JRqPr/AJH/1PuD/gvV8OtNt/2mfAuo2Wm2sP8AaHh6G+kMUIVpzJcYkBx2DI5I96/pg/YU h0yH9lb4QLpFtBa2TeGImijt4/LjPGOnqAAP+A1+mcWYypi8Lls6km7U0te6k0/yPl+EaEaLzCEN P3jNz9snRrHW/wBmT4z219brcLD4EvriLMYkaJvJdSwGP7rPn2Jr+Dr9gr9pXR/2Of2n/DPjDxJ4 c0rW/C9nrzaPq0xuGt72zinYLJJ8oYBh98Db8wQDIyGH0vDdKti+BcfhKPxc8X8k6bf4Js+ZzitT w3iFgpz29m/vaqJfif6CPwe+L/gj45eA9H+IfgDVI9U0DV48o6MGktpF+/E+CRlT3HB9jkDnrP4B +CbD4vy/GS2gdPEM2nvZNbiNFtUaT70owM7jk+wz9Mfl0VKNaVO/Wx+o1XZKfkeo694o0Lwz/Zv9 t6jb6f8A2tqCaZYee+z7RM/RVrlvi58M9E+L3w+8TfD/AF4Itl4h0uawFw0C3BtHkjeMSBDwQAxB HGQSMjrXfRrV8DiaWLoytODUk+zi7r9Dz6lKGKwtTD1FeElyv0asz//V5f8A4KS/8E0PGH7H3im2 1GTXLO78Ka/qEr6NPpjNBKHZ41gDblwVO7BOVK7Tx6fqN/wQ8/bT+FfwV8Ha58HPi5JJoWrpqL3O neIREdRtgrhS3mMPmVeAuVDHD84Gcf0t4hZgs04LwuOhp7SpGXmuaEmflXAlCWBz7GYN6uCcb+kr H9HkH7Zf7NFy8Udv8VdDlklAKqlvdEjPr+6r6B0LX/D/AIx0a31jQdQs9b0TUYiIbq3/AHttcL0Z SpH4FWGR0Ir8Eqc0EpJ7H6ioupGaa0P5tv8Agrv/AMEsdW+INzrfx++Edl4ditbLSmudc0KGwSyu dNmiVmN5hV+dDj5iPmBzkHdX8337BXxa8N/s4/tTeDvFHxCtk1HTPDl5c2PiiK0jWSOxhd1SSZQO C3fBIyK/qbgfPZ8ReHlbLIu+IhCcPO7i0tX3un8/I/F8TQoZHxrh4N+5zxq27Rvd6LorWP8AQS+H X7WP7OHxB0LQb/wb8UfCtxaatZwSadZm6+yXKLKoMaNGQNp7HPQ19KKysAykMpGVYHKkHoQa/k7M 8vxmW1fY41WndrX5n7nSq1K1OdT7PT70f//W/vl1jWtJ8P2E2qa1qFrpmnW+POvLyUQwR54GSa/O r9vb4ofsw6t+zv44h8ZeLvBmpXt7otxB4e+yyxalq63TxPHG8Spl8oWDf8B+tfZ8LZdmWKzbB1MG nZSjqr9Hr+B8dxLjqFDI8ww91z8srLTdpW/Fo/zn/HF/BqnizX7uwuLWXSZdXnl024VDDfPGXIVZ kxwQB359RVLwfq0+j+KNH1FbSeWC31e2a4FtIPNeJJo3l+UHnIQjB9a/vPE0arylUW7T5LX3s7Wv 9+p+IZY+Srh51o3ty3Xpa6/Q/wBKT9gX4n/s+/G79nnwZrXwifw7qUNrottb+IdK+wwx6tpE/lKB HcwMN6AAADIwSp75r7N1Lwb4R1mym03VvC/h/UbC4Qxz2d5o9vcW8gIwQVKYr/OvMKGNy3Nq2GxE mqkJtPXW6Z/U+Ljh62EVSil7OWq9Gk0fwq/8Fwfgb4D+B/7U2nWfgPw3ovh7RPEWjC6urHTLRbOM yhQYmaNQF4VolG0DiOvyc+Cnwb8VfHz4hWXw98FaKNT1/UtTitpAT5MdskpwrZ6gZHOOgJ+tf2nk mcew4Lw+aYh6wpptvyVj+fuF8peZZ3PK9feqOPyT/RI//9f+m3/gmF/wTe8P/stfDCZ/iR4O8MX3 jbWXSeSSayh1GUKV+ZnkYH7wWMAYHC5I5wP1NufAXwutFAvPBfgG2SY7V+0+HdOhWUjnA3RjNe1m WaY7NM1xGO53ecm/lc7cwhg8trLBYLSlBKK+S/HqUI/AXwdnljtYvB/w4lnZt0VvFoemtMxHOVQJ knjtXgv7TP7FnwW/aD+GXijwnfeAfDdnr95o1zDoGtadYR6TfWVzJBJHHiWPaQCWHU4BAPatMtzn Msrx9HFxm/dkna+6W6+e3keNmWCpZrl1XDVLe8rJ22fR/Le19dj+O74Rfshwfsd/tteCdJ/aV0if SPAd1rMmn2d74g00yaNcLI4EMzAjbtDGNmLDADHIx0/tY0X9n79nTVvDlgdK+Gfw81bRL6wQ2t9b aLa3KXcbLjek6jPPP3SMH0xX6J4nZ9jMzxmDzXCyapSgrNPS616ep5fB9Gjh8l+oTj+9Upc6a8tL 9tnZH5leOf8Agmp8F/Cf7V/h/wCJ1p8PNNl+HHiCJH1m0aAy6bpl0jNuLgngY2kAjB9+QP1I0n9n 34BWtpCNI+Ffw8Nqq4imt/D9pOHGMZ8wKc8e/evhcxz3NcwlTq+0fuxUW/NL/gXPYoRwlCj7CSV2 27eWh//Q/rn/AGsv+CeXwH+O3ww8Q6Vo3w18M6N4xtdLubjw7daPpdvYvdXBhcC3fICYkOF+b5ec Hjkf59v7TP7KnxR/Z0+IXiHwb4q8La/o1sl8baxlvtMNviHDeUdpAwDtHygcZr+o/A7jHmVTIMfO 8nrFvr+Pr07H4f4nZZHAZlHMaatSmuV9lJbel1t6Poj4uvPDwguHnlmeQIowfcE81hXVxF5oiVGd h1YDAH1r+pKSPz2cbRMq6hkeVGJKxdCp4FbdrM8IjjDs7omQM4XHvXXGN3Yys7XKTifUFu4LnOyT O3/ZpLURxL5LyMDCBEA/Tpxya1SUdhH/0f529SQx/Z1WN5JZJdo2rlV9ye1V77R9SvGimjizbLiJ 592FjPYD/Pev9WEuyP5HKl3pS6XqdtIt6xkRAl2E+aF0PPHPUZ61pySxzGSNAu50yoU846Zp8rvY mauinJY5lFwzB5UjCbY+gA9vX3pIbyS2lZgu6Lbzkcg0rW0GtijCkOoXs8dxbNChw0NwpDRPk8hh 1FPSS2g1GTTneOKOMr++K74Uz3wMn/8AVQU23uf/0v54J7WzRmggu4rlmX/XIGWN8jjAIB/MdqyJ 7C5swFZYRGqgr5Q/dAeg+lf6sH8jmJ9oFtJKFj83JygX1qaEAM11PaQ3i7CHSfJWIY+8AO47UEqS Zane0uYbAWEc8bW8Tfa43UGKUljtIPXpirQmia02yKpTcMxsBglTkHHtimk3ojOTuyrdebcaZfW9 vIqRyH5oNpVZT3HH41X04TJB9mVPJSGEIpb2GMUrBGVtD//T/muWT7PLJm5QnIDKGGYm+ldHbrut nmup0kVhkRkcyDsBgY/Ov9V+VXufyOQW9n5kqXDKAqkhFXgKtVrhVimnNuVd2bAUD7opOKbuBMqQ rJ9pZFYiLZhjypxyfz/lSBrSF47sqC2CvzfeIPUZ64ocU1YDS0OfQIrlpNd8O213a3LB7Zi5f7M+ Tlhz36/4Ve1ibw9NqDppBYmCLcVMJjjXeAdvvtxVJW0E0nY//9T+cAuyQBbxYyScgKCEXB7VEFmk MzmRjGzAqAo2xjAGB+Wfxr/Vg/kcsKIrnbb3D71jXMZIwB9KfayRW52I4DhtkKnkP7YpOKYltqT3 oQqBcAn5QeCRtxzisuO5gRUe0tfMKzYmjYbSRnnH1qXBdBnWa5YaNJolvcFYoJ7dT8nBnm3nICj8 AMCuSuLlLeG3D71xhVCpyv1qlFR2E3Y//9X+axTJJMk1s+DGSx3Mdkp64NP8yeYrPcRiCUHDRISy qfY96/1YP5AbvuOnZ4onMuRGefl++1Q6fcafcMqiUP58fyQu2GHrx7UFRbWgt0pt47nzSzFThFib zFCj6f0qxZYe1CDA81Mq7KdxB9jQajZLGSJUIcyQliWCfL5ePX/PetmwihMDyhw8iHasOcN06n8q znHqgP/W/m3vGkntZ7KSMJ5o2yMBuZQaIYPs5g+xu7RBdmGUqRgd6/1MlDsfyRd2sXYL1IzcpcRl WJEaErjd349e36+lI8MjWriLaySdV6NU8suw1Joz7a1v4njbIEStz83Xt0rr7L7L5RVton3bt2cf hWXs10K5y7HOYy0S5cOcEIN2MVn620X9nyxia1tGz5kjXELO8wXPyLjoT69PWk42g7lU5PmSZ//X /kY8W6kDq2pRQtCYt2AE4MZI5BGe3H51w6RyOghij3kKdsh5C/Ud6+w8QWv9a8wX/T2f/pTPmeG2 /wCx6Cf8q/I07CJ42YBFVhHtY9/etXTbnUdLvVu7WdozBnDZ+Q7gVIx9Ca+KTSj5n0cX7hJfXE17 eQvK4IkXHmA4wc8DH51o28aWp3smQRjOOK5artJI2pO6uzsPDFtC14nkmUNdX1ugMR4B86PBPsMV /q3/APBHpQv/AAT++BeAy7tLlyGXawIYL/7KK+ZzN/8ACrgvWX6H2+TxtwvmUl/c/Nn/0P7K/wDg oVqTaP8AsZftBakkazG0+H905hkzslB2rtP1zX+U94wDa3rHiB3ZYReXs87L/rXjUyMMgAE5yOlG Nssnj/j/AEkedhk557Vha/ufrTP1P/Ym/wCCNP7S37XXw+tvGHgzT7PStMldgmpX8otTcKuB8x8t sdR25J+uPtCX/g2a/bCU4utQ8O3cQhZ0T7elxIHB4UMIRj2JP4dq+Cp5hiMRKcqML04tpPvbt5X7 X7H3GIyilhnSo4idqjSbXZPvpo7dH67D7b/g2k/a4VbRbRdDsLiIOzXpvY8pnnDBl5JIA+UfhX5d /tr/APBMj9qf9iP+zdX+J3hsro19emF/Edorz2pVgfLRnVQAcKWGQMhT6GumhVxFSpy1I2Rhj8Lh MNS9pSldaL8j8y9UvNRuJUt5cXWB50kyLnBGAAO/4V678Efg54/+PXxJ8K+CfAXn6h4kvbn7LYaS GjhtZPl+bzCRwADkn2Nd2IlGjh5Tnslf7jhy+nLE4hUafxSaXzeh/9H7p/4Jvf8ABPH/AIKe/sVy N4m+G9voGk6X4igB1Dwpf6vFdaBfg7WWeSFlOCduAyHJVsHoMfTP/BSH4+f8FX/DX7PXjKx1D4U+ EtF8Naro1zpeua54OtHvdQtomhdXmLrOSqjOcheO4HUfB8MSrRxFTERjenN3t2vfX+tD7PizD4St l9PBQf72EeW7drpPbt5W3P4J9fa6uWuLy/gvJb+8uGN6GUvcNLuKyEjtyDX3J+xT/wAE6/jz+2/M zfCrwoLqysLwwQ65qVx9nsSU4cjHOQeMc/eHvXXnGLjgl7apq72Xm30PKyTAfXJ/VaekVF38kv60 +R9k/tQf8EQ/2vv2afh3L8RNb8F2niCy0uLzNe1DRGe8ht4DwGYLyvl5BZ9oCgkngEjg/wBlL/gj p+0/+014Zv8AxX4W8O6NIflht5iiscA/MJXYEcbhwO/XB4HFWzSphMuWKrR1bsl31X+Z2UMnhi8Z OhTlaEVdv5f5+fc+ptR/4Nyv227Wxv8AU10TR7iaK2Cw6XbTiKS4C8sokXG3P48ivxH/AGlP2dfi X+zl451H4ffFbwbceDPEFtKILADNxFdsGZCqSAYO4ocE9j+euCx1TFu0qfKradb/AIL9f8/OzLC0 cByqM+a/l/wWf//S/lsSNcvayRR72bBmYfPx1HPTHNQzBVLZVV2Lhin8QFfO/YNYO6b8yH+0djJA VynVD0FP2pdXTSW0MaiUgSunB44GfWs46MprSx01naJDEXlcbYvmkyQpbnp+vavXfg98IPHnx18a eHvAHwv0CXW/EWszkQrGwiFqgYK0pc9hn9K4sdWhh8PKrU+GKu/RanpYDDzxNWNCn8UtF6vQ/brS v+Def9uK60bS9Vl0OwuBJFHc+Ta4Z28xQ3zgqu7GeqjH1rWvP+DeX9uZbC7upPCukzsLdgohutk0 A/2QF5YY7AivGwmYV8bBTpUXZ6rV6r7jsxeWU8JJxnVvJaPTZ/ez/9P8Rv2j/wBkv42fsneN7bw1 8WfCep6BdyS/Z7K8nh8uxnKcF0k4BOcDA9evBr5g8Q280s7SuS00qCOVmYjzAvQH/Gvi4xnGSUlZ napxnHmjte33M5M6WILyaaeVHupo1jUIwZUjHIUH6nJqP7JIHkEjjZEuAVkUElu+O+PatXFpXZdu gyyjmhUrKyyFThZB/H6E+lbkMsUYRny205cLzgUKLbsVFWlY6zQbo3czi0w0owDHkK0Iz145zjkf Sv73/wDg2fik/wCGVPFc5VPLn8RSiCUZ3kLIOCD0xkfka8DNKbeZYP8Ax/8AtrPrMlk45fjf+vf6 n//U/vn1iQQaTqkxOBDp08hPTG2Jj/Sv4Kvgtb3Gu/8ABVDR/tSSmzi+K90Ztzlll2Syup/PBz/s 18rxHX9hktWS7o9zIoOWc0ku0vyP73bP/jzteCv+jR/KRgj5RxX8mn/BzpM1xpvwM0iKOOX/AEa4 1W4XbmVQlwY1P45PH+zXbV93ARXZHk4xOWIjb+Y/nt/Z3/4JnftRftcaW+s/DHwpLHoIAcX86Pay yZxjaSjDoQenQj1r64X/AIIDfty2wgceHY0kUhvJFsLuCYDOTJhSRnHbnnoK+WoYipWlNUYNxjfX pddOp7dXLrVYqtLluk/k+u5ah/4IGftuXVz5f/CH2MKRxG4LR28tqHZs5ALoeR1wa/PH9p7/AIJw ftHfsiobv4zeFNUstDzt/wCEg8n7RYBpZCIxIyr7HnAwO1a06uJlLlnTsjHEYSjRjzwnzf16s//V /n60jQEtGmlgjeUh1SOO3HnSFiQFCAHuSPav1L/Zw/4JIftc/tJ+H7Xxn4P+H5i8OTJHcWd1rDNp /wBo353EKMsQox14O71yB+e4rGfVasadrzlsl5Xb+R79HASxNL2l7QW7ex9LXf8AwQJ/bLW8vYF8 MW5kEGLOeGCTYDno+6MjH0YnpVGL/ggZ+3TDYySnwvZ3ckTGQtHL5W5R0jSPYDn/AGqz+vYm38LX 1/4A5YChFtRqXS8v+Cfmf+0z+yZ8bP2Yda/s/wCMngK98I5naOzvrhcaXchM5AfnnjOCec9iCK+b NG8I3utXNra2VvJPe6jcpBpltCebmRmwoz6H+VehNThh/a1NNLnLhqft8SqFKN3t59tv0P13+Fv/ AARc/bX+JfgzSPF2ieCDcWGoOs8UfllJ44ZArAIrhc8NyxGOmDXqVx/wQS/bb08XwtPBFm0lzh1S 1WRpRyON7Jtz6nJHpXjwxtSulOnTbi9n/SPSr5YsPiJYWvO0o76f8E//1uI1b/g36/bh1HSJ76Tw 7DZG2AkSxgnD3y7R8xGRg5HbnJ9K/LT4z/s0eNfgH4nu/BPxA0zVtI17S52iWXVbX7BBcqOCyjPJ GMEHJ/Wvz2jHEVL80LW8/wDgH1Ty6krypTvY+u/2Tv8AglX+0x+1j4e/4Sr4f+FobrRjuMd5rFuY bRgfuvGSpyfr68gUv7TX/BKr9qj9mXT21zxl4Gey8PxoJNS1OHEulWij78oYDgEY49W7YNcWHrTx NaVOlBuKdr9L/wBeZVXLo0I81SSUmrpep8g/Cj9nv4j/ABu8Xab4A+F/hi48R69qF2IC8MBewtlD KrPJIOB94dSMAk54r9TdR/4IQ/ts6F4bn8R3ngO1ktraE34g03Uma7ZQN+0q4III4xkfWlCs6mKl haMXKS37LV7lVcu5cHTxtZ2hLRedrXa8vTqfkD8Q/hp4s+G/jDXfBHjTQrrw/wCJtKLLeafdJh3A YopjBxuJPGPUY7V+kH7Pv/BGD9rz9oTwxD468H+HhpmgXVlEdMsdWKWU10rKr+ccqwBZSGGOCCOc 5rbHVfqFaFGavN6WXU4cHhPrtGpOm/cjrf5bfM//1/iH44/8Ey/2of2f/Gej+F/iL4P1eCDVp1sd Dv8ATdNE1nqtww+WLduxu5GenAJ9cfUfw/8A+CG37aHxE0XS/Eek+F7O0025AmFjexLbm7R1BDsz 4OfTbjHrX5vWnWp1adFQblLX09T6F5c3h/rPMuS9v6/Eq/FP/giB+2f8L/Dt54n1XwRbX2m2btJe zWVz9pkjhVDkeTHlQAO+CeOtfjZrHhTVNG1nVdG1G2Flq2k3r2N/aMGTY8bFcqCOV46+1dtKjWcX KcbbnlYimqdRU4u57r+z/wDsd/Gv9prxVB4c+HHgK415nuFg+0zrsWNwRl4+oIG5CSemRX6ry/8A BAz9t6KxEx8JWSu0MYU2jpdu3qShUkN+lZYOKcWz1sQrVEWLb/ggP+21NdIR4Ytislvsl+0ypbxw Njgg+Wu49OK+cvjz/wAEbv20v2e/D2teNvEvgSbWPDumWD389xaut2QsY3OE8vhSACcMMHHBrV/G K14H/9D8ItT06a9+zW8EV3bvJKYpEkttssDocNHIuDtPt7V9s/sof8E7P2iP2rr+6s/hj4ULR2F0 EGoXpMenTR9JDI+04OSm1VBJweeDj4RK9VI+hcbUmz9Dm/4N+f221kL3OjaHOkLHa6/64g8DaFB6 eh5rHk/4N8v24p5Ing0u0cbmW5S4WCzMozwFcgkD8M+laTh0ZjHRNHyD+0n/AMEs/wBqn9mmxj1D 4j/DaSbSJ2MP9s6MPOhtdqM48zJw3Ct0wT2r8w9UtH0i5VLNLlzeMIE3RBvJOSC2QOMEHOemKUqf 7s81PllNebMk6KRcJHLciGcjBkJzk+rU26I08p8xk24UsvLGuScdUaRdon//0f555r9UARogwYDD 56H+VaELBooyEKyv8qHGc5//AFV+f2PUpvSx7z8JdUlTX9FhgmuYVGs29iqSRYiunZ1bapxzjHXp wa/0/v2TbGbT/wBnf4UwXCGOZvCdrNIhIJBeMMc/Xrj3r56hF/62uS29lb/yZH1FSX/GKxXX2r/9 J/4Y+Uv+CuWoz2H7FfjpLeaS3kvtVs7MyRgHapW4Z8+2Fxx61+YH/BvbpDiL4w6vdwv56MI7e6fg Sxh4wyAZ7Fyc+5r6bGxcfZ2/m1/E8bASuql+3+R/TrjHHpxX+cr/AMFONG1f4h/t0/FTSPDcE13q U/jW50m3i5+yzs5iUDd2w6scD1NbYiVuSPcnDx5pOXY//9Lm/hz/AMEPv20fHvhjSPEWleFrDTtI vIlvITLckzXe4bgWhaPIVs9N2cGu5f8A4IL/ALbUc9wyeF9NDTxAbvtoNsh6Dy4zGCD6jn618TNW gvQ92Os2jC1T/gg5+25Y2Et/deErC4h0+B5mNqhe6uSAcIYmxx7ivx7+Kvwj8c/CvxReeBvHPhW8 8K69p11JbXEd3avAbhonKOsQcAttwf8APTOiuelzMqrT5anKL8Lvg/4t+LXj/RPA/gPQNR8S+I3m SVtPtnWJPLc7PnZhjkkcYPWv1w0z/gg5+3XrEEGp2ngi3s7a/PmGxn1uBo7dWXduLMoJB7BM9etK lC8mRVjpFFO+/wCCDP7dVitusPgqO4me4ZGMUsUuxefm3envk/SuH+IX/BEv9ujwLov9u6p8Mf7Q 02zgku7ibTZhPMiou4mbb8wAx90L+NJR/wBoURciVBs//9P8P/G/g/X/AAZqTaXrFkbGc5LLNA0C SMmRJCVbDJLGeqMM4rmtGtJEYzjAMg2HsQO1fIulaJ6MfisfsB/wRq03ULr9t/wJbQzRpZ2urWl9 KskY2SmXMOAe7bjHj0+av9F3/Ir5PJZRq5zjoro4/wDpKPqc9pSo5Ll8n1U//Sv8j+Qz/g5k1SY6 n8KdKW1WW2i0A3FzcKP38Ia6b5VOcAEAnn0FfyEX9yY5jG1wZ452AjkI7f3TjoRzX0lanZ2PlqGz MO+ESvG0UisVHzgNkg1Xy1yjNLLOFX91HAcCMDuf5Vnyq1hy+Jn/1P54Le3h+0CC4IKSttOVzhSc cirt/bvFOtvYyP5NumHlRdqlcY2/Q9K/OprU9LTlsY6QwW4c2cLRjzDucjZnnk4+tW1e1d7W4WUi 6jl8osg+Zfx9O/tioJIrmKSBnS1DxxyH96cBWk5zVmKzuNkcsToWZwBG3OfXis6H8FL1KqO02SXF zdTXEVreyultaMW+zJ8qA9CQOnam/wBowzRXIsy48n5WUjaR0Ax+fWtCT//V/nvj1GSa1mjh09pb uOJQt+ZNsUKgksSo6k4rnZr9hNbotpIzTSMj3ig+X0+6fTGD+dfm56BpFIVjiiG5cnLHOd2e9TXT W9sn7wNK8UJ8kIoJyegNBu9EV9McxzKzh9jDzd8h3Mren+eKrailhBeSPbu7hm8yRihRdx64FBk5 e9cisPMv3uBDKIljTcHUAhMeufWtO0jivJ2MM6NPBLskhxklQMHPpzQVGT1Z/9b+ea+to4HkubeO KRwhj8ub5lTPVl9D/hUMdpLGsEgdp4513OxP+qPPb2r82sk7npv4COGKG0nmkU/vZRtZv4mx0pJN MkdvtDSGMJ86MerH3phd8yK8gnvZpo5lS4hmi2yOchhjA4x6gdfercthKlrbGAxWayAwyeUctIF9 eeOoP4UGosBFiVMjF2jX5Sxz0rKeV7yN5REixxyld6Ektjsf8+tAm7K5/9f+c2y1IWEM7yQyTBxh RCpcp/tYH41ahvbNraQyLJcLMnltbykhnGTwc/j+dfm56jnppuSaPdOfPtVs2tbJ2zHFKx8u1wex P+cVVutUu5JZTHbQxWkIEZ2yFnn7ZxQZlmS3gurQzQSRW5DL51s5xI4OeR7DFSWdulqhhy+05w3L Z74JpqLewET+cu5Y4zFDzkJ8zP8AX+dYrtdSXaqJ4o4lUpJE0Yd3z069KQH/0P53NJtPtvmxpK0J gYks2VWUjnCmn3ls0KN9oQBlYbnC7sjsa/Nz0Y6NCWdli9txCqIt0wDvuC7e2TWv5UMUUjX0USXN u7BZEbd5qk4HP05qJrQqbd7GHBFbySNL5YdBnAYZzms+7lSwPFuApXCtt+VPpWRBesNShsXhunt1 usMHkikHyuBzisu68SXcd/PILpbbTrmL99ZxptjDFiQSeuAOAPeg3W2p/9H+dSOWzmtVuYrk3Ekr lJIQpAjwByc9KrxWyzwXlyZoIRCfLKI/75znjAx+dfmcGle57BNcW4ltUji2pvTIOep96wI9POn3 Bia3cSqRK7yIdjZ5yD0rQLGqwfU0eKaCSK0WRVS4VsM5GCcfyrU1TUc24tYLEqoKQR7QG8zAAL9e O/X0oOhKysc81wbdZbWUOg28lk+Udeh/CoYvkCeUxaHGAeu7/OKAP//S/m7fzmmiSN9sSAmYEfe6 Y5qo2pRxyNYxyOJJF37Aud4HcfiRX53y+6fQF2zngZoEdLiGTzdtxImPnU8Z9j/9ar9pbmOb7NbK zwByS0h+YDk/jn+tZ26ANuHSG5uI5VVoWjxExHzBs889qymKJMnnxgqrZiBHzZPHFc40ruxorcuc RSWjRoXxlxtIHrilu4llt3tQBIyjcAy5Vh1xT20Zuf/T/nC062k8r7Ys0YX7jxE7ZF9Dj04qxmO7 YRMwQQtncOg7Z4r8we59QULqAhQhYk78xM1QxwzmYB0WSF0JdyfnUjpxSAZa5eeaMFtq/KJBxG3P THqMVJbxKsrpM7yTbjsJ4VR2AFdApfCx2rafLJAqxOqyMQYHnXcsbDHOPatWyjeG2JZ1kMSfvSn3 SRwcf570GOtvI//U/m7nt5YSbx0RVljOzb8xAYYNYFtNpWl6fJABcTs9zsMcQLuCxyXc9h/hX5uf SxV4WOxMum6jDaxB5rbyY/3jRMDPMOgAyMAVn/2Zb6fbXMrSPK1wmEMjBzB83YDp0/WgmG5VhtNo VrkoyAAq27cVqCZxdSXGlXFkH0+eIPFcPjMmM5291I/pQVFWk2K+m3c2nSW9rcLZwpgEABt6qQB8 vHX2qaBfM0+O1xsvY9wkfJYOB90n6gUDcUz/1f5nrSScJOsxQ3EEvlkIe49KtXjhLK4kaICZ4djy CIO/HQjIr83unsfROLTsOmukMNpb2sEpkNqpfemFzjnB6fhVtbQwoyTuEEsAa3eNsuznPy+2KLp7 FuGmhXisprgSPexABIWMkSuDGqDjJHfoPzrUF/HBGggVt5iDROwKr+HuPSldbGkYtR06E9tDd6nc Rxi5hWZczEzTLAHwOm49f58VTktku44LySGS1vNPu5YnGd0c6cBW689M1vGV9BWP/9b+cO3WJZJ7 i0D+fdACVgPvkeoz65rqNB1N7S6tIpLRZHku0hdlG1/nbAc/7p7V8Phda0UfXVlbDyZ9reEbNLS6 t2uwks8s7RAMeXIBwQB69fwr+jL/AIJA6fKvnXqwT2siam4k+22/2eOf94cbDjkZXA9SpHav6Q44 XsfD7C0+7X5M/LeBH7TiLEy7Nn6m/t36qLH4Ta5dXl15Opro7nYuRCYk3sxZu2RuH51/EF4wstTt /FPiG+8zSLuyvCkljC7ec9rE0Klt4YbMk/dPOcDnOMfW+AUeXKsRO3X9D5PxelfN6Ef63Py0/amM dtrGnpbWCSwvYvBFcxXK7rNjJ8xcdTkjGB0AFfAfiu3kght2nnjn86Ro/wB0P9WwxwR/kV+d+LMu fiut8j7Pg5KOTQv5n//X/hs0e2VmMMwJcrujyNrfh9K7awsZ0tJWkERKOREs0qjevb+teTWWhTfv XOy8NWUFy7QuERlUFHdgkOecj9B19a1nj1e4zDMv2EKxWAJiRiVJCuDgfUdeteZVR0U3qiJ59Vvn tk1KW3uvImGWvsys7DAXaSeDwK+vPhxbK+nrPfO9tAqgQkqfKLpgYB9uDmvPrGkXeoe4NrG65s4p demihSBY3aGLfC5C4UMQM4A9D1z1rBj16K+uk0u5cShJ3jhliQckk7cHrzx+tczaTSOy3un/0P45 otIsVuluZuIomEk6N9x8eo+uPyrQmvoJrmM2draRwlDHLcROE8sKDjjvn61863eo2ctOLTO+8KeH Nb1DSZb6LSVm0QSSH7YrbC5jOWJU9fYg1032O61CygmsIRbG0uDGHbEZuDjBUk9fX2xQmm2jtktE V9VtLFXa2uJGkmiUNcqh8xIXBHOen/6q4p7meSe/jtSsexAFmI3A9sZ9xXVSdrE21seXazaz3KsL pGkhglMbvC2+S1Uk5Yj+leY3llhFtIHuL5IpC1uZk2m0Gf0+tejSdonPUjarc//R/i18I6p/Y2qa a93az3sccomW4ijE+DEd+JFz93jGPev0j+GL2uqeHtHnkso1uJoY7qPywf8Alod6Fv8AdGOK/efA S64irLo4/qj8l8T0v7Mp2/mP6AP+CPGuanpfxm1qwMUCQajpYNtcSttSORHQCGHj77xmTgnjHvX9 hvj+0ubz4a3OmFY5orTS3ZlcA8CzdhnPH3lH4E14/jdFU+OqU1/d/Q/R+Em34YJP+Wf6n8BX7ZHh 2P8A4Xr4kv7me7i1K6uDdXlukga3kEMccSuygcE5bgelfHR1F7XUZYrVzvuk+zweYof5iMk8jg9e a/rrhmftMgwk/wC5H8FY/j+jOyqK+vNL/wBKZWW61VpsXd8lzGiERxrCI2iOemR7D9ap3l5aNG9k sCo+7eJw2HB5ymOhByDk9x9c+/KL5Lj51Zn/0v5+7Np4ZJ7a48+4tX+dfLO5l44UKB+Nba6gdLAd 0YxQxYQhSZAp5xjr+Ff6aRi4s/iurK9KzO68G3mpXviXwfKlsbb7Lrltfm3uUO6RGnjihOz1LSqw z6Z+v+n9+xTqFjqf7NHwvutPuDdQtoMavOX3+ZIFXeQfqa/lr6Q9P9/gqq81+P8AwD+p/B/m/wBS sV25/wBInpnxs+Jh+E3ga78X/YlvI7W6igmEkhjjhRydzkj0AY4747dRu/DL4ieHfij4P0jxb4cv 7e9tdQtlknjilV5bOTkNHIoOVIKtwfSv5wnS/d+1+R9xhIubqW+y0/v/AOCvxPz5/wCCq/wL8afG f4BSReB9Nn1LVtDvI7x0tmPnQxpICzbRyQQWBPQZ5r5//wCCLdhqHhfwR8RvB+rnytSgvU1O5sp4 mivLMl/K2sp5HO449a9J1KcskUE/eUlf8THJ6MqeZ46dS/LOKa/7dS/Va+Xqf//T/v2ZVdWR1VkY FWVhuVgeCCK8O1j4Dfs/61ql1qetfDzwJfam8pmvZruzheSRz1MyE4P/AAIVVOpUhH92W+VVVJ7r Y7Lwd4N+GngKC4tvBGi+FvDUEzbrmLRo4LRXJ5+bafYcewrd13xHoGl6NqF/qOsWFtZQ2cjSzm5R sDYfugHJPsK1ftas1Jq8mPE11KEqlWXqz+PjVf8AgoT4g/Zj/bo8U6v4S1e51j4d63rCjVLSGBhp 8lnIyBo3yNuQRnnv3HDD+sz4LfGnwF8ffAOk+OvA2pwalpeq2aNd2bgC5sJHRS8M0Z/3uDyCCPcD 6viDIK2AwWFzFp2mrPyZhkeLjmGSKb+Om7P0e33O/wB5+Yv/AAUk/wCCatt+0ZoI8S/BrRPDXh7x 4jxR3UdtYrpQ1DBEZd3iTkFFRSNp+4OnVfxz0b9nL9vj/gmxFdfFfQ7W1ksI5dmpW2lzSajp8yNl vnXap25GSAcDA4449rIc+w2Iy9ZNmTTvom/Pb/I4VQ/s+dfGUlpa79La/r8j/9T6G8b/APBcD9pv 4peFNV8D39lomlRakHsry60SOSyuHixiSB/mLg4ByQw6/n/R5/wSd8Vr4x/ZU0rWjbRWtxea7cXV wkUvnKS+1fvHk4MbgZ5xiv0HinhyOQ5TGcL+/L/M6MgqLH4XE41LaKWnmz7l+NmnQ6r8JfiDp9xD 9ohuPC9yJIehkCpvwPf5ePev87v47xX8fxQ+I2ltodvbw/2tcWelyE7Y0VWZlJY8BlBXHpgelel4 XVHHMqsfI+I4kw8JZhh6n2tj+s3/AIIU3b3H7NV+kt9Heyw3ce9kkEjR7mlwjMOpUAD2O6v2f8cI sngzxWjqHQ+HrwMpGRjyJOfw6/hXxfFDvxBimv52foebJxlTV/sR/wDSUfKv7DV1C/wu1/T4EcQ6 d42u/JZzy6ypE4OO3O79a9v/AGhYRN8EviehJwPB165A6nbExGPxwfwryYStioy80ednn7yhUUus f0P/1ftb/gkk/wBg/bes4IE+xNcLdAW4UsjAzIHA+isw9q/si/pxX1HFf+/U29+SP5I6MNHl4dwS 8pf+lM/kv/4OBNC1uL4p/DXXrMtNEdM+xI0LB5IhLJGXiKDnDKr8n0r82/8AgmJrEehftk/D3UNP FvcnWGEUazofMtXicEvHxwSAR7AN6iv1zh2SqeHteK6Qkj864MhOlxzWa39pL9T+/NTuVW6ZAP0z X4f/APBaP42/ET4T/DPwzp/gvW7vTIPFFz9guo7WNAZDuDY3EfxeWV/HjBAI/FeHqNPEZzh6FVXj KVmfZ8QVZUMLVqwdmn/7cjxb/glB/wAFEfhPpnw4f4UfGXxFo/gTxImqT3ul6nq9+llY6uGO5lw7 fKwBJIBOdvSv03/aS/a+/Z80f4ReJlsvid4J8QX2rWiWdlplh4gt7iacmVHJKBi2NqN0HXHNennP C+YYPOKuHjTbpt3i7bxfX+uxpi86webSpqjK85Rimuz0TR//1v7RP2KNUTXfgH4c1mC3gtrTUNRu 7iyitxiPyi+VP4kmup/az0pNY/Z4+KlpJKsSp4Tu7hiTguEhc7V9z2+lduHpOhj6dKW6lFfdYy4o g4ZfiKa6Uv8A20/zgvEltaWuueK5biw2WrTA6fMspa7WWNkJkOOj/ewvbPtXdfDb9qn9oD4L6pbX Hwh+IGp6I6Ni5gurr93KC24lnKsc5z0I4PWv7Xp5BhM94fhhsXFSi4r77fgfhGQZti8qwXNQbUpJ r5Hu/iT/AIKJ/tYfFK50jw9468YX/ivQft0E11a3ThLO0lEi7SuMGTDYwx6Z7V/dh+xbrP8Ab37N vw11MmHdPpOWWBdqRnOSmP8AZzj8K/nzxN4ZwXDdDD0cGt27n6jwFjsTmmX4vFYlttPr/XkfSms6 xpfh/S7/AFrWr2307StMtnu76+upBFBbRoCWdmPQACvmSX9uL9lG3uZLO6+Nvgu0uIn8t0ub8wqr f3dxXbnjpmvy2jh62I92jG78vkfQyq0qVWTqO2x//9f+z3/hvL9kXKqvx18CMXLKu3Vl+Yr94D6e lfO37UH/AAUe/ZN8P/CLxdZaN8X/AAR4p1nW9KfSbXS9M1pLmT9/hJCypufIUtwQBnqwr6HL8lzH GY+nhYUpXcktvM+ez3H0IZTWnRknJxaXrbQ/gQ+IGtvceKPEmqwCf7HqmvXmr6dbz/8ALCCaQmIb Tz8wBfn+9XkLtLd+es092ZZmLqVP7kDPK+2K/vvJcO8NlmHw8lrCEY/NJL9D+eMPz04Rpy3St9xi NbTyg2nlyXJhJ8guMsfr61aET6XHb2xhA3AyvGo2mL6jt/8AWr1+S0rFqa5mbdrHJqL+dFJOxCrF 5QcmGMZ6sOg571+0n/BGZb3S/wBr74ai72RO99LYtLbXIEEsYVZoifcMpGB1yK+A8TV/xiONiv5T 9J8MdeKsM32f5M//0P7+K/B3/gtz8c/iJ8DfBPw41nwP4l1rQJNS1KW2Lac5jgiZNn75sDnBkHyn g46HAx7nC+Ehj84oYGptN2PO4mxDwmHrYqO8ZX/E/mQ8Wf8ABQf9rwE2cvxz8Uakn2YBla9W3jVW 5wIwpDHGeTj0rweLx74o+IPii98ReIPEh1AT2cZle4UC4lMLh0Q56APwcdcn1r+nMp4IyzKMurY2 hD95yv8A4Hex+d0M7nmOfYf2r0TSXl3P7+v+CfmqHWP2T/hVdssSuNI8hxAMQ5j2r8vt6V7T+0RZ i++B/wAUrc87vBWoHGM5P2aQA/gSD+Ffy5XXs83kl/P+p+rcRQ/cVoS/k/Q/zmvEZ1S68W69Zwas lvc6jrsk1rZSyjy5YozsJEfQHIbjvtFf2t/8EYbq5l/ZD0u1uBEVttXZ4ZY5NzTLIp5Zf4SNgGK/ ZvE6CjwxgZvsvyR4PhteeQ4ub6L/ANuP/9H+9jxZCJ/DHiGEhSH0W5BD/dx5L5zXzj+xzIrfCe6i jwI7fxffw7QMbW/dFv5iveb/AHTbJw9nOS8v8z2H40iNvhH8S0lLLG/gjUo3KjLYa1lXgevNf5zf j+LTJfiV4m0lrKO6vU1O4868aAw2oXzS0YZ/4jhhj2Ffe8B884YuUdlCX5Hw3E1WnDNsJTlu3/mf 2Q/8EStRN7+yakbu0kkOskhyQyhSZQFB9sD8xX7C38TTWN7Chw8tpJEhx0LIwH86+Fk+bGNf3l+Z 93j/APdf+3f0P84X/goVY6kn7WvxYtDBHtm1+4vlS0l2m0QOsZEy8YZmDMc84x6184+Ap5bLx1oF 2ZpI9Otrq3m1KG3YAYt5Y2hJB7eZs3d8Zr+tpVE+Dq0v+nT/ACPwjhW7z2g/+nn+R//S/ta/Y0uo 739mv4WXUMy3EU2gB4pVGCV8x9uR2OMcVuftU2Ueo/s9fFqzlTzEl8GXmVxx/qmwT7cV7eTNQzyn /wBfV+aOPjr3ssxf/Xv9D/NQ8Wxxz61die3ezbSbtpI8SZjuzKzSk49PmAwf7ma8h1BmudVnkZFk E0pcIFwu4nOAPrX+gmRyvgoeiP5Qp6ySMN/DovtSuri5mbT7hJFW48k4eVRwATj0FRS2trPdSRQ3 M8ksP7qeOc9FBIUivYkvddwm/ft5mpbafFFAI7YBi552HOfpWzo8c0f2iGaAvEYWJtmbyzNgdAex x0NYVY82Ha8metg3acbd0f/T/pk/4Ifzyn9jrSrOR4SbfUjI0cRBMfmBinI4OUCZPrmv2MvI/NtL qL/npbvHg8ZypFfUY6LWf15P/n5+p15tG+XwX/Tr9D/OT/b00y4s/wBqn4wNPZ2zLD4juZZpBKWa Lc7bkx14YH8BXwRFYovm21qksr3dw0rCQZ3s3PHoPQV/Y+SwX1CEV0ivyR/PNWXJUlJ93+bL2k6U be70+O60VY7hbthbLMDALg98MeAe4xjqK/uG/wCCDjon7Nut2axJDJb6oonTfvmDbpThs88BlA9c V+SeMDj9Xwzi/wCa/wAj73gF+9Xuun9fkfuqwyNvY8H8jX+fH/wUwg0XR/2vvjTc3u2yv4fE1xLZ C4Y+Uxdw04A78NjH1r5Pwz5Z5lVT7f5mXHs504YZw6y1/A//1P1T/wCDevUorjxD8SIbXUI57YaK kaw26CO2wzhxtHUgEAZPcGv6pa+vzlKOdYqn2nJfdJmFDXL6ErfZX5H8c/8AwWTtv7O/bi0u6uVl RLi106+tpduSyAwKQvsWVh+Br+rH9nbVDrHwQ+GN+wbdL4Qs1JYbSdsQXOPoBXTnjSlhZd4L82eX kDcsPil2m/0POP24dH/tv9lT402QMQdfB091H5zbI90OJFBPuVr+fH/ghjey23xx8Y2GZGabSnjf a222RY0k4A9dzNXO6n/CVUTWnNH8pGqVs6pxvryP80f1eV/Lf/wVy8W+Lvg9+1/4N8eeEtfudKv7 jw7aalaPZEwTW0lu6IPmBGTuRmB469arKJLmqN/yv8jnzXSdK386P//V/t7/AGX/AIh658VPgX8P vHPiR4Zda1vRUlv54VCLO6/IXIHGSQc46nmuz+MniXWfBvwp+IXizw8tu2teHPCV9rGmrdD9wZbe B5FDf9817OCfJjYN/wAxhm15Yarb+U/ztv2uv2lPH/7RHjPXfE/xO1mC/C6tM1j9r3STW5mK4EW5 jsUbV4HH7sfh8Q3rR2REsE28bc/MBya/u7I6K/silSWyt+H/AAx/KuPnfEzfdv8AU519Uf7Q1vcx bO8rJkFdw+UYq7bxxPut/NeGCTLOY38tjkc817OMp2oORvlT/eqB/aL/AMG7s8c/wc8ZxpLIP7Ng gsI4HARmj84ujuB/Fjqf9uv6QDjjPrxX8G55U5uIsTJ7ub/Fs/qqpSSy2hHtBfgkf//WyP8AgrW+ m6R+3T8aHjheGWTXzbPNH+8jkaVIZRuHUHYUA/3TX6D/APBvhe3WnfG3xrpACQW91oTSIJH8yW6V t824ehww/AV/S/HbdXw+wi6qUf8A0mZ+KeDnu47FKPd/+2n9hHT8K/kr/wCC5Nimm/tT/D6/s7eW GfU/CEUt5dBiElaGVFUBemQrDJ96/GcqmnUml/I/yP1fN171N/31+Z/Rf+xW+/8AZi+EjblZv+Ea RXVHDpEwdgVBHHGP1rp/2pbWO9/Z5+L9rJnbL4GvUGE3kExMAce3X8K48FNRxkOX+ZfmdGdaZfWf aD/Jn8uP/BFC6Kftb3kFtJiD7Bf29wh43sUZgMe20n8a/sLPQ/SujiKX/CxUT3/4Y5sj97h3DSXb 9D//1/1C/wCC/sgg+MPwkkRGLN4YRZZgCPIH2lwOf9rd09q/eb/gnzcR3X7I/wAIJYRItudCItkk OXRA52j+f5191n1o4LA3f2f1Pn+FnzSzHyqHtP7RSeZ8CPi+nlrKH+HmqIY3+4wNpKDn8K/zQvEN xLJrvjHUrzTLeG7l1aeSOIFZlbciyIfL7bGZgD6AemT+jeG8ozyjF03tq/wR+fcX3XG+Ca/kX/pU z+5L/gh1eSXX7F2lJK7ySQa/KGaR97ZZc49uMH8a/Y2aQQQyzMCVijaRgOpCgnj8q/IZSX16ov73 6n7JiU1Rin/Kfy/ftIf8FNrLxh+1/wCDvhfr8k3hTwH4Q8YxWJAIDm4jnCSSytkEjcFGSOF56dP6 cND1nSvEOkafrWiXtrqOl6japdWd3ZzrcQSo6hhhgSO/I6g17ed4N4TE06UdU4Ra+aueHkuNji8D Kq9GpyTX+F2/4J//0P3h/wCC9vh3/hOPBHwd8MaRHFq2uNr9wsmjWkgk1PbIEMRES5b5ijgepxjN Y/8AwS3/AOCX3giy+H4+JXx08Em48Q65/wAg7TNVsTbTR22VK5J5XdsQngMcAMcg4/XeJ82py4by /KqcryUYyku37uMV/wC3aeS+fx3DGXVaec5lmU1aMpuMfO05t/8Atup+v037EH7MUpjK/DHTbfyg BGtteXMKLj/ZEmPzr6N8J+EfD3gfRLTw54X02LStHsQRbWcTs6R5OTyxJ5r89xF1RTXkfZYZqSqL tcxPirp6ar8M/iDp8gDJdeDNSj2lQwyLSYjg+4Ff5knxX0jTtD+L3xB0SELbRp4kurd3jTbLJFFM 0Qb8QBmv27wPqv2mLodGl+aPxnjany8VYWr/ANO2vzPUfgv4z13SPiB4QGkXGpW9imo28UzWDfYb a38uSFUOVHLbc4OeDzX+kl8NLp774deA7yXeJLnwbpksgkOZNxs4Sdx9c9fevD8cMLToZxhpwSTk rvztofrPCdR1eEm+02vwP//R/rf/AOCqdxeWX7G3xAvLDVr3RrmC7tQl7YMVnBbzQqgjkZbYMjpX +e74k8XeNr2W8TV/GHie5aPUrhvLOsyrDcRtlOTnPTPfmv6o8DMLRq5RVrVYJyU1Zteux+IcZVU+ Ia1C+nKrr5R3PEZBaO9ykMkYk3GQRAjeBwOffjvzVTTpX3SJEro4Pz5ysi84ye4r+jMRFSw7XkfI 4VXnGx/S7/wbn6/ren/HXxB4at9Vu10efSZTfWjyER3JEbmMEdDjHXqcDrjNf2r9Pwr+DPE+Cp8a 4qy3af4I/pnL424bwPN/Ifxo/wDBxjYxJ8cvAd8LNTKvh2GIzxJunO4ggn8G69gtfBv/AARduLmX 9uDwXb3P2aaxi1K2d02boVO19iMT1Ytjiv2+jNvwlnd7Un+h+aeHkU+PJWW1Wf5M/9L+/iv5s/8A g4B+L3jn4V6X8J7nwd4p1Xw817oV/LImnTvD5kkd1EAxwcA4fb6kfSvufDHBYfMOJqGFxSvB3uvm j4XxdxuIy/JZ18M7S9pa/lyzf6H4PfsPftU/He+/ae+FOia78RvEGpJqPiNYWL63Pcm32/PnY7cK 3A46YOMHBr/Qh092lsLGV3MjyWkUjyHq5KKSfx616virlmFyviCNHBx5Y8u3zZ9RwxGUuFaGIqO8 pN/hY/BD/gv/AOH9IT9nDwh4xSwX/hItP8Yw2ttqMMWJ44ipDbnHYBsZJ7j0r1D/AIIefEXxP49/ ZfuofEmsXOpvoGpR2FsLmQysq/vcPk+qhF47Rj0FceZKM+AcNNr3o1Gvk+Y5uFeZ57nEJbJRa/A/ ZfW7G21LSdRsryJZoJrSRWVhyPkOGHoR1Br+OLwt+1d8bfBv/BQKx8GSePdVg8PwePHspNKa8d7R Ylfa0YQEA9x04PTsay4YwlHEZTmU6qu4QuvxOXEuX+uGV0H/AA5OSf4H/9P+/K3lE9vBOpys0Kyg gYBDKD/Wv5sP+DjnwVp83wC8JeKrK3NprT6k8M9/bQhXnW3aJ1DygbgQJDjB5x7V+j+FNZ0+M8HZ 7tpn5z4vUYS4fnKS+GpB/cz+Im7guktY5HcSuLdc7l4Y46nPP51wksgM7FoUjVeHIGCxFf6CUI3R +JzfuL0RGl7HNcbJ7XdbQoVQ/wB5ueo9Kmkt7OURXNrM3llMEbduGBII/Su2xmpWTRUeP7M7Twy4 z96I8q3qarRq+q+ZLKCkCnYn7tVViD6j0rWMerIbsf/U/nijmazjFvNcrLIzEIdudo7D8BWTd3E1 soktruVot5M8YbIY9M1/rBa2iP5HXmYyTTTyBmbzN5yD6DtXQxziOMGWBBJjbuQYZhQTLSLKsN62 T5aH72Dnmrd3FHc26usqxS7sPERzIMdQahxu7kKbSsWNFc2EFyB5cn2iPy281ASf93/H2qrJphEv 2mRY40lXg9ScHp+lHIjVaq5//9X+dC42xRb0ZY2Xje3HHrUep38ht4omcEbRjI5kFf6u8iP5Ccns itaWERhL8+ZnIQjJHvRb2rWlxtDsTO2+VScqv0FUopKxBfvLdrdI5bflmbDDooHv/nvWbKGLkSKq /wAX0NCSWwF5JIdgIK/LgHH9atsA0EjLjaF4GMYx3qXC7uB//9b+bB7S0uG+WFd5fLsox5h9TW3M 0NtaoFBZkX7i8mv9W+Rn8ipqxFb3pmdLdI3G4cHHSrsOmL9nuklmFpK6l47qRS5B7cD/ADxQ4PoH NEqDTxbxRxSTG4ZPmlnY4De+O1ReXGwM/MyDCKo+VVA9qgadwvbq0it7Cyt4ENxc3J8yRpiBEu3I 46cmiCSNJiFQBz8ucZyBmqUWxSlbQ//X/nC1sQS2DQMUM+4GHI+dP7x/Adqy7S7eG3FuI/NRRt37 vmPua/1Zacdz+ROdW0JxBvMMrOwCvgqOcj3q35EYlXymBO777cFfpSJUrLUh1G4uHZLRtuzgC6Ug ufXI9aztk9tKjxFjlsZUZUjvmgbn2H3l49wymSPLQkeWh5Ce9Pi1OaW4liuYoGgeFVjYAAhhkEEf gKaTauiZSuf/0P5oEuXspJTNbtJFC/nRxRMMzegB/wAa3bEPdRyyXWFDP537sbRxnA/Liv8AV1QX U/jxz1JlgjmKvKhmjLHMedpUfWqVvptlbhpHijQKzNFIR++XPXDUOC6FKSZH5chKpCN4lJBlY/dG K1LC0aYJHK6l04UjgjHSocWldmkZNaMLySKykuLR3FwqjOYQShOM4/pVCHc6m6wwjROiLtZfqKkt STdj/9H+bK0glLPNJMW81txEnA9hW/aSvBDNbySskNyQCoUZXHcH/Cv9VXBPY/kcqS+VC21pElCr 8vmAbqSEHG9CGDDbgHAWs2mtGJySGXcZhjjljDZQ/M4/DIxUtigeUSqTIoUGWNT82D6VlKKS0FzI 0w1za28t5pLMZ7WYZ3Hd5ZY4w2fx4pl5oralp93fXt3OJhEXCBAsQIGWz+GcVm17kvRjpyfMf//S /j/8VaZEup3EcJ+YzeY7qcPKBwCw/CspDJEisEwudp7E19V4gf8AJX49f9PZ/wDpTPm+G1fKMN/h X5GnY7Xkd24G0BiDyKs39wpUQwjHHJxXxux9JYv6KsC3EqajHDLA1mzQ+aGDxyAHYykcdcHn0rok 024SO3inRcs/Jjy4w3SuWt8RtSjozvPD+lC0MKRxgvDeQXAKgiSP98mCfUdf1r/VX/4JEwmD9gT4 ERl/NH9iu6Sd5FYgqT7kGvnsxVs0wT85fofb5T/yS+Yr/B+Z/9P+x/8A4KMTrb/sV/tAu8aSo3ga a3ZZDhB5rpGGP0LA/hX8BP8AwTL/AGGF/bg/ajuPA2oagmjaF4ZWTWNfkhAivr+GSdkVFHAI5ycn gdjxXl8SVqlDhlzpfFzWX/b3NH9TXhSNGpxooYj4FG7+XI/0sf6MH7PXwD8D/s2/DDQPhZ4Btni0 XRLdUa4nVBdXsgUBpHKgDnHA7ZOK+Qf2pP8Agq5+yf8Asi+PpPht8VPEGrR+JoIUkurfS7NLpLYu oZUb5t2cEH7uOetcmT5ZTw+XQoJL3Ypu/V9X13bfod+fZtPF5rPFVJW55NL06L5LQ0/2Vv8AgqL+ y7+2B42l+H/wl1bX5/ECWDahGup6YtrazImdwDBywIwANyjJbjIBI95/a6/ZT+HP7YXwb174RfEW 13WWoAXWmaggzNp11GG8pz6rk8j8RyK0pxozxU6cEtEr+uprj8HWo4Cmqzvz3a9GlY/zHv2/f2S7 j9jP9o/xr8FtVkM40u98/S797XyHuIJl3xBjgBsLxuXIyGGeMDgv2LPj9qH7J/7RngX4zQ6Np+v6 ZomoBNT0y+kMaXEMh2SbD0VsEEE8ZUZwCSOfN8Jy4aeGvvFr77nDwzin9YjiVq4zT+5RP//U/tg/ ZJ/ab8B/ta/BLwr8Yvh+lxa6XrFsLe70u8QR3Gl3MQCyxYBIKg52t3H0rsP2i9HsNc+BPxb07Ure K6tJPh/qsjxzKCoKWczBhnoRivleGeWeFTiuyfqtH+R7/FNGeFrzoye12vRu6/Bn+Tn8WdLi034i eONJBEP2DxJPKpRgylZCcBfbKn86/oE/4N7P+CiHgn9mHxpefAH4q6A1t4c8e6s0fhbxtpiNdTWV 1cShfKuou0ZO0bk+73BDFl4OKcLGvrL/AJdzU/Xlbvfys321sacIyl7WNCLt7SDh960/FI/vI8Se H9A+IPhHVfDurww6n4d8V6JJY3KMoeO4t7uErvXP+y+Qa/M+2+I3wn/4Je+HLvwv8S5msfhdq2pt eeGvEem6cGvyWLExywggMVBCkIRgqMDHT0amXU8wwlJwV0nf5d/yJ+uPLsTWw9aTTfu/Pb+mfa37 O/7T/wAHf2pfCU/jX4O+Ipde0S2ujZ3JurNrC7gkHUNESTjkcg4zkdQQPzH/AOCwf/BMrwn+2R8N 7z4iaNDDY/ETwNo09yqxQJGNZij/AHpLSY3Bxt69xyfUdmCpYebl7NLlTtp6HLnNGphmqdXdK/5n /9X+bPxv4QvPCfivxZ4d1iK1jutC1640v/R2Z3UxEZ3kjqCcZHULnrXlF/by2+WQsySMcHOQPavA rR5HKK6Dw01OkprrqZ0TfPsI3Z65HSrwmFi4+z48s/MxznB5PFYQV2b2Ooss6jbxFl3bj+8SQdR9 MV+i/wDwTd+PMf7KP7Vfwz+Jer+HH8W+HIbl7DUNHiixdQ28py7Q4wGZWKMqnGdmMrncPLzSl7fB 1aPeLX33R9DkN6eLo1kr2kvwaP8AQn8K/wDBWj9kXxDoOnaq+seMdNuLmCPzdMl8HXIkt3KglFY4 BAzjnBHcCvrn4IftMfCr9oS31Gf4calqV2NLI+1RappjabLgkjKgkgjj1/rXRllfAyoQhSa5vQWM wOLVatKonaLZ/9b+rL/gpn/wTk8Aft0/DR1vkh07xz4Ysp59G1AWqSfbQF3+U56hgVGD3HGMhWX/ ADVfj58JfEPwe+JHjn4X6/G8Ou+CvEVzpVwsoOZ445nCuOT1AOBnoB614uMw7SjXitNjZVqcWqK3 3Pm5zJNM9zE2/wAo+W0f90rwRUExaRvmjJBIYxkZAI6V58vhOpaFeS5e3cmQ5Ruq9MHPGK6WxMT2 yuUY+b8pKjOzryfy/Wpi9S4/Gdb4TREujIoWGQN5byAbfM6gEnv7Zr+/f/g2it5E/Y51maXcX/4S u6hySNpw0bcY+ufxrws10zDBv+/+jPq8lV8vxv8A17/U/9f+++9tY76zu7Gbd5N5bSWsu04bbIhR sfgTX5Y+Af8AglH8IPA3x9i+O8WvX13qdtq51iDThp8cJaTJbDyg9DnBwOnHHGPCzbAQx+E+qyvy tq9vL/M9nKsUsFiniErySaV/O5+nHijxPongvw7q/inxHex6boehWT3+o3kn3II0HP4ngD3Nfykf tWeJPCv/AAV2/bH8IfCf4RTX6+DPAOmf2ZfeIdRtAlvdqLkyXEwjJ4QHaBuIOXbnisswU/7Hc4/E 1yr1ZWDw6r5ilL4ItOV9rXS/U/pM/Zh/Zs8D/st/C3Rvhl4KjSW309N19qbWywT38m1VPA6KAgAG e3bgDnvjB+2b8C/gd4gPhjxzrOsrq6IHng0fQpdUW2yAcOwIAPI6Z6/Wsssy2GX5bDDN35Vdt93q /wAXp5dWdGKr1MyzGdWmrcz0S2SWi/Am+D/7Y3wP+OOuDw74D1nWLjVTCZlg1PQptNVgCBgMcjPI 4+p6AkUf2zf2TvBP7YvwU174TeMESE3mLvSdSEYMtpcRBvL5/ukt+B5rpwksNX9+nZpPUxxuFq4W Sp1t3qf/0PTf2Wv+CNEuv/tjeNfhH4r1SeDQ/Aeo41eUIIRNbI/mRtsbDHChVynOWzkHkf21/DD4 a+GPhJ4J0LwF4QsorLRNAsY7G3VIVheby0VN7hRjJCivjp5fSqZ7PFOzjBcsVbZtpt+Wmnmm/n97 jK9HD5HQwVBe9N88n5bKPmtL67Pv0+Tfir/wUo/ZG+C3inU/B/xD+IVzousaTI0N4Bodxc2odTgq rqOTnjp1yOoIHqf7O37YfwE/anh1aX4NeMB4hbRVD39tPaNYXUaM20OEYkkZ7/X0OO+tDC0kpTS1 PAo4XE1uZ09oq79P+GPm3/gpl+wL4V/bf+Dl7pNxLbaZ4v8ADljcXejahNaCeO5wm8JJjDAqUBBB 5BYcHaV/nS/4JZ/8EgrHx58TL/xN8RLi9h8O/DDxTvmtwwlt7iSCVtkEauMj5oyAcdOeCOPF4l5n g6WDw+jqPk07Pd/LX7z0OG5UqGNnjaqv7Ncy9Vey+bt9x/aDZ2eieDfDqWtrHBpeg+HtMJwAI4bS 3t4yzO30VSSfrX5yeKv+Cvv7Cvg7W7/w9q/xQvDqWm3T2d1HZ6FJcRrIjFWAbcM8givY+r4XB4aK cfcgrL5KyPHq4urica51JN1Kkr+rbu/zP//R/uV+CXx6+Gf7QvhCLxv8L9d/trQpJjAzSw/ZbqFh 2ePJxn1BI7deK/LL/grX/wAE6PDH7Tvgx/i5pPlWPi3wDpkl1qFrFYrMurWyEyO5A53Djcf7qlu2 R81gKuHxdGpWwyTi7pfdZ/ifTVIVctx9Klid1a/o/wDgM+o/+CXng3TPA/7IPw/0DT7eCKXTprqx vZYovLMrRybse4XfgV0//BSLS9H1H9jT43vrFhb3yaf4SmvLVbiFZRHKo+UjI4/+sKyyPDQhgYpr W7/Mw4lxDljq06TsrafdofzBf8G6/gm1vv2h/iLqepWVvcHSbGK7tt6BjAzyTkYU+ny/TFf2xEAg qwDAjBBGQR6V4fDlKE80x9RrVSS+6K/zPTzyrNZZgcPfRRf4s/z+f+C4/h/QtP8A27/F8Wm20cP9 m2o1GGySIRgz70mOGHVWUAY9q/pi/wCCOn7cXw0/aD+CHhv4WWNlL4e+IngrQIzqemyQbLLUY4wI S8Mucsy7VyGA+9wODXPxBalnWErS25uX/wACVl9zRXClBVsnx9JaStzL/tyWq+5n/9L+5f4wfBHw P8bNO0LT/Genrdp4e1uPW9PlC4ljkjDKVzkHBDHvx1HPI7nVtV8PfD3wncanqDx6X4c8M6avmtHH 8lrBGFjUBR/wEfjXivDUXKOIktUvw1PVjXrTgsJF6N/jsWtK1PRPGXh+21KyaLUtD12x8yLzY8xX UMq4IZD6g4INfyVf8FXf+CSXh3TfiJpHxP8Ah6n2bRPH/iE2N5a2kMdrcWM8+XeNMFVJ4yOgOScD BxFSdOOArVYaKzZ1YSjD+0YUMT6eZ+2v/BOf/gnT8Of2MPAmn6jZ3F74i8da/pUFzqGq6syyyae0 qeZIse0AZO7sBjnrxt+tv2hv2pfg5+y7oGneI/i94guNFsNUnaCySysG1C6m2Ab22AgYGR3zz0wC R4GBp8tJtdW3/X4L5F4yV6sV200/rrv8+x8r+DP+CuX7D3jzxVo3g3w/8Sr+TWtdu1stPS80GSyt nkbhVaRm4yeM4wO5A5r9C/E/h3Q/HfhbV/DeswRahofiXSJbC5jdA6Sw3ERTcue+GyKuUWqiQ18D P//T+ov2nf8AgjpaeFP2xdA8GaHqt3ceHvifqn9q6GNPUWJCvJsZZedg2swXoencDj+pT9jX9jv4 ffsefDO08E+Ek+3atP8A6Tr2uzRqJ7mVsFo0IGdikYyeuOijCj4KjK9drsfT14Ww8WdX8cP2svhD +z7f2mmfEC618X15bLdx2+iaKdSKRuzKGYl1H8PYn+eOQ+FX7dHwH+Mniu38HeDLrxY+qXK5jm1T w22n6eDgna0hckH5T27V0zOSKvE9r+N/wd8MfHf4ca/8OPFaEabrVvtjukiWWWzlH3JAp6jsRkEg 8EHBH+d5/wAFT/2Er39iP4s3Og2/iG31DRNfvG1XRoGsvJlaOWUKFB9wwbIwvHHJxVWvD5HmOL9p JebPyX1uGaMx3kflG6kkEe12wcKBnP51z2qK9xDBEsrW1wJg5mB37v8AY2ngg81x1PiRrGNlZn// 1P507m1E1hJGxYnhX2D5nA6gfXFdFY3lvZXMFqsU7xSW4a23R7/KwoBViBx7Zr4GXQ9OmrH0l8FY I7vx98O41Z5Gk8X2iXME8W20XdIoBI6nqPzPpX+o58D7NLD4QfDe1jiWFY/B1jmNOVUmBCee/WvD oq3Eyf8A07X5n0c1/wAY0v8Ar4/yRzn7RnwF8N/tH/DLUvhj4pvLqx0nUbqK6kntIxJKDHuGMH1D H/PI8t/ZL/Yp+Gf7IWl61p/gK71G/fXSBeXOoRJCwUMGCKq8YGBj9SeMfRY5P3Ld0eRgXaU15E37 Yv7aPwm/Y38BS+JviHfXMms6nZXA8LeHdNRH1DVrhI38sfMwCIXAXcc4JzjAJH4nf8E+/wBhzRf2 rPiBqH7XnxTtpl0O/wDET+INI0hZorqDU7prhpSrsV3HYRy2AMEEckbePGyjVqww1Taaaf3P9D0M vc6EZYumveg018mmvxP/1f73NQv9E8H+HrvUbxrfSdA8Paa1xOyqI7axt4EycAcAKq9K/M/Uf+Cx 37DOkajqOlaj4+16C7067ayYDw08kVzIjFGWNw+Mgjo2DxXxNZctH5Hv0VzV0vP9T75+D3xj8C/H TwTp/j/4eajNqPh3UnaOCW5g+zXKMvVXTJA9eCevrkD8Xf8Agr3/AME1vDvx70G8+Ofh92tNd8N2 5n1y0giCyhSVH2iJxyBuCluflJJ5B+WcFJVsN7RbO+3qzbGQdLEez7WOb/4JLf8ABLD4f/BzT9K+ P/iVrzUPFV+pTTLO7nhv4SqlHaUvsyAZFJAB5Cjnpj92fif8T/Bfwc8F6t4+8e6qujeGdFQG7uvK M0hLcJHGg5Zjg4HoCSQATW1GK1MKzSSR+eth/wAFi/2HdTvf7OsPHWvz3wuxZtbHw+IZFYnGTumG B7np3xX6U+HfEGjeM9Astc0lxe6NrFoJoGmjG2eKVAcMhyMFWGRz1rm50sbGl11Zq6b+pyq9NEf/ 1v0B/wCC0f8AwSy0Lw1PrP7SfgC6Wz0bXNZa81rSVsjN/Zt00Ujl0QEJg4brjKrwQRx/Jjd3drBc SxWbPdJ9oMPmJEYzuBxnb2+nOPWvmqitTO6D/eH7c/8ABDbRbi9/ba8FJfiIxmCCWDaNzKY2LqXX sQynk+or/QLBzn6kflx/SvhuHNM7zBf3o/kfbcUW/sTLEv5Zfmfxhf8ABy1rcl78U/h74Ztruc50 qGC5iQeUkI2QysN/f5ZGP1bFfyw6pbQ2RkjhCtEyglmGdh74J/pX1tfdHxFN6aHnl9GsdyHAeJS+ RgcSNV5ILljuiIaMKHmJP3BwM4/EVgE3ax//1/57dQibbHIjDcoHKAAtjjmobe9LyrbylkWZgpbB JFfnU9zvTurhOGQ3MRlVoguF+XBYD+vFQ2yW8VsvlRLufLFudw49KgZnNdXyCSO4ZHVHMkciqQ6J /d/CrVlZyuY5reW9nDDz5F2kJCpH1rKj8AVtHctzwoshZnLMwJO7PPtWHPbQW1zbyWt5IRPG32m1 8v7rZOAT3HANagf/0P530kaayOnoxg3EtuX+IkYBP0qvFPcwWElvfXESxqypJK8YUKQ2AVB6E8DI 9a/Nz0AaG7g813haWP5VhcKdy9/pzVNWczO5huJWmYK7A7hHxjcc0Dcm1ZluFmjcI27A+6SMA0+G za4uGL4EQOOe9Gwi3dzR2IitIYFXfhN6jCn3JqrDI1hcPPGiwgLy64G8kck0k7q6Gm1sf//R/nPW 7aMSyOzyrK+xg3z7Aa6BLV7GLa0mdwEiISCFBHFfm56b0ikYV3+7uEeZ3jUEbnjQsR7gVtamYzaw gzGVCuAFXa340C5mrGNAJLSJy0mwSD5M9azRLK+o2RdnlVQylcEIAcZbI4HSgtTXU6c26XOntqcC fa7S1uvIujG4Owg8qw6jp+lZhuLWVja2TFLR5d4Qps56c/TJoIcm9D//0v5t9SjudKe8aIyTFSTH DEwdXx2X8qiWaZcTSQFcruZlHyg1+bnoGtBqUt1bs0kjYceWzoMqAOPm+mKtbESMRRbZMrkYOd3e tJRSQeRkSXVxHLFbmHHmNtYkdBW8+ox2XmPKhdntykSAAgNjg/59KiL5WBnWF/NM8EjSmFlbDpJy p5610UsjX0ckcsNiIGfzWudg+2s/QAHHTqfrikB//9P+dm2kXSzGslwzoWLgDlk64B/SpLjUReTJ Gc+WwzLKedqj/PSvzc9FaMzxqpS5SGKMfuwQGkO1xjoQKtyXbX1jLHcsqzRPvidf4uehqJ7Dk7sr Wd24Ty3j2ADIIHOaZfTrciKBrbzI1O6RwfmYg8DHpWQR1kSWNwtzdsrW8SRABI4pBtVSOOcmp4bK 0EtxaNHYzMMu6nEjgN3B6jkdqDY//9T+d2PR/sltIY9q/MWyOMjt+OMVj2kCpdSKVESsm5kB4Y55 P481+XnsHRXFvFPbWtnprefqbJkRng59OOw65rnLu+nJSGeIRtCvkttYtuIzn/PSto30A0dPLTM0 /mQGBIhH9nVwBuHGTznNLfR3McSTxxBxyHBbhGHoe4x9Ko2jK+g23SO8kzJsldwPMEmAqH0GayLr zYpCtpEHKv8APG3yrGv+ycYP+eaqMXIo/9X+cCOY78SxK6SfLKpXcP1qeRbCedJ7ZVheGLyMqMYx wQPrjpX59bSx9ANtI2nWdZE8qQZ2SbcYHODz9KkhvreAtFcSOp+6jBclzWLTQrq9irbzebfQxzS/ 6E0nzsU3SD0P+c1n3d3iWd7iDEMD/unjIcsB0+hqeVJ3Kjui9bsZ4X8sySMR5i7ySRxzU1vqX2I5 mtlmd0aMbgSVyMce/wBaGk9zc//W/nPvbANbI9qDJFIgd1PBQn+E1ipb6hFqcSC0HkuuCY5N6rtX qQTk5I/XtX5m4dj6dNPY6SaFJLYTXMZRUY+U5GMsPT8/1rnk+1C7MhlQ220r5IXh/TnqKFDuMoJL dwLeRYUYn8xH2/OiHsPoP5VftFQZnu53niiff5mNkkijnLY4z64rQmWkSt4kWbXorebSNcudMiS5 WeOWGFZEdQMEYPHPHNU40vbGVWW/aS3aMLJb+UMEgnLFvfj24oMr6WP/1/5xJ9etLQJPiL7M0ARG u0Dqj7cMeeOCciuZtJUlSVZj55b7t00QjMmTngAAelfm59ND4Ub2mSrCJkaJXZI8RnHC89f0qGGX 7fdX1mPMjkgCybSvyurdx+o/CgmPxsvy2wa2ltdvyldodTtcn69qo2dvLG0T3mS0Y2hDIZEQAngN xxWUm72NDRjt4r6QRCTy1R96IDtDEdPwqSaYQ3BgCRELDiaYAYxyBz68GlZ2A//Q/mpuEiiAa32L N5plEgOd/pkd62o7iyutLMkrut3D8kkUkW0Pjqyt746V+Xn1FiLSbq0mu4pQHFrCrCWQJhR1BHPP /wCo1BfarCilbJUuZi+IY3OE69zzj/61A7MNSP7u0mVQsskflTbeduTk/h0/Kqlysly4aWd3jVfl Z34TA7fl+lXFPm1NYr3Qi0t7wxFJPMnEga0ljO0x4PZvfofY1rlJ7lvs5xEnPmbBnOB09u1bwXvC UUpH/9H+d/TcWMUpFkJVZTHHdEnajkdj6gVD5rQyqkv2iOSSWPy2t0y7EuOh6DPTPoa+Iwcb14Lz R9fiGvq0vQ+4/D/2qa8sLzSLb7RZzXiiGF7gJNCnG4sxyPX8a/p4/wCCQ13bT6Lq0V3JNdfY5TFF 5+WMXk3MhDofU7uPx9K/pDxKXsuDcFT81/6Sz8q8Nnz51i36n3h/wUI1ewsPgxrsnlwtLc6TLDEb tOJWCOEU+oO5vyr+JzUbVby41E2FnPcwXdxI729pG020oMBVxnKgADI96+48BqdskrPvL9D5PxXT lnNHyPyW/aht9T1G8S5sojaXFk8jpbqNgMOMyKy54P3SDXw/JFFMT5+9XI+6xyQfWvy7xQTlxXiP VH2/CkeXJqZ//9L+HW3N1ayxt+9vCE8mMn5nRfRfTiu/s47V0VZbNLhGtiI/OmKPaPgDeAOpAzgH 9a8/EQ1sB1GlwyW8s19CDNpc8aWKSTQhSkkeGdl7A9Bxnjua2prm6nltJftkj29q5URMdgYtj8eM HgeteTWVjohpY3b3R47qTR20sNLYtcr/AGyJly6bs/NGR024HWvrrwUI9O8Ox6Pe2rXXlzv9mkll 3yjzNpIK+nIrzayNoK1Q6m6smsWs4hbPbn7QpjheEN9tVhkqAe3X8jWTquiaerb7NkiupCxdN23Y R2B9a4Zu0jrTsf/T/jvkmjtbV9XvPLfSmuFsfMVh+6dx8it9TznGMVmf2BNeGZ0iitp0USRAMY1b upUe4x+dfPWSdzNaSt/XU9o8HnVLbw7Na69rhtLW3tmlt7KKV5o+DjYu37pPXn9awNVv5rU6VaW1 xeNZSXIB2SGOGJWGd5J7nbUw3bN5NWSOys7mymLGckL5oTckYczoByW+vT6flXl1xpmr6Jrl9pPm fY7Wc77a0j2mBw53IQ/0I46DNdVPoRfUovZ/2PBfSyy29zJcPifdMpfcOVXHXAx6VwOo29ndB7i0 maKZ3KTReuRywP8ASvTopcpy1pan/9T+K/w/aTQ30VuypJEzEzszFAQPvFf0H41+i/wlvA3hK1aB /s88cMMKwOMmHy02YU/3cr/Ov3TwJly8SVF/c/VH5R4k+9lNP/Efu9/wSd1mBvjhosLRDEL+ZPag N5Ud9hdrvJ6MkiEdulf2qazZzap8OILXc4uZdJiZ3t2CSFjCVO4nqMErXB47QcOLqNV9bfofpXBk VPwzS/uy/Nn8IX7eVtHo3xo1u41mFUura5vLNHicxKFRkYBgRhhktg9sH2r8+li03WzFcW+FSdfM 86P5VGRn5SevWv6w4PlGpw1g3T25EfxrKM6VarTqaNSlf/wJlPV10u2u7XTobppLgR+bNLE5jiiH QAsw68E/hXMfYJpbyN5/4JCpdDjcueCSeOmPyr6h6QOeUrJ2P//V/BOxtpPtFxqOnMy2TAoVmky5 2/exnHcfy61Tu7LU7+US2wijMX7z5yCW2nsM8+1f6cH8RTk+VI7/AMG38Nn4j0XUriS41O5sby3N 2k8pheENcxjjqTtOMf8A1q/0y/8AgnGbZv2QvhO9o8TQvpzuPJUoiA42qR6qu0H6V/Ln0hU3HCT6 X/zP628HZN8CY/yqr8kd9+2nYf2h+zb8S4RIImj0V5UOcMzBWVQp7ElhX4A/8Eb/AI2+Obv416l4 F1DxZqr6HOVsX0WWYy2RbMjZ2tnGWQjjHMmTyFx+B4TDqtk+Jn/K1+aPr+Ha7lxXLArVToT07tJ2 X32/zP6pHRJEaORFdHUo6OoZHB4IIPUH0r88P2ffDOleDv2qvjbpmkWMWlWd5bStFZ2kQgtWIuEl GEHQBXHtXgOco0rLb/gnRhNMXJLtI//W/vyuFdredI2KyNCyxsvDKxU4Ir+HL/god+0d8ffAvx2+ Idp4c+IfibRLO2vzcRrBqM7MLdpiGYRZI+V1k6DhcDOK+q4NwlDGZvCjiV7r/wAmfOcTYurhacXR dm7/AKf8E/Pa6/bP/at1E3djo/xq8aalBA3mTSaM0yXcXyguzurCTC7gCMkc0t/+0V+1xe6TYpqv xU+NN/pEVtJcSi2/tD7JEkgIlFw5PzKFBByCvWv39ZBw9SUYVYpNa6nyMpZni8MqsG3HyPB7nXtf 1GOzadNd1LULizIgtGtHuNSljkJHzIACSccA88dK/Rf/AIJq/te/F79iz4m2+teKbTx7qHwk1S5W DW9H8i4SBIiAplaB12FlGQQCCQo5yq46M/weW4zJ55dUkk5L3b9/Lr9x6XC+LxGFrxnKLdFXUktr H9WHw0/4LC/sXfE3W9M8M6Z4x1jS9d1B1ge31fSDZWlrIeqPMzYH/AgPfFfo/wCLPCvhv4keEtR8 Na9bQ6r4d8R2AjnTasiTxSAMroSCBkYIOO9fzRmOUY3JcUlW9U/T1P0GHssfgHiIa05Xi/8AJ9v+ HP/X+rv+Cln/AAS3l/ZrvZviP8NIGufDV5qa39p/ZuVa3LOcxzwkbRgnGFGMBSMDKj9uv+CJ11dr +yjaaNfKyXWl6nIsysuzGXcKMfgx/wCBV+p8V57RznhLCtK04tJrrpdGvDlB4LC4rCp3Vlr87n6y eO4Dc+DPFEAXfv0O4GwkLuxGxPP4V/ncftG8fF7x9pdzf3clza+MtS+z2yICzQrdSR7M9Scpge1c /hk7ZrV/wnx/EjticNPzZ/Tf/wAEELxP+FP+OdIS2js/7OvI1eBGLOxMjPvYdj+9xj/Zr96fE0Ym 8OeIISARLol3GQeAd0Egx+tfJcUK2f4r/EfoGb/8uX3px/JHyJ+xTdwHwx4+0tEjjl0jxi1s4Q8M ChwcfXdX0t8VrI6j8NfHNiIY5zc+GLyNYZf9XIfJYgH2yBXi3tWv5nnZn71Fp/y/of/Q+vf+Cdcl 5oH/AAUC0Oxv5JLa403xTdW915RJjBEptniGP4CZf/HRX9nYGPzr6ritJYuk11hH8kdNCfPw/hF1 XN/6Uz+W7/g4M07WIte+FUmkTQWCaxol4bi9kB/dyW7RKme3zB3A90r8X/8AgnfFNpX7V/w2vtT1 KFZLObzIorfcBIytiUKP721mb/gAr9Z4Wiv+IdV5rVtSX4H5rwlW5eP69KStaf8An/w/zP8AQnsp xdWVpcjOLi1jnAIwfnQN/WvwZ/4L3+FrnXv2fvC99BsiXRtZF3JMkwju9o37wnphC7Zz/DX47wm4 riHCOe3OfYcTJzwVeC7/AKn8YV7FbXl7HfIk32JkEun7rh1llTAJJcHJ/PvW1ovi+60q5M4uL425 kiSPbeSOlmPMUE/MTx2OORmv7UpZbhsRgHCUVdxa/A/H8FiJ4bPITlJ8qnG/pdH/0f6+f+CY1xDc /sd/DVoJnnjXzwGd/M27vLcKp9MOPzr6W/aLtFvPgd8T4H+63g+8zx1/dEf1r2cbB0c9qQe6qP8A BnRxlaUcS4bOD/I/zc/HdjcaL4x8a6Na2nmHTdXnlEMrGSW5JwFP1+QD8q6D4YfsvfGr43PqFp8P vh5q3ia8XyzqH2MvNp8QkAzHvVfvjOMDHbntX9n4bM8PlnD9LGV5WXLH8kfh2RZVVzDELBU1d+9+ F/8AI9z8T/sJftG/Du10bWfEnw81fQPD0F2keqz3dqyJakOgiRTyfvDr7e1f27f8E3LgzfsifDGJ wouLG2k0+8CtuxLCI1fP41+A+KOb4XOMNRrYV3s3c/WeEcseVZXjMNVXvXT07a/8A+hv2hbQXvwV +Jdu0STxnwhe+bFICQ6m3kUj685/Cv8AOP8AHD6pP4p8U3t/NcJpKz4jgM0kEMZ5ZipDDOBgZPPH 1peD+Do4rMMROtG7jFb+b/4B8VxtiqmHq0or4ZJ+t1+n6s//0vlP4Y/stfH3453thbfCvwLqviG2 eFbgzQwXfnOkgVseY5VQQGBJycZ4r0f4n/8ABOv9sP4RadqOs+Jfhhqd5oa2ou79pVedLCOM728q Rzkt64/Ov7D/ALZ4Zy3N/YVElUbtdW07/wDBtc/IsdlWY/2HDHy+C17Pe2lmfn74g1GO4Nz5ML/a bJhbzwzQMk6MONjoeRjn9a4a11CVrhpTHtjYFAiLhVPIwBX7VgYxVCLi9D8wVS82+l3+YzTtWk+2 Xi2R8i4Rf3VxLGHGT12rn9TTJLi5MhmuF82SQkyuSS8h9q9BwV0yVL960dL4b+wyLIb5LiKUHCwW 8XmDGf4lBznjIFfqf/wS08S2I/bD+GUFjHPAdI1cfaHa3aJXZoyw3hscYwMj1r868TFbhPGNfyP9 D9N8MZtcTYZ9df8A0mR//9P+/ZG3oj/3lDcdORmv5/v+DgPSZbz9nzwVfRW00/2DxHvk8tMoVKuu 0t0XLOlfS8Fvl4jwcntzo8TjL/kVYlf1ufxZ64qPFbrPZ/ZbqytwhumkLSHJHyFuhxx+dWPCtwLW 7Tzw88ci7HXzfKWJdwO4E8ZyB+df244RllNRLqmfieSSlHMqUm/tI/0SP+CYoC/sbfCyIOjtDBND JsfeqlSuBn6bfzr6z+M6JJ8JfiRG/wB1vBeog5XcP+PaTtX8MZguXPqi/wCnn6n9H8VrkWIS/k/Q /wA5PxfoH2rxtr2kyeW96+rXC2MlthEUBFG5X7ZIZvxr+xz/AIIm6j537M0mmCQSrYXoYvtCMC0k 6lSPbbjP0Pev2TxRv/qvgV2UfyR4HhpBR4WxTe7/APkj/9T++PXo/N0PWYv+eulXEfp1hcV8tfsd SMfAfiqFgsZj8eXkqxKMBFdIgOPfYfyr15O1NLzJwyu5Py/Rn0L8RrJdS8CeMdPfAW88N3dsSRkD fC6jj8a/zmPj3BPp3xn8baLBZT20CeIbqC1mMbG1YxExhCw6Ljb19K/TvDjlUsZF7cjPzfjGE5Zt gZR6S/r8j+sX/gg9dkfs1X+luCs9pcpLcIG3RqxeRePyNfunKMxSDJGUIyOo4PSvzmfu4uVt7/qf pOMfNh7P+X9D/O3/AOClenW837cnxwWOR9NWx8Y3CrCqFVvLeaCzuMhccYabIycYr4z8O6ZFe+Lb S2068kh04EB7yeHq4kQBGIPCk9fav6ylDl4Lqpf8+3+CPwXhGf8AwuUm+lQ//9X+yj/gn3PHP+yf 8K/LdZGg0praVl6FkYA8duMHHvXuH7QFo178EfivbKu95vAOpxRjnIY2koB/DNe3lsVDOIP/AKeL 80cXGDlLL8VFa/u3+R/mS/FHSNTtdT8SxXXnw3VzqsttYthv3GwAOBj6NivGLaO5SwiVpTJNGxXz 25Y49fpX+gWQWeXwkuyP5RpJxq8r3RT1G48q33QSbbl3Ak9ZecH+v5VQeyvTA8lqwguHVVuDIuZN mQeCec4r6GavFol/GbWmWTwzQW9hcyLESHNxL8gVhgtxycZzW5LLsjuJLwSSqIWQsjlSTjg5/A1m 4r2TT7HpYV2kmf/W/c//AIN8fjR4T8UfAPUvh/Dd/ZfEekCO6k0y52pI3zvvCc5OA0bYIHDjHcD+ ihl3Ky9Mgr9M8V9znuFlhOJcVSmrWqP8zqxc44jKqFWDupUl+R/Cf/wUt/Z++IPgD9pr4ueIdb8J 6kvh7XfEc2paVq8OnyX1vLDPKPJBOMFSz8nnAA+tfnR8OPgf42+J/irTfDPhTRtV1a41O9EVxe6R YsUsEVx5m08gMw+XJIxnOa/o3J+IMLguE5ZlOWkIW66yVopfN2PxerlVSvnEcC1Zylf5PX8D+zv9 mX/glL+zbpfwF8OaJ488CrqniLUbX7dqF1q1hEL21mdAoZdyl8gAHcTk5PToPVf2Hvg/pPwA+LXx 1+FvhqWNvDWki3ubGGNGjCnzFGQpAxhWCnGRleCa/nvOs7x2c4acsdPmalo/J309Ox+n5bl2Gy6s 4YaNk4/irfifpxX8DP8AwVj0OLTf23Pijqdzp8+uI+vvJDpcsJeOzkkjGSoH3x1PPQydDivd8NdM 4ld6W+8+L47lJ4fD2WvOvkf/1/0q/wCDfzUrJPif43tYLeG2nuPD/wBnvLGO3+zLasoklDBT3yQp x0x71/WdX1+dR5c8xUX0qS/CTOOhUcsvo2/lX5H8iX/BcSxuD+1p4AkJRYpdGsoo0PUCWcAsT6ZQ n25r+mX9k+5juv2efha8Q+SPwxDACM/MEBUH8gK9LiaioxwTXWlF/izxuGZt0cZfpUkvyLf7Uenw 6l+z/wDFe2nOEXwfdXABG5WMaF8MO4O3pX8zv/BFO4ij/ai8a2sdzDHdhnWDTzLtPlKLkT7VzztW SP8AMVwqH/CHUl2nFf8Aksv8jbnf+sdOL/59v/0qP+Z/W8RwR7Yr+Uj/AIL6Q39h8afhJqatKtm/ hrZII1ysivc4GSOhBjfj3rLJafPWmntyS++zsTndWUI0uXV+0j919fwP/9D+yX/gntcpdfsj/CKR PM2rofljzV2vgNxn8CK92+P0fm/BH4spjP8Axb7VWxjk7bOZv6V7WETjjYP+8vzRw5rJywdaPeD/ ACZ/me/GO1ktfEfifSZI4w0l08MckThhatEwBBXtk5I9mNeCC5RbSSK6DyNbyYQIN2cYPFf37w3F Ty2LR/JuLk44lxluYNw32+6tpY3lgY/JIuMbgOma7rTwkl9pNolt5/nXKRTGVxHGFJAYljx0z1xm vXzGly4SUjuyqf8AtSR/ZD/wby6on/CLfFrQvKiR4WE8jxyB0JS4SBVQddoVCfTmv6XD29jX+fWe QkuIMQv77/M/rWcl/Z9Hty/oj//R9B/4LJeFdEg/bS+KyvbvFeLNBqkV1bkIkxEduzGX1OwhP+A1 9Bf8EEtfgH7UOs6dHaqv2zQGjEryZkDJbbgQO25FOR7V/R/GVS/AOF/xR/KZ+K+EcFSzLF0W/eV/ w5D+zQ9D9K/lP/4L1QSWvxz+FGqrAJEj8Ihd2/7zNcgbSv0iXn/ar8ay2Eo1ppfyv8mfrObJN0v8 a/M/eT/gn5dR3n7JXwinjjMSnQtojJJK4bGMn06fhXtP7QsPn/A34tRgkN/wgGpNGQMkOtrKU/8A HgK4sEubMIL+8vzRrn9oZbiG9vZv8j+TX/gjBF/Z/wC2pdRJceZbSrfeV820vuHlqSPoG+ua/suP Q56d67eJfdzyqpf1sZcPR/4xjCSW1j//0v1j/wCDgCKKb4g/B6OM4mbw07SoF2hjHdPtJbv/AK0Y HbFftN/wTXmD/sdfCOISrMbPTGsndW3jcm3cM+xOPwr7LPlJYDBSezj+p4PC7jKWZKPSo/1PqH40 iFvhB8UEuIhNC/gHVklibO1w1jOuOOa/zPvHawxeNPHlrPCsVzHqUiTWsOQyAIVIU+xBUf7tfpnh RS9thMXD1X4I/N+Oarp8ZYG38i/OZ/an/wAEIJEH7IccLOftDat57w5yEU+Zgn3OfyAr9t5wDBMD wDEwP5Gvx3ERcczqw/v/AKn7Zi1bCU5P+T/M/wA4v/goVZ38v7YfxMtmmSxSHxbfT6fdKRHcSMrx shD9Nyk7ueeavfDT/gpp+2/8F/Dq+EfAvxnv00G1YR266jbWt3dBQu3arvA5A+p7V/T8OCsuzzCU pYiNpqKtJabLbsfz1lPEOPwdepTpTvByk2n6vXv+J//T9q/4J0ftH/FH9pj9tX4WxfH/AFuXxzLP 4hiZpruFTaxs6yGMMoRUPKKeB/B7V/cVDDFbxRwQRpDDEgjiiiQJHGoGAABwAK/RePaFPA8QTwFF WhTXKl6WPJ4UUqmQRxNR3lOcm/vZ+HP/AAWG/a7+M/7L0nwvX4Xa3Po8HiHTLy6vnt4lceZDcQRK X3KeSJDt5xhWyK+2/wDgnN8cvG/7Qf7Mvhf4gfEG9/tDxLcXs1ndXZhWCWYIEKlgvXhs5759MAeb nuXQwWSYHFxfvVU2+2ijt9/4HHwrm881zLNcJKPu0ZOK8/emn/6SfZnjFDJ4R8UxiPzS/hy+QRFt okzayjbntnpmv8yb9oTSriL4o/Eq6mMMWoR+LLy0Ex5Yln37Aeu3PIr9T8C2nisU+tl+a/yPzvxD 5oZ/g5LbkkvwZy3wq8RXOk+LvDNvdC48u71SG1jZGxaxt5qMCw+it+ftX+mt8FJvtHwh+Gk3nefv 8E6aTNnd5h+yxgnP1Brl8fIcmbYG/WL/ADP0vgOo58I1YPpUv+CP/9T+tv8A4Ku2Eeo/sS/E+3kk 8oLcWFwJMldpjuN46euMY96/zvvE+l6kn293tbiKSS6ktYpYbZzBlQcSE46Eck1/WHgdWhDIKsJO 1p/qz8E4uoVP9bcTOK3gv/SYI8pvbC4t3hW3jX7UIvNulEgVzgZJC+hxVKytXvpbi4ku5o5WVTIV fZI2GA2DH0r+h7Xov0PmsHO2IVJ9D+h//g3i1S5k/azvLb7TNFbvpt0gt2H7ucJEAD+DF8fWv7oq /g/xXjbjXEJdkf05l3/JO4Hm/kP48/8Ag5It0j+J/wAMLhJQk0ng9QACFOftRXBPuFA+hr8x/wDg kTKlr+3B8L7Zoj+/1yzdDF8hZxI/PoeARX7HgJOXhNVv/wA+5H5rwIow4+qQj/z9l+TP/9X+/iv5 f/8Ag5Ntm/4V38IJYIIpZ7xb21EmD9otkiuLckr7N5//AI5X6P4RQc+McKl/WqPzfxrqKnw3Vb/5 +f8Atsz+a39kXy7L9qH4RSOZVlXxRbRo8HyygCePdk9hyAfqa/0v9Ebfo2kP/f0y3b84kNex4zJ/ 6zwXTl/Vn3PDDa4Ow3N3f6H4yf8ABdy18/8AYz3qGMkHi+EoqjO4FG3Aj02gn8K8n/4N+7qWX4Be ObZuY4dYgdD3GWuEI/8AHD+deJjkv+If0X/08/8AkjHhVXz7OV/cj/7af0CMAwKsAVYbWB6EEHNf wx/EHTVt/wDgqdcO9tHJbr8UbqeNAuyPYZHKZX/ZPB9cU+DE5ZTmv/Xp/kzzsZL/AIzDJ0v53+h/ /9b++rTGVtN09kGFaxiZRjGAY1xX4Pf8HBcM0v7I1liXyrVNZd7k7Q2CPK8sfj8w4r7zwzlbi/Cf 4mfB+LKa4cxP+Jfgz+DZ9YZNJtxLAhFzZQykzIGdQUDAqf8AayD9CK801O7tLjd9nVmxIUk+UqoY fz+tf6KYaLcdT8EqNqnH0MrN1CUMKLKm8JJvOBHnP/1/yp09ztQReZtUMWKjuTXc4JsSaexbs5bY gRXCl2YFgdpIAHH9asfY7SGI/ZztRyZG7KCfSrSvojKe5//X/nVkt9s6umWHmAksu4VbjiXzZ4Gt dw2+azFR5e09RX+sFj+Rk7q6Kz2yFWa3gQL9wBEGFx6DHHSsSeTdcW1vN5sUqylQ2cBhgYGPXrQT N2VjXaM24SKBAxPzFmGc1F5SxWzzOPOuBkKF6n/ZAoMizAkSpZBY0VoUO6J2JU5zyPQjOPwrNuLq e9nSKJtkccgBGOEweSaClJpWP//Q/nV1i5sJ447JLMSMyeVOZGyrA8Men8qgPhwG1t7pVunWCLy4 lUsyxxjgfL6Cv9YLH8fmvDaLDp6DLG4blzIu1l9MVjTIyzK4yzp1Cclqdna4GlGsN/AbecSJGRhm B2uMeh9a5NtKuNPDKkkl2GlJUyt8wGePahK+iAjRJUuBvYwoCDIh6VupcxsTGrkQyJsLA9jSA//R /nJuLKCO1P2aaRZQ4KSrg7hnng+tU0vraI9N0g+WTdyQfev9YD+PyWEpMZBH/wBdML1Hf+lWLS4m mt52kIDQyH774KopwM59f60AXJo0njErOkSCL5uCwlP096quLaWFmhk2R42HHygY4osnuNNx2Ma0 08/adu5ZQBiKRiFx16Vajj2yj5/mVsYxjFAnLW7P/9L+copYSzLM+x5EBRGI5B4B/PArIvE8qSNY 8RtKxyoGQR3r/V+Ubo/j5tLcvp8sR8thjHVqypriaNS627y4bGI8fL7k1Hs2TzoHLyRwhOHEm593 oetAT7PE7Q3IaSaXc6E72XjoPQcfrT5EJzfQSS0vLj/Vv5DAqxkADhgCCRz6gEfjSSW0ce0CDaoO 5xGSS5PJJqrLYhtvc//T/mouLKeaNFjiZY3Qt5ueV7Y9c1qadG/9n7Edm2jarsCN31r/AFgP4y53 e4yZphtgDhXUYBjO3P1qgJLh+JMkodrAnO4DvQap31RK4uwsQVFW1lQsZy+1o/bbVuC31ONUlsrl Y5APlcjzDj1/lQXCXRlLSbK6jd1munvpjMZZmlACgk9vQV0ErzWEzPJCqwzLxGq+ZkNnk1k4+9ZG p//U/nMv47doH8hh5oj/AHMP3VB7Z9qqXcN8YLWZl2Qoohklj5AI5I/Wv9XJQtqj+QG29zDm+eUp vKtnBZgTx9Kma9W3UK8iRJ9wFiF3HpWTV0K6W5oQxTWtpEGctA8h5diwJPUAmtuBVsSZIwpWaPLj Ocen0rnavoK6vYwo7q3tr2fyFmeSY75d+dpNaLXOsXcVxZwbEFxEw2TcRxgLnP5ZrCpdKXoVTlrd H//V/kH18hNavlWYzSmQEk46YwBx6YIrOmQkxluybitfV8fxtxbjn/09n/6Uz53hjXKKH+CP5EKM FOIi6gn5mHQc1or5by4Lc7M5PAOK+MlFpao+kVrM+hP2aPgr4+/aC+JWi/DbwHop8RatqV+llGjq 2VMxIAZVHMaDLMfReuMmv6Yrb/g2g/afuPh/p/iZ5fC3/CQLphkbR7ZpRLtK71xGVXcw6AjA56V8 rnGY1oY6GBwavNay8lb/AIN7em59ZlWW0I4B5jjnaD92Pdtb/lb5vbRn4cfGr4BePP2eviHrvwu+ Iug33hjxVojxGZZIW+zXdstwqiSMnkBsHr/9av8AS9/4JPQeR+wX8AFwFLeEbeUgerW8OaeYRbzH A331/Q9LATpT4ZzCpRd4txP/1v7D/wDgpZcR237D/wC0G8sxt0PgtozMF3bCZogOPc4X/gVfyhf8 G31vPJ+2V8S7nExtl8HyJ5zKW8/F0uwM3bADED0Bry+Jf+Sdgv8Ap5H/ANKZhw6/+MtrW/59P/2w /umr/Om/4OCgjft7/EaNnie1u5oTcMSzzW7x21uiKo/h3eUfwJrrwf8AAlf+UnMk1iaXlM9i/wCD aaSS5/bM8TQzLgaf4alMCcsiIfs20r6cscj3r+/evncnk5Y7FdlK34I+3z9/8J2CT/k/zP8APK/4 OOJkuP28tQs5IoY2ttOhjWURDzZYWsIpjk45G5z9CDX859xK6SX0djcJcRwL5kkc7BDDGOZMY74z ivczuCjLXsfCcDt1KMub+eR//9f+jD/g33QD9gHwfKdxaXVrqQuylc5uJ1wPYBEH4V+uPx3dIvgn 8W5JFLonw41lnRerD+z7jj8a+T4Rv9Tb/vS/9KZ9Vxsl/aEo/wB2P/pKP8l/4zXKnxp4tSOSJp31 eVY5BCfP4kYku3cZPH412X7Hk2sTftLfBywSVXU+ONPIjjTblWuY1bd29P1o4iSUK7faRz8I6YvD td0f60XhBPL8KeGEIwU8OWKEDoMW0Yr+eD/g4/m+zfs9fDGX5/3niW6t2K8KmY4mRs9QcrgfU162 Qa5bTf8AcX6Hi8XO2aVn/wBPX+bNv/g3JiaT9lTxXezQpG8njO5itnEvmySxAxglvT50OBX77/EJ gngHxw7NsVPCGpsXK7ggFlNk49utcOQPmo1G/wCZ/mz1uLH768qa/wDST//Q/BT9qBAPi78Sb23a O4srzxPMRdg7C05PzEKfUbT+dfI13L9mk2ly6tyy9Qhrw8Qr1ZrzZz4NtYaHoZzSI29w21Su1GHW pbaSOOIb0DMXAjIOSPesYQsz0E3yt+R1NnJsngS0W7mV3WNnt4PMJZiFCgc87iAM+tf15/8ABFr/ AIJCeKPH/inw78cvj34adPA1ppMOpaXZasjwXEkjIrxgRMihgwZsk+meR935/N67jWhgKbtUrNRX XTVyfyR9pwtTpwpTzGv8FFSl2vLTlXzfrql3P7CIf2Vv2cLHTobEfB/wGllZQCNPM0WJFjVVxuLc AcDkjFeh+Avh98N/A1pPH8PPDnh3QrO4bbP/AGBGgikI7FlJ/LPYV7tDL6dGEZx6I8WWOr1pTUr+ 89T/0f79zjBBGRjByMjFf5Zv/BUuW5l/bY+P9wpH2Y+OLxHfZ8/yyukeD6YTr3rkxC/2CXy/NHLV bWYU7bWf5M/La8Yw3LfZ8QxSHeyqoPmsTkk/Wo4HUzNvYEnqvb6V4LPYh8IstnBfTKsgwiOGJHtV y1ZrV3t1ZmDH5fYelYtamkPisdvpMTJE8tv5UjugRUkcKAw7H069a/0J/wDg3I0RdL/YwvZlLkXf iqZzuxt3cBtuP90fmK8fNFfH4Rf3/wBD6zJ/dy7Gv+4f/9L+9vxTrK+HPDPiHxAyCRdC0O71cxkE h/s0Ek2CBzzsxXzT+yX+1Z4N/af8Hajqej39hH4n8PanJpniHQonKXFrg5imVGAJR1P3gMAgg4OR XmYrEQoOMZu13Zev9bHsYHCSxMK0oauEU/lrf7t32Oq/ay8Aa78T/wBnb4q+B/DIzr2ueGJYNMXn LSKyvgY5JwpwO54r+bb/AIIlfCXxD8MP2sPihpHi63m0/VrXS3gjt7q3aPeY5pfMCZ6FSy/n0rx8 055YLCwjt7SN/wCvkerlEoxq4zm/klb7z+tKvIfF3wT+DHjLVJNX8Z+A/Cet6vOd8t5qtqrXE+AF BbkZ4UDnP3R6V7Cf7v5Hi06kqVXnhvr+YeEPhH8F/AV+dQ8G+D/CHhzUdpBudLjjgnxkHru6ZAP1 A9K9PuNV0y0hkuLnUbG3giUvJLNdxxxoB1JJOK56MadF8sFZGuJxNXEWnWd2tD//0/qX9s//AIKU yfs6f8FQPEXxB+DWvWmraRYX8eheLrWK683R9WWHbDdpIBwwG0qeeGTGcjI/rR/Zn/aP+Hn7Ufwp 8PfFL4eara3tjqtoh1KwinWS60e5x+8hlUHIGc7Seo9wQPj5Yr2OcSw72mrr1Vrr8/uPtnh1ieHK WNh8UHZ+j2fonpbXc/OD/gqN/wAExvDv7VHg+Txr8MdBtNO+LumzbybQeRFriNjcZFAOWG1RhRno eACR/O94N+Dv7eP/AASk8Vn4z2ukaja6LLG0GsxwpJcaPqMP3hDcI4CBjgAk9h7cGbUateCjS6Wf o0zPIMZRw2Jk6+zTWuzT6P5HtvxE/wCDkX43ax4ZvPCWjfDLRvC3iCe2Nhf6/wCWNQIyu13jThFJ 78EAE8Yr93P+CL2o3Xir9k2D4hapcT3us+NfEdzqd/f3DK01yfNkyWwBzuL5+teXi8Y6mJwVOW93 fz0ZthcLCOBx1WGytbyVz9KPjdO9t8HPinNEWWRPh9q4QqcNk2M68H8a/wAsX4xm81P4o+NLxJZ/ MTxBNFalbnYXmhcg4JOMHA619DmsW8HLlPlKUFLH0V5r9D//1P6QP+CDUMT/ALFulaiYSlxd6xMH ld98koEknU+2FGPav1u+Mtytn8IvihcMQFj+H+sZLdBnT7hf618BwZzf2Nd/zS/9KZ9jxarZu4rt H8keCfsI2AsP2c/DKBw4n1W+n/3P3wQD8kH51y3/AAUvne2/Ym+O0sbbWTwqST6qsisw/EKa9/KG lhInz+cXlUqN9j+fv/g3Q0eFfit8XtSXMr/2FHudhhhksMn8en1Nf15V4HDK/wBrxz/6eP8AKJ7u fq1DCf8AXtfqf5/P/BbbXbe9/bz+JVokYWaR209Wlj5XyZYyWU+rKvH1r7Q/4Nz7P7R8avHU93N5 s9jpssdsQ2Sqh5uCfwH5CuTieN8ZQf8Afh+aO3g5Wy/GP+5M/9X+/iv5Z/8AgsJ/wUk8ZeDvipf/ ALNHh2+k8N+EdHubafxPdW8O2+1p4ZEZ0abHEYOCBkDgHJOMeHjZShl05Q35T0cJK2YUV0clf0vf 9D94/wBjP4x/Dr4qfs+fDTVfBnijTNWitPCtrY3iC6iW8jkSJcmRN2QSME+5r57/AOCgXj7wle3n wM+GtvrFtqHiXVPiVBrEmkafOtxcQW0KmEyS7chcmYgAnJwxxgE18/l2OVXhmdSotVFp+tran0WZ 4OUOI1SpPRtNPy3/AOAfpXpcH2bTNOtun2exhg65+5Gq9fwr+Yb/AIOSPEFxpngv4PWVvcpEJDLP cR7yspja58tiAO3HJ9hXXgYf7LF+R5mNXLipLzP42tG8b6p4R8V2Hi/S5Z49V0S9jvYfImO8+S26 PA6Z4HNf0DfAT/g4y+P3w38FaV4A8QfDyx8aTaHo6Q2GvajfNLdSqoCoHJj529Nm4sOOO9YSu8Qk dDjahfzP/9b9H/8Agnv+238TP2/f28fCni/4mFLL/hF9PSXQPD9oVGlaXbROZlSNVwu8tI7O2Nxy uTwAP62B/U/zr8/wbjLG1Un8Lt+Cf6n2GMg44Kk3s1+tv0PPfGHw/wDhj4ru7e68b+GfCus3sUZj tpdetYZpgvcLv6jgfkPSsfw98Lvgt4P1A6p4a8J+CtB1GUr/AKVp8EFtK+05XoccEZ+o9q7sQjio K6PS5NW0qGOSWXUtPiihB82SS8jjjix13EnAx71/C7/wcN/HL4b/ABc/aS0Xwj4O8Q6brdx8PtKX T9dvtImFz9hnSLeIy33HG/g7c7SuM5yK3owvRbfY89qPtpx82fzXXsllsja7Mr3Q5RyNvTjp2zk1 z8gWZ3ZCxVX/AHRdSHX8K8mo/fRfIkf/1/52rWbZJ5bqZD024ya66XTLi1aKRXNvKUWUYxvTOGH6 EV8At0evFcqsfQf7Ndpeaz8cPhXoskkpOpeKokM8Yw8aiSMFsdz8xr/U5+HVkmm+AvBWnx7/AC7L wpp9vGZDuchbWNRk+uAK8qlG+e839xfmz3Jytw8o/wDTx/kj5A/4KE/tbar+x98FB8Q9C0ZNa1i6 1BrS1hmUNbwJEqNI754x86Dn17feH83mq/8AByj8ZtNs9SjHwn0y4u0ASzvIYozFuJwCkRjG8Y56 8d8ivocTFzhE8PByUJyufjJ+2P8At5/HX9tPx7/wm3xFuREtrBa6R4X0N3hgtNDtzKhl2RRKEBdv mbOWO4ZY7QB/dv8A8Ep9MOmfsQ/BxWijhkudM+0SLFgq+Y41DZHXdt3Z/wBqvAxUv+FrCw/xfkj6 DDx/4ScRJeR//9D+2/8Aa0u2sf2cPi/Oj+W58ITQLJ02eY8aE/gGNf5lHiW+1Wbxb4m1G7eeeWbx BMljNFkhI5WVEcnoSpJbn0r4vFp/Vnbs/wAj38Jrikul0f6F/wDwSU0BdB/Yo+GUYDmW8jM1wzuJ MuscQc5H+0GP419YftUXSWn7PnxSd1Leb4bNoqj+IzTRRAf+PVyZDL22UQmut3+LPRzun7LNalPs 0iX9mDTxpvwH+GsACjzfDsdyQvPLkmvhn/gtDrLaN+w74ykjlkhkm1+yVHjfYchLjj9a9TDR+Lse ZiFy8q9D+BbwxB5/jfwzcWV1etLqHiK3gN7JMzTnzH3ABOhBI/lX+mr+zJpiaT8BfhbaIrr/AMUh ZyMH5bcYVBJ+uM/jXjc7/wBYY0nt7O//AJM0exKiv9XXW6+0t/5Kj//R/qz/AOCw1/c2P7D3xCFo IWnuL2CILNxvBhuQQv8AtfMMV/nK6rayWsn7yxktJFnbcHTB3hiCfxOTXz1dWpo76SvVP3p/4N+t Gkvf2yIr6/8ANuJbTS1mtJWx5SRlRIv0IMLAeu41/eKO/wBT/OvgOGfeznMX2kj7Piu0coy1LbkZ /Dr/AMHGsmpax+0VbaXHcwolhZWl7b2Mr+VPdLDbW+8RHoSfnOM/wH0r+aLV0naJpLlZliiYf6uM yDj6A19dX0Z8NQejuYlxcW2qtEJEQJEAjKB5TptA2nHrWPdjcz21pNsGMSPv2sRxwKxHLc//0v56 4zJY2wjkKXO4ghkBJXIH8s81JHH5cf29oP3WTGGZflBI9fWvzua6nTd2sZhuGkm8tcbXBwzc49/w qOCTaxjmlQXC8si5xjPBxWYXaJJdUt4fKi+xSzvPcCFJIkyE4OWb/Z4q1NcrjyYC6SxqJD5TbVHo Gx29qilG1NM1qvmVxr3SXUNvGWCtC5bIxuZsAEH246VRO21aX9wpyd+cYLE+9XboQp2Vj//T/nns LCRNTtdQubmFI47XzVtY2EkQY8gMfUYxg1Bq8sl7dyO6RmN5BIxVAqgg5zgcdgc1+az09Tui21qQ /bDM/wBhjvXkVXDsC2McD/CnmVo/Niifarjy5Sp6jIP9Kd0lqUZ1xcGGWOISB4UwQzffB9KuBJFu RJLK6Q7OIkxtbPOc4+lS3eLAjjZLh3t7m5dI1kMkWTwOO4+lLDFamaOCe5klieXGxsLgD04+tOHw oiz57n//1P5zv7Guk1KV/Oia0yPs6BSsgA67uxzxW1cTLdysyuF8gCORRwFKgDFfmzv0PSaaSZkS SmZNhkIyeFxyMVuW66RPpga9vJre8D+UkKxbyfRs9KZJyt1G1xDLHLqN15yXG6PcqlNo7ZP+eetW bAIjL86yhRtkUjk/jQBcjubWIy2lk8elWtxIPPQHbFIc5Jb1ORmmXMMLvKsdzueJfOS4GF8zB+6P r70O/QD/1f5v5JPtHJ3AqMZIywq/ObfZHDG24+UDKrY5PPQelfnEVdnbJ6aFG1lks7yJZ4JLizuC RLHCNoiXOFz/AFPtUgeKy3mM/J/Dty+z2/8ArVs1dWM7sggvxqd60MdvcmWMBVdrZ1jI6ZDkY/Wr 0WnahBqzWt5b+eifvAJMbhnnAA7Y5rGzGm0yLVLaBpIvsgERMu0pv2qp56k092urN1UCKdTFnzo5 NyqeMAfrSsaR2R//1v5w1j+0RGSSQ+bIfmQ8Mo9TT5dkMDDeI0UbTI3A/M1+bJ6tHoWsZQsJCZ7m Gd33Y+eQ8x4ABC+nSuhsLIm1a5l2AsCqSuTtBH+RSmtAKa6lDDPaw3EkmGnwgjTcRxz29s1oTTwR TOLcl4ycI5XaT+FYjTs7oy9QcuUWJQWByxQZcn3qnbSNDdRTh0kbzts0Y/4+3X+77ZyPXoaDZO6u f//X/nHudduvKltJIdqM4aJtxR1x/Cafp19Bf6Pc6jLFJYXVuxj+zXMZSWbB2jyx39foRX5lyM9g ktSLS9ttRZpIZ1hMa7WK7lYgn6Z/kadqNkodJbdSY5wZU53FeTkN6H2rRKysNqyRjabYy2d2VigE djOSxEQIzIxJYt6fX3q3qN/LYFrZmkCBSY4gMpu989Kq2lzWCsjOWW3S3W4llZXA8x0jPDGt/Qrw Is4O6Tz0IxMP4eox0rSGxR//0P5vbvbZeZLISsby7RkFjljgYq3brE1u7eWvm4LIQ2FY9QT+lfn5 77WliCOe7jiD3UKLJuwyxsWjIz2NR3063EkUtvawvFEBuDMQwPQn/OKTV9CFBplO1aOSV8FiYiA6 lSFGRxjtVy7gWG2V5WQeeS0UbclgOtZcrvY1V76E2m62mkrcRQWX2rUdQtGs7JBzAjHqz8HGMcfW sOyTUI1NvqjRyXQkO2VRgSZOQOnUdPwqbW0N3sf/0f5tI7x4po4595hRgJERu2ea0l1GO5mkitT+ +tiG2Z+bB6Z9+K/Nz6SCabuSnRNV12KO6jvJ7WCyuiwtLXbMbsgDcrgjCg8c+3X0zNQhljEaWqIt 0JQ2yZ/3agH5gSAe2aDSxTNvqC3c0rBZovMH2hwwUIpHGwd+RWh5FskMhSSR4rmExywsoEajuMVb jaNyZp2OaWZNIthZQySeQJP3IkUSC3Tj5QMfdAH4etaIuDI8Vq8qRmbiJXwm735qDE//0v5nU01d QEtrNczXEkCsJLCOMPAiEn5h3HAOe3FW44pIGtFjtke2VtmFbbjGPlA/L6Zr86UOrPpofCjdJTy3 iKJbSvzk9gPWmWojs5DcF0aSZPLlmXjevYfTmotbQmPxMbetJPFEtpIsEKyF5SnztOCOnPTnuKpX x1GWwxZiMTQo2ze+DI3YHP8AOpcUzQuLII7dLiYQLP5W0pbPvwQMEZ9c/SoLZLu/WES2p8m7TEls y7nYf3cfpVWWxqodz//T/mPuYoX1C3hs7hoI45ifs4G7cEPKn8sV1eIY7WaBZQxmAIkMY3x4zgD0 r805EfWSi76Gcv2qwTYqlzMcNu+QOPTNa2j6bZ3F0/z29u0/WWZgsasBwM9BQoJbg01GxBolvb3t zqK6hegW1vI/loo2swU4KK3TPXmrl6dOiAhtF/0J+IC7iUqPcitEruxUPhNKOE2unwJDbpGJcmKZ EwGB46f561hSvqNvcG2iCmOSPElwXCuMnkBcfrW1kiItuSuf/9T+ci51eHTRBps9zIIXnSMEEsGk YD+Efzrs9GNjPdoC32qJRgOoO4n2HXg9vavkMuhfFU15o+sxGmFn6P8AI+z/AAXdNZWejmC2skjt 1QSM8xSK6Bb+92Yg/nX9YH/BJXS7cfDmCW7israf+17uJ47fbMvDsQpk6kAY28+vrX9G+LPucL4G n5/ofl3hjH/hVxkj1T/gp3LZWfwl1u2umuFF1YTTW94DldOSKNjKwXoMAH86/jV1VrrTrKAaXdOy xQ7bWRR5VzLEchWK9eQcn61934GLlyGb7y/yPl/FBJ5zTv8A1qflf+0be3tt8SvFcWqfZxAtvaoV R2kYsYRuUdsZyePWvh7V54ZrvCwmGWJiFyMLIuTtJFfkviTLm4qxK7SPuuHIcuUUvQ//1f4erT7T JErxN86S7ST8oXn/AANddbX1r9nGnXsMUF2Ztov45GZmUg/LtJ29fSuWvHUb3Nyznnhgg0qxle6K TgzxyFlijDfxKem7A9uldLLayxS2s6KJ7eCRX2TLt8wjhuB+NeRWWptDodDZrqU1zPbWF/NEt8qy JDCSsMJH97Hvj6DpX234N8G3NzpFjci6lub+TT45ZBaRs0Eb4zt+bljx1/nXlVvhNIv3rmhDrU1v K6XOLxY2McPnErJaOnyjZ6jIPFZtxaT3iR3NyIsljJH5OQrE5HJ6n8a82b9+x2n/1v447eKyiTU9 PvJA9rdKk72hQtAssakL8vqM1k6VfX8CRWt3M8skErJbhZR5rx7sqTkdhnivmqjSaRKV5o9nsJIL 3TdRt2BjAsAJ3WbZMVc7c8cj69s1Lrlh52jWMMsnmW7SpFJbZ2vAuQQ3ByQR3pw7G01axp3dxY7r eys2tVjngjiJWMwm3VQASxxx0/HNcd4qtb2/udOaOSLFjcf6PeshTzkReUGfbHB55rqpvVIzsea6 +jSSxSQLcjzwzzloWWOPbxk5/rXMLf262zxsiI65LTY+Z+3+frXqUfhOWqj/1/4s9M0O7vbqG8vp DHplrKktzNZ3eLmWJs/u1C85Pfviv0l+FUNrF4Ge20425urkLJ/xMIvMuLVRt2RxN1xhueeMV+0+ CM+Tihx7wf5o/LfESF8oT8z9jP8AglXqFnon7RumRXEt/bwahpxvLhb5P+JdPLGIoUaNhySCBgDr uPPFf3Jrfr4g+HNpPPazW7XVjHKggJj8kIQpx7ct1rXx+p8vEWGqd0vzP0jgP954bcvbnP4k/wDg ov4bW7+N/ijz9VgNxc3Eko0+9lUs3kmdZUjQ8gtuXOAeQPWvyXsoZ20HS7qG5hT+yYX0yHT7bd9r WJXeTzJONpG5yOueBxxX9O+Hk/acIYKSX2Efx1jE5Y/Ep788vzZzxs49QtXunvla4aYA2k8LuXXP JLdB3G2r9yLy8dIbd1it44VhmVPvsenPtx+tfbuPuHnTjaLP/9D8G2hXTLMQmUvuXDFsbT65qxoM qX9wJflijgzGDK4TeMdTzx9Pav8ATlprc/iJxukeyeCPAd/4p8T6Bo/hu3g1nU9fvo4ntLW3luL6 2WOVXD4RT3VeOc5+uP8AR2/4Jq+HPE/hT9lHwHovivTLjStSh3yC3uYjBJ5ZRFX5DypATBB6HI7G v5V+kDi6d8NhL++ndrrbWx/X/hFRVDw/x05Ne/ONvOyjf7ndPzTtofQn7S+nw6n8D/iHaTIkgOgy SIkib0Lryn45AwexxX8rH/BJK+EH7cQ0zTL62uNP1G9u7iYTEI7JC0rxSKB/E2DhfRq/GMojN5Lj bLRL8rHflFdUuOKKT19m/wAb/wCR/Y4P64r84NB8beH/AAZ+2x4l0TxBqtjpd14tSePSv7QvI7NZ mKZWNSxAYuI8gZz0x3x8nGnOrHkgr6fqe7h1/t3L1d/v7H//0f79zyODzjg9RX8l/wC3/wD8E9f2 j/iP8cNe8Z+BPCJ1e1kvPIsXNpcSZjxGxPyxlSHbzD16EdTkD6DhfMKWXZlDEVvhR4fEGXVcdCMK W6f5tf5HQf8ABOD/AIJgePdB+NNz4u/aD+GOn2mmKh+0QS2ipBeOCCxKsvz52ruDYxhcAjOP6IPE n7Lf7Nt34a1TTdX+F3gyw0WSweG+nh0+OxeKIoQx8ztx6569K97ijivEYvMva5bNqCSWh7NPCYfB ZTTwiV3y+9bv/SPwj/Yl+Ev7HWj/ALXPxA8C6jpXgm+0m0uZoPAx8S3VtvupQ7bLe3ywRgEBwFHb 8K/efxt+yv8AAfxx4W1DwvqHw08K21td2cltb3Gn6XHYXVmzoVWRJEAORketcGbZ3nLxNGtiJtSS TX9bM8/KI4LEZOvq60ldO3q+36H8qvxm/wCCNv7TafHbxVr/AMLdBn0/w+da+3aLf2omSBmXaVaN 0Q5yRuJJ6k5Oc1/RD+wRZftZ+G/B3/CG/tHwGe38PWEdjoWp3tklvqU4iGz5pFxuHC4BGeSe52+x xFn2DzrLY3sqsbet/l+J7WRYShl+SzwVZ3kndO+v9as//9L+634ueFvh74v8BeINH+J1ho9/4Uk0 6Z71NZkS3ghAib50lYjY46gjnOODX5Bf8E2fi/8ADP4b+P8A4jfA248SaLpq396L3wpPfazCv9pl JGQRxjO35lLOPbHXmvbwmFxWNwdalSi3GPvfcTh8XSo5ksJUlZzg7LrdXtp5v9ex+3GrWbahpWp6 ehCve6fNaKzfdUyRsgJ/E1/Kb+0F/wAEZf2g/H3xg8R+MfDR0iCw1DWZ9Qju0uEaRxI5YFVPBznp nv68V6nB+dUcix8sVX2tY8/Mcr/tGpCMnbldz9Yf+CYH7HPxE/ZP8P8AjSy8eJDFN4gSJR5ciyG4 kSVmMuAxI+UjOcDpjuB+lXxE8Y+FPA3hDXde8Y65peg6PbaVctNc6pex2Ucu2B2aNNxG5iAcKuT7 V42dYmOYZtVxNFaTeh9Fm1elOFOcdIwgk29PhW+vQ/Kn9gP9rT4NeJviF8VPBEfjTw3Yajrevf2j 4dtrrU47U6oAXLLFuYBjgkgDspxX66+IdMbWtC1fSI5VhbU9OlsVlbO2PzUKZOOe9c+NwGIy/Eez xEbN6nlvE0cfgo4ig7xaa+7T/gn/0/3q+Gn/AATQ+Nnwh/aauPjtbrpeo6Xb+K7jXIINOv47q9ni eRpFX7Pu3YY7CR146Dt+8fhXxn4f8X2zS6PqFvPdW6L/AGjp28Lfaa7D7ssR+ZeQQCRg4PPBr2s3 xizGVKrD7EUmd0nRhl9LCU370b3+bv8AqflR/wAFaP2MfG37Unw40/VvA8EN9q/gq3lvPsaXYt9Q eGNGlIhDYUksCODnkcYyR+IP/BOT/gnv8U/FXxm0fxREVj0b4faksmuz6jfwx3Gnyucyo21Q7sQi Y3DOGUdOR9xw/wAUUcDwhisqqK8uno1/wD4zJMqWH4xjmU/hlzS/8BuvXbX8nuf2cWkH2a1trbj/ AEe3SD5c4OxQvH5V+fX/AAUi/ZT1/wDat+BN74P8JxQXHiOzkae0tp7o2nnoY3VlRsgZO7oeTxiv zvLMS8FjqeJ/laf4nu5zT9vSq049b/hqfwT/ABi+HXiz4OeKNc+HHjjSV8P6r4LU20fnWjxPLGoP Kvj5wQF5HHIOfT5qn1m11C2uCTcwxRYkC7GQXJRgy7fXJUV/eWR1I4zLaOIp6xlFNfNH86yxVsw5 09Ln/9T90P8AgiX+3/8ABfxJ8E/DX7Pnijxppuh/EDR76a30TTtRhOnxX0QzsVZj+7J2RqeSD8r5 4GR/QL4u8Pw+LPC+veGp3VINd0mfTHkZd6oJoyoYjvjINfacc5XiMl4sxNGqre+5LzT1MJ4yOeZR Sx8PhqQS06NaP7j+cHxh/wAEK/EWv694m1y08V+HIbrWb55Ypnmd5Wi3EhWzHgEg4Lda/WD9gn9i yz/ZA8BXnhu6fS9R1W8mWdru1jEwgOWZgkhAYckf484Ho53x3is0yKlkybSjb8Fa2n9dzmyjKsJl U516K9+Sav6u7+/+up6P+2f8V/gh8N/gt4vtfjPqejRWXiHRJtM0jSdRsm1G51C5mxHAYY1UlWR2 STeSoURM24BSR+cH/BLn9vP4Da5Br3wCn8ZWeka0viu5vPA1nfxtb22pQSHEiLORt3korbWI4yc4 Bx4mByfMcyyaviaSvCDT+7c7sNiqc8dPBQkudx2+9r8vy17ft14q0CDxT4a17w5ct5cOt6VPpkkm 3d5YmjZA2O+Cc49q/nU8af8ABBKDxLqOsXlr8QNFt4dU1I3iwuboSQDcW4ATYxPckenArr4T4nqc M1qlen9tW+48HN8lo5rUi632dvmf/9X+yH9iz9kXT/2TvAsvhaO/ttUuZXAS4jjEjxAKAx80qG+Y j7vYd8cDq/2ufjv8E/gn8LNfuvjJq+lW9jq2mS2mm6Rf2bX8mpzOAkaLGqtg7mB5xwrHorEfSyxW KzvPVVpN+0nNW++54/EmIo4PI6llaEKbil8rL72f5wn7SGu6JrnxZ+I3iHwRLp0XhrUfGN7Pp/h7 T7Xyp4IZJiVKkcKqbioXPAXjjp4pqdxBDHBJaAo8IBl28D/gXvX+gORUpUsow9Kp8UacE+91FJn8 vYeU3Tjzb2V/uMLyYkB1ZiYZlBaKGIblbPcnt/8AXq3DqDyx2sr267pMxjkkuTkAgf56V7D+JG6a Umzb8NXc1lJeT3ETAGb5ivMgCnl8e2P0r+oD/gjP/wAE9vEPjmPQf2kZ/GOnx6bdXUeqfZ3R2u0j DsohCbD84Ikz8wH7vBPOR+UeMOZ08q4Rqymv4jUPS+v6W+Z+oeFlPnz9Yi+lOLk/y/U//9b+/SGM QwxQhiwijWMM33m2gDJ/Kvhb/goH+yXeftc/BG/8D6Rq8Gl67YSHUdMW8VjZXpVSTExXkE8YOD6Z HWvTybFvAZhTxS+y7nm8R0PrWCr0r73/ACbP4Cf2lfhF4o+CfjfWPhl4uSPS/EkVyJEFlML60vYi qSRz7yMlcYxjsw5NfPNtcW9v5lje3IdrcgXLwfP8qkE7fX7tf3jlMo4zIqeJjtONz+fcqxlOtiIV 6W3N6bOz+53P7Bf+CL3/AAUk+Ctr8LfDf7N/xB8TnQ/Fdtdk6Be3lrL9guDOFCwzS4/dHAXBYYxg kgZNf0oatp1pr2jahpc5WWy1bTpLORl/eI0c0ZXcPXhsiv4041yevkvFlanVVoufNH0vp+Fn8z+i KmPWdZMsdHVyhZ+qVn57n4OeNf8Aghl4B8WeLNT8Sr4xtLNLvUpL62soYZLaOBXbIQ7YyfTODjjg Cv0x/Y4/ZN0/9k7wRqHhKy1pNYN/eG4aSCNkgiXjaq7gD27jqTz0A5M+4qxOc4Gnga0m1BWSdrK3 br95tkmGjlOGqYOkkoyT2++5/9f+3r9of9oL4Yfs+/D/AF7xV8R/EMek2yaTcfYbVIHurzUZTHtS KNVGMkuv3iOMnoK/H7/gn1/wUw+Bur+OfFnwy8W+Ko9CuvGXip7vwnd3sLRaazySOsUMj8iPcCoJ bABIzxkr9nh8kx+KyitmtKnehTcVKXZuy+etr22urnkUc1wtLMI5bOf72adl5K/3dfWx++d3bW+p 2FxauVktr61aEuhDBkkXGQeh4ORX4LfEX/ght4L+IPj/AMReM7v4hG1h1fWZtWtrKCGSOSLzmLEO SjDPODjNbZFm1XK3U9k7c/uv0Zw5ll9PGY2NSqr8lmvXU/R39i/9jvSv2Q/Cuq+G9L11tZTU5FJC KVt4VUgjblVOevbufw90+Nnx4+GXwA8IXnjD4m+J7Pw3p0NvI9mblWeW+kReI41Axkkj7xAwCc8G vOp0KuLxyw9CPNObSS7ts9vH16VHCOtXdoRi7vskj/Pc/b0+Mfhr4w/tGfET4m+AZ5tV0PWNUljv JpNPa1hkbEUsZic/fGzy1yM/cIz2HYfsKfss3n7WvxV0fwnpmqx6Lqk08azxR7o9Ji2q85Z+eSEV fl5ySMV/V+aNYPgitUl0hb72o/qfhXBkXPPqUP79/uV/0P/Q/uI/Z0+D6/An4R+Fvhr/AGgNUl0G 223N8pLLcSMqhyCVUn7uM4GcdB0r1XxJokPiTw/rXh+5cpb61pU+lzOByqzxtGT+G6vXoz5Mb7Rd JJmGew9vTq00t42P4YP+CpP/AAT78Y/snaxqnjqW7tb34fa1efbdL1KCb7XFBPdSNEsUqEK4ww9A K/EiwsTfG+tbWEM8LOcgCMNjJLDPFf37wRiI4/hvC4yDT54J6bX6r5PT5H8rY+i8LmdfD7csmvxP O5rR2upxJ8yLxGqrjaQTzmojNewq87hrmUfIFUEOEHAGCeTj88V9koe6zgb96xs2c6pJGJZQv7sy IV6g/wB0ir++UfvpN0kP+7hDUOGjR20JaKx//9H88/2efjv4+/Z98a6P8Q/hp4r1HwzqmmXpv7iP TblrEakFUBkfacyExoVCHrxjBxX98v7AX/BQv4SftifD/QLew8Uwj4oWmlxp4g0G+t2sbm7mjiQy vCdojduSSqHnaxA+Vtv9G+M3DNfLuIIZ3Ri3QrJXfRTirNeV0lJX3962zPluDc9o5nkay6T/AH1G 6tfeLbaforuNltZd0fR/7UP7N3g79pr4W698P/ElnYJe31sV0nWprRJbrTpAQRh8FgpIGQO4B6iv in9hT/gmlYfsj+LdY8T32rabr0l5bGG1VIzM6EMWVvmGAcsTkc/KBz1H5U80xccE8u9o/ZOXNy+d rXPahhaKxX1rkXtErX8tGfqL4n8V+GvBWj3Ov+K9a0/QNFs1zc6jqU4t7WEAE8n2Ck/QGvwe+Hv/ AAU1/Zx8P/tt+K7XVPG9vB4Z8ewvpK+IhFJJpVnJJOjWxmON0a5jQMzDCBucc4VHLsbjMuxGIwtJ yp0knNrortX+V7vsk3smyamY4XDYynh8RNKdS6iu7STt8/z0P3003U9O1mwtdU0m+tdS02+hFxZ3 1jOtzaXKHoyOpII4I49DX4e/tf8A/BInUP2kvjPrPxQsPH0ekR61M9xPAx8uVS+PlPyNwCBwM+ue cLhlmZYjLZuvg58k+j+TRyY/BUMbONPEw5opbejTP//S/p6/YL/4Jqal+x941uvEs3iLT9SjeCSE vaszz3vmZyZMgHvx+P4frfqmq6bomn3eraxfWumaZYQm4vb++nW2tLVF6s7sQAB6mvpcTU9vjZ1d 3J3+/U44r2eHhDZLQ/i7/wCC037THw3+Iv7SHhC48Da7pmv2vhfSo9Pvr3S5jcsJI52ePcOw+c59 CPU1/Uv+wjdJd/sqfCKRJzOV8OIkj7t+1upUHvjIr6/jLC1cNRy51lZ+yivmm7r8UfM8J16dWOOV N3/eya9Hsev/AB+jST4I/FZJG2IfAWp7mILbcWshzgfSv5If+CLeqWLftrTGa8gW8kN8sELSYmnE 8TKcjvygGPU1xYTDOpwnjsSlfklD5a8v/txVevycW4Si38UJfPr/AO2n9ndfz3f8FcfgR4l/aD+P HwW8D+EUW61a50Py/sQk2s7vdYiJB4wAGxk9z714+S1o0q03L+Rr79DtzylKoqSj/On91z//0/7b v2U/hPrvwT+Bvgv4d+JLiC41fRLPbd/ZpPOihZguYw44bBU8jrn8K9q8WaHH4m8M6/4dl2GLW9Hu NLkEn+rKzxNGQ3XghsHrXt4eSWLUm9Ob9ThzKLlh6kYreP6H+fX/AMFIf2MPiF+zn8RfFF34s8O3 mkaV4m8S+d4e1+33S6e/nElFRwNsikA9O/HByB+Sl/Ils8KyrhQCDLEpPnN61/ffBtWGLyLD4ql8 M4qX3o/lLNaLoZnVoy3jJr7myn50EMo6vK674ggyBzjmvUfh14X1nxZqiaVpy+fqV9PHDp9mqBpn kkZUURqSMnknn0r3M4apZbOrUdoxTbb6Ja6nRk8JVMdCnFXbaX3n9v3/AARW/Y3+I/7M/g7xL4h8 cWktjD4u0WGGyivI/LvJ385ZhIQTnG38MnjOTj93K/z4zmaqZ9Xq95N/if1pVjy4GjTT2il+CP/U /Sn/AILa/sf/ABUPxI8RftA6Lol5r3hHXLZTfXuk2bXEmmRwxQhopSowh/dH73XrzyR+cP8AwSD/ AGhfCPwb/bQ0S48U3ttpPh3xBcHSG1GWYRRQzPCsCCdj8qfecckD5hzX9OY6jTz3w9U8PZulFN+T jfm+aUn8j8T4OjLJeMK+HqXSnJpejWn5I/vjsr2z1Kzt7/T7mC8sryET2t1bSiaCdGGVZGHBBr8U /wDgqd+xL8T/ANpzxl8PPEfgDR5dWttD0h7DUooPnYnz1kAK9sBRgk/xYGecfjOXWWIqX7Nfg0fr OcJt0LfzL8D9Hf2QPhz4g+FH7P3gPwL4ns5LDWNEsWhuLSZw8sIJ+UNjp06dQMZxXqPxisY9S+E/ xJsJZPJS68DapC0u3d5ebObBx7GvIwa5czgv76/NGvFD5Mnxaf8Az6l/6Sz+KH/gnH8Z/DPwg/b3 03/hJta0zSNDuNefSYpb6YWkU6BiBsc4UNkA/MRk596/udtLu01C1gvbG4hu7O6iE1tdW0gmgnRh lWRhwQfUV9Hx9lFXA5vDEzvapFP70jyuCcb9c4UowW9O6+5tH//V/o0/4K9fsd/Ej9pCf4c+IPhz oF9rV14c02azvhp1s1xOGNyki5A7bQOOvXGcHH2P/wAE6fD2tfDX9nzw98K/GFpfaX4o8N3E0stl qkBs7l0l25Co3PylST/v/WvrM1xkcVlmGpJe9T09U7f5HkZBgv7PqY2cpX9q+b8X6dz7W8a6M3iH wd4r0KNQ8mteGr7So0YZDPPbSxJx9WFf55P7S/7KvxX8F/Hzxd4N1LwLqx/tTW7h9LivLCe2kuFn IKsvyhmI4IGflJIPNfpHhZj8PgqWL9vK2jf3JH5/xngKuJ4nwNenHRJJvtdy3P62v+COnwL8efBP 4CTWXjfR59Hl1SK2ktobhHiZiPMZsK3OAGQfp1yK/YJhkYPQ8Ee2K/Ip1faZvWktufT5M/Y835YU 1Rh9mFr+fl5fofwBf8FXv2f/AIh/Dv8Aac+Jet6j4R1qfw94j1y81uxuIF2wKZZgxuEY8ldoOADy H6HAr8irYy2d1cWmqyt5Cx/aYJtmZCTn5CvbGP1r+2+D+TG5TTrr+Vfkj+Tq/NhMyqYfqpP82f/W 8a/4JZ/E3T/h9+2Z8KNU1rVp4ND1LWIrcC4I+zJOjOsSYJAX5plOevXrmv8ARWtbmC8tre7tpFmt rqFbiCVDuSRHUMrA+4Ir9U8WMLPC8YVJS0Ulc8Xg+sp8M04ro3+bPxD/AOC0nwA8afGXwN8PL/wf oGp68+iT3FrexabaSXUkW945IyQoJ6g/kfevcf8Agkpo+seBv2bofh14qsbvS/E2h6vNc3FnfQtB NJHKcqwDc/KNo/8A1HHznEGMlieHcFRjZ+y089Uv/kS+Fstp4HG5njXp7WV/V80v87s/UDWIWuNI 1S3Rd7z6dPAiAZLlomUDHfOelf50H7dngLxL4A+MnjvT9T8Lalp51vxjdaiJ2sTHawQnKxI2ejAg cHnmv07wIrUoZrXoTeslp8j878R6fLiaOIfRNfepL8z4J8KaydO1fw5cz3StFH4ihneXhl2byACO w5Ff6cf7KXiOw8U/s7/CTVdPuY7qE+C7G3eWIgrvjgQEfkVP412fSBws1jcDiLe6k1+J9v4b14T4 SxFNP31NfdZH/9f+0D9uDwVffEL9nbxd4TsLF9Ql1O8sllt44DcOIlnDSsFAPRQeeg78V8W/Cb/g j5+zHB4I0Wfx3oM+teItQ08Xl7L5ENubc3CBjHhkZvlBxg46fifuMu4nxeS5JHCYGVpud3r021+X 5ng0cnw1bMsVmGJipXXKr+kXf70fh9/wWF/4JOfB79mjwPb/ABq+Fuoy6VbCc2TaXLsimX93K5RU QBSvytg46kZ71/NRolnBJDaTWcsbRyWyMTO2dhIGS30PWv7E8Ns+xHEPCdPF4r+Ik4t97XV+/Q/C Mww8MBxNicJSatGSt5JpO3yuf0U/8EE/CXje1/ah0bxDeaNINIOly2guzD5MCW5Vijrgc7irMM8k Emv7ea/kvxTq0q3G2J9k78uj9Vuj+kMujKnw7glU35b/ACe33n8nX/Bxp4Lu9Q8RfDHX7bSRfpF4 WMtxcNGzfZUS6lQkY/3c4/2a/Eb/AIJb+L7Pwl+3n8IX1W9CaVPr0SxXAGbZC+Y13N1BXcCfSv2D I/8Aa/CbEU6esowkreh+Y8MyWX8f88nZOo3r2af6n//Q/v1jdJUSSNg0ciB0ZTkMCMgiv53f+Dgz 4ZeIPHnwk+Gl74e0+5v7rSrm9tZEt4i/yzPbPgkc9YQfwr7vwwxtPL+KcNiK7tFbvtqfD+LGArZn ktXD4dXl7S6X/bsv8z+Y/wDZd+Fnj23/AGh/hvrt14eutNt7XWIXvkh33QUecpODt4wFyc84r/R9 8OndoGhn5udHtT8ww3MKda97xexeHxnEVOrhpKStuvVn2eQUJ0OEMNCqrST26n47f8F07qC0/Yxa WaYxAeN7UbF+9KDDOhA/Fl/Ovn3/AIN7rhX+DXxNgG8v/bUE8mceX8xkK4/Bq87FQk/DunN/8/P/ AJM87hKUZcR5xFP7Ef8A20/ojr+En4+NPpn/AAVb8VWVrczBbf4tMLZWkOTG8lvLJsz25cYro4Dh z5Zmy/6cS/8ASZHh5pJ0+Lsnl/08f5xP/9H++fRyzaTpbP8AeOnQFvr5S5r8P/8Ag4BUf8MSTSmA SmLxQrklc52xkBfxLZx/s19t4au3FuDb/m/U+J8Vo34dxVu5/n9O1vJpAeeOSMwwIbZIjlCNq7Vy ecAYFecag8ZuYpjI9vEmDLGpypb3Ff6Q4Ze6fz5Vf7uKKjQGUyOHlKZDoVJXociqq288rtNKS6k7 UySTxXY4u9kZRly6G695DpcMe7lgm1iV3Ek8cVO08M8SGKQhHG4kHAq4xsiJTs9T/9L+eqCdkh86 3Xz/AC22uoHXFVZNRtTcB7+O7gs5WAlaP5AgBBxn3Ga/1mlG5/H6n2Zv3I0We8STw7NObaaMN5Ny uxkb0Bycjpz71z8zwyXTmYxLPB8rAAfQVPs9RTmI+GwZQEZDwy1gXTi3laTzh87bUXpuJ7D8qSg+ phexAbiQHezEFemOMVI5a5tJhEzQzyMoLoAOAcnHvwKfs/M0U7KzP//T/nHs7KC7uYLhmeWSGAwu HO3DE9evPQda7C3Gq2Ia3sriCSN1AdpXACpwzp19Bj0r/WaMVE/jvn8jnrrVUvpLmGCVGe2kCTMj ZQZ9/wAKg+0C1eCBds/n4LXETeb5ee2PWqJ5ne5s6jbGOBmtZjMdyiNdvlllPBLDt64rNim8qQi4 QOFHy7uVY0rK9yufyM27057hZ5/MWJdpZeCR7Cs/TbZ1tZllYbj/AKsngA+grGSs9CnL3bo//9T+ buFJYpLV55lWGJygt1f/AFmcY3ccdOPqahvNPVXknRQvntulOOPTNf6wH8c88ixa2qWMhuBMzq8O wgH5fets6X4c1e2smi1SS2lSUm5Z38uENzhWA54z39KAUmc+tq9peXNr9s862aT9yqtvQY44Pv1q /JatLE4DbF6Y6Nn6UAptFd7ZoIWOcNEBsBPOfrWXC0ocvMx5OOOtCV9EJtvc/9X+c+OwWZI2iVuF yxIxj1rPvk3XEcQdELHHzHJA7mv9YuWXY/jcdKq2qmGV1YFflZOje9Z2m2kkETLNcGZeWDsMMck4 FLlfYjnVi69pOygwIgB4LOcCqVvFHDfQ2d2YbWxjRmmvTuMkrnO1FHTk8Z7Z71ah3BzXQuG2uUBJ ceRKCEUMCTiqbGQoxhOyRPlGRn8x6U3BdAdtdT//1v5vLe6uHEMTlcL8pIGE+tS3jTx2MkMUohMk 2/coBJA4wP1/Ov8AWNwfQ/i8r2ZgkxHIjl2BAlb7wP1p/wBm+yL5gJkcOfnbpips0aQkvhG3u6aG EMWaOQnfsGAMEcVatJ2tYVEMbOAQhUjkDpSLuiLV44bFTe2TTPM0YBs0wEBJG5ifbrj0zWOfEM0u y0nKoWwImKEMcehosUpW0R//1/5u3RQwLSHzigUt0wKsxzpOVgZiPK5wfut71/rAfx259h7fZB5j SruP8BVeT6CqNzaW91cxywwhZYV2MkkZRBkAgjP86ymktjMa9veXEbICsqRkMig/c9cVZSUxskKl 5pMBdoBJB9KwlFW0Gld2QkBF7NxE0bRvhiUwTg10N+IzaTuSiyLaPkJhGcqh2j+X4ZrCtFKMvQ0p RvJep//Q/kF8Uh7TUxGLbyzcO/lPH8yPtOSQe2c55rnpTe7VaWORUzsMmwrx9a+t46fNxVjn/wBP Z/8ApTPC4dhyZVQj/cj+SJ0kxbvBHnDEMCzffPrWha2cDQyR3rymKZdrMh2ug6fKeor4+ex78Ve5 /RF/wbt6OB/wUA+G5K2y2F5ZMsFu3zs0UcT/ADSAgncfnIJ7Dr1r/Ta6fhXyEIQfE1eT35Y/+ko+ uxTnHhrCQ6Xl/wClM/he/wCDljwXbR/tdfDjV9J0yC1e8+H1o+r3USCMXzG7nfDqBgkYyT1O7nPF f1Q/8EvoDb/sO/ASMlWx4PtuVXb0giXkeoxg+9elnNFwzXBu26b/AEOThuo1wbmCb/5eWX5/qf/R /sC/4KdXEFv+w58fjcoHil8IPbbW+7ukdUjP4MVP1Ffy2f8ABtRdH/hp34p2b3Ekkz+FzcPEyf6o rOyj5vpuz9a8riVP/V+D6e0h/wClMw4Za/1vrx6+yf8A7Yf3E1/nRf8ABfQSXf8AwUD+I8Ruy6pd lGEEQQRBbaPasmRyV3nn3r0MFFPDyv8AyonMtcVRt/P+p7j/AMG0FpdWP7YXiuBZIrmB/CRaS5PJ Yb4ioDDqRg5H+ya/vsr5rJlbHYtL+b9EfccSR5cDg1/07P8AO3/4OKbyC7/b98UwXDt5lhpFta2y wjfIrNbQycj/AHZM8+or8A73R7SCzuZ4AiyzRmOYsf3j8dT617+fpqdvJHwHAmlOS/vyP//S/pC/ 4IBbm/4J6/D+Rw4Mmo3UihxhtpnlIOO2SWr9Uf2inWP4CfGVmzj/AIVnrQGOuTp84H6kV8rwqrYB r+9L82fT8aO+aSb/AJY/+ko/yVfjIzt4s8W2yMzP/bNxbEhdjRP5jMRnv95T+OK9e/Ypkux+1p+z 1bW7IJJfH+mnEgAWR1vbUDJ/H8iafEUb4fEPykc/CMl9coLzX5H+sr4ZXZ4d0BMY2aHaLj0xAgr+ b3/g5Wu/J/Z7+FkPmbTJ4pnkEZ4WTasff2OPzr1eHbf2bS/wL9DxuMdMyrf9fX+bPR/+DcmKUfsc 63NLAkSzeNLh4XHLyKQvX23BsfjX7yfEcxr8PPHjTMEhXwZqhldhlVUWM+4kfSvM4ff7mqu05fmz 2OKkvaR/69r8j//T/AX9pRWm+KHj6OaPfFbeK7k2joNsURBHAHqOM56Zr5SvkZ3V3XCYO7A614td WqyOfCK2GgvIj023sX3Rsu5Il+Xf1FTQ2kaSMf4FOVUnqKmEep6C/hteR7j8HY4L7xz4AihiQW93 4zsrW5gaL/Wfvcnj6rnNf65fwA0y10r4L/Da1tII7eI+E7O4KRpsDtJErlj7nI/SvlcZTi+J8HN9 IyPqstnKPCuJSX24q5+ef/BaL4v+Mvgz+xprHiLwNr994b1m88UWemyajp87W06wPvEo3Kc9CD7F QeoFfI3/AAb/AHxq+JPxg+G/xWu/HPjLWPFNrp2pxjTYtVk88WjFyrMr9fmAOc8+/QD7HHVPZYOi k9ZT/CxnkdOlWw+NjNXcY3X3n//U/vyuWKW87DkrCzAfRTX+Vn/wU6ubnV/2t/jiI7xrYTePL6V1 8z97tjuZcADuvzEfhXJW1wco+n5o48S0sdSfr+TPzeu3tmljhtwzSgjfMx+Uge1YOox+TkxSYkDD kdSa8Jroz1E7xsPt5Lk2zrI2JsExNjLbuwIrQtkuJR+8LxygfeKlS30rO15s3pO8tTrNFsLu7+0W sDrbySoxQzqVQsqkk+pzj9K/0a/+DeLSzp/7B+jNLIz3E/iC5mf+4itI6Kv1Aizz/erxse/+FPCR /v8A/trPrMuuspxk10h+p//V/u9+KTrF8M/iI7/dTwNqxI9f9AuOK/il/wCCSnxN8Y2n/BQ6Dw7Y eJdRs9K1TWrmLUtPjnJt76FJW/dPH0IYMc/QelfF8YupDK/a0naUZRaaPsODZJ506E9YyhJNProf 3K1+aFr4a0bS/wDgo5fS6LpdpprXnw6h1TVWsrZbcXc8kWWlfA5ZggyepxXoY1c2Apvs4/mebgm4 42ol/LI/S+v4af8AgsT+3R+0f8PP2wviD4M+HPxM1nw1a+HdXktNPtobthbRW0eB5ccY4LDg/N2J 7AY9Fvlw0+/L+qPOTi61nsz8h7L9u79ufxBNcR2n7RfjuaTLssMEyQyu+eY0YDczc8Ln6V0eu/ti /wDBQuHQsax8YvikdEvLVoZrq/spUjiwPnUzFAS2D1DH618qsWqc1CT1O+nlDr0lX1t82f/W/Du2 s9V8Ta/cajcTan4r8TalcG4u71bZ5riWRj0ZF+7k54xnk1+v3/BMf9tn4tfsDfFHR7jxlb+JU+E3 iK4+x+JfD1zZTOlpDNIB52xlz8mFPy84X2BX8xzGrGeKbjK1WNmvX/gn6Zl6+qYD2co3pSTi1/l6 bn9nnws/4Kf/ALFfxcvfD+i+GfjT4Z/4SLxDJHb2uhz3X+lRSyHARyPu4OclwuMEkCvrz4rfDDwn 8Zfh/wCJPh34xsLXUtB8T6XJp84uLdLsQF1ISZFbjKnB4IzjqOtfT4LGU8Xan9tJNrtdHxlWhUpw VWz5XsfwJ/8ABUL/AIJq+LP2PfiEW0xP7d8FeM43uNI1eKNvLtQJD8jNgBSRkY4JKk4wDX9YX/BE zT/7M/YM+HVuP9WL268skYdv3nJP/Aiw+grwMzwyoZxhklo5O33M+kyqc58O4pyfvWS/E/QL9pSc 2v7P3xmnDFCnw21cBxwVJspVB/Wv8sv4o2bT+I/GK263byjxBd3UEsvys3zgh0PuOtfTZi+XCv0P k8KufMKVu6/NH//X/pn/AOCFtj9k/YI+H87QrC13eXJkAdXdnSeVGY45GcKefWv0u/aGljg+BnxZ eUkJ/wAIFqUZx1y9tIi/qwr4Pg182TJ/3pf+lM+y4v8A+R3JeUP/AElHnv7GVqLb9njwKwVV+1RT 3fy990zAk++VOa8U/wCCqV5JZ/sP/GYRKC11pItCT0UMHJJ/75/WveyxcuHiv66HzuZvmnNn4p/8 G4MdtNffF3UDbzJfTafGry9YPLWXAXPruLV/V5XgcMWdbGtf8/H+h9DxJHkp4OP/AE7X5s/zuv8A gsXrH9oft4/GRprgGax8TywwvtyEh2JuX0zuz+Zr9PP+DazTJLrxx8W9WltYJIYreWe1v1cM7rMw Crt6jGwtz/f+tYcRr/bKD/vw/M7uE42y/GRX/Pub/Bn/0P7+K/zyP+C419Yah+3t8Sbae6meGG8n UwEFQ7BwpTj+H7xH0HoK8nFf7hJ+S/NHbR0xdN9m/wAmfmr8Nf2nf2hPgra3uifCj4weK/BmgyTC VNP0y48pR0+XeDvAXsAa/T//AIJV/GL4pfHb9vP4bJ8T/HviLxxerqP243WvXL3U6hI3fy1LMfk4 7f3a/Ps0qSo5ROnS066fcfa5FJYvPYRq62Vv6+4/0IFUIqoOiKFH0HFfyU/8HL9yxuvgvameNY30 WS1WLzAk7PNdyYwO4+T8yK+qwCUcFFeR83j3/ts/U/kMudGuNL2rcGOSaWUQQpBmQy5+6P8AHsMV 6jpvwm8eW2nXN/ceDdevbOPa0l7pumS3VnFG4ByZMAZGeQM/XrXL/wAxHyOpv/Z0vM//0fev+DfT wxDpn7VOqQtBdWz2+nSTQDUY2iuiBFvKhWGQCQx+gAr+36vz3BtLMa1l/Vl/wx9ljG3l1HXp+p/G 3/wXN/ah+N3w4/afbw18PPHHiPQrPTtAt3ij029ZIbQ7VICQg45YlmY88jOcDH4ZWX7Yf7aGuX8O np+0t48t0H72KyTWJLSVnzyPkYM2c4GOfSvRxTW5wYZ62NrWPjh+3vEmoS3/AMV/jRpsVxBuJjvr 8LfRsMZjJbJBHc8fyr4O8Q3OvT6nqlz4lvtY1XX9U1F77U9U1yf7Tql5I5y7yTElmyQTgk4JPSum m0qL9DzHf6y15nF39sjyq0jj5RkA/wAq55Vfz5W4DMNkf91QP8ivFmv3h0H/0v534DHb3AlmAIVc mTPGeK0k1Jr6aTdcTRpFgpL5Z+ZRgAZPsO1fALRnsH27+xhDJqH7RnwVsoUZZU8ZwzG5VMuyh4l2 gfRj+tf6hXhWJoPDHhyFxhodAs4mHXBW3jBrhox/4VHL+7+rPSrS/wCEiEP77/JH4M/8HC3iBtH/ AGXPDtol5FZvqmqXVjG0r7FZpBa9f9nCNn8K/g8mkvCIXebdKmHn8ty0LsRzjPYdq92clyHiUnar YsWrLd6jY2s900Ut1cxCBMEvIyurHaO/AJ/Cv9Nz/gnDp9rpn7HHwXsbMP5Nt4aihLSDDu6Rokjf iytXyGLrp8RYWit0m/lt+h9fhqclkOIqvZtL56f5n//T/so/4KF6lLpX7HPxzuoJnt5f+EReGOeM HfCXkRQw+lf5t91e3wnv7MytJ9o8TSQ25jTKjdc/3frv59DXxmNmvq0vRntYP/eYLzX5n+jH/wAE xtMXSf2MPg/ao0jq2leaHkUo7ZjjUkg9OVPHtXq37Z1wLf8AZ68ZMZfKLXFhGp7MTewfKfY4rl4f 5aeT06a2S/zPWzubqZrUnLdu56x8FrJtP+E/w8s5Aokh8J2e4IuxV3RK2APbOPwr8q/+C7MiH9iX U7Q3AjefxNbypARn7UIxhhj0HmZr1cHL902+7/M83F29ordl+R/Dd8Irxn+L/wAO9NinguJbLxha TSQQwH7Oy280alTnpjcP1r/Tv+Edutt8L/AEK/w+ErF8DgLvgRyB7DOB9K8e8VncX15P1Z6zb/sR x/v/AKI//9T+m3/guJrcWjfsR+IfNJUXGuQkEPsb5EcY+mZBmv4FNQvk1S1S7vxDvuUDPDCuDbgg EDnnoR19K+fxM/3SPRoq1Q/fr/g3r0201L9pzX763Fw66VpdusIKlIyFSUl2PfGTX9vmMV8FwtGK x2PqdXNfkfWcWTbweApdFT/U/gv/AODgLW7m8/bN160uJGU6d4bjg08KgldAGVWKnscY/Amv5+oL y6tbWaCdxIZXL7JWDr1IHFfVYiSTR8PT2OB1GxZpHmidLe4kOV/hWXHTNZL28sXyz7BLn5XR8qfx rFPS4Tk09D//1f549OvI1b7HKVM6fO5JywB4Xj86twXV7HdXNhJcqNHkKtJbkBg7A5yD2r88qNGq nsibW4LWB2ms5Yxa/KbVyCGcnkgj2/pWCSVgcrbh5nYM8uPmI9KhJNpMq6RYVvKs/MEBAYYO4cqT 6VjRySSpOQ3k7zhmPBPNNpRpqKNbfuky5BDF5YZZcshycnGSKs2ka6is28zfuVznZtDZ4/z9RRBe 8Zn/1v50iYoVMRmciNjgMcn6VbtlEy5Y7V6c9K/Nqqbdkd1OztEqy2sFoZMKIpZeDMo+bjpVWy0y ee6M8l3JHEFwFAykmOeR2qadJ1qV3ozbEUlCcIwenUs6ho9s4e7jklVjGsaxZyjEdW9qpxCZIY1m m3fMVQbslQOlZRUoxlGXQVaLjK8NiFLV386UFsQ/O7DnaM1opPFHsLQJKpUDzGGJIenzAfQVtD4E zk5mppH/1/5252mmvbT7JNGmnhCbm5m+TyhjsO+P6VjSSSQXEn+kJcRSuSjhdm4dia/NHK81yrS3 +f5/oejKS9kmlZ/n/wAMQafcTXV86TCONEfbDtOd646n3znity5gnhvvssUiSYw6yqMouRnn6DrW q5epzRqNnKqZ72WWNt0Y80rHnhmAOM/jjP41qNMloqxqhLZ2gj+I+5qnHW6K9o1uWlELl/kSQOMO rrnHfiqM9oclk+QH5VOfugelbUqMJwlKTtY05XKk5LpY/9D+bmGRI5NkpZnYbBtBIPHU/wD16fbw 2zXst27fvlg+z4B6Lkt/Ovz2MbPQ6JytCyLV3Hc21mb1LlEtsMLlEOZWQDpjPHOPyrOhubeeKN7d 1ZHX5Qf4q0soe9LZGcW2uXqa8eqmyhihQLHJMxjeVFwz56A+3BpjNeRr/aryb40Zo2kgcs8ajrlR zU+2/wBmlKKV/wDhzWMuery9bEw0xLq6TzmZEfDuf49p74qhcWo097aG3kb7AkrDDAscn7uT2rDD TtB8+6/r+ux3RUWlJH//0f5updRCNNH5cTNAw3vbt5rnOODjpUVw82pZSCfyImVQFEQOGXvzX5tT 95OXqei7v3mX9SRLS1S3S5QXE9uGLxnfsPoV/wA9aEv8aPBbSKN6y4Zl4Xce/wClO3Qm246zFu7T W++GS5tYhcupI3hWOAQf6fWq7XnlXckDW+6OaLEEpOFRs80kklYZXt4L/RWlmZzdSNKZ1Mzbo+eQ gPYCq1vGY7u41mGBW1G4lEkx/hGBgAewxTsbQ+E//9L+a6df7VlfMrwzKBIzqdoXnsTx2q1NHNc2 sSBjN5L7TKzY+8fmOcdeDj6de9fm57BrymC1axiku7cRTnygbgHzcjHOPbr36VbE5Fu8UUkMm2XC y8lOD2oHd2sMnuLnyVMMKLDG3zSA/Nk9BWbFEuql4igeRGw5xkp35NO+ljaLuipc2sVrdWFgmnt5 bKztdLzEcdj+PGK2LqWO1KM0KxjYFBXgDsK1h8Iz/9P+cUXW6GVpQkgc/uhjkehrLt4bqa6t2WZo oA7CSAJkTEj5ee23BNfn59AdDdwSGCRQobyhxz8xrAm8+O3ilthELcEi8EwKTLx8uwfUck0AZr3D 4hgE6RXN07LDEBiVsc8DvgUsg+3TLY5lE8dvlbgpnYCcHB6emRQbRSSuasVpc6I8BhvkeZYxunaP zGjbsD2PHXFWn1G1v5luZEl8kBoU8uIRxtKvHmjIyRkEccc1jLco/9T+bb7DKI5mfAYSgiUnIdeD u/EZpUhezWWWJovMmPLgD5jjAyf88V+bn1Basbq70Jr+/tb+6RtQhSKS3WY/Z0ZQwBRegJzyR6Vk WqXF3M8ju6YyTu53596DeyLLJMqsZpCqnj5enH+RViwWZyy7g0R+XYVx+OauXwpGVRXdjJuNKdr+ RAGKEboivzZ9jTZrNLuG2hu7mW3lsLj9xHsEYXOerHkglun61BjyaH//1f5qRY39kbv+zb1bTUJY TGtyW2rJtB+U+oPPHvVK2uZbOaKzvYdjznbCwbKu2NzE/ketfn59OlZWFuHnRGkt28yEyEzsx3+W BxtTHuOeakkkvLnSiqW0DHeTI0jkF48YCgdPzrKSd2wStcm05nEAU/u9gAVAuE44xWtDOBMhkRFU nA3A7c49KguKuyGxCSCV5JI5cXMiYiUosQDHGR6+tS/2jZWsMssepQJc20wVIXYo4J6c9B+NM2P/ 1v5q7aD7FrNnfy2qXM28yujpuh+YfNk/jwaYtlMLqWFVZxNcGVEnkAXkkhQT0A9K/Nz7A2Jbi1kA WdxkoI2iD70GO4P+elVLK2j/ANLCTpLapMJMysq+STwFUdTjBoAE06HzbhLSUvubzWXPylj1ANZr 5kmeKIMjW0ojnJXEaMADtGevB61cNyNos37WSRWjRr7y0Dhm3r+7izgdP5kelV7e31bX57y501Df SW8jRzeSc+SqdWYdhxnNdMYrqZLQ/9f+a6GGK7uCCyzmGQLLIwyYnAGfxGa9S8E2yXOtRWcb28cb /Kk8j7Izg/MCex4r5rLY3xdJea/M+mxcl9Wnbsz690ywjvfDs8bOIbKArp9nIq4SScsPLjB92IH/ AAIV/YP/AMEqtJtbf4R6WiQNatfabHPPapFk6ezKs02XPcsdufrX9CeMOmRYCn/Wx+c+GiSx+LZg /wDBWW5uYvhTq8NldpNcalYtZiCaX7MiwqgMwb6xpJx39q/j98YaRo94+qa7Y3V3bXVuq2elWilo 4JUjco+1RwOOfwFfoPgvBU+HHL+8/wBD5HxHftM8gvT8z8m/2gLnUl8XXVnc38Twtp22ZPL8y5SR X2kuxHYIF69utfHU7z6hqFybpUTyz5SuCEDBAFXaB2wB+tfi3H8vacU4p/32foeRK2UUl5I//9D+ IvSiLW4lh8hZmlUeU8g/dnHYe9dZAmjXsmmeVaBsL5k8EnJMgJDtuHQZPArPER1A62MLpLGTbB8x +QZyEz0z/KrJ1XUtSuILP7EkUFrEdjWyEI/OTnPU9f8ACvDrq0rGsHpY6fRJLWxlS++2BXjBeOFc F5mGQUIPX/6wr7C8CeI9U1TwxYCaZLKOWBLhPIIE8C4Od2PQnoe4968mvpE0jo0V4rSe7vksYroz M7vLA92628eOpLMcAdB168CuwWzg0my8mOe6v5pf3jvOAsdq55ZUwTlfTPrXkOX7w6U/daP/0f48 E1KK7njdrSFYLYieYyKAWIAy249QT27VoSW9q81s8VnbxOzb5Lnbm4CEZ4/T0618tWVmkTH+IdB4 W0rVheaxqt3NZS2c1utkukovmSywjLb34yGzg8dMd6fa6XdpdNKpuYYboZWC7BQRAdhn60oSd7ms 3rY2LHT7jyrlJ5GeJmKkSbUlAz/BjHANYPiO7ktrm1DyuIrJRNt8nKA4IBJx/nArspvVMg4LVdZu yDb2S3E0soYzTiBlgaJgdyKcYz6ivLBJDfSzrEjmNH2Byu0Z/i/I169B6NGE2uY//9L+KPSbg2V7 HavdNOkc4MKwtuRzjhT7D3r9HvgDf3V74ZVr+20y0t40/fzNM09yroRlIyB90hsnIAyOvWv17wZq cvF9OPeL/Q/PfEClz5HKXZo/XT/gn9rIb9pHw/DbNOYJdKW3tob6XZbhxMrboedvADnHXp1r+7bQ GW+8B2s0cs9xbR6Cn2MmNlkZyoZUIPpuA+le79ISHLmuEqen6H2/hs/a+HU4dU5H8X3/AAVj0azh /aOuJo5XtpNMN7fzxQwM06LcTWuzzHxjbmVxnttr8g9Rig05z5MyoZpXcQjOWyTk/r0r+i/DB34O wV/5f1P4/wAYrZrjEv8An5L82Nt5bKy0yV3sVmlVDLDzgqQck/zrjtdmtbW8t2R7hZ76L7QlvDG0 hcZGTgdOexr9BaXLY4Jr3T//0/wLhhfUrEid3yf9XHJGfMP+GMVnW01jYQXc+pSy/ZLGXc627lGZ gRgFgD6jt3r/AFAa6M/iqMPhR+pP/BLv9qP4Zfs0ftAWXjP4laHc6l4Tu57Vbi/g09NUXS13BVkZ TymGYDPAIcjPOK/vN0D/AIKPfsX65p2l3Wm/Grw2iahaLNZ2HkTtdogQNtMSIxUgY+Wv478b+Gc3 q8QRx9CLnSmrry2uvl+Vj+m+C+KMBheD4YXENQ9k+V922tNFrrve1r3PB/2sv+CiX7KcXwN8Z2Oj /Ea18RajrdiNJsLfTtPut8E0sipG8isisqq5XJIAAJJOBX8lP7Kv7UPhT9lf9qvw18Q/EOr3lzpT 6rEdSh0CyFz9iQXMTIXYngNt2nodsjV4nAnDGPxmAxeFr0necZW+S/pLzPNpcXZfh+MaGZQnenGK W293r91+v3H9kXhL/gqp+xB4wsLe8sPjJpttJLB5z2t7ZTRPFxllLgFOPdhX81v/AAVV/bQ+Hvxd +Mdj4y+C2vX2q6f4dmlgm1WB00+K7miW3WE2pDb8xiAsznBDPgHjNfPcJcJZlPiKGExlO0E3F/l+ p6vEPGeFwShXwL5pc6enRb3+dvx1P//U/cX/AIJ/f8FpvgNdfDTQvh58ePEGv+H/ABNocCWdl4m1 K2fUrG/iWNOJpc5QoeMYIG4AccL+kkP/AAVN/YsvFu3034qRapDZLuuJ7GyzEvry7qeO9fXcR8JZ nlOd1sFGF4p6PyZ5dTijLcfBZlh/hnr6P7V/ncyIP+Cs/wCxBPI6J8UZFjibZLcyaUY7aJvQsXz2 7A1+VX/BTb/gqv8ABj4j/Cm68BfAnx5q097OFN5eWVkuyd3nRQpwxK7PL65wBJu4Kgjo4b4TzLHZ vRo1aT5VJX/T0+Z8rxfxDSWRVYYaX7ySsrdrpP8AC/c/lYl+N0ul+JbLxH4d1C7g1vwrfxXltcwF 1hnmgYSBADjcpIwXQjb2r+uj9gn/AILh/s96z8HPCnhz4369ceHfFekq+l3l3JdfbnXZjy1dJCrB eoHzHAUdun7T4g+H1bH5ZQxeXw/e0lZpLVp+S7df+AeHwLxXQwuEngMdO0Hqr7XWm77/ANb2Ptmb /gtH+whBftp8nxD1NLkTCFQ2kbomycA71kZQPcmiH/gs9+xDdXV1aWnjLWJpbU4Z2sII7eXnHyP5 5Bz2/pX4tT4D4hlFzVCXL3s7fkfcvijLqcnCU/xX+Z//1f1P/wCCn3/BT74XfGX4YP8AD/4U6xqu i3N80Ucur3c8SP5bOxlxbxyMzDYmDgZO9RX8xGlfEbU/C2s6Z4q8MalqtjqmlXivZXM11Jby/upC QdoPyZI3LtwVyK/q7w14Phgsqr08yh71TR3077X7d+/zPxvOM9m85jjsJK3K07em1/8ALzP61v2Q P+C+HwHvfhhonhn44x6xonjbwvpkOnXt6AGXU9iqikBySW7deig9On1hP/wXH/Y1jeQLq16EjbZu uL2G2Yc4+ZQGx7c1+R5t4W5/DM61DD05Sp8zcWotppvv8/0ep9lW43wNRqvDd2bV+rWv4+RXuP8A guj+xpboz/avENzGshi82zSO5hU4zyw556cA1+On/BUL/gqD4O/aa0LRPC3wxuNR0nw9FFhvL1Hb f3bnLSGeMAFB2AIzjbxkV38PeF+c0c4pTxtOXs4vdxaXz8jwOIeLqONyqeFw3xu19el+n4fj6n4T +DPiNrvhPxj4f8VeFL06P4i0G7hvEuJZ5Psl1tZWZZSBu4IJ4HOfpj+pn9mn/g4K+FkPg/RPB/xw 8Fz6J4l0HSYdOOqaRqcktrqPlKER2jMTsnACnnHyjGc4H6D4h+HdXPqNLFZRH9/DRpaXXzsvl+Z5 /DfFtPKsFLAYxvlbun26M//W/ol1n/gvf+ylY6feXNhpWt30trAZlIvAttIAMttJhBYj+7gGvyr+ Hv8AwWl0n4Y/tA6r490nw2viTw542sZPt/hv7VPBdQwvcNIphcKQXVQuFYcmPnBxn9byPwqz2TrR x1KUU4tJtW1s+/8AV9GfndTjbBUcZTqRnzQs7287f8E+/fHH/Bwr+zePAWpLp/gXxPH4r1fSprGw 0i6uRdwJNJG0eHKxLkAnpkZz9a/Nn9kf/gsbZ/s8ePfGGr+IvhvDP4C8caitzql0VutKv9JYsxDA lXVgSYxkKM7enPHVgvCLPvqOJWIXLN2UU2rtq601t979Lo8r/XmlHN4VqbtSipXdr6S8vvR+pdz/ AMHA3wDkgsbrRPhzrWq217cfZhcN4ijtYg45cf8AHuW+Ucniuc1z/g4f+BNkDYWHw11yXWJlaO0M mrMLGSQZACu1spbkdcYrx6PhLxTVqyoqlLS99Elpbq3Z91a9+h6mL48y+cOaMt/nv6I/l2/bN/ad 079pv43eJvihPo8mkRapDDp9npsc4aG12BxO24KoJZzgArnCjNfD0l2kF49pJazKNu7zMiWORW6b cd8V/XHCWU1MpyHC5fWd5wgk/Xdr5PQ/HJ1YfWHy7Nv8fSx//9f8kvh54+1f4ZeM9H8ZeCLybTNX 0O/W+jaFWihvWUglXIwc8dR6kc1/Vn8Cv+Djzwvp/gPw9pHxi+Flzb+JNN0eOyfVNPuprey1cwgR iUAxsRlQoIx1B65r+xvFDw8nxWoY7LP95jo1tzL1el16/wCT/EuHON5ZRl7ynFJeyvdPqn1WnT9f XT2K4/4ON/g4WkGn/Cy6uYUt0mW7TX5ZUZm6xmM2yMpHHr3471Uh/wCDkD4PGLddfCLWbYsfKiY6 sfJkfOMZMYwB6HBr8YfgpxZG1oevvQ/+SPen4hYVJOm0/vR+Mf8AwUb/AOCluo/tna3pyabb6Z4d 0bw1eyw/2ZZ3c0s8C7YxFubYEl3Zckq527ORzx+avhX4oa34I8UeHfFvhi5n0nXfD1yt1pup2TJa PHJEwddwIKlSVwQefmr944K4TpZPwv8A2VjYNTndyTXdfP18npbQ+NlxRjJZg80pz99O68lpZfcr Pv1uf0pfBT/g45Xw/wCB9L0L4w/DPT9b8VaFp1tZahqej68trPf4XYtxLFhlXft/h75/D3W9/wCD jT4YRhFg+EeoQ3E9v51rbXWpSSPcd8gqg447A1+M5l4NZ3VzKqsBH9xzNxd4rR6pWdrW9OnU+xl4 jYObc0rNpaW69dul9j//0P2aX/g46+F2xIm+Dery300JaGC21OR0ZlB3ZzEDgewOK/Db/go9/wAF MPF/7ampaJbf8I+vhLQ7G5nvdPhs0kjLxfu4li845bcqqjckZIyOTx/TnAXhNmOU59SzPN1aFN3W qeqd1om+3W2h+C8V8YvNsAsDh9rq+6v5flp8z8lp58sGZTC8PDyD5nnBGSXPc8muWvr2wkRrWOST bPIRPE/yyTnuR7V/T9Gn7rSPz2Ex6XEJtFsjFeQFMxxEQFo/l/vMelbtrPBPDp2mQW8CXAbc93Md wQg/e54HWupU/eQe095iTALNctaXscqgtbC8jYmNiOC3tyK/Zz/gnf8A8FdPij+wv4ZXwDr2i23x H8Am8LJBLJJHJYxE5CW+0F0IYscHIwTjGSK+B8ROF/8AWrh6plUfjbUo+sf+A38z7LgzPFkeYrGV PgacZPyfX70j/9H9fI/+Djfwvdy276d8Hobi0uIt8aveXcVzKyjLhMgZx06A1Bqf/BxnojadeWul /BeaLxBLbN/Z6PPLdQ27NkJJIu4ZAODzx61+70/BLPFN3g7ecoLT7+nkfn+Y8a5ZiMPKFGsuaSe0 Zb2/DyP5uf2uP2idQ/aK+KGs/ErXdFttM1UJHZ26Wsf7qKHyo90SHAz91ctzznk8gfHEd3A6TbbW UX4drlJxJ8jKcfuypHrk5z3r+ocoy/6hk1LA78kUvuPxfLaccGo0072k398m/wBTs/CHifWvB2v6 T4u8K3U+m+JNJlW70+ezuRaPJMMbRKdp3DjGD69a/pQ/Z/8A+Dirxr4L+G+i+Hvix8LbfxXrmg2s GgPqlvO9vcTyQxqm+R4zsZSoUghRySM8CvzvxE4FfFeHpVcGrYim1q9Lx9fL9X5H3fD3EzynD1cB Wf7qevo1/mj36P8A4OP9HmWNx8FbW0gRz9tu7i/uZorZegJVWBGenJqWX/g5A8ObkW0+D0F1K4yl qtxcJcS4+8RmQYHfvX4/PwUzhXl+TR9CuPacIyd9baaP8dj/0n/8FBP+CrGv/tmy6Zoun6Zb6L4U t5ZJW0+23W93YyoEGWz80nQAc4BGTX5g2/jPWLK50vX9G1C903WNEuEvdN1KzZYZ1kiIYKwGByQO Qcg4I9/7f4Z4T/svhCWQ4lJznGalbrzJ63aXRrpfyP5unnksXnzzek7WcWr+VtLa/mf0KfAL/g4i +IfgDwV4b8CfEf4caZ8RdX0vRre3i8Ty3s+m6ncKkYVluI0TDOu3n5Rkg84wB9Mj/g498LyXRtov hPbRlbUTP5/21fKfHKnDZxnjOAK/JV4N5pHFzTqRcNWndr8OXR7dWvM+4lx5SqNVIxaez0X4a/5E 0n/Bx54RjlS3PwpsPtJjV5IGvbsCLPXc4zg9OCO/Wvys/wCCi/8AwVn1L9sDw/YeEbLw/pemWH9o xvBpVi1w/wBnhUDzg94QCjE7SVZTkJweSa+j4X8L8wyLPKea4ycZRheyjd3umtbpbXOLiHi/D5xl M8BSTXMle9ujv0b3sfkTcXVn9kghtYVtUkyXKS+YkjnOR/Ic+le0/s0ftWfEf9kb4seG/iH8Orie S7ttYW61DSpNk+mX9uqIrRyowypbDfMpz83sK/VMwyf+0+HJ5b/OrfimfHcP47+zswjjH9l3/Cx/ /9P9YNH/AODkLSzoVudW+CEX9tRH7PezDWmisy6gbnCAZ568YAzXURf8HIXwzH2fzPhQLlprUyvH Ya95jwsvBzweMg8dRX7jU8H8/WJrKCXLF6O/xLy639ba9Wj88xHHeX1Ixk2+aS1Vtn5/8A/LL/go 1/wVUu/24/COneCNO+HcPhvQEkt9Qt5opvt08ot5XlIdmP8AGwUFccKvXnFfh4EabSS90TatcMVE KSbJCRz064r+puBcq/sThvC5Xe7pxs/Vtt/iz8SzLEvG5rWxb+02zk55pFNuYS0AifEh4If6/T29 Kp3s7PL5McymWb/VybgoJ+p9a+2jH3bHlN2ncq288gfyZQTeA7d0Z8yMY6/MOK6h9QuPIQXkDGCF QuyAhN/bIPIyalQ7nRTqcqR//9T8cdPVobeMesouotwEjQrx+vXmvpX9mL9pbxd+yt8VNI+Lfw61 6/8A7R0zUReaxodzGJdM1EJghcZUjIABIOec9q/0Y4yyH/WLIq2VW96WsW+kk7p9bdnbWzZ/NXDm crJc0ji56xV0/NNW/DdX6r5n9P3gH/g498CaroNp/wAJd8GZ4PEQgzdroviAzWYwB+9ZGiyik5z8 xHB+ldcP+DjT4KwXFul78J9XS2uQBBMviBYWuD0JQNBgqPXJr+boeCufyqSVWSjZ9Xo/Syb+Tt/l +kVfEHAfFRu/lt97t+Z8P/t//wDBZ3Sv2j/hprPwy8AaFF4OsntftV1qkuoPql3AGPl7meNAADnG NueOozX85tvrl7NbadqDXQ/tWGRJY9RSJYbj5XDEtgchgMc+tfqXBvBz4dyqtlOPSqe0b5tLpqUU nFp7rTtZrofn2f55PNc1p5jRbjKCSjrqmm2mrbP8u5/RL+wT/wAF1dV+BvgGL4WfGrwqfEvhzw1I LfQvEnntp15ZxEKFg3rGyyp3BOSp4r9HI/8Ag4W+ANw11HY/DXxBqj29uZ4/7P1kskoXqSZLZMAe oz+NflFXwczmOYOFCSeHeqk3a3k1q7+ia136H2S49oyoRlNNVVo1a/3Pt9zP/9X92tI/4OJv2dL1 ZpdR+GnibTra3OyWddeS4BYEDYMW2N3OcZr5V/bV/wCC3Hw4+Ovwh1/4bfCzQNR0tvEmmTwNe3Gs bdQRwFC/IsYAwrOwyw5xX9IYHwfzLD5rTxWKnCWHjK7ScrtLpZpb7b6b67H5Bi+O6dXByoUVJVGr J2Vk++79dj+Xa+v2W51aWXUrm6v9RkYPeXUguLhSWJxnkYzzjP41/Qx/wTf/AOC2tt+zb8PtG+CX x38MXOuaBpnzaR4msb/bqlsh4/eRhGV1OBk/eG3oa+x4z4GrcS4SnHBWVWk52T0TTtpfptp09Nzw eHOIlkk2q13CaV31Vr62/M+6P2ov+C9HwC1f4S+LfCnwu8PXut6/4m8OXemtPq109vplmk1u6DP7 pWcksBgEdMdTX8yP7NH7Tfi39mf43+E/jp4egi1e4t9Z/tG90OWQWqrG+W8mJs9gSM8nJHB7eZkn h3i8PwvicjzFJVq/vaa2a5XG+6dpRu7XXRM6cdxRCrxFRzTCtuFNW10v8SdvVPS5/WL8OP8Ag4F/ Zu8T6RbS+LfBfiDwprbptfT21SF1lcKPuh0UqGbIGSenWvzW+Nf/AAWT0XxP+1F4a+L/AIT8M6bP 4d8AXgsDp17rix3F1FFICCGC/fUbmG3jJII7j5PB+EOfYdzdRw6pavV9On52Pbx3G2EruDp82ju9 P+Cf/9b+inSv+C+X7I82m6c+taV4r03Wri1he+sIFS7s7WV1BZVnwNyg9Dtziuzf/guf+xfFJDE9 74kdpVBL28VtJDEx6KzNIp/Sv1+h4W8U1cdLDfVZe7rd2S+T2fy/I/PsTxnljw3tI1lqtN7/AHdD 8Mv+CwP/AAVH+E37WnhDw98LvhfpFxNbwXsep3etSahHLcWIt3l2gIgJEhLvgEjbgV/O1fTWy2yw iMSRKwMM7vmZexB+tf17wVlU8m4ew2WSd3TjZvzu77/cvI/Cc2xP1vMq2J/mk395RhSIZmgKTsoA Ji+YRkAZB9D6iu68C+K73wj8R/Bnj3TTFeSeHbz7Rf6cZDb28wIAG4joVIyCP7x9K9rP8G8XktfC X+OEo/8AgSa/U2yWr9WzGnX/AJWn9zuf2zfssf8ABdX9lrX/AIZeGdM+LY1P4deLtJ0qKxvrO1hO saZKYVEZeOT5WALK2Mg8YOa+oR/wWe/YV2K48ea5IGbavkaNDIcepH2gED61/EmY+HHE8Mxq/wCz ScbuzWt/Tuf0N/rflNWhTiqivbZ6WP/X/oM/a+/4LE/sc6z8AfHui+DNe1Xxnq2s6JdabJpMWmxQ NbbraXb52+XAEjFYwQTgvntX8XcyDUpra98NwrY6tqN6NWsoLU4kNxkyqFyOcL8uMdB0r+veDcgn kHDValmfvKd5Si+kWtYtd2t/uZ+DRxbx3GDxdHR6JW7rRP5n9Pn/AASu/wCCkmsfBzwmfhv+0Fpv i+88JzwJPomvIjalc6NNGAsimNtoMb/dwpBGxByBx+0h/wCCpf7GqXcNjN8QtSguZsgRS+G7kMjD +BgATn6Zr+daNNxxU49rn7XmMknSb7n2p8N/iV4N+LPhPT/GvgTVk1nw/qeRb3axNA4ZeGR0YAhh 3Hbp1BAv+PreO78DeMbaUlY5vC9+jlRkgfZZe1eVhG/7ZpQWr9pH80ZcVPmyfFf9epf+ks/zPPjf La2HxX8f6bF5q3Ok+Lrp9O1KGTy3gJbcgVh3wAcYI5r96f8AgkL/AMFd/D3wr0+7+CX7Sur6xpnh CEpbeEfFVzNNq9npEiceRImCVR9+AUOFVEyMKMf054j8Jzzvh3C4nAwvXhBXS3atb5200Xd2PyPw 94spYDDywmIdqcnJLtdSf5/of//Q/sOi/wCCln7EMkiQt8fvCMErruVJ1uYz9D+64PscV+e/7fn/ AAVL/Z58NeHdDn+DHxHsfEXxA0+8SWO50XzIHFuWR2TcyBiB97jjlsEHmv1DA8AZ5icR7D2T2vr8 +70PznGccYClemnaz3vvf07H17+zr/wVU/ZL+Mfw18O+JdY+J+m+D9fbTo4PEGl+I4ZbaWC7iiX7 QVdUKspbLArx81fnL/wUy/b+/ZUbxR8INb8A+M7Hxt4i8LeJ4NT1O98NWRmjvLWI72jEzhS+zCgY yuSQcYzXXhOA+JcPUqwo0pJWflp313YY7jDLHUp1ZJNp6/c/Xqfql8GP+Ckv7HPxS8FaFrWlfGDQ dCmn0+JJ9E8QwXGk6hZusYLqVaPaQOuVYjFetxftq/sqTSyQxfHHwQ7RLukYXcvkoPUyeXsA9818 vPhDOcFz1pU38VtfX8/U9yfFWExs1FdVfTtY/Jz/AIK7/tVfsh+KfgDqWh23j/wh4n8dQaZcal4f m0mBdSvYkTyyY47jZgeYygbdwB+bvX8L19dXmoX+oSiS5a3Mwa3uLhDGZVKg5/PNf154XZTicu4W pUMev3ut+u8m16aNH898U13iOJ6uJw7/AHckra9rf8E//9H8Z9F1W+0W6tLqC8a2ns7tL2yvIGKX VlNGcpLGwPDA1/WR/wAEZv8AgrtZTWNx8Cv2o/iPeW8lmVg8E6/4q3SpCm9h5bXZy3l88ByQoPBw MD+y/F3gqlneWQzHCQ/2ilu1u46v10evkmz8T4Cz+rhcV9UxEv3U+nRPbbbVH9McH7Q/wHvIUlh+ Lvw7lhlGVLeKrNQ34Fx+Rr4K/bf/AG3fgT8C/Ctv4m8GfFLwYfiBbSLcfYfDWoR6le3Vu7pGBMtu HG5t7bfMwSqvzha/nXKuEc5zausCoPlV3dp2Wjtd+fT/ADPt864sy/J6KfN78pJWVtm9X8vzPon9 ln9uH4E/tKfDTw94r0P4i+GLbX5rZbTxBoWq6lDo2o2V7GoEq+VIy5DH5ht456DFfjr/AMF8Nd/Z 5vfgp/aGjXHgnW/i0dRtRL/YV9DceIZoGmEAklERO7YCzGR+ghAyOK+o8PMkzbLePKOClBx5ZyT0 a08/63PkfEfOMFi+HFVoTXtJyopWs7NyV/uTfyP4tZ2tYJp9PuAHsVlEYZJSnmKCDw3Y+9fvN/wS O/4KyeIv2Z/H/hz4JfGDxzqN/wDAjVrpNOsJ9WUamPDXmsREFnPzRqjNzg7dp6DHH9FeKfDEM+4X qKMb1ab5o6a6W7feebwRxDHKMxjha7/dVI2d3ZJ9H+Fvmf/S/u38O/FD4Z+NdDstd8PeNvCetaJq luLi1uoNbtpIpV/2lL5BBGCGAIIpni74pfD7wP4bv/Emu+MPDWm6Vp1o8/2ifV4PKbYpICgNk9uF r3aWT5hWxMMMqT5rpbdb/wBeR89ic8wGFwlfEuqrJN+bsun+R/A1/wAFV/8Agpz8Uv2nfibq3wqs 9Y065+FnhHxIgNlpECRf2mtuxKqrlNxVjne2MnnkAgV+PGj3clg1tc3YiS2tLyKW48yMLBPGsqs0 RXphgNp6Dmv784LyKnkXDdDA0/5E36tX/rzufzZl+Nq5jmNfMatuarPm0/D8LfPqf6KH/BKTxL+z R4g/Zx8Fat8LJPANv4pi0WCDXo9NktYddtcxhNjoT5qDdDIpH/TOv1Tj1LTpMiK/spMEqRHdRtgj gjg1/CPFmCzHD8S4yOOi/ae0le/r3P6zq5lgMRQpfVJr2ajFK2mnKunz2Pm79qz4b/CD4nfCPxXY fFLTvD+oWdjodzNY3epTRQXVk+zP7qUnI3EKNvIJxxnFf5sHxe17VPhd+0h4yv8AwDrk2mWngjxn LJ4f1fRpUEGIjsMcc6ABg2zHGfvdK/evBfC18wynH4DFr901ZfOJ+B8TY+pgeOKVTBv3VS5n25lU a++2nof/0/3w/wCCO/8AwVjh/at0hPg38X9R0jTfiN4Y0OJNL1a8u0srrxEYvleJlYhXYJtYMmOF PUEBP3f8T+C/CHjmyhsvFfh/SfEdjE/nQQ6lardxITjlc9jgexwPQV9lxFkuM4b4hr4SlFrlk7Ne v9feeXTzPAZrgqOOqNWnZtdnbX57nE23wA+ClnfwapafC/wZa6jauslveW2iRQTxMv3WBUDkYHPt XoniDXNL8KaDqeu6nNBZ6Zotg93MzsIIkSJCQg7DOAoA7kV4kqOYY/FU6VROU5NJX7vQ2xuc4HCZ dVxFWpanSi5PrZRTb0X/AA5/DP8A8FZv+Cq+r/tRzat8DPDOi6bpXhXQfEgWW+tp3mvmW2LHALEL ucn5nx/Bgbc4H31/wbgfGTwwbH4p/C/U9bsbTxHcNbz6ZpNzeol3fbCxLqhOSSBjAyc445r+jOM+ CKmT+G9DCYeF5xXPLq3/AFdn574VcRf2hmuYZjinZ4iLsuyTtFL5Jfrqf1Z3FxBaQTXV1LHBb20b TTzSsEjiVQSzMewAzX+ev+2V8UPD+l/8FP8AxP4oi1aKXSbL4vC+e+jlVYUTz4uDJnbtAI749fSv hfCzLsRi6OZ0oxetGS+bjJI6eI8fQo8UZS3Labb9E4n/1P7vvhl4q0jxr4A8I+JtCv7TUtN1Xw/a 3EN1ZXCXMDnyU3AOpIPOfwxX4tf8HBXiDTNP/Yq/saaVf7S1DxZDdW0PmBGEcMbiRiT2+cV954dY Sv8A65YXDuL5lN3+Tdz4TxVxlCHDeKqJ6Nq3zdj/AD7muZprdg4KKo2xwMweSNQAACR1NcqbQXIu LYymPzHEh3JkoR0OcfXpX+kNBaJH89VJe5GxVtb82+pGzmUSadCoHmxKTIQOGzn8MfSrqvbxn5Tu gkc+VkfOCSe1dZjzS7kN9pjTojl3LsQVU8LwazvtEMTC2hViEP789PwFNJvYxlN30P/V/nftZpbY OLQMqSLht3PXtis+6kuXimLsske4B7dx8rdcHFf60tNbn8Zqfcfp1tevGLqAJD5cThkjf5U44I+n pVezgufKuZJZBPcM5dHkHK8ADCjsMUgc9NC5Bh4QZZUadAA6qeM/zpjC2RlaZVdnUqo/DqKai2ro zcrPUoy28RWQsy+SrZAP38nHeq1zILXa6piPHRRwPrRZ9jRT7n//1v5v4ktcLfQXM8U0mcwnKwj3 6/55rZ0kQSXcEImk3XMm19rblbPXjP4V/rWoPqfxn7TyLV3p9vYpdrYQQgSHa52Beh7AcZ/xqnbq kUQlkgwyrtGBySPSn7PzDnJ/OnltxNbkYLFXVuSMf5FYct5HMymXJVJNhKc89MVna2hoTPclQ+9d oH3UPVh24qvbXpvI1Ig8vZyVK7QMUWFzJH//1/5vJgpxKYVkCsG8tvusQeKnuLu4EHl3tkIYmXLO DmMoenNf6zuKe5/GvPEgvI1+xh7XcI403ADkEdjWZo72kpuvNLy3MSbiFHQk9SPoDScEHPEt2ciT zHYhV4n3ZY9PcfnWwk0P2yKOVu+WYnCrxjmjkiHPEo386SXrxlSbWFAS6tyTznjrSpc2YVJkWKWI JmMqQxb3I/xppJbEObvof//Q/mvl1e7u3+x2byRFXWWRohztDZx+PT8au3MRlkjm2sJHUbtxxjjG a/1oP4xcmypN5gKI6Ek8Rkfcx60jW0i3kDCZ47dkAkxyqnPXFBJOupwx3FzZtcvKY5MQhk8rcuAc gZpE1GSSM2t7bwuol3RMMNtGcgk46jA+lAEflN501y7yC0T5FKg4dsDp+lTLHCBIPMdJJV2RjbkD OeT+lAH/0f5tfssVqwWa6kKFMgKuWLVOEE0Ee5iQX2g91HbNf60H8XluKCOFQS+VU81BcXaOTbsF MfXC9frQBWivYISlv5oaBHwfNPC1peZFvR0lwM7vL+6snsahwXQCG4uY5fOeIKfMUjb97A9BWVE9 sF8u4jKmMGRiwxtHrU8jGtHc/9L+bh54Xydo2BMRsOPzqlb3MCS5JY84YdAfav8AWKUeU/jWMro7 LSXsbm4jS4VEgBBIJAZh6DNT+JbrRUmaO33hTHiJYyGdQDg5Pp1qJLRjur2OTaWGxQT6eZ3JG9Y8 HdnHQD/Gk0i6SS7eYBhKBiRcfMjHtXO0aQWtzoLu6trZ0kiQxMVG9WIbJ7msPVZJbmBxazIspQuu 5tqtx0P19656/wAMvT9DelH30l3P/9P+SnVkllvLg3cUKPHOcCFi68emen0rfMPg+TRl86bUJr8Q SROjoFsYZWT92xC/OdpweeDX1XGdv9aMc5f8/Z/+lM8jI1bLcPf+SP5I8hNnHB91iZC25o95ZVPc AnnFT+f0trnPlt0KnnB/ya+Snse3Bbn7G/8ABF79p7wL+yt+218MfG/ji7i0zwxe3a6Rc6rdzt5W lNIhh80nkKo3x5JxgbieOa/1WPCnirw/438O6T4q8LatY65oGuWSX2m6nptyl5aXMbjIKyKSpI5B GeCCK+U9jKlxHUqy+GcVb1Ss1+X3n1leqq3DVCjHenKV/wDt67T/ABa+TPwL/wCCs3/BNz4w/tff F3wz418FWkOpaLY6FbabsWXNxZNDnzF2443Ek5PBDcHOcfsF+yL8JtV+B/7Pfw4+GGsoiaj4W0VL OdEk8zacAkE4HOc9u3avbzRvE4/DSitIRs/vObLp4fCcI1cHf95OfNbySR//1P6kf+Czfxh8CfDn 9h/4raJ4k1+wstZ8UWNvZaRpcl0iXt2wuEddsed3JQAYHP4V/JP/AMG9/wC1h4A+D37bGqeF/iBq 2n6FZfEzQ/sGi6zqUhtY47lJmPlGQ/Lhkkk4bB3Q8A545c+oTlkVKm+s7r/t1tnLwtFVOMcRJPaH L83y2/L8T/Q6gnguoYrm2miuLeeMSwzwSCWGVWGQysOCCO4r+Rv/AIKp/wDBHb9o/wDan/ab8ZfF H4d6PBf6Lr189/BeRXQikRZEjUIy4+Y4TBA6YHckDP28qODcqS5m0j0amFjUx8IVny8rbfyPb/8A gjV/wSq+NX7Gnxf1bx78TNMOkxtpstogV8W0yvkfKCOTk565GfTp/TldXVtY2095eTxWtraxGa4u J3EcMKKMlmY8ACvCyCnWWJxFSrGzlK6XyS/Q+p4rxOGq4fDQwzvGELN+a1Z/mjf8F1fi/wCGviT/ AMFCfilrPhO8TVtL0qcaWbyAq9u0sFrbw4Djg8AcAnH4V+ZH7Ovwn8e/tG/EPSvhx8O9EufEXjDU bpEaxhjZ4bWJnAMp7ZAbPOABknpmvf4knHDSlOq9Iq7+W58L4e0njPZUqP8Ay8qWV7rdqz7267bH /9X+uH/glt+zt4t/Zh/ZI8D/AAx8bWTWHiCzeS6ubZ3DuiynzFJwBjJduOwx3yK+0vi94XvPG3ws +IfhHTv+Qh4j8G6jpFgCQu6ea1kSIZPAy5UZPrXyvCUJrLFKpu239+v5M+q44qUaud1fq791WX3a fmj/ACqP22v2fPiJ+zt8cvF/hfx1oc2lyX+rz3Nit9IYZtyMQ4RCASGOewIxgjOQM39hW/t4/wBr j9n+W7g8yU/EqxsIbe4jYRZeeI+YGB/hIBA9vateIFbCYhvblk/wOLhjkp5nQjTd0pRX3aH+sr4d ZX8P6FIowr6NasAewMCEfzr+ZL/g5wuII/gV8IY/PiS8/wCEiuHhgYkyypmISMB/s4HP+0K9HhpX yyl/17PH4wa/tKrf/n7+rPon/g3XRF/YkLjPmHxZdIwJyQAxK49vm4+hr9u/i2/lfCv4lSbwmzwD rDByMhSNPuMZFeTw4+alXS/5+S/NnscUK0oX/wCfa/I//9b+ez9onVVm+JPjfXJ5n8q98U3rxWqn 5UkMuXwO+75cey181XF59o3MiFVznb6CvFrpqq0zDCq2HgvJGctyI45WVVRwwCkn73OK2biJZFgk jEzMzKJRDkkKTyTjoBxmnHZHbF3gz1H4U6wmh/FbwPqk0Yt9N0jW7fVLyVLnCiOGRS/ynjIXJyT2 r/Wr/Y8+LPhH4zfs7/DPxl4N1ew1fS5fDdvZNNp90l1HG8MYQqSpIHTGPUH0Ir5PG2hxPgm+qkvu /pn1uVJ1OFsXT6qUJfo/0PmP/gq9+zX40/aj/Zjm+HngXTZtV1pfEMV6LeEFyqeXIm4oOWAYrkAH r2GTXxh/wRn+BHj39jWDxp8JPi/pB8M6l4sl/tDR5LpTbQ3UokzsUtxgqMDnJOOOePoM7q1FHD04 LRSTf4o04cdGGFxim/fnGyXpY//X/vznjMsE0QODJE0YJ6DIIr/Mu/4K8/s1fEn4NftReN9c8d+G ptO03xTql3d6TdvA8VnqIlmLxukrADLfMPXr1rhrVEsK13t+hzY2m4YqE300+9M/El7W5ivXe4lS 3MbE+UrhlYc4AJ54FUZrmPexiCyMT8gcZTPvXjPc7ua0U0W4VuxHLcqF3R84Ztv/AHyO9a3h+9tn 886xPPHOr4tNw3iXJ4HsAM1kn75vT6n0D8GPhv4y+LfxA0jwN8P9HuPEOu6xKthDZ2ULXFxH5xC7 gFBIIBzuIwO9f6YX/BJr9nHxj+zF+yR4U+H3jmzax19p21K5t5UKzASqHXdx/tHnjvxXg4qftM+w 2HjvG835L4V+LZ9dgUqfD+KqzfxWivN/E/wsf//Q/uq+NcqQ/B74pSyNsjT4f6uWbO3b/oE461/D v/wRfeHVP+ClkskwNwy6teiMoQ3kYlyD9CoIr5Diy39kyb7r8z6bhGVuJKa/uy/I/vVH9SP1r8of EvxS8IeCv+CnFroPiPWINOufE/w/sdN0oXVwIYjO1vtRBnj5trcGu+o08uUnsuV/c0cuG5v7RlCC 1fMl8z9XwQQCDkHkEdDX8an/AAVB/wCCUX7T37Rn7Vnjv4j+AvBV/daTqfiB9Q0zU4F862uI5VVS GYcgkAHoQAcdc46pyaw7aV20v0OCNL2lZRe1z1v/AIJZf8EU9X+Hvj/VPF/7T3w7027trGSK5tLL XLcXC3MkTll2IRtyxEeTj7qH8P6LviL+yl+zV4i+H2teG/EPws8EWHh2PSJoy9to8NkdOUxsN8bA DB7epzxzg18plmWznXrYjHKzb91dkrfqmfTZhmMMPgqWCwLbjGLcrdZO+/yP/9H9Pv8Aglj8Cv2P H/av+Nfga60nwj4rv/Dmv3reARq6xzPcxQXk0capCzcuiBTwM5H5fvV8ev2DP2Z/jr4E1zwpr/wn 8JwXt5YSJp2r6XpkWn6pZz+WwjZJlwRzjk9OD2r4PD5bFZniJ1Gm9Fa3RH2+Z4qVTKsJyJqMovbv d3t6H8iMv/BF79rz4bfFG98QfDvwh4gNpo+tTNodxAj28nkRy7oGWVQMZCoeMHI+6OAP7AP2LdW+ Pd58GvD+mftAeH00nxZoVomki9Z9t1qMcCIkbSoR97aOWHXH4B0aGJhnvtYQtS5Wr/1p0KVTAvhh 4Vy/fRaaXXsyH9ub4PfCT4t/s+eO7f4sWNkbPw/oN1q+i6xMyQXul3UcTPGIpG7OUAZTkY54Kgj5 B/4I3fFbwD4o/Z0ufh54c1vSp9X8F+I7sTaRBdIb2K3lkLRP5Wc7cDGQMcHuDV59yxxuCqt6c7X3 2RxZPKrUwWLw0b/CpW9Ltv8AB/cfpL8ffCeseOvgt8TfB3h+NZta8R+D7zStNhYgCaWWMqqc8c8j n1r+HrxV/wAEPf2vtX8V315D4F1T7Dd3523crMkSRAnlVx35+ue1ezmKc8K4QV27nn5VSpfXY1K8 uWMWvzP/0v7B/wDgnD+z54h/Zk/Zb8FfCzxRE8OtabNPdXkUg+eMytux789yB16A8V3f7cvxD8P/ AA1/Zd+LWva/fwWcLeGZLW3WWdIpLh3kjG1AxGeuPTLDPWvjuGcJPA5f9Xrbptv5u/6n1XEuKp5h m0q9HSLsl8vd/G2hyX/BPP4r+Efit+zN4I1HwxqlneS6ZFJYaraQXCSz2UqyN99QeA3Ufj3rQ/4K BfB/xb8df2XvHnw28FW8t1rutmER28ODLLGu8OFHc/MvH5kAEjvymvTq4SM6b0/ysjzsxwlWjiHQ qqzdvueqf4n5hf8ABIL9l/xz+xdrnizwt8U9MudIn8XxmDTLu7/dox8wOiueAMkFR+fHQf0IV5uQ YWWEq4qE93Nv70mevxHUhW+rOk7xUEvmm7n8D/8AwWa/ZF+MmjftY+MPGsXhy+u7L4jay/8AYVzG rC2mEzKI2jfG1i4TAGexHVWC/t5/wQe/Y++Jv7OvgnxH4w8deHrjQrXx1pMMtjBfxtDdjaVKFVIB CsrFgDzhh3yBwcSS5szwuFp6ycoy9FFa/kd/Dk6eHy7F1qkre44r1lpY/9P+/iv4K/8Agu1+zn8U PCf7TPi/4y654bvW8I+IL+RNN1pIf9DS1kbfG5kAwSMMfzHUMF8vFK+CcfJfhr+h1wssRFvufzv3 k6JfAC5JjY7Wi4wSD1B61+pX/BI74o+Evg7+278N/GHjbW7HRdKuXXTbG4v5RDal51eF97n5VA8w NliOgr8+zWnKeBnCCu7H1vDNSMM8hKZ/pNaVquna5ptlq+k3lvqGm6hbrdWd5ayrPbzowyCrKSD6 exBr8Dv+Czf7BPxk/bF1n4eX/wAOPDJ8Q2XhrS2tJ44nBlEjSvIcgEMoHHI55GM84+iwkrYSKXY8 PHxf1uXqfmB+yB/wQu+MVh8afDXiP41+ArVPBdhqH2vULbW72W6hEbZGxEO35u+cnnHHcf1naJ+z V8BvD2gW/hnS/hR4JttHtoBbrbJoMC7wqhMsQuckDmsb/vebsaSb9ikf/9T9xPCeofs6fs5/8FTt Q0Pwjq/hvw/pes6dD59pb6lDFb2N1co6yx4yAowCQvcA446f0YxyRyxpLE6SRSIJI5I2DxyKRkMp HBBB4NfnOGusfUk+p9biGngaa7H8vH/BVL/gmR+0r+1F+0Nqfjr4ZaTHdaZfWyxW1+HCwwx7ApWT j5j2I7cc5zjm/wDgnh/wRR8U/D74s/8ACbftJeCtD1HTtOltrqG3uovNguHts8KjdiwjONpPynnG cduKd429Diw7anp/WjP6Odf/AGcPgBqvh260TWfhZ4FGhpZNC4bQ7eH7JGqkb1k25UqOQc8Yr/OT /wCCofhr4M+DP2wfHPgr4Lz202g6PPPHPLYTLLFBOJmVrc7CVyvX1GMYreE37E47f7UfmhqF09xJ HHAGfZKYpeNrLg4yf896e1t5EU8twwCxIGTBy0mewH61xStzG8YqS1P/1f52YpEkV4zt/fxtHEW5 8sn+LHfHpWjbWdxa6jaWpDOmUQrs/wBYGxg/rmvz89lqzsfvD/wSQ/Yd+Nfx2+Mvgz4qaL4ZubT4 feEdaEg1u4HkR3AVl8xxuHT5QM8YDfXH+hBp0Elrp9jbS7fNt7OKCTacruRFU4PpkVy0l/tzfkdl Z/8ACdFef+R+IH/Bc/8AZz8ffHf9nzSbvwZodx4ii8H/AGu7vtPs7d7i4iMgiKzYXnA2d+ODX8C/ ia3l8P6vq2k6nYXGl3Om3LWd5Y3EZiktHjA3LjqPUexFelOTVM8un/GRh6f4hn0+90XV4RBJHp96 kpN0AAsZ+VuT0GG59s1/pbf8Evvjb8N/i/8Asq/D9PAviTRtXufD2kx2esadp18lzcabJsUOJEB3 LiQSLyOq+4r5SvQ/4XsPiuvLKP6/5n1VKvbI6+FXeMv0f5I//9b+1b9sv4a+J/i7+zn8Rfh/4Pg+ 1a7r2mCC2tx/rJgG3FUHduBgev51/IHY/wDBC79refxJBrNx4XuINOn1cXj2j3caNbDdkv5Z5zxn nqT27fCYt/uJJdn+R7OE/wB4j6o/sa/Zb+GWsfCD4IeCfAGu7RqOhWAjlRZRMY9wUkMcYznccD17 HivmT/gp/wDGDwp8K/2dduv61Y6fda94w060tLS4ukhnuY42kllKoTubGwcAHnnoCRnlS9lgVB9L /mzszKpz43mXW35H1F+zH8T/AAp8W/gh8O/F3hHV7PVrGbwtZWd01pKJDbzwwJG6SL95WypOGAPP TrXx/wD8FTv2Yfil+1H8EdG8G/Cy3gvdVstZkkvLOW6W0d4pkjG5Wb0MQ6eo7Ekd+Fk1SfqzkxUr 1V6I/nB+AX/BD39rTwX8ZfC/i/xN4UaPSbDxLb6hqUkmow3ERSOXe5X2bGenfnA6f2ueFtNm0fw3 oGlXAQT6botrYzrHzGHihVGx7ZBry7NZpGp2VvxZ6Htf+Etw/vfoj//X/bT/AIOKvj14T0H9nfQP gza3cd74y8Ua19ua1tZUkbTYITHvM4zlM4xgj+IelfxD6ZcprGqwWEH2261G9uorWz0+zUvdzSTt sjQL3GSAfavka837OyPTpP3z+0n/AIIXfsI/GH4D3eo/FL4h6Lc6Fa6/ZRXdn9tQxyyLJE37lQcH 7sy9uMe5C/0518vw/hpYaeJqzek53Xy939D2uIcVGusPSj9iCT9d/wBT+H3/AIL9fs4/FjTvjp4g +Nl54c1C/wDBN0pls9UsLd2toIXkZlZ2A52rkEdtpz901/MZdwG4lL204aJ/3pkVjtI6jH+Fe5Wd 2rHzEFa6ON1SyvbqYypqEkEUaBNy7WZME9AQRT3to5AnkXDTrGoDSSgI7NjngfjWa+FoifxH/9D+ c+OawtLh/wB0r3kwVTKG+diPuqaW8uGSWMSLtfjzEB6Yr88mtALDsdSlih8vzYwmducYwOirTmv4 w0q3INnb2UWAIo99xcMCeNvb/wCtUxi9GBSs5ruRbh7yRwrj/RlK4WJe2ffH9KXbBbjDP9oO0SP8 mF+n+fSiSadjs/5cRRRkazt1S7gWWMvMTcw7cIBx82c/X8qvx30+nIl4gdrOUNIk5TCY7gcYOOaU XZmZ/9H+c6S0kvNQsdR/drpN/CZ7iRgQ2Rx8q/UEnjvSJqVsi7AwZQ5Cqo9K/PW1Tw860/6R2YeO nPLo7EU1/BdkFA3C7RvQr07c1YttSW1KrcLsjk/drgdTSpTXs7xOup7zUiO9ne4lSSN5Y4YwQQpw kh/+tkVWS5gLRxx4JUkFjyGbOMfh0rCMk27oxhN+0aaLG29FxLLGiQwzqqTQqSiMAR83OeeM49qm uLiFHSQiMBBsCt8u7Harmo+z5Y7ClBaytqj/0v50PNXULJoCkHlGYNuZsGPHI49OB2qkYIdoBILL 909vwr8zgo3s2d6V4pFZ9PiMDEuyEnrG21/zrIFzfz3i29pI/mrIsRMrEROhIB3H6VUabSUXq0Y1 UoaxOqvrJLYpIELzRngZysZ9R+dRboptu8YmHUAc/wD1q6qKesWXWjGdN3RBFMsEkjMvQ7ACP1qV dRsXK28zH7RKxEKKuc4GST6cU5xdNXFh5JQUemx//9P+caGe1F6pRtibCkxaM8kdh+lYN5eQ28t5 PaQM8hb5Yt+M4zjGTivgIzUmkun+Z0VUr8i3QQ2moSRBVvVkafDGORflXPJUgfl/WtG90+OJorsw JaxW0QiWOE4TCgAkDpzjNaVEuR3IpRvJMh8RQsiWLWMvEsOZXBU7SRxVvQ5I7Dcs77VRTudm3LJn qc/jXNCSWHcf66mmHjfGSXl/kaN1fIrGe3gkcsAuI+SR6mqDzTfZ3SV18uWTe0ec4I6D8M1yTfJC Tjv2O+EbKKP/1P5u7KztrRZ7iFECyuZ5cfM7k5yTUii3Zlkh3orH51IwK/OaEeWKierNWRhavdNa z2sMNhcXglkIZ4F3mPvl/Qds1pXttd3wsy0KWkdvCrLDavnzTjJMh7kZ/T2rXlVrGQyCxaBLi6gk H2yRfLjDjg4yQD7ZNWYb0XkD2lxbvDfRFWMZUmJ85yVfv0qeRJAWHaSaS3sJmmjhkBLy7T5UeO+7 1qpHef2LqUTIYryIH97bSHh1we49ayLg7Ox//9X+buG0hNncXT3EUJL8wIcn5iTwfbj86gsJWiga KJX2vJ/qnPBwSAev1x7Gvzc9g0LiJpggKDKHIbGSvY4qmHhW5gt5JHRVczLGBiORgMc/nQBt2kiy SPC6bbdGDKCpO4884r0bRtC0S4nuY7PUYbZ7qyJnlkCwSqMZfapP3h/TvVKLa0NIPWx44bhZLvba Xl9Nb20zRxtfQiKScKxG4jtuxnipb28F3Pb28qts3hWC5HTv+laxXKrGh//W/m5lEbyPsTEYURpH 7jv/ACrq/Dmt22jSCPUbGG6tpXDSWsp8sTbfujeBlTz2r8/PoDJ1DXZLm/8AtFzZ2GlyXkmY7Cwk aW3hwOEDEAngdxWXf3MgbcdrgHdsTAHXvQAunabbSznU5QHuI8/Zwy73g3DB2+lUJ4H0m4mv5pnU IWAZULhVk4wQB7/hQbx1RNdTotlAkKl5jJuld23B1OMn8OailuY7m3SDe8Rgf92qAbj65Hp0rKe4 z//X/muW4uJ3gslEqRSZd7gxkqAO2P8APSkufOiQQRKrln9cfia/Nz6guvHd2iLp+pWISWfbLHcC TzIkXkgKRwc5HNRQTSW806YV4o12LKp+960Gin3C13agJh5cnlITkuhXafXmmRXZzALeWMW7nb57 HbntwKCJSvqyTTobmG5aS/u90UkxMbRr/q0J446k4qXVoY7y1kOno15clyqRspjlOD1H4ZP4daCF JM//0P5pbl/s1vbAxTSsriPzACzIeRk/p9K1ZIUjgja8CSvIgdRuBaMHv7V+fn1BVim3KkEcbC2d toJTHfuPzqzcyWcCeQzqof5QucbjStumBFG4DxLJhYB94gfdFaLPBBJbu3A3boZHHyn86zcH0Lp7 lddSsrvzJIDkmVkcKmzLgkEY+orOe2tLuC5dosjdholTzEY+4/KpacdzU//R/mvgnjF6YZpSkcVu D9350P09OMfhWQ19Hqbx7rpoYWlKQSxYbziuRtJ7Zx9a/Nz7A0I7G0hmDu8jkdYpFGyMf7P1681o T22m3FhcODG/nkwGxkjYHBB/efgcY56gUAQ6XNHplokFsGaWI+Xuk+9ntz+IqzczRQw+YYw91eTe TLls/Z+MlzV01qRNq1hba1822kbIcRkIWyMyA+g/A0+G0+z2l7HYXkllcXh8uVbf5N6H7wJHXOOc +tdcU7mR/9L+cPTrS3spQzyLhmy0WPve5NeteEoIjqVvOLcJE8gCYH7vJPDV4mURvjqMf7y/NHv4 x8uFqPyf5H1/omiyy3elpbzLbWsd9Bczq3/HtIyyKQ20/wAWe/ua/sw/4Ju6NeQfCXT2jiSF7+yM s1xFIGiZMq2FHbLE/g1fu3jN7uV5fD+uh8J4bR/2nGM+Xf8AgsD4ii0nwIiJDBcXK281vFbDEpuS ttIjO3oP3i/gK/k08X6/aSQJeCFoIfJ+0x21quxYnAzgZ6L05r9J8IouPC8X3bPkOPEpZxf0Px6+ Oi63ceIbu9tZwd9yZrz7SpkmdflyAPVs/TmvmPUIzc6ityUt7JEjWJnXPzYHLY5Oe5xX4VxvO/E2 K/xs/Q8njbKqSfZH/9P+IyE29zObQzZgjUtDdqpCu2PfkD611NpYapoNnFNDNYzwXcIf7Q22WUAu TtA6g9uOajESVrAbFvJJeMFZVaKQfOsgyUNdFMrQtut1cRtDtClujdz/AJ/OvDxDXNoawVlcXw7p LXuqae7eTuiufminb5ZFPDbAP4sZxX3h4S+waVYz2djpyXkV1axrDO8JhewbgsoXp/eB+gOfXya6 VrGkd0TXerlp2jNtEsUOyJpMbJYCMjGMcg5H51V1DVo7Z4omlbawAk5wgyfWvGmrSOhJvY//1P41 JRZ3VoVBeSJAHuU2kK4GDhh6dK0E1aKC8id0aMT7VtonJMLHH3Qev518tXXvIxg/esek+D9TfTH1 m+a189rtRBGjktsU7SBGMHGCDk843V02tXkd/bwT6XaalNL5Ah1C3SEzvYSAYZwQBmMnGDjjI69a VOLexpJ6oEWZ7CB7o20v2NVX7Sg8mYFxjYVOM4PBwDyPTFcd4zuJYY/LaOORktd8eSAJA394/nXZ TVmkF3r5HGaVqMunAGNFmZoyYkcndHuHzMPwrgb6zu447ozTR7riZmhaCLYyITkbvU8dRXr0Fo2c k3rY/9X+KbwlqcGj3N8zaNY38U0HlLNfxt5i9dxQ5ADHjH0/Cv0E+AHiJZ/DuptpNvJY210Fglgv 9PBFw6eXu8okEdAhyCM468V+o+EM+TjSgn1T/Jnw/HEb5DU+X5n6ofsR6lAvx18F6xpF1DHDp86x 3KysoktpkniZ4/LPJyu/8K/v58By3Fz8OYIQI5dls4XyCERX8pWUH0yCDg+tfYfSHjbH4S/Y+l8J pOpwLiIp6KT/AFP43/8AgsLYata/tBa3YIjyPf27wGO0iEjXKhLW6Ub8/ewwyPRj6V+O2o6b5s8G yCVVltlSSGVf3qNjnA9c5r9+8K9eDcHf+X9WfyTjm1nGOi+lWX5mYssdhEEuh56WylUygBC5OMgf WuOuzFrN7LqNkGtxZDZA0oKFXwN4Uj1IJH4V+ltWSPOnpE//1vwdtor61siZ1k4XcJXUDbuPA/Hp WN/bEdnH5TwW2IJzLM88YKsW7PnjBr/UZx0Z/FUZaxZFp2o3Vgr3VhHBayTOTcC2hDI4OcKQwwRW 9P4guYkbW31PVrPU7KDdbLYXJtSj4wGVEAIPbrjHbqa5HhKNWK9pFP1OqtUqudk7I7KHxj4qvdFi ht9QvJJi0V3dzXF7JIJSORuBOD+XaobjVXhs2tZLn7Xe3EhnuhNGsvmFjk7sjleMYP8AU1yvK8HR jyUaaj6JLy6eSSNMPKUHozm9OvLa0vJF1Owkt5b5jHBJZM+n2VwAOMRqQgxjnA55rufOiuLKdE8g wRJujtYVKkuRhi5z6AfpWFTLsPa6iejzztZs/9f8T9L1O3tEu4orGzt/NUJ5xUTT5BB3LkfKcgcq a6nSNWl02RJINZvI/PhKz20d15UDDIxJ9c9K/wBIpZPgK0vaVqUZSta7Sbt21P5L+s16aUITaW/l cSbWSYhHJqF3PcRXDSyTzfvVuXfu6sCrdfTArn9Wvb5NKkikvDMUlNzCJJCvkHBwEUHGOehFawyz CU4qNOCSXlaxaxFSd3OTbMO0nU2gklVhcEblyMeZ/tD60unRRam9+ty9taWw2XcogdYp7k4CDLdS 3bjnH0rRYOnzO6CNW1LlidfazWNvP5UDSJDIiiVJJmdHCjC7gTziqMhtPtf2SJ2/012KQLePCGCj LYww6dfatY4KnF2sYSrya1bP/9D8fjBbWMS3Gnym5kcAlnunupIMDBXcxJHTp71y13q0tzMIDNLH l+YmGwttOM49K/0vqYSmpKyP5Pw9WXc0FlEkUcm62uCp2hrmNZACOmc9MVl6PZxXmv3uq6nDE7Lb +UBwbWRuAr+XnaTgcEDt61rHCQ5dinUbe5q6hdRtbvYW0EcdnJKZLgxAwyHIwdhXBHTsauSazqC6 Ymn2w8iKJVjglG6RoQvQck8nnJ68+tU8JTtsTKbS3JI9TumzcCYxzYG4sN0YI6k+tFpPe3puL5r5 A0EoICYDMOoYe2R0FYUcNDlTsZ1KjW7P/9H8aLnUlk1mDVdRu5ZbqFDALoOzBE548sHafr1ouPEu o3gjy8MaW8uYgi4aaMkZyeoIHSv9N5YSCVrH8je1eupPpupb75ovtjyQooeO1WNP9HPUsJANwHHr /hVifxOLq7uY2sfMt2cRySNJ5sE20BcbDx2/TNDwsLps5p1Wrq5hXNxHPOsMkUcdo7/uIBCI0DdS cjnPHrUGr+I1QPZ3BgvbeJVRxgPsKnheOhHvyK19ikrIyhUblYqzXd1cJEILaWG08oGGFlwrE4ya t6bcKLwJd3i202NsZmUiOPrkkgGsKdFKpZG0qjUr9j//0vxZguY7EzWjXcmome6eW3ltsSQRZ644 HAx1PNbK6i8ELRRSCQqMxySDhSeo/M4r/TtU1fVH8d1Zs5+/8Q3un3kbfYmmk3BjNGm+MegJ9a0L PV2NnaJc3LWk19csYrOVgTJgk5XPrycVbhG1hU29jrL7zrLS0vJXtRvl+zW9s9yjXE5253FRzjg/ 5Nc3b61/aMax38bWr2+YxEq4wpOR9a5KlJOTSR1U5Wh6mNqIh0q4iawuDdQ3cvk3btEPOlOflwfR f6/n0p1m1tzBfXryswtjbQM3zBOhZc+nA4FVCkrbGMZJSsf/0/yAsfGQu7eOUW8cE53x2rFvMkCK dpycYB6Hb6Y60zUdT1Ga3dYkhkRkEnmFg52g+n8JBHr0+tf6eKlFO5/IUpJo59mlllhkdkMHljzI wNxB9z/Sql3NaieJriOIKmI7crEN5LHsQK6IRtHQxi9WhNSnd2zFGvkRRF9jE72wOx9eOlcv/biv HbyR4tfKZnnkZSGYAEBAP61vD4iG/eujobC70650xLgXERtrmTdiMgbxnJ56VoI08yCWylyFch1u W+zDC56E8HisZw5mm+h006jhSsvI/9T8jfDMlxqOuWWmSsqpdTrbRbHB8sscFs5+tZ2sa2ND1yCy 0xpr7SWeSzlvFkCETb8KATnKg56etf6i+zWx/ISxE07opalcakRthIeQnPlOd2SffvXA3etXi3iR lY4LqBsTP5fyHIB2gdO461xTopJxR1U6769zRinvLl0dGO84eVB8oP5fSutsNQt4kdILnnJ85R91 WA/nTpUo7MqdeSu0bEFzdO6RLcq6TMu9ZHK7VPovr6Z9ap6pfahpuqX1nHcSkoFj27OEAGeCR1PP Sk6UPeiYyry9nI//1fxr0jUrZ7i6W7tZBJCPlnIA83dkkA9e38qtxrK0cq288kKuTLGGOXOeoOf6 V/pk6UebkW3/AAD+RcBO0Cna3V9peovdgRBJoClzKxw5CAsuPf6eta1nryXDgTzE2l2R54RgJJVB yQGPfitlh4PdGiq2bC41OGfdGuFjEm4A98EEBvWs+8vdOFxFNazRySysPtMKtwnbd9e1Z16MFT0R r7W8GmdDb6xa21rcRSaYs8gw0Ejz7YQcDkqB2Pv+dY8uo2oMly7FIwpZ2VdxXg5AFYYfDqNOMbdR 06nKn/XU/9b8YZNelh0t9VtGY6e7eSGkxGpLEZGSOD9KovrfkR2senWlttdwJ3IzIQ5+Yj6A1/p0 sPDl0Wtz+R61d87S7HWWviaGK0igt70ubbdHGqkiSNehBPp1GM1zRvY9Sna4bHlWrGCL5sqCPvAD tyTWuGpKkpRjsc6leXMiK5TzwXRW2RqcqoypzjJI/D9a5+406C7t7iWCHNzakCOWQmJVz1H416CV lYxb965Hpn2+FLiDytkcgVpmUcyEHgY+mea2JZHZEheRYhxgt0GK0gtylO2jP//X/Fe3sNQgSWR9 QuIo5IwbYpjagOc8dw3ORUOoTPaNbG0iMsjKRK+7IJ7Z9M1/qZKFp2Z/IKlzK5rjUPsDxvOkUNw8 At5CMMTvAJjDdwcdO+KtWfiXUGsdqQmP7I5Nt5ibmjXPTB6AY6ConCNloTGb1SIJdemeecqI5JJ0 Xe56MPQj/GomnvZ1a6WMMlsgMgB2hAeOBXm1acVW0X9amildlrRtatzv0/U3N1FcOWgEsYCR8cBu Oce/X1q62quZmha0VbJojCkcCgswHQn0ro9lHl2Dn10P/9D8adUeU272/wBmtRpzQ4jiZBIT1Dbh j2H5Vu6fqlpZae7s8cSpb7vKt4hCgOMEDGOuBX+nNSlDkdkfyRGbepj3FzNPbfbIoI1Y5kZM5P44 78VasvEEH2eKdogZWHkSpGN5BHUZ9K5sJSXM7rcc6nupFpNRlure8Ufubd1AbykC8joWGMH8ayri 4knksoEO6YMCkgTKow6Me1XVw0XjISt0ZnGq09Se+1mW11C3gvJQ19HEFE0Y3OoxnG4cqMg8ZqrD NPatcX1nAqO0rTSrGgBmyec/Wu5YeHVA6ztY/9H8h5bvZBcXD2cYF3tuJYjEGAcKAGI/vDHX1rJs ddEWbW3gjWGSXzZD5YYyMfX/AAr/AFLVCHLqj+PlWd9SW/1BYXSORFCqm1Ske3GeccCuSeOMT7Pu DduCN0Ctzmpw9JQlKK7mM23UbfkWre8itZPKtoVhikbLbuS57k8e1X+AjXFvNHIGJLRRDHPcY6VW KjzUVF9/1OrCtxrX8v0J7bXNZtpA8dzLb28kQt44CqvDkHPQitg+KbeTVLHeiS3LZe6imjD21wVG Bvj+7xjjj1rllhaMrXR2qs07H//S/Ia/uftcs9zsiVp2XzgkYhEm37vyqAOK+v8A9gjxl8K7P9p/ 4aad8YJ1sPCD6skb3Etkl7ayyuyxrHKrAjYSVDAjGCa/0C4ywlSlk2OeHWqpu3y1f4H888MeyXEu HdT4ZNfe9vxsf6Gnhn4Efs66j4R0qLRPhn8ONa8N3mnxy2V0fDdlqEd4hUbZPMKE7vocg8cYr8a/ +Chf/BKSTx1rmk+Mv2a/CiaLcXk7f8JFpelXbfZgcptdLUj5cZb5lYYAAwcZH8bYPEexxVXnindS Wutr9V59j93zeh7WdJRbVmnp5d/Lufp1+wF8HvGnwM/Z38O/D3x1ayWmtabezzPHNxLiQ8bhn0A/ M+9fUHxK17SfDXgLxdq+t31np2nWvh28MtxfXCW1vkwSKqlmIHJIGPevGyulJ8SUJRV71IP7pIw4 0rwjw7iY7Wozj82pW/M/zL/2l7uG1+MPxFnjmivbRPEkrQahCNsc5CqjhT/FjAyfWvCdF8R3F5bX EbS3FrGs/m26R5j84DuSK/0CwFGlKhSjNe7yI/k/D1J4eNGKW8pP72z/0/x6l8Q3kBeRtQv/ALWS YkYzl1WM8Y+bPI9QM+9U21aS6kM2oXd5qFxKoiiuZpN0sAXhQpUDjp/jX+k8MtwtGp7SEPwP47xE lPEc6ZmR3M1ndAQ3lzApn851juHUMTjOVBxyAK1r7xHqzTQyPNJJa2comtNsrB48fwg/3cknHTNd TwVBO6gr3NZSc4PmdzI1PxZrjXEUpuNRgk1CQmJtNu2tLe3KqBlwvdsdSOfWujsPGeuWdqbe51HV I0e38tJn1id3Rick/eAwT0zmtKmTYDE0fZ1qSklqrpWuLDY6ph8RzxlZWs7Mpapr+oahaW8l7ql3 fvYlkggupmuonDdvmzheB3ri73XpFtLi5vZrcTXcotfsUEbR+UBgKyjGOfrnjpV4fCRguWK2a/IM XVjGXPHW+h//1Pw9tLeOR7V5LlgHb5FZtobHUEfnXV2ExivIZEuJY5Lct9maCQwSJuxkhhz2H5V/ p7PB0sQ/ZTWj0P5XwNaEKLqp2a29TpNa+JXj9SiSeINYAi2pFLZzyQNIoAH707sEgdwAfes2bx7q WpzC5n8Qa/NcjHmNe6lJLM23gA84x7Vx4XhvAYWb+qwSb8u3+Vzz8xqTzHEw9s9LkEPjvxPoV2X8 P6/rml+evmNNpeqS2jGQZO5gDtH4Ad6wNY8b+INVuYP+Ej13W9WmklVrh73U5ZldQT8u0nb36mu6 OS4GFb63GlH2v81lf79/xOetWqOl7OUm4rp0OY1a5tLuNFhgZIoJ/M25yY1GcDPf/wCtUSXUbWlw YCY4jHhiMhtw6H1yCMgjpiut4dVbRkaOpzRjboj/1fyW8F/Gj4i6DpNha6b8QvEVn9nHyzT63PlU JBKwoGGMkdBW34u+PvxQ1q2ls7r4meLr2yumzdabLrU5tJQCCFAJIXkDJ9uOa/00lwVw866xX1WH P5Ky6dNuh/IrzDFul7GU24vueCaerwyT3dzAjNPMZJbkzPczzM7FmLO+WPXHtgVFf3cd/K1i8TG1 kyrqR+6lyO4r2XS9nFx8jPLpKniGlt/wT0TwN8Q/HHw32DwH4r1PwtfIwdGsLiSNSo2ryQwPQDv1 r3Gz/a7/AGjLMRTQfF3WmlWbzHm+2zRzqR1+YSHPTofzr5rHcFZBmtZ4vHUFKq7Xeqbt6Ptp3se3 DNsdQfJSqPlWy0dvvKmufth/GbxZpUuja/8AFDxRrCSXwl1K2l1WaZGVG3RqA5I6jJ47D0FfL+u6 82pTRrcXE1zAtyZGEgVHuCWLZbA68n/69a5bwzluQxlHLKfIpO/fp5mFbG1cVW9rXd5bX8j/1vxa 8KeNtd8I64PEXhTWtX8L6vaxobDUNJuxbyIyPuB5BOe2Rg19Xaf/AMFAv2sNKleaD40+NQq7TH5v iS4IOBz8o4HPPpX+j2ZcEZJndVYnHUr1Nr7f8D8D+XMPnGOwtBUKU/dWtiOL/go1+2et8/2f4366 /nNuEk2r3MhIzkDcT1GetZHiD/goJ+1l44tL7RPFXxY8XaxpU9wIJ7UeJL1bJzHxjyt3llemQB26 1hh/DbhuhVjiKdFqUWmtezv+h5+NzDFY6lLD1pvklo13XX7z5EvNXzd3t5e3Bkv76b7RdM5C7nPH ygAYH4V1nw/+K3iz4da4/ij4f69rHhXxDp7w39vqmlXDWyvLC4eJi45VlZQcqQeBX1eLyyjjoPDY lKVNxs09rf0gy/G1ssoJYJ8rjtbpa59p3X/BVf8AbY1jQpPDmt/GvxRqcWoWk1rdg6zLNYRxsu1M xnB3cnocfSvzvufEmr65faxd+KNRl1i+v9Rk1CW/u0xcSOzKwIcktkFFI54Iry8n4Qyvh+FX+zoc vtGr/wDgSf8AX9Xynja2KxccViJuU4xaXkrH/9f8+/gn/wAFPP2x/wBnLw3H4R+GXxa8Saf4NtIg lvpKagYEsT90bGIbC4H3R/dArzj9qL9tP9oj9rO30XTPjJ8SNU8S6Ppci6ibCG6kEF3KA21pmyA4 AZuCvU56gY/0mwPh1w9gM9/1hwlHlrXvZWtfr0v52vZW7aH8oY/PMwzHBxwGLqOUE09W+m33fj1P lhFtI7ZJraHYinLqOGbHB/Hiuav70zKDBAqTscZ4yoGcZ96++pRtE8iTTSOUjaeKVzNnzWYk8cEV sWFpC0v2q5kby41IS2U7WLEHB9sECtDGcuiI0uZpp5RPI+yPKKQdoHYcVibfKutpkfduzIzDgjtW 8VZIybS3P//Q/nbthIy53gjGR24rOlnMdxLEYvMVxtYY5HuK/wBbpbWsfxc2krla31aOO9uLCM7I 0jUsOQ2SMmrLqyxtdxzncp+WIdHHepUNDJybM61cyyTyxMimMZcM2Av4Us8Ru5LedA223yysrYGT watKysiTS03yoWEl380UrbCNu9Rk8cVK8EE7zJGHeItlQRjAp2N009j/0f5v5xHFiF8DsB04qCJA ozbswIOEbpg1/rlyy7H8W80SVbnUhceTMD5I+YyK+d31FaE6Xclq93Dv+yRzfZyxIWTOOu3OaTTW jHzR7lGwkltVmwZnR2LfvHL8nk0/T0LzuXG1d25UZfve9S0nuF0W9a8q1S1mfydkzbRJu53A4Kn3 rOs4mEpzJxNISARtVQahw7Eua6H/0v5vLq3cTNBHKW6On91snp/OrVyxhtI7R3LgjMkZGQxPWv8A WmzTsfxXz+RUklBQwqu0FNigDgDpVSy8rTbkvGMtN/ryTgOAOBT5Ghqa6j0SVRJcoFPmSMSFG3aC TjipVtxKPMuJzHkghSpy3t7Ummtw51a46azR/n53N8s23oR0rMksJbMypC2628vKkpjy/wDPFCV3 YnnZ/9P+bnRlVG+0RAOyrlj2YcVNPLJfzTTeX5EAXYu1sYOeciv9a3Bo/itz7FeOSBZjAkyz+Svf Jx7j9alik+Y714zwM8GpsyOZ9ys0a75S0aCTaQrlMkfjSLZ+dbQhHbzFJ8+Rl2g4/uikPmkRXuqT RtZabE6qkTeYx2bmk6BsjtnityfyRKnkqRG0atudQrA4yRQaRd0f/9T+b6WPfKshdCv3R3IxToLa SG4zIx+zAEgE/LzX+tB/FkZXdhkqzF5Ejjd0YEgBSePWsmzs7gtPLk4DZPmtyO2FFA3JIqXVmsMo uLceZG83m3Ky5O446KM8cgf4VtC6guGjIjaKVEySoCxEccY9aDJttluCy81DPG44yX3ELxnAAqW8 nVSLdIUx5O0TEZLHvQVCVnZn/9X+bYwfZYMzRl1lHygDIOT2rPisJbyWRo2jijTOGYnjHPIHPav9 aD+Lx0EchfKSeY4OzhsAYrWMLBJRd7XLKPL2j5o8dvxrGUbDjo0XLazFwiC1l8qaMZ64NMgtRZSy ySBfNkbcWAwWNc7i0dF2iOQSXL3Fu8SiKaMASnDSLzzj06Vt2Hh5rgQm3i+1FkZNg+dhtHOQDnt+ lc9aP7ub8jqov95H1P/W/lg8a6XYi4lc3AtLqOTP2YjZI4HY9x24Nef2k9qEkLv1O0A8A4zX1fGf /JTY7/r7P/0pnBki/wCE2g/7kfyRy97PatcNJCF5bDbBwSO9Z+FE4dQHB++rHpXy1SKtZHqxd7o6 eGNpfsrpO1rJAxlgkh+Vo27Ee9f1Zf8ABEj/AIL3eHv2PfD99+z/APtQWGtX/wAN5pzf+HvF2jtJ qd7pE42RMJbckgxsqDBT5hsAIIwyeHj8NOso1qPxwd15q2q8rnsYLGxoUquHq/DUjb0fR/J/mf0u yf8ABxb/AMEz43hRviR4lHnJvVn8MSRYyM4KswbPtisDxB/wck/8Ey9L0HUNQ074keINQ1e1jf7P osnhma3lnYKSvzgsuCcd/rjrXfKlTco1b631PGlOpRw8oq8naySP/9f8TP8Agov+354r/bb/AGjf Hfjl/EfiVvBV14ikvPCOnX0kiWMVnvIgVU3kIfLSLAXgAY4xivhq11nU9NaDUdH1B9M1PTm+0abf QyNFJaupDAq6ncBlR06Y9qWb4qOOnBRX7uKUUvJK39XMuHcNLLZTqSf7yTcm/Ntf1p2P7U/+CSH/ AAcP/C3wj8KvCfwD/bCk1fRdb8L2K6fovxBsEk1yz1GBVBjSdM+YHUfJtTK5UEbQSq/sdqv/AAcC f8E1NLmjhHxW167MjFN8fhO4hSMrx8+8grntkV5+FhGFB0anTb06HsZnVjiMW8TRdnJa2XXr971+ ZdX/AIL9f8E0PJSaT4va4iOwTKeDLyYKSMkcDnHfbmvxD/4LMf8ABeT4JfGL4J23wa/ZC8deKNR1 fXNZhuNb1ix0+40LEEfm5WYnEihHEbgAEZwSeBjqwEsNhsVHEP4V021W34nl5nDEV8F9Vje8tG+y dr7+X5n8aetavNdXFxdXF9e3eoalcm81C6uJme6lcYPJ9O2PTrmvuD/gmD+2jafsR/tV6Z8Y/Evh mXxJ4HltE03xJb2dzt1KKPz4v3sEeMF0Ck4YhT03DJI8viCnLM8LUpN6zT+/p+J2cLzWTY6nOjpG nJfckv0P/9D+kHwf/wAHB3/BMnxN4d07WL/4y6j4d1K7gDXehah4Q1CS7sZMcoXSMoR6HdXWD/gv R/wTG+fzPj1NEqLlmbwdqTr24+WI+teLlkFhMHCm9Gklb5WOzM6zr1p1Fq7v563P5Cf+C8n7e37N f7afxs8G6p8E9TvdR0rwXoV3a6r4lj0b7BHfPNLbiEhmHmMwFtkZXGbggEkMa/EP4KfFi4+FfxK8 BfEe1hkvdV8DeNbbxTb2zhjG6WzhgrBQSM4HABPtWGZ0nicNUop7xa+9WJ4WdfBTjXxC95TlP5Xb SZ/offsr/wDBw1/wT2+KPwv8Jz+PPiRd/DHxpZ6HBZa/4f1vQL25htLi3iWOQJcxRFGUlcqe4YZC nKj+ff8A4L6f8FQfgb+2PrHw78Bfs7a5c+J9F8IWNy2qeKLjT5NMsopJriNtsIkAdmKRAnIUAMgG 47tvTkMpYTLVSr6SjFxS79F/mY8S2zDMnVoL3XU5vlu1+h3n/BDP/gs38Df2TPCesfAL9pS91Dwx o9zqDahovjG2tpNU08q+CN8UYLjBD9ARh+SNpr9vf2yv+C737BOk/s8/Ea1+HPxdXxh4p8Q+Er3T NKsdO0e6t2UzwOm4yOiqCdwGCehOOlc2QYdYGvUVZ+5Kbl20bvb9D2M+rwx1KlKkvfUeRq/VaX+e j/Dof//R/mD+I/i9fGuq6l4ot3jKa5rUurfZI8JBapNwFjXthVXI9Sa4EyLHtbBYMMYBx615GJtO rKcFpd/mRSpuEFT6pGbJHLLzJgKDkBD+Valpqd7bRP5MYEpBUSluQvIIx71KVlY6krQa8i7ZX91a TRXMdyY7syCXc0YljdR1jKn+EjIx71+7n/BH3/grZrH7DPxZax8fal4h1b4I+IPK0/WvDtkXeDRn eRF8+KHlCAoPIGcqMnhSPGzPBSxLjUpL95BqUfVdPnqvn5HtZJj1gpuFZ/uZqUZej69etn8vM/tb 0b/guL/wTS1jS7bVF/aG0+xjuI1c2994f1CK7hLfwNGIi2R9K/Pb/gpr/wAFrP2ND8FJtO+CXxRh 8Y/EX7XBLo97oNtLbXGnK0itJmVlDp8q9MBtzLgcEj2JKGJoJ1Oi9GedHEyweI5qeye6ffQ//9L9 3P2F/wDgvh+xh4/+C3g3S/jh8V0+H/xM0XRo7DWl8T207w6oYEVDcC6VAmW7KcNwflGDX49f8HBH /BSf9kH9q74deEfhj8C/Gtv438UaBr8GrXWvadpki2lnFGZFci4KYOVmO0An3xgV4mFkquCaxGko p29ehedSVbEKWH1jKUW/zfofyE3kjSvK7TCSTzDhnAQlcnHArKjligHzYdt/Len0/KuFxamTfSxr f2kjIo3cdBj+RFZryT8zq5LM26FWGBkdAfap5Peub0pWR+jX/BNH9rLw1+x7+1V4C+Knjnw7PrHh 0QrZeI5tPXe9krsA067uGKqcbSQSBjNf6Dvhr/guN/wTV8Q6BYayP2hdI0+W6RFl0m60a+XUrR2H 3WiEROAeM15dPBVf7e+uX9xwS+ald/hY9uWOhHJlhftKbe/Rxsf/0/33/ba/4Le/sN6V+z18TtG+ HnxatfF3jLXvCdzpGl6XpllMs5e5jMSjkcElhnOMKSc8V/G9+wR+27bfsnftaeGfj5r+k3L+H7jU 3TW4reRpJ0gu5CS+wchxuBAPBAIO0nI+Z4hpQxuWfVaTvUev3bL7z1OG6ksFn8cwrX9ko2+/d/cf 3e+Df+C2n/BOrxf4Kt/GCfHnR9LdrcG80LUrC5tNUtZtgZocOgU4JwGyB71/G7/wVg/4KLQfHr9r PVfip8DdcvI/DXhuOHTdE1ewnNvNfS2jDypYWVg3urAjGM9cU6dRSy10J/FypMyrVa1HOIVcOrwU 22+lun3n9Bf/AATc/wCC/wD+zFrnwN8M+Cf2pvH2p+BfiZ4Q02PTb7V9d0q71GDWkRfkkMsURwcD G04I4UDA4/SWT/gtf/wTXjAZv2jdF2mPzVJ0TUE3DsADCDn260sul7LAwo4mV5R07XS2/Cx6OYez rYyeJoqylro+r3Wvncqt/wAFuv8AgmjHLDDP+0Zplu87BYzJ4Z1V0O7plkt2AHuTx3r8HP8Agsr/ AMFr/h38VfDvhv4Ofsj/ABP1a+0K8eWfxt4k0CS40lLzP7uOEbSsjKvzNyQAcdz8vRSxNKFRyW6W nm+n4nmTjKtalNNJ7+n/AAT/1PxE+Fnxv8e/A/4j6J8W/BPi/X7bxNpOqrqpvLK8aO9l2uGcMVIO MD7ueR07V/en+y7/AMF9v2Hfij8L/Dup/E/4kyfD3xvFpMKa5per6Nd3bSzrGqyurQxvklgTjk+u DxXwEZYmGdxxC1pyVpeq1Ur/AHr5n2dTE4SeRrAzX7yErwfk9GvyfyPoOf8A4LZ/8E3Ldyj/ALQV iwGB5ieHdRaM59D5X6VNB/wWs/4JwXLSpB+0BYtJDEZmWTw7qFsNo6/M8Sr+Z5r6BVKKndW0Pnua XI1Z/efzBf8ABZP/AIK26V+1J4iTwD+zh8RNatvhfoOnmz8Q31pcz6NBqvmONypGQrP5g3Bj0+Re TtU1+SH7GX7cXxD/AGQf2gvBnj/w9PqzeG9Nvo31rTrXU2im1m3f/j4ifoPmHKhsrlBnsV8rOIwx 9NU46cusX2lvdfM6OHsdUy/GTr11eMtJLvHaz6PQ/u6+Hv8AwXT/AOCdXi/wjp2uaz8brPwvrbWU Lar4d1DRL5r+0neMM8aBYjvAOQSmQPXvXTTf8Fuf+CbkE0cEvx8iR5Pul/CupxR/99NCB+td1LGX oU3Wiua2vk+vyuY1opVaioXcbu2utunzP//V/qUvP+C3f/BNmztrqc/tB6dJNbISlovh/UPOuWwd qxnycNn1BIGa/jh/4Kd/8FNNf/bK+M/iXVPBfiDX2+Ddhqp0nwh4fmuprO2uLa1dHS5ltW+VBK4L Aff4XdgqAPmvrUI06ihbXb7rHoclSpUhe65Xr+Jzv/BMT/gpv42/Yd+NOl6l4zk1fXPhRql2bPxD Y2d47otrcN8xERJG+PCHBwG8tfmBCkf2f6N/wW3/AOCc2raZaX7/ABxNhLc2cd3JYXPhHVnuLbeo baxW3K5GcdfwHSvn8lcsuqV6U3+7m+aOmz2lr52VvwPfzCt/aVGlUf8AFguV66tL4dPLXz27nxn+ 3b/wW2/Yrm+CPiHSfhF8RLrxj49mVG0RbLQbvSprWTPBjlnjXr/FtIOOnqI/2Ef+C8f7J/iP4S6b 4Y+P3j3UvAvj7wtGLO5n1vT7vVV1SDjZMZY4yVwWx83YdgvHs1MfCFWnKGq1UtPS39djhoxUsLVo VlaSacdd+/4dO58rf8FeP+CvH7JXj3wN8PvDnwW8Tp8RfEWjeMY9YubuDTJbWxtbeNGMh8yQKWHM e0I3JLdAMn9Ev2cf+C6H/BP/AMRfC3wXB4q+Jh+H3iCz0O2sbzQdT0O8lS0eONVIEyRlccdSce+c geXiuWrnNPGrVcrjft5/n+Rng3UpYOtCel5JpXtorH//1v6rj/wWZ/4J5CQIPjlbvGcgXSaDeNZn HJxJs2n8K/Df/gt3/wAFZ/2VPjv+zk/wT+Bfia88eeK/EerQl7uy0ZrW2tIIJY5p/MuJVGFIjCAI ST5rE4AJrxZ4uj7Ozl0dvN2dvxsaYjD1J+449Y39Lpv8D+P5ngmmSeWGO1kGdsaN5gi3HkBu/Qc+ 1bsWrrG9pBBM8V5FJ59tdAsslsyYIdGHT86+Tqwckoef6nu4Ct7Ou6vZH9Uv/BH/AP4LX/Df4FeE 7z4G/tQeKNWstA03y5vDHiNra51lYQxZWQIC7gKojXaoC4Uc4XC/u+3/AAXH/wCCbyuEHxtu5F/5 6w+D9Rli4+keT+Arpy+E6eH5JS5tXbyXRedu5WaVqeIxvtKcOXRXS2v1fld626EQ/wCC5v8AwTeM rRD403/yjdv/AOEN1EKe3A2bvwxX54/8FJf+C9/7Olp8CtY8E/ss+Ldb8ZfELxiP7HfVtMs59BPh iCRSHmkdwJFJJVAFGSX7AFqpL32kZTf7uJ//1/xDb4wfEC78RSeML6+1S78Xm7GqXerPqJN1IwYM vzZwflVQMY6DpX9h3/BMz/gvD8A7D4Q6H8Kf2ldZ8ReHPFHhGzFpY+I5NPn19NUhG0RxssYZ1ZR1 UjCgcZ6L+eU4NYzm6f8ABPppVE8HyW6o/Ta6/wCC4n/BOO1JH/C6L2YKxR2h8JXwWMjqDuVefYVQ j/4Lp/8ABOBmmE/xi1W0jiUP58/gy/eJgfTYjH866cQtGc1FrmPxO/4K5f8ABdf4afFP4Wz/AAY/ ZJ8QeKru61mRm1vxZZmfw55kSsFWKLA8w5yzclQuB1bG3+RuTUJpr6TXLqaa71GeUTXU8z73eTAB BbuOO+a3irYdHO5f7QyWW7gtVWViPNnO7aoztJ9ao39+YprZYx9oE7BJwDhYRzz+H9a86ZcZO10f /9D+dKW2uJI9sTLFiTergAbR6D8q2Ee5gurK4SRmlgkWT52/1m3quecZ6Z7V+fnrTk16n9W3/BGn /gsl8B/2d/hk3wV/aEt73wY2llYtP1rTdOk1OCSHLMCwQbyVJYHA+bcDnggfu8f+C5v/AATj2h4/ jFfzRHHzx+GLhSD/AHdjEPn221hRX+0ykb1Zp4aMTyr4v/8ABe7/AIJ5aR8NfGd3oHj3xH4w1pNA u4bTw3Y+Drq3uLuUwuqRtJNthTcxUAu4HOSQAa/gO+NHxsg+M/xq8dfEGz0OTRtN8Ua1PqJ0+QiR 13OdhMi4B+XbggAfpXc1ozhi2qiOEtDNI8kskkT24PywMvbuMHrX6Rf8E8P2+Ne/YZ+Nuj/EG0t7 i/8ABV2yw+LfDcF89vBdRlljdoYxhC2CGw/ynywMjAI8TFYeNXEUubTlmmrb6X09H1XVHtUK8qdK pGOzi1+K/FdD/9H+lvw//wAF6v8AgnTqugWmqX/xQ1jTNTkgje80NfCl5eXVrKygmMOq7DjnnIHF St/wXq/4JyptMnxJ8VxxmUxeY3gm4KqR3wGJx9BXwuIV6bXketQfLVTMXxZ/wX9/4J26D4d1XVdI 8feK/EWsWlk8+neH7XwVeW9zqcgU+XGsr4jXccDLMMZ5xX8YH7YH7anjP9rb4w+KfiZ4w1nWYvC9 9rtxP4X0S61N0msICwjgZ4Qdqfu44h8uPuDjaFAWEjy4ZL1NMTK9fQ+7v+CVH/BVNv2LfG+qeG/i NHrOu/CnxSsctxdRXMl5caOYg26QxcISQQM4ByqckDA/p8T/AILtf8E4pLCO9j+LWtSTPCsjaePB t7DdxFgPlPmBV49c44rahpBr1/MnE/xF6Iqw/wDBd7/gnlJJJGfiB4sXyxnzR4QcwP7BzIBmvF/2 iv8Ag4F/Yc8K/C3xc/wx8a+JfFnj+60Ke18OaZp+hPp88VzNE6xSGV2wu1scjkEgjOK5OX/aVLyN edfVXHzP/9L8X/jJ8c/G/wAd/HerfET4ia1q2o3moXks1hp+oXr3gs45H3KoDdAB0XgAYGOBjj/B fi9fBfifTvGC6XBq39i39vfxWruYLtngmSXEZA5JCFce9fFVNUelBpM/uu/ZP/4L6fsT6v8AB/wf Y/FDWPEHw78WabpcNhfaTB4cudds0ZV2sfOiBIwQeXVcjHAOQPplv+C6n/BOVZZUHxY1t4oP9bdL 4QuRAnGe5DfktebgPhkuzf5t/qdOYu8k/Jfkl+h+Uf8AwVl/4LR/sefGP9mvU/hd8Ftd13xp4q8S 3Qgg8/wxLp0FiuOZmaUDgYHC5J3DgYyP4x7i/vSxc+VHE0YSOC3j2LEBxye5Pf3zXVPc8wjPlT2j xMWSSVcM8Z+dPfmqv2YWRRY2Z9igu0vDNxznHFJfCzOaW5//0/5vprUmabUkQE9REo+UYz0/+vWd aXLfb83NuzRDrJuwo/A1+ey+EDcbUrSB1KEBWfZHJ059KzNRknjnN426aBmDSIq75B2OAOtOOyA6 T7eNQUK4SMJEsY2ps3hRgE+/Srdpqmm6d5kNxZtcrLEYiA+1gxIww9enSpqaP5I6/wDl1FFa4s7O ZyGzBbTDIUncyisi6lks7OWxt8S2hGxUk+ZEXIJIHY8VmtGR5H//1P5qrfz5JFV76WG3RNvkjG3A 5AA7VraYIXkmtVSN3lXYpIBcc8bT2zX5vODq0XB7HRQd7wv1G3ASF1tZEWOcSbUZztx7EVOu55Gj kjWRVGcjmow6aTgeg2m+XsXhbLEAzlW3LvCBug9xREvmSvK1tHGkbbo8IMDjrjFXKKilFDhCN+Xs Lb3CyG4huZwcufLIAR4weg/+vUOoaZZ3dvaSJ8ogLRLOHJM7dTu7Z6flSlomgUVK9+x//9X+bPCr HPb8lWQxkA/N6VoRaZI1pa7XlmaNd7K/yngZ59eK/M6UOaak9kenGHNoVFna7td20xFWKse6kHFV WtXgiFxbyFpmfDKw+UgkZYH1HPFbxmvacrFKlGd+bZFi3M8cbyyXDAJ955COPw6f/rq+LxmjEpBe aTje6bWbtk100ZJXkugpQXs+XrYqTSRIypNMomnbESep57VTQS2t4reQk7D+PGGIPOPWsKk3Ui2h UKavGLP/1v5sryWSSTzfLSAE7hHGOAax/ItGludRN0ZJBF5cyRttiUqTgMOzDpX5xRhOEm5HbioK OKbjtb+v68ySzu1tVa6h8+SYpnYVMif8BHT9K37KWW5sZUuV8yGUkAFcGMdwP8966KjboyZlRV2k N/s61vFaNlAtFhx5bsYyccFRjn/9VQstskC20UKpbwqFRB0XHT37VywtKi0jWguXFST7Fa1Essk7 Q3AWXyTGiyZCZXOB7f8A16z7KC58owXalpg5d3Y5G48nHt6UoJQvzHRR5mlc/9f+bqwg8orF5jPJ 9593AbnoPwp0kUq3Vyu9Yo9m2GHZnyTzyf049q/OaMuePMevWVnYbG7rciF/3sflLl14G7HI/OrB 1C2imFqxPmr9/uVzWxgP+zRNdlw770GAqvui+pA4JrRsI4Q+++lTySzRFlH71eOGA69xQBkXlzIY UgQsY7SZmM2zaZQ2Bz/3yP1rkYpreXVplaG3jYoGFy5zLIBngD9MmlZMqOjP/9D+a7yIm5t3ZhMw DKCSuema0bSFtNvrKzdTd2kytNd3e4I9qwwQuD970GPSvz2Ubnrx2J7nV47cypa2nnh8gyy5BiII xtA6/U8VRsdQjvbiYtaSGSFPlDRFVkb0U98etZNNbjJFv54ZtzNHj+OLABjHbH/16q3TpcPNeRNK pgjHmk5CoOfwx1rZKysXBa3INLk82ZLm6kZhgxwxf8swC2QcY6/pya2Ly7hhk8oRhgRlDsw478nv 2pmp/9H+aiCWWRzKPMQO+QrLtOB9elT3eovMtxcyRusdmwiZjHsUkAYx6/Wvz8+gMcXMmqXEY3Jb SRHLN0R15xknofp6VPdTmykVJQ1xGXAlMJ3SAHg4oA7SKK3gVXtpJFjwMNJ99h/tdqXV7mxW42Sv FFut1EkqndASFHBI7/1pPRGkZW0MNokRYyGjMTplMHpntVdbRo5BLH5al8qwIzJgdgewPNYGh//S /nAsdkt2Y/N6AK0YxiMnv+NR30S2149sPKRhJmWbfuYdOg6V+bn1BFcW11ctG6Xsj20A+WIkMOM8 DPQH2qom0xzrDKAUkJkV/lfIxnGf6UAalrJJDbRxwpumuSRMzP8ALCoA27V9Tg5+o9KytXtJTLZi M2yW8JBkVlwUI6Fewx7+tBMvhLtoNtzDLcsHtAoVUJ4Y9Dn9K0mktLCae8ilmidIi9o0J3Mjeh9Q RkUGJ//T/mUTUZ4Y1e8kMkLsqksu2YljjhR/QVfkVJdTnS3Mj27W6QQKZNxyv8bDHBOTwK/PYyTP oW29y9HBeWsqq8/7pEx5JHAOcn6Vzst3pt7eyQTsyTQyARMAcs3TB7AelUWp9zZYAhQrfc4we/1q /wCbDqktpZ3hYmEYiYZCIAMbSRx+FBon1RV1WOytJoYYkkQrEQChxCxz1PvSaHqaaZFex+S7XIX7 TFdMB5O5nxjac5//AFVMldaGsZK2p//U/mnL3dzdCUwwSxSL/pCysUdyTyR/hTU0aOWFo9MWJYY5 P30e3yzHtOWK8dR2xX52qfc+vckiSa5acu28HyAImc9SV4Iz0PSoReRIsZzuBbaXUblU89apxVrG fOy9Be217cKODHHJtkdBnDDrn6VJPFFK135JAZGC4Y/NyMjHqPeqjFJ2RnJtK5hw3Gq6d50kcse6 NCRvGI8dM456VoaZFrIvLxJmtbpHt0a2fJiZWYZfcM4yMjp79a64LUzUm2rn/9X+cYpbwrEl05+1 D5XKj5T9K9G8Bi6udXs7a3lKKkvngNgoVj+cqc/3sY9a8rJY82Y0P8UfzR6+Yz5MLVf91/kfdvh2 5kvNQ0e3nWO2fU9agtokWFp4ZiWEjR47ZCsBk8cV/aH+wFpcmn/BuxvLO3RINR0y3SxtFfbLbrEG jk+XsCV/8dFftfjPP/Zsvp+X+R8f4br3sVLzPza/4K+3dodDs9Ogs5GurmQ2EojkJmgDvtklA/2Y 0Zsdxiv5aPHc1npOnXS3E5ubC2ilCX0EP7+RFG3G3vjv7iv1fwqhy8J036nw3G9S+duPmj8lvjVL De+KbrV7bVJjYxXRS1iMv2ee6A3FDIoJGQpGcE9BXyvdSldRkZwXDyGT5zxySf0/pX858Yy5uJMU /wC+/wAz9Pyqyy2kvJH/1v4h4FEwjmjj2WwPIUYZyOoxWzGpvWhUTNCyzqqI33UA9R34rmrt2Y2z tbKEW8ksdrdrLsj5laM+WOPQ4rfuLqaGKFZIvM3gRmUR7UXg8kdhx+teLXvzNI2jsZug3z6f4hjl msZ5osFoZ4HHmo+cKVQ9cdeTX21omvjTLbRzb3TakrWa/a1kwJoXKnJdenJHb16V5lb4S4r3kW9X uJtVEdyN9nbF1a4kt4zI+FPUD14/T8a1VOkTTSW1xp02qRm3DJN5exgwIIbH9DXmShrqdUVaLZ// 1/4vfCNtqXiLXY9Pge1t7ZoWMrzzeQzuBlY1Un5s4IwMn9a9Pn0/SraJbe8R3nd9pjEe5YMeh7HN fOYiKckZU/iZ1fh6/wBQ0rUbQ29hbXunvayRzy3C8usi7APqASfwFbmn38qa4tlBHN9nvH8vNu+A 4GN0bnpnPQGopq0jVq5T1xmlngn+zxTwW1+fKt2f5lYf3lB/Dd61T1S3S/ScToqwum1uM5HUAewr ohpILaHk+pG30ye6muo0UWqmG0ntz5g28cY9D/SuSihd2zJftc/JujTKuGDnIzjoR0xXr4eTTaRz Sjd2P//Q/id02+jvLufR54ikEt15NzJJFtkhxkHYe2f6Cv0L/Zu1P7VBLp0bw/Y9MV5LOSRQ0iSw Rx79wPGWBjUfSv0jwpny8bYVev5M+O41p83D1b0P0D/ZhW3T9or4W6qbKO2SbV5rea1kc28t9cts aNnXjqVzxxxj0r/Q4+DDrP8AC20ubopbzalG80iRODtdYFj+VT7jge9foX0ikli8H/h/U7vBef8A xiGOh/f/AEZ/Kv8A8FcPDtlN8T73XYSRqFrfH7OZmUTZa1ihjRjnb+8+z5Hps96/ArUbfUWi06aA zotwRJFEZjvCHI3OQScDB/Gv23wiqyq8H4aL+zovuv8Am2fzNnGH9lnOM86kn97Zx7amJLx47suq yIYbpR8u4dMjvVq11DTYrSWO2RFht1a4h+1N5czkDoM9Se1fq0lsjxJLdH//0fwLspINUhub+bVF lv7RS6aZdI0TNGSFzEQu3j0Yg4zjNQJBaXNtMhYwwXk8bTG5IuNpV84z/dPoO1f6l8j1P4qhDZl2 LUbaGVLZWikCSFA6r+5GPepRog1C+i1RJA7qvkvbSORaOuc5YAdazStoalu+lv8ASxbiJoo7YMwk XHyhcY4H+elTWQGoXbJtnt0G1Yr+VcwzZ+905AH9e9TUV4mtOVtCrqTxR7bC7V7lbO7+12820tIh 5GEyeAcjj2FaGlTyRNdSr5ttbTRHD7OZjjHP5flWMtYs61PS5//S/COC4hkjkiAm+2NIQpa3dbYK uOd+MHOemexrp5XtLGzLojSSFFLBSDn1x/Ov9PIxsj+PHUdxVvY44pWQxyxNGGLOnzRnGSAfXtXN XEkEtleveEQ2jPlnaRg4HqAOx6YpuO7LjNtaEN3CLu1FrDJtiiT/AEdUOHAx2PUZq5atplp9jt5N PhlnjQEvIu9gw6DPX15qHFxehUZ3hY3LiV5LSFrm0NjcrOMfPuE8Xf6fWuQv1mh1L7Rp7PcZYr8/ 3ocjGB6fhWqViG7aH//T/EjR5WsJJrZpmgkvo8TEJvU9/wAOe9a9zZ2ksomnYBUj8sy4w6qOTiv9 PJQ5nc/kijJRRkvcw6XYKV+zahZMGVoWic3G8sCjk+n/AOuoNG1Kxu5LOCSV7RDKftKqwVUB6/Me o/8ArVcU1E2TTN7U7O4tcfYJvMAk3JLIgZkGcgkelUU1mRSLJ3QSJIJZlZBsf0+mapJvQmeiL8ko 1KQ28af2dbsvzBW3/N359Pasu0s5NKspfPvC0olZ412/8fOSeOOmB6+lTSpuFkYVHzbn/9T8PJBc 3yMYliimZvk83/Vj61l3GnpeeQlzNJBdJIvmNZk4kx/CRj7vWv8AUd9z+PmtLGpE62F/JEkiobqA JIA+Cw6/5H1rTkvFS2kheWKL7Opkbewj49R6/hU8l0jCa3RZa8hh0uKYTLO6lnJxnyFGDnJ9efyr m9Q0iS6QTxmOKC4IuEMWCHy2SPx5/OrtpYygveN671ufS00PTZohm7szdQ/JkxIjGPk443bcim+V NqE6SW5hIk+RiWAI/wAP/rVlGk1PmNG0j//V/EqG8fTPM+zpG00bGPzAoYDnkCtKXc1tFcmIbZvv snKg9etf6jKnJM/jSck1YiS5Z5IkmRLe0WMu13MwEbsuflHvgj8x61Snms3eK7XbNcxSF7SRgCqn p071XL3Q4PQgh1LVWmaXVlgcRuWJtkykR5A2jpV22LXcElwSzFMtE5j27uehrKpRvK6Noz5VYrTW K3U0F5L9ot44HV5dj+WMA89Rj5hx9Ku30VnfZjMeLNX3woWyYyPeiELbmUZX1P/W/EyW7FjbyFIV NrGMDYo3L6mqFvrSzRR3GnQTANCYpXuD+5jyxH3R26dD+Pev9RnBPofx8tVZm0lrNAXmhmW5gl2u kQH3AQNw/nWdcX6R3Sb42kCnAVU+761REtJF66u7G40+MWcLyXSykzBz5ZUdAB6jvWPcWemaZtn1 N4XZ8ckYjRmHA9z2/Crg2mZmja6fpMkMBitQLeVD9nt0/wBH+Yjg7fr2xSjRLqV5Yrw3VssJDhdm 1AO3PocUnzPRo3fw2R//1/xInmL3U+m2kk0DQwq63bKcHjJ6VK5FxHYwCRbi0huFnV1yQ7KeufUE D8q/1Ks10P43OikvbSBtwk23KJ5ioRngVzypba8Hi1CW3hm8/wAyOeMCN2GTjJ5PtispRurGinZ6 l3e+mxywWsaF2jMZl2B8A8fKait7a1htYXlbbsmDvECUZup5/wAKUYOMrlOrdWNCQm/eURBIZ5SI YnjOAF6A57H/ADmp7r7Vbq82oTtcNGR5zyPl8KAMbvw6mo5X2M5TumvI/9D8UGmSUTXCJcQ2O/yr d2UtI7en/wBenWjX9vqVmrO1xaMMi0Ztsx6E4Yc/h71/qD7G19D+OsLK1M1kvo5Yp4ru3TzZFcwx tkOozgEiuFE0ksy29vhAr4DJ0jx6flTUHy6Fc/vWZ2E7wRQWUUEbStLL5d60jhdqnOWH+FZFxpNt ZXEpgcqXcSKN/m4GM9aUqXMrM15/dsaLzTSqJYJ43s/JAG4Ydm74qtFdWRiSCSXcZ5TGQFLKn1/W qjTSVmOM2f/R/E6S0gtrefT7a8F9pkzh4oijRxK+OoVu4OecVJZW32F4ruaJJo9jRbHbDDIxn1HW v9SIxtA/jyq/ffoaMOmWN3cobHEchQb7fgqGPrVXWLSSxae1ihU3sY8wwBtkTEnO0N0rSnHluiYS Shchs73UrGeBgkcIMGJI8eYFJGM7jwanhge6sHMjCKdpCJdncA8H8a6klypMzvrYd+9Fs4UBnjUr iX92TjuDXNXKJLBY30kuGlf5LfkbivPIx04ppJbBdH//0vxdjvr2cW6raxrFMCqoX+ZcdgPSq94I ILK4uXuEW4LiNbVRhh6n6Cv9VZwbdz+OIy7E1pfrb6YYljtZhc7ZJJpIFkuICP7jEZX8Kyp76SOQ eWJckfu1UbfO9hUSpji7XH2LpdfMYWgdPmkXILZz/npWzM1m8KbbqSKR0wV8sleOxHX0rmlQfNc0 U0jOtbjTIIg9x57zB9ozFiPORj3B+oregui8izWyhHT5f3gH8ulUoNRt1KP/0/xnimMpuYSDHNG4 KPIMrIOpxWC91JcG5R7dlgSTyiHXiQ9mH+e1f6iTouSaSP5AT5TbinNrZJvCiMkI+44BB7/pWbvi tDILcFo1XzhtBaPDe9KFBxexMpe6MbWMubSxSOfzosSMxKIjHGfxB4rZuZpbO0sYYoYzdW8Q86RG JeQk88+w4FbOg3LnIUtrnOXsjSyzzgk3DLnDLluB0qxpupaiINkttJlU3CTHJUc5I/Ct+R6XRDd2 f//U/F1dY1BoZ14azlVfldcMMehIqDTri2mjd4Vw+8kAjaSQf/rV/qmk1H5n8bmLqmualclrOZI0 +znMTKirIc9s9+1UB5tsyLdxyPJK6qMfPtJ7n6f0pQi1K7LUVK5uI9sodZkKsR8rtklj6AVLpV7J YyxWt0EmeVNyyKAEQnoKK8eZJG9O0ZHRalHGIIDIV8xsyRxo4YD3PpXMixjXVbe5S4jeZYSzKG+6 MEFcetYyjsi272t3P//V/HCORJXVXKxKCNxkzsPNS3m6G5hbTBbS3EUyzRSuxjVHB+9nGeK/03xu DjiVOjVjeEtGns09H95/K9DETw9VYiDtKNmn2tax/Sh/wSU/4K9ab8D7C5+DX7R/jBLzw2kiNZ3t 1NJLd+F8ou2UzOMPC4IGCdwKHJA24/o+0/8A4KcfsMalaJewftEeAFR4hL5b6vEZlB/vBWIHXua/ jnjDgHMshziq6dNvDyk3CSTatrZN/wA1tGuu60P3DL+McDmuGpSckqqS5ltZ9Wl27fiXj/wUo/Yi 8i4nT9oXwBMtuu4pDq8cksv+4oPNfzNf8Fiv+Cnh+MPivwp8NP2ffiDGng+Kzmn1mfS5/tMVy0My FGOBsy/z5yc4RR7j2/C7gDF4zOamYZnQkqUU+RtWvPTv5X9Lo+T8R+JKWJwcMvwM03Jpys76JPt5 n88nifxN/askEWs3i6lqcm4ie5C75CTlvlHyjJ5wMVjLcLCwJgjACbSUHT8K/q+GB1UaXwpWPyid ajKrBQ+Ff0z/1vxV1pUldJIpNjdcAcNWbFdzxgRMu0qcoduOvoa/1Ew+FlKPs3o13P5CrOk6j5Sc eZ5rm6RQGAZZV++QO386sOysm5bgLEeAGGCRXVLBVErvZO4nycjS7GPDHIL1YBM00MhLooOWOB2/ +tUkd8kckkl2CImYwgPlu+0YH1ruVCCv57HBSouNNKe5pHyYIgoj8+NyGeMHYyeoBxWbew2t4VDo ISMeSdgDKR0J9TXPDBzhKT7m9RRnY//X/CQSyJ5VhOyG4tWMq3SjazbuACOwwOPxrUi1eOBkkEim 4tmBYOu5Hwe9f6o/VZ2aZ/HdOfJScL6mlda1LqflSYhjhQfNsG0HOMn/AAFY0jQwEyuwCM3Eh4BJ raEXBq6uRUqJWciJnu3mCwJmLIDzKwYKD3xVDUrR7soZbrLQvgbBsQjtuHcj+tMio9LMhuEV7XZH IFUfIzKc5288/l+tS6VJbCB443Jwv75ZePbIH5U1Czi0OM7rlP/Q/B+e3jkiWVWfdbyExDZ8qrjn 86bb3DXUXnN83zeWBnPTvX+ssVeJ/GkpNOyLR1ZRaLbNHIsysQ8flEceuen4VRuCsMgkgaTkblJX bz7iuSdO7Lwr5J87CfxFcJB5LRrJNwBNjDKoHTisq3ZzcQsjyLG7FyAeh711QgrHTdm1qBtoFMts 1wzrgOPIJJzjPTPSuftr+6eSYCCNgkv7ssMEAgZyOxzmsq1JOOhKm1UR/9H8GLmaGJk+/FmINIJG HBxzj29Paslb+5uGjVABBM5iZ/MDMoGD069xz/8AXr/V6lTVkj+PHMttdLCUhgjVZoT5fPJINdFY 6zb6db3Us8fmSC3zbQ+WZBNIXQFVPY4LHn0rfkSVjN1bPU5e98i6uZru4U26t8+x35j9QTUuna3D As1vDbCS2YbHb73mZOT1rDktUKVT91YqzX9pFLJHbQshZt23qVrE+3mSVIJXEjq2SoGAgPPFaypp q3p+ZEZrof/S/nzmuLqWOK3jjjawLlpA3EmTgc8c9O/Tn3qhctcQTExB2t1h3PHCu9mA9BX+tKi7 aH8aOaLltdTXEQCkpEU+WN1KyEeuKhEsNsskhiaQoPkwN2D06Vcadtw5ly2Mi7mA2TGP94TuY4wF 9B/n0psKyXkwuUlMUcSbXgC43k9Dmq5ImLdkT6PbKs900sLvHECZPOVtjE5xg+3XiqX2SJpSZJFx uJyx6Y7VRg5Xep//0/5xrjc1wkZJUNhYyg2KmAMdPpVWa4niaQycuDtLkcj8K/1wP4mukrkKWxlg uNQlkVp1ISFWXA245LGtO2k82NN0caBFwPLywcY6tnvQQ59hYLeymkvZIYIkcLiZJCI0n4H3R36/ pUKMoMcNtEsUMCbTGOBgcYxW0YpLUSm76krXUaMsEKqhkz8pOOasQ38Nvp7xLhrl5D86ncw5AwfS mklsan//1P5vbmSOUrHIuWQbiejCrFk8TL5e3EaHcWx+v6fpX+vB/EvNFaDWaMTrCk++Rm3bGGGA z0p11KsUjlbtobVlCyI2Dhh1IFA7ogSXc0rwkYQYVT0fHepzcKUXJAmAwSDgr+FZuD3QyBrd2tjJ c7ZrOKXftmO8lycjaD7/AJYqrLdiWVCFECoMKFOM/Ws7EyaSaP/V/m4iuG8x5ChTy/8AloeAaS+u l/dupBd+uBnNf63OPvXP4mWxctoftsZCkRyKn8QILH0HvUP9ljToo4b+WSaWeV5ELrt2DOdo9hmq GOvIGTT2NpIn2lPup1Vh3/HHamwb8rvLlliAHmD6ckUmrqwbDzctCCJFAUjBbHFVTPv3B2JjIx9R 6UJKOiM+c//W/mv/AOPeMR2h2KRkBVwFHpip4ys9gonnMUzSlYEVhiYgc5Ff64H8SSnZ2RRhtUgD SCZomeTMjlQwb1HPTPSkSczE+WHYJJsDoCVOKLdCHJstz3ZiWNW+cuwDLjp7mpEu5JVdokx5GTtA +R/84rNw7FRl0ZWeIXLrOUVJODtApZluZ7iMI4REXBTGSTR7PzNVJpWR/9f+ahJnhnZJkZSfuFhj fg4yKtXVyzQiHzmVuMuO3tX+tqgran8T7Gxp13FLEPJulMqDy5ccFarXHlx3ZRHJQ/MSwxvP0zU8 jvYDKmEspeKPKoz5bA54oSArEJMEbDt+YYJo5GBatrpSyIMqGbY3bJqnepNFNIiSksCGVW+YIKJQ tsB//9D+bNNWkhsPsspRkY4VyoLL06f571DZi9SSaeERlYk3yZwRtOAMg9+a/wBaLH8Wwd0bFhl5 4gYQxZS0kvAWL0H4/wBKn1FbSziknu7jZGOVVRyT26dB6k+tJq6sUTabNDG6ybA5fpjJC1R1m9Zp I448IofcDjDmsuWXY6BsLowUROTcKN0mT2PArZt9dvNCVrq3byztP3B8xOPSsakE6c79jWjdVIvz P//R/lY+IOt2Hi26bUvsbWl9KgW+bdsmmZTzIcdz6V43fq9oR5TuYmyArdV/z/SvqeNIqnxRjaa6 VJ/+lM8/KJyqZbRqPdxV/uRjQB1ldpHV42+ZF24MfGDVpHhXczDCk8soy7EetfLylp6Ho3aNaC4i Z442lI3Dauegq5NdS2hBt3MYjHyyAA9etc1mm0zVy926LcWqWEsUSSwwxyxqCkogViTnoTj6nvVy WWzfZJDDZqyfddbZFPv2rKd72IU2j//S/kVudUa7kiIg8lbddm9M4k9z/wDWqwNXkgYsWDKF2hD0 b/P9K8+SdkzSjL32T2eq3U8c8quflwbVmjz9mlU8OvoR2I9K27/XtWlYTXV5JctcRLbzySEN5wXs V6c9z1qXG+w3P3jG+2PO9y0/kMH/AOWPlBUiXGPlHY+/WrFjffZSjJceTb7jut4IwiPgYBOOSfes tb2B1L9DT+03MyLLJExDHO5l5IPestNSuoorm8th+6BMEe8bFZlOCQausrpInDy5Jykf/9P+S2PX ma4TFvBK5GHbbkxk9Tmtm71C1KpLshR3URznBVUXvtweCSOo5rxzXnRVl1GGcOssszDYq20Qw0Sl Pu5HbHNFreKHYb2E+Pn6/NUTV4m9Kpy3S7foxkF3bWs8ipFtjlbcyElVLc5b8f6Cr0t1OAIoWkjV BvUQkhAfTjr+NUr3MWla4RahK4SOWRpFjyxUoCoJ45/X86bLtmSTzJ5ph1WN3PlDHbb0I+tUm0rI o//U/k7nWJVXcSi7duIuMjuAKqXNyjqrwKUiQCMjnqK8h7msWrtFeO9V5DEc4jXOT1NS/afKIdw/ lt/dGWx9KRT2aFtNSthcNG3nK7qWt3Me5OMZDenBrqLDV5I5GaA4CjDYGMntUtWmghrC3YtJqg88 3CK9vLGT/qXK28me7Rj5SfqKfaXduy3Eiy3PnS3AlJkkLgEE8gk5H096q3QwP//V/lnnvLx5Wd1i lhkIErSLlwAPl2Htz159aqyTN5dw8IETT4M5j+QzbPuA/TPH1rxHHSyIcFqzBvHkmi8+OVt2/ZIF XmPt0pF8vy8wy+cU4O4YYn3HasHD3rljrZJjcrvi4boF6DNdr/Yj2rwSTgGK9jDxq+AY+cZo5Ve5 rT2Nm4sY7FWIvbfdEi7VSUPu3dx64qlbQRLNMLm8iSOYpsj2JBJEy87lYDJz3/rWcIWlI0lZpJ9D /9b+Zy/1K3hiW9uI4pvs6bVn8oNIOgzwOvTmo5NfgheGOaCWUmLz3IA2qD908+tfNThe3qehTUVe 3YzLzV1vYSIYfKD5WWNAFV/cgDr79auW9ydsUk8xKxxCMInCKAMDj6cUpJocdzVfW7CxEMttNl7k GK8zH+8KA9M9fSpW1y2mKS7IpBD9wzIHBA6ZU8H8akqduhYE+l6oI5Liyt441zhtmznPOQPpVOGe N7mZbaSOK3jHlJFDCI1HcknGTWD3sQ7H/9f+bIagUKpG5fb17kYrK1K++0LIiRESSRmFZEOyQZ9x 7nvXxi+NnoVXoixpx+z6dBZSBmmQkz3CkiSXJyNzdTjPrTJJn/tGSWB3lLxrE0UkrPCmMY+U9D61 TaRkkm9y+t/K0rT3EUSTMwM8iAAybRgZwPQVXiuxfXi3yTeVZSjZCJCfNLx/e+XAI6DrUydrMqCv dI6GW8Q4uGEHnbNiExLuPueOT061VGr3ssq292I5LSL5okkgjCknhhgD2FDbsOFk7xP/0P5xYru1 jLz+WsuWChJACEA6BR2H0ptzq8vlNbxFYMNlUhAVVHsK+Htbc9dO6uiNNevQGVGaWRU2opO0dMVt 22oQxxBvLKO6AXIeQvGxB44PHp1zWUY3WgTkkxqavLb+ckBRYCfMj2DLI3fB96w4tUnlmliltlDc yGd8SPKAR/EeRz2zRyMnnRoxXkKiNZkQfKwjIILqD1x6ZxT7bV50ZzKQRjywGQElfQ0nF7B7TSyP /9H+dm98SpBaxaXbwP5ABk/dffhdxtJDdfwzgVR+2S5M8jBibVbdm2hTtX6euefXAr4OEXzK53yn 72pGblGj3f3Rx3P+eKjGqLF5bsSPQnjA+tHLeTRrhZaux00OqQS267IoZpQNyidQVyPrWol1EU+3 W0qWl+mEBWJdhB+9kd/yq6F4waYV5J1U4kqeMZorh/Pu0QLEVLSQJsJHYccdP1rCku7G48+UxxRm SUSJcLEFlY53Y47H+lVBJTuEqjcVE//S/nu0yYJBctvl3TMdocksfp6VXsNSlsb/ACg2XMrsoKp8 x4wd34cV8FLTEJo9mM/3Diy6NRSC5aWayspipO5JLdQH9mAHr3qOTxDeTSrHuRbZ4tjWpjBjj9Al bzakrGUZuJRvZJ7qWO4d2dol8tEb7qj2FNhjgCGFpmW5lcuIcbo2AH6Ec1rJpUUjnUmqtytcwq6h HwShJBXqPrUSGOFEleIsF+UYBauGULbmyk0rI//T/nXku0mj+UMqou7aQVzj1/z3qSDz51juFVww 52Hk/lX5+ei3dl6a9kR1mKsssJ+VdvJwQf6U9tRiu2uLpbGDz5wWeQ24QIT128cH36+9RCKTbKlK 6UexImp3PkyxusI+1w+XdxwKI4ZwMgblHB69T61gWN1ax3csMqKk3VkxtIA4HHpWyfutGd7TN66n jiEbLu27cqiDlvwqdgbqe14ZLaOMSBGUq4fHOfb2Nc1WHM1LsdEKtrx7n//U/AJt15KEvGia3jKq m+MKo28LuYc4FVNS1VkeWS4trKGeI4EunvHqCcfKGD7cZI7Y718JJ+6ehCVpadClba9ekkG8lgjV PvIPs7uPfGM/T3q3EIr0Owd3LMGYMSd/fNVTdoWRcpXlcsz30w4EjGPbsZATjHcGm2F3aNcC5aKH IIIJQbTt6UUp2i/VlV5JyWvRG9beIFN1Om2LYz+ZJwCC2MA46fjVHUtQLyeYREJt2yOVIlQovTaC KzbSncjmfLyn/9X+eqVWV/MaUk44Qn3qGa4iZbeaXKm3mDrtJwT2yK+E50egdHceIJdKhgckfaXZ Xt2QAmLIyGz2OKowaut1JJJdATSS5WZ5EUmXJydx7/jWFBqNM1xDU5u4tyLOZ0QIhWEeavO0x7QT ge3t0rnpZhLt+UhckgAcn61bbb1OIlg+zx288rhlZQWUD+IjoKptqC6jFEVhliuEGXRx94elITV1 Y//W/nTk1UGEWxtAhiJV2CbQ2fU96kmuLVrSGMoFmJwqgZU+5r8/aurDas7GBHpn2b7QUUyQ3Eom ZPvKjDgkenrWlcRwwtblWa4iaLdINm1lb+7j+tA3GyTKkt3vG2KIQlTgqRtZxV5LVbsRSR8SIO/r UVFdnR9iKLgtru4TypAN68K7HatZpV7XzFCtI+MOkq/ID2rImx//1/5s77TJ5jbts+WdQ0qwPt8r r17jp+op22G1njRpzbswHkgkb5mHLBfwye/SvzlStBxHCMo1VNdCa5ntrpi2yQzgYZ5B8v1zUtiJ 7SCW3icyTXEvmeZP8xhU9FTAHH1/OuaipRTbPUU48zvoS6n/AGjBFLd2Vn9t8tArBZNoU+p9qtaX LcGCM3qgFhumIO0D2HFaatp3M4SnFtswrxWW/W4Xe8U+Y2RfuDHQ5qW/shLHYQRXk9tb20/nvHGc BiRjJHrVT96DsCq6tM//0P5wSbWyVzIWm28gqhZ2H0qk2rmW7L2hnexSPA3IEBY9R68Yr83pWpxS Z3KckrQ6GoIEntVuYVVFZiXQDBcjrkVQF7C4WGAMSpO4bcp+FVpzcxUpO2m4x5EltpDc220B/wB2 jgEEqwIbHPcAiklW8CIxMjhlCLtBbaP6YzV05qL1I/ePRFtfscaRyzW6yXAOPNblkx6elJFNbT3N y9uVGxs7C2Sg7fyqaXu3b2NOWXPFxex//9H+bsyfaNylVxu4PbinT2tjJbyebFEsTDE8ewbJfcj1 46+1fnqbb1PTxT53zFeJZo2ju7eMW9qEECQxD9yFAHT3PfnvUE9zcJHKtiqlg24K/wAq9Rn9K0aU qbi9jnw94zj3RetrwNuWUY58orjAU/5NOubWO2JDSoS/OxWD5z9DWNGHsr2Olx/eSlYguIYobdHR tr53Hbxj2rNEV1ff6Tb3ASJT8vync7A4YUp009WTzNR5Uf/S/m2khYQq6u8V2rBonH3Rj1pTqUFr bvPexvdXqxmSUr8pfA7e5OetfndKChDlR6rleHvES3nmrFdW9u8cLsC3mj548+tQ6jYfakaazYLc Bg6sxx5uCOD7VoEFobWibNLm3XQj2JEfLiCh0JK/xf8A1qzpdS0631BYnuFY3GXXcce+PwHpQZyV nYi1Ga9aFkso451mOEUtsPJxkduOtavh7T/DyJd298YEums3H2q4GJHfAyMjpk/hxQCaV7n/0/5t bTSnj1ZYXv0jspXSJei+UCfmbP0rUlDWc72swE8sMhRJV4Dgdz9f61+fnrKSsZi3Nvp9yjXOx0uJ ggjHPzMfu0lzNdQ3UzQeWttP/qEZOLYkc8jk571Mo3Q1JPYzhDFFdPcuskn7v9+ik7ZAMn+p/OpY 9dVt0VvBGmmuMxM3EzNnBVwR7D6HtVGtPsWjZJLHFcSTeQFcOdp2lab56WTyi9KXijcUmjBJVOow O5A4oND/1P5vpzBJaxz2vKyLvQkbWx7jrSRIbqL7OYvMEi5I285+lfn59Cld2MxLKNZJImhIw3KS KVBHpV4W8Uz7xCkJThUUkjI780FyjFDJ7hrcGEkyB/vKP4azZ9WEUSm3ijnGcRN5X2iMuDgA4469 aznvYpJWRmPqU17evIXV5LZ1a5iEfkRQFhkALgAdO3pXTyyCVIyo/eMuG2VmUf/V/m1hV9PEsqxN JEkRkklLfMhyAM+vX+VRC3E0Md9KYke9lK8Sgs5A4z+GOvpX5ufUFS0WW31Rrq5mmGn+T5SwRjaj NnOST1PSlmsVku7u9ZpoPOCm2tW5VVXgH/gVAGjZiK3ibzLhmuJVzFGwGFA4OP09ao3O+eGeKaMy oeGBXg96CJ2sQQzRNYlJI7i2kS4WCBJo9qt23dfXGKnsrO4N3cWE7lZA+8tK+5Pm5wD07dO2avkZ kf/W/mXk0WR9RuJhKJhbxA2sDNhA4zubPrg/hiq9mxR76We5ksZ0gE1tHs81lIOGPHpwfwr87gmm fQG0ZH3/AL5JEaVFlzICrSZA+bn1qHUrfSoYIZrdnjnnkEbJs8zMhx0I9a0Ansre6toGkvolYONg l2kJ6jB9cVNBcWBhknsyzskhimVk2FWHHBPUe9BrT2M02txdXUU87MYY92yIngk45Y+3p70/VrS7 W5ijEayqJFH+ikMGU4/x5xUuVmkWf//X/mpeXyZ7dpi8KhT5a4wkuOuf8PrVp59jB4p9kb/MyA4j PUc/rX5+fUGfdxJ9jlRmS2HJZoyFCA9wemec1miNba1jhsXyzENlk8wnJGS3uf60AbihrKzL2sMT yzcyKGAJPAJ+vH6UtqXYFWjCyOcnJ5qoaSJl8LIr+V7SFvMZInkGy3d8De3ouevTpVrTNRggjSS9 3JcSAJhVLqpPGMiumD1sZxXvI//Q/my1c2i3toJLt0klYPFEpw0x67fp0zXtHww8g3S3DRGOdJts hJBO35QB+tedw8ubM8PH++vzO/Ony4Kq/wC6/wAj7m+GVjc3OrWFpH5jyXGowvJPGSzWcfmKPOj9 0zk46jNf26fsbaFdWHwl0Iu42XGnwG3iUeXNGHiVmJx77v1r9f8AGeWuXx/u/wCR8z4bpexxMl3P xI/4LCXl5pHim21CC9mfTYdVhtLazmmEPnzSxukjknso3r6fvBX86vxCax1Hw1rV2zw2j2Um6FJU DW13lWLRLxyxIGV9Ac1+2+GFK3B1CXk/1PzPjSo/9YGl3R+Nvjo6PPqOp6ddQq2ox3jagnmIUjQN lBsyMcqq8Dptr5vup4ZL/bJF9yQx7QOSAcD/AD71/MHFbvxBiX/fl+Z+uZZdZbT/AMK/I//R/iX0 +Npbq2sIikc0zDyUY4Ree/tU1w9vPe2ttZ3YiuWnMauI8osi/eyPQY61yVwO80hBZq/nnzguWnDL kYOOT7A+tdNHLHf6dPKrB4ySGwNzIvY4rx63x6G0VZG74G8NvrmuWZR44NmY0MkmIzgZ2ntzj88V 9U+GvAsqzXMl3cojtH8gtoheNhN3GA2O/rXmVvhNYLU1vtv9myxwWk8jl0IZ2gMQyDgjBq9axQTy GSUGEyEYkztXd9K4GryZ204txP/S/jIu9ESxuV1Cw1CSaDEZ2krFLZsQRlQOSCQTnnGcelas2r3E UEkQHmzmPZA0g5Vz0bNeFiI3lcwpyW52HgrVvtxi0nX57hLrT4EnhlS2Zbe9BcKwEg+VWUsTzxx0 rsbyB9GN0sdx5/ls0olJz5WecjHU471hBNPU2TT2MfTmRHnNioZtRRZZWlclo2ODnBPHTFaOuyXF rbTRRNbSymHYXL4RsjBx/wDWreKalZlJ2TR5BqWj6jq7GSKRwYIt7wBd0W0dW9e9cLqKTaZ/x6qi yRTiRpwCd5GMBh04xxXp4fdkOKb1P//T/h5tLyWXxRvupZG0+8IurxYwFkhfPJQehPH51+gf7OMF xJPLHYwQLFc/aZp5ZpdjrInkOpx0yVjBH4cc5r7/AMMHy8bYN+f6M+b4vhzcPV79j9IfgPeaefjN 8Prq6utt/p+pG72y4jTblFL7u207T+df6Ff7NTTX3wr8LTX72uqLc6RBcRzo4dd0kQLrge/r3Br9 S+kVTX+y1OtrfizHwUf/ABj2Op/3v0P5uP8AgtBpOj6Lq32oXl1HqA1aG4b7JChtbjaoRVk/iAUA rgdS2a/nKutQez1Gzgt1e8cP5DQyYiCIOm329a/W/ByblwhR/roj8A4koxpZ1ikv5mcbfLZHVbhp l2zN8xjDZX0+nbtUF7aQXaIFtWjmU7ECLlT6EntX7HbU+VqKPPY//9T8Cba0ttMe+gvF8yaWJWiZ SCgU8uM+vT9avRrpn9mGeC0eSCO58uGHad7kH730B7+3Ff6oH8XpWVjl70LI9tawBrdVuvOkMY+Z s5LAnsOTXVW8k9q9qIn32n2ORZkRT9peXH7tyemB3A7Gk4p7itqUNWluBb6c8t0J7hRtngVcIOpO PrWnZa1BLAkQUx3IbaIkXKkDoQf6UuSIyhP59/dK6EsFbawQFiAOpIH+eKtjWbiWWOzNsqW8aBDO ThiRnnFZSppdDdO6P//V/Ci1jdJp4YL7z4ZFGd6mNT0bGOxB4P0qObWoBcNol7BLBqEx8q3MKNME CncC5C4AI75xz1r/AFG5In8a8yvYjuZ2tt1vwxcYaNsYI6Zqo9xcxSWsUluqR3XybZjtQ5OCcnjF NQjexUZdi8vnw3dzKotXjFsq2a5LMWJ5ZiOMf4VLBZSmT7VcOs0h+cBRtUHsKqUEilJrQ145reaI rfCdbrBKIeYzg9Q3pjHFQwLbANM0TRBGyVU8sR/jTdOyuNyfMf/W/DGzvZdW1W4aOLa1sqgoqbQB 0Xj8P85rorySCX/R2kdJvJ/eALhV981/qUqd0fyBGVtUUbpxDbLbvbLPHJEI1nRv3gIxzj6D9azJ 9Bhu47ZTtt/Mfy/MwEU5HBb2460eyNk77F7TG1mKFoZmF0IgVluQxKKBwo96pW+n2pl1CTU3uJBM pb5Dg9OFHIIHFNU7BKSW5Y0K/l1O8u7Fbc21nYwKYHLhHfGQfr/Oty+mD2lzbxoiTgf6PKx5z7jp /wDqqvZoxe5//9f8TEVWsYo5kYXkDZmmhlyjZ6YA/lWNfR30Hk3enRoHRjHJMJf3u1hhgV+h/Wv9 T+VLofx7J2RDo4ttSe5aW3ea8tZDG123CL6xqPUfpmpr/TEvXieXc5kfakROxMrwd3b069Krldtj nl8LNiGS1ndbBIAhkUwrAFJj4B4P4CrX9jXAZtKW5t7GWzt2uitySquoHyog9TkYA9KViIbnOTQX cZ0exnWXzIY5Gu9QuZi7SxNIWjVEI+XksODjA6VspbWWmu19HcuJJl2mBM7DjGOPXrzTSb2Cb1sf /9D8RpbuN3W3itNkk376TKnc/v8AjU8Uxt0lsLk3C2rxm4WMMSFbGCEI6Gv9U1Bn8XmDqMEutWjy RpcJp1lOCy8xuzdASO/SskTQ77OEG7sFacxrLdJmPjrkgdPcUezZcHZ6nVxhkiLLdNlkKyEfMr5H X/PrVXS73UILd7RpmuS7Ha0gCRxcnoopuHYTk9jdiE5sLs39t5/mW/lRRQSlFDHGZDxkgDPy+/Wq Ec0V5axJaJMI432OzKY1OO2Dz6/lWdraCjKzP//R/D06ja22ofY7iNZoDGVntnXcSccf4/41ZF5a zgxW9qttGg8tYlXYjfSv9ULdz+N010LIaa3hngUqksOC0W8eYM9MCueE2oXn2jESwywy+TFCw3+b wDv46Ck0nuJtJ6m3otpdNfSx3flxISIQw+ZY+eWOOv4elT63pwu54rQuHihn3Btn+t25wcH86Ekt hlC71I3FtIkEZ3wqIYbnb5bx7OCQPwrR0q2ubmwvdUm1JnKIu61uZsMwX5coOpY55+lMq75bH//S /FCWK6jheeJkildcEE4+UjOM1V0+UXRAll2urbQqEckda/1QP42d7aD9Ss7mWe2v7J3CRZjuo3GG 29Pl/wA96x7lbKIxTWcUry7vvuxC7h1wKLGcW9TZ0+W8uTtePEhXqBlagWO6vPtenuRHPC2ZyTte MZwAfTn+VFiCWa1vNOghgjkd2f5HI+ZsHvmrlvbT29okEryXETITN553lwc5JpKKvoPVxZ//0/xS a6up449OgNzdRRfPa2doBuL9s/Tmr8BlBDXUMiXNlxEzRlHQkdBX+qLSu0fxnRbVOyKU+mTz3Vhd rMRI0jOqltr56EH2/wAKxROlve3NqpRfLuFR5AMRoWP+JFQoq2xXN73KasaLNe+YySyJaRE7YXIB Y9yOh6d6oWt5by6td4ibaANiSdJTjk/hjFPlXYu7tY1IbU3lwkFssSWJUmZmbYIeTn8OnFSQ6b9l uGtgqMwj83KfPGR2GfXpTIjJPY//1PxPtbuO6kkkmhLG03QpG6GNYmwRu9TjOfwqZEku8zAmVYUz cRJnoo6genXmv9UYxvofxjiJNS+RW0u+M13MFJtxCCQxOFYL6n37CtEWq6liV3YbX3bi2Dn61UEO MrUylqSyQbnkfMMQ+Ud2xUFvrT3EC29oqAE/M5HzjtWpBNfai0FtF5UbXskGfNVV2u//AOqktbzS LrT4769iujIsjI1gISzW5A4bPTBNXBa3Hd7H/9X8Rbec3F/9rhuJYIrddkVsw2FicHd+XpxzU2rQ x3ECudqszY4+9n1Ff6wH8YJ2d0aS2UBt7VYFJZ4VjkDtnLAdvrxXPa8tyrWSQxKzRy/eHysh6DH6 1m4diudlmzkbSne9uwXAi3KsJ8w7jxyBWrb3sVyMpD8p+fze+T2xUNNblKa6lC4jibzBMNyMwKjB ByDnP6VmXN7c/bbaCJZBFF85ZATn6j0pW6Mu9z//1vxWi1W1/dEq/nMdu2RNhP0B5qUyRFZoWidV ZhMjg9GGf05r/VZwTP445mh15c6bcWcEF7G0scf3vKYq7rxxx361QtpY9n2SISxWsmYo0j5eVP4V /lRyRJbS3MV7aOziw+1HaZikSndKp3fxDqPxolvNYCNLLgpBFuiEeBJKefl/l19a1jDuQ59hYLbV pY4r8qEM0Ym2O3zDP8JHYggjBq1pt1NGjzXTSMVcrszg/Sr5Ikczva5//9f8QXvJblHWMBEALbWO ATjpTbCzmtbNNRvroRLNC0xhSIgwHJCqfrgHPvX+rnsz+MVJoZFaPeahb3MTRzW5wzEnPTuB3rau bTy7xXniIiU4EjcB6FB31NFNdSpqaJKymHOFOAQKzksJ7ICRoZrp3OFcnzCp68ClOKWxpGVnqXLa 7i2NcOrNKmFwecexFWtPuIftb7YkaWQYVGB3KT/d96z5V2NJS5T/0PxYOpRG5e2eATohxKjgqM+m az7ySee4ijsSEZSHkYNkRDNf6o1KSk9UfyNOp7nyHX63O5pXkMnmyJLcbTtMhj5UNjqBzx71t6d4 gtLxWEkIiuEGxRCzW6sAOPukCj6lRqWc0cHtZRkA1hd0MD3N5vhdjGomODu7Oe4HbPSsaS5uVvEh W0x+/WS4uM4eVAR8xP8ASn9UpwnGyCVW6Ll19jurpypT9y29ST+8C1Vursi3nSBnefOIPLG49R1H fvXVSw8EZqfRn//R/DKe9MoKkSGdV27ByS3pV68vBY29rHcIGuIovMdQ3mmMsM9v5e1f6yxgon8b KSvoV7a6u73YHi6DeuRzjrg+n0rPkmllvGtJS8UafMXWMlAPr0/WnJXi0Ep+9YsaZcyRXDlYlkEf yx3Mb4dR0Ix6/wCFWblJA+bdN+87yrjBHfP/ANaqsjPnZiajq1xFFgObcxyBzIuCDjrkentVqDUV vLI3ygvKpxFDtKs3uM9siqbSWxLk+rP/0vwntrmCa4UXUUIkJAL9duO2fasm8t7SO5MzwTzWs915 XnwAskGSQC2D0zX+svMrNH8X89upZvYxYR5iD3ESuqosBzG+Tj73Tj/Gpvt9nc2q2zsIwgJn8z5t uOymopxT1Y6zTiT6feWxj1CCUzW0Zg2ac8YDFnIwC+T0+lUI7WVmgt7n74OTMhO1/wDaP59KHT10 CUr2uU7xIoXEau53yYaMcBff9f0qnqUK6SHuCzSpGBKfL+YlT1zj6/pVqCtqCdndH//T/CK/F2kN m9kC0N3Ckg2DcwDDOG9KyXSWzuIs5iJG8p2ev9bIwSjZn8XuS6lxr0z/AD+X+97n+HFVp5LmdMQG NWj5dD/EPapdJXKjKxiNC81ygy+9VwyAZXnjJq99nk0xnku5PKiVQqh+AgOKpU7aHQptIvPeyWjx EqTHNG22YjKOMYIH4E/lUQFsd00ORuX5xjHNEqVyHJX1P//U/n/RrO6nWJhJKI4zHKSxIHH8Xv8A 41ZNrp1lFFPv+yrA+4OXOw9sMPfP61/rUqTWx/GjnbQbviuppbpgodsDcvTA4zV97vThImmQ3tvZ 3T2xnhFzJvXdgdTjAJPQHH9apU7Kxk5a6nIz/wCky3ENxLNdgttuCQRDn0B71bWazhhjsdzRM33W RSpA9AaPZh7RJWuZWXiufKhVmVACZGGQ/wCNSrazrcJfSRK0AyQynIGOCGpqmiedLY//1f57S4cO SrxxnnK8Z+lY0d9d29xPP9me4htIi8cUbfPKAOBz3r/XJU2lY/ivn7lqSa6up/tTRC3iWPIRMhlz 1FBuEiimnhumZmTymttgfg9ce/0p+zZXMrXC3uYXDFovMjHH7wbSKjVjKVtLO1wzEvvA2k4xkZqe VmTb3ZsajDfR2cMpaWJIX3Mvl4R1HUH9K5i5ihuHSSF3BYZMeMq3+f61ooJbnO3d3P/W/nGaNzcx QByzLH5gRRlhj/8AVSmSG7cq+75F2sWGORxX+ufL7zSP4i5XygzRqUtZMbJOdgH3gK0Fk815YrdP JHliMqkeyNsfz6CtFFIgxbkETJEiyJL/ABq3BX8qhuPOS5QW7Eu67RGOS+fWmCV9C3BHbCHfeYM0 ZL5RctnBwAP0rNjeJ13AGJpG/eKR8xHb6VUVd2Og/9f+cXSNLZ45GuLgSMCcEL0Ttk0l1GdOcStn 7IrYLRqWJzwMiv8AX5RSVj+HzLvLpC63lvaoZkQxxzN1FZscc9xMZLiT5ZB86kErnrxUSjroBtW9 xFFiN4mAX5coOg9xVSSfF+JRFm3PGwgrn15qXFovnkX7ieeS08hVxFGxlSMjvj1rAs4bq5jaSWLZ MeWCklYx2BNTKN1ZkH//0P5toFc29xa3hLQuu0FRtIGMYzSMLaFFCRs0cWFV2+ZvTmv9dPZ+Z/EK k1Yu6XfwQapbJJ93zAZMghQM13evW0TWIupF89UXdbSQkSALzkYHuR9KPZ+ZqmnscVdRrAscsQLb 0wcdF/Csl7lvMVSdobj0ocOxMpK1kStdxQQyR3USSo/C5bBj9GB9qsSWLxxx4ikEbr5gkZCEI+vT /wDVQqfcyP/R/m0RgHVVC43YO7oayNRt9/zoyxyQTiaFgN3klT2Gfwr/AF19muh/D5dRRJblDNJK blcOr8gN61LZQyWVvgJlvMy3ZT+FL2bAguYjLegM3yuoKp0Kn61pCUQ27lVjRx8mzu/bgVLi1uBn vNKzoFUxY4YYwaveUQqXG/bJH14+9UmsZK2p/9L+a26SK+SNL1X8zeDHJC5jKAHOOPwqWXSzcw+X HM6NEN33d7Oq8kfXAr/XKMXI/iVST0MyG4tXkcQpJBAECbWBSXcBhs++RWqIWjEV1KrTx/dXcTnF JqzsVsW5JoYzH5asVGGYEfNVmeJ5YQUChHG4ZHNIV1sYoQvN5fyqkbbuPvZFWAPOk2nIfO0MRQM/ /9P+bq70r50jMe2QLvVXO3fgZ71BbwLzMryEzHZMknyJDtGPlH4V/rc4pn8UqVo2JbdpLdvMd2aJ XIUA8kDoakkuLa8jbZNG11C4BteTMQc84xjFSoaa7lxlfQfBcvHA2EVWjbGMYNQeSbqdZJ1ycfIo HK1CV3Y3U7LU0Z1tYzEbdQjum11JzytZ+pK66e0ku4M0m1OMMOD0rOaXs5vyN4StKFj/1P5G9fvo rS9kJlDb7lvMBb50Gem2sO4ubbXY7qCyhEclvASGL7A20DLgn+VfVcdL/jLccv8Ap7P/ANKkeZkb /wCEih/gj+SOMkSSzmiWR1LlcM6tkOPpTS6Ah4pC2G/eDutfKnpkmQZ9/n7oEQSPjqD6VZXUJbra SxeH7oIORgcDisZfEx9LFz7RDHCwdwGk+RVxlz34q5Bew4KM5XYOdxwKynsI/9X+Pg3ZkQKrdeBt /ipImLXHkv5cilScMcEcZOK4G9kKN4ts2hqUUECxKgj2H5tozvzVZ9Vd9hkAWKM9/wCEev6Uht6j ciZzLFIXjf5iy8ZHoKX96Y3WP7q8gnhuKLCv0Ow0vxS7aedLvIoJHICw3My/6REqjhVOfw5zXOPJ kMnzlHckK424Prj8KmUWxr3VZH//1v5C4YDFM82QhbgKD1qe7LSxAI24p823PDHtXl+z8wKwmlVF b7pUDcQNxUd8VLBMQ/nRszdgT1NQ49GVGXKXpcuymViuRkY7mo11C6UpbQFhIG5JGcelCV3YnyNd Ibi3Uu8xczDMg7E9efxrMu7q43B1YRInylF4yfWqcGlc1U09D//X/kYtLkSSEF2ZxztPIra+027b YJ4wOd7FeP8APWvIe5a+Mge3ilffAAihsADrS3EIXGXwwG0Vco6JIJOzaIYIGYqykAISDu4NNtVv Yrm4Q58iXAiP9zA5A/nUyVpFQ0iaJlks3Dk74x98Hoa2NNuILiQO/mFJs/LsIK4/Sk7dCZNPY//Q /lbkuISrW6yZljPCE4rmLrUJjNDDskhJJ3gj90ex5rxwt0LUKNLaTXKgLFCxWUDljjngVm2n2eIv cR+ZslT70yGN1567T06VDXvAbVpcyQsJWY7SMI49D2NTyatqJmcsfOgEe1DuLMOO3es7WKi+UfCo l/fzK+8RhSxY4CjPH86tTtFqMtomxN9tIJNxXL4HUilaxsf/0f5erWSG3tb62uz/AGhHdqUtgV8p 7Y8FcYPOMfrWSA8e5TMCzpscDnYPQj8K+eaudlMsW9vPElxcDa3koDIHkCIQSPu5/pVJdTS582OJ 3SNTtb5Co/A9x7is57mhN+6liUxmMsvy72ODx2/Op4RMwAOQBxwOCKhbaje5cW5dvKjilKQRyF2D fL7HH5V0aXNqka3MbbsYBt1wvnccnOPbA571hZmcnax//9L+XebVBNK1zY2MsEkhMMyyNkwqueT6 gnpj1FLDcgbJWLSOh3GNiQCeetfHWs7nXOSlaxdtdVmiDuwOD1GM1py6mt1FA8e2FYfvMqBXkPfJ xn86ZBnSwyyW9xei5fy0cLgMCQT0G3r2q/ayx3UVuwgVXgUkHHPcE/zpNJ7lwlysDcO5VUJLF8In cnsBTI2FyZYr8zR3FrL8iK2yNuTw3NMuHwo//9P+Zmd5oERpIpZ4o2USRIP3zLkYIXjNd5rEPh6P TdMvdPlQ3NyjRzxs+J42XHDL268fSvip76npw3OJeWSCTzPLdBN8qTlcxkjjirGyO6Cw3NyYo3++ 69GHpj3qEuXRBPV3JIVW0AhiZtuMor85x6VMbuGJP3se2RwVO7mm9yChptyb2/uFeJI44SFWVs7y Ov8AhWisuZpujRRHBJ4yKQH/1P5qo2t7cyMZWkDOZcyHcy5PQewq6l7HnEke+3eMjsMdq+Ii7PU7 2iiCkjyfZ5mKhsFGPCd8f59ar3Mks8nkCM+WqDay/wAR71P2mKl7iuTLNIsUKFzb5bYJOnTt/St2 1u2YNtckD5Mtxk+uKF7txc3NJCTQw3EE0c3lyMBnDEfNzxxVeN5RFESuFhf0x+NJSTdiz//V/nJj 1GW5vFKyLAkabs9PObHQemOtbsE0sbtcHa0xU4lcB257/Wvgp/EmeinZNGXcPJLJyxdyxeRm7/jU c0saSRllJ2LuIHTitE7q4ijBq8z3ilkkEMh8pE2HC9eT+X8q2oW2XDsMhmXGf7taP4EiLJTM5ot8 kskUxcs22RNxIQjuB+nHpV/Toonc20kxXZmRt5/XFYz2LP/W/nRmjXzZ0Vi9uX4O3GcGqy6hfpML i3jlaJSI0jXEcny8ZwSP8mvgG7nbKVnZGo/nTCaRmdDJyueWT1q2kpuEFu3AVdoCDa5pEud1YwLy 88i6YWamQphNhbhemT/M1s6bpia0l9epcwtd20JeeFyRPKq4zg4x36E0Ep2dzPWa6W+tGbznht2C iP7wjHPBHpmukvtYt2QkyFNrGNPl2ucAnp6UNaWGpNO5/9f+d2O+WZfIkJkjnGGDDjHTBqpJN9g3 2sVrGY5CFI6BVyDkD8K/PzpTadyLUrW61aeKRHLNEiKqY+UJHgEFR14FXbi/tbKaH7M8gtzhAJFC ykgDdlR05zTTa0QNtsqz3JjlxauWWWQyzJISQueu36n+dRtO8qlAdgU5yp25pqTSHKTla/QT7Tsd AoJkXluOf89a04Lu6u7xAbYxxpGVKSOdxYDAYD36ge4qRqbvqf/Q/nSvLhnOVJDo+049KaTIqPIV YogzjGc1+fnW5u2hnAyNKxZi0O0bd5zg+grQivJFWW3KAowBXAw+R3/GklZWHOXMyrdSPbsl+Xk/ cqQ8Kjd5q9xjr2FT3d3C13atbK8MRAkdW+8MjlfoM96ZmMmv4ZXurKz3OIsee8ilZI2YZ4HpWDFc 3VrcO8gcLH80LRsA8h54x+A6+tNJvYD/0f5xYL2e7iKNEvlP84Zk2zKe4JqHUfLEAFq2y4YKPMlG 7YR1wAen1r4SS930N3FPc1xqFmmlJI5KvCCrnqXP0qC1xNAlyjrtfLqR1XB/Ssh2Kc6nd5pKvySc n5vrWz4dS0uzOftCQSRsPLhZSRISTuwe2Kielgn8UfQ9Em0qwjjxLqNjuW3E+RLjJI+6D6+1cH4h gt5oBFYXnl3YG5pFww4JwO9ZtWLStLlZ/9L+b22a9A8q4uEaGaPy5UU4kLA4ySDx9KinW1hntYpR G7Qkm183BaMAYO0nnocV+bnTGPvWLKKJmMcToN/OcjHFZt1YneZUuJI7iJSsTxt2OM8dD07ilbc3 tqXxqN7Z2Pnx273MUW1bhd2JZDjsO+cZp39oyPcR28sRUSLv2BTnb3pKPKU00kWI5YJ3MQRhGjHa SvOaoXtpIsUrI7bi25fMOAg4pvZmbjqmj//T/m/OjSlbPV01CfaFFvL+8BtmHrsPOR68ccVnLEtr cyWfnB5AS7DsQc4Nfm53RVkaG/yYsRuQEPK9jTIooJLd54tsTK+Xi+63JPzD1yf50FEcG68aSCJo llUF1NxII1wOp5/HAq0dQNm9vDtDBztDsQiIexJ+tAoSRnXkdvE8aSalBDPLIziFp1eM9yARn34q GysHiuy8qBLaVTJK6NtdzxjI9D61UU3ojWCad2f/1P5r5JIo7lLZEKQsh2bDk8dselS3Shrd42Y4 cbNh4bB4r8+Ssj1J7pEl3b2A0zTksrm+hNuFEsbSDZO/QqB12j+lPvocaYGjzHI7gNIq8+/0q7+7 YxhHlldlCzuLa3s2MpBKy/MS+58n261E8qzt5iRsyxfMkuPlXIx1qUjok9Gyhbz3buy3JURO5CMM 7VHbJrb0m5t9LvrOO4C3McsxkFm2Qk4GC2MdOO/86U49GYn/1f5zr2eK7u5VVPLid87NuFj9AKyt bMEv7qKLA2hXCrgHbjH596/O03HSx6BjafLdyrKhieK2jl8p3kXYrAc8Z/T6VoiaMRTzxyYjhUlR nLHb2A/pWhaeyKEd8195TsyqZMcn92v69KW40vSr2a3uLiDzJrFjNbyDjaSMc+v09qBS+Jk8Xlzx wSQXJCo27A+XcB2/pUfmvdXSxpCfOU4AVecdj+lAkrn/1v5sJLd/NVJd8UhbBblTkV0Mx0+z02W6 u3JnsyHUYLecuCGwR6da/Pz0+TS5gM63MlnepYWq2vmG4t1yWVxyQfrz7daS7uRO3lJG6tI3EcIJ HHH6UBBagLeSBkWW62SOvKKOVH/16y762g1GS3sbPT5WNs73l1do2AMYALY9Dn86Dop7lW/vL1J7 e0VYriEny7p5ZSJIhgBMLg5/HtWpLC0EkVrNjLjPnZzERx3oNT//1/5tLWKGOPYsrMAMDceFPtUl qmt2zJ4iiRW07T3+zPHNKFMbevlg5YYI56c1+fn0MdxJ5rm8IuGbmY5B+tD2L2unTT3U771UktBG WfbyflA7j0FJtLccndmRNPGtpJe2jTxLb2hybtTHIwC8s4PT/wCvVm0uUGnxTxwRM7xfJBCwM0zc nO3PBP4DpWc7XFd7GZexXt4RbvYb5L+dI7pSgi8tV7s3t3x1P51dlvPsOpwWbACNUAuUziUDoSna oNk7q5//0P5tbWeCJr5ZxNfWl7F5EcZwr2xPVs+nTjtWPqGl2lsLZprjy7O0ZbxAjn92efvH8a/N z6Rz7HQPJbrabi2+PYJYyg37+MjgVk3FpeTgamszNFGyw7GPzjI/hXr25/CgUZ2WpAwm3vuVPOjT CTN1K9do9KrTTX6qkz3Lrsk83YgC5UDGD60EvcprfT3EUzStHJIZxIhY7niA6cfrUltfGzl3yhrg u25onfazn0BrbmiRKXKf/9H+YeHULq3ZruaOVIyxHkr+86ngj/Pet0X25d9tYWtxcyLsEsuVcLnO 0HnGfcGvzyMlbU93nRWuby51yUtJYy2DWyLCpjn81MYxgc+361iI8kOpbI7maWyt+XRlyyuOpJyc Yp80Sk01obOpT6vfyQI+oPNYOwZLVmCxK2MHcOvr19aliu2FwtiLfCCIuZgOZDkDHp3o5omsH0Lg kmdIvLIURsdyEZMg7A+h6GopoWvQtsmoz6ddqC8UseAQw6Akgj3/AAqJSTasap2dz//S/mhvJWRU t52NxLANqNwTKR3PbnFWllsxZZu4AMKHdcbyhHPA79P0r8+TT2PqB9wbe/0yJo4vMjkb5AVwTt7k VQ02y8mO6k3v84JiLNlYiBjCj6imBQhE8K2xmuSJPMCzbFyshPBHtk96vvaS298WhkllFzhsMxKx 4HQenc/jTSu7BVVlYvbVlJ+0SFvLIVI5DnBzngdqLi1gkNlMk8sUhuij24hzGV2n52b69vX8K3Rj Be8kf//T/mmmtXa5gmaQM8NwGgJUZjIIxtNe5/Cy3trW6+3xP5jXEj217DO7FX2bWXaD0ycDI9DX BwrF1M4w0V/PH8zs4hbhgK0v7rP0H+DFxo91468KacyXianFei+02ztsxpNHGMTB5O4AZflOc7ge 1f3E/szPeW3we0WRLQRSHT4Es2ILSHMKscD2DAD6V+seM9/reAh/c/U+b8Mpc2BxUvNn87X/AAWm 1WCfxTZ2dq1ykP221U+eQ8c8vm/fjH93IYEex5r+djx+17aXdnaXExOkGOa9exePzYpnVCDIRngr 09xmv37w3gqfBWH9H+p+VcYT5uIppfzI/G34kXd/qPiTXFtrgPbWtySs82IpJAQCyqemFJIAHpXk IQQnzpcMX4A7iv5O4m/5HmJ/xy/M/Zsuf/CdT/wr8j//1P4e9Gnuo9SS6glZLgEJbnqeeMen4e9d lYW72d/OWEMs0SeZPuGPIyM5HvXFWa1EjUur2f7Or2dtPO75huEgJd7gE8YQDt+NaNgk0PkSQPsM 67TbFsFSOSjjtj+hrx6usjojsjs/DHiZ9I8R2NlNZXqW3nIJb2JCbdWc4AI79evY19pudfhSCbRL q2ie3hWeeWSXy2CMBgAdyc4wPWvPrqysbU4+9qW4HSREk1AgtEN1wyLkk9yKS8+1WcFtHbqtxpjt 57XEqbbrBwR24HtXJy6XPRpR6H//1f464PK+zRosakbArAffOP8APSstwbiZ18vfGBxJn5o8DpXj Vndo46StGx3vgOZNSNza2/nSxW5Iud1uy+WV4JLEZxzXY6lb3EUflwRpcQJOGmkz8+0jaq59uMVl D4jeMXucv4du7C71DWbOVG+3WMixSIVxx94HP93BNTeL2hu4LRfsqW0kUwEUtuWzMv8AtknA5GMD 1rdK8jZJtXOeaPVLVzdWu2NIYQHuFO6NN4wAfrXC6+LaNXypMjRF5wwyWzk5A/Ku6huwSbR//9b+ IjT3062vHvLkQvAFw5ZdzRqTzn/Cv0K+Ad3ZubmO2jTLWxu57hz5akKqCPaehOAox7ivtfDWXLxn gmv5v0PE4p/5J6uvJn278NW0/wAP/EfwR4ge1ub+4tf3OqpcSAWzx3bxhMADk8x9Oxb2r/Qh/ZBF rL8D/BclhczRGXS4PV7dGaPcyp3G1iwP41+0fSIh/wAJeErf3rfdr+p5HgjUUsvzCj21++/+R+Ev /BZXRQserX9zAJ760AksLtIytvI6lPlQEdP7x7ZPpX8zOr6ZF9uF3d+YNRRRtVZF8qMMBvzgdeBx 7V+h+C1T2nCtLXa35I/EeLabp57i0/53+bONv9PguZ8szqyuCrq2xvlOf6VpG5gWZGvkuILVYmdJ o2VCxAO0DPXJGK/b1sfD1JrnP//X/B+1t9OvXS61Ga5WyMjKhgQS3DcdCpI/Wr8SQW6vDaSs9mEO xpowpiX1KjOK/wBUo2vqfxM5rY5i2e2iRyxe9uZ73EMUce8xI3HPt6k9q9F0630eSymjhS4k1GCB ZZs7TFHk4cdOmMY5696kFNHLai0NtK32aCCa6iYiSOY7ljBGACvr6Vg6Bcx297drOLcuW2ohQn7O pA+6c9euCfWqUbpsbqabnTrJZ2EhS2HE0RaWVl2su7IOPb3rlrlpVW5u1cPbJG21sbSCOB+VSXGr of/Q/nostS1WeGVLe2libav+lSDMbDPJQ55IGevqK6uz1WOcrMr+dcjZa+ZtBk+XAKj3AFf6nciv c/ixTXU03tNMuri4viSt0iCNTLnzEAJOQOmTWbc2qa4YrSa9kgFu5EUyrvkjB6gD3p8qvsVGfY0b LTbOwidLe9lvHtHaMNMvll1zkKR2/OtCCQu/74KkaDKiNsE+uabj0ZpGb6lWSaSLy7yFftTo5U2z fdCdv5mp7C6ku7xorm3SKJP3n2ZRw2COM+lFi3JJ6n//0fxHW+Noty1okcT3B2bWTCuAc4HfirFp q7W3nzyWizLJAYdgiWYoT1IDd/8AGv8AVFRbWh/HCm1oihaw201wxeG8LTHd8lyIkgXHChCpAOeu Klu55IbFbTLyT20hZA4zt59fpSsaxqFnR7iG1hI1KS4eCeTeIISB5ZIxnn6VGunWl7emSO5vIGlj aMQGRDBn+EjjrjrVRjclz1LkdidKUr5P75R95wA/Tr+P9ay5pHuMPLay3EafM0UEJkmbHsMkUODT siVN3P/S/FixVG0y1ntYkh/tFDLdWzvvu7EjICyLz6Vmww3Wkm6nCCa0vnEZkALujDA6dhyK/wBV 2rn8cN9zRj02DR0v5BJGk0qi4WDJZSzjJbPQcEflWRDaMt5b3F/LKbWackumWSPuV/I8UzKfY0DZ Zee4QGCEzN5DhyW2Z4JPY0+OKK7P9qW13cXFzDiOWOVW8sKowpQnngjkH2qWrvYhaO5DLHNqV1Bc 3ci7kiMc/wAx2ADG0Ae3PT1rJ+y3kbvc4P2MM2zeCScHov0qrW0Ef//T/DWS+lS6tLtryO5glhCJ bkH7TaBSRg+x7Cui1G5jjs4r9UVtigYflTnAwK/1YP4tk2loctNqM13LKNLAt5J4tkkSLuixjn5c /qKvJpUotrBLy4eS6ZGliRk2oyZALNjgEkgYHagcXdanUWdta+W0HlqGVM4UYwOmf5Vz19De+ftg jjAVcmRnEQx9e5oIm3sbFpqL2VmzIBLcRsNrSpvgB64I79K59L54Lyafyyy3Tl2WLiOMn+6vQDrx QRFtPQ//1PxBt7Oyubs6oYhsT5bkkBZ2PYDNVrrUIoZvLS0nkCEPAI03vgnqR6V/qu4p7n8YK6eh bS9t5rgeTay+dLHvmldNjE4wB/8Arp2kvFBc3ww63ki+ZhEyH6KSzZ7AD16UuSI5XvqSQzIt1IFk LvEMuqN0zWrEY7wbJH2Mrb1lHDpijkiJNopzaTNeXoXT7oQWEUYNwJoBumIwW2Nke+OtQairwGKL ToCLNXAZU+aWUnAJYk44600ktjc//9X8R9VtNoMDP9ogMKMwc8hioLL+ByPwrPs7JdKeS8GZonxK sC8+XhRkKPXqa/1Ysj+NJy6I6aGe2ubd4g8j/akwif6pkYjjP09K5z7BJ5syPMIpYlxFHIPlGMn9 aTimYKV3YuwS3NskYHlt5ql9sLbiQp2nPcHPY1mTx3Di7ngglhu5JBJdySScTKuFjwp/yc0WRHO7 s0rW4unRRcDzLsYwi9NtbaztcOHlCRIsYiSBAQ6jvn1zRGC0RpGXu6n/1vxdXT3F6Tp18ul+VD58 ksxGSU+YqvBxuxj2ya121NZrFpmVZbkYceY3Jz1z61/qtOKVz+MaD92xzV2whLXjuwjjiaVokUyS HAJ45+tUzZTaqxkshCgdBPiR9ifKMjJPf9aiMU1qJ/ERKNQtQJi7CSUYdVfkHuCagaydWjn3eWwb cw65qWrOxoneJrtdulksFvDiSZ9jknaGHtT5HmOXQvC+0IVyS5YDBx+ta8iIjpJH/9f8WHntrfT4 DIrST3Hzs4yrAY6Ff15rBt7lUeeSEy4fMRckhFzwVA/Cv9U4K0rH8W4l2abL1vYfYUnuYmNyl1EJ JEHLIwz/AA+1QLfvLEsMblI3fDuncdK0iuiKjJOkixa20V4zm/ulWGyIkLbvnlXpgKev0qg1vCZ0 m07ZbofnR/uBx34PSuhRS0A0LOzubhLrybgQB0MZmVgZOeD8p6+9bltDa2aLbQyOXlQLOWwS574A 7VUVd2YH/9D8arnTrF7cRwhUdZN7XOP3wHpjPT2rno7jSRNKBf3LNCxUxS2jJs2jqD9fwr/WZxVj +LbPuVZIWnhuJrO5l3MMJtP7wEdAB/nrSaddjZGbpXnlQEHzBtZjz19P/rViRLmT1ZoW8Nheedbx TkTSfNLCp/eAf4e9Q28aWUd5BDK8zxMBHGy7SCx5P4CgqDb3LE1pDJbmb+1EjeMf6gxEu3GetM0K URPNJLLBcTop+cxgADtgHOKLdDRSa2P/0fxSG3UNTeZ4o38qIzo46Ifu5x689PepbstGkbxswlJ2 lMZQqeue9f6vckT+MeaXcYRbyRP5AZ7iIASBk2ruPJCnvxVuCwaBINR8428ofMSBsPEy4ww7/wD6 qdkSYcyxyXrSvNJcT3E2+aZyXd2PGSaXUY47aUAzoUQcqrBgx9sVcY8xMtEaMDzXWmSJHIIWcfIW XcMAcGstbS63WzM6+WsRjuIkX5ZGOPmJ65GDVcmhmm3K5//S/E+60+CCGD7Gk8kzfNKjMG55+6AM 4x/Os9tX+0xNbfutxHl+XMNsRA4Nf6wWtofxeallNb2iNHGmwxIBEEX5fp/Kp7O/hvJ0bUEm8pZv J+cZAHTIFADdWu7LT/8ARrSFsAlhI+PmyT0HamwamsVtFJINzucR4OCDjg59qiaurlqdlZmcttZ6 ZaeddXEySTOx5UbWJOd54zx+VJbafZ3s3m/bpShO8PGNsrHqCD9eaysaOS6n/9P8SfscdvLzMWBJ G7ufr71St0Md3IIXdxI21iOc4zX+rnJdH8ayqaJGwAYPP+0K8mIi0aAhQ5wccmsuxSJEkuTGAIWy PUMf4QPXrVRVlZmbs5EqwxXNwlwwcQHqufLY/Q1KyymVbh1aNEzGo3ZyOxNU4+/EpxiomIVW9ldl ZozuKSbDhh/h/wDXrR/syODTLHT4kke5W5Ae+MxEyxuQOcdcdfwrdR5SYpN6n//U/D59Ni0i+uMX a3zxvtEi9HUZwff/AOt+NZupgTyGVAEMvBz16AV/rQfxtZIvWEJtrRgpeR5ThpWcsQe9LfNvtvKR slV+fb94/wCcUW6BZGTZi1sd5Mjo03UsTtWrP21mmTfKGBbapXALAcUGAX0dlFdW5iUSSTdEcho0 x6//AF6oXMkk9xJPKqRhFIXyxsQcegpNJhKx/9X8ELF7K+dLZZUs7wAtiZ8pMQcnB+ldBex6ha28 NlGFS2dhPNhAUbjAOce5r/WRQ7n8VuUeiMuFovsktv5OzaxYOjcHqSNuO5z3qG1sLaRS+1kYnMgk wQw9quMLaIUpJqwxEE8rHJwh2kdAMVpwzxRzbpGDeWuQDz0q+Rp2E3dIjZILmRyimRh+8IUZKfhW RPeQtfpbTQzyQToYGbbtVPc55q4wtqwU2j//1vwxubC4sY/tVjdSfZDbK0kN0yiJNqjheM+vfn0r n5bv9wLuW1Ny6E4VsqR1GRX+ukI9WfxM5pPUrPjywQ2yVwCUHRc9v8+lSyALBlUbzRGEBUdafIik 7aoqWUt2YGmngeGRWO0MMOw7Ej3qpdTvfuiOjzHIHlycgfUVSilsbp3WhoXN3JLHDbOoHkrtVAv3 KyLkytFIsEjRMAADt6H6U2k9GB//1/599NaO282Rk2yXGPPx90kADOPwFTyLBqry2NyoFsqeZvDY LEdOPY4/Kv8AXNQ0P4ubS3GRxiyTy4nM8RAUM/3mI71g/wBnRvqYbypwWYzStI/y89l9OO1VGHcy k7sfMJbJ7lopZAJCE8huQRzyOPpUcd1gLLIm4oOVI61VkZOaTsjSub1NQtII9OhjtZiRudAW3+oO T+FOEMtrbtE7Eo3LkEn61Sg+iJc2f//Q/nylt1FvlZQFxkqa6PTNHW502W4gXfLDHvkjUZfH94j0 Ff6+ez03P4ijN31OVvLaZGwx2Rn74BwfpWFDH9lvIw6lo5CSpflfxNJwaNE7q6NCKVbiOaFYFR2c 8lhgY9KtafJNb2TzMMy2rkQnuoP9eTUA9mQat4r1a/s002QKsUbbjJ5W2RxjGM/n+dY2nXMay+TI vyhcLI2Mg/WgyirvU//R/nIlvootQkjSFRcNFtFwh3bgM/KarGOSW3byYv3xfLJnG4V/rxY/icvz 24ZInSNleOMK+7rnvimxyyDysTKpQ7fLJ2sRQc5bb7FEZ7u8WVyIireWx8wZ6YXv2qnAlil2hj3X DjmFz8uzP941UY8w1oyvLGPNeRgqlmIwG3LVJbWWJ5ftREbLygwcPk8Y/DmrgrXLnLoj/9L+dW1J 8sIN0fmLgupwWHpTJ97QSxmGW4idgojj5c46EZr/AGAP4bc7OyOceC4WPyLmFoHDkiMrggfw5Hri prSxaaMqC3mD7i9AaCoyutSoYLm1dobubddld7qI9iqM4FPMjIkJ4Y78EDnNASfKjc3oiL5yrHnB G7gMpqwxt1iZbdkRZFKl1PC+9TJaGXM73P/T/m9ntrV4bVEupzMshEvy4jIx1Jzz9KighYuYc78N wR1Ir/Xg/hyMm3ZjbpfIuBGUw2OHx0/Gry3l2tgtkJ22faDNg43SE8EE+mM4FBom1sVGuhLF5Luy zpIAqoMIw75NNvVhk8tnjMTRgbyFIU596BFQaVb6m0Ur3DmJgCLcAqDtOeT2ziul1LUmm082DsfP KCO3KnPl7cY4/Ci19gP/1P5ori6S0NrC0M800kojk8sAogbA3Hn61rX2nSxQhVVN7fMzZDqoGCV6 9a/14sfw+ZkQ4z3Q8bRkVoRPLknfvCj5lPUUAVZUF3IpRZEeJvmyMEkdMVHJCBIqyZJDBtp9QQR/ Kk1dWA0gVXc10rIAN4kxjP41ev8AyRaQfZ/n43Sk9WPsKhwfQD//1f5sEkSONXI3DPGR0NWrO4jW cST5EaHfJHu2blzyM9vrX+u0U0rM/iBOzuhLxbbUZnmtwYAGxHGQGDj1JFO8xlVSNxitxjB+6cVM oty0G5NqxXjkDsZyVw7HCr2/CrU8k0yqYy2yIY29CcUcmnmTsQWVvF5NxcvG5LfOpDFWBX2/Ckim RZ1MzBYZPu/3qThZaG0ZXR//1v5rba4/4mM9w7TSlo/KRZXJSMAYBAqbzCS27L7jhQOMZr/XA/ic v29swRVmX5CTlupH1qD+zHiv7e7sZd5iLB1XGRnHJoBaGncRpHIGnA3ufnGeDVDc8N4zQ7pFRPlK 844pKKWxumnsW5NKU2p2M32yYEh93Qnp9DWBrcd3b2c0MrzJdwRmRUX5gGUeueOnWsJr93NeRtGV pwP/1/47/EljfyatcjBlkmJmnuJ3zKWYZ3e+a5M+fpkwaRmEIH74FdzN7ivruPY24ux3/X2f/pTP JyK39kYe38kfyRFPdq0wmESyf3SRggfjVlZVnWWOJFDSRcsOMexr5E9YqssiIsRTa2OcDg1YVpII 0jVFBP8ACgzWMviYE8bwB0N1lXwSr4+XI7A/lQ+JS5TBQjn0YVnJXVgP/9D+Nuxcu6qm1TGM7T3A q3OLdJhLJIUkJ4C8KDXC4tGTm76HS6Rrmi29vdQazbzTRLGZLR7QL54kO0DfkEleOnbmsKC8t7p5 QvG8kKsnCsM9Kbg1sTzMJr37FtjUrHs5IxwR/n+VbWn3kckO+TajuMp/01FS01uL1M7Ulkjkjmjf gPkbeAlMN5PKmZ5DukbCv9zFItTaVj//0f49oYbh4fOWcyeUeNz5ZwPWpmuN08eEMKAfvEQ5VjyO 9eeTze7dFyKdY0K43kk5dhjr+FLDMrnaE2hTywGKLApJrUc021GdmaRgdqAU+G+EO8qAJsYV2Gdt JRSdyrp7GhHqJEO2SRpCnJJGSax764MqEx5BAyABn/P/ANamB//S/kNsFjjXc0mHcfNk81auwN2R vY4wH6A968txXMC0H292IkCsBweSOtOlu3mVWQELvwHPUAe1aDbvuMimd5vKDPucgDj5QO5raglQ IYJJmPlOX5PPp/T+VJxT3NFFOKuXFENwmBHvjP3g3Ga1rPFuAyopX7i7eiiplHsZH//T/lJvZoo1 eTyUaQPvVmGHB5FUoLg3UZ+0Rxxshwq92HqK8rkdgLsVxFEj25Ty43YbgBx9aVbZJhPHjzSx2QhU yXXsSPX2qAI5LUxWwCsCVOCDx04xVOFpC7IqqCq5Jzkmiye4FhZ1I8klmMp2FeqjHWtWOWCBkMey 3kKGDzycFgeqj696zcNdDaHwn//U/lGj1lhMUik2skpVJD1BXuPyzTNLzai6aW5lubi5uC9xNNgZ B+6APzrwGrOx0ptbG3Zz/aI75LkB4VZY1R2xxjk4qrcXkcbJawrEsCLlGAG984BBPtWM1qbRd1cj kVlaNQqjK70VSM/54rRtrqaLZvLIUIIB5IxUDHo32t2aRCqOTxjYPyq6yEIoDBUX7qjsBSstTGUr s//V/lgLRr89vvE0rbHLHGAOM4q7avGMxMpaQthmr5BprRnQa5niVJEWLLpHkMD8px2NU4pQ8Sgq F5xsHWkBmx4mmmEVxMDFJiaNlIXJ6D6fSuks7uOG1cSBfMOUQKcrjoCT2NAEsEceAj8Z75xt/GoJ LMb1tl3ZjcsZRMWMg9znn1/Gg2h8J//W/mRa8eIlV/eFB067sdqmtr+PIa4hVm2k+U5ztr42Ubno p22M8KTPJ5hmeCU/u4pG3Rw4yRtHbrSzvbwxySzSOGiUm3IG7a3bI/E1Kh3ESx639ra2UDY0MQQu FwJOfvH3q5JK0vMqHaDkN3q2k9wHwiKMyShnZtvCK2MH1P8AntRbuEtXO4tI8pLqxwWzWbh2FdN2 P//X/mm8uEpwvzkd+lU5by1tsJOWKkhXCrnaDXxSg3ud7dhIrqJdwjXbAzbg5GHfsCfwAqaGSU3I ljYfZ8YYEfN9RU8rethJvluFzDBqF1JHDdu7QQgvFIPLSItk5z68evpVFPt0CFjcm4YYRFCABQOO 1IyhJXuaNnPcsEM8CuFk3CTneSO1XJb557j7MUZYmQFtgwVpKKiaRnfRn//Q/m+tLSEsGJztPGfU Vbv5JUtpUs2SSb+FHk2L9M18M0nudvOhbfUHW0aWaxJA/cvjLg9OQauSNp/kxyW5kO1efOA3A9wP b6+lO1irq10Y15q4s1hZLR50MwVvJj3SLngHHXH8q0Y7mKJDdMrFpzkRvxs7VpHWDRhKTckSQSIC WZQoZtwCjGc1HMwWXciDzT0PQVhJPlL5rRsj/9H+dlymEj2nzGGdo559q5m6MqXNrtu3gIlLeSAN s4A6HP8ASvgeV2udB0K3PnCNCdjKuXHXd70+ZTHH9qjl5i5wGwWI7UuV7WAoxw292puQpgd8tJhR uY9OfXoBVW1k8jzHWRvnO3A4Bx3qlBvcC7HNNbM0uNwY5ZjzUVxHFNi/lVJfKYOkTcbc8E4rRRSA /9L+dPTjZx3sUm4tZvxNERukUnHKk9K1tQs7a8vlubBpcQQhJg/CsODnHTIr4eye50GbJJdaY8l7 ZXDrMrjyQyBsDvx/SsO3iF0xN5IpmeUyeYfkb5ucY9qALtx9mV1hhYyMoG98YqpLe2S2Ex3N5vmC NHU8Afxfj0oaurBYItRg2pFgNkbjN3+mas/aJpXgEEgRC2HY8nHT+dZyikroLW0P/9P+cp7OS1JW 4/eLdS5jeMkScDqT+HarStK0rW4JP7rBPGD14+tfAwV3qdBjPGWkVVkdkRidq9D9TUtndpdM83mC MW7NbtGxAbIJHTr2P51XJ71gJYJBPKwQljHJt2uuM/StDUbCKERSMSwmAw6j5kPcGoaadgM/TUYS 3/2lVBjUeSytu84/7XpgZqK/sopYY5t4DiTci91IHUj8a2SsrAf/1P5yLGeeTakyxlYo/LDINpbH tTGjS4nZR5akdmbpXwzStZnQZQh2zyLPkW/VcnIc+gH5VatQjSTR26+RFuLtEpIXnv8AjWLSTsip LRFfU2Esb2qMUkdTEskZ+6SD3HStDRLBbexeJ7rybmL7rF/nx0BB7kUVVaUUK3NKJFqlzeW3ywR/ bGiXzMI3mNKTzk+9Nv7kwPbbYD9suVC+Wv3gBjcT6Y96xnubcq5uY//V/m8jsIYJ2uWdmJA3Rbsg fQVPqU0MzWUX2JBLkrHKIzvC4ydzflX5x0sdyik7kC2YjcFPlwpIb0Pp/n0qBomknV/nAUFcfwEk jk/lSLi7O5dNvLERlsoo811xlMAdaoxazLd3UdzDGvlonkRSRrw4GRk+tBUpX0NKK7iWUlk2knHT HNVtYuJJZ438uOK3EYV1Vj8/qTRboZydkf/W/mil1q0gaG1skdyeTGQTEv49PwrVt7WaWP8AdwFr s8wqOGlY9F/lX5udyu4i+RLHcBLxJIDEP3ySLsGT61UIgkuSqSvGqtn5RwwHY/WgmUbsnCW6zmUR Ay+X5Kyj7ygnJx+Q/KsXUYGnbyJGaWIHIVSRz70DhFopvo1kkEAuYtoikMqvJksSfc1uyXkVxbsl v5nmWyCNsghW44APf8KqL5WdXKf/1/5rY4BepHM0S29zCPKjnK4fBxkAnscCma9Zamk+lNEdsfnK s7xoJA6KDkY9+Oe1fn2tj1J72OhjksLSCGGYPJczSYhHl5SLjJ5/OsXUrqZ3S1tQvls4EpYdvalB 6WZmZ9xoSLYlrdwlysw+TO7Kn7xPv/jWf5+o2ANu1w5tvvLCoBj56g/iKobbasa9tLHeWih41hkU AsnVQe+DVa+vo7W/0zDGWQkwxl02rZYRiSvHfH60EprY/9D+aKfUCMOzsIw3MjfLk5qz9uW3ilum nn3PIqeTsHlgAdc9evPf61+dS+Kx6BZAleGWK7kKC4O+JF+Xgjgj3x396py6LFJYxW1jc3Ec1vP5 kgkYKGUYxyevU5B9q1Gld2Ml9PkHnR3LjMcmIzA3BA9+nrWlBf2yFYZMh9hCBRlnxQaON5EkqST2 3718qhJh2r5TopOcHv602K/torgXNwkj3NpZfZ7dLdthkxjbuHc8UupVkf/R/mruZLyH7LeXCytA xbzI4U80EsONxxkBfUY61NZTTm3iWVAIQ7qIpB5ind3JPt296/Pz2DnbyfVDd+XazJBDCfLSMgGL b3GO2R6VrRX0n2yOCONLYWkHmtdfMxuN2cg9ux/A80m0txWKN4Z5ZpL1yNxXam3hmA7Cm2qz3Fup tHkW4fJmicmEgA8YPUk46UlNGlPcsz3FpcS4kt1guI41E8iRlTKQMAluhPFV2+ySIv2jfIsUwkt0 DEyZ78fieORVGp//0v5n4o54g0ylzCnzMMZA+taujpHe3QVr8QJKChDcxkYz8w/T8a/O+Z66n0BP qkkNgIIoAjKn3wPl8sAcBR6H9MVRPiBJEhRLeURFCJCTzkdeP5VFmwMiA3Nxlr1PJFwzbE2ko4yc A5+lK0YhvYtZ8uG1lsAfJs7bdIflXAkK853begpuLQFXStW1G7zdzvcxi9Hnxw3QA+zMewGAeevP 6Ve1K3neLTpHlE99JKbd7iWMR4GARz056AdsVIH/0/5nzZ3SwzoJWilVcbo2Bye+P89qcFFxZypJ I4nESqvmw/JIQQGDDsCAc1+bn0Brm706FFnsWkEqw/ZxbKiPaxsPlbHU+o9qwYJ3V3aV5Flk48rz TJCuOm0Hp+FU0kr3AUBbySaFppIZo4hLuUfKfmxjP4Grd+LGC3Rra6+1ShUEsUy+W0WcBgOucDJH r7VolG2gGDa29nc6lLJbyOvlKpdGAjU546fX0NaI0W1e7E+pPKqRSmSBoGwCpHRvftVW6Gc0f//U /mluPIVgrKVtnfy4W25Iz0ziqVyYNNuLaO2W4mSVw9xcNGTFFkcj86/OEt9T2bPsSxO6z+YsfmRP IAwU7cKTy34cmr09tZxXMkSHy/PPmDcmN/A5NI1irIwhIqT3EaYMscoDgEtGB2wfpVuF7mMuyeWx PKF+B+dBpGXKdClvCvkxwzrLcSxiV8cBWIyR9RWVq2k3btFLbPJPepN5sMQfZ5mBgJ9Oe/rQbLU/ /9X+ZVJrhbmV7yxazO1UNuz+a8TAAMc+hOasXFw+Io7e3+0F2AlOdojXHJPBr86g7dT6g1YEtYfI 3b0ihRtyQHnJzyV9j2qgbSe3gV2llaOGUysgPDKeMsPxH5CtQG3NmkcjPauVt5ZFlIf72fX9TVab URFfxQs52mPKMoyrMOoz+RqoSit2Oo24lnyZZ72ISsiW5InE7NzG59foCevrVhiskkSSzFI0fKMp 278f56V0w5Wr3M4N8+p//9b+ba5iGxZI4zKqnO4HOwjoa9s+A1mt9qGjf20XhF+S2ZU3RKdxRRIB 93dw3qAPas+CYqrxFhqcdXzrQ6eJ5cuV1pdOU/SP4LaFaH4qeDL5VW5utN8Qx6bbtZncUW7DRFif 7vyj6g1/cT8BbBtM+GOl2MbmQ2dkIbZ3GWJWMGRj2HJwMelfo/jPXj/bmEo3XuwX5s8Tw1pxWT4i pHrJn8wP/BXHVoLv4pJZw3D3mnWMyNJJd2wja3aGaQgxYJBGSP8AvonGa/AD4peJmi8Oatc/YpjO kFza3FxcQFkto5Y2jhKN23Fic9cdO9f0d4fQ5OC8PLpyX/M/HeKnL/WGpK2nNv0Pxp1q+aYS2U+n /ZlSQvKJn8xixGSVbuCST+NeS3MgSeQow8ouVh3nBH61/HvENSMs7xLb+3L82ft2BssvpJbcq/I/ /9f+IDw/JbnUkS4jkcRwlwy8Ij4+U++D2rWnujFJJJI5kaZ8PIRsbA4xXn1d2K6Op0fUbiFI4bSF BK0gkS7d2SWDHOVx6YrsEQTXcMyWawNIQJ5YyztcufvyvknBOegwOK8qqtWjphJaNHd+H0um8UPp VusF1D5aT2m1PMbJ6jp/k19N6bq0UekzaU86tePKjXcnl/vY9nSMEjjnNefVi7WN1Jbkd7rLwM01 0GdBAERmQjaqgDA49q77SvEVt4i8K2dm80S3aI0NuWt1tzGmRjLd889ea5IzV+U9LDfE2f/Q/jas L+MaVPbTWoe/jvWJuYptwEPQFh7+1WYJ49MVZks4biK+QuyTuyGMg53ADn+nNeJNapGCilFsn8M6 vq154jvbPSRdRaXeRJHcbf3cLNnJjX1H+Fes2Ba8gubSRmgEMmFfPzXDqRlQMcDAY8+nvUpWnY6Y RuiG+stNtrhpbPY90GSS6cR7ZyoUgeYRyR1xms3VIZp5dOia8FxpMMrNc+amRBuH8PPI4BraLtNI 2jFKJzVno95dX2ow2MktzZi3DRszCKNVB+Ytnj0/SvPdUtNOTUmtmubu4kVh5yhwCRnBCnGPoa7K OjKjG6Z//9H+KLWdK0WO+ltNP+2pHLEolhmw5Uc/xAY59OK+t/2XTb3N5e2sWrTJZKh02SC4OVsP KIcIMjIDMck5PbsK+v8AD98nF+Cf99f5Hj8UR5sjxEV/Kz708Nxuuu6HFaSziZtYtYhNE/8AqgJk JYj2Cmv9Bb9gu4sZvgD4GabUxc3cGhW7yLAWkQb2Z8t2z8+D/u1+5fSHV8iwj68x4HgamsJmC/rd n5Z/8FrtLmudD1B1WEWR0VoBfRguIj5zsGVR3G/Bx12iv5T/ABPCsV089s6PHhyzSZ/eNn5SvJ4P J5z1r63wFm58K2ve0v8AM/HuP048RYlJdV+RxgEUskzuN8cERkdEODuxwAfXPaueuLGW7MU1yjR8 /JAW5TPA3V/QK1R+aVG+fU//0vwqtTbWcc5liCLbR5eNgf3nQYX1PPas+4imk/0ywPnxSps8k/I8 PruHpX+qcNz+GnN9DLitLyx1D5rco0qZ39VQHuCDiopknTV9v2lxp4szmWP7xYkEiQA81bihc8hr 2C2hl1DTZBdfbMTbpxgkhQu3HYYH861pbAakq+Ukts6qJHuLdcMnru46D/Gmklog55GpHOZdPaCL yboRt5az+Wvmvg4zx0+lc1PPeafdJG2mrcI8qiSwlISIIR8zsD7c8e1Q4djSE2f/0/wfvzBaW1tE sAjikJaIRphSPWqVrPY6VazpDZ2sstyS8TyAo1u5OS4we/Tmv9VPZ9z+I4PodTp9zZTwBplhd+Bu ADFWA/lWdaXH2bVbmS2sFtJW4junRZI37ZAOQM/hVKCTNNh+ol5bC4jVI/MBy4UhGlPIwMdue1ZZ uTFb2VrawAXZjU3UXMirtxuCnqRjv+lKUW9joOkhmWNorg4ijjwZU8kEuD6jGa0RPpJmabSluWk2 FLq5mTy8+qRr2X3J5z7Ucmli5NM//9T8NGJv4sM7wBPlKDiSR8kErxSWsU62t0stzK9xK2LdFRVE JUY3N78Zr/VNcyjofxjJp7GYmqSQzNFJO0k8eNzjg/WtQalf391ZeHFt3kudQYtDNHD+/iGBzI3Q DngmoKU7Kw+axTT9ShsdRmuAJEMU8QwSjLxu3gYyeeP/ANdX2SJ3gji3GG0mD+YXMbSbegz36e9V GXKQ567mm9+lys000nltt2oB8+cYAUfhnH0qS1a60K0TU7eaGOe7mKw3EUn+lQgfKQw6c+/bFNzY lLXTc//V/FuBmRbiZrhlvGiMkjpDuNyzAjntk85+tR6SL4WEtuwTymcBzdLtmPOcrx7mv9VedH8X t6XZNeaJJd3ZVbtVguLQRyo5yke3cS35VmH7HE0dvh2UEJnnHHr6VZMpWOje0U6dZMlyghnkkTyl bcYipAwRn3B+lU/tsGlKdPjgknmkVpBKqZjxnkE+vIwKTaWg009jImkvJ1W6trLy125uI/uFFHGc etMtpb0faLc6ks0RuMxWMib4kTgfL9TnJz26erM+dn//1vxMOmR29zeTavY/YZYV3W8kTBraVG5G Bn/9Xqaw1W/gt7m2tpfttsxLW5kQsyFsk7j0wOO3av8AVg/ixe9GzL2kWsliftdukU9ww8plmBMW 49Rgcnn+VO1M3oCzyLLa3EbESQMBt/CgtK2gyLV7nTI/Nn3u18FjhPkE7VyCQTjgHA59q0NQsTqU cVwbmWCJ41dI42ALHuD+RqvcE0nuMu42sreYNDO4+zIY4AcM56jGcckH+VVWtJpLe1NqybApmkDK RLHn+E/jUijHlP/X/De40XVGtGuEk8qGR8NJG67xg84Gc1PaaaY7r7XHM7pGqxSRsd0g7ksPy/Ov 9WD+MI7o0pvPu7tY7eNLeKNQ0krcb+wAq9fvdabZ7ba3iJaMs0ioJS5PegcviZzmlWzyW09xJ8ju /wC8IG0hjz07datPEFBtGuGkZ4wXkC7CpOeP/wBVBJpSIlnYB5xNN9nj/cqCck9ASO/41W0mS5uU DH96gO6QFArqM9MCg2TfJc//0PxZ8Rvs+zfZ7WTyZnENxOQAkOFzubv27VRvruytbe2aBI5plBtQ /IjOeS35gV/qwfxdLSLNC2twTFOgRGZB8wHyDOCanIjimeW9aBk3rHCWTcSG6j8TQYE91Jo8F+08 GktGIrJreFGfYfMb5i49sgcGs9phLY/bbnTFF0LcW8oLnamDwygHGPTNNK4W6C2ospIVvbQyHUfK MMtvIQkIUHOV98ZqK2tLw6xDcGBhYSIDcSiTEny84Cnv71dJJz1KStCx/9H8ZtS1CG6uJksrJ7e2 LtGzzEGY4+UdunH6imwQQIkiyvGsvlgKCPmYZzx7/wD16/1ZqWd7H8X0U02jFmjlknaK3Km4KMIU mbbCxwcBz2B9ak0u6ng0fyprSKa9Vwt15L4QMeyn064qIfCNqzY5IxLceY1rcGBI+EWQJGr9ucZ4 9KWyR55Z7ZreVmYF9zJ+4QdAN3rRyq9ws+hteHNM0rVvtMetal/Y0kMvlWz3dlK1vI2dq4ZRgHOC CRjGaZc2iQXHkjbLPE5jaUOJFkOcZU98+oqhap6H/9L8dVtrS3jZbjZLI5MbRMAWhI7+x+lc9Lod pdNcLA5t5T8y7Om71I79K/1W0Uj+K8T8ERpsZdLjjZ7ozLgLhvvsemMVRtwGeWD7OIZ5Nzw27DHm juV/nVrRktWgkEen3b5iLhY352mPEqk9gatTW9np1rFC5lnOSu6XHmvnk9BgY9q3LldNWMgWd1BE 14YGt7beVEoPyKM8E1qxQrblZDJJJ8gPmt90n2qo6PUs/9P8Y7ZRNC0v2lVXfsCE/Mx9celU0u7X dJFFHv8AmMckrAbHI64r/WSbWx/F5kQRZ1MRgJFHK3XOEBB44rTvbVzcyIkSwyvwzheZyO4P+etZ iavoVJtMWI2V0Lq5iuQ5inhtQEJQ4HJ9f881ZuVghMclq8l1vHzMyiORfXPPPSgUVZsfdi3LxO1s lvBOi72YtgcAF/Xnk8Vl6c+lRG6iMzi4mylpxiMHP8RPPI6UFH//1PxPEVv5aNbXEiyA/PKvEbnP Kiom068kug0l0Ft2GQDyxzwc/Sv9Yox5j+Lx5knaSK0EaJBFKcSpxLP0+9+VX38plIvbiWMLxGI0 Dk8HjrVKC6gUzbWMUcs6Sy+WE+UMBu3UyDRLZ2WWRZCcbwjMSremRWhE9ijJfTQTxRxjZFDNibKf eGOg/nVWTWVbUFtRgrKfl4OHwMtg9qDNaM//1fxNuxFEp8gPGzjKhm3EZrnEtZor2yjlt/tBM2QS m7ycg8n6V/rHNWZ/F50f9nyPdxz+aYwp2mMAeWw9SPbFakNvGdRiiilR1zt2EbQx7deneoFddylr 6WyyohKliShfPyk+n86wp4G0+4hhmU4MSzwjOQwbkH9DSaurDC7RNSuYjczuqMFjNsAAgA9PerP9 mSJcWsOnyMpkPljfgCL0z2x0oSUdEB//1vxF1GC7tFktrkrHND1ZG3DNVrC0vLS2E4cSvJL5rb+A Aewr/WJcu0j+KHJyk12DUdSe5khilZ18oYVVGAR6e9JIrx26n5gd2cIuW/GrvTXYqM22WEufNtgj KI8HKvjB+tH9oRxRGMs0+0YYhD8vH61V4pbmikmiXSLe3eM3Mm9Vky6krgk84z+VUbiLUIb5RHdx /Z3bedx3Dbj7oGeDS5odylePvH//1/w6byo7oNPM7Oq7Io0GUbcf4v8APeqOq3dqmpWFqsbO8iGS R1G6JSBwPrX+tB/GvOidb/fELeOKWKQzFAZIiqAA9SenNNuP3f3CTMQVDL8y59av3WtROatoZvkf aytvK7MyR5cqNuT3NaOn6daRxLGMzyo+5EfLt65//VUaLVkKDbsiAWVuZpGlkaGRZDsZx95m6Afo OKWaz+ytb2k+8i4UzrkFd4Bxn86lzjfQqVCdtLH/0Pwqi0/SYbh7yO3UzRr1di7RZ6kDtmr0pluA 8UE4niWMMDEpBjHcHI/DpX+srqRW5/GEcLVnpGxhiIh2HzEZwSo61XuZ0CFYyST8uM49sVrTq05+ 7BmdSjOkr1NCGJnsXM9zIgtZIxtt8fvN+eWz6e1WLuCNXjkiRhHOuFm6gdCQT27Vu007GK2LdtIs KyR+Y0Mkkflo8fBc9gfas+406/MVvczqis7kFf48Dow9q0jBbsZ//9H8LbbWrRY2tdVXzrfYIt7L uCnoGIHoaz9Ve2tytvAwkjZPMUnhgPcV/rxY/iGMXIwoYVmjaQzBgMkNEdwGO1QwX91Crs1wrx28 bKi7QZAT3oNLe8MtNYeeA5jkUqT5m8cmk+2rHm8FvIRG+1yo+XGcc+lNK7sWm1sa9+Rbyqs0RWZ4 UmUrgja4yP0NPNspEYkCqz4I24I5HtT5JD5pH//S/ALWBDYRDdwCAFcjCtUVvayiVDPE8QkgDxvj 5NpA71/rxbsfxPOSTuLG5W9SJVDxrxkDcSR7Vr31isEcN6PvltzBh94f5/nTtrYjnRz+sTqI4ZLJ 1lWRliuYimCmeTg+xwKxbhYi5jhl2yEfKCOBitVBIwlK2gy2le3+RMMztglR/KtfzyF2yg5HXNWk 27Iybb3P/9P+exl+1BNjbdrcxqeWA/8A1UxdR1Ox+0vp108MjR+TsDYJHcfjX+wqgrWZ/DdN9DOk e7NysU0xZpE811kfcFyO3+FOjVrpPuFlTjgciplG2xrfSw2O3ikjnIkkimgXhGBAfnt700Xn2dIL dwzM7Eys54b0x+lZtJ6Ft+4OnkS9jdJG8hoHHkuVBSQHrk9aoJpgunigE3lv5gKlGAEvsSamUb7E w+JH/9T+cK402SyeRynz7tobqWA96lF8lqsZRMy43HbjIr/Xlq2jP4lclbQfLqks92rAbbd4SsoC 4YtkYx9MGrY09CEvY2Lhkzgrgq3pj+tNRbMHsYNyk1xNBDPvMsbZXBKBgfUf41otZxWBRt7/AL8b WIPH4VpGPKRB30YxJrCGSKJ1lmdZPMfcuYuvAH+FdtcafpuvwweXc/YDAomk81Apcjkrj3GKo02P /9X+dRGtJYJojKbW9glxAGIMcy5xgfpUVx9r8uNA/lkdXQ7a/wBgD+FytPfKSkUo8y4Ix5j/AHWN Qfa7iJN4i78lRyBQAy4uo7223MrLKjAl84LD0xVeGG3lkOydFaNN+2RtpP0oKbbWpbuYBKN8kq5i Awucn8Ksw2lrJaSfaLgWiIu8MQRvORwMA9aCT//W/nGiazVQSHKE8Njjip7OyNxLINODPu+514Pp X+v3Kr3P4chFrUW5tpIg8OoZguI/kYHAIPpWXNGI4SWYHa3BU/N+lKa92yLK0aQ70kcgqfmBxkZH T9agkku5bpRPI0luIsICT1yePy/nUcrtcDYtXi2Hy28vaNrq/BP4fhVCV905Yrh0OAc5BA71cItb gf/X/muVUExnkVWYqVGeidsinxiZ5GDK5iI+Yk/Kc1/sBZPc/iFR0uSywmJEisrcKv3RheB6Vo/a YEVYJLbypWQI8oXCkjjrUuKbJKk7i0WR1wcgEHHK461UhjgvozNNPIGkG6FosEA9s+1JwXQCay1O DWYRpskYkeN9l08kZQOFOMjj2q3qLQ2yJFENoiAznOWqHCSA/9D+bYpHJZs+BHHHmR3bGF9TUa2d sbTcZTcyzgSJJGcRovYH14r/AF75Gfw+R20y2q+UAcs3BxnH+f61NcTxqvkuxUyjK8cH1qXFp2DY prCqECOQAnkOen0rYtSJ0WMOGlX7+BjkUWdriTT2HRxXGXRmGwNyB0pl3Yx4VnUZxuUAcZHSkUnY /9H+a4Y8xcxlhjDMi5NaG1beMyOuDn5AfvGv9eLI/iOU1ayLcErRW73AMUrPmMwSHA5HX8KGkhjZ FhVhOcDzFJ2HPap5FYtSTINQhnWRBkNJIwVmf7q84P6Z/Kr1vA9snnxbZGjG7a/3XIrEpNx2I41a dF3ExguSwHHXvVbVNOlexuzbh53aFkwDhmBHNY1lalNrsbc1pwZ//9L+P7x7f6ppetLaXNmsDtEu JS258cbVI7cVwOpas5RVZfmJBkJXoK+w49d+Lcc/+ns//SmeLkKf9k0F/cj+SMxDFKokM5EcjbSo /h9fepkmSzGU3SZfGOhx659q+PPZvrYtsxacneHDKGUg8DpxWnbbotk0i9Op/u1jNe8MnmhhutsY b90MvuUcgn0rAcS2bGGJxIsr+WS/zYyefpUmLm2f/9P+NKxtokZp5HKyJjDu2FQVZkLSPsaWCYBt x8sghR2zXOc+wfZUeQbTxjGVP3anto4Id4KswU4BAy+c/wD66COfWyLUdpDqctxNlljiASMMPmIH Y/r+dV7u5+yEIAwIX5BjFDV9GWWrKWG7iZmfYyjJVvu0jvHKfJcAIW2+YRwO1S4pgf/U/jttLO8t r6+KX63NjDEqW8YQIZMEZkYnnPt71bZUlUB3ZCjBywHBA7VxqHcyjrFojvbhlt18s5ZjtUY5A9aW KWBYoz5z7v4/lwV/CoaadiCqt82GBbcm7AIHJ+lXLWGWdmMZYgfNh/4aQ07bF91Ajm5UPGAGXOC2 eOB3/Cq8LeaDHyoIxuPGTQVGbvqf/9X+QFbcCVQZyNo5AGc+lXJWGEUyOQvLEjGf8a8h3uBFG6Zw V4LdfQe9a6xCSI+ScRDluMEVuBUD+SwkQ9Dt54qS4aVQrsuZJDguFwMUGt/cOo8P+SJ44ppFYMOj cJn3NbV1LYWUrxW6qCpy0cfIyf0oMj//1v5Lry4V5wS0jBic7RlI/rSCeOB1UbZhwQ4/pXngXi7S yLtAJ25OeAtaen3b2LrdK+yaE7oyOWBHSsppXATWb6bVJo78W8FvJMP9Jjt/kjYjjdt6ZOOfrVKC 3ZUF0Y9iuShOfmO32z71ACx2sMVw8sUsxinVSVkwRG2PmA/WrBlhiZDcQJcorZUOcqOCOnXvQUm0 tD//1/5NgsUn7qBY1BkMibU/eZPYt1x7VbnsWlgKq0ou1Kt5argEDkk9+1eFPc6FqhEZzBJBIWLO Nsh6F/XNXYRb3ES+VBAotD5UhyM56dD9OgrCfQpSaVh8sEKbbrzm8xBtjiU/Ko9xUVrcMzHfIWwc jd71mJtvRm6bjzLVolUI4HDrwV96qvOXCxKzAqoBc/dY9/x4oEf/0P5VERnfAf515ZxxirSMkcmG b94oye276V8s4p7nQXbRv9fMqnDD51PJ9M1lxS+RNCJJXwZNrN1PPSsnFoC1eSNbXDQRqxc4JYLw MipLZRaNIbi5dkl+ZIzgoOmfpUgdDeXULvHb2UQjhSBNx8ze7HHJJ9+v41VifyZUQMNpz5hLfMKb TW5pCSSsz//R/mPiEKl5Vw20EqW5FVhEk032gDBQ4JXrXx56BoSSQJE0oyzBducfdrCeHeXeV2aN hwmMgHPWgDRs7PBAO1PoOcVNdm8tTHHEBNEVIeRvvJ+FBi27stRovkxYJBb5pWHJqn8gfkhgD8o+ negV2f/S/mbeUCNuDuAwtVxaLKAk+AHGS2cn8q+POpybAQRbzGHK+WBgEYBFPMjQ7iAGEXKjoGoL jrGxLpsyTrK8imN2yGA5z/nitPR7e2tvKF7IiPcXJSFl+dAASQD6cY61nNJIzUexameJLl0g4TzC FQYbbVK8lmG9INglClRIVzt9CR/SswS1R//T/m309pbhEjLIboxbmiiOeRnPFEVo0km28V0IbcuC ecdK+HOlqzsa8rNHam3ikbLnlMbkz0yRUFw0UMSRJuaXaGYbTgetBST5Wh0At2SWR03yRR7o4uB5 jenp+dQXSOTG1xiDccmNjjZx0q47NGbWqMy5uF+0QW0d0MuSI415L7QSfy/pWsrSxxgz4XBwNwwT jvRy+7cHoj//1P53xcWdxbxpJGfNT/VsgGSAKw3ktVlLXAQZ+WN5BymelfFKF0bxd1czbuWS2kjk ikQZYKzMPkZc9B71bPmSDZG+UJ3Fj29qHBg3ZXJW1NbPbALd5zK3lMVHyx/7R9qijja+8xYl8pA2 NxGBmotbQjn8ixLFJafuZBvCdSp3A8dqp/aSs4WUKYXHyKpwQMY5985oNFqrn//V/m6tikM74ZmD NxjOBXXJOPI2wkxsqbXK9WyDXw50GOl88e+G6BbaTsbb7nArGu4o7hg8S7JgD5cmPu5oAjtZJYl8 uYDeBtLr1JqcWtskEihFPmsXcBfvHjmgd7GY1qLeJjLE4A5QjJ4qeee40+3inFtJLHMBHabBjDnn L+3T86T2Yj//1v5yrDU5D9kivYmkFvJ5uGbIjz94VYv7i0V3ks24lOflO5Vz2r4On1OgyLK6gtbm eG8SZVniK2xC/u3ccnn6Cquy0uJJmhjeO4iIDscqrLyR7dutabCTT2J1ieWaKWFP3tuCY2TOW45z 69K6GNodTtnaa8+xz26bo4DGZPtDDt7f/XrJvVMZmmCVRI4JQMOSeQar8sMk7gDg46CjnYH/1/5t RKXmKRbk2jDkcVlvfxpfy28JLTQhWkUcthun8jXwUpXVkdBqXKQK3nTvJu2ZQD7n4ipIHTypbiYb rZIw3nRD5xnsRioLlsiWS309bET2kr7nbd5bxlXORyazLVi9ysnnLIrJiJwf4Tyf8+1GJkoum/X9 QUdYtef6lu43Qedc28ybIk3SdnBz2/nRp0rrPJJM/m3LruxId7Yb0/A1nKcLas18j//Q/nAnhMl1 C0bGFEUli7435Hp07VK91DAIRvM0xckgLkKO1fnKcXCx6NmEFzGpe82x3NkfkkhlzHKj9wMHtzVR JJry3vbq2ASSFd0Vs7BEbnGN3rzVRimmhDba5vbQCGdy9xOjTRkqD5aH+HjjHOOeTmqUXmqYIrGe Av5pD2pyJ4uhLY6YPb6GrVF21QDL6YyR5+0wWzRTrHtlYJ55PGFqK+jUxm2kcytOnJjfjn0OazcJ IhxbjY//0f5objQhFFpaPcPbi2nWWby0BklUc7S3XHT8q6mO4hkIwWjliOYSPyzmvziz2O5JxVhu qajNdzLLKwkkECwFyOoQYGffHesRVjSUTGPKkFSBwPrS1TtYtJvYWO5McwcRq3lnIjYfI4/CqUl7 Dd6l+6hNugYFoVyw4xnk07PsWoNO5c1CFdX/AHE6SJEhASMfKWI7/SpoYLKwVPPcJFuCOVG8qScL wOepH4Ucr7GmvQ//0v5v71klZ7IGLEKggxkZOfukkVdsb2VNLkttRMaTId0UicsgHA5PqK+AhFtH q8l3qzm45PtEs0jOywRfN5iDfICM9F/Ckt/MX7TdurPBBAZy0g2zScgYC4HPIqYwd3YmUOXZlqO7 iYERrgOASZOGX8KrXkKKhdDvGcsOpFKTcXZoghs4Q+8gFEXk54xVa5Wxa5UT3JiVThpdm8R8dxWc qvLsiowdtD//0/5n9sLtAspU2y4bplu3OPwqDUI/t1zbQ23nJbxvl5Y9u38R3r819rrdo9R030Ox t7y3+yy2l1Cs80cYihndyJYMDAIx/KuWna83TWjuD5cIaO9fCmUkkBdo9OKv266oqMbbmha6NcT2 dxObtFMcQkEb9GwQGx74Pf0rLMNtFeRTZ3Pt8uONsZycdD74q41ItGqhfqaEjFiC6FWIxs7Cqb2J WTzJ/L3xkSQbCGJHH3v8PpQ59hODWx//1P5rRdTSZgOQAoLZ/HjH4VFGbphe/Z51dQoK28mAisAQ D61+dNza0PWtNO1yje2t1PbRv9k2kttnuY3YIpA6fjQbu3s4okuV2xgKkhjXcfTJrCXtluFpdyyL ETy+eA50/dutpm4LeoIH4fnSzwyR4az8sSNJtBZ9uAe+KyvWT/4BUeaPUo6hb6hCqLcR+US25iOR IAezfl+dRuZRt/0RVnkjJhkyWSIfX39K1U63V/gap6Xuf//V/mmgu5o4UiKgIwxKCfvEf/rqpdW1 rDcm5s2uo/LjDOAMK5ON2Rz79PavzNSl1PbU3fU3rK3t9Ss5pXktphbQiaRvNClQcDuRyCcY9axI 7C0mN3JFe3RCp5scDQhWXbwQBjODg881vGol0/AXM7jfMmuoBH+8t0dNkM0sZR04IztIzxVm1a3t YQZnE7Kxjhkc/vH2jqRVOo72S/ATnLYzmdobyB3ijeJ5tzI77HRf9kVrTzJcxxrCRIkT7wrc+WRx nHY/4VKkuqLTnbY//9b+aK3vGUTpeqsIJ2wEEknn7xP9KsHzIIxJHbi8WLBMcrFFk7fMRX5xJ/yo 99XtqMVLIBXgit7R7iTaLK1H7lHPLYzzjPc0l7bixsRJNDGJTNuUplmJHp/Pp+NZe+UnZ6mVaC9u ibuKeOFTnfGQN8mMcEVcMaPuSS0Bdz5hm29D0Nbrnte5tGUVq1oKRaQMqfZogjL88/PmKR6+tUZ7 lzbPcTFzErbRGg3sRnAOB9aftqi2KdSG6P/X/mot8mE21zHlEKtDO3f2PoRxUd9EqW1/IblHZIle 3tcgtKw7fka/OfbVex9NKotbFOG9tootPIld2uHEdxF5RT7P/ie+PaiVxLqEln5s13BbEzRXKp5D MCSQgHoAMZPpUupV3KVZdRunRxSq4SFl81y6yyKVPupBqcxyb2jNvK21cLHGpLN9PyrOVWq9ClVp vSxkRxKLkl9SNpdtMCLRjtmjCjggd84Nbd1fXdxHIbOSNnt/9ehP71B0yB+NZv203ujTnp/yn//Q /misraS8QC4uxudd6l+sx44B6cDP5VdWP7NNKiMAkcPzJjMjnI4/+tX5ko1U9WfYqrT7EVh9kv3u 83qWRjjMrPJiLdt6jJ4zx0NMuZJ5VsxaEXdtcT+WZw+5sAZyf0/OuiMZtB7SnLSw26tfPsLxFeWN 8GGK4B27Gxg4+lQ2Ftp66fYxMjveWiMs08r+Z5rE9Rnn61rGg76mdVxS0JNSs5Lqy2QyeWQByjYG M8g/hUNnpcc0bSiWSLywNi7ctJyMj24zXXTpWVjnilKZ/9H+cGBYIrfYHZVYcF1IP4ivoL4SRx2t wZ5klaNoQ9ssKiRnlbgE88KOMketdHh1hk+LMLLtJP7jTixxjk1Zd42+8/Sf9k7SrnVvi34bZrO9 lXULpbFGt1Z4be4huInjOcct978DX9v3wuWfR/h1pk13F9n8m0W1aLYWRj5apI/PJyc19v40UYVO K8O1/JFP72eP4aUKmH4crOTv7zP5Jv8AgqBqS2Xxb8Q2FzOt3aLKunabbk+S8wa4aS4fcf4l6KB1 VPevw4+Ov2q/059F0mdYbS9tlFwb5/slsWUs2Xbpgc4z6+1f0zwhalwPh4RdrU1+ET8czmc555Xw 8teab+Wp+JXja/vAL1ruD7NeGXYYAfMQkNjKsOMEDOPevNNP86+vkhaMzyMwCxr2NfxjnFJPNq0v 70vzZ+04HDzhgoLn6Lof/9L+JKztY7a4t4g6NcTDAjLDaT0xXQHSIDFNHd+WyFlJi34mbnOR34I7 V5laDi3qZQoS73OrWwtkt7bVYGiFp5v2URhwW3KP4xnI7/rXWXU0MK2yRQLbyKiu7AnZKCMhsdsg 54rzKqd3c7aVNLc9Z+HRtxrOm6tYsRd2t3HJLbKBi4CHIVu5BNe6eJbm2NzJqctjbWcyuDNFFGII UxwCR6jj6159R8p1RVNbovW+paVcRxtqEtrBiREWKfaElA6Yzx26GtLxFa6NcW327QZ1huz8n9np blYdwHLebnBU47Dua5bQttqejRqwV48vTuf/0/4w7PS4LG4glFxO+93SRXPHzE4z64/DFaOsRz3V kkWcSI3kRSBfmCscD8MkV4UpXtY5ee0Dr/DqyeFtT0BYFtNb02LC63HKWt2YumG8vHdSRyfQcV6l qaQyXv2rSpI44lTdFHnBQYPzN6nnFSnrc6oyajocykN7dTSwwOY3m+SWdH8vzFwflb2PpVbxFY6d aafsZ55NTdY9karsgjwTuLN36e341ul7yNou6MbS5Vhs7t5GZpjAQkBfZC3ruORxgE/WvMblJr+S RltntbpXx9vDhocemOpA/rXdRWpSlq0f/9T+KXVtfn02a40vT10u9aMqZZ7qHKzkdH5Gcjtg19Cf ArxDcWXiK3imt2mh1KBoYjBCQGmO0AAgY7jH0xX1HBT5OKsFP/p5H8zy+I9cmrp/ys/SbwFLb6T4 v8JT6pK0FpH4jtJbzfGWjMSyDzFf8O1f3yf8E1/JvPgpYrmSSO20mMRtgNbyDevyj1C5GMdjX799 IJXyHCadT53wKalSzGPofF3/AAWC0gjwJrMrLPAn9lTWdovl+awMd1FcLJs/iXYGXjnP41/IR8Q5 pWkvHe2jt5ba5aC1aNTEt1GNoR9mOMjt1+Wvofo+TUuF5x7S/wAz8j8SU6fE2JT7r8kebPLO1tbu 1q9i0P74Kp+W77eYe5B9D6VmaXfpeT37yW0jiSX7K7OxjQYHO0dsZ46V/RMFdJH5VWlaVz//1fwk v7qN7IaerGV7ZAba6lUCZ2HUMR1x6mubjkvLKzEc8iyXlwcyuo2xrkkgD6f0r/VSC6n8KOa6F4fa 59PllmuF/wBHPlxRbvnl9l9v8azmh1SGfToo7F4obyUrJLKw2Nhd2N54HX8M1oUndaGjeSf2ZO1p IIvNGAUjcSImRkYI4q9Y6uWs7qHzhbuqEGRTtZgeD9aaTaGZ3heSyhLtPcSKbqRjAka7lYklgWJP FaGpNY/2hE5Z92BEwjTfnrjP50jSnY//1vwdtbxUkFqLgtahH/cyDcYnY9Rnt1H5UXenaXLaBGmR dRmm/wBEhjkxv2kFyfUY9K/1YP4kprQrWjNYXDQ3UE0qbCoWDhwSp2n8Dijdq08DS7YBEjCNvOm2 z4yANoxjp1oNEjo9KsoJ3vYyJLj7PZh2cSAeW/HX1HXj3qvpsltp+qxX0jrJLlkthKcYLDacep9q mV1sbmjem3Fnqly8/wBme1kUN56EGRSFZ2X6A4/A+lctaX9yvmPZnzdPKmSKUqNzZ/8ArdqItvcD /9f8LYJJZ5NOPlB44JGcyIADlgOCfw/U0y7tr6W4kutz2bkfKsOJCo6c9ua/1Wi+Zan8Xj/7HE8E uoLgS2zBSN4Ek3qSvU4x26VJqOqXOo6hb3cEMNlcRwR2zfZU8tG2AKCRnqec/Wsra2IlKysia+Q3 M9lBJMWmyFkLDDbjj5h7cVXvVudPvE06PyJZygaES3axecT2HB7VqopGLeti/JZXjzwR2ojmYny5 UicMY3/2fWqcGj3V7q1raXeqGDZK3lWkswhizj+IdTkj8KfLHsPyP//Q/EfU/tVoIo5rh7QxfLMI gGuNnTP9eD2q3AZ209JtNuTqJSX7NPJeILeeEMrYZVBIbGB34/LP+qrUVLU/ii7tYbDf3McQNzJA 86TeS0SvtbA6nHXpVWKZZdVkRIZHiMBnJWNmiUE4Hz9M+3pVkt23M28Se3uN9jM0JZxksvmLjOWG DWw8skEDXMM8d/cxyiMxP+62Anrn2yTj2qWlpcuL5RtwZ9Re3aSURZTa8aYjRsdz71Rt42W8CSot sijcSPmYHHr71RJ//9H8WbpJNRVVjLSx26Y5y2R0/L/GrFsEs4LUXKpC7zhj5ZBDIvUY9a/1YP4p UnEc93Zv9oltoGt0iZ3twuASRkqx9ietc2hutR8qXUpG3hUlvWt33ng5bbu7HB69P1oNU09i4J7G TWLu2kt5by2m2Np6vKPMt1AG5Txg5/SorZb2K8kElp9qtkn/ANGjiQtJAvA/xyfegG0tywI/E93J K95ob2WnecTFc3EqSfagmc7WB4P+zViQ2dnbC7ZrgTzuYTGkZZEBwAfbkfoKLrYE7o//0vxMS0u5 BLFL8tvKRsdZCJMAAk+xz/Kq8BNlcXEFuMtcc/PgSysFAyT34UD6AV/qwfxhezuWItRaSWO1Vd0u zJ4ATIOCPXitcTX1sIJrsxWyNP5CncGAGRyR16H/APXQDd3cqS2179vuzbXNvcWUt35qLDGUiZQm 3IBAI5yQD2NTLYNcJfF9kU0EIe3ZztjZtwG3jnOO1AiI3txHZxLqNvHCZiIirOshXBAGT78H8asz eXptwlrai0lubqDKyW8gkRTjIHHfrn0ppN7GifuM/9P8VtUWKaKK1uZbhruUqG+znMMQUhjk9s4x 2rN1iSEpDAYYYlj2rvUbWI+7x7niv9WLH8WTdlY2LGC8srFbdZ/N3rvQOwklC54Bx6dKl1SISHSp YXjKhjNeRjJkiK/c4xjqM9fSgiC94zZLpdTuJJ9RZ7l4mBh3kgrt5HH5UwzzG1dBOFLyfKr/AMXs Pyq1GyYnuxsV1m60+G3tpzISxmmji3woFH3nPYf41qQ629sDavH5kgLAyoQFI5wfb0rSlH3ro2jb 2a9T/9T8VodZj1KK2lhgjAjBSRgcncWOc/T+lW1WK51BPLjM6Q/JJJGpjCnAJAzX+rUo6M/jeEPe Zn3VkkE0i+dOsxfeRwEdD0BpLq3ukjgNnHDgNukaQ/N+VQlZWFKCuQz6hqAijs08tbl51w7fcC5G 4n6j+da1/qF/p9q32e5NmJmH2hosNEQM8Htjk0wskrGRJrhuYLaEXLzoiuDFtCqTkEMP16ev0qrl pbdZzPJbrb5kSNDt3kYwCKDPk1sf/9X8UNPm1HVUN19myoyJJiwTocA+mTWJcT32nXtybnDhSfsy QNlwe31r/Vb7R/F+Ij7sLGldx3sNnFfJMZZRtYJKu4Nnnbj6elUpdTuZJLe6ktpYjDJmIqCDnuo/ OteR6WMa14yUS3aXl1KwuizcsV8hlGWHqT2rUuBHfyyNLmGSGIPGjDKPgAdfzrU1vbcrpHMbby1l V47pctDnzASDgYHbpVfT7mRbmfSri0lItG/ePLEWUAfeA+nr0pxV3YSlc//W/Ge5hjlvo202Dy4Y IRNG0i4V+nGDwe/5VlCzksvM2kymeTzTAnRST1x+Nf6xzVmfxe9EPfT3F2kjIuYgJQHbAOOetaTI 94YxI+2NGyNp2kEds1Bnz6mfqtubOPz1dj8/zEtnaP8AIFVlhtXsTI0sisp3xpjh/UZoHF3kznbp 7u6ZHjVmliXy13D5Ilz6elaEVhBf7BJt85MLK6Apk/T+vtQWf//X/E6Ozksdlo+zYzedAxbKMucc fQ5q/cKty2bUxpJZRZkLSELPk4G0ev8AQV/rJT6n8XkQjCyW4ZPOuSdwVexqC8dZFSRRl1YjY4wg /CtALehRtLI4uEVk7I68D3Fa2pullC8sC7n3D7x+XHcUET2OSVbu/Zrh40ETAokSjlSOc/TBptml h8qmEx3XmtGonTbkjIJX296DI//Q/F0aPdX9xFbwMiyKo2hnVQc4wSSfes7fqVhNcwmSN7u3laCU ou5FHQqD6+4r/WWa0P4pcnawk0d9c2e+3lMNzGd0YJwrH0JrMsl1CGbyb+SMzNIHjZW5YdfbB9va siE09i/cpHMsJuIklKXAKAtgrjPOP89aveIbqxnlgltodkMEKxgty+cDIJ785xRYpNrYwYJYnDzK nmTLlVAHCH3+lW7ee+ZJpPIZvs6bi6/e/D1/CqjHmKlK+x//0fwxS5knF3OVMs00eZUnyTgck49e KvWuqN5MMqxo0Bj+ZGbIwe49K/1llDm2P4fcpRquz0ZYuXtJfJkAQbPnRlqBbuIkLseQFto2j5/p ipdO+lzam7K6NOe1igTz7vdsEWVXO0DjIzWBo9zdXV08cdm7QPEZGmIwidOP5/lT9npa5W2psTSv FIbd0CxKOGA6VnGW3EmWxMS+1B1Cn1PpSVGKsdHO5RV9D//S/DCF4o9RlWSPfvUBZFbIBzyMdPxr Qkso4ZYrgW7yOzHy3IOE/wA+9f61RjzH8YcsF/wxHdSvGJpJV2ose77vTHvTIrb7X9nkDmGF4jLI wGeQMgD61ahZ3uTKEbaFZPLaLzIAUblcyLhz9az2mvbSWKS3AaRW6KdufYn0p+zTYXUdS1qLs8EV 0Ymdw2QiDJU4rDlvr6V4ppkk/wBHjMaByT5YznAz/L3o+rq5LrTP/9P8JIooxHbzrdDfPGGnHBIB HcfnTW1Fop3gsjgxKDLt4LjPNf63/VoH8URxVWDvErm7kf5vNfyjJuMbfdjOOcfWmC50tTK6xytI SS7qAUBHU4rSFCEPhQpYmrP4rEUiTajFGnkiPPzRFuCFGcEnt070+LUEa3ktrhRJ5YXylxhSQR83 4YBrWwJWViIDCmbGURhsY9iav3d7KjxLd3AnDSLEsiy+ZGuRxzn6U0m9EJ7H/9T8HL3T9sRkSVFm YfIvUfWsowSpZ3M8hjmu/LEYUnBUDoM1/r5GLW5/EMXZli3shbWpGwAOPNZUHBJ5JrIjtcvOiQpu nYF5GGCNvSmoIqUtdC6lumx4HBRdvzyBSB+B98UmoywQae0Wmo1sAgxvbzWd+5yR0J7VSSQOb2Rn LMNlpNNcNJcXCgTxhP3cQGABuz7Cujjg3OJFmjaFI9wjB+bNMXOz/9X8Fr7GoxCIxq4ij2IGGTwS c/59K5u6udTht4FMrTW9udhZiD5IB6fSv9f0rH8Qy+JlhbtracKqNFK8HmecQGXntikbUriZGhuZ PMXPU9FGfaiyvcz5lqUGNnAZHhcvJIuBEH3At6kdqr2NpNCsjXOH858pkfPGD2/WmYuXVkzix0uR rm7lUeQpkVFG/cR2x603WftTrbtBauv2hPO2MPLfaRkHB9a6EraGPM73P//W/nLt5JfIFxIzW7q/ 7uMnLHHr6VGrTGVNistxczkOScxhQOMflX+xB/C8JdTS1ERWUNpK7JJPcOYk2Hc3fJPpSWt5LGk0 ca8lSR2DH0zQbcytdF1Zotm2ZvLcrzkZYVQvdLEMayi5F2WHmKUbiMHtj1rBqzsUQAxSRSpP8yeX iJIziTeO3/1qrPajYAxaKWNBNGrPhj14PNKwH//X/nhOoP8A2TALu1iVz8sJB3S8cHn8K5pLZTMZ SGJc52sSdtf7ANJ7n8PmhJFG9vuhP75W27VXOPer4upbW3jiki5bGGA+U/UUWsRzrVGdLG86ySqQ ZAf+BD6VFbSoYGt5H87yjtO85eI9aCYblSJUluD5ZKyxnJPVFA75rp0uUMKzBmnAT51i4MuB27UD m7aH/9D+dm1tLCeLzZLSUTSTiVy1xkIAOVKc47dD2p1+VdCIx93jrwBX+wLTW5/C5zlzaFXQuSwk xgntj0/Kp1WW2QynLxEbUB+6afJItfAzKFxHLO8O14sD74Qlc44Aq9FZ272zkO5u+F+7tQgZ5HP6 VagupHkbOnafaxxbpyN5GWyc/Tisq5meMzRyupTcTEipggdgaytbQqHxH//R/mytpp5oWSQgyMNk KBAoRe27Hf3rR0zUr3R7C8tIPKEtw255pMPLGRnGCc4xzwPav9gD+Hr2dipe31xqVv8A6ZIXeGIR RybcM2CTz+JPNVLKK6jtLidIklUuAwZgXc49D3wP0oGXbeW0mTy2geOQc+YXHlqfQjFPksJGZZUm 2+Vk7R91uKAM2WEwgGdnCs+DIFJ257n2qcW00PlPMUcSjdGVkV8joMgHI+hoA//S/m7WPeeVB2dV 7GrjIDHEse0Bhgxg9K/2DUG0fw+Ma/mtBKZYUWJF+Uk9MVkXOopdz2wiVwzYaRXXCrz2Pej2bA17 m3FzHEqHY0f3mAzxUMAh06ORY4UmQJtG/wCUR57j/wCvUtW0YFu3uVh2vDbA+auGyACBWVdEXrhg rbbdiRsJCtnj5vUfWkB//9P+b8X09tdM621obV4lAtQhaI4HOQTnn/GpnnguoHYLHbsx2+XFHsjT 0CgdBX+wB/D+xlKhjbdIA3ZTjHFX47dZoXidQVbkMAC6e4Pas5O0rkSkrWRmR6erfu0aRmhl/eoM jf3yD+NI1reQSgx7omzmJiME+maPsGafKzoLUyCNVvXjE78t5QKoT7CmTNK48sgMVOFbuRWdjZNP Y//U/nFto5d4SMIm4/M0gwAahvbG9N4XmktZdPGBDNBKWkdh97Ixjr0Ir/XlJvY/h8jvYTBFG8u5 IWXemDww9aRYxdWiiGUqytlHU/NwaGmtxx3RpwNLdu0JhBdYsqWbA46k+9XNMmkjS4iuIf3UR8uL B3FgRzn86iTSWpuRS2N5KjTwELHH82xsgkd6ZFqc1pY3mHCtNF5aTKcm3bI5HrnBGPeuPE6UZej/ ACNIK9SHy/M//9X+Oz4hXL6t4jklu0lQxAOLiTPmXBI5J+h4rz4BZg6SOHeMkgdnHp9a+x44V+KM Z/19n/6UzycjssroL+5H8ireCIRBrWCSNlA3gNv3EcE4qnb3UzyqZwyxHC8L0+tfKSinsesdDbSI XCIAxUbtuQCAO+K6KExOoAcs78FSflrCUFfUDZmhjs7U5SGMxfJKysCeeenf8K4qYqzkjIyfkZhS UUjOaSP/1v4yLdcRSW9xmeOTjIO7HsatxRGMkRoERSNw6ZFZT3OctCImPdGdjA8E9KmsQroyGXdL GcF+gY1ArK4yGeeO7cB/LUMfOVhgP9Kdezi+nJfZgnhUXAUegFAx8VmIoSEYkdWNLCU3CMnOPXoa AP/X/j5BjVHLLnuuO9ZVxPLJIqRApk52+49a5zFOyZZ+4yyTYJxgA8AfhTAfMyF8s567OwNZzatY kgNsYEGSVYPujA/CrUE81q7StJIXZcFAOPyrMCrc3xWQyyOVQrlyOTHWpa3dtc2y7HXzSo8ssChf PfHWgD//0P4/LK3eBp97nezb5GY9PQe3/wBatCZ49ojK5kPKkDp9a83lV7gUVheGVhJOdkoGD2TP GAK6qG0eGBFWVWjPzbgw+b64qh2Mpik91+8ykQOC+OnqcVpDyQmyRy0YwoZvvn3oNUvdsJaCKXzB b3AOxioO4ZBGeKpxy6jfO0kfkK9vMYNwclJFBxgH1H9KCYxaep//0f5JgkyIzCMOT8rKenvUUcDQ HyXUBlbCgfMuT79K85uyuNqzsEV8IJZYQgaQHBJONuParK3aNE824bweA33RWAijJqF1LJBGmcqx aUKMKV7f59qvJdXaCRonDKAMwsBtPXkHt/8AWoA1luzJas0ewSkcqWwFPpWc88kqqqA7lPzKelA+ lj//0v5P9PkWOTciDf0PHC11Vt4gisPNc2EFzdXCC1SRkDsFxycdj7814U9zRTsrGbuiWRrlocJI 2SnZPXFZV/Gksca2KLAVvBcuEG0S+u7Hespq60LurXJo4I8SHzsSMB5qA7cj0pZDFCI9ihndtnlr 95RxyT0/XtWNugzSCSRhCAOflJY8LVZZoN7xeYMR/MT6EdqAP//T/lGa8EMm77q5w2eKezbpFl2k hjjeOdor5c6DQScx5ELEBl2sfYUFFkiWZjuLcrgYP5UAPtroyBlKiWVONzD5jULL567LpMBshkHK /nUSSUQJ1U26BoDkdNucnirqJG6h5d6yHGMHlR3qJdgP/9T+XHzWs96K2+IcBj/Fn2psN1NEWdFL I33jXx50E9jJe3d3c2pUvCVEkQAxjA5z9OfzrQG8M1sFCkLuDH2ppN7GsHpYZZT3DyzuW3SMwUKv 3ABxxWpHOCkhkwHA2FjTcWnYze5Tu757eO2LpGsMuVSQHAfHb0z7VRmDswaFiFBzkdqTTW4JXdj/ 1f5hY5pEZGlG6MMqZU5JLHHSp9SQq1qIpmMoJmdUO1Y0A5DH39PpXx53KCRJBmOJ7y5eFreVxFEy OPMGcdV69e9C3YNzDBbxLIm/bcNcHYD/ALvr19e1Ju1ggrIsNCLQvcITtchSuMqPoPxqjcGdlYxs +QwK7Rkjn0qZ7WJprqalnFPGqSSkLIecE9vf3qvdXkUdwzvuOF5VRncR6VkOKtKx/9b+aCyvBFM1 zFEsMgQYlUbXb0561NDc6sUjed/tOWJuJ5Ttk5zjAAxx/SvhztlFJNliKRoJN0bH94+4ljkZPWr6 3hmdlZ18z7mG6VMpcqCMrtoV0kSN4XkWBgN28H5h9KzFa4nukBWGeOPBd5pDvbtwMc9qtO1zNtN6 Ej2saXwvAoiEUZWKFAT8xI3Nyc9v1qXVLnzoYpGDDaAOOd2KpSXs9BW6H//X/m/tbzYsLKjZCjBI 6UmoW9tqDJ5sYIRlmXd03jv/ADr42DujaHwogu7eGaNeWKQOJDH0UlarwyKyyOrsmeRGwwExVDau rFyD/SodyMuQu0lRhXPrUiG7jjkgaFVhbhJUfLSeuR1FYytfQzcH0Ivtc0UbecvmLnam0bnwPWqF rIsk7vIpAZPMQSrsIHc8/wAqk0SsrH//0P5ybW1jRRcFsJOTgoARx1zVNtSK3DxQy7FXiQ5xivhz oIm1KJ1lim+RoWC72H3s9D+tDzNHbZAjJByGb5VA96AIBfW0872yfupI4RI7vGQrsegX8qtxo0iw kOyOpBbKY3fhSS0sB0IEUxSJgMBAGGOB61RvUt4bmGHz2mixwuMLEe+B/npQopKxEnbY/9H+ciSK 18pzHLI1yXyU42Mvt71RlS3syI2kUPIAybfnAJ7V8JGNm2aK7ixk8901iIpJRJOJCsKeXsRV6gk5 69uPSpvs1yLLzSiRSvHhkU5UHGOtOSvoQrp6DdOFxFaxec8aT7sfLwDg8VI3nRy/aLpIYWZ9oEbZ UY43VibgNQluDJapsky2wFORjNRKqwBl3YAPK9MUAf/S/m1iVZcTRuU3PtbIxu68VH5NtbXsrvbZ cpy4GCT1BNfn50rctyPaX0PklF+Q5y3aluJU/su4gtHEf7kqAgBGR0BH1FBvbocxod9dXCx20372 aMkPIU+QjPtx3rdubWIRLsgEbWw+QhdoGRjj0pSipuLl0Mqc3Td9yvan9/5eMAj5geR/nirlvpyL fyzLIwklQbSx/dKF4wD260csL3saRqan/9P+a9b+OeeVXDK8TmN1cFRx3HseuaebV0Kv1aT5lxyF FfA3jtY73LTVjncRwSRMQBnn/GpbO2CQlYpg6MvUtlm96fMuxHN5mVa3EulPdtcbtRLOTbpJhEhB 7ZHJHWrFtpl209xrEKW8bzLsS3STDY5z70/aSSsZ28zPtNPsrm/kbWoFvNMwSLV9oWKYbvmDexPQ +lDXVuu6KKMzQp+7Rh1TaeOfwqXJvccZW2P/1P5pvtfnxooLBgRuB5IHpWis6LsQKGf0zyK/PXBX udin3JbpIsAMSpdc7R2/GqqwSukpXJjiTeSeAoHf9RScdUaqd17o+OPMSvIFCg8MRzj3q2RbIQyp GzHGHGMNVlxk27Ni/aHjlk/dK8qgPEpIGRgce1VbmCSzKzeXBctOgnaNJN6xZPfHcY6UGh//1f5p I7hd8lwyqspP7wjA6dvwqU3TXMqTHLkJ5QTJ2EepHrXwF2tj05NqWhmMFtb4b5ZhbTLgw26hyGOe W445xwaSePU7i38kSKrq+UO4qu0NkZ/ADPFRHmUmS23oyaV4llj2I5fZtkRORkelX0ka4tYngi8v L/OWBDD0yD9KUotsQQC7eWQEJ9nVSrEfeJHTA9Kw5gGnjs4o3+2zzZUMmVPQAZ6du9Pkj2Kim9j/ 1v5mo9NuvOIuMIxO14wQwXHGBVzy2tYyqHBHOOpr889nHseuk0tSKJZpLiOdZljWBS1xC3JuskAY z0Iznj0NJf3B+0wFoibZ7dspt+YvxtP0xnIp8kF0Q7Fiy1Kb7NcBIPPWSMqkZYpkD1GOO9Z89v8A a7i3cIUkiO5VVud3p/n0qhtW0H29/ePLcw38O1oZfLiYLxtAwOfXir+nQ2s/228nvWhuQFWG0eEl Jgvcv2PoKBH/1/5lpL1jdSS26xl5IzD+8Py8ZHHoc0+zt/sQi1G/BQXTNATC2QcdznGccV+fvQ9g fNdSzReUsioom/dOOjAHjI+nFOuYIbO3aUl729lTEFuFH2eNj6nqf8TWDd3cjTnAvNK7R+fsZtqr AuNkJx0A9+KS4SRIncLJLLFhAn3WY5x+FIszH+0Xl08flPFGigz7XMgUewzz0P8AjWzYzQS2LXaA y28LeUz7T8pyQAfTp3quQuK91n//0P5noUab940LRKzcBjuU/Q+9b0Isr5Z4LtvLkjt8xkHZnHAH 0xn8q/N7dD2DnoNF065YpFcSPDu8t0eTbHx1Jx2pL7ULvSnhWzitjMzGNLnzf3oHoB6GrUG9wH3u tT/ZIzcJH50r5BAy2e9UImWWZBMgJA8wccr64q+VWsBcSO2k1aK+uYY/s8Ufll5pOUAzk46d/wBK qabPbSPOkUoETTN5Uz/L5xyTxUqFnqbc0Uj/0f5oru2ea2VY5Ps11IcB5IwyIikHPXv/AFp8aXeE DSpLCYxiRT97HFfnMkk7I+gIhDJFcRXlqoka3k2lUG4AkgEn3HWtHVLK5uILdwwbq+VYOoByMHB6 +x9KkDkkt76ykxExkAJkddpY4/Crq6jLDapcTnDzl1hgzmVtvqvUZ46jvTu0rGqgluQray6yHUi5 gEcInPkHBBHUE+la1s0dkY1lwd3Eak8sR2/Q0iJKzP/S/mwuP9JP7tlSIoTliFaMj2/Gseazhiie a3jSa5kj8tpGJx3+bg+tfm59FZct2Q21lAltHLeTOJvsx3rBgASY9D2z/OqmnTQ20Qe6uC7xgje4 3MRngUC0N0Su9s9zaeSrxsBtnJCDPfA57Hp7VRg1m6nuFSaNbeZSWZUbcoAYgFT6HH1pcqTLjHS4 9pIZ7oSpapdXVrIskcbnYsmTjl/bqRUdwlxa326JyJGRkuIrdgyS5HIGKpK7sjQ//9P+au0FreXK aW6JHLDD9qhjk/dJhSQAp6A5GMf7VFla3EwltpvLW4nm2wujZcDPC5PHNfnTjbY+mur2uUBbpZ6h dxzRpcRvGYZLeTkRNgqTx1/HjjvVTTzdTQzCy2JFaT4bdGYiEDYwFPOB0yK0i7NaFFl7l5Hme4ka KNGBSKIeZ55OMnHUdT+VTBEZyVHlRxrudj8q47k/lXVB9bGdWVlqWHi8qQsJiIpQPlX7v+9607SW kD3cJZ32SEQStHsypA4/mK6ab02IhJcx/9T+axJpUkkW6ZQQ3C4+UDOBmvpr4SWomtHZdQuopfN3 BIlBwCMdT0APQYzzXu+G1P8A4yvDer/I5+L6jWTVfl+aP1a/Ymsru5+L3hyGM3W6C/tjaT+Y0cUY 81VlcBeCw8xSSfWv7ZdA+3f8K8lgkaOdYND8iK4mOA+Y/nfP419J4vxk+LaafaNjXgW0eGZu3Vn8 Z/8AwUJK6/8AHbxHZTW97eXPhqbzrYPIJra6BL4dF7lMk7unFfi78btY1P8A4RPxMIJ9Ol0q1WOP yZZVF2bgs67F78ANlRwBnNf0xw5hZPgujF/C6Wv/AICfg2Y1Jriacl/z8f5n4va/eXtzHe2h+zzW +oPFdE/fntpE5OCfXcelcORHp771SR5shfkTA/MV/GGZyvmNWX95/mfv9KFsNFLsj//V/iR02ys5 VtJ4VnkmX94ZJYSgRvQHOOP6V0r/AOkywh7eKaSNionJxInHIH4gV59efvM3jFxWpqaKIokvluLQ z2zyGTylfylaQDaXPBzjFR2Fr4kv9UvbnyfM0zyUgdprgH7NGuduxOuT0ryKs9TWMWmmfQHwjsba 68QRadq96tjpbxs01zFG8l5uA+WNQOMHb1J4r6Jl8NA2i2Au5dUtBMcXN8cyuu4su71xwPwrza0+ hq4u1yC68ETXsFxeptZtOiFzIjuMYUgZQdyM5/CrOjateacFlu2hljYFFJt1ERX0I6dAORXF7Sz1 GozUtD//1v47brTVtY0uZiI4Q+/k5xjoaxbma6upM2N5FD9lZTKTGszqGPykoSDg4NfPnGtY2Ov8 JyWNxffv4mfyrjDmSYJ5wGNwUZ+tekeItIvIrPS72KJU0m/vZIrUQziS6jZAu0Oi/MEz/f8AY9DT R1x2RW0yBLNo5NWmJG8GQ252Oo3DH6cVt+LLqy1DToFMESi18yKK5CKCVkK7FYgZ4IPf+KumHxIu LsmeA6zY600CLeSQRxLIUg/s8NGs6g5ALcZbH86Z4kuomt9Pk0+e8ghs1JnsHRTGcrjLHr1+n413 UFqEZWP/1/4e9St5muY2VCwkcswC8sD0APt/WvrD4ETXkesaNZ2kUipZ7fsypCZgSZFDoDzz827H Udq+l4Rbp8TYJ/8ATyP5o8nPZ3ynEf4Jfkz9IbS9eSNgEhhmtbhHkLEuFzKoKg/3uSB71/eJ/wAE ydUn1H4N6OiSJBH4f0K2tUaIA/aSwUyFl9Swr+iPH2Knw7hZdv8AI+a8A5OUsyR45/wVf8NXupfD fW7uO5aBzGLpn2q2Y1j8wcnpllXOOy1/FBe/a9Wi2ajdz3DzXskLX11gTQL5jYdRjB4AGfSvT+jv Pm4brR7SX5M/K/FePseJqsl9r9Dj9Xnm0nVLWCW8FzpzR+TCQN9yoVjklM8LzxzWLaWRXULi4s5Z LmG6DZRx5bW55wRj1OPyr+k6S0ufkFWT51c//9D8FLXT71RHPII5UWQqxLhWT046+lTTad9sff8A aUjuFbCxMCUIPckdOlf6rxjZWP4Nv73KF5ssbT7M0cclzFc5MkTExlRnOOO55zVG31W4umkhSQmK FTJbW0mCiOB94+vAx+FW4tblptbGdaLp7Tte373JuXtyhFzCY0Lk46YGD/WraaUGkKSq1nbupk3S qULJ3Iz1pxT5WbKSZduLbS7eNIdPin8sfvI7tn8wOMdOnXPNS6FBLdJNLHPB50J3SxO372Ie3rUG lPc//9H8JY7SCISXt4uRsNm74w+2Qjjjnr09KTVNK0JLLTBpDzy3OmKx+1RlkKs38JB9BjPrX+rB /ElPaxqaC3mg219As13P/q5EOHLdFyMVnaikcEl9aTTZubSYpNBCQzIeu1uaCzKt7a9SW3WzJMN1 G08zx8JEFYYWTPc+nJrZs3jmiktJ44vtayEpI0Q8y2PQbSaTdtzoNe622+nCFn+1yRx4laVgZLhu n6/0qG0tokVQ6LHE6cxcYT2HbipUlcD/0vw1El5b3K2MUUXlNmVXA5IAPBP4VCL+4CSmdCJo5sKi ruBXPc1/qop9z+LZXS0I5r0JqEagyRyyL+7KIfJUnqP/ANdbVvp97psIu4mtr2e4BLQykLIVz02j hfbntS5lzXMSimoQvdNJd221ghELDkK3v7D2qeeCzu4FuruBftK5eIlQ8iYPVW69u3rWiaexny2m UrCSaNiocw724dWw4HYj3rOktrWW6aIAvKsnGpuP9KfGAM444xnjvTEnaZ//0/xLu7eUqbpla5Aj UK78mQDA5P51RFrqkaSTQ/6LGD5yW6HhAeRx9Oma/wBVnFM/iNT7j5pnlEU9rp8ZeZFtZ7ryQzpJ gZPToefp6em/p9/f6fDJbvN5MyQc2sCbLe5Vv+eg75561VraCcrsxbezvLycvAC/74hg42IvfA7e 1F1PDHK+m3EYjumbejrFyWT+En8aTVzRtLcqSX0dgHmu1LWcCAyzg/u7cltvz8H+nrmplvreC/nY QfavPXb8+4RAEYG0deOuc0xc0bXP/9T8Mle8tjcx3U5tYJj+4mtpcyY64Pp2rV0t4nlmNxLNcRxA yRedj5c8H+nFf6sH8Sxlckn1K0him2hknnHlws4BhjXvkHueKngkluTAPLhgtjarbkwKB54Xqzep P9KTv0NYNLcabOGK8W6tQDNACUDfLtwORn3x+tbWhanqcd0U+x200BzM6SDyozgfN8/UkDtnsaYp P3hlzq+oajrNyiHy7NEVba3b5YFIyWCAduf0qS91W3hGySzjiO0IQq/u8jqxU/yrKSdzSKtuf//V /FG+1PyJEcvHcOxAQWyjaxbpx0AqfSrS4Rv7XltoZp4y0cav86JuA5I7dq/1Wje2p/GkYK2pU/s2 7trsahK1pFbIryrEhL3ILY46dDjP4UyW7S81Gwt7wP8AZpd7B0QyAFB0OOmSQBniqJmramjGZ9Pk ijV444b1ytuJHDPH/ven49qs3LtayIFkMzYzKcfITmggwNTaWMw35QXCGblG+aJSoHBXOeK1dPNk kH2tHb7Y8ZDuOGjBGCqjtRtsB//W/Eaykju9SksxHdqIR5zOkRKH/ebGMfjV+9s45bmH9yJUAyXO MLgcda/1YP4qnvY3LW4srH920MJupvl+1P8AMAAMbVz0rMvSSLmX7QV8vmOPysCUkjgH9aCE7PQy Y41Ty7yUuIi/lSBBuAY9M46VswGGG98t4LW6SNAynf5qxk9CMcHgmgDRtzHanyo4HMMob7T5beXI ynsDjtx+VYkNnbwTSGaWP7NLDiNWkE0w5x835fWtqLtcq/u2P//X/GyLS4rC2Jh+zJasd6oigTEn 6dql064iWUPEjBreXJV0wk2Rjn1r/V2S90/jik73bKetX0JuZnuIW+0uVjthbQl0GSMZwDxg9/zq G6JtbePK75wgYxhhnkcD61Ci2tAb1uEenebD9puI/LmkCuoP34ePu/41otDC1sLe4VN7j7xHDkYp OLW5Kd9jDtYrY3bQXNtZwC3UtDLAuGYjjaceoqO40yOS5kvpow9gVKS24GEBHfb+tNQbJc7OyP/Q /G/T4UkspBpwbyAm7yguGQe49qzU0WIyxSyyCU53ymQcrg9B+Vf6tKDuz+M52cYI2ZTFewrYeVFG qfclVQGNYkb2ztbWaeVN5UrtJJJ/rEAB6emSK2tbQ5a/8ZI0Y7WIPIyJGIyp2nGRn2qnBAFv9kzC U7MMhHK57kf561pGN0bWL82iz2kctxHNBdx7Q0cMWIZbUs3C8/eAHUjOKxoknju45r4mOXa5Y53B yRxk98/1ojFp6iSS2P/R/GO+1bUo7GISJFGEHlwGOLdwTnGe/Xv0zVWwVozNqFyVHmqF8xjxx/kV /rLKN9j+MOV2uRapNfvf2ihU+yNGGYhT+89G3VShmZZNsYaVDKZDzlR7CoUG0Z8ivc3LVZ54dRmu 4lRIR5cELHcz7uA209h/hWFukZfLaP8AcR8pk8se9NwstBpWloKGmiaPbBmOYgbwM4OeldY2mWoi E8R2yeSFcYwCR/n9afs9Cj//0vxJUT5f+0JUXyrgpZqjEjyzzknsfb3rXtFiv3mW3nW2dIhtZkHz kEDAH+ehr/WWC0ufxeasOmy2omm82OWYpiIOgPlH1rmdails7OVbk7hJiSNkj2yoT0OfT/GrAlsr s3Vmsa8P5YTzF+8uB/8AWpmspe/2ZItuGmlyF2sSSn+1j2oJkrovWEl1aWNrZn7IGlZTczSxgSNg HgN25x+VYbxK2oOJjumExWER4dIueeRQYn//0/xQuXkhvLaKOYRoFJLBiHZu2KnkR0+cyGVpCXlJ 5JOe9f60H8TPYjmuXhiwrqqjkZ9ewpmlfbZt9zfRW4cSFYjs5KDoSD0qGveVjGO6JNQtkZ8xvChH RVbDsTzwPwqpo9pcXk09k6M4cHEmNyjHWkr8zRuWLizu7ZFtI0gJZiIWChGY56M3tVK3u9Qs7tYL mFWjhfZOiEYfseaqGwH/1PxQWzh02/heUb0utwUcNtDKevtisvUreISSrY2Iht4lwXVSEbPXHYc1 /rUuW2p/EDVmy1aRWslvAMCMoMEE9/artgtjbXEj3J35JGyPHyeh5qTSG2hsXa6dqlpLahi4Efyl v4eK5lYJNNSJ43Vgkm1lDAse/Trj/GtOVcpZY85bp2Mu1ABkIeSRVOO2ginkMYOHOSOxpQV2VzWS SP/V/EBLTZfqRGpjYFsE8g1o3F1sQxyNt9h1Nf64H8XOSRRurkT2phaHKkYdsfMwx/n86oWkvyLb MrRQq3lwbiPmHt7dvwq4K7Jc1bQual4W1myS3uZre4t9OvEaezmYfupsdQD7ZHFY9pId7wogd4zt fdxVqKTuiHPR3Jpr1re7EMkIEZXIIGcE1lXt3GJJ18vcNgVQBnJbjoPrVpXdjDnZ/9b8HoNIgt7R 5YATKFDMFcurYHQDt1PSs+QwvHNcKs0EyDZLuQgnFf6+ezZ/D5o6MIbiwIlCmSQ7lLrh1xxj8ajZ zbXQSC3RoWGJZBgYIxjIqlFIV1exUZl+1Orz+Wsi4RN2IhU0otwE2CJ48YLxsCxI4PAqeRXNVOyR Ygs479lhR/KRhjdIdqD0pkOlQxJcQyiK+3kpIHO9IMHqPerSsrIJvSx//9f8H0tpp5PM8uVLa2AQ s4+R/TFI4S6W5S38oOvLKx2qMDJ578V/sAfw9fWxUW+e3j2SRmWPpvQZA9s1UtZFdzuQQLvyqZy8 gPfp0oJc0nYmutUkt0m2pHcwOfLVRtBGO9V3jS9jjJjI3dVzjPpQS5voY76c/nqm4hA2AnStNnmt FyiJkDaxY4IAoFzyP//Q/ADTLyK5vWkupDbQMDB5qDcUHU/Ln1FX7z7HYOY5sXFhMfkwAWk9ytf7 AWvsfwxKV2YdxKoQz3A3BjtjwdmwD7ox9KltBbm2nlkePBXAON7R9e3vTSbdhXRzyQxwyG4tYdsk nzSJncue5FPikYyP9qkdQ3IA/g9q2UUtjnnLqyBbW0afd9pkeQtlYJlBhYHvntXT6xd2Ulv9nhB/ tOO3Vwm84K8gAfkaZlzO9z//0f52F028ljd2j3IFDAIcuT34FSSbmi8mCLymRQjlxmQdM4r/AGJS ufwlB2diO2s4r2H7JIB9piuAiyOdrMTjb7d/1rYOlmyCrOVLq+zJIIUg4pGo0Wwlv0i2xIZFKmWZ gIsYJ/oaZptmkszwTSxRqdxBlkEceACf1osXGVtGVTDpyw/6HBucTsXkOAvPTH6/hSXUCz2ckExE byLhJhw+PSplG5rdH//S/nKito7pI4JLiRGtlAhAGS+3jGfoKkS0mMiEE7VbHK8t/nmv9g5Rsj+G 3NWsi+N9oJHSSPLsB5bRg496pm+HlNDcRM+5tqlVyyk8cU4wTVzMWxtZIjcFYZCWTe8hQsFA4yfT /wCvVeLTLd5XkM7sLgbo/LYYLZ5J/WhQ7hsWV0SbT3jumdDFKTuDcFx6Af56U9r1EuTaWyRLC4yc Jyn0pqCW4ep//9P+dq1LM9xsgkIi6swwrY5pkk1vMki7hHJt3LEeCcV/sO0m7n8LXtoYs8hmhaN1 LKvClTgrWpZ26/2daiZkIilaOOJH3Ns65I7Uxj5tF2Qm4tkL72G5WG7Z7/59a0ItMa3MbmAo6LmR n7fhQBWv7ZYrd7h87VcbkzgsCcViXQjuZPPUKqBANg+8cf1rOaSQLQ//1P5wreONVEihtvUnpior u2R42mUlNzYOf4q/2AP4YTs7iqI3hCRqN6YLeYPlb1qxa2qIDtlUq2Syj+DrQOMmmUVs4rWN4ITN LuYvJJM245JzgelTQz+VGRKrsCdq44A7daC+dW0LsV7A6yxlVKH5Mkcg1kTK0bEgZVfmAHJx7VcE m9SHJtWP/9X+bxB+6gaKRm8x9zbl8soPQ/StCXTrmVftsG1Y4ztdVb5j7gV/sQfwwpNbGPcs0rOs wzGibQp/i/Cs3DqJJ4fLR48KsbAlvw4xQXGf8xuabdMVVJud3B4qzqCWqwtG+DvODHgkODwc0nFP cfOrDxIfLit7a3CRKgRTySQPeogbWAXMFzFNEHgLLKgxGx9Mg5BrFqzsZttu5//W/myKrc7THm3E Y2LvO7cBwDmtG0t3ZhCIiXjG4uB8hB//AFV/sAfww23uKIUuJWgLDJbYMdN2cfzp8VrfaRNPbX8b h94hfYp2kMw2H6cg1Lim7syc1siZreSByY2GJTknptqv9rRHQ3ieasJIUr9/Hpn8KpK2iFGdtGV7 T7Rqtx5EMYMiMZAQcAr6VaiaWKVw4CshIZW6jH/6qDaMkmf/1/5zLiEzxhiWiQvwyjFUWxJOtjEy jBxG7MFDn8fxr/YA/hznV7GhLp91Fp4t5XM8ZfpjIQdgD7evvVC1ieBJIEXbniPI61MldGi3uNeW WNkdRhkOWIPBxVqW6u9QnY2yJAZD5jxwjbGD+ZrG3Q2ui3Hq91YRm1uMTNOxilkiGXQNxgfXuaqX +nRjTJ2sSwSNN6I77ZBgZ47muPEr93O/Zm1L+JE//9D+NvxrFcT+JrjbNI6GciQSuFWAdiB785+l YNzBbQIEiZGfq79C3/1q+343V+Jsal/z9n/6Uzxcjf8AwmYf/DH8kc7ePcRXKiMqYuN3l/MBmnFZ JYfMRdq5x6Zx3r5C1tD1ua0mQIfs13+8cncgwB0+grY+2CSIhVeKZOFw/ElYy+Jlc6tcaHvJFkyz HIBIZu446VYtp90AjuI/mR8R92X8akybvuf/0f4xrbzG+WFfnLZUAcHHqK0p4Lx54miASMxn7QpH JIGeOeKzmjmbSJ/JuEgEzpIInOxCyYUkUxHaEKrbQ4OSg4AzWZjfW7M7UroRtHJKSUVwH2DP61oW McJaSRWySNyq3GM0G61NCVysbEMApGDg5zWdEyyOMHDB8beh+tTLSLA//9L+Oq4JjUsrkhByoGTV QXgtZw1wuXdARle3auS/u3Ocs+ck7I8mAvJUdMj6U9ZoY2klSPnbg4HOBWQFZL1Z5Y2KnarYIbkg VvGAXiuYQPJ24jLkK/5UAJa+GrwpLNJas9ts/wBfsJjU9s1mNaIrFJIcSRHKsF5XGeRQB//T/j7h uAOsfmlupZsHj1qxcTSOgMaBZAu0kcAj2rzwKjG5e0KxmKORWypcZ3H0PfFX7OeeJtlxxKwwyx/6 oD2zQNPlLTPFIVK/KInw/HD8mnhw0v7xQwzkJ0Vh70G0XdXIhLbQalbsIo7ZJDt8iEna+epOSea6 C6NvDIFgCmHhiQPLYk8nIoGf/9T+TI3cfyhCq5GCp65rMnmJBSOTbOrZAIyDXnNXVht3dyvHA8Us ryIrNOOXUVRuDl2hGTGBjavXmsBGhHJ9lWDdCQoUJnqcDgZFXXk8xPkwgkGcdCR9KAEikSJCCPoc /rVmC9iRCVjV5HJVAx2qW7c0Af/V/kvWZoFZsoCTudRj5fYU+K8YfvRyo+5j71eJPYCy+otd2xiC BSPvHPT2qjDeAK6rIQyjaQOSOtZFczSsOM2FeQLvk2hTIOCcdAans7ua6zAYyXRdyvs554xu/Cix cZK1ma7rewRxwzKyufnEb5XII4ODWabeVgJUZAd5LKOQ1ZT3KTTP/9b+UmKa2kQG5h5HXK+lNikM jSfZ4vlJAPoozjivlzoHlZbbe8Uhky3K7eKtxSmVo8/IhXkDufSgCeKY28hIjRI2ODIR1PoKS8m3 K5yUBGFZRilJXVgMqyEi+Z5rucfMDk7QBW4bhmUSKNzbfKCjofUmlb3rgf/X/lgmIkj3I/I4YMNu 0/jU+nymJJI3mSYk52hRlRnoP0r5ZxT3Og14CX3tFlCBhmPykVHcPIZI0yA2MNIe4ppJaICaJlBV IxtePliBjPvQJw0qwEeckj7ZOw5oA0vIj8pvkha1UkeU7g7SOnHt/SsS8vHEJW3gH3gHKc4HTiom roadnc//0P5coFnkMQcEASBwQcZwcj+VdGIBcofM5lkOAxPT8a+QSbO+Luii8cSWZWUw+ZHIwlhX 51ZR3AxjtVa3jGoiK5KOIA4eHKmJgR0ODg/nWc03YtJNM1bq9zJHaxBQQ4E27+EY7e9akaqsZ2IC xGOOtKeyISsU5GYSLG4P7xsM5GAuO5P6VBcsqT/Zmht5ImTIuS+ZISD0AHHPrntWZk3710f/0f5l 7OdGnjtgocsdiu2Ni9B1/GusuYEsbbZcFD5hxtVg36D+tfDnTdmG5Z1QwqIwBhARgZ7ZFMW2LjfI oNwgOGPy5Pp/KpkrrQRIR5b7CWZ2UFiXJUcdKfbzRRTqBGWduBtXIPH/ANanbSwGgHEsu4gRlAcZ HP0rPvJ3WFyArqpxGvZTVqNqaIlJrRH/0v5r9Lku70LGIiI0UlmYbCuMnj1p17dGxjibaZjLIU+U /wCrA6k/0r42CsjaPw6jbS/QxPK+7bJwFKbahmdeJIwgiJ2sC3z/AJU3FPcovW87xwMkKxhAMoSO lFtrCXjKUVQpypIUoo28dD9KzlGyAebdZGeRpSiZ2pgZGc1Uu45A8EbIrvECqynrg9RUDWjP/9P+ bC2h1AZWGSU28bedLHjeoA6n2pXdZGaRIwxJGeME/WvhzoHFopTHLNboI4gGcbRnjnmo7tXnZbuy GbUptNs3Kk5+8G9qAJbaZJ4j9tMMV0iD93kBuOn6VMsssgQgJwcNsPQUAW4b5VkWBztkdtsZzgvx /TFUru5jgmlSS2E67OHZiNpOOVwetBlN3dj/1P5qLeY3HJDxkEldxwy/WmrLK1z5KBpGlBSOXy96 QsBwWPTHp9K+HLjLlVjTsZ7hfsNvqtxG8sMK209xHbCNHZV5baOxOaRdZjuJPIjUlI5WjMhGM4OO B9R1qZOxL3M/UZPMt7i23vFnEiXEXM0ZXJAHtnGaoWzX+ojyHkLmGMKZSMeZ7kfhWJsndXEt4v7M lVYJ3kflpjJ95DnjHtTo9Rub4rHJGBc52lo1IR8cZI9aBn//1f5sQnlxFpHGyFgzc4Ckc81d/tGN ZWlurZZBIViwqfM3QZGOn1r8/OlaMwFVba7ZAxC3M7MuemDk9PYVflWzjt7gw3X+kINoTh0yc8tz xQbXVrj/AA/ph022maaRbuW+uDKkhQIY8/wLzgDJq1HfXdzcXWlTsGIQS2uU2gAEjbu6f/roMBJr SWFGVPLFxt4Vj8o470HVvJtmgEMBkjYeZMVJfIHOOaAP/9b+Z6G7bzriSaNJYJwMtJH88eMfd9M1 oXus2w04/Zo5JJpStuINpinwSMsmfQf/AK6/PzpbbK88trbmGOUSt9owOm8qcD73pzV63R0tZooQ EkxiEvyEz7UCJbWzNvaFZpftM5HzTSqFLHvwO1ZFnLfpcLI0ptY2kMfkuAQfmIz9COfpSur2DyL7 6feTyhTcZtEzJ5KnEbtjrn8KrOEsongihiLzSbn4wR6n/PpTFyq1j//X/mvjjiFuDsXzFGMsMGo4 bdZImlQgSFsAhvmGP896/PzotbQLzUorVY45Fd5AAp+X3xVaDxHHLNLZx2jxeR964YHbOD269v8A Gg0p9TUW7kit43nhN0twziNlTy1iGSRn6DArBNvP9pklikkZDgspJ8uP6Cqjy9TVaM1fJkK5OfOI AJHUjt/n3qSaRLC4sLJ1maS9DRlVU7FXGTl+g4FOMU1cuUrOyP/Q/mhmS0tPMjVVj3MW2s2S3HNR WN04WO6igE1uHIx1V8da+Asz0BJYzHfh44jIk7BplVtsgA4P6DFRzSS2t3O8cLrYlR5ZkkMk+ec7 uAPpikBPHL9nQzR7nkkXgIMuAfT86txtIoVY8nPLJjkUANj1GVJ5LaOANEU3PID8yHOKtW8TXE32 hVKPHz5mMH8DQaQ3sf/R/munuGWYtGhJX5Wzxn1IqRRaDKwXIuJwoe4DD/Uludv4f0r8/PYIITar cO7RBmYBEccEYOaS51OVpnhMaIYQBA69RgEUF8+lkZNqxtY93nu+JHkl3j5huJOM+g7VrPf6fJNa Q29tumWDz2vQpAfcR8menp09KCCW4VYn8yVY2WYbRG/3VY9CT+X5VkSXqPdrbwAjd+7CkfI7Ac4P +elAPRH/0v5mJtOSa3lDgxyOpz5Zwyk55B9e9VkjuLr7PaXL3bwWFoxiZ4zmXPbIxzkAkda/Pz1X NWuNt7Ke4khiuSLC3UkQPuGJTzjfnp2GK1NqwQGOMxz3ETFVG/KE55weaVkZxdmZ2y6m1SAyRgQu 2XMY+cN2P0Fa+0xyXMDSZYfMGLBgwrJr3tTcoWVzdWlzPJbGF0mj8maJ0BJUnkg/l+VaVxBNqVqk FleG0EEwudRtI0DLMnQb/QEnrWtgP//T/mmu4WeKCHzwY4sARAgg7CCP1ApsUsWpuHcxxR2hMMka xYa4K8YJ+o5r8/sewV7iQSeYsEcdqo+QJF8oH4Z9qpXSLA9rI5FwWOx3T76Y65B/nQAlyVluI/Li V41T5hgmX249Ov6VejCSRm6JAbGwR7drjHtQBWe5UyxRC3S6ifIlEmR5ZwcY/Gp0jt/ttrZR28e8 r5pkZdqQKDge3+GKB9D/1P5yh/ZOoWjJOTBJDIXa8RsgoqklCvTkgc+9c3am0u1h+w3Hl20TP58Q QDkZAH8j+NfnU1Z3PfWxd07xP/ZB1A2MNjcwMDaXEV5aiVC54yCecjPUVhf2xcWsH2ezmlvGlnae aKRStvDlvuBvUA9P1qLDNa1mmfzSY9gkiwZAMDr0qhJp6z3FvMIl8+LKBlHDgnPPag2Ukx98bzSU NzIQltjySLdSZ3LEcEDkjmqzi2njQOHBRg8TSZLK+Dn+Z/Ck3ZXIm7vQ/9X+aJbnTvIFlPHcy6jd N5UEIhLQzLg7iWH8qq2dvPFi2WMKgYxxxpy2B7V+bLa59E0uW5LLEke6I5cXEbQk4yU3cEg9j71V l04WFgot9pEaYDv85IX1ApKWtjJ/GkZ895ZvZTPYNdIwQMDMNxklwMhFP8PsfeseXVJX8u6+xy2z eXsePYxbK8E7eoBIzjtmjmjexUZPm9nrf5mnp8GoR3ltqU6lbOQbntd3lynjgHjjP5iti3kuFvTP tQIh3pjkjPbNXGcY7l8s3of/1v5tJr61BjcQKkuwl5wvOKyrib5BIjtETyjN8rHNfnPtY3PpIRd9 S/b2rvHDcylFV+GlZhuGPUVY1C2srK2nNrc+fJdnyWYpseJSM5H45/zinGrFuzOuMVbQ51RBDDED KFuZXMabyCwCj7x9B9a1rqMS6awjkC7oiJ5EAYKB6j8O9d8Jwtuc9aGtjKhvBcSwI6OiWwABxtSc AY5/+tXQuC0TSWm1WK5UkYUHtmumi4N7mdOGjZ//1/5uNPN28cEU6W11qEs22WRAdmP4eD6cV9S/ BOylkkaOO3igf7V/pH2h9tuMYBk3f3cHOOvtX1HhnHm4ooVIu9r/AOX6nHxolHJ5xl1a/wAz9h/+ CfulLL8bLVry42z2s8MNpFEpa1uY3cF1PqTtXke1f2PX6/Y/htdWELMsFvpRtYXBAd025bn0zkV6 nixiYYjjOMIbrlT+7/gnq8G4f2fCKk3ufxOft96xJpvxy8cJJdxFDNJFBYEiKQkOqiJH/vDYWGe2 a/Gj9pCYSeB5bW1stKtvMtpbu5ubeVJrq5lkPSQqeCgBODzznvX9XZRVWB4DpV6uypK/l7p/P2Kn SlxTLDxd5Of6n5C6pYiyN1dBUWBvkjlMhLkqBztrBsZppBtIjdA5kVzw5PAOPyr+Gsf72LqSjtd/ mf0NCk/YRu+i/I//0P4odPvJrWwkkWL7RvkzE4GVhAPOV71Zt7l7PU47e4UfaJ4lu44/ZsENj3Br y66ak9DtdN8qO4WzvCkkiCIuRuEaN8oBGcE+tQR3ctncW3+sUzbopNnIHy55FeRWTCPMnZnvHwlk u2GqILa1u4TPHc28kxC38DEMJEjHBZSEUhecc165p3imdYbu0ubG9nju53SzLwvazwDkBmBHAGOh 9BXl1ou9glN20RJYrqs08nkXEm+O3ZSk8hjhlXGX9iQB0HXpXRGS2OmpbXKtKkYJIiQCTLHkZ7fy rjlTn2IjiJPS2v8AXmf/0f42rXVbVWvRqMEs9qkBLGeTO4jIComck9D0rkLa6W8up7mwt/sqeQv2 i6eI7FRGIXfnjI3Yr5u75zlirRR2lrFGw04WlvDqAe5S4l3SeSVHVmB+mcV7ve3ekWzWTeHpb57W 4m8h/tEBikDMu12i55A6ZHHHWri7nQ3yo5rVtJdtUtp5EO1QEeJpmAkGeGdfXqMGr2uXtn/YN34f a2huZrmD/RJ4Q0NxZ8jcOnzcZGD65BrqWjQ1JWueT6e17fxS6fq13eG3jc7LTcY4rUdN8fQgnrn2 rM8T6TDaxwPZ3KyJd/uJIzJuuGCYx5nt9e9ehh9zG+tz/9L+JqczafqcGj30cUN3JMjxEyCRjG2C G4zxg5r6d+COo3+n+KoJba4lgWzcbYoVVo7wB4y45GRkZx0r3uHJ8nEWDa/5+Q/9KR4OcqTyvEf4 X+TP0I021udH1Ca4DtcQ3c63QEih5FSR1cKF7FQT17iv7jP+CSWpW978DdK1CG9+2HWHmfVrq5xC 1u8BKQxKn90hCRgDJIr+mfHOm5cJ0ppdv6/A+c8A3y4nMKfl/X5nZ/8ABTvSrjVfg9qMjxr+/wBP uVs5FB8uPy4SxDqOTuCsB9K/hO1V7uLzXmgEIEreRFG+5GBOVYDqBg429q0+jhrw/iI9pL/24/Mf GBShxRJd0c7dWSmH7XPDE91Iu1Wk+/H3x/8AW9qqrbHT7eOaJS1zPE3m+VKHhjGRtA4GD9efpX9N wVon5BUXvJn/0/wdiSe2tFuda+S2dmY7ZAroce/4Vk28kaXc01veu8aygo0mFV1OPlUelf6srRn8 HWV7k2qTxWcV7qtzIpikVFCqRvHAHyj16/nUMWmTI63ttIkUU0fnWvn/ACtIOeDjjOQRinKV1YpR b2HxwXU9pLZalMIbhrnzjEIQmAeBh8Z6ZrpLrVbeO7s7drcalNbbFW3uwzwiLoPMAIO32FJNpWNI wsX1NpJAxNstpJJLlLSFNsKpzlVByQOgHXj9aNjpMNjLczyxmCKcblJ4LdehpG8E73P/1Pwldria W4WBs27gLFE4GI8HqT1P0qN7q5gK200cEathN8YwCf7xr/Vg/iOCJUu4EvrUwSESRL+8GQOVBOQf f0qtqU63F8+pLDFF9tbbIyR+X57p8pJz1PTmg0Llm94rQmcJFC8gVGVeTnj5hW1c2UUEjPM2H3kb 0534pOy3N7aWKNxYQ3Cb7cPPbpKu8OdrAsfTPbBPHpVie1vCqpGMrGN0bY2K49Caz93mfYZ//9X8 Rnh3R2sxDxzqCixr88ZJHOTj24+tZM0c00tzaljDIAMlUyw59Pwr/VA/i2SurEk1nNaTWFyVE7Ry ZKyJkeoZhXUWVxaxPcXVxbtfXUsJjjskdYFXIOGHuOw6UGTi1uVp7awS3CPGsRPyAt/rAf8Ae61j Lss3gt03NGiCBA3OcDABpx3QrDYbVILm4luldVOBkghfqP8A61JBaWst6IYXJUNlPLOc8ZxVKBjK Luf/1vxke4eS0urS1QytbQl5U2jcEUjnP4iqGmLMoilh87btzIs6fIwP8Iz6Y/Cv9V7NWP4fM94Z Uu4o7aYxyTzt+6GDD3Oc/wAq3JZoobCSW7LpLGfKedlyQexPtTHbWxjaXrs0SfOqeWXISUEAN6DH 9afqn2iGS21dbaZ7sSKYFgXe5JYAOw9B1JPbNBbg76DoUktppprlYp49SObmAN+4lYg/eX/61aS3 OnXdjqUzWs0V39maG3Xo428Ag/hxQSoNo//X/FPT5NDS2t5dUt0mjmhUKl3lV3FeCxyCCOPxrWv7 OGARWdnFB5l1GHj8t1K7W5znNf6sH8SxjY4/U7CaCS236cZxE53TAGSInIyCQcelRao0kUkZ0qSa OS0iW4aD7iof7qqT8wPpQbRh/MaFhqMuotGi2xjkNuWlkY4EjA9Txx/9arsdyzKYJXKyKSFBOAB3 /rQVyK9zQtgHumaCOPyYIw0ZZwznAwSffPapL2S1aVLi4TCqNsiqud+Pb86zm2tDWMbn/9D8XJdR 0WaeJdLsBHdRJhrhlDRyYHG2MjAI5z61T2Q/ZW/f3S3LXJXbE5WEKAPvAf49q/1Wi7rU/jc7IeFN W/4R2bV7nS7lredAsGqzRyfY4kU9FkUFTng965i0sJYrhIZAP3QDK6tuAzz/AJHvShUp1L+zknZ2 dnezXR+fkTUvFJNbmnfW/wBpKr5atH/e/jUj/PasO7s7hlKwyssyNkRM2EZR/e7/AJVZiN8yCezR DZy209unmTzE77aRhkEKcd6h3Rf2ZcNbQlb65Pyl8xLEOm4Y7n3oH0sf/9H8YfD97c6ZL9pW3Jt5 4jazNc52PwNx6c4Jp019HaLHHdFHe8mISRYyBGozgEjgde/pX+rB/FMviZMDFK1vayxR/u2Jjbby c+prN1e2vprm0sbcOoJ82WUJmJFzwD/SgmxavpY9OiFrNal/NQAxKf8AXHGM1hwuli8Un2Z7WF/3 UcTMZHPGcZPNAG9qV0DDCsUe+Vx5XUhcd+K5aRS19ax26W9sEdEuGkDfvFzz369fatKb3Ktokf/S /HuaUL5e+1WS3RQsbRAkMR/FTY5WnglCW626qS29l+ZgOlf6uNtpo/jZKyshkOn3Bsm1CxmjmMMm 67aeQKyY/ug9fYCsi6tZr67F3OmyQT+dFExKo5xkMPbk4HtUJuOxE30LcsF5sYSTKzxZkwh4PBwt Z73bNFaN5TCbaTciRgQvPAFPmexF2lYrpFaTTp9mikLq2ZIVBCZPPJ+tS6muoxad5csP2d2I8yMP hgCehP5VrF3Qj//T/GPTLqC3i8jd5M3l58vfuZhUCW15cyPKsj/Zg/zNg4X29q/1gP4ztdJEV7+6 mRbWeR1XHnqy7fLHcg96bJaxXEQVVljl5cNGMl+PWmznrRtUuX0uZ00uwt40UvZoY2kddrPhifm9 etSNc5iF47iSbJacYzIR3bJ6960g9LFp+7cxNX1S6tri3bS5bq40yZjvkuIUidHwNygc5UZ4NOj+ 03FvD9odpHLFx5g25XPb1pRcr6jP/9T8XL2ZpZbG1ckRb97xKOXVcA4P4itgWlupJChrZvm8lzvR R6Gv9Z3tofxkpJRsVZ57eVYraBZc2oKFmx5W09FXjgCs/T4tNs5Zk+0ATyMZFtxlv++fpQk0tSC/ DKswljmeQyMzKHCbSM9N3+NZ8VlPGWW4IkCMdjbdoI7ZpgQ2AvbqWWwKwoyOZVlDFdqg+h68V0U8 MsyfZ4ZRHEi/vZFOHc+g/wA9qBpXdj//1fxoNvp6yxpNGs/lRlsseCxUgfzqlFceVNA0lmoCvhzb 4GFz2yPpX+tB/GDTW5ej+3Xcl3LBDKghh8x0z1UHGT+n0qGeBbxGkUOZTEImhkO4DGRxQIpXjtpV gGjgSOSTEbbF4BHf8cVHpeoy35fz0CFQEIXgN9RQYtvUmuI5C7RyjKyrmPb0TtjNVFsfsjCdGw4B Z/MYbQOtBlN2Vj//1vxb8m2vDby3AUSk7AgyAOwNUtSLwGQW0UqbcRKzg+W5r/Wg/iBybVmXPsy3 NtbuEjIhUO5PSWQEHAz6VcW5W4MbyReQo+V4V4HHFAjIlszLKbp0CrbyHy5EfJkX09qsRa1axrs0 1XErfK0iDaYT3PPWgpSaZxlxDqMWpCeOaW4jkbcyvIWbPrW+YncJOkm+SUfvIyDlCPX/AOtQaOVl c//X/DuTU5La5C3cavAF27ud0ZHeuljuba+s5YrZwQ0Y3DpkcHNf60H8QN3dzJk04GNQoZAh5kHG Kxbu3L3fkwvJtjQNI4zt545P9KC6b6G7Z27IgVH2b1Cv8xzim2FvpFtcX4EkgupXHPlsUfrk5P8A T3qlezHKVtjMuSbe5zAu+MuUZ24YD/OKmWUttKEqikfPt4JGOKdPcfMrXP/Q/D6e9je7jnSBPNt4 ygfOMlsdvTgfkKZeyPcQtciNIyg3M7Hjjkj8ea/1wP4nuluWY2mv7GS9tUhhhQMm53zuIHIA71hu rzIiykoYW3rOBypHfFawWlyeeJpR6hqt3fwW1xql3daVBGqQxSHCIBnonQHtVaeSMX1xPaL5aORG R18zbxu/HHatEruyIc7qwk7xSv5WYxNIACWPJHtWULWS0upWTdLHGplPmAdAORWqik7ox50f/9H8 LNIvTeaRFMLXyZpJmyFOcLuwvH4frTtRWNYZJLy4IaVdoQKCWI9fy6+1f7AH8N8/kQaPHHEDLIyS QAbRDjDNz1z2/wDr1a8mK5EoQAKcgqp5TOaCVJp3Mkxx29xElxDHPGp2fMfmk+prUl0/R4TPLZQJ HPdhSwDkrGB/dFBsUJrSTGxLi1OIw2I5gWAPqB39qiSZLdDHaxfO3NxN/Ax6ZNAH/9L8J7uPy40s Z7iRzd24lkCHZHGeoXg9wR+tYjWqQXEMUF4Jt3zTRKpJTBIwT747V/sAfw/ob93C1vphWOFOSJto GGfj/wDXWJHePciRIIFkmjjILmPJix1/z7VcI31Zg3d3ObdriSYQLDiNVLbidu49z7jArSXzLYW5 c7i43IqMDjkjJHbp3rSyER3DMHMzAkMNo28HNXl05JbIyys8Rj4EZOWkB75p2tsZufY//9P+fWO2 jhBDqfmP3cYH1qu08aXtsDGzRRt+94z244r/AGISS2P4Ocl1Zi3N4Xklt5gzQhiysDjYD0H4CrXn W0ECQWkpljVeZZFIkk453UWuwUlbRkENzM5wq7GY7Rxwe1aj2xW1mNxAY7pE3xoSAZh1XH1p8r7G UndmZiSe1fMPkXMa7ufmCexIp0d4C8ElwgkdVEZCADpwMUNNaMk//9T+e+S5ubG4Eaqwym5ty4QA jjnvWaiyPcHBdy7k7gM/Xiv9jYp8tj+DYO6L93HpX2JrnyrwXcMgJUSBhOVOOBgEfnWZLqs00ixE MYx/CfvfWs2rOxfM0rCzLK7RSqZHaE/J1wtS/ZhdCPz12vG29WDexBFI2TurmdNGtq8scTlvmMmC eF+n5UyG4eZgRljHwQfSgd7H/9X+diO3DzQyITEVbdnpzVuO7nS8EMgQpuw7FcKeO3vX+w7V1Y/h ffYoXMhe8ljZTt6xODx+VUoyNzSTuFYkxwg8Bm9fw600raIDoLK9u4S0IR386FopJVGVZeMg/kPy rKuHhtbiCSTZb2u8qWXghj90Ae5oAbqN6zxRgvvGCY48/MB3qHTH2zG7dF/cxllWRQQw6fifSmot gf/W/nb/ALSkvhILSJkiUZkAGC1V/wCzL6/cMlvDGDEBuB2yn2IGa/2KkrOyP4XEbT7u23DysW8a 7JJH+UyEc/L60y3RJMImUUtj6VbgraEOVtDpBqkFhGYJonfKAROvyru9T7VSv9V1ZJYG8qFbOZBJ vY7t4P0PWlKKUdCHJvczLidbgN507OhPCY+Vceh/CsMuFkYwjcoHy88Vk0noyoPof//X/nK0ieyS 7CanOIIJvlyy7gzHoMe/8q6WP+yoZ286BLm2GGEbcKcHIA9Olf7Bcktj+Fzn5DaXmp3ptIDBAy7o oN2/yWOPl3HqOtCwFJBE0QiIj3+YThSPr/npSaa3AotK6+aFAlTPYfyqlPOu6NEDyDjcoGCM9eaQ DHWBUEKF0PmGVnL5zk5xT90e0W6/NIwJPPzN/nirjB9Q2P/Q/m0szKzGHGWAIUN8ua34Z5rCBYnK GS46ITkCv9iD+FeeJzsk3lTSzyASEEjafu5qO0nSQO5jGR1Ujj8Kai3sCkmaEMYPzLgD0HGKgcR3 DNGZXVoz/H3FIOaJehW5QrFFnkfKxGRgVHdLJORDK/LHDfKNoA4pOKe5Dm+h/9H+cYaesYijiZJZ NwOxjhcZrqrHxJpNva3Oj3ul+bNKp8nULZhE9jIFxuZv4l6cfrX+wVSNl7rP4S53fXY5F1Mtw4t3 yiHb9oB5Y+orrIvEssscS6zp0WqlNlr9rLGC42JwCcfeIAHPU4qTNuyuZmpSQzEmM+VGzfL/AHgO 2a5G7laJymPMVjgYGSauMbkwlfRj7K6niuMQExJjBKjDH8aJmma4J3FgAS/OCTVciuaRdmf/0v5q LHUdSkmntptyWyNut0PIbsSP89q13sIzh9pkcL5mGGdrDp+Rr/Yblij+FOdE0GqS29pJvDSRRfw4 3NVy1ktNSEYZZR5gyoI27SPWolFLY0jLtsQaksNkjoEZ3HOKo2cilh5cjwNKuArYDKawlHqjRzSN p7KKXDbsSIf3xA5JFY+rsINLvo5pJULQuInVfl5U4H41x4mL9nJeTOuhP30f/9P+MLxDeumqXX7u 7Yu2+RnQ7YwMDk+vt71yc14xlKkcNgKw5Ffc8aW/1nxtv+fk/wD0pnhZA/8AhKw7f8sfyRFI7o67 XypYfd6g+9aN5N9mtw2Ml+B7V8nKN9j1nvcrWqtcN5jhdipnG35vwq+xVdgSNiAcmRhjaO+D61zy jfVCL4jilEE0MchMOWl3HCsOhqayiSeVldF2Bi8ZByV+tZWtoB//1P434pJLWN5rVBuiQqXIz144 FattrDTbUltYw2wL8q7C3uRUzWhwNtvU1Z9StPs5gGBhc428D2FefzzSeZcTTBQzNhYwccDgEfgK xElfQpPfK7wqYgtuvUkcsa22jIgM8Uaqdvrg4oOhK2hRjaZkTe3lK3zSR53Y9QDVzz7ZgrpGVuVb ylZTy4Hr75pSV1YD/9X+ORrhgyweWGnkAY4ONoHeny24dJGmPmPgKg6hQK5ZK0bGMUm7MoPHsTem WkQcIxwvHahZWZGIUxADk4yCaz5Xa4SSTshyKChkwWZV3SEDjFamnztcMYogRGi7i5OM89Kkk6j+ 1NRS1SGC4kjhWTdJEeY5OCOR0/8A1VmzSvPIZMIH2bH28AigD//W/jsE0cE6ueIs4b0b2qzdvPdq gt3EPzqxYDPyggkfiOPxrzyVJMmgVfPErIH2nCx7jtz71ennMjJHLGFJO0uvXHpQUS+SkKrkkrt3 DuaWd49sBj6sduG6+lBpBvYrRxw21wJ5fnkL5Cnnb71qSbJ2jkbdgthdvA6d/pign3tT/9f+RWNg jsqncVbGTwB9KuxgMrSNGQw6MV4avOk7ICWWaNEXoW2jcBziqCz20JbzEUlzwcZIrACxcywuqlQO mDkdKZEnmssR3Zc7QehGe9AGXcyyRSvDGMqr7Tk9McGtOEBo13EDjKgdR70EyV0f/9D+SGOM7t0p wvbPR6lWLADRShgrEsp4HXpXhT3sK6RegaBopGCoGYEkjgNgGszTbeNbryoYwRI+W3Hjn1NLldro Zbuo5beeSLGyFGywX5vM9q0beRrUpPu2FRlYyME1ICX2q3OoO08wJYKIhz/CBjFVrWWRnRCjbHPr gDFTJXRpT6n/0f5RlQrJ8y4UH5h7VsI0VvHuWFBnuuBxXy50FSa+gDMpTbkZGMYb/PNVo9XtbZl3 Ru6r8xXZkcetAC38tteLFGqyxzSMHR4WKqg9x/npTriSQ4to9su1Qsi5GxiOuG6UASxu0ZaLysxq vzMePbFT71ViYwQAuenAoA//0v5Z7WKOUMsz8ud3PAAqzFFaWDSCNllkVw8M8nQr3Uj/AD0r5c6C NtSR7iRQQN/JRRhB9KsPF9qhAJaPDZ3g7WIB7UAXpIEaF3ido2KCNFTk+5z/AJ61T+yT7RHGMMo3 I+OM+9AFZxcxTLbMrMtwjCRxnC4HOfrzVkYt4jtChFXb6jjijYD/0/5dIr62jkhNwzgSPgeX0J/p 9atXF01uuQxbLDain5sE45r5c7YKy1GxvJ5nmGPauAc7t27P0rpdyNZBogBIOoI4rB7s1jG+hzFx cuZwHgYYcDzuNr46gVvJcsuwR4+YfN7dqxnsifIivRdNCi7j5bPlTnjd/jWfbQsLlQQGA5nYnG4D sKdvcOc//9T+YkWaOxXe8ak7laNtrHbzwavWsyajdGMuXWEbirjJcgjaT9DXxLi07HRsdA6rGIkk XMYbc7jkqB3qpc3tjdBWt1uBPCG8yIxlSxUkDApOLW5mpXkUJJnIJa3mkQ/JJsjL8ntWstm9jCtx azG3lCYQKB8gIxgfnT5X1NCpcztDbLLJG3m5wSON/v7VkJemWYFraRIGUNHIw+QkcHP6VpJWgc8/ edkf/9X+b6yuCEG0EbeGIGMVWuoYmb7yshbcoJ496+OjsjTaBIttG1vKYk3IqfNkcRe9VINPt0tE ErKtw8zEKJTIxXOFJ+vNDdkZlmdFRNiITtGCQelZUccyGVpYwkTtsicH5mGBkn0rOUk1oVzSNeOa K0jVd+9OpP3gKLl4bmISRyJiNh+8WQZ+mKgpT7n/1v5pWv0m+02EEq+baoss5WXaTu6KQD+NSWbS 7gpUrjls9DXw+xUndnR27RxN5jwxvGFwQwyOnXFVbuUFY009QSX+dWO1QO+MZzUQfQanZanPtapF KXdWV2bLlicn6Z6VpWtwIUeBY1bzDuEpHzLjsKsbnpoUC8B1KO5diZYlKCINhBngnHqaiu5S10hY N5bH1yBQZn//1/5r2g3NA0RR4mHO08iru+0tYZ0UrI4GCynHlHj/AD+NfDgZ9h50iyxXDl0XL+c4 AbGeBx6dKZJFKitParG8it8m7kEepHWs6nQNhrEXDs0bIrQqDMrjHJxwPXv+VW9LcKZ2C4Cna02M IPp2rM0g+hizzxLeuVG4u2BIUAJGa3IIYFjWSMK87KBuAxuNBof/0P5qY7y4ju4Laa3QpcMyhmOE 3AcAn+prRgtJ3MouzHE8bF1VGyAAeMGvz86DOnRWIn85VVH25K5x+FZ0dvHbXBUWQkOonM1yMhRt U4J7c9KB62G+brazQAwIlpHcEMgmzhem7GO4xxXTh7OzU3A3SzSAd8lc/wCelAihd/aGdWWQgkY5 PSmiEKkcZQncT+8box70bAf/0f5rTaKFdG5U9OOKrRRWDbblZA7RFrdkj+ZlwefYEY6V+fcyOgJY okfg+YCA8Zf76/WoVmuFlQpI0nJ3BiPyqOdJgc9quqamJJIpTItuDtiit/mkyeN2euTXaadPZXdk jziRLhYgi5XJZh1JNQ273AsnU5IrXyIYYpJEbCO7FSw9D/Osa7xHMswQRtcHO0NuUNjpn8DWsPhA /9L+ZW0fVdQ1Wz09oYEQTlZpBLttwpJ2lm79hx71rXKRQXltIysoEuxREDiPjkH2PvX5+dBW1xYp GUW4IDPkFh8x9qk0bTpJYG+3xJbSq2Yhv3NMnZuBx9DQOL5XcvXtjdwWwmgDS28D7pQWIEa552jn J9qxZtSS1ubSA4ha9OIPOBjEhxnHP8qDc12nuvLtpPJj89ZTHKiNsLKfutk8elMnN4ZUjcIZFb7z uG2g+/IpptaAf//T/mruLECKWWSET3LrsU53bBnnAqC3aaCyRkhSGKIECIqEbOe4+tfAXsd/Mr8p FB9qlWW7njWCVT8oGCGUdDVq6haS2hlWYvv+Xb2Y+h9KVugxtuVtmU3KLEwwqE4wfpVC4vUg1J54 bkhYkCTx7CVBboc02tWkBpPFLCXk2hfNwckYLelbGmXKoohnVVMn3nx90UgP/9T+be+1K1gbymh8 5JnMUdwsZ2oy8nn6etYQCxo0kETRpcSEu+3aXPTn9K/P15nsFmGJ3JwfmRhxjmpZXL75PsfkEYhZ iQxfH8Wffk4oAzbo22Y4fmeSRD5ixj/Vjplv896vRXlhA1vGIY0EaiNB03nv+PWgTdkbOutYzWW8 wloXUbYYzlyR+PauRgljliRhEysjFlRgN6np+dBi23uf/9X+aqx1KC7Z45ImtpLLCnzV4lGM571l 3/iKIW1tLYot1cXEzRRRsxhiKoQGO/Bx349jX5+egJcWBu5bBYpYppW/0uaNLjcqMVwEwP4hj269 KzI/tFs7RNGsYE7YAyCRnqR60AdBFP5YSVWxIqn5xwy+tZdlpmrXdtqGoJuWyjlwbiVtu/n7oPrg 9B0FZzt8yoOzsSovksBG4YNja/R/cUuo2Jku5bm3nurPUDaJbywp/qZAn3Sw9eK0Wuxsf//W/mWs JobaKNpmkaViUnMmflbOMqPSrRubWMNDakSXDsZAVX5c5y2fz71+fnsGR9tSze7DxNLcynzOHyqt 39ufTNXLaO5vba3ur20+wl1IYPw5XJ+YH3wOlA0ruxchwsivZRqPLADylsMy89+/0rOvBHZK95BF NdqJCcI3mMGP3lX6c8e1BsklsVY72SbyJrW2kdJclg6+WRgdOffitVJXuokF1E1nLcxmNEVw0ycE Hkd+tBlJrof/1/5k7qwcGW0sJ5zA6KFFwedwXBJx2zn8KrW5WIQ6bp8WJg+biUv+76859/QV+fnv x2Leo28lldjT7pf3BKyPdxglU3AMcj6GoBePp813CphvdOZNsTrGVccdRnvnBqZJWGSw6y0unxRW iy5uFaGRbhNr/K3BU++Bz9asaeNQtRm5VlQcK8hyT361lbQZNcakJzE8iEFJPLAZf9Yc4GaIbFlt Xa4uImXz2YncEljBJIGM574z7VL2B26H/9D+Z2aRYLhBHfF5Ew0CLxJAOmcj1xn2rI1aaS3lCw3s kF0qh3ktyGyp7E/TIr82bsj6SS91IlivpIrA37WbvFbzbZGM25pcrkYXr6/n69bejavpeq2jSiKa 2eN2+0pOdgyD1T1B9azldSMWrSUn0HT/ANnXO6RdPVXtzthu9vCE/wCOD/kU9YYJIpby3mt7q4tH AkiY5VW4JBzwcZxilGF9TrpzvUutxZ5Z7m4iRwiKyiTCcEfgOg4oSO3uLiS289rcE7t6qdi9sE0u V3sh8z5mz//R/mgi1CzFnebpRO+n4jlRBvkT0+Uc4/8Ar1T1m18yCGWaC4WW3hE0MFnLu+0u33Q4 +hGPfqK/MHFrc+oEsWkltoI7kSW7TgL9lkfMsbH+EkHGfpWnNpkixXBLiQjEUcO/a6kZ6c/rQk29 Cotp6FDUbO0t/KM5U3RjEYZCT9/Hyk9q2NLNta2AghDDzITFMkh3bz65P4flXVHm6CmnLcqR2yzp ErRm1lDnIJDcZwBxx/8ArqW6uTZXT6bDHNKREsjylMQgNkDn14PAroouV0a0YJQZ/9L+aiwtryS6 il8t1CSjaNxTd9RX2l8JrWyk0xHF/Na3F9K0k1nNlCPLVVZh3wSpA/8Ar19N4PRnPitJ7KLf5Hm+ I0o0ci5uvMkvxP2j/wCCa+kwXfxl0eRdO1WWSwkSOL7RgWUqysjRGH3BjbBPrjpX9aHjeZtO+Fmp STubf7NoyoJgN0zEkKwA9cE1t4hWfHtRecfyifQ8Kprg2k3/ACv9T+HT9tdW1746+PNQmWQx2mvN bp58JK3JBVfMHofmPPua/Iz9q3/iQeH4/st5pdvNf3ltAbFHM1yG37SWUAgZG7qe9f1njJxhwFKl /wBOf/bWfzThIOrxk6jf/Lz9T8rfFdq8gSEl8s7bgOEXocn/AD6Vw1nA0MygSjy4zyP4ge+K/ibF SX1hrzP6Wu1SR//T/ijh1K1txbxR7o/Mi2yMvKMff0zxWnYRW9+weRJJbuCQPA2ONo4Kk9fTj2rh xO52e0drHb/a1jhaLa0M4QbMDIbpxnt3rPulkt285gr7FDuE/eYB64x1OOwrx61hxlfRn1F8FZ7K 0u4tTZ4JhFbMLcuB5kUyjcrOn44x2zX0fa32ma8wudZtYoLUXBN0tjCsV3LuJHycd8Z3YwM15lZa 3KbSVzzvWNLvdHuJIJ/Jl0x1+2WdxDciWXa3RGA5DDBFbnhkaFd3qz6xerY6fBAsUkYUt57EYyR1 zxk+9c7dgpwi5cyP/9T+NmOG11OdJnjCPaws7Jv8v7UyHBUdASc9PauivrSwu7OZxZnTrOYCP7PF lvN4GQRjnGM81801ozC2xBplvYaWtna21x9sYuT9oeEr5YbpHx/cHpXuNr4vtV0e10uTTtP8uxgM FtO1tsu1JO4sj57nrx/KnT6o0m9LHI6xdXUkEN5FP9paR8GONNzqQcD8KyNRMxSBLmxaG8jjaVbi fdGi7lAGfQd8e9da2Ijs0crp15BqUVzcsxS6iuDZTBR+7wh+8DnoSeled+Ib8xtLHmVYBIxe8Qho 4BnbwPUGvSw+5Nj/1f4ebG9is9Yh1GeBdZkjHkh7omN0UDCkYPHAr6E+EWryt410u6vEitv7Tufs ejwW0pQrLK6qgfg8YDfeI6jmvUyKXJn2Gm9lUj+aPLzOHNltb/DL8j9QZrO/h02K6gnmfXLC6CXN hDIGkcq+2RA3QgruGfWv7Qf+CM+qaNqXwUWW0aQwz3a2UVtK5a4geHdmR17b+uPpX9Y+NVKU+B4V FtofD+A9aCzvHUX1i7fgfVf/AAUojuX+BeqS6bLLHfKkkNrGVIt5FlhaLBOPlODIcnsDX8KWuxWv 9o30NnHMxtZ2gnjuPvWk0QCSop7gMrcn1rg+jfKKybFR680f1PgPGdcvFtnty/5HA6nAt0iSyGWG MHEuwDchB6jjvT5UiKJbwfLaogkfcRuyOpNf1BD4T8dk7ux//9b8LZoofEM06OBHaQ/LHECSJMcc f/XrLh8NR208s8lx5toBtt4cYVD3G72Pav8AVg/hKCu9TltRs5bplR4laG2lzGkx3K/+13/AGt60 sZ/s1lLNeGFLa5ErRtHvgROSefyPAoeiNUraI01tJpJJLtM3iRp5iqnzAAc5xVGUfa76TVlWRLmR FWZpV8oEIMcLjsP5Uou5rGFjda+N9c2yM2bkbAuV2IyAdPyFXLm8e/8A+JciwrGR5CTO4QBieck9 MUzVRu7H/9f8Pbzw3Pp2jDU3vreIR3P2fy0mV2lwOSBnnnAGM9azLOLzys15GZIWYKW+7jHUg+3X 8a/1WcktD+J0rKxB4h0PSGvLKfdPDZkqJYbObDzDGNzNzhvT+Va2r2B1TTtK0GPUpxHpkBS0kdY1 uPLdgx/eYyGyAc+59alTtozTlsmy2kETRJZSFmktEGXPJf3J/CrFzAkun2zwXtrJex3RWW1m/wBY qdjgc4680TaasjQy9RlkjDW9pEUMifvJoekefT3rWuS1lZ2zzTgwS2xZGzuKqvVmx075rM0gtNT/ 0Pw5jvpJ7NCspaIODDcIuQ65yB+NXbCe8L3bzNA6zMHjAiBlOO+49BnPA/pX+qB/GUo22JVv9RSe W6uI1uVBETwyxqPNUYwAccY9qe8j3moz6pHa29nGI9sccZysQAAwfyBPvQRYpz2tzPZajd6pPtNu m61t7Zd0ki8AHHHJ/wAKvaVPptzHGDCwd4lISUZMXA6n1zTW5Dgmy9qlxb2rLYyWs093JbmaC32l WdBjJGeOh6VU0uHTreBZfsssczK0jEHBdj2wR9B+FO7SsiHFo//R/EiEHyygUedPLt3Nw/J9TWh9 ofy4oROxRP3bwZ+TH+Nf6qJy0P4l5UhJLWzlhVdjRTxN5kZRjkYOQfwq1NdWBjihuGOJGWKWHdue YnuB2/pWhSjd6HMGx07TrueMvNJbPMJYBIfmjXvwOv8A9att1mvpd9lc7orYlElwVEqngjB9QBUy bTSK5HYiu9KN0Y5J7p7H7O6tFtO0StkDbn3zW2traQxrLLcLvRtssBU73GPvA9P/ANdCctRWa3P/ 0vxX8QwQXumGztYAzy3MZUyDbsTnc27r3B/Csi9YaQIds6STxwiOJVJZMAY5HUV/qo5SvY/iqMb6 lvQzfXayG6V5GI8xWA/dsT2Gf88UyadwJZZLTzrjz9kfljLwRr13H0P9KINtu5qb8JsILJ57LBaR svFjHlsRkhc9e+SO9Z+nGO8vmvJbCWeyizbySEmBElweCcdsHj9a0MOZ9xY9Ih065nkglECXUvnL bB94iAwAAfSplZTdSC9CeSiBl/2j04ArKe51U7n/0/xagsLeWUXmn4CIzIXJKLG3uKlvDGkUBVla W5n8h0ib94eMliPT3r/VKMuU/jWV0tD1Lw34+1ix8Oax4Ujv4o7S+svIgtpIw2PLXGIs52sQB0xn 8iPO4I7hZ1n3Pu+9OJE+eT149aVKhSpVJ1aas52b87aGbnJxUXsiq95H9rdrdiWbhgRwPwovkubh opYHCTLGVJUbWOeD+Fa8yvYSV9DYs7Qw6UsVxLC7O3mSqBjnpznviobyyt5EheIbFTAYKAGI9Kol 7M//1Px3tVJC2Ak3ZbfHGRkLjuR61la/b3QiSFo4ZMy581W2sgH94f4d6/1YP4nGtZNLbRXNtJJa NAAHiLb/ADsYHyk9P/11ane6UWqCYxTTFQ+8ZbbkH8c0AQ3WnyiZ54Jd5PLeY+QpHYf571Mujz6x LDbxn5wMsirlnx6HtQAw6NdqriORfOVgF3jIAyM/pV/VtL0eYxm3hf7YsISdixAZh3wDiqpy1aHe 1kf/1fx80O2jit5jezSF1bbDAQWi289D61U1eSez02U2jbH8wBfNO4kE8gdycdPwr/Vpy1aP46te HoWTaWsemtNG08dkiCefe2fmwC34ZzxWJJLNcRi5lM3kx8Idp3BR0xUp9URboaVheaddSz28MpLx QgOJCQeR15rCuV8uURsHy0pVWUfK+PSm23oyJR00NSCJ4LiNFlWJpNoaFCGYnPysRnqMkfjWnebZ 45oZlFxJGd23ALMR04NXCX2SOXRtn//W/HHTbKBkiubyxjEsM5k3Zy6AcAZ6Y/xqG+gub+5Bt9Vi 00rLJcyWoOLWYnkAqBmv9X07q5/Gkfjiirc2zElLiPEksWG8sHy2OOoPpmrKu9lYhDIgm4XyyP3h HQ4OOnWmZ4iK5mynI21EZZV8mRfnxy4PTGKl8+3UlWjEkMaZWTGN477q1hpdC5fcQ+5tC9rFcpHE 6BuIEYZxkc+3/wBaqrMJ5zbQsXMSAgKPlUHsO3rVgf/X/HSW1+zWkXlxiS5kiK5kG3BznbnqO1ZV zcGCezhMUkMksfk6jFGrSruJ+RwccYBxX+tB/F5PeZhjhi0q3MkjMQ8cpIHCkls9+lRabLaxQNqM 8MMc6oUkil+b5uhCk9frQSk1Jslae1WZX/tCFo5o1llgjQmSDkjBOO3tVi9mDOYi25OqOgx5g9aA v71jNtYIdY88Ez2skGBNNDw6JnGT+NXYdOazV4rGaS5jDbm818uw780GkdJI/9D8Y3ssTK3m7Wd8 +XnCp6jNEZlaYS2+xoI2w6kZL/Sv9aD+NJ2sTW73b3TQsziKRsrIFCqq91OOuKW9j2SObOZ5TbnM rQrnI9KDIjtJTq5ljdUcwJvxKgXp09s1FJJb2ETvCBBJMNs7+Vu9sDigTimMh1KO80qYiJ1ktj5S Tsu3fjvVeOcyW/JRpsHCs33vwoOacWf/0fxdVFZIZYxIkkK7plJDKSPTjp0qH+2BeGWylXYDJjLf Kr+mPzxX+tB/D9rFKAZvBbwMFWFvk2ncgHAPFaTSRxx3VtAjzXC4fcFLk7uw9xQRytO6Ldrp6w2Q TdKSBlxJyzE81z62otdRMkaAiVSqxqMcnqa0ULq7LN2z0kXlrPdpvD2rAM/CqpPQYqnbxXLCXKDz IyRlVyrdeaPZj12P/9L8V4tPjvbqQSROVjQGVWjzzVeztLaK7maBnLxqyrCCY0x2yK/1saUWj+Hz ZtYZjbia7QIrS7fILct7/p+tZOsxxtBdWNrDs8/5TsP75ecgA1Ka5rsabWxnmz1E2SSPHJFuPlqP +WnHGcVtW9ktvCJtqSyGPbmX+DjnvVcy1EZU9oZrdp0ZBvk8sbjg5B5Ap0Q+zQKjFJIlO+YMMlMD sKtJLYD/0/xEvdLa2DXzRultfQCa3IGN/wDDyO3Sqdrtgt5pJlkuFlPywscogxjGPev9c4K71P4d lKxVhUTyrZG5NpY3Ckyxou4jA9P0q7amGKApuaSNcgsy/OcZHStbdCOdlM3CyyyPHuijUdSuNx9K TMPlSSzl42VSImXkEnpkdOv8q2jGyIlN21MZNOi1Fo5JJrhZRwHiPlzr7jNXFs57dTC93NeKuU86 5AWV1ycBscVRmp66n//U/BfT7maC4NuweGDaTkJuAPGMfWkaFb+8j+03AijQMzrI/QLk5A9SBX+w B/C6d9ieK5Ebxi2jjmtH4aUybCgxwQuKsxTfZTId2fN7GgCjq6tH9gdXijFzOfNDNmQgDPygd/rQ 5jldApwyKU809RnqP0ppXdjXnV7FSC02PK7E7SuGfkLWtpscM/m2+P3bHGehrRQS3KbS3P/V/BzU rT7OqCCGS6K52bSf3eAcZP8AnpWX4ftZ7iaVromGQ527kOwHPAr/AGHUUj+GZO+x0NzdT2we0nT7 QGQhMDJT3B/xrm7a0vodxtf3SSlvOnmbaPXBPvTM3NIz7iKW7ktwiKsy/ISjnB9yOlMlS4tGcSEP MvAVW3Aj2oMm2ylbTSMubiJ03twuclcV2cxhe2RY5doSFW+bhhgdG9DWkIprUyc+x//W/AWTy7qB ZoriKcN8uYiCOOO3HaqK2qRrJI0yKwH3G6tz0r/Y9RS2P4G5k3YqXWn2s1qZSR5oOSF4Ix2NULaS zjjlilQFhgKWGMH2NMLq1y3NJa2sOZEwzAMGC4K/WoZ3v7qW1u7cmeHYIn8xsAIM8r64oJcvesOe 9VmNo5XMgwrBeuKPskMLRJy7E5x6+1RKN2Wf/9f+eG9lEbCS43Jbf6uQg7mh6AUheWxiSS1WSRM7 slSTiv8AZA/guDSVmVGvX1DA4t2DfOxHA98VlqGiuZmAeRm4DZz0PWs5rqXdXsddbhbm3i6pNGo3 qeA+R3/Kqt5LHbTvECWuowFZFYNGM+/rWZak1oii2nSXYa4GUPaPu341AbP7MS7MUxw23tRYly7n /9D+eaeX5Iol2eQ8WUdB+9J9jWa83lxoHjPlI+4yMMsxHue9f7EH8HXREyFmEyu0wkJJyMeWO1Nk tydoEQbJypJ6H1q1Bs0jJrQktri6s32BiQxwVPOPapPs01wzjCSg/OM9B7VSgluEpX2K8Wm3bXFu ZrZljlkaFN/HTPI9q0Bp77miBVcZXcOUPvV2sJSa0P/R/nqENxZWnlboS7cF0TjjvVWwvLyxuvMe cTMpzuRdiKOwr/Y9pPc/hRT01NjxJrtlqkem232Xbd27YaUEJhG4Py/iTXOyW0lrJGlv86SksZDx tPGP5n8qZkOu4Nwb7ROMLgJHnLjPUkfhWNJIxLhZ3eIKEWJvuoB6UW6EqV3YIkaTEeRiTC/SnXFm YcBY/unqorNw00Li7M//0v5vmhs5VVLlfmUgqzDhSOh/AjNXJ4ZLBGeQrcCaMPFIkvmKAf8AOCPW v9iUm9D+EnJ30KEF6tkN05w8hyrj7341OovL/Owsyopywzhh6f8A1qTXcpTtoxtghmZlkR40jysm V2nuP6UjWKKFVC4YSfOxXK7c9RS5UncHNW0L8Giy3N2IIY2mgflJB95sdeK1ZfD9rppkufNDukQ+ QjLg+lVZmbk3uf/T/nBRZHkM7bSxyrbflwKrI53gykyhH+QueQCegr/YxQVtT+DHNLYmu4YbgKY0 2jOW9M1HBZErsPyoT1A5NWlZWGpplt0MSDauFQYLMP1rG8ktKw8wMrn74yDUSi73Q7o083LRzRrv i8gDbK4wJAccoe/X9DTTMrKApaTYAskrja7EDk1mLmjsf//U/m1jaZcyKScnjjJApUs2uGDxnyyf vqxyXPev9h3G5/B5ZVYra1+z7HWUSEhgflFVfNuA8Cs5dYiSp9M9c1k4tOxEmrNEt3dbPLDMSztj C9V7ZxUKx5bEjLub7pP9K0jGy1JhuSWaGJpYxtZm43MORz2puox+SVEfzk8sRwBn1qjS6vY//9X+ beFo450mKYZY+AeQGH+TSw6leLM+USXJOFC4CjtX+xB/B4wO2e24n5gOlblgY7eTcqBwsZ4B+5xw aTV1YadtjLmNxczHLBycnB44HesyIbpvmI+VvlYHisC5S10N1HuY5mMHllmG9kkbCvgY/PAqbV9H vNW0S9eN9kltbG6kII2KFBJU545rmxEU4S9GdOEleqj/1v4zNduQuoalFCxmjlYiSdcFGIIJGPr6 cda4aZFRDKAQ44A/+tX3PGitxPjV/wBPJ/8ApTPn8hf/AAk0F/dj+SM+Nbjdt2bWX5twPJzVrfLd MttNlShByy/hXyx6kpNOx0DFNPWNiFuUeLKlSV+bHQioLe5Vpk+1K7QNlgi/KAe39Kxl8TLjsj0T RdM026hjM16ltHK235hnOe3tU9z4Yk0mK8eMGeItuMysGCq33cEHpj+dcz3BvQ//1/43LS4WMOkg PlgbQRySf8imIbj97NC4Z2bCrIMCMY7EVMl7rPPIXvVt1+cKxTl2bofpWZLcpeTkiNVDnaoQ/KvS sSor3kdJpOm2khWO6wmOPMZQygdOlVL0Gymnidlktk4RVbIwDwR70Gr0E22U1itxEJYbuLLPExyk o7AVVsID8ly8flq7n6g0DP/Q/juCIQ7ohab7oIXcT9KmWzmWLzmwD/zzPDH8K5zBaMp3ESuQmMBh lgflKH61t3Nhp8umx3VtIls0e2Ce0llMs8rYyZF+UAKfTOQaBHMsgk8yON2UBP3oXgMByakhCR7f suYyRjIyKVlawD/tl5IGhfhT8o29TSKssTNyd+OM9KnkQW6H/9H+OZkSMgytjeOYzyAfWllmCBUX 5e2RwK4/Z+ZMY8o+C52ttI79c8/WtTzIPLDNuLL0Y5yvvTcFayKFN5GkLs7FgowCRnNUIryAyHdJ iQDdHnPzewrI1prQub1JDGQhz9wHnP8AhWpa3ZmR4WiK+Sw+c8B/pQU2luf/0v5C23fbGnH3EGEi z8g96mi1Ca4++TDHHu/dlceZ1AH4cV5svhYDBGG3sZdpYZ56AU2NYcA7jIR1btWIFw3EQw2zKrwx I4qu92ozdB3CRj5URCzv2xgUAUr24WN4kAbfPghsfL+dWoZZgOisu3aNowwI70Gc3oj/0/5HRcbQ qum4KOT0AqBr5WkRY0wg4YDgmvHMG29CZXlRQIUj2q+/DH73PIrRt5WgmeN9qhx5kYUDgn3otbQq MmtGT3Mix7XLBmcZJzkCqIvYWISRlaQkhNp3LUzWhqXLYZJcqCFHXHAFAeUTKCm6FeVYHFYlw3P/ 1P5Rkj8oBncpzu2scg1aikE5aMc7uhH8NfOKCOgiu4IUZEWJvPKYaRzlD6YHas37EpmNqwkchPOk 8oZKL6kdhWQFpNvmBVOfLGCW6jFa9vAm4SzFQhwFxnd+NADbqLZKwVx5Y+YnOM1OgeW2kfC7l4Tb yfxoA//V/lMX7Sr4Jye3PSlnviUjt2Ry+cF9uAa+XOgtpYxNIkm9lcgbVBwv4mp/Odn2+c2YsxmI 8Ywe1AFiPUJbfClN+w564FX7PU2nbaQEbPynqpHei1gE1G5mhYKqeYJAQ0i4/d/h/hUEGnlrSSD7 RMHlbzgeCycg4+nHT3NJq6sVD4kf/9b+WeMx2su6UCUQN0IzjnFalwBcbb2OGJ1bkxo/Tjrj0r5Z R5dj0CW0KNGqbRC5bJHUdauXM5jgdYgfLjOZHx7Vk0+ZpGlPqYxu7eeFJo3ZyGKuMYVMVpadcW0s RnY7SG2KH4bIOOB+FYyWyRmTXMzzN5NrtdIY/Ok3tt2+uM01J4nzBMFjiePadmS7tgjk1ocyerR/ /9f+YOFACwiyRGNkRkJCrjjvRpyXCzvJOFgYOThCDur4+xrN9DvLe1F5EqblZz0Bx9R/KqTWENv+ /Qlplc+aeuR9KDIfd6nFBBGXYRoSN4PTv2qr9vW4nRApe3SMyGQH5VIxgbffn8qDaLuhd8upZURu 0akAkIdq+5rKu7O4muFtIJmS2Rsleibh1OKJtcljnXxM/9D+aOM3VrMyOS0D4VoTgRt9KdqLWixR xWUK2uGyY4hiJR6D618bFqxvZWsUbHUGM+1vtAhJ+y3ELriGYAjkDrjPetXUNPCIiQSSWTNgrIgH yAYOOc1nJ3ZMYqxCLzyFijk8yd3YICAWaU/5FQyXT3cgtsNAxO1PMGxc/WpIkrOxYsbGP/SrK5vF a4VS6LE4kibnoGBqlfaYsUCGLAaB/MWLdtV2HTNJNMleZ//R/mailt1juG0+wjt9Qn2qxmh3ZI+8 S3celaoWUhy5CPjDY4A+lfCyu/dQEEF4fMNuHDxbTvck8emKmtVmjlLybAqPuiVHLHb/ALQ/pRGN gG600kz2kluzhjKFkCqCm3GeajkvWWe2jFoztv2SsgykQCk5b64A/GqAhgtka4eZogpaQk7P4vQm pJ4t8jhI96RDdzxQB//S/mqa70+1jBleWAAYXZGXAY/Tp9aW5iDwIIP3rMAZNx5cep4xXw4EVjGd S8sIl1DKJXiaJ0MQAXPzEdwcVfW6tbUiEKqAqUy3GfXNZTeoWLA+wTRIjKsrKwcRZwrY55qlfWOq agn2LSxGiB/PljV9h2DlsHPX6/zqC4LW5i6gUa9srLAhkSPzG8pC0bKMAgt2JPvVyRV0797aRvBa oAyhWMu0n7x6dM8/j7UGp//T/mja4t2hR5Jnkn3GRdozwRxV2zDXNpHPdNLDMxKhH/gHQYPfNfn5 0EBtHZ0h8wFHfBbOFIzWnqcEcVsqQXVvKsXyFoW3eXjjHtTUW+hUZcpkWVzLcWtwYVW8eMmExg7m jIPBPpTbd2LiSb5TCQskRPKn3FIas7mlcbLmWHyXJyCWCjKfiaoySIryxbzvXoCcgfSk1pYmKTdm f//U/mhOpBZPLlWRmdBHGkcZfaecFvQHuTUFneRwW0thdwRLGLt7gTQpsnBc5IY9ff8AGvzjla6H c4p6CuftNzi3KgeX8rHrimxQTJPCm4Ft/wC+b7qoOef8+tNRbDkiK0Hm61HaxpHcPLbGZShDLEBx ljnjr0qJZLhJ/slssTss22bD8xfh70rWdiUlys1RJDbyFHx5zHBAGdtJJarcqsSTvGJXzJOBvaEY /hB4rWKstTM//9X+am2ubaCRrSIiWZDh/wC/ntSsZQ7tcRFNrEBSctX5+dBKtzFuWN4wwfpvGRVP U2vzJbTWLQgRyjzkkzhkHUDHQ0APe/u1jCGZhCDvePOQx9P8+lUzdWWr3Wn/AGi1slNnJvPnSbmh IUglT1Gf60LQqLd0jRlSa1WOF5oWG7fGwIfcp7HB7VHbXkMiSSLDIxjkaNiyFTlTj5QexxxWkUnF mnN71j//1v5xre2SW3y8zRLNkI2cEH2zXKXc/wDZaq9/OtwI7kRrAEPmzAtgHavpxkj8q+EjFJ6n Yl71/MpXN+ftnlymQQsgZIh8rAEcErVraYoC0ckm/O5ITxHwOpPvVcqvc0IY2l1KVHvLcwJYSCVS ZMxy/KRn3xn/ADirt80M6WxsvJOZ/wDSNy/wr1I9/T6U7AVrme6vJlCSu8dlxskBjWQcAbc9akuJ mjSCVZFeR1OVU5MfOMGsGmtwP//X/mCa/wBTjWC2uSnki4aVtg3b9w6EduAOfatSO8kMZeCNJ0Rt pDvtMPqQO5HpX5+evdJ2NA3MK6fM5JhmcYW5b5RH7+mPrWc7XJuLR2nElvFlpolO3zjgBfoOTx9K AloihfW+qTFJbaJbdZpCm4MA4HfA9OetX3ltrCONrlW89yIiCoIyeAQfegxbb3IB5F8yB7hbWaNW ZDLLsVB0OfXOBUmmrCt6AYw7yoSkgbCSlRkAHpzQI//Q/mPV79L397FGf35d4iMAjP3SetaNmmn2 jXCy28EdrG7XEEXleYjO3LAjtyf0r8/PQMywuNNtme8g2yTyNmNgPnTtz6fT2rO1F7q5uGlikd5i 5Y+bgKBx8oIHt3zQBtRxSTWvI2PtwxWsaO4ZbkaVe3rWdk7+bn5mViBydg69hUyjdFwWtxs92d7W llC2yBspdyHEkmf9nPTir9nLevNGXumhlk+XKHmT2P5U0rKxqlfQ/9H+Yi6imf5S43u+A54z9TV/ Qfs9l5ovLZZP+eTxSkA5OTkY/wA5r8/PbUdbMSWKC5E6FfL8yXcVj64XOOeucGm3hvZvJtoPMuY5 EFr5czYWMYPT29qDRRS2HWouYU+xhI41RNu32HHH5VXklmSD7IhKq0u9Qq5UE9TR6jOj0qwvrny4 vLBVIyY+igDqap39tFasjtMTdLMSAPuxAjGBQYyVnZH/0v5mBfRmZIIp186UkbWGRjoagSVdJvLu Gzt4L/Z8xmcsuCcnj/6/pX5+ezdrRCWkj6sbgXUrRtJFlFY5XPoCemKyrqSa2kgjhtxMEJEisu5C oHf69PWgtT7m3p7G8t4klC25ghLLEDkxjJPH1OaivhPdiGF7qWK2icOoU7Twc4wfXFKSuiuaIHWN LivbWyltp7mGSNllkiG7ynAID59iQfwNMmj828W6jlQJFAVVJGwpwd3fgn2rAo//0/5mbL+zz5sw gZ7jbumuUTKBQe5x2+tYD3QvNQuY7exkaCFAXuJkMZbnGQCPu+/vX5pPax9G5XVjXa2gRfMhk85g fLba+6MEen+c9Kx4rnSf7TlTU4niaG189BFGdshBwF2jjPvWUpX9SJ63Oolh097V7zT7h44brDG3 lY+XCwHAK9QKtxw6PDELG6IQ/Z/PhitYt0V0z4BDkegOcc9K3iuVWOmmtUUk063sdQeaO6dbeW2S F7RlHlrtOcg9fT8qo3VxAb+SPS1KpblZp2u0KpOGyMKfw9+lJWvoD3Z//9T+ZWUC0nlujCttPNEP OCrgSLgkZ9cZ4qwL2P7BO6sxuCMRKU4Q56/Svzc+oGtHbausSwRzq0OBduH2qzcHAI/ClFybZUj2 7djEctvyc85P40WsXDci1KS2dEnlcCFsIVYYKk4H862tOgjuNPjliBEcbm3SI/eXaB830OR+VdEF sip7F22ubaxmiF9CZYlkHnyIAxhTPJHvVVt+o3cNxDKIrGOdmHmQbJJ15VR7dj36e9dFJapGlFe6 0f/V/m6nuJdDtrB5VW4+137I0xmAeJMkjC98cV9dfC3yrmytNSvBH5XkHyJwQxUdGz3HTFfaeDNJ f6yykukfz/4Y8LxPnbKKdPvK/wB3/Dn76/8ABL3S5D8UbCRRceekUUMcc5Jt1VEVkkU98CUNX9P3 xmuI7P4S+Ila6VDZaS10qxxhpZCsTcFj/tEflXNx57/H9Rf3l+SPruGXy8GUv8P+Z/CV8dPEN1L8 YfHi+Ibu51qzh1SSR4klVX8w5K72HTd8pweg96/Kb9o2SMaZ9vuIwskl9MyERG4SDHliPP03foa/ rLN4KPA03/06f/pJ/NGVtvi/Tb2n6n5i+ItSt5I3nCmNZJSuTLu8xl64HbtxXBW91G1x5ZRdjnaJ P7p+tfxNiVfEOx/SUnamj//W/iasrO0Fu4mcOiIME/xknpkV0emWzWLKIZAFblQOSB6GuCujoWqu ehWDW17uWZFWJU3Asu4sw7YrHvbpJdStoY4IrKC0YSz7JCySxjIyT26Zrya63Kgrs+hvhu+ktPdF I1PnhVimiURrvGDkkDpgdPpXtZuDZXk8ZlW5YRL5ZhOYgMYAB7159RJuxsYo1ET3I82G5VSdnk3C 9D64q7f2lgsDeZJHG1wPL8ogbZGPTA9v6VxS6GtCK5mf/9f+OK9tGbS7eC32ySRuGmvVUq4PTKj3 xmutsryb+zE024ClUZbhLpUBmfIAZST2OORXzk1aJmlaSRl2sMUd4WjCxLITnd0X0wOg969ci8PL rqW91a3Fha28NoIbdb64CbpAo3KAMkc5IyAOeTSp9QqLYzLTTHTTmspfKOoWV27xTQy/u5o26Kfp jjHrT72eKeO5i1i4kDWVmboNIpmEzKMIhb8PyrrWiRnseOeHoon+1wQeRG9xdy3ErRyeYjMTnb9c CsCea9tZZ9N1BbC40e7u/NuhcwBnSNMlSjYyGB5PNejh31REnY//0P4eL2KKC+maDexjzOpiUlXT JIKg9elfRvwvh0m6vtLna3njaOyiQySrsnknZgd6p2HT6Yrvyp8maUJPpOP5o8/H65fVXk/yP038 OWkUVtDJPdTSSpYR3Es6sRc5dA7bs/xDODjrX9gv/BEW/gl+HCQWUtlY2ywxKr3EZ+1XMskrrHhR 1YAnJ/XFf194u3q+HkZ9LL8j898D0qfFWOpvdxdj9Kv+Cguj3F/8C9c021Rpb+falqVyg8yNuFz/ ALSyOK/gl8R+G9W0rVdenvgYdWuNauH1KAEtbxys5Z9h78tn8a+f+jdOm8uxUH8d192t/wBD4vxs pyjxYpdOU80sxdPbS2l0zm4EjkTPHtSX5mwR7YwKwbkzwKy3kLIJAyFAchgDjOfQ/wBa/q2C9w/F mrOx/9H8JWv7TTbcTWxMShQzu/Cx9sZ9elV411axtUSZUGnXdy0kX2mVo7kg4LMi7TkHI5JA4r/V g/hKmtRY7aNZP9M/0eMkESysEjcHoAT9a6GXT7uJlUrBHZmIBmyHiIYcZHrQbR3KqeZYhXjiV4ol Kf6Mv+uIHRRnHcDH0rPl23siXBaaKN4eI5UMe08nGPx5qLxV0dEVqie1uY4o0mjAdUJjchcSPjjA qDToUa6mOsXC/aJJWazhEAMcSk/Kuf1zjuayOhK70P/S/D9LeCB4IWxtRmltzIPMXOSc4PvmqFpp mt3tu1vdRrLAuTLNvWKInvtGevA49K/1PulufxaopWMy+ivNJuIbaSFFt0w53MXeRTn8v16V1NiL C7s5ZjCVeCRSqy/MHHPf24yPei6NOVjLq+CRyGyUeeyFDEgHOOQOfoKxNDklE9zPdWGJbpBE9y8P yptOdob17Uy1BW1NgWnnI6wGQjcSxHXHtWQxuJfMsBC7Iq7SzHGQeCtK6vY2jBW1P//T/FCLS2h0 N44rxE82WLFnFHiK3SPIOWI5bB4A9adoWh3My3EqlRaQyCOOSRsSux5wB7Cv9TnJLY/ji2tjfktL W3meKSRdgi6SLli4HQfrWVcPYwWdx9hYrNKCLlGAITsrY7dKlzd9Bcl+hUgXzobd7xtytHtYp82/ bxuI/DOKnfRzLAZ9Ld3hUiRn2bCm7AG4joM9M0c/kJwSexYkh1ISJd3F0bm6gtvskTFtwAxgAE/S ql99re2tUs0lF7cTi38vygxHqVz1PQdO9NTXUlwXQ//U/GS+a0NtDZTI39oxuFmJYLGQBgkgDIOc /nVS1sBI8ZKNFbLIMuvzGQDqBmv9T1PY/i+VPXVGpaxyafqC36R+coYrHG54AwQO1Z/9kG6un1C5 ls4reKXAgeci7unbkhV9uvXHH4VpzscYa2HiTS7q9jhjZmeV/s5LgPAByDz2rSuzFo8VpGlpvEpZ S1nHuSHHI3AdM0OepfJ7uhYlsPtdpDf+SLjLtDDY3BMT7htIl24HK5ypzjK/nmXMQs/OtJYGurkY UxXBMT5POOfb1qudGbjdan//1fxxmt5JltLhSYoo1VHhABQKv3gPTv0qxZ+H9Gv9UuLqS1WVfK+b MpjTamSCRmv9UZS6n8ZRhcdpMcVu1xHbhrm2eV49pO1YCowBTp9FQxNM0RS3mmKN9m+VieMgnseR TjLlBwfQy7jS44JEEG9HQYiHRxnt79B+NXPsU8VuLF5PLjZvNlVMgqx4y3vV86MuTUVdKihuPLYe btiE0ci/Ogz1DVnz2e9bi+ntpHmRdsVvENgb6DvWUpdWdMIOx//W/Fi3bUBbvALRY4ny0gOQ209W PuP6U62jN7dpBp6xqQgzLKmW9G2nt+Nf6n3Vrn8cNW0ZpwvDZzNEw3SxKSuOTuHSobXVtRvLlJrh GSZ1MBMagKSFK5/ECtFOyszFRu7HPSXdx5jK8AgYSMrErgvg/eH1rprdo5gszkxEQkLHJ8qSkd14 9Pw61Boko6Iab+0v7JoYWZiHAjlhGQGVuQfTFSWc53Nbyn6ynt+FXGdtGZTjrqf/1/xs0VZbS/nu JZ2ed8q4YAIEOeFH0wKuPeRTXUyPFmJn2ozj9a/1W54n8VuGuhU1DzCk8cZaGBFDLcpgpjqfYYxi sOHSoI5xPLd3t2xhEse/Lqm3jBbp34H6VLn2E4NGik8W3545fnXlM1rWl7IkUiQwtHLjapA/eFMf w/Wmpomz2L2gsb63mlXcPLuGtWYqR5TDqD+hpn2aSC8uQ7/apZF+WRRlMDA49M8UQmrlQg27n//Q /H9ba/uopRp4KhWxK5G5Ys8fhzVO9gupEht7uPc0RA80L8kjD0H1Ff6puoryP47hH3GjUSC81DQL mxCwFXcOqTZgJK5wfw7j2qtcRzyWsVqVjjkjChzGMo+BgiiM7aEuLic5cwWIwZQbectscqnLY6A4 H+c06LS7qa4tXkvA9ikbeSjAgxnI4/HFVzok220q2iuIbvYGuIRxNgjPp+VaETRLN9qkVUdyFPrJ j1qoyV9BSV1Y/9H8htV1O0sotwQRicbNv3UY4rBTT0vTBeZeF0fdtXlZf/rf4V/q5CXQ/jeC/eL0 Ost9N+2qYr65W22DekzKcgr0HFc3rFgDOZ45HZ9nkqrHcgA9PSmpLUdaneLkVLfS0htnnlcyrnJU fdStC4sFvbNEtHitSoxJkcn0zzW6mk2Z8l4ogm0822nNl2O1dm7opOOcVm6ZK8W6KKNi4bLSkYGe wHrR7TyE4aaH/9L8a5NZtLiJrSeVYdRViLf+JcgZG70zU1hd28d/9muh5l7JCrPKUPlsB3Un8P0r /WbmifxlyOxsiDTrjVo4r5ruC3MfkI9ku+Uu+MEjp/8AWrk/s2myLeWLS3cr2l2Y45LmLa0i5Oen 4Uc0SLW3NDTNLtg8srxbIgoiMuMyFudo+lal5pKwRwtFKW83OSRkJz0/rRzxIkne6M1YLWy1IRRT PJNqMIifcNqL3I/PHJ9quTWUkbzRgLGiHPmBuZOOtO6LP//T/Gr+zXuLZ4pGKhHLQyA/vemKNPtl 0uSONhLO3lmMFnI257n16V/rOmnsfxg7tanU20lhZ2k0e1zLMS5B5iX3+uT0rKgARt1shAB/hXaG P+TRdCMuO8h0y8kaSLcJmZZAfkCk55P6cVpTywOkcYaNfMBYYHKmlzK9gGRiW5iW3dbcqHKK0Kjd jj7wA61jnTYA00QYPdibFu8HIxzww7HpxTbS3MZrU//U/FQx3do8syCeRFUrOChCgjkkcVFZ2Nve yPM251YBxn5due1f6zKUWfxM1dWNJvsUExhht445vK2LIqhS3Oa1NHhFzEfLQ/akkPnKF4wOhqie RC6hdNp9zKZNkkLbfu8yZI5BFZatFM8l7Exg8k4VJPvsSCDgVqpJJIShrqYV3LfFB9kkkiVZt0iA ZSUY7/TNdhp0qpaq8jeYyqNyKu1mOKOdFuKasf/V/FuHUNU+0O1v5TSXN0EZJD88YJGRUM0jxasY 2VIbsycqwAjY56emM1/rXNp7H8RcjuXJYtSuGlubzMC43JERtDkE/Mo9D2xWRBcSvdSrLbMX2/u5 CCv0qC+WJfmTUxEHyFiDbFZuVz1IHuBg/jVSe+Df6I7MolX5nTgHHXB/GmrX1IlGyuiSdZPs8UMS q6R/vFBO3dgHnNQLPZxxKbkmOed1hjTBK72OAM1uQf/W/EiWcGMwF2kCHy1UnO32x+NZ5R5W8mBm DIu7aF3F8dgPwr/XSn1P4Zl8TKMFtqE8lxeR25htoTh7mXAjd+6DHfBBxTbWaSKeV5yBFgk4+YDH tW8Nznd7sprqQvUQRI8VpM+8S7THvHYZq3fuI1hiidZkYbvKjjZmIHXJx2rUkykZoHhngckI+9lb Jb6fStzUb2G4iiM8YSaXaoS3BR3JIAO0UAf/1/wW1GGIvGkN3cQybQ5UIpx6gmiW1jvGQ8AhAjMO Gb61/sAfwlGXLoTvpP2MRyI/mDq0bHAX6UyS4Kg/6Ohj8wYLn5hjrj/PaqUW9h8+vkWUtWvHX92F jflZjyYfWqepW7acYYrYxywmTaZGJEh9DzyenerjHl3HzoSB7ucfZ7qOIFlDxhD0UH5T+OKtWdxH KJltfvxv5U4XgqRweK0Sb0QOfY//0PwtjkUM1mZPKaf7s7At5ZPHTris+6vRZLDbqS4jB3S4xub/ ADn8q/2K5JH8IuTZNHr7Wstt5MSO0hEUrTAEsrDB61XuVSLU/stxdAWk5xhRvQcZzx+VPkZk59jN itDZS3M0ciSQk/uVUE4HPQms6ELcXfzBlZWwGIyh+tUoLqZXJZo4oZ0BKvIJOSDgL7ipboo7hGZI 0K4dmYKremD0qkrKxLkkf//R/n6tbAW+YkkCpu3LsHTn0/Oq2s6fJFsuo5XMTfIEcYJbjFf7IpX0 P4A63FsYLhbFnvkEbEBjg5IPpills4Z4hNCiq6kEjqGI71pGNtx8ztylG/trmaRZpXR2ZRkIgUKB xjAHtRA1yGdJWSONm/crGNmFwO3bnNKUW3oTdXsX59Nj8uORNgkGGHHzHpms+5a9IZraNTJAMjzD tOfQVna2hcZW0Z//0v535J5RFHFPCn2iXEmxxwTwQf61vNNNDp+VRPOwD90Nj1xX+yB/AqkmY1nZ x3qbxH++VjuRTjd9ao3sM2nuyS27RydkOCxB6d/pUyV0VdbFuCZpYghhKkja0obGPQH8jWe1kvz3 iSPHzsZHOCMHGcVmotsvnZpWlw7NFCrYVAAD/E9SXMsPk8mPzRJl0JyHA7fjWkY23Jbb3P/T/no3 Wl/LG6xDT4YvuQxAyBB/dBPJ6Vi3F752+J0laOPOxGXy2GM4yO1f7H8qR/BF9LFIT3PyuoxBjBTH J9K2C0TRIqOwkVN5G7KRk9vrTNVJbFeN1WL7ZDLHc+QN8sLYBzuxgDPI6fnU2nXUzSF1Tb5w3SDG FTJ6D0/CrjG+420lqXZZIrm5WOVnieMfu25289f5VJbMRI8KZcryTjtV8kRrVH//1P56rxsq0Slo 3cbd/dfcVz6tJZXiRtN50DcPhc7z2J/Gv9lXDsfweXp0a6iluXt/KkeTbC7LtG1e4I9etaURa4to 4g254evqOOtHs0K6Whi3dk6N5jSKVmkIJB+Zf96s+a08jd8wYjrjrRKGmgRtbQgwVGYn2leenStS O7Q2yhnLueGOMAVHJIZ//9X+ba9jubjfHCQrEYRyu4IexxWnbvHb2zeYRMyxCFg56NjqPrX+yB/B 5kymKRMEbmZsA9lrpNOul0lBHFEtyhAZ88deo/mKTSejAsS3IufPFqi23m8Oo5wMg4zWbNKbeBoC ykEffzg/SlypO4DoJtVsLYXVvPdWM9q4mhljG0uGBGRkYI5PFXI9Q/tC2zOwEhUu8jH55G7k1ViZ Xadj/9b+cHy1Rd6vIXZiAg5Ss6QGWVFXc21sSMBhV96/2QP4HNdDbxQHex29Ce4+gp8TiRFWCVQA eWbgigCC6upBDLEwEjD5QR/F71n2sJLAkgEcsM8AUB5GpPdySEpBEfsyjALDMhx1JrKDqsjGMHB4 KnofwrNx94D/1/5vlnjClCdsqfw44xTreX50bG5Q207eDX+xjh2P4ITa0QuoSuWAixleTn3qtHMf KMZVQx6nvUcr7CFtLFLkT7nVpw2Iy3GxcHP61ZW38t1i3CWReBjn8qtQ7gZ0kubnb90q+CelXnlK uymMSlsZOMqB7flT9mh31uf/0P5zL7/S0RLOwQPFCFZowRv25Jds06ylgt9NuIjGBNOR50nV8DPy /Tp+Vf7Gez8z+CXJtWZi5+YEoVUtj0Y1LBPLaPcCPcDLGYy45wp6j2+vWk4W2BSa0IppSsMYWMo6 5XzQTvbPrUJwYF2xtvU5JzxiseRXNHNIsRSFcZY5Uc5NSahfhdGuothf7VG0BBk2pgjBz9M1jXja Mn5M6sPNKaR//9H+MLxJcS6Zr91ayQRGK3kZVZVOyfr/APW6VgwxAq88wUqxPyHoor7vjf8A5KnH f9fZ/wDpTPm8gd8rw/8AhX5FGGVAZZEUt820HGcVZiMDTyy5d1VfmYr8ygDnAFfJt2Vz1XuWb57c pbyxSh4mX7pGGU+4ohgLwmbcrJu2gYwVx2rmnsy4PoannygBXj8kAK6RrwrYq2ddvPIa2tpHjifA mQNxLj1H48ViRd7H/9L+MuK3feJDMpAUM0ZPTNaANvdQyxR3C85jcKCskRx1FB55zd7CwzDL80UQ wXz/AKzHeodOni3GALgA43gcjtU8kblQ+I6CK7uIGWDb5kYbKHocH3pt/IrFvNzgkY7iolCyuip9 ixbwR3dpPMsio9upQQBxGHCjORnrmpdPdp7Rm2bISn8Y2sh9PrUWsPmtY//T/jlttUeymQwsyyL8 qttznHvjFaTX4hXzJJBOXJJD/Lsz6Ada5znKbyC5VZIhgMc88Ec1k3d3KLiNX+QAhBs4iyeKAOkt dEjm083UFzJJdsT5ts6BUHPG05qsLeSFGjlRYyozuYgAfU0AY8E8dzNMlvcGQWc3kzlVyqMQGwD0 PBq59pEdwUnLNgDa6jORxigcd0f/1P43tVniVU2BiWwTxgEfWmwSCYxRSsiFuYgTj9a5wNBLTa5X I38Fie9WbiJFgZTIu9h5cfPzZqZNpaAZ+6SJ/scro4EYdihypB9T/npUy2sbOvOSPuADOPxrEuEr aMeyzCcRxIHYKPnJwB7VqtDLAuSCGZRu570Ck7s//9X+P+AkYO4gejd6tsFlQucrsGF7Bq8+3QSa ehSeWSby7fYUUjEjryXFaENq8dsAzbd3AbGDis3DsPYW3blkb5wPlYEfWnTpF5flRNtc9CRnH4VP JIx5m2W7qS2a0hgeNQytu37cugxggVBaGKNy7AmNuFHpUlOLcUf/1v5GbllVSFQbT/CahgijlZAo VccsCcV45hZlqR4lbyldVYLuZScYGccVYtnU56N8v3z1AFAcrElRcFcjEvC7j/Kq5torKLbHGJt/ O88bDntRsaJuMdTc0tA8ThyuzHzDOST6fSlkNxPcZKRQKBsjiiHy4HA/HiuctPqf/9f+TSB7yS6l gv8Ay1tU+aKbPz+mMVrafdW1sHiiYSyhtzBcFgD3avnmtLG19iO71fTrhXRzLBfQt9zAMIXtg+9U bd5PMmntrgxzTxeQ7/31HO0+3OawKNWAwxSZkHy5AkcLmpJZofPPlXDMCmVTbhF/T9KAIpFuAY2Y h45BkDODx3NXLJpYss+BHyAAckigaTex/9D+WWxtBPN5qGQ75DsODtz0x/KqLw+RIyTkO6TNgt3G eBXy50Fq3mjkvghZkCx7jEq/u8Hjkkf1qW/mtUljt7cRmcEvKq8FVPcn60AVJArfIT7ZB4FQxrGp MStmReevK/5xQBpSACJWMu1kK+YW5yB1Ap66gkoxZS7vKbZIcc5HUVKbdwP/0f5aLgvCGdkGGHzh lznPUGm24uoYFmtLb7PFdORMhIGUB4wPQ4HFfLnXGVtGXQzspdTs28DcMZqwVd7dpGYqI/vNjC59 6ajd6GkJ6mfb2pWOQhyyu5dlYcHPp+VH+jQqm1GZlkzjOQvvXO1Z2CWkWSx201xOLoSeWV+XYOfM X0NM89muWjeArHF9x1fO446mnKPKzmXxM//S/mN0+6tJE8q8jlW2QtHKyrtlGM4Iz15x+FV9Mla7 adpGiDxyEKiEkbM4QnPcgV8eVL4mPuYr+4kkWa7eKx2oY0syYZSFJLZYdc8cVDa+I3h1J7D7NeTW Uw8y1eRCkjIOztggP7UElq22ana3WoXUUkcccxijtpv9aQDgEp25H61dsZRAfkiyCMJuGQPr601u NOxoxXl5ZXCSQMqoyFPJC/I5PdvpnpUkTSFEN2I45s5cx5Cde2aiorK3Yxu1I//T/mtktTfNIhum hi2ZjkUAspHufWqkVr5eTMzTKq4DMcEketfD+Rtf3bjllincJiOMuPLT+EA4xmrN6J57F0d/tDQD YIgdwHb/AAoM4ysYiSzW1su9JWnikz5m3aqjqNre3NaNtdLLGsjRJI442yZHPTPHP/6qBN3dzMjg l0yUz2kEl08kxkeCNsEBiM4JP6VY1gXrmPbGyRjDM3Vs9hiojFpsR//U/mZtL+5sDHBdRK5vIv8A Ro2b5177vX8K1Z7SSeJH84Jk/vM8AD2/z3r4a1ncBkUCqgjjGRnAfFXLLT7uS8bIiNtHDuLLLmVj 6bfT8aYCma2WX7MFZZQejCsu+W7hnJt2ZSy87RgY7g0ALZ3BKKpHz7cyk9AR1xUn2lhJGoCmIsfO kz8wUegoA//V/mfEEN9HdKRKNrfugw27uOMGprffbKNyO7hdiopztr4cCx9rmhf7TK7BtuwqygbQ BjOfy/Kqss0F4zwPbQ3UDJlbhXBMLg9CP0rB7saV3YrQSrDPGBuVAcM687R06Gr0dncTfajZzSLD CeG3Ybk/wjrjnp2pW6G6VtER/YkG1JJmj42mXrJ+HvU2oTf2W0UQW4nt5UGyWaDYspIztHNaqCtq B//W/mVeGSUNcCNljDBWMakqpPQVpwajJcRR2118qW6FYXA4K+hP+NfCqCTudBoW0untZyQyIXeQ +WrEblRRg8HqDxj6GqwS3jWWMIoRm3ZUBQD3JH4VQEelRjw/Jd3VnN5T30nmS8b1bnstaV4Hvs3t vFD5hX98QNpnI9fzqZK6uBzFj9pgmmbzZUN5zLA7jy7MjA8uPvg4yTnrWjcQSJH/AKPAJWwD5kh6 kdRmsQP/1/5sNQjtJS15bRNZG3tE89ihYzFF+Y59+f8A9dYxWGaVSkEZ89x9okAw7ADGfc8V+fnS 23oaV3HZWt4jJuQiNUTcojJ4BxiqdzP5dxDHI2wTk+WSMbuOef8APegtxlYuBZYbkxRxJkQgfaYS GSTdyQD7cVnT2RsDeajaQh7qQB5fm2yTleAD788UWJ5GU4pTPcG4lt2tpJACYnzkY4zg1PcXGoi7 sX069Syt4JWN3tiEktyCu3YDnjk0BySsf//Q/mitjKJFkARmDFshdrqPrWhbxiVZA7tIzOWBkIJX JPFfApLlZ0tW0ZTWO3ieRrmZgtucyMqEhfpSSyWcQY28kksW8mR2GJFyfTNSCV9EPlS3R0ClmhkT IdhwPrWA9lZxG48pE33DfPIeScdMUFKNpJMljadg3ljcYRk5GT19KS3knaV0aXyhuBKkbV57itof CE/iP//R/mPnW++2bp7ktZ2hP2WaLIRjtOQQO/p9asWN3FqERvZmje4t28pt6/vWAzyOPb9a+Ei0 2zoFvGjkY3zgPKFCBj8smAOF+nHSs+HVFntWae3linN15e+SVWiZM4yMc5PB5qze6N2G+REljFpF OgQpKkxIB/EdO3X1rKe7s4FBt447cyXHNusWN3GeDQJzSdi+kks0ouJZGkVwI1hKhUXHGMis+ayk mE6h2sZ4pPl2qrqR369P/rUmk9wUk3Y//9L+Y9SkkiWzrDtVd29m2yuR1x/9ald5LYkRGEwuSWZe Ch4wMdz6/Svg59D0bu9xz3Vtc23k3apsPygg4DemanhghUxhGMgPG3OeRWYOTe4XMd6l9E4Oy1SL btK5bOck/T/H8ax57lrqXzJ4Y7iOGUNEjjK5Q5BP4igRKI7TVb+5udYE1ujIkRksbYO0gOAEC5HA B6810MU9laqkVrEGhgbYGnXZIqqCA2OeeB370Af/0/5nZL3zPMkniWMuSYZFH317En19qxZrj7cV t7WJ5ymXumXlVX1Ppivz9K+iPQMu3g+yzNAx2qTvXaMhifU/hW3DFZ3a3UTXFxFNboMJEg5J5zk9 sema1UFbUDSbWLGzS2t/LeeWRhEPLGXJx1PoBjk1Uez+13L38cccs4tvJhhZAfUfKMden5Vm1Z2K i7Ow3R7C5u/tEkpjsyqmJ7qeIOIxyCQMHJ5OB+tRWj2Ftqt3YySzXEMEGyKVhtuGlYHa2M/dJHbp k0jY/9T+Z2C2hcyAuWAj2pH1APrnrWLdyvFdfY4SI51XIjkOGP4dcV+fnsFeG3v45N9rOsybmNzK jbvJf+5jsOo/Cuj/ALStUhV4pC8sP+sULt2Edee/tj0qFLVlqbIhO1ywuImBjdcFWXDL1Bq5bvax 58wBlBy+OSv+f6U4O6LbtG5PFqc06zjTJsshMQ2fejxwTiuam1GMTy29ykhljQGOXAZZ2yMnP5/j VGJ//9X+ZhNTsbaBpXtA7qoSO4iTO3I6Nxke/wBKsxW6TW7BSq3Fzl2YKAwz0/LivgErux7BhRR6 kjG1jto1l87yxNM/lQMCcE7j/n+dbGnWF1Y3cq37W73EDsI1gkEqHII5PQ4zWjgugEMV/JFqFxZL ZxPdy2ZNrLMfLUnPJJHp2HvUNy0d8iqsyWs1pCftUU52faHyeV+oIwB6VkA+3tdNitHkL7bmWLy/ OTJaInI/L/GpDame0NrLBAtvBBtW+WQgSEAkrkdyMVjJWZutj//W/mIs5xY2bR+ZLGs48uGEEgyo p5B56dOtW41miuMwqVtroeW/mx5BTglSenYflX5nPex9AaVrFZSTCCB4rV45NwQARjdjr6Gue1JF mursXyRpc7yBMqYZ/fgf55rF/EkTLRotQW00Omsx8pMHALPhMdiahvy9ujC4mNvdQ2omtxZILpZe mFBzx+Oa60r6HZDdFjTVTUTG99fMk2AEBBRXHc+ufbtVw200lvqF9AbVoLKUQpD5yi7nYZz8nX0/ xpWsOUban//X/mGgv77UJbiS506JYZoY40Zy3mwYI3EKeOdoH51pvp/lqkayK4liMgkQgqh7JjOc +tfm59TZ7FVbe5NrFa+cdPmjnLtJCwKz56ByRx+FSfZARELlvKaGfe0wbevHB6cEYz+dBrGPKQ2U cupCd2jiltpJdlkYz5sThTgsT9R07YrsZmNlaxwWiGV1jzthiOxWx3/LrW8G0kwn8JmeFLk3q3S3 kTfaJpWgVZiBEGDevfHTNOmuL28SaG3s0EltIY0VT8kq54J9O9dNLoXRaSsf/9D+cGcwedZW17bR fZ7bahyBw2NoOPrx7V9e/Cfwy+o6fHDbf8S+2WMxyhTueVUQfOB0+bPB9a+98E4ylxBUf90+c8Un /wAJtH/Ef0Sf8El9LjuvG+q2tss8cmk/ZZLdZVLl1CrHN8x7ERr0r+jL9otooPgz4vkt41jNlpTN MYgMSBImxGSezEBT9a8zjB+08Q6sf76/Q+xyL3OC6X+B/kfwffGhRF8SfHssun21oLnU2WZYJvNn nlBZnMg7EFsenFflZ+1e1tHbQ21rcrF5sEVxcR210HOS+1lZf4Tw24e4r+suJpKjwTVj/wBOv0P5 t4fi6vFUZf3/ANT8wNYs4UfyY0cxtK2N7biMHtXNQWmJTljhZMkHtg9q/iaq/wB9I/o6p/DP/9H+ JLTGSXbGrIQx5QnnA6nFdtG8tvF51qEuLi2Xz3h4Z2Xodq+vNcFY1hsNg1C9S1nuoIn8pV/1U37q VMnGSp56/wAxWlYL52hz29zJDaajqkzWpvJI2nVIn+ZSV9FOfy/Px6zuaxdmfSfwme10zSX0vWzb zX8iKlvqFip8qR48k5U8LuX07r716Te28lvLFe2N9MIIyJY1kAMiP1JPX5fQV51XrY2NTTw12y6x cuLq0afyZJVYDLgZK8dKdci3vboWYVS0kuIkByVOf4fpXA3d3OmgtGz/0v48p49WmsNN0uyls7Sx vZnitH3AX84VQEUg/dx6mqum3F6wRXlbZb5tBHIAfMZSMtu9TXzsl7rBqzNeaTSb3UrTQ21F9Nvb wFYZFUglwpIAOCM8DiumitNZWTTYpSLqCwXzfOeNYGcgYDPjGT7Gppk1PetY7aSK0FiXeaSO+jiD vHHF+6dicjDZ549O9cprGqzSJFYTaeo3whPtT7kSQE87uxOOfyrojLZMzad7HM2emaLo512PiS+N 15lrfwTAWe0dcrj+Rrgru5t2s7y1uLdrhJHbY0iYYk919ua9Cg7NIzlG5//T/iXnSSBItsBUb9o8 w/MVBr2T4dajpdte6Qt7fTwSzajHbhIoQwiBdCufqRj0rbBztjaT7SX5nHiYc2EnHyZ+lFpNc6Iu napaG5uYJrOI3IvCH3Dy87wPQ4Ff1lf8EOdQtLvwnpUg2m5ubkXkzpMdluyR7kC+gfzFyD0xX9ne JUfa+GSktuVfkfmfg9JUuOsVTfWMl+KP2w/bViubv4M+J3W0hnkSFpYrtWfzbVhhDJHtP3l3huey Gv4Dvi7fz2fizxpDPfXMsUXjO8igmmjO4NIy4iJ/3t1fFfRulpiV5fqj53xzThn8PTc8Amur8XmJ ElSWIFJLYZLbTyGA65HX8ahvluvKkfULpXdYw0MboUmZc8AKB1APt0r+vKdrWR+EOSWrP//U/A+3 uYbRrySexn1FbezE9vGPlEch5Rgv8WMcfhTNN1F/ECCS7u5WjCGRZpY2Voxn7qAjt6D0r/VmW7P4 Ug1axpyTWmbWxa5uLmIDCSSw4bYf4iO2K021FEsjBLeFrHzvL3yAeblcrjHXPtWcnZWN4LqM0awv UjErSP8A2SZ3kgiYFWi3HJ5/CtXUbmxa1dlVEEREaMOWJziueU7aI6qce5m2+kG5kF67yxm3iKxR I221Ibblm9T8ox9TQdOZru3nV/39pMskm5cq8f8AEF+oJrN1LuyOyFOx/9X8K1kC3lwfmkiac/Zz u3vtBPB9D/hXRomotaSLZzlbdX3OpIDhj3weePb1r/URzfQ/jpxtaxlQzw3Lz/2lEs0kJEBgky7S r/eHYAn8a6BjYS5Vo2sNNhj3okRM23A556nuaOYtQVtUUpLm0SBJtPs/tDw5bdICqS+hx1qzo1xH e200F9bi1kU58kNzhuhX8v0q7p7MpRS6DHvv7NvIoo7KSe3KEPIOFzxwx7cZ/Kp4wkQTVTB5qCXb JDG4Lgdemc4qeY1UVy7H/9b8XLu+t7iMSCE26S8RhQUCkdM/kcjNVGt9Ts7q3lmuBawTIk2YXBWd D93I59/ev9Rk/M/kHk97Y6WaxtbsMS8jTyAM7JJ+vtnoayLjRJIxNMptoreUbZlRT9oYDAB9D36m lJtLQaXv8rLWmR20kEkTMiXMEeYYsHBUcZP+FamnWsk1vdW0Ej4uF2TJEfnk5yAAPTr+FJSlsTNJ SVjgNVW8N/Ekc0jR2MwZI2Bi3svQP612TWVjarbaldXXmXIjVtsMjskDnjao9RxzitG/dVjNJXeh /9f8YdP01r7U57pUM73DHaD7c5OfYV0MG354hsZojgpxhK/1HTdz+O2klcklt5Z4GT927geYvlNk D2OP5Vnp4be5kma5eSKAJ5yQIpWNnPYSfTrnmqTswUb9Dm3sYLKdphENNso2KMAGkkkO7G78faum Fhqk20aW8k4cjcFi8xljx1wOlVzaoIwbi9DXt4bgIpL7prcbiR3xWXql492kouLA3M4ukk+0R5aV sds9v/rU1K/Ulwa6H//Q/Im20m+vku0a9gjHlKLe3IKNk8ct06/yrA1DS7/SLjY7Cfy12ziNhtiP f6/hX+pLkfx/Gl1H6JiOS5WKQJJeOJArN90gYO38q7ewtXNyyzEIgi8xkPAn2jnb796XNrYr2Ria zp91LcQT2yyHy2yFP3ce5/CrVlHalbw3Vw0d4sWTG8ZdWzwAD26d+wrXmXL5nNyNSM9EuWi8tJV8 6M4ZyvysAfSnX1rqdw1tqCSK6WqmL7HFHtMikYPb+tZSkkdMI3Wp/9H8gbaw8yWZruTypfKJWLJw M4+XHrUNro16NQihs8R+ewVWxwvYk8dutf6jppo/kGUbMz7qxuXuzBHC8Qf/AJeVTOWPXPatyYWW lpZ2xUC+cHyiFO8AfeJPY1pf3bJnM1aRz2q2peaOX5mllYBUYbYx6nNdRFptiLK3SCJp70bnklV9 yYOMKFxxjnPrS5vdsPRO4yzhgci2vM2cTMUaeGISSQ5z8208Ej3qvbaXNLLMIP8ASUjBxO4CSHnA +UcAnviqi0mYzP/S/ILUdGuNOhe6uswjyDOzIN3ygE/0rOs4rj+zY59klyHIdWZPLeRTyGA47Gv9 T27I/i81Vmt59Oayt4ZnucH7RC0WNmDxj1HvVa2u5oreWxkh8pnIJUptLY6ZpK2onsUpdPvLmNbi ZIYJDIsaR+ZgoCcAgd8/zNbNvobRxNdz3ZLxAJtdfL3L0x15xReysioxu7E9xbXMNl5lnMYo3lDS QxcRO2Mbmx1Paql55xSO7Byu0JIlswXJ4DEHt3/wqIvVXNoQfNZH/9P8jdLkubOydAjQQz3TyxH7 SLh5x8vzPx8pzkYqzaatFdzT280DIbcja8sfEjdiPav9Ref3pM/kCKsuU0ruKe6traO3RY3jkZpT GMGTPTJ9B/Wud1Sz1KJYm05EuJlcb42O0H15pqaZTg0Oi0WZ5xcTwBrrZukj2+Yi8HPB9OafDpZl uUiKtGobKEcA/UU1LsQ49GjXlhK7LYoEAfYXK/IR61jyWrC5VDh4hJhpAOgHp6VpCXclxW1j/9T8 g/EmhQXEMImMssVtmVc4C4PUN+XSpIIZltrS7hWQxKipFsjwp2jt26Cv9UYTu1E/j+nF+12LVxK7 SJJiRUkwJmYZCnvx6UMltcSmLzMRoQXfbzz7e9OEr/edFWHLQ1BUtrN5bSFUmiMhzjDnBPBP6VXv o7W1l2FJQ00eFGz9yc+/rW13e5zKK5UQR2ivpwhlZ2iSTAlkO4oc/wBKJ9AjhjiihmZpYpBK7o/B BGR0+tSpIc4PlP/V/ISXwfBcoZWhWSe5kDF/uyuwAHUc/nUcGmEXa28sDwNbDyvPZMFcfz//AF1/ qzd9z+Ny1eWgG1gXdg/JBwPrWcLSNrq2yyxPK/lx72CI59OabkwLgtbiO5vY1bzIYwJCY+UXHHP0 P86niMsxigllX96G8jCkFQoGdx6d6FJmU1Z6Ep06HeHgQS3MI+aRsFs+3pVOIzXL3Acqv2fDPCTu lHPcD8a0V31JTS3P/9b8g7jUA8sZeMJ5abFfHEmBgcVSfzrjy5XURB22RsB80p5/wr/V1qaW5/G+ jReisriWaJWwscKHzAernt/WrkAghn8qbMJi+fgZ6dMVHPIzkorQsDRdF1GKee7+0S3MrKLaONwq cNk7x1P4Vz+o6XZpORayTRvuGVkbeMDtRzyKUY2vYdb2cNoPNiaXzWfII9RxVvR9OtJIb5JrfNzL N50UwkIdCc546GjnkTKHY//X/I29hjs7SaNizrJ8i7zlhkf/AK/zrH06wdIDInlRyBiyo3O/ng4/ xr/VtSk3a5/F7hZWaKh09brUDLeJJHKh37oTtDDv8vTium0eEWLXlxEs8sTusUSyYSU8/wBz075r VXQuWys0ZmqaHFqWpX99PcPZ20Vsqo8Z3lZAOAy+5/GueitLpreJ3iiZlmIlUnazp0Djt26e9W5P QSikzRa3H2faMQswIiYr0I71DbxK16I42Z5HTa5UfIgAJPPbP+FLmkErW1P/0PxhVFiud6xyGdZs IhXCZ5+Y0+8sLOef7Zd3DwyfKPlGcEH/AD+lf6xc0j+KdG9ixdXMzGO3PnXQEflxMSS644Vcc8df piqFyLmJY9sQNzEm5w5Cl/T6Uc72uacsex1ui+EvEXi/TYZrG0R7aKRlmtbaUS3fm4zgIOSce3p1 qjrHgDVNFUW+pWV5ZyiETeVdRtFcIG6Eg9P/AK1HPImUUloZElrctZNC8UYa3T5AFxJJ6An/ABrm JpPNt4zc24EkEocJt3Y2n5SPeuiM7aM55RSVz//R/DWJhfuzbmhIXcoYYP0x61onRpWjE9tccgZd mbYw9cGv9c6e5/DU9ynawRw+fYiRmhRi7bCXDMwyTz/nisizi3Sz/OVzlWjYcDtXXBaGPNFNks2j NZvbieRJEdBcRwxzAxkH2HQjvU00M8VvJPbJ5jAYCJguBn+n9KtRb2MW0tyimn3LT26Om3zTvlkT kqD/AHv8962rzwy9vNFf20scyNHuTL8xkcEFfX/GlYy5ne5//9L8HrpIkG6Z8TZyyDliKrzW0kO2 7t2lUqmPJ52EH1Ff7BRi2fwSpNC2l280mZj5vGAobG3tWqYobqOJHaK1IYsGkOM4HIH1/rWqSSsg 5ne5HG0kTNapcZts7lK9c+lQ3jx3OVJAaMcHHUimVzu/kZ+nwQxTwajI0rSDMRjL/umBPBI9q2rq xtdOuJ5bIxEMgkm8g5jy3JOfxrWEWtxSl2P/0/wTklkQpdxgyRS5VZQMoCOuDTpHtpLKSebIaP5i GXJcj0Nf7IH8Gc6MGTdePEyI1t83yQueSO1bh2uUNxLGDEoUnIDgUWMtjYiSGa1CNjA5VVGM/WuW kgfbK9uCGRtpQn7vPagxjLluYTRN9sMUjFZXXcN3etO/0xxDG7R/aVT7pAzgnigk/9T+fq2t7sMs DqQ4w3ynLKPQ1bzcrM8lwVMCgbI5ORkV/stGNlruf5/N2RSvbgzocyiNM/OvQH2H+e1UrSRdyxxy ZUt3PAqhRdy9NKApYRjarbFYDqazUeAziK4lAuJG+UYwqrQQ/jNW+2wpBIF3tGfkcHhR3zVFbmIS SCWQr5q53bfkj/KonFvY1P/V/nQjeKa4897mSUbisQbLAYPGD6V1NuxNu0cxx8pdHb0/yK/2Raa3 P8/zP0O5jtpXuZMsJJMKMlVfHpUerSnUL554QkcRbaIWYuwHrn/PakC02M2SKW2uYV/ePDI4Y9dm Rj8q17qGKRWWJ4wUUO6bhkE+v6UG70Rz32eZ5lXeqFWyuG2kY6Ypk9rNkIzkLn5pB1HvRa+xjd3u f//W/nZubm3thbRwTD92BtHG5uOpqtPKsmJIxuZjhuOtf7IWP4HWquT28cav++UMrH/V52g/j+FQ BpVv444YUjt1y5DDfvz601FvYa0ZWlt7aGdQrSMWJ3qqHavpmtMXDbo4Iwix4+/0YEVtFWVhuV1Y 1LGSOS3uZpLWSVLXOZFGAowAGJ54ye9W9MuorczNNAmy6AVG6yIAc5/GmXBq1j//1/5572aK4u5F gIdF+WNgpXdxz/Ws17RoNvmxMP7rE7g341/swfwdzR7m1aySzIltLveJR+6RuVU+oqKC1mtp5S6k huEdTyfYigxbvuZWpRyDgBuDkjOP0qGCzedUwC7SdFX5iAM/4U0m9gTszIusWtyYYWEkWRnI+ZWx yM/WpEhupmIjRNmMtg/Nn6U+WRfP2P/Q/m2MrxyyWxdllCgk9CB04rSfSrW7sI0ZZZWMgVooiVkf GCDke/pX+zFu5/BimupkrC0YeGWF0cOVw4wVI4wa2NOiIBMvyRA7Qd2d1S4Jlm1Atr84gG5g2wgV FcWdtAyTzxCYwt5gjkztJ9xU+zMpS6I3LPxZ4bvvD17p3iHSr+XVTcOun31ndpDFDHtwqMhU/wAQ 7dm7Y542KLyY1Bj2JsymTyR2qFTmpSbd108tP8yU5K6vof/R/nFE0UcBBYrLuIAAyCDT9JR4p4n8 uMwySbcSpuRvbH41/sqoJbn8DN2Vxuo2Ox3XKxy+YdqL8yrzVJIXhlZU+b5MnHQGk4diedWHRW7z ylGJG4ktgdabHaG3ndQz/Mdp3HgAVDTTsWXnthFH5sc7eWQQyryCT/n9azUgkEyCJSQnzkkZH40h XR//0v5uLg2sEzYUO0q7mKggo3Tn8hVuAqnl8DDHNf7IH8BKdty1d2/moZEQnPTHU1jTW024LtMe OXBXrQUpp6Ms2qySMYoPv/dZs4xmtQ2MkJjbeGaI/MGPzH60FXV7FS6hjupy8UKK+0KwTjcR3qNJ /s25JYBIcbeuCDVqHRkSlZ2R/9P+cY3M1rGoViC+VPqQe1U5CtxF5Kb4nDhiUYrkg55x29q/2QP4 E51bzGyZiiCTAMVbarIcgk9Pzq3BGJYFXCh1Y793DtTaa3I52WYbWOUzpK4BVf3S4yM+lUbm1WOP h8Y4YAjDGsnDsU59hunwR3vn2+SssSBh8vr0z+VUbvT4pIZrWR2hjORJOwyI8d8fhWFaHuSv2ZtQ qWqxP//U/jS8ZSpda5qSRypI9tMYLVJF2uygDcT75z+VeezC48srI7xq527APvH+lfccaO/FWPf/ AE9n/wClM+XyF2yqh/gj+RGglgCIY9vmMAAD096kF4tu0hXh1BQkHODXyzV1Y9bms2mQ53sixmRh Md0hYfKvP8NdNZvbw7rYh2ARWzt3Ieccn19q55LRopPsXpUbzhJjaBGCA54we9Y00kKysVbA3YBB 4PasbO1wP//V/i/tpHtYiJI3lEq7jMvIiHbP16VJFLCNotYgLmbhtzdfwoOTkRVlLzTJHKmAvykK chjSi08lXmgj3FSARjkDPNBSSWxfUM2142ZlKYKkcKazblr9UjttzS4fdNKVzvHp+HSgGrqxuwQS QxRtG0ZEijq2Tj04qtdXskaMkuFiQ5x9cVnNdSZRb2P/1v4zILtmZIwqvGo3KeBipLuUuEIAyV+Q A5/OsLPsc5rWU0H2ExynDqcNt42Z7VjTxOz+WmXiRss3fAoswNyDVTbDCEqhTaR6VXuL83sMgjkE jMCpBP4UgMq0tJYJCHBgRn3yYOPN4xn3rQdIvlAk+dm4GMgD60DitUf/1/42jayXLFN4wgypPFMh gOQLiNW8psxuBuZcd65m7IC9Pvj/AH0bMxAGFzj2qzbRh1jeZImZySsgfMieoxnvWLbe5EU7u5K2 nC6Y7wnl7tvuRWiunTWtukkajyEG3d1P0pFkUKJHuuXXzGUfc6E+mKS6vfO2uQUwNqrnOKBNXVj/ 0P48RcFZNrKzBuuP6VqLlo2gKuFI3Kc8rx2rzzOCs2Z9gPLm2eYzGNz97nAzzmt68vljspY0Bkbg 7gv3DxzQaGTb3Ko6qWJkYZfj5a1HMZj3qhLjk+tBKioj1jQxb2yC69QMke1MaNPJYNIcIOi8EisG rMo//9H+QkI0qCOAkH+B3OSPrUZSSNUDSATqfvA4BrxwsiNpU8zfLEDL9wynqq98VYF99lEV35LT 2ccnlzIqnc69OgoA3rjbqVx/owVYEQPEzfKYlI6H0qhJIVi2O4Kxk5I5JqZfCzKb6F7Rov8AWbWk QnkA8A1c3ILiMPJja3zFvujtmsSoPSx//9L+TW6wzhFfzC/8Q4UUk0DQ2aN5ADOxEcgGCSOvNfPm 0WnHUw5ossxkGHdcs3fpWtYRyJEIwy7GwyuOXrBqzsUWriSaD5Xb93tyvrUFpOkiqy7kdmIYPyAM 9eKRUUm7M24Bgfvj5jDgkHhfTFXxH5Yy/wA0TDhl5OPeg1jFRP/T/latbme2nd7O8n8naGW36Qhv 72PXt171Wnma6uW+07/PlIMaImEHOf6V8ud3Irl2WaS3gB8pTJ/qwAw3cetUYpUmLnbscDB7tmgd lsWQqRgKxwW5JFXrGFbkOIthMbb5GYDdjHrQTNK1yS7tUkVo0LSBRmRQOeOf8/Ss6O5isxE0CIvl vmQMvJ/CgyP/1P5YG1KW9nkm2s8cgCzDZhR71ftYxLJlXZgF6gcD2/CvmoL3jo2LMkYQBZQWyeOw qFHZPtCTuDA6YSI8j8a0sk7ijP3tBVkkk+98sartOBgU8wRCRHV/kYfOGX7x/wA/yrjkvesby2aL tvFuMgUgJEu8szAYH41UF3Yfa7hXkaOO3tjcvKYS0bEdFz74/wDrVc1oc6+Jn//V/mIVxM5YRgQO A2QAFHpUEt6UbZbomxfk3gYUY9a+PKmveOsvNf0S90vT7aLQpLTWIFWKe8WYR2UkSgAuyYJ3N7H3 OKyMRxyxXEMggmifzImU8LQSO2JJC0KF1kZsvIMZc+tJMskEB2As8a7gM4J46U07BsVLa+aW5jV2 OF5Kn+GtW7uo94MiFQeAw6GoqO5EUpK7P//W/mWj1e2Eiwqsr/PtIVCAn+1n0qaa8GGMO5l5HzDG cV8OaxV4WItKlsruImQNtikaNtq+WwK54H6DNW76aWCNfsu1Fl+Qtnp/jjjigXIuW5Gbt7bTyJj9 oz8zErjHuAPam20sE0KSRbV81cjb0HuBQZl23i2qZHZhtPUcHii4uopDyxKlcYPHSgD/1/5l5I4p PJnif95E5GTzjpx7VNNdrcItvtyVGXIOBxXw4EkM0uwqmTtGBkdPemLf3OkxJJK29eXdgcuwyTig C15zXc8N7FE86MqyqIly7LgHgd/pW3f3NrLaTRMJYbgpiICP53PTHtxmgaV3Y5yFltJkadRFCyBU WTIdmP1q88NvdLugO1FOXCnKk46Gg2stj//Q/maW21D7QHSZ1tEGxYWA2R45yvGeSasNcS20NxKY nmlC5iZThQR7V8OayV0QGX7bZR3HlTyAA+bGIzyQe36VJYiCCEtAixxux3gKF2N3z71hJWbKSsrC WT2894iqHyzFGL/LGv4murs7q10xzHfR7EY5THBZfXGKaVpWGYd3HZ3c7KspRAWeDHJYnoKzTeap J5lndkz2kBBs/NGTFxgge3A6VrJ2Qm7K5//R/mtSeQWqRSqYoWYbkQ7lLYxkj8ep9azJIGNvNDGx XeT5bJ1XOa+GWx0blxLlYIVjFoqS7BlmJJkOOp9M8VXeHeLm5RDAiIJ7iOJyRxjOMnPPHT1pgQQ3 W6U3MqhovLAjtmziPjknnr/hWpZ3lmYpTYs5BbMisThG/iA9qAMG8S4fUTeKuVhjEa4bCHJ5+Ud+ Bz710VtcQ+dFiWRYmRS0bkcNgbj+efwxWXI72QWP/9L+cq4dYyu0q8JXbIMYBFc29qkjyS2pQRo2 59hBA5r4Bq2jO6MUik8hmJluZGuPJPyNtLuuOgA9uldHaS6dcaZMZn23ERDQKyHL9iD6UijHl1UW 0caWqb7lm+aM/Isa+uf6Uxbx4Hgk+zpdiU4mWSYxrGScZ46/SgCHVo4pL9TKIogFwSH+ZBjOAe/5 9qy4rU20N01iVkAVpcTMTtYnr+tAH//T/mYE8/7ueLZG6wiKRDwH4xkf571YgSS2VpZJpAJGJ2k5 EZPXB9M18Ck7M72k9yrHNMYGZwAxc5G7crcnHP8AnrVC6uHjLfZoleScgTQodrtj9B/9apIpo0ft am0t4m0u9tIt5gZrkhlkx0xjt+fWoJVMcsDxJE1umd0ZPZe2PwOaDTQhtGtxdvf2V1viuPklhUko hU4xz9Ox7VZ1SRECP8g85ti8gFj6UeRlPc//1P5kYZLm3jKpDHKgbdJHOxUY+lPtwyNvhjijU5Bj C5jUNnoD9T71+frTY6CxPBaopEqmZZXGEI3EE8cDtWfNYCAhI0CwAZ2DnH0rSLkzTey7E87xyRwp 50nDCWZUOGkIz971rLSKO7vI5JN0ccJzGG+Xn1rQlxbk0joTJbytBboH+ZtrOGABxjAX3qvYKsQu YnRpxcuyr5rktHk8bT2qYyb3LjCzuf/V/l6t7UpMVlPmS72Ec0py8WT0BHbGBz6VcY3+ozNpu+0t xHE0qyEBGfb23DrmvhJrY9Aa2kyMhtJ49+5Az7WyoHU4PWulhFnFbi4t1YpbfJJsQthhxjA9xWVu g7O1zJv9T1GSWCb7OzRQuzOyZCsh4GfpUME0N0y20UC75CWDAEMenGPxrbl92yHGPMJLb3bOiW/7 l7acGYPHneozlf8A6/tWwWhMe6WJTOw2OwHUe9KUVa5Nj//W/mJnaC6V4xcPGYjjaBgfQ+1SRxNb qCn3ApOYxtMhPZvUfWvg4I9FK7sU5JYraYKVE08i7wqkMVz29q0pbaN2jkeMwIYsTXFuA00Y47Zr Qv2fYbDDp0CvdFiBAmI53XcTzj5vT61X+0JdSSKtwYYpom2SwdVJHBUisHuxRg76l5IXuLGCylkL CJQsjoSj3OD95/es++tbeO6inKDz0Xy/NH32H90nuPrSNT//1/5iLOQQySDJRMlwTwoPJPNSq8Iu LPURHDNNBMZfNlTczDsufTr+Zr8/PYLdmURtSS2hEUl7GJVIQiAszcnPrgfXmuX1FpluIdMtEjV0 mEt42DuaIjt75B/WsHuBoqSVCwuRjjbnAAqxLdwRwSxxTTQGSPy52QbiRnOAO9OMuUfSxPcWUCxp /Z8j+XcRgPPGfJnzgBtwHIqnFaJDPLKzqrRxgRtMokiHXgAjH51qpJ7CP//Q/mMfS7mwt7NFTzVv pjITGR+7B3EM47egqTSJ7xzezSCZ47aTyPNki27R1QJxyuB+hr8/Wh7Awg3U7WV5dSlGJljCkIYz /CTj3H+cV12j2EOl2V69xb/2nFMGbdM2XRwuEKv7ccVTk2Bx17fyG6GyCPaiEGbP7zOegFZk19HK 0cA0+RmZi1xfclRjGxMdOuah6ICawuJJJ2tIYGMl1+7iRhuOc4zj3x+tS6fYnR447aSeby7eVnOn EfuzuJOTnpg5GBWLbe50LbQ//9H+YPUpreC0vb37DJOEiP2ZYSXkt2JHOO/+fSktdSmgsLET3Etx b3BMkaMQswJ64TGR26ivzGSaep9Cld2KN/eGN7SaeFxG04iieM7ZWbPf862/MaK4nhS3S8aSLy0u Lj/Vw5KneCD14/Ws+W80VVWly1q1/Bb6e1ibJb0TypFcMThYY8/O2PXp+VVzaabDc2ly7OsMUZaO RgSh+X7rD0zj8q7+XlkjSErSiie7iKSrdwrErQoJI2l+WEAnBAOPSop5bTTtMluLW082S9vo2lub VTIejBl44wSQTx/Caze7NZv7J//S/mZuIpZ7OO5SVkBbcUROX5+6eKhsr6YTm2WyjR5SYkk8tjtb AyWOeO1fm59YpXkR2l5JPLdW15beV5cnlNv5346lfbpUN7YPb3gihmlnhusA+VIpithg447Z79ea DQ6bT4otJgtot8FvaQq2+NjtUZyeD655JqOO7urhGa1ufs4kfDMnKyJnpn3HetYbET2NL+zI7Wx8 zzQxLeahZguc+lLbX1vZLL5zqrEcsCG7ZrsohT2P/9P+abQ7pda10t5MyJZXkbxSOuRNz94KeoHf 61+gfgRZ4NOhazubi1W9PkJJ5YUHp0U8enFfpXgdTTzuu/7q/U+X8UE3gaKX8zP6Nv8AgjyJb3Vr y+WyupZbG5azup54vL85yYVUZHBHG4D3Nftz+2RqDaD8EPGN95n+h2ukypewMzL5zNECnTrhsn8K 8HiFKt4jVF/09/U+xy9+y4LpvtT/AEP4X/ilqGl69418Va2LmeyjvdUkN1eMfNRnb5j5SdeCSK/I T9qETy3+k200cdwZpHvLy+iIii0lI1YKspH987TzzX9X8ZONLgutzf8APu34f5n86cKxlPiSLX81 /wAT8/dcnkaWKNWKzYOTGuU2ngEd+xqraQJFCquZHnZsO2BwPp69eK/iaov3jP6JqfAj/9T+Jixj tImAtonwUwbp+HLeg/z6V1WleHFl1PTdQtdVubS+BZJl3hLY5+7u6nB79MV59foa09jS1bQzJNDd STztdxyDcFn2Rlc8gjoRx+OK1IsCARSgnKnLY+TaMd+1eNWRvBa3Por4c6ZbT6Bcuhae8s7dLmM5 DRXBLY5b1Hy16dpIsvIgvLu+EktzGYJtMK4Nm3T5sjvmvNqp38jpglylW/tLPTkSwt7p7Wa7la5i tbXBEndi/XGQfrj0ojsmcJdF/JW3G5l6S9McfnXAr3aZ0UYpRZ//1f427GGKa+sY79Jxb29w/kmM /PGQpBK/UevFaIgNxculrH+7inIaR+MHkfn/AI1889glJXuKuliS/ihuYd7W9yLmKRGwYpF+6wcH P5GvZdSsr2fSLJ55gpuVaQ22fmMfQHd15INTDYCpYaYdTeGwmuZbV4wCl00/kwBBnOf896076zu/ s8OkC9tdX02CbdFMf9ZISPmUSAbjjOPxHtXRFJpCe9jxcaXHp93reltM+rRzL5Xlyxt/oodwwIPc 4GOOmaxNUMGjSahLcxKywWgNta3ETh0ZgNzDHscjPH9O6huiJ9D/1v4ndTvX1nyVt7FLYhVES+ay +cwGMknpu/KvRPBFhdQ31jI0FnJqUciyQwyzbk3qcqqnjJ49vrWmF93Ewk+kkROKlh5LyP1k8N2l xcWWiSXjRzRtZwtcxTQeTbxrtCoqDuMbceua/pq/4IjSQW2oWukLLGYAlxeWCRQG3jTbcruR/XYI lAz1ANf2tx4ufwr5l/z7X5H5Z4TxS8Q8TT7KT+5n9Dv7TWkWet/CzxxHM8kcVjpNxd26pIImkwp3 xj1yAOK/z7vj9rFvZ/EfxfoFrbXGmWqeKJ5UuNRgBi1C53M3Bbr5aspJPdx7V+d/RtqfvsVT6W/V Hg+PsOTOKU15niVpBdsLu5hiivtRNqyfapfmfef4h9fX36Vzdpq1vrmrPa3enTRXlogt5vLTdE7q OcHOecDOOBX9h0o20P545ny3P//X/EW8khuoHllsFtzCS6mABVIB6MMeg6VgyzPqEdrezxx29lGR YW4tY1jMpXJJYDqRnkn1Ff6stWdj+DYu0UyjFbtFNM9zdO4t12x8buMngY7cmtmLT4Z5Io3iURMR IZZnAUMOc4Nc8m+azPSpR5qba7o6K9ufLa0tGaOfT3TbJGuQyHPBB6du3rRrNh5kGli3sIYoQWDy xxfNNnBDO3cjBGaxnZHZSg7jksL26hSyt4meNwFaOMZMmOhNOt7e5N79heL5EG24BXa0foM9utc0 pJNnoUqbsrn/0Pxmm0uztbWWCKOBntZ2m+1NbtvldgDgNjkd/wATzWvpllJqVnZW6WpjmkjPmiP9 2ZCxzye3GK/09549WfyG6U+xft/BdjuYJDLBLsxcC4O6RyvTk9BWW+iC1ur1J3iubUJ5SKqlRGCO e/JH5VMakXK1zV0pK2hVsoI5Y5UtrZ5bW3cxyXGwrtHIUnj1xUceiajBqP2hktJdOkiwpWfNwp5/ gHpx1qvaxsV7Nkg0e+u3lEMMYh3hSZn8sjPccc1sWuiLasqSQEtJ+6Ys+YeM42+/XmhTizSNOy2P /9H8iho0677F7c3FrvNwVKbhCCcAnjgDIGferFzoFksUYYAzMpSAsSEGQRnPtwRX+n913P5NjT1s VZNGvYpYhp8LXTRqFupACTjGccd6vPp73uyyiDxqI/30rLvZWPXj+XPaplNJaGnsVzEcPhu9eW4h 0uGe5u4htSBrZllmYDI+XByCOf61Zh8I64ILGRLeS2XUFL293nESyK2x0cj7u1hg5+tZ+16XB4dt 3WyNqTwXLc2skep2bJqdmoUyQJ5iyOP9ocsp5/Tis208JXDrK8tvGZUOy3hJ82R1wMkpjIPUY56d ulL272RMsNa1z//S/KG08O3IjuHMRgWFjmLbiV+ccL1qOXwyyTtLErxI0YMgJ+ZiBgj/AOt71/pz 7ex/JUsPYr21jcWchNjbeYs0ojuJN20QjnJP+HvXTro9zd2bR751gSUsrqdjtg/ePoDwMA9qFXtq yFS3OY1HSheXEVm7wtNbyq5gdsF1Oew7Guj0rQbnTImjnYNJeM0lqbS4EwhXGAhHUdDweea09sur CMWlaxjC0v4r2OCASPJHJmbCfwHO4D3x2qxZaX+9vGsrS8mhbfdxpcR+TcMozyVPQ8dKr6xHuL2b slY//9P8m9MsrjWIb0XMF7a3VvOoiVYjGoAbcMnv0HT1rRk0R1idLmJpHc/Td2r/AE8dZdz+R0pd UTWXhezitbe5ksoo7pZW2XEv7wMM/Lt64454/pVu7tp4NOlvgypMrhIA0RcpzyfocYpKsnuU4S7G pZxajc2U2bTyFWIeeWi2mTgNuVj2+lcvcWcauZVljEAYJM64Zic9DTVZakShK6djYHhq3SLznmMS sQEMgEa4PY+9W4dLeBfJjTJclot/G8Ac4qXW63NY0pWP/9T8tIrEtcTalMtqsltc+QsLShi57MyE c4wRjnt61HHY6xJdSXCzwRRLJiL7PnzEGOS56c88Cv8ATuNVWP5KlQk9LHSvDZPDpVtDaSmWPLXV yRvFy4bk8cAKMCqOseGpLu5kuYYoxI8u6JNmNu7stUq6S3MJ0G3t2Gr4ZFxcXFjJbtL9iiSQmRQG ZmHRR9Qa1b7RLPS7DT30yNbfUHjaWZXiIWCTORvPccDI9jUKur2QvYSUbtHPx6Nc3UUUN1Bbzz3E hMksZ2iUHOceorQg0JdPklSPyYbeFyn+jMHQuvVffpz3q1iEnboc8qLZ/9X80iYL60EtzFEqKvlG NsFCMlRkH168+tVbTw5cxiOGK0iaWRtsEEQ3JtH3VUfTHSv9P3i4LRs/jdUG9kXoLHSbmDzLPTrh LrzzbXbrGQyMDhlAxnqOnapn8FtfTuwiFvLp8PmubhDGkgPIGe5GCQBUPG04LVlrDTk7RRUuvCxv zavPGbi3tmEarAcSRgNncmO4JJ/Gmax4Fv7+1Qpc3FnY+d5ZilhVLi4GQR1zgHjkepqlj6cWk2Ws LUknZFm28MS2GmSWVxZlk3K32hvnaJRyOnQdc/hWDJb2UFrLYR2Hks82xrmdC0ThjkGM4wAeeh9a KeKhOV0zSFGdPdH/1vzHi8OW8dsZI0VTEnMMY3Lx95tvrTrvwlHIkUgR03FWjmTiMkcjP/6+1f6c fWIczP5PhQvqTWGnXlpcxWs7IJ3fy41YACbPTAPqK0Z/CtyZWVIniz0IH3j3IFV9YgnoKVJtWsVh ouo2/mmcCJipCEHcG7DPpn0965eWyuLbUFiuZ0iWWHKeUwMqvzng9q0jiYS0Zl7CS2Nw6dcXWntL b287rkRiR49jNn+JCePXFVrbwfqMot2tRIu5TuNyckMeR2qo14LRilRlbY//1/zPg8Na3cz3Vvf2 cISMDMjyqsE4yQQAO+B06c1HdeHriK5itrC1u2hCAokahrZGHGB/nvX+oka8U00fyTRpS9soMoJp l610be50XU4iG+WWSyYQSH0WrZ8JPLLMJ7S5j82NlSJVMUkjBQVIGOQD1x6U6eIio3bOydFywrt0 M220O6iu/Kh0q5wtv9omuXhPIBwFPv7VpT2gjt2eSwe6ZQsszNEf9GjJ4Yjt+PpW7xUOjOKNF2V0 JqFhaHTZmkQW1ihGJgFVWyRjDdN2cCk07wvPaxG6RhJZzWqzCSYlZYnJACuuBjAqfrEV1KnSfKf/ 0PzWitp5YNyW8tw0C7Wlt7dpI8jsCBgH2q5b6TbS2Ul4kFzcXjZR7cw7X4JyBk5zX+pvtl3P5CdJ rSxkRaBLcXf+kbYrWVQbaFFzK5I4XH19KivfClnKIJf7OO6G4ZI3ZNmJFOGbBxyP8KTrR6snkaei M+60aa1kktEgkiu5OFl2F0lA6hWHBH49607XTUU2jSWv2h2VontUjbeSBhcEc+p/ChVo9GZTpO2i J/8AhFr/ADDd6Vp/2VjlprORPL34HzZ7k8cVDY6Bi7v759PW0ku8LISpjEpUY5HX/wDXWixEeplG lrsf/9H8tW8OpcJM7rDCsVwY5GfhV+boP0/OrF14Zu4TDF+6hEsmyyDNuZuw49Tg8Cv9UfrEO5/H ipNIZc+HL2yt8zSLtc7XkX5XRuO3vVZfC2LqK5u0ne5mi8t2YkpEo5Ubc4BOBzS9vHqzJ03qrGcv h2c6wtotwd0Z89Y4n2uFIPBHpyOauS6SLe5ZJY977cFXXLgdiR+HWn7eBSpyeyLS6GWKLEgA3hQG 7E4wP1FOk0e40+5VGgAkkJVSgOJD3A9aPbw2G4STtY//0vyo1HSpZtiBB5m7mJzhvw96saf4fu4I ri4u7SeOGLgNLGcADqVPTBz9a/1U9rE/jiUJWtYhudBu57hJoR5a9TkYNXjpN5Z2txfwRfaXtUyE VdzM2D0Xqfw6VcK0UHsp2SsZD6Rrd5NbtdxrFYsPtN8djebIQBhFTv1PPatCTRUSNJkt9sbMVhhZ Ck8Q44cY6n+laqrAz9lK9iE6bJNBc2rW0TKy4DD/AFsPcEflWXZ6HdW1ykSwywiaMmGRkKrNjjG7 8/yo9rHoKVKVj//T/JxvD9z9mut6ZvImOwLyMHp9e9UrTQriVQtzExki++wXkDscV/q57VWP4xjS kloXtW02W3W2jsIVLuyiWScBXA/iIIH6VBLpF7cTRxPZFfJX99cHOHB5GB+dSmldsv2UrFTyL/S5 dSgs3kt7fUQrGK3laIl1XGc56j1robbVdSg0y0iv7zUZV8s2qCZnu22NnjnJxitIyTJdOSRzd1ZS WtzC4LS/b0PlqMlhjIwy9icZx6VxV9JcpfeU9sLaLOAzN88jZPAFa1JJK9zkrQagz//U/E6408Wz xzEJ5JVmkHRy3GP61nW5hvkIhvJEEdwR5TZBbBwfwr/XOirn8LVW0TGFtOnEF0nlR3PEchOC248E GqP2LyL4REk+b8seB1rsSsrGBnXmnSWt3DcRRidoHYOWcshyecc9OO1aguIQRLbRNCzH54IFLAE8 EYJ6fWulKysYz+IuCdFdhIjpPKBEjDsB229utVZryeEG0hUr/EpkPBJ9KCT/1fwbvbO7+0xXLPCi O22ZnP3PQj9KvLLhTZmcTAfeudowRnNf7EH8DlKWCF59tuwVhgEg4z71JqMVra7GidrhyvG/AKnv VRjdivrYyrS5m88BsdcKp5FXVglbU3lmi8qNkAMZb5OO+PU1qopbDHzQNLcIsboluWxkcBa6K6sr K20xra5YvFcxFZHRsF854JB/yK0jG+4H/9b8CLWBhabULJCp+RM5VFBx0/CpZ7u2hZIS6+WY8SAj CHd71/styRP4HJ71YraKC5aBnWSRUjdOiDBOSP8APSsC4MMsxZAzOflTB+Wp9nroZz7Gxpkl18tr IRsJOZTwQOyitoxxwzG18rCtg7uvPHWn7NGZi+JtDcfYdQsLq284NkxuSBGR/C464IOQRnvTY5rq SGTCKW2hniQ5RW/2fYc0lT7gf//X/n2juLsXRuWmdGVfKK/dAHpVaWe8Qsl3ILjJLo6xiPAzwMZ/ Wv8AZg/z+krqxnSym5KgcMn/ACzA4x6k1WG0ByUMaI24dy3emk3sY7aF6K+ivITCN6EHIJ+U5Bps iSJIHIVlXuBzRZp2ESyX99JstYIoWjYbnZx8/HQDPHrVcxSGS3+1BYI5jsYseM+maVhptbH/0P52 7p4vtcloLeGL7MRETGNoXjjJ7k8c+9W7TzYplF4HFtEeccsy+1f7MWP8+1PuRXM8dy5+zxSxoCfI cx7BjPPHr/jVe1gktneWQ+eCmwBhyD6/WplG5SkmOeSRcM52hj8iGoprdVnxuSUXAE6Ov3k24Hze +QPwxUKD6mvNpYsR2chhkuJ0CkH905P+sA9Khku1CokSF5NuHGM9K0iuVWIP/9H+caKCGYuwUqAC wwOFP0q5YSDKNtztY4J7YzX+zB/AMW07FmW2ld3dpEVixaNOn5VZt3iaAtLG6NAcHKFST6D1FBpz Wlyl20ngRHu/LiJUGNkcAkZHpVW7s45Y2uLYx7tmVRjtKZ9KpRbCUrbGdp95PBbXVlI0qR3CbZYe QGx7f56VowyiOONHBeTO1CewNPkdyj//0v57Hh8lzKqxuANxXOPwzVOS5Mo2tncvzKincqn2Nf7M 8rXQ/gcW0a7myXmMMpcJAqgYxwMHNW9V1CaxdbM7Gki4lnXDLuHBA9uP1rRQVtQMT7S91IqKA24H dISBz2GKuQCaLfBGfIuFUlSvQg9R7ZBNWlbRGCdnczodIMsV4oj8uSNgUJP+tzySKmsLO6sWdmbb 8vWTqfYUGspW2P/T/nYklEzDzIIvmG3cijcMH1pEmihlKo5RWGeD0P8AkV/tBY/gZO6ujKuGWKRV cmV3bO89eTzk1OnAZWBEfXf6VLgmMv2cyRuDFhio+ZgKlvbprwGNSC3sOQKn2fYV0jD/ALPD5JyA hzu6Hj2q1GXxtZt2Thd3Woaa3BNPY//U/nFa1VmZox5hHL5/hqaUHykReo5Ur0r/AGbjDufwFN30 RVjDyS5ckkHBJ4xitBoFbzZIZFYhNrhcHB7fSk42vYgpGaRIiI4izlghkH/LP3qG+y0cJDEFARIQ clye5FSXzWjZFO0R0LRqcxli5B7k1sCIpGshco5GFjDffHrj/PWk4p7kH//V/m1ureTcjIjNu67R 1oj82L5XYrjjntX+yzimrI/z/Li3ckCxojlzuzz0X2NbJuLWeMFmBfZtcHsfQVPs/MqKu7HP3JjV hHEpwxyWVsEVYWcRoyPktjg5z+VVGKiX7NXGwuyxvJF95Oc//WqkssksSTBt6v8AOGwQR7HPNURL 4mf/1v5wLVEmQyyOPk6IeTxx0qxBbq3mNBjJ74zX+zFj/P8AMq8jNrPaSAlt1wEcEZVfQ1sNI0UZ aaMYGXVkTEhHGfr9KGk9GJuyuP0+IFftMTboG5CsCHHrnNVrjY1yD/rAvRMnbUcisRN62RfZ1sYl aONRNPy7DBwAO5rmtYdms7w3E6wgwtJE4B2sQOAfr/hXPVjeEr9ma02/bxXmf//X/jI8VTPNqt4z CNCsmCsfEqnA5b3P+FcekUsjN85kkbiJT3I6V91xt/yVOO/6+z/9KZ8tkL/4TKC/uR/JEU1o5t98 j3AvI3KvA4GEwfXJqpDYgOwKlpCMNk5QE18qelLdnSWWlO0aLHGZWQfNzwvelNnNBIC+YwT8wPI/ CsZfEzWHwk8lvKfnaRirDuTgCs0pH1CeYgkxvboTUWsrFH//0P4toHEyC3mkKKXwGXjI9KsS2UVu u9JVZ0P7uQcZqnBo5o7IyYvtFxLEVWUTbyPLXIMg6dK0o7udI3EbGNkflHGckcYzUjILfUJjcGF0 8suNwbd8pNblvKs/yLsmbaSVJxyB1p2YFCN52m3qo8tDhR1APvU90EkiD3Kr5o4XHOeetImSbWh/ /9H+MHTrKJIXZZGZZJC7sz52+w9APStO3Wz3oHZlRzhGZckHntQcsm0tBZituwRT8r8tgcNVyFk/ 1YTBbpkY3VMleI43a1M+5VQZRzCEG5Djdk+h9qhtIllViG8t3PVep96xGWrh5LXyVbddqf3TNj54 v9r/AD60QqQTCqqwPzBjyR3oLgveP//S/jVM6RzAsC8o+UleAtP+2eW7ZyoA3MeuAa5Z6RA0HRby NI1JXaQSVO3NOa38oBlJHkHcWzgn1H6ViA2C/MzlY28vGQdwwCRVxby8SE2f2ljaM3mtGGyinpmg aSe4olCpGoYsrZGQc5qAF5GIaMkI2DxigHuf/9P+QJxAsSfd8zHBH8P1qK3Z9oAlMxJIZm+XFeeB WnmNu7hIkJPDyg8471ZtJ45zhV83I2kLyATQA+XRzbMrzMQ0o3IVYFkHuO30pGk+zGNS745VnbgM MYoAW0nlmmeJWzGFwPbmlkla3nMcgKxldrErn8aTSe4H/9T+RK1iIkLI26MjCkH5TSTWiLKAS0jB t+T/AAe1eXKCSugKEsfmMYiFKOCD34qxawi0RgWaSNj8iP3rMTuloaLTraRXTWih5bpV8xTztx0+ n/16I4csssiBFfBMZOR7/wCfepl8LMDS83dmOI+Xx8jDgj/OKwRLM3mxMxOHyWYYYc81iXT3P//V /kcF4qqoQSSbQAS3SrMV7cTBY5v9UjZRQchc9cfXFfPju7WLk8KyREqu5SM4PBqaBo4IlfBVl6IR xUSjo2bRd1qV76QX8Iyu11bdj6ZpbKARdA3zHkEdMelZDLqXgeUpCG8tTsbPGSMg8VbW9mhL5jZ7 YjCuwAIPpj0ptWNIPof/1v5T455UkjZFQxyYGzHIOetXhbX8IbU7gxKkU5jiMTB5FwOBt+h618ud kpPZFSOcT3EhlRI2C7pGReXA6VZuLa3jdTblmMhDnjFBPNIdc28/kyOke8QIHkXO0qCQD/OnadLD GSkW9AyfvN+N+fX6ZoByb0IzeNGZV814pipUNyAO3NZH2mKPL3waRIgS/kjDvjuAKEr6IxlJp2R/ /9f+Vi0uoQkiwRyKZMBQy4Yg9Mr2rotMhMMU3J81TllbjGa+bimpajuyhczsjOjMWZvmXJziq8Ms u8F8NG2M8Z2/StUruw4NcxoNcKAQOYwM4xgU9Jo7iN8lB5Q3BAcE9q45L30jqv8AEULW4WW6ljke VEYghWGFHbj+ddAttBCnlxL5hYbndl+Y5FOXwszsf//Q/mCFrBEySWst2FkBN1BcyBo93rGOw9qr SWUMaOu8ojkuWU5KknNfHmk4vdDIYJnk3vLJIoAjXd8xUDgAVcmhlt5FyreWRwx4wKCLaXLlvdlT tjGSOmeTVgRXUse95VeRp9jxSYh8sE8bfUUmEtIJkn2WOPJOA/cjkGqFxc2buY5ZCwUAjHy7T1Oa zluiIK0dT//R/mPTy5PLS2EbMWGdxxmtOxt0d3juRkoSm1WA55718ZGKcbDTsVUsZrd5ljVRExLx ncc7ie4xVi20tJ5oodTvAE/1uYssi47cdCeODRyIOZ2sSXdtOLkiONGtQAIUxgcd/fNTWEKQYNxE BtyUUDKinyREOEhcvuwFLcDPSsmdbaSeNLgMFVw2UOGGOM00ktgP/9L+ZJIGlvLcWAEEUTM8qyuM S5B/DPSrstmbYAvGYWb5wCMbwelfG8ivcCRJlht25VXIwueM1UdIru2ZZFky52rhSNvUE02rgaOh G80J0nhm2vAc2zvg+X17H+VOmuy7LLcOZrh5DIZD1yTmspfEBDfqdVdZJmxKFCo+0HbgYzj8KtOI 9MtlVJUmDELu4BZj1yO3NSaxlfQ//9P+axJ5i2wMBvQ4XHqKrRSQf8tZpBMzGP7PsHlYH8Weue2O mK+HNJvSxoDUf7MhRSY5LctlY3HG5v8A9VZltHK1vcRrAoaWRp8xEsCCep/rRY0W2pTiFvBG9rPM BK6EKrSbZRnjjFVWh3W4Sbzry64VLl3LHjov04HPtRYDXtltLZIxfAi7EeYcAlEcjHU/jSNLhQkr 7icsufvVE9gsf//U/mjglWWLBXchH3u4qhLcDRbKecxvLYWyA79xknB5+XGOn418JF2ijosa1wsr QRSyoo8yBZFI6hSARms2K527goWRJkMMqN8oA9T9KpO6uBaSzEaK3lo0RO1sdMelRw3EdslzZw28 OyRxvcph074WmBLBIm9YeMSuE3vwq57sewqnNpl0b12muNscbbY44AHjkKnGNw6g+1BpBa3P/9X+ bexvLBodRsrli9xEvlNEW2PbuQMEDHI/xPpWTaWHli6Cl/NKfuSg+Tg9x9K+GaXU9Ajt5QI1zGUZ iRJkdTnB/lUrqsTYbI3DJIPFKNmgGXJSMApbCQyDbvUHK8+1Njt0lCGUZEThwmeQRzWclZgZWpky X6FrdHEkyrbqr7jjjcTxwRzx3wPWp5hHpN0zPaSXJuF8iFYPuSMASu49AOvJ/OpA/9b+aF4oFtTd zvsEQ3Mo52+1VrG7OqxXCNGn2aEiPGc5Jzx+Wa+Dhqmj0C55VvbaeYUhCrDnYo6/nWXvSJ4p4vJ8 1vklDLudVznisxJW0Renv3n8iLyzPGH8slOkYOfmx+FYl1cWtusjLNdvBE7JNILZi4LH5goHUc4y KAau0O0VoGZnghDQTQ7F8xShXkYIU9DxXRzWNndwCF1KNFys38afTNBEovmP/9f+aadbdt1srqn7 rJeQhScCsCTzbYZjYEAcZOAP/rV+fnbyKxPBJIHDO+5mUHqCo+laIuFldY5FPKffHCjoOa2gvdDk 1uU5LXBDoGxuzvFU3VEYs7j7vJJwFHrVW6Fhp2khMXt1JdOJJ2jt2OdijplUBx0OMn8cVYuLK9jV ykyeV5hYs7eWUQDn6mlGKiB//9D+YJLdY5smdpkzkscD6DFXVZIbiKZLcTS8plm2hAf/ANQr4ex6 N3a3QZdi9lmkYOLeZDgqp3cDtzTCbuSKMnzhPJiMwW5AWTJHJH+e9Fh391o0WhdN8TSH5Bhow2Rx Wf5Ei/PHKkQD7jNHgSKP5dqBxko7kyXM1zdMbWaS4nlTZmZv3cpHct61Tle5aZoSJBImVcKpKqRU yTasib63Z//R/mLjtMRKgHmSn5nY8YHvVx5IIvKtxNFLIUG8RHcq+2a+DUXFM9SCKjaXa2Vw01o4 ktlg8yQAeWQzYzuJ7g8cetNstTjME9qWdnEWd2MhwT6/57UQbbsaFUGcQyW6nZbsNu4NuLg9c+n/ ANapLOC3hhWHZuEJKxPtAIHbgdPpUNW0YGmpazMTSkCOcEwknlsdf5UqPZ6hdLarIpu/LaZV/iAH Gf1H50gP/9L+XbVZr2yZtKkgkkaeEyx+XESJyvAGRwDzVyf97Y6faR2wsALURSc4mZj95mPb6dve vz89gtm8vbXRxAiRzPbReWkirg/X145NVvs6GWG+WVVmeMBlblzxjOfz496we7JcktCs1vsDSNFI yNIFEy8CMmr66Vp9owL3U5aWQeQHPmmRmGSB6AYPTpSKJY54rMzID5jEfdkGV/D06daguZGlO7Z5 agjKkZDUGcpO9kf/0/5lJLy4EQhCCZJYvLORgp9D+lO05pbZZVJdY9vKbiwfHTPPPevzuElseund XRVeVXjmkKjcDhj0YCnx6gZlitre4njhiwzxO2N/G3P596062GQ6noepyWiz2N3ZQuZl3yXLDcIy cnYmeWxgfjUVy11ZXTW5R5f3aSmS3XekpI4C46kDH51jKV9gGzw21heWvl3TSahOvnmFRg2u7pyP 8itK5MpuB5i+bdKcSuTu6Dv69Km6OiK0sf/U/mPjiKZM0Zw5KRqnK/U8e3/16dFY2wniuWgL3YYx ws3zbBnPC9Oo61+ZT3Poor3kMnns0lGnXcCzhpSZrhzhrVuowPXn9anhWFZMAs0Z4UngGnRXNUSN mrqxLqMMS2rMw2yuQsQLbQ59CfoDxWLLfaiLQWFq0YKXCu8ksBkCr3ANdUlaSQ+RKojZS4aKyX7c JJ1b91GoQsxGcYA9Bn8qoyI0w8qxMuy3fzJ7XGyLOMKf1/Ws+VtuxUl71j//1f5rNHS/c2oYwxqs m+SDO9kPGAo9OnWpNWlWK4ed0TfNIWkdCAzt6kdq/N7W0PrYx5WYYe3uWCAyS3KoWkAG0DJwPmxi mabbiyu5VvFWQxOUWGKXHGONx9R/SgsuOsEzO1y6iGIFyJeUGB0psF5axCc7woQAGPokY6ggf56V vC1kRN2Vh+o288kG5naWJE3xLjKx8dq1rbSbZLuDeZUiMcbvJKA8bFgCSB39vY11wsmgg9LH/9b+ duz8K39nNNqemxiS2t7hP9NxstzvbhB7kZyK+4PCVzpj6LpljarevPb3Amn8yEYVzsDbQCSQNv5V +p+B8V/aWIqf3V+p814lvmw1Gn/eZ/UR/wAEgdCEUEuoWEklxC2qu9/I6gWk820xxpgcfIrKwz0I r9Kv289SFn8GNct3Dy2vkO96QgLOdjKiZPTLMPzr5XGfvvEia/6ff+3H1zfsuCl/17/Q/hg8QM2t an4w1q7dNM26lJPbaY8IKvtUJsQDudoJOOSTX5c/tR6toKyxzJb3qTanaqbiKS0MNsCN0ZVm6AcA 88iv6q8QpOnwRWa/livxR/PvBaU+IYer/U/PfWpIZ2SaOQQSrHtmGAU46BTWVaXTY3/NuAJ+dcZH rX8WP45H9A1V7isf/9f+IyzugYERt7Sby6Y+/j0rv9OW5hWGeBN5dQckhmi9j6d68+r1Noq25sus 8oQM5lRR93HKdyB9DWvaAXCQ28EYIn/dyK4K7x3DA/SvIrG1Pqe//D2O90rR7trbRbWy0mX/AEL+ 0baZi8rqwZgydF6V6Pa2lqALryoLlBtlDOpQs3cHnp2/CvPqdTog+hajtU1SX+0E8mwubadJUufJ EijBI8sEngHp1qS6sJoL2e4u7lpBNGD5Ix5Snk7hj1z+lcNtWddP4Gf/0P45vtqS6hPHEjP5Kb5J QuFAztGPeteyaGFnt0DhrkPMCULkHGf8K+evrYxburmeL2588I/+pk5d4nDPGoONzY5H/wCqvSNA uhq1v5U2oTeVaxGCLKsUjCnhQcYHU8Uw5n0LWuCS0SNhICmwGJ2bYU5xj8eePeiysxHa/wBsw6i9 kls6xCAzbYkdjyVX1Pr/AFrpjuhJ2dzF1G3SPXLjUluZmkuLLy2jiAaNnOSGb3yeTXm2tzadO7T6 jNK94VNrNDyYjt79fqPwrspWUrBOV4n/0f4rLqG1VUwqhVIKFjsCDtmvQ/DVslv5N41wkE9uVkhu Hb92pDAjB/AdKulpUj6ozi70pLyP1E0nXp9X8LeDry/mhVP7BtEAtkVUkVMiPa38R+Uc9yK/o9/4 Ip+KFTxRq9raai093aFLa3iubRoFmluAksscJYDG1lf8jjrX9r8WfvPCLn/6dR/I/LfDNun4oVoL qpn9P37QOlPqHwp8QMXUSW/hy4eVJMIJG8jcWJ9QV/Wv4EP2tn0uL43+OrJPDtlqM1vr8epSG5md S3nWUHmmFB1G5SCR7etfl30bJWzHEwX8r/8ASkeT9IGNsxoN9b/qfIVvcSSpdy27GwW4eRoLe4Ro /LAJAjGRnp0z1rBbTls7j7YjzLLdp+7Mc2JYpVA+bp681/aFHsfzq4No/9L8OrOLUrrcpvAQkR8/ eQrSk9z78H86z7LSba6svssEjx+Xcu8Yik4LbjnPXAP6cV/qy92fwby+7ymlYacYrwR3LRySRqN8 SHzAa9u8M/s8/En4qx3EvgPw9qOrPFPHZQJawGS1mkJHmKp65UOuT0GRzXjZtmeGyqm8Ti3aC3f3 H1eS5Njc3vhsDDmnvZdkm/0sfTy/8E7v2g7fTbFL/wCGPi2+1Qo0aadb2MtrHGybQC0mw/K+TjaS cr0HFblh/wAE5f2prkXlrF8JfFltbNEJIraXzkFmcDcQzxHd3wNw+tfmNbxW4f8Aeam/Lb8feR9x T4AzWE4wla/Xf/5E3J/+CeP7UVlHBZ6D8KdduHhcLLqd3YS2pvPlGVw2MEE9RkcVtXH/AATj/a01 i4R7X4IaxbNJFDDOEuiYVaKNUMoPlrzIV3tkkbmOMDAHmz8U8mcU+bV9P0vf9D36XAGOU+TRro9v vX/BP//T8Wl/4JY/tn3quq/Dy/tluJlVdItoTeXKKnBLsuR83PfPtXYr/wAErP2o/OjlHgDXtKgt 7Zle0nM5mmlHCgEQMAM//rr+0qvirlab9nr9x+R0fD7ENfvZpGzZf8Er/wBseVHtD8PLl7ma3LgS 6Xdi7aPHSNgMBu4LYH1qtL/wSg/a8uNPgstC+EWtS6tHcmC81e6aWW1UE5JkjKjkDjAJIwcZzXJL xXy2GqaS63fQ74+H0lF88k9NLaa9/wCrep0Oi/8ABJn9rjF3HqPwqu9W0y8sXsVhsnuNNht5ABum 3mPec5b5ecHGc4INHQ/+CQP7Ydjer9o+F9sv2YNqFtDLa3k0K4BUJuBbJIOcEdq5n4u5ddptf+BI l8ATUEubXvb/AIPTX7zsn/4JD/tfyOCfh9YxJdJ9okRLK6BhJ5OSyhgfTtmoLb/gkb+2Hm8e38By yLIWjitr7SZpUhXs6yBV5/Gj/iMGWwVtP/Al/kYS4DrraS+7/g/qf//U3Y/+CO/7bEsTsfD1laCK 2aC6a3spo7mZHOdrBl+YHgHbxxTo/wDgi9+2LPZQXl54ftopR+7hjk02ZRGqkEOCARuPpjofWv68 l4y5dF6Jf+Bf8A/J1wDWj9v8DvNN/wCCN/7WjT21rH4V0u2imGHvJIZbWTJjwzMADxntjJ6ZrP07 /gid+2Be6g/2nTdNsQJTCskEklrEEU/60KYCHzzwSM1hLxlwW9l95p/qHN2XMdDD/wAEZf2v7ORb mPSorl5WdIrmCKQSRFTgO4EfGR6nvVy3/wCCMX7XuoWyW40e3t5bY+Q0yWUu7aTuLg4KM2TjhRUr xkwKs+VaeZpDgSWqlPR/1+hbg/4Iq/tksVzYWc0DXAy+DDOoXgkrsBP0wPrVqT/giR+1e97LLJpN itxb3qXFvqNskr3IGMFWbaE57jax96n/AIjJgk7pL7zSXAikuVy/A//V+qrT/giN+1H9ouFutFsi 145Vr63vHWeJSB8oDQFFHGeT1NS3X/BDT9qy6tWs4zpiQwp+4uZ5o5robTnaSIRnkAHAycmv6tfj Lho62i0vN/5n5g+BIS0u7/L/ACItL/4IS/tRvbtFeXGjWjEfaS/2FZVZwf8AVlRyQ2OpGR6Vo2n/ AAQy/aftFEc8eiS2t1IztaxI8whGMAH7pAOScbqH40YfWCUfx/4YiHAFOLTcn+Bds/8Agg3+0hFM 1ul34eiSMEJeJYQIVUndgCTJOOnUnjrSQf8ABB79pyz1JSb3wtLb2z+ZBNInnNIX++2Vzg/7J4+l c8vGugr2tf0l/mbf6g4dWV3+H+R0j/8ABCf9o9o7eaPX9HSeIl7iT+zrFZmORs2fKc4xjkZ+tPP/ AAQr/aMeH/TdZ0l0kJSdrK2tIb3aRjKgIBxwenasv+I1UfL/AMm/zNf9RKKVr/8ApP8Akf/W++7H /ghB8erexaztdf0q3ih3Tia/jgnu71nPC42sFx6kj3qGX/ggb8Y3m02W+vbHU3tnZ1Ml/D/o5fG8 nBCkf3VII46V/T8vGqDTta/pL/M/PIcA4LTnbt6r8bK5f1b/AIICfGbUNQgnm8W6KbO2g8iGG2VL cxbh1KphSVwOQO1Pg/4IHfGCBXitPE1jDAIvLddTA1GO8c5+fargoBwRxWcfGrljy6fc7mkuAMG2 5P8AS35G5Y/8EHfjjJB9ln8ZeHBboghu0eFE+2IOoUN6+xz70upf8EDvivPaGzh1LwTHMJhcQ31v HClxEP7hb7px/tAms340rm5k7fJ6+pEeBMMk42utvTzXmOuP+CCHxidFil8V+Fpo7iJY5QbeKd7Z lxtYFmIwPUUj/wDBAL42NqX2qL4jeFoilmYUnliimxuxuRYyCozgfMMHin/xGhWfX7w/1DoXTvt6 fqj/1/0Uk/4N+fjeI4opviD4P1GGK5FxHHLbxHaxzkvnG7BPQ5xXRf8ADhH4mzWzw3mt+GXuVRXi vNOuY9MhdhwVkgA+bjvu44r+lJ+NMpP3dLeTPzxcB0Emnr9y/T/hzR0T/ggb8Q9NguktfFuhwG5u PNKalcLeW8AP3khUfMAT6k9PxqW8/wCDfzxvcL59v480C0vGnaWTLNNAAcYVF6j/AL6rn/4jRUUn NS19BvgLCuKg47eZO3/BAHxunnyRfEDSYbkxR+VdW85abKfeVt4+YHJwD09TT5v+DfzxhNkJ8RNI +zywbLqLUHa4uZ3671KbVUg8YOeKh+NGIV3F3fpr/kXHgDAySjJO3qV9c/4N/wDxpfRaOdL8Y+H7 CfSY2EchvGYqSADtTbt+bHQnArTtf+CCvxKkhSG5+IvhmIxSLOss9lBcOzjGeFj9up5+tZPxkxEo ptu68rPf1RT4AwKleK0f9dT/0P1suf8Aggn46u3uI7zx34PmgkChRBpMUKEjqTldx/Ej2plx/wAE CvE8xs3Xxno0Uujsp04QXTW0D54cuFHIxkYOOp61+/f8RexS0Unbz9Lfr+B8QuA8u6x+7Qmuf+CC fjV0DWHj7wxp8scm+ENZ/aWQnJdt2R94+ufpSw/8EF/iDPFcjVfifo880jZVoUWAYHbHltwfrWb8 XMS923Y2/wBSMv6RsXD/AMEGfEM0UMUvifw9GoIE4jkMaTbeAzKo5J78j8KkX/ghBr8M1wbfVfCC wzWf2PDgeagzksG5OT75xVS8XMW7rnYlwNliaaiinYf8EGPF1vb3ltN430t/Mz9nmjvfspRT/AQq Nu2joTj8alvP+CB+v3dklk/jXRvLSFY1AuWj+YdZG2ooL/pTl4wYxT5ot38kunr/AJAuB8tUbcv9 fof/0f1pm/4IDeOFED6f8VdBtXibDx3NqZ1lXaBtyEHHHfP9arW3/BAnxuizmTx/4fYmdWjt5VEt sqjrsG04z3ziv3qHjDnkUneL+T/zPhp8D5Ym1GLXzNK8/wCCBWv3Ty3I8Y+G4tTuZo2+2iJTFZCP ABjj2dcDGQc1Bef8ECvF9w9w8vxJtmLbRALG4jsCrKNu44j6HuMgnuTVvxmzra0P/AZf/JGa4Dy7 z+9f5EEn/BAzxwTJFH8R9HFu4V2SRQ5d1GMb/vAeoqOL/g378Q2wiceLvBM8ocvK8lo9xO2c8B3A xjp3qP8AiMmd3v7v/gL/AMyv9RMs7P7/APgFW4/4N/8AxrcuyL8QdDhtJJVkexlkL2SlTldqqm4D j7oNX0/4IFeL7SW+SDx9YTxToTbPcXqyxWjt18tPLVsDsCQAPWh+MuevZx/8Bf8AmUuBsrX2X9// AAD/0v1en/4IEePnkleL4k6DumtBAxuN0sKsOPMEIULu/wA81B/w4L8fR2dpaDx3os0ttMzSXSul ssysegGCykeo9a/f14z57y29z/wF/wDyX6HxFPgbK41FOz+//gFqL/ggh4902eOS08e6RqCKC8kd 7qLzIWPQKGQHA9z+dSz/APBB34ibfKTxroLO04mW5QW8ggB6oGaMSYHTgY+tN+M2eOPLHkVvJ/q2 XHgvLVzRkm03ff8AyRUb/gg/8TYp3u4fFfhnz52EUzpNHNIqDoU3hVX3A5qOf/ggz8U9940Hjrwk y3iIZTND+9JUY2jBx+Y/GiPjTn8esH/26/8AMylwLlb2T+//AIBRi/4IGfEk2rW0vjPwlJbpN5y2 13p1vMhYMGBVRkHBAILHIIHPFSf8OFfidC5jXxf4Ze1lk8y4FuIkklOOPv5AwR05Favxrz3tT/8A AZf/ACRD4Eyy3X71/kf/0/0+T/gg18Ybe+NxZeNtCSyUh/sDTQxrcH+IOefvdyOPpUkf/BCP4trq F1et4h0I/aYv9GtTc2xsrNuB0xu9e/ev6IXjbna6Q/8AAZf/ACR+eT4Byy32vvX+RYu/+CD/AMTg 8i2HiDw7AWMcplaSG6VJF5YoWwV5/u1j6l/wQe+Ls8McZ1/wvcus+9pXgiO4N12nduX361vS8b81 V/bQg/S6/NswlwBl/wBlv8P8ieP/AIIY/F9bdrU3Hh3GfKjuI57aPyB0LKC+4/iBWJb/APBCX43W KeTDrXh642XH7u4dYVlRNxYsMuQx6YyOMda2j434+L/hr7zOXh9gpLlUn+BYuf8Aghv8eo71JrbW dDuYUIiKvLDavgjkgK2OvfmsZf8Aghn8d2+Uf2LHI9ywuJ5tWS4QD+B40PA56npV/wDEcca/+XUf v/4BmvDvCX+J/cf/1P0Dtf8AghX8fLTV5ZYbnQnt5E3TxX1zDPBK/cq4zjP6VUvf+CEHxtvTZy6h DpP9p6bqgvLK90/XEktxGrBlX7OybAcgdSeOK/pn/iOON/59R+9/5H5g/DzCWtzP8B1x/wAEOv2h ri1ljii0G32Sti4llgl1CdGbI7kAj2x2rCl/4IYftJX2J2k0a2kibYqxtHCZsdHkBPNaf8RzxX/P iP8A4EzH/iHGGf25fgI//BDv9pcPAp0fwjePESPtUtytvOqjuHXHJ54JP0rntQ/4IZ/tR6vfTMdP 8PWdncRrDJF9p3tEI8/cfKtljnJ3DrR/xHLFvahH72VHw7wkd5v8Bz/8ERf2oIplYaL4cjhWL7LA lu9xK4IPyyMCCNwH8Rbt+NU5P+CI37UpubSG7tIL3T7OX7RK8Ef2a6uW5G0HYwC4PbOfStY+OmKS s6EfvZf/ABD3Cf8APx/cj//V+vLn/giL+0YJLe6h8J6O5gl2yGcyXVwVJyWQfKMjtxVRv+CK/wC1 Pbfbb9tAjvoo0IsrORwiOdwI3wBGbgdCCOlf1KvHTEW/gx+9n5Z/xD7C/wA7+5Cj/gi7+07eTKf+ EG0uEyRlmmkvJolWXGQxHlkNjA+U471n/wDDmH9quC4eNfDti8BbmaCGR1RiCeEMeDzxgGnHx0xc X/Aj/wCBP/IT8PsNspy+5Drf/gjV+1HHFOL3SoUjmjKXXl+Hzd3dmFYMGhZlyCcAdBwT1Bqpc/8A BGX9pGeGGS18NG9vo8l4tTsJbWCeLnDBFXG/HrjrW0PHOrzLnoRt6/8ADfmZvw+pdJv7kYU//BF7 9qaC3ul0/wAN2Zup2WdbCHSJYEVScP8AvPmOcevp2qr/AMOgv2lbaa8EngS8aLyo4YSxuFW0IGJD APIIP4/mK7F440b+9Sf9f9vHNU8O76Kf9fcf/9b2kf8ABIX9p9oktbHwLf5nd2+239i83lIv3E2q mecHkmsBv+CQ/wC1fmN08GTIJN8bGPRbl7lMdCU2AMM++a/sKPjlg0vepP8AD/M/GH4cz+zP8/8A Io3f/BH39qq7V5JfB9/ctFB5NqF0G7UrLwTLwu0FcfdPFNP/AASr/a0MV0D8JvEOoTQiOBL0WbWr XEcY2k7UVgMAdxmto+OWWt60Zfev8yn4c17aVF9zMdv+CVf7Vi21rDP8JNXgaLUpJ21B033bIVAW MoYOQMcdQNzZB4wab/wSu/abmQy3Pw48T+YAwSB4QFjTON3EQDN+IHtW1Px1yuL/AN3l96IfhrXq O3tl9z/zMbU/+CVf7T0a2dwnwx8RzzW8spd0VoBeLjEe8C3fB4Hevhb43fsv/EH4SX0MPxC8Iaz4 Sbz3kNxrNsGtInjJDRpcYwGPbcBnJAGRX2PCXihgeL8wllOHg4TUXJXa1s0mlb1PkuMOD5cN5dDG znzKUlF2Wzab/Q//1/x91bSIboeTFM6xtEHXKbGOQCCcjP4YrkDpttYRNuXMyElSD19q/wBb8PK6 P4YrK0YkV7bSXcEOLmMzJGFhimfIiIJI56965+We9e4VLmWPzrYbCYTmPI4OPWvQWxgou1yzamVl DCVjlzv3chfoKszxwW0DSPcNCG6mL77ew9ziuhbGM0VZmjxFc280jSw4fa6lXH1qG4ljuSt3Hvku SBFIz58qLOCcH/PSmZn/0PwxaGJAy3dwpUR+aX3ZByOlYwileFY42yJW++qbSfQCv9i4xufwOMih SCWZLgS7tm1NrbXB9T/hUc00LPawud1wq8kA4645+taJJKyM23zks+nus0TxNsVuWPfPtV9pBCpQ wyXEjgKhXnYfU/kfzpgp66jbWNZdsajMjHcY3+UqPWpdYV20w2SSBZRIGVu4APIH4ZrotbQUpX2P /9H8GbKF3hYRtudUwFyAue+TVNrMQyNPcpHKsR3EHDIMV/s1GPMfwDzO9zRM8uoxy7EjNpEAdqc7 PSudl0y7STJzErnfG8fI69Pbpik1Z2E23uKkU6PJmYMYxnB6A/zqazn1AmWXfG7KOkjYOB6c0hFG aW4uGaWWQKS/PzFgoFSQNc27lo5N0TdWxw1AH//S/AWSNLq3ZywB3FSU659arabYCW6kF3NuCr8g LcMAO30Ar/ZmzZ/n/sSS+HVubeeazd8qx+bO0DBOeT9DVWDSre5geAXBiuBEzytJjy2C5xg/l+da RhbVmDd3czbHToxM4uG8qK3I2MzY8zjr+nerUiGF5DnzYm5QqPlGB6/hV2M5Ss7IgWaM9I8SZ27+ mKjvYJpYAJAHiRg6K38JzkH88UnFPcfOkf/T/npkntX+zwG1CyeWGnmxu85lbgnPQgY/Kpri5gkj yBK0sZEQhRNzP71/s7yI/wA9XNIWWxG2MC5khK/MIkUEMT2Oe3bis5ItQhuWhOw7pAUbONqnGS30 54pOHYad9UW9QjhM6okrToCArvGI2J78An3q1aJbRy7ZERyYztOMsPbHoaXs2aqfco3lwJisUyy2 ggBeJYl3rJ/sEehz1qO30iS6kS/i3RoFw0DAhmPr7VXs0JSfMf/U/nzuLFiP3cYQFMScYOR61jxW 6wedGxwQcgJ3zzX+zvIj+AI7oapWW7SS6yrKgijf7vA9vWr2sbrlYYYXCRxAFzCdrYBzk/XijkRU tJXKcNnbzW0xivI0nyHMEgKu46Bge9D2bfuQ87gBcMQcAYq0raITabGmFxI8iMZCoCoH5yBUsMLB wzzZZfml287fag2P/9X+em4tmClo3JjfqM4JqFIGttojdC23LiRcD8K/2gP4Dc30FeIzqJD8jxMC PLO0fWq1xaQrJAd7zebzJ5hJx+NUot7EXZAbJSsqw7o33ZQ9h/8AX6VLCJoBK0rgTIMBnb5m+v5V XsxDLK+uJyxuSI8NgKh5A961NTut1lDHHCskifekB+Yj3o9mB//W/nQgYMqNKfJj/wCWhbonvVR5 9Otbg5kDrIxEbs3yPj0zX+0FraH8AqTiXJ7SOZIJkZHaZd6xx5LqM8AjHf8AHrWW07i7+xzxtGnQ nGCKBOTZ0VtZR29vPLb/AHiN21+A5xjiqqxLbxbmmjjvpF81os52g9sUCGQbpWVWkxvbDHsKmmKW 95EsSpJ5I3pv+bDdBkf0ot3HdrY//9f+dGOzf5t7qrS5JQHr9KeixwkRIGkVPveq1/tClfRH+fkp W0Q4pCIzKR5XJHPBaqtjEjSTNu8sSnbknCt6GhqzsJT7kcvlW0ZIkZ3LbSAMj61UmZQUY9GHGeh7 VLSe5fMu4rG3iTep3Mycoo5U5PH6frTrYGVctbrEgTasgclic+np/hWcoWWgueJ//9D+cKdrlFCR EuqHkgYNVpHYwu1xjzG/1fHOa/2YP8/uZdyOwcSeYLhCqpwGXnPvSTvtY7OQPTigpO2qJk8h0jO8 7x94H1pJZ22iFUDqHzuxyKaTexTm2WIFVRySM8qMfKan2C5d4vkhdRuwT9/6fWmoNkH/0f5wUt3g LeagO4YGOntUtuZYBhFbdnBr/ZpQbP8AP8h1GBpUSORVyJA6kdQRyKu28rSB0LxMkMRWV3+8SMDC iq9n5kT2sU4prhJmKzE2pXYVx93rTJo2fhWAZuVJbbn8anldrmbd3c0xa5sppWZTKF2RoT345rE1 KUw6NOk9vGQqEuZEEigYI4/MVhUiuST8maR/iR+R/9L+MrxIkaatdoQkEiuCI2H72df4WbHqP0rk 7osrDyFwSch/7p9q+742VuKccv8Ap7U/9KZ8pw/rlWHl/cj+SI7SVwc3BIJOQSOCasYQZ8kqW+8/ qK+UPUa1sXLLVnsQ2SWR1wAOTmtJdRguUUTPtCndI2z5voKymrSNYqyMl7i4mYyEMsYkKCNujr65 96bIvlRhIv8AVu27yh0z/k1BR//T/i7srZtqTSrsAb5VcYPHtTL10DeUzhJCd4ycLXQcy20LdhBJ Evm+YrOBuSRO3pV+y037eZCQxJBaRguNpz1rOMVzO4zObSzaS7r5cYfEbLyrDpz/AJ9a1l0lbmRI rcFblwWTZ8pIAPb6ZrS1tAKsdukEjwvIFCfeUH97mmzxSmJxJ9wKfLIHz4rGW4H/1P4rIbl4Y4oD /qzKQnykNKTzz9K0nnJRFcbGH3QtBxz7E4uMrH5x3FeE9TV50nfZIDsUjapVgrqfXFKXwstbEc8R ceWJGbbH88jdc45qtbRyW5jl3sYWYKSg3e3ArAZsq6FvlyUPALjFdKvg7ZpltrcOrWk8c+VktDOi zQFT028E/wCfrSbsVF8r1P/V/jZnhjWVm3AsvPy8qKjaXPlSxIZEMvlSLt98HPsK5J7CTT2NUtCu x41Ix/CvyioIJWlkcSFiqtllz8rD2rInnSdipeTrCu6IMF35VMZIHvVqyt/PZt58sv07Bs0FJp7F 8WUlu6RrzsbeD2PerlvOtzceQWCMjbJAR8oI9aAbsf/W/j+u48BoyMDoXXp6VDZqUCrIdqj5Rjqc VwJX0Qr62IrsRyFhGzEr9/I4I9qZpjJbPu8xlPVExgE+taRjo0xmrLcm4nV3cliPnz60y8SKWEDc GYdc8VDi0rgM05IreMAlUYcsQc+p61d3wXW7zH3AjaHxmpA//9f+RN3S1RYY+Yh8yYbcazzOxMnL BpPlGR1rzJOysgH28WSxl+WRV+RV/maVpQrBXyrLkLzwfwrIBolaWSGCPfEvmbriRV3M4H1rTnlD M6xM2IlGHK5xn2rOcvsonkV7kBuG3ooxlMbiPvDPrUlxKjBQionzbiSMFj/9esxpJbH/0P5DUjuW uCCuFkGI0Xlce9bcFqsUOZSyTdFjUbl9+a+fLUbxJ4ZyzhWX5WG3pwTWnJBCUUE4/ugd6DUzr63k GIoTsyvMi9RVy2Hlgs77mCYJHc0nFMBkMQlcyhsLk5HQn8KmaeNnW3Z9pAyFbgAA0pK6sXBO+h// 0f5UrOOPY7SuAd2xcngj2p+9YGHmSbozJiNVbjPTJr5iz2OuS91MuoYi0hCgzFQEO3gj3P8AnrU1 uqujkkFlHykcgGnGKbsxcvu3Kc8sjyYkGQV2HtkVn3dzDayRFExlMKSwB3fT0qSQkl8x0Fx5Z3KO VOalt7U7zJ8oU/Ku4ZzVw3JcUz//0v5WBB9lfz0+aViAzY54zg/hWrA91Ksk5mO9F3O7th5ASBx6 9a+fAgGxyWYCWTdhS38HbNKyHcAjgjGOBVwaTM4aVDUS2iuLRlWRfMI2nbw+KyLeym0/znn2GBhs ViSXOP5VxT0qHpO1mMDI2JlZWGf4eox7Vsx3M0kH2i3ZW8tCeejY6g/ypT2MT//T/mBtnE8PmySD c3OBxsqJrF74mOOUoCQCd33u1fHnQX7i1ks0AgbOEwQecY71if2jeATpcySy78KjOowo9B9MVE3Z GSfusv2IXY1wXYYwAgGST3NX9TcILWdrpSJ22pCRlyw6f59qmL6MJO9Niw37ySASIkcSRFWB6ueO cmsyOwZ5ZW4lLMSFAxx/+qpb1MZfAmf/1P5gIkjWTMD7NnLR59K0VkWPbI8xi3ncCgzvPoa+KUuV WJi7otyzSCFZA7yKzBI8AtgngZx/M0xra6tUmupJRkwgpA/Ab6DvnP6VqtUUTaTqz31usV5HHbXR fZHscyRhfUnGR0HFSLPtuJdNFy0xtst5nLJ8x7HHt0oAJYWQBsnPXjoazyMAmcHcOc9cfhWsYpK4 H//V/mhg+zn59nmqqhtjDoRgg/gcH8KpXlwZSrzz+WIz64GOgFfIO19ALRgtlRWmy0pUtHkblXGO c+vNT2Sl4g4ffHu2nOAWwe/5UgHXzpCheWNnC9FUE49Diq0SpcFZd+EC8RsMEH1rGXxMLdDQjtB5 byGYYI4APPpxVNfL8028qNIgweVyP/18VJrGFtz/1v5p5lglbzLKZoWT5Sr/ADMpA59KYiw+aiSi Lcn7x2nkEQfAzgZ69O1fDmk1tYhjks7i7CzyrIoUiGDAIYjjd+Gf0q5C1vbTl0ujnGyWIMQEH09w aDQyb7T9MvNS+2G12SLGF80j/XKO9W4rq1sLmF5FkaIMAsaxF0Y9g2BwO2e2aAIpYTfH7V5jK6SF hAVHlL6e/akEcDS2zXsjxKtwFkKD7q98+xzSaurAf//X/m21xNPsYrWDTZGDXTlVkjj8wIAM56Ef ia5y1iW0jubS+uP7SW6lLlniCjBAAUjp2618PZLQ6AurhxJ9n3tFAIwUl34x1yMe3b61V2qdwjyw UZye/rRawHRrE/2OAbh5U0e47Sdy9v6VQWGPMpcEtjCnpn3oAis7aSZHHmEKsm0sQQTg81cVhamR JZHlVl/coOChA6Z9yKA2P//Q/mV0awZpLm6lleczSM4lkQJIozkgnvznrXQo6RecwLDyk3LgZVvU V8HPSx1qTKTeVdRidLhGgePe8KpsKNnnn1x6U3zbJwGzyq4APqKhO2xondEk4khhQ7o2LIGYjoM9 qyDMLOf98ZCHTJMcZkGDgZ447/hVz6DKml3Sz3MsCQufKlJ3ycE55DZNaMjSXaXV0khAtIyIFKEr M4OCPp1/KswP/9H+Zi1e7u9M+3PbKUaQQGL/AJZs3v7evpRBpk1sIrlvs8Ekjlpra0k3Q4zx7/1r 4Knuega00ayxcZx0O3msNIFtrt5YwrSY2l2wwHbAFQVD4kMmM8cTCL/R4twd7qEAzR+wBBGD34qx Ztpurl0+1XCCyz50AhxHcMegyRz+FASVpMqY/s5pJnPkwL/qjtJLnPTFXpL+G7IshJLFJLFv85Uw i4OCM+tBJ//S/l8vLScSG3t5GkYny/tL9cdjXQXWizxQwRXTh98QPmDowIBz+tfn56Bl/Z5lmFqe I0j+WaMEK3Pv6VoW6ZnNu6yKEUHeVKo2c9D3rWLtHUCZmNrK0DkGN+ApHIqe4Sykjt1ihRVWPZNc HJlkOckHtgdBVRfMgM0edbScS74DJgq3G0eo98gVavpI3gTzl2xBgHbGfocUwP/T/mCmsys0UZmX c2JYwsg2svBG4A/mK14bdGUNcGPzRlvkPEY5A/Svhz17aWGbDvKoQ4b7rkgZ/Gsp4NSurqJ7a6ns ltJQzssY8uYc/KSR+oNBna0XclnSaBjbCYzzbPMeQHJwxJ5/l+FP061imkYvKyFYtrQscJLz2HrQ QWI7aWzuFnhZfJ3bUhGAF6dO9JNeILxY4mZJAPMl44bsR+tAH//U/mDF3Lb3M7rMhjni8owsMsck cr703dFasyzusJ2HHy85xnFfDnpweti7Ba28wVpZJCrLwcnYQfUfhUE1xp/lStHGqm3zC8oX944z zj2yP0rOMtbGpYtLQQRf6SsjLMQ0Wxd4AYZVj7U+SeGFViMaBx1CHlxk4yD3qZO7ARbdL2e0DMAD ncHHzRD1FZ11AtpdGWI+VIpwGAwwXPIz74qQP//V/mIOoQymSaWaSB4IgsLKvXPB57dTTrC4t9Rg uiBtktH2xGRwFm6cj8/0Nfn56s21sZ0+opBfxaOZoTcTbWRS+MBgDlvQD1PHBqRbGC3tdSuLi6aW Sxl/dxW6GVCuCThvbHH1rnMjQsbddStHnWRisIXdakENggneVxn2q19rSaARooDxN+7l25bPtQBg 3t8BNHDNAkOAQZud0zfT6VYjEeoIq2d0d0XMiuVVRt6gnPGaAP/W/mK0+/V3ktbyA2rCQIs8nFuF H8QbuP1GK6mbSSmmT3MUsbCKNpVZHDgqoJz/APr9a/N0+qPTi7I4SCcfZGmmdZoWm8v7hjd+ePlP Paums9FGoy2rpFGzv+7jEYw2CRjcfT/Cm3dmpna1HbTKsV0kctxYXjJDGhZvK2jAcsOPoBn+VS6f ei1tbe3mtmmuZZGDzzEAxoD8u31/n0pAU7q9sLK/+1XbKkMTpvZs4wxAGSORknFS6nbXC3XnW8wM TqHjdmHy5xgADt1qbWaOqKbZ/9f+Zp1dGtWjb96U+VN22Nj0z7ciltoblkb7dHBHdWU5DNazGVDn 7g5xg4zxX5lPc+kjFp3M7U7SC+SGP7PHDqP2oSrO5J80Lgc49Bn86vTwyW929rH5UqJBHtlByoY5 37T3xgCtMIv3sV6FO6aLM9pbzWyfaWScwv5gjmX5MjlQO4PuKrJORDKtpbI0wG5ImbCsR2zya2k7 zKh/ERV1W3vlt7K4uJptzN5iiNTtg/2F9eM1Nf3Cxwy3iTSPfSeUkUEYAR1B+Z2HrjAqG9WjT7bP /9D+ZJLsLcxOXK5YKcAkqMir2q21utw8lxNDb+ZAJFlkkLI2BleOcV+bn16Mm1uAdPkgjjSVrtws +oWr7HRFycDnp61V8mFdTE2kag95Zm1AeKRCX83IycnnjB456igZtNaXYhkW78rzZcOnltuVFwMA +/XNUbfSdSv8RfZ4Wjtwz3E8QJeNMjBIx09z3q4ytoYyd2bqaiIZTpAAl3Rj5mxtUjplvp2q/HYx wRC4kufOE/VUfKwkZGCO39a6qctkEXys/9H+dvwpZTy6j/ZS3btZ3V9BeXEb3TDAMgB2knAAz9Bk 1+gnhXw39r0+SbRru0tNZiKGGG5m/dfIfnJODuHBwF61+seBcb18VJ9EvyZ8n4jz/wB3Xm/zR/U/ /wAEf9MOm+C2W4t5Y3vLMXsgjBVTc+YCJGB6ZUEf8Cr66/4KV65BpPwD8UqheJLK0j1HVGLCPzoh 5khCt1B+TH418bh37XxJf/X7/wBuPs8f7nBjV/8Al2//AEk/iN17UIfs7obBbe4uLTfG7nkl2Zlk Y55OMe1fmN+1bpc+q3F1pV0nm6lBZqskfmqLFIYtpVww4GFUHg88k9a/qjxLqcvBNdLtH80fgnAF Pmz2EvN/qfm9q0bxTIC8Mk4by4kRwRgcAn8qv2qhsR3CclQG29c+lfxa5e8z+gJrQ//S/iasYbUT iOYmEuuyM4/lXotlbrpzKqTmeCWERqxGM5AycevavLrS3OlqzsLDcsk8iRo4WM5LHjPWrV9PLKiX WnieN9OYXBt7eMl75lwfL45AbPUV5NRmsY8qPqrwpqlpd+HYrGKA2ssj/a7q035COwHfv+PNdjax PdpnMa20aBWh2lZFYH73pg/zrzqsty47o1YrhHf7LFgNIBH5RwqH0p+o6NqsSh7iKSDzPlt3YfLJ 7VyR6nZB2iz/0/47IbA2jFt7ebGAM4+SQDvUd7qViPIa41K60yUFvLmghWTzDtIKHPYg4x3r5taz I5fcbRR0ny7tRcsjxeYxjj3Aq0gzwWHbPavWvDkj2WhXsRmMDTFtoRBJG7qcxlh1/LnJ+taEwVyh rEl9ePZJNEpZ4fM8kfNEhT5d0nPBJ52mtzTb21trRkvLTzkniaNYpchFYHGcDv6ZrWGw+TU5u8vr c3bi23qqr8wbACH0A9q871izjV5rswxzu5ykrjJXJ6V20tJK5M4e6z//1P4pr2K5MLpKufN6qfuA DOOPwr0bwHqNxNBommzaXbXzyasI5JJyIBHCDgE7htxxwD61dP8AiR9UZUYvkmmfpR8Ob20k8PaN pt6wEemWSafaLGqvHGYmJBU9zuJ57Y9q/oY/4IweJ5Ne+K91ob6ZeB9JupdUiZisUMot0jjjdMDP O/JBz1Ff23nsVV8H230oxf3RR+ScAVnh/FeStfmco/fof1yfE62XV/hxqI1CSVW1DStskEZxvXYT NkemxXr+CP8Abd0EJ+0D4my9jZWlpcPPpHkkJcS28wWKJZn6nAgBAyeS1fjv0caijn1ek+qf3/8A DX+Y/pB0V9aw8+1/6/I+D/EVncfZ47YNIqRsyxqh+YbsnII/GorSWyuLSwgt/Ptb6GVbS5W/UtvX oZQQO2OnOePev7apyaP5virux//V/FDTZdOsri/igiGqX0wMaHLJCCONwX2GTzTGtrTTYhNp7AXH nE3iBcRx4/hB565P0r/Vi92z+FHDTQ6B7G1mtIdQtfMjnIEs7wACSVlHC59OP1r+xb/g3w8B6BrX w38SeI/E/hfSL3X7cC6sr6+sY7iYh3jLOgYELglF9cRivw7x2r1KfCFR0m1K+60P6N8BcNCea42p JaKi/vurfkf0yf2RpR250zTzsGF/0KP5fpxxUxsbIrsNnalQMBTbptA9MYr+GlUnbc/ZJJpvRCiy sxwLS2A6YECD+lP+z2+NvkQ7T1Xylxx04xT9pPuKNSV7H//W/vvSys42Lx2lsjs25nSBVZiO5OKs AAcAAfQYq/aT7mjm07C0Ue0n3FzsKKPaT7hzsKKTnJ7sOdn/1/7+KKpyk92W5SCild9yAoou+4BR Rd9wP//Q/v4op3fcAopeoBRQAUUAf//R/v4ooAKKACigNgopXQ7vuf/S/v4opcyKbaCikmrWKndb BRVEXfcKKAuz/9P+/iigd2FFAXYUUBd9wooC77n/1P7+KK6elgCikAUUAFFAH//V/v4oroAKKACi mwCitrruB//W/v4or0DOp0Cis6nQKfUKKzNAooA//9f+/iiugAoo2AKKzlJphYKKJS2sNK5//9D+ /iit07oLJ7hRVXfclxVtgorZ7GS3CisbvubWS2P/0f7+KK6bvuK+tgoo5n3BuyuFFKU52buOk+aW oV+bX/BUj4J+BPih+yf8RtQ17whpGta94csU1LRr+azH2y1k8xFZvMUbioyGw2QNmeOtfa+H+ZVc u4xwFeD+3y/KacH+enmfG8f4dYrhbFQlq0lL/wABkn+n3H//0vyZvIbm4vtQt2jS1fT7n7I8ca7E AQAKR9Rg/nXIazNaCaa0igL3cAUuyk7XyM5x9MflX+tWBd4XP4Zr/BEyA0BtojLbqRM+zev3xjgg H2z0qtJo1oiMbfJaQ5JkckjmvQh8SOe/u2Gv9ntfLH2duBtOSdknHUVQE1sWLOFYocrCwzk9q7Y7 IxqdCJHC2zy3C7PtOd6NwY15wOPzpohjsrBUtA0yOwCozbjgnqSa0UGZn//T/CW7e34ZnAwAjA9M /StOyjXyjI042Iu5QBzn0Ff7HpWVj+ByvcJau6MZDH5nz+Y4/ek91I9+lIunwrtmKLvBypx81My1 5tR93p9zNAGR9rg8N3jHrisi3mud0swdibZSBuXDMRnJrVQtuQRw/amQ3ZBWWQcqeoFSzK8iRMz4 3HYSTyDVgf/U/BpbWKGGS1keTa5yzxylWJPuDkVPLausDxrOrpKmCGA3L7V/s7BWVz/P8xtiRLb2 ZvGiluZtvlw5yQOjMO45rqoNHitrffdamty/zbcgRADtx9KppPcmTsjjXhM0k5hYAByAWOA2DVm2 tZWild1TZjG5T8/4Cp5Fcyu0rFcQQln2bioHTqahZL62KwNbiVLiItDIRuaLnGMdvxpez1KTlsj/ 1f5/dKRJZ3sHUwtJku7DAVh6/wCe1QNp7tcHM/lvC5RHViEcZxyPwr/aBK2iP8+/sFzN28bWSTiV PMxJsfarAcE/zqB4QLiJIPkWFdkgXgDAoMy1/ZqSvbzpskRSSY3JYSdv6U+50+E2MmyV454iWdVX dEFwMY75600m9jGa945C3hmUymVw8ef3bAYOKvolyYWmYny1fYkYPDgdM0+WQmf/1v58rSynfc88 QQldyjPGB6U6GISkSx/KpbG5hgnB/wDrV/tEotn+d5a1CRUlt2ZVXZ94KME46VTur57lpBHEFMpD tcYw64yCv45/SnyMabjsQWyxeXslYIQ37vd95jREiqZGJHm5xGc8mjkkbRd0VptV/cGBI1Z1c73k TLjH901ueGvEY0rzxcWdtqEM0Rj8uePmEnHzKe2KJU3bRjhJqd2tj//X/n8utWhmjKjAfeAyKPes zU4JbSdH8oxrMgcBTuU8Cv8AaJwaP8/oyvqUmMk6IFjLSJyQPvGrAsH8mO5iuJIJWbbPC4HzKeNv WpKk7sY8DC7gmnLMscZjAAAULjipZF320nkSHzyMx7x+7/E/h2qlBsRWs7uSGOaMmGbeAkp2h2hY YJCtjIq1YalBbTvFKmBOwVZCvAz2P+NPkd7F83u2P//Q/n5lSN5mTlUAzuH3TWNfyL92JsurYyeM gV/tE42R/n5KVtEQffjTbMwIbDgHkVO0QC5a4WOMLnfIeQewrVKysZqTQrTHCLEpZlX95KQAuR6f WqfkXeoSSKlvyD5hkXjcBgdPamIWHTLrM4EbNIq5Cjkkj0rOia4ErCYsHX5Hibjbj2oEpLZM/9H+ dcSBEZVWN2IOxX+6TjoaY7eZZRxfYrV3inE2XiAfIOCA3X8K/wBp7I/z6U2i4ty5f7RbwjzVGFRU 5U9OBVaexS7X7XeRywXolG9RwoUdz79KlwT2J5mXIJ1SzkYrJJGknloxXaRVG4FvNPa712PIp2yH tj1P+elL2egXZX2AvNGhYsnRlBwB6035VnCMxJYYLY6VKhIam0f/0v548hzBEoBZFwrt948YqCYL AJTIAkjDGRwxr/ahLoj/AD3b7mZGZrhXe7kZ44wRCgXAA7CowSIiBgKTkKD0qHC7uJNPYYISjEGY NDIo3A8kVMpe4LpZqU+zqEkMoG1gQOcn61PIxjJreOK2ndR87DBdVBJPtUWnvi2kWRixXhTnDH3N S4tLUD//0/5w0DyAxqSSrBiR3pXt990PPB8jbtUAYYt/9av9m3Dsf57kzwwQXMUBkMcTcvKU3BR3 6dfpTLa3sNQFx5csqTwDcI0j3xyA5AJORjp701DuUpNEcaQW/wC5cL5wO4HHB/GrMCwfMzruHTPY GqjHlRTn2NKytorl9jJnb9xR3NZd3HtbzU/dlZDHgnlSOxqieaXc/9T+cyGV5MeauQnoOuKeJ4jM oGB/FjP86/2gP8+lNoinaHzS8nXGAGPyn6UQCCO3dNieZJJvD5znPrQS23uWFt44oJvLA8yUcbhk D6CqUSRnDycOjY5GcfSi3QRZaNJnP2e6SSNVDuit19gfUVh67Kk2iXcDb5fLfY8PIYgqcn144/Ou WavTl6MpKSqwuf/V/i/1iS4TxFqjSlJpXiKWc7f6kAHCoR3IGf8AIrnI1kDBLpwz/fcqMKM197xy rcV49f8AT2f/AKUz5Phxf8IuG/wR/IWXY68FjEpyMDOPesyOQuZlCOBjYrE48yvlOV2ue3yq9yaK ynd7ZnLLFv2sFGfz9K3TCiTeQCGjB++O+KzcUykrlqOEST+WZDtjUM0e3bgdufwrTeyQC2ktyBl8 4PJUjp1rG1tBuPvWR//W/jOvmuLhD9o+XZk+aAFOffFZZtori1WRm80q/wC7kI5bHBBPp1rpS3Ob VaMGfY7W0UwiCRiWQqMhR/kVuadql3pqRvbXIHmHMgKhklX0I6fzpXV7DLdxe/2nJJNNh5OGKhQq HHAwKrNcmF0n+eJkIAdTjZj0oAinKyASRAb+u/Gcn1NUHvpWZLeR1muGfa7jjGegIrKas7gf/9f+ NmDSxmNyI2VDkow5UnuKzLvTklunaEOJEGwbgUQ59KEr6HK117EQsmtcb/nkVsEE5H1zWjMQ8cZj ZkeL5twGVH+cUFEVs6KrxvN5ivlnkbqc8kYq/GsBjCW7gBMDj7v4VlKNtgHPB8yNN92HJUg45Ix/ Worb7QkQLyny95wM4FQB/9D+NG4ZN7YdVHb3rPjlYTKsbN5Y+Z8965ZK6sYw+I6RcXECqPlxwSOG ppCxOoHIK/n9aySbdhO19C/NbwyW6llCkr94HlqrYVE3GYyPgJGq8YxWvIrWKp7lmO4dEB3eZsOc FsNTlli3l4Igk07bpVA5J6UuRFy6I//R/j0uJhbyqjbikvDpjOz61Z+zrLGsm8jacoM4PNc0Vyqw kyrsnMhEWAoH7wsOAPUU5PLLBWUBhwr9jTbtuMRUYSyBjgL8wKnOac8iSfMAwCjBD8HNZykmrIBY 7ZJk2yK/zcgg8VqIsMKKjD8QMVmB/9L+PuWVY5cuvlqf9U2c78e1WwZJkV0ChAe/XNeZNaATXEq2 ls7kjzGYISq5ZsnAxVWOI3gLSkgoRsI4NZAdBNcxnZsSGLZGEKqoXfgY59Sa1IEtDZPKIAkzERcn hlwecVzgc3LbCGZ2ACvu5wOWq7b2VrdbBOyiTO9AxwnHAFAH/9P+SpbZkkKRvgLy3HOB0q9tBQyO 2VxsRdvKn1r5802hoQwxZfaCFB4QkYzQypGxHnuzRnkHJ/KgUrpmi0Et3BFOp2Rg+XJjkn0Pt3q0 mjyxxefkKgIZtzdQaDVbXMq4n+yiWQKBBnAKjODVu0sGAWaco7zJvTOGA9j70WA//9T+UtopzlJB sHIB6DPtWdHNDuMcys3lNt3dc4PavnzpZ1X2jT5rKF4kmt5lTbMspDZI7ggd6p20qw7scqTn69zx WLT5mheRfdY723823BbCnHGMkdR+lcd9nmvLjLZURtsCPww9/wBKTVgNcW6xxqkmCyHbuI5ApHmC GJS/yRnIA4JoTs7oD//V/lb85gn3dyv0HpTTcuY2YhxHEdo2rkufSvm+d3Hyu1yW0l+zG3W6RTNd nYDu2xxnrkn0+tEN2j3MqQRySjdgOVIjJHB59PetE+qIhH94MOpTR3DGKBomtGy2weZ5w+nf6Vah 8++Myaixjjd/9GMacjP94dq45fGjsT0ZZvdItPJgtrR5LJoUCtcJ8zS8n7wPHp09KrtLLaKkCSJI T8kjgAFeOuKc9iT/1v5ZbC3mdXVpWZd2CehPvWkvmW9zDHGG+bglQSW7j6V8ebSdlY0xcyTI6Tws kgYrvJ4cA8HFQXbxW4jfamMYK4z+NRNaGIkBRsncxyu4BRkGltrxZXbZAZXgGwhuGjGcZrNLuWle DRFqEE8gMmUSLbgKv3s+9GnEzWgSXckzSFR5TcbRnr9aclqvQylpTsf/1/5lBFa27RW7oRczKZFf PG0EAj25I/OmGKKUOu8lA2wcYCGviVFvYiD0sVEubmyWS2juXkiaX5VIDL1/z1q/ZyJeXTm9eVIY UCowTcMnrjmtUrKxZJB5SX11LHFugtJRHEZBsE+VyGA698celRRwt9pnneY+ZO/mSIcKijAxt/Km BNazySzK3nK8RYrGAPl4469//rVavLeRsbQu7djk44rRTsrAf//Q/mdiKYltVkeCYp8zpwxHTj/P es+a3Qr5bfOQMb2GC1fHgWUt72eJIYJkjwdzF03sVHYematJI1gFLR5RWAaIHap5rOUraICzHFLq MVxNFKqIyHf3KDphfxxXP3UQtbTyRdSi5tjua6kwN47hhjGOtZOSW5rBK1y4tu9vaQS+a7W7Ykeb Jfk85+lO+0NcXsBspN6BipIHL4B5FNa7GiTex//R/mtGl73EsM2JJCPN4B/Cs2/0mSWR43LgbcFw MOnuPevhzpaadmZiWVvBqFrNDJcobUFZGdgFfsSePofwra/sq3jLXLuxVzvZgSS1Fugi1JAxEcsb ECRNqg/wCpYrSCBAZy0uOCDzmq5WnYCkLhGuLgJEIY0wE64P+cfrUc5gkhdpCF8vknHykdyaTVnY D//S/mnSa6+xyRRokhki/wBHkU7jGCOvpmsoQy4gjnXbtOZJVbLMeK+Fn8J0GpcWkDDmEs5UbQ/Q jqDVJooYCrAuvdl2/uxjHf8AH9KoDVW/RbfZGYpJF+7EWwQKqbZWkVuFDclelA7O1zPubmSymbox YZij6JTbW4muflkCh3fjPUewoHyy2P/T/mvs9iRPazZWZcuSc+W68/5xUG8XFsYrPaPKfcZI+WIB wV9PavhHG7O9LlVipdtBCqqoMMsyrtjlO0j3PHHesK3S4NxJ9ohi8tJP3Mqvu3gdyMcUciQzTur5 ZdsG0ssfDsUOzH16VrQzWpjCDY6ImCPbHanJXQEds9tG8xWBYYzwrsckn3NNsRIJZRLcoY5vlaFU xGACTwetZNNbjs7XP//U/mnvzOlkIrK6a38u5Eq2yKsizjkEkds+o5rMilcxnzVaMvJlw4KnI4yP yr4BNrY9AeJHaWRIrjCRIGljzgjOO3Wq8nlLtcOFbdgHdhSTxzSKjvoaTWmyJcOJS6/OgGFjPpVS CRrORcoGVZMkLypoCb1Lc0zXhZ3QJC5+QbcAfhWSsMf2ry3xG8J3xyFtit3ANZp3nYHG1j//1f5l YlvFlmuSIZCUO+1RMkEdGU4Hv+VbE9yx0pLm4kUpHFny0bzJYx6AV8Cotux6S5WrdTLvXkEVtNbK xj3KXDJ85HoR2qnqPl6i1ta+ddWrDEkhiYxNGwyQFPfGM/j0pJ2bgzV0ly3RNLNb28MQnn86eM7f OPMrHpyB3/CgLNcxK8OCrsOGOzbzg5reMWooyik5WJLiwZWEE7hvL+YqrZB9ORRPHui8p9zI67do 7U7cr1NeVdEf/9b+Yi3gMcizG2VkDeUjM2TJjqvt0rbuo9QuzDILPTNNglVt8dtK0rMq8BmBPBNf Gezvseu2luYEdzaPKomeYxwSjf5AyTg+la0l+skTRLHIjlwbZRynHd6pRSVjF7DLm4VIxOloIbnb tlm27ZJcZAJ+gri/7UDXcdtC9xd3EcxdYRHsgjZuACw6Z6c+lZzj2Edy9m6p9uLiKS2tBcrB5wKB jtz/AL3WsOH/AEg/aEt2nugxWQREDCkg8Z+lYczWjL5HY//X/l6ma1i1FIZVa3lEe8iQfNEDkHJ/ CprrdDbpNbiKaISAOZEy0ysQOP8Aa5GK+Bcm9D1oQ+83lsp7SPc4MnmASCML8yKQO3p3rldSgk+2 RpCCiyElkC8kgUlozVQZoWt5eLGsaRh0Q7HmLhVjHT9K07vSEiiikv42t7tVFzG+4gSK4BRgehBH NTKSWrBQkyTToLqWCC9K7UckRksCSAe+Pw60zUba1vZ7T7TLLHDFPvu4ocB5UA5AP+elXGPMZyup KJ//0P5ds295Nc6fGZXujKhjmRRnycnarLzjPT8KY0mn6Y/9nBHhnmnWRLgn91IRljH9eM9u9fn0 vdTueu48zRell0yGebUpNMOoX91ALGC4RQkluvTcwHULjpnr61qaTeyaPZXtuUjuI7pjIWuEDSJ7 KfQelc8XzK6Ma0HB2INP1SO1upppkfy542SXY3l8EHA+marRvdQXCXVrbrcxGQN5ELKzrz12/wBK mUmgirm7dxQSQfZZFVZp35DRgyZPGM9a5GDT4tK/tGzVxbXNsGleKcFJJx2K/wB7PbFF3yXBqzsf /9H+XTRLoTae1xq9tMrOxaGDBfb2GRjPUVsahPMLP7PG7W6zjykIHUEf4Zr8xjJx0PTUHYytPS2u 0W12GcWMmWZuZAR/Fx/P3r0/wx4gs9MkVUsFnheN7STzg0Tpu+XchIzn3rVNN2Rsk3sc1qlhL9tM ivC1mrkyzS8EZJwgI6kY/SsqeSLz4Y5Wbas/lq8a7iFz1A/CmPklYhm0i3hnL6kyS2d8SomVQ+VX opU9CP0qCwksZLuCG7mnhtFJREiUMz4BwvPQcUuZXsdEXZn/0v5ibjzWuHvNMdEtLUARiWVQyMjE EAHGenQZ6Vb0eSeMT3DgH7ZIXlbHyykd/wBBX5nPofRqbRJaSNf+IEtZLuC1jjXEqXeIoVznB3Hn t0FIJhK8zsFKw3LRI6HIfacZrTCW9svL/gDqO0LkN6zXVuYwXRd2S8bFWT8RRptvbv5rRXsq/ZLc 4Yne7NkAhuc8fNWk11HS1nqJf6zLqNtbafYfvJ2m2IZEKqoHDMPfH4dKpQvBaalFDfW4uPJO2W4D FI2XPLBun5VLNHuz/9P+ayTTIJv30AaOIjcZEAeWNetc7K/9py+U0QawUiOKRjmWcDr8vYcV+bn1 UZcpqxW1lbJ+5by7df3ZViFKnpg1jX+7TJoZbS4SG5nlEK7gAu1uSfc4B4oG5su3N5cPceVayxXU iDbK8pKxNkYJGOeOtXbG/wBZsNPaCSfy49SnNrcParksgIYA55GDz+FBGxmXmmiUjZIzXCPuQGTY sxHdiK1bqfy9NSFg0boQkixZxODxt9jn8/bv1Q+IE77H/9T+dvwEsd3q1qLi1e3CFYt80Z3nBUqA fQ4/Cv0M8MeH7i98qDTpJLZtR8tLZpLgxxx9jh/Q8jPev1zwJjenjKnZL8mfGeI8rV8LHz/VH9cX /BJzSppfh/BcRXbsLZSJ0kbzBdFRsYI3cK+8g+mPSur/AOCrUttb/BXxLYyTyIb/AECW1vFWUMGy GVMqemN3HbNfEZIva+I6f/T7/wBuPu88/d8Hv/r3+h/G74qsYLfS5ra8WSXWrHSFiW6hmWaGR41C iWYj1AzhcckZr8kP2kbm8N/cW+86l9tRkvSgCLpCJGkYxtxv3kHpnFf1H4pvk4Mrr/D+aPwnw8X/ AAtR/wC3v1PgW/0i2t5nS1ZgFOUSU4K+oHt1rbtIhHDESSZWwBt5Zse9fxjJas/eZvWx/9X+JfyJ I7hJRI5w2UVx8y/jXV2t+2BbMkrMzCaOTy/kXH8IPvXj1ep0HSQhpPvx7S8ZHJwR6Gl0172PWdLa C/uLWwtw0d8BHHKLtzlVXsy4zk9jivLmbrY+ifB1nNpelsbtvNW4vmmW/MZV8yHAi3jqFXaBXd3d 0lpd2htvtpilj2FwnmxK4XLb8dATnFebVKitUaVtfxEXF2be2uJdo+zySqc2zA/eUDHPH61tJqc1 xD+/uXeKU5JkcgA8jI9+vPWuZO1zrXwM/9b+PKK4eO0IlEkiRqeI13twOB61hz2SS6dbXhaO6t7m 5cfYwd15b9PmZCOBzgHPavm4/Gy4r3GV2vzYx+WltJ5aj92pO4kev19vavVfCVqbuzjvonaKG8/d NE6EIjLjLsevetLW0MoxsdPpeh3+qXV9CskM00EZmiR5RG9xg4IBPU85wPSoDpkltHPd3d2gSFiE gVdzdOg9W4ropx1sVY8uEd/qOsSQpHLbadNCGF/GuJYyTjAQ9TjBOemKbrVrpulXZtpb2e92MsUE hjEMMjMuQWB9emB3rrpq8hNaM//X/ih8TaqYVTYhQ7igtVXMi+59q1/DXiSytpLJnS8n2qYryMW5 Jizxu2j7wGQePSnSXLOPy/MKX8OZ+qvgGCyt9F0cTRwOhtYp7JPuLaRuiSRSEY77nIBOf0z+6f8A wSV1W7sfjXLp+kp5i3RST7Qt15dyRPCFmVeeBhMgeoFf3LjIKr4Qcsno6C/9JPxTguqqfivf+/L8 z+0HxQ0R+H8TPO1sj6MkMtxNGZmUSJsb5e+Axr+E39uzwwsvx08UW1xaQizjEj2rvC8VzaojgwZY 8/eeQrX4Z9HZ24prRfZ/qex9IOD58M13f5f8Mfm5qd9dW2tGISia0t/9FCmP72D9/PXPtWuumafd y2eoF5Yo1YNcIq7ZJB3AB6ZHrX9xw+E/maktT//Q/Eu1WxsNWOqaRpt6909zLDcxahn7KFPyh1bj PBJ4HXHpT49S/wBJ1LTYoohCZ/tUMNxDv28YIDH72Cc596/1XXU/hmUbM6TQv3dqtq4kWN3Ks0a7 3G49h+Nf2Ff8G6Orw3Hg/wCI+jwasL4aTcyQLbzPi8jgMkbRO0ecrkhuO1fg3j7GS4Qk1/Mv0P6V 8AEni8f/ANev1P6e689+Knja7+HfgTxD4vsNAvfE11oli93Fo1h/x8XW1Wb8htr+HXdQufre8rM/ BTxj/wAF/fC/gW71DTdd+BeoRahY3LWwiPiCWGEmNtj+YxtiyFTxgr14zX0f+yL/AMFZL/8Aar8b WXh/TvgjeaJo1zcpBPqVnqdxrLWavu/eSS+QkQAClsein0JHx1XiWtSxaw7pu17PfXbbt66n1mC4 X+t0nVjOytfbbR799vI//9H+/dTkA/zpaiOyVzeyCirE4q2wUUAkmtgr4k/bo/ak8R/sqfCyLx14 Z8M6Z4jvZL8W8serySJaQx4OSFRlYtnaOuOe2cjnxVf6th517X5Vc6MNQjXxEKL05ml95//S/sD/ AGD/ANsLU/2t/A+peIdb8N2Hh7UtNlw8emSO1rMu7Zna7Mw+YHv0HvgfeteflmO/tDCqu1Z3afyf +R73EGUPJsx+pq7jaMk3bVNLt53Ciu+54jVmkwoprXYlqzsFFANWP//T/v4ooAKKACigAooA/9T+ /iigAooAKKTS6gfE37bGq/tNeG/h6PE/7OknmahonmXWs2VrbW15qEsIGd6xTI28Lg5VQeDzjlh/ MZN/wVx/b7vPGV54Gg8cDT9dhv1to9KfwpptpqZYHBT99bELnIyGANfP53XxOGw8qmHa2f8ASPQy /CwxmJp4d9XZ/wBf5H//1f6Gfh2f+Cx3jvw5pPidPFPgWysdQs0uoLPUjpFhcOHGQWItcnr/AAnG a4LWf21f21v2TPil4Ts/2unQeBNW1CO3vtUi0mwl0aaAttke3uLZVBZQQxViGwOMHkfC/X86hl0c dVsoWXT/AIHX/hj6GGDwGHxssNjNXF2evVdNLa9LH7x/Dv4leBviv4X07xl8PfEumeKPDupwrNba hplwsyrkcpIv3kdSCCrAEFTXc19Xhq1LEUY1qLvFq9/6/LoeZicNPD1XRqKzXQKK64SS0ZyuD6BR VN2aEo7o/9b+/iikmm7IbTWjCimIKKlSTV2VJcrCinzJLUSi3sf/1/7+KKarxNPZvoFFP20RezYU Ue2iHs2FFHtohyM//9D+/iimq8di+RhRSWITdmHI+W4UVXtokqLfQKKPbRDlfY//0f7+KKr20ew+ RvoFFHto7AqbWyCiq9rAVgop+0i9gP/S/v4orRzVgCvLPjNr3xB8M/DzXtb+GOgW/ibxbY2/m2Gk Tq0n2j12oCCxHGRnpnp1GbmrWuB/Nl8Sv+C5f7S3wg8UXvgzxt8HfBtjrWn3MsNxFeaTfW1yio2x WaM3Cgc9xn0wDX118E/2/wD/AIKBfHfw9aeJ/AX7OPg/W9GuTgXsGl6hBERgZbL3YA+8OCRnNctX FU6daFJvWV/w/wAtDqoUJ1MPUqpaR3fa7/4A/wCIv/BRX9uH4BXtvqXxr/Zu8NaR4QkvRBcajDpu owJEh7rOLl488jBYke9fsJ8DvjZ4E+Pvw78O/ETwHrem6rp+tabFdXdrY3q3U+jzsMTW068MrRus ifOqk7DwOlXUqxjFNk4eHNUcX2Z//9P+/iiphVjcvkYUVt7WAuWXYKKt1UtGzFQaeoUUueJof//U /v4orbniS43lcKa7FUZgrOVUsEX7z4HQfWhSi+o5K6sj8Wf2lv8AgsLpX7MvjzUvB3i/4FeIZILD UnsV1GTX/sEkiRkqZfKe26Eq23BOQPXIH1l+xD+3z4A/bd0fX9R8H+HdS8O3Hh6JLi7gvLxL6F0e QxDDhFIcMOVI7jk845sdiIUKULv4ny/n/kdGW4eeIrVUl8Eeb7rL9T72r5X/AG24bif9lT44RWnF w3gW7SM527SyhAfwLA/hX0vDUl/b+Clf/l5D/wBKR8nxddcPYt2+xI//1fzR8TW8dj4m1p545p5X ux5wLAeZsUIdhweMqRnmvGtclieSQ5IuLo7VIGGVR0BP6V/rRlbUqafkfwxXT5Ymdp+n8RtJIZBb SF1iPKLkdCPfFa5tjezSCIJHIOQrMIUc/wCz0HevXsk7nMcHq0lwJhH52Gt3wIlO4DB59u1L9h8+ xmufLzKxAAztJ9SMV2Ul7tzOp0I/NjaE2zjzJmAAGCSmAas6cFxmeIjyiUCg5Vvf/PpWpmf/1vxI v7HSUspbgKY7h5EVUZN4cngnPbtWFCu+SKIyiNNw6DoPpX+yKV3Y/gc0dTtLZLiCYEsrgI2RkM3r 7dKry77Vi8+RGR+5HYgccVfswEuNRM9ukYJheX5A4H3R9PwqraeRFlBlyTl+PvVoZStcS5uvLuI4 EiKWUnErrHvZfX6Vn/ZZp2ESSNsSTK5GC2a0glbUg//X/B2W1IYWvmFFJ2+Z/Hu9BTrcpA0lvI5k lCmMO449M1/tBax/n+cvL9qF3wGfyZDiRVxjBrZQi8SWR3KyOcsgBAGPX9KtQbInsVrtHe3W1tJI kuN3MjDPHfj1xWlZxBVWGRx5oXlV6H3IpcrMhIbeBbiUszRxIpA2DJLdqo2lyqXDSXd48BScKo2b 2C547f5zS5XexcZKKsf/0PwpmS2WeOeSSPzJjiJ1QKH7cfhXL6nIv25oVikX5QfMVD5TH69Pwr/a Rw7H+fV1yWKQxaSiTLPIo8wqh4NW5cgx3QAQXaAhM5wSOh96agZ8yvYigmnLOkTNG0YPTgKO9W5v Pt7bc14rNeRGOWONsPtzj5vY1ZlJ3ehnLo18sW90ItyN0bnowq/bzTy2klhb20ZkzkSEbihHSgVz /9H+f5ILhFDahceXKBshWF90ZPc4rSD2MiwC8cRQQxbXkgjCySMAcNt9ScV/tQf52ylymTcC3nVG 85s4wm9fmPoDWeoEG/e4y5wqDtQOLurlJppXkYCIlYhuLkYUCrgtRcsLmPIEXAJPCk+34H8qC4ys Pi0t3iM0gDASYBUce1Mktwo8sId5bCEccf5/lQaKSbsf/9L+eU2whG48SJ8wB78+lakl39rgRLxR HsHyFBgV/tQf59Rly7mPEjDzZo2OI325HBHT/EVZS6QSRrKhkUN8rFc7SeKVl2NLpmhbXMczXaS2 8heEZBVcxsv1rIdJjzbKsUSnATGAB6VXKx7ER0+GC1EsahbmWUmTy/uyn/PenW8JmWQSfI8fBVhh hRyu9hNpK5//0/53Jru4gVgsZlwdqgDOabcmJ7WG7iUs7jDkHPXgY/Wv9qGu5/nuVom+U25G2Vhv GO445/lUM0sdxp68SO+7/Vsm1HUcg5znt6U1FvYlyS0NK2R0gMhAYbeh/h9qrJHercQ3MLyqse5S Eb92M4zuXv7Vfs+xldmzLcTZE8UhjEY+bbwzHpXNtlbh5ny5lb5iTyT60uTWwj//1P5z/lkYBVOU 6cVb27YN5JJzjaOo7c1/tRbof5681o3EtpXtnkdWDvjfGqkHnqAa2tY1hL+zsrU2NvbuF827vUy1 xIx42E5xhcelFrGfO7mZJKGtBaISUT5umKxorYwSteKhutv34JGJXjpjnj8PSgfOy3bGWZ3lWExB h/qxztyehptzY3VsLc7g/nv8zlSTGOwNBpzK1z//1f52TmBg2QZEICpnJPvT5o4ry5jE0oG0fOrH HSv9rILqf54N3Yt5sVRCgAA6EDg1lRR8sGBPBz3FTJWdgTsyvBje6yoSiNkAd8HtSzs5VhCrrC3B BO1l4xn61JuHzW9qsYeR0YjIdy7E8+tRwQ4ZiiMyjhwcjbmhq6sRKTTsf//W/nJWVLKRWc5bbkx9 Wx6Yq6+oxzW5/dqgzuicptev9o3C2x/nsncqMgmXYWOcZGOa14Z4wu7yEixEIztGOgxzTUO4zIuJ LSTIl+V1b5WQcf56Ul/ZG1sIhZ3YmW6dWcIP9UF5wfftR7PzAzdPv7yzv53kkElvsVY4SuCvBDZP v/Stdk84OzRiJpCXUZzwec0vZsD/1/5xj/ouVd9zdAexp8cCuC/98dfSv9pVDuf57kUlus7rETgL 8oOeamnt/swSNX3bQCzDp9KmULaoCFriQnKnOBtUDjFOKS45XO/oCOagC60NrBDFEoeCc/3V4JHY /Wua1uUw2lwHjZR5ZLNjAbiuarpTl6fobpXqR9T/0P4wfExhudZ1NE/0eG0lL274I83PzfgecfhX NWb/AGuYLsYqwKbyMAH3r9C44X/GV4+//P2f/pTPlOHP+RJhv8EfyRJNa3dqNo2FATwMMD7VDGxZ 2MkawomMhRgH6f5718olZWPbL9zMsUUarIRG7bhjpnFWrMhpFEownTd6HtzWLVmzRfCj1jwp8Pdf 8XX0dp4asLnV7k2ZvHgt7WRwyA4GHUEAknG08nBxXrdr+zZ8T9RtLR18AeJYvNmMPmW1lK32cAj5 yCuD34Hv0rhrYijRqclSVmehSy/E4iKqUoXX+R//0f5SfFHwP8aaElpLJpF1b20t1NBfz63bvpsM IhTcChZNhzg8FvT1r59mtLlLi9iM8DJFO8am2cSQsVYjqPTBFb0pKpS9rHbVfkZ16M6FX2c/63Ip bZ44/MJXeV+YA8EHpmqhR5vKhUYxwNowOaxu73FJWlYmiWa0ZWZ+hIdefk7c0skshBMh3QyN95jx +VHMxOLRdgeNecnp8qjofrULRQWCC4k8uHLGaedhgAk4obb3CCuz/9L+TDQ/hL408QaONX03Sdau bF7T7XFf2ekTvCRuwcMU24ByMk1xfivw3qGi3As79b7T7qQmOJdQtmt5SyAFlBIwTjkfX2pU6tOc 3Tg02t/Izq0K1OCnOLSe3mclcwMyxgM5I43AZ6etZa3FwXlUyKEjcooUdhx/SmZJWVipFvUlCpHz ZOOhzXQWmyOBZlRtzPtU7SD+PtRYG7FZ9RlQtHOpZC+PM6bKpnUWhcQKTMpB+ZhgD04rNwtcZ//T /jA+0RyIqqq+YqYZAPun2rS0Hw1q2s3Q/suP7TdM6qbdI2nkkQsBgKvTk9e1c0moq8tjKEZSlyxW rPa7v4OeObDR4r9vCviIqYy8tyNGnisUC9f3zDBHv69q86/sqa3x9sUIWBK4O5TjuD3pU5RqR56b uhTjKnLkmrMjQGCNjMy+WDgAdAPWqZEOVmiw0IyDgY2461RVPqSrbefbmVCFUsdrdxj1p9qrZEgc K2MIx/ixnigdrTP/1P46rtZpJFzsQE/OT9760kUsttL5buzfxBhz+OK5xWS1JJrqQDywCIiNzzbs N7jFEEJnIKSYUjMfuamSuhl6WD7LGkrlnJPzEDOKqSTozKRkqeTxgDFY2toBtWd3AVCNw+MBgPlI psgRWKk4iRvMJ/vewoA//9X+PC8LXRBzsRAdh64/zxVm0uCkSKSMgfNjofwrznsBcklDICyE7T+A qpFLOzN5QAVW5ycDHrWAFhLZ5pDPK7lF4VAeB71uRGRuWyYkAK81nNdQIpbhXZty7ju2jHJP1pIS XuDGXwoUbE2fcPu1EYprUD//1v5IhdSLc+RMArR8bx0b8almndwqSM0ce/G5B0rwGrOxvFWSITdB fkWUFt2xHHU08XJkcRCGQvnEkhHSkTPY6rR7HUbyOX7LHLeFXWJLWxja4upmYgKqxgZJyfwHNeyx /Bb4vtFDNF8OvF9xZzoAS+jzRwgsAVw209qmU4RaUnZs3hRrVKd6MW7blm1/Zv8Aiydnn/DXxixa Vn3W+jTSwKBzjcVAJA4wMVaT4BfEmOOZbb4d+P5Y1YvmTw5OFQkcqpAPcdMVdrK7LWExOvNA/9f+ YrVPBGuaL58Ws2d7YDT0Rr6K/tXtb23LHHMbKDjPGfXFebXlmi3LtHuaNXwQRh/xFeBZnTKLg+WS syaG4cDG1Ch+UbuMVVvneKZXtySoUAjtnuMVLM56I0Bqd1AkSQRoI5PvFyQyHHUDvmmIWTYzsHlc 5ZwMVFToWttS7dK0ke5VO3GAxHWs6GLJcyx4KqNhJ4I71mB//9D+Va3kQH5AZEjXDH+HOelatlIs FuxnhkngEhuDEkYz6AE9cV8udBQeGLV7WWWGQ2y20hYSTRkL8pwVGR0P9KaXktmWIqsKgBJHQ7iT 1yBW600IjH32ka2l6hZLKLe4tk8xm/4/Fy0qJ3O3oee361duJrcAy2zkKjFSXXaWA9BXO0rlRWjf mRvNHcQAGQecV3IqsOcetcsls6XkkrSHMjbzGvKg+5pSXusZ/9H+WSBNQLTGBYyAmViJxux79a1l abEWyWSCfgOwT5k6ZUZ7Hpn3r481lG6NuS7SS12mFElVdoIzmQ+vP9K5W9URQ7EX94cksxJJ44zS aurGbTW5DpdzdqihgquCT1yMZNWoWP2mR4/lZj8zr0P1oaurFRXusuJNuEkcuTzjGcg+9EcfkB5I yybB8uOR0pWtJehly3irn//S/mAh1dmmS4ubCG7CAxp5khV1JHXI5HY/hToLq4uYvLIjjk3Zkii+ dAenDEAmvj1Gy0BRtsiV4JVZB8qAD5mI5NW7VJH3KWAizzgYqlFvYfK+xXdnjvMbi0aHJwODTpDK T56HcUfcIwOWHpVqC6j5ZdizDeQyM8ghMYznYRgr7VfiuDKMkZBOAepWq5US0f/T/mQkQx3MkqZa TG0Hu3fH6U1bxVuEjukaJG4DFcMT6Yr5FxaA2FvPKt2EFokjrkpPkiQ/7PXGOPSsya4aWCZ7i4SM umwQIQ2Mdsf1rGUeqArWNw8MwaIMqBQvl5Pl+5+prSuo4pDcyCMMZo9sm4bgQOMYrBxuzaCsh+iT T6dZxm/g8+F9wmsCCy+Vk8KBzkjsKTRbPfqt8be3litJmB021WI+Yisc4PfI9Ku1tDeC0uf/1Pwq 8Ofs1fHXxrpf9r+Cfhh461G1lGYb0eFbx7G5A6mORVOa7qb9iX9p57dL+5+E/j61tXjCQPH4bnkt 7mToweQqCMegr4WilK6Z6NWFkmMg/Yi/abQy28/wU8Z3lwJBC6/2BcRxTKw+Xa+w5bn7oBHvXGeP P2cvi/8ADDSGvPHXw88V+H4tPVjqC6joNxZwx5YeWEd1APB5zjGK0SSqcoRh7lz5+8SJLZWPnWwM rRwCeGJDw468H6Cq1heyPDbF3wjqHa3YcqccZ+nP510SjYyjHRpjrmSCZ2j3KGxkqopjRw+RsyXE uY5UZc5Hes3FNhKKS0P/1f5sI4lgtZIIGKAxeWm3goMYGPSq8VgZrF1uJGjuR/qmQ4R+Tyc8jtXx MoW0Z0qLexXme7kihjTaLmKLy/MJwZCO5ycdsVnWpuHWV7ghoNxiyRhg6nDD396Ti1uCWtmVY4rS 0vXuruadGEeUgij8xJRngnuMZroihuQDGxjVuV45YdqRtZbGbqGmB2junn2RWi/McYGT3Y56cdPa uz8LfDLxn4svrFfB/h3VvFkl0QsEOhQ/bZPmAwTGuW44z6VXK7XY7H//1vxm8OfsYftJXcsEGsfB L4gKlyGkZH8IXv2qTugjXZh1x1INeZ/Ef4N+Kfh5eeR4p8E+KvBN/BIbKW11jSprG1uiAWUx7hjO Bnj16cV8JR96CPUqx5ajij541SKR7yC5adpY3/dsjrgoFHBz19sUyeFpJYYrJvIYuFJY4Xb3x6fW rIs3oXhFbQwajaQTfanAEbuEzA7cZBPt7ZqnZ2rDFusOIwc5T+LPUVbhZXQjqprWGKwLSt5ICE4I wRgVxohE1vGyzu/7391JEwV5iO2BWUldGyj7tj//1/5m1kAZUClJVIzIOWH+cU+5eJnklLNKsPOW T5s45yK+BlGx6LTTszOuYYyz3KtFHeXAWKNGyvm9cAAelWP7LiiLG9DMqJnyioKBhyMg+hFSaQVk U4dZhe1MeLlp/tJA8uEvEIx6kdD9auxzJbxmZidpbKibjFAp9Dt/DHwz8feO7uS28MaNquriC1a4 eHS9Nl1BzISPLRVQE89TnFbPjf4L+P8AwRodrqPjjwb4p0BpSrPLqXh66ghJzlcsVA+bGRnsDXNR /jyXmbVYr2MH5H//0P5qLm0vrWJvJjkeTyd4MQyrKQfmBHBH0PeucspGjgS1umMlxMTkYOMjnnHA r4e1mz0I9DvvDng7xb4s1fTdE8NaFq+t32oPshTTtOku4I9mC+5lGAQCOOvI4r1Sb9nH41lxL/wq fxw3kyNHO76DMgKLwChxzk9O3vXHJ2xKR6cYXwrlbZnl3iLwPfeH9UitPEmgar4b1O2Yk6brWnvp 925YfeAYfMOD0rkYbK9E88j3MZ0+Y4RBHtkQg44New4WpRZ5tP8Aiyj2FhtJ0jub3zFaJZPLIZt0 2McHb6deldloPgzxf4hsJtT8P+HtX1i3UeXbzWVhJMssisVdEIHVcc+mOtcdV2v8j0KS2R//0f56 j8MPiPp1nIdU+G/jOECMzvKdEk8lU7uW7Adc1xl9pz2V3NZsskbW8CPJFPlLmPeM/MjAEfjXyeHT lSb8j1MT7tXl8zmbqG0slSSXeIlk3SPbw+ZIec8qPp+tJcOL64tXtJpOVDRrKnlsVA7g9KzI5Wlc NQv5o32SeTInlgFpHxKMHHyjvS2KKxaVYLQLKgSJowFkz/FuHY//AF6iewl5CXcMcsLi2meVijK8 bfMqNkggGsbRJN8EslsmZ7K88mQecY3cryAF7gEcnpzXO43Z0H//0v5ytXbRPF7QXt3p9rpesWti Ptcluuy21RlHyggdG/nXCfZJ7XNrfBZLANut5g/7yPLcLtx27GvgZLldj3IId5mrabfG90rUGvJH jFklncsDhD1OMHqDgVl2tz/amtPewPKkthmG4Ujy4xJ3G3v9fSpS6Gh2ltbWzabe28qxf6Q2HRsK VxnGD+dZtqLi9s7h5LZpLDSZFtrdWjZpHBO35SASVJzg9Bg1jiU4pWNKcU3qdC32aC2jAiuIYhnK CylVU+p24FcfLANTYzyW80Nv5pWIkGJnA74znB6/Q13YSKlBs5cR7tVI/9P+YSO1NvNc6pvRJhiz jFu3ltGqfdZgBzkZ985/G3baRLetHNcQMTKweAyREBu25f8A61fn+IWjR71OKuma39lPayTtdQSI LQgL5EZmLbh2Cgn6gZx3p0tgJJQ72olig2vEr/ulfd03KcEjrxXNg/ejYzx65Z/eYOrQwLEjYaC4 SbbtUDy5BxgYx9aSzeS2UTxKyscqCy7Vcj09ulVUguZpmNN3RjzRaxfyzX7XUUohk3tbMQpx/s9S SK1IobTUVt7iVZlvLJiYd0RSN1ZSpBJ7rjoPahwfKTJ3Z//U/mptnspYTZRIn9oKplV3ICMij5h+ HWlhfTp7eWN5oZbiOQxRRIQ3IHOe3HTFfmFnex7C1Ry0dpDaXi3mnvJayOfKlVDmOQZ647VLqQvJ EeCG5ljdZSTNGVIkByMKecfXrxWsYqJrT2KsjO0MVu1yzyxgOIZCSqMP4iPXgc1XudQWO3jitlWS 4hkILCMkuzDo57AH09aos04ZBeWcHnPIt2o+eIRZgzjnDfl2qtHpUj4uZUARHPkbDxnp/I1lyO9j WC0uf//V/mOiVY0mjuLdLhWXKK4+6fpWf9o8ud7eCXBWMEoox5GfT/CvzOa6n0Lt0Hb7KZ/Je9n8 2SII955W5o3x0Y9OP8imWcNzZWJFzeGdPtLFg+I4414AYH1PfPpRh7qp8wq/AkQ6lNcW7QhYzH8+ Y/NYrHISMKTg8gg9DXQR6Z9mZHDKqzxiaQKuzBYZJ9T1FdMtYpmlJe+MmuoNPdZ9nnOn+r2r0qe5 urZbC8urq2DNLAEtkKEurMVwcY49PxrI0as2f//W/mWjvLgwR2kEKL5kWwStLsETfT/69RQo6SKs m+MmM7QigopUjqe2c/pX5vsfUGnGfNSS2mVDbSr8ztywPr0rMOmrP5tvAzySKNsM0wLiNiOCueuM /wBKAIrPThZ6pBColeJ1CSSt8xV+pY+1ax1ObZqGlsnk2kTieOVIhIzMBgnOMj6UCezLVr9iu9Pg uSYlmFwyRf8APX5AMkjsPm4/H0ps1zbC5CJ5jyXAAki8v9xCF7hvU+ntXTHRocI+6f/X/ATwHeRJ exwHa823/RwE3uxBAC5HTr3r7/8AAlxq+PDttJbWyG5uUjs47hhJHblTvYHHOAQePev2HwMXLl+N qf1sz4XxGmv7RwkPP9T+xL/gl/pUGm/BPRr6CS3+0/ZGguIbZDsRnOW6/wB0jHHvXkn/AAVo1LSz 8KdRTU3WGWdhZTOyHypI2UgAkdM8fjXwnB/77xGi/wDp7+p+g8UP2fB8v+vf6H8f/iKxnt7m7s9K thZ3F4s0YtJblrizMbqSCgJ4ABJH4cDHP41/GPUft/iO+nnmkENvctAsUDlFiEeAyuDwWDbjn/ar +n/F33ODZru4/mfhnhzF/wBs69LnxxfXV3NfyyTBSfNJ3HglM/Lx64xXSaPcwyndHuMiHbgj5VP+ ya/jWXU/dpfEz//Q/i1jgmuYySBGFw5BIDHnHPpmukuNL1jTrGzvptPns2lz9l85AFYKfvqe4IwR 9RXj1ep0Ge+vyIl0Z1UXMcYkQRrjfk4OB0z14HpXT+CZPD+r6glvdzT2kN04tjcCPbPHO4ABAOB9 49euPyryquxtB6H1bo+n3mm22m6Lf6xPq1oku6eJ4hFFCi/dKkcbsHGe+feuuvIfsVy8Nk8b2t4+ bVXUMrkZIB/A151UtOzuYbaPevJfBCypDD5kqD5G64+X3qxbXcF1DZ2Vzp7BYn8qNJIi32k8t87D P64xiuW1tDrptWsf/9H+N21ttRtYbfUby7KWN3IY2tguJbcgYBdMZAYnOTx+VWo7bTo3u3na5u7m 7tfItjDKIo4PmySR7j8elfO2980j8DM1tQs4I49LQASyt5SpP88kzDJIDnJr2TwyLa20KOCyupp2 twzzROnzRk/exzz/APWq7WMluWdOvUmivFjhkN60i/ZdzmNEAJyfqePpVXTJtOk0+/e9vPsTLfO1 za3KksrY+8snQgmuiDs7lNaHN6xfW1jd6HHZzzXMty7vMkUB+y26DIXe/TnIOPes/XrWzv2g+1QM THKtzG+Cq7kPHzd/oa66btIlrSx//9L+MHxFoiX19Be2zeZbsn2V4t6tcCccn5B82MHjNLpOlywL AwWZPOuVhjliUAhtw4J6d+R6URf7yK8wpq0JI/Tf4STXGp/Dq6tSsDyW2rR2cwuBi7do4FMRTv5Y 3MRiv2q/4JQy2+l/HJbu7tGtr2wvdM07TQjM1rqh2tLOxY4wV3qvGRnH4/3NCXtfCNKP/Plfkfgv DEuTxb5f77P7ltRsl1jwqumXOyKCbTGe3kf5hCHUvEePT5a/h7/4KgWjaJ8e/wDiX3B+0app81nc xyq73d3m4keEov3Rt5APpX4B9H6bjxpOHlL8mfe+PdGMsJTm90/zaPyU1VJZ3eNISLqC4aC7ikja K4t2wGBkDADBDDBBPerun22sQ2ayXVtJHCASryA5mXPDj27Zr+8YWsrn8r0Y6s//0/xhuYL/AOyR zeX5EbkspLDJ98Zqlp+nRmV5bud5CHIUxEBjkcc/Wv8AVhNXP4fnDodz4YtWjunW6YNECHtto5HQ Hca/qm/4N27qzsvEPxLsLJoDcagrvdvMCtw4Vnk+U987R1/u1+F+PsXLg6fL/MvzR/SP0fLLGZhF 7+yf6n9YY6D6UMoYFWAZWG1lYZBB6giv4TTfKkz9ZkrSaP5E/wDgvn+zl4M0DxR4U8c+ENJGkarr l3v1QWYjtbJzPEQRtAHJa3ZuSfvEemP2I/4I3+DvCmg/sg+GNV0PTLe01G/vJbfUpliVZmMW0EFh yQSWOT6mvksRThHP6Ka0u38+Vtfifd5PUqT4RzGrf3o8sfk5JNfNaM//1P7+KKwTtsbvRBRRGbCS smgopybUhpe6FfKf7W/7Men/ALUfw5k8D3muz6DIkhkguVQSQEnBw64J/h/U9DgjnxVH61hp4dv4 lY2w9X6vXhW/laf3H//V/sR/Yq/Y1tv2RfDuqaNaeKD4gbWcm7AtjDEhEhdCuSexP5n8PuevIy7B f2fh/q/NfW/3n0ef5x/bmN+uqHKklFekdn/wOndhRXoJ2PCkrtMKKuDsrMia1CimnaTHJe6j/9b+ /iigAooAKKTdgCikpJgf/9f+/iikncLWCimAUVE9gGuiSI8cih0dSjowyrAjBBHvX8Pn7XHgm38H /wDBSi5uNLsk0uzvvGUF8LSKMRiWMTGN5AvoyryfavCzyKll82+h6mST5M3w9t3JL8U/0P/Q/vP8 ENG3g3wkYgoibwxYOgVQigG1jIwBwPpX5Pf8FtfBVn4o/ZAv9T+wWtxq3hrXIdQsLuaFWmt1LIrq j9RklTgddtfMVIwrcPuHT2f/ALb/AMA9LNYOWa1YS/5+P/0s8H/4IReI59T+G/jnSJLm58vRxGPs MzZSFjKqlx9QOPQHHav6Aqw4YnbLOW97Skj2OKLLFUJJaulT++1gor6TmVz5xX1uFFXe6FFO7P/R /v4orGOlzSS99BRQpO6uKUXfQKKkqa0Cim3rYcVaJ//S/v4orznLlaO+nDmUkFFXKburEQjdSXYK Kcp+6yYK9SMQopc8hNNOx//T/v4orzHO0+U74QThzdgoqlPllZCp0+aEl2Citpy5UZwjztx7BRTc kkSf/9T+/iiuFybOlJvYKKaqdGU6ckkFFXzK1yGujQUVSdtUJxT3P//V/v4orKUtLBa2gUVm3ZFR XvI/j5/4L8+AtH0L9o34deL7G3FtceIdDhTVI48qdRka4+97fcIJ9WHpX9F//BPcWT/srfDe5srK GxW6tHmkiiUBiflxvI6kDFfN5rGbznA1V8MfaX+ajb9T6LKJxWTY+i95clv+3XK/5o9L/a18I6V4 0/Z1+LOk6vZJf20Xgy+1FIGHVoIJH/VQw/Gv5hv+CI3xE8T6X+0TfeF/7cubTRtVmk0u40JpS1tN kMxATPUFY+fYH+EY9XEykqa5O6/PU87Axg6759uWX32dvxP/1v7+KK83mskzrhHmdgoreM7uzIei CiqvrYSSSugopKV5OPYrl91S7n//1/7+KKwk2oXNN6tgop03qiZKzsfj3/wWk+DPhXx3+yP4l8a3 3h601HX/AAbdwTwXggVL2OBvMDOJR8w8o4br03Cvg3/g3nL2kXxdsYBnTpdGgeN2YF/OW5TeMdf4 ia8fiOSp4fCyf/P2P6o9vhSLqYzHU1/z5n+HKf07V4N+1Darefs8fGe3bq/w71Ip8u/5lt3ZOP8A eAr7Th2fLnOEkv54/mj4Him0uH8ZHtCX5H//0PzZ8elYPGPiWOJ7l1t9T+zfaCpaMKR8pUdhzgj1 FeP3Vk9ld4ni+021wwRCV3TjccZX6V/rHkz/ANng/Jfkj+G63wr5lCaMw3F3Dav+6WVkWQ/xBSQC aoXKy+SJcmd1PEa9SPb3r3Thi9LmPLYPZXcE15grdgP5LEGWNT0OO341oS3UTM0dv8sK/KFI/Wuu k/dsTM58xiK7knQLLgclmwymrYkaAo6ESLJycfw1qZN2R//R/Eq6naeNbbGFfDZxx7VlrYRWtzCW j8ybJWOVjjhiM4/IV/sjHdH8CQd1qS6lbve3jWFrO7+WVd3QYYMMHH8/1purIzJGkxd0tY9rFVLO nQdB71uVdFXSbBZS5md5BFGdjyDc1Z0oeCeTYxkUH5lEeCvpz3oMZSV7sa147QO+GjwdpboVpF1m S0wXhEgA+Y4/eH3q4XuZOeuh/9L8Gbd0u5fPAYB5PM2SdcirV6kMbKxEhmkBztXIXA7/AFr/AGgP 8+XJsxBJcT26xiNobia42KhIwyg4z9f8a01tZ9PkjjjUSO7L5h27sA963SsrEyl3JG0ppdRiWZoI UjnVvPB3Rtz14qWeKayubhJbdIpRIVG07i64yCPQc9KYrozL28EKHyypnJ+aLHQev6VnRhFPm7Q8 8/MhcfKvbigZ/9P+f6dVtp0heeR2kxNCCcrADjIX8abLPdhvLVt8B4dsZcdOR61/tTZrc/z2vpc0 Le1D7J4o/Mcjy9sq57EEkGqMrG3mjtWtHVWcnKruQEdG9BQotmBJb3q2E00kaRzPJC0Mm8Z25BGR 7iqBf7exQqxyhDY+X9a0UF1A6jT7680nSrLSZDc3lvNM0URmkW4njyc/UAZ/WsPUbS9s2YWU0tsL 1SsyQuVZsn7pqrLYD//U/nvjluJI0gbbI8JJaZmy/GBg/lQxV2ijEoJIZnBG1Vx2z6/41/tdyo/z ucUxz+VcRJGFaORQSxJpYrVZVHVihyc9KFFIhL3WhVjV1mRG2zL91dvyMOc81QntzFGrq7oc9A2A 3sR6UuRCg7OxasfMiQnewiJ8xwWJX8qtNMZJB90xso2kdcdjT5EaJ66H/9X+e90j80AsSR0yecf5 NRX+SoW2YueNwK/dr/a9RS2P89XJLQSG+xatb/Z0Vt+TIQdxxwRTIrkqxiVCcj5vk+X8KZXoTWkJ WK4R7qaMy+/OD26f5xVe9ZY44ljldiPlJJ+90H50Dbb3Na3EUduQ+17nysx4I/dk98VjLcTRyym4 w7zSnlTyoPc/qfxoJbstT//W/neaN1LEtuj6jjrVWdLuGApEMQXBBQAA7Menp61/tdKN0f54ubZq adNBalg8eZ1s2iWXbuYllIyc/n+FZalnWNXfckYKF9uMn6duc04rlViHJLdlyN0ktZdPWJnedgxn LkBApyAB2zxz7VMJnhibdGkUhHlhQ2Vkx3FVZ9gTT2KFqty8cxl4fJIVBlVFQ2cWXb5DcmNsmNOv 0pWGf//X/nVuoL60je9hQNaiRIpIW+SVC2QOv0NTz+S0Q8pmjym5vMxkHGeMV/tekkf54t6WKOnm F52QzIssZAKs2Cc8Ctq4tVjhdp9zsWzHFGRnP40NJ7klSS1ma3eTGzauApHzYqhaPNDHKiRLM0i7 QXbG3nrS5VaxDlZ2JrY7SJIYrhWdwk0cjhiD0JA6AH0rWvpZFARlyrLgEjAX6VPs3cq6tc//0P50 DGDINrn/AHj2onsnhdZFcMgwxkU5Br/bA/zrc30LN1dQRxfMD069x9KoLMYl8xVyGI+VurChq+jL jJMTzvlkJt3DbvkMf3V+v61VuGliReCxbkqBnFQ4J7FxlymrpggeBZJAGkRuEYcL6UsklxBuRCEE jZACjmm4+7ZCbu7n/9H+cd7JpnbJ/eyEEMxwtaCQQpbzxXLI8i4CsvCgf49K/wBqWmtz/PFSs9TM DNaMs2zzFVwMD5jgnGfwrrHksbu32OyxLt+aaNfnwBwSKcY3djY4hraUxtMxXyd+EJI3H3xV+2mH lmJh8pPHt70+R2E2ktSK6gWdkS3APZjjGcd6e0aw+Ukk75RQpY+gpckiedH/0v5z3gSYRk5eFDnd 0ZhU8dqsiv5chEKjO0dR7V/tXyOx/nrzxIUht0lVY5Hkd+S4OQhz0P8A9arVzbeWFaW4R2fJaMLj I7c1nJaNApJmW2wuAqEBe/bNWYXcODIQyY2oMYK+9YFFk26tKgad3d2AiVgNpPfpSeJrdLPR715I fNuDakRHbmFCRg7/AMCePXFc1dWhL0OqnZzj6o//0/4xNRtBc3mr3Ek53xX5gNvtxjgdPbp+dZJi Fkp3FSJOFwcNx7V+icbp/wCtWPf/AE9n/wClM+W4eVslw1v5I/kil9qFtHvkQ5Zj5adR9aml23cK lgQuQcdCQOxr5M9xQd9SyLASRLC5B2ncHB7elWlt08swSKwjZNmVOGx0zms5Ldmtuh+4f/BFT9on 4AfCH44nQvjcojs/EV4mmadeanp6X+ladHttijFmBKqzo4bGQPMyRgE1/oleDvgt+zv4/wDDGja/ 4N8N+FNS0q/s0msLuy0i3MYQorMpGwY69PWvlc0pt41XejsfdZRf+ylUgvg5k/vv+qP/1P6Cf21t B/Yu8AfC7xPa/GHRPAumadBYTWXkax4fS4QblCjYuwjkupwvOAcnANf5nX7Slv4LX47fEWT4WWlj a/DqHxXdWnh37GjRxSW2EkXajc/I0jJk/wB3qcV7UcujgsiVZ7zmrd7crv52vb8DglmEsbmfsr35 FK/rzJL8LngE0AYNGrPuLYLk8nnpT7S2MTFC53sflLdSR6V48Um9TskrSRea0l8i5DPiSYEB2QFl PrWNNFcJHHAI/NlyMyOmFI78e9ErX0KezFt2kjO5lCoBgHHANdlpEQv/ACbOSGGRZLiFmM0YkjCr KhJIOQew57mp2JpK8z//1f3L/wCCUf7Lnwh1z9mHwZrup+ENA103Xhe3t3N1p8MoSUwosqbNv3dw bIzySSeSc/hH/wAHHP7KXwZ+G+n+G/F3hHwtp2iX0niCIyWmn2K6cL2UoTj5AASF5x1PqcZrzeCK X1yjicXN68s3+B7XiBiY4HG4TDUdpOK0P46ZZJXaRYcBdxUoRgqRkEexGKpvYFPm8tmmP3VQfJ77 v0r1GrM+etpcSytmuHAniaF92URxtOO2RWtEs0LTpMg2KfkUDJx3NSZvWSIp9NlmhdoF+SQ/ekH3 fcVim1jiQrOyeeBtIToe1A5NpaH/1v4wYbOfzYxtjQf3yflNfrH/AMEmfAmg+NP2wPAHhfXtO03W 9O1UwGezvYRLEwWb97jPHCjdg8cVw5gnLC1Ev5X+R15Oo/2ph+fbnj+aP9HPxb+xB+zprfwYvdLu fh/4eeBPDguEt5tIi+yphcfLx6cjv71/mcf8FBvhX4V+Ef7TPxm8DeFLOTSfDug+Mpxp9la7msba O4KSCJN2WAUttwCQMVWSYe2VSk+ljl4gqpZ/7GKsve/Bo+HCWuJFgjRnTGD3zT4ilqGikTfHjlAv JraKUk11Mo6K5YKIFYwBliwCUPTOPSsZrloX2sMEnJVeQKpQstSL63P/1/47BmbZKSCFHII60sgk yRxkcg46VjZcooe9NENzNsSMSoSCQjbVJyScAGut0+1gWRfLXzTsXMTjaUJHP5c1Iy1qsK2cSSGK Ro3O1mVSyKfQntXOTQIwSOMKC/Py8cVjL4mBV8ma1n2qV8pF+ZGHLenNX7iXfEAVUOy/KF6DFJqz sB//0P47XkXHkbTvAySBgZ71PZ2zEOx4HUZPI4rzy4K7JGaQK8cijZnBPrj/APVVAXLifyY0by9u d/vWDVnYGryaOysXVrZMhdrDawHL/UVNLFPDAREjMcFgG4zUtXVgjB31Mq0xHuaRCrnqnoanW8zu GSgVskActQlZWCWjP//R/kWtwJnDsVALYHb8KvyhkVoztMY5PevElFvY25lYqPaHCSRISDhgFrQ2 ahZ3Maz237uaMMjc+YxPX9Mc1Lg76Gblc+rv2UPFXgvwL8a/hx4t8YB28PWviuC21mIRq8TxFgzB gf8AHBIGTX+kP+yhpX7Jvxw+Hfh7VfBGn+FvERutPW5ASwR3JCBT5oK53Aqww2D8p9K8fGU5LG06 jdla3zufZ5DKM8prU4q8lJN+nL/wGeyfE34efs//AA20abW/G+heGNH0e0RpjeSaYiQWkSj5ioA+ XAySfQHtXzh8N/jZ+wx8Q/EK+EvDPiHwPqV/LJ9lttPtbSGS6mIzlXiGTwAST6AntX0/1Jywrrt2 iicucsXWnQgryR//0v1k/wCCrv8AwSz0f49/DBvFHwk8I+H7TxLo0ZnSaxsPsd9PGwDOjOuMqcIQ MHBQdM5r+Dr4p/DjWvht4i1nw14jintfEGl3clrf2FxYPaPbvG+zbyPmBBBB781wzpxqYOFRbxTT /G36no42Mvr0k1oeWSWtvDGokcuzncFHGKpRROPlbKpK2FLjAHYCvLlF6HHPYuJbvHkzKzwo3X+7 9Ks2zCTdujCR7flb+L/PNS07q5a21FiAi3xLMWVASFkbOfYU+3iuLgxsVVSzbSgb5QPrWZpKKukf /9P+WlrVbVfLJiDSOVVVcHJHX/GpF3hAuW3MpVynCge9fLN2O5QSHWGoXOnOkbRLc2iliYpkDqM4 7elJqdzHqKG5js0tkA+dFXYQRwMjJ9q2vaN0RCPvsyLYagjO1useyRNjBo97Yz1B7VPAs5bZcybi OpA2j8qy5dblKGjNa5sbWVYpIQkTR4RWJCsxPb8cGsaa2vrfUobaFY3hMXmTXCuHCHjC4+nvRbQT h2P/1P5gYlW2VpUH3z8xP8NarQC7SJywVk644B+tfKcisdXI72MSYSC5+WTzQp2oo+VR6kmtS3sY pJVRi07SA58xQQpPYe1Z21shyg4mTf2SWupx232F4RHDxOB8qqccD8unsKjgUWrMTHK8UzFEKxl+ x6kdKnVS5So07xbLcFtvt3vYx5sQbaxHHIyMfpTYlunDqFKxr8zKBkEVryrnZmqeiP/V/l4SGUyf 8e/lxbtrP0U/4dK0AwtJVNugLJ9/d9xq+UgtDr5PesbU7x3ItyUj3yYEuxs7QB2984qsLG5h3kMz xEnYQvOD2NUlYr2aGmBhGS0exs4+fgmqcMdwrlmw2X2qijCqvqfemHIgn0vUmmM9t5TQIP8ASgXw w9CvY89q0LXFtGBNKoeTKrF/FTSM5U9NT//W/miKlV88KHdDnB44qrc7dSdHxJvQ7RuTaBj3r5Zq 6sbKCRY3rbp5UgdcDAH8J/zisJdOtZrp7u2xJcldksH8W3IO79MVi1bRkuKa06GpMskR8xIggSMK FC4DEDGKaHmihjmliVc8yru+4PyrmtbQ2px0uyaHVZLiePyoATHjkuFCgd66Tw5rk+j6pHq0Nn9v msrmO7FkJhCZikisy7iD1AIx70mdVNdT/9f9bP8Agj7+2H8B/jf8NdI8FXWlHRPiD4f0+KyvdI1O xWVZ8ABzDIAQVON2SARuIIBBr9yvFHhzwNo2jvrM+gWYsvK84W7W4khgAGdwB5BxzXw1BWbPcqwv GNz80fEn/BRf9j7wR8SIfAfiO4uI9cg1D7GbaLR0vInJ45kHpnpk46HGDX1f8S/gb8K/2qPhDq+i 6Xo9he2vizRX/s+6utGhPliWLfD5iSD3TjqvbGK0t++HCH7rQ/gQ/bz/AGD/ABx+yf8AE3xH4O1l rc2d3E2peG8zApND5jIcAAYwynIHHf6fnJPp8djFIzRtNdJEEljQ7S2M5C579cZrukloc0YLUxbV o5V8yOCYTnhVkQ70PTDfT1rSuIL21SOdIkkZyA6sxQD1xWfJqEoaaH//0P5oPtckUqb0YqTh8DAH 0qzLI0wYBmjjxhf7w7Zr5FxaPRs9ipHbzKuxneXPSR8biPfFXI4DcQx2RuIzJBJvMZ++isc5x+Hf 0pcrSuS0guNCkL/NPjKhA4OXVfTBqzCBZRNG4YunEbMPlIrOMbz0LcbK5hXy/a4jbB8eY24IDjzM c4NfoH/wTi/aL8Mfs3fGzQp/GXh59U8H6mBa3FzbFppdDcuRLJ5WQCrb1z9OnppKLUW2KK1SP//R /rw/Z48TfBj40fDzw54w8B2dpqFlf6bFLuuNKA2kqCeGGc4YAg8g59K/Hn/gu98IfBdr8Bx4istL 07T9W07WGvFvoLe3hmEdtazXUijIz83lIuPevh8HHmpL5nsYxclZ3P4PbyCO5v3DX4mSW5MguJEE ICO2VBA6YBx+FVb+ONb9WtgpgiIVRuyZMcH8/wCtaez1MoatBGrNZT+UWiV5CJEjPzk5zyP89a0r US26KOPlXarjlz9a0tpYl7lC/mF5Y3Akmx5CMjBjh34xwPfFVtHijliguIA0HkDYYWUrwABuH5Dm uaasmmawbkj/0v5nTGplPkZaR24wcgU2dzaSi3lC5bBcoQQeM5618PFXiepL40ZGoW5uNSsrpNzp bqY+oVYxjAY+4xit24vdQvtOitXhilubKeSeS6RsT30TbVUTEjqvPTjJrmq+5ZvudFOPM2RWdgyq 7xxp5Jb5mUD73J/z9afcwW1vHDJcSIy+bmRJT5a7R6GuqVLlouZzv3qiif1f/wDBAP4UeCvFGqXO vatbWGoQ3ce63kcGX7NhkiQHHdvnOT2xX9EP/BQb4CfBjVf2dviDPq/hPw/J9j8HahcR3FzpkTCF orZyjAtzyQvSuHApVKrt3O3Fw9nSin2/U//T/na8e6hZaZ4v8W6Xos8Uej2OrNY6PbWcRjt7eAIj BFJ54L4IJOCPSvN9IiIluDMd8nmF1kYcEHt+HNfIzp8rd0ejTWx+k/8AwTb+O/gH4KfHnTL/AOKu mXF74Z1S5e3hvYCZjpjukceDFwCrKHyc8dcYGa/0Lfg5o/wV+JXg3SdX8N6J4e1zQtU0yO4t3XT/ ADFdTGrEMCOo3d68Su+XH04Hv4en/wAJ9SXax+DP/Bdr9nD4N6Z8LtP8R6T4f0TS9YzKsN/DaR21 zAvlhmHm4DDnZtwfav4sdYtIFkt9Le58y2hmErXKSeU6he4x16Y54719PWglhabXmfP0dcRNGdFL YJceRC86o83lRPcOG3nPBOOAD6V/TD/wRF+PfwLXUn+EHxS0aO08Qm+mutHvNRhFxaauXIXIIGVI CORngqTzw1eFjp+ypSqPZHu4Kl7WtCmlq9D/1P6+F+AnwM8W+HfLn+Hfhi50vUNNZjdpZqxYMmS3 zAj8K/hZ/wCCyXwf8A/CX9ombSPAmg6bph1C0ke+e3Ta8IVVlSNR0wyunB6bOK+Wy338JOb/AJf0 PYzGPLiVDtK34n4iImoMl/A4SSRAxURHAKnoDnp2rOu7W+mNpcfaY7c2to1utqsYIlLEHJb1HT8a 527DSb2KC291PJAmpW6JMqrjsnqGBPrwavmBTHP5DNFLAu4Z+6x7f5+tRUdkSoq+m5NYzyNZJGth HY3YJZ2hcyxSk8l+e56n60tpDbRXcb+UDJ8zNMAAVbGOvfNc/OzXkdj/1f5ureCSe0up7SPfcwRm Rg4O1AOMn2rBvZ2uJrWKVRsDbGccKh7HHevgHLnR9BGDi+Uqf2d5M8zO0TXG4xmeFcHaD8oz9KrN 4c1tpbm60EwRCKH7Rdy3Iys+CFHQ53ZP5VtCGiaHbWxpTWNlf39s2oLJhI1W5jj3IkvZl47Hn86/ qh/4I0fDn9k/4i+GZfDvjjTvCuqeILW/MVxpuvafZT7YnCCOODzFO4ARseM8seODXmZ1W+q4N1uz X4tI9HKsN9bxSw/dP8E3+h/R34n/AOCc37J3inwzf6G/ws8LQaTcWrnzLTSbaFZht+UsyKGK9M4P Sv4g/wDgpR+zL4T/AGZfjXq/hrwnYwWulXniC9aOwe5BTTEVUaCO3Tr5YHmfKxJXK44Fevlq5sO5 +R5eNp8le3Zn/9b+ZTUbBoBLIm826uXkSJdx3ZPYfX9a9S+Cdr4Rl8f6BB8QLm/uvCkF5FNfQ2hL SWyySKu447Dc3B7jOe4+CxCtc+jpQfMj+4j9iz9gP9hL4u/CvR/E0Pg3wN4jM0aiadILW7v4wwIK srZOQVx83PT8cL9vH/gjf+yTcfCHxN4p8HeD38J33h/QLnVI9U0Vkt3R4YnkTdGPlyCvGAM568Yr zslm6zkuzt9zNs8oKjUXmr/fb9T+Hjxj4Wt9E1DUtLWZdRGk30tnb3jvuurhUYgGYdA/GCB6VwrX Qmt3huY9q2Skq4GJEXOSPeu7EpRm0+55tCm5JEENl5yxy2sRjtAC5fPBHX5vXOasGV5VWMhYwnyr tGM/Wmo3jcUqfvH/1/5ioNJuvtdvfrHGCsbwtl/uKccY9DTotFvLebzdPXbM7BRAuArnOPzNfnTp tLmPZUW3Yvw+H9UQ3KypZ2nkruMEs6pO0mTnAJ5/DJp8ttZrFb2yII54SWnCXHmPIzZOWB6Drirh T5o8xtbl90kOnQzEFYT5saFWkP3qwH0ZoCXRsoHLupGepzUyik0kaxg2jS0YX4ubhfLs2QxMyBzj y1UZJOe/0o1W01NYbWVf3Nn53nBoGxvCDBXP1xx6UShyq4oveJ//0P5forvWvNW5MEscMm7Y8yhW wOAcdway7i7lhhmaUstxjfAGhwsrZxjPavzZq+h9Aa2nyafJZsdZtG8ueLN1BDL5bksP4Gx1H9Kx mi1C5v8AOn3TQaLdXSxTver581uqDKgAevGfxrKlLlq2FJ3aTNO8tWs7P7RK5uppp/KVUTcqcfK5 zwP/AK1aFo00JQlpboMqtJIWJWLoOc9ucV039zU3paVGi1MI2uv9IUeTuxmH5v8APSnSX1kSZD5q RqCqLMApGMgH6cZqDWatI//R/mO0zUre4nuYZWt5TFLhXt23tGMZG70PWr12rXdtHeaS6ynG1o2O wEg4zz06V+aydj6gpXkkj3osomMMkaZkRR5kbEcH5vqPXvUjTMpUCdoDD+8YpwrYHQ1QFax8Qg6i F+UyEnYFO4oOgbH+etLLc3q6nLZrbSwI8XmyXDAiKQcdff0+lBnPsa1hawCMvOiM5JVWBwVJ6kDt mrU1tZW1oscXmRuz5EqtkjJz3z3/AJ10x3RpH4Ln/9L+e74bpfX2rW8drFFCsN3HC7TybZZSTnev qOD+PHFfpB4Z0q907WtNBuovJs7yK4uJgc7EUgsR6gjg4r9m8EF/wh46Xa//AKSfAeIWueYSPp+Z /Z//AME69Nk074I6HJHaWsdrcaTFqB8o/vzLL97cPQ4zj/Gvi7/gsLrMreArzSZoxcBdOa4e1VVQ GUhti56/KBkE96+F8PF7XxBh/wBfGfoPGfucKOP9xH8mPi6SOPSZ9XtftGnSrablbzg01qhXHB78 EDg96/FP4xh18U63czW5wdQk+y3Nu2beXAVD5gHALbSelf0t40e5wko95R/U/GvDiH/CrJvomfLu qpFJctIuI5HHzRq3HHGcVf0WMwqhLSDB3bE61/HUkrNn7XJvnP/T/ihsp5bm7RLjz4oX+TGzbHJx 8qk49cCvR01O/ubaws9RuPPhs1KQRk5WIdMD8AOK8etomzoMrUNFh8k3VpE22I5e3hG9n55Kr1/C tfSLHzDZ2ttpvn6gL4TEE7FlHG3PuCMjHrXk1TSn1PrLSJFhsnudZe70e5t447SPSJbVg90z42vz yB079D04rpn1KB9Jg0++2295GSbOS3XDHLZbeT7dPTpXm1maFvSvFf2Nl0TUNNSexum2SapHD5l5 b5/vc/d9+305EMGo21h4kih0y4e6jln/ANGM0QMUrDnaB2PGM+1c0nZXNqUrJM//1P5Cb3Wbe1MU clrHfGeMnYjBgMAnc2Og46VyFzbXmtCPU9KtbHSY3g8t2mvTCysfuyCJjlvoMdK+f6mkHZMYinTL u2S4S3vJLOTd9pgQSSybhhmbsAefpk16P4H1u7u4dYludDtbEvdGysJFumdmiGCZghAxk5HJI4q5 JWRl9o6Waa0sZIoYn8y8li8yRGTaqDJHFRW9qJruaS4tjJFGhZwpGC2MAE/Wrhe2pbaaSOI18s0j GNfJd596gRgbApGQQemRxV++lQWGWm86OGLzXTdgHA5I9xnpXXB6ok//1f4vbF9MjlvtZuLe7uLa 3ikvpRbN5dw7Mu1WPpjK9uPQ1heHtQ8zUbSO5uLq1W8uRFLFds0qxb/9W6gHPoaVNXnGT7lQ+0j9 QvgXqDDwlqJnmZVsL62EEc6BZr0PAVaUNnJAKjA9DX7C/wDBNrVrH/heeg39vJPcjTNVtUvbUS4k UyJLKdqE4P8Aq1BPbeK/uPLJc3hImnr7H9D+dskk4eL6T/5+P8j+76wlhufBdoIpJ2DaPGqzbN8i AKCpI9MACv40P+Cwtjq0HxyfWdKkhECSzaQkF3GiwWzb1kZ0frv2gAJnkniv538DKnsOPrPvJfN3 X5s/VfHhP+y4vzR+QV/qT6pHA1/Kiz2jhpUjt40e4ZVC5dtu5vuj7xNcTPNdjU2vUvbn7O8IiNoh yoQHuo6V/fsF7p/JlCW7P//W/EdtVk1C/aytbecRlAFiPzEjADNn0zTb5NRsTM1nbmaGJwyCSUI7 nuM+/wBO1f6rKNnc/iZtLRnW+HtZ1G9kijOnppkQj8x83HnshxyOep47V/Tj/wAG83iWzb4qeLNP t76Z2eGSKe3eFUIZg8Yfd3yUb6Zr8Z8cqfNwXWl2P6D8BKns82xUO9KSP7FKK/gaOyP2KorVJJH8 4P8AwcCWRXwR8NtQ3bUXUIwVIB80l50AHfj+TGvsz/gjBq41H9j3QYRAsRttTmXemQso8xjkj+98 3PrXzOK0zuk/N/8ApJ9lw83LhbNof4Pziz//1/7+K+If2xv2zNE/ZU0nRmXRrbxX4k1qUeRoQ1Dy J4YiSBI6LlwDtOCepx2JI8rH4r6nh5V30/zsejg8NLF4iOHj1PjDS/8AgqR8afEscTeGf2QPHOs2 8rZi1LTzK8E4HUIjoB/48apeNf8Agqr8aPAOkz634p/Y/wDGPh/TYJfnuNUmnCqgIBZiseFAzySc D1rzqGZ4idLn9np6f8E0r4VU8W6FSovxuj9Ef2Uf2sPh/wDtV+AYfFnhS6t7PV7d/s+t+G5LgG/0 58A52H5ipB6+xr6pr0cJio4mEai31v66F4zBzwd4S1WjT77/ANeojZAJAyQMgZxn2r8O/wBr3/gq Z8Uv2WvGmqaFrXwY2aRFqkmnaRfXMkkKXqqoZZfNZNhBBBwp4z65A0xdWdGg6lNXaOOlGEpqM3ZM /9D+sD/gnv8A8FAv+G1bbxGsvhq20K88PQCe4S3uDI0fzBAGyAGDEnBAGMd88fpxXi5ZjZY2lKpN Wadvu/4c+izvLI5VWp0YyupRUvv/AOGPPPipr/izwv4F8Q674K0EeJPEOnWD3FhpWSWuGUE8KOWx 1xn+pH5ifs0/8FNU8a/FnVvg78eNEtPhz4ljlWDS5ZkNvC0rEqIpM4IU4GGI7nPAODH4qeElCb0p 31OPL8PTxdaVCV+a14+b7a6drn3f+0H8S/iD4O8JQT/CLwzF4z8TXuy4hhWUtbxwE8OpUEEt2Hce g5r8rviP/wAFGf2wPgybXU/id+zx/YvhVrqOK41iW1uYIAm9VZvNVCAcHo2M+vevOx2PzCliIzwk b0bau11r52v+I44Sk5xpV5Wd7W2a1sfrP+zv+0J4C/aP+HmleO/A+pRTLc26/wBqaU8ifb9Jm6Ms iAkhSQSrdx1wQQPea9rCYmGLw8a8Ov8AT+5mONwk8JXlQqdLW801dP5ppn//0f7+KKzjJJWZUlZ2 QUUOfYmwV8J/tF+KP2v9G8XQW3wV8OaPqvh57VXjkmiEu99zBlkJYMGGF9vm6novFj5Yr6tJ4T+J 0OnCRoyq2rv3T4/8ffHL/gp18OfDOo+JdV+EXh7UrOzhkunOmut3cwRxqXbMSMf4QeG5yOpr2z9g 7/goT4d/aS0658G+P5LPwr8WNJvGt5dInfyF1NSWxsDtuDggrsb0PpivAwuPzPD4inSzTRS06ddn pa3nfz6nv4fLMLjqNVYRt1YptLXW2rVtb6J287an/9L+/iisYy5dC5qzCitiAoqJ7AFfxO/8Fa/E Vt8Lv29dI8SXCTzWlrbx6hdQRyi3eeCO5begP+0BJ/31Xi53f+zKrXY68tkqeaYab6TX5M//0/7J f2Ov2vvgn+0b8IPB2t+CfFemW99aeH7ay1Tw9qV9Fa6rpT28awlHRmzj5RgnB56da+TP+CuHxN8D ar+z8PhRputWWseM/G+rLb6NpemTC8aTyCrSZZCRuyUAXkknpXw+Fx9GfDUK1/scvne3L+f4an0G bYSqs7nGz96d/k3zdey3M7/gkd+y98SfgP4K8Q+IvHFg+ixeNbGKa20y6t3t7zDFJY22sAcYJyem cY7gfsDruu6T4a0q91vXL6307TNPga4uru5kEUaKoJxk9SccAcmuzJIewy3mlom3L5M6eKq0Z42l GP2IQg/Vf8P95+Gt3+2N+1x8d/jV4h8N/syW8d34QhunTTLm+0PGmwQIQgluLgj5Mn3J6np098h0 H/gqr5qTz+I/hh5QiU/ZIXttrEdQzFd31xXnYPMczzGVSeD+BSaV7fdr5Wv2Ing8HhsNSliV70lf r/mfKXxb/bW/b1/ZK8aaLd/HfwbpmqeBL2+VrzUtJtBNpMkW7DrHcA7QwByFYpnpkckftv8ABb41 /D/49eBdK8ffDvXLTWNJ1GBWuIYZle70uYjDwToDlWVgwz0O09wQPVweMxH1t4TFfFa6+XoXUy2l Uy2WYYNaQaUvR2Svd6Wdlp36WP/U/vi1zXNJ8N6Xea1rl/b6bplhEZrm6uZBHGgAzgZ6k9ABya/F bU/2rf2tvjt8X/Enh39mSK1n8KaXdNbwanLpwm063iRtoeaU/IpJ4Ocnjrjp85muNnhvZ06Pxydv w/zPWy6hDEYpU6vwpXf/AAT2f/hGv+CpAjilbxT8NHZPmeJJbZJpSeMEcp+Rr5n+Kn7Wf7fH7MHj Lw9e/Gzwzpup+B5LgG4vtC08XGjX0SkeYjXKDasgDdCQD2I6jnxVXN6FFzi1p2sdCp4GeOjTgvcb tu0v8z9lvgx8afAfx18E6X428B6xbahZXtujXlksg+3aTMVBeGePqCDkA4wceoIHoeva/o3hjSbz XNf1G10rStPhM93e3kohhiUAnqep44A5NezRrKphlWemmvl3+44Mfhp4LESw894v8N0/mtT8ZtS/ al/av+PPxl1/Q/2Y2sn8FaVMVtr67sF+wrDG4j8yWUgjLHJ59OoGAPZIPCH/AAU8ie5mfxt8OLpZ IswW0s9vEImPOPlh7e7Y618zQxeaY6dSWBdoqTXT5Wuu26/p+1LCYLCQorHfain16q+tvN2/rT// 1f6APjJ+1R/wUD/ZY8U+G/EHxk0XTNU+Ha6hGNavtF0+O50a5iJIeMzr91gBngjqOnUfsp8C/jn4 C/aC+H+keP8AwFq1vfWOoW6m9slmVr3SZ8YeGZAcjBB2seoHYhlHi15pcvqerg1zVZx8mfOP/BQ7 4/8Ajv8AZy+BLePPAaomoHXYdNurxkV2tI5A3IzkAlgo6HjPI4Ncd/wTj/as8dftP/D7WdV8dQWQ v9GnEMN5agLJdrkKWcAADJJ/LPQ4Gk5WcTGiveqp/wBbH6RHIBwMnHA6Zr+fPxz/AMFJ/jb4X/bN 1L4NOdJtvDNn4jGlQacYBJvQ72Bdj83Crzj0JzzwVJ/u20GHjfExj5/qj9/NHvTqWk6XqDBQ1/p0 F6yp91TLEr4HtzXj/wC0JJ8XLf4b6tdfBdIZvGVqpntbd4xLcXACnCxIeGJP8J6+3UVTldIqUbSc T//W/p3/AGRP+CicniDx14h+CX7Suo2HhD4haXLjS7rU4RpAvXVtkkEitgA8EjH9w9edvqX7Wf7Y HiXw7qXh/wCHX7OP2Xxf8RNS1CJLuCC1luoUSf5Y0Rk5JyynOCvBBPBI8ackqyTPYw0b0JSPjH4g /tb/APBQ39nVtB8X/GDwHYyeCZdSWG+kh00tashJJjlm/gYqGxnHI4I61+yPwD+PfgH9oj4e6N4+ 8CarbXdvfWqNqWmCdWvtGuMYlhmQHIwwYBj1x2IKjW9qhnh9YT9D2W5ubeyt5rq7mjtra3jMs88z iOKJR1JJr8f/AIr/ALZHx7+Inxqk+G/7J+k6b4h0jRyLPUNUurV9jzq7JLIz5wIxx1AI2nIJztvE SUVF+aM8FHnqVE+i/Q9aib/gpPJaJvj+FyzMuWifYrcDpvDAg/U18x/F/wDaq/b9/Zzv9I1/4meA 9D1Twe155V5c6PYbtOCgEsHnUtyVBxkjp261Tbehiup//9f+4D9nr9oPwJ+0Z4A03xt4Nv4jM8Cx 65okkq/2jolyBiSORASdu4Ha3cY6HIHukssUEck00iQwxIZJZZXEccaqMlmY8AAdzXn31sdqVoo/ IH9oD9uf4w33xxtPhF+yvommeMo7HTt2sakdPa/825Dt5ioc7Qiqq8tj1Gc8d1Y+Mv8AgpQ+mrey /D7waDON4hlubYX0eB08ncCufQgmsKc+arNLpb8jqnG1Gm+9/wAz57+MP7aX7d37ONpa+JPip8J9 CXwnJdxwT30FmssSZDHb5qPgEhT174r9TP2b/wBovwB+0t8ONH8e+CNSgmee1Rdb0cyL9u0W6CgS xSICTtDbgrfgcEEDc438b/rofQFFbQehB//Q/v4orB9BvdhRUyXuscdHqfymf8HFUdraeMPgTrM6 3HlQaXNb3PkJljsuRJGcnj+Jx+Ffqn/wSJ+P3w8+KH7K3hDwxoetWw8SeEWlsNV0ueZUuyRsw4BP PBX3xjjg4+ezVuOY4OK6uX5H0GTRUssxr7KP/pR92ftKeLPDvhD4JfEW88R6paaZbah4WvdHtPtM gV7ye5t5I0ijXqzHJOB0CkngV/Nd/wAEg/2YPidb/tBXXxiXQ57Twbp+sT3Ul7dQtaxTLI5wsW4D OAAvHGQcZwcehW+BHn4a3tX6P8j/0f7+B/Wvzg/ax/bub4H+N9A+GXw58OWvxB8b3/zalpUMsry2 RLbUixGjfMcPnqQVIxwSPJm+Wmmzvw656tvJnP2P7VX7ZOpWtvNZ/srTt9othIrySXKckZJyQF/A 15f8SP8Agot+0D8H7JNR+IP7MOraPpcLD7Zqk0d2LIDIB2yAbe/et46NGE7JM/QP9mT9pj4eftRf Dix8eeBdRheZcW3iDQncLqGhXI6xyxk7tp6q3Q8jqCK+jKmE713DsaVIcmFjU7r9Wj8//wBrT9uX S/2d/EGgeCPDPhr/AIT7xtqrLJd6PZ3BLaejHCI6oC29z0Xr6DgkeaaT+3F+0brNrFfWH7InjC7t WjEjNBBegEHuGMYAx6EZqaU/9pqQ7WNZxSwdKa63P//S/p6+Jf8AwUx+Ivwjs4tS8efsz+JvD+mM BJNfXkt1HBbR8ZZy0KgY+vODX39+zf8AtHfDv9pz4daf8Qfh/qMc0Mv+j6vpEkqnUNFuB96OVOoB 5KtjBwR1BA5a0uSg5PobUYOpjFTXVf5n0BRSpP3E0TVVqkkfnv8A8FSrK5vv2IvjLHas4kh02C5k EeAZIkmUzIfZo94/Gvxq/wCDem6K+KPizZBzsfwxFO0RP3HW9dOB9B+teNxY+XA4d/8AT2P6nu8F +9muMiv+fM//AG0/qdryT492gvfgj8W7csV3/DnWGVh1BjsJ3X9VFfa5G7ZphX/fh+aPz3if/kRY 7/r3P8mf/9P4C8fz3Fr4v8Zw3FtY28B1eQqYEXEgOVBCnOOFHNeF6jFdPJAbOSN5orkPG1ywUKM5 PtwOmeK/1iyT/dafovyR/C9SXu29fzZwFvJe3OrX4lUtGZn37W/dtzyQBxyeOK2LnzbW3iuZbMWd uyiKERsW3sOuM+2PaveOO6UDl764+yql2oS6PU+a25sD1FVtOa5v7eS+sVWRXODA4KkY4P8AKuyl 8JmTCM+ZDHJCElmB83ByB7fjQli9kdpdRAzfIrElgfTNaET2P//U/D7zXSFpbnaqhysYU5kYD0HW qlw/nNFOu93hGEx93n1/z2r/AGSgtT/P8tWtvdES3ltDtuZPlPbfj/8AXWXdahd20Z80BHeQCZWy Qxz0rYDUtrwyQmWNFRI2CMFHA71k3TC4vBsyoJGdv3aDGXxGjPMbLyltLa3lkBDEyruJA5Py9D9K 5i6R57m4vGiRJbl/3gC7UBHHA7AelbxVlYhtp2P/1fwNlkFtJGsYG4HIAPGe9dLHqVlIkdtcwr9o k/1VwOQDj7uPz/Kv9o4LU/zwbbMu8024kkjmibYI34Odu33FWXZrc5Zi7Fdqs3etReo2KQB23/MG OSc5waxrm6dbmSe4lJ+bYjFidw6DP8qrkkBLcKxgDrEksrcKeBtHqTVSG3m2tIyFljPzsPurVKGu o7s//9b+fe4bzpQcAbOuTjgVpxrFiLy3y2A7AdQOK/2vaT3P88k/csXkuGiwY8ENxn0rIkvJftcn mqzQqMLkfLz2Bp2IIreGAvOzI7I/MY6BP8adHboZBKlwI3Q/NEBjfjtQBqxXcTySXcFokbonlhMl pBgY3An1xVGe3ubwS3hSYoDsZ+saHHT0Bq+R2uB//9f+e7ypUPyx7DnLHrmriWUKG3muCTDO2CIs FwAcN+Nf7YWsf51z7Gg6aejD7Ojvbb8JIww5Ge4/n9KrajbhYy9ncLHxmQHpjNBF2lYoxLPBNBM4 3wheUH/LT8abceXIhJ4IfiM9TQLYIHVAVcb1I5HQAVnTXcEmoPGmRGq4KqOSP5UGkHqz/9D+emF5 pSbUxIkfDG4c/viOwArftVSwPly24eSRQ0dwyhgoPpX+2UVd2P8AO8q3VtG0U5jZBJg5kxlU98Vm gm3t441kEsu397IAAG98Vfs10NIS6MqpL57AZzsbDAfw1OtsonxIVaIHp1NJw10NCeSaKPcI1XeD heeWArMELSvLcHcgyFYycIvbrRya+RlKV9Ef/9H+eBhKl1Db+cvkHO55TtRfYVpJafKZNwaFWySD kcV/trKOmh/nXKTTsitI8UkctxFs8nbhQnLccH+RqkRkIqqG8z7tEY9WQ3fcatvcRXLLskG3Gfl4 /CpPs8DyrNNu3xHCZYhQfp61YtthvnXNvMWiZo9/y717A8U60iTTBcXKANcTOGUs21DnjrziixUX Z2P/0v579ReW/TdKqxBtu9I12oxA6msoxRxuFKmUEYKk9MV/ttyRP87xum2cEd1KxCAvJvLtyygA AZ+mK0dWlmgniyBMikFfLYcjjP5UckQ2J7u6t7m1V4C8W8beR8wx1/PFYkcRSXnO3PLDpScFbQ5y SSYxuxiBwRwccmmmea82LKWXyz64U+9ZWNI/Az//0/52BGkJJyTk4x174rTS3W5geJGwSvAHav8A bFJvY/znM9rPyCsc0ZmQ/Lk/damzW8Klgu3y1OAc8J6DNI2jHl3KsNk4/eK8hieTGCSwJqW9tp5G dEQMkEeSyDkgd6CinaNJFtBAw/zBDwfxrQuI2ZiTOJjIPMCjnyu239M/jQB//9T+daO1neIsJuei xkfdx79apSWN0Y5Btw0hCF2PyA5wK/2vaT3P87wMc9tusJY42j5WW4Vg7IR02kU6zkQFoGzhiAHP GKYFm5tnlCybQLZCEKockY74qJ4Ake5I2IZ9ibuN49RQA6a3a3jRlPzHHmAcbKZdRvviChXRos+a eOfSgXMr2P/V/nSXzDAg8pwASgkGAox/n9anV0hs53V8yxEbowOSDnn9K/2wP87ylZSR+YlzcMI4 rtgkL9FbPZfXpVyQxXAlRU5iz8zHnis5rqNaMz4LW4jmCkFlkTzI+eo55/Q1cuYozbYYmGSFvMRo VBeQjHyn2OP1rJxTNzX0S0+3QC9WXeoyGh24aIrxyab4hjtb7SbyC4lVTbQvMuCVeYgYC5H+etcd dfu3fsbUnepFH//W/jT8TGWz1a/LIdn2piYwu0gHop9eO9cjdvbXIGFYYOfmblfpX6Rxz/yVWYW/ 5+z/APSmfMcPq2T4ZP8Akj+SKk86swWVRhBiPIzjtmtK3jgTkyBgQAcHK/nXx5742dZopWa3KbHA OFbdgfWnrJPMV8lmLjhweMY61jJu7HHdHpngi/msvEXhJUUpOPENtIjxoSeGy3zdu35V/rGf8EuD PefskfDuW5t0GzRFFrKd3mP8iY4PYA4/4DXy+byvi8PHu3+h9vkStleN9I/qf//X9r/4ObhqmlaZ 4EgsdSubOPWNaminjglZYb0KIlBJzgFcj86/iBvoz9vngjFy+672ubiTfKzOwz8x6nmvpM15ll+E /wAP+R85kjX17Gp/zs9q8M/s6fE7xHoa+JdC8DeKNa027uGsre7s9Nee0DIfmZmVSR16HtjpmvQN P/ZS+LbJaTR/DnXGuo7owr9r0W78wsR94kRFV/M18csxw0ZyhfVabM+1p5VjK0lyx3117FDxB+yt 8XVt4pZ/AHiZZbe6cyRWmi3z7dn3Wb9zjaemScfWvnPX7GTTIrW1nsLzTtYt3lt9Qs7uNo2idWwR lgOV6ED2rWliI17+z6GGNwdXBtxqr/I5RIuJLe8CSKw3gLw6+lejfD/wh4i8dXdtp/hjT9Qv55HU QSaVYy31wGDqoBRBkDOAScYBrpquMKXPJ2SX6HLhIOrV5IrV6H//0OS/4J+f8FTv2uP2PfhzafD/ AMXfCjXvHOjafbkW0jaJeaZqlvCMKvSExuAP4mAOR97mvz8/4Kuf8FH/ABn+3HqlhpV74GvPAdp4 R1T+2ZbXVLoteXErBYxI6FBjA3AAFhjqck1HDTo5cqtLD/DO6XpJ2/A9LirC1sY6FfFX56au/VI/ Bq8gufNupvsm0F2kWOPBe4JPUAdyf1r2/wAI/Ar4heL9PtL/AEvwb4uvYJ7XzmudI0CfVEtuAf3o VDjg8fWtsTKFKV5u3T5nl0KU67caauYl/wDD/UdH1CO01TS9T067LNb28eqWP2a7dlOCFU4OST6d 66Wx/Zi+NOumy1HT/CutXmn31yUIstFuJgEYfuysgXae2T05rGpUhSipVHZPYKeDr1ZuNOL038ip 41+CPxS+H+ji/wDEfg/WtOsrWMtLdXdq1vbswJARsj5e3LYFeBXtoTdvMbeGKMgA4fguc8D17U6U o1bOGxliaNTD+7VVmf/R/jZiSVY5TdxKixNlXD7Vx/Dj68DHrX35+yba/G74O/Ebwd8X/hr4e8RJ rnh149WkvLTTJbvTXh3ZaG4+Qgq6BlI9HPIODXPXcEuWps9DoyuFWWLhUoq7i0/uaP6uT/wX6+LW lfBdNG8S/A6+m1j+yzYajdQTz22nWwC7TKWaEsAMDCs3zHHQE4/jl/ao+LviD48fF7x78T9ZtpdG TxL4iutVGltIZIo/MkGDuPJHHGSa9LCRo0sA8PRvrv6Lp+RyZtRqSzJYuo+6XfU8d8J6BrPiJo7f SNPmvL2SX7PbwriIzORxjPXPt616trH7Onxk0PTYvEmrfDjxJb+HpYGH9rTabPDZ+anLBGZAGGCO e2Qa8l4ilTr+ylL3n0Oyjhateg6lOLaW5y0Xwp8SXgP2ZL1ri4IS1hsLY6hucnG3CqcckDnGK9Hm /ZQ+NaQrfR/DXxHLbR2nmXsk/h+7QbsZHlyGPBHPYHHrVVMXRpSUKkrSeyFRy/EVv4cWz//S/kj8 V+Cdd8CNa2nibS7nRtSvBiOyuY2TYxyQpyM5wK5e30bVZp7WZfLa3mfM29tghAz7ew/OsuWSp3as aRpOFf2T+JdD3Xwr8DPiD4nhW90fwfr2uxzSbF/sOwfUYgAcK7lVwAecGtXxD8APiz4ZsNW1TV/h 74wsbazj3tfSaJMqLjjk4IwM5JzwM1ze3oNtcy/4JvLA4iMVOUdGct4S8IeLdduLTw7ptvP4jm1X Mq2FlatJL5qgkqVPQgZGOvFani/4E/EDwNAL/wAS+B/EugaZCBIZb7TZlnBfBU42kbOeoPGRU+0p fWFQb9962M3h6nsnWt7qPHbowymcMfJhjTALDbNu6kEdj0rFVTKwKZWNWwufvGrmrSMFsf/T/jyn JEm1E3N3I/hxVuzkJZlYgbUyATjf9K88unvYZ5MlxKEkDJFnOQcHrXf2PgSW9a1tLMXGpXN/sjs7 e2VWuJ3cZEaqOW/DpWE/dZVNOUz3bS/2ZPijCls0Xw/8XXQlX5ETw7dJsbHATcoDZ55BNXdS/Zb+ Ngsf7Qi+HfitYDJtC3mlzWpt8cFvucge1ZxqQn8LO9ZfjGm+Tb0PnzxR4dvvDE9xZ31pPDd2sn2W +W4haGS1kGMgqea5uSyjhiHDMzjeWH8P1rWnaR59RWny9Uf/1P5D47Yxne27Yo3fXFW0HmwTtuK+ Wm8rjcz+1eTJWYGrpN8Y5LWSVogInVlWVA0eFOfmB69Ohrp9e1/T9dFtKrNBcwSFJZIogIn7AKB0 FS1Z6gQi3iks737DdyRSzWwwsh3J5q8rkdskdRzX96P/AAbmWupTfA+S/u2mRPtYs1VxmNWjJ3DJ 9AVGBXi5o7VaK7yX5M+v4X92GJn/ANO3+aP0a/4LBztpX7LXjjWreKdWg8OTwC4R9sUTMrgtjOc9 Bkep/H+MH/glDeeIdU/bF0KWW6u2axu0nWCBijOZLmKLAHcFHJOf7ua+izGtKllKfTX8tDDJXKOd Xh1auf/V/trvLZ/+FcztOv2hpdHLSFhuU7VwNw9sV/mlf8FSYNKuf2xvjBaWscMGnt4ill+zrhZI 5EdgcMP4TkN+I9K46EJPLpPpovzPZxtnjGlvb9UfD2g/APx74w0631fwl4D8U+I7SS5aO31DStJk vLRzyrYZckgc84xx1rb1H9lD46aZPa20/wALPFepR7FlkltNJuJVVj2IEfBHocV5bqRl7qexxyoT ulbc0Lz9kv8AaG/swX0nwb8TW+nMcNNPGYU2D+IgqGx6ivmzXfD+peFdUm0fWraeGa1jc3alNrW0 qsy+SR14x1PpVckuwTpTp/GZtnZrcyWyOJllupRFbIYmJmY8hB6k19H6b+yz8a/FmlxXOhfDXxsL QoLn7dZaLJc28iEEgMyjCZ4I3EH865G0pcj3N4YatW1pK5//1vwBH7E37RNrZ2d7bfDTxFcWyTkP Hd2DxXqEg5YKM9RwKq6r+zB8cNB06bVNZ+F/iyw02KRo5b+XTpVt4cDdlsoDjHfpXzEmtPuPdeAx EYc0lt6Hznq+lapZ3SQ3KpAySYljR9xjAJHzDscqeDXR6R4cuPEM0Oi2VrPd6tfFVsrO3iaSa7JY KqoADk5P5Vq7U0+fY5KEHOTUdz6Kj/Y9/aKjuE+yfDTxD9je0juLdZtIn23Cv0YygFU+jc1oJ+xT +0RMHeT4V+IE+0fumnispJSrf7KY5wD1FaKDUUykk7rzOE8U/swfF/wVpt5e+Kfh/wCIIbC1ZpU1 DUtLltLaz8r5t/K4wAD831rynTNBubi9sPJtpvtmqsltbWCRmRrmQ9AoxnJ/yKzSTVhyp2dkf//X /Biw/Y+/aW17SLzxHo3wm16XSI/nR3iZI5F/vLxx9D19c8V4lc+F/EWgXc2i+ItK1HRtYhYrc2Go 2r2k0Bz02sAcYxzjvXzbgkj0uWzszu/APwO+I/xXunsPhp4J1zxVcQSmO7m0yzeS3jZSN6h/usRn oD+daHxG+Avxf+Dt5ZP8QPh74m8KW10pWO81XTZBbSyKM7VcLgEgg4PWsYq7LrU7Jeh5tZaJ4i8Y ajYaXpGmX+qahcXaWtnY2NsZLiaSRtqpJxlQSerYAr7E/wCGRPjV4d8OQX3if4K+I7Sz8lnmv9Mt Td3Enyk5ZT90DjtkgcA1nKPvl0Yc0JHzr4d+FPirxbr134T8PaDfz3bzm2OnyWj2kkQ5D7kxkEc5 A6HriveF/YO/aaYy2Vl8KfEBkVBPaXFuAbeeEY5YsMD866HBJtmUIaqJ/9D+er4g/B/x98OL86H4 98K6r4V1ML5q22pQGFLtRg5ifo2AVJwT1ryuXTHLpDJIIkuAUiO0tJJjg7F7mvmVC0Lnp8vvtH0T 4A/ZZ+MPjjSIda8MeC9e1PTJ08iznsrFr6eaXPV1XgLjrzxnkdq9TH7EP7VNlFBHP8G/EVzA5HmX FtEQvzfd4I4P1pWdrmnLHsPvP2Ef2jo9Nhv7/wCFviUSC5ZZLJrN2iEajIYShcbs9jXy34k+Hvif wlruo6Fr9nfaNqNm0iyaXqGmS2kxVdoJWRvlbBYcqTmizGo9EjltF0DVmmewKzarHcXChAFAkVw3 7tBt68n+VfXWm/sKftKeJbKx8QaR8KtZ1bT72JJbGWwieQ2uRnMoC5IIPbAHc1UVcyqU0lY//9H8 h7H/AIJ+/tcGOSSf4PaoYnlEQja1mjlhXA+c/Kcg+w7VSvv2C/2nNI06S61r4V67HYaX5l7dX9gr rFbRKSRvRl6Y4688V8w1bQ6+SR8s+LPClxZs0O2S2uIm8qW2uI/LeBlO1gy8kEc8GuIgto9MuXjV 0eVYhtkk4dxxnn61nKLeqM0tyK51T7RITGYvs6JtdIvnYuOCSc/pWVM95KYWuo4lt2OHt/M3Oy4/ iHp/jXJJWkzansbumWkU91JNuS0gEB8qBeUyBxz17U2CaMXMogEjGFwCyLnzDn7oPf8A+vScWtGd dGx//9LK/wCCCvhqLU/jjeaui/ZvsumpPd28TlmHnbuHJPB4TOPev7X/AIyeZp/wr1effFsTQ3UP IQOUhYjGe5218RQV3L1PpKi92N+x/ni/Eh7nXf23rrTb+5cQHxbFHbtO5G6ZnWXBP+03GfQCv9AX 9kfRl0b4P+D4y8NzMNHtS8kT+am7yEBH4BRit4x/e2LjFey0P5YP+DjxI5viP8PZJmlW8GjOVmiQ QPBGbpVYkj7wOw89sGv5uvCH7OHxg+Kmpmz+HXhHUfFQuyZIZ7CJ3jtiB0lcrtAPOADk46V22vL0 MOVJHu8X/BOX9sHT2tnk+C+tK8ke9ryWMwWkwHXDHgY9M59qvt/wTh/bC1aaZT8IdZkjit91lFZR faFL44LMDg9+Bg/WsanuJi5VKyP/0/wU+LH7PfxX+D9zBaePvB+q+HpzcfZbqK7sXAt3AyCXGVwf rkYPoa8hFgzFC5UIZBEsjNiL8/1r5GTbp3Z7fs/fsfX3w6/Ym+PnxU0y31bwH4B1bW9OFn9tWSJS txdqP4lTacL3+bBxXZf8O2v2sNRurKfS/hhqVtP5jRXz3GnzRxfL91C5AZenoeTW3Lencx5ffH3P /BN79rmIf2hdfCfxGlrDdCGfyLV7pYkHDNvChT7DOa+R/HPgPxP8PvEWp+GfGumT6fqWm3RQWdxA 0EjwdAxznBzuBGTjH4Vz4X3qzT6M6MRDlpo4H+zFJaO0JyIy4LH5kwM10vw7t49OvUmuQbm6kuTH MjSFCqlhhQfp/OuivHlptmFGDlUif//U/pi/4JMaVDD+zJ4CZAYVuNKWSGNc7iAi43Z5yB8v/Aa+ AP8Ag4UvpdL+AVvI1slyo1KQSNI+LeNZRGgJ9SxRl9q+OyiPNhlL1PeziKhipRX9aH8I2rxLJfxX BVI7dYVOxBlTkAnHsOapszNM5VYpUlyEmRfLjiGABx+FbuCuc6irFO1uY43Fu0kaXbMW8kH5pff8 atT3kquQ7GBVXDEcFT60uS10Yla50qO8gjlhnuIwoIuJgN459V/I1r+GLHVdYS3sdKt01XULmQWG k2MQEE94wO3BJ68jrjoK4MU+Wm35HVQjecYn/9X8bJP2E/2ndN0bTfEdx8INZSyvrcXDDTfMuiib cluYxHz7N3r5T1f4d+JtA1y7j8Uafe6Td29w6nSNRha3vIAvAyh5wwGfzr4jD2eH5vI9atDlrejK MOmRTRXlvGkjXEx2QxIcDd79/wAvWvTvhV8BviD8ajNo3w68M6lr+rM7Q3Zt7aQ2dmqHbIssyg7W OcKoyTk+hrhxsnFQ9TtwcOaUvT9DuvGH7Lvxb+CYSLx78Odf8L2d2pe1ubtZbyKQg4Ac7Pk3HO3P Xn0rwnSvCut+L/EMGn6FpA1zUTM503TgMMWDBAGU8ck4574r3Z01/Z7kcEV/tKR+0v7GV5+3N+yR fxa94M+G2sJpV0UuL/TLa0kvLK5TAGBt5QjjB2njI6HNfVP7aX/BU79uTxV8MNW8E+N/hzaeEtI1 ywTS/wC2W8M3yTQQTbUZ5JpXMe5sqAwXueh5rxchXPWdu6/JHq5xFwpxv2/U/9b+bbxBb3GrX07a lcbNTNy093KYxA8rFjl2Ueox09K4u4NxZO0UBnnkDhmULxt9c9q+exFO02j0KD91I9R8GC8fUdIC CNY21O3EsjsftMZaVFzGvc8889K/0nv+CX2kS6L+zz4UQicQf2HbJYNcMHMimNQ30wAv4c18niW/ 7VpRXmfW4Wn/AMJNaXmv0Py1/wCDiS+vLf4T6Vpun20Mss8yLCnmh3Y+ai/JH6g7c+w96/iP1iyh g2m6SLf5YWZmUANnG4fie1fZ4iFsHS+Z8jhv96qFBLS2iiV4408kKAFI4GMYwPbFfoL/AME5JLxP 2qPAYSzluJLy7s4tOm8wpCm2dvNHoThsY9/evlc6tHAzT/rY+oyZN46ly73/ACP/1/7TPh3bRr8N tOkVd6DTmlkQjO3cuQg/3QR+dfwU/wDBbS4nv/2o/EFt9uBudM12TzbfywsgjaMBYz7BduPXNfNZ NF/2a3f7C/I9vN2v7Qkl/M/zPwku4vs19qJuZ5Ql1b7LVIFAaNwMfN7HrmqdvazSx/vVDJGBKruf nBHQ8/h+NcUlZoI7MoNdpdyyRXU808yvtiwdwixyFJ64GP1qzbPJdX8UQiZLSAj7W68ykHIGBjA5 /kKzrfCVTj71jRdLrT4RJF/pVtc3DIuYNzwgDvjp9az7Wy1NruFvIdoblfIjto8NN5pb5MfhnvXK dUYdEj//0P589K+EHxca3nvtL8H+LNS0yex8sPZ6JNKLkHB3EgY2jjk9uRmpz8DvipYaaz6v8P8A xWZSwlukj0SZURWyyNGzAE4/DBFfnVJ+5dn13s/fscPeeE9Z0K5tY9R0nWLG4vjK9xbahatAbOOL ADvngbiePXI9Kq6DqtxZXl3bSootpsoRj5mCt8pPp617NCHNh79jmqLlqqJNfvCjkw+VmU4RWGSl foZ/wS+k8Rj9qXw+mi6jJp2npPbXGrfZz5guGEqgF4zxySmSOcLXgcSpQy2bltdfme3kNNyzCCj5 /kf6OHhBDH8NYLuWZ3uodG8ze+VAxGrY9h1FfwF/8FnNZh8SftU65cG6uZ72zt5bue1lgxBZyvIr 7VbPPyN9714r3slgpZcpf3UeNmSSxjj5s//R/mgguLuT7W0JhSzuIt7+YuyQkHOcn6D34qp4bguF 1u68p1K6lCIFMcxRyQCFCnt65r4fGwsmfW4WN5JH9lv/AAQNj8Q3Xhaay1C8a5tZ7pb20y5JjhLB WMhxwQ0DjvwK/cT/AIKEahPon7Nvju4inngtbjw7LazRWseXuAQVAx1yen0JrwuDJe3lXT6VGj2u McMqU6DX2qcX+Fv0P81nxdcT3XiPxLLKu2zfXZ/skBG2ZVLZLO3fOQc159a2l3cXslhDCLkMzb5N wTyQfuDng8cHntXs5lG1aa7P9T5/CQ0gl1/yJJtJ1rStRl8OXOmamhZY0glgtWaNxIOCGxgY4z2q 5BoLWpuGuRdhQNkIa0eTeVznG0dz+daum4YdSJ5E6rR//9L+alLz7PFbpKrWPmyFBHexm3djnpz9 eKmeeUOFI8uQttgLHbG+Oc5r4BRbw0muh9OqS9tEzNRtL2WdJbqWZbqKTzE/duqXII4CuRg5yO/+ NK+jyyl7+JFhkliCkxt97HQlsn9K3wcObDuRWIgo1Eh73N1FcQqWKMYdsqRjO4DGWI69qu2mj3Fx erDcXkq2dzIot9sLIiu/Te4ByOnToM/jx4hWmkv61SOqlBezb/rZv9Dn7eSKTUZ7eC7hSa3lkgnt PNDS5UsPrzjNXFvZ3N5aytuay4gt3BEalhu69s966q8LUonnxS9o0f/T/mbintbm5sotWv5LKwLC GaSICRIM8EjPYHvVnVtE0hZZbFriPUraNldZlIYSY+ZW4+gr83aZ9NKKsVNQsdPn0idtJlguryxR vti3MqxiF2GUCr1OB1I9a5PSNGmtNMik88SNdM0zgSmZgzHO4k9jnj2Fc0nyVrmJrLBNMIYbq5Sz s4GMk128Zk2YHTHerSW8c9o8H22cyPKEszbR7Hum/h3DOMEdhnrXQnpqbU3ao0FxNb2FoqSEvdLl ZIz94MOwFZEVt/bwSc3LWsVpE2YHBK3GSBtxjgjk+nWmazWp/9T+ZzSrOOwtzaFY3LSNL5vlhZOe xPsOKz7rUbWwS402GJNpGLqZmO4Z+YbMdPrX5nJNs+oLULtbWUNyI42S4BCZIeQbe57jt1qp5lte xTh1e3dMBN8e0XB/ix3xinC+wDZ9JsbfSpZVkFnJL8puYUHnRjgDHXv2xWiz2NlZb5pby72QJGlz O4V14Ayy4OR9MY/StEruxjL4htpbSeV5kF0kkbEnbI29079fT/CpIYrmdYrefc7TSFYFT70pB6Kv WumC1NIfCkf/1f5+Phtb3ltrFv8AJJvW/hiWFoismRInc/736V+nHha0hk1bTdIuLi3iu47iJomi lBiujGVYQBjwc4249T3r9r8FI8nC2YVf8X/pJ8Bx4+fiXB0/T8z+1f8AYa0W6034F+EkubZLK4fT EupolyCNwV1VieoXO0f7tfkt/wAFivEd3bfZtFaOaa+1K1u572eAhkgVo/8AR4kX+8QsnPvXxPhT T9rx/B/32fdeIdT2XCztvyo/lr8bjULjwebaLFpJFYJZNHcdVG3GXPYjGc9a/F/4n6pf2GpeI/Dt xHFMLnUGkE/mrJsjAzG6kdzk/TNf0b46Pk4YpRfWa/Jn5F4ay5swqP8Aus+YbqMLOuwt5jNtGSSf bmuo0Pz5XmjdghUKFOMk+oH6V/HcvhZ+yydpn//W/ixtCYMRSbmBXcBtyCR0qRLm6V2UxgS7x5TH gID/AFFeRiFujWMr6GzFe3VjJbzC6bdvPmMBsMgOQV/HPSvSvCV9Z3us26xsUmQqwZG2OjZG3FeP WNoPWx9e+KbqYLZXWpvJdqtjHI2o3UaxuSgGN3065/rXHTzaZq+nW+paXNeNqMbESWtzbNDDOv8A eUnntwTXmVXqalmzuLu0K3qWVveygbPs9+5jhIxtxkVoWljDdQj7FHBZ3Yl2yWULF1tSTnAJ7HJr krO0DWOyP//X/jnk8PzW9hf6xpOWto7li7SXQaUF/mbK5zt5PTjtV2Gy06Gzt7+880mXaxViZEyT gYQA4rwUthxehX1vQri8l+2addxae5IMsVumEnAUD5j1zgCt/RLy3ht45pZJIhBL9nnAH7twuBj1 7HmtJK6EeqG70uOzntptEt9Qn1O1EdnqFw7IbNcgh4yOp46//XqrFYW3kXccs93CjwA7bdSdrKcg hv8A9dEIWb10f4f15jbTSVjz7xQhWb7eik200awpOX3LK6gKc/7R4/OueudPuLmzdH8xZlQq0RHl uvsR7/1rrjuhH//Q/i1u57DTbO5W8nmjmh4mhii3blPTJzjqK5zStQg8+3uIolnmF0q7pJA4K5AA /AUQXK0ZKTuz9PvgtcaNcQJYkSbl05b43KoBCvEKlXHpksAe270r9c/2Edbh0345+CtHstOsLd9a 1J0vbqKJY7x4440WNnkxj5yw68/u8Zr+2eGZe38J5x7Un/6Tc/nbDy+r+LMJ/wDT1fi7H96/w2Bu fA2mWcN5Hc28dqtp9pYL5hCxqjgt9QRmv5GP+Cv3hnUbD4gQm9uoLm0Xx9cyQQLIscsEiBPLml7k EKcAEZ444r+dPB6ap+IMU+sv/bkfsXjrTvk0X2Z+Huo6fai6uvOuLgyzEys6jBXcSTg4rJu7W10z TItXttTtgXuTZ3EbNiWIEFfmB4AOSPxr/QeldR0P5IoxtBn/0fxZ020uY55Ghjj84wF4Z7dizhcb mHsMdfpSWskFyfLuVmNwQzxhlYJtUgE56Zyehr/VaV1E/iR2bRp6cBPK9uWKqjhBn5WRSM5X25/M Gv6Hf+DfnUdP0v8AaS1DQFubYTXcfmxwCUtdlIopQGbtgvMowfUV+U+MeHnieBsVFdFf7rn7j4HV 4UuIpU5PWVOUV5t6/kj+2+iv89L6RP3iov3k/L/NH4Jf8F6NEtr/AOBHhHUJEQXVhrkTW8rEg489 EkX8pc/hXa/8EOdUaf8AZuv9LYRqtpfebEiOWKjz7iMnGeAcL+VfO41f8KtGS7v8mj6zhiV+Hs3g /wC7/wC2n//S/vV8YX15pnhXxFqWnsEvdP0W5vbZ2XeEaKJnBx3xt6V/IB4F+Lfi34yf8FE9A8P/ ABV1SLxZ4f0zx3PZwWOpWqy20wimbBkjYcgOIuvA8vjjFfF8UpzwkYp9f8j7HgyKnn9OEldWf5M/ sQ0rSdK0ayt7DRtPstMsLeFYra1sLZLWCNAAFAVQB0rn/Hngzw1478La34e8UaLp2tadqOlz2ctv qFss6qHjIyrEblIOCCpBBFfR0Ix+rRilpY+fxrl9aqNvW7P4wfgf4u8Y/s9/8FCtR8N+FdaufB/h lvG1zapo2m3rJYGE4dIZF6lcOw29sj0Ff2zWMpmsrOZn3tNaxys4xhyyAk8evWvmslq1Fm2Iw7+B Wa7X2f32R9FjeXEcJYDGT/iXcW+rVov82/vLVfnL/wAFQvhr4O8c/sq+PL7xD4V0jXdR0TT5ZtJv byxWW/sHaJtpgm+8h3pCeuMoK+oxFvYTv2Z8jUnKnFzjuj//0/1W/wCDfm+uNO8SfELSLtVVr+GV oiOyqpdQff8AdtwfWv6oq+P4YqOdKvfpN/lE+64v1lgp96MfzkFfy5f8F4/CNt4N8dfCv4meGNG0 /QtU1MsNT8Q6XaJZ6nf3cXKGaRMF8LFGctk5XrXbxBFyy2dt01/6Uv0Pl8FP2eMpSvbU/YD/AIJg eLtX8afsk+B9Y1zVLrVtU8+W3uJ72Xz7iJVSMrHvPJVSWwD0HFfR37Ung7SPHPwC+KGgaxY2d/DN 4UuprdL2FZo4Zo0LRyDPQgjqKyyFurktNTd9GvubR63F1KNLOa8aCts16uKd/vdz+V7/AII8+KfG /hr9r1/CFt4gvLPR7y/k03VtHS8aK0v4o5ZVw8H3SQqHn6c9K/sfBz+ePyrj4YrTnPE0X8MXG3zW v5HpcSwpyyvLMWl786bTfknp+bP/1P7+KK5zSS95BRQOUb7BXx18eP26v2fP2dPEMXhX4h67rZ12 SATtY+H9Bl1trcEkYlKH5Tx09/Y448fjKOX4WWKr/DE2w2HniK8aFJXk/wBD5z8S/wDBXT9kix8O apeW918QLq5/s+YW1neeArm2iuH8ttquXYAKT1zxiv5LYv2hbTxV+2nH458CPe+GbPxF4+jvLKPT 91re6eq+REMxqAPmILkc4IORnr83iMxo5rSpVKCdtd0v0b7H02TYDEYLPKDqNWvbTrf5H//V/vO8 DX76p4L8I6i9ybyS+8M2F1LdMMNcO9rGzufckkmuqrioNyoQb3sj1cypqlmFelFWSnJW7WbCiu1a nltWdgoqHeS0FawV/Gl/wW78B2mt/tf+GoYjBDc6zpxspGuE8yO1DMoV8DsQ5bH1rxc7ussqryOn Ax5sxwq/6eL8mf/W/az4Jf8ABD3wLq3wa8O6/a/F7xLpnizW9JGpJeWA8uw3yoCI8qdyoGGOATx9 BX4x618JPid+yb+2RofgT4oarcXUNh4ztrVdeu72e908wmZQLhJJOoGecehPbj81w+WKHD9KUb3a Tfz1/wAj7rM8XbiZ4a/uxcoerSa+R/eD4K1Sx1vwh4X1fTLqK9sNQ0C0urW6gcPFMrQIQQR+IPuK /J//AILbanqeg/saa/rOlXdzaXUWrW1rvguHhwrzIWOFIzwPwwD1Ar6ClK+VNdVD/M+Z4hi1iKsm 9Ofv0TT3P52/+CWv/BSHxR+y94v1Dw74i8L61448Gaz8t2ujyB7y0j3BgIo2AQsCznaWX5mHbkf0 l6Z/wV6+A2pRpJ/wrP45Qbjjy28GwvJ054Fxj9ce9fMcN42WEdShUjo5N6b7JfovxPezumqmBwWK p9aaXba7+/8A4B8N/wDBQj9vTQv2iPgvqXwy+Gfwv+IEh1hhb3Fx4k0SDT50LkHdEA8jArsH3cZL c8ci1/wQ28PePvCmo/EPT/Etvq1rpNzp4MFreeYkEEvmlmwp+UH5cH1Cj0r2puWKzGlXjsmvuuac M4pYfL8yoV/+XlOSivNLQ//X/uV+O3wb0f47fDnWvh7rWpahpEGpoHg1DTnxJbTIQ0bMn8S5HIyD 6EGv53/h58S/iR/wS1/aN1nwN4+0+58V/CnxTLEl3qWlh44xAshEdxFvXZuAkYbSRkqORyB8rnVO cacMbS+Km0/ls/8AgnrZdKmsT7KrtNcvz/rY/pS8A+PfDHxM8J6P428H6gup+H9cthdWF0q7WIIz tYZOGGcEZODWd8Ufhl4W+LvgzVvA/i+zW70jVYvLc7Faa3bkB4yQcEZI4556g4NenRq0sVRjUi7x kv6+a2fmZ4mjUwmJdKotYv8A4Zrye68jy34AfstfDn9nO21C38D/ANoO2okefJeTHGAS2NgO3qT+ ffAx8nf8FetX1LRf2OvE93pc09vMNbsxLLBIYnRN/wAxBBzkDkHqCBU1IQoYOpGOis3+DKx2JqY3 ERq1fJW8r2/U+aP+CIev3Ou/D3x5c3s26Z2hjijz83l28rRGQ+5Zm/ya/dyvM4cmnh5xXST/ADPa 4mpqnXw9la9OP5I//9D+zH9vnwzb+Kf2U/izYTwLP5Hh2W8jLBcQFEbc+SOMKW/OvxZ/4IQ+MLqX WPG3h27ubk5ichTOTbyHhlXZ03AIOfTHpXzWLny8rXdfme7l0ObEVF/df5M/TL/grvaTXP7FPj6W CMytZ6nYTEA42j7QodvXhPM/OvjD/gg9qyXfgD4mWIIL292j8MS2FdVBI7Z3Af8AARWtWokoGOFp 81Wsuy/yP6Cq/jI/a5hbRP8Agpvrd0Xl2X3jS1urdYI90qttWJgV7AmNifYmnWl+6duwYVf7ZTj5 /qj+xPwdKk/hPwvNHjZN4csZFwMDDW0ZFdJV0ZXpphiI2qy9f1P/0fvr/gudotnZ/tWeCL3TrP7L Pq3hpIby8so/s15LcG4XbJuXGWAdSCTk4r9f/wDgm7+xLoXwz8LeGfjDq/i3WvE3iHU7Nbiyt70F YrM4BJZiSSQTtAOeh55GPnakrYmMX/Wx9BhIXwFSS6NfqfoN+0/4fs/E/wCz/wDFfRb3T4tTju/B 135dtNardjzFjLRsEIPKkZB6ivww/wCCPHhPxr8Pvil4t0TULbWotMuLd1dZkmhsgu9zlkPy7uEP PXy/9njres0/M5cKrxqLyP1r/wCCid5qWnfsj/Fe/wBJ1C902+tNLSWK5sZTBKMSAkbhyOnUcg4x X5K/8EMPE8viDxF8Tpby7muZ/wCy/KhExLMoWaM7sn1+cevAqcXLlhC/dfmPK481erH+7L/0k/pH rlfG/gvw98Q/CuteDfFVhHqOha9ZNY39tIBkqw+8h/hZTyGHIrocklc5lGzdz//S/tI+AX7IPw6/ Z2v9QvvBN1qP+nblMMwEKKrnJVtpww6DoOlM/bn1e+0P9lL403+m3lxp98ng+dLS9tWMc9vLwYmV hyPnVRkcjNeSnZ3PQtofx2/8E5v+ChWtfs1/G3VNT8XaL4i8U6JqUb6bqU2nlr6XaZgXZY2H8WG+ 6w6Djjj+q3Qv+Con7L2uaPaautx8QbRbmAStBL4HumkibGWj9SR7gVz4d2xFVPuvyR111bDUfSX/ AKUz5q/bH/4KGfs+ePvgZ4w8A+FdL8TeK9a8Tae9jHZa94Fu7KxsSyMEnLzKE8xGZSoBJyD061+b P/BG6w+Jfgz49WtlOuvWfhXUTJbXqYkjs7oy/KjTIeBnA69lB7cdxwuPvH9adFaU+pElaTP/0/7+ KKwdrIb3YUUhH8zn/Bwx4dN9ovwdv0tbeUu8sJaVxGWMUpO0+2H/ADIryj/gmD/wTW8SePfhtZfF mL4q6z8O7XVLwyrH4WupDcXmQCRLtZc4B+UE8ADvXzmdJ/X8C/77/I+lyFXy7MF/dX5n63eI/wDg m7qXid7KHX/j/wCNvE+l2kyytpfiBZLiCTaMcZlYA++Cea/Q74Y/D/Svhf4L0bwVooQWGjweVH5c QhQk8nCjt9ef5V61WPNGx41GXJUcvJ/kf//U/ug+O2saz4e+DfxM1vw9dyWGt6V4Mv73Tb6Ftk1p LHA5EiN2ZeoI5BGRX8yP/BKHx1rnxX/a61bXfHesS+LtZtbyZjqWuTm8uWdzckmMMTjnDDHAK8V4 uM93Dt+n5no5eubG8vk/yP6xq4j4keFdD8aeBPFXhrxHpVnrOk6nodzFPYX8IngkYROUbHZlYKwI 5BHFdUehy1NpfM/kP/4JwfEjxb8NP+Cgt78NvDl/Po3h/WvHN14e1HQ4rhlsHtkeZ2haI8HCxbRn kbQewr+vH4k6lfaL8O/Her6dO1tqOleENS1GxuI+Hglhs5pInHurKpz7Vw0al82q0uyj+Nz1MZS5 eHMPXW7519z/AOCfyo/8E3viLrnx5/bZj1X4latP4pubLxFNeL/aQNwv2lXmeLerEjaDHkL0Bxji v64wAoCqAoUYAAwAB2FOlUtmFaPbl/IzqQbynDSfXm/M/9X+8L4i+C/DfxB8FeJPCfizSLLW9F1j SLizurK9gE0bBo2AZc8qwOCCOQRX8gv7CXxQ8cfAr/goPdfCfwzr+paT4P1fx1P4du/DwuC+j3cG WZUkiOR8o43dRgdwCPJzGpyZbUn5P8Dvyun7TOqNPu0f2YUVvhnehH0OfFK2ImvM+K/+CiGnSan+ xv8AHS2jJBXwhJcSMBkhImV5Pp8qtX4D/wDBvrcmD4vfFK0Qhornwxvd85ZGFxKwT6EHd+FeRxXr ldB9qkPzZ7fA6/4W8Uu9Gf5RP6zByBXn3xYtRe/DD4i2bZ2XHgfVI2wMkj7FNn9K+zyV2zDCv+9D 80fA8TwSyPHf9e6n/pLP/9b8+fjHZ3Unj/XtGFz5t5L4hlgvLhoygRIipQK3Q5Jb8DXiGtxCyEyi KY+UdrP2XsTX+sGSf7lTf91fkj+EpSvH5v8ANnJWM6wm5Kx+bFNFujuAQFjIPOat6ck2rW7NMd8U cbvCjN8rYU4P6V9Achz0GnNECZjGzO5wg5UenBra/e29oyxtBEyJukEYCgDvXZS+AmTsrHOW0k0l 39ogj3BCeJBkHqP65qC9F2s6Ccgws4ICnIUk4rVRbdjGUras/9f8QtUggeZkt5RLBFwkyggY/Gsq ASI53OY4FPzHuwzX+y6XKrH+fnOjorW5MjIkcgSBW3BW49M81o3um6PeAoZpGvVAZQhUopz37nvT DnVjjm0x4buSGBtiMdtzuJ+X6D1ppiht5XhjaUxgfPJIuD+FaQXUyb6s0ksLIpBfv5y+TkREOVU8 dCO/41lT3sRjkHkKWY4U9APetUruxlze9c//0PwUUiR2iZRkgZYj7vfr/hUxNuiEwqZ5IeCByUNf 7TpKOx/neX7OWa5SaW4kSOGLaqj+Jic9vQY/WoL65WWNUg8uTY+VwemK1ghNpaMzmaUB38sj59pI PX1qVYobh1gkiLwsN7Mw4XHv61oLmV7F020MNrcEJPISNtvtIVGI7ZNZCS3KCKGSKS2RXLTRZ3Bz yMk0FH//0fwS063sWd0uVMg3ElySDj0x0psVjCSZIQ21pCirn7g7A1/tmoXR/neNuFe2yzK/lA5w BnFS20cd2W2rvDr8gx0x61pZWsBbisGKyRkKm3kDoTXO3tvJZSjeCWfLL3UY4oSS2Anh87aXXaN6 7fcVaETtaFFbGXzKryFM9aYN23P/0vwOtjA9usPl7XQkvMxyxHYUxEjeLYjIWimL56lR6f59K/21 mtLn+dDd2MeUyI6qnfAOMZPtWQ9vO6TRSRsVUZlD/LxWYi8LtZgsCJhIYwsaj+HAxiq81rmNRMwR 2bKleOO1ICF4AiiPzMN/ET/jVmLRnTJikglQjcJFODnHIOfTpRboB//T/ncYPFcszZAVvmYnha2p JJhEl4rPIsa7Qo5Q/UV/ttGPKj/Ojmfcs2F1bXcUCMFSa4T995pCIGOcAd8Yx1qla6ZK0khc7nDu qwJlkZf4SDVG0ZXKSwSxCRvJaMk7XTHPXviolDiZFd2QE9epAoL5nsTS2kcrrteTIYqJWTaPTPWr ME8+m20tpdZnMxyVkAeKQDkH8M8UGUpW0R//1P55pVNztYREDHTpj/61Q75LZPKDsEJwyj7pFf7c tNbn+c5NEQwZY49sWcs2MD3pJYk3wzAuHVsKFyFPbkUjOUrOyNSG5MRxOAc8gfxc0y4kszvRVySd xJ7HrVKLYlNrcpyLC6DfxVJoBeMtuGbyzwSDg+2KTTWjNU76o//V/nvMF/aMtqLeS93RnCxgt5YA +8T7VUNxFaoyqjmbpKCvAz2zX+3B/nZzoozGGT5otwzjnpirzWstr9njv0dVuoQ9sG53KcgH9KCH JsgVWSQwquVCnAxnFSwoVDiUE5OAPSgkeVi2tGF3P2OOKrkFVaNFGSMe4pOKe4H/1v51JUuIYU2q XKH5/M5Zh7Gtz/R4rX7RE+GkAHDZJ9Riv9uLH+c427BuYYzDlU2cqDklgOTWbJpqy2bRS72DEFiG 5wDnH6VLijaLuiGK6dUeCJw0aHaNnJQjqKlnu4vIPDmVU5AwN5HaoULvUu5Wt2EkQkaEhmXlTzt9 RTo3SBt+zfj+HkAVfJER/9f+diJ5SFaVkEjEkquQgp3mXGwRrIPKkcuy7s8jjOPWv9tHB30P87xI fKZiGLDa21938RqpfQrvHkYIB+bb/DTUEBCLiaCFkEhIB+b19xTjf3UkafMD5a7I1xjaKORWsGxN YC4YSNOwuGJJG8cqPSkkieVtitli2SvZcU1FRMHuf//Q/nNcywER7yyHsOcU2zwkszyM264xGc8K FHb9a/21cFqf50qTWhq3MdqsJiKKYgwNs0aZMTc9PTPrWdEvDICVO7GOhNYyV1Y050S3I8wRdQ0f HB7f5/rU8ZVtiOCJOi7ujVgWpWaNa01EaRKIpo3kguGCTrF95Bz8w+lcp4hl803pg8xrby3zuGw7 MHO70rkxCapS9P0OqhJe2gvM/9H+M7xTq8U2tvDPbM8Qun2y27ZjcDIHP4fnXOGKF5ZHwkWFyCTk dO9fonG0k+KMf/19n/6Uz5rJdMqw6/ux/IzLlY5SpXhX+9x96pdPie5MlsxRQnKHO1mr5K6Pai7y aC6kmEwtETyQh4mB+VscHmtmyh3II0OSWwW/vetYN2uzSK1R6B4S3J4t8EpJJcQxf8JLbxtJbLmY n5sDGenX8hX+tL/wTOtmtf2VvhzuvmupofDsZnj8vy44t8EbxjA74fB+lfL5p/v+HXr+h9xkP/In xv8A27+p/9L2D/g5zmX+yfAdlOGMUGtTvGgz+93JGhZSDkEFE49xX83f/BP3/gn74+/bS+IMM/hu 1uZtC8NeJPI1iaeSN7mZ12vFGltxzwcuScbh3r1uLcRLA5BhsRBXko6fOyR5vBGDjmOf4rDzdk6m vort/kf6A/7Pf7KfwU/Zr+CdnD47+Gmj2dnoehyNqclzbxwefJHEGmnmMgHzEKed3AA6YrwTXf22 /wDgmnoVzNYapL4NsGs7j7LJB9ohD256ZyjZOOa+ayDIauKwUcRNa9b97/5WP0LM85w1LNZ4elO3 ZLslb87n1v8As9+K/wBiL9pTR9TsvhnpPh3W/KxHcrZW8PmOrZAIPzFh7sMHnriv5fv+C4v/AASJ 1bwL4k8Q/tDfCLwmzeB5LFLnxBotvZYa0Zf9bcWyRjA4Ks3HHJz6duGw0MPjKmDWrat8+h5Gfzl9 RjiWnu/u/wCHP5BtZ06XT7hiYnR3c4QqfMChiAD78V+1n/BGT47fs+/CT402mh/G3w/oRh125hjs dcms2f7C5kCo8hwQB+8+Zv4dgJ43Vz57hamIwFTDUtJe7+DTf4Iz4Sq0YZtQqV/h1/FNL8bH/9P+ u74e/CD9nPx54bstb0Lwhous6TeWccn2yzVGMjMo3KTjkDJGK/ju/wCDkL9lj4T/AAyvdB8e+AdC /sPVNR1WXQ71dPhW2iuvlR4y8agEkHcO+c+vJ04Twsa3Om78sW/mtfzO/jjE4jCVaVJq3M+Vryd/ 0P5JUvYrC7tbjU0Nwmnssstup+abbyQMHPr0Nf3pf8ENPjr+yR8Wvhjp3gObw9odh4y06xW2vNOM Kb7negAdQ/zkEg7h/D2zg48rP8NOtKlUTtGMnf5r/gHXw3yylVoWvOUVy+qd3+Z3f/BVT/glf4Z8 R6j4f+M3wk8Gr9m0a8Or61pi6dE9nPH+7aVVKAMD+7DbWbkM2OcGu5/Z8/aa/YC8PeCtG8C+OfDP hrwt4ihijsL3wpcra27WrAeWWKkhgoK45APHI6krMKdTGU8MobJa/LQ9rAVsNhadSlNLnk7I+8vj R+wT+zB+1v8As96zZeB/CmnxrrmlvcaRcaTbRQGeRYiYw5HU8gYJyA3BBwa/zqv25/2HPij+yP8A FDUvDnivw9d2NleazPFoyXAP2e6QZZHhmIA+6CMHrgjg5r18rjTqUHThrKL38uv3Hy/E8VQqRdRW k9Pz/M//1P4/DLFFHGs+iLqbLcIslnOzIp2vnDFTxgj1r+9X/gh/8Yf2Ovjv8LNG8Gax4W0DTviF Z2hj1bQ7qKO5eRkxGJFb7zo2Bgsdw6EEgmvKzfCzqyp1Iysot39H/ke9w1WjCrWw7Ws46Pzj/nf8 D9//AIo/sefs8eKvhzr+nv8ADrQooJNEuWEyaZArygLnO7buGccEHj8K/wAv/wDbz+Hmj+C/2ifj b4H8PILbSvDPj65tLMTLsMECNiOMAYGBtz+vevbyuL/s2pUbvt+p4WeVZf2jCh01f3aFb9hj4qfD /wCE3x48A+JvihoemeI/B9prUNlrNhqEAuFEEuVNzFGQQzR5DbSOfLAzzmv9Jf4RfCr9jv8Aas/Z 605PA3h/wzrek6porJaNptvEkMDlNhTaRhSCSPUH6GvkMbSlHOoYmTtHlSXqm3+qPrMlUamTVqMf iTu/Rxt+a/zP5+/+GOfAP/BPj9qTW9c+MXgUa58Ldc1Rr7Qrm4s/tNrp6SOzQna3yAoWYYOQeMdN q/uv8D/jJ+wP8ZdUTw94QtPDeoal9kijvbP7GieR5g2oCOo7jdjHucV347Kp1qqx021BajweIgqH 1eg/3kd+/wDW5//V+/P+Cy//AASM0n4qeAZPiX8BvB2nadq+iW0l/fwWunLtvIUG4JsVcc9d2N3A +tfykfsgfsCfF/8AaS+MV54A07SrywsPDt4E1zy7dUuYmSTyzbvuYZDEFT0496yx+KjHJoYj7SVn 8tj2ctwUq/EfsZ/BJ3+XXv8AI/vh/Zf/AGNPgf8As3/CPS4PFXgHw7pl3oOkbtXll0+GFrmSKL5n LsAWG1TjnAz2xXh3xF+Nn/BPT4h2PiL4ZW+l6Fe6zrZn01tN0pYIbm4k2lTtZW+RvTOCMV5+XZPO pgliZvbV+v8AVv6Z62b42jUzKWFopWeiXkv6/qx8sfsJ/wDBL3wZ4D+K3iv4p6p4Ii1jwNJcSHw0 +r6QszwIXaUESgbdw+QFgP4c45GPU/8Agq3qf7Ffgj4HX2i+MtJ0fSvFL2EllpFlpgiXUPNaFwAp POM7flPHXg4p5bgZ43MHj9fda+5XucHEVejh8CsDS0bT+/T/AIJ/nceMZI7nxFrs8EyzWs+qyT22 VWOXyxhFJUf7vb+tcebkwOWXHlLy2TjFehW5faycdrv7j5ykpKlFS3srn//W/j8gaOWMMFP7zgyL 1Gaui2t1WMOn3DlZP4hxjNcLjuzSmiBSHuFgEijecKd2K/Qz9hfxb8P/AISfGfwT4j+KMemap4cs NYjieLUIfttvbef8pdiMkBMbsrwNvOK5MVGU6ThDc7cvUIYyE6vwp3fyP7lfAn7Zf/BOfxB4I0Of UrjwTdSG28p4JLW3uZLeSP5SPMJwOnHOa+tfgT4p/Y6/aHsNb0bwZ4e0jVTxItt9jgltpUGY/wB0 MEZHuD168UUsudLDxrSfTU+sp1Vip1I0o6a/cfza/wDBZb/gkDrHhDVtb+NfwR8Jyv4fvbb+0fEG lqQ0UhiVmYoB93CjHPABHpX8jWr2l5p+o3dheW/2d4Jmj+zlt80QBI2nHfINepVwvJRjXitHp8z4 epD2Vdwff8Ln/9f+S3fbvFFFn94YwoXbjHYZqKeGSxhMjKu2QbR79a8ya0uaTKyKZFjQIDkdD0xT 4VRQ0Y2oVbBA4FQ171iuVWSZsWaTSSrHDcraLgrLM4+VVII/qPyr/Qd/4N4Le1tf2aoLMSS3GpQa yBfSuW8hwFVyw/2iScnvgV42ZxXtqF/5v8z6zhz+Div8B+oP/BQT9n7xX+0Z8HPFPw+0G9eA6lph t/LQguV3bsKp4OSACPQmvwm/YD/4JE/Fj9n74xw/EnxHGXFtPtsZrWKVpMhiQ0zNgYA4wowc/l72 YxWIylYWPxbmWUTp4XMJYustD//Q/q4/aA/a8+Hn7PHw01mX4l6hFpMWnaJlpZnGZ227CCnUkkHA HXP1r+HjRv2d/EH/AAUu/bF+Inif4dafMPA194zk1EyXcQWeW1V1jizEhJXzPlfaW4EnqDjkrSeD yOWIl1enno/1aPfwkaeNzz6vfRXUvLVfoj+xr4A/ssfCX9mz4R2WleLPAPh62/sTSoo7l20yNLSR oYlDMOAM/L144ArxnxL+37+wP4X1S/8AD+qaZplvc292YZVs9BCxTOjbeHQYJBHXP415mVZfV+pq dR+/u/Vu/wCB14+eH+uyjS+C+nTY+lfgB8Tf2U/2iher4N8NeHL+OSEwILmxiFy2MgoCclTweOh5 64Nfz5/8Fpf+CUd3HcXXx++DXgyKw0i002V/E+mWNuIopSh3+bGijb8qnJxjG0cntvCXJVlSm79D nx9CUKEZTWvQ/Mr/AIJx/wDBLPxj+0D4o0TxZq6x674d0rWVnstJjKMyPHhnN50+6WVQnOeTX9pt 7oPwS/Za+GMUfi7wpo9lpGg6PDHeGOzjhtwFi2t26fIRnrXk0acsVmMrdNF+Gp6sIxweApw+3L3n 28kv637n/9H9uX/4KJf8E5bSfF8nhq1vUXm0mgiRlJO3aQxHPHQgH2r7k+Fmp/srfta/Du7/AOER 8MaDq+iXsD2booilP907SMgYIIx1BB7givnMThfq7Sk7NM+6rOvXwrklokfxzf8ABXT/AIJea/8A AL4sah478F6RL/wr7xjrgntoLGPzY9LeQ8x8cLk8/N69Tg7fq7/gkH/wSp8ST61o3x48f+ErTV9L MKPosWtSxX6svmNiQRZIQgqrAHgAjjk4xzeE5YVKg7SlZdtevc8vh2knKpiMQrqm3/TX/D9Nz+lL 43fEr9nD9nHw3Y3XxN0bw5penxR+VK8lugmCrgDDH3GcDsCexNfIlt/wVL/4J+SahZ6bbx+H72S9 u1t0jhtYXdG6B+hxx/Hxjua9Kaaop+Rw0YNza8/1Purxb8G/gr+1r8G9a0nSfCenSWHiDR5YbaVI ot0e+MqjbxkdwR3zj6V/Ff8AGr/gnh47/ZW/au8GaBrGlSP4MvvHEA8OS3BSQJEZQZgpxgjYzdM8 OOh6c9JXg7HRWhadj//S/sC+Anwr+Fl18GdBgl8I6XLbXukxRyCWxSOZcRLwhx7D8x71/FF/wXk+ E/g3wB+0h4f1zwhYWtjHrOkO2oqJQJCNzIQyj7pDBuO+fXmvCUfdd+x7bh7y9T9hP+Dff4WeA774 H22p6p4YtZ9UbUZQrX1kHwmdysSR/Fgt7k19af8ABaX4OfCQ/sz634nuvC9paatpkUlxYCCACJ50 VihPHG4buP8AZHpmsMPFN7dWa4uFkmuyP4hP2T/jR4S+DHxu8F+MvG+iQXejwa7v1DzbMXSu6yZt 5WUnGEIyDzgtX+iP+zN4s+AH7TfwV0u58M6DpGqWOpaJF9pne3jWSNpo8HnGdykYJxjI71nWVqii aYSF6U79j5E+DH/BNPwx8G/2hPF3xHufDeg3Wn6vdSPA9xo8d08cbSiRfLYg4Y7I8sCMhSCOcD7N 8S/HD9n/AMKfFLSPhPcaD4Xl8QXFrFHFFFDEqqsiklBGRkgBTyvHB7Amu6pTtSbSOanH96l5P9T/ 0/3Y/wCCqX/BNPwt+1P8LX8QeDPBFlZeK9KsHuNM1TTU2SQBVLBdgxlCSBjJ6/iP5Pf2Xv8Agm18 WPin8dB8M7q00kf8IxqQttdFzOIr/wAhWAkhjT76MQoy20HoPXHz9rUrf1se3CN6rP7dv2ff2dfA H7KHwf0vRde8J6DGNJ05pr26awWW33bdzfPj5uFGW9B0r4n8Vf8ABWj9iXwp4pv/AAr4g0zw/a31 heSQXjQqht8xE9AUCsCQR8ucHjqCKXL7tgcPesj6x/ZS/bN/Zj/apubnSfh9pmgzzurxQW8kMStO U/g2sAQcZ/yDX5O/8Fmv+CY58Y6bP8cPhVpUGj6rpGmvNe6etolzFc+WGlkC5wEztAJ/ug5z1Dt0 NFG2x+RH/BM//glb4x+PHiiz+IOrva/YNK8QxXI061vfNt5DAS7NJGcjG7AKgc4AyO39mV/N8Pv2 afhMZPE/hTRIrTSLWKymkNklqoVUC53bTtHy8YHce9TRi3F/MjFRs1Y//9T9tdT/AOCvX7KNtdz6 TdeD7We7sZmtbeK2tWUvn5ch/KClT3yeMc1+hHwB+LfwY/ai8HytoPhTR5LS5t5LRoZYFFwibBnd 8g6ZPqMY9xXz0o30PQP5XP8Agsb/AMEt9Z+GHi3Wfjx4A0OO08KXEpnvbHSQYrKTzpAN7KASGXJ/ 2fu+1fzFeJYVS7VIcSkEou3ll9c/lUyjpdHPazaKCRW0UUcbKE3fKQo+6T3NZkmnul5JLDO8gdBH tkA2qBXDKPvGtPY1FK2kAjiQFtuFO7AHr/WtjRVbzBK6odjeYsI5M3Hp65P6UNXOmlof/9Xtv+Df PRLiX4ja7qhtJY4bi9Iu0KZkjQbMLuxjaTgr9Wr+yr4q+Hz4z8D6l4cSWS1Op2D2MYUhTGTGyjrx 3/WvisI/3s12f6H09ZL2MH5f5n85sP8AwRQvrj4vR/ETWNYk1VI9Wj1RZlvYhLCyTCVt5YEvwNuQ AeeCOMftlfeP9K/ZW+FT6j4guY7Xw74c0xVe6vnW1gCQxBTJI5HH3euO/WuprlxF2Olb2B/JL+2H 8W7j/gqT+1X4Y8LfD6x06PRNNkj8PWt1NfSsiwyOkkkzoY1OMtKFRQfuDLDJI/o8/Yh/Yrh/ZR+H zwavp+janEtukhkSxWViFQAP90EY9Dkcn1renLmqtehNWPLRTXmeW/H3/gqv+zT8BPFk/g3xZpem 3eo2DtBcQyPFaQW5/wBrMTDp16n2640f2cv+Cp37MH7Q/i6HwZ4N0DTYdQiZVaOKVWik3HH7seUo boT74JHAOMMf7kJfInDx55K5/9b+hj/gpX/wT40r9qr4O3d/4H0i0svFWmhryK509Vhmu4DiTym3 DBDEbTk8Z4wea/lR/ZU/4JgeLvjH8b9a+GGv2kEU3grUDFe2txKbBLKSObymkkVRiTK5+UdD+OPk azth1L+uh9JCF69j+0D4NfBTw/8AsjfBqy0rUNNtNQj8L6U/nXH2GF5Y4kUZVJAvIJG7PbJ4HSvz 38U/8Fnv2SfBfiDUtA1x9DikspCkjmzkl3vnG3IiyT68HpXc42oXOTlftT7N/ZH/AG3/AIGftX3l zpngzRtGuIZFO8i0KJnvlHQcYyNw7j2OPyp/4LN/8Erbz4l6befHL4M6JplrqWlwSSajodqohm1B G+aZg2OvGQhxz35yPOy33sVNebO3Gw5aEX5I/i08V6Fd+BNSu4dXjubK5sZ/sF9FK4mki2sFyNhI Ocg8etdP4HtnvfHPg0WlvHdpd69BbJaMm8XDFgwUj329/WuvHPlpTZhhIc1aCXdH/9f+q7/gnTpc Wj/s9+Eli2IbTSIIRHEwBViilzgdiWavxL/4OKvEO/wHaeHpL263pKt3HY26M0VyvnxowY+imXPp wK+OyGXNgovyZ9LxBHkx84+f6H8YWo2kdxK9rBFNKLeDf8u5QQQRzj0xn2rAR7c4sUcI0a5CLyFx jqa3nLllY4Iu6M9rC1upLl/Kkie3AKX7L5LyY+YBfzwam8xbiSzXz4ZZGPlfZpM7p14yQfbn86E7 psxO10vVodNt5447aGaR0MflTqDbnI44x2NfaH/BPDwlb+Jf2nvhdLqw0+YWOox6pdaddQI8DKLm OMRLu+/u6kdCFNeVmFT2eHnJ9EelgafPiYQP/9D+zzwV4A8BD4V2lhqXhXSJYX0UvPKtsskxBjAB 3Y6jpxxxX8Ef/BYDwb4Y8MftOeLrfwnFDBBb6hLZS2ZiaKEvLDFcM0TNz8rmRTjjivisIv8AYr+S /I+gxEP9rcfN/mfiLqYm028S+ee5t7JVL3D243SMwIwMYPXkfjX9nP8Awb5+BNFl+HM2o6xo1hcC 5vBfNd/YebuU7mAzjBIEvJOeePWuDMk1Ck/7y/M78vheVReT/I/W/wD4Kq/DH4Ta9+zP4qn13wjo 0d3baas9nIbJU8iRXURPnGR0I45HHTmv4Jf2dvim3wk+PsXjy58PaNNpukapILSydFuI4YHkyTjP JVQDnjOO3Wvqq1O2U8zPFiv9st5n+gz+xd8avgn+0t8HvCOs+HPCmlfb1sVN5HJBGTBLGoR0HAYj crckDPHFeDf8Fbfhn8JL79mLxhd+JPCOnyTR2fl2cNpEbZlnZHSB/kIIKs2QexFfMcJrnnJvoz3e I48sYryR/9H+crU7jS769vzA0sMmnXBsXgfLMTENrfMeSMjg1x9vPuaUv822dgGWPkjt+Q4ryMVH 32d1C/Kj2H4T6dbaz8QPBGn3d0bOK81mNlieLmUqynaT2yMj6kV/pdf8E8bS3t/2fvBt7EEaOfQL JoFVs5/0dI3yvY5jNfC4t2z6hFdmfb4WN+H8RLzR+D3/AAcTaxHp8PgSyknlDzXDT2trBGTu82dU ZmbphSpxX8bPiWYXF8LaQloPNIjLHcMKeA35da+9xathKS8v1Ph8Gn9YqMxbvU7jTliW8tU8qaUR 2Yt5PNlmHHJXAwevHPSv1T/4JRJb6x+1j4JbVY5xZ+HUS/tLbyy8XnOxEZI/2m2g9hivh+Jm45ZU a8vzR9jw8k8zpJ+f5H//0v7VdCC6L8N7azIdFXSBcTC24lRmQNt/LAr/AD5P+Ctd/rE/7U/xR1HF uy3eqPbu2oNm4SSN0jjaMdfuq+e3Svm8k/5FTv8AyL8j2c50zKX+J/mfjf4kt5YHgmkgAeYbllzj eO5H6Vkyh0WIGZD5uHYI27qPun36VwzexVLYkFpG8ulXtlbGXUkumhuNPUb4pw20I+OrHtj2qCXQ tU024a6ulvrfzptyxmFkQj0ORxjNZ1tYmkfjfyNKCea3jnUPuZV3Rp1D5xx7f/Wr0H4ca3pOieLf DOv+IrOG9stP1aGe7srgGSzkQHDeYB2Xr/wHtXDUlZJHpUoXi32P/9P9OP2Jv2w/+CfmpfDLTIPE OneFNF16KxXTn0+/0yNWkCL80cbsADkljzgn09f0Q+Gvjr9hr4o64ll4Z0zwlc3krfYktDY27vIr DGSMtwMH9fSvztx5KHMfb0kpVuU/ND/grP8A8EwdP8R+Erj4hfBLwbbwy/YZRf3um2EETWUAdZsI iLnZiMEkY4PfrX8W/jTw7qfgrU9RTWrW4tWsrkWN288WwpKHET5XAwN/Q4xgjmvocFBvAORwYlqO LijjLZXuZ2WRS0aOQkuOVPsa/WT/AIJMaPP/AMNS+HIhFi31W5gB1GYmFrdY2AlxngjiMY9SK+R4 t/5Fco+a/wDSkfS8NRvmUPJP8mf6I+lwbvALWxk3Z0doZmlIRQDGMD8iPzr/AD2P+Crl/FfftVeK beQWzObO9iBtW83K/bpI0BOegEWR/v19ZkCUcnT/ALq/Q+bzf/kZy/xM/9T+aN5E8yTTZ7fygH8q aRwcBeRnPfNP0/S4zdJc2oYNZMXhfd5cYwMCvjMb70X6H2eGVmvU/tp/4IF6ZqunfD2CzmsbUTgo lxdJOJcwF5HT2BzK3I67q/T7/gqJr+pad+zj4x0+GKNvttm6wS8pcQsInGEI4w24dfSvC4Bim8Rb /n4z3ONL89C//PtH+dF410u8g8Yajpd2ZS/2gLaQxJ5phDZIDbeuM856Z9q/Qz/gnv8AsI+L/wBo b4k6Be+LPBeoJ8OtE1ITavqEkc1tbXRLYTE4HQqdwAz0/L0M9qezzGNNfaf5anl5ZQVTDOf8qP65 m/4J5fsUeF/B2kx+PvCGhQyW1oWtr/Ugsc1rhcud5OccfxZrlrD9jv8A4Ju3RtALL4a3iqnl2cSa jAL2I5ywHzZ3HP3cKa9nGxjSy6NR7HBhourinBH/1f2d/ag/4JIfst/Ej4MalJ8MvBHhpr6w06XU NBvbK2Jny+3evmKC2cjueMfn/Jv8Iv2TtQsf2qNA+Cnj/RoZtG0nxcbPUZJbIwX0tsrl0TMgwM7Q GIBzsx6mvhqDjUwNSpHa/wCp9pUpOGLhTe6S/I/r7sf+CP8A+zNrfw2vZbrwzpen3l3pQa1toZFE M7LEA8kgC7dxIPBzgDvX8Zf7dH7P/h79nb4x6v8AD3QH22EVxdXdqkEgCRwCQIg24x94sAR/dPHF deXxtgb+Rlio/wC08p8UaBZBTcNeH7QPIKLd7Mzkg7lHToBmv6wP+CV//BMD4SfHL4J+Gte+KcI1 3UdSt/7ckYrA8Ono5JiRXZWJO0Z4xjJwB38nMZSp1qMV9p2/X9DvwtOM6VRv7Kv+n6nzp/wV1/4J PfDz9mfw7J8TvhdbaRaLPMr23lQoL+ObaWIbAAeMojHJO4Mo6g1/NzrCJFYvdzjfL5W8pboPMmbG cAE9+2a9TEU7UIfM8VW9oz//1v5gY08+2NrLZxC0uocSbuJIM4OABxnrzWhI8KQSMYJIHidYgU+Y sq8ZwO3P86/P5Relz6d7MrRXEVvcTxNEt7FcABreFcl96gEEjuM8/Sr32FtKktdNsrGRbcW6yI0j fLGD2XuepwK4MRG09DKCvJIqSR2t3JLaTTs0N1m3EEbqqmXkDJ9uc1Sa2kS4isrRlN7YOHtoi+Fj I+UEkfjWqXuo0irVLGpJoAgvGnup/tV0wWeYlfKiV8cgdyPenQedYqF+zKkDyNNG7LxKxPzc9xkd PeqNpo//1/5lHmvFIkkjVYn4DJkp9AasfYrK5jaW4hikbbkq3fHrX5ufUFBY4Yy62u4RMcBCcqhH Hy0t2unWDwrcoJru7Tba7Xy8ZHOQOg9D9RQl2Iv79iW0Et1bXMUyLGkL/L5v3lKgNwPxH5VHNJay 28xu5X3+WI4AgBRsYAB/CtoQ+8ym92ibS7ER211dR3CoyFS9u7AGVfSMf561o2+nz3kVxq+mLB9r tbffFHNOYzFzz3/PHpXTCD6G0PhR/9D8KvgvcX2o31jfX0EF3cea0M0cgJ8xwfLDB8jBDEMD221+ jPwkls28YeD9Kk0y1v7q51oRwvcqZFhCxlgT2GCBg+/0r9y8II+z4HzCf+L/ANJR+ecY+9xhg4en 5n9xH7KsLaJ8JPDWn3MhuPsdjC9zMx8wESJvCKR2GSMfSvwf/wCC0N1oiahpf2uO70u4SX+2bu4g JbMccvkW0TDqN/mjgfXtXxvg3Dn47i/OR9n4oT9nwvK/ZH8zvxEvDPDeWyEWa36lrpvuRHCkqgJ+ g5/+vX4ifEo6Q/i7V5raFY4IJmilvDIWaeTJ3oc9VXgZzX7x4+zayDDRX86/Jn5Z4XK+LrS/u/qe CXUSvdPKsisPMJjKfc6+ldRo7Osqgp95fmkQZxiv5Ccvddz9kl8Z/9H+K+1uJp1A8oo0Z+Zgu5mX sfxrd0uEXd1HaJhriXiN2wqD6k9OtePX1TLp7nR/2ZbxmCz1b7MJjPvR1HmBSOhB/DP8q2vCFhbW 2v2wjgmupZrjbElu+wKcffb/AICDx9K8mstDeHxI+t9Ugnit7HS7+ZBpGpxK1ttxPJI5ByjYOVHA z+NW72WKyWzs7e3jEmwRgIoZPXLHt+NeXVWpsQatbxDSkfUo1ijlkE0UsD+Zs8psngc9QOKq2Phv UbWNNUtbuKbTb+UzpNDKGlPHMbDqCMCuLExfszeKWh//0v40NNsJdLuIrKBnup9XZ5YnG6VHYHB3 jkLn046Vt2Vxc2mpW92+JbawlW4+yBBLDLsz8hj/AIl9R3rxGnoRB6WOh199O1FY4PDnkaXIrLc3 4sZC4bzVVmTY4JUqSR/wGun8KTS6VExNlpGt2cFsY9Qj1C2W4kIl4DDujA96bjePLcaTs0a08f8A aBghiuLWGzt1zYWcM29kDYPkqOcBakivdUWWVZXiliMHkRxOMPEQMcep+vpVx0auUcb4ts9Qv7fw /BPElqtrcPdPsOxVOMAse5zj8BWJf3EsdjNqLzSFCfszvJw4dQcuc87ePvV0R3QH/9P+K7XHWdPO jkhvEntwJVTIU9eDkdf881zmlWEUT/JGsUpO8bRlVPbinS1aucyTdRRP0a/ZnQa1Z39l5d7bX0fh +N2lCAwSRiWIMrY7hkxwABgfh+qf7KF7r3hL46/DOV7exGnavfDzppp1Ezqk8UTsO48tRIcHqSPr X9ucAqFfwxnCe3JJf+Sn87Zj7TD+KUJ0+lSL/FH+g/8ACFbSXwDplnYkSpFpiSpdL8wn82ISKwI4 OSTk+or+Uf8A4LSaeT45czCAT22sf2lJbTy+VJt2RNuDdMH94cfSv5s8KZcniRCMv5//AG4/ZvHT XIYSXdfij8CLyCeSUy+cVR2AjVVyrDOeD/nNUp0h23KC0ty0sBS4F0P3chAIDBf73TH4V/oVS+A/ kmD92x//1PxJtL+SK3jjEMth5URVJbdyM54bOfY9OlaaXd3Pp8tuNQilCoFsJJIwHRScycqOe5Hu a/1VnsfxFTs2XtH+1JaiaVC0iHyfOZcByOme3PWvrr9l79pTxh+yR8Q9P+K3hXSrG7vLeSLUNWtb mWe2ur6OHkRwyR8glSTjGCVHfr8vxdl0c3yDE4Cf2oNL1Wx+geH2ayybP8Pi47KSv6O6f5n9QvwL /wCDjv4KfFrXPD/ha6+D3iTT9Z1SaKyuZrbXYjGsrgKSkLxBiN+R1x7gV/RxoWrQ69ouk63bxvFB q+mw6lDG5DMizRrIoJHB4YV/lzXnVwmf4jJK6d6T0fR9NNF+p/Z+Pyf2WUxz2jK9Kq7Lune9n8l5 H4wf8FxrO3n/AGarBjGr3bXkxhDAkkQvbA7fQ/v8/Ra8w/4IJShvg34tRmZZ0fe8AYMqZu5QPcHC qcdt/vXl4x2zCm/P/I34PlfKs5h/dX6H/9X++PXovP0PWYDj99pVxEdwyPmhccj8a/ib8OraeHP+ CkN20F02bLxpLtjjXDTGY+b5eOowFYnPrXxnEs+TDxf9dD6/g2TXEdCK6pn9uFm/mWlq4XaHtkcL nO3Kg4qaRBJG8Z6OhQ/iMV9BhHzYWMvI8LMI8uLqx7N/mfxGfGWOTw5/wUd1RpAzSRfEWIyM0IjK rLLHEcHp9zJz9frX9rXhlxJ4c8PuMkPodo4JOcgwIetfK5JJSzmt3t+p7rk58EYTym//AEk3K+Tv 239PTU/2ZPilbSy+TF/wj88jS+X5mwiGXZx7uUH419fiFejNeTPkq/8ACf8AXQ//1v0i/wCCFWo3 SfGrxHZTXQCPBK/2fhSxdZwCR16I2Mf0r+tavi+FnG2Iiuk//bYn33GEWqOXy/6dL/0qQV/OX/wc B6LJ/wAK/wDhnryyNJDDq6wyWwkAMbEyx7wvXkMBx6GvbzWPNgpx8mfFRdqtP/FH80fZ/wDwRn1D 7d+x1oKjzdtvrE0SmU5J2jyz+sZP41+lPxRtbq9+HPje2slha6k8M3hgW4x5LMsLNhs8fw1wcOq2 UxS7y/8ASmfR8XK2c1L9o/8ApET+PX/gn4l7oP8AwUlaCd1tZ7fxndxSragSxNi8VGGBwAys30ya /tGAx+dcfD0VHGYru3H/ANuO7iJWyPK0tlGf5o//1/7+KK5zWW6Cigs8B/ae+Kmt/Bb4JeOfiN4d s7O91jw5pUl3ZRagjSWauqM4aRAQWA2/dyM5xkZyPwL/AGDfFFj+3J+1Hr/jD46eH9B8XvaQTarH o93YFNKt3wxg/c5IfaEB/eE8qTgV8txDV561DL6ivTnKN/P3rWPo+GsP7Wviq63pUpSXrZ/lY/f/ AFn9mX9n/X9Hl0LU/hB4Bl02W3a28mPw3bW7xKwx8jqoZSOxB7V/F7+3B+zp4V/Zk/b1tLDwJYy2 vh4XlrqtvZhxLFALi4iEkSEKDt/dsAvO3cQDivRxGHw+Hwy9lFRS2SSS7bIyyWtXq55h+aTfvdde h//Q/us+DF2t98J/h3coAqyeELEbAMeXtgRdv4Yx+FemV52E1w0PRfkj286Vs3xS/wCnk/8A0phR XoR+FHjzWoUUR6il0Cv5PP8Agt3pcNn+098NNXyI5pNKjmm2HHmIjoEb65Zhn/CvCz7TATR1Zd/y M8Kv7/6M/9H+239k2+e//Z9+G0srK0kehiFyvQYdjgfQED8K+Yf+Cl/7M3ws+L37PXjvxlrvhbSE 8b+CtNbxHo3i2G1W31i3e3QAh5hjzBtVBtkyP3aDjAx81llK+S04S25EvwPe4mqSo51isRT+KM5P 7nc/O3/gif8AtSfFPxY+tfBrxx4juvEHhrw9tsPDUeqMtzd2ZVC7COXAYKMHC5K4YjHC7f0I/wCC t/hiPxR+xT8SrZ4FnaxSHUVDdFEUiu+PfaD+VedldSU8FiISekXJfL+mXxVQjHDUJxWtSmpP11T/ AC/pn5f/APBED4IfCnWV8aaxrfgjw5reqaZaBornUdGiu5IZYp4wSSwPJ8yNvqo96/pQXwd4RQRq nhXw4qw/6oLodsBF/u/Jx+Fc/C9OM6FaTWvO18kkd/EkVGjgqPRUYel+40+C/BzElvCfhoksWJOh WpJJ6n7nWr+m6BoejNK2kaNpWlNNxM2m6dDYmXnPzbFGfx9K+tVKPLfsfNUm4zUVsf/S/v4r56/a O/Zw+Hv7SHgHU/CHjPQ9PvL42znQdZmQxXek3GPkYTKN+zPVeR3AyAa86VKNWnKE9jpi5RkpR3TP xp8Ifsxf8FQ/2V9H1m0+DfjfRdX8IWjSzWXhdr218SwMgZmBgt54y4fGcbFTPdR0H03+w5/wUP1X 4h+ItX+Df7T99pvgv4vWU6rpK6hpa+G7bVMLmSFiQqB+VIyoyN3zHovy9T67lWLownK+Gb6LVaO3 yWl7P5H1KoU87c3Qjasord723+bW1/vP2AHPI5HYivze/wCCrOmRaj+xr8S3mlWNNPsvtqKwz5zq QFXHuC1fSVo89Cce6f5Hy+IvTin1X+Z8F/8ABCe9E3hL4gIsaoghYABtzbvPikIPp98n8a/oVrw+ HouNKrHtJ/ofU8UNSeFf/TuP6n//0/7ZP2wbS/vf2aPjJBpsSzXR8EXrrEzbA4WJiwz9BX86X/BC zUIIPjJ4p0+4hdL2a0bCBvkBjgmUtj2+YH/fFfJY1SXJ6r8z6XKUvrNX/C/yZ+6H/BS/TZdU/Yu+ M9vCiNNFosd1H5gyE8uZGZh7hdx/Cvyi/wCCAmq2k+l/FSySWNbiW3jmaEj94wEqAkH0yP0rWv8A DTMsBb21f0/yP6Tq/j0/4KUwvon/AAUcgurVfLlv77TLhZoyY/L3ymCXLeud2fYitat/Yyt2MsIl 9cp+v6o/rW+G8sc/w/8ABUsLboX8LWPlH/ZFvGB+mK7Wqw6fJH0NMSv3015v8z//1P1f/wCC72mp /wALq+D1++0FdAkkXb8rttlh2n6gxtX72fsT37aj+zZ8N7h2kZ/7MKM0g565GPbBFfMVr/XKdvP9 D6vLor+zq/qv1Pqt0WRWjdVdHUo6OoZXBGCCO4PpWXp+g6FpEkkulaLpOmSyjbLJp+nQ2UkoznDF FBP416coaxPKw7t7SJ8l/wDBQGxOo/sifGq2CF2/4RKedVBxkxKZB+qivxD/AOCCl8sfjL4kaYxJ m+w+bsaPyyikdc/VDx7iubHr91Bea/M6MnX+01v8MvyZ/UNRW8lsc0UtT//V/v4r5a/bW099S/Zd +MlskIuHHhCeZYiN2/ZhsY/CvGtrc9ZpWsfzK/8ABFH4G/Dzxz8bPGFz440G18QR6bbtcWdjq8Qn sEcvKVAhPG75cnOeMV/WRbfB74U2cSwWvw48FW8KDCxReGrREHbpsrmo/wAet6r/ANJR2YhL6tRv 2l/6UxzfCH4VuGWT4deCnDtuYP4atHyR9UrW0f4f+B/D1yt5oXhPw/pF0ows+naXDaSDHTlVHSvQ jflPNOvorWnuZzR//9b+/iiucq17hRQEY3P54/8Ag4C0+OX4YfB3UNiefbeJ5rdZX4GyRRuX/vry zX2b/wAEfL+C9/Y90FIkEb2viC6gliByqbFijUj2IjyPrXzudxf1zBPpz/p/wD6Xh9pZfmCe/Iv/ AEr/AIJ+p9FexJPQ8FH/1/7ovjrate/Bj4p2iAF5/AWqRoCcAn7HLgV/JL/wR7vZNH/bUhs08oW+ pzTwOc7mzvmVBjsfvdfWvEx1/qzXmvzPVy1f7cvR/kz+zD/9VVL9PMsb2M5Ie0kQ4HPKEV1w6HFV +18z+KT9nuMaF/wVj1D7IJBCnxmvwpLYkYebKnXoMlya/s1+IdqL3wB45s2BIuvB2p2pAGSRJZTL /WvLoL/hbqtb2j/7ce1jtOF8OpbJ1P0P45v+CSt2dO/4KCaloQcfZF8T3oUscO+yWQRN6c7scetf 2kj+pH5Gij/yNa//AG7+TM6i/wCEXCr/ABfmf//Q/vyuF3W865xuhZcnt8pFfxF/D+4h0r/gqbqg kZgbH4v3xjeQ7Cu1pDn8jmvCzX/kVVvRnrZPG2fUPVfqf26wf6iH5t37pfm/vcDmpa6cG/3MPQ58 ZG+Iml3Pmf8AbJsxqH7LnxzsyqtHL8O78T7yVURiImQ59lDV/NV/wQUntNI/aB8d6VJNulu9Hf7O q5IOfPIDH6AnBrzOKbvKqcV/PH8z1eDPcz6s31pyX4I/rtrlPHdvJd+CPGVpECZLnwpqNugHdntJ VH6mvscld8bhX/fh+aPheJ4/8IePi/8An1U/9JZ//9H4n+P1nqdp8TvF86woy6frM1oY4F/fRSLK QX2/U8mvm/UPOltr66uInuLmdynlyHbFEe7cck9Tj1/Kv9YMk/3Gl/hj+SP4LUrwfrL82clL5On2 cZ8vzJJYyzwR/wB7oR/+v1qhb3TywLBBE9srfK8ZGGX0HFfQpO1zlcm9iZ4XjR98YkZUJjYNg596 5aVZ52aKfzESQbmUEoWweldlJe7YiTaVzYiuI47OSOIRrIgDcINxxTHuEuwi+SluzL80pJbdj27V 12SMW29z/9L8OoUCyXEJZ51dfkEY2sD+vFViBOceVIqRtg54/Ov9mD/PcJVRoyqsRhtoFJZ27xyh /OljVD0Xkt6VrGKsmyHNLQ176b7IskrqZCUBjdFJYsfX8ahjgSSx8+7uHRUBcGUYDZPAFWZttvUq CMSW5KXG6NH3NH90KPas++EEFvcBFJdY/NhwMgtkcH2xmtYRSVyHJJ2P/9P8KbuVJ7CKRYQJmVQq BduCMBqkMdtaWbARO17Io2gDAx3zX+1B/nU5voZBTUNzq0Eht1TcgERXbnrk9Dk00WEpttsQFvM4 3LuH3e5yK2grIj1GfavKtwt0SrghU2of3h6fhTJ7ySJFVI3jBH3mBy+fSqHHcsxeckcUslwCshyI /M3Y9ivalv7mPcqxE8qCQecU4q7sbn//1PwNgsZbmH7VBMA6OVMI6kDuf89qiP2uGYSOfkjOQFb5 Scd6/wBuD/O800mNwwRQCHGHXqOeK1J9HGlRvIzyxylPljA455oMLsoxuUZPtFwPNkQvFEW+cgHG cf57VQu4pZ2aUsrsDwvUCgak1oUWtpraZZdxdWUMw52j2was3JeRUhRSplwScfMvcfSgTbe5/9X8 GPLSxMD+X5oKbZQ3IY+vtWfZMBcSypEig53wE5CfT1r/AG2km1of5zlQTTwXC/KWw29Rjjr9KvXt 693GSsYQYCyKgy3HrWVmtwMtnSMkxpg7drtjB+lRwPJcNumZV8o5j3Zy4Hb601FvYnmV7Ek6h1Ln ajZ6E8/54qG3aYRuqBsHgkdquMbbhzI//9b+e2SHP3h8p+/k9f8AOK1IFVoZYICGhjQNI56MT2x/ npX+3KV3Y/zj5yKaziSFHjdPOVNwA6/T2rR0QyXBzNsiMCk7jhVce59a15FaxondXKF1eQTXxUlo YhKEJfC+aTxx9TVeG3WW4mViPlPyZHPFJwTdzRT08x9yEI8oOVA49Bn1pzWsEllCzTFpYWIfcMBv SnyRuYSdlY//1/58Ef7IJH3CViPkTHyj3rOjnlmlYSRqVQbijDHB71/uAf5w8zLqnH7pWH7wcIP5 VPDbM6NOZEDwEAQMDuce30pcq7EX6EuYmkM8gwAfn9FqhPtNzFEsZIuCSki/dGBk5NMXMr2EKyux jjQEg4G77tTytgokMccckSBX2cAnvQaw3sf/0P5+odRlhMnnC4EkkDIJIjtAyMYPsc8ilsdFElu7 vNG81zDuhhLbmjwSMk9ef6e9f7fcsV0P85zNvvDuqWdq0s9vLtDZBgjMjP8AQfjzU+Z18g3zFikY SMP96MDoBS5FcNhs7QRq9wGwpXIbGSaqMzOuEcB8bhmlKHYlSTdkRJN5DGRvnKkAoep+lIzp9qd9 jpDu3RljkkVna25R/9H+fVI7e6R13Y+XC5PNZeEhV7cHfsbCluK/24P85k03YIGuYrqOZZFW2iOC SuRk54I9+almLyGQRykHO7C9W68UFxdmYdtbS7piqNEXlOVIALn+9iryQDyvKmiKOkhLTE/fHHGP bmg1bS3L9qLYJJH0UcBj2rKuf3DsFIKkZBP8VBm5vof/0v5yFt3nkDk4ZeVQnaMGriWkrSrEhJfg 9flxX+3B/nU5voWbm0kgLGTGGH3R2rMhYnO1WXJ2ncOeM80DU7LUbcxKU8s7nVmBJHBqzHBGwjPl 8oOCuc+lA3NWLh/1kKWgyzg+YDxx7Uk0TIWXHIOWIIyPxoMj/9P+daOGLzAzBi3QA/dFbEtkb2FV HkxzQRkRkARI+MkbsDk8fWv9uD/Oa62MNbiSJljYIrJwSemaQRtJL5hckk5IU421lKLvcG0tC1JC djSRZd1GOaqQo1zIYbpzmGPdA6LgISen86ycUw5knoSHzYvJRmaXacM7nLUmoWaXGm3cyCVm8pxm LhEwpzu45B6Y965sRT/cy9GddCf7+Fu6P//U/jU8YWVpaXQhRWjuGRpJF24MRPPTt1ziuFu1iURs GkJ6NjqexzX3vGr/AOMpzBf9PZ/+lM+ZyZf8JWH/AMMfyILh2ljjWOHARNpcHBPpxV+wtQ0UTRsZ JXO0x4wwOcfrxXyR7NPc9F8FeB7/AMd+I7fwlpul6hd6ndFR5VraSzsuc91Bx0PJ6YPpX0J4k/ZQ +L3hHQ49X1nwH4h0jTrXfI6/2Teyyyon/LTzGgWNRjk5Y8V59XGU6Vb2E93/AJv/ACPWo4GpOhLF 6KEdHf0PNvBWjTL428OwTW1wHtdYjd2kjaMouVwyDHzZBx+J9K/1fv8AgmfOp/ZZ8AF12tLoMFzJ HswFQxoE9+Qo6142ae9mGGX9dD6nIdclxrXdfqf/1fRf+DoGe5c/C+VUjVv+EgvrZ3jmz5at9jaL cvb+MZ/2axP+DX6z/wCJ58TIZQDLHqn2nzn+X5mRVYg99xT68V6fGq/4Q8HF9Uv0Ofw4jfPcfLs5 /nI/qS/4KHTTt+zB8SZ4EfdB4V1W4uJlXKqqWExIz9M1/k9eN7jVrjx7r95f6ve30w1eU3MX2uQq x67RhuACeK9DLFGPDcrLXm/Q83M3UfFcNdOT9T+t/wD4NgLjUtR1DxJf39zPckPIJIGmeeRwuyMM xzwQWA57Adq/q0/4KF+Vcfsr/Eu2mtFu7a28M6lcSCQAlVTT5zjnnBGc+1fMZG3PPXOf86/Q+74q jycOUu/s2f5L/wASTG3iHVrOxtoxPp+qS20zLJmNFMruxXt1JwPpWV8NdRtU+InhaK1meDVItWhu ZEjQh54lYK+X6YAJ4zmvZzZWxVa3dnzHD0m/YW/un//W/qU/4Jl2yQ/sv/Dl5Ybm0lm0OOeVZpjP uVkQo34rjj0xX84v/B0DfRjRfBlq9xI80/iCeYND8jKqLb7c+5O/8BXXwPK8arfWM/zPR8Uf9/pO P88PyP4lNaELTSXZ3ZjO+RNwKgAdBj2r93f+CB1tdR/tf6ckty0H9pabEul2nmBLeNnkgAY4PX5C cfh2rzs+ap4SodPCi5s2pryf5H+kf4tbZ8O9WtJo1aO70Y288boJIztQKzgHsefzr/Lj/bY1+/07 9vL4jSaddz2VunxPnsre1tWaCCJI7hoHAQYx/q8j3Netl8FLIqtRbo48S2s9pxj3/U/0R/8Agl1Z SWH7LXge6EtzPNfactxBFdMfMthGqRKvPqEH5V/Ov/wc+m2tNL8BajNbWrXra/fQ3JyqXMSkW+0g gZBB3kf/AF65eB37anUcv5ZfmheJzUMbSa/nj+R//9f+P+RVjuJzDJL9llUMhlJLMTyevP8A+uv3 F/4ICW0zftjaGlpqZkhEZtGt8sskLTSxkBh3GVBH1rlzdOGHqf11Pc4Zp8+a0+Xs/wD0ln+k14wk ay+GeuxxMJZYtAkjTzRgncMYH51/lMf8FNmWX9r746SOk0yXXxBvlEgk2QoLZvLckDrn5TzXp5br k0vl+TPn89Vs5j/29+Z8CqqG388Yk8sedGqtt8tl5Ug9iOufav8ARr/4N1TPcfsp6LqtzExRpRY2 6mQk/LuLsR9NpH1A9K+TzS/tqP8AiPq+G5JU8Qv+nf6nqX/Bfy6t7b9ljXL64V3MumpDb3a2waWx kEoMeyTGQWbjIPAzX8oH/BDjVb7Wf2yNM0pNS1C7tZZEY20srRRXAVg0jMC2F2tt4HXj0r6bPJOn wvTnHf8A+2PGyB/8ZPVhPb/gH//Q/tl8XvHB8L9cimjWSKTw3IVg42SkJ8oOfXp+Nfy+/wDBJI2+ oftt/tG3k9lZR3Unii8f7HgRwpi+lyFA44JBH0rhlDmyCT80fR5fJw4hk/7sv1P6CP28fs9t+zZ8 R72SH99Z+E9SaGSFeY2WxlKqMc9QMGv80/8AZX1bxHq37Y/hDT/7TuxbS+JnuJo0vWaabZI0mxsn I4jxjtwa9h3jwxUtvd/kjzsHFz4qoc3W35n+ol8HrA6X8G/CVhblBbQ6BG9sEIkSRTAvDep55Jr/ AD9P+DhLxDqtr+1hcaLK2onS49HhaDTrWfdHK5jG51HAXcyucnB4ArLhqTjlld9XH89zl4vVs5hF bKT/AA2P5utRcXMzTeQsFw6bFJALxLjAUnvjArPi0prqIQz7WXcGcdeAQQf0Fcs/iZyxa5T/0f5D dSsIbW2tE0+cyMRunQgB09M+3pj0rEMtyqtExZvMPA7j6VzNaWLptMt6daS3NxBFFExmY7IhjBcn sPyr9rf+Can/AAT61X9pvxzYWfjPTdf0bwXqFzbyXuppp433AicZMEzoVRWKbN68jORnBA8nMMQ8 LQlNLXRL7z3MlwDx+NhTfwrmu+yt/SP6zrf/AIInfslaJpWkwTa5q+kpp8YV45LnzxcPjJYsV65/ zivuX9kP9jL4Vfs8Xb3/AMNtd/ticuYDcSsstyIy5JBIOOCBxjtznjG/NWVCMZX2X5H0+DrU6M6k KWz0/T9D2/8Ab7uoR+yz8RortC5tPB+pThliDTMRaSBQPxOa/wAqDxxpkdn4j8RMzJI76m6+YHDn I68djmvoqt3k9OK/m/Q/PcW7ZnKPl+p//9L+SJ0W3m3Ox2k5VhyVz61JdXMM8W0MX2cHIwD9K4ZR sXPuZsdyLcDdvYE4wiklR/hTkIBaQZKk8JjLd6mxolZWOlt4JLm1Fqs0McrsCjSLkcENtP1xiv8A RW/4N79OL/ssWt+iRx+ZqJhlXIzgRRZOOuRsz+Jrxc0X76j/AIj6rh73aGKf90+9P+CgP7Sl7+yx 4KHjYWs95btPHCrq2yFA3Uu/b0HqSBx1HpP7F37THhX9pj4Xab4q0HUYJ72e0W5u7U3iyTWz4AaM oOeGDZBAPsOlfQ4qnCjgqNZ7t2+4ywGGeKw2IqQ3g/w0P//T+3/+Dhnwl8QvEHhTQ28PaXqt1oUF /JdarPZ27AWygAKMgcrkMcnpk14L/wAG4OgS2Xi74hyOt1FrNraW7yrMh8qWKSQiM4PRl2kEY4BF ebms3PJ6FNbJq/3o+gyHBulnGLxMuvNb7mf11fFnQdJ8W+FLzQfEDmO01GB7W4I+ThkIJ9e/Y8ZN fjT4h/4JS/sm+INWvdX1rxDqRvr+5kuibLWWiEWWLHC7yQc56nHpXTRnUjh1CmTOiquIbfQ+n/2b f2W/gP8As2XiSeBteuJYnuY5bhr+7E74Rv4yDkDr2yc9eBj0j9v74sfD6y/Zi+Illf8AiPTjBL4b v2xFOGly1q6qozyNxbHHqelYUsPJ4j3kb5rWc8Hr9ldPI/im/wCCbX/BS7Wv2Sfj0+hatDdSeAfG OvLFcMl0sTWLbzGkoVhtwVPOTyMfUf3HeKPCvwv/AGzfgw5/tL+0dG8T6IrxXdlKs7W7MhOGVT6k 8cEH3xXHCSw2Yc0euq+TR6NOLxGWwqS3h7r8lbT9fu8z/9T5G/4KHf8ABMr4l/C/4rau/wAMdD8Q eJ9EvJWmjaOwulFvhlAyyg7WHQknHB69vOv2R/8AgoX+0t/wTpv9Q8K33g99Q0i5uylxotxeSWN9 BcRjn94Q45jAA+XkeuMDlxVD6zV51tufXzxHsKai3v8A8E9F/ar/AOCxvxT/AGyV8NeANV8HN4Ts tQ1SEyJNrP2oyxxuDjHlJz1ODjr0PGP7X/8Agmzo9vo37M3gW3jhjEcujQylAvyqWjXcg9gcj8K8 jMVavQpdLo3ypQWW4ucVZv8AzR+Dn/Bx9rjQaJ4M0SFzp0d9rrsVSchrlIwqMSmeisx/76FfyGeD 5DF4x8JyWLPbvHrkMYbzWQ3JeRQTJk54A3Z9q9HEq2Hj6Hk4WF6r9f1P9O7/AIJy2pt/2efBcpWQ y3WjwXEspbckm+KPGPpg/nX5M/8ABYm6nvf2gvgHBBBb/brTxS0sG3cCADCuG7YY4/75riw/8I68 VT/fWP/V/tJ+CNvHZ/CLw3bHY4/sKP516I/2dAQPo3H4Cv4VP+C9V4tz+0rJpaxJbvaRNeQrJJuZ woG/Iz3KHA9zXjpWpv0Po5U/3i9T+gj/AIIGWl7F+y9oUt1Fuu9Rke93zSBnWNY0SED0+6557Yr2 j/gttqFjB+yf4ruL2NpRBZKgtVuPKWVgsoDj3UuvA7CssHH3vmzTHxtFPyR/nZeJJLOWa5uY7ci1 gJayCksyngEsP97Jr++n/ggzpgg/Zn0J57aYPLFGsRMhO1RGkpJX0yWIPoawxUbYiB04GH+z1L9j 7m/4KPftK6p+zF8H9b+IWnJ562FrHFbWxuDB5sk7GMA4/wB5fyr+Rv8AZJ/bq/4Xd+3b4a8b/FvU 18ORw3my3a9vwbKRA+0Q7mxgHcc9xgdecerXh/s6a8vzPKotLEvm7P8AI//W/sX1746/Dy0+Ggul 8Tab5X9liN7S3uBNIVKYAXHXr1r8Dv8Agmhr+jeMP2y/jX420C2e5sr7xXcm0vLmLkie7KybCMji MKcZyAfevAnpSPoaKTqs/eX9sy7toPgd8QZ3ZwR4Vvvs5iYh4H8hgG+nOPxr/Lq+NzXEvxW8XyOz TW39vXtvukkZlRVlIAiY84HIyOtXZcgcvvWO9/Zc/ax+KP7LHj608b+AZhqFvazBptAF/Jp6SkAh XEwPBOAG9R2Nfqj8Z/8Agun+0Z8cfhve/D3VPDVn4ZtNZsX0y41K18TyG6gVo2jkZxtAO5GkUFWB 57d1ZWRtGNkf0Pf8EJIorL4HW+uXMcz6pr159u+SJpIkjkSP5g2OAQ5J7da/YX9oTw38PfG3hG50 jx6tudKuJViYXM6xlsZJGDweCfpSoK0WvNmeKja3oj//1/6A7f8AYa/4J+zOuoy+F9Furq5cypNP enKvk5Ksr4XnoMcYr68+Bdt+zv8AAywm0zwn4n0rT7ZJjutYzEq26fdEeQc9+p7fSvBlues4o+Cf +C0v7TPwvs/2XPEWhWGtW2p6pe2q/ZbXqkfz5ZpCDwuSnJ74r/PE1K/8zVboG3a0ka9mCDf5qOvm NtfcOAD29qU1ZfI4nuzLLPaF/tU3yM3Dk8HJwP8ACtRZUMUaortI5O5z90CuCXxM1h8KB38pVkCJ Io+VE3clgOmP8961LO8WR7eQSR213KCUQciI4yRj0FK1jWmz/9D3/wD4Nz9O1FpvEN/cTXEv2+zh nijJPluUuMHGeh64HcV/Vd+0r4tvvBnwp8V+K9LuI7e70XSbi+gSVjGLgpGWI454xng5r4rCL/aJ W6v/ACPoakn7GPkv1P4w/ih/wXu/aN8MeONQ0nwr4S02+ttHvpdNdry7leIlGI4YMAOnXvkdK+Kv 2mP+CuH7U37T3gS/8DeJraz8N6PqE2LubT9WmkeaIBgIEjLMADuJJP4c4I7qsX7bmKoS/d2PWf8A gi5p+o6t+0t4cmtUlaKydptSuZSf38xyNgfpwpJx/wDWr+/XXpGtPh5OsiMJLbQssoHzSsEyoHuT is8HLmxdSPax1YqDjhYP1P8AN1/4KaGTxD+058QtXR2uLYajc+bBcORLbzmcFUjQ/wAJVTn6gV9J /wDBEjS77Uv2nbTVmt4ItGiS3jt7IhVe8lkJTiMDjaY2JPHReuaM092Mvl+ZlgVeSuf/0f7gNZMd j4DktXK2wj00TXBVsKoRMj9cCv59P+CdUyX/AO2H8dtWg/fTzeIZkhkKkptk1G5QlW7jAB/AV8pi LLAp/wBdD6ulB/W2n2/zP2e/bD1CDTPgL4/naKWWU+FNRR5E4YM1u6R4P+8y81/mDfGa30e7+J3j i5u1uhbSa5O+nxyBmkghOMsuP9rdhvavQcU8Lc4kl7Vo/qR/4N3dEWG113UIGn3AQQ2ZuvnlkhEg DSgdApLsBjtX9Lf7aWoBP2cviaYnWISeEbyOB8bHRjGV3K3Y/NxXl5MubF1L/wAzO7NI8uGhbsj/ AC9fjHbtH8QPF6Ibu/ii1+eRVniIkVTIfm3fxcAHA9K0/grDM3j/AMKy24uoZ7fxPZyQNs3b95MZ WMdjzXVmy5aNSxz5UuavTT7o/9L+uT9hvQk0r4B+B1wfOuNBspJcciQm3Rm/HLfoK/nR/wCDjXWW C+GLHegk8kWjR7dlw6S3m7cpHbCKMegNfIZBC2Ah6H0nEj/4UKnqfyAai+q2Gox3NtMAsb/vEUdu 6n1FYcVsi3EtwkYiW5nMpVVwAW649quovfPPj8FxutxXUpltZ5Da2aRoirCQCzNg7mP4iqJu0txb 2IhR5VG5bkDaQMAUR+BkbuxdiW1uIQ9xIwEEglbLlA2CCBX6of8ABKW2TX/2s/DSXOjwXy2s1rNY SGU+XaIGDMzKOvLkgH0HXmvFzh8uXVn2X6HtZPHmzGkvM//T/tv0M28HgOwDRyDzdDQyRxoU5Ze3 41/CR/wUk+HnxD+PX7YXjvTvh94Q1LxdPpXiO70jT9NsLKa5eFg+xpH8tW5G/GT/AA59yPjcFrlq fkvyPpsTFxxjv3f5n54/Eb9hb9pL4SaHNr3xI+EviGz0j7B9sg1L+zWawicsF2SHnYVyD82Dwfcj +rv/AIIC6JNpnwXgsZgzy2dy4vhJ0t1X5k2+hJLA9+BXHmaThSX95fmjvy5WqVPT/M++v+CsusQa N+y94tmntorsaiIrGB7hzmywJmZ0XuegA96/zmbu9tbfVb27smaMLfSNG8sQEnlhyhZ1/wBoAnH+ 1X2FeKWTK54FNP8AtA/uq/4IX6J9g+Bnhxnj83+0NHW7juAAropRN2fTlmHvgV6z/wAFs9RGkfsz 64pu5Ira8lied48q0HkxyMACO/INfLcG004yt3Z7nErfMk+yP//U/m3ntlS51jULebz1e9e4ihl5 mJkyzEnptLEkegNZNnI9xcoFiTzHYK0A9cgHHrXn4uLU5fM9KhG8Ys92+DsyJ8V/Aka21rePF4gt XFvcJmR/38YOPoCa/wBNv9jHR4tE+CHgmGCKCCMaNaxRwQD91CRAjke4yzDnnivgcTG/ENH/AAs+ 2oLk4crX6yR/MR/wcQ+JNTm8U+DtO1OOBtNtAslvJFOEk8vz32oTxyzORz/d/Gv5Ldf+ziSdbmX7 NG5xZTxkNlhg4OfofWvuca/9npryPisGkqsmVrvQhcR2Qup9ziJLi2nt3wVJHUHt15Ffs9/wSA8P avc/tG+F557TT/LLfY2uZLgCc24ZZR8o7gRtgH+8MV8NxTplMm/L80fVcOf8jWn8/wAmf//V/tce I23gho7mf7MBocbtcdXT5Bjn16V/m/8A/BVLxEmtftV+MzeXs95ew3FxFdqWyoYXG9XRevHy89Og r53JY2yaT7QietnEr5k1/ef5n5aX97NdmONFa5VDs8y6cllBPOPT6VUUveyXMENu8MenoN0kilFc kfwk8HGQOPWvNqdDSjtYuw2ZnNnctdSafe2LrcLLbP5ZnC87S3oeOPau11bx1qeoaNb6Pql61xCL oPFIy75wdhQZPJ6E1FTWCNI/xDm7aCCRpiHfyofvTSLsJwMnI9Pevsj9kv8AZS8WftB/Erw/pOo6 Fr8HgNryG71W906Dybme1WQbwJGBULIDtGOefYkeViZKMoX7nuYSm5UpvpY//9b9Zfh9/wAEUP2V f+EO0q8l1vWdIuJIAzC7miKOQoJcs6ccg454A9K+m/2fP+CeXwf+CfjbT/E3gjxOmsi2ufKjtbu7 imtY3HDOxVRnvwxIGemRkfnmL0wCl5n2+EXNjbH6b/EuKHTvhhrME+8jTtJcP5Y80MFibJIIxjAr /NM/bcuLaT9oL4sQwWrSaKmuj+y45Y1WOMKNzDA4PzjcPpX1OXRvlLkjzMb7uOij4YOp3ctxM8kM K225VU242ybj8uNoGMe9fuX/AMEfPD6eIP2g/CGmzyeZb2l9FfXF0WEktvEAzMn0Zlx+C18XxdZZ bNecf/SkfVcLRvmcPR/kz+9LxTDBZfDu6uWMiQpoxYxqSnk7YyV/HC/nX+cX/wAFINfiH7Ufj24L N5kE7WEMYhMQiDy+aOvUEk5r6zI48uSr/DE+YzZ/8Kkl/ef6n//X/mp1nUv7QuvMWCOF2YB8Nw+O C349cVLHFdNbxQxPGILmZYJiGC/IWAYZ7ZzivjcVFqL9D7LDSXMl5n93P/BCjRZdD+BOiXl1ZRQ3 mrzkNMr+eVt95Ma5z2+QCvqT/gsL4iXTP2bdYmsRu1b7Q1tawPlfNRbeYtjnuduK8Tw8g28Rf/n4 z3ONGva0Y9oI/gDup3n11Li5jax1CRBNcXgmzLdkyksi5P32JJx1BNf3wf8ABHzQ7Sz/AGcPByXG kW2JdOOp3L3qCW5dGbdEzZHJB4/EVlxU5riLCxW3M7/oXkEY/wBk4lta2Vv1Pn3/AILefErUvhx8 J9ZufCkt1ZXiWKwFbWZokiSc7S3Bz1kHA9BX8efw7+L/AMX7/wAc+AY5PHuutZ6nrUMb29xdGMWT yMDhD16cYPv06j6ziBSjw/eL15WeJlMIvNUprTmX3H//0P6sf2FTqF/8EfDFnq889zt8PWoaa8lM jSG4jWRxk+0gz9cV+Tf7bfhHwTZftwfDP+wdD07T9RublZNS1PTbcJPcyfaGGZO5O1Tn2avz/JE/ 9XOafxJK/qfomZwj/bbUNFd2P3m0+2ksvhzbiUxvC2g+SJpEKyRYhAeUjqMZJr/Pg/4KbwWmsftZ ePdStpL3UdNtbeVYLe4QqwjM+5VjzyAcscHnlvSvXy/XK7+R5+Mg1jGj81NJia11G/t7JZXuomgS CG5tHisJo7hxHNtY4JKK+T259jX+gd/wR88MQaD+z54VsUuFuZp9ME5XkxxxBFVVX0BA4+teHnKt isF/j/8AbZHflqaw+K/w/wDt0T44/wCC92oxj4OX1jPPPbSQp9rt7X/VhREgUAeuS4HrxX8Ter6f DHbkSypNPAy4GOCMHn6gY4r6PGQthKVvM+cp/wAaZ//R/mGv7mK2jdHDRmSQKrAfKM+pqSSeG3tU ncyXQEgSWFRyo45z+dfDyj0Z9O9mZlpMI1utQ0/yXmY/ZJXLbZIsHOBnpwe3rV221iW1mu5L6f7R NFGqQokweSJh0PGcge3pXnV000Kh/EVyjZNCc3V1aNdRvObgo3yuSTncPQitf7fBL5tzDbm2+bjI y2B0ye9OK2QKV6pJdXuqIto92sF1LONtsm8wHylzjPXJwDTL+wkimhvUuD5FwmI4SdxTacsCPXmt XBPY2nLoj//S/mFfUhcLHYxtv2y5cg/KO2APWiwa6N69sySSJO+yPdztHr9PrX56opH1BqS2kdkZ hMxwjbhtO7Z69KLmOxuIIZwIhcKNsM84I8rOAT61SXRGMviZbtrfdDHaXFzFI1x+682AFUyTjqar XfhZbIOk1zFPbocW0kcglScjG4EjgYzit4xSsiS1Z/Y5GwY0EvleUw9vamWlteWc11I5it9OiVWi Jk/eOOhGP89666cFsbQ+E//T/Dj4QOqyO1uG3yuqCNlOELFSCvoTg/rX6KfAXRItQ+L/AIDtLmW7 xb6gbueOBMxso2qCzDkHcR07E1+8+GKVLw6zCo+0/wAkfnfFC5+OsHHzif3U/AGwjsfhL4YjQxxQ izFxMWbLFEjRVz74Gfxr+Zf/AIK76hPr/wARLzR9UvnjSO6W7S4W6HmyRiRGW3GRwDjI9NvSvkfB KKlxspduY+p8XJOHDdvQ/nu+Ml3p6+HrmLU4J0vrewnNmLYBhK0ccjRM/sWZQfYfjX4feK1tNYsZ tQKvFfreyb7Dy9kRG5t7OffAwPev2Dx+nbK8JT/vP8mfnXhYl7WtJdkeNOIYbiTyY42U/wAERJji PoM/1rpdLuHkTZFthlLbdp+VZR6fWv5KlpFn69L+JY//1P4sLW5eFBCG2NHy5UYU+xz61uaTcobg TRJC0hXP72TyEX35P6V4ld6MqKbehYi0+/vL+e8u5P3inFrAshMb/wC0B0z/AI12ngNbwa9Z3Nhf yWVzHeK904i3SRhGCMhU9MrnPfHSvMrPSx0QTufWawyOWcES+USImCkYU9wvbPpVSOIhNQmeVnvI VDxWzsAZMnb+HOK86po2zdJvRFC9sJpolabULqLBLLbIw8uTPUEnNXtOl1aGykksmUOswW2iibc0 gGM57A9R+VceLaVM6YRdlc//1f49rDRZhbCS4kEMyv5bQM224VSuQ2OuCKmk0i+s9PnvYJfLjilW 3MxjLufMyAFHrx3rxr2diYLQbpWlxWdyj28xm+0ACSadAkty/XYD0GDnP0rodOgdvEGv2t5qVlpu mJFC11KD5dpMq8P5ZHDkH0460yrG1FcaTENMk8NT208EN600t9bDzHVRlcDtnI/Dmt1YEMNvOrLK JZnlBnK/aUwwILr/AA9eM+lC8gOT1TUvtxZZpZVCzH5CufM7A/14rm7yz+2wSNM7RRxKQSFyoB7/ AKV0rcbVnY//1v4wbiK1a2+2pGksVs7I0RVkSYqcfNjBHTtXG6PdyahfJFaokLG4LooJbbz90ZPI 7U6OjVznjK2ISP0b/Z31C90ZBfpbSQX89kdKaJ7giDY77iSfTJYgevWv0q/ZfuxN8WvA13qXlXSv 4rTSrSOeUR+QLhQWYA8E7lAA9q/tbwzUq3hvUgv5ZL8D+d+IZcnibRk1pzx/M/0Gv2aT5/wk8LgX KmV7GONo43OyCMRKVwfQ7jX84n/BcDSpm13QojpMV6k+oWVnORGWwJw3Lv6cjqelfzh4bRt4pxh2 qP8A9KsftfjgrcMxmv7v5H84eqWssNyYNskCWLiSIwOWUY4xj2xis2eeOX940hk5ALzRkMT6YNf6 G0/gR/HsbtaH/9f8YT58QlnSKIxyqUIkTIwcg4FZtpHHcRXP2AxGflVMg+SEr1A/wr/Vaa90/hyk 3Z2N9bd7sQM87W8UKgFIztjZgMEke+K1bn+1DbGKe5lnWND5BGXMUeOf615WZvlwc5eR9NkF5YuM F5fmjC+DLXvhn9oT4dXVlNLDFB4mtpVuVjyZVklTcGwSBjB496/1QvgteJf/AAm+HdzGwdH8JWaB xyD5cSxn/wBBNf5e8X0lS46rytrJP/0o/wBBPazn4bYajPeNRf8ApLPzS/4LQWFncfspXN7dR7n0 6+uWikB2tGJYAhwfc7D9VFfF/wDwQEvL6PSvilp1wwFsNPjki83i4kk89BnHoERa+PxU2syjF91+ aPJ4O5vqucduT8on/9D+/KdRJBMhAZZIWUgjIYFSMV/Ej8XdPfwt/wAFGNY1e8RIobj4hrcRm3by iiuFgjbj+H5vyFfHcSUnUw0Yr+tD6nhKapcSYepLZc36H9q/hieS58N+Hp5cebNodpNKV5Xc0CFs fjmt2vbwK/2Km3vyr8jzM1SWYYhLbml+bP4l/wBsa4vdF/4KIeIIiZHsV8cWwn8iMsUjiuUJRGxk 8CQ8ddxr+zrwBKk3gfwbJHvCP4U05l8z/WAfZY+vvxXzmTUuTOa79fzPUjFw4NoR6Ko7fczrq+ff 2qdJOtfs+/FHTxIsbSeG3dWcgJ8kkbHOfYGvq8Q+WhOT6JnzFZfupLyP/9H7o/4I2XS6P+17caGW hyRPDII7gYDxSXUO0Dv99z9B71/YhXxPCtmsQ11kn96S/Q+/4sk54HLZP/n1b7m3+oV+D3/Bd/QY L/4CeGtWnR9um6xCDLGPmTdcxqv/AKG1fQZjZYOo32Z8M3y1Kb/vw/8ASkeh/wDBEq++0fsxy2n2 gP8AYtRZTD5mWQNcXLIxX1I6n6V+w/iCCK50HWrecAwzaVcRyA8DBifNcHDy/wCEuC85f+lSPqeM WpZ1Ua/lh/6bifxc/sz3Wo+Gf+CmbwxI6SW3xQ1KG7UEorgG4Cox9DkH8Aa/tajbfGjkY3oGx6ZF cmQK+KxUvOP/ALcdGeT5+Hsqf92f/tp//9L+/iiuc1lugooLPmf9sTw7N4q/Zt+LGh2+1ZLzwtcK JXBKQYU/OR6Div54P+CLJ/sH9oXxRoGoXEMGpTWpR4biUJPuthdRyJEuctuMi59Nor5XiCP+2YSS 6Tj/AOlL/gn2PCMlFZgnu6Ekvul/wD+rev5DP+Cxmiz237aPh3WN13b6XcaXbBtS8km3imil8x0U 46qcnHXr6V6uap/U7R30PHyCfs89wr6c/wCjP//T/t3/AGWdbg8QfAH4Zajb3UV4jeHI4DPEMKxj Zl9euAPzr6Bry8BrgqT/ALsfyR7+f2Wd4tR29pP/ANKYUV6cVaKPEqdAopR6ilsgr+Vn/gu7DAPj r8JJ4xi4PhqSGV1yTGFlgdc9udxx9DXjZ6v9ikn3R05am80wiX/Pz9Gf/9T+zP8AYJ1C51P9ln4Y 3N7g3Y01orhgMB2UjJr039p/TU1f9nr4waa8KTrd+BL+ExyKWTmI8kD06/hXh5dH/hKpr+6vyPc4 sjKGZ41deaR/MJ/wRVlntP2k9X025i2ky5jRHOyJgLou23vxsXPoK/ov/b68N3fiv9kv4y6RY2r3 l3J4XllhgjUs528EjHTAJOfavD4epSnTxdKa/wCXjX4I7OI5e1wWBlfX2S/9Lkfjb/wQ28T2+k+L PiX4I1i8tbHWLiDbZ6Rc3C2+oTsv7yZhExDNjyQOB/CfSv6Vq14cg6UMRSfSo/yia8RJ2wjb/wCX UP1OZ8Z+K9L8DeFtc8Xa05j0vQLB9QvGX7xVcAAe5JA/GvlL9nr9trwN+0L4l1PwxoXhbxHot3p6 iRLq82XVncKSQpLAKyZ2twRnj2OPbq4qNGrCi95Ox5OCwVTFRq1If8u1zP0X/DH/1f7yPiB4xtfh 94M8ReNL6yu9RtPDmmvqdxZWIBu7hI8blTPAOPXj1I618z/s4/ts/C79pHWNU8NeH7XU/DfibS0a VtF16WFLm7VDhjCAcsQATjbnAJ7GuKpJUopPq7Ho4fCzxEKkofZV/uPsivxD/wCCkv7AnhrXbfXv 2oPh5f6povj3w/BHc3+jWcPnWOov5hb7SrA+ZGwcpnbwNxJO0ALwZhSp1sLOE3pa5tl2LqYLGQxE Oj19OqPXP+CcH7a/iv45+F7f4dfEzwbc6P4q8JwLo9l4g0+3uP7O1eCBVSL7QkmTHKqjaSGIOwHA yQv0V/wUL8Iav41/ZL+LGj6HaS3t+uitdi3giM0zRxhhJtUdwGz+Fc+VVniMss1Zx931stH9zOvi 7CfU8VKVN39pFVF6y3X3p/kfj3/wQ41aPQPGfxI8JarqkFpdXmnp/Z+jXk6W1/LKhJkKwthjxGQQ MkFa/parDh+Lgq0Zfzfojs4hd6eEf/Ttfmz/1v7lf2hBEfgf8VEmLLHN4Jv7cleGzJCyL+rCv5qv +CN/gfxJov7QWrateaVfR2sdy9oL0xsIkDpK7oG6EEbSfp7GvmsZFtR06r8z38rny4mpf+V/kz+h j9s/w5eeLP2YfjJoenoZbu78F3ZijVC+/bGxIwO3HPtX4Mf8EM5bPwl8TvHvhi/MOn6xe6Wbc6fM wimYI3VUYgk70wQBkZ6VrXi3Tgl0t+ZngmlXq+j/ACP6h/rX8in/AAVm0DVNO/bh0LxQ9vNHowFq 81y0bCBwsxkJzjHBDd+dprSpG9NonDPlxUX5/qf1Cfs8a1Z6/wDBP4aanY3Ed1by+FbaLzY3DqGj XyyuQT02/wAq9nqqEPcSNMTL97J+bP/X/Wv/AIL9TW9p49+DGoxzObq00ua3nh2nylRpYirE9Mgy A49DX7Sf8E4dbtdd/ZJ+GlzbXtrePDby2119muFn8iRGCujYOQQQcA9sV4VWF8VB/wBdD6XAVOXL 60fNfmz7por03FHjxlyuX9dT54/av0SbxF+zv8WNHgge4lvPCNygjRdxIC5Y/gAa/nP/AOCLesp4 V/aU8W+GtVkWzvtbsJ7O3srk+TKZI/NYqFPJI2EflXHjo3px9V+Z2ZVLlxFV94y/9JZ/VvVPUb+1 0qwvdTvpRBZ6faveXUrdI441LMfyBrZq2hz8zvof/9D+zX4W/ts/CX4s+Prj4eeHbPxTFq0MrxJf XelqukylGIB8wPuUNjjcoIzggc49o+PPh5vFfwY+J/h9I2mk1HwRqMUMced8jrbSOoGOckqMV5vI k7npOTtZn8y//BHp7nwZ+1H4i8N6nG1tPqUr24tbhTA6PGsqnCn0ZtpHriv6w65qFPlr1X5r8kdO InfD0V2T/wDSmRTzw2sE1zcSLFBbxNPPK/CxogLMx9gAT+FfJ/gn9tT4I+P/AIi3Xwy8P3uvy6/b Xb2YupdG2aPM6EqdswcsOVI5UdD6Gu3ll2OFzsz61orSMbIzlK+p/9H+/iisLNFqVmwopDU0lY/A v/gvxbJJ8APhvO4X9344EIfbl03Ju/AHy/0r2v8A4IpapZX/AOyi9vayF5bTxG6TrvDohAOdv45/ SvGzWDeJwf8Aj/8AbWe7kslHBY//AK9r/wBLifsTRXqcjPGP/9L+8b4i2J1LwB41sFjEzXfhW/gW E8eaTaygL+J4/Gv48f8AgmdZXPgX/goNpWl6rayWUk3ia4sGiZ8Lb7GlAJ7MDnaPf6V5GNhfCuLX Vfmejl03HGqS7P8AI/s/Ax+dNlH7uQHpsIPGe1daha1jkqO/Mj+MDwD4bvrL/gqf4g1KO0vILCP4 v3V6XWIqmx5ZHYfQjcR9a/sq1dGu/D+qR4w1zo86bT2LwMMfrXnUY2zWcv8ACeri5KXDtGD/AL5/ Fr+wVbX3gH/gpZDYyrbW1lL8SpbAG5/dSSRtdSsgj9z5f5LX9sIGPzrOlG2ZVpf4fyY6kr5Nhovp zfmf/9P+/cjPB6dx2NfxIeJtDv8ATv8Agql4rktXZYZfi9dw2kyRAAwl5UQ9x91QueteJmsb5TWX kz1smbjnmHm+6/U/th0ssdM04scsbCEsSc5Plrmr9dGFSVKPoY4r/eZ+p4d+0zAlz+z58ZbeRzGk 3w61WIuF3Fc2sgHHfnHFfygf8EL9Wgt/2tfFFqLghdQsFt7eGUjz5Gjjm3ZXqCAzfnXn8RR5stV+ ko/mehwreOdSfVwkvwP7MKydfSR9C1pIgGlfSblIw3CljC4AP44r6nKPdxeH/wAcPzR8bxJHmyfG x/6d1P8A0ln/1Pk79rizvNH+OPjmRINsl7q09yWhcyrDuKF0b0+cnn0NfI9yl/b2ytdOGacl2Ibd 1PXHav8AV7IXzZdRa/kj+SP4EirQk/OX5s5nUTa26JKU3Fj94c4PqagjsUcJdIzK33/kPX2xX08N jBu0kjJkuryOCbzVjwZyEZXJO3sT71XgsIrtxLJdybeCOMEH0rrpLYU9rErxxRylFwEHDN/E1LtB OUT90OE5yw+tdBkf/9X8SQtzEzeXEAeokx1/Gm3FwZFMMcX77b87g8Gv9nYxVtT/AD3OeWWUT7Fh M8mcbHJSNe24n25qyJriFl85kWR22he61ZjL4mLqF1LhI5n2/wB0KOHqWe8mvrW0imUCGDiNV6Nj jJ9+DVxi3uSTNpLpBJeIC0IQRttcOqF+gwO/FZK2iWkMvmzTSMz7wszbtg4wF9B7Vra2hjL4mf/W /Cu2kuJmjjVFdYf9UPTH/wCqm3067dxLR3GNqptwevAx1r/aqKuz/OSbsrFiHWX8u3judwwuGO3J bA4B/wDrVHeakjozpETJEeEGMsPatgjJWszJJlvpI3jtWG3LuvUgDnp7Us0s90AqQbyjYRAu48dK pQdyk09iWfTkmhWSWNonKhZNpICkVmSafLvG3eVPG5uuK1SS2Ku0f//X/At/J0yS1ME8oEsv+mgr uG3gbV549fwrTvPsjxt5EgZG6N3H4V/t0otn+dPNLuUYI5LEp8+ZSdyp1Dj60261zUJXxOWJjXCx PyQoGBWnJEi6Whm3VzHMsMqqRIg5c/e56gelSef5flyxs3H3lJ/n+VDgmJySGvqE8lwocBoQvKMM EH2qGSdnmcwq0ZYAHBJzismmtyOdn//Q/n/W4uXWNWJIDY5OM+5rWENvD+/uCsXAyxOAO2TX+3B/ nE5voZ2pQyC8KbxGYIhhwQVdWw30PUVA0c8SjLsuSHb3Hb8/60mk9w55ES21xJKxnOIvvFV4JAoe JY3jCjCynELE/hTIJBp8krYlYIBySTxUpngtEntraUyxsm0vt2hj649u1AH/0f59rARJI5nl3xlC rCTnr39qlheOC5ESkmG4VmUkYUgetf7dQ+JH+bqkm7FG9mYHbHAQI22jP6fhT/tzRRRByytgs7YA RTngVsWm1sTq0dzYyl4YZX3qS0n3lwf4R/npUxZD+9QsgAwydCmAOBQac6sY0kru5CLiMnlj2rcg t2jgCsSxfgoR0zQZN21Z/9L+feG0RXldiSI/UgIMnpUc0qmXFvEojUDcTzux/Kv9wD/N5NPYoNbz yyRzMkcWCWHOT+FSI7LMVLNg8E9zQYt3dzRtpFRJIpFV0lBjwfeobqURRxW32VQsLF/PiHzHPGDQ LYYshK5QHd69zUMVpLNvZNzPuy3rQdGx/9P+e2OYIjpKPMKtsIBG5frVKSW5gljlsrh4ZkbKSjna fpX+4B/nJdtHXHWNSltI5bm6aSVSN7HhXOOeOnPpWW80EhL3P7xn/wBWDwE+lBnd2sZF8Qy/KD2A A6AUsayPGm+NI5EGzch+8B3PvQODsyFgA7L5e9wfvMp2nFTBRcqVJCPGvKgdPw/Ck0nua30uf//U /nkjt50TKHcSflGcU2O2SSXM77JEOdg53V/t5KHVH+cKdpXH3cKeaojO2JiNyrwHbpzStbwwkskj GUDJAOQtZmxUMzRSiU8sTgegoaZ5WY43KTzQGxQkLCXGSitxt7cVLbRQSyStNIyiFcxgjcrtkce3 GT+FFiXNI//V/nfuTboIpgSzvx8o+QVagbAWUEll44PJr/blK7sz/OSUrbFa/wBzxIFDu0bFwCfm bvirGnxC52wRwqLhhkmT7o45+lauKZKm0rFSaGNjjDKY5jFIHBXJHp7UrB4omkjxhflyRye3FZuL SuVzqxa0G+tLa6zfQtcxN/rETiQLkZ2nscCut8R2XhmJWuvD9zcSRTx+Z9juItstu390nPP19qFG XMnbTqSuVxlzN36dvM//1v51TbGWRJWvY7RFUsYpFOZcD7q471oRzBFRQ4wR8pJ64r/buUban+b5 XmggnkDGMluuT90Ee1NggkWZkGMMMAjqKgCWEAHDbtqn58CrUV3bBmUwoEK8uRhuB1zUTStcNjNi LTI+yKSaHlvOAyqjgdfxqFtWm0u3ng8pJrEqW8mTO1WIwzHHtXLXX7ifo/yOmi39Zhbuj//X/ji+ Jmmzv4sv9e0+VfsF0ypHCrGVYiiDckZ9Oa8ykdsMzR/MG4QjP5197xnH/jKcdd/8vJ/+lM+ZyeSe WYdpW92P5Glbwi8DqhETldsabM4PqfWrsun3OmzpBNvwIFaSVBsIdh0x9Ofxr5dwSR7EHaSP6CP+ DfDw1p/jP9sXRdL13SrOSyeF2AngS98/ysDcd4JDMCw/3SR0PP8AogfGr4F/CPxR8H9b0bU/Behm 3OgS26+Zpkbu4MZjCPx/EDg/Xnvn5GhH2/E9TDT2938Uj7LFzdLg6M/8T+5s/wAtT9oLwhoPgn9r Pxno3ghr3T9D0v4k3UOnWEpLxJGb5xsQ9VRU/g9wK/04/wDgm7AE/Zh+Hggcusmg28crOoGwrFGu FH90bTiunPaUaGeUaMdlf8kTwdUlV4SrVJbux//Q73/g6LNva/8ACv52aIiLXbiS4kizHJKbZ7ST yyp9UmIyO9H/AAbDwy3EXim8gd/MuNVlcxTL8pVkgk3E9fkx0/2jXrcbrlyPA+kf0MvDaPNnWYW7 z/Bs/qR/4KCzwWP7KfxhlkuRGj+CtUjCBMiQtYSpge5LfpX+UL4n0+O68UeI5YzCvn67cXEckQ2u Rux8wPoQQPYV25dG/Dcn/e/RHm5m/wDjKYR/u/qz+tT/AINcfNibx5E0n+kQTzNePs8sSCQ24XDd OCrjHtX9Wv7fbxw/spfF95LlbeY+A9ViklYBlj32EyZwevLV85kcf+Fvl/vr9D7niuVuH6Tf/Pr/ ADP8kr4hebZa1rtpBLZhjqcuLknEj7iCSR3I5xXMeCYfsHjHwteWokkuW8QWcUrLg7kMwZlx6Hb2 9K9jOFbEVbeZ8tw58FGX+H8z/9H+qr/gmpayf8MwfDe7lMm660GJTCwx5KxxxoFx+BwK/mR/4Ofb qxntfB1s0dw3l+I7kmUrsig8pYcjPckSf+O11cB6qb/uy/M7/FKSWLp3/nh+R/FUjq8s+QZbSNzG nmoUd8E5yD17Dmv38/4IC29rqP7ZmhW0UUdyLWyS9gZQRJEUkhmkRvcBWAHv7153Eatgpv0OrhNt ZrBrs/yP9ILx7cwR/D+/nPlweXpAYGcHADrgjj1zX+XF+3PE1x+2v4+unNiXk+LkpMFrKGmTdeM7 E98HkfUYr3csSXDdd+SOHEt/6wU15/qf6Nv/AATTs44f2Vvh8q/aXH9kRMZbkfvsbE6emcGv5lP+ DoNYUsvAymKGWa58U3jxyyf8fDoqWx2kehLj8q8/w/t7Oa/uy/NB4oL/AGuin/PH/wBJP//S/j81 BvtcSrC5WZH2kEbRjoRX7vf8EBLO8T9sbQliazkmVYGeWNArrtmQjfj+IIGzntjNcudvlwtVry/M +i4VX/CpTa6KX/pLP9Ib4gzRW/w78Q3Dt5ix6AJI9i/NJ90cD6mv8nL/AIKGXVxN+1/8cmkkZ1g8 aahIRIwU/v7p3yF/IcdgK9bLFbKZesfyPl89klnME9/e/M+JmiuYrO6igWOKEwlnbPzbf4lX3I4/ Gv8ASQ/4N5LIW37IPhZp0WJgpWONQVMqybT5pHqduM/7Ir5POVavh/8AEfUcOO8cT/h/zOn/AODg /VpbH9jrxRZpNGPPfT4LZJsfLmSVpWUe42j8RX8qv/BBPw5c6l+2TDqG540gg3ebEATG7GKT8CRG f1r6TPUo8L0/X/248XI5OXE9SPb/ACR//9P+1z4iyG3+GGt3DATBfDiqqMu1JdoUYJ7Z9frX8zn/ AASB0q2m/bN/aX1q68uKK08W3bJHC3mgeZfyFUHcgFD+lc8Glw/JvuvyPfwjvn0l/df6n7pf8FEt Qk0z9lT4pXluZPIj8I6k10qJyENnImQPUb849q/zYv2IdOa+/bd8PyQE3Jt/E8093/yy8pCdm5cn k/PXryj/AMYnVl5v8kc2XJS4soR9PzP9Sz4WxLZfCXwyN5SK18OxrKHxmMrbKGGP1r/O8/4OFb6Z /wBshzDdiYy+HrW2iigXCz7iZRuJ5Bwe3ZfeuPh2N8pqz/uo4OL3bPIR/vP8z+ejUZUlnezdAs8L 7ZAo27CO1EUzW6uu/YAuDx1rnqfEcqVoH//U/j3a63Mkexw8n/LRO4qYiCJdnzLIeAXHzKfauew6 WljtvhaIb/4j+C9IuIrg58QW7vKIhJFgSDajDuHOF/Gv9Vr/AIJ3fCbwXpn7PfgW5/4RrTo7hvDd oVY6ckJTMcbB04yOVHTjP414mYR58XRpvZtn2PD65cvxdeO6cfknfZ+Z+HH/AAXt/ad+Lf7Pd14S 0j4TeOdV8NPrV7dw3Nlpt3sYRpLGI5CTnH+tK7e4PPQY63/ggT+0T8Zfjbp+pN8QvFl/r9hpF49q 0t8BNctI7hiu7k4OSQT6EcAKB7GbxVCjRS62/r8BcO1PrWLxMWr8ql+DP3K/4KK3kOlfsq/Fq+P7 4r4L1OyjhZMLI01q8a5ftgsMH3r/ACpvHR3a1rlxbyJLJPq88s+w5EeG2qAPXC816rs8qhb+b9D5 DGv/AIU5Ly/U/9X+QK4kvHugd8gXdllK5QgfyqWOZZZNzSbVjJDpjBPpXM0mtTVLmikEmqoxWCK3 lRkO0s0WFk9Me1Womn82DaCCWweMjFRNah/y8sdlbQXa2oubaJlnN1FE0mN4CGZAxx6AZ57V/pC/ 8EGtHn0f9lHw0zspF9Gk8gADAEWsSSNuHq2T75zXjZik61C/c+qyJ2wuK/wr8zl/+DgbXv7N/ZRv IC7RfaNVto4lLeXvEIlkLBu38Ir8Lf8AggF8VPiLd/G658PR+KdTXw8t3CJNMWcm1XzCqiTyhweF YfVh6CvZz28MhozXdv8AE34Uk55pWw3Rp3XyP//W/sn/AGh/APhPxn8GfElh4r0m01Utpr4+32qT mIlSTwRxxk1/Pj/wRT8N2nhr48/Gq106GJLK21660+GQRi3VIluWWAKg6cI3HavFxkZPLV25kfZZ XL/b6senK/vP3D/bp8Waj4M/Z+8feJtIurizvdE0C91CK8sxiaIpA20A9vmKmv8AOC8Zftx/tUaj rviXVbb4z+NraIapN9kitvEs9t558wkAAHCqOwUcdsCvXp2hliqLe/6Hj1K3s8U49dzk0/bu/bRF ozL8efG4lJwsS+I543fJxhpAwI69awvFH7Yn7UXjiz1fQ/HPxf8AFeu6bd2Y0+TSNR186jY3qMvz biD25HHPqetZ06701Cc/axakrpnzpPfS3UrzmK5V5pQhmtoJJXieMgjZjJGO2K/oP/4JI/8ABWq6 /ZQ1m9+Hnxy8YeIJPhy9ijaYzo+p2GnZdQFYDdImFONvb6AAeXjaSlL3fivueng8SqE/Zz+B7n// 1/6T/gF/wUS/ZG/ax8UDw94E1/Ttc1KSP99Bdac29c5A+WVFcq2DyAe9fB3/AAV4/wCCW9v8cvB9 98UfhHpOnaL4ksLdtUurWysFt01VokfaZFHJfYcA5z8oHPBHm0K7VX2N9f8AM+rzGhJ4eM4bPb5b n8UEXw+8QeFPjt4Q0Hxdpv2SbRvEMcOo2d0dgkHmpGXwMED5WOPcV/pw/sIJEf2cvhybez+yhPDF pLLAFOEby1OPxzk59a4cyg4Y6nTl0Z0ZXeOVYi66H82H/Bx1p2n67rXgOG7mSO/tZJpHmkm8g+SX eRsMeAdyKOM84r+VXwBYSXfxI8GWfkK7NrEQVwPMZXLqoKjvjJPvivTxatQivI87Bte1fr+p/p+f sG6P/ZX7PXgDT4G8u8h8OWSXIc+ZGHa3R3bH+8Tx2r8b/wDgqfcNc/td/AG081t8WpoXWQBVDfb7 cjaO/wAgb/vsVyYZJ0rf1udmKknWP//Q/th+GgtovhfpO/544dGURsIjGoJjBGPxPNfwM/8ABb+a PU/2vtZto/s8ckGnJBdz3zbrdXdhIixkchmVgQeev1ry2vca8j6dte0Xqf07/wDBDjTvJ/ZQ8D3B MKXFxaSRIIT8gEW2Ilu/UECuT/4L5Xljafst6jDeSrHNJm3gjHy7yYZGL+/Ij49M1nhFZv1ZWOle FvJH+fIt2/8Aa5tL0tJJJpsflwybY4WVl5duwPfmv9Dz/gh7pN1pX7M3hpblIAZ4EEUvmb9yR28c fB6d8D6Vz4pXrQOjAy/2eovI5n/gvdqE1h+ylr0UptGthc2scMbDN2XJkYsvsvynBHXHNf57t7rN 5bX1ld6Gb1YjqIMt3aho72MDcFZWHI+YA57CvZqr/Y02fPKdsY4n/9H+fy1/aD+NE1rd6Hc/Fj4k WOk3MYtINKn8WXLWUuz7u6It0ABwOtf1b/8ABudImp6T4qvnubnUJZ9WBtbm/BMkbkRmZ9xJ4wcD 6CvBqaUj38PK1dpn9G37dE1rYfs9/EaeUIhTwnfGKY/cDGEqufYHn8K/y/fiPHOviXxBcXNz9pkv NdupfKIO62/esuCO27bu+jCrfwFc3vnEpcTizh0+1tbed3uizLBa+dqB4Odu0FsDGcVLDo17P5d1 vkkjeN4xp11EbYryAzsCM8DoDUuWiN4u60P9Cz/ghtAf+GZfCl2gmkhi0hLJo/KxHEUUAnJ9MY/G ug/4LQ+ONV+Hf7PHiDX/AA/q1zoOoPaxpZXds5RgzMRIoYcqSo69eRjBwaVD4X6sWKlt6H//0vwY v/jv8bbl5po/it4ytBcXDny7bVpo4yCxwVUsNp4/hAqw3xe+Ok0Dq/xY+ILt5YZkfUpzKfZmGXIO OAeOK+fk9bntS3PNPG3xC8deJ7eTSvGXjnxZ4itpAClnr+q3MkFuEJI+Rzjg84PpXm8UCkpA7s4R A2SMsR2Ofwol8J58laTMm+t1uZxFIGihgO5Y3IkaQjBDfpx3FPtZVdo4nmMcSybDIRn2rge7NrW0 OgjhS3QLb7NokMglZehJPI/OptKs4IGla4u4xvJHnMvzRA/4f0q5rsOOjR//0/tD/g3R0aX/AIRL UrqE3skllcIL1L1VAtnDHjPptaMgD++a/oc/bqkjtf2fPiHcPtEFl4WvZTkhBIXhIwCfTH618XhP 43z/AMj3qj9w/wAwX4oTTN8QfHRzd2k17rkrSGNh5UWTkiM9MYPX6VxZuxaQRQK7SbDjDNub8a9K v/EYsPJKJ++n/BB3TbnVPjjd23mMi/bVu5Nz+YtscttKY7PkA59K/u98cra2/gDVZZZGWHT9L3MI zuZliTcSD/wHiuDAv/banyPSxcv9jpp+Z/mWft/eJbTWP2m/ibcxRXqLD4quEthnavkySyEKUHHA Kmv0q/4IN2VtqPxtluUhlaXSdRZ7WZlzI65QbWzyoVyOf9oVebSXJJen5oyy9pyTP//U/tq+J7W/ /CrPEzTfupU0R3aVTtji8uMvnPp8tfg7/wAEp7ezuvi98V7232XFwmufZvPxvkKC4mk3n8SMfU18 hXlfL0vP/I+yoW+uO/8AW5+rX7fGoJp3wA8ezM7RRL4TvYssmIxIYSEJP1UD/gVf5jXjf7XrHinx Eu0W0lvrd3YI87nywgkY5b0AJP616al/siTOB/7wz+xD/g3s0pf+EEtLx7WOA21mlruyJDOCWdmP scKRX7d/8FCbtLT9mr4m3KSPaJZaBcyrMrhMFIzKRtPBzs4HvXmZK19bqf4mdmatfVYJdkf5pHij xDdarrOv313OLi5uNanKl0UbFV9oGMYGdv612n7OFtf3Pxe8DP51ltXxTbzQWko+WUIwZg59OK6c 6f7ir8znyb/eqa80f//V/sW/ZF0qaw+CXg2OTgwaVFFEF5XbsBAHcjpj2Ar+Uv8A4OQNRvIfHfw9 gtZxGRpMSuZCJFSee4mWI7e4ATJ9Mmvkshl/wn0297H0nEcf+FKtFdJM/lO3XkYnGpS/OXZiOo4J zt9j1xVAanGxEccCtGUOJpPvIfUD/PSqqW57HBFWp2MqAeX5kck880bPvJnk8xif/rdvSnSIpCnY GYHKkjkfSi1osSjqmihJo9tc216NRubvaZ1mhtbY+WCoIyrEc44P1z2r9sP+CM2iWM37VOlQ6VaS LMmqQ3m6VGlEsJtiX3sOy7ckYA5NeBn6k8orqDs7P8j6LIOWOa4dzWnMj//W/tqv79Yfh9NJb/uL i00UMhZN2wKgbP0xzX8/f7G3gxdU/bP+LXi3VYpLuJvE13dRrJHmK4eW5lQ/XgcA8da+MwL5cvin 2X5H1mKV8dJ9m/zP2G/bT8P+HdS/Z58dW03h7Tr17bwzfCGNrWNl3C2copyDnkfpXwf/AMEhfDFt 4V8HappiWgsZ2E9y0IXaWJnYq0nfJXGPy7Vy5h7ypJfzL8zuwCSdT0Zvf8FstZt9M/ZQvnkKwyrr lpPv8veyRp5rSHHfBVTj2r/PL8+bUNRngMayQXsokN4y7CyyS4DEduCD7CvrMVNPKOVHhUo/7fc/ 0CP+CKGkNa/s0+DbuOEqjaS0QZkKOEjwFHuOevtXJ/8ABdjxBaaV+zFrs15aNKrt5UMMeC08jQSR gsP7uGB/Cvm+D37NNPuz1+I7Sl8kf//X/m21d72O7P2WyWO3lhEkohYbYlOAoI9gRWMtgUv1kivh GYkExkYAKDgHAI9+K87F1FKpI9WgrRij6I/ZMtrjXP2ifh7p96I8RanHdu0kReJW85fILkdAWUcd 6/09v2Y3z8J9GsWgSGTT7WOKQW6EI7eWGBQ/QivhZpviCDtoos+0UkuG6i686/I/kO/4OJ77Srj4 ieENGiQvcvFbRIwcuqf6TLJO0i+ylOO2a/l11pdMkxbRtHeRWrlYz1SGQZXjPpX2eKlelFdj4rDp xqMjsEljmt4fM8xXUbMnAj56Y9q/d7/giJpcmoftERSorXEGku9zeI4YyqYymwJ2w2/bXxHFUebL nDzX5o+o4ekoZjGXr+TP/9D+1vxpcrF8O76WVPsyz6OGnjlTL26rFyM9ugNf5nX/AAUb1K01D9qz 4lXyIZDDqNzp8V3HGS8w84yKZOw+UqM+grwMtvDKnH+7E78zfNjnL+8z8+7W1nlnSIjy1c5eYjCj /d/z2rLa78USard6WfsiaNhTEy4R3K4xk/gc15k1fU3pOyJLm3vBNaxSRzsoYO23PloFIPJ6c+la UK2lxfGJkeAwjzlS5G0zKvUqenb+VQ43gbxdqh1XhjWEW/guRZrNBJJJbtFndkbWUGRcZAJx19a/ vH/4IpfCXwNrnwO0bxPqfhnR/PvrJCVjixIogSNVjK/3Q2TXz+ZaSpeq/M+pytJ0ayf8p//R/fr/ AIK5fEe5+C3wA1y+8D6hf+HtXaLyIpLBmtI7WGOLe5Rl5UkFQCuCMcHIzX5I/wDBGj9or42fFjx5 r9v4v+IPiTxFpdpfRrHYajP9pAZ3jwpJ5I2sQMk8sc5wMfnmOTWXJM+6wNvrjZ/Ul+0NdS6V8F/F +oR+fvj8NzSXbIQssamEjPPucY96/wAx/wDavu7vVPjD8Sp7vcUuvErRqsUhWYLzsPB6bTkkd819 Vk8lLJ5qXkeXmUeXMIWPmS0gWFdkYUouEJ6lQK/oE/4IZeF5b348XusvcxLa2MVrIrq6yMyktncv UDDr8vuPeviOLGnhuRdWvzR9Vwx7uM5+yf5M/uN+I/mxfCzxAYiJpIvDstw7YIjOIvTt1yPpX+Zt +3rqV7qX7RvxGkvb1Xu76druKYnf5CxSbTGF7HcGB+tfaZKlHKeXtFHx+aSvmDfds//S/mHjil1N ob3ZPD9mJjaGWIxKxwBuB78dCPWuy0YTx3drHFDHcxtINtuVz5rk/KOeME4BPvXx2YStSbXY+xwC vVin3R/fH/wRF0Bk/Z38P3cl873tvH5Rs1/eRJ5QjX73TgqRkelXv+C4t9d6R+zVf/YZnuNQ/tBW t/KG7yMKC5OPQb/yrzfD61ONVvrNs9fi581eCX8qP4WbieLWPEmmg2wVbHU4Jt8Un3ncr/D6Kze/ Sv8ARU/4Jp6FNp3wJ8Kfao4wX8N2UUYjAO2LylGePUqDjrXncXS/4yHDcv8AMd3DyX9l10+x+S3/ AAX61W1HhiDR90sBupUtLtSeHLzr5LYz2MPftX8o/wAKNJuZvix4F0y4uUuoZPElqhHlZDESKCSR 0+9296+r4olycMyf9x/keVksV/bC/wAS/M//0/62v2O9Pl0n4HeDbCWOGa4sdNjZpo3DggoNih/4 gAuPwr8mf2hDban+3l4I0+5trcT2ksc5eD55FfdcMVPPpEOPVj61+d5BJy4WvLdxR+pZpBRzxpbX Z+5fi26gs/hpqV6ztEsPh6aeEH91v2wM23b7ha/nT/Zl/Zv+Ev7TXx2+IsnxP8G2HiO1k1mZ9Kn1 KwF2qDzHEcMIyOdsaEkn+Ie9eplNRPJ0n2RwY+nbGux0/wDwUk/4Jmfs4eCvh7afEbwf4Ys9D8Q6 JcQW1y1tZJBHfxSHaokVe6lBg57nPY1+hv8AwTH0mDSfgRpMDQravBYWqAlv38UKjCcdtwYn8q87 NEp4jDeUv0ZeDTjQr26x/U/JP/g4Z8Z2lt4f0HRLyxuGN1J+7uoYml/diUorMo7ANlvav43dT1F5 pJJ7W0mu5Zm2oqgiORVP3iexI5xX0eKd8JSXa583Tj+9m2f/1P5jprm6vo0sZ7cQwTXW4274xxwp YkVcUWscEsW3ziqMpVeqNggN+Bwce1fGTWlz6d7Mx7PT4JLaQrIql5C0pZNu8nufyA/CqyaJawzJ eQrB9rZtl1IEJEygYUn/AB9q4a0Niafuu5oamsttmWJAkMsh8nqQVHYeuKzdLW5une3eFwhY71cc kY7fWs7WkkVBK9zZMUCX8bNPcLHMFgSE/vIIiuSSABkZ+vam6hcW8Oo2srLI5UtGEThCuMtlRxgh cc+tbNNbly+Jn//V/ltW0uZjc6i621hHJKwt1gbeY1zxkH1rpwmq6V5MU1vvuZwojYDaEVwGViT0 4I6etfn9uh9QJqELwzSRXEcyJKOJicx7gBu5HvmslbeO/WGGW4kjhgf5mjAO8DjvVRjd2Zja8rG9 eW2g3enW9jDdXCCZjEGmVrWQnOc5zkcg96zbWCOyaLTzKxgD7VdSZB168muiK95Cas7F547eG9ju UhVXdfI3I/38c7mBP0qze2qzoZZ75zHMVSOBflRWU5Iz7/0ropvWxqvh1P/W/D34DyO8UUxuFnji 1mO1mt1G9l3AqGf02hunpX6j/sn22oXvx/8AAMcVtBJaT3clrJJ521JxuT5cHpjHX3r964CvR8Lc fU/uz/I+AztKp4gYWK6NH9yPwsgt7b4X+HY5mgtSlhLLe7QPLhG3IU+wXaK/ks/4KuapZax8YBFc tMrCaSaOa0iKWoWEgRrK3qVGRnrzXzHgRT5+LZT7KX5nueMtTkyFQ80fhD8bpraPwpcarM/+lLdL ZPCctLHEy43eytjGe2TX4leMbe4hacq7Ks5LeacSAkncRnv171+m+P039VwcOnM/0PhfClL9+/JH lKAAlP8AV7X3OVAGea6DS9Pa6vbeaLMkEGJPJKZBI9T6V/KsvhZ+tt/vGj//1/4q0ikZ288IuSQF U/6zHQVZjt4rhVDrsUfK4zkH2rwq+xpT6nYz3t7Z2Ni9vECyOsUMqRkyqvqx9B6n2r0LwXq9p9sh he3V5L24zfTQL/pIwp+Zj14wAPqK8usdNNH0rbapDceTcWcs0RtY/J8502PIAMHcvQ9OvtS3moeG Z1ivLj7XHrIdbSK5hiK2NwjEABscbs55/wD1151R2ujqjG2hdl0+SazM8tk0sGwmFgPmkIBzt9xX GadeyWkCjTorqBI52lijuFaAxuD8wORng/yrixPvRUTpirKx/9D+OaWK5/t251+bbDJKvlSbJSxm CjChlPAH09K3ovEdrcW1zpd9b74b5kESygmMSxvuVk9x2/8ArV41tbkw0RzU0N3E8sP7hjG4kt3L M8sKkcj05P8AIV6DpVkvid7Vb6SKO0t41tTbbhEZR/Eqjvu7k9zTNVG8ToP+EWi0mznsdFmt9Lt4 pjcskIWV1k/vccnrio7CCCwaGGSS7vft0peVrlzIzZ5YYPQHoB2zVxj1E48pzni8xQx3clluDs2+ GEoA8QB4x68DFZ6WSy6Y/n6nGPtNn5xj3hVQjPyn0auiC1CXxM//0f4ptaXWtKnvtNkfzLKZfNha KUMrhhxuK9DWB4Rs5H1eS3vYnS3OVX7LJtvN+flA9ASRz14qqa2OGL/2hI+//gGmvJqV7oyZMF9c Qf2VHPIJ72JYgDMFJ6A5IK+3av0o+BllFfePvDFvNosz6jYeIbfUXu5Lg2kSRRyKfLVOMNgMSfcD Ar+2PCaafh7V8lP8D8A4spqPiHh+7nD8z/QV/ZFuLK7+EHh+7iTyY59GtYoNrl1dIlZSB6EcA9+B X4p/8FtrFj4WPiEXH9ns9lFGY7RcXrEzhI5QD2UOoz6qB6V/M/AUnT8Vod/a/qfuPjVBPhHm8on8 uPiM/wBmNtaY3ADhWuF+cSg8hs+/865a61OO6NvYpCqzOuMpGFHy8hm9z6+1f6KU7ezSP43hG0rP sf/S/EjUrbXmtk8m7S6mvZPIgMS8R7Tghx6+9bE2pLpWkG0e0tjOieZI3lAXJwMn5+vOK/1YaV7H 8M0uqJbWK7uUXyY2EE8ccoRx5bx5AJHP+eK+2/2OPg5o/wAcfjN4Y+HGu29hLot7cLDJeX1yYJ4p GwcgrzwuSo5BIGQRwfkeNcU8Bw1jMXDeEG16n6F4b4OOY8YYLAT+GcrP0Sbf4I/pt+Nv/BBH4Fad 8GD4k+CdjqGjfGjw5Ypr+nalHqc08N9cxqsjK8J+QjhvljVOTkHiof2Xv+Cg37W3wM8JaZ8Jfi/+ zp4n8aDwlt0a117TNEvYb2aOLK7tyIY3BwDnavOc8k1/mFxDiMRjM5eauLb129dT+58I8PVy7EZL N8sYyTXr/Sf3kv7Sv7RHx2/bYTQvhZafBbW/h/4Glv8AzNROseHrm+vrzeChaWVlCxBTtOAOgOT3 H6/fsb/sl+Bf2Z/h9pUWi6aIfFOs6RE/iK8BZBIzgSeWUPO5d2CeOeMAAV42HofXMweJnBpJX173 VvyOOlH+w8srwpTTlXtF97Wd9P8AwFfPuf/T/v4r8Yf+Ci//AATj0T4paTdfGn4LaPcab8YNCcXs trps5hTVkQEhokH3ZQQvIOThckBcr4+Pwn1rDuFtUtPXsehg8Q8Li6dddGtVvbr+B4j8BP24P+Cg 3w/8H6X4R+KP7K/ijx5PpCLptp4o/wCEf1C11KeGFVjRplgjKPnaTvIBOfwHt1z/AMFD/wBqu70v Uk0z9kDxPb6srGGymm0TUmghJ43tGfmYr16Yr5Ghn+YUcSsAqN4JWTs726dbbH2mJyHAYtyxXtrS lq0tr9e7+R5x+yZ+yZrnx7+LGrfG39pfwR9mv7W5bU7Cwv8AR20+S5uBNuG7OMYL7gev7tsY/h/d y0s7awtoLOzhW3traJYIII/uRIowqr7AV7eRYecXUxVZNSk3v23/AD/I8bOK0aOFo5VQknCCb06t vS/nypeerLNfl/8A8FBvFH7VGo+GtQ+HPwI8AX2qaZrVmsWqavYWYvL+9jOTJFGx+WMHCjPU5IyO SvtYyNSWFnGlu1Y8CjGnUqxp1WlF73P/1Por4PfsN/8ABQL4O/FrTfix4D8CfEHRtas9Z/tiAwwI 8ErS8TLLtOGRgWDKwxhuucGv66f2bPGHxc8X/DzT7n40eGB4b8aW48i+WK3+zQ3hXjfszhWxgkDj JOAOg+QyLB4nBVZqpFqMv0P03iHE5VjOHMPCE4uvSslaW6eklbr0flbe17/Qtfmf/wAFRv2eviD+ 0V8BYPCXw80g63qUGtRXdzZxybJwkckcisi455Qg+mR0619BiqLrUJUn1PzyEIzrU4y25o/g0zn/ APgl1+z18Sf2evhrqPhv4g6BLolxLCqqs+3zZXE7uvAPOFkIJ9FX3A/UW/tvtthe2e4L9rtJLbce i+YjJn9a5Mqw1TCYRUam6cvxbf6n0HFNfC4jNZVcLLmjywTejV1FLTy0++5/Njo3/BPv9orRP21p /i3D4aE+jP44fV7nUY5Uaxmi2ldxPGARjB55POMnH9KNosq2tssyKkywIsqIdyKwUbgD6A5H4Vjl mEqYavWTWjtbz3FmWKoVciy7CU5Jzpqakl0vy2v9zP/V/v4orOMdNTWejQUVHK72HJ2RBc2tteW8 1peQQ3VrcRmGe2uIxNBMrDBVlPBB9DX4p/tY/wDBOTx0nxQ0z43fsf3On+BfFhmV9R0/TLoaA9tK CN0kbAbWjkUYKkZG0D+6R5ea4BY3D8iXvxd0exkmPWAx8a02+TZ2/D8bHsPwsuf+Cjum6ppGm/Ei DSdU0xGihvdRtYrMvKBw5d8Zycctx17Dp9ZfHL9lT4YftBeAdR8M+PfDuk3viG7051svFNxaLcap pd24D+ZHL94KJAp+Ug/KCORUYShi5xlTx+qVrbX0vd3+78fM681rZXRxFHE5Lo7uT30d9NHt10Vt LdLH/9b+nn9jH9nP9rr9mnxtceGdV1pNc+DxvJYxpdxqy3FnFHuAjmtomJMb7QBkbQR1HQr+v9eR gKFfDU5Uqu19PQ+lz/GYPHYmGJw3xOPvadVt87euyCivWjsj56p0CimlYmTTSRzni4eJT4b1geD/ ALF/wkpsXGj/ANoHFp52Pk3np19ePp1r+db9oL/gml+2j+0X8QH8beNdZ8MX8kmotPDDe+J45UsI iw/dxAj5VAHC/wCAA8rNMNXxNNU6W3X5M9nI62Bw+LjWxra5Wmna/wCH4fM//9f+2/8AZY+GHiX4 O/Bnw14B8VyWcmr6MGST7BIJrdFwiqoYcH7hP4/gPWPiF4bm8YeB/Ffha3kjim1/QrjSo5Js+Whm jKZOPrXm4ShKhhYUJ7pWPYzzF0sfmVfE0fhnJtH45fsY/wDBOH4n/s6fG8fEnV7rRF083jrOllfr cGSAuWxjAJ46EDv0Hb9uZ4IbmGW3uYYri3njMM8E8YlhmRhhldTwQQSCDwa5cBg3hatW6+JpnXnG NoYnDYalR/5dx5fxufi1+0x/wTR8Z3/xr0r43fsqazpfw48QCYXl/FZ3g0H7HOoAYxbRtZHxyp5H Tngj0DR/AX/BUiwtore8+IHgrU3hhFubi81WzEtwB/GxS3B3epzmvLqZbjqGOrYnA6Kdm9Vr9/n+ vdm0swwuKy+lhsbdyhs/w/JL+kc94+/Z7/4KDfFrS08J+PPH3h4eGLqZH1K10fXYrOCdRwySqiK0 q4J+VuCffmv0T/Z++Bnhn4G+BtO8O6TpljDqxgX+2dRgjDT3Ug6jzOpXv7k5PbHoYTCYmVb2+O1a 223+Wmn56mCx9HDYCphMI3eejf8Ad3303266XTP/0P79JYYriKSCeKOaGZDFLDKgkilVhhlZTwQR wQa/HL9pX/gnB4w1j4t2nxh/Zm8QWfw+1uWUXd9aWOot4eayuFIPm2zoON2OgI/ljhxNJ1qEqcd+ h7WVY5YDFqrL4WrM7fS/h5/wU007TktJfiP4Tv7iG3WGO8vNStZblyv8b5hILHuTnNcJ46/Zy/4K DfFvSYfC3xC+ImkN4dlvFl1CDSvEMWnx3KgFcSxwJGJFAJOxuM4PUAj5/EYDNqy9mpLl9df+G8tj p9rlTrKolbW/W33WP0e/Z++B/h74H+A9K8OafaWz6ylqq6zq4iU3V5IBgjzBzt4z7kk+gHukkcc0 ckM0aSxSoY5YpEDxyKwwysp4IIJBBr2suwccDhIYbtv69f8AJeRx5vjJZhiXWltoortFaL07u2l2 z8a/2mf+CbHibVvivYfGD9mTVtN8B689+NUvLa0vToUunXS4JlgcYUoxAO3IK9ACMY7LRvh7/wAF QNNtre3vPiN4M1SS3hEH2u61S2LzAfxuPIyX9TnmuHGYHExxDq4LRvXe339Hr0/4J2zx1DEYGlQx Orjov+A/u/qx/9H+n/4hfs+f8FAvixpdt4W8a/EbwlF4YnnB1e10TVzZfbUxgecixr5ijrsLYJ59 K+/P2d/gR4c+A3gLT/DGl2Vh/axQSa1qtvbqs99LgA5frjgn3JJ9h4uIgnZen5nr4R8taUvJ/kz3 qSNJUeKVEkjkQxyRyKHR1IwVYHggjgg1+PP7T/8AwTY13xN8WtJ+M/7M2tad8M/FUcguNRtrO7Og 2cc6HcJ4fLQ4LEcqBjn0AxdWN4JCw7Srz9P0Pcvg54E/bx0HVNKtvif460HX9BtmiivpxqkM17NG rASMWWMMWK5698dOo+k/jv8As2fDX9oLwJqvhHx14f0m81C8sHhsPEr6fG2saXPt+SaOfG8YZVJA PQccgVpKCcGiKcuWtGTPjv8AYt/Zb/aS/Zj8R33hzV/GVhrXwluLuaSHSZNYOoLDub5ZoYWAaNyo A+UgdAV4BX9NtXXUm0nUl0dok1ZrGVdOef8A1KzlD5Zb2DY9qKUWoKJdd3qt/wBbn//S/bv9pn/g lv8AteftR+MdQ8T+O/iDoM5ncRWa3niDz4LKISeZshiVMIoIBxjPA6AAD3f9iH9hj9r39k/xNbxn xvo914Lmul/tnSofERvbLUIwx3ObV1ADFScEc5A5GAR5VSP76L/roe1hZWwdWPmv1P3DjLlEMgUP t+cL90Hvj2p9d1tLnm9bDXRJEeORFkjkUo8bqGRwRggg8EEdq/IT9rH/AIJw6n4v8daH8XP2Zr7S /ht460y+F7PDpcg8OASrg+bDIgCjJGcHoSQOCNvNiY80F6r8zqwUuStJ90/yZ3+g6f8A8FM9J0my 0u/ufh7rV1Y26xSatdajp/2u/wBoA3SHZgucZJwMmsT4h+BP+Ci/xF8P3XhLVNS8FaTo+rRC21KT QtWtbW7kib76NKiBu3O3Hsa1cbpGcevqf//T/tG/ZX/Zo0T4EeDkXUdPsbvx1qUpudc1kqtzOWwP lWQ5PUE5z3HTpX1iQCCpAIIwQRkEelcMVaVmd0vhZ+Rn7Wn/AAT01/xP4x034tfsvXGm+BPHyXYu dStre/8A+EftnmDBhcRSLwvIHy9iBjjAXqvCx/4KaaFplnp2tx+C9dls4Fge/nk0y7u7wqoXe8ny klsZJI5JPSlTp8tSb81+SLryvCEeyf5sz/HEH/BSXxd4a1Tw8LXwroEerW/2Ka70hdPS9WNmHmAS DeV3LlTtwcMcEV9C/sgfsr2PwJ8IfbvFlnZat8S9YuHutZ1qeOK9ng3OrqkcuCQdy7iQc5PQcgbn MfatFVFJvUzn2P/U/v4oqJJbAFQXLXCW8zWsaTXCxsYYpH8tJGAO0Fu2Tis+V7Afz/ft7fsyftwf tgXsnhabQray8D6ffu+jaek8FvYxvG/7mdpFDO2RuIZsH94QR2HCfsO/si/t/fseeKRDpsAvPB+o XiNrHhw6lFeaDfLu+d3QnCsRkb1wwyDnIBGOKpqU4O2zVvvSO3CTcYVIp7qz+5v80j+jixluZrO2 lvLcWt08KtcW6v5ixOVBZQe4BzVutTk5nax//9X+/dlDAqwDKw2srDIIPUEV+Nn7an/BPO+1jxJo vxr/AGXdPXwl8SNK1U6nfW+h3B092nyXFzAo7E5BjHAJ4G04XgxMXKi0jswr5MQm+36M7j4dfHD/ AIKE+HvDtppvjn4DWvjjUrC1EEuuCzbTbu+KDAkmEUqoXIGWKoATngVteI/2if23dT0G+tNG/Z1t 9B1G5tntotQksru9a1d1wHVGk2HGc88VstjGS1kN/Yy/Y4HhjVNc+MXxn8PQ3vxL8Q6g97B9vjDP phkYs7Jg9yc+nTrtGP1C2qV2FQVxt2kZXHTGK5Ywti3JI7Ks75bGm3or/qfib+3J/wAE9b+TxPpP 7QH7LujNoXxF03WY9T1XTNDYxSSzoxdLqCPkDJ4KqOM+h+X1T4d/tTftsaL4ZsLL4i/sy6p4k1ez tRBca5p9neWEt8ygAPJGEKljjnaBnrgZrOFP/bKjfWw+a+X0odr/AJn/1v6uvEX7Wv7Vdxot5b+H /wBmO/sdZurJ47K71K11C4t7WRwVWRoQq7tpOcFxnGDXDfsa/sT2cviPxB8dPjx4JsJfiPq+tSX1 il5btHLYsx3ZUZ4C8YPXpzkcebjKfPhJ0u6sd2Ck6eYU6q6H66oixosaKERFCKqjCqAMAD6U6rw8 eWnH0FXd60n5n5z/ALeXxL+NNn4P1z4V/CX4Yar4on8XaBJZ3uvQafc38UEUyMjLGIxtDAkHLE/d x3O3+Y/9nH9k/wDbv/Zi+M2nfGDwV8MvF2mX1tqn2llbRpLi3votwEkdzCVJKsgK44PzZBB6YZpS jXwXs5K6uvzOjJqrw+Y+0i7OzP7I/gX8Q/FPxJ8A6X4g8aeDrvwV4kdBDqekzq4h8wICzRb1DbST 0I4x9QPXrqPzra4hzjzoHizjONykV7WW+7iKPlKP5o+ez1c+W4qPenP8mf/X+av24rG78O/tT/Fj w9dJKiw+K7q2IUebCvlFtpDDoGAzXxzc3QVJmMGUddiNKpwuD69q/wBXeGfeyrDz6ckfyR/BTjaE /wDFL82cNqa/ardyylfJ5/dcr+Vc/pv2iOSX9/cCOIZhBPTOc49v8a+op7HDJe8iTyHnmghupDFb XE4U3aIZfKB/vAVaightZWt1kBLuVjYElT2yM/niu2itDOV1qyO6tDDJ5SAkbd7yZzzVGGRtPkbe 48qbqr8nPtXVTXUwTdz/0PxbkuCAhkUCErxgc+1UFgV98sbDceWQda/2gP8APK/vNlZoWbc8G3fE R5g7jP8Ak1nGKR3ZjAJ2VgS5bbjn0q4K7INia2sryJ42gkeUAeSyt5bRNTLrTpre2T91tD/MSVwS B1xWpEpW0RzUNzOZHiV3WJSeVJGSKtQGO8kMVxI/CY8xweCOgrSMbrUwlKzP/9H8Mo4f7NnTyyTu GFJ5yKNU2Mr3DALI2Nzbe+QM1/tfGPKf5vSlbVmBeL5ewQSmZmUfNtwAccikuBcNDFNFGFZSBJnj IHpWkYXFzxNqW3jns7a6FxJbSN8rRqNskTD+YNRpcpZTIUG8SKAcrhjz1rUo1tTu7aOEXGQYdoAU HIZun61j3VzuSARsIg2GfI+YDuMUDu0f/9L8Ew9tcztb28DysnzSmYbQq92B70raZYrdG58xjI8B g8kORED2bHqK/wBv0rKx/nBdoW5guogj/IUQZR92SR2xzWY800gaW6XcWOyMhcEKOBTC7K9vEk5x ziKTneuFOOasqbaS7MDF4Yw4DSBNxccElR3oJbSWpLNa2byl7A3DbXKHzxsOP93161e82KGJh5AX 5PlLDBY9Pyot0JU09D//0/5+pnIfZsflBIHC/Jz7+1SNK01vNFdoJYSvlr37cZ/EfpX+3B/m+V4l liCwsjEScCSQk4XoAK04oyyiB9phZCrSOfnXHTH0/pQTe6dipawyfZ7kTSM8pUxwbWwqjnn8qrWU b2scSsgMMP7uFidzjFBkm1saU08bpsBbeOeOCfasO5EjMSrLnb12BQMcCgub1sf/1P55Y7QtcSGK aTZJCMxSEBNwHJBP+eKu+cEitrJbadpVUs12/MJwcbR796/28gnuf5rjj5kTtNMpk8tMLGONx7fy qcx5gS4Aybn55Y5CH8k4Hy/zrQ059EUo4nVXA4JbgdjTxbzmbfJLuXG6QY/z6UDc1bQrTt5josKF Ig3znHJ9a0I7hvJkiRyGZPLjcjJjOOooM3JvRn//1f57J0lhFtDDmaVkPnMzYL7QMtj156VAJH3q qx/LkB1XhhX+4LTW5/mwm1ojq1stOuLOK7SWdGQkNbuoUEAfnXMTSqLgqFCgnAB6GkItxRhhu3Zd T93NPumeRUwQkkZBMeB+8Hofzq4xursa31HQypBPHNdw7YxICYUONwz04q/d3FtiN9PjdZHJMsWz 5QOMH+dDg1sbn//W/nrSEyyvtQIxJZs8CqTu0cvlG2aRnbapX7qe5/Kv9weV7WP84L20O303S7I6 XNNf3A+0wYkW1B4b0ANctPEss5kQlUz8o6YpqLvYRNJCECsyBsDoeQay/tKeaYg43ueFHRfaiUbA aUlzFHbRI6nzRL8+0A7lx2quJDG7SRKVWQbcNxmpK5nblP/X/nuAluFKRoQ+MBV6ZqsYLmz2zXqM qyHCEfM3B6V/uAf5vle6vI2cQojYIwpxjJrPeVojtySSccc0uVdh3a2LDACLzGIYL271KrqYVIQk MQBt+96ZP+e1JQSYNt7jZ4kwoZsP2HeoreySFHiDPK00hY7uoB7VRLkloz//0P507qICFbaIsPLP y/7PrWjaI0cRjLKMDdu/i9K/2/sr3P8AN8zhcM0pEjFcNwMfNxSxterJcyRT+UG+dX3ZIGMEfjz+ dMCSbUVv/JimiDPavu8xAQ5OCMn9atxq06skrbIQNyoV5GB0H196ANjRzYwA+coDjJBZdzP7CsC7 nkju5VZWjKvnBUhGB6Yzx3oA/9H+e9LZbm3cShE3Rlo5wgcocHGPrwKwHhR5IUOWeH7r8gDsa/3A t0P83XK0rM1zshjQk7iflII4BppdWOEBR8dfWsZRaDmjsV7QyW0uZSCCSCO5qW5t2WJrpgoRycBP 4VHrUNXVh3SdirZSR29mbSBZk3OxeQvlSpIIAHbBz19vSqGtaW11omrma8+xj+z5DCQ2yScgfdBz xnnn1rDExSw00uz/ACOnCv8A2mDfc//S/jF1md7G8ks4nfZFJlBIxby8+me/rXMs6RzNI25yWySO R75r73jFt8UY+/8Az9n/AOlM+VybTKsN/gj+RLLfwxsrW0RgkTB3b87j6j0+lS/2pe6nITdTOzBQ jSN1A7V81a6PXhL37n7m/wDBBf48eB/hL+2v4Qh+IWvadotveEWGjX2ov/Z9rNI6bGjaZvlL4bIy cZwB3r/TW8cy2vin4V3974dnTUoNR0bzbSSymWQTvs+VcgnuQTXylCnUocU+3ktHy2+Wj/FH2lWV PF8IfVovWLkn87v8tT/Os/aM/wCCfXx41H9rnxRrsHg/WJdPvPHFxfRSx2byW21rpnzuA24PGQSM bsHBBx/dz+wWs3gv4F+GfDWtZ0ibTdIhjJvFNvErJEm/BPQZLcH09q34gmq3EcHBXN+HcDLKeGKu HrPV/wCZ/9OD/g578R6B4h1rwLFbazZajDpt5fJeR2F2hu1LtabAFzgsQi8dcKvY1U/4Nhfjv8O9 G8U+LPAut+I9O07xZeSvPb6Vqt2lvelCY4yVUkA5ADErzz7Zr1uOFNZNg4tfCo3M/DarSjm+Om3p OU0vO70/A/rk/b40LV/FH7NvxK0PQdPbV73VfCt9DZm0HniIyWrrHIMdQSV5r/NK8V/sF/tMDXtb Oj/DPxNqUtxdyNZyx2MyraIZC2Jotm4EEkcnv7UqOYUMJw/GE3rKX6IVbKsRjOJnUpLRRt+LP6kf +De34CePf2eV8SQ/Enw3f6SdYE18ftELqlscxYUnHA+ViAST+oH7u/8ABSzxj4a0T9lH4pvq+t6f bR3vgTVzFBPcpCzf6BKUO4nGCQAPcj2rzOH1Ktm0a1NaOSfyPo+Np0sNkEKc5K8advmf5OXjhhrW v3+oSyx3UTXzPCYlK+SUZlBB75HP419H/st/AH4gfF34l+CZ/BuinV7ew8RRb0SOSUxSK6ANIqj7 o3BvbAzwc125/ioYf2+Insr/AI6L8zwuFMPOs6GHjvp+Gr/BH//U/rI/4J8+HtR8HfALwvompvcR 6jZ2pjkiu0I2dAdo7DI6fhX85H/Byl8JfFXizw/4e1m00bULzRNL12e71O5sbYmzKmJWyz9iVjxx S4Irxw+HlKbtdP8AFnqeJFP65iYTp6pSi/ujqfw93WkQzTFopJokSRoTbzqFkQqcfP7/AONfuz/w bxQNYftkqIluJJ1v4lXaMpscHzhn/dGcemfSuTiaVsum33X5o34UVszpL1/Jn+jp8SGik+GGsyvE PLt9FUkSD+6Bjr64r/LA/a61OB/21fieZYYiq/GC7WN45RJKiteuFVADyMr1HqK+gytf8Y3XS8vy PMxbS4hivP8AU/0tP+Cdc0n/AAy38OSxiSO78K2k0G05GPs0QLV/Kf8A8HQupxP4g+GVtHMXtftu pNPFF80qsJbJS5zyMZx/wE15/h5dUqrf8svzQeKU/wDbMO11qQX3o//V/kK0zTnur4adbia6mZys bjBkduwJ9zwPev6ZP+Df79n34oeGPjtZfEzxP4V1LSdNu9SiSzM9mwHkM2DLnHzDaOoyCD14OOHi CrCnhpqb1k0l959hwbQcsz9p9mMZNt+cWl+J/fd4+t0v/h5q9vYtcM1zpf2e3VB+9Ylem3644+lf 5W3/AAU4+Eni34b/ALU3xHude8N3ljY694luZbLUdTV1NxFFM53biNpLAgnuCAOte1leuUzhHdWf 3f8ADnxeeUOfOFW7c34/8MfnDfX6q0CrC1xGJkSaJDsWNCwBkz3K5yBX+lr/AMEBlvL39kbwreyT I4s7S309YQgjAVIVzn6FiPqK+UztpVcNf+Y+i4buqeKt/L+pzX/Bxq8tl+x3ezr5LY1OyhLYDTZd zgAdQOB+VfzV/wDBvFd3S/tZ39mZFdrzUIZJEbHmYHn7DgdBiTnHTIr6TP0/9WKa73/9KR42QPl4 qq/L8j//1v7WfjHdQWfwi10yRtNGulJbhVGQckAnPt/Sv5Zv+CQ/xQ+H2i/tr/tBeEtT8VaZY61f eMr+Sy0me6WCe4WG9lAK7sBshmwASfkPFY0434dlbuvyPewrX9vyit+V/qf0J/t+6Frfi39mb4me G/C0J1DVtd8K6ha6aIYxNl5bORYQO3LleenBr+D/APYt/Yu+NfhT9q/wv4t1rwLrtpFb60RfT3Gk 3EdupkYxkyEoMBQd3PI28gc47q+IhT4XnSb1bf5IrKKCfEdOu9FHqf6LHgEJD8M9MjvIWjkXRmN3 E6bGbNuFPB6HP5Yr/OL/AOC9cyXf7bWueY4jj0fw9DGqydIHWFI4mA7kqVPHfNLh5cuT1U+yPC4v knn9K3WUv8z+fi5uJrq5luLqfzLvJAmRNolxwDVG+adbaMxOks7EMylsYUH5s46cVztJmX2D/9f+ OLzibVZNx3IvATluB2/KtCGOYrbzXgkSd4hOol4baeAT6ZpNJ7kQ2PQPhr4j0Lw/8R/BWqa1cT2l jF4ktXv75EaSC0jjk3FmAyQPfFf6uv8AwTV+Jfg34j/szfD/AFTwr4t0/X400K3inNvcrI6BY1Jy ueDnIIPTH0rwsav9soO3f9D7Ph+aeW4vDrd8r+65/P1/wcA/AD4i/Fzxv4R1fwR4P1bWINNS6ATT dPlvftTfaFcElQQCQOB/sn0q/wD8EDoYvghqniXwJ8SRF4D1nXLoXNrpuvg6ZdO6bBwHwCDmTGP7 p78V6efqVTDYdQ3Vr/IOGZQwmLxKk7c6l+P/AAx+/n/BQvwzrnjr9mb4i+HfDYlu5tV0Cdy9h/pR C+VlCmCQVY456V/lv/GnwbrPgDxdrWhazYXOnahb3UsF5a3lu1rcQlJW2MysAQGDY55yMV6UU3lk Wuj/AOAfH418ubST6r9T/9D+RwspiYbCZH+UEDOPes77M1s4SQ7t3zAgD5frXGn7ljaLtFEse0yj cCdx2YUcipbgSwSIImLbT94DmpfQhu07n0n8F/hr4q+Jl0nh7whpt3rmqzMluwtIvMuITO6rtI6c g9yMAiv9Hj/gjt8PfE/wx/Zs8O+E/FlpJp+oaVYraTJKvzytsUDJ7kADpXiZhUvjKFJd2z67J6co 4CvWe1kv8z5N/wCDi+cJ+yp9lkng3w6xaFFkGG2yRzbsN2PA/Ovwh/4N44Ibn48a/LF9rXU7OC2K JGSGj3TNuDcY5VeAe+K9zP8ATIaUX3f5ojgxpcQ1H5S/9JZ//9H+034zSTXHwr8VZlIJ0Vp3GwNK 3lwMxx7/AC/rX81v/BHP43/DHTP2m/jH4S8R+JdN0nX7/wASz/2dp99IsE90q3U4yFJ+8MjIHvXk 4hSllLUVtJP8GfZZfaOYVl1cWj9u/wDgob4X1rx5+z7458PeE7P7fdXugXcCGyfeZ/NhZVORxgkK M9Pyr/PG8bf8E6v2rp/EWoWWkfC7VJbW6uD9gmNnJFMAWJMhRsdcng47fSvRjWpxytQfxX/yPI+p TrYp1F6H7zf8EsP+CS/g2+0WS8/aM+H7T65KXS4j1vRQYIlDgAZB5JG368+hA9O/4Kpf8EzP2Nvh Z8Kr7x74P0rwr4R1LQoH1aVtKmh02SVY1IZDCp25BX7uOSSOpFeHgvrFatKb2TPYxeFoYaMMP10+ 84n/AIIy/sS/sdfHj4c6hqfiRPDXirxNPqUr38N/FEtzYhMAQqhPQAgZxg4OOnO9/wAFP/8AgjB4 L0PwrP4o/Z98A7bmXUI/9E0VtjXiFQWQoBkHhuRnBKntWdKrOWNn7R6Jv+vwMc2wyo06caGt4p39 Uf/S+CP2av2Z/wBvL9mb4oaD488DeA/Efh0WuporwPHiKeESKWSRWB4fYAemcnkZzX9337NHxG8a /FP4U6TF8YtIhtNQu9MjtNWhmiMaN8nz5Y8A9D7V8zTry+vto+xoSUso5a3xR2P5hv8AgtB+zz+z t8GvH3hn4t+FdZ0XSddu/EyaXNZSahHi9PzTb44QcnZtJZ14AZc/w1/TB/wTw+LHgDxx+zh4KTwj 4u0XWDpnhWyjvWsr6KW4aTyQzhkU5BByMHHStsfOVbG0qzXa/wCKKyytHE5VXUN1/wAD+vkz8RP+ C6n7NHxh/aD17wbdeDfDuoavp+mK5h+ywK7XG51KqxGDnKn1+8O2SPwN+Cv/AATs/av8M/ErQNe1 f4c6sbez1eM2Mr2u+KyYyr80uOAQoIBJA55I6j0cW70YryPGwjtVfr+p/f5+y3cxeCvhF4W0nxXJ Ho15Y6ZELxr0i0TKoMYZvb+XTtX85H/BTb9oT4UXH7dvwWll8baTPoelXGNavIb9Lm30hxdlAH2E 7NpjUndg8VzYf3aR1YiV6jfmf//T/tE+FHjTwr45+EWh3nhfV9L1ewk0MQQPYXaTLK4iG3BUnOSK /jQ/4KqfsO/H34k/tFap8QNF8G3mo+FUvVkvri2QyOVQhR5idT/EMj+EjB67fLv7unZHvOS5/mfv N/wSM8aeDvBXwttfhRrV7Z+H/EWhR/Y7PR7+L7FcksokfYGwWywY574PcGsH/gtZ8J/HHxg/Z916 Lw3p11q1pY2IlhNha/aZi6qSxVRz0B5HrWeHXQrFSfLY/gz8C/AXx98TvHdh4L8L+H9VvPEQlXS9 WsliG8/ZiEBJbG3LDkHBHI7V/oof8Esvg/4r+D/7PfhHwf41sF0/WbLTIAURiwXEfJOeRyMVlXX7 2HqbYOdqM/Q8F/4LafCnxr8VvgBqmk+E9Kl1b7Kx1IJBbmd2EMIZkyOmdnT61/ns6zY3/hTUNe0n VoLzTNTtrgW9zpt3bNbPBKMkDy2AIP3uPbtXqVX/ALKkeG5f7Yz/1P5lDqJkuLeS8giuHVg5d1/d oyjg/Wv64v8Ag3c/aE+DWii+8A6v4k0zQdeiSKSTT9SUWM1zJKzl5ULkZQ/uxgcjHSvCqL3LHsUZ WqM/pk/bc8Oav8QP2fPGnhvwjJHfz67pMtrbvaygsyOASyMAf7vrjn0r+Drxl/wS7/a/v/FmpyaV 8MrnUtFu9WlmMrKBdnceuAckcADjOF7ZxVyso2Gp++fub/wSw/4JO+GfCOkzeIPjp4Es9R8Qyht8 WqabDcvpytIRJGGO4YfYhweeOcciu2/4Kw/slfsafDr4Oax4q8Nab4K8J+LtLVLqOLTGt7C9u5o5 Aro8QG1/k8zdgBvkHPribRlpofSn/BDT9on4Q+IfglZ/DvTvFenw+INIWWzuNNlkW3lfJ3htueeO OOu017X/AMFePgf45+PvwP1Dwh4H05dQuZWWaIQNu83y2jKqD93d8r9TjnkgZNVQ+F+rFiJXku1k f//V+DYP+CTP7ZFzqFjb3/gyTTrG41LYNVvLcbreIHIfP3emBxzz+Nf1J/sHf8EzPg78PfhhE3xa 8BaNq2r3cfmXUuo6fDdCHYgDsJJFYheCcnse2MV85Pax6spW0PyA/wCC4/wH/Yw+HGhWF98PbrwV pfjQ65FZjTtGuoWuHRQRIZLeIZO3DLnpzg9jX8utzcwteSNbIzBRj5lKhVGdox9KTklGxyS+IwL2 6ZrjMduvmPhCc4OPc/560tuPKdYhGrmZs4c8IfUflXI92ap+7dmlG1ykrw3BWQb+Fj5RR2r0X4Z+ APFXxP8AGll4P8N+Hp7+51K5WC0aJjiU7Q3IxwAfl75rSTViIybdmf/W/aP/AIIw/sxePvgN4Itn 8c6JcaHLrcYur+GM482aTYctkBjtWPAyMDI78D9QP24fCPiH4g/Anxv4W8MW/wBputR0aaCGJiQZ CV5z9FDDHqa+Lwv8RrzPWqytBW7H+az8e/gx47+FfjfxDo/jPSL7S7q2v2lZ7tQoYSudhAzkjPHt la+YvOktNQmsblRM6xC5aZcbU3MQB19j+Vd+IdqiM6Emo2R+5H/BE39pH4UfBb9o6x0/x5qq6PF4 mlt7dbme2b7CHLFVR3/gBYr82MdeepH98vinV7Dx78MtXbwTe2Or22raFL/Z7Wr7vNPlOqLjs2QR j1FcGDf+11Pkehipv6pD5n8Nf7T/APwSr/ag8Y/FLxV4o8PeEBq8Wu38tzcNJuRyGkJV9mAwYA+g 4znngfpZ/wAEjP2A/i1+zb47u/EfxA0CFI54WknmtpHd7ckqxBPA6ovy9c9MjOHmnvKS9PzFl9Sz TP/X/ri/aq+PHwu+H3wX8Rz+NPF2l+G0n0S4LWeoXsemzvGtrKTgORk4ViAuScHANfg7/wAEaf2u fgpB8VPH/hrVPEEWnX+sastzpt1qWyB7xJG2rJhsPzsXPGBv+or4yrrgkv66H01GpbFP+u5+6H7e fg3xJ8WfgP4q8L+DpPtf9rWLRJeWxL5STGDgDkdfbPX1r+I/xB/wR2/am1zxZrsumaRdpa3N5JKJ pg0cDea3zEErhuPx56Zr0HJ/Vkjl517Vn9Pn/BKD9m7xb+y/8P7fSPHujeReQW8Nr9ps15RYlVUM g43MQgBIHp3JA6v/AIK1/tT/AAY8Lfs3ePfCt5498O2/iC80s28em3WqxRajKzNskRbbPmMwVZeg wCvJrz8rfLiJvzZ05jUvQivJH+eRdavBrOqO2nNiO9vn8uViAZV3EK57fMFB/Gv1R/4J/fsV/F/4 z+MPDXj7w7olnN4a0zxPHHNcyTFlZbb5pH3AYOQSNo6kqDjJI3zN81OZjlkv38Gj/9D+0r4J6Xce Gfhz4d0a5C293p+mxWs0SKfK3KgTj6EY/Cv5Wv8Ag4H/AGePi541vNM+Idp4bu7/AMK+HbBLvUrv SoXkFrHC/Ls4Hy4Bc5/2vTmvkMu/d4WMV2PbzSbqYucm73bP5CNRspGuHMs7CJ4g8IGW3A9Mnrnr n0xXN3iiIbIsOQMDb0J7Ch7mN/cJrVHaGP7QiRz4DMqtuA/Hv2rWjihYKWxvTv6/hRd2sVHZGJqI knWa2VmQzxNGHiGWUEEZHuK/Yb/gkb8e/AHwB+OnhrUPGxkfT9Wmt7NfElricWzRgwslxkgqMOFO OPnbPSvHzWMqmAqxp7tO3r0PZyqcaePpSnsmrn//0f7Z/Cvizwn4+8J6brXhXWNL1rStR0+MF7K4 juDtKYKuq5A6EEV8/XPhn4JfBHWtS8XajJpnhaa8vWuLjUZ/KsIblyC5JJwcqASeccdK+Koe7g4x 8l+R9VVnfEyl5nTaZ8WvgX8dNNuvCmjeM/D3iWC7iNtPaxahFd+e+DuXYCeQAevoa6Lwf8N/BfwZ tprrRrG20bSpg0ztHGsC7SRuYkD/AGe/p34rKvHm5PVG9Cpy83oz8LP+C6/7S3wfn/Z41XwnH480 l/EN1eZs9Gt9RjbUJ2W3lVUWHO7g8nj19M1/HR+zn+z98T/2iPElp4J8EaTJf3dlBbajrF3OWtYY LcyA4LgEZ2jODjO0jrXu15/7ConlwlbFXP8AQ6/4Jr/B7xJ8G/gnp/hHxCtzDJZWUaWsUqbFUFVD Be+3gEZ6j3r5b/4LVfBz4mfE74DXdr4B0WbWXhuP9JtV/eBkWMcKuMZID9a8jh6Psk/VndmtV1Gv RH//0v52/HWkXnh7xDq3h7XbOTR9U0uRrHUtO/5b28kfEgAHPB44/OvNIZtN1CKaITy24gmGLk5j aMoc5IP0HFeHVlebZ7EOh+vn/BOj9j74x/EP4jaH8R9H8MvceFLS+0+aScJl70Rz+YrYAyMEAnPA yM+o/wBDf4Q2d1pXw80mwuYls9TisEV4kAWMssQRRxx2618w4/8ACyn5H0sqi/sVx/vfofx/f8F/ fhB8QL74j6T4us/DmoNY2FoVvtRt4WuLMQuqoXbA+VgFc57568HH8rOq2sC3U0FrGwWJy8hCGIsc 85XrzX0lV+4j5mn8bLmipd6nqFqttZopeaK2gjjRpGVmIXJAycZwT+Nf1Z/8EUP2RfjD4E8c3nxE 8XaRPp+i6jDBMsltCxEsZAdSMgf7IPqWHuB8pxCnPCJRV/eX5o93KJqGK5n2f5H/0/7SfiOb/Ufh tq1tYxeZqd1oNzawxSYKmYW7GMP9So496/zXf29Phd8UfA/xy8Zp468M6jpMmr373dpcTwMtjcMc LD5cmPmUog56jacjOcfP4GfLl06dlqo69Vbt69fRHXjVzYvmv1Z+f87z20bR3C/volKYhbeFI9D+ tYy3gjliAgkaeYEW5kGU8zjCv/h7V50tEzrproWrjxTOjznUFt1jRVgVLeMbQRwDkepx/k0xr6QT mOe1jUtGDC7H96M88D0xipfwGt/fOn0C2W2ljuor2ytJ7ggzPPyiohywb6jcPxr+/wA/4Im/E34V ap+z5pvhnS/FWmT+JdOR0FhG6R3McbkMhxnkFSnPIyCOor5POnVhicNOHwc1n87Wb9D7PIXRngsZ Cp8fInH5N3t9/wBx/9T9wv8AgtV4C8a/E74Mx+HPB2ha3q7jdFOum2xmmufMXnAH3lBQDj+/zwCR +Rv/AAR38Pt+zr8XrjRvizFq3gS/8UX62+mt4l0yW2sLmSF1ES78EK3MhOTznGeK+BzFf8Jy/rsf ZYGa+uNn9Xn7Scs+vfA7xtHooXUV1Xw3cRo9o3npKslu6Jtx2DMje20V/miftKeGvEGg/GTxrb+I NA1XT7u41mWEvqETRowiVUwmeCPlLHGetexlM+TLpxOPMnzYuLPn+z0CzkneHSoJP7TvLqNWihBl a9kJ2qip6tnHFf0tf8EQPgl458F+P08U654SvdKtb26+0vPdIywyIRsRQvT+IHn0HuB8nxGnUpqP mvzR72Q1lTr8z7P8mf15/GW61BPhV4gFpby3Fze6HdLLDbglwpt3UYUeu4Yr/M//AG0NL1bR/jl8 RW8T6dfWsl74huZ7NdTsmtvskYYAKshGNrdQPVTX12WT5cA4+SPlMfJvGJ+Z/9X+ZY6vI91babdv Nb2ewvbmKLcJOpIJxgdsZNesfC3QNU8S+NvD2k6FouoazPLfRzSxQwN5aJDIjupb+8VDYHc4r4jF tuhK/Y+rwcuWtFeZ/oU/8En/AA3P4J+AtjYXek3Gl3bDfFbz2TWclvE21gChGQSSxbPORXzN/wAF 14fEl98BdWttJ0mS9sLebz7q8tC6uivb/OGA4OScfz71xcHx9hSn/iZ6nEVb2mIj/hR/EboYtLzx HY3UrLptnZX0TXl1IhX7OsbL5hkGMjBHI54zX+jZ/wAE4tU0zV/2bvATaVq9jqhj8KWEl2bO7W6d swx7HyD7H8a87iRc+eYab7ndkVRxy2tHy/U/Gn/gutovibxC7WVh4P1XxB50UCRvYW0krRss27e2 1ST944IGOPav50v2Y/g18Qovj94X1K+8F+J49HTVYGjS606VEsipILvlduAxHfpk9uPp+Ipc+Rcn keblM+XM7+Z//9b+vn9m20tdB+EfhfT57uJbqPS1nmgciOZCIwyx46nuK/GbxvqmgS/8FC9MbUNc soZ7G5TU5TdzqJI/MLgKB1PLnkDGOK/OMovDI3DyP0vG1ObM+Y/enxHosXiXwYdIlcPDfaUIra46 ICUGCCOvFfHv7O37N1n8FPFd9qdrqEEsd/eSXTrPLGs0bHv0Uc4X8vSurL58mWpen5GWJfNiWz1L 9p74QQ/HTwBP4SjvYBcecJ5iJFeOVVYHYSAeRjPrzxU/7NXwhl+DvgaDw3qDWk0nkrE93HJgKoY7 FCk9AMDn0GAOlPEKMp02+jX5o5qc3GE0uqP5m/8Ag4Y1Saz1Tw5NbayyrdlbWEMyvGwV8uh9AQpO f9sV/I9cavLZ3CqBHEhkypzt2HPavXxE70aaPHg/fmz/1/5p9Zns7rS1YpJDctIkiy/dJHXIHof5 GsezW2h+0SRST3U88SmG1yuS4wCq+x56+1fHPZn0UndmfqU4Ecv2WFi9oQ1xvUxqnGSM9PxqKN5Y YHuRDMBLHvSGNSxcnsoPWuWpqooqHxJFqwnhdIrW5uyGkkITeS0dox5PmHt24q1K8yb5LecmeMbR JFwJABjAz2IAFYNNTR0QhpckkwVhlbCzRpv25wVJFYdykl5K8ztPIiIXneMF5AB37+wrWe4prU// 0P5inW3n063soFkiIGZM8SSZ6Bs9McVqWd1b+aunazNdB47ULHdzAyK4AwqZHQgADHpXwkI2Vz6e TsirpOmXxEsU17Lc2q3JeOG46AMT9z6AAVLe23k/a5oI1WEY8uNOcbeoX61ZgZlqi6gJIriMxlED qCdr89OMe1TTWrwwReTHJcNDIqAKw3Y6cnvVwWpEnYuyQ2rSW1vLDO5lbdLICdsYHPHpV9JJDaTW 09rHBpcUjNE82PPJXALdOFOARz26V0QWp0/YP//R/F/9nzTdPu9PS1sbGT7dGokRrYZTUmO52lYn qVVFHH90V+sX7FmlwyfHHwjdu9zKdPukjaBocWsDOkjja3dn8sA/Sv37heLo+D2Lk+sZfmfnOMft PEmjFdGvyP7VPCcFtF8M7G2Ef2TbpL3N2jDAUYLFQfQgD86/jh/4Ke6rd3fxvv7+wNnDoMtwlhca MJfKlkcyTosqZ/vbeVzzg9q+e8AknxFUm+kX+Z6/jTL/AISacf7y/I/Fv9ozU5n8K65BbWEOmwT6 E1gFkPEgbnzix6kHuOgFfih4uub8mbS4J1u7aynHk/Zzs+bavJ5/zmvuPHyon9Up/wCL9D5Hwpg4 06zfl+p5bbrIZZTIrA5w4bqK7zw2WQyqpKoyhUwcZ65/Piv5jnG0Ln609atz/9L+KfV/Mt2V4VZg wwXxudPXFbegC1l+zWN3OsFxqkwt9LMp2mR+S+7P3QACcn0rw6+zNKfU6C8fxDYstkPIMJcW8qQ3 Ec0TR7sbgRkbsAHA9K9h+GVrZaZc2xvCJk3vvmkQS3DF/mK47gent7V5VY66S2PdIrezWUyWxZbI 43qTgg9zjt9Kq6hpdlK3kWDu1vbyK8J2bYgwweB7V5tXc64L3jcttW1jRDZKZGa1imE5gZPN5IwP oDx+VLqUNtd+bds3mPdkyOmBwWPzcfXP51yVEm7M6eVpXR//0/48dRFncWCqk+JZZgkUUnyF8d8+ lU47640+znt7uOOGW3m+QyQh5sFcBgccDtXky+KxnGXusp6XqqpdRzaorxac10sM9y4Dsw9Qn44r tYAZdcTSNJJkFztksr92+xRxbiMbgfUHGM9/SpNoztFI9Cj8Ga7HcwanPOllcCQEWsV0qpqWAV+Y HqBnPv61jxQXVxrQg1Dz9MSxcl3aPEkhPK7c8H0z0raL0sOUuht+No9Lnkt106Vm/wCJcYHbyhG7 M4wxJ7Hk/nXmV9pWnWti9utkn7+2SAPuyi4x8zE9T14963pbin8R/9T+KvxKbrTrtLY26zLsGHE4 Ixj0H4Yrj9PbVTqsVx5EluHnwrK+PMRRyVYcZ/lW0VojgTX1mJ96fsx6zd6n43itFXzLiPTLifTI rkm3aWZCqsFkOMYznnqRjvX6MfDXWDa/Evwjb6jPeC3utcS3JtGAjZycqskvozAAevvX9peDV58D VortP8j+fuO2ocd4efTmgf6DP7DF5a3nwS8KxNG0D2mgW7RwTAE7nLK+SP720MB6EV+Xn/Ba/Rbu 48HrfWyWbeRbR6eYrlQlukIlcuxPcqfKbAr+ZOEZez8VoN/8/v8A26x+/eMVPn4Jf+CL+6zP5HtU gtp9NnLXA8gwxyRTM5j+dQDJtDYIGQwA7Zqg8VndW8eo2qQrNFahcpgbwBwfc1/o3Tj+7R/FDnaV kf/V/FSwur7zIjOlvANPvRdxCOTzftXQgHIHcc1rXl3NrSRzaXpjW2qx3WJ1uyhtLmMHLFARxjnA OQa/1akrM/hKnN8sixaX99NbvNcRNBNFcCBA8YRJQO6gduK+4f2A/EcVt+0/8NrK2uRZ+f4khvr+ 5Mu1UaIoiIP94FxjvmvkeOaSqcL4yElpyM/RvDDEyo8cZfUhvz2+9Nfqf6Smky+fpemzkhjNp8Mp YdG3Rqc/rVg2lqTua2t2b+8YVLfniv8AM2tBc7a6M/rzF1JLFVYv+thVtbZSGS3gRh0ZYVDD8cVP U8iS5jjpzcbx6H//1v7+KK51HmdjZz5XpuJj3NGPc/pRy20QSn1e4tFNxUWkkEZvk1CiqUH1M21e 6P/X/v4oxUOCurGsZu1mFFOSu0S5toMY9fzzRSSSukU5e4gopte8hRk1Fn//0P7+KKBt3YUUWKbv GwUVLW4Rk+ZBRSUEmOUtND//0f7+MUVHJrqa81o3CirStoQ5XCigkKMdqA22P//S/v4oqHBMbdwo pOC57l8z5LeYUY/ShwvLQXM+WwUU+S0WgjJ31P/T/v4oqFBJFubCijksxczCijk9645P3UFFEoXl cOdqNj//1P7+KK4XS5tDuhV5bsKKuVHSxMKqUmwop+y0sLn1TCinCnbRFSqOTuf/1f7+KK5JUrzT Z30KnLSnHuFFdSjokzkcndsKKxqU7x0NaNVRncKKrkY1NrY//9b+/iisHBp3OvnbVgopqDIlNdQo p+zZHOgopqFnqROSZ//X/v4oqZRuJST0QUVPs/MYUUThzFU6ijewUVLg0Vz9kf/Q/v4orn5eZWNV NKXMFFX7Ni51swoqPZS5uY0dRey9mFFSqLVRzK9qvZRg+h//0f7+KK55U242ZtGajU5l2CinGnJJ Iqc05NsKKc6XPHlZFOryVedbhj/CmsMjbkjORkdRwa6sEnGtT9V+aODNXGWDrx/uy/Jn/9LzH/go vpjJ+1X8XImnjWe18a3a3XlgiVjGzRFSPT5QPfFfnlrYeSAxwEYTPmc4r/VzhO8sjwn/AF7h+SP4 PavGp/il+Zxc9vd2sOZMiBY/NYMcGQe1QW0cMz7kOxZYx1XAwfavrqcVex59hLSOVbi4jkMcdnGu Iy2Szt2xWIbSe/u5IoUEstuDMsQfacLySD7CuumrIiorory6lLullOCoAUIOQuOOKbcym9tlYRZ2 DKk/KFNdSVlY54ws9T//0/xAjkna08o8TM+0JnPA9KSaxvVVJrOVlEZw/HJJHTP51/tAf568uty1 DJFbW2xYWjuJSfPlxkZPenoF8p44njR1AkYucM6jritofCjEZHqsEcEssK+cY5tkjgY8s+h+tNTV 5ZkmjkgM6tGdjckxD1qrGD3ZRjSCRlZE2dmY+tMv2AidIiokUEqR/Ea6DmnKzbP/1PwehNxFDFPN fJcMMnyguHt8Hofr1qwt086sblA1vLLvGeAmBgAH0r/bA/zWlK2rK9o8MMjxSFSrNy/UY9a2JrBF iQvMHt5BmPPUDqK3SsrDMd2aFJA8m/n92PaqYUHy2JaRyMDPWmXGVtGWlWR7UxSwKfLmLqrclAOn FVDGbvZInmYjP7xUHzsB1GKDRNNXP//V/Bu601Lj7PPY3ckTONk8EsZSVQB2P+elV7YRw3BXymuf IbBeR9yFuhz61/uAvM/zeujTuHtnAkTlVXZ5PRU/CsWSeNpBG5ygGFBHAqX8SIc3fQviVfs3lx2i uYhhBEAJH56n1qlC8sdzbyG3+SNiX3Lh0PBHHeqM2+rF8u48y4unkEgnl3DAClAO2Kry3Ul0yQiP AiBZc8yOOAT+lAk09j//1vwXhMsenSweVHmR8+a4BdVGflXPTk/pWH9lVQ7FpAxcYGfl4r/bvkdj /NnnkWgBKFjO59mGwOCuKnkQXKLHbtjLDcG6jHBo5GSTwwrHHKMKQg2kcbqzbh/IgEKxllL7txOW qbPYCnl96jb8p/iPSlu1G9NowrD53U5UYFVGDe4276s//9f+fQET7Qo/1Y2oy/LnHFSRvJLLHbtM Yog2TkZ9uK/3AP8ANVSTdiOYi1ZhczeePMy28bFVeOM02QyqQwQrEx+Trt/zihK+hRNhmCnIB6HH WkmR0jLs5jUnDdmb2+lNqzsBH5RWPzD8qHgH1+lRMjEAQuExyXYbsfyq4xW7E3ZH/9D8DrW6szH5 QRDMiYDkDLevP4U9brQ3Ige0NtehSHnRyY5TnglT09Div9x7K9z/ADXWqMbUwr3EUaOSETaQhIVs kde2apyQBbiDdhgCG2/eCUnFWsK+tiSQIt2xtpCYw2PM2lAw9dvb6U6RXnvFkMymKNRlQuHz9c1S VlYYOYDcNLcSgKSF5PC9hxW1AXe2eaExpjEeAAGI9f8AGgtSa0P/0f5+dp3uWBGBg7T1oYRqgIGM dSetf7kH+bvMgDRiNt7Mu0Zye4rOkmt5nxa+aNgHm5PBPqKBqSZKbe6eJpCHWLb1bIyBVIyQw+Ui w7iT8zhPmz70mrqwXXceyw745GDbgvzHqAD6D8KkiYSJ5UhZdp3RuRjNR7PzGf/S/nyt7uS0Y7QM DuQDUF1O98qo8pQK+4KOn4V/uE4tH+bc30KtysYQMnLLwTistoWaQc1JHM1oWE8oZSbJ2nhR1NSR kB3MUbRquNm77hHtQHM9ri3MojkUsyKxUMdxAGDUE0k9tKssXDr8wwBj8Kai2roR/9P+dc3QnQs4 Cyd2xjNRRPtn3KzOVGSTwtf7hcrvY/zYuyQ+VNuMm1STw2cUkS4idUkywcfMecAH+tHK72NFNW1E hkLTTpCscTCPPzLxkcCtKFpWhYuPmAxkDANXyKxXMrXKsTRPdIs0mzafMChtucHNa98qXCPcFkeN SFKu37w5zjA6kDHP4VLg+hHOf//U/nfW5uQptYFymM/L97ApLeIiUkt1655xX+4XLLsf5rlmVdqh XCvhsgnnp0qS3dd3Kgt0BxUtaagtCVYreS4QXClvn+YRnaSOepp826DcsTDymBRlI3LjuKzcOw23 e5Buit0GI8g98dPpXP8AiO4R9NvYZrWV0a3ZYiAQyPjKcehIGfrWOJgvq8/RnThJP6xFvuf/1f4z vGcKC+3eS9vPJkTxEfdYentXMWthEY8vcp5hJyrfKqY6fnX6BxhD/jKMcn/z9n/6Uz5LKJL+ysNb +SP5GHfwTRSB3wFPdTkVcicFY1LKoY7Sufmb6189yq1j1o6NHc6HeX0V5p+oaXef2VqmjXKXdpqc ThZbLYykkE467Rkd+O9f2Uf8Ejv+DgbwD8NvBGjfBz9pGWRZ9HnbRbXxPJdu9lqkcajZNIshyjYB U7cqRtwByB5WIwqqVIVo/FF/hfU9vA41UKdXD1H7kl+KWh+qfij/AILff8E2tQ1ubVJ1nGoibab2 1ghlimKtjcHVyMY5yQMivGv2q/8AgvL+yhL8APGH/CpfEgtdak0C7g0eF23X32lYnSD90jAqBIVf k5IGR6HtoYDC1Mwp1qrdk03fy/R/kY1M4xGIwNWjGWrTitO/+R//1v5K/jJ8Z/EXxk8T3njDxdre o+JNc1DUpdWku9RuJGKPOqgFlJxwqoo6YCgdAK5PwB8QvEnwr8caJ8Q/CGqX2m67p11HmXSpzbny 1cOzbl+bI2joc8D619BnUoZjBxmvdbat5WSsedkkP7LnFUnrGzv53bv95/eH+wZ/wcN/s2ax8DfD /hr496jcWfinSNDFrqd0zyTQXflosZwz9dwz8rHrxgdK+ml/4LO/8E0rqb7VZND5Ui+dJOtn5KnJ IKtH1J+o/E187/Z05YVUJbR0/wAj6OrmsI46VXDu3Nr+Gq+82bL/AILe/wDBPnStO1NtE1Se0ljs nuEjhigtTdkAjYi7txbgda/kF/4Kyf8ABS7UP2rPi1qcfw38X+JbL4X3Ompp9np322QQXkiL5dyo iDBdpIJO8Hj14x9LkFPD5XCpXbXPypR+d7ten5nzXEP1jNXDC1ZXgm5S+5KKd/nt0Pxdtrp2kJnu GlCkcyY/nX7lf8Eff29PgD+yF8SDY/FjRLO607XP9Z4kFu93dWEokztYY4WRWClgf+WK5GOR8/nu ElmFKVCLtdp+ttbHu8LYujgsR7Ssr+60vJvS/wCnzP/X/cLSf+C7v/BP7TrKygtfGQhTyFi327NH bW3yjhvlGPwyPevnz9qP/gtH/wAE8fiV8J/F/h7U/Eema3bjTWuRZy7L+41GTGFWGPBJbggbgACw OeDXRluApYdxhOVkmn9xGe4qtWwzjS1lZr+rH+fz8YNd8La18UviB4k8CQ32m+ENc8UXeoeHNMvY /s8kdlIytC3lnleCcexFfY3/AATW/bWsv2Nv2iPCvxA1XQp9U0F72KHU7u1lZbi2DsYX3AAqRtlJ G7aMgDIzmuXO8NHHwqYam/dk9Pk7o6+HMVLLp0Ktdawik152s/xP7dPiJ/wcD/sU6v8ABvVY7XXJ 7jV7vQSktlZgXDI6jLAx7tw5G3HuOeOf4Bvjf8U7Hxt+0n44+Jui6dJ9iufFb+ItFt9QjeO0ljnl FwisMgnAIzjjk4Nerh+TDZI8Lf33r8kv8zi5q1bPvrLVqaX43uvwP7Yv+CZP/BfP9lXSfgb4X8Cf FqSz8B634a0H7I1vJcvcWW+JxE6o+M5JXO18HHc8mvwv/wCC6X7d/wAGv2zviN4Nufg1q41Wz8Pm 7OqXiRG0itY5pYjGrRsdwz9mBO7BO8deSMOGMMssp1FUlunFed2v+HN+LFPO3RxOi5JKT/7dR//Q /kDh1uHRNb03UkZXmtNRivYoOdl20LiUK4HO3Kgn6e9f3I/8Eyf+Czf7EHhT4N6Hpvjp9O8G+KdG 0FbC5jkgaISNEqh0tWYEg5GdpwfmAycGuDOcBPH4iiov3Yyu/PTQ+iyfHLB0a0L2ckrP0/4c/Si2 /wCC+/7Bb3S6c/iW6lhiwY572HybNhkckgknH07Gv59f+C3/AO3f+xP+0b8PLO9+HCyeKfEaa3Ek N7p1mEjsT8xlIdlDMuSvIG35+vGT9Dl9COETjVd48rT+7/gHzGb+1xEnUpuzun+f6H8mtxNY3uot bWU5n08r5Zk/1UuCOMjHVePbIr+yz/ghz/wWK+EvwA+Dknwf+Narps/g23DPq6khNTgLHy3k2gkO BxnGGAB4ORXz+Y4H63Kkl9l3/R/mellGNjhI1ufaSt8yj/wXZ/4Kxfs+ftGfAyy8CfB/Vb/xBe6t q1rJMLOArBbxxmRh5jPh+GCLkJg7scda/Cj/AIJYfto6H+xN+0Ho3jnxR4dtdR8L3s1vZX18t239 p6aruFaSMHI4yM5wDtAJGcj3M3pxxOUUsBB6pb+bd7fh+J5WS1fque1MfW+Btfdazf4/gf/R/Y/4 of8ABer9ibW/ghqC2PjK2TUdR0xoZLCQv58Uu0/IIwDjkevGc84r+EG8/aA8RSfHbxD8a/hpqs0d 0fH8+oWMmnSyxTrC9wZI04Ab0O/rxmuulTpYbKvqc3eT39LJBRxVb/WX28VaEevd3/yP7UP2Q/8A gvL8BL34L6J4c/aFt7rSPEuj6NFY3xu3Mz6i4jCu4Y4LEkE44/DpX2Z8D/8Ago3+wL8WfHtn4W8B 3Vpb65q86S2s0EKRLJIxJVS/rnPy5z19K4K9BPAtz+FdD6eDcs1/cO7k7/5n7KW0trd+GbqeFXaz bTJD85wxAQ9x+B/Gv80v/guDrFvP+2h8ULa8W7ksbS4h0qCNohucmCIxOrdcKTJ9dxrvyVpZXXa6 2/M+Q4o5lnmGT6OX5H4X3MNuWJUNuBwMjGKxZZUh35CFmPlgMeCPQ1yWtoWn7jR//9L+OUmBnVYk SH5BhVPyjFX3b7S4eWWWaRI/KDyOWJUdKT0RnT7EkNnOksIjeNQGwEkQFHB4wwPY/wBa/aX/AIJU f8FTfEH7FHxT0bRPEsuqj4Y3dyLO70k3bXFrGZCiM8IwThApIjJHA9uOOpRVbRvVWaPeybMI5fX9 pUV4NOMvR2/LR/Kx/XxqX/BdD/gnz4o0fSdR1TVLHULiSBWk0+WFLi9t5CMMVjb5gM+vQda/E7/g pj/wU0+AHiq48K+JP2cVkh8ZaNq8Mo1CCJILWO32l2Ejrhm2SJHgL/eIzxmvQhSp1YylUeiWl/6+ 45frkqOJ9tT2T/zP0a/Yn/4ODP2WdZ+DWi+EfjpeR+FvF2m6MLC7NxbSSaddNEvlSKk2GHOA218d cDnIr+bP/gsF+0t+z9+0X8ZLLXPgdpdlc6fqumSv4j1+OFbeR5FmzbLGoGd2E3Mzf38DNVhqsaeG qU5JbWS/X5bo8fNYPF5nTr0m0k7t/o/XZ9NT/9P+QYyz2LupzJDuwJM5/CpluV3mWTLwBQ2Af3uT 7VzWSVjSKuvmQzK6Ml1G52seEHBAx3FW7eV3bnJ3Y+cjgVE49URLdn6Zf8EwP2vPB/7JfxxfXfil 4VXWvCFzLEE1wILm4t3dlOBBjnb8y5HONvuD/aF4L/4L0/sJ6Fo2myWtxe2cawrvs7OGOKQkqCS1 vu3r+IFYUsHTrYrnm7PT5H0GDx0KeBdCcra/fdH4qf8ABZ//AIKzfBH9sH4YweA/hHHe393ceIYX le7xbQ2EEMRV3cdTkkgDk89sZP5V/wDBLr9urS/2Ifj1b+KPEVqNW8P+KMWmpTRljNamHDoQOh6H APrj6ducKnisJDBUnouvne/6HLkuM/svMqmOtdf5rl/U/9T9Uvjx/wAHCf7IeqfBTUn8MXGoX/iH VPDsqrpmnwxi+SQwsgiMZkBVmJx04zntz/EtbftN+N9L+PY+PPhpb3To4vFjauLawla2vJIzLuYN jqSAA3YnJ9KicKEcA6N7yf5f5nfDHVoZoq8PgWvzuf2Xfst/8HAn7MWofCzwpoHxZbUbbxJFoyWe oQXURj3OiBWy54YNgnA9cV6rqf8AwW7/AGANMnDrZRSyxgiNIrGK5EUfYsxYBR19cVw4ajFRUa3R HpYnHU5V51cO/deo+T/gvR+w5ZeHdVfSVeymt7crFDE8ebiQqNixBDhiSeDnAPU1/H//AMFBf28t f/a6+MniWfS9Y1bw/wDDKF7hdOtpbwz/AG0xSZCgAlBk7ePm2hRz0I7qKp0YScd3p/mefXxNXEYm m76K93+X6nlv7Ev7XnjD9kP4r+G/iFpEt1qHhY3Uf9ueHhO9u72oZS7RnP3iF3DcMA8d8j+zLwF/ wcLfsaeJ/Blk3iO21P7ba2sSXtqbePdI+3BwGfBAPBbA9685YWEsS6r0vv8Al+R6mIx98JDDt+9F 6ej3/HX5n//V/Vg/8F5P2Bp4iLjQGedW+WBYraOInOFzIM/U56e9cJ8Yf+Dgf9kjTPhtrWn+CtO1 efXbyxkg0610aP5Hk2MFHmEjHOAWAOM5wRXKsHhY1vaOWiPbq4n/AGbR6n8YH7Q37QniX9oP4h6h 4+8Y6td6h9rvZ5dO0m7meddJjdlAVWOAchVJwAOBx0A+6P8AgmF/wUt8VfsRfEmGDXZP+Ek+HOs5 N5ph3C9sNhBzExOwcbQN/BCY9MedioqrdJbWt8gybHfUqyi/gldS9H02en49j+pX/iIc/YY1XTLR tRtb2W9S3DPb3Nlvw469cgc54rNj/wCDgb9hMMg/sSeFtxm501FhL+o2rz+dbVXzQS8iKTUZN+Z8 m/t3f8F2vg/4x+B9/o/wJtLm417xHEun6XdC4S2jsZCSGbYHMm5OeCFHzfeGK/ko1f4iaxrWo6tr PiLUH1PVtUke8Z7y4Ms0MrksxVzlgNx4x07VlT0hYucuaTP/1vJP+CVX/BZC1/ZU0Gw8GfFuxvNX 8JQzC1hv7bM8liFOY2aNv4cKE+XGNi44r9r/ABL/AMHCv7El0Z7u58P6hePMjfaHjsk/eED1bcDn 1xXjrY9m/vXPwR+Pn/BYDwtqv7VPhf4r/BTRo9C8H+HXt77UBKS41X96xmYRghQVLEbDnO3qK/bu 1/4OI/2V/Enw1bQ/Emk6q/iCXR/sk2mrpwhknk8rG0A/Jk84ORnI60QaWoqsro/n8+Cn/BR7wJ8L f2vdc+MVp4S0fTfDXiTxBKt1oU6LcSW0dxN527ztu1GXaOVyB0Ir+jbT/wDg49/ZV0rTIkXwvIL+ 2s1hcwahFLA5AAYK6cDPbj8azqa1IsqlPloyRh+Lf+DjX9lDxF4Q1ez/AOEO1Xz57d43gku4ZLfk bfnYnC5zgcd+a/jr/au+POl/tAfGPxb8RtA8N6f4c03UtWkks9Os5luUmwf9bI4UAk8+ucmu1y/c 2PLf8fmZ/9f+Xee7aNmQxBd7bykeMjPJ/rXonw4+IfiP4VeLND8feF9Wex1nSLyI28bybIr1UkV/ LJHIPHb/AAI8Sex305cs2f2A/s7f8HFXwz8MfCjRfDfxR8KWWoa7pdhDbiW31DyYZNq7XUYR2LLg A5ABOenSvYZv+DjX9kXy5Zx4Nu0nYL5sTwmYbzweQmcD1xRPYpSszMuP+Djz9m2PRb+x0/4e32n3 k8MsNtIl3KCwYfJKgWHaFOTyWBGOlfy6/tz/ALZHjH9rT4qa/wCLdSv54vBa3LDRPD9vdsIZo2A+ YkEEjOOTycdhxWRtGV0eZfsm/tU+K/2U/ip4M+IfgqW+WDStZWXW9LMpls7q2yrOr7uwxnvzjpjN f1oeHP8Ag5P/AGdYfCWiWHi3wzdzeIQEh1C1IZXDbPmfIXa/U9OCD9auNoxdiKkm2j//0P0Fl/4O Nv2b50lQfDtGs42LRteXJVAAcLlDEcH8a4n4p/8ABx18Eb74b6tZ+DPh/ex+I9Ts7nTLNbec2ljG piZTN5xA4XP3V+bOBzXzdToegfyF/FX4yeJfjt49vfGvinUo7281e8lvDbyzO8enJM3yAbu4AA6D AGK8yittRtTqf2zUo7ppJcWqQQKkUcak7Rnqe3PtWZjL4mZc0kSxGacbQOXZeo9aqxX+lC5tRcyz rgkjyk3ytwcf5zXOVtA2LDWtMkaeB3WCRWCxhkw0rE4Ar6C/Zz+OviH4BfF/wf8AEjQDbXB8N6gt xf6XebfJ1SHcNyYYEZwW9PrQ27ChvY//0fuv4cf8HJ/wI0nwXp9j4g8EyWWvWCfYZ4kugrSNGASc rGVPXtx781t3n/BzR8DZoLmH/hX2qSqbST90Zo5jI2MLsOOM9OeBmviaS5Z/M9Gcro/mt/4KG/tt 6Z+178UH8U+GPBVh4J0/+w0E8hfz7+eYTvKjNgKvClFwR0ReTivzVDNdQvdRXCStKfKuX/1btjjI 9a663xk0XY29P1GXT5tOvNPvprK/0+6iuEurdgtz+7YNtD9RnHUcg8iv6Zv2Ef8Ag4Q/4UB8M5Ph r8YdL1vxpdeGYy9ldT2hYLbyHEMWUyxC/ON5PcgDjA4sOuXEzfodleXNQjH1Pt5v+Dlj4G3Plzv8 LiLlkMkQjuHUquflLfu8+vAPbtVuT/g5U+AkYeKx+G81zcSqG3wXLQxu4GcZMZbOeOlaYv320Rhm 4H//0vz/AP8Ago9/wUx8YftyeObGPRdG1LwH4D0613XdoNYa6bUX5ZWZSihcEsgwD8oBJzgD85Ph r8QvFXw38VaN488FahqGj+JtI1RbuOVrxvNvNkmCJGz0YD8uOOMfFz1w9v63R7lOdq1z+qv4K/8A ByTb+G/AGjeFvi74EtL/AF+xUWVzfvOVjuoUQBZCFU4Zu4BPOSBjivXD/wAHJnwVVktU+HFleGGA 3OYbw+TFxkIqOi8nvnua62/3VjH/AJeNmff/APBy/wDBi80y7t4vhhDb3z2sgtguq+WysFOBxCRu 4yO1fy4ftcftZeKf2o/ilrXxJ1Tdp+l3k0z6V4fF6NRSBZnZ2V5GHRS3yjHTsMYrlwVoVG33NMXP mpxS8j5IsZQJI5LNxD5PAiQZ8o9c/wA+K/cn/gmR/wAFc7r9ibQpvAvibwdaeJ/Dtnq8+qTaiL1I r4pcBAoEO0n+E5xnHTGDWuM96LRGAlyVEf/T/Ql/+DmD4M3llDeWPgiW2a0ctqFuHMrMvRVV8BFJ 5+9XzR+05/wcM/Cn41/C3xD4C0XwNZy6p4i0e402I6rcGeztfNjeNmmjVMHCsTjIBOB0r5OinGB6 WKd5XP5Ntc1lfFGv3+taez2umT3DpYafFbC1tLaMMcLGnXGe/wDhVXZbw7IJkVZSS/PBfvn/AD61 DVnYTeiRiznyJpLl5JGh6KEXdtx2AHJrZuRBDGm2XMskXmRjGD75HtmkaQd1YzrK9tY3WV7oC5hJ MqRjITIIwT6HJ/Kte2ubu3ntLvR5Ak8F39qjaCUwvC+c7wRxnPODketc9emvZOJ2UaijNM//1OY/ 4J7/APBcvXf2XfDK+Bvij4W1DxWsQig0+/gjSL7THEmz5lVcZwAeOevbgW/+CjP/AAXE/wCGnvBw 8B/CjwQPDk2osTfeKNUuSkmmQlCrrHEACGYtyST9wYXJyPiqa/dKJ785/vWz89f2Iv2+viD+yb8R LbxpdeI7zV9KuNQQ67bMi34u41wxZkIynQoWXJ2t7Cv3l+Lf/ByX8Nte+GeqeHtC8Dy6tr134fnt VlgklhexkaMhC++NcDc3BQ5JHWlZtpPoXCfKmfyjfG346eNPjl8RJ/FnibVpGs7uN722sJ5BdWts 8wBKF2GdyYwDx6CvqX9gn9vqX9jD4h6rrd7oEuuaHqdtbC5sXTe160MoGITtYjahY9h8x4r0Ksn9 X5Tnh/G5j+mOy/4OVv2fodMt/wCzvBot7lrRftMd6bqyFq4ABQFYccHIBDZ4rG8Yf8HH3wI17wr4 h0258HpeldKZ7eyhuZXOpOy7dm5ovlIJGC3r3rmy9ey0RriZ8zP/1fwQ/aM+NU3x++Kni34hReFL fwdeeI9Yk1dY7SJri2tbeWQskAnIUyOONzbRnaOO1eDaOtuLiayn+z5ZuXkIDOSeSM/1r5qpL3mz 2IdD+gf/AIJi/wDBWmz/AGQtJ/4V38UfCkWv+GV1SVtJ1+FlM0MLhTtmxGeBjAAORjvX7P3n/ByD +zfayrDb+A7+eKKVVM9trSpG2eOjIp/AA/WvH/5jHJ/1uerUk/qKh5v9D43/AG2P+C53wO+P/wAF vF3hfw94IsrjxBd2BsYYtVulto4EYhZHExQliqkkKoySowR3/kvvb8Pq+q6zePGY9Z1Np7a2iI/0 SLaqxwqBxhQmc+pNerUleCPIUrTsavgfxRf+GvE1hf2UXnizvUv0WZf3RMcqSBXwM4IUqfY1/Xn+ yX/wXw+BPw8+Glr4c+I/g5tM1uw0+CCWSJltra9kVMERseRtOcgjjj3rwczpxrQguzT/ADX6nqYO ryTbXVWP/9b9Zbn/AIOLf2W7O1ZNQ8N6haSqUNtArpqLzKwA8zCkDGM4z1r8KP8AgqV/wUg+C/7V UGn6b8K/CVyupTSSmTXNVWO2jtYmUEssagkkMCQMjt7mvmMJK2HlHpZHbif46fmfgIrG0tVS5yGX h8MXPB65POP8anit47qKKQhpkZv3HlnLq3ToK5J/CdNN6Ihjsbe9uG0+GIFo2AmjmG5d2c5OR7Z9 sVAmkRGfU7u/mn+0WwCWjBAYyAQGG70AGR6/lSXwFr4ixCrF4irtGw5EhTJ29159cYr7n/Yp/bD1 z9jz4q+HPFmmy3Wo+H5tQUa9YSRSz2tpb5yzAIScA4O3a2AOB0x4+Ooqo432TT+5nt5fXdKM0num j//X/Xjw1/wX1/Y18R+F9DTxVa3Zu/7MikubW5t7aRIpAuT5aSOHbkcZVW4HFfnj/wAFDf8AgrF+ y/4u8HeHLz4LWK6h4tv9YWZkt4Ibee0jVGZ2kx86kbQAyA4PB29T8Jj0p4FRPqcHLlxbZ7/+xB/w Xo/Z+/4VvaeB/jFDqGlatbjyftFxZ/aIJ0jUfMCzbmB2gY2knGcDJA/E7/grH+17+z5+0F45g8Qf BDTNWZLiG5jutTg0yO0t5bjzAu8qPmXCjkvydygDiuvATUcK4nPjnesmfkT4F8f/APCGeM/C/ieb T7XVRousRahNa6gGezutpwFkQc4JP4V/bb+yZ/wV8/Yo8P8Awt0KDxhBpHgzxJaWUcN/pWkW0Uxt 2SNCArH5toxjIHU9uc+Fm1NynHX+tP8AI9DLa3I3f+tz6ksv+C5n7CGt+dYjxXeWcckJi26pb+RF NjjaGPB+ma/ml/4LAftL/sk/HHxVox+Emlajqnim9EV1e6hZpDa6PGhl3v8AaByzfLGMYx98cnAr 38FNRwzizw8XeVe5/9D+ZG7Em24lu5bWCUXBW3S3BKInO05buK/Un/gmb+1P8KPgX8QrZPid4c07 XdE1zWoIE1jV7BSdJZNu/wAuRlIxkA5xjK4zjJr4TFP91P0Po8JL99FM/sj8K/8ABVv9hbQtEtbb SfH+j2/lwhjFBAzhe7oFQ5yPeuD+Nn/BTn9gn4oeBfEOgX/iiDXkvdOMDW82izNZtuzt2vsb5gcc 9se1ZcPJ04NeZ25vPmrX8j+IP49eI/hzffFfx9qfwvlvH8NX+tXElrZ3hSMSRHgbY15CMBkHryel fpP/AMEpf+Cpa/sv+ItM8CfFSW7i8Aa9crpiX8t7dR2+gBWPklkB2qoDt8yk8qARgccGdU1PMqM3 0Z6GU1XDB1YrqrH9T3ib/goj/wAE9Pirp9hqGv8AjfwprE1vZIqLd2cr3EW8A4O4KcZ+vQc1zGl/ tY/8E67CWBrbWfDekmT/AI9guihDdyE5xEQD84xntXtZpP2mAjDyOPBvkxDkf//R/Uj9v3/gqV8D fgx8JbFvgl43luvFerXRtbK2sYmhvCghfJaRsLFGpMWScnk4HGa/kA8S/tWfFPxN8RYfjBrHjXX5 fFd3qJvLi8l1GZZpEkyGVZEKuo546BQOgr85w16eAlH+tz76tU5sWmz+z7/gnF/wVZ+F3xF+F2ma Z8VvGtrYatpFsmmSLqmqrOJZYkWMgSHCsdxbnvjJwcqPDP8AgpT/AMFSfA/gS3sIv2fvH0Gta1Hc Ol3Ppp8+3jlDD91E/wB1mySCQTjaeuMicNP/AGNRRVWS9s2eTf8ABNX/AILCJ418Y6z4Y+Pvia4t JUufMae+vYobCKJwAMkjjBDZY/3xyRwP1H/a0/4KJ/s++CvhvqfiPwT8YPDa6zZ6fLeWun2msQ3l 7dOgXy4VWMsFZ84GevPpmul+84+TOVy5W13R/Cr+13+198Uv2nfHQ8S/EDxFPrlibh4tP0aSNFs9 PgUHy1jVQPnDAM7sMlifXj4ouZIbp57e5iEyzYmgeVcG2YH+DHH5+tehVnelBHnxVpM//9L+Y2TY 1vBHLNcMYIfJCSAFCOxz14x09zVARpbSNdRS4ZBmNx8rJjnINfF3vFn0rjuzU0qVdQt0tZWNxPI7 rPvj8rzx1+hH+FN1q7njWGPzobYWkai2DJuCgnIwAR7VhLdXHFe+kY32OX7H8lvC19NIZpVibYsu SOgxnPFWbWwup/OUl4I7OLzLmbzfLEeONp54NS0nUOq1ka1uLe6V5FuItkMZZizgbgOy+p+lUrO2 kspZpY3ZYb4Fmy20kAgYx6cUT3Mp7n//0/5kNTm0tLRVt5Ta6kdryThg21VPRUPXPeoL6GxXTL69 1W6ur0S24PMOx16dNvPt6/lXwsfhR9LPY2LXxALjR9NsPsklv9jiYwySx7J3RzuUE98c9fWsqS9f /UyFhCg+U+5NO6vYyL82uW15bx2q2kUU4QRreRrsfaBjB7E/h2qtZK1r5qtJhY41SAZyHGB17A/4 VcdGFjRRLtst+7ZBH8hzhyc9OnSq0s9wYXs9QYMmwr5IHykNwR+PFbU5HQ4tRsf/1Pxo+A0kmg6b DFY3NtE0dmIImjlG+JWQFhg88crlemcd6/Zf9gO1+2/GjRmF0kuj3lxaXF2bbE5hkjVyC391WBI+ oHWv6Eyt+y8Ga0u8GfnEIOp4lR8pH9j9xJHD8P54fLIWLw1G8jsCpTCKx/nX8Vn7e8/9vfGHxhPO 1uLY+JTfaXG0YVmjiXAhwejK/mHcM9frXz/0f4qWb15+X6np+M7vgqUPM/Fr9o+9ZdB1K0PnTi60 me0t0dj/AKI+8EPGehAyWwOvIr8d/E95bP8Aafs7FL1H2XEqx7InwAMj34/Svp/HiV8ThI9lL9Dw /DCnyYes/wDD+p55aOigxM7ymRuXYcj1/CurtYCRG0TKoQjcVfnjpkfhX831VaGh+nxXvn//1f4r ZbqKKz3TEtLC+6RmYbGTH8xiupjgsLm3s5oTG+yMSwyOoWVMqAeOo6/iK8TEKyOhLUkka3tjuX9y oOdkamQuT1OBk9TXsfgS3u5Z7KSOZJJWAMSTFYoYz15Y9yB0rya29jrpqzseu6NeRW41CG7j+0PL uNmqzfuWfbzk/UHAFRrda5azxWptIwrxCZzyI4sjOA3T8DXm1dWdFPc2Ida1W/CW98zbbT5YgbYI 2303Yyw4rfWy08pFeWct2yrGqXayOGjV+pKr2/WuOclz2OpO8bH/1v42biRNVunGkeST5aWNsuos EWPZgNI79ORzx6VtW4gs7pItauk1B3jxvTEsYCLtVVbrgcdT2rxJO9S5hZ2uT3MeiJCX2LKt6PLi VITJDGVPUnopGOtRRtMtxai3YFozjzCcREdgT7e1SpPmNYfCj0v/AIRnxJcWtld69fozu2bGzhvs z3EBHyZC9FAPFI1tNCZbOeNlYRiFWkQuU3EBDn645rZOw3oZfieRLSOzJSQRo3l3c4kzmRDkN7DO Aa5jUnkbw3dPJph1G0ubg2sd3BMQ9vIwJXODwMZz9etdVGV2E3bTyP/X/ixv7dLkB2iWOZYBCyCU yZK9TmuOtbiWzuVC3Di3jkLMgwwJ6HGfUDtW0XoebJWxCPsb9nXxDLc+JrFbyK2S0ggnOmzpGBcx Oi5Cu+P4n2Ae30FfpF4ZttWsPFPheS3gb+05/Etld21vlTGmZFzk9FUgHn1Nf2Z4H1Iy4Tqxltd/ dY/AfEGMv9baFRd4n9+n/BOXUry++CPhRb0pLJHoqxX9xkF2nj2jnHTABAA7GvlD/gr/AOHI/E/g WdYvPS4+wTGGeQAWg8rbKWPsDGR7gnrX82ZPJYXxWdSGyqtr72f0R4oUfrHA8YT3cIXf3H8Zfirw 9cGGKz11UwbhiJIG3RblkJDIR1U4H4VnvbR2lpDZJcLcyODukVPKQLxtUA88V/o5Qd6UX5H8MTuq rR//0Pxfs7YwiEpGbi5EzSKrID06LjoRx0PvVG5v54i8mdsW3LgfLt9ea/1ckveSP4Mg7QZ0EN7D Lp4lzskE0cEcLn5nDdXz/T3r6n/Y7fTtL/aR+G4RYHGqatDIJ5GMF5azwMpG3nBVt2MHqQK+a4xp urw7jKcd+R/lc+98OKqpcZ5fKW3tIr73Y/0uPBV1HfeEPC17Fu8u68O2UyBjlhut4zz+ddPX+Zde ny1pwl0k/wAz+yM19zMaqXdhRWXKrWPPi7Ns/9H+/iip5UndAFFVZIAopW1uO+lgopiP/9L+/iig NgooAKKB36BRQLyP/9P+/iigAooAKKACiiweR//U/v4ooAKKACigAooA/9X+/iigAooDyCigAooD Y//W/v4ooAKKACigAooA/9f+/iiq5HcXtEo2CinyMSmgopcsl0GprowopWfYrn8z/9D+/iinyvsO NTlVrhRWnLszJS3Cih010LUl0YUVPs30HdPqf//R/v4oqnBoabWwUUrPsIKKcVrqhN2VworXlXYy lK+h/9L+/iit3FPc5woqeRFc8gop+zS6E7BRWbi0bQaskf/T/v4oosAUVcYqUSJScXYKKHB9AU11 CilySHzxP//U/v4oq+Rk86uFFLlkPmSCijkkSprqFIe31/oa1w6tVi+zRy473sPU/wALP//V4P8A 4KhXMVn+3F8ZdGmV4BP4tvXaaPgfIU79yW83P4V+durWmdwtDHujOQ7nbuHviv8AV3hHXIcHNdac P/SUfwfUfJ7Rf3n+ZyOqXwuLU2dyyqbcEb14Xr0HtXEvdfY5lZmYqf3augLjB6cflX10FqeeW9St iLexnkv5YGkbcsKjZ52Ox/wqtB5lvJJKAJHA4A+8AR3/AFrrh8KM59itFYtG0bzwMttKDIzSfIqe xzV2Z9Pkby45MxMu0LAdwz9R0rqIUW9j/9b8SrfTPtKyGKaVBG20OOXGOazLd70Sy2SSzo7zeWzs p2gj68H61/tAf58crWljS1ILEIrPMzXGOsaZRu2W9OarQWE8L+fchJEVNvDZkGewGK0jNWszJw7E sVvbrbX9skHkQXrq8jLxJIV6H27VJYWkbyNbgyIuNu9Ry30rWLs7nNNWehmTRtHPOlvIGWBSXVjg 8f1qjAJpWeWUKF6IGb734VsmnscVX9T/1/wti+wQ2tzElmPtdyw8+5BLAAZ4Uds8D86k0ywF5aPZ SSubaaXzNzjIXjHHf1r/AG0gup/mlN62Lb+H1USpBEZEhXBYDOFHGSPT/GsWaeSI/Zy2QnAHZa0D nZQCNI5O/JJwAelXltpE2uADtIGVxlfegpTRbmkRMCWYNcycD1b1JrPSP7M1sscryzzSFZwqgJGP U/57VUPiLvdWP//Q/CwWccTsZ7yOAyf6t5GA2/h/hRdW8GCsMkSxGEvLOG2M+B/Djua/3AP81zLF gMRmNmbIw+49AKjNl9pnCJGoEa7hjncRyaALbqIoGCny5U4z2PtTLfAQpMWMoXcpY9aqMbkz+EyC ZpJZjG5xGCpj/hUnuas2Nu0Y2EjzWXmTbkn6f57U3Cy0M4aSP//R/Ay6kE6qkLktE/UdDjrSTTPb 7UljQxhOZN24ksPT2zX+4B/muTw2iAxzqx2MpDDsc/4c0wW7Nc7bdgB0VRQZ87V0JHIlrNIeXkwU ZZB8lQOqvEp3op3nepP3R9f89KBxk2yvdweUIkLYQ4fI/i//AF1ftrKO5mt4ziGKRwG35AUUFSWm h//S/n7aK3ee5jiOyJHKLhvvAHGQanh06SaaCGF90rMPLDffPoK/3AP8z7Ft9N3T3VlqNmVcAbXl wUyOcY71lJDIGntH2KbdtyRrJuwp4Dfp+lNaMpttWY/yHV4xwQvzuO5q81ut+gWVCmTwp56fpWlo ybFdrYoT2U6yrHgmKP5Qp42j1FW4bMPK0CSRFSo2lmCAexNWlbQLtKx//9P+evUA9mzOBjyzyqck 89qsPbeZEt95bHzvlabnGR2P61/uQf5oqXKrIhHLKPvYOCammii3CRC4mxt6nDD6UBF8rKksd07q NvzYy2B29a0bOIxbWlClZAQM/ez2q4xursvm96yNK4j0uGwYtCRdtNkSDuMEEY/L9KywZSnlwsQm 0uwTkgDkmpas7FNqO5//1P58YUa6SYLMICIy8Tv0bH+T+VXvskHlsFn81liDHHQsQM/lzX+5KV3Y /wA1uZdytPb7o1CZOOH46UllZHzvk4VeWyMbsVfs2Mv397ugMaEED90uFyDXNiN5InTkNyNw6ioa s7BdIltLd22gneFG3J5bjjn8qvCIM28xjyl+Qnpg0gvpY//V/npnYqWRcMMcVkNBcSISMja+cjg1 /uQf5rl+M74vs5ZRJ13NgE1A8L27EHDOVyBjn61PJECGIEyB5AdzHaFIwR9a1Ps4+5Kdqt6HGPxq eTXyALqzjVPNiVZAmMh+eBSEw3cKhsLNkKjqMbccYxWgH//W/namhUStbuVcxYLFeM56VMLT5C4B CHpxgmv9yD/NccLS3aMi4T73CgnkY7/pUMsCB4zb7lEYywPIegAZFkU7TsyRuOOWx2rQgCquZCzA DA29OPWgTaS1IbmKFv3oVRKOqjgn0quqGQiNgyIOXbPAxQS59j//1/wBs9Et/JfVLS4hk2J5Ulu8 22Vl9VHv/SsKWJxKxDDPICjtX+5B/mlzsqKjzPGWkZdhzInY+30q5Gzq+5do2/e44pPZhGTvqaCf vovMijAcn5jio5mKJIrECTGAp5696wNRkZ3IiSEMwXGQMfpVbxE80OiSpayJ9pmzDuHEqLjk+2eB WGK0w8/RnRgmniY+p//Q/je8Zamkl20FxaAXcUrxySKMs2DyzHpj6etedzsHVwhOG4GP6V+k8YQT 4lxz/wCns/8A0pnyOTq2V4Zf3Y/kiGe2kQxwMDLG8YMayHa2e/4Ul1AUBlVcJGoOFJJUivnHFKJ6 xBbzCVNj7t0oOdh/Q1t2ktkrRi6s7S5kj4jW5gWZCOnKkEGuRxu7G8XdEsSS6eEW2MaCOYzR77dJ TEG6qu4HA9q0YdWabzE8q3g8ohHMUCwtOD14AANQ1qM//9H+Ly6xMd8JY5I87jA4wB/KpGhmjQEO AMbvlOc57V7NfSCicVPSTIbi5hktV0+S2QWkzhpNi7DE3GWBHIJxUawRpJJLF5hQqE2NM7RYXp8u cfl1qHdR03HzWfkOlW2mijjUywybsI0MjxhD3IAPersUH2WGGOWRp1hQhJJ23FdxyQCaiLbkrkTk 2mVBMoEhLDjv0zSQyAmWTe8TvCYcxnBIPv29c1NZfvS8LeNNs//S/ise4kjmt7bypFgiYSeZFMwa 4A6q5z/n1rRMyxgMsa+WCdyt8xA9Mnn8K7XzpnORLdyyzPKZSxfCb2YlkA6Aewq4kgYopckq4d4y f3UuOgYd/pWVWL5k0a0laL/rqOttlrOs1pDFbsZCzSbNzKT1I9OvQcU2W+nmuG/fyKh+T5pDxjPI H+e1ZwcrP0NI35k0Ot7KGGSAFQ+CzFNxQMT/ABHB74FSTX89vFKSVIZgv7tfL3hfuhiOuPet6ban F+aInd05R8mf/9P+M3YjQx6g58z7SnyBm5iwACMdqhtLiOC3NoZQLfzjNGgUFo2J5wcZGfyrWo7T 0KlO0Dor3UU1KNBKHQJALZHSVhIiL0AYcgVDDApt2E1xJLbgYjE0rS7MemSf8irg72ucdR3RgR3F rp7MIQ/mytsQHk/WpYGvre9jvoLq4gmKmG4kSUg3CH+Bx0IHoah/EZ392wjmUqYUkcEz+b5uTuU5 zxnOPTAp9zqF7b/Z/s0qm4iYMrsgkjkwfusOlO7cG33FFtNtdv1R/9T+N2OdtQeaa6CJLOuzyYf3 FunB+6o4+pPJ7k5r+mr/AIIRfAj9kv466/eeFfiLJBNr8cUV5BYXyxLBeO8phm3OOS8exF2ZHyvk A815WdTrQwDlR3uvuujt4dhRnj/3q1SbV+9v8j9y/wDgo5/wQ9+Cd58LdZ8Y/AnShpninTdP8yz0 zSrYrDdMuGCqo+X5853E4wO3WvxJ/wCCcH7APxz8B/tU+FvFHjTwzqWn6BoWqrczRXVvJbW/7tty lywHdVOBzx0xnHUpWydRe7R9LlFKNfOPa1Gkotv5W2P75V8b+GPC/wAPb+TWb1LWG30xra5DExBC Yhkhj24r/Mc/4LFfEjQPHv7a3xUvfB2oSazaidY7p/PD2kU8SxoVVuwyvy46jdXq5R7mU1U/Jfif D8TJ1M8pcvRyPyQju7hTL9sESynoinIB+tYMkPmSSO0pILbgMfKDXM9yT//V/jUSOS6kTbG9u8Rw fMGI5wB1U+9bWGsgoLeY0g4UjpSaurGCdthsks/yuH8x2OQgGAo7U9w0sax3C+bk7tgOHUjuD1yK wNE24MRbu3nuIg0cqvGNiqgaNXI6E4+n+Nay7JJRdzz3B/5ZmJrp3j45BKk4qeZbIcL21HeZG80p 8wvbmLbcQK+Yp8cqSPVe2Kp/NHFOImltbaX5mjRyzt7j3qVJ81mWtmf/1v4/7Vo72NHhimEKviT7 QhiORxnnrUskKkuBmPspXnI7EVzmtPYgBcHYzcNwS3fFWbu4ESC3hPyjG5gchqT2ZElaTJrMvclo 55WEY2sqluSRyCD2xgVtS6lc2q+fbGDz2/dzfIMXKHghiOc8detZKLaCXYePEN5MXVIolURBDEqB RgZ6VjXMnnRxmOaaCYu3mGM7MAjBKkdPSny6JeYU/djNLsvzP//X/ks0a8srZoZkiCzWwEQwMFl+ vqea6ybxX9hdfsto91a3m571WbH2YKAFwD1PfIrja0epUNzPl8TteQCW3dhHMu2FgNksK9cc8g1n Xt8l7ax29zbR3LK5JlIy7Zx1YcnFQ29rivrchX7LaFJra1iimC7VnijDPEcYOAeBUc7CeBoJoRCy n5CF2nBPUehNCbWxtTld6m8GULG6yMCkIjQ784x0/CsySO0NvHDeCNo4HMib/lAJJJ/P0pN9Tas/ fP/Q/ksigt1kmaWKN7OcqyRGMfuWTIyuPXPNbTXX2iIRxRC1tkx5cNuvloWXncQO5PJryLvY2m7K ws1x5yGSXZmNAmcYJwOM1U0++KTyO2FjKeWeecHt9Kl7GcPiRoKNOxmeG2ZFUoZPIVnAJ/Ot6We2 ezhgSC3YWxBiYRqegwMcYqZt7Hfz8tyraxlEM1va26MJN5VY1i29iRx1x6USB7gu0sfGCCxPJ9qt K2hKqX6n/9H+V5fLureO0neaNfNyAkvlnABABI5xWnCbTSNNmhRXmmYlbad282WBW+9y3Uc9K8XV WR6UZ9jnZmg+zxQReUMIYjCV2mQdT7VoRQ2bC0ufJC3lo/8ArejAAYX8hxSb5NOgOTehNNfMscru mYpAVZAoPmD39c1V0e+UB21DSrCKDYYVQRjY47M64weMYHtUp80lcfOlCxuvf280HlDT7DYU8tGF so+UH5eOnApkarCqYkWOP+EIoA+g9K3Uvccf63OWOs7n/9L+WK4Yb5JRuXI2qx6visqPz4X3vI8w Zsje3CehFeFPexqp8si/bSx2Mkd99nZxGWEzpD5rojkM2PqcVrrqxZxc+WI7e7bykQw7ZWA/vA1L k7amik07jWvr5/ttnFdXZiuYxFG09yfKh4IAUE4AGensKi0e41FLORdSkinniZxG0ZC741+7kev/ ANas3OzNYzBL0zLIhLRkr91eDz2/z6VZiFuVgjkSGd4W8yN3QO8bjuDjg+9V3Y3NXsz/0/5fdW1K x0/SH+3xzahc3UoQKkHnOxOcZHP0H0rNt4WggUOoMEhMnkSR4VNw6AHp9K+Ybb3O7mV7DEKRzZji SEkCNAnp2A/wrdNxmz8skiTcCZM/MQO30qUZy+JlExtdQzrMsSwYAUk8yexH4VHm2Pkv5Fsjqnl5 gA3ccEt71i1Z2KlblSQRaXGZxelw8cWZHkcYZccjj2p0tjcarcxXFu0fk7diymTaCPf/AOvUtaWJ jpJH/9T+XiNYLMNG0Vt9oDEK4iUk44znvW2b+6nhnaNsNBBgyMMAAcf/AF6+MhG2p6Ds7lOIGa2S AmSTK5mkblm/GqUjqltLbWUUJe3fYJJHKsh6Yx3rSbu1YinsS2MbjMhI3r8pJPWqyid7t2kAXLAS MMhpFySoDDsP0yayjFxm2bOV4qPY7Gz1FYJzK3DNHsY4y2BnFU7l4pmEdpbhZvM3QPEgDRN/C34H H41M9ZDjJRVj/9X+aDQYtW1m9bSJXSW98lioLCEybOpzxV/WNN1TSolimiVZMHeA2Co5xg9/wr4r em0epGVqlzkEle12yuqmcnjcAxUfWtHTtQS4lvGnwDsBPADHGRkd62UnyKJN7SuVIr24lcIscNwB Jhgw2lBnqOtPu0jDu6x/ZwzbnSIfK1Z03aQ6kueNkSRzxRbIo2VVm4RujucdKS4je3lWRYwJWG0y gfNjHrV1G5qxFCfI7n//1v5hrNmhE5hTEbt5U6Mvy3AH971HJxnNXIG05rqIKipMchY1i2qeMZyB 6V8lGXKrHdVfNqV7ya5gZ7W02JOhyN54X/PNbT3NjdabBFcwLHqatu+0Jkk4U5XHYe9Z8yvYaeiu cms7MtxCYmRopCU3HCuc9v8APenmSS4iiDkiYDEZxz6YplLR3MJLqWA3Vq+xZZsxu2wH5dwIwT0P A5rpdJkurVDLEwMCxZkVsEgjoQazqWtY3Ttqj//X/mcsfFVnLast0JJhc/uY+NphcnADYzx259Rz UR051e1eOZ1jiVlW1yTHg9M+4r4uMkopM9WU/e02Ktu0a+fC88kVz9rCl2YxKeMAD14wK1bpbm0z 9mngvpbiNUijnlCpE38RyvOMdj/+qYt8xrz+7ZFX7Kbko0hWExk5iUgITVHUZSL5PtrNK8EAFsAc xAYwMY78VvUneDREJLn0JrO7mwy3kyw2hAYNICwX6jFTRJmVWk2SJHJ5kX7sY46Nj196zoy5LIqT 5mf/0P5j7zWrjzjGk4MCt5TAjOCe1ZzwpdZlSBVu0yhnBzvXqMen/wBevjpz18z146JEtiZbNnS9 naUsf4iWX2GPyrVvrqK4treORI5Ftn8y3TYMIemQK5eVuo5s6qlS9JQMlpcI8RRHt3O5ozGMKT3x j/OKpreQpqUEkyq9vGdgR+FUkY4PbtXQ5NwscT0mb8IleS+8i6NjizZ2fcFWYDkKOee36VyU1gms WMslxbQ6jJF+5WRpcLb4bnA9TXFXjzcq8zopz5Ln/9H+XWwt72BY4ob26tyqCMMku5UQcBOeMe1d rF508e4yB2t05bjn6j3xXx1GSUXA7ayblzGPdM0pAZEcOCSN2DkHHSiWK50uC3CFAlyPMhCN8yeo FG6NoStoUo9Xh0vUbEXUciy36siSYxHGACSWPvgjAya1rzVZEnP2WzaazeJWkumICxkn5sD/ADwa xs9Uakk7MwVVIJcD5hzjIrCuBe2zSohuLpn+aOPYFAGMFQwHT65rCtBOLZ2UZ2lof//S/mDln039 1nT4UmEISZJo1kZWxng4/lSW97bRrKi2wh2ArFIsYVV343Afl2r4Ooualyn0kJctS5RaezaaHz5p TKxaFFV2VMYzwQeD19OlWYZFtLppUN00U8a2yxhmlhO3JDEc4bkjNVhZ8sWjPFO75jQ3xRSpcsNo lTaNyYKds4/z0qi9/Kzxx3SW8tmJWeSBbdNz57h8ZB6ZNceJ96pHyHRlyxYXy6VqFsqC1RJPuTRL +7dBjj5lOc1StbWVIbaxsVPmxSFYGBLzZJzgsTn1r0KE1GDicNe7kn5n/9P+XozrdyRQO4eSV/K+ Q7lRhxz6dO9dBbCTTS9tOiSRPyBIA8Qx6dq/Pq806bR72G0qIeWuoGaVGltoDgxrDO6Bh0I2g9/8 4pvm3H9nMkWqalbRTsy3scWoyxSOp7bg2cY9KvAtUkb4uXPIxtlxDJ51km2SIYeQ8uYwD1PUir9t HJqVrcXM9/BZQ25BWAsd8rDB3dO1c+OSnXU+3+aOvBzcaPKuv+RGviFw8wjlurtrdwj3U19N5TAH kFd2G2+4x2q9Z6td3F2LrUNYukiYbYLS2vXt4Ze6/LnOQM8KQOK6K0+eioBT92bZ/9T+ZPxBJcas n2Oa+u7mCSbzne9vZbybjoiszHA4qhYSzWl3Kyyy3nlwLarplwENs0ZJ3lWIyrDjBHr+f50ny4dw Psue9XmN5dWn0aCex0jUr2wluCZYBa3b23kSEHDLjjPf3xVG68Ya/P8AYrO71W81O5tUHlm/uXni WXGGYe/J561zYeX7vlNas3z6F+DU75CupWV9JpuoxSY+12MxhkfsVcA/MPY56CtG48WeIhbX1tf3 1/qNrcSLdRPf3r3HlNjB2A/XqeeeDXXTk7s56ktEcG8lw6xFQpZ5SXCjaCCTzn1oyTci3m3RxxgL GmckAe9buo3oYWP/1f5h720vTcxyyXMSxSQr5NsxVWCgdT3rKvre4DRq8qxogyyKNwkzjGD6V8Kp +6fUWGx2hjlik+3mGNtpcE48sHhsd+lWW0xbi1uppJjeQ21wBEiyhLiZAcqQpOewz9RTTTkhxV5I safb3N3cTSafy9onnfZZ5l+0nHoPz6CltJL+3OowMsTJqcebsP8AO0ZBHIP4Y/GuZy/eaHQ7rQhi gn8qTekaFZT5fl55UfdyP8Kan2xl8q5xE247Pm7ZO38xj86d02Yz3P/W/l+mQQwQz3EMcKM7RxvK fnnZMHgfjn/JrdjvI9XiNveW0ccX2QRF4BsDEDAY+/Tp6V+frQ+ml8JT1KdYUs9PtommS3sgRdRE ybjuPBb15/SsK7muN9qiqv2YyASvI2yTJ7+447009bsz5fdudD/Z6I0MwkSSOJQXQL8rEjpn2qpK ZWedIo2uFlULHGDsEY4GM/n+ddCJN6y+02tsqSw7CGAUn7i8fdBqy0D3dxHcLCZfLdQyjg4BH8q0 pfEdU37uh//X/Hb4M6Dp9tnVNfsGltbCCRbC1EjKl27r80jAYJK7sBc44r9x/wDgm9Y6ZJ8Wkt9L i0y2026sorwiKIxz7lYLzjsAQMHnNf0C/wB14MNLrBfofneVS9p4i1E+kn+bP61vHUz2vw11FoZF VrrR0jLgfIqtHx+gwPqK/hu/bHubvVPjF4qvbqGT7Lp91PbaeGbaIWMrM7lM/wAWQQfQV530dqHP jcTN9l+bN/GipajQj5n5IftNX9rceBXtrZJzq1hqKzy3MY8tGhfYJEVupIC5x3ya/GXXJLp3mEv3 PtL7ii43DccEj6V6fju7ZpQp9ov82YeG0P8AhNlO27KGn20EkDbPnk8zbk5G2tWxgu5bqGxsh5uW xcXGOcc/1x19a/nmavGx+jJe+f/Q/ik0qztZLx7e4BnSOXypFukKxs393J4PXPFdFtt0YeXagQRM LdjbnKp1wD6Zrx8QvdOuCdzporUujzCNFMUG5o5H2DHGOevORXrPhTSl1TS7W4s9WtlvFuktk0jz RExUDc8jSHtn5QPXPsK8Ste5000esRaJZWWlJdxXL3OolzJLp8gXZbFeAYWJycnnGM8+1a1pLLJb xi8jZXlIP71dkgH+1nvXl1nbY2i7MvyW8kN20VnJFMmNqzI2OCPmx7daykWO01p9OM04hmiR7eQj CTPn94ufQH9CK4ld1DpUuh//0f42YbJZlSSzVYo93mYh4SQ9QfTvThObe2vVFujyvCYt02R5eeAU 5+8Ov+NeFLSTIfwFrQwX0J47h4dtjcM87MQjusnIznsMdfeukstGju7RDF9phs5FJa4xvEmeCQ3T 0FZp9hxVoo6Hy73T7AzQTgfZEENjLdyfLcuB90c56Dmp5PEEV5ZrPfzzRX5AtVQR5ty2Rht3fFdI 2S3SW9la3sWpWy6tHPb+UpUnIJUlm/D3HavMdPRoH06TS3lhsxMZI4Z8xwTHJ4kRh0HNdGH0mTU6 H//S/iw8Qm9n1HU2t9MktEt5SkkiRmGzj387ozzlcntXDiNxJEl0UUsfmMfORnGTTvpY4JK9ZNH1 b+zpJp7eI7G2klDEagsH73MaKJSo3Dtxwf8AgPNfqR4RU2aW2pahfst9p+p2zxgSkyBYZUJBI6/d IwOwr+xvAeSnwziIru/yPwXxGXs+JMPJ91+Z/d3/AMEu9RluPgpp9zDGblL6Hzb2Tf8Au7WdlV2R c9QA4/yK4T/gq5ay3vwp1a1mxFbRW0ttbXjOY/P3W4lMYfoOd+R71/O1Ney8UuV/8/D+ivERurwK mv5I/ofxTa5psTS2xGoyXtnDviEcb7hEVdgyhu+05X8K5i7awkvY5bcXIgRvKiRss6nGDuwACM98 elf6N4Z3oRfkvyP4Ssudtn//0/xh1YPcWxsLIfZ5G/eSzJKfNIbsvHy4OelcvJp1xBAtpcyyTQKo j3tkmQHqCT1r/V6S2P4Nj1Ny2j8trSws3e6m+zG5RFiZ2jCHBzx2yPz9q9M+E/xM0P4d/EDwr421 vS7mdvDWorcDULdmleF1P3/LyFYE469NuR3z5OeYWpjMsr4Wl8U4NL1asfUcLYunl2f4TGVfhpzj J+iabP8AQi/Yw/4KK/sxfGf4I+Br7/hafhzw9r1hosOl6vo/iO5/sW5gmiiXgeYApyuCADkjt1x9 gf8ADTX7P+cL8W/BUnJH7nV1mAx15UGv83864XznLszr4etRd1Jn9eY3iXKsVjHVjVXv6999d0Vr n9qX9ne0x9o+L/gpC2CEGqh5QGOASgBIHuRiiT9qb9neKBbmT4v+Clt3bYkv9qZVj0x0615f9jZn /wA+WZ/2vl1ruqj/1P7aJ/2vf2aLYKZ/jH4QiDSiFN9xMN7N0A/d859qkP7XX7M4JUfGrwI7Dhki 1YTOpHUEKCQR6da9X+w80Wjos8j+3Mtvyqovx/yMt/20v2WY3eN/jX4ODxy+S6+dOSGAyQP3XOPb NUo/24v2TpHSNPjh4OLvnajSXEZ+XrnMQxVLIc2e1F/gKeeZdH/l4ileft4/sl2EqxXXxo8Nx70L rKLe8kt2A64kEJU/gayX/wCChX7HisyJ8bPDs5QgN9ntLyXGenSH+VV/q/m3/Pl/gR/b2A/nX4kz /wDBQH9kaMlX+MehLIIvOET210krL6hTGDVJv+CiP7Hcao03xp0CAOu9ftFtdW6kf7zRhf1qlw7n D0VF/gH9vYDbn/P/ACP/1f7H5P8Agor+xtHsz8b/AA0d7BFCR3Dkk9OBH+tVZ/8Ago/+xrBI8LfG fRDPGpd4RaXKuAOc/MgB47A5r3P9XM5/58P8Dxnn2WqydT8/8iT/AIeN/scAOW+MuixhIhM3nWd1 AVUjIOGjBqq3/BSb9jFLdrlvjRoYiQBnxbTvIob7p2hCee3FL/V3OP8Any/wGs8y57TBf+Ckv7Gr 5EXxi0uZgyKIodOu5ZmL/dwgj3fpWfN/wU3/AGLrcyLN8YdLjaKTynje2kSbOcf6s/P+lVHhvOZO yosHnmXx3mRXn/BTr9jSxilkuPinEPKXeY00yaSZh2wo557VnR/8FTv2KpY0ki+KbOrnaR/YdyjI fcMB+mav/VjOf+fRP9v5b/N/X3n/1v63D/wVc/Yljmlgn+J91bSJnyxP4eulFzj/AJ54BzntnGam j/4Kq/sTzSQxR/FMtLcKGijOkyo55xyCRt/4FjpX0S4Wzl/8ujxP9Ycsvbn/AK+8n/4ek/scCGS6 b4hyx2kTsj3ctrDDbjbwTuaYZ+g5PpWQ3/BWX9ihXCD4j3T5baGi0xJUwejZEvT3q1wnnL2pjfEG Vr7TJH/4Kv8A7FsUjxv8QdRARA6yjRS8Uw/2CJMnHfjHHWmwf8FYf2Lp/J/4r/UIVnYrG9xpSQLx xnmb144zVrhHOutL+vuJ/wBYcr25/wAv8x1x/wAFXv2L7Wa5gn8f6ikloiyTKdIXIVzhSB5uT+VZ cn/BXT9iqKJpD441pmB4hTREMjLnAYfvtuPxq1wdnLX8P8/8h/6wZZ/P/X3n/9f+r8f8Fc/2MXa2 WDxhrdybpmSJINKhkcleoOJ8D86gu/8Agr1+xnZW0l3c+J/E1vCkhiU3OhRxNOy/eEa+eS2PUcV9 cuC85bsqevz/AMjwpcRZatpfl/mZif8ABZL9iN4DKPF/ibjqB4eDICei7vN6nHTFWLb/AILC/sXz IHl8U+JLRWlESSXOgeRCxIJHzNIOw961XAueP/l3+f8AkYvifLl9r+vvC3/4LEfsTTmfHjbWdkGc yR6OJkbb94AiTt71mN/wWW/YyW4khXXfFDRIoYXX9kQiJs9B/rsgkc81svD/AD+Wip/g/wDIl8U5 avtfl/mQT/8ABZ79i6CVoDr3ikyrgFTo8SjJ6D/XdfatO2/4LD/sd3LeWmt+JvNzhlGlRAJnpuLS jH5U34fZ/Henv6/5AuKMus3zfl/mf//Q/qrj/wCCwf7Got7m5uvFOsWkNq5jcvYRuxboFAEnU/XH vWHqH/BaD9jDTV3Ta54nlXPJtdKinwD0JIlx+tfcrw/z5/Y/P/I+ZfFOWp7v8P8AMtWv/BZb9jK+ gaa017xOzRR+bLFNo8cXlrxzuErDv61WuP8Ags9+xlbtsOteJ2woZpBpURhXPbcJTz7Yql4e5/8A yfn/AJHPPi/LYu3N+X+ZCf8AgtH+xonlhtY8SMZBv/c2VvL5Sj+J184Mv0K5q7af8Fkf2RL2R4YL 7xVJMMeXDHpaPNLu+7hd/f1PA9aP+If54t4fg/8AIz/1yy5O1/y/zMu6/wCC1P7HFnfXGnT3/iuO 5s8i6RtOgPlEduJTzUMP/BbD9jGchY9S8WqS21fN023RX5x8uJyT+VP/AIh7nz+x+D/yB8ZZbHeX 5f5n/9H+oY/8Fp/2NC/kwav4jmuQwTyfsduhJ3bSATNzj9a0pP8Agsr+xukHnf274gZxJ5bWn2CJ bxTj/nmZAfbIyPevvf8AiHmffyfg/wDI+M/1zy3v+X+Yy1/4LLfse3Cys2peKoFgGZml0qMLEOgL HzMAGq8f/BaP9iyScWy6/wCKTMThUGhcsT0x8+Ofan/xDvPU7cv5/wCRpDi/L57P8v8AMnX/AILK fshSu4ivfFXlRSiGaebToYUhYnGG/ekg+1SN/wAFkf2QftVxaR6p4ilktk8yWRbOAwqoGSSwlPT6 U14dZ89o/n/kaPivL0tZfl/mRP8A8Flv2P4LAX9zqXiiJGZhFGulrI0wX+Jfn6fWqdr/AMFpP2N7 pIiNU8TRyzbikD2EKPtQEsxzKABgZpx8Oc/erhp6P/Il8X5btGX5H//S/qJtf+C0v7GM4Zpdd1+3 WPLSk2MUxiUEAOQsh4OR+dV73/gtb+xdaJFKut+I54JmZYZV0+IeZtOCQokLY/3gK/Q4+HnEk9YY eTXov8z4yXFuVxWtVBa/8Fqv2OLx4lhvvFnlyghbh9MiSEEdQf3mR9cVsp/wWV/YyIiV/EPiJJJW 2Af2UhjVumC3mD+VN+HPFC3ws/uM/wDXLKFo60SMf8FlP2PEaZLjVvEkRiDSKU06OUSRr1cHzAPX jnpVdf8Ags/+xtJKqw6n4ukgZxHHcjSIRFK3dV/fckZFYy4A4lp/HhpL5Gi4vymSuqq/E1YP+CxH 7H90Lk2+qeLXNmcXQOhqPJ9iRIQD7E1mJ/wWj/YlkKJF4q1x5C+yVF02NzAQcfNtkNS+BOIVo6D/ AA/zL/1tyj/n6vx/yP/T/qjH/BZD9isb1k8Wa2jIcbf7PgLP3+QGcFvwFR2//BZb9iKZow/jPW4l lbZE7aQgVz0xzKMfjx7190+Bs/jq6D/D/M+OfF2ULT2i/Etn/gsJ+xuv2nzde8Uw/ZwGVZdETzJ1 Y4DIFlIIPrmpZ/8AgsN+xRasi3PjPXLcFd0jT6J5SRcZGSZOvsM1S4E4g60H+AocW5VNtKovuZDH /wAFiv2LLmby7LxT4luownmG5GiRxW4UdWyZs4H0rQtf+CvX7GN5JJDa+K/Ec8sab2EGiRyoF6ZL Cf1IHTvVvgHiFS5VQd/l/mV/rXlSSlKorfMik/4LAfsWRW63LeL/ABA8ZlML+ToiO8JH98GYY6Vo xf8ABXL9iWazS+T4g6mYWzujGjKbmHBx88YlyAexGaX+oHES0dB/gP8A1syf/n6vxP/U/rEt/wDg rl+xTcpLLH461gQW7iOeZ9FVVj98edux9Bn2psH/AAV2/YiuLlrWL4hasWRS5lbQWWHA758zoa+7 fAnEK09g/wAP8z5JcWZTbSr+ZqXH/BWD9ii33/8AFypptgBAj05VL5GflDSrmoJ/+Cs/7FlvDbTy eP8AUyt0cRLHpCzOfqFlNZ/6kcQf8+H+BUOLcpb0q3+8b/w9s/YiUoJPiRqMW8kAv4dnIGOucE1Y H/BWT9iNndE+Jty2xN5b+xJUB9huIOR6YqKnBefQjzSoS/P8FqbR4oyqo+RVF/XqTW3/AAVc/Ynu c7fie8YD+Wxl0wqEIGefnNa1v/wVE/YtuMY+K0SKQWDvpczIQO425rmfCudp2+ry/wDAX/kX/b+W f8/V96/zP//V/r+k/wCCnP7FcSRyP8Y9OWOUEqx025XGOu4FMjHuKX/h5x+xSZIok+M2lyGaLzgy afc+WqnoWJQYr6n/AFXzpaSoT/8AAZf5Hzn9v5beyqR/8CX+Zdb/AIKV/sWqkj/8Ls0IrGuSfstw ob2UlACfpTV/4KWfsXMzIfjRoqSKCxja0uN2ByTwhHFXT4Vzucly4ef/AIDL/IHn+W7e0j/4EixF /wAFJP2LZohMnxw8O+WX2Z+z3JKnOOcRnH1NWm/4KLfseqV/4vDpDKzbRItldNFz0+by8c03w1nH TDzt/gl/kXLPMtWjrRv/AIl/mLJ/wUY/Yziba/xx8MB923YI7gyZ442+Xn9KlT/gol+xxJIsMPxt 8OyzHrGtreIyf726IAfnWi4QzqqrqhLXyt+DOafEmW0071FddtfyP//W/skh/wCCiH7GkzFE+Onh UupI2+VdkZXqNwi2/rVyP/goH+x5Jn/i+fhRAqliWS6IwPpEf1r7D/UfP9lQl+H+Z8j/AK25S/8A l5+f+Qp/4KBfscqEL/HjwcnmHCKxuvMbPQhBFux74xVz/hvT9kQqXX45eEnQEAuiXbAbumR5OR+I qZcH57RfLLDy/wDAW/yNafEuWVVeNRfNpfmXF/bl/ZMaOGVfjj4PZJwTFt+1sx28NkCHIx703/hu j9kkGNX+OXg+IyZ2Cb7XDux1PMI49+lR/qrnf/QPP/wFmv8ArBl3/PyP/gSJYP24/wBkq5m+zwfH fwNLLgkIl1Md2Bk7T5WDx2FWE/bY/ZSkMAT45+B2Ny5jh/0yUbiOCD+74P1xSfC2dr/mHn/4C/8A IFxDluzqx/8AAkf/1/7Xm/bL/ZdV3jb41eDFaNd7lrmYIo/3vLx+tWk/bA/ZhePzf+F3/D9I9m/d NrSwDHr8wFfTvhrOF/y4n/4Cz5z+38t/5+R/8CRJa/tdfsy3gla1+N3w+mWHHmuuupsTPT5jxU8f 7WX7NUuPK+Nvw8ky/lgp4hhYFumM5qP9XM4/58T/APAX/kH+sGW/8/I/+BI1D+0x+z6snlH4xfD4 SbA+z/hJLfdg9D96lb9pf9nyMAyfGb4cJnoH8V2iE/gXzW0+Hczh7joy0/usp55gOXm9rH/wJf5l qP8AaK+A8mdnxe+Hvy9QfFNohH4F6qa9+0n8CPDuk3ms6j8V/AqWllbtcN5fiO2kkl2qW2ooYkk4 7VlR4ezaVaMI0JNtpfC+/ocuJ4hyxYebdWOz+0j/0PEv+CjPxH8GfFT9q74q/ELwJrNjr2nX+uzx XslqpdIZpnWVzE5G1grIYy6EqSpwTk1+fc2qSlnUrlMcg/ezX+tHDWH+rZNhaC2jCK+6KR/BtSV3 N92znr6dnE0WyNPOXbuYZIBPJFQ29tpsMa27t++8vzPNdDlWHoffA/OvpYLQ4S3MsM0McguA218N 5vLZ9RVOz037DNLflvtDXc4XbIwzwMAY9OtdMPhRMkmjavklvtKktJ1iEkUu5ImXLkHqB+Fcdp1n awidfJkidAGiLfKg55BUj/CtYu8tSoR9y5//0fxsSaGKEOfu4wY1GC3oc1BJMNs0kVuIpYlEkjnn aM9cV/ss52qOL7o/gFRbv6FVrtEf7RbxiY48ws6/eOBkVn3SzTxreZMEgO4wL93J7/h/Wuq3Q5di vb3kr2/kSRNNMGJ3Y2u/17cVZmeaGFEEYhdfm3hsn/P+FdCOOb1M2GVTM8koGXByQMEnvVS/+z+W IEywlJ3tnGz2FbxVkefUl0P/0vw0W0jtbWGTzDhztIcnccetJqF7cxxWgs5I4Ioxl2ijDNLg8Bv8 a/23iuVWP8z73Yyz1WfEiSzyoZlxKUJXcvXH41HLb2V5ZTX0EjrLBKEkjK8Opzhh37VrBJ6kylyk D2LLBDJghZn2KOjk88AfhV2Sexgsv3XmidZfLdJUK9jk/wAvzqZK0mUYbShnOGZpJOEGOlSwRXH2 lFUHdJhWP3QvuaIr3kVGXKf/0/wjvdOd5N0zifA2NjGVHfFDwqsSpCh2IgQLn0r/AHAP811qilHJ Mu+F12nO2P1xVBXmF75JdxJnaFGRmgDokijRiJIzKejqwzgj2ovhG4zDhHjXOCMVpT7CaurHOW86 BpBJuR5JBHnb8r54HNTvI0RCfMVOQTjpWglFJ3P/1PwOV/s8LbVCjoBjn1qvMEuYyA2SOvp+Vf7i OKUT/NctQyL5Yj+cMBsBB+Tio726nsI4Gt7dp3llEbbTtaMHgt+FZiskyGSLcOWcljvPXOetVZ7c tEySb0BIwTxn/P8AWkluHUk8olUjOHAwUJ5AxV6G6ZswqADEP3khHzN7Cs1pMfkf/9X8BzbRtIrL Hk7s49T71PBG9pqCXJDqmNwK87GH3fwr/b2O7+Z/mtKJcur+W+LXDRlZwSH53b8cZrk71JZZPNj8 yGXIUMq8yLnJU+xq7GWmqLUd3tQNLlWA8sE8YNSwyNGTKsjA5znOQPoK2jG25I+WaecJIkzM0XVW 5zUELMpzI4jZzk84qkr6ID//1v56J4UMjyoXcyv82SXXgAZA7fhWzNc2kQhsYGchVBl/uMx7/wA6 /wBy+Rn+Z5SneKOWISDYkjgbgM/Wp5o1LLNCCIs7UJ53Y71SgragNV5DuZDubGCccgVA826SG2VW kmkfZGqDJ+uKtK2iAdOs0hUOP9WOdxwBiqTFjJmEsHCFCVOODwR+NS4p7g5d2f/X/ntD5iWOUZUH sOVNTqTEdsTHBFf7ncqUrn+Z909jQW4AiCbNx/iOOKoTNLgGIlBv+bHGR3qmtLDTa2FvZUgS2jtD 58RjL3TSLt8l842r6jHeqhcyJGIiqjdl/wC8a57W0EIRJDGShKszdKWKZJVKuzqynBwMA1UY3LjK 2jP/0P5454yCcN34NOCMkSF3yc/dHGfwr/cpxaP81xWEayCQAZ9OuDU8tqZcXjD5wu0ODwFB9KVn 2FF3VyGVFDJJEwkYjnjpSxoZt6yuysPmGP4aQxGMixNEvO7jmoEidQBH8rrzuPIzTs7XA//R/nmj naQTxzrG0hbcZFXDZqaC4NspjuUdlxmLtjPQ/Sv9yD/NcquBKjfeUseM9cUyzKq5g37j2DfexQBa mksoHdRHNI5AVMJ8oJOCTUwyiKIomZSP3jEjjPpWsYpK5lKV9irNH8/OVCDPPTirYlhSzWZ1Xc/7 vZg7m/2qmUXfQg//0v584rnbGjRhURV2ALx+lQLF9ruMxt5bLyR3kx2r/cnlfY/zPKryRwztCQQz np0PHXFW0G/AKhI87enLUmugbF2BIoJQ0QaRFO5424UD0ou7QTgS42IzZBJweO1YuLWpXPIrhfs8 Zl8vcB1FcprF5PLa3hiMSskTSxpIODtHOPcDJx7Vy4v/AHafodeBV8Qkj//T/jG8drIdXvJ1kxKk hlmtchjGpPHuOhOPc1y9usMsazKwbaQNnTB9xX6bxcv+Mjxv/X2f/pTPlMmSeVYd/wByP5Ifexi5 uo8b/PCiON+oX0BFQXUV3bQsksWZXyrc5XA7V801pY9MyY4phsMCYkJw6njaDUirmctOWEq4AGfl 49K5pRtc2h8KOjt97rKLudYVk+WElS7PgcD86gSIodrSbyDyyjbgVgUf/9T+KiadreTEMjSKVAkQ n5DjofrzTkmu3CDaGBGUK9BXsT97RnDF21GxSFd4mY7nyi7h8q1ZxLAjIhySOc80EmX58yyRzLxG G/eEjDLj2rdS6F5EIw2UPLBuMn2rK6UxtdzPuYGkQhC0W18MMcnFJabwGjbghsI5Pyn61D3uaU9I 2R//1f4spy5tvuDzoySmP4/x98VGpuJrDLgI78hfXB6GvQOczQ0y7gQvmA4Cg7QT6VqxJKHDsCSU wf8AZPtWU3d2N4aRB5bi2wxRypOFypw2feiNjI6mRANrZwe9ZpKOw9jor22nWw+2W6jymHlu6Nl4 D06f1qjHCZLVd5LFOQ2Mk01oB//W/i5+0q4EXlk7CSjkYUeoNZm8tIw4SNiMY+8p/PpWk17yJnrE vx3Bt45Am55HAEZb/Vn1/Gn/AGhwUXc0aLwy7sBie5FaWscs09yrKkm8khlkVwYiejL6/wAqsNcT v8r/AC8AccZpNEWa901Y2jNqBMT5y8Y9fTNQW7Iqv5gJUH5Vx096my5bFQT6n//X/jUiCpbE7Xbc SS5XBHsBXp3wr+Knib4L+NfD/wAQ/h/q+s+HtZ8PXMWo7tJlaCa6kiIOCqkfe24z1HHcAiZwjODp zWjVjLDSlQrRqQeqd/uP7pP2Uf8Ag5I/ZZ1L4SeF9A+N/iO5tPF1po9tZ6zZ6vo11d3Uk6Kqyvvg ikUgspOG29egr6O/4iA/+Cf1m1xepqWnGAXWzzV8OzW93Lu/jUCPeQMcnGfalg8Nen7Ku7W9O57s sfH61OtR0T/rzPyD/wCCsX/BbX4e/GL4aR+AP2Y/HOoabeeI9Vjgv9T0lLzQW+zeS5lUtMsb4OUX Kg9OCDg1/JT4h8T6hq/iG71LXry51vVtSlN5quuTSsZrmYk4MmSckAgZz0r1Kk6VLD08JRd1G7b7 t/5LY+fxKeIx08ZJavRehzF9IRLvDB93T/apqq00aMyBHYZKKc15wH//0P45n1C/h0+Gzm02C4jj YyWs8rlZrfnJVCOxOT8wqtvuJQks5XIQEop3GP2/nWcpdEc5bhu1VMsoDltixtjd9altFkuGlZlE e37h9faszdJRVkEpZbmOARmNnH+sAyPx/WtW5tSkOYtsoOMgHDe5rKL1SGZcD+U6gA7WbbjBIA75 9KvfaI5HCdCr9WHyke1Hwz1NVBK5/9H+QV7qURGNBmMEnP8AOqtu7MzYJODyD90VzJWN0rKyJmzk naJF6Y6MPpTXs9qA7snuBzj2pSaSsTKN9USwqY5SxGVC7QR1Haoow0chRpndGJYFlzk57Vn9mxkW 43YSKq7lB4ZgM8VaaF4/9U4mjfnJXaV+lK+lgP/S/kSt4ip3FuGbjsatSMdjAuSCcY7D61wXtoOO jRDDCYwVEgJbovb6VLbYKBldlIY5z0P0pDa96xYSUJJgEjnOB/OrV7cRSqMHMm0Zbvmg2KSXIgBj aR2QruYgfKO1FyUkjWG4BeF3yCRgfjRboOT5tz//0/5JY90cPlBg6o3yZ7D0q8BOI2lJ2IB8i9N3 qcV5DTW5c73sU0Es8LvG2SjEMG4DCpbWBGSUMVQhNzfNjgEDA/OlboZwdqlnsa8ECOSiEHCggDkt VtZVtsxE5dfvD+5SaT0Z0se16qFFTzS+N2E+4fqahmv8PgEr/eUHIFMD/9T+VSJ45W2PlSQCrdM0 iqsaSGednfJIDN8qDsBXjnQVbkSRxCWEI3O18AMR+NRwXs3l5kUbd20sBxSaT3Hd7GiLuO4ga2iH 7/YTEzrhFI6ZNYt3qF4l6LOW03slssnm5IjJOfbnpSjHlY3L3UjStZpJUKF2RnO0BQNqjpwa6C18 O63NvkhjaeygUvwT06EkdcAkZI9atdkQnadkf//V/lQv3vTI014iWzwkW8VpB88WBwW+p4q0qLHE pdvmZA6g8da8KfxCqNx2LdlcIrxwXGEimOyRzwFHbIpdTvlW4jEAW5hVvKjlHXPI49OlZtaWHsUL y9eFYW2KyF9kxAwyZyQT684H41HYvEjzyTySGSZ1EaZxHH2J/lWUlZ2NIy6MuCURuySRKpWbbHKh 3CVfUnoPTFTkKj74cAA5AA6UrtKxof/W/lqjl8mVJppPvyAKH5BbgDA/z0q/qN0BbNJM4Ehky28h Q69Rj3r5c6CuPLnhi8qNN2A6y7ssMjoaY7zRYSVdwJypHelazAseTFdW+MsscX7wqDhtwHb/AArJ 0+ZIbnzSC8QB25H3z0x/OspfEwNqafzrdbe3nKQSy8qnPzZwRg/TFTqDbQvFGpBA+YjjA+lSB//X /l1+yLeKsgRnkQkxSYPy9j+daFrFcWszP57gPF5UkeBsxz1H+egr486VfoaBnggaHagbecE4+U/X 0rIuzafarmeFNpOGlQcqn+eKA1Whbh0+XKqQVM0YmiB6yqRkFfXPtVNHJmeB2IjzhAEw6EdcmiwX exauFaMxCObOTiQFCzqMdfb/AOtVfTS8S3d/DcyyTTN5SLLzFFs4+Qds85+lTKKY+aXc/9D+Zuaa WJILmxYQXqx4adBl8HqKffeJr/UYoLe7le4ktIyESTG7aepP5V8ao2Ormkcw0k0zERqsjA9zgKPa rFjD5bs86bWbgbRyKq1tBqb6mmthbW86SJcqk0xLtbngDnAPNJNcRh+UMik7WZecVzg5N6GnEmmW 1n9oleMuwJg6Owx1yO1Y0t9I0bXDwsbfG4NszlT6VrGV9GSm1sf/0f5jLuSLykCOVjJDbkGN3tVS 1khjkN0rOfLUhY8D5j/kV8edLbe4+aRLiaO8k2xsUHmlzh0X3+lQTtaQXCMl+JBdOFtsHKyHGcL6 CsEm9hGz9mtZ7SSab7NHNaxNJG7n53OMAAepzXNWOo2T22+VbgXe/wAs52pFDjOdw65Pt61uawfQ LezjvLkGQkpI2NyjO0HvWvpekyaPHeRWpl1GIyPKVnBbYG7KM8AdvrWc11KcrI//0v5b7G3hWXdF HgTuXAbpnOT+RrrYbl2uY7MK7ymMuW2ny1C8H5un4e1fDnXzsyZHa4uLlUAncthZNnKE9BU3kSoy LdZFxAvU/KeQO3bNNJvYr2itYqW8k9zAbqUGJllkhFqWw52t8rMD2PUH60xnll8pJxtYHll5NapN q0hqaJDfiK5jtCruSMM4XcI1H970z0ArRN/ApeGJJfMkjPlyFcKMcc/4VlazshqSex//0/5hZoxJ ZLEVzKyh5LhE+fcBzx6GqFq6RR7Y2Iwx3MTkk5ya+HPTU2tCaaSABXklAZjhCxwT9KWOcxJkBZSx 4YcgVMtIstSTKcVxO7tHI/lo0hQ4GC69Qf5flVL7Lb3Er2weVoi3zM75dT65qYysrMzk7u6Jo9Sg e8m0iaOSV7eQW6SA5jlTbnP9PwrVS3jtYpTYW8FvbHAkjjIUFuBnHqeKtq7K5z//1P5f7d/LKpIN wkbJ7/56VcE6x71t7mSEOQJCPl80A8qR6GviE7bHoNX0ZmzyQ21wLyWV0ji+VgThFzgZx+VX5bpZ nhn81XjijKrtcMiButaQ2HFamRqAS9QrFnUJLSNpLdM7Vjfkj8/b1rtbRHuPD8cAtitxJbqJ4ix8 tnxnb9BUzVnc2TWxiWi3TZjkTFxGedhLRj6Grl9qNpp426peGzHlb3kt9szoOnQHr6g8+1ZtXVhx moy0P//V/l9vv7HupoJra6acC2AW7aPyVwcE/L68D8qxJrufT2uLZMagjDdDk7QpxwV9/r618LJe 7ZHtqVndm/p66dc2Re6tx52zejH78MmOgPQ9SKVJwLXy42YJE5KAD7x6Z/SsV7uw6klJWMMu6vGX FxNLcvsBbOFx7dBjNaUqtD5SzRBowQ2G43iolDmdzLnUTOsoN+oPN+9+zJu3RIAVkPG0Mev5U2TV r9J7hIVjtEVsIIVLSkYw3zdR+H50+aUVqDSZ/9b+WnSJrF7ho4JfKu2YYRk2I5JzjceATzXT6hqd veWgKpiOKbynjdvkDLgHB75INfnDvNcrPYU1B3uX7S8Mrxvdy5WOHy0t2wYsev4f1o8qJsuBvQty vpVR5oGntL9DK1LUSLyGKKFPLVBE7g4bGOuKjiMbobYxgxSEmTadjE9j+dTN8+51UqiitCnfw26K YkZlkZcjcMICD/KorC3EoljMcM9xaDfHL9/yWxztP0ou7WLc92f/1/5fbK7iOm/a7sI7NLIRG7bJ YNpI5/z2NLaX8V/dwSWlqcOAgckiRwODx9a/NZO0bH08Z3ldEVtfQSPLdiWH7TYXxSWznXaXAPBO eMH2pNRuLCa936LiOf7MbhbeRxtSVs7sY5xnHvzUUly3RpOfNuJEkdoISrjzpE33UDDagcnkrzz9 a0ZbmO7t1EknlxCQRkId78YJGK1j7ruZzn95jNPFp81rGUnMF1cFEfGViON3J/LitCSSN9TdIZI7 toVG6QHBCkcHB5/P0queRCn3P//Q/l6uYVnvPMnUyOU2CR/mKjjj6cfpTJPPV2eWPNsgCh1+bf65 9MV+eKXu3Z9NLRDbi3guYYFDpmOUS5K5cAdR+NX/ADbNdQhs7YCB7nlIWcvtGMnn+VWnyyQ6UrSS Y+zkhgu11CK3824iLIqHKsw5HOOo5zVKaQxXEe4Sm5kBaULETGig8bj0HXv/APq527yZ2T3LElyj OFVyCi5ITgE+9Yb3Et/NcWlrHM01n+/uGZCBg/d2/jRF63RlNaH/0f5YtNMt9cKNXku2tbeYsFmi KGMnjEYIGa6mJViSO2s2WRnkJczELtUknH4Djmvz8+naurGxaCxRRG80VuFB3s5CIABnA/L+VZeq 6a+t2n2jSI4Lu3TlmZ/L5U5BHGeo9ulOO6E42i0izamY6Ybe5WIai0Kn93LuhifHzE8Z/DAqSOzM T289vfJuT/WwNHhpD6A10IySu7FnVLi7lfc4xbeXuaGIYJkGMN/Pj3rV0S4aN44kaM3LAOolbMI5 HDYroopKSNpbM//S/Kr4Y20U2nWsk0rMEjbEQwVR9xULg9jgn8a/c/8A4JPeHIr/AOJl3cG1M39k 3EhlBgChUdonYZ7qNoI93r+gcxkoeDcNLe6l+P8AwD864cg5eJGI62bP6j/i7CT8M9YhjlS0RNMF 05mYRJbQW4L4z2yqcfWv4ZP2nr2ab4m+OJG09Y3vNfuG+3G5zuijdlhwhPRl2n8aPo5wSqYqXkv1 DxsTcKCXd/ofjf8Ata3eo6do8Ntb3cf2aeZLy4giOC2A/wAjnqOD+Rr8jtY1Oa7uJmmjitWklIVF bhR2/CsfHed+Iaa/6dr/ANKkdfhxBrI7vv8AoRaYFEE6tKrCY7Bt+VgR6H8/yrr/AAvdLYtfxkuJ J40ijkA4xuyQfr/SvwOfwn6EopyP/9P+MWIpLey/aLZ1MDAmIZTzCABnPPpWeYyk0qRAxJNKZZlB 6k9/5142JdonelY2NPe+jhea7vDf+felBAI9k1tHxtBPcY79ePpXuvgGwtNRuI3trGZr/wAv90vk GFos8Z6c5APPoK8St1+ZtBdT06xubC7EkVyhW+06VgrxxlA8gbGNxPI4zxXQCw1PVdlxeXXkSWz+ YESUnz1AIAYkemM/TivKrb2LI4LG/VjP5KRvbxFnNvOZYGQnq2e4wPTr71FHI01uLu9dPNtZCyG0 BlZMH7o7njrxXEtJNnQf/9T+PWK0e2sd0qxWwCBo4rabzVUdh6gY71zmbk3trdqlrd6bDuurlZJ/ 3ku3I2hfT9favnqkrSJXw6mjcWtjq0GVjaztrtgyhCQ+0nIGDWxo9vrFj5mntOXsoE2IscpcPggq SOgHbjmsot8w47I7uQPNpMQu7YKDicMw3bdvBAPT1GRSWU9nqGjTx3i2semNf+daOqEvahMLuA68 EHrnpXTGVtBS0RQg1kpBqaTO10i3JWKMQACWNRxz1GeT+OM8V5zqWqXEps7mSyvFsYQZZYX/AHcs fPCKgyfm9fbvXVRfv2Ine5//1f4zdcmub5FjgkODBsEDyALGM7s5Jx/+qvO4AjXALoCFJVpScmMj jgdDQcNrTR9BfAtIR42s4xD9oknmRbG1YlUkuRnY2c9sZx0PIr9UrjTtT0AwJNaie7tbyKW6BG4B Q6NJx3wM1/X30fpp8P4qPZv8kfg3ijGUc8w01tdfi3/l+B/cv/wSb1q2vfg3oV1vtBZ6zYrfeRE5 eS2Yxquw44ByU464r0z/AIKewaPf/AbUtIvEh2C5SSOS4iO7MsckbBD3J3Lx7GvwHMKboeKfs3uq qX3Ssf0ZxnKFTgFVejop/er/AIH8NPi2zulF1plhp1ro8toxltLpZzdfa1lO7cUzlDnJwc9fwrgI 4FsN0E1yZ2VALhiPndupI7gn+tf6MYFXw8L9kfwXJ6tn/9b8VdT1eTWLyBhZ2umxWQWziuLZSjzq gALyHPJ9TWlLYQtPFbnUBN+5WRpFbcyE8n5fav8AWOa1Vj+C4bszEvbPUbqS0gkuZJIHNo8ywm2c BeD17cc49a02/wCWmnx2cbRNhQm3duHHO49/Xms68Pcsj0cNK00/X8jqdG1fWPDNncWEerywQ6nd f2gfs926yRSquwM3OOnGCPSuv0Xxt4qF0ZbDxXq8k7x7DG16kNn84CsQECkevX0618nmGQZbjKkq +Kw8JSa1bim9revReh7eHxuIpShGFRrt95794T8K/GjXre/k8O6D8QPFbxhXsjb2942n3SEASuso yDtydpwRn15xM/wv/ajkjnt4/B3xAnWZWVLaDULsXikZztgRTuIx0welfl2Ijwhh8XUpV+VST7bf dfW97+h+gyyviSphIYmMW4Prom/v8rPvqf/X+JfEfhr4qeDPCk2veKofHvhxdNlV2XW4rh4lkXje qOPvDrgj9K8esfij4kvHMdvr82ryPci5n1OWxVZLRcZKrgKMscc4J5Nf33leTZBmdKU8PTjOCdrr bo3+h/J+NxmYYHEezqycZ22/A6m5+KGp3TxSfbdUibUJhDNOl67LZhQQXKc7AcDgDvVH/hOPEdjD Jc2niO/up/O/c218sdxEg6bhlc8DOMn8K9iHC2UU04vDx+5fmcc80xc3ze0ZY03x5PHeXWp32u3k bvbiOC1ubwtBJMSN20cctgnHQc/hZg8eap9klg1XWrlpLq/85zEiwW4jPSLaOSAe5yTnrV/6t5U5 JrDx0tbTzuFLM8TsqjOeufEE9nfW9xPqN+v7wnSVW4kMSnkruyecEEjdnntXS6PDr/iPUIoLGK8u 9Uu4cyxW7Mbm8kypBEY4BbPJGOvvRiMmy2jh5VHRiklq7LbrqdmFxOIr4mNGMm29l59D/9Dw6P8A Z+/aifSbrXIvhD4xubW8tUurW4m0tnWBUAGU+U7OCK+cPiLrHjDwNKugeMNC17+0tQtxCLSWZUTT 5ImVnQN/C4Uk5GCR9K/u/KavC+Z42WEwLjKpF7W7bn815thc0yvDxeNTi2l/XqYem6pbxWdxe2t5 qckFy5hvHkuWkldGH+pJY9ODgjnjrWLovjN9PaWOzvZzZ3c58yKZvvEfdBBAJ2nkZOf519q+Hssq Rd8PH/wFfgfOf2liKcly1H97OgsdautWu7ua51K5vZbY/aJZhftBLEqgbfukE47ZOelR6tr9to62 GpXUN0v2qbC3KyyzykMSDIWyScHv1zWkcgyuygqEV/26v8gnmGJlq6j+9mtqni3UH/sm5s9Su5Y5 3US3Nz+8vA0fKpk5YDHf36VBL4i1sJfwJfMi6lMblrhSIrjeVCkGQchflB69STW6yDK/+fEfuQvr uJeiqP7z/9H837Pxe129tNJJd3WsaUrPEy6gfOh8vC+bnoVbnGT68VNNr8N7qg11bu5kvQogcidj FGF4IKjg4Oc1/pkuHssTsqMbL+6v8j+RJ47Ep/xH97JH1SO4tbDToteljsvt5vri1dykUzcnG7qO MjA456dxBJ41ls2mOjaTcXs1pbsEdZTH575OY8MDke5z1qv7Cy7b2Mf/AAFGX17Er/l4/vZdtviD fahp9gmolhd2kIihN1OsjrlQGztAXOQe1UpNeSCK3urIwwXs9yLaeCCTYXUEZwxHGc5yADx+NT/Y GW0/dVGNvRepazDEtXdR/eO/4SW9N0kOrFnnib7NbOt5IXjTd0dy3zc96tXuo7rhhvJWZdssEPyK yDls49euaP7Ay7pRj9y/yE8yxUf+XsvvZ//S/OOXWYLKYx2SMto0ysHeVpHgx2zx16HGOtao10yN uNuJoGbG5/37RA91LHj3xiv9NFkuBXw0o3/wo/j9ZhiG9Zv7xn9vy6bBbLp1ytultM37hHBmkL5O Xzk45OMcDAAqsNcu98Vs16U84GXyJLoPEBgttwT7Hg80f2Rh07qCv6F/W6r1c2QW2vahOnmC/v7C GMtDHDbXzwQBc5z5YIAya2rbUL66Zrq8vZbua1bzYpIVwYlX7pwOpAxyaUsqoxV4wV/Q3p4uUvdc n956b8Pfhz47+KXifw/4d8PPYeL9U1K7DadeXYEDWe4b3V8DDMuAoHTIFfdNn/wS5/ag1KAXV14R s7pNXkLwmXXWjCKx48plXIA69MV+ecTZ5kvDuJVHHJJtXSSX6tWPtsgyXMc9w7WDu2n569/6/U// 0/StP/4Jc/tOafGNHXwvo7wJeeckl5P527uwDMnJ+UckY6+pzcX/AIJYftc3UCRweG9DnspLkztb Lq4XzlXICS/LyOwGK/sJ8f8ADrd4RTXlb/M/HJcE5kqipOWttdGj5v8AjV+yr8dvgKok8Z+F0sLe eAwRwWFqbq1OxhjdNjBGWTjAwTzXxrH4jgt4DZS6TfMZbhpzM8K/ZYZA3zb0bng54HAr9J4angs8 wUcwwVuW/wA9PQ/L8/jWyzMKuXVk+eG/QoX+qai8cCygGLcZJLto0V4McxnGMnngY4GBxVeTWryD Zf3Vzd3k9zGsIvVkZbyTGPkJXGFPHHvX2UcrpXu0r+h81WxFRGlpniO7t7eW5lsls72d3t5o7fEM 1wgJwM+46g+nSsJPiJrkS/Z7d5bRllkgS1ubeMQw4JEewDoDwTg+oqpZTRqaTin8jP61VWzP/9T8 7b2+ka3srq4a2mvURZHRYw1uHxk4BHrV+w8RXazWjPbpeXMY3wPMDd3FrtOQsWc/LnnHbFf6hrAU 3tFfcfxC604rVlibxtqGqx3kN8ltM8vyPcQQ+QZFB4VwOMrjqKhOuTwKHF0kKxx+XDLLmW9U9fkl PK4PQDpSjlVKmuVRWhosbNvmb1Zaj8Y3sNgqyXiyCcuJZrmMTyuw6NIO/wBcVl6R4hspJ5nvYIFu 5GNsswg82KRDyCy4Pyn0OcYoWX0oaRil/wADQ2ljJyaTbbLEfjCVVk0zbHCtuzNFHBGqpOj7h06j GMYHHH4VWl1S7uYneOaOykVDHFdRQLDcBF6oTg8HvxzVRwVNS+FGv1h+ybvqf//V/Oq2kuJHtrm4 s4Zzc2RhdpeSITnHA75Gfw9K27DXzZeTbEIbC1ZleJ7fzzEGGDs7iv8AUGeEoJ2UUfxtSqVOS7Zs XniGGVI7WOzgitfLCxmMLEjY7FAP1zWO+rtZXBdCZDcjCBx5kVsUGAwU8dOKlYShZrluKdSd9yhc eIdU1GPZcS2980I8qAtH5KRc9AF4/ICtJfEBtILNFie1uImJCCMGIZHUHHB9P51H1Gg3pEUq01C1 yTTdYvJkZJri/wAQSNcCIXjRJdMAdryKDtPtkVmaZqSkykOFcSEnMCKM5OTnHPPc1bwFD+RHNKvN a8x//9b4Km1yze5kVI7V7yFfOdhap5uAB827H0rh5vEV/d6rJFeWVodPa4XZuj3S7QcsQRx8x5r/ AFBjl1Fp+6j+IK+JqKO53L6laW9z59tHtViPK8xirhV+7kDjgdqztT1w3iQQLeuYxc+ZNbsPNtGG RkEHJ9enT+Sp4Ci6qvBaFRxc4LR7mjaeKIofONvHb26iMQMEt1+4OxGOM/1qlDqskM1zEIoY/NYT LEVGXDAFTn+70OOnNb1MBQjL4UZ0cbUnJ2ZZtb7T7JDC9hDIkcy3d1b7d6O2eRk9uOnT2rLvfFrP eXcdlGbe3uwqjy+GiKdMdgOn5U1l9B/ZRvLFVI7M/9f4EGqw3UD2iBYZZH86byR5TSt3JPf3pv8A wkEmmed5UFzKl1b/AGe7SGc4kjHVSpPT6V/qWsBhv5EfxD9bqrq/vM4+IbeFbWeDTrJIbgHP2tVu Zo8HgDPI71fuvFh0x7W/hY2LRZFubM+X5e4csQBgd+fpVxy/DvXkX3GbxVRaXFm8XWt3bwztLcSX LSbZ7hHaSeFuoZm6nPU1Xt9aeK1a6hu5Zb9WYwXEzl1TnkFDwRgY59Kv+zcL/IvuM3iql7pkmm+J JINxZoJlZ3uLiCayhMcjHpg7d34Glk8W69eWdxLYxWOkyPciN47O1jBliQg4GBld44JHIzS/svCf yL7hLF1X1Z//0PgeXxdPqebS42LY28Qge3UBX3cMct19OhpZvF0iQrpmyaOzdgqSpOUWMLjrg8Dt jpX+pksowbfMoK/ofxCsZUitW7epN/wkg02dBaW/2hi/M6yeZbyq+MhVYfLjnkV2vhnwiPiBrqWG i6fdNrN/H9mgFm7ItzLINqxxKCMuSTgAV5ea4PCYPBVK9WC9nGLbdtklqz08DOriMRTpU2+dtJLv fY+1fDH7AHx+S1ltF+HmpajZvppUazNcOhV22sT/AKon5Dn7nPGM9aguf2Cf2kY2aG18B3LpG6RW +oJb3EouzkZAU8jHPXnivx3/AF+4Lp1ZUaqSadrW1fTT19fnoz9DqcGZ2qca6u01d6uxKn7Df7T3 2uB7f4YSwrbsyrdZkiju5BjaBhSykYzhhjPevIPiP+z38Yfhzpt3deJvBGv2Um9m1CZ5J5tpyXYo 7dT1PGMV7eB4i4WxteODw0oOpLZd9Nfmux5GJyXMcNhJYrEQkoLd/wBdz//R+D9Z1240a+U2yOrW toEe2liCSO8hBMhdlLBlAYcf3jnnGE0XxncwWX9pXOqT391E7RRoLeGQTocgiRiMjb04r/TnBYKi qK9xH8WOupVWkx8GtjWEknilNjeF2MV2zeZNCR0VRyMDsO2fpWL4i1vUNCk0dLLV9a1ORikl2qze TGmMF88YJHbt2rvjgcM3rAr2zj8LNO38aSXGoSLbalqFlZT2v2aISahLEzsTlmkw3y89hUuueKw4 tWluL6W+iQWhuIb6W5QHGMpk4C8dea3hl2Ef2UNYmSdrli28QraxWl7a3OqHUIz+8Y3TxpGw4BUb scjrwBUt344eJfPuNU1ZRA4kENtdHaHYgcqAT+XpV/2dg/5DKVeqtbn/0vz5utauBuvF1jXkn1C7 2xIL45iUAnIJ55I9+tTv4s13ybiZ9QuppYVWKzQTuNoUY+YA4bNf6lVMrwu6gfxYq9Ta5U0XxjrU ay3Go6nqg3b4pma9lt4E3EhTjdxjtzWppvjrVLOebytQvJxexG0tZZ5VlW3bcMOHb5g56Ajnk1j/ AGPhJJ+4jJ4qpzJJs+jvDXw1+NXiO03aTpHjK7tbtY5IbgJdeYUdd3yvjnr0rQ1P4N/tDeGLWb+0 tD8ZhLgGWCT7BJObONOQ8jMNwB/rX5rWzDhCGbSyyrJKrezva1+3f8Nz62rk2ff2asys/ZtXWrvb 7v6TPmTxh428f6Xq8+l6hrWuaPqEsCTXVoVNoypyoKjsdynIIzmuVuvHmuXfyX2s6rO68RJPfSfZ nAGDuG7JJx696/TMBwxlkcPCtCjDmWqfKr6edr/ifCSx+IqVJwlNtep//9P8mrvVp5Z5JodNtYzc /uZ3iATG08MQOv1PrWTd7ZkJgw0ucSjGMV/r7l1JUsPCn2VvuP4AVS8X6lZYLSeNEnjkRkfEs4B4 HoBVXVLa3ukCQH5opNkJHyu3Xr29OPevVUWzPnVzAt4P3nkXZffFnazcIT/iKs3kd3bxpNBK9xH5 nmFC44IAGB7cfrW2yCL5ro1NCtZNTvmHnSpLNtdlGWGeBgZr1zTvhTr3iS1vl0Pw/r+vXUD+XIdL 0i4unBxxgqm0+h5/lXHisww2Ag62LkoxXV6Lt18z0sNgq+KXJQi5Pstz/9T8qNW+GvivwpcNb6vo WsWEkVuJphfadLB9lLfwSZH69OtchB4d1XUbmaSwtZrxjFxbWkTTzzHOAqooOck4+pr/AGCp4ulX hLE05Xho79LaO5/BcKM1ifYTVpbWPUNG+CnjS907z7nwb4t0u8bJto7zQLgwXJHKou1Dkt65wM1r ap8AfG7Q28tn4P8AF8V00fmGO68P3EVqrjnY2EJIOO1YvirJKelXEwVt/eX+Z31OHcyUW1Ql/wCA v/IgsvhB4kMVs2oeDtejv0Upfxf2LelLUkcFSsfTjjNYes/BbxncCS5tPB/ihooUaR5o9AuI7cqv Tf8AJkZHQnA45Nc9DjfIKmI9i8THXZt2X39Pmc2I4XzeFL2saErLfR/19x5jqPhL+zLm1W8s9U02 5khZ/s19GYGYAjOVI4IyOvrXE3tgzsIoACwlOCD6HvX2mGxFLEUo1aUk4vZrVP0Z8XXptVZRfTf8 T//V/EC4UmCOxlAZtq+a5PMZH+T+dDtZWqC0+z/MseFbO5ZSepP+e1f7aqa6n+aKg7tFT7LDAUlC bxOSqKOqkcY/CoQTDL86KpU529jVRmlsxODa2Lt3qFzeGI7Y4fJAAaNNhJH8X1qncqPKkE0fnRyL ncR8ytnr9abeuo1Bsx4rdsERxyFo/mViOR6HNXd7rLHvdjcP8pVR933NGxcYK2p//9b8JZDcQMYH R4pOuWH3wRwRSbp42jiIy2/lumRX+3qmran+a5ZzDbzF5U3OwyCRwKp3oVbhbyMfvc+Yxxzn2p88 QEgkwxnS4kEzt5gXPQ/5/nSTvIDJLKDtVecDr+FVGWt0DT2KCTiQoNo2RtuOFwafOvmzh1Y7GAxH tAwe9ac+mgkmj//X/Ay9by28tVdyqhiAhOB0zUKrtjICFXJ4yMGv9wnJtWZ/mwk3sVbgXUDwuHdU jJZY07k9zXT6baSXqRtKPLONwLjBBqdhqLvZl250HWSsFzbW8sircBWkht3uFcZ5AAHXFbN3otz9 lnt5bGeaS3dEYR2cpJ8wD7hK8kZwcdwa51iKMJezlJJ9rq5o6FVtyjF29NDk9T0qWwuDAQ8LooDp Iu2WEnnDL2/+vWMiizmiMjF9xCuyqdpz7U4SjUfNB3Rm4ONVwl0sf//Q/CeHT7p3c21s8+xRNKqg 5ijOMtj8eBT20u5uBJJ9pggjVgv7zMUo3fwsjAEE9O9f7dKpBVHBvU/zdnCT95LQkuNFgtrE3sV/ Ot5DJte1CjytpH3s9e/SuPYXkeZJUJh37Uc+p9q6YWa1OJpp6kBgkJYPgqT83HFTrDiJ9jA5+XYe w9q1ERLBNGFPBz1A4olt47gxTzhv3L5Cg7UYdOa2jHlQH//R/ASFrNWbZnKLlV7fhWR9meW5dwdp JzzwK/3QP8zydW85ijoWVeNwHT3rVENsIbeLznRA2OctjJ5OPzoAqBBEZSuQAcDI4YZpsbtE6zBF R1PySAfOPx/AUGcp20Qya6lnMkToMu2BJj5hVWKJrOQbiWB+8VGTQQ23uf/S/n3EOFaTAMXmfKc/ vT9R/wDrq1NDGsXnq4XYmNrfezX+6B/mOU42kZNuCA3JPSo3lPEXYHI9/egrmkQzCX5Y1wEY/PkZ zWc0oikMQJyrAEr780uVCuy95ZkCFpGIHoMU0MCSqjYEPJP8VM2TTR//0/56iY3GCRnt7VSEmN7N u/dtjGOT9K/3QP8ANC72JzavPG0kUqguMgHqKlt1uQs0YbdsXa6Z5INBUZW0GwxSqHKKAqHnHLfl U2fMJUbVcjqTgH60rI1GWcsQnaO6fEYGdwXODkAdKbLJ5csnk4eM9PVeuM0wP//U/nb3PAN0q53c hulPFykmA5BbHCk/MAO+K/3NmtD/ADU50Kbjy08xIzKY/uqvU0xZ3Z4ZYLdsOSJGYbfL46GoUWyZ Svohxd1mJ5Yyt0bkA1oKhkUB2Mbp0I/wrZKysQRTxSlW2ZcjqT6CqEPmyI8U0ZUoxEYODkUEuSTs f//V/nkUMqiOOPlRlietOjufLG5oyGU/w8V/ugf5mc6Lo8md0aRQsjY5I7VHeRyRShF+ZUxjYcg+ +amSuiE3zXLMImkdXRgCAN/HYdR+VNup1k/dqSu08A9M1iavREM0hMLIW28Yyehrl/EGnxx6BqRu SAXh3wNHlZQcjv6YJzmuPGq1Cfozoy+TWIS8z//W/iv8UvENd1l9uJHkVWnD5NxtQAEj6YH4Vzat M3lyQbYlHLFByxHqK/UOLl/xkeO/6+T/APSmfJZJ/wAinD/4I/ki3BHfT3Edxv8AmVgJQDjcB1/l Wrq8qMAYi5dEA8rqGPc18uezGO9zEtnLNkZy/BA4xV9tOaeWIxpJkHG/1+tc9XS5pGNtDWjsi7Rq AzSR/NwM7AONx9BVHULKcSMY3VUZfnbO0sf7oFYwV5WFLRH/1/4kUikKjy+n3dr8EV1+j2M16jxW 9s7eQP3jgcA9ePX8K9aWklc4Yq6Zuf8ACMLiRrzcgWAyhlXcifU9KyprRoplhZWYSR7oplXdGQPU 9BVE2tuYN1thBidMh2O5iP51XhlMRjkjGRnaFx8vHrWLT5rFS6FmS+lMuxYw7t8pB7e9aFpCxkVd i9cybyduO+KTVnZjh8Vj/9D+NKPTHvYz9lCebFLiJCRliOuf89qLuBo3jiulRGPyRuBgOwHI+v8A hXo2a0Oc568hgjYI0Zwr7if7xrX0+8t7cqZoI5o2XiGTjOPespx6lKTjsa63Uc9uIWRDbCUtjsrY A/wrIu7SKHfIgZsnK7RkfhWY+dlWdbiOJYmZhDLxIAeMe9XNN1hrGYWn2K0vrQkCR5XKzR4HGCP6 0C5nax//0f4xpkilmllVFCSHBQdBmqMmn226Lyi7eU2+QFsFvb6V0WuYXew6RIZJ0iYOiLjEY460 +6tftEm2NN4UdF44Hc4oEPsbUXcayAzGNWIMvlsVUA4POMCujXQHukeSxt3uFhAYzN8in8emfYVL vsjOS99GTdpJbOGeABWBUOB8rEYBqg0nllSRlSwbcnOPalZqLND/0v42Uu1mWR4hsij4IbqfWo1u 90xYYLMAGTGFQdKqSskzKKalYts2xZIYoYfMvAFeVo1aTj3PQ+9MnurkvHFdBHaHC27oio0QxyDj rnHek01uXr3NBS93EftSJIkaYLS8swHSsmSclmTyd6/8s1HBOPelsZyTTsypJBPmE7DknAVPm21e tfNiHPzAnkt1FBSj7tj/0/48lkjk+R13hBwuMis6Ui3klkZAoK5wfl6Vg9yIwtuUtplbzApwfuHs K1NPlZCVkRsZ4PTJqXsaJXdjoPskk6i6ZfLiJ2Bmxnis3UXurO6js4Y5XknAClkKxBT3zUwSsU4N Ekdm8bOsu5ZEOHjYY+tVngkKyKiqAD8pPBFKUW3oan//1P49oPKjAimkZdy9QO9I8shxCg2BeQwG N4rnOgtQPtf7gDYxlj1/CpHnVH2k4ZsjIGcVnJNvQC6NjQp5QDF+HbpimvGdkUYKfKSSx4PWlKFl cmyeqNOOFFChTkzR/Lkgbsdcf/WqsZzDGpdCyjjKjt0pKzVrGVnex//V/kQefdC0oZE+bCKeDiiP ex5GV7r6155ooWsxl1bgKWjyDjZkHlatI6LBEqoxKdz1NBbWtya3Vwd7LwTjB7VLPEqMQhBB+bnq PagZQeZU4jcE9GG30NRqzyyFZHLR8YQfdX1596AP/9b+SF42JCqCuR8pHT61I128dqYmZ5Gi6Mck qPYV5D1dzSad9At7kh0QbRHt3OOMmmSPmTgBRnKYPSpbS3MmrSLEVxIqSPEHScpt3jgCr9pZyyRi 7mkkLOCTn/lp9f8APamdbSUbjyFtwZZn8qMHbkn1rRstON2JGiHmeYwCP94n2H50FRimkz//1/5V H066jngEMLSRK3kyYbLQsOPm9Oe1U7+Fit1DdQBGhYoDv+8QP0PtXjnfyq1jKgF47Ja2ZRCOJI5G 2gL36/Q1vx/Z7Yqk2HjABwRkE9+KBOKZHNfJ5kiBIooWYGNk6v8AX/CklnMskLMgcqoQepA7UGUo 23I5gy/NEAv97nFdPpPimTTxA8DmOWKNomkb96G3ZB+U8Ywehq4+67sz/wCXnyP/0P5ULq7F5LJI FYAOcu3VveljuELYI3kfKpbv9K8GfxO5NTqhZJIJ3eFlYvGmeBgDtxUkcK2enx3flpGBOdyPIpfr jcR2yKkmLafKzatoorgpJJDshdc4K7S3vz+dZ+qWESzxm2mSSID97EybXB9M9MVlPc02IrRjjy5I wyFiNvQqPatg23l2odPkUHgsfmaoOg//0f5Zre5tVkT7UqSBJQ0YbqCM81a1RI7p7RgqXgMmVVuY 0A7Z/CvlzoLdvpFxsMywRrCoIKwthRjnOPzrNup5jFtWMo+7CK3OMepH+eaiV1qhxV3YuR3cdtbs BBFJcSoA8bEqCe/NVDavJMJXIiUL5saA5LZ7Vka8sexoxQoI98imML8wO3qRUUiXMgMqMTk5YZxu FGxcIJs//9L+Y7TZrO3klAv4khmCKLaWVN0bgEMeD3J/DFad7BZCMwPcqbidsIls3mySd8Lt74r5 VwTV7HopNuxpW1jPNDM9rpTSWUFoJZJz+9MRU4YMg+ZSOpJxjNcnFpl1bjVZtQMQsbgEQfZy3mjG T83br6e9RTXMy5Q5VcoW4kt5rWeKW4mFvD5MDzvuaAZzhR0GTVxJw80s0yH5pCzSOuCzZ5P51pO8 VYz5VI3jZqYoJZLj7S9+7fNEu9o8Z4P0ArLjijWaa1tUM0ULEs6rgdyf/r0OHu6GDVnY/9P+YWfU 0i/cpDJJJ5gjLLgJEME5Pr26VJar5qPNJJuYgqx6E+1fIWa0OgoS4tkPkIW+bLNnBXHpV2yYSSJI zHCnJHr9aGmtwG6iDcTyOF3SEbV28YpA7rZfY+VBbczY5LdOtZOn2AfaQkr5Tkbl6bjy2P8A9Var 3EU3/EvkkSNlh3AvlYk6j09RVRiogf/U/l4aG5YtEqFypwijo3pj61ahguItv2m1ktyuGZHwWf6f lXx50F67s7Fi1zEhDLGA0bNkY75Huayo4bUXCwi3WGOFQYWZlYEkZbaOwGf1osA+cAAwqSzMdwPU ZquumR3IXeCAWzIoG0NQBqRJHpsIjt3LMh3gvy4NSWlzqSI92jN85dZlj5Vl75Hbg0Af/9X+XS4v ZpdWt8JE1r5W5GSMqUYYyTjj0HrXQveJGQkLv5s6FJCg+UAjBBP0r4xwVtDps07GTaRrY3CRBmjt klEpaJ90s/PzcEVXuftd/ex3Nk43o7IluzEh0P8AePrxVRXKrA42dh4huo2LsVEkhAfLf6sDpxV9 drM+5grviON2bCg+oPSmWodzKe0u9Omk+1RwTyuABNbyeYp/4EOM1Yj82IIwHmO56sc7M9qhxfNc pRSP/9b+Xr+0NWi1EQqsEEbW7xs0OGMgOB0xwcZp76cps5IUPlMScyqxDnPJwe1fENWdj0Dk55b4 XEVoYo5ra0jCx3btmWY5wdwx1x1PtXR2r5wqpiMLnpjBqJL3QK7QmQytKzfewgxhcH0q1bxRweYt uqF2i4R2wzcjODWSTewGHdSROJLhU+z3kbeWS64+UE9/89aG3rCbhLkyyNEFXZkxRHBPOe/P6VuB /9f+WjQNYCWEtvcwT+fDdPILq46uGAyF9gRxVuOX7U42qAquSX9hXwcG72PQM7U57fWLu/tYTLaG 3RcZXckrcfpwT+FPlubO1sGtrePdOqhJwGy24DOc+hH9a1Ta2Av6G19bLYat5UlnHPGZYZhyJlBZ CP0OQa6aLU3vPO0/TpczvKI22JuLOw4A9c5HAq5fCh3a2H6jBqGiyWltfPsuFg86ZUXEZJ+X5j7/ AOelcbqelMty93LDAl3fgTG3imM0YU/cyT7YODzz+NZiP//Q/l5m0x55Fe5VLRjAIysJH2dMAfMQ M4PHP8qwLP7LLPcQtICYBjzScBRk9vXivhnoj1YSb0ZqX0tlDbOtjHK0qkfZJJJfutjBZgBzn/Oa saRc77VorqMPOGDeYD8mSOQBWAT2KV+skMm+J2IHJXrt+lX0/wBPspFnLGSOP93g7SCelBmk3sUd MkutFvEiuJPNjniV5UVv3fPI49DU2oXFvHJEC3kxSSYZ1Xc2Pak9i+R2P//R/lvt7GbUnuJFFuLW KJTu3COVcdOPr6VYuNIafS8K0qJbuWkuI13KM/p371+fnopN6ISwuLaSAQbZvtEGIzI5++MYzWgt 4EX7NaMCyOfNODn/AGqDZKysYqzSvfTKyKijAjkLZMvHPHbFXnd7fLAEkfMWHb/PNYySTsjeCsil GJ72Vmba0Q5LMcE+wq8qXVtOPIWJEeLYmXG45yCWHb2zTmktij//0v5dYCpuAj2ouVUnEhTciNzk kfnTp7e/kZBp7x21yHHllcRlcHtxx3r82aT3PoChdWLedOr8NjczMuHZu7E/WqdtZR25V1L/AGt2 wXxtKj2P649qYHRXE0RjaNog9ybfbEzcbnxjIYDg57VykF/Fpwt21BJ4r3zwIfs/zxuTnO7Hpwc0 B6mleakWeBIw0khk3DKF417kn8quJcqbmK5S3jafdt3qAmOowR3HtQB//9P+X64Q3LZiygxuZc9D 3/Co/s1y1sUVZZHeTZAinALcD/Cvz2C90+nbS0ZWezktzuuSY5Cu1o0OVQjtWZHbBruG48xwVnCk q+HAPBP5ZqZb2M6a99GneW9lbxPJpuoautwgEZkvWQoWJB3RjHGM+/erNhcSeTOPmfeMTSsclgeT k1i1uds5e/YzXlE9yYLfC/JtDx8lT6111kkmk6PI7xr9ouB5Qu5eWnwfy9OlKnsYyk27H//U/l31 HWTcW1raOS9zBN/rlTGwHkD/APXU9skt8rwx+Ysspw923yuAepU9K/OouWyPqCUadbxmSC81EnC7 Ua6XJl7BSQMc020ubvQPLGnzGCItjydgkicZ7g/WtlvoFuhC12hu4Y0if7VfSl5JIgVUADJLdq3p Ii0iN91FXC7fUd63Mqa1FF7dxhlvVjFpL+4haNC85IGW3fpTvDMSPrpNrBOlssiFZbp/9ex4IIPO B/WuuiveiayVk0f/1fyq+HFhrMWkWGoTvC1o9y6xW8GPtKgKuGfjoe3P8PbPP9C3/BIuzutb+IWr E2t5ploEt7a7mRsmZwyPM7t2DAAA57Cv6F4jj7Lwgox/uw/Q/PeELS4/xU13l+bP6MP2ib+fTvhH 4wYRxy79Gnhdc7iixwscgfQfpX8B/wAdL3UNQ+IfjfUri6uA97qkccVrI5IjZY1BVV6KOGI/Gt/o 50bwxU/T9SPGWStRi/P9D8uP2tJg2lWCCPdLeq6rFuZfN8rAcMexIzj61+ZPinTbCRYJY42iut+2 ZQOigDAz9c14XjlNvieMO0F+bPX8PI24ei/NlC0SIpHH9mjVYzvHGCxHrXV26lmtnkhMcBBXYE5z jjcfSvw6b9yx9vHdH//W/i1tpJnvUTa8Sh/mbdneta8gihlLNGspZTGqt1BPce/SvExOx6BpXwmX 7EpSPTfscJjunSPdLPzuUkHjODgkdgK+gPhnc6tsubvTo7dnitBBC8zA+RvG3evPXjHfr7141c1g +h2IsdVtIhLfJazXUkzMjQg+WD2LDqOpqWw1zUbGWSA+RcFpdo87LwjPYnqPpXlVlrcs2FuJdkql VR0ycFSqMCM45rDW8g0qJ7mOFI7di087gmQOxOSQK5GnznQf/9f+Nm2uHgEksx3xm2+zukhxEnUb gOx5/lUqWDzXmkWyJbRW11cm3twHEcjyfLlG54U7l/Gvm6q94Evd1NOCC5D3VpcpHG0N0YoBE24l QcAZ9QR2qZZ/EQ1OOwSe2tkvCLYXRVY1jQEEg54zgYJPvULRgeqfZDLaSfYxc3lrCggkGzMYZh8w X0yckVUlsLaxsrSzWBIxbBn2nBJ8w5JY/litwsZ2qwaNpywrphuhPOoLxzRZQyMvzlWyflznArCv NNe4sN5gikliLSrIJD9pL4+VFjzgj1963oStO5E1of/Q/i3l1ILZ3EFzp8bX0lwMXU8jRS23OCqq Dt/OuU1WC5s7qGAfZ5UBM109tIsqRrjP3hxn2rOk7uxyTi76Hu/w8ENrq3hl7C8gTVGuY9QUNN5c 9siHCuMfxDOce9frDYa1qOt2smrzzwE2VjE004iZ4bhxENwHqc5Jz71/XX0eZXyjGQ/vfoj8D8Vm 4ZxhbvTR/c3/AJn9kP8AwRM1SRPg/wCHdOvkj1eF7WBIdQjBSCFxGwK4/vAoinPdelfcv/BSHQF1 z4D6rIUQ3tnLFcWZRP3jSAyhUK9x92vxDihey8VZzX/P7/24/oDPISq+GMIyevsP0P4QddFxFq99 dWRvo/tOrSRraT2TGVPL/dlN3OcbAOemCPWvMNT/AOQhH5I8mUyMbuNlwZSQAM+/Br/RHLXfCUn/ AHUfwpP3Y2Z//9H8SJ5HSZgYlSQfLDxhUPuKv6Q0DX9y0qpGzQb5yCAwZRgbc9foK/1olHY/gmk7 6ipcEXD+XFGVDZeULtfk9/Wpf7bms2mkjsnupRIBbiNhGMEDJJPof5VM1eJ1U5OMkTyytdWhM0SJ c3C7S/3vKJ6810/hi8sdH1TTp7q3sfsEVzbtqbXnywCGJ0eQgnOCQp/OuKrFWselTbdSNz+yb/gm x+0l+zZ8R/h14f8ABFpJoT+K9K0xNKmtIp4HuQ8SLGJY3U/OkmwsSDnJPcHP61XXgXwNFBDraaDD HsjEhNs4hRx0DM2M+vev86vEKtmuW8RYqlVk4pzdt1o27o/ujA0MLi8ipYqjFODhFp/Lc//S/Uf/ AIKofHj4FweAdT8C6Vp6nxY7m6u47W7tWgtYoQ+ZZVbDEsyPGAozuYehFfyratrZtER/JUifEaR2 tvsjh3Z2g49O5r+2vBLD4tcPyni7+9JWbvqknt/w5/L/AB9WoVOIa08OlyxSXz2Zyd3d3treW5gj L+b+8uEDny5F54I7EetdFp93NceXdXMSRWySEPFE4eQgY6+nB4r9vqUYcuh8HTqyd4mLK5MNybWI s8twzWw2hihJ447EUQfb7t7OGaSZpgfIiDj/AEcMx4wev61k6UYq5vRU+bTY2ru1hlhs7fUb0SzW c5YhX8sIwPYZ7V9hfsYXJi/aB8PR38H9o2120Ftbx3D8l0kDYD9geAfwrxOI1y5FiXDfklb7j63h ejzcQYPm29pC/pc//9P+yT4feEvDk3wrsZLPw9BBHcae6+bCZNkpaMNwck98D6d6/kY/4Kz+DNJ8 NfGgarGG0qz8QG4svs8uWit0WANJJvIyNzbhnngmv3LwixNdccuFV3u2tfmfm3jRQSoYadONkpPb 0PxSu5Y7uxGmRajdLZ3F4jRC0by4yqH5WY9Mf0JqteRRXTw6foto6yRJma6nbO1wcErjt35r+24Q T0P50rxk5XReGmXMUDPDe3P2iFQWjVvJW4bbht5Hb2PFFg+pXvlWuqxobb7N5j+Vcmd4OchFOMDB zmtIUo2HJySVjSttS27LIySZM3lwSyDIjycZ9K3ZpDaXkkVrfreQy25iVpotuWdMHCtyCCSB7gVU 6XL0Lp1Jb3P/1PyKto7Wxu/3cTJPGhs2CDLhAen04Fa+kazb2eomO2hGGbbIsuJVwwwxK9O54r/V dRSWh/Fs6jehonTdPur6SezgKxpIX3Fiu919j0HBxioZr24F35doJIpMGJjASC/bAxRyohzZkM27 a6CN40l2sGPzBgap3ttcXd9HcxM1olm/ntGylIQ3BGM9h/npUVNJJipyck0jq1h1CSOx1R4RLBqL mOKUkZbGMyBeuOR+dZ+oyahd6i9vb3E8F3FiNvJUKTlcbQMY5BxgCpSWwnJ2sz//1fylhlvLZktb iF28hB58VwNrnsSferF9d21/BBBbrJD5LEvKjsrMT2Iz07V/qlFJtpH8TqpZXM6GN57gwJMouLf7 58zBI/r9KfJdoJZVuowzpgQNGvzsy8DNFnY1VXTQng1G3Wa3s7tZrRwTK6S5BI78enzD862rPxLG sV5BYSNFIV+zOQud6en0OKU4NxdzalV1Po39mn9oq6+AfjDQ/EFlpmnXf2TUVur77dGfspjDguox kgsFXPTgHkZr+2n9kH9p3wl+054K0vV9K8MWVi1pZw200NrGJoIpSucqCoAHHQdPzr+W/H3IcTy0 s8pP3UuWXl/Wn4n9J+C2Io4zC18BLSdP3vVO/wCX+R//1v7K/jR44034U+F73xLc6fZsthbrMGew VkG4suCByeQOB61+avwi/wCCovwz+IXjs+DorLw3c3d/fC0iRNKmsmyCRyTjDYHRhnjnFfccN8O4 3O8BXxlG/LSV2Z1s1wuH4ip5PWdpVNvy/Q+4/jz+zV4S/aO8A31jqmnWVu1zpc6Wt1a2qGeEyxg7 QwIODtXoeMZHIr+Ln9t79nCL9mT4gQ+Df7a1ifT01ieOzF/bKkV4GjibaXABG0yxkYJHz49Mfrvg VxNiqeZT4dqawd2r+V/11PxrxoymjhMZSzSlvP3X8lp+CPjO4029hW3k2iWOY55fkgdeKzb2+s7u VNPWaWCWH94BGh8sdjg9D/jX9dUpp3PwqvKWzQR6xqKTIkttayLYx5gXnzJTk/M4x3/GqM8D6m02 oXLyJNJL5jnaMJ6gAfStlNLUzk2lof/X/Ly+vhJKjWyypZoRFIk0e3zuBlhn+nFXo7tzFMtrFMoa Ha0qL8wXuAe2cdu2a/1SpvU/h6s37JWMmOS802GAWiMLUgpsCZYjFaisb+0WG88tZtokCo4Z+Dwf bp0NdEn73mcseaxlXBngCwzNlpflVDjdj1z61R065ubW5Sy3MzG8y1yyb1jTPQAdR3PWsZ3urmkZ SUjrbiWCa8t7n7BBPeyHYLlUCZx046Dv6daVtUlSEHyGuriR5ITDFD5giBGAeOxz+lJ89mjbnk07 dz//0PzCh1G9ztWEqrACNQNpXHbHarq38o2h4vmzgns/1r/Ux0702z+M6VSz5WaSnUp5ZIru0jt/ ssYO2M5VkxkMT64Iqi9ysIld7nbMu4FJMFQh4Cg/n/jWGHT5ZX8xVNGQ2V0EaQeRHHNKD9nRG2+c BxuI/vDmoPtl40bo7vKYn58wg49APpWeHk5VZJdG/wAxSs4O/wDWg201S+gm+1QhjOr+S8bcq4PG dp9BToNaR554RGQwO1towFPc10Sm1V5X2X5nHJJysvM//9H80Z73ZarHNbRCfcWjukixKyn+F27j ocVnM8k0QdCoO7K/3hiv9VIt2P4arRTg0VLx724jA+1SWxRhtk2jjBGQfbgitv7EotlDTIGhXzQ+ 7Z5h9vUc1Mfjujnpq9SzMiNdWeRPKUhTJ5lwycxPH79z0/SrDAxaghQMskg+9gkDAxWy9+1y6Ctz NFo6jfHzLC5s5baZB5rXL5/0mM42HHTvn8aigAI/1b/K2Nx+8/uDWnItmzRRurn/0vy/ljuLCYXE hnNu85SOZhwcjlQehxkCr1pfS3DtLA/lH57aNpgRGxIwc+3Nf6q1LxlZH8MxWqMvVdKsZr/y5PIk ntZI7gGM5i3Lgqy+1aez7dbtBPGuVwYnzwRjvXVTg+WyJnBXILDZDHd2L+XE8RBUJykwPcnoCKTy 7hR9nhXzmDfez9zJ7fnWvIlHzMpRtsZ07wWscjTPJLPZT7DFEG3liM4wOwBFXbO9mu7Uy27SQqp5 YLh1PoR2p04+7fqZKVpWP//T/LkqtxMYZ3UQGMtIeQzMDkEkc9qoS+Ibm+aOGCxddPgnKNcRxsQd p2ks3JxxnA6Zr/Wn2cXHU/hJzvsbb6i404zQESLG2xBGu52I7AfhXvvwJ+KFz8K/G/grx3DZzave aZdperYLzAhVwSrp/eO0jPXnt1ryM6wKx2WYjBdKkJR/8CTX6nrZXiXh8XRxK3hJP7nc/tk/Yo/a 6+Gv7S3gfTJdF0K3t7u2tksb2Io0ciTsiuy7GUE8NyVJGSec5r7A8b3Xh7wfo8utTaTZi10+I3E4 MZbcAyg8c/3vSv8AObO8JVy/iP8As+q/eg1F+q0P7EpzjiOHVjIrSSuvQ/Ouy/4Kbfs+ah8QP+FZ weGbD+1o717ST/S2ikkdWKttTbgEYPX0Oe4r66+K/wAGvCX7R3wpWwt7aKwS9tGlhnt8JIjPH03D BYYbg9foa9jH4XMeFsVhcRUk41VJVI+mltujtr5aHh4OpguI8pxVOEU6bTi/Xr8+q+9H/9TH/wCC gf7Jni79m/xc9zrEsepeHroyImqtARcFm+eNXYADJGcnA55HXNfnJDPB5NrJaxMsBiEhi27Q+7Bz x65zX+mHC+PjmuV0cfDRTUXb1SP4sxmFngMdUwlT4otr7my9YT2a3TmS3kiWKJnENtJsdnOcEg5F Q6jrEaeSJ0YSv0SQZ2+2fxr6ixkZbX0EUJKxrGxbLb1xx1yKm0nGqSO8t3DBHGcImS0zjHZR/M1V 3GTQnyupFEl3c3Fs0cds63UYykuJMyJjgZHr1zVW1gimuHuW3biuMIcEt23DvWkNhzcUf//V/MLV b288+1lkuPO8hQVjdcNDgkDH5Cp9SuxbW63JmJfUPmxnaImAG4D09fxr/Vyo/c0P4nWhmC7vPs7e YivFJjIBG7g/eq/ot0bDVbHUIYEvUtLyO5e0kISO4EbBigY8KTjrRTd6ehzJrnSP6/f+CYf7V3wY +IHw18PeANd0ZdG8aWMS2N/p8cyXkUe3KrKXPzbWIJHH8XXg1+zmu/DfwVqnh+Y3eg2tzb3luYlk SBfM2PwNpx09vev4E8SMLick4q+qVJa87a9HJtfh5/M/sLh50cz4RWMpx0cV99rP8T+Hr/gqh4Mh +HX7RGzT7Z10jXdOk1KO3kRHmhCzSQHoAQC0JPPZhX5da1eWctgJ4/NXUYrnyjDs2oIWUHdn64/C v794TxMsdw5g8XPedOMn80mfxljqUcLmGIw6+zJr7m0f/9b8dPNkMkcscjCMjbtH3T9afeXv2RcW +xnI/enua/2LoU+WCSP89edbMoy6sogjViVd137SOagguw7x7jnLZBxj6V2pW0Ep66l6+ikmNu8a Ajd8w6fjUM5gzFabCs55C9APenNWXyLpT98+ifgD8FvGXxb8RW3h/wAFW1lLqRuESWS6LBIQ7hdw 2g8+544r+zP9gz9jyP4K+By/jnTLO61G9jhlMlrsmWeXBLOWZcnBLAHA+nav5Q+kFxnLDyocN4Cf 7z452eq0tGLXnzN/JdT+hvCTh3nwtXPMbD92/dhddtZP70l95//X/bH/AIKdaz+ylonw71/7fd6X pnjO10i4zKmnwJesJLeRNhYAFsHbwfXHHWv5SP2YvGXhTwP8cvCOv+LrRdY8ERaulvaQiYQvHG0m 8SSq3DkKv3D1I7V/pX4ZUc1reGMaeMnerOFTk6NJtqN3a973aeujWvRfyDxBWwdPjmpWoL91GcL9 U+Xlv/kf3gfs5L+zL8XvBOi6n4MttF1O4bTkNyk2kxyTgEADBZSCe2R6V6/4o+Cvwb0G0N/qGg6f 5UfzvG2lQrbovfCAYB98d6/ijPM2znDcRPAVa0r3V1d2v109T+qJYHL5ZBHGKmkmr3sr2PnrS/F3 7Hd1rFx4c03UfD8l87/Y202bSIPMjlHUdM5BHccV9N6R+zT8ENU0W4vv+EU0ae11bT/39zFpUSGd COhXHH5VlmuZcRZPKFTEzlHmtbzMcBDJc4ws3hIpxtbT7j+PT/gtT8D/AAV8FfiFHe+DtCFi19Ms JNlaqirBujl3bRwnycHaenXrX4TLeQapKraeCmf+WjrsAP8AeOen41/on4S4+vmfA+BxWId5cv8A X4s/gvPYQw+fZhhafwwqyivRH//Q/DzGzzGdhLctkOFOd3vipLWxmu5EWNVLEYw/AWv9sbWR/mku a7sQyWpEyFjIJLdyCmfkz0OR+FLPb7nGVJlcZOBnYB/Kok7NIundqxCba6RWuAgeFOp/hHaoGWSf e25wMYVMfJx3raXLczi3ccWuo4HKbSoAypGGbH+elVppfNhad12XRZVjEa7VKgYJPvwP1qpfCyoP of/R/CiMT3UayElxF0J5P0FaE8CwWlvcjzmZ8mQOgXyx2x37V/ttBtrU/wA2Z+7BWMibU45rQiWw mF4spEcnmDynQdPlx1/H8KsQh5ollK8bcMpHTrWqir2ZK7mXJbvbahBcDeUlYKUH3Ux6j0rYuZHt pRcx7JYtnMRTdtb8/pUt2bSK0ckDywX5jk8oRAxhpXjj2bug5H41nTywwKVhDN83ykj5vpXRFe7Y lyXNY//S/CJJ1gLNeRsXaHagXCnnpmqJk82NY9gWZnOD12qK/wBwJJWdj/N2LurDxLDtIALvEMB8 Z59KufbisIcMiSQtHI4LbI3XcC6k9sjI/Gsb3djSEbpN9j+mL/gkL+zl+yt8bdH1M+LrPwvd+NtO 1OVYtM1q9KOsBjjZJIAWAYEl8sM42L07/vvL/wAEs/2W9StSsfw90SNm5knhlB3ZHBViCT6/er/P Xxn424myHxCxNBTaimuW97ct3y2WnSz+d9Wz+xPDvhTJcy4No1uVOTV3b+a2vfrf7uh/KD/wV3/Z Q8GfszeOlufBulLp8usXjabPEJklhkRGVhIi45AHccjdjkV+KfkO8oR8tKG+RUXIH4V/ZPhRnOIz 7gnB5jifjat8kl/XofyJnFNUOJMxwq2p1ZRXonf9T//T+Tv+CYPw8+EXxS/aBs/CPxhm0praS2N7 pllqc/2W3mkRkiVJMkBziR3UE8FPwP8AVZ8Tv+CO/wCyr4u+H1/L4Y8BaJLqN1pbT29/Z6hJK5kV PlcKGIAz6en0r+/PG7jjPOFOP8LLCycaKjHVXXZtaer/ACP5u8P+E8sz7w+rXs68nNvrs2k/uS/M /jT/AGvP2YvG/wCzx8TNc8OaxoOr6XoEepyvp+qTQH+y5Im4gjWQAthRGeWJJzXyFd2U7RWz+cki NGWCqSSmScD+vHrX9U8KZ1Q4gyDDZtQlfnir2/m2e22utuzR/NONw88HjquDqq0oSafyMRZZ5JZb donQREDcRjPH+RWhbQXUrrbQ2hkVW3G4DDKjHPGc4/DtX0qi2cTk1IdfRzRzeQ+UYenpUMcbSQNE JOA+MNWwudn/1PwHgto7afdIm9ACCFPt1rLUXUgkeOMqFYjd7etf7o2Z/mQ23uW7S4kgidVgEhch XGOf89aa4E7qsKSltu4IFOfyq+TQcXa41FvJoi1wzqYm27H4Y47U/O0xuVKhecHnJFKC1JEklMrt KABk5OBUUyXIj8yJdwJ+bIznmpatowP/1f580aZWBfAC8kHpUs04nUqqkBTn2b/P9K/3QP8AMcfb yoIX3tglgIxjn8/89arlIkJldWLFuuflAHoKAJjE24FlPlsMqcVnME89sRggN91vvcUASxRGSQrv WM4+UMcD1xmmGFlV/NUrjIZvpQC02P/W/nytWtvLypQYX5S/9KrBGF1kIhRj82TkD8K/3QP8zxF/ 1juV2LuwwA2gH6U9S0eZUJG7jb/eFAFv5HZTDE+8x5dd29uOSeB/+qs2VdpOMqScj2oLU2tGLbvD OkqOCjI3LEcNUQXBdEQZ3ZLDjdQOU+iP/9f+e1rdrtYwkZ3qQXB6H1qG9hiExdIo4SFCMqDHA4x/ n3r/AHQP8zx8VsZI5TE8YKpkBmxzUMMEvksJCqsh5APBPtQA1QJU3v8AIQ5QRkYY47/SpmD7CUOH UYwxxQZyl0RKkrW1rI87gDGTuPTtVWF/NyccEcN60GZ//9D+eld0Tlwm9gDkMcK1SeXDNExIIkx8 +0/Kp71/ujZ7H+Y4sAkiZiAJ8RbUBGTyKqx3MpKFozEzLgxMQdhpW6BfUuK6gbtxBzzg0kslszgw FpCmAWKbcnHI/Wp5IlcztYs2zRbwLiPdGx+7jNSeKItMu/Dd4UDZiUAxsu3au4Bufyrgxsf9mqLs mdOCdsRH1R//0f4wPGdvpKeIb6ISKbsTlX8kt5TEAbR6cdK5D7XBZnyfLJbHQDAGa/UOL3biPG/9 fZ/+lM+SyLXKMO1/JH8kSxXsUUpQOwZxuUdAfpQ915suCvllGBV85DfWvlm7NI9uDuix5ywzkKkb FwAx2gn866fwnDrOta2um2lnLcNFEZ1aKFsLxwCQD+lc9VqzbOmhSnVqKlTV5N2S73P6Q/8Agnp/ wRXvf2qvhHqHizxfPqeiX97FNeRWttB5L26OP3RKsNxVxz+FfjT+2t+ydrX7Hnxj8QfBrXBPrw0y +Oo6Lr8iMkq28uNkcqnoy8g4yuQcHivGyTGVcxr4qS1p020tPl/k2d3E+BjkWKweBqL95VjeXk9G /u1R/9L+KiSG4j3TfZ/NUgtEpIUS7fc9Olf0S/8ABKf/AIJc+Hv2z9FvBq/iqGC8gQTyDSFgle08 9htGMljs2bcN1JJyMYrDiPHV8vwCrYde85KPomm/0selwzgaOOzF08R8Ki35Nqyt+J+9ep/8GwPg O80ydV+KPin7dHY4toF0mAW24gH94NvIPpkZ9a/lX/4KQfsFeIP2G/ienw/1CX7bp10Hn0m7+zPB NLCZNi7geA2SeASPlOK9DJPa46lUqN6xV/u3Ms+hSw1ZRgrJ6flY/Ku/jAd1wMI2P3g5eqEk6RJ5 aRQyMzAgIQvJ75rqv754slohT9m82IIXSR1O5gNys3PH8q774Z+ELj4h/EHwl4DtrpLafxPrlto0 t1IdsttFLIqOyA8EkHHtUV5qmnJ9Ff7jajRc6sYR3bSXzP/T9M+Cv/BtB4D+IXwnsdfuPGOuWGua nZw6haSx2NrLbgCJVRSm0swYfNy+cnqe/wDNr/wUg/4J++Kf2Kfi3beA9S1M6rpV0Z7vSJZLX7HJ P5bbSG/hyuTgAnODRktepmFGdSb1Wp6nEmEw+UV6eFitW7P+vU/L/WbT7JIFlMjSEf6plwIu1c3K 8zLt3lCmNnqfpXe97HjKOl2WrKS4T5pZZRbxvuMW0neen19Old8ktpJYnYimUKGA67SfWlyIg5q/ aSEFN4aR0+bjhR6CqUKwRxkttEkg+baOvap5U29Qbtuf/9T+Le2mjgLmTku21BntVh50wcRsrDo/ c10tWdjnK0dwUlZpB5zY4djyR0x+FTFnJyJCiHlwvWnGNwP2L/4JdfsG2v7Z/iy/0PVvEraTYae0 aSabbPDDdssqhhIN3zMpU5PXG4cHt/S7Z/8ABr/8MZ7UN/wnPi6N7mASQR26w+RG+M/NlTu/Svns RmVWGZPB09ErdO6Pt8HkOBq5HTzCv8cubrtZ26eh/Pt/wVa/4JSat+wxc6LfWep3us+F9ZvpNOCv YC3IuFy6FWyQNy+jDJB4xzX4cfZbKxV7ZJZZ7mKT50kTAAPP5+1fQShKMIuXVJnx840/bSVN+6mf /9X+NcW9xLDLJHCRGPmbC5EfPGayiX3fKuGQYc9N1az0ViWveRpQNPJEJVTcyjaC3A4pLuOU4kOQ chsDk/Q1Encotxuxhzj5mIUjoPrTTHIiSSkbvLXOMYwPapE0nuQQyvuZlmCxsnzoI9zk+x7VCvns ZHWQmAsOG4YVDla6Gf/W/kIs7SJrcThVDCMZPHpmuavwZrmSE8Kigggfe4zXOFi1ZxpujVx8mOoH ArrLGwjdpWCIoRN+QM4A6kiiSsmjelFNo/UH/gnr/wAE9PE37avjBvD2oWmpeH/CIkWH+3I7ZluZ 5TlhHArDaWOAe5A/KvSP+Cov/BMLXv2FpPCl7LrV9r2g6pceRaXE1nHb3AKhSzz7QOFDLjk/fPpX Hg6zxONqYentBXf3XaPTzDAfUMuoYuqmnVeieml7J+j3v2Z+L0tzt3OykFn+QnnIpnmKVaRflZuC pOPyrsseaf/X/jouJG8wAruIPTHSumtbWGS1DTSqsvGyHHzY9a57HQipcQoOUb97GcDB4I96hij8 /IJXzE7cZoAnRxZr5LSbpGbcVHPWtbw/4X1bxb4g03TtA03VtSvriYwpBY27XAQn5d0nBAUZzzWd WSjDmk7JCjGUkoR3P6hP2b/+CCg+LH7Oel/ELxXqd1Y+I7jTHuLcy2JTyQEwN8YCsrBgS3c+gzX8 7Hx++HN18Hfir49+GmoT29x/whuuSaWs0MBtw6Idowp6gEEbs81z4Gp9awssUnpey+65eKofVcWs Pe+lz//Q/kUa0hWFS67gwyEPQelRWshDOzKREOCP4vwrzr20OixHNN50gFuxZWGBjoakja4XMTRj CnBPemBrmaRAERQ69VLDn8qoNIJJz5mUHTA4DGmk3sA3dECSUHB27vSlkgDbUiZlDjIIH9aVraAf /9H+QzzbqykWKabzQpxHngY7CtgqDECWVpXGWA7CvMlDqjoIEgUSrKBuOMFSahaG58xZCDhcnHRR XNK1zOUd2a9vFPMuUKIgGCOp4NaCagsKSRtlQMLGu3IGK0SvodXJ7quS2tv9v3G8QeQXBBb+LueK /U7/AIJw/sg+E/2rfjTo/g/XvFFvomlaVbjUbnS4rmOC51ECRVSNM+uCenboTirmrO5ai2f/0v1b 03/g3T/Zi1ezhnvYNSnlv4hcq82peVJIGGdzOASPbA/xr8Lf+Ctf/BHnwZ+x34bt/HPgrVrrT9Hk vy10twg1G25XareaSHzu2rtI5DcYryLHpcrR/N2ImW6ZXIPlJsW4Mfk7+fQ9M+lIts8twsxXzTAN q8ZXB60kr6D5Ha5eube2ureLEPkTQuRx9xxxVWOJwf3eGZAQu7gcdq3skrGMo32CCOX7IpniO93K yIx6Dn1qqkluGaCC3eKOI8M3Rs8n/PvUSV5WMKlozR//0/5SsoUxt2pjHPrUE2+HyoCyf6RzE2AW UjuK8Go/3jRTjzXZYjgKMrhpCwG2bKYB+nr2q2YYpA8csbSxsPuPyD3qR8jLt7fTXBtnjDwlIRbJ Hj5CqDr9f8TVFpJnIyCHHGegNTKN2VGFtWNtGkSaRJN28/MoA+T8DWlLPIYsNuQqduB8wI6cVm4t Gygz/9T+Vma0aRN8Y3bR93uaktrG4s4A6SkK7ZWBjhIjnt9a+ZUGdLi0bser3lrCYp0iO9NgCEtj /aP/ANascXEkt5bJGC5csx+XIG0d/wAcVNi4K24zU7dCsc7S8wzBhFCx81iOMEDtz0qeK5V4/NdZ PtCnCnGFx7ipUUjdQbVzYa9F7bqZEEJTEYCDAOO+K9V+DHwa8c/HHxjpXhrwV4c1TWpbo4nFvGVW 1U8JJMOyE564JxwDzTkjWEbaI//V/RP9iz/gh9+zdcfCPwxf/F7wJoU3i640bdql1e2kyXEr5Y7u SFViGGWVVPy8ivqy4/4InfsPvxL4b0BXjnWSGG2uY/upxtZgwOD3zXzVvcPW5XznRN/wRI/Yv1bR L+z0LwvoVpf3tq6R6ha3L3t7bMQV4fzCEweOQa/lY/4Ke/8ABNbWf2PfE9/ceF9C1B/BkhZpLp0a W0tmbDKykA7hgk546+xxFGK536m1SN4L0PxO1BYNEOnW+oXqGa7dUku44W+zRFzwSPTpivbvgb8E vH3xw8U2Xg/wT4c1fX7q81qOynvraxJtLSJiCzhsdcHGSMZOMitaq0t5nOotH9Yt/wD8ERPhJJ+y tfaxpuizaJ8RNO8HNqH9t5Nvf/a4rczESozBSrONrcAjd1JHP8ifj7w2/hLxd4o0Wa3ezg0XUZLL fG6ym4aLKuwA/hLKSPrSSvCxzSXvWR//1v5j7S2tdRuSI5NjyJuEbjywcd+f61Q1JX091VGwA+35 Dv39vxr5drU9C3QzZJpZJflBEipl1HGR9KWCZum113nGAMEVE1oZcjvY2LeeF9xZmV1wo+X7w7ml eOcR3FxbPG4CBFgkwGZueVH5VkaKKWiM+G4a5UTSRzLPB+72yoUKEcEAVYt5bmUsJ4owsWWj+Ug+ mWP9Kdna6G13P//X/mNjvpvIaCQwmRzxJHEFdQOOvJqIzm1iRJZZJVVshn5cZ6jPpXyFnex1OLW5 PdbZbSSdGCAIMIc7pSOeKydLhk1WYKiZKZAweAR2p2aWpUI9WMaKTTbi5hnnaV0cAAptU/Q1ahmu LgptiaONepK8N+NJK7sJwa2HhlE00b8bI95dgSo9h6nilju9PuEWO1+1rK8eZjLEYVHUZXPUH19q VraFqCR//9D+YLz1AkRbUs0Y8sNtyHz/APrqmqyWwVFidSW3MV525r4872k9yx8kN1GU/wBI3RZU lf8AUEjkH1qdmgi2z9JO4VdoX/OKLdAlC4yd0nlEQ3bmTcXjP3vaoniUsqEkrxhG5wf8igqxRfWH tpY9NnRXWS48uDyh5kgz3A+g9cVJfebbRgEnyy2VdRz7Zot0Jbsf/9H+WiK5ZZSv3pAu7cwwf1q4 bhriABpJIxJwH8sqw/A18e10Z6A+ysZJXWAtGzE/LJJhFIoNvJHPIN42AY2KOBWcodUBE84U+S5T 5gSpdguMVUtpMbpBMg28YZhuGfQVmBGGTzSt3amaOUf6zb8o/CtmK+0ydHtZJLWCZYQsFs0YVmA4 +UAe3X9aC4LW5//S/lokCSTeRt2qF2o3YgdqkBFpbmKBN7l8YB+fJNfDJWPSkrMc8d9HMYhYWyRe SrtOZC05OOcDHH51W/s43XzM7K2TiNRhiB1OaZJag1eZp0t3m321vAbVISoMa49ux/rVaJrprkDT 1PmnOIF/jJI5zjOR7etU27JAXLi4W+MlhLdXK3Lx+Q8jzb5oyPTPpUmrf6POmnxm6eZbaP8A09lH 7xigyQRx27VIH//T/lq+0XVuhhkMkjSD/WMOFxgZJ6ZNZctjDbmQogkjuvmkk2/eJ65r4ZrSx6kF 1LkwsESCG0Z/LiRAzTKA5O0BgAD0ByB7VHb6gYNQt7dLaaWIks0iKDCBjHz85GTgAY5rFprRmjV9 Ga28XnnW8Ee+7B3bP7oHdvQVEsiTwSMkcytbqFuJVTMbDpwR2z60gtYx1mVp5ElMsixpsjjbk7ec c/jRLcLqENrbR2kVqsBKGQsWdx6n9OKAP//U/lptZ49OhleaTEe3DnooA7n6VFJf3N0yQWmqSw6Q 0e+SHaCk7Y4OO+OMV+fnpxkk9S5YW15b28czRCVBKV83Oxnx04/wqrILqOaYiVYXZiy+WcbweSrU Goixwlka5kTz3X9xHvGVPfFVn1HyblbeVsNIuxVY4EnsDWMviZcZ20Zps8MMIMEW3YAzxE9CTnIq u11bz3kVxOHFu0Pl7FcptcdHI7/SnJaXNT//1f5atO1m5mhvfsbxQrCzwor8PJk7d2f8O1S211Ja 7XlczTnHzsBgH6Cvzc+jjFPcW91ETljKd078sF+Udf8APFChBEqSSgsTkSFcvGPQfnVRjd6ikrMx Uknnt7tHklj+yhpWeQbGTaeCv19BVpNJk1e0tb1opYlnUx2ruMeawxk4q1DXUkr2EV9ZXCx6hCYy kpQLnJlC/wAs4pVnCamkv+kReWzXEULQlYXxxgkjB6+tQ42diopO9z//1v5bm1ACSNQJI4pMvLJ5 R8uHB7t/SmQardpcRkQyyWsZbZ8+1VbjnPXnHUelfn6VtEfRzd0mivaTXh1O2s5Wlks5JWuJVQea 7FgSFLHoORgVHfyRxX80MfMkcf2l7dAdyqCQTgfTpWUmuYcJKLNhJbfVdEgu4o2LmRi0gXEYAOFX HY8HP1otGaGK4tJScHDvD0wAOD9OTWE20dD+NWMe1uoRqG6CFcLKIbjJ2bMd/wDPWu5t53mhkt7m SMQ79yrndgf406exmf/X/mHubGwtzJ5ciSJK2d7jaz//AKun4VHeamdNisHjKW1p5vls5iMglbA4 Ldu2fwr87prqfUFjUIpbq2F15cc8THMsYYLIFP8AEPzqitpcyTje2LWNVW0hBORwclvfPAxWsd0F izd3FzZy6aLR7aBxNtmknQHC4PTt1wOelTWckslosqkM0kzxwlpMRyMDjG7sOR9M10x6iimiGa8u JlNpcKLWSCbl4WEn1xkY7eldd4aeKbVoIApKABgdvLncBx785rswq5qsIsrEe7TcvI//0Py58Bi6 tfD2mW6GeWNHRxukxJtyAAzf7q9P8a/pc/4I6W17ef2hJcLDDLJrRSS4gjBjkigkzGFfuGX5Tn0N f0BxrL2XhPhl0ah+R+e8ByU+OsWnunL82ftd+19dTW/wN8ajTRi/uNPkjjkGcQoUIY+3YH2r+Eb4 ySD/AISe4u0hklluLpGkYQFsyRmRGBGMAfd4brXu/Rtpt4TFS9Dj8Z6iVakj8kv2vbm40HV47DVJ 2iW1uDMkDD5pTMgaM57DDLkepr87vEF3amXyjJ/pDoJWjON4zkhseh4r4nxyd+L3D+6v1PpvDyNu G6b8zntOmnLvDJEJFZ8q/wB1lx/SvSrBIJbK9WRmS5VFe0UDO3HBHuO/4V+LyVoWPskrTsf/0f4u 9GMUsciiUPNG5hkkk+XYR9ant4Ge4kN0wEay7UEB8zI7duteNiVY9A1XUT3H2T9/Ikaec7bCxCjj Gf8APSvcfh5LNosUj2KGX+0wIpllX6bdoPTG0c15FWJvFWSPUdQ/te3gluXnim81AI40ZXlhPpjr n9K3PBmg6Rrk82maxcT2zTREvdRMITA2OHBPHBA4FeZWSTsXytNXL91oN/p+qX1lrGpjW7WOFYbG 6VAu6FVwN2OM4ODjuDWZJHpU9pNCFgWy05fJkHAIPp6kj09q53Hdm8Vd2P/S/jNtLhZfKiuY447q ONtyKxczDcdpIPtgfhVwRNdSQTNHIGgmwE3GPcc4x/8AXr56om9EU1ZILy01LTJ7eC1t5GWMvc3C ibf9nVhv3BuSSSf84rWjabWrSOKM3UUh+7dom2SNlODk44zzzWLVnYrkWx3vhnVL/wA24s5rqHTZ o1aIW4aSSDUFVflckDAJ54Pc4+mhc3Gg3liJ3k1OTWo4ZLeexNs9oiOTlJQx4cYxjHfPNbhy3ViX T7KVwunyzvewWdurLd3EYWWAHlgT9enriuW1VP3k6WdxLI8b7Y02bACO/wCta0fjFKNkf//T/i/8 V21rNLJFvknntF814lTZ5kh5OfXAJ/GvOZIZFby4Xe3QS7pI05eUnqCPwrnoK+hm43meheB5YofH Wis9oS4KyPJKN0iJEyy7QOxyAa/Yzw/eaxPo2l2guIn0y+s31FrW0CQQW5ZGRUCjv8oIBPG78a/r r6OnvYHG0/P9D+ePGG1PNMI/63P6+P8AgidrsP8Awr+Dw41zqFt5t9Hc6dbxhZLVwiR+Y8pxkEOJ MY7Metfrv+2lpy33wh16aWFne3tfPtVRhGiyR5fzC3YjZx7mvxbxBi6HifKcf+fif4/5n9EYj994 a0U/+fSP4EfiVea34a8Z/EzTZLm432fjnU1srWUBguPLlXyhjjJkJPODuPqSfGNZni1tNMvphLb6 goR5hGdhkcAE+YMc4IHHrmv9B8j1yrCv/p3D/wBJR/B+KThGS6pv8D//1PxUjubBtSt21GSVlt5V llRceZLjr19a0p7ew1P7ZdRHyHRvNtxGwQx5PAZe4I4xX+tUk1ufwNhr8upQt4oIo5Hup1jI/wBW CcGdicBRWZPfyGBhHEimIkuqHceD3qbHTsaOna1Zz26Q3VtKZJgd0kJ3RqMDbgY//X7Vr21tcTyy m2eP7GigbGIZvTkf561zVI6NHqUL88T9Kf8Aglrc3WhftDPDFo8lyjfZLyCS3RlWMPKYpQMdNwzy P7h9TX91FwTdeEbe3CfZ0m0aJ9i8sAVDMG/AEH6V/D/0hqFKlxBRnDqk2f2R4bVa1XgSnGp05kvS +n+XyP/V8v8A+CoXh+bSf2jlNtdSKvm6jPPG0hMdwnySROoPVszyEj39jXwB4b8L33iKKDTbQSXW tzys8dnAm9Wjz1LdiCQMdORjmv8AQjw8dOnwXgqu0Ywu/vZ/JOb4etXz7E4aKcpyqSS87vQ9t0L9 jz47a5pN5qWl+DteuImhf+zHvtN2LPIvOxWVjkN0UnHTpV7QP2Nfj9q8dsl78NvEdjbQ6gINWkgt pTLeIAfktgVALA47nr1rtq8ccOR51PEL3fJ79l/SO2PBWeUasKc6NnLzWnr/AEy7qv7Gnxs8PfaN TPg3WrKP7R9mitb3T5A9tnITzXXKgsvXBNfP/jTwzqPhS4Gk39rHbahasBc2iEtIrEEgqe+cHn2N dmTcS5Znk/ZYGd5W1/r5+vkRmnDeOyS8sWkot6a99vy9DhdP0d9TvTbYWCS4PnPJNJ5eSABjd64A FfVXwP8AhJ8bvEerWGt+AtGzLpmoqttK9xPDLf8AGV27EJKMM8g84GM9uziCvhsHk1Svi37lrP56 f15HXwzQxGKzijTwq99NS9La3fb/ADP/1vvD4d/tSf8ABQP4WeF7bwhqXgfWLrSrZi1iTNeLJBER goEEbFwOcb2Ax2FflJ+2N8TfjF8Q/G9x/wALPju9Gf7Ttt7XXoHW9Inid8RBuRu3OTx0IwK/rPgH KskjxQ8bhpLn1atbV3/4Nz8h8SsXiJZaoYlNPmW/pqfCFl4Qm1GWfTdHEEDbduJboxLNllVhGcMd /JKqBzivrrwZ+xR8efEOiWPiXwd4Evtd0uW1Pmwopt7x0j+Ussj4VsEHOPSv6Az7PMDw/h6dfHSt GTt/wfl16+R+Q5XlOMzqtOhg1eUVf+vN9Dy7xJ8D/iZonii50DVvDF/o08ViJ2s3X7VPLIGZXiyg O08Y55PbrXqXg7/gnz+1f4iisL+x8IfZtDvLc6jLOtpNby3EDfOkTiZR8wBHK+nWvLxvHGRZdhqe JrVbxntbd797W26910DBZFmWZ4iph8NC8qbal5NGf44/Yg/aA8E6ZPqfiPwJOdIsZi4mggZ7m4Ks Dk4+VcDGATyRxXzFrfht/twee7iE1qQsSbmtpgSo+V4+zDoQ/II9q9TJOKMs4ihKWXTvy7p6P9fT 1+V5zDJsdlNT2OMjZvVeh//X/Im50p9Mu3uxdS3AuAPPjzuS3IGPlPfPB+tS2Wm2XnG9hl2yoCDE SFjbPc+9f6vcq6n8QyqaHRaja6jp9rbS3aPFaXSBopIgNzBgCPwII61i2t4tpCoLYl8wtFM5w4+p /ClyIfOyJWGpxyELEuw+ZEXQQbCpwSBx1IzX078GP2ffG3xb1izsvCXhS78YWb6WJNRtoTuSRWOA 6heQPlP/ANfpXkZ3j8LlOBlj8XK0I7v5aHqZDgMRm2OWCwsbzl0/O59Vn/gmT+0BrGI08FatotvY y+XaLBrbiSUOML+4WAkhceoHueKbqf8AwS1/aj0Wxj1ePwz9pttPZ57i8uDNHeS7VJAZBHgDpzX5 qvFzhpTjCo5a9uXf/wAC28/wPtMR4c5zTpVK9NxajfS7vZf9urX+rn//0Pzk8a6F4l8Ka7beHPG9 kbXVZHnTYG37fJfayl+vTkZ7dq49YbYas9lZqEW4cIsk3yoM84yfTua/1My6vRxtCGKw7vTkro/i TEL2at1TKkdvFa6jdXE6QRb5RHmE/K+BjI/KsTWdGh07VLjUdK1C7vLiRUkLKwaOPdjhVA7V6Psz njU9w2xDBeeRc3SSTXbrtnmzufPpWdBHGlxcW8UMsIBOy4Rd8T8kFc9mBFJ09GbQrWZs+VdWluRA yPeSqREzjt9PXFf1wf8ABEXVr6H4caFAl35iay0V3cpMgEigBgOQOgO4Ae1fiPjnBLgqbf8AMf0J 4E1n/a2Jj3pn/9H+vT9s23W9+EXiC0OGmm8kRFog5QJLu4JyByAefQ1/Hf8AAB4vCv7T8unPp9rL eW/jC7077dcziGK4C33llto6SbS5HqCQOtfvvhJWisgzXDvrFvX7j5HiXDSjxxgsXF6qy/GR/b78 MTdT/DbQ3udsNw2kqkhjk3KNsKjJP+fqa/lC/wCC2ulT6N4807W5YrfVLDUdd8gs6C4aA7IGkdT/ AAnEPBHXGK8bwfq+z8QYRjs3JX+Z5HjLhva5PCvu4yb/APJZL87H50fAn9k34xfHi7tr/wAEWcVx bbllsoLuwlntFjIGDKVUgFshgCTx25xX1/qH/BJT9oJp7SW/8OR2c4gY3t1bsZobfJ+XbAY/m7/M dpFf1BxD4k5Nw5jngazvNb6pf8E/Kco4BzLNcHHGz92Elpo2/Lp2M+P/AIJB/tDx27m2WPVBd3hu ptVTR2kvURNuIkTZt24HTr8x5r5m+Pn7CHxv+ANrc6v4k0pLbw/I7PFNe2M1qtuqoZJN7njoGwK4 sv8AFzIsbj6eBatz6J3T1/AM48P8fleBnjr80Yq70a8vM//S/NK4ttPULZanKLBI5EEs5BWFt33W RyMEHP8AOvsf4Cfsb/FT492RPhLS9Tm0uGV4Y7i3UW7XcRACSb/LfgkkZxzxX+l+d5/huH8vnmeK a9mvxfb9f+CfyTkPDmI4ixUcFhFrZyb7RW/+Xz7H1PB/wSD/AGkv7DS0uLS6j1C3kYy3MmktdWaR MfkBdV3ZA5yRz6Urf8Ed/jvFFBqWn2q61eG1a3k3ade6dbkjHACpknrzj0r8/l4z5FNtxjp/iX+R 9RT8LcylLl5lp5M+f/2gf2CvjX8C/Ct5r/izwHm00uyS8juEuZBIYv8Als254lfKDnb9Oa+CYhbk SzW5SW1TCTPuAeE8ZBB7jPevu+GuLMBxVh/rOCekXZ3/AOB0vf8AyPjs+yCtkGZxy/Eq8rXutvy7 H2F+z7+w/wDF39oiws73wX9gOi6hqj2djq8izszeUR52I0Q5KZ28cEivsOD/AII9/tE6a0MkFlp0 92JnTdePcR280YyCzALkNjkDBr5vO/FPIsnzGpllV3nDSVrad7d+q6an0+B8Os1xmEhjI2iqmsb9 u/pttffVH//T9Ntv+CQ3xzullRELMshnWXyJQ6nJyiKUBYdcbsDivAvjR/wT3+K3wR0KfXvEmn6v d6dHKWneS0Fu8WxSwIA6Btp754zX+geXeJmRY3ErA05tTn8N1u+2jevqfzLi+CM0wOGeLqRXLH4r dPPWx8ufDf4cX3xG8U6Z4M8Oabq1zqeqsIZNPWCSS8tmYhRlh0HOfpX6BR/8Ehf2in0+XVrTR2mg mQIsupxPLFBj5gzKIyCPXacn1rszDj7JchxEcHmdTlnLbR7Prfa1/n5Hn4PhTNc2w8sVgafNCP59 rf0j85fHXwY8XfDzxKvh/wAY6ZZ2vii2vJrUWsNx9ntlWNiGaMvg9B09u1fVnwE/YT+MPx/0e+1D wn4a3R2itDFc/Yy78HaZTIqspB4xj+Vdk+KMsy7CPN8ZUUaE9U3110t3utfl2ODD5Jj8wrzy/B03 KrB2aS+Tv2tYn+Lf/BPr46fArSrnWvFnhea6tYYI4vtRR0iJOdxyYwQ23JxznHWvkDwB8Mta+Iur 2umeGLVmu/t6aa0FlCNRvtVupHIjhjiHOMZy54UYziurK+IsuzqhWzLBVFKlCO/RW1f3I4MZlGNy 3H08Bi4ONSXT10X4n//U2Lv/AIJT/tFnQR4jk8NvFYtbRXLI5nmeIKN7KEWIBTjqOee/FfNmgfsl +PNX8cXXga20aUap9u8i7EsUzSQrkKohCoSCc9l5Oa/0Pl4k8NQp1X9YV4bqzu/S+9+nc/kupwPn zrU6Lov39npa3nbt17H1pbf8EjPjxNYRzXmhf8S17UTxTTW+oCf5jyGATkgHvj8K8I+Nv/BPP44/ CGx/tjWPDsV/o3k40u5S2ns7hVUBpNzOuBgDJU9cfWvNy7xTyfHZnHL4XSnom7b9t3a+lvnextju Ac0wOAeNqW9zWSV9renrc+DYrCeS9mUXLb7G5a1uokYN9mMZw6cZBHB5GetfXH7P37Kfjr9oJZLn wRp2pXEctu9sl1JbHyklJGyRP3bZ/i47/hx97nHEGAyDL/7QzCXLT7+dr2Xm7afmfM5Dk+MzvEPC YCN5fkr2b9EfTuq/8Ekf2l7M2sMgkubqYJCvmWEsk8EY5JZAu05JY9RUGo/8Env2lpGuUs7azFvH AsFqYNIuTM03G/MJTjvyCQPSvioeLHDtSPPeSv5L/wCS3PqlwBnivFJaeb1/A//V8u+OX7CPxt+D GkaTqniHQr5dLtpvJvHu7Z7aGA+Xk3Dbh8wBXAAH8Q444+I/t9pFNHc3VtLfRSSuHjiX7NcTSAkb duOGJ6j2r/THKuIsLn+FWOy6SlTvZ7pp6Np+avr07XP4vx+UYrKcX9UxsXGdr/LVJ/gfS/wF/ZT+ Jvx3uJLPwZ4YuLu/uJQ7SS6fKbOOIKCI2lAwpweT0BJHNfTC/wDBKv8Aaft51sToOj6asUjSi2ku bk3s4LZKrui+YcnHWvAxvixw1lWLlgK83KrFtNRV7NOzT1WqaPcocDZ5isNHGQhanJXTk7XT2tuW bv8A4JQ/tCXE03nabJpeWjNnLaWcgjuAM70lGwkk8j5a81+Ln7Avx3+D2i6jrt94fs/7K0u1+03v mC4gugD0cF1Bx16jHvXRl3ivwvmWNp5bSnJVajUY80Uk29Er3e70Wn4amWL4IzvB4KePqRTpx1dn dpLra3z9D4Eu9PiW2mvdssDTOfPE6mN43HByD06Vkx/uUDQvuWQYyvKV+o4aHNB825+dTny4lpH/ 1vyw2ukfmPgljt4PX61PZTtDbyw/aEjiAZtsigdewOK/1z9kj+BPaskTfb6d5EBj8yaUyeSfuE84 Ofxqbw6L2KWaC4dyZeAkbFhGTkEqetZVqK5GjtwlX3kmf04f8EMzMugwQSPLDPHeSS+XK+fNXeQB nsQAox7V/RP8dEt5fh14jjmgDIujS71J2jOVBOfbOa/zl8QYcniFiH/08f5s/tbJVzcDUP8Ar2vy P4dL/TbvTv23/FuqNqMNjaj4nzLaQrOVdop3WZNo7KVcjjvn8f7dv2drhpPhV4ZctIZHs4xJ5vO4 rGEyvsdtfXeM1pY/BOnt7KNresj4fwmnzZBiXL+d/lE//9f9bf8Agt01pD4cijuVQx3r21zIY0M0 00gWaGOJF6fP5gBx/d9q/nR+D3wJ8b/FLSIoPDOhalcXcVjIsEU1vIJopFYqqBApJAPPOB05r+/e Asyw2U8DYXGY2ajThDWT2Wr/AC2Xc/k7P8HXxvFmJwuFjebk7JI+h7P/AIJ9/tAf6Pd6j8PLtb9L MRtcl5rIBzxlwUK4HXHNRXH/AAT3/aC1G5WBPh3f3k9tbgR3n9pqtuzno5Tyhu6dBjg17lHxH4Zq pyhiF5aS1/DqC4Rzrm5ZUX+H+Z5D8U/2Ofj58NdHtrrxX8PryEkM9zc7WCyRq33okwTkDHyk8+tf K0dkbTZctYXmkTQLvkjvkNvcup/56RtyvbjjtX1uWZvgc5wrxuXzU4abffZ9nrs9T5vH4WvlmYRw OMi41Lf5r57Hq/wx+C/xG+KmrNp/g7wrqmrTXCM8i21u2YSwGyVmGRsO5eRyMjNfQ0P7A/7TVvBD I/geSOa1cPeoqNKHT0HRgTxzjHvXn4/jPIMpxX9nY2so1t7auy31snbTuenQ4dzXG4X67h6TdPZP a77K+/yP/9Dx1v2E/wBou5na2vPh9eDc4ZJktyJgrchQD3ryX4n/ALHvxZ8AzRyeJ9B1mx05FzBd x6bNelZGOAkwAwoHA3DgZ+tf6b4Hi/h/Mqv1PB11Ko9UtVfva6W3btqfx/ieHc3wWEeLxNJqC0b0 du17Nnzxq+lywQRrCJjNBEbYsrbTMQSCSO3TH4Vz1jbahc2kuny3rW8Pmec8OcEsOOo719ThYqUJ W7nyjnbE28j9S/8AgmZcy6X+0Do1zFNema2e3sfsxbNpqKSgqQw9iAfTINf3a2O+DwzZQmNQ8Omx RshOUU7QTjH1r+IPHuEYcbQf+H8kf2H4byb4AS7c35s/h5/4LSx/YP2iPD8szXai98P3iK8aM0qi K9ZY1K44BZnz7Cvx3lMBt3WRszlizl87mzxiv7Z8PoKfBmWz/wCnNP8A9IR/HGeT5M8x0e1Sf/pT P//R/HqG1uLYzgomxgDAOq8isyWEOWgZSlwzb8/3q/2YhDoj/OiM9zLk06WSY7Cs7RDLpuAMYzjO M1qWZtnDQyQ7ZRwvGPy9K1UVy2ZSm73ZNd6g1g0Ky7WLnEYzz9Ku2dhBqGtaPNLcSW0V9qMNnK/U xbmxlR6np+NZYqXJh5z7J/kdWAj7TEwpvq0vvZ/aR/wTH/4J/wDgLwz8PPC3xSt4I59e1zT4bqYX kRinBk+dgepAXgbeBleegr7S/bY/aVf9k3wKniD7PDJb6Zp/2qS1ECyIY03xgD3JTgDqa/zZnPEc ZeJzw2Nk26tZRb8ubottj+3uKXS4Q8PVUwUbKlSVvXlstfU//9L4J/ad+POrftOeN5PFmpTXtqbt Zy9qGMUSxtMxhLDJUnaRwAOMfWvnNtJhhhttPIN/HJMFaQP5bIAeGUjoVx1HpX+vuHwkMFhVhKUb QjGKS8kkkvkj+BMBiZ4jlr1HeUm2/Vs/qu/4IVa/qup+FbnTNVvdSnisdZ+zWL+c0ka28ZI+b1G/ cPy9K/oG/abhjm+GOsxrOLZnt1RpVypIPXnt2r/OLxChCl4m1kloqr/M/uTDxc/D6jFP3nS/HlP4 MviNN8XvCX7QvjPxV4Il8T38fh7x1fSWraS01zEy2906bVRCdykAADBwD3r+pn/gmT/wUj0v45aA vw68eTr4e8YaLYjTLmx1JfLnklHyL8jYbseD071+y+K3D2DzrhnD4zLEnWowjzJb2sfh/hfnmIyb Gyy7NG1Crflb2ufmP/wXpjiibw3qlpDa6xcXuvi3SGadY59ohJXCqSCuNueejA+lfzj+G/hx4j8U COHRtMnv7+SB5riz0q0e6EaJgfO6jCZJCgNySeOlfu/hBmVHLfDrCVsbLljG929LaL+l1Pw3O8BV xfFOZ08LFybqyei/rTz2P//T/LXTP2evihM0kjfDzxUhEbb/APiVv9piI+6NjYBB9c/hWzo/wN+J 1pcS/aPh34ngbyW8u4n013toSAcmQgcdK/2B/wBduH9U8VHTz/pfcf58UeGc3qO0cPJ/L9DgNa8B eItBi1G+1fQtW0yzsj5jXl9p00MFwN2HkQlfugnnJ4FcvFpd610Lny7maOQR2dqLG2e5JeRgqlgq k45xnp7161LNsLjaKr4SanC+6d106o86eBr4eo6daLUktnv9x3sPwY8c2iz/ANqeF9a+x30RltZb bS7mdZRjI3KEyvHriuTi8MX73un6Jp+hapcXl8p8hZLF4ZEVNwLOGxgZGPqRRhs+yvFxlLD14y5b 3tJaWve+umzNK2T47DzUKtKSb2unrft96Ohi+BfxKu7RryLwrqzj5jNbpZyGW229iMfN6/LXEa74 I1jw5qLW2qWd7biCNZEkksZreG5yASE8xFLFeh2g4I60YfiTJ8bW+q4WvGU+yau/Tv8AK48RkOZ4 Oj9ZxNGUYPq1p/wPmf/U/FyDTi7RRBTw2doTYef4SK3o/Ber69FJHArGO1kVS0NvLMke84CNtU84 5x1r/aeeOoYaDq13yxXV6L72f5zQwVfEQjGjHmfZK/5Fu1+Efiwx3ccnh3WpvIyI57bTZZIJM/dO duRn3x9amX4WeLNIEEeoeEfFcLXKbruS50SaO0tE/hfhSTngfLmuKPEuSuWmKp/+Bx/zOhZFmqT5 sPOy/uSt+Rxl94S1M3l7AtndWs1lgm3vbZ7eUAjOQGGSD6/Tmueg025ldoVUnadrk9j06V6MMbSr w9pSd4vqtU0+zOSWFnSqezno+x2dh4B1KaSKxi0+8u9SulBt7WG2kTfkZBLYwF75zit29+Eniq3u rK1udDnFwbdpRDHayyhyp6KQnzd+envXPPiPJ6E1QrYiCl2cktu+unz36HdDIcxqQdanRk490n17 d/kf/9X8aNQ+G2qC7uJlttRupVtgzafbWj3EsDLwwAC5z/sdfrXLXmmw6LHIl5Bco0CebeNNYTRy 2IbAUSqVyvUD86/2rpZvgcU/Z4arGUt7Jpu3ffbzP88auV4nD0/aVoOK2u00r72uV/7GRtPa6tFa YuBLkfKCp54HXPTrVjRNFg1F57K5tp3vJrbfBBHA87EAjcXRVJ2hc89quVdU3Jy0SIp0XPlitfzP s/8AY3uPHHhH47+BJ/D02opZw6rb2skFhG8HyO2G8zueOxxwPpX+iF8CLyXVPhlodzPLvuVsFX95 lS4jULub0PSv4G+lFPCVeJMNXw7TnZKT80f2b4LUMRh+DakaysuZuPo7/wBelj+TD/gv/Yz3HiXw 9qpwkWlavewTzHJ8zzVtmjjQEdPvDPua/mhWXF69xCfKYkMcjByMD+lf1b4FtPw5wFu36I/i/iFS p8Y5spda83+Nv0P/1vwo0LXdb0HxJba1o1/Ppmt2MouNM1O2kaJ7ZkIIBIPcj8zX9k3/AASQ/wCC pel+O9D0H4S/Fu9tZ/E9pZ/2OmqNJ9kurmSEAKXj+4x2j5imOmQMZx/p39IjgqOf8MPOaEf39Dr/ AHf+A/L7T7H8h+DGf1sJxEslcv3Vbp/et+q/I/TX9uL9inwh+1f8NrptF0m3t9bWDzLbUI40lt50 lGd8ke0s2PRfX1r+DH9p/wDZn8X/ALL3jjUfCPiy2/0IX0qabcQl3dkEhGWDAEDPQ+g7c18J9GHj f6xQr8J4yXvwfu99H+W667LYx8beDP7B4g/tuhG1PEJX/wAS3/z+fkfM0sMf2Rp4/LEO/DMzDzSc emc1jbndWKNKVB24hbax+hr+z0rKyPw6y5iC2ZrXzy/nSNP1a4YyunsM9OnarMFsXjMwkGCcBc4J NMyP/9f8AJFuC5VSYx0PNXLe2W2tpEVmaWQ53scknFf7q01of5jlcMlsigfNKSWYHovTpVeH7RNP cXDzRQkLvT+BuB047mrAYZnKMzOWY9B61GZpJFCsM4GOKlNdEA0xsse0E5xngVJbzzwBACWj5VkJ z1olG4XS3P/Q/n2lVzvRvvufl5yKhjaJQ1urETxt+8U/w5AI/Ov90nFo/wAx/Ie6LsQhHGHCsQM8 k1Os1oNiOrzKhIk2cEccfrQ4tK4Esd65t3dolKoDHGr9uwI/nVC1je7a5JH70JvDu23OOuM9/pSs w2GmCQEecuwj7p6bq044GaDazEx7ssFGScVcY9wP/9H+fm+0y3kkicI0KDA4PyFh3x+FRTwG3+VS QAOST1r/AHUcNdD/ADLjOysyPdK6JAVLh2+QhcmlubW7iiKSQlSDmOQ/xDHShQ1FGfRmZE11FIHV 2VsYYLwwHQ1oxwLJln3HPJJpuCZqVpVgXcoXbEOFCnmnw20j/Nnaq/cz1P1rOzW4H//S/n0FxJAG jUEyE8uB92smTf5w3l2Qn5mIOc+9f7o2Z/mc2rXNJERFeZY1VmG0yEYOBUBmikQpHyS2GYdscUrG cpXWgoRG2IcNs+ZWIwcionikkPLgbf7oxn0p2drkGg4huLXyZEAcKFAxw4FVIlRXCEFcfKNq8Cto qysB/9P+fCS3baFDlmHII43U+QwpD5UUUnmyY84DLHIPb2r/AHYP8w5t3sTxxywxiUcKPXrUKwW6 Wkl1I5Nz5pEULKfmzzkHt6VLimmRHdFZnD4EkZRGxgqcEmrojto4gUzuzjYV6++ajkZrJ2QsVtdb WuTGyW6PtV2HyZxnrXKeJBcTWkltG42Tna2WKpntn2rix0bYep6P8jowH8eK80f/1P4q/Gao/iLU VWMJNDPtPksXgYgdj371y1wEb5Zv9eBliDn8DX6jxl/yUmN/6+z/APSmfJ8Pq+S4df3I/kIAp2S8 fuzt/wCmh47VZhTdJ8m+UMckEY218r1PcjHWx0On6TcXFzHHFDJKJG2/KucHsPxr9Xf+CWfwo034 jftdfD3wt4ks7nUvDt5JHaarYACO0ik3M371+4CryvuK8nN6qo5fWm3sn9/T8T6Hh3Dzq5zhlD+d P7tfyR/qNfBv4E+BvhD8NLODw9aWttHH4bLyGKBYtqmLIUBQMY4/Sv8AOQ/4LuxtqX7bXj6aCdTB Ktras/l5RAyQTeUD2YcnrS4GoQWU4mfVxTfrc8zxAxNXEcVYaU/5pL5KyP/V/jjvbCxtJpoQszvk YLnKx8dh0xX3/wD8E2v2j/il+zn+0d4Hl+GnizUNJPinXrfStVtEuWgsJYnlQbHUcFT1/vAg4I7d +YU4VMJOMlpZ/hsdmRKSzKHK95JfJ6f5n+rf+z5431nx18M/DPijXXLaprGjW1xcAKBlzEu7kccn NfxF/wDB0JGLj42/DiWCINdXGmOskTjbHsW8dy5ftnGPfmp4Ul+5rS/uSHxpFUcbCmtvaJH8h8nh i/ninlvIIi5ncf6ExmijAY4AfHpiuRvNBzMXjR4pYPl8tjhWx3rbT2h5FRKyM6UPZ3EFu4PmzAyR fLnO3qfwr3z4L6o/hn4g+CPGlysZHhnxHbamojx9ouFSRXdQOOdoz6cCssZDSVPumjrwrcKsKttm n9zP/9b+jX9gv/gpD+yt41/Z/wDCMD/E3StI1rRvDlrFeWeoOLK6tzFEiFZI26EFSDjP+P8AIp/w cRfH/wCHnxk/aH8FzeA9d0zxHp2l2Us89zp9/Hcqj+fOx8zYSFdtjcHrgY4rr4VoOhgcRzrVJr73 YXGWYRxucUHT6yv8rXP5jPEF0NUvTcICN2ERVHBA4wP0rPttKa+k2G0mkMGHZljJRAO5PpV3SlqK V7WNO50K7idHt1a7hkCgrAnmeQT3Yjt/hUEdteWzSxxW8pZfkIaJuGPAzx71V0Ya3sSano9/api9 iSK5RAtwi5+XcMrjIzyD3rkVt3i8w8lYBuYE/N+VJNN6Cqe7F3P/1/4sTbLcRq4aUMpDqFHygg55 pkkjsfKUNuHO4dBXbKN9jmj8KNC3sbeePeblFkHDREHzB+mKu2htjIS0iAxAIUJ6/WnGPKXD4kfT /wCyl+0F8Sv2d/jl4Q+Inwm1bUtC1xdTh0/UJLO4Jt76N2CrDLBnEkbYAZWBHCEYIBH+rR/wT8+L /jn42fs6+C/GPxAZ08QX+kwyXSttVg4RVkOABgFskcdCK+czVKlj6MktZXT+Vv8AM+1yaUquS4mn Lam01/29v8tPvbP54/8Ag6A1EWvw68A2Nw0htm8YtKfK+Z90drtWTd2x58n5iv4VtT8I3s9w6WcE kk0I8+5uo181pQOrN65r6rGJLC0OXfl1PgcFOU6ldPpNo//Q/jzXzrVXiAZ4WGJM8Bcev/16yZFW ebeqxpEo2k+/T8q0l8KFL40dHpei3b3EtvFF82xZW3/IgU55B6GrQ8P3l1qt/pa2d4j2toJhI9o0 QfcM5XPXqOlEou25UU3oNHhm4iYkQ3NxGsYlIjiZgevccVnSIN4eK3byX+Uq4AI47isw5XtYgntr e0i8/wAvYsjiEYXJyegrXg8KXktlJNFC0yxHzZo/LJJU9MADnioSWtzRQVrdT//R/kXOlXi6c8Vt Z3MSwlI2RbdlPzkBdo7jntWbe6Dqdkj/AG63uYGWYCC4kgMaS8AlRkc+9YyXK7GyikZUbk3Js0im aURiTeIz5RJOAA3TPHSvd/ghptxd/EDwbpF7aJcnUtaSDUbdiNqwMcAvnoDxx35qa94xlLy/Q68F BSxdKDV05LT5n+n9/wAE1P2Xvhr4B+AfgPXNL0kWmtz6fbXt9IsKoskzRIc9O2WHHavwF/4OedaE q/DLQhHBNp2maneG4ihYzXrpE8YYY9CHxj/ZFYcM4RRjWq7tqTf3Hr8f42pVxdKhL4YzjFeiZ/FT 4htIrd90BDwGMNbAAAlQOp9Oo/KuW8yMbCxbOOSvOPpXY4+6z52+p//S/jyjS3lyNxZV5Vjw9Q2z zFxG8nCykox6qMnH5dKza9w2hsbcYL/MQNoGGJ4LVhmV4pmKHY27r2YelZlHU+HrKDVRctKsglWZ bbzthIhZh8pPHf3r+jH/AIIF/ArwX8S/jU9x4y8Px350eV9OsLiWMbbozS4ErIR8xCo3PRcrXn5r FywFSMXZtf8ADnucO0Y180pqUbpXf3Jv8z++vxd4R8JfC74W6tHoFsbTTbLRmht7SKIbZGMDIMKB 396/yx/22La88T/tN/F/U5IoZJrvxLczC6nBhaT/AEmXChcc8Y/HvXfl+GVLKOWO11+p42YydXNJ 83n+Z//T/kjuImSaa2mISWN/LK5yeKZbafsuDIzBUEePmPyc8V59SKUlY6kvdv8A10NW10PyWl2p E8Ua796uGZSfb37VTurOSxnMLo6tI+SjqfMPGcY659q0UPduyUruxLc2RhkiiZ/vqGLJ8yxAjI3H tmqG394ITHld5GX4PoDVRhZlNdkQtDuLQIvKvyw6fWmWxljkZJCfLjOPMZen0qJrUk//1P5E7pLe bf5jdf8AVyDqpotmYOUDglQMr1bHYmvPOg2/sckMDXEgYR7gCQM7asrCjeUXWVI5RtSR4iIXb+7v 6ZrlmvfQqkWos1dO0PUYfMeS0kkhbm3a2Vpg7d1IAzTBpF3q6pNaQyLbu7Qxyvbuiu6cMOR29TxX RKFpI74r3UmT6ZouqWokg1eC4hjLbkZiDg5wMYOcHrzXtHwY8U+LfhP8S/CnjPwR4jv9H1iHWoEa 6huPIYr5isi57AMoP4fSnJaFpa2P/9X+r/8A4Jz+PvGHxG/Z78HeKPG14+oalf6JDIkr3JuHAjRV fr2LEkfh7V+OH/Bx/r1ufg3pfh/Exa8n+VI4t8d1sdH6ngEFQM/hXmRV0me3KHKfwg6npEt3Hpiw 2t6BdyyR+ZdQNA7smS4JI9c47VnTWNzpiqhVmPcEcoO2aiK94fs7IbEourbz1RtmT80gKZx3Ht71 NYWV1J5vkaZeTJbtvkna3aOGI44G44HNbHO4a6GzaWW+SOKSAvLN+8CTD92o+vb865ybTLmO7u4Z I9klrKGMeOCrEkbT34/kaLe+kcuKgk0z/9b+U2aCVXAERXcwXEnyoBkDcatJoVzMft1u8tyyL5MN vFFuRHOCWz3GPw69a8KvHlrM66FPmg7GjHZ35vIrIwM0n2Tz5p1X/REwQu3f0z3x6VsWXh25fffu 0jxW0bebFbxmZCR6EDnvwKXI+hSgtiW4it1ith8oe6JEETKVmJGc5U8g8GsCS2khRvOVcluVQ/d5 +lJK+iNFBpaIIYr2SNZo9Pu5LQMBNJDbtJ5C5xubHQD1PrWsNOxeTwTSqLdJI5oTCPM8xSoypxkE 5DZx0BFNxaCzSuf/1/5kP7Dv2t2v7S0kltRL5W+OFyuM4LZC4A9z6VlapZmCB0nEkgSQ+asK/Pb4 5yw7D3NfPnoWM6P7OrpHI2WYfu9xpLuAWamOFgsgO/f25PY0mtLAZcMkv2pmZYfs4XeH3EyO3cYr ZOJ4AxQIRkBUHUdqwSvobxaskMtILyWe3+zgMhk2KrDIz0GRX9in/BvL8NPh74m+1ape6FY3urW+ yHVL26t0a9jnjkf5SCeASEwMYwKGujLh8R//0P7Ef2poR4G+CnjHWvD8zaVNpPh26CCxwJ/3cLSB VI+7nZjI6bq/zs/jh+2r+0le/E3W44PiV4v0iDTNQlma2sdamhSNckoFiDAEHHOMY9+K+c2iz2U/ eR/Sd/wQY+N3xF+MFrrDeN/GGo6vLZNH5kGp6i888ZlDlVbe2drBQcduPbH7kf8ABQP4PfD3x9+z j8RNJ8Y6ZZ3VwfC9xqAvDGu6HyoztJcj/ZxwRkZqaKXM7dzea93U/wAxHx7pug3njzxXpel2ax6f p2uTWtnhSTcRxSFVYDGARgY+ma/q8/4N7vg54Vubd9f13RYtRvbLcqXeo2qF5pFfO8cYOPk7dVNb V0uW5jFbn9LH7XltZ+F/gF8R3soJrbzPC12Ueyi3YOwkpjtkZH41/mJfGTTr9PH/AIourrS5bVr6 /mliILSlUDu2117MMt70oxajoc8l7zP/0f5j7mEw3ZY5CvgBwME/5/rUMUF5qlybS206WWaKVY45 TE7A7hgHGPu+9fMSf7zlPZjFezub0XhhYbmS9midZnUQvGFk8k+WCcKpA7k/WpLjS72KDzxo8rCX BiEsZtrhEP8AHtfHynB5p1I8q0MFG8rIwptMWc3Ec/2yySO2FzJOkYHlgnGCTx25+tWtLspnsyyQ iRixFvLOxhQjoDnt/wDWrGKvBs15bTsQx6XNpGlPJq10k04neUvHGcIC3yqxx2GBzirej6Y+spLc Wc4NrEStyyOP3Zx91vfrxSovmppl1aaU2mf/0v5rl8OwWaOz5keZQkZG6eVG5OWVc4x3zxzVJdKE lvIl0reaXaNVBDLwSMgjgggZH1r5ZfxD03T91lb+y5xbPb2pEkhBCGU4QEcY9qoWGkR20DCCedI2 naN5bOKSdhJnL42A9O596qrDlaRVKF4XOr1TwPa3lna3mn3GtzTW1mt3cwvZyXEYI4c7lXJGeNp5 FYslvOFCQhPKCA4z5c6tz8pjOGBwPSlGPvg4K2hmKhYF2jeIn5W8zhien5VZjvng2CaAXMNqyqd1 qWQA4wAQORzz1rGunGpyoulT5o3P/9P+aq20i+lnW3j0y9luZjvSO0tmuY0U525ZcgZHYnNW7rw3 LGszxrcxEuLa6eW1lhjjfptywAyPSvkZx5Fc9uFO7sUH0GzgjW2W4Z54wS5QGSVj6YAP5VizQXR3 xpZTxbSVY3cLWxUDvhgCQfUU4LdhKmtjoorC1Swsr2SNN80n2RILVGleaRR91AMkk4PAHauVa11h ib9tB1aKG7leC0P2KR4wVYgqTjjtyelTR968hVadrIjufDckkJn1SyvNMuXiMXmLbtNLbeh3IDjP GDxVqK2iGnx7kkl8klkM6mKeQDIJCNg4yD2q4x9+xhKFoH//1P5e75LWRYreLckrsHRiNjr+Pp7V KgWJ7SO7umCLuRVKhlBYcEA+/wDOvmJRSdjvjsigy3YlcRtkpnaR6duKsmeQRIspDSYwxRcH8qyl Dqguk9TLvGsihaVn3IORtPP4U6yhhuyjeXCgT7jgcEAHGeOvtWTSYxGuVnfYCsc24oitwr4z27Zx 0q3bpaXCyQyxwQ6hEuYp3XhQQcgH3rFqzsa09j//1f5ZZYZVkAgkWcYJEiDCEgcgZ/lVO2kvI5op jGH8pshXHze+4fSvhz2DYmvpnidgSBjHHGKba2xthDeXF7KkiZYOp8pHB/hx6YpqyeoWQ7VLWAXN tPYhUVrbdeq2SGlz1B7ZFbnhrToNbsRJDDNYa2nmRwmWMJaSIpJ3PKSNp4zx2ptq1iWo21MG80WO zvmnTdPcRSF52XcYJHPGVPcD1FK11co0f2hWmRRsj5A8uktGZyaex//W/lnZrpr63ieCQw3JJj3/ ACbRjqfbjrTWgvNNNxYXZhlaaTzYrlTkhW5CjBxwMDpXw56sZ30ZZtdHsLewnme6lmv5pzIscibk jUjgBvQenastLdvNEJlVDjzDM3ys3P3Rj/PvUTWgOa6GdEZJr/UZrG9mWZV+yXMDZjjbb2Bxzn2r bsNQjg04QITGW+S4hHJyDyG/XrWQufTUqytZziURXHl3mAiII8jcfU1djsfLtFnYYk34Zf7/ANO3 agJSTVkf/9f+W+SKyubOSC4RHSRCHif5s+orOKxeTHDAkSxQKFjRAEIUdq/Pz0DobZlWOGNkYbR8 uGO2TPrTr+2s7lrVoXdJY5ibhTjy3XGAPr1oNaexzt3aWiahJvhYmEblYKJHJ5xtNQQS2s6IJ4Wa 5WQujyDCqOw+tZTVmWTulw8ieU8eXOHRjgEdjmtLTobe3D3GqorzMDFb2u3zbePGfn+vI60ndWR0 LVH/0P5Z49HR5VtoAqJNc7zO77CobqCenp+Qqzrui3ulTROLi0bS1wtxNFIJHjAyTjn09a/Nz6Wm tCsI7WUu1uHlTojzJskI7HFSny1X5lZjEN5wM7hWtPYJrS5X1Xy/sEKsGki1GdYfLVSJIG6gv6Kc nn/Ctq3kvNMhW2VkZWX7rDeY84I2eh+lWSoPqVJL4T/aZpHW4uUjZU83LNE+CNxqppGq/bIHt/El z5Wr6fbLFpscVoRHdJuJy54CnDfj+lKyvcvkVrH/0f5WsXUzTxG5kiWT5jFGAIsZOOo7Vds76P7N 5bbJV3GAMDypQkEfmK/PnsfRqHcjtpLnM8oja0e2kwz7vlkU/dINOFoiTLPIE8y4P76WMAyuB03H vWBOzHTPfW7QLaNGsMb73hkGI2HckVVuZXuLhZQwDOPKd0OBjOccduaGrrU6YvVXJl087nkTrjLb eN2KtQpIMSMw2sdoYtnZ74ojF7Ik/9L+Xu8hiuEjtXDM+/P2mPBCdsiqN0X/AHOnrI72lrIWXcMB ycA8H6Cvz9K2h9QW45bx5L+JkSWKWzS3t0LGPYVJPb1wB+NXVnWeya2u8WFwpWFJ1l5Ricce1VFX ZpG3K0QyaXExNpf6hLqAjBaK9jiEb7j0UDjgdCar2louneVBPLJcRNcFgYyfk5zwueoxn8K32Iju joL230wyOy/apFeH/RzGm0Fxg7pDzjjPH0rovAlrFLqEM01yLZ7eV3SSQERuuCoU4B5Oep9K9DAf 7zTXmhY52wU2uiZ//9P8xvhlAb7T7a3uCm9ZgQ6SlVkUbfLUKOhwMn6iv6ev+CN3h+SDTteE91eW qalrrXiWdxHsj2Dy2cRtjO1tnylSM5Pvn+g/ElKl4ZYWku8V+B+Z+GF6nGeLqyd73/Fn6fftz+JJ tA+DOvxW0hjl1G3dCY0LtBbqrM7egyVxzX8PPiuTV/E934h1GxmnvP7U1S4+wSALHczbCVBC/wAI +QdOgr6f6OEFHKcRPu1+Rx+Ml55jTp9Lfqfjp+0XBL4s11PDk14lvcwNJNqEl8fNkfy2IwJc84cD H096+C/EXhPUdF1K4uJilycR2xnWQb0wCQCpOcYGQfSvzPxqnz8Z1V2SPteAY8nDlKJBFPbwR+a7 nZs8sBflcv8A4Vt6fNc3Bt1icvIx2JGT8zD+6K/IJ25LH1t/euf/1P4uLLyYZJPMV0z/AK1WU5yO xH6V1FjCNscqr5YLElMcsK8fEanoEjR65FfQ3GkGMtvCNbswUzhsjb7/AEr3rwAZ7QQf27bwxzW1 yytGCcrnOM+3PH0ry6iurGsZJqx3NpEsmqtJfXMi28/zLIqbordAeDgfnWzdWq29rPb6fcvMZ3M0 N7Iv7zcfpjj29q82pFNo15tjYsdevxawRXUKqypsJOGKHvg4zg57mqdx4BsdY06a507W5NHvFuWv JbJLbd9uZvRznk++MehrnqKxpGavqf/V/jsS1t0E14LSMmVRb29+Y98iEZYqp6DsazZ9S+xxoJo3 +0xxmUBY8lgpxkV4co3egJvRmpHqVoqxX919qMU6rbpsjLfO+Au4Y6Z4ruNCilu7a8Eml39jbWao /n3NqYoLhX+6yHuD6981i4q9ze/vWNGxH2pbm3s7FjJbjcZljYFUUHn0wKngeeKCa8t0t5prRFZh dpiMDIBY5HbrjFUM0bbUfs8U0szpEsgDSOn3COv/AOquD1vWJbTWDZQWCL5lul1FPcZR2LZ42+4A I9jWtLSRMldH/9b+OrxI9hOI9Sms1t7qKErIbUF5JO7ED344FeYanoF8Li5urSOWfTZIBe21zgea AScrIo5UjHessNFt6Cs1I634caVcxa7pkkskri6nDELhiijhh69Afzr9X/Bl3ZxaHptvBFL5JhEh ldGzKGiRzuIGBht6jHpX9a/RyaUcbT9D+cPGq6xmEqev5n9b/wDwQv1qGHw/Z6XfQW+pXGpWsYtp rdir6aGihYx57HdI5JP90V+737T2k6jq3wp8bWFhEbsQ6DNti4d3w8bNhT1wqSdK/H/FOKo+JLk9 udP8f6Z/RmD/AH3hlQe96P6H8A3xttEn+NPxVtkW7ltrLxK1vFLcQG33ny13OAfYL+GK+ddUthaX BVBuC/OZgAuSOOnrgD8q/v3hyV8lwkv+nUP/AElH8H5i+WtOH95n/9f8TYtKfUbzzgkzSSQm6WUx /u1CkL+Xfn39K2buSwNrBasphmtrZnmktrYxtO2eA2e/v6etf61tttH8A0ZqMLGX/wASma3jS/di tx8ts5i882cqkMrso5GCMZ7ZyKfpd2mlXs01xBHf3F1ZSWzxmLMTbxgSFecMO3epTsdPNzWRoXNl dRxW00Flb21m9uWkbhHjkGPlHGDgZ/KtazsoF0w3sdw32iV9kgxtDkZzmsp2cGz2aC95XPu3/gnN 4jutK/aO8E/2rLNpkF+qWsGydja3JjusjzMY6KxYev8AP+9zQGgvvDNlcpOsqTaaUTyx+7jAU7f0 xX8R/SOp8md4Wotmv1P7C8LKjqcEul1i5fif/9Bf+Ctnh+5uPjstwIUudWttVntNNMbeRD5bFZV+ UnAX/SOv+zXsH/BO7/gnf4u8X+IR8QrmODXLB1t7qRvtEYghER3vEsDnBViNpJz2x1Br+xYcQyyD wmpVIv3p03FPt3/O3zPxrg7IIZzxziK9XWNCq5Nd9Xb7rX+Vj+lPxNqPwW/Z8+FT6n4x8H+HrCw0 fbA8Y8PefFEFAUMVXnjI/U8DJr4pm/4Kj/sSxXLadF/wiUd3ayIkMMngW5Fszs21nKqp+6OSSRwD jNfz1kOQcS8UUqmJy6U5Wbva7/I/U+Ic/wAmyzMI4bGJKcndbLT5n3J8M/G3wW/aM8JTJ4T0TwXq Fnfp+9fTdGit4pd25fMCnJO3GDnvkdRX87//AAUj/wCCafjDwRq+tfFjwfZRnRZbVXi0+O5i+wrK S/ysp+fAUcYGBuXnsPovD7iHG8IcaRwmZSfLJ8jTv6f15pHn+JHDscfwysTQSvBc9/K3fy1/E/Aa O3MTW0k8DwXGiXjw3qjDqs0RKSqx/iAIP5V+5X/BLb9s/wCHvwzurf4ZePLDQop5dTR9Emn8PteR 3iPIkcW6cdGHy/fPRG7AAf1d4j4Cvm3BdWlg3aVlJeaX/D3PxrwxxdDDcXQp17cs7w16O6a/9J/E /9H+0/w7c+EfGuiWfibSNI0q4tL23MUXnWESsgxgqPQHngnpX8tn/BbT4d+FvD194e8S+H/Dthpt 62oWQvJrWHy22NLJF+8wcLgbOepAHWv1PwqxGMw3H+Hw0pPWXLLXp1/N/efLeMmAorIZTmveg1Z+ d0v+Afzy2Mlv4Y8RWGqCG5vGsL2LV7S3VziZopVkCnnGCV6cZr+xL/gmv/wUC+Gvxc0DS/Ap06GH xpZaQLSazm8PqttKkTLGfL/hBOUyn1wMZNf0z46ZZi8dwlTxOEf8GTcu9mv+B+J+UeEVaj/b88JU V3VjZfL/AIf8D6k/a1/ZEf4h6lY/E3wpY6Do2o6MkMz/AGS2ispp1QkyF1xgllx6cqvevEtJ/wCC k3wf+Djw/C/xxpepWfijS51sJp18PRXcTqFCLOJd3IfaCcA4zyK/lXL8VmXEmEhllGTdSin92m1u 1vw1P1p4TA8M57WrcqUcRL8Xve/n26vTy/QLS7zwZ+078Nbu2ttOsb3Stb0hoopr3SYLeeMtj7rA ZQn5eOCM1/KV/wAFJ/8AgnprH7P2rax8StEbTZdB1DUXub62juFm2r9134A2MDj1yW7ZAr7rwe4t r5BxV/Y2M1jVfK/Lu/lZP5WvqeD4wZDJ5LSzehpKmle3ZvT8z//S/IizGqXTyi8giliwzwuHP7tW OVDDoSOB+FMu0FraSJI0qSySgxvARuIH8PNf6w01eyP4YTSTINRvfEKQpcxW98bO98qKWcx/aFh2 Y2/J0HHGe1XNRuo57vbaWqeVGRL9nkyX2joT6ZIz+daRjpqPmaQWNyn2qJr2BkueJJbdFJtQh/gR +hxg/pX6Y/sC/tla5+zHqMOrf2Eq2Gv6wqNYbRe7raAshHI+XiSXhcZLEcV8pxnlazfh/E5c3bmj +Wp9VwTmTyriChjbXSf/AKUuVfiz+gx/+Cw/ga9itm0fw1r0V2bVTOx0eIQq3AdUZ13E9e4AzX33 +zh+1XoP7Q+mqbXTr+3EqkNHfWqrHOuSr5QjbwQQSCR+tfwfnPDNXKcJOvKpdps/rjLMTLM8TKly WVrn/9P9Zv8Agpf/AME17LxNPf8AxR8PTaRbzXFjdP5MEUdlODJIsmFYJ8h+Q/Nkeh6g1/Kn4z02 +0DV4tHu7FIbm1vZbWS7gn86N2hbZvHcZwevNf3j4G8WPiDh9YGt8dFW+Wu/z1+Z/JviNkv9hcQ1 cNHSE3zLtZ9PkY04t57iD7Z5rW8e1ZI4BuY+rd+aivrn7B5scEIW4aMC3hYbFx/Du9OK/c3F2SPg nK0GiPSL+e2U3Eu8Xsbf6PFG2IFz13/3vatVdUktHjk8r7QrJ5sz5CrCQeRtxz68U1GyZXO7KxrJ dJeFby1IlYfvIYymE3e49K/qS/4Ie6pJceC/D9jcRlPNae0RIpgsNmsNw8iDJzksHzyfavxLx1hf gia/vfoz+g/AipbPasf+nf6o/9T+1n4peFdP8Z+HL7RL65KQzwFN6qJFyCCCc/T9a/MXR/8Aglp8 K08ey+PLfU7WS/l1T+2JYpEljuA7P5gVcL03c8njtX0/D/ElfIcLVpUv+XiaZ3YjK6WKzj63Utem fcvxW8e3XwC+F39p6h576VY2w05Z7FzJPHtiOAQR3Abt1FfzG/Gr4neF/wBu7466X4JtpL+30iBI 7YX1/Gr25nKrGXfCjD/eKgjPJya/QPCnCzjisVxDB/wVJr1tdfmj8/4/q0cZm2EyKqv4jjJ+abcX +p/Qt+yV+yrp37OvgTTY9CvLaaB9OhklS2XyZiIogoJAULu+9uPtjpivJP2jf2+Lj4M+Lb3w7qWg +JbqC3AEUulxpdGfI/iZ1wDkHgZ4xXzFTFVOLuJK1StO0pN767M+szKUMjwFKhSh7kbRSS6WPKfh 5/wVD1DxV4o0vRR4E8XR6bKRDLIWjikQHPzsoUYH4f41+j/xG+G2k/tNfB6TQdVne2TXdK8+AXsC ytCWXILMVyMZI/E1z5zl3+r+Mo1oVLtNP0a17nPBf2tlNenUhZSi4v0aa7H/1fbf2hP2A7D4Z/Fr w94G8Xa4bTRNa1uIfbI4hcvKXkBiXDKAA5wegAwcZr+lL9lj9nLSvgn4L0NvDOoQ6nv0yCR1igED ORGGycfKTggcY5B9q/evEDjLFZlwvgaTb5JLX/g/1/wfhfD/ACOhk8sTOOs78uq1suy+88E/an/4 KIXH7OPiSWDWfC/iPULOzVhO+mQkxqnI3sxBBwRjjnpxzXzJ8Lf+C2Pgf4geKtB8PWtj4ls5b29W wvDqNvCLXdIdqskigMOcD7vHfjmvn8i4DxWdZTLNMNL3Urs9DH8WYbLcyjgKsbSb0Z+rXxH8H+Ef 2nvg7bx6xcQzW2oWpvIp5Yw8luTGysjZHQhuQenpX8vvxW/YJ8HeDfjzp/h25m0KbQNa1dLRI9Pi 33E/mbVjZodoTncykcgbB+Hs+GfEmO4fxeMwCbsk+9rrRfjt8z5rjTJcLnGdYHEqzTsntdp6/wDD n9IH7Jv7LWkfs6eB9Ji8IywfYxZYW2ijkWaEOS7PliRk7yM5GMHtjHzB+1l/wU/0b9mbxc3h6/0X UNQWylNtcLbujyvIuPMG5x1GVwoH8Qr5LK8LiuOeKqtHm/eTk3q/U+o42zWHCOWYeSV4wXIrK3b1 7H//1v3A+EH/AAWe8AfE3xjpHhuLRvENrNqs/krFOIV8snPynC7h0/8A1DkfrP49+Hmh/tN/Bz+y dRuXtLHXrBvKmlhVnj3J8rHjdwDkd+TX6/xfk2J4MzKjD2l5wlzJrT+W2/oeHw5iKHEmRVa04e7O LTXre5/O/pv7NGs/sm/tX+DrS11LS9S0W4vRCbkMYLuXzVbDNlByAdoI9Md81/Ub4Y1Webwbp6xN C0dxpaOWkQMjEpuOfwxXLxxnE86xmHzGT+KMfwVn+OtjPgzLFlmV4nA21jKX5u34H8aH/BXmx06y +MkWpT2V1DqEj6lHB5CiJVuPOjIY4AJABY/Wv3I/4JJXFtafB3SNLt7u+81bNZLlJLcW0vmsq5zj tgnIJ4Oa/QeOMTKr4d5byPTT8I2PhPDijGXGOZ861i3/AOlM+oP+Ch9ompfAnWY7pi8DzBJ2MKvL HH5Mis2MZ4Bav4W/hP8AFjxP8A/i7p/jPw3p8Mklhqr3E9rc3X2VG2zMruylSSTCXXAxkP8ASvrf BKp9Y4YxmEm+sl8nFI+W8U4/VuMMNXilpGL+6TP/1/6hv2Ef217D9o/wdpOn3Fjc6Xqcljh4wgmt 5WKjMZyP9o9TyCDjqB6xe/sq+G7P4np8R9P2x6p9plugrAQ8yNubdhecHJGT3NffcQQrZfnc8HKV 5J2fy0MMMqOJymljIRsnG/4E/wAe/wBqSz+At14f0jWruaX+07WMhbDZcRwKSy/OD93lT1I6j616 L4o8GeHf2pPg9DY3M7rb6vabree4i2NbmSIqwbjO0rIflPqa4/aV8v8AZY9SakmmvlqcsqFHMqeK wvKmrNP8UfywftFf8E57D4S/H7RfBN9q9jb+DPFtyA11otml3qFzcXBeKNH+6FzIACRwADxzmv6F /wBjf9jnS/2bfBuir4bu42tIrOO52IxW4cspdi6Y2gnewIH8sCv03xH4xxWe5VgHGTjSkr8qenNs 3/l/wT5Dw04boZPhsc2k6kZOPM1rZN6f59zy79rH/gpXoP7LPiqbR/Fuk+IbwOVe0NqLZopQuQ6q X+bK7Qx9nX3x8z+Dv+C2/wAJPFvijSdMa18R2TahMi/6bYxWTQBzwMruUn3zj3oyzw/zfNMm/tjD r93y33Wtt7K99P8Ahjir8c5dgMf/AGbV/ic1nptd6fof/9D+xHxRpvgj9qT4RIGvLDUNM1m2E0ba paxyBMqQdwIOeD25r+VX9pH9gPSfhR8cvAfhOzaG58NazqrajGLCdHgjaSTZDuATcqoyyDg7eMYr +nPDniTF5NTx+V6uPJKcb9JRW/o0teuisfjnG2T4fMsZgcdpdyjB26qT29Vr95/RN+xb+yBpvwK8 G6RqujX5kuLywW+lSK7a4WV3+dtzHgglyMccegxVn9pz9tuy/Z4u7eXWtC1HWYZJGtkFhbRXF6jB STs3YwDj17ivx/CzqZnnNR1JNylJtvzb1f4n6PnfLlmXQVOPupJWXpoj558Df8FXfC3i3xBp2kW/ hDxjp1heXEcO7VdGhmdWYjLnyy2AOp68V+kXjPwz4b/aU+FuoabeQ2ktrr1h5UMt5pkcjx9GXO4Z AyB7jmtczdTKsfCrSm1KElr5o5suprNsoqRnFOMotW8mfxtf8FIf2F779ljxBJrb3STeA9YWCySe O5WS40y8nlK7REFGYnKtzgbeMcdPysih0/T5I7W0ne5tckhcEorc5C9SRxX+hfBGbrP+GcLm9rOr FNrzXuy6vS6dtdj+Mc4wUsszvE5fJ/w5OP3PT8D/0fymubu2u7u4uIkuLWJXMcdo8oZUC/Lu49cE /jTZZpBZGSKDzow2ZGCZ6dvpX+vcErn+fkpW2Myx1CUyRPcxyR2Zl4ljjLbRnkDmvQ7CWxW9lu7N rh4FH7hpgFZ/Zh2705wvCSOihUs4vzP6Rf8AginLdHWtQhQQQxLLHIllFciVYN0gZWAzk8Bh+Nf0 7eMfDlp4s8N6lpl07QpqFjLaOMAhd4I/mBX+b/ilT9j4iV1/f/U/uLhp8/AGHl/07/8AbT8UPEf/ AASW0vX/AIoN8RYr+wF9Dqi3q/6eipe7GBHmKynnjGcj2r9R7DUz8DPh1DDrBDx6XZY/dlbn7OEU JtXnoWH5tXFn+dYviSeGlUV5xtTSS3tt89TgyLKsJw5gMTSpu1N3m27aX3+Wh//S+1f2/v2n/h/+ 1z410j4ReAr6O817RtdTTruaSyaC0SW2kJK+Ychtp4JXuhHUV+p//BP79hbV/gl4dsvF2sTWd7Pq JF8zNIs4jDYJjROi8g8An9QB/RnHuJx/D/COW8MzbjzLmmtndNtRt2vLXfWK7H5VwLhsHnGdY/iK KTtJxjts0tfXT7m+59K/tHftl/CL9m+WOHxsttb+a224kbRRdxSfLnaNo56j8/rXzF4V/wCCu37J XiPxBZaRYXNta3lztt4YZ/CslvFMcchJCu0Y5OSa+awHCee47AwzHCqTotb2003vba3mey+Isqo4 yeAqW9qpar1eh+gHibwv4H/aa+FrxWWi6Be2evWpisNSayRLyCKRcPg4yOD09q/lC/az/wCCc+r/ AAW+Ll/H/odzpPiCcLoysV1CKASOVCiNjhVyB3HHtX1PhlxvjMkxOLyVvmpycprupJW+aaSXk9bb 38LxH4Tw+Oq4POVpNcsH2cXqvubd+69D9nP2A/2C9W+D2jaJ431aXTNVi1GyhuvslqyeWvAYr5RH GOmAeMfSvsT9oL9rD4E/s92kF98R7DTdOtBOYZEk0hTCqqA2MgcnBGM+/oa+OeMzXi/iivV5m69W TslsrbRXlGKsvTqz6zHUsu4VyOhGcEqNNK993dbvzbd2f//T/o00X/gqZ+xl4j1mx0zR7zRrv+1P LhT/AIkrQmF2xhWcrgfiRX3H43+G/wALf2lfhhNbWXhvwzqFlrNltjlNgsFwAUxkSKMhhkEe4+tf s+d4PPuDMThsTiZONaM1ON/KzT809n6NHy2SVsp4vynFUqEU6UoOLtvrp8mt0fxv/t6/sKa/+yt4 l8S+Ire31Cfwm7CezsZVaW1g8ydIUigZFwch9+WxjB7Yx+XDzQslxtMlv5almDJ+8RgDwQeR071/ cHB+bU89yWlmtPapGMrdrxV18ndH8g5pgquWZ1Wy+s/eptxfye597f8ABNDVg37Q/h6R7uc/a54b dEchY2aEsxWM/wB4ZUn0DV/fp4acjwfpk6lZpTpEE481uh2Dgn26V/IP0iIOHGdKfdR/I/rzwqfP 4fXfeX5s/iw/4LdavDYfH/w/eq++6u2vtFOnKnmRmIzrKJFfoDumz+PtX4n389kIfMulit4h/rHI G9Oepr+0/Daz4Iyt/wDTmH4RR/GHEDf9v5gv+nk//Smf/9T8cVvZ9RYx2U0YhiBYOx+ZgoJ49+Kq X3mzy2kkUjFIlPnqV2lyeAfwxX+0CVtEf5x0+pRltkQvcb8PF82V/j9jU2mzm6LiJG85TwSCN57A VajdXLi7q5Xi1GyuL5BdId8UnlFXQthug4r0LQYzbeINDmW5jiT+2IHXzbcXCxsjh4xt92UAnsGr izSD/s+uob8kvyZ6WRSSzbDOW3tIX/8AAkf6En/BOS88/wCA/g+GGdLgR6NHPLMJNzs8hy3HYZOM dsV8Qf8ABa61luPgxf3EjSSG10+YS23k7/tEYkHyHA7bnb8DX+b/AAdan4v0Iy/5/wD6n9m+MUpT 8Marh/JT/wDSo/of/9X8atGklubVt3+hutzIu1AVZ0LttBz7YH4Vq2WoW8WpRaYzBDH80bN90E+v pmv9knDmbfl+h/nvlt40Kb7H9Rv/AAQguRaWN7YQmOSW41OaNZBJkDy5zkr7Nn+Vf0sfF7w7P4r8 G6npkcQY3tm9oVYBiGI4IHYjFf5m+KSdLxPxKe3tG/xP72y9OXAWGtu6a/I/OD9nL9hvwN4PtvFU fj3wTpWpz6pqdzcprN/Zma/SN87VjlYELu4LEDORX81v/BRayuv2Q/2pI/FPwM1m58HNrmkf2nGY ZN8N9Mbh4McjK48pjggZ2iv1fwdzirxLxdiMtxr5sPODXL06I/DvFnK6eSZZgK+D92pTerXW99fl ofHOsfEz4yftg+IfCXhfx5rFxrVxbaqj2VzFApvJZmXy8Hy1G4vhRyCRtznjn+nn/gm9+wJpfwx8 JQ3fxP8Ahza3Goa1NHqM97e6U8bwRMS6ICfVWjyTzx+A+18bM5o8GcPU+GsslyczbXc38H+G6GaP F8R46PNzLltbrdv/AC9Ej//W/qz+I9v+yB4BvIbDxH4a8O2V5IxdhHcLDIoztwwyBg4Ix7Gs3SJ/ 2H9fvYdPstN8L3Ul0kZktYZ1n3k/dRhuNfseGXFtfL3j6Lk6a637HwWFqcNfX/7PUUqttvN6s4j9 rz9gj4I/Gn4O6wvgjwLaWOrHRJ5tNm0KFYbsHymaMKQO7cEH1HHFfyR/Dz4S237Of7S+kWHx08N3 kfg/Q7l45G1aWS3jdm2x+c7bVUsGLfKR6dM1+2+DHHGLx2S5jw7ipOWIUZcm99U7L818kfkfibw/ SyTjPL8zjFRwtRx5vJxav5WtZ/Oy2P7LPhh8HP2UPjV8INGuvD3hvw7qkWoaLGILyzaKa4tlKAAb RnHf3/r+dmgf8E3PDfg79oqbXj4cl1Twg2+WwtNUslk0rSJGmO7Yw+YjbhgnGDnqCAv5HlvHudZD i8wwOIqNOaaWuzu1+KZ+04vg3KMxr4PMlBcsNXpumk1+K/qx+mU/wU/Zd8OxaJpmpeENAtrqeQII 5IoopLljxuZSM4yDgc18Y/t5/wDBNP4WfFr4Z32q/DTw02m+IbPS5ru1s9Ms4Ck7KVlj8vK5GdpG VIPz9OK5OFuOc6ybP8JmGKqP2fPr6bX+Rw8W8KYLOeHcXgsFBc/Lp6p3tfztb7rn/9f4nt/2WPiF H8RJ/AUml6vDrYmNrFYnTympzSEkKEV8cBvlJ9jzmv6mP+CfP7AHgnwH8N9Gh+LHgG1m1OeZtVvm 1KxjeaRmjUKMlQQow2M5+97Yr+9PGvxMX9h4bCZbUtOrZvXyT/C/33P548I+D6MsLWzDMYX5E0vl f83v5WPubVPgx+x34fe+gv8ASPD2mJO+yS18yyWTg8IiPhuo7VV8L/AT9jTxHqUdto+laTeueZob m3guCB0wwORjpX86/wBp8Yxw/wBcfNyW31P0mjU4Ur1f7PpuLltbz/zPz4/4KU/8EwvBPibwVJ4m +Cvh+ew1u1hLN/Z+lriFWwCU8ob+n8P3SHOcYzX8tPgf9mj4ieK/iWfBlho9+k9lq8mly2H9n7L9 vs7Bcsp4QNj7rZPUV/TXgx4iKrwhi4ZnO86Cb1e+9l9/69z+euP+FMRS4+hg8JH91WUWvLW0vwX3 I/ru/Yq/YH+FOgeArCb4g+ALaS9/s6ET32o2EYe4cKCQgkUFQuMHAGc+1fRviD9nL9jXTNRksLuw 0uzZiN9rE9svlHuit1APpX83Zhxnn2d59ia2Cm2uZ6LX57n9DYjJcmyfA0KOIio2jFbdbW7H/9D+ pTw3+yn+xPrs89rpvh7w5qMl7brA1uzQyXUbL3V153d+tfj/AP8ABUb/AIJa+GNJ8JXvjj4MaW/7 q2afULSOwJ24VmAkZcbgeAG5wR261/TXAPiDm+RcY4eOZSapyfK03b+rvQ/GvEDhbD4/g6viMtiu eC5lZbpb/ctfkfy/6j4Zm0KCXSLu01HTZhI1hO0sWHhmX5SgPdgelfrN/wAE7/2BvGHxD8ZaZ4g8 UaTJc+CpLOBJbr7KY7mRQUeSSWVkCjIBHGR6A1/X3iRxxhOHeGauYQneVSNofNf8E/GfDXhaee5v QVT+FT96WnbVdPK5/UXpX7EP7MPghdC1KDRrPw/rlokMcepS2kTy3DjHU4ySevFfoD4G0bTND0Br HRilxZx25+zSKuxWGBggZ9hxntX+bvE+f5jn1RYvHu+uh/ZmT4fD4HDVcFhlpFXfrsfycf8ABwRB aM+l2c7izW71bEk1ofOYSYTEX+yW5we2PSv5aZfs6xQPMdrS5wc8yAV/pT4DWfhxgX0/4CP87OLG 1xrmifSpL82f/9H8Fhbo0zPuYpn5ccEV9w/sDXcEP7Uvw4tA5smvdSjka7VCUkkDBI/Nx6lUGfQC v9mvECHPwhmEX/z7kfwd4czcONcBNfzr/I/0jPhxA9p4D0KCV4xKNNiiYQHMYG0Y2n0r+Kv/AILw WdldfHbTtRmlgtFjsJreGMsQ1yWuGDsw78jHtxX8B/RtqSh4n8q6uS+92P6F+knZ5Hhpr+eP4o/n au9NJWRYXKIn8Jbr7VVs0nt1YuDsZwAAPu+5r/TI/jWWrRoSKdpIVXIGen3qzPtDSbVjVoihO9GG BnNVGLZm5JaH/9L8Do45Mo4/f7iA4X+H86ZKJIrpnnZUgOAiKcn3zX+7CVtEf5iucULNbwNeyfId piwpVs7Tj/HtVOJAd0bg/LwD3NBV1a5cFnF5IeXhc4Ud6jlgC4EaglxjkZIx1pWsyFNXsQao0FuL cQGQzTR+WV2ZCnoaijhCwpFIWkkAy7jgGmU0mf/T/n5hSN3IU/6s8+tTSSRt+5+yqJTIH+0BSHIA xj/PpX+7B/mNbW4ktuWXO5gyc4UccVVjjQsPKX5nP7zPT8aBlw2ynZFuAlU52jnNSCzuIiszxPGo O3O0jfigUtEyOZXnbDqShGxSeNuKkX/Q5AVmMpCgFMfKo78f56UEKatqf//U/Ae4ukkhDqzY8wgR kc/X9Kq3myWBW+bIIIX/ABr/AHYP8xVJN2RFa3OUMYTjGN+MbO3FaCvDlIbiV5F6K5ydn1/Kgaae xmXDQSXBEH3VONwGM49qiZ/K3qH3MVwB2oKTaJbSJFiXEQLxrltx3Fj+NNW5k2SeYgU5wAvQUDcm z//V/nyspInedZTh1TMZPAY+lPfZ5WXdMngY6g+lf7sWP8xwd55ESFxsRI8I+AOMmoIfs0cTIm53 RsPI67d30ot0AkWNsiQAYHbHWoGLbi3HXGPahJLRAXYnVnRGQZPAIGSabJEVdjGAffrQB//W/n08 tohvUkvnJpsckobzMKM8dOtf7sH+YU9y79raQNG+FPGKJVRtm/J2jdwPlwKLErcjIjlEbBRt6JgY 96kaJYhlzk9RjoKCpST0RJcm4aNEfOw/NGB90j1rmfEsO3SLnAdGEJBlQnchIG0kemcD8a5MbFfV pvyZ0YJ8uIj6o//X/is8TTw22szWhh2M0jsXRSUJBOSx7E+lcgdkjFuA7S4IbhiBX6jxppxPjo/9 PZ/+lM+T4cd8mw/+CP5Fxo0WNXw6KBkEHGcen5Vbgl8iSOUBtqgOxA+Y18pf3rHvw3P10/4JSfso eAP2vvinN4T8b69badjUPI061uFzuYGP7i55ba2/kH7px3r+239lj/giB8HP2fvEmjeOPAniOO7v baVLqOLcgupGZwzAyc8HGCBj65wa/P8APauNxOYVsDBv2aS9Nk/zPu+HcThctjRxk0nP3vXqvyP6 FtKtWtPDTaVqk6l0s2tZXY5jRTHsIzX4D/tef8EW/g5+1N4x1zx7qXiuKw1G4m82axRFaS4KgAby emMAc56fhXs5Jja2Ay6VKl9pWfy/4c8bOcLh8VnixFX7HM0u9/8Ahj//0P5//wDgpF+wXc/sVfGH /hGLTWrfV/D+ryT3NjLZ3SzMiCRgBJHuYo3AHBK4HBPOPmH9lRbeX4+/DNEeS3mh8UWV2TNFvU7b uKMHA6kbicegr1swoVaGDcay1cW/vudPC1aOJx0ZLdVLfc/8j/XM/ZRMQ+CHgTdtkdvDllIZQCj5 aJSwK9uSa/lu/wCC2nwI0n45ftafC7wlreqTWfhya1/s+9vrmz8qOy335TBbnKkOMHqOTiuDhiXL g60l/Iz0uLaca2cwpy61PyTZ0t//AMG2PwP8Z/C221fwjqUUdy2jm4t1TUXdJZ/LDGQFcZOeo59j X8fH7X37IHjj9lH4ueK/hz420jV7caPrlxa6dqJiae0vbdCPK8p8YdMHO9ckAgEAg1hlcq+Idp/F fby/pHjZ5CODqwjD4W7eWh8ZXEem3RUbvMktZTGNy4eMDqq59e49q/ol/wCCPv8AwS0+DH7a+jvr Wv8Aju4/tQTOl1pHkLY39gfMG1I9xJC7SDnGSQ4zwKXFWKngaSnSWrly+a31/A9Hh7BQx9fkqOyj Dm162a0/E//R/Txf+DcX4dabY3zeEPiZ4l0y58kwWdrDfibeVGQG3DnJHAXHSv49/wDgqZ+xv4r/ AGJvjlL4N8Q+IL7XLbW7U6hpkskf2hJoxPNAGlIY7XVlJPA+VupGKMleIr80r+7Zt/d/XcWf0cNg 8RT5Iq8mkvz/AAPyZh0e5hvLZ7ibbDJfqiCPLyTl2OI1UDOTnAA9K/oG/wCCWP8AwSvv/wBrfXpd U8RXd7pnh15F8iOfT9tqVwmY2LhS5JySATgg9SMUs0rOhR/d/E3ZHrZTg44vEONT4Ypy+4/odvP+ Dbv9nuys7i1m8R6daveSKxU20cG0jB2qocAjjPanaX/wbdfAO8uYFm8XWkEQX91/Z1gLcyuMcl2Y 7iMd68tPH06dnN3Z6dKGXOpZwjp5H5o/8FKP+CAer/AX4a6z8SPhFfL4r0zRbY3+o6RdBrrUJowQ G8qRAWOOW55XHpyP5EvFWm32kXuoWN9pNzpt5pc5t7+3lhbzEI98fMBg8+xzX0OCXNgoVJ/Frf8A H9D5XNHH28lDY//S/i7CSRogU43DJGeoqF5ETeeASNoC+vvXoHLD4UJFBNEpnkUtGehU5b+fvUkM CtcCVGDxyHarHjHSg0jpJHo/gaK60/xv4AuYGZbseK7aSFACxwjEkkD0wDiv9bD/AIJjxRH9lfwE 7wLGZNFRll3b3k3YYn/x4DHbbXz2bpfXMP5N/ofa5Hpk2M/7d/U/GP8A4L4fDZPijqXw68HX4ddJ uPExhu9VaPzIbKOQLhnAIPy4zx/dryj4Xf8ABul8GPiH8ItJ8YaD4yePxBqGnLc/bYZGEMqNGreX 5e4cYOCCc5HQV3Z5XrRo4anRvsrnhZFgsPLBYrESS53NpX/NH//T/D3/AIKTfsAeJ/2LPiZr3hDU tO1JdIaT7To2q29i09pqULMqqd6jGe5HUAHk4r57/Y6/ZH8UftF/FLwn4XgsZrfQNav0TUtUhh+0 fZooXDNlSv8AFwpUcjJ9DjLGSqYbBRrJa2/E78LhXiMxpUHs3r6dT+yHwl/wbe/s+XvhvRdXvvEF 1Z3V1pUJuYA/lCTK5JYAjHJPFdFcf8G6H7OhktHk8cyzwBxEU1R1aDYBjYjb93Hp0ryqcsbKhHmb u9f+AfRVqGX0a84wSsnb7v8AgnL/ABa/4Np/hSPhnrMvw58QRP4jSymeyut52yl1+VCqsWC9vl/D Br+OH43fs5eJ/wBnb4l+LPhh4/0VdHufDOqS6bA6B2hvEjJBKSNkMCAMEH17g16+X0qlSnP2mso2 +48jMadKMlKjon2R+gP/AATU/wCCdWjftaeMA/iGTVtM8LXF0llbQy6Z56GTjexn6J1G0c4AJJHb +lpP+Dbv9m2xhW6PjjVopZokRrdbgR24bH3X2sNwPQgfga8h16lXFVKdP4YaaHV9UpYfAUqs7c0r v5H/1P0GsP8Ag3F/ZqWSWLUPFrw+edgihcqASSVZTJIxH618n/t7f8G+Oj/DD4N654++CCXXijVN B09pptOu9S3LcRiImWRB2dQCQuMHP3vXyoKvPEwU78p7mIhRjh5uFlpofyx/AL9n/TvHfxp0X4O+ Ptdm8EGfUmstR1S6s9kkASTaVLk5RsdzjvnGK/tA/Z5/4IJfs3W+m+HviBpni59T1O1lgvvP1C5S 6F1sUYVkUjk4z/LHBrbFqssWqCXuWd/vKyz2McPDHyeqkrX9L3P6Wfg34Ri+H3gjSvC9vcGe10u1 S0t5VAWMqihRwPQYH4V+fH7cX/BOn4T/ALZOr203jLWLazurNJHSCSMDzvMK7sHOc/IvQ9QfbHRl kpUKc+TfVf19xee8mPxUalTZ+9+H/BP43f8Agrz/AMEovBn7IemWvjrwl4ktLvTLm5j0p7K3l8iX fIpaNnjDHd8qMOcdR14NfzmXdvAwdbVvLwuEyvGfQiuupRnTpRc1ZtX/AK+4+f8AaxlUmodHY//V /jit47yIJuCGMEiR9pyT2wfwq3GAXjVkwYycyrna59PSpl8LLg7OxdzIAyjO0cD/AGqiNlDcKq3D /ZyrCRWL7VXaQRuPpxz7ZrE1P6K/+CS//BO74QftbWOsS+MfHQsrp3t21LQLJ4Ft40KIscsUhBJU sCNx5+U+1f16/sc/8EwfhT+yVrdpqPw+uLS+uShea+e4M+oFSe+OAORkjrtXOcDHhupXxNSvCa92 Lsu2l1+h9bliWVzpV4WbqR+av/w5+rPj3RLPxH4PutC1C6+yQ3FsI3lADEgKR/Wv5z/2lf8Aghj+ z54//wCEr8f3viLytd1OeTWtxeK1jhbluhP8R+Yk9O2BgV9FhJzWEVBLRniypUpY2tVqb7fmf//W /nL/AGoPgfpXwk+Onjf4a2d7bXY8IX72jajbBhLeBXYrJIMkNlNoyp/hPNfSn7AP7C2t/tYfEnSN J1S08Q2/gtNTj+06tpulM9nGkbxsyPI6EZbcAccqAx7GvEzStPBrma95WVvmfQZJgFmNSFKTtH3m 36an9dGh/wDBvt+yJBoFnJqeta0hubQLd+bPH9niLgMNqvFhSp9P/r1FpP8Awb3fsZaMRNb+IDcX sty3m3movbuxjfoi8fKwHGec13U6GIqUle+y/L/g2OhRwirWSVk2lfyfQ8o/ai/4N0vgZf8Awk1P VfhHqP2TX7fde+fCyg3rRozKjRoB8uRnjJHOME5H8WPxy+E/iz4RfEPxJ4M8WaPBotzpN6Ut8q8c dzGrmImPeA5AKH73OOvOQOvDwXsJc2sk/wADkzGnTpVF7NWTR4O9ykYbYgLsNyHHJHY/Ss97nzWX Prhl7Zrjl8TPKsf/1/5DJSrhgvQNtP4VPFi2mjZcMzY87cuQ6+g/nXnO6Wh2RSuvQ9M0eO68RX+m +HdDsLvUb7Vv9GSK2g80274G0EdzyOPf05r+tf8A4Jrf8ERvhr8Wvhfaa78bNW8RXk0yi5vbaa1W y+yNIPkjiXaTjg5Y9CWHFeXiqkvbUqMVdyevl/X6HuZZgqWIjUq1XpFff/X6n6jah/wQR/Yk0sRW xv5Le3A3w297eR27wnocM2GrT0P/AIIG/sUXfm2lndy77yIoiw6gjFywI3AYPXtXsyXvJHHBWij8 Lv8Agqf/AMEc9N/ZI0Gbxx8Lmvde0ATN/ake9nu7G3X/AJ5AAgjbk5427T2xj+eTw+sNx4u8K6bY w3F3JF4kt/LR4izSmKQBkkHXJ6Gs5KyaNElzJn//0P6vP+CZ+krZfsxfD+BgkTppEa/ux8kayBW8 tfUD+lfl1/wW2+HFx8TNd8B6VqC3lt4RtftVvqlxBaG4hTDxCKRugBO18c9uhxXm0l7iPo6i95mR 8DP+CJX7InxR+DGhasmpXOp6q+m+bBqcstu9xHPJECwKKnQkZwc4ycHpX8x//BTn/gm14m/ZE+It /eeHlutb8DdbbU2icPZszEmKQdCgIK8ZxgYPBFTHSTRbguWyPz6/Z9+Fvhj4jfFXwh4f8YeIL/w3 oGo+IYLDUltwiNKkwJ2qzcDdgc84BPBOK/tU+An/AARc/Yd8TeAdI1rV/EN7q/mRLcPLd69Gyvle MjoRjB79T+O8Um7GDinoe/8Ah/8A4IkfsN6xcHTtOubK+k3mQ2yQW0kcgGflkAU5OP8A9Qr8C/8A grf/AMEbtE/Ze0y2+IXwdjmTQI71rq9SKK41CWKLdzH3URtu9tuw896IpSqpI5sbT/dpn//R/mK0 XTk1fxfpFnI8tlpn2x7XW78WX2iawGzoIHwGIOCM8dM8Gv7a/wDgnZ/wSR/Yi+NfwS8LeLJ9Qm8Z 313p0Tz3UskQS7dIvJcTW0YABU7iwboX9AM+Lj7xq6eR62XwU1L5ny7+1T/wQ68E+APjj4b0rwXJ qo8Aa7qQe5tdNRgLSPfkjcQUTdnbnI4XI6V+r3gP/giX+w/oXgjQ7XWtI/0ieCN7m8vhFc3cfmKC yh3GFJ+hx2qor3RWSnY8e/au/wCCDv7N938KdW1b4MRNYeKNK0e4n0q6mjFwZCULKPkUZxzt+YDr n1r+LL4k/s/eMPhv448S+APEWh3Meq2eoNZ2EUGnys90pJVGKHlQSOpPA+lJWeqLsf0Kf8EqP+CO /h74saHaeKP2gtL8XJptxArxaFdBNP01Lfzd5R1ZfMJfaPRgHxxtr9x9U/4I8f8ABPLRMaff+GtG tGkkLQw3E0cVxESOApb5yB7ntTtYmXws/9L92fC//BH/AP4J5/2obOztLG4upF2PapeRXMTgnIJi b39OK/OP/gqD/wAEU/hl4O+G+q/Ej9nvwzAmqaTYlL3SNLgeIXygFmkEajlwm/p1KjjFeK43Vj0D +MrX/DaeE9UvtF1OK5hu7W6a3todSha3vrJl4ZHU9x059q5m8/dQNJNvmjH8ca+Y34Adahwsrkp3 YRW8DQW97F86ldwimQxMwJ6FT346GpZrkpIkckbxGdSy/LgfnWSik7lGpZTLFDudiqj5VOMH/P0r 9Iv+Cev7cfij9jL4uxeLtDvLhPDGqeQmvWsUgnaZw4LHEh2ru+XJz369MTKNtTrp7n//0/66fgZ8 Xvhx+2V8HbK+ubyOVfEuho97BFfRXUDmWPDMrRkjnJ46/Q1/K5/wU/8A+CSV74Y+Js2u/BPwvq2s NrQLyWVjbTSwZkYyBoto4wSBgcY4AwvHzrVos9qK95H5b/Bj40/tN/8ABNj4gx+IE8L6toY1SYWe raDqNtM0F8Lfc2UJxtbnoBnCn6j6h+PH/BfX9of47eBtd8BTeE7/AMP2evaU+jXN3FqCyCG3ZCjy oDGrByrNjn+I80sMrya8zpr+7BH3x/wS3/ZM/YQ+O3wyh8S+OU03XPE2qTMfEFxrV6kctvcHBITD YAHJ7gnOSSCK/pQ/Z5/Zs+B3wVh+x/BxtOTTIVUCOyCMyK2MfOBk52j8B7VWJfLyx8zOjG/M/I+g Pilpfh7xR4a1Dw/4slaLSdRgMF6yzC3VI2BViWPAyOPxr8Kf2rv+CcX7BWt+Bdd8R6bcafYeI0il liv11AASSrG3LIuA2ME8D8elbQj+6TOJp+2a8j//1P5/viT4K0Wy+KfjLwl4JuZfEum6V4ml0vS7 7TE85NRfOAlsh5bB4+oNfv8Af8EqP+CXFx8Sda/4Sr9oDwXqL+HEt0j0Sw1G3bT1CMY5BcTLgHeV JHynjH1FfKNv64oeR9GqdsJzeaP6KPEn/BMT9gPwylqms+FtC0rzIhcLb4EM0uRtZi3LYNY2mf8A BOT/AIJvXF6bm38MeHdTMuyP/SLwXNjB0UF0I5x75rrxseSkmcOFi5VeXzPmH9v3/gjB+z74l+CX irXvg34bh0XxXZ6YJ7KXQNOMRfaPkjVV4CN8u4jAxnOOtfyo/s3/AAF8A+Fv2j/C3w4/aR0660zS 9E19rDVk1m5Wxs4p1cLCXzgGPbk7jkZI64rCjHmwzfkb1YcuIUfM/s90P/gkZ+wb8WvhFBJonhPw 9f3d9pOyz1eykF9Ikjpy25SVPzZxwcfz/Lr9mj/gjn8PfBv7QPizRPHXgxNW8E2+sztFcahbvYWD 2wOYwi87iq5BweSMY6gcuBfPRUulzqx1LkrNeh//1f6RNO/4JifsH2es2um2Xw80e0vp0At7eGFE Ztyndhfcdq/FL/grb/wR2+Hngfwfe/Fz9n/Q7nTbrTnW7m0nStMuJorgxMcmVVJTB3qp74BPQV8z FWrpHuct6TZ/KJFBBa+N9J0/XLUww+fINb06Yiwls3iykqOT9wg564r+yL/gnN+xx/wT1+KXwd8O 6vrek+Gb3WYbFJLmxuNXhd7Viio/yr0JdZCSeTuHTvpVXNOyKpQ5YXZ+kGgf8E/P+CetzqCWOmeH fDTM072otI594JPJTjBOM9zXwF/wUz/4Iv8Awe1L4S6z8S/gZo6aN4m8OWElxaW2laMHN8U+fbIx B6gAdRxn61FO3tOUqcHyXP4uPiH4E1HwrdajouqWd5YatpDRw6nBNCYZkk4DFVwDgkHtxmv0X/YA /YK+I37SHj/Q7/XPCmu6f8O9KeGPUp1sSiaosrI2wOVx8yHJIPQkZ5O3LG2jiYR8y8LTvQlI/9b+ gDS/+CT/AOwl4Q8FaRfeKPA9hZvCifbbxp2tEEipkmUq4JxzxjjNfFP7Xn/BL79krxd8PZrb4LPB ba1ZxSaxFBoz/wBoR3rgqqJPEfmy2TtO7scj7pHzWLioYdM+iw0eaq4nQ/sPf8Enf2aj4Nkufi/8 Pkv9QGxYZL2BrVIxsH3YuMYIcknOc9RjB/OT/gsN/wAE7v2Wvhl4ai8X/BS8hs/Ep1qLT7fRYZHu IrwAMZUVTgkpkH+IfMBxSUEqEpDcL1oxPNv+CWv/AATIh+JGt2Gv/Hn4f3DeGZLln06PUbGe02JI iqpMIxsyGJLMc4PsRX9Edx/wTC/YA8GtbDUfBWgafIkR8iC61MrCobgsEkdgc9h+FY4WKlTuViYW m0yppX/BN7/gm3q2ppa2OneEpb+Bgz2C3cBkkLHgbCoz7BelfGH/AAUR/wCCMnwAvfhxd+O/hFpd 3pGs+H7VZoRZWkuocKWbBQBgFyxJz8oGeBwa2UGpnHJfu7n/1/5w/Hvw78SeBfEN1o/ibTbu21G3 u5lMU1t9nwqscMFIBA6DkdfSvKvJlv7tXljVPKkKgMchQpIDAetfPVIa6HoJWVjU1i1ljhW90Uyy m3j/AH5YAfOOMegGc9awLP7SkqSXQklvplJEFuGmgwOeAB+f0rAxluWnu7C9tvtcSMRAjeeWTGwq SG47Y/pRp95YxOkIBeV2EqRhdq7T0IP+etYyVnYcZWRdFrb+bJOII2JcySNLjcCeBt+ntWPfu0cs Swx8O+GfPKispxvsbKTWx//Q/mF8NCxF5FHfxveWgbdPCjeUQO+G7EU66020OqXkmlZhtJHMg82T zZSOmD+HpXxCi3selzO9yv5MYLI4KjoTjkYqSURSfZ4JoVuYrc+ZDLJ13emO3U/nVcjFdozEktrr VWs/O226qCzONqLj73PfH61radftbSXNrDdP9l8pnKsNoTPGB7nA/Kk4MRRe+vJnS0t7iOKOKMxp JIcgZJOCMf5zWNN9oiLhpVnkPK7QRGKTi1uTJ2Vz/9H+WoSA4JLiVI8CXuD6CprS3bUmuLme4z5M QVBK20Ap/d96+HO6LuiN7mN0aPOGgJ2kHAftUcMkUVxbzMqO69RJyh55yPepl8JLm07IoX11Gb83 MLKo8wmS1iTakeDwV74P9K1lW3lj81Y445Jjuc7QhJ9T71k1YuL5kVoBZpJ+8ETSn7kq+gq6Zftl je/ZZR5lq4SO1lBjeY8gkZHHTr70hn//0v5XYjHZpN5luSZJ9jOqlyD04x26c1FPCzspiV4u75XC gev41+fnoGpYXMsskVnOQIvuWzquZN3PDH06fSrWq2zaPONzedujWVkGVaJj1U/570GsFoMnuYmh NxImFCbiQPnIx296zJXtJYkuLaPbGfuqzfPUtXaLKcgYI0gDK235DnGDj1qZ9SeS0TchWdR5RZOn Tn8TUzRpCTvY/9P+WW0a7uLW3kO+MNKY1VvlZwO4PWtW5ji8pIbmW6jVmG544jOzY/vD0/zmvzc+ jg+hlyTW8DvHFIXjGQsjLtyB0JFNgnu7sy/ZY4ZQibpFMgRlA6lc9a2grIuTsi0Lx52gEiDqI9uz HC9c/wCNbV5eW7okqWyLJHDhArHEjDpnPTNVYad0YsH9noLnWdQjngla2EQtbYZSV933z9OfrWVq mI/MvLdmuIkZI/NZMCNnGVQ/TBH4UDP/1P5a9OtZ7iwlkv2jiliQvG6fL5oOMDHrz+lZglij8qTI 8uFtxWQcSelfn59OpK1zautbsm01t1u3noC0rohaPb0GR7c1Ut5HvI2a2MZQw7ySQGjx35/lWHQw b1LtvNYypP8AaN4njAUoEDIw7554/I1DZ2Md3fSTWymKEn91bfeXNb2NYS6GpcW7s8URSSH59zSb tiEDqD65qa9t9P2wi2hm+0A/vyz7oNo6Eeh60Wtoiz//1f5edQu7XTrLzIC8z8s0Ua72XHoe/SqT XEskEOzT5G+2FGDiMmeMEccfU8/SvhVFWPqDdgkNnuBhMk+3BQ/fyO1AiigsbmbW4V8uZvPXZH50 kbLnABHbJz+FNdR+RXaO4aazkjQeVGfNHnN5e0YPUHrnJHNXYEk/tBo3t28uceZkAeUhPTaOv+RT EaF6Dptk6LBLMssyhynzSRgn5sZ7c9Pat/w7aq95N5d3JZq8iw2NsYg/yn+Nj2IzjHfFenly5sbR XeS/MxzKXLgKsv7r/I//1vy18JRW+l+HbUBJo5bvTF8uQMWmvZSuzeCORuIOMe1f15f8EjLCeX4U +FpG+zPqEOkxrcCZPLurWOGNOGzzk7gDn+7X9C+LcfY8BYSku6/I/MfCSTnxFiaj3s/zPpX/AIKV eIrXR/gZ4nQwGWTWbWSDkFDaxxqS+0jnB3En8a/iF8QvdXUl7JpSPY2lh9qktLSK6YtdrlnZkI65 GSB2Ga+u+jtScOHqs31l+SR5fi5WX9vQpf3T8mf2lxJPq8kUCTm8h03zTaW8PlXYHyuW3DBJPUj6 V8Laheme82SSX6mRVeSG6iMRRwNpA/Ida/HfF+fNxriV2t+R+h8ERceHKPzKKWhMrJs86GRhtB4O a6KwH9ntE4jlN4subcFSFh7bgc/WvyqppE+nP//X/i/tr2KYmW5GSMGRepJ9feuhW+QKpVGdCm4Y XDY+nrXjVnrY71sYNtLfX1/JNFcSQxhClvhclDn7/PcHGK+vfC3hi2vdM06/k1uKa4uLdPMtZnH2 pZwuW3D0bqPrXmT6DNCOTU21Cz0mW1fe26JZI4GMJ5O0BunPvXRrLPp7vpTxwzZbEkvBNvtyTg/X jFefU6HQXdJZ764mREDQ25xIzLjAPpV7U9TlgUQWTBI7dsJIigO5znJNc09XYcd0f//Q/jysoJL2 FjBLLDCqCaO1mUoEccYHv2z04602S+kW5a1uI7c4tkCSRusjxDncjY7t1Oea8jdsjVWsTaja2/2R pC/2SGNRJK2QBFjowFbMfiW8uNOt9MXUZTptpN9qaQyk+cCiqN3PCjGQB3JrCSXMax+I9OgsNU0/ QIY9F1XTNTvNQtzcTmORPMtI25MbjrwO2euaxI4r0xtDNbw3PmKTeRzDEUqkdMD+VEVqbuPLZXvo vxV/w2fmN+02VpaNbzWvkboiFHlkxqoI6HoD0wK4bUETUdSmnkeacLahIJZXwylBhMjnjGOO2K0p O8ri2P/R/jR1YXU4tRFAUulDAyFuTj2PHFcLdanJY286/wCkx3kzbPMkfEDLzuIH17UsLohzdmzQ 8JLq1zffaIzIYFKx27iXycTkjYY27MM9R6iv2D+HZm/sPwok6XJ2aPB5vnsGEpxhgnHQnPP+Ff1N 9HWpy4zGw9P1P528aqd1hZ9ub84n9Sv/AARM1a3a+1nS9PMy3ehXAd0KMA+PLUOn+zlgPX5TxX9J nx3vZk+F/iC5t0MNw/h+7uLo8oYwYsEA/Rm61+YeMdNU/ERqXWS/Fn7/AMPzVbwrw810pNfcrH8G /wC1LbvbfG3VoontrUai9xKl0IjEJRJHbOZJz0yuSo/2R718d6pawXFxcKjpJ5CbkdThZucHFf3X whL/AIx3Ca/YSP4PzdtYyol3Z//S/GaeG4tlsbm1uGEkzm1eCMnaF9PTGc1WvLbUop2uXUXCiIJJ Fu/1aj29q/1uVkf57wm+UotpEEtw09ksqRvs+aVzgOR6dB0NT2gU3E9rdxzW1zECGn8osRtzjp74 GfestNTrpyd4nZeC/BnibxhdvpGmad4h8RXi/vpLfRtIm1PaSMRJtReNxA9+tei+Mvgn8SvDmlpp 3i/w9rHgrzZE8m3vdLlaTUSVzgjaNi4zkk8V83i8/wAswmMjltaqlWlay/rb5n3WCyPMcRl88zp0 37GF7v8Ay7/K/me6/sZ6lZ2X7Qnw4sZ0m+w6frEKX4htxJtEcieVjOcLlWB9q/vu+FEUd58NdKa2 jtxZS2kkMSQDDxKFGN3PXGOPWv5G+kXJyzDC9tT+p/CaKfB835/5s//T9P8A+CwWk6ZYfHi1e2Te jXcsUs0Lh5oUkihIXGeNwPf/AJ5j1r9kv+CQ2rf2t8G7JHNyXtJv7IhmbDLNDFEiHB7kNDhj6sa/ pPiGo34O4S+9kvxPhfDOlbi/NeXa8vzl/ke8/wDBSrTry5+AHimK2RJVuLQRC2ZMef5izKxD+o2q Mf7Vfwma4DqMerwzXFzaz2968UU0Dtb/AGT7KSEXAPIwMHOSck9cEe19HN3weMhJdV+R8h4uWhxF QV/s/qz+uv8A4Iu6hHf/AAp8OTJez3dzDZ2yTqzATBJrdJZWYf76yjivvv8A4KG6a1/8C9We2iI8 uTzA2N4LFXUFlPUDr+FfkfG8lT8T5qKsvar/ANKP2bMlKXh7T5nd+w/Rn8EfiO+k0vX/ABToWkM9 xNZeILq2uri9QFLyQuXJAzwRuH41ufCnVdR0r4m+C/skMy6jqOsRWZQE7EEhXaSOxBAINf3U6ar5 KoyWjpf+2n8j5JiZ0c1oYil8XtIP8b/mf//U/rf/AGQZZJ/gZ4Ltnd57htHgmknlB3Su6FWJPqCC K/ED/gu54SSfwfpU5uJYEa0tLjVBbSKiySRXogC7jxkqpOPVa/VOCansfFiMVs60l+J854w05VOE XU6rkf4o/l/kFvAqx2qSnKBFWY7u3GTX6yf8Endbt9J+OGmaHOv2a7muf7XTUFn8tZd/lL9mBxkY YOQO/Ff2d4h0I1eEcVB/yflqfhHhXU/4zHDLz/NWP7VdTge78EwpLGsszaakzgsH8wqRu3Hoc4Nf xV/8FAYL3w7+0hBcrKVdLH7RNLOwWWJIL+WNoUTqD8oOevz9cV/GXhFVjDimtTa3jJfg/wDM/bPE em/reEkv50f1Bf8ABO3UY9R+C2gndK1z/Zu6eUnhncq4LL2OABXyp/wWA0G61L4N+IkulR9NstLn vWnZ9vns6xB1246rsdxz2rjy1xw3iZSXRVD3/FCnOpwTWUd+SP6H/9X8lXu00aWxgljmlsZwRE9u hdY052Fz+VRXsel6y8KPJdx27sHSe2fy3RlY8j1GMjFf6x0YtxUvI/hFySTR0M8ltoMKx2Oq3Ooa a8SxPC0DRkuTyNnPGe9ZF3ZxX94LyOSKCWZAGiiG1iq9F+greKu7Fyb9nfyLnhnQX8W60PDel3Tn U0uYhC4TMcRZ49yDIO4lWOAO5r+jj/gnb/wT8mM8Hi/4h/D8614WKBNMfxHZyahChc72mCD5VJ3h gO24H6fkvi1xNHhvIKlpWqTVo628tD9U8K+H3nGYLE1Y3p09/W1/w/rY/bfxN8Gf2MPBOi2MHiPw B4G0VFRSG1ecwbpCCpYjIUZIOM+h9K9l+DWl/Be1uPI+HS+F7eWC1WKC20G6Eu2LHCpyRggE4Xri v4ixmYZzj8E6uJk5U3u7H9PZVDDYfEOlhtJXs15Xsf/W/r4/astE1X4ReM9MFsCH0fEUjvtWE703 sT2GN1f5/nxo0ey07x54mit7C4to/wDhJbuNGe4M0s8iNiVgpPCk9M+lf1f9Gd2q42Hl+qP598ca bjnNCrbeP5M890yFbYzXN472zof3cDAfOP8AazyPpWdexm8uLnVUxNHGAHPHB6DAzznH8q/rmWiR +GJ3iyMRQzxtDHIIbyBfNZduRICPlXPr1rGaG4iikuGdvLjlCSQOxaVy/A2j04oNErKx2+iSPG8W yNRFjbMQN3lAjt71/Sx/wQx1u3XSZtNVbme6l1j7DbTyIBbMcF5XT0zmPHfrX4z44xc+Bqz7NH7z 4IT5OJ0n1i/yP//X/tG+MF3quh/D7xNq+izCDVdK0ea5t3PG1kG3I+nXFflZ+x/+3dJ4g+Jev/Dv 4qeNEGoQapLb2EerQCKaQpgYjZQoPGWA7AHqMY+pyDInnWTYypSV6tKzXprf8bGmZZs8u4joYWXw VeZfNbfhc/RP9pvwVe/GD4U6hovhtxe2t+IbiKSFixnPzKCu0E/xEH09q/lU+GPwA+If7OH7UllY eMNCuNMtJfEYt4ry6RzHcRy3SyQzHPy85QZ6kE8da+88M80o4PLcyyupJKc4OyflFL80fD8ZZbWf G2WZq0/ZxSi+1+aT9D+x3wbeLd+EdNmaMQlLPyXMS7UOFHIHpg18u/FfxX+zjpmqtJ8TV8Frerch nn17Sy8rsQuPmxyTx0/umvzPL6ONnmE6eBb9pfofoGd18Lh7Txvwba9/87XPMm+LX7CyTpLFrHwt tbu2lVvMtNPeNww6ZdBjI9DXrA/bK/Za8N6ZFaXHxk8DaTaGMQ2aQ3Rg3KqfLHg4Ix6jtXv4rh3i bG2jWpylbu/+CeG+IMlw1CbVRJH/0PuP/grD+0F4F8a+J9Dk8E+LrDXryKxguPtHh7UFaaAhZvK8 mXkLg8sx5G31Ir1D/glj/wAFKn12fTvhD8Z/HNzaapYSNp+nNq8Rdb1YyNqfaeVLDeAPVQT2zX9S YzgGtj/DGlB0/wDaKS5l30vdf12Pxjh7jCFPi+vTcv3M5OK7eT9enz6n7afHr4I/DH9o/wAAazJb WGk65eXmmSC1vkIDO5UqpBHG4HnB4yor+Znx9/wSQ+OGg3+rz+F9MuLvT4rxr2wvre6ks9QtlB3D JVdu4HkHA68Y4x8f4dcXR4fw9bKswlaN+vTo0fT8Z8LVcxx1PHYRPmUenfX7j52vf2uf23f2eoLj wZN458UafPpMrWN1a6s3n6fZREiNZCGB3E5GCxySw7iux/Zq+PXxN+K3xx8HXvxI1oa7c2Wq/NqV 0qh76IjcfKAwFYMcbR3Oa/Z8XwpktPIsRnuDguecG7r0f9fkfkfDWd5liuNMPgMU3aE0tX56n9qv w+mS58Cadd211KEu7HEJKGN4PkyMA/XqPWv5G/8AgsRBbv8AETU3voLlTceL0tw1quJJWlihYyA+ hbBOOpxX4J4ORtx3br7x+o+P0nDJsO0tHUivwf8Akf/R+Yf2d7p1+NXg2K1lZH+3pbzyyKfMXLDn djugev74vgBcLJ8LvDklqpNsdPWKJXkLOSqAMcdgTk/iK/o7x1kp5rStvb9T5Dwsi6fD00z8pP27 JJJPj38NnuYVRtP1jTwi7MRPG7qHdz35HX3Nfsn4BUS+AdLeAEK2khLdl+ZeEGDg/wCeK/J80hy5 fhGt7fqfVZPUbq4yMu5/KR/wWF0+WH4iR3DyiP7Z4uaxkljUG4gje3UvtJ6Btx6f3Tmv0a/4I7a9 d6l8NrWG6uZHu7a6e3e5kjLSyqkjICT33LsP41+p8VPm8N8vXZr8mfmHh8uTjXNf8T/9KZ+iX7cd jPrHwR8Q2MYZZZvJZZ2XbiPzAjKD9HJ/Ov4HfiZDY2/xD8UaBNcNdaloet3FvPcmIRiQO/DBhxkb SPbFfXeBkrZVioR7/ofK+LUb8S4eb25f1Z//0v1F/wCCJKSnS5UuJHmlguSJLkTbg3zMY3X03KVB x/dr+iP4t6pd6N4K1rU9Klkj1ax0maaJkBYB1XG73xzX6dx9b/Xes/77/M8/JE1wdh0t+RfkfxZf tN/tb/Fdfj1fP4ov77xXo/hXXv7P1HTtQ2CCaE7GPlAckhXLDsG9ia/p3/ZH/bk/Z1134Z6TaJ42 0fR5LaxhWW21SbyZi/lgOCRkZHH+Pr+oeI3AVWfDuBxuUUtFFKSXTz/4Pex+QeHvHNKOMxuHzOp7 0pPlffuj8+P20/ih4C8f/Hb4bjwj4l0LWUg121jWXT9VSe6lf7R93CnI5DH2OPWv3t+F1wJvh1o6 2yN82hxvH52SVLRj5TnnI4/KvzXjTLK2WZPluGrK01G7+9n6pwPiqWNweYYim7qU3qfynf8ABbMm 48U2UZt1ZYfEBR7x0+VYwkTOobHJJEoAHY1+BV9ql1ZzRalZTGGRGUxXSqTJDGpB2r0xmv638MKS q8FYOMdnE/lDjSvKjn2NfVTf5n//0+G+E/8AwUY/aa+DXhw+GvCnxPuV05pov7H07VLVNRaONgPM iAZeAWJIznGTyM8eifDL9rT4t/tCftH+Ek8f6qNTluTHYpC0MVqtlHE5kUoqDAy7MeozuOa/v/Ou E8ryXAY7F4WCjOpCS/C+ivpqr/Lsfyfkuf4/M8dgYYuV4xnG332+emn/AAT+2b4SmOT4daLIqRrF 9gjji8rgEJGATjtyK8K+L1n8AJpYH+K1n4KfyZh5Nx4lIiTLDPzE4ByBj1OK/jDLoV1mdZYf476f ef09xFKj9Wpyr/B/wDybSr39iw3gax1L4UWssCbh9nvo7JoAp+Ubiw9BxXu/h74+/AnQYYNF0bxz 4QS3ZDsCa7FHBARk4DEn16V7mZ8P55N82IoS/wDAX/keDlnEWSww0qNGtFeXMrv8T8C/+C3XjLwx 8TvCK6DoHinQ9SuDYWl+9rpmpxXnEVyGSVtvIyEkAz18z8a/masIbGBbuxErNc26JbwyTSACEqQG LYHPAxx3r+5PCXDVcHwHgMNXVpKLun5yk/1P5E4vxcMRxZjq1N3Tm7fkf//U/Jp7KWe7KFNi7T5z xvuU4PUf0rSsrmS2sZLW3A1KG2mzchWUSQ7jty2OmDxiv9fqaP8APCdWxZRw8KuLbCuT8pXC8d/8 +tJpU09wkiCNoMMy7GIIbGQCMVo17sjfD1VJI/of/wCCG97baf4z1iMW8izyW1uNlzlcyrIynb7Y bP4Gv6vvGdzLpnhTUtRgbY9jp814hxlcxxs4BHpx0r/OXxhioeI1Z/3kf3Zwkufw7w6/6d/ofyl/ tJ/8FXP2hfhZ8T9d8L6Dd6RNZ6ZfOrQz6dHdXyxH5k2r1GF2+nJ618q+PP8Agrx+0P470y00rWZ/ DUVtMnmyTQaWy3ky44Rom3KG4GecV/RfCfhZknsMFniTc1GM0unNZO9vLQ/mLOfEPN8T7fKZu0JN p2vqtreh/9X5N/Z51vULr9oXwl4laCb7d4i8XS3V+73Pm+VFJKCIxH0XIY5POCa/0Fvglevq3ws8 OtPLHGiaSrW8MY3LgRjnPfJBr+ofpCUnHMsH6P8A9tPybwVio5Fi4rbmX5M/nU/4Ld6X9m8P6Rq2 rTWwsk8RWCqjYiknikSVZDkddhUHnsDX853w61OQeOPCuqpPNNDN4gjWZQ+5pEZiF2A9Ow47Gv1X wzXtfDhu2ijP8HI/Ns7ioce1KfeUf0P78v2Hbma8+CXgiWWMRs+neaVU5wpwmD9CCB9BXw1/wVT0 pzrPgO5to4Yp4pYw96H8ueQK7qq/gWLV/KvDqb4omo7Pm/U/oTjG39iUpPo4foj9MP2Y5fO+CXha KU+afsMbM0gzIjNGNwPtmv5+f+C5NvBo3g2z1Kc3F0bTxXZFLcRgRPFNFMmCvruCL6HdX0HhkpR4 +oxj/O/yZ8/4scr4Kqzl0jH80f/W/Pr4aC0tPEuioxu4BLdxoJFG39/I6rGrY4Hzt+Ff3+/sK6i1 78FvC4dWJj0eMPKx3LLLgK/PttP4V/Wf0i4qOKwkftcv6s/JvAd82RYhra/6I/M//gt1pMl/8OYL W0kNjc3cCSpdxrlCy3Cxpvzx1ZB071/GleLc2uoX9lezhzc7kv5tu7ac4ZiRx+Vfsvgg3PgHCp7q /wD6VI/DfEK0OOsao9/0R91/8E/oZLP9oX4ef2bbBtJk1Dyluo9vmBmwZHPfcVjUV/oD+Ays/gfR VyJGfSkBTaAJCo+UfQ4Ffzx9JFL/AFsof4Yn9O+EWvADT7y/Nn8af/BcTS9GHx08Px4eC+g1y6S3 kgh3Kh86Euj9vm3RLnno1fhT4ktYUVreJC7TSFrg/l/hX9jeGEubgXK/+vUP/SUfxnxF/wAlDmK/ 6ez/APSmf//X/FyC1drhIYo2hWPEQZRsEhPr61sNY3EIeGVXV1BDEDkH3r/aNL3Wf5yQ0bHaNDb3 MbWMsHlyRgl5XYs8mT3z/SpZLQ6ZlY7R7qJ3KRyxkBM+mfy4q4fCilJWKaWOnRedLcyPFeqPMaKJ AzAdj68YrvvCcVs76dqVnOs9xb30VzLDexBnVUkXIVPU9v51y5g3HAVmt1GX5M78lSqZrh4Sdk6k F6e8tT++D/gmIy/8KF8GzQI4hu9EiZZJiPOIV+MjqOB0rx//AILC6ZHffArxVKIZnmGiXMLS2wII JBZW9tuTzX+a3C134xUf+v6/M/tLxYtHw2qRf8kPzR//0Px5g1P7fvkKK07N87qAPMIAGRjjtVZ9 Muop3mS0dZ70GaCWXlcjgfhkYx7V/szTVo28j/PjAvlw0F5o/qB/4ITm6tZ7CyvFgjmtlaaV4Isl suACQefUH6V/UJ8SNel8M+GNR1gxtMljbyXLLja8gXnGO1f5m+LiS8UcRppzn965VzPw/wAM47+z X5Hxz+zn+2L4V+Nl/wCIvC17ZWej61ouoSadeWw1LzJLcIMbnVgpIJyuVHUV/Kx/wWjCn4+aDeSF plutFeCzto18yGGJLuYlmJ6MS7Yr9V8Echr5L4gujUT5XBtPvp/wD8H8Wc6o5tw1g8VT3lKzXZo+ Sf2Bb2xP7RXgRo5bhxb6rb200HkZW3Z2ZlmJPGAVA9siv9DjwF51x4J04tDtK6dGnkynaSFUfN9C Ofxri+lOnHiHA325f1P0TwQs+C8Tp9t/kf/R91/4Lna7q1l8T9P0mzvLy1lGry+Q9ozxRwQs8A2s ehyxc45xsr8x/wBlzxrq1j8d/At3PrWoR3Euo21tDYNfSm3nywQtuZiRtOw7e5xz6/6O8G5dg5+E NOfs05Soy1sr/D3P42yLGYqr4o4ilKb5Y4myV9Lcz/4J/oSfs/XLt8LtMuIlR54rQRPKH83f8gJG D+Ir+Xn/AILs2rLqU1zFbw200WpRxz3EMISV5X8lzvfHOQGxz/C1fzF4Lz9n4lOHS8vzP2L6Q65c hw04LX20f+CfUH/BDPWtQuvhxZQajO7SWkaww25n3LIHdtr4z6AcCv3q+MPjCH4c+F7rxJOGe1sY HuJ1GFC7VJAyeOcYr5zxJwyqeJWIwlLRTqW+92/U/Scuxjw3h/h8dPVwoqX/AICr/ofyw/Gn9vc/ HT9pzwj4b0y6vtD0vRddW0ulDIqNtcAuGGHxleOON4PbNf1U/C7UNP1n4eaMYLr7aItIjjLzkqzn apPPbGT0r6TxO4Snwxg8so04bxTuutz5Pww4iWf5BjsRip3m5vfpu9F2SaXyP//S/Wz4zy6bF/wU N0WO3s4mkhv3ELkiQLJl8AkY4DDPOfvV/RXcwQ3HguAmNRJJpEZYooUJmHJIP+FfsfiQ6kf7IdR/ YX6HxPhsoS4Nxrh/z8kfwof8Fa/Evirw/wDH2y03T9d1S2gvLGPULgRTyW4ZBLLGWjwcA/uwpI/u Cvg/4JftRfEv4KePLTxdpPibXtTsre4We+0u912ZReqGBZQScEheV75A5r+3uEOGMpzrw/w9GvQi 51KdublV72snffTTQ/kOrm+OynirE14VXaFRu19Hrsf0+eDv+C/P7Omo+CLbTNV0nxBY6z9gisbs Xenia2ErR4ZC5c9Dnlwv86+dv2P/AIxeBvj9+2pq3jTwjZwWthfjzpYo4UilvJ0cxtM2Ou5CQSf1 61+A4zw3zXgnJc2xM3+5kpWttbp/TP2/hXizB8W8bZfCavUgktVbX8T+q6+sLLVfD0dv5aRwyaX5 IkC5aLMf3lI6Yr8Y/i9/wTc1D4k+LNU1+z8cXNhFeXLXFu0M728kYbja/XOFCjj+7+FfzzwdnSyW rUr1Ic17o/XeNMkedYuFKM+Xks/z9ex//9P+ib4A/sG638EPF9nrkfjy61OCIo8tu15LKk7HqWGB nHv6d+36reKYbO68F6hYaxbQ3Vk+jyxXAulVkkxEeeeuTX6DneZVMzzenj6CcWmtNtUzxo4WjR4f nl1V3SjJN9LNan8k2vfsp6d+03+134h0DS7HQrDSNI1KIPc2dkltHPuMZJcoNvO07iQWynucf0p/ Cf4Tp+zt8NLXQLhLSXS9K08STXNlB5pVE52jIHT16fhX6P4o8R4rF0svyCtJtRjF+Wuv5nw3hjkt LLeHK+aw3m2l3SWn6H4ift8/t++DPEfxL0T4a/DvVvEUHiDTNYtbR4I7f7LaGRXdcyOr9wUIAznI 9DX9A37Mt7LqHwk8M3d1dXFzcTaYhnuZTuJPlqXHPo2a+a474Wnw3wvlsay/eVPeZ9pwVm9POaOP xVF3jzWXyT/4B/Mj/wAHCOm6bv8ADDxzmOK31qO6uWEXzySSKyqWb/vnGegzX8ntjD5qBp2fzvvg SneIyew/Kv768AHfw2wa/rofwTxrL2fHOZx/6eP8z//U/B7TrWVJJI3ZpiMs8yr+6QE8L/n0NfcX 7CDxwftPfCe12QSltY84eYQrrtZWJY+mBx+Nf7P8fL/jEsfb/n3L8j+C/DfXi7AN/wA6P9HzwBA/ /CA+H3YgSLpEMmYmDJ8yAg5/z0r+Mf8A4L5wWI+L2lNNCksMVpNb27pkF5nuJGiGemCSCT/s1/n1 9G+78Uk/70vzP6F+kq+Xh/D3/wCfkfyP57bnTjDbpO43SbAdqk4Pr/KsWW5w0SSxAeadioi/N/wI f1r/AE3as7H8aTeliKW2kWRlSQAAAr3BHpVZY2LFNinJyxHWtoqysYXS3P/V/B63tEef7V58kKxx ER2iL+7d8cZ5rE1CGa4YAZUCUM7joMHJr/dg/wAvy3Hbsigo+5c43dzTrcDzSGZMqcqTwDQO7Ssa zBZUbegC7eoH4VmxxNO5iUsuMgFThj9KLCKlxEyllKlRC+0+YOT70vmxOgIADbdpB4Bq+S5pCSSs z//W/AG1uI4Z2jkiUmQbEx1+orZu2GyFYcq8EPlSZA+bkk5r/dtwsrn+YjmuhnxyPsmw6o+woc8E qeCBVCyRIZpHlJcOuxU6YPYj/PajkkS5u+hLJEUdp0U7wMk45AFSx6lc3DbHlZxGuDH2x64/Cnya CcvdsOkk3oBkqp4PYimMsSRGTOWHyjNSotkn/9f+fWNW3AH5gTuGRVxoJEzJIAsZTcm7kNj0/Kv9 2uWSP8vymJWf5FjKseQRwCOlOmEyMFWMFQuWPQgipGnZ3Et1Q53IVZjnH8RqR7KCeTKFlfHUdCR1 zT5X2LU7vUmRxBlHAyBge9WYmtPKJnRQWyN3Uj8KRaaex//Q/nyaGBXDr83zfTiqs1tE7HcgWIOJ QPRhyM/iK/3YP8xy6N0qJ5bFiW2svpUzWZVgsilQQGB7GglyUSF2lVgqxkxRvmTA+8PQUs8EkrfJ GIVI446dqCXPTQgh06faVeZgQeH6HjtkVKsuQyD5QpwWNaRimrsnml3P/9H+f2SCSSJBAjyHHJQZ xVSKJ1aIOcEngHqvuRX+7fK7ux/l82luaF3FFEkWwh3b5XfjORxnFKjFAsUgJSQ7VZVquW0WJST0 F8iOL5Y34U8hjk0LOuG3KHbOAD3rOz2KIJ5bjZtQZC5xGTjb9K5rxFbXE/h7VHcSKlvEplkVsbcu oH16/pXNil/s015M3wzarwt3R//S/iq8SQpbarewnzZLaK5kaG4mIMkqk7lPB6nNcm6s7sY48vjK bgQD9a/VON1bijHf9fZ/+lM+R4a/5EuH/wAEfyHvIWKwy4BUA7Q33Ca17WJCY0XJQjbMX5/Ba+Ra 95H0cVZtHu3wc+LHxK+CPiCHxR8KPEdx4U1i2u1vTf2bYuJJFBAIzx0JHPBBxX9Pf/BK7/gql+19 8ZP2iPBvgP4hfECHxNpV00NrcRSWcMD24DgJK3lquXLbeemM8ZwV8PN4U8Phq2Ngvft+qR9Lw7Sj jcyo4OtrG7/Vn9/8sTXHge7ud5kup9EeeOb7rK4izn65/nX8DH/BU/8A4Kyftbfsy/tLeNvAHw78 cMNJ0y+htlsJNEtrm3g3RRtKZGaMttBYc5zlj82MAd3CGHp18prSqLWKTX4o+b42r1KHEFCNN2Un JP70f//T/lj/AGgP2pviV+0r4nufF/xSv4L7xNONlpPaI5tYkHLbQThMk8gddo9TVr9lKJIv2i/g tMQJ7t/GNrEYtwVXBmhJyOuOK9rNa069GpUnvy2+5WOzhmnGhjaUIbc6f3u5/rofs2mY/BbwTI1u sEsnh+2mlQLsKM0Ywp+g7e9fmT/wVW8RfsyL8NNW1j4mS6Pp3jrQrNzoutWlwtpr1pIvCMrehkVQ QQd23HYV5vCWHq4pKhS6vX06mnHeJ+qY2ddbqSS9W0jg/wDgin8f/iF8Yvh7qukeK9cfxD4ds55L Pw7d3Cbrjy1IHLHnHykc85z04Ax/+C7f7HfwZ+I37PXij4k6j4c0qw8X+DtJl1TS/EEIFtdpLFtO Tj76nGCrdSF5yOdsiSlxFUwq+FScfwZPHFOOGyShXgve5IS+d7H+aT4gjgvZp1jCYW6dDcInkuSp PIUdMHiv0H/4Jl/tL/Fj4D/tJeBLbwV451mwg8S+IYLS/wBPiO6zMAkhQhl6EH8D79CMOJoxnSrQ nsrv7iOG5y+uYdrrZfJ6P8D/1P7b/g1rGpeJfhx4V8Q38iT3moaRa3xc/KrNLErEn8TX8Gf/AAcl aLHd/tZeF7O/vo2Wx8DS6mFEQKETXcoMbnoRmM4z2HvXRwtJzwU5y3cf1L4zpKnmlGMPhU7fg0fz M+FfEPhXwJ4/8Maz4ght77T9J8Q2t4bC5tft1s5jlDkSp/dwCOeMHmv9Ov8A4JZ/ET9lP4w/ADwx rPwOi8KQ6hHp1ub6z0uKPTtQsJmiAcTw8MGBGPmHVOOleXm9KpLE0aqfuptP52/yPcyqUY0qkV8T X4dT47/4LDa1+3X8HdLHxA+Bs0q+E/DlqL2/u7CzTUn25Zi8kTAgomFBOONxyCMEfzCfDr/guJ+2 x4E+IunXvj7xvLfaHpupI+r2l1o0Npaqm7BUrGq7VIz09Oo619TOFGWBpumteVp+p49JTp5i6tRe 7dfdc/su+E//AAU9/Yx/aH+B2i3PjH4gfD9tV8SeHYVvvD2pavbRXJnaENIgglIkDo24HKdulfwU f8Ff9O+Ath+1N4im/Z7udJl8O63p7avqkOnagL2wgvJZwGMQHAHyyHavHz8cYrjy7A1oYSeIm/dT 2+Z5me4iKzSnh6S0118rM//V/i8kiEabppHdVbaHAxhjzjH4VnSRrD+9Ysyu2Ah6H/PNelJWdjlh 8KNQySywRm3CqpGGHZMe1R6XbTzSArPD9nifLrnLs3Yj0FSUn71j3T4aQyXXjzwHacj/AIqa3n88 JuWAoSMk9vvGv9Zj/gnFbywfsr/DK1C7o7Dw5GjS7Nhm4A598Cvnc2X+20PVn3GRq2S4t/4f1PMv +CgXiP8AZqX4ca/H8ZoNEhutLsJ7yDUruVLC/tGVescp53DGR6Fa/N3/AIIoftI+NPif4l+JPg6x 1yfWvh3o2sy2mgi9lFwsEAkKp5bdcbDGcHpuI6YA9LH06lDBqtVfxNJeljxuGq9OdbE4a2lm/mr3 P//W/pL/AOCu/wCzL8Ifi5+yn8Rte8XeFLGfWvC3hi81PT9QtYVivVms4DLCwbGcZUBv9n3ANfC3 /BB39mj4RL8HJPEt74O0m61xdWm3avNaK+oRRZ3RBJT0zxnHoPTFVjqjnlVKElpex9JlELYnE1vt RWn3n13/AMFh/jR4q/Zd/Zv1bxp8P9ROmXVrcW9rDIWDOhkEnlqq9ONhzkEcD61/EzL/AMFsP233 mFifGVlc2nmSESS6fC13bIG68YweO5yc16ThTpZXCtZX1/A8qFSdTHOEnfVfof3N/wDBI740+P8A 9oD9nTQPFXxPu7PUdTvrRJmIgH74FQVLgfxFduR6lsADAr8wf+Dij9mr4QaV8K/D/wAaLHwppmn6 9D4ss7S7vLZBDI8brOZAVHUYXofQc8CvLyGrLEV5yf2lL8Ez1+IqMMHVjTp7JR/Hf8z6j/4Im/E/ 9kD4n/Arw/pXgKz8JWPjLS9Iig1LTbW0j0zVre9jAimLoMEs20HPPQehrf8A+CrmiftleFfBd74n /Z0ur1tL0uxlnnhsvLkvIyGLKygg52hehx97v1Xgyig6GKksT1b/AD/4bUM3l/s0a1PZpP8ADX+v kf/X/NKx/wCCwn7dfgbxm1h4z8W31xa6TerPqVpcaeIr8rDJ5brIvyngghlJB+XgjrX9i37J/wDw Vu/ZK+O/wa0i38bfEnwfaeIZvC0L63ouv6hBYS7jEFl81JWAUq2QfT+c46nP65BUVZHv0HRqZZU9 p/E6ea/qzP5CP+Cy2s/s6D9ou38Ufs0arplvrN3anUNR1fwPdw3ei2cwuGVQ0sDlFdlXcQpB6H0r jP2S/wDgqz+2ppPinwH8L774hvqeh/8ACQW9hDBJDFLdX0TusYUzhBKANx4JJ6gN0I68wlGi5VUv eiv0/wArHiZUq65MJVejlt8/62P9H79nPVtQ8SfCDwrq2rzLcXV5o8E0spAEwd0G7d29vwr+Yn/g u7+3F8f/ANlvxzo2i/C7xY2itr+lfabR4FE04RZWRxg5VRuXPAz1yelY5ClVo1KlTXRv9T0uJE6V aNKlok0vwsfyLftGft2ftIftPpp+n/GLxLa6rZac/mxxxwiAyMEKAtGgVNwyTuIyMn1r4du1EchK nMfTGMH863xFWVZRcuit+Z4sYKkpcvV3P//Q/jyhcvH5eTwfzqW2i8iXaU89XkzsJxg9KGrqwou6 LFxbXJkPKiMc7ejDHYVVv4RdxAK6x7o/LZC23zB0IP1rC2hXMz6O+Av7Q3xk+AfiK21f4N+KbrwV ftZfYJltH8yyu0JDACM8LyAScfyr+0D/AIIWftmftC/tIeKNWg+JPjG4106TCUSSZUdJsOqyqpAG AoxwfXPoB5+YTdCg3T3k0n+J9hw1GOKrOnWV4wjJryP6bf2n7++8OfBrxJrul3f2O60fSpLtpUf5 5NkDyNjHspPHSv8AOX/aO/4Ko/tnXnjzxfpXhj4r6lpnh6K/lga1KQzIYg37sFChJBUEHDA8EdDX 0+XxjDKnVXxJr8j5PHVZxzOdNPRp/mf/0f5gZfFviz4i/Eyz8ceNNSk1rWvEHi6GXUNw8uGVWc5R skkjjuTy1f6a/wDwSq+BXw58K/s2+ChpfhvSrSdtCjvLhLezUK8swDl2fGSTu/pXgZxJ1M0w67tv 8D7TIKXsslxVSOjjZL7z4K/4Lq/tRfFH9l3wBoCfDPWZtGkvtQmtgsON5KxxkFQQR1bgH04r+Tvw B/wVb/bbuPGWhSax8VNdutKutUgtWtZLhGSCOSRV/wBVggEZ68/XnNfb4iccJldOVOKu1q/wR8hg Kk6+PdOeyl+b1P8AQ+/YN8TeKvGn7PnhDxD401D/AISC9u9Giee4ktVjF0zIA5IAxz1IAxknAxX8 xn/Byr8IPhN4Z0HSfiBpngqxsvEl7rE9lNqMFusTgLGjlWwB/E49cjjsK8TJGsRRqznq7Nns8Xp4 fHUqdPa8V+B/Ftq7RmZFjdVu4ogJVRgVwRwMdu9YF+zRCGKIMsjqDI+Mkk9a5JfEzylazP/S/kHg tpVAG8yZO856Gr8dnLLIFP7tScNLkEgDtivNb9252xd2fol/wTl+Nfwp+AX7RXh7XfitYaffaFc3 qmSW80oai1tgRBHUsCikOg/Dd2zX+mX+z54z+FHxg+D2h6n8GbzQTbXejxXAuNHKQoZGi/dtIE7g AcHp+BryXTcMzp15ap6eny/PQ+my+HPllZQ+KO/p5/pr37H8vH/BWyP9v/4CeJtT+IOj+Ntd07wN PcSNBf6NIbpbJJHB2zZBIHPUdgD0BA/Nz9iP/gsR8cfht8ZfC1n8fvij4k1rwcdSih1C6nt0MenE uuHY7ASgHDHBxvJwcZHuNWkkeXBe5c/qH+M//BWH/gn78S/g3fWniT4lfD/XJbnSWkksrrUIprn7 hDh4cM+TzhSuScYz3/hG8R+IvAHiv9qSDxN8JrT+xvB2pfEtbjRQI2tn8uedsYibkAK23Bx92pqm lNXkkf/T/rw/YAtpLf8AZq+HMRtWhMXhm0G5mx5zCIfNj6V41/wUC/aC/Z6+Hnw/1vSPjQ+hgSWM kdquqW5MjSNlsRsFLZ7/AC9OvavOoK8UfT11ytrzPzU/4Is/FvxP8Qte8W2Gm6nqMvgS31SV9Gs5 ZC1rBA8uRtLc4Cqwx6sa/VP/AIKR/DX4c+Pv2c/iMnjXwzo2pyweF7v7JPfWSvLHN5LCJkPXcGZT kd1+tZr4zbltA/zgvhB+z746+M/xtv8A4deBZLSC9uNdc2xvN0AtDGxVCmOFVME7s5G3oa/qA+Ff /BKX9vzw38PfD9von7Q15o8KskzWkPiHUIdNgAUBFVRw6qOOV+nFb03dnPVi4n6PfsZ/sfftVfBn xrFqnxM+LFz4usZJgziO6kuyvzckM/IB/Dp78frp8b/CXhzxX8Jte0fxdo+na9ZDSnW4ttRs1vI5 WZCBjcCPvU8PriUjLMI2w3N5H//U/FD9t/w14W8HftEfETSPAljB4c06x8Q3otbGwkH2W2hd8x85 z8pLDGeABwK/b3/g3l+InxPHjiTw2vjLUX0uSdoH0WEhdPWNMZcJjA3KjqSByX5yQMeRnK5K2nke 3kUXUi35M/tp8Zw6NZaAmvaxp8Fwml2on8y4jVxCCNzYyPr+dfzTf8FHv+CnPhzTfFfhf4NfBjxD JBq8niW2TXzZJJbzqp+R4EcYwcuARzyCOMEjSEf3N2TOLVZH78fsgatN4k+BPgrU/EOpT61dahoU UjvLHvMm6NcqwxjnJOOgzX4Of8FAfhh4IX9vr4LroOg6PAdfkt4tTgW2UC7Vb3LeYOgIRiAeOnfF YS92Oh0xg5O1j+j3wh4N8P2PgbT49M0+C1JslZXhyGLbATz35z/nNfjN+13+w7+0n8c/iPPq3gH4 0XHhTSFHmW+n213Jbva45zkEbs5PcY56jAGzjeNziqKzt0P/1f2F+A3/AAT0/as+FPxH0nxb4t+P OoeL9O0+8SU2X9o3M7SoTtkQhjtPB6HjKg8EAj997XT7BvA91p3iSOK+h/sz/S0vIBLHIVjwGGeC TzivHPQP84r/AILM+Hvh/o/7VHjBPDOh6N4fhtdQzLbrbJbXOrkoFW5wOOuMcAkYr8WneCQt5MjQ MXIxIdsORnGPrTcbLUyhpInis75ZlkKxXNv5e7DOBtbsQP6e1UtQa6FyqzMHUEJGw6Jx90euMVEU kaiI86o8bl2iDbiFGWP0rstGsJbiC5lgud0bW4Se3YGNlV/lP5ZrFrWx0U27H//W+F/+CYf/AAUr 1T9hzx/BZ+L9c8Xal8PdRiitX0+OdrnSdPhRxukKYIV03uAq7dwJyeBj+xr4D/8ABXz9kf8AaX8Y 6H4a8JeJbPUdYubaFWtLnS51WJpfl2gSopyCeQM8BiCQCR8/LSNj26fxo6n/AIKPfsHeHP2tfg/q P/CNafoeleKbDT3u7PUltBAzpJGcOkgwVxu7dRn61/ntfHL4E/ED4DfFXxb8OPGVubKTSLv+y7G8 AEke6MsNwYZUhhhhycijCL3mdGJfuW8jz/4ffEX4rfCGXUh4I8d6vpNkDLPOthcmKKRsbmIHYnaB kEYFf3c/8EM/HPjb4kfBSw8R+LfEWuavNqLRRTRatcvM0YiHysueu4MxBPrjoABni9ZxXmGGX7qX ofef/BTrWNV8Kfs3+MPEfhbVZbDWbWwdLV4CySRFlkBbg59MHqMZFf51PxC/aT+OPjW71mHXvi14 6j8O6ld3FtBolt4kubezmiJeN1dQ3RsMCvTHtwOun/CRxOP75s//1/xR/Y+tpLn9oz4cW1vp6Xel W+sRszJlxA7sY3LkdypPX1r/AE+vgZofh5PhToEyaJYWyXlhExYQ5k/1alm39c89favk/wDmZW8j 63l/4Tvn+h/KR/wXm+Pnj74d/FDwt4N8E+LdX8M6VqlmysdLvXtp22kbmcq2SuGAA6c+wr8WP2LP jh8c7z4/eGdCT4r+LLvTr+9jWWyu9cll+1Hz0D+VGWPIUngcDOcEgEehmSXsF6Hn5dTbr28z/Rx+ ElvJqHwq0STVZHvbiXR0E8l0DIr4jBIIP1/Wv4iP+C9Oi+HfDP7Rtlqvhy1ttI1W6W2e5GmacttL LvRnkM0o6n91Dt9m+tZ4SKeDbXb9DXFR5cYl5/qf0Lf8EU9Z1nWP2d/C9jrkuoPJb2EN1ayyyNJH LAyb4l9PuyJx2xjjFfoj+098a/BPwB8J6j448Z2LJp1kHF1fR2okMOUZgWHUgkAZGevpk1w5SubD pLu/zO/NYctd+i/I/9D7x/Zw/b4g/ag/bfs38K65qcXhLSrxhHZvE+nwsFdolxGpPLo29S/P7rno Av8AUT4803RtV+G19bazBBdWs+mNMWvYUmjnBQkcHjnivn+VKtY+ht+7sj/Nt/bN+GI8bftheJfD PgLQrG3k1PxhqGkLLpdlstYhLdlE+VQdxVQSAvGPoSP3E/Zl/wCCH/ia9+H/AIa8X+Hfjn4p8F6j d2UclxHY2SxbJmiQug2yIwwRg5z0HoKajzVfmW48tO67H3h8Dv8Agl18U/hV8R7bxXf/ABy8T+KL XRrqK8lhmu5oZb4jOVdWkdWByQQe34EfvR4fsY4fBj6VriJqMM9hJBdQXS+dEdyFVyD7muen/vco f1udEof7NGR/n5f8FoPA/hvQv2rdW0jw5o9vp8d3eh5xb2y27TO77CqFcZAI3YP96v6wf+CRPgXT /D37OPg7TGsrJvsOkR3EtyUVpLjzVWWEu3ZtrnI+tRmK5cfTizTAU74Kcj//0f3l/wCC2Pj7XPhv +z7fXvg/Urrw7q0s00b3djI1vxJEcIjqQVLcYIwRgYNfkF/wQ98X+Nfi58RdcsvF3iPVvE0duY47 ldb1KW4QcnAQFuch/wDxwegrwMxg1hIL+t0fVYGF68l6/qf1x/GK203wz8LfF1zZW9tpg0rwzdPY vDF5Lgx27lce+QOetf5+mvfEHx98SP2ztP8ADviTxBq3iG3s/iCYYLCS8lmt4d1yvzIhJA2hugGA EwMAClODjgpyFFXxcYn993wE8NaJpfwx0KS20e1t59Q0uG4uXlh3zPI0YJZ89TzXwB+2v+w949/a L1K1vfBvxP1b4fx2cSCOHTHkgjkI3bmZldSCQyjjPCDI6EZZfBSw6kuyDMfdruPmz44+FX/BKT4z /DrxpZ+Ltb+OGr+JYtNaO5Y3d3MJ5QGzsWRpGY498D0weR+/HgLShY+Bv7K1W4ivgNPMVy91idZC y4+cNww6gj3NbWtUscMl+6uf/9LyL/gux4Q8C+Gv2k7e38F6fpOnGaGaXUn02NBEQELvG23hcs6E Dgcg96/npuEiguJ5YnQgvuPmEKABjO39a8OpGzO3m0RFNK1xbzQQXBh82LhUON31/Hms2wmu9OvG MNxscwGJnT+HcMN19qwcd2ZFL7SdJWdrVItRilOy4hX/AFUoz86fWlCW91dPfWwiSSGJdlsG2rHH nJRfp/Suap0H0sQ3WpJfX+Laxuoo4B5hkyREP4SnvRdyyC1R4IA8zOEEbH95yQOKzLg+h//T/lvs Gi06O7g86YXLvvkjYZ2g9RnsAVziqrTyQzwzwynZkxOEGSc9/px+tfHpJbHoGwrrIpMgdQFB81hg Mag8+RHkh2fKqblkPvQBzN3Zma6+1C7uLcqpAjg2qrnI5JxntVyPUY1uFWUAh49pLD5mYDsBQBbh NrZeZcXaKrSjcy5+cL2IrLTUUmLm3iPl+b5cJ5kLZ/iIHQfX0oA//9T+W+Kz1S4twgtojcSS7Ylg YyBxkAc47+gqnfWN1YywrdlRJGSBDFJyHHByP8a+Ias7HoFbylYxSS7cTMQyhsEY9R7/ANK0CbOR QjRlGRvvKc8UrC5UUmMYd1CoJBypIG9qdNYfb08gOgmkUiKJn27yPSk4p6MEktEZVjpl5bXoh1CL 7OkH7qMCQEEAcZAPHpW7ZRNDfXWT5kE0GEkVuUIz2/GsuVpNsZ//1f5arJ3e4EG1Z495U84Knt/L FdBLbG4cQMqKAMSEsBgAev8ASvz89AzEFnBJ9n2yGdBvt5BGSpwe56A1U1W5k8tLi5uEZ5roQNHI 2biUkZBx1xx1oNofChiJG+0SEjLAGM/wjp0oa0ghnliWPzIwgdcfKoDZHT1o2KJPLQx7BGSd2BHj K49atz2ltDAixiLaMzyN05PXPv8A41nMcdGf/9b+Via5iMkBaV08tzHDEG+TJOQw/X866m1huZLS dxI0syKCN4AULwMZH5d+tfncIpq7PoY6MwruwsL6G/gurl7GA2zK8sWML2bJPAGM81h2umyxoLnT LvNuD9nFucmYqnG4A9QegPtWhpPY6EWDNbWk8lxMTPdG3aOOAyrAmOW3DoQTyK0nht1iu1hme7XT 0UC4aIwJJ279+nrRYVMqWyRypND57kSqWUTfOkROTwPr29hWQv2aO4e3+2hpGwzWxPyErnkD1wTx QaH/1/5bf7SBjRIwsvlDYY8YViPU1lC2S/uWneEERneqI20EnrhRxxxX5+9j6Pkdjfs2tXivUEcZ VYws8JUbwuQCSvuf61XSGAOxit0giGD+56OB6iud3SMpXurFa4iEKyXZKRwlcHnBOO2K0rCXyUia KRHkk5QDoO/WuuGujNae5LqGqpdMtvKwVlXAdT8it7+vSoIJrpMxJseMR7JW27t+e3NQan//0P5a jpdtEHlgzCmA3lpwoI7BfSurtdk8aXbQLaHbtUxM3lELwCM9CcfrXw59QENo63D3MJe4LxkCIgMq DByVGOvU5qjPKLiVZpcpb22NwZvkc5yMjpxikluNLRsrX7rqUsCzSKbSY+XHaoArzPkEEHPTGKe1 811pzW0dtc2t3Hc7UnY+WSEPRCMjB65plRjeI+a5vLhIrCeWSJ7hgftDIzRIAedzdARnivTvCk+j Rz2Nsl2ZZDKsLSXPyiRw20gHvgg16uSrmzOhH+/H8zhzl8uVV5doy/Jn/9H84/AltYW2lWtvdKk9 vbQvcrLcKZGVVBcY9OeQB6+1f2E/8Eobaa3+Eugajf2ULXeuaYg+0lfLlhWFFEhC+4UfXbX79411 XT4SwNHu1+CPzLwbjz5vi6va/wCZb/4KzXcjfAXxK8N3HZ7NLku4DDD5lxJHCHMqBeo3qCM1/G34 lsILiKzcCfTbaSMxWy22JXj2oBg47AEZ571+gfR9jy8KSl/eZ8x4tTf+tEYr+VH4yfHXXtVtfGce o2l48s1hI5+0TMBJcw4Cxr3xjb+GMV8deILm7vrxtSv76Se9klMjg4cBSSQN341+EeK8+fjfFvzX 5H63wZHl4dw68h2k3sLCQlTNICMRjg9e1d1M5jtoJhbKssylcuuQq9MAetfmVbSNj6Jb6n//0v4v NIENtavcXCGcIzMqk5IY8fN7ela1ldR6hcafp1pGsd1cSMElaTES9PvN/n9K8Stvc9A6DTtLX7S8 NxMkMvmiONQw8tycjOa+jfB3hvVtNsJda2W2ovZRk2cM4a1ihxz5rtyDkEAAflzXmTeoHVad4gvp EurhbhbdncsI14CsMgsmfTnB9KyrmK7WyuLXTfMl1G8ZpWv5yDHaFs5fHcdOPXH1rhqaI6DUmW40 pLZYb1nae3QzvEhj+bGWU1HYNC87zXV3PKsjiNYCAIkxnJ6dfrXPe6Y1uf/T/j0tNVvNKgvLSEQ6 nDcIIReRQ5kTcfvJnkYyMmsG102zGorqKzkXkM6yXEIcBbgHg7x9B3ryIO8rCbsdHq3iPTdRTVNM tNLsr87hC17cuy3Fq4xuEaqwVsepBrn5INPtptLEYk1GK4TZqVkFMENsVDHbu7rwMe5rne7GnZ6H o/hG11GLQSmn2unxwarLIYJ3l+z3cDZ27Sc54AGQfwrudRntvD9lpdtcS2dxqN+RDhLsNKm0fMdu e/v+lXBbl81lYyr7Sri7tw4nFytx8gtwMGPHTafyrlJoFgP2dYmW4JC4cbWz0wa1pxtJsOa8bH// 1P45vFsF5bRPPb28TTyAQRxB9i4PBbP5mvINetJ3lDA/adqBXjV+IiOo9qWGVoik71DsvBtlDqcu j2xlmtotOvEv4onbylmkX+Fx/EMgYHsK/Vz4aQ6nN4H0HWtWu/Jlu1Ito4ZgFgjjIAVV/hH+PvX9 JfR5qtZ3iqPeN/uaX6n4h4x4ZPLKdftK336/of0tf8EStVz4pvA99I+pNPNeG1GOEiQAeaAfuYA4 PfFf1ofE62s9c+GviNLi3kmttX8POI4oox5wEsDAYH1NfD+NycPEG77x/Q/YeCWq3hZRXaEl+Z/n 1/to6TfeE/i3f6O9/d6qp+1ql1cOqtEDJGBC6dQwXH1zXxw9xPpTQfaLCRp3Ui1RkPlOoAwP5V/b 3BFT2nC2Cqd4I/hrOoKOY1Y9pP8AM//V/GK4a5OnXDXtxCkbzJJDaW0f7yFsnnd14744rKOpXs1v LaRJHGryBpLgDM7qB0B/z0r/AFpbvY/z2Wl0CW/l3Ed2Zb1lhh2hFc+Qpzksw6Z/wrorK+iNuwEc txcXTZiu2lVY4xnJ3JjJJ7HP4Ujqp6NM/o2/4Ig6doOpyara3Gjrdz2cSTi6aCK8uJ8XLGUEuPXP HpxX9BH7Vvwo+H/ir4T+I7G90XRp1GlzCBrnQ7aQ2rJHkSB9uVI28YOc1/CHi3nWOy7xLUqFRrlk no+z/wAvwP7X4YymhifDalCcVadL847/AH6n8Xvw3mb4c/tT3vhd5LG28OaD4zltWLpHaXt9bm6D QbVALZGxs7eNrYx6/wBz/wADL5JPhno+22u4FkgF3GjcF1Majb+nXvmr8csS8ZTy7FTesqcZP1au ej4W0J4fhatS3Sm19x//1vpn/gsX4aax+IaXulRWU16PEVvfzSX7R26QQvbmIqzE9N8ceQPrX3t/ wRY1XUJ/hJZm5v4AbDVrhDaQn9ysMzsm8DqfnU4Ppiv6LzSr7XwcoSn0dl8kj4zw5pOlxnmUYvfm b++R+hP7fOntd/BHVLWaaQ29u8d7cIqg+cgZvkDdjkAf8Dr+CPxEJLTX/Emn3K+cml65d6dIVwpu GEjbiX9fnFfR/RzknhsbH0/JHwnjErcT4b/B+rP6kv8AgiLfPbeFX099QjuksXGjSW8EeBalBGqg SY+bC9/Umv2G/a704Xfwe8SWnlvcw+QZSowXLKy7AAc9cY/GvyLxAcY+Jk5f9PIv8T9vxUXU4Box X/Pi34M/z7fiHN9h+KXxDg/sZLC2i8V3Fut0JDtklh2xSFge5Zd3H97HvUXgTVLyHxxoN1bSxw/Y vE1hJPNG37yULcxghW6eg9MZr+8sHaeTU2+tNf8ApJ/G+V1HSzCiuqnH8Gj/1/6z/wBjS4+1fB3w xJb3Jlg1HSI723iHC2JGA8XrgMxxmvyu/wCC2Xh7VNR+GtssUFnd2bOLuS31Kby4Yvstx5hckYOe JSB0yRniv07hacKXivTlPb27/Nni+LnvcIVpx/lj+h/J3Hq+i3mkzrsSMvGGs7iH+B1OCCCM44Pv X3x/wTVm08/tF+FrW6E1wmpqkbyyuYmt3h3YKjtuMiH3wK/t/jaDq8K4uMd1B/gj+cvDKqqfF2Gl 5o/ur0m2urzwjp3lyCGNtOjSN1yAVJ6nvz3r+Mf/AIKvWOpWn7R1vqN3p7GW5i1CKRIiWMOLhVY4 xxli2Cf7xr+KPCCEHxlJS35Zn7x4oynT+ryW3PH9f+Cf0Tf8Ev8AXU1f4LWGoxx3ENzcwpaXlnKg KoYkBLAjj5twP4Cuc/4Ky2OoXP7P2si1ie9jn820Nnt3bvNiAJPH3V5J9ga4uSNPxNjGT0VXf9T6 bxEc6nBdSUFq6advkj//0PyusVGneLhb61YzXGl6XMYhbFPLgkITcqlupUEjv0qnql/bpfzXMVnG IGuGZLGDKpGGbhEPJ4zxn0r/AFmwutKMvI/gv7MlbW5TljuZI/OlCxYkwkZGBjHoe9UfOjRTbKjp cSvh7sNkIp6gL/Wt18bNnpRseufBXTLTw/8AFPwDqU4kuYZ/EEOmAmUxAyXM0aozLn5sYY8+tf6C f7KMOiR/B7w5bW0SvGluobyi0R+6TkpnB4IH4V/Kn0m41PqWDcdr/wCZ/S/gP7H+y8XzL31L8HGP +TPxw/4LUnU9M8LaeukzXumXVssWrwMp3W08KziKQN1HAm3c+g9K4v8A4Iv+KNZvraMarq8909tq Ewijmk8+WNZAEwrf3d6E7elfnGEwNCXhPUxbSdRSevU+z4bxFSr4gYvDSfuKN0vPQ//R/sp/aDtY rn4WeLhn5jok7SM64yQBszjtkmv8/X9pDSpbH9oL4pWrXlsLIeIf7YsYUYrIvn28Hm7E/uAgDHYs Oua/qf6NErY3GJ9Y/qj8J8eItY3CpdL/ANfmfOGt3RvtSFlHK0isw2yspQuegzmq+pwtpjWWmWL+ c89m0+oSg744STgImOmAQc1/Yjtyqx/PsFaDuaNtZyQQxyXL5vZrVRBMoHzcYVnHPpjn0qKKG+hT fdos108pAiOMRgEBT/XHaiy5Lmsm1FM6LQYJYphcXSHEZLNBC3yy+xOK/of/AOCI2p2x13UopJhY sviF7qOyUl2hdwqxg5wB3PbjFfkHjVDn4HxNlex+3+Cs7cU049eWR//S/tc+Klsr/D/W/tCfaY4t KuzconJYNbyDkDtnB/Cv4ePifrOu6P8Atm3L2dyNPtzrkV1YxRTPGkSNFCCgbu25mbnt9K/dPBCh CvWzGnUV17J/kz4PxOxE8Pn+VSg9fa/qj+0f9leSbU/g14TW53XLLZ/JctP5ssi99+e4IwB6V+bn /BQmwsLH4o+BNdFlC0lpNCs4OVRzFMZCC3uu3B+tfm+XTlR4oqRhouaS/Fn6Dn0IThSb35o/ofrT 8IHgvfhjoDiQvFcacoVwAcMY1HJ/Kv5sf+Czct/ot8H065vvOm1S3Fqmn/8AHwGlj3bRk4OcH6cV 7/hjTjX48pUqiuuZ6fM8DxOk6WTScNNf8z+fKbxL4pv47iXPii7itp1uPsagT3qOfl/1Y+YjJycZ AzW/4b8FeO9aina30DxtqU9hCNYmvf7GuGtJFm5CMjLt2rnpjHynk81/a+IoZTg4c1SMYr0sj+YE sfjMQ4wba+bP/9P4g1Lwn4mV9t/aeJZL+4ZBLE8TDBGQkYj7KB0xgc1NZ/Dn4iwvpuo+HPB3jGG4 t75btdRi0a6WO32NlpdyKdxXGQPav9JsRi8spYaKnOKptd9z+R8swOKqV5zowblB7pPSx+z/AOzP /wAFg/GHwB8HWHgrx14Z8O+Jbe0uWtV1DUIr1NQdUAXNxCFLK3AU5PBQ8AV+7X7In7bHgf8Aa70q e4sNO0LSr75YptMtL7zRliQRtZiR0HHuK/ljxD8P3lvt89y67pN81uiv/l3P6B4U4yedYqGWYuyq JWfdtL+tD4//AOChf/BOTw58Sop/iN4POoaXqmmxyz6rp+ixpc296rN5iNJA+cgMMZHQOTgkCv5+ f2YbHXvB37Qnh/wX4n00JN4f8TztBqd/af2dfyKC0WJIwMNuXBGOh+lfScCcU1M14FxeU4mXv0YO 3dqz89T4PGcNPKfFKljKS/dVZJ+jbd1tbf8AC19z+5T4S28o8B6XF9vW6VNPzFuUGPJjHGRX8sH/ AAWi0v7H4v0dLo3Fqj+IrRBNbRGSa5lLbokHXgsYwfYV+d+D93x9H1kfW+PytkVNdqkf6/E//9T4 t+CtzrTfEjwlqct81hYDW4JPs6ptv5XaUpHkdcc4I96/0Df2Z52b4XeGleO02R6XatbiJt5ZfKCn cfUleRX9H+Oy5c2oyfb9T4/wulz8PTj2/wAj8zv+Cil68HxY+HYtokQyzxzXbomyRRDOGQfQBx+Q r9XvhJfr/wAK10eUs8y/2YI1bGSXEYB/p+VfkuZ3+oYab2sfV5Q06mMit7n8vX/Baaxkm8S6Exsb qaZ9ZS5S3s0bzJjKAoDsPX5ffivsn/givrEepeBQltYfYbGG5EFq3mNNIY8DO8nuCWr9R4jg14a5 fL+9+jPzDgSd+OM3j/e/JtH67/tV2sOpfDTxFHIrvBa6PJIo8zYEZM4Yf99fyr+Av40afbwfGPxx BFsW+vfEl1c6hY7d0dtulby2BHTI/hPrX0/gZPkwuMvtofN+L0f+FfCyXZ/mj//V/SD/AIIq39wN S8QRwNCqWc1vbjTQwdInAG4q3oSBgHpnFf0o/FnjwD4jfYqyRaNcylv4EzEy8+vJ6V+n+IKa44rr +/8AqefkLX+pWHn2p/kj/Pp/bBT7B+0f45capfXD3N/JKNKWAiCXMVvlwenRlH/ATXzoNQvNC3R6 Hf3+npJKst1BBfTW8HPU7Fbriv7syTC0cVk9DD1o3jyLR/M/h2GJnQzGpOLs+eW3qfU/7Kviq5m+ OXhO3vIVuYLi9tryyupJ2llspIJVL4QnoVJJPqo61/ft8J57aX4baI8MjMraaiGRBkFigOQfcEV/ K30gcOsHnFCnBWi0v6/U/r7we5KnBdStGV5Nu/3v9D+a3/guVpUR03R9OsIoo5pdSg1QXfCM7+U4 XcTwM55Hfiv5rLQ3OoW11NHFFPaaaDBeiL5nR1UHCoOpxnp7V+6+E8nDgrCN9E/zZ/NnHcVU4jxk V1kf/9b4L0TwJrxMWqw+G/E115dgLnbbeH7m5jto5FDBpP3eAcHqTxzXsP7OKa7on7QfgmOfRZ9M s5rtZnutQtns5Z1UhiV3AEhSAMDPJr/RviXF4fGZViadKV5RjL70j+OMioVsNmWC542i5w+6/wDk f31fAub7V8LNByUCCw2oY33Lhlxn/Cv58P8AgtvqGu+GPDcE2l6te2cUmo2d01vZylHvI5CYypPb BZfXGBX8keFdCjjPEOlSxCvBOba9Iyt+Nj+i/FitPDcJVZUnq+Rf+TRv+Fz+a99Z1+byTBqniCyW RB9ohS/+23HPJVHYMVGf7tdXDp/xZ1Gyk1DQdT8X69pk9sFTSVivbzUBIn3TH5aBT0P3vTvX9qV6 eT0IqWOUUttbJfifydTpZjiU1g227X01Z5j4l1TxXDq9gupP4njvLiJbO+0zxDFLbpbyW4JWNEYD pjIwTzn0JPJsvnatdwkNaXm37TIsEJKMCedxPGTz78V9blUKUMO40fhvp6WR8xJT+sylUep//9f8 q0Sa3lMw3YPBLfcYerCpZZPMmtYtJ0+108CTOo3CE7r5WILlz9RwOnNf7B04pI/zilJ3sS3CzStJ aQ5EiRhx/ApB96pta/2fc2Ly3MpP3pShKwrk9Pf/AOvTmrQZ1YZ2sfvr/wAEWdRum+J97FLLPILa 88yPd8zrGclB7qcr196/rx8b3MqeCdSJiD/atJkEiumSQ0R7V/nT4003DxFrp/zI/vLgepz+HmFf /TtfkfwM/t/w3tr+0b4tvLoWtjBNZ+c1vHCRPcxr5cYcED+9u79Fr4P/ALQgvbhWSLZHEMDecvgd a/uThRQfDmFcf+fUP/SUfwhiZ1nms+ffnf5n/9D4s+AV5c2vxf8AA2oafbTSD+0ltxu+WEKJYzKx 9gufzFf6DH7N84Hwe8IR7FeRtGilEgXBXzIwwU9jgEcV/Vn0j17PMsD5xf5o/IvA5ueQ4yXaf6H4 Sf8ABdGwj1P4fvafYWupIbnTvKkL7Gjd3kVhGMZ5USD8fxr+XHwpnT/FOiC/Zre50TUraQTRKy2E GZEHzD/dPA96/TfCtqPhnOHXlnb/AMmPzLiGcl4kTn9nmh/7af6AX/BP/UIrz4K+HYFdZfK01DFI jgqoOGA2/wDAifxr5S/4KmW88Vp4e1CR93kKsceBlUP2hCS31AIr+U+HJKPEsr95fqf0TxkpSyWm 1teH5o+/P2TZFufgz4YEBinWOxifz0l3+Zvj3D9MfnX4Z/8ABfPS45PhdZyy+e+pXWqaebeK2XAi XzHYlm6D5olUZ/vV7/hlNLxEw8n/ADv/ANJZ874uwcuAsRBdYR/NH//R/ODwlNdwX2mXU9xHpl3b 6hbXTW9y5BuDBcRu0aY/iwCfopGa/wBAP/gn/Mtz8CfCwZAkkmkRXTGFi1uGfBKq3cjjNf1v9JF3 zHCPoov82fkPgClHhutT6/8A2qPhv/gs1YRS/Cu7ug25otIki2NGCw8txKTGx6MGRD+NfxUXMFws cSTvEZPL/wBIM5EglJ5+Y+tfsHgTafAVH/FJf+TM/C/EqXs+PsZH0/JH1j+xRqQ0n4//AA5thfy2 FvLrP2q4S1TMUrDYi89twOCPYfWv9Cz4buJvBGjuiswttJSGJ26SbU3cfiT+Vfz19JBc3FdFvbli f034QT/4wOSX80vzZ/Iv/wAFzPCjz+PdP103cVt5fidrWIk7LgxuiGRxx1JQYPsfTn8A7qOV4VX7 LJJdSuYrdX+8eu1mP4frX9eeFMnPgbLI/wDTqP4JH8acUS9nxLmEe9Wf/pTP/9L8j7S3uoZG+32w idWwGDZ2EelV9W1CSNZszlmY5wANzn3r/aaHwo/zecktyu/lW1rFOFxLIgLtwGGR0rD0qG8LnN/c fZ0umuRFI5K89QB0q0rjTuh99C39qSyxziY3aBm8wgSIRwwHtxn8at6Rdx6Vq+l3EgbfbajC0QGS mTKoIPbn34zWeIp3oyjLZpm2EnKGKjKO6aP7+v8AglBdPf8AwE8L3XnCeH+yltwZB80ToEzx9Q35 0z/grHpkWofAPxTIrsnlaLdmQIhdnQwfvOB9M/hX+ZuRt4Xxjg5dMQv/AEo/uPxHh9b8Npdb0ov7 rM//0/ySfwv/AGNIVicqpkKoSCC4LHBAP5fhUc4vrfULdS0kkUKidZAuYk2kfKx7den1r/ZOlVUk 7dIn+elC8YUYdeZH9IH/AAQx1W5vfGF8ZohZvpyRyKifO94JXf7ynoOn5V/Vd8Yltv8AhXPib7XG p8zRpl81hkICnLY9q/zR8XE/+InYr/Gf3tktS/AeGT29mv8A0k/z/wD9pj41/Ef4M/tVfEi++FXi 6+8Iy2PiWS4hutOuSIblHjRyTETtkB81iAwIyc+9fH3xO+KPxE+OniFPFfxA8S6h4n1m10xdKtDc yCOOFBI0jMqDCgszknA71/f3BvDuX0srwWbqmvbunH3uuuh/AWYZ5isVifqUpN041JWXQ9v/AGJB daR+0n4H02aZ3j1CUyRpG4iiikjGf3hPXOFA98etf6LHwomnuPh1oVxdSE3g0hI58ncAwjAXOPwr +UfpWpLP8Av7v6n9leBt1wZin05/0P/U+iv+C7dsJfibp1+9zcRRWd60MgSAm3kbzYSUBHO4CTH4 mvxs/ZznkHxk+HkrowsZNdQW900atO0gkQxgDqBkcn61/pXwKreD1F/9OZfkfxdkE0/FTGRS1WKf /pUj/RU/ZrV4vhZ4fhTmQWvm3LlcB3ZE5Htmv5v/APgvhcRxeGbGMxPHd3HieA37hSUcxhWVmboO HwB/s1/J3g8v+Nm/9vS/M/cvpAf8k9S0/wCXsT07/ghRfWV3oMtzbqvl20rwpEIyAhDgRhfbgdfW v3V/a2gNz8GfE0UkXmyywCIws+yNmwQucf7x4rz+PlbxZl/1+j/6Uj7KV4+FkeX/AKBn9/Iz/Ot+ NOp6xo/xp8eappU8tjfWniify9VsLnyZNLaKUeWyqepbHI6fKc19deAP+CuX7Yvwu8Pp4T0v4map rmnx2ZjhvtRtbTz4mwcA7lYkZ9+On0/0BxnBGU8W5NhqeYR1jGLTsuy0ff8AR/O/8G5Rxhm2SRnD CSdpXurta3av69/x6H//1dP9gb9of4iftB/tJaRr/wAS9bm1fWmvJze6hexp9t8yUiQbWAG4YAwB wA2MV/cJFcGbwnarGhjWXSIYwGGTCGiAyPoK/pT6Q2WYfKOKcLl2G0hBJL7kz828GakqvhpOtP4p Tk2fwof8Fjre9tP2pVtJmYWI8KCC1lQ7omH2mZm6jIyzYr8fZdPkm2olpLO6yBhImcLj3r+0vDOp 7PgfL305EfyLmlOVfiHHR6+0l+bsRvbSXSvbSQq0Ukm1YgwcTlAM/KOpXOPav2k/4Ima2kfx/n0r ZDMzKYdOd4909qI9qNHn+5ulXGfQ15viyo1+AMxUVryX/FH1PhNVlhfEnBqezk1r6M/uM8QyXdn4 Nuri0kCNb6UzwtCNvCRE4Hp0r+QX9sP/AIK6/tFfAz4x+I/BPh28l1KzsrxVtLeJFDQJ5UbEZx1U sQevTPfA/ijwN4UwXFubYnA47aKuvx8/I/Z/H3i/MeFMblqy/wD5fSkn/wBupNfmz//WSf8A4Lkf tfpdW8UWt6LFbzMpW1Norn2812UY9ODVy+/4LeftkXukalYXGoeGz9oU20UcFrFctGMYaTBJ3Ajs cfjX+jy8D+HozhUaTtt0P4jpeJ2fV6dXDtySej1fp8z7l/4JOfErxD8RvjFL4t8Um2+167NDdajN DCtq7SBiCxjHHOTyRk81/UL8W45ZfAmvW0WSk2lSM0qr86Kq7jtHqRX8reMeFjgePYYWHwwsvu0P 6p4FjzeHFHvJSf33P8/T4u399D+3tq1mxuYY7X4iPEkb8s6pK2yQr2JUqce9f3h/so3Ul38E/DXm SLJ9nto0LrGIyVaFCS3vnNfafSAjy5LknnTi/wAD53wRrSq5JmEZdKsj+b7/AIOFrOQeFdMnjlMS XPie2/cCIOW2o6k7uqg7A2Dx8tfyeyw2Nysb2MrkplrlCMHGe2f8/Wv6w+j3K/hxgkfx54g/uuPM 0/6+M//X/DrMcNtHDEUXz2DdMSNj1+lfYf7D8LW37SXwturi2hMC60sUl27fvE3vGqKFHOB85PXP Ar/aPjhL/VTMFL/n3L8mfwP4ccy4oy+Uf50f6PXwo2p8PPDUcJWUNpCoSSdhHOBz0wDX8aP/AAcA 6TND8UbCK0e6Zbd/MjhZAyMqzqWdsfwqQcH/AGq/zz+jjLl8VeX+9L8z+h/pLpz4cw0v+nkfyP59 Lm+Zlit/JGY0HzLzk471zM88ouZFkt9gxkTH7vOeBX+oFk9T+M57kwEKwIiAKwbcWB6e2KiQRRu0 q5LFdvOSBTOVu7P/0PwRikuRIzQyyI2SVZRlU7VZBMa7HcOjD5sjnNf7uKHc/wAu3PsJcyrGsflb CMbSOnQ8mqYQtmZQcHjI4xTcF0FzuxYR5GVY0ZmRByKu2kZWVJX3RhTz+FEY8ruNT6Mbdqt8ZX2x tEhHmqzANjscfhWPJbLK4MUkYh7EHI/CrNE09j//0fwPBtWCpDbkvGu1rhsEMc9v89qvWElr+9S4 CLuHLP8AdOPf8K/3gP8AL8pXUVsH/dIQzKSjgnBHpj8KyzvjkTdIkKn7zMueB6elAFpjmNvn3nG0 Nj71UoVlhbPyE45xQGxYOTlpGBQjhcd6IbV5dy+YsaMNwMhPPtQS5I//0vwElRof3Uke4Ff3cgGc 89QfwqH946BWBIXlK/3gP8vFNN2ZNEM8yR4yMMQOlTSFUH7vcyk4+YfMPrSUUtgjO+5lzRSwk3qo 7QxnazAZC59auxTxIVkX5CV53DIYmmWMktwdz+YrkHOQciq/l7wwVCFDZfaOvuazdPsB/9P+fR4k 68ps5GeM023wzPG2HjdcBs9D3r/dzk18j/MDmdrFu3SO2wATgHK/5/Cpp7oynzJuMDagxgAVLi09 BFKKZpGISQYBzgit7UsyW0EyRmLbCFfCbfMI/ix/hVcmgGRay5gKM+6UN0xyKSO0tpyYJJWgYHzF VF5kbI4/HmtEraIiTstD/9T8BVaWwfFvN5keM7cZz7EGq0cqSS+a6tuEmFBBGSPSv94D/LhtvcmZ cyNJIowOdpHFTW11JNG9ojINzZQsBkH29KTWlgTs7lB4pomkExO/PKt1NORWfjZggZBB61nFWlZg 5Nl622FlW4BAPG8dvrWB4slE2l30JVVjhtXkkVDgyBRkEjuea5sSv9nn6M6sNK+JgvNH/9X+KXxW 1q+sXS2TtHvmLyRTEu0eRwMnp0rLEcKKm+Zy4IAwOCfQ+1fq3HC/4ynHr/p7P/0pnyPDS/4RcP8A 4I/kZs8f7x5VXLMfyx/+qrVpcSMyRKQu3lg3T3r5JpH0aXvM7DTtRWGFXdJJArEN5WSzZOOnt/Sv 2T/4IfyvP+27o0NkC7Tmz2Q3MZXGJo5GK591GCPevCz5L+zKy8v1Po+FJf8AC9Q16v8A9JZ/qeWz FPh9LK8REVvobSSKRtO0QfNx+f5V/l1/8FoF1DVf23vjGke+4t5NcmmiSVtkyx/Z7NAoz0TdvI/3 hXscFuEclxc5dIK34ny3H8Jz4jwsY7c7v8mj/9b+Oq80t9PEafu2wAxSNg5Q++K+hv2TrW/u/wBo /wCDd2wLSw+LLa3BRNgKedEdh/3gMV6eMfNgqj8n+TPS4djy4+lG32kf67f7OHkn4O+Dov38n/FO 2omabhw3kruz9CDxX8Sf/Byr4nubb47+FtF068uV0y28Kvc3doshSKaQ3ZcSY7ngEj/YHpT4JahC pL+5Iy46s8wS/wCni/U/WD/g20mu7z4GXl5fvFH9oyunw+Z5kjZuG3SN3GSpAr9Bv+C2c6W/7FHx XdzEJLfwvMHzzIQZYsED0+Y/jiuDhOfPxJUk/wCeX5M28R1y5FRt/wA+4f8ApSP8rfxQZY9Tkjtr MLFPKZVcHDR5Hce56n3r6M/YqijP7SnwkumYm+sPFMMskW/anliZDz2O7GMVrxPFx9uvKRz8Lrmr YV93E//X/ta/Z8iW2+D3hK1RHjSHRLaL942WP7lT/U1/Bx/wcnX19cftYaUtv5VvB/wrdbGKUsOS Ly5lO4/8C2+2K34RV8DJf3Dfja8czh5VD+VzVdMu5ZpJjhWmcxm5KhuvXNfp7/wTM/4KFePP2CPi 5pet6dFHrngbVtVtrLWdNluXt5Yos4dEOfKXqGBZSPkUEgcjTE0FXpTpvfod2V1OSam/R/cf6U3w e+M3ws/bs/Z50zXYJ9HuNI8U6I8eq6dFq0N20ZeNonAwcHncCOo4yAeK/Hj48/8ABvV+zr4/0HxR 4j8K3d9Ya/qME00VtbRrNb2sgy4CR4wy5AOARjPHYVjhcROmlCpszo9jFVpprSzP4af2sf2ZfiL+ zL8T/FHgbxFD4k0DTrLUpbXRtRKXFjHfxxzNGJnbgAMoXj+Ekg818VapC1qk4G+S5RCguGkaWSU+ pZjmvcraS5I/D0+4+XxHK4Oa3v8Aqf/Q/ivadt0fmqxSP5njByXNSIN8q/aAVRz8idk9K9SaOaC0 SNUG2S3lSPIdDtKcjg96q6bEltIXAEcW/gLwD+FRawJfvD2X4USsfip8N1S5EUEvi21imimYi3kD tjLfT+tf65X/AAT3e5i/Zk+G1jcRpGtv4dtpDIqgbt8UeBkdcetfPZm74yil5n3OT+7keK9Yn8x/ /BzX4tl0DTvD1vY3lxZ3eqa1co5hd0hu4IViJXA4BDOvX1+tX/8Ag2BM+p+HfHmuTxSGa01cwksC Xbz0gVWx3AMRPtivY4iahl+Eh3t/X4HyvCsnLMsWlsub9T//0f6wP+Cm91JYfsg/Fhykh83whqME ksaZQebbmIqfrvNfGf8AwQyheL9nO1uZjCfM1a4hmVHwQsbeXHkfgT+NLG3WV0f8X+R9JlLftMYu 0f1PIv8Ag471O0j/AGOtZsIgPtJ1mwleUZHAEwUHt/GR+Nf5yFtbtqetSXqzzJYrOsUqQ/uZJQpB KsO53DGe9e1iI/8ACJB+v5nhYef/AAqyh2a/Q/08f+CGdl5f7G/w3mkRRLfabFctICGLIttFHtJ7 EGNq+Yf+DkOeMfsivBKgkE/im2e3KcmErBMJCfruGMe9eJwsr1dP736n0XFl/b/+A/kj+J79jT9s fx9+wn8YtM8deDruTVPDMmqqmq6PMzIskKScN5g6fXp+hH+kL+yL+178OP28/wBn3RPFJn0eN/Ee iLbaxpMOqxzz29wi7JkkxjDhuoIDDjIBOKyxf7vFJx6mDq062AWFm9Y7ej/r8T//0v2r+OP/AAQf /ZY+NV94l8UhdY0zxFrnnylLG4WK2Lt8x2jaRyfX14r+I39uH9h3xn+xv8Y/FngN7jUDotpfyDw5 4lEE1mlxE5OyKX+HGPlJGRlDyegeHqTeIlOep6mLp+wpwS22Pzj1aW/tQLK6a9ttsm4KLhpAZM4L Pyc5x39q9v8A2UiLj4+fCyGOe5lK+PbJJbknc8eJEYoPb5gfqtRmd/q82uz/ACODL582Mgv7y/M/ 1tv2V7dF+A/gKGbpH4asrfe0flyTO1uhLY69TX8U3/BzLfLP8YfAkVnJiWz0C509AVJYO87Akk9s krn2NacOq+Dn/gZ63ECcsVr3R/J9PazPcr50R3HKkuecjrXN3tg6/aWWNwIX+f5t3B6H2FClzQd+ 54lW1tD/0/48o0e3hBQKxYlg7dqkhuNpY7RnIYt6n2oWquTD4UajXIXBcqxdcKQcGqzQRSjdtO9T n61h0sUXdOkk+12oTKXIbbEckRr9cdjX9k//AAbKQtBqnjPzo0afTNWks7hoxuWX7R5JdR7Axnn0 avJzi6w8H/eR9dwtK2KqRXWEv0P66f2wTbWn7P3xHmuD5Y/4QvUtkYXdnNlKoX8jiv8AJu+L9ncy +OPF7R3kmE8SzKIyo+RPlUruHJHGQD0JNfU4STjk782vyPlcdHmzB23V/wAz/9T+WPwjaXCeNPBF qXmRH8T2skhIOyJQ3Vx6ZxX+rX/wTkgNt+zT8NG8vg+FoRcTAcuyqFA/DgfSvAzKNsyw3zPuMmk1 kWK+X5n8+P8Awc3apYzeD/AmlQSLLqs2vvvjHyv0wVU9x8yjjuBX8YvgLRby8+JXheOTy7aybxPa QW0Ucu6WRS+dhH97I69OO/WvrMyco5bTvtynx2TyjPMpqO6lb8bn+qz/AME9reW0/Zs+HFo75jTw rYmONweP3Sux+uWwfpX85n/BztcQf8In4Bs7e5kS4uvEs11JGw3qi7FTcq9MghOD615fDSc8NU/w tns8Zu+YRk/5l+R/DVrBgGsakkabZodrPIY9pnGOCPXHIqgt0spUlRlhtYnqaxqfGzx1qrn/1f5G DOlqiqibi3VvT3qW33EKCz5c5XaM4rzbXR1QeqNy0tWeUuxMj/KI5GUSNARjDKDxnv8AhX9FP/BG b/grF4z/AGW/iDYfBfx3Kt18ONevoLfT7vWr0Wq2SoFi/dMFEfzZJKtyMAZwfl5pwi5XfQ9zA4lY ffZqx/cH4+8MfBT9rz4c2Vtq9z4Z8UaFrNtFexRxahFdFgy7sCNjhhzwRnBAIPQ1+MH7av8AwQw/ Zv8AEPwx1/xd8OPBl1pPi3StPuLyG78PR+TK0nlllDx8oylgozjjdnmvQkveRlTaVOx/Df8AF/4R 678JfEOqeFfGWhXWl32hXclpdi/tJY7txvxFKRjG1hnnoMUnwNsEuvi18MLWxtYrjzfFds0CSSFb Z0DgHP4sp/Cpqr3blUmuex//1v7H/wBilZE+AHw2hmnQmz8LW0TqsexUJhjYZPfAIH4V/LX/AMHL XiaWPU/A+lWkbRyRqJLnYSEuS08hBYZ7KFx6VwYdaL0PqMS/eb8z6I/4Nw7OSb4V3+qX0586a4+x RWwQsdglMi/N2++eR6tX7e/8FKrptO/ZZ+J11FtS4/4Rq6ELum/azoUUr9CRz2yKwj/EfqdD92Mf Q/KX/gkj+wX8IbzwePjNqWi2d344nv5mfVVzFMEdshV564ADEdSo7jJ+5/8Ago1+1Prv7G/wbuvF vh+xtNQurVxbR/bzmKN2XEKKoIz6nkdMZGcjeluzKuly39D4X/4Jb/8ABVn4i/tk+N9R8KeI/COh aZHZlgkmnROoITAG4ljy5YEYPGMc54/ev4yTLbfC3xDcygnbpbmSEEL83kuynP8AvAUYW6xaTIzF XwlvI//X/CH9sbULDV/2i/iZbFpQJPE95Gz2+4OV83b8x9Mqeelfu9/wbsE3HxY8RtILWbZCNItf KPlTW0du4YOw6jIcDPc59K8rPF+9XyPpOH0lTlfsz+2z45PYt8KfEFxPMLeG30OaeaM4GFS3Zg35 gH8a/wAun9sn4kX+hftMePL3T9Tu/t2n+MTdWV6UCwLucs7PJ975eAAMZ/WtqKvRM6jSr6n6D/s4 f8F9P2vfgh4Uh8Ew6R4X8R6daIYLS+1O5mzBAi7Y0EaupPc5Ysfm7V7z+yj+3D8Sf24v24vhn4k8 f6DoelXGjGM3MWlSSmB4TNIplYSO3zbp+gxgRr1PNck/hZ1RaUtT+7qwSS38B232Yrbra6QbkZOU UKhIH48V/Jj/AMFBP+C0Pxr/AGavjJqPw+8DaR4eu4tJaT7TLeK0pmVZGAC7WDHGMcH35zgdMdke VVetj//Q4xv+Djb9rt43a28BeA/s3k9HW6M75zhgPtQIPqCuRXPXX/Bxz+2Fq9hfaVN4M8BJG8Ij jF0LsSIo4YLi4wfy4xXjnoH4SftEfHHxX+0h8Q9b+JnxCmil1rxJfNILPT4pIrTThG5aMJuZmGAo GSxJ75r56lLvvt1T7RHu/dqTtOehzQ3oYp2dy1aS6hpccay+bPHJOELKMrGCf5DitW+jjkOEO6Fc OkoUgscc8deKzg9zRySH6fa3V1LELki3AlKxwhf3swxjJ/nxX31+zf8AsMftBftH6ZfXfww+H2q3 2loNsmo3t3HYRT4yCEB+btxgdCOlYyeyOmnt95//0fxc+O/7Gv7Qv7NtvIfib8PNb0nSDL9mW/kg a9inPVgkiLtYYOfcZ5zXzt4G8aeM/hD430T4g/D/AFy80K+sJIXeOzdoo7ny33K7AfxDP6DuM187 P4T2YP37H+kD/wAEqv2k/iN+0l+zx4R1L4lC0urhtKhiaZkEl3MnlncJD33fIcEfxHGOg+LP+C3f 7EPwVvvg14s+LVl4aS08TxbbtHtSto80yoxCkgZ27Qxyfarwu/3m2Jfun8IWp31pGrvC0Eto4jhu lWTEYJKpIAR6EkfnX+gn/wAEKNMhsf2dPCcFtGJIktzLJOxzKGVF+X6bSoGewFZYr+Il5muF1pte R9Bf8FkbmTT/ANkzxTNZ3UdldTXCC2zMIBv2yN8x9MIfzr/Nk16zk066vJ5rtr62k1aZLfygZFgD OflAHPXd+fvXVBP2SZypp1j/0vye/wCCbloup/tJ+EtGaOyEDaxFcXTbgk8gcgI3XkrtI57Gv9Nb 4XW0OmfDPRIIyrwR2O63VhhYlC4A/IZ/OvkU2808rfqfa2X9mX63/Q/hu/4OFtcS7+PHh2OM29+l v5tiXgG2ePaFUgFTxyM+2w1+ZX/BNDQrvXf2qvAaQGKLUNIuYbyI3UoIMUlwqSDHdgoYg/hXpZn/ AAV6Hn5Wk8R8z/Tb8EW/2XwVDaw8Wv8AZObPACl/3eM498V/Cj/wXW1y31T9qrT9LW+mBtpEinsN gaPKRrH5hPqDlQPQmlhP9zl6foXjLfXVfu/zP6Vf+CNugXul/s1+HIFlkeLSoRGJHj2GcEApjvgK EGO1c5/wXG1S70/9k/xIILiRXv4mjniibDPiCeQIfqIj+Vedkif1dKX8z/M9DOnH6zK3Zfkj/9P+ f/4e/G34lfB3xzpfjvwT4s1LwtqVvdJNZw6RPJBFfMgZTHcIDhwytIvzZwHJHODX6y63/wAF4f22 9T8H2Xg6+1LwOtmlgLWW/TT7m61Gb5du108wJvIHUIBXhPSufSxtKjc/X3/gjJ+z74H+P9vffGrx zpses+KdeuzOjXmnpcQWIjcySPCGzsPCgY565J4A/oM/aT8QQfs9fB7xB4h8NAadF4d0Wae1S2jD xxhUxGTEB7HIHoOazpN/WGvP9EbVIpYden6n8437EH/BVT9on47/ALSEHgPVtQsr/RE1p7VrlrIl vJDSBGbDbdwZFB4wVB6E5H9aFtPJL4OlvZSJrhtJ88hT5QdtuQfb1rmpu2YSb8vzOvlvg4r1P8/n /grR4jl1b9tm/wBIuJba82eJI0t40kHmQFHWNwzdslDkHpkV/Y//AMEyNGttN/Z38NxLGsbtZRXL qvPyyoDEoPcIqAUs40zGi13/AMjoyuK+oVb/ANan/9T9gf8Ag4G1+GD9nubT41dWn1iNbhCMEqWj RGHt8rDj1Ffn5/wb5+HpTqOvXa2ifa7rUY2sLsyDeyRSEyLxyMZzz614WZv/AGKm35fmj7PL0vrE /n+p/WR+07f2lh8G/Hl1dhJBa+E7u4WEjKsy27/KD/npX+ez+z0B4g/b2ih1C6aC4s/iPMfMi/eP dv5mCu/oFzk5ratHlyqpIwp2/tGKP9Eb4cQkfDjSMb1aLTCsDsNreXEuE49SBX8yf/BT7/gp78af 2VvHkXhXwFeafHd/2hJDcrqNubxGUtsTaoIx91uc8HtzXDkzbwSv2Rpm8UsW/U/Je3/4L0/tpiKa 5WfwakO/94k9gXdgDj/V5IOe4put/wDBwR+26LWTRrfTvh7p4uUBWUWdx5bDBypTzeM9fu55xWz/ AI2p581+5Z//1fwD+Pn7T/xd/aD13WPGPxEutPutV1G9kuZPsNsbSCLhY8KvJPyxqPmJ+6Cc9a+c 4LNNXw+d0qr5zxscYKjqa8er1O5R0syaTdZoX+VgFIJHLDHYVnSSDzIbjayiZcCTkISOx9+a5zKS a0HpPvdIPItvJjySw+VmLH7x9cVNL9mth5yLH5jfKWAAJrkqWEYWnzm6vXe4ZraNGZPIjYbJCPul vrx+daMqxzEhHdCr5RkPQg9qyA//1v5Y7OGaadkYEANtZm6Nj3qwYljDMBllziMf0r487edGVaa0 EE8N/uiaGYhNwJyOxPpXRmSKRBI9wvzoAqgfP0xjHsKB88TFFpbukqm6lMsbZG3GOemW/wDrUmrw IIbWeGZBIEzvT/WAjgqfT/69HkO6Rnw20Vykc99ElxboSHHmneuMdR6VqQLb2pc2sKAOhVAy5UAj HFK6vYLpK5//1/5UpLq7SRRbXNzbzwDMcsUjRsuOeCKht7oPcQrP5yzfPJLdzuZEmZuuT1zzXxMn dndzK1zVvDpWr2NiyRJFqdlM6RyW8jDdtyCW7ZPP5Vjm4mUqka5mQ4kic7WT0yfepJ5y7dMqwpKZ FWcqQ0eMbSOwPesqK5uWltb07hsby7faMylyQMY7DnvQTzyOiu8xh4ZzI13J85kY/IM+/TPHY1A7 Iv2WIs/m42IsYJ3HHOcfj1pNXVi1JvZH/9D+Wy0tIYI5J1kfHc7cLExBJB+tTaLex/Z76OR5Lkzy h7aUjb5GDhlHHINfA8r5rHoE019BBKsYBeUrlgwwB2qg8Fos63ghl1KeT55gq5MRGQvDHAxxnFSa wTsJqGl6pG0F0JrVkuF8xkjc+fEOgDDseKqPctC0AeRm2yCJxENzHg8H24oLJZbpxcRIiMIpQcSL yEIxgH65q1zIghvy0aqMO0YzuFTJK2oH/9H+U24tI7oSW1nc7LkH/RpJk2qnu1asU95YSC1Nwsze WEnMbbopAOhH5V+fn0BdSzF4nkSJGFuz5eyUbYWB4IYnjH1rRMcdpc+dcxRxyW8ItlSNggYqAA3H BOQD7/jQO7tYoaZbazHDNJBfyJY2F0dV8hWVSjO3zHafvZJHTpVCa4kjkmnfzJUuZDNLEvKnPt0p p2uOLtuRTNcrMslkp8lYd08ciFNzHoAary36WX2OaXTxOksjLdW0I3OgbIDkjpg88UjY/9L+Vh76 S2m+wSWMccchVoZwSHbcM88ccEU6bTtZ04furGWCA/NFPJld27nK569a+CkrJH1AtpH5LSTzkxz3 oEcsh6yYJ71olk8t1iWQLCnzlBjGO9c1RWRhKSvczboCREWUbhIvy/44q7pWLaM2zYEajKTScvnu AffNb0n1ZdPqTyW1naW803lNK28yrGpLO+eeBVvSZVaxlu7mF0ikJjKKwLwsOmR9Katd3ND/0/5f oVgv5o4dPldpAxWRJU2E+uB+XPtWrDb6gdKuhP5JtopysGxvmG4DG4dicV8OfUGZY309pdWsETG2 aMhVy4VHzx1PQc1Dc2P2bULi6nuw9vI4EkKOHhjPtgnOfagd7KxlSQQ3uoKbqASW8bCS3kVihixx xjua6TULqyilt7PT4J7ezG2eW5aQTM+3IwV7E/NnHrQaU9hLa6j1AvZurRK5w7yjy1bH3djH8enr XsPgGy0sa9YXVzpUTx2hjC+YzPG53Ab1BPDYzXucPw/4WcMv78fzR4+fztkuJt/JL8mf/9T89/B1 vYWVtp1wLhri11Fowkc0g2xb32xhiBwGJAPsa/ss/wCCatlLY/CLTZ7izZJbjS4SsMMv2iCwRY1D /PjHzs0h+gFfu/jraOSZdT73/Q/OfBaDWKxtR/1ueDf8FfbieX4W6hb6ZJcm6utDCxWsDeWNjMUZ QegyGbdnqDX8jOvNNHpuoqNoewtnWVvOELJvjIPlk/e3bgAF6kgV+o+BEfZ8HJ+bPhfFSblxfy+S Pw5+PVpt8ZJOt9ckWytYXFjJ8kKSlVbB9TjGSa+Ytct5FugqxiDMQ3lW3iTOcH2+lfzp4lzdTjPG v+8ftnCa5eHsPb+U0tCtBbyxuVLZ4LOMMfwrvHmJj3GHIX5Vjk4DemK/PK+mh7i1P//V/i8EiQWh WW3CM0ZclGLNLkfd9OO31p+h3oSS2MFjbxLDMzpfAsLhmbgKB0GPXjqeteFW3Z3Rdo3Z12nC9trm 3W+ELb7syRTOQZX3HhcdMjt9a+ldOvNT0uxsDcm7m069lEccLMRGRjJIHoMjP1ry6rHdHURT6XEs aCy3zXIEOBDuEak4znsBjn+tWEtDJctZQlxHFGJJp1wcA9FHNcE3e5pGVtC3eWC2bpDdbvJ8hbgS D594P931I9Ki0u1g1E3DWspeC3ia4H2iM2s5UHqFbn6euK5k1sXJ2aR//9b+PiL+z7TSrKDT1uTc 26s00gXGN38K4JJGM9fWsm50C5kmuLmJo/KuLRAZEkCTRHJHT8eleLR0dzJyukMtdER71UWRbcRK GEiuIy2B8xPqas2dpCZQhkYSSSsgCrkY7Gsnuwi/euddoEVrBLLprXs9xBC3mwXUKh1jl3Btki8F R1Gf51qX9tot3qcN2QZL6xUf6K0blEQ4ywfpk9QKun1NTQtdXd7kWxyIBblrdscHBO5c9jwK4i+u dQ/ti4maRWRAPKhP3Y/94/1rop9gP//X/jp8Sy6vdlkVX8uO23JOy7bSInghe+7vXlGqWN5bvFtv LWd5oldhbybsZJ4cdiMdKMP8BnPSWh2nhLy420qe8jhmntr3zR9ly84xwPlz6E496/TT4YXH9r6F ZR2FjJcwCQadH55KwRMqKSp9GyH+oB61/QXgBNQ4qqL+4/zifkfi7Fy4bdv5o/k/8z+h7/gjhJc6 L8TL+ziSwtdc3eZHawSHN3YyyhZY1z1wNo5HGK/sj8WJFdeBGtA5tVj0xbZXIykYiQ8A59V47189 48R5OOlL0+7T9bn6V4ar2nhjTh05Zff/AFY/g8/4KBaPHp/7SXjK5jtoLn+0JZ72O6lOCFifysKn ONxXOTz1r849a1zWSqedaNO1lJkRxRebMQSAAgHYDmv7L8O5+14Ny+X/AE7X4aH8X8R0o0c8xNOL 0U3b5s//0Pxesyb6VoXgkEZAlu2nHkz22egCnkg5H5iqz2SWNzPetLvtmHl29uGDO5GDnHav9aLH +e202XNKvJLuP5raa0W4UrKjfMIwp556HOAaoarq9pZRTeRay3E1qd9pG6+VHNKhyAfbig6IPY/o F/4IgfGTw5F4uOga7qGmeF9ZLQvNpnmNE08csvmFVY8Mx3MSB2jFf1bfFuC313wJ4hsNHu7W8iv9 FufsYilW5jmYx5CH06Y9s1/AnjrhZYTxE9rNe67Sv62f6n9u+HmKnmHhxQ5dHFOP/gN4/ofxzar+ zV8XrD9qJvFOr+CNV0/S7vXNwv2sW1kRkyRoJk2KSo+UMCwAUP161/YN8BNRltPhR4dg8SX5sNRg sUM02r/6HMIViG1iGAxnkY68VxeKWa4LN8ty94OV3CEU7d0j2/D2hisFkGIo4mNnzt/I/9H7A/4L W3Xh/VJjc6TrOhXkjJZ3NwY9QV7kFPmkJXqOYT+fvXqP/BFr4veCbLw3ofhbUvFuiNqNrdRxX0Up ktJooSu4vuZQHUNJtwMkGI8V/TjyyvjPBaMIQfNF3+SS/wCAfnvBmZUsDx/i4ymrVOZL1u9PzP3H /ap8PTeK/hprmnaNIbmW4sfOj2nzoJ081CoHBGCpb2xX8Wfj39hL4/QeM/HQ0/wbdala6xrUxsb3 e1vvkkckvEm07iVwMccjrxiuPwJ4iyzIfrdLMJW5lp+GhHiTwtmOeZ1SxmEtaCSd9F1fZ+R+6n/B I34IfEv4OwQ2HivR77S4bSSV9Qju4HSWXB37pM8cFyoOecfWv1p/aq+JPgHTvhv4kstW8YadoN89 oWWK4ikLJtdZMnjGCofp1wa/PONJwzXxCjiMF70ZTi9P8R+k5rVp5ZwRThXaThSaeul9T+Bf446n 4em+IvxCvP7YXUYr3xjcXiyQxMmBO6eUSvXLlsH2Wtb4RfBDxb4y8W6I3hyKa7iuLvyZdPt2e4mZ hgpJsUfLsYq25jjIA5r+8IVaeA4bVavpGFJX/wDAbH8aZNSqZlxFClh9XKpdel7v8D//0v6pP2Fd A13wv8JPDmk+ILK40zUY9JiWeG/XFwSmAe527sK2Dz64PFfLX/BVf4I+MvjF8K/EGn+Fba51C8td ImltFsiwUNvVgjcY+bLKeQOefWvuMvxtLCeIccfNrkVW/lucfiThKmP4WqYagrycI6elr/kfxTeL PAPjPwTr0ugeJtFvtGfT4o7NZbiMeXO0cUYdiRhckkHj+9yc8V90f8E/Uks/jR4Sa6MwlW/aZZRG GR0zGsaDHOcg/ga/vniStRxnCOJxGGlzQlTbTXXT+vQ/lrw2TpcZYajXVmpWfyTP71/CxgHge1dZ XmC2JVVMg/dcDCj6ZzX8eP8AwWIWf/haltrEE0s15a+LbzTpY1ZjIlsYxIAG/uZZgffFfxH4Qxl/ rwl1fMvvdj+g/F2pGnhaM+ntI/qftf8A8Ef9dtLz4H6dmFo90KpJvJc+ZtJIye/Svcv+ClFt9q+C GtbLgBrTd5tsY2ZZRJbyqvI/iyVwPavPzinUp+Jco21VRH1fGk6cuCHVp6r2Sf4I/9P8nbq88Ran e6rc/ZZWnn1aU3E1yn2e3s8BQic9DhQcGsK5eSKfKuspiOGKHeC3fFf604Omo0IxXRI/giU3zNs1 JLu2u9LCylm1WOfzPs04227oBwwfnnrximwW90q29xbwQ3zzhzKm/CWgAOGC4yx7+ldSj71mbSl7 h3XhbUYLTVvD2r6t9q+x6Nrlrqc62SeZcp5EoYMq/hz7EntX90P/AAT8/ac+CnxU+Evh+18LazKN UfT1EsF7Gqy+dE3lyr8pOOgIB5wa/mn6SOWYrFZJhsRh43jCT5vmtPyZ/QPgZmGGw1fE4Ss/emlb tpv+Z4v/AMFMP2Z/Gvxz8OXB8Fo5mvbcWJZy0iKgfcVbg4RhgcfmOtfFv7B3w28VfsaeJnufizos +maPd+TG80UvmQDDEidA2CMs/IPrX4ZlOeYd8BV8hl/FlqvuP1DAYKWW8VVs6m37OSafy/4bQ//U /s51zWPCPxX8Bal/wjl2dVt9V0abypFI8lv3bAK2Dx823iv4p/8AgoD+yd498A/F/wAQ+N9W0qe3 s7krPY3CWipE0SsJJ4VkfttSPOOyrzmv3/wDzqnk3Ev1LFaKonE/KPG7AxxmVQzWlblg07+TPy/v LGKTUtQvLnaoDliwYBF91I7e4p1lA923kwQxESNiOUf6xl9M+hr+7XH3bn8v30sIbdbZ5GZmcocK qnd064qwFkjUzy28rI7BUmJwgb0PvjtVcvu2ZUtkdl4Ps31rWbfSLO2muWmBwsTglXbaNz9wucgY 9R1r+mv/AIJX/srfEX4Yapp3iO8tDPY60V1W6N7BJBcJtIYNhlCgEblwTn5FxnJx+HeOmaYfL+FJ 4So/eq3S+S/W/wCB+8eCWBq1s8lmC+CmrP1k1+SX4n//1f7dvHaJeeAtfTzVie40m4geIDLyH7NI wCn6j8q/hs+Oulx6d+1Td3V3ewjU0e0nsbe8uUjjhfKpKoTqxAiY8f3j7V++eA8/9tx8bb03+TZ+ deKc4LPcqbf/AC8X/pSP7Gf2M725u/g34VSVIYJItIjaRYM7HJABbPXn196+Dv8AgqHdr4cTRvFU 8cLQ2NukrwSFY1Yx3GxmHTJKEcH+9X5nhIynxhVowW85L8z9I4gqwo4OnXm9Fytv7j7C/Yy/aQ+F nxV+EegWHhnU5jrUFkIZrGaJEy6L5ZYDPTIH418a/wDBRL9jTxp+0BFpk3hhIFu7TV7W6jdrd55c RxPHkKB1Gc4OQduMjOR6ORYqfCHGzxGMVnCT/F/1/Wp5XE+HhxLk6VCWktdP0PyH8M/8EmPj7b6h PJNrGl3EFvrXmTy31rLa6pJCCuQjCMqBwfk+uGFf0Ufs+fAD4f8Aw3+HGmaHr/h+zjubTTkXUJ2j S4QKqDcz71HQ7vvDoegr9B4+8S5Z1hIUMslyu+tmfLcI8IYfKo4ieMXM2tLo/9b70/4KE+Lv2Y9E +LVhf+CrKMXWij7Pr+oWloltYq6SkYVEJDEqCcqP4h7mv16/Yr8V/s0fGH4TeGrLw5JaaprNnpsT 3Fs6w3T7jHiXCsuRtdWG3HX3zX9DcRQ4kpcA4TM5t6bu+v8Amtz8w8OKuVY7Ns2w0bNqTt2tdr5r ReXy1Pif9vP/AIJjXvxT1RfE3wqtbaxnu9RS5uLQ6PHZKF2sGDtEuRkgNuKnJJBPOR8pfs//APBO 39qX4IeOrTX/AAvq9lp0cc0ct4lq9xZQShj8yFCDvwOcY6gHI608B4jUMXwusnzJ+9a2u/b+v+Ad GE4Qq5XxJ/aWF+Fzvptvdp2+4/pD8B3GsaT4J09fic1lJdwaeBqc0kvmKyKPmLg/QnkD6V/PZ/wU I8d/s7+F/jJ4S8S/Di4X/hKdHna91KztvIgjulWfPKfe3KA/JxgOox1NfHcA4XHY3PK+Hy+LdOSk mltZ3S/U+g42xuCy+vh8a7c6mmr2vbqftd+xZ+0r8OfjR8JtHTw9eTtq0YAurVJY7gphRGeFOV5Q 8e/sa+Jv+Cj/AOxd4w/aAl0/UvCal5oNTtbu2a9tWmVJIFZSMqCwwOc4PQc85HPkeNqcD8bTxGJX wSflo77/AJPzM+PMFDjHJqPs27O0tNdrbH//1/qfwD/wSi+Nmi+ItF8Uajc6Yn2PUfOmFhauFjjS TzEVQyDaSRycce/Wv6efgNDefDf4cabpfixRH9gso5L2eE7oLbCjcFZtp2g5xn8hX7f4mcRYfimV DG4fvZrs1ZtHzPAmXVMny6rh6x+MP/BSH9qH4Sv8RvDk2n6jqN7c6Y7W119nt0llLBySowxIXCxk k/TBxx+qH7Ef7TXwr+Nvwi0O08OajIut2Vmq32nTMspdwoRmUg55KjgjI3e1eJnWR47D8NYPMalN qlK6UraPr/wxpw9nGExOc5hgKU05xauu39dT4u/4KSfsW+NP2hxaXfhWaCGfzYQUktpAZ0jUgDco JVlO0g4OcEd8jgf2G/B2vfsbNpel/EPFvp0Ev2O7KP8AZBIjE7WRXC5I5ySO31r0swzuON4SoZJb Wk0/J3RxZDkyyzPsVmqaarN38rM/Xzx/a2Hxg+H+qweEb0Xtpq1hJZ286qsud2CudpPQgdPSv4wv 2qP2Q/iF8MPjH4juNU0xJ08ZeJ2j0fVI97PEgaRmjkDDggdQM9M+w+o8Hc3o4HF1cDXdvabf9u6n yPitlk8TTpY+n9hpP/t5/wDAP//Q/YD/AIJefst/Er4VSp4p1W3W30zWJV1BEKvANqlWBIZQDkb+ Mn7qnnPH9BXjOzfxP4Q1TSYCYbjU7CW3LBdy/MhC5Hpkg1+lcd4uniuMKmLpbOV/xODJKMqPBlLC y3UGvwP4vP8Ago9+xx8Qvhl471T4jW2lltGnuEttXecH5IdvEsWecBYs8ZHAHevxtXUrbVIdTWON 28uZ7aC7b5SrKcAkenFf3N4bZnSz7hujjqP8vK12cdH/AJ/Pufw7xXgJ5LxBWwFTdSb06p6o7L4R +MLr4d+OfDHiNxHKLC6FzeXKgtI8aMjbEHo2OR0Nf3xfsYftO/Cb4x/CPw3B4Q12LUNRttOiW5s4 So2SeSu5Tz1yMV+LfST4exLw2Ez2lG9NPklZbPVpvtfb5WP6D8BuJcO8FjeGaj/er343e6dk0lu7 buy0v6nx9/wUu/Yz+IP7SmmaHH4HsrO5uLe9ttSb7VK4IMMcsTIdqkgYkDYx/AOfT8b9B/4JI/tA WXiewu5bLQLPTV1VLu+toY2gSZlK5Mo2ZkyFAwxHbnpXzPC/idHIOE1lMIL2qVlK/fy8r/8ADkZr 4fVM14keY1G1SlK7Vuz/AFsf/9H+qD9m/wDZu+GPw58G/ZvGHhzQ1uIrLbdxjS4riAgKNxZ5ASSu CMk857V+OP8AwUp1v9l/wT448Max8PbnT7PxjpOoyuINO0VYnkAK+cglTCrkbOCSMITxjNf0n4c1 84z7O8XhY1G41IScru630b36tW9T8g8R1leRYDBYuNNKUKkbaWdkm3b7j9qP2Ef2l/hb8WPgh4c0 /Qtcin1yxtY7S4thPHNK7omxuQfUHg818v8A/BT/APZK8cftIeHYbPwrYwRma2iigvJIZJRA0T5z hFbB579wPcj4Dh3GVOFuMamNqx96lOSaej3cZL11Z9hxZg4cScORw1KXu1YxafTa6/JH4Y+Hv+CS Xx8tdRtI76S2s9Igugbm6a2lW8ucfIynPDKR0J2+nvX9Kv7MP7MfgXwJ8PdL0/xZ4e0y3OnWCRBT Y26oVhQBpWyuQTgnr3zxX3/iF4gS4g9jQy2TjBavXdvq7dtLfefG8BcErIqNermUU5tWXWyS/XX8 D8cP+Csfhv8AZW0jw94jn8ET6TJ4osYGuEstK0RZZmuQ8YUfaFGEYPIhHzfwkfX+amLT7h8XJa7S JCqzyyxETuQBklT27envX9YeGksZW4LwNbMbus4Xbe7V3yv5xs/NH808Txw1LiPGRwlvZqbStt5/ jc//0vyb8Q3mZRZqY1lmIaAl9jEd/lqQjU5LdbSyUg+UpkcDgYIDEt+df7Ewh7p/nDP4i3DdxQSN bXVw0txE627BQd+SAwA9Rgjmus0O0g1e+jsIW+13Eyl4IT947PvA+mKmcfdaNqTtY/ou/wCCS37L nxK8E6ufHGtWUkP/AAld0l5BbOGQ2VrCSVJbgANwMeijnkgf1M6xbS3vhS5sEbzHvLH7KmOSA8ez g/jxX+bvi/mFLMePKuKov3XL8nb8LH9+8JYKeX8CUMJV+JU9fuP4y/8Agqr+zl8SfDvxHufHU/hb UZ/Ct/p0ejjW9Mtmv7jTp0lJyYwMlDkllHYnpivxK1HS4IL6OEXKXMLRozXMcbWofcoYZQ8qeQCD 3GK/uLw+r0sfwlgsRQd4unFfOK5X+KZ/DvEWHqYHiLEYeqrSjOWnq7r8Gf/T/PT4Xa1/wi3j7w1r JunhttLvyZwsuTKjqyFdncHOfYgelf3qfsG/H74c/Eb4OeELHRvEK317Bp0bz2RC/aIG27dpGc4y OM4xnFf2J9JbK8Q3gcxhF+zV4t+e9vuPxTwIzHDRyzG5bOX7y/Ml5bfmfKn/AAVE/Zx8ZfHrwitt 4StFlnEMLsrs8J3QzMwKsqsQwB4yMHOCQMmv529E/wCCY/7TkOoxjX7CzOni5ilivb+Zru6utpBT f5cYGRtB+cjoK87gfxByzJOC5ZPiE3VaaW1ve+fS5wZxwhjsZxi80pW9k5K+/wBn/hj+uP8AYe8O 6t8OPhbYaV4rsYbC4trOOFmtk3R4jXa5HfbwMcdOtfDf/BWD4zfD228M2mlweK9Mh1eBDcrYYZ5n VHiZg5Awp278AkdK/JuD8ur5jxY6dCDk25aLV7M/T+PswoYLh6E6kkleCu9Oq/yPrb/gnN8b/hp4 9+AnhzS9B8S28+s6ZbxpeWZGxwRHtAU55+VV/I18z/8ABVD4B+LPjh4Fm0/wzpw1ORvKlt/ODH7O 8cu/AAB6ZOPer4axC4d40+uYhWVKbunp5Wf6kcY4VcQ8KrCUX/EhHVffdfof/9TJ0/8A4JwftJ6r f6FqF14MisLbStQFxK0V35styEIAOwrjBGerdz9K/r5/Yi0XXvAnwk0PSvFlpLp88duqsijNvaKn LKvtz+GPav6M8YOKsJxcsPiMIrcl01fre9/Q+E8KuH6vDeBr4XEO91dfckfCH/BXfxp8PNa+EGvW CeJbGPUvLuNPWxuJiXuGdomynHykKsh69MjuK/if/s42riK3v31SwnuytpOyFJCrOdmV9OcV/SPg NQnDgGlzq3vSt95/MfifOMuPcXKPl+SP0n/YA+Afj7xX8YPDnjbStEe48MaXdRafffaI2AedSzs0 QI+bqo3L/cPNf3hfCoTp4E0u3uzJBcW1osckUq7SDsXP68Yr+b/pC4uli+LFTpO/s7Rfk1uj+ofC bDTw3AcfaKzneS8027H84H/Bbf4G+PPFtlZ+L/DXhy71e30u6uPt0kUPmJCJoURJcjnCsnbn956Z x/LMyXGnXv2S+vJl1OxYRXavEyeU+MkDIGcc8j0r+r/BTMKOY8D4NUXd0lyS8nHp9zT+Z/IHH+Aq 4DirFRqK3PJzXpJ3/O5//9X8otRvYZWVUmJlDfMuPkfHfNYGoW1tPcCMoBPtBJyQGBGRj86/2njF 2sf5uyV1YydRkhW0js8uhaQ4YE+ZGR0yfTn9Kksk2xCRAxEYCvj+P3/rW0I23KSsrFy302HVFur1 F8maxiYsJWER2g9RnrnI6Vn2pk3vC2yQAY3Ny+c9f5U5xUotMcJctRNbn7k/8Evf+CoHjj9njX9L +EfjnFz4GvrvybPU7hWvItNjmljjjJOMoFZwPmbvnkZI/r613wz8NP2ovhRNHe3Om61p2vaU9vLN BcLIhFxHt4KnPQ9RX+evjNwriuDvED/WDDRao15c6fRSvdryt2669D+xeBM/w/GnBEclxDvVor2c l1slZPzvvf8AW5//1tf/AIKKfsBeLP2efiPLqPhDw3rOp+DCjwwy6esmoWEMbNvX5sHayM7cZ5Bz zivyMmTVYdRvtH+zXDX7SLbRWAtj5zSyAGNY89c5Az04Poa/1s4LzyhxJw7Qzig1edNc1ukkmpLy 12vrazP4HzPLq+T5xLLq+9Oo0vNX0f3H9H//AARh+G3jTwV4ludZ1bRb+COSO2U6hc28kQuPlDeW MjBCCXBI4yD6HH9WvjuzOreAfEdm6RyS3HhyaOCLaGLM0X3Rn8q/z28VMVRxXiPiMTSd4OpdPyuf 2/k9KpT4Go4eorSVNJrz5T/Pr/4KB/BzX9C+OnjLWb/S3to7a8cwf6O9t9phkWNVbcww23Yw44GM fT87rS5MN7NbQZQRyBJ9wKMuBuG316iv9EuAcbRzLhbB1KDulBL5qx/n7m+FeAzKeHkrNTl+LPor 9mbWtKsPjx8Pta8Qa5baPp9prqWpuriRYoFJIZcsSAOVwfXIr/Rm/Z/1nS9f+FHhrVtMvrG6gfRU aeS1vUuVL+WvPB79R+FfyZ9LHBV45pgcbGLdO1m+l7/8N95/YXgNmFGfDGKwEpL2ik2l1tbf77/c f//X/Qj/AILX/Ajxr8QtVgj8OeHta1W3TxAdTkudKt2a5ZZAjSbCARyI4gCQeQfevxv+B37NnxY0 j4r+BNRl8H67caFbarC4mudLkgutOJYb9+Mg8DOeh2/jX+gnA3F2TUvC+nlteqlVUHG3nb/PQ/lX KOEc0p+IWJzSNP8AdOtzX8r/APDH94v7Mk89v8JvD9jqbmC+t7BYJIrxvJuFUIACwPOeOa/BL/gu fo66n4P0bSbSex1Wa/8AElvdCBJBNKkiRPGudmWAw4/Dmv5y8JGoeJftPsKUm35Xep+q+Ovs6nD9 Ol9tzjZd2Wf+CHPhXxD4J0F4NbsbyyW+1QXkTX1q0KFDwuwkcoCGxn3r+gH9omxGufDLX7GO2lmn uLRnjaCPzWQ4ODgehry+P8TQq+KM8TSknD2qd+mkj66hh6q8M6WGqR9/2Frebi9D/Oh/aw8G694S +NnjG31+wk0uG88R6gbdb21e2lviLpyrK+NrgpjA7bTXzBPBHC06uGkhkX5VTh047V/pjwpiKeKy LDYig7xcI2fysf555lhfYYuphqis4t3+8//Q+dP+CX/inS/CH7SfhC41DVdOg061uUtPK1KdYpVl umRRJ82NwUKeT0zX+hZp4iuPCFlc2k0N5HJpsbW80D71kxEMHI457fhX9WfShoVlxjhcQ4vkslf5 Jn5j4K16UvDZ4dNcyctPmz+Lj/gsP8M/G/ib42Qaz4d8MapfLZ6Aum3qw6dLK6SNezPnIU8kbR+F fn9+zx+zF448e+KNK0TXfCPiHTPt2ofZpoLrRpAptwu5pPMdQq5Py5ycDPFfvfC/GeUZb4cUH7Ze 2p09r9bLb+tz8QwXB+YY3jWftKT9jOpdv5v8/wAmf0VeGf8Aghr8IL/wBBql5ILjVZ9PW7nt4poY pY8r8wibBww54JFfEP7LX7OekfsZftqp4UOpRx6HciRdCvr6SK0uLpHuE3K6hsbk2DleOevWvxzB +I+a8YZRm+USvKLg7X166W9bH6jieFco4Z41y3GwtGXM9tNt7/fe5/XprJhTwHeLCRMtxohWzkjO 9ZC8PBBH17eor+Df/gov8KfF99+0V4iubTwxqN1aTXJlN3HZSEkzpGWYDbwFbcpPOdp9K+S+jnjc Nl3EGLnjJqKcWte+p5X0hcsxGaY3K3hqblySk9Fe1+VH/9H5h/ZY/Yq8UfFT4tDQvEehXcWlP5H2 qC7sy1vCHJGS7AA5HbAxg9eTX9A+r/8ABCD4Zx+Gv7a8P61No3iBdELOtnZ262buyAncSpZR2+TB xX97eIPi68ozvC4LK3zQdr2/pH8tcKeHEKvCuMzPMVaom2r9kfPX/BNH4YT/ALPn7XXiD4UeLL+1 S8SIPp4uJxMt4iyDaoJxyG24yAfav6o/iL5qeAfEYt13zrpc6Qqq78ZQ8D2H9K/APGGtPGca0Mwq KyqxjL7z9z4FnSn4dU40Xfl5l9x/BN+0F4G8T6b+21q/jTU9CuoNLvvHT38k7xOgdT5KMQ5HIG0k Y9MV/bN+x9qdrffAzw/c2pTyPK8iURyLLs2ovXHtt6+tfV+O2MoY3Ism+ryvyQUX5Nbo+d8FaUsH gcwo11aUptr0aR+C/wDwXz8O32v+B9N+z2t4dHnvIFvJre2LsksQ+Q7yOBtd+/ODX8gjr5UYskf5 7SNYHYgeeSq4G7Hc9a/rH6PFalU8PcLTpu7i9V200ufx14mUq1LxAzL2isnNteaP/9L8TPDPh+71 a5WSCx1DVLoOLaG1s4i+WYrtJ4woyR8xIAya/pL/AOCZH/BNyTxze6J8UdeSWzfTbyLU7eAvuSCW IDcgOBld4J7ZK9a/1Z8duNKfC/ClXDRkva1k426206ee33n8heBfDbzfOf7Uqp+yoLTs5NNb+S/F o/p/8X/Eq2/Z5+HrXurxG+0jRLF2u5ifL8hI0B+nQE+lfw8/8FTv2z/DH7Ufjtl8ORRWRsL25sv7 Rt7k3Es1vHPG6ptxhQcOMlskdhjn+cPov8JYnHcS1eJ3pCLb28/87I9n6SPE8MRPC8P0viUlN+St ofkpHK0MglMjGJwFKMB2PXNXLp7e4jeOQAIQNpI7+tf6Gx6n8wVJPYxCjxMV+8gHyEcVdiiUwFgV JDc5OG+lawj1Mj//0/wXMlxCWW2bygeH+UEOAehzULea0m2UYY87sbV/Sv8AeA/y3B7dXdUkcqhH VOtS29rJbwTYlLRIePMOXwTQRKfRBGVRgATnOcjippLhpS8bFUH8IB+ZsYoKi7ozHAbcAuxicM/T eBT4ljRBHGqIN2SEGATQUm1sf//U/AyZvK2xQYZs/vFHUe5pHtnmVdpChjhu1f7wH+XsXcp3OniC 7gWGd5XVSsm1v3IPHT/GnyWTCRRMSSMMBjAoKGuZA7IYl8sjCnPzVahtokKyMWbcwjIHY8DkUGc+ xdu7O3VUEW7BPzMTjP0FQzLDBEpRixx1bg5+lBmf/9X8BvN8xAmdxHQVYhaKOJnfkJ1XHzV/vAf5 bldZ1Yt12jnJ61Ct8gLJtK/NjOKAFFzEzLAxZo5T8yj7p9CR7U6RUEiwKi7fWguD1sWdkcEW5thR MmR+yjPeoIb5IHYqu+N+fZhQWpJuyP/W/n9lDX86xRqquQTHEpwWwP8A61T2dhLEhZ42jCvtPmDb kiv94D/L8W6VzEfKVfNBwm7hQe2aqXse4rG4PmKoVwvQMODQS5JOwW+nhUV5WAljHysMgY9xU9xN qPKySmS2RR5Q9OOR+goK6XKlo8gl2oI8y8cjLD6VcMTpLuBw33SfTtxQc5//1/wGaICRFjO7auWf +hqVUiLI5QF0JCZH3c5r/eA/y3Kc7ShynynccnPpQlqp23St5KxNh9zbcn6UPRANuHLToqrvJyTJ nP4VXPnCbHzJ2+lZJ3ncDUs4kQuJGfcPnTcNysfxrl/FEcMOmX05hnniNnIGNvJ5Zt2I2qzHuM44 7+tc+If+zzXkzfDO2Ig/NH//0P4svEdhJ/bupvM8ZilmAhCjMseFAO/8f51gyWsdqIxPKQxJK7Ru XHY1+sccL/jKcw/6+z/9KZ8pw6rZNh1/cj+RnzxO0oRDhQ28Oe4q0vlK5jAxjv2NfHnvKW7N6xur aFo4JGCbztiCrncxPoOn1r9sv+CKdtFa/tufDs3EswivoYVFyqeXGjxzq3MmOAqjP1YDvXi59plt V+X6n0HCjazygvP9Gf6mrXAf4eXTXcRmhHhmUkRnPnDyeSCPXqPwr/Pr/aw/Yh8Z/tn/ALefxV0f wPPJps2p+IZbBrm+tWf7NCqxfdABBB2Dv0U4z0PRwxWhh8gxMpO3uoy4jy2WZcX0MPHo5tvsj//R +E/2nv8Ag33+O3wD8A3Xjqx1HTfE0aRG81mKygn027t40QuZY94ZWKgAEKB94cd6/Jv9k7w7qFp+ 0h8KLWSOa6l0bxtFb3SiL94rQ3cYk37eMbUJzx3966lUqVstqVZr3Umr9NmehlNWGHzqOEv70Wn8 rn+tP+ze1rL8IvBpgh5k0G0kJYnaTJEGwR6jkY9hX8Lf/BzNeWUX7Q3hG2KJNIPB8Ut3tBimjZtR vBtDdDlQnrW/CCvQqpfyMjjNpZjFv+f/ADP2n/4NwLCzn/Zvs9RtYPLjtbia2VXm3T4e5Dx7x/sg tj1r7J/4Lkhrb9kr4juIhLA3gu4kk3sSpZpY0UfgSK87hB34iqpfzy/Jm3iU/wDhBov+5T/9KR/l va+Zp9evUiM5tbG6k8ncdnno3IDL/s5I4PavqT9hfTorv9p74UpHYz6hJP4ttEnECFoIozMqsJGH Q55HstehxOlL6w/8RxcKyarYVLe8T//S/ti+CECR/CjwlJECJoPD9tPMgYujMYFYL9R0Nfwe/wDB yBC1t+0p4dvp7VLhtR8M7YWhyfs4a4nGzb0yd4/MV18Hx/2Kcf7h08aNSzOL/vn8x3gDwV4j+I3i uDwlpaXE+pahqMdraWkDKXYM+ORyQMdSBn6da/oh8I/8G4H7QvjDwDZ+LbLxNpcKXmlR6s+l/Yp3 it5JUDBQwBJIBGWPuRxiuXMcf9VrqjH4nr8v6RtldKUsLLEdEfnvrXiT9uD/AIJneL9V+F/h7xp4 z8Iz/avPuodC1O4fT7pizIMAHuF/iAyAOMV/Vx/wRe/4LGj4ow2fwi/aOvdTbxpPHDBYeI7pWMOp hiQTKvRJQSAQBhs8YxgdU406mEjNtJ7np5ZU+s1nSl2dvU/R3/gqn/wTr8BftrfBfWdc8F6Roy+N rGwN7Y3b2CNJfxMC5SOQ/d3EKc+vGRnNf5oX7U3wG8Xfs9fFLVvh141tpNP1a1uJLe3tooT9ldIW 253YGCBj69ea78HevhJTv8P5PQ+YzScKWJlh3u3of//T/i7uFjSSVCMlDgN6n/Ip1vIryKX2yOg2 5bnb6cfhXpSd2c9LSw68kEMweQLGm0ZLcbv8/wBKatpNczRGxjmntrtRlkG4Rn+gz3qblNWnc+lv gb4cnPxM+G32uEXLweLbSYWyIHe8w/Ix2wM81/rafsKxpF+zx8OIIoGjt18OwIA+coyRpwxPcdDX z+Oa+u0V6n2+V2WQV3/eX4I/lA/4OltSshJ8O9MClHv57vVPtDrhwUlWExqB0DFgT68V7j/wbB2p t/A/iK8tQ0ySTSG7VskzHzEG7j+6JBj6mvU4ju8Hhb+X5HzPCPIsfjLf3vzP/9T+rH/gqRPBb/sn fFmKVpUjHhHUXYdURlty0QPbBbb+VfLP/BDKO3k/ZigkUKXfVJFkQnOCvzOR6YLmjGr/AIS6K/vP 9D6LKZJVcYv7q/M+eP8Ag4yRL39lbU7W1hSW9k1mxMEG3cZY0Epk/IENX+eLa6Rcf8JHZabbW2pf aLmdLm9uPsbC2gCsMx59Rj8h17V7GImllEIvz/M8PDx/4UpyXdfkj/Tw/wCCJ9mum/sg+CtNTzf9 DsxblJIzEYyY0LMAeeSfzzXxh/wcd2Ul/wDs6eHfD8DymfUfiBYW1o0KhgiPaXIfdg85fYMe1ePw t/Guv736n0vFTSxPvf3fyR+DXwn/AODfb43fF/4aWHjqz8YtaSahpsepf2ZqGmlwqSorogIHHDA4 YHtmvzo+IPw+/bQ/4Jp/EbWPBWleM/Fvg+Eu88V5oOt3enWd9EOBIURgpYgKCOfurzxxtGmsZVk1 qos4MVg1RcJUnqf/1fp7/gi5/wAFe9R1W/tPhR+0bqniDVLy7YQ6d4hurmbUWunlk2qJ2ckhgXID DjAGeM7f3U/4KD/sQfDP9uf4Hazp2iWdi2uS6a9/pOqiwjF3ISoeMbyN4IIBxnH6UpU/YYvTY+qz vDf7BSxEFa619Uf5p/7aH7MnxH/ZV+KHiH4e/EDTI45tOvRaaTrbTgrrNoW2wOFAxuHzA85+XnkV zH7IU8DfH/4S2u2RHl8aWomkjjKopEkQDk+oBNaZnHloyT/lf5HyWVS58bCS/mX4M/1uf2dyE+EP gXYZFhXQbVYTKuC4SFAhPv0/Kv4+v+C03wH8VftQ/tgfDr4X+E47ldUm0qOzurtbQy2ttvvLl2dy P7o5xg56e9Z5DUjTwc5SenKz6jNqLxGYKlHq0fJvjn/g3T+OPh7wFN8QrfxjaatLp1g+qW2gzaPJ b/aR5ZIUSBiM8jAcD61/Mz8U/hz4v+E/jfX/AAf4qgNtr+majNb3cKMyw4DkbVVvmyPukEdq3jB1 ML9Yj8Nzxsww9PD2UXq3/X6n/9b+Oy2Mk8siyIBCq4UZ6k+1Mn2xRAglSsmB3BqKexMVaKM6O7me XoxWJskkYB71vWmqRTNIhUiQDKgDtWWxR02mW0E0iNMxKueGHy7Pxr+0f/g2DstIt4/FlkHuHnDG S4vCmRPJmPywGzyArqOPQ+leXnivg4f4on1nCco/Xajl0py/NH9Uf7c3222/Zs+Jd7bIly0PhLUI 5I2xvbNpIFAB9SMfiK/h1/Zp/wCCMPjL9sDU/FPjhb660LR7zUp4LZxbt58sobl0bIKlM9cdx16D 3ViFRydLq5L8tzgw2AjjMzqzqaRjFv8AHY//1/z7/av/AOCSnxF/Yf8AHvgjW/Eus3fibwzP4oSM 3VypSSIhleFJCRgCRQ3APbgdx/fn/wAE+5bP/hl/4a3NlHvik8N2x46AtEjbSOx5Un614WYPnzDD u2yZ97lqpwyXFQi9bo/mb/4OW9Nvb258DRwx30iaW91fzz2sQkjt2LxbQx69U6Dpg1/Jh8HNGu9U +LHgaFdMvDBB4qt9QuWw5EiJncq55zjPHbFfVZnOM8upQXSJ8BkEJwzatdfFUX+R/qjfsOwi1+AX w5t5YRbxweFrYCM582NmQMwbPPGSMV/K7/wc7XsNpqXgSG31SWzae6uc3DAbIFcNliDwCCg/OvN4 Wny4as/7kvyPc4y97HU+X+aJ/FlJb3RjWeV2c4xvdf3kyjo2Pfr+NY8yOrh0Xaudp9q55LqcEV7r P//Q/kCjnilXAfIU7G9c1tWbL5qxb2VVHEjdCfSvPtbQ64LU/S39gX9gbxB+2Z47bwtpWtahpeno WuNW1a22PLboAojSEEjaWZsZOcgNgcZr9mfj3/wbk/E34T/Cu/8AHHg/x7d+JJdEsn1UWWqWaxtA qKHURPHucdOTnHHArjp1FWx31Ttb53ParYGVPK4Y3+a/yt/Vz8XvCnx5/af/AGdPHNnoWmeLvHVm nhm/S3n0KPVrwWbGMkSBVBVQvHAIA9xX97//AATD/wCChPhH9qH4V+HPCviHTr/TfGtjpaWuqpeo 01relf3btuY9CykdOO4HSvUOZO0D4u/4LNf8EtdK+Mmgv8bfh/YWllq2jRSzaxFGAkWoW7AmZHVV 3NhVYjOeeMd6/jG/Z1+HGraX+0V4J0aXT9StZdD8YLZxxw2jTWkXky4IQkAkhlQHgYG70pVklGw6 TfOf/9H+0j9mexi0v4R+F4ljZIodEtYdnl7WAECNlh756fWv47f+Dk7UJH+I3gBo0kEU2n3AmkJZ QZEuVVVAPoorioK2nkfRVp337n6P/wDBuvoT2PwMtb533zBz+7JDI2ZZGJHvt2D8K/Ub/gqzq9xp X7Lvi5IzEkd/FHZ3UspCKkcsi7hz0GE6+1c8U+dvzOmU1yL0Ry3/AASZggk/Z7064t/JnZw+1oGV gFVwAeD3G38frXwh/wAHCUOsa38A7fRdG0+8mu31RCyQIX34G4k4HQIrdemTW1HdkV52STPy/wD+ DfTw8ND+Jerx+I54tHvN5ubWyuiLY3JBZAVYkFu3Az92v7Bv2k/Jj+EHizz7SW6C6DLMFtm2iTED kD6HFLDvlxCl5k4x8+GcX2P/0vwG/aottTi/aA8ayz2b6Wk+qXbRRsm6KQCYhFHHUYY81/Sd/wAG 4/g2907XNV1/XdFNr5xkMWoyoY57t3ZcBm6Njy+g6fnXl53rJfI9/JKnLGXzP67v2l5Z4Pgp45a2 jzcW/h25kXcm5GKwMQNvuAT+Ff5Yf7WdldRfHb4g3N3LcypPemS4a/iEbJJ5j5+ToAw49fl+lXSd qL/rsc1Wf79HzrbyxlwyOF243le4r9pP+CHcGm6l+1rp7X09rbwW8hsYzc3KrJcA/vQQpOcqefwF c0/hZ0Rn7ysf6ON7bvY+BvkdJUTTAGYjfFOgQAkY7HGePWv84P8A4K1+G9c1H9rLxDqsPh++e3ma 4tY7m3tZfKuJEuZieMdgwAx1x7Gt27QPPlP3nY//0/yO/Yg/Yi8XftQfFpfBkWmeIvD2lzunnaoc 2dpaO8gMjbXQhiY1lKgkZIAHQ4/fb4p/8G3ui6d8OrjxF4d8d67/AMJJZxm8jub5opPN2gna0aDC ocE9CcccV451uelkfyW/HL4Sa38CviL4l8AateC51fQ9bmidXjMIZd7cqD94DHUcZryG1u4JZgWK iUSbWXbt5HXA9KT2ZndbHVCWxltUCvK9zHKwmgZNioBjbtOTuzzmqMV6jpOq2jSbD5ZPlsq257ex rFbMZZs7y9l1GwtrSZxJkrLMu0NCNpAVc9d2QPxr/RD/AOCCum6BqH7MPhbVZE0O71ZkMV7NbNFP fuyqsUgm28hwyHcD04HespfGjqpytqf/1P6Jf+Cz/gnSte/Zx8SLpPhmC71hUiNjKlmCtvKgc78A YxgsD7M3vX+fOPhD4xe+WzvPDviea8OtlJmhsmSzIMpbbu28Ljg+nPTrXzk9j1aejP7/AL/gi34I vfBv7PegWmuRyWWoLbRllmBilRCF2IVPIwEAwea0P+C3niqx0P8AZP8AGEkssMhntDb+VLLtGGVl LAZ7c8+hrTC7/eXiZPlsf5xdyNP/ALT1BLC3itV1CWKY21w5jtoldlwVJ9snJ7iv9Fr/AIIfQaIP 2WvCk2l6pY3uoyQGK9Gn3a3McToPLKrgk/wDP1FYYt/vVbubYWT9nL0Ot/4LLaXrvif4C2fhLTLO 4vZdb1SO2jEceQrNG4JJ9AM/TOa/J34Hf8G9ngL4leCbHxd4u8VXWna5c6XFK+naJqfkwJctGGcy syb2ZSSpVQoynvXWpP2KRzp2qtn/1c2b9g21/Ye/bk+GejT6npUPh7V9UheG41KUWv2hYZx5rPK3 y5IAwAex7EV/c94Qt4U+G2lNZSw3UTaPC1s1u/mQSgRqSFYevP518ilbHp+TPrnP/hPt5n8E3/Bb jwb428WftLXt14f0HWE03TL6SRgtrJPay+aSHAA68swOORk8cV80f8Et/g744/4av8Da/qXh7ULO 30e8W41GeSxlWzljjLfKSRwPmHXkk9OK78xleivQ4stdq9/M/wBG3wtcx2/w/tFYh3t9KWFp921U BTqR7ZNfwTf8FcYNR8bftz3VppVs+rtBq6WcNtYW5uPMLlQUIUHk4HWng3/szXl+g8ZJfW0/N/mf 1qf8ErdIv9C+Avh2DU4ZoNRGmol9YTNsMRCqigpjhhtORXyb/wAF5ZdSl/Zo1VLS2u2tvPdr2Gyi d5dwiCRPvAO1cyNn2zXFlMeSkk/5n+Z2ZrUvWb8l+R//1v5q9fnuI7qC3ktpbaaFgsMki7DEUUAF D64xyPU1k2iS297DcSzefdEkCZxjc7fdc/7pOceteBU0qtnv0pr2dkf3rf8ABvpqsGrfBDw7jxBp v9qWt9Pa3GkxTp9pjiKRoN6jkbiknUdvrj9N/wDgqOuqn9mzxzY6Fpt5dajNpRiRrSNiZS24FGwC cEEjOMDOayw7vWb8/wDI6q87UUj+QX/glJ8PvFfhL9qJtS8Uxy+F9Nl1FrO4Oon7KlyQ8sg2buvy q4JH9/HXNf3tXckR+HKfYljuzLoUXlmGTzBIAigjcPx6VzLTGz+X5nXGf+yQt5n+eR/wUm0UXf7e N1NeWsui2l/rJurq9u1MUaNJK7+YGfA2gFR/wE1/bd/wTTk0+b9nD4fLp+sadrqQ+FLSKS9srtbl xNHEiSpJjuGDA56NkUZpLmx9H+uhvl0uXBVl/W5//9f9P/8Ag4C03xX4p8H6ToGiaLqV6fOe7uLi 1t3kgjjjcDy8jjJJBGeuD/drjP8AggV8NNY8IaNc3+q6VeadeX+qNLAb6MxCYMF3sAw4ACkYHfOe QQPn811wlNL+tUfYZdL9/Ufqf0Cftqah9i/Z1+It2zhVtfCd0su3+9Inl8gc/wARP4V/AL+w9rGh Xn7flpc6nc6To9lfeK7nUrF9avhb28Xl3EchiRj1kaISgL1OD9a766X9jTT7/ocVOrbNo+n6n+jF 4TaOP4Z2E1pdJqKnTQtvNbyLMqoUA42+lfwwf8FjbL4g+KP2iPENzF4Dn1PSNNnNraX5sHkmfJSU 3AO35cEvHjnlTz6eXlHu4OK8kdGa1L4t37n5y/sufsaeJ/2gvib4W8I3vhPXtK0W/wBaEOr3JgkS BEc8MZwMoc8gDJ5PGBx/QT4h/wCDcn4VzfCmXUYvFl6vinf/AGtLcrcmaS2+X5YlVvmbbkjcxycc DODXRJJT5jznUfJY/9D8Gf2jv2ftY/Z8+Kvib4Y6zdxXSaTq0trYzp80rRA7oWYZONy4OCcj9K+a J9OlsrlZnlMLSkQKwQohAzgGvCnK7O9tLclu7O21C0urdb0Wt/ahWhtY1Jkusnkjtj1//XXLzJq0 BFldS29xaxwiSNw2HhY9Vx/Pn86wc90Yyd2R21vbuXnmnlhVV/eNGPMZcdwCarpeQaghhtJncKpS CWRcF8ccj1rmm9bCKlzFBE9vaRmc6jOGbcozEoX+8R0HIHNalus8EYgnQ+arFSw/iP8AKoIhfW5/ /9H+WQXsMlvIkLlZYzhgRt/OktpVMWHyXU7l+lfHnQU5bSG+cssRkJcPP5a/OwwAfcnAA/Cte+s7 CRLOW0a4gubePypN/EcwwOCD0xWTk9gMmVlgVoZJY1eRdyMWCK2OQM06NbeRQBIXmxgpjMbD2NPm vJAWrZRbK0sMY64wwzFn1qaaDy3Krcea0mJGK42xkgZUcDjNRfW5pyvlsf/S/lguoWiixDhpAm+Q kfMO9Z8eZrRJLmIxEnDKnzEZJxXw52KGmpUguYdPhnVopQIsyK6Qs/yn0wPrTH1azDq0JZppMebM I84/ujPt39KAUO5ejR7nzLjykkWNd4Cn5Tx39KfZ28lshYxkNKPtAjblYz6L9CKCVF3sLNeyXICT RtHEh+b1JHHBp+mjygzrL5yMCAJeWjPYA+g96DY//9P+VXSYL6Zta025umEd5Is5DygBg3ACjpxj vWhcXLWqLFBGPJgBVwGwyEdMD35/Kvh27bnopXdkZrefPNFeeWI1H3mY5ZgOmBWvpBnN6L9ZVltS wEkT4Vf97HtxXObmzrd9pw1FYLX95dRxAzyo++DB6KO3Y1hxWNr5k0yuFJwWiJwZCT1x60ATyQxW mJo0mkRjwgHmMhPU4q1ciI2ZYqzODuDYyuMc1E3ZWA//1P5TPtaNjdlfLJK5GGx6YrUiu4NrSfZY pZtoUeZkMo/z61+ex2PZi7MmsdYu5lngktI1Xeskcg58orkbQ3fOaYx3Oy3E8ct0yCSREyYo8khQ M9OBVG5ejuRbQnzGwrqVznmqltPFGswZHuZJptyDbuWMYxgD+tVBJuzA6S1fTxus7ybynlUtC4i8 wR46bh6Vz97ZafHdXdhHfiaS48uVLqxgYxuABwdwGDkYOR2/GrcFbQ1hsf/V/lpXTrlppxfyidkj 8ldxO+HHHXsQKlkuTb2kVvNPPOkLCOONnMhUdM18JPY+lctGmWy8DwKV2lF5G5OR7jNI19HCht4k Rjcr5a7xhWPpj8K56q9xmEunqQPHCsYjliUTJyrjnaf7vsKpBlRxDIQ0n39qnJA+lOFrWOiCsi/I +bM3L20slujiNjHwUB4DVAljBb6e1+ZoFW7uxaoq3QkvJiqhsmLqoGeuKoo//9b+Wmxe2SeQoGgm RsPciMqxXGQQ3Q/TNXLGJ0tbhZLyaeK6n+0Bycbz/D044HFfBqfc+oLLacL1oXZncrgruBBGOmfT FS3MBtElRSkhDB5pIxuCjAAOfwAq009gMmWGRTHOkmNvVcfKQeua1IIZGt5ykUMoeLNtLLuyH6nO DgjpVIuF72RTurmaWxs9lpPDOjNG0IwxJ3EBsjseePpXqXw+uL2KS3s1T7Y7XEcaw3knMjPIAYwR zkgnAr6ThqHPnmFX9+P5nz/Es3DI8S1/JL8j/9f89/Dttbm58H2awCGBvEll5lsT8iAXCgpIfTgd fWv7g/2EtGXTfhNpsZjMMd7YxMBAhUJECX6enKjPsK/bvHedsLllPyf6f5HwvgzG1PG1PP8AzPzo /wCCwGrtbaLBHHKbPTriXb5cMpD3NvGwW4Q46Egk9uFr+SfxxavZaPcRaD5l/sMgtYZpC0phjYkm MnqUTOF6nAr9f8FIuHBUH5v82fmXibNS4zkvT8kfjB8dXkuvEyRW0lwsF1r1yEmvnAnHACebj2GS R7V87ah5kczwPKGkXgyDlTg44NfzN4gT5uLsZL++z954Yj/xj+HX91G1pJtwUe5uphKdpVNgIVQA CQf6V2NqXUhzK97aM5aNZ0ClO3T8P/r18JiHZnrWsf/Q/i8N3GFM90g2xt86suVx/sj/AAruZodB 07R9PMJSaW5cSYkia3miLjcqKh69yW614FZnYl7liOPF7c2yNClykEgmXcf9WRyCPevo7TvLFjbN LIslvNZDyXM+64snGN2I+xyDwexry6r1sPlvY19BhmM0Yl3XU6n90sw2KwzwCBWnI+o2utG8SOGK Fo/s93ZgGN3Ck8A8/rXBP4WWaV9eJdzI8EMqpCo2iXkp3IH+fSsrdLNqazujII4PI89W2oVJyQw9 sd/U1ywerNXFuSZ//9H+PC1TVNO1h/scI1XSYbNI5IN4C+ezBTNuxyFy3T2q3rnl6bPplmIp5X15 yhKLt8rrnd+QA9a+fhJcxzlC5sIWYyzXEkM8J8tUCZRh3J54PSoNJvY47jZdykxq5SIoMjj+6fem 9xI9f0M6VFa36rpiW5vYwsuqoux5gpydxPGRxWHcSxrdTR2VwJLBmCb2GyRgO+OeetXA05ml/Xmd FY6XFFFFPEYWEamSKKRg0jn1x75NZk1uQ187Q2x8+EBo2jGW2HOOfXgce9b09zU//9L+P3xvDfS2 emar58GjpakKbGyImDBVxlkPXPOT614nc6cl1Mku+Qt5u6MplTIewx/SjDK0DOaJdMu777fb22mv JZ3CXCs8yAF1AYZBB7HofrX7DfAe90yHwBFvnuraQ6l51teQ2yyOLmKFFk3ZGDjK9P75PNfuvgRU 5eLGu8X+aPzHxSpe14bl5NH7c/8ABJLxM8Px5XX9QihEEKw2C3asUvrl5nVV+QYUJ8jMQB+Pp/bx qMDXXhu2t5ihW702GaU8BN5UNjnsSMGuP6QcOXi6jUXZL9f1PvPCj3vDxUn05v6/A/h6/wCCmWkw 6H+0JeW1xeQwSPFeKyhAVnlW9KsqEc42rke7mvzPuovIknmsmZZGUpHOUBkQH0r+uvC6p7XgfL5/ 3f1Z/GXFsHDiXFQ7TZ//0/xditp7q9v5JL4hif3skh/fDoAMVUh0hfszbtRDXhZltwYXKcEZLNjb 6cA5r/W2K90/zyn/ABGie/N/pgtIlkjZRGPP8sBlyQMHPbPpUVvNiNpbtY3VmI8sriXj2pch0w6n oHhn4i674I1jTvEHw9u5tK1XTCsu+3c2814FwRCgA+9noT69a/qs/YI/4KreEF+HVpo/xvm0eW/0 /ShcSahqBnjuyzKoaKVNpZXQllfIC/LwcYFfz941+HkeJMCs2wi/2ino7duj/T7j+gPCbjmWWSnk GM/hSu4+u7Xz3+8+tn/4KN/sOJq51dD8OftOwSvqGo6w8UUBA3YCMuAw5xgZ4ryj49/8FTf2ZvEX gHXNL8E+KtBj157UGwls9VnUXLhvmSNmj6Bd/XAPGOlfz1lvhPxNjMRQVSnN0uZXfK2krn6Vm/iR l2V5biaNFr2jjKyT1vbTTf8A4J//1Pgz4ofFfxx8T/GXiLWdW1Rtb0m7upm0jT5VE8UFtuypVyN3 IGfx+lcN8OviJr/gXxnZ+KdC1m40aDS51nu9PsWMjXBg+ZAoyAoyACQM496/0up8MYOhw8sjhFcq pqLXS/X8T+Q8t4hxWHxsM0cvf51J/jf8Gz+o39lr/gsp8BY/hTpemfFHxdokXiPTbZbF49Ut76aJ ZdqMYjIsZO0biORgFfSvd5f+CrP7FU8qzSXPgm4+0zN5Utt4ev8AMs4wCTMYNpHPLE46c1/Jmd+E vE2XY+vUwkX7Pm0cU7Weu69f03P6Tw3iZkGZUY8skpys+V73tZq3y/pHSS/8FXv2QfCdhdXMeq+E tEnaETNZwpcSG+TPJURqST/s471+Ff8AwUJ/bhHxr1pbz4deJoNG8N3dx9ot7fSTKDrAePy2WZGw 4UKzLg8AHucGvV4G8Mc4hxJh8yzOnJ0U9W07b9/kfJ+I/F+ExvD/APZWEqR9ro2r6pW2a9Gn8z8b fEd3Hql5JrAtke6nlUXKNFlsR8I/fPY+tfav7EH7aOgfsn+Pl8ReLdEm1Kxmufsd/HLafb5byCVY T5sLcLGyGEcZ9c9eP6zzjKp5rw5Xyuk7SnDlT/4Y/BuG8yjkud0MxmrqEm/vTX6n/9X9xdK/4LZf spDSbbUrF7VVMSG8hTQbmC+td6jAdCy5bthQ2Mdaq6x/wW1/ZduNBvhILG9iu2NsLK80K486ZW+6 xHzBen8RIr94fgfxbLHc7pS0kl/Tva3d7La5+d5h4q5BUpKEJ3XLvr6PS115Le3Q/m4/bb+LHgH4 4fEPU/E3w+0vStE0+HUzcxQ6SHhguvMUMcg/KWYYyE4GzHufmb4P/HDWPgn8RNL8aWtvdaymkGN2 0/aHgt0WZWkkUcZfHYnn1HUf1vw/kWKp8F0smzHSfI4u+6Tv572d7dNuh/POEzqGB4olm+Gd1CfM ul7Pb06bbH9TXwq/4Lq/s86b4Aht/Eenaymqq3lW08vh2UEFolMRliDcDjlhkcV+KX7f37WHg79p 3xF4fuvDF3p9rbW+sXGqwX+maRPp8ExnCtcRyPMFdwAsceSP4SBkV+J8GeEedcOcXPN6kf8AZ1Ju 946Lfvf009T9G438RMu4mwlPD0H7yd9mtdu36n0L/wAE8/8Agq1p/wCzposvhv4h2m3RNPnaOGWz 0JpwPK8tPPwoAYMqqcbhtx6cV9cftX/8Fj/gz8cvhj4j8N+CrWW8vrmOGQ3s+gSRPYEMUj3BXbjd tOcdAc1txR4L5rjeNFnuUx/cuUZN80V1u9JS5tNvMufivDFcNrJsfbn5OVuz6aX0Vtd/I//W/MLV tQ+3Sahdy3Mc+n67fPqM0MTjJduCMZyvf5TjGTXnBMb+JXuXtZtPs2t1hXT40DxNtUKsxPQsxXJ+ p9q/1wwVH2WHhSXRJfdofwDKd5PzJL1I47+3tso8UiNIpY4c7SuFx75P5VbbVdXtbjzYIVjt5/8A Rjc28SosW0fdwBgZAwe5z9a6OX3jobXs2g0vXI7a6cXweXnCJ0x/jn3r6g/Zy/af1z9nX4iWHjXw 3eXv9h2d5Ddax4ftgVhbayFmWMZAJAHRTkjPvXznEuS4bPcuq5ZilpNWvbZ9H8n/AJXPo+H85r5J jKWYUN4PVd11XzX3M/o08N/8F6vhMNA02G8ttRk1Boo4zFqfh0yyEnAJJHXaeM98V8//ALV//BYn 4ffF/wAFQ+G/Cenvd659qWRLu58NmCG3EWW2GVjkFm2jG3GM561/K2C8Ds7o5knKK9lzb3VuW/q3 t5XP2vN/E/J8Vk9SFGb9q1dKzvd7La2j38j/1/pP9kf/AILIWn7PXh/WNP8AihomoT2l4Wm0+3Mk eoSRMzfMsRVQdnQ/MBjoOKr/ALan/BWr4PftIfDXXtE0TTri91KSBZY0n8KC8jsBKqxKXlwNnzlQ O43H0r+0ML4OZllXGVHNcBZ4eMk73S06+7e/3X8rn8rZx4gVM44W/sPERvPltc/CXS/sKB7C4M19 HBZs73L7YeQPlTgfWsV7rzrsWoeOCCWNooCjkEtg4UAc5Nf1DyNI/Lk7q5t3nhq/8P6davciEmW3 jk3Q3InRS4ycHOeDntWNe3aNai2klUSkb05xggcGqULou90h/hjxLrnhTWdD8UaZIizWmoBR+88t L4RMrPEXHT+E59cV/Sj+zt/wXFt/h74GtPDPxF8KX9vfWUCJJqsTQ3VrNEgGNqBMZyGzyOD25r8l 8WeAq/G2U0sPhGva05XttdO3VtLS3Xu9ej/SeAOMo8K4mr9Y/gzSv6rbTz2bP//Q/UvWf+C63gvx Vor2WlWPiSze6eRree08PJqNttG4DheT6EAHvX8/fx7+LNn8Tfig3xK8rWJtZu7kS2FnaMlhfRwq 5MbTRnb5fzFiScfe71/c/hr4WY3g7G1cRjErSjbdSu3dbLol+a8z+VuLuNZcSYyliE/gd0kmrddH vd/ofrL+yn/wWe1D4G6FeeFPiFo+taxa2VtDZab/AGW0equGZVJ+/wCXt53ALk8Y5NcP+21/wUvt f2nvDB0bTvDGraJaxRyRQy65DHA7m4aIb2RQzAKEHGcc9eprxl4KPC8Yf27Ql+45+a3X7u/z1t0u exmvibic0yH+zamlWyV/Ts/RdVpfc+Bf2Y/2rfiB+y14pttY0vXdX1fQpr+No7O28wz2ZLFpRGgJ AVsnIA6gV+6sP/Bf3QYtLElx4F8eSX1taoGupdG08W28AK0hYyBiOp5Xmu3jrwe/1nzlZpl7UFL4 r3Vn30T/AM7vsZ8PeJVXKMsWXYm7cdmtbrRW/rp+N9P+C/Pw8BdrvQvE97HBbJMog0mxgN3Ky5aN tzDbg8ZGfbNeYfE3/gut4M8ZfD3XdL03wt4g0PVtZtLnT99vZQ3jxRlMK5PygAnKnDEjmvicJ4C5 nDG0p10uRSV9Vtf+v8j1cf4rU6mBq0aE2qkotJ2eja0Z/9H88fHvxQ1Xxv478Q6zK0tvYXd+jWlv LKJ2vEaJD5jrjC8kgAZwFHPAx7x+zB+114x/Zd8Y2eq6Ba63eaSl4LlzYXjedbZ27o44cco/zAjk DIOOK/03zrhXB5tw5Lh6ovd5FFabNLT/ACfkfxLwjxHi8gxkcxg9U/e13XX/ADP3c0L/AIOAfDV7 o9nbapoviLSrm2t1jv5LjQ49QETgFdzOACMkZ5WtvT/+C+nw9aJ4E0zxPqMllE0s9zb+HYpLWUdN zllUoMkDIBr+bKn0f82hVtSV10akv1a/I/acP4v4F3nXdvk3+SZ5t8TP+C4nhbxt4O8VeHdP0nxD peo6tokkGnG38Ox3VxK7j5F4A2KTgM27gGv59/GPiYeJ/GuseML+e41O91i7kvDdX8nmG03gYjVO ijOeOSOmTiv1vwq8NcRwXVxFXHR96astU9Plfsup+c8d8Yw4nxlCrh5e5BPTVa38+57T+yp+1r46 /ZQ8aQ+KtCm1S+0Z9SN3qumWWob5mT/nnFGRtwec7t3b0r92LT/gv54LudCs1n8M+JTq7Wn78T6U gNu6gBm3KhVuntXjeIvg4+Jc3/tXLkve+JbWevordd73bPouGPEyOWZZHL8dduOz3uv89D//0v1S /wCH+Hgm20ebUH0LxYhEOwF9EtHaaXjlclV2DnknPt0rhvir/wAFvfDHjLwZrWg6Jo/ihbm60ITC 6OiRoJpHQPGAgXKKWA+fdyBxkV/XcfAnG89ClKSVNSvK2/S/4dmz8Bl4vUKNCrSppuo1p28j+ePx v8TfGfxB8Wa34wuL2W2GqztqLQTSfapvMZFVnkZlA4CABcYGOOK93/ZG/a78YfsveM4td0qfULnT rhRLdRf2t9kBuBKhLYKkHcu/5eOw5r9z4h4QwuecJVOH1Cy9zl6cvK1Z312SsfkvDHFGLyHPv7V5 r35ubzT/AOCfvRH/AMF8NF0/T4E8QeG/EUF9brE8stvp8F1alCuDKGzkrnrkfrXyn+1L/wAFZvDn 7Q3hN9L8P2WsWGsaZHNNbXV9piQRu0kZCMTtUqAQCF57nrX45gfBLFUqqVeSaTV99UunXf5n6fiP FnDyoz9jFqTul5Xvr02L37LH/BZq4/Zq8F2Hh/4k2uranpstsrWF1BbR3MRlIGY8yEYIAXIznrj2 8q/bK/4Ke6R+0Hpem634X07W5b5NSluYJTZQWUNqrhNnzgGTgA9Dg5HXqPQyfwexWR5l9eUk4puy 16qz6anmZ34l4fPMD9TlGzaV/VO/f5H/0/tn4Df8Fz7f4ZeENL8JeKtFvri9toIx/wATArdPIm0I ViJTJwwOC3NfQcv/AAcB+CLSS5mi8Ma/qFtEhiaKw0mB4LeRf4WO8Dd6Y68V/Y2O8CMZj8ZLFynr 0s9PK91c/nqj4xUcNglgYL3UrO6d/PrZfifJn7U3/BYjwj+0l4Av/CVhoOr2Es9v9juf7Y0y3hCN NG6BPMBIBwThVXpznPX+f0T3dvdaqkl3Dcm4ut0UkcCxnywBhSo4zwcn3r958N+F3wpkrymUrtSc ttr2VvPY/COLM8/t3PHmNrc2nrZNFS6vbuO5E6PtxEYgnkoUAbg4BHX3FfXH7D/7U3jD9ljx1c+I tL1DV20CTUoIDYQTyfvs+WxRUwVOC7KS/AGPSvd4y4ew3EvDNfJcTFPnTs30l9l7OzT1DhfOsRkH E9HN8O2uW1/OPVfPsf0LRf8ABfTwMLWWC/8ADnia31PT0hgkK6NaOJGZcFixdTjI9OQRjNXbj/gv P4CsvstlceFNQnnvYjJBLLoKwSSNjgbGwT/vKCK/lheAub3UW0vO/bZ/P5n7zLxgwXNK17dNP62P /9T9UPEn/Bcn4ZeJvCPiPSbjQ77TdQm0w28ULaDmXe54G5V49uTxzX81HxY+Ieu/GD4h+KPH3iDU J7SDUtYnGgaar/Jb2bkBG28lWIUdTnv6Af6G+Gnh3U4Ir4itjJKUqnKlZPRRvdfO6+4/jXxC42p8 YQw0aKajTvdO2rdvysz6C/ZI/ar8Rfsz/E/Tde0G+updMF9b3Go6QsRNtEkIb52JbZhztB+Vjy3b p/QWn/BfT4YQaRp0N9FdWOtW5FvqIuNCa+tIyv3mRk5cjg9B1r5rjzwdrcQZ9VzzKbR9pbni9G5L TmV9Nkr6r0vv9Hw14orK8qp5Xj7v2d+Vrt2fXq7Erf8ABfP4HzWYltZZdSn8/bO83hK4h2joMkgK vPTOa53xx/wXJ+C/jfwXreh6ZLeQa1e6TJCTZ+HdhtsjGcuyjGfQk/1+cp/R6ziVSEvrFOytf4v8 j1ZeM2F9lOHspaqy2/zP5rfj78Q5fjD8S5vF1lq+ryeHbO4lTR4biIacsyFhh2iVjgthSQSfuj0F eTjxvLpt99nV3aX7M0fzw+bGysCp68Z61/V+U4OngsFTwdNWjTSivRJJfkfz3iMRKtialWerk2/v dz//1fyVvETWL60nEKO8BynyjcvJJ5p93q2q2QKaehjWV/JcRpvZh0HFf7Hxi1E/zanO8mjdhmsZ Ftbi8tk+0WyiS5nddrTMAASw4HtVnQdbSLxHaatpQfSmgMiROjAtISpGMHj5iB6fqaU1eLRtTk0k f0u/skf8Fivhb8M/hzpHhb4q2mpWOp6YiaWdZh0b7dahY1A3u6HPOMFQDnr619WL/wAF6P2YY5o7 SLVLu4tAfLtwnh+4jnbBPLZGAPx4r+J+JPAvifM84qYvDxVrtp3Vm733umtfI/q+h4y5Hhcpp4Jp t8qT0aa0ttbWy8z5b/bF/wCCu37Pvx6+GWpeAvD9jFeateKyQRy6FJG6BonUTGU/xKzBuB/COlfz JXGmm3uNUdJZLiz+VLWaaX98W25A2nsMHkYziv6K8KuGcdwvwtHKcwf7xTlK2/KnbTt0b07n8+8a 5zh884jlmWFXuyUV6tK1/wCux//W/ImzubSZN6XW+4sboxSEH/j2dMFNjZ5Pv2r7r/Y1/bC8cfs6 fE7SfEreI9Q/sL7SyanpvkCaAwFFC8LjkMMlufvGv9WeNuGsJxRw7icmxEVzTT5W1tK3uy+TP4Q4 Xz/FcO5vRzTDt8qdpK+8b6r5n9Jel/8ABeD9mK+8P6fDqbK+twqlvqKXmkTx4ZFw0gbbhgSOoFbs H/Bbn9lSTTbmSd9FtoRbGQD+y7h5ZznaCAqk/pX8lLwG4ohFylHZ7KS2XbV7n7t/xFzJ5VbR0T1u 0+vfToUNd/4LVfsx6j4R1nTdFvoYNT1HR5LDS5/7PubKLzXQjALhCMEjBxX8v/7Svx98VfEz4g6t r+j+JZru0umeKaG+mjvdNjjyMRwRY4YFWJLHJ34yeK/W/CTwyxnCeZYnMM7ilUqJKOzsrtyV1fd8 vVbbH534l8fUuKqGFw2XtqnTbb31eii7eSv3tfc6f9in9r/xt+zT8S7DxHdeIruLw+92Zda8P6db ube4gQriQRAEBguRhRztH1H9NPhj/guD+zBr3h+1/taXTzO1rlBrGk3du90VO3BUKwDfXA4614Hi Z4R47O+Jamc5HC1OcVzWsryV03vrpyrZHucH+J1DLMhp5TmTvODfK3r7vbbTr1P/1/3+n/4LIfso wy22n6hDoMSXFsDBC1hIZsuOCFC52nPBANZHi7/gs/8Asv2/gnVLXQdT0+21CS1k0u0BgvbeOF5I 2HmAiMYA5xX9ULwI4mrOlSqRaUndttWVu+uml/yPw2l4xZRhaFZxacrWS/Xbv/w5/Kf+1J+1L4x+ MXxBvdR0rxPezeGHvJLjTomInh3kgu0kcgzhjuVQPujHtj5c0y4uZZfMeRFlSTguMJGPUDtX9n8P 5JhMjy6ll2BjanCEUreSt09NfM/lmrj8RmOPq4zFu85Sk23vq7n75/8ABNz/AIKL/B39n6NPAvxa t7JYbW4W607Ur+0AjRZAVbMq7sEBEbJHf04H7Xz/APBZb9kLT44xa+K9CkhdfNK297LdSH/tmi7h +Ir+VPFHwh4iz3iLEZpltJypTblda3e70Wq2tt9/X+leE/FbKMpyHD5Ni5e/CKi+lrWS9e+/3HBf GP8A4K0fsfeMPhrq2k22qeFNb1bWtLnt7exvI7mNIyyFSJhJGMcEnHXiv43vjzr2neLvit4yv/Bl 6H0t7w3VpYLFssoFlCyMYXZQdifOuPav1vwE4UzLhrI8Q8xTTqyTSfaKevzbsvQ/IvEzO8JnefU6 uE+GEFF+t3+lj//Q/HuYslskYwZVb53U9apiXfcxHczPFgo7dF9QP896/wBroK0T/NyUktC79gh1 KeWKX9zPIn7uTGVGO9UhHFpz/ZWnjmuGkKKI3+ZAMZLLWsFfVj50F8XhgMpyF6bBxvxVGwQmT7Vb TSGR4DJJaOgCoV5z65wDxV8is1Yy5/fNy01W7C2/nxrG85BEQc52g5VsjowIDD0Kg1+5f/BMD/gp dqv7PupyeD/i54kiuPBYeO205NTkZN679u1W5GVXaeegzk4wB+WeKvBNPjThStgaMV9Zh71N+a3X X4o3XrbXQ+94C4rlwrn0MVNv2E9Jry6P1T/C5//R/oY/aP8A+CgX7FXjz4W3VvrXivwHdpqdlIVS 48SQvNCWQgo4yGQ5Jwp5z09/4y/EXizwzp3xx8VeMo47y58G2XjSWbTIzN9plltIyBEylTygwHwO o7ZyK/098F+F844b4SxGW5tFwlKcnFPdRcUr/Np6Oz0v1P4o4+z7Ls44qp4/L7ShaN2tm02/ysf1 7fsY/wDBQ39j2f4UaFftN4X8M6vKirf2UeoCG7hdY1ySjDdzzzj06YNfZqf8FNP2UU3wXHjWygYJ mCG81e3gjmU5BI3HPr2r+T+IvCLi+vn1Rxw8m097N83XSyd128j+h4eKPDayhUY1k3y9LK2ltbta rqflP/wUk/aU/Y7+MPwz8Q3Xh6TRdU1aTRrp49U06e2SWG6SD5Inc4ZizAe2Ccc81/Ixb3Be6Mss YjEP7lm3bgSoxuz7jBr+t/AjKMzyjhmeDzNPmi0lf57el0fyJxjjaGY8TVsXh1aEmn+LuDrY3P72 ABSwKecoK+UQchl9CCM8elfu/wD8Eq/+Cm/iP4T+ILb4Z/F7VbX+wzbxwWU99eNaJNFCoG7OBETt BPGGIXof4fW8XuCKPGHClfD8t60Peh+F/wAk9uh9p4ZcV/6t8UxliJ2oSjyy1t3a/Nq3n5H/0v6n b/8Abe/Yw8aaXHqOv674Su/IjVz9r121aaIsMEbCwbb37gcc1ylj+13+wFa3trBaax4RguJbpILc R3sEhDuPl2bW71+9UeAOMKNJ0Yc0Ur6K5+a4bjnhtJThZt/fdfO5z3x3/by/Z30H4f6gfAnjXT01 iW4+y/ZYruKS8UbGDbI0Zm28cnHSv5J9Z/bD8SePv2hLTUfiLZWeseBdB8Ybls5rmXypLdZ/LR32 5UYVgSSABggBa/ZPBnwyxlDD5jjcwjas4tQ6a20ve3W/+Z+LeLnGlLMuJMqjhaj+rU2nJaNNqSv3 6Wt+R/Wl+zL+2z+x5b/DrSriz1bw54f1JbeJLu2sLy2e4g8tdm0rkHOVJAA6fhX1CP25f2bNV3Rr 420mW3I2slxfwRMyA85UtgdO/pX4fm3htxTWzWripQb96Wrvffp6H7rLxAyKGXRwlSVnZWWlvTfr 81Zn86P/AAWR1z9m/wAb+EdZ8S/C68tNd8QaZLbaqE06S3mETyz/AGeQAx5JVVcOSeQRjPOD/M/f pPKnmJsTKh1EZzsJ6j8K/vbwVwuOwvA1HD5hf2sZNa76JWP4b4tnSqcVY+vQSVOdTmjbazUT/9P8 XtD1fXtI1Cz1zSpUtb/THEkN3GNkyPGwdGU9iGUEehFf1V/8EoP+CtP2zT0+GP7RHiC2hjgWOx0L xNcaoohLJ9+OUH7rAK3PAOOlf6keOPANLizhCWIoQTxVF80e71/r5XP4m8K+NK3DudQwFaT+rVVZ rs7b9v8Ag2P238YfGP8AZB8Y3FvrGqa9o2pajeqhQ+ZaMZlBzuJLkEH161i6f8SP2NbK6s7uz1Xw /bzQTFVnW6s4YIm7bvmAOOtfxHh+FeM6eH+qxUlBK1uh/TkOKeGPautFrm38z5u/bP8A2/Phb8JP hRrt/wDDbxZputaja6dOYoLNxNHJLGoWONTGxAILKeSPw61/GZ47/ap+I3xK+IMfxM1HV5NO8R2t 1Jf6NPZ3kzR2qs+4JMxYsffaQBgcDFf0/wCA/htHBZTiMwzan+8qXjZ221X/AAfV+R/OfiVx/LMe LqVHL5/u8PytPXVu0tfy9PVn9WX/AAS+/wCCn3hj4o+BIvAvxw8T2+jaz4diWxjW4vo5GnTaBG6g sMqcHGM9K/SvxX4o/Yv8Rag2ra7r3hK/ubrass7CByo9X5JGema/BeLvD7P+G+LsZSyiDVNybTXV P/Pf5n7llfGnDme5VQxONkm+Vb9Gt9e6vb5aH//U/qx8NeJ/2OPD99JeaD4k8P6XJFIEiKW8QJIP yspPJHHUGvi3/gpD+3vofwl+Gl0vwg8XR6vrC6fiK2s5GJklY+WpYRknau4MQcDCnJHBr+iuE+A8 +z/i3B08zg3DnV2+y1PxTjrjTK8r4OxUMrklOSSj/wBvNR/Jn8iur/tUfGC/+Kmn/F2TXrjT/HVp fxStcwTyICkb5XaASMgHnHXHTpX9g3/BOz/gqJ8Nfj78NrPTfin4mhsvG1hp4stRs554/MvSFKLI UJB+YI3HXg5Ff0L45+Ff13KMPmOTU71MOkvO2nVfd0V7H594UceLAxnkuaVP3c17v+Xr+O59P+M7 H9jDxc2qvf6hpKXt8TPJe+RHcLbHlhnIbZn/AOtX5NeA/wDgoV8Pf2cf2o9X+Fvh3xQmr/De7uIr C/Y3i2EEVwjNny1Y+XnYVQBRyQvPWvwnIfD/AIk4lwlfA4ulKXJBtaXtb+lY/QMfxtkeTZ3QqYOS VOUlza211SsvRu5+u/x/8b/sn/Gz4LX8virxBpGq6ZPojamkdxarceUwi3rIH+6ShAIwTyv0r+Az 9rnwr4K8M/Hnxkvw4mhfw0iw3HmRwPbm9a4RZo3EfQFVYqxH3iK/oL6NOW51lf1zA5hFqEdr7b9P mfhHjrmGV47PsHXyy15Qbk0t7WWv3o//1fiT/gnprXw1sPjRp1h8Vlhbw7q6m6Mt1cLBErRbdsYY kAEsFAXvuNf3PeCPit+zF8NvhNaa74b8a6Ho2nWGgh1jiRXZ5XjBUYXkkkAYHpxmv76+kvw5nWaZ /g/qkXKjJLbp01+65/MXg9xblWRcHV1VdqsXK/npdfn19D+Wb/gpd/wU4+IXirxB4k+FXw+uri+8 HX2lG11PUJNRltYbxJ1ZSwUYIAD4wp5yO3Nfz7WBvbhd+pLEZ5ZiziNt2cnjJPU1/RnhJwhh+E+E qFGmrTqJSlp1V7f5/M/mnPeIcRxVm1bOcS/ik0l2SbRdu4oY5UgDBsDeyqM7PY1Cw85WA6A4Ht71 +ppa2PMk7s14bCMQ+b8ly6Jkxq2APx/Oslnia5KoixIp+ZEO7mtzKO7P/9b8IMYlkycLzg4ySRVV 5iz7CucD8q/3gP8ALSUmnYc0Mu2PZ0znBHb/AD/OjzljdY8eYkoKs2fuEe341cY33MthtzG6xgov OM8dhVOFSrh5F9snrWiilsNNrY0hErkA8AjjjAFUlSIXDRoRhPl49aj2ZsndH//X/BNEeFi3lAyT ZQShNwTAJy1LeQCySzlZpS9wCHkBAgmIOMKO2Oa/3j5Gf5b7bECTwIWaXcGXBTaN241aWXzixOwl R+5B649DUtOO5XNIpNDi4SOWZfOIDsoOQufStOKRFLR7QR1Lkd6RPqT3EsBVEXBUIcswwxPHQfn+ lYEitK7AAn0HpQB//9D8AWj+zlZR99RjGcD8aZIyMT5TfM3MiZ71/vAf5a395pkiiONiZMAFflHq aorItzvIAURsULBe4oHdCx2pMgdW3MD93vWm1kXUTu/loRtIPFAJp7GZ5auslqJXXzfk85iWVB6k c/5FW7eIeUYmUs0fytKBgOB0IFA9j//R/n4a3Z54vLU5UFjIRjYOn9a6RbWYWv8Ar/PTyvNSUfxZ 9R2wePwr/eA/y5cm9Dny87QTRSYR9+YpVHSpbW0ASMvOzOo+Z2HBNBInmbZtjZ2HjfjjipWuVk3R KCcLwuMk4oAo2sJZ2kUtG6H5VYdcda2NryY3bQO5HWgzc+iP/9L8EDabRmFnHUZHQmq8oaJwqsGY j5h6V/vAf5Zc7sDWTXC+ajhHQ/MuMl/Wk2qjGGQElhnkfLxSezEpO+o9fKiVvM25zkN3UUpitplE iT/OMENjKuMc1lHfQ05ly3FRmYkS4UA4UjuB61zfjW3SbwvquwMHCoUCkqGwSTn24z+ArDEL/Z5v yZthJc2JprzX5n//0/4vNU1FYLySK+tA93OW3SnkKQcg8dyMfTNcveo0spKbiCgIyOFx2r9d43XN xPj/APr7P/0pnyvD6tlGHX9yP5FRJkVfIkU7/umUnJHpira2UgXzWBeMjIkXg4+lfH8iPaH2avHI JEw7xv8AJuGeK9/+CXxz8f8AwQ8d6D498Ba1fafr+h3i3MIhuvJiKhgWTb0Ocf8A6q87G0I16boT Wj0Z14LFVMHiI4mn8Udf6/U/0mv+CPP/AAV58Gftw/BpPCHxA13SPDvj7wzpa6drVrct5a3JKrGZ AzYBU9xwAQfoP0H0D9nT4LeCviLrnxQ8MeIvC9rrOtXa6hfXaXMUbTbFwMkMeo4PBzx6DHz0KOIp 0Hl8PhvZ/hb79T6vEY/DRzOnmcWuacNOtr7r5M//1Ptj/gtL/wAFbL74BWh+CnhJtI13WPEVt50k 8caX62Vq0kkEhY5JUllGC6EbS2Dycfnt/wAELfgN+zD8evF+t/EH4i+ItLb4i2WqS3c/h+6jhsbf R83BeOVeTuDho2BG0Aggdq9fOKMsPw7DL6S992b8r/8AA/MrhyUJcSV80xDtFXUfPlt/X3n9zXg3 WPAvg7QbPRLHxNoC6ZpNsvkyrqcTKVjGAOD6AV/n+f8AByV4x0/xX+1V4WXRbjTNU0618HTtNcWd yrusn225UK5BI52RlV6/MTUcMUp4alWjJfYa/IninE08Xi6U4tXc1+TP2W/4NwPjf8Grb4KaT4Uu PFthpHim1ssatYX8wj82dZmUuDnBAV091wQe2ftb/gvJ8VvCNv8AsafErTdO8RaNe3beGWRZLS+W aVw1xEWHB6AfN7Y7cZ8/hDCV6Wf1ak4+65zs/KzOrxKr0Z8O0FCV5clPTz5lc/zE9WkD31hdWt9J dy7FMrsdiMsu0kH2XoM9lr+wr/ggV+y3+yl8RdFs/HfibWdAn+IVneqbu1v5ERtLkjIAePJywJwQ x4B45K8rieNWu3Spbymk/S528C1MNh8T7fEr4Kbcf8Wi/K5//9X+2nwlr3gbwnotr4eHizw8trp8 KwoY9Uifci8IWw3HAAz7V+BH/BcH9hz4IftBfBrWviPZ+KtCtPH/AIZ0SW5tL1dRhiiuI4UknMW7 dxnZw3HJxxkGvRyTCYnBpU4xdnp8v6sb8UVYVo1MZJ6xTl8/6uf53P8AbPiL4X+PrPxV4R1lbbX/ AA1fH7Fd6VemPzCIgux5B1wTjPqM1/f5/wAEM/8AgsjpP7SHw3g+EPxj1mx0P4g+GI4tLuLm4thH 9uSNFjEjnhCSSAwQYPJCjkDz81wMp4yNSGsotxfmv+H/ADNeHsRHE0HhXoqkbpPR3tf77H6Y/tR/ 8E+/2V/2nPE6+MfGE/g+W4vrGNLmRYrYST7RlXBJGDjHOM+9eMfC7/glb+xb8M/E9p4t8HT6La6v puCSl7HHA8q8KxAfaD04x1UHqBTr4TFuna2i0PUweLoYOrHlkrpnpn7en7cfhj9hn4EX+tW+sabq stvYLY2llBeRX00zFH8tAmc4zHknoO+BzX+aj+3n+2N4j/bE+Jw8e6pZWejXTzlbR7CMIWhRmAz8 o3bgSNzdcDsMV9DhaX1PJ3CovfqNW8lFnw+aOpiuIZVF8EPxbVtO3n6H/9b+MHV4rUWttdQzbeB5 0W8GVn5B49K56J5WcGELu3723HGQOgr0LWOSDs0jpFmsb2NItQ8pdn3RKM+YePlFdNpt7/ZamGEi 3SRQqeX1UduKCpP37H9Jn/BBv9n/APZt+P3iJdX+LfiDT/8AhL9Aup7v+wdegjjWy2XIWKSNj2wq MMYOQcnGK/0E/hVc/D74f+G9N8Jab4l0ZdM02AtF/p8ahlYkgrg8cdhXxlHD46tn1adVPlTSivLp 9+/q9j9ElUw1Hh6hh6D1knJ+t0n9z09EfxAf8HP3xL0PxB8Uvht4a0jVrDUrmDT9QuEgtrpLiVY/ tMW3IXpny3I9ccV9Q/8ABsR+0F8LtN0DW/Bes+I7Pw/4utoZJbrSr1DaBw05CvuPBADRgjg4HGcV 9fxPQqTw+Fp01qlC/l/V0fEcH1adHF42dV2UnNLz1/4DP//X/pl/4K4fEbwO37IfxZjg8XaGxufA mphtuoIAHW3LR4IPU7MY6nI9s/yRf8EXf+CvOs/s3fEkfCD4n6q9t8J/FF+/9j6tdKbl9GmuXCKX /i8pjgkNynJ5Gdvo1MJ7TJoxmveUrr5I9HKasVnU6U5e5NNfN7fij+zn44fDj9nT9sr4ZafB4p8V 6Lf6VdxR6lFdRXULPkxjBHzYPB4IPSvhDRf+CR37CmmNFNZnwjdaoZVm869tbaQAhs7ggYY5/H3r z8XhsRiMNCMtIo7aUaeDxLcrXT19Ufe0d38Nv2U/hjcN4V8YeENJ03QbBpVtYbqK0iWOKHCoIQTg BUH1xj0Ffwff8FWv+Cvvjb9rvxo/gzTbvTLHwz4T8Vh9NS2ZrGa6kt43iWZ8ANtGflGAckkgHgen w/g45fh6uIq9FaPm3qfLcY5zWxOZUcHR+J2nLsoptW/A/bb/AIIaf8FkLX4kadZfs3fHHXbDS/FG kwR2Oh6xMiyJ4giiXBIkyF80KEJAHzAMRzlR+4f7Uv7Gv7KP7U+paL4v8b6p4Uvr2CIeVLLNCq3I I+bcNwOSAoIIOcc8gV4mEVaOIrUaa2f4PXT8j6pSjPD0sQn0t81/X3H/0P6CPBf/AAS8/Yp8DeJt L8U+Gn8MaZqmnOJI3snijhZhgqTh9vBA9cEA9QDXrH7X/wC1t4S/Yp+CGr+JNJ8S6NenQdNEZ06L UIpJ51RSNiIQRnAbI9Bjgc1rQw9ariYKSPbzvNJRyxdUtvyP83f/AIKAft0+Iv2zviNL4q1fTook jKwwXUluIXVIpnkTy2GA2S3LFR3FfGvgvxtrHhDWdG1rS3uE1HRtTS+sbm1ma2lVxlSN6kdj+YHF dWZ+zrV3CHw7fI+Yyz2lJ80/i3/4Y/vs/wCCIn/BZaP46+HIvgz8ZvE9ppXiLw8gtLOTUFjSWZY1 CKWZiMNwOmd2Ce+0fud41+DfwC8V/E3T/jLL4r8Px+I4rWKKG4e4jw4T5s9RjPqBn36Y8vCUKtKM sLD0+R9tjcRh5SpZjT0Ult2a0aPzC/4Kpf8ABUqw/Y4+H76P4X1PRfEk+uWkul6JawuNSiedShyQ OcDJGAcYz1zkf56X7QHxT8QfH74jax8U/Es1mdf1zULjU7u3s4DZ20HmHKxJk/wqAO/IxXsVKf1L LoYT7UvefpfT7359PM+M+sTxdSdSW0ZNLc//0f450uThmRdpGdyE5IIqJle5PmMpIHCr61MVZWMo ytoWfIZY1IADEYI4JFPgMCuGTYuwYOaUo63Ju73N1Ls25TdIu1x91SCP/rV+i/8AwTg/b7+JH7EP xc0bXPDes6heeF9W1CKw1vRriVprR/On+UxL0V1ySCcA5IJ5BXnxdD21H2f9X6Hs5XinhMXGpd8u zt1XX+u9j/SP+DH7TfwR/bD+BkKaz4s0Zx4j8PKNUsZtQjR4zKm10kVWyjA7gQcH0xVrwenwN/Zv 8DatH4T8YeEtMsdPjN0ptrpF8vYMEuq8cKCeeTj6VlRUq2GpwfT+v0PQxdWnl+MrUlPf8v6Z/9L5 H/4K3/8ABXDxh+0v4g1n4S+Fbazk8LaF4iYQeIPs6pJdiyleMFG5C7iM54OHPAJOPv3/AIIVf8Fd dU0G20r9m74zawbTSopksNB1i7u4ycswKQfOc4HQMo4DqOB04eIKSjVpzwy+C1/Pv+f4H1eSVqbj Vw2Idozi7eTWq/I/pc+PPwS/ZP8A2nLO01Dx74h0PWoLn541u7q3mWXcM4aJwSO/Q/nxXzl4d/4J 9/sEeENTtNX0aHwDa3FjdpLHObWxD2zIykbF65yByckcc1tVp18RS5ZRvZaeh52V1aGHnKrT3u/v uz3D9oP9pj4Xfsi/A3xP4p8NeNtCCeE/DdxqFvb/AGhXjJiXcqBDlSzfdVeMnA4yK/zsv+Ch/wDw UP8AHv7cPjua98Z3Eg0oW8ltpMLNtitkMpceWgABLjksQOvHauzK6UcBl1TmVpzbil5df+AeXndW pj8fTlH4Y2cn520/4Pz6n5w/b3iQo22UrD5ERk52ADAP4VjTPvhw7tlScnoTmuGUdLItNpWP/9P+ O6ELboSm52LZIPetu1dp1LKrMqDLlTt2/jXCotnTTkrn1V+y3+1Z8SP2XPid4c+JPgLXdT03UdK1 FI7iGOR5rC4tmdd8M1uoxJH8u5lbjIB4KqR/pLfsI/8ABQ/4OfthfAfRtV8SeNdFt9V1LRUs9Y0y 8lS3UEx7JEdCd4zyRn1P0rFUVTr+3itXofQYet9Yy6eEm/g96O/W1/JL82yrrH7HX/BPDxTrepat e2Pge51q9kddQnFxb+dO7cEjIyOlem/CH4QfsnfAmeW78Iar4R0V42K2zxPBBzjA/wBUBuOFHXrj 2rrbs0jzeb3D8M/+Cy3/AAV38R/B4P8ABL4M+LdP1S81TQ2u7uaxSK9m0aJ98fKc4duq7+3QEEV8 h/8ABEGw/ZO+It3qXjr4neI1l+JlzqjPqp1y4t4zYM0iuxjUjcMsGZmxk+YM9AA6zVrhCV2f/9T+ zvw38avgV4f0QaZY/Ejw35VlaLJHFFfI5aNRtQfLn0Ga/iB/4OGvjj4C+Ifx98IeHvCXjDTdeWDw /JPf21vfpL/Zk5lfaCq9C/BAP9w9q4aWn3HsVp9+5+nX/BAz9rT4G+EvhdbfD3xZ4o0/wz4h0u6F lcDU7yCFrppFj8tlG7/Z4A7NnqcD7k/4LP8A7W/wJsv2WPGvhmDx5ol3rOp6akNnBZ3S3V/LNJKq wBIlyc/MxycABTk1C6m7norn86P/AASC/wCCruq/AD4l2Hwp+IfiOaL4fa/r7adZX0t0pjs5XdCy LI/AU+vPTHPG3+y/xh4m/ZD/AGk/C+l3Hijxf4a8T2dzGJlgfUYZpV4ywJUsOCe3IP0p0epnXm9E fif+21cfssfse2y/Ff4L+NtB8NeIY7pLaDSbQLqF5q8iurCONF+c/dyxPGEJJGBn9Mv2Kf2/fgb+ 1J8C7CXxh420NtSvNGNhremy6khaNSnlujpw6Nnd1Gf5VNJfvb9h1pXoNeX6o//VZ/wVm+H37Ivg j47eEvFXhzW7G/0vWtXaDW/D+mukNxDFDJbtNIZgOFYOVGSCCrYPTb/Rj+w74k/Yu8HfCzwtq3gX xR4X0PZpcEhiM0UcSKIUbAHYjIznJz9K8zNPelqenlcuWD+Z9+6p+0d+zp4r0abTL7x94a1Oyu4W hurddUj3SoVKsGQkHaQSMjPWv4dv+C6Hgj9lbw/4wsPFXwnl0W717xBrX2S6stLvGnEhL43yKGIO N7D5v+eQxwKKP8JxZnVf725/OlqsNkELaWrW8cUYS4VvlLSD7xX25GPpXUfCD4ueNvg18RvDnj7w H4juNC1zQrgXUMyAG2LJ083tgjKnORtPsCOWt8BrCT5j/QH/AOCVP/BWjwP8efg3onhb46eK7LSP G2mWrWV4st2r2siqRslB6FGU8YPvgdB9e+PbT/gnp4s1261rxRqXw+1i4v5WSPULx0uUhlY5YIxy FPT2AFbXexyPdn//1v6ffhtJ+wT8PdUEvgzxN4N0zU8/aT9iuIzHL0+YYABPQcGvyP8A+CvX/BXX QPgh4ek+H3wK8Zpq/iDX7eWylt9HuBLJZLGfLZzJ80Su29lAJDDBOMcjxL2nY6D+Gzxh4v8AF3xL 8Xa1408aapqGr6/rV09xczard/bLi1LMWKqw4wxJJwBzXnWpPOupadBbQn77G6nUH5VAOPbrTlpE yhuaEAnQ4eQgo24OGOWOTW7FfTojt5mS/wB4DhXx0JFZbGokZhuIJvMQiZf3qbJjDIWUgghhz1A6 V+u//BMf/go94y/ZB+Knh8Xeuala/D/WtRRPE+kf2mYLGCOR442ljOCAQpYljx644IiS1RvT2+8/ /9f+pfSP2wv2N/2gvhZa6n4l8deHte069iSWazTUUuXdtnRirYPU8+2e2a8r0+0/4JzxM95aL4Nm WKYTxtBGt1LkngIVzls9/wBa+eaurHpQkkz0zXv2nf2T/g/4C1K88L+NNL0WM7lgh3CGSOUIx2/M SxPHQZwK/hj/AOClP/BSTx1+1t481rwDH4h11/hRpF4y6WIbqS2ttUMDsgMgJwQd0ny44ODkfdFY fSSKxErxsfk/FdxXNy7TIGQ/uwCA2FHAH4Cv1u/4Jef8FGvGH7G3xgs9EuvFN7cfCrVPJi1OwvtQ e103Qf3qL5u0AoPkZxngnIBJwKxxCvNPzLw8uWDR/cjpn7av7GP7QXgDRtW1bx74dntDGmoyLd3s Uot3A+9hnBAz2b2rwr9pf/god+zp8E/gn4l1b4efEzS31bR9PafTYbC4WOS4kwFiQbdxO47Rxg47 itVL3EjNP37n/9D8XP2if22Pjp+0r8Trr4meNPF94t/aTiLwvp8t1Jc2WlQxTvNGqKThAWYksgDM xyewH9T3/BHz/gsr4S8R+ELP4PftA+LNP0jXtDhTTdKSe/Nut8sa4AjRuNwUHgHnaeOgHysY/wC0 c/kfQe0vh+TzP1/8ZfGT/gnd471uXU/EniDwdqGp3ZE9y1zJC32lt33GDMQT2wOcVBoXxD/4J8eF rubV/DOu/DnQ5wVL3FrLBbGLb2J3hQe/zVti3zwSfYjBPknfzPzc/wCCoX/BVTwJ8Hfhc9n8A/HT 6trWrCTS3bRrwxiABTko6tjc25Qu3Jzn2NfhH/wTW/a3+DevftMv4h/aeFzdeIfFmqPrFvrXi7Uj c21jdySMPM89z825ZH4bO3IHQZF4b3aTj5E4mV63N5/qf2l+Cv2wv2PPDOkGHw18RfCtnFbWn9oX UVvdxGKGM9/MD9Mn/wDXXEfGL9q39jL4u/DvU9G8R+N/COvQ3ttKFtnuY7iWNdjIWKhienY88VOD goJJG2Mqc022f//R/DL9sK7+FA+N/wAQrP4P3EV14KsvGV7HpcogMZjTfxtOSNpzgAdlHSvmCRXa 3d2laIHBSRcb4z2I9DXgVNWz16baij78/YQ/b0+Iv7HvxS0jXNO8QIvg3WNTtrbXYrqdzDaFMI0z hMBcj7zDnjB7Ef3ueAf+Ch37IHx4+Fulat418XaCZLiwgub6yuL9p1lYxbiF+Ybh+8PIyOBWGFdq zOivL90kj4v/AGvvH/7C+n/DDV/GXw78T6HofiDQrObXNJufDzoLq4uIU3RxSL1ILBQQSMbieMVy P/BNL/gsH8GvHOh3Pw0+LnjWx07X7O5S20iS9leOdoctgkN8gU9Djv6fdHNflxk5LyO2M/8AZoRR 8df8FtvHH7HHxK8Iy+IPA+taLdfEyGURaXc6FEkl7eSuS5iZh82OBkjp8w9x8Gf8Ekf+CpXij9mb x+vgD4s+KbjUPhfeFLeKaW4kmbS5t6Rg7VXgYZizE4xH34xGYN/XKMv62OvAtLB1ov8ArU//0v6g vHH7XX7CPxa8PaJceKPGPgzxA97GJLZJr6FrmESDc6k79zdvkIzkDivfv2fU+AOqWH9qfBt9NfTY dsMBsbZoliIwGI7cZx9RjtXzeOfNRhH+t0fV4GVpzfqcN/wUT1B9G/Zs8fahBJCSPD0yGCVGEc7B SdpI7E7B+P41/mZa54m1G0+IWqeMfDd5caPr2n+Kri/gksHMEMTpIdgTn7vTjPavRrSvlUoef6Hn QlbM1Ly/yP7Af+CRP/BYbw7rfhS3+F/7ReqWuma5pzDSrHWJdVIbUIRECkrxHAVgdynGQdq9M4H6 0/EH4+f8E7fF+vPd+I/EHhK+1SWATTXOoW4iimwckEscM3GDj0rgy7TD28i8xm5Yi/mVPDvxs/4J 56DOdY0DxB4F0KaGQXAubJltkDr3VSwBI9OcdhX5Wf8ABVr/AIKz+D/hr4Ij8Lfs/eOZdV8Q67Zz W0D6PcqHhViFeZ5VPyHBwq5Bye3WnN2qWOW/uH//0/5wvib8UfFPjrxLf+LvEOranruv67cvf6te 6rcG8kMzEsecnAGcAA4A49K8ze/1jWDjUb/zoIG8yBfLERiz1Xjg9B+tfOSkkmjsqdDKebyJDLPP PLPFJi2mJAMeeCAR+FSSoz2/3jMwXMjk4ZuueayMxsFrHMFlAKJBwVLfKxx0P+eKS3NpYzb0jtzI XLEYBHvmsHq7gT3U8Mlws+nw20E8tuLW4dF81ZACSTz0PPbpWZem43W/lzmKWJ8nZwX/AP1UhWsf /9T+Vf7J5GC6MZXYtLIeS5NWoGcZihjiMWQHldsSL618ZN2VjoLmnXB077W8bRGaUlUcj5oVI5Gf wP51DfXEksAYLjcDz2z6isjRQ7nNvYrqJgs7m1iubUHd5jv+9jYdMD+ua6FrH7BJBuiaJGGEdlIT j36U1oy2k9y9PFuiZIJI2AwVEfRj6VXEbxlQ+FLLl8HkH2pF8vu3P//V/lmuSI3853dg6bA33uB2 NZB1ONCsMduJkY7H/h2Z4Br4c9Ll925ubbmz09QyKFnjIY7hKGB9/piuLGlQWts80c5aGS5YspYG SJieRjqBQTboaVlZ3KRzLFcOLVgDmN8qx7E/TmtW0uS6h3LeUvyIz8E4/wAmgAvl8+N0gXBVdzOP ucdR9ar2Uca2yStysgwVB5PbNAW6H//W/lk+1RRSw+XAqqq/fY7m+pP9KijtnuSzPKq75cxgdWA5 5FfANts9aMVEV/MluCIyIEjG14JTywAIYj69arh2i2xQq5t5XEUpPRRzkj27Uih7WpTUZ4/PR8x7 48DsPfv24p0S7Lppn/hj2uR3FD2AstfrbzRvHK8gfHkDGSp9/aoLm/8A36Qi5Dx7h56QgMQPTHqK ycZCd7aH/9f+WG90638o3NlukBPyeZhZTjsRWPbST2eyZ40LzLtmjkj34HoG7Gvz9KysewaW6aGV Q0flRsNxXHYjIOapvLm6ZwwaNCGGOhxig1g3axpfZ4datisepLbXCuPJjSLzCwBGeTx7fhWh9ivt L1MR28lusDWYD+Yyt5pIyNv+PrVRdmWVpJZdslxtzcJlW3jAYDvip9MRfs88sQdHOZCX659F/Gtj aKsj/9D+V7TprtWulvJjcTTXJczKMM49/f1p1woFwT5bedM3UKfKcLgADtmvhmr6H0zgmzWiVYoQ 16BDCpCs64ZhnoMZrJlnsI7j7Q8LXcSqfILEweWemcdeP8muestGjOUbOxdt4x5IaQgSP82wnPGe Cf0qOxit4r9vM4eVdklxs3BR6YrA2SsrDp286aSxtZFkG7CmQ+Wp796zk0dLXzhGGSaaXzJ5A5kI J44zkAcdBxTuwP/R/lwbyEkWxuZUtmFv52Jgf36k444P157VqaxLBp9tbTwSRIjJ5bWxKmJcAYdW Hr6V+fn1BWsr29upbd9OvPM06aEi9hlQQokgB/1bZ55HrVeDULZNUXStQNyFuQXhmiXcN4OQpJ/r V09wNidQPllgzF91ZFHHHQmkaLyVAmuV+zlN8ESclHPtnjOB+lbwV2XT3Bbho57KaIyZjfblFyPb PpX0N8GLG2k1pbqS0sxLbzi+jMiK25omRxIwYYJG0AD0Br67g6CqcR4SD/nj+Z8xxdLk4fxTX8jP /9L4b8D2tld6roVswaWW+8RWbPLndLzdRu3ljt93Bx2Nf3N/se6TPZ/CDw157kNJpwWSQvkxDCBU A47KSfrX7V49VYXyygt0m36Plt+TPi/BqElgMZVe1/8AP/gH4m/8FntTvftWkW+lqjWUlyYo5b5/ ItY2AkWTP12scd8V/MX8RrzT7bTZbuzvd+r2e6SERqFijdeSwJ4K4Gfw71+2eDseTgej8/zZ+UeI S9rxpO3S35I/ET4nz3P9sap9vaOe6/tRp7Z1beHjdSSy/Q8H3rxK4t4rgtKGkXym3yr93p2/Sv5V 44lz8U42X/TyX5n7/wAO3jkeHj/cX5GzaQ+bGHdR5TRhkfOMDiuo06F0hdfthcO2ViLDy0AAxtI/ rXxmI3PU9D//0/41NNiicSJc+VJ5KhlDkZ644HepdRdpfI3IJ5YmzFM4ybdcYwD24x+VfP1Vud8d UXPDBvl1PbA1rcIWQyAybZIctg4HevpPSoNOtIB9o8ptRaUBcJuYKR69ucflXmVV7wzs7rYz2+pW VwROyASQlQmxx1+UdumDV9IJpZTdX7rIXXO/zMlm6kmuGS0aNIJWJnMaTGFWRiVBV1Py9OfyqCKe OG4S2kaCeC5ykwk4Dk9vw5rlirSZu4+7dH//1P4/NMmmjVkWWOzgih81nm+RcAcIB78ViXN/danZ 2lxcvcoLeZoobhflQ9xj6Y4x6V81F+8czdlcs2FlFqkDabe3aNEynzbyTAI6nJ9xisbT7NbXWLLT Ltmit57oRWt5Km6GLnaHY+mM9a1JjJt2Z6bol34jv9S13TdF+y6npGgW0hv0d4ICYoyxknjV2ywO B9wEj8al0zTZb24tjezpZrIrFi67Ewxyhbg4wBjj1rWmruyNLq1jr5RbWc222WS9tVjWE6jAhESt jgLnB7NyfTisTU1S0uYLh2Z4p1NvEWBWL1ZiR3GP0rqpRtLU3P/V/jc8R6jNeRyLbyCTFw1sWYFE iAyCQCOcY7Vytyix6YnkzebPCvlrM5BlVwMbuBToKyImtDziyTV7bVI72G5/0uGcuiyZWFjjGW9c dR71+x/7N819feDNHvLsQpZhvs9yY3Fwm54/LlJT+Fl5OTyeBX7P4ISceMIL+7I/O/EmP/GOTfmj 9j/+CbmqWvhv9pzwtazSvPo8l1a72IJiaOLzlZto5zmRTkdmNf3g6GsN74H02ae5V7iexWWGWQts RSd4Dd8BSPyrs+kXRcOJMNVXVf5H1vhBNVeBZRXRtH8Wn/BVfQ4Z/j1eX94bW2jaDUCFcNLcJJ9s t2LL35BYgex9a/IFNbtrG91SS7N1cWgsngggSMLHu7TBiMggdAPxr+p/ChqXAmA5f5f1Z/HXF/8A yVOM5v8An5L8z//W/GFPsdze7k3PKuDsB2CUHoSParuopP8AZgsW22mRshlwV2g9ACO/rX+t8fhR /njJ/vZepyTSPctBcTPIRbzcBB8sjdMEd6SV57iSRhCyrazeTKxUiNHxnYT0JxT9TfuO05fPug3n mRUL/MqGMq/BUA98dyO9a9q9w80ttPcXG2NSMM5SWRC2dpbrg+nvWfslJvmO2nWcIpx3NU+RFLEy 6ZBNuGxwUySR0AHvUU7w/agk2lfY55GETTpZLmFenAxxUexjDSKL9vUm22z/1/xtu9Qu7R7W1sG3 T2pEa+d/qJVHGG5x0qjHFJBGgbdLcXd3ukw3EW77xA9BjNf6xTpq5/C1OtJUH/XQvQaTb2Iurk21 rc2rISpcLKZZs5JOe4qxa+KZ/NiW3jj86wjZbdJYUlWIsMZAxxWkKcWrWOWWInGVyK4ubC43PqFn ZRSSRiWY+Uq75R1KDtn0HrSWt9DIlnNZuZBNe7LgbMSRKud2AfpjFbSpx5GkjJYio5asf4gvI5po ls/tdsj3WQzKE2hTkBz2zgfXmmQyfaJ7d5AtxJESQ27AOOAuPwNZ0oL2aizq9o1G5//Q/HGGT97N BcS4hku/tBiwAJXAwBnvwP0q39rVM6a0KPYXQHn24gR2Yg7lZiRnGRj2/Cv9c4JbWP4EnNtm1b3F np1obRR5LOGdCFG3ex43c9f8Kx50ggjkWeeKe6mXc0cbZyD0Bx/Ks+W02On8Da6opiBJ1b7fGpRM CONWIU8dc+1LeTh7SK3tHkaO0jMcY3FwqsclV9K2nGLg1YwgpRmnfqSTzJrVvpypaeU2nP8ANF5h +YhcGQj16kdetaEEMNoRcXV2IrUrl4YZQjuAeA+PpwD6+9bws46IynUabuz/0fyVW702aKRljEMM eXhcdZCf8fWs+01u5e4VW0tWVW2w3MkoJIHtj0r/AF4pRajbyP8APe+tzRnuppZC9lDawXoVkU3c CzRKGGCwLDGRgEH2rjh9st43sZrmWfbKzSMkh8tyx6qKDrUl8LOmisLaGwE1w0ctzHgxxEbZHB75 9qW3u9NjCv5WTI22fBwQQMc0nGz1NozTg4l2aaBESeOZkPQhm5Az0rRS8tYpBb2syupAcOCcuSMk +vWtPctsZy5Wf//S/JW8jTUbiKW7tkeaHMQZm3hF9qr3NrDMipZLFbyl/K8yOEdu59cf41/rvyx7 H8C8qK1srxTPZPOzuPlkdQVEgGeo/Or+maX5zXEiFQUkPksz/vG9x6dqaVkRzWjYnkk1S4guPOuP MFoxVraSXMuzcFVlHfr+FUvslrKQ80bDKhAsmVYn6U2rBz6KxYlS0hEJliLwxdYoFAwF/QfWmm/b UJDDG4S1XAbcMxn/AGeajlV7s1nJ2SR//9P8wYbZ2sXEUCbVAWOSPKOg6kDGMZq3pdpcvdrdyCGA yj7MstxJsCIOTl/Tvj3r/XKso8tvNH8D0nJT1Mq4iWW8muLdTF5Rwu5vkJ7vkevb2qob3yHkDXjF bjDTIpLIrLx/Ss3GHKO8kyzZaxCIbjzJlMin/R952kD0A75p0Wqu/MDp5qN+9eXEin/gJ/kaKcIc uplUcrmXcapDpskTi3E48zc0Yjyp55NbOqaxDdWMrR28sSTKEJto8qA2Rt9Rn0rb2UOxxSnbc//U /JuPTbe0SK4tRcLP5ah0kcEN6/Ljj+YrqIH8y0aWYhDCCxCkkIvPNf65xjHnsf5605v2TZR04+er zwTKIklMe55AoY+nJqaKW5hYvcho7SVynmYyn4V0xhFanLKpJ6FH/hIlnja3itjZy2chVJFZi1yh PLdeMDsP/wBdm81G0gsYEtHknLtmZScbwee/PUmnJI1pTb0MCHUjN50ML7ZF5cDkoDnH8jWhppum luTBMsMn2dg7nADDjOB6nFNQjaxLqyU4o//V/KqWRre3ihuJCYGO0vs+Rs1oee1vYvc28pfcApPJ QgDj8smv9fJqnqj/ADvqNufONtWkvbC4kjmkLzQ5AjHB5GQf14rJtZJJrs6a8EmWUbGK8KT3Pp/9 es6UY2aFzK2hJJc35lubaGS41S1gQW8oikLvEVPzcegzW3pWpQvbXEDPMeAsLMQxhIwMH1HtXQoU 0ZNyMq52XFtGkay/aoL5ma4mBAUFcDZnpnJ6U/U5Z7O3j2XXnSSRKzhWwAff8qJQptWIjzRle5// 1vyVtLiWa4SSWNPMVSqsQC+3vj64rRgsTLOZFL26EmUll2lz7+/+Ff7CRhTUdD/OXlm+orSul01i YY2llIcOxGHPYn3GP0pV0udbr7UzqpHPlhdwP1qcPTXtp27f5nPNfvVfpcZLHcWsTTC+tb4T3WTZ pHulgHoSR2x2rbbU4bewkTy5FMi5jeJNoRj3PpW84pRin3NabtWafQz7RJLFjc+a98bpQJJWcsw4 6E99vT8KsG/vZJVNtNMfIyYS53SxBhgjPp2/TpUypw5ndEvm5nZn/9f8sWuvtTsmoKzyI4SbA2gk cA/WpEfTHWS38qN5YwDEshLPGORkf/X9K/2BrRvZRWp/m7J2XzAWQlcXY2wtGfkffxJt5wRUXnzy XBfMcEJDPKhyA2OcAVtTinuiZyakxXlngZfIsrdLKZPMkkUbAABwSvc/4VBLPKscrIIFW4iCPKEA lZf7ufStoQUFYTm3sVlvnhsnhRWCQsHTLZBAHJx61WhmtbkCd3CIo8yfzRsZlA5UZ7+3Wppw1b8w 5nc//9D8lpri1kvGOmK+0QiUqIyiKDwQPyqob+4ilVmUtCG+cKMsPev9l4qysf5ouT5mP1K5a4ha eOSXaBl+Dyfesmxa+u13lTDFCu5pG+RJMdAue9ZTjZNo66crNJm7LJNss9yOktsxmt5W+5l+px0P TvW7pF20nm/bVQmAbXIRWBJ6/gcdKfKuazIcne9yaa/02C8aM20RV0G5oEVbiPOe4/lWcNSNlPbz zljElyGtzLGskXXhXB+Ur2INYqHLUkaKd5RP/9H8otVeCS+a7ENhGLkeY0WnwJbwKfTavAqbS76K Aq0iBXYmJPk3gDB5r/Y9xXVH+ckJ80ble68ySdmjSJTvBWYwqXPscg1OdQljtnspre2ZnlM0sxhV mlG3ATHQAdfXNbezje5HNZWRjWVxLPNDdz2pFzbExRF23x7F+7hemevOKWFrDzpGRSGln8x1Tkb+ 7H8hWVWmm0LmSRauLyO2lRjGwz0foR+NS6drEP2iOCSFbpVZpVnmRXSEt1HPrWkKatsZzkrn/9L8 lLyaw0+O8uLS0CzP+9dwDIhYHIOPbPaqk2r3l9ZW6XzrJBCwmiTyFh+fBBbaAOetf7OKlFRtY/zX lNPVlAzqZ7Zgi+TI235xs24OCa054J02hEMazjcg/wCegz1qacErsVKdp6DzZ3UU9tdr5cscQ/1j fMYzg9jmsj7TDLd/aHsrdZ7WQ+WyRhVfB/i7H3zXVQpLkWmo6zUqjb7mzb3huFa/ktYFuSR55jgW ONtowDgcdPas2SRWuJpoEkaRlwRGMEg8EfTk1cqdq90jGT5VFI//0/yGWxKRHPCqu8huig+tY9/E yJESqwwNJgSE4832r/bKMbn+azlrYllZ0EU6TBduArZx054q00sNzC1/Nax+YjhVkij/AHnOM8Ds cVqlbRDJHiW7iDR4lKjIQ9Vx7VnWVoIHe4nR1EzbVQ8Nkcc0zOWk0PS5EWoAwpHLOg2pBIA+7PQA VFdvDdCNLuGIs0gPlkZAb2HrU8kXpY0P/9T8ZZtN08LsEAjEnysu9irD3BOO1awnSC3WKQq6Iu2I EYz2xX+17oKFSSW1j/NWM2pRaMWKKw+zSRKjQzeZlIbbNsPzQg/nWo1ysOlSxwG6a/Y5hkmvpgkf GMABq6/q9O2qOaU22+5JNCdRsY1v4QJhCsTBHkaNivIZstyc9znpVVNOkVZVLq6EcJnH+elONKMJ e7oTGVmkZlrfwLdNZsEVEyCW+4SOoz68VY1LVVksxBGud7bPLUbXYdPvDkfUVKpRlUfMjSvVk78r /q5//9X8XrC7uIpoRFDI7ROMpLeSsjL3H3sfTINbGoalqlt5TWSywRXEgFzOrl1URgfIgJIBORkr g4r/AG++q0m7tI/zC+s1KacYvcqRapq8d896mqaunnHcbdNUmFoTyOY92D1PWmqsCwv55YQAlpFU kkDqR9KzqYOglpFXfkRHEVXJXew59at7Td/ZMl5BazouWtr2SJVIHYBhj6fpWbba1qikKl3qk4DF WSXVZ+Aedw+brW0MHRS5YxKeJnJ3kxbO8v5ruNryS6jitg8UbNdEvdhzyJOfmHXhulOcRx3MuyY4 kIYQscqnqBWkKSptxWxnz887vsf/1vxhNxbQR4XapkkCNGP4if8AP61n/wBovBcm0tVW3jJGJIma F+DnhlI71/uCsPGb95XP8yfaySTTNttW1mWYT3Gtay0KAKkH9oyGCMDoFGeMdqgv/EN2IvJk1HVr lPO/49Uv3U4PUk5z2z1qP7Ow0Vyqmkt9lv1frfVsf1uqk7Td9iGTUJY4S1tf3rIYSrpJeSPGwIww ZScE49c1j6fPbGdVigA3QmNkkAwM8ZGOmOPypPCU4r3Voc8ZSdVSe/cnitdWsb46nDqtzYyBBDvt JTEzxggha6+/8Ra2unpcWer6xHOTvMiapNHu+uDmueplWBxCUq9KMn5pPT5m1PFYik7U6jS8m1+R /9f8dT4/8YXcEsS+K/En2wxhY5l1aUhSB3BJyB71jHWdav7h11bxLqupxRxqbu1ub93juWUgruX2 PIB/u1/tnh8kyrDSVShh4Rkuqik/vSP8ya2OxmIjyV6spLs22vxuP8i8vV3rFK4Q7t6KWCD3NU7G a/8AC+oPrOga1qWh6gylHfSb9rF5vZwDz7EjjFdrwtKq3TqK8Xo09U/W5mq9SMIyUrNbeRqR/Erx 22nRW83jHxcl4A4nNtr9xbpKWJwxKMCSPriueurlJrd7vUTd6ldu2957q5ee8kYnOTKTuz75p4bK cvwrcsLRjBvT3YpfLREVMZiK0k6s2/Vt/mai/Er4gSWtroumeM/Gtjo8a7E01PEErW0CAY2LzlV9 skVjPrEtzLePqUlxc+em15JpPMlchdoJbH0rpw+X4PCVXUw9OMXLdpJNvu7b/M4cXVqVpJ1JNtaK +tl2Xl5H/9D8I4HLx7XBKqeDna64PVSOhyAcj0FeiWfxO+IGm6WmmaT448Y2un2rKIbODWXktYlG AE8tgVPTv6e1f7m1suwePXLjaUZxTulKKkk11SfU/wAu44nEUafLRm4pqzs7XXZ90cbqN9f3jTTX 9/e3c07+c7XtybqQM3J5PTJ5wMAelc8i3Bu4cmSNFbzDJEOOO2feupU400oQVktDCCSioxVkjorc NJv3xFWP8bjJIqKSCSIEpwJRtJP3QK1hHqWTxXclkv2aOONYriPZNIfvMeNuKzUdMMEiBZGJMoHL fWtCYpps/9H8HHYPKoH8Zw1S3BijYRxRkFVy7kYZj6V/vAf5ZT3Hy3TLCqRooJGPmrMtY5JJJWdQ qhs8dB/nmtaexhN9C00csk6NGwaGM7ZAB1/zipru0eVN8ShYlOzzAAAuOmRVjg9LFZrea0dMXEcq MoYFM7l9Qc9xVKOCO3k2x/vDI24s5+YZNSm72aLP/9L8F0FzIhYI0ao/LOPlkx6GgLHLtWQjcDhA exr/AHoP8s4PoUZrSaJ5DEnmd9pbJFQ26TRTo8qA7WBZOuBnms59DQ2rqzguLhbkwhFB3x4yGXjj n0qFmXzNiY4OCe1ZgPVYJJY1lYBI2y7+g71CZoHkeSEL8rbenJAOOlAH/9P8EpESRzvXIIyVHSqD 29lDMzJHiV/vFSSVHav94D/LGXxMiFvGZsSHeCfu54AqWW2S3iKxhcMcoi9/cihK+iJHWqtGVl2b tp+bHSn3DI28ys8cYUlUC5Ge3H1ptNaMqL5WFnaqyebIyohTcinhj+FTMzRIzRpvBOAucE80rFqd 3Y//1PwOacpLDwqgfMykZJHpVoaoFuCxQeQylHjHQA9MfTH61/vFGN2f5aydjP8ANhdmDDERft1F X9kEqNDZo52jOWGeaHFp2Mm22ZNqrPJJFO6RBW2qzAgCpI4PIeRlf97sKxvjO3PFJRb2L5ly26ks W5VG5QWXgkjH406TaNxQsSecDoKVjM//1fwStp5ljaHAYlsjPUetDWskjK6DhAfOOMEeh/nX+8B/ leSyOIIo3iTeS+GYHrUqyWk8bKf9eDkdgtAGbJGqTAv8+7jZ1H5VIqpM8m0LCI1yIycFuccVFvfu F7IU3ECqsWxt6feJGVI7Vzfi24SLQr0qSS8Lbl3YCqByTWGLSjhKnozpwLvjaaXdH//W/jA8e276 brlwXQNBfQpfQNFMs+wEFCMDlcbOh5rgpp5o5oo1kYwuAzA9ef1r9f4xX/GSY5P/AJ+z/NnymSv/ AISsPb+SP5IRxFLKX3FdowB1JIrTiuWjt03F5Dnbt5wPwr5A9XmkSmVeIFTY7Yd2Wr8DwwsQMsdu Vbvu+tctZalwk3oehfDn4yfFf4I66fEXwp+I3iHwBfXjbLttEuHWGUEHP7sEDJPJ9cV9Zv8A8FLv 22Z7WNJvjrrV9NaJutpLpHHmHjG9QxGeOD2rn5Ic6qW1HOPPo2z/1/4+viD8avih8YNbm8WfErxX feI/E1zF9kl1K4kPmRQ5z5Qz2HzY+tafwu+MXxS+CWqSeJPhL4w1rwtrHk7Jb7T7xoZLqPIYLIpy CRgc8HjHNfSVputaVXX/AIGhwUFKimqeh9Yf8PJP22/ssVxF+0H4lubcASGO9SMpAT/rBjBz34PX 2r5X+Jvxq+InxW1WLxB4z8X3/iHWYo3VLm7UrbopO4KIyTjqehpU5KneMFZPcxlSUpqctWncqfDb 46/Gb4Q6la618OPHmpeFL1bgz+bpkzQiRtwZs4PbGPx57V7V8S/2yv2h/jP4bn8O/FH4peIfGGnO wcWl4cpsH3kLbskNgAg9h70qM5UXz09Gb4ym8SvZ19Yp6LpvfY+V4cQzyzLFtjmT5nckMCOnH0/K vQ/hP8afip8HNUtdX8A+Ntc8NyW9xMIG0/UHsjGH5ByuCSGAIyce1c+JhCdeXOrq/wCpphXOjhoz pu0l/kf/0P5uk/4KR/tm/Zrl3+OXiiaY/Mssuoy3ckuO0jSEk4/EV5r42/b1/a8+KOiN4b8X/Grx HqOgXkPkappcjL5Mq5wY8Dggrxnjr0r6JYytBJQdrHBXdTEw5azuj5KkEcEksNqDFE0hnVTIzBWO Mnkk11vgz4hfELwDeJ4g8C+MdQ8J6/CPIF/pzmNpI1dXj3FSDlSoIYHIrhbtO7DD1Z0ZKpTdpI+z Jf8Agph+28tpFDP+0F4ukaK0FoGt76awkKr0O9Hzk45IwawtL/4KTftqrrEFwPjX4itppJSn9oXW ovqdwnBIO6TOGJA5yMZrZ4i6s9SZ88nzczuebfGT9rj9pX4z6PNpnxI+K2qeMNIkuQ93pmpSFhNs PHz5yP8AgIFfMF5fq8EbJCqERhYwxz5fHT8KbrTqpKb0WiM7S5uZ9T//0f4kvtA4Mq4dT1Byr59q 1rdYUg83eDKSCuDwBXqWvHQ4YfEi2Yo/NSSWQExcoVGVJ9P5/lVpJYg5aeRnA5AT+GszRr3kz0bw P8WPHvwv1e28Q/DTxhrfhbX7OJ4rXVNNumtmkWT78cyj7ykgfl9MfVmmf8FMP27bWEpL8c9aErBU eZJ5BNMoGCGYANgdgSetKmlTn7RL3jqliqvKqKl7q1R88/Fb46fE74u62/in4leL9S8YeJYbIWFr qmrgSNZQFzIYYE/hG5ic9Tk9qofD74x/EH4beJdP8X+AfF2seEtftEEQ1HR7x7SWVF6LIAQG+h64 Gc4Fa16k8RNVKur/AMrW/IwoqNGMlT0/4N7n/9L+Yf4m/tv/ALU3xg0CXwT46+MniPX/AAndTeZf 2dwY4pbpcDMbuo3FSQPlLEYzxzXyva6lqEWqz30N/LbzxxrFBPCweWARkMhjz0YFRyOfevW9rNw5 W9Dmv+85lufWfhj9vz9r7wToNp4X8L/G/wAVW+kWqLBb6dLfOI4lHGQefrjpXQQf8FG/2zBdvJc/ HrxRbTvGY2W3gS4AVeVALYABI6DketZVKs5Q5JbI29vVm71ZXZjeKf2+P2ufiHp82heK/i7rmrWk 8bARtN5cQOCvzqBhhtJyDmvk+KBLWS5urkteahOMvLneS5PJUdup4FP285x9k/hRxYilCtW+sVFe drX8lt912dP4U8S+IvAOs2/ibwjqFzoOu2itNZ6jYTNbXUcj9yykHivpy3/4KAftchbLTrj42eLX s7SE29shvZWjRCOUZd4BzxziueDhTk5pas7oYitCHs4y93ex/9P+cG3/AOCgn7YlrJZxQfG/xLBD CG2m3uXjELdio3DP4mvMviP+1x+0d8Wo7rT/AIk/EnUfF9nOn2aSLVGlmcRj+7liM8DrkYr0Fiak JJweqFWlPEx9nWd4o+e54rO424iEaqmwQx/cGOnHas+0S5SWKzQ7YS+4Ofvoe/P4Csa15VE2Y0rK bR2GieIfF/gXWxrngfxTqPhXVMAS32mERzXGMA+YeCeg79q+q4/+Cgn7YEEGmQP+0L8QLpbKCOyi gTU3jt0SMbQXj3bTx6g1tF8r5o7m/NNRUU9F/X6Hg3xJ+M3xW+LLWV98QPGmteKbrS55ZLRdWuhL AFkbIVCQWXqTgHGWPFeQi+uCixyiNHLHCRncqc9M1lias6zc6juzniowjyxVj//U/jpKs0ZcxIkp JC7Tw3uapRm6XcwIXynxjd1PsKSd1c5zZjn3OrEpGQmSO1Y7NHZ3MkkaiRJmMmxTnB9/SmNprckj mkuhG6IqkPh0z94f5FdF51vDZz25heQPHkKrFHDDkEMOQQehHoKmTsjoTa2PUfAP7SPxx+Glld2X gj4q+KfC0t/IoQ2949xGigY2kE8ngfMfQeld/qX7Xf7Ud7A1rqnxX1TxRY3Ufl3Iv7qa3lTcMFgF Y5/4ETUpU4y5o6MmqvbS56t2/Ns//9X+RObVNU1GWafUr2S5u528yabOwu30HA/Cq9tqGoWmpWuo 6fqN1pur2kiNZ6hbXDQT27IwZSCCBwR3qakuZqUtTZTkoaM+pdM/az/aHtbe0s/+F2ePrWG0gKw+ R4hnbyAAAAi7sD6j0quP2sv2lInb7P8AG3xjJltyRz6hNNIT6l/MySfcVSrNKyM6VSdOTs9Dznxj +0r8f/iPaXfh7xx8RNa8QaBNGYLvT5bmWGCUKfl6NgmvJP7R3sYbmGKKCGBYoHyWk4GBn6cYpObl aL2Q5NN36spO0jyeWuPu7w/TIobGQjD5R945xg1k4tIv7J//1v4+zAGAijIEofcyADAH/wBetKO1 RwUQvEF+ZsHGCK57dDWnoh9tdGNpfL2lo/l3Hoa7bwp8XfHfw0jMfgDxv4n8M/ayXvI9I1OTT1ib G0JEUYfLgA85OT6dbhFLc6vbcmsX/Wx6Tp37TX7QANtOvxj8ei8S58x7yfxBO8cSHggLu5b3J5rY T9of9oZzeT3Pxu8d3e/d9naPW57cKx6Erv5X2461k1d+gpS5VY8j1bxXrHi27ude8Ta5qmr6/cRC ya/v7hrh3VcDcSxzk4HXPb0qh4L8TeJfhxejVPCniLVtB1ueVmmv9Nu5FeYEkkMm7bzxnI7fjSqb WYoztuf/1/5lG/aK+PN6JBcfGLxzCc7YFttZmt41BxuBQNj8q851fWdb165Or67rFxr+pRykNqWq TtearJ1I3yN6EmuCL5TtnPmZD4c8U+IPC1/eX/h3VtR0WS/YS3/2O7eJbiQMGWXgghwQOQRXU658 S/iJ40jNp4s8f+I/EFt8sgtdR1KSaCILwNoJPOCfm6nnJqbbm0qmhy8UqJJHBZFHYyBo3aXyjbsf 41fsR1B9q7eL41/Gfw9ZxaV4f+InifSkteAtpr08MbL0+6pH6HHtTj7ruKUuYv3XxT+IPiizsF8b ePPEXiU6ZctdwLqGoyXEKu6bdu1yzED3OOelZnhn4geMvCZnTwt4z8S+GFuZfNuY9F1aXT7W4IyA WRCOVHQg8ULR3QpT5lyn/9D+WbxV8QPE/iXUo59b8T614pmt7ZrOOTW9WuNU4dtzlZJGLAk9cHsK 1NJ+J/jnQbd7TRvGXiPQrLYqi1sNTlFpGRgZCZ615mLfNZnfhJKEGjVPxr+LOXlPxO8Zxp5IhiMe qvG5A7sc859sVyPifxbr/ijU7fWdc17WtYvLW2W0tX1O+e9jgUZ3MobPzNkkn3qYySTQpO9S7MKb UJwBbM5LOvmoCeue9QWKJ56M0rPHISsse3kdsYNZSV1Yrm5dTsfC/iPxN4av5J/D3irX/Cs8ACW7 6Rftapchc4DIOMcng9a7YfEn4o3TxG7+J3jaUrOZ98Ovz28hY98hvxqtjnP/0f5z4f8Ahf8AqmjP 4mi8XeMr/wANszwfaV8RSXlzaIjlSzxgkgbh1bHr3rx7xBrer3cl3b61qN9rMudrSahdNdmI4Gcb iSD3PvXgNu9zoMayhEzeajyDdHtYD/CtWQfYoZWhS2unMRhEU7fvCWGPl9/ftQ5N7mKWunkckbe5 hllmuiIinzGNG8wKPStOzK3luJo+hXcnowpGwR2izEszldgJ64zW7o0ltBNHJNEl15QZRFON6YPU YqZX0LhLlP/S/mCHirxbpEso0jxd4k0bT2BRLXStVktIo93BG0Z47Y6YqhceOfGkyRrYeMvEluYw sTeRrMiyMwYEyHkndx2xz6V8807WR1xlZ2ZqP4x8b3Ti4v8Axz4wvC43SC71qSdi+NpZvXI4rEuJ 5tQhMDXEsYTCBicuVHPH15/GlSdtypyvoXFntrVYxAruEUGUy9S3fv0qZLxYAuUM8V9lJV2Fgvua mr0bCE7aF221vxDpV8bDR/E2uWNpLADcx2Opn7JKSPlEi8gkCr99d6u8Ma6n4g1rVYh8yw3upyPa MexMYIXg9M9Ki72GpJn/0/5foLlZpktidoyEDk4VQOOvtUkMk1rcCayupraeG8W6S6tJTbXQZRt/ 1ikMPzr5hOzuepGful1/EHie4E1zc6zr14TOY7WG41qZfLQYxgg565PNVYfEeuNLHAmr6+I2Ym4k OtTYHoMbucUVPe2Loy5TR1O8m1CO3/tG6uNSWyTdZfbdTlvEjJbO4IzFVJIB4Hb2qvBeujRm6KOY 2MsZIyyntt9MVpSdk0hvWVzZOvas9ukUOu63aMSQ722pSRNIh6Rnnhfp6Vmi+1+L7SYvGPiKySRC ghsb77Ozo3DIzgbiCOvPetKL5bBWfM20f//U/l7s7m3tkeEwhER+O7yY43MT1J9akl1GK+kksQsl uwQNHM2BC5PYN0475r56pJanqw2sc+xNlcXNusQe2kfy5Fjj86OYkck4GOTmuo0PxBqWh6bJZaTr er2VvJITJY2uoyLC/wDs7c9BgflXNTfLNm0veppMtR65r80jC11vXd8j+ZNEdRfZOBz5ZXPI+tV3 1K8vLg3Eok066iPN1ZTNbXGR/trg8cVi1+9czeM/cUT0X4WRDxH450bT/FniLWrbS5rlbefXGuGv bq3jdgrBSxwp5+8cdeo61/a5+zf/AMEMf2Qfi58J9G8U2esa5cazPo0TvrUOshJriRk3JM6oCozw cqMH9TOL96rTkjpws1GjVi/61P/V+eP29P8Agmx8TP2WviLb2ngvVfEfiPw/cXjLb3dmJTJagN8m /aAoJH57DjPOP6Rv+CKvgzxH4G+FEE3jyTVBqGqzLc3EGoMyPCxLRI5T3WGMkYyN2PQD5fES5oxP pMPLl5mfTP8AwVo8daN4Z/Za8eXEOtWdldw2CF457tGaaGST95tizuPCZ9xkV/mkeJNXuDrV9Jae bNBfajNeh2T7P5au3yjb24wcH1r0JO+B5fP9Dgu1jebyM03iLbqTqE9pqHmb7ZredoLpz1Ybwc7R gcc9B9alm17xFMkTXXizxDJOCcSrqMiLt6BSucYGeO/vXFg5ctNxLxXvTTKWoeJ9ZjgNna+INfVo lE0kkerzb+uc7M47HtWSPFN3PcvNqtzfJp15brA1zcyvfSsw+brIS656YBHQelE23K5hf3bH/9b+ XRbu2AukhicxW7AiR0KLIrAEMP1Htis+S4njmj2opjnQFQhA2knHNfLne4p7l2IWgkeC4i3x/eMi AMQevQ1BqstlsWXTSRDJ8hh375F29WJ9/Sk9jJxaG6WDJGVl3Kkp+XPIXtnFYMtglnNexLYzSR3E zM8zNsSTdjJjXOTnPPYVgUoaa7k0Vtb6dFbiExhZAWjSNssnJ4I6g/X1p885kaFjE4kV8qWXacdD ighJvRH/1/5Z5ILlrJbiP94nmiIAn7pIJx+ABrIij+zXMqSM7pM24hjuQEf5/SvjJrQ6rWkky9dW cEkMTQZUmbfKF/5aDBG0/jzUv2dpYsRBlRAd2RgnHUVkbGTo9xFqN0yRtNCI32gyIYy2OpINei6T Ld6pZajoNy1pJZmcJB57qs6d96EnIzyMj39aAMOWO101IgkbPFAdrDduaTHXmsETSvJLKzDyZDmM YwwHvUNuL12Kv7tj/9D+UJjfT3KwxybrcttkywUMO4x/hXT6XqWlWl1f2N1p2wXOnm3FyYsRpJ1V wT1II6D1NfCqV3Y9Lm93lMPL6ZGYI4priJ3aVA7GVgWOcc9uenaqjxkrdtO5ZNnmrGi8buwFUJaM SJ5rWIFd4DIGkhBO3HXke1a9rNFeqA2UC8oVGfm9CPrQOKu7Mj+0iGZ4CNrHgIWxuI6ilDvboI44 BEo5MZ+bbnkigqCSk0f/0f5XhBHHai7n5WYlI1Bw4I7/AE5qJNThnkhtLcsLlDuLtGUjbHQZ6Y9T XwUotXZ7KV3Ys3oW6jUTJ5b7wrSJn5OTjkdjWtZ6NJdaeUE8QXeIBJJMkGwt06nP41Nna5pyIyo9 Huog0c8hkTSm+zecsqkErxkkdQT3HHNQvcm5eaWOO3iYDyhEgKxgYAzgnPbNKwOMbGXbNbxSPFPc sLzzf3cflnaQwPQ1oSada2MqSwwZklXzrlgBsck+vrjFBlax/9L+V3UDJdrbeWZLKC2YO725y7qP vDB45qrBdxZRZZVMbOVEj4BYe/vXwCV3Y9mKu7Ghe3tpFAbIrPqdxcQ+Yl3KnliHB4HGAR2554qn ptjPZ3NvPqESOGIlMAH7lkP3VYdx60SVnY2SsrI24byKJ5LMi3hSUhBlBtgDHIIOPlH9KqXs6+Z5 bMrtbqYS6NmOTHQg/wBRxSGRXnmtaxROhyrq8ssUmcIQCAf0rZsJE+zhS6mJRjJ4IA7VXM7WN07o /9P+WS0mthqbj5FhQEq7f6vPr+X861bm9iVofNSNbdCXt5Ag/ePgn+gr4Hmex9M5KJkfaEvXmPkm IEBnYt8rsD/d/Ksq3XT5rlnkuAYYZf8ASljxJnHBGPwqJap3I5uaSL32+Kd7mSEpFbWuNryOAzj/ AHeuR6UlrI0sjPblnjf5meTjH+Fc0epqdBDp2QrCOCacgOJAdyxgDOR74pXhTDeU5LykK5bgDGcV aV2JO9z/1P5cUtvtPnLLGp8yPYZSMkgeh/CqqW2n3TwQ6k1w1pbSFZI4Bv8AMz93I+oxX5+fUHSs 8WLfy9Neyt4FCJs+SOUDIzj6VmXEMD3TXEJVVLZHeSIjoBnrn+laQXUB1xa32oTwRwzzwW6x+cTx HG7DoCTx0PSrCxxLcRi4jjmWFPlcnnfyAa6Ka6lw+Ilnlmhjn+wxq05i3Quy71Vux+v+Ne+fCjR9 Z1LW9L1FLuGHT7Jd1/p5cLPelwY9nXIGWzkZxX23AVP2nFODX99HynG37vhrFN/y2/FH/9X5B+FG hSz+IPDNjZ24lksPEdhcTohzIFM6ocH9M9BX90f7OaEfCTw3fALJLqMSqTnCxrHGiAEdjwTX6z47 zbzrBUeipx/N/wCR8x4RQ5OH68/7z/Q/nY/4LL64l3rVjpMInuvtPiGCzit5lIsLZlEpkkZ/Qbwf cZr+aT4oC1ttIvFkjElxPBMbmCGPesMapkMvvwfwU1/QvhXTdDgWjfs3+LPxvi+arcZ1vVL8EfiR 471mN9VvlFjPFb2paGykZdqEZ2gYPIUYHFeTpfym5Ac8H7yrwrdsGv5H4sftOIcVJ/8APyX5s/fs nXJlFGK/lX5HY2aC4jiLTNFCW8qZQM+WM4zt7/h611z2sBUQwRxmzkRZI7i3JSUFeMHuucc18niV aR3wk9Ef/9b+L+1d7kMbiBbKa1kNuvPMpHO7r6YzWlZj7WreVMspBKuxb5QQcED39q8Csjsg7Jnb +GbfZeSw29j50lvGJQrDajnJ44x9a9Zg0i5M6X8myLzQPMjhlYzxbcYABry6u5oejJoPl366i97N dJPHGsEKKBHYqE5DY68/kamvrEy7oPPYo38aNsI6VxPXc3jsaWnadbssguEkkJiEUcglYCLBzkD9 KnTRVnkjhTyZUtn81QRllxzn8Mda5npOx0K1j//X/jmur/zI1lsCskiny0aVMxArwAQeo46VVtLJ 5LmJLuY3sQPmTQ2zEIpYZIAPp/SvneW0rnLJe6ya7vdPskMBheOEYUvEnzDJAAx3xVb7QZEZ0Pnq 2FtkuH2iPB4J9P8A69URT3Ok8O2FxpjNNFiJrrIudrEFkPVWPoa7Tz7e4m8pZUU7cRqjZVfQV0U3 sb290tafEzlYdQuZIYgGW38olIwwHAI71g6zfXmmzEzvE2miHeyMuZFKc5H4V0U3eZqlZWP/0P46 9W1G1lMLwWqyxvalwog2xKr5+cn+982fwrzS7vY4ZJvlZo4+FBBUE8cD86KMrKwpJ8pm2Bury8aS 3tTNPKv7uFV/dRY/iJ7D1+lfp5+zhM9h4W1bT71/3t0kNxa3cIMfzcB1MYz8x3g59EHvX7B4MS5e NaK8n+R+eeJCtwtVlbsfrP8A8E/dW1W0/aD8L2U93PJDpcDTO01qhhHmtFGjNKBu3ZUdeODX+gh4 QMM3g+zbzIZY4NLjt08tvMSZjEAce3IxX0f0kYL+2cJNbcv6n0Xgq78EVV2kz+N//gtH5Hhv4xaJ a2iTQXN+NRa81FYiwtt01mYwSeP3gZQO4GfWvxih02QiImSORpG3N5igqo7AjpX9KeDt58AYFy/l f/pTP5A45ly8X42EdlNn/9H8ZJ7CfTJriC9lgh1CRXuLN4E3RzRR4YAHoCeOPes5dXju7hIbtpmn eAtGsa/KwHUsB+HPvX+t8VaKP87ZvlmzLhmLyT2s21Y2kxgfejOeGH+NdHDBBomjtH58+ox31w1y fMH2iWVznnAHHemaxbfumXb6lC1pIEtpopmkOHkARoQQMBVH55NT2kjj7O01yJ54EEWZECPtJJGR 369amfNF6HbRScbSNm5kudxeGOQCCP7USFIVQo3bs9O1PjupNWF7d6j8scyk272/3s4wM/jmsm29 zrjGNj//0vxo8tUjj5Z2VRiR4yocg4/+vVu/jkbTZhZ2yy38KeZBubajMAQQT71/rLUdj+EE7R5U Yu02Gi2EbwXIubxi9823EMB/ur/ifpW/pp0uO0Z7eJWk24mkK5kLdMk+1a03qjlqJWZl3trb3jxq s8cUgYBJJVyOSBjFWbm5vdNm8ixiia8iXy1MMQZMjq3TritWtLGMdGYdr/as6XFxqRWOF5yFhL7p 2x3cdRzXVaLZWN1FO8NwLeSE7ESQFPPbA3BG6HGR7daUY8qsbc67n//T/G6R7SyX7N5ktzNHceUq 7d+0s2Czt2x0rX+yPbLNPEqzPJCAjbd74HPyj29q/wBdItaI/gB7nLkSXUNxLeTXNvLC3nCK7hMH yjPOTgcY4rU0jS7O6dr9rtWeDaFy3MjEcHHcDH61TV7iU+XRF68SS3EqSqksUgPzJ82PpRpi6ZbW /wBrmiu0YE4EqEQOBnHy4yD7mh/yoTdmDSC4lWWPFsAm5FVWDXOehx9MfkKqm5iVXM9u8iIwJVgV VxWkHys5KnxXP//U/HO78q805biM/Z3Sfy4rcZAlGM4HrgVDazTJb5Vim1sFHHJ/Ov8AXyCaep/n hfW5vxXNmiytc+c0xhBg5xCCDzn654rCkvkubtojayR+UQwcRlYnBGcg1dkdKk07s6HRjcag160s EFxDxZW6iNk2BQMsD65/lTNSsLaEWUNtDI0skhF3hMgjPb6f1pSjdGkZaNloeHf7anFhBHNAscRn +042nKKWOQTzgCq2kfZbKwuVize3ZLbp54OUUkYEZ6jGKnkVvMFK5//V/IuzngnuXmuJHtjAQnks pHnZB6eoFX7m4spoQunM0dzCxaJAhxIc5zntX+vigup/n+ZE2qs+byTY1wj7ZwoAllfHOR3B9ay4 b7UGuLVQJLRbu6MG50OUHXeQBnbRFNXIm9LHW29jvkE5na4Jcr5gG1Mjjp6Vn6gZBe/YpgwBmVY2 QEMSTxt9amT1uwg9LFny7zSX+cP5F5C0bhlKvIhPJHtxVWN4EijNvaL9jhmLzu52jPX8xjisU3KV +h19D//W/KXT7uWBNweTF6+y2jIzg9AMf561qX+m6jd20AlaeCJJjggERsw6qe3pn6V/rhUjfRH8 FxspPUp3cdxAEtIUKoU5fB6+tZyaXPDCfMJcyZYFvmbBzUtNJoWl9yWDTooZFlni+cpsQt0IJrXu dHiXyZdOtxcXbr5k8CDbuZc/nwKuMHynPN9jnNf1oXun2yLaf2fe20xW4VIB9zcmA3rwCM+hzmoo luUAmWcR7YVk8jJ2y56cYwCOuf1q4JqXKefWb5bn/9f8kZLu8u4/tL3ItJEk2LG6eeLhfr2rWsp2 eye6xNPabjBOiAoZv7yDPciv9eOS0tD/ADvpNeyszmW0eWCdYkaZI5QZ47QyDaqtj5mHqBitG2lv rSQ6bqYF1p8ERudNMV5hk3EcMuD0OcjjtW8dfdXQxmrakU0ry3izOqo4QI3ygZUDCgfkPyq7Paz+ QbmUC3VU3xEqQXGcDAxTa1syoPlTkX9Ms7S1mL/v7O8YAv5zB4psjggY4HPQ1PcW3lCaZWXc75Zl +RDz6dvp71MU46EqSlJM/9D8s10y/wBRjaWUp9itsOfkO5MjsAOelZ8bxTB7QTSFMFchdkYxxgD8 6/1+5dXc/wA6ZaNjtDnk0iW3gvrgTW8TsI41G1XyDgN+IqEahdTXMqXUX+kvOfI+zPiJEJIAJwCe 1VGnyrYlS00Irw/YZ0m061ntbqRWivZ1mO526ZxxjI479KqWsd2jhYRJvmk4TJLFie1AFthqhFxE DLMbOT99DjcUOdpJx1xkc1nagl3CE3I7xAjzOMOKbCKbdj//0fycs5LWXzms4J5rq2gDNCIyCu4d QTwfrSSX5CXMEjusgjGwYxg+lf7AtcsLs/zou7WQkEkrLBLDD500HWRvl3DHTP41ftL+WaG68xRF Kj4Eb5DsD6VVBO7fkTy3dxyWUlrHJqIjdWUbjIFLJEM8E+lTWuk62LGe4nuFurJ8yGCNMOuf9nr2 raerS/rcyk+WsrlvymeNbaNTaBI93mkYXIz1HUVlQsWuhA8UiFoyWcNs6A5IP501Ft2ZjKbbaP/S /LFBaS74bg/NwvmgleR05qjdxR21wrxSDY4ETuOW46Yr/Yr2buf5sNtqzFZMSCUFZBgBnQlQo+lX bIKt1Ct9ax3DxXH2iApnJTblQQc/ia0hGytYznO60JLnUb0RveTwQb5mPmWoUGNBk4GBgdPSsQyX V+ZZY4Y2kIxFahtiD0A61pysmEktyvpNvqWqzXUc8MMYDMsCRArvKD5kAOct7Ul1Zu8Ki2t5JFjO ZhsKeSBxubPSnBWlqNz7H//T/I7ThKFn2q0ckYwu3+Ic56VHG0UTP57MqzyjloztBPGOntX+zB/m gnrdm+jWjSpa3ESC3Q7JASCXz3z39qguILeZBYtLI1pFP87qfLd0BJxu7DtSaurHQtHcYLW3eR41 uFkW1QGCESGRpT0A/D3qxItza27rIfsjzJmSE/ePcZPei3vCKkVozrBPHJAhUhZvtDhHmOTgoOp4 x0pNdt7gRwnCvaum2Zgc+UR6j39fapcdWyofEf/U/H+zhvInjee2f+zrlS1lcAh/N2kq2QOnI79a 7K522thDLb2gecqIo4EYAytkfMfTrn8K/wBkrN/I/wA34+6uVGUGkixHeHypuXCZwn0zWcZr4pI0 lqyukh+zgMHknXtge/ua0i21qRO6NC3t7u1u1kuGj2AAz20iZAJ7fzrP1COJLgjTbZY45G3ER8Ih PXGe1LlvJN9LktWVyaB3nc2twIZGWPPPIQAHHXvxRdWH9l2BvjtW0dic/wAbEEBvyyK1pxs9jGUt z//V/Ju1nEdvPGscc4uY9o3oHI5zwe34Vi3mn3F40CbBFsOSS+1PxFf7RpPlZ/mc3axPKkKSQ2lz CJEwBuVMoT7GtS7u4CYxkOY1EccecFVHQAdhVQgoxsKDtJsrx3Uh5jXdCjZkgbgOO/PWq1vBa3F6 6vNHD5x/diT5VB9DgVrSi0rFSnrqy/eWlzYW7LI8Kxn7qxuG3Z6dPWucF+UlVUjEIZPLfcPvHOc5 7Vs1eVyKjvZn/9b8hIIftRujcOQiopjaF8+YR2I9sVUvoGu0QTEstuuY4mXG8joB71/tvFWVj/NB boqfZppoILQxkGQh0H8Se39KFmvbC5lsmgyAqpEvOSx7t7dMU0r6Gkm1saav9kSZ5omibZuCx9Ce 5Pr3rNYRSTG7jmnuIJI1xv8AlWNtoLAD6k1rGNtzKUu5nz6WoKX8d44AVnMQTLAjlcH3x70JM0jo Liyk2oBKlw4ILN2+X6c5puKvdFc7eh//1/xXkvJmvgXZPK27TGeAnuattam6l3vO6LBhlKcr9DX+ 3zjdn+ZXNqZiO0d4l5bb28slVGdySZ4yR0rWLSXzIkqeVscSswOOVIOP0Fa2Sjcx5m5WLX9ombck cowDggjH4ikhuPNhmUyKpiyu/OTj1rO2ppppbcLPTdNKToyrcTPGSpAKqCQcHIPbisldLuwWMceV X5eu7ZUwT57sTfutM//Q/GyC3mhDnao8pPnZyFfPTgUsIlnhmYYES/MzMeM9OK/3Gb5T/L52tqVR CnmIFmC5O05PyLz1PpUc8oihbyGhly4Rw7YIHcion76SRlHSSuZUMkGZI5EKhH2FQuA3Tke3+FXL ieOx+eKPKsmNwGa6Ke5JFGTcxux3M6guFBwR/niq1xYzLIpt9zyToDuc7th6YptXmXDc/9H8O5LW 8hdIpgWOdxdfu5qxGmyQyKnmlP7wyAa/3MS5ZI/zBvpYu2txcbGikjDoWy0ZHzN9D1qrc6QgPnwK 8eW8xlZycE9QPanJ20EotlO4jndYbe1dVdiSyvwCMdanuLVYFV7UyfaUj+djwqt7fpWE02rIcY2n fsWXuLp7eFJlBJjG5x0LADNUo7+4iTyo+VjfgMNy/QimlaKM2vf8j//S/DzbI7K8DpE7/M7KOAeu BSW8iy7VyscpYiaQ8bsdDX+5TSVrH+XV3dnSWOr6zp0fnwgSWYbac8xP2O8D2Nc7deZf3Etw6BEZ 87U4VcntRBWkXJ3ppLoJK4hQW8JVpSAxl25Kj0quJtsbwviRiQW7bK6V8PzOfXn1KdzutYXnRmQZ G1VG5jnjFI0wMUMRiUnfvdhw5zgc1qYyV38z/9P8KJGRW2xRkIvJOO/cVcsLmJJ13wo6HllY7VbH TNf7uw2sf5YtiXNwbprhjYQ2spm2qIJDIJEHAI9P/rVZlYQ27RJF5YyMF1/eZHqfx6VMl71i6exB pyTyXMpknYwiInyyoOW7EH/PWm36XQVd58tfvqB0I9qte6ki7DoR59vHcTLtKP5aMec474qk0bxO 0KsQJW3t6N7fpVAf/9T8MDZR/unORtbLoRg9e1VNUEheNLcoQD8zEYOK/wB4D/LKe5mvJsTBQvKG 2jA/CpYGkL7e5HI7VrT2OafxFkxuhzHgBuoHQ4qMvLkxElVHOOxNWJPldzNmaYy/PlQrfKV5zVyX T3/c3azx7CuHhxiQHsTQbn//1fwYU3G1YBnYGzu7Cqctu3nLIN2IudvTcRxmv96D/LGLs9TQCTRy pcK2+PysyL/dJ/w/rVeWWDLTP8rjkLjO6pkro1ui1HfRajGVMoimVQgXH5ZAqBrMWDObm4S5fbuC wH5F6d+9Y2toJySHwJb3EchCkMQNhztAIPesa+jmtbtXCt5DqMshyoPuKCXPsf/W/AFpxBG0m4kL yzHoPc1agTzrdrlArB8HeMZII4r/AHgtfQ/yvKMkbqQwz5jHC0jwvA77mdpJju3Mfu8DgCtIxaeo EvntEgVQxPQjHWproS3FmbdQsUswCpNt3eV71bjcC3FF5WmrBLLEbqIDdsYsX45wfTNVImMkYZg6 Y+XaeowaGlawLQ//1/wBvgHkRAr7sZMnbFRNBJFIsMhXcQGADAgj1r/eg/yxlK+hLPZSqV8lWkLj 5Uj5J+taejmW3ffgq5GCrDigkjvrYSSFSqrubcSB0OaZDZs6qguQsiPgs67lx796LAJJFLE7IXEq 5wHXKhvoO1LBbsWMasQByWbnPtSaT3Ic7Ox//9D8FHQ2yec6FSXCIf7xPAqdJZ5CU5jR12vj+L2/ z61/vJKHVH+VfOBs5Y4lwyFc425xiqlvaqJZSUIwM8dGrMmLtK5YshCsx3A7lyV3jcAfeq86x7nd SFcsWIHAA9BQXKS5dCpDIJmKjjnBYjgVyvjq1K6RdNGQ7tAYwz8QRE/xHHXjPFcuN/3Sp6M6cuX+ 2U/VH//R/ii8To8msajcHKbLgQYBPlsqqACo7DntXJTrgFi0zMuAoA3YHtX61xdf/WTG/wDXyf8A 6Uz5fJbPKMO/7kfyNeKCDyxJyTxgHhs9apSXkql44wuc/KwH3elfKnopXdhYrq5EhZR5oxhzjGK1 4JQYxv3guSc4+6awqK90aKKjqPS4Zo54shtvQkZIFS2pJKIWZjnK+rc1zFn/0v4sikY3szbJU4ML Aqfr/L86SO9nZZIQQMLjpg45r6HpY4or3WFtOXilgkGz5/vBvlq0ih8RbgCW27mHQUgZEIRZuizK ZFDloyTxnNa+mvGZW3nbG5wN38qi7Vomzd22S6pCyGOSKVXR8hkB4ArFYPcS/ZtrLsUMkhGIz7Uq us7mWsaSgf/T/illuZrZ5YysjEJtZQcDg9RUdu93Ipe3JhYfNvKg7PfFewcF3axdlWRo0ZQZWK7W k6EnvwKj+eO1dC7MWIJz256VLjdmcNLoRmaOEyhsxkbD6g1l28swfL3BaM5MUPRgT1zWfIyy3BDN dLJAqSyKBjaD8x749aryQMi4kGI04O4nd+Aq4pxTE1dn/9T+JJRtiMQDOXYlVxlsUqwmMoJNwbsv QKPevSi+U4Fo7mzazs0jROiG32gKTy+e5q5dW7rF5kAVt3ykDlh9RUlylZ2KMEd4JIzGm/ByMj5f XnNb9nFPOZFmbLnJXtjFBMvisVJLeYSAT3QmmIxjptA4Ax9BVGVpDJhYZCsEoR2XgEmn0saxVk0f /9X+L4zvEH8obiSFjwcj3zWfbTXIugVRggkKlkBwT/ED6V6S+FnHFWlZm+sYZmeNiOcZZeQehqC5 WeJflcTEjLOBgj1FSaWtoXbYM0MWAobJWV2bG0HOP6VciJhVlMnmFW+U56D0rOCs2ZzWxehkkcKW xknaN3AAqjh3kcMAAHPI5yAeDUW0uatH/9b+OQ3SREB3G8j5VBzmqxnlllVoypx3zksfQ10AtSSI XUG6WQpgy4OG+Zgc4IFO/tBo5mICv84CqBjbx1zWkldnOvdlzF2S4knKmXKgjoBg/jVaK0xIJIZH eRuChxtqHuzfmQ65M8JRCMxDljnJBPaq06qhWTu/YdTWc9jA/9f+N+WTdFGCZI2HfGAOeKqrbjJd ZTIF6jONv+cUWsc40TP55EfG5du91+WrsFkyO6StvyNySDjj0oNJ9CxFH5TtgKuzkHpvxVsyi4bK howi4YAZyamSurGsX1KJt2SUOeSPXjZ710emRvchoIpo9zcOWcKAKXIhq1tT/9D+QCWCW1cb8ZDE Aqcg4qCSSEziQ5yRyDzgjt+n61Eot2SKvo0TyxzSKssYMauANwPY02VJYF27/MIb5G6AjFRGLZJR aY+WQJSjRN0UZ6+tNnjkmhBmdtzDgqNpaqSUW2wL9niQjeREUAG5hwwFV7mZWnKKT5Z4qeZ2sNNr Q//R/j6jdwwYBVB+Xeepx71qRMhB2s6sVKuc4B9awWjNKfYymRY1hbc0amQq+O9RTlC6qApjzz6m ra98u62LrXTCMxJGChHzg9x6VpWV41wYjHdmONP3U9uzYJ46Ad6zsY1ZNaEzXNvG7oBwp+91Un2q o18puWB2hEXIctyePSs57pApNLQ//9L+RlJvMAcvkZypHepVlaInbzu5b3rzyuaROsqvDt+7s5OT nea0YhBLY3DLOkVwqgopGGl5wRTS3Nua5zCSXkNy/lAqVAb5uFkP1/Ct3y7m9ZbmUKhxtCRncuB7 0iuZogeNxMrCV12tyqjIPbmrE+4NHGTuLc4Bxt/Crs3FWJUveP/T/ke4tw69ZS+Bjt71rQL5kYzn A5b0JrzKu6N6bcU0ivqBmkkWFY2AUAPn5QQcYNWYFdI5BJI03Hyxkfd+lYR6jKM14I2GI285cKzM pAVT6Gr1uGOZUbaV+YSA8ZqgES6knuhKZDtLc9smujErGNhu5xlfb60nswP/1P5m/h/8cPG3gvRL zQ9Pgt7q1vke0nF0P3USsCqyIgHD8kZ6HuDXn9yJ724uLycL57gyyrHzvPOTivASu7Fzvcz/ALYt syCJzCXXBz196tOlq8dpJbH7R5chkklkbLtJ/ePuKqSSaSHCPVkqW4mzJtPLYJUZGfQ0qiKIt9ny 0ajYyFNgVh1o5GaD5oJJYibdcPtyUPG76VBo2orZTq9zFEwSbZ5cn8RHJH+fSpcWtwP/1f5XrrVb e4vpYEt2SJvmHlrviUk9M57VS/s+xjkSYjEgJk3AASZOf0r586C8zRylFSaWIJgyMFyre1WZp7GJ I2WQmaR/LK7CB064oIlK2iKMkqSfKjNlDw3QMfT8Khs57mG5WMzFxcvsVXIVIh3rKe9iVNmmVW0k kmBwpbczdiemf0FMklLo8lzKX+cNAo5WMCoHzn//1v5Xlu2MmUG5B8pz8pA9qtwxC3Rp8+Wpk8xj n1PNfLm8anQ2Eihn8uWSUrBGwlKRnkn0NUHaCO886EYgfJvUC7s5ACnHY0G0Z66mLZxyvcXaSq7Q NIHiEnzY7/kO1b8kkP7iNlPmAbUIPzN7fyq6e5al2YsU8u0gqCADtcuAT7YqoTidTP5jrkkKpwc9 vrzWoH//1/5XnlcG4kMcsjAhAipkRc4571r6dFCySpcuTIq74lK7NueAM/gTXzk1dXR6F7EEIngn lVpUWMth1jbcqZ64PXpTEhttPlaeJzPC8pPm/e8vJ6CsbK9y1NpWKk9za3NzFPCtxEYDyrSkKzDg tgY4PUA1es7j7dO1tBLHOS+0MzrGCO/J4qJq2pSqWZejv1huBYF2IgkEivDIVO5SD8rDvxX9G3/B IT/gr1dfsy+JG+HXxj8Ta7F8J7q3ENs2sbrqLTMOvliM7WIG0uOuQAODgAYz96cEdNKdoT81+p// 0P6Kdd/4Kkf8E4/HtpZ6vqPxd+GOprPscW+r38Ejx+WMlHWRQQc5wD61zlz/AMFZv+Ce/hjS7x/D /wATPAVneAM9rZafMmnwSOoODhEweBwcdcdeh+UqdD3KU9Gfxl/8FFf+Cj/xW/al+JXjjRLD4lat c/BqK4NtY6Xo8b2drqEe8uikuobChsF8c5foCAPyzN5k7ZAESRAkbdQoHTk8+ldiklQ5X3OZ3eIv 5Fb7RZWcGoWizxXUs6BYp5Yt8lsc5yp4x71We0nsreGNrhLiQxiQyL3Dcj+fSsIrkb7FVJX0Mmef VUuI5LZbdTtEUweAfvY/T6+9bCRxyWjJMWMBYSsCgO1l5HX6CplJJ6mVj//R/ljea4lhRYAkUUbt JcJu+aUYwvHtVSZ0na3aORkIO1tq/JgdOe2a+S52j0CZYJbpClrKPLUlrl92G64wP61B9iGB5ccV v5UfkgovIX0H1xSc20FraGrYOwthHJtDE7dwHQZ4pmqDelpIbi5WK0lLbIzuZuOmPQ9fwqQOetfK E0lw0TPLKxUI5+52Bx7da0HkWYpah5XZBlpDHtRcnOFbpQFkj//S/letlNtvsdPjDiVjNNM0mIt/ c8nrVKR2S58pgZpidmY+VY+or42Xws9AsRW80KL+9ZyOSGHJq7bzyyGRcEKoy2TgD/OKxAuf2bdK ltc2VmlxJNkMIsEIADnOOf8A9dZ8N/b2N8lze6ab2OPI+z+aYnjYjGdw54x+lAFB7ye4vblmOLV8 NDChLC365B9e1WWtkVVnWYtBt+VThRuHX3pSV1YD/9P+UF/sl1Amy7KSSXDCRYxjYAR3+ufyrea1 hePbLIkqhcgsQ7N/jXwcY2kehYpmcsW2AO6fIoI2jjpVfcrloiAkg5KjqprQCxcRXK8NIsatF98r uU4x1Oa0k0O40/TYNWkuYI4L6Qw28SupnUpncxTOQPT/AOvQXBamF9mEcwmkuPtBkclWk4kVvUfW r7s0cbtIBtUZJUZbj9aDS2tz/9T+VP7QLu1jQq8JiJKGb5PMz7elXbZlESFo0DFdvyj09K+Gutj3 IRtqUbqW6bdBGrqjMGby/md8HgYFaxsoJI4bi5ZgsIVnTmNlfqARQlZWNDOvoLEOtzZRXlpKP+Ph xMzrdZ4yU6Gsi0tHuNblxqZis7eJDcW81vt85z0O7kjH5cUwOuntrRIUcrukjcMhRdxJ46n0rn7p rqWW4EXm+RCFeOFE3Zzjdk/U/wAqy5Hcwbb3P//V/lLM92n7lvkjKZOACD6g1TvLeK6kitbYCIyo FTPRWA5b8xmvhoqyPbgtR/2m5awmguZXktbJTAs0IxLFzhvmHv09K3rS+iawifcJQyeXGWbJxjH1 qJrqakEUHnErPErRtwzMPvAdBUF3cSi58qC1JjVRHtKE9BycjoOvWswJS7SW7wtiLK8N6Yqppl/5 /m28wmilt1ICgfu5cEjg+vGce/eg2if/1v5Wra1SaONokmhePfLceewBcdRgdu/rWobiN9Ohtp5f tIt5mm2MnECnHIP+elfnzkon0c1qZMl5pYnlht5ZGuI4wZINhA+bkEevFZy209t9skit7Z4ryMG1 GT5sbbvnJUdOneoTVmKCvJItQHSCJbOWKOOScjzJV+V9wHA98+9atpdx2y3VvHBBIs8ISJiD5kTB slhj2AH4ms4x0Zta2hFaahfoLiWUR20ds/7sI27eoHLH0zzxVy2ku38u4uhHcafqaM1pcWiEKrjO 5WPTjjPvW0FoTFWbP//X/ludntNPuY4o5ZimXjC5aU4ydij3qDRrlbVra3uoZVa7zOx8ol4M4Yh8 9MenrX5+fVKN0zWkmjjmuQk9xcRtJuUyDAT2AHSh5LaLyy6tuYfeCkqn1x0rosDVjTSSS40u7QRf aAkiEPJIIti+i+v/ANas63t8lVyqD0rWnsVT7GrbTxwErM6bU/iOFAFfQnwM06eW/wBReTzLo6hd pDZCEZkBPlhVUc+//fQr9D8OafNxZhF2l+jPjPEGfJwziPRfmj//0Pnf9lm3vh8XfDOnPBEb6czw tBPlbhlQKyqV7YIJ57qK/uI+DsUNn8O/DtlDbR2MZs40e3UbFQiNRkfUAc/Wv1DxznfijCw/uR/N ng+E6S4YrS/vP9D+VX/gr54pfUPH8Oj2ImuYszxzbJPKgg8mUfvAfUCRQpHJxX4A/FuO3j8L3t9q FwbGx8p7E3EK7pd0kTgF+cnOQv0Nf0r4fJ0+B6Ef7l/wPwfiKfPxlWa/mt+Nj8SPFVu17LqUi3Ul 3FEDMksvySYOPvD13E15nb2aKEuXkDFWKmPo31r+OuIZupneJnLdzl+bP6PwEVDLqUV0ijpLW+jS RY+UixxuHBPof8a6K3uLvyzEzeTbyyblCttyR0I718zifiOyEUlc/9H+LOa3mufs+MR8YSdyVXPT 5valtftttAYoyEleXa8kCbmAz94Z4zXz1bc7oxstT1Hwsur2Wqx3RnMltcQqlwHfMrAAgY9CeM/S voWSOeD7KPs8khnUNC8I81DkdSRxXmVtPxNFBs19Pl1JS9vbcXJQlUlXKkdSMU55ZIZBLd74VZuV dSN3OK4zVKysdemyCzWewnS4M6/vYpFKrB7g45rKL3QljubdyYGzFOU6H8c+2K5p6T+80u+Sx//S /jfsoWaKK3WKTyv4ZJgUdvwpDZ6m2q3Vho8bNfw2QvGS0lVZQmCSQScE4B4rwGrJGVkou5hTQXS2 nm3MkstxEwE0d06+cdx5Py8ce1adtaWF/ZOftEyTeTmAIcbnVhkZHoAT74pGFM77QY9b8SvZw6dZ 2ctrHIIL1pbj7G8gHy4HHUkc9K3PEM8vh+9sjceFtDWRLn7PLLpd40qFIwFDMc53AdQMc881vD4T sUbLQvQanYTah9nuStq3kG5hgkJ3AHIXbnvWBrGjpcbhNLLNDknazYLKeq1rS+M0gk0f/9P+PbW7 rS7G2G9FVILfYpHyrEB/D74FeRa5cxXkbPbqFtPLDRSYyZG9fbtU0v1N5xvBmJ4a1++s7mK1klW3 W6uPs8Nx1KZ657YIB4Nfpr+zdqVxBrMMpK3lrbae93BLeRqLVHSLlB2LfdwOc5r9Z8IpOHGmHt5n 574i0+bhOs/T80frN+xx4lvbD4++H7i4iuI49WVLGGVYALB5XuEkw56ZKoVAH981/oCfBxJ5fhzo tncCFpLWxjke5gG1ZFK/KpHqAuK+1+khBRxmFm103/r1PW8E/e4OrtdJf5n8wH/BbPR2ttd0jVor O11F7fUp4Xs5rfBu1AV4gerErvUj3Wv58I9TF3ctEttBbwKoSSZZCiBiOwI7d8YH9f3rwMm5cBUL /wAz/JH8p+JtOFPjCtyrfV+vM/8AgH//1Pxg1Sd4dTe42texWuYopHyyYI52+1Z7XV3Gr3tjaW8M gAInCYMK5G4D2PSv9cYfCf53VtGUhdW7R3s62cU95ck+bJgCK2Rh8xUdiDyPStC11nTmXT9KtRPE 8FqkD+amRcP0xGR1J/rWnLZIuLsyOGC2W6uVi8//AEonzFmyUjxgAj06DpWo2hNcfZ55nbdDF9m8 3ncycbR+GOPas+aPO1M3blFJofquh6tdWsEUeoXDSyKLazMTZS4OMCOQDrwDx7VPb6XqOn2JhY7t qfvRtx5JBwc59yPzFQ5QWiZ00ud7o//V/GibV303Z9ohhnlTatxFM+2KNG4LMRznByPX1qadnhZz DI00EqC4jghcHy1YfLk9cjuDX+tFblurH8EQ51e6LUU7XGkxRzuXWNsqjKfMIPOT71VZYbS3dYEK CRgARzn6/wCFaUzCV76mbBa30gvZEaIxJHnLDMpJOMqD9c1csntrC1Y3YN7dyyAmdpiFA4wAB/X0 FaIk0pBpkkCwxPcLfXr4liKboYBjHynOe2Tx60yW80mzjs4rcf6bEGt3DDHOeWH1wK2ailci8j// 1vxlVZrecyfZtiySgSbgWWTc3NdNazalcfaJks5Es7RhCLtVJSR8Z2IRxwDzn8jX+ukH0P8APy8m tUP1a2spdNiZ5jLdSFoZ7O4ARAh/utkknnpgVzEFqlkm3YUTogHAwO1aeREYts0Wh1LyTcWbQeW4 Mc3nfeQ4+Ur78GrlhqDpNFpuqB/tEts06TKnmtLj5V3D0JIGe34UrrYqp0NG8VglqL+J0kslYKIR 5IBPIDeoFUtSs4tTtILiOd9PRUEM8UTh2fAUlgSOhOfpzVRlZ3Oae5//1/x8lEa/2c8UI/cEpG6d IMADP1OKabcMsyMX2ynaGHLA+o/xr/X7nif53mbJcsHNm9qytDGNlygPk3JyepJOCOOOmMe9aY85 UhaYIUSEE+V8xUY6UOaRuti7pXiCazudkemTTWkOXuZGBVI88AnHOMkVXl1a6YWtxfr5UdxOwi8n L+Quc5b0GMfjQpJjOsjubVlgt5ZHaWYEW7oSueD1Hpg96rrpt9afaoLeWK4s3txMxBHnAg7tufb8 +Kd13A//0Px3Mokv4ziYGNWXy8YQ56k+/FNvy9uE+zt5bEdU5YZNf6/3R/n3z6nQaZpn9pxK3lq0 iJumO3YynH3mq2l3bW9zDBNBvuYlKJiPeu3p1p3WxDfVnU2kmn3litpBANPeWYxyXDEyMmCD5gXH AJJ4GeBXKXyyG/iYTRXrWE3+jPnPm7TkMq9e2fas5oUZK90aBvr2+FzPfwSXEzSbLRnT7hONw/3f YVYg06yd1st0YneP7R9myMyLnBwv19q5FPlZ6lOm5U9O5//R/LKPRr+HVbdI7e78y6Rp9KjnjxbS lB84V+zAc469+1WtF/tOR7i0urZ7a5lR7iCK5YlwysQQVJyBxn6V/rXLEQ2ufwd9XqdEbsv9nzxK kF1K13bhvtwe3ZIkIHRSRz9aprpwvCsUFwY5LmPETMjMPTioeJp7XQ/q1XsdNN4Vu5bXyfsF072V sGzMpSSXA5KswA98VzQ0fUbAyyrcB8KsogklUz2i+hxwB9TVUsdQqL3ZJnPVwVeGsoss3+l2k1yZ 441W3cKZDJErTyMQNzkdDzXG6ha3K2rtPlmilaJb3Z5ZuAOhx0zg/rXZSqRnPQ8yvBxi0z//0vyS t9Nk1K2S3knIhinWRDGFDAqwY5b3xjHoa2otCuHF1LptxJI9jhneRN0EI4yXUde359a/1/2P86oO 1MorYyQxXurS+Zc6mYjCTEfljXqWC/h09q6DSdKvhaS3tzpc1yRGjqptg80yvyAuPzxR7WNNvmfY hwqTS5Ffcil0n7fepd2wt4YwpWSEhhLAw42lT0PBBz6VW1J3tYraFpBcKZNjOuG2eox14p86m9Ba qDTGTSReeqxhp5I4BOVHLDjBz+PFYdpqeoQXclveKbq0uCBHGsQMiOD0XHNONuazCnFtJn//0/yr k1LVftL2FvrZ0iER/OkMKzG+Bx+7yc4Pb25qO5je3ikcr+76mV+Bn1r/AGFXKz/OScnexm2+nSST q93KRFMQ1q6rnIx3/EGtNYEs1nedRPIUIiljfBjPbI/CrIi7MzxcbYTG0rT3DLuZhHtIPYYq81jO tvbTi4TDNzHn99Gw6ZFBsWnju7e4drMutxLF5N5/enJ9T+FUYrLUb28AumMduv3ieS2OgUfhWVTR BTTcrPuf/9T8w5rJre4hvLe0SO1MAtZLxOdzLnClR1JwelVTai9V5xahxCN+JITG7n0IIz271/r/ AFqkY0H6fkf52SpvoRqWlhAW3+y+WxURnvjvUsOny3NubmKEGNSwaboTt6he5PsKuhUjBpt9DWlT bp8yQlsZru3cT3F0LNULxRqPLEkat1I+vY/rS2rX8s0hi1OS4s0Qi0jlURlUxwCc/WrVaE8SoRfR /mjzJqSlFyWr/wAijDe3l9LNGkY8tCP3kT+YpH8WRjjmrd3bXQW2kmlby9pEKhMbR7/U5rqTT2MW rNn/1fyZeG4WKWUK4MTYIbv71QE8smyCVS25uGzjy/rX+yB/ms1pYvKlzEG2E8cAkcUkeyKFJ5bq T7Q1wUZCflAwMc+5NawatYwLEN1JcNNvjCwKSquehFIk9xbAT2UMZkhlDM7gkYB4I7HnFU2lox2Z FD/aF9ciSKGQSO7TzyQJtCN1BAHrVhLo5lkuS73Ej7ZlOEXA6dPWs1N31FY//9b8torBYmjvYVZF mKho87o2Pbj/AD1q7qeni8tru6eCSZ4SBJb2EAm25IHRemPav9l4u6uf5nSTU7HDy2ssV2ibJIk2 GSOJo2WTC4ySD06jitCO8H2G4ncKlsHWEswwSzHGP0/ClRfNCL9DebcSK1nhgdls/LmuCu6Y9TCM 9K0LqE3tsLudpfMZ/LGfu8Ad60l8TIc2YVy8lu8G6FLxrYExRtycHsPQ8V3EsH9p6MuqWdncny2i huLV+MluG6+mCcf/AFquXwFQk+Y//9f8lnjntJ08iILbhdoiP3E//VVy2lgefeW2MeGVmyqnpmv9 l3of5uwlfRglg+pS7bWVZPLuNskszHykPB2D39q7G00K5mje6W13pFmKFyPldl4O09ODxVxaV2zO U9bJGNr+myxSQoHjZ2AeZI2/er+FZH2eWCGaWGNZP3Z3B+oHqPepbXMvMmU7rXoYSyTed5gjKgDD 8cfWtxZVG1pYkmtpl+z+U3zj5hy2Ox/wrpVluYPdn//Q/LhrG2s0t/IAMLKzSMDuO70/+tWZeqja csjuheViGCn51w3GR2/+vX+08Wnsf5kSeruZFuohtpN8mVX5k3n7v0qg9tcIwuGjJSVsq3RXHfH+ e9awVr3Ki+W5ciEJafa7RsY8ohPGaqRJDE73VwGMcI3FlGfxxWhL1dzXlvLa9NmEDzwwzLLJDkxs 4HX9Can12WCcKNN0BbazhiDPdbnuJHJP8eeFPpimtBH/0fyCt/LtkWbbJsfgjb3qR5xfIwCqhQ4y PvLzX+3B/meQrbSxzxXNq7G6iGF+Y7T65HQ1peVKjGe5RA5GZGyCzGhaBKTtdmfdsZlWWFfOMTBg GHHvn26UtusbCTMaLkhti/c568VundGLk2Q3ixhRCjLnqGXlRUD30d3bPDdXxZrKPy7VUj8wv22A 9sY71ulF7En/0vxfmsrZWgRd5DpukeQjLnPP9KnvJYYbeJIZfKR8Ruqn5j2r/ciyP8xlJbE8NuEt x5ajah4I59zTrVkvJzYORH56mHeQQASMZNTo9EZtchHBoN5BK1v+5YWqFEkjORcYyc5NOEC28Eh2 KjMPnGc8isbx6FzUklfS5Usbm9VBcRQjy2fbgDDAD1HUfjW5bpcuWliDFj1UUqbXtHcJJ8iR/9P8 aLtdRldJIY3MQuBBcKqEyKTwMj09T24rcWGIRNbTjA+8COM1/uM3F7n+XUubqZ0tvZNaT28EO2JA SrR8cj19e9YtpZRICJZdoJzlmxjFaQSbCStYZdW8KuHsnSct0jJG9SKS9tbu1ska4QP5pIV0BMa4 x8ufUcVqklsQVdPW4lGdqx+WMu2eBnjBpwe6hdmgIklLYGSdmM1ooXVwP//U/Gwr5fkx34VPOjEq l+ODnp+tZt3IsMbxW4VgTnIGTX+6ns/M/wAu4yd7MIV2xebIrFynG3g+39Ky3mv5NsCq0n7zdJtB ZlHT8O1S6ehvBtOxOhVZu/nxnGCMbTitRLR2Rg8wiSdeX45IOcY/CspwShccHebQj6Pd+UohxICc oM84zjJ9PWq8Xhq9WX5tpD/OWJ+T6VDa2RlZpn//1fxduNINrIi7CZ8GT7Oo5K92rMTTLe5ujcsJ kjQbGWIZXPv1Ar/cy8bH+Xbg7jJBdW4aCNc2pyAR1I9xViCAG2Ef3ST364q0klZGcZOzRlXdq0Lo w4BOCTVeO3Rnkdm2ogwVPVz61vC1gKkkjvMqBcoD0xwa0w9jFKtzeoqscJGoBwx7DAq42vqYN3dz /9b8N382SIs0CokhOMfwiqcVjJcSBYZFUgb/AJiFyB1Ga/3fSS2P8ry3BAxeQysVCHbkcsfpSPuk dEmkbCjgyHlvf3pPluXB20ZUZtgNxHKGKEoI4z8/StINcXtnAdhdt23ZjJQelKTVkzZFhIZpIkto LWTcM4G09R1/GqUkUmQ0iNFKg4VhtdfqKsR//9f8M4zMD8w3RoMs7nBNVrlRFKJJMoJQTErDBbiv 94D/AC2aTKcR3DBUeYW444FSNGYmz3bktj71a09jllG7uhxDbwvICgMy9x6Vbha1mMiSnBAAhY4B B75qyVC6KTqomeFdr44DH+lTCISSfZndQU7g8HHag1P/0PwiYMrMqcle30rNublGkgeKTcBFtmwu 0bs8j8MfrX+9B/lddXsSzXMptY7S3UKZHzI/O9h6D8qcsYEMu+L7qhd7jBJ9vpQMzItsW94tpYfe 9TVjybplFwrRmJxuUfeA9QaxadwLdhBcTyskMauiqXdcYVMfxe2KS/RQrQlhuwQSOeaahdCulof/ 0fwDhh2RMh/ecYO4Ak/Wr1svlwyyOSqBQqoeFH4V/vJGNj/KqUnfRlm2WEqJCiuynKk9V/yKZcxx y3DOilUDYjD/AHgOxNaFKaehKdOWWMyKQAhA+6eSf8/pVecG1BidWyR8rMuB60FlILtfc/BY7d3U 4rS+yJFtcOHRx8oHc+9AH//S/Bm42BRHtBVh83T+dZz20ssm4D92ifKTwQBX+9B/leTwljk7WAi4 B7H6f57U9mkXayZIzy3TFADm8yXGwbmzj8alkt5YdpIAZuvPQ+9BMnZaEbBpJEU/LsPzEjg1ZAYM doUKoyW6HigxP//T/CWORpU2uwMZ5Q9arQsyTNG53KX3A1/vQf5TkoiZbhmkcmBmG1f7vFOm2wB3 gfdGOu7g1Morl0BNPYoTwknBzhgG3Rn8etRKgbPygZGGD8twe35ViAJC0c8axIriQgbRxtNYvj+z 1BPC987Wji2R0UzqMpG5+UZx9T+ntXNjov6jVf8Adf5Hdlv++U1/eR//1P4sPE4mS5mWe3Ane7JM aNkIMnb+mOK5iUsoErYjdWwqeor9a4tVuJMd/wBfZ/8ApTPk8jb/ALIw6/uR/IhhkkkmXzBhFOOm F+tOngVnn/gzwGXv/wDrr5azPWgveSNjS9P/AHCrKrZLcIgyWFbP9mq/yojgqcvG3yEj8a53sbVK aUhv9nMYpMWhTJ2l4xuwO241bTRJIYlutsnyISy7TlvTaPX2rne4Rir2R//V/ifvo5ZyJkeVCwwR KCrD0yKmsldWRJ2yQOTj731r6A5VG110JVHk3LB/nQtuKIeD9KsNcxlw6hkVBjhc4PpUydloOyLl tK1zJumjBQKVUMMAcdakZoIm/duVCgl9wwF+lTPRoZYufIe3hXcSCmZNzfePtV2LUdGWwS3eGYXU A2RMm0o3zZJJPI4OPwqG29yZRuj/1v4vtRjimBaINtZflcDj3H86q2kAZ1jUneRtUDkV7Bw8jI7j z7aYqeIkyF29H+tVA2UYFzucncvf8KCbCSMog8lz+6zu/H1qjFZ+Q/nJIXRgMFhyPb/PpQBaF1dW 0qvZFQxwHOSCfpVeS6leUmZSxQ5IYfKx9aAP/9f+KqF0hSOZkHmyna2FyUFVS3nySblKKjkKxGAw r05rU88jDyRXC+R86hfuH72f85rfW7DoVWEwyMo3MOQSBioKluXtKjvdQv7eysURndwjGRtsa+uf 1rtjBDp0kyXEUMhSEqxGVCE916f4UCW6OceySTfdpGSudokC8DnpmsS6c2peAIY0c+Y5x98nviml d2Nr6XR//9D+LoTJFGyQgEt97f1HuKuwQkwh42ViMn5RjDd69A5I6ybLUjyeSoYKjEhRgY3GprSx lcmMrLu9CPvf/WoLI5ElgITywwV/uk4VsHinTIbUO5Ibf0wdw5oAZb3N0WWKJBIr8Bs7mB9qviPE RIPzZwcc89KVtAP/0f41Jo2CLgAyDglutMt38sx7UAcn94rNjA55roMYu3U2JYUmhJVsODnA6Vim 2m81jFkpBzISp+bPpQtCTUgkdo0UYbDZwx6DvV4XWnx3ICGeOaRsJGF3RdDnnt0pt3dy1G6M2S6F xPJFuEYZyqMfukg9KZ9jkeSJd25kbIycKuOhpW6ByWTP/9L+N+ZZX3KeBGcYHRqbAAk5VkCIwCmQ njPv6Cqa5ZaGUlaKNK7053T5SRtwwwOMdBVYPcxlIxyCdrM3YetJu7uKzkiS7XCK8b/MMB938VU4 prgN+73IZSF6HBA5pG1raFu7Z5CgQfMfll7AjHarFji2eONo5ArAhGA6/Wgdmf/T/kKeKa6BicfO B8pB6VlXEQtpRExY8dcd6AOjjuYfs9skWXdYQsqsAFJHHH5ZrmNUu5HMcUa7T5h8zHRfrSV7agQW tvGZGPmlsDe+R941aDyyB/N2MEBKAHB46D9KGr2ATzDPbgsBCCoQgHG0jHFWRErOhEagnCsqjI9M /pUez8wP/9T+QFYvKYwv8yhtw7Z+ta62sAtiySKP727rzUKCTLp7nPeUxZknZdkTloGzuIzVqKGA woqsZWcFtxG1uDg4Ht/Wrsga98ottWTYpbd246fWtqG2t9qDKxu3O9RnBrnMq25XkhdCc4cA5J9e aoSW4kmaQAKpHIzjNFhpWVj/1f5CbbMMRiZVZByuDyh9amVnd1jU5cjp0z9K5eRXuA+V3CqMlPLz uBX71RRTuwwR8+7gjhaaSWxvFWRtwKZpQPKzhME569qu2ivE0kaBv3L5dCOTnvWco21RSV3YWcSx S+fHE6q5AkJXC59KqTQma4ifDLNJ8qRqCS2KuGqSFJcrZ//W/knS3ZGdXB3k5y4wG59asyS/ZSqH JTZk7RwnWvPrR96yNYrVlNfNeJ3mug/mSFkZF2ELn5V69q0EuFEarFmSUAYbH865zVRbGXFs7r++ IEjfMD7ehqCWYGGO1jHlIDuJPH4Z9KBNWdiWG38mZPMcEbcqw+6T6VrR39nDs+2XHkr5mwEDdvJ4 ApNaWFY//9f+Wi8txavC+nfZp457cSyOjEsrH+E8Vk6lp98A2pNPsaZcOYWxs3E5wPxrwoLU6LE1 jb6a1nMdSUvnC2t0p+aNvde4IzUUOnvZwrE2+OF5DcWxIwSrHOB7VpZXuB2Gj39hpkRbU4wyzFkt I06SuV+TeT0Hqa49prgXEwkAALkoAMDbniqSvogLiX2bd4mi8wR/PFKp2yKfQ+31rJhkS7zNO6yN DKxlAGdh7g98/rSBrSx//9D+Uu2ntoXLqm5TJlC3HfgVbmMlxPuMY+YfMcY4HavEcFa5q3JOxcKQ oiybmVs4EePkbHXNU5/Nmm84CMIi7QoHzVkZFZJhnYNo3OSc9jUd3BNsjlhcO8c6OcDGVzyPyrOa 6gTXTXDvHBM2Ldl3MUG7PtVyJVnCqdx2qNnHHHrUxi2Juyuf/9H+WS3jEM5OFlyMGIrjbj3q5dM1 xEqqgj8vOY1Oc+hr5tQ7gUbaVi4QFjtO3y16ntyK2pILOS0lZ1ntpz+7ldBtVvQg47ZFS4NbG0fh RRhmcowth57r8jbhhiBxmobpV+SRiMDjg4NaRjymtPcihns41ZZphbs3MLSNkM35++fwrShYOxcx uwjlEaybCFJwOfpzVGp//9L+Ya6kEMMsxjw55Py8ycfrXNJPPOsT3ZlhSaTZH9lQNLCuepB+nevn WvdaOyfREhj+zyyI25kdsRs42uw/2hzzVu0uEBktVgaLyl/jUGN856e9YlRTRly2RRnlYM0chwwx 8rH3NTRR6dbwZjhK3O8DdHgRbcHP45xWU97FBbRQRziSCRn2HOW5bPfn863LjW5I0W0jTdvGJizF SVPpWTXvJm1N+7KJ/9P+X+01ERxNbXFtHJb7zNuYbeTj0HPtmpnvbO9QRwxRy2yAqDcxBW9No74H bPtXyUpJ7HrwXKrFXUmngijigtRJaACMQRALHg8c+1aippWp6YxtZyb+wUW/2JYtseeuPMzjOMdR 3qqk2oqK7jhG82/Ix5tAlKyGSJBbuuJ08zEmT2A7/UVatfIije3YK2xAELDLRqOAM5/ziuhK8LGE lZspvP5ksZJMhEgiTPYdq27mUfZI7aGISS3H7ryAn3/4ifwxXFOX75QOiNN+xcj/1P5Z3k+zzXEc thcWgtyEkEqeZuBwC4Izxn8q0bGysY5FXyJJYnYySIfl4J6K2Divk8TH2dPmPSoJzq8pRnjTT022 cc1wonbzgF3SDOTj9f0rLaWZvMKoxcDKq3ygj0qKD5qd2XWjy1GjRjBMakq+SPuJ97PtT2jge2b/ AEos4k2eUVyy8A5ahqzsKCTWpzhhniuRJ1jZtpY/dXHrWt5SmCScORHtBRoyGDE8UiEm3Y//1f5V 4WWTEQZoAcfOOCTWgbKHzYnLYkiG5ZAxV8/nXxz21PS5XsMuxIoRVl4JyWAyQe9Ojs2lhV45X+Ri Zgv8X/6jWNruyLUNNdy/F4nvtBVzp8yQStAbZy6BwQwxkKcjPU8VyVs9xLJPLcLvjJMiyZ59y341 c42ehijRFsQs0hiWISAENGPmY9PmrOuLtIEMDQtOdpKJ2Prmsx2P/9b+TK0jX7G0xhVZJWdQqqRj k/MalkutPsrS7kS5muzBGGR7eJhsbgsoQjJ79K+HPQNa3mgn0uyvzvRbxxFEWQo7MoywZe340jyI 16/lQRogQZdCXc465JpN2Vwt0Fjvd1zdtM0v2ZY0SGAxblU/xEN15/Gti0tdLubO5DyXRuZRiIu/ yxg9cdwf8KZvFcqsU7fS7G2it0S8vb6SOUpcNcoo288BSOuPU1pXdsQ0flRM6Mpw6Ywp7Bh/npQU k27H/9f+VxY2yz37Byw8lAxw8eOm2mqLt90Nn5s8VqDMyJFl4w2AWbuB9a/P435/n/kfSOHup+Rr R2clrbQ6oNskMrm3Z0AZ2kXGVbHOBmqF/MJQzurQRlwzICfXpmvRnStSjI56d7tEMkwfyWT5VPCo wGeKimkiRHLcvL1J+8PpWcYW3NCVLiCO3SK2aQoUG95G3fN3/Wo7a5S2ju5J2aXam1Fi/wCWpJ9f wrNqzsTyRP/Q/lUhjacTPdpLal4t1urDGCORnPYiptGNrDdefeQpcxR/Ku0/vIvcds18RbQ96MeV k0UdtDp2pXLXEbf2hdmIQbgJFGM4CY5A4yeuaz7Ozkh0u4uSiqiXQRHCZjIbOB7HA5qXsUX4L23M O5nVirbFC/3h1FRS6h56BIN0E0eVuScbj6cduKwAfFA08eGOSoznoTWcljFHci4lmkjKoQ6r90+h wBnPFJvlRpB62P/R/lea4jsEnubovKix7ItgxyePm9v61lR3N7JlEh25XdvdSqKGxgn68Yr84bvu fUGz9m0mOGG5eRp9SYCOQwoNhQdgecHP6GmWkEP2iC3uXubYpIXa7lwYpEboNuM5HP14qIv3mgoq 1UpX9nZvq0UMUZuY2/0m3uooc+ZtGAR6VftLfVTqCR2NtZvHCplaOV9krDHzcnrx2zW0FozSa6lg 2jlFkzkRt80avhST/eHfvirMl2Vt44oJT5cGUjhDZjhJxnA6Dt09K0tbQi1rpn//0v5d9OuZ4Z1k beMfMHXjB6VZuI0AZlO5mGd3evgEtT6yK91jLbZFFMPIS5kdRt3MVKc5JH/16c1tevaqh8siWYeb AqncycjAbqDz+lbmYu9YZfsyMyKoCSpMCrRAdQfWqF1b6hHe+ZayxzafwWzlZWx6Dt2rWGwF1mto Z3R7hbpyiythcxIGA+UjHbofxr6x+Bu/zbC+jVEjG4jacRvwo3qOowQMf7tfp3hZD2nF+Ev3f5Hw viLK3DNZen5/8A//0/Iv2RNKhvvjT4IibU4k8QX/AIki88GX5ri15DIh5OSGYse/Nf22+DLK4g8F Rq8UCyC02WyibdFCiRjBz+f5V+meOD/4zGhDtCP6ng+FmnCM5f3mfx1/8FW7ppPjCiQzRC4stYuz ZtBPvtTDlEnyuec5JU9iRX4afGvxBYR+FPEUey8DQaOWgijUO1xcDdhlVuMAE/rX9QcHWpcFYe// AD7/AEP5+zeXPxlWiv5/1Pxl8QXwmuZhLKVlwI7mHjehAHDAd+OntXBeRM7HALKW52DO36iv4qzi XtMyqz7yb/E/pnC+7hYQ7Jfgaltby/OXQOIyCnOc+xFdVZJJcPGLn9wi4+Zhwo9QK8HE7nZD4Uf/ 1P4t47lY3jsZrjekTgvKpBEaHOGPPtWhukimbcxEDPtjkEO0cdxXztb4j0oNJ6npnhm7iuLqKHzU XaBtkJzGDkda9p0e7vre7EdvHO4lt2jSQwb4IOP9YT0BPQc15lXY2Ovs7zULON9lpa3N+U2QXUxI IOMHKDp+FS3U/wBvtYla08uZkxOr9S4JBC+2McmuQ0jFND7e6bSoltIoo1RusbICD7Z7de1XHvNj WcbQ3EYljZy6JmxDgjK7uoIGMZAz+FYVPjQ3G0D/1f43dP1/ULiazhnee58x2S3EkHln7xOFXqc1 t6tHEskzReZYaiiAvcKhTzRjGzd39MV8/wCRk3aMjh8zQXguWiN4XTyGguJCsTkn1HI+vtWxe33/ AAj+oro95p8dtDZRx3Lz2MQuFAn+7gr1A4zjpk0HNSd9T0HTLlfsqw2jtayCTzInjXCMCec1LLt1 u6vLKecWt1bIjW0CyFri5fIO76HnpWsNrHYnaNzSn0tZbeyW9uFa4tG2i8CA+XzyjHrjiquoeaZV V5wxVRGrMeCo4GK3pu0kbw2sf//W/kO1HQdOu7OV9QWSaCKMyhI497g45wvfNeJatHDLAwtCgsxH hQo27QOgx26dKVLsdDfuWOQhgEEsMbLaXkM7birMfNtipypGOh9jX6R/ssWy6rDBbTy3bra2cl2b JMytKypGsYJHA6D3xmv1Hwoly8a4S/f9GfCeIEXLhDEpdEvzP1n/AGcNSNv8W/AFg91Hp9rBqq3/ AJcqhYbpogSsZY9CMlh7j6V/fp+zjqEl/wDC3RZZJ7ibUNQsYL26SQ7PLzbqo2n3Kk/jX6R9JKK5 cNLrp+N/8jq8CpOXB+Ij/ef9fifz8f8ABbqyH2O71GK5htp7WaykkuGIVbUM6LIADySTGRkf3/ev 5g7i6McdxshETRzEOYVMyz8gAx8dD1z71+x+AlXm4DpK20mvwifzJ4pUlT4wxDf9as//1/x8sbe9 ud8iGLckJLx3CgBQB0IweetcHdvf208sMqloZyVUIcJn044/D2r/AFuj8KP886isxjW9vHDEiW5M twStyxk+9jptUD/Oali0yXbaagh+zvDcF7R2wcGMjnHbnpWi3RMbI9i+GfgO4+K3jjwx4GgnltJP E+qx6d9pg2/aJWJX5Ax4XeTgt2BNfvt4L/4IYa94q8L6brureOdT02Brn59J0fTpb4pEUDAmQjDM CfQr+tfjnid4iPgutRowS5pq9311tbp2Z+v+G3A1LjClXdW9otJdLdb/AI/8Od9F/wAEFtVkS1it /iBrkTPMbiw+0+EGV4NnHmMQwVWIzjkE10dp/wAEIkuo5bbU/GWt3tmLpWQ6nosVqJJgR+83Dc3y kHCselfi9fx7x1WlL2LimuqX+dz9Ww3g7l9CUo11K6XV/wCVj//Q7T9rX/gjb4p+CfhvVfGmi+J7 /XTC4lks5tBit4L5IkJESyBdpYAAAhQSM98V+LtzYRpC6W9r9m1EwSG5t5wPNtWikMSpNj7pYhiF bBwDxX+hnhxx/DjXL51KjSrU7XS0urb2bb6avbVbH8jca8LvhfNPqdnySSab8/6tbye9jkdPknt5 vtU7XMUkhNs9s0W63iIzyo56881o3kJMVvdK4+yW6sLpM/PIzMNpB7YBr9ZpyvG58BJLm5epTtrZ YELPemRLhsxrgAqvXBx1qKSwitlmvIGjWzmlw/mNlwwxnA6CuhSdm2ZpRHR6pZw3y+dF5iIA1vcM cGUYx07Himy3Vnf6rPc2OmLPE6Lb3SOjFR0JZffnr0q0TU5Yux//0fyFvhbiSMgyRJ5eBbq24rx2 NYNnqOsaRFcx2WpSPHK7OYpogypnj5l6E4P61/rbze9Y/gJRTi2+g6WFLqC3v5mmN0CVjjjz+9YH BUDp/wDrrcWxnJg+1xzRR/eeKeIq7Ljjjtn1qpOyJiruxcuLdZxsiR4w+SDj92nsP/r1SGno/HmS fbba3aK3fgBASDjP1/nQpJ6ImpF3shqave3tt5dwsU0hwq3CvlpFGB86+vBpJ51xbwSRqI7cl/QN nHDH8P1NNSsc8oO6P//S/IqKS1xc3AjMcUaBTAVOx24wynv+FOtrtFErxxyh0iIyUz8rAhsenBI/ Gv8AXZSurn+eU48rsZmoeRIqRW+ISU2IABkHkbvakj1CW0igtJbTdLjY08alhKw7k9qXN7t0awUp PlNaJrXcfvNOcpIhzn5hndnoTUUmnHXJDY20vlugAcHAMY/vEU4vRNia0sWtL0qSzaOQ3cl1PaNh HlAZWA6EDH6VfntLnczwyyDzMkqp5z1xirbVhQ2P/9P8ql0mX+zpHZ2WWQAbFjHmvg9Wbt9B61yG sWUttJEm7a7oJAFYM4GeCR2/Gv8AXg/z3NDRn1CKVXiw6Sr5TDdtMhGO3rzWnLbyCWUtdx6fcW/z 7pkcyDI4ACgn8/Wgxle9mV9N1MxeZZtlridCkpuV2quepT+f41futK+w+RcabdwXM8ZIlSNw7RqR jhunf36VUpJ6kKVtfM1tKvZrbUEs5oPPiFtFukkIVbhmIDMDjCkHPQdK/pR/YL/4JlfBL45/DnRP G3jnwVZapqN7GtwbmK9aG1uE/gQYXIwxbcw7KOa/HPF/ijFcKcN/2hgpONRvluvl21P23wl4cwvE uYVsPjIpwhFS176pfL/gH//U/oY1f/gjj+zBFpdraz+FtI04W7yNHO+vyGe3V23FYpGT5dv+1nr1 q7pH/BHL9mKyW0utG8P6feMknmn7VqIu8bcFW3FDnJzkAjtX7LU8Y+JFH+NOz/vP/M+Zp+G+Sup7 1GN7dl0+Ra1H/glB+zfexS6beWdrpsc0jmS3e/CWkjN95I125Ud8Ams60/4I1fsxQwNLb6FaOlwi xmZtTe4PyNyyrtwpPqOfesqPi7n9Km0pySeuja/XfuTW4DyrF1XOpBPl0Wi0/wCB2XQ07v8A4JG/ ssw27W76PZec4UwR3WuySG1UHAaNWXdgkY6modX/AOCNX7MeraILa38P2Vveu7tJeG7MlzICBjEp QgHOeoNZR8Ws/oVY1YVGvRtaeTuN8BZRXozpzpxat2TWny/4Y/nL/wCCg37Kdn+yt4vnsNL00SWd /qz20Fuuox3ctmqooBUbRhCVYkZ6sMe35Y6vFfTTTG4Dsm0CGKP7sa98D8/zr+4PDrP3xJw5hc0l e8kk776d97vu+5/HvF2XrLc4xOCj9mTX4/LTsf/V/KO0iktYRG7LDHjKlm2uzH+tbFnaLYWOoB9U uLe9u7cv5gmxDKG+9GffHb8K/wBepuzsf5zR0Vi34At4h4i0XQ9UttQ1eTWNXXdc2UfmQpDuUsjA 8YVc8n15GK/r9/ZO/wCCV/wJ8UeBPD+vX3hyxma9t49au5Jrk2YuHljVo/lVTjaGwMYHy1+CeOnF mK4YyrDSwk2nNtO1+lrX/E/ePBThzC51isXUxcE/ZpWbS0vdO3bS1z82f+Co/wDwTu8EfAK0k8W+ FLe+02fUNsUMmkaiEtrhPtSvIXDKwBAO0bQo561+CDwq0CQM0bSwExzzA7izA4JY5619V4Q8T1uJ eEaWMxDvOLcfOySt92y8kfm/HmWU8o4nxWApbJ3+8faSSN5yW0QTyh5V1eYzlWHQn069Ka9neWxa /eNHtliEdpPGQQwOctx0571+pxleWp8vGPLBH//W/LGGwgnmt76e33CPLI7DOGA5/nWrdvBd6XIi TwTrMro0EXzSR7SRtPv6Y9a/2A6XP85pK1QoQw3MaWxiQt5UQiUSoCQnfIPfk+9VfsMZuGQGKKWQ 8ySvt4HcmtIzvF+REYtTsVjpt0JSZPLjjU5BTln9Dn0xSS21yFSIySyxq5LT4CgM3IBP4fpVp3Rs lui5HNNbvEJjtQkCTjORnrn8a7aO1s7zXdHggiIiWzkklkicgK52jD59Qeg9K560rJs1w1PmqJeZ /9f9T/8Agnr/AMEzPgx8XvhZ4b8YeKtG0i8nvrRtSeG5laWWG5fBd5D1PUkAYC8ccVyv7fv/AASr 8J/DDw34k8e/C+0trG5j015Y4bS7ieH/AEdDcyE286tncsTLgEH5uGHFf2Llfi5mz8R6mRY182Hq zdNLX3XJ2i0m0tHZN/y30bPwPjXw1y/BcD0czwKSq04xlJ2XvLTm1Svrq9b622P5oJdR026vrGKV 0t7VLeFri9i/eeU0wGQ4HTax2n3Br+kX/gm5/wAE8Pgt8afB2n+JfGOj6P4hkvcPNDqe7/Rgy7yV XOTuLbueuAMcV+seLPFOM4Y4VeOwDtVdo312tfSzTWyPkPB7hfB8SZ1LD4+N6cFzW0s3qldNPTVs +g/21P8Agkb8HfBXw01/xD4G0e00tbaE3VyukXa6fPJjLhI/l4BCsMdP0r+TnV7S203UNU0dba6t 00u+fR7gO+6TfF8rncPU55rzfA/jbH8Y5dVxGZO9WnaN+60a+e+p8v4tcN4PhviVYbAK1OSvbs9b /LbQzliTToXktYzDHtw/XDd/zrR0iWO8tGk1Nbl1KMIliZUkUjOzqCMf41+/J2Z+WaubR//Q/K1p FbTpGnXyboSHMAcOSAfl6U1NMjkSNpIyhxu8zPEh7iv9jFK8tP60P81ne2g9RcXwubeBlWOxg+Td hQ5z90fmabYaNb3O231Kb7KJs+bMw3BMA9B68V0Qa2MGnYS90yey0xbK2kaYFtq3Mije8Yzg9uel Z1tZzxQLA8jyiM7/ADDwSOuCPbNTNpPUukrRNWTV5HNqLC2e18pCs8oPlhz0wF6jiqn2OX7XALuC VYbtgzyx4Yke3PWuOE9Wjfl925//0fhX4XfD/X/HWu2vhnRdLvNRMhCnbamZyrnahAHHBI5PAxX9 EfgH/gj14Gv/AIHS60u7SvE39gm9a9dwk6SFAZJJCAOFOcDPb6V/or4t+JtXhDG4LK8vn+9k1KVn t2v/AJdb+R/InhxwBTzvI8dnmOp3haUYcy7LVx+el91Y/nO+K3w+vPht8UvGXw+muY9Rk8MavcaV b6q9yJbq6XeTvcZwM54xxjFeJXmnyRxTaYzsWWQTvuOBIRyGb+n1r95wb5qcGuqR+I1VuVNJs45W Ee7ySHxM205x6mt6U+Zb+TbA+Wj7GJHccZrv5U5Mwl7tjBubaa1ulWcTJ5iCWOZV4IOcEGtbQZ9s L+fdz3NwkrMplwkJB6ZVcZNU1pYumf/S/K3zra5uIrWaZbaSaE3BMqFUXGcr9elO8O+GLjxFOfsi TIZLxoAzR5CLg4cjrgkEZHrX+ylWpGlGUpuyR/m9g6U61SNOmryeiS3P2k/4J9f8E8NP+OM/m+Lo pRo0rCco8IsxcMCi4jdlyx4J3t2B/D9pLn/giP8As/skkMT30LzAGP7P4hmihSQdG8oHy8/QCv40 8QPG/MYcRV8ryWbjh6T5bx0cmt3fe1/66v8Aq3hnwewGHyehiMyhzYmouZ31STWkUtdl/Xb8t/23 /wDgky/wC0HWfG/gSyn1DSRp6NrM3ktqd7ZosmPOhkUHbgld3A46nHNfgzdWN7pl7faZeWr2tzbS vbiG5Vo5J9nBZVYA45XPpmv6A8MOM48ZcN0cXUf7+D5Z666J2b1vqu+7Tsfg3iNwt/qrn9TBx/hy 96Olt918n22VjkpLKQSFCCuWJ2g5HX/PFRyWTXU1miySwRWcjfaVjYqtzkDaQOvHPWv1RNqB8DUV nY//0/yjuLZ7iYbZbhIIiCgVyAMdSfWs28t1muW8tnRVXAy1f7R0fiR/mPV6haNbgG31OFprS2Bl YoQGbBG0E+mcVo6XbJrNwYoJlRjxGJmCQQqP6Cuh83K7kwega1od7o8Aa9tTGZjm0nzhLhR/EnqK ybNrcQtFcMWllUlVYYVQMVGwpTsx9ksMdw3lpgONoZhjB9ql1C6vtPZngnk8iaPyJohgxMM5Bxjr 70OTRcdbH//U/Im41aO5sjZi2WNzhpJd3BYHgqp6ce9ZUGmy7lminkLt1iPyrzX+2af7tH+ZS+M0 UaISNBKWWaEBmWP5Xx7H/PWq9/5iy7bNwY5QHbzHyyAZ+U47/wCNZqbvymkvhZQFxcxSQx2pBCtv nKjI29xWhdXkK2cjQiMGRdqy5wB/nmumlJ83KYT92KZissixo5cMrjGc5znsKrpbBFwgCEMTgj71 dkWlHUhtpXP/1fxbtY7y7uGjkBO0YjVF5xW1ZQwfItxAHkWQjLJ8zDjj9P1r/cd7M/zAW6J4IZLZ 70To0cIkKwhmDb1zwcDp9K9N+Efwx1P4p+KbDw5pNjeRf2lfiyk1tV2Jp2z5pQmRhnIIAz0P414+ b5rh8myqvmmIfuU4uX3bL5uyPbyXJ8Rnuc4bJ8P8VWXL6Ldv5K7sfsd8Uf8Agjh4z8H/AAhtPiH4 f17V7+6vNIBurO4ijkkQFPNjmUKD8xH3gCCQ3HXj8J9b0x9KvJtLvdj3mnTNaXQh3eWsiHaeuDz1 wfWvzXwz8RKPHlLFzppc1KbWm1rvu2fReInDceEs7p5Rr8Klru+nZGt4a0mx1HxBpmmPLcQW960d tcPFhyHdhyq+gG78cV/QV+zF/wAEUbT4z+EtM8a33ijWZP7Yha8htIbQWtoInyYm3g91K4H161j4 s8fV+Asoo47DL3qjavvblt8tb9T2PC7g3D8Z5nWw2Lf7umldbXve2t09LdGf/9b9DvGP/BBOXw1p Woazomr6rdXMVo2Leb9/DcsvzAPlQxOR1FfzrftE/CnWvgT8Sdd+H/iVCNQtJPNs5IImjRI2OAsm 4dQQQCvt0r/Tnwd8XqnH2OrYDFSvOKutEn87WW2ml9l5s/h/xW4Bw3Bc6P1Ve7N23b6eep4ran/R ZokKFz8zMRhmrmdRZzHIGAjCDhjwox3r+iYyaZ+OTWg3TUiTyJk/eMp37h8yvWpd/absH5sqzEqu TsXtwK6qTurmUvdlynPyWF4z4gultisg8xecMueen8q0ruOW3QLAyXDqQTJGCFHTOAa3i/dsB//X /EWS2ur24JuZnz5ZfEjbAAFzgflwBWtp0EUMB3fPgYAY7ia/3Ugf5dxi73ZpfZ5FTG1WjK7kCt90 YrKtZPs6yzRB3mMxhZNmRwcZPt1/KrezNYq7sQXxiVhcl/3twNnlqMAH1FeyfBj4Wj4v+KtK8C28 9ymq6m0VlavExEE087COMcckghjtB59a87MsSsFllbFtXUISl/4Cm/0OzKcG8dm9DAJ2dScYf+BN R/U/fvwp/wAEE/EGveH9L1abxRqNheS2ShxHLJcW7kqMYGMjJ64OMVZT/ggn41hF/Z3via+hjljW QIkDTRFkPy4Y52gjJ69+lfxxV+kpOhjquGlGL5W0lZ9H6/mz+pK3gLg1ShUU5LTXVb/NdfTsj//Q +yZf+CGXxHuFa303xHp4ltrNLeC9utD8y4Ea4JAZlG5vUg18KftLf8EuPib+zboc+o3F+urWMNvJ eXG3SvJVnOZGAfGeQCAMnpX+jHC/0gqeZZ7SyzEpctWXdpryjdtLvs7rRvRH8i8X+EayLIamaU7t 0l2Wvm9Lvtuunc/H++0zVILuNblti7i7JEoZGOeRjqCO4qJLaLzncb/NKhQCfkH4V/WXPouVn840 vfTbGXliZ06klflPPSsS4tWtcswYjZgcHk1ttsXKNlcLa3Vk3yIQf4eMU2aMyTJGo6HuO9W52Zgo +80f/9H8NpIbiWf7GjkbTyc4j/PpU1ukltKbaQfORnnqK/3ZjL3ND/LBqzsac1obZIJXdSZl37c8 jkjB/KqWowqz25kjK/IWSQD5W9hUvQqGjMe1VRLOGU4BwE/vfSvs79lj9nLWf2ivFB8FeF4J5L14 POuJgpjazBZVBDEYx8wOfoOSa8biLN4ZFkeJzeorqlG/z0S+V2r+R73DuUzz3OsPlVJ2dSVvkk2/ nZO3mfq/pv8AwQW+N90hltPFN18zYSXcGDHqwGY+fqMivh39rX/gnF8df2a9Hv8AxLrejabrEEUx ka6sCI5Z7eIFT5g/hdcZ6Yb8cV+EcG/SDy/iXPoZJiIRi5PlTV01qtdW7q3ax+h8beFuL4Ry2Waz cnRVtXqvvSR//9L8OUufuiKFZPPiBA3EmMtz26kU0sZ8R3SbnjOICe4Hav8Ad9bH+W61M66U2rl2 wE3AA4+VcnA/nUExuWniVUPlE/PKeFTjitoKyOc1o7SdpzHagzM4+YgdRVC6tZIXcMMMnBxwc9MV ZMnZFWNBu3Z57kdqtqIiskpZ/NXG0Bfl980GJ//T/CSG4gZJJMszI207Vzz3FGoW8EkMboPLlK/O rDB56Gv96D/KlNp3KENuYozG75OMrJ/EKkt4pnVop5d6ZO04wRQNzZXWzUlgo2kEg/7VTQo8CLF0 i6AduaBOTejLRjdEARcf7npSLAZ1JCkyDlvwoJP/1PwUmjkjUqq4LdccGnRxO0BEiHj72R1r/eg/ ynI1AVsrlCvA9DU0u4ttbglchh3oAdDPJbcB9oB3BsAjI9qsXuoT6nJE90obYu1MKEzjpkCg0U+5 mXALsoRSSpyQBkAVato7i5V1WKSPyHGyVh+6bgEigtNPY//V/BaWSPe2Ox+ZByFpjwrcxNKJpUXZ gR/dxX+9cYX1Z/leT2Sq4S3cPsI7EjkcijzWlAg8kI8OVdl6S8nnHbjA/Chwd9CZNJFu3kht4w3l SGXdwSfkFMlmeeQ/ujk84A4o5HYybb3IYkaaURlSGBwT2SmTxmC5ZAzFMYy3GaXJIiUrbH//1vwj hQNHHCgOM4LHqOaSSFUkUkkqvBwMk1/vRa2h/lDzPYdOUkT5WK7DkL3NQQrHIrCUfJ0wTwaAjoyd 4jhCMEZwoXms94nWVt4wwPOe9QoWfkatpImSDcVZDhgePzrL+IFw7eB9She7liSK7t3ktyxWO5wX CjHqDj8q5cxX+w1f8L/I78st9fpf4l+Z/9f+KbxZdo2t3LbpY0EzLtkOSu3jr37dq5c3AlBaSNiq n5c8Y96/XeLbf6yY6/8Az8n/AOlM+WyBXyign/JH8hLafeGQqSI/mwe9aFuqy3Fu9wWNqjgzCPlw o64r5lrRnswik1Y++f2Sv2MPit+1xr15pvwpsJLxItR/s6K5MLNFDIqKxDSbSgyWwM9djV+qEP8A wb8fttW9tbjUfB+h3Ek0pO66v8TKoHDDagXafXNfI4zOo0cZLAxg242u/VX/ACPqaPD9XEYSnjZy tGV7adny/miva/8ABv3+2fcPbomgaRDbQzFJNNi1YK0zA7vnOwuR/unFWdS/4IJ/tu2Wk6nqC+Fd Hvre2dpnghu8RKq4/dxFlDHGPU/Wks1vHmcLa2JlkKpwc/aX+Xb5/wBbH//Q/lH+M/wG8XfCDxjq Hg74j6DceHPEdpPJZi0+aSImI4yxI4bqMH0P0rwefT/sT+XJCRt6OVzkf4V78LtXZyxcajXLtcyL u1RE+0RKcyHGz+IY9qhEaxwh2+UBtxGOv1rOb1KLkUsWzIOGCFowBz0qC2VrmYs670BwykYqC4RT NK5jGNqICBwP9n61UXTQybsEM2WQKeHoE42dj//R/i7tZrhbWbfDiJCV2ScOvODgdaiRiNrojRsw wp6A17NtLnOU5Ypny8xfylJwD3NVbcCRt0WUKHAz/DVcjFZMmj015ct9oyIsvIz8IfQD3qJrzDLb CIMB95sYVR71PKzLla0H/ZSYJJFYjaCdwGSBTEEixhmQSK6hVbGCT2NFna44r3rM/9L+KbaEZI5H CSuQihj8oqzcqkcbwgBgnV06Me+K9drQ4uS0rEG9cAKpyyhVYdAfercZeDJlJMmcJjnb71i01ozR q6NLTJLjSnW9hLLchxMjEZUleRmu4sbq68a6zbWMkMVpNer80kYEUDFRkhe2eM4peZMIPm1P1j/Z 5/4Is/te/G/wgnjvwBpdtN4d1ZEvbCHXbtY1dQSrssQTeMnP3scc+1fE/wC1z+xl8af2UvGEfhv4 t+Hp9PnuJCyX1nb7rB4z8oMbdwCMHGcdSBzXNgsUsXWqU6cdIde52Y/Byy5wp1/il5H/0/4u7+wu rNzE8ZDFg8L7TiRTV6wVYmw7FUYbnXtmvRe5zpJM9M+F/wAKPFHxp8b6P4O8N29wWurjdHLbwGaZ 5FYCNEUA5+Ygn2Ffe/7QH/BPP9oX9mPw/pnjLxv4btbzw1qVpHbvd6XHOXsJZRw0odB0zyRxzkEg GuP63D6+svSfO4834tfodlLBTnhZ4tu0Y6er0Pzh1Xy1uzHCmQhIdsjbuB6AVh3E4dgFiIZTtbI+ Ue9djVnY4yays5IA1xGxRw5cbOCD7CnWk0zRSK8bDdKdpcbW4OKQ2rOx/9T+ONWjJKTphsZGG6is y6SNbjEEbAOApwcsa6Xuc5YmiuYUAjOdyj5Vbn6VDbai8QZZM7mO0JjG4iktRtWdjSEMUtusgYhi +SqcEY7VXl08tiZJGyhJXPy5PvQaJqL5TFit5ZbwFw4ELFiOdjEjg+9dMm+FsuQR9ME0Fn//1f49 baxuL144bERzXF3cRwQQGQJJIzuqbRnvzX7X/s3/APBFT9pn48eF38YaJ4ZtrrR9StVEWnahHJD5 qKFbzBKQAA+7j6d65sdjKWEcVPeWx34fLa2Lw9TEQ+GnZv5/8MfHv7Zf7Bvx4/ZC8QGD4i+HbvT9 IvVVbGKCP7bFancIxEsqLyB947ugPX0+C3MZJVnPmRfKdo4zXTSfPRUzzaLU4XiRCAzMS5YhBkLj AFTIqmREwSTwFUUGslbQdcW9xbyHYQ+4YCgZZD2qCz1G6eYw3TjER2xgx4P4f570Di0lZn//1v5C 7SaVN8hbLr0I/irPv2A/0wMzuR86MPlXk5wKB2H2crTQiWI7iBg8YI61RuSA7SThUH3QQOZPwoEZ 6mSTzYY2VIwA7HGOmcc1K0R2IVMh6HnigAmCyWsiI5MoxlVHIPt71c02aVcTMGBQgMGGMke34UAf /9f+QLVbiXzYmMLI0ybwQuBjHFQRGZovnJCg5J6UGlNEstq7RiZFOAOh5J9wKbGY12T5kkOzYxKb REe4H1wKUnZFS3RPmF90hTBxgsB94VnXMxVlMe5FxkVyRe9zmqp85qxuHhUSZDbQTnqc09Y4OVJw +ON3APtVRlfQs//Q/kPhtWBdmQIpHzsBgkDp/Wpks1jMt2sm5oBvhRhknPY+nGea5rpaMcVdkVx9 ovGja1j3yPhBDICm0Z5J4zxzT2tJ4meIKDMi58voV9KE7nXGHVk+nXEtn5kl3K8pxiFONytnpgdq +tv2VPgF4r/af8dWXgXwbJb22t6izrcSzWRujZRptUO/I2gtIo7k7gBkmh7M1jG7sfvho3/BtJ+0 LrWkaff3XjmH7Lc26zMr6cz7A6huEGCRyME+tfBf7cv/AARv/aB/Yz8Pp431EW2t+GtMuoYTc20T wTMjq2X2YLcYOev1p0IrmRNdKzZ//9H+UXWLOSKRYnDI4UOyYICZHT69iKygrsArL0+UZ/jrjqxa m79zpjbkZhyRXSyTxTApJFMVWJOQADgZHrgCr9q72zgsuZDwEIyDWLSSsax1Ro7Z5ZZJbhTHztSA c7KQWKSzmNnZQY95IXJB7fnWJK1m7jZNHOo2Uqx3ssE1lcK4izsS4XpgevXp7VJJp7FECqokicPG zc5I/wAaC3FM/9L+U22llh3L5gUjlkPTirMupz3sItZgjokhKLFGEODxgnv3614sbXdjt5EV7oKb cQwDyguAR1Ciuk8P+HtT8V63oXhrRIJZ7/XtQh0m2uFYMIGlYKCATyeuB/hVvyJjG71P6Xfg1/wb t/FT4q+BNK8Rwa9b2Cy6Yt2fttubiW5d4g5QDGMZI53HvgY5r8jf25v2A/iT+xL4ig8M+L7eHVft Z8+y1HTYHhtwm5lfzGYngbSB9PTBq4LW45RS1Pz4KSxlkZSM8HsKjhtYrZpHiUeZMP3gzkEnqSKz JlHlP//T/lTgs1izKGWQK+TGRjaRU0jbnRmJhdm2xMh6546V4z2Z0pczsh15cPsggESolsWPmj/W TFsfePt2+tLAxhSJp42wx+Z8ZGM9hWBlJJTszEsbN2vZX3ySRmUkLLw0Y7Vr3aSxpmMHyFBLsqZI +tTLWOhnJ8rsYkd4fOjkK3E0XksgiWHekrZG05HTGD+dddabprRGkjED7PmCn/VmnHYiex//1P5a wJZLlJi4Vk2o+ePOA7YqPUrk/vDDiDPyDZ1BHpmvnwS0TG6IBYGW9cfabgxldr8Ig9QPWuhnv4J7 ZZogrQO2HjOPmYdseoNNJvRG8dlYy4rnYGdIfs06MUiKNkup7/8A1qz54p2k2sPlPJIHahq2jNox tqeufDP4UN8SvEXhnw5bW8N7f6jqcLW+nyZSR1Djcx+U7QAC3I524r9r/iB/wRT+KWmfs7ah8XPC 17c3V5ZaLJ4kbSrgxyo0aBnkjjcNsXCKzBXx0AzWaneXKaWdrn//1f5lfF2n6xot1c6NqdjPa3Ol SNBLMy4hnZB8+z6Hr6HiuNWzS6ERS4njMZDuUICvnI2mvnnszua95IvXMccSCIS+YiN8rSH56e0U zpG6IuyTI3jljj0rG245aLUY0lxEBasivbN8xlJ+dSM5BFUJ4Ukgza7QBJhiPut1Bx+VYz3tYE09 C9YWYiiBjjAVeWwOOeT/AFqCS3t1uJbhmkbKBSCflH0H41Fi4y5T/9b+WS38yRnkkI8lZCI4++3A 6+/WoZgDmNAxRmxtXpj3r489aLudbY3dzFZTafarbyTSFWtZrxT5KEcMDgFuB6V+q/7AH/BLfxX+ 2Ne2dt/bcOheH79nvJp9GvorvUL1jJhpNmCQCQcKcfLtJ6iprVFFJy7o6MPBynJLsz9CP2pP+De/ 4g/AnwBrHjnw34xvNa0jw/pMl+bK8tVuJboKpMu5olBXYAW3MTgLX81+q6FeaDqms6DqL7nsLk23 mtD5FxlSRiTnhsYyvvXcm+RNHI1+85SbwF4Wm8WeKtP0Cyhmub6+uki01FYR29w4cAiR+Qo5HXsT 6V/Tz8BP+Dd7xX8Wfh9pXi7xD4jNjf3yx6lawabe74rNpYgxCPtBIBO3AJB4I61505Xx0YnqRg/q bkj/1/yT/bm/4J1fED9izxrcad4u1pptMn1FYrEXEq3Ud7byu6RtuwGDFo254GAeBxXx78PPAV/8 QfHOl+CdHtxPe6pdJZWEYvEtjK7HBBY9MZyPWvnM1iqeHUn2PXwMeetaO97H9JPwc/4Nw/FfxF+G 9n4q1Xxtf6RrlxaCdBbTLeWU0vl7lEkY2hsE4IXccY+Y1+Iv7aP7B/xN/Yt+JDeGfGlrDfaFPbtc aRqiK4t5JNxDRszAEHIYYODgZHGa4cC1Ww8alN3TSaNMdTlRxEqdRWabR8E3a3d5NLcvAtoGfP2a A7FjxgYHPSq5EkTthFUvgSOBnIFayi+axjT2NG8s4Tp8RtZ1uhPbmSdI8Ga3O7G0jt0/WsIaVPJC wiL24RfLVkGFQe6moasy7H//0P5ZoLF41RZlRyvzecCRnsRii6hUyEI+xCcI2cFc9s18jKNtD2C7 JYJFF9lidXyqhNjGaWUtwCO/41+zn7MH/BHn4l/H74TXvxMsNX1PS5L+1YaRpt3AEso3jjDFnCgO VyRnnPJBrJR9+yKt7rufmD8aPgR4x+EHjLVfB/jHS7S11jQNRksr2xcsVgaJijSRSEfOjEHHcHIz Xl4ttMgQx7GkVh+9i2jG3v8A/qrSpFxdn0/yOanFs5+W5gkuHjs3kS2D+XF5kRRhgdCvamPZpbl5 JD5ryYKEjaV9RWcFzQbRdVcsrM//0f5Xrdbea4t7YqIInVt0gTIUgE9B61nvFbQXojmWCKEnY9zL nyRnuxHQDjmviEm9j0Um3Y349Dulge6jhj+xDJjkgJmVgP4gMd81yIY/a5IUEsUg52PGUJB7kHkU qkbXihwWpv29r+6HO4EjcMc//rp0llJFc27RTrHE3ysHG0ZPTP8AhQ4twbR1WXIrla8m1NZVt/It la2j3q8MmDOS3BPFbdvdywQSxlEZ5E3ImfmdsdAe1VyvQuNraH//0vwi/ZU/ZF8b/tSa1LoXg+wM 2r3LKszXDCWDTDuVF25IXeS4PPYcd8ft/pH/AAbjfHK+hs9Tg8VwJql5aLFdzCFf7NO0fIDCnXnP zDJ5r87hXpSxUsMn76s2utmfWzw9SNCNdr3XdJ+n9I/MH9r7/gmL8XP2O9X1hvFKrH4ftoYLmJ7a Fm0y5kkYi4fzH+dOVOFK/wAXWvzP1ODzJntTEp3rlfMGwx4xzX0NalKOHpyZ59GUfaSXYzE07Fpc qtxmaABobh2BnDE4yi9DjOfpXP28A3T2Mt095dQkGWZ1COoYkrlRwMgdP/11ype6+5tKyWiNiLT7 i3gC+Us8ErZfYwLoB/e7gVDdIFkVU2eSg3PEq/dY9s/lXO4sg//T/lZ3aprssVlCsT3gjKr5sojj 2IuQuTgdBWZaGRdxEsEDWreU9sw4dwOgz1Ar4c+gL/2NLi3eZUJFonnys6AJCxODtPoc/rTLr7Zd 2WzT3KwWaCa6gj+Z7n5gv3euRnHHapl8LAp2sen3M8LTStpsbMqy2x4nlPQlAf4jgmn50qxlvrtr qf7KZ8O06EyKF4JbA79axA0NRvbaxhWWzJuYpEEiOp+8CMiiw1aLTLaTV7tUhmKLiCSMXE6ggkER 4PByOaia0uXDc//U/lYjC6xYrcFRJBPJkRscSpyCW+noPamvauJZFtGcRFAJTIwGcH0/I4Ffmz0P qCKOCWOW3uLdcxQt5cqAYiYYPJH1Fa21r9XMsihQp3Ltzu44HtWNL+JYqkv3tx+mO9pGZbVDDJAn lweemPIU8YVTVGSbUb7UbiGxihkuYYkKlJdjXWeXRB13DHSvQpw913Bt3sSRxjTbl5Zrm4lW8Vdt hKB5UTJ1Knr3HGajNl9nE5tfl86bz3kzuxk5JwelaKCRJ//V/mBtViukULI8fy/MVQMY6pSTFhJF CHyp8smVDGzD1x718Pax9Td2sWBLa2lqIpXC3uQ+4n93s561tW0k2yCQzxx+X85lgIkYDqpyD1HX H4VUY3Ik+VHNS39/YvNdXMc11HcyssstzCC0i55bOB+dJBqMd0krWxVQG8tUkIVmPsD1+tXDYUZX 3JoLOWJ2im3Tfa2G1UGCBjOM+nX86+z/AIJI83lWr23kjTtMEkUQUJEqhl6epGf1r9X8Ioc/F1B9 rs+A8SpqPDs492v1P//W5T/gnppek69+0P4Nur7Tvsc9tqjYkuPmknVYAUkQfwqSSAevy9a/s3gW P/hWQnJNnPcaOQWUeWiLg4IHYEfzr9E8aZOfHNOPaMTx/DSPs+DmvNn8Wv8AwUh1PQtY/aG8XPG9 xLp0No1tp2mmDyHj/fNvlR+ysyrnPNfhz+0dc6ZPonlaZdTzXMelzWV4nktGLeRZNwKP0biTqOhU 5r+qcki6PBGHa/59L/0k/nDFT9pxtWX/AE8f5n5HeLrWKzuybIGSVs/a5Zm8ySZh/FkdT1z71ymm 3ckNx5eV/fHDhuNuO/tX8TZjK+NqNdWz+oqMGqEV5HZWMKzSExRhm3ZdRwJK6DyrOG3ea4NzsjGU jWPc+7OAp9s8V4eIfvWOqmrRsz//1/4sNOtJbh2ma2jt45DkRZ3BR2FdmJE8r7GyyXG9MiPBG1l9 /p/OvnazszvimlY7LwDYaFPeLDNFcQT7HENv5ZWJm/iLN/nNfUNjJBb2cWkCCFY7ZAsFzCA0xznh m7jkV5VaXQ2hexj6lYCO8F3DdMEgjCCLzCGkY9cjpgda1hHLcwwTQj95GpUbuOvXHr0ric7NmsW0 nYl1C2ZdPaVi8kiRF1eOPNwp9l9faiw07Xr7RdLuLoGS6upHWCx83LIqkAMVHQnuPY1hKV2ht+4k f//Q/jskuYE1C2ecpBeaLKLu1tXHl7/lZQGOORyeOOlQJfJrMNxLePPb3VgxvViGZLW7BO3Yj4xn qce3avnlsZTVlJGZqUqtb+dIoRxhowoAUYHAI/DrXYy2lh4osNNuLJIINabSI4bva+Iblo87CM9M LjPrz9ahz1MKKSjruXdPk+zSwWd2sMs8kZiVoJB9mXaPwORjH1NdFcST7jcWFvYwXSoLfzrh9ogT gFozyS2e3ua2pvU6uXSxY/s9bS6TTftVvqUs8S3cphciEuRlgWOBkdM1BfoZlDeSkechI8YVcccV vHRo3gtLn//R/kY+2XFvERyoVyhUj5h649q8Z8TKsb3ElksaW8jfvUC7dpJ559Saig7O5tL4ThjP a2d/b2xt4YhfEK12XDrak4wSR6195fsszro1xrtnBrepadeiAzQ6hC4xfZCt5eTwFblQAOgr9L8M pJcaYR/3j4zjpOXCuKS7X+4/Vf4J6nYS/ELwMkmsRyX8V5amaC/iZnmmYxq0qsqhSqsSeccKeO9f 6Av7I99cah8H/D9zLHCZY9NjW2cMSxjTJ5+m4Af7tfrP0kaf+xYWqyfAWV+FsXS7S/yPxU/4Ld+H pb/w1eSuTBawadBfSTi3Mm/beQvux1IyWUjPY+lfy83MUwkEogjltZ4hI7A7JEbqMDH41+n/AEfq qnwLTgt1N3/D/I/nPxbpuPF1eSP/0vyp1fRv7E0rSdYsLu3mu9UZo5od52zRr1BP94ZIwMcfjXFa td6cs/mSwJaxFd0cK5K5I6Jnk81/rbB3R/nrVi4tIyruOyu2smtYfIdV/eCQ/M7HGT+QqaRdPup/ sN5ey2BXakKfZy8E2euGH55rRPVGJ2fhLUvEvgzxDp3iLwNqcyX2k3Cy2d2Iym5dyFsH7yk7eGUg jHBFf16/8Et/24viD8XLRPDPjKVhHbM0E4+0tP8AZjEhAG3PGflO7qc9M1/PPj7w3RzTI1mi0qUf y3X43+8/pX6O+Yyp5zWyufwzjzL1Vk/vVvuP2Z+KOta3o3gnVPEumSTltP0+S7Rt7EYCkjgEHGce lfzi2n/BVT4lp+0TcfDe+0+9i0S411NIjkk1OYGDzmBjcRMTwcjHsa/kzgrhd8RYPGSi9aUeb9P8 j904mz1ZXxJhMA/hry5T/9P+wPwrpNr8cfhFYw+MJGkGpR/6TbSw+f5bKCFYk4z8rfke1fyp/wDB W79lfwd8BtZ1XxP8P47OOy1q/to5oYrQWUn2iVyrPIFO1hsIIOM57mv1/wAHs0xWV8dwyujJqnUf LJd9f+AfD+N+SUJ5RDMIL95TaV/LX/P+rn4b29teQPf211YO0c8eVkYD5QTn933zx1x3rJXR9fu7 ZkSwleCS58s+VGx8iEjKySD1JHQf3hX9/wBKqlBXP5BqUZurKxV0/SLy6nntLO3kuZrJWMyIhbyi p24bsCTxjrWzplncSWpgu9PISZy81rLGGkj2/eJ7jp/Kuj2ys0RGhUT1Mc6XpF1cX1s0KpHayedE 5bLQbjlVB+lbNnpRghkayMXlp992YAr3wfT8a0jVXKOth25aI//U/JC0tGuZEnliQkReYr7g6MBx wfwqMizmtbq/Fq8zox8914SJE+X5Vx27k1/rK6keZan8DwpSVOSsMTwvc28tvqV881vaxslxbBAS Jt2Nucduef6V0F3FIrRXIlSRCgFzAGylryRwx5I4HNXKrHqzOFOUZImWOWaMyJbBFQZjEZz53Pp3 P0qvb2t49xcTJ9kWBcQ3Ty7XEJJHy4I4ahVIRV2KalzWsWH0PT1uTLpUJKrCGu5JblHjMhPKogxt yeefXrWfcwwQw3Uc9pFOtwdmyVAwBB5x2PvVKpGSepnOMlJJo//V/JlNIN1CltFE0WxPMVFG1ERR g8egFS6NDaJI8cTR6vbOCsjRPyuVOFJHTH9O9f64xqwUT/PiUZX2KV3pUUty+zZAZciKAPnyRngZ J7VKdCu9Igt7ue4W5tjHhkkcLsOcbgOf8OaXMnSbX9aG9CP72PmbFjoMtx5OoSIIImkDbJAV80eg +o5qvqWlSX19Nf6OxS1FwTfLbKZPs44CDAHCnGDn+VCrU0rXOaVOpdos2+kXsdy8MN0J7oKCIQwW KE4zhj+GeaXXYhZS6bbQCSbU76Ty7SKE7vOPG7B6ADPU1ftodzNU6q1sf//W/LiQahHdWsG9Ui8n zGiklVDNgEFvU4PGR71mXtpYx2KXYiu57661QCe4iw0Uce0jYM9OQPpX+uPtE42uf55e+pJNGHLp o0owsksmoeawuNi4aS2LMcKfccH8a1r7T2sVguiLlDOqyOLn5nJ4zjPb27VrB3WoT3KSiwuNUnmm MikKoiBAWObC8+46VYS6sYJHggTa1w2AR0+p+lEtIswTX4nb6Rpgv0jS4aGdNrEkyeXv25IAP4AV /Z9/wSb8QXNp8F9CjWVm0LT9GjiRLWYzpC7hWO/qcgu36V/O/wBIqmqnBsL9Jn9IeAFf2eaY7zhH 8Gz/1/6Wv23P2vfCHw/0ZdFsvEun2mvzu8SQS3arI207Wyp54Y4wB/Svef2FfHWteOfhPb6v4gd7 i6uTm0kCkjYpO0nrkMhQ5719rjMhlhuFI5lVja791lZDnVDM81xOGoyT9mtbdHt/meU/8FBfHnib 4aeDW8V6BqNxpz20r3F5NFkJEkaB+SATzh+B698Vd/YT/bO8HfH7wBp+lza7pF14ytwLe8s2u/I1 BWUYJaIjqdr8Ac7avDcPSzDg6Wa0FedKWtt7HiYXO3h+Lq+T1pWUoqUU+6WpwH7aPxI8eeA/iR4N bw7rV1aaRqcVtJcW8JAhlxPtK5xwDhwcdc+1fpN8Mtauda+H+lX1xM3264sd9werhtu4HPuCprxc xwdKnkuHxUV7zbT+R7OSVK1SvjYVH8LVvnc/l/8A+C1+mXN1rOi3U4jZrXxAiQTFB9pM08SttJ6m PCsT6HFfz4Xdst3PcIJV8y0DGdYUMgXbwSxA4x71/dHgbXguB8Mm9m/yR/G3iFSl/rRjb/zP82f/ 0Py2/s2XVr22tInhEVwjSxX0km2GLYQOR75PX+7Vq401J7donl85YZfLadOFJGen15r/AFylO7um f52OCvZC+EtYvvCmom+89m0u1u438tHEN4GDozJE+OrhSMccE1/YT+wF/wAFNfgrD8ObXw94x1/S tMvtM0eGxhh1GS5sHLJGj4zKgU43MPlJH7s81+AePfDtTiDIaMqLSlTk/ndafk/S5+6+DfEVDIMb iaeIvy1IK3Zcr1+eq9bHgn/BUX9q74RfG74b67onhLxDo91q1tpDnR0tdQ/tB5ZPMSRQu0ELkq3O fuqR3r+V7ypoRJA8USzvGJHSM7o978tg9+teh4F5biMn4WeExC15mz868Q8bTzPi6vj6Xwza/BW/ Qu6O/wBlsrvT5rZp2nbz4yRhhjhgQf4cH8KvNbuulzMIYUhSLfbpE+4+WuA2Fx/D6Cv3CnUhGV2z 5a0lQcOqZ//R/MK30LVpdMW8tzcvAxEgme0lEMSE9WO3he2T3q9pOhm1GpwayHs5o1V7QQwFi29s Kzegbtmv9eaeIpSi4qS0P86I0qrkm0SXNpeWMFybsNb3Fv8ANtYbiyk/K2PQjnmuW+22t86MIRNC U2Ndn5dsmRuX3HT86dKacpJDa5KiRbNz5UkRZ45Il/dpAWJaQD6f41DJDdXlvKJZRapFJ5tokYJD jod57Edhz9a6ae9h81p3LGl2N8UknvM3CbdqFuRwMKfw4/Kruj2t7f69a2dxLNp9sLmGSa9VvLUI Jkyu7tketcuIuqb9GdeBa+sRXmf/0v6af+CWNzazfBu3WzeE2sOx4I4T8pR0BLD3JLcf7Nepf8FE dLnf4Ga/qOnxzXF1YiWeVMEqsX2aQNhe5wWOPY1+ufwvFmE1usTH/wBLR8/xhap4dzj/ANOH/wCk n8EQsbCGx8T2tm1letJeSqkgs1ivYdqEqg7gcg4HYiv69f8Agi7LAPhT4WF2o+2vZQwrcJcGRWxG FAkXPBzmv6N8f6nNwXShHrJf+ks/IfAC9POK8v7n6n6n/teaQ2pfCvVonuJIYvskzySdIBtAADev fiv8+Px/ol9D4/8AGel3csgsdN8e3v2h4lVmvAApQZx/e3kj/arwPow16dPAYui3rdfl/wAA+a8e sPOpxLRqpacn5P8A4JgatavbW5E+kXjRkb4wtthHX+8M4GBUFjpUmqo1rZ29xZ3URAdJFJaUN93Y oB+nev62+s0rXbPwb2D9pypan//T/Ne60CGKSOKWZVlEpiYygoAw6gsRjjH6VHZ6Jdma83z74fLz axy4jhiKgliG7g4GK/2DjiKV00/6sf5vzoSi9UYWLeGOS9mnWJhJ5axr8qyk/wARx/nmuisdNur9 bOZbBr+KeUxxCFvMUuuflYjp0IrSWNw1JXnNL1ZKoTk7RV/kZ6WGsWiqdYtZdOluJXCWtxE48hVJ ABJHft9a1rPQ5Zba7vrGQ3JjjEWYRvW2kOcB06nPTH61EMfha8XKjNSW2j69jR4WrR/iRae/bQqR actxbh2aOXkqXXhMjIPf1pNM8PSvKGitpZJ5LkQwB2aQMzEKrFQT8oJGTiuWniIxm3fTX8zSNJyV l5H/1Pub/gj14E8L+IvEosfEWl6Rc6xbRfZdQvWt3JTEigiKU8gHJB/3R61/UN8Q9CttG+HniKy8 PWdvao+gT2MUYbEaKImyFB7YBx9K/dPGfGVK3iNV5neKnp8mfKcK4WjR8M8LTw6teir+rjq/W+5/ AF+154Hubf8AaF+IDubNXfUk+wzGUhJf3MYcPgddwcj2wK+O7zRr+YTS2cyRzQTNDcjHmLMqnkA9 ulf6G5LjKOIy+hXoyTjKEWu1mtD+B8ZSqYdyVXRptP5aGH9ueKZbd4CJFT97IPkzjit+zuS8Cx5U hM5YgBjn1r3Ivm95bHnU6qrQ5lffqmvzsVILSWd5rczrOSGkWSRgBH/sf4VbikuLSK5tjp8DtsB8 wJyhHQg9eP1zTk+iN6aaTZ//1fyfginu7hLmeJFkRQrnd5hYgYAX6epr7K/ZOh0TVfjN4N8NeJNO Go6bq94JL2CXHl3CW/73Zt+gb65r/XHjTFvA8L47Er4vZyt62Z/A3h3hI5hxXg6L2VSLfydz+8j9 nr4beANM+HOjajoGg2egvNbjKWUSxKm1ABnjoAOPbFfnL+2n+1d4p/Zo+IXhuVrw/wDCOyatHBdx b1iV1I3nLH+IorYGR0PtX+ZmQYKtn+fVsNFXnLmZ/dfFuY08ipUMRVlywi4rp6H6PeB/E/ws/aj+ HEBZ7XXNN1nRIRqKQzrMY2kVWDqyk4Kthgw7gV/Hb/wV1+Bvhv4OfHfQLPwyWlvNc0bU7m8vLsh5 beWK82g5HLbhjK+5/D+hfo6YvGYLjDHZDWk1TVNycenNGcYp+qUmvmfgf0g8HQrZXgs5pJc0pcqf W0ot/deKPyKtbW6jtLua5vYmv4XAjjWMk3BJxhR2PNa8uny2CwQ3GwTum2Zi6mTJ7lR0r+1PbU1G 1z+Y6lCfxNH/1vzGi02+klFoscZuG/eqFbhoxzvPp+PeqY0RL5TNp97byyRz+Tcoj7tmPvDFf7NU sVSUleSP8zJ4SvN2hF3Zm6tpEAZoLY+bcxsFuYVYfICAQT6df1qlLouq6QYTJFLbNqeI7KRB8s3s rfz+ldsq0XFtbGKw9anLlktVubU+kXrRtqWr3M11FZWptYbVZTKYmOdmF7LnPSsK30G+uJ/Llsmn eEx3UsdvMjmKMtlXfB4Xg/XFYqvBuyZEqco6tHSXWhaotxPdyaTFHYSq32Z0lMSQfJ8rHOAACfU9 PfjLttBvdsv2+4WORn2i3YGQKDnoR27/AI0pVYS0TKpwkpJ2P//X/I240ie0jK3a4jedora8SJlh lIPABP61dtNNuLSBpJXd4Ld/3jup87BPUDGcDOK/2kjjcPKfsYy95H+ZzwuJUfbOL5e5oHwrb3N6 mqrezwTGD7OYHXMUgznOOoP+NZ15oDCWW2huYXu9hleJTh0T+8R1A961pyTk7ikm43M2KG5sZXtI IC00dqZpJggeJ1J2/wCc1RntrVrSIzKfnGfKdNoz34/z1rqpSXtb+RzVLpJE08dnDbJf/JFFFbqH h6pFtHJA/Ck8mC5gEjsYhIodJSuFAxkcV3wSm7Jlwpc8W7aJXP/Q/HK3FxbPGN4KO4KDgO2D1B9K 2hKsF4plXzS5Hl7E3/N71/uJKShFpn+YdFRlG73udHFosmubfKfyZnJCOflVdvLH8B1r+nj/AII1 fs1eCPiD4ci8UeJtNsBJPdLJa3SwrNNJIjHcGz3ygJP09K/nH6ReeYjLuAZ0cM7c8rOz6Lp6a6+i P6Q8Acgw+N4qnj60bujFcvZOV7v192y9WfvT+1Voy+F/gN4h03QCYEs7FPsUFtGIwI0VomGOnCtm v86L4k6fLF8TfHysw8iTxNO8PmzKWQszAhh68Z/EV+ZfRMqpZdmMqj1bX6HgfSKcn4hYVW0dF6+f OclZ/btJ1COZXltrmORZI5YzsdACCGQ9ug5r+nX/AII7/t7fEq4v7H4Oa7cXupWOnMYLYzJsjlhD FVWMnklMrz09h2/XfHjh+jn3AVepN2nR95ej0f6P5eZz+BmYTwnGUMCvgq6P1jdr8G9PM//R/uxv r27uPC81wCym40/zCrdfnUDj86/gY/4K9Wt5F+1NGgia5S40qWJpmUZ3LLI3zH14AwenFf1b9FN8 vGWITf2Jfkz+afpM80Xl0Vs5yv8A+An5fW2nlbZrsRuytwVX+A9MH0/Gse5td1xaxeW75YmXcm5O enB6iv8ARCM4tbn8q1FZo0Eso4cpHAikKTiNAFH5U+HR5bmyW4tJRD8xyzLuUHnjr1rqozik02Yz 0lZlK18NHE98fNMbg+bcMxMWVyGx2A/+vVKUQ2Uqxq5k81PMUqch1zjIPQ11wlBok//S/GK6SC+X aiSB1jIJ6N+lZ8cTW9oY28xVjbIc5dgK/wB04PWx/l7Fp6IgstRkhleIP5iScHPJX3HpW4ZQjBol 810AJjGDuzWpadncNZUXcFvPFaRo8Z2yCBdgHHHFdV8KvG/ib4aePfCnjXw7dfZNQ0HVEvo4Z5PK gmK9i3Zv7p5wfpXBj8PDFYCrhKvwzjKL9Gmmd2WYmpg8zpY2l8dOUZr1i7r8Uf3jf8Ewv21NZ/aW +F2iR6xMFv4Imhn3BPkeFtjKCAM54PTvX6I/HHxdf+BvBF/4nsjI32K3aeQKwOQi7uAfXH61/kRx fkf9k+IFbJ3s6tv/AAJn+kGLzVS4OjncP+fXP9yv+h//0/2e+Fn/AAWL1vX/AI4WHwo1XQL37HPd /ZTd3TRSjerFXGAikLlTgntiv298ZfDfwv8AtCfDaXTPEtra3FhrelmSG3vIFmSHzF+U7vvDGcgg jFfsnHHD1bgTOMFXoStJqM1+DPhuGM2o8fcHV6mIV4y5oP8AFafp1ufw2/8ABT39jnR/2YfjFfRe F0RdK1rzr95bWfzVsy0qoFaIjGFZJASCDgqa/JuXTbvzvMd2jXn5Bg5+tf6TeGueyz7g7A5hV+Jw SfyWm3lZf1c/gzNssjlWaYnL4PSnNx+5tE1jZyzSXEY3HI2bvvKpH8qp3Gk6uxKvF5i+YFRFIXzA DyQT6A55r9CjVi3ynDKn7l0i4ulyWsv2byxLv+8dwIHA4FYsiwzTSRKhABKDHDccHnrUSqK+jOWM bTsj/9T8W4LKWR1gW0un8xcCUQNsU9uapDSR57Tql0biK48qVXVggIwABn+lf7qRnFQs2f5ZSTvs WLrTL150aWF1hK4yy7QCO361BesDGlsyFdi/KCOeOM0nNPbYWqurGW9jMsUM5LLKASvl4OR/tV9a fsh/tLeMP2ZfixofjrR2ub/TYkWy1CyhmECYeZCGkQghwMkY4wSDngV43EOWU86yDFZVV2qQcfnv F/J2Z7vDeZVMoz3C5jT3pzi36bSXzi2j/Qi/Y+/aTj/aB+Hula40Bhmh0+Niixq0QJAB+ZeDyeo/ xr5G/wCCueg22pfs/eK1NtCkiaW863YtI5HiOQ7HcRnACZx35B4Jr/KvhbDTyXxXo4JP+HVt+J/e PitThmPhpWqW+Omn99mf/9X8btf8LnwxqjRzz2biceZZ3FuwVpo8cF4x91uW47jB71hTW0axYicb gufMcZYmv93sO1UpRk1a6R/lpL3Y2KTws0TlinlsACxwSSDUcnlSgKpGFUA4HHFdRze08iqblrNG G/JY5QqNrL7Vp2jWl3byLPuSbaTuIzk9uaCG29zMkskiXarKrsC2DwxHtTLe2jMbPHIDsbDg9qCb q9j/1vwwdJiC1vGrBDwojyXz7VS2PKzbm3v/ABAjpX+9B/lPdXsQlVjzvwSThQTmpUlhJ2JkbPv5 GB+FBLkkMdctkNjnkr3FMkRsgS8pkFPw6UEufYsrOIIy+QzHseahtZ2kkdopCFkHz7TgH/P9KBqa 6n//1/wfRo1mIck5OOecVovJAV2RuCGGD2xX+9B/lNzKxnRWTSNtUFgx+8TkCmXCyRIykF2j9B2o DmWxWw7FGZfk/rVm8/dRp5Z38ZII5T2/T9aBlGOR3VjEu5iQrZ4xzya77QNdsbQ/Y9UtmudMWBx5 CHYyyEcS+5Hua0nTbhaLs+5UJKMk5K66ruf/0PwXeW2nvZksVcxmRmXzE2yld3BI/pSXCpC22RiQ RjA45Nf74H+VF2SoHt/LKENxjnmi5Fz9ojliSOPcQhUjCuP4j9ev5UC9S2s8AkCSkShOqj5QfxpW kw2YhsXHGT0oM5voFjMVuCsowr8FjV2e3tnXLNnDZZs9B6UGZ//R/CsBG3Y/dxop2lOWOBxVWBnB UTc7zlPpyOR+Ff72uF3of5PjpYVViQ2fUZyKlktFECzspIxkKOA1S4WVxXRTSaSOQbk2p2Xrtp7y bXKkbi3ILdqgq7tYcHeN8qF4H3uwP0rj/iEkt14XvrcyFI+LpwqfMzICBz2xnp6muTMF/sFX/C/y Z6WVSX16kn/MvzP/0v4p/EEMMmr6sLqGSJrZybd9hdLpmIIOfp+WBXPRwvndKRtIwgGK/XOL3/xk 2O/6+z/9KZ81w+l/Y2H/AMEfyRbiSFQyIoDufnJGC3+c1ctLMWkqs8qmJuTzkL6/lXzMtInrRWqP 2f8A+CR3/BQfXf2JfjDp8M2kQax8P9Z1+BNSsJtodpLhh5k0ZIJ3DnttPRiOCP8AUp+AvxX0L47f DTQvH+g2lr/Z2sadFNb7oQCN8atkqRweelfnma0qWGzVVXvVt/5Lo/68z9Iw+JxGM4ehT+zQuvXm d1/l8vM+Iv24/wDgoP4J/Yg0h9c8c6Db31qZjZWdvHbiJ7iZsFVDBfQqTyPvDrXO/sAf8FLvhn+3 TYaja+HPDUekPbXMkL2lxAJ7eQgnI3cqeOvPavoMwyyhhcjhmE95vRfh+Z4mR4ypmNarhoP+Gm38 rn//0/1G/wCC6/8AwR58MfHr4eeJ/j/8MrGHS/HugaJJfT2mmstsmsGCOWYoSSAHOCFOeuMmv87/ AFrR9Z0K61bStesmj1PSLh9PngcYdnj45z0J/nmvdwnNUwEK/Tb8jhvCjmVTCJ/3l6O9/kmcxPo1 9MIZhEVXZ93+Ffb61lv4e1PevmIGgkUtGUbKjBxhh2PfHpWb3sdHK7XJm0lN0ULuVuRyAq43fQVF dwS2EiFtqQgYPY596TWliqd1OzJ7a1FyJfJkOHX5lc/KT3x+dbNloczXESkkhR+7djtC45/pQKV1 dNH/1P485LTTboXAm8wSRHIYHAmYHkNWfbWEV2ynEcabiQ8jbIowOp+gr200otM5yvdaM0bYBEyy H93sywPv9Kw5NIeHzpQS0cf+uQLtYdc4HU9K1C1iwLNILOQzieMEB4isRfIPqOvpWQunEvtRZt2c srxFWJ7AfpSSsSnfRFyzRwSmyRAvEiyRmM/TBqndFopTHtG3OV/2R2pSXuscYtyP/9X+L1NGuXEc qxLJvy27uMDsKksNJa7jklVGVUkaLDfeypw2R+FewcUrp3L0GgeXE+VPytkueQCTxVS606QMpZiR HkkrwrfWomtUakUMpljWIg5Viu0/0r0HwO1xZ+J/B/nx2xsLbxNbTXCPnzbhC/zIcdvX2zU1NErF wR/rMf8ABKnxV4B1/wDZW+H134YudBVpNGgWe0RoybMJGquh3c8OHHPP51/Pn/wdOWfgl/h14Nvd P07SBrK+NRF9tsY0+3pE1pKJAmOu5jAcc5OPWvM4boTj7XmWtpXOzi2sp42in3Vvkf/W/jf1WG4e 4KmWSUQqNpkGP8//AF63dK8My63azGONpAImJWJxE6KuAzFuwFei9G/ImEeflXW5/bV/wQd/4JI+ Br/wf4d+PmqazZa34jtQr6eiwO8cDMqS75d3Vx5oAC8fJ9AP1G/4L2+HfDPhf9gnxVpcukad/a8d xp+n2V4IUS9CmUeYVwOrKj9McH65+c4doVMbnc8wnvJ2S7JfLy/pn1XFnsssyqjltL7KTk+7b1/P 9Nkf5r2u6WsQklED2M3mN5sMoxIMEgNk+oAP4iuQtwGcqy+aC2DjvX0k1Zs+PiryVtjoVgt1gOSV 9ugqk1jO8TTR7GgUZLA/Mo7YrOLVrFS+Jn//1/46v7PkjCSgNJuHIxlh6cVHbpvl2MoSXdtAcYwe 1dUviZglcs/Y2hba7AylsqBz+Aps9nGoiLRbZJPmZe/1/wA+tSi5RbehtW2mKlnvgVWZgSmTkfjW bLZzXTQ7DIgBKhIxhWPTFA1BXIZtMlssNI/O7Khvlz7GrpjimCfKPMQAsO1O2htytSSP/9D+SHwr 9gs/EPheRo2hVPEttLqV0ke/7LCHGZBjng4r/Vb/AOCS3jXwV4i/ZV8DXuha1ZTzTaRHLM926Rzs qqMsd3IyzMeTn5q8DO6cquNwi6Jy/Q+3yWUaWSZjF7tU/wA5H4nf8HMvi3wg3w18N6VayaPHfaj4 wX7ReWKIZkSGI7t0q9N5ZBjvwa/gugiMUTQywFZlldgzNvZwWJGffH86+vq4d4fC04y3cbnw+BXO 5/4i1BZvPFJIjAAZ3N02465rQtdDktoEu1L3IP8Ay1RTIqk9un4V59joqQSe5ZgsGjXzZSzMfnYu MMe/4Viz2Ms92DCiiF+rjBIp2a3IUNNT/9H+QsQGEtExYBTzxyfwq5FBayhkklTAXq/ygYpvoa8t 4pEtpYQR71iljZSu4GPB/GuduTpU1ykVxPIkwkMYjSPzD/vD2/wpxi2TKNieOC3VZ44I2mXOwzMm 0f8A6/8AGkMZSMwshCou4tjrmk1Z2It0Mea2MTCdHDIVyFH3gfeq5uHkXbNPNaQ7trSRoPMU+oBF IuUUtj//0v4/wVK2wkv21HcgYzycSj0Vvce1Slkd2QH5CMBe3HpQbQVkSSPPEkIA8yJwVYngxY6U ywW+t5I7Zy8y3bFljC7o0465pS0VmVKHvpFy7tNpEDEwlGy6R4JOeBn2rTj0NJLaIyR5kJ+UsMDH qB+FccFe5FSFmZ9zYTQb3jSSXyCFZQvJ+lRPHFcxBlY+ZE4DqPvflRFNSCMdNT//0/5HIxPIrK6F VQDdu4+Xtn/Pat+GyMkfnrsnhKhjLENyj13fSuGSszqjDXY7AT2tjpaRx6VK+osMx3cUZdWXPQnt 26Y4rAvNTbUbOJZbNLW7iZkkdYwkrgcAEge3WiG9jrUFbUybLTFuUlZEh2W5zKrH96vpt/GvqP8A ZW+NHjP9nb4k+HPiJ4Iljsda0zVknu/tDBrO6hIVfIkjJG8ZVTgY+tU07s0S2R/pv/8ABOT9qbUP 2oPgd4W8YX0FtaXM9kttNHAm3a8YAbvnHBAPfrxmvnr/AILialaWf7GXxDkm2G7+wKlk8iKwjZHD 7hkHJXazAe1a4VN1UvMjEr3Xc//U/ld8Y36X+sXdjduZ7i3mRrx4QYDKWUPy2MdCOneuUupIEISA yJGnCCQ7mGPU1z1YtykvM6KfwMbb+QzysziSRhnH071GJEVtshG1uFbuK5mrstSsi2s8U0lusPmL JA2JxjIkH8NbNtbRvKUEhaSRslerDj/9fFY2adh09WaUuleQqPCyywtwXJA+foVHqRVVLcFjFlvM BwQwwR1/lUyTtY1lyxly3P/V/lXgsGuJHZdzw52JJGCWlPT5AOT+HpVgFHYwwqA1sfLkzHsbI654 614sIu9mepKHYVoYgNjJgydSO9esfAe9h8L/ABV8KazPdRx6XperW+o34uMv5OyZB5qjpwC2fpWr g76EKOtj/Up/Yk+Pvwu8SfA3wXf6d4x0H+z/APhHIHSWO9iMLOI1R0wCcFSuMdRmv5Wv+DkP4n+E PFvinwpoXh3XtMu7y2iN7LFazIZLgPcDMbY5AKxSEg9fTmtaK0fzIrLlR/JVc3Fu0EZWNg8h3srD b5XoB+tV7a3MpkaMMgAy5PGB/kGufyKVN1HZbn//1v5ao9NYHKzCS3lfajEgcjqB61Hqemvbj7Wk BdYoBGhUFjFg8ke9ePUdopHpwwtWm3OotHsFutqlpC90SzXTEQB+TKRngD8K6CK1skO2e4zK9n5k FsxUGOTtgdcA9fpXOnfY5JRftDHTTZIknundp5ShGUG5eMkKAO9Xrfe1okM9syO4+aLbukbrxjGa uNKTg5JaIwqLlfvIjtrV47eUxRPbQs5QFk8tlZc+oyMVBDA9ykscTbmjl8uV0YElgBkNjv04pU6c pvlQ6lJ6WP/X/laQfaNRktkmmFzANpgkUop/2lyOeldHb6LLeQ3AZPMmh+aFBxuPoT+deDKNpqJr GH7pEUWnzxAQSW3+lTRsRDuywx1xjrisKHT/ALPIjxzzvF5phMDH93HJkknmrhFqWppTWxvw2TBi kgZ5CCwcfdA/xrcsLBb+S3jZdjQZOHPlBgM5LZ7VnXahJKR004Oo+SK1P6uP+CCf7Fvwc+KEa/FH xro39veJ7WZZbQXUiyQ2wMjxqgiI/gERPpyD2Ff1HftUeE9O+GX7M/xN07Q7e2j0yPwJdadDZrth 8gyRNFuyBjo5FcWDxdDGVJKjvFnZjcvxOAjH2y0Z/9D+dv4yXcuq+OvGzNdI11ca7M0dqCDFCpfa 2xB0B5OfpXltto9vbSyCKZp9yBSCNozjnA9PrXz81a6O2Mk5RKeoaFPYLBd30DRwXILxRg5MgzyV HU1mWEryLL5aqWJxaRB9oTH97NZwjzJjqtXsdgdOIQeaEZioaVccYP8AQ1RZbFN9nHHCjr923XA8 ruMCs50JqLqdF/X5jUbK6Iw80MYNtCs0ZbbPhwGQeuPyrJv5EiVGMed5xx/Dz1qHD3U0M//R/loW 2N0I1ikMZDgnnar+xrTt7eJCocAYOC/3gexr5OyUdT04L3h+oWM9vJby2F+QWcLG5QARhhySvfGD X9ln/BtvZNbeDL7V55D9pjuIrHRpzCdjJJNulwCOoKEnHQCvIzrFLDUKcnG7clb9e59DkWBqYuvV inZRi23/AJH9M/7ampz2H7PHxKuFucRW3hi9fzZAGVi0e0HHfJYj/gVf5avxs0sap8U/GesRE2Ue ra7d389s0pZIy9xIANuOCMEZ9MV9pQwSllP12+qdrfre/wCB85U/3t0lujqf2YdHubz4qeGLO285 BD4itJYvs8IlaYmUId3fad2DjsCa/wBR79kzSZfDHwS8J6Kihbey022iEruHlk228avz6bgeB0zX yFWpGOd06N9WtvnY+jpYef8AY06zWidr/ef/0vb/APg5C1yWfWvDGjzSq8h1SCaJkjXMkUkpOzON 3y7T/wB9Gv5pv2evFHhr4efF/wAGeKvEzgLaa0lu1yzFEtxI3lmRiOFCqWO4jHFePxHT5MCv8J62 Ta4qz25v1P8ASv8A2Vf2ofgVq3we8KvpnjrwzaQWOiW/mRR6xDdpAywqG+ZWOckE59zX8in/AAcQ ftD+CPij8SdF8O+ENfg1eGKNXuJ9PcyW1vLFJuK5A2qzlxk57EZ+Xjn4OpYbMMvq/WLpwTtbS9m1 5j4jqTw+Mfs3u/zP5h9S1OWPVIopLS5+zzQ7xPBGZYUK4BDkdCeoHeup0fThOsiXKjCZddwyzZzt BH4CsJNObSOajU5oKRkW+k6hbvLcQWCw3Um4zIJAEcKSAN3Tp0+tbtzb6etskXmOssgHn/vhkueq qByBWM3rY6Y3e5//0/5eZraSGR4mYoqKBECcgjH+RUv9iT3iDKHylIMkg+UJ7Z/z0r5Kbs7M9lJt 2R+rn/BKb9lX4bfHn47WOleP7R72y0y9hmNzCRcJKVDTpFhgUHzRhTweV9q/0KPAvwI8G/Bn4f6d L4TsfIhi0RWeBo0jRV8oDaUUYzx830rjy+tTxubPLoS99OF/Lnul+R3V8HXoYKGKlH3Z3t58tr/m f57X/BWnxDN4h/a8+IM1rLGujPdSzSH5Vl8wEAIF64ysn1FfkvLZ3FwGuraVcK2ODgOO+f8APavp +JsreU4t01Lmjy6PbZdu542XTqVvdqRtK+3qyjcpaW7SXForPcxbJBDJIEBbA7HsTTJllgiju76N g+7d5YPmiMnjA7cCvFwEeemzsxkXGpE//9T+WiLMTGeFFICCQtKuIwCcd6hu7S31Gd7cmJYJ4j5v 8cUYxg//AKq+SwCTxUaUldO/43Pp5U6UqUJJWubfhfX7vwJ9sGm30WpQXdkbO2t5YvOitlxg8Hvn pnPA71Winttcu766mmWG+W2DRItuAZWPAU4wF71hi17Ocl52OJ0m6rpw2X6Gfa29ytpFtjuVkSbd cNOQPL3NjB9h/LFLqlpLdzRwKkxVWVS0SljExOQxHYdK0wkrVlGR2+yUaF2Oa3vVl828P2pyothN tCNtA2pkD0AH5UeVM72lrF5Z2zBZJrqTywqd8t+Vb46ko1VynLhYuacX0P/V/Cj9kz9obx5+zz8V vDXinwLqk9lLY3Kvc2EKebZXamVFZXPRg+QMHjCg8YFf6Un7Gfxv1743/Cnw5r+rWsET3OgW1zNi EDa7AIMOOudpOfxr8Wrynl/F9H+StG3zjqm/lpY/V6dGni+GpxXxUpX+UrL8z8jv+C/ev6fY/ATU 4Luytri7htZN01xbK7hgyiMggbgQVJBPr7mv4NvFctvPdWpLRxzvCHKYCuu4A1+tY+CjltB+p+fY anOOIqXW70OPmf7OyyRsGaNSoycKfrWc8qf2iLzdFbQsiPeKke4z7Ooz7/pXz8XBSlbd/wDBO/ET StBdL2OkvLuxuWkW1ja0jmh2xvHKXVM8Hrk56/nWa9qIQtvHKs8chWSe4lAE0e0H5Vxxgk/pWc9j mjLXU//W/lNkSYXNwq3EizyRfuXjjDKM+pzVsaNE8kN1ebJrqNdyuAVUNjuOhr4c9znNGOWLEkDl lWVfLlhibaJfT9eaxGWTTSw875i5VHThiPcUpK6saEL6NFfSxXFzGZjAwuIMjBRx3qtb2plnuJbm MeRMjNOgYPuCZxnI6kVi4tbgSaeYLvTXe6t/Lfzni06OOTbGNpIUMOvTt7d6lGk6aZnvZGvZbyS2 S2NvMgEClCc4OckYJqZK6Lp7n//X/lVMstoYESLEZYRokZwF/D2Gfyq9JE4aR4VlnUYNwyrlUJHQ e1fm9j6grC/8rNsyvH5nSNlIBxzViy1G0mkaDZ5P8IPXeRwefzqYK1Q3pwtMsrdWkt9JCzErH93B B24Hes2WSzt72KKxlnN67O0gMWxYgSfmV89O3b8a7kmosxe7OlZbOf7Mt4POeEfu+dxj/wA+9Vrl FhiuJYluJVcGOFYEy2enT/OK0Fa2h//Q/lusftNlZRrPPPDG0m6RUTknHQ/5704Xi/aGGGmkZCPO cZwO2fevhz6gYIjdyRxI3mybSCvchck/lg0++04SadJbtPPHFKcSLbvskA4yAfwrSHUxk7s0NQ8Q TR6D/ZKxw30X2QRWayqRLbsv3QzHn1+uetc3b6ZGiwvMBHNIwZIjxhvYVUPhFex2VpMXngUlA6YX pwwAxX298A4Gma51S4tlihsXjtVe6Aezui6hlXbncRgNn6da/YfBqF+Lab7Rf6H5x4nTSyCz/mX5 M//Rvf8ABN7wlLqnx00m4yXlfzntZVcm1tkSSKQRgnocLIO/DYr+v/xLhfhbfebayxqNCCLDEmJI fKAG1B77a++8XZOpx6kunKeb4fLk4MT9T+Hr9v8A1aO7+PHiyyF+1upkewitFslTJSQOSZSOCAcc Y5Y96/GL47XUVta3ksNrHbPpn+gje257iWUjDt2IHAJHQV/WOGn7HgSk+1H9D+ZYJ1eOqtN9aj/M /MHxFbxj7QIpYJ5VlYSRoQ5jY8tg/rXnthZMtwJlj3tzlG5BHf8Az7V/D2Mf+1yv3Z/WEIr2aj5H SW135E1skDFRuP2gsuQBngDmtq7uftksx05/tUCYUxSERyFhjdnkjrXj1viOmEVZH//S/jFstcmt 3tWjtbWcwTbrlZ4t6ODwcjuRjofeusivbfULu6uYSYVZxIIQgXZnsB6e1fNVz1oJcp3nh2Sxke3Q OI7guVjTZslkIGT+ma9n0/VraGaCCb/RxMghBdCzxsMfN9Dj9a8io7sovWsE1zezC9BKK+9GPyrK p6fj7Cu6hsLWSOxkjMB+xHkJIN8Q3Hl1zn19ulcE3aJqvgOuuIPDj2N0y3R86eFiJgqsVbGDv9wa 4STTZdPnhubbUy7G2+VYZRtGe+B0PXNZweqMj//T/jqay07WLZhqTQSazbXZnMo3NuAOFVWz09c+ tacelXaBbaK2tRBGSWEFwhcZA4xnp79Oa+dh8KM6i96cTmNOtm1DUdRt7pxFHbH/AFcyYUJ0z+dS 6nBa6LEstncSIir5MYgzz24I6Cs5fEyKMdLkmn20k7W1lNeMl2h+2xRSSeTMUOCoyeSOB/k16NcM +uxWumRaVZRsku4yCVy8jDAXG4nkdsVvTVrHSo3TNwwyW+kzRLHD/acf3/OfEz7TjjvwOw74pi3R trOOe5t4BdYDqtxH5yx8ZBKnj8DW60kjohG+h//U/kL1u4iitftk7OFiUyyvbIWwfUKO1eTeIJA8 Uq7NqSAPCV53gj75HY9azoI66qXLY8omsXhlnsriVpY5MSyTOwOwEZHPsDX3x+zjDDcxWUNlaC6n meAQrNIRNJHGwDBmGecEMPX2r9A8P6nsuLcH/iSPl+LKSqcN4qL25T9OfBlj/wAIn4t8GahDq0LT yeI7GwkdRvtoFmlQSlnx90DcMg/wn2r/AEFv2H9Zi1X4N+GUgZAtjoFs0qgYV1kUsrqe+Rtya/cP pHU3LJcHUXd/oeJ4Bz/4SMfQ7NP8X/wD8zf+C08c1/8AC3XPtELGztdMf/SEhaO4tWik8xVYg/db fGPzr+TG98j+yreWzkMlobNJY5kYvuUqDknrX130cJ34Vqx6cy++zPw7xgjfiirG2qX5/wDDH//V /Ii48q9tdOmeUeXZBhGU+cS+ZgZJ7HhRkVkBdHjnin1DbqEsLPDAsowkCP1LYPbjFf62Q2Z/nvWX YY9laTXl1eCeOM28McUUC/8ALUEk5B6cDFVJZUe8lW8tI5Le3VQpJ3RtkDJbHPBP6Vqlqjlk7J2O r0i4vLCZEtiraY0SmPY37tD6KPT/AAr94/8AgjFr50/4ga5OEt2m1bUBpkCeYJYpJPmkw4/hJWKv ynxfhfgzFtdkj928BJ340pR/uy/Q/rJ+LMccvw48Q2Vyux28PTwSC0xsDNAcAdsbto4r+ID4s/D3 xLp/7YVxqOgtM96+qwyQSXkYjt8xwIXC54bCrxjJ3AjqK/kDwhx0MHXzCjVdozptfqf0NxzlrxvE OXVKa96E7/kf/9b+un9lrULjUPhL4dknuPJmawiF3FM2yVnKBdx9/lNfh/8A8Fvo9Pn8NWlv5Vpe yz3ttc28kMi+Xm0E4nRsdSyrgHqCo9q/R+Apul4l0qsPh9o/uuzzPFeKlw1XhPV3X3n5l/sY/sEv +1SNNBuINKnvCHuLbUL2QLYQ7VbaGA53AO3OT8hFfqs3/BDTw1Y3wvLjxpaCOWSOSa0h1pbcoEIX hDEVA4z61+8caeMFbJM3eWYF3Ud7JNf1p/SPzbI/DDCYzLqOOxMdZpSs209f+HsSW/8AwRD0JZ7+ SLx1ooa9ug8ht9QS1Uw7uFkSOHGTzlwCTnrXyz+1Z/wSR1f4JeDj4m8My6Jf2kOqRXd9daZKJ71Y WOZULGINsIXnIOMdBnNeBlXjbi6uaUMNiJNU3KKd+11pe/8AVzXOvDLD0sBVxODgnJJv/NpW3S18 7aH5T/BD9nZ/i38Yf+ELunaykstahsLae1uYvsl5skVGM2IyrMrK2QMfpX9Dujf8EMvBFxp8Ul/q +krc6haR3d1qKyvDdvIwBeNlCMmO2dv0Ir7fxC8Wf9XK2HpYG9px5rrrez1u+h5/DnhlRzDCSxWI s79H0tdK1l1XyP/X+5P2oP8AgjNbfD/wTL4q8BappUcmiR7o7GW6lKzuudoMap8wYbj83931xX5R fAH9m/xD8Uvibpfw/wBX0qHw4j3n2bVLi70qT7F5J3LJgnDKy5VgrA5wfSv7a4V8WKGcZJisXjZ2 q0k2tlfT9On3H4DjfDmrhs7o4KnD91NrVJtWv1/J/J6s/evS/wDghh8NLnwcbjRvGksDDSBceVcX ExkjlZcuUQgjH+zyPavxB/aj/ZH8YfCLxTp3hWbTU1DQ7PUpbGfUbeNPtepQqVVUAVFHJDdz2xjJ A8bg7xmWb5tPC5tK0emy7q2jXlfQ34p8N45Xh6Dy+CfM7PrvZ9b269e5+lf7Hv8AwSg8B/Gvwlo3 iPxV4o1jwy1vDFct4dNh5MkYkXMaHI3EkHJJGQcjjivsy4/4Iq/AS1Y2v/CSaddTTTFVW9tpYLkA 5yQ3IZseorwuJfGrMsNndbA4OVqULWa6u179X+J9Lg/CXLIYSFWqryau1LzW39L7yOH/AIIb/s76 pMBJ4lW3hW4VZ7a1s3hcoOuXUAZPr3z1r80P29v+CXU/7P8ABbap8MdJ0zXtJizcWXlM8uqQLkLK HO0ZyOcHrt+hq+GfG3HYjOqGDzOb9jKVnovx623072+Xg8T+F2HweU1MxwSXNG2mr0bsu/W3yv8A P//Q6P8AYT/ZH8CftEePvsmv+Ir7S5NPSLTm00adusbmSbhzIerAHGAePlPGcV+rXxw/4IcfCjTf AGv6h8Ndbt9P1+OyknuPPt5LSylKxEh9kYXbsfDEKSCAeDmv674s8WcfkfFdPCUpv6u2k9fstp3a 1Ttf7tD8eh4X5fiuDv7RoxX1jkbslduaj07X2t38z+Wj4rfC7VPh14mvfDV/DaQazY3LWeqSw3bS WjtEACYCcMM5BOQO9cnDZPqa2dtcb/Is57WJ5kzNtBuIw7ODwwxuznqB681/TuW5hRx+WRxtB+5N Jr0aP5wlhK2GxMaFVe+nZ/ef0hfsLf8ABMD4H/HDwnL4q8V3d/qqanBDaRyS2mFg2ojblCthWO9f u4xg9a7D9rL/AIJCfDr4R6VB4l+FV5dTve3SWV/Zx6dLc3CKuCdseCjAg56ZyvXFfybnXitm+XcZ 1crlUao8zjvpa2ll09b31vc/p+fhblcsjo4ynFOo0pba6vW7W6V79j2X9mL/AIJO/AjWPAdvq/jG a6i1e7he7nFxp/2W7nd1U7nAG4D5j8ueORgEc+q2P/BGL9ku8+1PdJqquXJ2iKWd4snI2ANwMe2f evlMT4tZ/Qx2I+r1ZWvb4nqlt16H0OK8M8hnhKNH2cbpX+FbtK5//9H99bD/AII0fsyy291axX8s 8kJaWye50YeXak9AcnfxgfjX4m/8FDf+Ce2rfBDVjP4GhHiHQLk2yW1rpdidIktCrZkyfuuXQbAB zvycnPH9T8BeLWZ4zifD4TNqsvYy0d5Nq78vK9/kfhnG3hvg8vySWJy+mudPpFefX1svmfjhdeH7 vQtSv7LUtLNrZyEJDJcSvDqlnJgNteMjjj17Yx1zWfcpM48kPJcRdAztvZB9a/srDVIVaSnTd09b rY/mLEp0qsqUtGnYxbLyluJRf2rTW0GfJljbY/mdArDHIPPFTtYyR3J1H7OYra4mIjjUZS24+7k/ n+NbtdDlUt15m7AHsZonkukhhT94iCQFGz0yOhx6H0r9Pf2NP+ClHxB/ZuS98CQ6DZat4ca0+2xX EOpzWlyXVljVRGqOoLAnIPHyDHXA+F464So8YZHLLKrs916rZbre259vwpxZiuFa9TEYTecXH08/ lc//0vnn4+/tN6x8bPi9pXjDxJYrDLqfiN7aNpbl5vslrNKpaARsBhnbHzHIGAeOo/sE/wCCY8iQ fBDR7Pz98drbfZ7R3l8ySURoow3PYFB+Ff1p4z8PQ4b4GweWUtVDR+ul/lds/Ifo+4yrmNfM8TiJ XqO0vW7ZX/4KbBZfgTrdosYMkrTCR0XLZe0dUGenV84r+Pf9n/49+O/2cfHcXi/wmbPxFdWuoMNV 02/me2SVVJKeVKp+U/cY5BBIHFeb4H5RSz3hnHZbV+GbS9Oz+88fxJzatk3G9DH0PihH79z9Pda/ 4KO+IP2o/F3w68N3ngmbw3dPdx6deX1xqn9oWkIjkSRo4soCAGB5JBwfev6pvgJIl18K/DbRGORp LBVkXG18qoADfgBXwnirwnDhDC4fLYu6u3f8l/X/AAX+p+G2cSz7L8Vj5K0nK35n5D/8FHvgzonx W8W6VZ+KLK607RWurSW5urSLEkbL5ihgzcDcrkfgK9T+GH/BLj9lnWvh7bX+nmWPUr+w+a+hsLa4 u3yA2JGwWP55rLBcZZtkXC2GweXzfJe7S7+dumlrfM8Cjwll+cZ7i6+Kgue7Sv2u9V567/LY/9PY /wCCjf7FOu/AHxNPrnhaxvdY8PLeSpZ31po7WzCNsDfOMcsijHHBOelflFp88duiRTebIJ5CjTTH YFZTzuXHB61/pd4a8Tw4n4Vw+Mv76tGSvdrTT/L5H8CcS5Licg4mxeW4jZSk4vum/wCvTQ/Vf/gn b8Evgl8e/GF74N+J8T2U8Gy4s5hdRFdUiVgcAMDtJL4xjJEY565/pU0f/gk5+yWmk2Ednpd+sawA 2k8MMdrPggckx7d3B4z04r8H8b+L87yXPvqFCV6Nk0mtNk3+p/RfhTwjlWcZDHG4mPvvmT76NpW+ 7X+mfmf/AMFEv+Cb/wANvgt8Prv4keAtcmFvoaSx6hpeoQN5k8cqrna4yzPHwwycEbh6V/L7YxJr N2Lm1nWyiiu/s1vawL1yRhXQ8g4IyO2a/SfA/iCrxBkEq1bSUHa34n4r4l5XDJeLZ4Gn8FotfO/+ R9xfsyfs96/8T/ifo9hqGjzXnh0aeFvJn0pzbRBzHIGErLsO7gDn+9nIBr+pP4ff8Euv2aD8PNGH iKCe51Awl7+K4023NnmUBsKrDheRjkivi/Gfj3GZPmVPAZZUfu7rpfr89UvKzP2fw28O8Ni8hecZ rBXqfDda8r2fztf0aP/U/pV/4dl/skG2mWKykWMKkYaxsrViCv3d46ED0qa8/wCCTX7KfiHSbyO2 OoLLOgEk02nW1z5jLggjIJUA4xsxX71/xFHivDUlP29S3+J7n5jDw74dqXSpQv8A4T+bT/goX+wt qvwG8Uape+CrDUr/AMGpFcR6lqx05rVIPmAikZATuEa4yQR34wM1+UNt4Wu4Be2SzwslmizP5cm0 SB8HIU4Izmv7K8O+IaXEvDOGzSMrzlFKe1+eOkr22u9V5NO2p/KfEuWyyrPcRgpKyhN2/wAN9Pws I9pCfkhEkUse1o5H+6rDqKpXdxfTrJZNIkSM5heWABiwHp9cV9/T3PAaTOt0/VLaHSfsS3sRvY8R wRSZFxOMc9sfLjv+tblraX6adZ6nI+nteLfpbyW8kgaKVRImSwH+z+GayxMV7N/M68Dpi4eqP//V /oy/4JD6nb3nwZtpALe23bZzDDb+XGwAaIBR2A8sfn719mftuaDrniX4Q6xpehx3c0tyh+0RWkRe SSN43iYYA9H/AC61+qZpXjg/EydeeihXUvkpX/Q8niPDyxPAaw8Fdyo2XzVj+KjUP2Jfibp/iXUD FoHiCSW6vZLWeAaVNDHdCJiBKH24X5eD/Kv6Sf8Agk14A8RfDXR7fQfEeiXWneZI1zdia3KLCcny cZ6fdT681+z+LvEeV57wrGGAqqTjZve9rW6n5l4OZJj8lzKpHGwceaOn5n6y/tIRC8+F3ie1lKso 0iW4iiK7i7R7d36Gv4utG/Z+vvi5+0p4x0qx0W5l8MT+MLvXNYltrELDZ5OzaZ2O3DOmFXnvgYyR +f8AhNxPHhjJMdjG7S5Xb/FZpfi/89Dq454afEnGGHwbXu9fTd/gv8j+h/4Yf8Esf2arzwNodz4m s72fUprQTzWt3YQy7CVwRuI3fmT1rrIv+CYX7MMEckNlZzf6Mwl+XT4A1sBnk456etXS8WeKMXKc 41ZWd9E3oui3+8634Z8PUMRrCPu6apb9Xsf/1v6ULz/gkL+yfrui3scEV9DcXpMzGLT4Tbuc7sFe ep5OCOvSv56P+ChX7C+o/AXxdJqXhaC8/wCEZhAsXdbeVYXhDErI1uOFKgnDR9hgg9R/X3hr4oY+ pxLDLs2m/ZzSS5npe6b0d+l7bbn83eJXh9QwWR/2nlsUnFrmsumq/Pl7/mfJ/wCzf+zfrHxT8Y29 jY6VPe6MJ0+06xFCRFGrMpIEbpkOuGBzwCwr+oL4Qf8ABKf9mz/hXum3PiiyvJtXuES5vbyfTLcy ySbQCWXGATgHnuTXpeMHiNiqOOhgcoly+7q1566NM6/DDw+wVTJHmWZq7k/dT7LTZ/1Y7WX/AIJa /ssXj5is4pVRdnkyaLbMCR/EVGB2zx7VNd/8Eiv2VddSWe2sVt7+C1CxmKyVbdyAcM8I+TqfQ/Wv yXCeJPE2UwSpTmo3vu7f10/4B9nifD3I8y5nKMea3ZXP53v2+v2CL79mvxLNq/hSC+1DwrNq4fWL cW7Q2+n2yYIkjUKEAf5gdpJ3e1fUP/BOX9hf4IfH+0j1j4h6rcxag0kd/ZafAyIYFI3Rls5J4KgK QMHkZNfvmbcfYjEeHMM9yyT9teMZW3v9rbbX00Pxzhng+hS45rZJmyShG7jfZq+nrof/1/62vgh+ xv8AC34CamJfASRLDLI00sjWqR3LlyAXLLzngf8AfI46V9u6tbQXejy2VxtaCWEwylgCHUgq3X1H 86+04izWtmuaUsbik/aSte++jt/kYUMPTwvD8sHRtyRTS+4/Kb4rf8Ev/wBmv4k6prfiOe9u7PWt Ql+1TpJZJNAhABwoHT7o/IdgAP5a/wBvP9nfwx+zp8SX0DwxdJqlh4lvLlrfUIYmt57L7GsRmWUE lCG89MFedyN2xX9ZeA/GGcZtj3kuKcnRhBJX1tZq1u2mltrdNj+RPGnJ8syXD0KuDUfaVZu9vv17 37s/PaPT7d7hZJI1mVZMEA7C6jqM9s4rEltfIt7m6jjIj89omXO4oRzt9q/riinZQPxKaUKUeQg0 uKCScXEskkEaJuRVGd7jBAP+Nbb3O4yyIfMK4WRehAPQ/wAqrRVXFk05y9i2f//Q/K51khKGBS8j nLD+71JzX2f+w94X8VeIPjF4a1+y8L6tJFpGqhodU+ytLDFH5ZST2G5mUbiP61/rB4iYiNHhfFue 3K1+h/BXhdGp/r3gvZapyX/BP78PgjG4+HXh9GiFvJJpyNPDjaEfyxxtPPFfgx/wWs+HXiPxH4Vt 7yy0yaex0/VbS9meBPMmdU3B2Udem8cdM88V/nv4Z4ilh+PYe0+Fya+/Q/sLxuozr8PVVR3TT09T 8qv2Kf8Agovrn7H2qat4bv8Aw7d6z4MmumEc9nqssus6WyKnAtDnchG4YyOY1HcmvAv25/2udB/a 18faT4q03RdWghsHvrdNXv5ltr2Np2jdYGthkhcxsSSxOWHuT/Y3DnAv9mcbVOIKC5Y1FrbrdqWv zV+10nufyVxjxlUz/JsvySUn+7d3fyVj78/4J0/sD/Bf9pLwfFN4z1wjXkvI57qEQAvZFow6qHyM gk/+OkfX63/ax/4I6eDfBng6HxP8P7qyuJ5i9pq8sdktvM0LRnJ2qvBAXIbn3xmvzniHxazLh7je rl2Ik/Yxny635bPy/rufsuA8OMvzng6lj8NFe0cU9Lc3323/AEP/0f1D/ZD/AOCUfw68beHLzU/E Wp6jp89qiW0MtzpcZuGixypcjnJA9R79q+tNd/4Iv/A/VYxJpurNNeWtmYIQYzZJtI+YMowvzHuc 1/UmL8Zc2jmdSpTqt073Xa1+3S66dD8dpeGGVVMu5YQSqctttbpb3669dz+fH9uD9gzUv2dfFeqJ p1tNZWTOIE1NZWvNMlhWRY8u4U7GGT1PIPHTNfMvwW+B/jL4r+MtA8LtaSXOnWOo+SskMQvYo4gQ TLvIICtnp15r+ncv8RcvrcBvPZ1FdQb87pX2v5baH88UuD8dPi95HKD1kk7qy3te/wCp/Sv8Kv8A gi/8Jb/wRp+s6prUAvbxhcTR3tmxUkAEjGTkA8e2K6aH/gij8DLl72S21exj851e6VLR9sqg56Aj jNfzZLx1z2OJm6E21ftdb9treh+64rwgySSjQ5bSjo+n49S9qX/BD/4P6jYXdppnie1jnuYdsUQt pFiQjkEgnBwRX89P7X/7GfiP9mLxtfaBqbfbtOurmWHSdZgjxjDuIoX4IwApGeox0xg1+h+HHjHX z/OHgM2lpy3Vklre3q9T888SfDWjwtluHzHAR0c7Pd6Wv8v+HP/S+3f2Av8Agl/4O+P3w/03xH4q 8SRX91ZBbi4Qxr9nt2cDEQO3naSeTnofpX6A6x/wQ78A3lldR2upaOTK7PCL1WxnJK8jkDvwK/rT N/GfNsn4vqU4u8ISkr91qlptt/wD8Oj4V4DGcJ0aqX7ycU7L/Py/4e5+E37bH/BP/wAb/s+eNp4L BLu7sLn/AJB0Kyre2KSqnz4kVFYqxVioPTd34r6H/YO/4JnQftDW66948mGkBohEdMntF23Srym6 UpnGcnA68jFfsOf+MtDC8GUM6y2S+tVLJxf2Xa7fXTTTftuj8o4W8McRmXEmJyzMotUaV9dubtb8 /uPqb9qb/giVpvgTwFqXiTwK2l3jmKW5kW3le3u4SqFhtOBkcfdHHHSv5jvHfgDUvBniK78H67Ya hp13pzYtpLyUTC7cAiQI4UZAIzhgDgivs/B3xEjxvllSpjJL6zTbTXlpZ29Xbbtc+K8UOE5cH5ws HRT9jKKcXrbW/X5anEWYt9Puw2oQCeNfvWzsRE5GcE/jirVxJHqkgDIi/vCyJEPLjUdhiv3yCXxI /PcLWlTw3sm9dz//0/x7nsZYLu3dEMu1HCDeSsQb/Z9q1NJtzb3MUakzS3EoQ5IAiLHGefTNf7fY hc1Npbn+Y2HgnOOul0f0V/sTf8EsfD3x/wDh5pfifU/EgtZLrSilwcrHNcqw2vIVxtXcc4AHAHNf v7+x9+x3D+y3BDoek3gurC3kV7VoplkVAOuQAOW5JwP4vSv85/GbjzHZxPE5DiVpTk7b9O2p/oJ4 Y8LYTIKUMVh/+XkFe369z7P+LnguLx74RvNFmaNReR+Q4lOEZW6gn64r+ef41f8ABEvw7rknjTxh pF3oaapdi41K3tzLlPNfLDKleD7hgPTHFfGeEfHmM4OmqGG/5etX+btrc+T8TuBcLxLiqub1n71G LS+S5j+ZH9on4Ta18E/iRqPgbXILS21KztysD6ezS2zxbVyGyOGXeB+FfcP/AASfu7i2+Omk3T30 8kCFbSFCp2QhJEaTa/TLbiT/ADNf3lx7iI5h4Z4nFr7VFP8AzP528GpX4/wyXSb/AAuj/9T+7COD 7T4WsVldlWTS4nVu4BUEV/KZ+1p+x9ZftHftXXPh+TVfIe7ybVJEMDRs9wwLeZ2BQqSP9nvX7n4L cRT4YzXF5nTesYs/LfFnhqnxNmOCy+pp7zf5I7v4i/8ABCpoPAd3qNnrOnPfaTpbSIulX32ee5xH k5Cgbjx3B9q/nL+Nfwi1n4QeLLjwt4ntrq0urFvJlL2sg8lVGVZ3KjcHBwrAc4PAIIr+t/CDxYfG uPr5djJ+/DVX0erf3ry3Xofzd4neH8+EauGnh43p1W1p05bf5rXZ373Pf/2TP2Qte/aM8R6dYadB Hp0F3JFNDe6p5lvbCLePMMpwR93JCHrjHrj91h/wQotWtLS5n1bSbh/JDzR2upQ2tpvxwNmznr1x XkeJ3jTV4Wzv+y8tqaxunbXXz/T7z6vhvwdWZ5RDM8arOavZ9F0/DV/cYtp/wQX021e1ih1uzNvJ I000Ueus8MJZt2WV8Bh7AGvMPjb/AMELNd0fwnrmraHeWkuIkkM9hPHPdKqMCNi7D5Q4wdgzzXx2 UfSNzivmuHp46p+7ckmuVJWclva3a3e11ezZtmXgrTw+WVsRhVecU2tb7J/1bqf/1fyj+IXwz1X4 b+M/EPgjxC91aahpt5Jb2UqLgXqI5QkMRjIKsPfHFcFcWk8u7yWZFji8uXzTtDY65HrxX+4uVYyj mGCpY2g7xnFS3vv0+Wx/l/WhUw9aVGqrSV0ZmmwW7OZZbclUfBIJ/e1ZiliilmJGw9VdmwqqM8Gv V5dbHOqmmjFkElsPPEzNHOPNCFiyjPTAq3Z3E8tvI0SBnYtteVcR5A9azrQ/dO5thav75H9dX/BB OO0/4QHT4pVacz7nSSNMIm52Mme+QQOe+a/fT9qxHPwc8RtbRyyTCAokUS5dgcADHTqea/yj8Tnb xjqc2yqx/wDSj/Q+opPwmXLv9Wl/6Sz/1sP4a+E9XtP2yrfULewvp4m8XFbxLpSrxZm3sVX0HOAe 1f3U/CuGCL4faAsKokZ0mMpvfDbSgxnuP/r1/TX0ga1LEY/LnTadqcU/uR+QeBdOdDgWpKqmrzl+ q/Q/kU/4LkRXmofFW0tLKNW8+4ubW5FuxmmAD27Lt9Pvtwf6V88/sp/8Eptf/ad0e18SWmoTQ6dc BYJbS4nFs8rRgZkDMuMFsrgdcdelf0LkPG1LgTwky/MXZyatZ+i6aM/n7JOD8Rxvxpm9F3UKdSTb 9ZS9V0/DufaFx/wQD12IiUarBbec3lMltPs8rH3SzIQCeOtaFv8A8EB9bu44n/tW4aa3Uxk2mt+W 5BGD/Fkhh1XJr41/SQxHJ7rV/Rf5H6PR8E6Er86dn5vT5f8ABPzk/bD/AOCXnxP/AGYr9NfOjyX3 hZtMZptQjmaS30p4mA82RUUg/KeRxngg9a/LWx8ITTXlpY6asV1fX/8Ax6CZinmMxAJxjPr8uM8Y r+h+AuOsJxhwzHOea0o35+lrN62v2WvmfhHEfC+LyLiypw+43aceVb35kmvvuf/X9V/Zt/4JEfEP 4weDNO8Uafeobt7ZZbmO8kS3S3eQYxGmN3y988fNX1DP/wAEJPHNyHGoaxppuVjR/LjukhUyqAFc dRwOxODX+gmffSFq4LOK2Ewsko05OK0vpvrfd7XP5Vo+B69hThXu5tKTfm1+C3Mp/wDggn48vINQ tRrMBe5xNaztdW8gtnjGSI1xj5sAfKK/IT9tP9hj4pfsl6nYDxPpmoahpk7tavd22iCO2BxkN54w DgFOP9qvq/Dnxzp8UcQxyHHNXn8LSs76K29rX+eu+h8l4h+F0eFMiWc4VNpNRkm9Nbu/3L00PgDU bWSyjDswKSLxgcLn+H6iq2npGstk/kJdwJdxvLC83klsOMHPqDg49q/px+9hZNdL/gfiGAmpYxX/ AJl+h/fF/wAEhruCL4EaBCN8WNIinmTyyu15Bt2g9+Ap+rV3f/BVgz3f7OfjSC3Acy+Hbrbhik6+ WFY/gVz+Ff5VU5W8apN/8/8A9T/QbxBlfwsSj/z5j+SP/9D8VL+cXqg3M3mSrdSSK6ZYcO2Bn2AA x7Vkvcl2CqSQvHGcV/vDQ+BeiP8AK9vQrzeY2UdCYyRz/hRZR3CT/uYTc5ztiwWY/hW5zlqaKIo6 ywMs4+YRkbWU9ahgu402p5WAv3s9auKTTRMnZG3p32W4v4vtMcRt3Hl+dLytuTj5iPT1xUt9aabZ T3kaXENzbxlgJLUko59s9RnuKpxTZif/0fxIg+yxlGQvtxkDHTjoap3DQl2eKFEcjoABmv8Aeg/y fOfnjbcSwJ559qRIU8on59wcNlTjgdqANFBG0JkER3N8oUjpVNoLq4y3llCq4WNvQUASwW7IDvRW bbnDdqtWQs4HjV0Kws+6cRgByM84oA//0vwpuLOIGSaIkxB+FkOXwSaelvZzxtFGZRcY+UIMKvrm v96D/J8YpeBWiLEBeMjrmp41Me2d41mVhjB5H5UAVLiMkxhFGM5ZQQMClkUM6/JmH7uOpWtFFWub Kae5WNu0eQo2qeh6ZqRYI2BUs6vjAHQH61oCkmf/0/wYt4vs00ki4yRtHfFNYh5MSpkZyC3Nf74H +UzkloyYoWGRjaOOvHFTGSfymXKleigjp9KCXJLRFIwpAi8HcWJIHOMnNWoVRmVDIVJG4KwO1sUG QMWWQ+YACp+XA61bULIu0KTkYb2oJk7I/9T8I/JkVZIkJV84Vgc8ehqyUtYrdd7N54bG5sBW/wDr 5r/fA/yYu73ICiuhOcADAPrVu2DSQGF3HHKgnKmpkvdYR0Y2S2toHBJ8x5V3FAxITHHTtUMqxFRM FHPy4P5VklfY059SgQFdS+EUH5f7qisPxyXXwvdzwPFLvXYh5JRQNxJX0OO/rXHmOmBqv+6z0cqf Nj6P+Jfmf//V/ip1mC8W+1Ey3ouoRfSGHCYMaE5VCfbp+Vcs/mFzmXAHZRX67xgrcTY3/r5P/wBK Z8vw+2snw6/uR/JGku5ys8aq8ijBUHGaS2uLqObLxxNiXIifowPbNfLSV4WZ7MdGj2b4WxzyePPA /nxxtbP4kt4lV8hQxJx8w6AY61/rsf8ABMRIV/ZV8DzW6PDDJYrsgfICBVT7oPQZz+lfnnEKvm2E /wC3j9IyWz4Zxkut4n4Of8HOsH9ofDnwfa2QaP8As/xMz3TqSjymaGLYx9R+5ZfavJ/+DZq2ex0z xcktvKxk1hnTcpOxAqoWX2Y8f8Br6ziR83DOCgns/wBT53gemqeZZpN7cj/I/9b+yT9ui4eH9mT4 qrGVVG8IahNgHDxBLOVtw9MYr/KG/wCFNeJ/jR8aLjwp4Utn1XWfFPiRLNkeV43ctKVZgwBwdoJ5 64r6LCVKdDh1zntGV38kjkWFq4niz2dNfFBJfNv/ACP2Y8F/8G8H7YWv6KmryaRpNnaXqpJFbyam ZrxIWAZHXcm0HBBPzDNdDYf8G3H7VsMshmkMquzbYDcROm1s85DDB9jXztLM51oe0UdHsfXf2Rh4 T9jKTumeMfGf/g3s/a/+GHhu68YR6Tfai+mxNLG2lCO+lCjkKI9gJc4xwMD9a/DvxL8Mr+28ZXHw 91CzvI/EkOrf2DNYapB9gu3ulby2BXOB84x14Nd+ErTxUHJq1jx8ZQp4XEqjF3/p/wCR+4vwX/4I BftP/Gf4a6T4u0jw9o+irNpqXsFybuW7vZG2B44zEq7VBBUkn1HFfCXi3/gnd+0R8KPjfZfArxdo N9P4n1PWIrOz82COztpopW2q8cpABUkED3GM1z4fHKs6j+zG/wCDPSxeUypVadKPxNK+ul7I/9f4 10H/AINzf2qtbtLa9sdG0GS3uYlmW5OqsygP8+GBGOCR0U9OpFfMn7XP/BGH9pj9l/wHc+LfF3hP 7bYQqZ9S1PRbaS7tYIVZVyVRAowGBJYLxnrgkaYbHzxVaNOKVn1PbxeV0cLh3Ud7r/PT7up+M2r6 Lq1paXVvJAII7VfJgks5d91IGOASuMqf9nrX6g/sef8ABKH9oT9sjQZ9b8DaRbvbJp8cVxc316LC 2ujvIEcUY3OXCqQzHaM8e1evjqn1Onzy3OTBZe8bVlB3SSvsfo9cf8G3n7X9tFbJp+l6FMslunnp LqRT7K+3DAb8lh9c89qzrL/g2t/aym8truzihSB2efydQiZT1+ZTkfkPyNeXPMpRfJBI6/7Fpxi6 sW7M/LL9tb/gnV8dv2O7+Ow+JXgy+h0eec22l66m5orhh843S52kkY46/wBPzo07RBqlxHp5SNNS up/s0Nq37yeTnGdq5OAAST2xXrUm6uF9tfc8VwtiPZKOqdj/0PzO/Zn/AOCDX7Vnx78DaR8Q9H0/ S7e01WFZLDT9UaVhpyFARIDGQSx3DAbP0Fe/XH/Bt3+1xYPGtvp2mSjz3MohvFhhmyPvNk7gc/w+ /XtW1PMFUvKC909irksaD5KzfN5dLiar/wAG2n7XzaDf6mo062uraIy/2dDOZ5LzaAQXZhtXoB1r 8LP2kf2XfiX+zd491P4cfFnQbnwtqtjH/o29MQagdxUOsv3WDcFdvWunCVninJW+E4Mdg44azg38 z5e/s2VN37oYSTy/kO6TGfvYr9Hf2HP2APjT+2jqt9Z/C2GwaDQbv7NdatqFydPYTKqlkj4JJAkU ZAxlxyCRSx1aOFoutPZfrZGWBoSxOIjRju/0u/0P6eP2cv8Agmr/AMFa/wBm7wleaD8P/F8lnoOw 3FppseuJNtZlUHHDMA21flGPqK/BT/gq6/7YGheLbXw1+1CNdnmstSlv7R7xXS0hbCKskUuSrISo xyeV9sDbK8bCVJ0qS1k9fwNc9wlOnWjVrPVLS78nb9D/0f489J0rVfEmt6boWlRQ32parqUNjaRX M3kW2+aQIhkkxwoJH1r+hX9nT/ggH+1X8RPDFj8QLa705Idas4btPDtrfFpPJyC+442hX4KrksQw zg8Vtj8ZHBNKS1lojtynBVMZzVV8MGm7eb09Nj+4n/gmL+zt4m/Zh+C2j/D3xBbm3vdNto4J1ZCP MkCYkbJAJxgYOAP5Dnf+Csv7IPir9r/4G33gnwnMsd0JIbgoxAjd43ym8ddueP8AgX4jlyCrHCVn WktEz2uMEszqRVLZqP4Wv+R/DP8Ath/8Ec/2gP2ffD+oeKfF/h5bzTLGy3tqtozOtgkS5xKi8Fec Fjjsea/CiHT4LG71GzKN9otboxxiRhFEvcKSeMHI5r1W1Up+2WzZ85Xw6w9VU1fY/WP9ib/glN8f f20NDu/EHgvSrC20uz1KIfbZ5gbVscPFACMvg9Wxjkc5Ir9GR/wbaftRWslzDLZaNqC3zhrqO61I WMcaL93y/LXgfUdq8VY6TnNU1pF2+f8AX6HorKrcjqXTkr/L+v6Z/9LwWz/4NrP2qGeWW2tdMtbv aRBm+N6XHu5O4j/gNfmB+2r/AME0fjl+xfr2mXXxG8GX50WWAGTW7S0W40pZSwjZPkXCfwth+SHG KxhXq1Kig7anpYzAfV4e0p3aOA/ZM/YO+K/7XfjO90H4eaPo9y1jdQwi8utTS1a3RxuZ2QjcQAD9 0HqPWv0M/aN/4IO/tP8A7P8A4Dk8b3fh7TvE+mRHzrkaF593qEa43Bi5iXgZ7Dt1xXPLMLYmWGgt Y2v89Qjgv9kjiGnrf/I8f/ZA/wCCN/7Rf7Vq6heaH/Znh3S9JbyVuJ7jzbuSQsQFeH1O1x8wXGBw c198at/wbUftVafpRkg1Dw/LcWCPOkjRFEu8gkksFJ3DnjA+tX9c9pKyVjtnlDw6iqrd5JPQ/Af9 pf8AZI+J37NPxI1T4a/FHT5LTW7NxNCXgeO32kFt0cuPnVhyOPXk4r5NFr58jxWYJmDmEEkKGIOP yyK9aEG6XN3PJly+25ex/9P8Hf2C/wDgnP8AG/8AbUmuv+ECu/D+nQ2V69jqRvdS/wBPjeJ9pUhV bAbkjgdVwcnj+nT4Mf8ABKD/AIKf/s/eFo9I+EfxKltNEsLYpa6aPE84t2EgDMyQGMqBnOFGAMnF efisWo46FFL4Wm/Xp8j7XCYb6tl069R/HGy7W0/G6+Xqfgt/wVL8F/tk+DvG9n4e/aTfXtVtLa9S 9kuHXztJvSwUGRZsAHaQBjttPpivyBu9OXyn2GNzEhkL8Bzj/P6V9RjcQ8VRjWfZL0S6HyOWwgqk 4U/5n+bPr/8AYq/Y8+Jf7YPjq38E+BdJsfJeES32qahem00+BcnO4gbmJCn5VyTj8R+6A/4Nu/2k fs8D29/pctjMftJlsryO1jhyMFY0ZgW6n7w/GvA+sr2ro0+m56lXATjhoYienM3b5EcH/Bs9+0jc 30c51nQfsMEZjklbUma+KN0BhAKAjpncSPevlX9qj/ghP+0r+zB8MtW8apoqeJU0dv7Rvhp0/mxm 0VgW2jYHDKuST/8ArqZV63tOVpW/rzMa+HpUaDqq7sj/1P5LtX0TUWuxNe2l5pt5pqFr7TokL742 O1ScryRgdMY5GK/WX9hH/gkZ8b/2yfDf/CUeHPDWj6XYXM7Cx1LxBqUiPfROSuVt443I6YG7j+uO NrfVaUZ21bSPXwGDli3Hm+Hd+h+lw/4Njv2i7WSC6t9b8GlwhiubV7ySL7MpGNiFoPmHHquPetuz /wCDZr9oMpvPinwvZ3US/Z444FW4gVDzuz5BLH2PPvXMsdUilex6byvB80vedl6f5H5a/ty/8Eof jz+xabW58baVbav4WuDLLF4l0aM21s0yIWMVyGICseo6Z7A44/HO6MiO0NxHLDKzkKoG+PAOAN/Q 16UVzwjUTumfNVOSNeVKHRlZIMSbWIXj7p6GsTUUibdBJEJ1LfcPAyOh/lTcNNBT6H//1f46wsca RKoHyqCEB6H3q3FDuZZN3zRtnb+lNqx0xVmkeqfDP4deI/in4o03wVotvbfb9Zn8m0nnuBDbwnci qJScABiwGc96/po+FX/Bt78ZfH/hLw94hm8a+HNPuJrCOW7/ALMuvNsWkZPmWJmiyQvIB6Hg4Ga8 rH4x0cTSwsF70vy/r+merh8D7aPtZbL5f5nrVn/wbAfFu4N06+NvCjTPam2uJk3NfqgJxt2oAWPr X49fty/8Eyvjt+xDrEFn400I654UmdoNN8S6RayeXEFVcLKCMhvmHXrjIrenvY4akNdD87dM8OTa xq+n+EtNnjTUdflFmsl9i1jtWYZy74+XHGM1+/37LX/Bu58Yfjt4I0zxrqnifwhpct/psdykOlrN qVww2/xS7QhcngkA9MjqK0eiuFODsf/W/NX9oz/gkX8fPgH8UNG+G/iGHRpLLxTfNpOk6rcboYZ0 yisWl+UKQr5yTnAzgV+h/wAOP+DaT40eIvD9nqi/EvwdY2t5bqYLW1ikeWBT8u3cF5Y45JIzXLzR 2Z6ig+p5d+1N/wAEAf2mP2fvAN18QNF1PRfGdro1kXutM0uB7Ux28Ks7SfM20thccEdR2ya/nh1r w1qWm69qWn3ts9pcQXBguLOcbLizmXIkRh16gms4fEdajaOppeBvA+q+LNetPDHhrSrrUtb1bUI7 C3t7eFmjaSRguS3TK5BxnjOTgZI/pq/Z/wD+Dc/4ieNbLQPHOs+I9F015ra3vp9PnuJb1ImaJWfc xCqWDHgLleAQehrW/u3CUfeSP60P2Av2Y3/Zc+G1p8P4XDraMxZ1wUZgqoSMDAyQcAev4D41/wCC 9moSaf8AsfeLC8AMVzZ/ZFmY7Y45DyeO5wSB/vCtcBaVVIyzCPJB27H/1/5TPEV79s1OZxbSQBAi BpYysk3yjLZ7jPeuWuYJDMrbyUK4KY6H1pVUlOT8/wDIuk74e/8AW5chaGNFRIwZDw79xVSWNo5Q Hw29h5Z9c1xqPvWZondXNJ1mtITLZQiSR2CYfhVzwCfpX72/8E3P+CNfjj9tLw3H4uHjOz0WxS/e OKO3tPP80mOJgSxXoDJgEk5wwwOK4q9ZUKqi920d+V4WWJqTn0ir/wCR+ut3/wAGvuvfZhJH8SNF v57ZHUWktn5Gxj0KsoznPfHFfgP+29/wTp+L37Hnjq68PeKNLbVLYsY9G121tWlgnUn7kjLjIHyk MQCRn3x6E5RqRuy/ZJ1L2P/Q+YP+CfH/AARJ8d/tc6Dp/jDxH4xsNA0hrv7ZBp1rbFtRiY4CLk7d i5JBViTlWGOmPXP26/8AggF8VP2bPhtq3xD8GeI4/FlroNtNqN9bxaXGks6FgXAAJbKjnr1PYcjy 6clz8rPelQnZKJ/OLrfhHV7CaS38m4t7iAskVvcReV5jLgYPPY4yM8V+7P8AwTq/4JCXf7X3hGDx BdfEHSdFuA6ieazs31KeKRQpMewsi7fmz1/h7VWIqxoy94woYWtUrOmkfuN4Z/4IJfHL4faVfW/g n9p3WNHtVgMcWnaSJLaE/L8mIlmCg+oGemK/l+/4KM/spfGD9mf4n3uk/Fnxhq3jmW4id7G/v5pL qeD998rKGZsBskjGOM8c4rTD2qRco9jPG0pUWlLufmvcWSTAsWCtGMguwQMewz61+wv/AATR/wCC XPiH9tSfV5PEd5N4X8O21tGba5eJvP1CSR9qqsfGF4Ylj0+teVUrP2qgj0MDR0dV7I//0freX/g2 S8PyWUcp+KmkWFxFOJlgTw4L1AqDHlo7T4yfUoRz0r8s/wBo7/gjb8R/hF8WfDngbSXutR0LxLe7 F8Q6fAdQtFUShHidAMROoKtk4BVgQeDjxMQmkl5H0sm6mnqfoho//BtPZ614EPiCH4hy2Oof2cmp RQz2Ue9XMYYqRnOD6jaea/JbRv8AglZcD9rLUf2cfGOsabosLfNaa+u7UdWvYsBh9nOdoDHklug4 wScDGNOoqHOzz5Un7eyP2B8cf8Gz+m6N8OLnxT8P/HN/fasfDxuI7Rmisow4j3D5R13EY57twR1r 89P2R/8Agil4j+OPj7xJ4V8WeOtQ8I6j4dufskfl6Q14rt5zRMDKSuNpU+nRsE4rsw9b2uCvEeMw 8GlTkuh+rc//AAbEeDLyG3hufiu8k0YP2mKO0TN43VWYmTaD74z796/Cf/gop/wS8+If7CGs3zfZ rHxL4J1OQXGm6rbbbW6sSMB/ORVO4AISMZJ4+YjOLwfuVLsmpRSpqL3SP//S/nL8J+H/AO3fFfh/ R7OW1iGu3qWx1OeMPHbKMknb1J6gD1Nf1Bfs5/8ABvroPxg+HOm+KX+M93p6a5BFq88VrpKSW85l jWQ7xuRiAG24JHIz6V4lb3cTGKPRjhp+w5eqPpKP/g2e8GajcQx/8Lju0ktISLVoNHggYDjHVmJ9 8mvyv/4KK/8ABFP4gfse+Ef+Ev8ACFxH8QvDiBptQvGt1tNVsXX5t0aJlGRkDZPUEDPB51iv3vKO VF0tz8AfKltL+I+ZI1ut4ltNHcRGCWLeyoQRgcjcOK/pa/YY/wCCHfgb9qLwF4e8d+JviZew6nqG nRXYt7K0jSztd+HAccFjh1Bxj5geemePNYOMHZ2/4cvD+9UVlt+h/U9+wx+whon7GdhF4e8OXUd7 awLiO7A2y3pYHdLJjH0C9vpxX2V8f/hlZ/GH4e+IvAt3e/YINf0x7GWZhvVmYYxj8R+VeZkOHUKk 2urf6nv5zWdSEIz2SR//0/f/ANr3/g320TRPCHin4l/D3x7DP4utrW41KCyuwtlDJtBkljWXoSVD Y+UKTgHtX8pniDwtJ4V13UNFmeS7vdGleyufmV3nmiyrthQBgkEjgda8zE0IwpyqN7HfCm3iFTgj 9eP+Cev/AAS21f8Aa8ZH8Z6tc6HDc6Uur210NEae40dTKAoRmOwBkZPvYY7G9sftfD/wbT/Ct0N1 qPxNGqme3USC802NJAw/iQCQAHgdP1rkwMFiFJrQ78ZhFQUfe1e/kS2n/BtR8H7xkh/4WFqJWRhC 6SWCoMDkf8tCCBjj+dfnv/wUM/4IM6x+zj4F1X4pfDXVYNb07w5pmy+s7eIDUL6NeuFyRv46hvqO 9bckqi+r9X+jOfEJUsMqlj+ZbUtGvdEubnTf3ytND5skkmFuLYk4YOnUMpBGD6GsO+by0jxsnWNc h8YLeufyrKtRdFuk+mhzU588btH/1P5YrO7ZXRtqRRKDjzFLoM9zj/CqumapPLEVvLZ4bnzmSPg7 XXcQGGa+Wcbqx6FOR1tqsUE6TzzGTy0JiBXzI4n2kA4x6kV/dX/wb1aBDB8G9KJsf+PGaW5iuki2 JMsxZFC47AsSPTNfMcRN1HQp9pI+74cqRjTxNRLVxsftT/wUBmax/Z3+IFsfMRLjw7cQSSGPdCF8 pyp9sMF/Kv8ANq+IXhDTIfGmv2OvavBc6df6pObbVLGITYWTJIb5uFVjyc8c1+l0puGQK+2h8NUa WZTcTtf2RvC1pp37SnhBdLmudVgtNVisYltlLQ3iO5hdy3oA2cj1HNf6anwDEI+FPh+MW0lkbHTo /wDRpCTMxeMOAQT71+ZxVTE8WwlzWUY2t6vXz6LqfdTq0ocK2UdXK9/Rf8E//9Xof+Dh3xDBqHxX 8JabczRWaWpUGVYjJNF5bu29/wAWAx7V51/wTg/4I7/DX9r3wXaeOL34h6mt9dStLELeCGWKPaRl nRuhG4YA6D1rzuMWsFRwnOtJWPW4ekq/tnD4lex+sV7/AMEBdY0Pw3qFr4E+PviPTb1I5VtbS1H2 Kzl2qwhDrG477c4ycE4r+TL9uH9kr4pfs5/FXV9G+Jeprqlx9paG5nudWkvJ5biP7k0BYASRunIJ +ZcEEAgir4Zw6eFxEqeis/uOfO3y4iEam+n3nif7K/wWt/jb8WtB+Hd5rcuiQeIb50Oow2iySrtk iVY035HzbwCewPFf1Q2//Btf4A1T4aN4x8N/ETX38RXOjm9sWvWiSG5lKb8EgbiBnAC9B69/j61f 2eZxoczXN9x7WAwMZYV10k7H5+/Av/gjJqPxC+OWtfDnx/r95pPhzwhqBtpb20QSPrDOwjEYfOAO HO45wOgzX6mad/wbMfBRlAX4h6jOHDsLJ/JWN2YEIQ64YbeOQRnFd1ak4Vutrr0/r1udcaUJUXor 2f8AwP6R/9b5J/4KF/8ABIjxT+xMLXX/AA7cjxZ4ZtnmmuRfj982CNoXYCAw7YJ3DPpXB/8ABN// AIJ9aD+2drNxf6143k0KDR7uCNtCt7b5ZXlAkPnhyOUDIpGDyG6HGfncfhlDCOtbe2x9blcYyxCp tJ77o/qd/Y6/4I66b+yv40/4SzQfFdtrMFxKt1c232QWbso3bFX5uSu4kt749MfurrFncXfho6Y8 ywSNb+QzAb1AKFG/ma+fybCexzieLp6SfLr6Xa+57Hv55iFPLKND+S9vL+v0P5lP2w/+CFWm/Gjx H4p+LGlePH0zVLuW5vV0+5sUns7osxZVZ94YLz2B5bjHAH8i3x5/Zx8Q/AH4uah8FNSj0q4v59SS HTrjSbo3O+OWcwuZAxJSTKsQp4IK8191xFWnj8NWrz3jC++1lqfF0KkVjsPTX2nY/oN/Zq/4N7tE +Onw78MeMdW8QR2ep6toNrczebpCzxRRiNZEAkLhd3zrk7ckk49a/Mj/AIKEf8EqvE37F2rXk+qa pHrHhSWV5dLFvZm3kRomUMG5KkMHXjtkEZ5r5vhxuthHUlvZndnVNUsXGC6NH//X+Of+Ce//AAS4 tP2y7ZtQTxfPoGmwXEFmbRdIhvpHmkyAhDqc/dJ9tpyelfWX7b3/AAQB8VfA34a33i3wZ4stfEcu jI15e29xp66SI8AMxPlkhgU3cdQQMAg8fE8KVljc4q0ZP4JW+R9xm+GeDwtJRVrxv8z+ZfVvB50v VtS0q2Jhv7SdkvdwMsMUkZ2lMZ6nHbtX7l/sBf8ABIfTf2sfA1rr8/xATR73UY0nlRdIS8kjnbYx jlDEfdEqYC4x6+uHEk3gMxjRqdzHJaH1qFSaSvb8j9RbD/g2a0aFL6AfGqRJ7iNSNmlbSDnJ+QzM PTpjFfM/7Vn/AAbufEz4V+ELzxt4I8eTeIbXQdPkutQga1jiupY44y+VjUAEfKeSSRngMa78MubF RS7F4iNsK5W7n82vifQbnw14i1HwpqlpJa63p2Vuk2lkKhiqsOwJIPH86893RtOYJUYxI5WXIwXG cEY/Cu7OE6Dg7br/ACPIwT5ub1P/0P5ufh2sE/inw1p9r5iwprEcqwWiByQGA2yHsnP6V/pv/wDB O7RZdI+AHgq3k/dRjwxYxjamFkCWsJVh+LtX5Nj1Tq55hXNe9FafPc/UMBzxybEOPwtpP8Lfqfip /wAHDmvJY+BbDQ5Yo55dXYWt8ZpnhBSS6gEbgDuMyDHt36V/Ezr9lfXGsyTf2asECQ7Y1M/2gBVG 3jj2J56Zr9PzehTp5Zh3G+t/wPznD4qrVxdSL05X/mY0elPcKFeeGEPN5Y81wGb1wOvHrTL7QvsU szpJHcWsQVfNXo5749q+Tiuaq2+h7GLSi9DlrtSbiJxK6wwvuWKM4Dn0NXIrqC5DySO1u5PlpGg3 HPQEj0ocmzlP/9H+WG2lC7TkB1O0H7rPj2rTvokZ7i+tBObJY1H7xQixNtGRgepzXw57Bz2mRebe I4kBnklHlxzyBUYrzxmor63uv7WCXP7sMWZgfmx3yMUG0HdFot5drHLDeRujsUcKcSIR1BWozGyo z24E7bNzop6jvSaurFEIZJZrK3XSvKWHdILiFiQWwSSRnAxz09a0L5kMUCW7SGVH8xyygAdsVi01 oyofEf/S/lg277Zc4W4JIR3PBrOQSkyhp2iZAACjYz9K/PnFNWPqC9O8ZsvNEjSleTCMCaQnsM/T 1qHTrC3uU+0ywyWSDc32eTCnJySTj1rC1qp0Qn1LWn6Va+Xql5puy6muIlikYyYSz2sPnX0ODg56 5qCJI4Z1ium3bE4lTBkHpn6mvQt0OZvUlMyyy/umcD7u1uGHv+lVLjUr6ze1uLQefFbO/nxhifM7 ALj3zQDkr6n/0/5Z9LlfWHE939psoduJo5EzsOey96uWlidB1DV4b+6h1QOhXTpIFURwB1BVm/2g D+FfDn03PELFkimMkfkxOGIUyHBG7lifY5NM0u4JWdJ7tbhJ7zy4XWMCNRkjanfjnmqXwsxNKWzs muW3qhUMGX0yMYP6VHcQC42CPD3IlCoAcAjPr6+lXT2ApaXDqdxqiWsgtohHO28zHf5QUkKeOpPp 71+h3wUtZpvD9tHcGE3AuGSYI22KXylXa2M/eCkHHvX7X4Jx5uKV/hf5o/MPFGVskS/vL8mf/9T1 D/gljYCf4sX3mTLELK7t4IBGWD2++RWkLdhuU8H0Wv6s/itqc2j/AA/1CdZpY/O01RbkHKRMydX/ ANnknFfc+KHveIMk+6/Q4OCP3fBVP/Cfwa/tbtdeKvjb8SdTe4kgcXSoUvJPIgu5mkknZ4snHIkC gj0I7V+U37QqX7eBLi30y50/7WdVw0dyFMkqiMqYy3UAhm5GcYr+s8wjLC8Bu61jRf4I/mXJmsVx 4mnpKf5s/LbxFcXlvH5f9lW9hexSMTHFJuVvfP8A9bvXHwXV1NFFMkkCyzs0bx7ssD6gV/D+La+s y9Wf1dG6gjotNtrgSxW82BPuGZXXCD3PtW7GqafcTW8cSs92u3y4I9xDZ5k3D6V5Fdq50w+FH//V /jE0zTrqJ5Ipo4o0aD7SrvKAx7cevQ578VesA/2oIg2XBxlQPklHI5PtXzGIauz1IOyZ9B+ALTTr m9vft8kaTW2lPc2ofCrLKvQJ3zweP/1V20aWetxrdWlxGLm2BDQS5SRnDYGV9Mf1rx6sknqaLU6K 4nuryaCza0aP7NAPOuQNgY/wAevA/lS2NjHa/bpJbiea4mQqpyA6rnKoOOgzxn864KzSRpF+60W1 aCaSG2jubgPdLtlkZCEgAxkMenOfx/CrNzZXNvHH5cqPEW2oAcOmPX2P+NZUX74QVz//1v469Tt9 N0ORDYWnleQ5QpOTvuIzzh269f8APFVJrKfxJdx3mnQNB/ZdoZrk27skSocBi2TzjA4zXzyVtBVV +9kOsoIoprlppXnNyQsjSdfoPUVNqMVgxt4L1ZUgllAieNCyR+5PQY96yl8TFBaaD9C8GyS61e6u 11LKn2cadDPLIPmAYFAq/wAOAOa9CfS59GngbzXW7RyGEbBohjBUhgeT3rWnpY6UrXIZLWXULu1u nlnt5bMHD27DfebiCfMBB9McYrfnW41cKsaLC00Lif7awh2bQc5J7EA9f1rfsaQetj//1/4955pW sfKmgVhLI0CGBjLGQCVByOg47155rjQ2ZaOVMuqYQEdQff8ACssO9kdVV9DjxDHNNGSsZeTCrGcY k9sV9b/s8pd6dr2my3MckVrqMj6ba6Vbtkea3KztjkBdufpmvtOC58nFOCf9+P57Hz3EjcuHcXD+ 4/yP070CG78P6voVjdQWl1s1WEwwSzLc26SNIMNkE5AyTjjBxX98H/BNrUZ9Q+DfhYzRy3Mi6FDp VxPsEcKJCiiPavYjZ39a/or6RFPm4Zw0vP8AyPkvAKdqeOor+tT51/4K86cbv4NeI0vYGi0ibRdS ee6tYhNJPNFas0Sbc+qqPxJ7V/F5eTGy0yw06ysYreK506NrRZZCwkRQvmBuOG5wfc1630ap34bx CvpzR/U/LPGelGnxA521af3aH//Q/HG8uCbeOG2tUsYLfBlaFSsIzwpPbPasK5sobiEmT/S0mcL+ 7b5mKnPOPcfpX+t0I2Wh/npKSasWtMtCz3NxcSxW8RQhUkJVn2/wj1/+tTLw2+o3MUdpJLp8llb7 LuOVhH9o3EHdk9iAMY96tK7sc72Z1ejBtQsxMLiG1itYWjDXH7hJ3jAHlx4HLEYP+RX7Sf8ABHHx DZWvxbuI5bc2kMd1He3VrO4R3kjVojKiYyBjkHuWNfnHitS5uC8amvsn7P4GVZQ45w3L1vf0t/no f2WX8VtdeG/s2oSR3FrNZp9o6DehUEgkj/Oa+TD+zL+zR4q8VSarY+FPDMvipLhS8i6iiXkLheG8 o85wOPp7V/nBl+NxeBdSWGdtWmf2fjKMJZyqjXvRWh//0f68/G+k3Xwv+HGrX/heJ0bR9MkmaCEq CvlDIbGMcAN0r+T34p/HnxZ+1F+0XB8Ovitfg6PoHiBrDR9JFusP2oKefNlVRtYqSSARuLnrX7B4 W4LD4yvjM3lrWox5o91fr95814kVMTisywGVv+DWfvednqv67n9TX7MvwI+G3w7+Henan4N8L2Gj ahdadDaSyWzHzEHkq2V4wM5PI7CvkH9sPxH+2BoOrKnwbsZr7TUKPJ5dol1LbIQAS/ylsbh1wfvH 8Pj8JiaGP4onPNZXhzNNvsnofU59RxWHwFOjlyfMkkl8j5g8BeN/+CjF1q1o/jXStYNvcShbcw6f DFHNEOqfKqsF479u9ft3ommp8QfAMVp460S3vJLzSo7a7srmPMfn7Bub1BB7+tb8UYfLMLiY1Mqk rJ9PL/gmWQxxksrlTzNP2j6Psfhd8cfg94S+Av7Vvha78E6Jp+jHxBqVlJd2gkMyQPNLseWNTgLl pGPAz8oyT2/oS8Oaq9z4X0m8kSNi9kPnjXG5VVeW9+tRxZiauOyrL8XWleXLZ/JROvh+XLQr4dLS Enb01/RH/9L+ybU/F/w88UX8ng/W7jTrqa7XDafPc7Zwq5GfL9OTz2rno/2fvg54djPiC3+H/hm3 ubZxfSaikbpcn5twYtngqSCMdK6PrGNwMPZ05uMZ/ie4qFGqvbyj70dn/X5HX+F/iP4J1S5Gg6Bq 2n3k6gwvY28jfabcZxsZG+ZfYGovEXwO+F/jXVY9V8Q+DdG1a5ibeZbq33TBu59OfXrx1rlf1vAV VOMnGfcp0sNjKKU4px3LR+Hnhfwfpd0PCmkQaJI0yuospHXJJ2gkknJHH5Cv5ev22P26/wBp34Qf GWXw34X8calpthb6XPfRWMhEiSyLLIpXLdOSoyDgeh6V+oeFWTYTiviN4TN/eTjfz06n5l4pZvj8 iyujWy5tPms391l3/wCGOj/YI/4KD/tBfFP4l23hr4geJ9QNlJexQujaks7yyHYSNgAypDr2O3cP qP6d/Ffg3wl8RfA3keKdGsta+2WJMYvYNzoGGeW6joDx3FV4q8NUOD+IYUMvdoaOPTb8z2+DMzXE PC/PjI3nqpX1v/Vv+Cf/0/2L+AXgnwj8Kf2wPFfhrw9pqaFod3qf2mKC3TZBazRtmNUHUJhxnng/ hj93vH3kTeBtXjvJrlTc6VKUuLJTJtMkLKhwOSMkV9RxNi6+Mr4bEVpXk4x1/D9DbIIxjwxOFtpS X5H8Bv7fthK3x81bT7WAW0t5t1dtQnVhcSrgqVCdBu3ZPPYV8o6VFJbXQ097iaGO78u3E8H72TcX GDj06Zr/AEI4Hk/9TsH19w/ibO1bP5uSt77/ADP7Sf8AgkjqcN58FNHhhmnMgmliuY5Rgq0YVC49 j5fFfr5qmj6ZrltJZapY2uoWspDNBep5sJI6HHr1r+BfEiVSHGGMlB6qZ/c2W8ksjwil/JE4jxJ4 ONpoFxa+GIbfTbpLOSC0e0XyVgLIVQ4HHHb6V+LPj/8AZ5/4KAap451PUPDfjjWpNIn1AvZzTeJx ZW6pnOFQ/dHXheMfkPP4YxeDozqTzLW/fU83P6eMqyp/U76b2dv62P/U/pH/AGYvhp+1b4K8WPP8 VPFNzrlhPZtFIJNZS+VCGHyjjJ/iHJ7jrxj77+Mfwx8G/Eb4eX2i+K/DWnapb21i7ubuyWSYnZuB SUEMrB1Vgc9QK9vNcdGnm0MTlrsk1a2nX5GuMw9PE5JOjiFaTi076n8HP7a+iaD4T+MPiDwfpfhu ytk0jVZtRXV42b7RdJKpiiSTJ52KoAzkj8sfGVtHlLp4nRJgmQGOISACSWYnCnOAB3r/AEv8P6tW vwlgK1aXNJwWv32XyR/nzxDySzev7Pbm+/uYt1qErwWh/szLRTlpmjkJSUjozD04OMetXLHXBeiS 1v7Rorc9oc4T0OD3xX2PLeTR4bur+pYv7eC4CTwxSSxwxDIVMMi5wCyjoKwDZzOk0cVwUSV9zYYx yoMY2qw57ZqLGt9LH//V/L3wzprTW8FnELiSYMI49Qlbz3R2YKoBJznnAx0r+23/AIJJz+V8DNIt J3ubiaaaQxSzYIgG0KUyPTacetf3J9I1X4YWn2v8j8P+jemsRj1/cj+p9F/8FCtOgv8A4Fa/bLEi XNwQlu7LiN5WgmRcn/eKfXFfwi39xc6Tr3iC3tdIiaJr6ZosTEiQ+awLxt028YAPavkvo13eDxMe l0eR4z2jxDD/AA/5ntn7PGvonxP8DJBaGC1u7+WG5mdfM8u5VklXjHBxGwBzjj3r+8T9mG8e6+EX haZ5EuLp7JPPeJeDhduTj6D8q8/6SVNe1ws/L/M/RfA983D+Kf8AePOf2tPiR8HvCfg+7i+JRsof tFt5Nrc3umreLCSxIIOd2QwQgAfpmvhT/gn18ZpPGnxG8RaJ4d1XU5fBglWHSNOmt2sxaIocqqxt yoZADg8jPPoPx3K8qxNbhXE5hVj+6itHfrb791/Wl/rMFjMNLiZYGn8ajr/XzX9XP//W/s+/aG8A eCvGXwy8QQ+KvD2j6xFY6bcXNu2p2KXEsBVC3yEjI5XP4V/n8/tJeDYPD3xm+I/h+002HT9MsvE8 8yNEghs445AGVIQTyMYGf9k1/VX0Z8xxMsXjcunJ+zUeZLzuj+d/HzLMPRzLCZhTjack4t+lt/PW 1+ySOb8FeIPE/hHVdA1/wzI+lX8Ey266nGWtZI4EYMNpHRgyp+ZB61/cZ/wTn+IfiXx/8H/Dlz4n vbjUr06fHLJevL5kWTEMAdhyG4FfUfSLwWHnkNLH8v72Ltfyvt+LPofAOpUdLF4aT91JS+bun+CQ v/BSDQbbU/gB4qW6Nr5Tw3MEa3DYzK9pJsYf7SsqkZ9K/gwbTZrCaz1GGOFZYLid3njZWk1GTcVW ST1IC9+lY/Rqm3kuLg9uaP5M/M/HGnGPF9Ll3cPybP6E/wDglb+138E9I+wfDj4kaX/Y3iUXCJp9 xPFHeWepqMFTz91k2twc5DcdOf6VviB4bj+IXw/Mnw/1SO0ivrSNrK4SMQ4xna2BkAEEcY7V+XeN uXYvAcZyxlfWjUd121d/6+Z/QHhzmUM04Kp4em7TpRUGut4q1/1P/9f6W/bVu/2wv2avEss13421 2PQr2/aG2k07VXmRWkd9rOFJ2qQuRngDHSvUf2D/APgqDe+A/EM3h74+a34m1DRDHCF161uE1dLR 5BnMsfDmPKldwBI8wZPFf1RS4MwWd8GxxGCa+sct/wDgf1+ln+C/63YzJ+I6lDGJ+xu0vv3/AK/W 6/S39o/9vP8AYh+IXw91uwHiGy8R3moaVLaxWtxoLR3wlmjBQqXQcgquOccd+/8AGv8AFbULbVfi L4p13wrbPa+G9Q1+4n0mORxA8NqrhYYzF9AxIJPJxX7L4GZHmOR5FWpY+T9+ScYvpZNN79dE/wDC j8g8SczwWZZ+8RgkuW1m11f/AAP1OCa/+1XbxwIEjWXzJIRJv8kdwT1/OqmpQypL/o/ylvmUHjbX 7tDc/PYbs1rUK+l2dxrlvaadeqWSAW7iSV1BIUyEYwzAdK6exi8qO0upjGbVbyJlCShpCqupYFeo ON2PrWVeV6TOzAa4yPqj/9D99P8Agjhqban8IdLdRL/plw8UHmR7MRJJI27jgZAHH0r9kPiJ4j0v w3pEl/rMqQ2UMBkllkiEoCDqNp9fyr9K4yg1x7iordzl+Zni5JcIYactlBP7j8/r/wDb0/Yms9Qu dK1XxpotrqOnzNbTRP4WV5Fkx8/VefQ+h4619D/Aj45fBH4r3MrfDXX9L1VcJKWtNLXTJec7d0fB PQ889K2x2Q51gMsrV8cmqfJ1TW7Vl+H4Hl8OZ1luZY+MMFZtX1T/AMj2T44WIuvhv4skMYlZPD1z sGeVOwHP6Cvyu/4J5+B/Cuo+IfH7aja2moXh8YyXrGWNGDLhCjY9NwOPrXzuVSqLh6u4PRPU3nTh /rjSU1q4u34/5H6IftSXS+FvhZrV7pcv9mSwRK8MlqDE8C4ZcDHQDg59q/jJ8f8A7a/7SWl+NfFd no3xR8T6Lb2uv3FpYxvqpNhPDE+1UNuMcngknI56V+ueCnDeEz/C4iWNV+Vn4/4q8W4rhziClh8O 9Ki/z1P/0f29/wCCRfx++J3xOspT468UXeuyT3EjIZZC8QKlg6gf3flzz0J+lfr/APtNfDLwN8QP hh4hXxNoOnXt/HpdyLK5ezEs4byjgBuozgfWv1Tiul/ZXHM8Ph9IxkkvRWR8xh1/aXAUMTX1lKDb dutmz8Cv2Ivjz8AfhF8dfFPwk8bC5029/tF4NAR9LVdMdSS5jDdd4JDDPUPwT0H9AHjPQ4/iF8O3 /wCFc38cf9oxC4sLi1cwZG0qAQOhz2PTFepx7hsVhs1o161+ScYtX+/9Ty+B8XSzDhrlo7024tX6 o/mA/a18Rftt/s6+Mbu0uPHniGz0C/mlv7WW2vg9lEiM2VAPR1wfl6YIxXR/sFf8FSNc8J+Lk8P/ AB88Uaw+hXk25Na1KP5Iy7Y2NxnnKnLDjLZyAK+9fBmBz3hOOMy9/wC0qKaSe+7f/APzunxlisk4 llhMw/3fmavttZI/VH9o39tD9iL4j/DXxPpWv+KtA8QC402ZWg1DSnWaDch4SQjGcgHhsjGfr/JX f/Hvxx8JPiH4guvgX4s13wvpup3vm2keksIbWBCTtJL5zhQoIA5wvPFff+EnB+I/sevl+eRvFv4X 2S3+/t2PzTxI4po1eJ8NjcmdmlZtPr/XT5H/0v03/wCCU/7WXxj+K3i6TTfiD4x1rxDqtnfrZ3lz eXu63SFyBFmPGAeJc44OR7V/Ttr0Lt4au/KkPnRWDyJID/EIiR+uK/VvFfKqOT8Z/U8IrQTVkfP8 I4ieN4Bo4ys7zlF3+5H8cv7eH7Z37Q/wv+OGq+HvBfj/AF7Q9M/smK+vobGYII0kkYgFOMnBXr/S vyI+K3xb8b/FnX21rxjruoa/cvI22W6wSgkxuweoyQTjPc1/cHhZwrgspynC5hQjapOnFyfe6v8A mz+GOMs5xOb4uusR8MKjt99l+B5XbmO3vVuY5Y2itZAZbSZcrKRz/WqBgs7m5upmEkZuJNy+Wx2b s/xL9K/ZItxpufXQ+UvdKKMO7triFt9sQI0bG1x8reta0loJLZLUK8c10Qxmz9wY5A/HB/CqU/c5 nudFP2bnOLP/0/zDvLY2cMT28kjGO2CsDHudpBkDGODnjj3r+gn/AII8/GP9nrTZbbwd8QGeLxnF td5dX0sR5DldgWTOcALGfoCe1f6h+LmGxON4NxEMHNqSafqtrPyP4d8JMTh8Px3hpV43WqXk+6/H 7z+t/wAKy6Lc6alzoElrJppjC2v2THlBAo2gD6fyr5h/al8bfBPRfBOp23xhl0SPTpbVwh1e2Z1Q spVdrr8y44bPYAnsc/538K0cRX4tVLDfG6it/wCBI/sPxRrUsLkNWtVWnJ+PKfwv/teHwBZfFjWN V+Hb6emk3LxwwrYxOsNz5hZ5XUN82EJReeODj3+YLeASzR58mO5eXzC5/dQE9PmP5cn0r/TvJaVZ 4elUqL3rK/3M/wA66uITxcaj8/zPuT9iX9oP4lfCX4xeG9M8L+KLy00PVtTH9oaelwpsZmU4XCHk 4y3IOOelf3WfCm+T4j/DrS9R8RKupJe2apcRTqHhkfYCW9K/jP6R+UwyzPqeNpb1LNn98eEFaGM4 K1d7afd5H//U/sY+LXxD+FfwK8JalN59v4fu/Jma2WCM29uj7CVkkboACQePQ+lfFf7GH7Vnir4u fFfW9Ju9WGseHbho4tOuhIlyJCVPmYYKp4YHjHAXvmv1LCcP4irw5Wz2S9xJK/y/zPjstz6hV4oj kDeqUm/vf6H2x+1p8D/h58Rvhb4muvEPhnT9YubDTZ7qGS7jDY2qN3GOQPvEHjivy7/4JofB/wAB 3HiTxjY3vhrSS+latcx2TmxAnR0dOd3XONh57qMYqqGbYn/UuphIt2TT69jpwOTYdccSr9eV/mz9 SP2ptd1T4V/B3XPEPhYrbtp0aQwRRAq0asChKKoJO3rhRk4r+Q2+/wCCsf7X9v4hvdNsfGMmlxWU 5ijuLqyW3uIMZ/duNvI4wcrxzxxX6t4I8EZdxjluJnjPjjt87bn4l4ucdZlwtx5hcvw38GcU5fj/ AJH7+f8ABMv9rH4o/tAaLDL4/wBYj1e8kmCo0caSmMFQWG8YyMnvz1/D7B/bj/Z++HnxV+FHiK81 /wAM2V/rGm2jXtndBFjnjkjZfn3YPOCcEc1+ZY+dXhPxFWHoaezlb9D9mz3DUM/8O41Kiu5RUk/P c//V/o5/4JRW40TQvF3hYnyv7N1h7URRMJFJjky4Y+oLdehr9d/FPifSvDdmbnVpxbWqJlpWwqrx 1JPA6GvuOK26vE1aS6v9THKkqXC+C5v5Dyy+8HfC74021tqt9oXh7xQtqpUXE8SXLYIx/TGfas61 0H4YfBpVGkaTp3hizMgfak3kW0QBwxBPAznv/SueNfF4iq8C22op2XT5evoYzpYbBU4YyyTk1d23 XT7l9x7Gk+i+MtH2N9j1bSbpQdjbbm2lXpyOntX8r3/BbH9mjwF8NrKL4leF/DFlorzzRHUpLKQJ FJvmC/NGeM4LYxjhea/XvATNq+X+JVLAKdoVeaLXdpNo/FPpFZfCtwEszjG9SnKDv5S0f42P5i54 Y7mzjvflZZU8xRnOAewNZ8U8yoIoQqAuGPGTkZA5/wCBGv8ATemmo2P4uo2dCMurR//W/H1r27e4 ljhVwIVO+ZsZJ9APpmrJt5Y7ePUCsj+Q6zOI22SnDAggcd6/3CqWsj/L+nUcYpo/Qv8AZv8A+ChH 7Rf7OGmXFp8N/ErX2iSCST+ztZmF4bVmCsVg3LlVB34Ge4HPb+pL/gmH+258Qv2qtGsL3xo9nJeM GCx2yiORdqrnKAAgckjJPr34/iv6RXAGAyjLMTxJhviqSd1ZaXs9H/wFZH9ceBXGWOz3NY5Pitqc NHfe2mv9bn6pfG3W9V8NeBtU1zSWxc2No8kYC7wWAGMj0r+Sb9oj/gsH+0l4X8YeLPAOnNpH9lWV 8+n/AGiXTlmvZIkdkZlweT6/LivyfwD4KwHF8qixm9J3X3nZ4y8UY7IMa8Hh78laLT/FX+79D8Sf i58Xta+Lni678TeJ7mV9TZWHlyWi2ybZCDkepIVR+FfdP/BLC9msP2itPs50Emj3tkb1xIwKQS7l jj2qOctgjHsK/tbjzCRwnhvi8JT2hSsvkj8N8GmoeIOFX95/jdn/1/7sfD0nm+FtNM43D+zYRhvu lQgxX5Xftu6Z8Ovh/G3xc0XVLLw54+0K6Vkhtr6KO91OMb22pETk5KkZx0PUV9/wRQxGJzN4PDq/ PJpry1PkvEfG0cspvH1XZx5bPz5kvyZ9E/safGnUfj18Ore78URR3MwsD5kqxmFpU3CMbvU4IyfU H1xX5+/8FTf2QfhJqfhmLxxa+HIotWiumlubuDapn2KrlX74IXn0zx0Br6rhbMcZwfx+6GAlazcX 91/wZ5vGuUYXiDhPDYvFq8koSX/b1k1r3v8Agj6k/wCCe/7OHww0b4O+HPE2kaDa2d7dWsdzGYsb 0GxSqk9zlufw9K9W/ay1/wCMHgPw0J/hTp02rXcJFzKsNt5zqMMAAo6nOwc8AZ+teLmmYVM440rT zWd4uet/66n0Oa0J4DheisvXvKEbL5a2Xkv+Dc/NHRP2lv28Z9Ts5L3wDdS6YJsRsNAdlTbw+4o+ T071+zfwU8Ra94/8IW3/AAnuhw211f2Hlahb+QU37hyGQ8ZGQOnUGtOLqGWYGNN5Xrbs7nDwY8dj sNXea6O2mlr/ANfof//Q/Uv/AILDfsW/D3w3pkXxR8IYs723me6v7a4toWgaN5PmXJUkBShxg5G8 1/JZq0Ml293Pb3c7sLuRJ0YBWcq7A5x9O3rX+r30eM+xOe8B0pYptyp2Sb7dvvTfzP8AOvxNwVPL OOcbg6StFO/3mVFDcxR+X5qBCNzhTlu9VNqMWjOdpkyzEdcV++R+JH5856Fm7uIr6Q2jxFika/Z3 i+TeRwQf8962dOna1lh064hjdPILPHuysY7rnHXmnV1g0zTDS/epo/qo/wCCDmp3U3hqK2xH5ttq Rih8h/LDR7lfaq9CPmYZ9hX9Q/jnTdJ1XRJrPW44n0+UMlwkzhMqQQTn2AzX+S3jL7Sl4r4p0viU tPXW34n+lWQeyxHhvglX+B00pX/lvZ/hc//R/q+tv2VP2bIPE914l0u00CLxFLJ59xfrqln9uyOd pzjaOnTB4ro/j38adN+AHwo1/W9M1Swnn0jQ5W0yI3kNzGjRxkpuAcDk7RgEda/WZ4DiLirNMLhs VTk7ySu0/h2b+4/PsTnWQ8J8P4hYSouWEW1Fa+90Vl5+mh/MF8OvjNb/ALd37UejWXjvTYXsbO+m N/bW7C6i1Da3DySn3PGBzxnPSv60/hb8CvBvws8A6bH4Ojl07ydLjkdDtSEYThQqgDH+ccV+i+N1 XFZCst4Si7UowTa89P8AgdD5/wAGsDTqcNY3Pv8Al5VqS17q7a/Fs/F/9t//AIKx+Jv2WfHsHgjT vD1rr/m27zTFp3BiCyFBhEUsxIU8DnFcp+xn/wAFj/E3x++Iek+HNQ8GWOmWmpPvgu11B3imTcVx 5bKDkEHjJPTjuPbpeDNCpwG+KnNJuHNbW/3bHj5H4mYjMuMYcORT5VPkb9Ov9WP3g+LHwe8JfH34 ez6T4osUA1DTlnUCQMse4bto3cHk/wAq/mW+FX7Cfw20T9s3XPBL6fb3ulWWqfaLOCS0RfJBm2Ng 42jqpAHA3cdK+H8N+NMzyXJc0yuhL3HFteXf+vNn13GPCOX4rjnLMzlH3+az03ttf0/RH//S/tS8 MfC/SPhH4Snh8PQtHBp2kyXEkUrKm/yUzjIHfaOK/nm/aP8A+C0PjH4N/EfxT4P03wDDq9lpeoyW SSi9czXBU84G3gD6nIwa/oLwm4LfiXnOJpYmSUleTvdLW/a76H5D4y8bVeBp4WOHveq+Xo/ha0s+ 6fyPqD/gn5/wVP1j9qvxPL4b1DwPaaH9k2wSmG+kkuQ7vtA2t7Bj1GNv41+ln7Wn7Knw7/aC+Ht7 H40t5UmsLd7xLqI+Y0REZxuQ8Ec1w8XZTW8M/EChRwk7ypyT69+/o+x6+CdLjbw5q1cetKsHv5K6 79Uf59X7WXwssvgx8XvFXgbTNQbV9C0fW7iGxvp4vIfLvvRHHc7SQK+a76GVbe1urJIzm6hWaMkB VBlQNx64ziv9P+HsZPMeGMPjanxTpqT9Wj/PnLpKeYy5VZe0a+52P73/APgkFBdL8EfD9zHJa3dl daLGZI1O+a3dGC7T79Tg17F/wU1SOP8AZ/8AHc09pkLoF4IHSMyEloCh3f7OWTd6AZr/AC+np41S /wCv/wCp/ohx0l/xCtf9eY/kj//T/GO9iW3a+mZIPLkvJBaxWg/dAbjnj65z71itGiD5LYpzvcAc HPf9a/3ewutON+x/lTKejCCSD7UYZcYKF40/iGO59qj2Sif/AEdzE7NkurFSPYV1HNdsrvuDOS5d weWzkmqhAXMmO3HbNawWlwbb3I7VleRs3AWTbhbf+Js9xSSW0scsYR5FTd86qcq3OeasR//U/Dx3 y5AGxfQdPwqnctGkZkDFcsFA7mv970kj/J8qIhklAkceWFLHI+9gcCtKxiWQMjKFQcv/AHsDina2 wDVQ+cwUjZGTt3cZFRJdJKS3mFNjlGDjHSlZGcm07I0Ue1dgxjLw9W2MAzeuKoxQxy3E42usWd0a MclB2GaTimQm0f/V/DyRFZVEaYKnq3ANZpYwSM8IAcHkdq/3qcbOyP8AJrndiaJN+ZGGWk5II6Up jlgmSNJkaFuXiK/Mh6DmnGN9WCm+oXE0QdFMRDKdhkTuPWn2cL7pIsicOcRcHcPTitbWNE09gkgl w63Q+dBgqvy8/SsxcmQbFJbpnnigZ//W/CCAMk0m9H2g5JIwDxUUpZnJwNg6cdK/3wP8n/UYkcrv tjVnUgnC9T61eWLbAWZQgB2ruPOatQfUhzS2HBAzKspB4wCeNtWns42MLqSyw8uUO3PtmpcWiXNv YrGAz3JZVGCcBc5K/wCcVdt4VW4e2wGJXBbPCmkR6n//1/w2ks2twqM4L9TtbNUpoxKpXPIP4V/v gf5LcyQsVqyR7HYbe4/z+FX2hhSBJPn2xkOFzy2PX2ot0C62LWoTWuoTLNBZRWWYlDRQuzKxA5bk kjPp2rMFqkhIlRigHyAH7p/yKSSWwyJ7NLiBozuV14RwcEde35Vxnj5YV8Natbi//s/yrASxOEMs k8ikYT0+bnrwPwrgzX/kW1n/AHX+R6eT/wDIzor+8vzP/9D+K3xNqIn1B4EV4LlZT9tjdR8pOM4I 4PqMVgosAmVAhZcffbv71+u8Xu/EmNf/AE9n/wClM+XyFWynDr+5H8ieEQWzysrBjJ8oA/h+gqW8 SJVjnh2yBgNw3fOpFfLN3gz2D1v4PT3Fx4w8NJEgMdr4gs22yS480SS7Cqjrnn9a/wBfP/gnPA9n +yz8PbWXbug0uJlkiOQ+6Ndwz7V+fcRK2b4Rep+icP8AvcL41vvEyP2wf2Mvg7+11aQaD8T4vtMN ld+dFExV3kJXACjOeCT7c8gnBGZ+yr+wP8L/ANkvTrlPhhaz6bFNv3KsSgyBscu33uNg+gA9BXoZ tWrVaVPDS+CKTX3JnlZBJYWlUnDeo3F/e0f/0f00/wCCzX/BVXV/gXpHiD4BWHhCa61Lxf4cbTYt Un1LyIYILmOS2mlMW3LkAuAoIwdpJOSB43/wRV/4Jm/C34heFNA/aN8QXWoS+JNXjbWLEeWq2mmS b2VQVOSzADrkcsSOgx63EFOOE4fw2BjLWrq7dml/wD0+HKMqmcYnNpx0pxsr902l/wClM/oD/ap+ Lniz9mf4bT6p4U8LP4xutPtoljsIfMSSZF+VjuVTzhSenY9Oo/G5P+C0nxtmmttKb9k/xXbzTymN L1L+6MDEH7wU2w47kl6ywuAw6wsaj0029NDswlWticdOn2evz6n7ofsxfGa4/aP+GVtqHizw5Po8 uo2arfaRegu0ZYEMoDDI2kYyQM46DpX8jH/BwB/wTH8J/BTWNT/ay+HWtzWepapr1vfarpL2Q8ue WdmJmEy4Kspjz0I+U8iqy9wVadKK30+44+J4wwTjVk/ha18nofdv/BAj/gqBrnxf8Paf8BPGvhaC e/0G2j0zTvEljOUacICimaI552pyVOPlzgZIH65ft8fsLeD/AI22Nn8XdOuodE+IPgY/b9HvLi1E kMzGQSeWzAbsb1VgPXHcCvJwkIwzKWAS0vb72e7nc1Ty+lmn80eb0aXQ/9L7G+GX/Beuf4e/FjS/ 2dfFHw6l1i+0zxCnhe713T9T3ytLG/kkLEyAliw6E455I5Nf04SeHPDf7VXwSubPxNZPHpnirRXt 0S6gSZ1jnTy2xkZ6Fhxj2wa7MypYfLcyp4aitfiPp8FSnjMheZzldN8rXnufw0ftF/8ABJLwB8O/ +ChPhr4Q+a2oeEvF+tJqtrDbr9mv4oZJpf3QJJQ8qQp5xx07f2YfsqfsN/D/APZH+GkNt8NI3ilh 0Tbdw3QSSWYqA7NuVRyTn6dOgFZ5zVlWzKlB/DZP5m2EqRpZLKrSVpybi35f0j8YP2zv+DgPRf2Q /i/rXwv1H4X3OtXukzGSS5GsfYYigCHBVoW5G7kg/r01P2F/+C9dj+2F8XtI+HGmfDaXQLm8mN26 /wBsDU1kUtwQPLUKOnJyCSAB1YejjsDhsvpSnLseHw7mLzupHD3ad2vzv+R+yf7eP7Evw0/bY+Ae veFvG9mEuDpv9p2F1DDGtzZzpCTFICADlGYkc85P1r+JL9gT/gnF8GLn9tjx78JPiprNsNV8B+IJ 9I0jyZYNKutXWO4bexWTLyDyxyqjjzOo4FcEq9T/AFfrOnvFfnZf5nfRpU/9YKVOfVv8P8nY/9P+ xbSfh5o/7M/wrGmfD+xlk0XSNK+1W1pCArTlYAU27QAQdo4HFfzo/HL/AIOFtc+A/i/U/Bfir4Da reXNndS21vPBrQs7iV43KkNG0HYjqG/CujI8LTr4Wz3R7OcY+tTzBqSev9W+4+/f+CbH/BZb4eft varqGgX/AIdPgTXbXcr6df69BcuyghcspCkg5A4H8Q98eQ/8FwP+CdXwG/aM+E2p/EZ7+PTvHuj6 TJPoV9Y+VKskkatOItvdHI5xjBYHPSujCxlRzJ4aK0eny/pEZrOnQwMcU5XTX/AP833xDZQ+HdZu 9JVpzNa3ctnNPMvzTvC5Qtnn0ziv1G/4JR/8FCPGv7E3xv0Ozs7CPxR4P8a+IIo9YsrmBkubHeyo WgnHyqfu4VgwbGCB94VmuHUqdTDy13X3f8McmS1lDF0a3S6v6PT8mf6jv7OfxUf4x/DTw746GmSa M2rWMUzW7uJCQyKRg4GR1PTvX8h//B0boen3tp4JtZ1j+w3t1fy3NzbxL/aEbI8G0Rk88M2Tj+73 rLhZRrTnLyf5ojj2j9UxVOhHpNL8D//U/jx0PU9c0HWrKe0tEtbjRL6PU7a+uwJw7QsDFvQY5yAT 6V/VB+w9/wAHGPjL4IfD/R/h78S/hYNbuNLsk0yy1zTdYNtFKFEcUJljaJsdDlhIDxwBk124zBwx VSMpfZ1OzKcZLDxlh/s1LJ/J6fmf2w/sOftKw/tV/CPQfija6SNNh1ixW5WPzi4O9EYY3AH+Ijnn AyQOg8g/4KQ/tpSfsU/DZviFceH11q1iuUWeGS8NskpIZkiyM7c4J3EHp05rhySnHGV5QatFv8j0 +JebK4wV7uKX4/8ADn8fv7Zv/BxEP2ifhT4s8AQfA68tZfEGmXGlWupjXxcWaidDB5hjFsrALuY4 3dfTmvx8/wCCdv7Nnhr9rX9rTwv8P/FKzQ+HZI4tS1SKFxC90d65UnnGd20emepxXXmLWHwU40tL J29Tzsqg8xzGjTqaptfduz/TM/Zn/Y1+Hv7Knw5t9N+Glr9ggt9JU3UTqoDbFDE5A68Yz746Yr8R f23/APgvTJ+yV8ZPEHw0f4TT+K9R0nEJurHxALJLcADcJVaF846c4zjPc4wyXA0p4Kc5LbX7z0M8 xs4Y+MI6K7X3H//V/Sf9gX/gvi/7XXxpsvAP/CvLnQkaBY52/tL7XNGS4UtwiYAJA6ckj3K/uf8A tl/sffDX9rv4M6p4d8dWTzi4046jHLkPLvWMheccEFiQT/OoUqax/JFbWPq8Rh3DK4Yibvz3/A/z 7vh58WPHn/BLT9urxP4W8Hz22vaDonjiXw9Ja38Rie6gdk8liVO4NsKAgErxzjgj/Qv+Cvj+w/au +AWl6j4l0SHT7DxXoohvLIS/aUBePaxQ49S3I7VjmWHhhMz5Yr4t/l/SIymk8VkksTJ6U3ovU5/4 d/Av4afsteH/ABA/hNbHTbaT/iZSI8aQyTshBJOOT1Az9B6V85/sqft6XH7RPxq8ffDnS9KWSz8K 389lJeLcgQKI5jFleOc4Ydeq9PTZ4anSo1Kz20t6tfoaUatbH3cuif3J2PnP/gsZ/wAE2fhf+0f8 JvEnxT1ATaB428I+H7m9sNW09FkMYt4pJtkinAZC2Qec/MTzgV/m4eNNBXwzrk1gjWogt557WC5h xDcXYimeLz2j6LuKHjmvWpOMsBTkt07fKx8c58mbyovqr/O9v69D/9b8Y/8AgmL+3P8AEr9j/wCO Ph2bw81rrPhPxZrEVprOgSQCOZ8lEMgcDO8cFcdcEHAbI/1BP2ffiePi78OPD/jhLQ6c+q6TDcvb x3BkjR2Rdw6Do2R+FeJjFGGb/wCJL8Lo+xoU51MolWb0h7tvXX/M/ka/4OiJj5fw0t4lkgnkub6a 4jhUKLwRtAcFh14LcH+/7V/Gv8N9HtPFHjXwdoN1YySWHiHxDbaY0SSHdsnlVG57naTj3FfYYhcm Bgv7tz5fI1zYipH++/0P9K//AIJlf8E1fgv8DfhB4N8UeGNLksfEmo6TBqklxdMt15rNEpcOQoIG 7OB6Eegru/24P2o/jr+ztBa23w3+GVx49+zRhJBp0Ex8sBsHhEYnIxjA7H3I+ZyqEa/NVnu9T6fP ajliVhqStCOi/r1PgP4b/wDBUP8AbF8TeMdH0e5/Zi1vw3pc1zGurX11Y3jW8kb8bgzRKq4zkZzn H41/QNpekWH7QXwiutH8eaVHDb+JNE+zXdpIm97cyRAMCpGepZT06V3VZ0vaKMDzvYt4Vyn6WP/X 4P8Abp/4J3fA74B/tz+FvC+u6wujfDvx9qCz6hDe3Edla20MtxtkAk/hQHnHYv1x0/sG/ZB/Zx+F HwP+C/hv/hTkNqdLfQ4bOKWylW683ygD94cLnPG3HB9hXPmkHUxdGbXu2v5X2PsMuqw/sifsFqpW fe233aH5Nf8ABQr/AIKv/Gv9jLxhfaWfg9Jq+gx6i0A1eYTQ28ke0OmxthXOM5OTyvTqB8q/sef8 HGV18WPi9oHgjx/4D0vwboWsX6WMep3fiARgOWwu4uoTkZx05wPca4vDRp0HUppPS551Ks511Sb0 Z/QJ+1n8NP2ff2s/2f8AVdI8ZX2larp2o2Z1C2lhuI5mgkEZ25JyARuyDX+Yl+298EfDHwC+Ofj3 4e+Ctbl1fQrW/c6NeyqkqWxJ3eUNpI+VSuR6104CEquXSrPaNrfM8LFL2WZ8ve/4f0z4elvViuZI ZDNJMFHKxkqf+BdO1M2SOzyptk+X+IYINUaP4kf/0P497RI5FR3QmUNhgO3pmt2O2t8KuCj5ySOd 3t/KnJ9Tpjuj1T4WJ4603xnpepeAWvX8RoYxp1pYxec0khmQDKnqTzgV/Z5+z3+3n/wVA+H3wx8L 6Bcfsz3nihLKzitzrcuhXpF+oQBZT5XyIxGCcjBOTgZrjxOGpVMbTrv4kn/X9fPY9aLxEaV4L3L/ ACufpn+xh+2l+1x8TvHw0b4sfBmfwrY3xIM4srqxitGVhwfMGGyD6g/LwDyV/RP9s39kv4bftU/B vW9C8aaZ/pq6RJcWl1FITcQSFC2QTwcEf54qYP8AeSRFeFkpM/zHP2ufh/pXwP8A2h/GngjwpLeu 2j3D2o1S5YNLBNbuYklIHAJwrfh1Nf1Qf8G+f/BQj4w+Msfs7+N1j1n/AIR+IW+na8zYkNsAAsb4 A+7yQeuOuOgKjs7MijBtXR//0f65P20/2Y/A/wAcvh3L4m1K2+w+LfDtr9u0nVrYn7QkgBKncT36 EdDgdwK/mGX/AILUfF/4C/G60/ZoTwrbeI7DRdej0X+3bu+kg1CYI3lZZIztI+UkZB+8Bx1HBZ7n t8vvKKP63PhXeWP7QPwZ0a68ZaHCbbxn4fV9R09pS6wJcxA4BJ7hs5+lfxD/APBaH/gnd4Y+FH7Q GiT/AAT0pTeePJilzpcZEbyStKY0KICMlsJkjv7HhLyOtR92zP0R/wCCSn/BKfwr4E09fGfxn8A7 fEU9jFqtveXFvNFNZzb2LICzbfmEq8ADmP24/cn9qn49+E/2Vvg7f6hoV7o9pe6fZx2+mabczjfv YrHGvlqcljkfKMcdx1rVfARJWqanf/sK/HTU/j78L7XxtrFgli167m3nh3iC6VWwSA3PGQPwz7V+ Z3/Bwr4gltP2T9a09kM6SX0ccEik+VDmKQ7vQkYB/wCA1rl/8RNGGZ/C15H/0v5SNWF0b+fzr4XU 6xrCqOFCIuM7kYcEEEEVkTN5ciqMONu129x1NOtFpt9zSjH/AGe39bmW1zFvmhidgyjBfGVB+tOh LYBmkzsOULHqR0rii7yuWlZWO50oR3dtNCYRN+4Mj7ZfKLFBnaD2zjtX+hl/wbu6FbaX+zhpQ8u4 WeZ1luY5GPlAtF5i49gZG/MV5GZU28RSn5nv5E+WlXjHex/Ql4o8Q6J4cie41e/tNPg/5bT3MgjC Z96+efiL+zJ8C/2jEg1Xxp4R0nxTsj32l5tS4VwvGccjOAPrge1enytQsYU3r8z/0/7GPh34B+CP 7PX2bw74Wt9K8IpcSJBDZq62hlcZCgJnGeMcdlr3Xxb4L8JfFHwnqOi+KNPh1TR720ljuFc5+Vlw SD+o9xXkQptVWfVc6dM/z5/+CzX7JXws/Zx+MU934Egu9MOphp57S8mBhdrmSQK0KgYwAoIA6ZA6 AY89/wCCOP7Xnxp+CHx20T4X+HNc/tLwR4n1KMPpmq5lW1lfcrNF3AyeQMZH5gx9O8HceBqL2tmf 6M/gq9udc8H6dqt4VW6ubJpZxGpVRJjO3B59q/hH/wCDkOcv+0H4HtUXdc2+mvsZD5aSj5VKk+o2 nP1rpy/3KUnb7J5WbSU5xj/ePxo/Yk+EvhL4t/tHfDXw74ts4NT0r/hIbMX2k33zWs0c1wsZkK5+ YKdoP1r/AExPgD+y/wDC/wCEHw90iPwD4Z0bw8bTS9itp1mtqyqiDHTjHyj8h6ZrxOX/AGxfM92l OnHA2hu9D//U/Rz/AIKe/wDBUP4yfsv/ABF0fwT8PbvSb2e4O6aO/XzESPcUU+WhU5Yo/JJ6e4x+ jH/BPdJP2pvh54f+LfxM0mxOq6hZm8gjtMmESMxLSAkkjg9BivDzByjUpwj1Pq8LGEoSk+h6X/wU b+Pmv/sifs/+IPG3hCCO5mjVdL02yuwywRvJG+xnwQSi7ckAgkZGR1r/AD9/FP7ZHx58U/Hxfj5q XiZtJ8Uza9GbaHRg1h5cCSiOJNoPI27Qc8sOcjjHZOHLgednEtcUktj/AER/+CePxm8UfH79nrwr rXjz7LcalPpaJKUt90cioqrn0OeD+Br2vVNA+E3wgn1rXjFofhi8v5WeXUpJI9OFwQC5GTgZwDxy eK8/Jpzng4X6/wCZ1ZnCMcW1E/Nn4Hftz6x8VP2tvF/w+8Maxp+veCtK1GWwhvLSVb233xEKyrIh wRw3OWxsbnsP0G/bQ/Z1+Gfx4+B/iqw8ceGdJ1KKPSJZYpJYl+1Qsqb1aNyDjBUH2255ruptrG8j 2M8XTUMLGfXX8D//1fw5+OXwmtPBHxw8WfDnwB/aZni8RMNGYXiRwafub5fJkGMJknk88j3r+jn9 kbwn/wAFe/hd8PNO0zwfqdrrXh+KxgFtFqM9rdvZwrGojRJHRchlwep68EZryMWovGP2b0T0PoKH N7CM6i1a/rufqV+zj4i/4KP/APCydHb4x6dax+HrqSP7Rc2LRy20SDJkHDnB6Lg+vpyP2a+JPwl8 I/GT4aaj4d8d6RZ6hDJp0qylogHbem1gG9CAOPYVlhqlSWPamtD0cdSofUacov39fu/qx/mqf8FO vgD4E/Z//ak8aeG/Cmm3dloMU91IqJeGa1Z4LplUInYqQwGCMDbXPfsxf8FI/wBpr9lrTn0r4feP 520fVb5LeHTNWY6jLZNISAbcOep3AbQR0FPOlZaeX5nk4JL2ybP7w/8AglF+0v8AE39pb4N6T43+ I19a3F5dMtrsjjUOzeUDgDAwR8ufUk9Og95/4KHfEzxP8GfgrrHjnwbf+VrOlbJoYZm224JWRiz+ oHl9Pc/WvM4alz1mn3Z7PEEFThFrsj//1vi34yf8Fov21PiLpXijwjL4n0ODQtUe40uGY6atrqNv Ed0ZMTR4HHZiM/SvlL9hvwTbfFv9pLw9onjOOHxBeajdQaq7XsAuYdQYS4MRj+6wLYY7h1UetfO8 RV5UcvxHLulL8mfV5LShUzWi5bafmf6Rf7Pf7O/w9+Gfw40u28L6Fp+lXcdmILqaxgFo85VFUl9v pwMdMCvzx/bh079u+TxEkPwA1Cy/sS0QOIWmjWUKMD5iVwFyGPU9e/Y4Yn/sMb9UXnb/AOFCaW12 eCfs+x/8FQLDx/o8nxJ1rSp9EJQzWkQW4gKhgdrgJu4GeVP+I/d7V/Amj/Ev4dy6B450u11MT2LS 6hDe2oMUkiqcHB9+RXS5yhirrv8Aqck4KWEP87b/AILGfs//AA1+B/x91y3+H+hr4fv5tQktWs7Z 9mkToqxudkYUYIyQASeo9K/F24gl8rfcKquVyBgqGB712ZlG+IfojxKH8PQ//9f+W+xaBXIKLKAp ODgqx7ilfUFubpgNoMMYJjYAFQOMACvneS+hu5OEbhp09xNdTDbc2E0RVpGEIuYvLY4bZnr8ufpX +hV/wQU01LT4JadIN8cc9jDbWsSgKJAE8zp2Jypr5PiOShLDpb86PteFU54bEye3Kfe//BVLXb/R P2XvG9xFqElnEdNFsWAUicSFtyc+oRs4r/NA8T+JLt7vWNPnixNdajdKuVZDbRNOzIEPfg4GO1fp cUp8Pw+R8dL/AJGskz7H/wCCaGl3M/7T3hO6u76++wafdwpbWBPmxzvK2WYjOTgLx71/pn/DO0e2 +GejzOiGaPRVaV87d7rHgFvoAv5V+cYB24pj/XU++xNNLhZxXf8AQ//Q4z/gvjqwl+P0FrLJZ3mP tMdtBPIqOsoW1xIF6nnPX1NeTf8ABGf9pX4n/C/49aN8P9A8RahP4dvLqFhozoZ7RDMxbaPQAqeu QAxGM4x53itUpTynDVaOjjbb7/z/AK0PW8OqTnmtXD1ve33+4/0EvD1zcXnhSPUbxi1x5LSySYCD ITJPH1r/AD9P+C7MsmtftGLHLfo6x+J9QMEaEmQeSkMf3v7oZG47ljW3BdRLK583WH6EcU075laP SX6n4geEdb1zwjrFnq+k6nc22q+GL1dVsNTsna0kEgbojAg5UfqBX+iv/wAEffjp8VPjH8A/CreP dWXWEt7XKT3ISW5cBQoycZP3O+eWPbAH57xDKVLO8JKl1lZ/ej7jhinRqZLifafElp9x98/EDSPh L8NtWvPFuv2WkaA2pHfPq32dbaaaUk43sOTt259gPbNfnN4d/bTu/HH7VMXw5+GnibSNY8M2TeRf fYp49SWLylfzRvU9dyAEDI+9yT0+gzip7HBTrrdGGT0oYjGRoM//0f7GP2lPgR8O/jl8HvFHhb4h 6NpurW9/pEggeW3j8+D5N4aNzkqQQDuHIOK/zs/iF4z8dfsLftO+O/DvwN8X6votloXiGW4s3e4P 9n3MUUhULIq/Ky5+XkcgdOAR4+FaxPDyvuj7Op/s+fcq22P6Tf8Agkb/AMFAf2h/2oPFmsaV8RLq z1GPRLCMl47NbWScNJjej9GB2DGD69cjH9HHxh1O50P4d654gt5Gt59O0eXUvLUYx5cZk/TB718p w5XlWzarSfR2PpeJ8NTp5fTqR6q5/EH+1X/wWc/as8FfEPxf4H8HW/hk+H7DVZdPtL7U43u4oguG BJVxuJRlBAHG4dK/GG7+KPir46ftA+EvHPj6ewj1rxJ4ytXvLvRLOQLGxnDKoV3Y7Vyo6k4Uk5Nf bcU01hcFWhHdw1PhMsh9ZzLDz6Rdz/Sb/YN0S40j4E+EtPhupLyG00yG3S9uV8tymwYXb26Lx2r8 Jf8Ag4M1uEaNp+nXvlhoZP3cGcl0uH2HI/2gh/BfpXzXA3PUyaMqmrsz2uKacY5tyw2uj//S/TH/ AIIHaHbx/DuK5t4lhi+1tcXEpA87zyZdmB1IChRnsK/X3/gpR4jtdC/Zp8cXdzbrdyXGkzadHmL5 WlnRo0dm/wBnqP8AdNfmvALrf2/jHU/5+yt6I/WOL6dGGGw0Kf8AJH7+p/mdfEHTLuL4ga9a2NiL GeHUTqV1dwkXMV05Ykoc9CSAfpiv2d/4JveB/wDgof4atk8dfAjTLvV9CvG86LTdTvo7e3nBzgxW zum4L9e4r2uMlGvmUXKN236dDwcki8NGai9D9ovD3xT/AOCrU/ifS4PHfgvT7e3t5VEwtrlFaROT l1EoU9upH1HWv37+HVtrXj/4bx6J8RbKA3s+lPbaguzzEVzGB1PUDOPwPFZUG6OYU6fZHRi1GeAl Ndz+Jv8A4LkfsffDL4H/ABB/4SrwPbXFvN4llS5uLfT7xYTDc5kG8x9CgBPynP3vpj+cG2tZV1HU pr6NDBAS2BNjeo43Z9TnNfS8QUualQn3jf8ATX7j5HDxetukj//T/nY+ANjAfiV4cUzGC21LUPs0 dykW6SJ5CNrkd0B2j/gVf6eP7Ets1n8B/BLJu2HQLXecbvl8lNv0OAOPevxzGqc+KsNzO65WfrOW V6X+quJhKylzI/nA/wCDjfWba71Dwfpr3Eqi4vbW4YIMFAGnV0z9VQ+2K/j7luLy0mvjLc+YY5mW EoxJSM5Cg+hxxiv0/NK0pYWjBrY/McPTUcRVkurOOu7hridPJRFlUn960mHjJHUfWpmWSaxVHu5Q VY42ylnznkmvBqOMG0t3Y6cTUnKUEtitLZC8NvHbEqI2zKc4dx3H41Wu7KxzDcpefYpIJwkkXTzv QH6Gsdhwd1Y//9T+VDT49K1K5uYL68w9lKjJNCRKsZJ+9kHIx1+lT6jZapZ6xLZXWrxPodx5ctvc 2pDnaeMsPUnPXpmvhFO7sj2BZdI8m9urGS5iinhiM9rLdgoJgAMKjAYDEdASM5qOxsL+8u3tdsaz RRjZdXMvlQ5fj7x4wOOvrVmtPaxW8T6DrWjS2drNFDE/liSYxzb0mz0YMM571Pp93NZJFJtETA48 1TzKDwQRQWQ/2rOmrwyIyQWOnDzboDkzB+AAD/SrTrcNG7nyzHId0ci8Bh1FRKN1cuG5/9X+VaGa QW+JokkWNj5XzYJojZy9tNAsPmRTqZo7jJQpnnp9K/Pz6gs6pbIbolP3L7hcYgx5XPUD/PanpIDI JLmdY1CYd5CThR7fhip5fe5ik7JosxxwXxeK2kFtbTxgiSAEEEjl2HfPBrMSzCXUhm2thfKdjlQ2 D1rraaOdXk9WW3vfMAFtbwyJF+7QogDbhxyapWEep3Qee7FnEpLKLeELF5e31Hqf60hPdn//1v5c dLiBgvFeUpdffRCw8tFGQAO+T/jVOztL5FuJJPInDsZPLjY+afXr6/0r4c+hsy22nCeZbq3iMtxb oSyu5CbeM8VfshI9vIsdhpzNbzFxIk+bwEjldnb/AOueatL3WK3Q0o4LK+2wxuYbxlG5XYfKT2rA istY0241S8tpbbVBMFtreB2EQswCf3iY5Y9efSrprSwW1sbXhG0jinnkd2LXV0ZJBKxYK5wGIJ5A GOB+VfoL8EZdPTRLmK4s5YZYrrz7bUHkxHdHy1BXae+QDn+lfuHgjH/jJ7rpH9Uflvim1HJoJ/zf oz//1/qX/gkb4fjv/Fc2s6h5cF1qs8cc9qxRJkZTtTnr0QDHbPvX9IH7QupC2+D3iRkt1ZoNJmfE jbHKR20mWX06V9p4kVPa+ItVf3l+hnwnSVPgmjr9n9D+BD9pGW61D4oeLZdUnlhtrfxFdW+mq/7w 3Cqcg7QeSCXwewavy1/aLm05t2nN/acAihW4mmOLSFJSQHVecscbeexJr+ts6qW4Cnzf8+X+R/L3 DVL/AI2AuXZTPzQ8SzRLdyrBPcXKpK0ayTtl2GTjNczp9qxuRMhSBoW8w+Ydo69h+dfxFiJL27R/ VbfKtDuohPJcobWWRlmXYAvUL3zXX6eiQN58yMfJXbkrlm9cV49a3Mawk+XY/9D+NGVLe5llkbcb Vrby9wco4Y88egq3pd26u6PbrthAMMufncdOlfK4jqj0D1vw81xLZzavC2FsoFkJwCXRjjbzXpOn 3FzJcb0jgjj8tWkKqQ+T3H5CvGrbmsNrHd26zGI3KGMbMKyu4VpM56DqcY7VmxTLFfOZnMZjG+SW UfuVUk9c8dq8+u9Gaw3sTyROrNqFnN9oSVQzQJt8vjvGR6g10Fo7y2H20zW5SAkNFI4Fz/37PPH0 rPDtKWppTXvNM//R/jy8Vg6hGYrdFu/Nj2efGhby8YOOmcg5FWGtbC5spdO82S0e7sVt1aCQxMsm 1QzHHPr0rwIxvIuavORmpZzO0elyKV+zkQ2074Dv06v3HbJ6c0axDcPK2j6nbxwxWxVESKXzI2GA Scjpn2NZOLbHTVjc02zubydLGwmWO93CKNGlEUUoA6bjx0rrorGSeJr25VTHYzhXtPtIMoYd4xnn 6jPWtIK1kaGhJaX4isbyxhZEnkzKzrhosfwjtk8Zz0puqP8AbtHe7vHGmx2/mWk6wv8Av9+SEds9 jjg1sl+ZUXZ3P//S/kLe40x9NjhsrWaOcMYFXaRGwAxvHevKPFVhc2kbPdjz4XG0SA/MhHPX8q56 Dszom73Zxmk3dvHqKItktwzfLErgloz/AHuOmPyr64/Z58ZrZeM7YeZ5F9pzBYh9mW4GJGVQSpyO 2OnBNfW8LT9nxLg5f34/meFnztkmJS35JfkfqZbWWqi3d7hInv7eZJ2Vn2FFikSWRs9iFVsAfT2r +5n/AIJb+JL3WfghYXypGq30lvbweQ58uPNrFucA9Vc5OfUmv6b8f6alwjh5vdW/Q+H8BJtYjG00 9P8Ahyz/AMFQ9Mtk+B2ttffapWS3llVY3VYnURHepBBOSu7BH61/ElfaXbPZxvdHc1vH5axyx7GB xjgH1wK1+jNO+QYmHaS/U/PvHKCjn0ZLsz//0/yDitpILryfMtvKJDMk6C5iGOQrKQQegHSucbUI 9F1O7szYi98zCMIpBF9hZ2BMiqOuATgdOa/1yhF2sf52SasUtTuvPuIYnlYPuUR7gIwQD3A/WoLy yF9cGX9+jBFjJQ7IZNo2jJ/AVUI9WZ8y5WjoYre906Kx86EXELYuo1jlDqvO0njOG+Xvz0r9fP8A glbf2Q+OvhwTO6HVZ3N1LIMIiRtEscQPv82c/wB72r4LxMhz8IY1f3H+R+xeB00uOMLfzP7Z9R+z 33heRGQIbi1hVRBkKQdobB9P8K/mt8R/te63+zR+11f2OsadP4n8PXskslzYXepPA0C/aCnmxN1P lnOFJA+6Owr+AvD7J6We5ni8sqreMreT8j+tOMc6eR5thMX9iU+WXo/6uf/U/r98IeN/D/7RPw7n Giebp1prummC/jeUXT2Rmi48tsDch3cd8e9fzoftY/sY6l+z98ctI+JlnLFqGn6pqVzJPKY5FHme WFEmduAQJRznhkHHOR+n8FYx8O57i8lrae0i4fde333uZcX4dVp4TMIq6py/CXX8D+kL9nss3wv8 KQxTNdGLQrVGk37zMfKDbienGcfTFfMP7VX7dHg/9mh4H8UaNa6ksyhEhQy211Lt+8TIOMjKjGPU +tfJYDK6ma8Rzy6k/elKSX3no8VZtTybDf2hV2j+tz4sP/BaT4ONa3N7J4R0K3v7aAuYZvE8jyCL 12CPrjtu60nh/wD4Lf8Awdns5IbPw3pyO+5ra4mvrq2tnKkZCboyGIyeAQa/QqnhNnKj719+1vwv qfnH/ET8FGrGKSs13/4B8NeNP26PD37Vf7TfwyutE0LT9Lt9N1WO3uJXkmnnuzDMZN5BAwu0Hbnn 5RnpX9UngaOObwJp0QKIf7PKRFTkSBl3B8/RhXi+IWR1OHcBgcvrX5km3f5f5H1/A2ZLNsBisbHa U3+rP//V/cbxnqGp6X+2TZNZ3Ur2CeJpYltTnCRRwCby2B4IbcDiv2f8Qol/4JuIyrt9v05ciBCr YbBAAP5V6mcQf1bCW/lPby+XNgqrfScl+R+On7M+uXQ/aq8VabcvMtksrval12pG8MhIA57natft 9FjaGjADSfM2BjHtWnFEFGvQa/kRlktT2mXKT7tGZqkLyWzbdpkAyhccMR7f56V/E7/wVujVv2kb VRYfZ9PFrq1m15b5UygXKXCq7ds54HoPrX6H4Du3GtP/AAy/NH5l4zx5uGYW39pH8mfPv7ATsP2o fAkca3NpDFK13NPjELSSNEgLP7Kpx7gV/ejoRmk8Lx4EUkUenEQqhHRY+Dn3xX030iUlnmES/kf5 o6fCiEo8OVebrJ/kf//W/anXtVtvDv7a3mXz2dmLrUjbsLu8jtFu8sZWZN5+b5ABgd1NfuX4gis7 zwSUt5jcQz6V9nhWFxL5qmMhNpB+mK+hzunVjh8FUkvdcVZmvD9SnVyXEUk7uM53XY/iJ/4KS+AP EFp8a5fE8vhrVrfR7HSpNOlvhp8i+bJHMQI92NuQu3AJBIBxnFfnPplgl5rGjG0iuriW5vla2tLO I3F1dBTlo4kHO/HT0r+9PDfMqVXgjDvnT5YtP8f0P5A4ty6pDif2MY6uS0/rzP7Af+CSugeIvDfw yt4b3T9V0zTbm7EFidcg8i7IJ3ybgR1BB+mRX7Xm6tRJ9mjnt5XAwRDcLKQfoCa/hzxFrxr8U4yr R1Tluf2dl1CVHKcNRqaNQirfIyvE+oXOlaHdX0cbN5Nu8vzAlXCqWxz64xx61+CHxv8A+Cw3iL4O /ELWvBa+ALLUY7C8MdtKtgbwyAD+58rdjypbp2rXgHhd8WZhLL4OzSv/AF93mfLca8Qf6uUIYjo9 P626tdT/1/0Zk/4L82QuiifDvT7e/iTYEGhSxzlgfvFTIV69ql1v/gu/qGuaHPYWXguP7TLakTS3 tibaJWbgEKkkmQO4Cjiv6dj4BYyc4zcvx/4B+LY7xYpywtShDez1s/8AP/M/Af49fFS4+OfxK1fX JdJ0rR4rjTfOlu9OuJCdSmjkaUllcnBAd1wMZ2r6mvmpr60uhLaxKZdNkdVuFYFSzIchlPB6jOK/ sLhbLf7JyTD5be/s4pH8r15yq15VKju3Jv72zba5tYNMXSRps0N8+oebBqE0vljy2UDYy9x/EM0t 1NKLIQWtvDLPbMPnWFUJyRku4GW+hJx2r33HUyULtpEK3N/p2+4Tzbe+v4fs9raRQ/aPtIPBB9B0 JJ496fbi0trB3ucNqKMoltQDtmP8YR+nBzUcjtcztafKf//Q+BNNjWO1057e2W1tXuIbjz1HzREM pVn9cY6V/Xx/wR/mvG+EOnRXWpPdskri3ZVCQyBZpSx29sAAfjX91/SLjfhRPrzf5H4b9HJ2xuPT f2F+p9y/t06LLrXwQ8QiIkeQqSnYwRvlDtgenIXkV/Ab4wng0Lxz4i0qxjuJLRNcntbMTSHzIlTt j0DZH4Zr4f6NNRvDYyj0umeZ4201DPqVXvFr8Wdf8EtSufD3jfwzbXwS/tbrxILzZNcGN7Qt90Ke /wBK/vv/AGOdQgv/AIM+EpYEWOK309F8yL7spdV4x7YxUfSQjJ08NPpc+98DZr+w8VDzv95+V/8A wWWsUh8A6je+TeSx2Fml8j/6uMSR3UZBB9hjivmb/gjj4qk1bxRfaXLPO19YNFczTKjK4aSIAxux /ulZFx/se9fKZDBT8HsU+qk/yZrls3HxWnBbOH+R/9H+3n4o2kV34B8TrJIxkPh27iRQMq7eQxG7 2JX9a/gb/a9tH0z4+eN4ZF+0Sy3kVxALtf3e14g+xG9FcsDX9MfRokln+Li/5P1Pwv6QEbQwTe93 /wC2nyzbambTVrb7akkmJi8NnHKFttxwu3dxkHORmv7V/wDgk3qUd78HtHjg3QxxQQl98u5ZVVTu AHplzgj29K/SPpERtwnF/wB79UbeA0+XF4ul/cX6nv8A/wAFErPzvgN4kK26zRq4lVt2DC2x9p+n ynOa/gTvBfWLR2Utt5229uIri5jmUpAFmcBiM55I7c14v0aJXyjFx/vL8mfAeOcbcY0Zf3F+bNTT tTvvDmsWXiXQ9U/sjV9Hjb7NqSSbVZT1znqO/wCdf0x/8Evv+Cn2r+JrXQPhV8TdX0i3tre0SxsN U1q+SL7cFO0uWC7UOQSAcDHTqQPr/GPhaGecOyxUI3q0tV3t/wADf7z3PC3iJZXmjwdV2p1I/K5/ /9L+xX4tfBf4EftA2KQ+NIfCGufa4o1liXVLaV5gBlWKZPzdMNjPAr8qv2wv+CU/wmsfAF9qnwf8 HQLrvyxWthDdFJiCGYtC6ISGGDgYIPfA5r9t4W4zx3D2OoRrL9ypLmT25W7N/Lf+rn5vxNwpgs9y fEyw38blfK1vzLZfN6eXysfyxeMvAHi74fazeeGvGGi6kNZ0zVJIVm1GMmNIYyVXymPpzgdea8i1 aSGVzbWUlzNe20u9pLh923PKqMjt9T2r+78gxFDFKFfDNOEopprZ3sz+MsfTq4dqlXTU07NPyM23 0l7VZLlpAJLg7XZQAxPX/Dmk1KaeayjWWONVgbHmom24cZzjd+GK+nhpKxjTta457htXaCA2KyM8 it5R/dIikdQTwce3WtpNNZphb3KM1vvTyRFN5YBB6Z+tZ1Fenb1OjCtRxkfVH//T/b7/AIIpeJDf /D+OwjuAILYi2ihXASI7mR8Drjjv61+uf7Vumm8+F3iZ4ywa30VmRxxgiRWJHuAv61+qccQdPxEr /wDXx/mclVqrwPh/Ol+h/AV8atR01fjr8R9He7zcTeK7qCCOOWTcgQ5lbPQKHDj8K/ff/gitqXm3 zQSXdxNNcswt1nJYWoBIIUnqp2kgH2r+l/GHBwXh3Rqpa+7+TP588E8RJcT1qV+/5o/pS+K1ubr4 b+KoVcoZPDtwjSjsfJY4/MV+Sv8AwT2aHTviV8QNNeGOOWDVjao3mEeZiV0XaOn3VY/jX8j5Ov8A hBxkH3R+/YxtcYYZr+WX6n6RftU2K6p8JvEtkywv5+lyJH5hALOpR1B/75/nX+fj8YPD1oPjP4+u V/dakniO6E0iSl4YlPyqoToOQx/Gv3/6Os0qOMptdj+aPpA4SrW4ry+pCVo2a/F/of/U/SX/AIId 381xJDY4W1MRljKucbwhKZOe77d1f00/Ey0afwBryhI3EGi3EpR2CglIXbg+vFfq3H81Dj2t/wBf P1R81lNJvw+pQvp7J/8ApJ/A7+1s2r+EP2o/E+u2l9qkGqabrFvqbLZyoHtzJGpRIT2VkALHHHmZ 71+33/BM3/gpzrOtXGj/AAk+KV7p9hcW8X9n2V5fzKFutsYc/vCFUyLkZ2jBwSAO3754mcNvNuCc FmOFjepSim0v5Xv+jPwTwf4hWAzXFZXipWjUm0n5p6ffqftb8ZvgD8If2h9KspvFUGga+zWqtY3c d3byTKXAYjnJOeMj2+lfk/8AtZ/8El/hVP8ADvWNZ+H2g6hpHie2tZJtOm02RZ7d5BEdokRNpK5H TPHXnFfjHC3FuO4dxdHD1rqjzK68r2f3H6vxdwdgs/wGIrUEnXUfdfn0ufzBeO/B/ifwbcr4T8SJ q+l6lpEkg1CymWSxCLkpHJvONwbHBB65ry2VXZ0SPc75x5rtuYY7k9TX9z8P1aFfD08ThkuSUb39 T+McVl1ajjGq9+aDs7907H//1foP/gjxNqFp8YNR8+aCW3vGhj+RlRYZYy5ZMdcsNp59a/srvImv PDSxyfJNNp4RlJxzsxX7b41z/wCM+nzLaSS9ND5jgWnGPh3Qj05P0P4WP+Co/hpl/aX1ub7Q6RXu jPaSso+z+UYLnG0f3lIwAO22vy3utPuI0lmiuJY7O3lEaEsVM0g/2u4Ge1f3b4a4qGI4TwUpf8+4 pfKKX4n8KcSYf2WNxVGPSo2/LUzriZpAJEkElwh3O6piIn+LilN7JDAqxhGuJJCHYDaEHt/Kvv5J uKR8lHFQjKMLkljqAgLRakiPvfIXhwRnjNdA15bXEwZEj8z7yRKAg4HRRUVItxbsb0qsPaScWf/W /Mxna4nWGMAyOwVIsj5m7Ae9ep/BK81a1+JPhnUklns77T9ZSZrO2kMEupsDtWMOO4/kT+H+s/Fs Ivh/FKS0VKb+6LZ/nlwPVlT4vwUoPV1qa++aT/M/0Hv2ULuW9+D/AIVnnJM8ukQy3JdsuJHQblHt xX5D/wDBcnGlfDCFra8m055vs8U91E7OP3l0sY4HIx5igkY7V/nj4WUFiPEuhB7e0b+67P7R8dcR GhwLXreUV99l/X3H8fGpXpF7NLbR/akSYRx3c1w15LdqDy/PI5zx0qW71a1uiypbfYFVQqIcl3AH LEn1547frX+l+DpKNOKitLH+fVSE/rUHJ6O3y7/foekfAm+gtPip4JupI3+02+uxC1KsSpUunUDr uxjFf6H/AOy9NNP8HfCiyFGhl0yJ4ysYjJ/dAdvrX8c/SnSWLy5Ls/waR/bf0fMRKtw5jqcndQkk vmrn/9f9uv8AguFqOpaD8MdObQ7k213JeW1pcld26SOecROQB/dEgOfevwK/Yl/bW8dfsh+PrPWb uGLxRozXUlwYrYGeWxmceWwZRyVO0d8g57Gv7j8MOG6PEnhJVwFSN5Tbt6ptfofx3xXxPieHPF6r i6ErKCjf0cYs/Zz4if8ABdnwL43+Her6NH4GNvfX2my2OoXVpqTIIGlBTymjIGxyeMFv6ivon/gk Z4wbxzJ4j8U3UT2V54h1u41NLfcWSBZGDGI5OcDHB7jtX5bxlwFiODuE6kqy3lY/avDfjJcZcWVq 1L4acNfI/Un9sC2W++DniO2yocW6SRuePKYuEU/m3T2r/Ov+Keps3xQ8dafaST26jxLdxG9mP2jz BltpUfdAySMe1fqX0XYv+zcbVfdL8j8L+kdJy40wUKesuT9X/kf0of8ABB67kt9MgsLyffNbxott HFLujkUKiAsOoYkNxX9H3x7jJ+GPidiDvj0+VwAduW44Psea/n/xKS/4iliIr/n4vxaP6dyRcnhh hZVelNfkz//Q/o2/4Jp7n8Z/EWYwhGXxHcb1jP7oM7Dt3wSfzr7n/bYa8j+BPib7Gzx3Uhiit5Yl O9S25Tz6HP61+i5nRVXipYd9Wtf1POrYj2PBtHFU19nb56ngf/BNS+vtY+F019dXbXMjXlyXRpCX g23EkQB9j5akVY/4KQ3E+kfDCPVIb6a3khuAWhiP3lBQ8/iSPripwtFf6zypPRXsYZ/WVPh2jWpu 7UY39b6/cj3j9iy//tr4L+GL+SRpZHsYg5diZB+6jxuHrjmvyl/4Lwi1b4NajaXlg13aTQRyBo9w mhlgc7GwCONzqT9BX0vhipR8T8C4b+1X5n5146Sb8L8Tb+SP5o/jJsC4srfTWTa9jCImAXargDqP UdOe9TWr2nkySySIsisRHbElZJcehxj86/1eg/cTZ/BNOry4WlzPVxVz/9H8gPNM0CTiMxs5xIn8 XGeD+VaKSJeRW0Lu1rGJcS4bIZen5d8V/uO6fMtOh/lpSrR5IpvVv8CtbRTRyzCy3PHFk74weo4H 64r+rP8A4IPMlnZWsZMiajHapJJ9ohCBxMdr/iCDX87fSboTreHtWNNaqSf4M/ob6N8Zx44qX29n L9D+j748GNfhp4lU7iyWMhVIx8x7cD2Ff51X7UejzR/tA/Eu++zPNO3jK9tY5eUeGBfLYAr2LFif wr8N+ihJQr42/wDKj3/pGRqPN8G4bWl+Z84ajayzSyiWE5BHlZbc+Bjqa/RT/gmZLG/7TvhbfDKk LwjTpXVshGjYTIWX0Occ96/qzxCfPwNjl/07kfmvhBFx8QcG31l+jP/S/uq8OytL4R0whRvbTYow W+TPygc+9fxr/wDBZHxn4ns/jlpujyT3kMEf2ibCzOIQkc8aKyAHHO4gnrwK/oT6PuHpYjjiVOsr rlk9e6asfiH0kMRVw2SYWdFtN14xdu3LK/5H7zf8Elb8XnwM0Oafy7i4u9FWX7TChIZHwwy3TP3c /SvQ/wDgpVZTz/Bu4W1KRPHcmeWXaCfKCKZEI/2gpXNfO5jDk8Tq0f8Ap4z9Gz1W4Jo8n8lP84nq H7ARiX9n7whGhLPHpMJkYD5M7V6GtD9qb9p7wb+zdpDeI/GMQlsfLXPMjBt8nlqoRFYnJzkkYHUn GTXz8ctqZvxjVy2i/fqTaXr/AEju4jzSlkfC1HNa6vGnTg384pfqfn0n/BaH9ki08qOVNRgkuGwY NPnAdj/EGDIMc8YOKh0n/guX+yhCss6xXdlaQSvb77zUFhkXaRgbGUckc4zmv1OXgdxPWS5ISav/ ACv8j8j/AOI1ZLgY882rNaK/62P/0/tD/gpR/wAFPfgV+0b8O9d8G+Ar/V/7Q1TR1sba6iaK8srB pJ45BK6IzHIEUi9c/vBxxk/zR3N5Hbv5InQA8PtGZGc/eY+5PNf66+CfCeL4R4WWXYtWk3fs+vTo f5i8W8Q/6y8VYzN0rRm9PQwkjFvJK6MJVx8zeo96uiWFI/Lk2SGVMqy9s1+zpWmj5tz0GKogUsyF ZFPyk/41bsCJLgZIMh5Lt0TPrRV+E6MK1zo/qt/4IIyzFWtZ2tjJZNuR4UIDh5COO3YH6Gv6V/j7 PLB8OvEU1uZFuLeykkWeP70eBwR+Nf5P+MSS8YKqf/Pxfmf6QZLJvwooNPVUH+EWf//U+bv2l/2l vjXpHx2+IljpHxG1O3ttP8R3lrHpNvfOfMWOVkHyn5cDpuHpxXzpr/xx+IXiu3Ft4o8UeIdWs5NO FpPp02qyx20rhixc4P4YNf6/cNcGcPU8tweYU8NH2vJF382u17emmh/mjmHEWbYqM6GJrNxcmvx7 7v7z7r/4JVanp8n7UFoLe4a3keyQXloY8JbSbYyAD9PK57l/y/vVsYnuvBVsip9mMukxqdvz4+RT kfXNfxb9KCHJxzh1/dX6H9t+CUlLw4a85H8N3/BZKJdO/aMsLyK3gLX0Dws7SiOTcm2E/J9NxPuf evFf+CYkqW/7QvhHTo490lpqb3CkjfbiPYSM+mGbv61/RWFSn4IKXeifgHA0OTxZlTfStL82f386 KrzeDdOlkWORpdIg2rF8oHyDp9K/ErQLKa1/b3NqsqEXcQuMMQkjf6XNEcnucoGr+GeEElTzFf3G f1txCubiXLp9FP8AVH//1f7p/GZafwbrE06Dzv7FkeVSOOIzuGPwr/O1/wCCgtrPYftMfEO5S4ha NtUzp9lAWWOMyzbGWUY4ZgBj2xX9i/RMX/GS4xdOT/5I/lz6U9/bZUk96kv/AG0+9f8AgiaZ4/jr qjBn2OsU0iRTiSNJFdY8FevRsZ96/tY8UOp8E6pLdbmQ6I5uAqbsYi6EfpXyf0h0v+Ikaf3fzP1j w508MqcX/JL8j/Or/wCCkKrbftJfE9JvMltbnxiTYiBN8MyLEuHb02njj2618L6WsLTF5keVYsOi norqwZSR7EfrX+hfBztwRgrf8+o/kf57ZPK+ZTiv+fsv/Sj+7z/gjJqN1efAnSpzAsEdzpUPzDBV x5cbFhjjJJOR719F/wDBTLTDefs8+OZFneJY9Cunu9h+VI/s/wAxI9MA1/mXiXyeNLv/AM/1+aP9 GeNFz+Fmn/Plfkf/1vxh1FxDrerWEEKx2ljqEkEbpl4Jw3zb1J/3u3Qis7ULtrSMRRBSsuFcEAk4 OR/LtX+7eEd6NNvsvyP8oZy3SIrUSFvNaJMqhBJUEqDUt1azfZ45ljdYXOBIFOAfrXac3M1oY9sG jMij5kB3M3c5qyyKhSZYlmVeDCw4at4q0UDbe5FtHmoYbdEduAi4JT2zT9k0kuxh5ajl26kYpgm1 sf/X/Dv7REsM64DSr8qFvu9etRiAzqpli3A8oOn41/vgf5NKbW4y6ATyhBGhkX5WJJx6c1o2ETpF MRGJj5eCR9/PGdv5UFOa6FAhxMwKkIRnngikNrBcgxbdrls7x1z6UGbbe4wwG0K2u0qUXP196ZB5 okZzuwRhVxwfegR//9D8MpJHbkA4HXtQ6FtjMgSPqW7tX+99kf5LivKiMnkMHjx8395PwpsjRzKu FGc8uDjNMBBIsaOXTIHyhsZq54f8Q3HhrW7XVV0m11aAo9vcWV6AI5Y34JVv4WHYj9elKUeaLj3G nZ3NLxpqOkaxf/2vodo2kxPaxw3OnvcedtkGdxVuNwPHYVzdvewiAh4isoG2Nk6H3P5UoKUYKM3d rrtfzNU05tx2P//R/DWO6lSNk4ZJFwYyoyec0yeCOOPzEI3EZK1/vitz/J2XwsoxztDIkkYKsh3A rxmrf2l7ySV5Yg+9gdu0AZ9cfrWyd0YkU/yS4ZQOONvap7aGRwS77VYcD1rOUr6ARyRTQXKNExC7 MEYznP8A+qnxDy/OO98y/ebv06fpUmc30P/S/ClBMj4cMUbjcTkilJwwBykYPLV/vgf5HlwiJs7Z NyoMgngNTC8jZXHykY47j0oGnZ3D5EiJAwy/xn+ADr/n2quJpllVkYeSOcnkPx2oHzO9yeS8AcEL jdxwOM1558Sok/4R26EzAGTaTCYtxmAz37Yz+OfavPzX/kWV/wDDL8j08lk/7Uof4o/mj//T/ie8 TJLLrHnWyFIJMjZg54PrWYsojQKY2aR+gxjFfrXF7txHjf8Ar5P/ANKZ8xkf/Irw6/uR/JBYw/aG n3uFdSPLTPLc8ir6R4LIYdrngNjKkepr5hfAz1m7I9R+DNxY2vxP8D/bFljiudftrWaSL59irPHJ vC+o2nFf7C//AAT4toF/Zk+Hwtiz2Z0S28tmX52LQxM2ffOc/WvgOI03nGF+Z+jcNz/4xbGx84n5 Cf8ABav9p/x1+yX4j+H3jfwvrV/bWc/iQxT6ZZ3TWhuEj8tzuII9Bkd9w5HFfqH+wJ+3n8LP2z/g poHiHwzfXtv4pWwFnrmmXkLNLb3CIizZcDaQS24Y5IccAggfV8QYanDJcLitm1b52t/kfO8O1XiI VsLFXlTm5f8Abt23+Kuf/9T65/4OAP8AgnL8UPGupRftM+GXh1fw74a0RbDV9NRvIu7SBZHlaZQc btpkOQO344/Un/ggo+oJ+yLoFpczMy2WNPWF1/1LRxoGVW9M5NelntWniMswVVbxtH7lb8dz6bJ2 6dLFUV1u/wAUfph+1F8avhN8G/C0+tfFxoYNBjhR5Z7mCOSKJN5+YhjyARj8frX5h6h/wVM/4Jes 7LqHxH8JxpZR/JDJokwdSByF/dYP0BNaYfA16uHjVjpF/oeZhsdSji54aD9+O50fgP8A4LN/8E2P C8X2bSvi/pNnazEvIkOi3cSAg4B+WA9Olfi5/wAF4v8Agq3+yj+0J+z2/wALvg/48tPFninUryzS zjs7KVREu6VXaQsvy7VfuM816OV5bKniva1Nopv10ZxcSN4nAyhfVta/NXPij/g2TRLn9oDWzJ50 xsFiWMbMR+cZnSQ/98t+tf34/GMrF8NfEjSYWEWJLbl3BiVIUfXPP4V81RS/1jml/Mj6POW/9WqC l/Iz/9X8ZPGd3Mv/AAUcvr+OExW958cHltjwUKtfyMxYDkY3p+Z9K/0+f2ZC1x8FPAFwFZA/hyye NcDc26FGc/ic12cSU3HiON39n/I+qyOV+C7Lbn/Rn88P7dVzbx/8FUfgNJFAqItta+akblnCpqUx cnrg7Wz9B2r+n2zkz4QklK/f0F5Nq9BmPPH0zU5pFLHUV/cRzYZt5L/2/I/y3P8Agt3qJ1D9vj4m 25cXllp+rXMM5vQsS28QCuAv94bmQ+vze1dJ/wAEGNT1Cf8Abl8OtDYLJY2lrHFdmJCjy25uoQWX HBI8wcmvS4mbWBTl2R85wCowzJez/ml+rP8AT5vEFv4O1Es4ZG0B3YyLuC5QAD8Olf5cv/BT/wCL vjD4P/8ABSL4seMvAGrahpGs6D8Srm+srvSr5rO+t1R49wDKc4ZQuR/XFRklJVcFVpy2aX6np5nU nTzKNWm7NN2+9H//1v3C/wCCNH/BW34Yftn/AAm0j4aeOr67g+Knh6wWzu4dVuF1CDWNo8vdFJ0I 3ZO0gEZ6cEDS/wCCn/8AwR/8N/tlnSvEHgxNN8LeKbQssWo2OkC2co4wxkZMbgcJz7Hr2rLa0sDX qU3eydvwR7+JhHEVIVqmnNZ/5n8mP7ZP/BJz9qb/AIJzWNh8W/BXiPVL1NEnaS/13w9czWd7pyOQ Uk3ABthPBYcA4P0/P/xp+39+2D458Bv4V139on4gXPh2G1fT9V0+81mX+10E0bRyxLKGDkFWZNxJ IDV7dBxnUjioLV9ep85mVKpJvCVLumraf8MfnZezRySOyu0iM5cmWUzXDsfvMzHqSeT7mu++B80V 38X/AAFaz3Di0Pi7To57BMRySq9zGGdW6/dDD0BIqMfFRjJ+TOjLNcTBea/M/wBfL9hyIp+zd8K9 ts1vAnhSyC7z+/bdGpBIr+Uz/g6c1GC1f4bq1u5ia5vYzJb/ACtjzoWdFGeWOV/75FcPB15Sk+8X +aOnxEl/tkW/+fi/Jn//1/46Nc1C3udbuYbaWSA2arFOjKQHccj5jwcAjpXTaDrTefZrLys9/bWm 1EG1t0yKdw7fX3r25q0pegsHpOL8z/U8/wCCJOnSW37Fnw/VoTEIdJilQyH5W/cRghfoxP518bf8 HLE/2f8AY+cpMEmm8RWNtOVICsphuJDuz7DHFeJws17TTuz6Tjde05vSP6H+c/dIIZYbIXkU6QwK cIAdq44JI/lX7M/8EJppZf24dGlRIZE06ygilbbtaQNPDzjvtEhJPbaK6M3kng6jOHhj3czoPt/k f6fUYVvB8pkQEnQQc5LgsycH88V/l5f8FmPEuoxft5fGmysR9pgs/EM1te3jpnciiNlRgfQkr+Fd uRq+W1n2SOPP58uNpS/vM//Q/OX/AIIBy293+2tb3htZbpxLCjxsBHA586NcA+mCGx3xX+mLqNy0 XgqSVskSaSSUc4jAIwAf0rjpPmzB38j7LHVG8koJ+Z/mDf8ABTi4kP8AwUR8fAxRETfFLzGIXDDb cRxKD9Fx+Vf6G3/BObTFtP2VvhscgCXQorkqFwy+cFkxjtjfj8q689X/AAp0n/XQyyNuHDlaC7r8 z8RP+DhD47fE/wCA2g6DcfDbXr7S7rxNNc6ZM9lO6zwONqqBgjG4PnB7qvoK/C3/AIJEf8FYvh1+ yn8VtcT49S6teQ+KGX7R4vKNNPFKZQ0ouk++ed7bhk5Y/Ljp35lQlVyylCnvv62sedkOYwo1K1Kr tqvv1/M/of8A22f+C537DfjH9m34h6Z4K+I9lq+p6r4PvrKz0m0trh7u4nltZI1jXeiqNzMo5PTn PBr/ADrfGHi2DxPq0upCwkS3+1u1l5yZuXEsjSFsj+HLcewq6UHQy+EW9W7njVaUf7TdaPa34n// 0f5d/wBnC9nb44fCtt0Yt4PG1kJw8JlIDzIpbjsoJOPUCv8AWu/YqsVs/gD8PI0g8qO40CBg+woJ A6rJkg9D8x4rxsbFSzWmv7r/ADPucG/+Mfqp/wA6/I/k3/4Ok76XSta+GrwtI3+lXKpG+DbojuiS kf7WFHB7EV/J9+z4i3nx1+ERsU3Wcvj+xtJpFPlrG5nTYyr0z96vrMb/AMi9f4D5Ph+0Mwqf4/1P 9af9lCzMfwI+HhWXz5JPDVq4lUAebviDHI6Z+npXyp+15+3L+zR+zLq1rH8bZ/7PFyWSGXyVuXUA ndlBl8fLnAHcYzXzGSUZVMKoQ3S/JHu5vVUcbKb6s+Gf+H33/BNSW1hf/hLREi3JjAh0K4Er7MHc xePbjkDGc+1dtpP/AAX4/wCCeemRTWqeNL3Twi+XHv0m5+UAfK2EjYYOfrXcsNJw9pc45Voqk0f/ 0vgX/gtr+378L/2wvjh4e1b4N6xezWvhDRRHJ4hEBtWeSW5Z0ESlt5AVE+YqOSRz1r9L/wDghN/w WUtfDd1Yfs2/tBX2o3E0zrH4b1y8upJoblUXHl/MQASBuHb5cH2MXFujGS3j+XU+mySahh54ef22 9PO7a/O3of1Hftj/ALKfw3/bT+DN1oskK/ZddgjubbVIbWIXQDAHh2BwdpHXnnt1r+UX9pr/AIN5 vH/wq8L6l4++G3iCXULfQnl1ZoJ9sU4ijG8uqoCA4C56jJUYHIpUa6eG5ZGU6So1KrktV+h+AXiL 9o79qTwAPFPw9sfi98TbJtKvZNIvki8Q3ljaxqhMYxh/mQ7WUYI6GvhTXLjVdUv7/UtRv7u+1PUb g3V/f3ty11dXUh6szMTyf8K6aSUaChHSO9vkeLKr7eUar3OXZCVYtkkDgYySaqQwTyI5QlPmxg8Z 9qLdBySUtP60P//T/jugn+y3CIA0kjOEdc7QOcfpXSRozuiZMZurhIGmMm0wh2C7ge2BzTnFqJvG V52P7Cv+CNf/AASHPji38M/Hfxjq8uux2LLfaLp/2WE2GACFdmU89A2TjJbJGdpH9W3xm+MHw3/Z I+E7a/470ays9I0hFtJJ7e2UyZClgxzyfu4AHfngZNeLl9WeZYpy2XT+vKzPt82hDBZfRwUPi3fn +nX7rJ7Hhv7Jv/BRf9l/9qTXp9L+HMl0/iC2uP39tdaetu8eCFyG6YJPbP3vY1+mHxAmWx8E6vek bYl0+SMt90ojISfzANddJv2z9TxsVFeyT8j/ACpP+Ckd01x+2R8U75bxik3iK5sra2SEMkoWXkvj pjAr9pv+DcDTE1X4v+KJ5VkstStboypJECROiBkWP25OfoaMT8RGEinE/9T+4H4rpHbfDHxFNcYl htdGdZ4gfncJGzNtHrwTX+Zn4/uYtc/4KQXF5ZwXC2t38R5RaxzH5gPtTRupJ6gHj6elcS+Bn0Tg lUTP9Jz9mGy+x/B7wcQ4VX0C0jUImyKNVhQDA9AABX4eft5W+m6v/wAFCvgdp2r20F/a2qwaraRy xiaIyMZlQuh4wsluGHvzWcFqr+R0yVkl6n9AOk6JY2/gG1hiijhQaT5jERhQrbeGHpzg1/n9f8Fn viN40/4bLTwjFrd9Hp9lqA36et65RvMuAN4XOBuVV4/2F9BjoSvGxzz0qJH9jn/BLnSDpn7MPgCy wZIYNHWPcxBYNIS/OO/Ar8wf+Djy+uoP2ZmtLe4e2l/t5LJ4QVEVwGhblgeQAoYZ96vLvjXqzDMt U/66H//V/kvsLKWWxs7+S6guBCi2qIkg3MEBwcDsAAKtSyQQ7nWJGjX74Iz9a0xPw/13NqKcaTT7 nPx6eGuJJLYMbeeTzChbIQ98VsjTYpAIUY+a+diHqxHYe9ebT1bNYLW5ZFnK1ubJY5+Z4BIY1O+I LMh3fhtJ59K/0ov+CDOhy6f+zH4TDwtFFFCRBOXXzL1FiiXLKOnMZrysyqOGJoxtu/yPosjoxeHx FSTtp/wD6c/4Ku6lfaH8F2vdNuZrGea/sxK8cpj37p1XoPQZPscelfRX7AEFw/7PXhC/u5pZZ7jT oUzcMS/MaA8H024+hFevUlFRVjkpQfvX6M//1v3u/wCClniO/wBO+Pfwb0SyuJLVNU1tWla1uGic lLqFSSB7BvxC1+1Pw2jSDwFo6tukkTSx9oNypBk2R4yfy715117RRR9PyP2Vz+Cz/g4g1v8AtX9o bSLCaWQi2hiuIkUsir5W1mRV7nJOfSvzt/4JbaDqOq/tk/D+eyVi2nvDqDKzARoUmPzc8HoFx1O6 pzOoqVFy8istoSrYlRR/pz+Eori28FadGzos4s0diihY8+WGJA/Wv4BP+Dh3ULjVf2ntPs7m4eUQ P5i+QfmhQbN2cfdycH6GunLlGphlJdY3POzOmqddwavZnxF/wS08PnWP20Phn9n2Nb2mySeKdf8A RbgxzCVUPvkbse1f6bnhyOSz8A2iTmIzR6ViXB+RiUA4+n9K+cpzcs3lDoepCk6eAuf/1/I/+C39 4t7+1lBHtMM0EiaeihNoXY4zj/gTHrX9af8AwSP0p9G/Zi8FxNsaS30SKLAj2szmNFcj2+TPtk14 +aezpYyhBre/5H0eXc9XCVpdF/mfJn/BfnX0t/2X9Y06b7S9supwmeNVO1JWAjTnoOZScdxn0r+B PRsX2taPbS2kzTPq0Gm2yq+9FXz1TD9uQCM+pFerXpxjlik/U4qU5Sxns0f6V/8AwSm0JPDn7Onh qxEY8pNPiitZjJv3II1AP5Ka+PP+C9/jufwT+zhdPp11c6Xez/arb7TDcvA0yPECMbcf7o/3q8jI ZRqQSitFf8D0s0jKliHza7fifx1fsK/t/wDjn9jv4g6T47t9IGsaZPNJceKdPuZRFfzRbhsMKkYD lRknnIOCK/og+I3/AAct/Djxx8Kb3RbL4Tazb3msWX9jR3Calbxxu7xGNw7DDLjPYH6+urnGONkz TFQ9pg4Jef4n/9D6U/4Jaf8ABO/wd+1DrV7+0l8RrcX+oatqk+taRYC4FzZWZkkDo7qRksrEnaxH RTjIFf0wfGr4i6L+yb8H7zXNQtbB9D8P2sYkQQR29xMI4wijKjq20AHpk+9eJgn9cxEpR7v52/4c +jxFKWFw8ac+tj88f2UP+Cu3w+/aa+I118PtO+HtzoMtvc/Z7O/a6LQzgvtLcDI4JOCPx61+3t9K W8M/abKWMI2n+YHfmN9wwQR+YpwnFY+UV0sddanbDwl0aP8AND/4LCawmoftl+OYzISyTXcK2EWT BETPuYNnoSCD+VflrNcWaCDZZRpc2rI9o/kb3VwR86Z/iHX8K0ziLf3HmYd++4o/0R/+CEfhz+y/ 2XfCFzPI8v2kSXUImGJNzRxJz7go5/KvYP8AgtXq8+l/sg+NIoMxySWUsyTwgiU7YJk2g9uZCfwN eRwx7OpJyvomz0uIfaciit2l/XU//9H+bi5W4mv3a9icqsI8sqe+Pyr9DP8AglXo899+114eS088 yx20AWRycW7PeQtgHtwCfzr5niKUIYOvUntZ/lufT5JCq8XRhBe9oj/TE8Mx/YvAtjOoLTrp6yXI Q7mkkMa7sD3NfhL+2d/wWc8I/sg+OLzwZ4g8HWviG7RJFMCXRs7iF0YKELGNh65B54B9cdOTU/8A YISWjsn95GZ1ZRx0uXWzZ8P2/wDwc0/C8TXKt8F9Vja3gAS6g1OO42MeobMS4+vNS6j/AMHQHw9i 0iK0i+EPiCSS+haNY01JXZzjAK/uwMH2JHrWrg/bq+wq1eKp2vq0fzA/t3ftkaz+2Z8YtS8bS6F/ wielQ6pPLHYS3Ml3dskiqQxLADOSQCpOApFfC+oh5IyiTNNGnyLKMg+nNd2KftJ3vfTQ8LD39m7o /9L+U+0kljWG2hg8tYpGDl8gyg9wa0bS0IuGufLKSAYcjksB2rw4r3tOhvKPMuU6a1uYp40hKyQX lyXtkAYbZsghA5x8o4ySTwDX+hP/AMEDPEXhTX/2efDUMWp6G2uaTbtYz2+nagLm4nZViQPKueGB WRAP+mfevkuI8NVlVo1d4p3f3n1vDdXko1qH2mreun9fefVv/BX601PU/wBlXxdpkFnqF2UieaYW UReQIkcvOe2AST7Ka/zedU8Pa4LzUDfWU881vqk0Ox1xMg3FlOD7MMe1foKnBZHCEZa32/rY+XVK q82c2vdP1C/4JSfCjxprX7QnhTxjp2h6ve6TZ6jAySixZbFAshLB3IwcEds9G9DX+i94YvLex+H9 nFNe20UtrpKm4ieQcv5YLKfqc/hXxeVUPa5/Kr0it/mfZ5hUlSyKFLq3+h//0/lj/guH4wOvftat HLpiXEMMt25uIiwt4DIYdux+h2hkHpnPpXNf8EcbabU/2sNMbS7a4uZtMFvFMAAY3LMT82epVSWB HTBzXgeJNbD1cvoU6Dukkn6/1Y97w9p4ijmFapXWrk7emp/ovWMsEXga0aAkpFpatMrjDFygDqf8 96/znP8Agsl4ke//AGrviTD5hc2GpT3NtBNbf6NaRtMsknlHqG/erzjua9XhWNOlk05t68uiMM8l KeaqFtOZ3Z+QmiNbXV5DZSH7RHfzncAR5mDlsKfbAr/Qr/4IieEzov7OXhcRS7p7cTTSymTzlbzj G5jVxwRHjaB7V8DmUHPOMMpa2b/T/I+qy22Hy6vyaJnpH/BZjxlqHgT9m261ewiik1JL021v5s3l M/mRMfyAyf8AgNfw0fs5/tr/ABB/ZP8Ajnb/ABR8P/a9ZtmuPJ13SpCqxzqzq0qoD90KVAUjjA56 5H2WZYGjiMq5erPIy7MZ4bH+0a0X5n//1PpPx5/wcyeG73wFJ4cPwk1WbxHLpot47xNWhihWSSLG 122Z4znOGAxya/li+Mvxm1r42eOdY8ealpj6Ze+INXWa506G7F2sMIkzsRjjIO5zzg4Izg14uClC jln1NL5/18/kfTYmtOeZfWunVf1/X6/07f8ABu34Vuk1/Vtcvv7R8maYafJBcOJ4bNElLwiPHIBO 48/3Rjpz/WH+05czWfwU8ZTsx8oeGrq3ct8qbXhKbmPpzXynDE4QzrEy6xn+F3Y+iz2tOrltCDVk 4n+W/wDtIX+pah8X/HIMRls5vFeo3FpLC3+iIA6ov/oOM+1J+zFY3eqfF/4aafdfuZ5fFUNyInCs kSwTq5bd2yBgevSvrOJMS8XQxEmrLlenyPAyWj7LF0U3d3R/p/fshadLp/wZ0CzHmMWiiRml4xi3 iAwR9D+dfzGf8HFGoeX4p8JWd5OguhBERHDIMyoXflh1JA/zzXlcBSUso5ZdpHrcTQ/4U4vzR//V /Yn/AIISaLf6L8IxE8D30MVyFt9Rlh8gXCMFJ2/7nzKOfSvtH/grvrNzoX7LnjGbfFFYvDEshm/1 akseeOeAWPHoK+L4NVKlm1WrHdzf4H6jxHGU6FOMukVY/jB/YC/YY0z9rH49a9pnjHWr+fRbHU1v ZpNLv1WK7/eA4OQTggDoMjdx0yP7nvgl8A9F/ZL+GSaR4dAu7CxsWuY98KJNGkMQ3qGA9FJ496WK qU8w4gqYWtryO6+bf9fMzVBYfKoV0tZJo+ANW/4K+fCPTPjefhHqHgrbqEl4mly67BerKXlJ4DoV yEIHB59wOcftB4B1+HxP4as9btYvsS3tkt28UeGSNSDx29D1q8XJUM5jFbWt9xz06ar5Y+bXU/jS /wCDh3xHJF8RtH06S2tr2yt7VrlAW+z3LyGIjIx/d3KSPYV/KHeQXtp5wiDTmS4DuC2SyseeT1wM flX2+b04fVqLtpyo+SwsHKpUh5n/1vwP/Za0r+0vjX4JsFMVw9zewQC1eIyBYzcRtLIcdMBVGfc+ lf6ef7KGnNpfwQ8MWqLsd9NhihDNnyljiVMEdiCh/Kvyl1Iz4qhFraLsfpEqEqfD85w0Tkr/AHH8 nX/BxLcrf+OvClnE1y72UUKLPb4kkWf55DhPTO/OegFfyb3ksds97HEjF5p2dzKhVnbPPX3r9AzR qVOl5I+HoRalP1OPvLdmKFCUcvmTJwMc1vaJbWZG2RtjO4R3ZPMCn+9t614MYJ6s1krJjXt76ygv LpYd8cTOEdDyoGdpx2zjj3rzx7bVrm2tHnWNnYebLlisiluSCD3FTJJOyCmtD//X/k1063/s3eUt 1V5TumdRgsff1rdgQ3FlI0iyI8oMe1yAy4yAV9Oxr4eyPYLl3Nb7bZbuWS5mMWCknLpsAC89PTHp VOeS6WGO6hklkdotvlJ87fKcAMPXj8qDSn1L11Pe3On21pqSql5CnmJIPnfDgEKT3A/qaxNLa4c3 VtIqSIjDDn5tufT34oNVa+pHLau12VCZjGORzz71PsnUmBA7KATtU/Koot0Kh8R//9D+UdGMkYVm 5jbBxzxTrlCNzW6yiPeDEzDPI5Ge34V8KopI+mlLl0LouJ7LT43uzHL9ouPs7BsCeEAblOPQ9Pzo HkSMNsfmXMqEAhckKKySu7Gkeo3/AEqXTrmDTr02F7H88sild0ig5KgN/Kq+mXt6oKzEXUxOJGuo x0HXoK7J8lkosw5ZuabWhdiuv9JaJLcwfNuDJgxv0/w71bS2jcNc+SftMcjGOSRiqvxjAH50KMWt BNO7aP/R/lksPMWV3ZGaRjgnaQD6CrU98mn3zB42We8G0iGIlYVxg5OMDHPWvh3o7H0KcthrXpxs t8lt+Fdfmkkzjgj/AD1qvZTXGkXb3sFqv2i6uALjCBWlU8EsO+MmgiUnFl/7PBDeS6lsO2Zd7iN/ 9YwzjPvWUqXm9REs5MxMmFbHlA5PPPQVpS0h7xKqO51WkqkUlvIonklilxMGctHjIzwBnOM+tfoj 4J0WJvDelrG8U9u04vpvszFbkMAu2MqeeNgB9efWv6J8CMGquaVsZF/Ckvv/AOGPx3xZxM/qlHCW 1bbXy0P/0vuL/gkF4Sa+1G7nu7OWK61HWlu7e7lcxyRQxCBnATpjHm/iK/cz9sO9Wy+Dnii6S7ZV ls3s7a3gHz7BEfMJPocH86+64uhRx/iTUinvUS/JdzlyFVsNwLS5lqoX/A/g2+L1/JrnifxdrxhD yWd/c6daLEuGkZWYCXaejH5AT6pX5V/tXyRppWlWeoArPb2JuxLLuMgd5FLMWAwRjoPXNf1ZxpVh guAq0N7U0u29kfzjwRhamI44jUv9p/hc/NSWH7QXkiZ3jWTg9yM//qqxtQR5igd5Pulsfd+tfxJW tKs0f1O6Fo3Z2OgzDT50nmj84FQgjYlYyOQ3vmutmuLTULS4a1uhZsFEdvGsfmAvuwQxJ4A5rza9 JN3CKsrH/9P+NOFY91xBeRiNAq7AAQXOBkn0otZI5ry2WKdY4/P8hneMsRt6nA7Yz+VfPVqF7npO Nlc940Wws9X0xY4LhfsczASm1bEUpU4IAHuCD6ZNekabY20SM9xJsCtsj5OX7DntXl1MKnISqKKs TX11cW04hS9tFRGVo41BdplK/d3ZxkE/pWnPcE2MaXFuJWlXBXZuPPY4rlngoSTuS67WxW0uRtDh eQzp5MIeRElIxErZ4x7Z4/CpbO4N5JJNEIFmCh8jh3B7fp39KyoYWnGeoOtUTUoPVn//1P5BfDl5 b3l9eQPD9mSGQ+UzjfHdYBKnI7t0x29aiks7s6pd3cmnWtjGrA2yQyGbzCc7jk8jovHtXiwizVWd RsnvtT0+3EcU6s2rMylVK5hjUjg565yKx9RhuYpZftY8uVVEm1jndkZXBHbGKxKWjMO1u9RTVLWK 2OZLoFUXO0ZH933xnj3r1e0uXmsUKW7PNbqzLGePMfkE598frQtBnQtqt3BB5MxCQlFdLeF9ygkc lh6jpWJqaaVqkCl7xVeKddkJYoLh1O7Yw/XB44q4vUD/1f5FJ7dijmNEgKE7ABhD9K898RTabZz6 dp01++oX17A004MBEdud2Am7oSfYdq4qMtUbSXus8m8R3kltrBewt49OE8K25KHbH02k5PrnJr3X 4PG3g1rTBK0UmoWsKCW6trkD7d+8R8O4JzgduxUd6+o4fk45/g5f34/mjyc5hzZLiV/cl+R+xXhp 9RNtb2uo3RluNRtEm3SsXnxMqlc9zkEZ781/a9/wSX125u/hVommi9he20+yWyuY44tkSyRxqq+X j+EZ6+oNf1Z46L2vA9Cb6WZ+deAr5M3x9Ly/Vn0P/wAFIdMivfgbqVrfySR2k0wka6T5plGNjKPq HIr+FbxJLNf3+q2qX/mQ2OrTW63LKUyInO1cdeBgD2xXL9GGd8oxUV3PifHhNcQQj5H/1vxiuTfi djEjzBn4YcHGe47VcjEYclYI3vHXa0hjDvkD168dq/12ij/OlJcrZpSaIl/ou82Fu15cqrJcvlby FCQSEOcA5GCCORVaw0rUb9Z0soDcLZR7riJSN8eOMkdcU7kqK5WULIyWtzNHHglX3Tb5CytnqB9P bpX6sf8ABNi5Wx+OOiWUkkE15qEkOo2MKkDyVjzG8ec85JU8d818L4jpvhLGJfyM/YPBNKPHGDvt d/kf3EaWVk8Ex3QViLXSSyxY3OX2fLx6civ4zf8AgqPpt7F+1DZWVlCFhu3nv7a/+Yc+Yt20R5wB lwMHn91+f8OeDMObjGqn/LI/obxpqOlh8IoburE//9f+lf8A4JjXdvf/AAbt7+1BMWq20C23m8NC YVG4Edjhc496y/8Agpdaw2fgHTbuQyXKpcTQ3CrFyhlQEc9gSsY9sV9lmsqkOP5Rjv7T/I9LNlTW SwqSd9IfofTv7G17FqHwI8IWzIZJf7Mhl+2DDHARVxn2wv51+NP/AAW5sI4vCGl6wYBerpU66lDD IgiaQiV4yrEckMCDg9a6uCJy/wCIgUW9/aHzHic4VOFKlSDunFM/mC07Sv8AhINch+z2Fv5+pvsM VogkRFYZ8sevb6n619//AAk/4JxftDfFbT4tS8L6P4a/sn7M+qRXOr20kd5CpUBESDaojb+HBfJO elf2bxTn+B4cw9LEYxqz/Trufzfwtw3jOJKVaWGj8D/rY0Ph78APjJ+zV8b/AAzF8QNLsLO3fXku pdQsCl2sC4aFkZ/4QckbecZPNf2z/BdbZPhnoayXbTeVYAjcoZkRo1/lzX8xeNGb4bO1hMfhPgkv yuf0P4W4SvgcjxWErqzjN/r+p//Q/cX48XUPhj9rHw3BaufNvdegl87GwypMhhRienzBOg9q/bm2 RpvDdg1wPPa1sIhcQ8fMUAGOOPSvazh/7Hgm/wCX/I9TLXfA14rpOX6H4mfDSMaN+2r4rijtEt47 W9vWKlsxFTdxliPohOB/s1+41tMs1tDImCJUU5B6ggUcSS5oYST/AOfa/IeT07Ze7fzy/QdfRjyO G5A+UjqD/k1/G1/wV20Vv+FwX6pcva21xq93dG6EWIx5b4CFfVg3I9hivt/A+pbjKnf+V/mj8+8X abnw3G2vvr/0mR8j/sY6gNE+L3hHEcsv9oPEkAIHlyjzc+Ycc4GWr+6X4X3Ul38N9IuZlSMNpRLO z85EQBXP1GPyr676QbjPNsNUvrZ/n/wDfwtjN8Lzclb3mvwuf//R+u/+Cusvi/wN8V9A8Z6IJLC+ nvzLBfxSgmzCJERvI+6N0RYH/a619vf8E6P+Ch3hnxJoeieEPi94htrXWrox2dtHfasvnSBFwHji J6E7jgHOMdsCv6OxHDEM78JcLmNCF61JvXrbf+vU/MOGuIf7P4yx+U4iX7uo9F05tv69D9Fv2q/2 XvC/7RXw91JfDvl29/qFokqXltFFcC7JYNFKNyN8wAxuGCVOMjrX5E/s2f8ABLPxr8J/ilba7rek 6XrOnW+qS3NtqN5oxS7t1kdWYhmUquducLnnpjPHyvCHiHXyTh/E5NVlZvRd+1lr/Wh9ZjuCcLi+ KaWfTinGKvbpfv8A8Hufu3f6v8O/hF4Ut5L1G0PTtNthH50ciKGmCF5Qu4AZO1j1HT2r8tvg/wDt Uy/E/wDaPvNK8JeJdSfwvp2tzW+68hAt9RRJdvyYJXIBBOCT6Yr5TJcpxGeU8bmNWN4RTbfm3/wf yPpszzOjh8dhcFdXfTy/paH7a+K5Ul8JvcPE81vc2G8BDs2ZjLE5I6DHTvX8Kf8AwUM0K+s/2hGv xeyLbw6URJuPlra3BnZXV8ewDf8A6q+7+j/VhR4sqRn1i1+Z+Z+M6qTyyjyLaX+R/9L5d+CfwS8U /GrxlB4S8OW8Rmk1KKO91eZ0lESyozDZH95hlcfKCBk1+lur/wDBGP43p4fvfE2j65cXUH2UPHpc OiS/2jcK2Czeds2r6hcf/X/0L4t8S8DwljKGDqJS5rX1tb+kfylgeCcVmuRVs3gpaXtpvb/g6H5F fGL4X+IPhB4nPh3ULG6s9SineGO41SMrGfLYLIJTtXBBDdQARXlj6RZsA80ltbIvzytbAPGXxngA 8gn+dfrvD+Y0s0yqjmNH4aiv/Xoz8Wq3VRwktU2vuuZF3bie2t9N08NPc3Epju3uNuwJnI2H+E+/ YU2zlaxlk02MkIjhJraSPbIxUdmIz36jivXd7qxcFZEn2jVNLuIbiWHdtjMm0sfMjjIwQuBnBGaZ p88GsXirEVMDxl4S5wzHrhfXvx61PvcruK16h//T/N+2uZrDzrY3rCNRvmMkXnpbjB2jaO56dzzX 9f3/AASBvvL+H+n6dK8U4eyjZZ7fKRsWyxGO2N361/eP0ho34P5v73+R+EfR5lbM8bD/AKdr82fp X+1jYR3nw71OxuY7g6f9jee6aCby3+TGw9COOTiv4F/itY6dpvxa8a6PeM9vd/8ACUSwDcfPwFfY JEA5AfBb8a/O/o0TXLjKfW1/xRzeOScczpT6Wt/6US+Abezj8c6dPqQmFpDfILCWNBuyrAhwvU4w uR/tGv7xf2H7gT/CHQY0VknTToI7qN4/KRdi5VlXPcMCT7Cun6R2uHwy83+p9n4FNPJMU/NfofF3 /BXHTn1X4R+ILTzCiDRNSluWkx5cKKsbBueoBycDmvzJ/wCCNeuND4s8SD+0hP5t/DDJKECASGPd GT0JBDbefQ18nw1SdXwhxyj0f/yR05bNLxZSlu4v8Ej/1P7jvGkUk3g7URFHHveyw+47oz5kTKwz 3HzV/BX+3fHFZfH7WzqN4tusVkyeST8kksc8isyueuM9B/er+kfo3Pl4hxK68v8Amfhv0gbr6k+n NL8kfHFibPWElvFmhQWKsbeV13oxAPQdz3x+Vf2Mf8EftVE3wa8OWMvlLdWulw2y3LqY2uRGBG3H qB/Kv1T6Q65uEbdeZD8B/ezHEtbKn/n/AJH3Z+3Lp0+q/BHxJZWsXnyLAlzIoQuCqSD5cd9wJX8a /gT8T6RNp+t6zperRxJcW15dm9jik/emWW6nfdIv8PXaB6LXy30ZasHl+Mo39+6dvL+mfFePFGce KKOJt7vIl5X95n2r+x/+wfq37WljqMdndpFcI0cMVkZ45IIIpGeIu+PnDAxscc5DdRxn9A/if/wR k8a/DHwxJ4m0LXXs9Y8P6WJLWewsimnXSwgFFk2hVVhjjHXjmvqOOvEWhlXEn+rlWPuN2fz0f/AP Q4d4JxWK4apZ/Qfv8t1b+vvP/9XnvAP7TH7RXwc+Kum2GueJb+8tfCWr/wBl32n3tvNLHeRxkoWj IAJI9T0x71/Wt+yL+2Z4F+P3hPT9DvTCniSO1igBfMMt0ShX95EwDBgcg8Ee9f0B4mZFl+Ao0cVl zVpLW34dbn5j4cZnjcdRxGFxyu09Lnyh/wAFFv8AgnbafGnw/rHjvwJHDpeqwW6XE5igDzwNEjZa NVwGDE555569Mfx0fETwLrXwt8T3vgrWLaC11O0uXmuboeY1zexOAUkEcgDJkkgjoMcHHT+g/AHP 55xw/LB1XeWGtG/lK7X5NdrWP5+8YsjWUcQOrFWjWvL5p6/5nA2kN1au1xPfySsJGlijHzOh/gUA 9sitmCCS6t4bi/XY0vzmMrhgD/eHY+1fvzvc/MaK9zQjNjZXFyDNqT6fbxqUhljhMioR0DegNaMi XM0CWtx9mMU06C1mMgDl1PysoHI5ptXgaU2411Y//9b9af8AgiHfwPoEobTpNNle9mtlit2Z4nlD /NnPKgHjJ/u1+9nx7WW68Aa4o2Iy2Eitu5QglAQfY8/hX6/4hU+TxJrwf/P1/meVRqKfh9hKkf8A nyvyP8/X9o7R5NF+PXxIaWwso4rjxjfxzajay7pY4j5cuTjnlmcjpX7b/wDBF3XdLHi3WdOt7h4o 9O+ziy2p5iMDEu4luxYk/l71/UHi9SUvDeHly/kz+evBGaXF9SEuql+aP6kPiSkkvw/11FR3Nzos rMsaknJgcjp78/hX46f8E+rsRfGLx9p88URure9WX7PID5ySHeGODyPmkA/A1/HeSUnPIsd3R/Qm Pqez4ywifVS/U/V/48adFffDnxHBIokmh0a5mKDPVU3Daf8AgPFfwN/H3wPr1n8avHcFtYQ2yHXr m+u728leOJ0ZgVAbbgEbicnjn2r9o8AMVRw1PFQqySb2u7H4h43YHE4jOMJXpQcoxetvO/8Akf/X /QD/AIIxyXln4jujeWxtrXT7kxxXsYZlvG3NhVx1HzcHuK/qZ8fu158PdaaFBsn0dxIoHz7GhbeF /Dj8a/WuPFCfHlSUNudfmj5rJub/AFDp0n8XI/yP5CvFn7EGsftOftF+Jl0PVbnSLm7kjaAWjozS iOKOGTcpU4wYxjngV1vxZ/4I7fFr4O+DpfFfg/xDquo6vo0w183a2zPJHJGPl2EAFTkLznHtX9A4 rjfBYHFYbJa38OUEvJX2Vj+d8r4UxdXLKuc4XScZN6buz1aPjTwX+1r+0j8Idet7TWPFN9rsWgX6 w3FjcrJbzWrRMFljQgKG28qQe47V/Vn+x5+2R4I/aC+H1hZzkT65axrDeW13C0U824Yy6N+Rxxz9 a/NPFTIsvw2Hp5hllkr9Pv8Al1P0/wANs7xWNnPA49u7XX+vT5nyb/wUa/4J/wCkfGPw4PFHg3w/ aw6haQjUVS2sFniuZAGbbgfN8uA2D+Br+Qj4teDdW+EGs3uky2jyS2V3su1ml2PCjfdURkBgd25S D/8Aq/cPAfPZ5zkf1KrK86KS17a237H4Z4uZWsm4gnWpq0arb076XP/Q7r/gkvq1nH8eNJgjvXjn 1iWHV7myuCEjgwyROjN2YrsIB564r+3udWbR7R42LjyoT5h4Vl+UE/kK/oPx6w8aXHllG2i6eW5+ e+FmJnifDiipSu/eW9+r/wAj+TP9tP8AZJ1j9o39pXUPCdjPsSSZ9mobzJLExu3j2rGnX5VTOeu7 rVL4jf8ABFv4n6F4Us9T0jxDBf6XpOkCRLGfQmic4QnDnGCOeOhz3r9N4e8W45NhsBlFGK5VFJ/8 DXp/TPxrN/DGpiMFjs1m7O8mvTu/Wx/P98QvAWqfCfW73w1rB+0Xtq+zyJImt5lZ3cAsrc4G0g5A 5X6Vx13bhoYpbcqSqb7hWb5gSeAB+df2Pg5+0w0Jvdo/kam5c1WEns9PIpC3DIZdmXbGGzyMZqaG KQMZiWHlgdffjg1tKyi0a0XU1sz/0fy5SGOLY0c7StcfvHAbd5PsD26Zx716v8Ko5k8beG762nuJ iniG1Ey7cvCqSgMU+pIXP+1X+vHF0Yf6t4zm/wCfVT/0hn+b3AKm+K8A1r++p/8Apa/Q/wBA79jG 5a9+EGitOGSSO1VAhOfu7Rk55HXpX5f/APBbLw1Pq3wxubu0trlTb2yyPPGBMzJFdRyMgB4BPlk/ yr/OnwnxCwninhZPrUlH/wACvH9T+3/HPCyxfAVemlfSD+5ps/jfImsYDLbJDK1uCUiKgTAAn5JA f4s55rNuVuLqSKbyViurhA3k5ysf0r/TDDq9Nz82fwBVupJdj1b4O2+qX3j/AMHRBYLUaZrUWo3N zHMsNyqxONrBT1BztOO5Ff6Fv7IU7Xfwa8KF7mRm/se32xPgNEvlAAY/n71/GH0qGvrGXtb2l+Z/ Zf0cOZ5DmSf80f8A0k//0v3c/wCC3Hhu7vfhZdtA0k8y2tvPbToAPs6xTEvk+m5Y/wAQK/jredrG WewvWit7y3XZMtuQY92doII4JJ549a/0U+jtPn4Kw9P+WU1+N/1P4O8X6fsuPMbVe8uX8IxX6D0M lxZ3NllYlmQea7LksBzub1r+sb/ghnr0WseD7staqBp+o+Va3I3CS6t3RAshU8jJB/IVX0jMOqnB cqiXwzX4n6D9HnEuhxJiKX89N/g0fuB+0vZfbvhprluNmYLR52SVtkbhMMAT7YyBX+fd8avBsFr8 WPGdmI4rW3tPFd5OkYAU3CtOx+U5zweK/OPoz5jDC4LG0pSSu47+j/yOvx2yx1uIsJi1G7Sa/F/5 n7vf8EQ4ns/GWrFWs/7LWcfYobeXbMGVVJ8wf7xc8da/pv8AjJps2pfDLxWDtZY9GnuLj5grEJGz nHqeMgd6/G/FJ014lYiVLW809PkftvDdOo/DqhGr0g9/Rn//0/6Iv+CbWo27fEj4jWlqZEt7fxdd INwJ2/OBGp/4CozX6JftkWz3PwT8TtFJsa2gWVoy20SZO0fTls/hX6fi4SXFcV1uvzPl41Yy4Mv0 UX+SPkz/AIJfTmLwNrtkdyRw3s+0BMgbpdxGfQk/zrvv+CkdpC3wZ1W7uEjaO3gKRbwd5kdCVx9C P0qKMX/rfKP95/mzLNJ24Ooz7xj+h2//AAT2kWb9nvwtOmS0tpEHdm3lmVVVhn2Ixjtivg7/AILe 6Vaaz8E71Zblbe9tNMmeKJl2Nch8Iqhvclf8ivo/DVOPirgof9Po/mfJeNVp+F1ZvrCP5o/iI1S4 ktNdv7BtrXGnyiykWE79wWNev45H4Vki48uTFzGRGxwoxjaK/wBW4xvTTP8APVqXIkuiX5H/1Pym 8MvHENQEsYu7Brcqr+UMwM6kA5+orkrWOJ5rhFmIWCQjaOQQDiv9zKa96zP8oUrKDXQvvcXIgme0 mWNdnljy12scDr9a/p8/4IK3093PPdrdXd2qpHgX3LwHIWRFHoGVj+Nfg30iKVSPh5jJv4br9T+k vo4YulLjlU/tOnLXyvH/AIB/UN8X4EPw/wDEdzKGeWLTZZ1hVQ3mADLDH5V/FP4j/Yz8f/tG/tAf Ey98GveW9pfeM702kxszcdZ3EfmJjG0rtOQeg7V/I/gNxNQ4WwuNzPEfCopW28z9Z8XuH6/EGeYf B4fe0nf8Pv8A8jyX49f8Ezf2ifgb4evNe8SJp+o2thcGSW6srIpJMjfMsYQ4C4AIzzzjnmuK/wCC eV1ap+0v4UFnIYDaarbjzIkKNfsZNjq3b5Rjj/Cv6orcYYDjTw5zDG4HaMGmt/TX5H4vwHleJ4f8 UsLlmKT51K+1tLS/yP/V/uw8KeVJ4YsW2FBHaLhHORkKCB/Kv44v+C38GPjv4fvuLWGytLqxukhQ TJMJ7kSHdk9OQB9RX9GfR4X/ABnr/wAMz8J+krJLIMJf/n/H8pH7Zf8ABHqeGP4DaRDbbY4ZdKjC RRyblCBV2HnkE4ORX0P/AMFGpfs/wR1G5kRntpI5tPkQLkb5IWCOT7Eg18zm114pV0/+fjP0/iD9 3wPQf9yn+aNP/gnddPJ8BvD8Ejb/ACLRI41C4KoMYJPfoea+Fv8AguFB5/wO1UWCzfbk05dkscTH y/Kl8whSO/P6U+CeV+LdBT29t/mfO+L83HwmxFSGr9hT/wDbT+LqztNU1uOzjjsIvt9mY5DwIlwx G5y7Hk4yTk1+gnwf/wCCavxh+NFhHrHhWwlv9MLm7ljlhWOzjibBXkKcEsOTknBr/RTizjLLeD8J 9ZxFnf8Aq7P4p4W4IzHjOjFUE1GMV0b+SP/W+VP2gv2KPjV+z3Hcaj4p8LWtrb3G6O2l0uRpLaQr jCncgAJHQE5+tfA+oaQRcSyRyKsu4O6nJGf4h+Ff7XcF8QYHibK4ZngH7rSvtv8AI/yhzLL6+TZv WyvEaTp6df1JWy1s0UASC5BDGRk3KwHUEUi2sxmDs8ZlKgoAo2jj0FfYP4kct9LkN1JKVkR5FlEa 5dkG0n2FaWkot5E3krszHiVipPkjGNx9hU1PgOjCTXMu5/Ul/wAEEtUvJYLqa4SOB7DUF0pwsAjh eMRrsKHqTwCfXca/qA+MEMUvw/8AEEUzqIptNkaXeDsZcfd455yPyr/KXxqUY+MVfl29ov8A0o/0 h4UnOfhNh3Pf2P8A7az/1/z6/a6dbP8AaZ+KFtDDbxk+JLhC8WXdld/NAH0B598185DUxMJIFXa0 M3lszD5h0P8AWv8Aa7htL+wMHL/p1D8kf5XVp3xNSPRTf5n6g/8ABKlPK/aU0q1nMc8+oSxy28MS r50sagbtx6/LszX9/GhtK/hawWEHBsEjjaQbedg6jsM1/Av0qIOPHeHfeK/Q/vzwLUH4ZuS35pfg z+JP/gs5pkTftC/b76K22mzZoEB3tKfOw7IeinO7j2r5b/4JwWw0f9qTwnKkhit9QkMb5cmJwRGR uB4zlGxj0r+hcva/4gfFLb2J+C8Hy5fFqT6+3l+p/oLeEY0g8IaR5WZo00iM5Y/9Mxxjt9K/DC0u Wf8A4KBysFAe3YxhmO0JumLLsz6Odv51/C/Bq0zJdoM/rLiP/kpctiutT9Uf/9D+7HxQ5Pg3WZSM uNIkbA+YcxkEfTmv89X9v/QYz+058To4pnkm1HVYrny5RsQNCAP3frjAJ92r+wvomT5eI8dffk/z P5d+lLHmxeUpLapL/wBtPr//AII4adPY/HjXGCwxLbyW6sY96zyhkR3wCBnDAj6r6YJ/tq8QOqeC tUbcHik0R1BdcggxdT+Ga+T+kLf/AIiNd/3fzR+s+HUGvDOm/wC7P/0k/wA9P/gp3aW9l+1B48sL e9t5YZtVhvbCKBQICq2YDgjhjgscnpuFfnroq3xlhEKqz/b4RImAZHHmLwB0/wAmv9CuDZJ8D4F/ 9Okf535SlDOakH/z+l+Z/dh/wRsijt/gZpVlFPDPGlp5cU0KiOEeX99FUccMduP9mvo//gpTcyQf s7/EMRwszz+GLq3ciMupR4Cp3D0ABr/M/Gf8nnlf/oIX5o/0d4w93wxkl/z5/Q//0fx78ZLbWHiG 8hhLiLzRM8TgAxlwCQPYDH51yTrHcRvOg3lX+Re5r/djBf7vTv2X5I/ydbvUaLKsFgdekhGCPeoI Rqhjkhy7W7LvMe7KDHfHavQML62KvlqoKlcOenYmm/ZrlArMCQemzpW8fhQzLaR4bp0Zni8sbg7q cZxkAVctZisfn3F1E7OcCDaVcj1pkqSbsf/S/DV7cSuzRuAueF7nrSCaSJ/LdzhRsRRyB1/+vX++ B/ktdbErQurHevLDeFHUA1Nb3M1suYWERDbvmXOaBjGl+2Xm0kodu53K4T9Knt4kBfa671fAweTj vQS5JDbgybvtFxESw+VW7EDvUDStJgw4XaQT9O9BHOz/0/xNijthamVt6eZ93zYygOehGexzWRcQ SH5SGVc/eHC1/vik3sf5KRlfcz5o44NqQ7izcP6dasQZjBVo2YYzkDimoNlJp7Ev2mOPegjBWZdq iZfung5H8vpUUjtMAs0ikxcRqv8ACvp/n1o5JDIWtRJwCRkZA6ZqBRsXO3heMntT5Ha5cHrY/9T8 NLIwTOrT87IyiFeNtJcxLuKrJk4yFzg4Ff75KLvY/wAnJNWsVxEZFAUBVUZY9+KcsnlyJ5I3hV+Y Y5z/AJFXBWRkI0cskJuDEylx91iMirxfy7eMn59kY8xx0T2J6cVDg0TKVtip9t4xtJwcAn0q/Pcx /Z18uDbkZ5HOap0+xk3d3P/V/DS3uHuUcCFQ6n73ovNPEYA2kBg3IJ4wa/325Uf5GylyokAmhOIl iCuhSQMgfIPcZ6H3qezWKOG4aV8uB8i9MVPJoQpNyVynK37vcoDYb94oXoOmSaqEeZlc/KOg7VHK xuVpAoWNvnXd6d8VxnxFmuH8OXM8YUSwgQxqUD7d+eSPw61wZrH/AIS67/uy/I9XJtc2oL+/H80f /9b+LnxbeTHULm2jhht4be6I8yIZ3swBOD9T0+tci3mzSbW2s2cLtGM+9fq3GDb4kxv/AF9n/wCl M+TyRv8AsrDv+5H8kbS2f2ZPOkCgkYOOucVL9rZYjgBjjaBxkivm4/BY9ZybPbP2fNC06/8Ai38O b/U7See3h8UW2+GZvKsWj8zEob1Y/Lt9gfx/17/+CfXmxfs0eA4nlyEtFdY9oxGrBSmCO23bivg+ IU/7Ywr6an6Tw5Ff6qYyT/mj+h/Np/wdFPeJ4O8FSMVQ2fie7EMzcGWNoLUsPqMA0f8ABrdcyan4 B8cRSXB22eoMLYSMeuFO1R9MV9fxf+74by+3dfkj5zgaPNj8y5t+Wf4N2P/X/rx/4KVxrcfsd/GA XUcUsEfgvUZMOgY7ktnI9v8A9VfGv/BDvTRp37Nb24kl2rrM0sW/DRvhnB2kfhWmYS/4SaEf77/I +mymNq+Nb/kX5nkn/BxNY3n/AAx5q+oafJJ5gv7C3mMRKyW8bTFmIxzjjJ+lf5uep6np00t/FBJO 80jGCQHUZAEbJUBTng9q+ww0uThylNbpv9T4ajGUOJ8TUfwuMbfJH1l8I/8Agn/+1X8aNDh1T4be CtQ1eG4tkui0Ess7xxtgo5bIGGBzycn3rxT44fs1/GL9nTXTpvxZ8H6r4buYiBLeXOnSxWaEnaJB K3HJIHXvXNl+O+sylCF9P6/A9/N8MqGHVWb0kvxP6N/+DX+ylu/irr16gEk9vq6tfNJhEj81pBGy +pLYyPYV/eN8ch5Xws8SPcOqx21usz5O0Bkyw/keK+Vw/wDyUdS38yPfztJ8M4f/AK9s/9D8V9X0 u+vP+CiZtrqMRLP8YTbg7toTN4SGH0XPSv8AUh/ZziSD4O/DyKBojHH4dtI1aIZRwI12sPbGK7uJ uePEacv5V+h9LkEv+ML5eqn+jP5x/wBse2s4v+Crnwut4y88aaZDLL53yNGbme7V9p9PkOPSv6d3 ITwbcrAfkHhvdAB8pwIgRWWYvmzSl/gRGFaWQ8q355H+Vr/wWftnuP26vjHLqY4k1+5hinkfYsWx YkU46EkIfwFe8/8ABvp4evZf22LCDUrzy4fsMI86FggQKY3RQe4YqgPuK9bilJ4B+i/M+e8PafLm EZT/AJpfkf6aWr5j8G6lHPIUJ0gxiRVwANvBP1xX+Yf/AMFAP2efif8AtG/t7ftA6V8LvC8niDWk 8b6pp5SxDTT25iuDGZcAEfw9D6exNZ5JVjSwFWU9lb9T1MdhpYnMlShv734Wf6H/0fxW0/8AZz/b n/4JyeMdC+NPh7wt4r8KWukTQXV1eR2jnTrphhpFmQDDIQh3AjGO+cEfu7+y7/wcx/Fi68W+E/BH xYsNJstBnnis7+/GntdT2xZwm4lj90dSMj6jqOp0YVHUqQ3dz2MNWSxsMJXWidvyP669V8N/A39t 34HWk1xc+GPHXhPxpoiSI7Ilw0ImjD4C53KQcHBwVZexFf53f/BYX/gmJ4l/Y3+KfivXfBvhHW9Q +GGuM13pV/pyPJZWDFtxjc7cArzgNgcjB7Dvyi86jw1RapaGWd0nhakoPpofz9TOv2h9iL5RXEbg /vVP8Sup6EGvdf2cbO01X4xfDG2gRbi8bxdb2pklhKRo7SRlUd8YxkA/hV5rH9zUa/lf5HDkKvmV FT25o/mf6+H7GMX2X4A/DiwlkLXVh4ftLWb5MIT5anCnvjgV/Ib/AMHS9ndv4p+FdubmWaJo9XnV CQiW0nn2mG/ERgc+h9a4uCHdN/3X+h0eJEL4yy6VF+p//9L+ObUtPUahcOG2sW8yTPzHd6Ajr6VY 0ZI01LSQLiWN21yz8oBcoW89MBh6dfxAr36sV7zJwfxRXmf6xn/BHbTbnS/2NfhtY30T211BoqyN Cx3BxKocN7cbce2K/Ob/AIOTra71v9m/QvD9rHJcT6n4rs54oLWPewEdtOjq4HbByPcivm+FfcV3 0bPquLKTq1fZw1bUf0P439I/4JXftha74Tl8X6H8Kr++0S6tludy2nlXgjZd4cjgnCkZ4PNfbX/B Fv4TeJPhd+33p/hnxJo8+l6qyiG+s9Rj8maBIjFvVV9MquM9d1XmVRVMDW5b3/4Isly+rgM3pU62 6/yP9JjUVW38JXKZKxHScBmGMBVyP5V/lof8Ffnkvv23/jlYRz/ZW1PxVJdNcqOJccGPceh68ewr 2ch/5FVdPtE+e4gf/ChSVtOZn//T+Dv+Devw9Jp37ZtlNDbOIbWYLK9y3nYLsu11HQ7mTOPp7V/p Q+I1jXwbewsvyDTFVQvO3uD+YFcsNMxkvNH2GPSeTYdLz/M/y/v28Lc+Iv8Agor4timmlkn/AOFw SWlxmLLJt1EgZB+gGPQV/ov/ALBVnNa/s4fDjzG2FvDlvE1uRjbt4RiM/wB0D9K68+Vsxpy9f0Ly iNuGasv7yP5qf+Dnq4uYfDPgHy7v7NawapeT317GVDwzKYvKI9/lOPwr+GrUfLuBObhkklugLmRn jBLOfmyR2P0r6CrFPAUXfW3+R8NhVy1q77sw4hBHCIZHdoXm82WN5CUlYdNy5xxnpUM8wkkKx9du yNgMeWK89u9Gx13u0z//1P5g/wBk/TJ9R+Pvwz01LpYf+Kktrh977TMVkBP4jbwPUiv9cT9k2SI/ An4dm3ubq4SHQLZQ1wgSXiPaCw9TjP4142Mi1m8JLbl/U+5wK5uGqkn/AM/P0P47f+Do99Qm8QeC YbeG3uIrOxmvrlruTCRGSbZxzzwh9eQK/mK/Zbt4b347/CXS2jxC/i6xvnt0T90THMrFi3bjP6+l fV5l+7yy/wD07Pk8hT/tWUH1qJfij/Wo/Z0sbXTvhJ4LttNKpZQ+HrSG2iQ/IiiFRx+X61/Fd/wc 3zPY/FTwRboJ7yefTvtLW8M/yyp53zq2OmW/LmvF4Xd8PNvrBnq8SRcMZyx6S/zP5T7DwzrOv6lD ofhKxjv9U1CVmisYwbk20mBligy3cDbX6K+Gv+CRv7ZfizwDp3j+z8CXb6SbT+0p4ILZrLULo8nJ idcuNpBHTv0qcTjVR5aUt29vvOb2E61JzT0R/9X+cE/sq/F7VPiPc/DC08Nz/wDCWJq66YlpOJLW /DZ6FSjF8DPTNfcmuf8ABKb9sb4V6dpXxQh8I38U3huxTUlvdMWeOe0Iw/mCdUChlx6pg9ulY1sZ CliIYV/FL+tT26WGqxoKrHa9vyPr74G/8F3v2yfgAuh/DnxZqv8AaOmaI8Ol3J1iwjk1GaOL5GD5 ABcAcnA9yK/tZ/Yd/bH+FP7b3wa03xHa+IrFtbms/suv+HbuGKzuJHaP5l8ok7gVOeMg5PAPFLFw lR5dND0YQ+twrO1prU/nK/4Lb/8ABH+BX1r40fATwncQNIr6rr1h4ckMJugCZG+QDauT68cfiP4p PEVhPpmpPpWoA2OqWjGG8sZ8pcKysVYlTgghlIPFenFw9jFRfQ+Rpw9i3Reyba9DnZbYAjc5BTgE Hhs46iprewlUI0oIhfkOBWZrN66H/9b+QO5s7ZZmbIbH3SOGFaOirPd3dvawKHdriOJBIMpy6jmt ai9xlRdpJn+pB/wRC0f+yv2Qfh+A2yQ6BELyIpt8uURohj/AR5+ua8W/4OAdYns/2UtcS1TZ595C BLGx87cw8tBt7DnOfYV4nBjVWrCL7v8AU+14hUoYiCf8qPwv/wCDdHS7m/8AjPrmpau532+beC2E ojmlklKHfIp7DymA92Nf2+fGtriy+GPiCMMq+Voc02WBKFkgY9e/euuEbVW/M8rESvSSP8qn9teW 6uv2mfiS0nlzga3cXhuCu+XLuM4PpX71/wDBs/FLB4+8YXshlc6nK0EUkibmQrMjjaT/AHuh9MCn XV9yMLKyP//X/t0+Ol0unfC3xJMFZ5E0aZ93fzPIcDI9ya/zLfCJn8W/8FD7aTUJbtkn+Ikt9a+W m5I0iufNwB02nYysR2LelcvLZNI95yamrn+mx8BhO3wx8HiZVW3/ALFtoYdqhVZUhVSwx6n+dfgh +1aIfEX/AAU0+E1sZDFFo8NnFPvAchUkuZSfpgn/AL6qIxN5VND+hq9Y2fgTEYDeXpCupIJRxjgH 6+lf5v8A/wAFW5X8V/8ABQDWotO3mWXxLFHLKxYRxyNKCVDHoqg4reK/dnLOf7w/uw/4JwWsul/s 4eD7ae32GHSIduPvNlFKkn1wDmvxY/4OPfEMlv8AB2y0y2tkvbzWNRaFkvod1odsbbgrZGGwwx6U YJcsl8zHMal728vyP//Q/lAvILbStOMdvGlt5SsixR5YRnJ4/M9a5rz0eIJv+dsFlzjNa4nZFxl+ 6SLlg72bh5AzoWG1B39c16DY23hu7t7PUJJZ7W6trtg/nP5UIyuMgd+p/KuCkl1Oim2XxNpr35S2 uWaK7MdrHEgz5zbhkqeuDzn2r/Sx/wCCJlr5H7Kfhi4bzXOB5bsvlKivDAQgGMnBL8/SuPGwi8VT b31/I9bAznDDVEvL80b3/BYnVhb/AAZ0fT1YrJqXiaytH4+ZhGJZcD8QP0r7c/YgshZ/APwHAHlY f2NbIpkO55Ssa73P1YkcelazheKJp1JJ6H//0f2//wCCjIGq/tdfADT4JATHqv8ApAB3OzJfRu4+ vOMfSv3m8OmWHwLZHDNIdGJkYgEgmMZOK8eMf3mp9JKs1TZ/nt/8F7fEEGoftTXx/ezxaOsyKWRh JHv2EgY6khuB7181/wDBIYPfftfeCsx332PVo7e2RYrciVMT7yD/AHfuH9aeOgpLlqbOxnhMVNPm pvVf5H+ln4fVo/BNi0x3MmjKWx8xJMYA/pX+eH/wXO1iPW/2vNcguCun2ltYTSK6n5mIk2ksx/2Q Gx2rbC+5CSj2OfETdSSct7nl/wDwRs0oWf7YPg60XUZL+I2Zv7Q2iCVoY3mhTDA8noc46BjX+knF HHY+CIWyX26Gsr5OSXMYP88V5EYJY9yW9j1Paf7Jqf/S+f8A/gr0lxrf7a99Hax3F1H/AGuiytcZ YLi5Jz3wNjZ/Ov7M/wDgl/BMn7MvgGe42LdroEEckccXl72SNSz57lty/rXiYql7WvTnU1lHY+kw 9X2VKdOGifQ/NH/g4R1K1sv2etUt3mnjutQ1CO5WMqfIkMI6E/VlH1r+FXwZBNd+PvDOh6HKhX+2 oIpreWTcb7ZKpxu/3wPSu2bn9XjTb92xzxUXUlNLU/08P+Cb2knTf2b/AABDcKI5D4dt7jy+V8tp U3FT7gswr8hv+Di6/i/4UBPp4kQXs19GEEj48kdSFB/vBMfSuXK6UaLioaXOvH1XUu5vVM/hJ1GW 6t72Db5UiLsjlYPvU7eG5HXp2pJGgvr2yjW1ZUaYpJJbJu+yLtJ349MgVGKhevK5vGr+6gj/0/3x /wCCFGn2lj+zPp9lFMlzFCkDLeJ9+dmgjLnjtukI9hivZP8AgsfcxQ/sqeOPtEMM08sUdva5BLoU Ryjcdwdp/AV8/lcVGGnmfX5pPnmrrsfzQ/8ABD7Tpbj9ou+ivgGuIi9wjSNhZArNE5wevMy1/dB4 tY2PgiaSNiipYKQsI27TszkH2OKKceXGSl5ompNvDwj2TP8AMX/4Kn6pct+1h8T7opJcRpq88N1O Yh59w5kG0j0XgZI9vx/OTTJ3vJLCOENPdLqESyWqjLOjSKCvqRgk8eleni/enex5VF8tbU/0r/8A gjJbWFn+yd8OoB881tpPmTPjhZfusre61yn/AAWyhn1r9ndPB1tc3YvPEOoGyiks03bBJE+Q4z02 7gf96vKwEVSm+Xuz1cbNTiudH//U4Hwn/wAEAf2j/iB4Lt/Fula5JHZ6hYLqMMT2XkS2YkQSCFQW BP3hye2Kyf2Gf2V/iB+y7+2/4X+H/wAQ4YbfWxq8EEs5fcupw+YRDIMfKckMAB/cPWvmsxw/1zDV KEtpKx9dl9f6riYV47xdz+/DS4Lix8JWi3cirssxcyv91GXaCqj8AK/zz/8Agt6rat+1T4vkjgtJ ZLHxhczo9w5jheNzmPnBBGGyP92unLv3eGjDsl+Ry4982IlJ9Wz81f2dv2cPid+05470z4f/AA/0 q0OqavIfPmnm/wBFsYUYq8srAdflbagyTxX68eNP+Dff9pXwZ4Hk8ULr2m6vLaWBu44W08ZtRt3I wY4+UnAPfnitW3zXPPmlsfgB8Uvhv4r+HXjLU/DXiCym03XNHmkt7pFlDWjujvG4X+LkqSNw6GvN NtxATFIqCIjcRnLsTnIrZSvHUySs2f/V/lavZHcxPaxu3lja8cg8sgjJ49qg0i5vPPku9Sb7PEWM KQBt0agHAYnrXgvS53pWVjsG04TS/u5cTlMxBXARgR3/AAr77/4J1ftxfEL9iz4q6TqWnavDb+Ct Qv4rbWNMuriTyUjjIzMVXngAcryQADzgjys1wix2ElhZddvXoe3k+IlgMbDFR15Xt+a+aP8ARw/Z r+PPwi/bd+B2mavZtp2vtqulLLrNnuF/HbOVJwQ/JwWxyP5V/P8AftY/8EL7/wAefFrUPFXw4tX8 M+GtT1dp59L0q1ii0y6RDiP90pUIQuRjpz+A7MHUnDDKlU1sl+BdRU/rftEvdv8AhufsD+xx+yb4 G/ZR+FWnaFqHhfS7SXSLQyXGtfZg07MDvkZ5Dnp6Lxx+Ffll/wAFc/8AgqL4Y+Efha++H3wX8VXg +ITPJFI+nym0jtUEY3fvh8pciRdqZ5weMioynCzoV6teT0l28jpzXG0a9ONGktF39Pmf/9b+cTxz 8R/H/wAWfF1/4z8a+Jdd17Wb+bzLq51jU3vTPIxZnC54VdzMQAOPYDFftr/wQvtpJP2grO/sLV5l lne6ubqOJjJJgyW+Cf8AYL8Y6ge1fnXGEqtTAOEPi6etj7/hVU6eYKVTSPU/0DtTkjtfBkRiVmhS 33v5ceHxt53D2r/Nt/4KxeJdNn/a9+IULzvN++uEEhP+rYXLER7ed2UI/Fa+yyBSWV2XZHzmbcss a35s/Mvwra2R8T6FcOsgge/2mGNMSEYyOnQZAB+tf6P/APwSC0oaX+zh4Zgt4Yra1j0S3ltrMxlb sNIpd5HP+0HQYPPy89a+Rx0ebN6Fu59DhJ8uVVk+tjxL/guzqin9mHWbOYIk8EU135w5ZW+ySpHg 9sMV/Eiv88rWLPVnmi/tN5w4iWRW3/LdggEM31GK+0qP/YkfLxbWIuj/1/5ZNUvWuLj7IivCw+Sf jHnADHf2/nWjazyWqRHyJbhIdu6Feu0en4CvApW5Gj6CTvJM/tA/4Ns4mvPDd9ELyCaTUrTzRGty JnsJ4JnRE65+ZXOc9CBX9Iv7b+oXdh+zz8QbiJS4i0ea3ltkcCWdCmPLTPQsTj8a+K4VjUjnWOlN 6e0dj6LNJRll+HS/lP4rvAv/AARl+NP7VWra9438M6nqHhiweee6sLa4sxNbypLIzJzv75BBKjjB 714tL/wT1+Iv7JP7SPw+0z4i5vL19WsrOe8Np9mt7xXuQI2THysBkcg9UIPPT67Mnz4TE+jOHL0o 4ui/NH+gF8BUWD4VeHREBH5llDJGsaYgi/dLtwfTvX8k3/BwQYdY+Kmi2awBr21t7aR5yp3yITN5 ihuR8v7s4PYiuHgmLp5bL0l+p6fENpY+L80f/9D96/8AgiZDLD+zP4Qt551N1YaW8xA4aVZpQyk+ pUMF/Cun/wCC0er29n+zHrFlMPNy8t7IJM+XKFtZlRG9i7IB718NwpRdPF1L9Zyf3s/VM/qxnCLX 8sV9ySPwb/4IK6Tez/F/xbLb263ElzFFaCWSYI9pMjqTJs64Kz7a/sS+Nt8ln8KPErTO8DQaFcOZ 2Xf5ZaB1H4EkfnWOGoy/1rxLb00DEVI/2FRXqfwEeG9PufEX/BQezjvWP9lRfEOUyO8gVZ1STdFy eoZuPYZr/QA+D0EMfw30u6SNIUvrFGMcHKRZiBIU+gzx9BXTmcH/AG/DtY48FO2VST7n8S3/AAXo 8RR3vx5OkLC9zcwpNLFa3sGzy0FuyNtf1cKcDp932r+aC81GbU5USxtmWJBullf5HVs42bfavu8y dsJQT/lPlsK17ao13P/R/G39gfSI739pD4fFLhrW6N9Db7Hs2keRZGbOeOh2g5H92v8AS4+CDSxf CfwxKzkC50qORVWLy5IN6Bgfrgj6V+W08MnxRDEvpFr77P8AQ/T61a2RPD9HJP7v+HP41/8Agvn4 sWX4p2YtY41nhEs8as+yQLawNHI598MWA781/MJqkUdxeLdkuqbQSCMA555r7jM/hp+h8XTSvK3c xpYbIXXzN5kJUNKEbcYx6j0rLs9De0vbvXYdVu5Slt5NtZiQNFnOcBB0+teSFSKsTz+IpRLBAuB5 u0XkQ5SbBz8wpbyGwkkSWe4e3k3ZhhiUbJCegJJzx7VlPczSsrH/0v5SrkyWpDKpnRWBk44A9av2 mpQ6it5EfsyPDEDCkP8ArEU8EsOx6898V8OezZkMyLIURW3ALy7DoarrHe215CY5VSADYEaQRx3B bIIPtQXTvcRTe3F5+/mQMj8oGDpIoBAVT3GMcj0qW0hj0uTUJba2tnW4BuZts22cyZx8oJweO36U GlhltepdIT/pEZbIcPEUOfTmqcazw3Gy3uiUJOUm5lGeuD6c0DV0z//T/lJt7V7GRpnfzvOXakbg ZHc/Wty1nENq4ucvFO4dItmRAynAI9D7+9fDn0c9zJ1aVNQuba3SPyo0w7FMn5gCOfz6e9aGn250 vfNFIHndsbJH3EdvTgVhHdGkU7JGiYba2lkuXijllmUkp2HqeKzZLqx+yytFCkUp6MXIRMHnOfX6 iumKT3NneMdCqBM0azL8vOVA4Jx/+qtWwvrm4hupQtvItp8y2nnDzJiOvHam9HZMhcvU/9T+W9bq 9kZp7Q2uLfaQWboc5Ix3xTpNRjKyfaRFHv8Al2P8zz55ODiviErvU+pceVlUbUjNxaxyQurYSSLJ 2n1zVixSbzZ5riTzZGiCx7eUYnrn61UoWizGUb3I7iwmtZPKmuJooJdrqFIfYDg4GeO9XZru0Nqk UAEVz8yNJk7pgCMZ7fgKOX93ZGcYJSsdX4YsnTUIhGwkupFDokg3QIR0LDvz1r9DvhzbvD4dkFxd RCWPTvtImiBjEM3G8juQMdO1f079Hqi3VxbktLR/U/FfFtxjPDJb6/mj/9X9Q/8Agj7ZxzaZNOt0 Lm4iMQhvtxeXy/IUTBTnoS6fpX6d/tpavptv8IvE0MsnlF9KuLbTm2lUWQwtuyfyx2zX2eY0J1PE +cb/APL/AP8AbiKGIVLgim2tqX/tp/Bp411K6bUfFXlu0MA1+4heeYYmd2bcXVe4yev+zX5nftMa hFqWraZpr6zPeW9loRsb63W3VvNPnGaJweGULnbnIzub0r+q/E6ny8EVUv5Y/mj+d/Dmtbi1Te13 +TPz01CaGxk+yaesaW6yNmQnMgyeh7cc1qSi1imibT3edJLRDMXwCHKgvjHbOcd8V/FEtKjP6ZqV Hexr6VarJEHaaZneba0Xkn9woH3h+v8AjU8atHJPFBIr2+4lmcYbOeuex9a4KsraEKb6n//W/jBj mlZzbzzxzrHFkuz/ALwjHGO/tz6VPoR+zy+YJDPltxjcDywOzBq8OpPVnfutT6Q8GN5rwW8ZUQOf nYj9zFnksSOgrsdItby3knsb2SB1lunkgk83IRWJK5J46Y715lSWupLgraG9baPEFP2yTzPJJkil MQYsc8D8AcZ9qtXa3Vte2F1BIBDCpWaB41aGTpjIxkEY7GueU3ZlRpJ6C23h201uK8W3f/Srv5ZY i2FcDkEA9DnP6VGbO90qIfY7SKcqwiunc7ZIRzg47jIx+NclNu7kzSMORXP/1/487O+Nnf8AkxWl vJPNb+bbW4ZvKhf+6zjocc8/lWtJr0kYaO7t4gUbLujmRl46Dsa8WEnqOnJuRxuswpr6yT2ss9tL gDzVXypwB6g/Q1sqlwtpaX1+z3VhZfubqMcXUiADDdPrjr0+lcjk7s2+1YqabcQX/iCxvdFSaCaz kZIraUbzIHXaDk9+n516Lay3ltbyM8UkQiuRbvP5ZkaN2JOCv504z7jOhl06OOxjmlvEuZ7gsmyN Coi2gFSeTjP9K59YbWNkea3BZHJTzBj5uRmrjLXQLo//0P48tbvntm1DSIp7i7nRkuxOjho7aOXd mJWUYyvHuPeuavLS21PTkJzLqli4a0uWARlHOQ5/i/8A1151GVpI2k7JnlGs2n9pXJFz89uJPKdW GAWH3sflXvHwmTTLfU7S1i0uxB8oSRkpsIdVABx3Jyfx+tfS5LJf2xhW/wCeP5o83M3bKsQl/K/y P1j8NzS6hBpNxPKdNv1SGS3gtW8x22KpSHBOQWAA2k55r+yr/gjZqiSeCLC2R2Fre28JiimXy2tp NjMYmBJwSSuc9a/rjxqi6nh/Sn0SX5H5h4DVYLiXMKMt7afJv+vkfo3+3Jo5174Sz6VLpF1fedui uFt4zJlXBVcKOBhiGJ7ba/g4+JEsVtrnjPQZNHhtdTh8S3EMtvaxlJMFkZSoHPIO31+TtXz30W6j 9li6Telr2+e58p9IBezz6mutmf/R/G21xYX4t5bW6t2mQA78uIyODkdjVtdPl1C7kjtxsuGlMcYc +WHwM7s9OmDX+vCtY/zmhL3WVpdT1lrW206S58saU/lWxFugRwGDEFgMv6ZJOMnGKxpL6ea+ml1G BoUjmVoJrfJiJ4xuCnpn1pO1tTWKtFmvottIt3JPdQo9rI6ojeZnO47cY6gnIr+kj/glx+xCvieX RPi5LqmjXGr6NbwnyU1iNLjTZkx5sKxqoGCQ33+fmOTnp+XeL2a/2TwdiKiV+b3fl/nsft3gVlqx fFkcTOVo0ouX/bz0S/P5pan9Teh20ug+HWttReKMJYOsgklj/drs2gnnHYGv4+f+Cs0dpof7Q3hv SrfUy93PFd6tdSPKnkmb5WtRuzghlI49GPrX8a+CvPV445Evdam/uTf52P27xpqwhgcNO+vOrfP/ AIB//9L9/P8AgkZ4ltr74L6RpX9r2hvoNFjm1Cznuoo7i3vCFE2OeVbYcAdM167/AMFLpbWx+CWt atFqkVzqUDs9rp0ZS7a4YWsqhQozzkD8PTiv0LPaFWHiVOjKLu6qX3tI4MzzCFTgRY9STtS5t+qV 7H55f8EyP+Ck9jceHdF+FPjKZY9TNs0OnXLmPyng84pHhQudyKjbs4JxnGCSP1M/af8A2WPAH7Vu g2lnq3iPQJbaO2S5jY60lqYSQQjPwefmPUdfwr0OK8qr8EcYvF0U7aSWj8vzPH4fxtLi/g3DfW5K 7XLJX/lPgrTP+CM/w30G/wBN1GPWPD63umbJYZU1yOKWYKQVeRUiCk5Gd2AfpX6lfD7w/pvwC8Av FDrOj3gsdOkEUf8AaNvP9peGIPtVmCktlGAA7ucda5+JeOcfxXGnha6k+XZfM9Xh/JMBwxRqww7j FT3+SP54P2zf21fB3xg+OPh/wRLYW2lXPhvWbm1vdRto4vK1KclNvmOnVVMRPp8x7k4/o1/Zi8Ua P4n+D3h26/t7TXu5NFilnE9wsL7RFz8p5xwT9K9HjXh/EZZwjgKlSLd7Pbo7/wDAFwfnOFxUsbTp yV+Z/er/AOZ//9P9rP20PFeh+Hf2kfh/e3F5pbLLqOnvEY7tHMIx5YIA9PKcgHoSvrX7Y+EtRsdT 8AafqOna1aXIk0pLqSWaYQs25QSGB+6evB9a+qzrB1llWBxHI+W1vnp/kVkmOo1KGKw6kuZTb/Fr 9D8Lz4y0/wAM/ts6o9xqlnBDqWsy2n2i2u0njmDOkbMxBxgiNxn6V+5/iTxBZaJ4PTWtP1SwuVi0 +OaNobtSpITL8j0weO5xVcS4Obw2CqqLs4JbeS0DJcfB4GtS5leMpPf+ux8dfBr9tDwr8SPifefD W/1FILxIpFtru5Kw2u+JtpzJgA9AADyc9ODjM/aE/YZ+C/7QupfbvEWvaRb6lFqDXgUuJY5pGABX cudwIAO0n+EelaZZDMeEc0pYygmpOKa32e6+9HHi5YPiHLoqu043e+23+TPHfDH/AATK+BPgPxLp 3ibStY0qafTlSObcZI1VlORtCg4weQBj6mvq/wCMfxm8Mfs7fC66vdR1rTbbT9O09nWKXUGhLYGT gFS2MbycgDgVvxDmmZcYY+jTxCd27Ld7sf1jBcNZFWnQtyQi5WWibSsl89kf/9Thf21f2t7j9p3V df1OXSb620gTLbaQpulVZ4ImUGUqQHAbawweSHHOeK+EtE8aTeHriC/0q0VbnSrmO/sre0kFncl4 3V8rcsGKk7AMjpX+kfBfCFLKeEKfD+KXMuX3l6rVadnpdH8VZhxLXxWevOaT5ZOd1b1bX4dz+qf/ AIJq/wDBUtviVofhv4cfEbT59E1+xeLRI767uWmg1JolA+9tALFTnjg/nj95vFvjfTrLw4NX0zUY ry3Ea3rfvjFFEuMkM2DyM++TX8VeIvBOI4a4srYOlF+yk7q3Z6n9ecL8XYXPcgji4ytJLXpqtH9z P5av+Cjv/BQPWfFWsX3wdgvbux02MvP5thceXHN8vlS5nRMjad4HXr154/Jb4DftKal+zn4ttPEe iG5univo7yTTYnlM90jDy5VDYKDKc5Iz8vWv6i8O/D3DYfgd4aqvexMW2+2/9eh+BZ7xriP9c3jE /douyXl/T+8/sG/Yo/bi8HftQ+BtGfVby50u+GmpE1rNKLmLJJiYZXn8SBw31AvfFn9hL9mv4q61 da74ov7BtRlUzlzp4mKBWzmQd+wIxzj0xX8tYzAZrwHxRiKOFTTjJ2tfa/6M/e8VLK+I8uoVsRJN OKfTqvnuf//V/qN+GH7Dn7PHwy1a38S+Er/TU1LC3Iv47BLBpxjHO3Bx6f41H+2d+1ndfs3fC+71 7SNTi1Mic2kOm2l60k13tAJjij2kY27yT/s9s5r9KlPMuMc+w1DGJ3k0vyPls7xuXcN8H4qphpJq MW/6+8/i5/aI+P8Ar37UPjLxB4r1O5tbMXyyyRaQUbdYjzWdIy3J5xjt1NfKei6nY2elNbahYzW8 7TuWFvA1xJIeQvC54464OM1/o3w3lUckyTD5VB39nFK/d9flfbyP4SnUdeq60tLtv72aFvd3d1Z2 8mn2gBu5Nn2pvllgyMhWU9D7HmkMWqWs2672yXediSPy3H+RXtlqSV0yzLqE1qsl29vNK4QW+I/n JLkIe3T5jn2rPGl3lq7rd2yW6WbJdQiBgqkSDKBCpwcg9jik9mRzfvFY/9b5N/Zk8LeBPGnxR8Ka R8R9Xm0XQ768RjPFAt3FdsmSbedWIAB4A789Div7ef2XvhV8IfhZ4O0jUvCWtobRNLjUiPT/ALNF CgjBUrsGz7rDGPQ1/an0j62Y/VMNg6KbotNv11/yX9M/EPo/zwNCji8TOVq0ny6/ypJ6fe/X5H05 q2qeCfG2lz6Hq+oxG2vkMQd4yyshGDvJHH0Nfynf8FaP2Q/hB4C1ZfiD8L9Ts18Rz6lFa38dpbm3 +1o8gVmV0yhZEfJJHIX2r8d8EcRm+UcXUMKouNKo+WXaz7/12a2O7xpjl+OyZ4uhUTqxnFq3WL0d v67nzx/wTb+Gnwc8YfEddM+LmuFNQ0XTo1tbloI50uMTgyMd2dhbdH1HOzg+v9i3wu0XwJ8ONCtr TRdaF1ZPAq208UarAYsAj7pIHAFfVeP0M2xWf/U4xcqSS5bLrZX/ABuet4N4zLsFwrzzmozlfmu+ 0rK9/l+B+Zf/AAVr8W+Hbv4Fa61ney3V/JY3djBFEPLLLJHwFz945x/nmvxA/wCCU/xN8KeBfipq un+KLmXTrbVtWtzpomtQ3neVEihhIWAb5mVSozy/NdfAuUY2t4WZhhORqpfRNW7nkYLOMHDxepV1 Nez5Wk1qrtf8C3rof//X/tl1f4g/D+/8GPeW3iCP7Dd2KFG2EuG2YUFFywwevt61/DH/AMFKYtM1 P9pMppV7FeWVvps0jTxQkQKDMFkAz1LMDzzjn3r+mfo9ZdjsBxbiIYqm4+61qrbX/rQ/BvH3HYXE 4TCPDzUrTe3S6PPv2VPDfwi8TfFbwh4W8f30Vlo95rEEcDg7kumfzB5MiZ24bjrnr7Gv7cP2ffAn wU+Gvg/SLnwTqml2un2tjHAkdvCkEcKIigBVXgADA47g19Z9I1ZrOnh8Nhk3Qau7d/6R6nghispw mV1a0p2rtuMvxtq/K235nt3ifXPhf4v0+40LW9ZhubW8gCGGNhul74Hr7cd6/kk/4K4fs9/Cn4Ua qnjX4Zai8t1rl3BBrGiizX7SyTzGEyBlwAVZ4jyM4J+tfnPgFVzbLOLaWFlFxp1FaSs+/X+t0jyP HGtluLyhYmi1KpGotU1s0v6+Z8D/ALIP7ZHxT/ZU+Imm6j4eh07XPDk0sdpqNlIfsN2YgQMmQEAk bQQe5GMDJNf2qfs6/tM+BP2m/hrHqmpXcNhHqmnkXdjPdpPjeoDxH5vvDPH4e1fd/SB4OrPH0+Jc Gm5NWlb+7Zf5fid/gtxHQq5HVyLGS/h6rtZn/9D+pjxV+yJ+yX4j1q51DUjZterN5txJNo9pcsxP +2yb+OOc13Pw4/Z6/Z9+GF02q+EJ9Oa6APlS2WlRxyQFsAkmP5gflH5dK/RcyxOcYvCcmJjJpaK9 3+Z85lbyvBTk8M0m+2h8b/8ABRP9uq//AGcvCk+meHHtdRF7ZbcT3bIMP+6+ZVyVKl8nPA78c1/H p8TfiXqvxY8b6v491pxJc6hEVMIkE0dsoJZthIBC5yVHYGv7A+j5kFTKuGZ5lWTUsTK9unLC8U/V ycvkl8/5S8ZM6jmfEssLF+7RSj83q/0/E8ua4g8y1cSAQSMCtxIuAh9TVqO/umleFkJgGXWZhtyP 4QB3B5P4V+/yj1R+Z4eSUS6JUl0TUNPXdHJd3Ky3JyPMjVAeB1wCay9Pn0ZZYdOlS4kuPNWWO7aR iNy/dCY6Yx1FUk1CxUdKp//R+9v+CLPxw8JaJqd94Z8WalHo2r6VdeZHYzTqZLtJCXEnJG5cP25y D1Ir+k74x+OfB918M/EBg1OxvIr/AEa4COZfJ8s+WSuT6/zxxX7/AOJ/D+arxIq4iNGXJKd0+V2s 3p958Zkuf5VW8P8AC0VWi5xpcrV1e6VmvVPR+eh/AZ+1hqVr/wAL28U6xpTJc2WtazNq13awfNDC mI4U2nP3Ttzzzkmv0f8A+CSnxk8IeFPjBf6d4luZ9JN3Mnk3s0Sx6c52RhUByDwOD15ce9f1H4k5 Picf4ePCYeN5xinZeSP568Kc2wuWcX/WMVK0JNq782j+v/xT8RfC1x4FmubDXInF/p2yAxuDvDRl T0ycc/pX8h/xH/bN179nj9rW68X+EUUaTAoh1jy5MSXpa4dbiZVHBHCDB4wp571/LHhzwhjc7w2Z 5fy8s1CVua696ztfqft3GfFGDyriXLsZzXg5JNrXRv7j+mf9nL9qHwB+0V4Cjvb/AFeKG71PSVjv bWTDLtmQZ3YPGQc8+9cH4i/Yy/ZS8Uazd6nqNnY6tJeXJmvEhsobtHZcAHO0n5RwOvQV8pgKGdZH KVKjCUZpu/8AX5H02aVsmzCqqlacZRdmr69/6Z//0v62fhn+z3+zr8IJi/gbULTS7iW5e6FukEe/ dkE7toBX7oH0A9q+Wv8Agon+3Pc/s+eCZtH8LS/2re6hpSvJHp15/pbiVjEI1AztJB7j9K/Z8kyT H8RcX4TDYiMk5OPNJq+y5nd93brsz4TijPsJkvBmKq4aSvGLUY+r5VZeV7+iP5rvhD+358RPhZ8X 4fio7Xoi1Yfabm0e93jS5ARuUAKAVcFiQwySee9f2G/s3/tMeBP2n/hjZ6nNrkEl1rWkJcahYG4X zGEyYbHOV6kjODhh7V974vcLYjKcdhsdgo3jJWst049fnf715nwPhfn2GxWUTwGMlaSd3fqn/keV eJf2Kv2VvEut6nquoyadHqF/ePPdhdNtmnuZTwWaUplm4613Pwq/Zy+Bvwhu438H3MGmFS0uBbiJ ZXPViV68HoeOK/Kcyx2d4vL/AGOMi3Hpc/QMpo5Lg8d7XCSSeux82/8ABQX9uFv2e/CcNj4c1Szv WuIVSeaKfYi9RiTIIA5x0ya/jH+LvxY1340+Nr/xR4gRlkvTK8s1vcLc2d4HkR4sLsUr5ZVgD33H gDAH9Z/R84eq5dkFTNKys6z0T7Ruvxd/wP5g8Z89pZrxR9SoSvGirXXVys/w0R//0/h34L/FrxF8 DPGVh4p8Jobie3vY72+tml+zG4ijGHCydmwBgcjIr+zH/gn5/wAFCtJ/aN8H6XpHi7Zoet20Atra 1u5drXCfLtY7jnow4981/cP0hOCpY3D0uKMHG84vlnbtfR/LbpofzP4McWRoRnw5ipJQa5oX721X 697s+17v4S/C+18bHxfbXWmW+t3o+1CSMK7kK27IfJPX+lfD3/BQP9uS6+A/gue10PU7adryyy8C S7pZEH7sqAfunLZy3GB6HNfgfBHDmPz3ivCYOrB8vMr6dFq39yP0Lj/PsJlnCWJjh5rmkrJX110/ U/jB+PfxUvvjJ4/l8X6lbyR6n9jFs8huBNDOM7wANqnKkvgkDg15NY3VpLYXEEsW3URMQrEFAygd WPT2r/TXBUlHCwj2R/n01yzqebK9nE0V8gZTJaSn5vnwvA5x6VuSzwEXFtFCvzR7BuGFweCQR39K 0qR6I3pLlTTP/9T8uRFElrHbaYPKMYVXkYbnUr2Ga/ZT/gmJ8IPhJ8VfH2lj4g32k213pQW6CXUE X2lW3KIxhuQSyxtk+gwMjNf6veJ9atheC8XUoJt2S085L/hj/Pfwno0qnG2E9u7RTb18k2f2LfDX TvBngLRotI0XXdMkt0hTbFDNzGq5xuyeOv6V598ePhl8Lvjr4X1jQPEeqWipLpzRsrsk8QOQQ/IO DkdR61/mzkjxuB4hWYUYvnjPmXfSVz+8eMngsxyh4OtJcso212+Fn8Pv7eHwd8O/A340HwZosVld Werx3l9bajYsdscUMiIm/CjOSJOO2Fwa+CWlR9ZWBLsyzKmYFjUhQFwDg45xnvX+p+QVpYzJKGJn vOEZfekz/NfMF7HFVab+zJpfJ2P2g/4JVfBP4F/FzxzJF471rTf7f8PXEbPbalYJLvkkkBAWViMg kRMFGQMcc5x/Zd8OdE8H/D7SLbRtJ1XTjaRRrbW4E6qEVBwABwBx+Qr+FfpG4nHY3iueBlFunS5V HTvFN/mn8z+5fAlYDAcERrKS9pUu5fKTS+elvkf/1f7Hf2kfgh8MP2gvDOo6H4q1yzeyksmjk2TR zR4HzfKecEMAfY+9fwiftzfBjSfgX8a9T8DeGbix1HRbbWJrjz9PYyFoztMKtnJGPmB5I4Ff3b9G HG4qeHxeW10/Z0+SUf8At5ST/JH8ZePmFwtPNsPj6DXPU51L/t2St+DPnGw2yshmdLa5fMcKjjj/ AGjX6A/sG/t0a9+yJ4ntml0681rw610kOpC11I28trCJNvmxoRtYqrcBuDjBIHNfufiXwvLizhvF ZXD43FuP+JbHzPh7xVS4Wzijjp/C2oy/wvc/tR+E/wAaPAH7UvwzsLq3vWkg1zTvLZbqBLeeQsoJ zyRnBU9uvrxXx94p/wCCYH7NvirxNqniDXYtLurm/dhdl7OK4cyZ6hTxnAGSozX+e2U4/N+FpVcJ h4yjJNqXqmf15mmCyvP6tPGV3FxsnG/mez/Aj9jT4M/s7XsuoeAptP06W4JlmMZFs+e3y54464x/ h86/8FFf27rP9nb4a6vpS3Go3j6nE+ko+nQrMZTLEdqksV2gsNpfP8XFepw7k2P4y4zw9KsnzSac na7SW79X+tzzeOM+w3C/BFadJrROMVfdvT7ldv8AA//W/Zj/AII9fG3wr8Q/EHiHxE9/Hpd7r+se Zd2cyBFknUKu2IDG7j5i2OSTnJr9nP2v7zSl+EOvwXV/Z+TfQKFRZh9oYBw3yjPoDyemK/ceKsor 5V4gzwEldwmknbdaP9T82yTM6OP8O4YmLspQba7O3/APg/8A4JWfEHwxeWHjvw8utxRz6Zrt1pq2 t4BFJI6PuJ68gBs/mK95/wCCj/iDw9H8FdRgv9StoI0EgkmW5RkVTbyNvIJ5wQBgZ615NDB4iPGk ouO8n+bO7NsZh3wRRaloor9Cr/wTN8eeE/EXwM0TT9N1aIXOnwmGS1mPkFCCHDKCcEMD19vpXzV/ wWZFnc/BXxLqcE0GovpvhW7ht7OCVZJldzHiQkZIKsBgY7+9fScAYHEYbxawdKpBpqtHdWfxI+U8 XcXh8Z4VSnRmmnTjazuj+GGwsXhSW8vd63t65uLiWRsyc/dzn2xRf+Y26LaPKIBRyMscV/qdH+Gv Q/gB35UvJH//1/x1hnmggfyZpYonTDLkhWx3xTLa/URSxRIAJBsmIQeYffPUfhX+50LpH+Tbk1FI s27ys/kwxmQAfKuOB+Ffof8AsKftyeKP2SfHlhqWblPD9xfRWN9Zo6yQW6qU/fSIR91vnGAc88nm vjPEfhqPFXCmKyf7Uotx9Vt9+qPuvDXiyrwhxNQzZ/Anyy0+y9/uaT01tsf3LfBH49eD/wBqv4XQ 69pWraURqulsj28d0uQjqEcgezZHOenPPFU/g/8As/6H8F9Q1zX9DmtI2vr+XUrhRKu1i4x94+gG Biv8qsbgcy4cqYrIHGSXM09Hquh/oXTrZdmWJpZ1GSb5U1rtdan5if8ABTr/AIKD+F/h1pI+Gclj od1q2ouGv/7QWLVJIrdmeMN5S7uWIJG4fdB98fJH/BMH9in4d+OXsfjBp+t6PJfHWZdZtYI5Ps80 KliREiE7QMPn5ufpwB/QGSUM44O8Iq2MjF8mJ0t9z29NPvsfgmTywOf+NNfMFLSgu+j5bx/Ft/gf /9D+7DQo7bS9Lh0qa8jla1t1VyJldnBAUsDn8c1/HL/wXEt7Vvi5pd1Z3MM1laC8n1S8Fwv7rE0M cMQwefuA/wDAjX9KfR2pzXiDyzWjjI/n76StSNXhzB1IvavH/wBJkfrv/wAEaPFfhvUPhrJpVpe2 8U2lWsdittPcKoZkjXlCDhlb7wr7P/4KP2lrP+zp4lH9oWtrdQWc95EPPVnmK28pwqZyeg6e1eFn eXYmPi5Ohyu8qqS+bP0fiTM8JLw1jjFNOMKUXda/DZn4y/8ABKr/AIKa6NYXVv8ABjxtdpE09w6a FczHKyIXysZJzghf4fQfXH7pftDfAXwf+1R4IWzv9Rj/ALPuIt8Tw3CGB+7AtyOeQf8A9Vd/H3DO P8POPoY6jF62kn0vZdfNfdqeTkGZ4HxF8O6FDFtOMlySXX3b9Oya07o/NTSP+CJvwYtdSjv4b3TT Osn2hra4vRJHK2cgmPHbt/Kv1D+EfwksvgB4MbSre607+xtMtWcxoYoEAjXOOQPTAH+1xXm8Y8c5 xxZShhcTzWTX/APc4a4ZyjhTBSpYTlStrY//0fvj/grD+398KPFlh4o+EK6Fp+qeJbF/IsLfT9PM l5BKD+6eSQfKBkgnnpkjJFfy53lw0t68gRbYTymRoe0e7lh+ea/108B+HsZkHBNGOM3qJSSe9j/L zj7NcNnHGONxuE+Bya9bXDyy0gzs8g8GTp0p13GFC3MTLsUCNlyFYcccfhX7ZY+SvZFJYGlCsm1f 7+RksPavY/gf4a03xN4zsvDGqXdvYQay32f7YxPmKcgbT2AYkc9sGuPMak6GAr1qfxRhJr1SbPWy GjTxWcYXDVX7k6kIv0lJJ/gf3Hf8E+v2MtK+DHhjw14k0/XLHURqNtBfTxW00EafLDGMYUDP3Rk9 SWPtX6s67Y23iLQ73TXktQlzC9o8crrs+YEEA57e3pX+PfHWZ4zNON62PrRfPGbW3Zn+oWFw2Doc Kxy2i1yKNvLVfhv8j//S+g/+Cqn/AATluvhD4h8Y/HTw81tLYahqX9sXI+2JPFaNcsscgaL7wBJT lSedvQZr+eHzZLm8kmW2iiSRtztBzHIfXp7fpX+vng1xDV4n4Hw2IxH8SmlDa2iVlfz0a+R/mLxd lsMl4mxeWQd1Cb+5nvP7N3xi1X9n74oaV8SdKlma7sdTgfyo/m3Rg7JAe4BQkcfjX9+37F37aXgD 9qX4W+H73QL/AE7+1EsUgvLNrsJdRSqu1t6dc8Ht2r8B+lZwdWxKwnE+GjfkvGVuye7+VvuP6e+j vxO54bGcM1paJKcb+a1S+ad/VHz9+1t/wTA8C/tJ+L7LxJqd0BM8ZRoPOEK53s+ehJGWPQjr3ryz 4M/8EivCvwe8ZaX4utNQju7rTblZrRHnjYQbGyNg25JxxliePTANfidHxWzXD8Lrhl39kk1bp2P0 rK+AsrwGeSz6DXtW1K/Xvv5t/cfpH8VPjToH7OPgG413xffxw6VpumOC084SItDHnkg9hg/jX8mH j7/gphpUP7XVj8YNJjtJfDFxdRWl0unP9pkjRJiwlKHplimQfRh1xXt+C3hxiuJMDmOZyi/ZuMor zev5tWR8z4oeJeDyLizLsFSkueE4yk+yk1b8NX6n/9P+yD9nn9pLwP8AtQfDL7f4S1WzuZJdKTzV R9swSVNpJT2OQfQgjqK/Nr49f8EffBXxn+ImoeN7zU0hfUrk3DtDcraSEt98MChIyQM49Ovav3Ph XPM18LuIcVSpXU03Fvr5fLVn5hxzw9lPH/1XF1XFqK5lqre9v81ZHffswf8ABL7S/wBm3xBceJNK uhcXUpBdxqC3czgNuUhQo+nr/OvrD9rH9rbwh+zF8NbiXxg9vGz6b9ljFwzHmRSgBwc55zjtkZ4r mzDF5h4j8aYZVE/aVJJarotf0OvMMwwHA3h7iZNr2dGD0T3crJfifwefto/HLw98fvjDqnjnw7pt tbaVa2i2ENzA5mmu5MguzsQP4t2BgYBA5qX9i74HwftAfFbRPCa3Gl6aTqKvNcapdBXmKJvURR9M 8MckH7nHcj/TLkq8L8AOnU+OhRtp/Mlp+LVz/PHhaKzXiCjfRVat/RN/5H92P7GH7Myfs2eAtO0a 3vLWS0+yiS3ENyJ0UyNvkJY45JJ49/y92/aI+Ett8b/hvrvgme7is/7b0yXS0lLjG2aNlJIzyBu/ Wv8AKnE5zVnxvLPZR97n59uqf/AP9L84wNLHcHLKOZWcOS/yP//U+Vf+Cgf7Guu/sl/EaZdTMN9p +uao2nWLQS+dGqo5y6vuOMAjII559K/P+eMsc2RUKOXQnDKB3HrX+2fAedSz/hXBZnUXvSgr+bXX 57+p/lRmeHjgc3xWCj/y7nKOvkymzFZPLGcsoJdhgZq5AslvIUEoleVdpKEkKPTH4V9qeRtJiTxx z4aHMbxIS7XDCNW25zjP0qkt0SNsRZsdSeQa2h8KEnZWKN/mZVbAI/iz1NRkQS+U4jAMabd2O9UI /9X8NMNHubn8OKiUee5XG1+gBHWv98Um9Ef5HmlbBoyd4zJjZzzmoJJVSbbKuWfgBQdopqEgLMNu 6ETGPAcHbz17U5zGkPywbJy+flHL9ua05IgXFiNxbDzpflVduwnmstLNYlAVyQOGyecUOCYH/9b8 Zre8heCK3eBHEcflR+YBlee34/zrD1CYIZoyhDAbWRhtKV/vulZWR/keY0So+GKbl61aivJJnexg 8t3JXKiPc6ADOB3plwkkrMiuWiKFMfPG2046qayzbzBFm67n2oufmJHXj8qC1JPQkxPtZpDhwMr7 USTzPGGZQUjHz7E+9QUf/9f8KLa4jC7oQfm6ZUimzp5rpcAlZYVKggnBBIyD+Qr/AH4sf5Liw3jZ WOWIDcuGKnv+VW4WjhDMAWZTu/D3oAmkke8t/MjIiR+Ex1P0FG1YIZESUuCvzqflzgZI60GD13H6 dHZtPby3CsYd3+kxN8uB6jBzkVa1l9Pe9H9mtIbdECjzcBs96BH/0Pw6tpfKV4VVW8wfM+Pu49KC m+RQCQE6r03V/vwf5FT3JExuDM3ybsMp4IxUSpFJJKHPy7iV9MelBAzjc5VSiEbCOcNio9sYcqRk dfTFAepPGINuT0zjPauA8emWPSL25jZNkKBPm5UFjgH+debnC/4SsQv7kvyPZyP/AJHOHj/fj+aP /9H+LTW3aW8nWadZonkLeYi4EhzyRWRbpbxzYUncR98LyK/V+LV/xkWO/wCvk/8A0pnyeUPlyzDx /uR/JF2/l81PLQEgADdjrWLAJ2mEMMW6OFgZNxxn159a+ZSb2PUP6Ef+CLX/AAT0P7Y/xDs/F93q 2ixaH4Qv1ez0e71tUuZLhZdjSSwBSduFcBT1JGDwcf6XX7OHwsl+DXgDSPBl5PuNrEgwJBNbIFRV HltjkHGfx6Cvg8yq/XM35VHSk7f5/j+B+pYBQwPCSot+/W977rWX3W363P5N/wDg6F1fztB8E6b5 rzx3PiXUH8veA6hILbaF9N2WxUn/AAavahYv4K8XQtd2EV6niCWOK0e5VbkMRGA7LnoSjKPU5r67 jZf8Y5l6W65fyR8VwFWlUzDH/wDb6/Fn/9L+u/8A4KWy/ZP2PvjMJpRAkngTVogyjeWL2cvITqcD JPpX8z3/AAQp/wCCs3w28F3t7+zP8VtWj0u6l8UTJ4V1m+YW+nmKchvKd2PylGByTnAkzwA23rxe EnW4ehiKe8J6/ge3llW+b1MG/tx0+Vz+kD9vr9kqH9tn4Mz+BLTWrWy0/W4opLbULa5E1sWXcyMx 7r85BHoe3Wv5rbT/AINfL2HVfO1DxZpdzp4vhfPaW95HBNcyBs5DMhCj2J79a2eaThlccFD8u5lR yynHGVa1Ve89O1rafof0f/sx/s1eF/2PPhDb+G7rRvDr2/h7TIIGaOwhlkWOKFI2y6KoYkouTjr9 cV/JB/wcKftt/sz/ABV0aX4b/C/w7pOq/ESw1u2gW9tLYeXbeWzLdJIRjOw9VK4DLkkFc138LYR3 rYio9Ixe/d7HkcWTq1qNOlR1tKPySev4C/8ABsZp1/L8T9XvJLK3s7ZbtJNQ8ib51YLJNGNuTkHb x74r+8j4haMvivwTrPh2aeKA6xZCBppsBVLLgn9c187h58vENafRNH1mdwb4dwke8D//0/0/k/4I J2w+PzfGqHVbfVBbeKF8R2Zj1GEyI/m+Y/mK4y/ocAE84xX7tat8VPDv7KHwltb7xnN5XhvwjpcU M1/NL9ntYEiRI2kdsHABx7c+nNd2MdTN86p1Ix1laJ9DRqUcBkjwcHpv38vxufw5/tvf8FgPAOp/ 8FDPA/xm8Fwx6n4Z8A3UGn6k1s/mRalEl/NK+H5XgS4GTjsSOo/to/Y0/bQ+E37Zvwgsdb+HOtaf dztoMdte2vm+XdwebEAVaI4KupDAj1QjqDXocQYCOFzWEIO/LFJvzW5xZMq+LyzEJbQk3brZ3PxO /bN/4IGwftPfGfxX8SpPFenW3/CRXrXD29y2JdxUfMMDjO3kYOSST6Dpf2Ff+CH0v7H/AMSrX4hf 27a6hdwyoPPtZlzCsUiSABNuf4AOMZ5z2x4+aYivjYumn7j6HTkdKjlU1Uik7H6hftq/t6fDv9kP 4Wa3cfEXU7a0kvLGWx0lrkNEk8kaoSm4KQSA6naOTyegNfxYfsL/APBWb4YfDr/goB8UfG/xAtNE Twb8XPFs2pzTNpwuRYvPcloJPPb5wu1vnGdpLMSPT1qeW1Y8OSqrSU7WXWy10OSGYwp8QpTfuq93 5u6P/9T+vfx54F+Cf7cf7O7rpGleFNb0Pxf4eYafdRYcW/mQlFf5QCChORnkFcGv5ptb/wCDZNtQ 8Q3GtaP4+0rTZDdtPF5a58hd3yoVGOQONy49gK1oVnSoJPdHtTwqhmDqVN1sfuD+wD+xF4z/AGNv Dtz4fufGdx4ighUNbQRzGWyjbGG2gn5QcAEew9AB8Ff8Ftv+Ci37Lvg74VeKfg/40t9N13x/daBd WMWipayy3jzS22INowo5eTht3VTjlTXq5DTliszVVaRim2/Jf1sZ5/ioVZWa3SVvuP8AOB8QT6a+ ozSfZ104yTvO0fDyosjFwDjrwR+Vf0F/8EZP+CZl/wDtR+LtG8eTa5ottonhe9i1iCzfVVh1i7um kRkUwhGxGFQje2Oc455E59XVHDTaXxe6vnf9Dl4dourj01/y7XP/AOAn+kN8DvA998O/Amg+E7y5 jup9F0+OCSVGD5ZFCghuNw+Xr7V+FH/BcD/gm7rX7WXw+/4WB4b161h8Q+FbC9eHSLpspdFz5oUe hLIAGJwOQeDkeZw5iVl8OaS/u/19x08Tw+v1PaT7834H/9X+RP4g+GtW8JeKvEPh3VrJtN1Pw9q8 2hahEUK4lt22OQG568exyO1cSovDPazRFTcWd3Fe24Vtis0Tqy7/AG4/z1r6Co+ZNrqiaDSasf3+ /wDBAn/grp4L8U+DNG/Zy+LGp2WkeN9Nmj07S59VcwRX0RjSJFjkxgkBOD0ZVyOhr96v20P2Qov2 qdO8MTwXNk0Ok6vDqaL9o8yG4CIygjseHb/PI+cy6P1CtUw/VX/Ff8E+yxbdeWGxj2dvlyvb8Dt/ FfjT4c/stfBWa9+Ilp4f0vw/4X0GNdTmltoollRI1iaSRgvTgfw455xmv4Of2l/+Cp3wt0n/AIKH aB8fvgbpkVjoWgW1no2vtb2e1dYWO9llmcowG3crRICxUnyhkjNdkcBKtgaze7el/v8A0OGpmy/t WM73tfbzukf3hfsdfthfDP8AbY+C2jeLPAeu6devdaXHb31jHcKl7alowrCSH7wIIIwecg9xivxd /a+/4IA6B+0f8W/EvxPHj6HSb7XtSkvJneMSTF2JIyoGO5yev8hzYHG1KeXTpwTUpabbW6NEY/A0 62MvUs0tV8+zP//W/Z79iL/givZfscePrDx3YeKLfWbiCSOSaS0AtIyVdWYuCCTnaABx1OSeMfcX 7cX/AAUT+Gn7HPw6urf4h6lbW+s3+nyR2lst0DPIquEUjaGAYjkBsE4zjANPKsHUxWOhF6tvV+n/ AAD286zCOHy9RSty6L1bP5Ef2NP2Zpv+Ckn7WHxE+N8+u6F4d0e58aTeIrS0u7/ztUZ55le3IjVS NpXexYsOUIUEkY/vX+BPw8b4V+AfD3hF7iK4h0uyS2S58wMrlFABz6Hr+NGcVI1M2nQhqoNfiduC xEqWS/VHtL3vyR+Qn/Baj9gK5/as+E17qOn6hYRajp0VxMlq7lpXdjuVtvTqQOo6DpnI/wA1n4je BL34beLPEPhDxB5w13w5qU2j6gg5jiaBzGi/XA+vXNevCs6uGVO3wq35HySahWlBvfU8ymt55YDO Y8R7yq4cA8deKhtWBmRZCMqwATO0yD0zWVvcNb2P/9f5R/4Ip/8ABNXQv2j/ABJD8XPEPiTQvtHh /U4pNK0Wzv0ZwqkGFpR94AsGGfukxt7Ef6Gvwo8LxfD7wV4f8LPcQBdG02KyZ1ZTHIYkC9vxryat T22Mu18Lt/X3XPq8DiXHK5YO+75vnsfg/wD8FtP+Cckn7UXw+l+Iuh6xbQa94Y0+4uYNKnwyX6AS TNGpLAZJOFycZz6gj/PQ0zxb4m+BnxeOr2iP/aHgzxAhVUh3RXX2d8NEqdCpBYfjmvpMRfFZe01o lyfh/wAOeDTn9Sx3tIbr3vne5/o/f8EdP+CqPgb9sH4P6J4NvmsNF8ceGLGKwube/uVie+aNEXfG AAPm5bHtjruVeo/4KEf8EovCf7bfi/Qtb1zxJDpD2tsyeaql5HjcliqNz0JBHYZPXIx4WTueDpzo W1S5f+Cexj74mpCvPaXvHxb8Ev8Ag3j+Hfwd8e6R400vxNZXl3peoC+FzNIUvJgOqOpQqwPPTB56 9CP2U+OHxh+Hv7InwQvte8a29g2geHtISO4L28LM52hDI2BnDNjtj5xnqaVPAVMRi05t32M8TjKe HwbpxVran//Q+IPjD/wVd+H/APw3jofx08BeDIbDwjol1Faa3aW1jEH1eLzJBI8pYYRnV0AyAV28 nPT+6n9jT9pv4H/tvfAHRNd8IHw/dx6lpIttY0O/iT7TBKYwJI2UgEEHcO2eeM5FcuY4GNPMadZa xSt9x9RgcU62AlQ6x19fT0Pyl/aS/wCDf34M/Gn4k+IvG+lazYeGBrF49/FpunhY7e3kd2LjGCR1 6Aj2x0r6e/Yn/wCCVWm/sbX/ANu8L+MnvoQhkkRLryhK7EZTaQN2MDDE5GO/btxNSNaCTXb8BYTG qhXqVIr4lY6z/gpL/wAFE/hd+yd8LLrSPiTa2uqXeq2EsMFsxRnvpURl8qPBOfvKScYGcnjNf5mf 7SfxQ0v4qfF3xp470Pw/YeGdD8SavNqmkaTZRCOSzSeZ5dvAGAN4AGBwBXTDDLD4ZSl8UtfkfLTr wrVpTXRtf5niMcpkAYk8LubnJ+laMHiQpZ/Y7xBKIQRBGBygJ9ai2lyj/9H+QMeXO4kQvHlDwehJ 71TtpLvTbyG7juGeWGYPBGrbFlZfmAbjjkDntWtT4GZxlaZ/b1/wQZ/4K++FtA0Hw1+zT8W7ltP1 e4uRY2Wsagxe1n8wL5Q3KvBHzEsTjk8dSP6Y/wBrf9k7wX+2t8MJvCOseI4rGx1KSO9sNRtIxcBS ittAG4dQwzkHjOMHBHjZfD+zsS4QVt7fP/K/3n22PxUMfh6GKbu7JS23Xktr2fy9T8Urz9j3Rf8A glJrtr8X/B+vxa/4ejmSDWPOvIrSSPcy7pHiGCxA+Vee+MjIr94fgb+0B8P/ANsX4PQal4W17T/7 P1bTZNM1WGVszwO0JRyCTyPnB9R0ODXdCP75pnj153p2P4av+C2f/BP2X9mbx2/xe8IeILS/0nxH r01rd6W8yyOsjhpYUiQcsrBWJycjr0r6y/4No/G3h218Sa3Frl/pttq01xdXFzaMR58LyyoqBB2U /Nz7Gqrwu9CMPNJH/9L+039pzxDpOkfBjxtfT32nm3Hh25kiae5QB/8ARpCmOfXbz2r/ADOfhH4p 03T/APgoRZzalq1lbraeMJvM2TqyvFJN+8jTsG2yOdvWs+VqDR6bqJTVmf6c3wN1zQb34U+G7vR9 W0+8sE0uIQLHcA+QhjBwee1fxzf8Fgf2yJv2cv8AgoF8PvHXg68inXw7FbXmo2kOCt9ieVJ1Zhnc GgYDGeOTkcEZxi9jSVQ/pv8A2F/23Ph3+2x8GdG1/RLqTS7y5sxbX2n3MRj2yRLGXXeeMguuMcEH tzXxL+0r/wAEb/hB8WfiHrvxhfxPHaeIpLuTUoLd1jW2Mi/dyQSQeOWBznp2A25bRsc7qXkVP2Qf 2z9P+BPxgm/ZK+Jeo2sd3BJ5GhXi3q3lrcBiPJwR93OeAf6GvcP+Cn/7GHgL9r/4H6n/AGl4ui06 9tojq+jXkN1GEgnCnkgnBVlOwqcfe9QDU4aLjb5mWMnzN/10P//T/my+PvwkT4TePvE/gKfV7TU5 dG1W5hS7hk3pcCKRoyp/2sqePpXzJBGyXOyZIwfM/dgc4GeKdZ3XKyrJQSNqRPmAZvLdT0Xg8VYi ucsUbDRYwUYdfeuOmnY7KVr6m74ejtJfEHhm2kk+xW51qA3F12t035Zhzxxx+Nf6bf8AwRe8deA9 V/ZV8AWen+ItOu57WxmiuCk6Ll0lfG4ZwGClcjtxWGLg5Yim10v+R6OFnGFCpF9bfmjzb/gtP8Qf DGleB/BTz69pZaDxjbpFZpco1wVeOQF9uedu0cDPSv0z/Ys8X+C9b+APgrVdA8RWWoQDQ4Lvesi2 6Qq8av5YUn+Etgj1FVKLsZwlFXR//9T9ff26/iV4Si/b3+CmmTa7pO8SG+WRJ4zHFM9yVHmc4GWh Xk/hX9CeieKvDD+AYr6LXNM+zPom9WF0mxP3eccnt+vbPGfKjGXtLs92U48jR/nOf8FrtePiP9tf xLpun3FuumBsWhtLhLmOQSMEEknOMjGcHsBX75f8EZv2DPgLo3gjwl8VLLxrDrfjKe2i1TULy+mh EsTOu7yIdpyqqQO5zk9PlqsWnJpv+tTDC8kE7f1of1AafqGkWVnFpB1SwgG3ykY3KEBV6EjNfyj/ APBd/wDYI8A+IPDusfHfw74r0u21/TLk6xqFq80fmXscjFWiAU87QS209iR6UUny3RU7brufyMfs 4fH3xp+zP8WNA+KXhK5tXm8M6p59zaRsYJr21J2yxl/TGCFPGVr/AEh/+Ce37fvw+/bJ+DWhvPqc mlawlhHaaja6nClo8cojVmUuWwysGQqw67vXivPUJfXOfpY71KLw3Kf/1f6VPjB/wTU/Zm+LPxPl 8f8AiS80m98RXd2LqySeaJysiEHG0OM5Cjjr8tfoz8Gfhnonwr8J2Hh/w48J06yg8qFLfAhjxgBQ o4AAAGB6V41Tm57nvxatY/nR/wCDizxA1j8LbGymSWaOSK6jETKCWecxJG6j0Voyw9K/Cj/gjj+y /wDs9fHf4pfaPijrY/4STQIrPULfR5YI7OMBnLMWZu6sqrjqS5IPFdFZydGKh2Mqfu1JN9z++/4U aH4J+GOgWHh/SdW0q30SytxbwMNQiaNVA+XB3V8af8FEv2Xvgx+1N8JdasvE3iXTra6trWRrC9hu 7acxTAAh3GckLsAC5H3jz0rLBxcZwLxUlLmt3P8ANj/aY+F8XwV+NPjL4baLr2la9oGk6tI1hqNj OboxxKFDQA44xIXHU4weTxjwiz1oadqKMzbYMYlOM1OIu6raNKVS9NJn/9bzH/giz/wVD8U/ATxz 4c+CPjS5tW8Calqoi0vUkmQ3U4k3ELMsjhQeETgcFFxndkf2r/FLwH8F/wBrb4cWNj4h8RQTaTqy C6njN9BA65XoVLYyPqev0NeFl8XDmttc+mx01JR7n44/G/8AZY+Cn7C9lc/Gf4I+LNIhv9Jci80u 91COT7dGWHmRwvEQQ/yhtucHYM9K/UL9jP8AbK+G37VnwpsLi81ix06+sLZbC/tnvIikzR/K5VyT uxgDOB+ByKXw4hv0HzXoxXqfzBf8F1v2Gvhx4W8QR/GX4ceKrSWXVLiaHXNBuLhbiTVXk/eIYdoA XAjfPOOh57fyn2eo2ui60I/szeVa3DSxz78ZZTjacHPHr7V6deV43PPhpV1P6af+CK//AAVivPhP 4gs/gb8VTdN4dvdQMOia8HSRB5+4xCQO4xgoqkrkfMMjrX9hnxF8HfA/9o7wjomo654isp0jkS+s 1uL+GD5yq4Xr1HYZ/DgV5OGvGo09j0MTJSpqx//X/qn/AGjf2lPCP7Hfweu/E0fiXw61j4asY7SP SpdURt6qpBPlp1bCk7QP4ecCv4Xf2pf+CqnxA+NH7SGhfF3w3pVrpFr4d1D7N4dtEj8nUL1VleQz OVIYqScjle/OTx4VZ2p39PzPo6Ws1Y/s7/4Jn/8ABSX4efte/BbQ7PxLr1tpPiTTrRNN1ewvLuDF vJCgjdd+c7SUJG4Z+YcVf+N3/BN39jv43eNL3xv4tvrHVr3ULr7S0Dazayov+6DyB6en4UsA37BX 6BjLe2bRtfBP/gn/APspfALxWnjL4dXGjadeQxeRGl/d2slvEevysuCcnB98DOcCvnL/AIKZf8FM /CP7HXga80KLU9M8W63q2gtHp2nafKsqrLvKRhuCdpwRgbc7WwcZI2OCaS1P4CPjr8Ztc+NvjjUf iB4htYrTU9VleaWGzXyvJRpGdAU4HCkA8DJzxXk8lvpF9ZSajBPIt1YqFeNnLLI7HqB04H5U79DM /9D+VNpJJJQu9nkBJOwYU47kfnSOS8EsO4gvxJ64rxJR0bR6CV9DpLW2kntjJYXKCa2i4jlfBmPT Aq7aSRJL/pS2806oA6MAcg9Tjr2rmq3srdzto7teR+y//BKD/gor45/ZF+Knh7w1fX9rcfD7X9W+ yzpNdtE9kpw3lqXbYDhRgHg7eozx/oM/Cf8AaD+HfxR8FWXi/T/FegsuqWgu4sahC8SArnPDHp04 zXIp1I1uS3uON7+ae36ndLllS5+b3k7W8rPX9D8Bf+Crv/BXS2/Z8ttf+GvhTXbPUtfv7aWy0+20 MRajKHmjdQSmVbAK4JOR83GeQP4evH/xB1bxv4i1fxj4pN/e67rt8b25klkRoIWPA2qpwMKFXpwF AHAr1aEuWlyo82om6nMz/9H+bj4aSW1x458PW2rQRNoEt8ZdQmkkSN4VWNygi3ELuZtoGeK/vl/4 Jcfsx/sp+Gfht4K+IvgLxMW1G/0G2kN3qF1Zw3EpCo0gdkVVQl92VXp3zgV+cZyq8sZSha9N797/ AOX6/j9zlMqcaFSd/wB4vy1/E/c9vGfgxbU6Vc+INPaFYhDJJHfQ+SykYIDZwSBX8dX/AAXQ/Yq+ BOiNqPxt8L/ETSNH1W6ulLQz3cC3GoylXkaOHAAZisTkjHABOcV9hk9b2WCdPyR89mMXOvddz8yv +CQ/wY/Z++KXxeSH456zapeefDPoWmme2mtJF8xvLeRXBKtlDgAc7/YV/fj8HvD/AMJ/g/4dsdI8 I+INGj0qO1jwTfQpKF2hVBVcDsOmBXzdVf8AClBvoe1Cdsuklv8A8MeJftp/B34L/tOfB/xH4R8S eK7KzuRDI9pdwXUcnlnaPlkT+JSVX5cjqcGv84v9rf4baL8GvjL4k+Gena6datdD1SRLbUbaQXVt Hb7mRF3D0CDjPXivp6lXmwnKfPxTVa5//9L+Wq+P2eeWRtr5OUfgsPQiksdRiiEyySlmni8tUYcQ 853ge44696+cpStE92e6P1i/4Jef8FDfEf7FnxM06Jo7d/AOr3AGrSafADd2xLD7jswVWbav3jjj Ff6CPhX4i/B/9r/4QWd3J4ssp/DvivTYp3f+0reIl/orH5u57g+4r5TKIzw+d4hpe7J3+e34/ofQ YuUauWUkn70dPkU7X/hB/wBm3wTrEvh3xN4chsNH06aSM3F+gaQxISGkIb5tqrkZIHGK/i//AOCk v/BU/W/j/wDEWLw94WtQLfwFrtzFb6obWOzF0EkVfM80MWJDQqyhduM+p4+oxEubD1l5M8/DNwr0 35o/eL/gjn/wVL8P/Gv4eQfC74lX9vouvaOsdna3ElyrxtHFGokMpdg6EHAC4OQ2QTzj9Bv2mP2L f2Zf2mdS/wCEk8c6pZz3S25+wzW9/CDKzKOGPUr8inHtXl8L1pUsLUhNW+I9nOFCeJjOLvs/mf/T /WLwb8avAn/BO34teGfhtb+L9B1zwfqsn2K30y1vAbyyglmkOZNzbQS6sF5xwvbIH6oftOeBvhD+ 1l8AtSs5fGtrbQanpLXlvO01sxtxJDlAyE54zkc9+PWvjMol7HHSa2bv+CP0TMZ+1oLX+kfxE+Gv jV4o/wCCaP7ZOs2HhnxJp3ijTW1T7NeDR5V1CG8s458KzbTtjlVlIIzk8A44I/uG+B37Svwm/bG+ Bum60niTT0s/EvhtIdQt57iCNEcqFlG4HggjJ3YOCOlc9OTjxFVqdzSc08phA/Nv43f8EzP2bfDF xe/GPwZ42sLTxRpd0dZe6bUbd7WaSM+YcFCdpGwfMBxjtX0B+wP+3X4F+I1/ffA3XfEEEOq+Grs2 en3waP7LqkaqVBBLZyNg+UZ4YH1rXMZ82axmuxhgmvqMoM+Bv+C2/wCxT8NvHfhjV/izofjmxj8R 2CtqGJbyD96dpYQKwOVGUK+uHx0xX8Pl6rQas1jbPbLcW2uGwvXmKiFgJCjYPfqMY719fjsQqmCp PqkfO4eHJiJrzP/U9b/4Iz/sb/s7eJ9Mh+Iur+LL+/8AiFp1wZJYr57aKDTQ2CnlDBYoU6Nu4MrD qor+u7wxP4S8I6NaeHT4gsEsoYAkEjajCQgC4x97jjtX5zhlL+0nOXf/ADP0TFOKwSjE/nj/AOC0 f7FPwx+Lnhab4qaB4m0+z1rTR58vn6lFaI0S7vOVTyvIy3OMbzk4xX8PHirS00SS+0Zp4ry7srp7 Ka5tZBc2rFGILLJjB6AccZzX0uOqc0Ivsj5mnF80jyLJ0l7ggea03qctg+vtVnStSuIfMLJEYzyw ddzYzyAP615qmmE4s2JYbS6SC+eKOwhuZfLDuAGYDsAcEnkcGubvIIUDRuZX3v8Aup8ZaEcjOOx5 rOpJJ3JjHTU//9X+TfU0jhZLWHVBczlAzR4Il24/iBx/kVdt7eISxTWahBLAsdwCgjcFRg5x15Ge fU+tfCqcXsz6BR0skW2SWMnEfnIT84J2gge9ZaFtSkCyKqx28uYt3zEkf3fzp3Xcai1sjXltxbBH kKh1XgA/MAf8moQ1uoVWlBmI3bVOVUdiTS5olwi07sspO8asRGs/mjaoPC59fwzXPXW9LyXydjXV tiPEuQrkkHap/r04ppp7F6H/1v5YNNtZZI/OvpIkliiMypvGzp91ffms6eeONpJ47i6ILBFt3jHl LzywwM/nXwzWlj6dtJak9qjzu08WVAwpZl2bvpWhNEqRpJgI7nyy2P8AWEDj9AaxSsw5ktTLMrlj bPIJJMk+YmQqj0I9qhvJk+xwxwW8NyiTEXkc6lDcL02n8R7V0pXNlOMtC6be4hsrWe4VYUuUMtqU k3BlB28j2PHPpUVisFpDMxVJrp1DTzqgikugCAFJHTj+RocWtyI27H//1/5ZbC7t0jeWO2EMhk+e CPlfqPXj+VJq1nFLKZZ0CNEomWLbtMZxxxXw59go83QrWF1cSyC1DOLcqcqWwpbjGB36VuQWlxaS H7RG8a4DhCNuQcEH8Rz+NXKV4idB81kWrkJeWjxltxaT92ACCFAPy57YPpWDp4utPluppkgktNgg VpovN8ksQAQex469qiUnGNrFvC8rTT/A9G8C6l5vi60tVSWZTpszvDHD0cbQj564BOcegr9HPh9b Wa6XZi780NBE0+p25wPOBzgeylSoOOhFf1t9HKjGrhcXNytqlt2Vz+fPGGXJmOFoy0uv/bj/0P1w /wCCPWippvw6066/s9bO/vpnmli3NK9tECmxc+hWNOfavr3/AIKTaglp8HdRFixQSNsZ1wqMqjfI PbdjbX3sqlOp4uSoXuliLX2+1b8zHF4eVLgCLl/z6v8Ah/kfxMfEK90e1lN3bhZPtcrme2Y+YvmM Ducn6g8ew+tfkH+0PqEOn6vLc6ZBGDNpX2W9u5ipLgyMcIDnGATyMEZr+pfFqdOhwJXnF62j+LR+ D8AYOiuIY1MPK9r3Pg69USyrtKx+axYBT0/zmtC1k+yRKqF2IOHbrn6Cv4dnOV+Y/oWV07Ox3mm6 rLapC9u0gIXFwyx4Kg5BGfetG1kuLGW7vJI7ee1vovLiidAVBzkn25xzXm15y5mGttD/0f4s57ZL hmMIWKZothBHLjuPXFd5p1hYzWdvZ29zCmp3MYgitkAVLcjChmBPI+lfNzlK7ud0L21PafDE2paR FLogih/s1YxKGWMeYzHgvvxnsMDOOtdQ0MN/bWsN4biN9NuTMbqH5ftEeDhZPXH17+1edUmr2saS tfQ24dWlurBbayeZYHJR3I2sg/vDPrgVraVLDeLc6ffXn7y2GUnaIp5p/hUEDHIPX2rnlVSVmjak o21DVdF8Q6dbpe6Hd2qzzMGjhucgBAeSMDPTvVPS9Z1C/wBPgmvrJ7GaN3huYpYmhkldTy2G528c cYwPxrFTh7J8qHSi5Tal8J//0v44vsptvPvp5pcwr5rbBuYnGCSfTrxUTXkd4B5Vs2AykXTqVT5u Du7gD0rxILlTbFRNvUJbmGKTTV0E4ktfn8RW10FEeBu+WPkPxgZHr7VmXGt3KaRbaTJp6M10ph/t Jyy7gCMZGduTzntXK4vm0NZX5tCvYWs6PHMDHZShPKlaH5yAvG7PqRz9a9H003PkR2cc8tyRL5xy 2VlAB+ZvcDvTUO4Juzub0IWRbuCW4Ns3kFlKp5jFwMqoHoemawvLW6tb22vZDFetEf7LUMB5z5AI PpwSc/T8dIxu9DM//9P+QbTrRdMlRrlEukj+aaFiUec9CGbtXm91dR2sl0sttNbC5uXZIGcSIiBu CG/EGvMpK0rg29zg9XvI0ugioVj+9GGHys3dq9c+HH2a31HTb28ma3njkjjlkU7UdHdRxnsMj8q9 /K245hQa/mX5o5cbaWDqRe1mfql4eihXT7ezmBnEWy7S9hkO+UGNdu0jseuQe9f1xf8ABEC9ht/C y6DaRRNHcPbyySvdfbpvMwzyyhu2GRo8Dnt1r+z/ABcpup4Zxa7RPxfwO/5L3Fx7KXX9D9sf2urY X/wi8TXccktt/Z+gTxxSROUmhlCl4yPckDmv4IPi9BBYePvFFzaTzw6jYeJ5RPLcBWu7plCgmT64 HPpivhfosztWxtJdvnujh+kXTUc3o1ur0P/U/GbWL131KCRXYXNxcma5Y/dcMfugfnz71t3t9Z28 Ed1PG6BPkmS34Kk/KOffjNf67xWh/m/Tk1FmTf3EMtr9odLrZYwtKnlKDFIW4CsfXIH50ti1heWt ubjqZEaeMyBGtFfG92bn7oycc8rTN4SfKzXh1DS4mZ7RZ57W0ult/tBQ7pnz+6bgYGcA/h7V9afC v/goB8d/2bNPfSPh7r9lZaTd6m2p3dre6XFNPNcTiNJMyFSxH7tGwTjrjGa8LiDIsFxDgZZdjleE vvXp/wAMfV8N8RZhw7Uli8DKzas09mvP03X6q6f1dqP/AAWR/a5ks4ra/k8MwNq8Rs/7YfTFa3nT H33RV+VRjHyjPr3r4S+Lnx68c/tH+JbnU/iYNCm1KKATWGp6XALKCM7I42HTcTtiQg5ycGvz/JfC 3IOFsT/aWXp+1Wzslo9Nerevf5H0ufcdZpxU6VPH7Rae99e/47H/1fjD4Cfth/GT9ncw6b8PvHV7 YxQ3ct/qj6lbxanDOCEEaLG8bOyjbyd38XGMV6H8Q/8Agph+1J8atIjtPEXjnRrK3lvvspGn6RGL Z4I2I8xwytksOOAOCfXj/STGeGeQY/Oln9en++TT6Wute19fJn8bS41zb+xXkUql6DXL1vba3b8N j5Y8OeNfFvge6stf8HeIrjw94r0tzLp13aE26kOcneoG3aQxwMYzzivvLw1/wVQ/bV0vRhpp+INg 12YhAjSaTYyRXEUUeT5krw/KzEYyq7ueta534fZLxKo1cyp3nHqtHZdHv/n52OLKuMc2yKksPgJ2 h2eyfkaesf8ABXb9snU7eCCPxmulGezRwlvaWl/c28se3fGWkh27ScnvgEDJ6nl9Q/4Ki/tc6yr6 VqvjbRNTs7iHGZdFht9WDshVl3qnkrnPJ2HgcGvCw/gvwpRl7SEZX9V/8iepivErPsXT9nUmkvK/ +Z8LeJ/iDrXinxTB4lOohtQjbbquq27eS0pWMBsfKpJzkFh1/CvpX4af8FEf2ofBa/8ACO+FPiRd 6d4XS2OmW+lyyrdxQwoCE2qyZVuW+63PQk19RmPA2VZxgaeXYyN6VNWS/LV9vuPDwvFuYZdUlUw0 mnPf8T//1vivx5+0z8V/izrsXiPxt4zl8Q2trLHDJefZk0i60URZ2mFoRkYIDZOSSSe9epWH/BSf 9qLw5HJ4Z8O/GDxvbeHDZfZDcXckGuQ3GBwEM8JkXJLZIIPGOnNf6UV/DLh3FYSlga1FOlT2Xd+b /H12sfxNhePM7wU6s6FRqVTfy/rbfy1PDNT/AGjPjzrPie08YXfjb7RqFofMto1hNmWJUgFnQ5yd xJyMEk8V9IJ/wUc/bGttOj028+JTadoa6ILeaxVkuYJmA2AsHhYrnOdykdOlZY7wu4cx9KnQq07Q hslb1u7plYPjzO8DGpGlU0nvv+FrdNPRnz1pX7RXxm0jxNpPibw78QtV0m9t7hrxW08Jcs7yZ835 2C7lJLEK64GeAMV7/qf/AAUV/bMtrmCO2+M2u2tqYgoU+Uks5UcYIQfMfTI/rWmM8L+Hcw5JYilf kVlr+f8AwLDw/Hue4Si6FKr7r/DpoVov+Ckv7asRi/4vHrgeCcieN1jiLKOm47Duz75PvXB+Ov20 vj38VtNvNM+I3jjxT4kt/LSRxNLb3dla7ZM5COCdvQc9MmssN4RcK4bEwxlGlacXdK91v9/4ozxX Hue4nCzwFapelLR7/wBf1of/1/y21SOe7nt9Str4GGaJknR33q4zuAAzxWReXUVkltdX0IsUuFEc UEEby8DgMQM9cZ/Gv9a6dFxSin0/zP8APVVFybdTqPAHi3xl4L1ibXfC3ijWvDt411HdWUtjPsii CAqAFYFec5PGenpX0rqv7ef7ZVnpq2snxk1660tomtZIpZDJFMhXbgpj5eD/AAkEeteRmfB+R53V WIzOhGc111X5Nf15HbguKc4yqlLDYGs4wlutH+adj5i1j4jeKPFd1LqniK/gvri4izhYzEIm/wBn LE4OAcViNqcsUFrcPBPGZXKtIyECNf72a9Wll9PB04YWhpCKsl6HLRxtSbnUqaye56B8P/jD8Xvg /wCIYNZ+GfjTV/DUDW+1be2mzaSyNs+coB02r2Oeevp9KT/ty/tUX2n6gurfG3xW17qEQtUe0vWT yIz1+YnI4JGAfTn0+bzbgDIM6xKxuPoqVRbva68/+BZ/gexheNs8wNH6rQq+5svLfb/g3P/Q+ZbL 9tr9qmwmii0741+NUitoVtonu7vekwA+Y4zg/VhnPU1wPi79o/42/FCK50zxd8TNc1ayjZmla8lR HMbDbIsa/dUuCylhzhiK/wBP8H4bcL4PHQzDDYdRlHZXdr99X8rbeR/BeN4yzvH4GWW4urzUpb3S +70/E8ZlllQyLaAWoQEv5ChfMyMcnvx+dcoYXispkLRtcnIikf5FY54J9K/QacGoa7ny0X7yQkcV 8kVv53kRmQnebeQP5rA/eJBNTXmppbAEwM1wuFiCkuZCOCSKC09G2b9rq8NxYm0mgt97yCZZlU+c i7cMh5xgnnp2+tWrHVZYXe0SNr6ARkrb/Z1uBboB1wRwATnPak9mRzXkmf/R/LhFs724ItptQtJI m23D2969qIyMEFAMYPvXtejftLfHXwmP7G8PfGj4g6XpEEX2eHTX1qW8sgMYYbHbAx244r/WbMsj y7O6ao5lRVSK2TW3mnutuh/nzgs4x+Vp/UqsoOW9na9ujWz+ZtQftUftDXVhZi6+N/xCSNbp4D5P iSWzkuGA+XyyjAjgjrmvP/EfxN+K3ibUrK38WeOvGOtKEa6uTrviSfUrUnB8vCOc5+cnJ5P5V52F 4QyHLKir4TCwU1s7Xa9G7tfIrF8QZnj4+zxNaTX9dFocno2q+L9A1CbXPD3ifUtF8RPE1pBrFjtW aOMtnbtxg9sk8+9ezp+018f7XQdP0LVPjF49VrZm+2f2d4qvYLUoclCIg3B5A4OODx6a4zhvK83q KvjqSnJaJvyb/wAyYcQZllsfq+DrSjB2ul3a/wAv61ZzGt/tEfEfxfoVx4b17xn4j16wjDJBNq+q z394gLYOC5ONwyCQc4NcSmu3GmwWt3aS3ttd6eVl0y406Zob+3fK58sqc/wqe/3faujD8PZfg4PD YWmo053bS27W9PLZHPHPcapyxXO/arltLro7p376bn//0vkTS/2sfjppy/ZofiR42vLWZNkelXGt ObWFgMKxXABA/ugDp3xXk3ivxnq/jPUI9d1jUp7u+tbJrIb7xrpW3OZG69MuzHA45r/VrBcI5PlW K+u4Glyz20v107s/zvx3EuZ5nTWHx1TmV762v/X9bHFx6reWxiFypibzluYZrJ2guV2OGQiQHKsC BgjFeu6R+0r8bdEZLXSPiV420LTGZvtFlFrs88NxuGCAznI/XHYV6GPyHL85h7LMaSnFbXW3o915 2Yln2Pyt8uCquF0r2e/a667u1zsLH9pn9oe7kgutG+K/iwnS4285bnWHkaQD7hVuvGRwc9K4nxz8 ZviN8Q0s18aeKNY12eyjMc76jetfC5+feMbxlQG5wDg15+B4I4fyrERxmCwyhUi903+rZjiuI8yz Cm6WLqc0X3S6bdDx43nnGSOW1aWN3KrDuI3j613/AIQ+MHxW8CxhfBvjfxJ4c+zRLb2MVhePbWlq F+VcIpAyABz14616+YZDgs4wzwuPgpU30f5rzOrLs9x2U1o1sFNxltp28z//0/iOH9q79prT51mn +MPiy9WeTFxLJqk5uwG5bbKzsQ2e/NasX7RXxula4vp/i98Qpt67/s8evTI2/wBdxLfoK/1KpeGn C8bKeFT+b/Ro/gLE8bcQuo5QxDsvSxxfiX4q+NPiFFaN428X654m8oGezttfuhcmPY2cStgFiGwc Nn8a4vU7e0KLcpJbytJ84toEKRIp52c8cV9dluWYbLIQweDhy0oppJbL+uvd67nyuYY6tjqksTiZ c1STu2+v9fkZ8dk91YOUgjitRIRGrKPlYdQO+OBWO2p3VsklvLZxFDH5ce9t7oQeqntXqez7Cp1V FEmmX8cSMs0GyRyQ8ijcWU/wn2p81zDfzrBZMkEti+Y5EhVHJODzxmmqd0W6y5r3P//U/L0+JvFe iakt1pesTabrDRBYNb0staXtshbcUVlI6kc17VL+0j8d7izl07U/jV8QJtPu7H+zru0g8S3MAuYm Ta6Fd+0ZGQeOlf7AVMmwGInHEV6UZVI7ScU2vR2uj/OVZtiqfNRp1JKDb0TdvuueO32om7kj8qO9 vJSD9pvLy4+0SzEnOWYnd+f4Yq9pmo3lrdNeW11daXfadEk1vJY3jwTl0fekgIONynpVQwcZUYUZ q6SsVHGOmpSjve57n/w1L8eotMj8OP8AFjx7b6Z5YcNDfiOBBnBXhdxXAI2ggc96848T+MI/FE9l Nql5c6n9qza3l3dvzEA2cqAOQTuJ6HPavFo8MYDLsVKtgqSi5v3rbf5dXsdtTPsXjouOKnzezS5b 9P8APodB4d+Lnjv4eidfB/jzX/Cwe6Bn/wCEf1SW1+0xBBGQ+G/ugAdsAV32l/tafHLyx9l+KnxT CWkjraWsHihrN77ccjO0MXyem4j6Vy1+AcixE/aVKEeY53xrndK0faysj//V+NL39qz9pC2ktJIf i54rsb8yyf2pDe373txGCflVC3Izk55HNYGv/GD4p/ES1tj448Z6lrLwRbTI5HmzAOGjzu3EADj5 cdTX+skOBMnw7VXDUkprVNaP707n+cNXjLNcSnDEVW4vRp6rtseaSb7KSTyc3Vnckm6guDuI3Eli CckfhXo/w/8Aj18WfhtqGrf8IF491bwlpjWcdrp9vot66JbED596sMbW9FA6A5rfE8F5fmcYrMIu dlZXvp/wfM56fFOPwMv9iny97dT0SP8Aa5+P7adLBa/GHx+04B+zpFr7RLHKTuZjJjzChP8ACCPx qr/w15+0/wCQLq3+NPioXUWIbm1kvpby0G3qcOx+boc9ea5o+GfC6alPCxbXe7/U0lxvn8k4qvJL r/Vjznxh8Vfit8V3W48ceOdY8UWn2oSwaPe3r3EQnjwI5GQnBwWbC8jPNeXxvNaXDvM3llGMUlvj BGDzkH6fpX02CyeGXxWGwkFGmtklovS2h4FXGzxWIeIqtub3b6n/1vzLF7DIrBbiGLy/3jFmCNj0 59f61p6B8S/iJ4C1VdS8H+NPEPh2SFVks10a8NqY5EPysD/n61/sTicjo4+g8NjY81OV7p7H+ZEc 1xWErRxGDk4zjazXofQV7+17+0rf2VuZvjH45udUihy9zNrMqDJwWwyEN9MmvOvEP7S/i34iaun/ AAsDVfEmtT6bpf8AZNlqniHVH1x7BUcSsyBxnDMO2P5ivKy3gTh/Jp+2y+goz79V6djrx/FudZp7 uPqNrtsjx8aTJc6hLqtzdvLb3irNbyLF5ZYAYU7f4enTFY+p2txaXqB4pFgugu2UqcuCcc/ofxr7 ChTlTpRiz5JxfPJ2erL6pBYx+WgzGc+WpOWQc8msRbx4p/MjZpF8zo3IAodPsaRfKtUf/9f8u5r2 QNaTymNYkbKmLarHj+IDr+Ndn4X8Y6n4f1m28R+FfEGp6JrdoyQ+fYTNFsCMJFyvQ/Nzn2r/AGWz DLMNmeGeCxkeanLRo/y6y3NcRlWIWNwkuWrHZ+f9fefUMf7dP7UVjLJND8c9UYxgLJGIytwgA4Ej dGIHrnrVf/hvr9p2dGe3+Nvip47ttivaiFYZFwdyhgueueRxx0r45+FvB6s4YZabav8AzPo5eJHE 9ROE8Q9fJf5HzZ4x+KPj34jagmrfEbxFq3ia+VJUaa7uBJJCJGydjkZC9eCTyxryvS9OSW4l1F1m VYZWtYi5OZB8pJHr2r7fAYSOFwscLSVoxVktrJaI+PxeKnXqTrTu5Sd2+76noHhr4geJ/htrC6z4 M1rUdAu2jIlfTJhBK0ny7JWYDOV24/E19R6N/wAFA/2vhYGztPjL4gmuYkLJBdbXAU5588gsTx0P FfMZt4dZDn+K+vZjSvVfVaXWm+/RJHv4HjrPcpwiwGCm/Yro76P8P6bP/9D541L/AIKHftc3KzWK /G/XptQa08i+iaziFvZoy8orbVz7EemcV8seLviJ4o8d+KIdV8aeJtS8Ram6L/aGrXzK4maTBLbQ oIwcnAz171/sLkPBuWcNNwyqmoxlrJ6Xb6Xflrb1fmf5eZnxFmGeyjVzCTlKOy6JabfcclcSXH2l jCzuqyfJIoyHAPp74/WppNYVYyzpjy3CPGrFHcE4NfQVMLVlLTbYyeKpypci3vc+vPhf+1n8ZvhF 4dli+HfxR8YaIGnVBo+nNHJbIqxgK+6RSUA4Hyds9K7ab/go/wDtpLNBInx01sQRg7oZLeKaVWPP VkOR9DmvgK/hPwxXxc8bUo+9LdaWv32v+P6H1tDxC4ghhoYRVLRhond3t23/AEGT/wDBSX9sC6Wz gf4y+KLyaa48qdDBABDz/rFf0+78uPWvEPjB8fPjR8bZbVfif8Qda8SWWnzRypZNthguTGTteZAM cbjkLjg9a6sr8OMjyLFLHZdTtV76fpbpoY5xxnnGfYN4PHS5qfr29Wz/0fgzwB8Z/iB8Gby11H4d eLNU8O3I1AXhltZQY7YYO7y1xxyScc8sa928Xf8ABQ/9sjXPDF5pGq/F7VfEGkXbqpiutNtZ7mOP uRKU3D6ZxX+ueM8OMlzLMFm2Mjeve97den3WR/mzQ41zrBZe8rwrtRta1+nX77nl3w2/ai+MHwh1 abWvh1441nw9rurXS3t3cCQXMF4ztlmeF1ZMnPcHjivQPjF+3d+0l8YNBbwz46+IbX9is6vuj0uO 2mlXHzDchVASPl+6cc110vDfh6OZRzaVJe2TutNL3ve3dHLV4zz+plzyuUn7F6b627XucF8Jv2wv 2nPghd3kvw2+Kmoaba3Tlv7OvYUu7EA9BtIONvIBUDrWl8Z/21f2mPjLpq6R8RPiAmo6EfMMtnp1 otvc3u9cbZJdobAJzjJ6nFehQ4AyChnLz+nTX1nWz6Jvd97u/p5Hn4nizOq+VrJK028OrK3ktkfH l0JzaedLunlKKpRgI3OBgHH0p9upuxNI0TxR21uSE3BixVQc/nX38Wrcp8vKTP/S/HyaF1017syr neALfB3sD3Hal026hMEj3VkdpRhtjASYEA7eceuOK/3QTs9j/JX2myIrN3WQXUMcwbPlrHnheepH tVqK9SO5yzlZkkKzgjcoI7Y/nRUfPHYPbxpR959T64+BP7af7QvwG+wweBfiRqC6Rp0cttBpd9+9 t1SQljEjAZChiTgnj8sfTUv/AAV8/bFt7aO3Xx7pdxOGLvbxaYGix/CHaRSD6cHNfk2d+D/C+eZo 8zr07Tk7tJKz32unbXXt2Wun6Bl/irxHl+CWChPmjFWTd72tbWz10+b6t9fhH4qftCeLfizr914i 8e3Met61qt6ZL1pV3RxIxz8hxlQD0UcDmvQPhD+2p8fvgI8K/CrxRdaPYkC2k06YrPaCFSMHBXqA CAM8Z6172N4DyjHZLDhyvD/Z4qy7q3Xt+FvI8LJ+NM1ybHVc3wk/3073vqnd9vJ6rX8L3//T4c/8 FjP26ZBb3LeK9Bmtgn2WMLpaQysg6FmQDPavi/43/tJ/FH9oCe/1D4m6iuoz6nlv9GgjiNsd8Lsk bBc7S0CMe+c+uK/2ByLwn4c4Zxn9pZdB+1Ssm7aLfol+Omp/mBnPiBnfEVGODzGpeHNzdd/m3/md P8Af2u/j1+zhLc3vwn8dRWKyMZ5NO1O3MsCkAKYsbSH6cBhxzyMmvcfiJ/wU7/a4+MekSaD4z1jw zqGnPbzW6R/YSvk+ZE0YkRUC5K5BAfI46VvivCzh/F58uIqsP9o5lLpa/o099evU0qcf5zVyR5BO f7jl5Ot+Xovlp06HwnoHjLxH4Z1/Ttc8L6/c6DrWm/MlxZeXtklU7izqVwec8YHB4xX6NeDv+CuX 7a/hDSbLRdM8Z6fc2NpaNbeXcwxOW28AndGx57YPXOcV28U+HOTcZezlmkPfgrJpX+//AIFvVk8P cd5xwzTlh8DP93LVptr7mvxvdaHQr/wWA/a/MNs6a9oc13cZuPtTQyyLARgvGx4OT09Ov1rM13/g sL+2TrWmXmkf8JDoOmWd9AwxPpy35VmwpVc528ZOCSK+Ww/gJwhCrGpUTdnfRJbbdH1v8tOl37+K 8YOJalGVKLtzKz1b3vft0f8AVz//1Pyd8ceMdc8Za3deJdbea+1/UrxrrUtSkmXfesw7IqgKN244 5+/1rhdWmEEMl6Ldp52UK8a/Ow/Cv92cHhKeFoQw1JWjFJJdktEf5C+0cqrm3q9fmStKEtFieNg+ wOFHBQnnmq9uysWE8RYIAyBuQ3X+WK6+TU0czftbVbqDcn7thyuPbtTl1eLQdStdQ8P3F3barbRE LdZCvDIylWK4PIHUA96KsIzpyg1dM2wtadGqqtN2a1TW6a7H6Q/Cf/gq5+1z8KPBlt4bsvF2j65F YqltpZ1OwCXFvGibAmU2jAABO7d1PtXo2j/8Fu/2v44phNdaBNdWsvkoX0sR2ku7kMi5ydp6k9a/ Ds38AuDc1xVXGuLjUnLm2TS+/V9be9f1P1PC+MfFVGnGlKpeKVt2r+dlp2vp9y0P/9X5r+O//BRr 9oL9oPQdS0P4havZwQ3sMdvHBY2SPZzqsqyuCrk4yUXp2J9a+AYpLa1uYY/MYW8uFAI+WInrn2r/ AG54T4Ry3hDLnleVp+zvdX39Hay3v0W5/lJmma183zCpmWLd6s7XforL8C1erbvMEU70A5dOAR9a +if2eP2q/jD+yxr39t/DHxFf2tnPJmfSAIpYV4UBwHUhgNv3WB6nrxjfiLhzB8S5ZUynHwTpy/B9 /ketkXE+N4Zx6zHL5WnazXRrqn939bH6Jaj/AMFu/wBrb7PYTyXOlmS0VYPtVqC80u8/eZCQMjPJ C449Kof8Puf2wpLrMLaLNIiAxNcWkYR/XdsYDkV+Lv6OfDV7c+n+Bfnzf5n3EvGXP5weln097/gH gnx2/wCCm3x3+P8Ao0vhrxtpWiR6E8jJqVnbyt5+oq8ZVyrchRuI474I6GvzctTEJhdQokDyz+db wMu7yAG3BSSTuwa/TuEOCsFwXlbyvL4pxbu3a3Xtrbc/Ns8zvE5/mk80xk26krdb7H//1vj/APZy /bv/AGjv2Zr7UJPA2uR6hpM0DR22mXkvkx2RkbJWPGCVByQGY4r7Vtv+C337WKywRG60SUtGzXYl gMshwMhSwwWPYYNf638ReB/D/EWbVM5q+5Oe65U9b97rft38tD/NXK/E3PsswtPBKfNGGi1a0/pb jf8Ah9f+1sIre5A8Ol5w8t0qRy2c8ChvljOXbBx2Bbr2r5Q/aS/b++MH7WujPYeO47PTfscawW5t QTBOFYMWKMx+b5cZ468Cssg8Dck4czelneElepTd0nD9b/12Ms+8R81z/KauT4u/s52+0+jutGv6 1PgKe0lht3jtUWAbcsnRG/8Ar10Xwz8c+Jfhn4r03xn4dvrjTdf0mQT2ssFwY4ZGUhgJFHXGOD1F fs2LwkMXg6mFrxvGacWu6as/wPgspr/UsTCpRdnBpp+a1R+v+gf8Fwv2sNC8M6P4cNt4T1D7JbmK 4u7y1muHCj5V3YmQZGcjaD75rdt/+C7/AO1bYWBsrrTfCOrRFTHEn2SWCXI5U7t4wOwyR9K/AsR9 GzhjEVZV1USbd/gV/S/Mn8/wP2VeNXEUI+zd3G1rc7svNKzX4H//1/gf9qz9r7x5+1rqNvqXj+xt NOurKRriKGxunuHhc4O4bs43n73J4UV8n6aog2OH8yVOWDj5Tiv9yeGchocNZNRyfDu8Kasna34a n+TmNx08dmFbHVfiqScn6vcLnZc3IuXQRRh+UQkAf/WqGcqlyqxSYxzvXmvoowvucLku5INNudTd isc7mMZQRgnd6/KPpWcytaLGYgzb5PKdGUqy84Jx14rW3RC54kN4ohDHezIwyO2DVSEz7EjeIKZf mDgZGB2zVcrJ5+5//9D8NcEThZM+WjYcY+U4qzL5QlEqR8ucoEGFUV/vrCNtWf5Gc6I5boo67jyf xwfSoRMWmaSddxJyGxgVY+eJsCUyRKq8gNkBeCatXKpEttmMjb99mOSc0BzxKs0CGb922Q4AJXOA DUUlssT4LtLGFyWjYdfSgXOj/9H8PJLhkMe0kBXwDj+dRXZurnzZADKf4z6Dpmv9+oxbP8jOdFaH eu1HOwHjGcUieWsxBOwk4L9DitORWsVzR7lm9EFsqNC/meYvJ6t9TWTayOWbepBV9q5Pb1qPZsFJ dC7JwNrDduHPY1MoVECBcKeoocGjSMz/0vw8fy/IKRwqD0VuN3pWaquN0PklpXI2gnHWv9+D/JPn 0JntmhYKyBXHXAzTkZA21mA3cECghy6le/uYraJPsyzOykIYo49wwcAY/wA9q0Y7GaKJZZHBkcbm jHJT2Pv0oI5okPlmNicH5u2OlLKgd0WK3EREe6SRm4c+vJ4ppN7Cc+x//9P8Nl3YHlrk46CpbU+Y x3piUHC7en41/v7yI/yGlNdRJ1RZWifjI57flVFZCN8aAsy/dak4WiTzotWrzPHiRcIGIz3NNuLY gHYQWPCFjjNZj547BaRywrslQOrN8zdq5D4nW6v4RvJljhW2jvbdWQy+XK8gEhjC856jn8K4M1V8 txC/uS/I9bI5pZxhv8cfzR//1P4yNbt5nu7gXEUUQFyRCIjkbRgc+/WuXeS3SYIxMOTsSUjAH1r9 h4uppcS41f8ATyf/AKUz4vK5v+zcP/gj+RbniFujeVKbiPd/rdm0H8KoJeRRSrE77d3LDHAFfN8k Ues5Nn29+yB+3H8bf2KPGD+M/gvqVolrO2da0C6QfYtW6EHPUMCowQQeT64r9vW/4Opf2vLOxsrO T4aaAlzBaokk76hPNbynGN4ZJVwOCeSCK8uWBo/WJYlre2luq0ue7h85q0cEsHKN4q9tbWT6bd7s /Lv9t3/gqB8Zf26761k+IFrBo1tpErX1pb2EzSRrNLgS7ZWy+SFAzuPT6k+N/sg/8FAP2j/2HPGN h4l+EGtQaho7XUqz+H9SJijlScgmMyKVYhWG9SW4OeK3x6hj8JDD1/s6Ly2t+px5RVWVVp1qC0k7 td7tt/of/9X80/jr/wAHHP7Vf7RXwv8AE/wt1nwZomhnVtKm0TUNVOrXMiYuLd4GaJAV3ECQnlmH GDkdfwv8P/FHxd4a8W6X4q8PavcaVr2kXSX9jeWzDe1wCCWk46MRzjse9fZS9n9T+pxVoXbfnpYz eL/22OOpLlmvntqfv78LP+Dlf9s/wB4H03wVe+HvDWvT+HdNS1kvbieeKe+ESBVlIEqoWOATgcno K7Ky/wCDpb9rydUuk8B+HXtvKKtBLPNDdPIe6gyKRjuCDXHTw2HilFLY7cRnFSrOVblSb1fr+lzn /Fn/AAcr/tbeMvDd7omr+BtJkN6pja6gu3ieCInsrSMMj04r8F/GXxE1v4m+Ktf8X67l9Q1nWLi+ eRlKFEmcsEXk4Az26mu6nKNOg6NPRN3POr4pVaTTWvf7z+sL/g1neJ/F3iqya1KJcalFPa3rgh5V tzKAik/eGCxIr+5X43anf6N8Mte13SBt1KytTPb71+VdsTP8w7DIGa+Lwqi8/qW/mX6H2WeSf+rm Ev8A8+z/1vOfjb/wcYftN/CX4peJPB+k+HdBvY9K1O4tUiuY5xNiJyhVGjlQNjHJxj6ZxX50ftS/ 8F9f2n/2n/AWueAPEXgy107RdYg/s+9ura5kiSSFnXO0SFiv3c/Kc+461+kujhcvzFTpxT5Plrb7 zyKWNrYjAxTdm9fxPxDvNZma4mngnDSONzu7+aJS2SSc/Xp2r9DP2Iv+CqH7UX7D0rp8O9esdb0A u5bRNZLxxwIzZAVkw/y8kAN7V52Ip06+KlUqa6nbgsxr4RVFT+0nF+jP0wtP+Dnv9tVtUefUfCXg u4ZpGkSaNbmF4h/CcvcsOnsPoK0JP+Don9siQ/ZYvCnhyEqzS30jyXMsUsZPAQi4AHfkc+1TKhRc m0l9yKw+NqUqDpy1/r5n5kftzf8ABT/43ftzW+gRfEaOLwzpmg3k1zLpumztepqfm+XtbJZiBhcE Fjx2r832ktzqf9rC6kt7h1UxPHgtEyEbZFB7jA/DitqslVpxpLSMVZJGLnz1FOT17n//1/x1/ZH/ AOC+P7ZX7K/hm2+HFjc6Z4v8NWkJstNbWYXS+jUYC/vI2UqBj+It1PNfXqf8HMv7Zc2qXE0nhHwc 4uisVqjNcTiHbwCxE2eehOfpivr1g8PGn7OKOp5nOpJSqxTl39NA1P8A4OXP22TDcafc+EPBVpa3 UbK4MN9ppjABB2yG6I5HOSDn0r8Ov2pv2nfGH7V3jO/+JnjuZP7XugZIIFna6EUjNu4J5IXhV9AP z7MNGlhqc6dNW5rfgzkxFWNf3pR16anxtLcSTOIZXkVx8pkP+sP419//ALI3/BQj9pH9jLXoNa+D mvSSqtqY7nRNUKtp8qKwZVzwcH5scgje3PORxY3CUsRH2dT1XqY5djKuDrOpTfSz809Gj9g9K/4O bP2279YZ18LeFrV7aHY0E163nOQRu3ZbdwegUjr1Nee/Fn/g5A/a6+I+h3vg3WfDnhC0i1JTHNJa XWoRzplCpl/1zxnA6DA5ArCOCw1On7KC9Wd9fMY16HspwV11v8rfd5n/0P48fE3jnUvGGuav4h1U KLrU7ybULmITNODJLIXbBbnGW49BXLQ6nsyz7g8jbdnTaBX1fsYRhyLZHLTdlp0PXfhT8XvH/wAJ PE+k+NPhz4qv/DmvaHqEWo2s4VLmKRoZFkjV96k4BXHHZ2GOcj91/CH/AAco/ty+HtBt9DvdH0C/ ksIgkWpxRkI6qu0bl80E5PPBBOe1cyweH9usQ/iO6GaVqVP2D1XTy9PvPnH9qD/gtl+1X+1r8PNR 8DeMrHw1pelXoW3v4rSa7i+2IHDDbE80uCpAbqvKjA61+QU+ql3mUMRLdIY5ZFT5DuznPbvXVyxl FroedGdqzqdWfoN+x7/wU1/af/YomvE+FOq2b+HG8i5GjatsFrNJEqow2qob5tvXIPPUV+kA/wCD mL9uzUfMmfw74EDqQohW3u4njHIyGa8YHp6fhXPDB0KblKPU76mZVZqMZr4dD//R+FI/+Dk/9ue3 H2d9F8IJEN0s0k63E0DqQcLtjnQkg9MfjX5mftf/APBQv46ftwX1hffFpdHtdOsZ3ul0/SIZoGuG YEKXZpXcY4+XeRx0BJJ+rw6jSbcFra1/L+v60MMZiFi4KMlZJ3+Zx/7L37a3x4/ZA8Xw+L/g1rot 4xbLZ3ugX8xOn3iqcruHbA4DAg9s1+rq/wDBx1+3r5MECWvg+MRSK0TRByGx1L5lz+VcMsvoOvKv fV7+q6+p1f2jUjSjSavpvfp2OL8af8HFX7bHi7TNR0DW/DvhG7t9RJi+0QLPDN6Ft7XLjGBjlef0 r8NvGXjvxP8AETX9Y8ZeJp5X1fxFrE+p6jvVV8t5HJCDA5AA6nrXR7KEYyS/roefOopVOdaMpeH9 B1/xPqH9ieGdPvtb1qQKY7C0t2lbDsF38cYB61neJ/C3iHwrqVzpPiTSNS0XUI0/eQX8Rt5SDxlP UYIII9a4pulG1KT957L0D2utup//0v5wf2NP+CgXx/8A2Mru6f4Ra7YaXaXESWzWOtQvqcLhGDfu FABVmbdkEjg9a/Udv+Di79vy0lxbnwxfxXEYwbVDbCMjqXSRifw3Gux4Cg5up1fT9R0cxnSUYNXS 89f6/wAjz34uf8F8/wBuj4keEbvwbql74R+z6hAYbrUdOiuYdRRZUZWQPvCKyhsFgh9ia/ErxB4j 1zXdVuNa1uaKS8v53ubjyZGZWkdiSdx69gOBwK6m7UPY9Lp/oZzrqtWdWKtdHtH7Of7W3xu/ZS8W Hxd8G/FN1oF9JKJ7uzj2tZ3ZU9GVgV2sMhhjsMcjNfrVZ/8ABxZ+369sltcxeEruO1iCR3XkvEZ2 AADHbOCT7cCsY0acZ+0W73OhY+oqUaMtlt0LI/4OJP8AgoCm6+guPDEcnmiOS3Fl8pRR/tSng9Ou ea+Wf2q/+Cun7V/7Wfga58CfELV9HtNH1WaGSe30SK4iuIFifcUZWkaPDHn1BX8KuMuWoqkVqY18 TGtHkmj/0/5C7ucvC0MOeIwhLDcZB33E9fxr7o/ZK/4KF/tP/sh/J8KfHsy6fcHZcabq0S3VtEBy mF9VwQD1wxHNejVoxrSSn01/EvD4yrhm5U+qafazPvG7/wCDhL/goBPmNNQ8LW8ghCpNbWhiack4 JYl2APfgY9qzrf8A4OBv+CgsUqxXWteGZ4I02j/RVzzyST1J7cVjUw0XJO+xnPESvzRVj87/ANrD 9tL9oP8Aa/8AEun+JPjP4mtbu202N007SdIhZbWPzWDMSWyw+6gPJztFfG0x3zvLdHOfutncRmuq pUdW3Nslb5HnUoxpcyh1bb9WMSCNShieRRySH6Se5qlMD9oLOiEsu1WQdewFZqMbWOhtp2P/1P47 beeePKhgyq2ACMbauwsswJBDOevpXZOCcGkjjUnznXeEPiB4i8DeINH8TeFte1DQ9d8PXK3Npdab cCKVSGBBOevP86/XzwT/AMFyv+CgvhDwvp/h+08baff2thbiGC8nt4pLyZcYUyPtHOAOlYypUlON V7o7aOPqUoOgn7t/6/r/AIJ4z+0L/wAFWf2vP2kfDFt4P+JGv6V/Ys0qPfPYWqQ3TCN1cbSc4bgD K4Ncz8A/+Cm37Un7Ltjf6P8ACX4k3r6VdzfaToWtt5kVueAzRcEfNjnpShGPtG/M6Kk5OFjhP2kf +Civ7R37XUFrL8VNZsJ9NtJXawg0eMpJFIwEUjlzz0UjnJGTjGa8T+DHx6+JXwB8U2/jb4W+Ndf8 IalZfvpbXS794LW/cKV3Sp0bKlhtPGSD1ANOtFX2JpVHHQ//1fxq8Z/8Fo/23vih4MuPBPiTx1pE ukXdidPbzYJILu6jZCp3Mi/ewc9hX5m/2pem+l1l5yuvyXJv/wC17VmjukuCdxlWQHdnOO/4Vvyr laRpztyTP0h+Gf8AwWH/AG8Pg54D03wL4Z+KUWoabaWpsojr1t9sv7dNgjRFl6sFUfxc18UfF39p j4yfHvxhL4t+LHiRdc1iUsv2qBEtRboyKmUVUXB+XoOMk1MYxstCpVXsj1r9n79tz9qX9mCWVvgl 8X9Y0fS5JPPm0e+ZLzTn4AyInVlyBx0H14FfUt//AMFxf+Cg08V3bL8VYrlZkaLzf7Mt7XYW4O1F iwMf0qrK1jH2mu58A69+1X+0D4n+KP8Awta8+JuuWnjpb9L7+1rNzbLujAK7ApHORzn8q+0n/wCC wn7et/4bHhG/+KdnqWmrZrAbvUtPgmujtIA3Axnc2AOT1xSpxUVqjKvUctj/1v5M/GnijXvFGq32 u63rN3req6reNf3Opz/IzSucyfKOBySP61yMHnvPlv7vy+xq8Qk1ZHPObSRfF1InysdxHUkZNaSS LNCXVwSo+ZMYdKVOCW51QrJPctJJtgWQL5zcho2GUIx/OvqP4Dfts/tOfs+i30z4GfEvXvCGmLP5 kmn+cLuzhkIwzCJ9yMDgfKw9PQUp0ryTSLhiopONzo/jz+3Z+09+0RcaNZfE74h3nji20u6a6Fnc 6XbaLCH2BGBMCqzD5cgn1Y967D4M/wDBSn9sv4E6M3hn4efFIeHdAZtkWj3Sf23bWUS8ZjSdHVSc gAeiAZ4odFWKWIS2Z//X/mr+Jf7S/wAcvi34zj8d+OfiTrur+KjOIYtYSYWLW8YcurIExtwTkBNo HAHSvrDwh/wVG/bp8HeHYPCFl8c9Qbw3psAtLKO6soLy7kRVCBXmdC5GBj7xqHSUZXaNniE1a58Q eL/iR4s8feM9V8ceM/EeqeKPFWrs1xqVzqU/mmRixJ2j07Y6AdMV7b8C/wBtL9pf9nNG0n4UfFPX /CGh34klFks0dxZ27Nz5ccUqsAOuCMEZPWoxCp3SKozkj3b/AIeu/t6CQBP2gNfuyjbyXSOBRk9G kSMMx/T2ry34nft5/tefGzQ7zwh8S/i1q+seGb6U/ahIyi824+4km0fK3Gck9OKwcoRvY6Yqc1sb /wCyF+yH47/a2+Icfw/8I3Oj6KFiV7/UtXndlltpRhWG1cmQkN8o5x36V/RloX/BEr9tz9mzwTN4 0+CnxfWw1G3tRdjTdClnhkvGVBxhgI93yqASOcKPSsIypura+p0P2kaV2f/Q+OvDP7Zv7e/h7416 P4B8bfEXxo13YeJI7C6sLtE84vHKUbBEYOCVIPHAz0IBH9/v7I+p6vr3we8K6j4gvjqWrSafH/aF 25BlmkCKH3qO+4H+VeZUq0o1PZt6nrQU3Tc1sfzJ/wDBy74pl0rwtockV+V1NpotP0i0icq+8zFn yPo/f+7X8bPhf4mfFH4TeJ7Txj4E8bap4Y8Qjf5+pwP81z5nytuwRyMADHpjnt1TUVSi12OWNZe0 cex9TWn/AAUj/bmVdkX7RHie5toE2RCSUR8j/ZA6e+azZv8Agop+2VdTahFefG7xR5OoRn7bHFNH eQXTYxzDIu3nJyetZ0+WFgrV11Z8ca9r2ua9qsuva9qsmsaveyPNe31wgjmndzlmYDgdAOPSuaZl 84xuS0u7cRn1qJ8rkZU8ZCKtfY//0f5aNOv4NGnS8/fLqCsrW97CxiubFlKsnlOOVwyhs/nmvqjw r/wUG/a78IWK+FdG/aH8b6JooxHp1umpG7vQqgcb25AHt6YrzaCUE7nZWxtOrZplLxZ+2V+038Q9 OubLxv8AHHx9rlj5JtxHc38IgMbDDrt2fxDgkYPPU1yXwm/aM+Pnwjlluvhj8WfEvg6aVpSFgu1l gCyFScK3GTsXOc5xSlBc10VHFwa5bl34h/ta/tL/ABaAtviX8ZvFfi/SbGfcdP1JIo7eVwCM5UDI wxHpya+brvVJbyd5pQpuGlZmkHAkBORx61rKcHotyfbxTvc1tKvr7S7+x1SzLh7aXzCY7l7WePHK 7HU5BzzkV9peCP24P2vtHtrXRvDfxl8ZaXpNjNvsbO61A6gYjjhhI3z/AC9jkYrmjBQlqdH1iM0t T//S/n6+Lv7Vn7UPxD0+bSfjB8XfFXi3STcB7nR55POSRUY+Wd7ckEHnAHBIB718vW96byaUq4tI 2hd4HErSODyQo78/WvInGMk0mevCryu56r8PPi58RPhffwax8NvFWveA9TSMR3d3o2rSWxkAG3mE DYxI9evfNe5j9ur9sO5jfTj8fvGf9lmRZiU1GWKRnXoTGrALj2NRT/dR5WKrWU3zWIh+35+2vY6k m/8AaJ8byxR3G2KQX3ntGvQlVfIH0ByfWvF/id8ePix8Z9dTV/il458QePLnTgselzatccWqgkn5 BweWOPSq5o2urnK6sU7HB3ceqXdhPdxMlkIlJLDE8pXoePeuMkuYsib7XJ5RQJ5O4pFkHO4j1/wq XUjbqZyqpH//0/5Q47yQSIYY8sH5IHDCrtwruQUHlyMfm7/WvHU4ysjX6zCLuzSikks4d0QLMo42 9T61RY+df+YymIvCPNlc4IC8j8OTQ4xe5SxcVrFG3aXUcV4hdvtELDb5XUFuMN9R7V9B+Ef2q/2l /hjpdh4V+H3xs8c+G/DNqrJDpdjrUsEMYc5YIqkKPYEY9qwlTUXpsaf2h0seQ+N/HHj/AOI/im68 UeOvF+r+LNbuoFhlutTkDO23oxx3wT/32c5NcYyyJuWSaRI4+fLOSGP0pxlyq1iHjW3sf//U/lNu 7y4uLqK3nhM1hKqq9uSQV2chgB3zj8q+gvhl+1Z8d/hBaHwz8PPiz468KadDl7PTLXWZDZafEx+Z IYjkDnPccHvXytfDqrNTfQ9OlmLhBxS3O61X9vz9sNoo5x+0H8UoIorhvN26xMPs6cfOkann1P1r zfx9+0H8Wfit9nm+KXxT8W+OrW2g32dlq908kTOybC7LnGSpIyefc1dOpOhDkp7HPVxfO+Zo818I eNtY8Nataap4d1jV9CudIGzSP7GufIlJZvuu552jC4HQYr6jj/bz/a2sYLHSx+0D8R7O23eRAbHW 3hS3ijG4IdpGCDwMVx+zcqiqdUbwzGp7P2SWjM7U/wBuX9rK+gvIp/2h/iVqUVwwWW2vNaeRJVHG W3EngDqOelfL3inXtb1uW41a/wBQvtR1DUnJvtTvr5rm8nYkuep4XLseBjmu72lRw5Xa39eYlL7T Wp//1f5OXiuJGWbzJCSoR9zlkwOmB0FStJuubS2LOXP7svEu5hnpn/Cvlk5p6HqOpO2iNC0kFnZT RSh4rSO62yJMD++w3D8dMnBB9q+ifh9+118f/hBpZ0fwP8VfHfhywSVRp+j2uqyTaY6bQQ3lZCqw BOD6DvXMsOoTdSGjfU1WJxEoKD2On8U/t1/theNtMuPD9/8AHbxadH1SJrW8tppVi2RyDayhlAI3 AnPPOea+YtY1bV/MtpY9SvLuXdmaaWTe9w5zudieu7JOPU8U2qrUo82j30RcK1VSTS2On8HfEzxH 4N11/EXhPxB4g8La9avFu1DTLl7KeQrgjPZ1wBx/sj0r6XtP+CkH7bkD3FrYfHXxt9gZ/LK/2kkr GNRgD50bBx3FYUKTopxwzsvvOqeMxE2nUV7H/9b+anxZ8c/ip8UvElr4i+Ivi/xD4nvVga3a6mla JoGRt6OGU4yvQYwPavafDH7ff7XHg/QZPDWh/GrxjB4bgQafo2myot2qoCQVklkUsqqOg6emOK+D jRqqXLTnZvtofT/War1nG9u9z5x1Dxl4n8Varcapr91fa9rWqXby6xfzTkyuHcvkdAACei4xXsXw 1/ab/aA+B9jqOl/B74i6/wCF4Jg9zdWSTedatwBghwwHTqOfXOBSp4dwrtOXv/O/3m7xNWVJae7/ AF0PQfEP/BQP9rTV9Ni0q++N3iYaRfWn2fVNLkjjMLh12yj5MBgckYIxivHPDv7Rvxe8I+ItN8Ve EvF2oaDruh3X2iy8Q2bf6ZeEgH5oz8m0H+Fg3TtW9SgnPmnLXz1ClXqKHLFaHonxV/b3/ao+Ktnb +HPGfxj1jWtGt0WQ2U2nRWlrcSDIAkjTCtgcZ/2jx3r5RvLeTVhBdXPnWxguFuW+zqYBKwO7OD2J FaPDVYRT5vdIjiY89uXU/9f+dz4U/tJ/Fj4KX/8Aafw18feJvB95cwtbXC6Ve7oLrcQQXiY7eqgn Hp+Ne6n/AIKeftkTzfZrT47eJPtH2g+dL9kW2baOpR8ZJBGMZx718QpRm+WO59hUm1qzmPiJ+3X+ 1J8UtKn0Xx38Ytb8SaPcWjafdQX9rDHJJESpIQr0PyjLcsR1r45tdRW2eWCS6uJrSLLW0UiZALHJ y3XueTVVKTjHV7nP7Va2Mu4ktri7acQscqIyzD5cegpJLi2t1LvE6qq4V0TciegPpWUYuOjM51Ob oQ3d35/2aGTM9upDhHX5Yj6r75qvqtzNBbM8cTM+cJkYx6ZolG4uZJaI/9D+UfzCYbfVntbF7vyx DcxJHtJwoAbsfx9R61naas9091ILiSJ2+WCHygYz68+o618IoJH0LlLudDcW91Y2kDXrIPOyiMMA yEf7PUVixSog3gFDG25MDrVWT6E2fVkb3Nxc30MuFeNEKywOdvnluBz2xz+dVbg29vPJDJDLuYAt sJxt5yM/1p26FxjfRl+C6tZbRJbWOZbZSI1dyWkXHByMeveqV5bNb3UcsM3mIxDXAY4aInn5T+VS opO6H7Jd2f/R/lCdZHt8BiQhEgIbGO39aeILmB45m825Eu1VEa52eufp618LJ2Wh9KqaR0y3kUsS i8BSJAIt0cWT7bsVRuZpbEGGGaS9s7hwylogpgx0+npWV2jWFKFrtGdEu6Vpfm3HnjpU0RR55nMD BRtUbuSTjn+VaQeljVRS2J75TNFGHm+Zf3cIzhY1HO1R2/8Ar1FbMsTfvFxgfLkelWUnbY//0v5V 4n8yV2jCIpbhU42mtVru38u8uL0yXNwAN+5spKegDN1H4V8OfY3fcy7SJgxurjbbRIQVy3Cr1ya1 m1q81dW2KDHb4t43JJedF4zz0phzS7kK3yxyrC6yQhRwSAFJ9D/Orlm1yqTzYRoRKrlc5Vx7/rW0 Y80dUDqSTtdnYfDm+aDxYbtLDYiSobe537hIoYF49vX8e9foz4espdQ0om0nFv8AbVBUFiDEr4+U E8+or+rfo8xccvxr6X/9tP568YPfzbBxau0l/wClH//T/dv/AIJYWSzfC/QtVeNbN7/SVhaCEZit ltUijZAT6l1+tP8A+CrOvS6R8GNRSxt47i+nkWytVaUwInyP5p9MlXyPdfpX3eXwc/FHT/n+/wD0 o5M9n7PgJv8A6dfofxOXMuoaWkttNa/JZQ+dtvY/Ok35Ls7k9st/OvyX/aKYJqlxFdXflW3nuhjf 7kwX5lVR1XAwfoa/qDxaVuCZv/D+aP598K+d57d76nyPdQGSYSQjYFT5EUdB61NYQzLOIBMivL80 vmckjvgetfxTOSU2j+kKvNdHfQW/lKJDctFapEUnRVDB/wDa61q6UqygqAWVTldw+VvpXlV371hx cloz/9T+LPYE1CS4y29RsUYICD0Aro9GsrM6gNQby4JZQIS54Y4PGD25r5mq9Wzuh8J9G+GG1LUb HTYibe4hmna0+0QsEdNnPzevUD8a71ZNPUm2kUszgxJGvO4gHivLqt3sWldle0uYYZZoEtSlv5e1 pJFwmT3Q+3HIqOec24uIpI2e3aPfHPEpEo65FcMm7M6qcUkdLp9xdb7DUIbqSKezUTQI5yFIG4Ag 5HUDiszW/G2qarPeQ6hodm13eAeZqSIsUkmxhzgDAJAwcDvWUW1RbZvGC5T/1f4zm8Q6gljP51gE juyiTpHG00sYDHAVvfIzxWloUel3LSTX8lzHEUMaWpxEszdAFz9ecV4z2JpvqTw2dxpqG3Qf6MHY x7HMibCcjn1xj8qoXqTXduiiciOGXeqE/IecEe3/ANasDVy1ujQ01bg+extwkwcDMj/ulX1I5/yP y9UtbL7Faw6rcy29rbXH7u1XzQZZCuA5I9CTQTdiyW0t5qVq1oUmiuCIUlibfGzkgBM59TUcV1p9 vHqDanpclxfW1w9rCFwXjVeDt9CSB+VaU+oj/9b+QiW4m1K2aeOGSFEb/Vn5XxnBz/OuK1q0S5t0 t7S282a1mLlzKWY5HI56964Ka2Ik3qjzm7iDtE10yi5hmOyILmPGeAK1vCmrXc+u2UEc0QkfUo7e OKaPNu/7wY3fTAIx6V7OXprF0Zdmv0ObEXeEnfsz9h/DbWlpo/hnRre8inaxso3nubWRZFlYsWeL eOqgk49j1r+ov/gh1rWm2kOt6bp0s5gS4UaTF5B3QsjmSZY5T94ZZyTX9xeJFL23hY7dIL8EfiHg nPl8SsXDyn+Z/Rz8f9MfUPhR4tjmkZ0TQbiW4gWPeJWUK6AjH+wRntmv4Gfj1aCL4qePbW8srGKe DxTcI0iqRdkGOF0/76BOef4K/K/otS/4UsdT/u3/APJkV9JCDWYYaovNfmf/1/x28R6XL5+mzxR2 8NvcmVkjkuBJcDYQOABkAnPB9KnsZYbK3WDUIIbyGWdi8jODPGAOFA9M+uf0r/XiK9y5/m/SXuyR lS3EMa3FgHxbXi+W69UABDD9VH5VBbwQuLi3ijzFMnl3BX5JHHT73XPFBrT2sW9OGmWl6bK0udRt LaSQC602+uBcSRmNeZg4VQc/MFGMj9apw6WdfuL26S9KWqSmRftTYeNVIBXJH17dzSOlyfsuVHZ/ 2jPqyWXh6HyZZC4tbIsAQpPHB+tZtjF5N4tvMDDLbuYpIuVKEZBBHbvxWWIhF0mvT8zfD1G5K5// 0Pxt1e6kOqSPbx28UUFr5bguxlOWGSe3PPHtWbOsYCS2sDW/nKBJtz5DbRjgdO/av9crRsf5/mvb ahPqLqkUYRY0EUk0eSHYcfhXSwW15HAiPGwiD5eVeiH/AGvTNZ0I/u1fsZVNGK5uYIrnckDRSYWF gMzx47hu2eelZi20Bge5nlwYvnlUttdVHce/tWqjfYyi7mOLu3soYtNitpLy1KM8txuDPGMZy4xk 59ulVfscNzaibSSkcibZ4y4IUgkYyOvOf1rOEXd+pVRxZ//R/ITQNKliju7qaFY7u9k3zqCShCjC gDpio7q8dWFt9nBd5fLd05AwfSv9cVHVq5/neV7m4n050EplEIKn9x87ducD612DrcRyGC73SQCJ Li3Z2DswdQwz7YIOPekott2NYWM67s7pIrS/s5jGn2sDahGGVCN6k/w5zwOtaN/Hq+t3NoZpbb7N Yf6QvmIqMhA6k9Wx261cE7MJ20RNBdWt8zh7gSyQIFkYEYKr8oz+C1U1KC3aRpkvoLGAwiOUCcI0 inqAgOT2OKuN0rMza7H/0vyLt/ELq8CxWEF1bWjKEhZjCJlXjLY749KbcXdxNPGs7RiBlbZbOMqh bpt54xX+usVpqf52uVnY1dOinmYRsRFsPyyMdqIPU+1WL/UJSq6MJ8x7xMwXBVz6/wA/zrop7HHP 4jHk06OSWONWw3mqREv8ZBBA/Eiukg1WQ2s9lrhItcfZinlLJ9lCE42fl1qJRbnc6aDSi0zH1XV4 ljt0tXcaciAW5K7FcrxnA+mPwqW0WO/tjcozRtIPmCNk8cfnxWsdkYzSUj//0/ylh1ZfMTS9REj2 cKCGGflJ2yxJB/E9feqniCS3t5J1sIXW2aIR/uzuYgDljiv9gD/OOVovY1tFvhLpWoG6t5di2gME xy9xuHVgMf41zsF6104tbuJXtX+5MAPMzkAAjH1rWC93Uz22NydYVa4srbypI7NhHHcxNiOQbQdy gjPByM+ornt0FnGl1eB7+W1cqCo27yeMEDjuKpxT3C9lYj0O2upZrhpoZUP3og4IYDBJJHpit22n W11JmDeUWi8uRy2xWB7E/wCelZuDSM+fXyP/1PyesofM1FoZLiW8RybmNLOQIXlHKZ45A9KFDW8l pHewXd1Pf3vkbIoGknQsSM7Rz0r/AGBi1Fn+bU5Xa1JBp729xK1wPKl0+U+THcDy5wGOCcdu2R/h V7U7hTeaY1sbhhdbYZd53Kr/AMRz6fWnNqSsiU3E0jqA0a6Zbki8/ekKEXbGgHHJ+ufzrJi1C3Sb UJr3dCpAYjaWZ92Nqj0GD+VOlHliTXlzVLvyLOkWsYuJ/KVShjMr5IBiTk1RvZ5LMrcxTI06nfZZ fbwD3/HH4VbXvRa6EKWkkf/V/Jq/u7rV/Inhj+zNboTMI3/1rkDJrX8PLpw025haGSG5LbkXK7XY n52Ldee1f7Fzi3BrzP8AMt2UxJ7OO3iWKJpCNxLvI3mBM8j3wPemyrM8u3UM3kRtyXlUmNjIAAGx jv1/CnTVi8Q1NplfTJJbe8dbbf5P/LWDftZx/s+/1qO+klh1hrU+crsqv5TjJQMOAcetaWumjBab EzP5d3FbSTJBeeV58Y2nbjOAf0q1/aCuBZRuryJJhowPmc4zkn/CnCLTsd8muWLZ/9b8s5p4ZkEB tFSSLLyMp5Y9ge1V/wC15YYlQQlJgwCuhxwPw+nNf7K8seax/mZVqWjNmnNFC0cLwB7iSVi1xNt/ dw5+nSojJYXITyprhZbKQxzRlcQyHHBX1HI/EGhQ9/mOWpUvFBcXRg8u28/bG4Ds6jCnPQe1V9Ri QWZkUeakbffBy4P0rb2bMpYi2hladHdtINSt7izZIG8v+zpGDXcx67gp4x2rq2lt333os4Le4lJS YLEFaEdxjH+cVapGcsV5n//X/LSNY5I5blXa4DHMTSMA69htH4frQ0Ed1Lbm4QwNb4lUrH8smOMn 61/tEqdo2P8ALr63dmhd31oscjJDDYyOmyPau2HfjA4z3P8AOq+naqEZTc2Ec0gi2mZXbliR29Kz hR5UtDV4t7XLMt3OZBN96yiB8yJhwv8Au1JJHp93DHGGPkn9+6Q/JJGR61XsIyfM90w+tShKytqY 13YtOCsAG9htR2PJA5xU8lpJFp9rGyGGS2kEigsVYMp65+taeyT3OatiJJan/9D8uDC95I89w26S Q7nkc7nYnOWJqkv2qyea5VmnSLMcQ6O/fG3PtX+06hyx5j/KmVbmdkTnX5BpE1zcWDR3012ILW3Y FBgkjOPTkH8Ky3ubOGeBblpYfMBicRIdsrN03/T2rSCUo+ZhVqTpuyZIUW2miMcU3l+UxgMYwhIG Bn8+ntU8OqfZrBobpBDmfzDcKMthtoCkenH6mtYwVjF4mcbI0GEdvDbXnmo+ZBPsifByOVLY6ZxT E+y6jc3Vy7sbiVvPaFTnJJy3fiiL1emxtHEPmP/R/Ku+is7ovahI1dI13FBhxznLfl+lWbPTZLmY QRt57wQmVYpPlMm0Z4/AdK/2x3Z/lL9adO7tcRbq/uJJYfKS0ERzA0L+czqBkkjtjnjnpWbcyWzA 7kldgOZkXcZPoKpwsiI4pSdnH8f+AaFrrupyyul7ut4bdFit5JoQQ6BQFG3Hb1Hr+NUdZ1ScRyXF xHLJFbwboHXJXP0x09veq9mmxvGrZQ/H/gFFIbqeCK5MhM81uHMWf9Vk8qR68frWjJYwxadDLDIx uZG2yowChSPTv+dSqSSsRLFP+X8f+Af/0vyh0+9Nu7xXWlxXAPyl5AQ4HsQa6VPsEl2zwP8AY7eZ VOwrlYSB+df7aql0uf5OPEp3fLt5mNqA8+SZI0keNF2NJjEcoPHT/PWq9iRpsa28cRRAp2oo+VPe plQk3uY/WnHVx/Et/wBotGk9pbStIbuIrNJKo+QOOVH0x1pI79bG1jgEZkYDa0hHyFvWlTpPa4pY 6y1iUo2jMcst05dmOSo/nVqG8eG3fyvkR/l44dgM4roVK61Zzzx7i7KJ/9P8onxM4nI2OFKPgYL/ AFp8ENvKrxOVheZMK7oGPY9e3Sv9ufZ2ly3P8kaeNm17qQljcSqhSFUulsJgk0rgrE2T0J7+nFQX enme4a6CLFgbnXO1BjJ7mqcOx0/WJJX0/r5l3Tnurd5hJKBGy7UUelR3Vws83k291GWUZeJl2v8A WtFRvqCxc9pJf18xDZSuPI3GCeTBjckpnPfP0qG5u7uxD2k0gJVMPIsolBX65PpSqUrRuNYySXKk vx/zP//U/I2TXFNt5cjB0Q7YyRtPJ6frV1NTvdS057SwaKBI/wB3I2MOwONwPrx/Ov8AcKFJNXP8 mamPqQ7f18yxp9kne4VXjXaEkyZXI79Pb9aw5r52lktb6ArLnMR8zlcE4yvvWvsdLmX9p1Oazt93 /BLlo8vyb3AGcEHuKnvp0xlnULCfkCc7jW8aa5b2MJ4upOW/4IaJoNXRp5TIslsPLXA278Dv+lZV uzgSqoYeapiJI5Iz/wDWreNOK0sYSrVHomf/1fx3m+1RRmFnIgLcAgc4qrI7rEWRiqjg471/u2qU Lao/yCc5PdlixMjh/KmZVA54+8aSKzEtyIgC08xwkm7aM+h7USpRSskL4tJCm4ltB5ETxOVkw6k8 HnnBpTAJUlZwx3fN8h+bg54qlSRzOtFNooQWe9muViuJOdpSRPu44zW1B5KktJIU/dnYicsTg8H6 0lS98ft/3e5//9b8fEuGtdoSQrAesZAIjye3p+FE7MrRTyE+RJIFRe+a/wB3p0W42sf48QrxTuLd 7FlRlJAccAcLTNQkfT7RZZFly+1oFiQu8qngHA/zirjTtG5qq6c7BZy6eI3xbMJGj3tvzuz1/Dnt UcF4Q5khBYJ8zA9OvSnRp2SInXXcnXUYnuFVo5LZWGXYJkDtVZpWaeSARM0WS8VznG7HHI7fSuj2 bMniE1uf/9f8fYoEkR4ZX2XDHdG6ncqgdj9ayxbSS3BcSqiK+2Q7uRgdcV/vZGn3R/jesR724kpH nRwxqzMSd0xGVb0Bp08DLGGYhWHGB396bpq5q8QMtL17ZJYmn+VhhRt569M1FMiArMj/ADY5B70/ ZrYuGJsB8wn5SQCOKrJARM53uHfgLnCjHfFaez11BVz/0PxstkD+at5K0irGfJGcujAcfqKzzHIx IYZ29Pwr/e909bn+P8cRrZlhZC+I/uELtBPGarLdPZlFmZ3kd9inBZVPv6CojT1KeJui+NQSZJDK v71HxhP9WccZFV47mcOzxuyBQc/StHT6WI+sJFqKSW9KoyEuflTC4d/y+lEcQYYwC0bcAf1rGpTs 7C+srQ//0fx1uL5VKhIypIAKg5J7VgXM6pc74RKkqkZByOfUV/vXGkrWZ/j68Qr3ubAviwHDsrKA xxgA1CblknSHBK/e4HH403TVmL6xdWFuLuSUshVk4wg2/K2OKz3tpfK3Bjlm2+uKz9joZUMRaVyx DC5KJjOzl27HHtV2QWsqAs3ljHygDa2fSuhU3bY2liPeP//S/EtozHIXfcVLYIHcVYS3GWIMkaOA sQUlgcetf75ezZ/j4sRqRQ3MVxeTWPnBhD+74HRvTNTW9sIbh1cFwr8dxVKCCVZxdmen+HWgtnW6 WYW8yjMfIGD+Ncp4u0+bT9SQyrGftKrOjpjawcBhgD64PuK1jB9ET7fzOS1DT2uVTflII2V25wWw QQPxqKaQGNVUYVeQOmPpVKm+ovrDuf/T/D+OYKiuiKwJKneu4E9KlOZVbaNpC8YHSv8Af1QXU/x6 dczmthEkZmJO75gW7c0kmWUAAEk9KfIuxPtzSt7K4t0a4bKAqAq7vlH4UxU855Zbq4Y3EYARSSFI 5HTp2quTTYbr+ZdgV2V0jBPHLDkgCqiSjdKqfMIn2OG7Ec/1pqDWyEq76H//1Pw9uJPtDIkcQCJ9 4qDkn3pxFzbxGSKQrE/ySoB97B71/wBAipvqf48quzMeRnccYbPygD5qX7NLjJIJ6AZw1Hs/Mr6x oOkjPlqHAQqO/U1H5aspkQhSOwo9mwWI0FjjjldRLN5S5ALvnYp/DmtCSzkt2cPIksaj5XQ7kb3B pODSuXGvd2P/1fw5U7GVyrEEYB6rxViNEZ/PyRxgAcmv9/3FXu0f4/TrqLsi4gjkgm8zaZIxkBh8 5z3rCENorPcctNjYoJwBU8iuCxPustNEYbeF22GbzfMRkOSAcYB+lJJcyneHDbgc9OWPWr5OljP2 5Y+1FY0FxGTudY1GMMcnHNXprf7SjEiOJF4iWP7yj3NUoPYUq+l+h//W/DuMx26skjPuckRsfukD rioxKbd4zFHvyclie3tX/QJ7PzP8c3X8ytPczahcKjxrHsGzci7cgc8+tTl7OxQPM/ljcE3nOCTw BS5GkJVm3ZMtSOBCJEBZR90L0PFVnEd3FG7mSJgeUBKspHfis3T11Q1X1HQs8amJmkufLG5dy7Tj 0z3rkfGEcVxo/nXQT7OmRLHn54mwSCf1/KvNzaPLltey+xL8me1w/VjPO8LFvecf/Skf/9f+Obxw +nW2oPBZ3Ru45JyonCYVT/dPoV6fga8wuoZcPFKd4Viy7R27V+y8Xxf+suN/6+z/APSmfC5bNQy6 gn/JH8i7ZxpPF5Zll8uKMZyPmZhVY2MMt3hd0iqvGepI7fTivm+SVrHqc+haJltxgx+WhHHbdjjH 6U/7bGIyZEO8YCE/dxWDpSaZo6y+EvKyzJuDlWbGBGcimTagbb5FiK5H3uorGVF6Jm8Kq5Wf/9D+ KKaRp4m8qUq+4MzD5e+cVLZXDxTrJIDlGDM+Mhx04/Wvs3T0sePCaTOjmiNywmRiuQG56ke9UhbQ iQOqtuLeY5YnDHGB/Ks1S1sTOqlF6jzqZRliuFIDSeVE8YJyT0BFeq/CDwynxM+JPg3wTe39zpmn anrcNte3UMq2q+WzhAjStwoYlQT6VliOahhalWKu4ptLvZXLoyVRqLe+h/pd/wDBJD/gm98P/wBm PwPoXjTwx4rvNYvtRih1Caaa3iwS8I3bTHwobcDzk4Y5OMY/drxro6eK/Ct/4dluTaLqcBtmkQLK FDIy9O/WvgOH3iZ1pYuvdyk2/wAf69D9CzzF4fGZZRp4ZWjCKj+CP//R+Gf+C63/AATbf9l/4mt8 Y/CniK11Lw5r+pXC6xpkyGCeyad2mZouu5SCSAMEMncEAfzcJcSPaMS7FJWJCjIVxzg7fpX37csS liHvJJnzeEfLCVJ/ZbX4mCsbyibEyosR3YBxI2DjpT41eFI3Dbtx+YEdqzlTl7Rqx0xasWLotLC0 kTBduAy5wxrF864izhs9nY+lHs2XcuG8M8WwhsqMBh0zTorS5LK8yMqKnyzL91ge1ZuDSY4NXP/S /i8nt5NokRtpU4DY5os9ZvbSdGjcYRsMWjD9OO9fbum2kedGolseiav4quPEWkQWd9ZpPOuBHqby fvcLj5WXofSvOxZixTydzsgOUZucZNEKTgmkVzaWRQFpPK7pGVkkzuUtxgfWuhtJLi3jZNgdgnzH GSAKdWMpPQzi0rlMX5EzL5W1t2VbHzVWvMSSeeCRJtwMd8ZqVRkOTSR//9P+LcRbos7HWfqTjgfh SQQLvL3Cl48YLRnO019o6UjzlNKFizp0b3Hms/nQbHxCD8pdQeuO1bU1xI6BFiZVXIbjANKNBtam M5LmJIJIo4mDNtZBkKRgtmoVlYna8fyZ3Ar1odKyHTklK5duZN6Rxl2j3DIBHHFQWtyBOIYi7vn5 wFwqD1Jpqk7EVJ+8z//U/kC8tpYm2HOxd23GSapfvAqhSVTrJgZJr7H2TjI8VSTMCSXU4Lmbyw8s Mi/u416nHXPvxUrahIsb5MokGEWHBLg9MVDptrQ2lLY2tPgNw/lycyADr61NqdnNps/2eZCsqAO0 T8MAeQce+RUSpyUXczUkmQ6H4q1zwxrtvrGi6lcaRfWcTPb3VkxEqOeF3AdQOfl6HvXpPxC+N3jL 4paRotl45tvD19qOkW0sH9s2NibK9vd5XYZUzgEBR93Azk45NefWwsako1H8UdvyFJQlUjUa95XP /9X+N+CWCBQxUOyjjA+UVrpqrSIPmIKryVOMegr3PZS6nkOa5rmlp900kMzXKlUceWHAy+PUVBcW KxrkyGVBgoWHOah0dzSnVs9TLd40dI5FyhPJAxn61pB7eGLcylFA+UDtjvikqN0VOorkkTzSqeih lwhz8vsTWNGZjczxo5EkfGR86SZ64NNUbMzdVLQ//9b+RDR9KvNSMvkxmSa3hMsqZHQH9aoqs+my zpMGVd5IDjaQe4/WvbdO0jznXUYj4dUEsMzxrlrc/Ox/hB7irqxXFzbJNAQVdTISD8649uvvSlS0 MPb31MyS9fIgJ3SRHEuB0BHH40G3aQMzEKDzH6GoVPl1Eqm7EmLJaKg/fuBtyRgDNURBPujHlsPL OVUDOT2xSVPsaKpc/9f+PqHTZZCXJbz2bDxdAK6RPDn9n2BndJGJOWkb/VrkdM9OK9SVJ20PMjPU 8+mmt4pZo0KvLIx27ed1buh6tcWsUio0nluvlzQkYTKnPT2rJ4aUkkVG0qly5cXMcrB97OG+4uc9 fao0ijWVJSN8nQp6D6UlRcZWOmNdO7Ni4gje3WC1m8i3YiQxbANshHzEn0rFaGWCcQsfMZlyoI2g +9VKlqJ10tD/0P5DYtPaV1KggdW2j7oq4hCsIkkOB8nzdDXd7I5Pap9SIWxJCySCZkz8y/wHsRVO W3UMx8wtIBgLnAo9l6j9oaljIMNGCm6NMOob5/piqjAPJvwIt7bQjAKT2xTdPyJdWPQintJ1cpjD HlQw5GcHNKuVuUTPKL1HRuOlRKm0rmU6mh//0f5B7xnSSJTHtWZsA9Mmp7M+TNIksYY7cAnoARXU sPKpNnHzxUUjSFrDJtVp1PmNgMBgDn7oqY20envKY28wE+mMj0qlRklZGt4LqSIUmykE6nBBaIDA FRwRzWdyxik2tI+WGMj3+lP2UgTp3NJbiKSXpJHcRNtLbeJRjnH61mavbiWIMLmSBXO4PH99yp+7 S9lIvlh3P//S/klSEOkb9cLhX6kD2rdQlofIYsW2/Lk811unNdDJpLYZAPs00BkiLSyv5aSbCQfb PbpWpeWgvHhkmjOYHyhI+VTgj+tc9bDuXQ1o1UiiJY/NaJZYtkLkMQR94dquLPDNEfNm3Iwwmznc OnWuaWHmdsaySPrD9l39qP4mfs0/EPwx408Aay1o1jcpFc6VdRqbDU40+8JSefujAAI69QcV/o5f 8E9P+ChXw0/a/wDgV4W1XX/EPhDT9fvNM+xajpP9pv8AuJ0AWSFw+GDKSy9P4c98VzLLP3/1hJ3t Y6JY9uh7B2snfY//0/6ffE37EP7FmvfEFviNqWn+EP7fguWuBcx3kKLHMzCQSZJxkHBHpgegruPj b8evAH7K3wc1/wAS+GfF+iPY+HNHedbCDUY5ZLpo0yqZ3KNzHCjkDkDIyK4Z4GblzNanYsSo+6mf wAf8FHf+CkXjL9tf4hbtU8OabpmjeGdRllsGSeaaK6bzWaMBmJ5G7k9PlU4ya/J6ez1O+uZbi5nK xM5Y26O0kKDJwFzXTHDTcUmnoc8pJNyXUnWeO0UwLL8wQscj7g9/1rLsbG9vVe4aU7YSXEg+VCOc c/StXg5R1RhOSe5alWWSIG3Tz0Bxvj+ZSQcHp71HBp83mJPMC9wcbzjbhR0B+grGWGknsYqEPtM/ /9T+VKe48zzM7AIG2yZxhabFo0DuL10V8LlXPWP6GsI0Ki6GChTW0jTvIhujjtwTbPCpEp/vd1xU KRAxGItvdOuRjjqARUSoVE9jWMad9WIsTyJJHdMqo/yoFPQdKqx6bJG3+rNzsBYeWedo71Hsqi6A +RO3MWlmVlaaEhVgGJFLZZSOoIq3Zavc9LNJ2d8Iicq2emAPfNP2VRdDWPJbRn//1f5YL3UdV1AI +pSO+1DB5Up37EBO1fbGenvVey0x2AeNSI85UjoK41SqPodCkktWacx8naroTn5Dx1rIuYvLkO6S RVYiXaD6cYH5VrHDykveRm5Q/mEtbpJrllCL+7T5c/eP4VBc3a2jkuGjjdwHbbwOfWqlhbfZ/Azv C97mwlxLDwjlY5ExndyQR/I1hyadb3chXfvCyZYp/COwNYvDPa34EuUHuz//1v5VoLSGyGzcHJ+4 M5araWdxLDE7YjUyEiQjL8dsVyLCtbIyapN2ZnTQXGCkUkkbCYjcwIDD6elKtooiAkvPMmeQo0bf K3TOR7f4Uvq8lsi+WmtP1LkVtsKeWcMB1POKsyGY7ECs7rnkDHNYTpS7fgUlRM+fVPsUkKFSbhyS FPUgYBI/MVcS5spVK3Mk0Luc/vl2yZxkbc1Hs9LW1NEqV7n/1/5WrOCaS4mu2+dRJ5cLkk7QB1Pp U8EludS/eyRC7EJOZI97FRwMHHHpXhVqdpnVFwS0RKv9q2tz9olOY/Jkjjt3j3RlZAQGH1Un2+au bs3nma7e4gFvbxP5NrGx+dwP4sehrBtKTuh8sGtES2UUSzl4nR9r4YKclD3B9P8A69bFxsSN2k4T Hy5GTn1FYKNp3N7rkskZVvpt5qCy38akx2YAkhBAlwxIBx6e9TTWU4ZXYoMDBQNkADtiru+VxROq Z//Q/lESQXUq28WUeM7ZEAAU9hS6rptxpkdnfw3ds8sd3mSMSKXGAcLgHPcH8K+WirKzPSvKWho/ bkitrqe+jBjuYMt5iZYA85UdjxSXcc/kWbWHkz20kXyOXDXEOM5Dj+WawnG07nTdclio0vlsBKy5 6HkKWqeeON0QecymM+aNh+YdapOyaEnqrkMlwblFhkiCuE2NIBgkDofrREv2JHkiAMCjNxIzBXI6 YA71jBcrdjeU00rn/9H+Uy11draAxwl1glyVVicZOPmI9atz6lcz/ZkZ0e2iULJGg2hjnOT+dfGW kqnMj3pVY8lmNudRaC4kuY0WCAosaRxKXZeACxPucfSm+ZJBEzTTOq3BDEyOfnJOQOf5UON6vOgh XiocjZhSFxdM7SSSIBjymPyrWzbNJc/KxjSCKPckhO3P+zjuf8aqcXJm9KrFKwqtazfLMFco+Ewu ScVt69dR3WnW9rFqV5FcW6hrluFjSIDCKpOeOD+VauTdNRfQ5+ZKo2f/0v5Sjp081iZFnZUii81b pMOUA/iNH2eKGAs1yJC8A8pwQJCSK+EjBxk2fTOcZKxFostz5LRXh37H2Q5bJwB3PvUMyXEj3B80 AF9ojThQAeMVVScrWMnoJbeXMY4rieVFjkV8QcsuDzx36dK1mljkiurOKY/Z7s4eOQhSwycZ9PwN QpNLUhuPUyCQqSQW/LxfIhcHGR3BqaHUF1EtBfLIsqL8rouEYqP4h+FK83sXGzP/0/5Q7WK5vYbq O1QiSMMLcSKVWcr29geefaplBsfKKRlpMZdP4FbuAa+GjdrU+mjypWNW7u47rTrOHULcxak8m9ZN 3yRrj5UUd8jmuecxwyvCA0mDhiq/dzWivukP3WTm3iMbYHJGCe+feq895LbRnMSS/u9khKgnbnjm pd76j8i2zWtmscTAFLqATewLDoRU9lbR3TXqXTQLZyRoyOQWl3KD14/3QMUW0uLmiup//9T+UqOG zt9VikubmU6XIgj8u3TMmT/EBnp0/M1qm6SCMxxSNNaqx8t5AEbHrjtXw0ldWPp009hunt/Zmn3E t9qJvIb6YyQQCHmywSASQOeKoSX8c4cN5g7RMowrkHv7UuSJvFxSLtpdRWsDfboHeEHe/wBmj3XG P9kd/p7VQmmW0nMsM0zw3LBUR0w7dcFhzj/61NRUdi72Vie3t9zFJAWDNvDt95Nxzn9auvBHArrI zTZyolcBVjHpj+tU1Z2Ef//V/lXjNokrlI3jAjUfe3rKw4J9vWnzS28li8Vu0M7Fw8s0LbmRc8Bu 2c8c18OrXsz7Amg33FvIkskZUxCIedz2wBj2wKS0vwLQ2bTRJe2U/wBnISPYrqOj5Hc/jWrlGwPQ 0xDFqLNbytuuxHviVFyGHQ7jnjt+dZkCyRm9svmiukxHuKnywcdux61vScVFXIbXMj1H4X2Tw6xb TXdwm2DMcZjTeQ5wfmHQdB+Zr9JvB1kkQ8OxTyrb/aNStJHTdlY90yYXnjn5cjpzX9VeAUoxybHy W/M//SUfgXiy4rPsJHul/wClM//W/ol/4J02dnZfC+zt4bZo3lt/3ZAG0BSBK+BwNxVenXivmL/g sHqVlp/wd137Xey2kp33OleTIss7T+SwXCZ7MAM9q+24crSr+I6fX2r/ADZPFUacOCJQ6eyX5H8d fj+eG4ivvtdzdRqxDPcQ4kdvMAdc84KjO09uK/JX45XLX3iG/tYNLubqKymY6hrMrf6OZvlUlBjP RQue+DX9O+LdT2fBTpT3bj+dz8B8LvZSzlzh0TPmi4l8ido4Y/nUbgG+649M1NbNb3d1DIloY51/ d/MdxJ6e1fxnOF5Nn9CVqiTSsdrO0cVuEIKjaFfaN2KseHrY35uorOdlNq+ZJVQ+XHgDq3Tj8a8q vCN2PnR//9f+LG6ub1JIlnKlbd9u5IwQwz3bHI+tdZ4df7ZcHzBDGFbc8Y7r2Kj/AD0r5iv7raO1 Tjse5WPmW9lbrpLbfs7F1iVTHCzN1J9f8RXYx2hNtfS2mqQnUpLET21n5ZU715aPewABIHbPQ4ry aszaEo7FnTbv7XbG01d0je6ZJRBKVeKzkVRlUcDJXIJyf8K2ZhHNpUMkEqs7TtbkDDeWFxhj9Tkf hXDKd72R1wceUtWMaIkMguVfySRcDIKMBxjj3qrc3lhLelHiK5yqk8I3uvp/9as3USos6qDjJWP/ 0P46Z4riFLSZBG0MUvmvBIm5JR05/L9KTUrDS746fNA1xHZwoLhUmj8sR3BPztGB2+teLL4Wc9OT UTfmMMSGBZA0PkDe54bcVz07jrz7Vy8EFw2nXAYWs0W4/YpJW2CKRjy3HXoPzrEpzZU09L9LKO5a U3ge8e2uX3AKm0Z4A6jsPpXpdhpUGt6VYq0nl/Zro7TM/wApBO0qoPbr+YoSvoilPudXa20sDT2c enJYWtjsEMsbgLcNj5nAHQ57980Cwa7u7aK1hecyORc5O0nOcEHuSRz9a3hEpSTP/9H+QrXbnXPD GtQW8+iTMZ777JBa3SEW98yqJCq4IY5BA49RXmHiHWNRuNSaY6LHb3t45kj0jTpPKVAOGQKehHfJ 6muSlG5m9JST0scVqciKH+1K9lcW026W2nOHGe/4f1rR8Oiym1zRbz7epj0/UIb10skONqEbg3A3 e+M9K9jBL9/TfmvzOavK+Fn6M/Wn4dRXTeFdJ1mKytn0+3uBaMVb95KTGkzZB9pCBj0Nf0+/8EYt X02112HQbWPUNOu9Pk82zju7J4BNb3HzHYD1BMxIfocnB4r+5OMIPEeFD5elNP5cp+I+D0oUPE3E 832uZfO6P6i/jGt1d/DLX40V4nv9FuHeJWxKUEROPy/lX8Ef7VVukH7Qnjo2tte2+l3s0d9bi6Uz CadoIDK6y7QOSzjH+wa/HvovSUc+x0L/AGf/AG5f5Hd9I+m/rGFdur/Jn//S/IfxBpt1qU/k6ZbS LOXwpk5mjXALFTjnPpWc+nyKIop4iLkJsaZiVJx1yvrX+vMV+7R/m6pcvMU57MxXdvbNAklvI2Xn Z8TKR2A9D/Soprj7DGjwoI2aQEQSHLtzwGHXFDVjSnIrXEdxPN9skgjtjcnBSPjbx2ySfWuhtbEW 9kzSTYDx+UiMuGk9z/nvUzi9EdMJJwl5GGum61ukW2jg+zafILlrpJR5sYfGFz14x0rQj36NGNRe 2lkjkkCy7wzyOzkKu36k0ON/dNaTS1P/0/xz1E6WbeWeI7Ly8C74niJX5WGRv/GrsU0EmnR6fFBH cyEeaLhm4tumQvPtX+uUotWP8/YyvoQfYLs2qxW8xtG+0q5ZRtEm085rXtptTEk0bbpFdliaHOGl b+Fgvf6gU/Z2Vkc053bSK8zanZebBcaberIJMJHMhjxnocHoKgsZEvgY9UiigYybflO48Hg49qrk 7Mzi7GfLfjRpNQltYvMWZPs6kJudQ3ycD3zUkNpHYW1tKVd3VNpVjlyT1FOMOVg5Ns//1PyDt9Xv pDGps/sql9j+a+X8vpnpwe9UtT1myt702NlBOYgoSOVofMlmA27ivHqR71/rxy2P86ubW4ahAt1d 2k6QzZWEQumdqSc5yw9a32h1KC0JZNquQqbT5mxAABn07ip5LPRm8PiRcsQmBFIsgDkMc8xMR0J7 ZqZrmOGW6SISi4wVdJ/9XImOGQen9RQk0WtVcq6dZv8AYNc+ypp8U80OILe7Pl+aFBLlOOvXgda5 1NIFzDaPNCkEqsJWEabRJ9R/jWmnQxlzJH//1fyP07RWjmmvJ7K4e0t/9asXyFMnAJ4p19bwatcp NZR+XHazZMU3ysQvTHv71/r3GNz/ADmbsrk0eo3GnvPFcQpKlzF5eHXcAB3B9fr61LN/Z08ljPFF c2qpH5c7qgmd2P8AEq5HtxnitEktjlc7aGbbrcXWqX1mZ9625Pk3Lwm1ZlxlTjpkj0zitu+eCPTG tEsTdXjMCLlpiEUZ+YbMc59c1p7N9S1Ky0MnUJLSDTZ2TT3vFS1w1qhOUbAyQB6c1q6A1sumwS6X BJNLHa/aJ4Z28iDL/dQDGRjkc9T2FUoWK5nfU//W/LiC30m/09muppLfVklfzbARZ28DB38DrkcV WvoItMS0l2lllQLIHO7aMnkD8BX+wvItj/OBu+rHpfy2tq15Ag2PuiVGTPBBUnHpWfaxpPbHzY3E zSbklI+XBqzLnK91ZJZuG3SvuGMAYQf7x9M4pumXSae01pezRxKCtwGnj+WZnIVADj3HXigylPTc vajqF1YpLbrZ/aZb1ClpdwuRJEyleAvQ5BIwelFrp1xr9tLLLDiOKMQyts2oSB0JHT/69Bjztto/ /9f8nF07+z9QV3R/PhXzYIYtwVU7EDqR0rq0vNVtri01e2s4Tb3CGJJFmVp4HBAYspOVPoDz36V/ sPyJux/mlz+6VdVSW6uPmAlLZlkmZt0zuxydx/z1rDu5J5MRxMkZtfvRjqQOuD60OmkyoybWxWuZ JSsci5fcoI83Iz9axdWia5t3eO3ddQkuohGIpzs8tWBbcD69MDNaRp/cYVJM7uy1W5XTo1e1tobt kMLmJBmYDgE+hxjNZY0lLy8s4linkv2zA5CEw253fxDsOnNaxp9jNyb0P//Q/JVdKmttQvRc/a4J Y4jGsYyIww5wB3B9aR4LpbUXjGVLaMFnCJkyegPpziv9k/Zs/wAxZOyOk0S8W4tmNzEI7lvmVN24 Be2R60/UtSEUqI8W2ONBmVVG08nimqfcnndtjn7u5WK/F3BJHEmR5DYJEwUDcdv58Vejh+0Qy3/2 4zPL8ykrl4fU5/DgdqpRUdjQtaw1rcrZ6jDiWVohCH6AqAM4P1HSsCzjnN5IYrQs8aZiyCdxIPzD 6U7K9zpje0V0P//R/LODT3a1Esjy/a2ckb/usM8iqepXDwXNn5NsBJCMIOWV2OM7q/2ZjFOR/mLX krSY7Spr6TTJ4m2rHBIwvJEbbwTxk55A4qvZbHiaOA71BwJhyzZNbxgr2RwVp8sUb9xp5a3smkj8 woUjJx8xBIA/z71vtoMk9u1vbWc0UGQsl75RFuGIxjceD2/SuiNPsefUrWZLc/DuxsZbW7muIjIi hwltP5xJHfI4GfSnXfgfUEt4Yku2uZpLj7XLawwnzbK3PIMx9weB9Olbxpo5J4hpn//S/NmLwVL5 l4baO5WC1LMs00uYJQw3bYhzyPQ/hmiO2IMFvPuklWLZCyjltuAS/v3/ABr/AGz9kj/Jf6z5lDUd JUyrutmuYwfnjZNwRh0wPXPT3FWdG8OtHdTef9sto5YsnzEzLErDjapx1yOatUVylPEu5pnw5cww Jp80U80MwLJLIuySZCSc5wPzqGz8M6gs5xbokcz+TEy5YMBjrxwaUcP7r+Rt9Ybcbd3+hcvvCGsW SSSuI4ZlAZEDCQ4zkHI4GRg4qlqOim6/s9r65W2eSQLEjyff6gjA7D19qpYRmWIxai7H/9P83pvC 97cWLvbMsEizG28rzv3pwTllIz25B9xVWfwfaq7DSWuY3k2JdTXV0bowyKMMcHoM9sfjX+3P1V7H +SUcZEvX+i7fKN6WnuI4l8hzjaNvCtj0wDz+tYMug3EpiKpt/e71JClHAxuFXHCNbIxnj6d9zqD4 P1V7rT2+1W0emC1a4PmTKiblz8uT06Hj296gbwzFO/8Ax7xRxuoN224zxR54BJH+fatVhnbY5pY2 LZz914XuJyY7dkEUR/eJEvlB1B4I+npitSHwuNOhNxIjI80RVJ1j3EkDIX8yOamOFe1i/rsY6M// 1PzJsPCupTJPdeS7QQEI0iRlypY4G4+nT6Z5rU0vwtqs7XuorNbQR28ZhQXEhUuTkHCjr0Ir/cGO D1P8gqmNVrFRdEZLS1isbeM3MIEEknmkbgcA4z9PxqtcaNd3IbSXSGwmtT5iSuuyWVsj5Cw6jHTt itvqj6mUMbbUkvfDFzdLGLh/tKsUWVg5URqpGcd8e1WJ9IvJTDaafay3iQnbNCYjIqjByeB7dKv6 rJaGkcdC+pLp/hOaaSW7KTW01nDiSPbiIszAABOxGO/vT7jw45jWO4ubdppT58MhQR+VnKhcDuSM +vNJYUTx0Gf/1fzJGiyC7ksxHLLtjDeftyhJGTj6Y6Vu2XgsXtjcbJd9w1uZICZhbqxXr19Rngc1 /uYsLZH+PcswinYyLrwxq9lDZrKYLZJZjHKzkytEAQAfl+voagk0W8uL2e2ij2RQuI471ziK7GAS y9wO3NT9VZm8xgTXPh2ayktj5TN5uditHv8APOccEenp71pLoME1lbpM7ae0UnnXKlDPHJ1+XGM5 7ZpLCOLOepj4tGPZaTE15LH5KTmdtkQZAVZeygH1/rVrU9BuYbqEy6f9msiVQLbp86diWXovtW8c K0tDn+vQurn/1vzEh0C9N5cKsLTQQylY5dnlq6jkHafbtUkeh38E14v2dZopIxFbSPF5ot2Yckj1 44+tf7mPDu5/jpSx0HHQzV0++WL+zsRB0BmnXb5DMQc5HPYjpWn/AMI/PPZmK9uzO80wACqYplXg 9cnOMdf0pLD9zd4/QdD4cmsIrmZkvLu0glEaSvF5kjB+FRQoySADnr0pz+D/ALDbwXmZZobyVlSa VdksOMfKWwB9B25raNGysT9fSZZ1jw/fs1lfTQ3Z3Wy29mmAsVwi7VDqejYwBkGsCDwbcarqkFub yOwS5jdpJruP/R12DgM/8OSMdD3qZUL6B/aCR//X/KW/8FT2wure4e0WWDL2cqyNLBdMpwAu0Hr1 zVyHRmGk6Y9vbSWF3Jbn+1GI3LJLuONv0XaD9K/3UjSdrI/xtqY9scNLvbO4heQFjw2+IYb8vWqF 74Vae6N8iTCeTIyW5H+8PxraNF25Tm+uvm8yxd+H7iGKDZHIZcBHQjLEn27Dmmp4UvpY4mKEqkn7 9WyC3qF46jtWiovYv67JalZdN1GPzIo7WMwEkBTlWfHcnGM1dtvCWq3cczRHyCsPmohxkdsk59xW 0aQPGSvqf//Q/Kx/CVwJJYdRuS93Gg2mDD2sp45J9vamnwRf/YzPdfu4ZZzDbPFGWSXbgnI7dev1 9K/3qVPsf40rGN7svv4QuLW3h+yQrNcTxlPskMLST4T+M8Y5wenI2nNYx8Pam1rNKtqrCN/lVF33 LDjJA/OpdLXY0WMdjLtvC8v2lWk+aO4HnbcESD/PfNbE+hzWVusktuwy+2Mr8wcdh9e+K2jR0tY8 v6zdliPRtVkuLRLJAlhLH5k7TSqI95AG4rjORz+dUrzw20V5hJBMp3bp4xsiBHoDzg9qXsXe4LEu 1mf/0fyfh8L3NzGFli2oJM+ZJlV45BI69hRLompuqN9hJhSUxCcH5Mjpx1yf6V/vd7F9T/FpYmwJ ok13bKJYTDdQSlJFJDbcdB+WD+NMm8NaqmyORDhPnjL4I56DjpV+xsUsT3K40DUpN0klokPlNibZ 8w25xuJA464waWHwtdDBjAWCab7znYm0dcev/wBeqjSsw9uOk0mdpxELaWY7hBbxph2YnoBz71YX QNSNtuukWGNHMIdE2EbTkgn1/wAa2VIiWI0P/9L8jU0i/hu45EiAgXcFJ6nGAOOnOT+VF1ok7bwI DF5q75HjG3n6V/v0qdtj/Fb21tytb6LfBYpXt5Pv4XK8kepHXtT7nStRmlA8pApfap3Y49cU/Zl/ WOo2LwdqUgvJ4wLkWyCfykhPmbcgEDsTk98VctvDN5deQZrG5QNKY3QxGOWJR/GQe30p+zYRxNtg 1PwzeAubCHcsbARqzAFh6H3qrL4Ru4prWS9ZoTcQiYxb9rJk4GT0HQ/mKfszRYhbH//T/JS78Jz2 pjm+fyZU3rLj5QMlcg+mQR+FUhpF0rgWzechO1vPQDLd9pr/AH99kz/GFYnsXZPDMoWK5nhe3KMN rHDh26AAD19DVHVvCN2sUl0ZwJVO9oJE8pmzz8oHHrn0o9kxfWnshtn4amk055IbW6knB3kwp5iq vTJA6c984p8nhm8jht7pgrbgRPbKcyjHT2pOnYTxHcvXvh8vBZz6RHOlyltmeGeQZDjJ+XA9MfjW Pa6XcxiPzYXXexMh6YI61LpXJ+seZ//U/IiDRJZ5nMUcs7xHJCIWMY7lvQciq954dvXkDKiuZGwT tyygda/36VK2h/i+sQC2E8UZjigaXDbWLLtYdjUyaNdb2fYAcZGRR7N2sT7ddxItJu4rsR3MTBpM GLeMBgwBBH1BoutFvUuJY0jZIyuTkfdNHsdNgjiEmV4dJ1VJMQQx4PWS4cIo+n5d/wA6guNGubuS JSrq6thiOF/GtFS01G8Rfqf/1fx6uNFuI7aeFYGklULIssabtgBGc8dDnBq1aaDOqqtxDJGskZBA 4c56Mp/Ov9//AGXkf4vLE22ZknwzPa3DOkRQA7o2lj++OcMfWpBpd9iK4t4HuYN/lzyKAFiPYn2p qlZbA8TfVsS50/UhL5MnmxZIO2P+EcHt61bi8PX0k0dxMftLId1rGzfNEMc5/LpVqD6gsQtis9jd 6rOLOG0nS68tphA0LRg7B82CRg4qtaaDeMjS3lo8USSFCSQd+Pp601T7h7dXsf/W/GybSZJNqrZP BGpOxnTYZB7U+10ifc8Agcu68yBciMdOvav+geMV0R/jA64+bwxfqkVtNaQQvlmMv2rzjKMgpkY+ X/6/estPDt41wEEQbJCkD7qHpV8kuwvbFvUNE1KNJbR0L/Z2wyRn5xg/qKrt4bvpYVzuDlNyFUOQ B2NPkYlXHRaTfJGI442jGMuc/NTI9Avo2lmEEt0ZPmk2IP8A0Gj2b6h7e2h//9f8dY9G8iWJ7aIx jyQbpJPmO8jDAe3J4pt9pxcBY12hMfKiZ/Sv+g5QS3P8XPb92Z03hxxgtC3nsAYsLgpmol8OXksi hiI8clzzjtjFHKivborTeHroSyiOJ5XTB3yHMT8fwj/61PTQZJ4iwibJO1QBtGQcHg0vZof1m2iB vDl3IywtbvFtXIcEbH9AKSPw54ikt5IJLOIpJP5cGyYC4Vc43Ff6UnT00NIYlJ3kz//Q/GUeHr21 gS28tnRDtMkq/OGHUZ6/hVU6ROsjAIyqOvHWv+grkcdD/GKWI5ndHbaH4EfxKpht7y2s7mFd3l3B 8nz1HLLvPAP155rF134e32l3X2KaJhOJCFMZMkbnHQN09/SpcG3Zoj62ovlvr/XzOdPhrUpE8pQR OsgRFI64Parj+GtaN0kV1Zy2bxYO+dNu4DHOOtWqbsH1hbEt5ol6hZzC7Ln/AFgQsCe54qhNpGql FAt54YWwRNJGVikGcZVjwen6Vaggdfuf/9H8YX8M6lLaSOLfzYoSFWXIA57D3rMsfD95KJljxJPA wR4iS0vOcbQK/wChHkd9j/Fr2/S5ctfD107Sz+UPs6EIXBBcsc/w/galTRr20cxJbpLDKvyiaDzS wOeAGHB9DUOCF7fsyyujz20cKGxkjhmUum6PC8HFVn0G5mzcR2kojD+UJMfumJ/r9ahwfQf1jW9z Qm8PTiCMLAwAUM8oHyoScAN7nsPauE8X+A9f1fR7zTtKsZru6lQSxRwoWlcqeigdT3weuOtcWPw7 r4SrQS1lFpfNWPRynMYYPM6GLqO0YTjJ+kWm/wAj/9L+SXxL8C/G8suoyafot2bufUi5EpPlbjwQ OuDwTj1rnl+CvxBijmf/AIR64VbbEU8zt5xBPGSAOOR3r+7OIvA3iDFZvXxTi4+0lKVnF9W331sf yngvGXh14KEKVRSUUldSXTb0v2ZMvwI8eRwF4rJQzgFWcOgbPXov8qtwfAvxzDEt1DpEM12YiXX7 WX8nBxlo8cDp1rwv+IE54+v/AJL/AME9JeMWS2t/7d/wAb4AePp5bOW/06aIRhnby2d4ZVYYVigX OAen16VYk/Z58YXb2UNvY3k4aYmWRLd1RAMgKRgE5+naueXgZnq0T/8AJX/maLxeyST3X3/8AvR/ ArxjpDPHc6WiRq7JGI0dpWXpllIwD7Z71jyfAL4hXt1K0ekyTWdum+OSFmzPkD5fL25BHv6Gs34E 583e/wCH/BOmHi/kiXLdfef/0/5ELP4CeOds8X2EidDk2xtnZh2GX9OR271q33wB8bQ21sn2BIC7 fvhIr4XjOAwHLZr+wJeBGfPd/wDkv/BP53j4vZJHr/5MP0D4FfEbYi3FhD9nHDySl/NUZIwSAVGe 1drefAXxFHpbywaeZbuJ8SiLewUHpyQOfbpUf8QHz5bf+k/8EH4uZHLRv8TjF+Avjy4juLyDRLy4 is7hQ5SJVVx65J4+lS2fwQ8fJbTTXGjX1tJBcLdQxxsYrkhTujkVugKkAj6Z7Un4EZ+1aX/pP/BN afi3kcNeZfej9Rf2ff8Agpv/AMFGf2cPA0Hgvwx8R/Ek2jRQJZabZ6sya9c2aoxEcSPMrmNQDgAH aFAAxgY9xtv+C0v/AAVW+1EWvxF1OMFlE/2q202W2RS3RQ0DDj1XmsaH0f8AGYeMlCm7vy/L9Ox2 /wDEasAqH1dSXJ6n/9T8Lf2tP2vv20P2xNJj0T4y61DrlnZ6ot8klvYW9uFdCpVD5UasynB+9uPz H1r4eb4OeJhHK0mmlZEjA835o1LHPGwjP/6q/r1eBueQXJTWi7pn4DT8WMigmnJa67rqc9qfwC8a xxwT2+jXDXV3x5HlmNmQ87lH696kX4IeJYwqTwBFSIRmOVJFmJx1XAOcce9SvA/P73e/oyn4sZF0 l+KH3nwK8QR28jWySxmJAo+0RO/nNwRyOmenP5VWl/Z/8UT29pIsOyW4mVHgJaPYCMMCdpxg1v8A 8QNzze//AJL/AMEyl4tZEtOb8URyfAvxlaAxw6M4cSmPY8wZyozl8ehx061pj4Q+Nms5UNnHdmaM W8cKQNvj9CD69eODx70f8QLz1rf/AMl/4JK8X8hStdff/wAA/9X+S25+Cnju2hsvL8P6g0V1+7D3 CBA+3h3QjOQD261q6B8C9WlilW6gnmdZWR82jwlMcgoSOcZHIz39K/sP/iBWedf/AEn/AIJ/PP8A xGHJU7pr/wAC/wCAYr/BDxcLkw2+nX62iXDf6RO5TcxzgDjp6fSpX+B3jmELBe2iz/vt6NCzFkTq FY7Rz9Kb8C89e3/pP/BKXjHkq3a/8C/4Bb0v4HeJZblVGjXTNNP5Uflz5RR/z0buB7dfatfUvgR4 wj1OO1sLCRLhRslikRkVwQSSTg8DHXHrUrwJz1//ALP/AATReMOSWvdf+Bf8AxG/Zz+IcmDc6Tdi bzAytYws8PXO0sQOCO/8qml+Bvit2t1TRLiNhPtDnlZFX72ApPP+Nbf8QJzxLX/0l/5mi8Xcjkrc y+8//9b+UaL4FePYW+1R2lkIZd0EMVxbvcebuHc4wpH0z9Kz7L9nfx5p00WnX1tciC6uC17dQxER KJMuApPAwcDuRX9ivwLzxdf/ACX/AIJ+CPxbyS1k19518P7N/ieK2hksobvULl3kitrdV3PMV/hw Bngdz+dVbP4DfECcLDHo9wxcu7zSWzeVBsHKAj7xApR8C87vyxf/AJL/AMEwl4uZJ9pr7ylqHwK8 ZNcWgn0aTaX2PeI7pbRL2LfLubPoBxTf+FCeM0nVHsbiG1aQoZVgky+Om0Yzzx1rR+A+d9X/AOS/ 8EX/ABGHJI6Jr/wIsD9n/wAZajdRJYRsPIRmaK4jdGnKryBx146e1EfwN8U2kMqf2Y8V4wARvKkM LMxPUkDAHtSfgVnS0Tf/AIC/8zF+MmRPqv8AwL/gH//X/lsh+EHiqxlWGWJJ3EGZBYwsWYkfcyTx 171ZsfgN4/iW4N94d1O2k2GeG3ltGd5EIJjZsfdB/I1/Yj8CM6tv/wCSv/M/nqHjHkPVr/wL/gFa D4HeMvItr65sxFGrM1/DHblW2jIXYckA5xnPrTJf2cfGt5Nb6o+n3FpazTLDCLa2e5kfOMFiBgH3 9KIeA2dW0f8A5L/wTX/iMWQt/F+Jp3n7PfimFxaRQXkc+8KZRGYWc9kCleDnFYE37PfxN/tCO61N J3trhmhE89q7uQg2gAjqRgDjion4C53JWT/8lf8AmZvxfyO+/wCP/AM+4+AfjAXFv9lMEi+aEnjk t5bW6fHBUBlOPyq7c/s/eNJru3trXw/qUocqtu7v5BvnJwyj5eQD/wDqrF+AOdOLi27/AOH/AIJl Lxfye6af/k3/AAD/0P5aJvgB4rRp9OfS0tLiBsMxy4Qg4YY43AeoqBf2a/HX+jM1m7Wq5mvLpLd4 wijpsB6gnjPFf17H6Pmb/ab/APAf+CfzfLxkylaJr7/+Aaul/BPxstvPDfaFcQsZwlqUtjdqY+MM cMACeTzWtdfAHxh9leRoZGVWV41axkijlGfu7+R9T+Wav/iXzNH/ADfcRLxlyuK+Jfecy/7P3jy5 vWt49PhnmDBoIbXzJCE6sXBAPA644rTv/wBnPxtPY3MaaXdNfIvlWtvbqyq2cfMzYOOM9vx704/R 6zTpzfcZT8acsTvKUfv/AOCSj9nD4hW62ulNbWttLdIsKKZ3u7pCQMgqF/nSD9nTxdbWpVIlLrmJ 5nhZWlOeqnPIFD+j1m23vfcC8acncebmX3n/0f5jv+FG/ETR7vy9Lsr1JJLdFubyGzJK5HQndjmp L34I+Jr20+z3aIbndlRPbv5kjf3sDnj1r+wJfR5zZNX5vuP5pXjTlEo2Uo/eZtt+zf4slt2CxL9n t5A108aSQSyc8YDKc5pqfs/+MLjUy+n2E0VxAVgjguZ5Ybe57cDbgdec1Mvo85ts+b/wEzXjNlN9 JL7zdtf2dvElvdyR3kFvFeCUrc2yKZ4XbnBVh6dOOKZefs4+PZ7q3g0/T0uSW3xolvJGzjB3AL3w PT8ql/R4zXZN3/w/8E1j4zZQ9Lq3qZ7fs4fECa9aJdMmt7Bcx3NyIJWmt5ccAIVxgkd6fD+zX44t g8EcesXWoshcn+zDNGi5+VsAjaMetXH6O+a7py/8BNo+MeVrdx+8/9L+aN/2evHlhfW4u7C4ci3V vJh06WN7gspIJZu5/wBkEe9bNj+zJ8RdVgV5YWfSrmJvN0+SGVbx3GSPJx97b3r+xF9HfMEtXL7j +dY+MWWyfLFr7zl4v2VvFljBcxtYXomhWS6hmk0aTAQNxvIbGB03cAVQT9nrx39lYzwaZBPHLn5Y pcSIcYwcYLH0zitY/R2zFtOPNb0CfjLlcKbblG68yxZfss+PFtb3UCZHFtdIzTJp5eKBXIGxhvwC TwDnjirC/sw+M21C4lnm+zRxSIUikgWNsEfdIL859e2a7p/RszCUrxjNeX9I+UoePGXwguepC9+/ /BNq2/Zh8W6ndzwWwu2lmf7Ja20SLJ5ki9diA5Y8gcdc+9R3n7L3jPTru3TV31G3VgVDzab5TW3l 8OpUknAPXrip/wCJa8x5vhn+H+R2/wDEd8p3dWH3/wDBP//T/m+g/Z38fSKW0+0juraN0DzNA0IZ W4yCf0qO4/Zp8eyzxRJ4f1O4kSfyZxZWhnEoYHaVI6Y+vPbNf2t/xLXj/wCWf4f5H8srx1yl6e1h 9/8AwSoP2W/HMV79ma0v9OuJ3EMMl7atICScALGOSegPfmtGX9lHxnBqLWmoxXFtPDagEPpsls0z Ho+0nJ9eBR/xLXj/AOWf4f5A/HTKYv8Aiw+//gmen7KPjaK/lks9B1mVPLMiXEltNH9o2DBY4U8Z /Diprb9lXx9bzJLqWnQmKX99aEXPmTIxzxsbGfz4q19GrG9VP8P8iH48ZX0qw+//AIJXh/Z48XS6 jPG9q75RohaTQPFKJFIyVdSScc5ArVuP2UfE7WC3IW983z/tKMtqY432kfu92c4z6ZNKX0aMe2kl P8P8jnqePOVRi26kX8/+Cf/U/nJj/ZY+KLm2urzwxFDbyMTasY2vJMAddgxjPvV6T9krxvf28t9F oGpu9tEzS/ZIHihmK4BIABJwPpiv7Tq/R0xtBqEISvbr8z+UsN444Cs2qlSNumv/AAR8v7O+sWlj b3A08W0LwuIbchZNky8fMQ2RyecjmoR+zPr15pkUsjfZZJpAZZMF5d4I+7z90+wxUUvo647Z3Oqp 465YpWUl95e/4Zg10SW89rbIbeGTyp7u4YW8IJHXf/FyBxWc37MXjqWR2kjsCWc21u8DHz95PyoE J5z2OK0X0csXzJJSCPjplq3kvvL9v+yx4zcxQtJbRTh2ilS4mjhnXHARU67ie/I960dO/Ze8YSrJ b3Wi3EnlStDHcxWzTLCecgkZ546j1rrj9HLEJaqV/l/kD8eMuWia/E//1f59W/ZevEFys1zc2s1m kZ8iZJYmY5GQE8oAZB/iPTvWiv7K+t6vGsmkW09o4G+Se6n2wyrjHyqT/I1/cMfo41W/eT/D/I/l p+PGA/mX4mZcfsz+KLHU40ZxLbPCot7OaCWQPIp+YrKoyT09ea6D/hnHxZI0yxafcWw8pC1pe2TL HFnO47yQTnsMVX/Etzd73/D/ACFHx5wMXrJfiUrz9mvUF+U6PYxXMq5MjsiBwP73PHT60y4/ZY1t ItPjgskhlvIHmsBHzG2wndtw3I4IwcfSmvo3RjvFv1a/4BpLx7wi+GX5/wDBJx+zZ43aext5dEuL e4mQG12EpcA9BIsTc7TzXofhb4OfFn4flr/wp4m8TeHb2wujcO2lapLZmB5BtIEadd23nt69qpfR 1gv+Xf4mEvHrDWvz/gf/1vyqhn/anuVXHxD8W+ei4aSTWbm5uLiRgf4MYJI7HOPWuC8T+Bvjb4ys VsvE/iPxbrulxAyarazanJHBG275GwxxwwHfgj6V/ckvo6U+sPxP5PXj3h3qp/geXwfsnarA6xLc XNnAMzoJQ9zF83zEybo89+3FVJv2eNcNrqkMF7Ck6Iq2MY4mlcHB25XByOcHB570o/R1p9Y/ibR8 esPJayRNpv7KeuXU13MLe6vVt7VLqUNKvlMWHzR7Su4kHkjtWTH+zD4iN1NG8Oq2GmbsW1rebRDd knlo3Xnyx0CnB963/wCJeIbcjM5eOtBvRo1br9mjxAUDWbjT4HGFMNsGifH3k3DgOR+PIp2n/sya st1dGMX1ybdF81y5uYbcHqGAHHTqc896cfo6UVvG/wA/+GMv+I60n1R//9f8ELX9lvVtZF8kEN8t vIfI8uGIR/vWO0OGK89selWYv2ZvEWmSXGkFfLljiEMsWpbZcKowSsgIGT9a/uz/AIl2w/8Az7/H /gn8nrxypNK00SW37NFyfM3S30dlHttVlilD20UpBJAbYcnAJ68VPF+ytIlw7Wgmna/H2f7UbqUJ K6YGQThe/Y96H9HfCren+L/zFLxypref9fcXYv2QtSgUKlrfz3Zzcxh7o3vl8/MpCMQOnAIzzVmT 9k7VrN7C7kEi28ivuhM0vmMegAixk49PalH6O+BWrh+Zxvx3gnZTMq7/AGX7mO1nSN7e1meZDcCS 0ls5bpN3ReDggdST34qq/wCyzq1v4ggnS2nUSxJDj/SPs0okwRLtydzcYGPXpVr6PWX9YfixPx7t 8MvyP//Q/EV/2RtS1ZXMtpcyCOTZNazTvppY9FGD82f5ioZP2bbbS47bT2Z7NSWtFkN7M8aMD6lS T6AjtX94L6PWAvpD8z+P349ya+L8i7f/ALJmqxxRX9tdwX0WVSM2TS3IjI6q0ePmY+orCg/ZD8QX F4l5/Z1zcPv8yI3nmwNEBxtAzsHPbFbL6PuXpW5Ec0vHqb2kSXX7KGs6SHF7o91peoX1yIzcR6jF cNbkdQyt2xjp0zVG/wD2UrC6WabVTP5EsDWn2W3vZvOLpwWkiDYGezDn0oX0fMBbSF/vNY+O8pby L0n7GWsa9aRLp87ade2+nNJY2rtPHc3MSL8gYEfxcY3Hmqnhr9knWWWSxfTLssJ102+ma5eJnlIP HByv1zS/4l7y9701+J0w8bpS0cz/0fxHT9j7XrcTlbK6j/siRjcCd9zSb8iMeYzfNjr8ue2apyfs t6pHftb6rdCK7hhRIbGISRO5fBB4yCcEdDj61/eMvo+Zfeyp/n/mfyavGnmduciuv2XLxb63S/tt UaT7OwsI7PzRPIzcDfHj5lOOCKsp+xs8c6atq2m38AQRranURKI1wSSHAGCSfXmuSp9HrA/yfi/8 zeHjNzOzn+RPqX7Iim+S2s1164nEgv47KGCaOONO424zsB56mrUn7KWsiG3WK6soo7+4ZYIGuGOo Wxj++WQruJJzgY745ril9HTBzt7rXzf9fcdq8ZIwi2p3+4yZP2M722uo795NUvnvroWsL3ym0RXc cLCAu4A46YriviH+y7r2nabPJqelXVkbeN2gukjeISPGG5hc4GVxnB6+hry8Z9HTB0qVSurpKL67 W6/8PodOA8Y6mMxlLB02nKUktlrra3/Dan//0v5XDLPaRfY5jwieQ5VTG8rJ8pY/UjNZ7sB+9Tlw u0464H+f0rizCnVw+NqUKis1Jq1trN6f8OZ0pKVOMl2Ndby+a2i88EwoMQ/L8+Djv1/CkFvaxiR5 meQSIdqAAbDjj9a8qd7u6OtWSsUbW3it7hpI4o4S/wA8iquBI3TcferLpJcPJC2SA27gcL+FYN2R qp9yeUy2XlPHMqxyxmJ0Q8vyOoHpj9KxdsvmviRpFVi7op3Og65NQqnctNPY/9P+Tq1VRO91EVYX shBljO5AV4IB9sdPWrl3arsVmt04fekjL/rD6n396+T9p5HfGbvZE8KpcXCLJueTYB5TEsh7ZA9q j1O5OmxyT6fiR1zviQ7VbjBx79qTqJbl80jMlntbxAco0uwMRu5UntR5t5FvzCpjWIBJN/I+o/Kl KcXEXM+5DLf3BgRYo0a4DBW3tsAB7/lWlexPeGEYWGKNAHjydjnj5j+X0qG7LQXP5n//1P5N7ieC ORbfJ3N93IwPc1NaXHmo0duUZ3JUfxBscV8Yp3drHoXuaNtHcqqefC0UgbD4Usuc44rfntYpdJkW aOO6mVwd0i/NDgggqPXtSUnzMEnY5i4tntp1S6iEK+V5jMx5CkcE+2KtC1it4I3jPmLInmR5bG4e opqTe5vG6XUp28seFnSJgNxEmRghgSP6Vbkvjfl4pLRLS2SMK8rv/riOOQafvreLHvsf/9X+WG3u EtLEWtu0At7sm2nO4JGc4OB29KmXQ7S8t5C2FOnR740i+dpucAD1/wABXxjp1G9j11OKe5zk8ghC KsbQnzMfMu2T8R2pbowRoPOkeIyAqrxLkg47+g461MqMuqN7qXu3MzTpJLa6intwZjG5/eAb0PUc /mauNaW6LeXMssrL5u4W8g3bO/y8duKzlHlVmgVK+iYthKbqRnZ0jtUX5Imi2SZ6Yz6e1TKYYbgn pv4ZgM8U4x7DUOTRn//W/lYt7lELM8kacYVWYKcVYittQ1Kcw2KQMVTzm3yBC4B55PHTpXwblyaM +mhRlNXMDVWlhItbwqlx5+YefmiIHABrI/tK4R5YTEdxQebIUBMmO4/Lmt6cHKLkQ4pNRNO0l3wl MN5kjZzjpSXlrJLHsVl3EjPbp2qXF3shSi0iZLGCSNIJpHmldCHRcr5f0PXpViz04fZtQuvt5gi0 6LeLeRfkucHkbsccfypWknZkK/U//9f+TGXUbqfULZUt4kskUZxAzBc8cN0wcAnOa2xEt06WkDAy PwEzxz6+lfFqF0fRRTvoF0J7WNrWADzoeQtxkRuf8Kj1AzRWG21WMzMBtbAbymPVse3pRKmmrI1T ujYvI2niini3xoYUibK7S5CgHgcckGsWQkoYzxt+ViR8y0400lYvmkWdPgudLlaeRnvrcFZ33P8A ulGOUA9a1JdRt7uaNbeN2SeNZFSaLYQWzlQO+PX9K0jTT1Nj/9D+VpYSWmDEQ4O3BHHGOlZ7W0Ft KywRLG10uHeMbPMx3OK+LdJJ6bn2ATLNCwhWKSYLGJcxKWEYzg7j2qwNOZLea/kZEBbESMcunGck enHWmqSehhOLbInj1O3Q+VNHJ50KvuhyjLnqC35flWms9yqAzhUMgISd2AGR1J+lawpRjHlIlBnq PwdNjJfxXZvPNiubt1hjgQtI0seM+x3bWGf9nvX6o/DvT7TW9a0B7qylk0+4uoZmaaNv9Fk4ZN6/ exng+nFf1j4I4eNHhPHVo6NuX4RR/PXiTzVeLcJQlslH/wBKZ//R/pj/AGC9Jit/g/pl3DbC0uJd OhdopCUKoUViAvXnOc1+Yv8AwWK1uxstMjgnsFvE1R1sba0V8n5uTI2egGf519x4aUlX8Qacqmr5 29fK7PM8QHKnwdOEHb3Uv0P5TPiTow0rSdXW1jht9Pt7YMbWKbG5cooEee6ZPHpmvxT+Lt5qOoeI tVW3v7ldOl1R3tLeKXYAFwB5mPvYyfzr+hvGqr/xjkY32kvyZ+IeF2Djh87kktGn09DyZLg/aIkv Pm8oBS235nxV4bnlZLdPJDkPDODzGc8n2xiv5CqSkrn9EzpU9E4nb29wktu8JKbxHguw4kwOSAan 8xdL0Kxmad7a3mvpYJ1jjIErjaVzj1B7+leViE9WOMI7JH//0v4v4pJW3xYzvHXHUehq7YLJY3CT ywSbSwC+UhdmweOPTNfLVYtndFJH03o0thN4dMk9y1je3dxHb20MKebKpbIzjBAXJXnn+tSGxuoZ fLvjGQ7AQywy7ty9i2Pun2zmvNrx6I0grs6y306W0SGNv7K1D5ftDIZxM8AfP8S9eB61npqulaHp l19ttja2yXfDxECCGMFg5I9zj6YrhskdEVoyppdzZNeancaYizQTMJ7GKacQ2rLzgkjPUYyQe/et 06j4f1G2kF0Y9P1bSoTIBZk3EFzuJG2TLZGMnB9BXPVSTszWhotT/9P+N/RTdPG1tHmaW2iG+GWT IYE4zzzwM1u6jLam23LHIHjAEce8KsZxg7hjkV4zV1YlQSjqcnPLPukjmj+UxhWVwQm30+mKLx5Y bWJLWKTyokDRwwoZEUkfwgVHJqZLexpWFzpwhT7HDNCzRqb1J4PJAl53/L9fpXaadfrP59qCClsF KDyyqyk9xxwc5/KrjBJ6A0lsdJp2q39rPObr/SrVYx5kDfM4Ttj05HWq2na3c3dzcmWB47UytCiw SFZEA6N9eRW8Idty4xTuf//U/kG165k1HWreKN3bULQfa4prhiyIF4LBjwCNtM1eL7Nb6heSRaa9 9Dp3nswZEnUOB84YngnjA7YNZU42Md7nhsTJdQtqdzaGZ5yQLS9PzYzz0PSobDUYrDVNOisNFmll vHe3McOSkWeeR6H19q9LD+5Ui/M56i/cSi/M/W34bajJd+DdBS1tJ7e2g0iB71VLSxxXGxUcjA5J VU/LFf0R/wDBGfxFd23jfUNHup0a7vJ7a10yfUGaK8it1ijmBhQnIBLN9a/uXOP9o8JG/wDp1H8l c/C/DdywfinOGylKf62/Q/sT8b21tc+A9QFtN58F5pDadZzTDbJEJYjFux2IJP44r+Fb9t20Oh/H DxJorzu0Ad44IQERbVkAjEgHcuUJr8J+jXUdPjGtRtun+CZ9H9IqHNRo1V0Z/9X8iLgtDPFpV1fX EuoF1f7ap2SK4YFSccAdPyo8VXs+nXioyXAnSIxztMglllkk2lmHB4yCQeuD1r/X2CvBI/zYk3G5 z1vPJdojX9ujPHcAWb7tksxI7KPTnmtOTT7hrxfPtTbyx/MfMQoykdODTktUioN6Iy7uDU7poY4Y lKR3ZSaR3COQOpX27/jXW6XpN3qF9Fp1vDeavqQUeXpum2zXl2Qe4jXkgd65cbXhhqTr1WlGN229 Eklq36HpZfh6mLnLD0leUrJLzukvvPR4/hD42ihlEnhDxPpt7dqskNre+H7oveoACPJCqVLY/vMA PWu01X4SfE280mSxj8G+Jnga0F+LOTwZNZyK0fQyTBSAeOoJ+tfMw464bqNWxUNb76bLrfb52v0u fSrg3iCk5RnhpXjvbXr5Xv8AK9up/9b8xfEnwc8a6bANV1bwtqmmWcNvHNcNcwGGSLIwf3ON7Ad2 A965GTTbS0hilV1tzswsbgxtKcf3euT1r/WTC5vgcyi5YKopqOjs7/167H8B1cDiMDV9jioOM97P R2M1r+WSVQ/ypbjaAF+UE85rQ1FrW6021ulvozc2dwsEdta8zzbyzFmx2UgDJ6Zruc7Rseba7Zfl v3igEc7+c4jBMrtvZj0A/CuNs7i61C8kkmgjS1V2BmA2Tbw2MY9CM1UZ9yToV0mzuLnalx5BaAyC RyCHZefYDpwPWojDp9tdi3e/uLx5IwP9IjCrGR94rj9KpTV9AP/X/IW7jX7fEI2ea0aPBf7jKw7b e496qas5gjs410yOZkuGe2vkj/0qHeAGUkclTtBwe4471/r1zNn+dDVnY1Yp7+5NtDDbRz7YwoZR tlY59McnmrSX08t7NDNd+VZ2loY3s9hMs0hIIAbGMdetQ5JbnTDfQrQ6k01xFEjiKMPsfuwrpLSx vtav7aztbT7ffyzra2ks26MIhI3qsgB7DO3uQKmclGOpdC8pcq7n0fo/7I/x01cy2Wn/AA91vUtP ntk1GPUkY6dcWG4q52EwEuu0bduP4s56Z8i8dfD/AFT4fXOnReJ7K/8AD9xd3ckE9tqKNILfYdoL S7FVS3ykA9c8V8tl/GeRZpmksnwVS9VX9HZa218v8j6POOFs0yfL44zHx5VLp1/K33M//9D8srrx BZ209pYW7XEYulkW4lT51YrjYNmBwQTzntVcW1xcWt1Hpyl71Y96ysAoQ/3ivf6V/rzGVtUf5zuP MtDj7KLVGuJ7PVtSW9uFXa4EKRiE5/hI5/GuosGurWF7KWOO4KZaJymSN44OfpjFa3OTkiywl7bp aul1FJBf7iiIQDE+OwbqD/jT7KHUdVBtrKJBJOFAdsFYgh3NgnpnnPc1optFKPQxXjvbeacI80Es QMbIilZZC4xgD3zXZrPq2naRHZ3GmEh40S4uPJ2Xbr1IBPfPcU/aNbmigf/R/LCzNnJYeZZ+fNcx zsty0ybXjJPyg1HNbXFuZmuGW5ZBzAzAKp9F9a/2GUtbH+b9SLiiWC6Q2Q3feMmxraRMZB4wP/r1 LcGW2t2LEeXvEkcUQ+VRgAce2TQpJnPa6sUxrEFxazWtwGWSVgkRUYYDnOW981nm0it8+d80rsqR mZc+TyCDj8BVGLjZXLmwXODHI0VxCRGklwvlrN2J+h/rU+pR3NlbtZXIa2t1K3D3FnKyW9ypXdli Oo5OalSWxCgr3P/S/LOz/wBMl0293mUx232XThFnbsYkkY6nJ5xXqvw6+Dvjr4savqmmeDNMk1DV dPmjg/shY5PNv3kVCpyqnZjcQCc52mv9ecxzHC5ThZ47GytCNr/8A/zlyfJMfn+Kjl+WQ5qju/JJ dXv5L1aNb4k/s/8AxZ+EV/af8J14en0Qzy/Z3toYZb2SFicR7xtHytg/NggYOSK8YTTvtd282Nsj Pg7V2ITn0/Cs8qzrA55glmGXy5qbbXndf1cnMMqxmTYuWBxqtNf1/wAD5EWunToDFYm3vDcwjzFl jnEdusg4O8gfMMHhaS3GnySQny/PuVi/ecEKgPYGvXjPRI8yUU9ehKLaORxHh4/LbcrBsVYurpbK x1UWcQfVb5USK4ZyBDtPJwOvFdFN9DB8vQ//0/ykjWVPs8jyu6KwSUPIXcH155x15pNVa+eU20OV tZCrOkZwjY5G76V/swf5jNaDpdKgdUu4ozHPGq/vANzZXp+Rq5YINRjlt508+QKVKY+dxjqMUBFp rQoPp1q8CBoZIxYkjLHO7Oen4VYtrpJXltLfEVt5Xzgn5nx1zWqghmiYY/7ImhiMB8qWOSNDEfNZ d3z4I/H8xWfb3M6XH2mOICBVKkdCTjGKmUbM7rLlVj//1Pyrm1KRZrd7UkS5z5DD5Fx3AqzBfWXm k6lbqL0uUt+pX3AX1/wr/ZqD1P8AMHEfDJEn2VVkUIRZpcnLpINqEE8kiqOlzW0GoS2csTRW6y/L NGA7yKMZZV/Piuqnrex5WMk4pHs9na6TM1lLpt2b23uFwPtNqbeZGH8DIc8/Qmtq/wBMuJJA8UDt CsOx0jmEca44HB/HNd9OmrHhV69pGL9suopzataRSyIoEZcGTZxnIweo/Gopr82/nXMV1PDeOoil VU8yKYZHB5z6+3FdMIO6POqYix//1fgKVprkhynkowDeWrEKTjk49/61oQaUdStfNleW2iiYQpJA NjEg7iN38/rX+4Ps32P8d/rXmU3torrWJbCK68lIeQ5BL7gMjOM85OM9BW1KmwRNLcNdzKq273A5 xt4xjsBjp2q+TTUp4nUla7Zbm1+zKLto0OQzZRVAOfxHWh9Rv4lkmuLVFhC77aONsyyDnPsDkdK1 jRcooJ5r9Xbhy367/wDD9iP+2pY0ltxZM8Vwy7zKpMkQyeh9s8/SqNxZQJBbS3AWVopdscjjBJY4 A/kOK2VDXc5J5t7XVw/H/gH/1vhHTrprWV5FDxRq/wC/UJvBAzggnp17elSWkuk6hpk9ylw0Us4l E88aFXcgnGR7kDn2r/dBYe+iZ/jQ8xsvh/H/AIBYs7Oxk0+3ltxLdXEcT2k0Fxgq5/hYEc5wapi2 ubZjp15ZIkjAPDOjlo4gTk5HX1raOHaVmzmlmKvbl/H/AIBLbaf5yCxkYvbPJvaZn2C1xjjHXBNX F/cytbaZJG0J+S6DOwFwO3X096r2CW8jL+0Nfh/Ervf2UbR2y20a3asS+0bs9h+GQap/2pqtytl5 tqs8H2h1mNvjNuq8nK9hgipjS5upUszS1cfx/wCAf//X+Hre7TT7QR2l1cSJNcO1wrPuQISMLgc/ L83Wq9rMbu/u4obiOW3ji/1RXysHuAe5x2Nf7sKjy63P8WZZnB7xf3/8Afq9no0NpayWNx9okKs+ o/K0YsWHGxsnHfOaybaSyt5YrWVI5Xu0IhkZC23oeG7H8e9WoX6kf2jG1+X8f+AbR0tyWhB2RKfm dTlWHpn8KxpLNYbsXUN5IbdB5LwLgDeCRkt19sU/Z+YljtbqOnr/AMAkaQvdzqtwTcoQlwjE9hx+ Qqjc2y3E2xQHcMGH8Q3A8YH5U/Zrv+H/AASfrj6R/H/gH//Q+Fktn80LOxhuZuTJEAF45x6AHGCP emWkNyNYksD5hL2z3MUwUmCEIPu5HrX+8MKemjP8TZ4qV/h/H/gGnFHdNHIl7DLNFuKoTHkH6GsA TxC6lto7eSMY+ZXUoRn0o9guj/D/AIJCxb6x/H/gCRiWyjkhvM3c7yl4XOE+zqeigAc9O/rU0st9 Kkk900EMRhWC2AiEbSLjaQ3HX364q1hVa/N+ApY2Mfs/iSWul2qRhmdPtO0tDkZwSOCBTprufSzB Hc7g3liO8Kg5k4GSh9uverVDTRmTx9O9+U//0fhi71SyuNNhWwAluDLujecFGK9zxVGY6jbSwW16 LVlaPeGgYHfnoMj0Ff7y/VdbuX4H+JEM1VPRQ/E059JtLmK0ms2T7QH3TFIN6jaRmNs9c9KpTeRd 3y/aFW1XghbdfLClccY7A45+tP6rHuOWcafB+P8AwC3NcxxREME8qFjI0xJHTufT61m319LqlikW 5ntWi224iO1T33YHrk80/qy7/gZxzdN2cPx/4BQghu7h4U8y4SOyjKIqnCgEngE/U9Kdpr2ENzPH qSzmEBgpQ4Kt2z7fSqjhlJ2b/AJ5oouzj+P/AAD/0vhg3MF0scNjBFMob/USW6sWA9CRkdO3pRqy l9MisENpDLNdBmMj7BAo67QO5Ga/3wjhoR3Z/h/PM+Z6RX4mdcWcKRvtKXAwI0Zhhx/tAZz2rIeG S3uY7UMCrgFypz5bZ4U+/wBK2WFj1bJ/tNp35V+JLcF5rjLSM9xt+cyH+7x+nFaOl6mbK4AkWOeE q0ZjkTK/MMZB9eatYWnsrmjzRvXlRFHPYx3N/DfJN9mnVjbfZsO6PgFTgkDgg/hVLT5UuFXJdkWT yXdh5TLzxmtPqqIWZVW9l+P+Z//T/P7VbaK1QEuDLv8Au5+dR/k/pRpd8s0F3af6yWS2KW3mfNFb Nn74Hr2r/oBWGgtVc/xA/tGp2X9fMqSvfWD2u66N5KD5ZNqrAwg8HPQAHJzgnvVy7vJoJrFNLiVZ lG9yEDl853AjvxntT9hS6omWNrqLadvkZU890LiW+t7RYpGYuEt49kUXY4B4A5/Wp0v7iSOWO4hj mEiklmjA8s+oxwKz5U9yY1ktL36FPCxfNFuD4PHUH/IqukdsVWd5mJulJjVPnAYEjle3IqfZ+Zft j//U/OEF7RLeSe5E8hG9k25jXadoG05HYce9aE88eor+7UQzsxkmTokhz1Cjp/8Arr/f7kR/iCq5 Rctbo6pCk1wfmAclVY+5rpIdYRILhTbQ/aJoly4Ak8oggkKSOB9OauMOyJnV5k43Mtv9IVo4gsMb 48xAcbyPX8s/jWVcqzBbdjhYDhD0Udzj601TZft11HWlhJcyERLFJIq71VmCHAGSRVjYkO5ZXN3a q25rfcfJ3kEdR/ng1ooJbmc8Qr2P/9X83ZAsp80xJECoUJGm1BjjpTLa3bc/HmLHzuC5AGTjNf8A QO4Lsf4eSxKuWDOxUtcbXSJfLhUAKVHJ6d+pp8NpHfwNcwlESNCS7goOOOBS5Vsx/WEkU4ZTHK0c DnevEjDgjnittVv3iWYyGaBj5byrlmVgPuE9fWqS6IPbrqVhNFPE8FvaJCY7tmmuDkTE4wAO2O9Z N5FbTLLHL+8ITDAk5A/z/Km4vsawrWvqf//W/NxjI1gsEbF7KCNYvK4YKByB6jkZ4odLnUSixxDy rSMmG3X5UgQHLY+ucn1Jr/oK5ZH+IvtluUkAaS4DDAMoeKMkt5SgYxSuC0qHarAc/Ou5SO+RVezY /rCL0FtaR2lz5k9xbylAbU26ggtkcN7f55psLBuZgGfILBhgPR7PsS8Q7+REwWErOgYP5mQmPu46 GoJVkuneZ1Xg5OFAyffHc/0pcjJlidD/1/ze8xYmWS1CQmeLZOkY2hj0bj3xn8acYS0fyoNw5BHX mv8AoKdNn+ISxC3GJDNZOt4YkYr8sfmRhtpz159KsZtLjzZLv949wpEmxdrAnuPTnHTtmmqZMsT2 KFxYQ+UCQSqYKMeWGOhz6jApGmeSaJRDGSx2vKcKR7k0/Z+YvrPmPkgBUlwC2c5A4NRAQxwyeXbx vMQQJHzgEjj+Rp8iKeI1sf/Q/Mi2llsw4OS08eyZY+A/sK0UtUW2yCIpJxtcSD57YcYJH9Pav+g3 kR/h/wC318yO8ht1mjBlinwgQyRfdYDioTFApIi4B42Dowo9mioYn3dSzbaUrwstzGkBdy6S4y5U cDPfHHSqAWOykMkY2kOAZAvLYOAT+Qp+zRaxFxt/dXF7cpNPIWaCLyklVQh2DPHAHHJ/Op4ILaSE 5Utv+932++Krlu9hxrRjoj//0fzBaNYxllM0cXIZlyijOM56fhUNwI90Zj2RNjHyjBPPU1/0JKD2 P8Svb9mXHijVI2jdJWCjeyqQp+gPNRRwCQ7I5YV8r5nh6SjP8Q/Kq9myXX0K0tmIo7iXe1zMAXUH G+Y/3c+taEaQtGjMm0mPvjKtjp+HFPkRPt9B6WMQi8zMMjvkEAjch9x1FU4V+zZVsb15O1cdc/4U KC6i9uu5/9L8uZFjMqlAESSQF8pjcegAp1xbhJXncIgI3cKFANf9C6SWx/iG8QKhjRS8iecGGdoH K4yOtVlgBYuqHLchSOlNxWzD6yWreJYpRI8KMY+SjruU4z1FNuBBFNuQqRKmdrwhVUnkgD+vFTyR 2F9Y1uJIsc7bl2AAAHYoVeBjoPpW9pekW07gzT7I1cZBXll559sYH50KnFuzJninCF47n//T/M3U 7OyjMbQyrM/murKgYIqggJ1655/Ss/yYYzlAp3Lg7lBIr/oVlT190/xBhiW4Lm3JfPlUBF2qi/3V AJ/H/Gp9R1Mi2hkYyXjHbCzbtyjOFXGfTnvU8jCVdP5Gbdtb/Z0KQFrlG4MeAcH1yakikeKH967M gGArHIWq5F1GsQWt0LqhEfIG0gDg+tSXNtHJGsV5++hWP/Rot+Ykzg4/nwO4rWMHayJliNbn/9T8 twuBLuASHOwRr0I/+tQbGK0w9ttfz8FvLyC2R0PTpxX/AENcrP8AD54hXCGJY2aIqqKSMjbwD/k1 bmdpWG8+YygDeeoxwMVLXRkuurEc00xjSJyGSIERrgfIG6ii2VNpBXKDlV6AH3FRyalfWEth5tYZ gUmjcsHV0C8Lwc8j8KvzCGII6MbdlAHmISCD6j0qHTXMkxTrycHyvo/yP//V/LlLVbc74RGjeb55 kEa7nbsT6/jUoWDznuJ44Lh5R+9PkqqvnqCMfXNf9C/1am90f4ULFVU9GTLZ2Ykle20G2htLhN4W eJZ4yV5Ypnp9AMdu1NjtoGRY4rDT4Pmy89vYxRTOB1BYDml9Uo9UjRY6uurIrvQdMmjmtVs7cxXF wlzl4FaQFCSArHkDPXHXGPWtSGzETiUWVvZzTkxwXMNmsXmBQMjcBzt46ms5YOgn8I/7RxG3MzBO nRJc3EF4kF0Dc+c0jxLmRh79f1rQW0sYldra3gVZHMkkb26OI29VJGfSp+q0P5V9wv7RxC05vxP/ 1vzCi0vS3WaUIyzSLtZEVfLl+v5dOasqsKuh/s+xlEUexomtEaKTjGXXGCfc1/0IfVaH8p/hesxx HWTEFjZ3CyKYILWFlJeK0t1ijbHO0KBUo8lYYxa6RYJC8ZjTz7ZZZdjDBzkHn360vqlD+Un+066d uZnPR6BaW0skscdrbrGyk2YiJ3ck9CCCBjoa7q8vY9RgtLS+sNGvvsUDLBO+mxlxuH8RIBO3GB2H vR9Sw/WK0/4Y1jm2KimlN66fr+aMa1isrFpWi0rTJGeMxiNtOhaEEnG8rt6jt6VctLex06AyxaVp dw13N5cz3NnHIICec9O/p7Vn/Z2FjtBL5It51jJ6OpJ/M//X/NW+0pYNskMPh0I0247NPgld9pzk 5XgelZOp2um39+L2WwtUG3c0VrbxxW5k24DFMdMjOPrX/QX9QoLaK+4/wzea4pqzkzRmjW6sLeBk SR7dXEAQAOikYx7Y/pUFvZ2qxxpJY6c8ix+Q00ljG8oXkfeIzQsDQWnKhrM8S1ZSYv8Awj+jQ2TC DT7NWhuFulLwqGnIyMEYwR04PHFRz6bpj/Zp5LOyea3JK4tFzyc88YNH1Ghbb8AeYYtr42JbxR29 7NPDa207TRPAsE9ustuFcFcCM8cdvSmPb20cMKCys4zGAjFbSPzGIORlsZ4pPBUFtH8BfXsVe/Mf /9D8ymd/Je0ESC1mkLRp9kSRIyc5CkqduQexFVjpsmn2tutvZWcUImaRbmO2jFxIxwDubGSB6Hp2 r/oK+pUbfCf4cQx+Je8mXVjsLqMxX9haXLpdJPC/2VShK5yGUAcHjr6dap3IjubuQ3lnZz25mDJB JaoY1wMDAxwO2BR9Upfyl/XsR0kXbez01TI8en2A8wYeAWMccIwMKRgDnk1HLp2ladbtdSSsmoFg ttBCgVHX0buf/rVDweHf2S1mOIX2g1C6j1KxtreeOCYxybnb7OqSLwMAsBniksZ0s32ra2MyyWzW qx3VlHdRIrDBIVgQG9xzR9Uw/wDKNZpiI/aP/9H8255LWSK1iW101vsluYkiTTYYvJznc2AvJP8A e61l3NvZyXCzNp9jIwhEAzaoVYDuR0z71/0DvCUP5Uf4ePNMR/Myw3lfaNPb7HZwrZZCCC1VIxuP zHaOCeaz4bH7MJUjRdkkpkDPGCctkE/jUvBUP5V9xn/aeJv8TJo9NgEq3RgRpI4xCryJvEY7YzwO /wCtdK93AYYUFrZAxRGMSNbK0rE8Ft2M5x3pSwdFLVCeY4lv4mYUdrBaym6tkEDL8odBjAb+H8f1 q3qUbmxtZbkQhoZT/rowJYkcDCg/3T1I+lYfU6PYn6/W/mZ//9L8wUtbVYJIorSzQPN5rSx2yLMO MFQw5A9qsxWEt3LFKtwY44sAs+ZS2BgDr0/P6V/v79To9j/DlZhiEvjOiu5ZLq1skls9PFpp5CCG 1sUiW6PALygD5ie5P5VnI11az3E1mjQfap/PlCDMeegB9gOgpfU6XYqOYYm2kmLLdWc87SXVrbvc R24hjIiWNUbP3iAOT16+oqWLUka6R5o4Fiit/syx/Z0kEYOMsoI4bjqMGksJSeyNo5liErOQ9kil uINQmS0naNBHHI1pH5kagnA+715PPPXrVqa/id4JLGGGOa3ZipSAIUDfe7d/as3hKXRD/tGs9OY/ /9P85VuI55njuNMsHhVvNaO6so5DdEDhmON3P1FTwySC3xfyWf2a3mNxbW32JGh3HgRhcY2jAG0n HtX++bwsFsj/ABGWYVmtZM3dO1iLVtJFncWj2yCdg80NukCuo42soA6f1rMtpdPa7eKdEjt2PkgR oCrAEY49yBz71H1eF9hrHVXpzMkvtO0qe+S5hjjhniGUaMZSIehHcYJ4rOM2oxanJJZTRzLJb/ZN sdsjoVGONpXrx1AzUvDQWyKWMq9ZD55ZUv8A7ZPYwWl2IhGd9lGmRtAygIyuQOSMZyarShbyCS2a ztUhkmEz4iVShXoV7jNOOHgugPGVVpzM/9T4A03UVgVbOP7BbgjYLi5tEn2AA+qk4/Os1r++QPGb eweURssUjaXBvCN12/J71/vg8PB9Ef4kfXKn834nP2W2DzRHbcFw0jbP3uR05rqo9cmDNFe21rcw zhW8mWxjlCbRwdxGQce9R9Wj2CWOq21l+JWZtKjka58iJFaQkO0SgwhuuPTj0qebVY5beW2sbg7A yrCUAC4GcjrkduBR9Wj2Mf7QqxekiKzury13xnaRcR7HSVRID7jPQ+4qK4Nl9pgljR1k8nZclQf3 jAkHjuMbR+FH1aK6G0Myq20Z/9X4EudVmtbOC0+0x3NrNGHjteCsKodgUp2wB0965+2uLazliuI2 EbSSER26oUEPpj/Pav8AfD6tDqkf4kf2pWX2jXN0rmaR4o7mSaHycyJvwp7VHLP9qhtrYxW4itFK RQG3QR85ycY5PvTjRhGWxv8A2jUcPiM5rMRQzWhggdWw8j7ASoyCOfqRz1qg0Vvuy+nW0ULRiJWM ZUykdX69f84rP2dO97HD9crWspGxi20zYtkIrfUIDHcRTxRf6og5DHPfIGKredb3bRtIpuLoTNJJ NK24FW+8FHbPOaPZw7D+uVr7n//W/PG6vJdRulVZYIbVLZbaULbokW1AcABR16DPWtVdUuYRZ25v riCxtlwPsxwx9yARnt1r/e+NKm3Zo/xGjja1viOeS8We9ecyyzSrNmOeXhxtJwfb8D2roZ9XluMX dwsVxdQTrKk1zGLiQbOmCc4Ht04pOlBO1injK38xS1nW3vXX909rKq7Z0hDhCTySx6DPHy1UEiXs ENrMokMJLROwy8Y7jPp3xS9nDsKOMrW0ZpWU0sUhc3KNEsJi3Pbq08RPBCPyR6cYrKuYAsvWSS38 0GPJLBST3H+elQ6dJSu0E8TWkrXP/9f4Mnv7i7i83elpLuAzbsQCAABx1HTnr9afaSaz5lv5FxNi 0VvJkLn5VY/Mo55BI5HvX+8/1ejJ81j/ABEnmWJg1FPY5mWK5upZkv4Y1lZtszraC3jc9cqOlasY Ntarp9j9nxI++WaRBvORjbuPQdOKt4ei/sowWYYpT5uZ/eU1QrBLBcxRb0ceSVPyJtJzx0OfWrFx DctBHdGRQxufMni6SZAwrA59/wAqPq9H+Uf9o4zrJj/trf2lDqImt7aSCUTp5sRkQEHpjB/M1Zu5 5b+5vw4a4k1Gf7RLLCGhj654AxxmplQoJfCXHMsXf4mf/9D4GninSaVhulFxEsbxzoJcBccBjk8Y q3ptz59pJplyr21nBd+cDja7EDnDf3TzxX+8vsaC2if4lf2hiprSRHLcSi8W4XzktYyY4mOeoBAP 8uKv2jX97NO11ci5bG1n3EoxH3fw44rKVKjtY1hjMVb4jMmnljnmtxawSSZwS9sLgIB0IyCPWny6 beRBLsxq2H37YxtROf7vGAfQetZSw9J7fkdMMfiV7rZq22t39ndpfxNN5kcWP3alvKA4CJnoOvFX 7u/upbp52tJc32JERzkpuHDt645NQ8LSS/4APG127H//0fiNL2VJ4jNPPK1qOZ2b5gewzxzWnHda XdLezXepNau6/PC0bE3ByMfN93r61/us8JSe5/iosXXjuync73Vfs2pPLDFHgssjg9sLg496oTxW upRebf39nbSRXGUSa3ZZp+ACQ6oRjgDBPWsfqtK//AK/tGtFBYSzwSyS2atlX6qSC7H/ABqpKNQM zy3s7wyyysGh+ZDCh6LtPTj+dL6rT/pAszrPY1baO3ZYrdnl+yxy+ZNFG2MHH3sHv2zUcqR2lyz2 sjLDdr++jVuW2ngMP8fWmsNBaFLMa19Wf//S+JrKSCQXk8lrMJy4EMpbIYAEEfy/KnxWEEl3auI/ 38r5n3jcjHPUg/rmv9zHhI9D/Fx5nWWupLrxVY1s7ZY7aMkLIkI2RzY7kDjPvWfa6UVSEncYpZAZ jjBIBz8p7dMZ+tSsJCWo3mld6X/E1Ly0+xXr39leTx+a25VaQKI/UDFZWp3TzxMl5LO1u43bS5Xc egIP1qZYOkmNYutLVsmSS0ltLS1MrWrtFu/fS5Kcfj24xzT4dNvriB0tGvdSmibzfsluWkeQKcAq n+yCT16Vk8DRZUcbM//T+PtM1Nrky295GYxHjFw7FmcgHIPv09az9RSyMkd07pHGSQI87kHv7f8A 16/3EWCorY/xe+u1Oa3QuRiG+tNi/IsJ+WWJyp9vpULxSRgWqXd5cISXWN5dwyfSl9RohHH1YyID BdwW9obxSZo08zE2WEIycDJ9KhsXgv74yYRZY0aUSzHZGrKCc57njj3oWAoo0lmVRfCiO/127lWZ TcXMmoSMP9JMhc/L93JznA9KmVUmsY5vKljEpIkZQYxLIPvEH1yar6lR2F/auL6M/9T4jW1EcAeW 4mQxKQJHclyD0GO//wBemCW5utRtxPeSPcW6K1qZ+JnRcY2N149K/wBwXgaV72P8aqecYu2rLuu3 uqXcdve+bue2kWAXDylJ0BOAFPtkmrumLLqTiDUdW82K2Yuk8pd2XODtx1OeOtc88DRvsd9HNsU/ tE88Rgaa++2TFwyqY2kO4gYAwc8//Xq9pdiL+Y3t1vjywS2nfoJOP4j35rN4GjbY7YZxi1K3MWL7 Tnh1hIb24ZPs7kLJIzPEpHcd+w6e1eM/FzXLu28OXmjMTdQFnufPfLJb8bV2k9Mk9O56+/j5vgqU Mrru2vJL8mfV8J5jXnxHg5uX/LyH/pSP/9X+X3xHpf2vWQI/Me5uMokMLbw7KOQB0Ge/86/QT9n7 /gmP8dvj98Nbvx78NvC2r6lozPNbtfX8cdkGddpk8jJ3MoDr2OOafGUuXjHG0k7R9rP/ANKZplWG hPKaOJa1cV37HxX8Svhh4v8AhFrWq+BPGNlfQazolzKrJPbsiIUk8oqGIHdcc85z6V5wUmu/Lh05 FmnjdTMjjaXz1VfevOxOHjBKSQ6ac5an6nfsw/8ABJr9o/8AaU0fT/F3ge0hv9Au7sectzaxl449 iMfJORu2l1Bz6jntX2Lrv/BvH+2DpujX/iiKaJDa20hXTbnTows+3kZKsdvA6k141P8Ae1nC+i/4 B6NXDRp0VPr8/M/GX4y/ATxh8C/EWt+AvHfh8WHi3RpFkVCWhW5iLFDJEH5AyD17Y9a+d7/TYI96 ieSDzifMe3OHbPUHPat6uHjGXLYxoxurs//W/lX0S30XRoba1a0RrOOQu2xjGzkkk8dOSee9VtX1 wXN8LS3EckcIAMaoRFaoc7VHqfevnFhoPeP3nqygrXRadjDbfaLdniuPLwrrw2GGGB/DNZtvDE8K xSEsGTaxPUnGCawnhYJ7GNkc+9la2OsOzTytG8KrbReVtV3P3txz/Kr032jcFUhY2+XaQOc0vZKO g7D/ACYftEaSk9ApdR9wDFaM774BED9ziM92x61k42dmWoNn/9f+UOLTVv4hG0iq0fzNGf8AWMOn Bqz4csbTUNT/ALIhjeCZpVitmzs5LYxn618baKPap076H7Afs8f8Ef8A9pj9pXQbXxZ4SLWmg3kI uNKD2q+ZeEMF2MQxIUgq24/3/wAa+mrX/ggN+1zpk5LafH5N85ikupbE3lhbFeCSd25TkY6Gow/s 5VOWLudVShOEby6kS/8ABvr+11c6hNd3elWMjmJQjKjTQSIDnZgkAKeSe/PSvAv2gf8AgjL+158G 9J1DXtc8FQ3WnWNsbxbrRYjPHDDGCxHT5RwAxPT6dOucUsRGKIhTl7CUj8i9Z8P61oubW9tJ7Dz3 eOW3mhZZkmgbZIpyP4SayF0kXllNbrKstxCWlfdwrqD9we4/pXoyoq6OBc2tj//Q/kobTrkXSLDc Ty20L7ltHIMQP8R/QflXTwTX9nJam0ufsskcqkqEyMZ6e1eC6Kud7v0LDxNJcXN7fzyXDSMZGZ+X B9qo39/p8cYhlhLrd5t0wpeRCRwRjoeKxqwtuXFy6EUSw2WkrbWiSrNcsVjeSPDggE7ifwNMt0N5 hrqYyTEeVIduAoXA6fhXHVp9jrpN3KdzHsm+ywOTk8SdQAP8mtCDTS0e5Zy7FSRu4wR2zSjDQ3kn e5//0f5VNG0ebVW0m3NtHNd3FwsVxHIxEkO9sKSuCT24A9fSv1P+EX/BKD9sP4p6TYeJ/A3gNptK urMSCLUYZLKOQMocFS4BJwR6DnpXwGK5YNJ9T7PDRcr26Evxa/4I/wD7Xnwy8O6l4t8T/CzU7izX D3MmiRy3l9AgySyocj5fXPSvy0m8KSeHZ759Yj1OK5tHls4re4t/JktpY22mOdG5DAA5HXnpXsUK V8NKR5VaTVdQMS0dpbhpAsSQKMADC7u3581LdNHDdRxfOxz86AbDz2J/KsJJJ2L6EcVj5t9LOWkW 62CEOsgwyKOF9OOelX9PubmHT7jTmSF1u5ybiSZN0qgE4CHt71LSvcR//9L+VVbcwuE87ZCU5t+A sh9T/hWOVja8t9Ss9o8pik2zgyryME+x5r49bH0aUbK5sKpurgSz84TjsPxoJtI1ZY0zMjFmk6qf QfhigqFraEJnmuFRN+PKckIDxkipLFrKHUlh1SSWK3dDI7xR+ZJkA7QAeOTj8KCxBLPGS20yW8ku wAjhvTI+mKbIsNtG88Fy1tcs2Ff7/kDHO0H+VVrHZm3NHuf/0/5WYo43RI5brzHdNwmTBZse3TtW H9ra9ujFa7tkE/llmUr06n+dfHu59dzRR0en3c0F0YUnjjhvo/sV20qggqxB4J6YIB/CpzGtmlxb PIs6xqScOZSV55z3/ChX2Ik1fQo26I0cz2geSGSEG2Vvk28cE559OtPuLJLmB7eN558xiO8t2XKw kjsR2Oa3gnsxc2iR7F8IdDuLW/0q4dks7S2iaRLOIgtG6E7CW6jcRgj/AGs1+r3wh1m6uvEPhy2v 5WR9R1AZtzDkJ8uQnHQHHX1Nf1t4QRlS4FxlT/G/w/4B/PXHiVXjnDQf91H/1P6kf2RdHj034UeF ppUb7ReaaqRNHLvRIo1VQhHrwPwxX4sf8Fob+3+0aSBHFZpFqKQuEuAZZhiU7Y/chQwFff8AhPFy 4/pf4pfkzi8RlFcKTi+y/NH8w3j24mv9E1RLuWA4XCxbv3shLYDoDycd/qeK/Ff4nPNPr2qLZ20M Zs7xo1aGbe84CgvIw6Ak8YHZB3zX7n45WhlFGC6y/Q/I/DGPPmFSXZHjtqxuZZ5JA5eP5QGG3cfQ D/PWtr54tkMaEu3LIeG+lfydPqfudR+9Y6awdZYYpbuJbRFcqmTt8zHYg9qtW9zf6nP9jjUC3jmM 1pax/dZsAFiO5IA+lebXejQkf//V/jSKGxhWWWMI7DMgI+aM+hqXQ7d9S1qzkub+a2tXRkTEfmwZ 6j8+nXvXzU97HbT2Pp3RHt9DNtHcxWdwUTeI5HEjEH2ByD7ds1NrDSSS20VrDaw2YTzZDExL4blV C/w4zz/k151ZaGsPiQ/TV/s+fz4UG6UCObd3XP8ATJr0ww6VrVlPnS7OJhZiJZCpeGUKAM7Dkbj7 9a89xaZttocLYW1paXK/aEtgCTbW9tsC/MQcDA/PHtWf9t0nRJb+SGyha4aLy7nyoQAoVtxY479R +P589aDvYcJe/wAp/9b+Pr7JJbyWUsc0H2m7sl3mQLand0Az0/h/UVkXmyGW6M0U1zPHEWiETjyW YHHDdCR2HfivIasZOfusyknubvyiyb9yhHjum2EjHQn9O1XtKlvtJhuLyWZ3QuYUto2SVB823K45 AHuam/vcpjGV9zK8QXF3eTzQWhNhZSQKG+zsTMz45bd25GQO1dJ4V1EadLLNfzG6eaNIIbOclUby wcHPUk9/oKpOzuVdPRHQ6jJd6hdv4iju308+WsdzZwkLBsjGACv4c1u2D/ZhaXCvC0V/EWaOPl4m /wBods9c+9bwdrM1pn//1/5EtZ0iG+u7O7/fxtE7K6W8piE6tj5Tj6ZzXK+ML0XNxK8Onh98C21x byneoSNAqKOBnoSc+tTSfQyjq2eP61cPc3rXVtA1rBFAsKwQXBkVyowcL2Oas+Gr+dr6yt8Or/bQ 6zImJz0+Vm7DivQp2Vn5r8zKrG1Nn68fAS01m0+HvhdtW0n/AEDUdQnkGqxXyTt5ccjR+W0XbaUc DPJ+gzX7p/8ABKu9+z/GyNRpyNqNnq1vfWc8jiS5aADYDGv9zCnj2r+3oVlW8JLp/wDLpfgtT8K4 Yg8L4qxjNbt26b3t/wAA/tG1l7K48CRBp5hbNpEZBZcSM4XJYntlgfzr+KH/AIKSeHU07453cTQi OSa3kjt5vL3C78qRh/rP9kAkH39q/Bfo6VHDj6dPupfgmfW/SAoxllcKr6Nfi0f/0PyCgjW/Dzae Rdy2sxzfbwTIRx5Zx8vGD/WseR5TO99eQTXCQkhYlk2Rsw6KSeAen51/r5T+BH+b1WKi5MYUvtTv 1uJLP7FbNabkVGDtaSrtACuODn19jXTQ3txPG6X5aa5iUGWWRsyKOAMt+VVJ2sOmk7WGx2866ipY LFbrEJGLH7wYArj65Ffrj/wTL8SfAvwp8SSvxK0PR7nUdX1COKO+1OBILmILbRYSKRxhlYIcBSfm DdCa+M8QoV6nCGNhh377g9vkfonhRRw1fjbCUcUrxcn235Xvf+r2P6+PB3w0/Z58f6FpniHw54F8 O6jZy2gS3m3CO5i3DlSOo78HpzXN+LPDfwB+HctrJ4h8I6PY21wPsTQX98IbaYclSAw5xhuPav8A M+Oc51/aDwntZXTenmrn9143JMtwtOM6kEtUm9tLrf8ArY//0f6bP2jP2VPhX8dfhRcW3w98NxW+ s3TreWN1pO2VGQDDIw2nIKllI685BXGa/kE/aS/Y18d/AbX/ABDfa3p97fWn2yZ44bzzp5rWAzRQ xLbIsW1QPMZyXIOB1x0/qvwN44lhszrZJmU3eo9LvZrRb9N7n4N4wcHuGIp51gY/u1FqVl81rrvd /cfD+txJaOltbq8u3DiVRvWXJwOnHGKqw6LqrSxPBFbqLiPcgEjCQsTjy9m3/PFf19e9/l+R/Nd7 qSXc6DRXs7E302q6c95LCFCocr5RUnOOOvasvVL23vZc20f2YGTzdkXy574NbR2RBWgtt98HdjCX j2AZwo6c/Wta58OCwlt7+a6E52CaIRD922eAG9xQ21oWleNz/9L8kb6yuZoZjC6WtywHlEn7gOOQ KldH0jy455rfVjNY5jZHZWgkZSPn44KnPAr/AF4P86be+ZWjnVkRb+O4gt2+0GC6SLLSqnXMYI78 DPXg11kml3fmLKYd6TruhVU3PL659DWdZcsbm8ErGRpywzalNK9lHE8aFchuAB94kdB2r2X4N6hH bfEbwkl35f2G78TWkai6j32qhJlJ5HRm6AHrivMzWdRZbXVP4uSVvXldj2uGFS/tzCuv8Cq0732t zK9/kf6AX7M3hHwBf/Cjw7fweEPD17eahp8F1cyy2izSzoUHLZPIIKjHTj3Nfz1f8F1vhN4E0jRP 7Y8O+G7bQdU1mOCa4k0xDHHNHDfwxM23kDaJRyOy9a/gTw1zPMV4vRo1JvldWzV/7x/U/jpl+Bnw lHFYdaxcWmvWx//T/LOy8N2tnp2oQz3q3t6oSTTtRi+ZYwMblx3BHH4VWlv4rfTo/PieC6nYxImM SuOgJr/XCLu0f50QX7pv1MOw0W5N6dp2ur7ruWZgkpXrt578CtiGxvbaeSVJQFkmLRnfv8tB0B9+ tdXMzlpxbRhXtnqV5ceWttcXUfmGeSdIz5ceSBgv/QV2FpaM9nLEd+mpEhSNlch1AGckn8a0vaN2 NxleyMm10a+1SOSSTUlmMIBSeJwjtsORznJ6dqkk/wCEgheCSVka2uMokoud4BU4yV6j/wCvTurJ m0Yzuf/U/JqVLkaot2+Y0cCNhANsIOMAhfXPPuTXRJoUx/0+7unmiiG6VZHEch3Ht68fWv8AYO9j /N+cZWszBuc3gaK3gkgjhkObhpPml54249MVoT3Ec9ssc8wVolEccf8AG+OCayUuWVjJRumlvYfY BIponNtFPF02yJuBzxke46/hVu9kiuZSYozPLuAWNiN2R02/lXQpXdjCXwIptpeq6mklvDFEJWXc hVsmMAZJ+ox+lbDs66TNazWQvIvshgll3mOQMcDd+OG49656klGVi6MHK/o/yP/V/PLwx4ZM5s4b a7txPPbomlW0+1LezYZLFj1OFBO3261/VP8A8Eyv2AovC+g6B8VRrNvqh8RsdakmSdASCIykZTbn HyMMFj19NuP9B/pBcS1Mk4Xp06O9Rtfcv+Cz+Yvo55RDE57i8bVin7OCS+b10+S/q56D/wAFi/Bn gv8A4Uf9vOh6fa6zZWsn/E1Fkv25TGjhtsnoD5TegIBxX8bkkOpNJLDays9nHp8K+bGSzyqVx5rM O5Pf1rh+jXjsTiuEK6xM3KKqK13fdO/6fcfMeNuHpU+MpRoRSfLrZW8yqkWm3NlJaW4upZLQ+UJ5 ch3dcZx6gnir+iWvlkLIpRHGHkxllz3yfSv6Lpzuz8YdOTgvma8mltC7NLIoQOUjZWy068fNjt3q K38PT3d0QrIsIiMvmzNsVRXoU2rHM6Uz/9b8uLm2gguZYBJuH3GIXBz6j9KatrJDP5L/AL4BBIki sCjDA4PofY1/stJ2R/mPyyvqXo5g6XcltdtamUhPssfEDEZBBH41z6gWVxJbiZhdumT8uCqtyNpq 1oyIPdGrbRwyQSwbpJriScSQ3JcRpGvO5Gjwc59c5FRXWnQwB7aBDDcHl2Lbgx9j6f41tdLqWaGm 2IaFVleQ3EYwVj4jK+re/H863LnTrT7MjouyNDhtr5dmA5xWNSai7o9HDxdRH//X/MK2tLuTLNpZ SIljFLPCokmxxlGznjGcZqtcWrw31lbvZbj5nmvI3yyxZHGB78V/spRn7zTP8x8TTXI2janggnUX kizXGxGhCMSqoVO3OfqK5kQypMlzEqJPFIArAAuRnJHPY4xXbhZXk0eJmdNwjr0Pa3kkurDTZpre JJ0slLNZ4HlkFgGbHRiADxVyC6uzBJI0/nNs5TPz4HtXuwVonx1ebc3FbmDNfPZN9rtrSe7vpZNo tXlEKbeh+bt+FXobSIxJdSRyeZMC1xDJ8ywOxOQD3HTn61rC1zzqrZ//0PhJYLGd33ziFol2pEAS 05zxjtxVsxajHLAsYIt8EBQMR/U+9f7kH+MCk+jH2Cyw6gTDbRNtfzZ3bksAMlce9Yn2yTWZb4xr JpyC4dWQkQyINxXKj+VO6tY1TbRrfYc2trbwSSo1rH+9lTBkuMfxNx1NWdJtLjU7G9uftHnR2ymZ A/7tliXbyqnuM5Oa2pzsrIwxCu7s24La3eCIsznf83mscs57/wAqx9ZvY7UGzgEUy5/fdGK4xjBr TnZnTpp6H//R+H7fWFu7F9MihjtnxumfyOZx6B/XgVhrb3Du1tDaiKGNdrtGMqOuSfSv91FN7H+L jhHY3LK2ayjixNvjYbwVHTPrV8XFujlrgySO/wAqOV4HsT+Faps5JxipGZfNZRtHJ50xy37wQsQq jPGR/SsjUbG4iu4zbZW2Q7Y/4S/Qhj6YwRis3Oz1RKppvQqrNeWVx9vihM7QxMrps3ltxAyB/P2z XS2v2VbUvAqWrTs0jlOMM33v/wBVKM2txVaSeh//0vgZbO6i86WQ7o5ptiInKDrzXTR6fZWdo0z+ aj7A42gb3fI/+vX+6znof4iumuhj3UdreJaxATh7gs0sMw+V9pGM44/An0qfUoraKTRbaO1W0a1I NxExJ+0Z+6wz07Y7UlUKjTRoNKZbhLdVaOMfMW3bQfarY0pBbXk0rwLHs3KCwDAg54z3PFWqrexq oRijnn02zne3KXccPnSb5ZC6md2IACEdcZAGe2a1l0hbZ/mVdyjO5W3HP1pxqNrQUopI/9P4hkne S0uZGiCvZXnkQhjh5/lB3AenJ/KtfRLzT7sSRN5kOowgGSJ0xEAc42t/T3r/AHejU1P8RZK6sWNY u7iz0+WKGHzZ3YATCUItsAQSSpGTnGODxmuG+0TuDM0O9t20nIVkyRya29p5EODSI79bm3Vbva0u FBGAXPA6YrUXz7yKGe4DJFIq7IGj2MhbHXuOvQ1akmjlnB7FeS3ggkEss3lNESUG7bnqPyqpBdpd M0t3vu44ZPlWJwGXHAUHp+dbw2OWUNdT/9T4MureR/LlgtyFEe5EAC7AOcen+etWDHeXcOmNFbwo 6QeZdNcNmRXLthdvOCFxwfSv98D/AAyjTVrkE91cRt9mKm33v+8ZPlT8/Si4jjijGdryo3zNGcsA ef8ACgbppj1sbmZlWPa0cyfJnHzZ4x9azpQ0N1bwRyrAYZArptByoOGGKNkwjSV0WZdQW7ubi0id rWO3OVUfK8vGRz6HP6VAljMhDzWblZ1IUTIVVx3ZT3/WqpyV7k4iF56H/9X4KQJZ+VLCGjMZHy7s shHvVa5jhuo7ea7kRLieYjy5iOmeCPyPSv8AfdO5/hU4NELR3G1vIZTg4jB4GOaIbTymSCa5Yzkb 3bbyG54rbnXUy5G5DnggldIQ0ayRRkCd875cnJBP1A7AVJc6Y9im2YoTgSJIjCRGBGRzTU1fQ1VN 21KbBopULgSu4xERyBn+oq7p+nsGnikY7N5BZ8ZVs9K152awp9j/1vz5fTJZp5FkmMgtmPQ5dsAj H5Gs2aCSHDRb4ATuSSPiSQZ7j8K/6BVUsf4ZcjNRLZi8N0t6jRvGBJbKpEqHvuOMY+lV9Qsprks8 cL+VGAoaCUxuxz3wQfX8KOdGkoL2Rn/YbmBUaTdjkKpcsce9TrMoiG5HjaPIII3M3XGf8+lT9mxx qbvqRNb3LqrNDKqH51kVSo47A0skj3bQt5S25gj8nIGM4PJJ96i3QvmR/9f87DDCgEZJkIG0yY4Y +3FSLDFauJd6NJKPLVf4wO9f9AL7n+FyktjZht7aOFriaKOUuvlrKesQPUfjx9MVzkhNo8suP9Hi kC7s+aTnp7noa2WxPNr5EiyLNIkqbtj8uozGSPb0qxcWiB90SssGzhXl85/++sU7E87uZVwsccAM au9zu24BCrsOMj696itV/wCWYDIrH7pPBPStIWSM51Hsf//Q/OC7a+tD5QgiEcQVy8i796sOcf8A 1801LcbNxlwZRuxGcf56Cv8AoPb0P8IZVH1Y5bZZ2fIkO1Cm5SQF59OnapBPPbRx2lo5kieMRymS MDbj09TwOeOtZWurJale1aSHz2T2kcdwVUNOeMDLMB6j88fjUiXN5tVIHKWYbzZ4iTkMBgED8T+l XHS+hftNLNlhLiELIvQM+UJ5PPqay7j720Rr3ywByfwqzaFV9z//0fzZVZITgcpIPmYn5R04q3Bd LG6oiZfONw4z7V/0IH+F6q+Y54Ea5EjRCONZAtwM85yen5fpU0to8krCCMNFkbDjGBgZz+OaBe08 ylvSAgSxtIgPKhgufxxx+VRshLkxo45yATuBHbmgiVRvRDxbzXLOqxlvKiaWR1BOwL6j9Kpwyho8 7WH8J3DpTSb2IdRrdn//0vzfjtsBZHjK7lJSQkgMB1x/9ahZJUzLE5RQDhs/dHrX/Qhsf4U87aNS S6gktIrd490jAsZS2S4HcDFZJWELm2SUIPkXzFILHgH9c4oJdTzLBJm2WTpNBcQSEFSoVJMjo2ee P0pFg3qwTasmdpD4AH41ryrsJVPMqgFZ2ikZQq/Ljg8/72cVHKFLHDfKpzhT1qrLaw/a+Z//0/zO iB3rJwPmwrdMYpDFLM80zXKzoJCg2nOTzkk9T071/wBC9l2P8J/aa2uOhsoyyNh/3a7AuTyOP6Ck 8nLMFfADcEDkULQvnaLawyW6yTmaQwuVEgf5ljPC5HoDRqYtsqttHKdqBXkkICTH1Udvxplqo+5H aCIL5UkKshiI+ZjlPQ/Wi2eOydxCivC6FGSQb8Z7j0PFBftPM//U/NMXUeou1nBZzAq2CnlkhwPT jms64x9oe2aJo/KIjy67cf8A6v6V/wBDB/hj7XoIYyjhYTnIxj+HvUJs7v8AtASNZShoIGjxCDvn zgkEHJyCB7UE+18y3bxPPG8jQSoEb5j1VR05xTLiwMVzHdQyNJGISuzP7sZ55Hr70WD2vmS2QhAa cxMSchkfhgeQD+FWZmUgFioUdcDn6UeRn7SVz//V/Mryt4Pl7VI+aMOMgHtn6Usy3DQpDLsdUck4 QZJPBwfwFf8AQ5DTof4V+1kUkSVZGBwIyMbSOev/AOqtWAoI9oMa7TkAqA5/H+n6Vb7WJ9o76Fe+ DOIJYZo38wt5ygEum04APbmoo4FaSN7o/aIojmOJvuxeuMevJ/Gokkuge0sSXG3Hl28SBN2Y9q4Y D0z3/Gnl7hvNikYodnlDYNmzHHP5Uvda0Qe0a3P/1vzBt7YsCgkLOnbqCOc5p6xjcUbh/wCH2r/o Zsz/AAo9p5l2HT1kt2d5wGSTaVC4LA5/lgVXuowI47eLIij/AIc8MfX8qajrZj9p5mOILozy7goh QZRxyze38qtRx71IPBP4jitFFdhe08zR+z5iiELqFC5kJTk/Q5qC5iYqY8nIXK4PTNUL2vmf/9f8 s4FNtEVnkeTaxc7+T3/l0rYhIuIopbcqpyCPMXAAzzX/AEQH+E/tfMs3cCbMOFad+RsIII9ePwqk 0O1BtPzAcfX0oa0sT7VkbWNwyq0p2EqGYDp/+qpLRUllZGYR7FPBwM4Gf6Vk4rswjVZMwmN0shlD IsexUVQucdyaiu4bl2DIA0JG0kn/AFbdc++aTST0H7S6auf/0PzJgtZJrbdIQ7RjEhjUhVx1+lNi tkk6ZI6fT3r/AKHFPqf4P9TSt7JNrxNdh/NBEco4WDnG0j8KrxwTqXUSK0YJVQExIB0ye1LnYFZ5 nsossZbllfbHFnc4BPOPzz+dXVzIymUtkYYJn/P+RUt3Cw2eFZJg4/g+8vXHvSzLFEvmAYV+Aud2 KlySdiXBN3P/0fzLjgEQLKhAYZCjoKcr4Rt33umM8mv+hg/wfLYSTyd0TLll7qTt+o/+vQFJCKCH k24bau0E+w+tBHJqRGERxuTGWlc4wMB+M8f5NXJbWIR2shRopRHmUeZnkk8Ht0xQVYrOYoQXMuxS wQ7j6nFEqS7xDgi2C+Z5gGRL1xgZ+opSl5CjBt2uf//S/MK7H22zms0aSMyzKTNkpLGFJDAegPer MWl+RFCBI7KybSMEKuOBj16V/wBCvtEf4Qxpve5AYGgkQRzPsRcMrfMW4x1/CnBpJW2p/F94+1HO jSMVEsT3GzyorsytEkZjTb1jGSRj8ST/AFqpBsdGPmlmziNQM7ue9S5t7FWsTKHLZAO4Dt1GKOVT BUtgjBY5PpScmylFvY//0/zVEsqbZImKgAEggAKfarmm6rYpdvFc2DX0LIYpIhMVwzDG9TjqOSB9 K/6Ebs/wtiuVakUEX2YGawmWMQuY1jKEOoOSGPb2wO9VbmNguRiSZuQBwc/X/PWhydimCoUiRyds mcMncf5/pS/usMs22SWQ8My/NCuc8fXH6VnzolpvqRvAoaVEKlUUMT03cgDGfrQlun+sEqJsHzI4 +Z8nHy/pRzojkZ//1PzIkE0F2nyB1yAyg4OD3Jz+g9asuVZlVBtLN8qnjPtX/QZz9j/CdprQbD5j ybfLZ5C22OMclz9PetGWY/apobzYk8IMTqV+4yjG0gcZo5+wkrGZLcIf9Fw4lZwykA7GAzx+n86c IZX2pjJziolN21Hy3ZbuNNYww/bEIjY7owj48wqeCcehxwf/AK9QBo/Ke0miNy0jAhpGyAAQen4C sed9C+Rn/9X84Y0iE4iCo0YOCANobHP8hUt7uby2sESGWOUKUAwhQ8MT3z0IFf8AQHzs/wAKvZvo QQ/aNNjnaRvNtTMVDDlSevB61PHczSlysafZli3CR+pJ6ce3WjnZSi11M543uGwih2XLfInzEdc0 wWwxvOIyeSTxjHrU8z6lk9igFwIphLJE53na2Bxjgen/AOurlumyaVoQ7RgEEL1A9/ypAf/W/OK1 QyXPmlUHbc/K/lU5mSR9t9aw3MceWCQp5EZIBCnj8/ev9/ZTs7I/wwTsPjmmuI1VGaKID/VqNvr1 9azZIlMnl55z97vms29TZJrqW42nt0QBxINuJT/y1f8AwqO3D79wJVd2cjgikMdNBLLI6+Y0oUbs ufmX6moIbMyXEXn3b2tuAfNYR+YMc87ep/Cmm1ogP//X/NQIHeO4gE0lqbpoLa6kjMSyFe/PHQjI z3remkffbOki3kjHcVQMhiPTac+w7V/vwf4bmXHczK8hjjEVwkpB85cx5Ht6Uis7sxlm3u/LSEck 84x7UCaurF51QW0duihnDb5JWXJbjGB6DrVcW+2eFI8LtO6VWG0gYzxQYtWLM94Jp0HlFFVdm5V3 k4/QVBHNND+8IUsjEoQg4HbPrWbn2LUFbU//0PzrSzR8XcoB4xu43DPOMenFVp44wSwwxB4A6Cv9 9PaeR/hlKNkWI5sGMsgjTbt2KcOw9fxqq0kiSb+mG496FN3NOlkXLZ5Lu48qNHLTHBCqTx3rb18w hdMtFUG2sifs4DZkHILFvr+XFZ9bDSsrmRc3kTbgBuLpsbPPGf8A61ZtjYRNdpHaMqNKdpVTxHnt igdtkf/R/Od44raYxKTIiv8APjjB/wA5qYSpIomiVSFlI8pxu+6e+ex6fhX++KbWx/h5yWRTtkth LMU4nDASAcqCecY7etbllDcRXaSRLGViyLiJ03nbgj8CP6Ug5brUsX2oQlzDI08Vtc4geOBtm887 c/metV9NjtrI/MHmEa4zIvLD0PvUOVnYcY8pdSOyup44kBtm3GTcX/dTZyAvtjrVXzIYWmt4sSI8 uXwxZdwzyKzbu7mvKkrn/9L8/kt0z5oLbejDPBx6D8atw6lJaSQNsYgkxdcbFPWv964tpWR/h3Vi lIin1EXN7Ks4JjdAEkBySfr/AJ6Vm5i3sokAIbaQDyv1q22kZ2Qy4ETll8xjJGOQjY2/71SGC522 wD+Y83KAMGVR/telZXYehZimvDIllBHpqrINl5Pcweayr1OwnkH3HNbZurez8mGKRJ/MOyN4VPlu w4KjI6j0pDSjc//T+IZ32Rxu4IkBO9GGPwqWytoLoJPLGywiTaNozjJwTiv95pptaH+IEbJakmsx 2/kyWdvLHAyoHEki/LtB9PwP4msmzuFtLciM5gk+9JtGXIGDg1ibwlpdFvSXLSTSmUJDLnzPlJYl eg/z61Hc3Vy0sZWV2slfLgLscY6A/wBfpWcnKJ0aPYs2xRxvMnlNJJ8ucAHPbFWL6IvIJXnYp8sa jfgLj0/wrNtsPI//1PhK9aF4ZbbDJJn5Xj6n3ptlbNLE1vJOkcSMJirqPMkYdOfT26V/uo5STsf4 nNLZmtbQosDz7T5cbFH28hsf/WqrDFpuo3e+5laBLVCYFVCyyseMNjp6/hU88iHFJXNrRLKL7dcx 30oFm5BhiVSkrkZKlXB4x1pPFFxBd3XkRvEWijUtNHGDPGVyApPcYo5pAoLuYTm5t4FmXYEmby0L ECRyOc4/ClMsU0UYJ2zKfmBHytjtWbqSWg+WKZ//1fie3ihtDJO0srFlDeVnMUYHoPfBrYkkt306 31KKe2BYGNYUk3SSHP3mHUfh2Nf7me0dz/E5q6sc20QncFUZYYR8pb7i47f/AFq05NTk8qO2kKIo G0SD9OBR7SS2CxVmgnurdMsojwW3luT7f59Knsr62eD+zdQtfPaFAqb1x8m7KspFQ5y6G8fhKOoQ QvqEEyxQiESodjrhNqkZGfXjiuk+xrHd/brR2iD8rCGx5QII4/Dip559gUYo/9b5HW2S6S4a5nMg QBIo4Y1hWAcAA46g9z71g6vBHKsEWYrWCOLywVjP8I4OB+X5V/uPzzP8VlBcxQ0sXg0+aSCBpTBl pFHyuyjqQKsQ6jc26LdpFt8obFjd93lg/wA/rVXkZyUU7ISXVZL50Lb53kBMq4+QKO9S+THKUuoA qRFjGEiOUZh2pKU7ambt1Me+kks5DtjVJMgsZFzx1/UfzrUTU5brTre2PlxMlx5iHflWBK5G38KE 5FpQtqf/1/iDWJ7vVJIbJtLNvJbN9oa9iXZFtOBtJJ5B44FVI5riyJuJkS9Ngo/0UfvSsZ4LBgcj BPb1A71/uM5O5/ivCKWh01pbxzxpqs5UwOA0VnKPu8BslT9R19KrQRTXH26SK1WKKSTEcinDHnkg DtWbm7andQgnoR61fS2emvaTWCOzPGftcuWeNQPTPqQeemKqNIZLW0052lnbCzRMxzKSSME4+n6V nz+630OqFO0uUle9vbxHjvGujcQzi2VN21goOA5J5PHb2NeTfFyxujo15596Z7dLJ1M0DBorEMpU F+24HkZrx88qpZRiJP8Akl+TPsOEaEp8RYNR/wCfkP8A0pH/0Pyi/wCCeH7Jek/tGfHKz8NeL21G PTINVWSG80uSKaa/C5cxyh+AjCMrx/f9hX+hv+z9+yZ4Q/Z2+HWn+GfCDRjQrFYbm7triCMIiiJE aMKAFxgc5HXpwBXBxLXdfjHGtP8A5eS/GTPey6iqWQYdNa8q/JH8G3/BabW7m+/a+8b6Dpel2una Vb6tdQRSrAqwXjRSFWlDADj5APXJOTjFfi/avd2l3GJYkWTzgSiZCsVbPB644rsxusEvI8ujFxkf 06f8EK/+Cgfiv4d+L5fgprGmJrPh+fVCum3MQLy6ZJIQ7b93VcIigeo9M4/u50rWZtf8ONeSGP8A f2BuZDOVFsqlCSpB4A6jnivhsvxE3nVfDv4YqL+//hj6nHYaEcnoYhbycl91v8z/AD7P+C8k9rrP 7T1xDa2FhaXGlW09jYwaYiRy3yb4xJlhwceUefRm+tfzoX9peHVJLZo1ePKlvLfDwZzncP5V9HiZ r6wl5Hh4eD9m7n//0f5Y73TFjMsMk0cDWsYkMbZZzxwDjoT7+lc+7xxzRwqg82RdzEDqB0rxKj5a qij3YQvTbNSG1lv2A3mNU+XywPv0XGk3Fgzzur+RHCCqopdie549KxrScZaGUKSdyO50wy/YrueF 5pIW3woEL7cjHI+lMkRZDGAuJHYKgIwAfT+VU4qVO5zvSfKZ7Qyy290yogubKcJM7P8AugpOOKYu W2lTu46Lzk+1cVRG0bW0P//S/kwtL2OW/eS6W4hdAY7R4G+Qkdd47cA+tdBpGpNZ67Z6kjCOKGQR yKse9mwchl98gV8ZUVkrn0FDqj+uL/ghN/wUH8R6FrDfBbWbKDVtFhuZv7Gmnt5pL+0aWRmVAGcq U+dcdAMDHev7Rp9VFx4ae/jtoRHNp32za6eUQNu8jA7+n1r5zIalVZpi6VTZSVvR3/yPrM5o045Z g60N5Rd/VW/zPwO+N3/BXzQvgn8X7r4VTaJc6zq8GqCGWFLZWtLMGXbsY787gAD8wAOeowcfsX4E 17w/+0r8J0l1nT41XWtElt5baS2EjxCZMBlJJGCGHevpq0v9vprvc8KlG+Cm/NH8Kv8AwWb/AOCf 17+zb8VNY8b+Gr2z1HwzqUDatZaariCW0hBCTJGAAmd3zfN1wMHsPwHv9Ln095ZLQl2lj+591Fbq XGO/NezOd5JHlxptJ3P/0/5YLHR9QS3kuCiExtlBjDZ7giqNqZzLcm6tgJGkMqyK2XOBgLgcY714 Tk4yPZdO5A15FEtzKbaeMxsGvhOrIqoOA6KeDkenpW61hZXEa3Ngi3RMYmwFO9QQCcL04/yaiu7J PuVCF3YqS3MNnPFa3E7yeZD5kcE+F8ncegHbp0qJ7FFuTcWwWG3cBpVJ6kfebP0rlqJqNzopRXNZ Dr+ysbU272zvNNNC07RFOg+vpyPzqraXd3by2izWKXNjv8yZoZBHOntz2p0F7SDaNal4S5T/1P5d 7aDUZru21zQmtodRjYqJY3EE6ovIzj3xjPfvX9xf/BEH/goBq/xL8LaN8LfF2nQ3Gqafo6WVrq8t y0l7c/ZiUnJccZBIwcDgjliSa/L+JfaU6NCpT6TV/SzX6pn6Vw/GnOdeFTrB29VZ/wCaP6Mviwml 3nw18STajptrcWz6LM8CXimdOIXwxXp71/mHft3T2c/7R/xLtoNNS1sLzW21K0jsLX7PZ25GVmxg YOSy+p+X2r7LCRf1CfyPksTZYperPhG90V4nM9nBssvuxI6FSzDnfnpxxwO9Zuoxv5CXARrm5LBZ CDye2c1xSi20bfYY6wvpYU5sY2iI2pcuzCaEjqo7UtzJIw8wKVA6AdR71m1bRkH/1f5Npb5EKG5L I6sEQqCxYtwAB+NaV1aXFtbR3M5ECsNwROFYE8f/AF6+OWx9C3okXcbY9krBZWxtSPEiMpGfvA/T 86qSk29zCluy7UYNcCdfkxjJApl09y7ZTW148kaGFHLHy2jI569KraoLiO2tjdrCpWdtk+QJ5FXA xjPT049aDQzluLuaTz1fdFwCm0KDgY6D6VpQR2l6zJekRRN8kh7oDxuHrjrj2oA//9b+UfS4JXlE EeVt7eQxrK0eImTkD5umenFXN1tbNNFty2793sXJbHH+fpXxz2Pq7JtIijVZvNuJGdreMZSMpgoR 14HJq2kkciSKp2NsxDcnlRnrleuBjpTh0Je5Wl8i6ltp7ibzHtYvIjFsvkRtwBnaOD68+9advNdq 42MoRl2sf43wcjPr/wDWrog/esFrK59J/BmFtS1a3nK20cNjumn89wBNt28Be+fT6V+o3wasNQ1j 4j+Eo7S4uW+1ajDcXn2S1UbUDo0gdmHygcdB/DX9feFyVHw2xtWXab/A/nji9Ot4g4aC7xP/1/6y P2dNKl0n4R+G5Z3jlF1px+zJbjm2TagJJ9cr296/m/8A+Cz95c3fiPw9HDFHIdP1SyuJIYZhmTZF M0pH+0CuMe2K/SvBqCnx3Fvo5fkzzPE28eGpRXVI/nR8c6nHai4vZbGO7tooGku1c7IgrHapz1G0 kH/Jr8fvG81pe3ertbW4huEuZFdsbTJli3B7jnjPPFfsPj1NxweGh3b/AEPzPwupJYirL0/U8NAn sLtLlQrtG+5FlGV3e9WoL64e7leYE3BO7d1EZ9q/lOTdmfstb4jf1RJdSsLGNY42mt2J+Vtu/OeW /Ou5tNURpLCC3VRdWVlGkjcKykfKNrd8YGa86vszSFr6n//Q/jsupBLGkcqA3BTdOy9O3OOuKk0G zeTU7aOC4WKLcsapLgRKT1zXzU9zsp9T2vTrOT7cEmtVnGzy3nJ5jI7g/wCetbCSz6VPNaTizuLa 4lZoLqVisq54CHPGBk8j0FcFVX2NofEiDThcs6JJbyJbJIYpIXJ3fL0K9cg461pG+1mHUwlhfNBa SQMZYW5ETKQECjpyCxP0riZsS37eGZdPgl1OK6Opz6okEeqwXRRRIpA27FXJbJOeR79DUjf2c2ZP Jfy5iYnaWIo7YOCTn+Z61z1VqyYNKqj/0f47Lq8Vb+KDUFiHkED5HEuxei4Pb/69RW8sCRzzXpVS tywgEeXVk7EnHB9q8jocdnyO5GbCKGd5JbmRw6+Yi4GFB7Hj2pt4wtLaFY7XyoWXcnlqW3gk84Hv mue7uSoNq5lpI0TuGK7l+Yhx90Gu58OXEVpcfabq2tZIvL3CK5gEoYg5Bz1H0/OrjJt2ZUYtPUkt NUs9SvZJ5rdbOVppgLFvmtpkz8uxPUYz+PtWlHdabpzrdyuDvjMLhl/1a56Af56VvB62OjkP/9L+ RLXL2MX8Jjml+wvEhWFVAA4+Zg3XnsD0rjr2w1Czt7q8SaCe3u2aK1FxIBLn7xG0ZYcd8YrKm9TO mtTzG+tLe2VzGixKCZpXUnYzE5YAe39azbO8nsnjubRgrhw8c20Mqn/aHocfrXoQlp8xVV7tvU/W v4C3d5qfw7EFrqEDW1gianK4uTD5TTrulEa55JdsDHce9fs1/wAEr/FBsf2iNNe9KPpOkaZHpltv cpcvLLIhXdJ1O0CTPP8AEK/tzKOWr4UOL/58/ofg9ByoeKFGX99fcn/wD+6LTVs9U8E2SAeRbXem iYtnzRErAv8AKSP85r+M3/gq/oy6F8ZYoPtVzqizWl/5CibzYraBbq3Vh5X8LAyTMT6NX4L9HxqH iJOD7T/BM+18f6UnkUai6Nfmf//T/KCO2h0jSryDTrlNPkRA0dqq4+2ByQfpjOea5K2ieRIjqCXX 2ETj7T9nyV3sMZGeO3f0r/XylrGyP82aztdDWiuJJRHZyzGzgk2uQ5idVGMMVzyOnHarUmkwi7mu pNQuHtYzsfa2yKcDuQc/T8aqS2Jpz6F3TbG1vrq7mjzDawBdkbOzo5HQAHuOK7C21zUYJkiheZ4U ZZvNhkaOa0eM5SbcDn5ep9s81w5rQVfBTpSV00/yZ9JwnipYTO6OIi9Yyi9PVXP7ef8Agldry6t8 EtBF7dPdRwaBaNFe72bzZdiEgjtneOK0/wDgpx9ptvhPLrOn28jalZpLdWjYxHL5KKxTOcjr17Am v8zczwVOj4mTwyVl7Xbpqz/QnifF1KnCDxabcvZp/NJH/9T9dv8AgmZ/wUS8S+OooPhdqnhey+3W c0dnaS6fO5W5jIODhjwVXavyjHyjpkgfpV+2D+x94M/aK+H+pR69G1hqy6c3lXtvbiWYOx3qGIOS N3B6dcg8V+ocW5fV4G4yhi8JLRyUl00/p/geRgKUeLOAVHFK0pRavbZp7/10Z/En+0Z8GL34RfEn UvhnYRbDpd3DHaXBsfLFxHI7FI44ics20DLDjJxwa5TQfgv8VPET3OoaV4J1TV9Nt2D6VJa2syST yJlZQyhcAA7seoAxX9yZdxVhKnD+HzfGzUY1Ip36Xtr/AF0P4ypcO43EZhXy/Bw5pwla3+b6HZ23 7Lnx4f5rP4c6qiyv5tzHqdpeE/NzhWjhYY68dqTVv2SviraRhU8E6/JqDHfN9l0i5FlZq33WLSRp u5yMKT05Fcq8SOGoVVSlX079P8/wPbq+HHEEaPtvZrTpfX/L8TxnxT8OPEPga4hg8S+HvEdpMbkJ JfX1mbS0jB2gEDqQMjJyeSBWXcaMsd1cWiWepa1G84l02y026WPUZwxAjJ3HHXkr6V9fhcypY7Cr G4VqVJ6pr+v+CfJYjLKuErPDV1aadmj/1fhjw9+zB8efFsFxNp3w51WTbIv2Ga1jmvYLiE4+ZGWM At1+XOPfvXWw/sdfHaC2upLv4UeNhcouEvbbQpt0bH5dskZB+UjqRniv9NK/iTw1Rm6E8RaSdno9 PW6+R/EVPgDiKv78KGnqu/r8zWX9j/4v6XPZRnwD4kYNbpJevLoU9qIWfowJHQZ6EA189+NPDWse E9fvtK1T7dpN9pkrRXFjPA6ygAgLIuQPlbJ98jBxXRlPG2V59XeFwU7zSba8k0v12V+pw5rwxmGS 0/aYyPLFuy83ZnCa3pdzYXNtJFGIori3Z7mV2ISTOCrAdj94HnsK98+EPwj+LPim+e4+H3he/wBV k8PmDVftUdhJcFg2JIXVcYADEDJOO2ete5muPoZdl9TG4l2hFanJw/gMVmWKWGwibm306WWr8rf1 qfux8Df2s/29PhD4a07w03wfbXJ9I0/+zrVtQ0qZYnjHzLlCQcqBjhsewzivi79uz9pn9ob4wrb2 fxI+G1r4WS0gTbcNDOLa3+fzBsLZXDMQSinqi5Jwa/ljhHJOHp+ICzbCTtLncor53S7fr0P1rjDM eJJcPyy7NG+SMVfTtb8D/9b8wnZAly9nGhmOEbZgRgr2A6DrWr4K8I6j8RPEdjoNjpc11qZiyxih Z4YMsArOcHHPpzgHiv8AV7EYuOEw8sTLaMbv0SZ/n1l+CqY2dPB0ledSXKvVtJfmfaLfsFfHyO2g i/4V34m1691UfaprpLeWxgs0/dhX5gJI2ryCc8k59eA8Xfse/G/wLoOsaz4n+HeraZbWULSNHcO7 xrHuVUlLeUNqE/xE9M5Ar4PCeK/D+IrexnJxbfKtn1sm7P8AQ+6xHhlnmFpuSSdld7rpqldL+rdy v4E/ZY+OXjzTJdS8C+ANX13R+Le61JYJRplncL99BIsZ8wDOAU4z/FWf47/Zj+M3gOC6Xxl4F1XT tLuVFtZ3bDZPdsyEuqKyjJ4bAUV6UvEfIKmN/spVP3rdvL87+e3qefU4CzyhhvrtWn7vzv8Alb8d Tovh7+xT8avG2iWer+Dvhv4ou9Mznz3sJWkkTblgF2Abs4zgtXGeJf2b/in4X1PT9A8TeEdWstSv b99NttNl06WwuSQpcFd4252qcDPODxW1HxEyKeMll8qv7yO/bTt+nf1OPF8I5rhaNPEuHuzsl3u+ n9fkf//X8/8ADf8AwTy+P/inT7C9sPh14nFtvExDQBxJCE4KlI8hjgEFsgd++IvFn7D3x18M+GtY 1fX/AIbeJ4NIslJLR6RJczrCi/O8uFB4IHAz359P9Kv+It8OfWvqvPq3bt1t3fn0P4kxHhzn1LCP F1IWUU21rt91vx6nw9qWiS6eRb39tc2moWszKsF3pcmmMkZVXiJRwGJZXUnPPr6D0v4XfBTXfiXq +l+GfD2g3mv63qsnmn7JamY6dH0D4A5BJUYPc+gzX3GIzOlRwbzCcl7NLmv5Wv8Aj0Ph8BgquPx8 cBQi+eb5UvNu3/Dn1g3/AATH/a0uhMlh8NJRbxRiW1mlaZGuVH8SBYsZP90kfjSS/wDBLr9puK8t 54PBOuRSWdgt1e282lT3EU8vJYR/IDjHGD19a/Pn41cJxn7OU3fr8Nv/AErv+B+g/wDEIuJXTlNR jZf4r/dy9j5e+I3wq1nwDrV9oms2Wp6HqtiWtjLPYT6fb+Yqr5qSKV+UgMeP1644vw/4M1nxHFb6 baS2jXFzcrDP5c5TywuCzL8pOcdMjrX3+FznDY/AQzKlJezaUr72VrvbsfC08rq08y/s9L95flS2 u9uvc//QPh1/wTd+O+sN4Z1LTdG1abR31ODVbl76xmaRFGyQKG8oAp3245z94Cv7AP2LvCepeA/h jp3h7V9Oeye3tPLhi8oxRRFdqDauOOBX9P8Ajtxvl/FGChgcI/4TfVb9f07nwfgzwZX4UweKqYy3 tKlvWy6ffc8O/wCCi/wJ8T/Gz4WatoXhjSDrV2tldC3gEeZN0sag47dVHev5MPH/AOwp8dPhJpt2 +reDNetdMW1AuIjp00zF2cMjCTZgKxwApwB2PY+p4C8d5ZkOUvI8dK0qk00/66an5R4y8LYypm9b iGCbpKKT02tofEX9mSyXd1YtAthqFq2y5tgB+47AnHr1969z+En7OvxK+LeorpPgXw3quvGzVTf3 kFi8sYLMqgHaD/fXJHTcK/q7H53hMmwM8xxk0qUVdv5dPX+mfheAynE5lVp4XCwcpy7dNXv6H2kn /BKL9qi4md08IpCWRWiju7a6IdOpwPLAH8zUo/4JU/tRLqD3E/he9FhbBR9h062uGF5jjashhIXn rnNfmUPHnILyUI3S2fMv6+4/T4eC2aScXUq2vv7r0P/R474tf8E6Pjr8KNKg8Q+JPC2qGySWSW+n +yTJBYwvjy2bMasShwD1GGzjjNfBus6BdaPqWoWBl3Tae2ye2CkyqRycfTOPqDX+r3CXG2V8XYZ1 8FL3o7q99O9159D/AD84t4SxvC2K+rYlXT62t8rHJfNHeyiS3aSLy1kjRvlWUnr+oNac1s91dx6h hMxxiJUxkBRgDPr0r7lbHxEFZFOCCY3E8i4YCTKRL8ucDkVVmF48yedujO75O+0DtmmEXc6XSjNp 1+lwZLee3nj+4Xy7HHORX0l+z5+yT8WPj7q0OoeEvD8t3ok0sl1b22n3r5kQuq+dcFo2VQzPhYx1 HOe1fPcSZ9hOHMtnmmNfuR/F9D63hfJ8VnmNjgMIrzl+SP/S761/4JIftQs1rayeGr5pvtMt+pUF o7KEZCKWCDPXO0nnpWFr/wDwSf8A2q9HEWsT6T9rtoQftUR0iaKWQbuvlhWbdt6YYfjX+jmB8dOG qlSNKreLfe3/AAP67n8V5j4N8Q0ozlTSlFa6X+fc+Afil4G1r4ea5L4V1vSr/S9UglaA2tzZG0+7 Iy+Z1OVIGfUE8ivH2s2FzvZGKbdqzKeFJr9yyjHUcdh6eMoyvGdmvRq6PxDOsLUw9Wph6qs43X3O x63p3/ILkkuJjIEhRGWLCbgqhQePXAplhbrIs0wk+zoihwrNlzkgd+tfXqT5Ej82qf7xJ9hlydOv 79bOxkllv7e3+0SnyWjgAyAQr/dJHHGe/Sn3s6xpHbefv1BG3S24XHykcE+ufb0NaxVpWOWq9Ln/ 0/gpdPTVsTQQvFJaXK7liPlszLg4A9OcfnXSaheIRFDZKySbgJEYGR4+mQeme4/Cv9yD/F1Xsx1l DNb6hyAY5FyxP3s9en1rAvrWG51K4ayMheQ7iucqT/F+FBonJR0OjsbmKG1CRNM1wy+U+I920gEH pzzzWOYb7ULm5s7INpdha2oSSSXdG92SAcKuPc8njjFbJpdTCTlLoXdHsZdNWGDVL55bOMMyg5eU 5OQMgdO3tWJNar9omitkUuczgNJhdgyScn2B/KmmnsVCLP/U+HrLTBe6fDexri3llMXmEgbyuD8v PI54I4q3YyR2H2q0aJ7eO6YvHHu3sGHTJPY+lf7qRkkrH+Lc4u9zSiW3htLhpoXeYgLDGB+6A5zn 36Vl3UTyIDEyrGcDb94rV3Rzyj7wraPHbW0t8kbPGTHE7iTzTGzkKCV7DqeBxQtv9omaC6mS1shG T9ruAyogHrgEisXJSZUY8o02tnY30CW9zFdiWPYZkLfZyCB0yBk++O9UrfSZ0+1Pduq2yvuQ/dMi 5xgDmqg0r3OeqtdD/9X4dntp7ux/0acWtr5gSaQgmRVBGdnueMZ9at6jJdq+nxvNFLZtH+5bePtE qrjJfB4I96/3TlJNWR/iM720M6dW+3uYMxhFV4ULiR1GBnOPcH8KivB58qm5LNOgDEOpG30ojyW1 JXNowuJp53jkuJnUjbEpVdoUDgAACt7VNJXSoUMkzXBmiV2BfnlQRhe3WrXKtjS72OWgtLqOe3nl jLwNModDGWZQTwcdvrXX3bGwjSdVeaCc7Fcqf3RH+f1pQ2Jk+VH/1viWScNJAvl7t5B8sjDNnpj9 Kl1kLDB+4UW0o+VmQ+XcZHv14r/dmO5/iI5pLQwbHWby7Iswom8gFmmJ3GTsVY56j+tSC4tLvNii r9p372QcEY5rdK+hnKroaFzfWENlapa29yL4OvmtJKoj4+98hHoD0Pr1qlJqkjlpFxJ820oi/cxx wBWkYNO5yzq30RF5STSpK/7x2YHbMMo3oCPSktbCQPKkiFRIxI8pdqewFdFPqYuTZ//X+Cg0wSSC JWba20nsuD/9aiRpoYPtMUUjv5o3iM/MTwuevp/Kv98D/DJSktBTdm4bbMmAp5Z12/5HNaa+Hr14 rqa38iSAwpKmJMSc4456n6UroqXOrMx2W+s5ovPmbZbMHEQ+TAAAI9+9FrKL+9n8q3QiYB4pZBhk 68A++efpT0sEXO60JNUtLmAxiKGKa4iPlrHGoEkoY5ID9+3X0FXrW++zGOK5MpMi7II3Py9OnPSl TabVhVrxmkz/0Pz8vknMkqvJtBYMfL42c5x/n1p14kbPaXUFqJ5Ikj8mN1DBmIUE88cnJ+lf76pR T0P8KXJ31L99LKbpi1uElMYHlwqAqHHPA/Gq8tjKyh5GZGdcKwOGXPvVhBpPUasUNjHCjr5rqm5p Hbc7D6/hWrDfm6eNZ7OOW33BNm7GR/SnHR6mqkmc/rMRUTRxRTxqsilUgbdNgkcL+H8q0FU2WmFI bh7q5kkNy63IEaxE/cQd+MZ5rcuMuU//0fz5R52mTKMJXHITLA+tJeNJEoT7PJ5hkBErjERHcD3/ APrV/wBAB/ho5KzsaVldIpdjp3k7QArM/mLIcc8dhnsfUVEbggsCMMzlfLXnaPU0FSlakRzTSySx rGNwi+dNyfLnIrPS1mWcz7mZXYlx98Kf6VomuVI8pc1zXvJX/sx0s7hJbyJgUtlBBYdeD0rLit53 t7y2lKxXTRmUJJ8io2DnHTkdh/8AqqFZGruf/9L879GaXyYRqdo6sX2BQA0kmDgOP5/hV3UZo7Wf Y1rLNHKwQSpGWNvkjLtzx+tf9ATteyZ/hMr9QNmJR/o8k0kWTlQxAYdjis65trhXZdhVccLICW/H 9K1jshl61sxcSxAnywExIAuAOOv6frUDGK3aaKWUjY/8XAJJ4/nVJ7GTerGmyUMpmDpHNwrqucfT /CnwWsTSTWkAkkW3xJLczJ5fJ9K0g0RKXU//0/ztnuLkiaCMrkp5Ll1D8D/PBqtaQOwOCQY2wCRx X/Qe9mf4MSlfVmmunhwxVm3AchWIqiB5fChlKtyrDnqef8+tTF6alPSKRde6naJmOxtifKHHyir2 mwwXELPI8cJkj2rFtO+UkEZBxjj3NUnfY0T2Me5tXgYwxupI+6GXczfQ1nTRXTBd77QpwWVMD9c0 y4y5T//U/PRFSayWKRA8sfPmL8q47cVnRW8UayO3y7pCFDnlmJ6Cv+hA/wAJU9EPWERBoLtJMoMo WYA56jOefzqRJbgYVJP3ajBB+6QOxoBySdiS7jWUM7JG6OuCqj5V/CpbW5gEBhjtFCw2/lRSRAAl gCBkY6f4VTabJlJNWRQ0651G2eeSESQR3UD2syvFjehYZHI4yVB4p7iEW8tssA81mDiQHmMDOR+O f0qo2t5mZ//V/NyCOVhIXbAjHyAnlvpT0I3xocAn5QhOBX/QtJKx/hBd2sTNvRmVoWCInL46dvy6 VFHMskKWxlkdI2LRMxzsDHPHbHFRDcRLHbXUs0t3GS7OfLJJyS2MZx/WnMsiF0dWVwCG7HjqK1AZ HpFxP5YWJ1R4Dco8jYJAJGPzBHNU0gjaEsrMJVkKOjck44z/ADoA/9b82LW0Nz8rHa0WcgEjIPqP wqv9me3kZIQiqX3EBfvepx61/wBDB/g+TQLLc30FmEkEkz+WjKh2Z963bvQLm0tIriSRI3kmwsJQ kyJ6g9AenHvQBR+0vbgRsikZwqMBtb2I79OlZSsAShDHngddvtQXGTuSFVxwdp6U+OMhGfAG04+Y dSaDU//X/MyKCRgZNkyTLISHRsR45x/nNSi1HlbmJkkZjnI+Yfj+n4V/0MH+EqleVkSRaaLmKVEk MVxEoZFDiPgdeSR0x0qsL+/YyMk7M2PK4Gz7vynJHNMXOug+NVAURGVGIPmKz7lkJ9scVa86NbGe D7M0tzuHlur7dnPPHQ9f0rZNWFzvoU7aOZMyOvHQoV2091fexSMhGPyqcNxSTViXJs//0PzWit34 3HYeuCOlPkeINDuLbDnzPLXOB9fwr/ogunsf4QXfchjhWYk/cXHBY4qu5MbCNFDiRwu7ONnqaCFJ N2LlxHBHCkMQQeWv3k6sccnPWqsOxBlw5XoTtLD2+lA7rYsSywRhpvLkZEICxocucnHXHvURZGDM gIPXJpK3Qbfdn//R/M2z3b2kVWUAmN+PUdqnkjMTBwFIY8FsEjHtX/Q/otD/AAe5rkMUchjIlcM2 4nCggHnI/pVuFI9mHVmdnxH+v/1qLIq7tYY1uX80DAKkLtPU59B3rM8t0lBXkA/MPSmZuVti6xlc HAAIXjAwvHtVORyq75CI1DBS7cJQTzs//9L814xCtu8TwxzO7h4rkDDAAHI57Hg/hVV8kOrKBEVx t24ye1f9EB/g2pOxetIljspHdN0wOEL5JVeen1wKito1nK+epQZ+YL1P0/xoJ5pWLdyfJQ28aMQ6 53unIxxgHt17e1cy0BjuQznDPxx3ANAk2jb8obE2nnpk8VYEIVclWfBBbaeBRYfNI//T/NuWIDcY AyRyOcx7slc9qitXe3aVCituGxdwyCCOf61/0PuKfQ/wZ5pDLe3V7k2sJEKCN7lohhQdoJJ/z61q RFlWMW5jLu5jcPwcdDj61lHls7hzyKR0ua3S5bURCLkTjyPIlLBU54bI69OnHvT0tJ7KCG7mt0mg u7lo4/s8ymSJVAyZBnI5P1x+dJ26BzyIgr/aHdQCrtvcHIA49/pVa4fHzDLNu2xoeAaVkLmfc//U /NfZcoEM0flhkDLngsD7f56VF5Q8xdykj0OQK/6GD/BnmkWWd4IvK2AK7bg2Pm47A/56U0BXXAJB B5IOKBczFkwu18khRyMd81NvaSJg0bFSuFJOCh/yKAU5FRLaLIjmLqgG7J/ecjkYyfYVaT/UkorE Agbyflx/n3oaQ1Nq9j//1fzOuUQEeSG3EfOR0yD2qTfdwRRh0cqw/dlgdrY/u5/Wv+hflR/g7Ccn oRxpIZCZFJ9hxio5rZ442lVthBB2k8nkDpRZdjTnkL5DyoWZC/AyT296lg0+7t5Yw1uY43XzoHK7 fN+nr36UcsexXNLRF9LMypNNApWUkM6kYX0yfTtVT7HfSyJBbW0k7yMFPlAsV/ConFJaFxcrH//W /N+O0FpcvZ3nmRSRH96zIXRSOq+mfaqn2eGAT3EJfk7lVVHJ6fh096/6ED/CnmkgjjnkiEsUbhmG RGw+b8QP5VCYA8cbu8nmRv8Avo4327wfT9fXtTsrEuTurl+CGLypBHHNcyqNwIyQnt7/AJ1H5Uki ImwRnl3V1AfOOmamy7D5n3K01veRCMPGymcB0wM4U9yaWWB1RS8W8KN4OOvofzosuxDqdD//1/zK iE8owYypYbgD7diav7AqwJMAshHyDGCx5zj1r/oMfLdH+ETnJk4EttLHNtw8ZDKcYII6H+VX4kEs l5LcQQbrxhOJORKjAHOOe/v7VmLnkVh9nYkRhHKDBZRytOiVA25ZP3jEjaByB/k0W7j55XJjFGAB mQknJDDcFPt+lUp7OSF0kRehzk96xSXM0y3Odk0f/9D86bUtJJNKIVGF8yRcBQAcLkD8R9KS4uAy x2kSiPMyzPIB+9fb/CD6V/0BRUXuz/CR1JbIjvLdJOQpAJ4QNkD60sbTQK8SlWUjaV2ghfp6fhV8 sNhKpNIZHGzEsg5HJxUK5eZ4ySzgf6v064/l+lL2aKVV9S4lgwKrK7RZ+ZSRg4qOGNhcXUUdwEIT zBGzbd4GAQPXucUOCtoNVdT/0fzoSEIApBx3AOAPaljkkBdSoRclQF5yPev9/wBxT3P8K41GixbJ IH82JjOiHEkbr8ieo/WmpIlletiOF2ZfMVZo/MGD2Gfr+lZNWdjVSe6ZFJBbzLJcQl42Ylp4slgm OPl9B7CooLtIYvs5UEzsEjl8vfg9uecdOtSPnkaSaPcFJJ5HK4bbknhs9KzUWCC73XGZgjeUYlYg tkjI/SgOeR//0vztNgro3l+YT5m6AO25I1J5GPXpzUc1pLZTbFkbAAdGPyuM81/vwf4ZKUiIpIMv jOT8xIzkmpYtPl3YYbj1TAwrUClJ9TQis7vaSUAjf5TlcEY/l+FUXsiJQVLKS21jnPtQZOcnsXfs c0MbyQSc4w2w/MPY1Tt2MFjeyXEYlRv9GVD8vzEr8xPtnt71LgmUpTtqf//T/PFTCRDmJpvLIbyw SFGOuapxp507pHgENkhuQnoK/wB9PZ9z/CyU5bEk1rfqZVaLIVQy4wGPXP4dKvNpt4lvHPJAyRso ZWYZD/j+FSrJu5XtHbQsKZ7pUxDHC8URQtBEInIHdio5+tYs0NyFZUYsScGSQbyOetVGLTuyOeVm jRttHl+zuuA1xcYkQlQzcdAPr7UxbaSC3jiuYDBcBw+8Aq4Ppn8P50+RXNuaR//U/PueHS7dN8qX AmuYyqvCvmAuAdpbJwBmo7d5nhjL2gjEEXkRzpHtWUbidx9+f5fWv99lBI/w0UnbU09V06WDT7SO yihS5L+dd3O35ro8BAfQAccVD/aIsrKKOURtqc0h81IU/dhcdS3r2xj8e1ZyVnYXPoOtrGAwJqBm lupXybq33ARR4PygDru4zn3/ABrPzcSOdtvMpkfkPy35VJcZO1xy2IuWlaW5MDWxCywMCm4ezUjw SxSIbJAyqwGWAkHufSsZ7m0W3uf/1fz+k86YxLLIB5RwqxqFD/X1rdS0heNY7iFhKi52kFAT7V/v VF2ep/hw1Ju7MtLGCZvvNAEYqFC5bg45qG502OGNZBKBIJSHj2feGBjn1pud1YfJIpNH9pnBt7YJ IyrDJjo2wYLH64q4I5oAwjt5JJScRxRqWYnocelQS4vqX7WxHn+ZLEsbMuGQ8OxFZa2cUN2jN8yp cbvKbK72ZicjH4/nQB//1vgm5lklura3V2RVR2mVvm3E42gdxWpa3jWbiBRiN8KATwD61/vLKVtE f4eQ2C7tnnnt4tru0pI81jnAx3NY09jPZOIHYffDMFOQKwc0jWGjNWBTk5kKo2FVQgAX61ZntLiK SIzIUgDAvxksDg5xWcp/I6ae5e1TTEnt4mtICI2f5NzhY/8AgRPSqK30sSwx/ZbZBbDy2jQidCRx nkYPes3NI0Ufeuj/1/htbYpeWzyPGsUhJkjdiHYY6AflW9L4fsbr54PtETvCcSGTepPsMY/P86/3 RcrvU/xScGirBposi/myySKUw0efkJ9f/rU6wsrEuwXZAXP/AC0BZJPYHNSpJbMmUHbUnvnj8xIr aXfMAVbYQcAAYA9OlZMMSec8aZM0gxJvXOSOxNDkurDlaWxeuoWFikDwwNOJAtqD8zK7cdeuO1Y8 +mahb+ULgIhdAxVfmKnPP0pc8SOVbn//0Pi17h4rdENp8si7XkmH3x/sjHf2qhD9j+2QPKXgUIVj ROIwO3HTjiv9yrq+x/iWk2yxNKs862MSKZOSsbMIyR3cj0rLe1nszPPOkl05nitIrRDkqJG2mQf7 ue/rVKUbWBxle50MmiagLR1d0WFQHhUOGfDHnkdetMgsZQXQqiR21vu+0SSgOxySRt/z1oTgaq/L YymRr7IUtIqHHyqQCO5PpVuOWYZgMhWFcbJOQ3uCfyrO6ewWd7H/0fjsRPDYTT2z70Mn2eSVum/A Py9iOR0zg1lxpc391FalC6RrmRnG3GcZ5r/cg/xTakndGhJavvmghcRW6INwbK+Z2Kgim3Oni2+z wNAqo8azIpIwVPTj04oM3cguIxdRXVqLcRyqAFO7a0i9CQB25xWFYafeS6dfQ2rGHynHlE/KFdGB 4P4EfjSuu4nFyViO9FxPOrXasxeMbWPIfHHJ/CtGzit5JbZGjw6EbYwOZSO1JSTNVF8p/9L46v5x qAhsnVrZA2ZZCmGBHAGM/XrVCTw/Jaxl4QpAQhFjOxpB6Y6V/uM3Hqf4qRutGa2maHINH33M9w1/ LJuVJpFdI1PVcAZ47YNUbeO9sZ3WOR5BG2NjqRECfb/PSsZcvyO/DuS2GXP2m6uZorwtcM8WzaB8 hzg9PamQ/YBJei4e8sr2GwVdPubaHzYg4bAHIIz3/wAelRLl5GjrhKbmro1rTTbSC0W4aS7uLqcf vbueTc7HGT8mMKcmvqX4OfsC+Lv2tfDl9beGtZ/sSyvFFvc314rAXeCD5YjWMnOQDkAdMZ6V+deJ OcrIuCcZmO9otK/d6a/kfr/hJlH9s8cYTB9E+Z/9u6n/0/05/YL/AOCOXj/9lL4lWHjLUfEFhrtv bqsxmtI5LN2JdWIdWzkhRwR/ex9P6XPIFz4c/s2cbZWtFimdgS7uQFz7814GIq/WOIsRPvK/3n1T pOlk9L0/I/kt/wCCgH/BD34uftCePfFHxW0jxdpsZub2e9W1ulurS6SMuWSMeWjZBBIJ+XJ56nA/ lB+OPwD8Z/s9fEHU/AHjnS3g1bTL50W4iD3FlGVUMFSVh86YYbW75wele9j48unkeHh/etfufoF/ wRu0e71L9qbSdUa0tU0m01qOwlgwE+0zDad7gc5K9Ce1f6O+jpNpngmMxwxuDpEcssJ/eYVolJHv yTXweXuLz7ER62ifW46DWS4e+15H8bn7Wf7Fnir9t79rXxHY+F9U07w/faZrN3aLcarbSs1uiyue I1BDK27A5/h6HNfIX7Vn/BAT9o74QeD/APhZOh+ItH8Ux2to8+pQDTDph8lEZy3yqd2ABjPzc45F fQ4lJYtRfY8XDQbotn//1P5r9T8Cr4eur+w1a3Sy1izLpqKz3HnC4kHyfM/cZGBgfQV+nP7F/wDw SI+LX7ZGmWHiLQdV0jwiNg/0i7gkuzMAPnjxtHy57kZ/lXh1V++R9NTjy0mfpLB/wbJ/Fixk86T4 jeHxLLd/aF/c3ZgjLDlfL2Nj6bse1adz/wAG0/xcn08wJ8VvDXm7mijg/s+6aSXceihdrAjHGeOK zrR1RlTja9j8g/2zv+CXHxx/Y21jV4tfu5L7QLWCOcazPEZIYAwZRKVZg6qXAHUkZ6HGT+TCWWrv cy215E7z2gLu9uf9HPo+7GMY5rey9izz6kf3uhXjjuMXQbMQlyrDOfMxwM1LEklnKkTMwfAZABjG eQc1wVkdEYu1kf/V/lBkS1DDbsZj8pUH5gfpWvYGJSgdF2wr8oVeQevWvkK+iufQ4dXdz9+f+CDl nJrf7QM+oXthFfm3ZbRILWMm4gVDIElPYAkqDnug9K/0GNSlh0nwGRKjE2WheZOGG75hEDg/jXze STUs1xKXSS/U+vzik45bhW/5b/kfwW/te+GZfFf7dpkgk2LqWsJqGozK2xlZLmRwh9z8i8c/MK/t u/ZIht7H4P8AhO3hMSGDQbaxwUw5aKCJXzx2ZW/Ovpa/u46B4tCN8FP5H8xX/BxXeyTax4d0PSpZ LySeMC4hiUtG8KuSyNjsGfn/AOtX5Hfstf8ABID49/tZ+GLvxZ4a1jw54c0y32Lb2+sWNy7TZWJy TIIyExv29DyDXqrldWCXU85wkqcm+h//1s+//wCDc/4/X32mNfiN4Qihu4xBJBBY3Ajt8LhsNtLj ocMCT9Kw4P8Ag2n+Pn9ky3tp488MG9gRzbLY29xenbFnG7eo3F8d/XpXg45qlVUT6TCQdSDaPxp/ al/Yo+LX7L2sXOh/FPw/La3Vszbr0IosJ7QOUDqQcNztyB/ePpXifwZ+AfiX4x+L9O8E+F2nS+1X UYrWxvI5DDBp0bAGRpsA5AB4GOc1ni3y0qb7/wCY6NO85JdD9wdE/wCDdD9onxNbaHr6eKPB2tT3 NtG00Oow3FhFZK67gciLLYB6kdegNdjJ/wAG4v7QhltzN4h+HVu9uht7aG6a7vhAD/dKwhTu/Met XjKdsKpdwwqbrcrPDfjf/wAEG/2oPg74L1rxZfzaBrkOmQrdq+jxXEa29sCDKq7oh/COmD2+bqa/ EfxB4LvdD1fVNIvbeax1LTL59Pvbe4jMKxBSdrbckcqQcg0supp0px7XLxianF+h/9f+WXTbr+zr mWKCBniEwguBGcb1DYJ/Dr+Ff1Rf8EDdCsbzxfNqtoYZ5ptSbTrCF18v7LEvlPcKG/vHg+/PWvy7 jKr7HB0pf30fp/DNL2mJqRf8r/I/sn+Okkdl8J/ENxZzpaNp/h6ZU+USwsfIIIYHsACfwr/Lm/bO 1C81L9oPx1cRajLqEFjqE1mGT5bLKyAHYBx1De/Fff4KUo5VUUdpKN/vufFYuEXjYuS1i3+qPkO8 uLvyFhku5UXzt/lI3B9QRVIXQgV42ZfKbnBHevLl8R0r4GZscjbTaRsfsola5IZujN1x+A6UqXDN m2Du6tIFjZU+ccjg/lWM+hB//9D+UeS3RSm5VLq25XZAzIw6U/W7a6u9J0+LVLpL4SkxLDG53IgO 7MgH3enr2r48+jkkrWLFs0DkxpEtrZQwYicNucED/wCtVBkL2sFwjrMsztHmRsS/LjO4e+RQOmit mzt1ZvskSXiQlbeZchlc9x+o/GrLtJPFAlwjXDjGXPzNFxyR/wDW9aDQsrHENgi+UKfunjNPktDM sodMwsMe1AH/0f5T7O6u7W2e2iRpooyZTAD8u7pux61oRCEqbjZG0zpjkYYcHAPfivjJ7H1Bl22o yOTC8MSQxuVMyHljnuKg1KWCy82SCKd0fG4IC5/4CB+PSqgnoS5JE+no8giLW5QtliX4MS4OCfr6 e9I9/eM7xaZYtfTK/lLGG8oqCcM/Pp1remrSsNzskfZfwN0KOyisldzctc/vZ7l/3eHIyR+eBj6V +qX7Ktpn43eEdr3MsUrtFeRxK4gjSUpD87n5QTu4HXIr+w+Ao+y8K8VJfyVPyZ/O+eT9r4k0V/ej +h//0v65vg0v9n/DO0EQklWSyY2aSHYEjAY4Ueg3YyPSv5T/APgq54hutQ8b2ejWnlXhGsNf27t8 kiR2zSCcg55OJk4+nrX6p4GUvacZufa7/T9TyfFWqqeQ8ney/X9D+fT4xvc/ZETRg1z5vm70uB9n hKxIrzMOfm2Kc471+RPi7UrM65qMMby2v2yV7lWWIugZhkqhPGPTJr9Q8fpWWEpr+9+h+f8AhZG6 rz9PzZ5tczDySjL50g/jYYb64qOyuBEJd4PIwxxlvoK/luatTufrNaX7yx11hII48+RlgokTeTtl X+ldZplpBJexassMkaWp3eQc+WpIGQfUccV52I2Li7o//9P+NC6nkjM94ZIz5hyqKNshGehHtWl4 ZhgjuTe2uozXUtwVbypRmKFh95duOMf06183PodUXZn0LZXcK28N1LOySR/NcRjIQqF9fTk/TFTa hNBPstjGJCFW8jYrjAHTr/niuCe1jW+tjS0/Wbm60ee6S2iNza3JVbiRy1xIAdu0j0wufY9624Yb fVHsYLkx2E8sT3DPIMROI13BSR3OQMVxta2LUnE5u6t9Os1gubm0uDFHqQvTJbNiJPKOWzxgHp19 avDxDa+JLVnhik08XsrKkEoDNEqnAYH14JHHQ1hON7mcZfvrH//U/jbmv7a4ghtNS0jTbC8uoFBu xM7TswOd7c8emMdCK0LZRZ2yyTfZ5oZIxG2CGdCMHcAexx+teOc7+FosiGGWZZnkxDMmCGHBH/18 VEY4La2WO1jd3iH7uGQmTfgkjaT7fyrGS94ErKxS1KEeRe3LWpje0iWcbCFE6McbQSeDkgc10/g+ 0juhNaXMTMssQa2nubgMNyjcVHr06njp1rRW5rIa3Om0rSbCd7jUtTUWQ0+RvsqQkE3OBtGD2znv 3rntUgt7u0kuJ45IrdyfIuVTcd4PKkD04z9auOjNz//V/kGnuRdW9oVto7lyBHv8vakagcAr2B9+ c1n3TwyvsubdIzApWONFOxeoG0muem1oRGybR5j4kmW2tjbTaUlzGwYpcO7KI+RkAA81wVjOjSlV DW8MTq3lRIXwM4IAH+ea7YNqI2tUj9aP2bfDF5N4ON7pUEVvp4WJNRuGX9+3mhZEQA+uQ2e3r2r9 j/2AL3T9D+NPh3SLl7SaOG6S+1Jym3UyMgbgvAYfdAx/dAr+3eGE63hTyrf2T/D/AIY/BcW1R8UK Ef76/E/vD8DXMF/4AtbrSW86yn04QWKNEweNWiBA2nkcnNfx/f8ABXy1trL41+HdQmUwaeuo6tp9 xqEgMcN1LLHazKvPUneQB/s1+D+BMXS8SmpOzSnf1s1b7z77x8cY8N3e3NFH/9b8qYrPT9fv2jub 3+yPskDPHO6borsjJEbDt3/PvVWyv3sre/0iGBbprgEx3MqfNBg5BUdDxmv9fsNrFM/zXrrV+pRj 8m18omKSW4cnzww2oycZzj1rYh0yO1jvNYgRpNO1IPCljuE5tWAUc56DBH4gmrtrYxjo7nMD7ZYw 6lPAYFSTAki8seaithVfn8BkVp+F4TZ6Lqk9xPC88TeelpJIY2uYycyIG6jI4x7moxkb4eXezPZy SfscbTm39pfmj+17/gj/AHyH4NWekCxRY45vPhRT5wSDyiFLt25RcZr6G/4KPwWsvwK16eVFc29u 628WcMA8Mwl+u7CqB7V/mPxLzQ8UJtb+1X5n+iuYpS4EUujpP8j/1+n/AOCY+uWukftB2dpYea32 S8a6mmMPlPKhdFUpzx8idPU1/Z26G+8KAgB45tOIg82TerFeI+R6kD86/Z/Gzm/tjCye/JH9Dh8P 5KXB8Utlzfmfya/tJfst+Ivj5+1VNawo2mpbaqZZLy1jPnRyCfKwpzkHnGM9B14r+hb9nb4HaL8B /hTo+l6/oelpJpGnsrzXVla3l1MiKN0krBcFjgnrjnPFRxXxfiYcJ4Dh+hNqy3Wl9bnj8H8I0MLj cbntaCbqS/Fb7+Z5j4m/bW/ZB8K+Ir/w7r11d/akws0dn4Kjktt2ASNwG0kZxweD6V6t8L/2gf2b fi5I+neE9l2t2BHPa6r4et4EAU4UhDnjj0/ka+Ir4HPaeD+t1KnuW/muz6nBVMJmFR0aFPZtbaaH wh/wUt/4J6TfGTwRqXiT4dQ6ba6hoEP9rWUdhHDpmpyqF3XNssvAZXWMEKRgEDkZzX4m/shf8E+P E/jb4xQW0OpHyfCkqnUBrN//AGnfzyOyny5NqABQrE59FwPWv37w78TXhOB8Vl2Ju6lKLs3q7NWX +f8AVz8O4v4Edbj7CzopKnUkpNLyabVvw8j/0P65/DOgeHvgj8O7Cz8SaVp9taaDYBLkWdjDPDtR cFunAAHA9+1fMOuf8FJP2SPCt/c6Lca1d2ctoWM6weG4pwGLbcDbnHPv/KvtcHDNOIsZXxGEk3Jy b1v1bOfM8Zl2SypUq8Ek7JWWx9CfAr9oz4KftDw3aeANVi1I4CSx3WhW8btgYAwRn06gdfavyk/4 KR/8Ey9Y8f6nd/FnwjrOlaTqVrYSyTBNPgtYr6KJEl8uZBHjf+6GWPUZ74x9TwNxJjuDOM6Kx92n 7rT297T9dPPyPivEnh3D8QcKTxWGSTh76emyV2fy/a/Y3VjqeqeHNbtrZrrRX+xajNGTPAkwOGWM Y6fX16V+oP8AwTt/a+8G/A74kadoXxE02eXQ9dsYtMiu9LjD/vomxCXjPTIJTg8bsnIr+1uM8LLO ODsTDDOzlT5l91/yP5s8L83pZRxNQr1Y80JS5H6Sa1+9a+R/Yf8ACzxd4L+J+i2viLw9YMbN7ZDG L6xjjuULLgjOMjPoa/Hr/gsJ4E8OXPw51A3UcVsv9kzsZUtIUlgcOGRlfbk42PjHQ/jX8G8DYnFZ d4gYbmk+ZTsz+sPE7B0K3CNdyirKNz//0fzQ8OaVY6g1hZ/2zeW+myyRyTXcMKee7KpIYq4xhjwf qe9f0Xf8EyP2HrrWZ7P4mveWL2Rji1HS47yzMFzeKvltDM67MZbJPJ/h+mP9CfFziV8PcJVKmv7x cunfofy34L5BHNs/hi5a+wvKz87r+v6v/Qf48+KXhz4LeCZNY8YWA+zabbvJfXNtdJGSsUbSSHLD p8jY6dvevhPUv2r/AIC/tf2N/wDD7wO17eX9zbeVNBe2UYaAGRASNy/OMjbwed1fxRkGCzPE0ZZt hm/ZU5Xflrc/p3FV8HPNP7MnFe0bWndaH1t+z38Ex8EPCEOnTGO+sEYGxhhh+yQ2iDLbUQfKfve4 zn1r8kP+CpX7YHw4tY4PBH9mTf22NXiljUzQxxWXkiSNZXjChiGYSjj19ia+o4F+t8TcdQlRk7t6 37WtqfIeJ2LhkHDXs4xV3ZL5STf4XPZf+CaX7efw48X6GfhtcaPFp+raDFFZxajZTrcRzrKSys0T jcvziVSRx04HIH3f+05+y3pfxcGj+OtOMkes6Wgv5PMTzLe4x80KmNVzg7jnBHBrXjGnj+EeL51K 8nZyf3Nf8MdeSYHCcT8F0a0aaTSi/wDt6O7/ADR//9L+iHQ/+Cgnw0/Z9uNP+HnxM0O70TWpk+yR y2DyNAfs7GHdJ8h2qWDYPfnjrX6FeC/GnhT9obwLLLpF68Wl6tpbh0EcV6gSVSqnOMHr7Hk8V+jc QZVjsFhYZ+pt0qjunfZ+vl0PNyHE4XOo1sO4xvSvGSfXpt2a/wAj+Zv/AIKUf8E15PhxL/wtHwr4 ls7m0uZ5r7UNFnt5rVnWLaX2uqbThHzggf6tsZ4r89P2L/2mZ/2eviTo3ia98IaP4ksrzbZahbT3 EkN/YIzJ5gtpQp3BQgbDJztPA5r+quBOIY8ceHdXBTny1YwcG77dn+H3H8m53l0uCvEf93DmhBqS 00d0m7el/OzP6W9E/wCCuPwkl0qyt4fh/wCKzstUafybsWyRuRlkUMucg+oFfY/wJ/a88D/H9Suh WGq6fKq4nstUJnC4O0ENtA7/AK/XH8p51w1icrVSpKpzKL/rqz+p+Hs+pZ3U9kqXLpfX/hj5G/b8 /wCCeOhfGnw34n8daJP/AGNqtoDrQnsdyvM6xOH8wLyR8xBDBuueuMfySy3ur/Aj4o3Ec8Onz3mk 2/2iya6R0ileF1Z45EIzyME5A6dq/o3wJ4med5JW4crvWCav1s0o/wBedz+dvFLh98N8ZUs6w8fc m1O2y5lLmtp/Vmf/0/2C/Z2/4LNeArLwz4Y8PeNvAn9my39pb25vdL1Vp7DzGTMojYpkDcWwG7dW 61+23wK+L/hf4yeHk17wm0h08L5kTtMJ1wTyu7A5BzX7B4n8A5hwrj62LrXdGbk0+mr7+vR62seN 4ecXYfivCOpS0lBK66/157XLHxq+M+l/Brw3deItcsJLrT7cO1xJHIYvLEabySQD1Gfx/GvxC/aH /wCCtvwH8e+CPFfhjT/DV1da5HpDxAPevFCAxMeXkZBjaHI+pHIrm8NeC8x4mxlLF4F6UpRctUtE /Nr9T5XxJ4kwWWZbi8pxELzqwklp/Mmvw+R/Ot4c8B2nxV+Mki6bDc6fJ43vo4kSG5R7WzUuimZz 0OBjABwdwHev7Bf2GP2G/DvwM8L2vi6w1e81271kJc/aLyEIH2KAmFU46YOOTk/TH7j4/Z5iMqyL C5NRbtJJN7bLl/Q+M8CeHsNPC18yrRTcEoRv5a3/ABPa/wBon9rGw+BEdpLrHhbUNYuGuAieXeNb RumxmHOOD8h4G76cE188+FP+Conh/wAUX0Fk3w41jToZZNnnw6g04X1Y5wOMV/OOWZFUxWXrGKra 99PT5+R+tPOIwzZYFQ67/wBL9T//1P7Rr3RtA+P/AIHubO+t5H0/UrMeQxAuHhYgH5dw59Mdetfy a/8ABTT9hE/ADW9T+Imj6ub+x1CSXU5Y7q3MdxGhdVliVlHIxtYK2cFTzg1/Q3gRxZXyPjH+yKkv 3dZ8r+f/AAy+4/GfHXIaNbh15sl79K33f0z8LNRh1B7q3ntTcS6dLbB4gY2M6qQG+fuCcnj861tO nt47JmknZDg4Ro2ZwfTp/Ov9DoSvofxarJEGmxy/brWKK4Mm5Wd7iQiOFSo53HoM9h9a2Li2a6mk ImGSvlnaRhR3x71oRTWhSksIILm3tw9xJ5rC2hfYSwzwoJGcE8V+sv8AwT+/bJ1j9mfVZdKufBae KvDL2sNhK5MtvqokizlIWAKkESKSSBgxjrzX5x4nZTTzzhTFYGcraX3tsv8AJux+oeGmZ1Mn4iw+ MpK72+9/8A//1f6G9M/4KueHr6OG8i+EWvxl4lWKV9SLiVujAngj8jX3t8BP2gNH+Pekm9/4Ru60 Ys217Se5a4dFztIyQOuD+Qr77OsA8HRdn8PnfZ2OHJq6xtRqa38vI/NL/gpF/wAE8fB3j2KT4m21 /eW2q6W8s2HgBtZvMKhBIVUkhc9fc9eK/ke8WeG7nRfEmoaTDc2s9tZa9Npt4u0232NLdzHsEYH3 htPsevfj+y/o6cVYrOsiWW4uXM6Csm92v+B+vY/jDx24ao5LnU8Tho2jWbbS6P8A4LuI2l2vkKk9 1KU81ZYY4p9ucE8HBz26fWuu0bRJNXaC10+C5uL2eX7Nb28MTTSSnaMAKAT+PSv6oq4inh6Ptqjt Bat9tN/kfy3h8LPFYuVCmryeiXd3/U9R0L4LeMLu0EyeF/EMV5HsDPBpNxNGG3fOpZUI7Hg4rp/+ FP8AjWy1CZrrw3qTn7J5URXQZXuYwSMDDLy3fj86+blx5w3CfJ9Zin8/8j6heH3Ec6aawz/D/M// 1vJJvgr410eK5uI/CfiC6tm8uU3Uek3M1wokwJHmCxfLtJPTjtmsO3+DPieIJOdL10an9sbMUmjX c3nx9QRti4XB4J9Og6V/sX/r/wAOuLf1lK3rr6H+Uv8AxDniOMkvqz/DT116fM3br4LeMmSG9tvB viy7lZTF50ekzxW5bPCjcueeecdulUdV+A3jmzYXOn+CfEbOqhbhorR3SdjznaemOlZf8RA4e/6C F9zNl4d8Q/8APj8UULP4N/FCRLn7H4C8RrLDkXEMunvC591XGTWjD8G/iNFfbLnwh4suoPISa4aH wzd+VEcHMZkZRyOmADntVLxC4eUb+3M/+IccQ81nQ/E1tR+DXji5d7a28A+KGdrT7XHKdBube3jH 9xnkUc+35VmH4HeKftFmYfCHiC+SeyYXGpWujzSW9iCuGVsqOh44z+NVHxC4dbs69v68iZeHfEFP VUL+n/Bsf//X8Ot/gn42smjisfAnitrK0GxbpNGljtMAfLtTG72xitVvgh4+nvo7oeGPE8lk1skI mOhSm2sZHI3NNmLftXnpnBJxX+xf/EQuHVtXR/lH/wAQ84he9D8UWbj4MeNohcQP4b8RMsKDNzb+ Hbi5s5TnBCnG7n0Kg1mRfAnxdZw7Lfwf4kt9Jubgia6utPlHlyY4I3Lu2npz0qf+IicPbe2/L/Mh +HHEG7or7xbT4J+OorG4mufAvjCC3guxGsZ0eUpOVPDIerDgHgGrF18IvF/2e8WbwX4tt4YSi3Es 3he6MSI/Q529/XH51pHxA4dk9cSkYS8PeIFthm/Rozh8E/E8lyZI/D2tXNnHCvnJDYzLeWhOCp8s oMgjscEZNQX/AMG/iZcvbNZeB/FMlol2kM5n0loLZYG6ylid2emAF5weRWkfEDh+9niF+JnPw84h ausO/vR//9DxS7+D3xEtQNPs/AviC6siM3FzDpk7tHu6YUISR15JHas9fgH4ndTcReHPE0uqO+y1 gfw5eESrnDBXCbc9ea/2Z/194ba/3qP4/wCR/kPLw84mv/usvw/zG618E/F2lxFl0zWoJTtAkk0S 5ZVk4/cFtvDZ4PGPrUWs/Ar4wXVzaz23hu4uYxDG99ItpK0sIwMKvADH9f50v9fuG1p9aj+P+Ql4 d8TW/wB1l+H+YrfAj4mCSYXPhbV2t7d4Z4/KsZYp5gWHybdp+b2zjrzXUar8BvHjw4PhXW7V4rJd QiOoadcxMxBxs2rG3HBJ3cGrjx7w2/8AmKj+P+RnLw/4lX/MJL8P8yO3+CvxBuF2weFdUunhiRw9 npt0YCzDGGZ4l79hnHrVK/8Ag58U47R4W8H309ytwwLvG0MCJgYIyvOOc1S484cX/MVH8f8AIw/1 A4lbt9Ul+H+Z/9HxW7+Bvi7V7awu7Tw7qY1mRTbsWhlEUewc4ULzznB9D26VSHwJ+IU2owWv/CE6 9eia1k3zNDJtVxyV+6OTjOfp15r/AGc/4iBw2tsVH8f8j/H3/iHvEvXCS/D/ADM2D4EePtPS0ZvA Wv6YskhjuSmlzzMr5xgDbub64wK3bf8AZ18fP9vuT4R1u3a0txcNd3GnyiKYHGQqqhcEd92P61qv EDhz/oKj+P8AkRPw+4l2+qy/D/Mig+CnjOaWR4/CWq6lb2x8x7qz0q4nUYHQjy85zkcZqzB8EfFc 9tHcr4R1vT72e4ZJrFtMmia1UE/MzNHtwR6MW56VS8QuHF/zEx/H/IheHXEd9cM/w/zKVt8C/HA1 a5ifw7ezWlsF8mZIZCru2OxTBxzxxilb4O+Lore4uz4f1k3MczRwWsdtJvkAONyjZjpzgkdKr/iI 3Dm3t0dC8N+IIq7oM//S8Esfg/4tuLafyvDGuIbjJ8x9NnL56ZYhSB+dOX4L/EWCA2//AAjFw+JA LeZLaeZLsk8hSI8A+zEfWv8Aab/iIvD8VrXX4f5n+QX/ABDzPf8Anz+f+Rc1f4F67KI4J9A1JXaR LaS3W2uIJYmxlmJMYUjPoe9Mj+GnijSnuLaTRb2OwtTHBHeGCW4gJOBtO1CRjjOaS8ReHm7e3X3/ APBF/wAQ+z3/AJ8fn/kO1b4ReKb6C4W48IX91EiFI59H82eYDGd5PlhMEdgxIqn4f+DHiC1gtY/+ EM8YWuLcN5moaRI0A5wMSBSWBGOnTNbf8RD4d5bfWUJcAZ9fSgyXVvhf4jS4Nj/wi+vfahhreWDT 5GBLAjBXHH0NZ83wG8dz28NxL4Y1SfyJskwW0iz27hcjcrKOOx55960h4gcOp/7zH8TnreH3EU5p /Vnc/9P5lPwT8cRzxy33hjXrZbqLzFjj0m4uVBHBBO0DOOcfrWlZ/BrxDHb3U8+mav5dsDNHPLpk 8SQgkKqlAhY89+nPUV/trDxB4bvrio/j/kf43y8OuJumFb+4kl+DnjkRiSPwtrAWVlW3ne2Yrdbh kFBt3fmKxLz4S/FCa2ayj8EarezkFo5IkeKZCh5VlIFdH+v/AAz1xcfx/wAjF+HPFF/9zl+H+Zt3 vwO8bRaTby3vhbWhdLbqXS202W5wWHIkYL8oz61mxfB3xkscbWWi6pHJs8qWKfTZ4kdgASQxQYxz 9RTXH3DT2xcfx/yEvD7iWKs8JL8P8zE1H4WeNdPQz32j3MrmUJts7eWYuT0C5UZPt+tXLT4Y+K7q O1hufB3iXTmu5ykd1qukS2tpIAMgeYRt5xxzVLj7hxbYqP4/5CfAfEkdPqkvw/zP/9T5tj+DfjKF t7eFvEKXMbstubfR7m7hwOpcJH0x0wabL8L/ABdqF2LKfwr4iiWG2a6t7tdLlNvuA+6VwMk4x7V/ uEuP+Hf+guP4/wCR/jLLgfiGKs8LL8DJHw58YvbSK3hzVpc4V5E0a6ilhAI+YoY8lT0yv5VVtvhH 4sdGA8OeIvNuZdsaWmlzzSDsXyyABe/PI7gU/wDX/h3b63H8f8g/1I4glDl+qy/A6aP4ReLIYrmP 7FeWUEEQWZbnRLie5nbvhlQgH16VEPhL4lt3tRHo+p2qtF57PcWslz9pB7bFXcmT0J/H2qPHeQO6 +tR0/H+vOxP+oXEC5b4WX+Xr/wAC5TvvAGuXs4gh8M65byQhPtRWwa2VAuMEHGOcc4yTuNTf8Kc8 UXElzM+kamkEcCskxsZmErt0CkIc56c4+tU+OcgW2KiXT4B4hnp9Ukvu/qx//9X5ht/hD4rimaca bfgqPLa3mtpWlVunyKqHirU3wn8as0gfwxrzxvAGNyulvLB1wQcZI/ECv9yFxzw/t9aif40f6gcR RX+6y/Ag0j4RfEHzZPsHg3XJ7K1IjuZY9LlMUA6ZY7eAKTVfhV4yivZYpvDGrRKu0JK1m5indvux oRk5I55x3rVcd8PbLFx/H/IhcAcR8vN9Tlb5f5l+w+Gms28fk6j4f1rTZZ/3MEp0ue4Mp9Vwp71z N38IfEIe10+80u/hnuLORotQk0u68m/kRvlBXYShPUZAAA6k0/8AXzh+9liYv5/hsYvw/wCIF8WF l/l56GjZ/CrWtT0ZGbSdWt72yT94JLKdBDJuwFYFcNnsFzkU+/8AhP4ri066nj0vVxdwyAK15YyW 8d0mM5AwW/XtWi46yBO31mJzT4D4gt/usvu/r0P/1vi3Tfh34vnvIbabQbiOS7w0ckkciQIvcl9u MjFb6fCXxPMJhZ6ZePHbSOrTx2+FlKH5gmSAx642k5r/AHXlx1w6l/vMfx/yP8SY8BcSyuvqst+2 5ND8KfFkdmdSi0+/ijihaS5S606aG5i2n7pUrjntj86sQfCLXtXt47pIGgmmkxLHcRSRhABk/MEK gn0zWb474fteOIi7f15G68P+I7pPDyXn/Vzn/wDhVnie1u3s5dKvpnN0kYjjt5ZfNV22kxMEIOBk 4re/4Vrra39xpMOk3sJ0qNTezXFq8Stu6BGI27h6Eg+1aLjnh+P/ADFR+9/5DXAXEVrPCyv6Iguf hrq1q0k4stTNxbZ/0YaXcTzv/tDahGMZ6+lZWn+AvFuo3Bgt/DeozW14wRbmazls4OerAsoPy/TH FNcc5C/+YqP4mkeBeIUv91n9x//X+TJfhB41sreazs/Des6nMG2xPYWclwsoJ42nGcDp+FZh+F3i a0WGW90DXbWXyy19FPp8yHTmU4CyZULkngYJr/diPG+QS95YmP8AX9dD/Fr/AFGz+N08LLTy39Pz 1J1+HWryn7ZPp15+4cOYbizkBl9M8Ed+9Wda+FWvC4txaaDqfkzKuDZWskqyu38KLjn8K1/13yD/ AKCoiXAnEL1+qT/AZp3wq8Sww3Mk/hXWo4rcuv8ApNtIkkzegX8zk46dKnj+Fevy3MMtvo19bRPC W8l7V0EpXkhFIy2cHleM5p/675B/0FR/r5FPgLiK3+6S/D/Mlj8CeINRVraSxvoYTERDI+nzQQx7 eOcr1rOs/hLrtyxjtrfUZjLN9kuHTSLiXnsBhf1FH+u+Qf8AQVH+vkZvgLiH/oFmf//Q+QZPg74t t3McelaoyKjiKSXTZ189k6rygx361hN8P9Zjmjim03UY5ZVDfPp8w2HuD8vtX+7644yDl/3qP4n+ K0uAuIo3X1WWhYn8F+JLm2+yJ4d8STEuArwaPMyEDpk4xj9aZN8MPFbSeZLo+o2iW6CJrX+yJftF wSAIwqqvHTk+9NcbZBv9aiZvgbiFf8wk/wCvmXj4J1WzSO0j0bU4tQun8vZdWskKoR1wCOB/Oq1z 8NPHUF0zz6Hc/YztUubZ90pb+JWIAwO+cHitP9duH/8AoJj+Jl/qTxDf/dpEx8DeKEh1Et4c10Ra dGpWRLCV0vgx5ERAI9/mwKnk+G2pvYWl5B4a8RpcTQtNLE2nyF48D7xULwD6ZJpPjbIP+gmP3sa4 I4h64af3H//R+Lbf4beKY5ZZZNA1mztWACX0+lzJHcZXICrt3+g6VRT4YeN2eeebw1q9rGmEVrqy ljDFmwCF2ngjucfWv94/9deH/wDoJif4nrgfiFvTCz+427L4deKbS8u7SLQNVn1HTFW5laOzkit5 FIUrslYAd66zX9J8S32k2t5/wh+pwPAWjuIo9JlugxjAUMjIpRix7g/X1pf67cP6f7VFfNm64H4i inH6pLXy8zjH+FfxDllCzeEr+1jlhjvAbu0kilKt2RApOee3HFEXw9uLNES6t9T+03UzRC3Gk3Je LaVUqQIj6nHOf0p/675AtPrMSo8C8Q7vCy+4jm+F91fPHLZ6Pr7zRI4aSLSrnyogD0lygAzjirD/ AAt8WhAF8PakYRbG4k86zkUQKo67gCCT6D86a43yD/oJj95b4F4hSu8LM//S+IbjwP4lFvZQ22l6 gwurjy5Wj02ecW4Ixubap49cZx6GoJPhzqkA5k1Kdlk2O0GgXSR9eRlkH51/vP8A67ZDeyxMfvP8 VnwTn0Vd4WX3Gg3wv1vThc3rWl9K0KCWJWt5XE+7oNqoflHGc+tc5/whPieSTMWgajPICGuRDYPG E3d0UgZH09qpca5D1xMDP/UrP5LTDSFi8AeKbgGaLw7rQJuPs8cJsHWTngFgcY59a2v+Faa1BJNF PZ3lvdWmDMLi2ljQu44BAVjxn9af+unD71WKjb1F/qRn/wD0CT+4im8A+IvtEkDxAeV8r7bK5Lq3 /fvkfT9Kbb/DvXbmVmtorieWCFiI/sVysRYc42mPmj/XPIP+gqP3kS4Lz+Lt9Vkf/9P4g/4V74om uVjOk6hI5tvtMvkaVctGqgcgHy+e/Srq/CXxVdv5EWh6xbk7TEraNcJGyHncrFQMYz3r/elca5At 8VD7z/E//UjiKWiwk/uKR+GXiNkvEj0y7nSxfb+7tZBKwUZZgMYwDx1zx0qiPhv4kS6ED2NzGywr dlfsz4KH+EuQFDevp60/9duH9lio/iZvgbiFf8wkzV1D4fGMPJbQSC7ZF3w7JGAOOg+Ujn6/jVTT /AviueF4j4d1RYWlEW77CxD453g4zgeorRca5Da/1qH3mUuCuIE7LCz+4ox+BPE9wGgt9A1JYN7B 7prGQwlVbBZSATjPsDVS4+HniTTbuO1fTNYu0ltZLuKaPR7nZIY8ExqTGOSNxGePk68jNS40yKO+ Kh96f5ER4M4hnrHCT/8AAX+p/9T4Hn8F+IY5LR4dC1hYLm3FwTJpsyLAvG7eSv5VrXXww8WQWM+o DTp51QJ5McVnPcOQxGXIVMYAJ5zX++D40yGP/MVD7z/ERcGcQy/5hJr/ALdaKkvgjWGufKtdMu5o oow9zIsLhgcA4RCu45PGPbvTNJ8I63dzGU6XdxQRy+QTcWlxayxtgkEKYyT07U/9cchjr9ah9448 HcRS936pP/wFlI+ENajkKSWWqXEzTsubbSJ3Ma54JwnTFaFt8PfESuY7/RdXtpiwcWx0i5Ny8Z5V gBGRyPfFR/rvw/8A9BcPv/4BT4J4h6YSf3CR/DzxtNevaR+DPFKJFE000kmhzxrboM8sSvcdMVeT 4da40ECz6BrflMRIDeWLQ27c/fAI5Hen/rvw+l/vUPvJ/wBSeIlvhZ/cf//V+FNQ+Hnie5WVLXR9 QEltKscUv2VoIyCw6BsZHPSqt14E8TR3i6edF1SabgmSOxdoecc7ug+nWv8Ae3/XfIP+gqJ/iQuC +IeX/dZW9C1L4G1+Frizk03WQbNRuntdHubiI7xwAQnXPGD6HtW1B8N/ENpaW1/caDq0iTHy41Fi 6yk9cspAwfYUv9d8h/6Coky4L4ht/usvuKl94c8RTSW1o3hnX0jeMskp08yeSM4w20nB74qt/wAK 68RuTNH4f1e4hSQxRXR050ikYDJAzR/rxkD0WKiQuDeIov8A3Wf3E8fw18YXUUU3/CN6hHGxaWOI 28jXAVO7IAcdO571Cfhl4sYyXI0nxBawJw8v9gXckTHH3QpjDZ4xnpS/154f2+tRG+C+In/zCT+4 /9b4Tt/BepPeQ3V1pes2kaxNb28t5pF5bw3BJXJVfLOT8v8AnitaX4c+IJ5cWGjanqOxkUpaWMiy EN0IDKMfjiv963xzw/bTFRP8RFwRxJa/1Wf3f8EpyfDzxcLhLdPCeuyXCO0IMWnMVGOWUuOM8dM9 qvWnww8UX9vJc2+h6hBO7m3hE2nzifzFPIACEHv35x+NR/rvw/8A9BMPxE+CuI0v91n9xFfeANfC rHq2m6jPNE/mQNFYTtJcMvXKbd+Rj+LiqieDvGMqD7J4Q8QSI5PkyHTHEfy/3geR6c0v9dsg64qB D4M4iX/MLP7gn8E+JY2jM3hvW4ppE8yXy9KllQHpzsBwfY1ft/hN4z1CxbVU0O6itraPzbmF7Zzc woSQGIAOOh4IqXxtw8t8XH72P/UriR7YWf3H/9f4Wf4eeJfMMY0HWotkfmm7ksnNuUHQ7fvZP0qe H4c+KLtlVtB8RFY5xbvPBok5iXjg/dPB7EV/vK+N+Hlvi4/ez/EF8GcRbLCz+4W4+GnjNIcx+EvE VwiTmEMNLl3HnAPI/HinS/CnxtbramHwtr9xcyEtLCunSFFA7Zx19hnNT/rzw6v+YuP4/wCQ1wVx K9sLL7iM+BvEs0cZj8O6u8ocwz28emS+YHzhVwQPzOK0Lz4U+NrK3smuvC/iEyXMmfs1ppks09vj /nrgYA+hPQ0/9e+HP+guH4/5G0eBeJWr/VJfh/mPk+FniY27XTaXdiDzzbRM1pcrJIwxnAERB47Z 7iqsfwq8WTyCxfSNZjaaJpYFj0q4VpwoJIQ7OuAaS484d2+tQ/E0/wBROJFvhZf18z//0Pie2+G2 pqixRaRqoupAyi0ns5fNt/LGXMp24Hfv2+lUU8CeJdRZpP8AhGfFbWmnMYbc22iXAt7lv9klMEdT jiv95f8AXvhxf8xUPxP8TqfAnEd/91n+Ak/w98TrbxtNpGsWBlcqhm0i4G04yN2Uxzj17Uw/DHxV qEYmi0rUVQIURjp8wa72cMyKF4xz97FS+O+Hf+gqB1R4F4iS/wB0n+BpL8OvFds0XkaNf3Vt5W6S RbCTkADIxjOfbFX7j4aeI7me1ktdP8R20sEYnW3vNGuDlc/8sl2dM59eveofHXDuzxcfxD/UbiR7 YWX4F6T4VeOrZrYWOh6g9xdMTdyTaNdG1hUA8ONuc9BgA9aw28AePoGtmtPDGuyTLcCOaXT7CWNI nB5B3gMO/wBM+1S+O+G3vi4lR4E4k2WFl+H+Z//R+OLz4e+NLu23R+EfEVw8suJDFok7MGzyxfbt 68cHPNYM3wu8aWLyxz+HtZiZAdjTWMixNjHG0Dd37jPBr/dp8d8N30xcfx/yP8Xf9ROJf+gSX3L/ ADNt/hr4jtvKSSwu4LaeJWfUBaXBjy3WNQIz82OfSs+++EviSCe2OjaLrmriQlZ5obSaWCMnG0YK Dnr2qP8AXrhy9vrUfXX/ACMnwJxJa6w0r9uv9fM1R8K/GVrcIj6PrXm265eEaNdWsM6MPmCu8XLD PpWbe/D7xDbwKkmi63JfOxZANJmWFlzwA5XkjvwKr/XrhxL/AHuP4/5Gb4F4lv8A7pL7l/mQJ8Pv GNm+px3Gi3sUUMKlDLayv5xIyAuFPParMnwu8Wny449F1iR/sYupUk0ya3KEjhPmUZJPTFZPj3hv /oLj+P8AkH+ofE26wkvw/wAz/9L4sg+DfxLaG4b/AIRLW4vLjWZdtg03U/c4yc49q04fhH44F1aK fCXiD7RN8lsz6LObXd3+crjj8a/3SfHfDfTFx/H/ACP8Vv8AUDih/wDMJL8P8wk+Dfj+5uo/M8G+ LC6S4d/7Mlit2xkdWAyOOuO1EvwY8XWzO9zout2qB91wZrCYKo6ARnHf8qzfHvDS0+tx/H/I0j4d 8Utf7nL8P8y3D8LdYmuY7ZdB1lpJiYYYU06VXmKjPyhQefxpj/Bfx3FdfabbwprkttGoUxRadLLK HJxtcY46Vm+P+G9vrkfx/wAjWPhxxV/0By/D/M27H4NfEKXTnaXwZr1tql9dO9vBfaU62cGwEAEr k7TgHnB68GskfBz4kTFo9V8N6hYAbgXtbC4uuFHLKPL4Un1PFYS8QOGo/wDMXH8f8jaHhxxS9HhJ L7v8z//T+PW+EHjBSs8Xh7XZ4ophFiKylkaXjq21Pxxg4q43wk8TNdKkXhrXZpS4jEUejXPnqO7b WQfKMda/3B/4iFw0v+YuL+//ACP8Zl4bcUy/5hJfh/mTw/CjxhPNdwr4N8Q2zWcJaW4vtLmtI7gE /KIwQSST0rLb4OeNoFuJLjQ9Xt5fL/d79HuWjZiDtTcqHJ56ij/iIfDS/wCYlfiaf8Q04ndl9WY7 TfhB473JB/wiuvgrGJLu4fT5pUgz0BwpIz/tAYqU/Bfx+shu4PCuvSibUEtFB02fgNjLA7MADk8+ tZS8R+HIvXEG0fC7ieW2HN25+B3xGN2lufC+oLOW8lYvJcszD0IUg5HpVD/hQ3xDTUGj1HwP4rhe CLzN9lpEt7CynuzqMAcDqKS8S+G0rfWP6+8v/iFXFN/93X9fI//U+XP+FH+N7byUn8GeNBLOTKo/ sC5mBjzwVAUk/l3qzd/BrxRDZwNbeD/FxuIncX4m0O4EkCkDY5XZgDOcjOfav9tX4mcNrRV/y/zP 8eoeE3FLV/Yfn/kZyfAb4nnL6doviF/NxNtuPDV3ZxKn8QJK7cY75/Crf/Ci/iDf2txMPB3isz2T 7Z5YtINwoA5yoU5IOOhAI/DNZPxN4bvrX/L/ADNoeE/FKs/YL8f8iKy+BfxWt7WL/ihPEMtzqRlh lj/sm6to1tmGA/mNHsD45ILdcYqSb4B/E77KLHTfAGvRTQ3KR28U1lLcPeREDMplCnbg7uMkYxT/ AOIm8M7e3/L/ADJfhVxQ7/uP6+4uW3wZ+IUxt7W98O6zarC7JKsGkXd80jR5G3KRnv1/yaz9S+Cf xDt3gvU+HniYW8rEyXC6PLCq7eMNvCnJ7etL/iJvDT09v+Q14U8Tq37j8/8AI//V+U7D4IfFq4ml gbwF4m04RSb/AD7rSJXjMZ6HA7n8R71LcfAn4hWl0za54V8TwW/lh7e/j0W6hgkc9F+ZMHAJyM9+ tf7YLxK4Z/6CPy/zP8gV4XcUR0+r/wBfcaSfAXx7HbIY/D3ii7Rpwyzf8I3PEm1uV3A4wOvIz24q xH8C/iKbu62+DfFc0doEKeRotwzSHPIA2Zpf8RN4ZX/L/wDr7yJ+F3FH/Pj+vuL8nwL+J0aIw8D+ Kdk8pMr3umyWS26+uWXp7DJqhbfA34iNeWlq/gXXZDcyPHPP5Ewgtl/hkP7vvzgden4z/wARQ4Y/ 5/8A5f5iXhZxRv7D8/8AIkh/Z9+JTag1jD4K8VXYMxVryDTZoLKNc8bt8e7P4Usf7O3xqiW9sk+F muXkP21prG8uImRfkPy5Qphgce1Yy8UeGP8AoI/r7xvws4p6UPz/AMj/1vnyb9nn4pQvNJL4B8Sr eiFZTY2uizNblhyUjkEYU8dunv3qGy/Z6+LsqTXLeBb22jkfann6ZOkpXGSPucOMetf7Sf8AEU+G Y6vEf195/jzLwt4pfu+w/r7htr+zp8Ypt1wfh74qmt/M2xpDpkheZefmAx69q1Lb4DfFRx9juPht 4xhkVTLFFLp7xxYHZzglTn1BrN+KfDF1+/t93+ZK8L+KY6fV3+P+RnXH7Pfxl2q7/DbxJbhn5EGl 3Vz+7HUlli4/DNVbD4B/Fy7aQD4deI47dcqHk0m5IkKnGFAjLf8AfQHTrWy8VuF7fx/w/wCCJ+Fn FDlb2H9fcaVl8Avi2k6QX/w88TwFJTLaSS6RcoFwDswdmecHr69K6CT9m34oa/Fuu/DPiCN0cAQx WEyXrHGdgYxcY79frUPxW4WWvt3+H+Z1x8LOKGrew/P/ACP/1/n+f9mP4vxTxIvgPxKLSMMsiS6V cT3W4fd2lUKkH2zWyP2d/in5MsEvgTxZbpDCgjz4avZQzkZ6iL8DX+z8vFfhX/n8/wAP/kj/ACGX hXxT/wA+V+P/AMiLJ+zz8Zb/AOyra/DrxROrAiaV9HuLKOHb2/eIMn2FVn/ZM+NN3qFnd2vw+1qC 3eRRexXVrcR3TqOpjCxkD/gWOKyfi1wr/wA/n+H/AMkaLwn4of8Ay5X4/wDyIR/su/FjTr28MXw8 8VlHkxNusbiRQRwGH7sDB9s4rZj/AGbfik/ky3Xw38eWR81U8i20SW4lYDq5by+B+HesZeLvCqdv at/d/wDJG8PCTihL+Evx/wDkSSL9lb4sJPfG8+Hvii6tLiD5IE0qeW6fJxwREVB4yecjJqvF+yr8 ZLdSNP8Ahh4m8pJA88TQTy3EgYgYjTyyd2B0PFQ/Fzhb/n6/w/8AkjReEvFPWkvx/wDkT//Q8lm/ ZV+LBlDwfD/xZbGJ9lxFe6XND1xt8uPZljnOT0q+P2XPjZ51nFL8PPFV7MsvmL9n0W4WMp/CNxU5 Pr9K/wBkP+IucLf8/X+H/wAkf5Lx8IuKX/y7X4//ACJen/ZX+MoZZ1+HPiSMM2ySKW0ZJWOcfKfL GAOpySeahm/ZQ+MUkaJdfDPxZPc2bsySWlmxsnBGMscfNgH8DUvxc4Y29o/w/wDkjpXhDxT/AM+1 97/+RK8X7I3xxsZZGtvh54kuwiLLLBPpE8FyC5+6rBCrYH061tR/svfGYzQrH8MvGWZCFFuuluCH HXB2nmo/4izwv/z8f/kv/wAkQ/CDipyt7Nfj/wDIkNx+yj8Y727iz8MPE9vDZSeY11Lp9wWbHHG2 Pkg8YqMfsk/GuS5Ty/hv4ixOrGRY9PluHjA5VhtTjPofzpPxa4WW9R/h/wDJB/xB3irpTX4//In/ 0fNn/ZE+N13f3B074ca7gRKYpbq0mgSLbw4lYx/ltroP+GTPjRPKoHwe8UzWdoAPttvaTD5sYbef LwR6H3r/AGIfi3wr/wA/X+H/AMkf5Ovwg4qgrOmv/Jv/AJEqWP7IPx6m2y/8K512WYTvDbQRrK0h 5+VdgTAOAMknvxRP+xp8eUhQav8ACzxJaz6i7yxOySGOEpgD59gPoQMdax/4i5wr/wA/X+H/AMkJ eEnFK/5dr8f/AJElb9jn47m2jnh8Ba5NetD5ccbW5jiJTGSw29TjjJ5zVq1/ZG/aGvmnjufhV4qe 3RFQ3MdjIv2bIwf4Tkj2rKXi5wqn/Ff4f/JG9Pwk4ot/DX4//Im3dfshfGmC2j0af4deLbh5YBCF tNOnmvm3KSTs8tcEeuSOawh+xf8AGyDTZWHw18WC6iAWAjTZliQg4IlJXr69RWEvF7hW9nUf3L/5 I1XhLxT/AM+1/wCTf/In/9LOtP2J/jqlxB/bfw51WWSSzFys1vDJCIx1X5SpJJGBx1q5ffsf/H1L WNtI8AXxuUkBlhmtrgL5RHAVSind09a/1vfjBwotqr+5f/JH+WC8IuKZaeyX4/8AyJi237HX7SP2 1orn4X6u1ncy+TFPJHJAYWxn7uwkjp6Vr2f7Dn7RUqYf4b6yHhZ447P7M+xyOY3U7OhxU/8AEYeF bfxfy/8AkiX4QcVp29np8/8A5Ekf9hD9ovTntL8fDrXJpuHu7O3sJY1O7gxK0g5IHfjpWYf2JP2g PPmvLDwReae81zk6beW8l5NbLnBJdCR1ydueAaz/AOIw8Kp/xX+H/wAkKXhHxQtFS/P/ACJ4v2K/ 2im1ZL1vAU1+1iyRwoLaSC33Z5lKMckDI/Ad66O8/Yq+P7JNe/8ACB3MvksI5CLK5iihPBJVtpGM npUy8YuFf+fr/D/5Iz/4hBxT/wA+vz/+RP/Trah+xp8ddYistNuvhvqUr3NwYx5fmPCqKP8AWB1U MMnHGD0rRb9gn4+Olta6T8PtQ1KSytfJdWSQlMD+75YJ9jx61/rE/GPhb/n4/wAP8z/KuPhFxRHe mvx/yM6L9gb9pWV5dSX4cX8+pRKtrNHbh7h7SNeNzDaNvpjt60sf7E37RBuDaab8NdQursdRdSZa 6buqKoOAOfvYrOXjJwxfSb/D/M1Xg9xPJX5Ff5/5HRH9h79pGGxAufhfqMMtswH2aBnYqcYIJ2bB jtyRWUv7Cv7Qt2hlu/h5qFpIJybszxzFYl6Kcrkc+/5VE/GbhdP43+H+ZvS8GeKJbwX4/wCRqWX7 CPx7aK4dPBFxYuzBlS3t3uJWXOBuyAPmHfHfrVG9/YN/aT1K4nt4Ph5qEdtFdCO2c28nm3in0ABw QOvJ5rF+MvDb2n+KOyPgzxGviil8j//U3tL/AGBf2h7W1vLdvA9+1rbt5loLwOxZycEFFXg8Y+bF ab/sI/tC28kTJ4LuLm7MRk1BGt3hNvgZU9M4PTPT3r/VX/iM3DyVlL8Uf5irwc4hbty/gVtO/Yg+ Ol2Xa++Hl9YusDTfv5N0MrZwihl3AA+pNVZf2E/j4Y55Jvhff308EP7iW1vna3iZuhOMcrwcE9qm XjLw/wBHf/t41Xgxn/2rL5f8E1bf9gX4+28l1cweB5WU2sMizXsUp3HbllQBTtwT7ZrLP7CP7SSG 1jm+HNyltdB5T9mG2dmBKqwHU56428juKy/4jLkPV/8Ak3/AK/4gvna2kv8AwH/gjZf2BP2g/sdt I/w+vGDTeRctMgVkz0IAO4dBwAetR2n7AP7SSSI9t8PnuyJiqIJWV0/u9V6Dj1NJ+M+Q9P8A0pf5 GtPwYz1q1/8AyX/gn//V3Lr/AIJ7ftS3dvDe3fw71OC789oIdPEZilKA/fJYkFe4AOa2Z/2BP2kI okUeC3imjl8oCaOdE2gDOfk559DX+pf/ABGfIuv/AKUf5qf8QTzvr+T/AMylp37DH7SkdzMLjwD9 uihcqJ7W8MEFoOxkyjE/kKdd/sE/tL3KJHH4Ma3uUmacozm7hmiC/IFZQoXJzyx79qa8ZuHZSSlL T1RtDwX4hirpfgx+k/sGftFS3jWt14Alh1K6iVLKUSbbWDn5t+NzH8OK4L4mfsjfGf4aI95rHgu9 bS5ZBF9vsY2uUWRUJcMpUEkEE4UE4PfmujB+L2Q47MYZbRl702ktVu3bb9Scd4RZ3lmW1Mzrx92C cmrPZK97/ofLZkZEiSPjkxTK4IljkB2kMvY5zx+lekeAv22/jJ+xpfNrPhK+XWoGvGYeGtbuNunQ lkBJUKV+XHPLemOM16PiZhKeZ+H2NwtdXvTb+aTa/I7PB/ETy/xCwtak/tW+T0P/1v2A/wCCZ/8A wVf+Kn7ZPiuXSfFXhTRdPs9NCw3M+mTyNCC7+UqkEnJ3HOc8Y754/oB+IGqT6F4O1PW7ZmjubDT5 dQUoMgiOJnGOe5A/OvlcJ7/EOKT6Tsfa433MmoLumz+Q39qT/gvx8Yvg/wDEbxZ8PPDXg7TfFVna TzWkkev6lJpr2/luY9wdBgK3O0HOeDnnA/mO/ab/AGtviH+1R8W9a8Z+JNI0TSIb+4LGx08O0Fkp OdscjZZyBgbm689BivrseuZ28j5rDxcbH6if8EJNGttW/aOea6eSLTv7UKv8pl8+aMBUfHbklPcZ r/Q802W0s9BtGu5YxbJZqk427k8sgZH0xxX55lkX/rHir9on2mYK+RYdf4j8If25NK8Lfs++ONA+ O3w58dxaJr2veJY1k0O3uRENUJ80kPEH3N+7XD5Hyhux2mv17+EWrW3x6+D1nceNtPtr3Ttf0Qw3 tpLH5kUizQrhk78q4IPvXvYxv+1VHyPIwsF9Rcutz//X+pv2sf8Agmn8FfC37avhPTLTSM6B4x1O HUDpksEL20X79l8tI8cKSu45H8WBxX9JfwD/AGZPBHwL8E6YfAulJpjDT1R7e0jMEFvGeeFyQDhs fl6CvAq3WM5T65RTwtz82f2qv2sv2yfhh491DSfhh4B/trSUu3htZ57eS+gVI3ISQBDt+ZcE5/Xn Gj+yl+2F+2H8QPiBZaf8UfhtaWPhx51iu7mLTp7FkbYw3IzsA3IH3c4x3zxdeNp6nLT62P0E/a8/ Zd+GX7Vvwe1rQPHOkRS3z6MZorpIEN2hADhC7c8ED3GM8Hmv8zf9sT4PaF8B/jh8Rfh94a1fUdWt vDupS6fBBdRKqRxI7DO4cHOQAo9DnNapfumcE7e01Pi3T4bm5tz8kLIHfc29hJGF6Db7/wBKnuWU W0c88CnYxELjq22uGotdTVS5dj//0P5K7Zy9yZWUDcTk91711elSQSSymNnZ0wrrn5E/+uf6V8nX j7up9Dh3Z2P6Zf8Ag3q0oXPxe1m/S2ltf7UsZbG0kaQLPPdiVoQcDsqlm/Fetf3ea5babb+Gxa6t OqWQsVW+mkfcCBGAzMfrXyXD0X/bOMX97/M+4z2S/snBP+5/kfm5q/7GP7KfjHxy/j+6Xw1c+Ior g3VvcvCslzZybtx+ZXU5BAPzZwQMdK6z9oX4++Ef2Vfgtr3iHQvEdmsWh2BuPs0boVihQfMRk8Mx KgDvuNfWY6Ljjov1PBwdpYOS80fzcfAf4nXX/BT79p+1j8fWNl/whuhXEk2m2codpZ1TJId85O4s CVPQYyDnFf1V+Cvgj4Y+AXw6mPg6CHS4NK0v7Xe21vuhhkZFLDCk++OnQAdhV4Ct7bGuF/hsh47D eywilbe7P//R+u/2o/8AgvP44+BXxN8R+CtF8K6d4nsNBvGtby7uZ5YliOFwI40UdMkZLHgZ9h+g X/BM7/gpr4v/AGuJBDrPhaz0yK/f/QRbtJIrguUbaSenOdren1A+Yz6Tp1YeqPtsnpKUJej/AFPY P+Cqv7D/AMLv2iPg3qniHUdOhtPEfhiyaaw1KJd3IEh8uQFgCjM2COOqnOQK+Hv+CU3/AAT++Dml +Dl8Uy+HNJuPE6ancyXuqSWzi/gjjcRwrEwbAyQrZz/AMAdKrMFahQfoRhoL2lRLzP0g/ba/aU8Q /sc/DS48Q2tjaazFZor21rNI1qhhRDlGYHjjB4yePfI/BXwl/wAHDHxI8R+MrPw1b/CbT4/tt8kc LRXMsouI94BMYIOTyMdM+3NdmcJwypVFvY58sXtMw5H3P6jfg345sf2lPhE7eMNFRNM8RaP9jukl Zzv86AbsZwQV8zHFfxXf8Frv+Cfng/8AZn8dr8Qfh3dXsln4kvmv9S0M7biBfPkZXMWDuAztfBBC 8jgdOXhdvE5e63dN/eb59D2GM9l2dv0P/9L+X+90qCG7uY445LZZZgXLKTuZiMhPfrx2Nf12/wDB vV4ftpNQ1rUZbZLIeeH02Boh5TOgiSRwexbGSR6V+W8bw/2Okv8Ap4j9S4XlbEVH/cf5H9QH7Yur jQf2fvG9zAwZo9BuY4Spz5rSRGPoO2HbP1r/ADCP2nNeRfib4/hjsXitn8QX09r8nzKGl9OuAT6/ wmv0LDRayh/I+GxTvmH3nys028LNKoJZPmxx+QqSaOyudNmV7dgpXcrbj5pIIyPpx+teVNWdzoTd rIw7i2twiPa7w5jCRowOyE49PTitGNXMMYhBt50YAzFMDI6EevNYzWgj/9P+VQNLbwzGYI9yy4kk xuVT/fUetVdPSVQ7TTGdT84Zhyfwr41uzsfQtt7lfayl0Rch3LccKB6VTffbj5FJUHJ5ziqLp9SY XdtiKOS0eS6+8smARg/qKv2yyrDczhCxWUIUz8yqRnOKTdkW3ZEEMyzzIkSykncZR5bARhepz+v4 VYvNUW0R7VF2QwovkoQW8wn7xU/09qZlzPY//9T+U2xmSLzbg5d3+VOMKPqKhuizv9oWYwF2xIoA WOQ8f54r4+3Q+oJLexR4nKyRSA/61Q2SM+taFrqBsHQxwWt0Pu7LqBZojjpkEfypx3Rzm3eahoqR RSQ2txHduDNcw7gLd8n+DuB2xVC1MAuTcw7Yp5sSFV+7jrgV1QWtx1HaJ9afA6e41G8iiJlWKWGW b5AfLUQIkiHaf4jlhz0GfSv2U/Yk07+3Pi/4PP2priKwu1vL20i2CHyZH8uLcmM7g6MevpxX9h8L /uPBzE1H/wA+5fjofzzil7bxOpR/vL8D/9X+u/wja3Vp8MtPhjjMctlojw2gcbSilTljjrxz9a/j 5/4KeyWUnxlnWWeaO4t55l04RuYoZEZgsu4f7Xk5PrxX7F4AQcuK5yX8r/M+Y8X58uTwXmvyPw3+ OV/YWmlyqt49tIlvIBJApZLSKVAkhJPTew28ZGAc1+QPii1FxPHfxys1mc/Zrp0MSSKDySOx5H6V 9v8ASBlevhIr+9+h8l4Wf7vW9V+pzEtkHMUsKmQFQrunLOPYCqywCRwoXy0VwDJ1z7EV/M03+7sf qVa/tLdT0W3FskKSMsbMECLnGeOnFX1WWcOyyfZ1AGVXkNj1H615ldqzN4bH/9b+MS4VVPmfZ55E hjEk1ySPLfJI2hc59PzFdb4QOlWU3m2tnhrhwxkIaUjj5lI/L8q+ZqSt8jpiuZ2PoCxTy/sN3HaR 6g0WLprFQQlwFy3ltx3A+lRaJqkV5d3xvrB4LiVM+XKnmW1uCxwgzwMfWvPm7s0UbSuaFyi28WyE JFMx5KH5SvbA9fetS51bOkh1iCNax7Wl8vE8jDjIHf8ADiuSbtdo2UGyhZeI7aY29stszW+4S3iz orQSHPKhff1rLuNNgs59T1WO2eCzmlWaNYXeVLYccgfpSS1bM4037e7P/9f+OObw9YzszSeXKBFg M6ZkOexPt1xVOXTWt7SyiG+5hjQQXFofkjcLgBgc5wR19K8c43K8RLa7kgkZYx5rkGK1s7j54Is8 KBxnj1NbtvbXyRS3KF5LiOA/6I6bYoySQRvHODnGPesp7lRd1dli/trmOCP7VBnRr5RG0LnMwdRl gfVTnjjj3rOEki3ccUMRNqhEdusTFZHyCCMegpR+IpO+x2trezfYRBdW5VlyPkYkhc8Z9xWhZ28C xbHikn84hYkCltue5xWtzoP/0P5Fb23uNLM+k6dFMtvqM2+5mumEctrIOVIHdTk4A6GsnxDp32TR p7me4YqgSCSVTtlDPkKQR7iuGnIyXxnmniKKwOm6ckN5O96XJv2mYBFXGBgD8/yrhtCuEjbVEt41 uAqefHIqEygxE4KHtnNd9J3hbzJnK0+U/T/9mHW7rUNO8O2On3FzEl7HFcz2U8/2dZfLj3S7x0wF Bxnpmv1l/ZHv9Q0T49+Gpbi204DVCkSXqSi6vpVS4jLIoUkBQGySfbmv7j4FXtfDFQf/AD7f6n89 Z3WdLxQw8l/NE/v8+DqJb/D3T7K2KvbWWnKlqWYBpmMAywb09K/mT/4LD+FNNk1/SdMnFvcz6fri apIL4LEjh4mkGxs/fHlr9d3vX84+FVSdPxJptbuor/8AgSP1zxwownwvJT7fof/R/LHV4rLT9TvL d3DLDbhpNoywL8gL9Oh+hrFv7yyUQtE8knlRqA6ps3HGCo9cep681/r7hPgR/mzW+KSOYJ1Ka5My uREgO9SM+Znp9MUz9/bS/vJ7xRPGYZBFIUJRyMqB2/wrZpJpmMHZMv3tveG0gjhlaVYYBA3nKBK6 LgryMc5GfxNNutQ+wWdvLLbQXU4Cw7RhVYsVWNZMdgSMn3NKsvcZ6GDmo1qbfc/sm/4IxarrkPw3 isdTnso7uV4YHezuxc2lygTK+XxkYw6fhX6K/t16Hc638HPENvpsS3F0tvHJaxsq7HkDhwuD1z5R GP8Abr/MrjSUMP4o1Ki+FVU/xP8ARhwqVfDqlF/E6L/J/qf/0mfsJX81l+0paaeLsSawNXmtb67a dIFiFtPEiRtEF5TCOS3Iy2K/tf0ia41HwknlJBI4gVYfLx5b7dhYD8civ2zxra/tLBS/uL9DyvDh S/1UlB9G1+LPxr8KXc/hz9s3xLpN+sdxa3Wry6ihf7i/PFGoXr90M3/fOa/arWtPs9V0VYdSQCOa BfN6bXBUZByMYI9a/O+JZ81PBTX8iPqsng6eWVYP+aX5n55+NP2D/wBmPxjrmo65qj+FLfXLxhPI 1zr8emzqUGMgKQeMYPHauz+F/wCzb8Dfhpqia74e1DwrazJF5Aez8SoLNWXgn5iB0yT6nB7CtZZz mVbArCyp+7tt/XY4cHDAZdW5qUkpPuz6l8WeIvA8vhLU7OTxV4bUJpjz+W2rwyl9qEE9fmUjI4z1 r+RzVv2xNf8A2bP2o9b1jwNJHNomsar519DpV6jQmK0VYJ9q8q7cMwAPzA9z0+78KcklmmIx2AxM Wozg1dr1PzbxEz6nl+cZdjMPJOUZO6v5xX69j//T/rb+APxo+HX7Vnwy07WZNW0nVptT00Lqdg0g tpZzKg4ZWAIYgkdM5B4r8X/+CiP/AATLt7q5v/Efwc0iay1TUbj+0ZrJLuSKyz5mXUABl5BO0YHz Y5A5r9V4XxUuDeLpYPGRtTUnGSfa/wDSPnOL8HT4lyFY3CSvJWknH/gff8j8vvhV4o/bC/Yz8RQX 0Gja9aaW94kstnJazyWDpv2s6SxKwUjJwCTz2r6I8f8A/BZj9oDxd4TvNB1O0tRbzNJaRajJHGsU 8fIR3UxBsDHJPBB5r+gFwNw7xjmlHPcJJPlabt3XdXX4n4djONc3y3La+RYtO3K126PXVH5A6pr2 m+I9a8Uasy3Eus6/dy65dXkt2jW1xN5YD/KFGAdmRtx+NY/hy91GxvtIvoWt7e7TV7Y2kgb5yfOT cA3bOOo7A1++VqUYZb9WS91K1vJKx+O5BFwr06kekl+Z/df/AME59en1/wCBfhW/uJme7nsBd3Bi G6PBxsBPfAP614x/wVf0e21v4Layh0+G8vG0+7kgkZcfZvLiDnnp8w34z0zX+eapxwXieqcXZRrf qf3Fxu/rXAtSbWsqS/JH/9T88PCWgJttgsTLZvdeReW925leBIyVYKOODtOP972r+2j/AIJba01x 8DdGgjjjijsLWO2t2RdzbQpIVuc42uuPQEV/aP0h4urwhQae0l+h+IfR5UFjcamteVW++Rt/8FK9 N+3fBXXA8UgjkgeK5MStD5kUsTLISw9AW6V/P9/wS81O0sPjVNqQjtxZarKkdnFcTifVLaAvMjEI Dxh1TJI7L6g1+T+H1BVPDbNVHdP57L/gn2uMrun4t4WlP4XTv66tf5H9idy8N14dSEbnheyX7K2z JjDINr/h/Sv4mv8Agp/BHZ/HrVXkhkmub+3nt2muFyVa2ug+UU+hmbJHbFcHgRH/AIzR97P8zg8e Z8uTUX057fgYX/BMQpD8d9LnkuJLS0vroW3mcTfbpBLGMbR0C7j196/uL0iXd4RjnW5UxPD5UcoG 5URQAMj+lez9ImlycQYdrT3f1R9J4Tv/AIweKv8Aakf/1fo7/gqy91aftE6exMU1s2rXVjDdLKY/ P84wyxsRwQE8xsnsc1+9f/BMJ5V+B2g6fNBFBc2EKCeWJsrcBgQGXnJXgH8fXNfv/E8E/CbAd9P0 PhvDmu58QZwn0k1/5MztP+CjOnSX3wS1yH7BDd3l3a3On2LudqxLPZzRk57ctnPsK/BP9gf9gjU9 e8XaX4w8YeF9NvdPsJ/NiknAvvPBkJYhGO0cDp+feuDw44lnw7wjmE4ys5NJfJf8EWecJYbiDjah XxC92nBt+evX7kf0K638Cf2WvBejWs+ueEvBPhzd8rS/8I6FkdjgHcU5Pqc11fwq8O/s+aZqBl+G S+FkmcBZTY2X2Ocs33jgepUHn+6PSvz6tmGeY7BTr1ZOVN7vTf5H1mXYTKcHmX1fDRUaq++x798Q bVm8Ia3BFIoL6TcRsv8Az0UwSDH0r+Av9tvS7u3/AGkfFMFxAjW5s/tEOECiAz+UWb8TGQPYV+wf RumlxHil3h+p+Q+PvKsLg5PvL8kf/9b889MltI7iwhuZ2H2Sc3VulrKyxb4hkBmAwoOMHNf2t/8A BKTUhe/BLQJWEUMMmlW1z9mgO8RmRMspPXOQD+J96/uL6RdFPhWFV/zJfkfhv0e6qliMVBfy/qfQ X7fUSz/BHXIRCji9uvsqoRlmMsMsWcf8CGPfFfwmeJYlGr3kc62a3wv7mCZzEn2mVFnYR9PQL+lf J/RsXNhsX6r8jh8aJQWd0acv5L/iz0z9nN9Vh+OXw+gW+traL+02cyXTiHzYk2vNEPXhVIHrX99f 7Pcwl+F/hgQMotU0aFRHnOJAu18fgM/jXJ9JF3WEX9dT7LwOjbIsSv7z/JHOfF0/Ay6jfS/ip/Za wMwO7VLFLm3UjnjPTHXJ4rwS21H9iOyU/Ztd8IWrQKEgks9CVZTjsxA68ck1+CZbh88qYRLBXdL8 Nj7atjspoYtqu17WLe+61P/X/sh8N/tJ/s4+HrWK1tfH2nWVta7YYoYbMwoQAApGD0wOp7Cvxq/4 K2/Hj4PfEX4d6xp/hfxhpGt3lhodzLm3Ux+S7MqozdsBWb6lD6An9k8OOGM6/wBdsHip0mkpptn5 L4s59lmK4JxWHo1FKUrbX7n8ol3Jcm4ilS4iubW6tRIBs8to3zgL+XNUZ0tbcBFDKu3Lo5zuc9cH HSv9LqR/Djl7tinbSwLm08q9nu5nBsYbWLervkfK314Aq3NHqdrcwwQ2+XkfE9uFImhIPII9Rzmt W7Owou2h6p4U8Eah4n1KxsdJmWXVbi7i+wWudsk0gdcR4x/Fz34r+mj/AIJy/sDaz4XdPGPxP0PS p4r2VJltJgNQghTYCMrIoydwbsRyPXj+evHXi9cP5FLA07+1qap/gvPdH9MeA3CH9tYuWd17OjRv Frz3/Vf1v//Q/r88a2P7L3wzhjHiyx8LaJHLIlukcujwnzWP3Qq4Cgn0HPHevTPhLf8AwfvY2k+H V3p08NwwkUWtktkq98KoAH1Iz09q+2xscVUwKqS+Dl/r8TlyupRjjp0o6NN/19xY/aTt0ufhZ4lW SJLjydNMkNvKmVmIZflz9Mn8DX+f1+0F5w+OPxLufNsoLKTxJOdPsbcBYYwNjEgjr94D86/pL6Lc 5xq4y+ysfzL9JKMHLCpbu7PPbC1k1WO3lsYYndZQJ2eXAhx2/HtxX6Xf8E+PB2n6j8YNOPiCzt9R gt9QjEA+yCYxwbDJMCT8obcqgE9q/rvjytKhwVj6tJ+97KVvmrH8r+G2HhiOP8BRqr3fapv5a/of 2I+Efgd8LU8Haet34R0ae3ntlu9jaXCkyggEMCF4Jrynxbcfsv8Agm7e28Qf8I/o/kvtKz6NDI5J 42Bgv8/TrX+Y2U5jxDmuMq0cLVlOavpdvS+tr/K9j/RziDB8P5L7KeLpRhB6LRJc1tL28r79fkf/ 0f6y73xt+x7mCKTWNCT5A6xR6FE5I7cEZPrgjtUz+Pf2Nre6S5bVfDFwZbcJ50fh+EKgHd1Cggj2 Ga/cI4DjZR2nb+vM/JHnnBbk1eN1/XYVfH/7HW0vPqHha7RZfMjRdGhh2Z7kkA1WtvHv7HLzNbWl 54VC3smCn9lw+W5HzHLHpj1zVRy7jfrGX4/5mf8Ab3Ba25PwNCD4gfsfSXM7G88I2k8X7rzW0OF9 +DgMrc56dafN49/Y6O+M6n4av7q5+SUjTI0wc8Y5Az9KpZbxt/LL8RLP+C+0fwM2Tx1+xal1bz3u t+HnuuLeKNtKScQBcjEkeMY69QT1rQf4gfsdsrwrqvgaazZNpWHSLeFwwOcBWA/Sl/ZvG38svxH/ AG/wZ0UfwP/S/rWj8efscTQsTN4UgWKUIPs+kRDy8dGPb8aX/hN/2N57mUSal4atowo8x5dKQRzg cBtmCG6dhX7n/Z3Gy6S/E/HHn3BdtIw/AdH4q/Y0Etu1tqHha7eS48tY10uEhS3ALRnkD2IpL3x1 +x1bzy2NxfeE5ZZW3GF9FjcR44+UYAB46Dmq/s7jbtP8f8yFnnBmzUfwJrXxl+x7G0U7aj4Via2h JhhutLiIwTjiNh7d+lPm+IP7IHmTO+r+EbS1mh8ycnSYobafbyQc8Z46U/7N437T/H/MP7e4MW3L +BWHj79jm+cXkeqeCGglHNxH4cgLyYAwC4XPPHBqX/hNP2PLVmkn1HwozeTxHNpUE0cansExn8Ka y7jdfZn+P+ZL4g4LWnu/gf/T/riHxI/Y8giVo7vwvCtw+2O4i0uCIFl6ccY/KpY/F37JETGafVtB mRgzwrLo0UrKCMlkOMflmv3j6hxr/LL+vmfiv9v8E/3Sr/wmH7GMdu4TUfC7RmbzZzceHkn5P+3t JX04pF8Sfsc3N0kcd94P8u4A+e30FGSPsCcrkY461P8AZ/G172n+P+Yv7f4J/u/gQT+I/wBixmeK 61LwlKbb92zHSYUkkwfl2gAHOPSrw8V/sYtCs8eseDGhdTGUl0yBCAvBUhwMdO/NP6jxsukvx/zI lnnBMnry/gJH4v8A2Nnij8q+8JQrJJhQPD0cmf8AYzjgdD6U2TxL+xm948H9q+DxcovmSImjoISD 2AAK0fUeN+ql+P8AmJZxwS9Vy/gf/9T+uRvFP7HG63S21/wZbMjkKI9BjjeMn+98nP1x3quPEP7I Pnwhb/wc8wcyLcSabHBvAH8OcZ71+7fUONV0n+P+Z+I/2xwV0UfwJ4dW/Y5iWeSK+8H3DAHzIZNG RNgzyQW4z/u1FFrf7F0sr3Nvd+Eo/wCzot7wfY44Ul3cEhG+9j8qr6nxqtlP8R/2twU3ZqP4DYvE X7INwnlWl/4c2sS77dKhOR1O5gMAc9M1el8QfsYJM1lLe+AkvrkLJFDeacizSDHVP64o+p8b/wB/ 8SlmnBKe0PwKkeq/sXxzu39peB2kDlZLY6dE5Yjg7FYf/WqWWX9i5okuluPB6xeZs/5AqpyPX5at YLjZK9pfiKWccErdR/D/ACP/1f64v7X/AGLpJnX+1/A9tEI1/dw6KluxwO52Z/GqI1X9ik3Lst74 R3Q5WN/7MikRunO31HtX76sJxwvh5l95+HvN+BnrKMfw/wAiWbxN+xbNGVur/wABlEQjP9kwW0hO ercAknA4/nT1v/2L28iY3PgR1kXBgbQ4pI17AuhWn9S453tL8SXm3AdrJR/AbDqn7FCRM/8AaHgT bK5XcukRW8cG084QLx+NS/aP2N7ny1OreDLqF0ISaHTkmde3OMkAduOKpYPjnrz/AIkf2zwFtaP4 f5F4n9jq0sEje88CfZ1UuDFp9rJcy84y743ZHYGqItv2Likcp1Hwoy3I2x/8S6JIpCDzzjBxnHtR 9S46d9J2+ZrDNuAoyvFRX3f5H//W/rkEX7HUd1G51bwhZm0gZfIuLaGGGbd/EMjB+oPT6ms97L9i zVbqO1Or+CJbqEGclLWOK2XJ6NKoGcehNf0J9V44XSX4n4tDNuBFs4/gPhtf2MLaSaJLzwLI78EX FnDMq4PVSw/DArXTS/2OFCzBvBsiM5i/0bSl3I+Octx7dBT9jxyukvxE804GbvzR/Azo9M/Ywnun gW58KvLHODKj2zLIzA8LuIxjjkZp0mmfsXT3E8TN4VV4pd6lIldIiOCvy/LjpndVey43eyl+JP8A aXAl/ij+BA+ifsVvJEkdz4CnkSTc6vYwytn+LJI7fpWn/Y/7HPkRi51DwDCkpK2kt1awm3UqeQiE YHpQ4cdrbn/H/MiWP8P5buH4H//X/rhfSf2OSRdRXvg1xBN5TPBaqY5WHACgfKfyIpZND/ZCu0jj dvBg2SZncadFbshPQOQM/rX9DNcdLfn/ABPw765wC1Zcn3obH4Y/Yzg89nm8DQmc7ZFlsozOu3n9 3kbh9RST6R+xTZxrdf214GcA7ZPOjjKg9BhSBj8uacP9enK3v/iZSxPh9TjzPkv8hB4e/YsvIyBe eBvMm+aGRbZQhA9Rjb/Wp18K/sZxyMkt54DaWYpEVjtosLj1CDI961dXjy1rS/E6IYjgCcVOLj+B eHg79jl45ZIpPAbRQSETEQ28/P8AtAjPFZsPg39ja/LSxz+AfLkPkyMLeK2CAfkB9an23Ha35vxN VX4BWkeX8D//0P64YvA/7F7SBLU/DceVJgvMsflzN0zkcn+VFv4T/YxeN/NvPh8rrK0DNAkciqc9 15/Cv6JVbjv7PPf5n4t7fgL+7b5D5/BH7GMxcyX3w9JuYtg8q3jhjYD/AGRgA8fWoZ/AH7GTLZkS eB0AcGEoi7SVGO/9c1ftuPf7/wCIvbcArrD8CQ+CP2MHAtrmbwE28M6K6L5pwOTuGfSoB4K/Yta3 VZLjwNDCq74pIoFfuQQcjORjvU/WOPVp734h7XgDry/gLZ+D/wBjeKB0hfwHcQwPullMUbSjJ+U5 xmpI/BH7G95JvWTwPLIrHzJYIImEY6YY84/HFWsVx50UvxIdXw9e/L+B/9H+tS9+HX7F4jbZP4Gl WGTYI7ciSZCeuVAJxx9Kqp8Pf2Mh5UjL4AjSGTZbyFI7d4SevO3OD3r+jlmHHuzUvxPw6L8OU+aL idEvwv8A2Rry3Fn/AMUI3ylvPtmWFmGONz45A7AnFZU3wz/Y0dfstzJ8PpWg+XbO8Z344zgDk/T9 af1/jvtP7ma8/h7veH4B/wAK+/Y7h220eo/Du3ECjerGDaoPQcjPTsOamg+Gn7G1zK1ta3fge4eQ B8Bllxg84PQD2oeO48a0U/uZXN4fLrD8CC9+Hn7Gct2fNn8DqI38lm8xDEpAxgjpxUzfDn9j6Ewx RyfD24GA5S1jgaONe2cDjPfOTRDG8e9p/iZyn4e9HD8D/9L+uIfC/wDZIVjNBD8P0juzsAeaNEGw dgMZ6VRuvhZ+xjdrZSzf8K/fLMgMsq3MDkHBBXtjFf0ksfx69Ep/cz8N5/D+97w/Ae3wl/Yrt28m SH4aySTMGMMfkyZ9DtHT8TUU3wp/Y3R0W2Pw3TyjuWImBSg78ZJ/Gk8w48WjU/uY/bcALTmh+BWP wn/YokkhmuP+FeNFaz+Y8dzMrKGbPrx296kh+GP7FKXDmJfh0xWTfakrFOIc8cA54o/tDjztP8TN 4jw/TtzR/A0Z/g/+xwUW4uW+HwguP3e2TyoULHvgjgfpTLP4UfsXqzm0h+HEotLkDY08axxkggBB jn6jNL+0ePO0/wARLEcAJ/FD70f/0/6zj8Jf2OmV4Vtfh7GqszTHcvmxljksWPP696tJ8K/2JUhn SKD4alnjWNvOdGkQDAyExkfUfnX9If2jx52n+J+Gqv4f20lD8ByfDX9jW1Rmhl+HiSWqeevzRuGV eCFUjDfrU8vws/Y+mWOa7tvh8POAnjmYJA7dzg9M+1P+0uPVsp/iTz+Hz+1D8Bk3wk/Y5N0Jnk+H kAlKsrhYPNXA/hJH+c02X4RfsfSLELe48E3YikLoxkhLEnPG48H6U/7R4/7T+5jv4fd4fgVp/hV+ xTPLDp99H4RW4u1LmOGQLFMq9SdvygVdk+E/7Gmn+bdK/gRIJYhBbqFgmdQuM7Sck/Xt61X9ocfr X3/xKX/EP2tOT8D/1P60W+Gn7Gl0rLNd+AryOFA628oigEWP4ug3Y9ulOHwr/YwlDW81x4DunVgf JFwm2MHlVwOT265r+k1mXHq35/xPxBf6gLbk/AWD4VfsXWiXH2mDwG0dw/lL5zxCQAHsFG7H1qWL 4N/sXMEuIIvh9FbCUtte5WOIn2Bxjp70/wC0uPf734jX+oT0Thf5EifCn9jqWTMN54DjcTbgEuI5 16Y2j0/GoLn4L/sT+eyaonw6MsjBhOfIZ5D3yf60/wC0+PP7/wBzNIR4DvvD8Conwk/YhM032OX4 cjaNskM1wkiSkcDKt8pH+c1dn+E/7GHlqmoR/D6JY4/JiGVEKA/3SvY4o/tTj5bc34lyjwDfVxt8 j//V/rXHwp/YujhPln4aRQp8qlDEOTzxnk9s/wA6IPhB+xjfMtvDJ8OS8CGRoo7mCMOD1bBHI+nr X9LLNePevP8Acz8SlS4Alu4/gUYPhH+xXLBPDajwQk0cpibyxEq5z0Bxg9KfN8I/2MLTfOV8Bx7S FncW0BiJGOCMYB+nOaX9qcfvRc/4h7Dw+itJR/AqW3wm/YburuXyf+ED85WUnekcS5znIYjB/wCA 1eufgz+xRHcsZdP+G9xLKVlzKsMrsAeCrAdOPfpVf2l4g9ef8TJx8PlopQ/As/8ACm/2LImIlsPh nCs8vmkmC38xAB3b7wFWG+F/7FNxG1xDN8OY4bf5TJCYILcduF6Hv0o/tLxA7T/ElQ8PXq5Q/A// 1v61x8LP2KXH2gP8PGSEeVG8bwrCvPP3eCTnoearX/wl/YqMYka48AKJGURxI8cbFu2VHav6V/tH xAe6n+J+G8nh6teaH4EY+CH7DjMIY4fhxC8f/HyqSRxNIzc/NnrT2+C37DayDNl8OGIXY5VoXzjH Xjjsaf8AaXH62U/xK5vD1OzlD70W9Q+CH7E91Ey3TfDe2s5oFbaq2luw8vnIJHPT8ahX4b/sTloL dD4AdPLFtb+WsdvkAbQTgDJP97vml/afiE9lP8R28O3q5R/Agu/hj+xejC0ktvAqyD9yQqxNMoBz nIGT9avx/Cj9iqQZM3gBnkChIZEhSUY6g7hn8OtL+0vELqp2C3h0lbmj+B//1/61H+Gf7DxkezkT 4aofLx9gEcIkbPAfb1/I1Yl+FH7FMEVrHND8PYliyqLCYN7DH/LQA5P4iv6U/tHxBXSZ+I28O/5o /gLF8K/2Mo43mtLXwAkcqmGOS5ghlVT1IBYcf/XqOP4Y/sQJKJZYPhurxEDc0cLwMw75C4zmn/aX iFtad/mH/Gut7xt8ixP8Mv2MJ4QoHwvFusuyUwwWsiv0IXO35fwpr/B79i/c88th4ASSMAmSOOJc xgcAjHIo+v8AiA3e0/xE/wDiHltHD8DMg+HP7EVwXhtrrwc6PEYpmgkUyRnPTjoPYYq5c/Cn9ivy IjLc+A0hRljiaVLfkjgbgR/Oj674hdVP8SXLw6TsnH8D/9D+sq3+GH7Fible38A3NtBcbneW1hIi f13Yzj6cVpTfD/8AYcBYXMvwxiaVNkUMCQR7CuORgZDV/Sn13xC7T/E/DOfw7S1cPwBvhx+xXIEu bW5+H4+yruuC0MV1AykYBYONtOX4b/sUqodbf4eyEnaz+RDcZJ5+QYwvXtT+u+IXaf4kup4cr7UP wLEvw6/YytJ0O34dwxeUvE9nasikd2yMCopfhr+xFfloQnw5UQszuh+z21u7d2Axt/EUfXfEHtP8 TN1fDpbSh+BST4ZfsQ237gv8PElZCX+yNASY88EyL296snwD+xZBHLJHd+AvskjY2vJDKYex2hgc Z9uean674hX2n+JpGp4c94X+R//R/rfj8A/sViOKWyPgufymI/eWsbRA4xwCMY5pYPA/7GcEMsK2 3w3sGmlCM5tLVZp+c4BCnPfp0r+lPrviF1U/xPw72vh09E4fgXl8Bfsal4QH+Gkao3lRwJFbIzHu SMcn6+tJ/wAIN+xZCUQP8OpFiZnEECQBt2cHdtHWk8V4gdFP8SPa+He0nD8CneeCv2KdPliF8fh7 b+eMQBjbq2T8w+8DnrV2HwN+xrb2jzvdeBfs85IWaWODylwM7VYr2+tJYnxBfSf4jdTw4WjcPwM5 vB/7DupEpJf/AA7WRgBD9kMIkU/dySBkDPWpLnwD+xRZJKkkvgG3cQAMF8kbx6kY5J9TT+seIT6T /EXt/DePWH4H/9L+tLT/AAV+xZM62bxeC5FkXdFeSWkL20gH8JcjAx6Vcm8J/sVwT4M3w4McqiJf JtrdFQr2G0fn3r+kvb+Inaf4n4Q8R4a7tx/Ast4c/YnXyhPqvw887H7mJVghhOOmRgA/8CqtH4W/ Yp1hZ1V/AMjL95YbaCLJBxkMo5zjoKTq+IfaX4iWL8NFpeP4EUXhX9ibTDcyyH4eW8QwJWbTre5l jb1OVLCpovDv7EN1It42p+BW8n+CS3htracevQKcVPP4h/3/AMTVYvw4vdcv4CXPh/8AYg3m3kuP htAFj3CKGztW+Vjw+4L1Prmln8DfsXWUEU6T+DTFPhYn8uIPJzngij2niH/f/Ecq/h29uX8D/9P+ t6Pw7+xKFk2XPw9BVth86zinZCeD95eahuNK/YjtVSya8+GOIz5olS3tkZsc7QQMn6V/SHN4hpX9 /wDE/DFiPD7py/gRW3hz9i65hmleTwNAhAlZr+0h8kKxwAoYd8jFS3Gl/sS+YkC3fw3MsSBBLYWF m4hB4yQE9+pzRz+If9/8Svb8Ab3j+BZg0H9iiGMxNJ8NJlt0y9xJa2TPIepI4xuqtZ6B+xCZftVp f+ELv7TIUZRZxGEEHp93A/Cqv4iPbn/ESxnh/Hdx/AgutL/YpguRBJdeC7e4n+eNylvM2P7oBHH9 KaulfsTLE8s1/wCDwbMNIY0gicsO5Py4/A0W8RHvzfiP6/4fd4/gf//U/retYP2JhaRxWuqfDpll l8zylEM0gYc4fA4+hqje2n7Ey3bF9S8ApdznY6BYcp7hT938K/pLl8RHspfifiKzHw8vZuH4F5NL /YmjthNFe+DSYjseQ2UUplPcAlcD6r+dRQf8MOrJ9nhvfAUE4G5z/Z8F07jPThTz9eaTp+Ir6T/E h5j4dvdw/Anvh+xPbqjfafBrStgMz2EaLGp/iKsuP61YEf7Fd7DEsWqeBblY1/cqtvbqYM9gAvtU +z8Q9vf/ABF/aHh0/wCX8DGeL9ixJXt5bj4dXKiT97PJY2lyqc9GO0nir9tH+xb5VxBbt4I+zH55 XWyiEEYX1YjABpey8Qv7/wCI/wC1PDyOi5fwP//V/rXtpP2HuWtLjwAhSTZIkaQS4PTcUH+fWn6j ffsT2ESC4ufBbmL/AElZUtISyKep246fUV/R3svEL+/+J+ILNfD29/d/Ajs739iW7txDBqfgVTK2 dz2MQlkB5B3qM/TmiLUP2JLSRrY3ngcy3SGICfT4ZVAU8cMpKk468E1PsPEDtP8AEtZ34fx25fwJ 2n/Yxg2zxXXgO3MSculhCjoTxnOz/wDVT1179iuGGO0l1XwXKXfC3MMNvNtbrztXOPcjFQ8L4gN3 978TVZ/wB/d/AhfX/wBiSywP7V8DhpGJWSOyg3x+uTjjNWIdd/Yq1eORoL/wjGVg8tibZbfK9MgY /lS+qeIH9/8AEp574fdeX8D/1v61Y/EP7FGnubOa5+H5S3bYjTafbzPL6nO0sfxq1ban+xbCZXju /A9zHOodm+yxOluAeB0AX6V/RDwfH/8Af/E/GP7f8Po6e5+BkHxN+xTDeyAaj4OWWV1hYf2ZBuTO MEYXOPcVpz+K/wBjWCPzJ/Efg1ktn2rHcW8BkcNx8ilckfyxUvBcfdeb8Sv7e4Ae3IWovE/7GUIK waz4OmWUrvdLWIwk9cO+3HHoaon4j/sYm78mC78DSuSUuZo9NhdYdvQupXHOOo54pfUOPuvP+Iv9 Y+AI7chDceLf2KsLaTar4OeOUieF0sFHzfXbgcE+3SrUXjL9i5lOn22qeD41nAD3Fvp8cqydsOwG cZ7Hij+zePX/AD/iNcS8A/3D/9f+s+5+IX7GGkXlql1qfg+OWNvLt2axjLqB0AHXHoBWjP8AEX9j aaCOabVPC08Drwsulxojr6bQOn1r+g3lfHvef3s/G3xRwJay5PwIbX4ifsS3Xmous+BVhhjIeIWU cSjb1UuB19s1Xn+J37E2n/MNU8JQQ3kPlyMmmRNGAOxZhxnj65qVlHHz25/xGuKOBlp7gyP4n/sT 3sDW51nwrCq8Ff7NbBHZgQCMfSnyfFj9iFJrGzufEHg64kgQNa7dO/dAdsnGR078U3k3Hz35xLif gS+qgEvxF/YvtG899T8DlBIZU3WKRoPfJwMUsXxW/Y1vGdV1HwhKn8WLaJoxnoFwT+lX/YfHT6T/ ABF/rNwStlH7j//Q/rWvfi3+xnBAkb6p4VlhV8tFBpqOSV5G4Hkge3pTU+Mf7GV8rltU8JTQxKGe F9NwF4wuc8Z49a/oNZFx63rzn44+JOCrbRMj/hfn7DrXDWieIfBHmIPImgFtG00AzjkDnt7mtpfi /wDsYWvnltX8LSkW2ELacXkeM9Nh4H50nkPHnVzJ/wBZuBuiiZdv8bP2JbmOe7OoaCYIXVJXk08y Qx4IAzgkdau3Pxy/Ywkmt5z4j0EyzfLth0xl8pV6bsjj2oXD/Hn98HxPwMukfwEn+OH7Hlh5VzFr Wg+bzMY4NOKSnnqfT8akX48/sfTCeddR0LfKBJNK2nAls9RkH+dJ8OcdN398I8T8DNbRP//R/rXk /aB/Y4s3V7q/0NS7rEsiWSMj5B6HPPpxWcv7RH7FgkkI17w/A0W4m3axLjAPPyZ4Nf0H/qxxzJK/ OfjT4p4FWyiWl/aC/Y6uRJLDq2i4gjLINP03yVkU98dM+tRN+0X+x5DaxeZe6RJbPJku+j7GZh6s eCaT4U43ckvfNY8U8DvVKDET9pT9j1m+1DVtCggXIW4ubIyMg7glc7R7VVuv2kv2OrS4Wa11jSCH UM0ltpu1MNyX+YjjkVuuEOOVdWlY8ufG3AUZX90nj/aV/Y8LPFD4p8N3u9vNdJbI3EjFR909Rx9c Vn/8NUfsbzRtOmq+F0j+ZZJLazjIhdTtIcDlSMfrS/1O457S/Ef+vXAvTlP/0v6vW/aj/Y7urVid a0N0tIiTI1nsidfUZIz0PWorT9q/9jjaYYdb8OtCwUuTpolVm6hQTx6d+K/oj/Uzjh6NS/E/Df8A Xngb+7+Aj/tWfsd207Wk2qaFaSzRGYxy2AQbM8kDPOcHpT739rX9jW38mK21PSblVKo0kWmeUsee eO/4CqXBHG/VS/Ea454I+zylf/hrX9jqUtNNLorRJIbeab7GpUsOcckZ/pUtx+15+xQnktJq+kqz qFUtZoIkGMAY3ZOegwDSfA3Gj3U/6+Zf+vXBiW0Pw/yIU/a4/Y3BiuLTVtJa4mBt5SmlFzbL23E9 BzVd/wBrz9j3eITr+h3f2cfK8dqknk8+zHGP0px4D41vtP7/APgkvj3gq20fu/4B/9P+rK7/AGvf 2PJHiF1d6bIGBkhvGtVhUlR15OSMHqM9aoL+21+xmkfl3GtaVa/ZJPLjYW6SqAx/idSSv0Nf0b/q Fxre/v8A3s/DP+Ig8EpaKP3f8AZd/tq/sTXlzFGNa0K9SBgokhsUOxm6g85yfeorr9s/9jvT0Bu3 0e1tpJsGW5to7dMY+U8tnmh8Bcav+b72aLxB4Mte0SxYfts/salpTF4i0lm4TzYbNbm3RevDA/h0 qH/huT9jlZQYvEOmTyw7prdYbRPnKjBAUkc/XApf6hca2t733sa8QOC+qiTT/t1fsb6bbPNealZW ccqiULNYRxpcNkEDrg9fpU5/ba/ZG3pN9p0zc8XnK/2eELHkcbuRx+FH+oPGv94teIPBS6R+7/gH /9T+qr/ht/8AZE/1d5qOmQt5e8H7Hb+SwHO1juH1x0qnN+3Z+yBcSPBa6pptxNCcMun6dHIijGRu AOPz6V/Rn+oPGu3v/ifiv+v3BktUo/cUJv27P2L4IoJbzXNFtXI3ySS2kMEdvISQA7B+SQMjjvT7 H9vT9i6ZJmsNT0C6eDO6VY4Jih9TlsjPYZpLw940ei5vvZlLj7g1aWj9y/yLa/t7/sc20gd9e0K0 VkLN9q0y2gbf/dX5iSapr+3t+xtdK7Wt/o93Ic+ZcRTWsSsevP7wHg/hQvDvjSWyl97MX4hcHR0t H7l/kRR/8FEv2QpLn7JHqGjvfWxGxDPambcMLjIbPHsTxRN/wUL/AGQzLdbtX0h2t1xOkdvHKueh ViG6j0NU/DnjPa0vxI/4iLwh0UPwP//V/qJu/wDgoT+yG0Elzc6pp9tHBbK32iaC1jjYAfIgLEYH 1wKq6X/wUc/ZCvYhImqaW0kreT92yYYGMEENX9Frw24wf8x+Ef8AER+E4q6UStN/wUj/AGP1v20q TU7We5XDPHbxWd3JboThTJGHLKO/T6CrFx/wUZ/YvhRvtPiGyhljAeHNnF2P8JJB7HpSfhrxht7x C8S+En0iUF/4KafsixxArqGkSqzbBNIbXawY8gEOTnHbH41Bqv8AwUl/Y8tt4XWtG2Rx79n+gIVU 9jubIz+NC8NOL92pkvxL4R5uX3fwNrT/APgpF+yV9miP2vRWWdE8mO2W0kupN33cAZzntg1Gv/BR z9lLbqZOoWyLao3mpOLWLk8BG+Y4Prk034acXdFMn/iJfCW3un//1v6W5f8AgpP+yLEkdxMbSCJW Ee9obX7NC2OpYsOv+TxT7f8A4Ka/se3MzxHUNLumDr5RtBbO6DOOWBwfxPev6Nj4Z8XPS0vxPwH/ AIiZwdb7P4F6/wD+ClX7IWmSTTS6xYukCBruS3traOUBsBBy3Oc4+tV7f/gpF+yPNC90k2nwwoPt EMgS0knmHX5eRzx0J/Gr/wCIY8W/3vxJfibwgtlH8CrB/wAFN/2UbtroW0+mTTwkMUkmsnnC9MyI rkqR/tVl6n/wVG/ZCtCZm1LS57ryPMcKLWSCIr0UkNhvz4pPww4s/vfiXHxQ4T7R/A0bD/gp1+yo 9tbTXkujwieJpjcRyWSRSqBxsbcQTj1IqNv+CoP7KRm+W40g2oQzxmS4tDcPGv3jsUkZ4/TrTXhh xb/e/EJeKXCcb6R/A//X/pgk/wCCnf7I0Nqmp3ep2FtpyDzI7qa2t/IfsqKM5JznI9jVSy/4Ko/s iajLDDZX2mT3TMVkKRWsXyDp3yPxr+kf+IYcWf3vxP57/wCIpcJ32j+BWuv+CpH7JUNlNcw3eiKk LtE5ubixHlAHB3fMOp6L1ORioIv+CqP7Ibl7Oy1OyZnQKSotoLd3xkgA4z+NP/iGPFfXm/H/ACNv +Io8JvX3fwGQf8FSP2SmeG2Go20jzOwR5orZIV2fewoJPatC8/4KffsrJHA9zqOiETLi0E0tpA4X +/uZhhRT/wCIYcVW15vxL/4ibwr/AHTLj/4Kl/srQvKs11pt3GZRCi295Z3RlJ/iVQckcdRkDip2 /wCCrP7MkaRiK00hVYMqFp7Nbw4+8yIrZOMdAKX/ABDDijtL8Tan4mcKvrH8D//Q/pUP/BT79mNb a2v2imcSAyPLDLaxjaP4vnIxj1JHSsS4/wCCrf7JAlgVJtInMwPlrNfWNzchhySwR2x07+lf0c/D Lip7KX4n4uvEnhRJJuP4f5lqX/gqf+zMksEC2uhRWt5ai7Epv7YrOucHOOB0/iwfarCf8FRf2a5r hLaOXQbmCSMFUtLu3JjA5wwGenvip/4hnxanpGX4/wCRrDxF4VnaKlG7duh9m/An45fDb472Dah4 UtLEJBzGn2OP50O4ZV8ZPQ8j0PcECr+1r4f8PH4S67MukWAktrY3MMjQRqqugALEAck5P518Bh5Y rLuOcNhKkn7SE4r5po+7zPD4XG8GV63KvZThJ/Jpn8PfxSs0sviR4oGiaWkWkS6jNKf323yLlZWS ZQh5A3KSPSvi/wDaXvbW002+uI7aGVJHhlghllNy0RdIxIxx6OW468Cv9G+NZyn4f4mq1q6DbXrB n8D+GahS8SaNBO6jUtf0kf/R9R/4N0NIuJLvxDqs/wBlME2tW+oy5GZYsOTtC+h2rx7iv7Evjze2 WnfCDxXdzSskNv4dunVo0zk/Z3Kj8MflXyOVVP8AjIcWv7593mkP+EfDP+6f5aH7c95qN3+0L45n F1DchtRllsZRdCRdhVF5Uc8EMD7k18lW8MizIkc6JdOgZgw+V/UY/A19bi53qSXQ+cow0if0l/8A Bv8AeHC/xe1LUZXtnjTWVEBg2yBZIgwfzF6jqDg+hr+7Lxgq23gG+dpEVY9Fkurhz+58pYkLHHp9 2viMr1z3ESfXlPq8w0yihH/EfwS/ta/E7xx4u/ba0bwde+Iby+8OS6yjWMFm/npFbu+xwEHCkGI5 9FHsAP7mf2W7C30X4T+HIreUy27aLapCFTaoKQRxsBntla78dWUc/jR7xv8Adb/M5MFC+UOp2lb7 /wDhj//S/eX9qKEat+3X8OY9QiO/TbJGVowGAWU3MkbH04jIwK/a2C7Gi+B4bgK0vk6YjtFJHl2C qq42+oxmvnsVLlzWMe6Ps6Scsvk+p+Onx2/4K7/s0fAzxTf+G/Gug2X221nNp+6htmJZTtLOZMfk M4Brw2L/AIL7/sKtdSW+FsXtgsizQCyVHf8Augb1HB9DmunGfxF8jhoJ8rbMn4j/APBwb+yJH4ev tO0+W/n1OeyIXyfsUsDZHyhHSc5bocEZBr+Hn9rf452Px0+Mfjn4h6Np4sYPEeqTHS4mn8+SSLeS u8BQAVbPTqCK2jb2DsebWuqqPlSG4eKKeS5ZLPYgRvLY4lPQ59KyleR5pU374s7ogfuD1x7mvOq7 mtj/0/5LrQ5uXE8RSPzNkW3q3rkdq6qGNLZLg21uftEqgDyE3SEj7uB3PP618zXXuXPew79+x/V7 /wAG8GhQP4w1HUXiD6hZbZrSW4+SCPzbhnJU9A/yEenGK/si+O919j+FOv3bH7ObTR5Wnk3YJ8qF pPlPrlB19a+S4dcZZpi5R/nsfa5+pRy3CRf8h/nZ/tWftU/Ev/hdXjq0svH3ibTrWx1eax26Tqs1 lPBMm0bWUEKFHK5APT06fCfjH4xfGfxpaXmi+Jvid4r17TLlkYaNfa9cXOlDaQUypchsHke+elfX Y+K+s8yPCwL/ANm5T+gX/g350WU/EbxFq+o3SXrm5W0tYk2sbeRCG3Bhx8xQLj/YOa/tG+NNx9h+ FWvujKLptElQlEDlWWFmxjoSSO9fOcMYqVbOMXGXSdvuuj6fiDDKlleFa6wv95//1Pxx/bNjttT+ P3xVtbe9+1x3d/z56FHgc5Ulh9eeDX9JH/Bvl4atP7E1O/lnlaTRdRt7DSXtkURFWUiV8nkj9yeR 1318nxPPlr02v5kfouQ006U0/wCV/qf0T/txutv8BfFeJRCq2Nwrx7hF9pIjLrn1OU6e9eI/8E2N IhtvhfNdGBoo7kgsrNvbd5kg/DJUMB7itM2qKGFw8vNfmRgaXNWrr1Pzz/4L7aheTfBqfR7e+mgi 8k3RaNRvjRDGJFbHJRghB9BX8ZvwItZb74veCfO1CeC8F7H/AGelu4T7UQ6Mwb0AXt7ivQ4kbXDk nD4uV29bHJkMF/bcOfbmV/v1P9Kf9jix+x/BXw7Gbl5reLS4PJKx/NI3kxhv5V/Nb/wcQXH2S58K +TqrWV3b3OJIYvnu7i3Z2TKoOvTkdMbq4vDtzq8O051laXJqbcaQhHOKsaXw87t+J//V/mQ1dLi6 vrqSaeexjFwxEsD+Y+zPyuoPAbnpX9o//Bu54dEPw+/ta98iWWG5W1tEYn7SykP5krA9DkYIHcV+ acbe9CjTX86P1HhqPJKrN/ys/d/9vu7tNP8A2b/H1x9oWBLTQpvLRnESmRiuz5z67QAPev8AMV+N d+198QfGE9xMt9eSa7cZlc+WIU35CqMdMlq/QcMm8pSXl+R8TiIpY1ng+5LuSVSQnkHay7Np49qr 3TW4PyseRyMY5FeRVXLC/wDW500leVvUzkv5Uhht5i0iC5OzEWXJcgAcDp0FawtJ2Zsu0eXCbW4C n6etKEeak/mRVXLI/9b+UqYSQNIk1zvlABWJh8so+vrUZnUbVjU72I+UcAj0r4ya2PoC00ckTkzQ tCpP7tScsRjqapQmNZZvMbhjiMdcg+tWVF8r1Gi3UyGVGLBeAeua04rlUdZEBEuwxsuco3uR7Vg2 3uOUk1ZEBNrFKkU3mlJyRM9udrop681lXlrFE8SPdPNEkg+zFWyyjsGzz9aqMmnYg//X/k+mBCqY 2IAHT+9U50a61XTBM92tv5NyPLRXCyuP7wXuOtfHn1BNHZmwiaGNv3jphmAAd896jLtbrCDA5fcM DGcjOKcd0Ype9YvSws7xs77AAVnO0uIl9xWA1xfrBJ/ZkUTTw3B2tM5AVVPUL3+ldVN2kl5hVSsf dHwKsb1LW2ubS8mnupoAmoRKNkYJVXKge5OOg4GMd6/bT/gn5pqXHxf0a5N0oXU5f7I1GLfg2Dxe U8WFHOMy5J9+K/sTA0vZ+CtaK/kT/FP9D+dMLV9p4qRb6SkvwaP/0P7CItRh07wFDelCIIfDoS2a MHClYe4PYnua/im/4KZazPN8ddSkv7m1uTd3DrYWOxYxbJsbBUjqRn86/bfo7UubiKtU7Rf5o+I8 Z6vLllKD6y/Q/Fj44TTweHNTkk0mO9SazNvFPcZhglC5d4UYfKXyVPOf1r8i/GdxbLcRWkAaLdl1 tiMeSjdMjp7Y9q+h8fZ3x2Fh2Uv0PH8LI2wlWXmv1Obsbm4tlZI1banzowzkH/Ct7R7dzJLNI0bp OpLQcEsc5/Cv5tekEfqNRfvTUj3PK2FwIvupnG010Ol2tzdo8Imt4njQySNLIIlPPHWvLr7GsVZI /9H+Mby2mtpLKWVk68ocbiPeu++G0n9nXTpDFaSafMd0okJlkeUbl3nORxnr7Yr5Oo7I7KfY95nu zKkMUDxo6KGCw4RgB0ziqMIu10zUIb21iW41DdHaXZY7YtrY3Z9T3rhl8LNCVLuygmt9Kv0lnuWt lZL2D/UhsY9OoI5HH1rPnvruwvvsl3Cp0ye3IjunJUiTdgKB9PWuWpojdO+xvxaLbiGQpuid4xIo jAO4kAgk9uDWtaXN1PYXNks8Ns0f7u4gkH/HzEcjI9z6dsfjVQ+FBT1qXP/S/jivbq6ivrKC0RcX EhSYSqRgEfKRjpz3rnk1XW7yeaG5gksrcsba32w5YhGPI4/iOa8SL1aOFP3C9/x73VrJERLPLnah GG+UdQBW295rV9aefDIllCMoyo2N4XGSwNTPcE7JjbfUnklt7S9vnuIZmEMQkG/ySM9D6V0tjPo8 d0st0zTJEhghAbZsIOBg4I5NTFaouD0sPupwsjmDiMufNy2H2ntXQaTqZFjKunebOgkxNGOWhxx6 Zx/jW9lsbc7P/9P+Ry+nvJXnuJU/cwIPsyHLOv8Aez+J6Cua1H7Xq6LFcSLJYxSKWhYbQu35gT6k Ed68+HQyj8Z5lrhsdMnulmUXxZ9wRv8AVRKemR1/CuN0yW0t9QMqlraFmBjij+6R3GfSvQou0WyL Xqn6O/syajpOoLpl9DPKg+1vp+IUWJyqFI5FUHoSCeSOma/Vn9mq4fTPjF4O1Ozsr2Y2+tpZnVFl XyFhkkTerJzhumDjHWv7i8M7VfDdp9Iy/U/nHipuj4oYdr+aJ/f5+zmguPhj4VWS7e5d9Kgc3Abe JR5KKM++5XzmvwK/4LO6Zaf23Y6jd6dEyt4iswZ53ZDbRbHtiMg8ZcZH+7X85+HslS8UoJLer/7c ftHjZBy4Ocl2X5H/1Pyy8TyaRql/ctpX2mG8ktfKi3od0zAtgIGAyCeM47158sWoyI4MkTxofK3Z C4Zeq4Hcd6/16w7apo/zTrP3x8dyLSUQNJwAGnAGSSBnj861rtATFOkbfvEDoCvIGOp9K2OeEndj lvot8EUqPMsriF1iBby/diORjvU19p1kL2xtIzHvu42kaSWdTCAvJBPrgHApVW3TaZ6GHdq9L1X5 n9aH/BE/WNCXwJbRWai4ttLdPIuDlmczSOwB9CpkbJ9RX7C/tZQ3Fx8LPEdzaw+ZJYWP2yOMfMGd JFKnb3wCa/zP8RYOj4m1ub/n4n+J/pJhve8PKCX/AD4f5M//1eb/AGX7pdB/bE1O2XSys914yuo4 tQdnEsOZG3W+0fKA7u5GecIo57f3CeBfIu/Atk1spKjSsytGcFWdBkg/8Cr9v8a4R+tZfVg9HTj+ SPH8M6jfDM1JaqUvzZ+KHiG/itP2yr9rhLyEC/WwgVoyqu0yRsoAxk5bdzX7d6vcJfeFVlRD5kun RxrkFChdAmR9Af0r854mgo4bBS/ur8kfWZLU58trrtOR/Gr+3x8fvjp4C+Ll1oej+N7rQtGlvrlI bqGVPOgETtH5RVhgk7cj/f8ApXxC37THx6d9P06D4t6412sXmKrmINMW5weO2D69K/qvgzgrIsfw thMbiKac5Ru3r/mfzFxTxNm+HzSpRw1Syi7bLyLeq/tG/tI3scFrJ8Q9Yu7F4JopGYfbFt4ox+9V HxgBvmG39K8Fur658R6s2v3VzcahNYwSywXsCPMYyeZCVAIByeRX3eU8PZRlbnVwCSk9GfG5zmGP zKdOeMfM18u3+R//1vIv2Tf2p/Gv7P3ja21aXxVrMvha+hijv9OuIZ7i0tvKYMkgQYKHI52DP5DH 9PXwx/4K0/s4/FODQdM8Qf8ACJNqs1pHa3EV9FcQL5pwrZ81NgHHcg1/VXiv4fVcyxcc6yhe9b3r d9dbLv8A53Px3wv4zo4fDf2Fmct37t77OyS+8+0PH/we+GPx+8AzR6No2jQ2+q6aEtrnTolNoHIJ XehJBxu6/TFfx4/t1/sReNv2W/Ed9d3kerX3hm/vHjmW7ULa2EEsgEUtuyA8BeSDgHJ6dvC8FuJc VlPETyHMJPlqOyT/AJlt8/0uHjFwvh45Z/bOCp2lHSVuz2v/AF2Pzf1G0dZf+JFdW95AbVXLKxUp u6qT6jPpV6MJol7osOrG6htWvbZ47m1QXTQkyLt3DPcnH41/ZOITeCk1ufzZkslF029uY/uF/wCC Vly8vwI0SeG43RgJbtEV2q0bxBkwPUYGQO+a6f8A4KU6csvwX1mKMy3Fw0ohRIVzkyQurZHcYkGf pX+duYprxPd9/bL80f3LxQ4vgSc1t7H9D//X/NG8tbyDVbyHS7zUPsVrLdI5vFNpdKN7Bcc4IA55 6ZxX9of/AASQvJpPhHpdrKI5JEtbVEMbbjKjQKoLe4WJT71/anj3Pm4Lp37x/Q/E/ACklmuK/wAH 6v8AyPrH9vnTotT+C3iPTbr5oriwMMMm07onKyIVB7Z3rzX8wH/BOOGbTvjPbrJaWEcCzGKC4Y7d Tnia634x/dPlgfjX5H4aSkuAs2j0dvyPtc2gpeKmBtvy/qz+0HRo5pfDBiidZGi0sQ2rOMKuE+UH 6V/GL/wVcs7Vf2gb67v1niNrcXsEKxAujzeZAxUHvknOPTFcHgTdcc6fyy/M8vx5dshoL/p4vyZ4 J+wJrV+P2jvDllBLHbLaxrNHbpGd0rzSCNt7dOAAf+A1/dR4Gt7mDwLYxSRRSyxWRRth3xswQDP6 frX0f0jVy57h0/5T6Pwm14GbX87/ACP/0PsX/gsPYafZ/FzSpVt993bXctwoSPbFHvjQ4kPfO2PH +6a/Wv8A4JR315efCzTLaWYNNLZWisBOJFUNDvkCnqQrBh7Yr+gM9u/B/CTlvdH57wDNPjHNaUdu Z3+9n1V+3kgtvhHc3bFf9F1G0LbyChVpCrZHpjr9aqfsFwae/wAMYCun6eZIJGgBCqTBDllTA7Z8 sn8a/JqVaVPg+oo9an6I++wsebiatd6+yX/pR88/8FRkvbP4P+LZ7K5OmGPw3fPa3VnOYHiaGJ7h drA53YXtzX5Sf8EiviJ4r1fxtqGlar4k1DVdNTVIlgkvZzLcI7xb2UZOdvy45zkmv0vhLBUsT4dY 3EVI3cdj4uniZLxNp4WMnZw1XyR/Uz4yt7i88HT228m9ns3tjLGo3pmFjnHSv4SP+CjtrpOn/tA6 tClxes66ZFZrfwKEgmY3AwHxnn51Qfj616v0c3L/AFpqpfyv9T4z6QXLDAYXm/ml+h//0fzf0O0t YtRZo3UysMP9pO6NlyMrs6YYZFf2o/8ABJ68W7+F1uFe3ji+yW/2WyjVQkSIi4Ax6Advev7q+kOm +D4P+8v0PwP6Okb43FxXSP8AmfXH7d2kS6t8GNcW22+ZboksKxgBizbsn8No+ma/ht8S/D3xJrvi bVl0TwpqlxeQ61cWFtFBYyXP2Pe5kYyuoPGSW9snsefgPo64uhg8Li515qMbrVuxXjHl+Ix2fUfq 0HJqFrJXe7eyOo+HPh/UfBHxV8CR+JNKvre4s9VjnllurGRPL3EfOjMB8pZQD/8AWr+679lO7gv/ AIQ+GHEpmlj0mJp3XhY2dQApHqMHNL6RNWjicHg8TQknBt2a1PsfBenUoZZi8NUTUk1dNeR+Tf8A wWfu7vw38PNSvtP1O7guxp8dwq7zFHmKfYIww/vZT3/Kv5WNB+IXj/WNFh08a9rsBumZ2DXbR2UE jEj5V+8ew69a+q8Ccoy/G8HOvi6Kk1Nq7Vz8P8Us6x2E46xODwtRxTjHRPS/LH/P+rH/0vmDwn4T +MGr2c+o21x471CaGR0jv9Nu5DvCDAPykEjPTg9q5bxj4Y+I+l28l/rllqdtJLbSNfLrkpNzKgG8 GUSDIU7TjacfpX+oOX1eGcLmKw2GUY1trLf03ufwHm1PPv7JdfG8zpN9dvU8Iubqe3MF5PbMILuH YquCpiYYOUz19M1hXN/FeuluysZCdzrg4GDwQa/UaR+dWtFM6eGK0Y20H2prZ0CzLOeJEI6fMB2N TLd+ZdLNPM90wzbyapCjfZnKAAgse+D1rWwqf8SzPpb9njXZl+I3gddG1WFGGvxmLzLbc13LHglA xGQMDqOPev75/wBn1mvvhL4UkZbeXzdLieTao3iRowzo/HY8YNfxX9KVqFbCNbuK/Nn9sfRunOXD ONgulT8LI//T/an/AILJ2NzpPhW01CC8uLF7WW0lW6hk2jc0kkZGzOTwpX8BTf8Agjj411vXtEk0 6+1i51S7ttSkaOe5closlYxHg9e59s+lfteJwcKnhvHHRWqqNX8mv+Aj4rKMTbjmvhW94p29Ln7m fG20S9+G/iuO4G5LfQrqcDhTvjiLD/0Ej8a/z5f2oPDenaZ8bPiFaR/ad9nrss9xbRZlto1uI4pA zNjg4AAHuePT9S+jNiOTE4uHkmfi/wBIzDuU8JL1R5/4QuNOt7S0m0yMQm6jMptruQNM3Ys3p2wO owK/Sn9g7XBYfHLw1PZzzJDcvJDqFmjFIi2IsSYI+bqy5HHWv6/43fPwXjV/07f5H8ueG0FDxBwU mv8Al4j+1/wfLDN4P09hEShsBKi87mHlg7f5/nX8tH/BWux1vTPH1vcWWs31rH/wkrGXTraUwxND LHy2Qcll8vbx0B+lfwL4CqnPxNp0aivFuSt01v0P7T+kVKcODHUpu0k077H/1PmmbV9Qa8eHWfFO tyuzh9PSTV53a1VeFGCxA9jirp8S6zDEXsfE2svNACIzHqjPtB7Yyfev9p48OZTJK+Hh/wCAx/yP 8fqmf5jCTSxE/wDwKX+Zxk2s65q2oy3Nz4l163VYSHi/ticwFlU4Ozd1J/DmksvG+v6fCZ4/FOum WSzNqsY1J3e3XoTETypPHSul8NZRb/d4f+Ax/wAjjjxDmidvrE//AAJ/5kf/AAmfiOe4Uaz4i8SX MD25gsornUHaOAnqexJPqSe3FaVx4p1ay0+xNhrWrzyoTNNEuoSsbdVJG4xklc9wQKa4ayfZ4eH/ AICv8jGfEWaq7WIn/wCBS/zKT+Ldee+tJrHxHrFioYSzBbs7rg9ywYkZ/pW1qvinxJcW0scOtakk 0kJja+WRY2j3EEnCqM4x0/8Ar0f6s5N/0Dw/8ARg+JM3/wCgif8A4Ez/1fj658Ra7bSW96dW1Eyv HFZreW93MksgwE3Fd2Mn1IJ6VqXfibxJdQ7rvxf4luZbKLZbxSalJvt8fddT2x7+lf7Y/wCrOTf9 A8P/AABH+M3+smbf8/53/wAT/wAyta+OfEk9zOx1e9S5uIUgW8SUrdRupH73f13HHPStVfGHiO3u LSTUNc1a9uUk8z7XNqDu8pXABcE88cdqFwzk19cPD/wBf5CfEmapaV5/+BP/ADKN14i1ubVRer4l 1uzkkkGxotXntwg7hdrAgH0H5VDd6rrup3D51nUbZFbMkrahc3HnDjIyZN2T3ya2/wBWMn6YaH/g Ef8AIS4kzRrXET/8Cf8AmX4PEdxYQeZa6lqMd1bvlX+1yOshzwWBJBxjIzWG3jzxAZhLc+Jdfa5F y268TUZluJDI2Fx82FxkY24AxR/qzk60+rQ/8Bj/AJA+Iczau8RP/wACf+Z//9b5fPiXVLCU2Uuv azBceWZZNQXWpTcai8neQZwSAeveq954x8SLHFBbeNPE0MhOxpbbVT5rKOidOB6gV/twuGcmX/MN T/8AAV/kf4vPiHM3/wAxE/8AwJ/5ma3jbxlG7QT+KPEtyXUGOd9VlURY7gAj8unqK0NP8ReI2luZ 5PF2srJc24CytqUokhKnJw27GDgcVouGcne+Gh/4BH/IX+sGZ7fWJ/8AgUjabxd4mSyuJ08V6xLJ gTrLJftKJCMd88D8a52z8UaxqMF8t1f39xvJkXbezR/OTkknfj36dqf+rGT/APQND/wGP+RlLiDN F/zET/8AApf5klp8SPHOlothN4t1p7WOTdbwRypGqgj5lMgXe34k1abx/wCLWeb7Lr2t/argAh0u 2kZVU5249Kf+q+TP/mHh/wCAR/yIXEWbJ/7xP/wKX+Z//9f5a1vx14n1XFq/irW47hIlWWJLt4gv y52nGFOKybjxL4znj0+I+MPEupC2nCyfa9WYpbLjaNigDjjnn069a/29nwrks1Z4aHyil+h/inHi XOIa/WZ/+BN/qXrv4h+OtN+T/hJbuWBP9TBPI7RQEjHy7WAOMZHbPrWbP428TzQymXxf4oVZzvkW 3v8AyreYcHbgLlQDngE9qj/U3JOuGj9wPi3Ob2WIl95sWfi7XFsYbiLxF4qgjilzLA2uSTyS7cf6 tu34g0ut/Ezxfdww+Z4s8QS3kEW21lfURKtvxwcFc7h7EU/9Tcj64eP3f8EtcXZwn/vEjKg8ZeLp UtY28WeLZLi5ZUnuYNQ8ouSfnZ/lI24B4A9K2T8RPFs4dpfHfi+yaSL7O0FnqAtdOiVMKNke0gEj r681a4MyT/oGj/XzNVxdm7/5iGf/0Pk+/wDiD4gQSC18a+KrhJ0WJ5BrReJVXHy7CDz1pT4r8RXV 0s9j4n8Rx7Y1DNNqbtMrY+/xj8uRxX+4MeC8kbt9Wj9x/ixPi/NumIZFqvxJ8VWlxBZf8Jl4jvmj Kma0F7lY1HO6U4/Lmh/H/i66QXUfjjxZaTxKYSlnqpjUqfu54PI9c1pHg3I4/wDMNH7gjxZm3XES +8qr8UfGkRtvtPijxRem2LfNc60zvJu7k7fX1zVjRviR43t2vnXxVqyLdSGWQtcl5CCOhOeMegwK 2XB+SR1WGj9xnLinNZO31iVvUgn8e+NJbyz062+I/iW7sreEz3WNW2orSdI1IUMCOc5Pf25uzfEX xNB9jRPGfioJbTmRf+JzMRKcd8YOO/X86JcH5E1zfVo39BLivN46LESt6n//0fkWH4j+PpboXEPi /wATcSEwzDUnwg7LznP41oL8RviCt1G03izXXLbiWlnVucZ34K447V/ucuCsiTv9Vj9yP8TlxbnL X+8y+9le/wDiT4yuLmxudV8V+ItVg087YYherBIgPB2lVGD6ewqLUviN4wOoJcWHjfxppMRhzNZW /iORy+M4weNucYJ7c4p/6lZAnzPCw+5A+LM72WJnb1ZUh+JHj17NiPHXjFQ0xmaOHxHc29zHkY+a UNuY+5J5FR6R8SviXZtdP/wsvxh5cieXZwz6u05jckDLs+S3GcdOaHwRw9LfCw+5Iz/1tzyGixM/ vZp2fxH+If2qUt488YSzrgsZ9ZkMIJ+9hfcZ+mau3njbxhGsZi8d+LFt4pVeNYtakWKJycbsdep5 pw4E4dvdYWPzRhLjDPXo8TL7z//S+TZ/iV48guZrdvG3jO4EkhuZLm1102vl7Rn5ZApIHXgdfXis U/FH4iXLTsvxD8dxrK+2czeJZ7gXYByrHceSPX2r/dKXAfDsnf6rE/xCXGGew0jiZGpD8WPiVAsR T4i+M5rePO+K41p7kSdiCWBPtVfTfir40me7GteOfGUsbMxs0t9XNq6Jn5UO0YY9eT2xUrgLhzlv 9Vj+P+ZcOM8+k2niZf18ja/4WP43RN8fxE8Z2YbDQTPrALouPukbB1P4iss/FH4lJ5ry/EDxPLM2 RBdyaiZXTPqDkH8ar/UPhy+uFj93/BJqcZ5/BcqxMvv/AOAV7T4k/EqK1eQfEHxZDumbznGqCOK4 ZhhDsA6jHqc8fjau/iZ4/ukgb/hY/jSG6jt1inMOsS28FwcnHyKcc+9argHh1r/dYfd/wTP/AF24 gSssVL7/APgH/9P5Gb4q/EV/Me88b+I7iaPiwb7eYWtDxyCozz3FWp/jF8Uppmlt/Gt9GpjVZbeO 4kYlupYru6nHWv8Adj/UHhvrhI/18z/Dypx1xHe31mX3/wDAK8vxo+LsrXQvfiLr8HmhUsxbzeVH alcZwpzndjByasJ8afioLmxuR8RfEomtlKSmG8W1ik7cRKuwH1ODyKX+oPDe31SP4guOOI5O/wBZ l/XyIo/jD8V2M7X3xG8U3DSRmNJVvhAy89SVGeB6EUy2+MPxgS4ItPib4odFXZCt3qEl3DH7lCcH 1pPgDhp6PCR+5/5m0eOuIktcVL7xut/Fb4rvdzCP4j+KkaVI5XmtNQNvbTuBhsRjkLwML/OtO2+M PxHW2mI8f+KEneJY1NtdLbscDrvA3bj/AHuuah8BcN/9Asfx/wAxrjniO/8AvUvw/wAj/9T5o8M/ Fz4jqI7ybx14rkmIYNFqeqtdtA2fvbnByRj8fao9V+LPj69udsnjrxXCvm+aRFrMqh3zzyCAo9AB xX+5/wDxD/hm/wDukfuf+Z/iV/rxxFr/ALXP+vkZY+MfxlsJZZ4/iZ4oXTJJgggTVJpbgAnpvZjt z24rPufi58T2fzD8Q/GjMcmPOtOhTI6kgDP6VpHw+4Zb/wB0j+P+Yf69cRrfFy/D/IsyfGr4kzWk aP8AETxo9xMwiukvNbe9VlXoEDAlOc5wfqK2/wDhefxIW4s5LLxj4jtwIPsl8P7WcQyrjAKoAADn nOe1af8AEPeGP+gSP4/5kvjviJL/AHqX4f5FT/hc/wAQbZlhuPGHiSW3jZ5oDb6nJayPKcjLsCcj GePYVmWXxr+J1vbyQP8AEHxdLLFvW0nbVX/dB+QGDbi+Pc4+lWvDvhn/AKBI/j/mZf698Rf9BUv6 +R//1flE/GT4tSRCSD4m+MxKyhHWTVi0JGMMVjAAHt6Vi/8AC1PilGtrBcfEjxZJFbSNLGv9ptFI zN1+dSGI9iTX+7a8O+GVthIfj/mf4hPjniNrXFS/D/IevxY+KoIltfif4uQKSybtSM5BHQEtkkcd 81Ivxs+LzW0o1D4i+JGu5ZQFe3vmhQICMgIPlGcZxjmn/wAQ84Ze+Ehf5/5mD454hvpipfh/kaMP xx+KEaNJb/ETxQmZFL4vg6Bl7hcYXpyBUj/HH4r29td3Nt498RLePJuMz6l5kbg9SEYHb3+7xR/x Dzhjb6nD8f8AMj/XfiHf61IyrX41/F2K7Oov8S/F73OPmjuNTM9ng9QsLDaB9AD3p83xi+Ja3bXs fxI8Uww3jgiKz1DbllAzglTik/D7hhPXCQ+5/wCZf+ufEFtMTI//1vkCH40/FeD7QP8AhYviuWOe PZN9o1SSSSTBz98EEcccelbUPxg+J3iKOSFfHeuiRbcoGOqSxsdowuWDZODzg/jmv93v+IfcM3u8 JH8f8z/D1ca8QWs8VL+vkZdt8XfigxFpb/EXxpZ3lpEIXddVlMBOOSBwOefpiq8/xc+LourX+0Pi X4ylMLCSORtSKk449Oh/GheH3DH/AECR/H/MtcbcQX/3qX9fI6V/jV8TFRPL+Ifi8qEzEX1g3Qiy MNhWGF6e/FcrL8avivFIpk+JPin7OpyYhdJEvOR0C47+n40n4e8Mf9Akfx/zNI8b8Q7fWpW+X+Qn /C2fijbXa3h+KXifULm6tzGYodVuIDYAj5cLxHuH+yD0PNXk+OvxdSBIR8SfFjPCojQzXomQc8kh lOTjjrR/xDzhjrhI/j/mL/XjiJOyxUvw/wAj/9f5gk+NPxBvRbW1v478bIZFHmGPWo4NzY+csViB AJyeDx+tZLfGr4uW1xLEvxM8Ry7HEbbbobyq9I2f7345zX+7v/EPOGP+gSP4/wCZ/iR/r1xGlpiZ fh/kNt/jr8WIpWhb4keKopLgGWcwXwufJK/dVTKGwDnGR6dO1VV+OfxmWVml+JXiiXeMbTdBIE+i LjBPrR/xDzhm/wDukfx/zEuOuI0v95l+H+Rcf49/Ek7lufiN4w0dyoUSJrUmyQr/ABcDPOeg/WqV 38ePizdyKkfxU8WbVO6NDLGcrgAsWK5OfQnij/iHnDD0lhI/j/mZrj3iSL0xMvw/yJn+M/xYlhNu fiD4n8pkBFzFqHkTKw9dgGQeOCe1Tn49/FhIrVG+IPisTWmIg1tfhvtIyAGk3KeeME0v+IdcLbfV I/j/APJGq4/4j64mV/l/kf/Q+WYPj98XzJF9o+IHiURQ3HmhV1EKZUxgo2VK8+oXNZOu/G7xtC0d 3p3j/wAf2VxMuLqG11gRwwY75KktnngYHtX+7y8POF47YSP4/wCZ/iJPjziN/wDMTL8P8ippnxl+ LU6pHD8TfF7+RC0plutWWZDuYHcDICc5IA56dBRqnxn+Lk0UdrN8TvFc3l3KzSMmqEI2BjYQvyke oIql4d8MPX6pH8f8xf698R7fWpfh/kVLz40/F4uq2nxF8S2ygjyktp1SKM5BORjJzVuL42/Gbzp5 rn4keJmjRNkMDXyqhz6nBPHtVx8POGFosJH8f8xf67cRSX+8y/D/ACKk/wAbvjFPdxCf4neL4rJc ZtbLURbufYSFWOPZgavQ/Fn4uzxTJa/EfxjNaiL/AEtJNRDFjknJdVUqPb261f8AxD3hi1vqkfx/ zF/rrxEv+YmX4f5H/9H4sX4ofElrZLeTx/4qgSFmd4xqrTW8hY9lYEjv1J/Cm3Xxg+KEtxaWzfE3 xrcyoxeIJqrxQ2qqMBSoABOP4jmv95/+IfcM/wDQJH7n/mf4hPjXiJb4qX3r/ItzfGX4gS2+1PH/ AIrg1KE7oriLVWWNmHBLqMbvoxP6VlyfFn4q3hluLn4o+J490aRvJ9udV+TjhQcD3o/4h7wx/wBA kfx/zI/114hb/wB6l9//AAC9c/Gn4qS/Z1tviP4sjS22K0qamzzTGMY5yNuD16HtVWT42fGGK4+0 WPxE1+CYTGUzSXBmk5GNuD8uP+A0v+Ie8MX/AN0j+P8AmWuNOIUrfW5fh/kLL8afixf7Y7r4h+L4 7qSLE13D4gnBlZSSu1ScIOuQuAa0bb4m/GW1tXu7n4leJo7d4/3YGq753f7oZQwJ/lS/4h9ww9Pq kfx/zFLjbiNf8xUvw/yP/9L4cf4s/EprXYPH3icXxlJnnnuUkIUY27SAGBzkk7qvJ8avi00S2kvx L8VGHYC9yL79+23ouSOn+HU1/vR/xD3hf/oEj+P+Z/h4+NeIv+gqX4f5ErfGb4sfZxaj4k+LY1V9 wnh1Jo7hgSfvkdcfh0qO8+LXxWmZFtvin4wkit7fy13X4LMxGSz/ACjJBJ6jOMc96f8AxD3hf/oE h+P+Yv8AXbiNbYqX4f5FSH4vfF65M73vxN8WXRW0NuqLqj28cTf3hGhCkj/aGant/i38Wbey2L8Q fFCyycXFwmrSLcMoBAA7f/qo/wCIfcMLbCw/H/Ml8ccRN64qX4f5Cp8WPigbSOH/AIWP4yECoQ6f 2p+8kJJJ3NtyRz0OatXHxt+Jd5BHYL458WwQWkkbwT2+uv5z7R8wcbQMg/yp/wCoHDP/AECx/H/M P9deIn/zEy+9f5H/0/ip/jH8Wr0XcUvxQ8XjzJMlYL7yPKTsqkDI+oIpdH+Kfj+2ab7R8R/G8heX /R/O1ya5RmYY+YHr0PXjFf70/wDEP+GP+gSP3f8ABP8ADh8ZcQvfEy+9f5F66+JXxLRHjPxN8U+U cGVre+8qFiO+1VGB0GOeRTj8X/ihLFGD478RGKJNsrjU3jnlOeCpB49KX/EP+GF/zCR+7/gk/wCu HEHTEy+8y9V+KXxJujbrD8RfG0MKDzJEk1+ae3ds/wBwtjjHpj2p0XxX+MSeasXxJ8Rt5gAJWYQg KBj+EDPHr6UPgDhnrhI/c/8AMylxlxCrpYmX3lA/En4iu3mTfELxlM0qfZ5gdemMUmBxhM4A4PHN aE/xS+K0lrDHa/EjxpCLVQqRtrkv2dj/AHig4P0PpR/qBwy9sJD7v+CR/rlxFHX61P7z/9T42k+L fxUaFzc/EHxhIbu1+yvJbaqbaNGAHz4A46dAR161mH4j/EefywPiZ45ZYFwx/wCEjuGVWH8QBbA9 OK/3k/1C4ZW2Eh9z/wAz/C3/AF24jb1xUvvNaH4r/FWCwltofiV4t2NN5xl/tEmZcDB+Y5PP9arv 8WvjBJcQz2fxE18rGPKjtpr4iJFIwzbx824nnNP/AFC4Z64WP4/5l/68cRf9BUv6+RrS/Efx5OYl 1D4ieL4hs8mRLnWGuURj02lhng9x/wDrpv8AGv4rQZsh8RPEU0domyyMlxgxKepOACxwMZPIofAX DVtcJH8f8yXxvxFssVL8P8jC/wCE++JEpSZPir4vuXkk3tHLqs0iJyDtIY+3atG7+JvxBMdxBH8Q vGaS3KCO5kfXpJIdowcKp6d+/eqXAvDa/wCYWH3f8En/AFz4ge+Ln95//9X4ai+Ifj8JHLb+NPF1 rcQuYftkfiK5jnlAGC20Ptz06ACnt8R/iQzfZk+IPjEW8S+a1zL4guJJZHJ5ABPpnNf70rgPhy9n hIfd/wAE/wALv9cc/tpip/eaUHxL+IVlsceOvEd3GMtGsmoOdg6bTg/jRYfFLx/5wnbxx4vgMc5k Z7fVWhdeflILK2ADjkDPvR/qJw1ezwkPuJXGOfRd1ipfeVrn4pfEy9lu55/iP4yM1w2QW124SMKu dqhEYKTzjJFIfip8RJbSC3n8YeIMwIyN9n1eeOSbJzuZySaS4D4a2WEhp5G0eNOIbf7zIyoPHnji UF77xt46lRJdiRv4nmlj2Zxsw2QRz39q2JfiD8RYoHWx8eeNIXG14Gk8QTBYQOgVFwAMVX+onDi/ 5hYmq424iX/MVL+vkf/W+JP+FrfE1YZ418beKYfNx/pMmqNcPvxy43ZI+mahuviP46u7c2t1498a vcqAFu38Qv5We+2NQByf72TggZ71/vT/AKh8OX/3WP3P/M/xAp8c8QL/AJipfh/kOX4l/Ee3jFtN 8QfGc29ArONYeB0cZywKYOPQEn6mtH/hYfi/bJdr4u8WrdCEQFzrjzIfc7wSc4J60v8AUXhtP/dY /wBfM1lx1n7jb61L+vkVbr4sePrgWsf/AAm/iy1MFt9mQWGsG0VvmyZH+U5ODjt9asRfFLx7JYz2 yfEjx59oxsZJvELmPnGGU4yOPftR/qNw2tFhY29P+CL/AF0z6S/3mX3/APAMkePPiGgub6Txx4vu njtykccuv3EyJnglUzgn61l2/wASPiOzr9o+IPjW3t5E2vaWviK4s4hnjlUYA/jVLgnh2O2Fh9xM uMM8lp9Zl95//9f4stPGeo2psRc+OvFltcSlkW7k1eV5HYZIBY5z259+9Zd9488eplrbx540ucS7 yx12WPcuedwGOMZ4r/e3/U/h+H/MJD/wFH+HU+Kc6k/95n/4E/8AMlg+IPxBdHnt/Gfi20tnk8vy 4NYlhSFsc7W65OM9e9Jp/wARvFsF2i3fjfxrdeUxVpLjxDczGIt/Eis20nnPSh8H8PVN8JDTtFL8 rGX+s+dQemJn85N/qy9L4/8AFzvIi/ETxtPx8iDXpIQhB+ViAP0FRxeO/HFzNKyeKPFUt0zfaWu3 1qR489DuUngdOnSmuDeH1r9Vh/4CiZcU53LT6zP/AMCZk3Hi34j21xcyf8LK8WypcvuuEttakNuw JztVSSF9OB0rYtfiB4/e0uYY/HPiqMToBJPJq7tNGqnO1CemcfWs6nBfD898JD5RS/IcOK88p6LE z+9/qf/Q+D5/H/xAuo5xF4+8UMkwWNluL0vICnAOSOvHP1qxZ/EHx61tNbS+LPEsxeJoSkuvXCo2 cYcbWDAjHTOPUGv95f8AUfh9f8wsPuP8N48Y570xM/vJ4fGviW3uZbk61r8tzJaCBLp9YlaW2ZcY ZWJJ7dD+dTXXxC8dtFbyP458XMSmyV49clj88DsRnH/66n/Unh7/AKBYfcNcX541/vMvvJIPHnjI 2YW48b+Mo0E2+FItbkVXAxmM5BB688elSP4u8Q6s0u/xP4iE7xKu261+4dRgjBCKyqCMemKzfBWQ N3+qw+40hxfna0+sy+8W98c+ITdz6Y/izXra6ggO660zVZ7R2ZVwMkMAeR+vSsyLxx40KRG78Y+I rx4ozCryai2QMnB3D5uPr9alcF5DF831WP3I3XF2dPR4qX3n/9H4mtfHHiaIsJPGviS9jmO64tpd cuXEAAI2YJABJ5yMnjrV+28Z669kkOneKfFulpPOcQW+t3Nu7lScBsnlTnp0ORX+8C4RyKK0wsP/ AAGP+R/iC+Js5bu8TP8A8CZz+qa/4qmuLm+m8Q+Jv7RaMhLmbVZZ1yOFPLfKBjoPfis8+JfF1zHF NceMvFNrdGBIp5rbxBcwxrtHIUbsBevHvUy4PyFu/wBUhf8AwxNo8S5u1/vM/wDwJkp8Ua/9nieD xT4pknSUu3/EzlSRyP8AlrnPU8+ldNpnjjV47JXfxb4pdmRjOX1WbdM2edy57enFJcI5Hf8A3Sn/ AOAR/wAglxJm9v8AeZ/+BSJZPGfiw20cUniq/ubNsosEE8sExXOR5jqwyexrJHifVFacnXNbRmQR pFHqk/kR4/ugtxT/ANUsjW2Ep/8AgEf8jm/1lzf/AKCJ/wDgT/zP/9L4Tk8Xa9fT+ZF4h8RxNaIE EEusTPby7QcMPm5PPXrzUd14s8X6jcwwal418SQ2UZ86KOPVZ1WNgpAGAc46Dj19q/3cfCWSdcLT /wDAI/5H+Ii4kzi2mIn/AOBP/Mm0/X9aW6jmvvEOuagGBEgvNZunDLyVVV34AyRx2q9e+J9X1GSa 3l8Qa8ImCmGIarNHHEq8YXDfzyaf+q2S/wDQNT/8Aj/kNcR5vfXET/8AA5f5ix6v4ghVhF4i1tYc b5GudYmnL4GCMFvaqsnibVIzK8ur61PM8axKw1efywo4zs346fnSfCuS20wtP/wCP+RouJM1W+Jq f+BS/wAyC6vb54be6GsaliBxJsOozNj6DdgVqxeMNS1AXK6hdS3atAIY0nZy647hwwOTjtik+GMo /wCgaH/gMf8AIr/WTNEtMRP/AMDl/mf/0/hux8R69ZwTvp/iDWbKQzk+XBfyeWFPQAMTxj+VSt4q 8Rws08viDVrm7eLyxNJeurovZeDj8welf7s/6r5O7f7ND/wFf5H+Jj4ozZbYmp/4E/8AMiTxPrM8 8ss2p3syOgMiT3cjDK9x8w6+g4qpYeK9UhnvEivtQhkkGS8d3MgQHOAPmxjrxR/qrlH/AEDQ/wDA UYy4ozZ3/wBon/4E/wCkaU/i3UPsBtxe3fmTEedI1y+5mHQ9aiXxbrjSQTS63rDMimOcJqMkccy4 wFK5xxnrjNL/AFZyhf8AMND/AMBX+RiuJc3tZ4if/gT/AMx8fiTUL29jMmqalHcW0G37bBqM0dwy Z4QkNz9MdqgfU9YiaeZtf1nzm4huGv3MyL6Zpy4Zyhu7w8P/AAFf5DXE+cxVliJ/+BP/ADP/1PiK LxBdQskl3Jd3cRTDZu5T5jdDIwLY3e4Arn31prm7+3r9rthb3KxxRm7kV3OcBmw3I+pPFf7srhvK k9KEP/AY/wCR/h3LibNutef/AIEzpP8AhJ9Rt5JNt1eyMjlnWS/mNlckjqE3YGPXAqm3ibWpoJV+ 1y2yXQzNbK++MY7gnkdOuaP9XcsTVqEP/AV/kYy4jzOzcq0//An/AJkcWpTXEO+7uJ71SoTy/tLq vB4OAwxiqM97fIbqJdU1GzspoliVE1GQIgznahLZUHpgY61r/YGV3/gQ/wDAY/5FrO8zcFJ1pf8A gT/zEgNzp1j5tveXFrB5zLPKt9NFckEZxvVwwBwO/Y+9WrO4l+wT29pf6rHDLJ50tt/aU3lTHg5P zEjp+NL+wcsW1CP/AICv8hxzvM5aOtL/AMCf+Z//1fhyw8mZXDanfW5usmWKC+nlDY+8T82Ov8q2 tVuLS3ssRmSQEDzbgyGGVgCNoIQjBzX+7/8AYeX/APPqP/gKP8OJZxj0/wCLL/wJnLT3bXl5Lc3F xKrTWywQiKRoUgVBgfKDg5x1NRT67ek/ZRJLkBUjitsxNOyn5c7cbvqfWn/YuXrT2Udf7qNoZvj9 P3sr/wCJlWzv5bi/nAa4iuFjdp1eWRYixB+Xbnbk4/DNM0+e8uIGUzXFxe7hBP8Aa2YLAitkpGuc LwSMqB1qf7Cy7/nzH/wFf5FTzrMdvbS/8CZtSPPbWxtoX8sPKsj+YTcYwQfvMSfUYBxzVi1uYJJ2 a+itZYnfMgjgWMY/DpjrxiqeSZe/+XUf/AUYrOsda7qy+9/5n//W+INQudKhlm/sfU5rZiFWa2in liDjOBgE4H0+tZ8iWssdxa3LB4tsd0lmm2Bw4xhtwG4jBOc1/u88mwKdlRj9y/yP8OFnGNf/AC9l 97LC3VmDDDDFKjzMHvJYk8pIxH93LA+/16/Wo77U01GdbESTTwWQ2p87seec7z8361nLKcH/AM+o /cjT+2sbHT2svvZJbywxxSL5LKkZLFk/1zZHI3Hn8OlGnJBbuklje6gJdrxyRXMnm2+1+oCnjkfT +tQ8pwSX8JfcP+2sa3/Fl950F5qTKkPlxw/IyrIwQB8L2BxwOO3rVbUdXkvmlt4HKTTIolumXzXi QH7qZ4HTHHqaz/svBwd40o/ci1nGNqKzqyt6s//X+JLG605rmO3iWOR5SxnlUNK3TDHPOB6gUv2+ 2055IrVI5rV5tjXQDNIxHUbuvBzwa/3ReV4KWsqUfuR/iRHOcdDSNWS+bJJNQtLm2muRpYnuUlEg XHnyMU+42zGD9KrWUdtdeZcvAUuL0B7iJozE6sCcfLxjt0x1qY5XhIfBTS9FYzqZvjKi9+pJ/Nss 6lqCCe3Z7VJprd9mCBG7dvmOMnHvV6PWtPaBU+zx5XIVNgOG6c+vI71ccvw6+yjKWZ17ayZnzNaX McQMMcU0Mm4SRQrE7fVgAe36mtDTJjYC7kG5UkgK+ZIonbJyeN3qe/vT+o0f5UR/aVeOrkz/0PjB 9XW8htftFpDM0UKwzSSwLFv2jG7YoAz1Ocd6o2lvaJqUlzZw2oYAMrm0QuvqQGBGR0ziv90vqVDn ty/gf4fLM63L8TL9xHLbxXN1cCG7vJitsssyBVKNuJyB0AxgAdKdJqQihhdrS1WKFPKlCwqWkQ9c NjI6U3gaFtkZPMat92a1nf6PHGlzYW1sLrcJG823QoQMbcIRjPrn8c1gyXUCXV3dGCHzrwHzkeBJ Fbk9FIwPwArJ4Gh2X3DjmFa+jZDbao1iheC3RYkfLKYRJjng+o/DFX9R8Q2bacoidmjvpC91FCWk iDL1LHpnI7+lQ8DQ7Gix9Xqz/9H41j12SGAfY4vOyg2RRRqvoM/T68VDfXkF2gZ/Lkv3UpPL9mUS Af3ScduB+Ff7l/UKHY/w8eYVr7k6Wlpqd3p7+VZBlAj1CK4iWKG5RQAmY9uwsCM8jnNa002iRWtn awXelNNHC0T2VnY+VeWmPlKvIqAZPGcE8k0vqFHt+BvDMKtrGAmoxWixobOGKUOR5r2ySud3A3gq cj1zVWa1t0ht5oVsQ8Ux2o0aibJBORx07H60fUKPRG8MwqdzutM1TKxS3i2/nGH7MT5Kvsj9FJHG e+Kxbsefeal9nk+xQW8BSxkhtUYSktgjkcZGSSKUcBR3aLePqvZn/9L5MtfsUqwwXEFndtDApZAI ysKDuR0Heqk95o18q+c9tCbeUxWmEK7Qp4G4DAUknjPrX+5f1DD9j/Ev67X7sxEubO0a+dbSJXkc RDKBoZAD95B06c8Vde1jtZrbVbSCyuJHgXa0tqjKMjO0gjtnGaTwGHtqhrH177mHqFppyXqM8cVw 0zLNsjJRInIBZRjA4JOexrpZBapDYwXKqsMqkWyMoZkwBwM8/hWH1DD9jojjq+zkUYb+yE8gvbbe ICDFGsYjkyOhHHHFbsL6ddxx/ZLC1hk375p1tUjm56fMBk980pYDD21R108bXVveP//T+YYtWSKR bd3hnESFV/0ZGaJccjOPTPXNYELad9qeOWKFUUE2hNqis2T8wBA96/25/s+hzbH+N8MdWVk5F1UQ RqLcIm1TGoRRuC9cVU0cLqF5PHLYrLLApAmihxJEV+7uI9OPyrkrYGj7N6Hp0MdVVaKuz+sL/gkb Ddt8N9Pnmje5S002KBZ2YhmeULJnHp878fSvuv8Abh1iTSPg9qTp5aQHbDceY2Azy4RQe3HHFf5e 59hYx8Z54aNmlXt/5Mf6b4HHTn4Qwxkrpuhfz2P4i/E2owz+JfFeqeYLmO/1mbU7pEJXHmnJYZzj d1B+lfAf7QuryPpd7NEosbYTq0k0i+bMgYHCgEYy3y4/H61/oHx3Hk4AxfN/z5f5M/hfwtk6niNh 5L+f9T//1Pp3/g3Sgt77TvE2oRxNZyaVcWEgiktiy3azrtLN6Hcmfxr+pb9qy+t9J+BXjqecED/h G7pepPlSPbOqYH1bHNfFZd7vEmMt/Ofe5jK+SYW/8p/BJB/wS2/aS/a18VeMvG/gnwvbiGXU7uGz 1WfSmkLhpA0qxykgYBKZ2hsE4PQ18CftE/sJ/tEfsvTWVr8UvA19Y20t3NBJqESefIVhcBJFVARh uuM5AxkAnFfV4pt1JW7Hz1Fq0T9s/wDg3n8N6jZ+PNWuvLSKObWGubhZ023MMbTQxoWB7nLAD2I9 a/tc+M0v2P4Z+KpBgxPodyilzjcnkuXzjtgE18rlsLZnUl5o+gx0+bL6ceyZ/nz+HLuDxJ/wUjTZ aLPZWXiS4Y2bqVikSbEajrwP36Y96/0BvgbZSaR8LvD9jNEYUg0vzd7v5hTOCAD7Z6VePipcRRm9 1B/mv8iMFO2TOHeS/J/5n//V/dD4g3Evij/goDb6VDNcSf2P9ltWkkG04jJkOCeq/v8Ab+lfuD4u nhtPB15NcTraxrpErLcMuAh8rOT+P86+brXeZwb7H2UJ8uBlFdz/ADRP+CpLtr37UfxCmWaD7AfM uY47jcYwXZdxUdM7QWI/2R6Gvm79mH9hr4oftSeIL+2+FngW117+x0jD3cyGKzvPNZVwW4G7cwxn JPPIFdWL96aSOCjPli7n0N+0L/wSD/aj+BnheTxn4m8BSnRbWEyziwg+23emSdVaSNc7oh0ySMEj rX5MeN9H1rQpfLukEFzbt8vmHaGUYBbA6HnpRGdqbicNRXqKRx0ctxFC0MipcrPj943zEZ64+tSb pI3ij2sEDhmRV71xVJJM1Tsmj//W/kruJriO8iQW7Mjy7R68+/Suq0y8u4rqwtbWNbi5uL1YZN54 SM/ewfXHSvl6rvSaPcpO00f2Mf8ABur4Rmt7bX7q7a9K2mofYxA6YQDzBImWPXl2x7ua/qm/avvD p3wC8fZVSH8KXjbpAQYXMO1WB7EbvzxXzGQUVRxmImvtSufXZ3iXWwmGp/ywsf5fX7VFzJL8ZvHN 7p121yuoX1xdNeFjNBPKZjhifUAgYz61806ZqV5DeFr2432/lYmEg2CPb3X0GM5r6zHP37s8bAP3 LH9Zf/BvDpU15dX+qJZSQW8WrpJdMts0oZXkWSMgcnDA9e/Nf1v/ALTl/b6Z8GPGU8kj26Hwxd3S zAlJo5EtnKYxyDk9K+XyCKjnFdrrJf1+CPqc5qN5XRi+kWf/1/wv/ah1Oa98d/EnVLR999deI5mt iT/pVxE0mAHJ5HViPyr+vb/ggh4XXT/hnYXGm2wihnht2nZ8yXat5SysJB0XJmb6bRXxnEzft6dv 5kfpOQyXsp37M/X/AP4KHahJD8BNYSVQFCFkbzNnmybSFDfXOAKs/wDBPzTZbf4GaVcMF/4mNpBf kggFd8SOEx/slnH4Cnm9pYXDxfdBgJctas15/ofjH/wcC+Jbu28FW+jWsqQieAw35B2yQwTskbbW 6nPzZHpmv5Lv2TLeHxR+0l4Eg0+1uZYNN8SQhrW/X7PC0E0wjkAJOcqoJUcdK9nPbPIoq/Q83KHb Nbruf6aX7NmnS6X8KNBs2jWH+zoYoIWQ74WBjQrk/wCzkr+Ar+Qr/g4m1J774paDDZagIbmx8uRm WTYI0LkSKinqBuXp3es+DGqeWSh5MfE3vY3m8z//0P5nrlpZ702qxN5EkbNJeCRQ6YHYH3x19a/u o/4IJ+H5bb4S6FLfSqJiplVlwk7eYkJKnHUbhIfbNfm/EsPa16Uf7x+o5LL2dGo/Jn6E/wDBVrxD beHv2ctYs5njWHUp0hmkdjkAseAB1x1/Cv8ANe+Jtyl74l1/U7qYNdx3bW13MUMUYVJHCuT0JORn 0xX32GlbLOVf1ofF4nXGXPI43tYbuV5jMS6DIBCgcELjNdV8Nvhd4z+K/iz/AIRrwnpcurXs0yBV X/WRiQHascaqWYnaegOOc142ImlSbl3R1YdXqWXZ/kfovN/wST/axtdBsfFUXw11t7C1tYbp5p9K uoppzMm5o1QRgNsBHzYHXrX5/eN/DGreENc1Tw7r/hy/0PXPD9/IuoJqkbWrjC7VIVhk9+cd+pqq ElLDtrzObF3U1F7o/9H+UzVLZ74wTwK1tcCNY8p8+JMn5yPQ5HFWJrKS3RDMyszpjco5LAc/TNfI NJs+gH7Gg8tpzlZ0yEY7gccc+nTvXMX9vK0bzGZLcEnyTG28qM4B/Sna0bgR6YZrWBLdpmeRmM3l yJj5WwQR3561v2pDy4dSqggs5PBrGUOwE92bZmIUbcdG/rWSfsosrq4beTasWZiN5Yf7OOcdKFTf UD//0v5QoLYT2/2rzwEVP3cWMsTWhYXlxBBIs6Rsg4iYH95nqQV7Y4xXyCTex9PfS5Ev76XesmSB 87n5WUntUjybv3CuJZBg5H3o/TmnFO5lD4ipEs8DSfvZFMjHzfm+WQdgaZY28ayPJJdfZBJcKjOU 3xxAsMt9K66UbyXqFZ2R+jHwU0xbGzlhCrIs0wuYrggxTMTGqqwH90gA8+gr9t/+CYmlR+IPjJeW UQE09lewyO8lsBLbyCNTJsPfKpGcnupr+xa6+r+C813gvxZ/N2SfvfFK/wDeZ//T/r38aS2tj8Ot We1dktrfSRHDG6BflRQGGPUhTn61/DP+3Lcvd/HjxEt1JY3cUNtLc6Yu/Nw5acL0P3QgGOOxHvX7 x9HGDea4ifl+p+deN9RQwVBeZ+NP7S13qD6FPoyzXVnbQubiZUmxbmQPGdy/3SF+U/Wvy78UiaW8 3ttCoABIq5eTA7n2rt8e6kf7Ww8OvK/xt/kc/hXrlk5+a/U5mzvHAcly3z4IIxuTvXoFnAk2nS6h E0VsLRYwsKPie53EglF7kd6/niaXIfp1R3qGvZbHuX8xG2+Tj5UzI/0qBEeLUGjit5VaZciZhhHU H7pPqK8mvoaw+FH/1P4zonWHyrmaINCj4eNwRv5xg45xmvV/hfEz3vm6rFYppVrOZ1toM/apo9wy pHYkH+dfJVdjrh8R7peaVoNtp19rOnXeyGECYiQjlGPAXvlfSuXAkWYWN+zTQzoLmKSEGSDDAcZH AI4yD6V58pNuxok+psWUenRyr5hSW8wY7MOQq7+oznoKuXmoz62HsLzQbC3ubWFnkubJzNb/AC8F sH+eBXPV2sbxVkVfD4aFGNwwSRcrHEcNEcHGefpUj3MJGpiKe1GsviG3tl+YITny2IHbv704a0zW lGzbP//V/kC+x2WoXTJYzM4jtwT9qIW6B749QTnjsKpvJNagW8UUrTq7L9oDDKHt/LHGa8Gm/eaP PtbQ4u51WKzl0b7Vf3n9ox3Lme0bTFj8mIdWE2evPAwOhrUlunu9MubW2uvsj3RVraeaHfJJvOQV X19c1cluRBq1hLu2GnxTXSwiZrZAshTl/QkCuh0GxttQ0238uMvCAZCJFKurMSRx1PXv0NKCNE+V 3N++8IX+mWtpd3EbRWd3loGlmHmTdecZzjp+lammXMWlIdsLFRFhkTnzWxyTW6S5Xc2TT0P/1v5K 9Tu7Z1EscYCum7yt2CT6Vw+owX39mzm2hQRzXMME168hR4NxJ+Qd+Ae2OOo7+fDoc60PIvHEA0uO e1WZr5luVdr6NQ5m4x85HGABj8K4e20+6kg+0xlS4TequxCe2T2r0KS9xlR/if15n3/+zD5+n6hp 2ZrKSK8jWNvIDEQPMBBIWyPvAsWGO3Pev1u/ZvuD4d+IOlo+oX1vBaPNNceTbi7tZneWIKBxkFSv y/71f274TP2nh3Ugtfdn+p/N3GLt4oYaX96H5n9/H7IF3FN8ItEsjc/aLgWFvcQkoVlWNolkC/m5 Hvivxl/4LdW0i+DhcziRtRk1C3nhhhVnFqv2q32t0zuUPISDxjNfzzwTFQ8W6MHp++/9uP2/xruu A6k0vsx/I//X/L7WL+3htW3wC9u4ofs9vdtDsmTJ+9kcjucd68wsJpZ557ZkUqXLGQttYHucV/rz h/4SP81MSkpMtTNYMyeVG73iJ9my5wDzneR61qoWtLGe7nWZVWIowUEkpjnaP0rc5oR7l/RNKsdO 05bixDyPqMDXDO2ZHi8wfMshPQkEDHpSR2EGsW9miW0NzcvdfZbWKGTZJuPynkfdHXPsKip8DPSo xXtKfqf1T/8ABHzwL408A+H9IGpaD9jheAvO0GDaTg5KNn2AUZ7kV+6Xx6s7jXfhp4ltrGxnubq9 0t4447cFpMlCCPTvX+ZPiVi6eJ8Qa2JpO8ebf5n+luXUOXgfCYbeXsUvnZn/0P2t/Y5/Yc8MWXj/ AMT+N/GYZtQv/EkupLLNYxgo5x5UaFvmVlK8nOOTgV+gP7Svxn0T9nr4WpPpGsJa34drS2s1uDF5 oZWAJAOSc4wvTH4V93muY5hxlnWGy5Lmtywj6JdPkvwMsPQwvCfDVWpe1lKT9W9PxZ/Pd8Gf2yX+ I37TNlrXji1g0+czRtDcQ3n2kTMsmz947EAk544B9ueP6stA8UaJ4z8EWmpaTOtxE+nqirGoAZgo K4wSMHjpXt+KfCmN4cp4FTT9nyr5baP7jn4Gz3C5tk1WVOSc23/w6P5X/wDgoX+yN8T/AB78bP7U 8OeD7/X9FF/e6k9pbJuijkLsqFHwV4HOCQfl6HnHg37MX7BvxG1/4j6b/wALF8CDTNBOoRRtcyRK 9+dr5IUHP3Qo5xgE56dP13hnj7CZbwLDCxn+9hB29T8qxnBtTMuJXVqL9053fax/RNL+wF+ynpvg G5jv9Kgsrm3tH867itYIruafbwC+Mtn9M/n+H/gn4G/s++Ev2kbzwle382oeF77xDt0qB7azt7MH zQ0yyOeG3IOno3BFfJcFcZcQ5hSx0Gm1a63/AMzs4w4eyjC5xgKEEkpNp/gv1uf/0f6bvF//AATy /Zi8d/DnyPDug6cs2oaW5sb2x0i0mj8zYccRAfKSOByee5r+cX4yf8E8Pjb4M+LLSfD3wfBceHWC JpxntfsanZhWUxog+cMpIJ556noP6K4E8Ra9HM8Rgs+k/ZtPd9fS5+U8TeHzozoY3KUuZNP5aeX9 dz9i/wDgn/4g/ag8Cix8AfEbwxJp/h2wGwXt0WebamQBl2JOFCKMYwBwPT9C/wBqHwB8Efif8OtQ g+KtvbT/AG62VES5eORjtyowHPY98Z4FfBZ9jVR4qWYZQveck1Y/TeIsFhMXwa6OMl/y69+/Rpb/ AK+p/Db+0H4K+Hvgn4qeJ/DHw11aLU/DUN/K1nfWsaR7lSeSMRyFOpQJgEYyMHoRXBeDvBPiH4he KLLwzotpf6t/aesQ6ZDLpCfaruCaJreVXddh2xknacHIwea/vXKcZVxHCtDMcf7snTUpX02Wr8r7 /M/hbCUlDHLC4f3vfsra9eh/al/wTW+HfjT4YfDiz0rxL9oaTCqkbwtCiJkHG0gYYbSCevP4V9M/ tlfDrWfiL8KNe0vQLea41H7HM0SQRmSZS8Tqvy9wTjPtX+eefZlRfH08ypv3FUT+SaP7txeAqYjg yGCl8Tpped2j/9L5E+LXwo8YfC7xNqGg+PtKvNMvYpSLQX8bQx3cLM+0M5A5JVgM8kL6giv6L/8A gkH+0n4F0/wppvhbWLzT9G1Gwkjs7tv7Vh8+RCpSPETNnClDu9Aw+tf2z4qRjxP4dUsflvvRaUvS 26fo/wCrH4V4PYuOScV4nL8W7NqUfnq1961P2i/aZ8I3HxT+GuueHNGD6hc3Gm+faSW6eas5chlI 2546H8/rX89f7On7E/xy+F/x0tfEuraBPbaGmrzRxX0tvJDAEeQvuT5eMdR+WO9fz9wNxHhcoyDG 5TitHVi7eux+uZjk1Wtxjhs6pvSDSfov+HP6f/Cpubfw3aQXEsrXiWQExlUY37MH6c+vSv5Ef+Cy WkafpHxLi1CSWX7XJr5hxgQW4eQhpDn3SEY9yK6vBKbp8ewUftNr5NnyXjrCMuH6cpdJX/Bnwx+x K8+hfGXQdZS8bZqOsw/a2jZTKICfLVFJ6c9x61/dx8J11CT4c6el28pkj05cyM+9WBiB3E465JNf afSTpxjnOHb7Hr+D8+bgW399/qf/0/0F/wCCz2maXZ+KdO1zUHQXltd6Zb31vaPs+3xyeZHKGbsQ sQP4198f8EkPEGmTeA9Lg0+2zbWmnxxWw2sWC7sLvb1K9/av6CzTmr+DVB20jK35WPzLgWccPx/m tJ/FLX87/iff/wC3FaWd78EvFlvPb75Y9NW/dlk5i2SbgB6kkAV8b/8ABN39pfwNe6ZqXw+1jVdL tvEVrqj6Td20V0olTymZIjJGTkfdIyM5IPQggfmeUZfVzLhHEwoRu4S5vkrH3TxcMNxeqUnbnhy/ PV/ofUX7aHwUv/jh8NNd8P6BHLcSTQSyW7woJcboWjPHcHjj3r8cv2Vf2ZfHP7I3iyw1/wAXaDqd tpOpah595eyWctvbW/lHKor7eVI3fMcHLYxX1PB2fYfD8LYnIqrtOo9PuPJxWVTwvFn+sKeijy/k f0I+G/iJ4d+KPhSO78NXsc0rx+VcLHKH8pgCjjjkdx7Gv5Tv+Con7FfxGsPHTfEC00PUJtKH767W 2tS4kiil+0CUNgj+Dn2OOOtej4MZvR4X40VHH6Kb5fvvr+Nz4/xsymrnnDkMxwr0p+999v8AI//U /PCC2sUf7a/2iIly6edE0E6EE8NGRuB46Gv6av8Agkr+138LdA0/TfhzrmpwaRqdnHCbEXcoFzfb xt8sjqMDJOcDHNf6IeNmRV854LqQwyvKHvW9D+XvAXiChlWczoV3/FXKvVXP3i+NXhyX4ofDzWdP 8NCO6bUrDbbN98HkOu3Gef8A4qvmT9mf9mvwn4B0HW5PG/gPQjdajdM95Je2fzybMjzGfAzlccjn jr2H8T5LndbKsnr5fRk41JNev9aH9M4nLsPXzOpiq8b2VtvX/M+GP+Cjn/DJ3hXRdKudMsvDFh46 trjCWUEqyS20IWQ7mX72NyAAqP4T6V9cf8E3v2qPhv8AEr4W6N4Zsdc0k6/YWqW2p6f9tC3sEwHy jYeWB+fB68V9vm+XZznPh3Tx+JTl7OV9uh8tw3mmX4HiXFZRSlrNaetolr/goR+y14l/af8ABGo6 L4dt55ZmtvNht45grSSRypIpKlSGyAwwCPvceo/ETS/+CM/xigvdMvNQl18aeblZr+Dytu6JcEII 1TOSeCxI+lfQeG3iVhuE+HJ5TO3M23969T4niXw2/t/i2WdVr8jsrLtGy108j//V/qv/AGXv2V/h x8J/Bwj8R/DzR57gWSrPcX9qwKRoo5dDz0B+u0cV+Zn/AAVSh/ZhvvCGoW/hfRtB07xc9hdaK406 /XT57NZLaQpL5YwT86gKg6lAD2r974PzvOc+8QKVfDzlJOeyfT+vv28j8W8ZcBlWV+H1ajSio1OV cumrfofylQXh8jT7bxDBJLFYW6RebkecduRnb0O4c5zzmq09zpqtLJbWRhguXJRmBDKOcAfp+Vf6 MUkfxK3pFFSSSMxs5iPmfZ/KhGSB9f51Z0+8msbW2hEDz2zzkOjrughz944+n9K1HFfvLHq/wp8d aV8NfG2heI5o5Z4o9RWCC2t4T5ForDDScDK8ZGevI+tf3E/sE/te/CP4sfDTRtJ0TxFYz679igF1 YF2guoJREoOVYDqQR2zjpX8qfSX4YxWZZPRzjDq6pvla9Nfxu/uP6y+jlxHhsF9ayCu7SqWlF990 1bystfNH/9b+nb/goZ+yN4t/ah8N2OnaG4bESTxlj5bwushcYAByCD09+3Wvk/8AZK+C/iX9hq9s m+IFrOmnHUSGuzaSxQyPMQud3I43A5yef0/Y8Pm8KvA0sgXxX5j4TCYCeG40qZzJ+61y/cftbc6r pfxb8BalJ4cuba7g1PTpbdgj72/eIRgjr1P6V/Hr/wAFBP2HPiN8Ofiv4h+I3lEaDrt2897EYJjb JHHDHucShdpCcYHXBPPXH2X0f82pZVxL/Z2IdnWbivXp970PgPHrLK2YZTDMaCuqWr9Hv+B+UltF bSzs9nDFcwsAbaVIg5hKsPnU9ulfev7EckumfHrwrc6jNd3a39pJZ2xgj86FHLofmPbPynJ9DX9z cYxcuEMZFf8APuX5H8i+HiUOOcE/+niP7jvAF00ng7TZXSREj09CiSL+9w8YcAj8cV/NL/wWdtFX UrPVpJTa2h1a2gubpXETx+ao2OO/JG0/Sv4C8CZcnitQX99/mf2R9I6NuA6j9PyP/9f4sgtXnVXu WeZmYr5zNncOw9qsWmmxaRM5+1SFJF5hY58v2r/cmC2P8XKytPXcp3djZXDySWthcT3VxdpOj+aQ VKgqWKZwcDBx/s1nWUMkV7IGBYxIXaRk2BCD0/z6Vuc70mWJ7qW4f7VJbCa3z5Ynz8obGRj+dWoo RPFthBimZCjSg4JU9vp7UJX0Rk9gU28RdSjukDBGmZMBjjnb9M1fF4zxywxMkqmHCAdU/H19qdtb GD3P/9D4ntnufOJCmdIkykbH7v0qTVLe4kit7nyPLadtjKnLkjH+Nf7o26H+IspJIxzbXFm5mDlV B3ZdcY6cYqeSE311by2t7NNH5CmaJl2pDJk5x6jofxrSMEtWZNt7ll9LRkvAZp5bi4KpaAHm1YY3 H36YAPAyfapZ1urS3E0hf5RsmIO4t6MQKsRb0mxh1DapuxhkJjDHHmMf4frVK6sEtp4jGySRlyu5 eSGB6H3q4RT3C9lqf//R+LZLSSe3mlkfcIuU/vE5H+NVrFvs10jTQhw/G48qgx1x+Ff7vKMUf4dS l2N+cW0+26TEUYQxs8vEZPOcD6YrjpYbmC2QztueWRjHJHxEygkcVRN2bVhtNo0DTcygjYe/FZH2 6TSkWKODzTNceXJMrfJEOwx3z/SqjG5nKdnYt3BuJNjxWc1zErqJjFHuAY+h+n41o6NdwxYvjbzx XEUzBw7A223+EDjOa0UUjFy1t1P/0vii4aG4N3eQyJ5iyMzAtt2EnoPXGazLGXUYhIDKotUBlZdm Xbdj+Lr26e9f70Wtsf4WSemhqajGJo4ZoEkS3bCeZcAZJxzVE3L3OyO62FlAjjEEKxKqrwMgDH41 ryIy0W5PPpqwpD5M1x58zHYq8qc9vwqK6sSbeFxgvG5SV9uCT1wapRS2Mm/euXrS9YQtbIWjKIcO g+72rGvWc27KTuYtgE8Y5wf60zSLuj//0/hUW0UvyRxxxKsACOzCNXZR1bnAz9e9VtLW7kvD80kb KMM4O6PAr/fOG5/hBOXU1pr2FYr63is3up3kEV1OyESEjHzD1GD1+tYtvF5SSRRuwjnYyYblsjPO evc1qJO2qInVlwkhBIPOOpqy0KBVMcrQ5A3Nt3Bh3GK0duVFRu5XIXWGIiVUWPzGO7aAHbHAJA7n Gas2K2+oXEsM7tH5MO+IKB85zjmna8Aekmf/1PgWzvkW5Fu7v5ayFj5aEhf6Z4Fb95dpKo8tt+0f fbiv9/3e2h/hFTkluYaXsO4xJtLJwwYcdP8A69VbybzJA0kYO0Bfl+XcvoSOfWk02rFOaudFpDaX cOvmW4srZNsbkuZBnpuOaz76HQxNdxR3RW3U+fbyfxO6EEADsCf6dK2hFWuZSqLqYNvdaost00SP ciQgwLEu6RieD+v861P7Rklla1mtzbiJF81MncZBkNn8Qat6Izck7H//1fgKaZMIzOGyxTYrc9O4 pgkthNHH5Mjlo2AEY+VSBgHj6jiv+geN2tT/AAXnJKRauBDGI1yVyuWyuNpPYj8aZClrOzRyriVP mV0PX2pR+AcJK5c+02ttbXLPay3coG1UA3eUDxuxkeuaw7m+VZ47UWyo0cPmEuWDsrHggfl+lURW kr2JJp/tlqtujDylkVyoHdTnOfb61NHfvZsYFjSa3uE4Z4wzKR79R+HpW8fhRif/1vgm2ndobhGh j3SsAZHXMihTwFPbOKzpIo4ndoiYp2xmQDnA7c1/0IH+BU9x6XETBzdBnfbiI8AZxjmqtr5Al8hv NcbWlUgZGQc8n8aBc3SxeupkVEj8ttj4UY529uabbXKWQkWKF7mWSJkjPQRZ/iP4fzoLp7WHDzX8 u4kcbwdvl8/L+H51aeaTzCkqCNgu0cbQBjj9KjkVyz//1/g3TNQ+zNsmh+0YZjuYhUII46en9Kfe azbagLqGxtzPPZyYuPIG5oOB8p/Mf5zX/QYoM/wT2gMgu41gVWjeKRR/pEVxg59OKrX93Fc20caR osiTb1mQlWI9D61ailsQm0rGfAdskwaIkmPKuy4APt/nvUhjkJ3J9wDJHQ1rCLvdiC6jmaJJMEqp wT6VUKknKtvGAQoXGPUGtAP/0Pz3jaC4KQTm4tMxGTei5L4OMAfXip7aW3eRrYliEGEd0IH596/6 GD/Ax8l9RNyRuQAD2K9PxqskDLdI06koPnAZflcdQP5UGbtfQabSK3gnEK/Jc3ZuCNxIjPoOagX9 3IYrhXkhddrLGwIPHAx09KBE7hCpXGCB8i+lQqFP7tgMj7p9KlpN3Kirn//R/POSDMMc0Ew2oSsk bpl3xxx6etP05orZ0khUxNnc4X5M+tf9DB/gZGNjQv7gxvcPZzssE5yFZQJV9s1g3dxdXEwmuJWY RxCJA3RQOn6YoLJIDNtZRLgsMbh1P4VNM9vEmbhUGFHzH5cH1NAbFOaMQSCWNGYzkA45A7A47CrE UQCSefJxuwuFGdxPyigTdj//0vz0gknsZt8ZG/BQkcrgjB59wahnmQyu0UEUAckuIk2rnjJ//XX/ AEMH+B10MEkcUe7eNxbb6sc8f1qeAgJK7IZZAcxooxgfjQMsTYu0jS9i8pkQPCWjzgZ6H3ptlbwy O0kEWYljZMTAI7HaeQD+f4U0ruyMnJ3KxW4A3bHiXeUG8ZBx/n9aquRbyKxIZyODj5TVezZcXdH/ 0/zrLiQZPHpUZtDdlPM5SMYHbdyev51/0PqKR/geV5y7XH2dEZGiAREVQhK4447/AFqN/Kt4w0rr vZ8rznkHv+VMCHzxISysG3n5ivGOcf5xWikVrchYZi5gkHOx9jfgaBptbC3MUcagqpaJPkVt3zk9 s0W2pX0EaQW8zWkZnE0mAN0wAIAJ9P8A69AN3P/U/PNRGDK0gZ1Zf3Tqdqk++f5e/Wo0gWczoWij e1GXR3CSNz0APU/4V/0QH+B5RugI5dpjSWFyHCwsGeMc53E8jHp1oiaLnhkRmwob/wDVQAr/ACsX X73YbQRj6VUaeK6UwiJ4Z7c73kz8swPTA9sGgCQFMIVyQRkNjbV2a4lLRLM52rGFjjzhVHsKAP/V /OIW4uJNkYPmBC3B+9ioEhZJDHJhQCeo/Sv+iA/wN5la5dRbdhLtkxLCANm0nd+PbjnmqMbPmdlJ +WQIF2/eHUn8KDItW8gUSfw7hg443YxUrO4Hy/exxkZB/CgRTAkClcHax5J5FSxS2kBERUea/wAx UHDY6f5+lA07H//W/OoQWyL5ody00mXiwMoOnX8KbFbyQh/IBaBeSSu4Kue57fWv+iJp3P8AArnZ FNdCGGRvJkmwCAFcAbu2SeKqQXM0ke4gorD5kPVfapE5N6F2GPEMgkhkmQkKj7sKnt7/AEqxFc+X JuZAEA+YHgYoJ2LzWjWhgmlWL7PeJ5sBgYOijuG54IOcg+1SttkjIXhR7UGMpN6H/9f87mAAMO/b GAWHfn/69U4LW5gkRrYLIs77JFLbjg8E49elf9DLVtGf8/5tLYS+U7CRxtGxok6j3NVj+6kCsCiI uEYHqaQD5Qb2F3eblcAKedwrJVL1rjcZImt1hMSR+XtcH1znnjP6VctkBNbK8bu20FF4Y+maLqOZ FiCRv5cj8HGSfofyqLdAP//Q/Oq3jO7kYA656CowZnu5kaNVt4wBHIvV+OTj+Vf9DyWrP8A9HG1x klvIBIsc7IHUsGxkg9sZq1bCaVbaOVjMyxbJJFADORwMj3z+lRyvmuQ15g3ltcrGIsYONxXhf0/l UF3GwlIicMsbnlVxuHTnv+daJWNo7IdFMzRtA65idw+CMFWXoc1J9p8p9pB44GelMZ//0fzeaV7m 5iQJui35c5wg9j9asfZVe6VERp2j/ebFHPygk4/AGv8AogP8DKa0Kb3Mzyu07Eh5CwBGzHt/P86i k847mSUjPG3vU8q5rllqHaqAgqZMfxcZrQu7kzCFBDbxLFEIsQxBHlI/iZupNZyVnoBHFf3+nCWS 0ZYyx+WKWMSrx2IYY9qrNIbyU3Nx5SXMzb5VijEag+wAwBnPAqRq3U//0vz0lRH+zkRx3BVx8svK Z7EelZ0glRpRJkrux8owMV/0LTV0f4JKSjoie3uLfymtLXzI4Vk3Mrtvye5H5mlu7aGDySX8yS4U yxqhBbAOPmGeD7Gpp9SG3cjtYYxHLdSOkMxG2NHU7mIOME/jV1IvtSMu9o1EJMjIcFT2x+lVK9tA IDHKEKQRGR1A4dgBN6mgy+XEocrGxYDG75M56CoUpITulof/0/zwdYpWitXYxyXIzHImcDHXJHfk daYUS2mWFZPOMJAZ+7dM596/6EnzWsz/AALi7JoleUHPlkfey0bZLEVVu5SUhkYEiI4Cg9PXIqSo fCWpAlwIJFUBTkhVYMFI4PGePofWojbIzK8zHMLh4wOCSpyP5UFCyFZ4J5EuGiut20MIw4Uc7s8/ p71SZmheKATebthDlvLKgnv+vFFug02j/9T894Jbd7VlMbC5MuS4IEaqB6euT+lMgdHkWAOTI7hU Udz0GK/6C5K1kj/BaM29CO7+1PM8ExlUxEAozYHHfGabDLBJdRw3AeKzUAO/3iWx2/H8s96nWxsm u5OsOZH2thDwnbAqqp8u7hgkVjHJOIsqpI59fypFrsbZF5pzMBGqwK5aJtuT9Pw9DWDKDLMBHPFt OTNGpJlgJxtJHTB5qHOztYD/1fzomt5Ld4fInYhGDyEDDNg8j6HFWJFF04lCYCk43dVr/oC55H+E CtfUlElupjASXeGIlVmHb0x/nmqs025mMeQc8+o+lSaqSbsMMksqorSsu1gAeeRnJrpjp1gbGK6i +1CcNm4DOHik42/KAOBx0/8A10DbsjNle2jV4vL80sMtEx/p6VUafZkqphbGCFyBigiUux//1vz4 sru2iRy0Lv1UZbbg+vSpzEZoknikRELGORXGGHXBHtX/AEAH+EktYEUUO1mRiDt5Zuxpn2pEk8p4 +M5VkAG4DqDV8ytaxg1dodd3mnSxbIbW7N2f9WYxiAAHkFSMk/Q/nVJRmIiVHRGHU/KT1rOyvcos 2kS7xLE+Sfu88HFXn23RET71dXwQq8kdOKZDjd3uf//X+Ary3SDyYbV7wOrFr03m0qCeAqAdAP61 T8gOPLhjaR2ORgcD3r/f5qN9j/BmWjFT9y6m6O6IZDY4ZeOKS7uU8xVFu0Zljy8gYBHH8O1e3H1r OVrJmcvhY+xFpZ2dwLeJpHSIAJJNtYc4G0E89a0Fs0aJWmcGZIxK8L/N5XoD+lSdaf7tEd2UMDzL tG7CPF2AA6gVn25uyQLbMayHY5H93v8Ah2oEn1R//9D4siSKZC9tbwWxICNHFwqkDBJ+p5/GuXu7 lobyXT74lQzBSUHmxPnpg9D0r/fg/wAHx8UESzMJdx3JhGA6UvkCMNJAXjkQ4DgkPg5GQaDeLdir CjJOGaXPz/vHbl29WrYjUoxuC6urnjHyse2aBS+FkF07i7hgEIlhlXK+U+ZN3YEYqjI09tKI/szT CTIKxsoaMgdwT2oMT//R/P8ANlp9x5cphaO5iy0kgfcJDnI4xxj61oajaafJ9jubJZGuI7cR3ssi gOSD0B/u4Ar/AH4P8HwheR5ALeJcRxNJIzEBfl5xVVri8RXUSeWkh37IuAMdAMVLimRzPm5Rls1w EmMjY/eYjQ/3fU/l+taG0wBJEf8AeNkZxxWJZOlygjaGSISOzAgg4IyeTn+netKC1cIkawg/aMjz D0GOgJ7VEoX2NqclE//S+HILWCyuZhHi1nYeSpiYbQD94ZHrUl28d28WniSGJY15aNf9Yx69Opr/ AHn5baM/wsU11LuiW7WE9wLiKRokTEMxT5X/AM/0p738a3AuVTyZwxiR8Dc69M1MovZDUkyKHTC0 S6gw81Un3LubKsM8gn161DJp5aaSUIlvESWEO3kE8jHpUcrREpJ6IgkjlbMONiZy8uPmroFu7eG3 NoLcXMbxgefIpWYYHJAB71IOd+h//9P4WMY80CS6lEfzeUjKAi55wcc//rrTtdNljO796gdA6NjZ uU9D9DX+73LZ3P8ACyMo2L+qKbKzhW+jn3yy7bciMgOR15x0ANRXV9aKltbxJAzXEJZVjUsybcDD E9+RRKNyFYonTrk+VKiKkZbEjK4+T2xUcNlLJLPcu6+QsZKBxtLFck4/CsbW0NIpW0GRmS4t5hZE NIDtYx4bbjsab9kg0xRaSpFMLmASzoibAHbrjuCMY96Cj//U+GZb0oLS1ttPEQRPKjMSuXkUD+Js 4+Ufp61es9OgtnkvPLdjcxbTli6lgfvD37cV/uwf4XWXUs3cZS1jkiQMC2JCDh0HvWbbxx2qF4N5 nnbETKvyJg5bJ9aTT6M2gla5oPZW0W4Sx3Ekk6eZJcSys+GAwdoJ+UegHpzS6fFpc6LELae7aM5l a5IDHHTaB06U35G8IprUlvZjbPG3kSxxOxjDKuY1IGSCfxHHuKzLn7U9uj2c06hnOSf9UT0GR3FY +8ty1FLof//V+IHlgtrQJbGWa8mAiuPk28A8jrzmpv7Khv4fJVbgQlvNkUALJgdQTjoa/wB0byP8 P7FmeztYLa2hLlmVTFbgjhioLbAPXqfzqC0axYSrqc0kURThVUnaewPtmkVFJuzIpBFbyNaMqsgx LHckguAwGMfhinqtrbXFrNdbLlEYANMd/l54BH0zmspcyZ0QtfU07zT5r2WV7HymCRltzMIzIB3A P8qrWplis4Fi88xxg292Y/mBc5Idj7dOPWpu+pvHdH//1vji1toWdFMxgjGfmT77E9c+tWZZ3V5b e3hLB4zHDcuqbQenQnIP4d+tf7irm5rM/wAXYyskyHR5tQeSFrQb7mzm3zqI/MVwp546D/61dTD5 U8spjR4pSTLst2EO5hzhvY9PpXHidKMvR/kepglzYmC7tfmf10f8EorFbT4MeHrxIpVXUbK3M2Y9 rxSeX7dVwyV7t/wUQmB+CevxQ3I3whJhFNH+5aRNzp9cFR+or/KnGSnU8ZL319uvzP8AU6tCFLwl cVsqDX4H8PHiK6E95calKu83E++RY08pfKj/AHabVHTKqDXwf+0vrE11byrZDyrSW6Fw0MaeZIsc ZVQCOhIU/hmv9CvEeap8AYty29k7/cz+EfCFc3iDh1HpL9T/1/iD/glB/wAFI7j9kv4pWegavpcV x4S8WXMUElxPM8cpW3BSKSUZCjYJG6445Pcr/oBaN4u8AftZ/Bpkjv7WHTfFOh+XdRR3kDeUsqKU kVwx4IwQQc818Zg6TpcQYuq3pKaa8raH3OOrRqZPhKKWsYu773d/wOA8A/D3Qv2ZfBusHRNQs30i 1LXEQe+TzWCBmYKN3f8AwHoK/mF/4KMf8FDPhv8AtN/FCy/Z5t45tMeLxKNP1XxV/Z9tJLp6kMg8 hS6kliTkk9H5IxX0dSXNOTPAiuWyR+1H/BN/9iv4S/Bjwjo/i/wDrcWr3N5bI2p3upTW76hqUnUy lkwozwyr/Dnvwa/Sv9pHxVpOm/BzxlDLqdtYzf8ACK3q2zy3EYZXNu4XBzjk4rwcEuXGSl5o9TFz vhYxvrZn+ex8CPHnhqw/4KG2t34mulg0vWfHcmgwaisyeW8sc8AVN5OAGMHfuRj0r/RL+FeueHZv hZp72mp2l9ZLpTIky3kWWyhOCd3UZH+cVGNb/wBYIW25H+a/4P3FYScf7Hld68y/J/8AA+8//9D3 v/goR+2vJ+zR+2/D4j8OpZajHpt3b/2kv24ySXCSAb3yrAkLgY5AyDzxkf0u/sxftOeAv2yfgroX iLSr2xtk1vQlBh+0IrhlXa6OrNkMD1U4JBHrXzNZv+0YW7H08ZL6lLU+APjh/wAEVf2bfjV4vu/E 2r+MdV0p9QuZHvLfTktoriRZBho1lbdtBxzhcYzxjGPoX9lL/gnr8Jv2RXmk+H2pQX4tI2VxeNDb SbcgjzXDAMflU9B90ccDHRiW1M4YT90+Jf8Agqt/wVA+GP7PXgq++HfifT7fVNc1mxng02K1t471 MYZFZ3zwASP++hjPOP4Afi944X4geJde8RHSRpq6xqU9xBZrELeJInfA2xg4XKquRxz6VDdkYyd3 oeWxBIrJoPMFu4iJtWxvIYdFqBby8dWRoPNnVQzzqcnA7AVxz3KU11P/0f5ObC4WQu0mxtnCxtyw PvX01+yn8KvBfxX+LXg7wj4y8Q32lWfifxLFpiT2qIBESzbR8+ATuUL1/iJwcYr5Sp8DPUhNqWp/ oz/8E9/2Ovhf+zl8PdGufAniE6rbSRrd6hNePDDcXk3JidmVsYCshxgAY6Yxj9Fviboel/ErwB4k 8L6pcrHpuu6TNZSzwzRShMrn1I5IA9a8rK4tVOeSs3/mz28dWVuSLul1+SP87r/gqx+xhH+zB8WL zUtP8S6fqPgjxLqMktpYpco2s2b3BJjJt/vEBlI3gkYZcnnj8UTbixlkMk8tzLLIwk88DG0HgDtg 5PGK9rG+8zmwVSx+yX/BLL/goX4n/ZK+JelvfW8V/wCA9Rv4rLW4g6i6CorCFo0Z1H7olR3G3PAx X+gX4a8c+A/2rfg1FeaTq6taeJtAV7+KXyo5rczRgqdpb5lYMMkevY181lNOdHOKmnuys7+admv6 7H1OZV6dbKKav70W1byaun+H4+Z//9L9gfFn/BBr9m3xjrF7rmqeJtV+0anfPc3D2r2ylSzZxHIP m4x+GOMcV+g37Nv7Lfg39j7ww2heALn7VpsWWluZnQSXRVdu6YhsFtoAHTAAA4AA+MzpOrUg13R9 9lc/ZwkvI/D3/grX/wAFZfCvh/T9W+COhW1rqWt6fIZtT+yeZcpDJBLImJJldgpG4HAA5UdDXtP/ AARl/wCCnOhfErQIfg74s0qPRNW0zTla2uGldoLqIOFUKzHAI3qAO64wDg4yzmc44Wg4R5vejdLs 3Z/dudOVeznWrRqSt7smr90rpfPY/TX9tH9hX4d/tc6fFda5rt3HJcGL7Olq8ACxksSRuYqRgjGV 9cEcEfEHws/4Ih/AD4WeNLPxn4W1rU72/wBPdZlj1Zba4gWZSDlCuxuCOBnC9R2r281fPlcaXkeV l0uTHufmfon8bPjrof7IXwfl8R69qVoNN0a2CXNu0ouG2BGAkEatncNvfjpnAOa/g1/4Klftx+Gf 2t/i48vh21ub21sJlfTtbksTaSfZ12t8y7iF+aOMY5Jwanh5exw0orzHm8/aV1J90f/T/Fn9hD4F +Fv2gPi3Y+CvEurxWM2oX26OW4iS7mCRqZF2oXXaDIEGfyr/AEEf2HP2c9D/AGevC2i6NoNza3lq tqhEiwiCWTfHncOcZwVPHcHHGK+AzWn7TFwXmfoeAqcmGm/I9h/bK+B2j/Hj4R634avNUXTpolIt nuoUlcSGNyDGMg5B2nNf5uX7cH7NV9+z/wDFbxb4U1jXF1ixmuTqtnFFMr3EoEmCTjkZZR8px1z3 r6yjK2AcT5fEP/abnwgtyLu6ieUKodQjbgMAIMKD+Qr9O/8Agl5quhWX7R2j3d5Nta0vrC0KFNjG Qys0SxA4DBgSG7HcBXzmdTqf2RiJUfj5JW73s7fie1kfsv7Yw3tknDnjdPZrmV7+Vtz/AEnfBA8J 3vwl07db6Rf6VdaQGaS9VI23NEH6Hoy+g9vWv88v/gslbeBbX9qbxhbaOljPdmWQhbZIxFIGuVEi kgZPl7AQD6mnkM51Mlw86jvJ04tt9+VXOXP1COc4mNNWiqk0ktkuZ2S9Ef/U/k/vpJLa+mS0Vk82 cCaQKcpkAKR2xgAfhWtFfA27wXUzPNETNFuGPN5Hyfl/Kvjz3YPSxiNfPPFcGRfs8jhkjizuVewN U47LNsIXaPai4EO/5j7irfwBFtt3E0mSOF7pbkvLOr7VllU5RSPuqehA4+mK1HlEQIZWCIcdOpqC yjBItzctBO7linmIACBtzimST2lrqd1pNrLdR3VxapL98N5URYqMoQRgkH/69NK7sB//1f5N7OeB ZPJhlYyWzlLjeu1cjGCK6K2tReoFg+Z2bgjvj0r5dK2iPppfCZk8LW0srqGyifOig4+XPOKW3Zmm W5GU+TDcbUbPqKcVd2Mo7ovXV3AtxFCkaMjIPOkaTkH2FaFnHExTfbLJbR5kLL8x46cdD049666S Tml5kVnaMmfefwpa6m0y2ieW8ji+wQxiaaQebEVjXGW65wePSv6C/wDglJoN2/xFuL3To5oruXWL eLUr5EASGBoLUIwPTPDj33Gv7Ez2PsfBpw7xh+h/NvCkufxKlPzl+p//1v67PjLLcab8NtW2bZC+ jvFbyKoJMqxlyWHuAfzr+Dv9qnW7Kb40eLL2+tYv7R1O7dbNsHbEkKRrcLGf4QJM9eTjvzX9EfRu pf7Ti5eS/U/J/HWbdHDxXdn5XftVal4csvDjRaZdPf3MFmUvluX2QSM6ec2WYA/LsC9OueT3/KH7 QFihubiUSvdAzKWk3KgJ6ewHYGuLx7l/xkFGHaF/xO/wsjbJW/P9CnJ5W1ZGSMbmJLJxkds1t6cs 8OG2mS3X5h3CA+lfz9Ul7l0fpco3mdDbapFHMC5ZSDzIBwB/jXTW8qtGZYXWZSckOcBVrya70NUr KyP/1/4u7+/ka+2vCLe1ODDFHl146nJ616/4QYR3OnyBrdIr0hJpmk+6vIztHPGTwa+PrPod0Y8p 6vcF7WKeCGEzWaRmRiSP330Q9j/Wt278R6J4htdGstNsZNJ1yKIW13bxQk2lyQAEdWJPzHnOOD+l eeUc9bwW0GrWGn6lPKl4JyT5aFmlK53f5/nXQz74BM9mZJAJPs0rwjna5/i9jjmsJ3s7nQZX2l57 trG9idWjhR7eSDCrtyfvkd/8adPa22bu4gtEaSErFPKq4lUYyMt19OtbUV7hcNz/0P41I57z+1Gv LaULGJljkPRoOOSPXpnFdHrU9paWUsqawiIq+e9xdRiEyFSOB1OTmvnab99o857HPXVrJfIpeKJi pD7yAxYnHfv9O3PvUNxp1xIttHauolwQZQu425HAA7cVrN62MUn0Lk0U0QWxkkIPlCO4mUbWkH94 jOM/T/8AXbi1+z077Pb6fd3H2OzKLdSsBm5YfeUYyCfp6UQ0kaxvbU228Sf27Jf2TRCbSljUWsrn fcFSSWGR0PA6eta6yWxNhHpc1xDttEW5NzDnjPzIMn0AwetdVPYo/9H+SzUtJt4bYXtlc2jWyM0g jn3ee7E8hl5xyeOcVyl7qb30ECEwFtwhaMYjX5eQWPQYPeuCmr2OOLbepzN/p8bQXEcltZILptsr A7jgHO71wa4bWHg0qWOS5t44NLuLZYLWQLsV2jXEp9Oo/M130bcruWnaZ9O/s+6ha6nr2jyRuLaB WM/nndbw7IgjHdnjJAOB6getfq38KbOeTxR4Pe2lmkuP+EjsjGIpWCyrJOsRD4ONv7wHJ6YFf2z4 Kv2nBdWn25j+bOOHyeJGEn5w/NH9/X7CMsLfCi3gnJm1PR7CC0E/meaJgvysw9l4H0Ir8+v+Cyek pf8AhSedoXAj0kz3Dt8pjEcsTy7W6BtjKR9BX87ZDP2PirCa/wCfrf4n9CeL9Hn4EqRt9mP6H//S /LSzlsbjToY3ubq5uLqBRC00W6WVsHJJHcY9O1cHcWUejCS6Oo+Y73DLIsqhZVXrk9sdfxr/AF3w z/dpH+aeK6EZsra4uFvIJflULLC+crI2PTpz+NXEv9QvxqdjdpJcvjzRsgEEUakdsDtjPHrXUYxd 0aEep3GnaCLDyPKtWkXzL2Il532jGH9uea7v4MeM7LwF4ssNV1DTrfWtOgvFlurSSJZWjiZhvYA8 FeMkVyY2j9YwdXDp25otX7XVrnrZdilg8ww+IauoTjK3fladvnY/ri/Z1/4Kr/sk6P4EstF1NV8M atomkxWmpNaeGTPp0JhjSMpE0CkcEKfUZFe0yf8ABX39j0Zs7nx7er+7xFHF4YubmCXfxliBgY/u sRX+dufeGfEuM4grvD0nP35dHfVvpa5/eVHxIyHCZPRdaXRdVbZdb/ldH//T/oFl/wCCr/7FB0+4 Fr42cSxNtFt/wi8mly3Mir8u0lRweBknpX84X7d37XumfHj4hJB4Q8ZeIbXSodRuon01YntdLjXJ ZDFLuIc7CqsRnGSOMZr+rvCTwuzjK+JY5lnVCUYRTa5lZP5tbrTT1vsfhHiZ4kZbm2RrL8sqKUpt Xs72tft8/wAD8+/t17LqMsdheSKI7IW8Go6ZfNbzxGIlymQRz0/Kv2t/4J4/8FSNE/Z6tJvCvxk1 XxjP4ZtZY49Pv72RdZCOVUSRGXAG0srMN2SqsBnA4/afE3g2HF+Q1MFh0vbx1htv87eu/Q/N+B+M p8M5nTqYhv6u1aW/4b/0z9g0/wCCxX7GviG9Gn6X4nu5LsAOJY9Lja3bd8zIJCTuxzn6Vnyf8Fiv 2PQI7c6rqPm+eYII7DQIPPcgY3Fg4zntgV/KtPwg4wjCUJ0J7X+F9fl+B+8YfxS4a9k5+0ipX0u1 /mfGX7bP/BUD4PeO/h7F4Z+FOualDq+pK8U17FbKk6LLE/Em1t0TBgnOMcdeK/nOn8cS2mtabeT+ J9cutXjlS+m828kVYJBx+7AAXnnGOQOK/f8Awh4Lq5DlFaGbUrVZtr3k1p8/l+h+L+IPFVPNc7hj MBVuoWtZ3ta3a/np95//1PuH9ib/AIK4/Dv4P+E4vC3xOPjPbZoLeG8s7Y6paSrEoLOjHJXCgA+x 9BX39L/wW4/ZHvLV7qLV/FV9DCDO872cNvcRjOCiIyBuv/66/p/i/wAG84lndfF5ZByozd1yq/4L Ved/kfk2Q+MeVYvAwjj/AHayVnd9lbd6fqZbf8FwP2TgIEMPjO6F1thjs4NPhmuYQ3AcjIBz6Zr8 qP8AgoX/AMFHPB3xw0+TSvhwfEFhZx6O2n28N5CdKuXkMgkNxIwBwIlTOEOSeOuDXVwj4MZ5QzvD 43NIWoppu9r/ADXNf5dz4/xC8U8PnHDtfKMpf7yfuv0vrZ7dPu2PxQttaW4sbVYreNJJmdri4JE2 4kDDF8Z6565wCB2r3/8AZn/aOuf2dvHdlrn9jr4rtI9Tiv57e2mFnc2LBx5jj5WEqmPeuw45Yc8V /WWZZfHMMqq4CTtGaav2PwfJMdPL8RRxkFdwd7H9LvgH/guP+zvdeGbC11LRfFul68yi1ht2tFjj nlGAzmUqVAHJ5xj0ruX/AOC4v7OUW2KK81N7kE21wSUmaJhkFW2pjk5HOK/jHHeAvEDx86sItxbd rK+l+6em/X9Gf1hR8Y8kq4KFGU0pJLV6fhb+vmj/1eo/4KLftb/Df9qN4dV8O3N3baNpeqWZbfYx +dPcC5UhZFRd/l7jnPAG9jkYr8+fBHibxLoHiKHxJ4Etp4dU0S/huZdQsIpP3TAg7TgfPuGAVIPv 7f6LcOcOf2VwVDJs2XwJp3+Vvv8A+Afx7/a85cVYjNMvl/EnzK3n/lY/pE/Z+/4LG6f4G+HGhaR8 Tvh54kfU7CFLCe902+GZljAw/lyINozu4Bxj0r6U+Gv/AAWJ+DnxU8ZWnhOy0TxDFc3mq/2ZDHLq ICxu8nlxo0YT7xY46nHfFfzFmfhbVnLG5jgql6MXJq2vy38z+gcq8Qfa4/CZTiKfLVnyptv5bWP2 O8Natb+IvDA1G2ikiMsW4+YfnQNGGAPA7Gv5W/8AgtjoUcvjfwfcSXFjJHqN7HcXKzxMxgkWHaqh cY3OMtkHr+NeD4MWp+IWHpvfmsT45xlLhjmXRr8j8OfAvxJuPAHjLTtVt7ZA1lE9xGFJXy3jdGQD HODgg46deelf0O/Bn/gu74R8HfDvR9F8YeC79NTjtPsl3Ha30l8HlA+Z9+zAB5wD27V/Vvix4XVe OI062FdqkX5Ly66W/E/EOB/FiHCWDq5Xi78lrrS6u9emqetux//Wj/b2/bg8PftcTWv/AAjGgTaO 1xeQT3Nxq4a2uovs7kBsfxKyFgM4zkHjmur/AGDf+Cjl9+yZJNZeJvDk0/h6K7E8s9vqLssiBiF2 gghRh3JVh1xg9a/vuXhTVn4ff6pTlesve/S19r6X7H8acP8AidHBcXVuI6qtSnJp2u+m9t7a+u5+ in7QX/BZz4X/ABY8Ca3oWg+DvEsd1fWP2QfaJktLSSRyNjbvmyOuASvJ6V+Cvhr43ePvh98ZP+Fh eDLyxZLvWftuox3c00alZDvkQlDnAfLblGeOAa4vDrwgq8OZZjMHm8b+1VktHbz0ud/FfipUzDiL DZrlMrRp7769Hul8vzP6D/hn/wAF4PC2leHG0rxd8NNSXWdAsIEvnstRea2mdlCNsfy+V6kbgDjG cnNYvxf/AOC3Pw/+IPgjV/CmneBteinvlezttQjuV1K3tpWQhXkUqgVVLAH5iec4r42P0f8AMYZm q1Jr2fNfdLS/rfT0Pu6/jZlWIwU+ZtVbbcrbv91tbX3sfI37PP8AwVh8RfA/xZqGo6/4AfVvBV1c YaK31KQ6hJ/DJN8oK85VhleAo69a+hf2lv8Agsb4R+LvhW+8IaN8Otca2l07FvqDahJIVMyFcH93 uCgMwJ7enr7+K8CsX/rDQzPByShFxbd7Waf3/g0fPY/xgweP4WqZTVX71xcLNXun23Wl+6Z//9f8 77pHur+/+2XTtLdzvJayEFFiDsWGVPOeTnvUXg3xbq3gvXNL1nRp4rHXtD1dLuG5UNEl6I2AIlxy QwA56jaOlf66YvA0cXgp4OsrxlG1vlY/zpyrNMRlOIo47Du06c1JfI/oP/Zv/wCC3134A8J2vhb4 geBYNR1i2ZorVtIvryX7fDGA6swkjKKfmZMh+iDhelexa5/wXo8JX9rqFlYfB3X2n1CIqHjvJCbJ WPl7gixucZIHYkkDmv5PzP6PGOrZtUr4RxVKUrpt20b7b/h6XP6Il494N4VXv7S2q5etu+3p+Nj8 F/2ofjvefG7x3d+PrO5WPTIg0y2jTXE80nmbWBJdVIVGZ124x8ufTHM/s8ftC+NfgT4zufGuitpd /dTNCf7BS7uNMZ0R1J+YZXLcnIwdyjnrX73h+CsJ/qjHhurDaFnp167P9fM/GY8d4rDcVf6wUZNq /wB617r5+T0vbU/fnwJ/wXpkt9OtdJ1z4Pr9ssrFVuJYfEJlvHYY+4uz5uOnzD3rek/4L26FO0tv p3wk1aOYyCMf2pr0onk7uUQKQAB/Ov55rfR2zX203RS5W9PeW19LH7BS8dsK5RTk0v8ACz//0P1J 13/gvd4Tv9H1jR734T6/aXdxAYbS2sLmWdrkcq6+YIyBn1Ixz1Nfz3ftC/GXX/2jPFeueK5tPn8P +GZZ1ki0Y3zTXuVkLRiUnk4PfqcDgdv9DfCvwbnwZm083zBpu1oq97N/hpfve67H8LeKfiRU4zhR wmGb9lBtvRq/b/P7jwvSNP0wpK9/PfQpBEsdtCsfmwy4OApycrgcD/61VrlDfzmOC2eKKN8RQyMF dVHALHp05r+jaUbI/HOfmsiJLOSeVJUdZEiyjJ2JBx19sGt6a+WO0gjFsjDP2eV0OZFdjkMy/j+G PrVOKSZp7R+0MxpLuAXLW8cbtAOpbCk5xx3/ACr6Y/Ze/aL8dfs9eLdJ1/Q9P0vX4lv/ALQ9rqks 1sLMSKQQJI2BKK21grbgCvTmvneI8jo8QZLiMprLSotL9GtU/vWvW1z6PhviGvw9nmFzOh9h6+au 7rp0287H/9H9QdE/4LxXKaRDpE3wia71XTbdYJHj1CeK3nKsBuQ4YFcZxnFeJ/tH/wDBZXT/AIye HrDwt/wr668PfZrr7Sk0t+2ppA6Ky5MUQPI3EjecZA49f7RyjwHzDDZk4zVqaa95tNOKae17308v kfyznHjFhKuAn7KX7yS2tZpvfW3r3PPf2Wf+Czmv/BCC48Oa14ZbxTZXk/8AoV3eSTaX9qRnPCsV IVk46qBjFb/7Wn/BVaL9oL4fa74VsvBNtbahqCtYwwS65JPIu5GEhyyKNm1j93PQV9JlngrVyLjC hnOG/gxmp9krO7Vt1ddNUns7beBmnixHPOFamVYhfvXDk89tHfye/V/n+Nvg6906ygktp4EhYN5B aHMiLuJyM/U9/SvtH9j2Z7L41+HWurq6tbVLl20yK3gJWbYYiC5HAzuxj/ZNf0jxNDn4Uxa/6dy/ I/C+B58nG+Bf/T2P5n9yPwduzf8AgLQXkdpy2nRb5JUx5uU6/pX8+H/BafRtPvdN0yK6gV54r+1u Y4ZFMUUyoxGFOeW+dcD61/np4JP2fi5Qj/08a/E/tP6Rsebw/qS7Jfkf/9L5ImsW8h7NZDaq8e5G T5ZYsjpz0IrLt9OnW0ktrhnuDuwl08u+XAB6n1PqfSv9zqcFof4p4mp79jGijvHjllN8+Ij5Zif5 UjVecq3X/wDVUmoWtxJZosP2hjLtkZ7YZE6jqCa6OSJyyq2Zet9PFukEBMQZ41ATd8iD0I9avQ2M kjiWWaC2jiZlaIgiSb0x261UYdjGVV9SW+j3WNvZxWu26uHkyyvvJUY2EAfQ9PWsvw7ZuLjUILoS RyRIAm9SEYk84P0p8jvsYyqvY//T+OJfLtZZ7dN8Vzs8z5l+RxnHB6f/AK6rS6mEt2QsJbpH2IiD O0+vv9K/3b5Gf4dc7MSdtQljeO7iJWSMOC6FGbnOcfhWbpt9KJ57cSeVu4KrwAB2qlBdSeZvQ6W3 ngXKo7tc4AWP7zEk44/Sqd1exxMDcSS+XIQCFGV3dAOv4fjVKCvohOVlqMuYZr23QWkLxzJMr4U7 TxnOPWo7a/msle0u4WfZP8rdfLzjIIx61qqaRMpn/9T4yu3uriZUiMcVuI13QxDAyB1J6moLe2Fw WbzcllxECQFGM5Ff7zckT/C91GtDO1F2toLOzh864VZHaZ5TuU5yccenT8qg0+4gQxLqDtuWZmgt v4No9u/vTUE9EjL2j6nTXN1a3N7HcW9rBl02qigiOInAyBk/lWC9jZxXUghWTdHJloGz5YbqcZ9+ fTmtVTSVjOVVp2Opi1GxsNDf7Q7wytdqsMkbYYFiMAr1znvXGM7QSPE00kiK52jqRuPenyIz52f/ 1fhI3UEOAVwN25wejE1bsLSXzWkDGOOfOOyfSv8Ae5QSP8IudnW3MtudOTSru4gUWil4XBBmk3Nn 5fXkn8zXLvBFauGWRS+zcA52sRz2/CqsZyn3GxXlwrNMYw5UcN/zzHt9azrjXJMMlxayWwR9zHqs oPIb8v51XK72I59S/Z+b9mM0ahoJ283cV2sRyP8AGogY5XEbxySL1KxD5iO9Wqa6lKasf//W+DLy bz4ZLCKDy45HX97nE4wegb0pWNxErGKdIpCRF9mbKlwepzjjH1r/AH4jH7KP8GJzWxrwO+mWlzIR FNJPHthK4chgRnJ7dv19a5NUW4maeZmidAUIDbQc85x+FaqFtxxqdC7dSQQlG43kBVIbhuO/vR58 IRVmbaW4QE8E9h9asrn18ieytBKzs6HZu5HerTWqf2l5Fqn75HEZVwU2kAEg/SqUfduHOf/X+FNR t5rSfGbeJ5cM4iAdMZ6Eds46cVhXMsq3SW7vKVY+dMsUJjXb2A7Dr09K/wCgXkR/gxTnoWH09ppI 5MlRG6uFgcq0ox0Pf6+9K8iLdzhQ6W0km6JJDuKgcYzRyIpz7Fu/t7O4sGJPlID86rKQJvQMKxoP IjBkkMflqwjjRhyBjr+lWl0Ri5pbG3FcQw3e+zlOwHCuvybuOce3JqpelmunmjwjOfn3D72Rg/j1 qlBsHNdD/9D86jCLZ/LVfld9+QSxBJ+tdLbpHbYubSWQttA3SIATwPT6etf9BbhZH+CMpcxBcyWj NE98ZY/MmUzMoHzjI4X8qha605NUmW2SYRltsHmLkyLjIP4UKPu3FGVtiSWQvLIdoVAAAw6uR6ik nMUnkNKd7rhWTO1ti8BSfSiML7kVZXdkV18tHfFttUuQMOQiA9sd6llRYY9iLIedzK68D0xWiVlY z5nax//R/PsXTHf5abnVThegP+cVCZDLEqmSIu3EhT7qN3HrxX/QlGPMf4DhEkSpHDcunmoeGUbU x7VNcW6qmLRGmm2k7UPL8dB+v51Xs/MCuJkjtkSZu4VTjJU5wB+dSrN5Tm3aNo2QYLsME+1P2a6l Rlyj0bdIBtO0j74/L+tR31tcBrYs75ckIit94Djn8+KXsylPuf/S/PeIF3SJ3ERDfM2NwoVnsryV 0XZO3O9Bt8wHvX/Qp7M/wOc1yorSjfIJGlO+VsMWY45/yasp5MKbJBlweCOlPkRHtPIaGcSOjsDE /KNt2lSByM1aVo/NghPmEupPyKcEDuT27Voot7C52OWV44JbVirRlyxc8nr0H5VRQpukCsNq8sT2 /wA5q/Z+ZHkf/9P89ZGUgSeaTJGvlx7+dq+g/wAKqrMIijOwLbsDjaGNf9Dns/M/wF5lexZuiZ38 3/V7lCEL8vQYyPyq3BDJNGiBm3IAvzZOaPZ+ZRJEJkguIb1YhMJCiLHkhR2J9+D0rPlghiVT5hL8 IuRjJx1/Q1Lg0Am2JU3zMc+3FSWtraNFmC9BnaTKRXGWLr1O1unHbNQ463YH/9T89Zs2yuVIwRzx nP4VDHLsgE52Ksx8so2BIDwenUV/0NKLa0P8CVJpWIpMcfeYFgc5IqYxechUcAHLE8fShQbVxXIU QF1RHxsYbz1IrS1A6bfKsUVk4KYMjyn/AF5X2/Cq9m+pXOylcF5JE8tREipt2jjpgDj8KaowhMrB SnPPen7NdSW23qf/1fzrklJCBuIhkiQDvx/n8KsgwCMNjeGGRj5c1/0O8iP8CL2ZmwxpNJIjCQOh +VAvHfv07VovviiMSsYpMgsSvIwen4/1o5EVzsezXN2qLKchMsCAAw9cnr2/WoftMc8gt4lRHjXY zk7SffH+elNRUdiCRmbZ5TyFivqc7aqlFdcyYJHCkjkVRUZOOh//1vzoiTfIsSsBltu5uAKknknt WESoZI/NKeap/dnHUg9+o6etf9Eag2f4F8/YtWWoi0uxeNBDcXAjaLNwpb5WG0jPXpWRcw290yGS xhWJJd6RL8yxnOeCecUckg5wmitvtBW2jMRLhih4jQHsD371JKLcJOxEzTQSBUMKloZAev8ATmps 72LTurg0PnJFI6SohAznPWopYC8oXz2Cj+M4OMdqpQutRn//1/zijha9kjtgkkot8vGUyNpGTk4/ H9KHReqThyWKvjquCeCa/wCiT2fmf4G88b2NO3+wWqsRZwG4kTDXGD5hPbvVO5Mk6h8BQvG3AB/S j2fcnn1Irdwr7pQPlGBuAK9MdKbJEY8sqko/DOOgxzg/iKfIhc7JLUQuCrkRbOEyOD+VVLm0kuHD x3USLHn5DGx830AOOKORA5vY/9D80mBj8uOVHV4zwyOUJ9OhrREy3b7SMOuNsjcgjGK/6JeRH+A+ xZe68keVsiJkcIX8sbiPb0/Cp2lgEJtGt40EWVW4iwN+fX1xRyIjnXQzE2R/LywHQnk5FWQVGC7d wi7unPQf/Wo5ELnJI/OgvbWH7MJYBIzzRMhLc4I4zmoJbQNdXavE0XlS/unHCuMA/Xg5H4UciK54 n//R/ORJBA2X2tg7Ru6cnAH/ANapWaTYQx/d/ewOK/6JnBN3P8BeaJGbe1ktS6vI8rnemxv3YHfP f8uKZBGrjYBgr+tT7PzHdMvwTojxAxp+54ZG+5LyeSP0pkkeLhkn2EP+8CqABtIBA9O9Hs/MiU+i EcoC2HIRvlVc8D6Ve02aydpbCWV1kS3aUNtLH5VJGT74FTKPKZn/0vzjQMx2yymR1ON20IGGT2H4 VoxwKoXyCdzDcfmzk9yK/wCh5wTdz/n/ACzYzeVcvFNI8cTnZPIn3kBwDx9DUX2RmzHHI0yRMxjM g/eMCeM/h2pciAoTyvbxnEbKfMEeAvHJxVgSLKiI6CIxrtDooG/0z/nvTcU9GRKVnZDo5VjhMLxA tv3ecM5I7Aj2x1piJCHMkk0gwvEZOY8+oH4UKKQ4yuf/0/z3jmt5UYRiRCGKuGxhgD2/I/pUTbSp dMtEhCyBB8/XFf8ARAf8/wCUyDtIUkKvI3HOKZHPJEMxAqytnOP1oAu29zuZnlG1s5DEctU95fae 8T28Qb7RKMJIV4QjqfQ00m9EaKdlZmclvMEB34XkCZxhWYDP+RSSQ/KHlYMMbTtPOfpT5ZdilJM/ /9T86rJIrSIB2LyCT5OOMHPX9KslCGeWGQxSn7rIcEZ4wK/6IbNOx/gRGVtjOkZeY2UFj1JGT1qC RPKdSCDlcgjoPY0rW0L9p5CSqXCvgB8fKUXHHTnH0qeCKdvLZ8HawIIHOQcik4p7h7TyNa5NtJbq CxN0JNrRbMMVP8WenbH41mtbW+/Kkebtwcdcdan2aD2nkf/V/OJomaB4N77ZPu+XJiRcHrkHIq95 Mv2Py5XLkrtDnBcAev8A9ev+hxw00P8AAtz7FdLbYiZAGxcsycbhk8kVZjmS3Uv+6m54jZcyrj0J 6Z9qiMNWS5NkN3cJcRNiPY7rkxtgsn5fSmWVxLA0EQgMx3hJApAyOhJzVcjsLma6mhdRJI4UkxFW 3KocofocH271DeWg+yfaW3RrGuAuDJ5x3Y4AHv8Ap1qLWG5NqzP/1vzmLMHjWKaK4ARd6xK3nQOc HDZ9Pb0606OFfPZh88pOT/ESfWv+hdpNWZ/gOWAy5+6N/QAd6fJJbJEqTxKsqsSGbh+cDFTyIpSc dEVfLJZJreQJHu+dQv3vp6VddoV2ASq5OdoPUkUezQ+dlZkW3sbvUDKERHSHZsLbmc4A4/CmJuMG Z/JijjbcGbCSSE4GB3PTp9aytbQan3P/1/zsaM25WRpPLjn+RduAW7YxVNoJIGCruLv/AKstwTnp zX/QhY/wPUktUWoR5cgEyGd0Hz7Xxu9gf89KjS0ZkkKSZYuzYfnZ7UnFPc09p5FmNxaQwC7kEz3j mJHiUjyiP7wGcZA7nvV+byjHsikkgltxvVwoZy/HIyPb9Kj2fmXGfYpRw3Jg8uS4lunUmVsvkHJz 09s4q9a2tqoK3RNt5oLeeIi5UqD1GeaycVfUvmkj/9D89LyW1tY4FiZzJdhtgkXbnb6Dt34NJDBI LeOaRjvY/MmPlP61/wBA3JE/wZU5EsML3L3KxqikHcQRhsjPHt9PpVG2jjk3FiVYnlCuCO3P8qOS JamjamtrRrGEQIwukkJnZnGGU4xtHtUdvd3EKCBFdo0Xcz4zijkiOVW42xi+26hJIpR/l2HePmJ6 YHPv0qK+WKKbYhEgXhnHIzn+lLkRPO+h/9H867FRJPMjAMsZ6AgZGOv4Yragt5r64lghjRIoYwY5 DJhX7dPWv+gXkR/g37R2sUxIttKUlHys209yfpUiwRxyOzhzE2ZIJG++oPOP8+lHIiXNmdBcTh3/ AHG2ONsJMXAYjnOB19K37h9NnijiV4kaJSJZFBJfv83P6il7PUOd2vcyorUbHmtLqJwgykQY73PH C8c//WqaOUIVnncpg5OODkdqPZmTqO5//9L4JklMpaSb5xOuf9sD371NcOJ4oTarDam3g8ljHxI/ Ocknv16e1f8AQH7PU/wS55GLcqZlEO3LDiQ/36BHHmN7h2Kxp5SqDjb2A/P+dZuCtqjOVRpWK72V yNkmwEO+I1U5Y+mRWlKk0bxmXAd1DcHJ9OfypckTr5/cJo2N1uiSBjKoyCBlCABk0u1rYEvlJAuC oI+WjkiTCfY//9P8+BNLYRLOGcLNIxWRPn5HXOKvrHcXaW812UuvOUSpJHH5ZAB44HTpX+/vIj/B vnZbeeBHBHL48sxgZAAqWG3S9lAiutvIDRsNoB44BNHs0axm7aFPVrRBe+cihWVBEzxnKSY7+n5U 2yEs0jmYbkjGEA+UAUvZ9huTa1NiyitvnmHyNHnGTnFc5HIsmoSeejlHdmVgeAc96ThbVGXOraH/ 1PhO88j7KZ4GSIRnbIQAu7t/WswXLRNHAWG+4BIXPzYHU4/z1r/flxaP8GeeQ+RIIbW5eS7U7/lM Ee7zk45PT/OKdZWqtAn2Vnuth4LHc5HH8qLNbmftLSuWLiVBEp8pw+drkA8/hjjFDNcQx+Xm3eGS ISQog/0lW5yCc49KjkiWqjexPbRXNsouiY1T+NZE8xufT0/WtaS4upYUihyrM25uxx2+lS4di1Pu f//V+GLyxvFi3iDy93KmJc89yQPz/Gsg29yDHKTtAYZc8HPXGPwNf73uKe5/hCqja0NhNSvni2xX XlyFsN5qiRWHcYP9Kp311KklhNFarcTJclLsv80QQ9wv1H8qXJEbm+hsWTI6SIEZY5GLsNxAz6iq d1dSiRWF1IIpG8hYzkg46cdsBahwtqjGU9Qe7+zfKZHmWRd75X7vbANZ7XUlyj+VvzEpCgdVHWos lsVzp7s//9b4CDzOsSSCWaQEDahw7n2rS857e8wIZ4ThVEczbiMdu38q/wB57Lqf4QKbezOjllmv I5pCv2mb7M0aCQ58okY3CsGCKPaIpGWS4iUeaw+Vd2AcD3qZRVh88i5KJLC1gfcSJmKjcSQrenvW jqaR3VhbQzybPsURmhmUFRGxB+QY65J7/wD16xsjaMna6MiLVWtEjKNHHIqgEiBVDbf4jx+dNEtx qLfaTHlv9Y8oTYpB9AOB7AUWXYtzZ//X+IY5RcMVG4zW5AO0ZWMH27c1cvJJLMK0MJAn4jyPvEYz tFf7v2XY/wAKlKTZEupKFkt4l8ua5i23QcbiR904+tR2FreWkjSiyEen28e1DNJu3yMQQ2D97jNR KKSubJtbCXt9dyXI88jeRuVANgx9BVa3lBl2I3l3E0m1XY+WgJPHNLk0NY1NNzcuFRVSzuJpGi87 zJJEA2bsBSc/Qe9X9QtFXFkYpBC1qJrSeEYT2yfw5qLGqm0f/9D4jNjKiuxlSJ1w5nc4RAOufyrp bOF4NPu7wPMbtrT/AETylEock4JI9Ov5V/uxZPc/w652c3Zy6pDJElzKLjGTIjxARhjwTit2NIbh 5UkghM0i7cMBnApcq7BztFN/sm2aOa181gMKqj746ZBqJxbndGYNiyRKkCqR+7bK53ZHpn8cVlJJ OyN1N9CebyYEVUuJLfygNsmA2ehIx78j8fxrUsvs8lstrJciD7RN58seAGGeNxFQ0uprCo9j/9H4 tvrfy5VWOWUCJziXBUMp7kZ68fzqnFKbhnW2m86NH8vzcEfU4r/ciyuf4oqo2tCy0l1p729jYxOv 2tC5uDn95ggbc/j+ldFa281nPbXd9NsUXEX2lY2LJMocApj1IOK48XaNGb8mexlsnLF0436r8z+z b/gmPokOk/BbRbSwmaSAWkJh3Ha+PKiyTnnkh6P+Cnd29h8EtduPOaGOO2kaQrx86QybSPfBP6V/ lRTar+Mya/5//qf6oZreh4RzT6UP0P4yfCmlW7Wtu+pXNz5lzEBK9wu+TJz8m08Bc8Yr86f2iLtL XXI4xuh05jO9z5UPyA5QlcdR0JAHpiv9BPFpqj4cY2X/AE6f/pJ/Cfgi3U8QqC/vfqf/0v5ZINTm XUnGm3j/AGVA5hvTGbaaHIIXaezev0r7L+DP/BQP9qv9n3QJNC8A/GrxRpWkRRgWtpJHFqET8BPK VZFbaAFXBUDA46V81OKhmEpd7/mz6Tnc8PGHTT8kd94u/wCCsf7dfizSRo+tfHHxBBpd6rQSxxQW luzIQVJysQY57jrXwxr/AIgn8T6wviHW9SuNV8Q38izXWs7hbXMkkahVlfZgZwi89SRnrzXXzNuT OaS5bH2R8Of+CmH7XXwh0e58N/D/AONGu+HvD9naxR2GmfutW83ykC4XzUbYDgc8k9M4FaPi3/gr L+31460LU/C2ofFnUtZ8OXkZS6vP7LtBdIrDDgbIVcdxy+OOgriw6UarfmbV5t07PsfCCeMNYv5p r+4ub8a3Jqg1Z9UmlZb24uQd/wBoL9VbPTb0wMV9x/D/AP4Knft3fDHwxb+DNC+MF03hmFfs0cZt oTd2ibQoJlaMucADgN17VNePNmHtPKxFGq44P2fmf//T/mh+I/xs8c/F7xJq/jf4n+Krvxd4hupU cXl43ltCIySAIxgEEnpXq3wZ/bU/aC+BtpLY/B/4teIPB9nOpmj0W3uneyMnOflJwo+gP0PGPmqz X1yMj24Sf1ZxPobVf+Cxf/BQG0sdNiX4u3k0ls2biW08m1uHOcZYtE24D04HtVGH/gsN/wAFArlV K/Gq8hEbmWUXFvHfu5IICkmMKynuhBA9K1xDvLQ5INpanx18Zf2hfiz+0DrH/CQ/FzxRJ4v1xYz5 JubRLKOzJOf3aJ8o5GcgCvCbiW4uWCSOymFfvPlgPUCs3K8TOV76FCaYRBYyCw6ZPOD6061JiZrj 7VEkygFYMbxIOnI/xrmnvY0P/9T+R+xu1uBLcNBJA/2htwePYJAD94Dpg9q7vRL547u3nguvs4Se Oe1njmNtfWs8Tbo5ImHRgQTmvk5tODO+P8Q/Rfwp/wAFI/2xfgl4Uh0nQPjXrcWlQRILe11JAzbW wiHf1YnIG5uK1V/4LMft6pI2/wCNmr2qQxEMwsLS9juBjp5JjIY+m+uXCR5Xc7qsuZ2Wx8P/ABu/ ao+MP7Q3iOLxD8WPEOpeLLpXRbTU7lltW08IGJxEhwu4sSRyAWOMZrxkXF3P/wAtTMqEyK8rAuw4 4z3rvxDu7iwsrG3ZXUccD3aIrPbZkMMvyDcpyNpyDnPcdK+1/gr/AMFFv2p/gZo40X4dfGTWtD0e OIG28O3NnFrVnAq4/d7p1kKgYAG3GBx0rzcPT9niXPuz161ZVKKpvof/1fyduv8Agsf+3tPbXd2v xnuvOdAtvbW2nWtqXzjOdkKheM9j0rLvf+Cxn7fl1pzWX/C5Q9rInlXUcmmWksjA8MGBt8ZHrnJr 43Fvmmn5n2GGnyQfofnL4y+KHibx34l1DXvFus3uu6v4hvprzUtRa4kj3tISzB1LE4/hGDjgcCtf wX8WfiL8K9a0rxV8P9f1fQjpVxEVm0vUQkwMcokHyvkHoPTp1rTFPmpQVtv+CaYefLKVz9GG/wCC yv7dsNhDbWvxUkWzsEiis7WGG3hub1V+XM0xhJDADJxweauyf8FpP+Cgryx2lv8AFuFoHtRO9xda dYQbDtyYhJHbKzEYxk9c+vXqxNRSwygYULxrtnjfxq/4KX/tQftOeFofB3xI8WiPSraQySLpgEEd xKnyqJo8fvF6nDkjk8V8FpfXcLSR3F28zYYCZjtc5JJOO2cniry2ap0ZLyJxl51Nz//W/lr8N+Nd d8G6naeINC1G603WLDLafrGm30mn6jbupDJskTkfMO+R7HFfot4T/wCCx37dHhjSLfSj8RZNRs4r KK2Fvq1wPtNmIwApS4RFOTgZOefQV8Tikp4uLPtqM+XDyR3af8F0f26ruxbTLzxbo86TsIZmezjl aSM/L/rD82QB1xk+9fmP8YPjh8QfjD4rvvGfj7W/7R1e/uZRJFGn7qUO+QWYndwAuB04Fe9Rmvq8 onhV1aaZ5FC0d5O2ni9js3EXmhpyQhyTjnB4yK3/AAp4v8Q6Lf29zYatdaRqukXqXVvqenSGFhJE SYmK9DtPIzXlYi3suXzOzDu00/L9D9O/A/8AwWk/bh+G/hmHwFZ+PrbxLoaxi3gu9d0lLrVGDADa sm3I2kdGJ9M44H58fEv4wfEj4q+K9a8a/ECaPVvFGrTO0d20mW2yOZH3DAC5LZwuAK2wiSw7Xkzk xjbqq/dH/9f+TOWbV7m4M2IdjRBZnJ2FcAKoUdyMCixCQTsl7JLO5jaOEN8ywsRkEntXx57lNGeb qeNp9OkiSZJJA5uWA8xME4Vcdue9WIri1topUX57zIMI37Qg75H+elPpYtKzuadk9sDI9wiSsy5z 94xHOc498EfjUc02C1xNcLBZuAiiVcDOcDn3pDHGbY0cKwhnfO6ZRuYAD5V+h5NZ4+zySSMxMcsK MizmMGQc52A+maNhxV3Y/9D+TeK3jL+Y0ePMTaWA5Ip8FxNYXdvcwIyLZyebGqfcY99w96+VjK59 O1pYtald67Nu1PTbnSJUvwUudPb93JYtnO44559PbrUgaVrYIwRpTH+88v7mcc4q07O5EY7MzbC0 hu3uBcSMXtgAkbfemJ9vbFdX4dn+0ebFJcErazpDGsGB5hzjB5zkf5xXXQ96pG3czxCtTlJ9j9Dv g1Na2eiyNfeVKEb5kuYzvQMiohXHUfJnn1HFf0m/8EhdJ8rWZLuzchNfu4zcvMuYo3hG0qg7bFEf 4V/YvGbdDwijDvGCP5t4DXtfECrU7OX5n//R/rN/aWvI7H4XeIPJupLb+ztJnmtPs4AaYiEksW9B jJxnrX8Ff7UF1JrPj/xTcNslshq832eAw4uJQJSTPHjkq7MSCfev6V+jXD3MXP8Awn5F45e9LDRX dn5F/tLQ2N9pk2n2+mPPMsKyzTyExzMu872Kg4wq4x+NfndPHpxk2p5nkKAqJjaFxx+VfPePDvxN GHVQX5s9rwvhbJL9OYpxPFJKVG5bdeCWGNw9MV1FhIWKwl/LgVgRg4JX0NfglRWgj9HelQ3Tpsl3 PHFZWpkknbbHDu2s/pg1a06Py1e1kCSXC8zRA5SFgen6V5NZaWND/9L+MuG3e/Ji+zFDEpjjHBMv PJX8hXpngzSWewe0uo3LRNlS3EiKTlcHsc56V8fWR2wbd7nqsiRXeni1uriTzLaECN2Yh229Acda ybNrNElG27gvbVwVldCsMinup9Rg1wyVmWar2lverBPHcXn2+3BnW4jXcgzxnd378e9SXVzMFt4L HT5LCUMHup5JPMa5OfmkZccZ9P1qJK6sbRlfR7lu7tY0IuY7kB0RZAEYiWYA5wR27/nTruQSRyXT CS2Sc/KrfI78YH16VrRjpccXaTP/0/48H00QW7TSvHCJGEYI5lVz0yPQ8c1lS6FY3yKLuUXElvIH KNwF78evTp7CvnIK1Q89rSxJLZ+ULcW92wgSUvjdubPPf61Xu7i70+CYpMslwymRhtGYwemO/wCN bNXkyYxstSaylS90yN7jUFfU5QUkRotuxeilv89qu2BtvCNxFDqrR6mJWE6y2loLqHJGSp4OOOD7 04JKVijqbe0037N9q0+IQLcH7QiFdpw3OMdsVntdSm/VZsskjCPMUWDDx1I6YrqgvdHbQ//U/kK1 zSjaPJNo+qakxvY/L1aKaPbAIoxuQxAsQCT1wOcetcdbWsl/pIuiRHFczyWyurfeZDg59Oo/WuOm uiOZLqNvktbfTL17qe5CW1mXke3cefHgcFR9cV41cXBvw0FxcXFxEI8xmYllBPTjt+VdqXLCyKSv O7PqH9nt7hDHZOY5fKuElS4XCzRgOg8vb024xnvkD3r9ifhhcjS9U0O5iv0t1t9Ws7OG5eHy0KC4 hGSR3GN2e2K/tTwJftOE8RDtf8j+cfEeHs+N8HV84/mf3gf8E8dRN38MtDSNgZ7fR916yoALhpGK gM3t5RNeLf8ABVfSBN8J9Zub7T47iKUyR3UzfMjLLCqAPzwF2Dp2FfznSvS8UY8un71f+lH9KeJE I1OB5ylr+6v/AOSn/9X8tLZ7mOLT9RWRIIVh2StAMqEUkBkz7CuV1W3sdRmmMW5pXbDq67YnGOvN f64YZt0l6I/zTxKdkyW2to4o4LeB7ebygCNo2mMj+AD0FQahJEImuLeRPtayBJUB8vrkMQe+BXdd 8qsc1PcSynzHfx3TJKLUiOBYyH+1KRy49gcjn696zbC7R9UtovLaFnVngVG8tSqkDDeg5oesTrjd VIm/YeI7zTbm6ht7WxExaSa4YyCSZskAZyvPT/8AXV6HXvsiXTvZrbyvIZ0uIwDHukHzkgcdew4r X2NLdRVw9tVvZs//1vx3gu9Rt727vI7ppJLxgzIOYuBtzs6dOP8AIrbsrG2nu7K/EkMMkcrRGCQF FjDDDNgD7v05r/X10afI5WP82vaT5krlGS9utE1SWTT0jvniZlMSH/RpQ/3uPYE/kau38tjqtlve K3jtWuEuriCWMXEULowZflbI4YAjPPFYwo0pS95I6K06iikQC51K0hjaOSD7NbwlY5oraKCdUbgl ZFAIz3xTdKkEam6toY5H06bz4Lpow8kW7qpbqRnnnPWtXQp9jh9tW2uaEOqXGqEwrpNrZyXjLAI7 BSRMQ27eSeckjPtit66sY4fsLPPDqDNb+ZcNHC6tYHJwrblGSM9RkZPWsZ4elGS5UdGGq1HGTbP/ 1/yXkgu7S/VrC/kkyfN8lZWjiTPXcM4PSsm4NzNHJKXsbnzpNs9q0KeaRnJO4gkZ7fSv9e1hoNXP 84adaSeh3WmzLYQG8hklULZDFpCgKyMo+RQe23kZHHtT7TVZdSuGlubCZtOjdBdXAXzOTgspzgjn iq9jBPYc6jsZN9pMFpaXVzbXckCS3fnfZvNJSXzM/KozwBjOBVaC/jso41k2GVWI/duGRscHDDIP 1FY+y5o2WxpRqqNNXL8V/AsdzEWiD3Q89WSTM0eeCT6entiptLuQmoRTxRWkkVsmA23LytjB3sOf /wBVdfsYWsRPEvmTP//Q/JyTVZjd3mnk27OZGmMMK7RLk5XeM9eQK/bf/gll43/Zp0zxhp/hn4t2 2gQapqRitdNttY003VvbzkISGDAgFiy4YZzsYZ4Ir/UPxAwOMq8L42nlz/eKDa+Wp/Dnh7jMF/rL QeP+FySXq7WP6Yvi7+yn+z58Y/h60HhbwZ4PnmezdtN1G000QLb74yAzFSDw2ODnkAV+HPw3/wCC X/xY8C/tAxeLNP0qw/4RLTdYOoW66dcs8/yOGQeWw6FgOQx/w/ifhbjnHZVgcdluYzvzprXv/V/k 2f1hmnB2CrcU4DOsHC0YWvbZrz+R/Sr4S1/S/BPge1j8TXjaYUtBHctKhePdtKkcZPAAr+WP/gsf 8e/APjnU9J0zwFeQ63rOha+hNuRzKNrRSHd1Hl7j14HPPFR4J5bisd4gUcXRjeEJNtr1v+Wr8jwv HzNsPhOHvqd/fm9PTb/gH4L3V7bT3cVzdCS3aNvmwoeQeo49cCq6zz3jMRJHHFOTFFb7g0pA6FvT Oelf6QU6fuXP4Qx2I5sRJryX3H//0fysFollqKzXEbAQEbmkBAzzjA6cdq2LfUf7Qvbi1SYlY48r EUJWXkYB7A4yefSv9hvZr2m3Q/y7oTtRcelyH+0nfV3tbx3hcRfukYbfujPA9x3+lWbYB55zavJE hk3lkPzue+cVUodzopy13LwuUa3uFleSe6lkaaSSYfMyqP4vXGB+VZkN/PpulytaQpI8lwZEh+4s gJx/L+VaKmraj9qzYXxDE1nIyI0U0EYZ4YxhCAD0+uOlVbbxB9uBuBO0bsqiHKBZ4gCCwB9DtHFP k91xYOpqf//S/MLUdZfVLu9MQmWQFVNxkbY3xjjsKplnVzJduHdovlkRQNpHHze9f7E0o+6rn+Zc 6n7uyCDV1mJhQmF4FK+c5++M849BwKtXd3dQJbrBL+9nhaKMqQrMrcMB7HHNdigkrM8qdT3hbZdT hVYUw9uo3zCVv3cRH3Tz9cc0tpP/AKVd6hqmoxgAmQokQ81R0VUUfSpVNOZPO+RWLUOq6VLcNeCW WLPyRPcR+RNKP8+9V5tekuL6RrO+ubdYAY+OtxuAHJ6gYJ710eyQoza3P//T/MtJjPLcKbxxePaB uWyiKMjIHY8/jWTYT7dTd95Rx8kvUpIV7kV/s8o2Vmf5Z1avu2R0Em5k2Jcw+S771df+Wh54Hpjm s6eY20hMjbzt27l5GMU0kjKD0TM61vbhiltZxvIZ52JKx7mB7g9+ew+taN1YyGHzdpQ+YBKobZhv f8ulNq6sVzfvLkDXP2M28LIshmJBQt87jvgd+tbMt1bXFk9qWSCNlAdI/kl/76HIxWXLaSRpGV2r n//U/NyTVIrG1L2YczMgiYByB8vG4n/P6Vgi5lEk13ZSbJbgf6WJl80yEjGeeh96/wBm6cFZs/yz rVZOtYbcC4aOOLVNPvHS4TzrWcWjeTuXGCTjAHzCtu2+0XCW5iuntWUfOXi3HK9PwyB+dLEQUqLR VCbTPQ9FvrdLN47y3xeqv7qSFR5W8kfO3GcdflHc9a+tv2atVnj+JvhaEX1wGub6OV541XbEI3Qs GJ55Usv41zZ9T5uGcTBf8+5fkdPCLUONMDP/AKew/wDSj+5/4Cy/aPhpoO2VpPK0+GIMwwTiLHHt xX4k/wDBayxt7fStBvLm2jU2Xl39hdxp5gVwWUKw6HDbRj6V/nH4SP2Xi/h4/wDT234n9yfSAhz+ HFZ/3V+R/9X4teS6u7Vb8SXN5d3dwY3VkEbB0/dt+7AwvK9PrVXTdUNm0kV/JcStIWKoseUQDkkn sBX+6VNbM/xPxKtMz323zme1u44bC5TaEj/fAFSc9OnTpXUQXqLZWlvDcCSC1BT7oV1JOWGK2OKe 5zYupX1JnlVxDFJ+6BbLFRyD9a3b3UDfyDnyxFEsSgRrGJAOMnHf3PWtoqyOaXxFKSxmREa3d1I5 UAnepp9w901sBcXEfnlNjI0v+kSJn06/nVEPRH//1vim08ptORL6dpFsAz2hnj3Occ43ge3equnW UhvYNRBgjjM3miF85fGMHHTBr/eA/wAMOZoXVNVnW9kIhZJoXDw+dHm1YDoB0znHT3qjcXUVxcJc /YoIJ5xtCwLsRjjk4z+NNJt2EJZ3FsXube6JS8Me+2RSC2RyRjvkVONOk1cRmMxoImzNEc7hjBDf p+laqKjsNvTUjlkuIZmUt5YiGwKh27sd6fYzwNcRm9PloJAZZW/gAIyT+FWk3sS5Jbn/1/jtkjlF xtCJbhSyMTkyr2xjpx61nStp8dhFbsdpSQ4VfvyAnnmv96VFt2P8J2+rKckNpbrFFZzTPDGmMTnc QT1xRp1o9zPcNcCGRFi2W80nEkGSMqvqDjNbKNncwbb3HI95p2pOEtVuLa2h3yFmwcnHOR25FOS7 NwpvNjIWkKmNlwUx0pmcpNaIxNWSOGB72V3kCZlkjJLbAuCCF6ev5VoW8STmKZQqxzqrqw+fAIz8 34U2mtzNOzuf/9D4hvrOKCJp4zHIvCLnAkJAzjb1rQW+iksIfNbZI6jdBH1j7EA+3rX++Si72Z/g 5zqxl38logiktVuJVMIAikjxNkccD8sVn3mlXkU8ExMsUM9qJBDdAmU5wVYMeo6//Xra1tDFu2rN GGN4LUsxLmQYVVGQcfzqi4W6J+1IxVQAqkZxjgCglTQ6dGOILW62wFcmFs/itSWwkWVIUkVW/wBW uSByfegfPE//0fgq1We7udkaAmBsZU5Ltn8vTp6VPeWUd0VmjuXjdPmlibgoV7Z75r/fyC6n+CEp Xd2Q2wwGtYw4Erb2eT5gGPXHp0p8+iNGZZml814EyBF8y4JHJ/8AritBJ2d0Z3kmRQ+3bCG8sEnB z0xiplaKF/Lmi85gB5eRkIQQc/hTs7XLlLXQ0GvozJGkEMsNurB5HB3MDxnmsqfVLiO7W83ySvOd 0YC8v6/zrWK91FRejbP/0vz3mSW5MuZGXcd42nayd+K0Lb94sszyNLMvDGQ5Z8dMk/QV/wBBB/gf CSvdEH25ln8x/wB0VxkDhY+1F75dziOPJmgIkjA4icMckk9+AcUWKc3Ypvaw3yojzyxKrDcoGMkc 8GtbVtMjisIZ7MRusXDh2CsSeAc/561uopbGXOuhlWsTRRb5Y8H74VTnB61pw239oxysGRfLXcUd xG3fkZ+lMOdH/9P88yBg5DSt5gUbSMKueT+ArdLRW9uIUdJDkP8Au23Y3AdT+PT2r/oPex/gU5sb De25lEWqWP2uMfPDIjbQgAPB9T06elVfLW5zLDGsHlnBHc8npUpPlsJSaYXuoztBYWYs7YLC5Et1 Emyd1b++c4bBoSEhzO4Gz+HP8XpV2sROV7kr5VCzQZ3DPlscYpmofaJrVY4Zo0aRVeSSFg7xLn5l PoSPX1oM1JqJ/9T881AVwc4AG0N0J/zmrElrGUBiCnJ3MOm71/lX/QrBWVz/AACc29BJQkw8vy1J KYw3y44q26rHa26RLGjCLaroxLMORyc9asnmZUi0cy2xhk3qoX/Wbsuv+1n1qq0ILp++kYRYj3yc GYgbRn/61BUHZ2NC3NvDcJDNN5bBDLgqWGByOnrwPxqvPcTXM4IjeSIKf3+Plj5Hy/z/ACoNT//V /PuGBnlVVDsSjSAhcjCDJp4HnkPyzgbdrD5sD2r/AKG3HWyP8B79CpITFJvRVJU5KkZyR2xUkQgm R3lDLIMMikgDjk5pxjbclyS0IXuEMttujO0E4iJ2/XJFXIpnUOq7gXyAcYIB4xWg1JMbNBdWiJbz RSHzZVcqFHmLu5BbuBg9PSodRhgmmPlL5UI4ZUzxgUEua6H/1vzxhh81drchBwfWlNpGzopOCHGF PQEV/wBEB/gAtGOuV2vsQhihwcdDWjZzTkR+URBt++WONvvQbldpleaaGSQyTlyfM3ZDDnJ/PvUb uXWTT3aHaxEyyeWBNhc8BuozQTza2GSWcc2IZARGw+VTznnAqA6cIXV1J2JzGCcKuBj5axn8Q0f/ 1/z2t0lZ5Xuh5kSxMsCKMHdzgk+xOfwpsUTvbBpkRZkcnaPmwB0r/ofirJH+A42ILK6iUeUpJ7ct gZwB/nrRcsYFJQ745G+UYw0Q9G/GmA61ZGHk4UE/P5gALH2z/SrrWu4RuWIy+wbRkn9PpQJyS0ZR u43tLkiY7IiuYyBnOM5yfy/Wh2VwCeVIycf4UGLd2f/Q/OeXa/EfyqrcDOeKtCBZIwVY5T5gA2zp zg/4V/0QH/P+XbeOKWRDGoSUxhXBfIyO4zUF9ZyI2+R8ZPQtg/54oKUmhWyIC0kb7FIUFCV3fjQk dstxJcGESbgCgYZMYXpjH0/Wg0jK+hTmYgs8YDBm5/ven8hVeQhiOTkrkKRg+9BR/9H87LSDKS3A IYRHDjPKk9OKIWEvLudqZMaknac+g/AflX/RQf4DkU/lq0aJFITISzvjhcfy7flQ7bXwAyRjse1A EEyrJtYyMmCOVOC1W2kn8iBI52SOJiTGoG2XPrSsr3KUmlYeLdsrJJIxEigpHngYJHT/AD2qWaFZ 95ihIWP5n7gUxOTejP/S/O9IxbyLOshh8r52B4V/Y/z7U77A8kYuEUCKRzhlPU9TxX/RQf4DlWRA jhH7HBPpTjE0khInRYEGVjK5aQ9MZ/8A1UCcktB6eSrqLp0t4pGC+ZIpKxk8Dpmr82lrApC3Edwp bAMLbk55HPFBHP2MuWPylMcYOemTzUaOI8I+A2d3uRQDn2P/0/zgn8ycfaEw6EnZIRuRiMZpkUMz rlCqPnhiPl9+9f8ARQf8/wCafkxpG6yriULuRj1as3ymQk+cH7tH/FH6Z/KgBWmV3U4GB3UYGRUp dtp3qpjyHJIGQR0/z9KAJBLNKYriN3YlwwlDbWwPf6VLvZJ92WdC+cOeT9aAP//U/PSOKISzSmJV jmO4bvnCEYx+QAqExsyMCyMTk8DbgV/0UH/P+NjmUoIZYynOccK/tzVhV2rlVAPYkZB9DQBXaOKM pJIW3L8zsDtQ/h/jVhpoJArpGx28M2MjFAEEsW5CUGRnd0zii3YJcxSSIUjWMpKyHDHP19s1nNgf /9X86cKrszkAM2FGMH2rVils44IP9HcX6yFRIH3Rsp6YXHB49e1f9EB/z/laUO/nMyYZzh8jrj/I qxZ74gASSWPBY9B2FBLkomnJKjySjUFCbmG5to3HHA49f85qpdizlk22cZgt1GA0j73bH8THt9B6 UGT3Mpjtw0JEmG2kEZHpUsNtC75kDHJyc9Bn0qoK71CLsz//1vz0mjFrKWQleMKUPApnyrhYlaPK fvOflkOev+fSv+iflXY/5/eeIkc8UTG1uofPS5X5gFIClSCDn/69VJV8piB8wLYCAcnFTyK9xpp7 GjsWSCPzCsb7cFSMYH+TTbZ9Phhug0QlmDgZOcrwScD8RzV2sMrlGmt/LZh5AfeqYwQTj/AflTXA 4B4UDHtQB//X/N+dXQKWlQB3AQL94c8Z+tW3aRUCqcYXBzx/npX/AET2Sdz/AABjLl0IJo3RTKV3 4GTgZY+1R+Y0hacwiPcM7CMBfbFZzVpF86F3PKpl8lo0HBwpAXtUskrQPB5bbvMTzFZR8gIP3fr+ nFQJz7FyMzXjSSTybJjxvIwAOnOPaqYsXillZMbz8zMRksMf4UAp9z//0PzmUnfHshaKU/8APQgj Axz+PpWxP5bCOGIDcsf7+fdkSkk9B7dPwr/ogP8AAXmiZclrcW7eYx+U4Uc8dfSofK3EyZClSBju evb/AD1oJc9dCYKjTJJgCRVClxwQBVi4hnimt7m3YKjsTNtbEmMdcUGhTdHluzK0zO8hzt3cD3x/ nrWgkTAESSfKoPy56VlKLvcD/9H88vJ+zoksabI5yT5gT5pO2M1BIsUELMqLES+6SRRtJzjr2/8A 11/0MWP8Bx1na3dzO6xQSsiRmZpRjAA6985qy9pE0ql7gBGUkfLuZSM4BHuR+RoBO+xYCIsZAIK5 xnHSqrWySdTgqdy47E0Ck7IcBDHbywvG7hpVcFZNoRxnBI7+1SarYF7K2vI2Rz5mJYZHBlDddw9c /p3rKUWnciMnezP/0vzvS1aXywWIOOd33R70zyxJPItzJJ/o6mJVXkbuoz/nvX/Qgf4Dl23t3Jwg 3NnA55I96tNpl95cv2eBPtchVVy/y4yeMD17UFqb6kUun3EAjR9jmQ9F+Yqw4xTxGgd4b3fuUYPq T0wTQaRl1QyEot1HChECuDiUnKxgdj3qndi+uJyJJWEMSHyjGcbsZP3eMeuf51zmvP5H/9P4A0+O yuLaH7SdzWzl0Dj5wTx+I4/nVm7sxNDZTNL5EbuWkjRsMuw4VTjsa/6CD/BPn112M8u0UsskTlC5 ORnr2qMpcttdol2O3ySLjnHXNBoOw2dxcAhfmweKZbzF1mJIZWUqHQ4CnPegCSxl+yyF3Bds/KMc CrcgE0tyZFVYl5VosOTkdcfXNBLlZo//1PzytTbbC8ySRjzSiyYwzfhVk8SRCHeyqvl7mGOD1r/o IP8ABcseRC2/CNJIG+UnkKc1HcrcOVV9+AuAMYBoFKyWpC1o8UPmDDhveqtr5e6VGVcv821hzgYG aBKyiW4xDHIgT5V9BwBUl7bmFo5AyTxTL5gCsGMWOMEdeoP50GT3P//V+A4Z0nWSWfCEIEhjUYBI I5/L+dVW+ZjGOM/N5meMjtX/AEEH+B5MtvdRr9oiYB0OQxGRx7VFCybTLdQNcwrzIkZ2u2OQV60r XVmc7NW3UahZvJFG0PlqSoY/vVHTpUP2OGGzVpJ5HuN+3y3Gcj+9u/MVgdbl7tkVRfXFgUeMhI24 fPcD/wDXUqrHdZkaYhi2Sg6MOP8AP40ERl1R/9b4Vlit0haG2t8SRoGDFd24YOeOnNVLG7kggldY 3CodpDLgj6DrX/QAf4J85NaWsVzGtzAR502XeFsMVNVPtqwztaSR5klYqFwVwfYj0oNIy6o0POkV o4JLcOsbkEE5KgDue9VTNtaXy0ZA/wAuOwoKcm9GZsX2kXJWOWYQhcyQ7SEY54Oe/FXZo0LqqMUy OcryaCXorn//1/g9VCwGCZlWLO6QsACcH1pIoba4nZTPGFVP3boMuw4ON3+e1f7/ALP8EXJsz2V4 pYZFtYJypaM+dk5B4yfXHX8Kt6dN9luZBK5tPLz5ciKJVY4zyPrxSl8LMua0rMtiQBDJM+WJzuA4 b3rPki852uEfasa4x3NYl+g5Zb2aJY4YnlckCPdkIhJAyfpWnNLd2G11Z7lkUJNMy/u3YcHB9KC+ d2P/0PiJ9b8pEYnJkXYQRwm4EcfnWR9rW6aRh8sVq2yRW+UseDkfmK/30lHqj/BaMr6ofGY2TIUM HHy8Y9eatwCOPf5yufk+U+/aszTndrAl3LLKltvVIx97auDEP65q+JLYQmGNR50gKecw3hAeOAe/ vQYObvZELtbWtutjN+/l3lmuNwAdSBxtx2IJ696qyi28vyokCbjneCQ7f5x0rNw7FRlfQ//R+L7P S7ZBHdtcKxALNCeGj29/cGqt3OJoyyopQSYLJyV9M1/vVyM/wXWmxPD9okhjk01mgnVtszyEGPGB g/zzVO5nhEqx3MccYVy1xIjbFkJPUGpNINt2ZaNza3drPE/2gMq4t2YhY1HIJYcn8iKx1urmW2az LOyldrOT8wA9DWUo2dkdMNrALdpISFCNLtwgP3jjv+dbVjNNbWf2dypZ8MRj7rAY4oUL9Sz/0vim GO8tpZ55txhlQCLbDgRnnO5v6VKEjs5LfUnkF1chHRIXYmJQcc46buOD1Ff7wH+E+xXm8oMLqRQk lwc4H8OelacRuY7aRpwZ1A3xp/dz0P8An0pNXVmaqfczJ3ErG4VPMVcRPOVwu7GcCqslvM9rNbmz jljugA0zjbLCBnlGByM5/SmVdFi1MljaRRuztBEDCsT5dgCMdTzXSvOF063c3cbQ7PLQ5zLH/sBe vFYNNbmkZW0Z/9P5AkgtH0u7glDNNPgKxbbgDPGMd8/pVMtPpsWnSabdTqYYzE9q0Q8pcDG0DkEY r/dg/wANk09i5ZahaRrFLfRsDM4JBXHfrn/CszVLTy7nz4pn3TyYT5sbSey0mrjJLVHhDxIA9yQQ ZZeiY7YpbuGOSwzDJ/p6SBX3jAlGQDtA6YGTUTi73RcZcujM68kK2cBZn/dvlmZMM5HUDrnr/KrO myaZNqrtJPPcXl7ahfIA2tDIvIYe3b8aza6GkJ6n/9T5EjaeVPst7LG26T9ysa7QpAwFPqevPvVN 7KSaS7+xmHzoYPNMbkRBsFV2r2ycg/nX+5bg+h/iLzouzQxraRFrefzNqjaT86HGSQeK63QJIpJ9 Mj/csz38NrsuxuUl3CgEHuc8e9edmCawlVr+V/kz6DI2pZlQi9ueP5o/tc/YOs0i+FWkCGMQC3to lVEiCSGPYCu7HXqOvrXhf/BWXWW0/wCBOuQAWztPZXEubglFBSzm25H/AAL8yK/yryaLqeMsUv8A oIf5s/1T4skqHhNUv/z4X5H8fMcU15qKaa080McekC+SdINzT7Ig4CqDwW9K/Lr9o7VpbjxbplvZ h5rSe0uZ55GBEds6yKrKx/vtkNg/3j6Gv738a5On4ZY1f9O3/wCkn8OeAVPn8QqUu0v1P//V/ljv WhtWZVCMZG2sOu2q7zRxRBG2ybuV9jXg4mFsS5f1ue1TqWopGfNZpcsZZXDmOIizUvhUfPOR3GP5 1nTmYgrBJEViAVwrfMCTzQtEyHNNkgZLSMsyxzy+WHjXcPn9j6VPot5PpcstzaRvB9oJMsCykxtn 7wIPHNYQi4u4VKiehA9/Kb1/MjESn5sjG3HpU894BCzKylG+Q7cbhn2pTi3W5yYzSjyn/9b+Tc2c CRlpJnd5V2+Vt4XrzmqiWMDlpiXh8hg0UpYguQeQK+ZqJupGXY9NT5YOI+LVYdTkumeZHMdyYm8t do+Xgirce22ubiSJhJarEHDHACHGT+VJu7MnJJ2I21CK5lgmiXzEZMeYv3sDpn2qO51+18ia2WCK S6gUyp1SRh2X05IpC51Y5afWrad5bY2+oQSgLhpbJ0iJbsrdK1H06axnt7l44pIp7baJVbczHrjj oR6e1ZzQ1NN2P//X/kktpxOskbc44V16rSLdLFFco6t9pEWLKQfdjlDD5iPpnpXx7vy8p3xa5roi 0O88Vay9y/jLU/7TiVlRS7q0McKkBEjQ9NvXnua25ksRLIbYGVF3JFLIm1mGef6dKUNEjWMruzMO OMCSUxhj5hAJJ+UY9quKhIO2Z43j+XEfOT2Irabulc0ptRbKsh1uaZLeWOMRwHe08cmxZQeny+vW pXZLDdc3EwTgAKTyT6YrDls00dfPo/Q//9D+TC0vLhbmGWNJHkYgLEV/dsOxOeMVYvbtpmZUjWN8 /vAqhR+Qr46S5ndn0kanKrGdaxw5LS7mbdjd/CtX3hiSMKnmbXOQFyQpPOac1eJSqW2EuEX5MswC qAccZ+lV7qd9gCOygD93g8j8Kcm5R5WNVUpXQsFxMYyH3xp/FOPlJNVrh5ljCM7SMx4l9j6mrpS5 ItXJnPmaZ//R/kl0q2vSkpuGQiM78eZ95fxx+Q9a3NYubbVbOIQxNFPG3lkKB5cq45b2ORXxrg5V eY+nda0OUxbS1SaJ4kIWaLgE9SR2qCawvJVgnJ8sRuVePO6RwPb9a66dS0GjhqvmasZV3Fqs+sW9 jZx23kTRbFZsiZZOxz0wPQ1oSf2hax7LwRLeQL9ml+zLt+1bTxu/z2rnm+aNjem7L5f8A1rNp2s4 pbryUuI8mMbgT6YqOSV2hu907LciBlgfGRuOB17VUJckWkY1dZKx/9L+SQ3rRIlokrPiMO3XnjBO frSPHOMSwyBkYZZs8Gvjz3oL3SGKxvLiSdvOihtzEArAZuN57gHjGP1qutjbW7SzwmW6uVcQNPKh XnjIGOMe44oKL9va3U0zfZA/2kx4wVyD3HHfvV9r6U2tnFJK8955jJdmWHaFYcAnPXvQBa0K+j0m /FrLKbrU2PnWLqolifPVPTIz0qrJbb5Jw4Mdz5rMYx0UE+lBtC1j/9P+TuKcQAQzHO0ZJxyKjN9A ltFdLE0sDTGNY3DKspGcgsOR3r5KG59NJ2RLZfZGlklgt7e1+2N+9hjbiM9AeefxNStJe2shgS3j lV22iYvzGOzAdDWoRlfQlt4WtXN2cSlp1hKqcyDd1Yj0FXPDmjJc6wr/AGaVbb7er3ssU5hEm1gc qfXp0Fd2CjzVoLzX5nJjJctCpfs/yP018CWkNh4dt57eUtcWlqt7KZ0Dxq4RcoV74I7+9f1Ef8Ee tLF/Yzaj5jXo1awhkV5o/JltZHjgeSRFAwuVQJ+Br+wfEp+x8LKEe/J+R/PPhrTc+M69T/F+Z//U /qj/AGtZbC0+E+p3E80sDTaVeW624x902zbsD1OMD61/Bh8Tf7QvvEWsatYyKLmzOoWlpdXfSWJL tliQLgj5Y09s568V/Uv0baS+pYqfmvyPxzxuk/rOHj6n4+ftW+JZor600ieZmnJ+ztfWTCMoAiZW Q4HQnb65Br4PvI5JykdgxbyBmVmPM3r9a+H8dZX4va7QR9N4aK3D8H5sY29t0YzGzKNwYYC4rqNC he4UxEK7woWyWCnavfk8/QV+GVV7tkff/bOqtrmZ7yKCFpIZbdRJHcAkAY/un1GOldDcDT4PLnjA iurn5ZHVP9YQMkn64ry60TY//9X+Nm1vHSB44E+zyvG0fngCRlBPVQfoK9c8JTRS6aEjutt0rFiX PyjHbJ78dPfivkq0eh2wTW52cVv9okeczAsAPkUAJ+FURO093Jbthp+AkYBywGBtHr26VxONyzVF 3q+lSssAgjMOPJVOXU9y3Yj2+tTJqdxLG9vdWtx9tmuFKXDnzIWQ53NkDIOSMA+lZNNbgtNhs2lz qXk8oiZoyFlx8wHXj+dUoX0jUzaQay92TZt+5IiaTc0Y+U44WtqKbukVGVtz/9b+OeaW5lXZktEx +bPGceoqBC8cErqgJX5d3YD3rwIx966OOorMoxXtit1GLy8WztncIbiQbooiTySB/KuiuLF7y/u4 5WtY4LKzT7PNAQWvI2IxIR2J3Djnj8qtxblchJvYzJtLnjEP2NYkh88C4uHXdsTncT/QVsW0Nuup z2wnjvrG3VBBdSLt804+bAPTHSlFe8NRbOl/cr80bgKuBtPKqPYU2KbT7Z5Zr6Ey28bbpposncnU heOtdcPhNUklY//X/kR8TSQ6pp9neaV9t06xMyqrOpTeE7MCAcEDp0rFhsLq4sXZJCSsmYLfBVZT jHmDt7etctLoc5zRttOa6FhqKsdSuIXEz28fmmMrkqjnpz05/wAK831eBLS7C3UDK3nCKONergnC 59K7Le6NaO59SfBLQ7e41DSHsJltyyv9si37lDBwTux34U49K/WDRNdsS2mmezf7BYTWkjRwwjdJ 5bRtkKPplvUE9a/sz6Psr8OYqHm/yP558Uk48S4Sr6fmf3C/8EtfEMWv/A7Q5bWUz3zzBbmaNPLh e2RcxkA+u9jx6Gui/wCCnGi3Wr/A/XI9qNatcPFcvI5RhGbbOEA642Oc+tfz/jY/VfFOKl0rL8z+ ieN5/WvDeVaH2qF//JT/0PzDEN3pujXmj3T+Zdac8MIMUYlhvIxGjFlb0JJ5+tcLFNBcahPBJDPG kC73ljjyi54UMewyRX+t2Dalh4yWzSP81sVomn3/AFC7WOzmimhK+bJJtEUY5fjBP4/1rOW2guzP PPNLHawttO1MkSEZAxxkepGcc9elemotRucqkti/cWVq9vHcaMLtzGq/2hvcAquQMx4HGfcdxVaK 6js7kedA07+Vsh+0E+agPzLjPbPNWoXRrze9dnQGxi1TTDcQ2EUWpJYldUvLcMwYq2V68KMFV/Lr VKPTNdXT41n0cx2kyCKGViWZiMcn0B7Z61q0thp3lc//0fx/i0q/CTSFIk8l9sbLJ98YBP5GiwS4 klljlLI5QpG4XLhvYV/sM4rlsj/NVz5WmiWz0wIyQXcjv1ElyV2B8/8A6+1adrYq8Nxp9tCiW0kw lkAOQSoPzMfpk1hGHvXNJVuaNmYk8E1vNJE3lSWCwyW8EcMu5ScY8w/Q8ge1XrDzdN0uK2hj857w NLPOvyibgKPlHT7vP4VclZmHOyzZWAS1ssz4lnRpY9zfvW+Y449q1LZ7uyvorOR2eWKENJ5se7zN w79jx1+tQ4czRVKooJpH/9L8oSkcUtxMArTQMVKOdvDL94D8a467dInla3cZfluMY9QK/wBhFDSz P814T10NfTtRnSFkaUbHXCjHII61ahv72WSG3t4pzaz3AVkLeWjOqn5sHGfTjPWjk1LlJNWOWmsJ 9cvLm6+335t7e7+ziIysbW3bn5QvTnafyr0IaRp1xa2sN1G6SW4GJoHMYkx2NNQsrIhTSdrlLUtG a1Xz48JHPCYYmU5fGai0G2e2ukjeN5FPKRRDmV855/I/nVkS3R//0/yqli0/+1bgLOkF1KcsksW4 tyGwpx+v1rqtB1OXS9cTW7ZIzqtjGr6fcfMHikjYMjAKRnBA6/8A16/15xVBVqEqclo0195/nFl+ KeDxUa8HZxkpJ9mrP9D97v2VP+C31h8L/CVp4U8c+H11u6sgtkkj6HdF2WJVUlSF6HA65IIPNfWf /D+z4USwSXz+HdNtIXZoYkOlXKyJKDna+/aoHP8AezX8e5/4BZ3iM4r18DG9GbbTTit/JtNeenpd H9L4Lx4wEcLTjW92UY66N2fyVn5fo9Dw741f8Fq/BvjvwB4i06w8HxQahc2zW+jXiWE8VuzyqY96 AZGVJ3BiQAR6Zr+e7XvE0viXX7nxTezpcTTpGJYwyhZBGm0r8oA5x1AySfpX6r4Q+GOK4GlicRmE f3k9Fqnp1+F2W3U/K/E/xBw3GfsVhndQt0a2btv1/wAjznVjbXESXixXsNzd3Du0DoAsHJIwQT8u B1PqK521m1BJ5riJG3RXiGHYBu2jZn+Tcmv6DhFxjY/Cq7jOo2f/1Pyav0vNYvbGa9v2j0yK7SeR vmfa24EbvUZAyBVy/wBTudL1drONbW6glmEc1xYkeUyMAwZOOoyM/iK/2Ptrc/yyov3OUdbW6XOp 3k8l1bWkUNqZILm7cF89NmO/B7Vr2OmXtv5t3p19CY7SFpboQ/NGvAOWz0/+vVOLbOiDSepQ0+bU dbspdTnhFvE9wbaBF4AC5DN+Jz+VSNqMH25NJAd2SPcs0q+XvwOcL/8AXqpJvSxaatub9vpjX72l laNZrJcsTKbmUW6DbnIZzgDOPXvWLNoep2N9c/6NElsYi0UqOJIuvIQ57Y6/rQk7WsO63uf/1fyr s7VLgiZIi8Tj5lALeYynr+lSSI6xSSYZkDYEYHzHORgZNf7Jxg0f5eSqaWHyaU0MTTkQ7CFygkBk O7tioJTM8Qit1SBok/dyFcvGw4xj09q1XkcU7aj2GrXltJai7nt/P2xzyQcbgCDnA/GrD6Ja/apJ 55CUEO0EfKGI6Z9v8aqMXzcxm5rk5Cn9qin3wvbOIYWa3jOPvY6MvtkioLSCa3mmntUMvmJ5MymE OAMjBwQcHgcjmtiYtppH/9b8yrHT7IMZJmkubi6hZEt1byXgIA+Y8cgE5rNfTbn7an2J4Aox55mJ wMHke5Ir/aFJvY/yplubmp6JqVjbwXTW6tAU82ERSALz+PfJqqIYZLdZnePZJwVLqZUI6gr1FCi2 Ck0ZsVvsM4sJrm3u1P8Ao1xGwSLnv/n3qextp5o53kvGuJYV3O7kfO2cdOnemoNg563NGDSYp7a1 vNSCNJE7/Z7or5TYz0wD24p8+n/ZR9qMKmC7by4WTMiyY4/n1+tS0U52kkf/1/zQs5bSCSZLq3l8 so0aFlwittO3r15xT4ItM0+KVrq3uLi9kYMhhlWK1Ax/Em0n9a/2jjF2aP8AKmc/3tzOg1q9vtWZ ftU62awC2jsjJuhXnrj8x+NbeqG4tHtfJjh+zSk+ZJ5mJEx32/jTnC8bFQq2Ujf0WK+hurYX7N5U p+026SKUjkjZcqc9+OfwFfXf7Pk8a+PdFufKeOGG4I3oQY2ztVc/m3HtWGcQvkWJh/cl/wCks34Z quHFWBf/AE9p/wDpSP7oP2a9UW9+GPh0lEGzTYlbauORGM/zWvyU/wCCxvh99R8DzR3LzfZbPTpb qGUp5i2+2YTB/oDGvHsa/wA0fDaXsvGOgv8Ap+v/AEo/vjx1j7Tw1rf4I/kf/9D42F3KbKA36RrN cMWluolMcRJ6vjqM5z7VoTxStp72Vu8DWW1UEkC5eQEAncxGeefrX+6VH4fuP8UMU17TQ5m9sUsL O3sbe2SGOaQys0EQjAIAySR3Of0qhYwus7CNWLFcuMZDY4Ga36WOCbXNYpy33n6pNaFljMABmCjD EHpj34rQt5IUguHl8ye4P7u3gBxjJwGHrjk81uc0ndmhb3MttEqyErPG+PKKn5R2z/hWvp2oaTNc k3cZFyP+PdWRWhmf+6ST+nemld2Mpvof/9H4zsJ7m8u3S4SO2s7bc7lFVSRn0GB/hUN1dQ3V6qmY SrEAiMiCNVVeAOOv1r/eXkR/hY52dkQ+IIZg1mdiLYNB9olu2YMrYbbsUDJ3d+alaWzjsyywowRR zgFuoxzVpJaIjmkSaRc6TJJvVLS4u7b/AF0iwfv4iwJwzEZ6enFaN5eWlsJ7i3sorWadlDTq/wB4 DgKB70Cu3ucdPavdTxyzM6q1wsoYfIw2kcemOOfrWjf6aFLSK4kM+AsSjeWJ65xWtNaGUm07H//S +G7Sa9tIzbywOIipWMshUHHYfSobm0Sd4pAr741LhATgn6V/vgf4PSdlcfEI7gqrFo9p2SllKIp6 EAmr4htbS+jt7l5nSSISwG3YMkhOCNxHTqevNBlzStYt30E4DiEttkTaxTnA4+8PTIFZ6aRc3FnL cpceU8I2KjDCSdCW/DH+NaKHczckg0nTbuNLrUA8V3bhTHJFcKJVTjBJH48fSlt2+wwbU2ON+VXI HlgdgPT/AArSye5Kn3P/0/hO/cXJaVCUAXBjB4B9qS1vInSKCbEIERUyBcvv5IyPToPwr/fix/gp zos2S+Yt4EDXVwgT7M07CNE4O7OB6jj6miOG6l1Wym1d3lELiWaG2k2xsuMFcemOmaDNtsdd3Ts5 SMfZ0jkIiw3IGeufemmd7l/LYg7VwZMYoSvoibozYLJ/PuZIUlmmLjAGXAUD5senTP4VBPDELeWa GS4mkkn3i0df3kY44RvQHsa1UFbUlzXQ/9T4n0i1me1hgt5Y0In86VZkxKvTPzAZ7Diqt/Zsuo3L K23zMFoxxGSBy341/wBAB/gQ23uRrO1uUKrGcHDAoGLfSpEt5Z2d2kaEN8zIfusPQ/j/ACoBNpmY 1wsEjoYVMh4VTkqMdD+lVHBluUllLQu67FRVwkgGOcfh1+tXH4WXKTTsi2sklvI0BQiJl8zzdoZF HoTUz6ZKII7rIuLbdmGZFzGGIyV9iK0jsi4u6P/V+CQyQkNcRNIkmIxtB3Jk43fh15qqH2tJaxuA GckPgZxX/QQf4EJ2d0OlgeIKINkjuQo83+L1/wA+1OnMRdoZHR2iwpaEbY2x6EYp2e4Nt7jYjAY3 xw3bPGKuSJI1ozF0khChhEWBYnPHH4VsndXJTT2Guq3BtYA/2eNgolmKZ8sE/McDrTJUtYJbm3gu DMsUnklxxuBGRn6gg/jTBtJan//W/Pf7EIfOSGYnKApCeCMirdpBElvPFMqwzxDJBfDt7BT1r/oQ P8BOdWIIkdgdxKrGCdx5zjoKuo6rEG8t1Eg+VWG3dRYzu9SNrklIY5IgIo5CdygB2z1yav8AyGBc nhjkccLQJt2bKk4IaKQltgyi84Vz9O9ZksZUyeXb3EkMrbJjACfLzxk+1UkmhRd0f//X/PZ7J44W 2+YEiAKlhuYgYH1q7b25nhDRuE2YZt3ytj6Gv+hg/wCf8zjKiXxCMtzbodpYZGD/ABD8M4/CtW3g hmkYTSeRBGSYiB88i44wOxz60AWFuZ49PLGELG8jQCTfkqB/9Y1nSeV5KKV34Abef4SD1PvxTSvc ChepcQ+U8e2cSYVhnDIvHI+nt6Vb81Y4lt4Q7bsu+R09RmkVzM//0PgbFxshktVcJHkE7Mg5OCCa ZbuZdYTzVjgjAVphGp+UAemfx+pr/ocbtJ3P8AVKwt1Ml3dzSpEYo432oXAAcDvVC4traVomMq79 42BTyT7flVRad7EkssThxCmN2dqlhzmpbSC8j5uEVigwzIm1R+H+elUBLHqUR3iRJI7iNiqNw6OB wPp+v6VnzJPIZJgpbcSxwBtoE2luf//R/PizhnaNJgBHIrZ8onIOPXtVO8L+bcT+YNoQMVRCFXHX H5/p9K/6ID/n/I4mmjEQw24KGBcfMfQnNaUEhIkGN02NzADCk84oHdrQpxIQzXLxx/aljMbqrEqv fGfyNaThZ7SFvKSOdCQZB1YHt+lAJ63M+SK7UMwy4UfcUYb+dXCr+Rb2/lmB4FPnNKSzuSSeR2I4 GPapcbvU1jK5/9L8+EuBGRBI4Cu23f2H4D/PFJnZna5ZVUqCf4z0z/n1r/ogStof4DjI7Gdp9Oup TKsAnOFjGVk4w35VBcsz3EkMkTIvRCRlXzmgyc29iVLF9qRW7hJhzuc8YHX9BU8DTwsXlmJH3Ah4 QH/69BLd3cndLlpGF9byQjAK7lyGB5yD/wDqpYtPjbLNKBGQePTg8Y/CgR//0/zuuoBEBtV1TcED IhbqcUxhsjSONpP3eBIznl/896/6ID/n/L0MebSa9Cj9xNHDjOHO/dzj2walZprlS8mSIwCcDhR2 J/T86ALMgt5LVQzlzkEqvHA5znP6VSCB989nOJIUfyyEOHT6inFa6lRdmVnT5ixQhuiY4Vsdz705 4YXSG/s7wLqNm7QywPBhYs4OeeGGAD7ZrZJLY1vpc//U/PFIpVt5fMABnPmNKgwshHHI7dOlJpbQ x38U9yjPaRwOskcX+skfqjAngYxzX/RQf4DRd0WIpnube4knjjj8tvNLZG9BnAyffI/SqeJHDEJu j6FgvAoGQRwQXSyGOcEo+yPjhSPWpBBMg+Zg+zglFwD74oAmWNLgqJ3dPKO5NpIyQMgfj/WmkYke fdsjUf6stjfz2FAN23P/1fzpnkEsRCEjPRscjtU9lb3LRmYHLp8u1WIU45+7X/RQf4Byn0Ql0HlL K8ew8Hd3/CkFrbW8C3l+10bK0bz5fssfnMnOAWXBOMkcjp+FBmS3MUMy+bEZXQ/MnnR7HweRkdqp QPLvdIw529Ac/pQBft3hdtkjAOOGJH3frUZs41kfdKJcH5GHRutAH//W/PJZnhjNqzKLdj8sYGAh 45H1wOlRBGWR12kRp/q3DcNx1r/ooP8An/CWQMAOSwOOvSmLK8fyvEriRghbHzKKALDQRIsvCHy2 w2DyB3Pr2/Wo3lt2KR26M6GPc0gwUOO3+fSgCS1hWcxOjFY1UoExhTyOSPb+tWLqy8lEcfNknB9K CFK6P//X/PWJDJ8h3YHOc4BpLiMrhUcR8gsSm7cBzgen1r/ooP8An8l8Nyu9sJirJlpc/Kq81IsT TAxzNJEqcoU6tjsfY1Mm0tAhsQG1upjlEcW4P3j0PbFWVtpkiYwMBjDSxscKcHoeaIv3bss29Pu7 Oa2urM2UhuTEBE/+1wcj1+lU5yi24jZVWT7uQOcisnuZObvof//Q/O5V3De5yV+6G+UZFJEz3TRu YhEYsxk5wWOTz/ntiv8AogP+frnZoP5iqykxgKwD9HJx6H/Cmr5jmNIhuyRu6jApxV3qS23uJey+ Uyl4pJUEg37PnYDOM024Th1jZx5ibkwvAzxQle7QimiyQCPZlt3DhhyKvrOrIVYbSDjpitoqyA// 0fz1ml+WJTuZE4Utz9aI2DZJGVHTHUV/0UH/AD7khEFzGHXKYYoZJAQqkEj+lUWjMmMY+XjI6mgB ksMiSKJgxVee+4U8x8/uxjceh60HQNP2mCZdqq8Sn51xuB69/wDCrUoS5j+dTGOvHBz2oA//0vzq jeITpHLA9xGuWKo2zBHIJOD3HYflTnVpYwVjKSeaFQMMAjOP/r1/0UH/AD/mhcxR2atFIyvKuApz 8uf8mstmZ12+UM7tx449qzqdAJ1LSQtuA3j5GVTgD8PpTYbYOMzE/uGDqOy45rMC2zMTIhjVUYYG ByR/SnxvlWXdkbe3XvQB/9P87o7+HzliuAZedigHa4Az0POOlJNMHuzbNbXdowIkjkI3RMpwV59/ ev8AogP+f8sSTO5MMhLBEBMgGFHb/CqD7gw2YK46mgB6gKF3yJKW5+RSu32Oas8lSASRjPuMUDUn HYZHZv8AJcboyu8jbnEi++Owqa6eOKSMh8yNzt6/nxQU5u1j/9T4BgnQQXEcz5XAaGPHCNzn+n5G q9sk0m6SWPfmRvlI2hgGOP0r/obnuf8AP+WzJcKkjMqxJI3CR5Ube2f1qrbQ24V45Im2li0bbydr E53c59ag1p7FprZW2wo5hRgA7sQWJA+nAJFK1oiIqwyqJW4G/kMfagme5nmFYzKZELs5B+8Qqkf5 FEbtKNhVioHJ7ConsKHxI//V+B7WzWRHkWfhFxtJHBHt1qrHJHbiYiMTGRw0mRk8YHBPTiv+hA/w HLDMLeZHQBTN+9SLduIH+RUpmkQyygn5yAzEmgPIz4ZSs3lrJjCkgMSzUty/ktudSwxzI33XPpSb srlRfKzPWVpp1KRlSY2YnOQu3BP5/wBKsxqJ2HmOAqIfn6Hkjj/PpWBfOuh//9b4IQWNtaPIGRZF XbGjAlpS2Rn0468+lV9PdoYpWmmFypOUjlQNg55x7V/0EH+BfPr5FS4WOUsJfk+YN8g2qv5U9rac RNFDMbhF+YeWCCw/Q0Gqk47Eu63tlXCySNIAHDfOEbpwPStO2itWheFQi5zIy7Bk/Q/0oBtvcz7n dM+87EWGPyY1QbSfQkDqfeqECsjlk35IIbkkc9qttcqQj//X/Pk2okBdwcH7oXgg+tW7Jnhhlimm h2AkqzR/vF9B3Pav+gg/wRUmiCyeaV5EilR5FRpWUsELBASep9jj3rUgN1NbRM9x5reYV8qTgwD2 9qCb6alO4SBG8mNpmdWy5ddsZPonc1oNA0WmzIphRZSCmUUzDkcbsZ7DjNBPPEwIo58+SYR8pJ3g 5Y1OirEpQqVViWbPYk80C50f/9D89p0JO2Ifu4xknHT1/nUEV1blJGRi4iJEjEYCkda/6CD/AAJb bZr2l1JcRbEMSxGPfvY/McdABjoef0pI8HcjAKg4IXjj/IoMpuyJTZ3MK+dCs8VtJlA2CpcY/qDU jK32RUdt4GSikfvB9e/pXOdMvhM5j5mxNpO04ORzUp0xjLayLKIJC+XRmKhU/vH8aCafU//R+EWW RWnd5lcKcNKnCv6Y/wD1dqhyQnK71bjyx/FX/QAf4HlOzuJrQuEXlGySBkAdMVJcNZXKefHdoWjk PnTSLt2n8PTOPwoKUnHREsCTyQFY2cchmd14I7HPvmrGLWG1meW4cXC7RBAke/zyTyA3Y/X0oK53 1FtIpZXMiRtCYkBfznXnPcAdunWq91jzCIQ5lA3M4GFz7UESm7an/9L4HIMrxRsC42/vs8c5xx+F V57eS33SxEnbwoQcj2xX+/7SejP8DOdG5o6XLWfkX9iyvMxe1ymZJFYcNn+XWqc+myxEq4IYHo3J X60ONzNu7uQSJMsKCQhV8zYqhdxbnngfzou4ZI3aCEbYAfvdHceuPf8ArWfIzWLurE7JKLEwpLJG 3QMjYdAeuD+f51HHbS29oYVeeSNlEjLJkqT1z/8AXqWmtGUf/9P4KtnjxzHvlQkJuQOmRxypqsxk aWW3mt2QMBJwm1MH09q/34P8ELtbFmO3YuItxUrGXU4O3gHjPvWzbRTG3Ls6konULuG4DpilZXua c3u3KWmi9kAgfbPclHZpGhCBAOTz7e9RIQk6qZ1jXzApZkLfUYqJrqZEl1YvdXZSGYN8wEbx5KHp j/P1pskYsb2SxmLSzoAN0YzED3+bocVmaU0f/9T4alkzLFGNxJXDBTwuB6VnskgZhEJNrtx2Tiv9 8D/Bc6FGlkjjs7cm2RQslzPkDcByy8+uCKp6pHFOoMURZ1fLKOFZQO35VzlQ+JFSFwkd0ZiqRMip CrnbKp7k/l0q9Bp8rwyNazr5U9udzOojMWDyc55HH6VE0+h1UyEWMVtHGyztJLjPmA5Vx1/+vUn2 ud3hjt4QzxvnzT827pnI6cf1rNNo0P/V+Q380Kgd18uQYmXHH4Vk3ltBBI6pltvK4PGSOtf7wH+E sm0tDBulltEDvN53mPiNR1XJwAK19LvLpnuIpiEPkiOEP8wfjtQOLuh8VrZ2VwkMplLK2ZY3YsAe 5+tat/aP8lxG2bFiEEqONpJBO0j8P0oGYdx5lzst4NqKX2hnOPbJqYaXPZWzXrqk0UJZNzknBOBl ecZ6flUT2KUmj//W+KJtTTUUiiiia1ktlBMxO4ykDk+3fj3qXR7yd7x4boxy20zbT5wx5ZJwWDdR X+7B/hfCfVDtaine5u7TTbKaezsVDNebgYguOWHc1npZW93Ba+XevLcrkyp5ZHkEHAGc85FA2+5r rYKYjh3eQ8gIxEjFeeMfSqFvqENzLJG0TRSRqWWSTAjkwOec8H270DjNobby293/AAmZw+1fY59K tXUNlp8sEkaSG8dsKxIWNB/EenWsZO7NYT1P/9f4pmeC4Qqssn2lnAt3jbYEOec8c1uC0urSNEkd JrjcHEjqFRv7vA75Ar/c9uyP8POa+xfgnvY7S7TUIY3Y4dJ/l+QLzhcDI6da1Ph7KNd8UeF4rOGT dc+JLOCeORRFiMXCF2UtxkBSRivJzOfJl9aS6Rl+TPqOG4e0znDU3s6kP/Skf3P/ALG2kR6d8JPD 0ygl2s0tpZT8pkMY8vJx1yEU/Wvgn/gsLq1qvwsu9LERuLs2Uk4jklC29z5iAbD35Ef6Gv8ALHhP 974yQf8A0/f5s/1T8QF7LwpqL/pyvyP5LodRhs9N827+1adcXQH2j7KB59rGVUOiPyeVXaDg4zX5 jfHW5tItV1KzsYTJDHMzxT3LFpwpIK7zjlyT8xFf3T461eTwzxq/uP8A9JP4t+j3TT49h5P9T//Q /lGuFkjRZZAiSSsXlhVi5i9gazpr0qFDRkbjhWzk4rzcRG82zrjK0EaWneVJcWsIjidkYnzZcndu 4x7f/Xra1rwnf+FZkuZbMyWd8AqLalZo4GILEFlOAR6e9Y2XUOdnEJvkmn8yJrUCTEJc4JHQfn6V ZmW/t7O4niEcxidBKGkEfDkjjvxg9Kwas7Cc2yIeZcDeE4Ve/AqojR5ka5Dq6jYFjPIx6CkLma6n /9H+SVLuO4kCoLtYY3A3TQmF36ZGD26ipNRnkZQsDbYh95dvCewr586G+rMy2JmV8RrFhjtboz+5 rTt38qOSKWRY0HLqeVk7cVg1Z2I51ewrtFDGskIjh8o52qcJtHoKjR7S5cz/AGaFJcYUhBnPr+NI sqal/aE7wo907QYA8tjuXC8DHcYq3+5jtmiDOTEm/Lnl39B7VMo3QH//0v5IrC3W2sUMUaxHeWkU ZfqSetRKkSlDAGkWWQuwYE7D347d6+R5JHVC97IbEGDuWcwDeQEb5Vceo/z2qdrmRysX2g7IuI1/ gGeuPyqoLW5sV5p44EVA5aWWTZFtHBJ56/hVyxMqM6yKuNu5XJy30q7IcW09C9cTpHaNOzMPLb5l VcsRUq3WkT5M1qZmaHEDsoDRscZP6EUOKe5uf//T/k2W4khg+RHZXbaGVciID1PqKz7uJI1hkhmn a4fc0qMnyAdufxr5Xlj2PYMuAXdwgifMO5iSo4ZsdP6VH/as8Vz9jt5BPs+SUEgiP/69Oy2HdrY3 7aZ5EHnlS38Kg5/Oqd4k0ErAnIRRIwHJUH6fhWL3Dma6laPUCTtLE5OcHhfpW3bi1nEaFj83v9w9 OaRHtFsf/9T+Tu+a1toHt1UBsbQR95qxoLgxFYlO4t0TGWxXy9j0+dk67o4ZJYyVk37j24qR5ZjY yTJLh0U7SecmseVpFRnfRmPokLy/adQvbho57chbdN+VmGevqMHNWLiWee8mSdXVwMrK3zbie5NJ JvY0Ta2H/wBnD5XM7y7Du2t90H1ApDfiGWO2a3EgbI3n7o/3qHFoNWz/1f5LoYraFGl2+ZNKCpyB tjXsBUdpNbwOYZkAtSGBgT5Q/Bxz25xXx59FBJsr7+CsS42nG7ORipLDU1tZV8kRyJG/7xCA6n1B FBpyoneaTzFms5ntpGfcJEO1l9h7VkNc6lNqU9tc24jijiVoJUbd5zZOSfc+lBDjZFkXT26bREPM kO3zxy8OD1qxokN2mo3dxJLFLa3UCxxl2+eJgSWYZ7HiguKsj//W/kjbUILe78q6y0qjJZlzCa7t ta0eTSRax2QWOAm4RWUfvmYDJbuPu9q+Sg9bH0s1ocPJsuBGbYjc8hWUjK7R6VsoJmLJCWCRxBCT ztxjmtSIfEWrab7O8gSCORJVCTyPyQwx8wHrxjNdx4ReSDVIniV7mJ5F/cxpvEJYgBiOoBJAzXqZ dG+Ipr+8vzOHM5KOGqf4X+R+inw3tYrnQpbi8mNs5LzzWqANbxJtHyrIT9TjHTvX9Z//AAR30U6b 4TKQ+ZL9ot45Ee6h8m4SERBcj2IkU+/Ff1t4sv2fhrhId3H8mfh/hbC/E+In6/mf/9f+ln9v3U5N H+DWsToIGt10+RYpJGJkikCv0HuCee2K/hi8b/aor3xPPFdPpqavfuIGz5i2jbh5rRHnqOv1Nf1p 9G+jy5PiZ/3l+SPxbxonz4+jT8j8f/2kdPs4tavDffadUaS5ljt9SEGY1VCpkkdvVyQRzn8q+Opr WCeZJYHWE7shUO0nHtX5j43y5uMqq7Rj+R9r4dQ5eHqfzGFFOYWiFxKW5ljySvtj19qv220LLAhk thMnli4Xh4SOh5+tfilXY+5S95nRieEWlpZxxl3h+/ctzcTscAk9uwrQgiuJZIo5y6qvywo/FebW NoK71P/Q/jf03Sppbq1hn3M6y+aIrUktKgycE+46/SvVPC+lMLfUtQd0gFzdGK1tuGeJU4JI6jPH Pevlap6B3S6eRiGJpFdo1aNIwSnPTB96jvLfyXU2+yK5ifDSDAIx1A9/8K4QG/2ffzRPeYOIeC7P hX9Bz3rp3vjomj6e+21un1GcGVC2bi2VTzvOOPYCk9mhMgGpjV7sywItvBbxlmVZCQe3zA/WqguI bWFXhkjaylmKuGxu3dip9O1VhvjaFKTjsf/R/jzYSbiFRSx4ZVJ249aIJJJra/0u22qbiMPKDjjY SeteHH4mc1fdGfb6BYxOPtS74RmSWN181ZCRyMHrUcUazyFXeWxiBMCS4wCgPygj06VoRT7ENgt4 bSZ7m48+CW4eOMK38KnHIz+P41PJts1WB5Ukt9+6Mqm1juxhfXtj8Kzj8bNDV0o3bSyjeXt2+aPJ BI/2fXiuulnja3mghtxHut8CLOA7Y9T6kA81009jRRukf//S/lI8OeJLTSNJm0Pxbp1rrq3VoWju ImCJZFuYwhAJ+UY3D259Dw97dx6dHcLZzxxmVSLUu/mpbk9D/XrXFTTuwkouKjbVHnIg10PA889q dXvZjG12OUZjn5yBzyOSfrXGa7pevG2kuIpLW/mhm3alOBuNuoPyuq9SD0z2rvS0MZK1j1/4I+KJ tN8W6X5CxwW8/wAuoJFhpZQ5jhc4PByG+tfr34XtdO1LTre1gnmeGVmaN7hDBdZb7iyID2woxyMV /Yf0d5N5RjKb7/ofz34uPkzTCz7W/M/ts/4JJXCr8H7VftkSnTLG0sI4LFAbaWXY0cpxnIKjYf8A gRr6e/4KGWNldfAvXbY21xdXs2ntDbNCxHlvMskK8dMkyY/KvwbiBTj4n8uzdVW+bP6Cz+SqeFye 9sPbTyjY/9P8uLm/v9Ju5NBnka6v9MuZdNuo7WFrhxtZlUFwMYCgLnPGDmqdtHAH8ueCS3u5pPNl tZo/Ld8AYJ/D8hX+tuAlGeEpzhs0rfcf5r42LjJqW5yWr6feXF9LFFE/leaJIWXO2MehPtz1pn2W NiYvtRV9ufKK9SOv0/GvYVuTU8+5LNNbaQ6RtIftV3CSAOVKoQD7Zyw/OsrU7i8nY3LsjzLGsVqO B8iqAob0IOf0q0uiKbu7mrGdWGmvFLdusDxq1/FA/lxygc9uvTim6+dNit7Oz8P6pqCXkDR3F07o ZLW8VcMUZsnkHIOD0raUVbQpN85//9T8l4NVt7iCFPNh2sAzKWAVW74NMkdBcpHbSKWYZLocFMj1 r/YtQutT/Mub6GA95di8ltjOBLbShJCGViO/05FaAv7i22taySCRwY5FCGRJFx8wbtg5ojFXaZF2 ZyX0Fu/2m7Vkt/MxcbFy3JwSB3x1/Cun0WG21tL29hvbS2t7Wf7JZrNII570hQf3aD/9VJxs7Bd7 DJ5XspEjFsskUZaYymPJjwAMA+nJqgmozDUYdTtIyLO4I+dpfOY/LhhjHHU8Vah3BNrY/9X8lXaf VlmlWOO3kSTYGf78y54Ax7c1FLoUEqq8ha3MaYlZwcyYz93/AD+Nf7HOET/MyEnexg6MYLR5S8bS IkrkrMpOFPAx9DXZxXVncxZleVIYDvt7ZIy3mtjGPbPFPlSNHJsqTXMht28qxKK8gmkt4ofLDMgI UkAdQCfzqdtQMVvbvNE6XLR5eMEMkY/vEfkPrTMXN30I9KnVr94biMyxvyBkhge1PMt3ZapGbOSf 7TuZIreGLzHJPcYGcjB/Ok0mKVQ//9b8h2nkuLvfvMjn5Hdh0/Kujtb9NKcXLrJMYVVFVOXTcQuQ O/X8q/2JtdM/zGVTctXOlQvqk+rNeCMSxhY7W3XYtueCxH1IH5VnT6hcXX/Ems0+0G6DO6SqFgZU wXdiRhSBj6/nW1k0jhqSlrqTu09tpcVjFNbpawp5RTzS1wx9SOw+lYdvezLHGlvIPLR9krk53Y6i k4rYNoM7LS7T+04Z1nuIysEJaKORykuBkttPT3xVTR1MEl3bw+RIs0RjYzhQIxn7wJ6H6etdMVZW PNnJqdj/1/zIU40pNKW1juXaVjNIrcqOCqquPY5Oc81z0MEdwhEUPkoJNi55weg5r/Zg/wAq4PoV 5tN02Rbi1vpZ0mlQGFwfkVge4PY1deRYLMWkN2ITcwi3kVf3YuFQg4P/AHzVRjzGqbWxv38DWtpB BbXUE0csayf6M5McLEcjp1HQ/wAzUltaBhbWDGGXVBKjw3EjgqVcgMu7p096JR5Sud31KOtyOl9q OlGWCNJGMtmIR++WNAFf5x2LE4+tVNN1i5guYIr2RkiiIVQfnQgdMg8YNKzexXNoz//Q/OC8v7SR LmJ9Oe0uLvEsF3busNsqZIYCMDgkdxiuf1FTHbwAnAckRHqWxwf8+1f7ORh1Z/lk5XViRPsItY43 bfdMoaR937xWHQY9OlZ95cHT7u3UgyGZN5yvUZxWhzz3sdFDd2KRST3Ec1kzjZbRNHvWTgfMzcYz 7Cuc1G5nkhkxKoR22NEkW93XPHPbt0qofEjFzXQW5/dWlikJCSxnzAUwrDPHzH1yBj6UG8vWk8pk KJGuXcDDSk9Oa2sVzK12f//R/Li3uLjdbpMjCSGMtPceWV3k/dx26envWyTBebIo98fy4lMf3yvO T+Vf7UH+UMpX9Czc2mqKWMLedo0ECJYpHvkkj2g7y/Yc9uelchbqDqE9y0QmVm3SscxrGPuknsBz jigIysy3qss809ta2U1vFBHGC4tow0kmeeW9uBx6GmqywQM9snkwrhJDu3b3/iOfc8496AlK5p2s LTENczzyop+SBk2p93qMY/XPWsy91e+t9llD9qSKEmdSBut4ucHnpngClZFSkk0f/9L8t2vb6Szg kuZHaynnLnJEjNIvBOc5HU9fWtlJ7R4fNMqzNtwEQ73X0B96/wBqoq7sz/JtzfOZBt1juyCyW0lw uYJFw2D1yR6j0revUsrhbO3iuZ7yWTEckpTyt5A+YBOo6GrlG6shqbSZ1Gh20EyPp0141rLbri0i k3MV4AIz+AH4V9GfB+5uNM8T+FIXuYYUudcgt3QAvJMqbsoPTecc+1Y5nTvlGIS/kl/6Syshq8nE 2CfarT/9LR/dL+yNcQ3Xwg8Mn7O1vONMjmniL79pYsBg9/lVfzr89P8Agr5Y3198M722si7MuiO8 +GOPKWeMPu/3lZ1+pFf5hcFfufGKj/1/X/pR/or4yw9r4ZVv+vS/9JP/0/ka7ZL+2gmEbwKigvbs mAFXjn8hVTw+j3j3rXJFnBC5FqLcGaOUjsc4wRk1/ujRfur0P8TMQ7VWVdTvry2F7axWkl40VuZE VIy8rBgfuqOcio7CWO304X14ssMwsywieMq5LDKrjqOwP4+ldKjfU8ypL3tRtrDBMbXUdUhsbW3N qGeOBxNcOck4J45xn36VQWGKe5llhUpCJGKFuWCE/KPrit0ruxzNtkktoItih22yZYuRkjJPFPZN Ps7GNrsMZbiXy0lCMyo2eAMdCfetkktEZyk07I//1PiOFoZFeKITAAfMXGN3pzUlnp0jP+7jICtv ZlHVe4PtX+9B/hOJfSvavHaNPMbPBEduq+ajOcYGOwznn3qA2cd3L8tz9jAjDNbyHCOR6UBYiik1 7T7fUYoV091Do9vdy26NIFyC4Pfpkf4Uovbe9aO4vnj/ANYgjQKFjDA8FV7cjP4U0m9htWINWvWk 1KON3do7dBFGEOEI6jgdetajTJcr5EMgjaJRtkZdpkPt9K2irKxnNaH/1fieaOe5sFiluWD2mQHO TJKD6dhir9jAHtMIoMka4MzffOO36Cv98D/B2Xwsy723meLZJlEZshhxuwec1NaabayxhhNKrKu3 aMYB9f507O9jHYhmvr6xncwTncE8lscbkxgqR6Y60sd59pZ2uXKqybNkYwgH0/CtzBqxXkuWhha3 t2fymbc4PAPuf0qjcRgG3ZJFZm/1gHVRxwf89qBH/9b4dkhimJaFG4w2A23kVl36MREFRYZCQZAy ZduvT8MV/vwf4Hl/T5haSMLy2e4tJoijeU/lTQsejCnwK8Xnz5mWGT5UEh3kgHt6fhQJptaCzWiX NulxbCTZ5vk5kOH3+mPzp7aZdWl0Ld3MOyI/a85ClSBg59Bx9a0jG0jHUr2s0tp5iQzFvLBiM6fL 5gIKk88881CyLaN58rZ3Jviixgtz1rQR/9f4Vsrq5humuYpyqOmwwkAjnqasalcR3Fwhhf7sIWQA YAPJI/Wv+gA/wISvoigGMThncpEBnzMbv89qbb3BuYzJ9pO3PTOM/hQaKHcjtYg89wzrxJGFEzdQ QQePTgfrU+oW802w2l1GfstttaObCKq5ydvPueO+afSxdihPNKunQmJDbmK423MjSeYtzzlSR2GC Rx61bs9Q8lcmPzZGkURQs22FRuy+Qc5yOlawegWP/9D8/wC7OqvJEiSpLA7tKcR7fsx7L056ds9a qi1uQS+G83puZDsz61/0EH+A9raF2wlWWaSymkWOcRlmdxkOOny5qaXTpoJ0hVd4K7kdSG35rRK8 LICr9idrS5uFk8nNyIVQr80mBlsduwH/AAKooUYK6EnAHPqfpVpJbCskSxzBSYt/LcLuNaNzaIti sh+WeWTcCnBfHB/kOfYUyZ7H/9H4Fgihe8hkYOG8vbKv97HSoWs3aS5aTHmztvjYyYIAGP6Gv+hA /wCf8SFjGGBOVHyn60QzBJGd32+WuYy3IX/PWgmXwkKq6EsZi1ucsA/JBOckH+ntSJs3PMJ3bd8v kZO0Y746UEc14tCXqSzCBY2CiKUOC/QevH0q/HNJAjBJ3GWGQmVR+3I7/wD16CbtKx//0vglJnfJ WQAsCu5xleQR0qjJJPpQKO4uWdQd8YG7nnp0Ff8AQtD4Uf8APzzNKw2Fo5g0pYLlhtjC539cknP0 /OpWZprgKMQxrxtxnj6/nVFRlrqxJ9yqER8wc5z1B47VYtJY9gjKqVY4bdjpVRW9ilK5p3dgiwJN HhotucKPudqwzZzFnlzmFQAcDBFSUf/T+APMbTY2dS0sRUERdfwqzKHeCO6MH2R5oshQMmTnryT9 OK/6GpL3mf8AP5B33KcALQSTXKSw7f8AVI6Y83BA6/rzUhs7ORIZY43hmMvnvtPyIwPb+tVT6l+R LucTTT3BTaW80bV27R1NazfuczieK4t761SWIdfLz1P1zkVoBzt9CxaGOGNWid8y4GJPbn0rU/cx xLbZ2y7eQG/nQZ1Oh//U/P8AjkVXaFyohb5fNLEFTmnKht5B5ESmONdo44P4V/0QH/P+lZWGXAKR fanQlejEDO0D6VGjMiyTpGxQgBwBjjP6UAT3SQ5QRbijoC3Y5I9qrS+YjKqZ2AZCkdKAFZJbldqu sTHG1yMhfcgUzy5kIjmlEsg6uoK+YfXBoGm1sf/V/O9onSVRJE+X4RgDsUj1OKtmC5eGHe0TTRkB 0UFVYc8D86/6ID/AFybVi5Bf3lpcxxrFBMsTYjt3BeAD3wQaoTDUhdq8zW8ltPMzyQhQrQehU/jQ SW0jQuksjH91IMgHr9ag1WBJ5vJV5FgZQ+5VK5PUfrQBN9tuBBBA8plWNdiqxye1QzTIHhgL+XNM cIgOC2PQUAf/1vgJbua02wzYlXzd0UbL9xvWop0f/SJyPMlkcyhD8q/T+f51/wBEB/z/AItu0Gdq kxqxBkBOVyOOlXJ/30V6NPkjmWxlWC9MecAlQ4xnrwV5H+NAGXG0iopXIzkPnt7U3yJFcOiyOXbO Il69smgBdzRzBm/h7HnBqVLdpZslvLMuWZn4B4zn8ad2i3NtWP/X/PGG4mjabS9Qt7sRMCUP+q8t v4ST1xjt79aaYVRWCFgy8jA5YV/0UH+AUZcqI3tJZEcBWIx+8HTGfWtKxvJNPVo0xMLy3e2kXZuC BgQc+nSgHN2IZI53sktbeK2he3OxJAmHmy3VmHU+mfQVWhFzZTSCSQyMybWVgCPXpjrzQLmexA8s xm+TaqnggjkfSrUsRZVUnLMOBjrQvMk//9D87FgZUEZHPbirdqTAZVJIPQEGv+ig/wCf5tLcSR3j eF/vyg7gCoIOOpYHjH1oE+5pUkbbFMm11UcEZzwPwFZpvmsRz9iNZjMp8o5j37AX+9gcfpintBIP lBQrnKFVCkf7x/DvWgc5GisihZhzj5nAwAaliTD5cgqTxt6496Bc7P/R/O2SBHdgQZDnKA9fUU0u 4wh+UkYC9/8APNf9FB/z88zvcT7PIjqzkbRyB3qwsqsmApDKf4qCoy7joXjilklmCxI7YCyYO/0F SvdQ2h+yRxW5iupB5UyINzMw6A4/zk0BKXRDldbYOkqYAO3A4KUrMHJhXcQRuR25654oMz//0vz5 hSWJW5DEdT61VmLv8oVs4zuPK9uK/wCig/5+Lu1h8CyKMhvLdeVbpg1MkkonBlw4IxgjIbPeonsC bWxattoLpgqM9D0OfT0qpcokDzNAGAkbeysc8/8A6hUX92wXexLp4lYrcSRyCUZEYjbYBjjP4YH5 068tZrby/OJYykyqWOSMnOD+dSI//9P875QwT5wCpIZSP4cZq1FbAxFgxDfTiv8AogP+fcrkPCgj chnDffyeeegqWEyRiRsN8/47fp+WaaAtRq7QEuvyr7cml3GVFjxtC8KTxV0+pnN62IJY9mNzBQh5 JpJPL+V+MDr2rQcHpY//1Pzx883Vq/k8xxyYBdCnPqM+w+lTQPsiYEgFvl46/lX/AEUH/PuQ3Mas ixDJVj2Py/jTGgfYArFQrDlTg8c/0oAvsflDGJjhQhbGe1VhbMU2Mz7mOVkyFbFBSk0WGWSGIIr5 jDZZSOKpykb927g8YoDnkf/V/PGOGNpFlJK5x8w4zjP+fxpzXXl3EccsjSB8mMEZ2AH9K/6JpdD/ AJ+eaQ67gZ7u3LTjy5FzIQhIjwQKb5yRy7ANwAwWIx9KJfCxqbW5KqqCZiwCk87Rj/PSlmvEjP7t csMZAAIP1rEOdjTcBotihd5bPIyx9hSqtu9uzJMy3AGNhTK+/Of50DjN3sz/1vzqnSZbCT7NBbS3 gmjdHlUgsqk5UHtn/CraTzXLGedVEhGZFzkKfQH0HNf9EB/z/kczxPtYMDvGDjoahuIGQWx8xYlk l2gEffC8n/PtQBatYB54uCqFIzkIw3I31Hf8ajt/PFxcLsDmD52YDCBM4zQBJcJE92syM6sYRGVW QiI++3pnPeqkuBMoMg9EzwxPtQB//9f87DAzLh3ZCHz6ZxWlBNdI0aovmxE4dmB3L6V/0OyjdXP+ f/bclkmAZhk7SMAHkDNUch1dJGaPYd8bKcb8HODg9KyGm1oieN98YYNvCj7w5BxTftWUBMZEiucE csR0AAoEROGzI581VkHyhudvtVmzwY/LPDNzkdeKia0HF2dz/9D8+0t7aKdny8DSOFlm3EgjAH3e 34UjeVCCquJ1Yn5uD68V/wBCB/gNdCK29wVBJHHHUf5xWldraxRwoZ8SSKD5DcOSByRQRJ2lYpRW 8cjtIgw4XGT0YDmgyCa3ZCrHDFTkcccUmrqxad1dEUNv5YG4Beclx0x6VaSx+3lhbSrAoO4vIMAh eo/Q/nWMVd2Gf//R+CvsNqsInd97Q5BWQ4QfSqpkVNrLGuxvlUD7uPav+gz2fmf4DjJ4wISYvmbO 59w3HBOcCpLa3WdYpoZQ0h+RoUB3ce1Z2toaqatqV5Y4oW2ruLD+8ckmpbZ5YCboZI5XZ39/500m 9gc10L+LFESZGkaSQEujjCoT2z1//XVdioSSMhYT95GHzF/oaGraCc+x/9L881aUttJIGfvdqtRW CuklyLlzN91rdh8oHqK/6CD/AAL59PMaihJEKCKNghFxk/M/pg1ctUkmLEpJFGZCof1x1P60GZYv LGW0dJXmjmtp13WzqwMmRw4fn16VUuRNPGBHIEW3UyuGbb5nQAL75OaAG2ErsvdZmX5A4+79aCbw efJ5cMiMnlPLJ8zRuTkYX6A80Af/0/zwjt7hpCZSrWyxETkHy2LcAYHPvWtpNlEUljJGJQUQlAVU Y4z7+9f9BB/gORJbNaSNbyhYJn+SFWbaCPUU8QboZY2ceZtIJ6fiKSerRlUdmS6VdT2EKxeeZDGp QSP8zgEbec1Vu2mjbzYWfezZXJ5bFYWNW+5agu7v7a73MEavNBiSMwKuchcMoxgdOo9a2pILCUQn zXW7WIn514UHGVz26UAf/9T4FksbiS5ikTzSqNkojYjOOc0+O4SO62CUibBCxgZZs8YFf9AB/gUp tKwQiWDzICCvmYDo45OOf6U6700wR/aE2IC4WaIkKWJ4Bx+FA+di2128iS27BlWJcA/wj6GqcZmW YlnDIOApXPPrQRd9yVFk3ttJBfjk4pim7jeSP+Juof8Ah9MfpQNybVmf/9X4MCtGqHeDN1YAGoSt 9OJhHCGRPmO1tpI7k/8A1q/6AD/AcX+1byzhVIrh1Up5LEcuoPGAx5H4VCLm5FrJi4/evwHdd79e KANG2SSZY3cDMK8n+f8AKmag86PDMFBWZwu3OGUDjOOtBdPcfJNHbRuZvMYvyAOsY9xjP/66livZ UWKcuqW33V3L8361m5rZFuSR/9b4buZfMQYYI0jfJKBhjUcc4s70W9zY3s05jRYbgFTBG55y4IJK 47cV/vwf4HJ3V0XNQ3N5YCosjH5/KUKg9enH5VnzW3kxxwCV7UswmTaNu/ndwPfBoGakE7G1kDfc YkzyMmJjt6YbGa52S+t22QkSCd1LRMqdMYB3fnUTaSsBqWguFnWKCRi00S/uyR2HU4/P2qe5geC7 EUZS4k24Zl5CNzkH6VkVGXKf/9f4Kn3wyrK52mP5pcfMCB1FddY39r/Z6XMKifzIsxxFcJnPINf7 4H+CqlfoUnxeq9sFEKSRFZVYZ3Z/z29KguEFs8QidZobe3Hm448kDI5H+etZTtfQtaO5kvCl6BMo 3Krb1Ycr3qVAdOfzllcu8PlrG5zEgblsD8iPpUGyd0XrVVvINkGOQFQbSgUD0HYCrraNJYx3Estx HMk+FhSP5ZIiOWLZ6g8jjFFi+aR//9D4nsw6vJHJIxgjQsoUZ5xwB+NMiH2y5DXEzxxg4lKqAGwM AY/Kv95JKKP8IG29xZ47aK6Ix5sSY8pyR8h9xULf2aYZRdXUwuHG2zS2QHzHPTcewGeazGpNFN5Z FjihkPmz9HuCfnfjAJ/L9aeyyJEqrc4YMr9NyEj1HT1/WgrnfU2NPMRnmF0sKkQA5ZhuOMAsP/rU y/k+ZbW1lU2zyB5/nLpx/LpQHPof/9H4aa2i+WS3maR5H2GMKV2DjH51v/YbWKWHfIqW5X982SZR txk49a/3fsj/AAmjLqie8FpHG7WV5K6SpsMTxsrsDwa5O11BbPUFgXH9o2481iGElvID2Ax+hNJw TGaM/kRQiW6EhvckqIpNqpu6jA46VkXUfkGJWyqzoHj9Dn/PSsnZPQuPN02NKErYRwCA+ZL99mwQ o46VKI21OcrczNvCkArggntjt69Kzmla50Q3P//S+HILC6jvfspdDLbQC63yKUWUA4wpxjdwTj2r pL2zmuJbSdrkqtugdo0JUscfd59PWv8Ac6VuXU/w4juidGNtPb3d1d+fAku+W3JwZB/CuP55r1L4 VIniT4keFQj/AGNLPXLZ7SC1j86SQCQMSyAZIBGMDJ+Y9a8TPJcuUYmXaEv/AEln2fCcebiDBxX/ AD9h/wClRP7jf2RbGW3+EugxzzGWF9PjlO9NpDhckfX5ua/Jz/gsJdzz+F7i2F/aWqJCsXmzS+VG FEyB1LdsqzqPc1/l74fQVbxjpP8A6fP82f6h+KdX2PhVVX/TpL8Efy2eJrHWYrKG6gK/urVluY7U GYIFH+sz/dwfwr8sfjlfpH4ov2aO5WeOMW0YkUrZ3GQsm9T0PDLz7kV/av0gZun4b4peX6H8e/R0 XNxyn5H/0/5U5IWuU3yqVkxgleBXM3FsfMCqcosnzEcdK4K+7Nea0bmx5axxJNAF8qED7RIp3MM9 CB6+1W7W4v7PT2tP7Subq1nuTefvZd8ZY9Dt6AgcVzAp6amLfODIu8o5cAqQfu/Ws2WfzZzHvJjC gGNfm3EGs5rqKb6I0kkUMIccKAXx1X0zVZ7e0NwgLujO2/IPzHHf8KzHGV9Gf//U/k3gSBDLGLl5 y8hZVlAVl9h/k1izXLpOyR/NBu2zoRwfpXz5pN9CxMUghDW6qXzkIzYz9aax82Pc0ZDqN20c/Sol G6uZnNXlxOxlULiPjJzhlx7fhWlbbWVJvMZH2fKhGAT6H2rI3jshYXV5M3JILNhGQ4H/AOrir7Qr IdhYOrKdpD/dFAz/1f5H7SRnaRA7RRxjb8wJzUkQRJBJuYxE7WKcOfz6V8udlPqUr1OA/wBpkPlO CsUgBQKTyM1XaO4JKeXuiGJWcclFPTn05/Wg0LEUbxTfaIriL7OI8SQTQ+Y27uynPccdO1XlaJwz iRU5xhuPy/KguC1IJkYsJo7qSSOVVU4I8ogdqdiMkokgZkOGdT93jpQan//W/khM8sUZMbsIkbn0 zUtrd7riWdi2WiAhGwbAe5r5c9g00nWYruRC2MbiMfhWTJDp1haSxGztIr2W6eZrqBT502TjB5x7 56571m5vZAZFvO8DrlWMYk3MckkDP+etT3cYuWvJ7B2Z2XCNMTtOOgwPT29qzInsVYLNpvLzL04Y juRwR7VasnltZvJYgRhypcjJH9aDI//X/kcvJjJdBhLv8kYfup4wKha1DzRXSXEkQiBI8odT2/Cv lIS6M9Akhh1C93CFtgj3GQ+Z8oQdT9T6VC5kiZYYr6Se3Rt8lvgCPeeuD3q9wLL+UYhEkQOWDNj+ GnyScNJGpkcfdQnGPYmi1tEdBFcpcKqGGUiUruAzgZ9BVOG3aC2iuNYlW4up75oobW0z5kaLhg79 uQcY9jQaQS3P/9D+RaDUQdVe0uLeWCMwloCRhW+vpjioNaspJRH5dxJDHK2wtDw+O/NfJyh1R9LB WQLBLDFHaW0kly8nH75ssBnnJxVmCxtLWTyoYysjnfMFHAJ9azLLUttJG8jCbMZUCBQcKh77uKg1 K5eRIBYsZZUQLLIyGJEPAbB68f59aAKdkZlZxcSb1GMKFH48+9aUhubeBp0iEMNxIUtlyTIxHBI/ pQB//9H+R23i/eKbmHzLh/l/eLnHvU8hnS8issJszzjpID/DXyMPiR9NP4S/BY+RK+X+QtlEA5j/ ABrRnE0CI0cfmK7bSQ4BA7nH5VsRBamYt4EndMgqceXxwx7ivR/hfq94/iK40eTyfKuIocSrhbgH zVOwcdMYJIx0HWvZydKWOox/vL8zyc7lyYGtPtF/kfpz4TsbS38Oi2nLo+5bW8i2FlVyQpZSOuMi v7D/APglfp92/gfTNTNpBBMB9mbDbkeApGqnHY4jB9t2K/q3xnkqfAWAprq1+TPx3wlpuWd4qfk/ zP/S/of/AOCm12LP4K+JlkMUMRs1W0LXARV8xZN7H/v2VH1r+HvxbdM+l30Qt5ImgkSzsrM4lmuS SkbuD3zs469fev7F+jvDl4drT7y/RH4d4vS5s5hHsj8k/wBojU9Ui1G90q8lW3tNOupo0tBtE0zY QMM+q7Mc+h7V8XSNBHJHerJIGV8iEY3nqCOtfi3jLJ1ONcSu3L+SP0Tw/io8O0X6/maGnXG922ja HcsEUfMM9a6SygG6TcgdXG5nY8JivyCrG2jPsk/eaOhtdOW4WCR/kx8yvGSFcCujtoEMIE0iErKR G33WHtXnVV0ZtB2dj//T/jatr1bHxFBcfa7tLRIxDMsDcuWG09uOv5Gvd2t9PsrGIGTe7os01wkn AVgCYz784NfL1Vuegbdvr0+p2kVpbzQQxaY5jR1jVZCjcgN39warwp5m1RL9pTcTHNjdk9+a4ZK0 mB0Ua2mwwSz5CJncBw7AelY5s31K7SOCQypHnMJYeWMdTntWTa1iFjQltRYzeUbW3WCePDBDnPqD 7VSmAjtZVWGB4LdNtvblQqREn+HFLDSanYmUbo//1P47PtUdtvUfvSW2N5Y3E9v0psOmXpvSYcOb uMIipkyf55/DFeNaxx1HdllWvrK6smR0migmDTwyRB2cA9Af8axNfS4kn1TUdt3Fp7NuFuMyFd3J +6OM+ntTFT3INMJeBZiZorZ1HloylRn3B7+1bNtFBckQb1E7Ntt9wyXbsAKzj8bN4pN2Zvafp/8A ZE1vLJc/a4RKBcFF2xzk87cdRjpx6V1dmkF8Jo5Yl3TZSLymOUyeB9cV0Qdkza3RH//V/kU1IWEN pbWkzfZb1ZzFDAG+SQcgDPU5HOK5STTW8y5NxJIYJ0wyM4McBGRlB1BPeuSmXKNtiDVz9jtLSWyV hJaxhfM+9vHRc/mK8J1q4vY4703ZjRkvAIoVY7JE69c/hiuyL2Ice56V8GL2F/G2k3E8DNZEJCsa AvKrmWMngeuMDPfmv2jsL4Lppv0s7y3uXtmmt4o4yuoJtUiIkdzwP1r+wPo6P/YsZT81+R/OfjVa GJwzX9as/sL/AOCKF/aXngjTcag9yum2MH247sSSSSoWXzV7tjbk+hHNfqj+2rpE+sfCDxBbxxqz aZo8+sI7DghOoPuCAR71+IcdylhvE1zas1UX53P36EI4zwspQj9qi1+Fj//W/OTx9E+la94v0/Rt 9jJHqRsbyYxqEIWYsdg5wWzye5Y+przKSzvI9QurzU5In+zWL7xKdwiBTg8HqePpj2r/AFmyCbq5 Vhqkt3CL/BH+b+cU1SxlWmtlJr8TO04XVrbGO1gSCGWMyxyKm0Nu6FU+mfyqG0MM9/aljsZJSXeV cCZu+71HHSvoIq8bM8SEbalHUrVdRnktYkRbmDf5FwePKHfDH1wOPateGwsblbKzh82S4jt1jmZn 3NLIB8xUenpVrcsJIIEhksG+0wuk+LyVH3EICAVVSODj171RjSwtZpGs3uJYpVMKJOyrJyCATj9e a3LgveP/1/xg0iQFbvTr7Q4nFjcEpO0hC3CHkcHj1rfvbiCxtLaS3gKNPKsKw27B3gBOMnnO1e/0 r/ZA/wAyZO7Nu1gsL7S7ua8stPub6H/RYp1hQS4wSGYjGSP7x68dazNIhEKXUdzdqjCJvLZkLeYc jCKf61K3ZIqaZcT7Zvk+zxv+8GeWHf8AOqV7bWkLo9jAqLEMxLGPkRh3A7U7a3KcWjStfEEx0q4t Y4N1zLG1u1y53Bc8HauP61b0qxNlpu6do5LmZSvlthxhuhC9iOuexpk+R//Q/J0IkS+fysqrs2bi I/c4/AVDbSeZdmOeYOkzcLJJhF4xwfw4r/ZA/wAyoble9WGA/Z0il8sLtEsvMr8j5ANo6HJJzjpi p5JHjuo4dNMhlhAMBVNjtnjO3sfag0ezNGC4uEkX7YrI0LbpFlXa7nPcGo9YsDNcDVwDCGURskOf IK9hjoKDlm7HR6LJpVuGdoo5btrJpHEhx5eMgMp7kZHHvWHe395ZrBc6dq0x1fUUk06Wf7MAtuGH DMQODgDkYPvQKdrH/9H8giz2MiwJi4YKGuT0MzgfMR+NbwitJjFfyXu1mQQtbFeCTzgHHJFf7H8u lkf5f83Lqas9ppdwq3FhcXiXEMQDiZxHA0gGTle/GOa5i83Bpb24vDYC2tSJVt1KrdjIBU47kd+O hq3HQ55JMsWcUt+1zcwReWbPY0cErbpZY2GQ+O465pmuJN/ozR2TK0jpEq28e2IH1YD9TQoNk2sm i9PLcFEtsm3LqLdWgTa/P9evNa1jpsY0h7n7QsklrLte3aTbeygdwO461scc4rmuf//S/KJ7DVJC bu3uZYFQiYpIpBhQkDG8f171rRLZadGLWSVrhDOJjKrhgd3zZz/Kv9mD/K5JRVjG1KwS/v3ltmZl DACI5zkcgj/61NDLAVWeLzGKlFYjcE9eex/wq4OzsFjQGo2YFrDZRSTRpGRNNMpSTexyQo9BwB06 VpQW1q0M1xNcXSOEO0LgZ64x3/Krk0lqMzfswv5YpGeXEEXlNJ/y0256E+5q7b6bbBgzyvOIQWQs eWHJA/D+lOLugP/T/MO7t7meeAxXwN20IMlvONsaxH7rAdiKdbzO1ldwy43woWgLDq3tX+0B/lfs clHaXVzOwVpUkX5y0RxIR7V0F9bRzpYrvfNqvztIcs34/wCetByTk0WtQLXlqrPLI5iQRxtncsQX oMf/AF6rx2nlrFcHmNh86MDuyP5fSmtHcyK0r217PNskMESuVU4LLkA/LUcV3LbtLJIzXExj8tIp MmJuCAxPXjjAHWr5yre7c//U/Mqymvr3SreS4dWmVjFLMiBVnC/3h6jIrNt3iF/cQmeaKZItoEUZ P3gep7ZH1r/aeLurn+UDVnYmg0udLaW5immadJNzvJIWiC9ACOgzWc92moMbBYzFGyCJmjyuOecN 9eaZUYp7m5FoaBQYJhBEAsd1clcsi9NxxzWUscVjIIPNkurSOXcQxw04z19ifp2oJkrOxtQ6hpP2 We7aSa0EAP7ksJJT2wMECszT7OLVG1a9+0D7DHaBrWAuqSXLlupHsOcA9utVFapkVN0f/9X8xRp8 9tYRyC2DQXcrG0iM6yzMV2h8j+EZPArS+zWdlGJ1txA2A8ltxvLYwRn1r/a5rVH+TcWrtmRqEMlp crf3FuqRSQiYRPkzwDoOB0yOanhvbKS/e8MMZaa1Do8KlYoWXAAx2b/A1RlKSTZ1mhR3l9vlljSJ 5gCpnbbOig7mOOvIBr6B+Hsqw+INIu0nFpLFrFnHZrG4l8sLdRFiQRxlQwz2zmljVfLay/uS/IjK Zcuf4R9qkP8A0pH90P7FEyJ8INAhKy+dBpkMN3LMxYyFSVUKfYAH/gVfMX/BT+G1tfhT4j1O4hQq fDeolP3e4TsluWijJ6AMwUe2M1/lpw+/ZeMVO3/P9f8ApR/pT4ox9p4ZVm/+fK/9JR//1vkTTWkE iTIsstnc2UbRHfvSP5Rls+h5P4ioftca30traEKVXzpUQ/6snpu9Cf5V/ujh/wCGvRH+JmJ/iS+Z SuJ5ZXa/t5zHe6ZLuRUcI8mTg5HcCo7m7l1S4+1XTlgQF8gfKiADlR7Hk/jXbD4UeZNe9cr+Xbzb 50iBBwroOAdvSrO9RYkSx/ZYZHwsyjDDHocdsVrC1zmas7Bm0mtZRbtNe31uu/yI3XhP7xB6jg89 qNPmlWFoo7pLdbk+YI3QNlunfODWorH/1/lSOOFrRYb25jDxglLl4wG3H+8VGW6dOa561vtPjg1I ap5ssc2/7BJDIY/KfG1S2OeefocV/vQf4WSit0Z7MGsrPy4iqwQ+QZnOWm2/xH3xVGSOzvod155l xHGfLwj7WCg8qrdu9AoKzdy1JFpnkwXFhcNHbRxG2hVpsuxfjay8ZPAGcetVo7SC1hjjknQlGMgW TGSSemfyprS4TfQbb2tsztPLInnT/KVTLFMfd47fhW5FpVtGomuZnJj+ZBjYp4PWtznmf//Q+LHt LxreYoNoByG/vj2qHTbsCMwGQjD7j2z0zX++UVd2P8G5lrXjJiJomBtv4Sp65Gf6GsiPUZdPjEkO JOflVhkM3YVVrVDMrypJO8lwWEcjMElhkb7h7t06deO2KdEk0EM0nlmTA+UqM8k8VoQ4CXl2gRAY xHM6qpV/lBbH58+lTXEdu8X2j/UPHGqFScpM3AJ+vegyP//R+JolktbcSOiOy9QJBlvQCqVxaPd3 NvqMk8keEEa2hH3SOjZ/Cv8Afg/wPEW7kXfH5aMysSXx94f5zRHOSu1yAgY5XsKAI/KjkuIoUvZI UkuVLY4jjPTP4Ut4kkF7crFe3d8yv5UxlkEkYI6BcAce1dBjJ6tFSV4reCWe5YQGJtu1jtLU+S1N wbaRt7GOPKEsR1HOQOP8M0En/9L4RNsc7o85xjB6mmNDNCBJKhQZwM9W98V/0AH+BMdJIsmKJ442 lIaOXKqFPOemP0qjHbW1r8ikAMxIQHPOew/M0G3oaNvC8joGXEYGQF4LVTuNNuLq6aMKimOIoshI iO04JAPqcD8qAsUVF3aWkcV2ILofNGoBAdgOhbHOfrVa3IkuE3xYjD7QGbGO2c1SbWw1uf/T+JLS FpJntwI0iSPzHdm5UDvVOdZriaT7EryW8I+c9M46tj/PWv8AoIP8C5R3ZkxpDLdSDaI5Y0wzYw3/ AOqrLh5ERoWaYWx+WVCQ3FbrbQzM6Vt0irceeBy4CsRuOOCfxxUkFwoCuJVacMR5YXOwdt3bnPT2 pgVvJRZnkfcHzu56d+npWksc86I5DbIfc4UH2oM59j//1PgG5O2cLDvUleJAeQaqR20kYZhJLNsH zGQ/OTX/AEIH/P8AmnFZP5LvKAMAMADnOen9KhWDzIFPklSQWCkfMQOuacVqiZ7WITGLqB0GQ0Rw FAxUlnAIGjDosgcHr/CR6+/ehqzszFPQW6jG/OQAvQD2qpcRs8cYRvvDDBeq/wCcUJN6ID//1fz9 t4GnSOFnaKOJs+jMfUnv0qVoVid1lJOF+UNyWr/oYStoj/n3KNlblJW2A7AxYKfrmr8KO087LFF+ 8OVYtjaAOnJx/OgCOaKR4y8yqir94oeF69+PeqssEgtmlt1ebywGAjyN3tV097AbZhuFtIZJ54lD r8tt5q+aR6lc5qkI5pnEeZFh+9uUjY2D0qXe+pTk2f/W+CioVtsiZQDCse3p/n2oi8uPJHzkdFJy K/6HXu/Q/wCfeDs7slmu7ieymtGTKBt8IchQp/2f896pxg2hiy3mtJGdqYJjB5xn+dKn1K5ne4y3 MpRxcqDITn5PuDrwB/jUqWkikADCkb41HRB2GK0L51YVre7Ulk2tjHyE4ZucEj6dfwpZdPs7K4N3 LdySmWNRlPnWAfxDb65/lQRKVz//1/z3MZecKAotwMr/APqrRdroIsUOwK5w7d9vcCv+iA/5/k09 i5Gyx2htipZS24lyWK+oyaxrpGZgUl/dBdgQcfjQMjjjkVOpYA9e1aFwongtySImHyOw4VvSgCBo 3t12wsHYL8hPRiPWo2Z28jgidyA+0cIfrQB//9D4KabzkaOVyJIyAAq4ViO/86f9mlONo4U5z/F7 1/0QH/P+NvkiDI9ujh1QKzHrJgnBx261VmuQYY1ngVpYhuLoDuJx/wDroAFRVQvH/F87LVpJRcKU dCTjCjAGz60Cutipc28UDxMx3EckK3zVTmgW6nSaVQrQgvCVb5l4x1/CgZ//0fz2RY71IzMdpVg3 ytydpyOR64FWPOn81laJXiK7QBkMPev+iA/5/wAWOyQ7lhXYZDuOT0PWpBBJsdFJVsgyqnAl2jGW HfigV1exWSMoHZshFbn0HStEfaFh8xMxqSMNs4wKaV3ZDKkkUSxTFW81pF+8cnB9R6dP1pkVm8Ni rzS7ty7gXbLJjBzV+z7Af//S/PmGS8nzLezSXc3X7VNy8oHTPvxTZCWbco247Y61/wBFFrH/AD/k cbsZHkIYDHOT1pwCFg27YCcHNAGkrRxKp+VlPC88jHqKzJlhkuJJ1f8AfyEJKB0O0HB9M80Ec6uP ktY/klLgnldq5BXpye1SxKFlXe2UC/ebPy/XFAnPTQ//0/z+kkCkNtJy4UbRnqQMn/ParyW6Sx8K FZTkN/fz/wDqr/om5knY/wCff1Mu6DRyyRyMRJFlHI/l+tVXti4haPeGiOdzEkN25Hemkr3QFyIp uIYDPoBgCnK0Ku0eW3FsjnNMClczBr1YQ6KrxHdExy7YxyB7VZ+z3AHnQTGMj5enyle/6ZoA/9T8 9pGRZUjVHLYyZAPkB6YzUVwGwVxgg4z/ABCv+ig/59wRHKlpFZVU4BY5347j/PanhFB34xn14FAE kloLxIkYbxFKCChG7IIIGfTj9ajH+rHnRbSsm5EcBmQgnB9jQBEsV5HdlrgxPYyRbz8580Men+TT T5n2hDCGeE8FuAF9M/yoA//V+ABIsajcuf7/ALe9McxKSAR7DGMV/wBFB/z7lKSRQsinc3HBXgCp YXVLWIhWMvZWOTgAAD69aiewCRyTtKWdQgPYcYq3JBIwYrtZ8cBj1rICFQ0BWaSQxoh5BOEPbmp5 pGu5l4wMcDtigTaWjP/W+A/KQAocFcdPTrVgWcqwlkBEeMcdq/6ID/n25o7XM/7EjbVnLOiMGAzh sjoc/hU5dYz5ajAHQmixMpWWhXaSWVlMfy7G5/utjjFPUP5mZFKbuRjpWlPqZEMoJYiQebETjaBn IpHiguP3asRECMj7jcc4rQadnc//1/z8liaPqVC4ChAMHj1pI4beNvtEkbzKiHMIkK78j/HFf9FB /wA+kZX3I7WPzYXkBSIIRsg53KMVGrRGZIxLguSJCQSkWDjnGaCk09hHMzTRxR7ywUuFxgEDrz+N Ot5WkMgkJUocen5UDJi7TIEwVC9N3BqnJAUJD4YDlQDnIpN2VwP/0Pz8hKvGkCRfMT8hxl2JxxTH SFJVd+XBxIoGMe3+fWv+iWV2lY/59xJ7gTTlVTYqrlSTlcDt/n1qsITcvmNwrM+Fjxy/PIFEr8oE iRJcAxglSOCOnNLH9isI7n7SskkqNgKMksxxx/LpWQEVzLaXro9pH5DKoV4QSWQ4HX3PWrX2SeGE StGCchDtIBHuRQOO6P/R+BkWCNTJMSAF4AHDf5/pVdNiCfEausqEfN1HpX/RAf8AP+UBFvjj+XB6 lV/h9hSPAspjcSErD8rZH3T6f59aCXNInELooy5HOVXPWnvLst5YT8kl8n2d5MZKDIb/ANlH5UEx kkrMhwFVVOSV4LDpVmNLeOZJOJcDlGXhTigHN9D/0vz/AL+b5UaCMSMzAFAQCo9aigeUsYjwrDnH av8Aodmnsj/n4bb3Kvkzw+ash3rv3Jx82MdKtLGkscRBDvJlZkxtNv6A/p+dZFqdlZklrtijMBxw eOe1NKmO4hCxHync+bISAEx6D/D1oLujYaxkurd2tSjKHzJvODgdce9ZKx3toGdPKhnWcJ5cyCXz Ij1Knp2/zzSezH5H/9P4FcROskjcvLw69vwHb8KxAy29zGqqEt1VmlJ5Cnj/ABNf9CB/z/m3IscC rLFLDM8ih4wmRtHB+bI/lnpV6/1mwudMW0k0hF1GMK1tqSyZ8sDAdSuOc896B+pn2q7oSfMywHXH tT4iiKEPGW5ApNpbmkNrDPMEjhfKZUDYx13Cpobi1gW5CPJJKsoCQ4xtBHP9PzPpWUGk9SrrY//U +AILxUmJmh82ORvLaPbkQ56M304/OrNxFGwjaNoxDESF2cDJOK/6DnJJXP8AAVSV7CxZLgIFLA7S Sc/pUEv2a2m8m3whZ9zyqcGRj3/kKybu7lE3lI0kWGVZFcDc38/50ojtJnmzLJGyoWyq7kkwe/41 UZKO4FBVXYSzZUHayjtUE0sJWJI90aQjDF2ySf6D2qAP/9X4Bs0R8M5LoDyQOKneJY3LRu7owIUD gj61/wBBB/gOVJ7aJvId9xeF94AJBJGRW4t6ltEptpI/OmiKzIUVxGCSOhHB47c0AV2iH2RQjNI+ C3zdR9KgW3i8iIvKpkVd0uDjn0x7UAMkRlZCqsgdcoTxuA/yaeyh0VFONpy4zzmgD//W/P65lSAM FjaQdDtGST0rStGZojE6MIG+YmP5XBHTnr6cd6/6CD/AdK+hEly4mS3uYEvbZX3xPJhZrZs8FTjJ B5GM+lNuHi8/G0xs52oirjJpdTOpHUa8GLhEYDAI3kHoOatrBDHNJNJKxUQ7UjPzKhGeR6df0qLL kLn8JUtEjN60kZMryKWRST8+OAinBxk4rSu2jVoy0Tx6g0StdWsU4uIovl5CfKCSDnk+nQVMkk7I Z//X+IVR54lispNxRC7ZARkIGSDn0x/KsxpGFzb3CCMSiNfmjUcEDHPvX/QAf4DXSLNzIlyyMV23 MUgkE6nByM9RVVp5pZplWUTndidj84yQCRzQTzq5Ku6JXiW2do5UC+aB+7hYEHk/QHgUwRWwkjO/ cxX95lT8n+cZoEp9xGigmDo4IAbI7E45H8qYsnmMQifvB8pccnHvQaH/0Pgry/Jk85upG0lucY7V Jb6hIkrL5KlN+MqcBx371/0AH+A424t9OLyb9irMwJHTBPQCpZ9Oit1jlWVZFcb1A6YGKALVpIqJ NcqUMiKPLtXYr53PrjHFPuprS5milCHy/LUMjHHlvj5gMds0W6AtNigLBla4u1HmYwjsxO2Nc/Lg H69RUk9qLpbeKaYfZon86SIcecAOFz19PyrBqzsNtt6n/9H4bfyMRSo4DR/cjYfcI6AVKk0175zS SFJpZdhdvlA4x1/HtX+/B/gQm1sU/sF3Yb4p52uFUhwwJbAbHf8AHGat3MEj3MV6gMttFa+UQTko Rknj6Ec+1D2sbksEpu4440EYik+UKBg4PcmjUbBoJbNrmJFtbVRGpjXaXG4scn1OTWDi1uBFFfBb zdDBhHUhJB0HtmoY99tdtKSSqtvZex9v5UgP/9L4xtpIryaURWQcSDJyeU9s023hltpXRkEax/8A LIqNqj2r/fA/wVh8KMi9EhG6N3iDPlSH2OMH+VLCDarLKgBnuIDA7PyCpBBB/OsGrModp8IisTEC oKMVbaOJT16dqXfBcWzR3MUYeOQ42vlyoxgkf/rpDTa0Q2RpUa2ezkCR4MLKvyOhHfPvWnBfkKsV y+6VjtjyM5HNK2tzRTXU/9P4vnvYYW2RIm7+Ljg/hS2UUj3TSxxIEkbcYycoTjHT8K/3jcHfQ/wb c+xWurfyPtU93G0MaMWWJV+Yc9Av8qp2tjbyS+YZ/JST54xcYQop9fepsxKb6lfUbRre9RUYOhBU zq37sA4xge/9KaI7gKYm5aJizORg/Shxa3KjK7sOWzTc13NJtu3UAIr5UoOnHrWjFEuyNEKjPzSM vLn2NIs//9T4iudPaG5tX894wZlL+SCCgyMHNXdRnE13Gu1pZoRlpcbWmBJ5btX+8B/hFB20ERQ9 1HbF5I2YEyzAYEY9FHr1qjJpUM98iWAxLCWJdiAZcc9fw6e9Zy5vkVzq+pZ1cxiCGMxot75QEwA3 bDx0NY6wWrx2kTGScQKJLmWY4VHByMew4/XtWUtFodEHpY7AWtnNGpMqNIyZeJSFfgkYA/AVRt1x OptrcKsbfMBy3p0/wrF36m9Pc//V+TtQZlQTTjYtrFtjTHzNk5wPxJ4rK0VtQ1q9SGK0F9OgL/Ze QoQZyWIxge/86/3Lnuf4fK17lzUbERSSSmz3zPhBHBIZAuODjnnFes/s8aRKnxh8LXTyGCOPUrfb bhN80haTGB9Pb1r5ziObhkeLl/07n/6Sz7bgqCnxPgIPrVp/+lI/u3/Z5tJ7D4Z+GYxAUgbTYj5j YIlJjXJH1r8Qf+Cw32I2mmW2onfYXM8cqW0BHmPK08oiEg/ukxjjviv8y/Cr954u0pf9PX+Z/pl4 y+54X1Y/9O1+R/N1rGqWv9gX0N/A1vcTebbx3KTeWiLgjiPHIIB46c1+PP7QUdzf+Lfs9r5l1Z2N 1JHJIf3QZSiGNgvXgADHbNf2R9Iuaj4dV4n8m/RvhfjNy7I//9b+We3SFo/szt5fy43N0H9a5a9t 8CSLJPz7fkGA3PWuGsm27FNrlsVXtpbWBc5MPSRM5GPeqjaiCrQ27ApF/B2X2rlsSVrZxcMwkQRs w6c84p0RW2l2lUUE/NIwyT9KT2G9SrLcn7R50AKoW2SMowz4wAT61akgF04fzDvjOcg8+tYAtD// 1/5Fp4NQilM8bK1uowMA+arD+lV2DsqPlgZG/eHHGfc18+Nu7uaLQAKoIZjwCB95vpTDDdxMEBCJ g7iTzSl8LBbmbJY3wD+X5TbuGLnHGf8A61adtArYglKjy0GGXqfpWBva2hV8hGbEW4qrlZNx+bHb ipbi38nbOoMYBAXnn8qAP//Q/kbMkAjDfN5oOcrwD9aqoW2zyKWAdvmB4Ga+XO6C90mksZ5okaXm B/lzu+c46gCp4mUPLhmCLHjaRjOPX/PakncoavksvEeRj95lvu+4H5UtraWX2uSaZEulWPasdwTt 5B7AimXTWowyxae8NrGIzpSqxktmU70Y9ApHbqfypYraMFpFj2qz58oDHmZ70Gp//9H+SDfG4eLY Rz8w9AKvQtDgLGi/KNpU8ACvlz1Jtp6FKa+tbQ+XtYOWzlfmHNVmjjuTDMZFDNNtZM7n29c4qZRu vMqLbbTLV6LdJFW0QmLOcTY3svQZHas+2uILSOW3UHz9xnkTqSGPBHtwelY2Jn2LACAK3zxxv843 Da2fpULwiGZro3CogTKxSEBWI7j/AD2oMz//0v5Fo7VZbSS/WSNWxlg0oTzBnAwpPJrPt1uXk27n EZ+8vQoPpXx68j0CfdJHI8JkaOGYiM5Hv3/GoZGhtztXLY5ZgetbQvYqCV9SezuIniOxuS2CW+8c elaAETJujkIDcEAfOD9Ko2FKfaZIZEJ2x8SFxsMeOMAVQ1PzXli+xyFWhOSwTdk8jFBtFWR//9P+ R7yVuVtp7hZGdI9y+YCsinGDxVc3Vz9oijaFPschEe9xjyDz8xr5c+mh8KJLa6KzyQiPGzOJ+ufp 7Ut00krJ5GVkPV8cN9Kws0KUraIsuJkt1YkbU5lQn5vqKa9u08SeTKHjm+Rwh5T2PpSM7shuLUQq EhDh0bnjINb/ANkuLmC3uZzKsaKECwr5joFHy4X8qDdao//U/k7hS5lhYT2zRbXzBOy4MnsR1HTo eeaz5l2XEk8hQPDEXjyfkiZc859K+Rirux9FUlYSKfVL6KCVo7W2VQAzQO0guBnluenH4Vq284l8 xJBsKfu0JbJYj2/OtkrKxEJdTNuLS3gjlumQy3EGZra3BIMjAHOD79O/WvZPg9oH9tammsXFlLbX ZlTUkKP5csC+WUdBn3IGOa9/IYJ5lh495R/NHgcS1HHLK0v7r/I/UPw7pd3Lb2OlQmNrkxx3Bl2g 7t+11aQ/iCc+4zX9mX/BMy2Fn8KtFaZbMSXmkrdLcwuNzBI0Uoo9PmFf0/45Nx4Sy2mtr/ofm/hB G2OxUz//1f3M/wCCsWp2GmfCy9iu/Pk/tWxC20BbPKghtg9tw4981/F54xv00+6ub2SP7UtncO0s M5JDBWJVcD2xxX9o/R/pqPCk5LrJ/kfgnizUbz7l7I/HX4mXUniTxd4mDQxXcct+0jM8xZoJ2Csx GTkdRzn1r5k1C2FvdCKKLDRSsjyOMeYc46e2OtfgXi1K/G2LXnH/ANJifq/A0bcN0Gu0vzZfsbWK KSN5ppY2ZWP7tc5JGAp9jXaaWLWLbHKdhZ8HI+UA9K/Lap9TFe8zcSfbMCrE28ZwQRjGPQfhWxMt vPBJEIwWlUPDIG2lW45FeXX+Is//1v4xtBTb4jg0m4ZonuyscErxEojZ5yfpX1JpFpoMT6hp93Dd R7IAttcXPzRSSAd1PAHHb1718xWPQMNILbR9RaZUjdFYNcxKf3cy9QDitO0ewnvXGnSXtpHM3yW1 xCRBFkElwQOR1rzakrMCpeW8pXyZLkq8b5dwNgcH1FXtJ0m7dCPOQW8ZMiFyIzKe4B7/AErBvqBc m1GNbl4ryFle0jEaooKBRgbWx39z65q5qlhZXPh24m+1TW2orKrW8MJ2rLj5vmPocf561OHl7zsU 1aKP/9f+O2TUNFvLO+KRXVnemNViZYcRhs4cgngjqc81c02Oz8lQbsSXUUO6RnbBcZwMYHXj9K8W /u3OCT96xR1O4ha6sLiwuZlgtzi5XjZcHkED6dqvi9N7E1nZWyTPNOCfMfaN/Ye3XvUSd4oqnuVo 5Z308Sz2Edowd18lW3odjFeCevT9a5/Urm00y3OpSvHFc2pSW13Ng7mYDAqU2nc6IbnYadc3NzaW c80YVAS0wjJKIx+71rb0iCWyvJbozy+RNgIgG4Iwzkg9q3T7HRBXZ//Q/kpv7+C2L3ap50yNvRpY PP5HoMH3rz28vJJLlmmEg+0P5hHlkRk+h4wPoa4aL01N2tLFDU76+NoYLCz86W7Bg3Y8xYcc5/HG K8iv44JJEjvohJLE5LiReAQe4P8AKu+irtIiaskd98Lm0/T/ABHZzNOsazXqL5J+XncCoU9uRn8P ev208DXsbeGNCklgn1Y3mmxxBHJV4JuEcI3VlyCc/wC37Yr+vfo5yTp4yH9bH84+Nsf3mGn2/wA2 f1X/APBDvXUs/Cmm6ELaO3lu5H/tmV02zxPExREdj2GzHt+Vfur+0zp5uvhH41hkG8y6HKY5lkG7 AKswX8AT+Ffi/ilal4kSqP8An/Jn71w8vb+GOHh/06t+H/BP/9H4l+MmhW+gfFz4maTYOb6G114S acL4hVDsgkO4jggkg+38/nO/1W4kR98jLeXVwzXjSKrKgyNoUYwRnP0Ff6x8NS9pkOEqd6cP/SUf 5z8QwVLNMRT7TkvxZFHdXFvNNZ36BGOHS9cbBGCu4BAvGOR2703TrVZEa9nZPL8o7ZFXqfXH4frX 0qVlY+fKj+Q9tJIMoUYsR0f2rF06/wBW0v7RqMKFbu5iFoFdEnVYnIVigI+VsZ+ZcEdiKqKuwOk0 K43RXW6BGhdx5zE+Zn2Yn3J4rIuWtbG/dGKoFxcfZ93mAZHGf581sNNp3P/S/IG2Md5qUMt3I1ra kgFpISgbcAynHB7gfifSp1Glz3uq24ST/QXURTwjzreTcAeT26jjnrX+yHkf5jiNFDBa3Elp52Y/ 3sscAy8nbpVy1SMJbwyIBJcLxFIuH9cfXpUQd7gFpd/ZTKsDJLCG3CK5fLA55Vh6dRWfFbzXscsF sv2bzlZUKE7485+7/ntVjbbHx2dzpUsWlT2LyAQY8+aQrID13N3zUkEsK3GIo3+0qoXapLxsB/F/ 9agV7I//0/yitoDKZJpQyhl3DzV24/A1eTTtGjt7ieS6iNysQZI/MO/rklR04HrX+yB/mNzqOxjW 2p6jf3ryG1t5zBABDcO22VlA2AuuMZxjnqc1Sm0t0uZrz7RJ57usgjz8sO0D7vtxn8abVhc61NyR FktBeS3aXF3dbbcrLIBs28AgZ6npz6VVstYu7gz6H5dv+7XzYZnYAtjqvPHHWtNFAxnPqzMkj1LT pJHvoiHgOTH91mBGeB1wR/Sr+l3puAViSCMXR85xNgMpUE8MfbPHfishN2Wp/9T8sLrT4ZIYZ4FW KVYi10CNx3ZOMH3GKpWVtHPHKFwGt3yQwxz1r/ZaHwo/y5bbOgtJP7R0i5sr2zs7aOC5dJbryl8+ 4j2L1YjOPYdcVxn9sbYvKubeze2g/wBEtUEPztHk7R+v4ZqhNWNjRzbrcwXEiTv56eXIkQwIVXOF zW9Pco3n7FUGNT5SnqcdKCJNJGVaJLdnMg3TSNmNX4yfrS31zPp+6MwxJOw2Fl+YKfcUHJPc/9X8 o5FeWxMlzeTOxcB0hA2sBwBgfXtTp9EvLUaY9xNCbO9iZ/s0b+ZexKuNrOv8OecCv9mD/Kpzb2Oj FtDcCMRLJbNDCAsijazHGNxPqaq6bpqWlxDZ3MspDzHzZfvSFWOT7d8VUV7yE5NkBvpNLulkTQvO kinwqeYrBuf4ckZB4/Or1xNY6rbNeEXdjcCbyl0yNlkCg/38HOB2/wD11q0nuHPIzLpxoqK/lPN5 i48lWCu+R1GSBxwaopdG41KJbFn3SW4+0JjZGD3J9wB+PvTSS0Q+dn//1vzPjn0myhnu79pvtQWO 2WdlyXAOMEdR17entVK4Dpcyzo6NZPhkwM7Rt5Jx6nJr/aA/yo5nsU7Ge0WeTUFll8kAwjYoKiTk bc/56dKdM2n20co1C6uWWSNngaKPLqTyAR1wM8kcigxm7suLb2+jypCbmKVruy+1RRiQynb0OfcH jFYVnrs9zbR2wkDpDcs/2p7cLI+PlAxjkUEGznTpIYRqcghj80PHNBHidiCDtwOucY/Go7yC2ukW 4XELDIjjACl17Z/AUDu7WP/X/K2xW/01XJRzZli7sxwkWf5VdlnfTFS+EBzf5cw3C53j7u7Genpi v9pofCj/ACfHvcWlxaAEyRy3M4D2yZ8sgDOc5/DH1rQuo9Ls4Uv7USQ+SB5sDqJI1PQ7cDp061Q7 tFLUriaTSTc2MHnOJduxLgebKDjA8vrx1z0qWOxENvHJKIzNNCPMAfzBHkcrn1FawSsTJ9zFbTbA zpHPcTWduXDzSJH57OAfu4J6HGKvtrVkl/fS2GlTS6Q0wt4IZE8vC4ADcHjp6n8etUlZWM6skmkz /9D8ybOESyyTW7SqJBnyWcssZHoO3pxVjUlvJkEEUOTIUczMd2ChzhffOD+Ar/bB6Ox/k1CnJwbN JPteqaHM2rT6dJeRO0X2rzGW6eNBwHHTd24B5A5riLNXsoFhjHzFhGTIRI6D1Jq1H3bnPNNSszqt DSSW/kk+1Su8MIDYBIbH3f8AD2r3z4Z4j8W+Hb67ldLWDVIvtEH3WnDMAOvbjnHqKWJV8DVX91/k ZYK8M4w8u04/+lI/ub/YNvH1D4Qabcl3dZIFYRsTtiyqEAevf8683/4KWaRLq/wC8WWp8tY00+8k VZQoMjLaySKoJ558tgAOua/yxwDVHxkXliP/AG8/0y8Qouv4X1EutBP/AMkR/9H5LkS007TbRppn SzS1GY4yBLvH8I9s9q53+0bA3cp0+DzLqcqZtkeGQKoUb2xycAAD69K/3PwjvRi/Jfkf4mYn+JL5 mdPFJI1zPb/L9nw1yWbaVJOMY9c1ZgUaXb2zaqqTCdhcu8cw8+aBvYcA4zXfD4UeZL4mX9Kh0uaC 5j0/7ULfzHeFLlw84TPBYgdfWiz01tSMyzzkWNqp2qX25Oeig9jznFaQ32MZboyXjNt/pMNsItgM TSIdsm3p198/rU9pFE9uwZX+1M+6NhJhcY6Y9c+9bbF2uj//0viS1W8kZoZWIKDcqyMX3EHgAjPP 1rSgtbl5zI9upaNtklnIuN/HO70I4r/ehan+GEotaEtzBeLHBbx2kJhMpE6nK+WpHO3jmsy+SG3t raFbdolO5GYrtRAp4zQZe8nojMe2xPZyOkclomZI3Q5V3GNvHtn9arXwikzJdRgweYu0YJOQwx+t XC19SHe+ptXumw6ZKlxDLDObuzWTdG4k8nI9B0IrOTUEvI5NPuxNIY0DCTlBJg9D+XY1sld2MZy6 dj//0/iXTLy6s55FvZE/s54cRW20yXBbIxg9AAKtC+0pblpltPKUgJ5cnKg/3vx/rX++6jyn+DUp XJL3VdOuwqm1kQIoWOKLAjB7t/Os/UjEscH2WzDQzI26aNR5MbABfm9+f0p2W5k5JFOCCEQ26XLl Zdp8yVT8h9jXUWzadah7V5DMDEpV1G5SxUMQMdcc/lQLnVzEjv7W9vY7q5t4ZI40ASB0wmEXauR+ Geep/Ko5WjvZTCiKFyXKIMIo9hQZvc//1PiKSCRkSJNsjRn5cN8wA46VpWyJcec7xmMiPYG3ErCw HXHpn0r/AH4P8DI7tGJFI7rPD5cfnJIVWQnar/Tviq81h9nljiaeORAoaQRscgnkjOKEUSPFBKJ7 S0Wb9ynnhpOSR3G7uam06K5UNKsIuAThoQ4WYY/iwT0GTXQZSVmJOiXksnmwRDY28qy7mLA9ee/F WLxo0gthCCsjJuOeMDpyPrn8qCOtj//V+FLeVxKryMdikNgVYvblLyNjHGW+zMN5ztJU8cCv+gA/ wLiloSG4ty1ulpFiPPyxt8xXrmr2qf2T5Nn5kUGm3LfIHcMxck9W64z9KC0rKxl/bVt7gJFILhEQ LvVWVJDjnGee1W9IePUtRvFvrq3tDLcrJbRSTGJYYEjAk3MeMkjI/wAaDaFr2RTu2tENykEDyiNs LcfejAJwOevP0qtbQ2bS2fmsYiJgXJOItvfd/P8ACmnYT5VJJH//1vhOGeOeXUriFtscO6LjpIBn jH4Ulp5EiRFZGbccyleMc9B+tf8AQQf4IaWNCKO0FyZQqxsWC5cDkDufb61C1/Fa6i4EcNtFKoTd 98Fh/F6YPoBTSb0RhK19CG7gl8tMmGcNMWEsfJVe3P8AhmsqVYzNLtjVXfBO1QoyOK3J8gL288iK 4XzIY8GJW2s/J5IqdriQgxwwvCjR4kYNlSR7df8A9VBM1dH/1/z9jeXzSAhYrxjGd3uK0JsSW5cb owMeYFOAfSv+hFK7sf8AP+WIrqJ4PICHeq5LZ7VXWXEUkak5xsTtj2/XtVpe/oRPYjtWSOyuIg4S 78wbgRuBXrgH61p6V9jywdEed0KeZMdyxk919O1Q3d3MY7IxpZrcXJgLFpe4PcVc3WcCJ5gRcnaF U4LemBVU9wWx/9D4EdnEu5IiQzdBxinKLjUrj9/hNiCLaECnavyjp7D681/0MH/PvsWohHGy2uwK qsVWcAiV8/3uSOKnuY7SFElglBRAAQ5/eE98/j/OgmMrmfd2UtrIsrSNPbX2xgm7dCoHDY/M/jTb m5jhZoYgcMNwC+lbQ2sUVYIYZyl3PAZDGwZFlBO0/T8a3AirHkAwoBvVDnH0rOXxMTaW5//R+C5J ldAvlktjp3qp+4LmSZXSOIfPtkMYH1r/AKG21zM/58oStoyVR+9O3MkIG6PJzUryqWG5ACOmOAKc XaLNRE8wu2FJYDP3eMVPa3McDtJet5SkFfMxlVHvRF2XzAjErsf3bhg/Ac/dIp0lukbMvmrJ8oIY HK5x0FaAf//S+CI3QqQ8a4+6KTE4bh12qwZRjkjjIr/ogP8An5i7MsvLBJM6PIYw8O7AXKkjoM9s 1mPC43NzsBzu9qC3NdCSCfaxwMxsuCOoPvWxHPplzbtbyowmiXMLqeA2f4h6YoGpRM4NG29Yx9wd SOBVH7QyTF0IVVO1iRxQHNFH/9P4KlmBUS7EDgenBNTxyS3Plok0cTtw7uD5Y/AdPwzX/RAf8/Tm +g8MI0MV3kS4z0wWHY/yP41DPBm2do1XahDBj97HcUE8z7kdsUmjBAKFcq3PDCjzIbZpM87l2pzj aaBBHCvlvKImlKDeQPmJp9kLWaRZZYW5QF4W4YKOSMf56UDUmtEf/9T4Ec6RJcPHpqnZAcJLn5Rn BKkeoPpSEHl2DDy/vMPumv8Aohs9j/n6U31IfPfzC0JA9Qe1Slg0iyMWVlBwFYgN25HekTfW5NIZ pUj8mIKqcytgtuGf/wBVAur0yKvmgQqP9WYxtPrVwTumaOa6E0ywRyH7OdyNz86gH8qZOfMjwFO0 AKO4PrWpDk2f/9X4DikVG2MMgDAHpT54gqiRDtB6jFf9Eab5rn/Pwm1oilMQseVUnJwQBTUIeMgg AR/PjoTWovIiEo3gqPlbkHPFWZJIJZVjjt3jdY97SjmI44/PvQBGF+0kPFIdsbBwych8dvoavSSw 7AZOG3YIC9ayc29gP//W+ACU5GOCOM9qaLoxFAzqqBsfN8u41/0QH/PuOuCLiaRnGVkGBj5cHnnN O2OkEiCQrwAu1cg4I61cL3sK6vYhnifZ5ihMqBwOCfw/CoIiykuFV2KkEYyc4rUZFDiXeWtvKnhy DK64d1PTnpjjtU0M88aeSwDKXJL7cE0Af//X/P1bdHWRXZsfwsh2kc9jUQ8sXyFfmhUASQsfmYdz ntnBr/ooP+fcmu5OY0hQeXu+YE5Kio7m4WOSEfZw0G3Yw3FfmxgH86AFsA1m0k8iM8RO5kyTt4x/ QflT7maO43PCqouepwWYGgCoQoRhI7MScIPbntVmzkSKJ1lQHPIJGCKBXR//0Pz+fyiPNHygn0+9 7VKYxIFcqOm0YGOnSv8AooP+fTnRSmtBAfkDPvO5/m3Ad+5/lT7XyZsgkYjOwbRnacZqZr3TO7vc YwlD/KhUKcHI5NWyrOoKhsjqc1lbQfO7WI5UM0YimRXRvkx257mrYRIFQOd20bQR0H+f60iT/9H4 NQQxyDaQVPOMV0+o6paPo9tax2ojmhBUTg8y5bJzX/RAf895ycMBmkMhO3AwAT96gxRPK2SN0Y+Y elADnEfPljBA+hrHm8yRGjDMjMcb16r/AJzWlPqBdjwihMZKLgk8E1IkcfnZMbP8hfYh25xWgH// 0vz+lkmWWH/RxIm75uQNopXgctJJtCRu3CKSVAr/AKKD/nv2CGRIQqSKMBskjguD2qJYme5eWGBm ijO6R8fKo7DNA02tiy92zlAhQ/LsY9CoHYUwQI7K0mRg5ypxu69fWgrnZYnVBtReARycVnpZsVcr Iz4YklzyM+lRN2Vi4yu7H//T/Pq2M1jdxSMfl27onBHyEHr+n6VNcuru8jIzKwJ3A4IJ7n1r/ok5 7JH/AD7kNtHHKGVnAdeT6kemKkbZtEKoo2vv8wDDfnnpx+tU2uUCCLyUllEav9qUhgRwoXnJ/PFO njR/3jHczEMxx1PXNYjW+o6AwIC3l8N/Fj8OKeHaeaQRBwEAVnIwG74H6UAtGf/U/P28SUrHGmeM PjHUZ71EXKhU2kF/lPGfr/Kv+iA/5/JSstC9DhWjaJSWTByVyAR6iqmpxJPNuZFRJzl0jHlqxHU4 H9KDIlnmT/R0bl+EVVHP4/lTLlAGUMMk8jjNAD2tpW2xp5aKSJHLDdxgn8KZuNo7GZY8Fcjcu5T2 /Dr7UAf/1fgWO0t0i8xCBJIu7YGJC4P+elMQMrZRTnvkda/6H3JJ2Z/z7N2LCRrIRHIpHGS3pWW7 RRFoY/nuHfdIqnkqMLn/AD6Vi3djHyAhSFGMfxGpgruqlsqF4bjrSAtW1xJE5SEmKJlxNuO7efUc cU6ZGuGWQCSVoj8i7yFf2xnmgqL5Xqf/1vgSSNA+0MVlZeI+uz/OapxWM0s8iSgQhBwW/wCWhx2x X/QlJJOyP+f1SV7F2KzSR2juZFiAX5S2ecduKvWtgYswPJbXCbyYHjiwQCOAxIyen4VJRau9PFjb xr5exZmz93GCPQ/jWS0ZVxGEJLqTvxnGO360W7gRIgLMDKiFF4VgcyHIGB+vWntBbwg/Mj3dx+9U qx3pt4IYe9ZcnmB//9f4a0trWe1lt5LdYZZJNsjuo3tj0Pv7VVurf7HvgA3Lv3IG756Gv+gpxsrn /P8AkAt3QfaUCqS2GTp264/D9KzhcrNcSEwFXiKhZgf3cvuB6561JfOyz5RmnErnavmbxtwqr7D0 rrf7YsL7z7dtMgjQRLAHTPVQOg9T/jQNz7GDKbMXAEaLsjILxyDAbFM/s+C5W5acrHFLOJSI4+UU cbFGe9Audn//0PgeSCZbxVhkjSxRCoV12yyf3ScHHrVoxRqVGVORnIPFf9BB/gHzjlFvK5jij/e7 cMW5De4qaOG1KyG4T9/GwVTH8mVH0+nf1oITa2Mma6maRmhXy8ZSNXUEKORz+FI0DCP5mEpAAkeP hef5UDUmtCyDIv2dQVkiWPad3Lp9KvXMdq1t/ojM14RnyADvf39KDTnVrn//0fhKAw2sLpPGJp2C kvkhFwCSCMdeevtWhE/m20ksP7q2UqlxLGm5E3HChsepFf8AQQf4DRlfVFW9gi2JGI8zKwdGBxkj nJpu0rP51ym4ZyyIMbfYfyotqTU2M1d95JKzRTWo88Kkm0mHAP8AEcfTjmhhKrHzCNi9c9MUlH3b DnpEcskr3ETW58uNBj5Vw2fXPWpVujZStJID97b5xHA3cAfrUOD6EuTTsf/S+DY5niaUsCGmPOBj dWjA0VqufIXOMKXGSB7V/wBATi0f4BKVlaxK0th+9aO2YtLHhwzHYpx1XGMU2ytIZAE3rGGGGZfv EgYyfU8Dn2qRNp9Cq1zc28jBGPkocMAflbHcj/PWobm+hlKssSiQn59o27u3NAl5jvsd1JmSOJ2a NPNKgfw9aW2R/NnaKNftTRh2UIMfQn2osb2sf//T+DkzcWzeZCdzsfMBORn2/KmBIWniQboxEmSO QrHNf9AB/gOad0kctsskPkJv+QuwyMjnj8qgnubGbSUSEu8iEpNtUqUI4JU9eaAMmK2nuGt4laRL dmALEfvmX0B9e3NbDW0KpsLsPJzvLcSEDufypN2Vyo2vqPe6UII41KxugA8wcSAen5fpUOPOljDJ 5QKEq5B2NisW7u4526H/1PhexmsZRMwdZZLdvlMeJI2bPRueK2JrESWv29YNhCgsy5XAzg8dK/34 P8BzO+0qzqsrtLCi5UIOWPoTSPLPLH5cabIxk7F4B9z61m520R0LUgSYRBFAw2cAKMYrsljj1DTG E8j/ALrD4cY3kA4/nUNt7lNJLc5xbiCNY7eBQ80bM7D/AJ5/U/hwPaqdjI8wMkwALS4APXbnqf8A ClsSlfQ//9X4nF1eRXLOr27xx/LGLe2W3xxj5sdT7mo7q6meJiC3n3BCKAcZNf72c/kf4LpW0Rjh ZwxM5LKhweD8prdtlhvZIgEyjx+WFDfMTjHHvUuTegFEQlGltoX3Ijf6xj36YPv61NZ2oW4RmQSB DiVs5Uj2NTsJrQ2JIVktGghhhR5pg5lKASRKCflU9vc1k3KiBY4Sm2RmLLMVBRduBtJ9Tkn/AIDU c6Gf/9b4mtEhtL2OS9QTu8YVUj/eKGbufp71eKpb6hcTJK8Nsv72FCvzf7o/+vX+8vOj/BcdPdRX n2e8nVr2KSYxzGNxECq4AAwOCOef0qC7WzvTI8SmAKuyO3f5iR7kDFHOrgV9rlEjRAwACnJyeKbC 05n8mKMeTNlZ5HTcE28/rzRzouHWxYv7bS5vKht5JFuYY9vmKOHZjyPpwPpUVnAI2eJ3BYfKCpzg 1DaexTfva9D/1/jKRbu2lgSxmWW/nby99wim0hGeGbPp7CpHtbrTp4zdvHKxHmM0bb1U/X09q/3g P8IEr6IrJdxX9w7mOPaQcXCNsAwf7v5/pV2YNE1lFbWMxjeKS5nvYzu+UFQpI7chhnNJtWBLWxkr FPqN012R5iibY4+mBzj6VeV49PuJ5SYvLmi8qWB0GRyDkfiBXPJpas66avKxXJJ8iWBAHa5DiaRS IggI3Ae+N3511lv/AGU1wv2e7jjMsImV5flB4Gc4HqazlNWOmmndo//Q+eND8F33i7WlsLS6tJ5e Ggjub1bKGch1G1dwO4kE4Xua5zxb4U1LwBrk1ne6fdw3LOIkaMFkkiduGDDggYJyDziv9y5yV7H+ HnK1qU7PTmS4Pm3+IpR5sYLmRlzjI9v/AK9fTP7M9sLv4k+HIhbyiSLXrTyr0qD5gM6gg/RdxxXy /Fk1Hh7GyfSlP/0ln3/AEHU4vy6H/T2H/pSP7kPg/pc+k/D7Q7VZGl+zaZDs8w9B5KAkjtjB/Cv5 xf8AgtbfzSa14YtYrz7Ao1bTJbmLG9LkJd7iSBz8qh2+nFf5r+DSVbxZpyX88j/SLxym6PhlUj/d ivwP5+Nf8+Pw3q/nYurhJoxbsYlKxKZMOU444OPXFfkD8Z9dW18Q6ldLM5hluh5TyoFlkTykAZ8c A56471/XH0k5W8O6iXdfmj+XPo1L/jKZ1H5n/9H+U6zvXvMqw25B/eMdoPpilnka2tBM8cUolLIy KwkcFSO3UdRzXn1ZO7IfwGSLiS8gZ57cQH7rRMwY8dD+OKyobVrd3Blt5Y55N6RRptkiHbJ/z0rn 2CLSSuEqiFkkYjejfKi/xj0NE/lTxxvkKzjDIThlpSV1ZFN2VyjI0dttUbmZuFwOM+tW1DRpkZZj yT0I9qy5ZIE7q6P/0v5J3ml+ylUZUZuCzjIHvis6SRzGyJIZFLAyEDaufXFfPgJH57SofNIZcAbu FwP/ANVX1nEiOZSWIPy/7WPSlL4WBQa6JYoATkbWjB4/CqojFm5uoyxkbglyX2j0INYGnPp5kqyS QYmXYd53Ow4Jz6f/AF6ml1AXEZR1IYcq/XH0FBof/9P+Q+2ljmjU5VmyVK7cZxT7OETXqWd0jz2s cpmeNhtBU9F+ma+XO2F7Gxqk1sskEEHmMIPmUnhQT2/D+tVo7a5KTeYglEnKqp+bntj0pRSRY2e3 a0tJZ0XzGVQWiClmKjqo96q3DiZ4gsIgk28gZGB2plwvcWx8PX+tajDFBeR26RZlu45lyZ1HRVOe prc1bTtR0SW3mu9Ouzpm5Y31CLBiViSCn1wKlKSNT//U/kVikikuJZE3iJ5CIwRhsDpu96uDytux zsY8ptXlq+XPTk/eMi/hjjuLYthY3kCY3YZjntVyHck0oMEQVVXyW3FpSO5b0P8ASo57NouLvdFd njMsu7IIAZznhR7flVyREW2SQzRBncRKjAmRQBwc+lRLZCmtCldTyLE8d7cTy+WVjQnDZXvyPw7e taGrLaXFiIo4UmQxBQ7jBjwBwMH8OaTd3cyP/9X+PS4hEsEbuCfs4wgBPy9ugq/aSPbW2RI88+QZ JHGDtJ7D2r5BaM9A2I0lnAnuHUxKMRrjByPWrEsWmhJHuZI7dWTmQ4GPwrRSS0A5fQys1tLLK0c1 razSG2nRQZGByeR7A4rchglCi6tSqSZDEuC+F69PXGaOdXNotNG9K0aSRxvgtLHucDhhx3FVkihh 8yUxghc7QxyD6HNPnidEZJqx/9b+SuGUgeZPI0hYlUZhwo9Ky7wsjyASgoeXUfwj1r5ZNPY+li7J IW0LMCOI1I6vwWHrn3qeKU5THVG+UY4H0qHKOxm9yvqN06QSO+zyVXMxz90cVr2i21pbWpifzfta ecx/ijJ7fkAfxrN2QhlleW2rXN5bWzzebZkeefKICDOCeRz0rd/tWPS7ZismZoHDwKy5349R+H60 GinpY//X/k4n8STXaCaXYrSOZFhRfLRie+2q8dgl2jTOTLPOpVoy5RMH739a+Tg0ke/Ukruxev5W sbVYIIEmmiiCwQxEIW9s9B+NZchEl0XWR7eO1thPMJEyJWb5cBun3s8emK2ja+pEJJaMLJ4jdT3m pNM0ckAhtvLGUU9eVPTivX/hbe3Vx4lsrWxlnleCF/KZR5nk/dI3gcc4PX3r6Th1JZvhr7c8fzPm eLKnLlFfl35WfrZ8PNDnk8TeAbK5MsoFxb3V550XkpMsyiNYNw+8AXVsNx8lf2vf8E9vCFlp3wj0 +e2s7ePzLLFs8fyvFF8pZcHoOAeK/o/x4q24fyul5N/kfEeDlL95i5v+tz//0P2B/wCCv+rx2vgl 4roB7iVorW33kbYELoG2/wDAcHI6Gv5D/iUulWsF9qF1LO0dnIYILaxh84akDI2x5R0GOAWHGK/t jwJvS4MTfVv9T+e/FR8/Ec0ulv0PxG+LestB8QddjtraGxCSi5aa3XasgPHPqflx+FeI6hcyX1yJ ZJC7SSbi7cbgPSv5s8Sq31jjLGy7Ta+7T9D9t4QoOhw5hoP+W/36/qCyXEjgiPCo3yjr/n6V19lB fW3kRX8KJDfjdbu4O/Kjse2O4r8/rQse3F+8zSZLq3dA8ocSSbREBgge5rpbQwou+cvgYSAoNwQ+ /pXk1lqaH//R/jPia5vdRiEH7+WxnFxLJjDJnu34fzr6C0uBrnSpL25v7i5uFl3mK4+fKBf73Xj0 PbvXzFY6nJ2sSbIbmdXliEYO0yhRhpgvQZrrUuxcTSNDYRWkBQLHbR8ldoA4Pvj68mvNqpamq1Wp zd9c2Gn6tp66/a3sOn6mzRwXYiL28Mqj5RIe2Tj/ACKmuLa9+2rHGGWxiT5HBO1yem30x1/Gud7D JbZ7bznS5ee+vI14kniysSnoqsAAenSqeo3aXsFsbMXD3G9leFcCFsccH1HPBrGjfmbRc21BJH// 0v44JrHzHhhW8EYSMkRsuVTPPP1qC30W41IpbJqcmmb2w9xDguo9Bn1/rXhXXIec0+YisDoOnyto 730mo3VtK5WSRPn4z1Hp710EFxayfaoRhReW7WzToNstsSPlkQ9mU/1qW9LGsFaTMy/aDw7oqL58 2oNbJmS4upQWkweST0H1qxq5s7Cz0+aOw0LxFY6zBGSzSeZcWbna45/hwTjnjikdMFZXOsudT8y3 0/S9H0qaHFuJtRu3hLQMecBfQgYqDTtXe2aezj3TvJH5cscyA5XI5U9un1raDujohax//9P+ROa5 jaD/AEWU+XGhLA8sT3H4Yrn5ryW+02IWtozTbg95bzgIdyswyvX+E9/evOpPY6CExG3SK70uT7Jd MGQL5m233MQN57Ar/WvGPFqxRXs7PfiV1GZmAGGlBO5QwPzD/ar0cO9Sanwo1PBV3ZW2q6JqUzkv NfW9utikO+bLzxjIB9s/gTX7i/DmfT5PDGmWNldXMGrafaCIw3UZRbaQDeDG38W0sM/Q9etf1r9H Ca+sYuHofzp44K1ChLzP6af+CLviq3sNVm0sSPfXM10sU9zeoxJF0S7MntvLnJ7V/Sj8boYJ/hl4 h89EnS00djjJ2yrsO7GPfFfkvjJS9h4gN/3/ANT9y4Hq/WPDKh5Qf4I//9T5V/ah09rP4wfEe9YS aabe6g1KWBv9SI5VihiMeecLjk9+a+QtVspb+eQxeRBvOeu0txkkD8+K/wBYeD7T4bwcr3Xs4/lY /wA6eKOZ5viXaz55fmQSabYfYLFRq1wl5BdBbnT2g3/a1IYKfM5wM7ePrWpO72NjBDHNBDDel454 gVeZiu3aFBGV/i6Gvpz5tRatdnIi2uXvzZW11FP+7Wa5dfljjQkEqc9+3HfNW3ZEupdOfCTADYwG 5WBHBHtWsNhu99NhRb6fbW11a3S3RZo8rqMIMNqshOTzjlh0wOPrT4bG1v7qzuLm2uJBOBC13BH8 xEQH3+3I4z71YO5//9X8mdYtba1tPOXyWEp8qCBZQ7rs6lhnIx9O1c1YQPapdSiQKl5L5pjR9yZA AAb3GOhr/ZA/zBcmyzcJdQw21zEkrpcO0TbAUD7cZ+boeoqzroknt4FjjRZl2RK/JKs2FywHpnBI oUeyEt9S5o0Om2sEdvqhP2m5mEbTlC4hPTp6Crcst1oN4WtsHchSKVG2743A5IxkZH/66DZ3S0K9 9rH2+5gZ3EN1JlYxK2TJgfMdx71PpMMUF2J2ga7QKRIyNgoSMD/PtQRzNxdz/9b8tL25iW1dIkYT spVQw2lc+orirMSx3O26hBXcCJl5LDP3WHp6/Wv9kD/MBxaN/THtba7vZpQ8BaIrGLdd8ZycheTw OP0qvdPPfR3HkGON1IAZyVMwJxtXHHA559PwoERTQ6NAbfTVUG68vM8zDYysRkgN7dOKsLpMdoIV svLublW8ze/zOoHQA/1pt9CZRubM90k9tey37WsV28UaWbSxkmRgQjKO3T19KzbhLfUdWRla10u0 itI4yhHM0iRorEbQAN5Vmxjjd3ot2G1dWP/X/LTz42VYxEFbzAMg7UJHQt+VVWnvba+lhnjURyRi RYxGAJPTY3vX+y6VlY/y6jpLUsrq0Elx9nuw1vbSph4wMvEOMjPTNU4/DqmOeaVX8gTLLZyiRSHU HIBXGc8DpTKa5v69TRt7+KMf2TaQOo2+a8jxYllfHQHGSAM1k+dNp1vbatfwyLbXt00VrKQdioB/ y2Tqhzxg+1Byz3OgtLi1nVFVGJQi4SZQQp9s9O1WNQhtr+JLg7fMckCRVwr442ge1Byvdn//0Py1 s7C3CNIt0gMEm5oWIB/Dmpmu4p75wxdSkQiiKrkMR6+1f7MH+U5Emr3FvLdRSqhtgoT5gN42nt+l TaJqlwlw+pyRW1xbxTqFhmb/AFYxnkDk8Z9j0q4bmb51dj9Z+RJb6djJPMwKwWynEAPTCAfy9Kq6 A8c8N21lCzuP3k92U3YxxsOeh9q1LV7GlNbi9kiRwoHl5l81sNjP8I7dqjn8PRWn+k28hl2jdtxs 3j0Uk/qfWgZ//9H8v57KeVY31Anz2ceVGq5HPQN+QrQurZ1sLe3gEayTymLyl4fp2H+elf7QH+U5 nabaQxIlpdWcl0sFyZnt4ZzbROcnbI/uuT0qS41eziW602XRZ5tQdxFaXrDbbQAlSzK3fjt7Cgxk 03oNElzZNcu9pFqAt7QxJOyGQwjIJ256DPrxk0mkW9nq0tviaG3S2BedLlWEQ3Z2r8uSBxnp/jTS voiSAaTLd/bZra7tZ47FDcW2xysU+GA2qTznBJ59KeBazRQXVqGIMa7jONkkb4GQFx0zn8u9VCN9 y1G8bo//0vzsQ2htIIZ2V0k2mXauSGPQ4PoeRXPavDBBc2UF1dm4wvlJJIP9YoGegAAPsK/2nSsr I/yfLxOgKipKk0Bdf3LQqCqMo6uemDUM0Zg0aW8t43vEguvLuAAZZCHBK4Ufw8EfkKYGXfra2k8d /FBLaRSwhY43jYMCwUsgH1A4rPguLyaZJbiEpCkp8vgjeDx+VbQXuiaurGhqW4go8ZSNlGxgMnOe QafpNjthPmRiYM2yLacEZ9R+dUc1VN1LH//T/N+bS0WBooTOAyfvHjJSSP6Ec/jSrfwKwgmG2QnY u7g9/wDCv9rWubVH+Uar04xcUiS6soGsTBaur+cu6QkHIYnP5+/0rkolt7SQJKS0+7aVYYHtiqV+ pyVWpT5kek+FvLtZZZd2Yp4dr2yRljM+5duPcDd6da9v8PXVpa3WkxJp5uWvrxIGkWEm7tizhVIX rwTnjpWklz4ecPI4Iy5cfSqdpJ/if2sf8E8NRM/wks7eKbdbRCOOEFuNywpuTb7EjPvVj/goraRX fwT1kTLIVW1mhlEILOd0LhDj6tj6V/lhjofUPGFzqar299POVz/TfiuX1nwqnyrX6v1/w2P/1Pk+ fTodNZ9NvcXqwxqquVKNMpG77p5BUnb9VrCujb20ytCklrZtIG3eWRLHngZPsf5V/uVgXfC0/SP5 H+JmJTVaa83+Zn2FtPetfxWcj3CW87NqErRHy7zOdvzdPSrcGiQ3cDtMWSQqyAHgR4ztx7A9q9OP Y8iTsV7KxvbGG3V5IJLpINl5cQqYwSMgjnscfrT9Pubh/MjkjBWFiEVOWck9/wDPatoNLQy1epZ1 e322sdvFKUa4bMqsf3g74H0rNsUgVjG8p8xDtVTwOKt22NFVUY2P/9X4xxe71MLWhjuMxq4B822A OMtnjJxxitie8i0OCLarTSXHzux5aQ9CxP8AnpX+8yUloz/DL2sGaUOrQsg3SmKRYvNhIQsRu7Z/ xrGmvLSHbITHckMd0Uib0kPcYNVaVtTP2kL7DLK/0zUIrqyl0co+3zBeLKQkGSMIqjpn/GseaSeK ZLOaGCS2jIMFwsY3MP7pOMnHvnpVcjsQ5QT1JJIVtr9Cix3FvLF5jLEu7B7rj1GKZcxqEe6EAhD9 bZQCy8dR6E46VrG63Oeo4bo//9b4vsLWC3iedd+Z4sPFOcuAcHj07cj3pLyxWPa80SCCZkTzlf8A djeQMZ6Z5H5V/vopOzuf4MS5S7cWmmWsUMcPmSl4iN0hHUdcn+VcmttKjzzD7R5EjDcnmExRkcA7 e2cfpV31sZS5bF63s7/UhLbWNnPc/Z4vtEkUSeZI6ggEgD0yOtXrCeOyFwkpPmbQLZdnfIyGz04z +VMi8b36DV1Sz8+5ju9GwpXC3yvgMSOdqDpg1TENrFLHNbNMyNy+TznnOPb60GUqkUf/1/jOO4tr e6UMirA0X7sLH5ch9fm6ehxUbXkrxPb2KLtllAuHI+ZAeCa/36UWz/AZVLMzZYltLnDOGMT8OOj4 PU1WuVd5jK0REc/zo5XEbY44P4U+Rj9rZhCiySMI2ZXVeXHTHPSm291aabe4lnmmkuMwxAjb8p6n A4q4ppWIdS5cRkMoOxpByZPLGdgHc+3IpWg8uVjIQDKn7lmXdGAeBx+NUTB66n//0PhdoHhIjLpK xGSVUqM/Q1YtBDdExHKKp2PInB+lf9AB/gPGUU9SV7a20+4QCQuc5yF5Qds+/wBKb4hsZTNZ3TXE M0TwqVijUmXBA27s9Mc/lTsae0glYhtoLQttklj8yFM4DAqc9qgu7aBElMSRS3EoC5ZA/lrnPB7f hTUW9i41qcSu+nXhSJ4C0rjBa0hkBZlOMFl9qsWRjkZxc26gAFUd8qwPHP8AOqVN7EOtT51J3sf/ 0fhe/SG3hktonT7vmPt4JzjjPt1596p2aG3aPzfmhVQ7vFg574Ff9BkYdWf4E+2gNe+kPKwh/MkJ VuQEXsMVVu1ZxFIhyd+2VTyV4+vtWlrGLqwRq2RSGFlfPOXUdwaywJDKZnCtEy5XafnU5IIIq+Rk e0i2h2YHkYw7WlVMEkfOPUfyq1G7LF8wHmsdqpnBI45/DNHs2E6kWtD/0vgSR5Av7hkjlJClyueB WqLm2isZLbbHcXThWaTDIqeoA6dutf8AQooNPU/5/OdFO0DRx3UZ2JcldyuRkBPQH3/pUogDWiOG zMr7JEVMZGPvfrTatK5MpXVildQbprVYpPK2KTcowyZ+ex7YFE5ggVGjLCRmA47fWsiC6tkkiied 44zt4cnkk9qovYusqozq7YyGXv8Ah+VXT3Dbc//T+F1iYRRuzbnjQKMDHTvTrawF5K8h1BrGVY2Z WKF1nY4wpwM8+tf9DB/z6OS1RQuGmtJUhuB5jh/LkdRjH+1S3Vo8it5Ko0bcs2774/8A1UBT2GT4 SCKNI5Elt4sLHI2FPcYH4Co44nfbI0XzlRlByR6inF8rLNKGSFBtwVI5PpxTLm9F1vKnhB1IxnHF OTTd0Zz6H//U+CVBiDtLyzgGLH8P+eamXbJZSr5KSO0ih9zBNwJ2k89cA5x7V/0NtK7Z/wA95Naw Ry/u9zIIwQzbCFGB2rOuLYsxaKZkX7rFejDNR5G90i5HdX1pieAxJ5ZUMZl3pIoxkY/DvxTr+4Gs XHnNBaWkflkG3tovKgkI74JPPbA4NBPOiC0gz8rNhAflHTFLdAxEqqGQHpjr6VrBt7hzo//V+AvL LwyK6uD7cEVDb20jzxSPLIqIhVYwflOe7Cv+iA/59lJPREt3G4wY2XcrfdI5b2qS2nkkEludrk/8 sgMutAyuqoznyhvEbbXVDyMdvwrbh00zRNcQjLbvKMf8QPrigCO6sorH5oXlmm8oCaOQDyg3c8c9 /wD61VhJEbcxTQRsk4zJs4KEdMfnQB//1vgyQWyIEY8AfL702DZGwIAIbtX/AEQH/Pu2luSzSLcu wjGZEOwjHt/9eoLdpg8sD/cPG1h6UE88RGUJzHng7So4H1pJxF5arhfMdxh34Ynngfz/AAoJc+ws L3drIYmbyY2+STdnoaoTWk0OpC7tpUlTyzEcZIORz1/w7UFKatqf/9f4JhsthBxhpY2kUKM4xnr6 dKYyXXkBJnaKOUZMQ69MA1/0Qp2dz/n1Uk3Yhs7FVii+0swOQsxQ8gDq2akn2KBsQ+XuwjEcnFIq 62L9rIDwvL7enX/PepHZZlIIjD5wCqgVcHqkBnSwTo+RymOvrRDfzwzJ5YieAKySh03Mp6Ajtxz+ VOUvsgf/0Pz+lZXYSAF0HzOIh8zD2qU3iSRARRtHA53RLKMyovYMQOtf9EB/z7gWT7mBj+9g1Gnk zzgoiyRwxFJGQYVSeMtj0JFbQd1qAG1RVCRIBj5VAHA+gpiCWEsuAdoO7jIA6f1qgLlhcNuDWph4 QqA0SyIQQQeCCKrzyIsiwyoWnd8J5a/L9a5zJyvoj//R+AYI45pXEk6YQD92Pvj/ADxVgQmOWN0j WSON9xLrkEjtj8K/6ID/AJ84y91kd+zJLEiQgLId8jH5Ag6jFOWQZzhVUdM8qTV09yLu9yK3gWeZ VlbYinGQcEg+3+NFzH5N20NuuIo1yWcYZjj0961Kg3cgWWZ0VnjEbMeYzyy/XFOlaNBjG4gcnrig 1P/S/P1XfyWnWGSRN3l/IOp9KsW6+erKkCvIw2DbgOD7mv8AooP+fczJY7u3kCSICq5DnPzZz2/W rrxK1uyOVDA5CsuSCOn5UALa28kh8vzRsALnsCADkfpWbNHIJWRVPL/ux2x2oE2kaMMQkiZDEWnU 9SeFAznj/PSmRKc4lKgZ49D7ZoMD/9P4CKrI6jAwD6cCrs0GE/duOB29a/6KD/nvM+KKZFK3DlgW J3Y24GeKVRa2lxIbeLZHNKXxkvsz3/Si3QCZ3iMiSpLHMrA8IcjjipTJJKWKBYlJ6Adee351E17v oA77N5QDTEsCd20fKajuJo7lSUi8oR8bU5zisiXJJ2Z//9T8+yCw48yI4+UgfNj8q0YW81Npy6r3 PVa/6ID/AJ6ud9CyECD92wGByOmKjEsMkbNEBIyna5U8gigvnRX8puDkLzlieSR6VG8aq/mRjKEZ 4rSn1J5/IEVJCRvG7rtqeGVYptjDp1I9K0LTurn/1fgy9+zu6vFkFOATwTnr/KoWnnZDGsK7Uj4c cbic9f0596/6KD/nvEls7dkieQyecvzBSNqD9ee1KHdFYEMEbAwvQkZGayvaTbArSWn7oNh4stlX HGcHn/CkUSRHhvMXtjkVfNECVS0rHcCFHVuw9qm3RKjIQyy5AVgRsI9xUzA//9b8/wCS2M64O7A6 5PX6U5DGF2McJ90mv+iFvRI/58VJrQbJpww1xa3ACs4jKNkSY5OR2/X8KmfMUgEqjyooMMx4Oc// AF6baasaRlfQq2l0q3sk62oKQYQeYcrOCMnj0/wq1fagbuWOWW2gt41jx+5XywSOgI/rUlGpoViu tSfYozGk7j/Rt5ASVs8Lk8DNTa5ot/4ev3s7tEjlEaEKDuVwyg5B79SOO4NK6T5eoH//1/gKPe6y ZOCDwxFTRFISryRecwI4BwOvJ/nX/RAf8+5ch1OysZZd8I2OcJ5g3MCTxj+VJf8A9nTMswhmhYDl 3YFSx64oJ543sRR6dai3e780CaL+Fn+aRTjAVfbnNQ7onKvtI443jBFBPOPnGYmEec44IqptknEa TbWXptVRziglykz/0PhJGjwIgoUfdz3qG4HkFliLb1GSSPlP0Nf9DLbb1P8Anwbb3I4LrdFvaBmy DlhwF9zVXzIpDuFvskRigfH7yQE9z6f4UilNrcsJGVG1mCpnJDDOanmdRENuGXO3iguMk9ClLG6K r52FTuOemO/6VfBL28VwhASUfuwh4I9aCj//0fgKK3kWbyuVklLOgkPJ6k4zSvb3ouBHLd+TAOWX ytzcZ469/wCtf9CUlZn/AD7kBi33SbAeuyR88Dvn37VsI/2RwCpYDoCcVJrGfRjbvzpofMmIAP3A DkLg5FJZw3lvaw35nt5IzOYgjSg3C8ddnbrQUnfYo3aM0onihJjLYkkzhFODj8aZs3P5rJhlG3cB g4rFqSHdH//S+FLIQL89xtki3Z8o9WxVQs11M82x1EblVV8jGDxX/QR5H/P9fWwTSTH/AF2VVW/d oOAR7/rTYYSW/wBWDHtwijgKaBkjptxE3y7+OnIFXrC1EEE0LurKtw06SFQJGzjHPpx0zxmgDNlt hKzlXyzNjKnBqzYBEke0nnWJoFAdpyVVvTn1oA//0/gqV187AkDRBsAjuKmeGGJFEWFjHzDaMDmv +gg/5/8AYhtr6O3kmIEbMikRtIuQD0z6UC4ZtjSHfI5/gXhvwoM1PXyJZ4o8AJlmHJKjIFO/s+GS ykIvttzID/o4OC4/PI7/AJ0Gg2xP7sxypJFKi/clTA9OtX7W5jQtH+7W6+9HKAC5HGQaTkluB//U +G5IxGk5mjIEgH7xl5z1wD70yxKIwKqR3WNhlSc8Ej/Pav8AoHUk9Ef4B0+pXkMzXpWTeZFhZojH whJ6Z+n+NWrCd5ZY47oxRiE7jJnAfjv+VLmSdmKb6Gm7G6t5ZlXZFG3yKSD04z+Nc3cRySzZXDDH zrjAXHHSqjUSjbqXOtTmrRH2oCllJCkjgAcVZuFcwCCOQPukEkiEZBx938Rk0N9WYuUdz//V+Gpj JeK7yYN+yqiyOB5cYUAZwO4AH5U+5iGzPmGR1AUt03HFf9A3PE/5+3N9DPbzEhLLlwDjC9RVpIZE tkkQMW+9KU+ZIs9B/n1rJuLegRk+pXWWSJyRGZN7BGBXdgMcE49gc/hQbaGOQ5GwH7q9x707roh8 6sW/MCgQuWKEbVaq73H2eQx5Z0I2k47elUqiKVa25//W+GIry0VfIMbrH1DIcEfhUMlq000oheN7 QMGjPSZfZj/QV/0Ctwe5/gB7ddhzRosLpLIkYhBYNggH1FVoIYo4zsBKSncDjO7JqXyWsjRVE0Wv OMLLiNGULj128/pVNbhZTc/fLk7N33VX14xyOagq/kT23ltPDBdALEVwkpJyhPHT071PNM0TtZ+Z 5kcUhMDgYB9xnkA9cGofKkQ59Ef/1/iY7Hi2ySxK7IA0cESoBjvwBk+9NutSvGS2gjOIEQxOD0cd tw71/v1Jxex/gFGTS12KkamOVVbaqBTksPvE9MVY3SR+bkKv90eoPSs3FM0VXlKN95EX2Xy4JzIV DO24EOT6D/PatZtVJtH+Qxqn7uONvlIbuT6//qpciG666IfZ3umNouqLdWk0mpO4FtJDgBV+XkjB PXPT36dap2yJJEcPHEY1wVclWY+1Q42HGtrZn//Q+H33oCludwA3MAOp9BTN8rw+Ww8tlJZCy4ZG x19a/wB7uSJ/gYsQ3sJZzXNpERLD5y3CGNppVLqW/iKnPXkH8RVu1uPsxSSONITGflkZc/jip5Et 2HtXfQzUa3RLox586eZpNxOQWPU/pT7AXdtvuHu45EGUayaI73J/jB7Y56n8KTjFLcPayZcEk8jb 8Pym4hMlB2Iz+NbMkQvbC3MafNDPueKQdSOOD+VZckTWM31P/9H4jurd47ho1lMNw3AZcZiJHark ke/NoLszPbIqTmZdsm/apOD3GGB/Gv8Aebkif4LJt7mhDaXEGlPbQpasib7tFZtkuQAWxnjoM4Hq abJp+2zHyBppgsv2hGO5EK/Mu3pn39qXIgTT2MV5og+IFmEEWElnI3bTzzVWIXP+rspzIruVCud0 smT25JFJwtsXB8u5qRWzwS7XQCURmWMycbsAnp74rQ8L6W2om7ktoRHKkrtcRuuxgcAsxB7EEHPv UW0uNtOWh//S+LNr3c0ab2Ihm2xbWZDGuecH8T1rbvLrTrmWO3jhmidW8uWRjvRT/PFf7v26H+D3 MkrnNXelztfbLaZdh5CL8oHrmt1g72/2Ga7ttOlgtfJhkDMxvHJ+WJAM8nJ9BWbg9WHN+A+1tr2y syTCqxylmSVk3Dcp2nI+uKx3v57GfLPbTSyHcQYVbAz6dvwrKUHNcqOmM3D3mbNtrEsMVw8VvHcX E1s9tboFCx25kGxnA6cKW/PvXNWNvLp8ckpLTm3OwvId6nrxkdvp6VnOi9mdFOsraf1Y/9P5Fv5o nFhqMcU0cMEKORC7K0Ui87xjkYPT6VduvEms+JLi3uNS1q+vNPtLI2yW965uZ1IOVO5skDrwDjmv 9ypUmnzdj/DuNaMrQfqZOnXbRystxHkRjeD/AHuelfYf7HV7b6h8bvB2hwWkkiy37386qGuGU/Ks GB7SEE9sCvjuOKcocK493/5dSf3LX8j9G8McRBcbZa5L/l9FfO9l+LP7jPh9FdWvgjRRcyg3P9lR iZscthMgH3wQtfzIf8Ff7+xufFNijMv9o/2pDcRRmPKrDDHOZduehw61/nF4D0amI8UYTjtGUr/e f6MfSAr0qPhzVp1N3FW9Uvz7fifgz4xvBa+FrgTypE11exLCWztKjc284yepUdPy61+KfjeZtV1r XZNQhfyl1OSOKOZfvKoXYR2x3r+q/pNVFS4BlG+8l+aP5m+jE1U4iqwX2bv7z//U/k1mmliMsI2k FsAY6AVHNdHYqDhsYLAdOlcVWLldmbnFrlJYnicKs7EDoXUVceC0jt4pYY49sjlPtGfmkZcdfpxW K+FlpWVjnNQkEmEKAbOfMU4YY/pVSEhnaXy2YkbWbHy4H/66xclHc0UGyWa0W6mtPLlaKFWPmAjl uOAD9a0mDQTJCowwXPzDhhUuS5SWrOx//9X+Re/Mu3aQAiHkY5PtVW3nC7QSo38FDyDj1r580VO6 0YtxcPLcRxqRHjjao4YdqsR7o2WNzuxyCeorKTezNI0ra3J2gRXR4VYO7FnyPlb1FZpLzS3CB0Iz 8iL1XHUGsZRk2WodLli3toX8syyFQvPk9DmqV3Kn2orCVUr/AAgYA4qle2ppGkn1P//W/kKtlVzu XIKn+Hg59qtec5fyYWZLiYFVfuoGM/zr5Jwdz1Iws9S3BaSRxSJNMZnnl3yTNjfFtAAUY7d/qalS 9eKVwrFkiXYGcYAAqlSqdBT3JIr03BlQENEi+a4HDNg9AO9Qv9p1G5klMax2sUKG3kI2vMedwYds cVahU8gT5XqQzalfWLSm0j+bZ+7mJw6N7Y9K1X8V6jfaMmkajP5ttBcLO0cijHmEYBzjJ60KFTyN bp6n/9f+R0lVd40ADlsuoHAptvNJO0sapnb8oJXHIr5lQl1PWcU9zOvbeYXMD/N5idEbkDHIwO1a F5dfJHCixrclAJCinJPpmj2Xc0jG4QQymALNBCNp5YDLt7//AFq0ItPs7iFN8yo+4/uy3zHH1rOV JrYfJf4WctqltcQ3DSITLb8bXxuhJ9P0/Wrsc6NA8Uin95FgbRgKfao5GCpI/9D+Pw+Ys1v5UbSr I2xgoymPc9q1vKJuAJYlWNUOQDtYEY4x+dfJcjPZdCK6mjBbqAGIKxOSsbHocdR/n1qLUbXTpLKY 3FtDeXMMRWGM8yEnpinyMpRj0ZmQWq2qLbtDDZKsPmZ8wRg56rj/AD1rXs9VmaGSzt9MsmltnLm6 NwyyTrjoew56AClyMpQSYlrFLJLJNPhH4+UHf9eammmdt6hQsX3Vz1PrmmoPqNyS0P/R/khZnu3g t4yI0HDyAfKv4VDBFAyyAiRmZtqFxjocHINfLqj1PoPbK1kWLhoonVSFLsQApNRXBlt4g5hCgtsX 69etZum07GbqxiXNNRZtzmEOzqUCsu5DwQahuVltY0MEIkbfsbHGwf4U/q7ktSPbrqjIk1GWxu4k SMwmRW894htL5PQ+p6/pWsxtJcz7TLOy7WBGUOPu/wAzTVBxVi/aJrQ//9L+RVbVnnjDfumByp25 x7Yrobd7u0UfaUCK4PluRgYHFfMKievNvdD5JDuLKoJI4bPJ4qK4ilvtPWyZ0FvFdLdSptAnLDoA 3XAx+prWEEmkEIy5bjnjtXiWJ1Kyb9zOvJYcYGP89a92+ANlqMuvTTaTB5ciytHcyRt++eNVXeWx /sMe9fZcH4b63xBhMLD4pTjv6nyXGc4UckrVZ7KLP1c+E1tqeofEPwZqGpak01rY63ZLcQzSHy2j EyBAy+xHHuBX9zX7GttZWnwr0m2W3nt5Lm0RtmwxLCpjRj5Z/uneBz3Ff0D9IfCPB4LK6UmmkrfP Q+X8Em8VQxdWnpZ9fuP/0/0f/wCCymrQw6Xb6Rp7w/bpr97a0e5ZpFlUsC+3tnGVz2wK/lD8b6/f xaZe2zrm4jsPsjxwwhlIZcfNnn+LOexxX92eC2AlHgSE+13+p/L3irmdOhxdKi09ZJfkj8aPiLqM aeN9ZhltopbeGOMF5CZJHcqS23+7ycke9eMXdwk85eNMMh27SMbOfSv5G42rwq8T42ov+fs//Smf 0pkMlHJcNFfyR/JGlaWUnlG4klKwr1xyzt2Arq7C8eW3i80tLJbHbGH+ZUBPGB296+OrVVLRHfHm 3RsxtDcSOoKtJCAzAnkZ6f59q07s+TBGIhluCUI4avGxFTXYpSkf/9T+OjwVLctqDXsUVn9pum+y yRXKhY3ReAQDxkdvpXvOlLeabbmS/gzC78TFAqupPPA9q+OxNXllys3jN9CqNaudT1C4uptPs7ax s2FtZxwBYZ7lVyNxX1Pqc/yrpotSlRiTbxrbxqphl2gMCeob1xx+debUm3obRldak8viO01qB7a+ soLq3icmNpIcW5IwBtI9D/KrlmghjWC5MKgo88czvs2ooJVMdOnH5Vg3Jp6G0XFGF/bFqkpuobeO KaEkRJJhvtTAnovI5B79hXR+HLiK7sHlvtHtrUy741eIbnjYtw/HTPX86mkpJXNuWEmon//V/jcu 1aN/MiYzxSE7HPDr7GpbG8snWZGivPt8sJS0gEZWIPwMs/OPp9K8C14tHGl71/Mzb7R7XTYItVaK 1e/u2a3kuEcNPEUxuGOo6gc1YtCn2COSzlMzTDLl4yhRskFPwx+tI1Su7In02107U4tWs9XVr+OC NA+nTwB7JwxySWyDkHHA447Y51LyTS538u109LK1SKOBLG3jJjhEaqoKDrztzStrc2Ssjv8ATPKh tjdHUYnSe3INm8cnmLsGEGcDB9OtYFjcWsZlCQxtJPIZY5JDtfv8oPp/hWlPc0p72P/W/kBZYEVf 7NtxIlwXhunmjKNZ8kkRDockDk9jxUauumS23n5EE84jmdV3Pj0/H9M15lPQ3vYxNVnty9wloYbS wWX9yn3I4snofbJNeQeL7GG31BbZBbSv5YuGaImRcsMjB6Y57V6FAmo9LHReA5dBfUba01V/suoN dxPp8yD52ZWxtRv4TnBz7Gv2L+Ek1vY6FYXV8r3CtELaCWZSZ1Mfy7sDqCPyGK/qj6OVZrNK9LpZ H8/eN8E8tpT6pn9Jv/BE7WGn+IeqPOoa2fUo9JWOZBKlsqxu8bf7PMa8+9f1kfEe2tn8Ca3YyJA8 smlSW8ZdN8Lboyq59eSMCvz7x3j7Pj5td0fs/hsubwxw7/uyP//X+fP26tOl0b9oPX7CGeZ7vWYQ VQ2+61MNvcMzIi56kFVx26+1fB95LcPqZmlZo7eebyY4yAkcTLwwUD6Gv9TvDaq6/BeBqvrD9Wf5 8cZ0lT4gxdKOymxLiWCwktXtCzTWjmVsASGXvznsMdKyNU1repW4tAZHYS+bGOVA4AwOnvX3Vuh8 pyJF+yu7aW7luIFj8m4s1tHjdcMrDaQwbrnIP/fVYIAstUvNXJa5kx5NrDLL+4twOM47+v41ulZW IcHfQW91e4nskhjjMl6koVf3Z+zxb8fM49MYzj0rfsJdWaVJNVe2FoIVERsrfyzgfeO1eOfzq4JN 6ilHlP/Q/IS/j00A3FkWaS1nWS1jnAddm75ldT1yP5d6g023ims72C2gRp7i/wDtDSSSkc7QNir0 Hb9K/wBkWrOx/mFKNmS3k00UsVrM06fZf3L2ufkhwedo7HrVvT9a07T3hiMMl9OHffLdhSI1OSp2 gAew+lVBpbijG44TjVb9pZpokV3yAIvKVMAYzj6VZu7rSrhBaackh1Bo/Jlnlb90jKSMoOMg9Tnp Sk7s2MmKJzImn39vFNf2+5Y5kjDMq/x7f0ORUe6fTjvsJpNrnByuR+RqRcqtY//R/JK81BJjFbXV 6sV/BZoIlDhy6nkk++SfpWa11cwLcxwANJcIqZkUFjggnBPTPPSv9kD/ADHtbQSGS7MMsTs6pMuw hTgg+ua1rHTZZ0li/tCC2lji3IlwSTKRjO3HGevBPeixlJRWwaimnWzJEMXU00IJuXVojC3GVAzz Vy0LW9vFLDLEyzME2h8znBwSO4x71c1YgW++zTzrYhcGBPOUtyST7fhn8KIbezEfMgeWRvmcofMh A4wp6elRsB//0vywSzk+zOFiM4nlCl3OTGoBzke/FTJLLbatYWt1DbJDHB59qPvRlUIwrfXnAPpX +y6d1dH+XU1Zkes2lgLoyFFEN0NxiVjwe4B64/xq7b6l9hSFrqKC5tNoW3toiTKAOMMM/lTKg1aw l/afaTBqULTWDxt5kKJhHjYdiOvGRxmufcahLaFZiJrWS4IlgbqGA4O31OTzQc81dXJ5dZtrKYRZ uoLGOFDEZbQqrkqBs4zgjmtWxubi4WCSySE/vjvjnX9yoPfngdjzQY2V7n//0/yptLBPtFxcmQyO XJIQnJI64A+ladusM2n3Oo29zBdTL+5WBHInsmDAbpUI6HkYHr+Ff7MH+V9k9ylePYvLbxXNreM0 ibrmaJ1RVx0YAg/lVGxktYnuPKFzdr5mI02+V5Y6DOM5JxTWjM3Dsdfp8zS3Uk0wib7NGu6K4GBk 4KqAevviq9g89udUMMscFve3GZBb/LBOQcqdvtzg1smnsQ1bQz9UYQwsy3LLNIu1J0GXY+n0FRnx Bf3Vhp9peGEPaxfZzcrF5XmAE8kDvg9aYNJbH//U/Li9adWtJI7wtGro5mjy+VBGSo65x+PFXbrU VWeSSxa+u4oTlZJYdt0qg/f25PP1r/aA/wApyKe/uGubDTNODTX9+4lggVQbm59Rt6nPp71PDLKL wWWp200EiSlo3mT95B13Ajjvn8qDGSs7FLVzc24jjikNxDPIcqCqzFc4yQOwqaze00uSRj5Mcd0u SrgvJJgfdAx1qo6Mkm09t2lT32nRoFS/MJtPvTBSTklfT/GsiK6spIr+9kjaeSCQxRWSN5K+YMEF uOlOMuXQrmaVj//V/K+w1W5vrzN2qWQMQSO2gUyISMDr6nkk+1Nvv9Ou/IuUmS/huQsIkYGKdCvD jHQ9eOf0r/aaLuj/ACfN6O30sWx07VLeWS3kiMfmW74kt2A+V/oCOgqnYWtxaWNyLHU3IMq7YXfz vNCn7rDsMD9aolST0Reunj8z7TcSySM4DCMt5io3A4Haq0l1MYyJIHd4CqwrjDKpbd0/4Fn8auLt Fjbsrim/a8jleWNS6HhBgE9Bhff/AAqtbQai8kgMs1rCp4QKFlj69zzzWi2OSo/fuj//1vzen1Vr OG3S1luVaYYmllKsp2nqD+Hp1rGkvY7u/kuniuZnWIbpVXdGW6E4/Ov9r4rlVj/JNzXQ1FlMcME3 mxETs0ZiWQGZNuOSvUdRSwNb3ST2klsGJJEF08P7zzByMNxx0zinYJSTVkdp4HU2xVp1Q3RYp8z7 YwFLYIyep617JpLMLuwkAG+21OC8Vw4haFUkRnO702g8VvFfupHG7fXIJd0f2Of8EyNRtrr4Saa0 FyssN0GvYNygl1kUBXB99o5r3T9u2Bn+DHiAJF5xe1DygfNKi7mRio7n5hX+VvFV4eLcv+v0fzP9 O855X4Wc3/Th/kf/1/knxNPcHxZ4nnf7Tuj1+9hhgmx5iRpcSLGoXoBtC9KexWTTg8/zMzZaLA2A Z4yK/wBxMsd8DQb/AJY/kf4m46X+0VEu7/Mz3jjM1rJaslp5QGyK3URrJtGOR+PNVRqdxcXk1uFC pGqgNtK/Md2eemPu/nXrKTjseHJ3djS1AWlnpLeZcE3jtvHl/MxB/hNY+mSpawtqO6Np0OIoH5yc gbivfHX8K2jokyHsyae4BUtMo+1t8yMMMm0jkH35rDWGaWVvl2k8hgOK0V207GLd9D//0Pi+K5kj j8mRFhCDAJXmU+v/AOqm3TGa3SYyrIYY9yiP94Nufav96D/Ca8m9ditp4u3bzLefbPvD4mXK7OMq B9AfzqtDCZp2EeXZN0rA85A5NabLQzSbZowXknlsFg2rGfn2LjPb5vyqtLdtI+4LtWMEFnXcq54P FaLbUmV3oXFB/slbi1uZI9RubloGhVSWNvgZcHtzu47j6VJJbMIAslwHDoMsww/HJOKDGe5//9H4 ZnnlVWWJm3Hhi3UgH+v9asvfu2mNaRv5SuUfayBgShyAB2r/AHxTsf4Kz+EjtDdX0H2i5Aik3kLA pyAPUdvSrMkCQvbrLKfMuDiMMdq84xx61UU27mL2sbljZzW8VwzSeRKoIWWNtkmD2z1xxWA1hctH NLaRPcm2PmTEktIQTzj39q1Mnta42OW0vYkikbyHDeW8kp2omeAfwqxBpF/a2HmyqJ9r7ftMZDRP yRhfpxzQYyj1R//S+MI1uLqBluQv+jqfJGApbPbNZKrJCdpDxyzjDJHlvzI/zxX+/cG72P8AAFq1 tSxGIroXFtPbuIoEAe4cldzkZCgfnzmopYIfs6pHIYlt+kb5YOOnB9a0d+gktDPScxvlF254xjk1 aWylu5FaSJFjbhJOAR+PWmvMQ+GRrK6aOZgIJFMMrR8hh7fiBVh5XiG1JC8EX+rLjIUdcDNAbH// 0/gmS9nl1Azy4aExqsZjj2DIHOffpVwToha4VWjSSQ5VRhc+wr/oBsz/AJ/3ezFuZG/dSK3mnAyc 8gUplllXy/L2kHdyc9eOfTpVKDe5nLmSH2dtDJcLDPIkG9vnkPOPYep7VXuWS3lliw8f7wpCz4Bm x0I5Na2tsTd2vcbDGEkM5LSTnC7icBQPard7IsNzb2cs1u8c6F4DGo8xj/EGI59OD2x607N7Am+5 /9T4IuIkgnmgnEglUgHeuFII4oU4XYnTG0D+Ee1f9CCVlY/5+eaWw6Nf3YXI4PKnjFPjEELsMtJl cHeA3Pr04NBEnZaFdLsxG6ie2MskhDWU4ciOEKRu3LjnP14qVPttzIpS08uFuZZFARCygcDjH5et VzSGtbXJriKO3CXNvbeWjKFu/l3OshIC4xnggH6fSmlicFkIwvpim5S2NLQsf//V+FYLL7S/lqVT I3cnGfpTr2xjtV8uRyJXGPk7D1zX/QlzSR/z7ks8n2jTmtDCkZHliO6QbZ8IMcsPUdqhtLpYh5Sr u2jG7vSbb3G2VLqaKKT7bnHl/KzfwgHgim5gnRmVWEgO5cjg+1ImWkWTl2a2D+U6hMht3KuR6fpx UdhcpNGZAHZt5TDIRt7d61grIxu9j//W+GTcMqsi7MbgXLH51wegHvT7dmmlDKm0L1A9q/6GD/nv JLh4WeVtqySxkcTDG7169f61jxvLbCQDcInYsqt1oKi+VksUyyJmZSzjjnqoq0skbbPKypHy5Pc0 GrkkI6wh9jK3mL94AdfbFVFaOAOohfdIxb5uQO39P50GUnd6H//X+DogJlPOzacEEdKrmVZHMQGN h2nHGfev+hlts/57y6l0YVeLy3C/dVtuSamgWNFj3xl4TGVbBwen068ikBVtbsyvLAYCkUYwrOwb f/Xjiq1yj3DCONjH5Tb9yrye3P5fhR5AW5HMA2wFWLIPvDdtJ602yuBHM/n+XMGixg8GM5Byv5H8 6uDs7Af/0Phu6ngDsLZCUkX5Cw+YZHIP6/lWTbNKMO6gMeGQNuCfQ1/0QH/PgnZ3Q5lDyLIAVlUk A54/KpU+Vm8slZiCC68Eg5BoKc2wVI4lyvEmeMDFadpdXFhi6gfe4O5wVyFx0yKAjJ31Ib67lvZJ LpkVZpBuZUTy0PvjtWOVZVLHLE8f7K0GnMj/0fgex3+QTcFHlBIRNuO9EkMnDtwwOOOwr/ogP+fK UrrQcCI9397HUcZpsMivc75FZVC4xu5Y9/aggtRhJLkr/q0J4zzin3cQRv3kYxH90kcZx1oAqySI 0fPDBemM4p1nHN5fmiI+UW2b/wCGgD//0vgid5I5GCkqR8wIpWuZJFDn52HHzDn0r/ogP+e8aZUj TZL8jPy7Z+WnT2UxtFng8yRBMBJtUFFHufzoDYcbOSOJLgSGMsCgAbHYZBFSRwzW7QvKF2yjcnOc 89acXZ3HzPuVll85pNzHzFzhf4QKfAYljkV1BLng9Mf5/rQ3d3Dmfc//0/gxfJtomkCZVB8wUZIA 9qR0hbYYGRzIAVU/KBn3r/ogP+fHndrEEtsYXkHmrMvqvCj1FRwIULRpEAj5dnGBk8da0p9gUmix bbzfWtsYHe3lJ8+4WRVEIHbn1pZ0RJrgQO7K7bVVzngdOK0FdkFlE8MjEARhRtAI+XFFwPNmWWRi NnyqV4xSsuwj/9T4LT+zhIxjVzJ5QBkIA5/wGDUwQLFIySZ4ztzz+Ff9Ebg76H/PjFX0MaNJZNsT SMVUkP5nzM+c96tRxhphEjB2Hy7AcYq4RstSbW0LEsLW5IU5lTn0Kmo5JLmYiV8Fwu0kjBwOlUOO jRW+85zneo+Y4wKTymYOquUD9WHLCg3P/9X8+4ljtAyJuLs3c9RWhbbLXmHEbO2fcsT1/M1/0UH/ AD6ydloSXECPtjaXMuCzFjhwayVsTAxWO4kmX7zGY5fJPI+npQS59ieNWhDMrHcD09aVyZVBUAE9 fUUEN3dxbcCIyRLnc52uceuKlvbQ+TAGkzGhy5VdrDnPX8KBPRXP/9b4IZ4M4QFTtwAeTVVkmXIV tu5gTkZr/ooP+etz7F2Ri4RJWxxgkDmmi1VAkkoIVmxCSPvCgnmkOubWGFVjijEboMkY25zzk/XN WowxtyUdFcDG5hnb7gVElJoFNpWK83myANuJCjFQ+QQpIbnGW44rIk//1/gKKWeWZI/l2JkAkfNU hDQ3DbCSHHzL0Ar/AKID/nnLxXAAyMngkdaSKAKXA4A5PYGmk3ogIBCXZyrE7T07HFNFx5LFcKT9 0oVDY/A00m9gIxDbBllVNh/jI/iJJNTmKFWEmd24YBByRW3qNNrRH//Q+BCC8mQDsxgYHU1ehtp2 gmaOMbIWDOxcbwDkcDPNf9Ekm0f89Sm1uQHdJgsSwUgBAeasIfMjZFABTtwTWYc7GvaN5GZmAEgw Pm6dulQwW4gjVB+8x/EeaA52DgxF2wBuBG0jj64rNzJJkMhZVbJ9B/nFNu+44z194//R+B3uPNYe SUzGmxkXgDjHNBgieEqiqjsSW4GM96/6ID/nvJPL2Irq/MY4jAyrHjk/TH61XmMl2jGfLB12MOhY dO1A07O5Wih8rBzgLxtJyTTpHjlwrJyT86k5Vh0oK55FtgtuqPA725RlaIxtgpg8D9KuXt1NrbR3 V9dXFzdWyeUryzNI+0dBknkUW6i5mf/S+BmZRGp5A74GKhty8N6vnO0ltNA3lxqoBjf+Ek+ntX/R Af8APg5N6MfdSw291bK4xK5LxhkJUgY56YqeW48wYYZAbOAOtAhPPBDBE++oUZHK85/pTJkcLvP8 qNgIBcy/cVG24O9uwApAzRp8oO3qD1qHNW0A/9P4Mt3OA5UMf4s1N9pRtytHtZThc85HtX/Qzdn/ AD3iRTMlu42BY5Tlh0zjp/n3qKIx5+UAY60gIpp08zy2B64BxUy2ghLrbFpRIN7CTnB4zjk46dqA 2JGYNGF25wMF+y+1QkiNB833fuDoB9KTaW5spJn/1PhEW8dw1vKU3TRZ8txztz1/pUd7OwmjMh3t vxIXGWk47/lX/QjJ3Z/z68yvYiiH7wyRjhu3pV2ZUdVOHQqAW387vWkUNu5PtFj9hQ4UnduUASA9 Dhuv4e1Y0toqBI2kYocAbHIK/wBaNtxptbF6RGNv5bbigOcjgUbjwpTah4G7qRWF9wu0f//V+FGg geNEm+QBgQwzlPerl81rb7Y4WacMm4OARu4HU+tf9BB/z8XaMyNHERnlU+UH2jPUmtV5bRrdltYG hd1BUvJ5m0jqf/rUFqfRmTNEs0gbzSZYl27Qfp2/Cmu90EeBopreVHC5deo4JOPcetBUnyol+xXF pHFNFFJJG7Y8xvm+pJqCYqSJZV3MW3EN0z60GV2f/9b4C+zxFH2cNIck9hxj+lToWCNDLkFFzyDz 9P51/wBBB/z8XaVizbLbqmPKDbzgFlz14q2YjaSwsiL5iYO0pxj2FAikzpHJtUSLIxLF+qfQU8Ro LiEyKqEkbucMVzz9KC4ytoxLpA1xJLFM8iMNgR23Yxkcf57VWghVLiO4fzNsaFGwc7gcHv34FZT3 NOZbH//X+LzLa6kCmyR2RNztM2CAoz+PFZckq+e/lIVROMkY3Yr/AKA4K5/gAm4kDOpmE0qPLCGC MEYI/PXBIP8AkU77JCVbG7Z94EnJ/E0pKzsDd3ckhVXQph3WLlivQemahng5UpuRWOCSKTOZCMXt X3CxnnthiJrhcBS56A859/wp8aBg+z5WY8Z5Cmqk9EgP/9D4VcY+0rLeRSzW+FzBGVjfAAAGevpm rVrKht/LZdzMdzO3b0r/AKAD/n49SkI2gZoVLyxuSf3h3Edzj2q/abY4XT7qEbVU+1KyvcqKV9GV nt72JxclWEcZ++o+Rv8A69RXMqSeS6wEktiSQseceg/z1osk7hMklWN/LbcYol4CE7uKhaKNnxGz AOSUEjbjGB6nAoSS0RNr6I//0fgg221tufmJ6HjNSOxt49yMRltpGOK/6AD/AJ+mlFa7hHK8iqDy XP51oQ2VxKwiRsAru+7yv0FBotixZyRaU1x5kTyyMRuMqYOOOgPToKWaKKWJLzITzsuI2UJjnnHb 8qycHaxqp6amVMkckiu4BMZzH2rTE0MiESW2WEeI3QfNu7ZqClK9z//S+IvKVf3io3mKmShGOg5q iHknmQRRM6qdzEHAQj1r/fVxfRn+AcpK1i7EhupmSZduw53EfliiSGK2DCTzCJ2G5lYuEA9B2/Sp aknYlNJalB7hYJYmdlkAkHlpJ0f0GKmt0EzTeeGxI2YVQdOnFS01qyTX0e2jt7yWSVpoRDESSq/e B4xn3qG/+zOfOD+WZH2CNhtJx3z/AEqXe2hpTfQ//9P4jjnFthVAJ/hZh0qs7XUpkabD56MBtxjt X+9b57WP8CY6uzOn09c2MSzQxSIcuNyBienT8hVK4u7Zp0Btkto1G0BxgMRx908CodzS0W7GLd6V JDdRuGLiT5owpzE2acY5PtZt0jZpyu5k24XA4Pt36VDcr7FWVzoEW+s0aF7RNmwGQfdcA4P+eKsx XVy1uHkj2xFhBCwG0MegAP5U02tJFPl6H//U+KIrWWzu1gllN1O0nmNKfmLZwRntwMD8KbfQR2eo SfaI/N+0SrMkiSkbMIq7WGf9kevav94uaS0P8FIPT0Ng6nZ3OnXNvJB5F5Y4McmdrOrkdB3x3/Cq TTXAtomWcSooCPGGG9Rg4JHUijmkVFBDciKzdYkRvOdixI3L0xjH4Vm29osFxFcSs8ZJLwv91Ael K7vcZrWcW2cNMJpy8nMhbcqccDP+FasEUsVxdNM3lpeJ5LGPCOyrggfoKLsuMbSt2P/V+NIzBHd3 EqysqKNsSY3bzkDP8zTpxPbvBcRRJOkcolePbnzOQSGI+lf7v33sf4ONe6xFebz3upsQNIrMiomE UnJAx9cCmSyQ3NpCtzHH9pgcypdogjcN26VnzsEnbU29KZLaCQzGUwXCbZBId4k5zuAPTkD8qwdS sEiuNkgIilfekqkF9hORg/SkpWd0aL4LM1Y7cWlmVhUMJQVLMf3pB9P/AK1ZCyXixOIUY+U/zRle OepP4VnOSbtI6VdJKJ//1vi86xd21yYo8SacyIjDbtZ5MfMo9gSK0tPtTaRLOEZ/MkLlW54PQfhX +583aNkf4Y0pOUk30L94LC02Tzfa5prkFRbIywJFtGd27aeuensea+1f+Cd2kXGp/HNLsBFuI44P sMIGJbjbOu7YT6AkkV8J4hVnh+DMxqf9O5L71Zn6l4T0frXiFleH6e1T+7Vfij+3PQbSdPC1hDjd KLCNpChDNlVBI/DpX8l3/BXPWvtXxhtLGWZ5Lg3DwW9lDGFIjDRCR2PYICMg9d3vX+ff0b0qviTK TX839fI/0A+k03T4D5Y+R+LnxMiuYvBeoXEcG9rCeBIZvKM0aGR+EYe+z9DX4vfEPVxcavdJafvp pbkrIWiMcedigkD2A6DjrX9HfSkqqPAkafea/NH89/Rcp/8AGQ4mpb7P+Z//1/5KBcyxyOtzGSwc lWMfyNjp+FMkvI70Koj8uTdlgBwlc0vhZ53M1MsyJtCwRyB2xkY7cetcxdHUrLyYmuJJLRbh5ZUI zkH+EenauW6s2dfNLuXYVa4jUwDbHJwQ5O4evX6VbgMlkjoyEqT5YP8ACuc5zWE0ramy1IrhVZI4 95Tym3AoeXPXmljluZJFnljAiT5IpGOWcjqT+fSskurKlHlP/9D+Ry4ieWNp4pPMbHMLcAn2rnA8 jOVeIJ6nrt+lfPm0Ni/sjmKSxKY5rZcBt3Eg4z/KrskRjjWctukIAKdc/SlJXRRanubdbRIbdpDL s3TO42hCey1z8SNExbcQGGd4HU1MI21Y0ruxsiKOa2SSRtsyKVUqMfn+VYsloZNpx5hRsHs5FVot Toim7I//0f5F9LgFtcRmVisW4DBGTj0q/dJCpkmRA5E33VA3ID36184pRvsewZ5Lyo0YYqpOSfUU ycSQR/L84PyqCMlu1WJxTepatooYphcNbutysfkuRwFB56flUsl0yJIdpWIPt3AcK3oapSaVg5UZ xaW4+ZnOUOdoH3h71CElnmmV8JCSNy8DKjGCD+XNSTKyWx//0v5CJLaCxuZBb3Mm2TDGSU8njp/S rsdw0SFy/bPy8E18+ekptFf+0GnkSSZFQQKQpByz9+ahvs3XlTWsnlMuC7Dlic0GyNSC5j3hSWUB QB5hGXPQ1Bc28s8sckTGNIpN2YzhmyCCPpRbuNNrYuxPbQw/YpISY0LTbycAknJ46dax1n80bolM YZyiq64wAcf0NJJLRGsHdan/0/5F4iixtHCwEsY3njg1WRrONjcSZaYtlxJJxn0Wvn7J7nuzeli6 +omCNImjClvngUndGuQM8/56VFCY7dY7lpkWd5tyNKC5RuvPt7e1RJK2xlsZOtRXGui+j1BGnaWA SGcx7UTkBeB06AVDcBLZbcW25GESR3Ai3bWI4GefSsjaN7am9PP5FvGUkbcUCntmrEdrfT2xmCGR Fj3eWOGce1W2uWyOecb7H//U/k2k06y0zQo57W6SU27AtC8oa7cscuoTqcZOMegrPurKWaRJ4pY4 wIxJEQ53AnruHQH2r5lSaVj14qysYiw29tqLTazBdz206f6IwYxCSULnGew4qQDZCkCNIY2lMq+Y 5fyyeoBPapLdO6uzsNPuLfT4YzC7y3JUgh1ASMnuvrWVPcpbMEyGnkb7mc9e9aRl0ZnyRMy9ijYQ Xd5IV2TBPkXLHJHGMVNcXMMdw/8AZscqW4jUfvo9rBscn880pSd7I6IRVkj/1f5L4LmFo1eRV+0p geWG+b6/zqS9UzxuJHZlIAdmORj0FfMqTie7USWxTfNgwlMhmhwFUqCwXjP6dK1W+0Ca3mijQJcQ rIzkgYB6A/4VSnrqOyUCvcWhlkiWKfazkF3Q4I7nH+e9fS3wC0u3t7m7Sxmu7a6uLpZGk3bg5dkR myT/ALKjHTg8V+g+GMPacY4J9po+E8RWo8M4nu4n65/s8aI2rfEDTdGldUkGow3dqbu13j9027YT nH31j57cjvX9zf7NkSQ/DPw8ZIWkkOmiG36JGqKgiK57ZKZFftX0lMTJ4nLaHZX/AC/yPJ+j5QSy HGVZb3/zP//W+xv+C2+oKmpaDpyyTWs2oaqLGCO3cZhjkWcmXI9G25Hpiv5jviDY2yadqzX9+Tcj TpVN0qCMGSOPYmQOME7R+Nf6A+DknDw8i/J/kfyR4sxjPjp/4l+Z+IPiTTdUi1TxBJdONwvmnt5f N83zFcjH14IriUeMXAMsZJZgJXHev4e4qnfiHGf9fZ/+lM/q3I6ajk+Gt/JH8kbtjGVn2M2YGO4c 8fStZLCVHZo5mSNukeOW/Gvl6kj0ox6I6q0tSIxJLiJyACuNpYDoTWnNFJPEkpVV8viMKeXA45Fe VXkgsf/X/jj8OSAtBFIfMltLt7uE7NmwtxjI64GBz+Ve8QXtpqOhhL5Li2cXHlq65O7acDb7f418 TifelsdEVsirFYJY3qu7vcB5FVIXGz5CfvN24rp9TvrdZV+y2qSWsaiNoZCdsoxg5+vtXFJbXNYL QldNLvbONtsej/Z0ylvbJuglCj7pzzk9Kk02W0vNMkl1bSTqPmo8MEX2g2k1vgkJJnB7AHBFZlmZ HYwoscmwJICUNujiQsex9u1dJaQ3VpY75lRNznPlE5A7AA8njv60Kyjddy23Fpn/0P48bSKOYJGC TBGd5DjHOTwKfBNKmoQ/ZUijiEmyRrhthUDqelfP3aTSOeEb6HJtZxLrd5LbW8TiWdrycPOxhLZ6 YJxyB+lbTXx8q2is7G1tWiuvPZly3mk4zu7dulJuxpFWk0R3N/5kommlWwKqYjcWkSkgcnBXpjOB z2qq+u3dteRXMBgld4jbyuyjhSMbk4I3f5zUqT5rGh19rPcXKQ7kk2MRllT5nz3KjpWzqFlp8tpD byFFnt38+Mp8sq9AcH0wf1ranvYavfQ//9H+P/Zq0qXsGlO8bWtq10C2FQgA9zxmuVs7LW7y3tEu Lu4n1NZvPkkmjAtmGR8gGMccjPfivNpK+hpM1tcsbGeze1awVSSJWdiSQ2OQvbGRXlGtWo2ozyhk tlMaoqBWbkkKzda9DDoyqXG+HbC1udR0nUrpH8+3u1MVnbMHZwGUHKjkjBI/H2r9gPhVq8UXg20t RCJZTcxbb2ZD9obfBGCmOnBwT9a/pb6OtXk4jq0r7x/I/EfGilzZBGq+kkf0Tf8ABHLUYND+JC2M aMJNR1qK5vZBJuiW37EH67+OoBPpX9juvwTy+GJo5DEtw+nkhzCJYsBCwfafYfrXzP0g4cnGql6f ofq3hY/aeGdG3Zn/0uJ/4KPvPoH7T2ptbWN7e3z6PdT2+LJFt7bFztZwB91Svlkn1dfWvzc1a6ub 2PSbOaK3tEguJJbh1iCyyNJt5c9SRjH0r/UXwrm58CZff+T9WfwJxtGK4nxqX85LPo8FixuvPkjc qBMr8qV7jHuKzb6HRZrO5vLS2kELjyljK5lyCN2O+AckfhX6InZnx00lJnNwaZFKyT2jMbdlAOTk bh/EPcYIqG60IbZLR0uobrzQ7+c/ykEg8DGcEYrczL8enoW+ylzHlhE5Q8segAP41qH7RBJHbxvI Y7GIQsCobzeMc8dc/rW0F7plNp7H/9P8b54NT02W6tru2E9z5gfMh8tirgN83YYB6Uv2qKxiEchB knw8ccf+tVlPH4V/stKKZ/mHKXQ0HErB71WEzE7rl2+aQHvnPP1NSXRj1G9t5mtIbaV1SOQxgxxy KoA554PXp/8ArUItaszU7aJk1u0lxcrZ2kJULIYCSPkOOBg9ef61LBZAXEob9xcxZjZHG0IfWplF R2H7TzJIHl0+8ie7P7mNAouFBkZlPDe9aV2+n3EvnWm8IQUCHGH6Yf2J5496gmVTuz//1PyH8g3E Eun3SxvJvHnSCMI5VhkYP0I6VJJZxoYEaMmGBBGAzHcQBgHPtX+yB/l97Rdzat9NWfT4dWiuIhp4 uGsx5jbZJZEAJCj8RWReXltb213ceSGnhTdboX2lTkZJ9quMb6kuatob+lJYeI9OSedlsb9iHSO6 g2wPgZOH6fT61lWOmG1vpZpJDLCW/wBHRV4yfSqmrtIlzdtCK7eAag3mSbL9gEVSdjEDhQR+dVop S1z+5YiSNiskecrnuTWbVtGCm1uf/9X8ttKk2KuoHUJLVklEZt/K8wXMbhhvC+gI/UVSLXUly0kk 6ypvJR2jCHZnjgdK/wBlYbH+XEpX1Iby9fU7hY5Io4La1jADIu0yle+epNaVmYIIbedtNcS+d5i3 MpxwBgbR+B5pyvbQjmj3M6+utQV1eHfK81wTIzjJHfiren6h5Rme5jEgdh52WCspzgkVkrp6ClJW siMWdnLqUUU9/O2nTXAlkjX5pIgeoAPBwM81Ff3f9jy3enaa7TrfAxQiaEb9mQR+PHb3rc53JLY/ /9b8qbawnVIp/tM9pcNz5UfAb3P+FVdNtFOoypp8ybLacXOp78ESjjere5wfpiv9mD/KyMm3ZnaX 1ra3f+ki4hjlVMeWSA0o9APas7S7QabcQ3Cq7wwymd4wu8yHsD7dPyoL2E1A3GpKZLmA2ySymWRI j86fNnH0qjCt3JdyWlqrXenmEO5yAYSDjJ/P9aabWxg3d3LkejX0lrNfSeVi1u1t4LEyA3LxsGJf H90beef4hWdBcqdQlu105XnKlYoIiUtI+euw8cexrZO5UVHqf//X/Me7kt1ubUzqFi8ncI4FH7rq Pm/nzVO1uYJ9R8iGWRJPJKvtXH2hT1yPy9q/2gP8qGrOxoQpHazJcxxRGa3uMiaSEG5UDHCP1UEg dPSo9T1Q3s9u+EhkS5DtMU8x5V7hiTxQYS3JbM2Nr/aRvLWW4k+0CHT9UXAjZGG4x7COOcHPtWTb xeIZb6FYrTS5rY7smdS9wvugx264/Wqgrsk3jqEGkSu/lvIijlUj2GQ47D6/nXLQeS4u2w0f2yY3 LeaMAdeF9ByeKag+pLklof/Q/K5YIFmtZYr4R/Y5xcFYSAZsfeQnB49q2Fuo9Qu3ZDHbmCMyReZz LPyABken4V/tLGPKf5NSnfRCS2jucM3lyS/LuB3Dr3FDW40qaV7ectNNAbQeWodSr/eOD396u3Qy Uk3Yv22laYJo/NlvQPsvkkkh1aTHDY4wM4/WsvULiWznIZ2BTCMWG4sAAB+laqFlZl3ZUglkudSb McUFssSzxTLIAJXzypX17/jWnLDctezXTXjxrcqCd4DKpAxwPerSsrGMn72h/9H8xf7MkEEbvfpd xqu2OJA2+Mnk78jH5VLpkf2e4U+aNy8mMYKcc8j8K/2zhuf5GSdrIZJpXmakboTb2dzIqcDyd2Mh QB0OKfe37eXPZGKUbVxFsk8sh88/yH1z1q4/ExyfunS+HLa4lESi9iWfKny55doz3UE9TXueiRxp bmC8CySlG8slv3QGCefoRWi+CRwc3+1wt3X5n9df/BKHUYU+E2gaPbTmX7Lp6ETSID9oQLlQp7BT 0+tfbX7Y1v8AavhHrjxkx3H2dEWXbkDEm4Aj0J4/Gv8AKzjh+z8Wpy/6fL8z/UXMI+08K0u9B/kf /9Lwr4kafBo3jTxdpcojLQ+ILt1dh5LXG+d3bYDyNucHrXn8VvCbeWNjLHE+7a5bzGiB6fU1/t3w /N1slwlXvTg/wR/ifmkfZZjWh2lJfiykoshGIYzcXEyoVjbAUk+p4/Ss62dmuDbIQ0hJIZuMDvzX u2Pn29Spf3cVvthubQTSLcbxM7nywo6cd/WtSQafbiCQx/MYxMYzzGuR/Tmt4qysJuyMu+t7gJIs DyJ5oDQzYDZX+XbFaWhS/b4ry3ncJJaSLb20bLsacFQzOG9icY9q6I7I520tz//T+KNWtZUcsZBv iGNnUEc9qq6XdywvKVTeGTaFZcrnPWv96D/CNT1ZsxW97cXoiit9pEAuPMXlACSMenasa6zZ3Cw2 0kkbRSFpZCuGOcAp9Bjp7mt1sRdrY0Ib4RW8yLH5yyr84HyMPpRPanyG2iVfOUOsZA2gHjOaZlOX RGc0MkbWqwyKfnKSyLIF8vHcD07fjSQX0czybpN5hfy2V8gqf880GMpNan//1PjGew/0CTUo0+SM rvAHHJAwPzql5EchUwxOQyAfOQ2D34r/AH0ikkmf4JSkmhhfbjyS25OGAHBqCRhMIBvQXaS5gLj/ AFeMfMe2Of0qlK7sYykktDcN8bmCMFNtxF8jljuViP4h9aghs9TYST20qrBt23SCTDvyMAD8+faq MjL1C3t5bRkW0c+ZIoPz4ZTnnJHX8PStSxlaJkgSZmgYBZoy2FGPT6CgylK+h//V+JZXmnu7iG2l aO1TnzG+UNgdfzqS0cZVVmkQrHsLnmQ8YPPvX+/lNH/P+Q30kkSRGAzyRJKN64DK7EgBm4zgc/rW ZcyzuDGIsB3+Zm4Ax2WtB3srGvcx20dhAwiOYseZIR0JGSCffHT2qn9pkFjIu4lTIHiULyoHv159 PagRDb3BkhzcW6KQf3eTluO5/wAKIbjzWMEil0zwF+X/ADigD//W+GbqzV1ltnlmtAq8fZwA6kH1 OR/Oqs8gUJbWkV3cBIkhRpMPKSSAznHA5JJ+tf8AQJBt6M/5/ZOyJ0tHhna2uhtdewYEHHUj/Pam 3EBjbNrvUSYVi38XTP8AWtDJtvcbIrQXCRKBJcRjfliDGjDBAJ/KqgjmJWe7kBm3hSoz1Pce1AjS jRVjkMjEMV+UDqetUJIpd9vPkMIiR5RUiT2Oe1XBu9gP/9f4TkHmP5l/BLNFJFgOn/LPAwuT7YHW mraKcLasZAF3/Mea/wChA/59yzY2wWSSR9jsi5ZGPA/CqMoSK4kCIx+0DCgZIQ57D8KCZ/CLCsqk xOoKv94EYIx3rXhmmt2EVuU+VCWD4YDg54NVBXZRkT3WyXDOSTzjopx6VLFKk0i+cfLWRtpfHTnr WrinuB//0PjS0+yRyGRmj2QxbPNzljj0/KsjdBemeUS5KyEMH/hHbP8AhX/QtyK1j/n3IoJIykkR DlD991OWQf4ZxVXykTIXJDfgaiaS2AmhtbZoZ7dtzRyL/qjgqGHIOPY062jhtrGe1H724jPmLJJ9 8DI7/T+dEUnoRPYktYWuVjmMgjiePJVumf8APFSBRErRxlMA9QK1tbQyP//R+DpLdI97ISd53sfU 96fYmSOQTJIVUH7vYn6V/wBDB/z3lmeffM73MSjK7RtBGewP1ps0SlBwRtGQfagDORXV+UwGfCkH tWjc21kkBLmUTnDxiNwqAj1Hp+NAEdtI+2OK4WNZedrrwzA88nrxg1pSRxNC/wC9JKhcIygDgYPI oA//0vhCSHdIfs+5tq564BNZQtL2WTIBiZX6E7d3pX/Qwf8APdJ2R0rlgI47qGFSIwG8ht4Y46lv U1RVij+Vn5f4Qx/z7UEc/YcluTJkK7PK+AqjOSewFXFj+zswBKOymN+xGeCKBc7KUqWUSxwRCaVw czTSPu3k+lQGwtk8yVOJCMkn7x9qqOj1KU11P//T+ClLuwzwqDaPelgcRyzBo5FVQDuf7jdelf8A Q9zK9j/nsjK7syzaeV57SSF5VmTbGi4CxnPLE9wR2qxeKsM5VDG+Yg/yODjcOhHYjpg1RZVshA00 n2tZikcZdDEB1zwDnt/9arEe/wA/zGISJxjgfKAKAGX8ifdtvnbG0vjb9aqxqFRUYHaRhmPrQB// 1Pg69Qp9nS1RvMfO5vLLgY6/MOB269eeKZDDJEsiyMzNI+TubO3oMD8q/wCiA/57xwj5Kkcnv6Ux YMv874ZOQcccUALu8wGVSAVfy8Hgk/SrshnFqokAde7EZ5oAbaxxCVJmA2kbZQQGDDnIqW8axto7 ddMDx2zqTLG8hlKtuJ4P+etAH//V+DrgLMEC53Ecmq2Hg+QcgHLZ68f/AK6/6ID/AJ7zWgtbi4ia VYlWOZDCZ5IhIsWcevQ9OnNWEFylqLAXO2NZM5K/I3rkfhQBnXcG2GICYu7ucoD/AKracc/XrUPk SiOJCduCQxck8dsUARo5RSigMAcM+0ZNNkEbg9cqc/LxQB//1vhKK3kMDSoMq3yIWOAzd/5021jJ dIbiJUOfnfJXA9RX/RAf894+7UWxKp8yk/K5Ocj3qrEGmzvO046oOgq6e9gCGKRmcK25lPHtU8dv FiR7mRkl8tihH3SQOBWoDLRfMO1slc4yaWSJFfyzxg9+Qam0r+QH/9f4LmgtmilgjlMEroQkmM7T 61QiWSKQW7OTleZFGFOK/wCig/58E+Vk0lt5bod5AHPBxu7VKHhhIdiUYsAHNAhkjp5zuXyzADce dxzx/OmStcptO4Mu3OB1X60AS2zPMGjIXaxDb8YwOmM1JcReVuEfXGAetBpGeup//9D8/Vt3BDyH LHt71HMWO0bthjcMGPPIINf9FB/z4ylcvIA7yTvNksMlz3PWm7lbY4IJBwV6E0EkDzHzNgUjfwvH yirDQNZrG7sG38lAclee9AEgmYthFIRmB3gDt2/U0lzDNJIG807W+8v8I+goInsf/9H4Nlt7aJEk iaTOB5gfBGfb2qtcTbtmOv0IzX/RQf8APOWIAGYCTncOPaqt7JM7C3LuRCcIuMLg+n/1qAJ7eMmM iRiWzgFjzVnyxCBv3FG5NADgY5JAoBQY47ikw8TPGyjy2Aw/QN/n+tZ8juB//9L4SjhETF9u7jIx 1Apkqq7CZD8wGMZ+U1/0S8iP+eLnfQkk+UDI69GxwKaYmkRiGJyccHFXaxaknoOiZoIz5y7Qvfu1 REfa90kKAqBkkjkCi1ih9v8AZLUvLeQm7tjGySRB/KYZB5DYOCDVfT45ZnVFUMjHcMDJ/P0xQB// 0/hrdbszRxniJiGKjgkdamMwYuFGyNlxwctxxX/RHK1z/nnMpwqMNhI5wuecf5xToIwku7IXedzH ++f8j9KgCSVjKxUttSMdD0PTpVTbeB1lhUG3jYeazA4X06f1oAsyFpnLuBzzjGKjjhIdgOEc5PHB IoA//9T4PZIofkI2lzwQPWoYbUo7AOWBOTubNf8ARAf89cZK1mShTBubGdx5B6UF4TyThM4JA4FB XPEgESqruZFcs+ETByBjr6UxYVZS/Vh2BoFzoehtZVCu4eMNtYKdxUgjI/SlMKRz74XbY2F8vrj/ AD/SgOddD//V+E0+yyu3luGaJvLlXGNrDBwR+VSFYAwLAYHA45Ff9EB/z18+gy/SOTyzwdox71PB ZKYfNAC445HWgnmkVRb7Xd3YBc5GBUkrLNGFXCqOpPXigpT7leJLdTt3lu2AOtPe1HzGVwgyPKQJ ww71LSaBz7H/1vhGePbblofvAYHcA0228sxKHO+ZfvNgBTx/+uv+hmx/z18453ZoGGVYb+y4A54G avW0doYRG0L/AGl1ysiODH+K4/r2pA5voUDZ+fOkaEbhJtJIHHNaACwl1RissbYQ+vrQNTWzKN2y iF4twjMn3j0556elNh02WWJmM6FVXKoc72I9/wAqmSurFn//1/hWwimkWSVdyRW5xIccA5wKke2W WN5TuO0/MwWv+hFqzsf895nqzQSFQCSp444FOubq93iTEU0cq+XIGO10PA3Y/wA/WkbrYfCVRCNv zdevNQSpENkhky+/lWGFFAzWuby3aOC3jREeVfmUDJ49PaqEyuGjPWNTkA+orCzQH//Q+Df3t1IX ZTtzjhdo49quyLEts0aRyTTlgEjjGS3Nf9BB/wA+4sTXc8WwRbkT5mTGdoGMk/pVVhIrF4gW+YKo XgUATpZwP54u/MR/LyhR/LdWH/6jxUMe22iCMXdWbYXfkj6mgbbe5sW7rb2s4u2KxDBhGeWyfTt2 qhPFDckpDkgjcOKBH//R+DFg2MQpBVRyPeiIQ7mln3yqDtdFbafpnnH5V/0EH/PuT2u8q+BlTwq+ gqVkklBVGb5V+rADr+WKAGW9s7qph3zmHmXcNxXnGSfyq7e2DCNJop4ZiW2MY23bD3U+9AFDyfJZ CzBAeGJ5HNbK2YWBnYq0Ux+U/wARx3ArGV76gf/S+Gp7cpGCZAoWQHZnBbGcZ/KtAfZ5LUeZsjmZ cxqOrY71/wBAcE7n/PwpNKyKMkKvGMArt45/ixUl1C8cdvJA6sWwJoCcbQeuD7UndvUHJ7souphO 5Nx3DqKnBldF2tu28MD0XipEtdiU2t2YkuJm8u3SX7qsCZePTsKbMNqAxsFJ+YDHGPegD//T+FIL N7hZXUooBzIXO04pjF7NwodXgcgHbyOvAzX/AEAH/PuaU0N1aSGO6t5rSQDgMuXVWHBH4H8a9+0v wD4F1/wMuoaZ4ijttZ023M99DqipapdLGnzMkoOA2f4T97PY4zy4utVw9ONSlBy1SaW9nu16f13O nC0qdao6dSfLo7Ppfon6nz9cpOGNnPcoIUJZWV/3RP1qGzuGGIZ4vMthJ8shQbIzgD8a6jmLdzaI ZRIvl7Qc7d4VRnp+dG+3hjeC8tpI2kOFeNQZDzxz6cUBsf/U+F7xz8jW+BIpBUyLkDp2okLOkEZQ N5rZd9uADxX/AEAH/Pw23uWLyxbTHSORd5kTesqkBV9sdaitp5YbpbhZ2QqOMH7tBrF3Ql3I0k3m LKZ2bmQkY/Ok+0RybIposLGv7sxnBY+4oKI4itxuR4pNqAmIoBw3YE+latjP9niVZIl8x1JC43SR 8fyrBu7A/9X48W1uLW2GoOsN4jq0hgklMe0AlQHIHGeo61gtficBvsqWEbqM20J34f8Aiy3UjPTp iv8Afg/5/wAmiaMKCsh3ZxyeadcXEDQIrCVZlc7mUgq69higDPiuLDyEaXcshmaMCVMAEdAD70NK zSRJGPJCgsJuwIPHFKTSWoFmbUdRI8meaOUdFZIljyB0Gev50qmCS1V7qKYypIfKkVx5Q9sY+vfv WBcPiP/W+IvMhuC0hHyxjAVeSxFSwyRRMRPxG3DruwyjvX++B/gObj6VM0NvPYXLSxuhkSNeGQD2 /wD1VzMjz3sheUbzCwEnAGw9gcdOlYytfQqOki9a3En2mOOZ3W1jPB25CH2ro4pBbwtcvbpO6ybo 5+FZkOMr+gNSWpXlboZF5eZuZJ9riOcbTGH3HA4x2qW4ie3gtplKLFIxYIx3FSPb8c59qCz/1/iq G5KXbyhVcAZ3Me/elu0lu7yOQpmN2VYsElc9y3HT2r/eix/glB23GahE5KwTlJXhcxi5jUJ5ignB Ip9vsJjt4YHfb808m8Dfj+Een61MkrMtSj3L0ZFxMsCWpiRsmN1HyKV7N9fWo9UivHjgWVV3W7FI gpyAD7fhWJW+xBbLIlvG4ldsHGK3rXfeLIY4dtxDESyO+5pW5G4+lA02nc//0PidHktg01zbGNxI cJn5Tg9BWjpU21bmXLmT/XSJv3qobphe1f7wWP8ABlu6sSXqSXhjjilSN5MBWYY2c9Kkv9PfSrS2 N/BHP9sDBFLbQdmBuGPqKw0vY0g7ozLW6u3WWGYS+SI/3c6plIzwACaktI4y6Jc3LyhJMkFcnHWn K3Qo03t57+6H2K3mmS3YMkUaF2UDjoKXU2ltryOKbdEpUJLFt8sp/vD1HFQ4p7m0Hof/0fjd7EQ4 VIrny5GDJcGImI556/1qaV7oQrEJdi5wG6EYr/dOa7n+FlN2di5cWMLxW8t3qiy7lAJjUtsyOn1H f6V+jX/BOawvB8c9GhRYnhtYYXsWjf8A0i4Dzoj5Hbl+T7ivzrxQiv8AUbMU9uRn694Lt/8AERst cf5z+0XTYmg8L2gSKWFhYokgJ2spdB1P41/Hr/wVMnN78dPtxgkaWPUr2GVi24WoaWKMggdmKxgE 8D8a/gj6MkebxEnLyl+p/en0oJJcCq/RxPx5+LetHSfCesSf2gkccQjf7Cw3I+0PmYj/AGNw5/2q /FrXdUnvyt9KbfdLI29olwjDJww9sAfnX779KxqPBtGPef8Akfh/0WKd81xU/L/M/9L+THVpF3tG WPmMcIcbVb3zVCytyEZnwCH65GD/AJzXLJaM4mvfH21z524FUEiOQAOSB702UEzkFSwHfHHauSzU Wali1ZbadZBBG6R/MEIGw/hSTTQSR+bJNC5LENHGCFQgkYI6flWM72N0rKxlubRRIz72JUkY7fSr FiIrqKMO+Ezgb22BcZyT27VkP1P/0/5FpxI5Q2zqiI2Cc46Uj2GHEzbirL8w7MfWvnzWF7DIGV5t g2rEpwQe59KsXheMlmChAm5CvIwP/wBVBZThmjlFxJIgjWFA0hUE+YD6D1qZpYmjjVYHjiK/uyy4 LUAQwmchotxaLq6jg8U5CqtIyq7ADK7R93p1/Wi3Q6F5H//U/kVlu4Y082RzkKNoxjHuf89qgSUX bERSlHZeGz1B6ivnYxsj1VL3bssyJPGiqgDBR87scEAen6U+B2Vo5CFbYclXHHFUSpNsnt7u4klu WmaDDyZjEf3VHvnvVJoXe5lhN4fInYSeUTsUsB1xQai2aNK83kKWjhby/MYYWUjsPpTXS7a72rFH HGn38nHy98e9BE9j/9X+Q5rQeZvdvMjU/KDzVsCC4QwLCBJj5j6D6V882luegZ00UEaSBQJHceWh VsEEH0+magCPEPLXksBnJ549KZtF2jcnnuolltFIT95L5T4Yfu+Cc/pVuaQCYiynklty2xmZPL2s OGx6jNBEZu+ozUoPtdobcSSLypMiHy2BBB4I+lMcybYogGk2qAX28/iaDU//1v5BVV43aWIeYIzt l6457GrD6LDqCwm7DxxiQSzRwDlUzyAc18+ewW9eNhGtquneZ9liYRbJwJJ4+iqSRx9f8moUkijt VV8O0jna2eAKzn2GlrYGuo5ZWt8vHEirmNTu84qOTkds9B2qCQSs7eVFHEH+ZePTpWZuXxYefAGM heUphuMAYrYtNVOkJYkGO4MjG3ihnOQeDwRx+FBlNan/1/5Hl8NSWkjXJzE005uwIpfPDhjk9zjJ 7VRvLy6Wa1hg2LC7MswYEMPQj8a+XPZtYkVbpkEV7K8hDbvK3EoB2xV6zjinu0ilUpEx2naPmA7k flQaT2NC+tWDItqViEJDKC2XlC+v+e1Y0dpcXOp3N3dW6QNLhlmXgH0HPpQZEj20dteXBllnnjmm WWVWbfGhChSUHbpz+NbF1BA1ncPDtd1QGOA/KHGeSD6jrQawfQ//0P5KINNCKJwn2q5mUDMZwV54 X61pz6bJHD58jyFGA2p/CpHUfWvlz3J9ioM+WqqrMGIXYxwKdqVzPELvTxYRI5iTZvdsxkYbgfl6 9aAbvAy7W808QL9q+1rcSDDtCfMizkBQg7EHOa+6PgfpWlWSWd9ZySC8s7tJb8Sx74r7hGXB7gEg 46Z/Gv07wnV+McIv736n594lya4brryP1h/ZjtJ7742+EBbXEsjXcTg7cYcmWAlSh5z1AI6Gv7mf gvpSR/CrRWt5JYoZ7VdtvIdj2gRQW2+5yT+Nfqn0kpc2c5fBdIr8zDwFThwvip/3v0/4Y//R9+/4 K/XsWp+N7OPUYluNMhtrlrVpptk1k4dFSUY5yP3g/EV/NF8aJZV0PV79r2KFjYOWsI5c3EiIVGFz gAZOeOTg1/oX4YxjR8O6KXWDb9bH8feIrniOOJq207fK5+R+vXqNOyXMDo6IqyRbtwACgKC3fjBN cNHJb3PmRJCoCkssj8MtfwdxO759i2v+fkv/AEpn9e5Mv+EuhH+5H8ixZQo0s8au7OsJaErwAwIz x9M10Wk3UWoy6dZTIbXytQRJpRnzJEJAxn+lfNTWh6NPY2nvYLy8eKJrho4ZjCHeIrkAkA4/CunW 3T7MQXKBUyrdWJxmvMrIzejZ/9L+Ozw1Y3MurRHGy3aPFxNkGMjPAx2PU/hX0doq6YdNmgkn8y4F wBFC0JXyNi8MrYxzmvja61OuD6FK48+TUIYpBBdPC+bZiv72AEFdreoI7Vfltktp0gniR2XEhk6g df5dK5JRtsaLYvXjaTLYHzY5/tRIFsYl+XOeQ57ccimRzNcvbWMr28Hmr5MNwo8sPwThsDqOeayc U1YpK7sZX2ZLa7SZOJHYKWJ++U6HHqK2b7X4ordrYqszIVlaFB+/bPGE+v8ASsrW0NUrpXP/0/46 1u4kJMKk8DarDaCfTNV9Z1PUI7yK8t9M023hksvKkSFmncFMDcynoTknOa+fM4Ibp97D9l+2zQMm 9yrQTxbSV9c9eefTtWPqyuQs+m3TpOTuihRM7OnI/wA9qBQ3ItL0LV3W91C/ubSYXilIt06oIwvX KZyG57ita301vLCWttBcSRx/uyxwrNzznnH4VFnz3NTodL1XUYtGuVFlZyah5/ko/nMQoUj5j+Z4 9qbLrRkvXtVsAsdtCJri7IcI24dATxnjoM1tDcqLsz//1P49LUXl7Z3ktvLJbzzLttklQpADngyZ xwag0bWtSlvY7d7e1a3+WG7lWTAjK8MUP4etebSdmayV2kaXi2eGFzHYyeZbRkSq82BIwxyMDj/I ry3Vntbq0efzI1Lvs2Keowec+td+HfQzktWmcz4RWK38RSTzJOsNpEZI3hBZpmHQAe3Wv2A/Zyvb TWvD1hpltqtt5UlhHcrLeg7fOwJHQuQdrnzT6elf0L9H2tycY8l94v8ANH454z0/+MWbX8y/U/d7 /gkpfvB8Xb3Qru4t7a51TxZBZWiLIWdEcJiX2VlyT2yD61/brPNNceEhKFSVbXTxEkiMHaUAgEE/ TI9q5/pG0lDi6E11t+h+i+Dk/aeGVD0l+bP/1Yf+ComlXtn8fLjUJI1jZbq7tbi8EhV3E81ukAI6 GPzCQfcCvy/1XQZtsFtdTeVq93ILmO4MgksVVT8wJ+uOvp0r/TrwjqxnwJl/L/J+rP4F44ThxNjk +k3+hUuNfjb/AIldwLa8uHi/fPOMAlMAqjEZ56/hisbVLqG8vPs1nZHTLRIgAkbmVZ2Iwxyeeo6V +nHxcviIra4FnbJp8AWSSKQylNu1hu54NY+q61djU7W5vubd0Mck0jEMWACoPwAz+FbrVHM3dm1B EZrhZUlhVIh9oPmMF3gf3Qep9BUF9pV5fyTPb31zD5n7zdC5RuoJ3frXRFWVjObsrH//1vyJuV8r TbiW43y3nmFSXDDywAMHPcY71FpFhbTTrfSwi5uWg8pHK71Rc5wPSv8AZg/y7m+hoW88dqZbeO3e W4e5yzA8cgDH4YBpbYWs2oJFrlxLCFnVQPuPGhGQV7Ee3NBmZthqFlPeyyWDygQXDxuzDyyhRiP8 n3rWfSr/AFgX72mofNIFk8yQ+TIFLAN83qB/OlJXVgG3PmaasKX88clrbkeSsbGWZmOASD3+6Pyr K1nUbBb+JrB3itnjUxhUKhXxlxjnv60lBAf/1/yMvybNLZ1MclxcbXYqCWjBAxu/DFXpf7QuJYbU WO9Gg8w3AYeWScfKDn9PpX+ybi1c/wAulBtEE0qQosNv5kf2XKiyOPLjc4ycY6nA5rVsPD1nehLm 4lnihugYZjIFCOcDcqcDnn1qobByOwSanq/2RNEs/wCyjpmmf6NbiSxVbqJN2PlcYJJ565qtBJdP KFmlaO1QiM3EceZYW56c4/z3qmtUyuRdTI1STUNTu3muJjeSQ4j+0tEsc8qpwh4xzwOv510VtHa7 7C5S2aK9W38ie3RN8ErLj94/Ubj0wetRKLb0JcGf/9D8nZIUs5mZf3YzkI3yqPQAV0ml67o5kW1u 9NAMlqY2uljM2w49D0Jr/ZeKsrH+Wc+xg3gglvFt7YrFEpwAvDn/ADxWpOksdkiTz3EkNmTJFGzY VMj+XOaZg52djFt75Ehmt7pXilMMk1nKT5hkcZIHtUlgbm5gW5a3hk+XbPk8MenI9f8ACixLnpYs XD6rDDp8lpYaWbq2YlzJIdkqls8g857dK6IWc+oXNrJDZRW12sCvEBJ5kW7qzAnnHHH060GUvhP/ 0fzRvLe61O5nlSUJc26KW2IqBhgLlQMZ/CqU1t9l0fyNsO67uCXuPu3KBMcMOoHPSv8AZg/ymprY zbz7MklpCZCLlxut2JIjyvcmtgG9t4jHNnEwDM0ZGVUHqO+OKDZfAbH2zT7RbcmYXUV4xjLiMmSH Gch15x09/rUSXdpbGZ7C1s45ioSCOQkPdnOSACMZ9jxxQZFa1v5BcTTSybhKTvWVVypbqMe3t6VA b+3tLt/stlBcAD5N52sSeW6V0LUD/9L8z1htrvzJJikMbfPJwf3I7jnnis7SMPq940YheMWxW3dc RMgAA3Ht0Xp3zX+0B/lM1pYs3s8jBra0ljWbcPMlZQ6dRkfl/Ose6jiRZIp7na25QksJ3hiT2P5U GTi1uac4vfksrVwIQwyZ/kh3ccnPT61dt97So0klvutiYgInznjBIrWCViTO1dkmhCI3lskpPmkb g3+zUzPaTaLZGSF7m/N39naNwCCgA+fP58VZg92f/9P8xr3Q0ihhkis0ihkO5EZsCQ56Z4J6dulF pELbUo7W78iK8uI8xQyExxxjg8E9OOnrX+1B/ks3ZErP9ou7n7Gsl4IFJkijG5YQvVuBnHuabI8X 2dZoI8mIYC5+ZcVtGKSMU7O6IXkmFk1y04jydyCb5cew71zLXrXQee5LFYeGYr1x/n9KorndvM29 Nt7e5SVnTfbyQhrVs4wwIOSO4rSktyYnV28wBMqmcPkdx+lBB//U/Mmy1FYS6SWM0Ziw7CVdqT56 BT74p16Lae9JiCRNPD9oMcX+rQjGQPzGfqfSv9tYKyP8ip7i2Fkhuo5Lq9uIYgpysEYlMuenX056 etRacNBmnuW1fWJLe4N0Yba0ms3DYAyGyBgk+nt+NUkkwv7rRda8S5mjTSUkggtm8q5mlhKy3ODl WQH7v617x4MWOWaIXkzPF5B8wM+5gGXkgf0rSPwtHnN8uLj6o/rg/wCCS1/bv8M/DpggT7RNZwxl o/lh8olgCAenbj/Zr9G/2qLI3vwv8RoinMGlGbOccxuG+XtnFf5VeI37nxWqSfSqvzP9TZL2vhXT S60P0Z//1fBfjlHql38TvF0urQoYF8RXhs7sKVlcrKN43eoJOfrXIxzWjQQDDw7mEQYcpk8YP1r/ AG44Vs+HcE47ezh+SP8AE3PHKOa11LfmdzKhspbbUXCToNkm1nVg/wAvf6AjiqOpW8UWoTJHF5UU sfmW+187hgZII6Dn9a+nUVE+acrsfaQWl/BLDf8AlzzRkiNkOUZR0yasTLDLJbwyCPyoyIpSGCyI vbaO9XBXYpS6szp2l07zYo5QI5/3URmXITuAB+dT2tpmyZ4JEN+zFtxBCMvYAdc+9bGDdz//1vi8 xTXQzOyoNvlyLv8AnY9MLUthJB/adtbgyRabvWO7lKBm2EgEj6V/vQlfQ/wfNG51ueG6xZhY7W3H lbY/+Wi9AS3WsyeKKRo5rjb5u/zXTgs4PqPSuhK2hHOi5c2NpHYS6rBqFmNr/Z49NAc3kpONxUAF QoBPLEdD16VUsZH1WymCrPC1q/2dDIMCTgNwc9OcUGDmkVksokVoro+UT8yEHBPPpU93p0arb+U6 GOQhWIUs54GMY/GmlfRGM59Wf//X+LJ554bSTTo7l3gEgnaEAZJHY9/1qxZwpcFFEnlTFQybB09K /wB90rKx/gVKV1ZFJraa0kmAyxZjGR0IBPJ/Ss6fT7m3uJEEgmjf5oCo524HX0pkbbmhZLbtGRLd JZ+Uu6UzA5/Ic/Wpo51Dny23wnlXzww7GgjnRWlu55ZYo0j2LHIWChPkcHpx+FV9ZgaSS2MS+QAm Z1j+XzGOec/TH5UGR//Q+HIZj5LQjARsA5HzZFV7eK5adxDMZMjDoDjysetf7+wWlz/n/NGQNHF5 bMAewHSnwOzQPFNKzoq5hU9Eb1x+dWA1Le51ErHNIsdrANu0Jgsxydx9f/rVVlthbSTRQyGWNeA5 HB4oAmSK0W1fzpCZQNy7F6egx/jVC0RRIysMcFmkbgLimknoB//R+GGYM8i4bkYQ4yHP1p1pIIgN oZHb5ZWJ6+1f9A0LW0P+fufYWeKea4iliuNuw4kQqG3e/wDOrF5st7h0Em8NErgHrHuUHGO1UQ7X 0MmJWSVpSGIb1HFXGZGtSzAHZMWE235Rx90/SgWxHHIkhj/iJHyYPHFLNLcTXjNkOgjCOCgUKcYH SqgveA//0vhaYsibLiQ+T1kK8sg7mhY7WJC9peedDKAkMyHCsP8AaH6V/wBCB/z7lebTrjzgBIFe J1lWVTuV8cge/SpLaGZrn7TcrIIoW2qQNscjYyOcdvT3oIlr7o3zJHuHCqZGZ8HnAGaupH9nXzyw aYcFPTHahaF2toZtwRd3hupRjEflxqMKin1I/Op5LGaOSKBlU7oxMJUcMhDDOPr7dsU27u4H/9P4 PuITBIqB3Cv1HY4q6YgsEiKisJYirowwD71/0IH/AD7lK0jLW8ypI8Ewby1OByO/Xr2pqtOgIdSW zhff3o9QHzLLZp5u+OXp93gLntz6dKpqFiZnmLebcEynJ5IPTjPsKqHxGc5J6I6ExSJaQ/c2zDei 7sMB2z6daoGVUG3y97E4L7uE/CtjM//U+EmfeRHwCBkDPWmFQgbY+GLcL/P+Vf8AQwf894kzFXWW SXKIMFAuSzcYq097DsRWjkEjjjjge31oAmiWJ0lSTaDGqvEzDBOTgj6jiqN0plYLsQRrjcecuc+n +elJySAuRwoGineNiikBiRnHrVmV42hlVIxseUBJ2yCOvGOnPHX0qXNdAP/V+FpUktzjkFRjA4qe NzMi4YLIOoPGcV/0Lc8T/ntkrodLG7x7BnLHBI6rVdrSB5tnnGQW6gBhwScc9PfNUmnsYk9rfslw 8kC7TE2IWZMMCvcj1pZUZ0E0rksHLMAOCKAI5Yo/mKjapTOW4JPpVHCvHtbcrDvkjOOlAH//1vgy AK+/Mi4R9pP3efT9auxhm8wPESqHHIzuHH+fwr/oYP8AnoWjuNhaMELGmxU+VF7KBVea3jjuzdbz mcjcueFIAUfyraOyZbmraF2Xb5BaNAXUHgcb+9UvOB28lePunsaoUZW0LSJ9oCKNibclnIJJHXFK FjlIhIIWNvmYHBIHWgtST0P/1/iCSSLi1jV9knyi4VsPEB2x/npTbpIMxRWysHQYlaRs5x0P44Nf 9EB/z3lMSFSVkIz0+mOKjO+WaOOKJjgkuw4HHtQBHwsjAxgNnr/9arSzh2+zurFCN24c7SP8/pQB at7j7OkypbwPvk2qsq53gjBbPbqfyFV5o1DpGyKiBR8oOQKAP//Q+GkSNJPNjOSh+VDzjHtTTGHd 5ZRwWyQBjb36V/0QH/Pa5JFae7FqAIi2zOAeneoY7qeaRmIby4k8xgEJNJO6uSp6allQHXfgjzTv BKkEUkoJPlqSVVtu/sT7GmTzO9yLbKjRxpErRk4ldm2eWPXGOabIEgZ4mdXDNlHj6gY6fnQbJp7H /9H4LjDMCwSVUhyqYOC5xwR+n5VKpCZeQkkda/6ID/nvHxPDd/u5dyRhvlcHBGP89KqNLLbzsq7S FGE+UHd71tBaAPglOd8kZRwcbux/z/SmXjEEZx85wp9PpVBddC3HbxQAEXauzAHYFx5fA4P5GoLg jzAScsR1IxQS5JaH/9L4ISN5xNHGqeaFzG8hKrkGpILdokY3Lq8iYACg/iRX/RQf896aexfVbZ0R mlizIdqEuP8APasK8jXz3gXLBPm9cigNtyBEM0m2GOQsq5wFJOF6/wBauGSN41GCG6OOxoEmnsNc yptSLAXqQPSpVupNjhI1d9u3DHGPU0DP/9P8/mcF0VnzIwyEzyvODx/nrVxbSKdGjlG9SOVPc1/0 UH/Pf5FU2ywqYckjGNpPIFVgGyywq4CHoW3Nj3NAnJLcvyRbI4n2gseoxzml8pp2JeQjPLbjnJ+v 4UEyn2LCxgRkAj5Riq+913eX+8dRkA/d9qDNtt6n/9T4Kj86KMLdqDK3LIFwF9BU8iI0Y+UKw6YG DX/RQf8APOMg+RQHGwqx+b1+tQSS7pS2MqrYDAfeoAnjZXOQT8v4Zp6uS2JCGycqMYxQK6tcmVUM yEcBDnbVuaWCUBFADKcg+lBlKV9j/9X4bKsSFzkvwwHGBRNbRGPMeQU4J9TX/RQf874xHklgEcgG IQSpCjPPXJ79Kgt0aJ8yFkVl3BWypI9RQOOjHT/6VvSJg6xjqP5VBEXgyoGdwwR0oeiuauaQ/wAs OGQjGR0xUkMs9kE8kBCEKqVUcg5Hp7mspSvoiXPsf//W+EbSGWQO7Lgjk44FWngkG5UwGIyCwyM1 /wBEB/zw87K0duxOJwuRwSp4FWo44UPygsV6E0D52I1ussoAYAZ55xUEyNGHiViYycOvRXx0oDnY jnKGZVUeWuNg4NSWyG9RXhcFSpPB447UDU9NT//X+FpbORQ4lDdAQOhqW3i2ozhGbA6da/6ID/nm TurleQNJjewTBxj0FNmgSZVjj5KctgcN/n+lA7rYhhtwTnIJDbXUnBWrPkRQtFM+DCkoMkW4r5o7 rkdjQK62KzWFpD5radGIoJpTOY+6seuTSW4kWUFlORx6YxQHNFdT/9D4XjUGVl2KCx4YcZ9alHl5 kVwoeEdzwcccH8q/6ID/AJ5eaJYtrVJldpVMbbcxg87h6ioEMqlknOwE/uoweVHv2oBTTFuI1KSp KMAr1Bxj6YqjDDG6MisxUD5QKiUraFCRWNzH5kyLuEK+aysQpxkD+ZFWWJbazcg9+y1Dk3oGx//R +EDsdnWJzuQZKnvVqxVFUnCkk9G6flX/AEMH/POSHyt5jdVSI9VQbAT7UxY0hCIrnj7hJyw9qAGi Noy5jzhjufnIH0p1swdmwu7/AGuuD/n+VA47ohuLNrx/JYBSeEBO0deM1etbiaBWt/JjUCPY7kbi foe3Qc0HQt9T/9L4aCW0wdiZVIbB2yYiJHPI9aJHe2dAGZkA3bB90/Wv+hKXxM/57xBPDLnMYV3J 5IzxxgD34/WoCiKZGbJIOEXHyD1//VUm62KrsysCq89cgZFK4zHkquW4XfwufegZrC2vYpoLeeKK aH7N53mW6jAz2LY/zilEMMilMhdpwPMP3fxNZ8+6A//T+InliWJI48HtuXkGo45JbZw9tEskjDA8 w7Ame/6dK/6CD/n3JLa5hSd4JCVlxlmAyh/D6itMWFvc6ZOY5FilSTaJA3MfGQSPT/CgDA8ryAha UXBjGC6gjJ6d6V5ZdisiAxBsuCBuGcc4/CgCGNbkxzyMUmic4iBBJj+tSTWnmWNs0V1DG4dnmt4S xnzwMNxjHHY96AP/1PhOGNogiMGUkZO48tVg3NpJJ9mKqs6r8yDAJUcA4/rX/QQf8+5YjtxAjz+Y uUPyI3Ax71Hczoql/LLE4yIlznPGaDNS94sWJe08yVT+7I3SBuMgc4NUobqIRu1qw2Xp82VFXAHO QeeQaG0tylJN2FDlpYywEix8bG64q61wqFZGcsinhMZ8semKhyiTKVnZH//V+FbqeC7lkuEJjjkf HkdSMd+nFTeZFI0ZjRYlSMIFyecDGfqev41/0CKSTbP+fHnkSSXKeQqhQzB8fSofMEo4Vkf7rA9q nmYnJvcz501CF33RsAw3QhhgY4HJ+oNbcEZvUjS3SG1YQ7p98hO91A3EtjHPYe1SVGVtGQQyM29e WUtgjGcYqzeRo7brdGjREClZCGcnHJOMdTmgrnR//9b40t2tPsLPdQiB0YxPIkmRKpwFOMeuRxms SQwQAsJAzH7sWDv/AMK/6AD/AJ9VJMlZppY0Zmdj12ud2welOa5uLdTEgYROvzoDiN+e46du9BRW uY0mmS3Vw21ASqHKgYHH4cCrcE7fZZra4TyipCwuAApA7/jigTaW5WjWN3MTzKCi703Z/eHIAC+/ NKbefzHYy+cIkDIrNtVBkZAz1PJOKAuj/9f4U8x7nzFAEewj73DEd8VbeaMxLAuecYDcNkccGv8A oAP+fcjfzSVjBM0u8AqzZIXvz9P5VWvrZ48S2txbtG8pEsA3PLEPTOAP50DTa2LXlC0iiZ0bypky pKkDtnFVXW3VG2hmDcq5bleaC1PTUdZTCOOR927Z90Z5JqW3vJbpvOSIw7T5bbwQXOe36VDguhSm mf/Q+IxPKDcC4fzJJjtx91FAHGAOOKoyQM6/uuJEb5AeFJr/AH4tbQ/5/lJMkRJoiIZVj84gbvL+ 4cjtU1vZyTSeUZEjdgSnmttBxQMeLfaxtZkXCHezbQSMY5BqeWOESiRxvT7zbOCR0P0P+NS4pgZ1 uJ5LtgFDRHITcOVHIrVdHa5htfkkgACusSnqeSef1+lZNWdiovlZ/9H4rkthbXMs8NkY7WGVfOwr NCx7ZPbOMYPpS3dtBfXiXcChVKl5x91FwPm+Xp61/vgf4DJp7EkV+YWf7OTGjRmDdnoPpTTNHapc +XAm10UtJk/vW/vH8KycH0GZN3c3cD2xWJmSXklRkAYyPzxWm2qF4khK+WyriRSSOfpUtNbiuk7E 8cVusPnXU4QPjaoO5j6YH+etRmcOwWYyeSF2RPIu0N9KRbk2rH//0viIW22TKNlWO361p23mPdzW RP2U26lQ+NxkYdQP5V/vQf4FxlbRhLaQ/a7ZWnzsVncEHym4x8xHfngVGd1qztEo255J9KTV1YtO 6ujrbTU7J7CGKKOIuzEpwFlJ+6cj8KzdX0y/UxSQ+XcxOhllaMlhB6ZNZOLRcW0zJsdiI1tmW5aI CSacR7IkJ6j8KuC5WLVEmiSQNNB5ZnRdwcA9Ce2T/KpNj//T+MrzU7i7l1G01G0hO85tZSfLZQP4 vrx+tU7bTLi3Epzg3EKkBT8wXqM/r+df7v2ep/gvsbcaEmCWY+XFEuwbRtyR3NMudKhuW+1JMZXT LTBX3KBxtwKxaa0ZpTfQitrJpA63Nw1taLJsjAcKZGx129eB/Orvl2VpdtaicSs1sGiIj6MegJ7d KRoVLkssZCMzT5wVhYq+B9Of/wBVUC4lgkRvMJVCA0pbeD9TzSaNKb6H/9T4nskuDNGySM3kjDp5 m0YyMgjpzitie+WWU20kahRgpIp4B75r/dSfQ/woTtsaFvNZraEPEFMbFm2DcvXrn3r9Xf8AgllY 6brXxde8t7VoJdPkggudQlI8xZJQ0scSjPCsLcH6mvyvxjquh4d5jOP8h+7fR8owxHidl0J92/wZ /X7dytF4TJuHWEJYrI7ZwFVBkZ/IV/Gf/wAFKrie7+Nlxc2FtBM7rcWMsQudrxnziyui/wAf+rGT 6mv4d+i7C/Hc5vtL8mf2z9KV/wDGFcnnF/c0fjf8UtLv5dKuvtu63lNpO8YVBOWCAswcZ4yFIOem a/HfxGGS4eTzFFu+Ft7ZECJbheMDHYcD8K/bPpb1HHhXCQ7zPyf6K1FfW8VO3Q//1f5M7ySKdPKl TcSuMng/nVMRxwOFcmOMoMKeF9q5ZaRMJQ99WGS24QPNCEAPLsg+b6mqokkDcnKbfl7E1yvSL9TR QsKk+AZUY7lB+QrkN/T865u4uXluBBHG6/NuBHRvrWMl7pZel3OiSRgqVXYwcYGehNacAhs9GKzL 5rEPIpYkvhskfXHasrK1wP/W/kOtpIbaOJHicwM+VfHOTyc/nWhNfB1aXaTEPljQDFfPmlPsZHm4 VGQBMsS3y4arsMjbSGC7ETdk8k0GhYtPLVp7hk85p1CrFwsS4/iIxS3lwknl5VR5ZySOq/hQBlRz kSmTYSNxxxjIq9DJ5sm0RuidXwPmz/hQawelj//X/kO1G3txCRLncT8mw/dHuKx4yix+ZAUKRtsz u718+ekmlGx0cBLxb5Spjix5hLYUntzUc93CJRGAH4yZEPC+xoFHRogmhmTyZbUCRbkFSVbPkkZO W9BSeRcPmSSJHdSI8g7crxk/lmg2bsrltpl0+ACGGVwW3NHHIFb3Az0+tTNOLhftAOBs/eKoyyYH Sgzm72P/0P5C0nE5MIkWOTcdhJHzj6U1ZArYimLtygkjXIJBwRXzMpXPQF0/T3a4vppJURUQSxmV jhiBghfc+lQyXdtu8uSSJ5ZlJQQHd5XOMEjoeP1oUmirvlsTizhgdIbm3iAVRco8n3yx5wB9Dmp3 urZdoXAXPCqOK0Uk9CSVbiAwzNKJdioTF5ce9iw5xgc+3FQbr+XEaxyxK6iWKURcbffPQ9etVddD aMrn/9H+QhldMRyJMFnfEkicFT61aivJG/cOxdoxtMirjeB0z+VfPnsFd7R5txReCc4IxzTZ7dWt CrIyyRHEm3g49qma0AWxhWNF2LknuTk1sP5cUTSykAovLEdqxN4u6HW93HyYTuG3y5V289j3/Cqk 0HnsojkYtFJ5kbcZHXigiadz/9L+Sme7nESpCTG8rgN/GEwOcducVQnI3o0iqWLYXj5ia+XPb5G0 i0sLPNHJnBI/fq6EeWB0IPvUM9xHavIEcbxwuOpqW7NI1aurFaaYy2bS+YY78AmGbG8xk/XtxyK3 bG5bV0tV1CN7TyYdrGJ/3bBAfmz05POKo57W0K25EmmhSSNwi7vmIJIrGm1B7iVzpUjytZfLepGu 6OENxhvT7woNKa1uf//T/kXt3vwI83PkxLIfMHCsxI4HrxW1ba3d6XbXWnJHFNa3q7VlmiFwUfO7 Izyv1Br5c9yp0EXMwRSRvAy5T5Rn2/wqSaOaV1c5kdFC7uhIHbNFhNe4VE022v8AFncPNbC2uftI S3by36glc++B+Vfa/wABNat59Q3JbyvFbwK0VvOmY0+6kW8dDgjPvxX6p4Px5uM8OvM/NfE+X/GN 1b/1ufst+wp4Xi1X48+GdZ1VkYaNeIClvlWQXAY7yOnRWAx3Ar+4PwPZG1+H1tFEsiRGxknhjB2S pH5YHI7E4P51919Iiu6vFOCofyxX5p/qeh4J4b6twTUrP7bb+7T9D//U2f8AgrFqKX/x2+x2CvNB e2l9Z2NkZSY4UE8DGQqevRx9R7V/PZ+0Zpt/a6belDA722ksIGhXzJUEhIO8euXXg9h7V/olwQnR 8OsN39lr9zufx7xVy1+O6kVs6unpdWPyI8Q3ltEbMx3S3RlslM7rn74ypDZ7nAP41xCXSl5XGIyT jaG4I9a/gXiB82dYl/35fmz+w8rjy4Ckv7sfyOj0m0mn2SR4Rc4D5x9TXXy2Udo6xCVbZ0fZLeMC /wAw7jHr7Zr52a907IKyOgsYNxJiwfMUAtjG7HerTQzySxwtP5EXAD+h9/avProOTc//1f49fCck tpcXcRW4VHUKZZFxbzYORsPcjnJr2Wwtr+waO7vMW2lT4T7WcSbM4PmAegGa+SqJXsd0FojadtLS 6t73TZbieW1lMb3N3D5KX6EAiRQP4fT+nSrjXCXE1zMypLL5O1SGx1OePpk1yGkY3KFxqUFltthB cTyXMYaUxw71t8dD+lEd6tjDFLLaqyKS6F16nv8Ah1/Os5pJDgtbktlcWOpGcG5gMcWBOEl/e2zP zj1B/wAKprpdr/aGoS2t1PJPJIPsbswfZtwAQe2QM8etYzWhqf/W/je1CXbbQwKY/OFwJDKWwdvY YHp/hWYdfBvHs7eH7RLblPtAdTjDDKj3zXz4C3TX0sS2zKvlSS7p14GzA4/AenvVKJJrBXurqe3S z8oos0kn+qOccjoOnWgVkncnhM8khhubVGhaMSoUfzI5Aeh6d60vtl5ZKywQeRmPZFhcAe/t07UD NXwxCtpHqUWpGeS4CmdnWLK7nYsVAB7e2e1dLJHHNZ5jMe2WMtbq/wArvwSOOuaunuB//9f+QOx1 iQ2RtNUGyVGW0QxQhVkiHyoZAPXHJqOePSbZra3tYmiUOS32eIhG3c8gdBnPNeZB3NHfS5jalBJd XdxM9oiR7xFbwJI0iyqAOWPUZOeM15XfW5tzOJYPs48xgsP8OcnlfrxXbQ3REn7zMHS59Wt7yG5t yjwwS/6WVBPkR5AYtjsc7fxr9Xv2apYINBv4Ut1jnvbiCeyYR7bW0Rixk3t2zlCDzwcV+6+A9Rw4 3pq/Rn5L4yRUuEKnqj96f+CaOs/8Iz8cLQtcRX39uQxD7PLCGjtntm+SRG6jmQD15P4f3UeEoop/ B2nxSRKCumZu4kOQnmRh+D7BhXrfSRouHElOu9pJf5fofX+B2IhX8N4UY7wck/m7/kz/0PRP+CwG jD/hdCWEV9IttdarcyrFDGD9ohVobtQ7H7u0pHgf7Rr8eGdfMmuPOS4YxqfJV90UYGVBU+/ev9Kv BmblwFgbq3u/rufwZx4r8VY9LpUaK1xYrqO2SF4rLI2zsbVbl3+mSMEeoNY7WjabHLbLPHdxIStn duCJNzE7vMHJ49K/XYu6PhZq0iC3SS5mgIEYeEiOWZhgYHc+tXLltk01tqFiCYwHgLRgxTA9GU9K 3h8JzzVncxNTWCeazeKNfNtm8xM/dB+lXPMWKH7RarOZZVIu5d2+O35Ayo6YGV69zXTF3RlKNz// 0fyKbULh4fsW6OQpZNZCV4xIsikk5z3YE53e1T2rSW+nQ29s772OJXA2rJjtjp+Ff7MH+X8orZjd OZ7dy9qjyNGxEwmTfnIIIA7fWi7vU1C3LX8JgFqxjS6EO98ZwEznpk/rQFlsYKWbRNJL9yNJwduc GQYBB9+/Ndbp7/arVxFc7UcGO4jjPzECpckgsivfvHeTRRLHHHb2sXlNIAUZ2B4OD16nJz2A+lOf SY3UKodmP8Ea73AOfmx+FVcylbmP/9L8lbJNNtWV7uVhHMFhUXI2guxwD6j0Gfx6V1V5qlnaWxtr a0HkW8fkLco27c394f4V/swf5euSSuc7ZwWEt2zXNxdZumLPdyKJG74yB/nmtC81AQRtp0MP2rEg eFWJPlHjLqBQlbQnn7Fe7055r6xuNPu5ITEyXF0oRY1IGC6HcDyMEZHXt60k2pR29tJBCqrbO5ln K/MZmBJ3H3GT0oDn7HOx3lut4zmC8uYZIN8UvmCLDHGCw2nj2/Wuktbe+mtlttPv7i0vZp1kYlFe 3MSnLgsehwCB+NBLk3of/9P8qNSgeSY+ZK0qQ4Ekh/5aEdcGq0t88NrPHpJjkm+ysbkPGpmiCn34 6AHI9a/2YP8AK+rLsR+GGgmeWbUA73i2jSRQqOWfABZj/s56d/wrWsJEku5PMkzG/wB+NzmMDp0o OSUraIm1S7tbGeIRW1vPGAUVzGrRqTwMCm6XBfaVFdQyoqNc2pKvJEGiYkbkwO3agcZXWpjIT9qJ u5WEzptZxlYSV649OtbUNy7JJLFDJc/Y4t0RjmCJcZ4Kt+lBM2tkf//U/LGS+cqy3FzLEyMHszBt JtXUhgPRgTnOfWtJNVNysd4IhNPAhNy8+Ckh4G4p7nmv9mD/ACkpytoVlT7ZC80aq3lbvMBTcwyM 5T/61SaLJayKYrtp7mY5RSGMSxKDwD3/AJdKDVSsrHRzW8FvGY44QCf3gUDn2rji322dlkChbdt6 IsmwFug5700tbEl+IEwNPLGVYvsREO/J7Gm2lkzzWw3HzFfc7OAD3xitxX1sf//V/OK803T4Ld5J 3uJftULw7LVS7wOAdu9cEEEnqKxdKgt9LEglSO6AO6QYaFiCMcHOeP6V/tAf5SSk09CncTwtGsOn 2KsZrj944kLzKT6dzn0+lUdYsfJtYZIoniEJ/eAjnjrx7YoM229zSjtbu+sYFkMkkV0yhJYmJuJM 4OcfpSzaRJpupixhkQ3ksIab5gVzj5Rn1HQ4rSm+hjJu9i/aeHtUvNBknvJLGO7junM9tFNl440O N7A8jOTjnk1Vjj+wKkat5gIJUNwUPqP51oQf/9b8vTbTTqbmW6ZXV9kaEkqBkn1/zmoZLB33TSuT OT5iF3yz49Mn9Pev9qD/ACUk0lY0raK42wEWtvaTeWY5JjlGcOOrnPsKowefcyvarChEEohe9jVl huT1yMn8OPT61vH4UY3V7FzUdHCoZpbxkSJeIn/1RPTNZpii06TM48y1kQfvDHmNs4yPwNMZc8me 4MTRv9ktXISIoAFYL1Cj1wDW7NNateMNOVpIVXy4muYwJD069uooA//X/M++sUv4oPswuYCu6K9X zQwDq20uCAMD0A9utV1urrRpJIrKC0u5ntjBCbyH7QyMcHdj14H61/tulZWP8iZtXLRvLqRrdltk 86fiUkrbxxnHJC9AM54qhe6clxPG91bRyTQv5kcn31VhwGH0/wAKYuhoeHoZhfzGaM/Z0G1wXCiR ieMDrxz+dfQljpNpAIbu2umDCJZn4/cjIDbVHX2OaqHws8yq7YqL8z+pv/gkJdCXwVZ2kQdVh09J IFc4cNI7u7Y9N2cDsCK/Xr9oO3S6+FvibzQWMOnvK6r1dQPnH5Cv8sPFdez8Uqr/AOni/M/1Sy39 94V0Gv8Anx+jP//Q4H9pqaL/AIXJ8SrOMOLeDxfeXVjCkZa0EU3lyBlYDAzuHBPXPoceDSvFHZwR RPF5krZkVW8wR45ycdP/AK1f7ZcGO/CuX/8AXqH/AKSj/E7ilpcQ4u3/AD8l+bMI38EN00jZAmYw su0r5pxyV9qtWVxbypLExVPLciEkAyoDjK5/Ba+tWx8s/iRH56ac72tjFE8bt5kksnyumR3PoOar Ppd1qbmWM4mjYOXwfJ49CO4HNaQ3InvY1oIZLydEvFFwImDkk4Lleufc1JI0kdy8JiWJto2SKQN6 9Bx2xgj8K1IP/9H4ua1tknuDeReYxTMCMAQrD7r/AIHBH0qvFFLH5TozyRNmNXI++R1HAxX+9MVq j/B2TsiecIkiQKs0ck43SnGQuMYI/wAKrrAYZNrS+bv/AOWh+Yn61uc/MrMfbW00rSK2PIX5nxyV 96bHMhnuILW4kEMUijKH7rYXOP1FBiPvori3kgvdRAjtro/Y7eaQbWZjz8oqaO+FsGgVg8efkYr8 5raK5VYym7vQ/9L4jeN4LiSdHzJLB5XGGwj/AHh+NaHk29parMJt1wAHPz48snBxiv8Afg/wDlL7 JmQ308txJLLuIbnczbi5psl7I9vMbQGOeXKOHQF16D+g/KgzC0hmumUTK3mNiJmkQrgYAyfUe9Wp bOW0G0OshVirKi4Ea54oE2luVlfyt5j3k7sHcCNvHapFkluJbaSeJkiE/ltno6jGSCKaTexk5Nn/ 0/hr7FdTyyvtSPbLsj2jYhHbBoigu4Q0srxJJCok2q2VkIOCP89q/wB/0rKx/wA/sXdakkzyzxB5 MBl5bC7ajDMsIkBDMjfcAO4++OlMoswTM0wVyY1k+8W4WmXL3dsJtsIe2Pyysib5PvDbj2z1IoDy KcrJJ5W1irEfvEHHT1q35UsrJCLaaTziFZghKoD/ABMewrWCVrgf/9T4hltJY2Plkfuc70lYIcA4 yKWaOCK1t5EZpHdyG7yg993pj+tf9A6Vrn/PzLVleF/LLMpXccKdwxRcXUJvdky4n8oBcoF3DHH8 qIu5JbjzJFtBVWU8IeCQeKjOmwwlvOfyI5P3hB+YZ69PemZzfQekNoJUVpViRU3RyjG0e/6VlQ2o tNQupWvvt6ySkqyHEar22/1qovlZUNj/1fjA20X2ZLuM7/NyCrDDA/T8DWKF8uRFKIitz5Zxtr/o QP8An3LKmcBZApKq/wA4KnAHbFVbkyOyg71QtuVFJAz0zigyl8Q86dcQMZnLKrp93oVqSF4pHFrn bIw3bujHoKC3KyAxJbF1kGVbgvjOKsWtzCsOzYz7JciSQbCPpQZXdz//1vhO6uCspabBVm/d46c9 KeoaXaquRu4z6V/0IH/PipNCRo5mJHIXgkdDVhMzSbVI3odoRqAcmSSRMPkl2lh94Lyo/wA5rNmt Va5W4icsYwAwkG5Bj09ulC0JNGBw8y+a/mQqM7EGCOuaiBQTSR+SBAxJRgoVgfcVundAf//X+G49 qOE8rdu+UNjJ+lQQQxi5mJDAHOA5Py9sY7V/0Lpp7H/PZKTTsgC/OV2r5bdc9RirflK7IpwRjHri k5JaD54k81qCBkj7uOe+KjjhSURRzoq+W+8EHk4PGaxKJZ977wCBlto2rtXH06VRYyKi2j5K7vMz 0CkYxQS5JaH/0PhOdZzMNz7lzyeoq/8AZ0WD7SJovlIVowf3vIPb04r/AKED/nqlK+g+zVLmJ5hI DEcquDhgR6jtVeKFY2eNc53cnrmrg7OxGxOYEVXABEm3KFRnJ/zmo4J5REQ8TF8/KzDaBjOeDWpH OPkt3nVXMqhTklcgHI56VRVE3MrvtZDyCPvD2oLTvsf/0fh6U28ilVjWPLDDbcBiMc/X3qSZ47Z7 a2M265uYzJAIjvXaBzux0I44Nf8AQwf885VZCpI/iJJ6U+CNWLGQBsfwkZxW0fhQE0iggeWGJJww AyTWf5cP2uaU+YYMBYo2xwRnnP8ASqAuROlsWbKkMpUKwyORUEZMnnbRlv4SOBQB/9L4dsmgDOjn bL2J+6KJ7K4ctObiMQnhQh/eZHqPSv8AogP+ei7IHhRkVot5YY3kjoakuJMhPLCxeTGASOGlwf8A 6/6VLkloXBu9isjwtLDJMvyq2WwM5+oq3OsDys0Q2nHRRhT7ikp6ajk3dIi2SR4bIdS2Dz8yUot/ Pm3sQsceMtuy5/CqTT2Jkn1P/9P4PuLoxEuI/lVsHHykgd/5VYsvMkSaWRuXAODwuB2Ar/ofbS3P +ecnEVq4PnYKZ3EbcgMvT9aSD90zyJgI6mPBXqOmDUwatYBATDH/AKTHlXJERUdfem20SSygSS/Z 4CfmLdB6f4fjVgLewuunSi3uUX7TwSoDSDB7+neue+zyRhSCS6n+LmgabWx//9T4bjkkeFQMAsu1 2xjNQboxdCxa2mllKb3eIBo1UH5ifpX/AEQH/PS5N7EdxbrFI6Q7iCfkOc49KpxQzNN++k24GFBX NaxaURXdrE1zuWMoQxA5OzrTDDJPEmMfKQfm6ipcr7CJxEttuEgEg2Z45I4pWRJArkE+ijg/jRDe wH//1fhSFQW2ISOMkjgrSzXKxF12bmZfLbPHHGa/6KD/AJ59tiqEtiFWKCIGM7kKjkE9f1q1hjFJ iJC7gBmxllA9P0oAy5Ufy2EbvHxtLJ98jvWtp4t5LbMyxyKybUZl2sKAGpNYqWj2lJ/MCpI3KYOR j8yKoz2lxBM7MUNuXKb0bBz2wOtA02nc/9b4Ga3xLBcQ+WJ1G0u67vlJ5B+tPmS5WQAMqrwd8fP4 f59a/wCig/56G29x91DFEyFJjIWTbIxX5c+1VVzGx+zrl2IDFufSgRakJZzGyujp1BX5SfSrKeSI nDA+cfunHyDp1/WgCo+/cIwDnu2OK0Iw0MG3auVPLY5oA//X+D4biJ5HtX/1v31yPmIHH9alWbDN GwUrnIOORjNf9FB/zzl0TWzRzQTWwkSWAqJfRv4f1xWXHbp5e1QcRHaR+HT8iDQS2rMQRMHDgAqT 90DpVlo2dWmWM7I/laQKdvA9aDEfawsImnctsIzG3YigQBVaSR1YE5Qp1x70Af/Q+GI1LsxV8Dbh c06GV2YW4jZpixAQAsX+mK/6J768p/zvixyCOT5hkBvnQcAYqZjLcmaWbyGtp3EVmxJ32qqAGU84 755FDkluBnRJNam4tt0ZgM2ROhDoxXI4Pcd6shN8g2MuEH3lGM1i3d3YCyxPGhcYIPAIFJHBLJae c75ZX2InYCkB/9H4ctxIn38gA49qsv5k3yghccKScV/0QH/O+IbSS1YrNJFMh/jiYsD+YH+RQqqG 2KQQ3AYdaAGz2UJUodxJGDgkGiKBVWMykbFOMZycUASMIXdxGoQMMHI+U/hVMqII/LTKoJN4UZVc g8UAf//S+GY7u4luHNwWleRcqxJOccAc/hTYppFEpAZGRiCGAwK/6ID/AJ4Yy5SCeN5ihRQknHmM f4wCeR+dXoEaLdtI3dOecUm0tyRqIwLxlVcMCyup5B6cmm/ZHnt0tpnQeZhZ3ZcFOCDgjn8qLruA pWK2tltrX96YTsL5y8mO5z9KYQWjRQGjeUhVJXLKaYH/0/hx2aMpvwzooBKrtBqrIkyzQymHMLr5 hVj7gAHn6/lX/Q85JH/O+aKW7yL9sEihg2yOEAq0Y/kelNKyu+ZBljhR39hRzoAniMZ8qUNvwMqR hhkZFJEipkjAKjK8Vk3d3Ki2mRS3BuPkKlypwVQZLYpTHK8EbCGSKI5CBk2nI60hN3dz/9T4eAht 1/eYDtxkjmqxRRIHiLbQckDtX/Qwf88qknoaRhWWAmQBW+8p71AqoOZVPyDAI70FbDwiyRSSBwsY O08859DV20lTMcWxNhG1WVADn3oEpJvQhMAkvtjyJCFBPmOdqnpVCW4EkhjJG7d5SsqFAwHAOPw6 96LrY2jK+jP/1fiyxsdPSEw6hLcWlsQ8izRLl2ftye2axFikQESsZkztjkxjcPU1/wBCk2tj/nvL YNswjVAC8T8nHSpb0xrGnyBQgJ92Jx/hWZcZ20ZTS3SSJGUkMx5zxjNW106WVPLjaNTbsJFd1ynU ZyP0xUSkldI1LV3eSmSKJgsexduI/wCL/wCtUTpY+bAk24I3LkZOSOf8BWRhd2sf/9b4tc2N1Eba 1ItJkjbeGb72D8u0/hVBM+aYZtxKKChVeCR71/0EH/PpFvlLF9aBDHKgYM8QZ93Jz3qnaRSxPK0c p2TLh42JwcHsKCeaS3NOGxM23MZG5sArwD7VTk8pGlWQYKZTDHhe2aC+aI2NdrRkYwuPkUAK2Kin jTzyYcqq8kd6Ak7LQ//X+GYYzPc43s8hUsF68L1q1Fb2y3JnFsTdP+7ecjICjkD25zX/AEEH/Pg2 3uOu7qNvMjePZORjIGUwOPw/+tRp8UU0c4Z2Z4IvMKqm7aMgZPoOaT2EM+1TIXS3+beNjDHY96rr p8omO3jI3lOhHrmspSuGwTxAEMrYdeDg0qW6ojs8nzNyVbJZvWpFfWx//9D4YijR5CwQELz0647Y qae3RmWSIMkZXJVuCp9Pzr/oAP8AnuckgjiQ4UrwDnJHINMngkAfCcLyOcAigzlPsWLlH+zoqAk4 BJ6kVSXeAC7FVLYPbJ6UGkXdXNNp3tbcpCiAyEHzCuXX6VBY2mrXBEsttOtm7lTcY+QgdTmgZ//R +J723tnVhuc2qcxrnkkfX3FY/kyABvLzkZQ9SR61/wBAB/z3liAShgrKdgOWOcVbNwjLLA0YZWxs kOdy49PrQWpvqVYYoo5fOUqZVHAb+L2qeaeOa4IjiZF8oYVm3DcANxz9cn8aCW29ygrr5/ygNKhx wfuVpRhiJASCQcEjkUCP/9L4cMYKsDxJnJweoqyLRZHgikU5fGCpw+PrX/QAf8+Dbe5Ue3mt7ySW 0BSMsYjvYFwvPH/6vWo2gkt0umtgjO371i3XOO2fw/KgpTaVidJZbqyhuJI22qhjMMgIZDjsPqc1 Vs3/ANHP2qGM5zHhMqoGe3fpig0i7ohMMYO23BjjAxgnOKvwhFCRowcK+5nHKigZ/9P4fldWuFIC sSNoVRjpxnFRQuRMFU4CtltwzkV/v1L4mf8APuK97vvVjnt38hOWeMhTj09f0rUT96I9jmcbtkcW zbIo+oqTRTezFtprZorh3hnWW3mUFiQElTqR0zzgf5FV41FxOZoz5MZOTg/KR6HNBd9bEklq1ixf z4ZI5hvTZJvdM9iO1MWR42S4gfbIn97nd+FYN3Yz/9T4qknkm82a4kO5gvlxKB5WQQOR9M1Z0vT9 97sWVzFPGFMZP7sMe+P0r/fA/wAAop62I5/KsxLFLA7Az/KyrknGQcUscBuSqMEgjmO1Rnbsxxk+ 9BG2wknnWs6LKxmEH7tGaMLG4XgZx7VmXsAknuL2UruuW8yRolwoNJuyuBIlo0UsakFwFDIzjCtk dMH0rTuXeeKFJyCkIIXAA2A81HOr7B5H/9X4qtZ4I3aJtzhiSozhsex/z1q7YywRNcgZeVYDsctz GSep/DPFf70t3dz/AAGi7oda3dupX9ysoQBGjY8ggdf61fWX7RcOFgSaPyjuDjcVOOuPbk/hSNoJ ozEtrG1u7S9urzyLS2kaPyy2JZi/GF4wMcnn1roL2WG5ijjh1GURA5WFCPKY+4xn9aTaW5duhkvA 8UaxRozfaWKySZ2oRT7XyrBjbswlkjXeD97aPr2NYG68z//W+Q/It9VuTcXIiZ/lisQcLFFJkYaU Y+ZcZyBg5OfYkP2yO7dxJZag23ZLHY27RxRKmF4BHHQciv8AeA/wWaurE2q2Ezr88gtd0YkVAc7M j7p9+1Z+k397ZSakLO3MV3HZiOOS4hS6hnGQXAVgQOAe2R61nOw4u2qJhdY8y8ZUmnkfe0ZjCRQn GMBQMdc9KbpzfaLppZDHvClgW4J7YFZm6d1dE0NvJLdy3VujMkTFd8fK7l5P5YOac+oRahFvcKcH 52aJVl9Bz19eKDWmf//X+MUsl80tbS5DuA7OdoYHsK1dWtLXSktmjeKR7lB5mAW8roO/r7V/upM/ wnHaMtutxJ9rRpbJ8EgSeVHu4wCcH8hzX7J/8EkPD5ufHOpmK5YW194lWW7dIgARBHGIUDd8fP8A 99GvyPxsqql4cZi3/L+t/wBD+gPo50XW8TMvina13+Fv1P6wfEpiXwfctNICsel4kBOAwCgY/wAK /iJ/b91ua/8A2h5hp6zk6RZXMzBWLwxCa6/dqQP4uXP41/Gn0VKPtOLq9R9E/wBUf2B9K3E+x4Wp UespJfr+h+a3xneR/Ct3eNd+ZPLbzyNbxOy3Me0Qq28ccOJB68Zr8XfE1zDLq09ugZoIXx5gT92f ZfUjv71+pfS7nbIMFD+9+jPiPoo0vcxNX+uh/9D+T02Udztf5kwchSNuR7/lVa+tFuI2DM4UDaHH 8OPSuOp0Lmle5BbNHaK0AkQwYBCj5nyPWiXyZo38uHOEJ3k7dvvXK9PdIObuLhkgW1WM7zPuEwOC BjBU/XiprXTnkZXDEY4Y9D+FYTbvYC7JBFEQJCrwrwUPLgg/epSiOWkGWi24TcMfkKgD/9H+P1pZ omP2kP5fmHyIRyDk9q0rYyS2DxxSxRuJmk2Py+Ow+lfPlwWokKBgsUqbHI+Yt61NbxO8txAFXMSh lDsFMnqAO9BUpWTQy6v1jl2Rx+WFUKABznpUcJe6uhAoZtsYmlkK7VbJxgH2oKTTWhNexS28pCgi NYw2/bhQfTNZFhqtlMksttdyzXCXLWrxNERDlACcNmgpNrY//9L+Qm4kEnluQWkDYfsgHHFVL+zt LR4Lm3UbZ2AkgjHyk+pr587ou6Lbfv4Hg8smBgGkzkAVA0tvZQPMySFETH7uMyHjsFHJPtQUacFx HFYZiUuzAyKPuNzzjB7809p5bmwjtvmUg+Y207JXJOdpx+VD0Rpq4kH2fYxSdWy3U5wwPvUiReQQ EbbIG6t0P1rKUroco+76H//T/j9ns7Ey5lWQGR/LuZocCQAHop7HrVeK4t9MnvJbmY/ZIdptlI3y hcdwOp6dK+XPRs0XrnyNX0hZoL6e2M029Vjj5ZB2cHkc9qwLTTxZJIkMa/vHLeZj5ye/NA02k0i4 9g5MMks07tA++VVmI3LjG32+vtT7ZZFiGQrNvO35t/GcUEnTWl9tgdDbscLgY+QqR3B9+a6GxGnX 1qqbntr9n2R/aJVS3Gf7xB46fTmgqL5T/9T+RrUpftd75bRyWp062WDauPIuGHBYEcNnrn3qkZfs 6g4wzNukAHUV8ypNaHqxk27Mlku42Mfl3MkAZx8scYdpD2BB7H25p15JKxU7cBeox94UOTasyzLs lSC6dYvPcFzNvc5RSxOVHfj8ua2mhlvjIvmmO2K7SwUEhsf41DklozaFraFWa3uY0ghTLMf3ZnOE EmB1Par2luxjuIHg8sg7VmJ3GQdz7UKSeiKP/9X+R1pJo2ZETepO1RjkfX071Dew3FssFyhDTBsq pGdlfLn0BZs7u+khkguZ43utjTEScYH8KZHoOn0qrdQWM0S3LeZ52SrxcgrtxgjHrz+VAFMNMr7f s8ghderqQxz6D866NbqwiWWL5YbQ2yqkTDY8RAGcHP8AOgTinuc1FbXC6lLOqRrbzRhZZmkxISOF 2j6VbtLV7G5V7W5kRpXLz7TsE+OgYd+g6+lA0uh//9b+R/UZ1uInEjKtyxL7o125Pv8A57VV0O3u IY0e6kaec3BkgS6QFIDzgem3Hr2Jr5c+gas7Ml0+6uzfTx3FqsCeYygpJuj5PDDvWyLiSK7Nshkl G3eJHi2ZHfpx+tNBboaI0uH7dFfRXjo8ieXJAQNkhPc56H6V9l/s06QguL65kiZGC+TI95L+7kQO CkiqCSQCx6DuK/WfBqPNxrRS/rVH5T4rT5eHZpd/8z91v+CfGmi9+OVq5le5jtY7ZL61hhZLaFWn R1dnxjLKHAHUc1/Z/pv2yL4dyiSEpdnSNyCLKvHH5agD64FfW+Psoz41w1Lsl+h7fhFz0+AW3trY /9fI/wCCj17J/wAL21q9jSSa+s7aO2s3uZD5SwPPMbsKP74yDnvmvwg/aPuLZ9B1nWo5Yop4pLe1 hs7m4Aa4iG8En1YsF5HAyBzX+i/D6VHw+w/lS/8AbT+OMyvX8QXCX/Pz9Ufi7rkA+0XFw6C2Fxdy ulijb/sg3nCA9x/9eq9vp0UsJBXbIy7vmbtX+f8AnbUszry/vP8ANn9mYFcuEpx7JfkdDYSOkVvZ 2nlCVXCHzH2RkZ55rolug901rfLKT5QltmCbopCOCpPTIwTXgTVrnUlY6G1uigSaPaYgNu08KCO9 a65uQsqgSP13A/J9a82tuM//0P5BNGvJ3AtGtprwIpdVVMJEBj5Qen5mvRhJc39vAksssNnbQNA1 qhAjkDEHBB7denrXyU9z0Y7ontNQto3WCSEzxQgKLaI7HxyFA9B0/KtO3aW8ke6ijeC3A2+S3302 ZBz9TXIaQXumqRJcXcCfZ3COmPMC4VSB3Pvx9ani8OXGpajcPb3tjaWlnAHmi1S8WEuR2jHc9eAP r2qJ9gpq7sLa29rcCW1W1ginnl2vNEArPjgEkcHpVCXSZNPvJla72tbn95GimRvTAA9uefQ1hL4W U07WP//R/jht7SFJru7FokayXTHy5GFyxBH8Knp9arQ2t1K2pap/Zqj7Hab5ZduydwpwuUx7j86+ djrcLWJo0e4himRCBMoZhySpxnB9KWC2tLm3Nvexjyml2yR7A64zycUlNARalJqVtdad5Dxz2VtA YVlEKqkUcZHlgr1JwTSO8mrq0sFyZIbvE0GxdmwKPmA79QTz9KsLdDa08QW++aaRrdpQEeQuzJL7 YzgfhXYLPa6dZ/antRfMIxLEhUyMCeAOOR1/CtKdvmWoO+p//9L+OGe4vLvVMWxd9r754BFmJM88 nGcD61uBPs90khYuHX5wFwF9q8yFrGzV2hNXliijhMO4qULSs3VTnoPYV5bry/a7UXOGEcm6NJHX bsI9M130Y2Zi0+e5xVnHZJcxiaWVdxCSNFIYhJz0b2r9Uf2X5muPDzaZHe/aNXSGO2uWeLdFJCAr QDI6MAvX261+1eCEvZ8c0fNM/L/GCFuDqzfRo/Yv9gqe10L49eHNT1i4uvsNxG1jam3YSw29wroy 7hnPzMEGPY96/v8AvhrdNefDnw7eiQrc3eho18ZRgsRHtyR7qFr7T6TEH9fwkn2f5v8A4B3fR7nG fBeIh15/w5V/wT//0/qr/gsXoknh7xnDrEVitxPd6nFDZvBAXdxL+7CHHOSqBeP7tfgVrNzYq9zH Z2hEsiAQ+SmyO3Ixuyo4xnNf6KeA9Z1eBKF+ja+5I/iPxOw0cJxViUvtPm+9szIbq506zKu80010 fIliS38xIIwQ4Jbscgfl1qGXUrib7Pbx6Zu89xAJ40Cx/KOGc/pn1r9zjsj8tqOzuyzKkVpbyOIJ ftkMo3KpDWzKPvc9/wAKoaprl3qDJFGuIraMDGzkD61vD4TCcvuF0KHTZRPJq4eORgUskD7QxHc+ 3+FUJYZvtv2fTC89wsbGW0QeajKSAGC49q3hsYua6H//1PyOC3BfyzbPF5ACyb4doQjgg8fhzWnY 3AtmewuLVZhkXUUsfHlj0B9T6V/swf5gN3dx8+u2P2t47Kzlt0G1ZPOdTJOxHzYwPXNWXUS2RFpA Gt2k/eo4y46nH45/KiwjNjtzdLNIbeO3VmaNQ0ZCxjkfLn0+vYc1EHfwzYi2stKVnvoTBHezDzHm G75mUkcHtkUmk9xNpbjVikkgSSWNQxI81GGcex+uK1LueeKOC+s5LaOZj5PlRPiYYGCWHpzxTMXq 7n//1fyOSd4nT7bBBJlThbld8fOQGHPY859RV62uEuLGTRobWSa9hL3ZljP7sRtjqMZ+XAxzjmv9 mD/Le+ljMtZbqC8t98RljV9r+aCIwPf+ddhcwJp0kOuRRg2yjFwxUyIvOQCBknNAFKKLUdQ+0Xls FjeIG+kiJMbQoCMhhjoc9PesjUNTtfMhh+wW0LyuI447fcQx45IJPU0AdCulX0iyLBZkxmNVnhEe WL5yD+Ht61k3N40ECWUkITe/ltNG5VgOmCPTGaBN2V2f/9b8rDBbGS1t1vBNEVVi+7GCR90/T3qw 1lHazXYj2OxzGWGCJB9fxr/Zg/ysqaor6XoF5supoozvUNcFlYkKgAyPb6Ut3bC0sDc280UjzDD7 DvKEHGG9OvWg5JfEyHT7SO+Fv9rkVHeUq4i+bygMHdj0Gf0NbcbpGnkmdbgK2xFY/MAOn0x6UElS 6tDqc0sNiiB4Id1wpb5VVfvuD/Qe1Edva2FpHa7Fijlm85ZckSSsOoJz09qAP//X/MdLONrdPMtF MfmmdJnyobOAQD6fSobWfTYp7lbezEk0S7WhmLGA7gff2r/Zg/yfjLqh+kW8stxJbQAxSncwx+7C Lgk/gBUaXcPlm3Ty3ZJiFeFAryN0IJ6/h2oNoO6Kul6ne2+put1uV4laQJcAkTHsCT7ZqO/R3T7X bwycXCQL5R3eZv8A4sDsOcntiqirsTmlsbKXcmjNbWmo2vE0aXLSpIpYRyAFSOvOD+HQ1Le6ROjP qNtf3V/psLCe3tYwvn28e4EbiD6nnpWxMZe9dn//0Pzldbi7KyW06xwi3zNGWA34H3j7/wCNcdFH qV/qr2sBa4DSAKyLnK9/yGa/2gP8oZO7Nk6DPbr9mgR7e9vpNsXmDEpOQCyj3GcfSs7Uro6T5dzO jXsOnMI5opCXH3gp3Dvz1H1oIbsjakDWT2as7zpcIt35IX7M0SOAwAz7e1Z32Jork3UZCrM+4P5m 5wem324wAKqHxaGLd3cla4dJpIzaXMn7rfJKq5hOM5yfpWFZ3BvbxyqFFLnaGOAi89T9BWxEvhP/ 0fzORoox5MwjERJKuOpJ60260hZrIT2EiSx2bm4laWTy5ix4Gw5HT09K/wBqD/I8oWj63PDOktvF M5beJskSqg6Y5wfetBU1MQxRRsERpd/C4APQ49+lbxVlZmGzM+7g1i7f7ELqGNYWMwa6TdJJjooI GfzOK1rW0xat/aT+a2z9wFIIJz/F7deKZcX7rM7VJJrt9Ogt90A0beyw+XiJt/qfWrA1maPTjYRQ RrJNJmZxGol4HBDdRj29aFoZn//S/MXT5NSJmijjlVbgeU8rY7EHjPPOByK1z4O8U7ZtVls5Vhsu YmkdbaRgoyRhiM56ADOc1/twf5D8rloh9rdQGEPdweVMsbBY5Fy5JVgOPris3R7e8EENxqkxNxMg Em1PKt4wPugDscHn3oE9mdHb3NvHK1taW7z3SgSqyfOz88nHTivZPCwKJEZ3RyGw0bjeo92HTH+F XBaNHm1l+9jI/pc/4I6a1PdaZHFaxXKwWzS200kikJKA4O+InqnPH0Nfu38W7I3fgbX4WiEkD6Rc LIznaQPLYn8cCv8ALbxph7HxRqJfzr8z/UzhObxPhRh5f9ObfdE//9PlP2rJ9Og+O/xLsbUm2ih8 QAyQqoIw0KAEc8DCjIHcGvmNQ7u8VtHuUsxSXb8+3tn8ulf7W8Cvm4Sy6/8Az6h/6Sj/ABN4wSjx Fi7be0l+DM+dZbaRJGjSZYzmIsg4IxVi3uoLxd4gWK6D8kfLGw/vD/69fZnykn72hcuLGKSO4Vgn nOgA/wBo8cflW7pdpcwaW8zCBDt8sWrXP7zIAG8jnqCf88VpTXUlu5zrSyfbnSEG3gtYQznzARLn GTjsMkDFX7oWk4W7im+z3UNsp2XEylLnJGSFPPqf61qld2JbUT//1PjG4DXBlmdS0kahfkPTjjHP Sr1hqQ021zIibLZi5edQY49314z1r/e6MVE/wYbuX7c20Mcmpx3yXrXCk7NuIbcnkhgQM46f1rlj cwpetMsaGSU9IvuenTp6VRzvexdM1xZ+fBArQ+cN0zS8efu5IHPOKzIkSM5iQw5PG0YGaqK95Gcp W0Rp3hmvrSCC+uHk+yvvggcblbPU/UYH51lywSTvCyxeWc+WmCenQ1sYSdlY/9X4pdo7NMYy44cd c1kSTB5D5inZKMqd2NpHTiv9+D/n+btqzagsW+z+eDGsceeGPzOeP8f0qQWbxpblvKUzMzRyZHGA M7j/AE96DOUr6IS9lu7aFVUlnuXCJsbbvOQOtZsss63EP2gyrCJBHOV5MY7kjv06VUY3INO4uZtS lkupJo2igjWKG0jhS2aRVXCngdflGc560mmD7QqrdBredmBhiYgoBzkN79OlaRVgP//W+Mr0AXE1 hMXQquUlhwybscDPv/WoUdYlwyYkjAj2tyZPciv+gA/599iO4KvAz2+zerAMj5xg9ePpVW3KiQq8 ixKOmRnNVGN3qaqa6kl8kuwGOEzR7d7yxgbYACFBfvySAKsKt3e20UUeY2jXM2PvSdcFvbmnGN9y 9L2M4W0cBLStloxywHU+ldPaTC4gEgk8uUqVVjwpIHGfrWqVtEJuyuf/1/jaaOOOLN0fMvJ8MhJO 2Men4+9ZsttNGzyt5fzfcQcYr/oIP+fcrLAzDdMmwsfl25OaXzooVctGXI+XpyaLW2Ae0AjEV4kU 0ks58tCB+6UcH1/zxTp5VuLSeW4cGaECOG3OQ8xJ5A4xxjJzQZT3Krwx/ZliMaukkWxsEjbkYPQ5 4qtBaQ2kcMMDHCjG1my3+f8AGqi0nqEZcqsz/9D4fmneCEIN7biFMa9Bk4zUkJ05l8q5lYX7c20O MgqMFix9vSv+hBa7H/Po5pbC+Zd2qXLROk2/G1JVBWPAxgD09aLmaS4zdkGdngjicRx+XHbuMfd/ AYoM27u5K15I0WblXkdyApPRfrSxxWMksV3EPIuLbpvG4SEjBx7exoEZ14GlkKqWKhtxI4yf8/zq XyyIH8xMxggqw4K0Af/R+KjaW97YpiNGmVg8cnIJA7Y6ehzTobBFLqZoUdFBZC/zPnjC1/0IH/Pe VtgR5DGdu04K9apQEw3HmA8g7ge4oDY1JDOIFm2I6SPjlsHHeo47Ry86sqIgQErwdv8AnIoM1N9R 1tYogleRcpGN4w+xm44qNWTyVnZdnQlDgkexq1Kysy4u6P/S+HHldriP7ODuYZyBhVAxnmp2jhh+ ZAWeTmQFixJ9RX/QpGSSP+emTTehEsasCSCfVelT28K+csZYoh6E8lazJSvoi1JFCjSRrI039xpO GFZdwzKRtyvv60nJLRm0U0rM2rLNwLWKaRGaSba21drKpIH4/wD1qu6jpsMdysSA+WoxuYgyg46m hySI9mz/0/iufT5YFZmZXj6jBzn2+tQtbW8FvHcEv5jDHlHoc9P8+9f9B6knof8APS4SQsMKRRo4 h8tp28x1RhhQeMnH06damEIMhaF/lb5SxHIpk26EapsuEFwzGKNgQU/jHv8ArUjSrdO5h+6jEYP3 vx963TuiXBEEsaLEXZGLhsBgeFJqkifaHaLyz5qKXD46juM/hTK0SP/U+FxbybDLuAAO0BuP0q9a W4gkS9YHcPlEhGQuRjFf9DB/zyQ6saAHUKzL5+8hSBhcdiahkMdtKAXWRjwxTkVcZW0ZZo25tHgc yGQSs/yiMdV78+tZItnRlVzlN3A74qudE82tie4hSJoyynLcLx8vc4qXHmRqsMaiRVJcp3A5Ofpg 1XMluNtI/9X4WgVAG87AbfhT0z6VbKSICFBPGcYJGPWv+h1Tuj/nnHxOseQARkc8cUjWjlfNID7u gHUVkXDcoSWpE27swA8sdFxWjHbsUXkDtjGKV0jWxKkaW3yXCEOfm2txuH0/CpEuzLNtlt4BARtH lRiNwBwORT1WwH//1viOeyDSswB2dlJzRH8u1CoUDtjBr/oYP+e1xW49UjnDMoyqNjHTmobmM5SO JsZ5IAwRQZySWxIszFY7OZshT8obtn3qldQSoXzsNuThRjPP+cVrGd9GSOEbGMLwqqvGeBxVbyZe GKMVBwCB8tX5Af/X+HGgnVVy21FG8CPndx0qNG3sigBJBkCQDa/zcMN3XBwOK/6H7q1z/nnHovlf Kg3FONxOR+FRTrvAYblkzxgcE0wJIFk2jzAPMI+b+tO8nBbg8+goAgjtS7nLcjkVK0CoB8xDZ59q NgP/0PiaGFUXcoBd1wWxjcKrrBb3E6W5YCR3wCehr/okU+5/zzXRDdWaWtw6Rn5V4Y9jiq5keJ0U E/NwMd6OfQd09h8pO5VG1SCDyOvrUos4pxtifmM72CNjpQp9wK1wsKTIAGLAdVGQCPWlQzNDIsi7 kdw/zDLKR6fnVp32A//R+EWdYyhCknHORik2yTkk/Ii/e9vpX/RLzo/55wRAzgEEqDgE96tiFEyy KDjtjBoU11JlLlHyIGt5ZOj45z94VDDEZIUYgjcobB60+eJDm3sBt53UlNuc4/DPNMEbtNEzSuI4 z+9jGMOPSqE5N6H/0vhO4iczNPCVUkFeMDAPH8qasHl43khupzwK/wCig/54LvYVpR8kQPQ9aSRp EmJXL+Zy+D8uelHkLyLqREQ53qOfmB6irtldLaGMKqyqH3vFKN8TH3WkncDa1TVbbUEtILS2htZB D9nYFAsCcnlfrn/PfnvswJaNl2lQQzK2VJFMD//T+H/J8vgHvtHGajuVVvKHlN5qfMJl4x7da/6J W1GVz/nfJI9NlZGJdQGGWyQGrPMDxMYY3Zxn8KiTuwLMSrJA8ZAzG2DnvT4FhtFaSUSOC2SEPKjo eKkCxHDLch2U8HlFPG0U6O1lRJg7qFP3UxjBpN2DY//U+LIoMRLG5Dt16YB5q9c2b2dtHcXtu4Sd d1sg+V5AOdwHp0/Ov+h1ztoj/ne8im7efCr7WA6qh61WW3jbAd3Q7t25CVKYP/1qFNW1GHlztIVg O/0LHHT/APVTkjOD552sONgpc+oXSVxzxokXyhht7+pqn5JdUD5/vZxRz+QH/9X4baJpJVC5OBtj 7AVNYxAl4psgjjfjcCfev+htzfQ/53y42iz3Tma3uUjS1t2lnjfCrLyoUIfXrx7VQQCVpY/3ivAc SbhgHgf41ADYYXhlmJk3RvjykIwUwOee+aSZ5kQKp3Pn05FACiGRwjxRsk4U+Zno1R+ZcxMplJVl b5RgjbQB/9b4aCTXTP5YJVOXbBwATjJ/SpjbyR4VnwnXd1x9K/6GD/nfLoV7iMW8BIZVJB28HFRq ZbfYjESyqB+8xgHj07UAVwG89pG+ZiCDu5q/AYTJELiM+WG/e7BhyvcD361LmloaKHciWC0EhKSO hEpMYYfMV56n8qn3+cwRmZlUbVzwAKnnfQfIrn//1/iGaBZJNu8OF5+UdKRlMKfu8/N8rDHWv+hP nZ/zxNRTsxVBBVUbIX74q6m0BmVg67fmBo52aNXViNFimtWAQwsXJMeMDnvxVWKOWEYhD4VvvnnH 40uaREYtSJ5FnnjaYrnycZPALU77MJEMhwpVdwbuKk0P/9D4xm1GX7EIjBHcBG+QsMMh4BOfw6Vo 3ccGo6ZDKu1JYkClY0CBcdQa/wChA/56eZnMWrLZO5dBKGOCD1FSTbbh3kwWTOVTqE9s1nN9EbLV EMcbtkLlQOVU1YZrswSGEL5iru8t225x1/8A1Cs9jaL91Gvpq6dcrNcyJIH+z+VGJhyG9fw/yazr wwxxbDjMkg3OQM+gCms4ybdh8sex/9H4lt9MWRJLqEMSmIyR68kA/katWSLBI00y7owdjbuint/n 2r/oDcnc/wCfe1h12k0xeVciAdGPRR71lxyLEWD7tjSYjl6B/XH+e1Cm+pMldWRq7DcW8j+YRCjb Rzjc3sPWs+MJHFLCQCZAFy43Nwc9ev5VopJmclZkymJ4gAQksZwHbpUZCmZUDKzsdpIPX3pg00tT /9L4tu9KGnFLmEtIz/LvUY8sH1qurXIcKP8AVMpO4YyD71/0Dtpbn/PhZ7FUJK7vCEXj5ssgLZHv j9KS2sriGYvvZRICpxxwRyP/AK1Q56WQJXdjQKNbOsykbgePlq0jvJuuC2JcY3bR/L8KzGo30KcN n5M0VwY0LiTcDKu9QT0JFOkDb8hdxzy2M0bEaXP/0/jW3Nsnzwk+aMOVZAQCPSq08okMjlSeCQFA G4/Sv+gA/wCe1xjuZ8MpZMyoYt3G1vvD64olMkx8pi6pkZCHDY9jTi7O5iWICMMpdsAbEyMYA4FL bhYQ8Uy+dhxKGlUcYORjj1xVSaew02thrybZw7IXRDkKR8tQzzTTRM0V0kTq2I4STvYk/wAIAqC+ fTzP/9T4sikEESJcwpLt+9uGM1BdySzy5jjRSFACIuMADA4+gr/oAP8AntUkyCFXkGxzsZztRfU+ n6VObfyl3SMAo4OcCgouNYaLLpl00Mt4NTKAqyyhIoxkAn7vucAGsi0SQhFZCzKdhkYAk47mgzn0 JGs44nmOQjsxOAOvv+lPF7FZwxxCEtIzlZJN3ygHoSKAp9T/1fiPMKgzPGXLjau07cHH9KRGRD5r uYyBlS3H0r/oAP8AnvHTTJtVGBWUHO4nhx7CluJodqNFGcgYc5GG/CgCxbzOiOQYyJFxskjDBffB qg8EPlSoJNjBgRGec5yCQR9KCoy5SN7KUWrNGQwRcsM4c/T9KZbKssMYQNGVbYRt257c0Dc3sj// 1viaSNI8AxAMeBJnBH4VNHb+UC2AxA3Egg5BGa/36n8R/wA+CbiVVsklm8/zt0I5ZcYdvYHpxT4V Rcr8yLnqPvCpNyB/tMUvkPLJ9mmcbQFPTOMkDrz/ADq3G7RzQ2iAvCZNoZk459cc1EtEap3lcfeR aZDcyy+XELp1WNvJVgjbeM8+tXrGKC4nCyiOBjEMK8bKGyBtOADjPXNZFn//1/iC7AYsLZWfySd4 U/Jwcda0LW/+zRotvbq0v8QZsEH/AHq/3wP8AE2tid5nkjK3WyOVXJaINvCH61m3Uy3LWVus7wxW 83mu6DJkB6r9OBQQ5Jbk85MpQvM6268FBjLcd6Vx/o6C3GFGNoYZU4//AFUmrqxDm3sXr1Lqdbaa zt1QNiOaFpNrLx95PUE54/Ws3D7NsrEE9QylW59jz+dTyI0TTR//0PiC4ga2tXuxbySRIoE0qfL9 mDEAO3tzRpYjhliV980crgBQfmkJwBzX+9coW2P8A4PodBNZOJpJ0tvLUsFVdm0nA7iqqyTWVxa3 CpOrXE7QMqfc245J5/D8RUHQp20Z0MtjHfaWtz/xLYVSZzkzk3E235gWVjtBB4AUZyvvXO6Rp8M9 2/nzyxrICERBuyR0+g96iUb6lqSexNfadcWqiGKaR1BxuZ90g9yant4obGJFnlinmuV2ogOWU+h9 6yNXPTQ//9H41ga2AkSTeUWUhVAw+fr/AJ60ifZoE3G3kE6PlGWZkwPoDz+J71/u9Lm6H+CPPI17 ySfVtPadEUyWxzKBw5AGKo6ZC8jLAHO98gEHBXismmtwhK2hGJYs/Y3AikiYs0+0kEDPB+pqtBZS yzxTQyBY1fdOCCWI/wBn3pHTCVtGXphfQ3gkikZIEX/liCNqkYYEe/NWobOBoLho4nQood5ZMAFT 6DrUyTasjWE1c//S+R5LAFI2ikBiAUjnDN6nH+etNmubx4o4orI3pmU26ypa/aHgA7Hj5TxjJ55r /dKSatc/wmuitZW00zIw8yGB5RbzMBuQfSv3v/4I9+H2vNcl8tpBHaarITLLGY2lRU27iOuQ2Ac9 6/FPHmfs/DjHen+Z/SH0YrS8TMKrbRf5x/4Y/ph8dzR2ngjUnuIxIIbRwVjXBO1G24H1H6V/EB+2 bf6cPjbrmoRWV090161lvHyQyIGYuZOwxgEeuTX8n/ROhN8SYia2sz+pfpYTj/YNKMt09PyPy2/a Eu7+Ww1m8t0tIFFiXh+xybZxuMaPGR3IVQPxNfk1fq5doJbfY0bFgh+Z4+/J719t9Lys/wCz8DTe 3N+jPF+inSUMrrz/AK6H/9P+UC4lbyvOhdk2vsIKct/gKzGuZlG3H7s9uoNcc+hrNaDILdbiVVhC hpXw7McL+NT3om07dA0al3UpjqPrXPNW1JjF3uYwgSNFabLsz/ORjjP92rbym2TEGJBnlm4b0rmm rO4TVitJExXznAORk7TnH1qGCTzP3aEtzkhjgge1QQf/1P5ENQhDNFI3ypAd2MY7YrPtp7K4uS0A lQwLmZX4jnweg/OvnzSmi9Lc/aJGUiOEoeVVs7R25PNSXNrBi1dZGN9E5lznayjGMCgzMuSYK121 xE43KFjIG5s8crTIJbq2uICsqr542xBmGWPfd2xx3p2srlwTubJ1KWSJ/PZcMfmgYfLx0Of89axb DT9Ot1uTby7W+0GaWJVwCZOuD+FI1P/V/kVjhVMKVJVvvnvim+XFMPKjVVRJCFB6ivnzqh8Q2Z/s +IjhcsA7MMYHekf7A8Zju5nhiiBmWSFNxYgHAYemaDVO7aMSVkY27B5YCBnYergZxke9X0uwo3ku McAjrxUy+E05vdsgeaZpRI8nLnODycdifT6VdmaSGzFwY5L+Z8ooiX7gzwPwAxWTWhbasf/W/j9u JVmQbFKlSvnR5y8ZPY/nVePR/tV3NFHKhcQmVftL+WjkAfLnpn2r5c9aXws15rO50kQpdLbiKVf3 sVsRJs9xihQzoZY0h8tcZRztfHsKCI7MuxRQDoiSBxh16hhjkGsfy7e2laO3to7dUbIVMhQPp2oJ Su7CTamYUzbDdG5DSrk7CRwPx61oLFBBLFewWyRiXaZkbKgsB1IPOf8ACg15Ve5//9f+RdZhdxuS hjUSlXYDK/nWJdmRZkWJxNCsnzuDnivlz1lFJ6EETkXPLqsZYKrj/ln2zXQXPmweUxXzdi4UPz5h 7Z9aCjHluJyZQ0ZDIm5hEpLk9cAdasWN/dWDbLhi1pPGHRZI+YyeSMdRnuPas5RbehrT2NptRS5I Z4zGuPljA+76YqWNipiEeEKNuJc4V/UGos0yz//Q/kukuLWS5kgtVaONwGDk/Pn+IfTNUrdfIvLu 2+1PenasoWYAGAHPTHuDXy59ARSWqySyGMKjvyzjgsR0zTVtpmlj8uSPajYdyc5I7CgC6ftM14kL ZkyAkWfuqP6VG7xy3UkM0S/u12g4BLkZBoIm2thtzBLI8SvGgtiwDbcgrjkE9u1TTKItzRjekY5J 6irjG5S1R//R/kTuYIjElygkllZsrGO4XrgVuW7yCFotjQ7YRI7P8pUEZGfrn9a+c5Ee+3ZXKwtD 9m/tBJoWZZzEYY5N8nH8RHYdK0rS4EsToyss4TfvIwMDtT5Utgi7rU0BFfW8umXPlw39nekhBFKP Ncjhk29dy5HB9RX6E/Aiyt5NPS5CKjy20cqM0ZWREIwUwemTtJ/3a/X/AATp341p37P8z8i8WpWy Pl7y/wAz9/P+CX+jm4+IN/FPI1w91cQyXAlRESC3TDJtYcnnHXnPHev62vFury2nw+vrtTHBN/Z5 hJT935cSqVXj3wv516vjbJ1PEOlD/D/l+h9f4awVLw5hJdmf/9LxX/goLrWoaj8cdevGe9g02/1C Syi/defHCsZPp93eCfyPpX4mftSxQ2/hbVrmOS1WKKaK2e7u0+e02ktuRATncASP9oCv9GsLH2Ph /SS6Un+EWfx5QX1jxEcn/wA/P1R+TuuT2MrzGG3Vt/zrIvCueMtXMWsxR289pNrDaqIMqPrX+fOZ vmxlV+b/ADP7KwulKMfI6HT2glnh8uL5lHzksTyO+K683UduHiYCRbhNjMU3GEnuvoeOtePUR03N PS9LdnJt7wPBtP7t0Hyk9Cx+gxXSWl7b2Kxr5UcaKdoZ0Hlls/3e/PrXlVgP/9P+RjwreQWtowtb hnaW5khu/n+YhsFV9wN34V62lhYTWNq9zdpZnzBGTvG1175HUY9ff8/j6rsz0Y7kdlptjp98fsMf mReblJpGMhkOeGyeuf61u3Kvp8iyqsCvKjN5UhCRqepI6A1zm0dkZ+jeIJL51ZYodguGj3LIHBCn BYDHtUusRQXMiFJZkS3ud7PAxje4HIKHPVeelYPcdjU0r7NbrcP9mSJoQrQyFwrBPUj8RVDUrpHe W8h2SzHlmVhmQgYHP5VLV9Coq5//1P47PNS0t5rlj5hRNygDqR2P1qDULi6uLWPVzc6ja/b4EspL aCLfDJjGFkIHQYHJ46V88lbRDqvl2NHTniRJLeeZ7Wb7NkQQjzDOTjg+mcH9axLLUtLfzx9p/e3D SC3ttm6QmM4KexJosiYu6IrdNRucyy232GFhlbVpA8gxnIJ6c4/Wrd7EJJI0gDW0kFmreQyeUw3d f5fpTKjuh0E1pHZWFlfveakIH3bioGGJ6ZHp64rr4J/Ni8i0fZPJIqJCRgkexrSC6m5//9X+POwt /EOkardXAgg8i4maOPNwrmQZ+YyL1HUgfXrUuozyrdxxRW5WVpMjZKPLj9zzyK82mtEdBneIJzb6 bcztbXMz2qh2S0TzzNkheMHjqK4e5juL3T7WaWYm2kjYCzZCr2zZyc/n29Pau+luZS0lc4pIIYb9 iA7rAAwDJlCQPT/PSv0g/ZAu4I1uL6ae4GrJMtz9gmtmjs54WiEKkt0G3fx9a/YvBqShxxhr+f5H 5t4uR5+CsTy+X5n7LfsltBo3xg8DaZJYhYtY8TwyX15FIzGBzhkO322EnH8K1/oG/Be9srr4Y+H7 uJXdJ9IhgVHB3FQmdxz7N+lfo30moJVsJNdF+rOX6OMubhbFQ8/0P//W/RT/AILJaDr0t1ZKksSQ WdxbX0cjTpbySGQSbWCkbiNykEfT1r+abQItVtLOcav9gW+urUG+McTK8L7tzLHuHQg4OM9Otf6E /R9nCpwHS5ekn+S/yP4s8XVOHFtdyL91MkmmRWOlTLaMLxZr+XdmW6jH34z6AjP6Vy5vmsNQV0lu PsYJiNqzh7ZM8bgpGc/Q1/QNOKtZn5HWtYdq8d2k0P8AZ7S3UF6yh4Wj2Jbtjn5vQDv61W1BktIB FpwS6AT/AE+V4TFPA46xp13DnO72FbRj9lHJJO2hgxX1pMjQ6hbTRWikTJcKcSq3cAdccfrXTQal pFvcQNocE+yBcyamxPml+DsbgdPp+ea6ErKxk01oz//X/Je01G5j1vVLua5zbXuwrActJ9394CD/ AHjzxU99dxsomtw6R5ICSLiRuenH0r/Zg/y+avozGgSHUp4nW3tg0IM6zXLGMcDnB9fT6Uk3iZbI m0sWFzK4LvbnICgcbyfbnHagai0tDpbW9uL3SkWa381VXzI1+8zd8R+2e9Zx1K5e5tI/7PmvpIMJ FEWy8eDwAOnUnP40Ezi3p1JdU07VRezsR5TCETyR4xt3AMQy9iM8jtVQk2pimaIylfmEYXO8/Sgx P//Q/Ie8ime6W4dDJE4wY1H3M8YwK27Zo9ORGCKjTxGGKQDErDGSue/0r/Zg/wAtpK6sVbZ55RPL JHuRASqkbWfrir0LNbxRzsxAaPc0LMSEJ5KnsaCYxad2UotdudM1GLULK2lu7hv3LW2zzba4U9Y5 V/unvSy201zenUvIgiuJzu8lIwkVtnnCL0GM4FBWtzolFmZ5I7iS6Mhth5UgOyMNjv7denPNYaRm 9SdjCkjhDHBG25WZs9iKBTV0f//R/JeWw1GOWa4jtdunW8capPghDJj5lPvxn8a3rTUZNWgtopdP aG73tC32OAmHaoJDOw7kY61/swf5Vz7Es2riKxnOl3cUnlKbeSBZgpYrwQT9e1Yax6gLVIniiRZg JmVHDMgPzDIHT6HBp2925yy+Jl6OFInjlUCN0i8s4yN3qTTkltrN3eYYEgGZz88eQegFIlEUtnaC 0nvIHuYVt5vLt0hJSJg5IAbv+HtT7NJp7GZrlRPHEu0Bz8/PpQB//9L8pV1C9EltDGVmjhXYgnkY i3XOchfxPFdPM0t0wubaNGkCANFFCIxLgY6Dp0r/AGYP8n0raIsxNIzw3c8LQsWH7mddjT4GSPpx zXOrYyrqMnk6c8sasbqOSKMmB2IyQD1OO/0oNILRkWqaleyyWc9vo5ldyIio3KYwP7wwfWuiSK6t 7c3T2ibgqxlEbalvlhkn14Bq4LUhqzsV9TXTL7y5tLP7yJ1g1GB423u5GS4PpjA49qWSIC6jktpJ 7aOG2Eb26ybo5MqN5Yejc8dga1M3K0rH/9P8vby5OUSKJFM7FIkL5+QHnH+BpsNrdLc+TZG4tTbq A0yIUZQy9Ae4IOOOOa/2gP8AJ5ySLsmm3jzSXMEsrXaAOzvIUTgAAKBwOmfxqxG+mz4glzvP30kx sdhyxJ+tFjKUkzSu5dP1Gzia7guU1C3lVIbkymT5cbFXAHToKzNNvEikuLa5tg+9wFck702k9PY/ 0rSCa1ZF13J0uDPcXEDQotu+SyITtQD68+vWqFvb2Rvfs0SmK2C4EgXgEdRgf54rQZ//1PzWTTrC GHzrmdpZlmIt0K4VAc8/hmlhgWOEw8us5OeeGB7V/tQf5HlqSCZ4HtbXK3bJtjEa5ZSBwMCmHVrB LOwt43uW1G0jMeqicq0DyDoYSOcEcnPc/jXQZSSuMsZLzxDqq2yWn2aISTXX7hN5mjVN2zcfu4wc VzcwDxtP9pmiSO4dBbmbOMEglgOvTIPSgg37B1ubdT/rBMwBlK7WmA4DGku9Ls1vLXT5xcJqFzKz WRhfbG4Vcnd/9c96aV9EB//V/NO1vVsJnVrd7iHO12WQocj+62Dir+r3st5a2sNjb3MMUkwZpLi8 MvIxgZwMDiv9uD/IOUuiKeqX9iL0aZeJPHq8Nuk8jiE+QQeAyyj5STjOB6+1P+0vcx/ZPMaSBDuC jA5IxmgTk3ojq9DsbvTrma3W2m+3PCElZwA3lSAMEUdjjr/vV6dZ2kitBFYgwSFUMjuN6yYYF/bn ke2a0p9Tmrrlsz+kf/gj7rMtu19Z7EP2R3g8guIfKR5DMMD0xKuPY1/Qb8TInuPAPiSGHczSaPOy LGN7kiN9oxX+XvjvT9l4o1P8Sf4n+n3h5W+seEWFn/06a+6Nj//Wwf2vPCUelfG/x5qVxHJ/xNrq 1dWZhG9sPJ8o5XPIZoc7scE4r5jgl/syd7aSBmk8kFVXrsYAhvxBzX+1Hh9WVfg/LqiVv3cV/wCA q36H+KHG1J0+IcZB7+0k/vdyOdruWJmhtHNsFJuHmXaIwO9W9IsoWgWWWAATZEUrDCMBx8p+o6j1 r7g+Nad0QXSpbNKzHEinbCgPPtRHNfILtLqONPLRRGnmkyyhgMkLjjGemT0rWnsKXT1KVlpdpdSu 19dyQxN/rZEQsYBkDcQOSOe1WLzSIXuyYl+3WNvcpYwX8KkMY2I+ZkPIHBPPTAq9iZ2P/9f4/lia zut9qQ0ONm9uhI9R+Aplm01w0kTkTSzz+a8RASJCO4HoOT3PJr/fBeZ/guJq8EcS/ZjK0bSOCIEO A+OpJ/pVG20i0W3lug7x3objLnAXAHT14NBg92JFD++RD5t3IqfITlyvtmqNzBeGUqrPEY5A3lOm EI74/KhaGEtWdFJHL9jtkmLQrKOJggbJHasKe8uEmitolBO8KGxgjPcV0HM9z//Q+Oo9NspXMNxc GO4UZmDLlcjtn19uaxr+2sT5RAeZo3+Qs2NgHA4r/fg/5+59DUtb+AWjxPaOxIxvDkbce2KzbFLi SWVZBK8QyyEKdqD/ABppXdjMupZfaNyM7mRG3RPIeIj2/p+VV5oQHjDykIG/flV3bsen1rdJLYCV bW1edrmKEwSEBWAbIlA6HHTPFRXDeRdQSSN+6L4ZW4LDuM9qDJyd7I//0fioiWS5VLW3nuDLukZ0 Bc26ptxu+ucfhU02nzki7kkCeYShRgQy4Pp+fNf9AB/z5qeupQkH2cucggnB7A1HGiPGwCF5Nwbc pztHPH8q2h8KNCO2WM3SuWZlYgFZGPkrjtj9atahetHftHZuC0yKGMZwo4AIzRFNXKcmIYG8krId iyYDAHH+eauQ2rrb7YWO2Ufu3zlfzqiT/9L4fnS4hcrJI04QAFuoHsPp/SnTwXl8IliV33kARxH9 5gHngc//AFq/6CD/AJ9wvIWi8ieGZg0PBVSeeOc9sfWoofLeVDc/LFvG847d6LWDYludVt2l+xRX e63icpEqHacAnnb61HcSWUUPnq6yKsywbwMsu7gn296DBu7uPjERYxq2QSQjIOD71HNBFEQZm2FT lT3JFAt9j//T+H/JmvtrRS5kEqj5jtyARkZPqOK15rGKDy/MSNZpTkBSGkQZxgn8q/6DYppH/PeZ erZR444wVGP37MpVl7fL6/X2qW0nhigNqqud53luu/HQHt/+urAUsZFZMhGDY2MoD8VHLFJatAzR hmlYEhHUhVJ+8eePp1oE2luaElr5od4zGqJw8gOQf84rKfPzRx5kjH3s9KCedXP/1PiqzmVB5UrG MKPlwMikXdNM0VtB5rMxLSZ2iMD+Imv+hA/57XJJEFo+27ktZT+8EfmgEcMoODVsWcUjCZP4Tgoe 4z6UEOeliW9SGeJ41l2EKpVRwQVIPH5VhgOjFCXy3yjDYz60EGmLhIYvKKs20fvOMnHoKSXAjDQo fLcZRH60Af/V+Ioo3UjevHU4FSqqefCkYczM/wAoK5Ru+Cf8a/6ED/nnNWbTZGjvVVPKdYg6urYC cjOB34rFjtphl2ZmCcBsfMR0pSdkVD4kTOjxNvkBHyZHqM9Kqo0N2rAbm8s9V6KenNY30aNmtSU2 Eq/ZporoGL/WMqArJGQ3yjP4GtCOVppxM0jjDYIb+I+9Rze9yl8vuc39dT//1vje6FpcxlrYTwTR zMzB5t8Ei8DaFxwRzzmqJkFxClrPD+7t5xLFIucjGMj6e3+Nf9BDP+e9D0Bke58mKRI0OdjZII7Y +n9KljidIQVUEyEhFY7Sa0jLozKatIrussDNHMAsgHzYO4fTNRW748xB8rbuMd61Ta2IJlMhWS3l UZJBGevGcGooJ3gujEFHzoUyw9Rg81an3BrSx//X+J5gokMcqlNvO1Wz6elJLCHEeJW8rqyqe/Tk V/0L3Vrn/PLFWRYEdtYSwSIv2rj54mGMZ6iqrW8Mt3cTqnkI7AJbsS2wjrg0lNMonljm/drA5hZW +9GBuI6UqpP5w83MjKOpAGfeqIlZSSHgGTzEnb5WOQW6rxVKOERSbIZmjUN80jgsAM85xzz/AFoC eyZ//9D4smhjECyDym5+Xaw3jt0605JdqkISpK7XP94elf8AQwf88qd3YiDW8qyRpkSHp6e9PtkI UwtIRx8vfNBS02JFs33HHztnPuadLaylGDh02/eAyCP84rFu0jpas7EY0x51heIyO0a4ALEgLx1q f7HMLiOCKCWR2XLApxn2q1JXEf/R+P4rWWWRgIZP3Zw2QRUy3OnXE4Etui/Zl2o23YCfp3/Gv+hN ybP+e57MypdqTBrVUEJfLjOP0qvdPmTfEoRwM9OK1MCuBI/7yaEZbIBHUYyM/pTZLMvbq8Ujl/M2 tG3IA9RQtCZRuXmtIzaL9p3/ACDeNhIOR9DTVZ3hReRGfujbjFVJ3ego819T/9L4knzG6RjcWAwx zlWHGMCrMcSsuQuX9uCa/wChu65bH/PJzq9ikV2OVIIyelSb5AojiCNuPAZAWH444qVJqJolrZk9 six585suecelPlTG1ky6seAOa0jsjGTd2ioylJV3I69ywHAqs6yTyERxs/cqByaaethNu+h//9P4 kji3MrtkbBgKDgDtS+VFHI8qkrIvzRseQCORX/RAf875WdJ5gJJd3J5Yj7xpggZnUs27ZwO2KAJh BEMtKSccZHJX2p6QRRrvjGMdD/E31oNaaIZoidkieUrF9pDHk+vFSvBOXZy6Mo+7sTao/CrUmlYJ Sadj/9T4TmSdCiOu5m6NjAHvV9fLtUjMwLh3C7QOTmv+iA/55rq1x6rGTIR8o/gUCqcpW2BcsAN3 AJ4yelBi3dkjP5kasuQG6r0xzWjuiew3tshlt2VIkQEtcA5LMx6cH+YoEQiZnZCq/Lj5lHeiSMYk CIVEhwu7qKuF72A//9X4beMQ7VYnLZCk9GIqGWS5ZC048+ZTiNVXaSOxJNf9Ek29j/nfGxpmRTLF 8wx8nYdOK0hbKGeWYpAjJ5oibIEeATtzzWe2wEHmxySbFBwRgEDg1N5MaOWfKleNvT6/yq4Oz1E3 ZXESJJMq5IzyhB2nimR3Plq6xI0sqttZWOMdKqUrbGLbZ//W+IWugBzGWk/uAYpyu/HyE54xjpX/ AEQt3dz/AJ2VJolMyhXBQtLs2INxUJnuR3qikUsW52BAUZJxnNItTXUmHlBUkLECRcsGXbz71JBD u8wAblbgelRN20HGV5WLgzbou0/dGMDvzVmOM3KqdrEsPTGDU817XBtO6P/X+L4gcyQvlArFRkYY HinqiiQDAY7Cm6T5guRz1r/oY8j/AJ2ZO5NJFHAywpcpOFQSZXgjPY1WlkT5kC4yMcDOaBXY20n+ zuJNgcKfusPlb60TXSSXHnwxhWY5kA+ZQR6CgXkQ2dh51y++8dI35CSZZEPt7VLPE6yGJSGKcAju PUUGsNj/0PihbeRQXYHaoznFIl2sVnOVt2mlLYRk56dfxr/oXbsf875p6KLWaaCSWYo91bnzoZG2 Lb4YjnsOg/Oq9zpxhnlmUFBIQWGfvDsR+Apc6vYyk29DPXa5KoTvX7uf4qmtLaWXdKqNI6KZNgGW AXk8VW+xBEv26Rlu5o2hic/IsjfvGA4yR2ps7IZwWMjtJhcEdKBuTZ//0fi2GGS3aW2eCVHkUONw +R1IzkVCsLEsAcqvAXOOlf8AQwf87kHdaj0+0QzhFBQlfusMNinTCX7QqlP3e3d5gOCD6Y/z0rKU +iNYLUnkhht1iLMHebJKKCWXHrUL5cPvieHy5NoyMM4wDnHpz+lZ3WxtJWRsDAsIomt0KyHKzMn7 wc54/Ss6HzGmkjW3YRqflbcG3DHX271k52m0ilG8bn//0vjFTEkhKpgE7cHrmrf2NzI0ZjMmBuyg JQjGeD3xX/QbCSlFWP8AnkqrlnYoRxxteOyEJbxKyOuPmZhjH9avSTWKWzRw2n+kscu+/cCO2B6n 1zT5le1zTpcztrxqWYjHcDrSq7EKiEhSeSeB71W+wrEscaSTSwiSVIo0H77YTGxxzjp0qOCCVo2x Jv8AnIxnGR9PyoA//9P4oMTBHX9AOK1rKBrOwkkfEgmXKFTuVD0wfcf0r/oQP+ecwblAGjfyixkY Ar0B55+lbdrbI00do0Bt4mACTv8AdbJ5JPfHrWDd3ctTaVhZLeKN5Vtj5iqcBmwWPqR+tNjs4Lja WlkiZM7wFyx44xyKym7M3hLRINM0y5upjaxSRkKxMkjHYmBk/nW7d6QpspQbeIS48uIuCdjDow/K s6clo2bVItNxR//U+R9PsrmURwxQSySMhWSWIHy5HHX8fagWNybPfGsklt55aYNGcqV+XJ/HIr/o AbV2f8+6TtYz3MkSvEhJEvLIfugfSmXnlpbWtt5SeY5JyrbmyABwO2ajmXMaKGmo+a+jmsbDTks1 iNnueaeMbWuGJGC/0GAKprAbg4ReQcDjBqyHFp2YslqUUxjBY/e7VDEYrWT54CZXIEcwBJXAOR/L 8qrmkJruj//V+PFu99u0M+Wy2Vz1H1qmoLSMka9WG1V5r/oBbb3P+fcsSWptpgJGO8gMCvOfarOy J45JJlkCRgY8rAIPv1pBYz7FPPuAJmWOI/Krv91fyqtKs6XUlsvJRyvyncGIJHFS2nZBa0ZNGyum 3IjjnciQNEWcjJMQX+9xxVqzthBD9ueMyIMhFYZQgjGSemOaJfCzkju/kf/W+LDOILiTbGEVl+Vz 91c1TeQoD9eD1Ff7+xd7o/576y5Ul6FiNUkj+cZbt7VZmhhKqYSBMse1h1PGeas5yiTkHjMiD5QO N2DVuSQyRRiTh44xEAQBtAJOD+ZoAnSz3W3mySRDcMBS2GYY/rVSDT7S3j+0yTGN7fJRMdc9Mc+t AH//1/hxy9yS5cvk5AFTW0M5SdwjRtCv7xzwNvTr/Sv+gA/55yITmyxd48wwkMu6MSAEdODwa0JS X+Ug7HjEmW6jIBxj8aDTn0KYZHhMaFkySMgYbiiScwxxRxt5zkASMg6HpyKCG29xhilMgMxdl+82 OozUbxPdsYLTy0MQ+0TySDdhAQCe3cgfU0FQ3P/Q+JJIWbasCvsRVJDcnIA3dPfOPanE+bdb7hCk RRVOFyqkACv+gA/57yTUI0bZt2zCAYR1HTPv+NVLW5WJpo5bZ3Hl5RyDsU5NADreB3Kox2h+Qc/d 61I0GyOQAglclT0L0AUlErqpfcfLJVAM4XNWJbhLaxi/dO0wkPmFcHI4xj9amTaQm7K5/9H4mQzy xJNlGVZPL8lzlmyOCPpTbWO8a7KzK8EauVVHZSjjGc5zx9DX+/Ld9z/nui7ouh42Z1ClFLYwB8oq nITvbZBL9nhI8yYr8hPXGal6I6I6ofOFt44NRuHMKl/LiVuEkycAgd+la9pdQuIY44y0kbbn4+di fWsCloVZRDNPcJ5O15TnMgw0JB//AF1C88hu2lztPCll4U4AHH5UGyd0f//S+L5YIo1E7zvDHnfI gUYlHvVRSsqiWInyZSGRlOA5HQ1/vgf8/wCatvp5vrZ5hGWlEphBmYwQO2B1b2pE0mCBwkzjzYu0 bB4Sc/wsOopNpaGU3dmdcLIiSIse9ifmwen0NX7A24tiZt3mA4CegobS3IuluVJ7stuZphGI5Asa kkM45/Dj+tLMV3p5mfnG/eelMqL5Wf/T+LDJJfyLZN89vNLG0gABSTymVlDL0PTkHrk1d1QxRXPm JDGixOBEkSCMRdcYHtiv973sf8/6fVFpry5urIRlVcNuVpDENzBsdT36CqUemzRzWq791sXxJEGP moo64J6Z/GsDRT11NS/mBaVIVW2gDExxiNSx4CjLYzximaLbR2DW8c0uJpP3iTSNleT93PY+1Bon bVGt4jkEKJGo3XD/ADErwMAVk20MH2SCe5he6Nw/ktGo2soB/hbseOorGXxM059PM//U+RtX8uUx PZQQW6D5UjRuenQnueO9VTbOsULXClRgFmB34Ppmv94D/Ai7NKAQ20NxKqy3S7lMsKMFwvTg/XP+ NV57m2N4s1vbfYoYwNpDZYcc9KLdBxdnYaJY5GNyxVU3Y2kZeTHrUwnjifU3jSOO3uyhsgrEyWuB 84Prk5+nFZzSWx1Rl0ZLpd9E00scuwGSPYpbkk98frVq3W1tZLn55riSRgTufcuOm0Dt2rM1Tsz/ 1fli+WOK3ldHZJsqIIwNwxkZGB7fzqkH1PTp4ZbN2h5DzRKNpOQAS3rketf7qzelj/CBO2hvOE8u 2urVBticRvEo8tZD97IH9fev6Bf+CONheuou9Rt3jvme5nljaUbmzKpDHHAyA3Br8G+kJUUfDjFp +n4M/p76LdJz8SqLXSL/APSon9BPxfuDZfDzVpkdAF0mVszHGzZCzHn8K/hr/aQ143vxN8cxXNw1 3Z2uqRuvmoFeDMQ3D3+ZmwfQgV/NP0SoL+1cZUfRH9G/Sxm/7Nw8V1PzT/aTcWGl7LC1ElhdPBfW twdwLZjBdQ3fawYlT0OOlfkhqmrzXGpXdzHGEvvtcsMQx+4KAlefpivY+l7U/d4KHn+jF9FeNsmr P+t0f//W/k4lbybcJIdzvyVHQn2qmqHY8kqgIDyi547ZrgZ2OK5CvJeQQSpGwZYJTtZoxlhnqalt 51UorK06yApAWU8n0qJr3TMr6Rd6bFqSrrttOLeaVoLSOMeYN+cAntjqadrVmtlqPk2Uiz2j4kjd iV4zkjnniueXwiaT3JJmtzHHHE4GRsKjnJ9TWTPssyXkboMKy8ZPYCsSeRH/1/5Frq6ju7e3liJO xB5iFOJeOh9v8aS0toLiGIm3W1ePcVQch8nNfPm6VlZFK8iDORFFkZAkYLhjj3pHnjeYy3JOxUVC AAuAg2/yFBi01uWdShhlsop7Uxl0b5AXwCD1z+nWsraomhEiRuy4ZJEbJz/d+lBrFWWppXUUQiMj cPsyoHIyaqwW+EYtGI2f5jJjkUFH/9D+RqOUwQ7n2SkLypPX2rKkD3nnTWINu0eHELEjew6nNfPt pbnXBa3HoYHjnWViZyBITISV7AjPbpTGLSB0UQsojy2SCCOmKzc+xolYfq0cDRRNpcbzyqig+au3 a2BuGR2HOKbDG6QGOREWZiAPmBGfapcm9DaUUomREt0lxNbXHlyxknEwOWPoDWvHcm1hSI+ZFCDt Dxnnk+lT5BBdWf/R/kCtbKSBDCImCMxuGuJf9bPu7sfWonXdcWyrHuWJzvi3Z3/U/ma+XPYOgd0u 3lieONZDDtRnyWTHvWTDoF5EpnVprmLfmRi+5geMj6CgEkti9eO1qI1iiKcct1BP1rGlSa5LvCrs 0Yy7FflBNTze9Yzgldhp7vbFIygdVbcwPO38KsG5eW4WSSImNJCwJbasnBHTvwTUyk07Gh//0v5F JIjJbbbZysRyzhOF56g/jWXBBHBFIgwx3E5J4Oa+WWx7BFY3+n6ZHfTXGmG6ltWEkCSqRBcE9hgj PbpV/wC2Xt7FHf3tstvFNlrWCJ/M2ckc+nTHNMCKW6tYR9vdBlU2MpOxnI9u9N+1W88kRNu0mG38 HkfQUAWXluFbz5TuDrtVZPvIBwM/lTpZYVQod3nSjAjUE7/f8KLB5H//0/5CrJHjmB5HGN5/hHpW hNFDA/2sv5ZlTyZJPu8ZzXy9j313NBLZZijRsqLt+8zbVI9c0x0t4IfKghKKjlzLnAYH27YptWdi rO9i5GHkw0LAALw/Rjms+dFt1aVmCzZAUH7xzSFKPRkDXXmq0bvIuRg7eGX3FXI4oghj82RxtzGZ B976mrg0txxjfY//1P5KJIxEElwDt4UDkA47flWbHcLK0sN0ZG3gqrqdq5HTPtXz571RWViza2QC SW9syopG/Yvy7sc1asLu3SC4jSJZHdTCHdiGhIPJA98EUBBe6aukW0cNzbNNhYknWVIUXzJdwdWB jT1JA6ZJr9PvgjYCbQ4rqWG6ksltYrh5m/0e7jMkX7pWjIyPmzn6HvX7Z4G0ufjONukWfjHi3K2U RT/mP6Av+CSWj2t34/uJzZ3d/D5EYv7iOZozay+esmx8gjG1FP8AwLrX9SXxW8gfDbVVgtxvm0cy QRSyfvCI1DMC3bpn8K28YKiq+JFKC6KP5n3XAFN0vDpS6O/5f53P/9X5m/a11iy1j49+LLe7Goya PJqctlOLK6E5huVACCNcEcLjnvk1+Hf7T89tbeHNR0m5nnEdxcR2flsD5rqylSMYPzKWXI9DX+je OXsPD5X6Uf8A20/jzIpOp4hX6e0/X+rH5h3zpZwm2aRt0ShBGVzIAOOfeo9G23izIUMWI85devpX +eWNbdafqf2ZR0ijcsbf7Le2w3by5+fA4rvrQ2L3nlzMsMWzEshXftz7d68ubVzZdTQtZrWymW3t HP2OVtswiP3gvIHp+FUpv7SvJQfLQWJY+TlsSE5xgr9Oc/WvKrPUZ//W/kl8Laer2lklraLFILpm FxcDajEADHPBAIPJ9a6/UdHnS3hu7gWtxISyxzQSeY8GD0x2B/WvjK8kmenFO5vaZu+yRo0uZ5UG xiuDCcHt+VaGrTaheR2+mahZRobLm2vYB5s06MuTvYcYxjH865HJs0jsjnNO04aXfK1t+74YpEcK hJJJP55/OrWoyai92ltbJE6LAZWuQwYxsWHyfTGPxrFz7DNVtOjmc6jbgPfIqJKJJy0Rx0Gw8Y68 AVWbTr66S7/0ZT5SmaUWsnLp3O0gYx6VUZX0GnY//9f+QPWNMtX1F7Gwe8TS0hjnlurux8rLsPnR XBIypz7crXMzvfIYtPsNTuZrEBoXV8ASc9CBxxjtXgJ2HiIq+hY+wxQXEUmoXSCOGMSLFbsJHuSe iMR90j8+Kpx6Lo8N5bSJAB5cjXCqCVcMdxPPXueKRlA6O3vYjHOl3al5GkLW5T58Adj9a5u3ur65 uZZHtI4rgzMFEUv2iOFFztYkjkdOD600m3ZGhpWlnJI4mgmH2mNvOcPGpU7T83yHj8K1b2VBqEUs 5UtcKGbyoVtlRhxlVUAenIA6mtoq2iNFN3SP/9D+ROK2uIpWPlsRJwJSMpx0X64PasvWLeGG9juG QCe4BiUK/wDqlwMnGe5ArggtUkbt2VyvdWuLZQjTKGQo+w/60df8j2rzprjbvhmWVY0mYKrcM/PX Hp6V2UtzmqSd7o5ZRAb9oZrtYHuXMcLMPu54Bx7V+if7LDtZ6mY7K7eaOFILLWgsCXHlqyDY3lkd WZc57Y/P9W8JpShxrhWu/wCh8H4m0/acG4tPt+p+wX7OniWPQ/iL4ZfVpjNfa/4wthZGO2Je0V0M BdCOFwZCf+BHFf32/sv3Ul58KtAM0zTJpVmtlMCm1Aw6YPfgjnrX6t9JijJRwtZ9V+V/8zzvo3Th LhzF0OsX+f8Awx//0f1H/wCC7GniLwpHqsXlQXdulhcWc+1ySPtyJ29PNxjHRTX8t7yanqaQB1Je fhZ0URrJj+L05/rX+gP0ck3wFB3/AOXkvyR/GXjO7cY14LokINKv7OXyZxG+4Mxnjf8AdnaOme9c rrM04mt4baze4kkuFiOwEg54LE9gBzX9GU9j8brbI61ZHi0pr2YrLKJRbBIjlUOCTkduP5Vyn255 ZbpfMdWcDyIPLGOOGJatqe5gUdQ0+R5B5jOSVBzjqMdhWp4UuZNKg1SwnnjGnaqyMWuofL+z+W3G D1OeRnrWonFPc//S/Ii/itrPUNP1G21BZNOuiUmt57IrNHOGOxUYthgQAeR3qe3umu764RIUSFPl CM29Y84zz71/swf5gy+IdqNrNJMUjgSKDaqqIjjOAM5Huap28ca3VxJbQNEbZ2tys0ePOVkAJ6f7 RH4UFKaSOg0yfyYxFHcQKVzEiZBaLJzgDr78VYurWe2kJsLlWml4nl2fLg8kAkZH1oMqkuqMQ6jq tzMba0lhgdG+zzyzcq6t8rEH2FW7pbjTL6OynMF/DGMi6iPyTZ7L7e9Bgf/T/JWadba7xIbhFmQA ReUcfn6cVe3XrGwnaM3ENlL9ps1uIAIxyNwHqCRzzzzX+zB/ludHOlpJBpt3qeppGZ5Bai0giWG4 ZuqqqYxg56/WsjVrQLEI7YSbXuFRWfDbASAufzx+NACeVNoU9vfNGxwA8BEYZc9Oh4496BfR3E5V lMalsh8YJ9SKAHLJHF9rBkluwzYhEiBCuOBz+J/Oqw1fVYJodPl0qGHybI373UR8wgblCDI4+YNk Zx0oE3ZH/9T8w7XWFmtp7ad2aO7cNLasgMZI6Ee+an0S61GzvJru22WiJA0bQlBKo34UckdcEn8K /wBmD/KyfRnK6hpqLdyCwuLa4hD72WGJot7nlsdutb2nLFKlsJxDawIJPtMkcRa4kcDChznn7oHH TNPockviZUvJ7dDlFbC8Nnnd61Uuzb3MlutnLI9sjbltimMZUYLdvXpStYksq+pMj2V5bRPZKwub YhRG24cAHHX8elaUFxaWkM9lLDulcrLvDEeRxyuO+ePyoA//1fyoIsbyWf7HLLFeWrqQFhKiQN3Z vw7ZrutFt44IVvLq9RQh2S2zIRNM3qpxjHBzz6V/swf5QJ2uSare7mh2OkMfmD5mTcXB42+2Tjmq 0mux20wsoEWb7KuH8uQGKEkfMqHofqKDaPwofDqJvHt7uyga1jbKyQvjzM/dJb0zyakuZYLeWL7T cpDHcyLD++J8kFjgVtGPKtTKTuytqeiSaVqcccE2+01GNbuCOP8AfSJuBG1sc8HJ55ANV3tINH3E tPdT3cfmFHOEhbn+H056cVRyn//W/K6KVbiedGhmjntnwrbcKcgMCP0rS07UmWS4ae9mku5pUjSI R/JjkfNjv0r/AGgP8lzWa5uUZmgu4htUzTrKNqsB1UViXzhriCT7PEkUzhdoX5XY+p962gvdMZNt l67lmtXt1jinWLyvml8vMGR/CD64x+VWRHDJIZ7Zm4TcyEZLE9d1USJe3OpGBY7Syg3F13TSAqqD oc469aoQW2oLMY5Nstw75IgGVOTxjFBV5Wsf/9f81JLWe+QWpHlSrJiQNgPjkYHpyazzb3+nKI5H mEltIUWPGUxnrnP+c1/tTFXdj/I/Y0Ivtgs5rpdRe0SZTAxjfZfOepwTng5xx6GsiTSJLr+zotCm W4mSVn1RrxxGAm1mOGz97gYFbnOak4S1uLKa1a7ivrRcyiNjDHIcFcjB54znNZ1lp73bubcF5UnV 8uCsahm5J9+vHtQBulvJvvs+6KTZwXi4Qn0HArK1iGeS7S6jmeR4YiFQZ3xDuF/XNXBa3M5u2h// 0PzRt9SgFgQXU+biKRZEwy857jgjjkVoLJZ3kUUNtdNfR28YN1b7DB5J/iVSc5+v6V/twf4/cyMu +huM77y28i14FjcBvOcjuG4HTimadp7yLcPFeSKiyb3BG1SOxz26U0tGLnVzodE8+C8Fq17c6nJf zhLeDaZZMnAVVx6Yr27QdQB3WphZJbJgkuQVdSMce1aUldtGeIbaVz9+v+CQ2oWQ8R6ok10ss0d+ xaZ2BWR54onVGHUbAu38q/pm8WFk8Las0CEn+zJdvlDK/NGQMfiRX+Yv0hYuHifN/wB5fmf6aeFr U/CLCpbezf8A6Sf/0el/bz0oW/7RfiGEtLIw0eK4a8zvtskRuE9MhpW468Gvii4t2jlTUJC0ssgR LhrOPzGiwNoyg6DA/Kv9m/DKXNwPlr/6dr82f4s+IHu8UY1LpNr7rIrNcy3sTIxeW0jmx+7G3zAO xqneyy3r2cW+XbYxeTbRqPKSFcklQBjuSc+9fokdkfBTbumU7v7Ut9Fd7ZkiXaY47kCQOVAyckYI znjH1rZhEOoX8+p6rdSrMyAwW0GIoGb1K46ADp3ransQ5Nmd9nN3dtMbmcRqrRpDHhEb0J+npUNj 9rhupR5hAhl2bDwHHcGtIq7sS33P/9L4/wDJaN2judwWeUbEj+ZI/wAv88VqWmgand6jbXVgoaK2 kDBlf72BjDAdsV/vgf4JczbsjntVW+g1MLcwBpS5YeSCwG3BIAPPA/lUct3aODM8c0Uu3aqIPkPr u/KggNOv4jMscJOZPlDj+A//AFqvag08Kq0+2ZiTmThS2PYcd6qMb+hztNaFS1ijv7lAlwsTypgu 5PloRn/PTvWvHoebqRpbqJpYTtLQjeCcZ9scYP41sc5//9P4zmnWz1V4kjW6VCDiToeBnp71QvJT JOWkVNzHLCNQq/gB0r/fg/5/JrQsGVYogRtiAG4k962IZ7q2tFuTHEsM7D5CAspOM5A6gevbmqi7 MyMuG7ldpC25UL/If4PcCiSVTKEkQ7SMhwcqT781sZuT5b+YSubOZDKD8y74gOmD0qnerNfXEdyZ S52bFjwEjQD2H0FBlJ2Wh//U+ONPmW2lSR94eHKkgHEmR6VDe6q11PI0iDYvEaAYAPY1/wBAB/z2 Rbe5Quo1mgUqGD7dz+ntimafcrAkiyIyMVwrMPvVvFWSL22JkiWQFlZFjHzLkdaiaWWRGjNpbpL5 gaO527XCg/1GaZfOx2oLcosCbk2S4BZSGIHcgVtxhbfS0hsEhW0scktLIBdysxySwLE4+nAoFzyP /9X4x1YJGIUtZTK0sKyykxlFQnqoOecetUI7S4t7G5ngmX7cPnjheQ4mB4YA8gcdj61/0EH/AD48 0ivAuy0ht0h8kxReXs3FsY6c/TA/CoVhuC/lBdyup+ZhgIR2oJ8jQjsDCLe0NrBMQ73JmiiXzEJA 3Bm6kcdO2T6mpFtLa5JhddsKnLkcAgdaDGTd2i3LaLbbZLcRvZIdkTKcSDAGSw7VnzKt7wp34OOO c/Staa0Em1sf/9b4cs7mOUzRWkqMbeXyJgDkxMOoNaLuzkKw3bBywPJxX/Qgf89PNK9yrOWkBcqx 7MX5K8Uy3yCGBK7WBBHXj/JoE5O5oi8Ml3LdzRJPLJIXJkXKkn26VHeMJIWWOJY1Y5LqpLDPofSg RRiSaOIWzO6K+GJz1x061oLEEjZImA3D5ye+KAP/1/icosMKbmDzOx3L2A7f1pI42mUCF9o3fMvI JxX/AEIH/PPsWbgTRxRKCivEjJ5ipiQq2cgt1PfGfWoFme3C7SZATywHC5oE3ZXK8/myXB8tdpxn dipYoIpHjeScKVPAPAY+9BHP5Gq8EUKSSsEZyMBuox7VlLKzFj95VPyAcCgtO6uf/9D4m8x8ttYK SvBPRTUUVxKbTynEsN4GKGdB5fmAjqvsf61/0IH/ADzlo3dxFAlvJLIVdBGMklsL0GasQLdXAe3h lUAr8rTn7mO2QKie1iofEjU0PS9T8RFNO+yp9o85rW2ZQyy3rJk4VT1zg4+legN8NtftraS3l0ea 2jt1EgdLGQRbmxkSsEzkBff+deJjM7yzAVY0MZWjCT2Umlf7z6DC5Bm+PoyxWDw85046Nxi2k97a HLT6NJaLdW2AXRhA5SN1ReFfC5Az1AOOhBpfD/hLUNQuArQyBZZTDaAoW85gAWwBknHPStnjKUZO tKS5bb9LaO9/Qwp4KtUToQi3O6Vut3dWt3vpY//R+ftQ+HOu2DXMs+mahaWgi8y3a4sZi8xHUjau NvXriuWfRTDZWssk9vPLKzCeK2SRUtyuPlbco+b1A6V/vnhc2wGYRcsFWjNLfladvWz0P8A8dlGP y2ShjqMqbeykmr+l9zPELqs+chQMLxgGnadpcU1wk92vnCCFpIIw+0Kcda9CNS61PNnFKQ6a0tJI 2kuJxHLIWIVQXOVBIB9AeBXPz7ZgD5TRAjZyvlkY4z+lb87SMHHWyHwxW7kptl+0jCxymUBG/Cku EUyx27IY5mIQPtyAx6c1XtPImzSuf//S+JjYXUT+XIPMdeHKfMG9xUpCQoGTKxpzM7/dH0r/AKDu ZWP+elRurkmA22RcO2eOOBjNPmtWuQm7IcPuZwMEmo9or2NYUurNu2tId6K29ihXaVXcZGJAC4Hr mus1rwjrGlqbuXRdTWAwiWedrKQW8WF3H5iAMY54yPc1VTG4TDShTxNWMZS0im0nJ9lfd7aLuSsJ ia6nOjTcow1k0m0k+raWmz3OAkAu40ntlZoJRuSTaQrVCtsyjkfN2960UveJ5LxP/9P4neIkFQw8 wHJzwtOVvLlEUiqd42k9QM1/0LKaP+eayQ028dqxMe071K4H8OKXToiIZczM7tIzh35AH90U009i nFpXZ0+h6Df6uj2tnDc3F/cSrBp9raQ7nmIxkKPYfzr2zwp8HfiHbyyyHwtrCCZAn2u+sZXhtxjJ Z1VWIHTjGelfKZ5xTk+Q1fZZlWUG1dXvr6dPxPtcl4Oz3iCgsTldBzgnyt6WTsnr12fZlyT4IeMY L9/sukavcJLH5aR2+hXUUUpzlmDtGFCjGK2L/wCCHjxUZ4PDWqy30cSrbNb6XOtqxAG5JG2ZyBnk V80vE/hNpS+sW/r1Z9EvCfjHncPqr0X9dD//1ODm+EnxCW38yfwRr1qxkNrNKLJmgGRnOeuDzzXj XiHwvJo94YLyFoJIiY3XptbPIP5dO1f7z5PxdkufVZUMsrKc4q7Xl3+9n+DGfcH53w7RjXzWi4Rk +VPpfXT7kcfcQNbsFhYEE/UCj7K0sojTLO/3v9n3/Svq1N2PlZQVyaKMWZ2sXYLkD361BK7KV8sc N0x/DVKfRmbjbYiedokWOWTBZwiu4wCSeBWultJcKkcIZ5ohmRUTcgAPLcdAM1TmugRi22j/1fEN O+DPjTxFp8NzoXh/UtXVJiLi9s7eV7O3wvKM3l7SQeOGPQ1yuvfD7xR4dRW1LTrmydiyhpreSOAF GCkeYV27uQdpOTziv98sPxfw9i8c8tw2Ki66bXL1uu3R+WuvQ/wMzDgviTK8LHH4/CyhSaUlJ9n3 S1Xz2ONntZV3THZK9k6xXUcZ+aNnAYbh2yCPwIpLc73k2wBMkGMZ6DvXvRm+Reh4Sp/vEemeG/hh 4w8TyIdD8Ia5q6yQpPFcWFg1zFMjHBOR93HX5sZr0zTf2efH0sdwLnwT4nge1R5JGl0toraEcdXK 4LDBPXgGvj808ROFslrPB47Er20XZxWr/wAvXX8T63AeHnFObwjicHhJexnqpvRP9demh4Lr+gXu ha3Npl9DLDJbuwuEnURScHACA/eBwfmHTHSufEZil8tcIHbJfGMA/wCTX1+GxlHF0YYqhK9OcVKL 7p6p99UfH18JUw1Wphq6tUg3GS7NOzWmm5//1vjCeNm+WGNgvQNj9SajMLKgjmHzkcMtf9DCm2tz /nl5EmISYIF8xzKGk2iHaflHr6VNBArbmBwvTae/+cU1N2uHItrDzZcqjAZk5UE9PrVWaCMF4Ypm LBx935lPrUupZbm1GHY9b8F/BrxV4zW4k0nw/qepTW0am1jgt23SFkWTzMYwUIZehOc+1eh/8Mvf GO3try/PgXXpLe2txJJbNpM8Vw7cAqg2kYxz+H5fEZx4k8LZBjHl+YV/3kbXSs7Pt8S1/wCGPu8o 8MeLM+wf9pYHD/undpy5ldd1o9H08tdj/9f5f8V+F9V8O362Wr6VcaXO8e9ba9jaKeMjggqwB65x x2rigtrK7LNdxRyx8iJs7/TjAr/oTwGPwuZYWGNwU1OlNXjJbNf103T0Z/z3Y3B4jAV6mDxUHGrB 2knumuhntKiTNtzjoGIq2fszoEmTJY4346Gu04Cn5KWXKu0kUj8F+dueABV8MgVtoO31I70CTvsS wwBsSA5K/wAK8Ct+z0XVtVEEVnYXM01y3l2ccVtJM1wwIBVdoP8Ae6nA688VhiMXQwVGeJxElGEV dt7JHThcJicbXhhcHBzqSdklu2f/0PC/Gvwq8Q+BtO0y68VaDfadDdyrHDcXdkwiV2XdgPjA6H/v k+lebX9taQyYhdJVKjZKowORkj8K/wCgzLc7y7OsIsdldZVKV2rrut01o0/XpZ7M/wCfHMMpzHJ8 ZLAZpSdOqlez7PZ9mvT0MV4fIfzFJYMPmVuQKe/lXceJgZAMcdjjnFehGdzgcLK7CTyhkpCRtGU4 +bP+RSmFpIRMwZsL86gfdqk7toza0E8tGt8LlZQ2VOeAPpWnpyaRFaXX26Od7+YbLVoWCpER0Lfj VGLVj//R+J7i3lhjM20ybCAzKmcZ4GfSprb/AFRL/KzDOMcmv+iA/wCdcqyOm8MBkg7TxyasM75O QohAG7kbjn1FAETxCXIDDaT8oxzWzp1rFLd2OnKz/ar6XybdFjaVpGAzgKoJ6AmsK/ux5jfDxc60 Yo+ovCf7Ifxj8YpBrGneDddfS0hL7DpNyDf71BiZG8vAHc9etegaf+xB8fms1Q/DDxRbXjs0ktzd Wrra2205G0+XyMD2r8izHxp4My/ETwvtHKcXb7KWnnzX/D5H7HgPA7jbFqnOpSjBSSet21fo7Rtf 528+p//S8c+Ifwp8Y+BdQltfHGi3uh3Vxe/ZrSS8sJbVbx+NzLlen19DXi1wo3OtvyoYDJ9jg/yN f795NnuA4gwUMzyufNRktH1T6p9muv3q6sz/AJ9M6yPG5BmFXK8yhy1qbs1+TXk1qvyRBDGZGcvh HzgepFWbazmkRlYDcJDyecjPX8q9bmex4qimy6NMlbcltE8zKN8qBdzKo6tj0FVPsqpIAAAG4b0N VGdtwcVZDDA8TsnTDcsegr3T4V/s8fFP4zf6R4A8Ianrent+7j1O2w0M7of3iqMZwMEEn/69ePnv EGXcOZfUzXNJ8tGNu13forta9d9rnv5Bw7mfEuYQyjJ4c1aV2t9Eursm1223aP/T5r4r/swfF34T 6SNQ8a/D7X9D0yCFHn1JbY3Vq5c4UEfeAz14x+Rr5fe1FoGW12lDkEBQVyw5/nX+9/D3FmT8V4BY /J6nNFOzWl07dUm9+jvZ+qaX+APEHC+b8LZlLK84p8tS11vZryv26p6r0sReQ0URKjDOMEAc1CFn RCh3scbQOTtzXvqV3Y+ckrJoabOWEZaEEt0/+vV9dNBRCsxjfHO1unrVehlZXSRC6yIdocSBDg8Y yB3FVmQT7TFgsTx2HFVzyFax/9T5Atb2/jFwk0UbRyQ/Z0Zly0eBjIP04rKe1ntz5s7FFlf9yR0Y Zx/MV/0Itt7n/Owm4vQ6q1tYb6JFuJo4JkTAmLgcKO+evTp78VkS2c322S3Eqzwq/wC6kjUjcvqR Ut2Vzph8SJxYj7VCruSu4AsOFjHuT/nmvo34dfs++Pvilp11J4J8Gat4jeCYJPcWNqWMKhQ4Me7C vkHJ2npivnc/z/AcOYF5jmUrU07ed2fYcNcK5nxbmP8AZeUwvU5XLW9kl9/VpfP5nlfi7wPr3gnW 49C8WaXq2g6hEzySWupWRTZEknkgnBO3LkDr3Fcu8NrbXEkXmgfeC7erNyF/XFaZdmeFzTDwx+Cm p0pq8ZLZrVdfuPOx2X18uq1MFi4ONWErST6PTtof/9Xmfgn+y78QPjX/AKX4O8H6n4gRCY5pbUk2 ilZNp2yAMGbgnHSvpg/8E1P2sLOP7Svw61jetyXQz6LJ5JtxkKiFG4bBHLDt2r/abiTxi4d4Wzae TYvWpDezS17bPbr56eZ/ilkHgrxJxPkcOIMI0qc72TTei67q1+i7a36HyL8Yfgx4w+Gd4LPxd4cv 9BvEuXiYTWRghlYYDbmI68D6HivCxZCJ95AxnGD2r9FyHPsFxFllPNsulelNabXWttbdf0aPzHPM ixvDuZVcozGNqkHr2fmr2/4e5HMsX2lI5kOwLmQphSAfSoJYZHD+SgkRB8mMA17Km3oeU6XUs6ZH ABJFfl1WZNilOkZ9/alulsoyGsWbAOyVeoJHGa2i3exzn//W+PbeAzK7pNEqx5LK65dz6A9vxqK1 uLq1eaHG6Cdz+7cfJnpx+Ff9BLk3oz/nmexHe2+2APJIqlidkYPIx7UljvLB2mckJ5eNx2r+FIa1 LEcMwvBEFZ4WBYyoPlj5A5/MVZlieC4e1mPlndhpl7Dpn8Oaynua05LRH1P8Dv2b/iT8YLqw0z4c +GdZ8SxT+ZNc6hZ6RJcJGwVdoEwXGDnpntmvsG2/4JcftSTxQXGpfCvxAojYjzIbkIWYZ+9FsY9B npX4Lxn40ZNwjmdTKJ2dWG7bsk+qtvp6o/oPhLwTzzivLqecxfLSqbJK7a6a7a7210P/1/qO3/4J e/tbR+bFYfDm4VFmLxm4tHhiKEfeIUBsjjqM1euv+CZH7XVrpUmoXHwwjuLa2zJd2sCzLPMgPLKp jI9+c1/qv/xMjkVX2fJyrVX969/TXTr36H+UNH6NXEEFWdVSdk7e6015vTW3y6n54fET4Q+L/h1r d7onjLRLzw9fQTSLBBeIA95GhOdpHRlxyDg4OcCvILiIM0clqrv8+2BCp89iOvy9fWv6IybN8Nne W0c0wUr06iTX6p+ad0+nZn875nlGMyXMq2V46NqlNtP9H6NWf5iILiNZzJbxg3S+WSY9pjwwPHof l/nS2Fu8V3Esgwsj7enTPAOK9hT0PIcPeJ73Tpo7mePCByxaIK2Sy+tXfD+kRXzSLeXCQpCdxO0Z Oc8Z/CiU3HqUqPNof//Q+TdV05tI1BgJbW80+bDRTQtvePg/Kw7Gq8JtYpS/mpHNt8yOI/ek5HA/ z2Nf78qTaP8An95EpEN/fQXEqKiGK4UZJwWDjoaWOJpoXWN+DgzBjgED0qZTaRSgm7GckYMTCN8b pCgbrg59K9n+E3wb8SfF/wAXad4S8FaTqWtaxMqSPDYQmVyMjIyFODjJ57V5Wb5rh8oy6rmeLdqd Ncz9F/nse3kGRYvP80pZNglerVfKr7d7v0V36LufpTb/APBJj9qq9tLd7XwpdaUtypK299pzTyqh HGQqg5PfNeIfGb/gnt8evgxoa6v458M3UOkRBlmuNPtmsoAFUtuCsvJwpOMg8Hg1+E5L9IvhvNc4 jlc7JSaV1K7XS7V9Vf0su7P2jPfo4cTZRlc8xppvkV9YtKXZJ20du97vsj//0fku70dFijS7kMJL efCzARtLHnjj8KwZUiYuYFzbqwBB7Ecf41/vphqsakFODun27Pqf8++PpToVPZTVpKyaejTS1TQz 7U4ZhGkWMfMAg/T0/CpLW4Kl3AHmMNpDruGK7DzyrswWYHDq2cCniXzZEEmRuOGH8WKDOb1RamjS P/Uq0gJG31H4VLcQy2yRlkaUznaV27vL470FRd0f/9L4ljjcGRXUKBwm3g1ZN2/2U2gGzccSkDJl 2nK/Tmv+gA/55yvFK5SSKaNWikOWG0CQEehPSmPyqN5rRlGyY8ZDrjGP8+lPoBPZ3UUM8Vx5IlRH wysgdT26HinXFjumS6spUg3MTLbEbQ/fJPQd+n5VT5UkBPNdG+unXelvAsSxhNoUfKOckYyc+tZh kjtim23MrrLhwVwSCR/F1xx+lQVHSSP/0/i43ZRGktmjaSXKNCh+4PT/AD6VC7z4WORtqPIMoB/E eP8ACv8AoAP+e83LdbSztjNIJGdc8DoazZr25u3WQQqkK/KEYA5A9aCJtrREU4skZGjuC0//AC0t 1RgIPTORjn2qcJmHecEZwF/iHvQVF3RXCFriK3AMcciF/ObiNiD938f6UqRwfaGSUsUiOHToRjtW UpX0In2P/9T4mMO0uY2BGT5ajgr6Utpdq++JlmacEo7bCsQI9DX+/B/z0JtbGpBGDBJ+8QBnw8Z+ +pHQ/SqdvJLFOLbe8iSvlCQGWRs4Ax+XHvQdEJ2Q+VTm4DpIJoTsSGdNrDABJA/HimabqMlmZtsQ 86RPKYOu1kyQc/pWMkrmqkmrmpc6ddNm8maLdsDsqtmRs44x0zWZ9mmlJnjgkghjztilyS+Op/Sp KTtqj//V+Mbma3u4obe5t5GUZUxo/lfNg4JP9Ks2kQt3tneMPBCw2wZwMDsa/wB8D/n7jJ9S/e3M m7yFYRQk7kgHGzNZrzSNsRNoKcbmXNJpdTJ7EC+eN0UZjlkjbcZCuFbkDoauR2ZGHPO48oOvvTMX d6shn094pBP5JkjQ72UrkAUl21pd2K3LH/VqWXyFO7jopHHp70G6VlY//9b4xs4ZreNLl4nTcoZN ylWGeBkVYktnlLOmXldcYlAcsSMHHH5enFf74W6H/P1GVnqTf2u1k62cti0Lw2hhk808u38DYx8u AOn0qYxA2MV1JeP5k/3SF2FD349B0rGSs7Gq1IYbSS6U7pS8i8Rqc5kOeBUx+ypcwG5A2syjY7fK GH+HPFSaRl0ZJqW2S3jnJ8u4eUKshbcFQcBce/qai84i0WMzhcMDGSNoLHAwKlxTND//1/kuwgWF 57d9l3G6hxI68ISOQpPPHNT3FhcWsU0UYfyZcO7BfMRR9e3Ff7wWtof4Di3Bhi09bW1vg10yjEfl MVxkZH4ZzzVC4tIRZRyOz+YG2+ZvGyT2xjr/AJxQBjyw3Vv5eyFnhmbicf6uMj+E89ela+bNtPbz fNivkfCFcG3dMc57hs0nG5undXMu1t83MYMjZ/gK9QfX9K1H1GDTrmCyW3FxcTg+dMNzFF7Ejp14 49O9YWtobQ2P/9D5aYnKSpFKyD5i5jOE96y9SmkQSSC4LzSgKpxk44yPyr/dWUVZs/wdT0VyxYRa +Z0hOmzyQMFljkVxI3TOFj6kd+M1/Sf/AMEbZLWXQftG5/tsk8ovXktykgcSKZIznpxKnHvX88/S M5l4b4m3dX+5n9T/AEV5KPiTSUusH994n7cftCX0dv8ACzxPG6jYuhzTlpMqY8IcEep56e1fwz/G 5rXVPH3xE8mdZnHiae2V5FMbW4iCbcj0wQR9a/n/AOiVTf1rGT8j+gPpWzX1fDQPzf8A2qdTn0nQ tEgimjFjHp5lZ3JitHdpHVwWPckLwPUV+T15d3t/cXl1LElvGzE27RRnG0cbueuf61f0upXrYOn/ AFszt+i3G2R1pP8ArVH/0f5G5WnE6eZK0iZ+Vsf06VaN0sdvNEWEkr/cz8hGDk/XgEVwM7b+4ZMc crvHMzbdjAhODuIrp5r5U0iO0WCFZhcmc3IQi5GRjaD/AHe+KiXwsyMmykm+0Bpx5kIJdeMlD0zi q9+88skyYPyqGjlYYHJ4A/Kuea90CpBI1mQCnmoxG5gCWUnAPHpXR3GgJrk8FpazriMCV2Y+VjI5 6+h/kaySb0QH/9L+Ry8tPsE0ulRssk8MePtEKkxehGSOtZ88zxQGBWYSLGcPn5lP+f5V8+dA+znW WNVJkEgABPG1j3P40yS0SViqqgHIl3HJoJ5Xe5XtdOkia/FyP9EliCwqT8uc8kfoPxq7Fb2sdvvf HmH93FsUMMc5Oe2P60FFQ7FeG2Vw6ebmR5SVC/7I/MVI0twGeFomWNHOGdcbgPT2o2L5Gf/T/kB8 15WkcgRxxkInPLVIbjyYw7HyxnAIGM18w3dndG+zGX8Nxd2oFsIHt51K3JJ2T4HTb6dTTvskFraL 9kXzXWIebLjbj296RRBaXr26t5q7kY5yoywP0qvLctFKZ0heZ2OxYy2F78n6UGnOMWO5tYZbma3Y tNJvwik+nArTt5nIWPy2Z+DsKbj69KB3XLY//9T+Q+YzvFIFWZfKTdI0iFcZ7Csm3h4bZIwZCWLE 8jPavlz1efTzL0UpAZGD+bgZlxjPpg1etZpbcnbK4DtlssSBxQEZX0ZTu5TfuIkkZI4cSKqLtLEH kk/0qv8AbC91HYW0zwtjdcx+WfKdSOpbGOMHgVknaTKVuhRjSeG9I85GDSH5D0Ge9ad7lJmHmIQI twYDC55yBUDP/9X+P3TdXmkje3mgVIgMR4HEo9TUd63JVQI7cLuck9Mda+UjJWSPYNmzh026tbd7 mHzY4ZBIkgc8uBwT6/Sty/nsbWNGgjVlaPbFERhS2MH+tWBzdxa2N5OgVhBIkf7yKVcRFmJ2hPXt UEdlcWm17hAjhyhVDvK4/kKAJ9zRyZ/1gbruHy1oxwLMWmLgNsx8nKjHpQB//9b+R+BY7YzzzAyi GPckW3IkPv8A5707xLHp7aRGMGU3ibbqNYyrWIP8SHv2+ma+Zbukj6BabmVptxi0ht0aYyWoBWWR CI5x0UDPUgCt2O68+5+yCDbNKg8sS4EL5759sUm7u5vdErSLaymN5DnGDj7p+lQiewvImnulmWaG Yw2qC3yX5IZt3YcUiJ2sZEiRyyu0bMCpIDYwG9jWityn2WK2kVj5ZZnKjLsCBkAj6UFx2P/X/kLs Zr6ZpkZwtjndbpt2sijj5qV4lmmaAuY03DLJgNwQcZ98Y/Gvno7Hv1XuavmxWH74kEspRVU5IH9O lG6D5BHFs85t5mUHrzwRTJi2oM1razt21DRbhbmZXtb3dclwAgi4zhuxyP0r9Rfg1qAfSYVlhuS5 jVo3GfLlCdFYdjgk5zyGHFfvvgJSc+K5S7R/zPw3xdqr+z6cH1k/0P6Zv+CPtqjXkczxyIup6m2o XdnswsQL7FjZu+0J+df0O/tB6naaJ8KvEeoGDfCmnS2sKR/KwjMTbyD9BXh+I/NX8VZxlpeUV+CR +tcLxjh/DTDJfyN/mz//0PiL9p29jtfi14/n01ZHtL3WJL2xiEoaVEDhM8d2+9z/APq/Fv8Aa2uJ 59H0+2sLG90ZRcmaO9mhMkN06SRq25yACD8gAXp+Nf6MZ/J0/Dpy/wCnP/tp/IPC0PaeILttzv8A M/OrVku7qdpZooo5G2x7lGBIQMbj9fWk0mCZbsW8rGAsQGBG3I9RX+eOKl+9l6n9lU42ijtfsKWt y5ikW4h2/JMucs3cY7Uk8kqRCX5AyNk7urD0NeXVdtDWzR0OkCGSBZp7UNFP88TByCmD3Hfkd66a C0urlY0gQOY389gvVVGef1FeVWd2wS0bP//R/kx0W4v7ay+y3nmtaGUIjqhf7KrYJxjlRkcketdn eSRaZp73lxdxTwNIEhtEGbhRtySFGSa+FrfEewXLfR5Y9+o/b51tnhElvDOyAAcZCqOc/WtxdfOn tbadcw7Xlh+0RsyhtyMNuf5cGuWb1sGi0MG8TT9R1C3glvJIdimR0U+WMHufcYzj60S6fNPqDRC5 S00xbUNHPbvuub0j+Int0xgVmTLRMsQGa0mM8bEK3EAbksR/FTbPUr7R4pDcuZBJI/2q+FsZCqtn CADgDBx+FXDcd1ex/9L+RPxP4jiv4WvFjaFZmQXFsBmC3P8AFsUfwjkgelee3jJC9p9mlcxysdmz 5Y4sDPPPGa+evzNvzLxGw3yxNtbzCXU5IOcsaZa6rNc5jn2pL5jK8hXDFATt57HGKZz09zfgnhja NZXzE/yykMFcD2z3qraxWmnRyRKAhkmLq7yFnlBxxk/jWkE09TU1rYMZRMTEisNsBVuXPOePX/Gt wLHNtlv4AJbRfKtbg4ztPX/9VbQV2OK1R//T/kelCwMbhdUlkkCqUs3TFsmOOG9frXKeKrq3FnBe RFJNTln8teSiRRjG7Jxz3IA9K46a6m8rW1LthfWh02Fp5DJGPlQqMyD1z+deP+Krq8lu4MqlsIpG 8ryclrpecF/px6V2UotPU52ru5ywtN06zyRkE/dfPI+npX3X+yz4ntYEuPNKLqk92LU21upM9ykT ALJK3cYUfiTX6Z4YT9nxhg3/AHv0Z8j4gQ9pwji4r+U/Zn4Na6974r8NyRx2en6tp2pQZkuf9HSJ GmjTLA8A5YIe/Ir++79j+a6uvhB4fedjIk0A+2uSBschQBnv9zn3r9r+kxH/AGDBytq0fN/Rti/7 Ixyvomf/1P2z/wCCzGjG68A29zeWPm23knR5WKKyRESrLAWz2JjU+xr+RPU4J7EQ+W7vCsaxmSNN kan/AGfT/wCtX94/RorSnwdOlfSMvzv/AMA/jvxxpey4srT7r/ImTU7c3JtWtRdebEI5YnfD8YO4 E/dPHXFc1csLVppJGltplfhUZXCkH5ccdCOv1r+nKex+G1X7hDaRvaoqWrxkz3X2qfzUEkcuRg/K eOnSlNiFu/MQLtcFEUkBVY1tT3J2JT9jjdYpnY3rf6tF5jI75P6CqWrpFcQpdXqQRRRD7PaW8b/6 QxHO919yfpitUr6ImUrH/9X8jZvPuobIxS7/ALBIJI45gJY4nwOxGD24Ip07krKwSNBLzcNGgiVm yD8oAwOnav8AZnld7H+YDd3cJbiO2tLZLtyPtdynkzpkiPYScNj6D8q6O5vjfzRyyLAuLdIS8ihN 4UfffHf9afLLsZ86MCyuobe/bUDbwMVZozE8e1c4Kgge3B4rXluXlt45JXESTMyxMGCliPvKKfI7 ESlcrW9hBJEzCcQSwMGjUKCs2eCGPapbzTGD2NxPNDZxxHy7d0J+QgZACeh4GKi1tDHn18j/1vy2 BhuBFDdzObpEDGKcHGBjLE9s5BArLOpX9wb6Ozu1juoVC2Uc8O+KPb907TwR3I75Nf7MH+WnOi+1 tcag1vf3lqj3loFllKkGMyBcM6qAAATk9OM1q3VtNqNuIlc20bsrl1ONrLgjn2JH6U2raFJprQpa jpt1DNDbyTyXZESmOPzxJA24bs5HHep30iE6VNeNceTcWt2kMMaIGjYtywZvovH1pDL0LabcaaSw 8q+hkCFVhKxSpj7xb1+lUV0X9/cX0OostveWi28sMbAhQGBIPccqOPagmXwn/9f8r3jgtMPuMqI3 zEJkgDvip59ZkKgWCxS2TLie5bIeTjjaO2Oetf7MpXdj/K2SuhLiJVezbSkDW5RXuGkjKtuIy4x7 E4rOu5rkX32aKTC3MiqEiXLE/wCc07WiYOKe50eqaaunSID5cqqmAxO12bHdfz/Kmht+lRQf2eIf NuCFuNu12KjAVMduRWiWzMB+mWd/qoGlPBi9km/0ZfM2lAvGZG6Vlaza3lhePpT27G8hiDtsw5dS Ccgj0Az9DUNWuNRbV0f/0PyuhubCzhtJk+0yNOgNzA0OySFwSGBzgEdxiulivodSt3FhL8kExSNb iMo65xnt7D8a/wBmbn+UKi2ad3YxNpUBmmdLpbkFrdEDpKgwQ2fzGPeorjSIJbeV7K18u6umEUUK fK7kjkjPcYpGyVtCvpDWtrZ3Ns6vNqAxl1cFB1zkevHaudvJbm9ubSztpUmIly1vKm6RmH3Qpz1B 7e9dBzy0uzZM2r2D7ntmhu0hwpnw/ByDhhyOlVLid5InurlZWDDc5XLMe3FBzn//0fzE0azMUssd xcNDY3i740kj82fPUOWPPfGPc1FYaelzf3xgDrbxysFkmTaQVIXP044r/aA/yYk1ZC+Y1lcs8lv5 0aNsVz80Rb+v0Nb+i3FxdLfG6tUS2CqxuriIL5ABJyAPu9vrW0VZWZhJ3ZH/AGmLi4FrA4eNyyQm SPKcg8kHgZHrWDNp2t+HNQeHUcy210Q1hNGh23CHpyBjPtVEmvHqD7Zo7mTyrdrY/wCj/cmLdj19 xS2WpA2r2MYt1eNg0l5ImbqMEfKpP6/jQVf3bH//0vzR+xJBb27i6ku55JS1w8r7FYk5GAOgHoDi n2uoT3sd/ujdoYmFuzOuFR1OcDueAfzr/ayCd7n+Rc3rYr3kJv8Ay47ePkAAhT5eAMZ2nsTj8amg ntrbSIUtBJBM16ytImPOuHTacY6nHP1BrQ5pN3sIYL3UY4bt42WBxlZWAjcjv8hwafHI0QjtLOaV Eik86YhRGZ2x0b2FBN2SiFJbhZEmUPHJuO3g7geDn0qG3t2a4vba5vHhkUttmwH81jk9Qenatoqy Im3Y/9P8u7zT0hiitzc7/NQMZ9m0g7jyPXpn8a6nTdLtVCXyDyYYohFcPJLsVz/CQPXOP1r/AG5S u7H+O5BrsspMdm/mrCoDwsVxEe2B+n51BDZzBSm6RQygNHFkvIOuMD+VaxjZWZN3zWNjw2whaLUL ea7iniuHj/eqbeSIDAwO+Dk8+/WvSIJNT1JrcWTvDKZt1w8jbIZxzhmPc8n161dKNmKq24n75/8A BJWSDQ/FUtu8EJkup45b024E0rzPEqFuf4f3fH41/UlrglbwzdRq3TTikhI5ICLn2/Dviv8AMr6R 0eXxKc/Nfmf6aeD7c/CTDQf8j/JH/9T0b/gpdpFxbftFpYaWkR+22c17NEsfHyTxmNmY9xsOMdOa +Gb2O2gWSS0lks7lbbybmCNstJuG1znjg88HPWv9k/CmXPwDlkv+nf6s/wAX/EeHLxbmCXSpIz7W S2tLMq0uIFOJGAAZM9T/APXp5X7POskTxNbyRjaoZWbpnORX6ZHZH53NGZf3MN4Ut0gdDkrLJI+V bpjaO3eoWtoYn3PJ5bKgAYtgD2A962p7GZvW95oX2bcfO89l8mUKAoRuzD1zWTY2bahemGFA8e4u 7SYVAF5BP04rpgrIym9bH//V+UNTt5bPbJOWjt2PlQSIMrIR1IPtx+dXfDviW48JyS3FlN5qzR4k RlEvnZ/h5B2/Wv8Ae+UVJOMtmf4IUa86VVVYO0otNeq1M7VPEcV7dGeTT44rgJlZFm8zhuqj5R0r Ma33RpqSxvG5R4lVlxEwdcHj1H9aZHOk7GLolo1nPBPPBHcS2vzYYZjb6j3roDarfSLJJ5sMc/3B jJBA+6B+VaQfQyk1qya0sre0jia8CxvFdNvSMljKgwQc44zzS7A15cfZ5BDNdHzi4BQAYCgkD0AA rQ5j/9b4naG7tZgZI3ZXBxMwzk+n15p0CKZvLdTtMgZzjLLX+/B/z+z0iWrm1tkjllMsskgbEcIT 5MepNSrcLPYo0k8CTE+StpljcqqqB5jDGAD9aa3OeTsjGDPC7JIT5QOV7DNWEdFlTzjsidgu5hwu eK2irIxLd4iTlIhJ5sMbYSUIVPOOx5pJLdLQFFSWSVAWYYJbGOwpkTdlY//X+KUkZ4zhHyf4WXa4 +o7VN9nLQvJ5IaWMZYHgkV/0Arc/56YvlZMgUIpdGG/ggj7oqGaC0Eu0l3Kj93gfKx963NeZETKz sqsrRJnI2fdI6UQBE+029w/mrIMxzNwUxnHH6UDKUTfIsj5lZfl57VZiVZ1ldkZDjyhHkhWIwc/r 0oA//9D4j8gkbHeXcPuq5OFFICxCIpbdG+ScZGOeDX/QQf8APc2luWJIfMSR4JUEqgExtw5GeSB7 U6NJGjGTt8sd+9AJ3Vy1DNJxsOwgEEg4Y1Xlcq37pCA4A2Dv71oopxMXuQxGTfJbvIdrJkgHAAxT QwtXAgb5x8w29eKtLlVhH//R+II5CGnmjt44hM/mukcewscelW7eWCSNGVikjOQy9dvTH9a/6ED/ AJ5x11E8Me6R4yH5wjBjj3qGO0MqRzR3EYUHDwAEyOOnBxgY9zQBo2wS3doljjdsEMZkypBB7dqf PdKLVbRCI3M2HZBww9Cfy/KghzXQb9kRjtVi7gcjqcVHMkVpAIwfMnnY5B6xgYxj8z+VAc6uf//S +HWBmk+R8OpClWzWpBFLBIhIAKnkEYB7V/0IH/PFKV9EaUlssOWmGdw3qnDHBrngpjZ1y/kyPuCY yU9qCbu1iKzuUuJbhYHLCGUwMSpUgjsR9CPzqw8cSTww3G5fOJ2vGm/BAzz6UCLc1hthw5nSUnIb d8hU/wCyf50skMce2M4RkUA4xk/X8qDSMklZn//T+M4NOFxvdJEXA6yNtH4+lTQ6VcTm7uFubM/2 egxG8oJlAOPkHcf571/0IH/POSLJa4LSwJLKDwv8C/hRZ2sjSSeWQHnOVRT82cdvyrOfYumvfSP2 e/4JJfBLwv8AGn4oPpnjewjubfw5eGSaPYsck4EJlGdwJ5CqvGfvk96/qeuv2XfgNdaIdCk+G3h0 Whi8rzorMR33TG7zeua/zI+kvx5n2WeI8sDgarjTppOy6621+7pbc/1o+j94d8P4nwkwdfF0VKdd czb7yV/189j+V3/grF+y34X/AGY/jT4Y1/wu15J4S8Z6aL+wsdir/ZsrSy20ok2gK4U7CGIB5PHF aH/BML4IeCfjZ8bVsvG0EkthoqxyQWcUYAuVdHdsPyAHCbScZAz3r90q8dY/FeANPiWjJ+2VOzv5 J6PXZK33H81eHnAmXVvpAZjwvjoJ0qU52sl9mdk1fZvX5N9z/9T+3q8/Zb/Z/v8ARV0G6+FvhaWw SAW6k2I+1AAbc+bndn6mv5fP+CuP7IHgb9nPx1o/i7wF5un6J4t0Ga5j0YRqYonSdYpDkdSgZMHg 47V/Zv0cfEvPaviDTyjMKrqU66a1dtXott1dp/I/hv6VXhnkeE4KpZ9lVJU6lGaTtrdcspPVvT4b H40JH5cMImRmhf8A5asuNwPOarw6ZHcJIsTSxTM5wyOeR6ba/wBMYbWP82asf3vKQXNg9t5UIOZT wzyrtU/5FZz2M8kjwttJSXYJB9xh6itXL3bGKj7zC40plkTYcMABx0471rmzvY44nnUGJ0CLJtAD ccEU4y7k1FbQ/9X5Cu4Gsnw8hI/hdhtD5/zitK3W1No9ldQyi3vCpneCIPOyghiAx6dM1/0DuVkf 890F0KTWMdtO9paPJdKX/ctIgjkIPQYHGecVYFhdROYppMMp+VSOVHWsFO0jqhBuOh+pn7BH7Efi f9ojxhoPie68L6jJ4HsL4C7uZ7F47SUJhd7kgBRuI5bjH41/Ul4o/YO/Zt8V+Bn8FX3gDTbVW0wW Mer2S7NQicIB5gJyrcgEqw5x+Nf59fSH8ZMfguOcPlWU1P3eHlaSXk9dn1d3ftY/0W8EvAnK8X4Y VcwzelbEYqm5JvTe7indN+6rJpeb3bP4qP2ofhTH8FfjZ8SPhrYTpLpfhrxVdafpSrFhxDFIYwMD hQCuevevmW8eWOVcnYMYwetf3dwnm/8AbnD2BzZu8qtOEn/isub8bn+fWe5Y8pzfEZc9qc5Jel9P wsf/1viu/wAwReezrt4yQPX/APXTLcPMWKqTuTaDjpx2r/oQP+e3lSdya2s2kHlAnuELHlsZzUpj uIdkUdtJI2dioq/N19KpScTScFZH6Lf8E41+F9/+0D4R0n4rW9iuiX+orYwzalIILOIYQzKzkjBL MufYema/tb0f4NfB/TtPtLfSPh94MFisCm1ePRba5EiYBVhIVJYEYOc85r/Of6Xub57lvFOGhhZy jQlDdNrVJdfv9dT/AFE+iVkeQ4/w4jWr04zrqU1JNJ6c8rXXol9yNZ/hZ8NZMGTwD4Pbau1S3h61 O0e3ycU+P4Y/DmJQsfgXwmig5CjQLYD8tlfx5S4pz2Kf+0Tf/bz/AMz+n5cMZH7Syw8Fp0ikf//X /u3uvhN8ML23ktbr4feDpYJM71Ph21Vjn/aCbh+Br+Wn/gst+yf4A+B3izTPiD8O7Z9GsviFbJLf eHYgv9nQ3UdwIpHjONyg5ixg5G5hyMY/rv6NfHed0vEmhltaq5UqycGm292l+t9eqT6H8c/So4Hy aXh3/aeHpKNWlUTVkl9mT/8AbbadG+5+Dj2uoefPG1uqCLBjXBJY85GfyqsIZYrprktKPMTy3QHC R+4Ff6pRkrH+XFSNp2L8thdyiJoGjkU/e3kqQKdcWKWBVbh423qHAU5xmplNKSIULWSM24Mcq7Aq lMhgSoJBB4PtXZfDeSN/Gnh7T5GcJd6lbrcjyfNzF9oiVx7ZDVx5pWdLLcRVpu0lTm01umoux9Bw rhaWL4ly/DV4qUJ16MZJq6ac4pprqmj/0P7Y/gH8Gfhb4X+EngCHS/AvhrN94XstVu5rvSIb25uJ rm3jmkZ3kViTlyPbFfH3/BSH9kX4P+OvgP4y8cW2h6b4O8S+GLA3rapoOnwWMd8hIUJNGFCbg2wr IBkc5yOn9K5Bx5n2G8V4T9vLl+sNWv2k7H87eK/AnD9bwsxMoUEpxoQadvT87n8UIgkt5bi0muEu /InZHugQXuMcKzEdTjA/CqH2OZ5xFDKyLJOgaVRvMS7gCVHfA5xX+uMJWpq3Y/yEhD96kf2if8Eo bT9n3xx+zpod94e0rwprvjKyza+Irm/soZtYnaM4EpikBZVJ64GMgetfqpL4N8HTxNDP4S8Mywuu 14pNCtWRh6YKV/kB4z53xHl/iHmFKtVlFqo7a9Py37H+0XhjwxwrmnAOW1aFFSpunDp15bev/DI/ nI/4LZfso+BfDmg+Evi18PdFsvDGo3U7WWsWOl2iLaXTrLGfMWLomVkO7aQPl6en81UkcxkaGaNU khYoXHftjHbGK/0J+jbxHiuIPDHCVsdLmqU24X8rJ/m2f5gePvC1DhrxNzTD4RWpTlzxS6XbVtfk f//R+QmguPMEMYOCu84HFMe0byluJPMHO1hj5U5x/n61/wBCSkktD/nrcLyLLWqSOq/8sETAIXax PvVFLPE5dpCsC8YH8XpVKS5bMTg76ExS3M0ccskyKWGZlG5o1HXj+n61q32iWdgltqenXc07tcZg i8oM85x8qtGezHrXOp9zswsFKJ/WL/wRp/4Zu174K2+h2+k+DLv4vaVO0OuQ6tpyTa3IFAb9154O 4Lkj932jJ6Amv25bw/4f2vG3h7QijfK6HSYCj/Ubea/yE8ecy4hy/wARcfRrVpRjzXjZtXT66Pvc /wBoPB/I+G8Z4fZdicPRjJOCveK37LTa1j//0v36/wCC1/7Mnwzb4I2/xi8O+HNP8O+LbDVF0q5u 9ItI7O3vPlkuIGeJQFDAxSIWUDKvg5wMfyeRIt1awTyRxtcXECzSSJHtU7hkY79CK/2B+ijxJjc/ 8Nowx7vOlNxT11X6fDf1bP8AHX6UvC+B4Y8TMRDL1aFVc1uzdn/7dZeSRTZYbOJ/MQSM3TjLL9Ki lydsaWzJJtDncCCQeQfx/rX9Pn8zRfvNDXVpk2EYK9RjpWlbRieBbeNU3RjdMzMFP4ev0pPYqkrq xMsi20kKhfvTx2qKBnc8rrGgPblmAyfWv6aP+CV//BO3xRaSaD8avi/o+k3fhS5h+2aFoWq3EWo+ fjcu/wApR90sobD54ZRzzj+dfpLcbS4P4Bqxw8+WvXfJGzV9uz31d/8At16M/rD6JHANLi/xAeY4 6nzYbCxu7rTmfn0aWlt/eWx//9P+zH9rD9m/4OfFj4DeP9D8R+B/DsMWieF7zWdKu7DSYLK6sZbO 3eZNrIoJB8oDafbGCAa/gr17RpNK8ReKtKdHFnoniu50vTsptZoV2FPr1PP0r/Tn6HPFWZ5xl2aZ dj58yg1JN7/5fa7dEf5j/TM4QyrIs5wGZZbDl9ouVpbdfn9jTXqzn5LQ5JVuCcAN0AqeDT1jkV22 srrsWMfe3HgH/wCtX9sUW2tT+IKqtBIgmspSxiQswLYRQvzsT0AqWz0+RHAkYspfbLCDtlT65HGa 6YvlOWWxSvLTbdymF2iRn2orjKgD0qw1oIgp3iRRyXXOP15qnK0rmOvU/9T43cSEFsFoz6j5RTEK yhgmMqO46V/0Pt8p/wA65SSBj5rTMpdTuUKmFJyOB+tSNGJlZGUrxgt0H+eKjndgJ7aOOKLa6MZ9 /wC7bcDGVx6Yznp3r2X9nHxF4f8ACXx88AeJvGltcXPhDTdTWHXYksG1CFI55EjWR4xyVH8XsTXj 5+qlTJcXGl8bpTS9eV2PpeDvZrizLfa/D7elf09pG/4H+gD8IPE/ws8dfD7w54l+FJ8OXnhG606F bH+x7KK3S0CoFEUkQAKMuCCrDPHfrXpwSFc7ba2Xd97bCo3fWv8AEPi7GZ1gs/xOExdWXOpyT1av 7z6eh/vRgMnyWWBw9bD0Y8rgmvdWzV+x/9X+oT/grv4S+Dl9+zLq2qeJbfwnp/xC0rVbW48I3TvD Z643mM6XC7F+eSMx+YcMCoZVOQRX8Y0GlXpZo5wrzwObdpI08tJNp27sH6d6/wBZfom43H4jgStD Ht2jUfLe+zbvb7kf4+/Swy3CYPxTrTwPwzhBuytryQ/W/wA2I2mRRSqT5sl0hImRX/dLnp07jmrG J4QTCu1gOcpuHX0r+qeaJ/Lqg1dDY5LtibgI0bE7FmjGwds9Pr+tU545PM29edwbtUOdnoaRi+VF 9LW4dF8tUadv9UZQDHnoM546noevSv7Sf+CQHgPw/wCGv2O/B+sQ6RpsWuajql8L69jsokvB5c/l 7SwGR9zOM9hX8qfS1zLFYPw+pxw8muepZ2fmv8395/a/0MMmwWP43x9fFQTdKlBxuk7X5r/kvu8k f//W/uj+L3gPwl8S/hz4y8L+MtD07WtMvvDd5GyX1qkzQMIJCkkbEEoyNhgV6EV/n3/E/wAOWnhX 4h/EHwzZqqRaH4sltbWJX3gQsiumPpyPwr/RH6G+d43EVsyy6vUbgoqSV9LppL82f50/TNyDA0MZ lmY0KaVSfutpdHzN/kjgBblyVUgORjJHAqL+z75ZVeUBRt+ZcDccdD6dq/vZTSeh/ntOLu0IsUyA uAZlL7QoGcDpU0tpNGhkVflI5B6itFOyaOfa1ipDEVCykoG3bQjcb+vA/Ko7qIozz+WIjkbljQIn pwBwKqMrtjfwo//X+PobnzGaPdlgOFqDMkjsknKdAD/Div8AoQP+dcfBGXUu5aNI3ONw5JHtVu2v Z2uAkUP7twQ0wPzY71nU0SO7D2d7n0j+zt8AfF37Q/xO8PfC/wAICyF14gu0Fze3+UitoBlpCDg5 baCcY5CnpX9sv7HH7K3h39k/4SaZ8P7BdO1DWRK13q+sW1sA07uqAxq5UMVUhsZ9a/hH6XfHtTCU sPwfg21KScpNaaaOz12atp5yv0R/pD9Dfw7pxwOJ43xsbqp7sE10jzK+297u9/5bdT8gP+C83w88 HWHhLwF8RNJ8N2EXjr7fBBPqNvAIRfQJdIu2dV4Y4dxuPOMZzgY/mXn8Pq3mQ37zb5ZfM3q4zFk5 xj+nFfqX0Zs4xWZ+F2GqYublKEpxV3fSPr3d36tn89/Sa4fwmR+J+NpYOPLCpyz0VleWr+7RfJH/ 0P36/wCCK/7QXwZg+HcnwO+2f2V8RoLxrmz/ALRsEtBqqMArQwygklhsVwrYyG49K/fjcw4z046V /S30jMNmWA8TsfPENqFSXPDp7rvt/XU/BPo6vLcV4S5YsPFNxpxjP/Ekk7+d7r5H4e/8FwvA/hq4 /Z80jxtJYpBr1nrX2UXtnaK13chWidPMIGSoO7Oezmv5NMaZPJGhlMQvlV4UbJdy5G1V9Dz+lf2R 9FHN62O8OHh8TJydOo9X2en4WP4P+lhk9DAeJ06mFgoqcI6Luuv4j5NOghgnjuWUOjiJJDyRzgD8 6pR6Xd2kpLqCmMAJ8w9s1/TcKnvXP5mnTahawi6dcTX6QR28swmfbiBN5yfp3q3d20Fin2D7DNDc mRhNPKUKeyhcZDcHnNdimup5ri76H//R+SjCFjcRDC7sMw45quGkMRtyDhyAZGUM4weMHGR+Ff8A QJKfY/557dClJYxqzhZC+05O4kljV2BI4pEJT5RgtG3APTirvsY3cbxJ4bwCW4WHAQnbtPJHtW1p 0dvdPLFfYkimjJKZAb0GM/Ws57mtPof0m/8ABFb9o/4a+FNMuvgd4jujpXirxDffavC13eBTFqCY SMQbgMrlomOCTgsM4GWr+kev8kfpK4DMMv8AEjF18RJ8tV80e27ul5dfmf7QfR5qZfifCvLVhIpq EIpvdt2W/n0+R//S/vg13X9F8MabPrHiDU7PSNLtsefe30whgjz0yT/ng07RNd0bxLplrrOganZ6 vpV6pa11CwmFxbTAEqcMOMgggjqCK97lxSw6rpvk2v56nnxp0HUlHlV/RH5bf8FLP2DdM/aS8C3P jbwjaadY+PPCaHXZwqG0k1pLWNy53p1k8vP3h82xepAr+PvXvDE+g6xrmlahp91Zan4f1iSznjlj 2I8igFsHvgMOnrX+i/0TuMqmbcK1eHcXK88PL3fOO34e6l6M/wA4vpZcG0sq4soZ/hIWhXj73bmu 3+LUm/VI5i9trqR5vIheRZoACUTfjnORwcH3FZltp0ttKZ7kzf6Nj93s5BHIz/nvX9dOcUlqfxy6 cnLYaZpZL5LgQmTPyx8ZBHI/xqzN9nsj+7/cwBQrq2Qy+5/+tROpHRGlOlLV2P/T+arHT5L0iRSk 1ldJgLjc6YPUenT61Df+GZ7PZLEGdWfMcsi8kZ5Ga/3zVSNkj/AZUZOTK40O8jzP5Ie2cZdyuGTk c9OPrV+HQ3uI3kt4Q0dsMyKhLNKO5AHPaplUjyehfsWpK5Xm06xvtPiNnapC0JLfL95jyDn8Qa/R /wD4JcftB+Gv2ZfjnBrnjbT0l0DxEn9kXeoLP/p1lOzIFKIRgjy2YgZHMfJ5yPz/AMRcBVzfgjM8 uoO0p05JfLX9D9S8JMVRyvxEynHV17kaqv8A9vJx/Nn9r+g67pXibRdL8Q6Hdx3+kazZR6hp15GC EuIpVDI2DyODyDyCCDXEfGbQtD8R/Cvx9pPiKytr/Sp/C1608N1AtxGpS3kZHCn+JSAQRzX+PeDe KwPE1Kk21OFSK87pr9T/AF/zalhq+Q4h8qcXTl00tZn/1PIfirpWjXfjrxJpXh9LhNI0XXLi30yO 4hMI8tpC6iPPO1eVH0ryaW0sg0sN1DOrKDGRDMLcgj8DX+7PCcpT4ewM5vV0qf8A6Sj/AAb46pxj xTmCgrL21S3/AIGzEkgitl8uEyMSdoLfMfbJpHglt8Bhg9GBHK19OfFkyREMjAAOT36VH5SvcMUT MzNt3Hox46UEtJyRYtUmgmYysY5UOEDf6sH3q3NdG7uMhlwD1i+4p4zigaio7H//1fi+8R4ZXUMJ FXnK5w2ee/P51Pp8EpguJLm2csRvjdhhQvGD/wDXr/oAP+ee/QqvHL8hK7VJyrdA3OOKmktHa2lf Zgx+3OPX/PrVxV4sCnGvlRNz19McGoIjOuWlffhjt4wMVThpYCeGwjuGy5ljhHzuYvlPXPWtB7iJ xJGqboolCRs4HmvgY5rNprcF5H//1vi7y7C2SOUMrTzqZGhUfNHgkfN+n51fsI0vgZZUCKhyA3ys OuK/6AD/AJ7VJW1LF7dyThYBbRxxQHa8w5EgHTHYVUuI40EDWsodiMsucFD24oMm7sc1vbpatdzy iW5mkKumM4IGetZqrKyfvFIjzgKwoa0sCbWwqiUzLtJYRnKjrtA7USX0rS7RCkqNwx2kuTWDTTsx Sl1Z/9f4zgijdGmVZE8pv3iNGRtp6gnctqw/flZMZ+U44H8z+df78H/PMmnsPFpc2s0kcW0rfJsm OQwIyD36dB0ps0NrFci1m83bbYdJYuS5YA9z2oNoPSwJBZqwlhu3llc/MksZTZzRfSwSCVbOZftd uQjSshZGI9PWsGrMszw89v5Ty3cskzACVgPlY/7voP0rXtrob286Zvu46ZX8qRrBrY//0Pi+WSS2 ufNnib7OzjbKI87cnH/16vyqiqfLbcpGVOeua/3wP+fcpadeS2pmE0Uc6FuBNEHYduGPI/CrrvAy SyqEWbZvSNhhfp+FZzC3QyHErRzSGVYnC7tqAh8dyP8APatP7Q0lvELeRm8sDzHAw2eM5rMSSSsX o9Vu5hEAAn2fIYgArOCMYK/n+dZ3nGMz27RERyOHeOJQGj2nt6d/wNdAz//R+TX1BZ3CbBHbRxhI 1Yg/KM8E+vfJocS3E22ECBBGGhdfmLMD0r/fA/59zP1WzKTomPOeRQWdDuwT1z+OfzqFIJf9WXA2 ngMcLWU9ylJrQvXU16TDGywJsjwn2eJIxIPUlRz0PJ5pl3HBClnNII5JlO827fMIscAt9fSoLU09 ydLZXtxNPIpRThcNwMjPI+lQeXpkkcK5ly8nmCQNuQAgdPbvUSbWxtGXKrH/0vkmeSFJfs1oJHji XekjNhpSM8kf0qlJcXc3lIZJY4IpPPcZwHOCMH29vav94D/ARTRNLG7QSyxTpHJcKYi4QExZ9B2z 7VDbaZePCLsr5sdudrJu4c9TgUFJ3Jl8uYuWDKqDci8hVpyzwQ2s8bgNLKu2MsodR7+3TrQ9EbRa UdS7oyadaKl7fW00+QyDZcbETsG24Occ029it0uFeMhTIu1HchQQfc1zmkZNLQ//0/mi3u5IoRaX QlEflqWWJkkaVM/eB7c1yaCOK8EkrGVWk+5jLIPT0r/dd7M/wXUtjtUubW+QPYSmymsJIzFbXcxa S8UcNtdRx34Pt3r+oD/gkZ4USLwdDqsNq9tFfTyXM0Z2yCAucbd/cjyE596/mX6TmK+r+H9Smn8U rf1/XU/sf6I2AjjOOKuIcb+zgnft/Vr/ACP1C/aqu1tfhL4lZtxYadJGgK7tyuu3P4cflX8N3xGs TP478fX0Fyb6S98STvEY49ihVCpt+oKnP0r8e+iRT/3yflb8j9Y+lfUs8ND+uv8AkfnF+1uNMjs7 Lz/tbW00a6abaQiYzTRkSPIyfwBSSPwr8xNUljtZ2jWVXMh2orHIYYzgD6V5X0t6v/CnhILt+h9D 9GOLXD1SXn+p/9T+TaeEALME2KCCQRwaxb7NwYwsSx+U58okAbicZOf8enNeedUXeDIbdXYfOhUq +Co6nFW5mYgSTDy1Q4Cgcmpl8LJLdvHvLumTZrEHeVf9Yp7gL3xUThGQ3AkbykXDIwxu98ViBRhQ TmSXzAhRN0SH5dxHQVt6TrDaVdW891Y+efOWV4NwU3KqeRn3AI9qWiA//9X+TDXdRtL65mltbQ6b HLLxFvMqqTzw1cOwKXoZhLIMGN2BykWf4iO9fPnQXbfSrlfM/wBJlMMjeagVsbfYHHT8+tWpkSyt 3lhCG66bWYsjdvm/SgC+5RbOBZ/IYTp5rHzgwix1Ht06GsP7TGk21JMqi/cPGM9/xqZS5TaEbLUt RRws2WXowk+YcH0rUF1IY3S7jEjhdluyjAUA5HHtWTbe5R//1v5BLeSC5V5kByrspR0KAkEgnB+l UdQ+1PPZblUWZYiYKDnAHGK+XPQH2tzEs6W8juLd5RuKD94FB5Aq1LbGSU4Fzb2UNxvKROG82LHT Htn/AMdoAV441Teu7b90BVyx7dKqLBNJdJLKBFbQkBl34lZuo49KANuOWWfLhzHHE2RuHTFIbzbK 84AknZuSMKWPrQNLRs//1/5BZ9QlnufJKzoGXy22cx59/wDPapYYDCj4AfjDfwmvlz0CKMOrF3Hl 5Py5bIHWgXMcJjAi+0O7nd8xQcg4P4HnFAFXN0sjHeIgx5TGN4zUazv5zJGD/tPt+X6ZrGStJlvS KRM0IAeTCo2c7iM5PvUNzeRxrG7xswxhnxlnx6CpNT//0P484LuO7ywGxo12ojJs2qM9ffrVuJYJ 8h1MkfQ5OVNfH7HsFk2kIdXWV4IgctDEQseB6iqDJctcNmd3iEvmQg/wDsB/nvWqd5OxrGPu2ZZl 1E2zCVYRM8Y3YKbhkdMe9WDcOEfUHeTNyA5hk/1cRI6KOo681Zm4tblqO7iWxfKxTtMQAR/rI8en pUVpbI0dwRczpbNIRK0g2NBkc49uc55oEf/R/kmjtDDCnlSrNDwmXkzNkDqfY1Qtri9e4ni1awtV hD7YhFc/aPkBxycDGcdPevlz6BKysXZJ1j2odoijz5S9dgPYe1MmfzFBQhZFGY3A+ZaTdlcCCWIX BtyWk8+P5h2C/Wt7TrVJ47kOy+Zb25k3E4RTkL/X+dZxk72Aw5bKSLLKwdS2ZGHUmoUmFvcyB1kM ENv59wyqWdR0GB15rUadtj//0v5D7R4ZjNdpP/o7KSEC7Nvr157VAiWTXTTeZIWR1eP5MoABg4Pv +NfOQkrWZ7dR2ZuG3QQNGBlJTvyRlgfX9abH5VtC++Q/JyuR0q46tBB+6ze8MvNLqcQksIL+1chW ikk2BlJGT06jtX6xfC+Z10TTxJpq2lpBpaslzFGFF4+Dtd+5YABSfQCv6T+jxC+fV5W+z+p/PPjF VfLhqd95P9D+of8A4I1aemr+HdA1a8mVmmjuPt0XliJrfbIqxjp6xknPrnvX7O/tcF7P4PeIkeWN YTZtIp8zAgQDnj6ZH4ivjOMaixPi7KPRVIr8T9yymDpeG2Hvu6X6H//T/Oj44av/AGl8SPGc8Fnd tKuuTWUBePbY3EQfO4Dqfu4yOu49RX5G/tXX99efYNOvr6RtOtInkitZJSkMRJQlox3AYnJ9cDsK /wBFuNW8P4cVEulG3/kp/IvBEefj5t9Kj/Bn52a1eMJSiyK1uh2owGGcDuaS0vYnkiknLsowm7GW Hav87az9+TP7JWyPQrPzCInt03QI37043ZX2/StOe2hmEKGFIhOSjM7ZVeev615097FNtqxeSJtK 8uGJUaMwgphhIpGeGByfQ1PFfznyHETIzTECUEpvxzjFeVV03C9tD//U/k88B3xv3aGeUW1rDbFp g53y3BX+FV7gnH0rpbjT7a7lhYu0XkSGRZVjDtGD2Ga+FrfEeu3ZXCC5uPMeGGL7Yi/6uKU+XnHU jr2zToIXur9r7U7eW1eKPZZAAlwvHHv9a5prS5nzNvUsX1lp1mLaYb7yPbuuL2dcTkYxzjgHmqKr NHb2H2CKaSOS/aJblxm2jGMhc9gKyKm1axcu57+KwluJIoria0fypfIkGxiScbRnJ4Hb0qSC+u4h IPNn+xvGHuLVcmNiORuHqPetaS1FG1z/1f467yAzzyNHIrnyh8yJiHOD0XA9qxJ7FJIooY5Fa4il zcOxyzDI4GOmOa8GCTdmXXd0XZWg0yONJ1iPmkqgdfnkOOgNYdrbGTeqOi+Y+SB1B68ntWvKl0MK ZrXdtokOnP8A2ubmNVbIuLfLFOMYIHPYdKy5zHd2wkt3M09uy4B52IeASOx/+vTNC6LZ0v7DUFMq JCVIR3xEr4wSR6c966+XWILy7FhFE7XluB5oMbiEkgNwcYwcjnNawtYuLSP/1v48rqS7hkmSdHMI XzSvJU55wG64qjK0Nxp5S4hmlgkyhKkIBnPf2zXPTVrGrkrM0LTR4UsrKWO6ha3RjHJaoT9oZUAA J7d+vqK8x1nZJrl8IizR7AYrdV8zyAvByexP61109zCTstDlZJhDKzXDMhcEInVkx0yK+u/2UJjZ a0kwuhcTWU0c7A248yIPcIEk24OQhYk9eK/QvDr3OLME/wC+v1PmONY+04WxcV/K/wBD9i/Acrye O9KnvLe01ErqEN692bjykaR7iJcjHXIcnmv74f8Agn/r11rXwe037QJJYZVjiimEhYb4wFYEdiMs D7j2r+hvpL0E+H8JWe6Pkfo31rYPMcP5p/mf/9f+gv8A4K+eH01L4SXkolnWZFdntRGXURwqkyTH P/XNh9K/jT15tImsdOj0e+kNreW6zTy3UxmfoSeNo24bcMc9Ovp/c/0X6inwtWpLdSX43P5D8faf suKXLuv8ihoujaNbWxeXUHE88jB7udhNLHgZVAoAIBP8/aueuwIJg17b7N8vLzfKJ1XAGO2DX9VQ jrofz9Vn7iJV0+91tCdItPMjhkLyLAxV0VecKe/Tpnn86yb+aKKzWOKP/iYGYBJT96PAYMCfrt/I 1tGKTsiW20LpcjSSRPqKRNeRKI4dpxEwGTwv68frWJr1rPH5knntJdGXdBHIuyEA9RkZx2reMbbi P//Q/JbS5jcr9haJke2wbyQRkxxqcfOT3HQZFbDW0TtHEFjFqWZUuZlZElKjOF4Oe1f7QH+XzaRQ uILqSRLW3s1AYtIzj/VqBgAD8/0NVUttQfMDokSDP75s4b/P9KDAt32jXMOmtqQiaa3guYrSVo/v l5CcKB3OFY/hWtHoVzem0uG0zy9PgGIru4BHktj5mHqaCJu2hgref2NcCWS1F9H5xW4hlJRCnbGO c960r7U31h/MWGCBIVCw2oP3OuCAeT061jL4mZX1sf/R/Jy3tbuKaM3S/ZDcEEF5PMzk8Hr37D0r TFqLWcPO4SVOQMfeUjr+tf7MrRn+V5FeTJcQTpbXbRFXAMqtsY8jgD9Kl8y5tbO2YXMkyDKyI5+X HXdn160N3dzWC0NaGOG40ma/s7hCkR2zHdmVG+n6VhjUVWIx3JkSEkEBQXXPTcQO/NIsuaddrHDP G7meBnLQ7kCtyMD+VNRLyO1BsrRZNQnkxdqCdioMYbHoPT3oMZKW7P/S/L7T7Z4WaZizSOMCJwHj jbnJwR+lO+wafJEgvPOitIZ/PuEii8qWRkOQFPGCSBz05/P/AGZSaZ/ldLRakou7/VNQmuUsRpOm yxl4FuJPPlfAAwPyyTx1xWZbrBDP52ozNpspu/kvCPlQBsAj3Na2vGzMDa1O4+1TxrdWCpJaysxv GbNxexsFKvjJxxnHrmoUYLCrTW5uBbv5yBGMZwOn5VRgt9S1ouqXOp3TwRxwWFvNP5U7ytsYJ0AD 9R9RWL4ga0a/trMWM1i9m/lLeWtyboXQGNpY8ehH45pNJm90j//T/La1smkazfUPNFn9pAjdUI3k EZGfqOa1dTMq67ELSC0stLOEmkMvydMbh+PJNf7NSjyn+Uyaew9tRt9OmC309tbh5dsUkkoAx+P9 Ki1u+S6vIPs90ZRGNyhTtV89WA7j3pJaoG7Ibp0M1vKpjgihiCiKMuwTGeAAB+HWo7/R7gam8ltG EMQErj7skTNzx9etbnNN6GnFea5FG16tjbyw6aUhnMxSRLpJeGyrdCcsM84pwvIEWOS5hjS1TKtE 3KqOfujvjPAoONybZ//U/Nmz1qa9iurGaa3TTo1P2EPaKtwOc48zG7r2zim2AdbS4ktdzgnE3dj1 xn/P8q/2ljHqz/I+U3bUpWFhfRX9zE8k3k3NyJ7+CQ5CsIwqbR26DPXqau6lbskTpbyzr5hEUu0f u+oPTv6/hVmDbe5UtdPsoVF3eX1xY7fklJIa3kyQEOD0OTjOfzrq4rpIo20+TVri8LqohR4/MhiT OQIyR8v+fxCJTs7Mr3WhWN/Ddn+0LOyvUiMqzXId35I4VFBz06HArkrt4opE8p3uoGCxO3liGQ7B gkjvyDgnmixpzNLc/9X8v1ntxHJLEbiWFFIKCIrIjj+HB69q09Da5v5HttsMQS0e82OQjkJ8zZ9T g/pX+2B/kOXJFnFvBLaBGgnImScr8jrnBANQJaRabMdS5yzecYXhE8GUwcqDwORz60GMviZTutev 7jURGIbe2h+zlTtjKMzscqdvQYGeMVcS3ntRDA3+kXMoEjscKxzz0/GgkddBrSFpJIGRidihkKhj 0rK0+WMySRxHz7lP9arAkRhwcc+w/lXQVNLY/9b8ydR07zIreBV3vEFdE83mPb/n9Kd9hvtRijEi 3UdhbbVmZCfKbBHBHrx3r/bqHxI/x3NWa0juLUm9v5nFuQbREQAKvA+bmqMMklpdoqSyyISHjnLk Sls9AM8Y7VsHqJPfX02uShUupPKVWYTqVMzE57nnPFe36HfyusztaxQQpGiRLuO93zhgAeSKunuT XtFH7hf8EqtasV8fvE5WOWXWbcXFyAwWLciqF2+xkr+sO9LSaJJ5yk+ZagFUXO8FR0HuK/zS+kvS 9n4hqS6s/wBLPBLELEeFdCNvhhy/crH/1/pP/gpuJtJ/aD0u6XRpbxrlL6LzRCUNpEkqAZAH+1jn 161+Vuru7zyXG37MWkZVhjyCvP3ce3T8K/2N8IZc3h7lj/6d/wDtzP8AGnxJilxjmSlv7RlJNGvr +BsZhgkHz7mKO6+31rYsLHTjY3EBdVuIWCKFUvKoAGMHp+Gc1+pR2R+bSiuVIwWFxHKpkt7hQRmN miIGAcZ/P+dSSyRyyEXsZlDuuEiBBGMe9bwu1qYSVrEhtrdbmNYY5sOCs0W7dGPRsdeMmpAs0YYR I21WwSBnP1rpSsrHLPqf/9D5Ju2vZNHit7h/NKMQvH3VJyAo9uKyJYliVIbWRZWZVEq5DMnTOR2N f75Rjc/wHKt8NPNvGkczm76MEB3LjqT2x6VpaP5dykUcpLeSTs3uVRu2GXPP405KwuZN2IWN7Bdz JAoWebfEIkG6OVW44yPSnm6nt2hGEiYMpVpV3hCDzx6ZqoxtuZzd9EbV5dwKokjkikllTzZQowqM c5wO30qrfal51lBdwRZnhjEKOse0soOMe9WQf//R+M5xPMYppWYOB/q2+UDOD938BVq2imWUsIwy Yy5J4Nf78H/P81dWZZkmgjktxE9uYrjKXEUkTNLHjAz6Y9Rg1U1K2FpqDXF1Gi20aBFnt4j5cigf KMYyPSqiveRzVFZW7EVwVZnt5rWS2fakkIZcHDLuBP1BB/Go4SBIscykhT8pK4BrYxJJmRZCAu1C Onv61VtTdfbsyvHLGsiso27dqgDg+/Wgxn8R/9L45u5HNy0m+MNI2FWPjjt/KkmnuLa8Hn7dskIL BPungdfy5r/oA2P+ecY1xDLBDMkbh5PldAQzRNkjkenSltogkrOyhiASNw4FdC1AqCI2cYjRmmWP kRO25sZzx+dVXyxZlXiRcYPJX6UF87CwT/WxhdiiXexP8Wf8/pWxYWU93qawxWouVWMyLCknl79u c9x06/hQNz0P/9P5LuE0m7QNbo1uYUIuN0nmgSrkHYe46de5NYhSNvM+wyOX2bZVJKq2K/6CD/nn H2cZaFLnZh9u2TI5TOcqTVnyVuI1BuFtldthkZSyx+5HNNK7sCemhmXcX2cOttIZjGf9cDhHHrt6 /wD6qkjeW6SFg0anaAXC42getbJWViXNLQglsoJHM6u4KEo2WxnPqOlVFgexkWXcsoc7VHVoqZkm 1sf/1PiOSZlKsB8xIIxxTlwkiMQMPyw6Gv8AoQP+eHnd7k8el3tzK0rRCKPH7kySBUYevuKT7Jca ZFLcqqyIGKyxRsCHJ6HH4UCbb3FDXF1bq9qv7yWPK7h83PaqkTyW+fNKySldrjHKn2/KgRp2DT+c zjHMeCxP6YolulCGCZVMiyblkYHzB2IoFdH/1fiUQNBcGeI+cjgE5XIQ/wBCCKvec0mVY5Yjn1Wv +hKKuz/ndckjPNwbJxHLcgNM22AOeW46VOkrRShsqzD5wSODzWiik7i50X2WCf52RYppJfOkkT5S SRg9OKz7hmtirB8sHBQsARx0ocVqx88TZgvnmiLXmHkYbUfO3cfUiqAVfPZpCWVhjb/d61iUf//W +MpLINCRG5Cd27ioo7bCGPcwCjlskFsV/wBCB/zzkzwxLPA0OXEyZfssLAkYJPXjBz71raXO6Xgk 8oOLYGTC8Stjrt/z61jVRdP40fvR/wAERtRivfjRq7PZz2cl7GL6N5FLBwINgX23ZB+gr+sav8kv pRq3iliP8K/Nn+030em/+IQ5Un0hH/0iJ/OZ/wAF4NNe7ufgzLFNEJP7Fv0FvInmeZsu4G3FfQbu 9eEf8Ec3s9P+OUlhbajc3Ms9urzxS22I0Ihwyo+PujcRjtk8nFfsWWVU/oxSpv8Alf4Qifz9wXhP ZfSgzTEpaOVT/wBO1P8AI//X/v4r+ef/AILu+H5tZ0H4V+XsObW4hUc+axF7bMwHsR1+gr97+j/U VHxTy+o+kv8A26J/Of0naPt/DDEUv77/APTVU/A/Qvgz4p8Y2zvZ+H702diSIp7W3luJrjIwQqRI 5IGOpHFWIv2dvGtpcM8fhbW7oBS0U7WdxbxQg8bTlAS3bkD6V/ptX8S+GsHVlhqtb3l6fq0/wP8A NReFHFWJpLF06Fovve/4Jr8R0H7PPjmwe9m1rwf4luIja/arQRabNLAi5Ofn8rqvB69K8f8AFPgD xJ4bla2u9Dv7ZmlDWs88DRJdRtjBGQCCvQjHWu/KuP8AIs6xf1HBVk5vbVfPqeVnHh7n2RYJ4/HU bQW7V9O3Rf0zkbLTrm5vFgaKdpg4iMYgkfBJCgkAE4yQM9K9+0L9nf4meIdPtLqDwXrEdr9na987 7PPMJjuwI/kRgDgZ5xx716We8W5Vw1TjUzOooqW3d/fY87hvgzOOLKs6eVUm+Xd9F91z/9C1q/7M fxKktrVdP8FavqklwAv2f+yp4zAx77mUHH4DgVR1L9nb4p2tvClr4A1pL2x+S8P9kzxWc4GSfnYY X+76HHNf7VQ8XOE6jjF17Xfl+Nn+R/iniPBfi7DUp1VR5lFX0v26afLX1PJZPCV3pN/NHqVtFZar DcFVsHYgQYAABBGcg7hxnoO9d94c+CnjHxxbReJG0TVjc3NqEaG2hkEoAIOf9WRuxjPORn8a9zNu MMryvL1mtaovZP4Xfe6/q/8AmeTwrwRmWf5pHKaMGp3tK6fuq6Tv59u/4n9gf/BMbwfe+C/2atD0 rUtMk0++Egadpo3jluCAwyd3Jxjr71+ibA8Y7MDX+P8A4j49ZhxzjsbGXMpVLpn+0mV5fRy7h3C5 dQilGFJLT0P4x/8Agof8FfiFaftT/FfxPB4K1ybw9qHiG+1J9XisXktJY3mZ1ffjbtHI4OQc56V+ WetJYX4mMB868hfaUbKsmCVYHjORzxX+sfgvn2BzjgbAU8FUUpUoKM0umra+/wDRn+Mni3kGOyHi 3FxxlNxU5uUX3Wif3H//0fjK5/ff6LEVLLIFZXHQggGrEkbQW8KvDJI/m7JEgQ/IvGCTjjOfwxX/ AEIeR/z3kiK+9ZjGywwtwT8zIe2fWrBlcyMsTnd1z3P0oNJ9Df0aIWfkX2LhL6zm+02U9mQt5asG UllPX+BSR3xX9xf/AATJ8W6/4v8A2VPB954j1S+1a9tZ5LaO41GQy3UceFZIyx5woPAPSv4o+mPg cPPhjD46cf3kZWT8r/8ABZ/oX9CjG13UzLL3L92lGVvNx1f/AJKj9BWGcDJHPUda/n58Vftd/tAf Cr9p/wAR6nJF4h8RfDzS/E1xZXejz28g066slcxybG24BHLA9iBgjgn+IfDfJ8tznEYzD5jbSn7t ++u3Z7a9D+t+Oc3zHKK+Bq4K/I5vnt2Vt/Lc/9L+6/4U/FHwz8YfBGleN/CdwXsNSixNbSMDc6dM APMgkx3XPXuCOByB+Fv/AAXosluvC3wjiikWO9vLia1R5QTFDGtxHIznHoQCfZK/o/wPwdfK/GPB 4Wovhl+HNFp/dZn82fSJqU8b4SzqRd+Zry15J3/X8j8HPCH7PnxC8aafa61p/hHxBqFjzCt3ZaXK 8F2VXcHUEBiDnqK62L9jD426r5Msfwy8WRpJIVMcXh66kcBc4dwEyAcda/0bzLxg4ZyrF1MFWneU NHqt0fwDlPgXxNm1CGJsoKauk03o1fXbX+rnB/ED9nT4tfDjSnvPEXgu8stGSIy3l5Lpk8Jtlzxk suQfWvnjUNFLiO5LK8JjDRur7gy+oH4d6+x4c4ryvirBfXcsqKSTs1fVPz9f61TPzPjDhPMuD84/ snM4NS3TtZNeX6/8MZMOnpPJMIWVPssfmlWGAwBAP8+lexfCr4ZeK/FOuaXq3hLTNQ1zU7e8inWw 0yye7nhEMyON4UZG4xgf7prs4nx+Hy3IMTi8VK0FCSb9VZfizr8OsuxGZcaZdhsNG8/a05fKElJ/ gmf/0/67f2av2prq4+H/AIb8PfFH4e+LPB2p6Hotvp8d8mi3NxY3iRRKi5UoGRgFweo6cDoPEv2+ f2y/hN/wpLxt8OLD+073UvE+ktbNLe2j6VZwBGDNksMkgpjbgZPHODX9DZDw/LH+LFNYWV4Ovzp+ sm7W76+j9dD8J8W85hgvCXGOt8Xsox08uW7/AA/TzP443tLaCJJpLeExz54hyFkXoWPuaY0Om6kq /wBm3PlXEfDKsJZcevbniv8AXyj/ALvH0P8AHiK/eL1P0/8A+CSPirX/AA5+2F4C8P6fqdwmla3K q6raWYMEM5AdWDRj5SGCAt6nn6/2pMMMa/y6+lrhaFDjynVoxSlOCcn3dlv+J/sB9GKrUqeFOEjV k3yykl6Kc0l91j8Tv+C3kNw/7POgSxSSGKG9u3lto22GUg220k9gPmzjqK/kWaI6nNE1om1Z8FQr FuuOSTX9TfRPqW8MYQv/AMvJf+kr/I/hT6T1By8SsbJ9l/6U/wDM/9TlPh38B/iF8Tc2vgTw5faz fWcOy4eCxmlhJAU7QyqQWIY8ZHr2r3W0/YE/amezEc3wh8VQT3C74p28MXJs4VJPJPJY4wf4a/20 4g8XOGeHcfLLcfUftI6O1rfi+noj/FLJPBvizPsBTzPB00qVRXje9/wWz9SKL9gP9pRCsafB7xrd mNzHNJB4ZvHjnYdlwPlH515V8W/2bvHfwuMT+O/AHiTw5AsCF2e2fS0tmYHaHDpg5x071yZP4zcL Z1mtLKcFP3qjsm7LV7K1/wBTpz7wU4o4eyKtneYRXLT1aSe3r+lj5nbQrxbmGOWEpvmVQJH8oMuQ eG5xwcivS/BHgTWNb1iy07SLC+1nULm6EC2VvA8iBerMCoIyF5z+lfpOY5nRyzBTxuIdoRV2fnXD GTYrP8ZTy/AxvUm7L9W/Jbn7A/sK/suftB+Dvj94L8ZyfD3xp4e0OPVInkvptPls7S4jRcoXfAU5 7k9Bjmv6x5PvnpnjOOmcc1/lN9I3iDLOIuLYYvLmnZPmt3dtz/YzwQyXF8P8A4bLsYrSjp8le34W P//V/qL/AOCy8ywfscX8xkjRofFlrLH5qeYhZYrg4K/TI59a/i9t7KW3ikMrxrFFCjQICckBRwOP yr/Vz6Gv/JvKy/6e/wDyR/k99MpW8Sk/7i/9JgZdwqThlwF3c8dhUySRvAP3jSTw4iDMOAoGAM+3 Sv7EP48p9SFDuSaQRglTsLEDGSD/APX/ACpEtESSC/hlSS6RWRrYqzFssCoxjByQMAZ60paRbZvT i3JRR9/fBv8AYJ/aE+JVlp/iS1+FPiW60281C2vhdR6Ncw2qRttkV1ynQDAORjI46V/a98B/DWpe Dfgx8NvC2r2a6fqei+F7ezvbNV2+Q6g8EeuCM55r/NP6WfH2V8T1MPlGWTuqE9fPdXt21sr/APAP 9XvofcB5hwlwzisfmcOWpiHzJdlaKS9dLv167n//1v7tPiRpd1rfw78d6LY273V9q3hK/wBNtLeP 780k1tJGqr75YV/EP8df2MPjn8Mrvxl4v8WfDTxvBoMt/Jqg1WbR57eG3QDLSPvUKRgD7pPC96/t f6KPGuXcK5hjMJmE+X29opt26xu/lbX1P45+lnwNj+KssoZhglf6tFyate6Snp5Xvp6Hxhb6ZDOJ J7TdcRiTyim0hkIAJ4IHckfh1r6e+E37JHxT+OFu9z8OfBHivxJHBO1tJc6FYNOttIgG5hJtIO0k A4zznHQ1/oDxJxhguEsp/tTHv3L23t3P8+uEOA8dxpj1luXq0krt2ult+Z9Er/wS/wD2rsSxRfCT xZGYo0S3muNDe5ZnOCzZEa4bj73TrxVf/h2L+1lJdiKf4L+MYHeEPNfJpch86RB3G07VIGOcmvy6 P0j+FeezV1/iR+q4j6MfEsfdhU++D/zPlD9oD9mf4u/At7aXx/4B8SeHoLl0t0l1KwkVHdjgbG2D j3YAZ4zXzq1usUW18neDggHg+h9x6V+18KcVZbxdk8M4yyV6bbTXVNbrt2fz76H888Y8MY7g/PKm Q5kv3kLa9Gns1+Xquq1P/9f4+xcqNjNmJW+VW6fgKi2xxwvJGp80vyoxtx61/wBDLd2f86zdnYjS YKhLrvIPGRg8+tPXymjkB/5bjaSDjy89xSeiuNK+hMlv5BjzukULkE9a6Sx23KiB125IMewFSW7F scmubFO1Ns7sArY6nbuf1lf8EN9W1TUPgJ4stbySY29hqUUYhkZtiOPNUMqnpkI35V+3qfeX/eH8 6/xd8b4Rj4n5lGC051+SP97eA6k6nBWW1J/F7Jfqf//Q+8/+CrviTX9V/a08VaJeanf/ANkWNrJB p1vJcsbRSkzKyqhOBhTg4x0HpXxT8J/2bvi38ddXuYPhh4G1jxHPbyeTfXTWc8tmudrHyyiNlsMD z2OK/wBaPCziDLeDPCzB5jiEox5FKWtuZ66+v/Dn+UXitwjm3HHizjcBhbtp2Wl0lpp/XofU6/8A BKv9q5iSnwu1IXU0ge6kNsIrdsAYKb0ODwB8w9apQ/8ABJ39raWZbeT4VahA6kg3b36vFID03AKF /LGKKX0luGNXOzXS0l/mzgqfRa4ocLQ5lLs4P/Jf8OfPHxo/YX+O3wE0+51Hxp8NPFWn6as5337O 9zp05bnEDFAG24YkA9AcA4r4ymiieJWxsDYx5o8tl+o7H2r9k4N43yvjbKXmmWTvFaNXTt21Xc/D OOeBc14DzaGT5rBqbtZ2av30fVHc/Dj4b+Nfi1rEXg3wTpV/4g1Ke8igj0/SbV7jUFdnQIBtBwTu BG4jgE9Aa/qr/wCCf/h/9r39nHwHF4E8XfCHXda8JtcC4tLe+mW11K0L7d8ofbncecggA+nQj8B+ lLnGUT4ahw/i6i9tK80m9tVZ790nr+p/U/0SMnzrCZ7iM/wtN+waUG7PWy16a720vZ37H//R/r2/ aK/ax8WfC34beLNTuPgb4xtJm0C9t47/AFBXn0e0doGVXkZY1DKN2SAy529cZI/ij8aXVx4m8e+L vE12IrGbV9QW7uy5ID71BXb6cN09q/0a+iRlGHwcMfmVKqpOXu6W8n0b7fif5zfS6zPFY7NcuwNa m4xinJXT3Ta6pd+z23Pq74BfsEfHf4/aLba54P8AAPiC4sJIkMutNCbXTdxJ4idhtYYwx3AHDADP JrtPir/wT5+O/wAIY7E+L/AetQ2t1K8C60B5tk7gHYu4Lt5xwAa/csx8buH8s4mlw1VkvaRbTfN1 Xl3/AK21PwzAfR64lzTh2PENKL5JpSS5e/d6/wDBv3ujpvhv/wAEuP2pfHmkab4ns/AQh0u8zPC9 xdGB5Ux8mFKY+uGPpxzXQ+Mf+CT37XOh6BLqcngC31K3tS8lzFo9yZ9TEfZlgVWztHJFeJU+kfw1 h83WAny+zUuVvmV73tpsvk/S6PXl9FvidZDPM/edZLmUeXSyV7Nav5p6b2Z+XfiLwdq3hjU9V8P+ JtMm0zWvDOoyWs8U8TQNIwHBUNz3wfQ/pyeZWX94Bt3ch+r1/RmVY6hmWEp4/Cy5qdSKafk/S+vR 9mfyzmOEq4DEzwdeNpwbi15p2P/S+SpnsYLuQwwC2mhVQDFykhA5Y+/+FQrMrN8qAtIcbsYGf8iv +hFLS5/zrrVFs2rBcl4zkYKE4INew/Az4BfEj49+MIPBPw18PXOv6p8s+ora5H2GNmCoCQD8zE8E 8Dv2FeLxBmuGyPKK+b4t/u6Scn+i+bsj3+G8pxWe5tQyfBq9SrJRX6v5K7t5WP6Iv+Cen/BOb45f s+/Hjw/8SfG+hx6fpWnwGObzdTim8oNE6EhV+bPzEYIGSR0r+h49T9a/yL8c+NMNxzxa82wrvFJx 8tLbeR/t14O8KS4J4EwmQSVnBK/fbVu1tb3v+R+Xf/BTn9k/4i/tTeAvDei/D+ztr6bSboNeW73K W87jcz/LuI4BEZOMnjpX8rv7S37LPxa/Z31GG1+IXhPVdHNwrz/bZLSYWpjRkClZNu0ghvvZOenY 4/or6LfHeXYbAw4MrytVk3JX7vXT120vrY/k36WXAeLxDlxnRjeKtF27LTX0tfXS19z/0/Xv+Car bf2wfhI0M8gOqatbwSMjH5kYyBT+Of5V/co33jX9lfS2SXGeFfX2b/8AbT+Yvop3j4aqD/nf5yPz I/4KgfC/xb8a/hH4W+GXgWyTU/Eeua+7R6e0yxGeICJWAz1J6CvxG1v/AII/ftP6LodtqsHhDSNV lt4Q82l2dzb3upxhFyoiRXJLAjsM816Xgf4s5f4f8LxwGMavVnfV2stfu67nwnjl4P43xA4mr5ph Oa9KC+FXvor6bvZWS8z82/HXw41fwB4nufCvifSptK1uyu5UmsLy1kt7uPyyB+8jdRtOSRjJ+6el eh/An9l74o/tEeJ5tA+Hnh+XUbm2YNctM/l2gQ4wWIBIU9zxwRX9rYvjXLsFwtLil1E6Chzb6bbN 9LdX0R/EmXcA5pm3E8OFaNJ+2cuV97Lql102XfQ++R/wRX/adLme1i0HTFuEWJ7aPXbeZYQf9Yy/ NuVj2OeKvR/8EXP2mrKbZaW/hK+t2UoW1XVLe6uiMYzvd9u7uCa/Aav0qcojBwpwV9Ve0vwtb7z9 5X0Ss69rHnm+Xe14L77/AJH/1PrP40f8Eof2kfhP4Wu/ENz4Oj1rSNMZ7+/n0XUYr+WFACzE+SN2 OOhBHv1I/LXVdKurV3ZUaKOKQQNDPE8FzHIAN8TIyghkzyCK/wBqfDPxOyvxFwM6+EklVhvFPp37 p90/LXt/iJ4o+Fma+HGPWHxcW6ctpPvrp5rR2a7PtrzUzCN1BXkHMn96rjJBO8MxkAKoQlvzuYLg bj9Miv15LRH4+1+8aMqSMW85kMixxu4MjsMqmT1IHP5VrIilygmVnQZWVCQMYzn1rOe5UItaH2V+ xJd2Mn7SXwdjkvpraex8W20U0kYKyyebKvkhMf7Sbc/7df3toDtGQQxALAnODgV/mj9ManycXYJ2 +x+kT/WX6IFZ1fDGUX0qS/8AS5H/1f66/wDgptfzWH7MurNBK8cs2vWkCiNijPlieo9MV3v/AAT/ AGnf9l7wE9yWMzG5Z2ZzITmTI5Psf0r9Pw9KnLgCrU+17a3/AJLE8BV5RziVLp7O/wCJ9beJdg8O a/5hAjGi3W8sMqB5Emciv4mYP2bPih+0d+0r8RtB+Huj/bY38SzMJ3k8q2hCs8Ue/PGCIxyPbkV+ x/Rw4mp8KYrNMyxE1GmqabvtZNvvpsfgf0geEanGdDLcrw8W5ubtbf4Wuz7n2lo3/BFL9pG0sLl7 vWfB73l8gZkXUY/NsyOQqHzAmOTnIP1rSk/4IrftCXETJcap4MkVogrJ59os0jZ/ibJGB9a/Za30 osDKd6EVy+al/wAD9T8Np/RZxUIONZy5vJw/4Ov3Hl/xP/4I+/Gf4UeFLnxdb6fZa/aaHE13qdnp F79vlkiUZYqoYlAvThccDNfl1q/g22069vtO1uzSwvUnKvZ6i6q0BUgBcEZGCM1+peHni7gePI1Z UpqMqbtb5X66/cj8r498HMbwPiKGGnTclUW7d9W7W006Xd2f/9b6r/Ze/wCCcHxu/aD8Lnxb4Rs9 HsNFubvZBLqd5HawLErYL/NzluwxngcV9o3H/BFr45xgiLxH4Sv1WBVjgnuo44Uc9SAMZx7+lf6Z cWfSKoZDntXJ8PKLVN9m389bJ/8AAezP82eGvo1YjM8op5njIyUpq/xJL5K17d7/AJmdL/wRL+PU +nXFi3ij4euJlLMbtixJzuCgKCMA+pHTrXw/+0P/AME6vj/+zDpqat4l0221bQ7lHt11TRB9o01d o3HJUkgqoPyEkkDOK6ODfpG5ZnueQyfHWXtHaLV1b9Gl8nu9TzeOvo4ZnkeTf2tlkW1TXvJtO++v dNvRdNkfn0dMmtlE0EWYZmMg2fKmcncPwwfyra06zjubvTL6SKSNtO1CGWLy+RvMsafMPTBI/Gv6 JzWpz5PipL+WX/pJ+D8KUZUeJ8CpaNVIfhM/vV/ZUtvsv7PXwpj2su7wnbzBWzlQ4LAYPIwDXc/G RxH8KPiI7SGIL4Qvz5g6p/o74Nf47Y3/AJLqp/2EP/0s/wBha7vwpJv/AJ8f+2H/1/F/HV7MfG/i 26eaad18UXceJeWcq+3I9F68V5+mmvI5Msm2NmJMrPkr7Eda/wB1eE9OHcCl/wA+qf8A6Sj/AAd4 9fLxRj0v+f1T/wBKZlXOnFVkZpguQfJJBBlwcEioLKWKAssgMuFyA43Zb8e1fUrufE+Rn5meXc7g 4kLKFG0D0GM1c2kOpKZGfXB/GqM5uzRDeTOtxISEjiIAjRSWwMc1es763ijGbaMsoxwMZ+tBMdGf /9D4zMct1IUixJI4MjEcbQoJP6Cqc0cs1vsaZw0PyBAxBUe361/0AH/PFs2PjguJ4Yod5yvyqS3a rO2ezthZsxcb953Hcw9j7VSlyqyLi7ohZVC75PuEZKZwTUAKShmA8uPsCckVfOrakzdtDQTyxbbB IQWIOAcBsc81Tis5bhpgpwq5d2BxgDr/APqqZSvsKEktGf/R+JFj2yq6gSFPl3Y5x/kVeS42g7QU 3cE8gV/0Att7n/PPdWuTrJNNaT2qNuhZladRgPwem7r+VUpooVuT5MZtoyBsjViyoBxjJ6/zpGbm 76Bi3t9ouI52kuJC6SZ/cjAAwas3k5ljBUlQo2iIZJwO+aPISm76mfa3EhZg0DovKhnGB/OtDy4o woyokYcBccVnKXRDn0P/0vju2f7Msi+ayqw2sSSN2eMGo443jkWS35YNuKMMr+Vf78H/ADwJtMim uvMfMed4POCcZp77mIkJwccseMUHRF2d0JsVHj5QgHMhzjg0oe1gMp+zvJGxw4jOGxxkqT0PHWk1 oaqSZXcW07s0CukKY8qORg7qBgYLAAH8qLdFWZZZYw4ibcOMgY7GsCj/0/ju5uLmYSNhWA+cKSFB x2x/nrUenKbiRTMiqoUymJ/mxg9se5Ff74H/AD7Rd0Qyz7bmUAfuiSMbfujNXrixs1Fjdi5ZpEcT +UrfKw7bh6exot3FLaxftbtY71Ga3t3adtu6aFJIQCeTtII4+lUdRg8ppdgWJixwq8Rj8u1S+Vbj imlZjLFZ5UlhtreS8u4ojMqIhY8dzjt0/Or32XZbtqwYrdTExXNsSSdpAz2xjJIP+FO62Gf/1PkC 4+zy20QRBAsbEzAHcWPTJPp7UyG4uVYiMNF5PKO4BVxjqBk/rX+990f8+zdlcl8sqgkLneSW3yNg N7Cq13H5qRGMyDLAhg3ygjGQfUe1ZSab0JjJ2dyG3Bh1BJppJysa5VA/7sHHoaleJzPIwj+9+8+Z sk1Iozvoy/PdavcTWdtEiBYEyIo7WPayrjhztyeB1Jz1pxnhkiigWzitnhYo5GVwO3HQDHYUW6Gs ZNbH/9X5KtDYuJ9rN9rRssm04Ze2D09e9Vb6UvFLaohVHxtcD5hjqa/3jlG2p/z+qSehu22kLDp8 FyjCYTrvIJ+ZSAOMfj+hoiikbzRbyrbweaMQu26VsYLAcAHPSotYtNrYq3ulX0sV59hiJWEmZbct mcxgbiAcc4/pWPZ2SX1tvkaWCWJd8kcoAEY46+h60Gyd1cu2MtzFcGKwtnvTAmDj5lRSeT6UuoXc V6Ehktwph+cuOSx9PbFYySTsjaN+U//W+T9LtfNna6jncS26eWsG8mNwMnpTJoh9ta7aEW/2jAEH JOQMEnPrX+672Z/gjD4kasUNrGhubhSkMSky+Wu52x0AA9wPzr+uX/gldZPZfCjw4/2doY7y3jlW Bj88apEjjOM5I87v3+lfyp9KhpcDxX97/I/uX6GrceJsdbrCP/tx9n/tnavHpfwh124feQLf7PGk f3pCT93Hv0r+IDxxcpf+OfEVzbTvZtLrEtysUcn7pPMbcDtHGTk5Ffn/ANEig/qOLr9NvyPsPpY1 0sZhqHXf/wBKPzM/a6fzp9TGryyhba+Cy3VviBm80hVKgdO3GP4q/NR7SyS6kmSSW4G0Hz5H3ZYc Z/Ie1fH/AEs5/wDC7hafaL/JH3v0aKLXDEp+Z//X/k1eWW5+bZuhQ7Rg7ifwp32cTYjntF+X5xM2 VZB7VwNWdmdcY+60R3Udtb2rTRFhcdEVvu5zWM0haAlyGZuuegP0qJL3WJwadkNge6YfZkuxawse Jo+dueCCKoX0WpWMKxxGS6/ej96y8Mpbnge1YlOHYmaJ1RWBbK/N8x4Oe1aNpGXiMkjscZ8tj8xT 1FRPYlxaP//Q/kVWQXqyxDKvA5UiRCofHcVRNvOo+aVBIw2z7e/0H4V8+dBNFdTQxuJN7rCu1Ttw Wx0/lVFJfM3SOnL/AHVJzg89aC4LUnNnFfW5YPJBIX2S2wQiJdo+8jE5P5VSudPVZt+5yRHtSQHB JHqO/f8AOg1LyqZN0Lbd8cO4DdtBxjvWnZTkWwiuUDljhJyMMpHb9RWDTW4H/9H+Q6R0Mw8tAoTh yR97FJczST2vlwqSvmbnX7oGMjI/z3r5c9AyrCe3iZ0KDzd3yB0ySR6enSr/ANtbY4ZR/tKv3QfS gCi1xcmOCZGNnLC2dpUSAf0qC4mubiWaZjE0pUEBF8sE+4FAD4Jpo4TvWQyMepyA1WDC8ybwTGwG QVOKCub3bH//0v487eW7tiw2K+5sAt94e9asF/GYm8xSrqx3ADHIr5c9Aybi63SIgLMjtjJ5Aqzt MfCDcy/NuAzigaWtirHqSzziBtgdG2/NxnHXitA28sUm4MNpYOVP8f0/OsHq7lz6ElxNAi+VPN5a O4OQQB9PrVJ5YJJ4444/OUHa28YUDpn60i1qrn//0/5EFgtJoXQIitt2nbgPWRYlbeGaABpDHMyb 24JwelfIJXdj2AWR7l2jBZQvBH0qaeRlh8qFMyREiWTqCD0A+laqKTujdW2Rn2Mc9w4VJ23xy/vU C4weo+vWugu1eKGL57WSOOUC9WVxvjTB5UdznH4Zqh2MqS5021uViEJilmICyQIXjkBzySOB2rpr PUhaXLeZHb3FoYjGUlUtHLxjPGD6UC5Uf//U/kEN6ZJ38syxy8kKqsbYAcYLdMjNPguZ5y8DRBSi ZEqnPmHJ6jtjivlz6AuCGRUVrnGG4Yg/dqwZYY7cyowkRW8vg5fI9BWcpLZAWYWxC0pXH91u1QDU f7PncmNZ4rqAo8TsUTPbkc9eeKzIm7Kxkabf308kyXUcSNFISPJcupTOVzkDmtO8gvZIHutLNobt 0KmO7kMa4XoAR1zzxTu73Ep6an//1f5D1a0tZYnK+bIuDdRxsRHKcDMajHXqM0q3NlJaS3Vtp89o qXDR/Z5WzLj+8PUV8utUerUbZchuvKXdISYsBlBHP0q3M6PHvjQNlM+WcKW4rSnJppFJ2hodB4FR U1m2uGNxHFF88m1t1q5Lopj9yASfwr9bvhp9nHhSzMWoSyQwWcbXXnoQsTkNhEX0wOvqTX9S/R1p c2YYqp2ifzn4xt/WMFDvL9Uf1wf8EjNKEfg3TLuaOGObWIGurnEQR4dmWEeB0Ygrn8K+6/27LyCH 4Q+II5jIrXemTFRE3zYWOT5fYEgZNfm2cxlPxgq239svwt/kf0PWcaHh1hk9LUV+p//W/M34l+IN vjO5ll0+H7PZJLZsn2g75Ugbhmx0b5jn/dFfkH+1i1lrmt6bDM6wW1lZzRLF5mZyssvnIzdhxIo/ Cv8ARDxNn7Lw+rxf8iR/JXhw1U42nPvJnwPrtktncG3jkW5gwClwuRnI6EetTaVArLGm0M5PLY4F f541fikf1+m7o9N0hp7cpAvlmJFJYscNz7elTOQ0rxW8yTMk26Qbt4B7jPavOqbs2L1mIUlmgJZn lOFkZtyxE+g9Pb3rfa2Zlhy0ZmhURgqAhcAYztryqz3QH//X/kl0K2t1sba4RZ0u4GdZWVfmcHGA h/p7Cuo0uSaFL5bme5kuZ5FNuspDwRKAc+4/xr4Or8Z6dnym9YYLbogRdwjzAPUd2zWhc67ekWst 3ElxbwlolUAS3Ccg5wOSpFc0pNuxNmnY5671K6thdXtnJFc5AQWV0o8hO+MAZ5HftW/DqsWqaDpM lrpTaQXvS2p2oZpYlwColTPPzHP4Go2C1tGYNzpty11PeWhuJ7C1nUvCFXBfdhNwPXk8e5rv51WJ IbcWnz3YUSt5G1wQOQw7Z/pV0nroEd0f/9D+QBGOzbDGr5O1mXovrXMmzghuLyZj9nnY74pGPEz5 6EdhjP5V4UNypx5m0XysV8q208h+2woJ4D5ZeJARhlVunJP15qqmnParGpRY1jJdpjks3fHv9a1M 4x5SzfmK6tIzCI2TOx1ZgD/3zTPsVvZQr5FvEk0kQE00f37gclQ3sMnH1oKL0FnPNGkdxtUIPuyD IBP3eKvrLd2Mclgo09roR72u2QK8oA6K3r1IFaU+oH//0f49ItQuLp/sDyPPJApfeYiVCk4wTjHH pmqOoRSfZXTfsVBkKPlQE1hT6Et2TIdBmS2slSSViFdiGlfdIxJPf+Vc9rqQWd3eal5I826iVJBF 8olK52uR644/AV109JGMm2jx+7uUubgzozq3mENEfvjnpivsX9nKfRtP8QaXq93dsXs7iCwnWxVh cI1w6eVEwPXcy/QFQc199wHaPE+Dl/fR4PFT/wCMdxK7xaP130m3jjuI7yCJ7qRtbgmR49y/KLqP cBjoAFPPbmv7zf8AgmZqsGofBjR3jlZIY9LUCFWLhZXcu28/3gZQPwr+mfpIUPa8G4Wt2f5o/P8A 6NtRLE5nRfl+bP/S/pk/4Kj6R9v+B+oWkGDeS2M9t50rlAfPgkUKSOdvzAV/EZf6ELy2hsPsf2K9 tIBp8oVdpR1GDkZ69z9TX9ufRaaWQYnu5L8Ln8n/AEio8vEUOVfZPPpdEfT7OXUtTv7eGBLkWken lXe7kYNxJgAgL3Bz2qLVbGWRbRp9Silt0hZ7S13l59p557KM4496/rin1P5pqzskTeFtUWytp4bo eVMSW2cjAOAB+VQ36W97IbtWWNEuNywLxklSCR/nvWsVd2RUZqxmXFqZo5J4meL7Jh0lQcqe2frV OF9Q1a6it52d4gv+qIAaXaOMnrjoa3K54n//0/yfuNSmVBY/YJmkc+U0kMGXcZHBfPQbQfTipbjS JNPm0a8e7nlntt0sdoyg2rq4xgr37deMiv8AaDY/y6lK+w7VdSubIq/lyqrEKxiTc0Ab+L6D29az dXums4dLe01FNQju18xxLH5E6EE8FR3HBH1qZS5SBP7Yu0he0beI5WE0qDJG5eA2PUAkfjT2vo4A LuSSVYxhpWkLPjoOnb8Kybb3Mp7gLr+1EW4F5brHI4UI1tvZVHQdv61WlS4tb24u7AW13qoiIaGa MbXTn59vTI6j6UiLa3P/1Pyd+1XZtI5ppLdbyNBLOsXIyM4PP5celQPrM128UrRszY+dnTAJHTA9 K/2YP8sk0oj7m6kJ2JYw+aZFcuxZI2QkZHHHTPbqBWi17Z3VvcwofM8tVIi+7uJwGUN7c0JX0RSm krG5pWn2sNnPPY+Y1rb2yveRuMeVnAPHfk8VgJdrb3jNbWcl4GXfao8e1ZN3QDII496pQb3LTT2N LUbCdf7NuraLy2+9cbRtXkcjHfHFX9OlbTDJfG4MlxMpR3ZNr4PAB4rVKysZykmrI//V/Lv7bJHF cSTBY18wv5q8Y9qvW+ptNAbWaVHs/KE0aNbgXAf+9u+9jnGK/wBoLH+Vc+xJC8d9d2lm86vG+BFK m4LaEk5L8cAck9R9adg/bWtJFguUtZSsky4lVwp4K/XGc0GT2Y3Uk0y5vJPsMk9nIzowiuD50kqg 4K5AHHXtwKnnsdUhV4baWKaIKSZbYh9oA5GT+NBgZumXtkJ7q2njubaSKDfHLLCfJmcHBUMOh781 da1t7sPffaEEkZWKKF2yWJySy8dsDr6igd3ax//W/My2tNRymm+a/ktOXVpB90sOW/lx7CotTsms BKt7dvqdxLMGBdQIYlPXK47cfjmv9oD/ACgTa2NT+z/D2qWkdoll5tyIwTcSfP5WO6L0A7fhWLJY S6ffwsyo62mFlmeIZER/ujHJPFANt7mvObFdQkgt7iW6tokS4Es0BiRQTn7vPQjH4VbuLzEk08TT TKY1QbuhIAyc4zjrjPYUGU+wsl3p406aK4ljMN0FKAfMJHHIAPtz+VcreT6XdxRw6gHY+cDpscJI kSVR8rMf7vXjvTSu7HGf/9f8zIbSzWzKPMpuQN3lYPy/5xUFrqVxBF9nijVI2fEzL1fHQ1/tQf5F z6G4bvT4hIft1yZ25kxGXjk2jgAnv279ag0/V7q9hSCaK3+zxXDOfn2yygkAZ47D39a1UE0ZiapH HcI8LjdEVyYwmQ3p+op1hqNvHGUuE+yfYIgyMynzJzwAFOMk4IP501FJWMZJ81ipJqNje3kjNcy2 UnljyYlhMnmYOPmboM1r6XHp88xllVepgWSVOhzg4HocCqt0Nl5n/9D849R0yeK1a93TMksxto1S MhiR1bHUg+tc4ltc28bx/vVkuYWiacDawVuGAPY1/tgf5BSbTOhht4o7SxtReTm3tIVhhilbIBwA SccDPP51rSwfaLNLYs4VQQrA5ZD1+WqiruxlJ2sc59ka91C1W5mECRkQmVk2IwU4AY4/+viti7LL LLcTeUDHCotrhTheBjJ+o4/GqUU2UZDT3N80vnXMsqrbF41wDGSOmfY5xnmrmjxX72kYh0xDcXCk 3JtiJAhAPU9v5VoTLSJ//9H82raKC/KXDsUlilKAkkAY4/Hqas3pvI4JraFnmhJD4gbavuecdK/2 6h8SP8dyjdxlbE3NtJI6qFjlTbvcscbuB2Bz9KlitY47a3uZk3NjID4JB74rYBCs1/dJJbyyRLDt lLo2HYg/dBr2nSUvUhtWNsLyNUXyZ4gWYFgGZenLAtzV09znrzsrM/YL/gmd9ls/i7p8dlcO8zXM Ul6k5HlrLiMxqR05O0j8a/sAt4ZZtAUPy/2JcAN1O31r/OH6UUHHjqnJ9kf6QfR7lGp4XpReicl/ XzP/0vsz/gq9YpH8fNLdZkVYBqEMkTTEuCWi2LjofmXOO2BX5HTWVvLqqRSQTv5uWMcfAbrzkg1/ sN4MS9p4cZW1/J/7cz/GzxTXs+Nsyj/09kVn1K4tC2mRhfKEm07kDSDtwe30piG001fOuJgGkJKg /eb6/hX63FapH5fKelkQm5ivLpbhrkIEbEbxt+7ZCMY/GnXNgvnWolyFZyI2hQEOT0BYfSuiK1Rh OTWhRvoJLW4XyrhopfL5HYfj/Sn6dceXHNBI24nkMx5J7mtzmlLof//T+N3a4IKGWRtjZRSc4+lT RNHbljOsRuNQJa4uWGZEPYfj6+9f7609rH+Ac5fZRmz/AGa3lZ4xucHk9dxq24aYLiPytqhjtXgN 71ZnfUSOOZoA95dhbpF2xOg25I6Ac03zZXiUzKJAnyCTHUjv9aAbS3NDStFl1CZJVkhMLRl2d2+R QOx/wFXta1GYQm2lt4rOGyRU8yONUWUL90gAcfXvigV13P/U+NbVlvbiS4u7gsgi3RqP4mHqf89K rzXU0jeVA0gVzjYBwwHp71/vwf8AP45roWrAi3DYz5uflVhk59ga6Ky1+ECS0v7SK9W4wDG58sxk Hhge3XmmtGc83ZWK+tT2tvs2wCPUjjzFSLFuU24XBPXsOPxrJF0WtomuISFklK+aFwBt6nH5fnVx k27MyK5eKR8HIiPCknmmti3LuEfd93p19K0MHuf/1fjK0hg/ctdM0YkclnPLRjPpSgNO5wGl29eM kAV/0AH/ADwtu42RAuXhXy0TBfA68+nv/WkvGzNGsReKPIJMnBIx1IH51Sk1oVztsupAsMgnEaTy gZBKlg34VHLJczQTxxxxQRE73Xy183OR909fwFaKSehpdLcYLVoyBCHlZ4wzqEIdOOcj25qxb2U0 gFxvZIYGw5VsMT3FUS5JI//W+Nrs28EiRW9xJL5pLPE0exYQuAOg/wAaiRDAzzbsIR1HBPt1r/oI P+eC7I4LxiJLeRtkbtlcDGPepGZgHgR98QOS2OtOO6BNrYRDFbJnOZGO1csMY7jFZ5STexSUQ25B BcjhTjI/z71uIv21w9tYxxXJt7uKcb/MRFEinI+bI57D86rmSO4d1C7V4C5HpQB//9f4xSzMlxHE JEZCoO8AgDjp07dKqXMPnSE28u4RtskTqrY9DX/Qgf8AO+XWv2Vo0IwoAURpnatPubn7ZvjWPYyJ n5B8rnpyPzoArRyXEUW3zhFcbdoZFxnPUCqpsG3mZ5NrD7zOeKCZSsjZubZNOh0+4tr6G+lu4911 BbsWa0bdgBu3PXHb8ial5B5kzXchYyonlopPyRgdePXjrVRTbMT/0Piu2cOzx5MeR99lJSrDWE0c 9vFFcQzNJGXmmGUjQ9hzX/Qulyqx/wA65l6rb7hFLt814pArKADt9xWlHGkkYDjC4CqG6+mKYETY WQxBwuz1/Oob7MogR4+ByHU85HTNJ7MCcWmABKzELhgUJGPrV8Pb5Ty42VTwd7hy3vnFYFRk1of/ 0fjlZpEd7Zdpt3lHQDJxxnP4mp7yFoEgkUrIGOWjVv3gAOPwz/Sv+hA/54LtbFxpHvYhIIYYvKQR YVFiPAxkgdT6mrGlo9pcCVlXM6vBE5XcFJGD+OGH5is6i0N6crzij95/+CLVs1t8Y9SuZbl5rjzr e0KMgi2q9s2PlHbBPPtX9Xlf5IfSldvFGv8A4V+bP9rPo8wv4Q5T/gX/AKSj84f+Cgn7HHiH9qvR fCh8K3Vha614bEsCteXItWaOSRZCAxUjBK89+Ohzx47+xP8AsB/Eb9nb4iQeMvFF74dMC2nlSx6d dm6mJwfkUYwM5yW5z+teVlvifTw/hrLgqsveaaVvNJJ9u1/nYWV+G0MD4jV+MaW1XW/m5SbX3ydv K2p//9L+/ivy9/4KHfs9az+0Lqfww8P6KGe5tWnj8oYCN5sq/eJ6D90SSOgWv0bw+z6nw9xNSzSp oop69E7p6+Wh+b+JfC9XizIVllO1ufmafVcso2XneS+V/R/WXwC/Zv8AAHwZ+H+geGofCXhmTWbO 0A1LUjpMFzcSSnAYCZlLY4HIIycmvbX8H+EpBtk8LeHXHXD6JbMP1Sscz4uzvMszr5h7eXvybSu1 ZN6KydtFZf5nr0eFshw2Gp4RUI2irfCruxJ/wifhbG3/AIRrQNoGAv8AY1tgA9RjZXwd+2z+wr4G /aE+Gurjwd4Y0PQviNYQtdaPeadax6WNRIALwNtXaGYKNrYGSMEgHI9fg3jzOeHeJcJmtStJwhNc yu7cvV28t++h8vx34e5NxJwnjMow9CPtZQfI+VX5lqkvXbsr3Pw1/ZR/4J0fF/xP8UpNN8RaNb6T onhfVi+snXN7yssc2cLkcrnOATnIwOnH9THhD4XeBvBmhaXoekeFfD1vHp1lHatNHo8AluGRAjOz bdxLEE8nvX694+eKNbibMcPQyqq1TUVJuLdtVorrR31e/T0PzzwE8L8Hwnw1P+0KKdeUnfmir6N9 GtP8j//T/vd/4Rrw5/0ANF44H/Eqg4x/wGkm8L+GriJoLjw9oc8DjDwzaTbyxMPQqUwa+x/trOVF fvpfe/8AM+Y/sjKZpwlRi1/hX+R+Nf8AwUX/AOCd2g+O9LX4r/BnwN4f0/xFocX2jxLpemRGxkvY YnDtPBAg2ZC53BcEbAQDliPpf/gn7L8FNW+EWnaJoek+Hx450KRofFVjqGnwPrEEwCr8m8F9gAA4 6HrjIr9rzLjbP+I/C6jhMNJ+2w0rVLN83J3087N9EubsfivDXBuRcJeJOMjWX7vErmpXStfflXpq l3snZXP0Tgt7e1jEVtBDbxA5EUESwxgnr8oAFTV/PGJlUlWi6vxO35s/odxj9W9zazMDW/C/hjxB aXdp4h0DRNYs7uFobyHVdNgvIpkIwwfep4x6+lfxef8ABUv4XfDH4T/tA6vF8J20W30zUY5Li40b S7hfsVgwfBRUUYBDF+nYjk9B/aP0Q8yzz/W+pgarl9VcH3ttJ27bpOx/A30xsBkUcmwWNw9vrXM0 0rXdnHV9dm/6R//U+RI0jmn865ZY9zbncDGD7Ae9bDSwwoREyz+bhQzdQOvFf9B97M/57Y/CNuLq NLdrZIx5mM7tuAB3qjYpDLdYYM6EYUDht3px+NKD0N5bo7ERiwtvPRt1xuDRrGvmMGBGA3sO/oM1 /Z//AMEl5pbj9k7QJp5fOll1BneQfdf92i5H/fP6V/HH0xdOB6T/AL/6xP77+hK1LOs0j/07h+Uz 9OWBKkAkHsR1rhbL4feD7e2voLvw9o2oDUJ3nvGv9MhvGm39VO9Tx14r/NTAY7E4NOeGm4yel07O 2+68z+/cXg8PiqnLXipKKvZq6vtsf//V/bn9rn9ojxX/AME9/wBpB9K+DsMNp4P8VAatd+FPtIl0 0BwkkiRwSZUbBIQo7BRgjAx+Xn7V/wC2z8Q/2ttd0PV/FENvbaPoVysVtobpFDBaRJL820JkjzOS 3O44Ff6X+FHhpga2DwHiE/8AeHTv13XV6pbre19lsf5u+KfibjM1r4jgiprQpV7X01W3m9m+ttT+ on9gz4h/BvWvgR4M0jwlc+H9K13T9JiOv6ZI0FrdPcEYaRCcF0OBjuPQV90pqNlK6xRX1k7nhY4r mN2P0Gc1/FXiJWzajxjmMMVNuXtJW/wt+79ysn5pn928J0MueQYJ4aCs6cfvsrnL+OvAHg74meHN T8K+N/D2leING1azeyuINRso7oxh1xvjZgSjKcEMuCCBX8dv/BQf/gn/AON/2X/FF74l0SOHVfht rExt/Dc0Uq2sGnBnT93MoQAsqhsAY5PHFfuX0WPEOvlHFcuF8fNuliPhTe0vJXt5+jkz+Xfpb+G9 HNMhp8Z4KNqmG92en2W9G7K/k23/ACI/LHUdLMKfZ2le3ldQzyRDBkQ8gj6iv34/4IlfFH4SeC/F fifwd42m0yz8T6u6ReD9b1eaEYUhfkLPjaWwV3Dp3wDkf2n46YfH4zwvx8MuX7xRvp2s/wBWj+Sv o24rA4bxVwcswaUZJxV/5rxf5Jn/1v78m+YFW2sp7FQVYV8Bf8FDPgj8O/iD+zZ8QdY1nQNOt9Y8 LaW2s6frNnaR218hGI3R5ABuRg/IbP3RX6hwFmWLwPHOAxNOVp+1gn533uflvjJgcPjfDbNKFSN0 qN15Ws1b+trn8Mc4e/hkiSZ4kgka2luFAEQCMRlO2CB+tTWOrR2E5iSBJyIhbwukW08fxNtHPGev 51/tZhp3w8P8K/I/xcUeWd/P9T9KP+CX2qeR+2n8JGEMsdut6fOC2hjCF3VXO/HIAZTxnHPqa/tr b7xr/Mr6XkVHjfDL+5+kT/XH6L0vaeFtG/8APL/0qZ+Nf/BaNYx+zvojvC85bWZIhGik5BMROT2H TP0r+Yz4CfAvVfjZ8VvDvw78N3f2G5vLi1hhkWATMPMcJuJwRwccYOcmv3n6N+awybwerZnWfu03 OX3LT8bH8peNmQVeJfGipkuHjeVRwj8uZN/ck2f/1/7J/wBi/wDZJ0T9lH4bw+GY57bVfEVyfN1H VVhHmrnkxh8AnknJ/XBxX1/e6laadD59/d29nCDgy3EixIPxP0r9M404oxfFfFWLzqU3ac3y3b0i tFbtfe3Rt77ny/DfD2C4a4fwuUUaaSpxSdkt7a/5X8ilYeJdC1UhdN1rS79z/wAs7S9jnk/75Bz+ lcJ8ZfhD4Q+OHgDxD4B8Y6VpeoWutabJa2l1qGnx3zabMQfKmQMMja2CQpGRkZ715WWZxmOS5pRz GjN+0pSUvu3XW11p8zTP8hy7iTIcTk2LivZVouN7bXWj6bOztfW3Y/jc/am/Yg+IP7MXxVfwprmm 2+s+HPEV2NR8J3WlXTSwQwvKwQpuXftDI67DyCnTmv3E/wCCc/8AwT0tfhtaeH/jP45vnuNQ1C1F /p3hy5sRhd43Kz5xgA4wMHIU8c7h/c3it4zxxXhXha+Bqf7RiYqOn8zWr20sruz06dj+Ofo/eDdD IuN8yrZlDmjhpSjFSXS+3m01a/ZH7WGUgYBCKOABgBR2FMr/AD+xFSpUjzVHd3/zP7qoU4KnaOx/ /9D+pv8A4LE2CX37GutRkZZPEtu/3gMKLe7LdfoPxr+MfU7eCS3tZPMJhltY7hdjHIBUEKa/1Y+h o/8AjX9f/r5+sj/J76Zqa8SY/wCD/wBtgZEclo9sY0i3P5hJkI5wBgistvIRfJtVxHnawJ4Vs84/ I1/ZB/HlPqPtrYFnRpFwp5PY/Suo8B3kGl/EbwZqN1YDU9N07V0nvrU/6uVdyqM/mfp17VyZhSnX wFejS+KUJJeri0j08kr0qGbYXEYj+HCpBy66KSb/AAR/eb+zN+1Z8Bvix8L/AApc+FPF3hTw5d2m mQ6df+ErnVYLO60meONVeNVYruUkEhgPUHkGvrdXSVEljkSaOVBJHLG4kjkU9GVh1Br/ABG8Rsiz jJeJMd/aqfvTk1fZpz0t8unQ/wB4vDzN8qzfhrDVMrtyKnFOytZpI//R/vnLKitI7rEkamSSR3Ea RqOSzMegHrXhvxV+LfwQsfA/iyz8a+NvBl7pkmk3VlfaS+rW17PcHynUxCLcSWOcAEfnX6NwZleb 5nm2G/suMm41It26e8j4LxGzTKcr4YzH+1JJKVGole2rcJJJfM/j8+B/7P7ftc/tQ+KPBPgvWLWx 0C+1tzeeTCIRp1vCB5ghUABQcMzEcjPTtX9g/wCzv8B/Cv7N/wANNL+HHhPy5obJ2nvNQ+zLBLdy sFGT1JwF6knkseM4H9OfSb40xlPCZdwQn70aUJVN9GkmvvafXS22qZ+C/Ra4KwOF4frcW8i5q05K HWy2/peZ6j4i8ZeFvCEFvc+LPFGh+G7e7m+z2sutanDpy3DkMQqb2GThWPHoai8O+OvCHi43A8Ke LNC8RNaLuuV0nUYr0wjOMsFJr+WP7MzmWDWPjzOgre9Z22XU/pejj8qlmf8AZ1o+2u9NObRvW2/m eaftC/ATwb+0f8OdW+H3i+JImuombStZS3Sa60uYqyhhkcqwYhl4yD6gV/Ex+2Z+zH4o/ZO+Kmp/ D/X7S3m0dZU/srxDbmQRXqyAyRuwf+8rKAyDB2nPzAiv7A+iFx/iaWb1eC8XU/dzTlG76q7tqvlZ NX5l2P4X+mZ4a4ZYejx7gYWndQqJL0V9H2V7tO3K++n/0vkC6RnUgSkOG+RkA2sPQ1JBbDySXkUP 1IY4Br/oXTuj/nVqJqpqPs7KGeVlnlWJCpb5yFHH+frVWK0KStzhPMwM8isbu1jenG+pv/YJWMeS fnwiHqM1o2VjdWl1BcPtMcL5bbz6jNZYmX7u3kdOCTjjIPzP6xv+CHI3fADxpceYJTda3A5bdk/K 13wP++s/jX7bJ99f94fzr/F7xsv/AMRNzH/GvyR/vf4fxT4Iy1/9Ol+p/9P9O/2xvgxqPx8/4KTX 3w6sLh7ddX1lLUTFwghy0xfb/vMoH/6q/oX/AGWv2X/BP7K/gEeD/CuL3Ub2UXmtazLCsdxdSYA2 5HJVQAMnk4zgcAf1X4kcXYnC+HuT8LYWTip01KX+FdN+t7bNNXPwvw64SwcuKs24nxEFKo6nLH5K 1/19T3TxP418K+CbKPUfF/iXS/DljLKIYrnVbwW0cjHOAM/Q/kaw/DPxb+GPjTUf7H8JfELwx4g1 Uo0i6fpmrxXF26qMsVQNk4HPHYGvw/D5LmuIwbzKjCToRtd9F/X9bH6v/aeVxx39nTnH27vaPXd/ 19xe+IXgTw58UPBuueBfF1nDf6Jr1obadJ4EnMLdUlQMDhlPII5HYjrX8bX/AAUD/Ycuf2WfH9xp dvqMd14R8Sr/AG3oGrPa+TFbxyTSKsTEnAZWj2FR16jGa/pL6LHHWJyniifC2Jm3RxHwrXSX32Wt radZdz+T/pdeHuHzbhqjxdhIfv8ADyXPa2sdddruyvfXpHomcd/wTp/aM8DfsqfHq28XePdKk1TR Nemjg1G7a3MraZKITao0SjOCoKyAsDyhz7f2xeC/G/hv4jeFdD8b+DdVj1fw14iskvtMvoQ0e9WH Kuh5VlIIZTyCDX0X0u8jx1HO8Ln/ADXoTjyW7SSX+T/Dc0+h9nOX4vhGvkij/tFGbb84vZ/p63P/ 1P7xPG2l6fr3gvxbo+sW6XumX/hy8t7y3lQSK6NbuDgHuOo9CBX+f58TtDsrT4y/EvTbaa4tbey8 VuI4FG+OICRgoX2wg496/vH6HuJqrMsywzfucl7ed0r/AHH8L/TDwtPkyvFRj7/M1fy95n9Uf/BK H9sD4WfEH4W6F8BlmtdB+I3g63ktfsBhNumvKjyNvjbu4QAgZ5UZHpX60eKfDek+MNEvPD2vWNtq On3ZXfBdwLMgZGDKwB6EEdRzyeRX4Z42ZdmPDviRjXVm7uftIO/To/vW2tvwP6T8Isxy/iHw8y/E 0YJRcOWStZXW6/4JyfiD4i/D74S2Gj6Z4w8RaR4UtWjSx0pLpha27gAhFXtnCN0/uk+tek2d7bX9 rbX1jcR3dneQLc2txC2+KeNxlWU+4r8xxVPHLDLMarfLPZvq9L/Pf8T9Ewzw1SU8NGK93Rr+vI/B n/gqt/wTl0Xx9ofiP9of4e6h/YviDTY2uvFGjLYxyQ3wnmh3yxyBdygyKjMCcLvYjPyhf5XtX0y9 sJGt7pEjuIZWidEkEinaxQkEdsqa/wBOPorccV+KOC3lmMk5VcO7Xfb7u+v/AG95H+Qv0pvD6HBv iDWxOCio4bELmjbu9bb9Ph+V+p//1fkF4gWffkE8ZPaqjAxgRxk7hyvFf9CS+Fn/ADqv3Y6GraMH U/alZxj5ipwRxX6af8Etv2uPh3+yT8Y9VvPG+ntNofjOGLT5NSMBuLzSQWAlkVucchGweu08jgj8 98UMoxGfcB5llOFv7SdN2s7bO7/BP57an6Z4Q53h+HvEDK82xdvZwqJO6v8AEuVdHbVrXtfpc/sD +Gf7SXwP+MU8Vn8OviNoXiPUJ4BcJpkMklvfFdu/IjdVz8uT8ueAa9tr/GTiHJsfw/ipYDMYtVVJ 7/I/3PyXMMLm+W0sfhHenNJo86+Ifxd+Gfwls7bUfiT410LwbZXb+XbXGtXgtElOGPB+iN/3yfQ1 +DH/AAVd/a5/Z7+NXws0PwB8LfGGh+N/EkmoXJm1DTCXjtIFWNZEEpXBLDftXOSRx7/s3gPwrnWO 44y7O8KmsNTnHneuqUVdei/NWR/Of0jOJMow3AGPyGslLEz+HVLl9/R+rWluzu33/9b6D/4Jt6Xb /wDDZHwYsIo1EEWuWwjV1xMvk7yiMev8J4r+29vvGv7E+lvJ/wCueGX9x/8Atp/Nf0WoqPhtD/E/ zkc3q+hWN5fadrU1ukl7opaS0kaMM8QJDNg4yPu549PpWxp+oW+pWkN7aSia3mGUcdCRwQR2IIII 7Yr+WHUk4KLeyR/RNOjBc0rbt/mz8vP2/P2BPCP7Qslh8TNJll0TxdpmLPW3skWP+1reUqvmO20k OpA5PHzHPt73+xt+xr8Ov2U/Cjt4cFzf+KvElhAdc1W8mE/lADf5MIAAHLEs3Vj7AV+r4nxXzXEe HcODJzbfNy3v9jzve7a91/N36H5ll3hZk2W8b1+LqNOKc1dJJK0vl0T1XbRW0ufXmu69p/hzTLrV 9WmlhsbRPMmeKF7iQD2Rck+vsBXD6B8Y/AvibUbfStI1C/lvbpykKS6ZNEjEAscsRgDA6mvyiNOU 6TnrofpNl7RRsf/X/vovbS21Kyu9PvolubK+tntLqCTlZY5FKOp+oJr+T7/grL+w3oHwFvm+L/ge aVNA8UXy3d7ayQr/AKO6zxC4iLkYBKtGdy4JHGOtf1B9GnjGvw7x/Qy+U/3Nd8rTvu9NvS/3I/lr 6UPBdHiHgCrj6dO9ehqmrXsrvV9r2+99z8L78afczMqK0M0R8lxu8xJCCfmz+VLa2T+ZdRWssFy1 rw8kcwMbdPlXOM4PpxxX+s6aUUf5HuC9q0U57Yh5GmUDJwFHIGKLeFvN85Uwu395khflHFRPccFa R9r/ALCGkyap+1j8Gza/Y/KXxNa3ai8fy4yYbmKUhlx83EbY9z71/eoM4G7Gcc46Zr/NL6ZU78WY OK6Qf5R/yP8AVz6HVPk8NZt9aj/9Kkf/0P7sPin8J/Bfxk8LSeD/AB1p8mo6LJdJeeVDN5EqSR5w Q2D1BIIx3rV8AeAPDPwy8Lab4N8IWTafoOlKy2ls0hmcbjlizdyTX0kcfiI5YstUv3bfO/W1v0R5 8aEHXlibe9t8rnh37R/7RHgL4U6RceDtR1W3l8ceLtOl0zQvD4LLO/2lPJErsBhQPMyOeSKz/wBm P9mHwj8D7G98TwWyy+OPGMIvPEF/uEsMHmlZfJhyuRgkgsOuSORivdo1cdkvDtSbTisW+VecI35n 135ra201R5zo4XH5nGqrN0L/ACk9vut9+h9E+NvG3hn4eeG9R8W+LtTi0jQdKj8y8vZgSqegAHUn H6V82+EP27P2YPHWv6f4Z8NfEizv9Z1K+GnW1otnKD5rMFCscELyRyawyzhnNs5wc8bl9PmhT3+/ 7tFq7tF4nNsDgsUsJiJJTlsvl+p9cSxRXMEsEyLLBcRNDLG3KSo4KsD7EE/nX41fHH/gl/8ADHxp +0N4f8YLPcR+GPFl99q1jRJvmW0mjCiRLdgvCNkNgnIOe1erwTxljODc0qYrCt8s4uLW3ez/ADXz v0R4vF/CGA4swtGjiormpzUk/K65l87J/K2zZ//R/u5+GPwy8H/CHwbpPgXwNpcelaDo8PlwxL80 07H70krfxMT+A6DArhPjL+0v8G/gGdNj+J/iuLQZ9WDNYwG3eZ5FXALE8KoywAycnsODX2eGo5jx Vnc407zxNeTfXdu/W7slsruy01PnsTVwWRZdGU2o0KSt20SsQfB39p/4MfHi8v8AT/hp4qTXbvTb cXV1CLdoiqZ25B5B6ev0zzXo/wASPhz4W+KvhDVvBPjCxF/ourwNDKmdssDFWQSRnsyhjjPrTx2C zPhHO6cK65K9Jxkvk7rs+n3Ec2B4iyicVadCpFx+TVn5f5H8XP7ef7Ndp+yt8ab3wPbahNqGk6us +teGmuStuVhWa1TGAOR5c4bGScxt68fHdvdGDW9GtS7pHdX0MStEAysfMDYf2IUj8a/1V4Ozx8Q+ G9LOJO7qUb/dC2vnpqf5X5rkcsj8UP7LmrOniLeX8S6t5dvI/vd/Z1hlg+BfwpimcvKvgfTzIzLs bLW6MQR6jOPwq38epooPgx8TpJmKRr4NvVLA4ILRMq/qRX+WGLX/ABndRR/6CX/6Wf6l4hW4Plzb +w/9sP/S8I1xHufE3iQSrOHXVZJpXZvML+Z8y4bvkEH8a4uW1Ek5TzvLUElt5weK/wB2OGFy5Dg1 /wBOof8ApKP8F+OZ8/E2Nf8A09qf+lMoTzwvE1s7712lYpAcMnuKaYrLZb+U0xZYgsrPgBm78Cvp 47I+LbamWX0eyt1nxfeZNtE8bMCEcMAdo44I9/SnppggshdzyBy/zxhPmRlBx6dRg/lTIluzGES3 crlgqpkBBkkmkubVbSVY2bIdcrjn2oSvoI//0/i9FNtMjLOVkIPAJGAR0J9wTUqxJNvdWy2eSD1r /oFUFbU/53yKKaT7RJbyQSw+Tgh3AUPnnI5/nRcqqyrNNcfZ0J/ePLlkAHrgE/lR7NDu7WG3Wz5Z PPSSJgPKkQFVcHGOCAfTqKVrORlWQxNHbv0fojnuB+VPlQh7lDEyqg+XADY5XFW3ktkihSIMTsHm MByT3qJRS1QH/9T4rWJkieRZYzP5o2Qsp+de/P4frVmRECkOMZXdjsD6V/0AH/PBdpWKlowhDSs2 0k4Iz2zxU88ZfbMGA54z29KCbq9iK7S6kto9jefGHLzJGmWhxgBv1qxa28wZQBnMeTkciiwKSeiL s4uLe1+yzgIzyCREBzk84P1wf1rHddj+buKyowCptyOB1/8ArVDhcZ//1fjWFWeOS4kw0SMBIyj7 uc4/kaRoJWmKxTNHjD/L8px16V/vy1bRn/O+SwhXiaNo18xWwJs4JX3Hrk9asyRb4xBGA0cZ3PKF 6k8deuBx1pFRlZjrWw0xzK188qpEnSJsM3Yfr/Oq8k5aQhY0EWzZjGMjp+dFuhqmnsVVijiOEVmB 5O45IqN96TYcsEfkDtWDVnYpNp6H/9b47ELMzOMeVEAZQxxkHirBeWJQ0IMcYUqgUckN1Ga/3wP+ fBNrVHPR21zql4IIXdTIxj2rw+fQe/b8a67+w7exs4IJJJGvxDunWRdpiPQJ9eAfxoC7Mn7LMuWk lCpFgherDnitGSe2nidZI2Z1i2kHjnswrFxaHzyMyxdreRslkYj5ZA2wrz/hmrUM9xLLKiZK9fmH 3qk0btG6P//X+SobG1WOYNcFXxxC/AFZzNJChdSpckoueR9K/wB6D/nym2aL2Av9HVbxonuEHnK0 chi8vBPoeuAcA+orFjeRBHCxaSOE5AQ/NjPWgI/Cy3NbOPKm37VZs7GHLDHSlWctJEXCsUft1IB6 fpQRY2JrlZJhJCQkxHPGF+mMVRuLmSRmSaCMnI2OoKgHvmg1gmf/0Pkq2K3c6QReRBNERl2HyydP lYZB/GrevRWNmYFS8Mt4ow9tBAFgRfXduznPY+9f7xSbb1P+fqC1M/TjraRTXFw6tbsoW2ZYhHhe hyO+MA57mpYbtDcq0zZUEKGzgA9Kk1NkCS0uEu5JzKzDY8YcqSlUbyztZry4ubZ/s1vLH5s/mPkZ A6KPfFBtD4TO0jUPJeYW7KsM+YZ2ZtuwryPxHH50wlWvVW13SPIh2q4G3IGT/WsHdvU6IfCf/9H5 QtHjsJ965PmIBIGGMHvirF3HJqi+YGCW8Z3bscHb71/urPY/wSgveLeiObi6W1+SV5CLdEfkZYhQ cfXH41/ZT/wTN0Q6V8IPD8UkRLx6dCVmkYFthiCnJz1OwcfSv5I+lfW9nwdSpd5H93/Qyw/NnuOr dopfgz1n9vV0g+EOoF2Jd90qoHCJ8sUjZPuNmR9a/iZvbaO4E7XcaWl9Gk1+xhXzJbxmZ3VS3+1w M/w14H0SF/whYt/3ken9LSSeeYVeTPyr/ax16CaC4guVuSLiW1mlyhnmuyXjTaMc8Nkk+hFfBF7z NOsEbrAoChSMMcDnI+tfmP0r6nNxXQpdoH7D9GynycHe0fVo/9L+R9L2eylheDBTfmUE42Y6NXWx avFewHzz5kzn5pNoG2uZxTZ2weljCuygaSJkWYEZDP0UH0qmLSN4xyNpUg54NZSVnoX5FCGFLIfM dybsKXODVuC7kdpYblf9GCh45t3I65GPbiuW1tAIHlsA6SadJLcW0wyzTLtLMOGwMnjrVt72e2SK SBFiZgTGiqG3YzkYxUT2C3Q//9P+Qs3hljidAUIPIxgvn1pkkJIV1kC98ZyQRXz52+zRLCzXSFDg FSQy5xn1NUkggt3dB+7R2+RN27BoKSS0Rpxyx2kO+Zg8ZBAfGSBVZog2zZL5isNyqRhkHpRdLcZN AiMRui+ePID57HHFRTRnOVk2ImdwXq2fSolblA//1P5C5Eje1DAvE8YyzDkMM9TVOOeOMODKzEDK joDXzCtfU9AhNu14wlV/IkjYNE6gBhjuKs+fZK8dnLIqu8hCK7ANOwHJA70hN2aRbbyW3RmNRkYB YcDHcVS2hJEPkhn6Z2/KfegZa/dvJtxg7QCOymr3lwpAkalXZc7yOClAH//V/kGuLNjtljbGRtz0 qvCBBu8yIP8ANhnY/NXy56BHfmBsCONYYzgHaMDPc1cs5pUUx+UjROmzJXO70IqZOyGt9DHGjxi7 a7ljka7J8uNBkxgHqcevArSaRI5YIHeTdJhcCMkp7fpWJpNN7GbJDHds63MJTy7glC/LNtPDVJC6 xOq7cquQGPUn0oCKa0Z//9b+PlQ6yTNbSkOw3uuQSPUAVZtkBi8mRf3jSb9wOGx3r5BaM9gp3UsN rqUkk10kdvIiQWkEagszjly57cfy961ojaD95M/7t8bmrXmV7GkItO7ILh4LVJJYN4kDcyYwAKnt ILSbTmWZYiZ5N7z5/ePnoDziqNChcaXKqXDxSwbIR5sYRS0rADoPfqce1OdcQxMzEKEGcjDA470A f//X/kDt79LRIYGj89GkZmfglQeen1rXtBBI0s6RqkRUrG7nBQ+or5ScraI+gGpdwRDybm4gcbtv 3gA5PAABNZ5K286vEieW8/77cCdsfPQflWQHQxKb1HhRCszDNvHCP3QHv3FcxdANKysQTAo+fPyA +lBlPcpQXIjl2xIVkJwxHCsK15NNtmSBJLueCFbwXrrGS7Fg27GfTI6fhQQf/9D+SRrqwErRTYnk jHmpug+5uGACw78ZrBlutqOHBOGwpVc5/Cvlo7I9Sp0LUZkkfDjACALvGAfetmyiszZvczXHmSM7 W1nFkCESAYO5s546j1NXD4kUl7tkdd8IPDetR+ItJTU7mL+yH1ANfJFCWkOZAflB4xyMn0r9Zvht Hplu0F1LPe3Gn2F/bQw21mu3+0Jg6qkUiFeQcgEdOetf1p9HKKU8bUfb9D+cfGKX/Crl9Hz/AFR/ Zt/wSv8ACE+kfD1nukiBmt4rwI2PNslZE3Rr78cn6V6p/wAFLfEVrovwT12RpEtpJLRhC/kFxaoF IcsR6jJ5/umvy1z+t+MEnH/n8vwaR/QPEanhPDtLqqL/ABTf4XP/0fy91++slstRurkWl4+pwyXl uJrdkks45RhA4PVwcgnnOPrX4z/tKyXUfiS4ghnsZ4CjW928ZLSWLqVwmf4vlCj2weTX+g3jBUVL gSpHukfyR4Sp1+LZVPV/gfGV5HJcXbBG3xYAbGeCK0IZEtpEgtlkLhB5zMmBg44Ff591fikf1+mr 3O4t5EuLd7qAvvhRVnyOVVeik/560+BYtOlS5m+X7WCwhX7zA9z+NedU6nQa1jNBM7mBFZ14ALbc 10WnQo95HdjbmNdhGdzYzyv0rya27Gld2P/S/lF0lGvoIVtIfsuccbcFcdcZ+lb2qSw6VcCK6sBN p88Sn7bFMDtfowOOfwHrXwdVe8exYoXVzHdXcceki7it5LXZ500Zt5C3GVC45BGavaY2m6pIsLXN 1a6tCRFHalP9GucnaASehJ79PeuVp3Fyq9zV0t9JsVlTXrZXhtnllmW3C7nyT94nrwPfviqT+IEl mt/+EejRbKdTLFb3LhjBt9MryPTv2pWTiwa0Ymo2cYOnzs58y43XE/lMUVHVvlBHTqM11VpdC/tp Ee5aOWKMAT7d8rHpnB6n/CtaEb6EpLQ//9P+O201mGK3hazjjtx5m+VWiCl2HBBB5wT69ao3UTai fNLiOaVyYyYtpTJ5wD0HH8uteBBWaR0EN7df2VLbWccn2i6ll8sLGvmCLC7slhxzjp7Vq6dNNc5O ps4hD7FRIMuoJ+X8PrW4WMGeG0jmmMSFrgTmNVdjGoJ/wz+lTRQ6rYTzxT4IitwRG77gmTnO7PuK CXFWsSxeIUOoRpdRNIqJ8rg/KrjgDH+cV2Mlrb6ja/b5LmOKWCB8RI48t/x9fQVurW0JcOx//9T+ O2x1GytIrm8s5yILKFhf/KVVyMbt3GTj2qSTWIdXsr6wFpAYpbcOs752biTtJbjH0rGnuJq6sZmk WFxZh4J1ik2pjdJtlXPqGrI8Qi3kTGVPl/MzoMxjbnIHv0rpp7mco8qPIZo4pro3UaMhDfKHQoRg 8bl/CvoH4JSX8/xD8KQwGdYLm7jvL63hhEkUptZUaJsY7MRkema+54MnycRYR/31+Z4fEcFPJK8X /LL8Fc/a3w/4im1CRrRrVLOWWGQyT2X7oO6nIEYP3S/PU4zX9vP/AASQuop/g1oFsks7RXVgl/K8 zhjBIYx8ki/390bfmK/q/wCkCufw/py7uP8AmflH0dZW4ix9FPRJ/wCR/9X+r/8Ab80VNZ+AviOR 7W1lnERtbWZ/+PmBzG7Bh2AyBz7V/BdqcupTeIdenuhNBZx6yySXobh3HysQuc4O3v71/Zv0V63N lmMovo1b+vmfy/8ASSoezznD1YrdP9f8jHfVJp7q4s/Ito7QgMLudRLMirkn5SMDPt6VxdxBHcT2 vnqQBMyWcuNnnSAggt7dPav7IppvY/lCu7RRHrySyXEH2hDMJVzLLEoi3MMdwOen6VUsdPu0d5JG k8hRuRm+6B6fhW0F7wozdtyW8iMBRLa6dI7ht06yfNv9wPatB7Wwjt2eCVri4VPkYqyFW6cCtR8z 7n//1vytt01ae0FxaXdjp8wtmhmj1C3a5R9hyu09VLFc5Hr+fMQJ4iuLy5ub+7imQSAK0DgImV+6 q/eUZB9fr2H+0Fk9z/LHmkaEjXcjNAxLRW6BpJXPBBx378kCk1KwiuRayiNNtsmU8tAvI6EketZT VnoPmdrMsWF5JBp010LZV1QgQRLs84nIIweOnOD/ADqt5sM8D2ggMdyU+bzHCxls/N8uMgVBLvfU ltoLVIGjmbEkWRG8aYRP9ot0PPY1HBc7ZZBHAk1848tb1xtUR4IK/jnP4UGV/fP/1/yj1S2nso7K G4a333FuDCIyGYhsnBxzng9ahtlhfy1Plq0BIYjOWJ7V/s7GOzP8rzoIgzWl80EiKRblHDqDweoH vWVp3hlrG3xGrqboedEJP4Qc4x6CrsiObY0b601lYiYbqORraNZp7KGEW4uVX5cuQMHB9e5/Gm39 7dva20do8lncKwmDoBlOgYA/TI4oLIrzXZ54Vs4EZRE3zTHAJzjoKsxTJafZk1VUltrhVcypLskR WyC2AO3WgTdlc//Q/Mx9P06LTYbGOeW4UzG6juWPmNKrNuXdn04wMVHe6fahleK8AAUK8yx7HdAQ SMEe2P61/tAf5UN3Kmn3D/aV8pIxbK20ljtL9utRiy1PTJLq8IjMEj7jht/yDpgUEOSQWBfU5vPi wAP9YzjAPoB7+1bUc09lM0ZwZGXKxocvj1IoMTOgu7e488sqLiT5lLbmPfn/AD3FXtFtor6W8nhu re0jsxg+ecPI+DtWNe+cHPGKAP/R/NOwnuXvxGDcXF8JC6RINxXB7D9as3GmlnuptReWSWVxsHmY VMEZHH+ea/2gP8nzLudQm0TWNPSysyV8ovOs+Ui2kDbn1znOPapbW7v5orh79okMty0UEijHnISN vHqM4/CgDcvPD32aW2nW5gu0SJZJjbyZMR4+VvxxntzWbdavElxOrpl3bzGRAAmfYUGdToYc9nqe oXNsbXT/ADbKYOVkhkEnkMoyd6dV4HU1s6NbWYvZhPFGzpaiHYyErbPkfPuPQnb+pqop3OaSSeh/ /9L8yJVtY9SvVfbZuVfzL5zvUbQBGAg7n9KfpmmS34a1ubpUluYmmfUhGFkLIpKjaOPmwB+Vf7UJ X0R/kZPYsSaQUWaOWCdrmO3LWxR9iSn3HQ5x7fWsy50e/sdNguZd891Phxa2KFmgyeQ3uPauhGQl rPM72lncXU1vGHB3+WGlxkEqcjODzx71a1aAyybhJJJEsm2N2Xa2BwM0Aamm6F5Tm4vJN0rwpcWq ZUpH0I3D3HOKjIeykn+1284t4itxbvAMtdENyq9u3egV1sf/0/zhvNdla/iS2RltFkDi2m5LgjoD 16/yq01rK99MJLdzEtr9rl8sl2tlOMMR2HIr/bA/yBk7sdCpeyaX7K6wTDc7zDY6IDgnvjtULk2c kMAvrcIy+ZHJIxuAiEZ2nZk57e1NNrYxn2Mi7USak0UdyJoQolLIT5eWGSBnvkVchl1KJY3k+zKs a+UITAJI2HQHByOnrVwerLi7oheJJnki+0JaGaFokYAgg4zkKOeDim21o8dhbMmp3Nrdx3flzIIu LlAAOfZjkcVoEldH/9T819VYaVLZEjKzHMiRjHlknHP160601WZr2aJEEluP3KqV2OgIxvb8zxX+ 3cFqf47kmp6tplpbvbozCZ2EYfyyIomJ5J9vp61nQpNbTWk99cx6jawtvjeKFlUqfQED1/StQt0L qO09yLjSVdYmYq9u0ZgjznryB+de6+HtTTTrSytEBiYSpvRT5qh5CA7AntzVw3OPEKyP1N/4J0p9 g+Menx27/abfVL+11K8lZx50WH8hlUDqMRA+xNf2WaHKJNBtkQtiOzEQaUgucAjJr/O36VMbcY0p eS/JH+jP0a9fDOa/vS/Nn//V+7v+CudtBp/xahup7aBh/bs8DX0iMHUPHEw8vtlii594x61+Okt8 ggZSd8krlEm8wKyA/wAOMdxX+vfgVU9p4b5freyt6eR/jl4u0+TjzM9LfvJfmzIic/aWunEBEOPL RVG0hQBgjueOtaV09rqdpDJNDBbSwqZAgRSxz/e/Lv2r9op7n5K1ZmdBY6bLbSFSUTaQfKcJhsfw 8Vb0pbaSxthKXtbiGZgBIQZCdxwQM85AFbR3RhUdncj1+K1USXokb7ScCOJ12wyADnHv09q5eOeJ ltmy6mQEsqjlGPqa3ORu2rP/1vjmNo2k+wN5gursYguPOEcEBH9/I79sGjymTcjp5rj5WJ+YZ7kH +tf76welj/n/AJS6sqywQW9vcSyqy3ETqIkb7j881Kbu78pdhRTJhsMuM+2Ks5wlAnQRXETRtjuC pGfQ1FaQx2sflSPNKiMfLVyWLg9hQBNFdz2cZkt3McLvkp6H6GrN/qraj5JvJN8wjEKsFCgqOACA MdutAbH/1/ikafNGl7P5oURxjamOmTjp7Z5PtXU6fNB9mSG1iDXK2486TbjL4+YjvX+/B/z6c6Mm 5AL/ALwMmwcFB87GsiytwollLtunkM5dyWckccZ6D2FBlJ3uzuLUafeafFK64VB5Sm6IEitj5gCc cfSufuAIsWolaSASs0W77qlsZA/IflWsY2dznKKDyneNgd0ZwVYYIrWfbJbxyCWIlPkMBRhKR2Oc Y/XsKsTfRH//0PjwWySsJJlcxpzsTrxUBuIfMkW3xE4HERPzEV/0AH/O+XLC6dBcC9treaLyyIEC FHzjgsc84IB/Cq48zzBcsgcE8lhu2ntQBJK0xj8+Hz9sRxK2zEak5wM1FM1tKdPYBxNbyecXZvkd wcj5e+MHrTW4221ZmhcXr73mD7Z7glpGUbC+7k8DoD6VSWd1jZEfapbc+MfMTx/StxH/0fkFbbzo muWMflwEb/mxI/0FUGQTs7oDiPoP4R9a/wCgg/53yJYfMxkDcOuOKsLGqq43BX9McEf5Apx3QGZL EjlS55jbgVfjgWWFo0KhuoVup/CtwIXiVXUODheGHQGlki3OywrsUkEEjOR3oA//0vjFvMETRgE5 +Xd0NPiSONAvliOTbjCABePav+hA/wCd8DEilSAHfHCgZbPNRQ3Uib4FVF8xsnKAyHHv1H0oIm7K wXcsYAR0G5WzvXO41GZYpQluWyzjO1uCaDIrxxbZHVSUiPRh3NX4WKqEcZj6Kx5rWnsKTsj/0/jx mjRZRIE4TCAAZz2rMt5nEgxypOM+lf8AQwf86Tm+hNIP3qoTjc2W4ycVJI8Y4UYCOBg/5/zigXNL uPmSLDXLMoDgAZGACe1MgiEu0yMF2889D3pNaWFd9yKe4kSVkUFo5F2OR6dzWvDb2cMCImySFU2x fO3m9OpB5rL7HzLjPoz/1PjXyJopWcDEGMxvn7xz0qRZBLIgbO5l2k8ZWv8AoQP+dnnkaVtIltaz xyIskjyho5GOCgGcj8ePyrRsF3zQvjgsDtA3YNTL4WdFGSdWKP3C/wCCNklzB+0ttd7p7S/04SSN t3QrNHC6ov8A3yw6+p9K/rZr/JD6VCt4mVX3j+rP9tfo8/8AJosrX91f+ko8t+Jvxp+GPwcsrPUf iT4ssPC1nfyGKzmvklZJ2XqAVU8+x9D6GuP+H37U3wH+KeuQ+HfAXxB0nxFqtxH5kEFksmJucYUl Rz3x6c9K/GMPwpnWJyz+28PRbw6teXotX+Z+hYfiHLJ5nPJVUX1iLd49tXb8NT//1f7+K4e8Abxx pT4H7nSZ0BI7sxP9DXqUr8zt2ZyVl76Xn+p254B9hX8+v/BXn9oz4y/B74jeCtH+HXjXXfDVhe+H YbuSLRtRksmeQzurO20jOByR34ByAK/UPBvIsBxFxzh8szKPNSabt5q1n8rn5N4z8QZjw1wfLMMs ny1HOMbrs7tryvZXt006nsP/AASb+NfxQ+LVr4rl8f8Ai3V/EiwW5MTajcG4VmVlCyDPIJDZ9DX7 UngH2FY+LeUYPIuNcRluXQUKULJJbdV+h9jwhi62YcLYLHYl3qVIKUn3b6n54/FP9pjwx+zl+0vp 3hXxQv2bw78Q9MhuZ54I/wB4lxPIyib0O11APs/UdR+gljfWmqWNrqNhOl1Y31sl1aXEX3Jo5FDI wzzyCODzXh55kmKwuV4LN5J+zrQSv5xX+St8i8gzLD4x4rB05Lno1JJrrq/87n//1v6z/wBtr9nz 4yeJNOn8e/BDxz4ss9bgYf2l4XstTmjjlj+bdJborAdTyCCQMds4+P8A9nT9r/4u/sz2lzoX7TXh 7xzqHhma5KxaveWEk9zpbAkF1lc4YHuucn14GP6J4awuR8UcHSyapaOMi7RfW/R9/Lz1R+D53jc2 4V4rqZvK8sHNXavp5rtvr5aH2V4g/wCCqX7Gum+Hb/U4viG9/eRWrFdAl0O5gvJ2KHEZDL5Zz0ID Hqe3NfyzfEb44a9e/GzxR8Ufgzrl34K0fXtYvb61sLO5l090ilm3xIkSjAXGeOxVSOvH774D+FOJ y369/rBTTpVI2W9r91t0P5x8YPFijmPE2VYjh6q4uk7O1rvVb726qx/U7/wTK+Ifi/4j/AGLVvGP iO98R6naaibE3N/L502FHDEnnJ5z/wDWFfo30/lX8e+JOCw+X8b47B4WPLTjOyS6bP8ANn91ZJiJ YvIcLXm7uVNNn8iH/BSH9pL4t+Gv2rviD4L0D4ieJdC02z1e8igt9N1Sa3t7aGKQRiIpu2kkEEZG AK/G7xpqOuapq17e6zrepa9e3E3mm81aX7TcRg87Ax6LnPC4HPSv9RvAbhPK8m4OwOaUKSVerTV5 det/v/I/x98dOL8w4g4rxWBxFW9KjUdl6pfkf//X+R2h81sZRBt3YHCCqILu4SBC8u7aq+uK/wCg 5Lqf89cJLkuXpnuFQCWMpKBhsj5gBTdHaWR5FiibejllnJwoHA6fn3pQ2NFO7SOnFs7pd20czK4t jKJgNu07ecfjkV/aX/wSPnjm/ZE8LCOMxKlx8yHn52jUufxbJ/Gv46+mIv8AjBKP+P8AWJ/fv0H3 /wALmar/AKdx/KZ+nzMFFZOmapp+sxXEmn3UVwttcNaT7GDGJ14KsO3/ANY+lf5lUKcp03KK2Z/o RVlGNWSe7X5H/9D9Lv8AguHau/7QHhtYoVuYhpduzzo6rLbNKqBlHfsPyr81fg58HvFfxS8S+H/D fgPQNQ1a6uL9X1FBCbi3ghV1WR55AvygtnAJzgGv9c/DrM6GS+DGBx+L0jGk2/vZ/k3xFklfOfFn H5Tg9ZSxC+7TX0P6/P2d/wBh/wCGXw58DeHz4p0Maj4vm06OXVWDvYxWzleIwqkHKjAOSOR0GK+o 9J+D3w+0O+t9S0zQ/Iu7VxJbyNeSzLEw6EBmPNf5o8YcQTz/AD/GZil7kpu3W6u7O/nv/Vz/AE94 fy55Pl2Fy++sIK/qkl+B6aBjj04r8zf+CtfhrTvEf7HniM34IbSfElnqNrKigyK0cN020exIXP8A uiurwyr1cL4g5ZXou0lVVvxPkvGehTxHhrm9GqrxdNf+lxP4pBHPJEjyTxy7oUkG0nESuoYJzz8u duPau1+Gl3qOmfEDwReabdJHHba9ClyRjz4/MkjcMrdR80SZGcYr/Y7iBRqcOYlT1Xsp/wDpJ/kV 4cc0eNssdN2ft6X/AKWj/9H+7/4dStP8PvA07SNK0vhLT3aRiSWzaRHJ/OvLv2rre2uv2bvjPb3V sbuGTwJegwDHLbMoT7BgCfYGv0vLZcniFC3TE/8At5+feItL2vh5mEX/ANA7/wDSD/PpWEmTVNFv QITperTWsy253LO2/fgkem4fkKkgs0SbEauifwlhj8jX+12CalhoP+6vyP8AFCppK3n+rP0h/wCC XN1fr+3B8IoLuQvYGSSRt3RifkAY9epXr3xX9urfeNf5n/S+/wCS4w7/ALn6RP8AWj6LOnhXRX9+ X/pUz8af+C19pdSfszaNeQXKQxW3iJxNG7FfNB8o4HudpA9yK/Gv/gk/LY3P7YPw8upont57qBGe xcblhlX7mG6HazDn/Zr9H8Ip/wDHPWYryl+h+PZ3Ti/pN0Odac3/ALZI/9L+/E9T9awtd8MaD4ot RY6/pVrq1qG3iG6jLhTgjI9DzXvRvGpK2/8AwTLEct1F7X/RmFoPwy8C+FrkXvh/wxp2mXYG37TB Cxmx35JNdptfP3WH/ATxWtSdStJzqLUzhy06ahB6I+Y/iZ8JfA3xX+Nvg4+Kli1FvBXhNtT/ALIK xyq5ku38vzgQSAdhxjB4ODX0tDDDbwwWlrDHb21tEtta20CCOGBEAVERRwAAAAB2FehmOZY3EZfh cBXm3TpqTS16tr00SSXbU4MtyzB4PFYnF4aKUqsk5W72u/vbbZ8GfG/9sHQPC3xo8Ofs/aTY3Mmv 6lfQDVdSdxBDDucERRHBywA3Hp95QDnNffDKqttQYUAYH4V08QZFPJ8vwWIn/wAv05r06fgxcP5z TzeOIVP/AJdT5H6q9/xP/9P+qH/gr4zn9kTVIEijlMuvxuBKcJlIJ25/DP6V/Fk05u9HtLm0YbFt 1CxMMmLAwV/DGK/1T+ho3/qFiF09p+sj/KP6Z8V/xESD68n/ALbAyPtErlPKEcckZA2tHlGHOe/X pTzbCFTI7AyNyQPuj3Nf2afxtT3KxDyOqR/d/i29fzq2fJVXQFwjr5bjJDkEc81MloyqMuWoj0zw VrepaBd+H20V0sHg1a0UPbwBZjGZEiK7h6jbk9eOtf37/s8vLJ8DPhbJcLtnbwnbiYZLcqCvX/gI r/PP6ZuWYTCUMDiaEEp1JXk11aUtz/VH6FOaYvH8K46hiZuUaUuWPkrU2l6an//U/un+LUs1v8LP iJPbP5dxD4Pv5YJAdpjZbdypz7EA/hX8GHjq/wBe8QeKfG1hP4i1+2tYtfns5Uhv3RZzE5JBbJ4B PHt+v9z/AERMvw2KxGY1q8FJwS5bq9npqux/Fn0vcficPh8BhaM2ozunZ2uve0ff0P1K/wCCH+mC 0/aX8TxrbhRFpkzecw3SH/iXykkn1Ygk+pr+scnJJ9Tmvz76UE3PxMqeVOH5yP2X6OuGjhPCbL6S 8396TP55v+C6mr6zp0Hwli0fUbqwmnijgZraVomVJbmfzGBzjJEajn0rzj/gh7fazefGD4rw3+o3 N3a2GgbYIrm4Mu0StESRnkklepycCv0PI8HhH9G2vjXTXtUpLmtraz0vvY/OoYjFy+kl9WjN+y5E 2ru3xR6bXP6X6/lz/wCC+lmLz4i/DBjMkKQadbrLlNwkHmSkbh36gc+tfl30Y24+K2Dt3/VHu/St SfhXik11f/pMj//V+U7izazZQyEg8x9wR7VWfy2yNmCMHaw6EdP5V/0KQfuto/52MR7s7D2RzGuw eYw5bbyQKtWxUeSksFy5uLuO2UxRb9hckDP4gVzV6saFGdafwxTb9Fqz0Msw1XHYulgqCvOpJQiu 7k7L8Wfst8EP+CTPx1+Mvhq28TC10/w7oN1bQSaTPq9w2nXdyGhVjIFMYyMnkru+vp5n+0z/AME/ vjR+y3odpqXiTw/Frnhy6lGmz6voqtqIeRmypSQJgY4OH5AUnPBx/M+H+kFk+O4xXC/NFLmcb310 bW97XVte3ZH9SZ59G/OOHeElxTUUm48remmtulrpNtJPu92fsn/wQ6sDp/7Pviu2ZCr2+p28Jznn m6Gcdj8v6V+2qffX/eH86/z18aZe18TMxmus1+SP9RvD98vAuWxe/skf/9b96rmzkuf+Ct9s6lWe 38VJI7H92qKjyuVHqcfrX9AD/fb/AHj/ADr908UNMJk8V0oL9D8/8P4uOHxsn1rSPxA/4Lf6peaX 8F/BjWks0ayaoDcC3lMczATwxjp1H75/zr87/wDgkH513+1dbNB5qW2naa4aGW8eRSZoHO7aT1wk n5iv3PgjA4P/AIl4zLHypr2tqi5ra9ep+B5lmGNf0j6WWxqP2KjB8t9No62+Z/We/wB9v94/zr+e /wD4LuLDJ4c+FkMhhEjGMxmeTykOLickE++Bx64r8W8BLrxSy5r+dfmj9R+kHFS8LMyi/wCR/wDp Mj+ba802W6spLtQ0DQDzQ38JKENjPviv7gf+Cd6ov7IXwp8tWUPYyStvBBLMxZuvuSPwr+qPpe1G +GcEr/8AL39D+cfoa4dwxmZz7wj+Z//X/vP8SkL4Z8TMc4Xw9ek7fvcW8nSv4Gfi2LP/AIXL8U3j uZFuLjxRPHbRTRdAHb5zx7kdelf3D9EGTjnuZf8AXtfmfxZ9L6knlmWSf/Px/kz7o/4JIWs7/tl+ GZoo4mWztFW4YNhyziUblHshfPtX9jL/AH2/3j/OvkfpUpf6/wAUt/Zr9D9S+jXFx8MsMunNL9T8 Vf8AgsheyWXhP4U+QWhmuNfhgNwjlZArSOMcHpk5r9Xfgbbx2vwX+FUETSOkfgLSwHl/1j5s4iSf qSTX5pnFOC8MsunbV1Zf+3H6Xk1ST4rzCl0Sj+hyv7UzeX+zt8YXyq7fBdwfm6Hpgfniv8+lpna9 vJJyd11eS3IVs8BnY8Z7Zz04r+tfoUq2CzNPv/8AIn8F/Tha/tjL1/dX/t5//9D5LuEjuN20tkN1 BxUEUDbsED5eh71/0JR2aP8AnWTurnUWuh6g2l3OqxQgwQ9fMjdVbHPBIwePQ1hpKDPLdww+VPkR tCFKKQB2Hofb1rlnyzTXZ/1+DOik5QUZd9V99vzR+2P/AARU1O5vf2qxDLNdywQeGrgG3lZmitpP s5Hy9uAV49z6V/XeRgkDscV/lB9KrDUsL4lTp0IpR5FotN2z/bH6NuMr47wly3EYmTlNqzb3dlHU /ny/4Ls3rW/hf4YxwykSmSMvAzFY7hGupVI4PUEflX869sklxKz2zQWEzcpmFViDYxuIA4r+l/ox 4aH/ABDWGJt73PNX66M/j/6UOInLxHq4S+ipxfzaP//R+jv+CZMupz/tn/CCO4lW5kj8ThgypmUg cuzuPUb8fSv7ZG+8fyr+wvpbW/10w1v5P/kT+b/ovJx8N4J/zP8ANnw1+3Z+0pr37OPw207UfDmm 21zqXiW/Glm9u3Kx2MTfLIUx/GQRgnjn1r339nm8uNU+Cvw61m73fatc8OQazcFm3EvcqJCf16V/ P9fJoYfhKjnLfvVanL6KKa/NXP3HC5i6+cYjLktKSv8AOWv62O78cSeV4T1l9u/EMY29M5lQf1rf 04k2FkxXaWtImK/3f3a5FfK8loJs9xtaxLEqRPG3nrE0I+/54Uxfjniqapo9u4ZP7KglxwyCKGT8 CMGuqnh8RXtGhG/ors86piMPQblWkkk+uh//0v77w0ZQuJYigGS4cbAPrX4Q/wDBcf4l+FW+CHhr 4aWmr6Xd+JdX8Q21y9nFeJNNZ273EcTSuiktgYJ6c7TX7z4LcOZrj/EfLoxptKE022mkrJrXTuz8 K8b+J8oyrw7x1arNS54pJJp3d09NeyZ/J1qKLDqFwgBO5yWIXGzPP4daILOWwwYFkaBiGJXryP6Z r/Yyy5D/ABif8Vo04Y7cRnzro7nk3bHUlseoq7dWJuPJa1fI2YO0fIRjjipnuOl/EaPtD/gnKCP2 xfhBpdxbyXH/ABPknZnjJtcFlRVDY4IJYkV/d5X+Z/0yP+Suwf8Ag/8AkT/V36Hsv+Nbzp9qj/OR /9P+x/8Abs/al1T9lD4RxeP9F0ez1nUbnVBYw29/uNuoBTO4DHXeOcjpxzX4o3//AAXE+Pj3CR6f 8Mvh9Z2rxLi5vku7hy5+9wkw29uChxX9W+DPgzQ8QcllmuImrRdrO9tL9ten4n8q+NXjXiOAMw/s fBJqdk20k3qk+ui3ts/8vj2H9qL4g/tMfta+AfFHj+202wvLrXIBa2Wm3MlzYQxrLDHHGA4DDBkA HJ4YV/Z7pxDafYMOjWcRHGP4F7Vn9IjhnDcJzynJ8LFKMKclpot10PqPo/cT4vizhvFZtjZOU5VN 3v317vXc+Kv+Cil4lj+yj8RZXLgGBVxGP3jFYp3AX67PyzX8sX7BtxNrX7U3wvNzEx0+58RxeWpf dJPKct8zH0OK9/wQw0KvhxntaSV431/7dRw+JOLqUvEvJMNFu0unR2fU/t9AwAMAYGMDoK4DxS6/ 8JR4IjyN4v5nx0IG1R+v9K/k616j+Z/RDfKj/9T+/gDHHpxX83v/AAXHtZr3xL8MraJyCbHdIfN2 BIlMzyZHv5fFfsnguk/EbLoy/mf5M/MPFhyjwJjpReqivzRf/wCCGkCSal8ULxZROi2i2qfMWeBo 5SCD7EScf7tf0Z16PjzBU/EbFQXZfmzTwvm58D4Ocv5T+T//AILqXAuPj/8AC1raNWvbLT100kgE yx3E0KSgj2XH6V+QekW9va+NfD+nWdr9sWbxNb2yk/OGIk6Y9M8V/dHhE3/xBnBp/wDPmX6n8E+I sIrxsrqO31iL/wDJkf34/BuA2/wp+HsTRmJh4TsmMbDBXdCrf1rlP2m7lbP4B/FW4eNJFj8H3TFH O1ThM8/lX+blR347d/8AoJ/9vP8ARnMH/wAYrUiv+fP/ALYf/9Xw64vke81iS3FuqLq1wHSR/mOX bGOcnpj8K4vUY5LqYFfKVj8rclQeevft/L8a/wB2+GlbIsIn0pw/9JR/ghxtJLiTHNf8/an/AKUz k57BxcrJv3lflQgEYBxkGr8Vu213JICdjX0UL2R8g3710NjV5Zytws8QCgoZBgSr2Kn0pn2jUrWR o7ArJFKSjLP+8CgjBx2qySy1g8NosgmP2nfv2hMBKoXE1zKY4GikkaGPc0+zCDnoT+VAH//W+KvJ Eu5iGWXG0ZPDYqSC22BRkhwPnCt8tf8AQIp9Gf8AO+OuC/mIFbO4YYnjH40Saa0picsXgX5rgqw4 AxwAfWm5pbASIIpWCzqfIjUhAFGSR0/UCpfJaTaFchE+YKzAbR/kU1JN2E3ZXK26FZpIlkBfZkjP GKdDuK/MNsWdu/bx+FTN30M+fSx//9f4sZUZTJA7M8blGzwDj3q7O9uLRN0ci3BTL5IcMe+OOBX/ AEAH/O1zu1jPtZopZRbEqJJAWVWODgd6veUUhKXBUlWIURNkEZ4/HFBBBDbXOdsDmMtxnOOvH9a3 reOazZejtt2OzEcjv/KgClcOk0hnmnjiCEJFG+S8hPTHsMc1kQvcahOQYQoLlMAj5uwI+tBtJO2h /9D4wgElpetsXmOUeZG43oxX1HQ1allaWd8wlJSuRIDtX6Yr/fmTuz/nZt7pC0b/AH8E+X1wOTV6 AtdA20ZaAMvzso5HuaRrFWVmVJStrdyWZBnEUOTMHwu7oP8AH/8AXRse52pEyxtjmRgSgP0/z1pN 2Vy4fEWEgup3kS3tZppbcfvjFEWCBRyWx0HvT3gnZYDNEIht3Dew3AH8fasXJ3ua3V7H/9H43jSd p51aWFbI25SUvnzJDuXAUYxV2GKXZ+7uUitoELeWy7mkxwAvp/8Aqr/fA/57Yu6sZVtay2kpmjZ1 Mj+aNxOYvQe2K0Gmup4bqU3Ki7JLL5xyZST+poKKVk8n2mGK5w5ZxvLfxVav50W6WO2yzmTy2ABB U/1obtuBck0/9ykssiCQkjYpOUxxz2/I1fido0hgOxYQ2ZpoIgWIIGcHGeP51i3d3N90f//S+O5m lmz5aM/735pScFV5qxCsIIjlZU+YHc/QEdDX+9B/z7NXVi4SVlbyXheGceW8ZbcOABnI6AnJ4qpc 2f2FRcxL9pVUyjICQ57jBGeDxyO1AlGysCNPepE4h3PGuRGRyCeuKZp6R3N0Y5EaKN/vzFSVi7c4 6UDUVHYtm1kW7jWG2mdQDJCf9aZQucsMDpwT7CrjXVvPsh64cuwZVGGwM49uB+VAz//T+Qb7Y82b MgMuBM+0gEDqB71keZG23Z5itu6TIUP4Z6iv945qzP8An7p9joYhcTRSR4bYVwyRg4H0H+elVFtH ERU43D5sdSMf/qqDQWA3BlZ5YzLmIq8hyACMD8/8KsG1W4t3meTyhApfMgIUY6j8aCoytoaFvp/2 i1hZhEkZfMflptL5xkk0Xelw20lvKTsWNjIW3bQQPT8qzmtTqjJWsf/U+Td0c80gO2RFTcjLyrDj vXR6esM2jzLBJE0SXB3wghX3EAH68Yr/AHakktD/AARh8RoeH9MsEuo4LmJoZpWwjkEvubGwk9gD iv7Ov+CcmnPa/CLQRLKl3M2jQM7KxMMO2ONMISOc8nIr+OPpb1OXhbD0+8j++/oZU5f2ljqqelrf g/6+4zf+CmGpS6f8FdZ2cXDQO1qiqS5CW8oY5/4FX8ZttfxQXKzCK4D2KCC9SeZZWYEKrKgHclm4 56+1c/0S4JcN4p/3kYfSxm/9ZMLHyPy4/apt7f8At2aztdSj8qy8yBboQhN5WaORDhuB1PB/pXwj fxusk7efvkSQu8mPllXk5Pevxb6VNRPjmMO0F+Z++/R6j7PganK27/RH/9X+R2YwzM3k5Zc45XBb tU0j+VboiptkLYbAxXPsbQfukyQrJbk5bzBk9c/hVSOdRHjdyhyD/d+v/wBesG76s2jLXUWRLa5H mzruDLgMOKrPHEVARmxjaqdq527s0GCNIY0trKBcYxJuGNnPOKsRxNGAqqTxwx+YKe+PSs5tWsB/ /9b+RCSPAyjqS/X+6azY5ZDMq7cgEhweMD1r589AcrpGu9TncThuzfjWPcwXm6QzKyFH3g9Bg88U AaRuBJDChmVSqfKhP7w4HUirSPIcSNhiq4bAxnik0nuFhqlmJEDuoZtzEDOKQJOitGd80srbkONu B6AVEo2WhUbWdz//1/4/luLgyBXUxoflYHgn3xUEto0c6LJhkcfLIh6elfLnoFy3WRNw2jG/y1Lc BR/eqvqP2OGZEubC2luraXzrW6B81wMYIHYZ46c8daBNapmLPq91eXAjS08qNDtLAkBj6c+ldBb3 BEaBgGZBxznHtQMIrjdNIEi3/LtZmGc59KqbfJaQQ3rxrnbJFtG0nrjP+FA7M//Q/kOSSN4o9zFh GuOtYkmoI908QUNHE2XJBG3A4I9a+XPSUWwuLoTKJIFLxOBkFMflV2G4SOAqxfgYjI42n/PaolFv VFxjbVlefUr0PFGjLE0TB0kK7pGHXrV26u7eQwOVZLpQVwRjcfUGsrW0LItjMMkIXAyxLcVmBndm ETLt6H0Q+1NJvYD/0f47LTdbHepLyKcF353H3rSWYg+azLvXkDt6V8hyvax7K31JRYWl+RqU8MUi pJteJTxC+MK+P1zWfdOEuZ7ZFk8uBFfdtPluGqvZs3Lmm6iIrlWvrcy2mw5VCFYkcDr2/wAKnmub R0jNtZz2yTxmUDgpnJBxjp9KrleiAZas4REH7uOQnJYfzqxeCPyzAGDtjjFWB//S/jxjRbYTNLG7 uiEpGG2lj/n+dbloRFHGsisFK7vJfnBI718jKLTufQD30+3EK3l1bwqpJIU4IUjndWX9shn3siFo ySocjAbHHHtUkSlbQYmoXKXDvaTSWwVNrFDgOMcqfb6VdVoZoHjmijcSDI4yQ3XcD60Gbbb1Kf2R 7RPOk2tk4gGMOxPQc1shvLgBIy5GQH43euKBH//T/kKR2MschG35gGHXiny28kwk8s4V5BmQj7pz nivlY/Cj1J9jr9I8PPqk0Vq8yLJKNkQc/fOMgZ98cVmyaVBoObXVo5WWe6lQRxhlMRGSCxxx2H4V SdpJDTs0vI9p+EJafVLeWKY/YoCxMM+5mlwcKMk56/yr9Qfh7aamyaZZwW4gjnNvdiabAVCWRlwO 5zwPSv68+jnF/VMfV7J/kfzR4xT/AOMlyym+sl/6Uf24f8E3dLmtfhhptxcyYuJ9NQ30TkO0YVRt wenzE/pXln/BWHxK9p8IfEEVugmW90wWciY2eSQsiqPbIbJPpX5PkVJY3xblFda35SP6O41qKlwF d9KS/JH/1Pyl+JEsl9piSWcbaTJdxyC30+MFpII8Fgp79D+dfjR+0BBcR+JLSK1QDT75JJVaRGM1 4cjM4P8AdyGUnnkEdq/vnxvbp8Eyj/h/yP5M8Gpc/E1eaXf9dD5RvPkunFs4iUnBYdSR1IrSiilO x/MJ/vSkff8AWv4Iqq8mj+toSSO10RLOO4j84Ge0lGy/tx8vmr6Grd7LNeXMYXT4Et7I7LUqcy7C eN2ev0FefVVlc3U3axsaVorX8os7O2eS5ctM/wDBwAOB24xUdnO1rrNrDBE+1WaG4eRTnAzkKD7g c+1eVXVrm0Xsz//V/lM8N662kwM93pSai8cZMVtJMbcPuHBJHoD0qa1mH2cl7eMGWXzobXBZYmY5 4B6YzXw1Ve8z1pP3TWvbuW1ayuJZsvNiBhBHukhKAAYUDPI7+1IdLtI3bV0eeW5fKN5ieWEX72Tz 1zWFkRzu5Rspb579J006W9sSWNzJsElvhedrememe2a2LfUdJ1OXy7PRJNMMSFmie3IZSPvkH9cD t+NY2tdEylfctI8M0flxAzQlzh5BtK4OOnaiazuXhivNMuo4Gt50ZlBBFwoPzKeDjgdfcV0YdKKH Cex//9b+N86ZsmaW4nOfMYiMD5WXPy5/SteGJr+3Fwbp5pxHszJ8jYX5QB9ABxXhJcskmbc152M2 00wKLOVJLeQXV40UYkm2TB1IJLZ9c/mDWnqtjqsWnapJpLzf2ihSRuARGqH5yvHXnj+dXF3Ron7r Rw+2WWWO5Z5g3Ej71Lln6sffn61o3sj3dy0TidG8lZSeQuOAMt05xnFUStdjDd7W0ltWlLO91L5M IVS25ue/4Gu2gQjTZ71IZpkjk8lbYL5c8jcjKqcAgcZIq4OzsTJ2R//X/j2i0+Oe3YsBEpXaUcBF f2rIiN5aWj6U1lGscjyXa3kgwF2fcypPPU4+lc1J62JckjW8PSQSzRLrMNwke58x2zK0jIBhW54G Wxwe1c5qNrFBPPYz2txHbsnnW8syjYwbJyuDnI9wM8YzXXB2lYwk3yWPF9dZIbpnsp2lgQlHkxtJ YEggD04r2T4H6xcXPjXQooEnWe0/0lWt38ssoKAqw646k9uK+u4Vk4Z3hpf34/mjx881yitH+6/y P240G2tL/ToHgtroPeWqyxXUxMbOCP8AWYAxgkHOM9Div7LP+CL3iOWX4VaDp18rxajdW8UPlqCV kKsD5jDGPmVmGB6V/Y3jdFV/DSEl2i/uVz8Y+jxUceNMfS6csj//0P6/P2zrC01T4GeNIp90O22B g8o7XjIZQzN/wEsK/gh8faBdab418WWt0irZaV4hnsrRFufNkuBEcNJKuMAsSSOehHTv/YH0V60U sZQfr+R/NX0lqbjj8NU6Wt+ZwtzYvdz2ljaQK8l5azXRlWUBo/KIHlkepG5voK4q7sM3ASRWR7T/ AEgMxAZdvPA759Pev7Yoo/kLFO0EjNj8UaXLczWTw3KM0ixWk1xCfKk67twHI6fTrV261gBy1vGx g8sRbUTEK7QBjd6nrXRYxTGyRGaGG+ngYLJEVsw7AgEY3fl/hWBdwXjOjWd1KgXIuUgQNKhJAXHB 9evvQB//0fy60nUJ0822uzE0s1t5CyXduJvLYgDzCB3+grCMT6f5kEkEkt1dyE/aYojHCcd8dPTi v9oD/KhNrY3rTw/dRWk82qQwFXCiKG4bZOwI4fb6HI/wrbt9JgBld72zRP7OaOGxWIsZHZCFBbpn 27HvUT2NYXa1Oc0qUOfLhtQuoICJbdSTKCmSSD0P1HpTb+HTXumv70ssqptjkzuAJzlSPcnrWQpt pWQkeiQ3VrOhuUhWeFhAVYOyPjK7hnj/AOvSR6O0mmRSpuWK1uPJedfl851ALdPwP40EJNs//9L8 qJhHPK13cKA6v5cRC4C7R1Gfy4qC0gE17G9vaCJSwjkJbKztk/Pg9Ov6V/s5B9D/ACvLcmrXWm3V 3A1kjosnllY3ygx0fP51pWv9sXtlLe2wjSONCzSO4KxgHA//AFdacL63Ilo0JpF9qhgvpo5Hjub+ FrLzXj48sgfKFPTnnis+bTnsrWOOeWZrq3z/AKQXLNKScmrKVraFRUjiRXmEpeThVjTLyHqABT0t 4ZLlBcxtLvI2eYmGhAx8uPTI96CZvSx//9P83LfSIYtFF/bQwwwC7McyROPMV8DDOvUAgDHbiuVi tZ7q+cG/n2EHykKDY5GOMdu/5V/tAf5SuVnYWR50XyGQedHJsVScEjPBrWsptWQIJoTJC7+WHOGV MDken4UGctxBaJaz3LRtOrFc268CNWJ6kdP8KZFo16Xa51K+CyXMamVkO9IsgjC98ex5pN2RnezI LywtNL0x/s8clxco7SyTsxAcHsB/jVrSdFF7ZDUrXdFDKOCJvvSLjcoI7jrg0yj/1PzQhmhtFYJC JNR3FGuHz5gweB+FXY4SsARUMQc+btdy5LHJJyfU547celf7Pu/Q/wAnymtj/pC3F9eS3M9yW3i6 IVLfadoXce2AOv8ASpYrj7a0Fhb6ZHcf6Vt+1veeSlsAT+8xjDcdqYNpbkmpaZGciOd4pmGN8Tbf mA4Pv0rIsrGOXU4Le7mZUuJPJnnjQSSx4B7f56mgwnPqdFpRuNH1CeOJLhYhF/x9DhGByCoOeuM5 4qW61C18gHSIvOMm/wC1T3cfmbnPy5xxt29iT6VulZHM5WV2f//V/LWeym4N/L9qDYNwsZ8lmHqD zj+lbuiPBbWzBLp5nMhVRI5lkiPHBJ571/tXBan+Qk5vYuNe6vZzedG327y1JkFwgZFR+MD6Z4qg utXkcqXAZt8UnmDHyhT04rUzuyxpl3L5XiHU5TBqkz27Lo8M1ujLaXA243sevR+D6/k661GWWzRr 0sLiYhw6oixK3G8bVAAHA4H50CLKKLi3SK3l+Y/f2jAIPapNUtmWCCI3BMkaYjhB7D2/H9aAP//W /NJWtZGsnhtLo3A/4+nuXSWBGUjGwAArnrgk89629Ttz9ri1RJLmzvHgERlt7gxpNHyNjJ0I5PWv 9sD/AB/MW5uprWF45pZTaFOZncIq9/n9qgQPdRaeIzbh5FBPltuQL0GDx1oM5kcqeRdSxSKoVMAM jYbeegPFa13O8NkplikWaF/LdXXGD2yD0PBqofEh09iUJ5iWUohImKfK5TchDZ5/X/OK2Le2uJ2j eS4ii+xI6FHULGQMuDuxnOScfUCthSl0R//X/NC+S/vb+zlLW8sbgs0avmVApxnb9f5iuiSwMX2q eKBJZpo/9KkZsMrdRx26mv8AbqHxH+OzdkYFtpi6hfCGUIuwea6y/IjbecZ/xrodZlufscNv5i7Y MJHGEVWAAPXAyf8A69bC5la5z2mS6zd3S2hUTu0hEWAE3IAT8xPoAcn2r2DQpUkaOC4TyZYAqBlO 5ZdvcVdPc5K8k07n6ZfsIXEOn/tA+Co0mj8u8tDZu8kpjktUeRG3Ig64JbP1Ff2s+F9knhqwLOjK 9giNLDkg/Lgmv89/pY0+XifDz7pfof6KfRjnzeG04f3pfnI//9D9If8AgsV59v47sLxIRNbx+I1n U3UOVKyRpb4ZcY4xuHqRX4K3EU44ls5oVnk+0xmSIoOeAVP+HSv9b/o/S5/DbBNf1oj/AB88Z4Sp +IGZwl/PL82VJo7m1RcRS/McFsH5ff6UWf2l5N/nH5SC4b5wQOMEdK/d4qyPxqUkpNHTQaTA8LFL 3y/3YkGV2ox67evaiKbTksIVtI7saoHZLqW6lVrdcHCmJcZ5HXJrWC1OapK6M+9uoLswW12wkuLf LLIo2qA2Mgj14H5USaXFHJbNuURZEhAOPr9RWpyT7H//0fjhZo2khS5TBE2yIqvzAE1189totrpk k1ve3E+qZZJLYwYjVTjY+7PXOQRz1r/faKstD/n7mcmrGdCk6fMGwM9a0I4YriNFkYI1uy7cAfIo bJ/rVGM3ZDruWC+uMQMrwx/Lv7r9feqIkitZzuVJFQfu9wBGc8H8OaDNXs7FcmO5llVowisd0eOi +1UjA8Mw+8SvKsO3pQJ3T1P/0vjiHbN532gb5Np24byyp9cDr9Kn0+Pa8hjkMYVMddu72/z6V/vw f895oPZQNEss7PlWBUxyFXQqQeexBxgisaYwySv+6k82NsRSEbQQevHft+VNK7sJ7E5jmmjiiKsI lbgfwqfWpTLsiNunlySxTkRuT94dMj9a3MCpFBPmea6k86aSUsGPXHYE1OFWABiMkHdyMAUCbtuf /9P4/wDtLySMgARZMDA74pw0eeOcXZ8hhIAuxWxKoHqD/TNf9AB/zwPcluImiQFQrEHjGMf561Ci TyI0cn7uOT7ue/bigQ0288FlJbJdMUiAUpIx+cjgZHcinWtvGqxC/LDyV81fKTHmZPOM/T9KcVqg Ir5o729kkt0NvFuHlo5yygDHNOkisQlpCtwEuJrkRSSS58qMEjk9Tx14963C6W5//9T5FnRbe4Nn BOlxHISiyRjCy7e4FVby5Frav5kIi2jD+WCd3PU/57V/0EH/ADuqaKawyJHHOJA2/kBTn8TUkDBh JIx3MnATHU04uzuxp3RWCbldphhs5JRcAVYtbVs7o3KqvzBmOWNbJpjJZoPtGYizKT/Gowwqaa3C yII32xwRZO7q5A7/AI0N2V2B/9X4oeeRJFllVlR5NkbAfJkdv1FPcyeesuWw42CILliex/IGv+g9 O6uf87rlFFxZi0Y8kEPETumUYKn0JpkkMtlco0zBoZEyDs3bj3IamZSlfVlaZkDHyQX3/MCRwKie B3MfmRqGC7sryVoMpT6IubX2qreUVCkBVz5hPY1Nb20jDyZEZGHKhuauEraMi7e5/9b4yaCUSOpP 3Qeo60sMcQMZIcMEIZB90nsfwx/Ov+he6Suf855OJElY/dPlfKdoCscf196j2R7BCVDO53F/8aYE yXMOxLd40cISJFZQV+tWmtkMRaFSUHBYDhc9P5UnogGQwRxQuwXdztbcM4NMt5GWQx+TuZ0KxgDJ 57isPID/1/j142UbHaTcp4RyQRRPYmGNZ9xUv90Z+Y1/0IH/ADrNpLUd5UV1b+XI7o4HDKOR71r2 VhqASGOxeS9mdhtMWFZfTjipn8JrR/iR9T9qf+CNkmo2P7SOjLfyTw/b7SQyW7Sics4LQqzY4UcE Y/2q/r4r/Jb6VUF/xEmdv5f1Z/tt9Heb/wCIQ5XJ/wAq/I/Ev/gtRppufhV4AulmeIpqd5D8n3jh YXP8iPxNfm7/AMEkdRtE/aI8M28e797bR3g82Z+DOTHhQT1BODX6HwJh6VX6P2Lm46rmPzHD4qpT +kXUoSejS/8Abj//0P7+K4W/GzxlpJ+b95aSx4A47nmvWpK1RryZyV3aafmdyeh+lfzO/wDBbyNb b4p/DjUDZ/avL8E79oPlgO1xLGMnuCF/Q1+zfR+aXiThb/yy/OJ+FfSKbXh9K2/tY/8ApMz0j/gi Xebn8YxJbvCklqY3Tz/OVShLZ9AACq/hX9DR6H6Vj46x5PEfGdtPzZ+g+H7vwNllt/ZI/my/4LY2 2sj4pfCu40V7uLUH8PQz2k9ood4yt1OpOPXciEfSuu/4J6/t6eM/BF1B8Jf2itZ1O68LwrFbeH/F +p6eSNLDrhFlkUZ8vdjP3iuW9q/WoZBl/EvgphMIpJYqC5obfEvvtfZ9bN2PwLJeIMz4e8Ws0eJi /qVSbTetvievZ2vdH//R/vT0Hxn4R8UwQXPhzxNoWtw3KCSE6ZqkN47gjP3FYsDjqCAR3FYnxL+G XhH4reENb8G+L9KtNR07WdPmsTJNbrJcWZlRlEsTEZVlJzx1xzX2FCeZcPZnTrSThUpyUrPS9n+T 1XZruj5PGYfLuJcjrYWLUqNaDjdWfxLR27rRq+qa6H8fH7dX7E3jD9lPxPLqN1Y3ms/Dy/vhcaPr kEbXMEOflzIwXqmeVPNfAMt6iyCaCdJmMXnRyRN/qjjKZ7ehr/Vzwr4gwvFXCuGzTD7uNpLs0up/ kfxpk+N4U47r5PjVrTqXT6Ncx/XX/wAEibyW8/Zrie9EL6k14s13PCFAl3GXbnHGcAZ/Cv1axX+Y /i1C3iDmUf8Ap5/kf678MyU+GcDNdacfyP4s/wDgpb4G1rVv2zvide2Vhrd/Bd+Kr7cmn2bTozsY I41JA4UeUT/wL2Nfnt4n8EarpcEx1G11K0Fv+7mJsmdbc52ku4JUAHA5PUiv9TvCLiHKavBeVZdG tH23s0uW+u7+V/I/xp8VeEs9wXEWY5tWoS+ruo/f6bL5/O1j/9L5geNLFPsw/wBIY8MZACTx19qw rfMN35sZ8tkbcpHGCK/6DofCj/nhpz/dss3c811KWOGkfq+MAmls5WiPln90WO1uox70KNk0OnUv NK50lrK9uRCN85lbY0mzOxW+X06DOfwr+zn/AIJDNGv7JGhQxTfalg1F0W4bKtKvIHB6AYIFfxz9 MNW4Co/4/wBYn+gv0H5X4gzVL/n1D/28/UccsM+tfyi/tL/tq/tEfs3/ALTPxW0X4ceMZLbSovFF 6LjT7pRc2UcCSkLuiIIDKzYDegHBr+Qvo9cI5fxjxJicszFXhyLdXXV7f9ur0Z/R/wBIfjbMOCMh w2YZc2ptyWjs/srfdfEz/9M+Lfx++IH7QXi+Txd8Uri11XWWRVtrqLC/dx94KiruG1fugD25Nful /wAEOdK028uvi1rJhRrmwcJCXiDNbs7Q7tre4YnA9a/1g8bcro8N+DOJyrAaU6ceVeji2z/L76NW Z1eJvFxZlmPvVJxlN37qUEtz+h4k8nv1r8pP2jP2vvih8Mv2r/CXwk0W7tLbwvqTWjyQvZxTvdec UDB2K7guCehzknnoB/nPwRk1DPsxq4XE/CqcpfNW7ep/oVxdnFXJPqdSjvUrRpvrpJP/ACR+rEbm SKKRhtMsSyFcYwSASK/Or/gqnGZP2OPGwAJK6xZuAB1IS4IzR4du3HeXeVZfqeV4wRv4cZt/16/9 uifxG6bFLeaRZiRGMjwhRIBjcBkD+Qr0PwNo9rp2s+HGkjb7TL4ntAJTJucbpVHA9Bzwa/2Sz2Vu HMRb/n1P/wBIZ/kF4YJ1ON8si+lek/8AyeJ//9T+7n4Y7f8AhWvw+CkkDwZpoBIwTizhFee/tQnH 7PPxfG9YxJ4KuYSzdMOApH47sfjX6Pg9PEOPb61/7kPhuPVfgDH2/wCgd/8ApB/BJc2NvBrOszPb RKG1WaYusPlK5Dbdx9yFBPvmuKvtUae6aS0wIFO2NG5A9ea/2rymfPgqcv7q/JH+JeNXssVKmuj/ AFZ+gn/BLcX9/wDtnfCp2tNgtNUiMsvIDxeap3DPUbgoIr+4dvvGv82fpexT43w0V/I//bT/AFe+ itUcvCui/wC/L/0qZ+Pv/BZa9gj/AGddCsJLcXEl34idUDLlBuEcf0z8/H0r8Vv+CXN1F/w1r8JI EthFMht4XRyTOuJlXeR1GQrZz6+1ff8AhEmvADMF/jPyrOZqp9JyjBeX/ptn/9X+/E9T9cV+Yn/B Tr9o/wCJP7Ofwu0PXPhtq9xpOq6jcSo89tAkkg2tGgJLA8DzM4/2Tx0r9Q8P8nw+f8a4PKcUr06l S0vRf8H+rH594qcQV+F+CsbnOGdqtNe76t2+WjevQ/EKy/4KZ/tpa0lgLD4nXLvd2kSosWjWkckj uBnqnB5HJrp4f22/+Cj8oYReK/EktnFKXkvYdDtrpSgBIIYW+MHB/iP6V/aOO8JeA8qqKGMhCLe1 4x/4B/Gb8WuPczw8KmXuo19q05W/C/6H6Uf8Ep/jF8VfjL4i+KWv/FrV9T1rXodCjhiutVTZcKgu 1+Xb2Az6V+0SffX/AHh/Ov5A8VsDgss4vrYHLrexgoqNtrW6H9p+HOJxuM4QwuNzD+NNXlfe/Z+h /PV+0xPGv/BTfwHHHHLMIdd09rhFAKMD5BI/8eav6F5f9Y34fyFel4lQislyG3/Ph/oeR4XznOlm k31xEj//1v6oP+CwSO/7G+veT/r11+HyztJ4NtdKR7ZJWv4vLeO7ks9LthDHZpa6TbieNoRDNNI0 Ue4EADnOSd3PXJzX+p/0NtOBcRH/AKe/rI/yo+mjG3iDTl/07/8AbYGZc2AtG8wZYg5+Xn8KbeSR +Wm0CQygFyAfl9Qf89q/tE/i+L5WJGRFFm1G1xzuHJHHNMVHkiAdPkVid+z5mPfmi3QcdJI7jw7f r9q0iOC2dj/advaqo5YHzFJkPqB1/Cv7+v2ZJru4/Z6+D81+MXj+CbQ3AC7QW28kD8q/gn6a0V/Z eWPrzf8AyR/pv9BacpZHm0enP+NqR//X/um+LrBfhP8AEvcqtnwNqaqrcAk2koX9SK/imj/Z2+Lf iLV/FWo6f4I8SalHea/cX8cthpsj2QR2DMA4BAIJPGfSv7S+i/xLl3DX9o18wnyxdl99v8j+RvpP cL5jxM8BSwEbyim35W5v8z9IP+CQfhHxR4N/ab1+z8Q6fd6a7afcxRw3kDWsyqtpIoR1I65dzjnr X9PjfebHrXwf0jsfhcz8QHjsHLmpzpRaa9ZH654GYHFZZ4b4TAYyLjUg2mn6I/nf/wCC6tnJff8A CqoImjhkj0yO4inl/wBWrreXQAI7kgnFeV/8EIbzVb34nfFSS9jtpVTQvJe7ji8tj5ciqm09wQep 54r9cyFRX0Z8VB72l+TPyOFVr6S65f5LP70f051/MP8A8F37oW/xI+G1vbwLdXN3pETsjqPkKM4G 0+wy3/Aa/Jfoyr/jauC/rqj6T6VVl4V4pvz/APSZH//Q+Yb5JZGjlZmOwH5R91T6Y/AVnjZIGUKN 4BG48AV/0J01pZn/ADrYh/vGN0tUtHaW5mkEz4RYlJZO+fwrrtBv47rX/D9t5Riz4jtYvLHEUuZO HIHccmvNzmH/AAkYq3/Puf8A6Sz6fgeSjxblbe31ij/6cif6EXwX+X4O/C3aGTf4D0yRlIKnc1nC zcfUmvLv2yPDtj4p/Zr+KOnajFHNHb6MuqWzSgM0E1tKksbqT0Py4z/tEd6/xb+sVsL4kutTk+ZY l/jO35M/3C4my/D5l4cVcHVV4PDxfzjFSX4pHwX/AMEZbY2nwV+IMb5DP4nhKBh821VnJ/8AQxX7 Hp99f94fzqvFaXtOPcbVe7cX/wCSRPV4Ij7PhDA0+0Lfiz//0f3aS8hH/BWx40kdpf8AhP8AynRj kL+8K8fn0r+hB/vt/vH+dfuvih/umT9/Y/5H59wBK9LGx7VX+R+Ff/BcK0u7r4Z+AVt9QGmosreZ cMMof9Jt22n67K+Bf+CMYeT9qrWRLJ5iW9kTDIVG1x9gmHUdw7EfhX79wRyv6NWZQ6r2n/tx/OuZ QnH6T9PEdHCC/CH+R/Wc/wB9v94/zr+eb/gvGhn0D4TWwQF5cCBmGV3efMSMepC454Ga/CvANf8A Gz8tj/fX5o/YvpA/8mxzJ/3Jf+kyP5uDcXEwjs5o5pIZWMflLJ5eD/CWYdgQD+Ff3N/sCRND+yT8 I43dGddHbcqDaIsyOQv4DH51/UP0vo/8Y3gP+vr/APST+d/obS5q+atfyx/M/9L+8rxWobwn4rU9 G8M3ynnb/wAu0g69q/gW+LlvqNv8YPiZ55jjhtfE1zIiou4kliPmb3VRx61/bv0Q3bPsxiv+fcfz P4u+mHeOR5dUXScv/SWfoh/wSFs40/a68OX7sfMn01m8yH50O+C4VVb06V/Xy/32/wB4/wA6+V+l TFrxETf/AD7R+pfRpkpeFeDkurkfh5/wWhmjg8O/B13k5HiCJREV4JaYhWz9a/YH4NMr/CD4XMv3 T4A0krxjA+wwYr86zmP/ABq7LX/09l/7cfouRtf625l3tH9Dzz9rZol/Zw+LpnZkiHhVtxXof30f Dex6H61/AfqccdxPJaZcfYLma1iLR+WgXeWwjdx82c/X0r+sPoV64TMvX/I/g76cCtmuBb/lX/tx /9P5Z+ymCKQwp9obeOIxudcGovLlG2VXWNs4IYZFf9CB/wA6S+Bnfad8RtfsfC+q+C5by01DStSQ KkF1Dvk0tlYOGibPGT0GcDJ988Oj4cMpBcyABuwOeK5o0Y0/aOH2nf52t+l/U39o2oRl0Vvxuftl /wAEQLW4b9qDWrq4dc/2ZOvl5AZh/Z0pVgPQcdO9f1x1/lR9Ku78TanN/IvzZ/tn9GyKj4OZTKPW Cf8A5LE/DP8A4LA/CTx18ZtT+FnhbwF4e1DX9TSy80wWFq11hhcStGHx93k5z7V+O3jD9gX9pzwX pEfiLVvhtrFpa248yW7isZXt0Tb84JYde+ewBr9V8CvEfJeGeC8HkWYVOWdScu2l3ppv2P528f8A w5z3iTjXF57lkG6cIRTsn0Wv6/PQ/9T7I/4JeeHLzT/22fAtvqem3unS6VrJMJuowJWIjmU7gCQF Y4wc/wAQr+ypvvHHrX9cfSnxMMXxlhq9J3i6d0+690/n76NuGnhPDqnQqq01OSafdNn4vf8ABZJ7 hvh38NrSMlYbrXWRyW2oWBRwMevyV+nX7OtoLH4DfCG0G7EHgHTUw/3h/oyHB+mcV+VZp/ybTLl/ 0+n/AO3n6Zk+vFuZS8of+kxO28eMy+FtSVSFMhijyRxzKldNZrts7RcfdtY1/JAK/OH/AA0fYpXb Pzt/4Ki+I/EXhf8AZh1XUPDOoz6bfnVI42mgkMbFR83Uem0Y98V/LnY+P/jPr+p6ZZWnjzx3qhv5 VtJLbTtTuLqaQlgiiNIyWOWZRwDjPNf2B9HzIcmx3CuMxeYwUuWbbv002/C5/Jfjrmue4fiTDYLK 3bmgkrddV67Xa+R//9X9CdM/ZH/b41Pw5/aml2HxOtY7smZbdry4uJp0AyjMhAxxjvX5wfG3wH8S /C3j5rD4vrrz6xZKkVvLr7SyShgxbCbuEwy8jAORzX+q/hVnPBWK4jq4TKuX6xFSSta91ul52v26 rqf5R+MeUcbYHh6jPOHL6u2m73S12bvur/o/M+ejBYW0xiiMsts0m2V2YGUjPY4+uMjipY9ODNMy 6ksoYEwRBCrWijoJOxz14Pev6si/daP5Ja/eNmXdx7dhDrIq/Lx2rd0u1mubUGHeAJQvyELx6f59 Kmq9Ao/xz9CP+CcWmST/ALYnwnuCl0YLLVY3niWMmAnJKsSO+dvX0r+32v8AMr6X9VVuMcIu1P8A SJ/rP9ErDyw/hvKbVuao3/5NI//W/pY/4LafaE/Zq0iWJnEY8Q7HCjdk74G5Hvtr+S66vNQN/wDa xd3v2eWJEe2kjVFDr1cgDkn39a/0y+iW4rgia7VJfqf5m/Syi4cayqW3jD8FE+k/2WriHUP2kPg9 HDFHdtb68haIr87Obm1Pzj/ZALY/2a/vXthttrdSApWBAVX7q4UcCvx/6XTtxFgI9oS/NH9CfRMf P4f1p96n/A/Q/O3/AIKn3V5bfsf+Olso3eaa4hjzHkPGpWVWII9mNfzX/wDBPDTn/wCGr/hBHJDK LezvILyEOmXYjL7yOh+7il4I1IUvCvPn1bf/AKTE9TxGjKp4tZEnsov82f20j659z3rzbxKC3jfw cnPyLLIeR13Ljj6Bq/kVNKpJep/SMlc//9f+/iv5pv8AgtZcQ3nxY+HumHzZJrfw/JIsfl/uCGjO Nz9jlxj61+0+CUFPxGwEpfZbf4W/U/K/F2bhwNi4pXvZfjf9D0j/AIIeaFJZ2/xQ1NIhFazosIMe RDIRJHyoPPXcfxr+hGuvx3qRq+ImKnHsv1O3wypOlwTg6f8AdP5Jv+C3Gy8/aR8LwwrM8un6YHkM S7UyfJkwx+imvy48A6TJceNPCEEMjw3F34ht/s7twT82GCnqP/rV/cnhPVUPBnCSe3spf+ks/hLx AoN+OFSn3qxf/kx/fV8Nrd7X4e+CLaRzI8HhTT4nc8FiLWIGvH/2wWZP2bviwEJDP4UuIwFOCdyE Yr/OOHLLjhSX/QT/AO5D/QvNIyhwtWg91Rf/AKQf/9D5nexEl3eptkV47uTzi7EF2EhG7+Q/Cs68 VYZfLMo3YyADlsEV/u9w9b+x8Ml/z7h/6Sj/AAH4yduIsZf/AJ+z/wDSmQKWiMMiRCTEykRum9Ww e47ipLttzBi8aIzE+VCm0jPUH6V9DHZHyzaW5QJVES12FpmYymViS23oAB0AqtCkjT7A3fNMhzs9 C7KWilULM6zAfK4G7n3B+lRQtvDRzQyxxnO+VZBufB4+lA+dH//R+O7iOF9zWzHanBDHLD1qKL7N FIm6VkMhwVbox9q/6BIRTWp/zuuaJ3it5HljEwSSMZMbA5Pt7fjUFuHWTywSqsdpLfdNU4qxPPpo WryMQHZxuTIIHOaz5UaUBTujLDBOeAKaSTuTKVxq2NnbmGG3kkZs7WLndkH0PoKlSFlaSFn/AHRf 5QB0rKXxaEn/0vjgxeUNowVUdfWolxwWHyj5cEZzX/QAf865IsUO4umFYAhXwM/54qeCaANmRDIY zhl7tQA5lM8ZmRXtD1EbSB269sdqWYyrEpV3fcArOwICnuKAIriM/Z0a4ljibIiTeu0SZPQY781X EQTKxN5TMmz2T3qW0jVyvHQ//9P45ZRaKFeVJXZQ26PoaprDc3c4SGeO3eTG5p22IFUEnB9eOPfF f78H/OxfSxrWqOpW3eRhDM6pNIB8ygHkirEcaxo7wygHzCgc43NjrxQaQd9GZiQwvcSt1aVsyMe5 wBVr7N9nG/OEY4j7EEdT/Kk1dWLLtst80ly9pdy2ouEKzSQuN75xuHPriq8tjdJcKWiuGhddySSK cSHvtPes3BjTs7o//9T5AmjecPFbx/vBEXWNgQ0xBA2rge+ecDApYROijbGYJICN8Myb8kdeBX++ Li4n/PPGXVE1zFcNNGTM5hciV7bG1Izznj15qtdRpGfkAkA5TPBH4UjXnVyiqLKyliN27GP4kq6N MniZr+4voJ18xY4hbDBhB4G4nknPH5Umrqw+aJPqSlLma3MkyNEiuVmhMLfMoYHB9fUVYF4F0mKZ JysrEoIDFgoP7xJ7EVi1Z2NIya0P/9X5LtkZoVaCG4upxl5UhjzEqDHzE+3NQxwfbLgqAuzBO2Qh cgCv96D/AJ9xlvC4kMyIkcCNgl2JGM46VYadi25ZCFh4VM/IfwoDfYvS2s0tgLqBdzs3zKnLY78e tZdtBM7+XJJMiBxtiQ4BPvUy20A1YbXUFuvtweeIQr9nDB2VUGMEAfialgt4orpjHERM6k/v1x7b wDRFWVmQ5pH/1vmO20psyr5YY44YkYP4Vj3loFTy5IwzQu0g+XBX15644r/eSUW3dH/PrGV2UdMu biCZLyUyPE6GFI4uEIII3e+OD+Fbks2bZpIolDq3RxzS5GXzO1jM0v7Zc6h9n8ou06nhflVcdTj2 q3f2b28UyhJJADlsfwYpOLQ4tppFO11KeNYVZ2McbcK38XtVqa/fU90KKTs+XaeBg9cfnWMztj8K P//X+WbCO1htkAhmbywsDGNfMkYDA6fzrFv54ZdQvLA6bd2S21yDbLIDCzAjIdgD1IPSv91pv3T/ AAQo6tXPZPAlutvreiC8WO7ha6RJLeY/6/IOEz7mv7UP2HtOfSvhJoqLbrCgt0jitkIAs4+Sq4+m K/ij6X1RxyTCR83+Z/oZ9C+CtmMra3X3WPDP+CoOttbfCWRYn8u4heRGRkDAqLaRznPqQK/j41Gx 0yJdRuo0lhfRr52mitVMt4+2XKkLyWJyD3616n0TocvC2Il3kj5v6V9W/FmGguzPyE/asCQa3mK9 u133pkgnuPmuZjKyyBJl6E8n6Aivja7ukcMzApM+YpkPQ7TjIr8C+lFPm4/lH+4vzZ/S3gPS9nwH Q/roj//Q/kfhDEiWPaI/4WUA7u1X2KPGuVGR94965WtyqbeiKMhbYViyFY4LbsGnziFRuto1V2jE ckeN27jGcVzz+E2GvbN5MTFyDn50UY49qlfSJIDFKXO0Dd8x5wf51idBQmM8cUkYwiyHLOo+Y/Q1 JBdusYiCsyqnzSsOCelYyTT1A//R/kVlbdayFIt2SYyRwYye9Zs9vHFbhp3woG1nHU57GvAs1ueg NvNIW+tbBopp1htJBNbQodsZZegI+uPyq48fmRbZJWeTYN5cYKnpikBjyWiSzrsQ+dFhWwP3jD0F bkRjgTJG4dApHzCgCOIAowRxEXcgMBnbz3pJopGVHkRmaNTEtwON3tj8KT2A/9L+P2ITXE4ijVpZ CMFf4qtCCaUiBYT5yt+7Eh2ZPoK+YSu7HoEsKEth1ceWcFSMZI65rJ1NvNmjUEck7mxwoosxNpbl iaKOS1je1MTlRh0zyMf/AKqz/s7suwDys/NleOaQyeEXECExEpMg+VmXPI6cVFEsk0bpcSKzyEsX UbdrUGnOz//T/jnhkvY7lIPLJgUku+cLIPQe9aIAeZsW2I2GOTlvxr5c9WMr7mmqRwtD5i4jVdu1 R9361FeLGIWaOJXQ/MvbbjvQWZtpbGUSSlgvljduc8n2H0rViNpIWj3r5wjyB1zSsuoGVcW0xkQx yEbGy69mHpU0FnI0bMkezrx60wP/1P49GCwv5Mu796MIQOM1LPbSYCYClFxkcbq+XPYGmK4FjPFA 5ilkiKA7sbTzhhnuOv4VQj/tqExMt/cXAmgFpdIQrAqP4n49vp9KEr6I0U+5oi3aXEYUhsYJ5qJE KTrGZW8qM56Y3HuPpVODRDbe5JPK/wC7cJsiWXgk4Bx2pJBcQusyqFUuGkVud3Tgfp+VNwsrmsZX P//V/kJu1ju47eV4PLcEFvKO0sB/e9en61PCGnuV7kqFjLnCgjAGa+Xt0PoDVutGulD3V4VktmHl qkLZXgYJI6GufltitvsyVgUFUVRtCZ7/AOfSucwk7spQadJNuRJFzGu9VyF8welaMKwiaK3/AHYO OQSNy461cYXVxEmqXIS03FI52t5CbSOTA+bB5Udj/jWbFNNdiJnOxvLBIJ5B9Ki1tAP/1v5B4plR iXUsVHzY7VMFN2kUE1xJZ288mXMQG58A4GD37fjXy0VZWPSk7sfqGpJpkdpBFfXM9wHV5WA8h4wh yoBH09K6FdYn1OzMt28sk02A7XA/eEDgH8fX3q+W0kmOL95XPVvhfNF/aVtBbZWUt8ytkCRkKt8v tgjn61+uXw5ia2vPC016sp2xwLPbRPv+0lgpCoPqARnpg1/YX0eI8mSZjU7J/wDpKP5m8XLVOM8q pP8Amj/6V/wD+5b9hfSlsvg74cuWilhur/QbQ3hljEYDrEqFPY5UGvg3/gsJrJsPhxqMexY7ee2e J4BKPnmiQY57Z+YH61+XcBqFfxeb6e2l+Ddj+h/ERunwDKL39kvyTP/X/IfXdQ1DUbYCWKCeS301 bZ1edbYxoIwrAsSMtycc5z61+Nv7QGs3Vn4xvNGjtTFBZxyWcUc9wbiWEJITtiI4Chmfiv7q8e63 JwnGmnvKP4H8reCFDmzjE1Wtv1PlhmMkxEuRIWycdq6fT45mdYlLbEXjccBvYCv4YqfGz+p4Jpan aaZZNbLK0gYs53YY7tv0q5532N2uX3ybRuRQu9vyrz6u1jpSsrGvpk13fT2+okTx3EDFwkchjVwe BvA/rW7aW9xPqQvZ9rXAm3pGVCIMepHXNeVXe9jeHwo//9D+W7SPDJ1DD2CSXh+xmeUAZcMoyygd TjpWGLa8Wa7jsYv9MgXcttJ/rR16J949DwPSvh6m7PVmmoIba60tw4Z454545PLiiMB3bxweew9M /wBa6i0vba8sZo9p3oD5iSDY2RkdPSucyMldVv7ExeVbedaKTHfpFKY/NXk44/z1qxaNAtnFq1te 3kd4bx/Ntjb8RrjCgnGcc4x7VgtmFuhp2c86qLdXjKs3m5KDJPcE1qm2uTHt0uxYlVMkzcCNyOSB 7+1bU+goJ2SP/9H+O6/iaGDy5blGuhuV0mAhxgcc+p54rn4Ly5gwit+6dSMr0Qn0rw5O8UxRb9qS Tm3FvZebC97cW9wbgOvyFCOhT361ZsfE+r6hZ3a2kMgFzGbOGZ8l4CDg+Z7cY61CfKzeTaWhDdWt 9p9vZ6XPcxXs6Azm8t/9Wm8AlOOMjj8jRYw+RIGuZXlyxLBjgADsD703K5nFtXsa1raWd/5lwIoE hjkxbQtjzLYY5OOueuD6VBFez27FZvOkit5mjhEowCoJ6D09K0pkn//S/jsv7u3vo1ilXzIpgAsS nDqw6HjkYNNZZ5I4jNcyySQptRbjpsHQBvUYrjp9TGSaZNoEkV/cTTFyAnybUHDY4yPpisDxprM9 mI5buaeRph9kinx8mOVWMH1x/WuynpP+vMzkvdZ5hdaXGLQM2DtcyLxgn613/wAIZrb/AIT/AMO2 0E0GmXd9fRWP9oStxbjklmHdOpYegFfT5BP2eaYeXaUfzPLzWPNltSP91/kfuZ4Wv7h/D3hLQNMu 4pbqx0o2unzuwSadPOkZnzznIJIx2Ir+u3/gjFqUa6DZ2+oXU8txeacItOu2hCLZzISBH7/Kw+b3 r+0vF2m5+FkOV7RX5H4h9Hepfj/MFL+WX5o//9P+zb9ozTor/wCGPiu2vIlurdNJczFMeYTtxnHQ 9elfwNfHOyXSfin8ULLTJor6RNeuNWe3vgbK5eKXa8aICcEqCeM9gK/qr6LFSSzPGU1ty/qfz19J ul7uGqru/wAjwLRLOKTWEv7+a5tXtkZbfzHPkqzr0cA9DnBrm9Q02+uzfzTzwtOkrGOJJNybdxAC HuAOfxr+76C0bP4rxc9EUlsYrO22yLHczA7lGNrvnsKdA076bOqW62sJlLNCeVDDPOeeTn1rXXQU PhRnWLQXDStNNKEtW2suCA7DB2j8+TRcX1xFdw/ZktYfJAmJkQyLOmcjeM4OOP61RR//1Py0SLWB erqlzJYmLUIvNghtbYuzZBwOuATj0psaX2oQtPcTNa3abojahi0YXoBu9+4xX+0B/lTBXeo6TUJY LNbC9i3GYCKKVJDJIijt1yP8KZcXV3bwCBtsoYgxYwJfQZasZNt6mxlWEF89+Q5miuQhZJCfLC+o Y+pB78VsPa6dPZeTMXuLiNi0gdQCSDgKjD8+akTaQlrDY29o6Svukbk20rgSRkdOM+mOlPg/0axF zbvI8bsQ8bIcYbgZ9PrQF0nbqf/V/Keaw1TUHS6JmKwWzQQQRgfZ4Y87iWx3J6ZPf3rRurU2Oj6X dPeww+fL5RRyiXTSL82zHXkZ4HYH61/szex/lc3ZXJLSOxutPvLy5eIPBKsRjkkEbybgTle5A7kd K3tKfTrixHhq1u47S7uo2unR2Jhiw3DGTk56YBrSD6Mxbe7K1x/ZUGmlor28udTW5CW8asggiEbf OWGMnPOPpWS7TyHzDIJf3vnTK8e8MMHgemPxqwUnbQfDqRnt5XitBayWz4iuHG539CUPA9KfDHGp tJru9tIHY4jmcEorcYzwevpz0oJbaVz/1vzDjsZWuGQF75uJEMTFY32879vHTrzWk9rdQrbTW1p5 rGT5pHbywnuOO3tX+0B/k+VNcURavFcXEebi8CvBDCxWLcAOmOOg5zTpNSYiWEwxwzI2IcPwD39j QKWiIrm9nmubX9ysdvEipMUJIlb1JPTjPHtWvPPamGPy5YHd3NuyKS0sfH3iPx7elFuhDgzFvtUt 7OSKGF/tMQJt5JtpKzHk5CEZBHIP0qCxjtPD4vbyxvJJoNYInt7VWBjinIUOSv3l6d/b2wFpWVj/ 1/zVtrJbSSe/vpGtpQqzgSt5qu7Y4bPYg1mXF7f6g888E8JRZ9kcEamNI1HUrX+0B/k+aN7Z208a 3F1fS2caRBFj2+Z9plchVye3OPwJq1oM1lYyxWMrpE21g3mZGCFP3cc9RQZT3sOk1mxMsNjBZy3V 5Jc/usoSTyd2fYdc+lVrWa20m8nuWjjM+9gY3XzGhZ+C2DxkZOM9K0gtLmM03sWr3UGby7i0k8mG JfLlNy6qZ3foEXvjB9aUXEENt5AJX7QwMzxjBcA5OR/nrWhhJXVj/9D8wrgwzX0SQFGmuJDDbxSD O1M8F+w/+sa2ZbC2sryC3it44mdgZ5Y5CY5WH3mBP07elf7V09z/ACCmrO5DeSW2n38cNwbp4Lpt +9Iyyquef5VuQHRruK5kjhjFrbBRK8uInYE8HGc5+npWpKTZhz29jBcSzws0elFv+WRBlUkcZQnJ +tZrMjSMFL3lpHLtj+XY75PSm1YR0FkEtJ4JLVQ2Xw1u6lgn19qp6xBc2t5ZXu24jmdcTzxv+6lA yCgz0HNID//R/NfTDezJLOrRLC0rQogG5sjrnNWUjuJ7d4925EY7GPY56A/Wv9sbaXP8f7EQ+x3U yWmpkG1SA/aIcf6x8jaPp6j3q/bWmnWBTNvKzRDekYi3LGOwUcnGKRnMhurrStZW5NtGP9HlEXme UYHkZOVbH4D/AL5rLnGo3zSS3bOSJMebLz5oAHzcVcFqS5aWIo72/wDtKRLcu9tax+TBb9EjOSTj 8TWsLzVY0VHMDxT7lmcld6DoBgcj6n9a1JP/0vzj0+3sN5ktpibiBcOpfPlk9h3x061dHmh28llw 65kPfIr/AG7gtbn+OM2V0u7qItKLSGSVWEfmufL2ruG4+/GTjvT7m+s7t3Ebt9qxvjgbOCM4+lam Ln7pUkCajeLYyzzWTW6lppYlJcYU5QHGPm6e34V7D4X0vT0sdK8q/GoKlskxlnBgkUNlguDgnAI/ KtacfeSOLETaiz9Bf2Jo4T8edB1B7dpItNk8mKRmCxRs/lyFVP8AFkKB7ZPrX9sHwym8/wAFaVIQ yhoypRxhowNuB+Vf5/8A0toWz7DSfY/0Y+i373hzU/xy/OR//9P9Wf8AgtOJ7S7SWKD7PFe63p8k lwih3jjExBC+hZtoI96/AfU7ycNGjASopzBEfvRAf7Pav9Yvo3z5/DPCS83+SP8AInx8i6XiNmEL W1/4N/xMz7ZNfefbzQQoPL2JsY5BB5rPs7eeyusPGBE52BnG5D9R6V/QkfhR+ETVpFS9ml+1vMmI xLw8SH5VA6YH4VNHIE+aRRsJ6dCa1p7mFR9BYF0ySVpJWkeaCTCxqNu4Hrk/lWnNcBxBPiNYxLsa HONoHp+VanLJ3eh//9T5Cv3tPtkZtssgVS6D5jGcDOD+tQahB9naKS2mkkinG9HfiRen3hn3/Sv9 947WP+fufQiEVwLVG+0IJGmEs0rx+bIyg52qMjGe5q6syt5sgOwuMKuenqMUzCexJAttE0xZjGXU bo0XCufWnf2TCUW4luGnt52xGEAHlsOR+tBl5GcBdwOq+Rn7SGiRtu4Rbec57HH86WSGbAAGWHG4 nkUDbvuf/9X5BttPlaaNjt3NHjJ9Af8A61WbsxwymCKJTK4PONqr7gV/vwf893MkNis7tiN67wOg MgH9aJ2e2T/TISnluIoWX5sFjgDI9SelbqKTujNzurElvOsaTBwz7hhl7VFfG2mMH2eBIBFEEwgx 0pkBawGSUZDOPuBc8EnjP4U+6g2M8RHMfDcZwfSgylK+h//W+NZJPsix3B+Xy5Rtym8D0O3ByPwr UvL+/vpjc3G2F7i3RhCsSweWNo/hAGOnSv8AoAP+d8zVadrZypcpG5RmOSV/zxVqzmeQxRtG0oSQ EBTtZiDQJuyuVpLjffjzoyRIxaTafkB7f59qfegQui+cXiONyjgp7f59a0g3exDn2IMq5yGAxwPe qszYBKR5IYKu7jvwfpWhDbZ//9f4+8sTJFMQsTwYUMnRsdfzq5c3trd3AeZVWGJPmRVwGwOB+YFf 9BB/zrlOS8tVaBYYEuIMCVmtWIQK4U7BkY+XkHryT1qg00P2mfyCY4d5KxSNukUehPGfyoGm47Fi RR5JkQ7c9R0zVyyZPLcqjS4X5zj7v4VopLRF8/c6izuNEmsZpHidL6CPaPLwqNjG3K49epBrHubO 8u7Z5Y4BGm7YzEY6YJH5VU/hIuz/0PkpNGt7qC2iP7pIHEzmV/lDjrg+/QD6UOFt7h5FCuEGI+M9 sH+tf9B8VZI/51yg94RG6eSUUyYdW+UP7+9WLqdns4CyGYIcJn/lkO4+nemTLSJUazeSNZhty2S6 KMbP6UyMsiMSmSCFOaDEtQy26q8n351HyxD77Zz07f8A66P9IRUM/nWckgDgMu1wrDIx6gg9fQ0L zA//0fjycyW0jMSSp4DSLhiP880iISpk3cZyDiv+hFvSx/znlYylZ90iDyyuPlGGJ9f0q15aMrtE RuUfdPWrU7KzArPZFU3FvmIzgDFaltazC0RArKWjLhAclgucn8MH8qpu8bkSlbYzU89HkVsmMng8 7h9a0txiMe+KQMqjJZdrAHpj9KxEp3dmf//S+TGiSVUkLANn7n8YxVeTzYwTs3qwwN3b6V/0IH/O eMEp2L5ce5VHzEDpXRaJevbzq/zRjoQDgd+aia903oSftYpn7Pf8EjL1bv8Aak8PNK+8ppaJHtlB MZeZyAV7Z2Z/4FX9e1f5N/StjyeI8m+36n+2/wBHR38HMqf91fkfjL/wWkgij+Ang3V5rlbZLPxZ LBI7DOEeNSce/wAtfkx/wSivref9qrwoRM9zIbdFSNlEaW6pKmwL9eCc/wB6v0zw6g5fR6xzS25j 8ilUUfpKqLerR//T/v4rzHxPrFnpPjDwkt9dQWiajcPZQNPIIllkwcKCe5z0r2cPSnVrezgrt3OH FTjTlzzdkmenEcEfhX4y/wDBTP8AZQ+LXx/8YeC9W8AeHbjXtL0zwydK1GOCMTZY3LyYIHzDaDnp /wAtOM4Ir7/wr4gw3C/GNDNsb/Dimm9rddX8j808WuGsXxZwpPK8D8fMpW3vZNWVuvvX9EzZ/wCC aH7K3xL/AGeL7xRN428NTaFb6tATAkitEkeSflQNycnaTnn8On7A0eKGeYXiXi2vmuCd4SS8+rPq uE8DPK+G8Hl1bSdOHK79z49+IHwv+F/xe+PWm2XjvTtK12bwv4UCWWnXbx+d5hkM3yqfnwAzk7cd /Sui8efsc/s+ePdBu9FvPAGk6PJNaG2tdX0SL7HqennHyvHIc8g469RnnvWVDijPslpYTD0ptUox UuXo02/XRr7jwq3DWSZ1h8c1Fe1nKUXLrGSVvLVP72f/1P3Of9if9q/4HfFeLVPhjPrXijQNG1tp tG1C1jkBmgWTMXnKDtzs252nrnhelfvB8Ktc8b674Q065+IPh1/DviWOMQ30BIVbll480J/DuwCV 6At26V+3+ImdZLn2DwuNwFlWStJLfbW66fcfkPhplGb5Fl9fLs2vdSfL2a8n/wAHoQfF/wCEHgr4 3eCtR8C+OtNj1DSr6NjDIUVp7GUoyCWPIIyAxyDwR1r+GD9rP4T+HPgF8cfGfgnRdWuLzStP1S5s 7crGEtAqSmKFVAyFJGcgEgY/Cv6J+iJn2NqYrHcPyv7FR5l2T1f6P7z+Vvpb8O5fg8yy/iSlZVqn uy7tRcVd/KSXyP6P/wDgiv450W/+Bt14NbxBpNz4g05YbiTS47iOLUAD5pbEOdxVQOoHQZ6c1+2N fzd42YDEZf4lZlDEwcbzur9U+q8v8j+yfDrNMJnHA2XYvA1FOPskrro1uvU8Ds/2e/hre+KfE3jH xT4P0DXtd13WJb1bnULFbjyo2bKgqeCeepzwBXzt+13+xF8Bfip8H/HAfwxo/g3XNN8OXd/pPiHS LZLMWkyRM6iRMhSrsqqQCDyOc4rfgbj7iLAcT5dTwlZ8sZwikuiulp+Z8J4r8B8PZh4f5p9ZpJS9 lUnzf3lG6++1j//V+cPGmhL4a8V65oUN3Le22mzJHbXkoKPchlyvB6duvTv0rlI7a58r7TdBIlZi vlq+9+P/AK2Pzr/oFy+u8VgaOJatzxjK3a6Tt8j/AJ36kFRnUo3+Ftfc7F2GSCM5Zj5QGM4y1TW8 CXk7+SDjYWUucZxjjP8AnpXWZQ0mj1X4Y+Cte8aeJ7Dwto9pDqup6pOttHpe9lklRmCucqCQQMsM 8Hb1r+1P/gnb8FPFvwM/Z60bwn4ttJdPvZJTeQWE4xNBExZ492cEHa46gda/h36Y+eYSnkGGyJy/ eyfNb5r9F+KP9JPoP5PiI/2nns4tU5JQTto+VSvr11dvk+x94LwR9a/j8/4Ku/A/x38N/j74r+KG paTqEPgfxvr13PHqDWzNp0qSyh0PmgFc/MOCQcD61/Ov0WM0w+XeIKw9d2daPIvWzsvm2fqn0s8s r4zgSOMoq8aLvLyTcP8A5E//1vng6mLiUxW8arapNtilRt4cZ7Gv6A/+CG/xM8L+FfGnxG8D65ru n6Vf+J7fzNHstQvkt3vXEkUiGNWPJcJKPwr/AGI+kDgK+N8Mcwo4eLlLlvZK70i+34H+S/0Vcyw2 D8TcNPETUYuDir6auUbH9OhGMg1+Xn7Tn7Jfjf4i/tK+DPjF4cslvNL0iOzF95dx+9AtnBYBMZBO 3oM5yOeuP8vOCc5p5DmdTEV9pQlD7/8Ahj/TfinKJZzLC04P+HUU/u0/U/TiynM9pamTKzm1jM8b Aq6PtBYEH0Oa+Vv23vhR4g+NH7OfjLwP4YtHv9ZuHi1C2so8+ddeQJCUQDksd2ABXHwljYZXxZg8 fV+GFWLfpez+4nxAyyedcGZjltH4p03b1Wv42sfwx+LPD3iD4YXl54e8RaVPo17oF3NZTRakjJPI 0U3lMuwgFWRztZW5GB619Rfse/s0fEz9pX4j6DbeEbK0u7fw9qQ1PWsyFGs/JKEMxPyhcOMc9e4r /X7ifP8ABYPw8r5/KSdH2Llf/FG33pvU/wAgvCrKMTivFTA5TBP2ka8U7L+SSb+Tsf/X/vM8HaPc +HvCXhrQbtke60fRLfT7ho23JviiVCAe4GOtc38X/BsnxB+GHjrwZCXFx4g8OT2Nt5bBWaXbvjUE 8csqjn1r7ahj4R4q/tRfD7b2ny5uY+c4oy+WP4ZxOWQes6XIvVx5T+E/9pL4ReMPgj4/8QeD/Ful 3GjX1vrUmyK5WSMyQShWgkCOo+8fMBKswJA5BBr5wlt7KO7t7ZYHVH2lvKb5nYnnr6n+df7RcD5n RzrhnCZnh3eNSnF/NKz/ABTP8ReLMFUyjiXGZbVVpU6so/c3b8D92f8Agk5+x38S9e+JnhD9oZNP GkeBNHmSRLi51BG+2BMkKiAZPPOBnnbnuR/VeTkn61/mh9J7iHDZ54gzw9DeguR+tl/kf63fR7yC tw74YYKhX+Kp7/8A4E5O3yvY/Pb/AIKTfAnxX8cv2fNQ0vwXZTalrugXEmrRWFunmTzqEDZROrEG McDnnoQDX8xv7C3xE0f4H/tj/Di9+JEGo+GI7DVLfS9VuNVsZbfZIXwHdCNyrufkkfLjB6HH6v4D 4qGd+Eub8N4d/v4Juze6ab/DS5+FeIduEvHvLeJ8bph6zSv2f8NX9Wf/0P749O1TTda0601jR761 1PS9QhW5sr6ymW4trlG6Mjjg9/oQQa+If27f2Vdc/aq+HeneGPDmo6dY6pptw8sY1SdoLaQM8b8k KehjH8vp+j8L5pPhbiyjmdaLUqE3ddbptNNeT3R8XxzkdLjDhetk8WnGulZ9Lb369vxPgr9lr/gk x4g+GHxG0bxN8W7vwv4q8P6XN9pbS0uGuISwBG3ZgEg8Yzke3U1+2tn4J8FWNmmlWHg3wvbaakYh Sxg0G1jttgG0AoEx0HcV+geJXifjuLs1p18DVcKcF9luN35rTb9T4/w98NMs4WyiWFxlFTm39pKV lr6nx/pEnwV+BX7Tl9omi3mgeGF+IXhdGvdOs7uOO1sb17lgEeMHEIkMYYBsAZzwK+5SCjD25BHe vzzimjmspYXH5pFqVWGjfWz3+5pvzZ+h5Bi8sr4ethssmnClJxaWydrfmn9x+bnxf/Yx8VeMf2mt H+PGgX2lva2Nzb3M9vLdmC8h8ojcVUjBOBwM4z35OP0cjuFnOekgUF06FTgZ/DNb8TZ9DOcvwOGj vh48n+X5MjhnJVk1Cuo71Zub+Z//0f7Hv29PgN4m/aL/AGcfFPgDwfNjxBHMutWNoMB9RNvHKfIQ kgb3JAXnk8d6/hq8Z+HdY8C6/deEvEdhqula7pM0lvc2urWb2V4hicoyMjgMGRgVIYZGK/0u+hln 2GnlGM4fbtVjLnWu6v2/7e+5M/zP+m1kNejnWEz5a05rl220t/7b+KOGL3Vw7xuo3Ak7VGOKpRyq rPEyFXj4ZWHK1/eR/A10nYhhYxpKEGd3Y80tteFv3MgdGByQ44/CglTRs21zPb31hfWk3lfYL2G7 kRV5lEbgsB9Rmv7wv2Ev2gfh18c/gJ4Gh8H63BPrfhTw9b6Pr2iSL9mvrKSJAA3lk5KFdh3DuecV /En0y8kx2N4YweZ4eN4UZPm7pd/ldP0TP9FfoM8S5fh55pw7XlatUanHs7qKt6+4/wAO5//S/vS1 3SYdd0fUNHucG31G3NtOCu4FSQSCO4OORUGg+GPD3huwi03RNB0fTbdUCPHZadFb+eQMFn2qNxPq a+qwuPxWGoOhRm4xbu0na9jgxGDwtep7WtBOSVrtHyH8ZvEfwP8Agt8avhv451W60Lw3r+pST6Xr 6acIoJpo5E2W81xCuOcySDceSOucA19oWV9ZapZWmqaZdwX+nX8C3VneWziSCdHGVZSK9/iLA5w8 uwWb5im4Ti4xk79HdK77p3WutmeVkeYZXUrYrK8DJc1KWqXTo/uaafRH59ft1fsPXn7XyeF2sPFG neHp9AtPsha/jkYHErSAjaD/AH2/PpzkY/7C37A95+x/rfifVrnxdpOvLrWmiwig0yCWMLhg2W3q Ohzj0AH1H3uE8TXhPDqXA6Wkr6/4l38r2PgcJ4fqPibPjeb1a5Uu1pdvO34n6SOyRxyyyyRwwwxm WaeVhHFCqglmZjwAACcn0r+Sf/gtn8SdC8a/H7wrpvg/xLo+tR6BpERvFsr5JSzworSwxuMqThps gHHXuK+q+inlVbHeJ9HExX7ulGTb890vm0flH0xs9w2WeGiwM3+9rVFGK8rNSfyUv+HP/9P5putT ikV1SEgry3y8/U1heZsbLgICcEkYOTX/AEKU721P+dLES9+6JQU34PLZ4NWEa6sNW8Na4DK1tp3i K1ublbX/AFxVJF3cDqMHP+NYY+j9YwVWgtOaMl96aPXyDGRy/N8NjpK6p1ITt/hkn+h/ev8AsU/t A/DX4/fAjwPfeAdft9RvfDPhu00HXtIciPUtMmtYUtz5kWSdp8sEMPUZxXvfxQ8DRfEr4feKvAk1 42np4l0ttP8Atg6QbiOSMZx9K/xO4xweL4b4/wAVHFxtOFZzSfVc10/T/ht0f7w5NicLxNwNhp4a X7utQjG/ZuCT08rniv7J/wCzPbfsw+C9X8Kw67Frsmrail61xBC0SIFTbg55J5P8++B9Mapq+k+H 9Pn1nXdSstJ0qzG+5vtQuFtraIe7NxXh5/mFXiXP3jKcffquKS89IpfO3c9zBUaGRZLGlVdqdKLb fZK7b+Wp/9T9MPEX7Tfw78J/8FPpfipd6xbal4Fbxis8mtabHvhtP38oBcnH3iAuf9odO39Tvhrx P4f8a6BpfivwrqlprWga1areafqFlIJYZkcZ/AjoQeQeK/pzxq4WzPJ8ryTGYqFqbpct/wC9ZNLv qk/u9D8P8HeLcq4ieZ0MBPmlCq7+m34fqj5T/bG/ZJsP2tPCmkeGr7XbbQzpFwJ4prm3M6MQxboA f9n/AL5968P/AGQ/+Ccun/st+PP+E5j8ZafrU5glie2stMNuZC6lF5OMYB6//rr57JfEnFZXwNX4 Kiv3dW62/mXffr+B7NTw/wAJiOOlxnJ/vVp5qzt6bJfifpwf43YqqqC7ux2ogHJJPYV/NH/wW3+M Xg7xTq3gnwP4V17RfEGqaFpqTXttZXUdybd5JbrfukBO0ohQ4Hc9q9P6O2WYvHeJuCq4eDlGk+aT 7JNb/c/ufY+a+kjm+By7wxx1HF1FGdVOME92+WWy+aXzXc/Lb9kD9mPxF+1d8QrL4feFL2wtZ7KJ L/xHe3kpK6bGpDHoPmzg++B0Nf2k/An4VRfBP4UeEfhnFqA1RvDlj5E18oKpM5OW25wcDoCQDx0H Sv2r6XHElGtjMNwtBe9TtUfz0X5/gz8z+h/w/LC8K4jiGbf7+Til0tH5b6X32Z//1f729UsV1TSt V0p5PKXVNMn04y4z5XnRNHux7bq/jI/4KH/sv+Nf2afiZ4h1fxXc2Nz4W8aaguqaPq9o25JfPmES q+QGAUgqeh4yRya/sD6KudUcu41nl1XfER5V6rVfe2kfyL9LrKamM4FhmUHpQnd+fNdfgk2dx/wR svZNU/a80+O1JksbG2eJ9rhUjZLaWTOPXrx6Gv7DnHzt/vGub6Vr/wCNiqHanH9f8j7T6MDv4TYK XnL9D8IP+C1jM9n8FLMuFifWIZ5MsBkx3LMowfXn8q/aH4QgD4TfC8AKu34e6MhVcEArp9uG/XNf nuewcfCvK9P+Xkv/AG4/Rcgkp8Y5nZ7KP6Hlv7Ylwlr+zN8YJHRXDeFJIgrtsVmZ1VefqRX8BaXr zwE3Mm6Z55SV24OBK4H6Cv6t+hVT/wCE7M59Lr9P8j+EfpxVV/bWX0v7n+f+Z//W+YYrj7OwaItF HtKsgG5jn3qEyRXDGF0KoB5pkHHI7V/0IH/OeVpViRswhQGUrNlQWODkY9Onar9rFDBbmQsrvNIS kTnJIA7e1TbRjUtFc+9v+CZv7S/hz9mv9qXS/FfxBa5tvCfiG0n0IyWqrOLKSSNI0ZskcMBIOehI +o/t98NeJdC8Y6DpfijwzqVvq+hazareafqFq2+KZG/UEHIKnkEEGv8ANT6YfDVbA8U4XP4R/dVo Wb7SX+dpfcf63fQ342jxB4f1OHaz/e4OXKvONrL7ly+rZIuj2y61JrpG69ezWxVjyI0UseB77jWZ 438X+D/BHhrUNe8eatp2keGoo/IvrjU18y2lEny+WYwCX3cjaAeM54ya/kjCyxdfF0qOGb5vdUUu +lrdtT+q8VHDUsNVqYhLl95u/a7vf5H/1/6ff2UP2QvCWofGW9/ai0C8aw8NXmuT6n4Z0mOwNp5v zMFKA9I8EcdRjH0/XQ9T9a/XPEXPcTnWa06NfV0IKHnfr1e23e9z5Pg/K6OU5T7OiklNuX37fgfi Z/wWev4rfwL8KLd59j/8JVFOkOM7/nKj8MgZ9ga/V/4Gs0nwZ+F0jbd0ngfTpH2DCBmto2IHtkmu 3NKVvDHLpv8A5/T/APbziyaov9b8zpLdRg//ACWJX+Ouvx+FPhT4u8TzLug8PWceq3C7im5I5kBG R9ag+BXxm8FfHX4e6Z408EalFfWqqNO1S3Vt02nXcSgSxP688hhwR6EED4WnleJrZRUzSmr06clG T7X/AODZfM+mePowzFZfJ/vJRckvJO3+f3FP4/8AwK8NftC+ALnwB4ovbzT7CeYXC3NnGssiMBx8 rcdcfhn6j45+B3/BLz4N/BTx9pPxAttf1bxFqWjz/aLW1v7GOGFWGcKGDE4zg/h68j7HhnxBzDhb IcTk2C2rXbfa6t28u6PlM84NwGfZzh81xavKlsu/X+tGf//Q/vxeUIrySOkUUaGSSRyFSNVGSST0 AHev5bv+C2fxu+DHj3UfDnhj4d65Y6v4+8LXMcPiC70myDhG847o2mxljEhfdnK8gV/UX0a8BmWY eJeFxGFbdOm+afpdPX7m/kfy39KbH5bgfDDE0MSoqpN2hfvZrT5tfefz9xS25uMTJKsMj5ds7pWP dvzqvHEz3jfZ2wrnDrnaWr/WFL3Wf5GqerZO32ZpjAQFl3cruyAKtfaW09L5bYmSVYTIEV8YKg4I /Ws6ifKgoVP35/Uh/wAEo/2IrU+GvAP7TniXW3N9qGnW97o+j21uFV1VCf3j9B8zAnAz97ucj+gO v8iPpD8QzzvxExdJ/DRlyx9LH+2PgTlMMm8MMsw8UuaVNSlbu9/x/M//0f7L/wBuD9mZ/wBp74La x4M0/Ul0zXrMHUdIlmz9muGT5mhbg7S23CtjrwSAcj+IXx5omrfDTxr4m8J+Jre0S98LaqdPuUtL w3yzjy0cENjOTvx+Ff6H/Q/zdV8ux2Svenaa9Ho/xZ/nT9MXLo4bNcHmaf8AETT9Vp+UTqPgp44t vhz8UvCfxDs7OC6fQPEUWsR2UVyI7u5iU7njbPcgYwOTjiv7k/2Z/wBpDwB+018ONL8deB7+N3Nt FHrmjsx+16PcFAWjYEAlc5w2O3IBrzfpc8L4urRwfE1Jfuoe5LbS/Xfvyrrv2R9h9D7i3BSy3F8J zl++T9ot9u35vyOp+N/wY8NfHjwFqPw+8V3F7baTqJDSy2BUTKQCOh4PUjHoTXyH8F/+CZ3wR+B/ jjSfHXhjUtcudS0a5FzaR30cbkEZ+XzMkhSTnAH+NfyjkfG+ZcPZJXyXBu1OtrLda7a99EtPXuf1 fmPC2CzXO6GeV0vaUdFpfTf5at/0j9GHkSKN5ZXWOOJDJJI7BEjVRkkk8AADqa/LH49f8FC/gd8O Pjd4M0G21xfEY0yb+zvEkmmTCO20t2nKyAsfvOikHbgA9M81w8J8JZjxbmNTB5dH4IylJ2bstbfN +q0T7HdxHxHgOG8LDEY2SXPJRir79/l9+rXc/9L++HQNd0rxRomleItDu0vtI1qxj1HTruP7s8Uq hlOOxwcEHkEEV8p/tD/sUfCj9pLXLDX/ABvLq9ve2MAtiLB4/KnUcDIYZB46g8988Y+0ybM8fwpn LxdH3a9JuLXVNOzV1180fN5tl+B4hyxYWv71Gok15q107fodZ+zp+yz8PP2aNP1fT/A0mozrrEim aS/KDykQkqiqoA4JPzHk55J4x7Z408b+FPh34ev/ABV401uz8P6Bpsfm3mpXrEQwj6AEn8BwBk8V Gb5hjuJ84+szTlWqyUUut27JXfdvr3N8PDCZJlnJflo0ott9kldv7j+Lz/go/wDtH+F/jx8f9U8U /D+6u9V0aIy2Omm4tWto71IZ/K+RskfNGQ4J6dCK+pf+CWP7GPhD9pa8f4q+JfEd7Dp/g/UI3t9C t442cTRhS6McggEtHz1Cseec1/ori6WM8PfAf2cov2tOjbt8Sevlp9x/nZw7meC4/wDpALFpr2Xt ZNLde69Fd76u/Z7H9YFlaQ2Fpa2Nsuy3s7dLWBe6pGoRQfwFcd8S/Amn/EvwN4k8D6nPJa2viDTJ LA3MSiRrZnUhX2/xAEglcjI7jrX+beGxtSnmscxbvJTU/mnc/wBGsxoLEZfVwvSUXH71Y//T3v20 f2c7v9l741a74E1u9jma4aa60rUIHb7PeRrICnyHoWWRDn1zkA8V8a3CxeYxxmRxuaTdkdAB/Kv9 wvDvM3nXBeXZo1bnpR/8l938bXP8FvE7BLLOOczwEXdRqy/H3vwvYda3bKJwHQ7IyqjuxqqsMhy8 nzc7skcjPrX3kE0tT4Fu+46ObZHPEYwWblnfh1GMgD69fxqGG3li2TspjMo3LnuB6VRHN73KMlBe 7R+sW05cDHPb8KQRTMz/ALwBF654z7UFeR//1PkHz0gmV3jUqcIeOoPFWZ9N82Tzd6vBEgaN1Hz5 PbFf9AKbWx/zrNpbmZM5idSYmZW4Ljjn3q1ZmNXR7kHyc5wv3mx2qnzW1DmVrlm6Nuyt9njILnCm T+H9ao3VtLEFWVgTjnA+57VANpIquEUxGIMXB+Zs5/SoZpZdyhFY5f5iP4RQZqemp//V+O4PLliY NJ82duw5BPvmnvEqRHd91O/pX/QAf86sXdFGFnMbOmSC3APpTVi8zcys3oxXtzUTT+Q+ZXsWo45i 6w2ytNIwxgc9qiImikXzg24chGBH+elTFSVxmgyyXUluzqjxwsCqSfMqe4Ht1/Cq98+zcFG5mzkj rUDvpY//1vkLT7KGezLOyrOr/KHbJKjHSq99bTI8ZjSPyI2CmYkI3I5J+lf78H/OuRNcKEYvINsf BYHqPWrFtGsTCVsbPvBSeGzzzQXDcleCRhst0G+VsKu35m56L71FHG6BpZWY/Nt2Nngig1JXlazl S8ikKFIztUKJUJyCNyHg8jv2PSrttqN80Je/u1lYymSKFYhGsQPUADgD2rGTbdhXS0P/1/mBdWtI yZoYirqhcO4GC3cD6+9Ypadop7qB3t2Xi4beHeQOeMCv98W29z/nhg7PUnlvm8hV4RwoMjlADIcY yfyrJi2t5sjOSxbkFvbtSNeZJ2J4GiSO4k8nzJBhY8jl89cHt2qae2jjtVDRllkPmkE8owOR+vP4 UBdENxJ9o2TTSM8gQJucksVUbVGfYAD8BU0SPe2skQjVvLUKoXCkDOfxpNJ7lxdmf//Q+S7GwlSa 1g86WGJT++28qqHqAOhplvLEivFcKysLhpI5HIDbTxs6e3f1r/eg/wCe8je8nEqRRJEtuUO4DD57 Y9j1NdHDZacbMZkUXU0eZI5CvA65X/H2oKUnHQxIri6s7h0jlZLUsBIq8iUKc9f8KmiljkuLm5tB LI8seJYpCEiQr0K0DcrqxDJeXM1rNBgQXcc3mRuGyYxwQOuD2JB9cVes7kXUQguxML+IrI91FIqo Y15K7Np68856fnQQf//R+aUcRWk9xBfCCVWCxQPGzPMO5zjaKzI9QlkuBJdxocDAKjaJAO5r/eg/ 57yjqMo+0RHTVW1jRQBGw8yMEddo7A+laVhNBKPLuFLytIW+U8cjH3fY80Du9hZbmGzu7cGNVMbH 97FkyY7DAHfmobrUtRb5/s5NjchkO3/WggjA7/59jUT2sXTbUjIkKi3FsAQUl37iuX5xkfpWvaXF uts9nFavJcH5lnRsNwOc8dsVzTR6EH0P/9L5ZtXeCN7WCZQLlgZChDbSO2e34VYubZotXUzObohF kkdT5uflHVvb39K/3Wl8J/gfQa5kek+BPIufGPhOyZ2mlbX7V4k2lY3zcINjkjGADn8K/tz/AGOd MksvhLoV5cb/AD7+0WYqz52hQqDj6q1fw/8ATAmllWDg+/6n+in0M4NU8wmtr/oj4S/4K7eI49O+ GE0TOLfNpK8cipmSXCxwkEd/9a1fyapPDZNKk+majc3ZtTNPcSXwtEvnZd8hOVyDjPGfSvsPos0P ZcEyq2+KX5H579J/E+345VC/wW/E/JD9qe+tdQ8VSQWUBEb4liuJ5d81mUC71VCPmwTt3+wr4uvI YbuXEcoRIuHkGQXPfiv5j+kzU5/EOq10gvzZ/XfglH2fA+Fi+y/JH//T/kctUSONoVlJ2sQXbgEe wphDTOEjkIRD85U8N7VytqzQ46MrygwlYYDIzEljuOehH+NSbZ3ljKSrG2AZGYbdg9RXPJ2RubrX lp5KxRojy/c3scMRn5mrKTWBlrGVy3lfLC8h2+YvJArE6FrsVpG+0xC4hZVhWQxtErgsCOCcdayx PcvKkMSkRCT5y4K5A44qZq6sG+x//9T+RZrO6RRNCVTHzOr/APLbHYDpTrbyIbeb7XZb52/epvl+ WE9fujg5rwp7nopX0Q+G9CQ4jVCrjHIyV+np0/WsWeznL2yrcFVmut1xNL8xjXk9hUFuHYlmtZEZ 5FnP2iMkQSxMdjAdGPftUEKXJgYmVBMGO5nfJIPU/jQTKPKy3ZBFDBTubGSVGQ3rWgs4eIwHO0fo aGtLDjC61P/V/j6mIhm3KzRlGzuTgt+NLcG8uPKlvJwgil82zWH92yjkfOc8185GFnc9Nwsi8bmT ajs+Jjwxbq/vVCe182ITLLEr78NEx2lvcdqq2ljNxT3I7YEPJDHgEde4/wA8VedEzDBIdssjbBtO SGwTg1m4WQ0raCCF0aSKTPmKf3Z65HqaqtJBZM4m/etJgkAdP8P/AK1QB//W/j+eaNVjkiCPE5wA x+YfSrNrcxgTFo8Slh5QxkY7nNfLnoC3Esb/ALqUA7x93O0sKYiedA0LkRxldkarwyDGMUGkJO9i pqDjTrFIfllllIhVTwu3HLMe3HbvVKK1IurLyGEkN1AXlniO2K1CdQzHj06f0oLur2LyXLpLIiYd du35uS4z2/KrkOowDdEiSISMTyD5vptFNJvYZ//X/kA09E1W2keKB/MsrolzcHy3G04DBT19eK0L h7VFUCbzJDw3GNpFfM8jPYMW5348stkFuVXv7UyfUZLORW0778sYt5oj91l6n8eK0jG24WJ472dI w8kmxn+VwBzg9s1VWEbnm+0SyGXAggKbVjI+82fQ/wBKoLGbqtxf4jiW0jltvMxK/m48vIPJX61M Jr5pBcXQ/crCsUeMBSFAAOKie1gXkf/Q/j6W8kmgVIivmEZXNWomMWmRStN5+opOySRJhAoGCDjr 3/SvlZXtoe5e8C1HrV0Qkc8ji2iO+SE8g+uPenXV3DeS+fDvgtZBmO3m+V1XsGB7/WsbGZkK95aT DyIftEv2jC4OIQue5+nardjPZXEzPeQmG6juG3gR7di+qnqM8it4qyswMvWJkuLt5IbcmKMgAKSz cZ5Aq7Z21wSrqUAKgBHXn61LhrcD/9H+Qm787AWNIon2gSuASOOtZ17d28Ighky5DgRSBeVc9MV8 5BK1z0XuyxFDHd7pZY/OnCbFEmcIR0P1robGOa6VIpIgCibS+flI/wAjpV2IvZn0N8I4LG012wtb RPtL30ptI7iRxJLCpHzIoPqV59DX60fCW2sNZ8YaJoWnfatReCWG6RwPKaZxIgYp6jc3Trgiv7I8 BKLo8J4+vJWT5nfvaKXy2/A/lzxJxCxHiJl2HWvK4q3a7vb8T+7z9kLT1i+GOmWEyyxzWOnQzyRS 5jZ2ESErz6b6/Hn/AILNyXOteFLq0iuEtZHhcJaBx5jSl22hOerqeMf3a/I/CyPtPFL2m/72T/Fn 9I+KM/Z8C1E9P3dvwsf/0vx0+IMVh/ZGmvLO9udWLWrGKPJtpEQcOB39PpX4o/F67l1bxDd38jiy htLma2sIZJBJJcBnJ+c/3uM/hX9vfSFmocOUafea/Jn8w+BMfaY7FVFt/wAE8M85HbBjCzLIS0vZ x2rpdMcrmZ0LInyoxPC+px+VfxHNWk0f08dPcXqtAAsjl9uS0bYwK17KP7VbiaR3BCARDGd+O59O ledWWh1KLa0NSF5Fj/54jbtZ8kFwK1NJubl50khl3tC4byy2S2OnFeTVTNoq1kf/0/5S9N1DU4jF c2d5c2zBCrx28xiaI45II5ORxV+O/wDs+pf2qkxXVHhZZZp/nJIBAY+pHr718PNWvc9aSujJ0u0e /S41C3klu/Kd5poB+68pgT8xz2z/APrra0bRUkspdWm1LypssgtGkBdyT6eg5rnMQeJYJGJuB5zR eZAq8qTkD5h6da17fV7i0hlt38lTexeTLIigCMdc8/Tr71ny2TQGZBqsMTOJoZgsT4+0W8TTI4B4 JIHHFdbL9nm09dRsdT2OLsKlhNktPGF5IA+7+NaQjZI1gtD/1P429egmn06W/vJ4NU1YyO6RRRFZ 06FduBg8ccGs7R2hvtGgnuS1rIXZGhJAcAHr65Oa8OStGxlGaUzpLK4trR0RrATmBA1vJLkNGe59 8gUt9q1vKBHaRjSleXzWtrFdlvckDkSZz16/UVCV3Y6nJOOpzjatKzoktrtlLlDzlFHQEH3qxDAs 0yrczJhyGweFXByMH8BTkknZCpjtTtG0ESS295M8lwRJKr7XhRcZXaw7YPNPF4bm3Fy0DDcgVAhy rNxyPUdfzq6expbof//V/jz0W2trZ5rqSaN5o9rJDNHvTJPOB0OPQ1Jf3MAjlRo/3rndG6jaieoA rjp9Ryik7GRol3Fp97JNbQLPLt+S3lytuG5yabq1xNNp+oSQWlhqYucL5M27bZMjZwmOjcHn0NdN NvmJlBcjPEtUa/humFwjRJLh0hQkpFn+Ed/zrqPAUT2ni/w3rjabfX9ta6pHGzWkJlVN7BSX9AB1 PYV72Vz9njKU7bSX5nm4+mpYKpHyf5H7nfB7VXvdH0SWOxt7OfTU+zSTtiRirEvuGe2Dj2wK/q1/ 4Im+INSea80fXHjn0e0Z59GuTlLnztm58j+7s2lc9h9K/uXxKSqeE3NLpTT+dj+evASUqfiTi6cO vNf0v/nY/9b+1r4p2drd/D3W7G7BYSaLcebnKu37h9ig+pbbX8FP7WFjHD8cPHFvdy2h1Cy1OeK6 ltwC8JRlSKN3HByilse4r+mvotVWuIsVRS3j+v8Awx+DfSbgo4LDyl/M/wBD5Gu9QhtGSKR3X7W2 2A9MkdWIPOAM9OlZxhsrXUIbY6ihiZcXDWmJ3iz3GSAfz9a/0Ao7WP4axTul6kc91b6dcT28tu94 fkkgvJICjBcnbkDjkEZx6darPNBqFxOtukVtCMS3Qkk2RJ0Py59+n41sCbSsjM1C4fSZraEWRu0v 5xFHcQJ58YVxje2OgHUntipoJIbRbmHULaG6uZYzHbwlfnjiJBaTrwRjjsaAUmj/1/y103UH08ny HKxIo+y5BAhGOw/H9KT+1I7O7eP93PKij7QkpDMN4yDj37V/tAf5SRnrqVo3RraeKW1VJGm82zmU EyYJwQO2P8KjWKSa78hk82MYSJpxs8s5By3OBgisprU2U9DW0vUbOw1S9ju9sk8CLavBLGZoX3AM u0j0GOc1kzyR2M5uYIykpu/tEcYlJQfMSQUPb8agiU03Zmnrd1oN2bXy5xBc30RlvD5JCI/8QQ44 qCZri1tFt1kD2TbCi5B83aML83XODVqK5bk88b2P/9D8v9Huby2hu1Z1Ed0yokDtllC8gkevXkVe vhZXU1laanZQyyWsiyRRFedzceYTnqATiv8AZg/ymclbcw9U8NT6bcfa4ZhNY21wFYXY2+bEzYZV A4z057Vq/bbW+nFna7LO12tK0gh2zDjCoGH+NVF2ZEnorFC58N6jBEt3D5w00SiD+0jGxt4XPPzs AecHOBk81mw3V0lsoLRSgOd0kYw2M45NbLXYqLujdtbbEbS36vDZs370jCSEDkhM8E+lTahdeHjY yyW13MyPcRx6dALZnlG4c+aQMKV5oBvTQ//R/LeK4WdngEt7ALeMCS8iJj3u3QBh2xjNdReNcWum PdW2sPcwwxq11bGPZLDzgOoOd3ocdPSv9oD/ACfKiXdvrUMUt24tY4ZBEkkmIm5GN4B5x15/xrTm 8MaXfWlrcWfiHT7fzpvJE05MzfKwBK7AcZHqKCJv7Jy2r6dPDay2UV87J55HmFtsrEE7W/U/nU9t pY0iGzjeLzWubXzXuo5vNXJPRlPIbrkUGd2W7rTVFhDcC5gi02MtLeSm2864iYnac9D6nGcfzqrp OhLcalJm/a806CPehjt/Ikl6Y6k45/lQNSaP/9L83JLW0nRob1LhYQ23LRkquOhI9KqabYi3mhtX Q+Xcy7YFVPvEjgY96/2gP8mud2Nm6aKfVDp1yn2WG2tizPswfMA+VSOvp+dQW9i6Nd+Zb26qoDQS yYmlkyM7sY4NNRb2IKWl6zBAtxHJbhWt52W3vSmLh3Q4IJ/uk9MdKrZOoNczOUeUuNuOpz/n9a2S srCbS0YzydiP9pVZmgw0SkbypHSpbJpYy96rp50sRt0jeFZVAPBCg9Dx1HPApnPKSW5//9P8y7q4 1C5u4ReaLHpdtBCF/tS0KiO72YGXjByHHOT3q1NI9+lpJbSedBCvmKxGDID3H5Dg1/tZTP8AISpq h11KZYnJnFwcKqpIPnhA4Kj9fzrNnu0NxFFHaO+VSNmt4j5QPAww7e+a0IUrKxfvNKQzP9oMkKzq rPCjFNqEZA696rRRxxTy2iSRWsKIDaNLuYSMf4cDP5mmyTZ0pmtPtLXkizXTNuikiUiEpzkYPIJ4 /Kt2+1y1nitE8ld0Y2FHVZIk46kH1z1pAf/U/M5rW7s5DNZMZURxIoUE4yRn8cV0jGW3to5ryCUI QJBbRkRSHPOc9s++a/2yv7tj/H8qPB9u8vUdOsnjBm2yxs4keDbjG8Z6cD61LPq7TatdoIfmSJBJ Lt2BiV5AXp7VNjKb1K8sWmxRSB4GjF4OGjJjZWU/eB6ex+tVDDqH2d2FyrRocJwA+OoOPb+taQ0d iCdbCCK5jljuhdWgRHlljjIIYgbhj2JI/CpZo7RHkuEnwiL8yckuTjjHb8a0E9j/1fzliewslsr+ FrVo3ucXsUnysik4JY9Se4ou4kstTaC2juZobt/P3hwVTcMoufpg9O9f7fpWVj/G2bsiOe4tUjSO 8WZsTqwWMlM7WHy7h0/GoLidUlM1sixwSSFQpXzGQE/Ku7qMY60zEsmOSN2laVmjmQxyNEwU49Vb sfevR/C9l59usksrxafAohSNyHmLKq4+f0wQfxreHxJHFXT17H33+x40tr8S9HlsozLHaagt8yFz 5c7yeXGo/wDHM1/bz8KpvtPgXRLwgieaxQzKTkbxGhP6mv4I+l1TtmeFm+x/op9FOfNwBXguk3+p /9b9nP8Agt1o9lYeF7G7uUCm313S5I5kVi92PtSmX8gP/Ha/nTu0t4r65mXa8jx+YqseDgYAJ6ZO K/1W+jHUc/DKgm9py/JH+TP0jaSp+JWN0te35HNToIUjwjNLNLvJjTEaZP3R7CoNQvJoZEidmJIB kRV3FRwK/o+Gx/PE9y5aWlrct5vlyyHOMOu1R/nNPv59Pt9Vnhm05jALJDEbdtsAlKDkZ9CDn61v T6nFP4TLsJrMpdQXltt2yb4botmSYbRwcYxg5/KoobEbZXWZSud+JW246DArWKu7GDdlc//X+PF+ wKWSVppJfKJWK3/dyAjgEk9s+magWa3eOVry6NsYrctCXjMnmMMbU46Z9TxxX+/B/wA+8pdWWrJW vdHnbypIZUnASaRNu8cdPbnINQC08yXyoZFe4hiaWaMHgIoyWzQYuTejIIJftK+YjbxuKAHowBxx +VXfNfYECuiRtuC44X1NBI6G/ntpZmaQSQyRYQugHkkj5tv1plxLOTFNGu6KQ/M5PXHB/KgTdkf/ 0Pj2NnPnXMU7xTRbdkW0lGGeeaiuZpHmE0xCyMmEO3AI56flX+/UY3P+eckinaMMSPN8xdrgnaQM g5B7Hgfhmti3vJHtniyqyxjdGzAMCQe4PWtgK0Sqf3bOBJMcdPvGqFzH5chBP3Dt4PWgmWkWaa21 4tvFcpt2Ebo2VsHI7VTK3c8rk+ZLNK4HlqC0kzE4wB1JoMT/0fky1uIWZoLhbZZ4WaSNrlWBBUH9 3twfmJ9cCo54LWSLz3M32rzQI40GIsc+/wBK/wCgBK+h/wA75G0c5tLhmLQCPaEjCY83LckmoYvN W0ZlaGMTAgybxvAXtjqM8Vr7NET2IbeOKC2E8rPN+9wwyBLjrx+vNRO6SyySqGe3cAKkmN6/iKpJ LYyJBa7VDqcjOcEc/SlNu9whkKkIvAAGCcf/AKqYH//S+L2lk4QKyLHwMng+9QkpKDFFu8w/O/GO AcYr/oIP+dXmV7E1usy+VDGiguwVIlHPpgClmjhikfzUIkBx6DNA07oneFvKiVnMYIBAXkge4/D9 akjujaP+6b5M7QwG1sUDFkhN5cGOLzRbLtkacAxKxUg4HPqBW5/a2pW+lz6aZ42tnclXaJTMuQB9 889qpJvRAf/T+OYYrh7eRYZXkhiAdyzcZzwT+NWIbkbgkzcEfeAzj61/0IJWVj/nXKMpEsxc/dB2 47VPlmURIflHXPagzm+glzHdWTNEk0cittkDodwwQDjP44pvmyJEZJEJXODgZz+VBmWUghlt2uFI SXcB5aqQ2Of4q3GtzqVvCJpIibe2xFIXCtEqjhc/0oB6K5//1PkKSSR3jSdvOZVERZhu4HH6U9Ld Yn2s48oNwo6NX/Qgf85XPZ3KKBWuZgWA2thU7gVC0Tw3KyIzb88gdGHpQTdvc1rW5mEt6199mlEi YhUpseIjGAMfSlEiyWolWTbIXMZj+7gAdR7Vpb3BDreJfJebO1VOCzdCf8imPuYCZ5dsJO1XJyq4 9azA/9X5Cli8u6XZcb12/MU+4QcVO3mTgiFh8qlctwMDOQP1Ff8AQgf85zaSIrVmS2MEaiNclpdw +cn2rTjR4UjljUzwyHbLt+Vk9eKmXwsuk7VUj7b/AGFvjvpn7Pvx/wDDPjvXbqGx0eC5gW5VlZp7 vbIPkBAIHy9c+lf2keAf2n/gV8RvD1n4k8PfEnwuLO6iDvDqGqxafc2rYy0brIRyOeRkcV/nP9LD w+zbH8Q4bPcspOcJxs7d7L9d1vquh/qj9F3xbyGl4e/6t5vXUK2Gm1r/AC3fLf5WV9tH1R+M3/Ba L9on4V+KfhT4c+GPhPxZp/iHxMniA6nLDpJF/BEoiZMFx8p++MlSQM81+If7EPx2H7Pvxt8GePvE MSS6VFaw2+t3MasJlZHVs4GeRzknsvfgV+neEvA+PXgfiMjx9Nxq1VNpeWny6Pv2PxvP/E7LcP8A SKjxDganNhqc1Bvo7ppfJt67W9D/1v7bvh1+1d8Afib4asPE3h74m+FEtryEPJa6hrMNjeWj4y0T q7DJB4yM5r8uv+Co37Wfw6i8I+FdB+GPjiLVfHeheIhqzTaETcWdtEEbcpuBgBwQpBUkDuQcZ/ov gDwn4gxHHdHLcfRahGTu907XS87db206n87eKPjDkOT8I1cdgaqlUk46X1im029mnppa/Xc9x/Yf /wCCjfw7+LfgPR/DnxS8RWfhn4haTEmnXV1qc+2z1fag2SeZgAMR35X1IIOf0Fm+O/wXt8Cb4o+B oyV3gHxHbbiOmcb687jXwmz/ACTijFYHB0G6PM3G3RN7WW1ne1tLW1ue5w/4vcLZrkGGzKeIXPKK uvO17/11Hx/HT4NyhSnxM8FsrAlX/t6DYce+7FfLX7Vn7c3wq+Dvwn8W6x4P8daHr3jqLS5B4f07 SZl1Ly58EI8pHyAZ4xnPpXncO+FvEeaZ9hcvrUGqc5xUnbpfVb312+Zy8ZeMfDmR8J43NcHWUq8K cuWN+rVk9mvdbvbysfytaf8Atv8A7QP/AAuBPjHqHje5n1NtXS7lW0kaUC3Eu/ygBn7vTC9MHBFf 1Ofs0/8ABRL4BfHDwRo2par470Hw14sa1WPVtM1KVrGN5lUB2TcoCknOUbGDnGRX9MeO/gpVpZNg cdkFO86SUZW0umtdNr3SevTZ9H/P/wBHjxxw2MwmJy7iGqlNy5o37X/Ky189z//X/uQP7RXwMBx/ wtPwYeM5GsRsAPcjgUx/2jvgPGPm+LHgjvwuuROeOTwDX6i/Dniy1oYeT+4/Kv8AiKHB9P8Ai4qM fmfmT/wUU/4KK+Gfh98L7rQfgT43ttU8X392LXVNT0kFo7O1aNxIsMpwwfJQbkBxk85r+T/xT4/8 SfE25v8AXPF7/ar7UZ/tjTyu090JdzNlnbqCTX9//Rh8O5cMcN1c2zCFsTWk1r0S/wA1b01P87Pp NeJFLi3jWlgMvnfDUIqzXVvV/jf5WO++Cvxn8b/AjxpoPxG8H69eadfaPdRfbLK2ldEv4EcEoQvT HUEd6/r6/Zh/4Kafs+fG/wAG6XceJfGWl+CvGMdqkep6brRexW5cIpaWNWXcuSeVIwDnB7D5f6UH hPic/VLiTJ6d60dJWW+mqfTWyd3fVerP0z6LvjRgsny2fCefVbQj8Db1s3pvulqrLZW8kfVT/tU/ s5okkh+MfgVlhyJfL1lZmQgZIIUE59utfgT/AMFVf29b3xQ1v4B+C/jGQ+DJNP2azcaeSJNVYSfv Gj2n7uGjA3jI644r8O8DvCPNMVx9g8RnFH9xTlzNPqo6v8L+d9j9Q+kP4wZRhvDzE5flFX99XjyJ rXdenp5H/9D5puXXWHeZXeKaQ7/37F5FIGBk9e361g3pls5zb3CL5iAAleUc4z/Wv+g6CtBI/wCd GMvdZKkO2GOSRV2SHIXcA31x1qeGLzGZLeYxNEC6gDO/HarS3HTnsfSP7LHx7j+AXxw8O/E3XtD0 nWdL0aaFLq2mtpHnljMioxVUBGV3eZkjH7sZPev7Ifht/wAFH/2R/iJ4b0TWj8W/Dnhy91a2SR9G 1mWS3u4JCASg+T5ueB0J9M1/DP0rPDbOOJcwwmc5X7yUXG3novPy6dfI/wBGvojeKmSZDw5ieHc0 fLKErp91PmafTq2t3a3mj1Jv2xv2Xkx5nxp8Gw/Ns/fXckJzjIHMY/LrX5ef8FRf2xf2a/H/AOz9 qXww8OeM9F8XeINa1G3u7FrNVnjs/s8qu7JvXJYqHGFA7c88/wA7+EvhjxZl/H2X4mVOUeSondX6 J+XTft1P1zx98R+HMy8L8ywmFmpVJqKV7f8APyHn1R//0fluS3ihultYnlt1RMgtH8y9ME445BB4 r0Pwz4w1rwpqdj4j8Nare6dr+hMk2n39vIYT8jAsj4GSGAKj0z3r/ezN8roZpgKmX4lXhUi0/n1+ W5/gfw1xBi+Hcxw2b4J2qUZxkvRXuvmtD+qT9jH/AIK0fCDxl4I0bwr8cPEVt4P8X6LpMUEur3cd x9n1DYij97uTIYDPKlh8vIGM195f8N6/shnZ5Xxw8JTvIAY4oJZnlfPQBfLr/K/jjwP4hyrijF0M HTboublF+Td7bba6WvpY/wBaOE/HLhjOsjwmOqVE6vIlLb4kvN76a7Wdz45+IX/BVz4KeEPivp8G k3kmqeB4Yl03XdTYFQZWZstCik8qNpwfTkV9S2f/AAUb/Y2u9Di12L40eH0Ett9pTS5/Mh1cZXOx oSOG7cnAx1rkx3gXxLQoYXE0o3c17ys9Hfpvp06bX62WuE8d+GsVUxmHqO3I/d1W1lvtr10vvbom /wCS3/goN8XPC3xs/aG8WeOPA6GPw3deIJNQVwi+TdySxRruPGGy67uM/eXnPA+gv+CZX7cngn9k rxlrGmePtOubjR/FUCHVdSt7B5p9KUMoaSOQDaFyEJVsDgjIxmv78z3g7G5r4JrhiTaruil+b/Jn +cHhlxXh+GPF+nn9ZL2SrSvd20b79NV/w5//0v7CdH/4KU/sT63YRahb/HTwzbCUA/Zb4yW15Hns yFSPyJp83/BSP9jG3J/4vPo0yq+wywWtxJCCO27Zj8envX77U8E+L6OJalS0vbr6dj8Ir+O/BNbC 3hVd7J9Laa9z+cj/AIKp/tZfDH9pP4maZqfwzu4brSfCelxaH9tnSPOszLdGQS4BJ8sLu4JBr8e5 RILmGR5VmfztwKSGJCM9MjoK/wBQPB/I8Tw/4fZdlWNTVWFP3r763a9NLaH+UHiVnVHPePMzzTC2 9nUrTlG21nJ2P6OP+CbH/BUD4UfBv4W6B8HvjItt4V0jS3+yaRrttEzyEghN0qjPmKcDLZBUjuCM frt/w8z/AGJHhWWD44+H7lmxi3ijlFx/3yyj0r+FPGTwU4kxHHOMzHAxTp1Zcyeu1rdL9vv06H+j Phj9IjhT/U/CYTHTcalOKi1put76q3+Vns0Y+s/8FRP2NtLtZ5rf4mwapcJFujs4bV4VuP8AZErD Z+tfyOftVfFrRPjB8dPGXjnQEa30TUNevbu0hgwifv7hpF2OOyj5Qe+OOMV+qfRm8Nc74azbGYnN Y2pTgo21s3quvkfg/wBJfxSyTifC4GeTS/fUZyknpe3NGS2fRp6apM//0/1O/wCCcv8AwVH8N/BH Sn+EPxcm1m78LRTRNpWtXCmb7Azx48uKToQAnKvjhBhvlr9ll/4KkfsTsI3PxXjjLjO06c5ER9GI yoP41/bXi34B5tDjTE4zKYuVGq+a1tumlujtt0d9ei/jTw2+klkeL4OwazOSVemuV69V3X5PqrFt /wDgp3+xeIy6/FaKVSu7EVizE98YzwfrXhPx2/4K2fs2aH8OfFMfwy8UTa/4yvfD9xBohb/iVRWE 0ieWk8sh3bdm7eMDJK8V8PkngJxFiM2w9HE0nyOceZWequrr5o+s4m+kNkWEyHEYjBVF7T2cuV3W krOz+T1sfyy+IvjZ8QfEXjoeLtV8c6rd6rLqI1F7mC7ae3im372ZJOGKqchSMdOBiv6Mv2T/APgs N8IJvA2m+EvjlfX2k+IfDsKaTFrSW6kakkKbUYqWAb5VGGVu2COM1/UfjT4JUc54XwlHJVapQ5Vo t2k1qt7O72ejs9lZ/wAy+A/0hZ5JmGMwvET5o1pOSbdrJva+2mnyPrif/grH+xFDEky/EyZ1kRnj EukTQqxXjbuwQDkYGTXxR4s/4LQ/DfRPjxZNodtLefDKbS4NN1T5TNOWDM8kxYDajY2gADOAM56V /OnDv0c8+zHEVaeJhJJRbsk97aa/kurstdn+/cRfSgyXKKNKWGcXeUVdvp10Vvm+iv5Nf//U/qhv P+CxH7FVpoUusw+M72W+jtzMuiy2ElpdO2MhBIw2c9Mgmv5Tv20vjfon7Snx11/4q+HrWLR9P1LU b+WC1iYlroTzLJHJjgYABAPU9SB3/wBQPo0+EeecFcSYnNMyTjBRcNU1d6qyT7Xu97W1tdH+V30n fGLJOP8AJsJluW2coycrpp2T5Xe67202vfS9mfM7rNbIiTPG0jIHDqQWIPr3GPQ1mXBLByACc5LA 8mv7gP4hbuxsMfnbSCFx+YpstvIrDgFf4iOtBDkkW7biaKVGHyc+oIr7R/ZE/al1v9l/4nab468O XN5FCJdmtWKzGSwvojtDLJEeACuVPs3GMV8Zx5wzheLeGcVkeKSaqRdk9r2aX+Wvc/RfDDjfE8Cc W4TiDDyaUHaX+FtX+7R99LH/1f6dfCP/AAWj/ZH1fRrK78VXmu+HNYa1EmoWMOmvfQQv/EEcYyO4 znjuag8a/wDBZ/8AZT0rRrqTwheanresy2jNYR3aDT4ELAhHb778HsFzX9jUfoxcU/2sqLpTdHn3 cWvd5ur0S03ei9D+Nsy+ljwnHI518NVh9ZcNEpJ+9y9Fu9emr9T+Yr44/GPxV8ZfiF4h8deI/F+u Xj3+pfbtKWO9kgt7eNlVkxGVXlSSOgGB+FfrN+wz/wAFcdP+CnhnT/hP8cdN13XvDunQE6T4m08G /vLSNQucxKpcrnGU/hJJBA6/1N4ieCOA4g8PMPkGXQUcTQjFx2b5ktbfit9YtpO7P5Y8MfpFZhw1 xtiM4zZuWGxEnda2Sb6/nfpLVq236Z2//BZH9jS7hE1rrfiCQYy0culPazL9FfBP4UJ/wWR/Y0e6 W1XWvERco0jE6S6hAq7mPJwcexr+RKn0buLoWbozurL4Hr0P68ofSm4KkudYin3s5r1/rTbU+Jf2 0P8Agsh8LPGfwm1zwF8Ap/EsOteIwdNu/EklnPYPBEwIeKCQLhWbK5YnhScDNfzi6vql5q88up6l NLe6lL/rbm4czS/99nn/APXX9l/R48JX4d5LWxWYwtiqz3ejSv26XsrddL9bv+FPpJ+MP/ETOJqN LAVL4OgvdS+G9u9ldq8rvVa26WX/1vlsphfOQFiGyUHG71FQzyqY/mjG8jI46Gv+haCstT/nLqyv IzLYT4Dz5jVjnkYIGeOK0bN7qLzHE0TxGQPCDw23jqM05L3WyqNSzsfbf7Hf7Xfir9kzx8vjDwbL 9rsZdi+JfDLtJ5WrQyyorxooBBI3M2Me4IIBH9FWhf8ABbv9k6/0+0fW7PxTpGuS2ySXmlJYyXQt 5CBvXeEHAOe3Sv4n8fPAXFcXcQR4hyOD55K0uVXvvur6at2dtb9baf6HeA/0k8q4c4Mp8NZ9USqU bKPM+XRJKLTd76JX6ppuyT124/8AgtJ+yU6zSLF4peOJN6eXYu8so6cLsGPTk1+ZX7ff/BS/QP2l /C3/AAgPw5tPEfhbwpFbF7qXUIJrHUtQleWP5yVG0oqqGAB65zk9PzHw++jlnGX8WYTH5xTl7CnJ N3jZdd/6R9z4l/SXybMeDsVluS1oSr1ItaT17q33W631P//X8KfWg73ERhnmV3CFrmUyeaAANzMc ktxnPXIr9Zv2Cv8Agp1rX7MFifh94y0zWPFngf7eXg0i3m+0zxJIkY862by8owIYFfmDAc54I/2j 8V/DbAcc8I1MntacV7lvLZKzvo0rLW+z0Z/i74M+L+Y+HnFn12pJuhVlapfbXdvTTqntbdbH64xf 8FsP2WJn8mPw78QDdJCJLiD+zlzbseNh53fjtFTy/wDBan9laBpEn0rxejwxiSWL7I6zLn2ZAPTk kV/EH/EtHE0ZqCpy5v8ACz+6YfSh4UjF1vbQ5N/iXX/hz5v/AGjv+CzPwu8bfDXxH4N+Dun+ItO1 7XLBrSTVb2ArdWSZBYR7VKqzcDJPQnGO382PivVzreoJrNzqE+pX0gaZ7uZmBXzDu8vB7Dnj3r+n /AXwglwBh8TjMwi/rE3Zcys0rL8P838/5K+kT400/ETG4TBZZNPDQs3yttXu9+l9Ve3ZH0n+yF+1 R4o/Ze+JNr498K6fHcXFxNHZ6pAl19ngvIMqHE6lGDjY0gA6524I6j+ifQ/+C3f7PV9p9hNrXgjx nZahORBew2sRaKCYKC6qGQM3PQLuOCK8Tx58FcXx1m9LOMrTdTl5ZWV9vn5L/gn2n0f/AB+y3gPh 2pkGe1IxjFtw5na99V082rdl0P/Q/pVi/wCC2v7M8kDzt4U8aQL5zQWxuImWK6ZPvKrrEwyO6nkZ r8bv+Ckn7dnh/wDbMl8MaXoPg240jw/4eQ28f9oRO2oMTOZXlkl4UD5YgqAdyT7f6MeEPgFnfCnG VDO8wi1Tpa6q2umm+t7H+bnjz9IDIeNOB5ZFlFWMqlSS5lF82iUl20Wp8S/s8/HbxN+zj8QtD8f+ EXFtd6XfpcX0VruguNQjUMhXK8MdrnhwQcD0r+iHwn/wXV+FV3oNrceJ/hT4t/tAwKHvtPkCafcu BtYiPyndTkdOR9K+68dfBCpx7mNHOcBd1UuVqK9N9PLTtr3PlPAT6RNPgXJ6nDOatRoxd4Obsu7t r1b+61tj8rP+CgX7dWn/ALY3inw1deFLW48L6V4Itbc2drqNnNHudLiSWcmRlUsxD8YUACMdzivt P9mL/gtRpHw28GeHfAHxg8K6n4mGlaZHbab4g0iVoZPKjQKkbKYjyBxjt2OK8vM/o7zzDw3wnD8E /rFL3v73+V3rp5q2u3pZN9KaGV+ImOzSrO+DrOy/kvf05klpZ7aNvTer+2D/AMFjvAHxm+EPij4a /DnwZ4q8PvrDRWupatrdiLlzFubPkeW2F+cRHdIO3Sv51Le0RJY2WSUW7FmUTndO25i2XPryelfq XgJ4XYnw0yjEYTFfHVknq1ey72232301R+IfSD8V8N4o8RUsfhHenShy6JpdO++177a6H//R+VLi 4SFjk5VGwVAyT/nNKJRKf3Kqu5csuPug9K/6ElFt2P8AnKU/dshEiC797Bivoc4qO3i3yr2IO1Gb gLninyNK4uZ6eRcjjtZUkjuU8x1kDRSIxGxlOQVI6EetfsP+w/8A8FaPGf7Nnh6H4f8AxA0O68W+ CNOgZLGQ3j3FzbYf5Ni4LKdhwSPlO1eOOPx/xf8ADfDeJHDM8qn/ABo6w6a6O1+myavp0asz938D /FnFeFfEf1+LvhqmlRau1k9bddHZ212aemv6Y2H/AAXm+Al6Tn4ceKUijAM08d2ZkiHTcV+zhsE9 OK/M39ur/gp/fftTafaeG/B+h6x4M8OaRkwQXK+S2sSmbcs7uWJKqqRsFKKR+eP5a4H+jJmWV8RU swzGDVKm7+9ZdNNN3/Vz+rePfpX5bmOSvA5TNOc7XUbt7p76KPfXtZXP/9L9Iv2Mv+Cu3ij4BeF9 L+GnxL0GT4gaHZwsmlHT7xYtVskDFgEDYHc5HI4BwOtfeR/4LufCCMkT/Brx3FkEo32uEgAdS3yf yr/RPjT6MePzniCtmGXpqnN33ivLZ6n+f3C/0uskwGSUcJj5L2sUk04zf4q6/E/JH9vn9v8Ab9sH VNDn0nTLnw54Z8O7FtLJBi7BR5X3SMW5JZwSRjGBivqn9lb/AILI618HfBun+BviT4Sv/Gfh/QLe DTtK1KC+aXUmiWJc+WxQYVT1Vt2O2Oa+0zT6PlPF+HeF4Ygv9opu91a6fq1bXW7630Pzvhr6T1bA +IuY5/jZf7HWfu35rW6e7vppZdLavoegftHf8Fj9G+MPw8174deB/BOr+E7fxPamxu9W1WEzyyRY 3uiEqFGdo7Z4r8+P2M/29fiR+yx4iez8Px3GveC9TvBcanouoXaobvaG3sYiQgZhyuCGB/iBrg4W +j7DL+Dcdw/mNJudZ3V7O70trpa3Krdnqnc9niH6Tka3HGFz3AVV9XhHlla65d3tZ812/wBGj9eN N/4Lw/DW43wXvwR8YwXUUJmeX+0reO0kCnDlD8zEZBx1P1qw3/Bdn4ZLcW9s3wh8Sxyzt/qmvAXR CNyn7gzkDPAxivyqp9FnOYTcOSTX3/ilY/VsJ9Lfh2eHlOdWmn22/Bu5/9P9rPin/wAFwtN8beEP EnhL4feAZvDWs6lbTaPPq+s3Hm/2asilHkVByGAJxkZBxX85fjDxDc69rmpa7O0slxfXDzXM7Ssz XDM7EvtPC5zwBj86/wBcvAjwhqeHMcXicZG1Wpor2vb81a3VdT/IP6QvjPhvEtYPB4CadOk25ct7 Xtp5O93s9LbXOYNwJPKlJVBF8oUJh368k0kk0TeWIQfMkbbgcEmv6UjG0bH8se03JJbcRDeincFH mMSN2faoUckSof3h2Fk3LnoOFJ9zioqL3bGdGrarc/ZD9ir/AIKqePv2aPCfh74da9olp4l8LR6e sVlo9zNI39lFQ2EgYNuXORx0478Gv0Psf+C83gm5KFvg3rs0YG2eWyupJ44GB28sqMuM+pHFfw/4 o/RvxHEvE1fPctTcKr5ny2um+jT107rS1up/fPhX9KPD8OcO4bh/NbKdJKPvXs0tLqS01vqnre/R XP/U/c/xj/wXT0290nV7Twh8M7iw1CS1ltdPu9QD3kjTFGClY1YDAPOW446iv5zfHnilviP408Tf EXxPavFr/iPUjeXNoSqRQeWohRhsOw7lRWPuTxX+svgb4Q4rw1rYnEYv4qsVFXte17u9trWWj/Q/ x/8AHjxgwXiZiMOsA7wot3tdK/lfe93qv1OWkfT3ns5tOhc3yIUWA7pHkJ6kAf54r7P/AGR/20Pi N+ylq0Gr+Ebuaezmm8rWfDsrH+zryPGAWiHynGOc8556gGv1bjjhTB8X8OYjI8ZG6mnb1t8t/XTc /M/Dfj3HcBcWUM/wr91WUlfTl0v91rrTXY/YnTv+C8tu0MEd78E5rqeOIfbbqzv5bezD4527snk0 lz/wXw0tHi+yfAjVrmPdsuFS9LPGcdQxYDH4V/G8voqZhGraOsFs+aPc/tSj9L3JpYZyqT5anbkn 5HnHxS/4Lk694s8Ca5o3hT4WXHhTUNbsG0+11A3gvLhFlGyRvm+VPlJGecZ49R+GGp+JYPEfiTUf FVxI66xqV9Jdym5uPtA82RyxcrkrycEjpxX7P4R+DdLgCGLnjIXq1dLuzdrd121+9n4p4teP2I46 qYWOV1LU6erteNmtdpd9Lu/Q/9X73/ZD/wCCq/xH/Zw8K6f4F8Q6Q/jnwtYTGK1tZLjzLi1jB+VY QxBTjCgBguFUY4zX2XN/wXlMcBuX+CzW+bloltZZZpZo1B4LlXI5HPy8V/opxd9GupnnEOIzXApq NR33ite9ntsv8r3P84uFPpV4bKeH8NlmZSXtYKz92T6bXWn9dhx/4LxQeSZP+FV2sUjuqW9tci6S aXOOnzgY7818Fftgf8FQfiB+1b4TTwN/Ytr4J8Mw6s41HTYYkSe8SNo5FkaVmZwB5YAGepzjjjTh D6NM8lz/AA2b5hrClJPlunf5L/P5Hn8d/SnoZ9w5iMkyh+/Uja/K117v07ep+Xct3pMs8r274ujb 7PMcZgXuApzz0GenSvqr9kj9tT4kfsj+JZ9S8E3Fpf6ZfOZtY0S4aO20y9YpGjhhwDny1I9CPXmv 6f4s4cocUcO4jIa69yrHl6/L5dD+YOCuL63CGeUOIaTvKlPm6a3/AF6262P150//AILzat5TtqXw TgKQ243z2d3JOkkv8QVlkIwPUA1sTf8ABcTxDd6VqF7pvwis42itGuLdjdPLIg27k3Rls5ORgY5r +Oqv0VcfHF+0ppuKfSUbWv56n9l0PpeZZUy6UKs0qjWzhO+22mmnz+Z//9bO/ap/aP8AE37VXj9P iL4lSTT7+ZJI2sp4kBgUlPkAABGPLX36e9fOdxFbG2823kRpYgBLC/3j7iv91OEMkhw3w3hMjg7q jHl/Ft/iz/n54zz2XEfEmMzySs603L5dPwW3Q5yHbuPlqsLKSRgbV5rXSSYBlTy5ZHQAkrmPqOfY jHb1r6qDuj5jndtAkud3mw3YhxO67pVjEe3aML09hUOoX87RRfZIA8QZY1mI3LtBG/n1IBqibu9y vcSGWJEiUAr8zdif881BuGwMjHzFIEqt3HegG7u5/9f5FlZY1+ULIScqSuf50iXM0ZWKRShZc/UV /wBAB/znleZt0u0jeh6j/CnBJAiI2Sh4U4+7WkpJqyAllmQrDEh2tGu1mJ3GUjv/AJ9KSSS4KlSq sp6FhzUPUd+hBEkKoHnlSKbzNnknd86nqV4xkU5okIYA5HY9CaQj/9D46tpbdGaORtshbbEGAK4w cn60+aOVCUYgxN0YdMV/0AH/ADnhlUVFjKkL8owOo5ojdElBkGI8YKjjdQBtWN9p9nCZYom+0DdH LI7b9ynHCjt/+qor+WwvZEaK7zsTAikjKSAkZPPTv60uZLQabRTtpTFHJLCGkeNioyMbMHBOKbNA k4a4M0W9gd8IUqwPr0x+ArJtX2Nz/9H5AhtjEqK0gIOf4vnGPWpldo1kSdUlRlKBHG4AEdfqK/34 P+dcym8re0YUBVHAxjFWg6lUCoRxgjrmgNizI+5oR0aPoR1BqFlnaRElRzAzkGSMbgvuaB3fcnjI +zu6bZkjYjcBl1A4z9P8KpwwtuMyyZEpyR1AHTH6VnOKWoj/0vkZlhb5CW2Drgcj6VTawjSfdbzv dRBTISEZDHjJIYe3rX++B/zuwd1qaKWQ1VcWKz30wUl4LaNpZkCYySAOnasq4g3sh3+V5C7BGBt3 f72P6+tBQ+ykmWVgyo8JjK7SPmLcYIPbGKluHmRJXLJg4UxP1A/vD8KAGvCGa3TzAI5EEm7GfLBP Uj+lTzG2jf8A0QsmwlPNBZWmHrjPFBrB3Vj/0/kmC6uyyBN0ywRFcYztUkk5/En86S+hM6xu0exQ d24r94+g/Sv97+VLQ/56oztoyKO3Tz7YyEpE0qiUHjK55+lS6va3cmq301vYeTYWSiW3aMl3EbDb lj78CspR5djXfYs6cj3KlmQlYk3NGiEyMO5P50y5ha3USC3kt1kJeBidpkAI5xUgNO2eOSeOHygo DSyD+I9D70+9uUjijtoiVlaPDPjDEHnFAH//1PlNZPtEQiG7YiAc9scVCkMt5LFawLvlZtkajGW9 K/3oP+e8rT2sCzrC1yIw+A7kF1Q/gM8f0rPaATHy5DuET8MMhWx0oA1S09u0Upt/MAwIiOEGP8MV fvnlSCRkcljKJPLBwB0zWc11KjpJFby5ZohKyoitkFzjk1DYxmbfbRK892jkF4kIXn+H3PSspK6s d0Hax//V+R7GSa3u2CRqS4Maq0fmFGPfb3IzXQrcyQWn+kPAwjbe8sSETMenz/4V/uxNct0f4EUJ Nysem/DKEXvjjwNFFId8viSxkmgWFkeaI3CK3OPlADbz7A1/cv8As0WkFv8ADLSI7WR3tZLaOe1b sqOu7aP93d+tfwj9MOUvquBivhu/v6fqf6S/Qz5VgswT+K6+6yPyo/4K83tiPCCiaQH/AIl06wRj MrSkMW3BfZtn/fIr+V7xPc2yQ341TfOklhKluZIsO0sg+UgdiDz7ba/RPowwmuA1J7X0/G/6H5L9 JWcF4iSit21f8LH5G/tDNZx+ITDBIVvbW2NukUhxIhLBmVh1BwB19DXyf5KoJDcALMzEyd/y/Ov5 M+kZV5/EHEeSS/M/tPwgp+z4Jwq8l+SP/9b+SU2vmMXCbYR93+8fXjtUEypbgCAKHXlgW5fNcclb US21MqcytcqEZTJtydvRfrSSpK0ZYyZkcbcdPbisZK6NafYnt7aRUUMQhA+Xj5sUrW9lJOfOCStb /vIDtyM9CQfXt+NYmhPZG0hjf935QeX5nI6HP9atXFotx5bW78An94vAOKCouzP/1/5I5HkaJFJ3 bDsziueJly4B3SyNhnJzxXjNJ7nop21RDceWYlgYfMHyWVipyORwKz/M1EyOHmItpPkwR0x3BqJQ stDRzRox3RWM20gWUAYEgB3AelQx2k0jPMgkCHCjd90YrMiUrs2bQi2QwRxosk2Ru6/XrUfltEyh pgxZTuQDHNBrF3Vz/9D+QgrG7bmwEXhiR0NVrhT5YQlSd37s+1fPnsFWRCFXcxMnTB6VcdYZbVop I0kYjBZf4PpQZqCIF22sLSqCzE7S23AAHrVVI5o51uVnIiJ3rvyzMaC4rlViW41qSwWP7bEpknby o3iBkVs5Kgnt059KLNlvpXkmAjR1CovfPf8ACs3DsFle7P/R/kBu7COKGUIFbdHiDn7jev14/WpL SWNbNA0e+4T5ZWP3sivmeSR6fuWZl3c7PIpVV3IdwyPlz6VKGlkVsAqyrzilyvaxBkajAZWtlN1L IW/1yBcBPUVsmVBEttDD5cQiEaqFwCAAKag2NOzuVsBWjdVHyLtAxyMVFJ8/lOQ0RVuSrdTWqVlY G7u5/9L+OlLmVJA0M7xFJPnHRZB6H61dMQkTIO8t8zN0wa+fPWjK5NaIWAQpudD1b/GmNYwyTSOj L5kfJXrsz1/nQappRaYwCNAwmAk2nIGN3tTmlIIICDI+RMcj8KCW72KBkk86RZFADfwkdalmjEkL byx2j5UX+H61MldAnZ3P/9P+OjT4PkYxMykOWWbPII7CtN4m+021zAiIOTdj+K4wCF/Wvlz2k7Kw 29k8pZJvIMzTMsexT8454I9Mc5q0hhu5IZbjbGluu3aBjd6kn1osSdRpek3t4sa6bEk8UkpXZu3z gjvsHNZus29vBfeXMYrU2yCO6fBVn5PLAng847dKdtbBbqYc1nFbX1y8Dt5Bj+VyDhhjrg9OhqWw laZoovtUasLoESEDcUBztPbJ6ZpWtoB//9T+RqKOPUhNMZliVLgw7GUiRsZ5+n+NZ8tlCp8xo9xD 4BxlW+lfPRVlY9F7seFNujmID94dz8c1asridCY2MtssrA4Zcbh2Iz2PHSqUWzKS1PrH4BQaLrGp 2d5N5bNZ6mNOuWjTZPaf6ve0JI9D15GSK/XX9nS2s3+K3hOw0hr6O1sPENtFdbrXzLi8WQgD94AA Bk5JHA49K/tXwblGh4c4qrJaKE2/x3/rufyjxdTdbxZwkFu5w/JbH9437O2npoXwz0yGNlnuUhDT 3EmGeRdiqAT/AMBH5V/Pf/wWY1ZZdf0nS4vlY3vnhXfabMRxySFz2HAJHpkV+N+Cl8R4i+2a052/ Q/pPxnapcEVqfaFvwP/V/H/4j6wbTwxrqRy6db2f2VtRIvbOOQnySGLJMQSjHI6EZr8OviA0807t KwllldzJH5S7IsdCD64wPwr+1fpEz/4RsPH+9+jP5n8AopPEvr/wTxKZVSX9yWdf48jAB9q6axuw YVhlTbtcAbhtUiv4wqo/pi1jftYGPmlGh+zAjbhsspPXPtXbae0aRoJVIUARgRDIHbJ9q82r8B1w aWhau20+z03y9ReRwkzS28kceZZMnIQgdcVJpGnuNQtg8ktp5hWeJwMrsyOpORyD0+teXVtqbR3R /9b+UiC0liYkK8UUJCSTRkPG3cjIOOgq4w003EMlt5ssgXcWeMlUx15xjBr4qe5672ZZvRBHaOlm VV5lCXXlv5Plg4ycjnjt+FQSRwRwq9pmNYFWPE7gF843FfXJrGUVZswJnjDTWqyxmNIbYR28gXLT r356dRj8KXT7fT7S3u5tbvp3dJcqzoGiKFsBMDGCMjnvis7AdatpBp9vI9hOjweXldygpICMkY/z 0qjbRT63N/oqBDbnzHSOPYJNgGePTkVT0SKoN/if/9f+OnStcuNCurGd9NVo7Nn8iaFVkmZnQhS+ cjANcVptjfanqOqXU8/2ARPss1kgYLdknc3ynt156elePUX7tHncz9o2d2qyTRPabi1zsBWZm+6Q Mf4Vzd1o+p2k8vn3EckJUNHcJuKykjLDkDGKzprqdqn7qsRf2Zf26LcXV15kd0Ujs4GYHjkEg9vp S3unpqFo9qwdZ4H3MI35BQ5yCOO1E1qVCbNJ7uAw+TPGrsYxABMm5fnG3n3qGCEQyQQBnSKLAigX 7q+gA/pVUlfQ6U7q5//Q/jwUr5bFl8plIw3QD61UEcaie51O4leMTKIooUHzJ3we341yU0BFplxp iTTS3MVxvlBjsYhkJLtJO1uw478Gn3lumi2oMEdx9qvJWnVWB2IW+YfTGO/0rrpq1kJ7M8g1gXMs k1xMskkpcliwJxmtnwFqOvWOpWn2W+uIYDN5RigXcg80hWklGeVAOMD15r2sArYik/NfmjgxcVLC 1IPaz/I/b34B3cp8AR29zsup7C3h0/yrUxmOTejSEyyDJLEg454B9q/pp/4IzanqJ8RSWbX0Pn6l qKC4FrJlkMNtEoiAPK7QrDH161/d3HkY1PCJuX/PuP5I/mrwYnKh4rVYR6uf43P/0f7dvF6NfeEb wy2y3U15p3lHzBtEJ2fO7D2wePev4Sf25vD1vpPx28dQoIIZNfmGqfZcASW8kZWEtGP9ox7unUV/ R/0X6vs+L61N/ai1+v6H4h9Jyhz5TSq/yy/NpfqfCl/p4u3lIsWP2SJVju5cbkcgeZjjgHBx7GuJ lSC0BS309pr+e6/eXvmnyIowFG3GODnJ989utf6F0rWP4Nr/AApef6nQM3mWxSeCeeVYlVArhVCg /d3HP4VgatotnC97NY6naTLfxpILS0meSTTsIA8UjEDnOenHStdBlrS9YiWGHTJ4/LR0CQ3rcouz AIz9K29Sjto76K9s7VCx0x7GS7jk3wzJJGUJYHuNxI/+tTA//9L8oNNt1jtRBfXBaaNQscgAYTEc ZY544rYh/spJF1G9je+WNVFxbK+wHAxgMBnn1/8A11/tAf5PkFzAwthc6fO8cXnLM8TxlhDxnYpP PG7k+v0rS8kYW2uIz/pEId2ZfLYgjjPcZB/Wk1fRlpySMYpY2d0sCose6UtJIQS7EgDJPU8ADv0r UW3gvJgYVVZxERGbnakEnoCTxzU8iIKsulxWiXcTiGRTFjzJJC8ZlHVIsdfr0waLeCBI7AXkjvbQ TtKlurghnCnaD6AE/p7VdugH/9P8sY1t5ri0+1KJEuZSnlCTBBH8Jx0zx+dWdQ0+eGczcR20SbTu JDxj+ED24Nf7OuCP8nrpbmRdwXr20ToytayZMTs5c8E5YVYsoordY90ytKSEUN1YngCkoWeo29DW /s3Ubh1mmupQEyUsociFxj+IdzU9jb2rOIZIN4f95Lb3MBiMAzgA+o6fjmtLWVkHNZeRo65aajcW kttc6fcJBbOs1retZyQ2qrx8qyEbTn/9VYy2LpE8doIoVCBpgxzu9cfU5oDm131P/9T8vZbNbWGC JLe68rUJ8ztuygdQBkHI+X6etEvmykwxKzpGQsg5wcc81/tAf5Oc+pfuIdKntmtoN4uzAGeG6Qwg ZIHA/DjNLpumaVBpDWtl5qXsdzvllEhZH45XB6YOOlBhOVvUqvbR/akW5a4uZuZPLjbG0gH5jwf1 q+txIbO1jnaNm8xnlVTl4RkgDOPQCgIyvoxpvrdYhCsiXlu8jRyJJ8m0e/HOPSpb3URbPBc6Oq28 JgEV4gIKuQMHaPTj61cI33KP/9X82FvZNQUKgj3yDbtdgkefcn6d6qacut32pNB/o9q8DBbJ4XI8 xwcBRnoffOPSv9pnFOx/ks9i4ZYVurk30gjuD+5uWnlDLvU4Yhj7ilniudKC3hunmtGI/dhw+7dw o9cdKcVZWZDbTRNJpkuoEGOMbXj8xokGSPU1cg+wWgW0a2SPy0KMwjG8sARnHrTJk7swEt1tbu0u ENxdNdyvHewTyLthjHQqO3Wrlrbm1keK3Zp2iczIjMPMjySV6/pQcz1dz//W/OBpWspIbWa0uZJb pTM5f5hhjwBWrG0sUElvLDFbRGPbAhhVXjHXg9a/2sp9T/IKcr6GVDbWM2pWRimWNYTmZHJnjvGy TgqBwOmR6A0wfaI7mdJ47SOUzsQ1oNtsATwF4HA6dO1aEEd7PdDc0kRdIgArkYRjjoD+HQ1BdafP qNpY39sGgvI2PnQSSKUZADhlx1Oe3pQD0VzVsrKWPyoLyJnur6L7TbzW0nmokIXBDADCtu7ZrGvW t4ZjDEzybJcSHPJxxigxUmj/1/zm0iV2Ek9wfK04IY9ypuKv1UE+9afnLNbTu8bmCORIJZWHyQh/ unPbp19q/wBs1G8T/Hi7vcrTww6VDPJBcrdooG+S2b5Mk4GfpmrenQvGGW4Cs0o3YZcsO/X8quMe UiTaWhgapDLMtxPFBIzwSeSi5yiICRnHQDJycetaunwWqaakt5LO92uAIkTbCwHvmqI52VJLmK2g 1T7JDcQ6lfKoga3mAsEUON6OhBPK8ZB+uaw54LiGwnlmkcyXkwJ8vD4OApAI6DjNVFe8hOTasf/Q /NOy0q1SJPtMzC1SL7RdmZwpVBy2CT6Y/wAKuafe26zww2yTNDeHzopJASpXHykfh6e9f7gH+NEp dTqTJDb2V1Dd2NvMbplUyt8zRqpyCB2z0rGhtrO+juoGje3VxuheJ9iowztOOSQDitIR6mXO7GQk M0UUWnzT+btH71gNoZjgE+w4r17wvYE2SaZPI9lEHNyzCMzec20BRkH0GB2raC1RyVpe4z7Z/ZMl fTfiH4Yntw5H9pJBeJLMTFtaRQrkDpggYz6iv7fPgxIs/wAPvDsqhcNpyFyjbkLFFJ/nX8IfS8p/ 7XhJ+R/od9E6d+B8TDtN/qf/0f3h/wCC1BWbwCGu1tpVsre31WCG9UtFKYLhfl47nzW/ECv5etVE 14bN/KWH7dAk4MDHyzuA4B/z2r/Uv6Lf/Jtadv8An5L8kf5Q/SWf/Gy8XHyRoQWDtCjNHNOYQEwG AXA9eOD1rMkhnQi1ltRbTvNwssfmSp3GT2HSv6ap7H831NC8mnyQXLX92kduAfLQRyFImBHIVc4P 61Hq8IktRcraTrCj7ftRT9y5PGAa3p9Tjl8LOXntlcMwLAquUI4Gfes2C0kvI2N0Jo40k/d+W+1Z SpB5Pp7VtD4kYn//0vjhppDcqm1A0MWInxkAEk7SPrzzWeHim1CdZWaUlstCV5U9wv1r/fg/59Z6 ROseJn0hhaSKgkKr5R+UxBD6fTNZdrHd2D/a03plCkk4T5WUjGD6g5IwaDEyo5ij7lPG8twuxfy7 VqzXyXapErPHIq84TAcemaAK89pNNbTp5cmAmY5F4I55NWo5lNvbQzRRr5KbWZE2vKfV/eixE9rH /9P5CaaGWRIIisdumfOdB5jsccAj61KUM0TCSPKxtiIvwJBwMjHpz+Vf7+wTW5/zzmdIXjd0VVky B5fG3acd6jWOczEtxKihSudoXJ4GPwqwLkMcolYSSKJI/mSQfdyMGiSOSVgZPvHlnHRvfHagie1i 1BHJA6I8srfaMiCJSTGmMbifStdLQyyxSRF/OVsQ/N5YmYdlb1FBkf/U+QP7L1KXUnjlg23Ee64u QsqyYUDccv0zj1+nWr00M0iNGBgM2Y8feBH+TX/QCtGf87t1zWGXFxMLRIJIyGQlWZupxWLDDLMn 70BMHO3OQta8ytcie5qSyQrZpbJErSY2eb025J/xpY7AJG8DgAQqCXRgVX8RxTv2II7eFZPPZZ5F VV2hWUbcj0NW9O2WzqbhvOjySysBz1wKZMnZWP/V+OIDBNcyLOxIjcsUUheueDT5IpjcxSRyrHHC pCqEGCCTnPr1Nf8AQQf855OILa8uonJOUOXP+qUEZHGPpT9Qt4luR5IZ4SFIdsMY+Bnd+Of0oKUn HYhWEh05ysp8pC3K56cfTNJd2NzassUsQBbnbwGwRw2PTpQVz9hsNzMIjFHkhTjA6UtxBLNapvV0 EoPTjOODVwWpKk0f/9b4stXvIGMAwYGkGFI+99a2vI3ySQAI8igklTlABnkH8DX/AEIH/Onz+RSN wIN5ltTKqKWUROCz49h/I1NDtkKyRoQJBu2dWXrwfSghtt6iku0gTbvXPYZNaWnXcaSCOQblifYs eACCeaDKUmnZFZpVhnuLKMFdwIYYwQCen6dvSqrySxqIs+WhOAScBvaghyb3P//X+PuY8PIFyOMr zu54qygeRQGUAZ49a/6ED/nHIvsUFvO9zwJZcIdx+96AVae0Z/3iL8wGcDrxQJNPYqSQJMWklx5k rfOxA+bHc0hKtMYxHtRFCkjI3nHJqnL3Uhkb2UzDaHdVU71A6MB2IoXy0WKOOMqjNtIH3R6k/U/z qQP/0Pkd4tjk+WUYgDDZqUOV27V+YHJwODX/AEIH/ORd2sQzGZla4SIIrSiMlR8uT/DVxRcRp5is YlUfdBwGP0qZL3WXTdp3J4DdSyhxcJEUG9ZCM7GHIOPatvT/ABfrenLPpy65rlnbyg720/U5bOOR mGGJVSOuBz2rzcXlWAzKCp4+lGpFbKUVL8z1cNm2Py+pKeBrSpt78rav62IrjU5bmaO7vr7UL+aG P7PFcajeyXsiKc8BnJPem21wYnys5iYMWUq5B5zx+uKUcBh6P+z0YqMEtElZfctC4ZhXnGpWnJub s23q2/Vn/9HwtPEmo2zLGiPaAAPE9vdTQru9dgbbz9Kzn124jkvZppLl5LlQH/0tyEI5GBk4r/e2 lw9lOGqvEYahGM3rdRSfbc/57a3Euc42ksPi8TOcF0lJtd1oxE1RprMmOSaGWU7jLDO0TgjoRgg5 96u2Gra6sLW51bWZTP8AuEL6pNhcnoBu/Kipw9lFaftK+HhKXdxTf3tF0uJc4oQVGjiZxitkpSS+ 5ML7xPfjCS3evAQwraK1vrlwH68t971J4rLvo2upLa/Ora3LNb/MYrnUnuIH4x86tnPH4U6XDmTU Kiq0MNCM1qmopNfcgr8S5ziaToV8TOUHunJtfc2VbW8eJlhhHkwxptTyxsRAO2B0qyNVto5HdxcC 4Rfle1uZLLzGJzklCMn610TyzDYuHs8TBTj2lqvuehz0MyxeDtPCVHCS0vHR/ej/0vnGXWNckJVd W1ixt5Iztjg1SZNwPONwbPPHBNEN7ciyY3Gua/JMZAqhtVnQqOQSMNg9O/rX++ceG8kjqsLTX/bk f8j/AJ7KnEWdTfv4qo/+35f5mi+swtFDJcvC1xGotbXc8ss7oFGWfJIJPQnrWTPLO1xDCoJRVMqQ jhEDdT+OBXZDCU6Hu0lZdlt9xyfXa1WSnVd33e4WV69pdhpdsicq0foPapbrUXa785ITAV5hmJKy YPfIPtRPBUMQuSvFSi901dfczOeNxGHmp0ZuMl1Wj+9Glbax+6it5XecpIZGa5cys+exz+npWNNc CGfbbxrBlWBkj+XCucso9jSw+V4DA831OjGF9+WKV/WxGLzfMMfyRxteVRRVlzSbt6Xuf//T+VLl 2XzGgysgGQR/F71WMKXShZmIYjJY9h3r/oPjsj/nKT0Z2Gm6do6AT3Fyyr5ASKORRcQRsBy7Dr+F cwywwzyNayvPEGwszLs8weuPStIrRig7MlALyJIgCsGB2k8N6/yq1OttDLFJBCIJowNiQM0CxEdN oUjFclfC0MSuTEQUo9mk1+J6NPMMVg5qeGqShK1rxbT/AAsTDVGto1lZ7uWSaT97vuHcgnqxy36V JNq5uYkbZA1xCPIgdoEE5DnJG/GccDvXLHKsvoN1MPRjGVt1FJ/gjqlnmZ4mHssViJzhfaUm1f0b Z//U+VRMYmMrxs7EHdGrYKsO1az6hMbK1ZbIWk0zbniLBmVR7/yr/oHnTTST2P8AnhpV3Cnp5DTr XmNGJQH8obfLPAcHqKUaqofzks1gIUIkaSFAuO5xjJ9zWMsswddp16UZNd0n+ZUM5x2GvGhVlG+/ LJr8i1Nr1zfJFHNCiLHMkoVo0O5kOQWwMHpznOe+aqXOrai941xFcvbOuY2aNVAlUrjBGMV0PB0Z LWKaMlmOIhrGTRG2pXjRyR3UnmqyDYXXOSpGMAcA1Uj1e/kSXTQsItZTulZl3SuMYK59PaojQjpT toX9cqckpp6v/gH/1flASww3pjhgt5bdF8oIbVNkePQY4rf/ALav7OxisbO4lhTzmmjWNUKrngja QRjn9a/6DfqtN6Sij/nS+uVk/dk/vOXmLXDSyu5eeQ4kYjDPxjn8hUsVmhRG6MvfpiiFPklKMdjp o13JxcmW1OkNuOpoJzZxmWxRoRMGlDLgAHgdzntirIundZEjhggWZg7qlsiyN3xuxn8sHrVxw9O2 qOWpiKrk22EVpembbi1e0ERlK3ExkG444AOQO/GRTYm3hkOEjB2qq8KPpipqUKatJIqhiKkVKLb1 P//W+Y5bjawghlmW0fH2qNWwsrD7rED0JOPSo717PyoESGASMCryLGoL4AxvAHP41/0IrD0t2j/n QeIq3tcujWp447We2S3gmtI/KWaGFQZB7g8H6YqG61u+voXS7upXSRlEkaosKSAdmCAAjI6Ed6Fh aVnyxX3D+t1nbmkxnnMX3Rhmd1AOOwHFIb1YQqwRxT3DHaY5ACoXjP8An2qKeFpvSxtPFTUbXJEu 5dP8u3AjSKLc8dsI0eJC53EgY49ce9WpNVM7bECEup87CgD610fV4R6HM8RN7n//1/mG5u4o7WW0 mjDRuu3nGxFznAGPr0rEiVXl3x4KYAiI42jsK/6GY0lFpo/5zo1m04sS4t5Pmk3sc/e561m+VOJB 5cjBD99CMhq3Mm3e5fggfJZWCgZ3Mc4FXFXzG2qSSFxweDQSRxRTIJVMYyrdc5IHrWlZWyCVJ5gc JxgMVDfWsqivuWn7rR//0PnuePT3hUxFklWLMiyYwxycbR6Y21iSWr3KGZ0jCxHYHVQh56A/4V/0 KSprVn/OGpO6SYTvNApDAlUQDHQD0plvcug85wxUrtXnkf5/pWHso32NpTn7NamxcJZQRWtxa363 Mk9sGurUIQLR1ZgAQeCcc5H+FUY5ojulCIZhkKdg3AnrWns9Njm5pdyu1zcSAtMjK4GFU/Kp9xio JJZwojSVsEhnA+6faj2dmromNSWrZ//R+UXvriKT7NGg8qVN2CvIOeufwpEk3vtmhYMigljypr/o YP8AnAcuYR5TkIVIjzgnH3aSaGBTHPC0p2JhgHPlk/SrcX7Ow4O0ky1ay+aQyoUdeM9N1bFrdSwS lpAFdTvz39Ov0rFwVtC5VJcxXuNUu4JXa0ZYftDcFFwQe5xVpJ9evGjaJzM24CWRkG1VxzwBgVlK HRo3p1pJqzP/0vmG7uZYXZSeM8tjAJqzps07uZIC0kqg7QvLdOtf9BSpI/50qlafK2W4L6eF/wB+ IpSkvmZZA7xkHPDdetLd6tqN1fxeU0MsbnYD5CrcpwAFD9cexPfrVunFs51Vm1uR6ldyRTC2uSVk jHzQg9/esoljhipw3QEYFZVKaub0a0k9WaNjdS20MsARGWTiUiNSwwTjBIyPwNJJfTT7oo8bVHKd cj1NEKUbGOKrTlVeuh//0/m6HVdQgEcUcmy3imLpAF4yQoY+xO1f++RU51k7nW4SV953Eq3QegHa v+gqdNODTP8AnGp1pxmncybi8OfljkGRlS3I+lWIb1pYrczkstu4ZYdxQDH8vrTpxS6Cr1p3uV7i 5/fPLkxROSUTcXKj0z1qIPP9oQpLtj8piVYck9Rg/gfzrVJIxlUlZMaj3UxErjfESUBz8xPvU9v9 q847URwBtijKZ+Y8DPP6U9OdW/rUuM3ys//U+Uo42Mk8F2g85JCkyf3WBIIzUdtYafZvNOjTif7z pK5kScA/dX0+n6iv+hdJI/5wVJpWRLbQRTQxXNs8QguOV2vlYz3U9xj3pxa4t2YPGF2fKCR1GOtO 3QOZ7DbU7XJOFQHJB6VJJc2jTb13/J8u4EhG9eKxslKzN1JtEyXeXVkOAPlwTirHnxS3CDYHkYbM y/Mo6flTlGNiISlqmz//1fmh3RGHyDeTjdGMnHt+VXGu7FfsbwLL9pc/voZGyoAwP15r/oO5In/O Qpy7lW6uc3iwyWcghnVjmP8A1cZ7E+3Wp1uMRNGDjBwpB5FZ8keZo0jWko6MnW9trYwyXxd41kXc 4YjYOhP/ANb2p1/tjeU28gmhZRJDdRRukbBhnjcAcj0o5IqdgVWbi0mZy6pPBbyDMskqjMcm7JQj np37/nV641kWlzYzxW7rfTWQN5I7mQOxJ2kL22jH4itOSJl7eadrn//W+ZJ7iQCNX+d55WZpQMPg 8/Nz/OqzlDvjPIAxmv8AoLnCNj/nNp1JPqVIoVZWB4Cng9TUUEsUck8UysECFoyi/vNwHHPpUFKW mhLYyZjkHmGVtuGMh3Mv0/Opba5t7dJYZ43l8xyVdGCyKeAOSOg9KmS90zhK07k8KZhlln/esDi3 UHDx4wSfyyPxq9p9y0iSxhDE33BtONwHcipUFyoJVpKTbP/X+Z5hLal45WPkIMxncSQe/P5VErTh dpkWWKYBgQwkGOcZx0r/AH8rxs4v+up/zr4Wv8V+wqXsmnSRz2h8ufBCuoyU9vxotZ5ZJJi2yIeV hRI4jMjHoR7VjGmr2Lq13ymvDqcqxRxTR52DbJhgQCOmKrQ3mLhzcIzQsNqKrEY54Oe9aSpxS0Oe NZtD7p5zEEEbRRN0G7O4HuPQVR2rAqiFsHqWJ6f5xXPUhE66Fbuf/9D5ot7prW5hun3yIrfMqkcj +VaN7e/aplNvJhHfjLERoScc1/vrGEUrH/OxOq3LVkUlwJTDAm2OWMnzCJNyMeMNuPTv+dVrT/TD JFeXKWwWdle6lDPG7/3dwByec/1pTppqxEKjUrmPcRwLcyxBzOsbYWReAcentTrHYZpHeINFG+0J N8u8j2zn8qwp01zpndUqv2LibCamLO7jYP5VsuZfsqhjGSeCOue1XBrV5ayLLpmoTW6orB03nypl fGVYcHHbGa7PZJqzWh53tJxfPF6o/9H5bhkjl1W5vZo/OmuVcuOWRS3JIXPFVsTfaZTFHugcECM8 vyPX2r/fhKzaP+dCUr2uyklpIrEyOCzH7o6itGIgABGVdvB9a3SsrGfOipdyqzsog+1BCNpjwVPI yT7datNFd3IMdrauYo4jNMyjMMAyAMntnPGfSmLn1M9v9ImNttaCWKLLyn5UkIyQAfwAqtbRuokd gUd25Rz8woG59j//0vlRbCSeKKSNWId9hwucHGc/SqFzHcWrSxhlfPyn5cnb1/pX/QAf85nOrDoN vktvU7+mary3LxoEZfkLjBA5yeKBxkpaE8FspV5HXIAyCRzUypFJGC7bVHKEDLH04oKKTbAP3g+Y njNRyqWUSL0HBC9qAP/T+PUt/Mngna3DW8Z3Sgkg8dOe1NlkmuJDEoWNFOELHgiv+gA/5zyW2099 wJk8vnJLDii/h8qfyzslAGVaI7gaTTtZAUTb3MbxtGjSqx3yxJyyqAcnHbGM/SpoLRzKLjn5edpG R+VYWAvSBWw0Y7YkHTBqBtuE2oxcHGMYzzQbRemp/9T5JkiSSMSsSkyNkKv3celUwsryb+wH3T3/ AM4r/fg/51ya6tIpI4rksEkUEOgPyvVdYTIVZW2Lnqe1ACESmfaq4VOjf3q1LCS6tpSZC3kt8siA DLLxkcg46UB5Fi8g02WZnsBcWsDR7THJIJA7Ac5wAOTWabSTy4JI3KKHbzoT/Fj7p/WonsTzLm5T /9X5MjVyzPhQxXaBjgdulQSvIu22k2L5oIHkrtkYdDnFf7467H/OuQ2FrdaWoS1vmimdWQzbQGKE n5T+QHvWpNZiSBLeOMNPL+8luSuWzjsew60rX2AzrK3BM0L7kdFO1l5UkH+VUp0IO2SRQ7v5Sbjg EnOKLG0ZX0ZL5xiZfOj+4oRtvVsVNZWc2py3VxBC1vawHaiytuZ8Dkjj+negtOzuf//W+PFidllE MjbgdokU8H1pHIigzcXDrGHBmJfapPQYz0Nf74H/ADx8/kacsltdRwW8UUyyBRumeYODgem0YqaS 3/s6HzhdufMTy5YgSRKuQfwGQPyqJ7GkZdmZU00jQXEsO4FgFXadpxRpkM97OsMsyI7HAe4fap9M msiuaXcniF9Jvhs1Rir7WJOUUA8mkkvUuXMV1Bi6DDz7qCNRNcqu0BFOMKTjBb0oDmlsf//X+UA6 iEwBCzyjbjnK++fas2K0lllnLSOohQqoA+9k9/TGP1r/AHoP+ernZBGjeYYwd7RjCGQ7i2OpaumF iLyQfZYoowsYaRQ3y7sc7c89aBObJ7vS5VCpHeQTTGJWkWPhUIHTb2rlXlnMrLI+1omxjrnHWs5v oa023uXPNjDRDDFZEJxjhWHX8K1dMubS3nWRrfeqyGWQhim5toXGRyOBWMnZHdB62P/Q+RPtl59v t7y0iktxZXxleMDabpBwUyQeCO9dlAf7Ut5tWis/slq8nkGGRhI2Vx3AGe3av91qjdtT/AnCr94j 3r4B6Te6n8U/Aai7WGzXV1+1ySpvDrHiXy8nkbgjDj1PpX9v/wCzzpaaZ8MfD+n4ijjt7CKBI4Bh TmNCWJr+Avpf4xSxGCwa6av9Puv+J/pr9DzAOnkGLx7+02l8t/vt+B+EX/BaDUbuw0xPsbyhHtLa 0QxsEkt/Ovo1br/sxv8AnX84fi+QPaRkRy3U1urXSOh+dmRNxJ4x2BI71+0fRqhGPhxSa35pX/D/ ADPwD6RspT8U60HsuW35fofix8Zb5pvE+qL5bJctdl3vJ1JN8VVMkd+OBz2r55u7kLdgTfLCzAPK q7inqcV/FPj5U9rx/jLdGj+9PCqnycF4KP8AdX5H/9H+SRuUZYpwZJG+ViDtx2JrL8qaKYpIFZvv CRTuRua5mrqwGlcQRJEpKRpPKu8shxI4x0Nc1czG3aPBOxW25Y85PQVi4taM0prUl8+5JWRmcCND gAZHNWbQrKrFzskT5tuM7xXO1bRmhoL5M8aooVlR8sP4gR6VYguVhKxMhFuX5Kjkds0gP//S/kec xQ7yspkjLZGT8wz3IrJWLLZHyknI7AmvGbsrs64OzszLHmi5bhSQSCCOmPStJgBABIq/McgE8j0p rU0bSWo+2+zIN0sQdTwQPvDHQ/rVqSeM7IImUBvnIXnArFtPQE09ivJFkI0Ei/ITvYnDHA6Cqz3J ae12opCN85YZ34qTWn2P/9P+Pm9uNkMsaldzy5ZCOSvtVW0hdxFNK5K78woTyMY7V8+ewatxbPMq 4KgkYAHUfWn2UEMZERY5UYOPU9zQTC9tSG+jSAvFHMzwkBnZ/wCEnkj8KrWsxWRWV43EPRH+ZW9A RWsYpx1KLyxQ3cESTWsMbRSM0U23oW6gA9qQacVVpTtKQuBkHHJzj+RqZRS1Rg3dn//U/j9aZ33K DxG+CDzjHpWNMmoJeJJDIyIzZDRt09zXz56BJCRG7SXUhKvJsWPHC4/i/Gr5voFleBsqQgYNtwrZ 6DPrxQBnFHWVth3lvnLkdBWk3mbIWCs4iGZNoyW9+KBXV7FKWd2fKIRGOQxHFBk8wFAqH0HpQM// 1f45bu2aaGOONGi42NKpwxNaVujpDsdiCq4yOCTXz9j0NiwGkt7ZWVZC5J3FkwRjNQwtNPHLIjRq 2cM4+Uj60GqmrXGyiIPDFBMJ5TCHuTj92Dk9D9APxzVWecb0VPvovBHNVytq6CTfLoadpaee4nus zvKu0ADAj64NZOq2l7ZtK1pOXWRQHLdE5xjHcYxUjipLc//W/jijedbYCPd8vL4HGTViGWa3lWO6 ikWQqGUNnGDyCPY1864q57A6Sa7lmlHlN5cBXezKdj7hkFG6H3p7F3ZYlwi53Mp++P8A9dZ2XNYD VtNR1LS54p9Mnnsp4m3C4t5ijnjH8ifzqnqEl7f3kmqX10bi5lULMsh3/aMc5b3FVJLmT6jTk1yr YuW7NewXJZ1DRICI/wCKQZwQPpWb5MNqhZNyyM29Mg7hRyXdxuLR/9f+QXTtWtxcRW06Mu7q6KWB PfPp7UJeXU7zR3Uawxw3L/Z9pB3Jkbc/4V4CWtj1HHW5sQxQyxZEyNGG3SHv6bPwrD1OdD5dokku 45ZSVLCIZHGelaUlczqRs7o+tP2c7LUVuZxbiCV55YzZocuMEQhkGBjeSA3PT15r90v2MrHUJPiv 4LS98oTrfrPeQMdwk3SrHHnHYFs/hX9r+GFP2XhZim+sJ/kz+U84bqeMWF8qkX91j+4z4RwLH8L9 GtHIF4bKRb+TaYwp3MVyfoa/lx/4LQ639q8cxW8l19ic3c+nqqMSkjlIinTqPLZ1Pb5xX5J9H3D+ 145m+zk/x0P3jx+xDo8F1H3svwP/0PxJ+MlzeJ4f1eE6aYdO1TRZ7FXmgbyP9UozHng5OMkHjJ6V +Nfi1bcWcRsZ3uZJnKSgNvji2LtI3emQePav7L+kTK2W4WP95/kfzf4CRtCvL+tzx1N0zDyx0kwR j71byWbTyjaCoAGQT0P0r+Oqv6n9Is6u5uNOt5rS1hheKTyEDAKRFct/fJ+vbtXU2aNBZTu9xGJA Q8Vvgnf16GvKrPSxuWYRPczxzRRLfGLElxE2VWBcdR+P862PD+mXM96b97mQWwcoLJyoQEHrjrj9 K8qrLQ1g9LH/0f5VLBoFaYBZIV3ZQO3mI4I7D8P0rQsJIYXX94ETOxlbuK+Jm9T13s0RatHoWj62 Luyt5ZrLUURLjfkxeZjn5R6k/oKivjYi0S4ls5iltL5uyPJ8xDwcr2wM/SudybMCWxsJEa3nf7TD ZKvm2cEknmeTESTge3Wuh1y302cRXGiWEccR2ySwThpRckctkdix+vSkuoE0EMF/ekiJdPtDBHut QWyr4+faCemecVqQ21np15v3y3Vq2UZ4JPs7xHHHBB4qpbJCovldvM//0v48w+l2+n6Yz3MlzfXl m9zJBgAQOrkbG9/un6MOtchb6jres3e+e9URpO81rbXVqbKSJFABTnBwdoIPevLlFezR5lvfudDp 1pPLfxXtxKcxHmBG2wuOmH9fzrT1G4muU+z7VECOWUEcE9M/oKySS0R1R2RjzWMl6sS3N7FaxwqR ln2p/snJ79gB61TdwkDQ2UzPKqncY+VdQBk570pK6sawT3KMW22sWledXaSUeSiJ50gwcHPdcc9a msL2G71O/hi86e6s7NbmaZYz5Yz0Ut0B68VrTWp1RjZWZ//T/jitr2fUo/tEls9uhG1hMojYhRjO 0fSr2m5Myo4R4t4MUbcjI7msKa2LcGti+2kXN/eWml2MsL3MVxLqN8LcCQRRLGXb5s4Bwn4Z/Cq+ t5ED3Dy3A8oiP5oiwKAYyO/auynHW/QOT3Tx3xDe2qQFbWaefzxnzUiA8o+4PUcfrWLorarK8ctg JBdwSq0MYlEAucEZXJ4GemK9fC6VYeqPPxC/dTXkz9n/ANmW7mh8J2Wl28Miyz2cM2oXpjLyec4B z36Bx83sa/pA/wCCNGox6P8AFK80Ka5nNxLqsmo2tzHGXuZN4aGQsenys0Q47V/eHE9OWJ8HXGH/ AD6X4JH8weG1ZYPxcvLZza+/RH//1P7idR8i68OTN5kkaG0IbehyrFduSPTmv4fP+Ck1lcr8cLy/ tLWwsp9GkltZr8B/PvN16EK5GeQ04wSMDHbrX9B/RoduOZRb6S/Jo/F/pPSccgpNbN/rFn5pi/vJ /Ng1A7XnuG8u4L5W4xk7c+o79abYvNZz3Fwz2ot5lEbK9uskSH7oLDBHXnOK/wBFKabVj+Aq8tvU zbu31C1srg3ELQvbky787pLhGAZCq9eQQR7GsnwzpsmrXdzbW0TI7Qm5lkkhKKoA3EsxwATjGM5r RQd0aJ6XMPULhLabZcYiglnKWsLxiNV5wVTj1H61t2wuVUWt7II7eaITWtqrBsrj7xI6cY4PtWoz /9X8rJopYbUSJZKqyhhDvcuhOMdfyNYMEk9zC0cwWOaEbJlhJC7hX+0Fj/KSCW5sw3nkiBJcxW7R jc+DnjqxFW726j1BFeWaWSeNkktWU7QwjAChsdsAUDk7ImKJIJdUl8u4l8gjyXULCG24xx6f0rGs 7C51Dygys/kgtt8wtGo7k/T9KDn5kpWJlW7sdRstOZGeGUS3WW/ewpkAL19SOntVmWG1XdbZkiuH k8xXAwGPA/kBQRKXvaH/1vyjS2MbyQu7N5RMyzMMMpz0FR6prM3lptE7QphXUryexJ9q/wBoD/Jh u+rCy1bUpLh1AijtFtNoszEsUEMY53c9CcfUmr0UXzG6kXYqplAq4Ax0IoC7NXTdR1GaWK3hEUSz Th7yW9baY4v4tp6qSOw9a9B0Wfw3ayyajr2lPqulW7KsFtbylZJ5AylVIwSc4/MgmpmpODUHZ209 RxcVJOauuqPS/i78a4PGnhfS/DGgeG5NMstHiS5lhwoNwyLsWIAD7oG7Oc53Gvn691EwW8lw1nax XF9apALTHy2vAG7GecY7561w5ZgpYDDexqTcpNttvq2/8rX31vqdGNxcMVWUoR5YpJJen/Bv8j// 1/y8SO8soLK6kdJBJK3lojbmyu3kr/wIflUul6zFbXV/NKN07yrPFKYxtRh/eXpjj9K/2gP8k+fU 0Z5L/ULiaW5WC3N8VzPIv71Bx86geuKpywTaFFGskiTLco7h4GwYsHA3LjPPX8KqMU9DNvqynpDy zXt68UpkQ22yS4XJALY+UH2G4EVI0hxBFaI9x9oyQ/lnccHoBV8iuVF8rJ7uK0+zl7SJ7jy8ySIB +8kYclB2yMY4qBdP1C6tLW8mtZbaG6thJHEq5jhz1B9CCCDn0q0raIpz10P/0PzfsNJjWxaJkd02 7nYECXC989qSxsprMNJI4khkzHGrcBT2OfX0Ff7UH+Sbnpoc3JYK14kU+57dZgtzHIjYYDB4Pet5 Pt1xLcWhtlNtZRJc4Cj5VbAUD1HI/MUGTkluXY9F1q0h1TVNSddKsbS1R9N1C4vFtYpJHG/Gw8th Q2fQ9+xxov7SsZY7vVG+2tcuHVWXhgf4hjsetBPOjQlsklmn1hLuzt7i3VE+wmVkeYMcYC4IOBk5 JB4rbs5UvUJXaoSXyoQY/Lk38ZLN3X/PrTcWtDnc0tD/0fze1vUpLXU7FJYio4tFeINLHIw/jz27 Y6Vs3OqJa3GlyC1N3DDEWuhdKskUjYxjb+tf7WwTW5/j+Yh02ya1Gp2F/wDY9ZW8IGnmF9jwuBkq RwDkt37CpWs7uG8hN6qbSu6Py3VlIJxnIJ9OhqwL2r6M7pc2izBJI/lVgC6K+M4/WqCW7W1rbgEl 4LdYmcZCSYGMgdqrl15TOUk1ZGlbLcPaslnOYJDGSSF3NwCWArNt9Nh3PIXQFPnlVxjzPUk/j+lV 7MzP/9L87tXU2EFhBauh0yXM8sgU+YkuOUx3HQ5z/WsqPU2mSW3lDxQmZHIPSURggE46fePFf7bp JKyP8dy42lWcrRLDcNHayMWl8oYDY6DBPTPrVy4vriGRzI0TRLGsMJVApVVGME9z15/nTIclayKn mz3ot7WBGWFv3Y25aS5Ocgk9+35VYX+2dMe6trpUVfIa2ENxbJMYiehUMOCOx6+9Bi3ZXZWtBDCF +1H96V43J8rdqy4IzLdTWETZiuH2Jn5ShY4HX+ftWkF1Ic9LI//T/Pcad59lJpt28YcxmB5SowR7 dcdB0NVre2TTlMMbRQtZxhLSQRmQSDpzn+7/AEr/AHBW5/jHNq1jOvJr3y3NxNNIso3R3BiEcTkH BC44/nzVnTNRsrZo/tbu8jELDEEz5jemB2re1jMguLPUb25llXYqowOz7rhewC/hXqfg/XLaxsLa O/Sdbma7FtCkgLbRnaMr1APHtz2q6e5zVle6PsD9n+HUNJ+KvheeErLYTaikV6vmboQm4OCAOpyB z7V/cN+z6pf4aeGypUwtp0bKFOSjBMPn8RX8OfS7h72Dl5L9T/Qb6JMubhHGw7Tf6f5n/9T+hD/g sZoceofD+9nkdSP7AuIUMiB0UrIm3C/UjkV/KreRpJpuk/YPMV44FRl/h+VQB9Ohr/T76KtSUvD3 2fRT/O5/lV9JmEYeJmLl3ivyJtPtr2XT7iOOSY3VwzboFBUtjsfrjOazLWDVI2kkvIhHhgoeR95G 3sDX9TU+p/NFRpMNYae6ZVmmk8y1VWhjK4RVYfzI71JefbZrG3cXEf2ZUWL7MZdjHnk7PrzW9Pex xSasZMikn7O0bhiCPkGT9KSGcRW0iMzO0alYgq5RWOf61vHSSMZNXuf/1fj6ygUXKTXCsY3O6U45 GOlaNx5a3Pm26tIjcr8uG3DPT8a/34P+fao01cvwMkMpbUlSBLxTPHAjgluSCcDPcVSS9uZYNSd0 R4GYw2sW0ARqMAE4+hI+tBgYsU0YjKTxKQGCkquGOT7U1VaHLxjkfcz1pgaMU17eRmJW8k4P73Gw Djv/AIVFcIkMUWHWYhf3zqMbG6YpxaT1M5rU/9b5DtNLvo/MuhtjgIGRuCuQTwMZyfyqK8a4s50g WOTYyiRieQM84/Wv+gA/55m7K5FLdxIF/dkOOc9j+FWLOWSWJ7meJVYXeVIbMjqOc49D/Sgzg3ew lzPA8rjyymQGjx91jnkVelliDoyLlfKUNtGBkKAf1BoCbu7FdWlmkUwkgqdqhvlB7GtG8F08EKji G3XAVTlUJ+8R9SKDDnZ//9f5PhlCKScs5G0leCaiVbxxvLiNEGSpOWbnAIr/AKAD/nXKsrneqTJI WyB8oJ4PHFOnQrLJAucKFLDaQM4/+vQKTdrjUCyo8e8RHGFYjODzj+VN8uWJBEGJD4BGeuK0i0kr mA7eYRhyAgH3ugGPWmTu25MHKbQwK98jP9a0E3bVn//Q+N7WCXzGaOFnj3YeTbwn1q+G2GWJRw3A LDkV/wBBB/zlc7voSLYsnlOJFZypcoDgpjPB/Ki4LFAyxHrgsc7Wx70ApvqOtbyBWBuI98cCnyow 23k8cH64qo11JdS+ZN5hYjaWcliAOAKaV3YrnRSeWaOcGxVV2tzvTcp69q30uJG2CRF/dLlFwCM5 z/PtWyVlYIzu7M//0fkZY0jkne4dt20vDCkYyDg4+g6VTsri4CgXCBZDwzIOMelf9CB/znlhEtI5 riQrJ8yfuwrAqX9x6delSQoQjMmFkxkZ6e9ADmLgCZQqBuoX19ai3RswZfldTlj0yaDKfxEpAufm bKOrYLr1YUlxbBkj2Fiqep3MfrQQf//S+QQjb1WRfkU8J3z71dkYRMA67RgbR61/0IH/ADj7AY18 xTd44HmRKvJXI+XNQyzO7lED/KOo4BoOdabFTzHLFGGB0Ge9XBK87DbEqrCgT0zgdfxOT+NBrzq5 N5m5VGWRwSGweCMYqK3WETLuk2FJN+1496vg5FA1JPRH/9P5evkUM0zJuXj7nHHQ4/KqQ2gIsCSS g8Fm+9jnkiv+hA/5xyxFa4B2ZSHdvKn19f51XmEsnmRIx2hcnnHSgFpsR2chjz5gZhg4461LIBcR +dFGc9weMVMVyspu6HvH9ot4iW8r7MC7KP8Al4OcAH6VFMAIhKpPmdNoP9KykvfbN6UkouJ//9T5 Xhaafy0nDZJxzwSKpzFbVntwWZ0Jz/EpNf8AQTJO1j/nOg0SR3d15WZI1LDAZ0QRRoBgD5Rx+J61 oW1zJMqQLNtYN8nIHPFaRirajHG5ECyQOnmShsbj9xRjoPeq9vLjzFkfywxLeYxJUcdO5qnswLbW d9/Z8GpxSWbWd2WWICdftD7W2lgvPGcj8KyrpRiJjkOGwe6/Wop7lSkuVI//1flHz51gmJZgAg2S bQ5j5B4yPYjirwkW7tIHeaGFZTt3sh3QnIALgD8cDtX/AEIH/OY59inJps0NxHBdyFzG+4PEwVZF PIKn0Ix+daO9reQqr+efLADrnKj+6fpUSi2y1L3bMqM6Bwz4XnBPenecrPtKyFSPlYj5DjtmlFOM tSKsua12Und/M+TIwcAdM1ZkdjGGYEPgD2rS3Qwe/wDXmf/W+VlIVSGG5hHnjmqaOrNgq7IeSB8r V/0IH/OLGV7iwQG6eSKS4S1RVOJZw7RcdsKCefpT7U+c0sSh1hiOxZSm2OQjrg1pBFFkxkRyHLB4 xmMhcg1PIyzwWs+/96YwHO3aR6f596qKs2U3ciukV5Y3jJYBAJEIBDN6iq8ka/PK5+f0AwAfpSkl yjg7Ox//1/kuKWURuWXPOVzzyPWrPnu0LNI2Hxwem0V/0HuHRn/OlGdtCuIVfyrpfvoMMOobnrVm M+bK4k4X73y9ErWmjCo7s1dMgEhnZoZZYo1yzKufKGcbie3NZzlvMkGwtGDgOwwfbitEraFXTWhV aRnLRBeg44qCNPKkSUk46Mp61ko+/cvmtFo//9D5FuN7OggYxgMC5A4YdxUiahdb1t5EXyUYFWCj e/rz1x0/Kv8AoYP+ccZskeZ3yE5yBnAqdWlCkg5I+X2FK2rKjJx2JEnaJ0WZIvKRS24oNxPbn/Gm zvcR3ETlWKycqoXG8exx7UxN3Zf+2ErsCFC3G1vvVX8uRGKlduOSpHQUmrqwRfK7n//R+SfNdbg7 OnQ5q80IG13A5HNf9DkUnHU/5xyhOZW2xwoVjVwC3QEZGcVPFNG4lgMLB0GQxHDD2PtQlbmQD7O8 iSG6hb/WuAqNzuQZyQKqRiLckaDYoG0yE/d+pqKStoaSaa0NKNIFV3ZvOYqY1kU4Cmq9sNjOGPJ4 Dd61l09TM//S+UmtSXBLbh/tc/pUAt3hlygJQ8n0Ff8AQ+tj/nFj19Q5LtHktkYC/wANTxRzRO0Z jRsoMMQD/n/69MrbcScyxW5jCJ87hmbHzd+B7c1StopC7SK+GU/c/wA/55oE2kXI3ke7htFUhp3A aRhwBkAjPar14Ly1uGQQSLCrbUkdcLIP/wBVJq+gudXsf//T+WTvbMsh2MowD2/z0qujhpFZnkG3 O1VJ2E+4r/oZluz/AJvyeY3Fx5paTJc55GFzUUTzfZzbNym/eR6GsnFqVzRyThYjimjikIkyoHAB /iNNd2k3+UWRjyGWtDCbsrEyzXLwtveSRl/vDn8MVJZ2zyiRpWcExlkAHGevPtjNFtbmfSx//9T5 VhAWVd2HOdo7mrzLC7JG0UmWk2OyELtHr+Ff9DSS5j/m5jJxGXsaoI4YgDHGhUvjLv6E/rUFqESI xMuYycn0rV7MpTfUtSwW0EdpLaStL5hbz0xjySp4HvmomuBNLnbgrwQO+KwKcuaSaFl5IBQgBcg7 ce1OhmuI5YUtZ2KyjFwrfKirz/8AWpNaWLWjR//V+Y3XfO6XETFAc/e2kjnkGpLS2Ma3Nwk6wLGP 9HIyCxA5Ff8AQlyM/wCcWVTmi0MSR9zBUEks3yD5ckn2A703yp1wXUxqx4fGAcdcGq5LGSbSsRvt ghkEfmTu0nmFpTuct9a0I5Y7hIorp2jwuGdRu2f5NZyir2NIz5YNEEcflXU1vbzLc5xukjBxggHv 9cUjRi0bKSIfN5Zl7ex96SSWxE5czuf/1vmvc3X5eO/rTtkch3EBW24Oehr/AKELXVj/AJvxkUaH PIJ6AEVTljEVxxGQJOXYfcPahK2hNRtpXAQeZKDuygG1ItuST61HhxIzPDIRGdreoXOPwqlF31RE muVIjaaNJZDGTGhO0ITnHb860LOSSPLF8IoLBj2qlC0inK0bJn//1/l1yZHkmfgyOXYkcsSetKLN ruKTa6qy/dfgg/UV/wBDB/zeqSZnRx+RI0O75Oo28KTU0rSXCrGZCdpwA1BQ1oTGmd2SOGU9AKQw QvACdwSE7iqcHA5qXFN3LU7KxJPcx3EisI1jjEaxqEGAAoAGfyzUMkQCAiQ9cjbyama2SCMrPU// 0PmK332pilbLcghSMnFVb2Yec08ChNzZVBnav51/0IH/ADg33LsdxdTWzxM7EN27DHpSCOVYTwDI R261NmpXLjJJWZEqtJhLg7QnzLngcVrRXk08AsXYPAAdrFB+6+h9aXK+e44TXK0zN8z7HtREe5If EkhUKMZPapZdQWNZz5KqjxhDNIgZlHUhfT/61WZN3Z//0fmBrqFlVN0cZ8ssgdcSSYxnH86qRIZm Lckdz09a/wCg9rW5/wA4sHpYdvWEMifeJ5zVRU3lmHMp4xjtUShbVFXsQrHdRE4gIhcEmUHgnOMV K9vKsRGzfuOQ45K9azt0FzLuTxNdw/Z3mYyRx5UBcJj/ADxSreSrIfIXaxPGRx+VKKsrEzaaP//S +WYHnlt3S6dpXLHPmDA54IFPsoWTzlQkMU2oo+6MHpX/AEATi29T/nJpy5UMntJIihYNvddzgnIQ 9xUQCTDB+8rcA9qz5LNWHz7pjpTIEby3+Yfw5xux2qeO4uXs4ZJLYx3UbbgUlzt543Docf1pzWmh BciuTM/m3TliT84XCmqs6b5WSNy0YII4rGUb6M6ac1Fan//T+XXhmRW2jMca5xnB/CpY50i3ZiSW 3Mfl4ZSMsR6D0/pX+/CT6H/Oe31KHnBZ9ioxVccDIFOlDMwi55bdjPANDi7ApJPcuLZvFs37FiIy 7kZZf61QZgH+VSZZPmikxgbe/wDT8qShroXKqmrMkdo3Ch8K/TLdKsJYy7PMRC6gbiyfMqj39Otd JzJpXR//1PlK4HlupHyDOODio5L6eMBoYyTnYeMk54r/AH9ULas/5yG9R8UkkbK7xrIVGXxnaOKs 6lO87QymKNQUCAQW6wDHvtAyfc81YhLaW3hRt0JBJ52HA2+g9Kng1Oa13qjSRwzLiRA37tu3zL3/ ACoAYVtpXBgG50GS6k7XJHP4A5qnKk7SOSEQj7xIwtPS3mB//9X5jjv5rVIxZuHKLljjo3sKg1Bb lrdZ5oFZpfm82H5fLORnd7H0/wDr5/6AD/nHMqNjtkV2Ax82SMBQKfC6XLKHGEXgSBeB7mgqDSep KZsvGgUKkMv3iuUlX0IqWUSTYitrcFW5Lk7SoA7dqC5SXLoZn2eYvKssbFUGQcYK9qjhs7iRpIfm DYyoAye1AovU/9b5HgJEDWs6Mz+ZlWU/JtHqvrn3oaBZJBGmVOMg461/0AH/ADnk5yBtJO4HGe1V kZ4pBkAnOBn5uaAHXm6KaMrjcQCGUY5IyRj9KtpeeXbSGa2U3k8p2sD5cKL2wigDPX26ceqaXUCt Jdrbwec8flSq+35sEP6ED/GtC0JvB58rQRqEDNKsQRI8juABz1/KspWvoB//1/lWc232VWt5YZsO VYKcT5HqvYVR+0QAK5AMijDRt0Nf78H/ADpwSasyjcztLJG7grDjHlxjOT2rasba5eBbiWJTbqCq uTjp/k0GlraDY1cs4cZiL5jOMFe3XuK14jbxO8V22E8vIbHOewoMHozMcRSMRF8sStyD1PvT/JgZ o42uWWWV/LgiKn979D2/GplZbh1uf//Q+S3iVbpkd3j2cAqc7jxmrkSQASS8GRBhN4wceue3QflX ++kLan/OpKVtEVHjYhZZ4nheQZiD428eh6VMb+QxLDblzMhw52/Iy9se/WnGyehHO73K0cNzKxCK S3Uov3uOtLLEjwiOWFWQtliVG4Ee/UetRP4jbbYrsVMqecheIvyy9VUdfbPtWrbagkCn7ESBJlJI JY8gL0/yRUlqTW5//9H5WMTyxRpFHHGi5OFwD61Rlhj8qWC6toZllABEnzYwwYEDPXjvX++B/wA7 yaexajtUWVLhB5UR5KAkhPz7VauXW5QxmMLJGMRAqT5vPY0mr6D2Mjy7i2cxzQuhPJRl28fSrsUa uQqxqGbjzCANn+FYtWdilJouXFtLY2rm1uFMbLuldD949CKZalNLtftNwYnjugEj3J80jHB2g9iM 80i+b3bn/9L5WOnXbW6XsS53z4hCYd5B34Hvx+NTW8+YTIsRVWfZISpG8r1r/eg/55yzeW+i3MaC xhkivFiDzSMNgLdCPfpWW1tfwtbLb+c0jsQm1GAYg/dB6EnPQUAIGnQu2ya0vBIVk3ZVwMc/nn+d Rf2akXmXMuCkcYdmPfJAx+ZrKas7mtPRGjYCK5ZrNjBBbywsfPmbaQ3bHHHeo4tOlS0uZ4i9zHbY Enkx5UknA57ZrGa0OxPlZ//T+V7a6nWG5L2S7imQ7D5oAOrAf5xV+xCy2UY05rmc5P2kbOd+eQgB OQODX+6k11P8BsNK1RWPqn9mLT7q8+Mng6FhObO2D3F0jfLDvYLBGxX1/ekf8Cr+3j4PxL/wg2iT ANF5tpExXkDaI0AP5V/nd9Lpf8LmF13ij/VD6IVS/BFWNtpS/Nv9T+fL/gtBqVo1lJJ5lulxBdWE KJLmSW4YzXEi7EHXkRZ4+vBNfzl67LPHp895bNHA5sHbzJ8k/MAAY0wQScnqcD3r+hPo50pU/Dil fu7fdE/mP6Qs4VPFWry/3b+t2fij8cpLhvGtxul2iISSMEGFmLFRnHYjbzj+leGvcW80hhcBBtwC wyHPpX8KeN83Pj/H/wCL9D/QPwwjy8HYJf3Ef//U/kbIRXYJ8u3hh6/SobJWvZ7lgk6pb/u95QhX OMgDP865ypWvoVbZpnZhN+8lgOw7uoGTjii6iuFUx/2c10Y8XAGMZx3xWdToXT2LUkckEG9kUh8A 99h9KnhXb++aJM7RkDq/YD8KyaT3LJrGzCG5nP8AdMgAPCnrjH+elQyGVkZ2QCNeOvJ/CspR5WKW iP/V/kHnCbXlJKBR82funHSq1xfpHHZSRKzLLlZN3y4I44FeM1dWN46osK1uUVlAZnbknG7PpUE3 mMksksYMcYzhTuOB6j+lNKysaSd7IjF1IsUcsZTyZBgHHJH0q9JbxRNHNFlfNhEhHXJx2rGSsx0+ xVmt3mhQkrH8+Sd3zH8KY0YSBY9+JA5/g6jHY1JvBpbn/9b+PFYyWkaSPzGMflqWzlPce9Ot7OTf gF1KfOMggfhXgxjzHrOSS0JZJJeWXdsXlnUcLj1pTNDFGzidvNuE2ggZxjr/AJNSKD0sReY15C9u ib1K/vWI+YY9+1ZNncxwttkt3XZMVKkdQD/I1vFWVmOWkTqHvLO4gV4GdQrYWLGSpz3qrL5ySFJW liBQShDkbgR1xUz2MT//1/47bK1/dEr9oY+c2XmwrYyeMenp+FTRTmK6dHQso4G77h+hr589Az54 XkuZnkY+XIR5ceeFwOoHWpzYyXYTDY8hMFjxn2NJNPYiTs0OFpNAjNh2A43EcE0wSzwquDIQxxtX 9e/SmRze9zDrpXVYxHONpb95E3Qgg01kgsolmdvlPLSA56+1BstT/9D+PqB9sIeQOUlb93xk+xq+ ska/KQBJuBRvQ14cbWsz0CheSX8k0jNPJLF5f7wOcnOc5B/pWbasyw3MirsMK7jjLGRc9Avr1P4V D0djeyWg7BjKbBhJANxHPHWlmjMR3xr+9UDcD93FVGVtGO1tCz/aot4C2WL42+XGMuc+mfzqKS7M 0KxbWbeQD82So9TUAf/R/jplKW0Uo80hUjDOF68c9K11isLhbW+t7uS5d7ZYTFOOISM5C+1fN/bs ewRXEEwhlihcjeQxRTwSPT/PemWlq5PmzgmVgACRhsD1puOt0NK7sXfKUOVc4jYjcegSqcM6w3fk tF5quTscnpj3olujWMVEpNFaaVczy2KSJcXJEtxu3MvU+vA6ngVddJ55AshIBhDKWGAcjII/OpUn cbV1Y//S/j6sIFgLuUWWRDuxuwox3reWO0nS5nLIrRxBzGWPrj5R/P6V8/sexa+hHZ3umwXCQ3hk tY5urR25miIHfsM/jToHtRqGoiOEXdlcqIY/Pi2vIQeSq9hjFa0tzKvG10ffX7Mtpp3hu3lazt7b y4w0djAYxJLPLP5TFlLZ2sNpO4ngsAK/cb9h3TpNX+N3hf7PC8U2nwx6hJOIt9q7o+7yyxHPIJx0 wK/trgySwfhBiKj2VOT/AAP5ZjTeJ8ZKNNb+0X5o/tq8LvGnw40y7wRJdaQtxeLt2iN1iG4Be3zD Nfx7/wDBWl5L74t28d/F9odXvrtFjl5Bl8hFfYDkgeUw56A1+Y/RtSfGFWT3akvzP1z6RsnHhBrs 1c//0/xK+PXia4sPCMkF1AZRblh5csvmxKmwnaIz0ztPt0r8Vdd1mzuxLb2ai1ifFxPEIx1IwFBH 6nvX9ifSOly0cJT82fzv4Cxtgq0/Q5KwsN8fmKAzBi+0H5gBWzFdxQSq3lESAbCDzzX8g1NU2f0Q dFqFul21kIXBKQgSyOuOeuFHoOn51cRlVDEgLLCMSSj7qkdRXk1lujoLOinHnoZH+w3EokZ0ky6k E8A9ce1dnbW/k3thLbyOyzTeUg3E7zjdgqOvANeTWWlzamtEj//U/lG87bYkXNo5kklWGLywS456 7PTp9Kvaf4d1S6uZluTI1q0a/ZZYP9aDg5BHYjg18M9mewX7vRbz7b/ol1PPp8Nuitbz26+ck4+9 ICDyDzx/9erU8sN7p93p4ckXkZtZpYfklVe4B7dqwMGrOxd0rSrGwsZLQagZJLRFjt0mJYypjGG9 CMd+tQtqVzpDE7WidMSiR4srhugUY9MH6EU7gwstV/tqR5oUkdre4Iu5Cdj5xnIGOlbkdur2rnzF nieQ5Ukbhg9KprVIiHxL1P/V/i/NnfyWTpFFF5sw3Q3kk5aawBJ3hOcc46EEcdqqzwXDNbmW6uHe EgmQt87he30615s9I2OJw95pHULqkUagsXEaqNx7cDnNVf8AhJrIwLcNHM6yblgaJN6MQDjJ7c4z 6VjbodMYxaRjw3E+vR+aHSIiLzBHhtgbOCjd89fyrU8lUYrCWhkSHcxQEJjGDig0XkWtBsreUzBY VmTb5s8cr+SrgdgfU1sQahZWmkzxXn2jQ4dRumt3t7HTftUl8EY7Q7DJwcVpTRundXR//9b+NPVL 7+z3tba3t7qTT7mXDuzCO6jB6fKR3PUY4966GN8QabJ5YKJuXdAoWV85J80deMj+lYU+hs5JGRFp 0thr76xa3d3BFKHWe0ST9xKrgArjqO+fXNdL4h1eOHSLi3e1e5WeAQwzLnMAY84x3xnH1rspbhdO LZ4F4mtlSJVsZXAMIdYmT5wVHzIx9/X3rO0Ca4bzHZE2wRgrEx2DcCMHPrkDAFerRdqkPVfoefVa 5JejP2s/Zb1tdR8EiMwraahp3h62tmvd7RS3iSGGQkoe6ksuR1CrX7+f8ErDqPh74weHrq31Ibnj lkfhGkWe4lV1jJ7giI5+or++cXJVvB7ma/5cpf8Aktj+VeEo+z8YI00/tt/c7n//1/7hrA299oNn Feu4inskF9/Cy4XD/Q8V/GN/wVQ0bTNK+O2o+Zez2V1qjX8VvYI6+VeLa3EWXz/eyQT65NfvP0c6 sqfiL7OPVSPx/wCk7Tj/AKrQb35kfj/d2tpbXunwXRujppmGy7ljaZI36MWI470+/vLe2vilq63M MTDYEjKxkjkbgfw4xX+j9OfU/wA/K0PcVzPk1q61K9vbXT5Zbq9t7dZLvMPnIAegfjHBC/pTWg8j TFkuzdRT70uI4IJMRCZW+UsB17gfWt7ob91WL95cyy6Ylpq1po81lcxj7D5MUcuowygjLykAsM9O owPpWUFi2KiFYnjUJgDcWA9KqNk9TNSaP//Q/MSO7mvobWwsp1ult5WFvZpjMBAzIo7g5BO085NZ Fq1vcC/kCPGsUvmsXHlLIx4fcGAbIxjFf7S+60f5O86IUuItWL2zArJatnezBWdeo+X07VkXIuVu UgAkt3YiONhESig8Z6cikoptolz7HQtp00NqJUke5iWQRTBWEUZJ43sp5wME47U/Zq/h4BYbeOdN Sj2RhZQd6ZwQhGeuQOlOUUomV9bFTzbo3FtLPa/YS0hHm3Em+Iheozjj05q79siuktzcWB8+0vGn ikV/lmTACjp7E8561kM//9H8tH1NprGVLuxiieWUgggNcKEY7drDsw64qgt1banBD9pt7iAf8exM atFvZT03Yx06+xr/AGgP8l7dC/I13dXNr9ouV1C/mh+zQRR532yRfIivwBjAGApPX1rUtrW7lCx3 S+SYmPmLKpVsDPAFAFS4+26pqFz5r21laRwRx2sCuwvLsrxJjAwD3x6Dr2rTmj/s2WPybW6soLuN fLhuZmnVwoALrkAfNnPA/pRboRN6EstwdMQTWtwDcTQZKSpuVVJ6EVz/AJsWpNP9qgR7qRFEMqOQ qlWzkD86DI//0vzTOn2kggimu3ciMFBCvLNj7p9MZ5+lVk0qDTZ0aKQ3DY+cTgDaWJH44yMe+K/2 gP8AI2Tsguw95uMMiLLERGJdwLx4Iz/L9BSa1tupzDbSNwyRySSriNvl5P8A9YZraMbbmT1dySKR rKw+ww+Wsgm8ySZQCGxwAPUH+tTST/2gBMiNF9mQBzbxYQAcZI7Z7+9UVB62Nj7FDa2tomlSJcxe WJbiSWMqYgWO8H354PSs7Ukv4f7NXT52uI7q5IWFSRHH/fDj8vzFBUpW0P/T/Nk219ciKSORHeKX y3gjmx9eM81cvI9Ws7izuLG9jNuWEd1YywpcRr1+fkcN2B9q/wBqD/IlybVjOub1GSWeMGeeKbyX hPDuQ2Dj6dc+1aMEIWaQwXBE0kQ83gr5Q9CO+MCixnKTjsO1W2WSK3Sb/T7NuSLiPcpbA4Ibg9+O lRRtcRvDc6pcRz2jssNnbRR7Xs0RcAY6YPb6GqirsjnZcvtPtLvT5r21u7ZQj/JazFlu5CCPu4GO +eSOlY1ncTx20yrKYVfNuk5tzJHA+N2S2OD+vWtrHPzs/9T88bNLfVjYwATpdXD+T57jNkGBGG3d gffpiquqPFbXZsXIkMMmHnjbMKgZGc9xxmv9sLWP8eedvYvWNhMhTUfMkUPGRACMJMuMHmucvrS9 uLou0k0e2NtqqcKFyBmgTld2Z09vHNHpDtJdJJcNEWkDMDcOF4y3GMkD8qo2l001m4aJQjKV83gm HvnFNfEhFcNBabjZTySXDJguCQi5GCFHFW7V/KQmSHzpZUCZHCg+pH41uB//1fzgma88yNprcy2M T5kjJKsp6fL6d6sXtnbQ6XdTwRySui+YBku8YLc/kK/24P8AHKcuhg3VvPaWFqYLiVxcMUuC74lt 2IyuF/un17Y/Gugto7NdFEPkSSG1ZjdXMsvmxymTG1VXGQBtbnn71Bjzoqrptv51neWPmxTWds6y RQSFYdud27b2wFXpjpRLrN5qVwBeSM0p+/Iq5dtowCefYUGcpdWJGZ2uQbmEm0CErMxG5m5XG3r7 5pPN0tFk0uzkkmvI/nM0oBk9fm+meM9hWtPYzc+x/9b85oFb7MA8375OhzjJ+lCwagbczX6OnmOU tg0fl+Yo7j1zkciv9wY7o/xfKE0dygUSwu0HbPKpnHJ9Kmgf7DLDJdBJBJkRrGv+kR4xtIzW5PMt Eatpc3MFxetdJJtADx3J5VlI6HPfIrr/AAnNb31wZ5kRmDFIvMT5ht5BHvmtKekjKtZK59SfBTVD pvxC8FxQ3NyUv9aiuPLS3MsIZig3b8cYXGBnB54r+5P9lu6uJvhl4cWbJjfTQ0TEbS20KhJHrkn8 q/ib6XdP/Z8HP+up/fP0QqvNw5mFPtP9Ef/X/pP/AOCt+mPdfCbxCslvC9q3h24lE8kgEluUaKUl fTmP9a/ktV4rPR4lESybLWNsxHfhmC559s1/pt9E6fPwHOHad/zP8rfpRxdPxIrza3ivwMaJ9Qnl xau0UjDC7H8t8GjUbTWrp7hL29t4NOt4keONZCk0j7QG4A5yRnrxnpX9XQR/LVSpqWIIxf6eWLxf aLaIQqwI3bUUBS3foAPwrm7eFpTcmUmVVQKjMxwpz1HbtW9Pc5pT7lqCeTS7pJblWkhYYdVIyR04 Jpkk1jdTbyDH5sm1UVep564raO6MZTuj/9D5Qlu4f30T+YJQdoDDc7nPLE/n71csbm1thEl/HK0d yQitGuZYs9wMdq/34P8AnylK+iM+6+zw3CG63SwpKVimVfnKsQPw6VpWdvaPHPNKxSDlFiVfmuMD IJ9OcUEGKqjEyBfvnJAXABHTFV3lij8mINulkO0/LwuO9AuaPc0fMtoha2xeSMyMEmZvnDnPBGBn vjFM1PTrq3nuLSCFkEpWWG4VT+8DKACEP580GUndn//R+SbWVgitdzyyhVWJifnxggbvwrWlRHWQ 20wlQjb5jgEkA/p2r/f2LVrH/PFKV9DGmsWWUjyQ4IBjkDghvoM5/OnOhtIjcFC+wcxoNzfUCrJT s7ogxbSKkwJd2O7BG0r7Yq5GkzMPLUKyjO3bkkfT8KCZOyuKlrf3UxjjhJfHAjTG0etaVzaXVvF9 mnkXHlZC5+Zse1Bgf//S+UbeBDB5+/HlyACLvIO4J7VLOsDASRM6yjgDdlR+Ff8AQAf8611sRsUj MMryebIrCRyPvcH/AOt+tU5ZbjULmaZUJj84sZWG18HOAR+FBE2tiE2VxIskkQYiH55CqllRchcs ewyyjnuRXR6JaaWzuNWuTEzWspVxGXjQ7Pk5HQ7iPy+uGot7EK19TC82AWNxZXVtgvIq282csBkg 5788UxozCMMMBV+U4+UVuZTa2P/T+SLQSQxucuwuTvJz8rAdx2piLibK/vMMMj+df9BB/wA44l8k 8c8rqfMPDOYyDEgOOmOB17VWMc78xMduM7SflBoAswQGFm8wBpANxB5AxzVjCTq74IkJ3Zx7801e +gD7G1MzyojINi7iWOOgJxVcStEXaZN8aA5K9W64AFbgf//U+Sol3WzXDIwdxlAR0Hr+v6VF5qhA ijD4wWr/AKED/nMjNW1CNI0QKEOWJY+3c/zp8j7ImBOFI5cdVFApT6IBE8aRFgzROCI3OcHHXFVS ysWUIUQNgt0oMy8YrloWltIxJHDtM3OCoJxk0i+YWG08eh4FAbH/1fkVy4mJYY2tj8q0rgTXkcYh VC0YAGRj61/0IH/OFKV9CKO33TMk7r5mAFGcZwMVDtnt3ljD4Vhtc99vXH6UEEMVv9pZ0QOWVdyM PX3qW0hkRSruPMTiQAbeR7UAQO7rIWKMyq3UVYN1bmVI3Xc7n5PwoGnZ3P/W+TpZ7iWVoJE2JEOR jGR6mlWRoTuUERqMsVGTj2r/AKED/nB5pGjHJHcTpF5ri3yCzIAshXOeh4BxSzW6MslpayYWebC3 ErYljUH+I9OfagOaRH9nUr5IBG3gyHgEexqC3tTFdvaq8zWckDyJOWXKOOisPx/Kgam1uRyW3lwR STTk3CtslWPIj5xitBLaFRHv5GPmPWixoprof//X+Yrl1kYQwkbEPBPDGsaaJ0m2EEuDlsjpX/Qf ZH/OMqiTsjRETSWssa3BEl0VjaBV+RlUg5z2OQMVSMCxXUEYkGSN2FPzLg45q1BtaDjPszb1D7HB bxRxtJJcPzO5GABxgD6c1lv5TxCFWyxHXHNDg72Kc3bVleaWaOKG0BVERt0e0YOPT9M1JlkZS+GV lwB6Gmqfcz9otj//0PmCCKJzHG8vliV9mG+62TxVm+05ba8lt4ZoZbZAAkluSUcgc9a/6FuSJ/zh ufYwZWuI7gAq7KpC7lGRV/ybsr5tuyDBHmLIcHHfA9aXs0HO7DIo2aZDcxRskzeX5m750x6j3PHN WNQtTHciOKVTGiD5kP7vNRyO9iHJ9WVkUSHC4DrwWqWEG3ldLiZbtH5TanlGL/ZPrjiq9n5ib6M/ /9H5oleOZAsaqgwNwXoazuEcQqo8x8hT0UfWv+hVQS3P+b8peZJHK8EoBVWwJF+ZW+hro5o7htPS 4trVZreOaO3mZW2yR7+Bhe/c84+71qyuaSMS6nks8xqkhfeY5FPGwcg5z6VoSusFnA9qPtFzJHyk qfuUBxk59aB87I1kyqr5eJCOeKqmRSPmALKcNxQUpo//0vk9pQUdEK4PUEcihSpgIO3e67RkZAr/ AKGLJ7n/ADjc6S0ZKjQ20EUWclQA5PG4+36UomMZaSMABhgq3O4UWtsQ6juamn3yyGaOWMpuiwvk /IufemvNCu6MH7wwQRyapRbVxKbRWZI1dApCO/I3cZFUJAzzmPCum4LuHT3NX7NGnNdXZ//T+T7g qkzwBNiIQquTnzOBkj8apCSeOQkL905RhX/Q6oJbn/OE5tliO5jkZ/NjZZV6AfxU9JU+bIbGdu1R k5J4quVLoJSa0JzHGUjRo95Rt29uTx0qeWVyVwS4UY+YZxjtRZdg5pbFSR2aUygZ29famQ3qyO0c xwwPynsKOVdhXZ//1PlEA+d5RVWDHKEd6luUljDLJlmXgBecdq/6ILdD/nAuxkF80VtJEUDbyd2Y wzr9D1qIRzDa8i7Cy7o1xhip7n6/yosF33K6R53lQAwySv8AdxTc/uzuHy55I4NA+aQ+Foo9oz97 oPXrUskJMyIsgQE5ZhzigTbe5//V+U5EnEW2J14OCx7VL5vlWjrKQzqR8y9T7f59K/6Ioq7sf84F 2titbr5sjMVIXHyseMUt3dNAEAR2Zm2BlXgfX0q+RWsIVBdyjKHcOpQDJHFVo8QsQoJB+8Sck81m 01uBZEyN83BZTtPYrUj6hPJGzSBpIYcR5JJ2544/KkB//9b5bbE0aKJBgLngdz2NEFqszw2sMTvK OpX5nc88AV/0PtJqzP8Am/btuLJiJvlBAH3g1Vv3qv8ALgBz07VPs0ZSdyCSJm8wSLiXPCkVeiHl 2+fKBlC4IHUfSl7MzbS3JwfLXcQNuOV6U4yG4jKR5h3fddeT6U1DuRzs/9f5RlWOC4T96yyowZSr fKfrWnE2N7O3zvycjk5r/ofslsf82an3M5naAuxbeByFPJPsKswvvjVihQSJkqRhlyKYc/kWIvLj XZyR1+lUERRJK0bFsN8xPITtWc11BT11L4gvyfLeNliKbg7Lt69Mex5qCSyuraUEl1OOVI2gg96z tbQ1TfQ//9D5bvZLmTyhJjbFGEUjqRknn86jhQjADnb6HoK/6GD/AJt3Ky1ZbkCh0+bDqMqBUsRm uFdSjZXnAOenegabtoVvKeaRVwI41AGQcO557fSnMJIpCqru2nkN35oK53awrtG7pF89uZzzJGpO 38v8aiEVzazC0lR5ImcMsjJjIPRs+4oJuz//0fmX7ZFHNcWZRGMQKrlipY44IrOae9kmRreAkov7 wMcIoyBz+df9DB/zbllvtUTiR8BmG4qv3RTIP3zFZ5mLNJlFLYb1wP8ACgC95dtGwYuwGeSpywx6 CqeZ5ZJH3FQx2kHqR0NAeQos0SRSQHXPIY8GlYfZi2ws0bnGwnIGfSgD/9L5WYSFTGCcNz05FNjb 7KhRnIL8Lk9a/wChg/5tx8K5BJG5hzgdTSbdzErlcdRigB6eUyBnLljLsbKkBD059qDdNbzyqUXa 0ZTAUBOQVzigpSaKFvGr7kmcxqSQrgfXHFWIbKQ5iWVWEa5LFgGb0xQPnZ//0/meNGji+bLOQQM8 4qg6SqSHVdpOQCvI9wa/6F7I/wCbnmkbUUJFo0ikCKMDzHJA2k9MmqUJViHSUs6vgqvYf/X5qJpL YFJotzQpNGG3qpB2lccjHOabGyxxsEZdw+XGOTWY+djHdQoHTccvjoaptJ50piGCvG0Y60Bzs//U +WJltw0ccwUyAnyjj5wccgf4VZSPMZ8tgB0K4xiv+hA/5vFNPRmaYpUYmX75Py+/pVmOLYjSu/ly k7Y0C43dec0Fg0N2baUQzRxbSsjGQFuAw3AfUE1ZX5CDHHLLGRuZCdxH9KiaVrgPuJree4hEZARE AkDLsy3cY9qZO8NrumhgFy4OFi8zyl6jvg1kB//V+ami3qkgaNzKvmeXHuzDn+Ekgcj2yKpxR3Ia ZotkbI68SNtLDcMlfwzX/QQ0noz/AJvywq3Ey3azfKYsCJich+n+J/Ko0tkVVYDODliP8+1Yyjyk 86vYcLNZVZzuA8zJ56Een5VZmiKhnQAIV+6OSxHf9KkfMl1MNHd1DrGwLttWNlKnrjGK0riG7s5l W5tpbcugdFkjKAjpkZoLU2f/1vmT7VEX8uaUJlf4ecD3qrtMQaFHFxvf92cfJz0xX/QAf84an3LU zRu8MUAHmxRgSnGCWx8w/PNUZw28OuVdeORjOKBc7JWvJ3kiRFIdkCMGIKsfUelXTIl1NCLiREaM CMgKCYlz/d/E0C55FK9kto8qyDaw2+Y42n/61OtmltbSWFZCIp08o5++q5zwfXir5GHNI//X+VZ7 VWiURS7yOFBJLf8A16htrW7M3lSERqoLnzhjfjsPfiv+gFxaP+b8uTRSwSRxwBCrjMzMN35U9LpL e4a2kCS+ZFjbgHZnuKpQb3Gm0RXMccMYf7q7toLHqfT+VZs3nGT5QSoTPTINXyKxsndXLllcSQxe asSebGSzRkbsgd8VWn1VL+OcIw87d+8UReWVI7YwP0pcitYZ/9D5GshKv8JJIye2K0DqUsPlwXMJ ltEGGiLbGcHnr29c1/0Bckj/AJxyCEyxiMzQNHFOm4HHDA56HuOKkEMhSVbaNmCDe20Z2LxycfXr 71IFqWKF4IYSyBmh+YAYOfeoFWeCH5CcpwMnnH1oH0sZt3LcvHH5rOgc8BRjPrk1OksaSxQoZluf LBbc3zOD0I74xQEdGj//0fkJp5Flct5nz/IuB8nrz+VTRM6Ok4GRHyQeRX/QAf8AOeRT3T3LsUQI q5zsGP8AP/16EQLFJJIrl0XcnHegNhsckxeCTejbefLkXcgJ9fpin3a6jcSpKrwwYXAKQ/K3QAgZ 9jWdToBrBbC+sri2uYQt1DF5kE6sSzuOoxnAzzWLawNF5UJklEYkBeRvmIAPP9azA//S+Ut1i97I toj7WY8uBkD1JrOvLIPITFw27B9B7/zr/fg/50E2tioUlVY02DahIkJ79a1LR0iBSeR2j2ljg4Vc cj+lTK9tC1PubC3cEsG22tzKQBtGfv47g1SkkWYPJ5ZjYHayE9PwpQ2MyGOHeAeUwc5B6gGorhTM wkVj5sGBEF4OOBUzvewH/9P5JuI5Y1gZoiTL91s8Ng4P5cUvmSx20wMaTIMBw2Pl56/pX++KV9Ef 86Dd9xgkhuYYtglBhGDG0hZFPqo7DHaqUJvDdywxQShgvyyg7VHqPfihpoRaJaVQwkKtH8rleCT6 Vo2/2h4vLZYXiH7zbn9+2OMfjRrubp3VzFlkkL5MbRpv2FDn5SeKvBfLgdlUggZTjrSGf//U+RbW 4BZJ2DHy/vg8EjuKkkME8yXKl/J3/Mpbkj0r/fA/52E+Vl37dFcnYTHaxjEKs42xkjjP/wBanSRy 7Q0Di4ROA6AhSe+M8/n6VE21oblPdcymRCpeZIy2M5bgZ/pUNlcXcwBa2nc+Wf3cSbWBHr3rIC8N QS4t7e18n7OVDeexbeszFiRn0wMD8Kddzx/ZPsphDzRS70L8xqCFBI9DgcUG0UrI/9X5QS78tVji JVVOSw/hNX4tTjDGSVD5CxlVt0QL8x6tzX+9B/zziCaxmEsjCUdNtuCBJ71nFQtyZDHKIo2/dq5w yg0AbNs1myF7iXaHkC5IJbk4HH171QuY43kdFmk+zpLhAwzkeuM1nN9DaC90UwRFUEcUsojcb+dp Yd6NqQSwwW6y7ixMhkl+UgkYWsnotTpuj//W+dS1uqT2rRTLNcxYMhYCFMc49eo9ay9KurnTZEaB I/KL4ckZWQZ5x6H3r/daXws/wBw799H3H+xVp39v/HTQGW3klto286eTzMxwM/K7j7mEAA9K/td+ Htslh4M0pCpBhsFVlboFRFUcfRf1Nf5yfS4q34kwtLsl+h/qv9ESCjwBUq23k/zZ/MF/wWbngufG XhSxguXLQazDf3EsahjMIlyyA4wdpcDBHc1+GnjGZrrS71IWZIbXSzNqKybYvMRZAoMPrtyGKj0P 4/1D4DUvZeGmEfeLZ/J3jnU9r4uYhL+eK/I/Dn4t6lZah4p1UwzmXy9sLNsOEdSQcex+X8Qa8Hvb dCAIiu5WyXzxX+e3jLLn49x7/v8A6I/0b8PF7LhTBR/uI//X/khtUWSHzZPvE9MenH9Kyb621e+e E2d9PaQ2028RxbSki9wQRx68Vk42iBZLyYR3TYzHyppiPm46H36V2ekX+nnTWmllMlzCRboGhO+f OcsSe3bisKnQ0p72OS1C78qVkjQNHuy0Z6gc1JBdQ7N0sZ29lHNZmhOt3Ew+RGRWGDz19qi+0LJ+ 6CBXPXPTHtUySsTJe6z/0P5A9RlQ3VvAC7+XIHnQx7rcgdMn1qvfLBK21UVWLbhs+7GD2ArxzaHw op+W8aNIu8onBB4JxVm3uVmdfI8wrszIcEgDvmgolvY45Y1MYJKHJXp+FZltLKbiCWeObyY2KpBu /doSMZ+uP51M17o07M6i2hS6jdwNpBwiPwT+FSwwIYH89R5sZIAHQ1kkaxlc/9H+QaJPJeVpDkg4 Veopt1I8cA2Ns3sW3qM9B0rxYbHoGXLqs1vp80EMe9buRYZRt7Z6/hU8cCGPDHYka5+Vck/QUlCz HF8ruR6Rp6ahYXi3F9eWjQzMyTwQCJplBzsye3bIBzjrTWtxKHiik/eLxnHzEdKsqUk1ZFjTQlrb 7J4I1CznaTyznvn8jTdS1G5u7wFImkHkrFHKyHCgcfkOPyqJrS5ndI//0v4+ZEisrZriSaV5du2F EXKM5I4b8M1nxzPdiVQmfLQPKByyfWvnztj8GhmeXLHeCbJdVUrGZOqepFdAbm5tbNZSsbxyyYC8 7nIrPka6iqdCJr5rpSci3Rf9ZGW+RD/dGaiSZ5EzblZdnGGGfatETGNystmX2u7bxGxd2bllJz0H 44+laDWybLNGbzWYmTAOFiAB5Yf560GyVtD/0/45TK8U6okpljjc7uMKvsBWjK8Uc8I80iOTl2Kf MD349q+fPQJyt5eQtbq6EgFI2Hy7lJJ5I+p60/T7FFjljS4ck/uykw8t5Sp5AHpkcetBrGV1qVNU iNva291AVuFNyYXjicCS32jJLj057Z5qvbtDdRNKLgOPM2lUOPLK9Qf8KAc10I5Y4I5Hwwkyvyrj nj0NPsYd0nnPkIo/1Z4z9KCz/9T+P24t7a4iknhQSGAb5wR0C9c+1QWslpPFFLC0cUajexRSqAnq AK+fsexboPmnWJmaOVtw+6TzmnQ3DeVvD7pc4w/6UGyikWJWJi/eELkduAazoJAkgDIdgOPNA3FT Uz2RRqyT2ywF5lNwsg8uIKMCNvU1mSSTyKHlLvtGyM8/u17AVMEB/9X+Nu7lnhTEMM84LYlSMcge tdBplvhrOZ4i7zr5Dxh2wq54DDpn/Oa+fPb5eWSNC8UFDBL+7RHLqZE6AdefTir9iLltStrxbmKS LT442kChZBIuOAE9f8K0oL3kjOutGffX7P8AbTwb7id1aG8eObTk24fcgWRtwPTIz+Vf0If8Ez7i 8vfjTcCUtLpgmTVLS3ijX/RxiONlJ7cuBt9GNf2zlVFQ8F68Zdab/BXP5fyObl40U6i6VP8AgH9k MyRWfguW1cmBG077TcSHIALRb2Ue3IFfxPf8FN/EkqftG30mpvIjw6Rc+VLtBtixuoVSIkdyJFOP Qivz76MtHn4mqvqr/qfoX0lK/JwxGHeSP//W/BH9qDXYR4W8RXVxHa6SXEJFvGWlnuoyPLJQEYUl jwB+favyE8T6dYRIiaaiRuIvuRfNIg56n/PWv63+knUTr4Wl2uz8B8DabpZTUl6HCwXBtzhpJQ8X AK5Bz6V0FglzPcpcNyIgMBxnfX8mVJWVkfvamjqJGeRjhZleM5UohVRW7pd7ZyWyobaYTGMreK0g ZZnycFBjgYAzmvMrHRGV9GaywoLe4gii8gwruby8A5NdR4ZuLm3mtJrewuZ2iHnRzxReYlmQdody enX9K8qtrFm8H0P/1/5VtJuJFvmlvon1S+lLKgPylC2dpC9OM8+uK2F1W/0i8liumleA4ZRFBhrc n+HI6mviZpXaPW5kTyymaOK707US1x5xWaPcUIHuR35NLpz2ltHcYskEsx/fSEn5j13KexrlMnuS PDZSdZkdbgFHhBIePjufoe1RS3tklxBHEGktmjFuDMMkSDKnccnI4GKBGm2m2fhiAvI0jT6hcA+R sDEb8bACO3Pf061WkjkWFILJmhZrjdKpQjyl6nGfWqbWgofFbzP/0P41J5IntA1r5ilG8tox8v5i k0+180lGVxI42M7cBM9snpXmN+6mYVIvndx40Nre6QyXcgikuPLnhcK8apjBPvTp9P8AMv7TSrQo mhB9ruifvI26FxGOOlQnaVxE6WNloyzQySmaESHaxULJID3YDgH/AArKm1Kze5+yaW01zvjDee6f uQehXd7HPWiXxM0g3exTuXvVaeHTp9l/DamWYKuI4V5w2TwelXbHxHqkUcNst8bkonyq6hxux8zK Ox69Oma0grRND//R/jtstRSdIW1qz+0JIha2nEJ86Nzxlm/oelTT2jyXkSaVd7YflkkDhRHk8EM3 YD1rOC6gUJri5tZ5YyqXRil8uX7O3nIMHGVIzkfStCWF55AZLpmhZRi2VNoiGOc88nrXTS3BNcrZ 474sWGy1CERzyuzozBJI9sYAPUH8cYrntNniuLqISb8edsaCMbfM7Z969KnpODPOqPSSP2P/AGU4 zrXhae2MnnQWOkfbYEuNtleHyVggKbwMttBdgPav3I/4Jr6lZR/Gzw1bafPcQ2E1xHZ+SxaREvLa 5t5HdpMfxKzgdscV/fuXNV/B+N9f3X6I/lTKn9X8ZKf/AF8/M//S/uE8Lz/2r4T0/UnjDSXlqDNE 4wi8bWIPoRz+NfyA/wDBZbwDbWvxTTUYILpJrLVJba0miZrh40nELM2PRtnvgD61+4eAFb6t4lqK 2bkv0PyT6TWGlX4QjKP2ZxZ+MsCyXFgyNJNLHZyeYls0mPPPTKITjPr/ADrlNTvIprmVoreXTkaQ FLecAN8gAOD3Gc/ga/0mp6o/z7rtKGpV0SCHSo75opZVvtXvTNhEIt9vXZn8Bwfeuj1TVXl0/wCz iyFsst1HhW2zznYCCM++T0rdJJIwk77FSbSrG4gjeaa4snTDyMg+YqRwAvrzXLpZM6C6t7iVRG5Q B1wk3bk9ulbwj1ZJ/9P8wJ9ItItON0sjHXG2SwXcV3ttokz90x4PzZOeoPAz0xTpIIZZ49PlltVZ ozM10sm9NwQsASM8npj1Nf7T2Wx/kuYFidNcW+qRWbxym0VZJyWAuWBOWUHGAcDj2611Ngwu2Wco IiVG0OvAFCilsBHNdee4TUIIhbx4EsNshga6UHjGehYd8Vi39vP/AGuJp3fT3t3Wez05XMqBch1X PX7rA8+9DV1YhfG7l+6skv2nUNIltKoBjnbO1iPmI/HP6VHYWd2s1rYySG4M4MMEMZ2yxAD5eSMY PYfyrJxcSz//1Pyr1WKW7bZHORc2UgtZY2XBjxyAw+hrp1sJG0+00Tz47hbq9i1F0iOUhwNrZI5B 254r/aTkvFH+S5k7LfTtYmSObfHbyFVkT76gdCK021SC9WVLi4nWWSIiG6UAybwRtDAn061mBOjx Jb6jd2ZW9axP2czPGYnmYqpIjBGTjcOnce1c9YPqmpp9rvbaZAbpoLMuS0hCBeCOx+Y8e4oIlF20 O2ury2u7SNG0uzfVLKDaskQ8uS844STnHb8/xrmWguZba1mk02LRr2HMM9oCCFwTg9SOmOlOxkf/ 1fzDvhqGnQ27RSQNFIDKXkH+kMAcbVHTsc1JZ69e+XbolhFdl5xMPMtkc7h0Uuecf7OcV/tEk1Kx /kVNdShZQRHWhI8xtLaZG+1ROOIpCScD8eOfWtO5szM8XkuJJJZjGsceWXjkE+nQ1sQQ6nY3EUMc 7AvluY07hfvY+lLpQS5aWREnjh8opMAhLIDjnH1FBdPc3reOZtLmgAZbiVh5EvKmMA9CvcHpTLCO Wyligbc8kJJjZiSwY9xQW4pn/9b83ruwazvImhDLLJJvWOMfM5J5GO+c1Z+wwWDySyS3CvcDfLFI MrC+D8qjsOnWv9qD/ImUeUyo/sb6o8bxOIVUFZWcqrMwOenXB7H2p1nc+TfkyAtGHMKSHG7bn198 A1UWle5lNaGhfR3dwqfZZ42XzQWEmU8tQee3pUVxdW8dvLbNNHsWYJGYz5sz54OSOlVTOWTeqFsr ZYDI1yzfZSgTG7DdRgjrz/jViwgttFnuYLuSS80vVp1uDb3E4j28YRkHfj/IrQ5bs//X/PW6+yWU Lx2GyysYYzJbWrPna3Vju6nOOlY9rrEF+hAFoskCkttwZJSPc5I+lf7YH+N5eurjUNtu080YEkWL eFBgxqOenTnJrOV7qTEpeQfwMGyFVN3JP9BVKLYX1sac0tt5BMZ37l2b8YwM8g1BHJaPDLa3cDm3 ng2xtbyeSwcdC3qPYYPvWnLaVyuZ2aKEUEtqUIjdLRWMfnScgEfwnuTj+VaUdwQwWF1ePPmNL1PG cBT/APXqhNt7n//Q/PKeS5u4THac4O+bIJ56DP5/rWfp13/Zl3NFcm4mnu4fKa12FYFKMG3bsfgB nmv9uEr6H+Nc30NTWp9P1OKKO2sPs84wZrtP3TEAEFQOR6c+1N02SK2t7+1vTe29jexhIT5YMbOh 5DHqeGPTkbh61tyKxk9EYhtpNSuQIJINNtV+RYiWIIUdS3PXHT+VTadEEvFiJfDuIhtTcxJPGPrR ypGBtXmy2uprW+Jg8hvmjlQrIncEjHH/ANeswy6LG13LbRvJfXMSq9y+I269OmT+P9KaSWiJcoo/ /9H85pEt7S1R5CWecAKrZAOTyAen51ceVftSCR3YRx5hj3b4xnB69K/3Cirs/wAWnLdE9zqFvJG9 skJLk8yA5PQgqBWZNdx74Lq4ghb7FELePYn7xRzzjufetjO6NG5uDqNtZ28bC3i8zdcFV+ecZ43f QdPSuy0OOyglW3wsYAGJQBuGT1NXT3MsVN8h9I/DeO9s/EmhXcN8bOOPU7KFZgBtRTdwDaPQt7ep 96/uK/ZK1B774W6BI/MaWKQ2z7s5UYyPp0/Ov4y+l1TTy7CS/rqf3d9Dqq5ZRmVP+8vyR//S/qQ/ 4Kn6XdXfwc1B7aJGRbO4jmuZF3rGphJ2kdxk9K/jruD/AGbo9tG8UV0twkbJJb/6lN2G5PqOR9fz r/Sv6I0k+C8TFdJr8mf5b/S1g6fiAn0cP1My9SIrHc2RERR9vmNKI5n4HRevf8Pxpl7LbJb+TJcN czvEsj872ViOmfbn8q/r2x/Isp6sxYZZbaF3RGhEh8mSZlKl/wDZ5+tOUvb2E5VJLm2JHntGmRFu OBk/XFXT3MSKcxyrDb/OySRhZvObIGM8r6DFSwC3tXBjAyhC5xux24rZbmc30P/T+TtQizdpcY3+ bhjt6+1TzJPPiWKCRkiHllwhPPpX++0YtPVn/PeMs4WlRhdhWt0z1ba4fsBntVzUAkEdtFA8UjRB WlSF8hdw6Ad8dzVEyaswtUhmJjBVJZzgDBDIBycH/PSsd7ezdRPAbgvG5SRZVAVyD1Ug9DQY7bjo VLOjMyrtbIZuBGQauJefbcQ7C7tIsauZNvGcE/59KCJSSVkf/9T5mGixxGURy4hVN0u9t2PU/mag t5LB3+xw7gzLjcB8rECv9+4K9z/nebSWpE1i8cjYJZVHDZ578VDI2HMCvvkWLLEjoDkf41qRz9yC 3tYmnztLOilcKflqKEXMVw80e8IARyc8HgightvcvJezj5lkeMlcHyyQe4qgl025wr5/g+f7x6Z/ lQZTbvZH/9X5SHkeRNBGZBI4DBT/ABEEZx6etCCOG28yRZnL7lBCcKR71/0AH/OePtdOnntzdCNx kBoeNyt3xnp07VTEhDs2SG8zZIAMKpA4oAsQXUkc1yFZ1jlTZNt4jdcg4PbqoOPapy8EA8yTaY+u G+7W0PhQPRXKSQi6vraYTBYopVliJP7g7TkBuDlfWk+33M81wJo45WmDJJKygLHk9AOn/wCqqOc/ /9b5GMsscccartihj8pAPTnim2sMxkGwYjJyc/er/oIP+cc0JYow/wDrMKUwUA4U571FGIhFONy+ YEOxSCNx6dunr+FAFGKznMTlG3SkbiMnYh9M9cf41NNKbcRIMOcfOFBwv1rWCVrgV1DNJKYxIpCb pCmQu339qCwUAly+7gJ/jVgf/9f5BN+0cccM0u4SyBUQAkrk4GRV6WzVgCzrFKp5UjBH1r/oQP8A nHGGB4IoCSCLly0s5fMSgccD/PWlyoIGN6qcgDkNQBbS9CsbiUZhVDEV+6iemPTtRAlvhyoVgecP g0GcpW0RAySLJK0MhSKVVV4R/q22nr/L8qlurdmiAiVm/d+Y+xf9X9f0oJcnax//0PkDciB4pDli M5HJzWlYBo/3iXEgKoVKNjae+7pnP44r/oQP+b8qEz+cbveN8cu9GdcjIORkH+tTSSajPNNPPGkc UozlBjec88fhQBWkhmmiaKFW811IAQ7Sn+0fp1qpYm6thEt9J9omCCOaRRt3kcE9KANa6h2+WVkD LL0jCncuPX69voaakUU7QC3IzCcTP1ZfWgD/0flK+UgrDbgStMmXmV8+nHseuau2jyeWkc0KP5ab VG0A/UnvX/Qgf835FGkVtJKZIsiYl8q3KHpge1Om8qILNNIIQ6/u+cb89qAI2Z2RA8jJGDxjriqi Axu8gMhXOFByDQAxiEZgQVQtuYBepPetE3H7tvKLSx+XtGRtIOP6UAf/0vk1Q0kRYS7JQ+VVOZOD U63Dzl4lZvtMy+WzYBkbkcD68V/0KQXc/wCb8mhTy0IdvnQ8MKJY1CEoNzjktj5q0tYNtiART3Dm WdmKgeXGo4AA9qT7MwUiM/Puxg8ZoHd9S0Yk8hEuoVVx75K+mDVeWMGMBD8o4znmgltLRn//0/lT dJP5EcahBAQPNxlmx1JP4GtRoyyFYywIGd3O0mv+hg/5vHNdCkjuEeOQjKHdz3x0qOC52MZHbP8A DsYYX2NBLm2rIWGSaNnyUZXk3YIHy9BwalkLurxKcDduDjofagj1EsoUIl83zFZW3EqRgjpgfr+d WjFbyRl5PkVBknoxAoA//9T5chhhutlsk720Ehw8wO6RR7Hnmrg0uGJg32uedYhtQ3DLvx2+6Bn/ AOvX/Qwf83MZNPUoXFnbtKqmWSJD/Eq78e+KaYFQkQ3Mz7WVliJMfK8gkZx1+tBqmnsTxxC9mdL2 4EMojachz/rcY7/jWck0kZCBl+ThQfu8dqBkn2yUOreWowcHaM1C7SOWIXALc461pBXi0B//1fku KOSRxFEq5JyzPwAO9WhbfMobaAh/DNf9DTj71j/m/GXq5lVZk+VCCAo2571HPHC+BHISoIxxtNac ivcHorlm2kSInap6YGRTLkBZY2YgGYZC9T6cVVrAtVciS2Mkzs8h4GEOPu0s8aRoqCVlYnbu+7uP tQB//9b5KaHzGxKXLouFOST/AJ4pzAFBGmdwPORzX/RAf835UOVYk43DjOKsQgLA7kjJY4xzgdqA HpMhizvbzg/IAGxhjinrPK0eDF5PYux5f3x2oAq71tkk6uD6nOfxqr5GSspBCvyy55x6ZoA//9f5 eBt3aOaK38nYgWNckkDAzyfXFRy3Ba5wMKuOh5ya/wCiA/5vyCTZEQShZs5JxwKvxrHI6u7s4YAN 8uWQDjA/DFAGfdqu+RYEKgtzz8xppZRAR5RVuh3dRVW90As7VJN8k6uyRjCmPggmpPs0cjbkl4Xj LH7tSRN2R//Q+UEjYtsjk+Y/eGeDiqcqsvngvko2AM/e+lf9EUXZn/N7FtrUt2LzyRCJX+UtvKd+ BVmOdd8kGAVXlwy56DtTi7Jsob9oSF3ZUeSFkI2Rna+fqe1VkjLYkIOwHkVrYCVjbvJKq2xVHQKj BsMp9c9+h/Oq4tmRkUSH5X3Mn8LdetYyVnYD/9H5cjjhWEDdlw5Z8DOPYe3AqN2ZuIG244LY+YD2 r/ogP+bye1hxjle2eR3DBWCnoG5z/gaktCknyEFgBn0oMh9wEJctyUAxj+AD1plqgumCmdIM8+ZI GKcdsAd6DOfYZcMQVhxlTwx7mkgR4o3jjcrglgW+YrQZn//S+UpbZJSJN+JC3IXrWn5MlwsaQBPM U/Mz8Zr/AKID/mvC3gt5pSsg3NEcv+HXFVzG7XJSMt8p4yMdKAHThEKgZyeHwKjlkDwG1XMYZgSy 8E4oAsCa7hhCxzyyptCMhPykDpn6c1MswuyF3lXHBD8VDUeawH//0/mFreaZvLTOQeR1JApkMO+R o+Pk54r/AKGpW6H/ADXliUIqqjYLn7pHJX60qrJAhaPMrkcIDjPtUlRk46D5IXkVVk3RS8FQv3jn 0qFbS5DOJGbeP4ejEUGnMrXKwLI0hJPy9iM4qz9quHOWYttULHk5IA7CgFJPQ//U+bLSO3lR55kS NsE/vUDSM3Y98dP1qqZHt3kdgG3PhABgmv8AoYP+bcq+czylskEjGw8intBD8rNxKh3A+n0oJk2l oRqvzMd/U5Gfar8EuCcxK/8AtZ9KDNN81xLgpJAfJOJEkwyMdvHfFU0aFVCMzEjpnkk80FylbRH/ 1fmNfMKq3l7Q688A4PHFV5ljZ4vMQtgYG7gV/wBDB/zaRlfRirGqsCThkIIQHaWHf+lMkE0blvLK ITvUk9R2oLLkctxd+bGrRq1w3K4AUnJxgf4VVWznErR3UR+RcZPBJ7UAIbIJGyluev0qGO0dWMiS r8vVP4s/5zQB/9b5kjvTbzItztdZx8uPmx1xn06GnSiIuPNk2RnocZI/Cv8AoYP+bcgtw1/Fd2ys Y4FkWRg77TJtOPlGfc1ZL6fBcxACSJWwqhctjA5J/wA96mSurAH9o+cblbZEWESeWFZdz8d89RWe zTpcRoF+RzzI3QewrJq2jAsyK6NhlPPfsafb/Zct5m4PgqGj6g0gP//X+XXtkcmRn2spwMjk/Si1 CEyROz+WTncnBPoK/wChA/5tyXUntI1gRnDO7jYF6g54H+fSlkV5XiiZVj8tfnAGd/oRzQaxd0iN hsLfMRgYAPGabbyyw+YSxCuAAp6D3/WonsWPuordzC0QAZh+8cHKseKc1sloFLOtwCu/Cnr3x7Vk B//Q+alfzIMKPKdl3L3VD6fhVJy6tk7mcpgNnC5wP8K/6CD/AJvJStdFu0lklhkEsRQ7tmevT0P4 1C6mOQJuOFb5iOAfwrOp0Mi4QFzHExcE53Hilmt7ldsUSEs67+vOMZzisxsrPCSirtJeNfMyvDDH JOKqSSXNyiIDLMsA2qsjF2Rc+/agcXZn/9H5WMEYf51MZYY55x6f5960IbAi3idJVMgkO/I42+o/ z2r/AKAD/m/IxHbLNIkM4F3uDpEAS0ozgn2xgdaS+jla3aYhAyyAMM4lfrk49OP1FVyu2gFIeXN5 TB2G0YYZ5OK1lFsq+d9n82UR7EeN9hz6twc0QV2BUUJIkrSIZJEbI4yBUCz7w0dyOPMymw7Qq4// AF1sB//S+WY0iaOcQyFJs/uSfmUdev6dKaizi3MbzHNud25hgtkgkD29q/6CD/m/NGG4ieMKy5Yc YA+bjvWHctHBKzDh3fIJOWHtQA+5FwFikGTHIu3LcqKu28bi2MqsjNGSChbBIoKjLl0M6aSNnUke Wc/dHGaUJEdojiRXZsA/xOaDXmR//9P5KeN4XXMhSQHcBj9KsGJvLE8ys8YYKzDkDJ4/z7V/0EH/ ADjRd0WopIwohfEkMPyw9zEPRfb2qOSUxSZibCnjjvnjBrnGV2eMXCyLvbgZU8bTjn8Kknu5irxh VIIwG67R2x70AZiM6PFIzB1SUfu5FyrDPIx0rdlnhmY3bQwCdI/K8wIEwuAAo+mF49qAR//U+SpL gsEjVgYDLvk2qC+enBpglkeKSCIOvmHYGUZbqK/6AD/nPJzbR2wjZ3wRjeG+VyfpVubUFeGRJWjj jc5VVjCs3bHFBE9rEMFtbyhg8y2yNEzIxUszPjhcDseee1VGudyW0SRufs6+QXDFzJyeT71ElcqO yGzIYWMhcoMdCeTS+bcMkMQljURsGkeUffXPIHv1rIUpcuh//9X5Rtw8U01yIN8KgiVUOOPY8/nT 1vopolWK3RJDu3NuJLDjaMe3PP6ev+/B/wA5sXdamazhQ28tvJxtA4otxsO9SJBIpR4yudme/P50 NaWKN62uba2gWMBY2BP7xgfl9BgDNUIdzRPLNIpLuQ3GCR24/IUJW0Qrq9i6luEkRDI0UVxgvNNx HGvsAM/zqgsUJmlMcrHY2IxtIEgzj/69TJbDP//W+T7hjiNgyAwsco/32z/d9OlREiXaApEh/hHR vYj8q/32ikldH/OeX7eCCKyn3IfthkzCY3GwL3DD356HsKrpelZ7cmMmWIZmA4V8dBTdluA4MpMj NZyXMCxsWghYI/Q4JbB6dTn0pdNnUyb2UqhXA4+UYPTP40m00aRkkrM1ry4tLW0neC3SSaV8yNKB KmAMAKhHXOSefSsaNVuYEeMSMF/1h8shVrE0P//X+UlijhBkIB9VPQ1XGwDfGowj5MOMKRnnmv8A fA/51yzbFRLKEMUaypgq+GRPpnofpV+6jkREQvtXZz5bYxmk7dSovl3JLaTT4bRyUn+3oxJnR/ld SMKoGOOc555rPllLxqZFKozMI2I4OMEj9R+dYGqaexH5UEfkiLzA0n+t3ENtOe1S3FrGkSTPLukE xBjAPK470Fxk4n//0PlTbkBYbQqjycsqErk9yagu7eNCPMuY42PCIM/vD6DH9cV/vQf88612Eit4 sCVfMQkkyztkxcYwM/lx71qQzQ3ls0S3EETwEsXlB/e9Pl4BOf0oAh0+2+zyTXNzNvi8vAhCgqvI +YN1H/16ikWCOaR/N3LKPMt8OGVvUHHTFZTWprB6WIZ7i4RINkxhVHMkiqB+84wBn2qd90sQnkYK VOeQVZh6/SsZrSxq2f/R+YWhuLmOa5uJJFt7a1QI0cRkjlLSKgyR67icn+79TQr21rPaKjO0e3Mu 5eAcnj6f41/utL4Wf8/tD+Ij9Av2AjNqfxj0q00+zFjB/aKi5RRzfIjR5YHtjzVx+Nf2l6On2Pwv ECxZV0/dljxtMeQAa/zc+lnZ8XYeK7L8kf6v/RGTXhxOT25n+cj+Un/grzcR3PxF0y3s5o8prMZg +fzSp2or5x0+Z+nWvw6+KksEHhmVrK9M+oraqmpQgGOO286QLkHvg4HHvX9aeCtN0/DPBL+5+h/I Pi/L23i9X/6+L8z8OPHVzBY6lqMd0q5l1BvOhtx5gsyQDtMh69sn3ry9XSNidokgeTLDdk4J9a/z k8W5c3HWPf8Af/RH+lHAsbcN4OP9xH//0v5Ebm5kjcR2qSeUzny125ABPC0+7S8sZLeSSCVoZZ/J Zk5VG25zUN3gBI7q8JZsHn5Qe5qulzLFHmQiPDfKOuR2rmqdDSnuMlTc8c7OSWHQcAelRRTwrEYn ZgTMyIXGM+wrGSd1Y0BWeB0idizSfd3cL61Hc3LxE4jZnjGCw+6evSlJNgf/0/4/43DEPPCERkG4 A5Le9OlNtJIXRfKO0LkcZx3rxzoI5VVrYl2fCjB8sfe/Cs+0LW8khtriSEyR7HhBxvwc5IoAvxMz bAww7/ePTNXdypAV8sKythtw4+oqZfCwK371ljlZmiaGYPGV6ttPGR6V04ZLq1klEXlTRxmSRv4H A6k+h/xrEuG5/9T+QJruCKPnLlj82eoqot4JInhYYAYsmDnFeLBe6d6KZDsVA6bwoXbkD3raCJsU crg546fjVDILm7MIWGMHa3LED5TVHypyrTWzfMhyx7fSgCaO58vYt2QZScwoFyzHvj861bmeOKLK YU7cMFXdQYu92f/V/jruLwRLFE75jzv2N0yfb8Kpwssl1KtjOsdzcgI8TP5UExPQE/lmvAe53Q+F D79hpV0bG5eKa7RBI8cTeYgyOx74zj6ip4Lh5LdcuChO5IyM7fU0gaTauZ12zK6bbUzRu43Kv3lP qBV+wjjNw25JbNGtyztCmWJxgA0FWCEISYpLjyJM5WQ/xY55H+etaly5gRdzIryLtV9uCaAP/9b+ PW1VYIizOpbk5xk81TkvIVkZZiSo+bO3JP0FfPnoGlZ3MaJN5BdCq5Dt8qDr3rKe4uZ5XMUvCr8j BjvJ5zigtJ3aQWKqCiybiJCd0bAjJ5z+dQy3sxlkjjESxW7lDEqAPxx2+negUYtlgMUBeXYwIDRh R865HP8AWrMU5MbglYuPvMB8o9aDY//X/jZlttTsIZpLR5bq4ubjeY5CEt5ITgMM+vHSrJ+SPyGj ZAfmlIH7oZ96+fPbhHqydbbJR1cuq4+U5wKsbRbGSVsOgXewzkA+lBqlfQddXYgsbWeONrsXLmNI 4RvljODnK9RU1slxb30aXMTwwSwCUgxZXcexPY+1ZzG4uO5nXizDUYC0rRad52wxJwrE8Zb0FdFH 9mRWy6jadoIIK+1TB2dhWP/Q/j/ikVJJFK742ByehPvUNvHOtxORcp5KR+bFGnzHPGQT2r55ux77 Vy1Fe3K3SNNIZg8TQrDNCGjAII4yOvNbXhvR7ybW9MNnEzxw3KySEMYlYd0Yd8ensK1o6VIpGdZe 435H6Y/Be3mu9RbUpLW1gt40+zG3ihEkUYGxgVQ/dbK4HoOa/oX/AOCWek2M/wATpdYs7pW04NHF q0KKftEkjGFlCqRxjy8Y9zX9v4hrDeDNRtaOn+asfy1wgnX8YHbpN/mf1r+JTb6f4BuzOZpjb6YE +f5pGbZkL9cDH5V/C1+347+Jvj38RI3uJvIk1SMC3lQJLp7QOshUluQSI4/lHXcfQV8V9F2m1nle p2X6n2n0laieRU6T/mX6o//R/ny/a0kCaNfMlpNcGSxie3O0TyTbH2sSOgAKtjPpX4+X7z2Go3ah riAuxkUThlYK317e1f1P9JGr/wAK2HorpFv73/wD8Q8F6VsglU87GbE26ZYpwWaV8BlXcV56mu0W WawntvscLyDekahl4I4yT9Bmv5XlpFn7Pe5vXFxLLdyTsZYUmwPIP+rIBz/n8KekUhDrbsI2c7ty gFlrzq70ZvF3Vy75wigmeS4MMsqeWZWbbyDjnNeu+GbC4k0eSCxa7ub6WBGaJSAicZY5HvzXlVnp Y3p3uj//0v5RIluNKWJJbl5buKPDMBtfnqDWqlwl5bxu7yg7hvjlUpub69x718LOXQ9AtLMGlaEx RQmYERuDsGQM/wBO9WbCzmZE829hj3Qs+ZWxE2DknOM9jxWOwCvFpk9orWkMUuoQ3BK3huSEJ6Fd o445p8+j3GqRun2CS0NkizTSK5aGZj1bGe57VN7p2A09IZ3It7+SOeWAgwgKSFxwDz3+lW7u/dZb q5laa4aJcSMVLFFUfrxQ3a4oJqR//9P+OyefRkj+2MWeObkmL5ACf4/r7VnG9Dq9uyt5G4mKWNdu 9e24jvXmpWhYVWLcrobbPFdhw146RZ3wbzuC9BjPXGfr1qtHqEsLNsT7OyHEUqsG3EcZIPrWJlJW sirLqc85nL263U0I8x4nBAnHqD60ukJZx6dcXNuEx5zN5SgCZM8kY9M8fWgSbWxBfxRTwSw5miup ohIHiHzxL3HQjmr2i6Z9qiA0qG2triw+W4ur1S0syE7jJtz1Ax8q+laQf2SlN31P/9T+Oy409YEt 3hnM00hb7Su4rEvoVH+NZ0RvLK1dLeBmLfu3gdzHuUHPJwfrXPCWlyZSs7Fm3ms9stvb7bBnGW8l ThD7ZzV6YSQWuInDy7crO58s5HcntXZTdmRF6NHiniRdVmnuDf3qXUkIPl7+CoJ6KR1HPH0NcLML sQMsHmJMASskfyvnHGDXdGesbHHNfEfr/wDsZXMuo+HbXTtPvZzf2Xhk3eqRS48woYhuCt7HaD0O c1+6H7ByT2nxc8J2NxfTWt9dXZuLWxKiF/L2Ft2R9/JX/wAfr++OGr1fB28dbUv0i39x/LFJxpeM tDmdk6lvzt95/9X+234bSWk3gTTHt7jzLa60WOGMByGDeXhuD05NfzK/8Fk/D1zF4ps9UtLeY2tn dra3gE5IZZYgUmyem3JX33Gv2DwamqHiZDmdve/Wx8F9IGg8RwhNRV7a/crn8/UmjzwWF62mg3Dw Qu9rNK26NMYLKXHYAZx9K5GOG/urCefWdOe6lLqttdIcxQhch+eBg5A59K/01oJ8lz/NzFq0bFiz eCJYrxRCj6fG4+zyAPAgYbQ7D2xwa5a8tpLu7ieRt01reJcgISEKAhu3qO1dMU7GFtkdpqd7b6jD q1zbRSzX+pNFBHa3MmE0+ND87oR3Ixx9eRxXMrZalbRSpPfWcsUzhIrVImR1GOCxPGQfT3reGwNW dj//1vyt/su906Wf7UnlbyGOJd+5cDaceuDVuK3gsppNRhkZ4DEWSK5XEqqwI5HZsHt3/Kv9qD/J x2UbEE93Nqkb2qRHy7OMyRFVwUTksTjoBzUspkNrZXqSSIkEH2by1b9zNjGWP+0MfqaDIyUuJ9Sv ZZbmW6JLDCg4IC4G0+2BWywt7B08hbiZrr/VMo8w2TKeQCfUD8M0BY0ZVeysbjUbnyrp5F2W5Wbz bmV8gnfGOQev1qXSrqx1KOS4zKks8SpI2354QvTA9Rz/ACrOUk1ZAf/X/LPT760tFuYTCWm+0Mpe dAZJP4QQTz2qLWNRi0wW72UrJLLJmRBHkZJwVz71/tHztKx/kwk3oiNryLeryW5+2y581WBMWCML j0I5OSfSrOnRW32gSXKO0aH5UXgMcf0qClB9TUW1uZLiM2SmSA5TygTuySMkfTBqWaLUDNBZ6XNF a/NvuZ7p+IueSoA/WgTi0MTWJtDF4GtIr4hGVp8eYV5++jZ746+9WPtY1yzs5pBJZ3c8XmHed6yk 9MH06UGE1Zn/0PzCn0y+gWSee5gmNuBCllJKTM24kFkUjHHXr6Vr2t5BYubK5dvIiQTwOsZ3EsoO FH1I6e9f7SxabP8AIyexHNZ2lxbzOQ8U75ZHiw3HqfequlL9nkVI5XhXHlkS8OM8fr7VZLty6G3f 2c1zaM6h2Fp8/opzgfrVCCC7giglhvFiczYmsSpDTRdWw3Qc0EpuL0L11cSXF7D9iMlnFEMS7iH7 cnpjtU94kYi+3aXeXF/e2VuJ79I4CRb5O1frk456ZIoK53c//9H84YoLy4ja/v7honWJZoyQ32hT xhVUDgjrjtirdyY9PXzHkuSJZP8AQ3vB5zTMFDE8jHXIx7V/tQf5Dyn3KkaWU9pEJswYufMZkbO8 jngdhyeKe1hbNez/AGK5ilEKRvJbXEoSXaTjMa9z14HpQYTn1K9yswnS1t8NHMhJZWyyk8AVVGiS xmOWWSNXibzCmCUnI/hraCsjmk92WpngmS7MxeNZYQIoOX8l1I5zxgGsq3kj+3QGXfL5bB1YKSq7 ccZ7f/WrRRbOaTsj/9L81dRu11C6cSh2dhhgFPlY9B26VVGyYoIVixCAC0Shc/XHf/Cv9toxSP8A GnnkWrjdNcWcrvLG9t97DHbt6cj8KsM0ENwhW5DW18n77aSTGyngMvb+VUS3rqXNNu4I5Jla0FxG TtIkz8wz29+KiDrLPFL9k22sMxGR8xJxwGHp6/WgrmdrEN1DfpNaTtB5a39432dZpdluwOQfLU9e n/16sPbapA8Cy6XLbW843Qm4AjMgzjIzzjjrQNyurH//0/zdE2qxi6isEUW8MJunuY3DmEg4OQeM DNUotR1Ni899IJpHJ+dYgpKnjPTrX+3qgkf4zkq3EFvBDfW95eXKOxWVLqPbDFtIwFwee+TjtW9a zR6ne2f2xg0O8l41XYqhhgkAccdfwqyW000WtUTT7OFI7SZbiWWQrt8pke3YHhWPTnrwTXNAYX7O +TNLJvcyMNgbIxgnoBxQYPYt2Nrdz2+rwTXMHnRsDbRNL5rXGer59iKjOnQ7WiLeZdCMKXQlSDgZ 2jv0H5UGB//U/O1lur3TofDSw3aLbn7ZcTzcGMJ8wbJ6Ajj8fepLGxgjswtzdRvcyTF4jGrZijXI 2PnjJIzx2r/cOHxH+Kz0QkTol06pFEIMbWlRyQp9/rz3pq6Xb2uoXMUlxDeKr7zJDL5sR3DIGfbo fpWpgSXO2xjyse7acxnGN3oDW74ceC7knYwzSXcUeN6giOJeOp/L86uG5niJXgfTHwde5vNatoZg 2yyvY7qOST5kLxPFIBg9fuj/AL6r+3H9iPePhNoZebzG+yJG6B9yRNkfKo/3VB/Gv49+lvG+S4V9 v82f3H9DSd8NmkF3X5I//9X+tz/gopare/BLxJAqGZ47C7lCs4SNWW0eQ59sIPzr+IOz1qTUNC0m zuYVDRKbaDyogm7YxQFiOpwOp9a/0h+h/Lm4Txsf78Pykf5hfTCShx1h2v8An2/zG3sUdnMttcSo r8H73AyM/h1qa9tobWOC4SVDcPx5SkMy+hI7V/Y5/Gkn7zMq5ubmeH/SrjcFG0buAMcDioILaR4m iE7KhPmAdVJHt+H61cFZk8ytdDZGRDtmdVK/Kc8E9sCrkq2X2dDbyZuJTt2DLbPrW0VqjF7XP//W +YI7i6slt2u1WSJFyiNGMD0/xwarXNzNPY+TZ3VzbSNdRsCgBXAb5yfw4/E1/vwf89Lk2VbiKWKM pJMQhYhZmB+YjvjmpbfawW5DDEQAdlXmQD1+tBI/U3VrtpIIRCHPmR7SQsYYA4A64Hv61UguLd5D pyzbJAvnSFlxvxnvjH4e9BhJ3ZbeKOaG4EYYlCFRgvBwefpS2VgptzJDuaaJi8uGyFUYPTqMc5+o oE9Ef//X+V7i68zPlsZSRsf044qjHJDFGoiEiXQflsfIF+vrX+/kZWVmf865pWsq4cebIwQ7/wB4 cs/0x29j60vm26tNKFxK42gsOWz/APrqlJN2Ai+zyQwLeRyRlWJyqSDzB/vDqKilkjk+7lMqFIHQ Hof5ZqgD7HLFCzQTIxjfzWhK5eTI7H8B1rMWIyOJJI2QscgMMbaDGWrP/9D5bDWRiiknjdLu0cYa I7EkU8Zb9OlVBMVWVSski7vNEm8CGMHqMY78d+3ev+gA/wCc8tect1aoIS1vBHPsSJXwpICknHfO aguFby/JjKpu5JI4z6mmtGBBal4B+8bzox1iAHze2fxq7exadJDF9maYP/y1ikwUj9ga2jtoZzKD JNsAX5FH3Sox0pmzKffUMGxJ2ZqZmf/R+TCNzqgIMKLl2PBzUkMkWxggeNmOFYnj8BX/AEEH/OOU JpLhZmiKMisowxH3xUyW7siS5YLGcSYHFAFkSxWyMieZMGbg4AYZOOg9KinhlK5eMAvkoAdzAev+ fSt4r3UBBauEidC7mZsxuQNiFD2zn2p1tCgmMch7dQMA+1MD/9L5OuILdFBTG5f4scj1zT0tZZVi c3H2uaWIyEgHcgUkc/gAc1/0IH/OOMW3JVllzIiHOzqp/CgRTJcRXNuihUUxtG4yMMPTpmgzm3ex O8LJF5exdrPuYY596geFMqYt6lgFOfb2oMyeNAgIDEleu4Y5qG6WR8ncQ2OAOM/5xQB//9P5Us4L Ca33SxyvfxzfI5YfZwmMEFcZ3Z9+lTC1BYmMlVB+YjpX/Qgf835G6ARyQh9uW3Bj3pZpp5gGknEm FCYwARjgY7dqBJ6tFIRyBt0chVzwx7EdxViJIiZBIm4gfK3XJ9RQMYFml3fKdsQzu9qIXyWZV2Lj 5gBt3UA3bc//1PkrToWR2Lsu1f4QcFhWsJCgIzyWwnrn0r/oQP8Am75+w24t5VZkmjkifgZOCM+v 061DdW7rJHFInnRogeN87lGRnH4UApu2pMyfwvt4HQc49qaIxG+WBZiOFxQHOyR2QbozGDuxn5aY 0J27I2AGMZA6UFpprQ//1flW1jitrpHdwZbcrK4H3ZBnkH2ODWlqcemzXE1/p7PGZpAzWpAMcBI5 CN3GR39a/wCheOyP+b7mSdihuZcAnn07GrHnRRxAKjNMxO4kfJ+FMhT7iRlJ2UZZccbVODVeKea3 lcxJulRvkDAHJH14oKk7LQlb7VLO7FDLD5DecoGfLOMbs9sHFUPnjXy3JKdAe5oMT//W+Vow8SYU HJGeRzitaCeeS2NouMZMpUgAggdj+Ff9DB/zblVV4YvGTg7enPXFRzW6tGIyqNEwO5eCx+ooAjit wQwBASNNqr6jpgVFiZQAm7y8/Meyn3oAtw3TxqV2qAeHYrkke1T/ALieNoeAz/dDEKrfXNAH/9f5 SEJtXzuJIP3QcAVb83cd7DK4wFzgZr/oYP8Am3EMLRxxSTXBm5IjUnIiGSce3XNVZpH81GGFCjar KMZHvQaKZOkLs+9nRgfU5yPSmz6X5i8cAKXwr7eAM8HPsaC7rYitZjGsipGqneMtKgbp6VIiNGzt 1WQ5wTkZrWnsM//Q+Szcy2sod1xk4HGQc+v6Vp20aTMfNkwSNwOeK/6ILa3P+b8mms43VJGnClW6 N0xjrWZOVX59qlF6svoKDKTu7FnaksURjZkcfOwKYGPekmUsUzyB0z1FBKbTI5X/ANWFUgKcHHGR VpxEyqmxZGDBgTzjFBsnpc//0flG8u0hmd1Ukn5mGOF+lEBmvIHvEjQOMs0W5VY4r/ogP+b3mRXg 23MjKImjIAEgbkqeO9WWthCyQlXaN3xIc8Rj1/z60Di7om+zW6NthILL13cGoJFDGQM+Sp/d4GB0 55/Cgd1ewxonuEVG2BYx2UAn6nvUsMFqqSNdPINluWhMQ3KHGMBh6Hnp7UGUn72h/9L5cUx+WirL l2XpjGO3+FUnt/KeRmO5gcnByDX/AEQH/N4pJvUVHU/fYgY5BNP89FXchbdnAx0oLGou5HMjsj7w UYdMd8/pThGtz5i+YU8nGSf4/wAPzoAhlikhixHdR53cou7eR/Kp1hEMEUisp3j5oxy+c+lBDcHu f//T+U0tVX/SAxC5ztByRTZbY3BY28ThAB5jsdw/P+lf9EcEup/ze80ULHaPAYQAQW5yR8pGcf41 a+yxmQ/aXYIQceQQrj8TmrikthppjLS2iBWB5wmDsV5QWz/vYBPJ9u9Iu9WeIf6oHB44FUCaexPv REIiK7guDkDAqnGFAkEilvMGEcNgofX/AOtRZdQbsj//1Pk6K1MTFo2aSSRgNhfsParyBY8H+Nsq R/dI/wA/rX/RFJWdj/m4eruQsxUkSZCs38PQ03zJYfmVCiuSquw4OOtSImtfKltpW3BpJZDE7OCP u+nY02FAjbF4C9P5UGMviJJYFXM8jFcDueDUcSkkhSSW4zQSf//V+Y/suGBAyVGR6GmpK8MjqJMC RsOo6J7Y7V/0QH/NePaK3hnW4Mm3EiqH3EZJOBke5rdmjkQzTLtM7RsJGP3hu4JHvzUSlZaA3bcw YmiluFt5W2vtLBsdcU+a0/e7YwX+bbvX7oP+fSlziTT2Jmt5IzGpKoiglsjiT2/nTC9rG29upPGO Khu7uM//1vnRJMDz4HYAcK46elVApimUKgEso3u7nG4Z5x+lf9DB/wA15Dd28TZ3SPG4GVKHGT/n NPgZowN5JA4BoAlmZ5Hik+ceW42upxnHQf59KlldmYu5fcep7n60ARh4EikAVXZsHLDkYqKFrF8t MZ1dOUMZAiz0wRQB/9f5oubhHIFqjMyLl8DoPU0wA7UllwQDjnkA1/0MH/NhdkE0aC5/d5bJH3V+ UUOssUm9VDHHzBlDD8jQDbe5bimtXtJ4XtUE7fKJuQ8Y6kjFMsbbygsccgfIJIckt9MmgRTubeea 4KDciAZEivjJ/nVaSGaJ1LqZZAeQi43YoA//0Pl//STHJKsjCE4AiyBtOOoFPPm/Z/NdFdVGAynJ Q+//ANev+hg/5ryubiAy2+VV2UfMDkFs9f6dK0FthsYOT85BG7og9hQBWkSO2kRMkOw3JkdcdcU5 ZnTe0jbsnOTzjpQAoeNgWMhz0A7+lUlbypXVh5nmHqBjAoGm09D/0flh4ljcMRnPQHmre6OWSOJ2 AcglV7kDGa/6GD/m0lLS6JjFHFICmAcfNjripLGWOC4+0NBDdrEwYRXADJx0yp6j2oLGStFveZFR d78oqhFyewUcfgKa+0qOuVGR6A1jK19AKazTAMshHU7HYdPrV1bKUHdGnnF4xIvlHcw78ipA/9L5 q8oMhVyFO3kntUKwiEboXEqAhZj/AHGxnHvX/Qgf825VeNTOJVUMy8At2q/9p3sgkzvA2hu1BrDY qzvGWMZYGQEH6ehqvcqziJpJdrqdp2IFVx2/pWUkkXsXIhEFCh8vsygdSFJpYRbu5F1cG3kiQsyr GZI5DzgDv/KoIc10P//T+aIFLRPKrrs37NnJcDGcmo98UTBXUyLu+6pwx57V/wBBB/zblhWMc2xY 3WAoZBk7iD2B/wAaJBbvH1c3AbPX5APpUNxArr5cSu4nHmA48rnd/hVmKV5PmySVGAR1pS5egESK iTPNLI+7ZtRVbavuTVaAvCGlVick84xmswP/1Pl9mWcEySL5nZDncwHpWpabYUbYrMuw7Y3+baec V/0BR+JH/N3CTvYw2UC5+0BdkwUxlhw2CeRV1syDLtuAHK45FbBKWtkZkflrK3lgsxO3YByfbFXb iRbZPLYPHMRl4nG1kzyOOtTG1tCXNsrW88rPzgxjrjgke/5UmpR+ajm0+TBGGIyAO+fwzVGy21P/ 1fkyzR1LBuMEBmXnHvV+VwJGQHzowcCTG3I55I/pX/QQf834kLDZMmSrHhJEJDAc5xVeSxgKxNA5 l3ALtc7pNw4JoAm+zvhVm3InYZxUSxpFdbS0mxkIyCdnsCOlAEhtYXdSykl22qewqS90mSyZJmco rfPH6kDB4/SgD//W+TXkt5k80lnuVwIyx+QKOtODNPAYndhEDny1baDiv+gg/wCb8t20IjOQAse3 o5xTHhySU7nIz0rnNYyvoVmZY3EcuFm6BQeD9K0bSxWYZYuwLDcinD47gHn0oHzK9huy1t57qyuo EdIeYrhiUkViOAR7VSuI2uDHBHB5cEPzGQDicnufcf4UFH//1/lsaV5dpmGJxCWJaXGUVs5Iz/wK o1hu3eCG2TzHB2gRJhuO/HPav+gA/wCcnmktBPsj3lz5bkySKfnOchT05PaobfTY55bgTq0kVq2+ NYZArT4PzbTzmgTbe4gghZzK6vGEyiRu2Sg9/fpSFdu8QfdQb2P6Zoa0sVGXKrEEFvJcyN5sg+bL 7pTgHHOKgM0GJA+9sMVURpu2dsY9KwsyD//Q+ULZv9HIWR18wbCAcZB7Gj7ALYLIsqPvGSgBDR/X P9K/34P+chOzuiDKNvQ4Jz970qrmRJCqDKg/eFA3Js22lQ2sUTWitIPm+0/3wexHqKrIohWQzx7l ljzGCflA5GfzH6UEkKzFkALgDdtBY8YPAApJPOiwYQm5DzvqZRvsbRba1P/R+WIpoWLTTRxvIMMw 25APrVPzHa4fy0G12yGxyPYV/vnyysf855PNHPYEzg+bFPhAjHaEwAW/EZ6VSaaW4LeUEaFRwwxu LDIIB/Cps+oD4Ip2EqIWlVVDPIBgL6j+n4UxJDasyuFZJBtApAXojFM4jnL+W5CrgcIfetK5iltr cQWsbZIJkKjAA/z/ACoKUmlY/9L5MWWKaK5iZJGmijDRn7q5zzn1qKGSZlJjRY9kf7xG43+/P16C v9727K5/zrLVEQikx+8XywzfLg8EVqoYvKZGlKqo27uvPbrWAytGvnTxx2syqykZMnCqeuTV25tH ZHumljM0JBWILiKbscEdPWgcXyssxXMT24MsCG4d/kdfkEYxj8azp28lys43g/xDofeg3P/T+WYt Qki2tG5EeDGB0Bz1qhK5uLlreVI/Kg/eRMo3MSSBX+9B/wA8UZW0exvQxJCrw3XkgIwDW74Zz3BK /l+lUrsIJneGNHSRQrRrEqDGMdOlBakmTSJp5ghSK5eRngC7dhjWA85TnqB7cc1nJp0tvK1xdxG4 06J1XdbTBJGDe5z36YFYy+I0i+Vm3AukPOrXMMxtPLMZXeA44+VicY9M8etOuDp8PmLcTD7Ncp9l htowpfHb0wPesp6I2P/U+VbdbuG1kt4ZPLgQhdudw2AjHXp0rWtWs7mVI71cwBNsrwgB8Dpn3/wr /dd7M/5/KD/eeh+k3/BM1ZdW+NjR+R9lsdO1eGGzPl83McioHYHqRlEyK/sutrf7N4cit0ZXWGwA DOm9dqp3Hpiv81PpWTvxvRh5L9D/AFo+iXFrwwlNq3vS/Nn8df8AwVM1US/GmO2W0826l1m8ndxL +4WGIQLjZ2ZGUsD/ALY9K/HT4g2TXGgalfwXAtXm3SSQzrst7kQjecv0DDAwp6nFf2T4Sx9n4aYH /r3+h/GfiO1U8YMRF/8AP5f+lH4h/E/7JeareQWZDKsxFw2dwucqu1gfb+leRw2zeasUjuqxMHC5 wGx2r/NHxVlzcb4//G/yP9N+Co8uQYSP9xH/1f5EvtrTsWaExxxS+Wq5AdwODx271Bd3+pfaGQqJ LeMgRuWyZB/tDsaxvaFgJbdV3qVKSIx+ZG/5Zmo7uCSV2VeVjPzKMfNWMy6e464UGyLQkNInymPO MHvWJZXzTSqohDCJsvu6qB3ArM1OgWNbjfOAW8vhdw4U0yS6hZ0h2APs+dl7UAf/1v5BZVRYt+13 CnJVRlgPpUbRoYUeRCHD5DLwu3HceteVNa3OgZHJPNN9mgiQ223LOxOQfpTYtJt7aW4uruaXcFLI i4wpA6evNQBlyXUZHDsgLYAx81WmM6QEyRNOlvD54TducgDI79aTV1YC/BKl4tvNHnDpvWJuGX2P vU7XxVGQRMUZgGTO3GM9aj2bsNOzuf/X/jzCCQyjYckEg9WBPSqSxSQjNwCpJwCO9eMk4qx3RdzQ keOMKy5AK5OOoNTxTHa4QeYGXhsdKiDbepRBexzNAhiK74+XU+hxUUsk9rBbLayvAhm82XADpPgH KHPTqK0AfNcwMkDSRHzxKfn42pxwfb0/Gk+0LEmCA4PVm6k1nKT+EVkj/9D+NO/j+1zLIm5BnpnI H0/Wn2NpLHOhjt0uWRtzF22gcHkfSvnz0C5DbeRPNd3UjPcTSbW82IMEQY2qgxWj5STl3hJZyAxi RMhffApSfKgLssFvDEhYt5m3goPmJA7Cufs9WmfzlhtpVRJTE87rxjpj2/GhO6uBMbbzDvO6Q43M Qv3a1LOD7VZ+VdLvaGYvHIR8yjsPypRfMB//0f46rYSBZXk+VVdkQE5BGeOffj86zHtcyPKC3mAY MRbdsXqP518+eilrYghaeZ3tw7/ZQ3zK5wrHFX0D2yyoUMLFSscijcRxwRQbJJO5Dai4aWOSQuyq Oq8KffH4VrWdhZW9zcXMUOLm7GZmdy276AnA/CgYalbjyllVhFKXCRqThW64BqRSJhDDlRKMK2Rw TQXGOqZ//9L+QG5aEQJayi5M00oghaM7UTnkk+n0NZ9/bva77eNWmym0n7yH8f8APSvnz6AdHLst 0GwFcAbu+emKiOHhlt2kCGUkgDqPTGaAWhHoUbLqFrpjohkMzSveM2Ejxznnpx6eldiLqKW0e5LR ySiZ1EUh67SRuJ9TziomtC5SurHJXd5b5jV1Zg0oxH2Y1M9zAzi2VBEZxhcKWCgetZx3RN9LH//T /j32GIoiNuA++x4D1FHiBlijQQb5N2ANwfOSa+cnsfQGgUmM3nSyjybcB1bGMYr0DwvqML3MFjBO yTvMrAqD1JAx7dq3oL95FehnXf7qT8mfpN8Dl1C20d9QurXzhvgWPa/Mm6He27oCegzjHWv6T/8A gktpFvqfi3UrvfDbwIbXTbuwt1VpzPOfMDs3qAwHtjvmv7f4ihKj4MpJfYR/Lfh/KMvFipP++195 /Td8U5JNP+H+sXFxM3k2dgzygn96zLGdhA74I5r+Ej9r7VTrfx48c3sV9Z3jJ4mmvdTRY2imiEtv EIYTzj+8x7g8dq+Y+i5Sbx2JrPol+L/4B7X0ncUoYXDYW9nKV/W2n6n/1P52v2rdUv44IbOyhtrR YoBDcK8jN5qTs0i4HbaNox23Gvyz8V6je3kVta6jFAHtFY+bH87uCeBuxnC44HbNf0v9I6q5cR0Y doX/ABf+R+NeDkOThlN9WcfZRFozcqwJ3eXHtYEk+mOtddpV3q0N1G0sUFxbfKZBO/3QO3HTpX8y yejP1qG7L+oXd5c3yW0KNIPL3RRpyiHJ4H5VvadO8UbMYwWC7S//ANavNxB0U9guEGrTwJLBHKY5 VLLtATC8Alfw/WvYNHlks4VAYiZlAVYD0XAxnH415WIdkzppfqf/1f5TFu99vG7xq7NlWdlyQRSx 3Fw52zJFGiuBEU9OnNfBT3PQLFyFt54lvI8wvHv80j5Bn7uPeoI9Qt7ma502xIkmtIllJyQmHJAw fw7VmwsactjNpumfbEjlPnSBY9keY93oxHTp3rvdC1LUYNOaa0tbe+W5tCJLW4b5o3XnJHqOcDoc 1G3MPlfY5q2BkuZrhHjSVpcmPfgoTnP05rWiuiRL5iKhm+RiOfOx0z+VP4rpFwg3JH//1v46tSgs kt7aKMNDuYMx4KSAdRj3qpJEqiNLcp5e3EoZfkww6/X/ABry+dWsObSk0zTXw1pttY20qqVFlZma Vi/nM77yQF9jlB+Ga468uLckzeW0MbnywG4ZDnAIFZmM9xYYFsnuJprkTloFEYQholyMj+fP0qta LFLckIXj2phVDYjck5JI/rQQXzciO8VpL3yXSHbm1I3SDGNpx0B6HNWbaaaOKSO2idGmG9JByuOh 59aF5Af/1/42YUvbMrulilt42E0pLfvH3DkD6e1dBZ6ktyYTDFvViVZ+jIemMVyU9jnOY1m2Mbuk T7LmQtFCSvzopPb9K6+TTdP07w8Y9Xubi+IsllaaGI3Djp9/b0x/nNdcOhUeqPCvEEr313qD2wRI Lchm+YNtTAAyfpXEJLJJcBA5MYOCvQEd8Gu5dLHLPqj9T/2GdSi/tSyiitYZpZbG+sYYJ5zZoTHa 4CN3Ysc4HckV+4n7Id/qNn8cfDPiXWdXRrzTEjttKsEtAkWnq3yJgjlshNpJHVhX98eHs/beEMoL V+zkvwsfylm9qPi9hpPRKpF/jc//0P7TfgXdR6t8NvDcsgi/5AkEoEK8IdgDBvfgH8a/A3/gtNol 5ZaXaamsjrDcrbNqKLGWbZH5sURx6sdn41+p+G0/q/ilSprb2tvxPl/Gmj7bgzETW6g3+Fv1P5lF 19LWIXUUG+FIniFoVKyE7SMFa4OPW76Bvs0ksqWksgRIZfm3Mx4H5/54r/UTDv8Ad3P8ysVo7HS6 hqH2CKxQaZarDfQMt3dCLzTeRqw+Rs5AGd3TByKZpWnafBGl1LI8gaYsEEwQ4x91fp7g9q6I7I5b 2sZt3cGxeE6cWS6DN5Ezjesa8ghuOTg8U+DUFi+zwXEX2qaTO7K455wc1tFpRB7n/9H8wZE1K+mi a8QcNsihQfLsThfm78AdazFmuU1YERB4w+x4bhGNu6qRkEgdR1r/AGnTTP8AJcs6rdWwuJzaRqjS RYkSPIh3HOVz6dM1atAsFha2Ny0e2cCRkVRIYgSG+TI4/Dmn5AVZrF7dXuLNgytJ5IjI/fE+oX0q pFezw39kjoywJLsvRKu1lB+8R3qJNcoGhqGrPAVsrJbZ3aY+bKV8xJ1OCNowCCMHn3qTTILm6ux5 cy2UTTAXIWLIXoSMehz25qHa3mB//9L8wrvRreVZ5HcSzRXCRlbdszRs3Kkjrj1/CptM0uaG7jlm 8sBTiB7mMPbsykEbhznHp71/tAf5OU1obd8lrdXBuZUggluptssVrGI7eRgAMqo6ZA+lQ3FjBbW0 U8TJsXczoVPmJjoPx5oLEt9WaaDbp6xWt3GDtlddofjGTz6VBafZre/lnnu7XWhcWZs9Rso0cLAz ZzhuMHoQRkfUdQLDoNRtn87T7O0MUH+oit5FwXVSNoOfpUMmkai00XkITGQSbeIBmix39gMGrULn POKvY//T/NO7s7zcLzIug8BSYs/79CuO3YfX9aju4m0/+zRd3tlLd3Vl51nAj+d9kd8lUkzjtjIH vX+06io7H+SDWti5aQa1FZPdw31rb3cgMZWCPfGFP3gAemQKrW8MGjNNeahI11qMk43WUy7kjUDh y2fXPFMyntY0FvLecLLFeGQuRG1rHz5e4jBIFNktLqfXLWyluUtbJrZ3NzGgJlkUZVPmxjPA/Gi1 tDMkjaBhOrtgRgrKGODgcE1mxQana/bUt9YOlWl0UikaOLzXuoywOG4wBnrQB//U/O+W38q3kWXV oZtrgW1w0TQJJjnHp0Hf9ay7qV777OstubmOA7ftoJKWw5GFPvk8V/tQf5BzRcttH2efdRxfbYoo fmj3kFMkDdj29adbaRaNOdQmjjje3gaRLh2YbxjGzI657A00m9jOxRhsmt2Z9NIsoJWaUvfO1xKr +q9eMg8AinOmsT/YnTZdJLcm2ZYx5e0qAWcjnAORjntitkrKxhOO6RcgtYzBfS3yhfJJ3bCDLuwQ o29+RWNHbvp17AZX8qG8yn+lgxxpuGAw4zx6VpBM5mk9Gf/V/PC3hlsJCqMpaaMiee4gADxk5yg9 8DBpb3ULC7Ro9JtI7RbYAMWg/eXAAG8+3IJ9vSv9uD/GxxVtDJ0+VLu6uLW9aSODyjtnjj3mNuTk rxkcY4Peq0OnCaORZSywrKWSZE+d/Uenb9aDmn0NQQCNrW3QMiRN5yScrI3Tkmqt9qMumw3lvbFH VwfNmmT5kVsfMPQj+lBa2ApBrcmjyapd3LwaeNsEUUwQLwSCPf8Aoattc38sjWl3Gx0uSNhZ3V0z LKu3gBR07djwcULQJOyuf//W/OiBn0rRJ9PtrKR22nfcwozM0WckP271A8X2xI/skXlbrVW2SHnp z9PpX+4B/jA23uQLN9ttrewKwQparswB5cXGcu3uafZh2u4/IheQRcuVGEjC9zQI3WedHU2kKShh 5iscMNwPQj8P1rmkvnmzFfaZ9ln844keQhj1G0djnqDQZzbTsa1kL3TobqWOKBluk8oebEsrxr/s k5wfcUy6WaOREUFbq025fBKpuAYDPQjBzxQZn//X/PIXqrIqT3DQPNHtnkjzjHdT6g/TvWZfvbwB JFmlczuRGuzaiAAdD+vPrX+4UPiR/is9mV9OhiZpo0R41lbzHmzmPce579quotnay3EIuwPtB8tZ XBQPJ0UA9iegrY5ZStoi8b8Na/Y7uL95u2efgqQO3/661vCVlffa7m1gldYLhhOW85U37Oi7TwR1 /Oqh8SOfET9xs+hfB0aWviXTUhglNzdS29lDPESGjYyxlgRnGCQf0r+2H/gn/dNefCOwZtx2uuxg +5VCxqBx+JFfyX9LOmnw3hp+bX4o/tX6F9dvE5pR6e6/wf8Akf/Q/rx/4KH6ez/AvxDNGARKjxyH H3AYnBzjnkACv4dI7MmK1sIiktyrs1u0HybCzsQq/hiv9HfodO/C+Pj2nD8pH+Y30y48nHOEt1pP 80Zmo6df3lykCLvug+2RDw/y9fp0qOK3v4biPfIsqowMUpPmBnXqp+mBxX9lo/iuW7IL6JJiYmOW LgOR8pDA88UhJELJG7RunyiUdBW6VidbEiTW7qQbUGUqF80ksWI7gVpWgghdVWGN5pBgFxwpPAA9 6uHxIznsf//R+XY7WeS9mi1JJY41j3qjK2zII4HpxUMt3Z8WtrBcqFJHn7Qbd8ds9QevWv8AfdNN aH/PM2luRLHdTAQmF5MfMpA3BfStLSbffBd/aHSOCL53yQJOw4Hf8KZDn2KGoBpkkm84+dGqx2Xm R489Acc+nFZjQ/voJgqpsIMqjrJ60HNN9C3NeXEVvMkDBY5WztA6Y6c9ajtVlkwSNveVidqqO5NB N2f/0vk5YleKWS3JEcb4Z2UqPw4qR7RjCs6spCEKwHBGc9vw/lX+/Ki3sf8AOq5JaF4afcQ2rFyV kdshAhUiMgFST75PTtVHeEUoY8zD7kjnBX/GtFCzRldlC2mka4mjuoprd4/lRTgJL6nH0/nVm9kg xGIYXQBdrnOQSPT0q7WBNrYekFx9lee2u0hkAAVJNxMueoA/P8qjt4pwP3jbu+TzQS5JH//T+XPJ glsp/MjZmmxCCo5HIPBqnKHtrW6sywJuFUI45KbTniv+gA/5zIyu7MhitDb26SEsecnAJOfXAolu SzbDjpxgfNQWJAqi4VXLbXHGOas3kSW37mOdGkPzuwHyr6AGtYPSxE9rEVpeKo/eRmXnaBnGOMA1 Yijin81bmN4yV/dbCEbJ7n8KsyP/1PkXVEitpbawtHMjuglmmLbhEOPlOPr+lNiSYDY/zLE2ARz3 PQ1/0EH/ADjl+QTuFkSCS4Kj5URSzfTFRQahFcSQrIr2gILNFICA5AztI/z1oAWaVSzeUuOchVHG ParFtd2yrtuw5bafLKHBBxwCD2q1NpWAsL9gWwuXlTbcsMWpVuc8dR6VjW6yNKi5KvnIPQ/nWkXd GLk3sf/V+T1t0JcCTBcksHJxmrVhPJAHVyqgqYlCL8+36+h9vSv+hA/5vyeN4jKoyMZyM9KlmjiE 08u7HnSBhFGx8pCOMKM8D6UAUbyXy7hVn3W/loJNm3LsO3HvVxRDcotzFIOgI+XHt07UGbnZ2QSg KQ4jO2QHbjoSKbGqshLx4kU8ZFAud2sf/9b5jjRv+WJWN3bA3DIPt1rMRpIZ7ncGKeZhsPvQHpxz jt2r/oQP+bnmkJPhkJ3E88c44pLY/K6Ku9iM9M/WgV3e4+28/e0flNM5UsqRrlx68VFJKGlSBFMT qDwyld/c8H09qBuTZrWUaNaykygSFsCMghj64qLbysLR4VQfnAC4Pv8AjQJtvc//1/lXyrWORJS7 l1yHjVcKMfd7/WlupIbmDyjGwdWDIVO0jHQ+tf8AQgf825KtwxRY5mK7RtG/ripwWiRE6rnj2FAD WdFZtxxkY3DtRF9oRhK0ksjqm1fM5LKf/rUAMS5iLkSfxnAbGcGpHNxaxRSLMsf2lSXVMSYGSu0+ h4z9MU4pN6lQdnY//9D5XEO9XAUlm5Z+5psUfksscgIDk7Dj5RX/AEMWtof83Et2W3gAyjq+/G4E +nY/yoCHaoIA54PrQIh8oo2Y8hz046VGZJ4hujRWdTzvHB7UAXA0losdw5AEygSKT8nJ9frTriEI +Qq/MBJtB3BcjOM/jQB//9H5bVJt5cISAM4AyKsQRfaWEh3Jt+8MYxX/AEMH/NuEl1GJFhAZdx8s NjOTUMls+8L5hwDncD1oAt2/2TP2V/OS4fmO43bYE9n4/rVdWtleRY5hNLnY6AkopHfH40CuiWE2 0mQ5AaLkqcgt15qeayilSG4hKkLnPPKEHFA/I//S+U5LjfceS0YzGfmZc4b61ditjMcwOuwD5o2b DH6V/wBDB/zbiS7ljaIBW29hyfSqrwMIkZwVBPHHPWgBhhY7VDErngrnmriWLyeYz3MuETMYQ7ST xwfUUAVDMpY28paMoc4I+VvQ1b2MzReXypHVuOla09ilJpWP/9P5U2iSd1kUuWOxBjG3HFE4a2mj jjjz8uHyeV9OPyr/AKID/m5cm9CWQsIkd8iPcFdv4RnoKerRW7hlQOuNpWQZB4Pb8aCTKuLuWC5S KByJLj5FUHqO4x/Srp8wlCT0GG96AJlh89QP4eoI71nRSXMF9LbLDKApy5Y7o3B9Oc9qB3drH//U +VLqFW35Q+Y/3QOvfio0VLdAjBoXHzMj8MO/Sv8AogP+bcU745VkCMY35cgY9ua1LuaOWNV6yBQV C8N+NBcZcuhkQgPIwkDg/wAJBxtPbP8AhU+0ySiNo0ijUDLKx3SNnOSO1AlK0rl1rdRGQh5x0PWq kcbyRs2x41R9mXGNx9qCT//V+Ukhm81DGoZFb58jt6VfSOMpIhXLFshieR+Nf9EB/wA25mz2bM+1 huQnaQOmKsxpHny9oG3jORj/AD1oKUmrE9zHGRHHKdqkfJt4PWs67gmhdFjXk9SOc0D52OtELPKZ oSHQgLnow6/41afaJAIE2fJyhOecYJFBB//W+UoI2VJFYmMBs8nPWkRz5jiCWQIPlIK7FkGK/wCi FJvY/wCbcs3EjCGMoS7KduO61WjaU7Q/OeSDWkFZASwkJe75A3lAHeoGWz2wahLPcTmNi0SSPgFP vD3qx3aHi1a1VoPOeVj0d/vkZq29iIrWEJNvkePc46FDk8fpn8aNheR//9f5PW2uXygJ3YPzgcqK R4ZQ0cQLFB99+jE1/wBEkz/m3NJghREPJAxz7VDJIJCkRPMSkqh4AHcj/PesyZS5Se2jV0LeSBsB xx90+tVA8n2jHykZwB0NBiTXNwilIJv4yFB69elTQw+U+7BI7D1oA//Q+ZJp54JUR43jimGUcp8r YPQH8DSlB5ikjJPzHAr/AKHZStoj/mpcncje5RpWi2qEDBvLAyRjvWhLK/EfJDLwfSshNt7mZ5dx v3ZC7DhSRnNRzXMsMsSuJFO8SCWMZQkHj/8AVQCfKzbN3JOXmuB5rFTu3LgemcdKpyW1vIiFVEnm HPl4zg5NBsndXR//0fmWWC6t5QmQIFyhj67W7H9Kvhh9mEUqF54nPlyDHKnHHt0r/oZduh/zWyfK hJIUeICU4ZTu3fTtVQt5mQoyijr24pEqfcsKgdcbsbf0pJLa8JV42WaDafMVVJkTHf6f4UF3QxhC sWeN+cbO9MgTajbkGwnJGO9Acytc/9L5mgeIymExFWkBw5OEXBHBPTnP6VNtx+6IBXdx3HFf9DB/ zXJprQtyqyQFVCgjDnOATjgfz/Ws2VplCgpnzIGmEqkFV2nG0+56/hQMgtyHTeVbJHO3pnpUkTxx q4Ks8itj5TwPwxQBOiEs7ksyIMlV5Ymi5vLh4oN0MUW1dhKIqSAf7RHU0Af/0/l3zMIY8llP3s9e adFbxpbOplkAJzEqjhjnndX/AEMH/NeOXS08rzyvzqvXpke1IJJJY49uQFAADDB445/KgC/vuLqE mRUKwYjXAAwPT9Kz/sskkjHzFEQH3O+c0ARy2clvmduIl+Z+OFFWvsnzRXRDCJ4sp6P7j6UAf//U +X3D+ckQCvGyFt2csvIGD/ntVn7OgfzFJRgu3PXFf9DB/wA15CVjEjx73eTIKS4wpHcfWmSWV/OW ksYXlaJc7Yl3MfwoLU2txEtvNWMztmZDuIHC5pjTMJ1gwwbPC46gd/xrGSs9Cozu7Gi9srRMGYJM mCEI++DSIt3AkcwlEf8ACqq/zsvIPT8ufWpLP//V+c5/KmiRBt3kEumPmB7GqFssiIpKhRKP3sZ+ 8h7f1r/oQP8Am3KN4jLIpjJjweCe/wCFXE+aOJc/vCMuMfJkdcGgBzaeJSjRAtcM+CPWpHeBolQo DJGdr8ZyR3/lUz+EpybVh0EK3SSGN1WWFdwjPV/pVSaJT87Bg5GOnB+lYkn/1vmDTwIhIJd3UYXH BHNQ3YZpmuYlwqnaEX7iZPFf9A70R/zbl+3eVk3E7iB1HQU6FYkuDJJHl5z823j6VgA+K2jNwWcB gD9zFUpVdZvNifZEjHfHjOR2+lAEqXAeVd8LPAULb1HOew/Gpr1oRDAY2RN2fNQgAxgdM0Af/9f5 aQo7AhTjPytjr9K6C1eKOGQk4d0KLlc9v881/wBAB/zbmR9jUgpNIwcAlnHUnn8qfCYYtsavvOME tyT9TWnMuWwDSka+YqW+ZQ3mKVTBbrWZfiSWQ3cg/fXGBJkYPAwM/gKKfYCW1jQApgqcc443Ustx cQlrZSnkOf8AnmpPIGcnr2/CtNjoP//Q+VYhjKgbsjlemajYNF5mQZBtyFHBHB71/wBA3Oj/AJvy e2jL2nnSfu2ZSpWlsrcWiLI58xd5MJbGQfWqAfd3eYfIb51Rt5kxl19vpVe3RTEczjyydzZOWPpi gCR766gjijt2h+zJJl0kt1ebtjDkZH4Gpbm7lu5BIy42R4UKuG6YPNK6vYD/0fln9xcbd7wxrDGX KyDy2kYfwjHJzjgVTj8woW8lk3HAUc45r/oHbS3P+b5NPYPM+1S/Z+VEa5ZgcEEdsVbZ4kV44XLT 7NoyM7AeORWAytbzxtAtpdRrJNbMWguvLHmnOBsY9x3BP/6tCCe6s5FmjdVbsroHVh64PfigCpfv JNcXE7qXe4cSO+MbiAB0HAHHT2qKK5J3bt6ui7Ix/CfrQVF2Z//S+WZJJtltHJcOi58ySFG/dE9O R+VK7TW8zyxXM0NtNjbHBjdgdRuPrX/QAf8AOOZWHR5Hhlk2ScyI38X1qKOZlQR5b7QHxE4ONoPU Y/KgCS5+1Okce8oXYZl278gMN3HuARV67WLyQlqNpReWY5dz3zQBDBFPP5UYKrI2FG4hV/HtV6bS m0/zFmWLe3zK8bhwfpj/ADxSVugm0tz/0/k2JXXlVJAPTHSr5WWaYb5I/wB3GSBtwDtBxkfhX+/L 3P8AnEU03YoCOEwvJISk5lwI1Hy45yc/lQsQKkKWXJzmkWTmd2tQUHyROYM/xAj1FVDMHAhIYkdW zgD0FAF23nksZYWiiiMsDrMomhWZMjBBZGBVhwOCCKvX1/Jqrz3F39nSWT53NvaR2cZPskaqo/AU GsNj/9T5Rs4Y2V4h80kjAZJxwDzSTpLa3GVJjCHMZHykY6V/vwf855DIkrfvJWbbKS4L87+xx61a fyN6yW0Qx5SiRUTau4KATgcdRUTWlwF05VhvY7KXcEuEaUTAEiNyw2oRj+LcenQCoLiNTMyk5ZW4 GMY/zisgK4eSN2Vs7D3HGK7jwrcW8jyWerXASGUhUnuI2cKDgYyvII6gmgD/1fmLWrD+ydRnhguo bm338TxqQJVOGHBAI/8ArVlGVvOXhQCfwIr/AHv3Wp/zr2UdEX7toriUuqLGY4hvRT8rH2HbPpSW mmrqs8VmZBDlfODLyBt+Y5x7A9fSspKzsBS8uEO6hwE3FcgYYY4zW0tm76T5n2gv9nA3ZPBJIBoc WgM+xsp7tgse+X7P88ixqWYL3J9O1XNTih+zxRgSPKGwTs+4vuak0U9NT//W+UWjacx2qLny1G3y 48HHvjrUpg063kilkM7XEPDOshVHBx8uOnrzzX+9B/zvKSeiJIrRjPBeNdQvbE7ZLfLCZuRjnp0H r3q5dWZdo3tD9ribO1ITgyYALrn/AGc89qBmlYWXh0aXJLcw3i3VvdFBaWzDykRlG0s2OzHHvkVT C20kU1vZW4URAysgbIQjqzZrKa1NFPa5jI089okpjxv4nixgjH9KuxQNqt7H5qxwIqCNQq52hR1P ueaykr2RspNO5//X+Yr2w+yX0dslypglPluyqS+Twn8/etC20K5061LXkckN43zlH5ypPykD3Ff7 tVFa7P8An2wjvNn6jf8ABL3Q5V+L1jchZhFPJCt0Gcs1u/2najDsNwY9OyD0r+wKdTb+HcCZoylg il0XLMCoBx9a/wAyvpRyVTj+lHsl+h/rx9FiDpeFq031+9H8W/8AwUx1KbUP2k76SBmlW3tr27W2 g4MzPdW8ZB7Dhif+A1+Yfxm1bSo/BWoWAh1GFg4laCOIPZpIqnI3HnJyK/tfwwhyeGuCj2pfofxP xyvaeMVd/wDT9fmj8FfG80iXt/5MAV0uGxKE2iVTgqcewOK8+MczrFMsrG4ZgdoG0ryO9f5g+Jku fjLHy/6eM/1D4Vp+zybDL+4vyP/Q/kQFvcCfLx7j0YgZUepp8s0RaO3jGTn94cdK5wLtrp0cST3T Sqqom7YSFMnPRR3PWqkF5Gc3VqjHZIVQSrt344yR2rKe5UPiOcddYmuLgrEnkO+993BOey4q1aQt EftDR7CP3ZDDB+lYycr6GxrLLIGVx/qEUg26gBX9z39fzrEuCUL3ajZk5bI+6BS5pW2A/9H+P37Y 4VZAQMrwwGcim/b45YGVtqluAF9fYV5LbZ0FazmMcxJmZBkZVRuLVpXvktHueQtv4CEcVIHPPZGa XzEKjAwFU9a0bdZvLJCEgfIwPBNA7NFkCCFV8rO9MnAHQmqeArNl5hLKpZe8f5etAj//0v4/Fgc2 xZZTFLjDOBz19PyqjL5kjLEzqGIPlyOpKA464FeOdOvQnsITDcoL+RJYs5LRjaMew/z1qMvMN+E8 rMzeWow25AflJ/Tis6b6DUpJFfMkTGaZzhm289Py/CrCqZYml2/IOg6Voap3RTurZXXdM7Kg/hDb QfrUdlEJ2e3YmdEbcMfeAzxWMviYz//T/jynSG3d4ljKyOgI3A4j7H/9VQmxnhmM9hcSGPcFkRlC 70P3mA9a+fPRSu7ENyVuZo2FxPujxGY2AI+U9OelWYpZrd0+yTFGd83BYZ46YH6VMo3Rco2sPv5W iRJj5kjx5ZPL6k8jH61y6CVrtpoEeCIAtKpGVZj1oUbKwRh3NtfOZYfs91LEZAfM2AHIPqPy/KrM D3MNu8fnbiDneRhm9yPyqKa1Ias7H//U/j1sos2xmMkciiTa0Wfm/Gs25R47mRoVCwTKFJViXP1r 51ysejHdECo8bKAmQW6gcn6VpyTAIrOxaPG0b0III7fhWfO7m4xLoSOipGhRf9YynGfSqt7fk6rF FDp9yttsB+1sd8IIHOemOenrVxd2wLl3dW0LrJPHJOu9URRHvwWOM47Y55q0REz+bCgGOQcYIqze Kskf/9X+RuG8hWBllUFgoAfHt1H61z97ewqokj3Fml8oblxk5xXz59AQyJcm3XMW2N2+8o+534rP eAyPNJ87tEBtUqVIOOvuP/r0AWIolOxthVlX94c/eNP8wwPK8jRizt4hKi/xscncPTAot0AZdury bI44njZBIjxnO0kA/wBe1LBa+UkV5J80fmlHlU7ihHbFJJLYTdlc/9b+PVJoryYxxyp+74aMf6zn kZHvUC3CNcLEzPGxJVSyHjHB4r5+x791a5qm7kiWOKNQ8bOAybeZvqfxrqfC0unW/iW03STiWSMF 0hi3gsrAjOOw710YVXxEF5nDiqtsPUd+jP1a+EvlWWg29xDA1/dxXMKR2McoWSRFUB48ngZ45PQC v6iv+CR/g9rPWrnVYoF8/UmWaCKNBJFHcQqI0Xd0YYhbnsa/t3juqsL4OU1/NFL8P+AfzX4U4aWM 8ScRUX2Zc33P/gn72/tFagln8MPEF1cnbb22iSyT7V/fSukZPA9M8/hX8BXxzvby7+LXxGup7yFR N4innu0TbM4dXEcfmdSGURk46nePx8L6LicXivNL8DD6UM28bgFfbm/OJ//X/mH/AGrNXit7iwlO oXMF2LieLSrd4SlnfRnauZF77SvBJyNx57V+c+u6gs0x3qYuSXDDqfb2r+ifpCzUuLIx/uL82fkv hLC3CtJ+ZkaXHvlYJ9zcGXHAH+eK6+2nlEjqQghjXMmThj2zX85SVk/U/TIfEiZI/MmVvtDKT91V xuGenNdgkMi2wjDlQSCeOWPTJrzsQrKx1U+o8RXEciyocPgLtHAbHT/PtXqHgw2qfbll86S+l8tl JO+3jX5gwHoScfgPz8nE7M6aW5//0P5P7qx1SdrY2EsMCmdVntp0yrJkhmRhyG6deK1ILFLFr20v WlkkB3WztKGLdzj2xXwc11PRW5VN9p04jNwxW33bX3naykcHGfpXRWenafDMwsZY55nwNpAWVkA3 Zz7c8e1YyWxUFqPNzdxGVEllfTpHBmiJyjMOF49qvabqttHM9jHfwQTyNuKFwjRAj7p5znH86iT1 aNS05SxuYYL3TYFSYGX+0oH3z4PK7l+nPFZV5qcUjyWejvHeR2dwDeThGMjqy5CBexGD696IvU0p fGf/0f41YLmRvskdzHJLNLI+YlQmO3Vehc9s9Me1WL0+VcWsUjbYbmURhgvC+59hx+deNF3VyZaz RFLJeRXc0fm/aI4l8s+W+6Mqp7dv/wBVYNxeB77y3gUxAAR9ME45/HrTImtTYNnYy222OARlVyPL 4O76VlXJurVVOnLbw3QGFa4TfGVxgjGepoIMFrq6EH7yOCWY8OUi8t/w9K39NurqwjfzI3d5Iwqo /IXPOT+lNaMD/9L+M+1tLu/mCOwWMt5nzOFC49K01sZbS5UfaZVjicPH5YKQhj3Y/wCPeuSntY5x zTMzu7bXigk/1rDLE99tXhPf3VlcW9rPJaxyxlmSOTAKAEncp68Z4NdcOg4tP7jzPX9Osbaz+z2q FZrgGQyjG2665zjvxivJfNZWkQgIsb9hzx/+qu+K0RyPqfpf+wjrQGul7iO2u4laS3gkcstxp05Q Q+cwHXbvRwMelftX8Abl9M+K3gLWntbjVWGtxaNcahJdC3t44pp4l3yxAYJB5GMDOB3Ff3n4PcuI 8MJUH2mj+TeL04+KNCVvtw/Cx//T/sp/ZY1e31P4YaHOIBEl/YR/Ln/UGJRHj6EAGvyH/wCC1tg2 o/DnVpY2mI+yQskcabcCC7gJTf2+VpcV+ncGqOH8VaUZdK2/pI8HxcvLgitLvTX5I/lG1nTf7OaW QGGQQRBZ5ncLIUU7d3vyR+dY9nbW7sshS1mt5VLEXcI3RE52srHpjrmv9R8M06PyP8wcXbm+ZLLZ rPYQW0zosdvG0UUyyNIhzndz3znPHPNcbpmmJdXN6F1BLe4src/u0LLvBJ2bUPGff9O1dMfhRxmk 9rqdqgsbmKPUIBYm5g1KOVY9rFh8rJjJIG4HnqtZWZ/9DvYn8t7WcrNDJFnzVAxkH/PWtE/caA// 1PzatL1Jo1uCjqC21A64571HqKPd30UFvaoo+zjY8P3pZc8gj1IIr/aHY/yXKtzo6vbWM8+yGW4n a3ubOT5ZWUAfPxzgHOSPSqt7YWzNb30GIH0uQ2hjuZm8i5VwRvVPUY6/QVTd2+wFP7etrN+8xOSo 2NHJtEbE8dvqMe4rVkaDUpkd38wNGPOWX5ZQRzw2fbijkdroT2MiPSbd78PHIpdAyxuZ8GHjJB5x zitueeOP7NHavcGVBtv1SEPCgPQ7vbFQEtEf/9X8u7fVRfagttAp+1hSHzH5RkjQ7S/TkDnmtp9P ka8t4V1Cfy4wzRwOdq88tx1OK/2gP8lqcnYkmHk3FtcQTeT9nb9+Vj8zgdSAe5pRHBqWjahd2NzN MttKFkEyiFlViR93n9CfrQbxlco+HbcLJfwalYLJbSQYtJvMJdWwfmK9CAccH0rUs4XstJNrbjzw oxcXZjHmnHQnjvQUZmkyxpqMIntBcSs+2CZuNuTjBUdc9MitO813TW16e60YSQ25tkt5WLSJFCwU hwu49NxOSa2jeyMp7n//1vzTjuHj826N5lPLYMirvRu3Pb8R0qtdW6bLGWcqqzZaCRV8wp1xn0/+ vX+1B/kq4pjUubqOKSOOLcsgMMMjHCbuD+f+ea1P7MWy+02XiESW93JAHCTJ8zlgCMntwc/lR6HN UVtGQWirBe2kOn26zfaSUeSM5aDaCQSPTg85rX1C9szNFbC4tZLyKTb5XmAsCB1/pTd+pmzG0uKQ x6ncCAyKj7JElyJXZ9xBQHqBg9OKktZ4b1o7O4iMXlyjzPLXLov+7/SkI//X/O4S25UwKhuIYwRG Jv3YGOBuHb/61U7q4eCOO0xHFH5u+VbVgY3A/h6e/Wv9qD/IZq6sX4GnSO5vrCdrSxXdbPEWDSzi RSuCOpGAenH6VTnu7WOwitUUTgL5ckOxgJCD1bPH5elUpOOwuRFOb7TJbqjRujW/Kw7SvlD0x2q3 o82rMt8pmgjtDGnkho1ysilsnOMjg449a1TurowqR6I0pAsUc07SxySbd4t3OFlYDPBxU000+r6Q 9zqsNpqN5c4WygtIjvtVBA6Z68dsZBrWMktGc7irWP/Q/Ny6TWYGt7KW2mtHuF8m1guhsnwMYxn1 z+tUrVJw17brKRJbj/SEiwZDz0/TnFf7cH+OEo20N2y0+6tdPN5cW7h5HZ40Vcs0YGc/oaq6O99f 3DXUXkpYuW+yxXEgMkTYyBIpGO4xnv261cEupyzi9iaO9uNUlitpXae6trdktxHEEJAYEgAe575r Pv7mO8v7rT7+HzlSNLWSUHYj8AHDAclcFSfxzUvcIppWY+7sI7WFVtpoh8xaCE8BRgYGe/fmrEt1 PcWdsl05eSCERRqDhYz32n9fypxtfUid/kf/0fzvl1K5jljEJYK0H2a4BIEcisArZGPriluUgiV+ V8tY9/mK2FOe3/1q/wBwD/F8pPa6d5bW+rWjXNtcxC632d55BRVIYeY69OccdeK0I7zTmgkn06MW xMOI13lpMYxk5wfzFAGbbaoLdVGXRlPJ4GT0/Crjrd6tHYQXc8nl2t6LmGNUDTYH8IPUg9cUGM/i NeWa3uEuYvMCm34zIPL2nH/1xVX+z5UgEM1zGkZYyjySJDJkcFzgHI6Y7UC6H//S/OtNMDXksN7u mYQr5BtmAjQEA5Ygc9f1q9OmmTiO0FsFuIV2SO5+/wAEgj8MdK/3Egup/is1pYprHHboqoVaIkhg pBesrMIuPLVpTGJA7ZH3cHIPpkVocUl7zNq8hleexkF3DLCFDiURbwy4+4wxnII5613WhwK91bSx lX85doEI2gY6lV9ueKuCdzmxKvSaPXvC91bp4n0O4tLiR0t9Xt2cTH7uyRdzHHXAziv7M/8Agmvq Eep/BjRL2KQD7VZq8gDF1dlAJx6H5s1/LH0r6SfB1Cr2k1+R/Y/0LajjnWZ0H/In/wClH//T/sc/ bn0+PVPgh4msjKYXeBpIZiSqhgrBhnpypwB6kV/DX4nh07T9Z1KzsIRA+j6jNatCr7pQBIxQsf8A dx+Vf6GfQ4ryWU4/DLZtP5rRfmz/ADU+mdQX+tmDr9eS3yd2/wAkc5buzzRzMz27SMdkyqWCnBxT be5uNNc2U0y3MbO8yJcRBly4wWHcHgdD2r+3UnfQ/iJpXaLE2jyNYi5BL7QXed2AyD0rnpo2VVhU eZtYFgvNXC9xNJqwsyXUcyzWhSKOJQ0gnhEmw+uM49OK6CGKHNgzTIJZ3BMwTMSNkHkDpg+3atDn kro//9T5rlvma8uJrqUxBINhUn/WcgYPrnJ4qlP57xONMsd8bz+alrApZgGPbvnnv6V/vpT3P+eS e1ilJfGSMrFHIkjKFIYYeIgYYH8f5VRWScxeUwZSDgFe/wBa0MjQWQSrFBKQHhY8OMsPb6f/AF6k l04wL5py8bruU+YG2Z9R/Sg5amwkVvIyLbG3iZZ0M0UvmfvMocFcZ79fwoaNTF5LoVwQCOmcUGO2 x//V+V5ILuZRFaFE4yQTtHHtVmCZIGt2voFl8lxmI8BiD7V/v5CS2P8AnPN/W9esbiwht7aKWKQx ETELhAQfkCn8vyrhWup5fLikiEnlDf8AaFOCemFwPzrQyk3excjnkaWK4EWZFXzJBKofYB/eByPQ YNX7m4a+kkkWwhfzIsGK2jEMcW1QN4UYA6Z47mgIytoylmVWhkYgRxpsERA49KnEolJtY4QZZQDF O0mxI/UH60Eyd2f/1vltDe2UghlVHj6goxZQTjkZH+cVY1SykCCWaIqsYUgxuBktjr69egr/AKAY 7n/OOVGm+ztDHKDscA5xng98VFceRFfRzQLHLbySZ8odY/Y57f0rXlitB8zJJIQLtpYF/c7sorHk D3pNSt0l2XyxKh2eQ6xkiMlf4iM9fpTSsrEt21Zdijs4bVJLSF0keLZMJ3WcsxHLKNo2jPTqfeoY LaWdpJBwluoMjMcd8DH50xRfMf/X+T7tBb3IKeXJJIm4gc5HTB/zxUtuCoWUKN55aFuQvt/n1r/o IP8AnElJWsi7cajfTWP2W1ihtoluVusqn752X5QAfTnof/15SiZbhvNK73Uo4dAeT1NBkWXgEeNr fMvIZfaiaBbtFaZ9k3GSoHarhZ6MC9GbWGSGKW3WWFI8yShgWPYDHaqRvbUXLtDaskUHTz2wJT6A j1/zmtFa2gH/0PkR0uMwytH5SztwhOcev5ZFaLylljCAOsQ2DA5XJJP8zX/Qgf8AN+WRbluFC7wu 884+tV/s8rOoZ/LTcAZDnYvPXjn8qDOb6GvfZv4oEmuvtjW0QgR3GW2gk9eDjJ4HvWeogt0+zRAB x8xHf1oMx1mXklMUmVCgspfgHGTxUs2+IeY6lsNtAHAOKAP/0flxiZ5YkTLIx+dVbYR689qqfZzC zIrYGeQTnNf9CB/zblaSM7tx3LGBjgdTTkVQ6NkoUPJxgNVRi2BpxPGZ1bBjcjYHQ4yDxVqUQXF3 9ljxLPCPkI79s5oUdbMClJFdWc37wLlWO6L+NfTirHzXgaRSIDH8+xuoHORRKPKB/9L5bxH87gDB O53HAzRFGkgMiNhl43r0Wv8AoQP+bcZLaRXCeVcksScqwYrmrqjeyQAY8uMKABjNABIIzEIDGqTR ufMcsdzDsMVIGQAZAXauNwNAFWS2ju7OVYYJluYGMqNHjEw759Pb6/ndtokuLSAyHYCOVkHzIR1B FAH/0/mZFYs8cYIAyTxyAKiUPI2J2ykIxGAPmHJP86/6Fou6P+bct4Z0YpIFeQbEVlz9KotK0QaO Vf3o79qoC3byQsFLOM4I9wcdKhkU4bABBPAxQAxhLJAYpUBVeo254qTYRaTTCeFPKUBYpFbzJcnH yEDAx1O4j2oA/9T5gtri6i2GFRvzlsgg7ecgU9NRkt8p9mVvPlCMzHaYwTjP/wBav+hg/wCbckez 2r5bSq1w8hkRhwFX+7/n1qBfOUsnDMB1J4GKCJ7WKUr3sSRxTPbs1xIxg8tf3qKOgJ/p7VPFCkQ3 bAJv7wGA31oMizFPFiYSwZZk2oF/veuetUlPlyxRGOTYF3Bg3yAg8A/57UDTtsf/1flqN0mn5aOI q2xjjBbPHPHb+tOmjt0kItg3nsMli2F/Kv8AoYP+bJTfUc8UxigeJoxcK37zzOVYVXuFuZPKbeG2 vsKAjCj/ACaCudFlkaB0ClWj2A57gnqPw5pcyPtWOTBJwfagfNG9iOW380SLc8XCMF3J0x0yf0qy qxQwohleQxjhmOWPU/1p3aKP/9b5ad5ImWeI/vY23htuR+NQtBLIounmIkaTLoQSSOuc/wCelf8A Q9GV9z/m3I2uRuETkCNmG0sMoSKku2R2UqW44cFdqn6VQD4I1VWlMXmMRhDjMi89v0q/GsLRvHCm HIyd53Mvt+tAFNnuYSEjUEfxe1TxRvNOkkoEbgYDdC/1+lAH/9f5duZJY58su4KccDqKhkhimk8x Nx54Vjk/Q1/0QH/NuTMTIdvCKFwR2GKFREcO3RRtDd8f5FAENvsnnPOAG/OrflW0crTTz7BuxswW bHc4oAiM0IZ5EmSTn5FHVR/tDt/9aoo5ZJmG5SYnOAVHy49f0oA//9D5mku1tNwRQ0W3B4+Y4qG2 uWkWeJYx8yg+cWClcckAfh+tf9EB/wA24sWo/ZUbFql5g4CycDP1/pUS2qkPeSM8by8mKM5gTA6A UASjMvlgAOsZ4zwRUjZZtoGHHA44FAFW6hvvLllhLKuNrMF4H+f6VXghn8qJpWDSRjl1XYX+o/z0 oA//0fmJ3jKDKZboR0FNHlXCj7qBT90DBFf9EMXys/5txrRwgBVcou75QzZJ+tUCJnufKXPPR8YX 65rWDugLskZtU3TlQvqepoSPJWaMe+cdqoTaW5Zls2vFS6gmSGS1/wBbHK+ROG4+UY6jr+dUInk8 0i4ztRuFjbGRSbSWonJI/9L5nuLy3Z0W2tmtVYCMLJL5rk9CScDr6Ck2GONzkO4zg+tf9Ejmrn/N lKV9EUgzYRnAVyeE7nFTM/mNkRgEfL6GobuyCzYSKyzh90YXKOrKVDEc4/lVEqkk/loJFkDAgFTl 8noPrSE2luXHhjVlaaMFuibh068/hVgSKoDJksnyjA45oJc1bQ//0/CIbuC4gFpJGEnjXYkjDKuW J+Xn61n3Vt9ll8gyRF1wWKuHXnBxkcd6/wCh5xTP+acqRw29o8lx5W6adQkztyCAeMDt3/OlMhkU yFSsY6Hbg1k1Z2Am2RSwOAkhmXlXVwIwvfK4z+OapkglY2Xc6c8jrSARP33mKA6YOzpjNLLbK0sD xTvEbcYJVsK3qCKBptPQ/9T5xIeTAJ+XPJpUTazPLLhQ2EXHQD/P61/0MH/NQ3d3Y+SSJ0ZSSCF6 D+VLbCGGzIuEJZhuVEbDEc45/KgRBLEMfKdiunIU4NMhEq/LuYRngZ6mgd3sRXcG0GTJUKOp7VZh lxYjzCHf+EquNw96BH//1fmqN4W2hoyC7cO2QeOwpJ5PJKjYSpb5QOWr/oYP+afYvqEuo1uc4SI+ U2T8uSPukfhVWe1m8pmXCHf8saDKuPT2oKcmTxxSKQsqiPKg4UBRgjiqEjJHO5WIpFvwjHksCe/v QCk0y2sgi5AyW6kVSkRnMjSOD5rfuo1B3Jx3/Wgbm3sf/9b5qtLMKJPPGCIyY+PvkdqiJCDDEKBk 8iv+hg/5qeaXcPtjtHsGVikHyvipjthsi8pzMWAjCA/OuSCf5frQNTa3ILU4YxSsyoy5DY6U+OFm k3K+UVsccDrQJyb3LwuEufMs5WIRl2YY4DAVBJGY1VUYmOBdo5yFA/z+tBUZ9Gf/1/mxFhlVXjcc D+EZJJ6mkkjkiRy2Zd7ARoowQOOtf9DB/wA145bWMwiRwwuRJhQDwq45yO/P8qem6ONiXKY4PbtQ BSeREVpFySfuHsx7ZqdLlljMjR4k2bCNuXI9BnpWDd3cNhflULIEcDAJR/vClSCN5TLzkj14AHak aqaZ/9D5vX/R5hL5eHPyiUD5sUkkvLFQrMzFicda/wChA/5trmdLJbysEcAyLyAT0x3xV4XcaWzQ xxRlyRtdvvIR6UnJLRjGxyTwlGgmCz5D5HO38KlQOVZZLchfvecRgN9P89qyk7sCK3lAuyYYwSq4 BzhVJx8x9cVcKiTg4YjO5SKkV0f/0fnSa1tRA8iFzcMQoGfkUZPas6RFiIjkOBIMY7n6frX/AEDy 0TP+bZNPYtW9rcx2hNvHK8CSbp5NpZUDcDPpzxz604DzWDMCrJyPasBku8MzPApM7N85B+VhwAAv bv8AnW1YadPLb3Ja1UxyLhi3BY57f57UAc+63FtI9tcFPLQbYQBhlHXH51U8hp3MY2ksvG4fIPrQ B//S+aYFkbapUEW52nC4HHX/APXU91atKwngkEQVgPJB+Uep/wA+tf8AQAf825IRHxuVnYcOQcHF Z7W8cKeeg2rI5BVny/Hf+XNAFmBiVgkt5EmG8HeDwV+tWtXgiRwGHmLnfvYgMB6ACrg0nqBioPOu EaNPJhQgPnngdfz5q5LapdfaPsYLvDgmMH5245wD/nmqlJbG8dj/0/mRLVAn2kiTeq4K54yfWoyD uG8rF5hCMP4Rk96/6AD/AJvyYhmjW2WIlhkEICzHvkCqroFWJZGcRrIGIjxvYAjIHWtFNJWAVEhS 5O4MY2PybhgsM8ZptzFbqxI2wwqNzHGEX2queIFiIwTJGAqy4X5do/nTJzdWZDvbsvmcwSFflYDj j6GoUveuxNXVj//U+SxCmfOkPJO7nopqe31aaB4olijJeTarTIHQgdQAe9f9AjcWf83MFqaxQSyz SGKKKU/vPljEQ4HI/wDrVl27W6TTXTfNPOAhcn5VAznArM2La2lu0jjf85USDA3Zz29qqmNJZYzF ct+7cjY44wMfMT36nj2oAvvNH5kSlkKrw7KMhvpVO9SCIpJBLExc/MgOSmD3oA//1fkwSm4kCsAE XuK0JIcRxqiEKy71bHWv+gA/5w1PTUyg7oH3Lh84XjhqVzEYYvMt3iuSDukQ7wv4YoE5voR2qvJt ictIw4DEYJ98dqvLBsjeWQkKPlQZ+8eO1AuaWwyJ+235gePatAxmaRW+d5FQ/JnOR16VLWjJP//W +WYr5GiuY/szNJt/cyBtqxEHkkY54BGOKq2zHYtxI6lgdvl5yX96/wB+D/m/JLsR+UsrHbk9l55N SCa2aBIbeN/tIG1nZsxknnOMfpQAxkWP91nc3cY5Y1WmVhIqxQsXxhtg+7jqTQawl0ZHJBfQ28t/ bI11HAym5WL5miUnBYj0HPT29ae14kqlVUmFiDHNs2ufTIzxnjj9aDRNrY//1/lOGxtftMN8Lh2k hj2EFmVFJ7Bc49OtaEljfagkksFrcTBW8omKNpcHGQMAenNf78H/ADmc6MyW2uIfLMsMn7vgo+UJ weRz0qFJ/s7m2ETwHyw4UqQCG5HP05+hFTJXRSd0Mks7yZVlR2Ty3WRmzj5QwzVpFkkIQxmRm53Z 5OO9YjJyZoXe0ngCj5ZAWXDEAHH86uROzyLGs+xD03DgEUFxs9Gf/9D5puLe1Ky752uJSBtdMGMe oJz1FYkdtI5YwqshAwoJwePSv98D/nXBHjmzsgl3hSjStwpYcEfhVqS3lsbRJZJdk0ykKqHDc9fw rKad7hdbFWNo44cTJ85berdePSrFvN9pWZHgJRvkRMgA474/p703G9kwHtcSwwyR23+jlziRoxte TpwSOccU6C+Y5Wd1C7duW4JrO1twP//R+XraYRSykliGQqvlcP7VUmUqClwssTMpZC8ZBf06461/ vQf86602KdvaPKILbfLHCspmkii+TzM9cnr2pttbWonuJLHzRJuMbS+awXB6gjOOfb0oNoO6LzxX MCRhXRsks6jqG7GoFYQuk0civOWBuE255Pt9aymncokBNxP8kUqRW+DeXAOYYQTxkdue/vW9JPHp tmfsE8N3LcuQZDCRJAg9/fH61mzZSTdkf//S+Vo7lLuXIJeQHbg5yD7flW/GhkspU8xw4bIcMSBg dMV/u1V7H/PnhHadkfs5/wAEobBbjxLNAyytfpfRXDNN829UQspB68FCSO26v6otX1BbbQZLuRB5 UdoIyqrkHC46fhX+Xf0kqrq+Jjh2a/T/ACP9kvo4UFQ8IcJNdaf46s/ih/4KCT28v7QN9qUO/wAh 4LnDCVQqI95KAMdScRrX5efHTU7Ww8Ji1tUM8bvLdPOz5E+EXbkf7JByPf3r+6vDxOl4cYVS3VF/ kfwjxW1V8ZakU9PbL8z8PfHhf7Tcu0wlZpfMIiUBiCPuhfpiuItYQ2yRg+0geWjjY2fev8tPEGan xZjpf9PJfmf6ocP00spwy/uL8j//0/5IPtNxp8jRiISKx/eLKuR9Pas7Ie8edI0hjJBWEZOPxNYd LFuD6DrqdpnkjIWGO3h81HdsK7Z5RQO/Ss1LoiSGZTEYZm2SIjfcxxkVjPccI21ZellYqERjGp6M vBaq8peQCNVYGPluMbveoNEraFKO5kgdWkZ9wb5l6ZGeldNqN9oU9lElmkouY4w7IUG2Un7wJ/lQ 1fRkQurpn//U/j+uFjkhDiNVL/KFXgf54qlFZFGWQqu1fUV5Ml7x0GjHbWgDSEs0nDqw42D+6az5 pA8cgY5IOEABNSXGLuihaQ3MMxW7gKsw3pKr7oyp6Y96vyzvCrbTgHr6Um7I1ITqVvbbDKCxlUsG Vd2QP/11cs/9K8yVNzRtgo5XhKSkrNkqMUf/1f46l1AJJJCTvPm+Xk8A4OOPrV0XKAuxiV8Jgbs/ J7j3rwudndLYz/MWVY3RtpmbEO9tikntz/ninQ/2jDqckNw9jNZRIPLW3ZnldiATlvu4HtULTYjm SjYZq05KLEIwkituJzkY+n0osb8PGLedCVj+cFe+PWtOfUcHqalwsd4FVVAymRz1FZFtG1pceZGd kquSCpOMdKhu7uaH/9b+PS4ui7BWwTjLMOMmoDO3EcTkSv8AL8xwuOgr589KGjKxieNgGeMzKfna LgdeDV+GF7QrM6rMZE3qm7djPTOP5Urq1zVp3Qtq+WcMA+842E8n2ApJWK7bOW38mOb51fIKgjIx +pqXNW0GVUgXzmjhn+degU5JGf5cVantikc0tqgmuxHmON22qxFRGXKZT3P/1/40bhb6FgWaS2kn AZkQ5j47HtUtnPKXl3YdgPm3ce1fMN3PSSd0aodY5YjuGIsOXP3fpmrV3cq1u87SxJGFy+7H1yPe kbGdpiQbfNVSFkO7G3AP4VLdXRiLSRH5Iz9xhkN26VUXysuEb6scWN7tfaEGACPSpbiwvPsrfZZG WVwViQEDd9M1XPrpsan/0P46tO3yFbeSSQPtzOHGwxsD0A9/Wr8tnbrcRSTFpPIbesWcDPr+tfPn 0ApjnBwL2aSFiXS2kIKQEnnH1qG6hZ0DQ3DQyqwDFMEsM8jB9cUAOVdpJDjC9MHg8Ui2iXMmU8sr yWjc5Q+v/wCqgCKO+aHUJI5rK2KwWwS2iYERvgEdBjkdeveoYzutjbvsSdyXMSNvRScnP9aDOadz /9H+N7SlRZTcloTIknzyQjzCyrwA30rrtSCwQieGKN7q7RYXd0CG3RcHcB68Y9ea+fPdjrFoy9Ph ll8y4lZWhikyjEhd2DzxXd+FprZ9ZskgTzjO2xjGu8YI559uK6cB72LpJfzI8nMHyYWq/wC6/wAj 9Wvg60lppGn3IsC4aRIFuLgN5URcKhndh1wdxxX9cf8AwSHsn07wxos9yhkuo7xpYbeLcyOsjueT 2I8xj9CK/tDxUi14Q4eK6ch+D+B7/wCM/wAbLykfqr+2TqkVr8KtciW5jhVbOaOcSZI5hZsgj2Ar +Cr4uW0OreMPiBrenRXEEuoatPd3MDoQjhXYrKD23qQee496PowYf/ZcRibaJW/X9D5z6T0l/aOE j1v+p//S/lV/aw164+26fpM0LSwWsD39vOMSJDEZFGA2OpYMMeqtX5+6ndJfTbypCnCqOwxX794+ 1ObjFp/yL82fl3hTBLhKk/66GnaRLCq7DtcoMKB1rfW1jVMyhvNdcg5wE/Cv5+nsfosI2Y/TXCyz RG2WdpECxz5IMPzZyvvjPBrrlJXykLuyIAzbuMGvOxB0wWlzSikVCG3RzEZAjZ9p6cdORXrfhaaC DTbZTFCHuCTOI5BM/XPXGRjp26V5GI0TOiluf//T/lY0+6s5jcy3FxJGbTCxhI968dAfT8Ks2did RneZ5MZ4RpvlRfpXwc+x6MVqjlLrSGvRdQC5iiNrJ58oYje6BuUA9wf0rZi0S2vTBqCX/ly2sBhF oqGNoV4G8N3z/SsZJ6WNkrXNXRp9Tt7S+0yW6s7nTvtGYXigV53UHOGlI3cEdAccVffS9GldJ0tb c3Fy6o0roMqRgBmbtj1rOSd7sZYvrd4AtvZvFdtESJp0mE0Zx1Ct3x0q3BqFtpaW8w01po1mC3kt knmz7iR/D04x+neiKvJIdPSbP//U/jda7tVgsLqMebctOBOGJQeWSMPgD0yce1S6zpmm63ff6Pc3 cYt4jLbeZ+6aXgDa+08ZI6c4rxKexCd2hZUkRLO3iihtndNl5eMzSICP4vX8h2rlknsZLq50+e2+ 0RZIh1vT2YzwuRhf3TEDbnrkZ5pWfMhVOhuxRW8ekht1w1+9yEQDAUIOrfn1+lV7fT57pWnlYMqT bMZAIFXbW5mVpNKiWUssoZQTuBx5gPatG3tYFLQvJ0jDF5Dhh24qkruwH//V/jibSm09La488fvQ ZVAffuHqeePoa04dWWawubYRQyyMQvnAZdcHmuSC0uckpNOyM3UfMicG1i86zgtjLcyjIdWwvAX0 ySM/Stq1gtZdIMzI8MjQGYzMvDfLkKR1HpXZCPQmnozyzVoQji4JZYoocCIL8seM9K8zMLXN1JLL EseX4UcbgOlehBXsZvZn3v8Asg/ZrTULjxFDHJFFb340trIkJDcPtDO+4clsKg+h5r91fhjPcv4i 8DyNDbWc+jeJbW5ltSmEkxKG2tjk8kYz6V/dXgc+fw8rR7KX5s/lDjiSp+JmEf8A08h+n+Z//9b+ vb9ju+iv/hPo17b8219GJbJM5eHaxEiH0x8uK+Fv+CwWgTzfB3U9SOli9trO3kuLmITcSsql1DDP QH5vw/Cv0jJuah4oQi3Zqtb/AMmt+Z43iu1LgWvUirr2Sfysn+R/HZq9ivivyLjTTbwxTxxxwQ3D GPZkDKytngjNc/c+dN/xKD5PnpGbURrt2SEZBwR97nPPOfWv9SsH/BXof5dYvf5lNbO6tVFuJVfy sReVu2rGe5A/D9BT4La71J7uyt4P3ECZnuZYfLiJIwRuxk9MYrsh8KOS/vWKKQT3E9jaLPLDDDJ5 ZjiAxtGcrzwAazZIni1tfNdvsUiNBc28rElN2AjRYxyOvJ5qhn//1/y1uEvNMeHT5bi5MQYyQgDd 5gz3JHFV7WbVCNQiSZQ0YM8LSP8AvMkgAKfUdce1f7QH+S5PZi8juYZ7y7iu5Ui2xyiTzTEG5ZT6 HPUVv6q67f3hzcQoBEiQgqRnJyfy9aBpXdjGfTJ7ULPp1pNerd2/2idLgiEWz5GVBJ6en1olgCSy yR2YF2ypCoicK8iZ+f5j6dce1O7tYqUbbF+w0ywmhvUe1CSKSzLcZJY9iP8APapNLieC5FmWRYbi MpgfxsOUX+n40iXF2P/Q/NO91GN7/TbiOxjS402P7EiQwKitGxAYe5JA5PpUviIX0I0pfsUgbyMt cvIsews5K4/Pt6V/tAf5KxjyotQ28YgeyV2d5g0gwN7PJtwBux0zj865+zgvZdJvJlWeyJXbeWh5 24bjf7ZAoLTcdjW03xDbfJYSWkTTw2+5rkOY1YjA6d+/FT6iTGLi8sL2WOFoF+12yEGM5G3t7mgO Z3uZmk6fcor3/lzztxCpTLNHuI+c+n1+tNtdPu0v/I8qFELmRTIR5bgcnOePXj+dbx2RnKbTP//R /NVtXljk1CO0tbWNb22Fq6raq0IAI+ZVI+UnaORg1E9pdTyx3N3LH5UcaokUXyxKAMdPU+tf7UH+ STk2a6ETW39mRWUwiQbzN5m0MW/usR1BHrms27adbK1S5tndhCscvmNlztG3OauG5z1JW0J9Gnht by4+z3Fmym3VXjZ9s9vux8oB7nvjsetWdUuLS4aBpoLOKSJTBDcLAqSS8k5J6k9s+gq5WtqYSnpo Z99I8RC210gnljCblG4DsPx4qfSPtcN09xGspkjiG6XAPmkcY+v+NYk88j//0vzauYr7UdTlmuW8 v7QSjRx4VXHGGYY4PH+c0Wmmyrc3VrKTi2iLuCf4OOQfTBr/AGoP8geZ2sQzTW9nHDbpJIIT/q1B Lbvqac03MMzxlY2O1C4OB/tcen49KCoPozora4sTpl9e6nK11M4aJQsxgnUnGwlsHI/X6VUi/s6w itLeWZpWuWCrnMzsT0JwM8Z/CtofCiZtJszysn21obqQNBHIxjECAOo6dep4A4PvXQ6TdRQRSNYW kqSIrCJ55R+7xnLhR6gHiqOZu5//0/gXTDLrt9Fb6nbW8s1pDJ9kknc/u1ILFgT6ZLY6cVzD2h0W OXyZINQ892i+2sx3oFY9NpxnkDkV/trDY/xzn2Ok0iSSDTftMtz9oFwGVJG+7GOVIC/jj3rmNJQw XckEbM8VzMXcEhIwxGFOOntVnNPc2r3TrKxe1uGtXW9swy3EUcxC3CswIPbHHGfSsm7geAyXs2nS wWcjb4CfnSRT3VgTnHSggi8mW9iF00Q8i2yUIUBlH5Zq7byQ3cUDHy/JUYAxtZ/TNBE9j//U/OyS xjUlw5RpWyI924Ljjp1HStB7GKe2FvKjGJo8TydQgPc/XIxX+3621P8AF8ztUtbexgjgjb91JGEU Fg4P+fSprTTbZ7XeySB0G0yf6sMD1HIpgYM2mXGlXLGfEwLhktZDvXDc79wPbrjNdvC6R2Ed9GWO pY2qsIaXyUAwG46HnGO1BE2tmZ9zZJHEGMkTz3EQaXJ+92II7Hr+lFrPbzLt8yOErD5SLuy42jkk f0FaQinqyL2jY//V/Oeea+i1ea10osLT7NGXumjEjSH5S429gCB+lbUptLqBPtEG2+QbWmQbBLjp 8vbiv9yD/FciS2FujXRt3WIkqquN5bHYHHWsUj7ZJN9ltpEEC75t67MZz0z9D0oOOTtdF/Rrw206 KGYygNJANu88DnH51ueG5bi0urieQb/OLRwQrlDbKxGSR64raHwnPUs4O57V4d8gz2rW1q+yGVZJ 5yM+UwyykDPJyOntmv7FP+CYJntfg54dtjNLMYrSCKTfGIw2+FMtxxn5elfy/wDSqjfgam/73+R/ XX0Mpf8AGU5lH/p2v/bv8j//1v7Q/wBsLTDqXwe14x3AhFrA1ztKbsso3J19wRjvX8LHijS2g+I/ jyKVWlisvGFxpzq4AlmaOKAuM4/2uOuK/v36G9ZfVsfS8r/ij/OX6Z9Dl4hwNa+6a+6/+Zxt/qEm mS7otPknsppxCiuhjYZxk5I4K/0qLzodQCnZuvEX5mCbV5Jwo9cYFf3bCSWp/C84pJo3NMk1XzAq CC9soIlfVIWPmIY2YJtKlTtIJHzZH1HWnXelRxCKaxgVllkbfIHDNHj7oPf2q4O+hjsc3LLrV8k9 nOJJLVZxM5jhCMmz7qswGT3/AFq1pEEF3cOtqZCYW8yaKVvkjIwMD0PU1Zyydkf/1/mPUGnkmmsZ ltysUgljkXHnSYXufxPFZNpc3MN0Qrvg8rj7seK/31hsf88VRmnd3V7NAsZaIlJNymO1jhbaOxIG W6ck+lVGMhQPFAmA4DIzksMdTnH6VZzOTegklmbm3ur1WjtpzLgLnJOe+KiWxcmJ47omO42wsCdq q+evuOlBzyd3Y0tShe2jjAIJRQN/Q+9UJJrxLVZ7aHzGMgjD8bYz6n8OaCT/0PlIG9tyhaUPKGDb mwqj24qdnW9vIlceX8uGdfuMeef5flX+/B/znN2VyTaJofJkOxxN5aAjlx60lpaGKXz49kkUMgEw kzs/Eda0U9dTFu7uUZ/Jv7t5UBtdz/MkamONu3Q81cik+yz+THl8fKHHQitBEU+WcnbwGx1wF61M ZbVVhkihczKCsju4Kk56quOO3r0oA//R+WpLt9yrtDByAvHPJp2qrLI1rC00jIV5jTIwR61/0AH/ ADic6v5EL2MjGMINzkcBmAAFTW1grGRpG2MvHlfxE+tVqo3KbS3DyZnmhhjZUXJMpc42gVFeeUrx xW4neN+Xd/8AV7h1xzwOBVwfQzlK+iLQSNLiy+ZooD+7uCF35JwFOKuG2EjS75T9m3eXmM7Cw55q yb20P//S+Zfsdq77d25oUIWRupAHTNZaJPJcRyQqxWcYijxnPbp+Br/oIP8Am/2L0DTx/wCiyW/7 yKYs9wflJB4wB7Y/WkuFjU+e5Z2BIwQAgAAxQSpJuyHpNDLD+7ALt+OKpNEy5X5izc5/u0FEkCA5 U7mGMMw6VZjNtCLq2McciwBTLJIokC4wwIOfpyKqMnHQhzs9D//T+T5Idt7HcCJ5rcuWW4OfJkK4 4H5jI96ngkaWaXyIkjQZVhtznPpnpX/Qap30P+bvn01EnEkw+yqki3IJEjMTGijvg/SrUU13HYy2 guI5LdlVXhdcykK2c7/qKshu7C2hAcuZDHlcFfUVGYUklaaFg2GKE5yxxQIkD/KWcFJIm2pxgMOu c0jTu6eUQdw5yen+elAH/9T5c5jMQVcZ5LDvVq4EYiDhSZDgoGH3j6Gv+hA/5tyCVZZo2mieLzLU Cf7IwCCf1H/1qozStefvI4RCcD92xzt471rB9BKSeiJLeaC0lha4iM4J2iMErzjAOcdqnjMizosK DMjb2c9VFPmV7A2luW7mNFfzBl2PGTwTimqJGkaa42qCoXbGgReBgcD6fjTdrWZLmlsf/9X5mikd JcRQJ5QwW81BIj9D0NMlkupPNjdIkimlLYgiECqDxwAOPoK/6FOWHc/5sudkkFqse1pQCU+WLByc ccmpJY3Xc6MFwMh+4qH5FqatqVnsZbcW808RH22PzVkDZVh0zTpLdHjaIS7JAmI2bJDHt/PvSDnQ lus8Ksn2hlMceHI7+v8AXiqjXdxIxjA2lBkOflVvpQNNPY//1vl6J1BjeRpllBIkKg4I6c1PEA8r zniJX24bqRX/AEJxWzP+bZtLctEfabUyW1pLujfAKZcv6YFZU/mqgdrabfkbmYABQfUdq1IjLWwk NoglRXO1GYMXI+RTmrk7SRSMkQWYqMIy5CH3oNDX0y5hSKaO4Akd0wUXAL+wJ6fWsvdNbNMsyALJ 84RcMAOwzQRNtbH/1/mMzPLbrNCNjNjh1wwHTH5VHbxErK0hyd2AD1Pev+hg/wCbJTaNCJ0YGOSM llHyOOCKpXMKNH5ysVZOCGO2gc+hPDCAImK5Z1BQn0P/AOqpnhUDBJLu+3AHC0GZTms5Y1xbyYkU 7gSeneq9qXWNldPNlZ/vE5Oc8/59qAP/0Pmr7PDFuDLiVT8wIwSaqzyLG6DbgydDiv8AoYP+a8me 3YRmQrvLAAjpxSLFvXMYAHXp1xxQBEAQW35VV4GelR2qGKUEsZN8mQcYCDtQBe8lEnuix3zSNy27 cDjgcfhUcm6KDDQB9xyJCOQB6UDTa0R//9H5khaNWVnKvEx2mFTiQYx09P8A61WJrcxuOPLR1DAP 1CnkV/0M3Z/zYXfceksUJaB9OS7W4jxHcltotmGDnHfvxWdeQlUIZBufjHZaE2tgu1sSW3zRqmV3 IOR3x/kVIqCA+bgnJ7VrHbUam0MkkUkcYbrz3pkyvIVdSQRgcdaofOz/0vmOT58SMfurjHrWcjMs h2KSCck46V/0QH/NkpvqSTecqgrG5DtjcRhRUZllKqssZRQdnmHhTj0/OgtSTHC3eKdGiOUbG49h Vm7tgSFyCf4iDQSp6+RAsESYUISzHBPrVuFViKwg4UHgdcfSgqMrn//T+YruMruKRl+eijmn2AVQ 7Tw4Qjay52v+n0r/AKID/m3J5ba2VX8r/VysSsPWSP6nvVVW3KYclFHY0ARLHIjboicZ2n0A9aZt u18+Hzlkd5T5Vwke0qvbg0B6GpFOyxNb3EhcZG75QCSBwT+f61m3BnW5VV2pbCM5HV2YkY/DrQS5 JH//1PlSCG4ny5lVhGxVcHGOfSq7+dbSuJSoJbAAPftX/RAf82LbvcndXkEe9DwQeOnHNX8XAMTi B4kA+V9uEkA4OPWnHfQOZ3uVLrzJCshBcJ/BUqR3bRxFEILruEZHOPp+daylyibb3JQzIyhch+jj nBFVnQiTcoOC2ccnFZuTegj/1fl3dukiLJ8pOc47g1sAxA4K5GM5Pbiv+iA/5ryt5cl1OhmeFIYA TbhYcSZPJBPfPv0zVW9tZbgybd9sAPMXyOGyOcgenB4oDYqXl3eeXayNIZAjBZcxYaUjjkjnPTrz VqW4eeZHnIWQ4+QqFJ6YrOUmtEYN3dy3BCkjy/aGkAEZEJC7sN2znt9KjiQq2zHyA/fPQ04yvoI/ /9b5ruk3bEySMjJXIz9abLbNFCdjF2JyMj7g9K/6HZStoj/mnHRSvMqxyLjGAvatUhDHsIL+WmT9 P8is27gR28P2jdHbK5IXzCpHz478f5xVKW2lidwynJ+7kYIFF7aANSLYDI8oVlGNnds9+lWI/LCh njDrncQw4OPX9KQH/9f57aWFI8xqS5PK9hUE8Mr+VIFGCMtzkjt0r/oYP+acXygZMvyMAbQMAdqm YRGVS8n3RjkYVfwoAYwiEgEj5VlJQJ9OP1qfzYTAqPgBGwpC8tk4/pQBG628ieXIzb842YwQPeqz JHD+7A3AevRRQK6R/9D52DRmMK+04G1MLyvfippEtpEtwYSPJBDsXyzZ6kGv+hg/5p7pmTDEtvdX KWwkmi3+e7upxyeM9h2rajvcB1lhRw67UOcGPkc/pj8aA8ipI8kcqzFS0Eg2qDkLwMcfpTXlghxu t3lDsFRQwBTJxuPsBzigBGTzZQI1KxDsOcVKIljfKYK5x82OKAP/0fnuRjDlsbyTwvt3xVN9skn+ pDBVJ54Ff9DB/wA05AiPcQ+S20KXyvHTtmnmxkK8EstqMeYTnAz/AFPagBNvchTxgHPTtVq3i2xN JnALbTz170AMazLssjSRorDcGLYUAdzTo3hudPjngSUZkaFi6lVcr3XNAH//0vm6KB4QpyFzyAeO nFTTSeYwKqQchflHA9/0r/oYP+afyL8aSKVcQNIsYwzFcpn3qnd2qeWS2Uc8+W3BwaDSM+jIMqkY RUVQgGSRleD2/KoHT7UxkjBQgDHcNjv+OM1zmhIPMyGlJ+XhgRzVmO1di8se8xcFzjhScD+dAH// 0/neSExZiwzMy7tzEMFBGeB2qnbwsTIFwAg+633j64r/AKED/mwu9iF7WJ2JKFZVGw712sveo4rD YGjkHm4XKHd8wPqcVlNWkNSaVkXZbKF0hVGkjnIPm90YDpirMSAolsgZ/LXBOd2cd/y/lUA5O1hJ o47dgbWMFmAJJ+YA/wCf51CiziYySRgRsM4UYA/Cgk//1PndEbyHniTzAz5DFvlGOoqJ3jmljZ0T KcYwOPXFf9A0vhZ/zX7Ftyig/eULyoXgfSsq5kcSAQ55GGGKxOhahYNcC7CwxgugyysM/jXaJrF1 BCtrPGQAdwAQKMHjr1/pQBi6tNavOFls5Wl8kSLMkqgH+IDHuDn8etYcd2qu4jRkBzsEmNw9ielA H//V+aftU5XLAJ83zBRkn3ojllkDrAApjIy0oyjeoHNf9AB/zblpVkILN8vGG9KqPbROUkDMDG3I PKn2IoAdaj7MszMd+clFUYxUgmkl2xzw7xjKsvBQY4yPTpQA6aeOKNQkIYFSHPTaex96jhDpsn8r fFnMoGQ22gpS5T//1vmaGfzPtH2eNnjVtwDHGAT15qlJJtR/P4d2/dbRxn0r/oAP+btz00GJc3ay q2WWRz5Y/vnjHP4Vp3MG5YiMpIi/O3Xec+nQf/WoIux0cEd0hlViZLb/AFkTKUc/T2qlbS+dO/2i EvaB/LC7RhSehPqPY+hoKU2lYsvItoJI7WNHP3Vk2YCjj5sfSoZLu8uESCSd5oIcmJDyqk9cCgTk z//X+XpRFIkcacNszJu6E5PH5Yqv5eUEaKBIOAcdPcV/0AH/ADcJ22JfPlSJYZsblXBfGCfXJqNI 7aUNvTywB8mzkN6k/wCFBpGV9GQW25J8W7yFt2XJz06Y9qdNC0T7lRlz3oCUraIoyRzrIuN2Opx0 oMLzgpEhBclnlJwQQMD/AD7UFJ3R/9D5asbVYo2jnG8spye9StfLlYY8EWybFz+fP51/0AH/ADfl T/XQGdk+cHAyOM0tnJcyX26UDc0fl52AogI25x9KAJ54X027a3m2s6r5iyIQUIPIPFQpJ5iGOUqo Dl0bb8znp1/CgB+6KONvMQhidqNileGdrZZkVi6c5X5WP055rKUnsB//0fkzT1vJLm6k8vbmDbGk 3yh3JwQR2wDT5IWjc71ClDkqP4TX+/B/zfkouFLBXP7phs+7krUdsB5sg2Fin3WHy/SgDXsI7e7u 40mle3mSCSSNwgYGRBujU5P8RGPxFZ+XeeSVVePzGKuZRhhng5+vP4GgqO6sLCbvTmZICjLLE0WC N0RDDBUjv1qK2sW+wvJNPGk0c2AmD5bqfT0NBsf/0vlqWFA5hUbTtDeYD8hOOaj8+482SVJGLIRu YdBjj+g/Ov8Afg/5xx3lybol85maZsN6JzVcrbSSzpLNK0trtRSseC2McYPbGfyoKhvYn86SJZA8 imKVBGkO0h1AwdxP4Y49DVvZBsjeBXUlAshZ95J7kDAwD6frWDXKbFV4ridLgRrNLNtCWxxlck4C /wD1q0YlFrC1hd2uLjzNwnI2yxEAhkPsfT2pAf/T+YbG3tjqE8E0kltEAZpVQZdzwNqnoM+/pUkD QWeoyyBGkg3bIY2xj0BwBj3/ABr/AHwP+c8ll1C0W4WFrRIVUli8RCgg+ox1/wAKpy7Zm887xHE2 xVcZ2g98dKLdBp2dyk8DQusVxIjdyyEMuDyMYPoaiBCHfFIQV4THT8qC4S1syzBHujBdwMMOvJar i6N58U14ZI1hiOVZ2CBh7f4VE0rXHKStZH//1Pla3ubVJTLGrSnGFG7Yg9/51dupba5VmmLbtoFu FkGIyCM5HOfTtX+9B/zpwlrZkIZpJkl3kHYcyNz5hAwBRJPGlp9iSMqGmE/yLh2YZAyep6nj3oNL 9irDIXleM8SRv5bI3BU+h9ODWvc28i2+9FgwfkeSLB3EDpx3Gf5VMldFKTRm2cpjR0i3lpX8q5hP O7+7kd8+9OnSVnaDyngfOAjrtYj2rE0U0nof/9X5sstHtoJFm1AXEcKRllW3dY5HcjCAkgjGcZp9 qZoZNu6LaJCSCfkfr1Nf7uVE2tD/AJ7cNO01Y/eb/gj/AGkj+ItXZ7RGurjUUBkUMxi/0W1aXYx/ h/e/hk1/Sd48uv7P8HXtyke4RWoMiY6KFYOfqB+tf5X/AEhXz+Ks0n1if7QfR/vDwawd+kH+R/Ff +2XBp/iD446zeIkUS6ZCbGONZDIJklkectg9cFyvv+lfkj+1Da3FloAjj8q2R70pAlscXE25YmZd vpgr9K/vng+DoeHVBPpRf4pn8A51VWI8ZHOGzrL8LH4y+Ib+0mlkvpLR2bzirZQJdHB2kD64/DFc lc3USCMNFIXmlEcK55TJ9vwr/KLjWftOJsdP/p5P82f6w5HHlyrDr+5H8j//1v5G5FdH+dmJJyQ/ JxUc7RhdkK4kfje3auc6DJklkbdBKoD9AScbqpC1kSRpJWRIYkGxFBDOenT8qynuBtxhFgTICv1A cc4p0sgj2qJFIYZZcZJ9qgDOaaF7q2DqXG1sxsmFcD3/ABoEOFYqiI3Kxr2HpQJbs//X/jth+2A5 kxGokKx9dgrTgsZbiB/LmBaN+ED4ye/FeTL4mdKTew6SN7ZET5jI+FfHT6VLNbRxqoWNRuGWx1FS bLTQypcSSAsxRY+ijoQKsG3R7Uo4LvKdyZPG2lLRMZTm+x28KQlA2cQwoq5yfT26Vatb+Q6dc6XG xt45x5TGNtphYEc/z/yKxv0A/9D+OqPRntQ7NMrbjlT1Nag01/JLKwJVNzEnGa+fO6TsjAksppbi AOPMW3YvFj+DIPIrQt0BV1jfDg/NIV+b6UERV0yleQM8skjBvlTZvI+9UVohijaQgFAcE+tBUFZs sRSI+54HOc7SPT60XqTWkKXcrQAcrKolDToR6J155pN2Vyz/0f46LLbPDFLgOlwmY1fKSKe2R2/G nS2boC3JZuNwOdnavmXJnpQ+JDLWGSFGeYrM+7rjGRTpS0DSSq/3lGF3ZCdulSbE1iqLIDMcn7wY d6Zqsc8+1LaUKVfdvYb1A5OBQBRs2lhICqvnj5fMI79/8+1b9u2NzFg0ijBJHqKDKfxH/9L+Oi/Z 51ZXPl+XzvIqtZQRPFswSX4EuOTXy56N3oPlhkXEaMrQwvh1Jzk0kQzgTpHNE0vMT/cAGOD7cUGs ZXRuO6SKsEVulv5a9FGVI65B71j3Sr5SsDsEbFQQOZCfUUGkZcug61hYWrhZlNwrFgH+Ut6A49OK zLoa1Jdq0F8RZpjy7YLkxt/EVPv/AEq5R96yNk+qP//T/jkt3ulutuDNKE3zzNxk+g962bd/NSd7 gYndCiDGAg7H618+fQGfHdJCnl7XuGXKtITywHf/APVTYbrylSSWNZCzkSAHBjHOOO56UAJNDHqa 6hd2100M0KIfsCoEgYjjC47nqcU7TphLaxC4ie1Y/KSB8wxwTj86ALNrbJesfP8A35efbazSnY8Y BIyfTt19K11tLe2S4a3ktWunVo2dlDNheA3P6Y9KCJuysf/U/kAsHjttttKqff3tIihXYnqSfw/D mtK6sLXU5jJDdXKT2+3/AEdMeXOPRienToK+fse7B+6ZcIy1xb3C+QscvliJl2rKO+Pau/8AAtyl 74jtbPRle2ngkWIoYSMHvnPRDg8+9ehlFO+YUY/3l+Z4mczUcury7Rf5H7EeANLv4fCemafIyTy6 lbG0SAKY42YDGQexw2R6d+tf2Hf8Em9Fks/A2iajKscyWWnR2ZMibJHcwRoW6c48t+a/sXxhrrDe F2Go9JqH9fifh/gBT9vxjj6z+zzH1X+37d2mnfBnWp5DLD9mR1ubhJgibZUJCkHrnbj8a/hM8YX1 /aX/AIoeYzGG68Rzz+duMkksGxI4kI6AAKRj6V7H0ZouPDteX979D5P6THv5xhl/W5//1f5Qf2nN Rkbxlb22nlZ9OWwZJPtS+Ubb58shX/eY49wa+KL6GMTyBY48OOOyoPX2r9v8dK3tOMqkf5Ypfi3+ p+Z+GMVT4Uw/ZooxNIs8aFwwBBDqdwP0Ndtb+ZKpYh52Pyg4JLdq/DamkT9Cg7ou6ZGhk8sxmGSO XeV6hl4rd1r7PHFZxxRzedM4QuBmPLHABNeXWfQ6IfCitb2j6PIHmaJ1mlyQ581ATgYGa9s8J2tp BKVDrK725uIiF3bztzjH0z+VeXidrHRSR//W/lKjuLaTzIY9sb7CxYJgNnIwT61eiuVsLKECaSeX dxvXCBfUH8a+Dmj0YPVDhf2txcSX1vb2nnPhbsQoELFeOR+FZ09zqJvJZLSKCQSgK0JBX5eM9P5C szc6bSrZJ4RDZm2hkmfy2Mi+XFC38W4e1RXCCzL29zJtaT9350GdjEnaCB1FTPYDG1Gwv9NsUXQ7 1LYwlXLSpvjdeS6n3OetalhLfHTg8EzNdTvmWzAPlnaBtYkdyc8dqVON6iQk7Tfof//X/jUHhyLT RFBZ30t7G77mmumxJEW5APsOlXbdIoXgivbtLcTXQilnhX7QYYwRuZgOT0PA5NeJT2MoLVXJInlk TVR5NzPaRsV0y7eMRCRhycr9O2e4qxLZwlohczp5i2yvE9rAgEhKggORj6EnJyKuw5oo4t7eSMKi zvGCyxM/ygd8j3plrfIyTf2fatbSOx+0hpPMU4OOB0HT3pxXM7EJN6IxJ9ReG82GJAWOd3dz9Khs RfahJeLJdQPMpYW8iRgCxJIKoRzkH0OOtXBdR8sj/9D+OzZLbaTNJqafaYo4tuIlKPK4HO3v+VS6 bY2kYcWURhQr5whb5my3J+vOaxprv0OZpPRj/EEMjaZdiUNbebAEkMC4ZhwB078A/Wp9Inn1PSZL NrsRH7EIkllO3eFGAMepwBx612QXukxi09Ty+8fVVS6TVF0+CWBjHHDZ3X2kyqOjHKg5PfiuGBji ugXIG09G7V3QVmZNaNH15+zDcO+vtPBL5YhlD2VujBY5nVkBLr/ezjr27V+4Pw8mv7HUdASC5umu 9QuoJru5dxcM6iVZd8Z7L8qEk8jJr+4fo/1FPgnE0u3N+r/U/kzxMhLD8eYSsus4NfKy/Q//0f6s P+Cd15u+Duj28pLCK2Ql5pAwklaJfMK/iM/jXn//AAU78JrrHwK11gkc5FrdpcI8gyySWxH3c548 vPFfoteqsP4oOpH/AJ/f+3Hl8fYb2/AU6M/+fP5RP4trbTLHULO2EJjsUjhEdyyILZZfsyiNcY5y 3l89c59689uBZy6i8JtgbW1jedb6KQKwlwQiD2z1/Gv9S8BJfV4N9kf5Y4x2m35v8ynbTNpqyX81 1Yq8gzJcXEQliIHIQKcgngYIqFtQ1dVEi3dq1ldN5v2OA+RNE2fvsg7EdvbtXdFq1jh5ru6epJFq Wmx66LORClhfReXFfO2I4bgkZLY5AXDcVR1ywt5dW8+K5jaOzHkB4WJgcA43475xke1UaRn3P//S /MdtWu5rmyQXH9oz2INuHnYZ8pyQw4HYE4rb0+x0ywvbvUJoxcRNGBPBLKNi7eRjriv9oD/JRys/ I5W6sI1vze27C2s7i786QsD5SBmyRn8q6e4t/trQvBdKWEuJp1U7ZQAMKMgevNA+ZJ2NFiqWErXR dSVP2SVBmKQocMCfwxXBavLcQrBdxqMRtgSxv+8XJGDj2xQaOTaszaH9pyy2V5cakJLq4tjFcxSR YyCAqlvQgDryeT9adrlpJYx2RSOb7ddWouomUgwsFkZGUDHqvUkfSgl3t6H/0/y1S+cNBNLNGI1j LNgFWibPAfI9u3rXZWeqWeqaSdOuVW/ku1W5EvlMptpEY4/Men9DX+0B/ktF3VyuyanaW7GzkhMM 0DrJAF/0mNgcJhvTGelc4lxHFHJDqb3KSSxeTN5HHm57Hn1xQF1exn2EaveRAxO80efLVQQsqZyc ++K7u2jF7ZXaR2XlKc7oSmGIXpwfrQZuT6D77WEtBbJauYPKt1ing8naGYKOST1+o/pVC2Ivn8++ kkWEuWZ0O3HUdPrW8VZGTlaSR//U/NXUWVLzbCkk1uiATTKAqjoFDVcazlv4rd4nEMFm2+8j3AxT qRgZPUEEjpX+1KV3Y/yNk2loWFaS4nitLVg0gTOyP5lYcfxDuKqX8t1DDdQXduIzZXS7GkIDz5Vc 4x2BJHP92qgtTlmZcMeiyTyySwQpNcMswmRiArKOF646cc/41ty6Szl11AJDCyLLZfNztIyWb0Hp T5W9yLWMi7SKUWksscUdsZRayNbybJcL/wAtOvU+tXrK71G0W3t5btJkW8d7cKAW2kKAHIHXjPPc e9TKNiJOyP/V/Ofy5pGN8zyxSMGtzAx2xDDfeHv7+lSpEuoL5hLyLC4WQxtgSdRtz09fyr/ai1tz /Hi7EutOhnn8mGDZAgGd7AshHYcVLfyCWyNjb+QHt8bFMYUyt6bsZ4q4xvuUptE1vBE1lLayQQTz oq7mGf3bdeBnn/61OijuLOSISaZPb3VjbfakvHQFLlCSQ6Z6DjFamc6nRipd2+pgXtp/olxcborg yDCmXneFyBx61jLbbbaXN1PHMGO5UHEg74+tBnzs/9b86JIZ5Y7e8iluHh8oQr9oQwuhxyACenp7 Gq9ho2oXTNb3Ah/eyblht5vNO09Ce4J9MV/tpBM/xvlK25s6nFLbf2fYhvs+n2J2TCKMCUkk7gfp k4FUZ5Uga2ZESKJ32h2HOfVv51oYN3dxL60tXlu9QtJb1ppEEP75w0SoB90DtnrweuauwRa3Potk byWKe1hkNnAoYblQknJXt1P1/KgnmSLVvC1lFc2ttcJJBcRGNmVcYzjcFyM+1cxbaPqAu4rSB4BG p3x75BmXtjdnjpnmgmb6H//X/Pe5huWuLCwvIUE7q3mJYyq0gTnBD45IAJ5p750mBYIUuNUDTKs3 nT+TKY93JLHPQDpzX+30PhP8XZSS0KV6dGvTpkWm2+pQXtnctNfteXAuLeY5HliPCjgDOQfar13/ AGotnJIkAisTN5bO207SBkAdxVEKb6mZE9sqM16WeU4Eacjd71fa01m1uENtLbw2tzGqFI5w0gDD OHXt096CJSW7GyNbw+eysszhPJMrx8jJGSo7VRl/syMWM1vNI1xJPmSMQ/uZQoycv2PbHPA6+usL WsZ8/Y//0PzzTULe4uEaCAI5b975T/J1PQ+gq2pK3YIaOQv0DELs/Gv9yD/FFybViJJ5rnVrhVL+ XaoiwleYw2Mt+R/pV67Z7GyuGR4mmbGS7BZGyT09f/r0HK3q2YyiB0RrcqtxBh2cEqVPHT/63pXW aFYy383m+eE/jlmbJLY6/jz+tNOxzzlanqe0eEXMGpvHHDFdLqCNbxl2KIksagbSegJDj8q/ry/4 Jf3SXXw3sYVaVFhggWPMm5XwhA49eT+FfzZ9KSHNwGn2l/kf1p9DOp/xl+Pj/wBO1/7cf//R/tt/ aUsXvfhV4nt4su0emvd/N9zMezgjvkE/nX8JHxQ0y+0v4hfEtEkZlHjO6m3sNr5ZYznPfsuf9g1/ d/0NprmzCn/dv+KP88/pp07ZtltTvzI8qhN5qd8i3EzvEWAfeS0cfQbsVeeWz0u4kMMaXLsMbhlV XHfGM81/e8fhR/Bc+omlukcl9qEUzR3FxA1mYdxEbK5yWK+oI4q2L59IEUayecCm4hQVjbPVT9K2 prqc0tmZM0k0+pJdCR08+LiNSREAMckdM4xTrm7+ySXd9EJI7ycpHMEZYba4UAAsVA4bvu78555r VJvRHHPex//S+ULe2nvdQHkwTMzI1yUDF8IPmbnrjFWFhgE8yyF13tuIX70I6ACv99oxstT/AJ4K nUkaVoZ8qu6OMhR5zZ3Cm3cyiYgKttFJKGiAYvHGpA6n65qjleiFMMbH9xJ9p3/eKAhO3Cj86oi4 YSbQuIYD8q46EUGB1OnQWetqILifyBnaJZjhTxnH9KqXOn2cUTLFd+WYJA4j7uVPSghys2mf/9P5 fZUltnl3hQrAfN1bPpQtvJCIZCREZcrGGxl/wNf78H/OQ3dly1s5bm5YkbPs4+cnjbnjiqk+jNos pna+muo7uIPHFvUojE85AGRj0JrSML6sltLcpSJtPmHggbiB0NWLcR3G24WYQYYJkHh+D/hWhHOQ Xgt4JJmSdphjc+1Dy2OmKfBuEcUsqgCQcIww659QaCZSb0P/1PlgpAs/mPFK8yr/AKKFkKRxtnO5 lwQ3GRjjrVy2E1xJcGdWBjO6bIwy5PX/AD61/wBAB/zflSZkkaREMg8twY3PANX9Pmt0uFguicvn 5oyC+ccfhnGarkdrgNuoEIcElC5/gJyv4/hTJ7clIrdHbch3L5ZDKxx3+tVGLTTAcfOMKh9oKrhh jkH60afcrbRTRXCPcmVt0czHb5GO2B1rQD//1fmMqWkeRT8hXAXjB61WgEsVxEY28t0fdGw/hOeK /wCgg/5upy6I0QzwJK8xS5mbOCMoo561VSFroNK0TpGhAJJBX9PpQSnZ3IBavBcoI2TY5w3cDpzx V6+jN0M2/wC6SFQCAfvduv1pq3Ubk3oLaxPHGIj1ePfyO2ev54qC7sBbtu2vh/8Aj4DDGMHoa0il Yk//1vmWOWNRiILIkfIVh8p/ziorFoQrhcLknd22nNf9CB/zbk0ivM+1FclAWLAZUge9VoIt7Sue BnhMdMUAPZYUlMoOPMwrBjwcDHrxVUoLUuIjnfIWyo4OTx/n2oAsJ5k7AkD5RgepqKVzFNsbBkYE lcYIoFdXsf/X+ZIi23PlGRskKnTj1/LmrH2hJlW1gjZiAZJnzlYzwMe3U1/0IH/NnKelkVJ4jFHu wRt5Zh3/AM/1qFLZ8qqI5eX5kTB+Yckn9K0gtbmexorbBYt7BDEThs4DA1FaxTFylurSsMnAGScc nFCg1Ibbe5JJBLLH5rqYh/AGGD9SPwqnNHLHD5ZuIbiU4Z0hPzRA9M9qcotvQR//0PmNXdY03Hby BjGc1LNeDHlLEdy8biMbvrX/AEJcjP8AmvIBJfmVZ4YwEWMwuWG4Yb09P/10TJdTAkhwsYy4UdaV mlcBTJPKIo5ASka7U4+7U4aONGlkwRECzZ9qQDYry0lsyY92933BXjKnGPf8KjRDO7OImjWIZw3R 8dxQaQfQ/9H5tihZ1LjCk5GGXcD26HiqkEEzrMjEedG28RfdLqOT/Lp71/0KJPQ/5spu7CcS3Agi LzW6JKshSN9gfHY4qxOziORVO7PyxnPCfWtCU7O5GFjSNTJvPHRe1RxzI0Oz5kEknyknD4BP880G qlEj2yW03yxyOhUsWUfc6YJqVn80MzEhkGfm6ntgUGcndn//0vmKKSKQIVbcgOCE5AI4OfyqR2zd L8iiGAbnHTzf8+1f9DB/zXkyPvinvfLaK2t3HmHHHJ496futbqHzQQY3OFOOCe4oAcqBUijV+Iht XjsO1RSzO0yRRA+WsRdyUwQwI4B9OtAm0txwli8gsyuJt2BlhgDvx/8AXp20TAFRtZRliOgoGmns f//T+cTbFlDO+5hyz9c/Wqd3Cv2nIk3qhGwA44wP65r/AKGD/mvLk1yLmIJ5flGOIRKAMEkdzWJF 51phQW8tTg7snGTQBd3i5R4mb5UbcMcEn/CnmMsgaMbWA+6e9AE8cbFt0i7XK4HOQamVzGzQzYBI I+btj+VAH//U+XHtXiLyxhnDncO4H+HSr0G+eHfM2Xj+UIT2GcV/0MH/ADXlu2kjKIsgC7G3BDyQ fr+FR6pbmREkhbaqsS69z6c0AVrcBVDr98fKcjrio7uS527UjB5yvYH8a0gBEgeVSky7Jl6gDOPa pSxh2pGwdzyVPXj2/OtAP//V+Y3ZZ33SAKMcqg2gHHpTMPbgi3B568ZzX/RAf815PHPO1jIsxyfN 3pERhgcYyT+dZzwQzyxm6gDT2w3QFxnaG7gfhQO9iWVrmGSSBotsIjWRXPXJGcD8CDTrUmTJfc8m cAdaBFryZRu2r8wYZBGNvrUjIfMUtHjyxnOPvGgabWx//9b5yV9zbmwoPHT7tRXsQOXtJY5TEAzd cNnqB9P6V/0QH/Ni5NlW2Kyz+Y4dBt+VGb5c96ikRxMxKkKTkHscUCuyxFcQoGXepkA2mPuMd6db Krozrwy5+98tAXexZkdpI0ieNEK8hwgDHuCT+NVzG28GY7gRjdQI/9f5rVVRTGkYIBLEqdpbPvUU Vg1xGXZQZF+YKTknFf8ARCtGf815VjZkk+YHCnaUI5XHFasMrsjAxt5Y439UHXj/AD6U4uzAY8Mc Z82JxNuT5oguNhqCFpxKxYOqBgyZG3aMDp7USbbBtLcuIkQZ5wA4dSu3qQfWsmS5VJngABI6+ozU ickj/9D5pEa+UfmVDjcOM5NV4JZWcicbT0BA+Vq/6ID/AJrXJW3NJJLbgy7lIPVV3FfwpokjmvGa 41EQxLbtHDG2W8x/4Rxz6igxIoQyjDFZMNnGOCfpmpGRLhtwT5xgEEfMABxWMl71gNG3VHJ81CCi lVXAXJxgf0rOuElgZUmKqSAx2njmtIxUQP/R+eUi3LG6YfvtGGzj1pHlxuVlRVIwO9f9Dc1Zn/NJ zoqxxyNMpyDGBgAcMpqYPLHJIYSxGCjgenv+lQS5N6CWsl1HdCaKR4WTo0bGN16jqKfcSebcLCbo RzSH5Wf5n9zjrQSm1sNUeXPJFIElCnAkH8WD1H5Uy5kbdgjYrdGHAT2xQXzn/9L51jRY2Ox8sEye 2Acj/EVJAJrmRlhUyDbwij5+/av+hg/5oXJvQmiR4AXngJ6jY/Ge3aqfkC43pJnys9EOG6+ooDmk T3FrbC0KxeYs0YCxfNz0/P071CpVLSTzUdpUXjaM4P8AOgfOxlvb+bBzJtmxuDOOvt9amKL5UkEy ks6FQ68be2aCD//T+aEjeLZH95UG0N3IHHNaDI80OwBueCRwa/6GHtof8z5HHDJCgjztY8E/3h71 egt0ZpllGDFHvBb5Vcd8H19u9YrmtpsO7vcovteRI1YkD7i9cf54pSMk/L93hieRVwvbyKU3fUtW 5ihL+czD5CUVV3Fj6e1QRQCSUyZYA8lc8ce1O8upTmlsf//U+c5pW+0YO3y8cRjk/wCelPl3goIQ PnUbsjgV/wBDB/zSc6vYkaAqhUAAgZGKqIjMrr5y7Svqd2fSgpNPYqG3mjI+ZipPB9KajAPsBk83 Pzkk+WR2wO1BLmkaCI7bkkI5XC/SrS2hQRN527apBQjAXFBZ/9X50kDtJ0yqcemfWrKASIUQbWHq K/6GD/mnIWlkjSSJ5GGfQ1GYvMjd8Odg3O/JwB3+lADrN1SBpJfLlRW3IrfdZcd6beS7FW8VLe0h uHAgVHyhA4Jx25B4rnNoyuaMK6efOklkZ52A8oJ/qHHc4NE0MUrwHT2mJtoG85W4Xc2MnA7DAxQU f//W+bS1yZfLRGeQ8EjNRpexQ3JglcLOhAVR97d7j/Gv+hA/5rm7K5duG82TzXdWdvmYgbQPyqt5 2JSBg5GM1lO17CUk1c0k8oRoMN5hHU8Cq0kbCJhG4Yt97bkFe2M/561A7q1yWGCf7KZppYI2jIRI kOHx0z0x2+tRiZwQF+ZTwSRxQZ87P//X+c76eeOBIosFFfcqoACdxGefw71EsWAj7tr4+bfgDPtX /QNLY/5rYu6LMkjzxIsku542JO2MJu9Pemy20sIimO1RNH5kYJBONxX/ANlNYm8HpYWGSFHEjN5R AxvHB71ek82SNTNcl4gD5JxuHfAA9zQE9jnoopXeVp5lVeSoALHI6D+QqeBQ1t5ksewbioLDL8dx 9aCYytof/9D51t4Ul4jO9W+b1xSsEjygXgnkj2r/AKAD/m050Rk2rwS7nlRkIUBTgn359P61VQSu o+z4kXHz9yRzzQRzO90TwoMMd2SDyp61cgt43k+WXaW4feeFoLU11Kdz5VqvmGKWbc4hUA4Xc3Cn +dSXdy32WCO1UQyMQJyx3k+oFBV0z//R+arRjAZCIlJPB3YKuPcUx0yEBjJcSbhj7g+tf9AB/wA2 5OzrPLmbG88jjBJp0gEjQp5hVUb95jAJoFdLQjvo7VAsEt2wmnB2rbBg+BjOSQB0PvTLW2t1dIi8 kcAb55D80mPX60DGTxBJn8uZfIf93Hu/1jHpmprS1t7K3lgdXZyd9vIG4BJ5BGPf2xigD//S+Z5N OkG6R8tzlCoOH47VTadYXBc7ADja3BzX/QAf825NJcWk8ana2R/rM8E/Sqqq8gWK1gdYcfxDc4FA 1dPQtW0S2peQGR5X4aFQMH6U+dZHUGQGNQwk29CMev60A3fchXlHmiBkijcI749eMVcKQhkcLhVO 5lQ8v7UGlPY//9P5klvIY5jiIpHKdqAncU68ZqrNHFglEwX4Y+or/oAP+b8jjju9ix2sIeKEgSED 5Ikzgk//AF6sLC5lPkBsE4B6mgCG5iMhnFwrvcDbGhDYUBeDUcxCQwr5DvIrBRIjhfK/3h3oAkkm lKxpgNGpy49ferbTFYkkRgsSOqyFztVdxwPxqXFMD//U+ZmXJlkWQSbWIMkZzuI96pwW00mGl3AH LKZCAWx/+qv9+WrOx/zflTyo52LosoMblchSE4rodKvrK0EhuLJZ5XTYHY8Dr2z70gKJiZfMu025 DYEIPPJ6/hii6iniKyllZGX5wvTNBUPiRnjkSSmRyQMJGBkVYtoppFHQxg/Nu4x+FBsf/9X5gubW YEYOY0GXYdAOn9RTYQ9uGc4Ck4BPf/P9a/34P+ccLm3dlEoaVZXIEce3aoHqPXPbFU7USwztbTw7 ULfvJGj+ZD3569ulBUdGNkkS4dlcHZC37tx149R+A/KtaG3uLPybryWe3kUMvngruBGQQO4pNJmx DqVyLwR20aLbwkrvkgO11IIPHPtUKloJzGzPLCWDK0hy/A7HsDWUotAf/9b5enuGN4UWFREtuHEu cuXzjafwpbuTdEpQBGHPyda/3wP+c8hmkkuYYlELFlG1xjJb6U1LiWC2uLZRuWXbuDDJG05GP1oA zpkwqMrFyy5Kn+E1YhizDkrhjxj0oKj8SJgrKVXBCZxvPJX8K0mS6u4TZ29xAIFUgxyRLG/BznzP 8RWckxPfQ//X+WbSGK2BDqjv93k7gO1U5YmWRpDkKp+XAyOfSv8Aeg/5zyRIZ/LEccrK0hBgZsfJ nrnNaZgntm8x5ElYxbFkA2qe2RQNScdiPT7VDNPkZn4kXgfvCOMn1PA/KnWjLYi7haFYjcTeZ8yn evrwemePyoLUr2Rdj/s+FJI41zeXRVmmx0x0X29KoiPzJJLtpmV7V1SNDn5jyT+Ax+tRKN9jQ//Q +d01O2PmQ3TLLuQYQAOq+nX8Pes6GAyXoaF8RPKCySHagr/eGp1P+efC/FH1P6N/+CO1lbz3F5ew owitryaBhJ+8YhGRGKf98KM+1fvv8WZAfh/4lTDKq6VNIxAx8qxuSB+X61/k945VHW8V6i/vr8z/ AGw8FqX1fwbwkX0pf+2o/hd/as1O5uvjF4zhsl222iXosJLxZMzXW5I5QTjsC238Pwr8yPj3biXQ H1W6vQrQzOY7dWIkgbYiK754+bBA7/L9K/0LyT934eU2/wDnx/7af5yqqq3izGy/5ftfdK342Px7 1u4t5L17a3dblYXIaRedxznJPr6+9ZSF2y5Tb5L4C44OOhr/ACS4mfNn+Ll/08n+bP8AXbKPdy6h H+5H8j//0f5G55TMkmHH2gn5ePlWqiEqmJFUuD6cD6Vg0rI2Uk3YybpIg5uJgIizBd7NgNjpWxBC SjO6rIMBl/i6dDWM9yiq/wDpN1mWSX5E2+WvAGOB+VRtbEXKFG8xF746e1QBqS2biBZYbZZZA21W kGFTIwTn6dqq/ZJvswkl2F0PKhsE/QUm7IE77H//0v5EJ42e1QQlU3nBikGAcdwa59bbV9OnS7to 3dWmCzQN8qSA/wC129c1452QdkzUmmlNwTKNqn5gO2aW5lhmjJWQrgbWK9qClK7MkDzSsStuAbaz AYYitKNRAA0RZ/IHzeZzgen0pNXVijClWN8lxmRJvNjIboT7fnVyC3QMXI++uWZeCe9YtNbgf//T /jxklEEbHccE4XPY/wCRUcOoSzuYBMoDrsIBwzD0FfPnbPYutDcW6eZE53p9zA5PsapJJK8DI8fl T7j8yHJP+f60CpomjuI2xb3KbiB1Yfe96heOKNXiHER6K3AWnZoUXyuzINONtdPcWuDFLD82QuA4 6DPpWbc6e28SvLIx3nKsPugdBSa6MuMr3P/U/jltIZTE0xKnYNzAuAVHTgVZS5TJQlvLJycnJBr5 1wTPRTs7kiOvlZIJ5JbA6DpVNpI5/NXZ5bxjO09HHrU+z8xuV1YdbfvPLVI2XjbjFTyK0RnA3Ham Cp+8vvUNNbgpNaBGkflwuHiVmfaqu21mPrTJ7hYd3zBZBwPekJu7uf/V/jmjuVmKrOd6htku0du/ 6VeMU6RSurxiASAW+w5lAwM7h25zXy53t2MuRnRSOQucksPmJqvgovllXKN8xPRiTQUm1sXpYzHb qscsoMgwh3bmj/znpVeJJYpYoZZAzMcgscKD6mrgtS1PuackcbuCdsROPMRPu8d/xpzxxBFZThw3 3R0x6/pWptCVvQ//1v46pJcb9hy55JA6/jRPKGs3gleVHliIDLw657Z/Gvnz3edFLT4rlrmKFlWK xhh2tIoJfI4HHfPf0roTp0LAbAQScsT0JoG5JGdJbSx7zbgKYjvAUfexzzURW5ki8+6LFp22oijB QDj8M0DTuilZtfWc6WcZllhMxbbJ8zJnJIz1wK3ZYt8RDJ+8HO8HDp9KDKW5/9f+O5rKe5+WMyIW G0SLy1TQwXVp5rQSXMk5wzIvRtvYn3r589paRZfWSRRLPe2wncIZ3RmwUwM4U9z/ADr2X4Sk3mt6 fcyWMlot5bl49yg3W3egBk25wpz0zn6V7nD1P2mb4en3mvzPmuI6vsslxNTtF/kfr54FuriKHTYY CdtltCM43RPIgAc4/wAOcYr+z/8A4Jd6PexfCPSY7h03W2lwn+6sry/vQ/qSEkwR6EV/U/j5GVHg jLKK2ilf7kkfkn0bqiqZvmtZ6OV/zuzU/wCCn+safD8HjbXl0sNjJG6yFo8LIy5G1m/4EvWv4lPi XdyWSeLLaS1ksZILj7Np0vkma1vdzJKHV+ecH9K+4+jbSceF6kraN3/Cx8F9Iqop59Tgt1b8z//Q /kg/aWuX1jXRdzruvfPMt40JEXmbfkDAjqCxyR618oTLbSBo1mKuYyJmk4AOOg+vSv13xmrOrxxj E/stL/yVP9T898OqSjwjhPOP6mXY2zzyoqowhjfDNjAGK9Fs3kt7VZIcRzW7/KMYyPUmvx+ovdsf dUo9yzp1tcNcyyyGFSYRIqhxk7uRnnvxx1rdUhIglyCylyUDZZY29R6dK8yqro6oRRf0TSf7SkEV ztnjaYGGNgCEx16/nXpmmaRaWD20czXEsST7nkD7JNufuAjtjivLxC0OiET/0f5Q0sR5zNAdlvvJ gjPDEZ6E9zVq6aa2sHkngkkjQ/LsXJP+yPf2r4WSuj0YLUoNG1ndJ5drIsUwSaPv8rLuLE9xXQWC rdM90i7YkfYZB0LdCP0NYm501/f2cenfZobaCS9G1I7uFX86JiwJZ8Hnjg5HFctb2mo6ldn7YJIT bDeGk/1cgGcEevSs5gTGyv7p54Ir4JEcCVZQPLkwwI+Xrkda7MWrxSKsNxbibyR+9jIiThR34AOO KVP40TpzM//S/jStnvtQlc7RY6da4uXldgGu4h1GG54yOBzUmyGS6ae3tI4Ymf5Ykyykdifc9TXj QVoEweli3fXQsbcht6GT92qwgkSE8cD1qHT4bpIEjmmaaQ5ZZHGCq5yF/Cn5FPVahqGm6h5ttPB9 kgU8sWYmaUd+O2elTMY7Ui3t1A3/ADtlQqgnrz9c0bbCirJHNHy2jubu8uYwfOMNqkC+a0zr1U8j HTH4VPpTeYXnhVVCMDKCQsjHtx3q4PWwz//T/kCiu/tMZFzHGE2fJGw4Yj2qCO31UXEc9mkEsQQi RJ38oIBzkH86xpGMviZX1KebUYpbNJBFtX7yEMQR65+pFYkMF1ZrDErhjBGP34OPNPQ5HrXZD4TN P3mjjdfjtkvY72IAXE0ZSdi25ps9ePauHlizIzOQOwDD5q7ou33GMup9E/s03jWfjK1a2ZjEtyq3 EMbbg8jPFtLKfYdq/fHwbc6noGpaffPZ2UiSWUOqRRSSMgeKRQ21QATnB6eoxX9p/Ryl7ThnG029 OZ/kj+TvGeX1fibA1l0s/ukz/9T+lP8A4JgeJ/7c+CvhxZ9Na3NxZQ3TzxzNOYAYlYJz6bivTsK9 a/4KD6SL74IaptLrPcXcdvJK6uYobcK4kzgEgkNnp/DX6XndFYbxSlBvRVl/6UeLxJXnj/DT6zFW lLD3t/26fwu2YnsLe7bVL37RDE8ttZGykLb2EjnLZHyjsPp1rm7e80z7UW1JJPsF0kluj2gBkSVe hYnggEYI681/qDlyUsNC3ZH+V2Mk1KXMur/Mo6hH5vkWlpHE8KgMiFAST2x6VhLZX89yxuYns5Hl EQvriMwWm3gdhyq5GcA+wNd/s2cSfY100SytbaS2n1D7csWZ/Os0YoXYbm8sNhupxyO1RW+mzXMF rZmM20UsoEt5NkMyk/eYe3StUrKxpGTP/9X839H0jSbS71i7Gr6ULe0uvsVvaSS/8TGfbyJMAbcE cdeCPpXNa3dyxSM1sxkt5CeYgZArdBuQdR6+mK/2gP8AI8159WjMccBtYN0kCmSG0T5UwAGbb2FZ OqX73+nGzhzCsTEK8blGkI6Z9MYoAtW7JFp8MEssojt4hK67i4fOM5/Okt009nV1l+0eb82wfMke O/tQbRba1N/TobJ11C8ublWE6LDCjxk+Wq4DbSOQePyJqhe3Z1M6bpFv5sggQ2VsyRGSXYrM+AfX LGgpuyZ//9b8zk8MiHbL5n2u3dsrHKm1kYHPTPNTOlxFkaWi209w3lpccRRQleCSx4HFf7QH+SF2 W4bxbPTFsZZnvdStpnkkuUjy0is3AfGcBeAD0rHneLUl3Sx+RcW42qwGFnHXn6ZoEXobRYEjnRfN kkXYqpjMRHVm9Bx+tTHVLiJrJo43iu7WUtPLGSscsYxgFcY3c9zz+dAE+kQx3lzPe39xZXVzZyfb orC+TMkilumOhU5wRxxmqImmhtLq2uLRCt5cbIZEH7lRknYPT+HrW8dkYyfvH//X/MFrbU2vBZhY ozIRFIzTBoAv97cOOKsS67vsZdCiikg1C2k+z+fIipBcsxwvOeeO/f8An/tTFtPQ/wAjZ/CXo4b3 RnsbWeCGFfJE9xfQyea0pb2B7e3pWZeQy3Es86T/AGgSy7PL5LADpx79aqG5hJJrUgTSJRO63Chf l82KNX5XGCM/TirFy17feTNJLJP5arApUFuF4AA/A1ondGckrJovWdmb6aOKLP2cfOd5CHIHPf1G KglaSC58uRZopY5OqoAsG09D6dKZjPax/9D821Nzqk9pE0/lWKS4uJh0T/e749cV1TjSLbSzYWGo xSXUeoC5uXtIDHDIo/hDHBJHf1r/AGsn0P8AHcqQxmd/KW5jtxK2BI544HGcVhvbQrLsu55DK+cC PKggdz+n51cVZEOa6DrS5j06XHm7ooPncryxGON2eex/I11dvb6Vrtotxq+u6vb6hLl7GI7FslRP mCyZO7B4AA7GmYuST945XUPs0bj5xFaGUGO2jmLMpGAXB98Z65qRmsr9bYw3k1hLCmIgwAWdsnHm 5U8HPTjimt9TNzZ//9H869fV/sVvHeXSp9nBy1qP9HfHTkf49fWo9IkvYUs76ymBZ43SOVG5AIKE n06nH51/tummf4yuaRqFIJbaO3iuZ3ZSftskoDsZeckHuORWbLpchs52juXNosg/fXRUSq2MYUen B9qZDndWEsrFUKRefKIbht7bn2xkqOOvA/8Ar1p6baT/AGm5trtRLpkRWYAzGJpDkEAH3xziggqa lfrc3crQItutpFhLaBSscaAnqe568n1NWbnR7O4KyWwmhvVsFW5ulk3W8+47gNuMqV6cdqaVxs// 0vzdtba7luZg++KaxBeGVn8vegUEEE9uuPpUltO91eRW0sjkuSu7PI4Nf7fxVkj/ABana5sS20Gm oDI58wHcH6FgKiGo22oxBElC7plVQc+W5UnJY57YP60yBl7otxLPPevqNpb6dabd9w5JB6jCDqeh PSs5r2Fpwgmkn8+QLBc7W2Nju3oMY61UVd2Mpu7sbkEMNleCXat3DMqSMjkSITtAfAx03BuDzWxG lrJa3cmnQwv9mQvLaseV3Z7fjWiikQ2luf/T/NOyQXb3F9YZjgDiGS38z54JBncMdeeuMcVuwxRR tEEkeS725e3K5+YkgDHX/wDXX+5FrH+JnOi/o8dwou7i4ie1hijeW73riaFgdiHGfuk8H6iqF3an U3SWWBmSE+csiEq5A7Ajjn+lBzN2bQR6fcE6hqEYtkitUEsdo0o+0OucY2nrjitnwrcXOn3k1x5M 3kXtuskaXBLqDkhmVTxg8+3HtQYz1g0exaDb3F8qfYJI4L1ZBOryDIOSOQvc46fhX9ZX/BKPV/P8 D6DFbyM0f9mRiQSJ82FzjcemcYGR6V/Ov0nYOXAUrd2f1b9DaaXGWNj/AHF+p//U/uJ+OccE3w28 SGZJmB0ibb5S552dD+IB59K/hI+MlmJPjF8U7U3t55beLZihmj2RkbUZVA9gcE9+DzX9y/Q2k1jM wj/c/wDbon+fn02IqOMyx+cjyi+t2s49ulTnM9s0V+FAMoIb5ShxkHjkj1FZFqWs1ge7t454pH2X Esp23Sg9CgPfP5elf6Bwj7uh/n7Kb1uVrudrR3HlKxzyq8MvsfSteO7s7i0/eWzGQDgH5hH9DW0V aKOWU+r2M+O5SIlyMYymVG7YDxn/AD60sltHqemXMZcrKDiPIO/HPIrojHlRyylbXqf/1fk+1S5s GjaKR1aH5Fk3HcR0x+PpV54B806MWupz5jkjhSfQV/vwf87tRkTKtvl7tPMiYbC24qUJ6Nx71Omk 3sbefAwmgzvaKQBjj2B+nSg5ZvoPWBpbiNMi3SVvn28BR7CrMdpDbCe2uYXm+XEMqSeWV9zwc5oM 3sVQiQlVRioJ57Uk9vtYJExZR88jsentQc5//9b5ZQTsQ0W1PLO7ypV+Rx61dRUu7mOS5YMYQTHx 8qEdgO1f78H/ADjO9tDctoVSOSSaR1ZuSVHLDn/PNYuqhLl5pbNf3jW6xqsxK/MBjcfft+FVGXKY u99Slbwx2Ygt724W6ZgC7QjcMsASOeeOn4GmRxoXmRtqw+aHijx8yYPHNbJp7CJTB5txJKRGqLGM Ki4JI4zx7VbKLdIrk4Ma7Y9wx0oE3Y//1/ltnkt45IZWjPmMP3gwWRhn7rfj0pbeYRCRSS8kyhZG Bxu5/wD11/0BRsnqf83qkmK1o0syxjCRqu4lSMfSmywyWc7SW3ly3EahRIwyUU1sKbtoix9muniS V3DCQkOduORjp271SG4SxxyNLGqSAlkOCwB6UGd2jZJQQzAuGfgRRdGf1Oenaqkggs7e4YDzmkxt 3sQYjwDtwf55oC7R/9D5jhf5APlI9D1FEiQrIGZ8buwPev8AoIP+bcrXcjkbVPbA96u6bEXt5IpZ sbRuVWzl8f570APAVVO3JbsDziqqJKsmJGyjHcu2qUbgTPaNK8ZlSUFHDxMrFDkEdxWzceYGaKTL u+GlzyckZ78nrVQ0iB//0fnFbaGJbjKDLDaqHIxn0+lZiiFQFwoBPzD3r/oM53fyP+bc0ZFTyN0c xidB93BG/PGBWbDBN+8RN0rN8wAHPrVpp7ETdlYekXmJ5LOpd1zuxyhGcCp4UKRCOcoZlXkgfKT7 UyFJorh2gn5AK5yp6im3j3c8vnztHuyVQRqFJUdCeKBPc//S+XYNso2bnWXdxJu+XHpir9rEbaVm jkKB1KybeA/1r/oSh8SP+a8ZceZLHIFYJGrhXYqCSPQfl19qhFqki+YWkJiUKp3EBV/zitgCSN3j IQElRwM4FOjlks2gEtvPJ5nyoYGAYHp+lADpheOkqSncuc+XjDD2qvKltHG75ERdQs0mQrEjjrQB /9P5mhVVRQ53YHydyfSrLwFwZCMAHB9f88V/0MH/ADXjl/dwEDn5sKPT3quS2dhuHikYjekWAzqO x9ulTeOzAsSP5xLrGY44dsY4+9gdePXmoUlC3Elo6A4jWTJHGGyRzUtR5tQK08RQs5AVV+YnpgCp xIzwq8bMqlf4hgkfSoVuoH//1Pm7ZJ5aNGWIB+ZQPmqu20yLMud6AjHQkHt+lf8AQwf815J+9ZUm 2nOMMh5xSxqyFv3TPFnc5QZ2565PagCWJW3M5UGA8DI6etU7k26vGkfAL/KB2oA0nlCo0rbViVcs QuegxyPoP0qi8YZUlDq6y/MAo6D3oDY//9X5cFqQP3DCNZHL5XGSe5q5Gsfyw3BIkaQFCW2lsZyM d8/0r/oYP+arnZuhYkheEEBGHzJ2NY11GYUVEQNGHDBV4x3/AKUCcmxTKmVADBj8qEDqfersEMxR pGhYopw8gXKqT2JoE23uUFt8zM7vtVf4Oz/hW1GI1Xy4UGJjj5hg56daXcR//9b5zj/cyzwTqQyO Y8KeFx61Qmtk87zJJG+U4AVtq/jX/Qwf81imuU1YYUmgPlvGSnK9NzZql+6cyJINxAwy9D9aA59g iENpE+9Q2eVZuq/SrUZRoBKyllmTMJHGPcfkaCuZdyPc4x3CDOB1FVZTJOpdkYlnIDZ5oGf/1/mW 2uNpaAh40+6hb5sirNw0cbAQRs6KMNL2bnrjt/8AWr/oYP8AmvIzG7EhVyfvK3UU+SSTyGi2ZY87 ufloAZAkn2UXDxtHGshjO7qxHpzV5jFNEgjyDj0wTVRsnqAyKNEkDsvzA9PWqy6fZvPPKzSJczNu G07lIHTjt+FbeQH/0PmdbF7eZ+WZTyQx4HarUJhEjgnI25TnoR61/wBD6d3Y/wCa8hniD7ipIPft VaXy8q+d5RfLOD6UwTT2JUVTE4H8XJB6/wCeKS3hC/LuZDngqcMPxoAlS2MLSeTLKY2O5vNbcc49 frTjHcIsb3GF3nITPzAdqAP/0fne5tQIfPgcPGAA64+ZCQOvbGc/lWVHGIBvBZAxx5a/dPPpX/RA f815NsBUNwH6fSpY7XftLE7V6+poDYdKLOQkJEsTqnlhwMOfeoPsU9zFJBDvMhQ/c4fAByR+poFd WuR2wuBE0bceSoRHZj5jgcc+lWrUS3BFsTGGY/K0h2L+dBLmuh//0vmxJQgk3oAc+WMHkY70qvMg XarqGbAmC/KO+Ca/6ID/AJqLtO5HfTqIgixRl2l/e3HPmPnt6f8A66iSR7eAhZGaKVvmjJJ6e34n 9aB87vcekqqGkCEFeTlcj8qquXjT5GfEsm5s5JXPYegoE23uaVrJdaeyTWnkliMj7RAlxHz32sCM +9VL22ursiSMWoeUhnmxtYEdsD+VAj//0/m9NPljVXkdfKx8xPQY60/y4nDNu2gDMYI+9j0r/ogP +acigjDA7+edvpkUNpcIcyKC4jyyg8kZoAiXcJAqj7p59sVZiuGa7eaJVMnmZlGPlP4VlPSVzOUr OyLdzNczxT3aQkCCdICFULGMgnI+mOlUEElxIPPDHJwD71ommTzM/9T54iQxbsAlQduF7dqS5t0K Nkt5pOVIPA/Cv+hubu7H/M+V7axd0LrJtMY3He4XP0B71phY7aLI5km+9g5/P8qgCCMjJycfypZI omaJ3Vd0ZLK+Pm57UATPhwkyx8BtowOvPr7ZqW4ECwDeVy+DtxyMf57UAf/V+fzt8pXxgMMZ9abA 32WTz1coFXqDt69a/wChg/5ny5Fdwzb1ffNlMq6nCDPqaqNE1uhmQgtuyA3Oe9ADzcxSDbsxIBxx gE0EZjKkgA847mgB6QPHbmVU3EjOAfugdc4pxh8yHePlbq/PSgV0nY//1vnuA2wEiOcmOTKgjDvn 3q5G2EBRDgNhj2Ff9DB/zPj2EcskRyY2DfPkgq47cdqgvXDQSFQ6zJKgREGQyc78n24/WsouyYFS yRNk7SnDhgIsL94d81OfLK+6nJB74q4PSwEaHO8Nhg5yuR0HpVmI2McRDiZpOdqrIFU5/A1QH//X +fIbcITv53fMM/MQKkV/LLOVAjHGWHYV/wBC7aW5/wAz5aDhGEqx+dlcBM4yOlVJ7KMOJkkQiQcx puzEfQ5AHftmnsA0QL91ycDp2BqKWBY5EZsKpO0FfvLjHX86AG3A2SSrEGOyMFHPCvkZ4/8Ar0sc uAkcx4IHI5xxQNSaP//Q+fY0BmOWBgIIUgc57d+/FSTGG36yCNn4RQPvV/0LcyvY/wCaP2nkUhJH Ncx2ckRRWiaX7VuBG5SAF2++c59q0ZrO4txJEj/I0Y39twODg0nJWaRotUZaLvdYGjKqilmGMAjP T9autNbxosXlqylSoDIGCZ9PSshp2dxhiQKjxjCD5MDqtI0r2weJWZBKMMV4J/Gg05tLn//R+eFS 4tvLkglWWVl3eXFnzF/2TkDk+2aUWgmE0gNvHd3C8NNFuLsMHCnHDcdcj0zX/Qgf81Lk2rFW1WI2 /lu7E5O5nHzEg/y4pzJCjRBMsW4YAfd5rnJNORIiAnQgbTj1qCK0cP5cYZxjKqOScc/0oDyI3lV0 A+Yru2NjocVat44nhm+UlRhc4xj6H9KAP//S+fxDBlV8z5MdSMkH6VXlMkwkgWDdFEyqzE/eBx82 e2P6V/0CyV3Y/wCaum+hW3ATFVBVR14rS2pdIArlWQYPfj29Kzaa0Zqm09DPns5YpEj+Rt43Alhg j/IqzDCkKx+aXCjqgPIHtSHJ3sZ8pR7khAdoP44q8otJElQS7DGVASUYZsg5I+mKCT//0/nOxkgb zfJ37eVQqOp6E0zDIzkhgF/vH71f9AB/zX2HAbo3YQh1YYzjOKqW8UVnGzK7HDYEeMBB6fpQBNK0 MNuZkAjDHLlj1JrJS7mDswBzggKOA2aANkPMLKA3KqDK29VwCxIzj8uarbZbtZTGDG6DAJGcUAf/ 1PmOBLlMxyIwKcFjyH9xV15cINhDNnBUDn86/wCgA/5rysEDSxzFDuXhTzhaV4xKWYtgjgKDjNAG hDb+fAsrvGuoI3lLG4Dq8YAGfY8Y/AVUFpcmY7o8RiMtt+lBrB6WJAAkcbmNZfnKKx52EdQPzH51 TuZ3bbCVK8/fHWgs/9X5pV3SFIRKx8s8c/dzT1jjaQI1skzkDy3kbaFPc1/0AH/NuKqWySvHNGCQ Pu4xtOOD+HWohNcQyPCkDRwKAxkIGX44x7f40AtB/lucyKWDE7g2Oahu59qASZYkDk9fxoAz4HEM gMeMs27aygj8R3pZXcjerMsyNgRgcODQVGXKf//W+VbqWBkjASVZVUed5hBG7vt46UsQj27pWcR7 T90ZPTj+lf8AQAf83yd9ivGkoR5ovuR8y84IXvVxr3Cr9mbnqDjmk2loxSdkNV7hirTYLO25iOK1 3jtPscmIB9oDArPu28cZBHcfyqHPsKMr6M5iS6MMrho2ZSMIQTtBzWytk8tsRd7BFIAwhByx9z/S p5pDk2lof//X+WIENoJIoHwrHdtPf3pmHk5805U8jOK/34P+b8vWuoT26PCsaGBwd6mNSZB9ccVV eeMDdt27j93rQAkN3JC8kkbAxyxeS8bqGA5ByM9DwORzVjzJL4O42gIgUxrgMcccCpUk3ZFwTvct QjTbVoI/t0KTTx7fKmGXVsc8Y/KqayE3K28fAd9oYAhPx/8Ar0cyvY1P/9D5oufLj+R2EoDfPyVU jvzULCCZEjLmOJhtTc2eOR/9av8Afe6vyn/OOVl3cq0ryJDiNG3ZUBeBj8quWBF5cvC6NK3lvhUO GJCk4/SmBQFv/o73US4hLlhlhz8xB/UGnxXbRqsE8TKvdV+dQT3yPw9qBptbEIVYnMwPmIvJXOCa ttfteolu0SRpCdyFUCu2fVutBqpJn//R+WHZLUmSQMwb+EHk1EmbuWQQowijTzWyfuDIB/Dn9a/3 zmkj/nNcuUtAOceVLwvDDuPoarXkogt5olChzh/P25dAM5H0/wAKgIyuQJKohtXRfMSddxlBGBz6 dauOTLgQjbhc56LQUaqWUZsra8ea2byLja9u7t5shGCflHbnvisNgrNctNBtS+vPtFuFBKptXbge gytKS91gf//S+VY2it5AZoXmRTtZFfyzzxkH1HWpYZ4kV/MlEdov7x2nQyEDP0z78elf70H/ADnp X0Re09ba8ukZ23aa7mNLhCU57f5zTtTWzjaOG3vPtSwlvKduCOfoP8mgpwaRmBJg6XMchV0IYMp6 Yq/ql6NQETyLHFPGMEooTeff8qC4xtqzO+xwzIkhupFnXIKcCP8AD3/z706dXCKqS+WoIDgjPmGg s//T+V4tMluraW5tt5FvN/pBUZ346gH8qtweYjIzKyNHKrBJUwHAwwyPQ1/vDU6n/PThlaUF5n9M v/BHnTL2DTUzaxWiXBmlt1R9zMk0kbqXPQ5LP0/ugV+2vx6mFn8MfEsjSvE66JdIZY+x8kg8fnX+ SXi9OFbxZqxi7/vF/wClH+3HhhCpQ8IMMqis/Y/+2o/hr+NEenXXxC8aWthfRX91/bz/ANoSXERt hAw2BgzEYb7rYPbmvzD/AGuLq9uND1jTrCHSfKv5xNDcI7HZboRAI+P4jkMxPdQe/P8Ao5hv3Xh5 GW37j/20/wA08kj7fxZhTT2rv/0o/Ha9/wCJfcmwKqBCApkjHB4x19eKqpdXXmtITAdPC7Ag/wBe zdz9OmK/yEz+fNm2Jkv55fmz/X7L9MDRX91fkf/U/kKuVZGE0WBBI+JMn5164xVeRyCiws77Tn95 yW+prnAfNIZI5I3iSVcBgGXd5WPSltdWvWBgktisbqAZVXa4RfX34rGfxG0PhJJW2EvGcbhzkdR/ n+VQqryKqCUwxlw7zAcqByRWcnZFGna+MJEtJdG8xJoriTKK0QGPL7jv9cVnSypIVNvMIrlnInSU ExMnbZzwSc1lqvmB/9X+QaWd2AhyA8fPPAFbkN/DdQSW1z+7WKNFWZmCKcehJryGdsF7tincW0Mo KrKFGMRuxGX/AP11y8sLlXWJlCRtgnPzk/SkUopbDI4poCk0a73PUDnaOmSKkk+0K4SCXfHc4jkA yZGYn7uPT/61AykYEt/PeYn92cbMfNn0NX7aVLmLfCSgA2kfzqJ7Af/W/jtuXkMRjeNGix87Yy69 +B61Jc2EA+xTw2626xoHt5VJ3TNjB3+mOv8A+qvBir6He0noyKPWpIDJHcDO04DgblbnrWjDe29y p5+XjnbhQT0NEY3dmNK2iK8qwmVizOFUfeRQWbHoKzreVLqMkBpot5B3cMnbn06VpJWiyeVXuOs4 IoL17rcy5QIU6CXnj8qmuhiRQGaQS8hcfp9azk0xpJbH/9f+M8BhctJEXKk7SC52DHbFbNqkS+cZ RhWUFAOTkA18+egVLJrmaaVVbo+xRjaB6GteTT41DxyHfMhwxDfeoJk2loQfahAzW4Xy5ANofH3e OKzjeRwyuk1wTNJFteeRSEYAdMj+XvQNO6uU/thKIh8vg7o5CMg+4NSgGeQNKPO8hslI2wsmO2RS sk7j8j//0P43isjRQrFawQuJiZQr7W25Jyw9enStaASP5RcrbRKdhKn5Zh75+v6V85a7aZ3tXMnV L6OOaExKkoRsMpP4ZA/xpJ5jJCZY2VCyjCqu5F9cnNQ4tOwxI5l2RuHM65555U+9QTNucF87h1JO NorSK5dCre7cvqC6gxlX+XG7ORUFvNKLq5tbvIdEVocfdlz6H8KbdrIqn2P/0f46yXVi4jGzAyoH THFOVklVpANx428ZAr55tLc9gas4QgLgMR0zgZqzb6osyyQPFIl1D8pkCHyGHY59fpRfS6AYs86q zISx+4ZPX2qNbuXZH55Tzh99E+4Ky53e5SbWiNGABnEwG6QrgheQoqSXaAzrt81vlbdwSBVQbb1C StZn/9L+O0Xc8bGM7sscgAYFDanc2SvO4Kp0C45kJ4xXz/keytmi8moi8ljiZfkZcszHIWvoT4K3 SNrE0A2SyRyI8NwT5ccEYCq8TH1JwwH1r6bg+m6vEeEprrUj+Z8fxlP2XDOMqPpCX5H6m/DdIZv7 Giiu4YLmaa3jRrpvLg3lg+Ae/wB3j61/c9/wTs0a50v4TaXPcSq+zRoVhEGD58kiReZI+O2VwPav 6f8ApE2o8MYGg+jX5M/LPozpzr5hiPX8bHzV/wAFeZpT8KNW0yG5MAOktPb25XcPNYAsCe2cDB7D Nfx2+OWZfBkdtqokh1KMW/mpM5by3j4fce5xn3HvX6T9HaMYcE3trd/qfnPjwp1OL97xdl91j//T /j+/aP1oXPjfXrjSWt3021vBpiIqGFRglhKFPZlZOPcV8teW8s26Zwqht2d2A9fp/i3WVTjbGuP8 36JfkfEcAwdPhXCwl/IjTs7uTfhCTEh5A6YFdoWR1iW3lVpXQHB6A47ivy2e1j7WC0L8MTCZVCKH cBcrwSR0BNbcFtcmORJFdtp3AMMED2rzajOiKsiMG6hZLSzaRbi4mUBA5jwAwLncPunaGxXssDfa bOIiaQbVw0bKDtYDpnvng5968yukbwVlc//U/lCsInGI7iViqZliLfMA3pV9rXWPsjzSXnl6Zc3P kPFuDRK4XIOOucd/1r4mSSdkelH4lYgiIt7NZLi586ZQ0fygyF1GcAfhW5aQxWuh4t4yyXkxlaHG 2WLLZ3nPTk5rmas7GwTW2s6bqGkSvcWP9lSxM6z2zhrskn+JR/d9zV++uLuNp5Fl8xFi2xlPvyjs Mf0qJK8TJyabMa3me4V9rZkCBpMjGzPY/lUtnNJFJBZ3TzTNlgvzfvQTk5Ptzj8qmn8Vw/mZ/9X+ NLVJ0sooY7+aMC7T7NEk6Frd8dvTnPQmk0m8jtLyKK+dIbWddgKrujix/dPft+VeJD4SKa0L05S6 WaCK5aTNwJoo8KdoGe4/zzSx3sPL3EcsflMYxAFJlkKnGQPfFTD4hydkaOranai2gwJ5rhx5aIsR HkLjglu2PSsm3tmm33V3NIu2HbHGACoAOf8AH8+lakc9kkjEZ/NlWOKygOnq/nPMSVm3c/dTGOc5 JPPFX7dbG3jk8lESWZgUuAMAeucVUPiRXPpc/9b+OTR9SS6tQb2BftdtdsFZW/dPGOASP89TXRX8 sgsfPjuobdJgYy/mKvbk4znA9awpHOYFrbQ6eN0Fzb3tts5nhfejHuM+xp7Qre2rOgaL5jkE7dvU cV2wXukpe82ee6mLcZEQ89oMoRgBgR29q84urqKa6eEv8wbEir1jxzg12djNrVnuvwB1bSNN+JXh 2OYuod2acRqfNADJ82OhOAQM1+9XhfUp7k6DqN5qcgksdL3SRyW2ZfJjJCKy9Nyrt5HrX9j/AEaq jeUY2in1v+B/LnjnQhHMcFiGtbpfK7P/1/6C/wDgkNrtvqPwl02CyMjWt7pcd1BLcKYZwSemPQAg fgK+5/23rSS7+CPixIrmWCWbT1t4xDCJW83bIo2g9M5APtX6ZxknS8Tpt7+1X5nj13Cv4ZU5w0X1 f/20/gf8Zw2+jeJNa8MLqFu93Z6pOn2WMbJ5wJnBcp2x0P0+tcbq1mtvaWWj2UCTql3NqMrou2dG lVNwGP4fkzjtzX+mvDlV18qw1Z7yhF/fE/yxzpRpYyrQXSUl+JhwXoluoZY0lsoW2xyIx/elVwCR 9SM/jW7q2oR3K2yNJLK6PshWRjgdjgZx6fnXvnkU2tRV0mWRZGa+j01Y7SSf7RNyh2IWC7ffGP8A GsWTVb7VEtbK3nAdrEQLdBtqOoHB9geKDU//0Py5bSzbExXEKvfQ4ildCCJGxyVbpg56imLq1lpO oDS7yWFdRSITx2bjc5DHG4ZGCOD7cV/tAf5HJ3Vy7DNLbW0s1lFC8hiIlleMASrknnPAI6cYrOkv kl08qIIY7lJvNaIqBHIDgMQ+Mjp0xQXFXdmbOr6RPaQ2rRXEc8c1qly3lNkoGXdg/Ss7TrYHyvLm RIWUytKoyzZHCj1zx+dO/u2Kg9bGne3EENvBZwC8mcQH7RI0J3JjgnI49+1RaTfX0E7WNoWh2Wjm O98vdIhPUg44OM89vzoi7O7Km7I//9H8zm1VLazazvWnuPs7ee95HyZe+3aOmD3rUvb97zTbd7QT z2RRdkUUGZCDgkgY49+lf7RN+R/keZa3iaXqUU0VqWkb93MkgO1QegYd6fJCqTQz3EqSi8usrDG2 yWEZBO4enXpSvZWAm1GIJIstheSQoYSksRwCzEgDn6Z/OpNPge1gmhZvtKzBHkaeMFw454P5j6VV 42SZnKTTsiWV7C1Z9Rn3W32CHfKwXJnXI/dnHOCSPyqlZPJc/apZo5W0u4bzbeKPqnHVcj8M1qtt DNvuf//S/OTS9Rki0iWwMaRIHa4ug1is1wyZQAJcYLIQR0BA6jBqa+tbG8isjHiQiDfBdSWwiMeD kbvcbv09q/2sp7s/yIlPTU5XTJY7u8vLWfWo57mJgq6aMMyoP489RyRx79K3JI5LOQwiPyyF3Odv Kj1Pp/8AXq9OhhJ3YGWB4ZZWubaHEJYyO3zy4x8q4z7mmWT6fa2oT7RM5ZDOzkbYwG4CRgdsd/cU Kz2IbsrktleR3EUsen6e1tDpqrHPKHZTKDjkk9zn1qn5tpfXtz9nuWMktvuSGQHaSpxycdccUzGU 1fU//9P87NTntLLSrGHT4JlaVTFflV3Ij9c59G/p+NcvGjCa3azmEiuCtzuBDI2SMenQZ/Gv9r2k 9z/HFybZvXsdxZxW1xbhJ7aQFXmiDSZb0b+6Qada3F7MltEml5ggnEUcrMXaYtgtnJ9+1MhySLN5 aSCUoYQNwLGNRhkxycj86bHpl1qjW8FlEbn5MokbcswzlQPUAE0+V9jGc11MyGyumZ47qK28lZw0 XnYEiMhIw2eRz/Kr9ro6SzLbTRxfaZJTdKkkuI5NmCoU+nf05FHK9rGEp6H/1Pzw8yCaO7gud0iw DaBbYk2t0ANVDqmnWOiLZ2Wnah9ognZJJ8hlVSAeB1655zX+2kYyTP8AF3miVtPuW+ysQcmQ70UH 5h7kf0qK6l1C+ngguWC2UQ3uIThpuDww9q0HzIbeXlm0UFvbTvHJMPKW3eMqIscDBz3rUg1drP8A 0B8XRCEtCvLIMYPPXj8uKAui/ZTWbyPcYYwhP3kSpmXI6fgDjIq9q13apYWwtzm6wzXEgUxhBn5V A+lNJvYZ/9X87Ir1zamWfOJT5CBk+cAE9PbiqD2gt7yzuoZSmyUPNv8A4MHOf/11/t/FNKzP8WHb oahvLK6nLTtcXHl5lAY7Ul5ACqMcDoagVICl3JZQpbMQBIDF8mCeCo6A8ckYNM538RVWGeVp7eM+ YkkQ89mY4TgcY98/jmo4rdVtJrgyBjbSLEkEa7nfJIJGOwxzQIbarqvnTXCwoSrlrQwqfMMaqCwZ T34OcdRirVrq0k0JlgSfTriYGO4cqMOucY2jp379+1awbe5jLc//1vz30uytngZ7e4jjnaUymFl8 uSUfxSe/IFQz21tC6Sx+Yl2ci4Y878fdIPXpX+5B/iOUpNSYK2lytMN4E6Bgd94NwyobvgZ4PAHS t7TNQu2c2lpHLtn/AHa2yKZiBnO0dTxQYy+JkN3aCxvbq/uLa4unW2Mc6pudwrHJ3D1zg81vC8st TawksLa/sItMthBD54CxShgNyvjtkZAPSnHdEPZnrHhCGQ31l5jBI3l2sI4vlAYbfvdcDIP4V/Ud /wAEkbk2ek2umi8FxDawNp4l8vbEFjaPaq+pAzz3r8A+kpDm8PqrfRn9O/Q9q249xMF/J+p//9f+ 674q2rXXw88UQIVydHl2qxC7yFbHNfwlftEwP4f+MfxES7tw7XGt+aJhIu1dsEcW4gcgbo2+pr+2 focVVHN8dSfWH5Nf5H8C/TbpO+W1POR4ALh7a6W8hQC4CBkEg3RMD3C9x71Hc6kqzLHLZW8xUiSJ 8YaJuvA/Kv8ARKlsf501JW0MO/gmkLXDSby7FpBtxtJNK19bW2nx2tuHlmL+bOzHa2CFAUZ6YIP5 1qc7fVlWKVEDvJsSNlySxwB9a2pLq1t7K0NvNFJI8YmcJGysu7opJHJ+nFdBzt9Wf//Q+TZ7ppvO SMMsiMDscbc554/lW7p9s92qk3UG6JQ8g5BHscj/ADjrX+/B/wA7MndmlHAGlIDo7jlQoEinH6Vm SQ3rvMvmvExcEQp8jkBugH4frQYT3IbiBo2KtcIAFBZ4zuEZ7j6jpTbWVVibbLdzuWwzXPKjGeE9 qPIm2lxJt80gBiMZA4wMZ/z/AFqg9hf3DeTE0yLJ8juGKqoz1qeeJDimf//R+ZpI/sFlF5QMrxr5 RaQt+/I9+tRWUS/6yVSqD5to5yetf7686P8AnJ5WWkvL65lKBWMMWREiLkgDJJ4/E0l5cQ3W0wqI 5BEFYLxuIGCfqcVSd9iXHXUqQW6RqJnO987cEfd+n1qreBlQyREozSKADyWH8R/z61UXZ3RhJWdh 8TvE5ZyWLJhYyOav3dvI1vFtJBMe+XaSqpk8Ke+a1Uk9DOex/9L5kWCNII1kQSSZDjzBnbj/ACKV bSOeYzKCiAHMcY4/AV/0AH/NuVrZ2Wcw7XOATuK4X060+S3naUDcoMr7TI/ygD3+nNXGVtGBpG9k h0t0lCzQw3Gy3QECRiQpJI644rOjimv7eaadgreZ8kYXBIOec9sVqtQFjHloEI3OvHqcU6bHymYY RTyx6YHrQB//0/muezXy/PtiHQx+a7Ahcj2/Ss6e3ku/s/yeVGi5z0ZiPWv+gg/5tyWS2ZgoXOV4 GBuJNQJJMjtHJuiDDYXYYxQBK0zKhCnccbN479v8aWHy7WDzJ5HAjwEGCx54zTvYDTF3ICGJ3IME MRnNMuLuWS+a9hfaTGEQA5wB6g8UjOa2R//U+Zvtl1cNtnSNChIHlDbn8KrtbrI+9lcYJxg4XI9R 3r/oIP8Amy5JWJrnzJYYwmxRCOCBjP1q1ZzSD51KoyR/Nxz0x3pp2dyWmtxmQHEyp5hbqE43e9RX anBnKmNRgBSctj61qpJiHzG1WIRqkrTFQxlJAhQY5XbjOffPbpVNCZRsIJw2Ff2qrp7Af//V+YJi qsiKuNnVsYJqeC5RsoELbf4x0Hrmv+hFOzuj/mvI57uFA+VZmC8Rr/FRBNHJGS26M8AcfKc8Y/Wt IzvowJzcrArQMCyjncpxyOhJ7/SkeGTzYroq5CIcMrkbRx2/DrTckgJo5oYHdVmMxkUyKH+8ueo/ Cq7NFJHsMYJYZYNyCc9qbaQk09j/1vmVEkOJZWVVyEijH3s/SnzxT5RxKy+W2Sg5EnsRX/QqpLU/ 5rE/eaJBIUddw75CEZzim7Gd2cxlC3R8YAArIssKwReMkjjPZqgVUaV5iVUomSTwT7UANneORAFb cSPmXHAPpTYYsvhydq9UFAWtof/X+dpN0IVo92McEcYqllAysysG646Zr/oTU2rI/wCa8nlOI2bc YjnCxkcn/P8AWoYYpwylhIgYcjdww961AuykJE0QBUA8N2NUTDCG3IcnbzkZA9aAIUnZLgW2Gkhl QlphzHEcgbW79/0rbt7Vp1CSMqpGhCtjAC5JoFLRH//Q+bPLWxEZMbvDkxROf4iB/wDXFPu/LUwi SAm6nmVYN6cR59T27V/0MH/NOXo1DpKJcCSJtpxgg464po2EsHBZVX5fqKAM+MyMzh04VuBjnjpV tJWYnbuVAcFCf50nJLRhYimUSOhRgpjOST93H0qvczvcJsMhjAbaWT5do9R+tLmiB//R+apLMlVC SO4IBMmfnPfmmPZTmZsZMSrkZIzxnOa/6GLp7H/NOLbb4pMRg7V4Ydqtbbd2V41KuAfNY/ebk+v8 vagC7stnikZ0LSLjZ2AHfP6VkRK0c0k0jIkKx7Ej5yMeg6UATruJbnggsAeCR1plnIJZUa9hlSyD ESIr7Jm+h6CgqMnHQ//S+dr+ytorkmxMjWoQGPzsNIMgdSO45qksrBDEhDKW+ZM1/wBDB/zWKatq WLZ8Aq3BDdT6elLMZFfzEG6PABIGcUEubb0GxstynlAZfcTtzkn1pryeUY4oQ24Y3F0ITryAfWgF KRoSqglcoWMI+7v4b8aqJG7zFosk7fxAGavmtK4KbR//0/mi5e58xXL7gT5ZBONoA/8A1VFFFl2a Q4K5IA6Gv+hqLs9T/mpbb3HNeQu4t2chiuFyML16CnrZpGpRV2bsnOMZz3rYIb6BHG8O5pmGAuFq ru3YmVyULYB5/Og0jfZmqimQDB3KOT69KZcpIFCjJUc5NGxR/9T5hWaRP3ce47m3EE8dqubVdHMm 8KiklUX52OOAK/6IL6XP+a8gaKZBA0qEAjeu47WI7ZqZrpov3YBTucjk0EyvZkcUX2p5ZoWUD5QI 5M7j2bBxj8/1p096unlS7hSx8vJPX2oMRIwzO2c4fkEDgVDsl8/YrZ5wMUAf/9X5q8hAjMz429S3 A/PpVuCQiMJu3R53Z/hPpX/RAf8ANOQ7kZ2TYOfugjIFVJlbed4Cxp0boBQBZj3lQylGUjgnDL6U pilRTI674s43gfKDQBqQNHJAFeNSY8eSOmPaoxFbH/USDJJLov8AyzOelAH/1vApLl7RooYnjmhd hJLFPAsq+/X6VDfPG0iuioiv0jjXaqfQdvpX/RAf805UbAjdonw6YO3HWpreWdozmFW3DAbdhl/C gTdkI5i3KNgjZvvbRySOtSRSQW0wEyO0b8ERnax9ecGi3cwJkNuSzrGywNgiOR97EgdScDPPtSb9 21I1BYHcB9KLJAf/1/BJJCzlNuG25YqBg1RkkGxzGBJIHwcn/Vjvx/npX/Qy92f8z4zf5oEa5Xn5 scH8auxbUVomGXzgMeq+wpEydkOkSFMM5BVmEYwfmz0HHXvVtIrL5AVdvL5KbsbutBnzSMxZdssq xbhFCSdjDKg4yOPypS8l6pE8cShuF2DaMdvxoNvQ/9DwB2t0QQlXMiMFXByvXuMVUmgllO0qVCNg AcAjpz+tf9DB/wAzvNaVi9DavbqzxMGhyFlU/K/JPP0BH8qJ0lZ1W1iabcR+77gd/wAqA5tWmNML uFdEG/GCMYU0y6wQIcgTAYLL/Dms5voUSxAwRZZyN3ynccZzxTG83LJGdsci7X7Ag1Kk0rGMtWf/ 0fnaSwWNFKEuwPUHB/Gp44JyFyG+Xkgd6/6ED/meWw5pQhXcMk8c9aa3myEyDoOPp/nFAxkGHeVc gBOmRy1FwikhsOABggHGaadtgGxsVwu5RGeB8uGB+tE1u8TiQcqBn0x/nim5MD//0vBoUWWMMpA3 cFuoAqlkFpIn5QNjDDhq/wChFtvc/wCZ8vCfMQYAARfKzAcj2qnNMyqyoylTyfUUNt7gCQ3DRxyM 4dH/AOWYOWX6/nUtzb26xgTiSSYj90EfEcecZLDv9KLvYCpskUIgIaMcksMt04GanjVFjIxlmPyl u1K+pag2f//T+fcJHGqlhkH5scc1WvJjMYYUhBkV8g4wzg4H/wCr61/0IH/NGoK9ie5lg89VFosU kY8mUqCSuO2TmnxW87uQbhXQkGONTtKAY4J6daCkuW12VyZEkZimSCVHfNEYeQs7KFUckMMHrQUa EphiaOKI5LJkN1DepFVJSr5Q8MvOcdaAP//U+d4pWU77dyHT7rLyVNOjkae3aCWW3iNs5uEd4j50 hxjZuA79s8V/0GOV4n/NORYj25CkeoqNRIJIyoGC2Du449azHayuWpJJhIipCMZ25Hf3q2RcNOpW QRQrAzM65DBuwz7igRlDKQrbxFzblvMO4HkjPJJ+p/OrKzuEOyNijDYXx8uR1/mPzouluB//1fnN LkWh3tG7yf8ALFhyqHP8Q7iojczGRty7RMd8jqMbj6/59K/6BvtH/NQm1sTQLHMp8yRWeJ8MyKVV x7dakB2SnyRsDHIbHIHp/Kpm1sbJ3VzPubczGYSTI7MRGsEeROFI5Oeg5FTIy2csUGS37vMay/MS Bj1rMZOlsWf7QSgVshkA+btzVC+EYdTFG6Y+UknJY0Af/9b5ws4pYh5nUEfdxVm6gPlLOCpLqQFB y6eoI7dq/wCgG+lj/mwfYSydlhPlthkO5gTjmq8qwjaS6s0ilwoOcgcUhEKgSukfWMjG0jgVNNGr yxoiKCi7chAvr/nNBLkkSSwfu0MjKWztVP4h9BRA88VvJbK7+XncQOrEdMmgjnfQ/9f5zll86HAJ EpXb0wV7UWqNEiJIo3AYLEZzX/QAf81yd0aD2sfk7RKY5HcKdybkx6k9eKhiitxKIbsAiJ8GWA8N 7jjkUDKVirNJNJKxBV/lx8u0UsruZ3eWWQ7sAK38IAqXJJ2Gm4vQZHZx7Jbq2mMbC44gk3MznHLA 9MVbeMXUkPmSW8Qd8SzyHYkWepOB9KFJPQ1Ukz//0PnNfssLx3EkUs0MX/H0kTBTIAedhx8uRxkg 89qhvJAdRxBby2NnkSww3UgmuEDYIDOFXP5d/wAa/wCgA/5tXOKLN7JCxRChE3Vmxjd0xVDZc3My RI4ycJGrNjd2AH50DTTWhctnlVDHhyyttXj9BWFcl/tZQqdhOckdPWgZo2xszeRz+Su1UEbHHJx6 /U5qxrUNtFNaPptpM0Uyfv5jIGhVgBkLxnjOOSaAP//R+Z20yS73mNUJjj8yTcwHA9qrJLHErQgq 6zHB2IG2Y4wD2r/f9uyP+bqG9h9utl5N7a3UMrCSPKSRT+SyEEYzwcjrxx1qskKqjbUUBThG74rA JvWw0yiPAZWeR+Fx90VeZTPbeX8y8HJHyke1BUFZXM9IUST5ZMjOGSQDt6VdtxLeTGCJJDKCUjQD Jb6Cgctj/9L5pj0+8tmM+o2s1m23/R/Pi2eaueoz1HAqM2ZuRIbdGZicEqM81/vwf84DVkMTdCn2 eRSCOCxHIHXFWZI9P2JbsJGlnU7GOI0U9+evH4VlJ2ky7WjqOstDExDJl4Qf3u5/mx7UPpf2KSQW 8jSlMsHz8uP7pqYfHY0SXImjJe2LyfaJVjaVcgFPvRVdMcqwhVzExGSxXa34VVvfH3P/0/mAWxlh IY7iflZjxmq7WothIiwmRygUb8gxDrwK/wB8qmjR/wA5lNaMje3kijVw4XdzsJ5FZ4YTMy+YSwfD bDgg+hwf51UZW0YopWTZNtmaWG0Qyy4PyxJztHU8VokSWzSQywtbRN8kZnUeYy9cj9aXOzMr3A7w DEQ+XDdT71oCWCOxktjGftD4ZHD7Nh4xxj2pXlJ6FWtZn//U+X20+4vRGhUvKqAqiD5m49KyjZSQ XUgDEsU2lD91O9f74u99T/nIbuTS+b5ibB5IIAfaSQxqfbGq7Z8MH+WQnng8YxSLp9Rz20EcEUKM FVQFC9DjpWtHDZGN4XleKNLVhCY03u8m35AST0J6mg0MRGlsY93l+fKVKSq5xha1ZLcC1t3Fm9p5 9os0TFtwU5xuX16YpPZgf//V+a7JtO+0SQ3MoMUkB3SydfNwMYP1qtNHbRSxvbBtgB3rKAwkz/s9 Olf70H/OlT3IpbWeGKMx5Fqg3RW+4BUzySq/57VX+ys0ck5Vth4BxgKRQa2Go84Vlii3BVyBng4/ /VUKtLMPMkhaIFsZwfk56UAS3IMYjijDSylgSykKFH5/5xVuO6cIIJ4BPbtIPMCoqT9edsmCR/L2 pN2Vyor3kj//1vlWDUruzae1g3G3ZvnGc7fr2zWtp1qL25STAIkXyts5Kw5Py5YjnA7n2r/d+q1a TP8AnrwkXKrBLv8Aqf1Vf8EkdKgg+HmhzSLFBd/2VFHZtA5mhlIkkfKseRwVP41+on7TDzw/CTxT KlyluqaROS8mAD+7wRn3zj8a/wAhvEVyqeLlVSX/AC9X5n+4vCShT8JcP7P/AJ8fd7p/DJ8aUab4 k+PI2YySWOvSrOyAJLcFwsqbv+Auv51+X/7Vl5cWWiPOBJ5Fjp7yXtrDGBIJi4YJvPJyAh5/pX+l Fd+y8Ob/APUOv/ST/M7gql7bxbT/AOn8v/Sj8j7nWm1q0iuJ7P8As+cgyTwOQSx9ScZHTpUK3GLT eIy2SFTb0c+lf5AZw75jiLa+9L8z/XXBq2Fpei/I/9f+PmS4kebYnzRg4TcMZOPSnmGRsMpBK5GB 1+lc4Ettci2jk3AmRuDuGcVF9uWKPzJHzHvw2B0571hLdlxlbQY2oKzhyhZH+SIDjcanukurdIw0 MkJI37D3BGQa53e5qYxuZEjW3/cozOxVvLUy8n+9jPbpVZxeq8BSGa4DTrF+6X50ycFj7DrSA//Q /j2uAbdzE4AkQDaez57VS1Fk1OJbTYQgUGTaSFz7/lXjnbT2JzNcKipO21YVwvGCcd6LdHdj8j7m +ZuOR9aiTcdizRmicRGaCTC7PLYdCOxFcfM94LyI2s7RRRjcVVQGdgex6j8Kq6A31FqLZmljmeVF 3Sg4YyN3H/66p2kitK1ssToCDKML8gHoT0zUTaasgP/R/jrkkOVi6liRuHQYqn5l5cj7OsxEAYkq TjGO9eHBO9zum2loQG0VsAsxCnDe9bNraLGp3KzRNyFJxn0q0rMINtamZPNPbySBlOFOFU/Nge1S iUi3ZIVEYmXLtH8rH/OKGrqxQscN1KyPKHe3GBlFwI8cVduICschT76R74JG+6T6VEodUB//0v43 orQwwJJKERHPzkt95u+P1pqJGHdvMbDjYpJwAOwFfP2PQLZiMSKIXIkA3Agfe+tVHmubWJpZ2YsB v4GSw+lFiJ7FK2ujdOXk2guOh+8v4Vcezt7plwDIi8c8FuOaCYPoVrhEa1ithAqFHIOF5XHAwaq2 FrceeYYhK5Y8xq23digbl7x//9P+Nqa5ntpCJIkZTxuQ7vTrTnuYo1iVWJRnA+U5CljXz56BUa0V 5JZm3lhKYwm04Hpgd+taFvabYCjrtBySG/ioAoxLGTL5Z2bW2lAOBjvVS53z7hAcr/q5Qy/Mccf0 pdTRq0GjX0/NukXmQbtjA7G+6yjtxVu4cXMizBFXylI2Bfmx6Zoau0wprqf/1P48oLl/s+FRHlbP yt/Cvcke1ZM11e6eh1HZbz6ehO+3Dq00xX7wCA7uM8ccmvnZptaHsGbpmrwXMu1oGWeTLLHKSjqC OOM9a3RKFSaIQuHX5llbgHOeKVrRsA17OZniG+S3lixM4YEpMCpwMe+QQferVxaNaxxyTKAZo/NT awZ5Bz78fQ1kXT3NGyvdPtg8jRSfvLbyyC5YxOP4gPz4965W3GrPPPLeFPKadjbomQVjz8ufwq6e 45tWsf/V/jxMsKGNptrANjbnBb2z68Vl6ks04DiVVgyFSNhhgc9BXzfNafke1G2tyxp5S2MgYCVv LAjLZAU+9fTfwO0pbrVLW2shbWSXM8lzL9ok227SMqkMx9SVOB6kV9lwLFy4qwSS/wCXkfzPieO5 KPCONb/kZ+u/wZ0OO+1zw8JbNJ3TU7O2gW/gKWjs0scYkVejEcn8K/vG/Y20mx0n4X2kWml3hs7W O3E4GyObCg4Ve20EV/R30lnKOW5bRWzWv3L/ADPzj6M8FHAZjUe91+v+R+YX/BZfxKbD4bar591I kstu9mygbXYyMscQX3w5/I1/JJ8WdRaPw3f26TeQYbOKeZLyPzJ7l9yhQGwSGAYsfUA89q/WvAaH seAVU73/ACPy7xkrfWON/q6+z+tv8j//1v40fi7f6eviPVxcofsd1qrT3ke4SNG2E3hCem3tnpXg xiW/JeDPkmQiDnLAZ4zX3/iZUVTjHGzX8/6HyHBtN0+HsNTluo/5mjDbTxOUQYKcMV7V0lqVVJWI kjkjjyX25/EV+dVbqJ9dFcqsbVnLK8azR4lww3lvlwvc10Sa1H5ZyzBguMkHr9a82r1OiOyNrw/Z tcTLqIkV5VbIjLZil9jx0r1OKH7M6ILSSSWdw0Yt/mt/m/oPXNedWN4q0Uf/1/5Y0hGn3NjHqVqb m2uAJJVtXDSIBztPHBwDWJq11plzeTzaZbak+mzSnyVm+WKB4xgq2e6kfoPrXxc11PRTSI9OvbVY xNMm6MFoyP75HTH6VZvtRmvgkFnIkKiPynCZTf0wCelc8o3ehpzqxBbI8c9rJPK4e0lR5FGGEyqc lDn1q1qN5f3WqR3lvDBp9lLdETRmUlY4jkAKv481Eo20ZkbsNxodvePbRGZ547dZZnCHyZTntUlz fWkUsDyW7/v2KxTmIqpK8lQcex/KpSS2KbtBs//Q/jKutXt7vSp9G1gxTxZWaBpSWnhC5B8s9uor TbRJ10bTknvIbpDEwsYQQbiCPPG/Hqema8dWUSIJq6MvTo7i3neVIfltV8uQsu4Eeh/z2qrC8kt5 HqFxfhRNK1vDECo2BcEOFHP+ODUx2CexqwRNcMcyeaUJaR8jcQD6VrSeQ0QVw8SFdm7PJPft9aoy M9BBZrIJ924H918uUkBqO50rz4LpLS6gil+zBrZCP3W8nJ+b15/Sqg7SKSvof//R/jK0u1MMqJqD lnhj3SmOM/Z5e3pj6/yq1qum20ksAL+dCyAxQhSYVB/hI6cYrnpysYNW0HxrFZrcxW0CW1tJKJY4 lGAnABH6VdtLkSxFQCoHBAGN1dkJdBHI3VjCdRgDTQWltdXBFxKW+cdMkj+teQ65DDb6zPjaYGbm 4t+C4HA47Guy+lzKSs2e0fCEwz+KbDUFs0gFtavuljjzOAm0rtXqS2D09/Wv6AfA+oNP4Z8Fanam 31G8m0iCDxGt0n2O4OFDfuyy4OQApZc/d5IJr+uvoz1v3eNo9Gr/AKH80ePlBfVsHiEtVJL/AD/Q /9L9tv8Agi74luNV+HenTfY7eOH+zvsdgBL5mxreURuqnjsCfwr9cP2nbA6j8NdbeX5bexsJNSdC ucvFtdB9Plxj3r9S8S7YXxLqVF0qX/8AJjxsqp/WvDShRls6KX3xP4J/iqLWw+KPxCTUoorU6drN 39kkkiETtHJK7KCcc9ua8cvpm1O8hayiFvO8JO2EsVMagAvnryDz9a/0j4Pqxq8PYKpF704f+ko/ y84sw88Nn2JpT6Tl+LujnNQSQzWizCJ4bdSoCrtZTng5H1br60y/jnuRYiKyb9w+9HRsSM2QVBGf bHFfV+R83T+0ad1ql7OIbtUAkMbW/wBlaANCCi7XDLjB4IJzWNots+kedeLBFegwParHIm8W6uAp KejL1H0oN1qj/9P8zJI4fIgieZxOJGcyOcGRewbtxk0sRaOaWe6khunEaw2TTAXElvGAPkjJzgZz 0r/aA/yNgrIpFNYuLG+jNn9ogBDs8DFXTLgBiuABwfXr0rLs9NvxcF3W3aEL8iM/LYGTn+laRScb FbHoGh2enf2e019NMpmnIEcJBZAowc59TjGK47T5IvtIgtmGzeUVWyuw88YPNVyRHF2Zsme7tGmV biNJZAY3yuXKtwQOMd+9Oh0nUYtPu5U1uyhtVjD3sUaPDeXXOQiEjoATuH60uRXHJ3Z//9T8yDNK 0+mW2niK/ttShP2sD5HtuSME9Ccjp7iugj1YafI1g8EVuthkTGE+Y3T1BPHHb3r/AGl5Ef5HNpbl e7vbK5iKvG8Zk+eKURjfkcdev4VnCWKeNZldViX77vF+9AXjjuOaTh2Ic3fQdCt1PM4iihe3DAKT LiXpyStWXe9W/jkYD7OUMb2vQBsEB/1/Sp5JGZYSaDUppbG3CXM8Uvk3CqNy7sA7CehxkZHam31y 9oY4VxFcRkrJaqvyoBgD+v5VqlZWMZNt2P/V/NK6v7iZIhJdJDazOryWdvJi5uHjyQW/2Rk8H1qe C6XUTaxx3Dxi2lyIN2M44IK+lf7UbbH+QUndJDtUstI0mO41X7IBqEk67b2NQoaMD5lkOOOduBnt UWoX8d5cpeG3dPtkSko0mdv9Oua115WYSvfQtmw02ILeodxiXJglQPEcjkYrLE2n6hqvh3S2t5LW 2uJylxLGPLwhBOSe2OMCpgne5N3ykshkt5L3S4ZI5reaQRyoGwHCk7CT1B+bOPetQactpGqrBtuA oVlhyxcnA/rWpzz+I//W/OuSC8jRrKTYDkjy2wHTPUMfb9Ko2kz2O63+xJcXDyfumHCoMnkjHPHb 1r/bA/xtd9S1aajcs0zNcLb2ccbC6gkwI5AeOh9Koy3lwsyGBpooo381Fgk+XcBw2R6ZoMSacXUg ty8kjyXC+cAW+ZlOQd3fHXrQt01rFLaxBkllQojJIY3jORuYY9RkduoOfXoMZO7KFhpjPLLBKZTH cbVjjmkaQKVJPGT1NbU91p1jKt1JaXkg2C3DMd0bMnDhCcbcjBx+tBnL4Wf/1/z4s9W8O2sTWVis pu5nEzhlXaNxPfqSM1i6gcTPMhVeMb8YRvXcOlf7cH+KzaW5Jp5eKU3P2a25ySrLm3wfRe2P6Vfk jgS11GaNgbuNVFtCuMTB8h+e2OPzoJc0VNCtZYE1HUNVsFuopbP7NaKeZLVy6nzR7gKQPYmrd9Zv pAM9nNDK94FDSjEvyyAEqSBn2I9a0gurKTTRutBpMM8R08NPd3Nqg8iFsoCFBYMvY5yapafFCdWm i1SKJoZICVLS4RSFJAODx0GB61oW5Nqx/9D87mEkbM12kS21uxkj8s5VeeGP0GKwVv5byS6uTCDB I+Dhty4HA+h4r/cA/wAVy5H58drDcwOiIyPFKjECbnjp6Efyotpbh0kWJlBlXDCTgcHPHp0oOc21 vVi8qxaFJJ5VCh4m3buMnNVrm6X7TaW66ZHZ/YnbzI4nLGVm4LsT7HoaAIbhh9tTyZGLKTjYxVFy PmHB5qyGAkZ4VJTymjnQoGQjoc/jWlPsc003sf/R/PnR3VopPJZSqNsWCMBpJD2Vf/10+5L3XlwS 200F47GMQ7MumP72K/3IP8RVF6NmHEk1lcRlGYzQq0MMh/eFAwIYZOevPNTrc6hYTW1/aTS2pikP 7+JipHryPrQY2toTy3l7vS5sLmWaW7JE0TszBj6n1B9Pau105rq2srZ9WkWVkvY2khVAqKhZd0ZH cgZ/yKcd0RUVoM9V0bWIm8q2gWaOEz7ICMedEhPGP9rn86/pp/4JH6tFNaNbOJGNukkFu8yAFnDA MWH97nP41+FfSMp+08PK/l/kz+kvog1PZ+IVWPeFvxP/0v7ufiKSPBHiIBQ23Rp/v/d/1bDNfwxf tYWEN78Y/GwlWS2lnkjSJJE/drGU3tIT3wTj61/Zv0QLLiPFxv8AZZ/CP0201hMvkl9pnylcadca VMw8zLonlFWByUIVlYZ4ww9D2NVZPMm8meRRGyEbCej49a/0cp9D/NibfMGrtNHGjx3FuzsFPlqu 0jJxwuOe/wCVY00cly8chZN8jLGzACNVHAycegre1tDmk7ssXumKs/2WO48yI9HAyrYHPH+etacN ldX1vZQwQRbkJguSh3Tt3Ugdfat4u61MJ3vY/9P5XeBmaQQpuNuoWacj5yqkLk+/NMiikinRot+3 GJG5CEH1P+elf77t2Vz/AJ2Eruxq2t3PaO5VkZJDtVsZZcfjVa6mnuLyR5WdZBwWU4PTjp7VMpNO xDinuLZWL3N0kAdDDkElm2qnrmpVs71Z9vm26WkMhJDsQRnAyPyH5VMZXlqJwfIrFm6MgwQCxHyo wXGfSoTbX8kyyOrqkK7mZm8p17HA/H9aybtJInkfI+5//9T51vGubqKJriMgIqwxmOEIMKMDIA5P HJ71XMsMVqXEwkEcnlyYRlKnjjke9f73N2P+cyEWnYWy1DV7EPPpGnSyyvOIDcIiyqgcbfusNvOe 9P1TSLjTvL3fNOU3uqkMeO3FaQkluKrCUZsqSLJFApZcCT5lzwant3aDypPLimcqV+dA6xg8E4PQ iiM7aEcnNZFeZGmuxFEDcsRkeSnCEdhjrUzi8ghaaaAskcqrKJX29cke56VrF3VzCaSk0f/V+bEu WmST9yPm4C9QB2qe1ly+y0jkaRY8TqE3Kp6Eg1/v5Gb2Z/zf8itsVVkdNQnjNuwtxGCGY4JfjofT k013nfzFeNDGQPL67l/z/WrTMGgSGJkBkXDfXrU0kbRhFBxhRJtQ8YI/+vVxbT1JSSJYlsksjdyt LHcNJ5ccLICH5x1z/nNZwkc+YCPkb7wbkAe1bDP/1vmRJnKP5XMPTYfajz22ICdozyB2r/oIP+bf Y0LUoZUMYZQFw+88H3HFV71A7FQysSeMd/8APNBMXdajI4IYQkcmPMkbgE4JPXpUtpLAlxOLyHzV 2kQR5KoygANuPY5PbtQUOaMvGziILGBxGnYdMCst1mQ+bbW83lgFZJW5iUjt7UAf/9f5fgH7iG4A ZWnHmGNm3OvXr6dOlXtv2l0jBEe98sfurX/QO3ZH/NvYsvbw2x8kqd5+feB+7PPPPrTZF3QlYdoY YzgckULYipsQiF8IVYIi9T1AxVe6adj5ccrG23CRlJ+RyAcHHtk/nTJg0txXRbuJQPkZThj0yP8A IpYbFVVsSkY6Duf8/wBaqHxEvc//0PmzyurOoaNPlYA4JyP51DbusTSIqYyeM9COlf8AQgf8110n YbdW7FCQhUkbgQuc47VHp7l7SU3I8hFyQuPmO3OCf1+maDOUm9h6CBNl2JfMiuFVo1P3fY4960nk Jg3ZwnTd6UE3bKNpaoZ53lmVwgyjKpXIPantGFlD5ygPyr0xmgLtH//R+cZ2WNRMsZYJz8oyQfal he5Mb3KW8lwEI37V3BB6mv8AoQP+acsxRwy75ZGRSfuqex9MULcCVwk6lYovkTZjLDjNBv2KF7+6 XyIWbDHcjkdOaQW8q26cgO7cFhwcdaBkkFqgLP5ElxIx2KkZ2gMe5pYzcjdGbdxIG5TZ84Az1oWp bjK7P//S+dmkeNY5Ekzzt8sAkqfft3qnJJuLLIu2RRuTaPcda/6ED/mvtbQZMDJNZte3oi82MvGZ CWE4HGB1NWZJ1GPLmVgowADV87VgElmkuIFhDuqxuJAqn5Gbpkj6ZpyvCqASgK5HQcj8K1WoDjHa xR/KF/fscAsBuPenx6pHGs/ytEiRBMEb9xAAJH6mgma0P//T+fFkD2qrIVKgmRAegzj/AAqlHcJI +yQY2n5Ce3Nf9Cs3pZH/ADTlpXCI0YQndzu/ipqnazb+QOmO1Zq/QvltG4tu8E0joH+eM5wP61Kg DSFcD5224zjnoKHe+oQ1diC5TyZGx0Hyg9mP0quvlFfmAHOCccUidD//1PnOCR5Ha2jByrYXJ+99 KSYzLOIZY5ERU3GT+Bu3r1r/AKED/moluT2X2ZhNhuAh8sjpnoKgA3EKWVTu5yetXC9wtoWdkkYK iRTkYJX7pqvDuj3yPGjeXnbu+YH8Kbk0xFZT5rKzFkVWG5lGSQO2KnCb3xGdwzwPWrUk9hqLex// 1fniTzBFImMyr8pXoVxVXYkaqGIErjOB1/zzX/Qwf81PKxlwoEGZPlVmCZHXJOKSBJ4iYXcvA4zE QDgY7f59aBWd+Unt4obKczyEjHG9Thhngf0q00xlCI8gZEYlOgxk0Fxi02mQStKrbtryIxAwKZM0 iSoLeKVFZPnYnIz0wKClBJ3P/9b5tubZpYxHIXj3EOCh2uOQc/jV2YWufKtEdYREoLysGlZtoDEk e+cV/wBDB/zUsrW1tBE5aRVbbzkj5vwqOe/DuSE2xhto2jAUdq1p7WKgmmToRLG2cNs6Z4z7VBMw kCoVVFjX5cKBnFWVFJXsSQs6LuZgVH8IHSpZjJM6iNcx4yT6DFZT3HrzJI//1/nFEMczFUQ45Abn 8KsvOoZj5QBLZ2rwq1/0PfZ+R/zWOWl/MpeX9pbeWI8ttxGTjp0FVjMZLgQuMux2IdvH0J/xqIys rGb3LTyvbRmEIjssmGCgLn/gWMnpUMrs8sYjjRsDLF0DbcU4ytoxEqXKhxEwAOeOOKkMXnXEkqmO BAn3RnLkelaXTDY//9D53jgWeOSFmAJQk55BwD/P+tVkR4ooY/LIOMnbjamO1f8ARAf80vPEl2nf wvJHWnbVCtFJt+b5WyM7aBpp7EsVqibEVgA3AXPFLKqws0L7ZY1ba8e7hv61CmuozOmSeKSOa3L+ Uko3AHiMZ6fzq7ckWcqmNld3jDPGBlVJGf6g1e+wXsf/0fmQmeScyljtHAXHIq4CWfgFwq85HQ1/ 0QH/ADTkcbmd3EOFGcEDp1/+t+lSkzRKYo3USOQMOdvHt+RoIntYieOYgZPKelXLeNpRtY7go4z2 o23Mh8sMyAlVwsbBXB6j8PwqjDJLcJdiEMstvMiecBuCAjJBHv8A0rOUuiA//9L56VnQq2SSMbiw q1L5DMZQCGZASFGwKfpX/Qwf8z7dtySCaxbCjY0mCJWXqh6VXlhMCmQMXG7GW75oMpSurCWuJmdD BJnO4S5whP06mp3hltp0LYOVEmeq+oz+lBBKoVzIyBSXPzY6GqV3GI8GTKhSCuwleeMdKDRPlgf/ 0/nmCNpGMoUbVIDE9Se1aayPIuwQZZT1UAvJX/Qwf8zDd3cp3gkcNCC0eRzglcYOf6UWtz5SFdrG QkKD0qJuysIvJM0Ib5dw6njGKgNtHNtmYs10QBLKSAjAd9o6VkO7WhWluLfZgqzOr4JxlRj2q3mE gBGPQZBGGH4UFSVkj//U8DZJZQyRZOwbjjrirUUgitkaQSGUzBCuMDaR19RX/Qgf8z5DdeSJ2Cxs vbDHP41VddksEaMTv4IAzg+/+e9HkO2ly2tuFBKAZDZPqetRTbW+XGBTbu9BENvaxyXCCe5aCEAn Aj37iAccfX0q6+ACzfvFAwoPekB//9Xwm2lVI2EcWwKcYI+X3xVKYPu+6AHPD1/0IH/M9zK9i1HA UVEDjMmDIBwD/nmo7uxjV1AVk2nJBfIkOOtAy2mYfLjwAZDtXPHNMltpVldZF2urdHGMUupVvdQx 1VG24DHOMAZpt1HaRTRvdSSopjPkwQrjcwHG79KynK0jopx5lY//1vCbSFHiImhKvNgRhuqc8ZHv xU0scUBZmieWS2TYgAPGcHP/ANav+g+5/wA0iVpf13Io0STbLKnysNwUjaTkcZ7+lVYbYwSfvZNo 3ZLgZCjPT1rPndyxWka6cNAjShXCAouFwOOn4VZdVmUpjY2NuAMe3NPnAyTDd28vlSRlpB9zKnoe elEu/wAwRwK8jSKrOGTG0cZOalybVmB//9f593LahAq7WkYDcF7mo/s6gySSMxZmyWYYJ+tf9BB/ zUWdrkzxJti8o5+X96NmNp9jUDxyRyIznCngccCmldFzVrIYksguHh3MCBuDLwQO1SxvLF/o6MXe VizlucD29O1ZuVhKN35E8YkWRVaMEI2SCPlYf5FKFCSSwxR7YpJPNaPrtJ//AF/rUSd3oKSsz//Q 8G8iJspkKxXoeO3NRPECojBVo4RhmxyM1/0BRdmf805E1msbZicPE65Bxt+uR7U2J1EyEBWSP5ZE IOJPTkdKJO7KUminINrmUHa+/IAHGK1JfstwkBdvLZV+eQr932qTYpmR4SoUB0A5INSK9pcJ+8yr KNy8YJxQC1P/0fI9J8H65rj2/wDYtpqF6Joi6fZtPlubcgc5LqMA+x9a1vEHw28XaDIsupeH9Vto vsyM07WExt1Lg4B+XP8AD1xj3r/eipn+UUMwjlFfERjiZbQe7vt5XfRXu9Lbo/5ylw/nNXLpZxRw 8nhVe80tNHr52XV2stezPOI0kMyllW3WNSzx3SmF2+oPOeeh9KhvEEGoQSpK0sLWZQRGPEUBLAna a9dangSk1KxPKnkyxFCr71DEL/BkfzollETIwByeueMUzMryTeawEeWfdt3Dnbk4q5LbtZ4iMiSS MoYtG29TnnqKTaW4H//S+ajHdLLyvLDIPTPv+lX7aQYAlYFx1HYV/v3zs/5qqe9iS4nVlwj7hg9P vA+9Z7Myx72J3DknPQUuaRqXI4lls3k3qvmgAYPzHvxVAKGdkYliuMFv4qkCVZCT5QOBjp0FQEIA Y3i3I5wwxkHNA7Psf//T+axNKiPFGgdCMbfX2p15NcEW8kkKYhjETYXDYGcfU/4V/v2ptH/Nhyvs MMTXmWDYCLuHrwM4qGJDL5IZeY5cjJw4x/n+dNT7mkE1ub12TFZB4tshY4ypyYzkKTx/niqCqo+y 217jEJ4lI2yTA88mq50WZl08XnyJER8px+7GFqOOaYNsAJUjg9lxT5o9wP/U+WvNniaR1Yq54BJO 01ZbVZ45YkWzgRpYViL/AGOOcHHcArwSR94c+9f79Sd2f83cFa5QuxPPJsCxxZJZ3+4eOw7VqwRx fYoQQ/nb2WUkgow42kcfXP4VI5RvsRzREAiCIFo+cngLnjNTrDceSqldrDlsD73FS5WuXayREtj8 6zlCQknKng8UbkWd3aRQM4SNMhxx3NRGfvWYSjeF0f/V+eohJqM1pYRuZJW+SNWJJyTwqivffCH7 N3xV1iO8v7DwX4rk07yVkF5Bpv2m3nRsEPCq5bn+8R36V/ulxBxPlXDGD+u5rU5Yt2SW7fldpabv VL52v/zzcO8KZzxXjVl+TU+aaV23tFebSe/RJN/JNryjx/4F8Q+B9VGn+INMvNNa4UyWovI2juPl zlZQVXDcH5ccV51NErywGVcmInYQeRng115XmuEznA08ywMr0pq6f4fg1b8rrU4s2yjG5LjqmV5j G1aDtJfireq1/NJmpHftbDFqxkLKQ8cfzyEjsB6n+te6/Dv4IfFP4gx2lz4e8E+I3tpWM032rRZU iKeWGWUsVxtJOAATnBzivPz/AImyzhnD/Xszny09Eu7euiTaPV4e4WzXietHA5RT5p6t9klbfRmD 45+E3i7wHc3S65oV5pUtq6K8V4Ngud+TmPgFuFY7QP4ay/CXw28c/Ee8jt/DXhXX/EBCtJL/AGVY s4iVOMseg5wKxo8Z5LXyWXENOr/s0Vq+qfb11S7edjefBXEFPPFw5Kj/ALVJ2Uej319LJvv5X0P/ 1sbxP+zh8XvCmnDUNc8EeINLtYo2uLme70e4gt7aNRuOW2nJxzxXhCRXM6yeXEytwV81THK2emFP Nf7lZBxbk/FVL2+UVeZRdpLqtHa/ra+jf5n/AD459wrnHCtV4bOKXJJq67Pbb0KcQkhkZ5jGWXjZ KA6k8joeKrylLq6MUUcYaJN8rwx7SCeRnFfTHzKdolW7tprZILuAqksrFXJb94m0jsPYipTdzXwV 7sZWACOOQ4GcDt/nvQZku6OQ8E7RxtUcinRm3eNmeORfKJCseC2D1NEZ8srGso/u0z//1/moTX1k UntZfJnAzFIoDmIEY5B46Z4PrWdbKsKNLJveXzNmZuAzcHPuDntX+9lWV3of85lNXdizd7GIG0Id uRt5GarQIUnikdd8YOWUjIOO1Q23ozTla6DLy4FzeyMY1jVpNwijXaqD0ArRcQPbeYBtEZxsDfPk YOcVfOylBsZBe6hZg3VtDYv9pja2j+32Md6itwflDggMB396iFrM8UNykjGQsbdYyxEC4Izx2xmh zurISj73Kz//0Pld7DyGdRJGY1YfNJkZbqdvtknGPSomkaPhwrsDkyJISmPQAgY96/3oP+dZJLY1 rfypPs9ygZ0yY5IXfJ6gkAVfudVtVKW9vLbLO7bXtpowY1X059vyoGYyC5ZWnRENo8pgZl4IcDOB WjK0osvs/wBmkcyH92YxhpCOgxj+XrSeiKirswFuikKyCMvddZYj8pUdNqnpnHrVzT5vtksDfZ5Z VSQebbL8ssg+oHH4VEpXibxjdn//0flnUY3gnMUFq8MTkNLvk8x92OvQda2rCdhNBb2SrNMsW7E3 you0HOQPoa/3brO1No/59cBD9/C/dH9b/wDwSv0zPw90LUIjbpHd6DZ6jFDCpWKAvbROyIMdMFjz 619sftjXyQfB3xTGHVnfTmjgjdtkRcsucn6Cv8juMkq3jLUj/wBPl+Z/trkj9h4OUn2w/wD7afw9 +P0ubn4h+ILr7T5cVx4hlutZuR/pKImI18w9ztAxgcnbX5sfth263mkXH2IvcQT300kq7vszPDG0 UqO2em7zOnsa/wBJc7/c+Hk49qC/9JP82/DKPtvFWL/6ey/M/JbxG8EtxDNbqvlSDbIYfmXIGAP0 rm3ttSgMc0B3W3mgm1MuCB3YL64Nf48Zg39aqv8AvP8AM/1vpK1GEfJH/9L+QWy3GRZJ4llXzC2z O1kzkZHvUyGKOe4KxSLbxMdjyIUY+vH+Fc5MG2tSCSNstNBsk7qGHyt7GqqaeVRppDGnIPk/wsT6 Vg92URmWOOVibcFVXKqeATVqN2mhZy7eaq/Kj8jHoK5ilJrQoiGOWVAYixHJbHKmtK3V9wQOqbXK jPcetBpF3R//0/5AbtEkZ0cea0R+VsEZ5qlLD5SyJGRiVQXA7EehrxzqTtcZt86MTPFsWMY653Y7 1f067htQZbkSNwRiNPMZh2wKTSasyqZSvb/7Tut4I/KzIWGTgH/OazCjQyWrtGsjxycgNjZnv/Ki 2lkaF4wxwylpXyJQGJ3AjmqpkmSVQm1Y9xDsBl3FTydwP//U/jyaaEKF8shmGN3ce9Z1xCYWIhO0 AAu2dwHua8e1tD0Gk9zW1AW39l281nKrXAbbJbONjAf3lI6iqNhcTyC4jlgfbEqmJy3EnBzj6UAU 75nMiyAA7xhxnnjgcVBHP+8EHl7T5e5sdB9aANqDUblLKS02FIi29pAMAgdqrC8eUbSdsZ+XBHpQ B//V/jVvA1xIkQLmNcjcOFX3q/Dp8RFvI+JikgKRSfdBHf8AnXj26HbJtbE9nqMlrdTxX0EUkDgo sYOCv0PtiodRSW5mtxagf6UPKVHI2xtnCnPvn9KLaWM229ygtl9na4H7uWWAYd4TvTI64rMfVfId HBBG4IgU9SeKnkiVBO9zS843Lfd8t26g8HP0pJ3uoRmC3DOGG6Qtt46VEo21RXIrts//1v4zCl1b xPK5Rkb5nQnJUE8np2zViK7a1jeOO0tpxJtkSZ3I2YycjH9a+fPQBLmcz+Z82XOenyDHbFX/ADbq 4lSKARMRncjHYX9ge1ACBZY3lt2t0iuM5ZicoT6A1N9lwqK0SxMfvOg5JqJOzQ7MkUm0QvKkskan YCFOCe2KqXR+QGE4LfNIR94e386lzfQLtbH/1/43YIDPJtWbY+35yTtJB7UkumQ2yFIdqKrmQhic Fj1P4183znoptO5tXcel37QXX2G2+3oq4uEj2OSqhRnnGeKrXUc6JYzhbdrWSZoL53m2zx8ZQxrj 8OaUpXVjcrTTsrkQDfMOBvJCkDpk1ejYPKZbeS1eE2phukZfOkjkwM7c/dIIPPWoAhiCxtiWPKs3 DjtVmeRI5I5U/eRgbZOfl9sVcNGTJ2R//9D+Om50291S7s4oZdPs7JM3E8ssu26IA5Cr3JxwOvJq peQTx2zCT96IXyXRcGMA4BI+mBXze8z17+62S6dFPNIYov3odd6FgIy3tzX1/wDs/aWbXUrV9vl3 Fu/nta5DJkvGynPuI3wPc1994cw5+LsFH++j8+8QqjjwfjH/AHT9oP2ctSfVfif4F0LyYWOoalFi 2nUSPFHHJE5cHttI7epr+7L9mewtbD4XaWLiJrWf7ECYhH5UUhWOOMsfc7M/nX7x9J2pyrLKV+n4 WR8t9G6jyZBjatvtH4W/8FpPEFz/AGXY6ZDFEvlavZuk17EZI53E8Ykcj+6inPtt5r+Wf4hJcaPp cK6hHZa6808sUhWVhGv8ETSg9B8wIB6hcGv3HwXpKj4b0per/BH4X4m1HV8TKsHorr9f+HP/0f42 PHum6fLqWu3epRxpdS6jPj9+Gik5IUhewIUHHvXhdlcJZuUKIse7A4+5z/n8q+y48qKpxRjJL+dn zvDUOTKqEf7qN9ZIxLlWUA4bAO4HNaLyuoBUDHYAffFfEVVdWPojRsilpYXq2zOGvvlIAy8R74yO hptqJ7iOOynClYSQswXLnP8AePf8a82qtzpgrrU9Q8FRQacIrCSWOUopDTsMF8nIH4ZwK9Xtbm58 +O3Jxn93bB2EaRg9hngZrz6yNo7I/9L+Wlbi4txHPayGK8tctliN3ygk9f5Vyu+PUrO4KWciz2rt NJcrcbdyvjjy8fXOPWvjJ7HoFeGwkmRPKUoicjHOT6Y9a147GaG3ify0FtcymOOSRwshkUZwB6YN ZWHbS5VDybiCu5Uba7dOR71o6Pt1q4topbMXdmLoh1MgSNxGTnLdhkYyKmUbiNe6hRbox2lpboFf 96+4l4k7Kh5z+P51ry3T3C2tnNPLLDZxfuoZU2pHu5Ow9845rNL3rFSj+7sf/9P+MPTfsNwjs9rb XxgjaGMOpwuTwwI7j8qv3t5PDIstq7m3iiEbQtFmRGA529cgdq8O9oB9po1dMn1KWNoriS2eDyA0 eyDyrgvznePpjiub1HSGmvbaWG3hBRSgKqFEI4yQPfHOPSlB2dhOyWpZe2uLVLoxSkGa18mEKu0q /OW3e+B9MVovDOtnYLcln+0plZIzzIVO1se+citTF2b0OdkS9QyFvNdIGaJInO+WTB4Pt3/OrcGo CYRRzqYHJ2jaC2Mf3qCoNJn/1P407XUpEnn07NstvdoIEvLhvmjJ5yOOM8g1q2cN8lnJYXl5DNEb gSxGKFUlULxgP1I4/WuKm7mUmnsUtVYFDZxKHjQ8uOJRnGcH2xWdBPLbviE+cFXcY2HEmOxrrg9B Q+I56+spJ4DfG5it7iG4K/ZNjM06tkkr2GK8x1E7i++M5MnCgY28118zaMprQ9Z+EGqpaeINMh3r FcNeRrFIOQoB6MOmPc+9fvL4Q1jUI/C/hO9aza6s4rC10m3KDc08bnLyRrj5thZgcemM81/Wn0Zp Xr4yHkv+HP568eKa/snDSttM/9X9X/8Agiv4gsP+EevdH0i5WSz07VZ7q3j+YzIOcxqOwPmYOe61 /QN8Zrdbr4Za/ayW8Un9q6HOHR8iSEGInA9+QK/WfGSj7HxGqeck/vseRwhVjX8NcLJdKdvuR/Ar +1LLqH/C4/H1tLpf2OTSvFradHqP2ckXFtsV4kweCSXwW9q+fLxtSlcOqBY7QCzDxKFA3Fvl3Djk 5r/RDgOCXCuAUdV7OL+9Js/zK43lKfEOLqT355L5J2X4JHJxQ3DzRx3MsULeZvmnkR2gh5PHAJP5 GmRXLb2uruNrUW87JDGXIMqAYD47A5OB7CvteXVM+NpL4iHT7ZIJr7UtFubpEuAzTqZ3dQ+DvIHO Opz2q9ptsJbaGNZytsZ/PuGhbDMQcYPb8qo3S1sf/9b8220K91PUp5YLu2SwispGjQjLEohZtzdO cEDHr0rBHhy9+z6PeW15HBHqJF1A0x+7HvIO72yCPwr/AGgP8k4RXKbUWo2rXOpafb34cR7YLqOF j5ZkHIX0OM/hWPqUWo2otzaQ+YtxJ5YmY5WPHU478VpFO2hXLHsbFg900x01rJs/YjOr+YN4P97b 7nJ5rDtLfUbyUG9jgzFIDFMUEU4ZeANo4/E81p0I5UpWOhXTNYsmF1fwAx3ELeSJQTK75wG+n19a yjcahbJ9o+zvLbSAiaUfNFbvxtVh75P5UlfW5MlZ2P/X/LmwgvDc2dzbOyqHaSZJR5KE9Rgdx/nt WnDext50QhBdsu8gXLyY9T1r/ag/yNkrosXlvH9kWYyfZZTEVtRKflB7Z9sir1ih02w0k3S2d1dT ZaeSGZZ448dN8eO+OnvQZNWdihDMs2sahfO8cTt5l0kaotvG6gHI44yOyjknpnvPZapCji+lfEqS h4TIuQpzxlT/ACOazcmugrGbPqlxLfTXEKCKSeQyXBghW2jmY4w+1R149qtTzCXUUu7mNpLgWwha T7qL359ep5x+NaLUiaVrn//Q/NOEWa6hFfJGsM9nKMTbdzK3DLsU8EdMkcfypb3TpPNln2WF7JJJ 9pFzbnyltSTkBVBxn1PbHFf7UH+QLSQ6Ca+lY2E80Vxp9ztEtrLCssLFDuDHIPPHBq7d2Ulxpd0u mxW8s1rcKxjZfKnjXkYX1HHT1PTvWnN7ruSEKXF35FvZyQxiF0a9Eync8Y4cLjo3pUmo6hZiWW7F mlvHYEW0DjDFQvGAfzPcmqh8JErOOhlQSW1/NE0KKnmN13bTKSc5rslvbUTpYXd1brDcOIbpo4ln nQY6KT0PPBH9Ko5pR95H/9H83bKybTUNjMbi+1CS5aSzj3/vvLdjs3j+VQXt1e3d0lnDYzWc9rJ5 Mm3/AJaMBgknrnIPFf7YH+OLi0QG2vbe4DTMGlyHCFA6L3G5SOc9ea6rR7mezmcQeW5mHzxtCskL egAIOPwoMpQvsVzZqJru/mm8m46Q2xGRM24ZUDsMZP4VkQCOW5Fw5Eq5Zf3R+WMjII/A1vF3Rzyh 2NqLUEt1LzKjqgJSIABhnjIP+NVGvLK4RpTal4muOIJxtUEAfN3HPPT2pmMlZNH/0vzmntNKjikY Rs0zzLIhtpCsUKEZMYJGSe2eenX1sXUD3UG82q6akkpW02sZgwGBuLHmv9uVvqf4qTTdrFmPSrs2 V09xKrwWKBp7iGRdjDsR9fQc81kOY32uj4ixwOhNaRaasZuLW5ZXVPssEbS3dzLGzNDDZfZjKiEA 8tj9Paui0E2kZgu2lVLaIMbhLtPtMUkh+ZSVxkDtt/wqxGVe2u+7mvNOdUleQyxLuCRD2XsB14qk sf25VlhdzKwxMq9j3INBbcrH/9P8/vL1KGGO2miSX7PHmSNof3vl5yob8xyfXrSFtPM2owyQeTbX EakQwqS0DdyMDI/Cv9wD/FL3lEhvtR8K6nP9k0m5Z49O22s7+Q0U8suBuzngDJ6H0rFujDbyvABu gixL9oVvm9wR7Y96CDe0q6tLme4ttPj+0m7sF8i+8sh7RgQS23OOMYz06+tVZY0ubtVs4rhXgTyr m5nYf6Uw6uAANowcY56fWgCq8Fyk8P8AZURkvIfmRGQz+a6kn7vU9Ont3rZ0/Uddh8+51HREtpJY mF5ZTRiINEQB5iAdOmQR0IrSBnNa3P/U+AftFilnJLptrl95VIZAId5Oclm9q2ReW1rp15d2txNb 3+w26xLGHEisMNtY9D/nNf7kH+I5ySTFEUyxgO54Q/fAPrT7O5kguLuzkS52SW/l8w7oDlg3BPHb qOR+dBjJWkza8pNiCJmL2rmWMmILIu7AwR7DsT61d02HzpLiJmzM2JCZ3JB56r+AHShK+hnVbcHc 9L0OGZ4rWW3SeJLe+jQ3D2xEUjKwZlBIwePTPWv6P/8AgkZdSWuoatl5JkOstfEyDeoEsUe7b7Aq Mj2r8W+kFDm8PMS/62P6F+iXPl8R+X+4/wA0f//V/vM8Uwx3fhbWI8CTfpU4jH97KED+dfxAft66 Lc6f8XdcubXAiuQIHthIEuo/LklDOo/iDDbkdip61/X30R6jjxjWp94v8mfxL9NXD82Q4at2f/ty PhZNUihilt7m4mWMwDarjeXcEBRk9O/4fhUcKXOoNGiMqLvBkdjnag9B6n+tf6V0z/MCq3GWhHqF vK0n2hAZE8vauByMcDH+e1WdBt4LkS20qeawh81pWO1lI4x+orcwNMW9tYQx3Mqz3EcUxjkyQcgn oPce/pVE+V9qKQN8jN+6BO1iPpVxlbRktJp+R//W+Yp7T7NJ8vIcgkD39asEXFtC1vs4uAWO77oG OMf57V/vnKV9Ef8AO5GPLqye2sbiztY/OiicXyEqWbfJGAflOOxPv2qtFBefbDtSMADbJJJHujRe mTwfaonO2rM0ruxoW1hK94sGnMbi4ZvlESMwfPGMda9Zsvg/4p1e2+2WWlahfsrJ9oW0tWmggVhn eTjOB3xmvJx+cYDKqftsfVUIvqz3ssyLMs3j7PLaLqSSbdlstfl6dzM1Pw14g0eBH1TR77SrdFeC 3aazZGuJV27R02gYyTuIJB4HFMs/Cmq+ImsVs7ZZZ3uIlcbZGyhYAqgQHJ578cdRXPPOsulTWNhV i6KT95NOPTqtBUcjzGtiHl0KMvb3XuWal16bn//X5/WfhP8AEfT7OOSLwxqgYXrKXFmzQpAvVm6c sAcCvHLmwubVrqKW2lguIHxNZXUTW9zzyDsYZGc96/3RwOfZXm1/7PrRna17PbXsf8+2Z8N5rks1 TzOg6be1+vpbQ67QtE13VVWOwsL6WAzrH5qWUslvbuyK3zBQTgAjkAgZFdrq/wAFviFp4t7240r/ AEa7txcR4ScTYIyWEbRhtv4VGM4nyfLK9PCY+vGM5OyTa/Ht8zoocI53mOGq4/BYaUqUN3Z2fe3e 1tbHlGp6RcCRbbUVlhlh+eNIgQPLByWBxwDkf99VQlSCOHfF080J5MhBmI78dMV7caikm1/WiPmq dK9VQf8AWrNNdBjlU3FtAYUJEytHMU8s8HHB9v1rO1CIXEmzLbUX9+m7PzA9c/ga3hU6I86vTano f//Q+a4o/skTkvyD8rN0FblnZymNJlaNGMZ81QdpkPGDjt3/AEr/AH1jK7sf84covksU5IL0IXn8 tMMQiKQxx6k1XhtZrgny0eTaMNsUtWvNaxzNN6CbtyrE0IVFJHmYxn2/CqkyhdsYLIpbahznP41o ppktNbix2vmL5Pmttjky3JpJY2kdok+QA45/iArWLs9RH//R+bo7FvKbyjlwQvlgjc5PoPw/Wk/s a5k3bJY0WKPzZBL8mSOq8459K/6B009j/m2lsRu09r5ZjEbY455UH6fnVQGaS4kM6NAy4cDbtGCM ggelMzhe5cb7PdboZyq7BujujwysAfxqpFFJNHcFwr+RESR1MgyBwPfIoNHc2tJUyxG3G+2Zh5SB k27ePftUGoK1rO6bSfLPlSlWDREgkZGOPxFK67kybVj/0vmtN0iALHggdOpP0qUk2y79jPj0UnBr /oEnJJbn/NxFNz5V2NE2eo6hag3AeR8BSYkIZPQDHpxWj/wj+rvYII7MKYY/+PkRMomB7E98VKqq wTozeyK9voWo7tknlKQf9WSWdwBljjHbn8qsXGhXMsaS29vLNESQrQIXXjgk47U/aoj2M+34FRtH mjg81lKZYqo2kA496zWieNtjHaevuacai5kRKnKO5//T+Z3ZonIUlstll9KsIIsE9JCOPQV/0Hcy P+a1q7Q5pWFsg3iaQMdxUYVfbFVY4S4Z35D8bAOKd13E4LoXfs0QhihcLiMfJgcKOcDAqm1z5ivC Y1VBLgEdGHFF0TyMZI0sBKgIS3y+gxU7RTpErMhw4DKfX6Uw9mz/1PnYhnQIhWMbOS3QnpVeFJ9P lunZ3MckXl/ubotAfcrjH/66/wCg/mR/zVezYlsUkD7SMk5xnqae0cqZVwVYfhilzxNbFi1QMGjY LK7KfLDH7pqOKQvtilIVI2yWC5KDuQKlzVrIcV71j9Ev2b/2EfHf7R1kuqeCNQtLeyjjRrd7sL5d 0ZI1fe6kBsg7hgHA46mvUfix/wAEufj98JPCOteJNZsbPWoYbN70HSUBu4AvYIpJZeOVwOPev57z nx3yzJuL1wtV5PjUdb8z1t3tr00P6vwP0bcxxPh8+Npuon7J1EklyrS9mrNu2zs+nQ//1fnK5iuk kkikia3nt7trWZSNwV4yN65x9PzptwNwHyrHJI4DSdBjptA96/6DabTgnHY/5sZK0mmLIIw1vb3R 8yG3U+WwAJQHnaM89c1Tksoiu63jEYDZX3zVklsWwbA8xVXaSzA4ORzjFSC3dIMyRgOf9WJeGC+u ffFWp2VjKS95lZre2kkVVZ/3aAybhgBufun8qbLCqEYIMTDOT1U0nO43Bt2uf//W+dvLhkt4YseZ JFl9yjGeB1+mKptAqgy5bJ7Efdr/AKD27bn/ADVezZbhkjKgkZwpU5459R+lJEryzQWErhZLu4Ed v5KGRznoDgH069KznWp0o+1nJKK3b0S9fI6aVCpiJqhRi5SeiSV23fRJbtvojp5vA19p/wBuK7Ir tAqyF1kbyyeivheD9PaodQ0C/wBNIlkCyIu0NJHu8sMVztwQDkYPtxxmuWhm2WYyfs8LiITl2jJS f3Js7MVkecZdFVcfhalOPecJRX3ySRkzKk8a5DeYrcDHB/GmQxKd8LqAANwz1OK7YyTR5ThrY//X +e47RZJPNLPAkTc/wmTHHNTXLguBlXXGCeufav8AoQ2P+ahqzsQx2sAjzCzBt2McbKu2Wh3GpmSS zt5bhoCVYpEzqCDgjIHX/Csp4mjh4SrV5KMFu5NJL1b0R0UcLiMTKNLDQc5vZRTbfolrsWb/AEC+ 0xlSeGVNwyN8TJ/MVhPHKu6PBLscYxwBRDFUMRCNXDyUoO9nFpp9NGtPImtha+GqOjiYOE1upJpr rqnqSmzMcQAGWbhh6VUubUpFtTzIZNwdHRtpODkg+oPStU+qBRsf/9D5rsxJHI80rNlh8wznJ9at uDu81UV2C7VJHAHev+hRVOjP+a+xpxpDLZyECJ3UASROPnTngr27dazcGMYPAHzAEdKtO6ugtrci tpWuVZHh3JI/DgcClu4RbeSYtzvkl8j5FAI/WhtR3AuNGZ4FkVjEwPKjoaIraWFSRuuJG+6p5I9A BUqavYtRaTP/0fFYvC3iKe1h1pdL1Kew2EXE0FhLPbWuADmRwuFx0OelYtzZyQuDE6SDzNsu1wRH 3wffpxX/AEH0sXhq850qFRSlBpSSabi30a6fPz7H/NrXy/HYSnSrYqlKEKivByTSku8W91t8mn1R BcPEm+NiFZB1UgjP51DEE24ZQQx5I6muk5ZvsTzxMwjCR+UkahRtyC3ufc1VeLylDM5l3HpjBX2p 3drEJ2ZEXWPOASuOUHWtW2jk8sNDDNcPMQsVvGhMzluFUL1ySaJ7M1T/AHiR/9LjbH4J/FfU0hub L4eeI7uN4hIsttaiVNrcZJBwMehqTU/g18RdBF2fEHhDW9Ljgj8xLmWydreUYz98cDA659K/3rfH vCkcb/ZssZFVb8ttbXva17W+d7W1uf8AO9V8O+MKWX/2lPBSVG3NfS9rXva99ulrp6NXPKHe3Wae 33hZbSVoJ03DCleM5zjBxwR1qh5UckpMeOfmVgOPrX1KlaLZ8byIsTQtcOny7fLUBmH8WOKhd2VX gidowzAuAP8AWbfX88fjVKSbsZtWHwBYn8xhG2FK4dQw5GMj6VYWBDEJY5QSWxtycim3ZXEf/9P5 4RZLdpQrJI7AqHxu4PXH5U63lYP8ygs3GG5Br/oW50ldH/NMop6WETzBKUZRuRiW28jA9/oKlubY zgyQmJcdU3YYn2BNVdtAklsZoklQiJ1YOpxn0q0rKUdCF8xm3b8fMccf4flQMI28lJYmc4mXa46h ueP5CqO2GFTLIzjyjjkFy4Jxn+VNNrRBY//U8BsZdPEbyTtuPmBAg4JBqS5MNuDJbhJSxAAI2qR7 55r/AKG+eR/zTlKJI8oqwRwRrkkxggkn2pZbcs5nEW9o02iQjhRS5pIUop7jEjnMH2hsFAxzjipb Y7yWiPTuPWk23uZW38hzrdEuXYkM+7PQDtz/AJ70ogKSjE4t0lYNNtHySEcDIHpzWfOloPk96yP/ 1fAkXzJrsrOs0aTeVvC4AbGf160kqOWKooOCA38I61/0Lp3P+Z6Ssmi3GhwsTLHgncMKAyfj1qHU ZMSJGm0RD5RgYyaZny+7cgiuGa1ns1nkjlQ74vkBJz6VYj3KifactkbXIGT6E0EFUAwsVhLADsx7 fnSrF9pUgs2QcgZ4yOlBtH4dT//W8Ut9FmtreW7uWkTd9y2Ktl0A/wBZ9BkDj1rPWZ1ZnhLBY/4l HNf9Csm1sf8AMzZN+RJITchZScOxG5SMN7k0htnklify1CwYKFeMnBGT+ZrJ9wkkrWLJjZsgjanQ 8daiWGVSyqeM4GT1FQ5bKJUUrXZZs9Me5v7awWMCW8uBBHI4wiMf73fjv16V9fWP7C3x71rwePHe h+FTfaFJAsqmAPNLJmPecDAfPQYCY96+W4m4vyzhSnQnmT0qS5Vql2u9d91Zde6PveDeAc643hi5 5StMPDmlo3du9lpstHd6taaO+n//1/EdZsNT0WV7S+tbizvraY2tza3ELQTwOnUOpGR24PrWcpuL pV3gLtONwGB+P61/0DUq8KsI1qcrxkrprZprRn/NPWoVKM3QqRanF2ae6a0afmiWP7U8qxzRqz7g qNGuNw7cetd34F+G/iD4g+KtP8PeG7VdV1G8uhbm1hlEdxbZXOdp688cd/SscbjqOX4WrjsS7U4J yfov17eZ25bleKzfGUcswUb1aklGK827Xdruy3b6K7PcfjF+xv8AHb4HWia/4t8NTLodzGkiyIjF oVfGDuA2nGQeufavlkwxzOVQlJEYowcFcY68V4vC3FeXcW5d/aWWvRScWrp2a9Oj6aLVNdD3ONeC 804Gzh5Nmy9/lUk7NJp+vVPs3pZ9bBMojxEh3SEYLMOAaqNNsdYiCZFQiTjvzyBX0yk3ex8e1Y// 0PCJY7kW8ADLIrLuO0bWTJPDDHXjPfrSBMp+8+Xy+Rxwa/6DYts/5nrLsSQSpK285PyEJg45xgH8 D/KoZFCkKZC0u75wegNQ5NqzGaaxrdy2dnES17cyCG2jA5LkhV5PAySOpr9H/hZ/wTH/AGlvibpM Wt2On+HbtJWUybtZEUhTH3VbawLn8hivzrxD8QMD4f5XDMcYr875VfRab3+/Rf5Wf614WeFuZeJ2 Z1suy+VvZR5nZXbb2S8tG2/K1tbr58+PX7Ifxs/Z78Qw6d498F3drZXLP5WrWki3FsqIN2S3AY4/ uEnpwM4r500vw9feINeXQtKi+33skohthIwhWQk/KCT05PbNelwvxdlvFmSxzvL5/u3G7X8r6p/d v+Tul4fEvBmbcIZ9Ph/Mab9spcsdPi1srLden5qzf//R+0PAf/BKb9pvx5oFnrdqnhzT/PhxHHFc C48vLZDOS2DxkZAHFXfHf/BJ/wDab8G6RLfXVhY6+1vtmWXQiZNw43q6hNxxg9jX+vFf6RnDmGz/ APsarH3VLlvze9va6T0/7dv/ANvdT/Eiv9F7i+nwz/rBTvJ8nO0o+6tL8t9/+3ut9r6H5k+IdFv/ AA/rV3our2V7p17p8z2l1bXluYnSRGKkZ79KxZImKHAJx+Nf0HhsVTxVCGKoSvCaTT7p6r8D+aam GqYerLDVo2nFtNdbp2ZGsV0kDSwCNCjBQN20nPfH+FRhs/us7Zm5DE/n/OuhTbMJxUNCWWB8onmA rj94do3nPUZ69h9K0Yrn7GgaGKIFY/KXfEsgA6HhgetJTZSiorU//9Lwm6v53eJ5EtihfKiKBIdm PXaOvHeq9x+/mcqMW+SV3AB/bNf7/qbd4n/Ni4Wjc3/D2k3Wr6lZabp6PPc3kqQWoI2xyvIwVByf U1+gT/8ABNj9oO48FW/jm+0zTn0qa1OoMLC4Zr2NAOU8tkzn/Cvz/jfxIyrgaWHp45pyqtJLmtpe y6ddbeh+rcA+Eed+IGXYzM8BeNKgnry812ld9VsrX9fJn57a9pNzoWs6npd/C0Vxp919iljdf3gK gYOfQjBH1rMuoBaSxSB/leMM3Zkz1Br7TDYyni8NTxlB+5UipL0krr8GfmWJwdTB4qpg63x05OL9 Yuz/ABQkkwkP7gMVjHzPjoPepoCSjSJyWPcfN9K6k22jlrJRbR//0/DposoHZQZCxGU4447VXkRd qwiTaxbcwA6getf7/o/5rEloim6TI+yMFlb0PAH+RTjborwkHyliGGjU7Vf8PbFNa7ESVmOnjX7u zlx97sP85rOvI1eKK08wlRgYP3jtbP8AOg1exaWMRgKTuMgCIOpf0ouljtFieRoxuBATgbsZ4/Gk 3YdNWsmf/9T9zP8Agjv8KfDOteHTq3iDSLK+uZNOLrFqFjFdtEu+MlFZlOBlT+Br9bP2nfgR8KPE vwq8U3GpeCfDy3Gm6HczWt5Bp8dtdwlIXZAkigN1Xpnt9c/2R4vcZZvhPGmph8LWapxqqKV9PiP4 h8KPDrIsf9HmhXxlBOrLDud2tb8if9dT+GP4jaYI/H3im33MsKXsZjtIW2/ZcxRvg44+cMCQPU/W sd2jktbd9km9U2ukke0KckACv9IcmryrZLhK03eUqcG35uKZ/k5nOHjQzjFUYrSNSat6SaK0oCZY kFgAwx29qpkPcnzmbcAdox2+v5V6Dk0tWeZZSTNC3jhjjklCAkfJkds//qNTRQW93FI73cFpPZTp stp3Mct+rH5tp2kfKM8HGaly1SEo2TbP/9X52vlu2/eQRnCg4XOSB65qFIZFjiBjZHePc285bn0r /fW757H/ADXR+FG1oPh691ieSC0h8+aGMzyR+YsW9VIzgk+/ap73TWiuDb3Vq9lLD8s1qU8qZOMg 4PrkEHvUynG7h1GctPcSRyJauy/M20uq+WsajoTj+laU9uIhbSRSRTloyZFjVi0ODj5sjHOM8Z61 mnq0bq0YpsdJa2scXmyl/tCkPAYn/d88NvHtVKF5opcNaC6g/wBY7rLsZBnnjFXB2eoz/9b5omZX eS5gVo0B+56Y7YpxvI7iFcjAjzuY8c+9f76SlZ6M/wCbqEeZ2JLYTIMpgLI2OnQVZlt4o0LxndKD k84UDuT9OKqDvFMU1yyaIkllitYLi1ns7y3lvCJ4pJXS4RAAMKAuD3PJ9RxU91bLLJEyssSsMgzH 5Bnp0GaU5coQjzOxQsba4EUkc8ChJHMkbCP73bhsU9bOaJ0URuXfJVSpGRzyKcHzRuU/dnZH/9f5 tltY3yMDIPQdqpPbrb5Z5xDJHjar5385+YflX+/B/wA33Ww24tLw8qftVusnlSX8KsLd327iMsBz 7f05qa0gnhjdfP3Ay7oVI5jGBn9c1DlZ2L5Xa6O38FeHpfGniKw8NRysl3q1ytuki8NGM/M547DP A7kV+53wx/4Iy6l4r8Had4pPjfVFvNX0ZJFt5WZBCXQP+7JjyOox0r8O8YfFJeHWGw7p/HVd72T0 2Vr6d76dEf0T4E+DT8U8RipYhXo0VZate9u72s9E1bXqz84v2nf2P/Hf7O/im50q/uFvdMhRdt3e M73m0nZ5hIX5hnqSM/zr4ka1IuZYpoirJ/EUIVvoa+54E4rocZcP0c8oK3Olf1W9vv26ba2uflvH fCWJ4M4jxPD+K3pydu9r6fl6H//Q8S8GaSbnx34AAj84XXjK10+4gLbVZXb5s49jmv7ov2RPB+iQ /CLw9eto9osl7p6RuGhwQoVcD16AV/pL9LjMsThchwNPDzcbyd7O2/8Awx/mP9CLJ8FisxzPE4mm pO0Urq6Vv/2mfmt/wV/+Gfge3+GlxrNpo+l2etLFK1tdLaJFLnZs4kGDuy6geuec81/KqlnLFcyQ F5nETgCWdQu8Yzxjg46fhX2n0YcxxeP8Pm8XJy5Z2Tfz/wAj8q+ltlmByzxPlDBQUVKCbSVu3T5s 0tJ09Jdb0qRpbgQDVLeG6NuhlnMcsyRMAo553/gTX9xP7BvhzQ4/gt4eZdGtYpW09EctHiUqAuzd 6cP09Qfevl/pa4yvheFsH9Xm4vnd7adj9F+hNl2ExvEOYzxdNSUYxtdXs/ev+B83/wDBVD4c+DYv g3rfiaHStPttV05WMbpaqzOPs8rknjgK205HrXxn/wAEd9GtLue9iu1lu0gmkM13ghX2hdij1A87 v3Nfh/DWbZjX8Esf7SrL3Xpq/wCutj+jM14fyjD+OWEcMPD3o6+6v7t/lpc//9H+3347eC/DPiL4 b6/BqOn27xjT3KboQ+0bTzgjrgV/Ch+0tpcGifGrx4NMkWz0yPWza2EMQ8gxqI42LIg4wSzAkdwa /vr6IWY4zE5nj8PiJuSUE9XezutdT/OL6buSZfgMsy7GYOnGEpVLOys2lF6aev4eh4YiQzOqyFnZ QGXdn5yO9aoeS1Q7E8tyfvjq3av72P8AOQpXF3bxwyW5tPtN3dMPLkkkYeUc/N9c9PxqFrN1wkqG Jwf3kfZfpQO2h0/g7RP7Z1eLSVNujSOFjkuH8v7S7uqLGvbPPfFfut8D/wDgj/afEjwTpviWXxZq VvPqdmGe0iSK7tcuN2TKWIHboOPTvX4t4z8f4zw/ySnmWD0cpNN2T2t3TXXt2P6A8CfC/B+J2Z4j A4xtqlGLSTtvzauzT+zZa9Xp2//S+mf2v/8Agn94w/Z1uYdai26hoqqLOeGHC71TgOcLgMVOdygj I5xmvzZv7Sa2iiV7ZgGkHmwlCJLZjgqHBwQeRX+zXhfx5S4/4Zp5tde2XuzS/CVul9dNrp2srJf4 P+KPh9iPDvimrks4v2e8G+3a/Wys/R9d3lOHaZ0dEYJwCj7iPw/+vWnEdlu4JAVsLuUZwfT9K/TV qrn5u1Z2ZDGlq11GfLVpI1IdWbhz2Pt9PaohYSJBNdyESJ9rMKoWCSOAqtwOncjP0ph5E8DzrFGs aIkLf6xJ+fKyOo96ivtMuraZEtXhniZDIslqT5O0YOWzjB5xjGeKCWveTP/T+WIg9w0kJWUOi4Vy mVzzTXsXYCAtsdeSxPzHH/6v1r/eg/51xsbz2ivEkYyfuSNyM+oH4CpZUjkt5J7hkEy4WJmQkZII zx6ccd80FKLauV7KaXcuUR3hQeYFG0MBxnH9a2b3UJG8r7NE8YiwcsRuU+2OKmbsjaMUnZGK82+Z 0awkidlEguQcwuQQCPY1q2k9nEUj8qRZwwxJE5UN9RWPkbRjys//1PnW5tWumkaEEuigvET85+lT WmnWsTeZPNOr3DpEWiHzxbiFyPYZyfbNf7r4mVqMpeTP+f3LlfGU492vzP7E/wDgmFYfZPhNp0e6 Ey2dhBaq6nc0qLbKm70x8vb1r2/9uq8l074L+ILiMxCNVRbhXi3SOCxztPp8oH51/kln9q3jO0/+ fy/M/wBqaUnR8F1JbrDP/wBJZ/Ej4kvZDqfiKW2a3kt57tkjniDMZG4ZlbPdTgeny96/Nr9rXxAY bu40y+ktp9UubQTTWUkQjhkj2wxsPlGAQAoI571/pFxrNUOAa99LUv0P85/BNLEeJlOb19+R+Xd9 DE4lWOCG1JdikMXEMQzwB9KwnWQoC0gUxScrgkuMEV/jrjZc2Km/Nn+tcI3pRR//1f4/lvPIdnxv CtujbG0D2NW73xBG1msTQhp5HyWVS0oHIIHb+vFcU272FFWVhlqWToAAw3YY5Fal7puof2aurGJB aCX7MGSRTh8bsbevTvjHFZS0iykm9EczIzsjO6jCc7gDnH0pj/6mS4gkZ3CgRxqNrMenGaxNFBW1 Cymu4HkW4j2H+LcMY/GopLuJRI1q4a7hk3CNj+7YHsf1oLSS0R//1v5DdGs7nVbeWaMweczneHlW PbtGSME59azpiEZ2KCUKdu1D1PvXjnZBaGfDLJukCgmFhwh6rWmGRoh8qqduAcc8VE30NEraIzlt mDM0n3pDkepqYtbqGR1BkUfNt6ms7vYcVd2ZnSJE0Um7LK2GjRuG4qFyWQTIhPkrlj3X14pubHJW dj//1/42/MuZ4S0W1ZN21WYYKjHYetWLaG7gjfzZA7zgCRM5AAPrXhKb6nobDruL9zm3DPIgwccH 3A/IVv6ba4tV83glACCMkZ9atSTJjK5h38LJdtEiK8WzduPyurdePauaW7AuMSBlkGVyvce/rVFG rb3ckzJAsmI5j5ZyOB161bvrJ4JbVIXjZV5kAbJb3GKAP//Q/jgnaSBlKbWYpl1ZMjpx+VZljqN2 QBchYPJkbIDbwQG4O76dq8c7pRuad3Nb3oa6hkgfyRtcRsMlh61TMi3SCETbJjHlEHGMdaAcVaxV he5hfbE0aR2+fOjY7TdZ4K57cnP4Vo3Wn6WpE5uMxfIwVYMqrNg4H0JxmgpK2hO0NtCpkiXzpAud /fH0rQsZ7a7t0MeH8wHaGG3lcgjn3FTL4WNK7sj/0f45ZDDu+baWJ2mE88fypstpGICfKMUcZ+Vx wPp9K+fPV5ES2sMXkpt2uynI+masAwRrKRGsbyfKJN23B9uaCrIoXEkkjxvIrqYzjf8AdAx396nO p8gK2/PyIrDp71nNdQaurD7qW5hGH/eRhvNWF2PlZx6VXjBuIt/l7POOMIc4IPQVmYtNbn//0v43 MMZo4owqTyt5UZdtm7HoTSTNdSSLZ3UQiVXxJIxyTjoR9a+XPQSvojat0hCP5rZjii4YfIBjufXv WZfXFisaIGMbSuRED0ZuSCPrVSjymzWlkUofPWSNnXdj75J7dBWsXjVJEgiWNmH73Yu0knuaka8y Z7W7KQoPKKAF5dz7XA7AevvWcbpbaTY3+qLFTGeVJqo9SZ7H/9P+Nm0/tH+0raeG2indWZYRKS0c Snjkce1XpDM0c8N7KkUIf5mibh/Ynpwa+bStM9RbM0bAx2kcbXNy0hWXbErLg4/h6c/nX3P+zrb3 N4zvBb20622uafdRm4TkRjiRHPdGDDPuRX6N4XU3PjLBr+9/mfnHia+Tg/Epen4n7P8A7Knh5tY+ NngqZdKggcX0pS7s8edFsR2EEXqCBjvn1r+6f4NFP+Fe6ITF5cTaTGkBueXJUHJ9+TnPvX7B9Jmp zZrl9B9Ir8f+GOb6PlFUuDMRU6ub/JH8yv8AwWe1xo9QsLSSeR43vzD9pspPMcKZJlI9lLgKx9Aa /m++MF9ZaToN8spuoXeyNyi2kIu0mZE3hpCW+Xqo7n5ulf0R4TpUvDWj/hZ/NniBL23ipyLuj//U /ih8e30epeIL+9hkjUzFGcFiqhgOdy9Aee3avPMWkkoTezSFvm2j5T9K+j4qkp57ipL+eX5s8vKY cuDpp78q/I6CK0+z+VGI1l87DqQ4Mig9jjp0q9LDqKCNY8GOEfMnl7nIJ4y3bGa+YqdD1DsILSUQ LbyeXHJHEJWIUZIcAjkdaiFtNBIUVd0pTzEwcRyA+tedU+Nm0PhRraI50y4867nZruadXiBTzFYg jCYHRa93dpb23hjvzGdRhPnKUYBNrYZQMelcNbc1g7aH/9X+UH7HLGZN1y/z/vHLPuA4HA9q1bGz byFlR1CtlGwMEkenqK+Pavoz0CLe+mEqd+13LFxww/Cql7etOsMasxVGLRqONhPcehrP2b6AFsZ2 N4DJDcyRopW2I8lApHzb3/Edu9dVYyDTrSFBZw29gFM8k8EgCKxI3KFx0GM596OTUCGe5t0kR47l As524wSM9hu6VhT6lcPcHYzhYG2RySRnYCD1A7is3GzZpJWikf/W/jLis5oUuPsxKPt6HADUy481 PIjTzXkkPzER5Ctzz9OK8B9hNe/IRHgu7uaVbi6je2CrMqt5cMbY59jWpZzJE7TffLjar9QQOnFI mabtYy9Se5d7c+aQVVsQooVSCRg/z/KoZbS9nFt5lxPBHaIT5SPt8xeu0+gySfzq1NrQytbQbbXb ATSSRssaL1f72QfSoY5YJ7kZldZA2/BTajA+9ajSd+U//9f+MtLOG885IkRhGd/mMdqgj09+lbum 27sP3s7SKpxG2QuSP4eO1edSZn7N9S3Nptu8M0glRGHzMwk/eIfQVz2y2t4mjAlE0jELP1VsdFx7 /wBa7aY4wszEvpx5eySPY0Zz5mMDn1rzTxMYLS/NpbSxXRMImkmgJkiUn+HPrXVH4US4aM1vAl81 prOkyxowaTUoLS4mjTfIiSSAfKPXOOK/oF+B8Etx4C0a7m1G7mvNElbT7TT54SyQqCXJ3Z6MWJ29 evtX9WfRnnKOY4uHdL9T8C8eKa/sChNdJH//0P0G/wCCL2tELewyTRR3b6yLB5LazW2S2aONZQhx 6jGT3Oa/p0+JSwXPgXXXlbeTpTIrphmjYp1H+Pav2HxzTp+Ic2/5keF4epT8M8K11g/yP4TP2xbi 9s/jn490q5tSNNtZc3vlLmS6uWJKNGeh+UAZ7Gvio3bxQrFLO4t1uPtRgjPKFT0de/Awf6V/fnhr UcuD8C3/ACI/zY4+ilxJiUl9pmPLrRvnQLbxRDkKix4PP97PJqvqGj/2jbiODUES8gHnyW8kZzIo B+UMOMk8V+g83vcp8LS0bRQshNplpbul1HFHLKyNBC4MhyCpDDsDnv6Vq6bLp8Hhi3Wygv4b0NJb 3lnMBIImDn5kl/iVs5z259qo6IK7P//R/MG1eW1huTazStLO214AuY4DjqD6nPT2qpp0rWq28RV5 oLTC4GZCQp+514zzwK/2gP8AJSnsdMbXToCkkVpFHFezm5aeOPMkRPZsd/rzxUtt9suL4Q+V5mnK i/ZnLZlMmTuBHQDAXmtoO6BfEU7y/XUPEqxaiyaSD/ozXiQmRCI0OOF5/hx9Tmqlj5l9fo8krfY0 ciWaMbHAHcD1xVGb3ZoQ3F1cC7eXWWngtj5FnNPJi7uOdrDYAAp65A7CpIRBFFMkola3KB/LJ3Zc fxUCP//S/Ml7jz8vA3kxquTG6kMcf570/SzpEF29xctcPuiIaFJggHoUBBHXHX9Otf7UH+Rzta1x Li8d2i8qJr+JHMb2zD54F6hh6jk5Gc0yKGVYo5HR7dLt2W33IUDEHBwDz3H50ETRqGGzsTarfWpv IblwvmljC8UgPCqOcjoST0xVRtNuH+3m5MLfZn2xCN1Kgk/IBgndwOo+tKyuZlaIT+fHLdM8beQr ASpl1PG0Y6Yra+x3d5bPLe3HnHaGtltwirt7EkD0pmU5dD//0/zgS1hlTyy0YdVCsrnaRnj/AD9a kjtG+yX3h+A2qXWVXe0hRk4OAJB2Pev9qD/HxzS2LYgtLGMRBopLkYiXymDqzAfMU9Rkdq5qJtSt tSluLYzyZZvMhPKAHrn0I9a2UVaxlKeupuwWupWqSXsdrOLPUH2zzvGSisvON3b6VlW+mXEhdp9/ mPIVjhI37ucBvfNNKysRzob/AGHfxtDcmI/uL1YnQMBIj8kArnjoevHBrWGjsNVtjfOI7NnSedoX zPGm4ElT6jn8aZLlqrH/1Pzr1HUbePxBLdyu02l27hIw8Z8+WP7qlmHfGOnpVO6isJLuK5W5kS1S Xzim4iTI6ZI5/Cv9sD/HVtNOxLp+m65qF1NeW1rcSwWsXmb5R8lwpOAFHU4xzW1cwpc2j20G6G6k HyPE/ls3r8w6UGIq2Wlaalrc3moS3FxBA6LEkbSokpUbBJu+8eOTyOT1qlFdiWN47hEiGxnV0iEZ Zj6H09ua1grIymrMzjYO83ltIEzB+7ctncp6YGfei1s3srC8t7qUyrPOEVUhyIwCMN6jvk8DFWc8 oPVn/9X87pIkbSYtPSZ1ube+YzXCL+6uQBlWUn7wAOPTrT7Z3WLyC3mxA/ebqPp6V/twf4sNWdjK 1DcTNapcJPb3O0MsG6VoipyVKjnIwMitK+ttNMVg1hdC4W4QSxyLmLf0+UqehHII6VUU29DKb6Fa 7unBSeC1ji8qT5l2fuJCO2PfvTba0SFGvRqLGG5iIu7OZcJbuD8uw+nf8a2IurWJIoLiSyNtAu+2 lBKXJYhiTg4Ddx1/OoLK3u9PuI/OkCWRVlkCfO4YdOM98YoNrpq5/9b89DPqKXEe5Iljm+aUMQZi mPlOfoO/rRIYYrlpSy+XtzIyjJIA7/y/Cv8AcA/xV+yJPDp0llI9vY+RJKftU7LAtu+MAbsjk5GB VkWWlXVgtzpVjqsf2iHbJNNci6tnwADgbFwD35oMTJbTvKtIiT9nktvkUj90Hxzjjr1qzbOrRpNC zqYSDO0g+QDocn35oKjG7I9Ui+zTRwJL5jsRMjRPjryvTn061csXv47uK9mjluhbRghGBkUIOqkd NuO3vW0FZEzjuj//1/gl7jTPsMn2RA96kxlaw3FndWbhVwvDck8kDjqKZLZzG3lKxNbTugaOK4BU ID0yvXvX+5B/iRZmbqRuwkV39mhlmkhFurBBCJhEu3Ixxn5e/vU2nXM2qNbWNv5enyWkBuLzUZhu TcGysanByxA4/wAmgxmne5u2L251gCeRriSVHDfvMCU/wbh655pcTwatEbq1KAzqgjztAUt94/zq ofEjGqmoM9t8M6o0j3FgzEx2cBntYsqsW4MobI9Tnr1PHWv3n/4JJaw58QXNrBBdW4bUI0ujNl7e Z5YELeU+OUGR9CK/HvHqHN4d4v8Aroz96+inJ0/E+nF9Yv8ANH//0P70tZSY6Bexxohmks2jGR8g 3Dn9M1/FT/wUW02DTP2g72xkQme506RrKQyErbvbyuZs9uRMvr0r+sPonVLcfSp94y/BM/jn6Z9H m4PpVu01+Z+fU+l2EtskTeY3mk+ZL5QZ1YHAwfQ8d+9W5tJXTBA2nXH2mCaD96Zh5clu4xlG7c9s E1/pxDof5WYhWmkYjPqMj3AYRRMYsm3TAjVQcDb6ZwPf+tGOJYbi2LeZFH5izTOj7WYqRwPbjvW6 aexgbt3D5qySwuXgBwHI7n1qjp1jNPcyXEkkANoA8MbP5cko53bT69aZLjuf/9H5ie5eWQSSW7W+ 6VkQOwYsoOAcCu40rw6NTnsbVY7q5u72RIrO1tVH2iZnOAApHvX+8+KxEMNQlXqO0Yptvskf89WC wNfMcZTwOGjepNqMV3ctF+Z+hXwx/wCCY37QfxLtE8QWFvbxaUkaERSSxuEyOFJOMlRtyV457V5B 8ev2N/i98BZLn/hKrKxbS/7Na+uby2Li5RIpVBJA3JjkcEqcDpX43g/Gnh3MeJFw7S0lfl5rrfpd W089fvP2niLwD4n4Y4YfE2O+FJNrla37O+vlor9bHzP8Nke68b2ugWDB7u4vIX82aBmto40kXfux xyrscZ7V/Zt+x5+z/wDBz/hWmk36+D9B1WRrOMSXV3p6yNMWQBuO2MD8AK/KfpT55j8nyjC/Uqji 5dj+jfoY8N5VnmBzSpmVKM3GStf0/wCCfLX/AAUo/ZU+GNt8OdU8VeGvDujeH9WjhnumubWA28ah I8cAHAOdv4Lj1z+fX/BKv4TeEfGviia81+DTNdayugtwtxbC6j2AiVFQNwQWHPr5dfnnBvF+b4rw XzCtVqN1KL0d+6f+SPoMRwHkmB+kth8DCmvq9eHM4NaKy/zuz//S/tt8Zfs7/CXWPCGr6e/gbQEa axZfOg06O1nTA6oQPlI6/UV/GT+2/wDD/SPAHx6v9D8OQvHbusl6hEhUFIpNqq4zgqckA/8ATM1/ dH0YOKs1zDijEYHGVXKDi3r5a/p/Wp/nz9L/AIQybKskwONwFFQmqlrr5L9T7P8A+CYngbwx4z8c Rrremy38J1Xynt7uESQx4ijLbN3GCSvbGM1/UNqnwJ+FGp+G7nR7nwN4Xe2lsfJ8z+xofMwEz1K5 z79a+e+kRxRm+A49WGwtZxjHWy9T9Z8DuBOHMx8JMJicTh4ynUg+Z/L8z+Nr/goV8NfCnwv+PE2g eE7dtHj1KWfyLWCI+SVD7nH54FfGNpojGG4nP7+4gGY0JCqSOuPU8V/cnhvmVbNOBcvx+Jd5ypq7 9NPyR/mPxxlOHyjj/MMpwytTp1Wl95+j/wCyx+wX8S/2gPDen6rYtoq6drZ8+1eZmZoIc4Jm245B BAXqdvXmvZ/jB/wSs+Ifwx0TW9dntbK/tYrEyR3FoiW9u+1cuCM5BwOOQea/I8/8fMHkvGf+rikr cyjZp+m/d9Ne25/QuD+i3jsXwXT4hxEZc7g5txa0W6tHqkt9Oj26f//T8e1PwpqGiazqWl6pZm2j tJmgt5STLbuUIJ2Meu3jI6194/sw/sD+Lv2kltbvRdbW0sJFUpcvC1qHyxBB5bOAM9B071/tZxjx 5g+E+F3xK2pQaTjfrdXvpq/Rfef4R+H3hbmnHnFkuFcPFqUHLnaW3K+W13orvv0T0PqX45/8Ejvi L8O/CN74k0nVF1aeCGNJrciNrdY1I3uFSEHdgHpgnjJHWvxX1zRb7wpqV/pU01x5lvfyQqyo0LYU 8q/oQcjrzj8K8Lwn8VMJ4j4OrOFva05O9lZcvTRtu9391t9Tp8Z/CXFeFeeUcBVi/Z1IJpt3d+uq SVna+jet9loQQW6XtnLA8wt5nJFvO67gj46471jSQ32muLO4MN7LFjc1sd0UpIB4z+Ffs8ZJ6H4n JWk2Sr5rbleMwzYyYT95eM80RRTqru8Zd1yVCHlx6CrcrO6ZEI3R/9T51uLSO31GC7SC5tL1LdVk V5CME85K/THr9elTSGedyjtIwcFnfPPA55r/AH+jqtT/AJuGrOxJa6bFPDeXL3aD7OvEcnLEc8Jg eoqpKVbZKcFgNgdv4gvQfhWv2SUrNsa0emNEyyFvtEnyxJuwnHJOO9VLcCCYy4YhQUAx1/zisk7u xoo6Nl6Se/uc3HJiiOCpTZt6dOme1O+0maONbhCEbl4we44qjNn/1fnGUGOdGtlnjjLfJv8AmZT9 QBXufwO+Fw+K3jjSfCD6kdPF/coWIj3STKGG7BPAx09fmHvX+9ee49ZVlNfMLX9nGUvuTP8Ane4Q yR8RcTYPI07e2qRhfsm1d/JXZ/RR4J/4I3eA9b0ez1DWvGGq2sTwxzW9pZwxQIWwGy3Bzn8evWu2 b/gjl8MDII18RXtuYiSrQRLmUN2kOMZ9OOPWv85s2+kXnM8fWoqcnGMpJXfZ9tl8j/V/KPou8MYH D07Uoc/Kk7RWund6v53+bNVP+CO3wkiitUOvagXiDqWdI5EQN7cc/U1Ut/8AgjV8Gmt2tj4h1VYR cFyCoR8+owc49hXmUfpF58uZxcopf3mdlf6L/CdSrGNSEJbvWC2+d/I8++Mn/BG7wHbeDtT1Lwj4 quVvdJspLm1s2sfKtnZVOwuisCee+7ueDX803xR8Fz/Dnxpr/hS9mlu7rS9QkgJkjMckKLtxlT0y Cv4mv6i+j14r4rj+WMwGNk3OmlJXd2lotG+j7X0ttqfw/wDSo8IcH4aZngMVlcVGjWi1aKsrpt7L S9uvXvof/9b52ihjSRLh1V1OH2HhXHXBqOPTvOluryWZIIF/1MSDJdjz+AH+Ff8AQIpWif8ANla8 mivOy2YWPy3YSH5n/hXPSrCIAmUbJB6E8fhWhK6kO4ws3mDG/hs9ORjil8lUUqFJDHcWxyMVXVCJ 4LKO4cNIzFQNrAHkVZNpNaI0AJmEY/clvmUDqP51dTSDGtz/1/nK23szxzj5gMcHAzinW4dJXjG1 o3RkZWXOc96/6Bottan/ADZ1IqMrIdFbQiTESENHyY14Dc+lPu23pGyja5OAuOTVGZHKjWsBuJA+ FGT5QMkgz6KOauWlgJWtjFKZUulVyQpV4w3UEHuBWLna68zWmr1Eu5/V/wD8EhLA2fw00tplXz20 9DlAMEFQM/8AjuK/Uf8AaFigb4WeJ3lgjuXSwcRpLgKdyMDk+lf5GeJuJqvxklOL19rH8z/czI8F Tp+AdKg1p9Vf/pLP/9DzL4xpZWHxS8Y6ZpKvFBHrFwwCg+SXWTy5GT/gSf5xXEW8lyymGZYXVlDK +ArrtB4r/fTh6beR4KUutKn/AOkI/wCb7NYqOZ4iK2U5f+lMqTWNyfMuVRzaoR5sgBKQ5OMsewOe 9MUzRF1c74wfl2jHH+RXueRwbCbIvLS4jlBSU72UnlSPUU6Tznk2gsQy9wcAe1BjL4mSeY48iOQ/ uYQVC7Rznkk+tSPaW81vPJ50/mdIYlUbPfJzSbWxpFWR/9H57tIfljWRivljAI+Vj9fX8ameCNJW e5V1idcpxtZ+uCM+v9K/6DZ22Z/zXjRpjNbxyQ8hmP3ei+mfSv1U/wCCYngv9n/xR4v1Kw+K1vYT apcatHBpx1OPzVO1VVlOTwBuDA9h+NfnvibiMbhuB8xq5f8AxVT0+9bf1sfrngdg8sxvijlOGzb+ DKbT235Xa9/Pbzsf03Wv7Fn7MU9uJbb4a+HJobm3AW4trdAso4+bcOp6V+WP/BSn9jT4VeBfhfrH inwPoUHh+5t7YXJms0USKAyq2FIO4cnjI+vFf5x+GHipxLh/ELCYPEzvF1LNO667aPbo12P9NfHv wm4YXhfj8fhqfLUhTTTsrdNdV815n8xcpcksu9dgGCybPM4zkD8ait8yW8ssjFZxMDCF6MnOfxzj 86/1Yjsj/G6x/9LwWeRLi2jXayEjEoPyg/hUawouwNkqP7oycV/0FOTasf8ANc4pu7LkGlXGpukV jILRWYZupgVRQCN3bg4OQD1r+rT/AIJt/sxfBfxD8MrXxB4h8G6L4guJtNje5j1HT0ngkeRidxyc 5+UflX82/Sa4jx/D3Asa2XytKU9flZfqz+yfoa8HZRxXxzjI5tBSVOlHl/7ecm9Nvsrz7W1PQv26 /wBiT4JP8HfFXiXwh4P0XwnqunaZLcbtN0/bbyPGpePcoI6HGP8A61fyJ6lbTx6jewm3SJba4eJd vyvhWI+ZDyp9jXh/RX4szDibhrFrMZ3lTnG3zUru3yV/keZ9L7g3LuEePcPHLIctOrTv9z/4P5lB fMVkcKSinHzDgn0pkljMZRdXEjJCqnZCF++T0/lX9Xwdj+Sj/9P53WAtJkkgA8r2xVsxcllYBQPu Y5Nf9Bcn72h/zZQREiGYSmJvmhYLIB29M1ZubGRQkvmBWCgsinJIPWt4yajclqzsVIIfsqMY97mR 9wBPyj1xUckIupZDtljCoGO0nLMMDke9FR3XyHFe8jQjlkEarGu3CnLMuUGPrXt/wF+Dvif43+Ko PDvhlEe4jvYop5SdwjLMpOUAOcrn/PNeDn+cU8iyLE5vUelKDfz2X42PtOA+Gp8W8Y4DhuKv7epG LXdK8pLTVNxTWm1z/9T+tD9ln9iDwb8K/hYmg+NvD2na1eXNkwuHvYormWUMgDZXbgc7vzFfzZ/8 FD/hj4U+Gnx/1zw34P0yHR9AuC90VgtI7aGOQhDztAxwc9+/rX+kvgF4kZlxV4r47DyqN4eanZeS Tffuk18j/Mn6W3hvk/CHhzlNbDU+WtBqL/Dy6Js/POW1tYofJhjQpHxkEsZM+5qJSIgiL95iMZ4A HvX94xfMj/OSUbqxNNcyys+QAoO0Feje9RtCFjRixDnnkcEepqjHld7FdhCHWQNuZThiOlegfDXW NP8ADnxA8M+ItagbU9EstQj/ALRsAQu+MupZlPTIANc+LhUqYWrTou03GST7Np2f3nfl9Wjh8zoV 8RHmpxnFyVk7xTTas9HdK2p//9X+w79j/wAdfAP4lfDrRk8B2ekzXVnYILm2uI4buRjgA/MMjqCN px7d6+gPin8Jvh7448Ha3pXiDwxpE1vJYOVmjsIlliIHBU44xxgj0r+guMs74h4f8QKsKlaScaz0 vo1zJ7H4jlvCnC/E/hhTUcPBxqYfdJXT5GtH/S8j+GT9pXwPp3hf4u+N9K0e1W1srXWrq2ijjiEa usU7pE3HGdmM4714ZZ6e8fysCWxhRjOfYV/rjwvjJ47hfA4uq7znRpyb7twTZ/hhneFWCzvFYKCt GFWcV6KTSLk9nHa7oPNczj5pkYfLEW5xnNVTaM0EbmIkj5TNt2qx65/+tXtUprmszyGvdb8ySGzQ xuJBlT7VC1usfyJn1FdMneOhmf/W+fo4mbYznykU5ZzwMClS2eS4lXcPLZ98DgYAUevv1r/oMUve 5T/msprS5YuIHwGUBWVdrberH1/lUKRC3XfIDw2WJHT3xXXHZGV+g02wMhfllkJIbHzGq7xortEH UMOAfrxQx9Cw2n/ZnVpisjeVuXy5BIv44JH4VlASTO8R4U5Jz04FMR//1/nC1sRNyflkjY7Bn06G p7rKnaxyynLY7HrX/Qwf804kMu4bU3fMNpIHStCSJ4UjAmDwOo3lvl2sexpJ7lS6E6oFlFvMHFsV IlCcPz3GazESW1mCwfLArZbevJQcZ9u350zDW7NiSLzQ7lsgL8pHANQw24lXEmVx27iuaT9+xotz /9DwNrRkaRVJ2ht3HBPbJq5GmYlJO126A8Hn1r/oUi7Jo/5n5btDL6wutsbHZ56x4kSJsKeTjB78 Y5qa8igENiDaNbzWsOLgStueVySdxz07cUSldERu4sqT3UAk2qYvNK7sIoUge4qeOcFQJcBvTFWt VcztrYqiPzpztBeQDAUcipYXW3lih8pgXyJWU7lGP8aZra0LM//R8LfMUkrRed+9O3aXLAL6en1q SKGC3BYszSOvyRAYU46k/nX/AEJT+JI/5m7fu2/P/MayPFIsrhlEv7tFC5xnI5/xqeMeSQksoiiP zLJJnbjmspSVrIh32ZEZZZslBhFGVPY470webLGh2SuPNwTGCCMHrn2xXM5pTSOmML0m15H6V/8A BPv9jax/ad8dvq/iPULyLStEkS3toIL1LSKaXOWZ1wWdikcoJBA+YdSeP61vDvwv8JfDvwBb+ErC wjutL0nTo4lWWFAxMaBCx2gDtnpX+dn0puPcRiuMqHDWDk4xoct2na7Td9nrrf5WP9ZPoceG9LKv DTEcT46MZSxik0nr7ttN1p7qXfW/z//S9A/bMtLS2/aG+IcGm2scVjeatcahtgGd3+kOELZ5ztKj 6KPSvlA+dI25bZYE2hVhTluOOa/3P4CxNWtwZls6sry9klf0Wn3I/wCeLxCw9ClxvmVPDRtD2z0+ av8AjclsEvWvIfKiIQXUUU8xUlbdJJFjLHH+9X9RP/BN39gvwNovhzRPjFrAa713UQl88jSrLPGQ FCgfIOH2sTgD7x9Bj8t+knxnPhXgWdLDv95W93+vK7v8j+g/ogeHcOMOP3mOMjejhUntpd66Pukr f9vH17/wUk0rRZv2b9YgudItrm4s3ibT7po18612EoB0wc5HHYjNfxg3UF1aTTfbER7nzC0mxgxG SSM474Ir4v6H+Nq4jg7Hqq72qR38+c9r6cuDpYfxHwfsY2vSa0XZQMyESXJZghQL1J6D2zU0CyiS XfEVwuCXTAI9if6V/X1KScG2fxHiFySXoj//0/FrZJbuFpkHyGUxJEVKycd8elWJLX9w0bRsJh1J P3fwr/oLhOKVj/manuZ8VosLkMzozYC7jwT7VYltliRpFUPIDyfX3rBytJWNorUueGYRf+JtEC3c VgYtSijeWYYXDOoIz0Bwcgnjiv7nv2L9Q0i5+BPhKy0vUrPUbmxsIY7+S3lSSZm8mMNvI64bd+vr X8g/S9jUnwdgnT+zUlf/AMlP7z+gzOlS45zGnUfxU4Wv5KZ8V/8ABYHVND0v4L2U88dtJqsd6zBm AaVALeXAwOe6n2wK/kz8Fajd6D4h8PeJ42uovsN/FdysZvvgMGkBPOcjJHHpXq/RZjVn4dVFidVK bVn21/Rnz30wHTw/i3GWE0lGMHdd9NfvR//U/qL/AOCbX7ZbfGvwta+BdV064ivdKQwWGoSxLA11 GDtVgqjDL8p56jI5NfqlrWxtI1JZV3obNwQ3zbcrjP4Zr998Y8hlwz4h18HTle8+ZW6Xf/AufiXg 9nVPirwxwuOqw0lTs00tUo/0j+Gb9tOxSH9oXxrFD9raxTVbpxPkeQi+eR5jrnvlQDXzEmmmG5mV PONuyh0aYbnwQMYCjp3/AMa/1L8Pasp8EZbKbu3Sjqf4r+IWDjhuOs0owVkq09PmZ0ljLcvMbW7t 1it4xJibfHuO5Qy4AJyAScf7Jqzd6LcJNaNIhWxlhEq3ZRojMSAQqBgCcf1r7WnJcp8RWptyl5FV NPuNs3kxyv8AZ5fKlOPmQkZGR16UyCzupGL4Yx9MNwBilCUXdeYpUmoL+up//9XwuWwllQmCNnVG /elQSE+vpVm2smVQSu5Y+XXrwOTX++6qJVWv63P+bn2U3Quu5+4X/BLb9l3wJ8X7nT/FviCzs5bv SLmS+t3aBJrm2CmMBA3VSCy8HoRkYr+j/wAb6LYeGPhrr9nYH9xbaFcxQR3eJUI8iQ4x26H86/zJ +kjxRi8x8TllXN+7ozilba6fKvwX4n+v30aOE8DlHgdHHcvv4ilKTb396Lk/ld6eR/Cj8eVjl+NH i+wiijAhuvOg8kn5UZU2qw9umfY15lJaPqEJt5cFww25ULINp/vV/ojw1UX+q+Wrr7Gj/wCm4n+U HEtKf+s+ZX29vW/9OSKMGl3VtJcM9vcGAkIH8oiAY/2umeas/YnQHCyKWwFI4QfWvpIyVlqfN4in LnaP/9bxqGxntYLp5JI5leQIqNkzISO3bt+oqvJYXEFukk8bwPI2f3i4dl9s/Sv9/IOO5/zXWtZd ijID5wWNypByMgZYen8qy7z99MI9zoQcnBxmnDaxFToSOJdgC7iqLmnW0SXGyWb5ZCMRqeWP19On 6VXUq/u3IbqQxMVf52XPl7RgCt7wp4fuvGOqR6TaxNPfyx4t4BCZmkJyBgD3xz2rLEVYUKE61V2j FNv0WrOjBUqmKxNPDUVec5KKXdt2X4s//9f+mH/glR8K/Gnwr+HOl2/jGznt7qSw8uOSRSzKh5QM xADfKevXp6V+jP7Rnivw7ofwh8by6xqtpYpL4cvAhuJlQZFvJ6nryOOp9K/oPxArvPvFeWKwd5c1 aO2r0ep+C8H0IZF4MRwuLtFQw8l2VuT/AINj+ED4mta3HxB8Y3VhMhE2st9nY8tdRJFEI5h22kMF GP7lcAGuZUCzbPMAwdo2r+Ff6u5FCdLIcHTn8SpU0/VRR/iFn0oVc+xs4PR1ajXo5M0LK0e7WVZk z5aHBAwD2/z9KozWzQMbdomt0BGCV27s9CK9SUk07HjcjiDwSiIR7xmPgOq43e5q5a6Pesn2qeNp bVlLLP5eEUjACn6k8VnzJD5JSVkj/9DxmOzFzEgSGZHKlsMCNoBx938uTVOPTyvnOM4R9pkZvkUj qvp3Ff72+0h3P+bJUZpWLC2V8hdY7e4J2hmKIQQCM7uO3f8AGnzQX97cM89yftAhQM9w5LKqqFjz nnGAAPYUvawXU2WGqNbEGqeGb2209NQ3W13IUHnJbSqZ49xIBMZO4Djr0Ht0qvBpmowxpMiSSwPh JJRG3lI2AWjLdMjI79xWca0Od6mssNPkSNG+0mHyEuFmBYMGKKQ0YAPzKT+YrImtZZGIgiKiR9sK qd2/ngD19K09rEl4aaWqP//R8BudH1O0tiZ7J8sD+7bEbge4JFQ2+nQpA28xwpgyPuHJbrj8TX+9 M6is0mf84NGhKLTaH2UMWJQLkK/CPESNq9x9DRNY3CmV5NvluuYpd3ysO+R7VdGr+7STM8TSqKrJ JdSOLTmkgjmBWSEHH7nDA4+lRXRMsaxNKVWOQGNNu/JBp1J3W5OHpyUrWLUDyRgQYOR87Z7e4FNe S9urhYbedpzAfLWOEb5Yif4eOfwNFGqnTsb4ijOFe1j/0vAF066hRZGWRkP3pHXAQjqD6YzVa50i 6vXHkGJ3XGcNl2B6DFf73+0Vtz/nA5Jc1rFWJLq0jlt38zYz4aBsgKw43EdiORUltjzFimjcggug jOHfHpx64qJTV0zrpUm4tdj2b9nu7ttC+LXhfV9buol0pLg3lxayqsciPAN6sshOAANxI78da/uH +AXxg+FviD4beGZdG8X6WVj0yNHivL6OGVNqgf3tuOOx9a/h76XGCxuNeXVMLFyUYu6WvVn+i/0I sdgMDhM0w+KklOU7q9lpyxPw4/4LI/E/whqMMMPhvWNHuNfltVhs5bOeO7mDLOSN2CQM7ST7HvX8 9tzd39zatcahKbm72qrSiJY2l468Y/ya/Z/o44evhvDfD0sQmpc0nro7WR/OH0n62ExPirja2Dkp RtFXTTV03fY//9P0H9j39m/4h/Fz4i+FtX8P6N5ukeG9YXVr6XUA8XmPGy7PKIBDggkg57Yr+0P4 OWP/AAg/gHRdJ1gCyksrMCRTgRQgZyTzx/gK/uf6WfEFHHZrQyCg05UlrZ9X/lez80fwl9Cvhitl vCmJ4hxCaVeWl1bRWS9b8t15NH4vf8Fgfib4Z1/womk6RrVjczWiNFLax3AeWYtJGnyoD6BvmOOa /mMtdOWG1Bkv3YJcGKHzztfZwVzn0ziv3f6MeAr4Lw3isTFqUpt69rK35n8sfS2zCljPFas8PJSj GEV89U/yOo8MA6d450G/SGBBDfW/2iUyb2S3Uq0j7T8u7gsPfnPav7Uf2Afiz8PvF/wx0rSfD+sK +qQxmG5sJ3jWQOrEAIAxJBVAfbNfG/S2y/F4rhjDV6CbjBty8vP+ux+pfQkzPBYbPMdgsQ0qk1Hl fffT5fqeSf8ABVW5jj+B2spKSUupP7NfAAYeZAwIAPXp/Kvmv/gkBocek+GLi/SOTCpLNc70/eSI 1wFD49P3a/gK/nrIq3svBLGJdZ2P6mxtD23jhQm/sQv+R//U/td/aJ+KXhPwl8O9et9R1y00+6uN PkjRpZFRYx5bMCe/4Cv4Uvjd4lt/F/xf8X6hp3kS2EepS2yX8blob/ARtygjI2sZF9+Olf379DzA YiniMfj5xfs5RUU/O6/yP84vp05nhqlDLMthJOpGTk11Ss1+qPJ3lEbAYAYN27VYuox9jimWd3Zp irxgf6sALtbPuSfpiv7zP844u61K0yStKPOJmCRhVeLovHH5VaWZ4oQksvmsD8oYfvF9BmpTu2iu haspbaVJGvBMklvJHc2Zg4mWWKRZEdT0BBUH8a/en/gmh/wUBvfDtxpXw18feJJLaxSYw2ouI/Kj 8oHA3qx2jA28qcHnvX4j48cK/wCtXAmJpU1epSTmvRb/AHaP0TP6O+jXxq+DeP8ADe0dqWIapv11 5fza820f/9X+2/4lfDrwN+0J4Ea1uBYahDeQk2d20Cz+WXUchhk4OBx7e1fyVftn/sp6t8AfGmuX z6RMfC8t9FLJqCoTFEGdo2EaqDwq7HOVwB0IAOP7E+jHxrVyHiqfCmObUKj5V5O9vlrZ+jZ/DP0s /D2lnHCkOMMFBOpTSbtu1301fu3XyR+bdnb6a19dRSXKSymFboPZcQKrckYI7cdPQ1U1OFrZ2jtr 5ltjJ58Cxsjh+370YPPXpg+9f6Qwd4Kx/mDW0nYP3ZKBoCbiVAQ/3Cc45Pr7VXkfYxV1kYou1D5m ADnk/pVmZYs5g7rHJhwDwjLkGqsENzpcjo27ypZGdUDliMnnA7UCuuax/9b50t9UZLe5SGRRNbJ5 tuXgDbzuHyt27nr6YrPEo1iSK4kWO0uEX5kK7SxPU8DH8q/3oP8AnXI7mSXfHDKY2MXywtGqqBzn 5vXv15q1bQwGKbzlYyOpCq3EeccH6g0GsZKyRDbxW9g/medE19JGYREU+WQSDaUX35/SrzWttbWU AmkxcNGHMYP+ryPuH6VM/hNYr3kVbqGGG3hmUsXnOChcGOM8jOMZ7H8/pVNY9PRnaWW4MqIWjMK4 Ej5GADjgDk/hWJrfWx//1/mqKcC58+3iuo3JDb7lgY59qAHb6cg/nWzY3iarNBA8Mlp9olSPO7Mk LFgMjH6Z9a/3TxjvhZt9mf8AP/lSbzClb+Zfmf2bf8E3tEgsfhBopSSUtbWUNvH5qbZnRYoeXPry QR9a2P8Ago3q76X8FNa2pvfy8JGvBmG1yFPtmv8AJTEXxHjPd9a6/wDSj/aTHr6v4LNLphv0P4rL a0kure+voL+Kced5j2zRNkOEDO5bGPlJIP075r8zP2x/slzfWOq6XHbahO+jpJfTwAtPDP8AafLk UZ6AqN3HXNf6PeI8lS4Bxd+lL9D/ADu8AoufiJRf95n5nfbIbma8ZWZDBMYHgdSrIy9ev4fnVQxz zRySHBiB2ogXBb1r/HjFJ/WZPzZ/rZTjeKS7H//Q/kGMMf2Z1K5bOChHIqjFDjzFXAVRlifvLiuG a94ajchS7Z1YI2Qh24YbWNa8GrOlnPaKW2zJ9xjuXcPUVnL4WbJJDUVSFJXJ8nJH8OSPSueuHiik Ijkfch+ZFGFBrEZpyKXtVG0kuuXLfeFZkVtFCQJCxLHJPc0Af//R/jxS0ln3paXEtlIhDHym2FwP Ud6niiWGZIC8nIJYsMljzz+deOd0PhRDFEgurf7QZoMFlkVT8kik8HHTjFaIs1+0OimQxKuVJGEJ +tYyTTKKDh4YnWaRnmXIiYDp1x+XH5VgqZGZSSUYNlueWxUji7O5bEz7jI8YdowQqj0NXYgm3Kna GGWB7e1A5O7P/9L+OoQRg+cmdiZZkPHT0pDPBES6f62UZKk7kHYV8+dk30IftRS4jhY4DjczAelb cepwQxujM33TtPXOK3UbKxmYck5mldsHa3Vyck/Ssa8tJAI3giBbzh5ryZRwp6lT7UwFNr5eyW2u T5seHaJh+6IHrWxLdrMglBRJUiEY8sEhzzyck80Fwbvqf//T/jYuLkxGNW+eZwMg9AOlV7uFFOyL /lqgLKw6E9a8c9ArtYvZwAwRARAfvCo+9nuRVaGXfPEIHSdo12zvEdr2pOeGzQUoNo1IrfzcrINx DZGD8zfWrSIY7QpKvl4mOxCMtxxyaC1BdS0hiOwoAPlw31qldulqFQsU+beQnBPtRboUopaI/9T+ NCDZf3IeB5GMBDsRzGB/nNa8nm3WYJJl+zsMCBTtYEdT6Y4/Svnz2WmtyvbhrS4kwRLCUKBTyMkY zVKaUrgbiUaQpGnXLDOQPyoEOhurtp3+1xM8QjEaxhvmTHGf5VZNspjYxg7s5HrUTWgEhSQOi3Di UKBiIct+NaMnnpCZbYpFLG20RSJkD3xWQmk9Gf/V/jQMLXs1qZh/pdrc+fAx4AbBHT6E1013YTyQ mcKBMowVbgsR6V81BXZ6yilsYCtdyGKKSV7dZmMMygAhucY/GsO8+0xSTQXNusFvbyhoJgWZyAMZ +vsKqexRvJGiRJ5cjyI+AryDaxJ6g/jn9K0/IIljZJhDJKgiaQqWGB3I/rWQF6CeaXTrsTJHJqMU L/Y5Y8rFIwOF8wemPTvXDWmoeVILbV4IYTE4ZPLUv5hJzk56ZzWsFpciex//1v5FII9HnlhtdPmk g1HUovJSaciKytT2LnoAMnOSPxqC/wDCllp0htoL21uxGTMVWfNs7Y3EKxPTOePyr5v/AJeHq7RO b0yyvr43B1KeESG9JtEhTaqxYwM+4x+tfo5+yrFo+lvpdhqMV7f3dzfpb3E8Fwq+XBPJFgLuU5Yc 4J6BRxX6v4Q0lPjTCOS0TufmHitPk4RrpeX5n7jfsXaNLF+0P4ZS0uVSOx1KSWyildpZ4QhjjZyo G08MxPGMLX9tvgeVdM+Hum48u6Wx0xfs8hTYp+QE49gTX6N9JWSlxJgYL+VHR4DJx4Gqy7u5/JB/ wV01yw1r4h3GhWNxLbLFIRFMXJt7i4SSF2hUeoDMT9fev5+vjLqkGn+G9R1AxzSQxaXPbXO1N8Tu 22MoT/tKzYHX5a/pzgCDwnhrh3/07v8AmfyvxNUWI8V522VRL8j/1/4qfHcGhHVL+605Vgkml802 KD9zb8AcY9Rzg+leX20aG5Z87VQg/L3r2uIXzZxiH/fl+ZxYGPLh4LyR2NsYRGLiIM8it8gbgk+9 TNc3h89t5hgZNsxHDyA9l59QK8GpojtOi0rWTbRE+V50ckYhHmgkxkHqKvm8aeRmKqhAG0owIx/S vNqP3mzeKtFHSaTbw3M8Tyld4BCk8DivUNN0+KGCJ47lZkKcNkhhnnbz6Vw1NRn/0P5Qrq21Ge3e SxVkitiDLI0RdCP7uenPSqcuu3sv9mWohjjisd/mKoKtLuJP6V8lNWZ6FzorGVtUjmjeNS64ZGlc KAADuyT07VX08aWzSWdw0n2nYW3R42opPUfljIqAHS6TFER5SSSK3z792d2OPm9adcyi6tUsrXdb qW8ueNlx5a9D+ZoGotivarZ2rWaQo1vENySbss7Hqcdsf1qOyKXMyxXD5jRMhR8pPsTWU97GzVz/ 0f4zNS1OC5ubez0WWJ5ogpeWbMCXAIyVbsGHI/CoVFzJLK6uxkhj+aNDnAyASB+NeA1YqXxMvqbK G3uYJLkRzmLzD5ahtxxnDHNFjMpgjnEb7Q/lqGQgk5xxSJLdyAENwigNFwzfxLn1rEkeWfYHd44m cec68ybfYe9BPKr3Kc3mRx3dyxX7JFEeE+diAOpHXNZNhdxzx75WCFF3KSCHYEcDFdBNv3h//9L+ LHTmvZd6wuY4j8zqD989s13VjCjLHGXdAg3Tt1PP90V5lPaxPMkYJluk8+ASiRFmYiUH95IM8A9u PT2qGGO6ugrMr7I5tybsqpIPOK9CmrId1exV1PF00lu0Z2GMh5F4zntXneu6d9ktLi4ZMMqhkCLv llA4wqj/ADxXVTV4mTla6N/4f6hBHqujW0dpFLDPfxFA3yTq6sH8xx1BGOPev3H+A+vy2nhi1klA hsruUXEmcyMcIm1pPwJH51/UX0cJqGb14Pql+p+CeOzf+rMGv5j/0/p//gi74ob/AITvxFZXFpeQ f2hqX9raUJMmzcBY4WYjHViCcejV/Xn4ggDeGpVY28iNpYWd1/1AJTDZz2Ge9ft30hKSpceqa2dn +J8v4UVJ1vC/C8/SMl+B/DP+3/YRQ/tCrFc289rCsVzd34ty5WRvNRYkkUdyfOIz6V+dOsyLDq13 c6ZEAkjhEN1EQrICCwGR9c44zX9zeF1SE+DMC4P7B/nV4gwkuJsVzfzMZp9l4fttJuNSvb2aG9Os iKNUjdolgEfzuWxjAbjg5+VuKkZCS8mnzx3CyuB9ojBKsnQEZ5GePzr9K05vM/PKd/aSXmVprKWG SSKeERksrCRlDN2LDB6Z6VLY3EFi16LnfIFg3xMIt8Ds24AKPXPX0yKr0OlNrY//1PzQt1htDFc3 EhDwL9rEdihUXEhGQnI7E8544OM0thcSQwPc6nv0Z9Vd5QozJHcpuOSyqOM9K/2gP8joSdiFtQtf s9xFpwVlVTl+ihiRhtvfr0qdtVS3ewtbV5kmC+dcyMu1AoGBg+pJ6e1bQXujJWgivEknST7YqsT5 2D+R9P8A61VbEeTCC/mRW9xKyRHYcMw4Izjr9elUS3ZmVcQm0lLWw+aOcyATZOSc5Y/rXUWl/BFp l1cRXLXd7bxKwtIIHFw7OMGNOO2cE59eaCZS6I//1fzNW0N6IYogoaaLbKU6Fu49j2pmkaXp9xK6 XLzpcRzNE8cibVBXhQDnkHrxX+1Sj7tz/Ic6ptC/s2CJ4o3kW+mOCXVnTGMk9wOwHXms9rC4vNUs 7VnQQ2oMkTXMwhgt2GSxJY4AwCf/AK9SU22Z9/q1r/aQje6RzEptRIg8y3IOQSDjGDk81CYraGWa aCKV5oFzbZkZYHY9zz0xkfjSt71yRdRtLm+gMkMpkNxEY7ryl4gI64Pp3q3pl/FCIrGPzXhsbJYt jJsfIHDZ+oP50znd3dH/1vzotQLg3ayWayZtnmkm53W4Tnfwe2P1rnzNEbfynaaVblw7zpiKU/3c c8DB5/lX+1B/jw01ozqLDT9KP9nJeztaFt7WeoAF1ncDPlEk4BxxxzUV9b6PMHmil1DT75AWlMTl oJtp+UBffHJPNNNrRGM1ZkZ1tJdOiSSe6aR2xDayRERqBjLN2B56YpJopriaG8utRn09ba1P2eW3 QYL4/d7h9f51uvMgp313N9vsPsO+W8k/e6vfXEgEcrKOZCvqwA4z1qyLo6lc/aJZ1gW2hMexiEYr uHRe+cDH407O1w63P//X/Oj7JemLUmsjDcW6IbiK3uJFRmAwM89Tz0FY67kulFz5aK9qZY4xEzIG H8B9M8D8a/2wP8cbWOhlQajv1a3neyjS2gtjYJc+XCPJGw+WP9o5J+taeiukEBluY1S0VmCMQd5P 8R3dfwoJMq4vtOfZN5hljmb5EKncPcg1kakHvZoJC0yWUTcrH8rSe2fyraLuRNaGjevaW8Npa2UC Xl+cXMAkk8uZO20t+IqcXEF9fyRT3N9YzzQCK8s7SVPsoKnG0Ljkcdc9qoxex//Q/PuW3kSSyuZY 2ksVf7LGPunjHBA57jnFY9+6x6tPHZectom3arkMykgE7umetf7cH+LM17w7TwLO7ubmBYlnvImj k+UEsCpDYHY4yM1BfBpLLzYrY28dq2HlVeTzzt/+t6VtFJLQwnuXM6ZMAkjyL5dsJHR1OS23tj3H 5Ct3S7bT9Ks45dQZL95VN4kG4PFtYkKrKB6AcZ+tUQMS7ZLGZuUsg7SQxlcRxZz90flXOgtLFPGI p2kmj3xyxttEByPnK4544/EUFJ2i0f/R/OyGxut6pMWeWGIO8jfKCPT9BxTbi6SG/tYYIokWZN9w wfegAwDn0JznFf7hRjfc/wAVb3jccl7JcamsMNqJFlIhgtgSUfAwR9Dyce9dHpbXWk3D6dcLIlhv 82OInMVuTgFVrTlj2MTnb5oIdQvluXe5hmk82BDwsR2qABjtx/nFYb3t0IpERRAlxMI48gsjAMO3 vx3p8qTNorlVmdRp8mnT3klrdx7rmBRGk8Qw0TjHysB2x/k1q3izxQzT295NFvURC224jlAyCT/n FMia1P/S/PqLTtSe1lu1e3jitcSTHeBO4JwMD2yKS4u7+dWmkczSyDbkHLSbQAPxxiv9yD/E8zUn nNiy3CXMG6Ux+TJGUYc4JB/LpVoXF9DFPY6QC1hMySRWcjebeM0YY72fGO54FBzS00Czjla4W8WM F7fH2kFseVkdM+ue1bUWqQieNb2VHmMo8uFnwW54A/lVxVmjnrtOLseiaAtvLdI585VaTJUOcgeh 9R61+/X/AASeuLzTfEUcTMJY59YYW0Zk8wCMgiPcc8d8DsMV+TeOMOfw8xi8v0Z+2/Rgqcniph49 4v8ANH//0/735/MOmMyEPJ5eVwNynKjP9a/jc/4KkaER8e7S/Fqkc5guCtxv8vcWnKMoTuTiMHjv X9TfRVlyeJKT6qf5M/kj6ZMObgFTS+3H8z8wdWvJpYYY/KjQxsUYRcA446VWhmuLeF5EtjcBYGhj t2B8tWYj5wPUY4PvX+oMdkf5P4le+kUmtWlnE8sUkciRY3I2U56DGfUVSngaQTJHIsEyDf8A6SGK vjHC49aqO9jNxSWhozpcCxght/Mkd3DtbqMBu2cnt34qy2m3obz47adbNI1aW5AaSGJ+AUL4A57Z x1rWUuUyP//U8L0/Q5dXvbOC0ikEzyALJJGTEejdMfNkdhyfev23/YL/AGIrnx9rdj4o8U6b5UVm Y5rK6u7U2piQ/PkI3OTgcf4V/sD43cZ0uFOEK3LK1WaaS62S/wA7WP8AHn6M/AdTizxBo4utTvQo JSb1tzPReWivftof0iaVpXh74M+C5jG9o1vpdqeJCoDbRuwq9SSfSv5wf+CjP7bHgz4pNrPgKPRr eDVF0q+0rSp4kdnk811j8xwg2gAqSC7A5+jCv4g8DcgzPizjxZlraDU2+nd/1+p/Y30qeKMBknAq ySLtKrzKy3sm1a2unn5H40/DuW50DxFZajGZlthNGJ/sbec5ffGZFEhGcDaefQ9Oa/td/YM8V6H4 k+DmkSaRqFpOxt1lltUcC4i3YwCnUYAxX779LjCVqvD+FxMFeMXZ+R+VfQhzPDUXmWW1JJVJu6Xe yW33GN/wURtref4AeKDcRSyiSCSNBGuXP7pmYD8Aa/F//gkdd3lh40vdIKNHbIYG2+WEeNQzkbiO SWyTz6Gvxnw4q83g5nVKXdfgmfq3ENP2f0lMorr/AJ9M/9X+9LxBdxW+iy/aLiKEywgbpm2BhwWP 4DNfxYf8FIpW1H9oe4sdH1fTZ7OTTH02S5gKSyNsvDK8cbLnBDM4+pr+wvoq0p/67VZ205Jfkz+I vpnV6a4WwtNv3nVXruj7Y/4JYfDvx3oGu2Gv6jaPJpr3sVxFFIzvK8ciLuGSoI2kZxzj17V/T3ca lbWmktNeTxWqi23F5WEaJ8uDyew96+b+kXjKGO8QJSwzuo6ad0z9m8BcHXy7wmwVDFaPlvZ9Lq/6 n8cX/BV6/wBLv/2ko9S8PM+sppKS2NxJaFZLWKQsC5LjjqGXI9K/NWzvrtGjmeyZ0jmMgiiky4wD zzj6V/fnhNTnR8OMsjNWap/qz/KHxGqwr+KWaTg9HXlb7z+tH/gkteTf8Kl02BpJPNlsIZtgiHlw DB3Icdxkj8K/XrxF4d0zxPpVxo+r28V1Z3KbJYpohMh/4Ca/zP8AGSdSh4kY6rTdpKd16o/2W4Eh Tr8AZdTqL3XSSfo00f/W/dT9vX/gnxZ6FeX/AMQPhl4ftpmuoGuRaxJvihl3gkCEggbgDnp0HPGR 7h/wS00e/wDDmmQ6Hq1qdO1KytmjuLZxhSwkONg7Dk4+lf2LmfiBLivwYeAxE71qOj+Xz26r1P5P 8P8Aw3p8GeM2OzClD91Xi3F2/wAT3srvWz6XWh+tnxVjWfwJr9vNEJ4ptNkEilcjhGOf0r+ET47a RdQ/Gj4i2vlSy20fiOWK2g4WCISFZAynqThiK+o+h1ieXM8ypSenIn/5Mv8AI/F/pz5b7b+x8XFa 804/1955c3hfVBd7LWOS4iSATYhhZmBxkgcc4ORx6VH/AGJeXMqTGzuZHKbtv2dkaQDA4468j8q/ v1Yil3P86auBqxexQuvCF/ZyPqF1Z3tksrbbcTEqrBgCAVzwcevWs6CC+N6tupZTEy4mZSIxnng9 /fitPrFNx91mP1WpCVmj/9fxNPD+oalcyyC58y8lbE0bKzyHA68Z7dsdqZe6eljABLeQvIjrCVWT Mjbs4+X8Dn61/vxCvTaSTP8Am/qUKkW7ornSru1Z5PnSIjptYOc+o9OP0qqbHbNsct8/z4kyFT8+ ma1daCW5mqU3okPaxto8Fo2e4X/VEH5Fz3IpIoCC0s4H3trEgBVJ4rn9tC97m3sp2tY6a48OXUNs 5e2lV4080kqTGoPTkcVz4s18t3eWIJGQHkLgeWT0yDzWn1il3IeGrpL3T//Q8mvNKvIbaGWWI+X5 aGOUQ8Pu4UYHr/k19a/sTQw3Hxo8LrEjNcwz77kFdpRRnGGz6gfmRX+5HHtZS4Rx/I7/ALuX5H+C HgzRt4o5PGpovbRP7WfCOuW1j4K0m71aeK0jt9PTzpGOwIAgwfyr471P9qmwvfjDYeC/BeqJq0Z1 EQ6pGr4EKsCQAO+Ovpxiv8hctyGvm+YYyok+SDk2/mz/AHCzbOcPluIwuDnL95UaUV6JX/Q+/Ii0 1pGd3zPErbgMZJUHp+NfnHrf7XUHw6+PFv4G8V38CaXqVy1pFCX2SllPJ545BwPccd6x4WyCfEGK xGBor3lGUl8tP1OPi3iPD8NPC4rFu0ak1T+ctfyR976hqeneIvCeoX2l3Ed7Z3ekSXEMsTfKwKbh /LpX8R37Z/hW4b48/EK/dFhcOxkV1wJeULNnuV2DHqDX9LfRIrvLeM8bha75W4uLT7q7t+B/F305 sJLH8PZXiqEeZQk3dK9k+VXP/9HwG8hmaKGURTrbs/lJM1u0KEjGRyB6ipbWKUuvlYby+SrLvVvw PWv9+VWjy819Ln/N5ToSlKemqX6modBuLvTFvPsd1c28023fFbM0S7SRlmxgDgjmmtod3Zt++sLl ISv3xAzRg44AIHWm8dQvbmWhf1Cv/K9fL+uxbj0C4y1y1rc2S27ANNqNlJHbShuQVJXHQjmq0uka jMZTBYzTxxwNO0sEO+EovUoRwfoOaqWOoL7St6i+o1/h5Xf0NKx8I6jFbQyTWV9bi7RZYAbKaeVw x4BVFYjrnnFQXOlXMNxLask0EsIIKz20sJcDA/iUYzkcHmsY5tgqt6dKrFvtdP8AC5tPKMfRXtK1 GSj3cWl99j//0vAXtRdKSjbCG+ZxwMA88+/NdHHoOWspHhntTdS/ZrdWjZY5WRfmKtjke/1r/fee YYXDx5qs1Feen5n/ADhvL8ViJctCDk/JN/kX28MajLImp6XA1z5c6o9laWUs90qrwzFNvIODjGc0 mpeHZEuJG1LRdat1QCYBdNngOeoxle3cVzxz3K5y9nDEQb7KSv8AmOpkeb0oe0qYaaj3cJJffYyb +0SC5YoHBiC7X5+zsCobgEckZAPoeK774K+BNS+KfxF0PwXpd3BpE13cp5l5cCMqyB1BChvl5Jxk /hRjsYsNl2IxsNeSEpf+Axb/AENMly/69nuEyyd17WrCHn70lH9T+yD9jD9mzUPgR4S0y1e5+0o1 mFBWYS9QSTkADqc4HFSfte/tS/Cz4aeDvEPhfxVeqLy7sZIVjUjDuBhUycAZY9c9vY1/klWpYrjf xV9pho++6t/ukf7g8U4rB8IeDiwmJlaKoci9XF2/zP/T81+IutRa7488XajBLFJpt7r8t1p8caKG toi7naHHDBtxOeea87u/NEoEY/cMOGDfMOehFf775NQnh8qwuGqfFGnCL9VFJn/N5mU41Mwr1Iu6 c5P8WaunXptHiZrZb2JZFM9tKcRzLkZDfz/CjxIbBb6BtFef7OIN16skY8qOVufLjbOWCjGWOOcj nqfWfxo81yexjgb2QYBB5OOh/D/PetdZlOPkHChD6gDirIKrJHNIY8HCjPA5zXU6d4Z1y7jtG0/Q tYvRMo/dWemT3cm1uRIdqn5eRz715+MxlDBU5YjEyUYLdt2SPSwWCxGPrQwuEg51Hskm2/RI/9TD /wCFS+MJTAsPhrXppSv+lRrotwj2+RxuBXPNSSfBn4iXZWM+B/Ezxhtm6HT3XcvXK7gMfjX+6tTj /heMrPFx/H/I/wCfGj4W8bVouawMrfL/ADOE1Tw74j8OpDa69omqaDLcF1ht9RtmhZghI+mTgHit L4Y3s1t4w0O/s7y8sLuLU7dY720LRSxAzIhORjpkn149q6MzxuEzXIa9XDyU6U4S1Wqej/ryZy8N YTHZPxlg8NiIunXp1ad09GmpR/T715M/uY/ZG1O71P4OeHpby6mvJIoEiSedt0kihANx+pGc14r/ AMFG9A1TxD8CtZtNJ02XU7g28itbwxGV5By2MD0OD+Ff5G4OrRy3xZ9rL3YQrv5K5/tj4h4KtnXh BWwlFc1Srh42820j+Orxt8KvG3hEXV5rPhrV7Kyt4Y42mktHaMYwmRgcDaVY56ZPtXntjZxO0crK hhgiLgA/f4JGDX+wGSZ3gc+y6nj8vmpQa+adtU+zX/B2sf4Y5/kGYcN5nUyrNKbhVj0atddGvJ/8 B6n/1fAZZTNKUCFTuwEHpzVm2K+csZIHBDErlRxX/QPF3R/zX2todt4UsdVuLoNo+mXetXDyCCK0 sofPJYnuPw/nX73fsR/tWfEj9nzQB4Z8bfDzxXqHh+aKOWKRdFdzGu0AASBQQBjjOevT1/nD6RWH y3NuGP7GxVTlqu7ivu1tfXVbH9jfRLxmcZDxNVz3CUebDNRhJ67q+l7WWkt33W+p6v8Atg/8FHtL 8UfCvxJ4M0LwZr+h3msaVMv2jUbCXdCuxgzcqB6844r+caDSvEHjTxIj6Zpl9qVxq0rSSmwsJJDK zEAZPQk55r576N2SYfg/hbF4rEVE1Jpt6KyV/N+X3aGH0q88xfG/iLhsJhaLUow5VFattv0XZ/L7 z0x/2a/izeWM1nZ/D7xbcySsl3ptzHau1kxVxvjYxoWDMoIGeP5VtD9lv40yWQmuvh9r/mlwoto9 PuZJ4vr+6xz9eK/Yani1wlQbi697O2lv8/8Agn5FhfBDjnFU41IYa11fW/42j+Tfqf/WTxT8BfiX 4XhW61j4d+KNIsSrPJd3VhJKibe7EICoOD7V45Dp7bpWYoyBcRD+Fuozn8P0r/eLIuKct4koPE5V UUop2avqn579P63P+eDiHg7N+E8ZHA5zTcZyV07aNbaXt10f/DHrXw7+CXizxtCZtG0qe/WWRlZ4 I5drFQpAG2Jgc7gOvvjAr0i4/ZN+Ofl4T4X+IJUY4V4FM8ZQHBy20EEdeAa8XNfE7hvJMbPLcfO1 SOj2t/6UfS5T4R8W51ltPOMBSvRntfmv225bfj+gtx+xr8dmgkGn/D3V5JAgeBplkVGPHy7TGD69 814p4r+EPxB+H8hj8XeHNS0q8ZRHHbG0l8yaQOEZF4weucEg4B9Dism8S+Gs+xawGCrr2r2T0v8A c2vx9LnLxH4W8VcLYNZjmdC1HuunyaT/AA6ajvCfwv8AFPjS7t9K0PTLm/ursbkhtYWlMY3YO8qp C9MDrzX7Ff8ABNL9nT4y/DH4nXmv+IvB1zo9nfXcSWk0qB59qKyZYYwNwxnv7V+eeNnGWW4HhLHZ FVqWrzg9PLXT12Z+9fRY4EzLF+IWA4qlSvhqbaT1+JWTa6WS5lve/Tqf/9f++ibdJbNuHzvDhlPq VwR+dfyqf8FM/wBlr42eOvjReaz4e8P38+lpH9s+229uZ4ZuQBHtHP3Rg8+lf1V9GriXL+GPEB47 MpWpuMo/Npr9T+QvpjcJZpxfwRRw2VQ5qlOfM15K3b0Pxy8a+EtZ8HSz2Gu6TcaHdW4C3cF4pSWI uQqKBz1ycnt+dcMoTyYlZvMkQY3Yxmv9X8txdDHYWOLws1KnNXTWzT/r5bH+PGMw1bB1pYWvHlnF 2afRomjhAXb0Bbce4GaYweRyrfOF43e1d5xW6lcWwDH5SOw9KvxRCDZgbgWDYdcqSDnBHek9mEf4 sT//0P2j/wCCK2pvdtLpzCGAW90HeFMq4C+ZhcehIU47c1/RnrwB0XUQxVVNi4Zm4VRjqa/qH6R8 FT8WsRyq3vL82fz99HypKv4G5Y5u79il/wCSn8e/xq/Zj+J/xn+OvjeT4f6Vb6kj6pdwkG3lkjjk W5kXKsvGTlep42d+cfO3xP8A2Tvjh8EtPiuPHfhD7KQzJPdQRs0SuoJADEfLnp6ZNf29wF4r5NSw GW8LYqVq3JGKd18tH22P8zvEjwUzzDVMw4xw6vhvaSlblf593vt37HyZbXEVxqEkOqwXVoZZhHhV w0XOPm4NfVfwt/Y1+NnxWhN94V0uG40wObGASpIyTMxyWJAzuXbt44GT9a/WeKuLcFwhl/8Aa2Pd 4aK17XufjPA3BOYceZtPJssXv73avZK/4t9D3e3/AOCYf7UK6c8Z8FCZ3ka2ikiMqGNv4WKhGJAH PGOa8r+Jn7Cnx9+D/hybW/FXhae9tbecG4ubOznR4EA5UI0YDHqcg9u9fmuV/SD4UzLH08Bfl53a /Mna+i0stO9vuex+pZ79GvjPIMrr5tVjzQpRcmuVq9ld669na/3rc//R8Fu1hu5GFvK7RKxie3dD G8JUkEMDyDnNdp4R8LXviLULHS7K2mkuLi5S0hijiaZ/nYJvKqC20Fhk4r/fXEY6GFpSxVSaUIx5 m/JXv+R/zhZZgKuYV4YLDwbqTkoxj15m7L/I+5PCf/BND9pbxlBFrFjoJtdNNsLqKOezuQ14S3AQ +WSFAzyw5rub/wD4Jb/tN6hDFa2nhiCN4I2lN0bKX94wwQp/dgkDB9z7V+G4z6R3DOEx8sJGzUW0 7yV9H5bfif0rl30V+LcXl312u3GUrctou2q1ve1/wMPWf+CYH7ROhaLJrl/o0ouLeIzTwRWM+wxr 94RgpgE9smvzv8deD9T8FeJr3TdRglsbi2cRtp18B9sBA5bIADAndyBxj1r7zgTxXyXjvFVcFgGl OCvbmTuv81v6drH5z4leDmd+G2DoYzMnzQqO3wtWf4q3TfR976cwZJJrYsqbSxA9GX6iqjxLEy72 AI4MY4kzX6xHZH4qf//S+bUlntpDMFkMTNgKfvAZ/wA/lWtdWrho5MY81dy7uQR0r/oYP+ac9Y+F Xw01r4o+IbDwf4Rs5b3WLhxve1i8+5hdiNpVdrDGAxOew75yPve6/wCCTP7SukeH5fE8mm3Gq2Lw fbZLKWxKXECAZAVFAOehJwP8PyXjrxYyXgPMaWX5grynb7VrXfmn5H7XwF4K8R+IOS1M5ytPkg2t I81+Xd3TVtU1r2ueK/Dv9jT4i/FjxVqPhbRdG1mHXtMVdO1SCS1JtLacfIDCAuTnggHPBHNfVFr/ AMEgv2mU0q5SS10+Yx2bO0d1ZmG4lywC7SATkDnHfBr4viH6QfD+S1o0Gk3JJpt9H3Xe3mfY5B9G XivOqDr+8km1pFvVefr5HxF8ff2W/iR+zpqMEHjXR7uKw1E+XBe7HS3SRVyygsq+5x1rwPw5oNx4 k1iLSNFt7jU728eOK3trOJp3YySLHnIBCgbskngAHNfpnD3GWW8RZBHiLCVEqLV3fpbV/wBfrofj ud8D5tkfFlThHE0W8SpcqVmm77aPZ9+3fqf/0/vL4ef8Envj74z0i38R2lpBDBLGJlj1OKaOOTeo O1So+fbnOcYNdtdf8Eb/AI8X1zYxvOYSin7V9mtTb2lx6dYxt796/wBa8y+ktkeDzGpg6UYuEG4t 31bTt0dl6a2fVn+MOWfRM4pxmXQxmIU41JJO3Lok15rVeel10RHqX/BHP476TpOp3SW/2u4S0LRt bXbzzIUO75IynAIHbJNflt8VPh/qXwy8VXXhHxQk1rrNuQn2e6geBpMKNwAZRyDkY9vrj7rw28ZM p8QMxq5XRcY1Yq6Se610td9Lv5H534teBGd+F2WUM0xKlKjUdm2tE/Wy8l6s8tktradyER1njcBR tIBH1/z3pditMsUkJJPCt1CkdzX7dTlsj+fEvfEEDRzuyuQGG0kHFWSBGV4Lke1WpJuyHPof/9Tw +5uraI/dKTSFI0ZmxGpPBB49cf8A16/RP9mD/gn78Qf2jbGTV9IF0uiy2yMJBB5AicANIfOYdCGU DAzk9eRX+7vH/FtHgzh2tn1b7GivtffXVPZP52P+d/wx4FxPiFxLR4cw7tzXlK29lppo1u1v0v1P sSb/AIIn/EW93H/hKNQ0mMfKkEaLqB5XAAY4xzySS1eN/Fz/AIJJfGv4R+GbvxNBqP8AwlOlaTaN JcWyWO+Qk/dJkXoB7gj3FfzZkf0oMtxuZUMDjopRnJRbSaeul1d2v5ddlbc/pvi/6H+dZRkVfN8r 55ypxcrNpqy1ei1slfW7tvqfk3qUV7pF+NNvLK706/jcxXNvc25hZNpwwKnpnkDNffH7JP7CPjf9 qWx1HxB4Z12fR9Ktb2ayNjb20RuE2EA75JARg707fxYzX75xvxbQ4Y4XqcRxalFJNPdO+t9Hta7V vI/mvw14JxPG3FlHhVpxlOVmtnppbXZ3svL1P6AP2Df2JfFv7LF3cx67dRX1ubo3EEu0K7bkZGLE EgnDDAHAxX6h6lZnUNOvbAP5Zu7V7cSdNhYYDfgcV/lJ4lcTw4v4ylntN/G1f1vf9T/cPw24U/1K 8OqHDTVvYwce+lrL8Ef/1f3B/aL/AOCSnxC8ceMvFvj/AEPWx/pUEs1tFG6G4kKyNIFK7iGBGAOA T6ivwj8XfDjxb4M+Ilz8P7+2jk1u11aPTlLRNaowd1X51P3WG4DjjJ61/rV4AeJVHjDLI5KkubD0 166aW89+n/Df4q/SU8JsR4eZ9HNpu8MVUk/Le912v2Z+vHwh/wCCSHxB8V6Rp/im71W7sNOvmiuv sLNAbhthBboQu1uoHJHFf0QfAL4a3fwo+HeleELqVppLKFEZpCDJ8ilctjjJ4/Kv5d+kV4lQ4txd TJY6exla3az79X/Wmx/eX0V/DD/UTh5ZhNXniIqTk+t126dEl5dXqY/7SnwSb46/DfVfBcV39knv kAhlLiMRsu4o2T6Mc471/NH+0p/wSn+I/wADtC1Pxbpl9feJ9OnVzPLDEL2PTSFLebIqnOM4Hpzz 610fRt8T6fCOK/1exK/dV5Rv366rzV36nwv0uvCOpxbl1TjLCP8Ae4aL9LaXT9bLXp+fw5+zP+zh rfx3+IzfDmwv5VvLS6xeiEpDKwjJDttfptIwcdDX6yeK/wDgix4rXw6dc03xBete2lq1zLYR6lE0 1wqKW+4Bgk4zhf8ACv6n8UfGel4f51hsv05JpNvdO9uq6Wa2++x/JnhD9Hir4n8IVs9TftItqKWj XLdbW3un8tLXP//W+7vgV/wTT8dfFHxPrOg3t7daTLo9zLbLJGqWwVUOMybx1JAGPfpX2N/w5C1c Xcd0fFjTPHBt2z6ov2d2IIOUHcZr/TziL6S9PLMaqOGS5HFPvv3/AKR/kvw19DvGZjlrr4yTdS7W 9lp2XZ+dz8u/2rf2LPHP7MGrw2+v3VzqWmz3BhtZ/snmQYwxUrOoHI6YI718U3TuvkMyNCjLho5V KSNxkHH61/RPAHGWF444eo53hvtaNedk9O2/XbY/kvxF4Gx3h9xdieGcctab0fdXsv667n3f+xv+ xTq37VV850zUHsINPmWRnS4S0mjbDsuSx+YEL2Bxn6V+7fw2/wCCevx6+Felx2Hgr433mj28Y3fZ ZZ2vJCT1XcCq4zzjGOtfyz9JDxCwuFzN8LYuHNCCTtZO/MlfR6eXyP7o+if4WY2vkEONcFPlqVG0 7tpLkbUbWu132676I/Nj/goZ8OP2mfAVgg+JWuXni7w9eXTQ/bDboIDGYtjMjrxkKM4Yk4Y4OOn4 vXIhSf8A0V91qreWi9VAHG4e3HrX7F4A4rLsXwTCrltuTqkrWfp09Oh/Pf0lMNmmG8RZ0s2T9ou/ Xzv173WjP//X/Zn/AIIxxTXfiS5vmmW4ayiSBVP7pUjYS42L6ZIr+ky9tUv7K5s5CVS6gaFiOwYY r+oPpGvm8Uay7cv5s/nL6OMfZ+DuC/wP8j8Nf2gP+CR7fEjxR4j8eaZrls1/qTy3P2KScuAQWcfL gZBJPyj16V+Afxk+DPiL4L+NdR8H6nZX8cdizwyXF2nkBPL4KqTgMOuCnbjtX9PeAfi7T4go0eFM S0nTjaPR+nmt+l7n8NfSd8Fq3Cuay4twMXKnXm3PrbbW3Tz6fM9R/ZO/ZV1T9pbxaNE0i5g06FSp llN1HFLNvk2kHcDj7jY7nPFfqV49/wCCKOtWfhK5n8LeMU1HUbSIX50u4lS4uy8Y3NFazPENoO3A Ge1ex4j+O1PgfiqlkLV46czab381tbbT56WPH8M/o2Yvj/guvxPTvzO6gk0tvJ333u9O2qZ+L+o/ BjW9G+L8Xwp1O2v4tQn8QppMtxcslq86eaYpNrgEBlI25x17Dt+yXg//AIIp6p4j8Lafquo+P102 S6sC9tYrPvf5h8rSMiYPp3PFdviF43Yfg7LsFmFBJxxKUtbvptpbs0/la25w+GX0eMbx7iMfgqzc Z4WThZWXV63ad900tLPe+x//0PaP2uv2XfH37JHiQ6Jq9tZXGiCOKNdWgHmG7DSCNCxxhtxxyRk5 P1P1/wDso/8ABNTVP2jvBNj4pvNT0zSLG9zdt5F2iT8MUUlVQkAlTwfX8/8AXXNPFulh/Denxxg0 m52VrPRu97fho72vrc/xN4d8EsVj/FLEeHeNuvZczvdK6TVrtX89Va9tLXP3l/ZC/Y7sv2WtNuNO tNRTUDcM8jyJt8ss+0YACqcDaDk8/pj6/wDF/h6PxT4d1XQ5HMYv7OS3VxxtLKV/kSPxr/Nji/iW pxPxa89rP3pSvrvo76+Z/rRwtwtT4Y4Ep8NUUlGEHFJLTVWsuyPwO+O//BH+6a71z4heEdWfVNTa Bp7nTzPA9zONvzMjPCCH4H3SAfyFfgT8TPBmqfDvx1e+EdYtruHU7V3iEU9utvcb0kaPy2jX+I7Q eAM7hxmv9BvAnxRfGeX/ANkYnSWHjFJ+UbK33bdkup/ln9Inwifh9nEcxw+sMQ5S76u7vsuq17tn 3v8Asc/sO+IP2l7CG6vnvdAsrkmOKG5xbKwOD5zbkJwVDAKPTrmv00H/AARS8HyMktz4muZpUC4U amI4wVGD8v2c5Hsa+N8TfpA1uHOIamR5RNtR3at376Pp/XX9d8Mfos4PifhbC5/m9NKpUV7O/Xy1 Wit+h//R/oEl/wCCIvgmdDC3ii7VHl3sDqO6NAORnEIY/wD1utfHH7XP/BKjUPgr4Wt/E/hvU9S1 rSLbc17c2V1JcSwhQWUMr5bbnAJA71/oZwf9JfHY7PsLgMxd6Unyu6S/He/Z/wDDP/MXxD+iRhMk 4XxmbZXH97TjzKzbas+3buv8rr8ZLmyW3kK3ISKe1cRXEBOJIyc4yDzztPbtWVqCW7ziS2haKMKF xI/muT0znA6/Sv7mwteFeiq9F3i7NNbNNb+Z/nZjKVShWdGqrSWjXZ3tZlYmP7RCJpfJjBGQEyMe 4qK7jgguXFo5dONhCbRjjt2ru8jk8hNssskRkSPy1HHyDP4+v417p+zl8QtK+FHxZ0PxhqelLqtl YrLGYRCs5izsfcQ3BwU4684rgzXDzxeWYjCU3aU4SivWUWl+Z6uRYqlgc7weNrK8KdWnN+kZJv8A BH//0v6efA//AAVl/ZWPhDTYNf1H+ytcTTVi+yQad9n85lQJuCICQBjkgfhX4yft+ftp3fxb1U6V 4J8Xatp/g2RC8llpkocXYdVcpudO+1lwD/y0Oc4GP9BPDvwZzLC+JksdnUG6UHKeqfqm9rX2Xqf5 xeK/0g8jx3hTLK+HaiVWcYwupLtZpWve277WPyuvJLi7kSZHa5R8bZJY1W4yVAIOACegr0b4TfD6 6+IfxE8L+D2udPsDqeqrbTvqLsiRDncxAGflAY4PHFf3LjcRHA5fVxTV1TjKVu/Km7fgf5t4HDSx +aUcDF2lUnGCfZyko/qf0UeGf+CM3g3V/B9pfyazpY1XULFZTcMS8jN5Y+dGjQKm5s8A8V+N/wC1 7+xz4z/Zu8XnTbtLi+03ULqOCwnmbzIoCR91GCjIIUsD7H61/Knhz47Sz/jKtw9m87RcpKN9Emnp by0tbRa36H9heLH0cZ8KcC4fibJ4OUoxi521bTWv+d9Xpbqj4zTSL3+0IolQGVZfLEXlmZXIIzlQ CSF74HSv2F/Yw/4Jv3v7ROjr4g8eSQ+HtFnjje3t4na1urjy9mJWTy9o3tv9wEGc54/V/FfjzC8E 8M1MfGaVd6RV9fX9PVn4t4LeG+Y+IfGFLK40m8Oneba0tpv+foj/0/2k/aJ/4JL2Xw70CPW/APif cVcx3KApcNgc/dePfnAPTpnt26n4C/8ABIjw54s8JS6v4011re/v5fNMkbjzLrAGGaPy/lHUYOem fQV/flT6SWJ/1WVZN/WHPluvi7237dfl5H+akPok05cYKlGKWEUeZp/Dfbs+vT592e6f8OZfhWsy 3I1VZJQmxpGb7w9SNgX25HFRX/8AwRk+F7aZexaXqmnx3V9lpy9ojynGNoSYx7l5BBwRXyb+kfnv uy55W66/8E+/j9FDh2MJRjShzdLpf5aH4l/tdfsoax+zf4nm0iXTLiSwMwtRfxTtNDLFKVWJgSuB tO7oTxjvwP0a/ZA/4Jl+Avi18PtN8R6vqVmltNp6IYbpIr27nfYq73+TqxySeuc9OK/aeJfF6dDw 4wnEuXTftJNczTad9lez63u/NH89cDeCCxnizmXCGcUlyU0+WLScbbtpNbq1l5Mp/tA/8EtI/hvf 6TdeHryW70W8vFslube3iltbVPvZmidO2MZz3HYce7fDj/gkN8LfFvhWy1PWNatri+uYkuJZIcrJ CxRSVUIq7MNkY7EV+a1fpCZnUyKli6M5e1u1LXVetvw8mfuNH6LOTU86q4WtSi6dk46aP00+/wA0 f//U/er4tf8ABGTwnpfhXW9V8Ga7NdahBYGVLT7Q4lJTDHaX4JIBHb61+BPjz4ZP8PPGWqeGNctb +0m0eRzIt5CTFPEpUA4K9Q2ee4I61/qV4LeL8uOMRiMqx7vWgrq+7Xlrtv5q3of4/eP/AIHS8No4 XN8El9WqNxfLsnfqrb6rpbt1P0E/YW/Y08DftOQ391rNxHoieY0M1vcWqJdyBViSKQKF+XJ3+/y/ Sv1atv8AgjR8DrcQNJcx3piGVaeSSOGXK4IdANrD0zmvjvFHxnzvhPierk+Dk1CKVun9bf1sffeE P0fch444SpZ7jknOTt36Lfp1/rc4v4hf8EZvhfZ+HdSuvA1xb2urrbGVIFeSGORlBKrHjG3ntjFf zp/Gz4Kaz8IPFt74d1/TtRie0u5USUoEt5cHjDEAqeDweOeK+l8FfGOpxnmFbJ80k/apXjd/k/P9 F3PkfH3wFp8AYLDZxk8F7GTtLlT6W3VtLX/O7dj68/YT/Y88PftI+JL/AE3xXqKaeRJH/Z6zSDy3 jVIsqAmDuBLMQSTgj8f1Y+L3/BHnwFofgzUNY8AyWU+q6ZAL5YxCLa4uXXBdg2MHOOhPP5V5Xip4 zZjwZxjDKaLcaMVBv576ddb+qPd8IfADBce8DVs9rqLrNzUU7fZWiv06W7O+p//V/Zv9m3/gll8N /HTS3Xim7Nvf29w8M+mXcs1o0fTAEIwMEtzx/Dgda+w7/wD4I9fBt9Mv7Syk0xby4hZAZLZmYsPu 7XIyP8/Wv7k4o+kHntLMeXDVJKmrP3XZW3e2/wB/lc/gDg76MXD1XK1LE0YurK6vKPM072V76r0t ZbpH4Lftnfsa+JP2cvEVvLHpupy6LaxPa30kEQkg8vC+TKAFAPcFh1z04NfAd5pzRmC6WV2iQDyz CC0mWPAC98nHBr+w/Dbi/D8Z8LYXNqUrzatL1tf8rb9bn8UeKfAdbgLizE5POFqad4+l7Py0ae19 LH7hfsH/ALAfw/8AjpoWm6tr+vrLObNZ9VtpJ99xYmUlxEAGGM8HIxjHev1os/8AgmP4U8PWrp4U 8Y6npHlqTBDYTvACx7ZOcZwMgHtX8b+PviHicPxjVyjEU+alSdl0sk2uzvff1P7r+jX4YYd8D0M9 w9TlqV48zdr3bitHqrW/I/BD/goh+z3rPwe8T6Za6trd/rMFzrEFql1d3fmzWqNI5wR0G4k5x1zX 5mXMkcxtliBSCSM70Oeo6c/56V/WHgrmVHNOCMLisPHlja1vx/U/iHx6yXEZH4g47A4mXNPm5rrb t+h//9b63/YS/bftf2Y7pdF1vRL/AMQW11fBku7FDKYEZkCBvlIVRuZCO2FOcV+nHxk/4K7/AAm1 zwT4j0jw4lzpustZtaoZNPubm5iuHTCLwqDqf4Wr/S3xS8D8x4r48hneFTlQm0311Tu0+yv30t1v t/l34KfSFybgzw2qcPZpOMK1KMlG7ab0ai11bt0Tvfpax/OP8X/iL4m+I3iPV7/VNd1m+0ltW+32 n2+4zJjGcNjom4swTJC5x2rzZdk0e5ZVli7MK/qPh7JcLkGUUcqwkUowik7dXpd/Nn8W8VcQYzif PMRnONm5SqTk1fpG+i+S/wA9dy7pskcizJMxhkgUiGZCd5XoBX1F+yh+1TrH7Lfi861Y2mp6zp15 cq89rDfyQPAFDBvK525O7dhv7teZxjwxhuLcjxGTYlL346N9Gr2/y8rntcBcaYzgPP8AB5/g2/3c nzJPeLtf8k/O1rn3x+13/wAFG/DXx8+F9j4GtvOg+1edcSvcWc737SvD5e7zdgA2FmIbPQV4t+xN +31efs22K6Jr8N1qem3SXFlAIXma6t8ymWMHarblO5gADngcV+C5b4DYihwDi+GqsuWpOTcY6fnd peXpqf05jPpOYT/iIWG4joQUqXKlOXvK232bXdrNyt3Vtmj/1/pz9uD9t7Vv2g7iOx8H6ve6Ppl7 5JufIS407zFjRllXaQpyQcZI6rnrg1+ZCxIty0JDbVQkkH55GOeSx9xz3r/Z/wAK+BKPAfDdLLLf vW7z+SaSdm0+/wA7dD/CDxn8SKviVxdWzeMr0Iq0N7atNtJpNa6fK/UjisIZYZTI7Kc4Vs8jn/Ip qFl/cQDMqISyvja6+q+//wBav1E/Iqb6CWtxdWjS/ICz8BJE+5nvVz7ZDcyb5oFimgjCO4Hyy47i i+lzVJsv2yx3s8kjsxMiFyiABpP9010HgGMJ4w0O2kMlo99rEFrDegMjogfc4DjoTha8LO4Rq5Zi YSWjpzX/AJKz67hGo6WfZfUTs1Wpv/yeJ//Q/sm/Ytu7i5+F2lpLPNOkNlCse5i8akBTwfX5v5V8 y/8ABVSw0y6+DmprJZW8l/JayEXHkgshEEmMnuTkda/aeHlKj4wpU/8An+/zZ+LceRp4nwfq+0/6 B1/6Sj+Oy7t7aAx7INk8i5lxE0S4wAoHbB54FUZls7i2WOWIw3UUhWILktIDnvmv9eqPwI/xDxDt O5UuDOgRJI2HkDGTneV471jXMsTxrJbia0jJAf7RKZHU5wcE9AfStTCMry1NnEsTRKwwViVxKOC2 Rx/n2qzHcXTztKcb4kINwwBRMjHOe5oFf3z/0fmG12273DQkOZiWlaX5lb3H6dKqpeR28xnRZOAY 5Ay7V69v0r/eg/51y3PfWNwm+C2eORnURvgiRfUkZxXUR6IkuILrU1ie1iF4+ZBEbjYN/lAnqW+7 jgnmgaV3Y4y5ZL66kaSIxDcTH8oAjI6ACrTBYrdA7PLMSFIxwqjpjmonsb03szPa53TpA5Kx4LIu c4xxTrmVoGgaRZ0iJKwyohy5OAeayNIyvLU//9L5huOWWNw/OGiZThUIx3rqPDNlLe6vptlbTDzr rUre3kdxhH3SrlVPrx1HbNf7m5neOArtdIS/Jn+BHDqU86wsXs6kP/Skf24/sN2FvafCzTJbVCqX FsiDjGCD/wDW6+mK8W/4Kf34X4O31uC7O8bpMwJSNQIXIUn3OPyNf5L5bzVvF9OT19t/7cz/AGh4 nSo+D01Hb6v+h/GhptzcDSr7Tr5p9G81WdyqERyPltqRt12HIB7V+Vv7TE32F/KXUhaFkYi2YhSP nI25P3iCp6dcCv8ARbxWn7Pw8xkv+nf6H+eP0eo83iDTfaT/ADPz9kmR7m5mjPm+a+95h829uAT+ nWo7aeWBPnYlC5KFuXOcnmv8hMT/ABWz/WWjsvQ//9P+QCRIpZPMjmkjkdsO4OWXnoBUsyr55Mat yMM7D731rimtTaK5dDMmC27KpQBnPpxU6rCu0jkgZcDv6VlL4SicyJHb/aImdSAcCTpkUNcm8jW4 uIraNFjEUbRRBJJGHUnHXtWIEbXMSW+QH45Ifgn6VREvnYY/w8jHUUAf/9T+Oq28xTKS7eaSQpHB rStr1Xi2TAebHlSSuDXjnXGSirMiuLxJU8o8S/wZX+VNivd67Y3kVkHlsH4DMOCR7UGq1VxUm3b4 phubqOOAPSq88YSbdHEGZsABuAM4GTUuKYFDVEfTCWYiQucDyWDBiecA09JzJbrKYWgL/KyE8rgd f8+tZ8r5uUD/1f45IN8jL8+AgKjPAb8KyLlLyGa4WSGCW3cotuUYtKD3yOg/WvGUUjrnuXBHNMzX DdAgjUN8u3Ax+VDRwwxBmn3yTZXPBC464FMgqwmNphvkdUUbEY9j6kVdlnSceXFIT5TAOpXBcD1p N2ArX8VvBCZzdNAFUM0aIZPOzxjABOee3vSRxo9rvR+vzKNpDZ9CDyD9az53cunuf//W/jejjE6Q v5GGXjcWAxUTfNd7WB8kEAuPvgd8CvDlPTQ9FK7sPvWjdZLeC4mggZhGskijeeeh7c0aXbThr5pk hkt5IUitXVNjhl+8zflj3zUqbRuaAaG3jMbRyGWZ1RXQFtp98USwu6sH5G3qOSauMr7lxjfVnMlb 1bp47dS0ca7kIb5ge+R/nrV8WT3caXVy4BOUZQQScevp1qzRJLY//9f+NGC1hsLV7O2leATEhph9 8gnJH0+tPMPk3ASKVpAY18ze2ZAcV4DVnZHuz2sbdvECu9lj3A7drttRv8Ks6nYQC2jinaSO5hkF wBasskWCOAWHrxSMjjJ55YZvOLMUZtuxeCcd617ZmljLpIRg5IPAoASN3kbElssdwz58/lZQB0FP kfUHa4WQgEnbDN988dyKjkQH/9D+MS+eeJoxJIZHUAJI3yAEeldRJf3V5axok5lQoPOZlCupA9a+ eUVHY9gbbWvmxyyXEhQQQmRQRneR2qjJerfTWNpcQwy2tvP5kiyna0gOOCfqBQ1fRgJLbSsWitWj HmS/JG74VOuMGmw3E8NlOLyeP7fbgyJHEm9GUHgfkOtQ4a6AaOm30siQTeaqQMd0o2g7ex96zvFK W0+oWwtIY7iMxLI14mRvP9wr2x61pbsRNXsj/9H+OW0smaKR2uZW84fOuc4xxgVE88kUbRl3L/dh kk7D0PtXgJa2PVkrQsalib6WeK3sxF57hXE0pzCgP97HNfoH+zlp93b3kRvhKzkKWkSBki8xY0ZG j9iWPPsa/Y/Belz8aYc/IPGOq6fCdSK6tH9Av/BOuyvLj48eGPEdmtvdxzwyQqt1ltpL+SzKPUHd keuPSv7PYbO3tPAPlxsd9pophIVSDKwXHA+hPIr636RUlPjHCQ8l+DPpPBOLpeH0rrq3+B/Gl/wU 61TTLf4zPpIt01K2s9Uk1STypibmFXLRgMB/CDty3+yM1+EH7RGt29n4U1y1ty1hayTLcFHUtbwh nON/6kZ5G0896/qjhRyp+GdKT39m/wAmfyFmfLPxWlGOyqfqj//S/iT8eQOL9Li2mSWS6iZ7som3 YwOBgdMEVwFlDIDh3KgdyK9TOXzZjVl/el+Zz4WPLRivJHTW15JHPDapCZECF5ZSoUKAPvHP5fjX RJdQnzEuoIZPNixtRt2MHIPt/wDXrxquiOlJvYktXdG/dIixsfuyxh1XPfB71u21kioYoxv3/OXL ZBz2/wDrV5tTS5vGLtZHW6UktxN9nghUmzQO+0AZ+vt/jXdWt00X2aVlP2ZJgJbdADLJkAYB7VwV XbYrkkf/0/5YdTlaHTbWPRdQWaK+/fSWcpKNBIMAhx3HpXnd/f6nYzS6dewbLxVXzZo4AsShjuB5 55Hp618g3rqeglbQu+E1vtRXU/7UtLpbC1m8uK8hl8h7zPIVeP4R1xxzXRSt5E0ltbQhYjEoV2j3 zIoOcFscduRj9az50tDWMbbi2r39tKJZTM9nO4jQFQY1x12nGe/NW5QXk3ghIiwGQNrH2oU09ykk tjQaGGGJGkLEP8oDnAB9z6Uz7DH/AGgkwitrKBo1SeeMMw4zl2UZOfp6VEndmtNXkkf/1P40LS2t Y5mv5YU+e5MscbjOTk9venC4k0m4XUhp9vcWq8SiR2811J5ACgk469a8Kas7EufvEVzpWmyRESB4 W1CX7QCkZaRTu3gc+nHWoI7fUbqBbWC8uxGlyEtgEMbIwOMhT+XHHNQDkkW49O1O1MqXcjyRE4Y5 y+Bx81VJfLSUh5QplHloDx5Y6AmgFJN2G2lwLFpLFIjP5zkSNj/WepPtx2qnqWkRopuYDHEyDc8K 8YBPFaQk/hJk7SR//9X+LvR4vn3xTHAH71MZDD+ldrC0EUfm7pZpJXWLy4o8hAerMc9BxXlU97GD ZQl8PwWz38sV01lb4E6CZgPNmbqiDPAJzz2qna36JLLD5qSrHGGlxyIzzz+hrupN7D5ne5Qmadrt QiRSxSgs3ltkEEcY/wAK891ueSzuBbzozq4OyZzhkGSMdMcV2U9jNvRop+HWWzvzqMc7Wos3EocJ v3YyeAe1ftL+zZfavqOiaXpOLiSODRbc3Uow8M0TAOkpxwM7xkdjX9I/R4quHEk4PrH9UfhnjrH/ AIxLn7SR/9b2P/gk74phtfi5b6FasY5obi2fSROp+ySmBJjIgbPA3sgweuK/s2hQaj4bglmRNt/Z mS6APyRhhkgfTFfvP0jKEqXGUZy62aPkfBnE08V4X4aMN4qUX63b/U/jI/4KkaLp+jfHy81CG982 PUobqzOnpb/Mxgnd0fcOxEqHJ9/evyOfUpL20llSxge8tsyx2lxIPKZFJLqrZHJGcV/YfgvOc+Ac BKS15f1P4H8WKUKXGeOhT2U2Ycv9r2Nha3Zu9Nk07UoTJ/YefPms93UyA/dYY4I9Kh0t0sLWVbNH kN0+8rGTtXOOAOnbOBX67qmfktJe8zXjN1fxXoVJ5Z7UZu8Id8Z6fN71ixLc3McUdzJLb21u5ZYZ Iwjk+me4P41pT2OpxaVz/9f86F066aBGU2z283yhfMBuYyOh29QDXLDSBdSTre3MvlInlQlWyy8n OD7ZPT1r/aA/yMp7EYtoLRZbazcfYrfpdPxIzN0DD17VqaZ9nunlSZEYbMLKeCuPQVrBWRZCLmNL hnjiw8B2L5HyxyLn7zDpmpRf3t6rxWsSq8ZMtuH+WEEdT9enSrImtLkcyyWxihcC7uXJaSJMO0Zx k++OO9ddpQ0qGzhvm0+a7nu7TcLQzCCOA5Iy4xnt04PNBm9z/9D81bOO7sNel1DT1hWGRy8emool RJOBvJPPbp7VkX+pG/u52hVluY5yskIGE8zPJXHYmv8AarmdrH+RCV3ZGgmrX0X2eLUTG0r4Ekkf BUD+EA9umfpUy391e6jJFAsTo4KQpKoZn/A9eOcVDajua8qtZmTqWnwBhZohhvlcmVc7Rz7HpWzH Ddpb2wjiDBVAkYjDYHBLA1POr2M5R5ToY7S1gt0S01aKCeQeZdwTxN5YGMjB5BI5rktOu5onv7aY QTb2Li5RNrBc4AXPNPmV7GcoqzZ//9H81WuWtnQwOzw3SrakMdpVj2z6Hvn0qPUENmZIrmLdtJRk Q7WOOu1u31r/AGoP8fmk9wkuV1LRoLWB0is9OvPPjspGDXIkIwZARz0UCs8arMxWxiwWuH2SznBl gCgkdexP8qqL1Rzygrm3b6raaQksANvrCzQfZojcKYRbSFlZmTIzkYZc4/iNWdSeeG1kw6+TPGHU piVUPXCnvWxgVrIXUtnDd5ha3kgMjhwA+BnAb0YkcDnrUEF7Z6hCtrPYR288ch2zrIfOj54yR1GD W0LW0A//0vzctp7hbmOwtraORnly7uzGVYlzuZcHHPXkVLqUN1Az7TDLblhskH+sPtg9PT/Gv9s5 cvQ/xzurIqyXRuza2c1oktpE2Gt1/cGXnJ3MOc9ee2K6P7BClrDNb7lsbeTadPe7NxdKWGTufuOo yR/Knyx5dTMjg03RHe6nv7iSwszZu9pEifaZI5wfl3YHKnnPQjimabHMsU4mRr20jHmxJt2lF/iO f1pwVrky+FlW9gWS8F7pQNzawzKl3Hx9ptImIG5uw6ilUCS8l+yhOmN/8a9cZqzE/9P4JtdQgi0/ DrI01vKUnldQI24B4HtntxWGs07/ANoygxq+oyAyvKArFe2OwHT8q/24P8WprUrnRYk3TnUkaaPB tliLKszcEoMjnA6544rRsrm/uLuKIWMd1Bbws09pGMPMV5JPPTg5/Ct4/CjnmtbmPLLctcC7khjb z5DhMYVAOyj2yAKvaZH9tF2k2YQVEUEiHJP4e2TTJaa3KU9zqMbS6XcMfIhYbFYDEgwCCvcDnpWx YNaqlzqV6jRQWlsVAQnDMB1I547mi3QqMb7n/9T88F1OCaHzrdpZJbhPnDDbFtHTH4UltpyXE1nb s7pLLbTXQVEMjqsalufTOBjPY5GcV/uLGLjuf4q7RFtrG8Hk3kUiwSRMPlJHmqDnsPbP51upf200 j21wDII4mKlZdihyOCT+uO+KsiC1M29k0CGK3a5g1Ca7QMwit3AiuGwdhlyPlAJ5xn6ZrF+x3bQW 2oLHECJwxtpGDhFBGSVGTgfrzQamjuvhrF150+m3M1380C6fF5adOxzz6HjtV7UGuraSG0mkikMq jY0cm4Kx/hPuKCZW5dT/1fgK30+RYN84aZHYgDccY4yPwqOC3tUvUWB0dMlwJpNoi46c9T6Cv9yD /E8vajeLJEtpe+WjO7fYCeS+AuSx7dfyxUFpZQRTwzRXyiUDHl28oYNkYbJHT/69ByVXrYs3MFmZ 47a0h8sSkyXygYimPGCW9cCqtohFwYIIbGaf7Sg8uRPOlTYcoAT0BJ9ewrZO1jCavFo9ugWF0iij W0gvIkRZRAiorNgbuQADzmv2t/4Jg6vJZ+I47XAiSXUrfbI0QWRiIlVmJ68sCOOwr8u8ZqaqeH+N i+x+vfRuquj4sYNLqpL+vuP/1v73opQNKVjGRttB8idciMDA/EV/IR/wVetzYfG2yhZWny1663Rd f3RDISrD1+6eO4r+nvouSt4mxit7T/Jn8ofTFhfw75v78T8mV+wGGVowJDFKRPgkMG4P9etZ0l4y rFbhZAXJIfYcMB2z0r/UeGx/k3imlJWHbRsginuJYHuAUSYAFFCgcn3qsWS1u5B5i3Hk4jJmUEyc DoK0Ts7mLatqW5NXNy8cgiETRIIgycBgO+PzrUtdTuLy+tYVmKRSfurmE8ROnU5HTPFaT2ME7M// 1/Tf2ZtJ0bUviH4biuILfULWC/BFrMgmiSQMuHPoFw3Hbd9K/s++CfhPw7onw/0SLStLsbNp7FJZ ZbaHBk3ojD5uv8QH4V/d30u8TiI5hhqCk+Sy0vpsunqfxX9C7L8KuDa2OUF7Vykm7K+kmt99lY/K X/gqt8X/AIhfDPwfZ2vhHUPsRllRbptu4FJSVZjnqVA6Zweetfy7eL9ZvtThl1DWLyS9njhCz35t /wDTL88sT8ox1PIAAHpX6Z9FjJ8FT4J/teEV7ec3FvyX9L7kfzd9LXN8bX8RKuVVZfuqcU4rtdJ/ m2/mzkdD1W6injsknnTT1P2pGzhw+Oh788Cv0L/ZD/bW8WfAjxfptteeJp5vBsVyIb22Vpm/s+Fs HdIdvGC7cAkYGcjt+1+I3CWH4v4axGWVUnLlbj6pbfM/I/B3jirwNxbhMx52qTlyy1skm936W18r n7N/tLft6/A/4pfs/wB9pGi+KbfU/Eeq6f8AZo7C3lIdGuLd1DsGAYDkgkZ571+S/wCwd+0PonwH 8f7vG7bIpbuA3moSEi2dQHCsGHQbXA5HUe9fzZwJ4W5tgeAs4yPExcZVG3BtbqN+9tdVsf09xP4v ZI/GnK+J6Mk6EI8stVo35q+l9NT/0P3m/bV/4KHeGNU8ACH4K/ELT7nXL+waytbW2m2T2ssvykSK w3AAbskcYHWv5wbrxbrmpeL49c8WXKeJb9dVR51vH82IoG+fySuMZJLDHf1zX+qfgH4cy4QyStjM dD/aJyaTtZ2vrbpror+TXc/x++kn4mQ454ypYfAS/wBmpLa91drrs/O3mvJn9OP7HH7eP7NHhzwd a6H4nt9E8I65ZWqJM+zbLPtAUNuLc9+/5Vj/ALbf/BRjwLL4KvtM+E3iuJ9QuIXk87zvKCRqhKBQ QAWLA4AJ+7+NfgWO8IM+zbxQbxUXKj7Vt9dn+S6+h/T+aeOmTZP4N+0y6SVd0lFJdLxs/m+i319L /wA3Piv4h+LPGt9qmq+Jbr7XdajP9rN01w0l65flmkB4IbLdOma5ywdmlsgWWbz5DC0JfZtQjBJ9 +pr+/cty+jluWwy/Dq0KaSS8kl/Xqf5o0sfWzLO/r+Jd6k5czfq2f1X/APBJi8k/4QQWS+XHbWlj Fb23lfMQEJCjPfqck1+16n5VJ/uiv8mfGyKj4j42PeR/uZ4dyb8Psum+lNfkf//R/vg1vRdN1/T7 nT9RtLe8guIWhKToHC7h1HoR1/CvAvh18AdN+H/jDUfEmnnyluxhYImCxfeJzt7Hnr9a+owGbYjC YStgYy9yorNHjTwNKpjKeMa9+N1f1PYPiFCZ/BuuwZ2h9OkV337Ni7SGOfpmv48PiH8FLvx5+1F4 10TS4JjHceIPIgkz50U8bgMHVegwD15Ff0P9G7O1kWOzHFzdoqld/Lm/r7j+ZPpJcMR4pqZPlji3 KVWy0v1i3e/9Wufrp8OP+CU2jXnh6yvdXurCF7iyjdI2bzHhfaM8bPlOTz/WrM3/AARw+Hkt0b2W WzvZ53JuXkvSIEGScgbRg89hXs4j6Qua0cdXjhpyUeaSvfezavueLivoz5PiMLRpVKcLwS6L5r4f +B+A7xH/AMEbvAOs6J5MOoQQ31oC1gttfTJkhcfMduDwT1Ir8VP2nf2P/Fv7PvjCXwzFp1zNpk7Y j1YESNw+V2FjjkcEZ4PTPWv1Hwk8dKmd51/Yuaz92UW438r7Ppq195+F+O30eo8O5PT4jyamlZqM 0tNWla69E3tpaztpf//S/Zn9jn/gmp4W+Kfg241nxB4jBkecG4ihvFjumJVTltikhcEqAMjg10n7 QH/BKPTfhrAfGPgvUF1O188rfWl4RcyPEFyeXUfdx2/Kv9A858f8xyvjnEZY240HPkt0V1p8/Nf5 n+a2U/RewWa+H2FzWFpYhQU77cyu2/8Ahm326I9O+Av/AATG+H/ifQo9S13V7eO7vNst3YWpFpJG GjXKhQmeckEHjg1674q/4JJ/DKbR7x9LmtLi8itmMFpewCdJAoOFyUwfXkV8ZnHj7xBg84kqdSbg mvtPVf8ADN/e9dT9ByH6NHDWOyFe1owVRqVvdWktnpbZuOvotNEj+dv9pb9m/wAVfAzx1e+GpfDe oNaXd2fsWrRRg2duGZv3W3721VHYD7wxnBr2n9kD9jm4+NmuQHXUeDRopljuWjtW/eMrqW2MVI6c E9ecZHOP6txfipl0PDiPE1GpF1ZQ7re2/wCq9ep/G3Cngtm2a+KdXhDF0pRpU6jvdNaJ6R1210fX TofvTpH/AAS1+Cllp9jLqqxTXiqjnEKJkhf4gBg/jnmrN3/wS3+Ac7yTXFtpBW5ULuuIkdgw+6VX bjNfxe/HXiStUlWU3Zt9Xf5n+glP6O3CVLDww0qcfdstkvuP/9P+m7xx/wAEm/hTc+HJ30C9W11C 3tHfZHbL5Fy+0hN6gfMBkdR9O1fzuax4S8efsi/HK/d7DUB/Y9/5dlN5Ji0/Vo45MPGrY4Knn8Qe nFf6O+DvidV44pY/hjNpPnnD3bu976O19tL307H+Ynjb4VYfwszXK+M8niuSE3ey5WuVcyvbztbX voj9KvE//BW4X/wpvfCz+Fb9L630+O0kuLi53W0cu0RH5kXc2CQR2HBJPIryr/gn548i8U/HZdbM 5b7RPbSXSRtm3gLSMpjTPQKFwD0wK6a3hLT4N4RznMZ2cpqTXXf8v6+fsZJ43z8RPFjJcJRk/Zxs npbVLtp8/wCrf1l2Miy2lvIhyjxI6HpwQK/lA/4K261d+Ffj1pl5YA/IZriHa7R+VKJYtjlhyCCe 3PNfzp9HLD0sX4kLC1leMozTXk7H7j9LvG4jLfDenjcLLlqQrQaa6NKR9Ff8E+f27/F/is2vwh8U R3V26KtjHdTXbSxSqwXkMVBHJPyknOevJx+qnjD9g/4JfE5rvxBrWkwx6vrNsrtdRWqbhuUA7m78 cZPPHWvd8T8PiPCTjqWIyZ29q+ZrVaXT6dX/AFcvw8o4Dxs8OKWIz5NuCSTdm00mt7aq+vRuy7H/ 1Por/goD+zbp/wCzT8T9Q0bRtRtJfDd85+wNIo3OWKFkA6CQEpnH+Feb/sZ/DjRfiR8VNF8P+Ibm EWl20sht5LBbss0bwGMAHjHzZz7mv9ksn4wxGaeEi4npt+19le/W60vvv53P8N8t4Ew+G8bJ8F45 J0ViHB6acur2a8treR/U/ov/AATU/Zv/AOES/sm70Sa7l1HTlMty0UUQikkXcZEjC8ck8Zr8wf8A hjr4W/DX9ouTwd4r1VE8MXOotDaRvbxmKZXOI8qxxnAAOCcZPXGK/jXgzxe4hzPMMwwdeTd4ycUm 9LPZ66vbp0P73448COFMqrZRXoJKPtFGV0tW/lorKWnmfpn4p/4Jr/s5eK/CMltpmjW8FxdWKyWl 9HZQSRTnaChZQMN+tfG/wX/YR+GngHxxqXhvx7Y2y6IL5hpcf2MRwhGc4GG4UcdhjntzXDkfjNxD LA47J8RUbqvWO+60+TXT1t0PS4k8AuFsNn+CzuhBKhblnotL7PzT3ad0mvNI/Qy0/Ya/Zj1BJhaa DBdLIo+W1mtyseBjIAjJ/XivzC/b3/4Jx6bo2jxeLfhXbXotLV47m7tLS18yRPKLZBRRghgxB4HX t2nw+8Ys5y7jLCrN5v2MpcrT7vTW7+T+RweLvgTkmYcAYuvkMF7anHmVusVq7WXT4vRPyP/V92+B P7OPjL4ieP7TSbHw8JILK+UX9j9kcSR/NglkK54wSAQORziv6afhF+wd8ENH8JWL+KvDXn6vJaod QfUrWCNFcL8+zKnaOOvB5+tf6F/SB8Wa+HrYbAZHUV3Z/J9d/RH+eP0dPAnLMTkFbOeIKesnbz06 a9Pl1PRn/Za/ZWtTHbrpfh+18g7BDFNboB14wFrRX9jr9mjXoJGj8I6dexSwm3zD5Lxp2LDCZz+N fzdU8ReMaNNYic5Jd3ezP6Pj4QcB42MsFCmm10Vrr8D8GP8Agoz/AME8dS+HN/d+OfhloU154ZkQ u9rYWa2UcMqY2ElRtZti45Izx/dzX4xeEvEur/Dnxlb6xp9yYdV02ZECzIYhazRSLIQ4wdwO3bgH oevFf6H+CfGVDj/gCNDET5q0YunUV9bNNdfVpb7eaP8AKzxo4LxXhj4qVPYw5aaqKrS00spXW3ey b8210P2H+H3/AAWU+MPhzRbfwvL4R0i9nOLK1uhqJW3A24Dbiu5TwBjnJ788fA37SX7U/if9oXWJ Nb8TWMenbL3F1afaBdxboj+7RFAwoPJJOScjgGvM4J8CsHwvxdU4lqcr1bVr6u918k9+9vmfa+J3 0iMVxvwpR4aw/MopWfMktLcru03du2nbvun/AP/W+frib7TO8ybYzLwQRgL2Ax+VZ99HJCsdskmJ LvcIZ8FoVYDLfluFf9BFJWsj/mtqv3mvM0beIxwRKXLSCLEr4AEjdMj0BprS+WqqH+VlIljI+Vie AR/nvW32zEg8gB4ljIXcfu5wF5q95IjGSwwOp9abfKB3/wAOfhtrfxN1+x0Dw5FJNfXNyI9sWC2M 5xtwc5GfpX9Un7B/7EemeBPCOk6l8RfDSX9xLZlohf2/yIGOURQ3JCqSBn1z3r+TPpP+Ib4b4fWT YOpy16mujV9dF56b9mf3l9DXwnocS5pW4uzajzYan7sbrS6s35atW7q3mf/X/tl1vwt+zX4RlB17 RvBWkTTp5IF8I42k29wGOM+61D4dt/2YdeuUstCh8A6reh8CGN4p5s9eUz/Sv23+1uNMRgf7Qpym 6S+1rb8PxPyehlPAtLGLK1GCrfy6Xv8A1sfOn7YX7CXw/wDjX4E1GTwh4Y0+x8W20ZutMFrAkUDy qvyEYGe3HPf0Jr+Trx58MvF3wR+I8nhjX7AWOt2muWxli+zSvA2J13nawB+VhyBxj0r+r/o6eI1b OMix3C+Z1HKtBScb9VZ/p+Xmfwf9Jvwtp8MeImWcXZTT5cLXnTTSWikpJNfk/n5H9ln7Fk32j4K+ HC67ZBbI/HAIZdw47Ebhx719J+KbzwvBZmLxQ2nfYG5ddRx9nPbnP9a/i7i720eN8esP8ftJW+8/ 0Vyz6vLhXL/rX8N04J384/5nzf8AHP8AZX+FHxr+HuraVp/hvRYNQv7Fxpmr6YRCwYoVHzDg9cEE V/Ir+0v+yj47/Zo8W6lp3iPT5ItJjufLtLyWJo7fySoMflkLtYZPLD/6w/r76LPiVOnj63COcT96 pbkb3utEt/Oz035ddz/PD6aPhX9Uq4fjzJ4fuUuSpZaLrfa2vTXpLsf/0PBwqnyZVKyG4bcdvDKP fPSo5AzbobZjGWI3453V/wBAlJ3j8z/mvfxu39bH2T+xP8R/hn8KPihp2r/E+1WfQ5r6JZFuYZLq 3YkhMlFzjBKsWPQIfev7NvhVc/Bn4ieENN1rwRovha+0i4to22xaZDIY8gYzuUnqP0r+CfpaYfO8 Lm1DMcPNxwzjZ2bWtrLbbVM/1J+hLieHsx4PrZRiKcZYqnOT1Sd03frurNfl0Pnv9t/4G/DrxX8I daum8LaPa6zaxM9nfWtolmVKx9HKgDGOOa+Ev2EP2Dn0S8X4ja2ljqWlybGsLK+Vbm1VCSxCDjOf lJ46Y/D8b4S8TcyyLw1xmCnUk5SlaLu23fo29et/ReSv+yZt4M5HnfjFR4knSSp06esbJJNaXStZ XS18231Z+vvizVPhB8MNIE/iPR/D+i6XbIHBXSITFHzjP3fX8a8msP2n/wBl3U5UtbPVvDUzyyhT GdLjDZBwCQU/nX5fg/8AWTMcM8XRqylG+rcv83c/X6+G4ZwOLWClRhGfRKP+Ssj/0f7kfGHw2+HP xe8F3elS6LotzYazp5itL2OxjiaDePlYFVyMcH8q/mG/aI/4Jy+JvBXxWtdDSRrPw94g1otYrarH HaKsjBQsThehA3bT6nI7V/YngR4n43hbM8Xl2NqOUJRbSd3qtGtX5K3zP5D8ffBvLONFl2Ow9JRl CajK2nut36L1Ute1trn7lfsX/sb6P8AfBthDrGk6Nqdzc2gmkN3bxXsodlBMhyCAcKo47ema9v8A ih+0b+z38Fbm00zx9eaNoL3DsI4zpEbQxhThmbC8DmvzvPc+z3xA4zxMsBUk3J2irvZPf5t+trH6 vheH+FvDnhLDUcbSjGlTik3Zb26fJMy/h3+1r+y78TdWi0bwX4q8M6hfzybbZI7OCPzcckgfe7el c/8Ate/sf+B/2lfAN1Zf2Po1j4msIftWkaxDAlnK5XDhTMq9DjqenHIqcBjOKPDrizCYvGylGUZJ 7uzV/wBNzx+KeH+FPFPw9xuEy2MZKUJcskldSWq+/Z76Pa6PwO/Z38X2P/BPz43Xvg749eGdLtNE e6Q6ZqKRpqO2N5AwK78cZQDcOCCfSv6D/hP+11+zT8Yry1sfh74l0rUNQlw0aW+mrA0Z7jcOhGD0 z0PvX7X47ZJn/FMMNxpgE/q1Smm0tr2V7fO97vY/DPoqcRZDlGFxPAOMt9doVZJX3tzS+fpof//S /vsZ0jjLnhEUk98Yr5D+J/7Z37OHwv1iXRPHmuQQaooAkiuNNSYsDnbyeoPav0zhDI8zz7NXhspb 9opdP+AfnviFxBknD+Ec88S9nOLSv5dNfX8D+Yz/AIKLfGH4PfGXx+uqfDOy0aK1eV4r1baxe2u7 va6tFIV6YUFsNk8rg9K/L+6SC3eULkqv8P8Ad9q/2K8L8DjMq4IwOCzG/tow1v56r00eq73P8K/E jE4LF8aZjiMud6MqsuX7/wDO/wAiKKR9qsgyjDBVhyM1ai3RvuJ+bPTGQvPcGvv1NdT4UZKX3YUF lDbiR0FXI3jaS3D8quSyrwSTjGfpg/nVPaxnGX7xM//T/Z3/AIIzbH8UXU/lII0aWKKWIbVkyFIZ j3zkn6mv6RtSs01CxvLF+IrqB7d/YMCP61/Uv0l9PFmvbuvzZ/PX0cve8D8t/wCvX/tp8A6Tb6V+ yp8TZxqsiXGjfEDVd1m8Sh3hkuX+70yPmDc5xz2FfWPxJ+HXg/46eANU8M69YWd3Ya/prR2t5c2o kuLMyKQjqfvAjjoe1fC5pmuYYOtgOJ6Mmvht6x3+Vnb5n02WcPZXneQ5nwnioqUPei9O+z6apxv6 o/jg/bm/ZQ1H9lz4mXdnFq1sdMuZjfLhWmSWJ5diFHI+ViWxjGOK/Sf/AIJ6/t8aX8LfBEPg3xR4 U1LVVtYQJtV0+13yTynH7wNgcOd4I45P1x/cfHOMj4ieCmGzGVXlnJRd/NevfS/zP82vBSjPw48f MyyeVLmjTnOFrbK7XS+1nb+r/qP4e/4KKfD3X9as9Jj8JeJIRcvsaYR+Y0OehZdv+NfaOq6boXxR 8IT6dqNoLjSNbsipivrUMVEiEcow54b0r+Cc7wGL4cxFDFU6t5Jppro1qu5/p/lVfAcV5RicLiKC 9nOMoST6xkmmr6Pa5//U+7/+Civ7Dh/Z11+98baBcWdzo+q3zeXa27i3YiV1PmyRbeq7jnacfLmv cv8Aglt+xn4Z+I8v/CyvEfiG0vNSsb5Xt7GOFykOwgoQOnR16/3egyK/1LxHiJisx8BpZ/BP2qgq T+Sbvp5afK/U/wAieBvC3C5J9JT/AFWxMk6NOpOrHs05JJWfq35fI/pb1LVIvAPhcztFNeWWi2Tf JEAJWWNWb9duK/NLxP8A8FbPg94S1+bQdY8Ma7DJb3BgluVDNEpU4xwh61/EHB/C2P43x1eFCq1U XvPzve/VdT/SXjXirLuC8PQ+sUlySfKtLJWsuz7n3R8Dvj74N/aF8MS634X3pbyQnzbG52tJ5b/I dw9eeh9RX4//APBUD9g/wnq2h6/8XfCg02z1/T9Ml1CZSFtLm3eIAh0AIWRWz8yHryc81+keEmOz vw/8T6OBlfWXJJPZp6fk36X36n4t9IvIMk4+8I6uZLlTpx9pFrdf1p933/zHXW2MpbmWN514leDm N2HDEe2QahkiC/6Sjn7SjKyt1xs5HBzX+r1N9T/GE//V+fftE10ZpJRHHIW3bVXCk57CrHmysF+0 zeXAFCqwGWXt61/0Ip2aP+ahqx9E/sp/Hmb9m74jf8JnAsGoSSTq6eazRtEoDRkRkdysrEA4yQBX 9qv7Nnx90v8AaF+HGneLbOyktGns0F5byrmOXcNjcHnr29Gr+EvpgcN1oxw3FMJ+7bla89F/kz/T 76C3EuDxOUY3hOpD97B8999Ja38tW112T6nlHxg0XT/2cE1v42+EbFZLWLfqXiHTRGFlk2p5bFdo y3DcDr2rl/2ZP+ChPgT9pbxNc+E9B8P6np1/ZhVnuJ5USInO3O0sT1H61/LmCyLMOK+E6nE0qjbw qtK/ZK6+b6+Z/VMuJss4W43hwX7JRjiffhb+Z7q1tF2/4B7P+1J+zX4R/aO+Hmr+H9ds7RtUhtnu dOurmHeiyIjYDY5Hbkeg+tfkX+wZ+wR4GtviP46v/E90sk3h3W5LO3020iWa3RLeQMoR2GVy6ZJH OAB1zX0XAfihm+ScB5nkVGTdl7uuyd9O9l2VtLLofJ8aeDGRZ14t5bxjOnFP7astZLra1rtdXfW7 66//1v7rfEOrQfDPwPe6jZ2rXNj4dsJJ0tidipHEjOc4PQBeme9fkJrP/Bab4e+H9fvdB1DwifNs b8WksondEcE4Gw9s+/rX7/4e8BZl4i1cRVoNuUW3K3d6tv8Ar7j8N8S/E7KvDWthsFikkqnKop6K 3w2X3bfmfqD+z/8AHnSvj54Mh8XaTp9zpSTL5iW0zByULsgbhj125+h7HgfnP/wU0/Yl8FfEDwVq vxk0I/2V4z0SB5dQuPsyTJexbRv34HX5VOfpyK9Hw/zjMPDXxWoYenJ3hUVOau7NPo9V6PXZtdTw fHDhrL/EzwYxNbkV3T9rBtLRpX3s3tqv7yV9j+T+aM2+pXFvJIynS72SznKgASNGdpP9fxqrPu81 podzHYQSp4wQR0r/AF6w9RVKMZrqk/vP8LakHSrOm902vxsVrUzyvsZflJ4Y8bfQfzq1Islu2GbB DbenI5rbYie5/9fx6KOJp7Z/JjmfzUbbIBsfDAgHNfuX+wZ+0f8AtG/DfRBaeEvhivjHQGh2LZp5 srSIHYl0K9D9P7oHrj/Z7x/hhcTwFVwmLlaMpfo1+p/h/wDRTWLw/iC8dho3cKfbTWUGr/cz9UvD /wC2l8dtT1a00/VP2etY0qO4lEck8kVysUOTyclMYHuw/Cv0H0e7bxV4cjOt6aIY9Vsil9p0q7kA cEMuDn1x+Ff5acR4DD5SoVsFN3v31XW6t2P9hOFsZVzzLqlLHwVmmmraNPTZ7po/ml/4Kp/saeBv hjqll8SPC0rWEOtm5e8torNWt7cpGsqvgDgrgEY/uY9MfHH7HH7fXjH9kW2uLK08PWnirRp0WTVl Zmsr8FyA0ygZ4yFyuO31r/QTgidbxZ8GFleMd6nLyerivn3svJLsf5WcXYfD+Bvj5PNMHG1FVHPR bRlJW6Jdm1bq7H9If7HP7bg/aqjWSPRLXS0FstxugkMoYOHx83HIMZBA6Yr7y1W9bT9Nvb9IvONn bNc+Xnbu2jOK/gXjrhmfB/FKyKo/ejLX7/8AgXP9UOFOJqHF/BUOIcN8FWnddOnb5n//0P39+OH/ AAWGvvh94m1fwXbeC9KWa3vG0xLqXVltiPmZd/zHplTn5en5V+C3xi+J8/xS+KmufExZX0zUbnVf 7TtfJn+0Q20vyndG+AWG8ZGe3GTX+qn0fvDWfBlH+2qjv7emra99bryt311P8ffpR+LOE8RMXh8p wsbPC1ZJ6fK3m79tNNz9Pf2ev+Cufj/4UeFtB8C+JfDWl+IRFILVLqEyKygDAYDBK/KBkHP3Sa/o 6+B3xQf4wfDjQPHUumf2VJrNrHcNbLL50Y3xhjg4B4ORyPTgdB/On0jPDOhwnjavENKWleWi/rbz 8z+zfoveK0uOsjp5JUjaph4JS+S/FdvLfU5T9pj44y/AT4c3XjSKwg1CSCeOJYbiQxphmwx4B5Ay enOMcZzX88nxy/4LDeMvif4N1/wnYeBotOXVYZ9GiuYrtjHas4MZmkUhG+XsRyD2qfo8+Fy4vqQ4 hqStGhNf157adD536T3jJQ4JwuJ4RlDmniKbsu97fJLXX8L7H5pfA742eJPgp8Rh8QdHmEt5Kksl 9JeFQZ5JZ45S6vgkZZcY46ke9f2mfsx/GHUfjL8L/DnirU9Ojsby50m3llETF4n3xjIzgZxgdu1f pv0tuHsPHAYTP4aTh7iXlordraL7j4D6DnEdTEYXHcNz1SftL/4tfvu2f//R/u5tfCnhXwreaj4g tYLbS5r2Vp72fCRKzN74z26ZrwHwt+0gnin4z3Pw30i2tL3TbONTPqELFsszlMI3fHBz3wa/Rstw GLzbCVcTK7jShdv02R8viMXhMuxkcLpzVJWS+Sv/AF5ncftD/BXwN8ZPAGsaR4v0uG6a2s3mtLvy Ve4gcDGRkHkcda/iK+PPg7Tvh78Ttb8L6TdveWxvbk5uYQ8ibJdg2semR2HTFf2V9EDP8ZVq43Iq kr0l7yXbX/gv7/Q/zp+nXwvgaGMy7iajBKtNckn3tp99kvkvU9m/Yu/aW+IPwF+LHh2LwvqLto2o XItrvRzCkkLlpIlMrnG75R0wehbg5BH9qPw18V3PjXwZo3iO8t0trm+hzMkf3CQByPz/AErxvpeZ LhaGa4TO4fxai5X8tF+CR+kfQezvE4jhDGZFUX7qjO8f+3vef4t/gflb/wAFhYbi8+DNpZxSzQiS WRxLERuVhbuARnoeRz71/J3p8MrR2MZjWOcWsYEMoCPlUGdw9eK/YPoqf8m7l/jkfzf9MxOPimpr +SP5I//S/av/AII3W0kWqPI0bxzteGOZnIClAW2hQO3Br+jDXLuWw0u/vIMb7WBphu6YXGa/p/6R K/42nV9V+bP51+jq7+DWDv8AyP8AI+TvgF+1b4Z+LHiDX/B+q3Wn6X4h0q4kjitJLlFllCyFANvH UAnkDp7157+29+xX4J/aF8EaxqNloca+M7a0ae1ubOENLcOoDIQMZzlexr5PK6mYeGfGODzBNqN4 Sb7we/3b6eXc+j4ny3KfFTgXF4SKU24yUfKaTS9L/C77XfVH5Wf8E0vhr4i+FPx58QeFdc0y4sL2 0uIZ1gvIHtp5THIQMBhwMPnHt9a/pTuZBHbXDyBlHluG2cleDXvePGa0c74zo5nQek4Qfzdj5b6P WS4rh7w5nlOLVpQnUXyTa/Q/j8+NMrzf8FANJVhLNBdeNBJZqxG+AnVZiWKD1DHP1r+t3wG0n/CF +GQ6mN00aAEFdpyIxzivpfHVv/VHh+N9fZo+S+jnBQ4h4ksv+X3y6H//0/2m/wCC4Orz21xoyJDH JDYLYXrySx52M18ERhxg4wOD/dr83v2c/wBvD43fs72L2Xg7WIb/AE6SPyks9WGbKAF9wQRgEkDL cjB+YjpX+oPhFwvg+MfBehkmP+GTbXWzSS/J/l2P8l/FnjHG8BfSAxnEOX/GlytbXTb/ABul+J/S j/wT6/ar8Y/tNeCL3WfF1nZWeoWNzLDPBbPgIR5bjaCM9HIxk9M98D7g+JOu3nhrwV4g1uwkEVzp umy3cbsPlHlxu/4fdr+HOPeHMPw5x7PIMN8EJqP3u3mf6JcD8S4jiXw2pcR19J1Kbl+F/I/me+Jv /BXP4622v+K/B2l/2DcWek6q+neZJG1tcFAAfMLiJgwO4Ac8846Gvz3+HaL8eP2lNI1Xx3ZW2rp4 hulm1Iy3kk0Su1yZWZVOCCNx/L61/dvh54dYfgDhfF59hX+9q0G15e7zX8notj/OLxN8S6vijxrl nDuLhelSxCg721vNRa0W2r3P7RPg78MvBvgTwb4dtPDGgWmjiLSYWDW64Lboh/iRz6V5N8fdS/aK 0+eFfhJZwvahAZ5DEHkJyR8ufl9M555r/Pqri3mXE9evmsrpzldv1f4H+odHCRyrh3DYPK48qhCK SXoj/9T+uf4Ya1+2BceJLb/hOdNgt9HDBrqSe32STDbhVRVAGCcEk8dfXNfdGteGtH8Y+H5tF8S6 bbahZX9v5dzazx70UsvJX0wf5Cv0XOpYbB42lWy3o07ro0fMU4Sx+VVcLj1fmi01Jbprt+B/G3/w U8+Bvgv4RfF69PhLfaw6jqildOhn+Ub03FWUfwhskE+uOetfm+jOwUvj5Ryvev8AWnwhzOvm/h3l mOxN3Jw3fVJ6W8ktPkf4QeM+S0sg8Ss1yqhblhUe3Tun531+ZWuVMrb3wOdo7YxVd2KKoVgSWA56 V+mxbvY/LSxLvxuL4GzAWo7driCQmN3j3oV3Dg4PHBq5fDYqDtK5/9Xw+Zt5VgGLeV5SsCQyr3A+ tV7xNVu3jmunE0CBY0wwARUG0Ar6j1x3Nf78OnFK5/zVwqS5uW5XeZ7eRVjAYpgqh4U4roNM1jWN EurfU/D2oS6DrFvdLd22rWjstzbkKysuc8qwZgR3/WubF0IYjDTw0/hknF+jTTO3BYqpgsdSxtL4 6clNX2vFpr8Uf0y/8E0P+CiMPjPSNI+GXxX8U2769YM2lreXZEctwFbbFLgnoQUyR05PTp+rP7RP 7P8A4M/aF8AX+l3Nnp93qc9oZdH1VI45hvAzGck4Pb3568V/lZ4r8O43w08SZY/B3UHPni9r9WvK 6/M/2o8JuIct8YfCKnhMVZzdP2c1vytaLtfla+dvM/Jb4A/8EtNe+HfxJvvEXjbQtI1nRJbkz2sc rG6jtssN4wRnDADv1xxX7MTj4ffCzwnlINJ8H2dnYssQiK2kW5ELKOT0wp75wK8TxD8RMx4/xuHp Qm5RSStrrL03vf8AFnseFPhZlPhfldeq6ajUk23LTRLfVaJd32R//9b+un4MfFu0+N/xA1jTJJ7H WNCsL0wQiOXzkYAYbBHYHmvubUNGa10ia30BI7GRYyYYojsTJGMAnp26+lfoPEOXVsox9LL6ujST a835HyGUZjhs1y2eYYZ3Tuk/RW/M/OTxh4f/AG6h4h1OPwrrmlnR/NK2sjX0cTQpzjIwCTjvz1r6 i/Z6tfjVpmkvbfF/UINQ1KWUtHJCAzAe7Dg9O3Y9T268wqZVPKIxwtvbK197/wCR5uVrNYZrU+uX 9jrbVW/zOc/bK+EPgT4hfCDxZN4g0DTr28tdMeWK6kiAliESlw4bqCpA5HI4r8TP+CePxp8e6H8e vEvwu03xfd3Xg7SNREVlpVyFktxukKKCxGcoIwo/3jX6p4eqWc+HebZdjlzQormiuiej/PX7j8d4 5WHyLxcyjM8FZVcSuWb6tK6/LQ/pS13RNP8AEWhXNlrFnDdxz2jOUdc7HKEgqfY1/Pt8YP2rviv8 Dv2hNI+G/gzWpo9A1XU2s5bCUr5RjRxv2gjcMA9AR09a+S8LckhxFjsVlld+6ouX3XPvfE/iOfC1 PA46kvjqKDtpu1/Xzfof/9f+6b4T63deMPAeiaxq5iupr60JlJiAWQZwNw+lfiB/wV2+CHhG0sbX xjoWiw2WqbRcXotAkPntE6vGwHrjeD6jGelf0D4V5xV4b8UKMaLtTdRwav0T/wCAfzr9IDhiHGHh ViIcqdWEY1Y6dVuvK9/yPi79iP4BftJeJwPFXwu8X6hohvZg/lW98IY41ieRcvztIIyBjHf2r9fZ Phr+3lG2mw3PjWKa3tAnnyyXscrXA4BJUL356ev4V+i+MOfcP43iyr7W0pJb2v8AjY+C8B+GeJMp 4Ow8EpRhLW17bLtfpdf0j9HPhpp3iyy8L6fa+NZLe61lIR9seL54mbHOOvH1r8kv+CtfwX8FzfD0 eNbbSdPsdVWGaS7vooBvBgieZSV/2jGBkc8CvybwzzavlviNhMRgpWi6lv8At19D9e8YMmw2c+HG NwuNhflhf0a6r72fz3/sw/F/xl8OvjR4Ll8EeI57GK78QAXVtCixxXisVHmSqe21VUg9m9q/tw+E Otaj4q+H+i6rrYhuJtQtC0ikBlkGSp3DoQcZ59a/cfpWZdQo4vA5rBfvJqz+V/8AJH4Z9D7NKtfh 3G5NU+GlJtfN/wDBP//Q/pu/4KA+Obr9mzTZvGPgG6GgahenI8hvLhaQ4KAe5wRXsP8AwT8+N3jn 41eB4tb8ZXxv7u5thdNMxJwrb2QhiTnKhD/wL6V++VMlpYnwx/1kq61Yvkv87fkz8Vy7OZYbxIq8 MUlaly89vl223/I9f/bT+E/gr4g/BrxdN4g0iG4vtP0O5mtLxEAuYtsRPJ7jOOD6V/Eb4y0rTLHU dS0K3vZphp19Lb3MyqIpAYpSUJIGM8DOK/pH6H+ZYqrgcdl05Xpxd0uz0/zZ/If018pwlDMcBmlO Nqs1yt90ub/JH3R/wTo+LHjrwt8W7LSNP128j0e4t4o3Ak8uILCSBGydCSuBnuAM5xX9mnhu5lut D0y4nLGSazjkZyc7sjk1+afSwweGwvGFLEUY2lUjd+bX9X+Z+0fQ9xeJxXhq6NeV1Tm0vJXdvwsv kfzY/wDBZWG2utc0qFJIo7q/kt5fLuAC0ggE0ryLzxgRr0r+ezUHBLRxjakJIGOBj8K/rL6Oit4a YS/d/kj+HfpVNLxYxiX8sfzZ/9H5gYmeCWJyTEww43FCw+o57Vbt9bSG1EEKNIioEQxtuAA46d+n XNf73Q+E/wCb+tOXNuWTe3EkBdFiXygDtdA4bnup4NZjlhuEbjbJ8zIo2gH0AoSu3/XctVGoK/8A Ww9L2S02bFQyYIKsgcY9SDxSTys5tZZXkWIcho03Iueuf1qYrllYitLmgi/PcwKPmdfKKbvMJxjr 19PxpkGyCRPPLmOYb49pxkEcEH8K0Moq6aP/0vnu38y8nmht4WZoE3uxwFVc4zn0FYcjSLNLvRnC MQJEOU49CK/3vZ/zewuo2JZLw3cUNrBATIW2AImWc5447mrJs5obeG6CAtggtt+YetDkkjaKaepB eXvmhGcIWVQhKIF6cdhUEMbzRSyoAhXDbn/1coPTafWsXK51Rj+7bNKS2u4/PliMUC2axFZBKrl2 cE4A79DXc/D/AFCbVvF/g7Tiyi4j8R2nlqkaosu64jBGMDtnIzzXk5y3HLcRJdIS/wDSWfScJrmz 3BR/6e0//S0f/9P+0X9kLS4tL+FGjwQOrRLbRRkiPaZWEaqzZ9MpiviL/grbqM1r8G9RNt5n2iGP CrGxXzNyBTyPTHNft3DL9p4xKT613/6Uz8T8QIuj4QVIQ6YeP/pKP5AVvJbzTrRzueaG3iad7jDO zqBljn1IzWfMZZXjuXkcyJuBI4UgnPT/AD1r/XilG0Ekf4h4h/vGvMetwWJCS73kQggnG3nkn/Pe mTJGbcAFGVHxIrAHnsR/n0qjmTT2JEmLBYZIZpS+FSSNCyRgcc+naklgcISpOIzzk4DU3FpXGf/U +Xxtkt/LPyuDuDKdp+lJDAivbNLh4ZJvLukaPcNnHzA9iP6V/vQf86sZJj3aTeX8tpYLb93E3lhC UGdp/XvVO7Z5F+0Swz3Ki4SIO/DjcwG4H2HP/AaBuSWjJ8tPlYEaaUDAKrubirVtHbXem/aTPO17 55j8sAeWoUgY6fX2qZK6Nqb/AAK10kUAyi+aVwxIA3A45FTQPBeSmSRX2IgEEKtlFYYBAB9eaxsa J22P/9X5yjvrdrsWl1buyhPtEjYwmM4Az2716T8PbQf8JP4bu7GO2nUeJbVIIp5cpAZJQhZx1IAc 1/ubnLUcrxEu0Jf+ks/wM4WXNxBgYLrVp/8ApSP7bP2NtMOk/CfRrSR0kH2SK4gKfNGFaNCyg4/h bI/Ovjz/AIKvatDH8H9SsYQHZrG7fyQctNItv8o9uWYV/k3w2lW8YVp/y+f4Nn+zXHDdDwfnG/8A y4S+9I/kmS+sFtLKLWLBLue+0tIZLW1kCy2RaMAHcR95MDPrg896/FP9qmdpfEV7HdFrm1tJUtrO Ty/MZWB+bb7A7iSP7xr/AEL8ZX7Pw4xj/ufoz+APo3QVXxAXk/1Pja+ZIfIghKRp5ZYv0564A/Os 5y2BlQUQZLgV/kXiV+8fqf6t0VaNj//W/j6hjKSNNEfvnJHf61XmupoZCzHMOcEngL9a46nQ6C00 huvJO0vGpG7A47d6SeEs7PbqFxgFAOwrGekTeyWgs9tcG2h3RH5mwwPDJjOP5VWdGjVBtIAOOeFF YkSSS0Ei2yHExVsttjQGrAtVg5LxlGPC5+bNBmf/1/48iyxMSzKB2I5xVI3kZnVBGx28swHH4145 0Gr5lrPyCq8DHGMcelZLSeVK0RVlQOWEm3KD8aDSCa1LCT+WSQ4YMeA/3jWfJqBlu0EBaRIziaQn Cg9wfag0JtYi+22D28cIM9uBPFIjHcuD1zVa1mmAaW+kaTI5LcseP51i2+bQD//Q/jot5LeRUuk4 ixlVYYz+BqrcO24ypFsQtuC449z/AJ9a8TnR1z3ISJJlBdmQE/Lt+6R6GqE0Mobc68pkwx5xnt1q yBbeFgsibxvYZwegPao4nnAkWRUDK23eh5JHr+VYyfvCuthY5l+1QXQk8+KOQJNsHzLg84HTINS6 hcxRxSyafIjs8rMyEbmz/tY6VJrTR//R/jGS7kljt4ArJKR5m9wcE+n4c1uRELEnnsnmnoyj75r5 89WCVrlOe5t2T94yqUcARnhn56/hV2OSS1dHjH2iGRQWizhcHoQfb+lBok27IVrmMSKSxjcNuTvy Oagm1a0jYiOSUsB++Lx7FVuenqPeg3StoUYE3SCdZZRMWLgnARlI/SpLpr+0RALF2iupMQzhsxOR jdn0xW0HdWCx/9L+M27E5tfmaFZNw3ljtKL3x79KZZuTKyqmCI8iRj97HvXi/bPcmnfQ1oXnYFeG CjMgPUf/AF60baVY4nhUtI8oK5Y5256cU3FdSeR2uZSRLKSsyEmJyuSuAaquXtJzCrIsTP8AezkL 9aykknZEm/HFFLbiafiIjZ5jccgdQfyqhcSXctrLDZxxOxG1JWkKOgHp2J7c1IH/0/40l0eW9t0k vEceUw3bDkqRzwamiZ4pFSEHyWP3B1r589gcNZzc3thLbyRtFBiPJ+Vie/0xmqJtsnzxCGJ4LKeM 9KDSMU0WYGMUcpcqxQZQE42VU8wyy7mXbHLHs3qcs3qKBOFkX9y2Vkn2ZVnM2WBJ+Uc/oeKNNdEm dsRKkpHmO3RSP8/pWsYrlIsf/9T+OZZo7gzXFtcxNEr+UGSVWYN/u5zjjr0qvcQXrRi5YGdUwJHH AQf3mHpXhRTUrHrSWljotFks7jUI5tLtTbF4ViupTIWlLJ0IyMYyTX6dfs8S6pDpsFxFIpmkLxye bEJI5tkMagE4xnZMMY9Wr9w8C6blxnSkuh+J+N81DhrkXdH9CH/BLHw7q938QtKvrkWNtLbeZHFB ZyB/KU3MUzO+ehKrjjpk1/X7qVxLD4FW8uY4D/xLADImIUWMRncxH0HQV6vj7UVXj+hRW8UvzPuf CGi6HhtGo9pJv8Lfofw2f8FBr77T8f8AxPeRTW9wuls+mwiI7p3jllkuA2D94DgcdK/DD9oPVZE0 TULiZBJaNKIJd3zNcO4KohTpgLuz/vCv63yqLw/hvTT/AOfV/vVz+NYS9t4lTrb2qv8AB2P/1f4c Nc1i7uL2fzWVYzMypD5ex4wDgAnv0qpGFuIS4kZXjIJXGBXfmTbxc2+7/MmmkqUPQ6m3nQ2sQSFT MI9kpZMq5PHT6UlhapFcurq6qMEcHGDzXkVjoirRR1kP2bYg+Uo52+YV4UDj/P0rSWaOwAOzzI5D hWH+NebU6m8HpY37C+tbUSXEWQ8wCzbc5cDoMV0enyvKCpVnt2G+OToVJ7V59Us//9b+R6RXa2kj nlmtWlBjt7iHPngj0qxetMIrO4nC6xdCICf7QWjaTbwu7HJwAOB/9avjJK7R6cWludBbapO+nzzG Oy0q1tYBGY1JAdm67VOSG9/5VUsdbN7b4gbzg8uN23G5QMHBI46Vm9y1JPQ0rG6uCgUJJGIJyRHM 6ysFB65HHOKupb/b98ySeSFcqUlOyMkenpSHfS5ZiuxJbyWtwgbP7tVPGfqfyqWa4FvbhQhdlT94 qNuU+wqZfCXSlrc//9f+NnVSyeH5reymtZdVil3WhnwqyZzhSw6ADgdqzoo9RFosamM6wkYaW0ll CooOMsB6ZzjPpXgz+I5ea8mbenx6xfpeXd9DG62gVElUgFeAuGXpxjg1HLeSWcnmQyf6VEdzLHhy MjIOR3qSinZ6mt1BJLcSzxBJSWdvmSVskhSfx/lWdfQ24uI7icq6yDf5a/dA6DP86Co6MjmngKxN bLJ9pXIkJwEKjG0j8M1Ra0e6SWRL9497jz4V+ctjnHPbirgtRN3dz//Q/i4s7SKCeGVt+I5Ms0bm MOo7Z+vauotr/wCxrc/aYvs0sx32rxjeoyfuge4PXtivMpo59ipPd3F1fIXKT2sC+cI7jBidwO/5 cfWs/TbswtKsFtCz3REUg28Y3DpXfTVguluS37LYee0MciyqQYnXiOH1weh7YryrW5bmd1adpZY4 gSNwJRCff3rtpwVmmYN+8Lo7pNEYfNjJMio8ZXdtDcEkelftj+yBJd2mgz6Z9qjk+xeDv3pdFUlE 8oIFPfljjvx7V/QXgDP2fFqT6x/VH4r45Jy4Oml0kvyZ/9Gn/wAErL+e1+O3hv7TcKkEMyvMI2E8 3mSTrIIwnsImJPpJX9zfhUC68Joy3LKt1FvQyJjao9vwxX9G/SbXLxNQlbofnH0fff8ADbV/af5H 8jv/AAV6XSLX416Dtt7KE29xqcOoRpGYpb+FfKHzHoD8uPy9DX4r67otpYrPcWNvM1vIguLPT/NE 80YJPy+Zxnj19K/qXwNqOXh/gr9Ez+KfGGCXG2NS35v1aOJk0y6imuLmVcm4RSFEuQqgEAbc8Hrk VNpciSQSxNsTEoXkYYg56H/PUV+zH5BDSo2UWZtNsNSGla9cW91c3OyOLaWlkAOQ7AgqcDIwTVrS LmXUVn/tq8tbKOxtGkiuLgFBdMoB2tgcFiT7cVpB6WNW3ax//9L84kuYXsbW7inUW88jwiUNlAU2 7ufT5hVXU7OHSrtYYb1b62mg+1QyLGY9zN1Rc85GOh9K/wBoD/IiE7bFKKGwsI72IwHfeobpIpH3 KZccEk9s54qlDoV9dW1rJaXscdySFmgjBdpj/FgcYX/OK3TTWhXO73NPT7GNUnW6kEEsQbfFIfmy uRjjucVUu7YtFAmltcyGb5ruXHliHH8Kc/hk+9Mlyb3LdrZwWUQ1cm4OpxMYoJPMKKFIIcMO/B6e 9MtdYH2qRCzTqmIlkH7lcnqCMU1a2pLdtz//0/zZnuUgnaK2AkzH+8uIgQkbf3B+vPt+NMaFoVgv 4FV7zgyyRpjytvfHf6+9f7UH+Q6fVHPTI95qEck8ReMSiV5t2NzBgSuB0zXaf2Khu7K7tsxyBxMu 3l0yONo/z1pNJ7lqb6l2Xw1ZSPDePdSJczSs01xMpdTz2/z1FLOIDB5W9h9nAWVsY3Adyfep5Fe4 pyTM2G5tJtQa0eymvtJuFQ/bbZ/LltmH3lyeP55IrL+wxC/vfJeUW9lebSroFnkj7Aj1I9KfIr3O eU38j//U/POx1GFr/ZDpRtPPnRo42xK4KDaMfXA/KsvxItrFqEYM15Jc3szNJbPATDZkDnL9AGxn B7mv9qD/AB6c30K2pzaRE2mLpdjKkgYLezRIWiLEDc0nPr3qpcQ2SXKsrxQpI+Li4C7ioB6gDk/T 2rSEephKTvZENpdWerXE8D6dNapDJ8iXcLRMy4yrqT1BHIrXE3mrLBsMawN5cSOP9d0+4Pb39K0O fn1KaalBprWlrMxkEk7HyiNiEHog5578fSrENhHqL3R0eLbdonnPFtwu5s7SfY4/StYK2oc+p//V /NVbfT01FrbxFHe6fqcMcdi1zZymK2kJwQSFPI4wTnufrWhremXNk8Uksd0bRk3wXRjKWsw/2Sep 6fnX+2rguh/jcmnoS6HJYLGq3qyBSxfeqhHAOPXv7GotGkuodT1KVRE1laEzKlw3OoA8LtQdWG79 DRyaconJIo3OmCa7h1NIZomkJtxGHba7OQcFemcj9a6Z4dRjsisUksZdfLl2vtcqeME04x5TJy01 IpdO0+wMSW4EVzehYp2MnzXDDuw6dsD6Csu8uYsG0sdOubfV7aR4vPe4U21+DwAIxnByOue/Smlb cltLc//W/NOI30221uN0TEBp7dex7810kVvaJNI8ylglqIoYGckyn19OPr6V/twf4uzaLlpBdXEi hLaIlYDDFEsfmPkg8j1bnOa54KNOtdTmcXDyrKUlG7bK247TwOcfT0pptPQwuti9DJC00IvAba1a FVtpkidozJgfKe/fk+1VPNvprgWNokFoYN5Q7hEGxk5dj37DPtW4NJ6MpWJuDcWNvflrvUp5JPtV yMNDCgA2nPc9R+Va05u7ZriwWISWs0fnOHRXUqoyxB6r0P4etC0COyP/1/zfupFuPsPlItvbRlZJ BAu0hQMAD6981tWgY21wsW0OyBorqHi4A5G3Pp6iv9xVO7tY/wAVH28iexWyt2XMyvdeXzBK4IfJ 5+X68fjWd/Y2o/aLi4VkTrsiU/K3p/nNWTDc1rO0Esu28jLTtDgTtwkfQAkD0/pVS3tGi1C6nnul luJ1eyV4k2pFGVKBVXjr39aDRtRRS0uPUbeVJJrlbeWE+RAsYUyum8kbMg7Tjv71ZvfNub+PzRLJ bQS74ZJFSO4DN94sw6+2Tx+dBlKVz//Q+Ebr7dp0sf2J/JkjjDSMyBiVcdMHgEg1if2RLFeS3Fst /fwOUcNJCI0VjyVABPTPrX+5B/iU5vVGtckXcrWRtGScS5hhkyHfjgL379qzltre1+1sjNDPbuFM HlHG7+L8qqKTdmc89yR2dr3T449Qs4ZLrDMkzEhcEgK/1x/jxzWys9ja6rAyJCJbht0kUJ2vheuP pz64FbHK3c9FtHsliga1ikjZpNzmR/MkkJPHP6fgK/YT/gnB4ksofiVpdnbyytJI1vIIpFKszjbH IQD2VgMnoSxr878V6LrcBY+K3Ub/AHH6Z4A4pYbxay3m+1Jr70z/0f74dOWKTTISzZSW3SSRv95A T/Ov5J/+CvlhbQfGHTr24hupljv7ttlvEXYRsIcbu3y8k+tf0x9GWfs/FOmv8a/Bn8s/TBhzeGk3 2lE/He5YQWL3/wBjf7E0/wBm3JGWZsnhio579R6U2P7G9r9ntnLzxfvGW4RopJXOMBe3QjrX+ptP Y/yKxLvJGnbppd3ZfZESZTBZ+ZdO7DJkxvbywRwFOR+ArlpPKn0wXMShZkZWt43Xck6HqxPboOPe rsZ9CrDFu2S7GO5wHiXgL7itf7AqSeeJVjEOM/P94H27961mtLkP47H/0ux/ZK1IL8RvD62sQh00 37teuHEruwEezaT6ktkD0r+3L4NMG+HvhnL+YZNLjlBzwqsqgL+G2v7q+l9G2Y4R+SP4y+hZU5uB 8RT7Sl+bf6n4tf8ABa54v+EHt2ltyyQWscsXlAicyK5IYc9M7Tz6V/MFeSXUqRT3ETCF4gzr95ic c5FfsX0WE/8AiGkX09pK34H8p/SwnfxZxUF0hH8kZSuIcuitGW5Q9xWhp0qQrPMx3SSxsHjc7Y2A GSzfrxX9N8q7H8s+0cdug211y9jxFZXdxFbElniEzGE4ztAU9uvHvWgVuNR0u6ur63byXuRFDFLB iJ2jwTyfvdM/hVOjT507a6/p/kZ/WKvI1zaH/9P5/RI4rNrqG3tLfEm5hHAkDBgAM4AHPFc7cW73 pBZpETdgkZBP41/vRVhFK6R/zsUaknVjzPqdDbXMKxy2MsdtdRLCIYJbi2WaSAA8FGblfoD3rSmv baeKCG5tIfLhiIRUQBpDggbvoR0PSq9hTvzKKv6E1cRWlCVNyfLdu19DJitJU8syP80qDucBR0/z 7V0NlbWTW8t4HZ47GZEm2sMtk/MV+gHvUtLkb/rYvL5uGNpeqP6f/wDgkb4g/tLQpUWDy4GD24RI /Kj27wUKjuOCM+xr9s/GOpXWk+GNV1GyUNcWdg9xEp7lRn/Gv8ifHCHL4lYpf3l+p/u54bVVU8Nc BNbez/JH/9T+wT4Aftf6F4+8R6x4R8T3sGlavY6k9haRXkqo8xDFRt7kHDHHYCvvJXVwGRgykZVl OVYeoNfa8R5BXyLGwpTjaE0mv6/rc+a4czvDZ7gI4zDyur2ZzHjeFZ/CXiOJxuVtFuMjO3OIyf6V +aH7KHwv8Cat478Ta9e+HrV9US7W5+0vF++kwdke9upwMgZ9B7V7HC+NxGCyPMZ4aTjJxSuvmeTn WXUMfxRgPrMbqHNJeqtqfdvxj1jUfBXgbVNU8P8A7ieztWkijjXgbQCB64xnj2r+abxr/wAFVfj5 Y+Jdc0SwubO5tLbXrnRLZ4oybnfbkYLpjjqoyMdc9K/U/A7w7wXHlLFLEpOdPa/Zq5+LeOnihjPD vNcHRpN+zrLp0alb7rP8D9qv2Ev2hfGXxt8IwX/ixo7mcWcTvcRp5YZnA6DA5Unacjsa9s/aq+B3 gv4qfDvWxq+jWcuq21q09rqRQC4jZRuwT6Hbg/hXxed0HwT4irDZfLSlUS7XXU/ScfQpcYeGDq41 XdWjz97NJtP5W6W6n//V/Vf9j/45fEf4cftC6p8NdI1Wez8PxaybdNPOJbYRRMFPB7sCBj3Nf09Q 2ll4l0EQatbw31te24M8ckXyHcoyQPxr+kvG7K6OW5phMxw+k60FN+tl/wAOfzx9H/NamdcDVaGJ 19jUlTXW6V/+GPws/bp+O/xE/Zb8V2k/w41S907Sbq+FobSMKY0DDgglSeMEDH94ZHev0p/Yv+LH if4t/DTTPEPiO+GoXE1lFNNM332dwG/MA8+9RxFw7hJeG2E4oS/fyspPv0/LoYeHvE+Lr+I+ccI1 P4FBtw8k2na3q2Y37b/wu8FeKPhrPrGpeH7a41iyvF8q+ii8ufafvbmHUAEnHtW/+x74C8C6P8MN LvNG8OaTZ3U4UyTxWwM+NobJb16D6rXx0c6zKfAMsB7WXs4zta/TTT08j77AZBlNDj6vmMaMVVlT Tbtre6V/XQ9V+N/hL4ieJPC15Z/DjW4tE1lovLguJHCFMkA7cgjpn9K+DNK+B/7bH2y3e6+IEdza xTjet3fxMcL3VfLJxj3FY8O47KMPgJU8elz9Lq485wGcV87jXwjfsVvZ2+9dT//W/uy+G9j4lsPD 9nb+Kr0XuqRxCO5kB4d1GGI9ia/MP/gq38I/BWqfCS+8aHQbJNb022luJbuztgt3KVXKy8fxKFHP XFfuPhdmmIy3xGwdbBu0ZVOX5P8ApH89/SHyPCZ54UZhTxEbypQ54+Uk/wDJtH8isFzeT2MSXcgl fzHCAx7XTk539yeO9fpT/wAE1ba4tvjXp7uyJb6rcRIsYO52ELYYsvYAsOT3Nf6ceJ6t4fY/T/l2 z/Lf6PHPU8XMob6VP0Z/Znpy7LG2QAfJAiADgcDAr+U3/gsi9xH8VLVEtiYkvxESMFrcMRKSc84J /p7V/nr9GzTxRpryl+Z/od9M668LHb/n5H8mfPP/AATwRJPjX4fkZ7jbNcRxvtH7mL5idxPXpGoH 1Nf2ZaKCNKsBncBaRYOMcADtX1v0s4tcXYe/8v6I2+iG+bwtX+KX5s//1/1S/wCCyWmafe+PgtzZ gx2eoC78xATJCAhLlPUktFkew9q+Uf8Agnva28XxZ8P300UlrcXd4LG3JQ7UVTG3msMYGSq898Gv 9TeBakl9HzlfSk7fcj/JPF4eM/pUzcF/zEO/quY/s80DcNH04OxkZbONTIf+Wh29a/m8/wCCsusa x4W+LnhptMnitv7QuZJ7e6WUxywPbmPIXHTO8EGv478D8PTxXiJ9WrK8ZRnc/tj6TGOr5VwJSx+F dqkK1Oz87SP1t/YE8W+IPFnwZ0e41rVLjUvIsIFQ3TmSQb0RgR7YJH4V0X7buiJN8FvE2v2MpsNe 0ewlmsNQgGy5QrEzL845yCOP/wBdeBmtGngPFR4WgrQVdKy7OSv+bPs80xFbHeEdTG1Xep9Uc7+a hdfij8cP+CYnx8+IfjT4jz6T4g8UatrdoJkjuYJrl3azkJ6Hd2I7j09a/pF1O3ivdIvLe5hSSK4s 5I5IpFEiYKMOhr3vGzK8LkXF9KGXLlXLGWnfR3PnvA/NMRxN4YQrZq+dy54Pm2au1Zr037n/0P6w f2eNCtfD/wC0D4ssrCztLa3Uq3mRWywvJluc4HXp78V+kGtaXFq+nXNk8jwieIp5qHDpkcEfSv07 izEVcTmeHrVpNtwjufAcJ4ejg+HJ4fDxUYJyskrI/OjxD+wbda34h1TWY/ifrlompXjXAt0nctFk /dLBckAetfS/wU+A9/8ACJHtX8Xar4hgONovZnlCcknAPrn9O/FdOZ8Q08dliwSp2drX9PIx4fyG rlePqYqVVSUm9Ldz034uaZpmr/DzxNYavHBLp8unN5i3UQljyvKkgjsQDn2r+Dz9oWyh0v42/ELR 4Lq3ubbS/E15bTeRCIo4j5pMYQjrlcn0H6V/WX0NKtf61mmGlfkUItX2vzI/gb6dmDw1PHZPmVNL 2kueL72SbTf9dzxNEkmnna1IjjhTeySOOMY6H37CrL3kzWb2x2uWbzJAedzYxnPWv7+aurH+d3O+ dn//0fna3hdInV3JaV8ncBiMcYAP4VakhZUCMobbkqxGcZ64Nf8AQZBdT/mpl8TE8qVo0CyoNwJV M4dfXP5VGLKcKHYAkctjmrtrcklW1iYFo5GZgcnccY+lO/1bqrK0gLYIGBt96Uo3A+6P+Cd6A/tJ aRGGJWWSNrFJWAhZ+m0DucDJ9MV/bxo0KRaTp8IwUjsYlXoVxtHSv81PpkNri3CR/uf5H+wf0HuX /iFNbuqsv/SpH//S/XP/AILJ+KtU0Lx/Y2FjuC+VKYT9pltxGu+MyFAh5yGGc9MV8n/8E8vF2rT/ ABy0COS7ufJKhWtGuHdJgCPmDMSSQTz16iv9MOC+G8sq+Av9qVKKdX2bfN10X+Z/lnV4zzqX0oqv D8cRL6vGvbk6L3pf1uf2S6UI/wCz7LyjmP7NGUPqNgH9K/mQ/wCCt+jafP8AGHT9Te2FsLd0Rrm2 jEU0k5ctGZD3BUHP0HtX8weAFSrT8RLRejjNfof1h9J6jSqcC4ec1dqvTa+SbP2s/YYRP+FK+HZF lkkaTSrdnB+4p8pF+uflz+Ncx/wUBvrrRfhDfa3YyvBdWUcjxuDtjdlUsoc9gSMV8xjKEK3izPDz 1jKu0/Rux97xHi6mC8I/r9F2nTw8Jp+cUmvxR4j/AME5/wBrfWfi5or+C9e0q0RtKWO2sNRtXw0r LujIcZPQIo/Lk19iftS/sy+Af2j/AIfX+heLreSG+sIjqGl6pbIpuLaSMbgrZ6qcYIzXo8QLEeHP iVSxOXzcXGcZ6aOz3679V2dux899RwXi14Myw+YQT9tRdr2dpxTs9nbVWdt033P/06Px0+F8nws+ KPi7wok9vdW+m63cRbo3AliVH2R5UEgbgAcA+vvXi+6K2cs2djHBx27V/vRwtmcs44fwmZVFaVSE ZP1a1P8Am8zXBLLMzxOAi7qnOUfudjZhlt42hlZ/KitmFytw7YQsrAgEHsRkY77hX9hP/BLr7XJ8 JLmWR1nt5IopYZgcA5VAeP8AgJ/Kv5q+loo/6jRlbXnX5o/uf6DnP/rlikvh9n/mfXv7Vdst18G/ E0JGWa2kRSG2lSYZP8BVH9k+CGD4NeGo4mlbZbxq2/opESggfiDX+fFFt8F1H/08X5I/0swyS4sq Wf8Ay7/U9X8feBfA/jvSZdJ8bWdjc6fIu1xdzrb8cnG4/Q/SvA9N/ZM/Zh0edbq20fSI7hW8xHk1 uJ8dxwTijKsxzjDYOWGwEW4S8r29DlzHB5RVx8cVjKijUj52ur6XP//U/vG0e68JaLYw6bp+taHF bWkYRI11WAiNVGOgbAH6V8EftZeJPDGueP8A4Z6PpWr6bqmpQ+I7N7m2sr2O5dhlgNwViRjrn6e1 fsXCmU5n/bccTKjJJKTk2mtLPyPzPibPMqWCjhvbxlOUoxik03e68+x+hmhRiPRdJXZ5bDTYQyA7 tp8sZGa/mn/4LOm3h8e6fbNPDaWz6aHeSTLR5aR0Cso6Aso57A19t4BU1PxWoU5q6cpb+qPzD6Ud WVLwmxFSErPTX/t1n4v/AA3+I3i74QeI9M8QeF9Ra01bTJRd2vkbBb5cK5UgqcqcD5Tnqa/Vrw1/ wWe+O2neH9O0DUbHSNS1LyzbS6lqNksEQCJtX7kTE7sV/eviL4PZPxxVo4qpCMZ0/l+Vv8mf55eF Xj1nfAOCxWUTnKpSnfl1u0/n+Hb8vzd/aL+OPij9ofxOfG3jiO2i1M2+wCFnntY40bKJGpUY6sSc Z9fWvsb/AIJKyTQfG2+tY4mFksttd2oU5BLNtkVR2ySDj/aNdPGuR4fKPCLG5XSV40aTS+X/AA5P ghnmKzHx+wOZTdnXrNyXreVunU//1f75XTfZ4cklrcbzjB5TB4r+RD/gqxalfjhfQpZzCGDy2MsM xUsXZIozjPcuMD2r+t/oqUYVvE72dRXXLJ6+SbX42P41+mvWq4fw5pVqTs/aJaf3tH+Fz8pDeNaz QxSK8gAFushBleJSc9ewzzWfJavPcFYozICS27Gc4r/VKguVOJ/kDipN6vcpwozSXS3D87swKi7c YAzn8QfzqKAF47mAXBiQzDzZChZl29h3/wD11ucTn0JYG6NzsAxyPve9TgoX+RlBJw2eDVJ63Jju j//W/Zn/AIItrDbapcW8jrNJPP5bwxuW+zMolfBB9Nyg49B1r+kbVJ5LTTrqeDiaKBni3DOCB1/D rX9S/SY08V6/qvzZ/PX0bXfwRy1f9O//AG0/ml+K37Qnjv4jfti6H4L1/V3ufC/hzxJ9ktoPKHlC SJ3MaEnuXC/dxy3sK/pK8Kgf8IzojCMQ7tMjbYP4eMivP8V8ooZNw/k+Hw6tGVPm+bSL8Es8r5/P OsdiJXkq7j919j8J/wDgpR8HtX+NP7QHhTwjolul/dXWhyIba4UC2SRJ1eNiTxnLEj6Cv0M/ZX/Y 48D/AAP8AaZpPirwZ4T1bX4rKN7zUrnTorybeFG/LHKkfKOMY44716+ece4zLvCvLOFsLNxlPV23 taN/8u+vldfB8A+FuW4vxU4i45xkFL97KMU+6nPp8k+2nqj1u91X9l/Tdfj0u5tPh7ZeIo7lUS1X Sobe7RwflYAKOh6EelfQti9m9pE2nNbtaeWBbm1wbcKBgBcemMYr8UziObOhSrZjdwkrxbd9D+ks kllPJUpZY1eMmpJaWZ//1/6Fv+CzEh/4Qvw6Wt2OwSIJI1/eyFY1OfTA8wflX4f/ALIn7T3jn9mr x3p95b+Jb/TfC19cxTatpyTSXVtNtYxqPKGVUlXJYnAwgzyBX+m3gzklPiPwTq5NWV1U50vXS34n +T3i7xJW4P8ApFvP6Ts6Thfp7r3/AA19T+xP4A/tAfDn9ofwTY614Z1iz1e6ktBHq+mXCKJVblWB j5BBAzz+VfCn7YX/AATZh+OGqzeIPhnH4X8NahdN9pu4JENoZZUYFSBjaC2ME9to4r+UOHM2x3hd xxWo4qLUYycWnpeN9H8/8+uh/dPGmS4TxS4GoYvL5XlKMZwa7tar+ux+Q3xN8E/ttf8ABPvWE1Kz 8QeXotyiizvNO1YyaeeCRGygADGMY7kCvlb4o/t1/Hr4taNNo3ijxpqep6LqtoY7pi6JsYfwADqu 7Pev7m4C4Z4W46rUeN6UYuaavbe611fRa/ns9T/NDxL8RONuDMLi/DfMOdQ1S5r6LZ2XV2+S03R8 YX11ayyGdY0ilIC4VdinAxVcMkhj2qemW461/UcNvkfyUpdD/9D5/Z/Mfy40wSeuMVYdNseH+Ygc p1r/AKED/mlqS2Il0trmJ/Kfy3YqwYL5hjwwPT8K/s9/4Je2wtf2f9PC73ikhWRZXX+L5Qy5+o4z X8lfS/04Cox/v/qj+/foIJvjLMH0VOP6nvH7abGP9nzx7ICQRpEqbuMKGCL/AF496/Bn/gkTayH9 ovxRdXCosIleOSUqWSVjKCAD04wxI96/mHwyVvCDP210f5H9QeIsHPx94fUdLL9Wf1JXQBhu1xlW hlXGM5yrCvz7/ZBtHi+I3xpVSpgtfFmpx5IG8sLkqP5fzr8QyB2yrMU/5f8AM/pDNY3zrA26OX6H /9H+4f4/MyfBv4jMv3l8KXpXJIwfss+P6V/Cv4tW3vfGPiaa80SUXFzrys8U03nJaY8sbsYyNnzM eRX+gP0PqcW805u36I/zj+m9VqQzrI4w2uv/AEqR/XB/wTAhlg+A1mk5aTMCNHIedi7h8gPoCTX0 B+2dLMn7PHxGSJ/K83QJ4fMOAMuqoo/Etj8a/A+Io38Z6ltvrK/NH9S1Zyj4E3e/1N/+kM/hq16z EHiLxS0St/pPiK4u7iAcrbGRh8uM/d4GM+tZ6RlQyg7SDjb0r/X7L0o4Kkov7MfyP8Gsa5SxtST3 cn+bLRitwqpAGEmAXkZ8qx74GOKjcqqyb1VwVwWYZI+ldpzzXU//0uo/ZW+AWp/tE/FDSvBWj3sV pZxuJNVuriNmlUkrtjjUA54bJbtxx6f2U/s1/s+6d+z54I07Q4LmG8nt7FVd44yqQjGQvIzkBm57 nNf6OfS74vqQlhuFKLau+Z/en+Oi+TP82/oO8DUoZRjONKyvz+7HTsnG3yfM7+aVupk+Nf2zvgr4 E8Wr4L8Tam0GuPefYREsJkIYhSMnbtH317/yIH01o+r2Gu6baatpcpmsb2IT28hXaWBGeRX8W51k eZZdl9HH4u/s6vwv8T+9uH87yvNJ18NgLc1J8srdGuh+Nv8AwWQkni+FOmrbQJPcG1ufs0Ehyszt EqDPoBmv5Z7r+0rmM3V/ZfZ57/522rmFGPVV55APHU9K/wBC/osRv4exv/z8l+Z/lP8ATH93xPqK K/5dw/T/ACP6Hv8AgiwbgQX1ve/ZftNpcPBKIMRtkIWU7egH7wHj+9X9AviGQRaDqzZIUadLnkA4 2/4Zr+R/pDU1HxYr27x/Nn+gn0fpqfgjlz/6dNfgf//T6D9pnR5Yvjb4vBe3kim1O4vRI2JZZG80 x7geqgBR+deE3VqLZUxOuXG3YMEk+1f7h8HWXC+W6f8ALqH/AKQf8+fG8LcW5jG9/wB/P/0sSzhZ L22muLmSJDMFjkBK7iQRgn35H41/cV+xAwb9nH4fyeYHefRbWV0XO2HfCHAGfrX80fTBhfhnAz6c z/Q/tz6C1VRzzMqD35E/z/yPEf8AgqLZi4/ZwvnkkuY40vo8/ZeJTt8x2II54C5x9a/jSt7xWEMp ikKSRiX99yz7iWyfr1/Gu76H8Y/6mYtP+dfqfA/Tmp1H4j4Vx29l+kSxb2802oafHGsZt5tTgM0N y5ETJ5ilk59QOnvX9sv/AAT2Kn9nrwmVkWRV0e1SMKciMYLYz34K1P0uEnwbh3H+c+o+glGUOJsx U/8An3H8j//U/sr/AG4/EGoeGPgL4s1XTr2Syu4bf/RpYztbf7HqCOMEc88V/M/+yX+3NP8AA34g 23iTxPaajrttfanG0817ckIq7nVkiAJIwCWwRjOPSv7a8AuBqfGnBGbYZL958Kfe6va/Tqfwx9If xWq+GviTleIld0XFSl5K7Tduuyv5bXeh+z+q/wDBYL9nPVtAubK2h1GPVryHyfsh3vhjjKk+XhT7 sRX8zf7RXiKP4gfEjVPGFjm1sL+6nktbAtH51qn2qV13hSfvKykc9ByAeB+3/R98Ks44BzvF4nM4 tRkmldW18t76X/A/mn6TnjTkHihk2CoZQ1zwkm0mpaW11Vra2313Of8AhBHFH8TvBss84jQ63AkU JwGupC3yrnrt4OfqK/uu+B3lD4a+HVi2giFjKiAhI2O0lV9q/PvpgtungPV/qfu/0F4wjlGZtb3j +UT8s/8Ags3cz6d8GbW4hMrb7K42xR9cqseMe5w3PtX8ppnjkltrtYmWVokJkb5iABnB+nOa/TPo o/8AJu3/AI5fmz8D+mfp4nL/AAR/JH//1f3L/wCCLbCawmNwsEpW/mWCeF/NLqokdHJ7cSBfwFfv /wCMZNnhXXT3OlygDbnPy88V/Tv0ibvxSrf9u/mz+dPo6Nf8QawVv5H+R/KR8HdR1O0/bdlXz5tO hvtYlkaVZG/eZDAA8/xMoyD61/Wfo6hNM0xVcuBYQjeerDy1o8c6cITyiUOtBflEw+j9Xq1snzNV 3drETX4s/Oq7sLaz/bYsWjthG8+lpM8kS7GIaSXCH2yufxr9FtRGdOvyW8vbayuW/u4BNfl3Ec5V Flzk9fZx/Q/Y8qo06VHGRprRyl9+p/Hx4pgbUv8Agocs1w3myL4wE0Cu2xmaK5kYkjsAI2OO/Ff1 5+E42j8L6DE7bmj0mGNmIA5CYJr9j8cZp8N5DDtSX5M/n/6PFJrNeIatt68vwsf/1v2p/wCC2l2Z LnSkXCSaebR3jeESRXccd0ZNr54IHJwfSv59oUS4ibyZhGzqfKweTn0Ff6zfRsv/AMQ4wy9T/Gf6 T65fFjGu32o/mz+qT/gjvpcVn8Mbu6JmkN+8lz5txGIpf+eRDD28pa/UT9oVtvwd8dj5sNoFyG29 ceTJz+Ffw54tvn8YK7/6fR/9KP8AR7wppey8EsLS/wCoeX4wufwv/Eu3jsvif4otGmlnkfU1S4m2 j7PCFiQR4I77SuR1yDXuP7G1pLqH7Q/ha3t7OS5it7wL9o3BEDMskhAXr0hHsMj1r/RrHVox8Npa /wDMP/7Yz/LPh7CTreLdCNv+Yta/9xUf2/eFozD4b0KLB3x6NbIwY8krEAc/iDXwZ+1n+3xoH7Ku ox2Wu+HRqvmHMpErRlFyADnOOciv8teG8gqcU8Wyyeh8U5yt97P9gOM+KsNwRwis+xv8OlGKf3H/ 1/6NrD/gtf8AB/Up44YPDXmTSIdsKPcSyFlGWXeI9o+hNZOrf8FvvhfpVheXEvgPU0aOQwQPl9m8 5C5VQx98+1f2HD6Oue1Kvs5t3XTl/wCD/W5/HWK+lPwqst+s07crX83/AAN7/wCR+Ff7Yv7RNt+0 r8RZ/G0GmRWVtNBElnJFcyEz4SPdvRkQggqwxjGF7kmvkSOC6ihnKRrIU7nkoM4zX+g3AOSf6u8I 4PJXvSio+l7u272vY/yj8ReIP9aeMcfn/wDz+qOXr0T1s9UrlKW3DRGSTcGByPmwo654/KkDW6lA Spwv8fRiO1faRjazPiCRZVYgMucHGPSnu/JZeQp5Cj7oq2ieZXsf/9DxBniCozBow33SwwHx1xUP 2pVZvKDtE3yb2HDEdfYdq/39nsf80kFaWo0zQMQpiG7djce1Wb7dBal8JJGmGcD5mVe/FYVY2sn3 R003zN97P8jqPhvqGuaf448M6z4TijOqw3avGrWzyyXChlfYhUblYsq4PHTmv7E/2B/jh8SfHPw/ 0rSfHfg+50trWMRWt28LW/mptTYcMoORyOeoHXrj+MvpZ5fltfKKWLnpXjt+K+d9vuP9FvoLZpmc K2Oy53eHb79bXt5W3+b+f6NanJLFp9xPbw+dPHEZI4gpJcgZxgV/N9/wUk/aw8a6mdS+Ftx4b1jw pYPO0n9st5ttDdRpwwUY9A/GT1HSv5F8Gcmwud8ZUKOM+GD5rd7f5fnY/sjx5z/GcP8AAeJrYJPm muW66J/57a9Ln//R/oA/4I6RyXmhXWoSlij6ld3EE8gLyzoxhRMnt/qm6+nvX7neM9cHhvw3qmtF QyabaNdMpHUKpOP0r928YY04eIdelTWiaR+H+DUqs/DHCVazvJwb+9H4f/ED/gsLY/D/AMRPoEng q21W4WZ0d4/nkiUHClgB3HIyBXKy/wDBbe0t8B/AVokkdysE7NDMssAf7pOMgCv1TJ/o+18zyunj XUaU1f5P1X9I/FM6+krRyjMq2DdOL9nJx69H5Pp+Z5V8Zv8AgsBJ8R/Bmv8Ag2y8Nw6ZDrdhPoxu LbzmvZ/MTD7Bs24I+XO5evXrXgH/AATJA1z4+a1rDwtHdXOsrIwkbcrYnhkAxzjCySd+eK/QsH4c LgLw9zaLleU4vV+nkfna8Tv+Ij+KmT1oJJU3ay23v19Wf1sTsy6c7KNri0O3nGD5Z/l/Sv5HP2yL 2fUv24PDDrPIwsPGK2cqAeVDGJbqzXgjg5y/15r8N8AYKXEWNv8A8+p/kz9/+kVUlDJ8r5XviIL8 Uf/S/uV+A0KW/wAL/DEaM7hbBSZHUoWyqnpXwv8AtuaJYeN/HHgrwTq2nQ6nZ6tfrFOJSQIlyiEc c8h/0r9YyqboccTrx3jUqP7rn53nlJYjhOnhp7ThBP0dj7Q+D3wU8KfCnwtZWPhSxi092so2aK2j WODJQHGAPrXwh+0N/wAFELv4KfEW38C2+gwapMb5beZG+djuxwuEJ4z6/wCFduR5fX474nr060ve lzS9EvX1OPO8zw3AeRYeVJe5HlgvWX/BR+j3wn8fH4j+DNH8UGxNgdTtEuvJ5AXegboeQeSMe1fn L/wVV1SFPg/eaZOu2G/spoCxIMjFotoEfcH58fjWXBOF9h4iYXBp/BW5fubRz+IuKcvD3G4lr4qN /v1P5UvhPFdXnxW8CLpdvYpcya1ZSGSR/wB2FVo2cBQMk7R0Hf1r+6n9n+Ga3+E/hKGaMxvFpMQw V2s2Y0Yn8zX9GfSunH6tltN77/gz+avofUJxjmtZfC7L7nr+Z//T/oV/4LJ6i3/CBw2At0lc3MAQ Spv8vdcRxMw/77wvvXr/APwSRsmT4M6ddMskLHSIoZLeRTG6MuVJIPIzX9PxSj4B36ut/wC3H854 S8vHatb7NFfij7h/a4u2tfgz4tMcjo8mlzwsqZ3OpVVP86/hf8eyQzeL/FU8ayi2l8RTy+Wc5wSr bvoSxGPVTX7J9D6NqGYSX9aI/nT6bEuatlkH2/8Akj6m/YGik1H4/wCnOd0lrZSeXHHjEc/z2oZC o7gSt789a/t68N4XQNLby/JBs422MeIxtzge1fFfS5iv9acEu0P8j9M+hm3Lw8xPb2mn4n8uP/BZ XUYW8e6XEXYQwSLa+YCd0RaPgKeoB3lfoa/CpoW+zIs24q3yCTGC2O2a/qv6Oyt4aYJf1sj+IPpV Sa8Wscn2X5tH/9T5n8sP5cUZWIk7WlkOFUetWPsltbsjxrGNh2sq9iO+P89K/wB70raH/Nw3dkwj Ri2MbG4I45qG7ZFjSKK1MaQqXeVVLPITjJJ9Bxx70JWBtvQowsNspdSRLgCR15GPr0q3DLu/dlki iRecj5Tgd6dkDlpyss2mnLNcztmG6VrcqsDrugYYyTg9/wDDvVLZHHEFXOY2Kxx8nywP8/pStrcq EktGf//V+ZRC8xcGZ4mddpKMVz7E1cSzC2nkpLiMMIlBb5nY+g61/vgf838Wm0jvvAHwy8VeOfEd n4Z8OafHPqEx3tJtkMqbWQNGoVSu4hxwTkYr7H1f/gnd+03Doh1q38JtPpsuWgtraCaabZjIZ8A4 /rX5zxj4h5NwZi8PhszTvV13Ssr20vu73009e36jwX4Y51xzgcXj8qelBbWbu7J622Vmu71201+D vFnhHV/B2qXWheI9JvdJ1i1laGaC6tpI4pCnDPGzKAQTnjr+tYRdtkENpby3YYeVNGI8kPk4Ye33 RX2eCxmHx9COKwsuanJJprqml/XlsfE4vB4jAzlg8VFxqRumn0abX9eRajM4UxPHuDD5h1Ar0/4U 6QZvHvgFkhV5l8aae6RIP9IkAuELMD0CgZ/KuHO5KOVYp/8ATuf/AKSz2+EYN5/gFFa+1p/+lo// 1v7Y/wBmKFrf4YaKhjKJ9njdMsDgOrOP0YV+a3/BXzVNMsvhXqUOqXd1ABZNJatbDarsWQCNj/tb lX/gVft3ClOdXxfjGC19u/zZ+MeIFWlR8Jakqvw+wj+SP5L7+SI3V0Y4vIWeQuIAP9SGJO38M4rN MdwY9gXKA4BUfzr/AF7o6JJ9j/DfES/eO3mRRMwDp5JLR/KSB8xJq4LERop83AkwZvMOfLJ6ge1b WRzbCI20MY9y4PlAoflbHGabJL5UQjckMz4y3IalL4WNNp3P/9f5VT5JtjKJVb0YjB/CtHULlFso ktITC6uBL5jZGO+Pr71/vVJa2R/znrVXILdLoyxGYSLHJGGC4ypHYgVLfJLKq2h8yKBX33GO4x8h x9e/v7VIE0N+tjFeWOnsvmvbBbiV0Vn2n+43UZ6cf0pNEinKyW7b1T5mV1QNycnj6d6mXws3pysU F/drKDIGVWK7sZ3+4qKJnMbwsPJXzN6TxjMhGB1H4GsS+Z3uf//Q+fIfskluFTzGPk7XklGFkwc4 B/Ku6+CtuZviV4PvYLNbvPiW3024tQ27y0kdS0m3/ZAz7Yr/AHJz52ybFP8AuS/9JZ/gXwbd8T5f H/p9T/8ASkf3OfsyBD8KvDxhjCQpZII25DSZBJOPTpX5gf8ABXW8gtfAEpe+mtC1vM8/ljaQ0sgg jwfQlga/yl4Hpyq+MMUlr7V/mf7J+KFRYfwim27RVKP5I/ls1zT4dPsL67ku7dblLZwZZJdj7thV So9ScCvxO/abuLs6vFbFdnl3kjSXD4VJlxzj67iB9K/v3xxqez8NsYv7tvwZ/Cn0YKXNx1zf1ufH 99A14wsxbRSyxxmVpBJ8+OyDnHqaht7G9E32RyqwKoLMW+Zh12/hX+S2JXvux/qhTVlY/9H+SMWl vBE8uEDKmzJ/iArjdUdNjJJAXifkfL71zNJ7nQJb3bQeVHtCwyoNoHzECuotLrS7Z45b+Ob7Mfld ohmYHtgfXGfauaS0N+aK6l/WHtHWFrEsI2jG0uBlz9K5O6QnYVRnEYJlXnIPsKxsZOV9DFgUSXJK QzbkbdkA7ASe4qu/277WYidy+axYn5BGMn+XSgk//9L+O0fZI4QXnV5c429duOu4VCyOIyiR7cvu X5Rvb2+leOdAWlq8q3B/1bQqHG/5d/OCB71PIpMeyUgpxuHY0G0XdWK0sTpMXkjVbbyQsfB80nuf SrNjAkMd3EsUE8V1GCxdMunIOR78YoKJPIQPuEmVC/OgHPHahrFbhdxTEY6Hox/CpcE3cD//0/45 R9njSS2jYTSq28r/AHPTFJ5nylX+VypwhGeK8Xkidc97EkEwSOKIw70d8ksdvHt6VTvlL3G1EzbF TjnLg/WqMXKzaKsMPyZZirA8fwtwe9ElsoJmRWEjAK6jlJMe3rWU9zIl+zMPJgUOJ5VaQDb8kYXG dzdATn+dRy2bW5RRErb8l3jx8p5Jz361B1w+I//U/jHkfyXWJlIDfdYjgfj2rSAuFgSS1g8985BA 3IPUmvnz1Kb6FC+hjuViuTAEMZxIyofm5/StGycSxRxROiorlmz98DHT6UHRTRW1K38y4t54MB4c knrz6r71XhsWW38y6MciGQ7T95mGe4/z0oOiMFuy/cQxW0KTJKSgAwSMYPdcfnWl9oEthCoYyKhM kag5MJPUge+KqzSuVJe6f//V/jV+yQ3asLm1lMaZSRbkYWbj7w9R0/KlxDa7IyPmVf3Zx8uB2rw4 uz+R9AaVvbs4a6QBG2gN6uB2x+NV5t3mlrTMcuA0nbb2/Ck5PYCOCcz6iNNt8z3skZlVZCEEuAS3 JOOMGia3W4jV7gRxBX3TMxwW/wBn9KgymrSBtStpEt7BZlBjjJSAv8zDPUCsuzkk065MSR/JIxlk uGYkEsTxjNBKV3Y//9b+OX7VKo8uNmUk7tp4TNLbbWlWOVWDk8kcEH1/Svnz3uVWsR32mMbkymVm klXYgONvHTJ60hkSC2W3kUB9uNq8gEUEwfQyprRJYJFkyI5flf0YehqSJLWzVUwxjRPkVeQmOMig 0t0L4iWCyEUUZlEjGTygPnUHnp+tZ8IUO0SABSPn3/eY+lbQ+FGMlZ2R/9f+NzSbfTrW8P2e3jtZ Cv7yNFKxyYzlh2zVqR0vLq+KSGK2hjCqp+QzMcAhR3Hv7GvGVr3R7DRcsITaQCeCRnkz9nis92xZ vMYKdx9fT61+rv7N+mzWvhHTmSdC4v8AesG7OxDBCiE55IATH/Aa/f8A6P8ASU+LFPsj8F8dqnJk dOHdn9MH/BJTTY/7Z1Dz/Il1CXVFDzRQ4WGPh2O7OcEAZA7iv6hPiM8i/D7xBHp9uZJ10XFrAQFC oseWOCcD5Qfzri8ZaiqeKEqb2Tj+R+peGy9n4W4a2/JL9T+FH9r6XTtV+OXxL1QeSlnb6glnYxXT YmLQRkugHUZ2xgeuG59fxQ/amBbw7d3N1p0UEdzq8LwC1zGI9u7AznkdCT/sV/YeYTeG8LJ1WruO Hv22h+B/GXD1GOI8SPZR0Trfhzf5H//Q/iE1yGG6uPOit4hKimMn1OTz9a5mFXSYwI2X+9IfQ+ld uO1ryfmxU17sV6HYaLaq6F7ub5VbhAwTcB1zWnB5017JF5D/AGcEebdEYCL2Kjv2H415dZaHSdMd J3QI0Ery227PGEy3+0uTzXPTtLHexWY+0COKddy3OUXtnaOnSvNqrcadj0fS9IRS9yVkktZ1zbb1 G0EdRnuf5V01qvkwl7ZifJk3SwsPmBPT8OK86qW56aH/0f5L4LhjJbwSQtLNM+1UiTzApxkZPbp+ dWriJTKrvtidAQoxjNfGykk0jvi7o5+Vbu/ujBcfvrFMSu6tgqy9Bt6dec1vwwJZW4NmiRtsK7UA 3PnOTj8e1ZPcexaspo4bKYgPcX0aNMkbNsDAAkgsfwx9at3t5HNpkMtsrxNLbiYxkAMjntx3pFrS DKlv9pWPbKrbZBt3yr8y+5rprCeL+z1sruJWjVmc3MKiK5OQBtLenH86zm7aFUfjsf/S/jBWOG0n lsplBQKBavuJdQOnHTp/KnpPajUrcGJ5Jooi32xciKIH5SpP49DXz7+Jo5VbdFrUbk2qSLDdS+Tc DZKiHaj4OfmqlYQ+ZHK1sWAl5kAXJz60FDF0N7cXEhvJUtyQxtmXjd3IXt0rMupTIGklkjWBMQqj /KzAcdKDSHL8zodIhiu38hVgV2hPlG4kEUbHafl3Hj6ZNYcVlcWaLNNcQvMWbz41ykYIJ+VT3HvW lNdTM//T/ji0ubTdUhVX08LYmP544AXMPPzEc5z1qa+tdJgut0LXLQB82KzcvGAMfN+defS6HI5J aGPNatN5sUIIRmLsVX8TUi2sNhLZizuluheZjlj8vEtuygFgy/3fRu+K7qeiIk7so+JmkgaEWz+c JYt04ZCsaY7e+OOa4jVGkttNMUz+Yt42Qip8vy8gn6ZrupnLKSUjkNE1GWG6lS08oeZF5EqMo/eY dWByehyo5GPTpX7Ofsf3lmltYQyXssmnnwxcyakEXzbhnE4MUQYdMsYySexr9v8AA6qo8Y0ot2uv /bkfk3jNTdXg+rZar/Jn/9Tif2BPEf2X47+HLhJYrec3EslvbQ2RsxcRRfZ4jCrAYJAkd8nJwK/u 6+Heqw6l4Q07UbfDQvp0Xyt0RmjUlPwJr+mvpQ0Es7wtZLoflf0cKsp8BVKLeim/wR/Lr/wWE0tL Hx1pF9dWVs73+tS2t1MYAQqzgMrEnoTvK47kDrxX4S6zJZQQXcWn3VvJeQzKlrA0vnxhOd2XHBAw MfWv6N8CGnwBhbf1ofx/4yRtxvjdNpP82cJcWOsyQeYLOSZ7wrHEGlW3MeSDu2nkjHGMdxUs+gxW 1oILiaKSeRR5sMLFWhb69cjFfuJ+LxT52jCt4LMLMrvE7wyCW3aRSzKoyDuccD8euParuq3Ok3dh BY29oqfbTi3vCGMt2ygblRDwcE9B6CrgtTQ//9X8ytLsodJjvftMt5Yi0jaK5tr+LdiXI5jQj5Sc gce/pVi11E26rcSStcSBDBFEYw0jq/y/d/En2x7V/tAf5B0+pd+06U0EaXptzJcTrHE0r7JVY9EX B7+nPSsjUJraxY/YC80qyhHt4GKSDPcZ471rBWVy2+UpRusFzJakSC4Mf2h4pMk4Puf5VpzXEV3B FpTy3ECzOHc2kTedHjo2R/8AqqzKTu9CSTTLh7O2e1e81Ca0Zy0ckLQZUEKDs+nBJ45FbCzmGXTo prPTUFl5jSiaFWkZ3AwWP8WMYGemKdmDk3oz/9b86tMmVIpN0UZLyMUKpgliTwR3rB0291SXxBqc KQXMNtb4s/JDKRLvVhu2DOBk9/0r/ag/yCjK2gs+nXXhyzt7hw+ssbv7MY4mCSO/DHepPYHHHHFb mqFooo3EzYkgWQeU21osgEqcdCOlBpF3Rm3MjXGlmOK8eCWYrk7j5mAQWwc8ZAI/GtBJr6ayuTbi RoNqxT7UyzgYwfzpa8wpWtqNk+1rpO3TljglIOUlUptAHLAd6NF826hF0yRPqCqEZrhSIDgg7seo xkZpmNuh/9f80tWluxrV1fNfysYpEeFoIxHCjjGe2ex+mBW5p+nnUraa8lf90pw0rMC+8+o61/tQ f48yXKzIn0/UrHz47EJJDc7fOR23RAg9QSOCOcY96fc2dvCI47hFMTxYY9XLetawfQwlGzuiKTdJ 5cryTMEjWGMtncqL8qhT6AVsRwQTReYJRE8A88sfvMB2Huas5nFp6GddiDUDZh9OS4ntZjMt0T8o x0BX19xW1YnUBeGa3sjBBeRfZJBHCViwhBwrdsHOeT9787jJ3syT/9D889UuUuN0zyWsslv/AKGk LL++3LkZBHp/SqjW95PpWmm+W/ux5h8iOAlobY7txBBOAPX8K/24P8ZxLq13XdvBbyoyPAGkBOWV 8kYOOnQnHuKsadZy3d81rGSbyOFp1hQffWMZbH5dKAJ725mMUVl5wihRml+WP51kOAGz7YrYtLjd ZwLdTi5PkGJ2hURO7AHDH3z1oMLu1jm725toBJPI58+3UusR5lOOOBVJY8lJZ2kSRlW4XKlW+YBh n8DmgR//0fztsGm+2uqJHI0kJLebgfIOWK57jGRiptUieSye6tIpf9Ey85zuYj1Uegr/AG6ik3Zn +LMviGre3sGhRX5fyre5x5GoofnDNwFPpwM4IBwas2NvM9jLO0cF8kmDA8DE3W8feBHQ9+Pr6VrZ djlMvUr5pvLs1kMTj+IqNkZOB09eKvXDW6QLDbxT+e9sGvTc7cs3JJjI52459eT9aZpryMSyutPi aOJYys4jzLKyliu4EEA9atlreP7Vl2MbRmGE7vOkbI5DGgqHwo//0vzqttKtrn7MPtlyELFGCReY qjtjp+ZrVCQaNdJbyIzqiAS3UTb1fc3BYZ7Ag8en1r/cFaM/xRlvoPlvrCC7ma30+ESoxa3vZ4A7 upBG5D7+47Vn2F7etcyxT3rMkjZhnlRVCZ6ghRg9etbkmhbW19apLffaY7q3Mxjco+4xljxuB6Z7 VVkiuTdR2tmkSTylpUefPlqOWZifbr7YoNJfCjM0uDUnEeqTzW08EV2bZ5CwVgV5JCc59PrWtP8A 6Tc7badGjH+sYgjafagzP//T/PeeW4gu1mMhkh2CKVd2UOOQT71u3r6lbWy3lpeKzL+8uQuB5KN9 0j1xx06V/uQf4kJXC1v/ADUN9czp9ugiJikuAWeQ8D5fcnB7dKyblLib7Kbe7SKSRHkuJrnaB5mc /dPUc0GFQx41bzZkvJ4bibzN8tzEvlx88gD0/wD113TaJa2z2uqE26iVFitHe5DSSfLhsDPUkHP1 quZ3ucp33h/Y9nJdXk0WfOEcESDfKFXgnaOmMD86/UT/AIJry6XH8dLXzGWS+8uF7ZZ5tqxwBwzY QnAG/qfevivEpSlwPmCjv7Nn3XglJR8Wsqc9vafjZn//1P71/DpEmi2JVVG62jyM7lPr+Br+X/8A 4K2W15b+P5nWG0Jh1XZEZSMTRuq78H+8G2/gDX9G/R2bp+K1JR/m/wDbj+ZPpcRv4Z1Xbr+jPxEv 9ThaX7Croqyws8jk/uwRgBenJOTXGX7oFhAHmCKdHDRqfM4YYGfqBX+rFPY/x8xDdzTmn+z3Kx26 I0fl/OjneZN6YOcfU1kv56SxxxxRiLZtMcfAh2jAAFXsT5FvLXcJe28pEgbyJQmAyt6EUyWKW3gX ziP33ybyeTgf4VtJe6zNP31c/9W9+ywLCy8c+HxcSNEJNXVbUxyZeRmUDbj/AGiAPqK/uB+Az7vh v4YDHMkemxRZzngRrwB7YNf3f9L+DWNwb8kfxZ9CeUZcE4tLpOR+Sf8AwWX0lrv4dpfQzpAbfTmj d7pP3Rw6yMoPbdtKe281/K+J0VLW2QjyrhVIjyS0YxwM9xz+lfrv0VZqXhsodqkvx2/I/lf6WNNw 8WsTO+8I/gkV5InnMsL208W1/wBxIw/dkDIOD09KzJ4ZAyhZMYBV8cDHTFf1AlezP5ScrTcSOFRZ x+fgGLcCyyKCq4PUemDiuuN7Nq86MFhMYGWuDIEi9NoUd+nP51ol7yZldcjR/9bwO5lsYoZVupRF +9AYbS4YZIxgfhSJLbR7ike5HjwgdSAoI7Cv98px5pH/ADnRnyyTRXiMBt54/KQlpRKJxkTIVDDa D6HPP0FMiSWN7e5nlgmV5OUjBDIFOCGHTP0pW0HJ6MddSJdXdx5UrNGsu2NQNu0EcAfnV9NNubWN rq5gItEK+Y0qlU5PHHeplTtDUnDVGsXF+aP6Zf8AgjvfTXWmBJnUzQhrd44f9Qq5ycA8jGf/AB41 +6/j63Fx4M8QxjexGjzlfL4JxGQf0Nf5I+PdF0/FHFQt9v8AVn+6Hg9iI1/CDLa8Xo6Ka/8AAT// 1/oX4o/Ge/8Ahb+0V4w1W0Bmn0PxDFPbEXctqt4WEZYfLlDksx5I7V/SZ+w3+2XZ/HrwtbaVdaTJ ZavpqpBNvnLZBHBBOdwwOxzX90+Mfh5HEeHeXcVYZJOFODl/4Df8V26n8JfRp8THieJ8z4Jx0nzq tUcL66J2t5Wf4fM/QbxUnm+HNbTdsL6VOuT2zGa+Df2TruD/AIT7xpAzKjQyKvlrxGwcyCP+uK/l nIY/8ImYeUV+p/YGYT5eJsFHyn+SPqj9oFPM+F3iVFQM4teDjLAEMpwPWv4WPi9a3Ok/GLx9HZTy SLa+JriaO1ij8l4JH27xuPG5igORxk+1f1Z9ECUVi8fCW1v0P4e+mvTqvE5VUpbp/wDt5/S//wAE nNR+3eAtJbfII59NjMgnbMscsLOsqn1ywOfqK/W74pIZvA+vwgKfM0yUyMTt2osbM5HvgV+E+LEb eJ+IX/Txfmf1vwf7/hVg0/8AoG/9tZ//0PuL4Pf6L+3J4xtoGuM2/jK5W2RBvV02x4V27YyvH1r+ vHwqzf8ACP6dG5zLHYosmDlQdvY/jX9VfSASUMofeiv0P5Z+jC5f6qZjzbLES/I/nl/4LG2K2Gsa HeXN1cLZ3GuwmSCJQ6bPKdenUZbZ0/u1+hP/AATMMZ+CeluGVf8AQ4nhQPuMiSDdGxHuM10Z4m/A zByfSS/M8vw7SXj5n8I9r/l/mfUP7VcAf4UajL5rRtHdIAAAdwIbd19l/Wsr9kuOKL4b2Ainmlym 1/MXYBtPGB+J/SvxajpwdU/6+L9D+g8NFy4wqPtS/U1/2lfjPdfBHwLqfjGGyjvo9MtJLuSKZcow jUnGc8Zx1r8Wbv8A4Laz24mubbwxpnkW8vkSqhLSM2cEKiqSSPfA4r9O8KvCqt4g4CriaX/Lt2f5 n4h4x+M9DwzzSGBqvWpHmSs/NdOmh//R/cOf/gtZ4meUW+meBdGjjkVHW8nLgYI5OxUYn8s18s/t J/8ABUDxh8cfB2p+D7jwzpVozrLbTw5eGOSORNhkZyo4C5ZV5JIHrX+inCX0e1kufUMxrS1pyvrb 9P8AI/y34++k7W4q4WxOU0IJRqx5dE/1/wAz8fLjUduo31w6CRZ7lrtMKHAZuWGDx1z+dfod/wAE 3tct5/jxpUMllcQyGZRp7yvuiVY2gMwAHQMzr+C1/TXibBvgPGx/6dM/nz6PlVx8VMrn3qpfgz+z 7SHlk02yeZVWVrSNpApyM7a/lo/4LI29pD8Q7ya+cvO95vtGJwX/ANQjBMdexx7Gv87vo2t/8RTp Jdpfmj/Q76Zy5vCly7VY/wDpLPkT/gn9cXdj8aPClpGJY7O5tje3bRrtmjIkVEUntuDswH+x7V/a ZoMiyaNpsiEspsIypbqRtr7L6W2nFuH/AMP+RX0P1zeFt1/NL85I/9L9af8AgsdbW8XjC31K5uJr ULqqscJuiLMIyiMO65iP1318UfsHaxNefGHwndwTzfZEaZJtNd8RMytH5ThSOuWl+ufav9RuA2pf R9t2pP8AJH+T2LhKl9Kequ+If/tx/aP4acNoOlkMX26fFkkYOdgP9a/nD/4LC6fe3Pj3w7rMFqk8 ekkzyfu22Q7pIwwc9MsV9+BX8g+BtRQ8SIS8po/sn6UNJ1fDpRX/AD9g/uuz9Ov+Cad0l58DNJlQ GBUs4lW2YkyqAkfLfnXv/wC2CHb4FeNAq7gNLnkYFC24LC3y/jk143Eit4tyX/UTD/0pH2s1/wAa am/+oKf/AKbZ/PB/wSyv7K0+MupRiN1fULiG9ki2kBTmVCN/cZZa/qzfMmnn5fLL2pG3OduYz/jX 1X0gotcX0P8Ar3D8kfIfRzaXhbTS6TqX/wDAmf/T/rj+CcqP+0J4thG5bgBUbzG/1mwybj/L9K+7 /F1/PpnhrV7+2bZNaadJPG+3dtKrwf1r9H4j1zDDL+5E+H4fS/sGo/OVz+Zb4xf8FQ/jf4R+I/i3 wvoWsXdvbaNqktugmZfKaJfuckZ3E57kdK8hk/4KyftPXq3s2ma0oihsxJHGmoxiWOQYzv3x7SCA RjC845r+2+H/AKP+TYvJcLj8Ty+/CMnfzXU/zyzL6UWcUsyxeAw8Z3hOUVa/R9LL/hjivFn/AAU7 /aW8R6de6Zr3inULGx1GyHliKJTNPuXEiAAAYxnDZHBNfmv4r1u48W61quv3ji5u9SuWvrmdohFL KSer8nc3csSckmv6B8LfDzKeCfbTy1xftNHy2t3++6P5a8YvEjOePMbQnmqkvZ3sp3vrfucf5p2s iDbGTubI5PBAqukiMpGT5qN90L29a/ZT8Vckm2j/1PngybwQQTnggZzV4TGSPDLtwNo3cV/0HpWV j/mmcktxgh8kA53sRncD92hZUdTiQl8lWx0FMHsV02guSzKV6YHXtVmPycqGdv3inL4JCmgZ92/s AWkll8ffBWqQiK6ij1E2lx5rCP7PKVMibB1J2K2fr+f9tvh8A6LpjBiwksIpPpuUHH4V/mr9Miy4 twv+H9Ef7A/Qfi/+IV1pf9PJf+lSR//V/Yr/AILI6W8vxB0mUput5ba5tN0KKzDzPJwSTyNpVs/W vg7/AIJ/2Fwvxj0iZ4My2ckMVq0fysBJMqt9eF6+1f6kcBYhL6PLpv8A59yX/kp/ktiMBy/SxxGK S/5iL/8Ak8j+0nRAw0nTwy7SLKL5c5x8or+aX/gsBmP4qeHo187y572GSQA4jyPOXkdzjOM1/JHg Gl/xESMf7sj+zPpOpx4Cpf8AX+n+TP2P/YLmkl+C2kpMHWSKKOMrIfnwsce3jp/eqv8A8FCLOG7/ AGdfGMcxVQthMwJ4Y/J2I59/wrw8WlDxgv8A9RC/9KPr+LE5+CtdP/oEv90L/ofkF/wR9vYm8W6m 0sblJ5YZ7VhJgpJvPG3vwf1r+lHWgTo2qAZz9hmxjrwrV6/jnTUPECLX8tM8bwIqut4PYZvpGovu uf/W9g/bcnhs/j34/tUtjvu9YneeRl+VBiMp+R3fnXxebWOaIsrBtpwcc4Ir/c/w7l/xhuW/9eo/ kf8AOTxb7vEmYp/8/p/mWtJsppJJTK6NbRQMn2d03eaSDg8/3cfnX9gv/BKi/iuvgZp+WkFxLZru RVxGoXBzn/gRH5V+B/SzTfAi8pr80f2x9Bip/wAZriab60/8z7H/AGrIZH+DviKSGUxyQp5gOcKQ FbcD9QMUv7LuR8H/AAyOmLdSRtx1QEfpiv8APai/+MKl/wBfP0R/pbhbrjGqv+nS/N3Pk3/gpz4g 17QPhLEfDur32lXtw4LPZzNbmRdxUqWBzznj3H5/y3r+0H8bElmMnj7xDMYJzDJY200iXkIXhVyG ySAQT6+tf1/9HDhHJs84RqYnMKSlJTfTs3/kf5/fSa484k4e8UHl+W13Cj7ONldrVqL/ADZ//9f0 XRPHX7TWsJNfwy/EXU9PurkFdSjjuEgVeoyqndjHXHBr6J/ZJ8QeN5P2gPD58ZatqslwmqQPFDqK zCRgXCBWEmCNpJ4r/WHiXJeEcHkmPhlqj7eNOWml9mf5G8EZ7xvjuKsqnnc5vDSrQ1adt1189j+x PSxjT7Ij7jWkbp9CoI/nX8xf/BaqCK88dWJnlSGNoFtQFiLszMZGjDdsbwufZq/jv6PzS8WKF+kn +Z/aH0rtfCSuo94/dys/DaPTdRuWgt7Gyurq8IG2KztnnbOQBwBwM4GTXr8PwZ+JH2RdWvvAXiu0 skgEn22fR5BayN6oRn5R6nFf6eZvxLlmTKNPMKqg5bJn+SmTcHZ3nlSeJy6k5wju0tDzbXJJ7C5a OZGU2jm2lheMo8Tr95WU8g81+lv/AASqczfH24k2tbQ2gtzHCvyxS7k35PpgrXyXiRUjV8M8zq03 eLptp907H6d9H2Lp+OGVUKqs1Vaa80np96P/0P760G+FFcZzEqsOhbKiv5P/APgpX4Z1vxt+0DqN tofhzX9a+wMrv/YthJdyW5gkDKrbRyWIBAPav6s+jLmWHyfxDnmOKdqcIzv800fyV9L/ACbGZ/wT h8nwKvVnVjb1T9G/wPzg174C/EDQ9Mutb1LwV4xtLKICRjfeHrqwaJTydzPGFwozkg444r59uryS xkukRWZoJWtnHUblOCAfr3r/AE74Z4lyziWjPEZZU5lF2e1122b36ejP8mOO+D844Lx8MuziCjOU VJNXs180tV19RRdQywI86rHPswWVcbzTImEm8JEVRvvtjhj/AJFfUnwZq6ZDpsqyRX8r2yYwkyqG wcHHH1/nWQlqVOX7NlTjrg8UAm+ZI//R/Y7/AIIrWlyde1C6R3uIzqMjO74IXMUYcgdudwx2r+lD WZYodK1KWbOxLKUkqNx+6cED64r+qPpLNPxYr28vzZ/Ov0a7rwPy5v8Ak/Q/j8mknuv+Cid/bTpc NYWPjeSe3igyYyUm81XftkZbJ/Cv68PCA/4pjQSfMG/SIXxJ98blz07da9Dx5jGOUZGo/wDPiP5H yv0XXUngM/lV/wCgqdvwPzm+I8V3cftueGNwf7LaaSJigGAd06rnp3VD+Ir9MbsMbC5ADM5tZFAI wxPlsB/SvyTiiV8uyldofpE/XeA6coyztvZ16n4SmfyTftO+ItUT9tKPTI9RnRYfF0FpceWTkfvI 3wB2wD29c1/Uv8GZJZfhl4PeYN5r6TGzu/LykqpLE+5Jr9T8YsvwmD4KyKvQilKUVe3XRn419HHN 8wzTPeI6GLk3CnWajfp5I//S/ob/AOC0paH4d6C6bppbuU2sKowUxqyxBsntkZI7/Ka/nr+H/wAA Pir8T7KIeBvDN/4kjhuzZTXCQzSbyQCcYQghdwXJIr/Uf6PebYTJ/C6GPxkkqcZyu2f5GfSJyLG5 94z4zL8BFupKMdEuyv8AL/M+7Pg7P+1j+wfFa+J7/wAC69o+hm8T7cl7bzTpcoMbjGAhQKAD1zjj OBzX60fs1/8ABVPTvi34m0vQvGGjW+hWepSLaw38kbRo7FlVm4XgruBI57+5H554m8FZRx/9Y4ry SS54p3t19f6R++eC/H2b8G1MNwPxDG0VZRbvpsv66H6Y/FT4TfDj4/8AgmTQfFNhZeINHv4fO0+8 AWcKSp29QR36Hp7Yr+Pr9tn9i3xn+zd461NdJ8LXg+H95q88um3kCvLaW8BCMuMrhTlmGwMQMrjH IXyfot8bzyXiWrwjmU7U6ukU+kl5eunldni/TY8OaOZ5Fh+O8shepSXvtdYu2v3fkkfnxe2bsWZI 96xTCNg3yPGTnt1zxT408o8NkBefav8ASGGkLeR/lej/0/DbVQWmSVVXagdZwcpz2OPr+tRCNzIf Myf61/0IH/NFLoTW7+XMpUsiiaNNyHIUNIqkt7c1/Z3/AMEzrmOf4FWUcCFbfyBOm0HylJmc4B78 EflX8m/TAT/1Dov+/wD5H+gP0C5x/wBb8xg+tOP5s9y/bUjV/wBnX4hFo96w6LPcEj7+UjyoA75I /QV+IH/BJGWG1+OXiaytfJu7Se4jdfPBEkDN5hb8RgD8q/l7wzTn4QZ8vJ/kf1Px9yR8e8ib35f1 Z/TDqOVsdRKkh0s5mXbychGPFfBn7HNyk/jH41IAnmp4z1GOZ8fOGWfJBP8AwJSR71+I5Gr5RmFu kV+p/QubTUOIMDF9eb/20//U/uG/aARn+DXxECDLx+Fr2Uc4GFtZ81/C546h1K58Qa1DFDO06eIP +JxfRnyVv1ldXdou6gKfYcdTX9+/RDmoPM2+36H+eH01Kbq5zkkFG/vR/wDSpH9ev/BNpY4fgRps FuGNsLKB45GbezZYnk+uCPrivXv22UY/s5/EJlUsY9LLtxn5d8QP8xX4Jnrv4yz/AOwlfmj+ncwp 8vgZOPbB/wDth/Dpq188+t67iARM2tzpKpO53WNyiE/98g1nt++cJGjFyeVUElq/2CwOmGpr+6vy R/gviVfET/xP8yDzXDEAEqpxwfSmvJuUmRsKTgAcEfWutO7aMJRTVj//1f0G/wCCO1tC3xr1AyCH 7Q92s9rcxgyTRxog8xD6ZKKfwNf1w3JIS4JxkRP97p901/aH0tpzfiTCL6Qjb7l+Z/Hv0LqFKHgf TnB3bqVL9PtP8v8Agn8k37XkNyf20IYB9qmhbxdvaUljbvGzWyoAvTOVb8MV/Uz8KoEt/h/4ajjQ RqbIMFBzjhR/SvnPF90HwTkHsF9jX1sz2vo7xxqz3iaOMf8AzEO3pc/IP/gsuZj8N9HYNJGqAmIx HLOVEZCt2wxGD67q/mFZ47K0ge7WXesWww7jIQwHzAHvzn9K/qv6LTUvD6CW6qSP4g+mOnT8T6s5 LeEPyR/RL/wRYthfWWo6yUaRrm4di3lhTAiQ7Ilc+oEA+ua/evxo/leE/EDhVaRdLlMSsMgvj5cj 64r+SfpDa+LVdP8AmX5s/v36PXu+BWXyX/Ppv8D/1v0Tm/4J7/Fz9p34k+LfE/hRrTQ7K7YvHfS3 MrQN+8+ZSuwqCeccj7oPNeOftI/8E8/jF+zboUXiHW7e11nTIwwuLpZVm/u4CKE3blAc9cEEfh/r Bwj4x5BDF5dwlL4+SEHK60fKlt2v57a2ex/jLx34G8S4TBZjxxNP2TqTnZxeqcn16O3lvpe2p8Ha VHc6hfaLBfFrawubtLiOCSILKmw+aqsvUZKKCOuDX9vX7FVt9n/Z48CgIiqdMg2bMnCCEKoP0xj8 K+P+l+7cK4KH99/ofsv0F48/EeZVenIl+f8AmeL/APBSu0vtY+Cun+H9OeVbvVdcito2ij8wAOJl bI7cfzFfjn4D/wCCPfxt1vwra6quveGI7Wa2W4tI9Vsmnu3QqCql/L3ZGAOnSvy3wP8AE7B+H3B8 oYhrmqz2fzXdeZ+j+P8A4P43xO499vQT5KNO1473sn2flY+BfjX8APGfwF8aSeF/HWnWFvqVlqtu mnXcWJLK9Rn3K6R4B6I/rjg5r+rf/gnbp9zZfs4+FDeiFZ30+1jCWz77cBIFUlD6EqTX3H0juI8J xH4bYPMMK178k7LpsfLfRL4YxXC3iHm2V4hP3FyptWulf8Vsz//X/r8/4KIyMn7PPiYIm5/3RjLf 6sHePve2OPxFfxW3dhfW9zPFdRojwzs8QQ8CNnYxtjqMiv8AS36HLh/q5j6fV1Iv8z/J/wCnYp/6 6YKctlSaXbo/zuQSSSRPhf3bEfvCny7+MDNVop5FlSIcKp6HoR6V/as4Rik1ufwFRn7+56z8I7W7 uPiZ4Dnt7O3u4IfFMMcsbNslR8oVIbGMDPIz/EK/uf8AgQLgfCvwm13DHb3M9gs00URDKrFVB5/C v4I+mFKLoZfFPVP/ADP9UvoJKaynM5va6/KJ+Wn/AAWD3Xvw+0KwldTF5peNXG+L/V5cMvocfnX8 rVhBFtmS0dLiEyOtuynzEdcnH4f41+i/RTf/ABr1x/vv82fhn00kl4jQn/cX4KJ//9D9yP8Agilb X3kav5sFtHHb3LMTA+U2tbWxRdvqBnpX9AXjEhPDGtlsFBpsoZeRkYxwexr+oPpDpf8AEVK6/wAP 5s/m36OUn/xBXAyf8j/I/lP+FGi6gv7cOq3E8TyWN1r7TacrRlotwCMBz0wVk9q/rJ0sg6bpmMcW MIO3oD5a0eONanUWT+ze1FL8jTwGw88PluZ8ytevJr8T89IjNN+2lEJj8selQRvzliGlkZQfrz07 V+hGsFRpmo7mCj7M4yelflXEKa/s+P8A07ifruTycqWNv/PI/kq1jSRL+3fHdlH3jxPMp2W5LxSt JKoBbuCWOD23V/WH4TH/ABTGgsSGMmjwSSOvR2MYLH9a/XPGypCeQZIovamvyZ+IeAFGpRzHPVNW vWk/xR//0f3I/wCCxcMVzqloby1aZJdPWzCZ2RiXzXaLd7YxyfpX87Wo2rWl0safZ1uiQqw2jMYY 22ggIWAyORiv9YfozS5vD6jBPb/I/wAb/pWKNPxNxMrauX6r/gn9WH/BHeeS++FN7OeUS1xEHz5v zMGLY7ZLH86/Sf8AaTuZbb4NeOTC+x30G5iyF3nDROp4/HP4V/E3i7T9n4xYiP8A09X/AKUf6JeD 9V1/BHBztvh3/wCkH4IfCr/gldqfxnfUvG974ufSodTYvHE9rlZGAXDDK42nI6knr7VhWH7Ffi39 kX48eGL67vv7Y0fVdThhtrlDHHFDvV42IVVXn5v84yf6CwvjFHM/bcIx+D2XItP7vTX/AIB/N0PA qOSY3C8ZVL+1jXU5a9ebqrbX+Z/TR4Vm8/w1odwNv77RreXIOVOYwTj86/m1/wCCyEE9145010gu JTEkTGO2t2uUlAMm9uOp+6MD+lfz94M1IYTxVpVK7tGM5Xfb3j+gPpG4armPg9iaGHTcpRjZLr7r /U//0u5/Zw+CWsfGvxkvhjTk1nSiRkTW+nMsyAuiFmDptB+bhTzjJr9dbv8A4Ip65b+GX1q0+I8m q6mbX7dHpt9p6IhbG7BwxyQM9sE1/qd4ieMeB4QzehhMJNTUt7a69fzR/kD4W+AGYcacL4jHZhTc JJu17ptJafjf9T8Xfjx8F9T+DPjJvBGrXDT39uJCsswUCcoVDEEAAFd4BGOPWvCtMeeOW4je5ht0 ZfvXCNKjdAVwAeuOO3vX9GcL5nTznIcPmlJWjVSl+j/E/kfizKZ5DxBicnqO7oycb+m34EV8oWU2 6EupUNvA+TnsDWWlqC+WICryvr/nrX0sdkfMT0ZP9m3MWVtoVTkD+I8UunupmlAcZjH72NuMjPWm Qf/T8Lu3BhaIkyAuDApBxbDncF+pNUbeZ40+zom1FYnMnI564r/oAsf80MHZloQLgMq7m3ZA65qO IXhnVobe4uXuHEC20CNKSSwXAUZ/vLn6isK6XLdm2H1nyn7b/wDBPn9gRviFqEPjzXdU1r7NHNDd ppYgEVhEYXbC46k5wCSex/D+leyg8M/BfwNF50FpYabo9oRNNGVjaQoD1J4z2z05r/Lv6Q/GWI4s 4unlOEm5Uqb5Ul6tJW/H1P8AaT6MPh7hOA/D6lmmLgo4itHnnL5JvW3Tb0R5f8Mf2zPgz8VPF1x4 I8Oa9A+vQSNClo0q75GQ7WQds+3XmuJ/bK/ZG8N/tCeCdVmt4Vs/E8Vg6wTQxKzTAqcFTjhufxyQ fWvyTKqWb+H3E2FxuITjJNS06xb1XT7u9j9czqWS+JfCeLwGGkpxalHW11JK6fW3b0uj/9T+mL/g mb8Pbv4SXXiLwBq2Y7rSLya1gVx5Zm2yMGcDvyxxiv09+NnmH4Z+K44fOMj6TKi+Su5v9XJnIr9k 8QsdHNOMY5jFq1Tll971PyLw9wU8q4G/svXmpKUfPRWR/Er8VfDfib/hbPjP7N4Y1++huNUZbSU6 ZKkgVEVdqsRgjIxwewr9A/2T/wDgmZd/HXQbLxH4w17V9Be/UtdW3kxBiu5vLRUJwNoUdRn5ucHg f2zm/iLgOE+A8Pi6E1KqoRXLvra2y89D+BMl8Lcw4343xeX16bjT55vmem7b6/8ABO3/AGp/+CWR +BvgtvGXhnxBLrem6IjSMb+JFeMv8pDBBlhkjqeMeleb/wDBJG0kh+M3i6xu42l1C01WOOWTO2GP cjrge6mNh+IrwaPHb478KMzxs1acE0z3sv8ADz/iHHjTlWWp3hKV1/wNEf1fXiONKuVVgjizYKW6 KQhA/lX8hv7TEzXP7c+ladepPDbS+KTdWxs4/N+0TQXETgt9CAuewzX89+AN1nuPkulGf5M/pf6R 84rLMo7fWIfmj//V/uu+EcXkfDvwrGVbK6SjOzclyRkn+VfF/wC0LLbr8e/A8c7R+W6mYGZhEqOj ADHv8oya/TsFzf624jl35qn6nxWMUHkeFc9rU/0P0JhIj01XhwyiyUwiM5DYjGMfU1/Lj+3d4H8R ap+1JoupafZ3q2n9qiQT+UywKBIgY7xwORk596+o8IcbTwPFFStWaXuTWvdnyPi3lsszyOjRpxbt Vg9OyP6JP2cfs6/C7QI4XLG2gFrMCwYq6AhunbJGPrX5z/8ABWO0lvPh1BDHBcylEadJIomzEY4w zYYdMBN34V53CFV0/E2jVl/z/b/Fm3iFRVfw0xVGP/Pi34I/m3/Zz8N6fc/HDwAbN1fTrfWGjHmK yXcE6kMgwRzgbgffFf3I/CSKaL4feGY7jPmjTVDEgBm4ABP4AV+9fStqKSy6H91P8z8D+iFSccsz Kb/na+63/BP/1v6E/wDgr9oPiXxJpmgWGh6bd3UUFwLi4ltoGYxlZxInI4OPLyBX1x/wTg0a40T4 RaWuo293b3d1plsU+2W/2ed9qlX3L/wFT+Nf0ZXzDDU/Ball3N+9dRyt/wBvH4NluXYl+MeLzNw/ dKmo36X5dT3L9tW+jsvgT4vujKsZttPeViSM7AAW2jrngf8AfVfwz+ItUuNY8SaxMllNKk2rXSqy 4/fBZpFWQjtwF49h61+9/Q9pzeCzGo1onb8Efyx9NvE06ePyyjfVxv8AjJfqfox/wTe+Hms3/wAW dN1drDUVisJp5RJJbmKzUSm3ADfLkuBC3GeB2r+yfS2DaXafu9qLaJGqbcZCqAOPcYP41+afStzH D43jGnQoSu6a5X5PT/Jn7T9D7K8Vl3hh7fFRt7WXPHzTbs/uaP5R/wDgsTFfQ+ObKWeORdOn8QQy C6eArG6iGYbN2OCDHk+ymvxTuI13rEq4IY4G7Iya/rz6Os1Pw0wXL0uvwifwH9KpzXi3jlPsrel5 H//X+b/kyyPCJN2U+bIAJ70FbWCGZIo5mugo8pNwEOfpX++B/wA2LbTZCqyMsQJYSkAuFOFB9var rX08cDWbrCyOV3GSJWlQg5yGxkdKqKu7Cbb3KlxJHGuyKVpoxypKFcdCePrVKD5vMLDdGThTjkH0 /nRKPKK3QtolxHCZbV8EPhlPLD2/GktCrs0M2ImXgnHAx/8AqqToP//Q+WJpJElkRSdgbCMOprQu o4ZmhZSUCqpbDHAOBk/nzX+972Z/ze01sz9GP+Cd/hk6p8ftCRbuIx2NuLqaF5fv/vYXDlD2CxOO eucd6/tLsdI0yDw5FbfYrSSEaYCUEAAP7vOB+Vf5wfSyzatU4yw2GpzfLTireWzf43+8/wBaPoc8 K0cN4bVczrwXPXlJ6rW12lv0aSfmrH8fX/BVawtrH463Fno/kWFle3cs1zEYEPzRpbN5YPpkOc/7 Zr8rrm5gtOIiqsVJkVBsC+lf2T4PYieJ8O8rrVJXk6erfqz/AD+8aMLDBeJWb4anHljGq7L5Ik0Z TqUtrbJFdXdxe3YtLW3sYzLcyuT0Cgdh1PbBNfuV+wB+wbd/ES90zxz45tG0cadcj+z9MmcWzQIJ UxLKdhZnHlthQcA85yBjwfG/jSjwhwhXkpWrVbxir626vf5fefbfRw4Eq8ZccUJzp3oUGpSbWl7u y2d7K78nyn//0f7dGuNO+CXga4aNo307RLJZJzNMrMyxIEz2xwB+dfzEf8FKP20PDvx9tvE3gHTL NbdrG9S1iuYJnkuHMM8R2RxgY4KksWPRPrX9W/R/4bxXE3iTT4i5bwpT55dt+Z/Lpru33P5A+lTx hheFfDh8ORnadenyLu1blS+/XTZJ9D8aXiZFYTZe4UfextL/AFq/Bf2phS3uIUhMpRDLESAjLtye nQ85+or/AE7hpY/yIm7ybMu5dY3YjMb7tocfdeo5sPbvGpkF0MNHlh5Teu/v9Metb21uZxkmtSyx LRwxIEI8oBygIKtjnOf8+9Vp7QsYPMkJWNskDvUz2Eprqf/S+YboQwSIbe3aTaAdgb5n9valjmlu I7q0nsoz5qrnzEO+HBDcemQMfQ1/vS92f85CbWxstfQpaJ5cSQyQr5TKDvd9owMVg/2iyzpdSwM7 MjD7NKfvcY7enFIvn7F6zgtI7k3V6zwNfwOUtvKRkwFUrtyuQcgc7u5465y0aZo5FLOVaU8DgYz0 /KpkvdZpCVrMnezDtEtuzneoHlvjO7Pb2qzawxxzCS4WbfbkgRg7I2P+0Mc1lY2Tu7H/0/CpdUiv bV7YFY54mMoBTbGB6DAxk4r0H9n2OK8+L3hC1EFyssniC3ujParxEYjwWUfwnPJ6Cv8AcXiSXJkO Ln2py/8ASWf4H8Bx9rxblsP+n1P/ANKR/dH+zvbrD8KPCa+Q9uE0xFeN2y5PloSfxySK/Gb/AILF a7DY+HWhv4Pt1n5UdnNZvJ5YaOW6jiLFhzwZAQexFf5ZeGFP6x4yU4p71n/6Uf7A+NlZYXwaxE7b UYv7oo/l/wDE4d/NVhJMkSNIpKmWPCDK7vbIFfiv+01rv9o+I1j+wNPereFJkjk2rakxxtyOgxk1 /df0gZey8M8U/L9D+MPopw9rxpOfZfqfOFvOsCSssY83G0dj+dZ7y3M0obJ2HhkA5B+tf5P19ZM/ 1Ci0kj//1P5EVCeb5BcENyWOcKT6+1ZmqNBBLJafaYrhUAAeMMAcgHaMgHjpXOdBjLCElRFYhCfl PVoyfStmUCUxIT/qxhTjr/nFc0rA2luRxSzLPtdyyRtxnoPpWg06Hbh1DZwwPGaxeruTzLYaLl7D zpIseW67nUEANXOPdQPNHI+4yMxchOnPrSKP/9X+N8QW5maVNsS7t7nbnzP/AK9akKNdECMSKiZC swwzV45vdXsSo4iAiJWVGbJkznGD0qhdzs8j2yqACuYpP4RQaU9ysY7u5dYpZnKwKA23+JR2xWnF agt5sUkiJGgDRZ5JHU0GpWuJUWYbGVcjlk6cdc+9PspXvpw0EgMCHadpwrnOCBQRNtaI/9b+NW4i mt9bvfszNzbr5UUq4hDkkt83XPTj3qYsbjL4/eoSh9M14502drkaXLxkxEK7/wDoPvTZLuSF0VYj KjMEIQEspPf6UEOKZbnlgVAuMSBQWGcn61Sh1MQu/mQvLAihnIXcwHfFZT3IhHUDr9lfX0MOmgyG UlZzsZPIx25754qW6voLRm3sVjiAaZ8FtmfWoOmn1P/X/jmuIIipVWSRJYw6MRw2QD/WrOit9iju 4fNYh4gqRqPkJJ5Br589SNlZkbut1aS2EoWGTP8AroxtaTPeuWuY5bS8S2tY5LhFTJliBkjU/wC0 w4FBvB2eppxTPIpJCxyKCiCTIG7Hf8amSPyY/wB+wdvvExrhfyoN4zaK8ge5jlwpNpHHvEi/Mu/O AuB3rQ0m2WAhWjbLKM7DvK1tLSNhuV1Y/9D+O68tmQh2bI/gGeAKow2okYvL86DoPSvBbVrH0Hka FuILSUidGMLAM23G4jtirCLDPHeJG6xLIoOTxLKF6DPb6e1OCT3A5WTTWF1BdqDJNbsxSRD88YIw wOO3+FaUixugW6gM0ZxkY+Ue5+laJJaIxk7sJ4bA+W1rbWySwLsMyrliD1O45P61mPZbmaWe4Kxo cxJGuS/+8f8ACs+VczQloz//0f4w5b9w72+cCIhhPnDjrxUy6lAxV4rmPzW+TtvBHXivEcFbQ9yU uiNGO5JI3SP+PPPrVW4ikEihi24jOcHpQ4rlIW5Dc3Mc0K2wDMuf4QVII71cNqCUfDRqyANjnoO9 ZG5pQDe8bFt6Jldq8Mw6daoTLb2Uk0hz5wPmMGH7vHufwraHwoxl8TP/0v43CjRtBPBNb3Cuhnmj D5kiLdFBHHA61b8iO5fzI+FQDaufmOO1eMlZWPYOm0PTYr+7tYbj5UjuUdiq7mjIPyvj2I/PFfr/ APA3RGOjRSTebH5kfnfaZgEgREiBiRV/2srz7j8f6O+jxRcuIZ1OyP528ean+w4ekurf6H9N/wDw Ry8P3VnBcTySb5DNaxTW9/Asd5bJiFMoOoLIQzZ9Pev6Dvj/ADyQfC7xPc2M80U0emtCqKShmQrt kbPbA5x7V4HirKnW8XLf3o3P1ngSM8N4U0l1UJW+4/gx/aH121g+NHxEuW02G7MjYg1CeUz28roq JONvQlHZsg9MD2r8V/2pr2S7im086peSW97fyKLdgQtsu7eNv90c9e3Sv7K4paoeGFW23sf/AG0/ j7guEqviCpvf2j/M/9P+GCX7Tpclxp/nyzbbpx50y4kIPQj2xjmpbNPKkU/M0jkl3z81b4iV6r9Q jokdLbW0k8Od/kSbv+BkeuK6m0nSC3dHdjhREq7CXf647VwVi4yblqaUdykMDs/+jyRrkBicHPQ4 6U6TzryOKJlSZ+WjuSv7xsj8682qanpXg2CW10yRtQNpezQptSFiVYA5yQvtx/hWjazWttNuJTfc MS0aHeUxk4P4V51XcpRbVz//1P5HW122jvxLa+WBLEYZrRY2CQf9NAx5BzWzqW248P6beCGS0uLi 5lVZUYz3MyqRtYJyNp5596+Ibu7ndBWRDp8CSae3nySQGVSgkCYkBGcMQegzVfSob7S5Hla4j1J5 5iIxJHuCgDhR6A+tS9EUXLW4EzxG+h/s64U7WiV98cvJ5J7Y44roNQdbmbS4YBB5duhVZY3UB8kk ZI6nk1FN9B3tBlg6W4e5huLtpjOm/EkgKRDH3UIqrIgs0272dQoRQpyMCsp31ClLlsz/1f4t71Zr jS21uW3vR5btbxXEMLK8jjqpX07/AErS0COO50nzLZG3rGRdSNxJEGJ5K/pXgPdnDD4jNuLdbmSR vtTxpAh8uEoSk/PXgHmr1lPc6atqLDMstxmOaN+BGTnaMdweM+maEruxsTrNcrDcSakUF0M71Rsw 5ORhee2awYNL1K6sr7UZvI8kagIrMoRhl2hmyOuR+XIqpRs2Fi3bRyHYmBtU/NJ02il1G8tmKW0q t+6UrDIqbShPr606e9gP/9b+Mzwvfz6cfKMsklsUdUhwBuZh98kd/at6Iw3RmtJHTz4h9pfd9+Mc kAfXmvPpdDicHcSOa3NoZLYyx3kcpVg6gxSpj68HPb3rnljFherdwIZL68YQsSvmYHbPbFdlPqS0 1uT3kdxI4VmHmsGQkHgZGCB2wa4vXrbUdNgthd232u1uFbybgsFww4YEDt9K9Cmc04e9c81ithYS Zhid0ky0iIcvgnkA1+qP7FX2W7sGOixanAunTrb30cnzXU8ot98nQ/cyOR6Cv1fweqKHHGDT6ysv uf6XPz/xRoupwbi2tuW/4r9T/9f55/Yv8QyL8avAXmCOyWy1/Yt9OpEMrXNtNHt464ZI+ByS1f3u /BG5juPhv4XO2MQzaYskjLldxyV6deigZ9q/qX6UMJRx+Fn3ifkn0aKnPwZiKS6Tf4n89P8AwXF8 H/btM0+7KzNBe3tsLv7Jj7XCn2gwRv6DL+Vn2r+cN9N07TngmvLJLm4sBHbh9vlQ7lG3LdMkHGPf 8q/bfo8YmVbw/pX+zOS+6x/Lfjvho4bjnE2+0k/vuzNudXshMgmdpEuC6rKjkAE5B+cdMEj8qxZY vsUkTpdNOYpthF0MrIM8ZbPzDpzgZr+hY3tqfgMZfvWiHVIY2haKMLp25FG2NAkUO4fJ7Y5GKq6x pbCLS7jUJvOn0qNf7JaCRY/nUAsdowNx9Tz6mrh8RpLRH//Q/NGW5+1rbm8haWXf5/nzjzJtx/vZ Jz9Tmn30aLc2Vwqu7zAxXJSMeXATkB8D0GPxr/aA/wAg6fYyo7C2h1Z43gjvIZZh9l1Qrs8kqR84 Vj1x29+o7uurCC31e8u0u7rULMjbA0qCFywHUgdsjuc1tB3RUo3N6zsreYQ3k+JbiVWRV37TH6bj 3GeahtVRb2bdMDdwLu+X5Vwcjhun4VREo2LT3rjzLOO7uLCK9spra5u4QwK5UYX5ecMcZx6GuM02 XUMXlgcX/wBkjB+1Mp+0IFOM59OQDn1FO7tYlprc/9H82rzyLbSYwsjk7A5ZxtkJ7giq3hyKVBea hpsLQ2DRAahczSkXeX4A2Yztyvbp+PP+1B/j+LeQy6e00l1umeRjNasncEnqPUc/lT7Uy3OnRxpJ JczXJK3CvBzAVPykMemR1x6c0FRfKzb0nw4jp5msTQwLFavNDJ5iseAcjPbJXp7VzNprN5p8xl0+ Rp4fPGYPL86KdQ3Rk7igc3fY22h1jVk1TULZobOZm862sclYkj48yNfQY3YHvTLW1aKW1uvtdzC0 albmGPabRhnOWBB54HIx1oM7pdT/0vzt1fWoNSis7bS7m3uIridDf2kdo8czBGwqISMDcepB71Su lktLjbLELJrgHy7dl8qIY/u578YzX+1KV3Y/x5k7sg0OZZZ3bU7l7WNY28uMbpYlfIALAfjzjikm WMO0kztPJyYZEPmR8fdyPT2zxWySjsSOR57u2DSRfvm++vZBVWO7+xeeki+Yp4BAJYj0pmDVnY1L Z3ieCUMsVt5a3Ek1zGQAWOAgGOT9a3r7WrjTzBLI+5hdIkQiUGPJOA2B8uOnFVBXZzvdn//T/N7V lsrq5kjhKpcJci4klhzEFfJLcY6N1rXi1/VUsbnRYlt7qMyie1dI2SaJSgB3d+ucf05r/bdq5/jO Zdg8mnmW/aSPzRJ5Zs2iaW7fpllXBXHbk/41Pe37q/mwI0ZOGaRQUYe309qYNdAh0rUr0XF3cX8S IU89IFgLSsOMKD059/zq/Y2jfZ5904jxCWgJBJdgQMAfmefSg50r6I597ma4Nst3DHfXqAWst4qi 3kuFyBuOOMgY6dcCtSS2hkv5Jp5J4vLsktoYJZjJB+7UL0HBJAOPwFBo6fY//9T84IpUtLhJSHkR QVR+ojHUgfWtr+0bZlmitrhMSRDdctnyo1YfvF2+o5H1Ff7eQXU/xdlHS5nTX8shbTUjmfTfsyDa cCPcnAbb6gZGfQ1p2N09raQPaXIsltpGG6JArFmPqOe5rQw5V2GHTbOS3uJZEM10uJo52J4JOcke /FVw9xf3tvb3MU5ZFSBZIoxuVV6Lt68j+dANaWNW8ii/0wQ2gjFtMkc8kpMTWwP8JXGSSMfTFNEt vZGE2sCzBhvlkliEiY/Ggyi3dI//1fhK0udMaG8uLvUbKwlgTzIraVJN84yB8m1CvXAwSP61zuqX tvd2zXLXMWxQIQEQrvycdfX6mv8AcA/xQe4qabc3WnIY2A+zW4S3GcnAOcE/jWtoFrIEM97DG1pF bSRSwn727j5wfb5se+Kak1sI5I2Sw6iqWY1B0klLpFJO0kagnoF6fzrptQaQWEUlv5y3fm/Z5GVT sC9ChI5GQTnNVzsbbZBZWVgiyBnEMqruMIUrDnphR61SJCJcoi5ZRkKhwy5zzj8KuLuhH//W/P2I WUuny/a1Dz+WpiUbsMcjrj070x9Sgt7qOaxt3ncosbw3h3WpAGDhQegyT/Ov9yD/ABIWzKusGeRw +/yp2O4JDGGWMduOlatzpUE8Wl3Ud+8jNEVuYZ08siUYzjHVaDCqY32aVpb5DLBbwr8/kspJnZRx z68kD69atWD300umtIsM9ygVYbaRQqRHOAoB4GfXPeg5T1Hw5bXxlulmhCSWrF5IkbeIx91sn0zX 6Z/8E+Lq2Pxq00QLCt1b2R86SRMP5ZliLHf0wCqDB/vcdTXyXH8ebgvHr/p2z7HwflyeKeVS/wCn v6M//9f+8fwa7v4Y0uUgZk0+KQKvA5Va/mm/4LReH0ubm2klhuUlbUIYXlhl8gASBG69jw3P0r+i fAOXsvFrDpfz2/8AJj+bvpXUvaeFeJdtrM/Ae0i8m3ignCoLQbI2kO6WUDoWPrVWC73XAhEotoZJ QtyQgcsuecelf6uU9rH+OeJjZ3NW90W3tH+1xXjM0cgdIZE5lAPTIPHSse71BHvYRbp5Rk+eQHLj jrj9PzqzCV7KxqGK1ht1nh3rJcytNMTgBjwCcfgKgtLe51OQxDEsKAsVyA6+hB7V0EbM/9DlfhBr ej+HPiF4P+2w/ZIbG/8AOuLgzksrAFg3P0HA9K/te/ZJ+MHgXx18OtCtdE1qCe9tdPiWWKRhG0jb Bu2c4IORjHv6V/ol9LrIMdi8Fhs2w8L04aP5av8ABo/z7+hDxRllHAZhw5XqWrtqcU9rPRW87xeh 4v8A8FFvgV4n+OXwxvtJ8PWkV28GmytFG8fm75ADtGBxg59a/kF8Z/Ce+8A6l/Ynii2j0zXNIka0 QgtG8yxthiMnBBPGMZrp+idxLhf7Eq8Nt/vU+Zfi7W9Hf5Hwn0v+EsZS4jjxWl+6kuV6f9u3v6rb zR5perdOpijuXjMM25CM52nhl69+KzWwkMqFA0mAVc5+XB5/Ov7Th8KP4LqSftGxuPtESqHz8uyS MD5T6f0qzp2y3aWyKbWZgF+fy1U8jGenPvW0I9WZuT6n/9H5za0uDMba8JjeOcqzBc5AP6/nWpdX MXyRfZ0LD5RI3+scerc4r/fg/wCcLndyK4sPsgJWVHQyYJt23x8dRnFQXKQOIpjPJAAoCxKAASOu eOlFjRztpcZMsVoY13pJNcMrjbzwVDfn0Faq3JZQLi7kSOQCMBmLRAjodtKSTWoUZWrKR/Rh/wAE dt7GWSPUI7yeR/OcJiMLnAcHnuEB/Gv6G/Euz/hHdaU42yaVcRYJwCGjZf5Gv8l/pAp/8RXxV/51 +bP9xPBBp+COWST09gv/AEg//9Lvf2zdKs7H46+JbW4M8KalHI0lmg2ozRXDKj5x97aCufRRX6mf 8EcZg99c2f2hV+wavJbQo4JmZIwrgse+7d16cfWv9SPED959H6Lev7mP4RZ/k94AOVH6RVelHZzq f+lX/wAj+k/xGpk8P6skaxyFtPlVUlOEbjofwr89/wBmWOCz+LHimxijVZUnhSeMNuAEbSYIPoD0 9jX+fmQ839i5go9l+p/phmSX+s2Cv/f/ACR9sfGCyOofDzxLaKA0s2mskZPVT6/zr+Ij43eGdQt/ jh48jfRNZlsT4nuw1wli7QIQQz7pMY4O4KfbvX9J/RRzDDYLH45Yioo+6t9OjP5I+l5k+NzGplc8 JSc0pa2V/tL/ADP3z/4JPvfWei2kOoshVLZktwiFQFdsLuGOCMNmv2g8exeb4N8RY+8ujTOuR/sH I/EZr8f8WpqXidWlHVc6/M/pLg5SXhbhlLRrD/8AtrP/0/tjwFcy6f8Atv8AiKV3kii1DxRLPApJ kbIhjVmJ92BP5V/XP8O5nuPB2iyyrtkNhGGyuGYiNck/XNf1h9IGNsNk8v8Ap0vyP5X+i/K/DGaU 3usRI/Bn/gs7Z3jab4dmtd4a88Q2dvH5y4AUyqnB7Drn/er7B/4Jc6hNN8JbSC6Eaz2dslhc7TuK lBsiHoOBn8a6M5ipeAmHfaa/M87w/Tp/SBzuL6x/yZ9x/tIxwy/C7WY54y6ZRiw4ZADg49K82/Y4 v47n4ei13I01lK8UuJQ5XbKR/LH6V+I4eMpcGVZdpo/oPDzjDjKpF9aX6nH/APBQPRdV1z4FeKrb TIDdsNHuY2tBGWM+YnYYAGSeOg9DX8d+hfCHxXJaXKz+FtVW/wBRujaxTHTZIraDew+c5AxySec1 /Wv0YOIsuybhrGwxklGTndeeh/Df0rODs44k44wU8BByh7LlfZe8/wDhz//U/ZT9lv8A4JR6B8Sf DMfiDxT4l1iwvI1VkltZdjZ2rwAR90EsDjuDXmn7af8AwTHvPgn4F1jxn4f1mbU9O0sjV7i9kjk3 EW6t8kiq20/KTngdM9hX+kOX+Oc8X4irJIJui5qPk/Q/y74q+jlSyLwm/t2FvrMIc8u/6H4dKhmu lijIYSYdXHCkHngV+m//AATt8F+IB8atC16O283R7a2kEc6xu2yV3jB3HGB/q+n+zX9GeKlanhuB MY6rtem0vV2P59+jjhauJ8U8t9kr8tTmfkknr97R/ZF4eleXSLGSU5kNpGXwu3nb6V/Nt/wWd8H6 rPrOj6pZ6Wzxf24ki3CW7MOuWy46HahwD6V/nJ9HnEUsL4pYZ1ZWUm1829j/AEY+mBgK+O8JsR9X i3ySUnboktT84f2GfFdxbfGjw/bTzQ6dp/2keZc3JWHEiyYYHd6bRkDpmv7W/CEsU3hjRpYJ4bmN tNj/AH8EiyxyEL1BBxzX6P8AS6wtaHEeDxDi+Rx3tppZb/J/d5HjfQzxuHxHhnUwsJr2kJyvG6ur tvVdNGvvP//V/d3/AIK6fCvxd4r1fSdX8I+HNY8QD7djU7PT9Oa63IYWQEAA8glSD6g1+df7E/wX +IXhz4peG9T1Lwp4osbdLpxK19pckcmXaNEBULgAbWYnPAOenT/RbgLi/KKPgrPJ61RKtyNdLbf8 A/zpzDw+zyr9If8A1gp0r0Pa3vrez+Wu/wBx/YR4SieHw7piSB1l+wxl9/DA7AP5AV/P1/wWEurv TZ7KWKbyTeaxDZzfJkNE2PkA77jg+2K/mvwRt/xEan5835o/oX6TsnHw9k10qR/9Jkfe3/BMyRX+ DljIFkWM2kfksx4f92gIx7bT+dfXH7TOi6v4h+Dvi7R9Ft3ur2706SKOGNcu2UcHH4E/nXj8YVYY fxWq16jtGNeLb7JNN/kfbYLDVcb4PQw1FXnUwkopd26bSXzbsfg7+wf8E/G3gf4z32p6v4R1fTrK S+UQG9snshGnmsxXYeQeE4xxj3r+lBJI109DIyRpHbAOXYKqYQA5Jr2vGjNcPnWf4bF4SXNHkivm rI+f8D8pxOR8APAY5cslKbfo22v66H//1v6u/hp4j8P2P7U/iCM6tpypLKbSMi6RhMTLjOQcdVIr 9GvFVrJqHhvWbS3VpZbnTZIYlT5mfcvGPriv03ifD1qONwc6sWk4Rtpufn3DOLw+LyLERw01LllN Oz1W/wBx/IX+0N+yF8WB8bPGmtab4E1zxPb63q832W3t4SkUaMyYbcUYZwpxjGCxFfUv7Ff/AAT4 g8bavb3fxg+H8Wl2lncu0en6lBuV0ACq0yBQN2dxwcgcH6f2zm3jHgsB4d0qWBkvbRpxS16pH+e/ CH0e8dW8RqlXNE/YOrKTVujd+x+jXxk/4Jvfs6N4Kv59J0PRdC1KxsXnhuB5VumURjkZGMcEduK/ kq+JXhm18FfELxV4d0xomsNF1uazhjR/PhkVHIyrf3Tjj2NfU/Ri43zjiyONpZk7xgrre17pdb9G fmv0vOBMm4MzvAf2Vo6id9u77W/pnmcwlmeQBCIQQxlUYx/s1PbMEjmzEhD4Bcr864yePr/Sv67t 7p/G8m47H//X+fY2RJy6/My9ARlasySiaMsVVShA2jAYZ9q/6ED/AJnyI7tu3nDjaCDwKpbEs0Z5 XEalgNx9WIA/mKB3drCyuISh52ngnGc59auhfMjCxjCvzkUG1N33Pr/9iTxZ4d8H/GPw7deJJLkw 2msnUV8pSwtldYbXzCemMvj23enNf25/DLxb4e8YeC9F1bw5qkWqWT2CJ5qODKhA6OvUda/zm+mT k+NWeYTNVB+xcUr+e3y1T3/VH+tn0Gc8y+twDisjhU/2iE23HbduXz0ktv0Z/9D+j3/gpV+yh8UP jvrOi6h4I04zRR6kkt1Hby+TdTRhWDKHII5yDj2HXGK+QP2S/wBhT9oT4UfFPT9Z8UaCHsElRknd zA8aKWxlO5AY9OM1/cvCfihlGX+FkuF8RJKfK1q9b2sfwe/CHOqnjfU4z5X7F1FJO2lrt/rbf/g/ 0tW9/a6NokE+r3MVmllZJ9rlnkCqhVfm/Kv5jv8Agqv448K+Kvidok+gaxb6hc2t/BbzvbHzIIHk kwGPYkbwvsT75r81+j9gcTX4+liqUW4QjK77X2/Jn6R9KfMMLh+CcJhKklzzrwsu9k7/AHXR+2n7 BjZ+CWlb5I5p/kMkikFslQrDHp8i/nXon7Vvwy134r/CTxH4T8PCP+0r6wmitnc8xs8RVTj0z19K +Oz/ABay7xQrY6p8MK3M/RO5+o5hlk878LoZTh/irYZQXrKKR+d3/BPb9jn4m/AHX72+8Xabp6Wi OhRo5zLKSgIBXKrxx6Zziv1r8e+OPDHgzw5qd/4k1W106MWMm1ZX+d2ZTtAH1rfxEzmPGPGlHFZa nLm5IpLXVHm8B5G+A/C9ZdmLS9lGo23po7/11P/R9G/bW1Ww8R/H7xNrui6rHqmmalf3Et2tuubU SB1ZFyf7oHbI6818vRWM81xJbWtqwm8r7Q0MUeAQMAn6+3Wv90OA4SwnCOX0cSuWUacU18j/AJyO KX9Zz/H1aOqlWm16XL+k2kGoRywrc+SGzDcsDh48/Kfoa/rU/wCCTGlSaT8Fbe2ZneG3sVtLeTOQ 3l7V59yADmvwL6WE1LgO0f5l+aP7T+gxTb44xE30p2/P/I+6/wBqN4YPgr4yupwTHaadJK2FJGPL k6/pXgv7D/xy8CeNvh/YeGbLVWj1yxJi+x3UijeIlEfGDwTtLAHqG9q/gnK8rxeO4DxVfDxuqU+a XktD/R15xhMH4hxy+vJKdal7q78vM2dt+2N8Bdc+PHgEeHtCkgW9iDIgnyAN2cngZ78Edx75r8Ot B/4I9fG+DxbYavqWtWb2EWqrdXMMUOBcohGVdtuTkADnnA68V+xeD/ixheBuHK+W4jRyvbfrft6n 87+NXgZjPEDjWhnuFV4xsnt0svyX426a/wD/0v7Vvgz8BPBXwu8C2Wk61oGjXl5BbD7fPLZJLHEA BkAkZ7V+U/7Z+s/s4eCfin4N8TeELvQ9J17R/E1vda99kEFjC0Uc8Typ8uG52ZPr+tf1fwXnfEHF HF+KlSlKdKop3je6Sei06X7dWfyzx/kfDvCvCmXuUYwrUZws7Wba36dO/Q/Y34IfFrwh8WfBOk6r 4W1GO6a30+KC7gEiyvGyoAWBUkFTjIx9O1fnv+3p+wh4i/ab1+31HRbjyY/LRshWIhkUk7uAfXGP 8a+Q4PzSp4deI9XG42OtGbWvrdOy6NW+8+u8TuHl4m+HdPLsFLStCMtP8Nmr7ddz5q/Zu/4JNeLP hp4t0/XPE+sw3+nC7Wa90+6V5nkCnjDsp2jG7gf3j9a/aXxBY/C3wP4Tnh8UadpFhpFvYeVKZrVZ HdVUglOOOmc+xzX1fiZ4oZjx1ntCeWTktUklpdvRJf8ABPnvDLwtyPw84NrUc2pRdoycpS1skm22 /venysfyB/t/33wZ8TfGbWdS+D+020aKb6L7dFi6kaR1aXyE5XGHOW68etch+w18atJ+B3xbsfE+ o3cN5ol9qcMGqxyO0bWgOyFcNg8cyc8BcDPHI/vbB5Rj828G4ZXjLrEVMPZ332bj+CVvKx/mbwxx FgOH/HtZ5hbPDwxTtbRWk+V99nLXzuf/0/7o/hd8UfCnxc8I2PiTwnqUV9b3FuFnWGQSyW7AbW5H vXi2ifs3aba/F7UfiLqUMOordeXJ5FyuUdkLfMQOCeR17iv1jC18dwdmmOwUrxrJuGn5/l958Xis FgOK1gsyqRU6NudX76W/JmR+1h8SvgZ4O8EalofxGt4WN9ayQw2llaqZg2CqqOMZJPQ+hPQGv4pv i1ceH9R8eeJJvCwRNCfWpxaRFlkaBQ5AUsvBbjnHGfyr+6PokYfN3gcZjsc5OlNe7e9r3X+TP8wf pvYjJ58U4Khl/KqlNOMkt/w6bfM89urWXZE8aKYR8pYYOD7+lEVxKp8oLhAOg+6cV/aB/C7kkOuW lEcJiG0797IV79vwrpvDOiap4u1rSfDunRL/AGjrF7HY27bMwwvKwRS/tkgDtkiscRVjh8POvPaK bfyVzfB0ZYrFUcLT+KcoxXq3Zfmf/9T+o7/gnN+xfqn7P/hLSvE2oar5t3qcf2qWFAimXczEsyqS ATn1PQ+vH6m60pOj6jhQ5Fk/XkdP8/lX714vZ/PibxDxOYONv3jj9zPyTwp4fp8KeFmAyeLvy0U3 fzjc/kSOoWcP/BQK8YTiKObxPexTSSHymklZpGC84z98D8vSv65PCzRT+GtDltZBNBLpUJikU7lI 2evtnH4V+g+POFrUsoyOTWjox/L/AIc/JPowY7D18Hn1Km9Y4mVz8eP2zPjjp/7P37UHg7xhqyCT SdRsWtLi5JeX7GySqEGxecFnY+w5r9VPhb8UfCvxo8Faf4q8KalBcQalYLJcRQSbpbRnXBG08jHP UD86+D4o4Yxv+pOVcR01+6SUX5aLX71b5n6HwBxPgK3EmfcMymvbRqyklfWzlPp+J8BfF3/gmp4e 8f8AxQn+K9tr866wNUTV1tpFQR3DoFHzAICGOzruJJJ5xgD6s+EvxN0jRNSs/hJrDR2WrWUIXThI +xpFzt2tk46jjHrnnnGOfZ9jeMsgw+WODcsLG6S1ulvbr1+86uDuEcs8Ps0xWJpzSji53d3bV7dv 8tD/1f69f28v2Sv+GlPhpdW9pqj2WqaGP7UtoC6xR3BgQnaHI4JAGPfivyg/4J5/tL+DP2dfiJqf 7O3xR0zR7TWbfXJNMg1drH7TcSy5OMTkkB8CMlRkEA4Oa/tXw7xOY8QeFeZcK4G6qUVzprfa/wB2 p/D/AB1gsr4V8cct4nzJp08Zenrayamo27X0T+Z/QN488A+Cvjb4EvNF1CG11DRdd0947e9tgpZR IhXqOnoe4r8uYf8Agjv8P7HVP7S0Xx1r+kRx3Bu4LOKVGjjbOcDMZI59D2r8v4T8Qs44PoYjKqic oSbTTez2f9fmftfFfhnk/EuaYfPMNaFWCWqS1W6fr/wFofpx8JfhpP8ACjwrbeH7jXbvWINOtQGu 75y5wgPJY+38q/IL/gp1+2r8Io/A+vfCc22l6n4pvS2nWUt27LJan5D5itjBIUk9eowOa9jwfyfM OKvE+hWwCcff5nvZLz/FvTZXPh/pM5/lvDnhBicHmDTnOnyR2u3otL+duu7R/L1c3Bnu7+VWVobu 5M6FBgLwAB+QqvCzxs6BFfeOGbkKRjqPpX+uUdj/ABLi7q5//9bwoAKjMmN4/wBZGgwD9BUz3MZG 2Y7EEZyyjngHA/kPav8AoQP+aBu9iKGRV8ueK38xhNGVhkIZSQ68/h94fSv7K/8Agl5qtndfBJdJ gvbe5nsIYmIjlVmww2sNo5GGjYH03V/Kn0uac5+H9JwV7T/yP71+gdUpx44x8akrXpxt/wCTf5Hu n7dF01l+zp43+Yo8umTAKv3iAq9fYZGfrX4I/wDBIDUbeD43eJG1C9gF4dW8tjJMoATzfmYfipGO 1fzZ4T4KvU8G+IJQi2/+Af014mZjQofSH4dpVJpXi93va5/VPe7Y7S9lllSGEW0rtOzBUQFW5z+N fgH8Gv2xdK+A37WfxD+F+st/aWj+N/GGo38d3GAUZ3udqsJMc8RAZBwCBnrmvy7wz4Yr8TU80y6m nf2Td7bNXt92/wAj9d8U+L8LwnnWRYmvJfvK3L02bjc//9f+724t9E+JHg25gR1utG8TaS9s/lyg sqTIVYEj2JFfnZdf8Eof2frvVrjV5bWUXF03mTAyFy56DJK+g7V+5cG8X55wHUxOFwqacm4yW1mn Z7f8MfkvGnAeQ8cYzC5hj+WUqVnBtJ6b6dvkfcnwj+Dvhb4G+EF8N+HHeDSrRXllaaT9zEoJfgnJ 456n8hX5Gf8ABRb/AIKC+F/CugeIfhHo1vb31/rNs+mmeQyPFCJNo81goyQAS2AT90e4H0vhjw5m HiL4oUK000+ZTm+1v+ArvR7PyPhfHvjHLfDjwlxNFtNzg6UFfe6s7fgrXWrXY/mElZL2+1XV7dUU 6tfPdEDO1TwpwD0yQTj3qtJKyWdyI3eK9CBY5k+VRk4b35Ga/wBccPB06cYPokj/AA1rVOabn3b/ ADGWMiWe9s+a0ibNr8qDxyR+FWriwgeHYySefcNh4yfmQHoVXGRWyVmzObstD//Q739l74+an+y/ 8StC8a2N7HJp01ubHUbOzifzYneWIMZSY8ltoIGPl+c885H9jX7Nn7Rvg/8AaN8A6X4i0q4ih1K5 0+OW9sJWMUkgdR8wVgGGe4IBHpX+jX0tuBsViKtHi7Cxb5bRlZN6LT8LJvZWP86/oS+IWBhw1V4I xU1GcW3G7WrleS++7S7tHHfEX9iL4NeP/E7eN9T0wQ+IIZftNvfrOYvs7qdwO5eTz61l/D/49+Hv BXj+D4G67qUNxcoqSWN5FKtwkAlkaFQWU5wWVTyMfNx3r+W4f2xxbk39lTg26Ebx+XTfqf1zSeQc FZi8dSnGMcTO0n5vr+p3f7VH7PXgv4+/DXVNF8STWtrNFZyHTdTkkCRoxRtvzfX0Pav4oPjN4W/4 QX4g6/4IW8ivofD+qXNh9qjPnIWhnaL5ZMDcpCgj1+mK/q/6IuaYyVDHZHWX7uCU1fpqlp97P4K+ nNlGDo5tlud0fjq80ZW/u9/lY+u/2Iv2xtb/AGZPFWm2OnQ3V9pGsakkWoWdtI0kcgdhGpMWNuB5 jDg989jX9dfw0+Jfg343eCLLX9IurOeDVrfyL/S2uFM0EhUFkAzk9QQa+Q+lPwFWwOf4fi/CRbhV a5vW/wCj/Ndj9c+iD4mYfO+Da3BGMklVw6agu8bfqr6t7xdj/9H+7PQPCvhz4aaLeppEMGl2Eamd oUZYouCzABenViPxr8D/APgon+3/AKPff8JF8I7DSoLyW0tLiFLkWou1zHMkbvnBQDkAZx7d6/qL wT4UzXivjrD1p3XsmpNvol/kk/uP5T+ktxdk3CfhtiMvdn7dOKS66rts7tfe9tz+fy31b7XLbyLM sN155u18kG3jiJcsqgk9gQPcV/QL/wAE1f8AgobcRXQ+B/xKt7i1t9JhjXSr+R/tFpJC21AySYG0 7jkA9Qfav7b+kHwRPjLgmpGgm61Fc0fW3X7knZPRs/hD6LPiMuB+P6GGxDSoYp8kvyVvPVtXa1S9 H+9fiXwn4N+JOnaYdUisdXsobiPU7FjKrYbG5Dj8c81zfxS+JmifBjwNqWuzvbC00HS3mhtVmBwI xwoXPP0+lf5mYDKc2xmKoZQ4SV5KNrPR3s9PJ3v8z/WfMs0yfLsFic454vlg5tprVJXWvol+B/P1 4J+Mfw8/bg/aTP8Awsb+zbXSLC7TSrWO7tUeWcrPKyySFmIwd6hQAMAdD0r+i7wB4M8IfDzw3p3h 7wmLO00Szt1itUimRYCFHy7ADgDHpX7F4x5TneQ5dl/D9SMvYxpp633srH4p4EZvw9xFjcz4lwc4 utOq07W/mlf9T//S/uo+J/g7wV8RvBus+FPF8lhPpWoWx375Y3eIgfK6g9wQCMdwK/jT/bm+C3hr 4IfFS403wr4g0zWdKvUCm0sW/e2ABdot4BwDtOMD69MAf3h9EfMMywnElXKJpqjUg380m/v0+65/ nH9OfKMuxOQ4fP6bvWhNQ+Tta/lr958OovmOeSd3JHUimTRgToYkZmUAEZ+9X+isldXR/lvTfLI/ c7/glP8ACP4F+OmN748kspfFZ1gXUWl6ja242PAq+XhjyT8iENyfQ84H9OGnQ6HoNnbWFrdafZ2c SBLSH7SkSBR02gn+Vf5f/Sbq57j+Oa+CqQk6UPgVn8rL/Cf7Q/Q+WRYDwpw+Loziqsr+0d1vfW79 eh8//tJ/Cr4X/GX4f6npXiu+0NJ7a3kk06/kmhmlgkxwME5wcDp7fWv4pPjf4Hsfht8Q/EHhHQZb STSLK/uBbyWcnm7ttzKrKXyRgleMfwkV+r/RHzHMadPGZLiU/YqKktNE/wBOu3Vq5/Pv048ryz2m X57hpJ15ycXrq1Z9PlHfpex//9P9rv8AgjR8QPAnhm1v9G1vWrXTNavtRkhghmnRYpS8YCKGY8YC ouB3yK/oon1Pw9eRGzm1XSJku4SvlPex/vUYYOBn0r+sfpE5Hmq8TMRjIUZOnKzTSdtHf8rH8qfR o4iyWt4NYDBPER9pGLjJNq99rfemjwvTvgB8CdH8S/8ACWWdh4eg1ff/AMfIltYXGP4VYYIA9O1Y /wC0R+0RoXwR8EalrOnX+iXt5Z2oKQ/2jHstwAemM87V4HsMkV+ZQy3iHirMMJgMXCUtVFOz0XV+ trfOx+tYzOOHOD8lxeNwk4rli5ct1q+itpp+h/M3ef8ABSTx3L+0HpPj200U3Ecd2kN9epeMsZiR mwi7cAgEhtxX24r+m39n/wDaR8F/HXwVZarLeWFhqk0Ijv8ATp7qMqxKg5HzcjkjP0zX7l40+D2I 4cyLLMywFNtwilJK70030v7rt1slc/A/APxxwPG2ZZpluYVkpub5b2V99VZ9fvbSOf8AH3wM/Z5S 51DxncW+gWXim3X7VDqsP2aS98xTuXLAbjz7jH6V538Ev2r/AApL44vfhTruuWSi1na10i5lul2h l6Rhmx6YC5PXjvX5BLJ+JeJsnlRxFOUvYq8L36dL+f8AWx+24fOuEuFs55aVaEHXdmk0tfRdj//U /r5/bU+HPwY+Jvw61i58TatokepQac89veNPHNs8lC6blzlfujng+9fxj/EPST4c8darp9qIv7Ot Jkl014yJY3Q89fZsgD0Ar/TX6KVXNaeW4vLcfFxhHZPysuvqz/Jz6Z+GypcRYPM8vknKfxNO+t3/ AJKx+gv7Cv7cPi34KeNNJ8NSQ26eHpXSB7iO78gSZY5RoSNrDaDnJ6jtX9YnhD4nfDH4w+D7PUYt a0S8stUsQ15Y3V3EGhYqN6spbgg9j196/J/pK+H+OwHFdPiTLKbftdZNK+urvp2d+mzR/RP0UfEn Lc94DfDWZVUp0PcSbt7qSVte8bP1uVNa8e/Dr4ZeHbuHR9a0NLi3RmtLG3uonG4KQq7VPQYFfzCf tk/8FCPGfxI8af2ZoYigtPB+rFPtwYSW086EKY1xtLbNrZIOASM88V4PgX4fZhxDxNPFY+m4qEXv frpd/kep9IzxSy3gzh6nhcFUUpTktE10d0vwbfkkfrr+wF+3XoXxK8G6J4Z8b65YW9xFb/YLO58w RpavGQqxvnnGMD2J/L748e+EfgB49eK78aP4V1OaMAxTz3NvvxjqCc9R3zzXxvHPB+f8Gcd4r+zK cleTlFxV93quvXXt22P0vgbjDhjj/wAPcFWx1aLi6cVJSdtUkl2e3z7n/9X+1bwv4C/Zn8HzjXPD sfgzTp12o99bNaIzFWGAzIu4nI9eteEftl/tk6D8C/h/fz+DdVsNV1eWAwQR2VyjLEDG2SGzwVAy Bg9DX75lOS8S8XcS4bC5nCTvJJtp6JH4TxHn3CnAvBmNxGVzglGDaSa1eyP5D/jh8Z9f+OPi+58Y +I8tqMxIsjJcedcRrhA5YhF4Ygnntj8PFWMgjJ3rHIBkuf4TX+snDmUwyTIcNlVPalFR+a3/ABuf 4ccR5rPO88xWbVN6s5S9E3ovkrGn/aK3SxCQRkogRmSMRh9vGSB3rFnuIhcCN2KjnAB5bHpXvxVk j5+e5PBNmNgA20cBmGDxUUaRef8AaCGR9u08kBh15HT8aZB//9bxR3hXT3vnhM4WQxG1Vtl0dp5d QeCOD37dKoK8BLsEeSJs+UzHa49Ca/6AD/migruxKCqIpjO/JwRnlRX07+yFD8Nn+MOlXXxQKHRj ci2huNoRLJd0W4s5yBuJOen3eteLxEqryLGKj8fsqlvXkdvxPoeD1R/1py76y7U/b0eb09pG/wCB /ZP4A8Y/AXwb4CsZPBHiLwzbWNnYRkRWN9btcznYNu8A5J46n+7X4df8FF/+CgWvWupyfDrwZc2u pWV5IbSa7tr1SIgyqxcgKQSuCODgY4znj/Nbw98Os24o8R1POab5FUcm2uzv13tr+B/rr4teKmSc F+Fc6ORVk6jpKEVH+8rdL2v1+bPxg+HXxp8T/Dzxja+NrN5Z9dtbr7X9qik+zT7shm3leGyQD0zk V/Wp+xP+3X4J+MHw20tfHXijRdJ8TQW0QkiuNRSN3zGN6EMFJ2kNk4wfbOK/b/pH+GFPGZVh84yS h+8pWi1FdNP0X4XZ/Ov0RvGCeHznGcPcR4j3Kl5pyfXW/wBz29baJH//1/6lv2pPjP8ADD4da1pn xA8A+MNKTXI7wf2idOuElt7mM/M28rk4JUcjke3WvqT4P/tV/B34t+BNNutV8YeHYb69sBHf2V3q cUbyNjax5K85B7A8dq/oLG8AZ/icioZn7BupTla1nfl/4Hb1sfz9lniJwzQ4ixmU/WYqnOPMtVbm e/lr3XkVpNN/ZSv9VMkl74Pu7l5PkkW/t5HD56Zz3PrXbad8QPgL4PtbuDRfFXh+ze0iecW0V9Dv BxgADOeMV52IyXi/H0Vgq0Jyh0Vmexgs34GyurPH0KsIzd7tNan8+3/BQL9vLxhrWq6t8OfC00uo +H2W5tGe1uPLjUq8Qy77SCvzD+LqeMjO35//AOCbPxh8P/D74ypq/jnVtP0+x1K6VtRM13HbSKyI SrsxwCeDnqeR1xX9i8L+HdXJvBvFYGEf9prwba8/6uz+EM98T6GfeP2Ex9SdsLQnyp36dO2uy+e5 /VJqn7QHwj/4RO61m08d+H54pNMeW2iivkllY7OFIz2yOvvX8h/xq+Mvh/UP2xLTxl9uSXStC8RM x1SDdPp0jvdhFQlQcLgsxIGMDrX499H7gbPKOdZjPFUXH93JK9t3dd+9vv8AJn7h9JzxB4ejlOTL D4hT/fRk7X0UXFvp2T08rdT/0P7Of2fP2jfhP4j+GPhtx430FXttOSKWSTUECSEKNxHORg5GD0xX 49f8FOP2mLTTfGPhLWvh1q9hcXwvnsbC8t7qO5E2yQeZ93cFP3SM88ds5r+reCvDLOMX4mSoYyi1 R553fTW/btfX0P5L8T/GLJMm8LKeZZZiFKu4U0l12/4Fvn5H2J+wx/wUF8L/ABA8F6N4X+I/iHSL fX7O38h7t9RjDIIgEbzOgHIPH+Ir7I8XeI/2WvFFzc3Wu+I/CV9e7ciVNUgMwY9CmDkkfjXl8ZeG +fcM8W4mnltJ8jk2mlpvqr/j+Wx9XwL4o8OcYcHYTHY6vHncUpJvW9lr+n5nw3ZftgeC/gx8X7fw hD4gtx4Gur2NWvL+9Wxit954LKSRgoemOT6Zr7K+LPxX/Z08e+A7oax4r8MXYurM+SPtizXEaONp PHQc9fb2rjzPgHiLL8bgM6wtB81SzbWyat+abXXt67YbxC4YzPCZjkeJxCcaScVfW6aa/DR/ij+X vw9b+HdO/aus9O8GXVrJZnxaZLJUg2xSAS7mcOOD+7AIPfcMe39ifwrSRfAPhhps+edIh84k5y2x dx/Egn8a+7+kq6jy/J/b6VPZxv8A+AnwH0WYRhQzb2TvB1ZW+9H/0f7h/idrfwhs5YofH99pkE+A sS3UqgnqAGB49RzXBT/HL4B+GLCZdL8Z6DprW0OEUXSiCIKCTgrwO5IFfp+X8PcQZvg6UcDBypPR Lpe1j87zDibh/JcRVnmFSMKkbtvrY/nS/bj/AG8PFfjjxHqvgzwdqUN94OeWe1uNW/tFvIZFlMZA iGQc88E+lfj3DdfY5oPsN5bxxrehpBc5EjozfP29CcHqOK/0v8EeBIcFcJ0qbjapVSlLvto363bP 8jvpA+JP/EQeL6uJpSvSotxj2tfZb7WXzvc/qW/4J0/Hb9ly6+G2hWl1d6D4e8W2cJtr+TUbzZf3 MiAeY3zgEAnPA6Y96/Ul/wBpf4GWaCNvH+jxwofLBEnyIBwK/iDxf4C4qxPHONhCi5x57x9OjV2t H0+8/wBHfBPxL4On4a5fVniI07Qs091Lqna+q69mfnr+3546/Zi8dfB/xDe3ut6Pf6npsLX1rc2x iuDI/RVYZyOTnnpntxX8j3iGOxGvXZ0F3ltbi4muiz/KqAsSoXPOCOcY4xX9ZfRiy3Ocq4bxOEzK LUVJWT6PXb9fRH8G/TBzHIsz4xw2PyqSlKUNWuqVtX87W9Wf/9L5ytWkZ5F+V2Ulm7bR71ZlhRpP NkwjFcqycqxr/fA/5ryk25JhjJCAvuXkEAd/89qzpZfOYyqrYzk45BraMWtwLgmgkiJSLfujIVY8 5BxTLYBbcKVHDFmPRj2ptXLjZ2RNduojSOIsij52xwWPv/hVa3edUeKKLeZ2ARmjyxIzwprFqzsa n//T+YpYyxG9NsuOgGADV7SbWSa/htB/r5JAixn73PTj/wCvX+97Wlj/AJvqfQ/ok/4JufsV+K9F v4PivcxmVdSKrNc3GyPyoMKViCglgMAHpzu/L99/F/xc8LfDrw5PdeLLuLT4razaPJYBAEjwSST6 Cv8AKbxxx9Xi3xHqYXCx95T5Uvmf7aeBmGo8H+EuFeKl7kKabfotX83sfxv/APBR74l+FPib8eYd R8Oagmp24ub+VVSUpIkUqwFHYDgchgATyBX58XYgV4rWWJmErEiUcrkYwpr/AEN8LMrrZRwNl2X4 mPLUhDVeuq/C3yP8p/GHNqGc+Iea5jhZc1OdR2/Jr5NO/nc+kP2VfF3hXwB8SrbVfFNrp97aRXCy i2u4vNhi5VTtbPpnIzX9dXw3/a6/ZVPg/Rk0PxV4Y8O3lxpiSRaVaybJJXWPc3LY5Bzn6d6/n/6U fCme5/VwNXLYt0VG0u17t/k0f1D9EDjbh7hnLMxoZpJKu6nMu6jyxV/vT+4//9T9U/8AgoF+3n4m 1DUNZ8G/DfXrO50a6Js9QuYZyPJR4xtIZcZO7bkDcB078fiNPdw6m9zqOq6lJda3cbryaVoj5s80 nzNuPuffjiv9avAPgOPCPCMMVXhbEVt/Tr97XXsj/GP6TniUuOeNfqWGlfD4fRecvmui7b8z7HLX bvKqmSRfPIG/jH4Vnm2LSZUqiqMgMeM1+/rdH8vSk+ZlVVd2m8z5mQfu8dBiqqmWKQt8xLkAqe2O OK2ur2INaIuoVmRljcbXcr931I+lRXkHlzRCK5a6tgiyRyx5QyHbzuB560NpLUD/1flh9yslypcO pACk+h64q1PDqUkkirL9mlYLLK8vybgVDAbep4I/Ov8Aelu7uf8AOHGTvZldGCeYsybm2fJyRlsj kU6G4UMX8r54ucOM8UjQ0Rdfb3jR1BfG2NWOPKHt7dayWsLhXMjS7GDsqojZVlPQ4ot0NofCiZpG D/InmfZo8+cmSUBxn8jgE+tKzeSfOa5kmjuFVkRiMRnAzj2J5rBprQ3jG2p//9b5jKPLE0kLbRGw ZhjBkGegr6c/ZE0u51P40aZKsqwJaxRusCgK8ilmDEseh4AH1r/bvjGfsuF8fPtSn/6Sz/Bvwwpe 344yumv+f1P/ANKR/cP8GUNr4A8PoGL+VpkScsCGIQDr+FfgD/wWymEml2EDcGd7cXDwnJRRdvNg +g/0dOe2RX+YHg+3PxgozX/P1/mf62+PsUvBzE05f8+or8D+ebXNe02z03UcW6paf2dmS/5lezMp EZdv9kbuh9vx/Er4x+HTrnja7uNL1OwM147QiCedbUXEu4tG0eTySp2n2Va/t36RkuTw1xC9D+QP okxT4srS7I+Yb+yuNPvrnTL2MxXVpKY5hkEbgexHUVk3GpFNsA8qORGJYryzg9M/Sv8AKes9Wf6b J3SZ/9f+QtZIWTaxAf7zPjk/59qwrlYrlyWTDocRt0Y1zlubtoV4UlUyb1KtHzuYZXH1/wA9K1I5 EeJtjgsq8/U9MVyT2Jb6sijyitFK22QDOW4PPQ1kYvluHMsR8iJ8mYNlXGO3+FZCJL/URPCY0wso X5TnamB1rEy8dj527NyZNixopZytBSk0rH//0P42rSMbImkJdc7gjfeDe9bUGoeT5sjjCIpCkj09 q8cuC1MndJO6JbuFQHcFVRznnn86Li1kEbSO7YjbscGg6aaHW08yqkafNI2d0rLuOKvXF99miR3Z E3ttC939qDQxwFkdlRdiMd2B6k5NPiF5p4jgSQQZl8yAQDcNxGc5x7Cgxn8R/9H+OOVGlVzOWeZ3 Ikl3Yf3P1rLLCEui7yXO0svP51450bEYt1WVGYhUfq2fmX8KsXLRQjCl89n9aDFybZRXT7rUgzJz tGdzNtOB1/Kmw6dcxCVZLpvLA2qoYhpM8HI9Kwk7sS0dy7Glro3mTrLG7Oi8Mu14yfvVuRy6Zf2r eYWSQ4ypXKN07+h/xpHTTkf/0v42bm2la4aNZowiD5SG3KR6g1VgGpvJc21nIgMkOfPlwsagH378 V8+egJewmW5tibu6F1BtaRVH7tx0Iz3HHStaKb7HaXFpb7Y4rmXz5ZE+VpG7qfbnOKDSDbdmYOZh cvK4Zhn5d64QCtFLyGdvJcSOGby0MKbmGeMU1ubxlZ2ZCtp9kuRZ2UpW0jTzGRRiPe2dwI9fetb7 YkEiW8LYZuDIRwuOuaub6Dc9LI//0/46ruaJoQRMsvzbXZD8pPtWYSybQjSKhO0tngfSvnz2ouzL otg7ktM24oAVPQY6VQvY7+JY4YLthAHMsp8oK7A5woYdhx+VVBpPU2eiuVLaeSwhact5ZOTKZGxH jpk1oNMt1bJc2V1Hfxu4VpbYkW465HOOnNaOSSuc5WOyNmR38pQCwJU4Y9cCmJeIFG8g/NgrjgCs 4fEB/9T+NA2FqBJIY1aSWTzCu7g+2KoCC2t7oMqKNxyh2ghD71457Bo2jL5rlmiYk7ORlU56j06V u3Fs8yrN5u90TaoKktgentSezA50eYLi4EflS3K2+BGx2+YR0GO3QVbiW8mst11E9ncLFuktycsv tn37fWsC+dmUb+7so0ChSeVAYc4P9adLfyX8LKumXEUEyeR9pusCKZlI3snfHsfWt4qysS9z/9X+ M+BI7ZkRUiiDJsjSMYzgfMT/AFre0mN1NxOwjeKNOQz7WXJ6gZ7V456vNeVjrPBdlHfeK4B9rFuJ IW2SL80jlfmWML0IJA57V+ufwC0jVX0ePRLgrdWst5zE07fbNojBwOcgjgADriv6e+jnRbzatU7L 9D+cvHRqX1an5n9bP/BHjwvYR6XJ4murgNqWtarN9sTHmPbrHuRU2/woqxIM9chua/YL9q7UU074 QeJLuK5MczaVc2yxqdiMskTKW+o7V+dcYV5Y7xZqJ9KiivRP/L8T9wyeisv8NKKk96Tl96f/AAx/ Ar8eAtx4p8aTrbSSNpPii9czK5lBaVxvZ+eBkjIPcV+QX7VWtCK50loiq/atPczqsSpGfLYoSgH9 7+ea/tzjv3PDGt/15/8AbT+OvD/lnx5z/wDTx/mz/9b+Fy/na7uDOXOYwVUOflUZJqezvg1woCRm OJcF16EjvW1VXqMcmrpHTW1ysrpJFH8xyu49GA64/Kt9PtBSK+RBJbLL5EhBHXGcD9K4qqLg0ty2 UIT7OfMmSfkM/LJ3xntXRqrzxxw6ekEGqRw+XFLM+2FumT9cfrXm1FuXdXsdHpmnavZol2pW4SEi O6uIvmkjJ55HocHmtGOzayM120wM0r+YiAgMgPp+NebV3NIysrM//9f+Py208yz3kjSpaIkZlubm U/JGD6fjity0ivWks47OVooLQLG15dK5WLnIKnoQeelfFSVmdin3Oi1i8aG6itbpITYQDzL27hQ7 p1IO5Rx2xVczWl3htDjne3dN9sqrhiMZ6dqhq6sHOben6dBq4t7a/u4ILiJgkTzDYsoJOVLj9PrV S5so9DllSGKO4sUlZVaFyyoxzgr7ZFTGPKPmTix5eaeJBC5hlRdr+YN4IPSrEllPDB5jyr5jj92u 7JI7kjtis5xetiVLlSR//9D+MyHDW9rbreXz2KSsfKQbrbzcYO79PTrVi4sbOxtrjUrWIWcQMf2h I5TM90w4YqnuByB618+/iZywhadjm7ZJJtQmvUubh7Sac/ZLeRVjWJcdDxknjPJ45rQAkN2zO6Lb OcyR7cTqQMZDd/8APNBbVtCPUmhaDZFA875CjdIQyrnls9+lQx2yab5wgiljtpW8+SJnMmGI5I/+ tW61Q4rRmndtBbQtb2jrIWVLqOZcAMzqGKHuME4P0rI1OJ4pI5Zdsm5RkqOFOBx+lCio7En/0f4y vD1peTSSODD5MgyF/wCWse3rxXRTJZIzZWQXMhEPyD94+OB/k1w0kc5VZILFJhcvJGMbtrDMmf8A GpjasLZ9Uttps4Id07M2HTnGSOozXbTjsRJ20E1VLa+01ZkIsmht0eGa1X95MeCS+fqfyryzxHrE 1xaRQGeWWOMkwLKpyTjBI9K7qavsYSV1c4uL5lSPkSMx3YP171+kX7E892unaydNvltIrTWg9wiy gTsZVjRcn7x+6wPPAkGa/UfCX3ON8E/736M+H8SIc3B2Mj/d/VH/0vlX9m+ODTPG3gm4M8c15Drc EtpFO4Fs8schly3+0ArBfciv73P2Z72fWPhf4YurhVBm02JEUcII1QbOOx9frX9afShgnLB1PL+v yPyD6MULcKY1dfaNfdb/ADPxx/4LRaFql34Nnm0ZZVvJbFZZI4UEjhLe8t2dl9yivjHI28V/L14j 1XT7e2Glyaq11+8j3209qrXtxIqAuzYXK7T1xj6V+ofRsxFOpwKqKfvRm2/novyP5r+kFRqQ44rT a0aX5f8ABPPNRWxt7+aGMxXVnHAkzIA0RDSDPA7Hnv6Gr1ubTU4fIdIxhwm+ZipUdBg+nrX9KRXu n83c6VZo2r2A2kUllcpZ30NzbIpkhAZ1RMhV3dQRjr6VyuvzaPctbw6fbzwLCQEFxJveIgAdccjr +dXT3NXP3dT/0/zh+zQsts0xm2FQsxjUdB6E0+P7HFKIjdSSWzfupSDskCE8jPY4/Wv9o4qPU/x/ hPXQzvsC2aa3c6teGG1tlF9o1lbxNLJNtMfys2MdNxyfQfSqcjTXEypbhpPtBWZhs27cjPI7VqrW 0NXNW0Jb9Zbe4tI0ldWhUtJCn3JM4wfwwfzqPXhFbR2MlhNcwSSXqPOk4GZoiPu5HuT19qCHJvQt tNbRWIuokuJDFcDzC2GUh2VUGOxHOf6YrXt9IPlyanHIINQIXbbNAzSGNlBDZAxhs9Cec5q3CyuK Tuf/1PzRvEubzVY5tSngsNPs7QGWSOEl5GB67FGM49a07O7trNhIs6SW8rf6uPIkkQHg4/p71/tQ f4/N2Vx99HK0t5LFGGtyBJC075IDcY56EZ6e1Y1rqMtlLcRXEjumzEAi2mONvr6ev4U1FvYxTaOi 8O6ZDrd1I2pXAtFt0Y23nvst74sBhc9ufWnG2i0ySSZ4ljh3mMLGfMRsdgfypGykmhUntHglYh/J 5YgMQeTTLOGJo5hG7ujIdyu4Bx3xQYt3dz//1fzPbzp7pLLT4fMlLbY2X+D3NaljYtdQRzXkU92L YMnLEZ/3W57n9a/2shHqf47mYguG1ObT7aymYiINLHJEyyoT0GDyciuygtNKbTsWxa2vIosSWLxj y1lHVj9ef1rQDHV9qz/v4RNuBlVQOnVj7D/Gl+zvMqfabGPbKAsEgIViCeG465GevrQZT3Nm803C W8bF1i8tQsTDCt7j8qgvtEt1spIL66uFZblTEiuDGrA8ZOevHb0q4bnNJWZ//9b869Qszawxlnzd I52l0wxUdj3/AMKqWMjfavOljdXm4klA/wBaOox+Nf7ZyvfU/wAZySW6t7W8EkcsjsuX3RqQ8Wcj B+ntUJSW+s7ia5kMgV2xk+XhFO5SefTH5ULm5lcTaW5oQa20VrEls5YvGE8yRQRkjG0fiQPyplt5 0dzpVzeJOqrdFJYc71RT1yBwN2D9M1qZRdndlvVYZ2lk8i0hKl8xGAhAinHb1qrcCKO3UO25oxsZ icNn0oNeZdz/1/zytdL1K6sFM0B/sp5iRPEoaRXKjAJHIXGOvHNSx6E1pLIssEy20sQ2+ZHtjlHc iv8Abyn2P8YJal6bRftjLdWCbLeQeXDCj8xlAA3uRWT5TCcWZDTbHy6IQhPqATwDj1rQ53uLqcD2 0QiWZ0ZzghTh1AI7/wCelNstTtrV5JL2WcySgJbGLJmRwRhge+P6UB0NWXVbiZDZzCO7s55fNvr+ X93c3QA+Rc/3gep9qsxXtrdO9qthCPMg8qKGEkEFR15ySSAffNBzp2d0f//Q+A5LGC4gfcsYW3TA KY3oScgsO/pn6c1zi6a+pNHZvcSwW1tci7kCOEDbeMkd/p/9ev8AcA/xQe500MtnYW/lfaDcHeSI kOxx2y56enrVnTrd7uHUQbiT7NcsskVsrAJGV6FSACffJ/rWkFFiMryIrmO6WWSRZUiyskbbWQ5A H9fxx71Lp+lpbCIR311JNeEOLaZ+E29WG7+9mrtEmUuU05JLaS9UJp9uttLB5ZaabzJp2UYLBccc 5PBq3p0Vgk91cIiSMCI5CRkLx938R1oVraA3aNz/0fhC5s7W3a5nAQBxvTy2/dKp5xjP+cCqem2u nXEpuJwzQwLmSGOTY7AkDg4OOcc4r/cix/iM3ZXF1doYFtUhhe2hjO+R2XzXuAeAS3p0xj0PvVm/ a8vdSlv7iOGONIVkkNsvkwxoAi4VPy6c1SjdXOWpJt6GzD4bZrhIdQi2u0YuCLlvszIDh1785Uqw 9c1WGjWUF/HNHJJLHb5Jk/iXgggduKOV6mLkk7M7/RtmoGN4jJAIkWGQYMUkoHQSD1I/kK/Qv9im 7hs/i94fgtoVs9zOqZQBZjmEuZD1/hTGc8g18zxvC/COOj/07Z9X4UT5PEvK5f8AT1fkz//S/vB8 BRPH4X0xGIPlWiopXOzoG4/PFfzyf8FqdOuU0S18hbh/td7ZNLKPnWFluYgdo9w34Amv6C8EX7Px ewy/6e/+3H89/SijzeE2Mb/lR/PPq2iiOKyumuhtundZlVCWtipAP1Bzx9DXPPpJ0yd/tcsVyOHi uLdswurDcuD7Aj8jX+sVM/xqre8i/HfXMxYIiywrFtLEbiM8U6BLGSa1WcLbyLG0IkHV8kt0/HH0 rQ45PREy2MdoLzUrieNbW3QCKNyd0hJx8o74rIjjDSefZyupkO1kX5dwzkYA6fhW6vbUzbd0f//T +aDFdJqT333545UJViPvRgAcfhX3d+yr+1NrX7Pevabd313f/YfNhnv4zdCXTs+ZklV3YDbduAAA 2cZzX+3HH3DFHivhnFZXUhzTabj3uu3qunex/hF4UcbYjgfjXBZrGq4UeZRqdnFvS97KybTb6K/o f16fs8/tIeCP2hfCVle6RNaL9rsU3wyygef8vICNz2OK/O3/AIKKfsG+APFmj6n8T9Mu7DT9Wsg1 w1k0qxXkplYbvKPX72Djoe/av81eA6+b+HniZTwdNPSol6pPS/6n+onjRgMl448I62aRmnam5q3d pu3l/mfys6pELXV9V0tGZprPU59OTzl2uwiZk8xgOnQGsFsQ4hlkWaQfekQfI/4Gv9XcNNVqNOqt pJP71c/xgrtxqNX6sm04CBrqYRKYeAd7bcMe4/AdKivra1+04S7fLlLsRdCcYO3cPft9a7TFybP/ 1PnuW7tobiPY7S+YoJjkX5kbv25plzcWZuI1Rj5ky5COfmyOuP0r/flI/wCb1ys7D55pYRGQ6vEP mMXbPv7/AONRuY7pI5DuBc/MjDBU96LaFXRFfxuyxmeEkRALauRwceh9s0WF/FCyQ3llLdgsSD54 jjUY4BG0n9aQ4P3k0fvN/wAEgfH/AIa8JeIdTXUbm202a+uDiCeXMa7/ACkVVPYjrn0PrX9MXivx Jodt4cu5ZdSsViubNljMkwO8MueMe1f5b/SLyLMIeJ88WqT5Kkly6b63/LVdz/aP6P3EeU4rwQwW Gp14udKlaSvtaNnf0d15H//V9V/bmuxf/H/Ubq0lguLSxt5Vllt23l/OnCx4HU4w/wCtfc//AASf 8deEfB3jO5tdX1htKa41AKJ7kbYpQ6rkr6hScH0r/V3izLMTj/AeODw8L1HRWnyZ/kJ4J53gsr+k RUxeNmo03UnG785Kx/T5rfirwyvhme5Ouad5N1Y7rdvtSEybgCOCc/nX83/jr9rbxB8D/wBp9rnw 7PFc+GtUvRA95ZagGhlJmdSWHQ9MDHXJ9K/jnwh4Gxmf4rHZZiKDs4PRq12k9Nf06n9y+M/ijlXA +KyzM414u9Xldneybjq7bLp8z98vg/8AHDwP8avBNjqbarpiXd1bAXthNcxhmJUZwCeevUVwut/s yfs365q15qWrWOhXF9fyM8zSRQvvLcsM45r5GngeJeDM2xOCwMZJxbXXVdPw/G6P0HE43hHjTA4f HYqpCUJJSV7O11+B6P4E8DfBv4Y2yR+GpdA0hUBSJYzFa5xknCg/yr84P+ChH7fMnwU0C80LwtOt 9LfKdPcWTBXbzU28P6gMvTPevZ4L4PzrjfjfD0szg9WnJu9tHor9Px0PjvFfxCybgPw4xNbLaqcl FwglZvVO7t16r1flY//W9H+FHxeS6+Ouh+M/FFrJbWtxqi6nqupLfhhpyCNUeN9yoTuY5zjAwBX9 mPwQ+KngbxT8PdEutP8AFGn3Jt9Lia5M1wsUqBo1IYgnOMY5r+8/pNcFZjSw2W1cBTc6dOPJotdN L9fLTpc/z/8AofeIWVV8rzLLcwqqFaU/aauyfMrvtazur6XsfiP/AMFiviT4M1yz0rwtp+sW93LY XEOqSz2sgnIRGkBiTBPViOvHSvW/+CXPx++GmmeEIfDWq+JdNsby/SPe0t5EqRFS4j8/LZUnaRk+ lefX4MzrF+A1OjTovnT5rNa2vf8AHb13sevwbx3w/S+kTmiqYhckouKfRuKSf3fltc/S39o34heB 3+G3iKMeINPujFpzyL9mu0lglLL8g3A4yTjHPX9fwI/Zd/b31j4cfGvUvBt1cW0fhW61G4EcwnMr 7fNAIYnjnjC+i8cV834X+GWYZ9wnmmExtFxlFNpP0W34H1PiV4wZTwt4hZT9VrqVOq+WTWqV20r/ AI6em5/RNpfxf+DPxM8IWuoXPirQbixvrcPPay6hF5iNjDgqT65rz8+Hv2WraXzjP4VlljYARNJa yMmTwQOmPxr8ywmQ8YZLKrgsJTmkm07J2dm9T9YzDiLgjMq8MTjasJS3V2rrRf1Y/9f+2m9+Kfwb 8BaLPFpnirQNN/cs8UKXsG5cLkfdb24r+cL9v/8Ab38X+PNd1X4a+Gp01TwZ9j8vULqO7MRf55E2 7eVdXUDjA7nPIr+0PAzw3zLN+NIZlnFJqNK02313/r1Z/Dv0kfFvJ8o4DqZFktWMqldOFlrbbT9f kfi/bQG6uE8hHgWILsMYw0IXAAz37DNf0y/8EzviF+zjonhuDRtcv9J0zxRDaxQzT3d9Ch83bud9 pIxk55HTHX1/rb6QuAzTMPDyphsqTc7q9u1n+e3kfx39FDOcnyXxKhjM2klHlajfa7ktflZP7z9n V+PPwdsbWJk8c6A0R+RFj1KB5BjjBUPx0r5p/ac8d/szePvhrrtl4o8QaBf3cunPJYhbiF7gSYwu ef8A6+PWv87+E+FOK8r4joY+nQlFqpF38r6/gf6XeJPFPB+e8I47AVMRGanSmkv73LeO/mkfxzeM 5JfA3xM1t/B93ftpWn+M5rzS7mF4vKe3ikDRLA5DAKxB5XI+bjpX7rf8E9v+ClJs7aLwZ8WdTht7 G2YWEcupXZjlgSFYwZd2xYsNuY4XnCk4HIH98eM/AUeOeA6U5x/2qnCMk7aqVvl1bv8ANdT/ADs+ jf4oPw/47q5biZ2wVVtNX06L9PyP/9D+1K8/aJ/Zl8T2IvL3xn4R1SMgCMS3kMsmewU7v1p+hfFv 9nXVdRg0/QtT8L3d858uP7JNGZo8c8Y78dq/ZsTwzxZlmDnCtCcaavdX0/Bn5vk/E3CGbYyCwM4T rOy0Wv37n0vaS2stqj2jI9uYx5bR/dIxgcf0r+fT/gsLFHHL4c1W5uM2K6hHDFHKgMSy42qT6EnG K9nwSbXiHQ7+8fm/0mUpeHU+bpUg/wAz7U/4JdSNJ8DNLAJcpZIsp3iSNWx82D7k/wAq/SPxJr2l +HtNlv8AV5Eis41JlklXdGAOua+e8R6Up+IWOpx+J1Gl87H6VwfiKdPw6y7ETfuRoxb9EtfyPkl/ 2wv2U9L1A2194w8JaXq/mtEIVlj+2OVJ3bQozkdx1FfEf7Z37fnw9t/A2oWXwr8bW9xqN7HLYxiC ZopBIAFVFGOdxJzg5GD6V91wd4S8Q5nxBglmNO9Byi9e3Rel7eXyPyHjzxw4WwHBuYf2TVtXUJJN W06SenW17W1+Z//R1PB37R/xR0HxmPGV34puTeWN+90YoG8+2QKxKtxgt9M9Onv/AEsfsv8A/BUb 4O+IvCWlaZ8R/F2n2OsLZJMl3PK0M0m4D5WjYbgQcj8K/wBLfHTwVji8owuPyKH7ykktN3pt6Pff dH+WH0avpBQwGNx2QcT1Lwqtyi301+7S/lofTt5+3d+ydA0t1d+KtGEvmCN5JbYNnPRmO3HP51gv /wAFF/2StJkkgi8X6Nb7E3ExxeUXJ+6uQu4Z5+8AK/lyl4TcX1/3XK7fOx/YeI8b+B8JBVFOPN8r n5D/APBQj9vm28d2Emh/Cvxr9gtLyP7LBDY3Ad5vN+87IQGKKAw44yRnPFfh3e3k+uTXN3d3rXN2 VxPNMcy3TdCSfXnPNf6C+AXAseDOE4+3hbEVXeT7pK6t6tvy0XY/yu+kbx/PjzxAq4mE70KXuwXb +kl977mFco1nm0XAeTDPHkHjgg1TnguIlWSJgULAMv3iv1Gf1r9+grI/n+bT2P/S8Ad1c8KFkY4w g4zUiKgUiXPnqTk9A34V/wBCB/zPjZJVEW1srltsePyzRIqTJGrRZZeCxOVbpg49uf0oAkihjb9y +15GU7Ub5enf8Kda2ptzFBcXkRU/MXVWCRDJODnk4oNabsiWMIkxmRpUaGTdDcI5jk45DAg8dM/h X68/sKf8FC/+GfI7LR/GWoapqeg2sYt3Q20s6SR/KeCAeR049O9fj3jNwHS474TqYBRvWjflsrvX t+DXbU/pL6N/il/xDTjj61jKlsHVjaV3aKaWjd9FdXXm7dj/0/6erb/gsn+y/dQwzM+pQK5wcWEt 2yEfeyqplce9Pk/4LK/soxxTSpqGpvLEMb30eeCJR6Z2lv0r+v19HjiWE/YTUubtZp/cfyVT+kxw f9XeLpTg4q+vMrWXnt6nzB+0R/wVt+F3jzwHrGjfDW11Ge+vLGe3j1KRGsobWTyztID7WODg8c9O D0P89Os+OtV8RanLq+t3mq3urm5S8iubi73w70IYDySOBkHqc/MeemP6q8DPCSXA+VYuvmcf9oqX V3o0mrXt07LXv8/4b+kR42f8RC4rwVPKqn+yUeVpRs1dO9rrRu+ruu3Y/ab9kT/gqn4P+CvhSHQ/ G9hqU9vPBEHSx06a4gtJlRRKDJ5YHUdBz3r7ztv+Cz/wEvIGns9E8R3ir87PBot4IVQd9xjH+Ffh vHX0eM3zHirE5pl/M6U5N/C3fzTukf1HwX9Kjh2nwzhMDmc4RrQhFfGk1a3utb6bf5s56b/gtn8D 49Wk00+GdddPsnnwvbp57uRywMYG7jBzxxivzc/bb/4KO6P+0Ho0enfD+DxBpPmzCbc9pLY29xs+ XHmEcjIHXHT2r1/Dz6O2Ny3inC5pmsH7Km+Z3Vl/wW9rfPzXxPi19KjLc44JxuSZJOPtqi5VZpu3 l2S3b+Xk/wD/1OM8A+H5fFHj7wn4c1CaaGbVtfSW4SRPOS5Z5N7owfIKsWwQeME1/V/8HP8AgmB8 Av8AhBdG1DW9ItJtW1DT0mkubW1Qg7hkkg8A84+Udq/1a+kbx7jeBctwVHLdHNtvW2233WP8ePok +F2W+ImMzTFZtqqaUVpeza1373X3H5C/8FGP2Jv+Ga5JvFHgqa3m0DU7r7mM3canBUYwCATkYBPT pzmv1q/4JGX15qHwNt7i9ZvOiskjeNidoY8nHuM4z7V+T+JnFk+NPAzDZvWd6nMov1Tjv95+y/R8 4VnwL9ILN+HIRtSipOPTR3tby10P0A/abSOX4JePIJWKxzaLKkjKuSF8tz+uMfjX8cngH9orxd8A fi5faj4SuSRa6i0ZsZLx7RJvKbB6ZBLDOBg5OM15X0YOHcPxTkGb5TileMl+OyPY+lbxxjvD/j3I s/wErTinfu431/U/YDRP+C4mlWelWtvrvwv8QXGp29sgurmC3eSCV8Lu52+rA59GHrW7L/wXG8He bMsXw015XsrT7Xdo0ZMEiccRscHPPHXP4V6lb6KuY+2n7C6hd2vKO3Tq9jkp/TRyeNGHtGnOyv7s t7b/AApavt8j/9X9rPHX/BbrTfFlhc+HtH+H+taT9vtWZbkld0YGcgv6njgDjPNfhl8Q/HeqeNfF Ou+LHH+ma3eyXO6+H2mWNXctggkgZ4yBX+t/hB4Kw4CxVXE4+ClKSsr2f5dF69T/ABm8b/pD1PEb C0MNlVRxjB3srx+ettXpstkfV37KX7fPxH/Zhd4bCxt9Z0eS8R5bc3DwSJGRtYeXyCAB0HoK/S+y /wCC6stwkMEvwtkkm83Y84uDZrIB3xzgV874jfR3p8U8R1M4y2NlNa2aS/F9Hfbp36fe+G/0uI8N 8LYfJs8d6lL3VdN6esV1stHs18zb/wCH4lvPKQnwyuB9nwJ47e+ExOR97qvGRzk18gftR/8ABVHx X8c/C134a0rQbjw1BdFrNoYrsCWeM8FmdQQqj5s4Yk547mvD4U+jLXyvPMPmGPX7unK71T/BM9Xx G+l1lfEPB2LyXKpfv60eXSMla/m0l6/h5/kPK0Ukst0iLHdTMTO8fDy5POW6n+mBVVJ1s44oorZg Lhy87ggcA9D+p/Gv7Np0YxoezS91aWt0tbY/z/w2KnGtOrf37Xv53TP/1vqH9mH/AIKM/Ef9mFbC w0bSk8S+HfMaK70ua5MMlurAKNg6EDGeSSDkdK+9tT/4Lp+LbeVVt/hZaNbkBo7mG9+1GUEc5UEb SDngiv8AVfjn6OGH4k4gnm2DS5Z76pdXun27rc/ye4D+mBVyDhqllWbt+2prlWjaei1TXe2z21Xm /wAv/wBqr9r/AMZ/tO6uL3WbibRrB3af+zI7gOyAlWRUAGVAIYkkkk44GK+LDDFBCkEA8tIxxg53 d81/RHA/CWF4K4ew+Q4XaC95q9nJ9r9kkul7Xsmfxt4g8Y4rjrijFcR4u96stE7XUb6Xt5tvra9r tJDs7xGzZUR/eCkgP/n+lG/5g0bDavJBGTX2J8RzLVF03cbLHFJtUu4O8jBHbFXtG1q60LXLPUdN uY0vtNvEurfHKqyHgkDt3HuBWVeEalGdKavFppryejN8LiKmGxNLEUXacZJp9mndM//X/Qr4O/8A BXz44/Dzw1aeEb7SvD+pf2aFt49Sv55YftwACqyRxo5BwADnuPevVdf/AOCyHxx8RaRqWnWvhPwz C0VsVlubfVZo3cPxlU8gEkAngkfWv9Ts7+jNgcwz2eY04qUJTcviatd9Vda97Jn+UmSfTFqYXhqO W4qcoVYw5bcl7tK2js9Oiu15pH5DeJPir4r1X4iwfEuWOGHxVH4hOumfcZLeNvNL42kEsMEg55+l fpd8O/8Agsn8dfh94ej8MroPh3U7a0CQae18WeSGPofLAXgD0Jr9M438Hcq40ybCZVXSX1eyTd1o tFaz0/yZ+KeFnj3mnhxm2YZjTbccU+ZpWdpPyej9fJHxn+0L+1R40/aR1DVtT8arFbJcXck1ktve GQAsY3CoNm6MAx9Nx69ua6/9nH/goN8d/wBm0QeHvD97a654cuQY3t9SiMkmmqAMASgFtuQOeTye DXbPwkyWtwVHgytBckVo0tn/AF29TzcF44Z9lniBV44wlR3qSvKL3a39L7/kfVUv/BbH9omWO8ib wdYzRsDbRJHqUNuZM8Ah/J3gd818mav+3R8aNS+J8HxFivU0zWR5ckURupLu1gZZPMKyMV59MKox jOa+R4e+jxkmSVatSaUuaLjp5+v49T9B4s+lbnnEVDD0cLzQdOcZNu2qWjWj3t30P//Q/REf8Fh/ 2jb/AESXwtrOk6HO05a0fVm1NogIyCPMciAHHIxgZ65wK/MrXfiPruu+M7rx9cTJYeK5dbGqQala OJ1R1cFSAydNoKkkZIPrX+z/AAJ4Q4DgbE4qeGScK0XFpX27a/0j/DfxM8dcf4iUcBKo3GrhZ86b tvo76ecU9d3+P3z8Pf8Agqb+0t8PdAsvDGk61pOrQQwmM3mpxtHcIxA3FtqgEf7v5V6LF/wVr/aa t0lnudV8J3DKA0UVrLcRSN/v7odpx0+92r4zMvo3ZRjsbVxkVD323rfqfpeUfS8zHA4OlhMWqjcI pXXL0S/rZHN+Jf8Agrb+1PrWmtZLqXhyNZ4HMqWy3EMm04Tyy2woWIbPOBgN1xX5vfEjx9q3xc1C TxL4zgij157sTSeQ6zRuVBAdWCg8jqGyT619z4deDuU8BYueZUEnVasrdPO997Nq1tvw/IvGTxzz PxSo0sDNyVCDv71t+ySvZXSd73b/AB83NqxUmNwqj1OOlQRsyZTA/wB7Ga/bYr3WfzpGXKrH/9H5 9FxJBIyR53yZVsDhgfWrxtVkjyRuYj5lI6V/0In/ADNSlfYrs8lu6ooHlxqCNuCTX0/8G/2r/jh8 DLm7u/hx43vtFS8JleymDXFpE7HL7STuCt12cgHoK+W4w4VwPGGVSyjH/C+tk7b/AJ/5H6B4feIG a+HucQzvK372qcbtXWj6bNNaOz3a6ntXxY/b/wD2hPi14TuPDnibxfbzC/08Wsk0CGJ4wcCQbRjO 4ZHNfJfgb4j+LPhlqVrrHg3XLzw1q0VyLk6jpm1ZJGzuYMGBzuPr618lwz4YZVwzkNfIKMU4Vr81 lZLtp5XbPs+L/GnNuKuLsNxbeUauHty8zu3r713ra+3XT8PtTU/+CoH7Wuo6HJocvjTT7vTri1Fn PHdafJDeSDATe0kcijdjnIFfEOr+OvEWs+KrjxhfaxcSa4UP2S7Vip0wmTzt0GSSCHUHJJJOcmub hHwmyHgyriK2AgnKqrP3VHTr8/O4+PvHHiTxClg3mNRx+ry5o+85a6W3ttbY/9L6P8C/8FGP2o/A 3h+Lw/p/xMu7m2jIXffWm25RAORHIjjB6fw45Ndwn/BUH9rbZbNb+MDelpQzLeXBOxfQnacmv9hs f9HrhnHYyeMnZObu/cW787n+JeB+lhxjgsPDCpN8iST53svloUdQ/wCCm37VmvaXd2F14zEILNFO tvv8mWFuNu3cDnHGR+VfD3jv4g6/8QtcuNe8V366vqs52xzfZkhaHCIjZKgbshBye+fWvr+CPCbI +BcdPMMAr1JKyduW33N3dtNdj868SvG7iLxMwVLL81bjSg72vzX2stlba+m7+ZwEd0Udoim1M8cV Je3kUsbQFAWCYUr8rZHQk/hX6zBWikfiU3eRn2sXzxmRuQAQByMitEiYzz308+ZiAcAZC44GD/np VDfwI//T8i068ntpGPnRz5j81zNHuPmA5Uj07/jj617R8P8A9pP42fCSeOXwB481XRIHjKT2Suz2 6EZ2mJQwC4JPXPBr/fDPuHsBxHgZ5dmUOam/S69Ln/OXw1xlm/B2PhmWS1HGoku9np1s1tutfwvf 2nTv+Chf7V0ontdV+K3iKaCSFi7CC3SOQ5GADtLD3AIz6ivAtY+PPxg1bxdD45uvHOox65HGFWa1 LQbCrFl5LEnqTjpnt0r4LJvBzhbJatSrRhfnTVrJWT++77bLumfoWf8A0geM8+oUaNapb2clK/M3 drotrLe+710aPX7n9ur9pqXw/wD8I/dfFbxBcWUikbDJEYIAQAwC+WHyf7wfNfKGq6rqniTULrUN Uv7m91C/na5ury5bzJZXYlmYk/Wvc4X4CyXhDEVK2VwtKo9X5b2+/dnzXHHiln/H9ChTzmd1RWi3 10TfltounmJbmXT7guGY+UN1vcRSFXVuzexFez+Bf2nvj18OZksvCnxD1fTdGkkWd0YpNNGycMsb FcANx1BIr1uJOF8s4qwX1DNI3gtu6/rqePwpxznPBOZPM8lnab3TvZr0T6dGf//U9X1r9vD9qK9M iD4seIYdPn/d3FtNJHcJKvYKAi47nufpXy/qnibVPEF7q2v69qEuu63qhaa41XUH33DF3DMPYHuB /hX+5fC3h3kPCMp1csj+8krNtdP+C/67/wDPdxv4t8SeIDo085l+6ptuMU7692/Jf09Lc9dmJ/KV ZxIroDIYdybc9Vya3PD+s6zoJE/hy+uNKmtpRP8AabVgkueBy3vtHT0r66thqeIpOhUV4yVmvKx8 VHMquCrUsRQbU4PmTXRp6P8AA+krD9s39ozR9NbTNO+LPiaK1ikhWJIrlQ8CIBvTO3GTng44x3rB 8YftRfHHx7o+p6N4i+I3iPUbXUF8l4p7mLc0RwGVmWNTyMjIIxX5/R8I+EKGPjmEaT9onzdLXvfs fqWJ+kDx7isvnllWsvZyjy3s72tbrJq/y+R4hpGsazpN9a3eiahcaNcQTL/pFk/kTbVZTgtg9CAf qM19IaZ+19+0TYabHp1h8V/ENtbafH5UQS4hngD5wAFaPcCOc5bt2r2+IuBMj4onTnmkLuGit2+f 4HznBvivxFwHCrTyWXu1NXe+9rX0t5XXktj/1eyvf2yf2nF3h/iv4ovLWKMfa4VjiV7jPXYxVgBz jkH0rxPxd4t13xpdpqXiG81O9upR9oEmozRTXDs2MtK6xqzEYIXPQE1/ufw/4e8O8L436/ldO1S1 t1s/Sx/zy8W+LXFXG+Xf2XnNVOnfm0T6erf4WOZtUJ86YMqbYwipnBc57f57URgsZWiB3xfeQ8Ed 6+5Py6Em5G/oHjXxf4XvbPUfDfiPUtGns5C7iwlERn9FZiDwDXttt+1Z8fHljkb4q+NYIVtfs32R tSSWNCP4oyUwv5Z96+Hzrw/4d4jxSx2Z0r1LWurK6Xe6Z+o8OeLXFnCGWPJsmqpUG72abs3vazX9 XKl9+0Z8d7pcp8WdfS2mhMV1a4imuZcjDAzMgxn1AHSvFLm5nv3llvry7u7iSRnknvLg3FzliWbL H1JJ+pNdOQ8G5JwtKf8AZdKznu3a9lsr9vz+SPN4o8QeIeNY01ndW6p/CldK73e71/Lpu7//1vMN H1TXNAu2utE1SbTruOZZLW9tW2zW5UghsnuCOo5969Tf9oj40m7iVvir45FusKW8VtFrBChlI3HB UqAQCMBQRxycYP8AurnPBGR8Q1I4jMqSlNK11oz/AJ3Mh8SuJ+E6U8Fk9dxpt3s9Vfy/yvb5mxcf tFfGK5gntZPiH40gjjlDWfl69JFNEcAEs6gFhnPymuL8Q/FP4keKrf8As7xJ498RajZXGPPiu70y x3O08bt2TjjoPevOwXhlwrl9aOJo4f34u6v0a1WnkezmPjTxxm9GWFxWJtCS5WlpdNWe7drrt8rH ntmTHKwVzC6qWWQZy+O2e2eleieEfiP4p8JXEkmk+J9d0sTIQI7DUWgKOSMvu5OSFxg8cCvos2yD A57hvqeYw5odtv6/rQ+WyLizNeF8b/aGTzcKvffTtb+n2Z1eqfHr4yXUl59u+JfjJoJUSG1A1Yxx R7cZwFwN2OpAHPNeUW3ijXE1bUdUn8S+IH1S/m+3yazLqklxqImRgyFHbODkYyOQOnQV4uD8PeGc BSlSo4dWkrO/bt5fLU93MfFjjTM8RDEYjFtOLuktEntfrf53X3I//9fKuvjh8XtU01NGm+I3il7V oGtrqF9UkY3YYFSJMscjBIx2rzV72W8uo11KWS4jt4hEi8JgKuAMgd8DJ9jX+72T8OZVkE5Ryyko Ke9r629fU/50M84xzzilRqZ3WdSUPhbtonvt6DETy9/2eZoCwKl45DEwyMcEdOCa7Twt8UviP4Rh S20b4g+KbGJP3ZW31MosoHC7z1bbjqTn3qsz4cy3PKKoZnTU108n5f1bYnJuM884WxUsTklZ0297 bSV+q/XdXdmrm1efGn4tXMJhuviR4ou0kd2kW4v/ALQrK+cr8+SAO3PFeYy3RvAsc80t0Ydy75XM jgsSzEsepJJJ+tY5TwnlGQuTyykoN2TfV22/pD4g47z/AIslF53WdRRu4rZK+9vu6t2+809A1KfR LmC5029utNurNi9vdWFy1nPESefmH0HXNdcvxx+K93btZHx54v8ANS4MqNLr8yRMi5CxMqkcYHUY +nSubMuCcizfFfXswoqVTvfft/St5npZL4n8WcP5d/ZGVYhwo9FZadXZ+d9b38rH/9CvD8Tvihfx CO38c+KftEsW6K2sdZnX7C4PJTcSW6dyetcVrXjbx5q93HNr/jLxFrMVswb7NqV+ZrViqlRviwFb gkciv9yst4A4byvFLG4WgvaLZvo/LT8726H/ADzZx4rcX57g5ZfjcU/YtWklf3l2bbb+63Z6HCSS m6mNx54h3OZJCUxuB6gDtTZraGdeSW2/cZWxX2VNWjY/Pqkrsit40iJULtUev+FWPs9jM++5hWYx ZaLJK7GxweCD+FaWtoZN3YsSt91nULnO1eFAycUpKpIXkx5CjBwP8+lAj//R8TuGinjjWPdtQYVT 2qkuFLxsyRoFLyM/yhQPfHFf9AB/zQJtbCRzwo0ccMZkikUbJFHHTI4q3bwyRuJlUCFt6sC20Hjn I9wTWdVXhZm1B8sro37TxZ4nsLeG0svEWtWmm2pDvpyaxciCQDACAb8Y56YxxWJqWt3GsXJmupme ZnEksrj5mIGAc+w4rxcNkOV5fVliMHQjCpLdpav/AC9Ee5juKM+zehDCZliZVKcPhUndK2nzfm7s zcOkrGOVnDn5vQdulbNrfXtkDPYahdabJA5U3en3TWVxlxyGdSGP3Bx04rXFYLD46m8PiY80Huns zlwOaYvLKyxeBm4VY7NaNf1/wD//0vLr/wAX+J760ube/wDFHiDU4p/LjSO+1aa6jt1Q9Iwx+Ucd BWfZ61q1kLhbHxH4jtJJQCWstaubVSB/CArgc9zjPvX+6q4VyNUfqyw0OTtZf8Of86P+vPFH1n69 9cn7TvzP022/Dz3Oht/iD41+wtZWniTW7VGY+YW1GW6kUegeRmb8c596y7nxZ4zvpo5f+Eu8R7ra LyF+z6zPbO6DJw21hu5z1rnp8F8OU588MJC/mr/mddbxJ4wxFP2NXHTt5O35GCNVuWvLm6u7q9vH ulAu7i6uHu53K/dJLHOeMdaI9RnVpFjdYfNO5GVR5y7SDkN1ByO1essuw6isPFWha1ulrWt6WPEj nGM97E837xu/NfW973v3v1NweK9ctUt0h1rUmdUKShbx0QA5/hBxWN9ruVeSUybgxJfzPnLE9ev8 qyw2SZbl/M8HSUHLV2W/9dF06GuM4kzjNnBZjWlUVPSPM726ff3e76n/0/FrXX9a0uB7fR9Z1fTI ZgEkg0y/ksovTOFIwcAcjngc1jXt5dXPN7fX+o3SsBHPqN9LfzQjcGKqXY4BIGcdcV/vBHI8so1p YqlRiqr1clFc3nrvr1P+cmpxHnOIw6wGIrzlRSsouT5Uk9NL206dtOxft5dQ03ZcWd9LZvLHlpNP me1nG7GdzqQT9K0LTxN4mt7iFhrl5euTzDeBb1pCBw29gWXHsaxxPD2VY288VRjJ92tdPPf8T0cB xhn2V2p4DEyhFdE9POyenztcyLy91LUdwvL+8unSQuXubl5GU89MnjGT06V0ul+ItcMcUf8AbOpv MsYs1R9SlEcin5QoG7gfTGKxxPD2UVaMYVKEWo7abHbhOM+IMPXnKnippz0fvN3+/wDM+7v2IvhB 488S/FzTtbstDll0TSbyNDebjKl1I5Yuyuf7nlsMAnJB9DX9l3ga0bT/AAto9oyFPs+nxx+W3YhQ MfpX+d/0qczwmIzzD5dhZe9SVpI/1b+iHl2MocD1cwxa/jPmTfVWX9ep/9T95P8Agr/4U8c3WlWV 34fOo28U826G4tEZkhJ38OR2O3v/APr/AJ0JvFniE239nXHiLU40td1rPYpMYpWlAKvI8inLZAHH vmv9Nvoz5fk2bcExeIpKdSnLr8+ny6n+TP0vuIM+yPxAeHwdaUKVSHTr891a/RnFpIskOxTk2+9U csWc7jlgT9RUFu9usj3M8CTsuNpb7y4Oflr+tFTUIqMdkj+JqdaU0+bdstWN4LfUBf2qGG5Ulo5Y 3YGLv9OMDGe4zVu+1W/uZLqe51PVJDcMDO51GdAcdAAGAA6dq8yrkeVYuusTisPGVRdWr+Wvfyvs ddDijPsBQlgsDipwpdoya+7tfrbfqVft9w1qkKTO8Oc7jK0jSc5xISSXwRkBs47YqusM3miYxvOp OH2NtOT3Jr0cPhMNhI+zwtNQj2ikl9y6nmYnH4zMJe1xtWVSe15Nydu13d2P/9XwGS1W3Ll1SF3X fwPv59x/nise7dlVFJY7mAAQ4zn0r/faKskf81kXq0xVSTzI7ZA8Jnt3ZpTINmOm098nnr1qSJiq CBdkW391JJsGXHQn8eaosLJIbO7BT51hYOvzEbj1xTZNVtoL+QXGnSPBIhdI45xCVOf720+/b8eK Coq7F3NexfuViSRs4Qv93HOOcVqafqWoJbpp8sdmqBDHIPsUXmnkEESbdwxjrnPPXisp7mx//9b5 2mZ7WYSShWiYEbSmWYdMg9qpxvHJqjajbR3FpDFPHcRt5wa5i8ogqFk243ZHBI/A4r/fA/5vab1s frp+zb/wVn+JXwR8PweGtQ8M2Xiy0tYorKW6luFW+k2oqiVwdibsAZI447ZIrnv2rf8Agpf4h/aN 0f8A4RpPCl/oVmrGG5+yXyRw3aPtEjicJnoMBR69a/mzE+BGCreIS4s910HPnau01r8PXXdJ3d0r tp6H9UYT6Smc4fw6qcGzcvbcnIpWVr9JdNOrVla9knufk7p9kbSS4KiSUjLQyyKWklO7O1n9gf8A x0CtOUPJDDJNC8DTIrGKRSrRnHSv6KhCKlaKstPyP5knVlOClN3f/BZXby4WKOQZQwZHVwQuPetT z4w8tzbwJDqO0CK6jbLxMONyr0B47VNTCYXFRdPFU1ON9pJNfimaUswxuBangasoSateMnF2vtdN H//X+doZbm5mb+04vtciLm4nZVillYEbdx6k8dTnGKhjl/etJKAu0leGzkDgfpX+9bhTpwUKatFa JLRJdLI/5wnXq1ZOrVbcm7tvVt9W3vcmnSC8M00LBngRVWNU2kgcEnH06+9ZyNGVdGX5zx6Fe5NN q8VYxcrOxL5sOYIRDjajGWVB80pz8uT2x6VXIj++QPNzgIfbof8APpQou4lPTUcLqeWYqHcsIPKC EZVVwVIH5n86bFOIlRItrNAAAC2HyP8AD+lOa0saH//Q+aGtI2t5pi5WUpvYEmQBvYn/ADxVOGfb Mlw0xnYgF/NO5flG0Dk9MBR9K/3scbJn/OBHdE8yecVuAFjO3MYH3OT1x+FV/KlCF5InLg/NJtwr AelZnQrX1IYbu2aS4Zy6S2UYYMsZwR0xkewJ/CtMeWyxfaPMSOZg0MoG0SrnDBTjqKDWDVrEd+y2 V3LZRMBCX2xzkgvMvX5sfTp7Uy6v7VpAssAmUwqh8oCJcgAY6VnPexunaB//0fmux8u7Edsji2eR wu2U4C54GSK+uv2OdHe4+NvhhDMY5S5jliCMJJkWSMjPbAy5/wCAmv8AbTjqap8JY+b6U5fkf4Re ENN1+P8AK6a/5+xP7cvhvYrZeAtGhtC/y2EYRpVwWJjXOR9c/lX82P8AwWi8SXVtqGj6TbT2kjX1 zb6fdOAd8ccgO9fQty4OPWv8zfA6Dr+LFOT/AJ2/xP8AWD6RcvYeE9emn9hL/wAlPwG8VXsWleE5 rRYnjTV4zp+o3AYGNrd5ImdWyMg4TaAD3avwn+LF1p8nj7Wfs0e2Syug9vNIrRvGGUOAoOB36gYr +zfpL1FT8N6qfVr80fyd9EWDXFFeXl/meG6rez3N5c3chdpkBPJL7++ffpWRBH5o3y5aV+WZl2jH YA1/ldXd5XP9KVNqyP/S/jwlYk94kHC7epx70xwC28ZDKOvrXOF0ghnS5jmSUFEfMfltxvx/jUWd rNGqtGIhuGBjd+NczSaszKUr6ItGWOVVUDzHcANnllwO/p0qnI2Ip4WZ+OFHQk+lR7MqLvuY9sqv cCO4j+ZD8i9mPrWjNG5clY1T+7gfIKOSy1LP/9P+ObT0tzOqySYYnbgYAJrSuBZkNEAAqghiT9+v JaSsVD4jDk8uPZ5BKnPLKcFQOlWYZXuIZUcHaDuLetSdNPexLFmNX2kBWTb93DfifyqhMrzugZcl D8oI4H0oLlK2xDLE1qzTShvLB+YICW/KrNnKss0JmEhg3jOwbWxnnGe9BhKVtWf/1P42NRZYWZUk 2xtIVQ7v3h9jWZbvJyY2Uq8nltubDY9QK8ZuyuaOSasTPG5PLERxfMWxlvyqSy8u+s1upW2tveNU cFW+UkZZfwqHPTQzJ7e5kjWUM8ZTISLaNuPrTMXE7vL5byLbjdK0SFkQdAWPb8azAdYQwXhllngL qWKkMu1wVOMj8qkHkQ+avARedp6Gg2pp2sf/1f4zGlvpI5Z4bYi3gX55UG5IV6biaqvM6PhLhTAY wW2n7wODyf8APSvnz0C5HDsLSrM7s6gqjDITA6Cte18jZi4AK5G7PQe9W42dkXT3KepyNbySEmKW 1ZtkBXq4A7jtWIL+6gjhFozQkSeYiwnaY2AxkHrVqKRqWwzgwIizyyzSfNsHGe5Y9qtuw3FlwFb5 XLD5s1nJWYH/1v41ooNpBUKI0OQo4BPrUxjYqPMkKKp83Yfut2xXz57A5JlRjNNIFyhIB6HA6Zpy X6PDJJcDEbLiFMDO7p/n6UGk2rWRgzOb7fasOC3THAArSsrLydkET+XbN1GcRqexOKfQzJCm/wAy 1uHGFJdBtxkdDzUX2a1clUGxXGFVjk5HU1cYtO7A/9f+M67kWBhGqv8AKg3PjC/hTbWNPJSZt0kU oOx2H3uea8c9grWUVvBfXMZcSNdxDaMkCPB6ge+a6Jrtw6QRljuIjyoz7UAZd/eCK5jitLZY75Jd lxdMTucA9u3HTP1qqk97J55kkeVo35LPzJk9M96y5GO1jVmSK9WGRo0iVFCNGOSrAYJ+p61YazvZ ktLaOMSqkmI43fZGwPr6Z4rVKysI/9D+Ni8FzYXIhuY4EK/88pBIqeoOOh9qntbkNLtcNskIU4XO fqK8c9F7noHhDRYrnW9MSGVkuBqEcsRiXMu1XDMB6BhwfrX7OfCbTIm0m2u5I7uC6nuV1mW4ZjCJ d0SZ2/7rI1f1Z9HOm1XxdXsj+cPGySli8HS8/wBT+xH/AIJMaFZw+BtLvVhmRNY0MT293IoIkkkj gkZmx0JM0nXnbivsz9u/U4NP+DetRhl84Wx+zIoJLn/V9PXcw4r8vzSmqvjJOlHrWX5n7rVqOn4Y U5y6Uf0P4WvHhSXxH4nNxKTPrN/O0cVmSYrtX6tKCfl3eh61+M37Uenta67ZaVNd3UmNPuLdlkTD J8yMyj0I3A/8CPSv7b8TmqHhxiIdqdvwP438Lv3vGl9/fevzP//R/haa02qwZvkViiqeHbHtWlZW o+zosMKtIWIK5+cj3FdL3aM3fnN2G2jWPySJUdBvcDgRitKzVgyoJHS2U/MgOBIR6/571xVPI0N2 0uv9IKSxv5KKXEgX92vbAP8AQVtRQ2EjQ3CxSNPI+I5d/KY5wB27V5tUPQ6mKa+sbiC3jupLdNRw j5crHJt5APr9K7RLaKaxkF1Cr365VTbpuWX0+bt0H515VW1zoW2p/9L+Q++0ibLTSljbNCoNqTlC wPIYdwa1vtGtT2dvbm4mjsVXYLMNiFQOV4r42Wx0GlFex/Z8ahEkjRKfvKXMp6AEfj2qnaM1rDKv lrHGWJi8oY8tewNYgX4JHkiBjDTRZzK8SGTZzjnHTn1qa7gu79YobRxFFDlpUk4Mrdhn0FA7N7Fn U7FJnSzMk0dx5CNL5DbR7fMO/FQXFjqs8kU0ySGzsk2XMkY3hxnC59P/AK9JrQUrqyP/0/4ybqOZ LD/QblY5Wbcli5PlqxHzN+PTPWrsNvM1gjeaj7hvdGbIDADcPpXgSVpGMF7xEm4RhRbw4IPCHHln 1H+e9UN6ibFzF5brGdhI+U8j8s8UJXdjRpNF4SQyRgrGhkiX5VAxuxWbbwy3V3++uCkY48jblXJP 6VtbSyMuljemtLS2heaSMP8AZx5jBDkYHaqmuWMi+RdQxnbfyoYbQ/8ALJWA5HfA5PNNeZLaW5// 1P4xoSNGumS6u0hi88RPMrhlIyAQD379K6xfsDtBcCf94riaFRlScf3q4aeljn2GXOm3d5O/22SH dcnzozDIJsbiSAfQj0PNQw2EFjcy77qZ4Ljy7eW3ZtsTBc7sj3P8hXZTdjBu7ua62Hmefbq8awYM kTTsE46gZrx3xOkRkmTy5A9q2351/dkHqFPp7130XqJrQ4u0zLcERpGvGFLGvvL9k+5stK8WG6s7 2yjureFml0yVB9mnMqwqXbszpjgH1PWv0rwwlbjTBWdvf/r7z5XjqF+E8WmvsP8Ar5bn/9X4C+CO srD498D3E8Imhtdet0keWfyrV/MdYwzfQsCPpX+gJ+yHeNqPwl0O5ikLwm2S1iVDvjXEaknd7+/r X9f/AEm6Dll2CxPlb8j8c+jHXisozLB9VO/6fofAn/BW3TrgfDi/1JLEk6Z4euYCwyplmdWZOf8A v3+Zr+P/AEKafWdO1K6ii03+2GE06xyZjeJLgsWUAk8gHt1xX1f0YeaXC1fspJfm/wBT8C+ke1Hj H2Vvs3/Jf15HBrEB58TIPMuyqSzzH5wU6NnoPp2p1skmnQzs4uJilykEUqQl4pd3VgR6ZHGOx9K/ q6KfKfylJtV2Sz6hcrPHNFMs8UTbZQi+Ysn8IX257VVltZ9RT7VaQu8iyEFNu2Pr3Pt6VUPiNru1 j//W/OS5t9VuLVUt3VUt5RDEpwU3Ac8dxxyfcVzNtHfxateW15DGyRNsVopA1veepK9VwRjH61/t Af48wdmXDNqd1dAXUe2KHiPcPkA7KPWks9V+y6pdWtxDGjEIElY7ccfMPY8/pWkE/kbLXYsXM1hc TyXbeckVs37xwMKV7nJ68etWI9GuLtTcXaXEccoDadFKAu9AcCQ+x5xitAHpomsLpuqyyX9jbWjL zp4USXLPG2EcAdjn0GBWla397PbqyXcCbLVYwsXy/aNgChf0H5VV3axMnZH/1/zUS/t4nddQjkkj mfcxTHmDk5AB45/pVOW8tpZW/s+N7TyWO1bhdwIHTNf7UH+PP2bG1bTsIYrXUpUcz2u6WVRmMNnr jHXjPArIc6fPcyR2Zle2iiIkkYYPmAYwD6Zxz71cZWViTWiLDTYyJx5cModowv7wlfu474FU9Qmu bv7PK1wRaqeYBx5hAA57j61LdzaCSRbOpxDRpbW2tYoAoCSsF82aUAg8E8jGO1QaXLDFbpJbztcS zYY2zkqUUEZOT9e1IzcbXP/Q/Na/hRpbuSyhjjeaQMXORHHxzwP88V00cJ0+Cx00X9ldSXNubuVb Zzvh5Bwxx146ZNf7XR1if498l0NEk9zq8+rXOqST3ItxAzNtYtsAVQwHso59qyb37QJ5XiVit7/r pQdrhuBk+nH8zVCcGihaafdPcTRKBFcQzGMSynasihQdw9Rz+ldC02oLLauRZJDbMpup51Jito1A GQoB9AP6c00ruxzz3Kj6heXU9pNf3rXcFvJ53lBsIFJOFH4Yp93JFe+RPdOYrWO4Ej2qMQWGeCue pHvW9raHNJ3Z/9H85Zjq17O1wUN7LasBDFGm+SSP+EtnjjgHJ64pLjUbhbW4tZIXtbmF9kcdyMSQ Ejk4Hav9uD/GNzd9C7a2lxPHYQaatlPJeIV1G+kcxJGRztQkc+9Qx20sbXkFrK1yzSBb2AjEaquM bTjpjJ/H3oM5S6slS3sbW+DQJuibDojnOxsDP61tF5C7yAKVlBjZmUE7j6e/WgiMm2UraG4Mcy7W gdSQjNyV98e39KqxnSF+zWV3pv8AaNvAm7VZIbkxTu7NjzAOcYBGB7d6Cz//0vgK6tL+zuLibw9q lxY6DJdx3k9vesgCRDAaJTjnIDYBzjJ5FdOJdHvWtZn1iS0sm0ySfMsAdribAMa8dFPPp9725/2+ itND/GJKDmlJ2jf1sjkoXuppLdNNmmkEMh8lISRIT7+3Oce1MvLXVpD9tdDBOWPmTxqGQkf3scAn jrVHIZcVvdXlwVuLjmPox+bvXR3OnWsDotx5MsiQieJ+JMjHO1gCATnofSgUnaJyMsiS2s95JaSf ZbWdHYP8qnLgKG/EfpXX2+mLrF0b0Y03To1E0CKxDzFRnywT2PTNBhsf/9P8+IkkfWp5Gie1Elt5 JVQVh2AjGT3J5575NT3lxZWZnsYoHkujGJI9QUFVIbG6Mj/Cv9wD/E8oQ6PeTXdrCJYII7gEzXNw x8mA4yASM12NgkGm2kS3UzOXcR3D2yb0jPPMft9famld2Jk7IyY9F1aWG5+yeVceZL9yOM+cIcjL t2BGfWmR2MmqpcQMY1udJjZfOlbZvXj5Afw4zSM5SuYNtp72txE0CzTeVu3WwZn4PU+tbEU09159 lF+6BjCTeXGFeMHv9a1gnYbndWP/1Pgm7hWySBFjKWccAGZTuVuNp/x/xrOhaa2srkaclvtlTa7z KSYweTjByMV/uQf4hSldWRqW0euaxHaPfXMUGk2KhLS3EoYXZ5+YDg8c/TNa91qFrcS21lDb3SNa ruubyQItszjACKM7uAOT0+laRbUbnPPcXXtRutRMV00sUrzR4Mdy2ZWWFVXcBxkABR+FUbPUklCm 8mt7OCIBEUIIllI9+5pw0ic89z0LQJ3ic3cF0v2dkzGu1GEhODvYEZBXpz619s/shXlzL8ZfDpE6 iYvHbxLIhEbKzh2cH+8Ngx7GvneMI83DGNX/AE7l+R9P4Y+74hZbNf8AP2J//9X+6z4VzS3HgfQZ GnNxu05cysMMWCKpH5jrX4Z/8Fn9Kc+Gorm3nkjM9zbsu0bvIYXMQ+76YU1+/eD8lS8YsKv+n3/t x+B/SVpur4RY238iP5ztR3S6YumeYLm4tAzrJ5QUyE8nJ9OOOuBXNNDZW1lHHdQy7gvmzJvJbcR0 z04r/WWlsf4yVkc1b3/2OSaa2gzvIj+z7iUxnr9QCakNqmoXAaaTY6fOp7oT6CtTzjVfz2ttP0Rk +0oLiaU3gQKyh1XAb2BXgcn5jUqvbWINm1uguICCkyE/vByTvBPuAMe9dBEnZo//1vA4ES7uZ7ks qxM2ZJSdo3HrTbgxW1xtDeaqYYhl3LnqODwa/wB77H/OhKfU99+FH7U3xx+DtxE/grxPCbcGJI0v We3i00Jna0axqRwDg/LnjvXtXxD/AOChv7SXxGE2meIPF+mSaZNpyWbNFpAuLhpF+8ymTAAJ/wBk GvzHMvCXhrNOJI8TVoWqJ3cUt5d730T6q3o1pb9Uw3jVxXhODJcEc/NQtyqTe0dknG2rS0TutLXT s2/iO9+z3NxLfoW8+TJup5G+edzyzH0J9BWBtiEs7ly7MEW1VV2gDB3E/oBiv1KnBKKPxyck5Ns0 Fsb+SGWWe3nhiiAPmtGREAxwrE9OTUclnbxQxOs0lxd52uRhbdR7Dk5/zzWpjKdtEf/X+cbm0IMN w2FMbcOCN6+v0/8ArVSd7e7kQxrhYXLJKVwz+/0/xNf79wWp/wA25cMVvKF8+R8Z4VSRT90CzFYg /lIOC+AarkVrA3bcPtczyrD9+1STzdjfMMgY6VZEEkmJIYGMOcSTBfkT2J9aTgknYcJdUdH4f8Re IvD2oW2o+HtZ1LSLuzf91JZXDQh153IVBwQc19FWv7XP7Suo6Vf6Vd/E/wASW+iW6i2s4oZ451cY IYSLIrH06Eda+Kz/AIEyHiWtDFZlSvUjs1a/z3PvuHvEvijhPD1MDlVb9xK/uO7Sb3as1b8uu7uf /9DyzxL4j1HXHGqX97c6rrEkSw3l21uIWmYOxGVDEAAHPHvxVTRPEvi3w8x1HQdYvNHnhnVnmtNv yyEHbkMD1CkYGDx14Ff7vvKcK8D/AGXyL2NuW3lb+td/O5/zo0c8x2Hxn9sUqjWI5lLmW/Ndu/bf pt8j1+D9qP8AaBl0+DTtR+KWvXVtZq0cMWyJVZWGApODwPb/AAryLWfEOveJ9Uj1DxFqs95dND9n VpX2xR5Of3aDheSTx3NeLlHBGRZFVeJy6ioze79fw/C/nuezxDx/xHxVTjRziu5wi00trP1317Xt tpod9ovxq+Jfgq0h0/w/428T6dFaWotrZNO1BIGjVenLIcnoMnnArpLf9pj44KstxcfFPxRezzQl oRNdCJoJCB8xKKM7emMDNceO8N+GMxxMsXiKH7yWr82/LW3y0PRy7xd4zyjDwwWHxL9nBJRT6JaJ X0vt1u/MzYv2k/jRM4t5vin4na+ujlPNvGkMRX73l7jwD6e1cb4r+IfifxHJfXHiLUbrWbgqjCS8 l+1GJ0ZSX+YHGdoGAQBXdlXAfD+S4hYzAUFGqtn66PsjzM88SuKeI8O8DmuIc6TavGytpt56W01P /9HwqPUHuFWacKRM3/LKMRxDHI+UcY4H+FejWHxQ+IGh2RtbPx74s023kUrtstVFtAqEAKqpsIGM Y/Kv938x4fy7O6SoZpTU4J3s9PxTuf8AOjk3FWccNVniMlrOnOSs2rPT0aa/y+bMzUvFniDWHjfx Nq1/rsxt1VLrUbo3DOFyF+UnaB1/GudstX1PRIpv7EurrSmaYTM9nIbdpGXBU5HPBA6dMVqshy5Y P+zFSXsLW5dlZP8Az19dSKXE+b0cc84pVmsU3fn63f8AwNLbW8jsW+Jfjy+tbhtQ8YeJb6O5RYpo 7jWZWVNowNqZwv1AFchdySPKt/EdzI6sAsuyUsoxuJGCSe5755p4HhzK8qjKGApKEZb26/1crMOL M6zmrGvmdZznDVN7r7l5HSyeMvFp0mCxtPEXiHTLW3iCW1rpmrzWFtEe/wAqEZ/GobT4i+KrFUt7 vxNr94y27RwifVJdhfs0gBy2OwJrilwTw3KTcsJFt7/1c7n4k8XNqTxsrrbb/I//0vLpPHniGXzL ga1rRnkUR3E76lLngchQDgAnPQceprmW1S9uWEMt25Mibf3p3O4Bzyx5PTrmv97MFkeW5VHky+kq a62W/q93vpfY/wCcXHcRZrnFRVMyrOo1td7d7LZbdNywZZrC0d4o/ObH7x4jiRFJA4596jstRubC 6+1W99JazvbNbFo8LMwYgn5/vZG0cg11YjC0cXD2OIipRtqmrp7bpmGEzDEYCPtsLJxqX0admt9m tjbt/EutRRzRprWpK11tVZpNQlZ0KnIIJb881LH4l1y4lSXVNd1O4VcwNAt9JDbuvT7ikA/jnpXi LhLIqMvaU8LC68v6R7s+POKK9L6vVxtTl9bfitfxFkj1XX9SgstEha+k2qsMI/diQKoGxWPAPQfN X1n4P/Yy+OfiCz0/V4vAl/e+Zp5ubZ4nkEEfmdiu3Lg56gEe9fPcacT5RwxgIyzSVlPRRvv6+X9d z6zw54Nz/jPMJPJIfw7Nzs9HfZefXy33tf8A/9P6Wb9hz9oCKKG/tPA13hZDHcWVtBcp57ZAypfY vGc4HPFfuD+wl+xXYeF9Fstf8fW+rW2tKVmFtNc73jKAjZ6AZycHPX8v788YOPeHMVw1Onk9OKqy dtPPqfwR9HXw+4uyXi54jiCq5UYx0un09f6/E/Sf4r/EjRfgp4IvtbZkk/sy3AttPDgzzE4jQbR3 LFR0xz2r+Vf9q39pnxf+154sl8A2OhanCllrMKxQ6dbSX0c0iSkK5ccBcuuWAxwCcYr4f6PHBssX j8Rxfi7qnRTa7Pv+P5HsfSu45XJhOAsB71avKLaW6e6t93d3va1z+gb/AIJ4fDfXfhh8K9L0XWbK a1uPsCJcJLGy+WxGe/Ocj+dfXXx38N3vir4aeJNH06OWS9uLIrbiFcyEkEEfy57Zr8b4xx+HxHiP WzCDvT9sn8k1f8j+j8uyvFUPCmjlLX776q4W/vODS/E/h++Ofw38b/Db4g+KrXxdperW19puoytp RunZILiMynaVB4b5cfK2MbueevgUl9dXFulhLIsscc7zquwF1dznOce9f608C08rzDhnBZhhIJp0 4626pWfnumv8z/CXi/E5zgeIsdlmOqSTjVmmru3xO2m21j//1PEobfyoyjuGkJJc/dDc8VL5to0b QXKFpIRvtgEGwYI4z2+lf7+ewpz0krn/ADT+2qwleLsyxLrV9NbT2k1662lyy77NYkSPCdCGA3D7 vryKxTZaeEdZLWJhJcR3bFwX3tGwZc57EjkdCCR0NVRwWFoJqjTUb9kl+RpWx+MxCTr1HK2mrb/M 0Hu7e5SIJbweZbgrEIoVVlHdVI9ar+XJNC0lthFdgsjyExuh6EAdyB/TmumEIp6I5pSlLdkt0IAy ZLfaljCu8koZ5ccZAwCP1qs0vk4Q8+bjBU79uf73pXSQf//V8BiBhmlz82GyDjp9KmZRMzsRhj1J 71/0IH/M+QyIsQweT1PcLVuJUhSMDPzLkM2WOPXJoApmZ/NwEUlejjgqKt3Ny0scXnpCAo2AogQt 0HPr/wDXoKi+UhJMaYUFwf7vIWrsKSpGJI2KdtobjNJxT3LdSVrJn//W8WtNTmt1kVpjFvPlsytg Pk9KsXUC6ikkXmWpW3Teeiq+McDHXPpX/QZKmtz/AJoHWqJ8tyutx5cXklvLRRtEYGF49qjt+bgs 7fu1GVbH3vY1g4R5tjanUnzrUvJM9tJiI/I3LKPu/SrTz3UVvFLG80SM3yIrmNe2eM0+SNrWMueb d2yCNHufNmDQx+Wm5icK7e2e/wBKoGeWUuolMZAwp9celJxSjoSpT5ndn//X4z4deIYfBvjnw54l 1OG6lj0LVI9RmiQZlmCEEqAT3r+zX9iv9rz4T/HXwLomj+HNcjXXbGyWJ9PucQycDlADzkYPUcjp 0r/Tj6XPDeNzPIsNmuHV4Ur3+V2/wZ/ln9BDiXL8BmeZ5DiZWq1WpR+5JfjG3zRr/th/snv+054Z t9DTVY7JredJUEr+Vt25BAbaRhgef8ka37KP7Nl3+zh4RXw293HeLl/MZJfPGCflC4A4GPTua/jK nxlVfAj4Sknbm5uvR3/4B/dmX8AYfDeI9bjePxzgov7lE8X/AG9/2uPhb8MPhv4k8Harqrv4g1TT HSPT4k/eKWzGoPPAJOeewY9jX8e/iK6s9Z8SajrE8hmW9u5LppF4b58kADPAGQMDsK/tz6IfC2Ly rhXEZ3iVZV5JR22Sv67cr+bXRn+an02+MsHn/iPRyPB6/VIWk/713dfJ3T9LnNPM6vtQvHCudjEk Ej0NR/adsQjt2IHTbjg4P6V/Y/LE/imbdrn/0PIhFCoVixaTbkspyFprSJlY1YkscD3r/oNlFdj/ AJnKN+bQSRPKEjSDBjO1lxgj61TaXZteIEhxlj/dq7dCZ6SFgdXS4uJS+4fLAEOFbpkn9agF1GcJ K7RxudskirllGRyKq3u3J1bNGOOzWH/R53IiP7uVvvPjuQfX3rNlkkZ3R+Cc7WB4asIx0+Z10ZJX Xkf/0fAIpky8JOZFfqDwa7uy8KSajpX223vrdJ4wWNnK/l/KBncPU+1f9CcbKN7H/M9yc0t7HCxP MZVtL1NtzGGLOsJWPGeBn39KsSRRCNJSJVlVisis4KY7ED889etQ0TLSNiKRC4Pl9hwM4H0pII3+ aLyApI3tJ6+1BkSDaMuiAyRjABAPt/Sq0FvLkzvGYXkH3TjPtSaurFQ+I//S8KtRP5k/mqAqKDDI Dksec5+n9a17HXZ7NxATlZnx5oHzDqNvXv6V/wBCFrbH/MxKet2OuY7p9SdLp4o4s7PMB3KuOuQP T2qg6CV2SNCDF1kIxu+lY0t2byn7quVlMzlrd8bR8wdex9KcyXkAVIRkTZVmDfNj0o2mU5vkLVuJ Jfl2qJV6qxwMgetU0lnLtuVnVDu3qvyLzjGfxrVuxhDWTP/T8Qld3dvMyVaPjbxihRLbPau0XmQX COGf7wiI4GfTPP5V/wBBtR2St3P+Z6lJuVmKzkuDEMop+bB5qzHdyRRukYVlfBJZdxBHoTWl3axk 27laITR7ZLsLErHeqBtyAZPI9KZNLIWllhdGQrtjRu+Qc0Nju3crW8k0kYEy7GA+bBOO9AIXK8k/ ezirh1RB/9TweB1M4DplR97HDVpytbBCd7QyZ2Lzw4Pb61/0Irqf8y10nZlFbfcu5Gy3Ud6kS9jw kflkFSVkYg/NzgcHpQtAk7Q0NBlV1ygB9+9RMI1fE5OxlwhzyGxx+FKf8RBBtU5MZamXNzv2upcM jYwygKF/pTRsbe+GJBKkDIz/AJ/pUyWw6bdrn//V8UDfNtKZB4HFT27zRsdsjLED90ev+RX/AEIH /MkpseZNm4btpfkkHGaqxv5Fxg8lhlXxlfpQ7FRk29RJFEkjOD9B61MIYHjDKSko4KuM7vcH/GhL oixtzasscJgkUu/L5U5TB/rS/vbYqJW3CcE5xwQCR+HSgPI//9bxYlIT5iZKquOmBk06N/NBbb90 dfT61/0IH/MvN+4idXYkMf8AVqNrL1/KrL2i373Aslbyo03LG3+t2gAMx5/zmgwW9yhNZLGYwLmK YFf9Wm4NGf8AayMflnpSLbTRvv3D7vAz2qJRu4vszRO0ZWHMZkiwyl1d9vmAZIqhdyJbxKm9iEbK K549z+lLl95oqUrpM//X8fhMN1DCY2R3KZHTAPNZ9vE3nva3PyxMrAzBeCcHHHX0r/oMnFJXR/zL Upa6lFNPkt2aNXdyOQWOSPxrVtBMsckWWAfrnocVny2dzoc+ZW7CMEj3xq2WPLDHP+eKZCskS7g+ WLfjiqcWtDAsLLKh3qNzL/DjAJqa2s5kneW4DQm72ybG+4OMAj8uvtUkyP/Q8lkmktJZIlmaVpBj aDxt7ClkkIs2S+tJIb55B5G5+HiK5DY9DwRX/QO0f8yUNG/QzWiltvL+cEEbjtPA9ql3GWQunDSD DsON2OOaZA/yWJOwAbRl6kumWOONmlRQx2JgjOc9PrUx2NZWbuysJzlYtwyBnPQmlcyNLuiIaUKW kwfvAA5/lSkr2RUXypn/0fGIplkXzI9yluCh4ZTUAadZkeLG9XB5GQMHriv+geOkbH/MzN3k2a1x G8zAyTKASGeRQeD3/wAisl3bzCjsWVeFYdTih7Mqna9y21yxhRoYwpVQvz/ec57+lF1cWdlPCHxI ZABMQcRqx9D37VEFZnRN6DL+RrlUSCMsE5B3bdvHPFVI4riUgMyxeX03cbu1OTaI7n//0vHltEtI GncEyyNsBHQj1FZzySbWh8tTGxysu7Eyn0+hr/oAtdo/5ootqLt5Ekm5oAEG2RCOvANVJvLiSKNR nc5MjE8nPOAPrn86cdHYKjUlc0gPkjHTjABqvK7QXKwqvyzxktKoBRSCPlPp68+lKe9vMiKSJ5Gi icKWBJTORwO9VHbZIvlAtuPOOABTvZWJa95H/9PxC3u9txMYLkkw4Eka8NGSM/1ps7PIN67iFOcH nNf9AHkf8zdNEUckNyxDoFPTCjC+nSrMcQifaPutwvtSirKxrJ3ZHMYZ7hY5biGHBWJW+6vAA5x+ tD2kcDskdws6gZ8xVKqT6DPNMRC8cjR4QFG3csTxjpxVm3khgdBKqzxhwrxNxuJGMe31oA//1PCr ndA0RgdZBK21kTIePOPX+npUz3C2kbwyiJ47jCS+ZEryE54w3Ue+Ovev+gA/5nyvNA0e10woZd6f TtUH2klWMzYYnABPSpkroqLtche4t1kjcsTlvKI5CkntirhijkO3CZVuqnOfT+tTPoOGjJFSKznc ZLOfldS29Y+Ow6D8KZJER5jBvlf5mHZqxUeXYrmvFn//1fn1HYMGABVT9w9600tXVVnkYRrINyJj OQfSv9+D/mibtFIiiuIEe9P7zAcJGGwABjJJHvmmQy2sJkYF1lCExbANpOe9BBFbf6ROIwqK23Mv PByepq1cotv8vG4cbgOCKi3v3OqMkqbiZqBHD7Q5bdkAE5qZlYjlSIyuCN2Cexwac02tCaTs2f/W 8Ma60KIrFaySWytahWjvpftMzS8Z2MFAH4+h5qm1rayTmEiRgwDNIh2OMHPX8PyzX++0vhP+aqLX MWILO6u5VgRkjbYR9nGWeQ8bdp/OqjwvaXbW9wJIriF9uD8roR6j8/zpxVlY1ctbj2gumvlNqBOV XfMF5UheScd6m+yG5O+JTC27d1KopB/lxWTjema8zVS6P3v/AOCff7f/AMIfhX4dsPCnjzTzaPpW yzv7yKASvJLsCCTO0Bh94Ak5x15zX6vW3/BUb9lUzS20XiS7VLePdKxVdsWOgwDx07mv86vGnwgz /NeM8TmGETdOfvR7Wb0/y8j/AFg+j742ZBgOAcFleLl+9ppQklvdJJ3vb5Lqtb2sf//X/pa/aS/4 KD/sr/EH4Z6roiTX2u3eo6fNBplg+mhmmkKHYN7EFMkDBOODkZr+Vb4iDS5PF+qar4ejitdNv75r uK0RWUWysiYQhhnIOc5r/Uf6NPB2c8KYHFwzJNQla3a+m3yv6X8z/Hv6YnF2ScU5/gquWtOcY697 a79ulu9vI4mMIMkEDLfNjGDV5IrO5WaISLCyISJHG1Tx6/0r+qbH8ZQqcsSpbL8oEa52HAcjDH61 dnkDBAwjAVcOu0fOeKcI6WMXuU4xGG2bMKSTtXjOeavzT/2bb2iqrAXgdSXwy/KR0z9RVOGtkVGX Kj//0PB5HhvpI3Ztnk24RxI24HH930+ntWcpRXJt43kSP5t8wHBHcV/vwlZWP+aqD97Uiljdw11i Rzv+dj9wdeM1nySiYSKQy/KcBOGB9qDUjgJER2ZdwcYPBzUE4N2Qjsf3X3Mcc9cE+lBUPiRLFbnz Ad+CPvBfunFacRnS4EqzIYYx8oK7n/E1lPc2P//R+a3tJXufOa6UgsGAKllA7ge//wBep76K3hVR b3GJiMPDtJjfn7xP596/3wP+bmLsyssOYXXtJww6e1WWjzblIZWLQxjzQmV8vPH5dPzqeVJWKUrv YR5JZLRI1LxPFwrIQsr855qErMwk+3XDApDuVrgnJxjCfXnihRs7mrd0l2MO9hduVBCjowPzVfsi 3ksUk+bICseGGO3+fSmla5MpaaH/0vmQyXKiXM0ssksm8uzbscYx+lR29pIX8ySQBt2RG5wrDFf7 3ON2f83fPZFuKdYFkCAxlxtlwOoJoaATRFgUi8nMh/vyZwMf4fjVJW0IeruVofKRxhwxP305yvtT msxK7N5mMgsAvJGKBEsJij3HkOp2LkYJFUpvIQyyl0QxkHaTgtn0+lFjePwo/9P5liUGzZ4rh3Wc 4cHgEY5UfpVGXTxDAjxqyxn5UyckYr/e9q6sf834sESDyzPO/lwjAOSQvPIP610EiNNbo8F0sQB2 vHKCFZO4z2J6Vk4uJvF3RlzXE0IH2Ozt5SymPy2BMfIx9aqqbua2EMzqGjPCjLLHk8hfyqTSnuau l6VbX0kiz/PcRRF4ZZX2LHyoOfXjPFSX1pFDIbaOCNxbR+dLMqgkZI5b8SBz6gVE9DU//9T5og+z TzfapsLuPzMi7ehOBX3l+wBLbar8eSrQwQSWLxW9uG5a4Z4lPmADptDqOP7tf7UeJE3DgnMbb+zZ /hf4GRU/ErKYv/n6vyZ/a5oAfT/DNoF3sltp4kUyrtOFXr+lfy3/APBX2F774g6HmeNreDVI7S8t cKwkMsDyBvUbSmB/viv84Po+ty8UITt9p/i7H+pn0mHGPhtXpN/Z/KLZ+B/xhngttKl0+1vpRDFZ K80LwgoJBICQp/2VG4n296/Db4x3P2zxXqEo4lZi8nGBGHwU28dOuR2r+s/pS1OTw7lFfzR/NH8w /REpv+3sRN9EeJIRLkK2XGQ2erYrKuJHSREgb5hyVxkYFf5eyd5O5/orGTvY/9X+PK3bz2jt55VV 945chN2TxzUUSt9pninKoYpCqbWDI4zwQRwfwrneiOcivLR1aN3LtHHIHPlx5cL6r71bnRbmEjTv tDKD8rXMfkXOPQrXOBj2q3du5ZI3mdmCtGg3MeavXMsLSmPd++t+ZY9vIJ9fypN2RpBHM3U8wuZE tVYSxKJTKR0BPQfTHSuisLrzoNrLvKrh2PUnFZOTejOjk08z/9b+N4W/lvNKFBDnBCnoPakaA4cG RiuNyMOfwNeOVD4kMhh8wyRPlWVQyBejDuc+1aG754ooYxCm3a6n5jJgevrRsbrR3EueLKY28iG4 X7sbHBJ7fhWf9sKKqMNzjBZwMEH0pJ32Bu7M2XWU89YrgyIrSqiyqN7Nn2rqoY1by8MESQfecbQP qaZhL4mf/9f+Ne/spELPkMu/GOwJ6ms9bGdZNqYCgbg38OBzXhTetgNS4tI5I47mNnhZIMXCE7o3 IznB98VhTM+8qJSq7N3PH0qBpXdixbNtgRGGfUlcZ5pl6Wmt2WKeaCNHBdYGKtLjp0oNVFIkh1C5 gBmnmgijEW1sjY3GAPx9aSOU3V23yo6CL5yW2gfh60G1NH//0P40ZIpI4JI7e5mW3kGLmJCRG4HO GHtWZbQwqiGFw0JYkooyVB6//qr589XkVjWeSGYOFLQrAgMTqmWm55UjsMZqRY45gxd9sQAJRhy4 FaTTvciLszNuoLm6kk+eEQswSAA846ZNVDpbR3EbSO/7kfLtb92/1qpaI1i7lxZfJkVvmIJA2Lyf c4p9+qhC0RmZW/eLmMjOOuazk7sUpcp//9H+MFJJjbz3Aed22BUtoh8x98duD+lasKi4SIF2JUYw Tg/jXz56am76la4dmK28kQXsRntUrp5ENuUHmRowBLHJTg4NFuhpdIsWkETM8vDiQ/N2x/hTpbb5 SsIaKJOBEMjcM9jWqSUdRcytcS4bMkUakGR12KAfmX6+lZE5uYZprZgVa0ILF8dGI+6e9WNNNaH/ 0v4zrpLiWNJ2HCxghemQBU0mrRJDZQCOWU2xLNAg3K4Y5KgfnmvHPYNi4gsUidYLZGv7i1M9q4bP lEclWPYfXmsD7ZKlvGtxCsd2FBkWN94Q9+etACR/6ZFG0ABkZsCSRCGJzg44qxP5dhLGUYgyIEWP buZnwc4PvzQXPckDyZ82ZTt6Ky/cc+9bIu08lVIcxiPBA+/x2qlF2uQf/9P+NJpbS7tXeHzcCd0l 89SGyDz1565/KpbJS5mmBlk2R4VUG457HH5V49rHpNe80erfBGx1PU/HkE0921vZKEXTpY/lCuWA kWQdTgqDx05r9qfh1rVlaaHp2m6g++7tj9kWHYSZd3HyYzleCcDplq/rj6OsWqWMf91n80eNDUsz waX88V+p/aL/AMEvvD50v4WaNZzb7OWO2ivIII8qkcSpGuOenCKMe9dJ/wAFP9ak0X4Ma/qC+ep+ wTS28sNuZRCBG4BIH+0AfqK/IqM/rXjJ7VPet+p++8Sx+p+GXsrfDR/9tP4k/EMq31tNfaZezzNc BLlLmdgLqXagYkoRkH5XPHHFfjx+0Nrl9qPjbULaztoru3jM0tnczv5t7NGcKqlMdTtz36Cv7V8Y n7PgCvHvFH8Z+Db9rxRz9pM//9T+Ga8NzBckT27W0pYtJFKvzRk9Rip7S9aK7ilVSm3q4GRnBA4r WbfO7AbQuZ1afypGlllYGQNyAPStaxurOBo31ZpYd8bvCscO+J9nWuOrJrQqCTep1oewl02O806c 3FvMuHLxeUYG5BTHXt39fas+0822vbO6VFkWGcNjlinbOO/Xoa82o9zWyvc+k9EvvDFumn6XrmlN dXV86z2erJ840zzEB3SxgZ4zjA5612cXhI3lrPe6Bq1hf2VizfbIATHf2+08kxnGAeMHnnivKkpu o7vTp5GjcIwu16n/1f5ONXsLuwvfs9xFN9muV8yGd2yg4zye3PAFUo7hC4iLHeo27B1+mK+Km9bH copGnfT6JealarYWotJrbT1GoBywjmbB+bJ4JOO1V44/OkjIl+S4YrHsG5Wx1H+fWoHZPcJrqfRo rz+z5ns1uR5d55B8szgkAg46k4FJZXkMm7fNhXXb85wDkdCaASS2NKxWe0cyzXNvd2JBkIMm2S3V TjBbuKnj1ia4juNPtnkiiuHJEfKhxnrg9R70W1uTNaXP/9b+NvUbSJnBgO9ZE2xgDYW6nd/KqGla npwc6dcCaO9yXRkjMsLr23enSvHsZQVpWLLMjiUoxjEbZLEbV+tc5qD/ADS3STC4hCgmVT8p7dOv BoNJNJampbI0QjJZAJIw2c5YZGRgVIqQ2cglLSF2JPI+UCgwJJ5BPa3F7CtwzRR5aKPLecFOcBM8 n2rLnurq6hS4N7d211BiI2k0IVTGo4wTyD24/rQYyd2f/9f+KvTNTtbcxy3EUjMt6Cjqn2k4Y8sR 9Sa6m9E10z6vbZe3RxbmfyhEX4JUFQeDgV58Ohx8y5bFu3nVrc3M5uF+yjzSI1O0diSPx/lW5dQ6 fNp9vdCSK6haNJmXdskVmPA2nBzXZT7GZdlWXWAr2tlGIYLEwzRxuQ7nAAbH58CvC/FrTEtvuC3l n7K/zc8DAGPUc9a7aDZpL4EcNbXItyB5ZkeNwRzgmvsb9mKWzg+IOmC4tftWnX8LT3bibyrmGVXh QADrgBsn/dr7/wAPKro8V4Sf9+P4s+f4vpqpwviov+R/kf/Q/Ov4e2qWGqaHqMmmyyeTq1nd29rs ZreMxzqzF27qMYOfSv7zf+Cft7dH4PWMMroyiCEKEmDrvMYywHo204+mK/tL6SVnwzg2+v8Akj8K +jVCTxGZST0Wn4yPL/8Agp/4fTWfgprcN1IU821uZJpJCNkeLdiD69I8flX8YVrDALnU7KC2jU2t y8MEgTypI7ZPljHqQQAc966fos4hyyPE4ftJM/JvpM4aMOIIYjq1Y4rW4LKzlmSbcvCm3bbt3SOy jbn0wW/Sqb3FvbaeI4p+WnKeVN9/IBJI9v8AGv6/i7H8fVItVeYxlF1dLbs8Vj9gtZZJryL/AFdy VUqwdjjleSOScVo2esW8Eai3iRbW5TzYNnyjawyCAee/fmnDc3P/0fzdTVRHdSx219FbyxuBt8xW UM33cA9zxiobP7DBdyTai01zLHvkMayiElmHynPOeTnHtX+0Kdnc/wAeYK7NGwvRfQS2s9nEsxZZ IpGk3ABSTgYHB6H/ADms650m1muLieQwW5dgI/OBTLqeMDGe361qppm1raCxTRpbRWMtp5c4lLTs /MciEDZlfcc/jWteTSHVNJvrnU0NqLJrWHTdxijAThQmOO3T/GqAW8nzLb7RC9nDGzzRwkpOZS2V Z26FcZ4Ht6msVmlnaR/LW3jxlHyQq/r7VpGUUjOaP//S/NWfTbeDzp7mfdcwwCaxiK7orhty5yO4 wSfyoiW6jvbm4azintookSOPf5ck7Mgcv06ZYAY9K/2sfJY/x3NC8029LxTXccUEs0QmitFcO0aH oDipYxZbLz95byu8KPNbwKYvsZBI+cYAGfQfnRBJolys7EmnzRXF5DHZ2kS/ZrdrVZ/UTcPn1J9e 2KZe2tjAPsbTRyXUUhKopBLYJBIpuC6FptbGeLQGVGsWSaW6hYQxOdkDFR85LYwNuSPwottDf7fD fwuRGkLwIWOLdi4XceByRgEVKi2LyP/T/PURafp1xb2t9NLdwx83BsoyXHmc9CMEjI9eKz7x7jTr xdSsYft6WiCALcRfZ1mTGPmAHB569MjrX+16SSsj/HjmaNOztrbUdl6kaw3VzmV4LU5VcZyrD2we tVJ7PUJbnEDRqgcNIJpAgdc84PrTK59LM2J7fyliCmNjKMxyBhuTHBqsFms9QjmWUO3/AB7m3VPM tXDDB3A8MGzj0qoq7MJ7kDWNnPDPBpsX+kvcK/mrkxoSOUCnsMg49qxtShIKiSeeaWKHEokTaSwy OB9AK2OWa94//9T86dDs7uV3d/Ot0toizrcKY4Z1OCCrHgmrl9p730jCwga5niTzZTCPNEaAfecD njjmv9uD/GBqzsZ0FxFaaTdNeG4tb83saWSQREwtGpcTZz6/IBj1/GiC+ntjLPDOUZk+YngOpGME d+tBLV9GW7i93WjGKwe8nlCxR/ZlHnIxbrz+I/Gthkazm0zTbqSzRL6zW/up3lLfZZV3KqEgcEDk +hIoFGPKzDlkmuJ7iOyvle2tn+zl1faLg5xkE4JHHQ1kDSpIbuXzZTZG7ws9wh3OVHc4NB0KKR// 1fgi+bT7uPyrRrmfTrXy4GlUbPPKAAjns2Dx15NQ6iLGKzMYVYm1BjFaW6fOlkvUbWznjgfnX+38 VZWZ/jDOw3T459DVZN/ltJHhJOzKcg89jV2NBqdjJNbTrHGcykNnMzA8qPfJzzTOZ2voYRK2aO6s DcmZIVhbgNvJXOfY4/OtS3vbby5bKe1f7fOhKvCpKPtA2/TFBM/h0Mu30y9v0YCMNYvIYpGchVBU +nfBrpUtPL22ayR2ltZpuluJpVVHJ4JX68ALQczfvJH/1vg++stQhtmntWFwXBj2sdrY9c9hXMwi 4ijLXKJLPypSU74xnoB3yPWv9wD/ABPNnS5PObU7Ka48mS2sfPaBMAW4BxnH06D6VJpGo2UzPbWk jSCH5plkznJ7k9OaadjOe2ppaVfPfSuLG+NjJa7pImjcMs7DI2k9hz+neqr6VIlleLd37yz3pLfa 4XGIXLAgvgdhnjrzTjq7MzMtPt0cK3UMzeZbtskmT5RKMYI/EdqmTVJkVZwAyq25o7ZgpYjse3Tt 71sB/9f4SvL21u3QBYxA21p5ZwSsIB/p19eKr2VjHJdX19HcNdWRd4pGjQxqVwVLKhHA+bPNf7kH +HzaW5esIYbZ4bMQy3FtZxb7adycwKeSWGeBk9uMmqV5rMtzcLHYpsBVoGnRdrv2xg/lW6VlYxk1 e4wmK7huJMtJc2kCJAqkM6c/MB6KcHP161MsNm1gryQTy6jDIptYE2tbpk4YsT1xk0JJaIxm9Tuf Acgl1BUu7SKWyjlHnpJOY2nUgZKbQTlc9Djp+B+6v2Z9Rgsfip4YjtbZGe51ZYJXkcebawHKBk7Z Ytj868Piinz8OY1f9O5fkfReHdT2fHWXT7VYfmf/0P7lvgfLHcfDbw1cRs2ZbDeUbouQCMfz/Gvx 1/4LJ6Xe6t4NsbXSZoYL6aACN7p/LjaVLiNljz6tlgPfFfu/hhNYfxjw7krpV3tvo+h+F/SGg63g /jOXd047+aR/MhdLIRJ+/lE1sfLklA2ozLwd4+oPFZEdrczxXT3F9BO7Ntt0i+YquP4u3X+df62U tj/GKvFMrBLFXhjMGHEOJiOAWyeQfes+wsZbq7DM8sdlvKtNDFvlyp4QA4HPfvjpWp5UlZmnBJOl u94sORDLsUSfJKcE/Nt9ARVCZ57ovO0bSTN8zlBksPpXQYVNGf/R+dVt0e2EsKOMD9+jDaVz3xUE iSSHCuiuAFJY9RX++B/zkXfU2dOjjhjnnuJljijjwBt3eb7e31qC80940SVGIVh5iNuDlPTOK1gt DlknzaMzws8tobRZw7SyAzTsgLdfmx6E8ii5smtwoiG/yhtGzuB0q7WM5SvoRx3TG2u7adGaOZBE 0EnzLwQVOOnB5qo05EUEMkzQtJMEUgbS/PQe9VFXZlKXKf/S+Zo45YWNv9oaS2DM4E/zTAk9N3ce 3ah7QxYZZEGT9zOCB61/v+klsf8ANg23uXGtzCvzyCVXAZGTBUDHrTorFLqULbzlcJucyAg+4AH4 4pg23uJYRTZWZXFuOQ6TgbyDweO1WrpTbzrGbmJ4+fs/ky7kfjk4ot0BNx2Hi7MKhl+V1OQR6inR X1xLFKBIwZmy+PlQ+5FTFWVgnrK5/9PwGCXZL5ZnAAG8q/G72AFLPeXqrJa7mFncyiYrsG1yo2g5 68DPfvX++9tbn/Nkpe44ki2xkUhAcLzuB6Uy5DfJux+7cHkbuhrSouplBuxdkFpe3CeXN9iRR5sq ld7SKo5UfU9KqM7u8ktvCDEnyAen/wBfirirI56rZWsZLiaZvIgheNH/AHsj/K8Z7YNTJC88sqzu D5rfMWyQ31oktLCpt7H/1PBZljtYwuQMkKAOg7Dio5ozmOCRhONgbk7lHfBr/f2EeXQ/5qpO+xaE sU0c0TE+dbSCLCHKgYycH8R+dSmUOvkpuO0YUty3Q1cE/aAvgZnLNLbuJAN75+cYyrduRTbZTG8j IhXzX3uu4nn2zWlToTDST9DUm1GeWB7OMqq5VkG0Yj2jn88H86yJhLIYxkLtOSSMlu3FXyq9zn0s f//V8BBGPLVcgDnI7+ppCkbsoEEclxGCIi3AQ9+a/wCgSa1P+aam7JMnubv7NJbC4t2EboFmEB3B T35P41AqNDK0oX5WBKedGG+U9OCMd+tQ007F81428yMRr5iqXQh/m4P3e2KtmzaOSKRmJjVtxU9W Hp/n0qqi1M1K9j0n4T+MtP8ABvjGDWdUSO50u0ulupLd/k8pFI556leTg4r+qL9nr/gpP+zUPB3h 3QNX1ePTNZtNNhgniFgiI8ewKjKxxkHBPGeSfev5Y+kZwXnPFGBwlXK72hdO199Xr9/4eR/b/wBE jxH4a4LhmGFzq3tJyUleyvHlS0vvZrX1Xc//1v65r3/go/8Ass2YcS6/M0UEhSUfZLdlQjvjdXIX v/BU39km2heCz8Wu940JZYLeKIPER2YEjnFf1LR8F+Lca1TUJO77N/cfy7iPpD8C5dReIhNKyfWK 2PwX/bg/bGuvjT4iurvwD4xv49EjMttb2bbh54LRlWYfd5G7kMQNvqAa+YP2avjNY/B34hf8JlrR mmt7NEaS4uZ2u33NIhwEwTjIPPbcPSv7n4N8P48PeGryKmuXETp2d9He1lfs++2r1P8AN3irxU/1 j8YYcW4vXD0q3MktVyqV3bdtW2Wui0P6UvB3/BXz9lu48NaW+sahdabqHkxxXcUjJDEk20B/mfbj LA4+tdPf/wDBW79mSxjmle41NUtsLMLn9y2WHybeCG3dsZ61/E+YfR64pWZNwjL4nZOLu1fQ/wBC Kf0qOCa+XJKcdI6tTVlpd/cfin/wUW/a2+D37Saac3gRSNTt54bs3IsI4VVCWMiCUHdn5RnIGc46 ivyAhnkguDGTmXOQ5GM+lf6B+EOQZhw1wPQynM01VjfR720W3Tbqf5UeLef5dxLx9js5ytL2NSV1 bVa63/E//9fwYFiWYyMzE8mrNvbvsd5XRlB4Yfex2yK/6BYpp6n/ADQyd2Uj5TvdIkcjSIAVlbPl LzjFWwpcKhZA23A3Hrj0reMU9ySmj3NpfLtiMaqvEitwc8VNdTz/AGeZQXWPcCDGf3nPUjNUo2dw ImvYpI/JZVaUPkSkfvV45Unr6cUwITmVclfu7em7FUB//9DwQlYYfKVWDyHdJJJgkegHtxU6oxEY Q+xJ71/0IH/M+V5mWK4eJuXH3vQZ/wD1UyZ3bLqTkLtX0GBQS5WdizaWwnaLeSqogWZycb2yeR6c dqt6hpoBQJNGy5+WNW3OeOvp+veglTs3cov9rhR4o5fLglwJgUBLY6c9R+FSRxSmPCykDtjoaBqf c//R8It7RmcJPllUEj29zV1be0RZzvnWeN1MTIwEDAZ371Iye2MGv+hA/wCZp/GU5x5q748ZU4x1 LD2qe1EgVG4IH31PH4Vk46uxpGfLLUtvJFhsYAH8IPSoIrmQ3cD3Usk9okTKbYNyD/Dj0wetStxc 19BGSSYMEbywTnrjGOgohRUniLIpeFg/PIODSt0BTV7H/9LynUJftkjzg5dwN2eCpHGP0r3H4Jft F+Pv2fPFWm698P7m2s76GUSXqAjypgQMHGCCMbgVIwdx6c1/vVxHw7guJsorZRj43hNW2vZ97dfT sf8AOjwRxpmvAmf0c/yqVqkN0/tK92r9Nk01s11Wh+rEH/Bbv4pW+kQxzeELG9mhj8m51ARRpKkg GAGRU5ye44NQRf8ABav4rXKGxuPD9la3F7Fi2vPI8y2t3YcBx5QI5A/vDnr3r+Sqn0VaCrSjFJwv o1Lp82n9+p/cWE+ms1QXtpNTt1g7p+iTX3Ox+YH7Qnx0134+eN5/E/imffPLbD7duB/eyhm4QA42 85HA9xXzGyrDJKsOAmcgAbRX9bcJcP0+GOH8NkdK3LSVtNt2/wBT+C+MOIavFPFGM4hrtuVeblrv r3+4SZzMqqoZSoxgn71RBliAWQYY8A9K+lPmptPRH//T8Xw0SKVdT5nTB/TFU2YoWYlty9Nor/oR 5X2P+ZqMuUjgaad5cmQjqS+efxqXyZODzgHkDpVcjFJ3YSOCuyNSoUYPpTCuE8sqC2MgjrVWfJYk fZxPIjgMBsPzKSAR6cUs1uVlVWGSw+XtxUqDKjLlP//U8Ggs7aCXJypz1PQVdllkLDyJw4j6kHtX /QvFNKzP+Zlyu7orXcom2s7t5pAwQeePWmysNhLB3+XBC9qhwdxXZNCUiCry6Ohyo4ZTzj8qsW5X y22gsU4fPOPrScH0ERRAKXaUbV3HYf73FK28rvO7YDtzj5R7VLTW4H//1fFAwVM43dMqvINNkijv JFgKxRFiGXefLWMjlST25A5r/oQP+ZKe+g+JpSQrYZom2sd24Pzyav5iVy2PLU9Qf4alR5XdG3Om rFN3ET5RFdcjBzjP1qZN9wHAARRwDnAGf/1GjlV7lc/u8rM263NJG8KmIJH5ciBixdu7fjzxUqmS O08tVzhs7iOT9aozU4pn/9bwreW3CTKjGMj71aEstr9kVAXYxxeXGATz1zk59zX/AEINdz/mYjLl ZStBiFokTCgd+tSGzmkCqtykUStucspPPpwCafK+wPe5HJDlBvYuF4I6VHaRJHvBw+5srnnb+FFn sIJAxkKIcD+LjimfZmkjZN5BUghl4Yd/StIJq9xXSP/X8QWJLdC7kv5ikdfmBqFIpCkbnDJuyc8k Af571/0In/Mg3dixy+TK5jZ9jNlCy8rjj+lWls1k3SAg+Z824Dp60gvZWLpjWOKBIS+4DZIxbJYg 9cf56VFiQOyMAcEHJGRQNSsrEDwvHPtUkZ59qljYo6pJj5jgY6Umk9GUp8qsf//Q8cmilZH8uPcy ncrjOVA9qrQSFMh3+ZuHzxX/AEI2Z/zHj3WQiSRw3lqQEwCSRgelSLCCiuFJYH5VxRZp2HsQyRTC Y5Ty4+pJONvtWsq20Uas3zttzuz8oq4xad2Iz2nDyrxtjz16ZpJTufgZQcAk5xVpJPQD/9HxO4ld IzGEGf4VHercTww20aeWS8jDzWJyR6AV/wBCUo8p/wAyPM7cpVaV8uykC3RfmUqdxPqDTRG04Vld 4lXspKl/Y1JI+O3bcCr53Nl89R2/pV2SLJDqSGC7cHoaAcrLUrTPcQbV2jHU5HUVEL5A5At4pWOV JlQOkZ+h4osCemh//9Lxi32RZOCD2C8YqxKUuIxn5WRt3HBOOetf9CFk9z/mQTcdjPeeSRnYIYfL +Xaed2B161YW6d41VSjbCQGUYI5PU9/xpNJ7lKbLHlQeWpSQNIf9YzDBXrxUEcMUiGSOdZCjbXQH JGO9DV9AUrAJWhOVfKH7y+uPag3RYb2fcAcBc8r+FTyITk2f/9PxlCu+JwMsrbmGeTj1oZVnuZJZ WdWziNODgDjrn2r/AKC+Rn/MeLO3mZU7j5Y4PZvpSxqiInJ3HqMYxUACuBvYkl8lMHjaKjjhE3nS T3KRJFH5iq/3WIIGB+f6UAMvk2G1CBVONpbj585IpBFLHj94ImY4LkbgBxmiw76WP//U8Vmtoo3R recykxhpcKUAY9Rj29aGLRDzVIBA4Jr/AKCD/mUjJt2KzXZmkjVpCvOBsGFc9OasSWsjb/JKF0Qu RI2zoOlFjRNp6Fi1jOUmlAlJUCS1DYVm57jnj2pba1jnhnmlVV8r5hvOVGOaLD5naxVgmDuxx8p+ 6R92nMSG2LJknOFY4wfWk4p6AptH/9XxRb1mM1rMxLQgYDjAX/P9Khe3PlGcsu0HCt0A+tf9Aqgk f8zXO7WGrMHiQ5BwPmx0P0p8Xku7scM0a7kz0/Knyq9xc7tYVBM+4Kpdl5UAYKg4qa0ZY5XMpQ/I VUuc8sMdPxNRNWYcztYhuINjqvDA9WzyP88VCVlCPvR1+fZERjDDHX/PpUBzPTyP/9bwcxwwTeYi H51CzP0A9/wqxdJJHcR28cke3Hzsp3KQRkEH8q/6AD/mZUnHYoPIlu5C7WcsFwzbR1x15q8wvXXz Fjx5Q3NtPQUDc2VIo4pZhLI6r5hGxT1cn0qzdQtEwKkkEYOBwtBBF50ktu0SEB0PzSEcKO9Nnt3a FZISCwIBB6N70B5H/9fw2KBE2tI3mOo6jnBxUdwgcqqZJKksx/hOf8/lX/QAf8zXPIiQybQjAs6n b6YFWJEt4ky6LucgbsfN7UFRnfRjDaKQI1Krx5gLcE4pIoPLcHJ4OTjnI5rOa0Q1NFeWJ2uLi52Y ed8nAxnsP5VJHcB1kgY7pI2CbOc88/5+tZjUleyZ/9DwCTMe6OWEwzIxBX19P8imKJQDNudFXgjt X+/bikr3P+Z2UraD8rIjARgF+dxGCeP/ANVVER4Q+WDThsIuMrj3qCfaeRchfy5o/MiPnTtwEUbR 3P0FXb9WYF1fe5XaE2/dxxWigupSnfQhtoba3kijupHYOMsbdgrrkHpkdj6+n41l+fIiKJW+5O0e 1vvMMnH8v1p+zRd2tD//0fn6FIlkDFFO7nlc4qxISDujfa38LEV/vy1Z2P8Amh55FdhI7rKzHzsY 3jgfhVQ4hlO7M0u8uzsSwzk/5/CkaxnfQ0LOUNOBu2sf4hwR1p0zS2z/ACSFsvn0GM1LiuVo1jNq RNa6i9nKZ1bahy0gVQc8d/Uex4pjNHcQxTW4tUhO4O62sZ+0F8cs2MkgjjPTJ4rNUabp8skmipYu tCtzQm077p2tY//S8IupftRDeXFEYIEgjW3j8gfKu3dxjk4yT1qoFkdViXL+u5sn86/3vjSpwahT ikl0Wh/zWVMVWxMpVMRNyk9W27t/N6ld40ijZvmYg9QelQ2375iQzY9OQBXRyq1jlc2acReJH6hT 1PQU0rHNPbRGVA0x/dlm2qPqf1oUUtg52F9FJZxtcsy4hcKwGCrEnAwaaiwX6xSXwG+3fdCoYgn6 f57UzSLurn//0/ALqFY2SWJPLWT/AJZg8KO1V5pH2eRHjOOOME/Wv9+D/moW5Dcx3dg1kk7iPzz5 qRkeYkm31HQ4zTGMbDGFDseWXgkUG42WISh4miMcOB80RCOcdefyqrOjpbhLNI9iuPPZwPNYezdQ f8KAJ0sZ0iLB7eYIw3SQSiVAWG7aT69fyqJmaAlgjMp+8q9TUTi3qilJp3Z//9T5vjeKaM/OUIBI LgjJ7CmiAzlFZl+ZseYThU9K/wB8WmtGf82612JHGIkaMgxKCN2NoYg+lFndypJ50Ch3j4MbxiRJ PZlIIP5dqQLQrl4nmgm3Si48srND/wAsASeoH4D8zWnp8UF59sW+kEGxDLbSshkE7rtwhA6ZGeT3 AoHd7GUsEdwl1OYZ4gkhhiMmF8zB67QxwP8AEUxbEN5axOQxOMDuc0CP/9X5un0+5s5Yo7lGjbYH APO4HPWkkj+Yu6sw6helf74H/NuVRIUYK3AlGGQ/4flUpOCfmwBxjNAX1sXbac2LyIba3Z3XLPPC krRjHbcDjOT0rLtYne4u32lI42Bi2/dKn8fXigC5dweSsEx2BJwd0oO7yQpAy2OQCSBms0wGUOWU YBwW7mg2h8J//9b5kt1LIlvFF8qPl5CcBR7D8qvwm2mjlhu5plKcWyhcxs5ZBg+gK7j9QK/3wP8A m/IJbXTYZLmLT5JXgkk8yWSYbgHC42Lxxkj9aozvdy21vaxyBoYd0mVjEfmFgvU43ZXbjrjrUyXu m8VyqxZW4RLOGIoqvCCu/wD5aSf7xzz9aBGsgUJIPmGXIyNvXg1iaU1qXrWeGxhlkDM1wR5SqR8u O5/SszT5trXLLcFmm/cyxtks65DZ/NR+VZ1OhtZ2uf/X+dDLDFDPHLbpsA3RyjGQcjgjuMCv0W/4 Jz2jr8X7C4treO7Vp4BdM5CGy8xoVXbgZJIEnU9QK/2e8UpKHA+YNu37to/w98AKcn4l5Vyq7VS/ 3I/ss0pXg8K2sdwzu39mJFIzEbnDRgE/qa/k0/4KsXz6h8YVsra6htvsuozKjuGlUFXsowzKBzlH fGOhXrX+fP0aqareJTl0XMz/AEp+lbN0vD3k7yS/A/EH4pzi20bxL5PlzTyafJBFdHC4JGxtoYZ+ b+Rr8CfiFdNB4rv7JLid4ra3jSVbrL3G4jJYueuf61/S30qqnLwLGPeSX4r/ACPwj6I9JLM8TK39 anELJD5iKqKGnGxXL7QSR296qmP7I7ttDYBUvJgg5HpX+ZT3P9BYwtuf/9D+OOdnlt5XESmVEO0L yzdelV7ORofLa4yJNm9RIOQPSuZ7MxUXfU6q11sCGRjZwXjMuwszkNGPbB/Q1WjnE0qw26lZZDhk XJIzWBbgnsRyKlhO9u8brdIfMdT8r89Dj3qolnbSNLcrvAkbc+RgsemDUz+EtK2iOdm82PUI7VIZ HinypnUjZAAM/N9f61d0o3NktxD5iOkjEMZFGWGeMemKxN5XS0P/0f443PmsscTAbjyScCpXWGJ1 h3JwoJO75WPevHHHci+1xxBmbKKflG0ZOf8AIrEfVGm5AkiZSVwVxnHGR/nvWcpbo3JrOV3YNs+8 3OTyT70uoxypcKY0XyZIdhyTuDetTGXLuAwWdukUvn2/mXLqqRzAnZEQc7vc44pjXt4u23UtMygB RnAQdM/z/Kr50Yy+Jn//0v4z7+4k/d5JWMqFOeprUhkMEKmQhhsxknGR9a8B6u4GFf3cstrLHFvj TJI2t2qhbL9pihaSQtgeWJPYdqRUPiRsXcJMTC1KARQjhztJbvUVtbTeVG8hj3ZwUU8Cg2KNzBI0 6PDChSKXE3mZKqO3HQ1fEGJTKgiTdyTGu1D9B2FBpT6n/9P+N2Ge2HmtOHhi+4Cqb1lbpgDPc1Ru 7do2SVERHYYYLxgdsj6V4UFdnpcztYZG0TZBb587TxxU8RV4pI3GxgSq9/xrR6LUkaiC1Y2iqLl5 l3mYElYcYPB6d8fnVKG7laSaGaPAjbGOu8eoNMafKyrO3mXKLbK4kK7Qeik5/wA/nWnLqzy2TW6+ cL+xIUjyw0bKQcj+uBWD1dxyd2f/1P4tLK7vbiUNBFEEyYt+8guRkMWHYg8Y9q3YWNuyI4BuQOWX gOfpXz56BQ1CaQOjoQzO+JCBwgHYVes23WkrzSA7B8uB+75zjP5UDu9hljdGGXYWjeNlyxH3T6Yr VupFRY2WQEkB+GBx6Vo37gvIxLmeK5ladIiLpW2PKny5XsMdqIYgzP529y4G0Dlh/nirWqNaex// 1f42G1KAvGs8Dy2tr/rUibypZR3XdggdOOKoSRQiR5rFWGG3KsjF2+n+RXjnsGxHK2+BpGEMxXDo jZwOhFU5IInuDcKDknZjOVbB4oKjFsskxy2e1lMMkEpwyPzt9f0qPCX8TJC22RVySRyccdaDVxT3 KpiurdrO280fZQpadX+Y7jwDn8Ks2hnjMqzvFIA2Y3jH3l7Ajp+Vbx+Ey5fesf/W/jPvZEY+UpKl +u1adpL39pO0AMRTcdjk7cLjua8qbTeh6/L7zufRXwOW4HiSG4uFgniluxG0Zk8vyYsbAwI77mzz 3A+lftX8MLS30fUPDiazcwz2EFtDdxvBbmZR5xASGVsZDMZBkY4yeea/sT6PNBxybG4q3Rx/C5/K Xi/Wj/rbg8K3pzRf4n9uH/BPuzaH4aW9xdQQ5SwhRZUGWjVlWRcH+6wIx9K8g/4Kq6uJPgr4nsgr K914dn8idJiFtg0csanbnG7Of0r8P4fp+08WvZrpW/U/pbjeqv8AUJ1J7Oiv/SbH8R3iNLSHT/7Q bUyYZIfKgkC/Z7qPchyQO4GOg5+vWvxq/aDuWt/Fk5tbsNf2DlYrmH9z58Wcg+3Ygdq/tLxwqqHA 9SHdJfkfxh4H0+biGVujZ//X/hqutSa9vHuL+QP3leX5pCenHqauTW8e0FZCsbLlccH6VvJLmbAm 00K8oVxIEJ2s8Yyy13NsuktDbafLF9uMc28RXB2jJ77v6D0rzqz1saU9yd4rezhuINPMaB33tADh Q3f/APXV3QLV4UeV5hJNHJ50QI4AByFz7V51V9jQ9f8A7RS5W0M1sltdQW6l5kQr5oOCOOnA9BWx DeS2y/6FJFHLMP3jGXylnGc4Y+nT8q8uT11NIbM//9D+T1tYvJ4rmPUreK90+5g2NEXJaCRT8rxs OhU4wfr60yK3gvoxeSTRRXbsImjZdj4VeGz0r4mVuh1czvcwLi8VtTjsRbmQLFkzKNwIBPL+meg+ la9nBtEpeSVAhMlrEi/KpOAQPrj9KcUnuXJvZF2GLTL60cXLSBYrgRuJA0Um79P8Kv6dp+mW15Np s9n9uHDxSKNsbtk7Rjqe2fwxVciQR+JopahottDE3nwS2QDmdbOJi6ZycZHJx7U54Jrv7NOY0jlh kGTH9/b938OOoqmtCnsz/9H+M/V9VS3t9Plkjkhnt5Nk3kRtOcNgcKPx/KtWP7LFFdXVrCk7CMeV JNbCFm3DncOccn1NePYm1pGXayxSXDTXYE9u4Mc1qSY1bGQeeo/+t3qC10zTjY3MKwgPA0jQhWLE q5yCc9aBT2IobS0WJds8jmIZUSDDRv6D1HvS3Gz7O0txJmP7p2csvboKDnm7LQs2F8LCeyeOGRja SGQ71/dSKQR/Oq+qSx381xdMfLnuGG0Rr8vp0+lBlsf/0v4rrTTkkBtrWJkaIkSYH3jnOR+ddE+h O9haPBPeW0qXW9gx2xTbTjA79z+lefHRI88t28ZmVot0isz7ZSG+U4/TtUs2n25iliuDK8TYLZzw FIPAH07V1w3A6jw9emGF54CPsDgQxyOpjeRlJBDKfTFeWePIydcW2jEQivlW4YxwhBkjGCegIx+P NdlF62NH8B461jdwXk0RDoVl/wCWnGPSvsv9lux1m8+LXhCHStFgE9sk5utXlvAtvHE0Y80hDwWC gkD2HWvteBpuPE+Ea/5+R/NHjcSrn4dxVNbuEvyP/9P86fC99qF1BDZ6ck00kcQnmu3mEaHy9jvu IHy+Zh/bkDPNf3Df8Ew9cTW/gn4UneNVuNS0+C7uPJlM8SMLdHIR+65kOD71/b30h6MavBOFrPdN fiv+AfgX0b67pZzmOFfW7+5v/M9A/wCCiWmfb/gjrAgto5bi4DxLKz4eBVQ7sA8EFWb8q/hzn2aX caja38VxcahCJ9PlleMo85DuAytnBHIGR1xXJ9FaS/snFx63R+d/ScpyWe0pfZ5f8zi9ShafQre0 ZDPMt0t08G/FzAY5AfmJ/wB0fhWdcvbhWsprQXU1yUaGeCUIttkZYsO/XHr1r+xopN2P47rQXMQa gYrCwikmEZit0C3M/wDe3OEAIHfkVLNpsJe1jgRw32MTtAqbRCuMjjsAMenWrStOxSiuU//U/NHT LeO31Jr63ktUuD8jW91ZrePcsOF2KwKggDr144p2oaHPql7573EVosrnDmIx26P2L7RgD6V/tCk3 oj/H+yWwXmm32lfYrRri3kmki8xr2xlE0bYPJPJx06fSiS8k1KUAozyxjZ8ifM+3vj8KLO9jWy5B trbC8ubtBL5JtoRvilBMpfgcegznr0FSGMmGaQCGaaytyY2dgzopIU7B65P61tFcqsRJJPQjsLec iaFXUPcqGLuu7qARj26V0N9Dp9vDZ6RLGWmeH5mBLBx13E9BnIwKqxLWlj//1fzkudEv1WCVi99N HujVIYi8kCA/KrKM0tpfWFzHJPdSTwXaS7WVoyFZFAVQEA4IwfwI9K/2oP8AHewajdPJM9xbu7w4 EcbyAq8g+metVg0U9nfWka7J7wKg3qEkj2kMTu6c4xg1tBWRlJXlYvaJFZSR2mkxTrZRXExa/vZC Q8Rx0GOcen1rPk0+dNVv7G3uFNvZzhLS5mYK16doY4zzjtVPyNSC6v5jDHb/AGYFYmI8uFRv+bGf 5V08EVuNNtrcTeTcyZjFntKzBVUYb0559+KzipKWoH//1vznuoJxZTSW0jS3P2tY3tIjuvCoyfNx /d6j+dVdRuZbxbJZPtVtJHH5ThVCxz4yPm4/kRX+2B/jzytWuZdvaaot5H5RMdokubmMnyjOPZsZ B4rotQcX37qVU2QqCyQudwA9SKC5RSTaI9MS3IkIlaMxKPs9u/UjuPw4q+t9NcG106+/0eG6lKKI I/NkRvUNx1xjn1rSDexyz3Kl8mppp9zp1rIxaa4SSGWMiG7UIcbFYDoQTnOTmsyxfUba0k097n7Y WumvZmni3tuYAbd5G7AAAxnHFaGE11P/1/ztubq8ls5GDs8cACmBHAc4zgAZ9vw4qhbzR2z29+gu 5ZHQRS2kR2MQzDKs3rgduOTX+3B/jFJq9jVvLmea3ggumgFrIzTQxwYkkgIyuJW65wPpyOKyUeO4 ddPhtg0rjKNzvcdyaDJySOgi0690xIJhJbTNcExiBJ/30WB3XH8qpWEN1c3XlvDbqsRMcclyd0QD nncOcY68+lBPOR3mlPb30stqY3tgQsscP3A44JX6mq72k8qzTTcsoxCobk4x94H24/KtII09p5n/ 0Pz18mRLUSrKEh2IPsUco8mJgSN5GMknJ/MVHcwWepDQZLyVYZrLUjPCUbdJHsyPmXoVbKkg+ntX +4K3P8WZz0djoNRW4u1kiiFoZ8ho5X+W2bnnp0GKr7ZIbRdTuILO2KXBtEgtJD5a9MEg925OfanZ WRjz9yk0XmyS3ciBnQblXH3TjjA9eKpiaa3cXFud0m0qSD80YYbSfyJ/KhpLYUpX0RuaRKiQ/ZLi b7NaiI+Tcj5zvZyTvA7HJ5Hr0qnqy2f2S3ikux9ve6cLaxpmOaMAYZiff9RUnM37x//R+AI7vUIB HHvPlFNo7qmPX61H9nmvZlljkhCQth4GQ+Y56gg+gxX+4B/ieW3sb2AW0lsbJjrU7WWoFnQ3YVNr AH+ID7vT09MVuWOn2unm7tFitv8ATW8sSnpheA2fz/CnFXdmTNe6ctCqW6TQbIY5Y5WZhEuwj1JP px/Om2kb+e9zDcNMJofKECsTEmD1x05qox970IjG+5JaXkt2k1ovltb22WkROWJPByPwH5UBrWGA WFrbIxlkBmaRiDknJJb2z2rUUo8ux//S+Cba5ltUURm2OWEWyaJZon2nsGGOMVBq+oG4GUuDFNdM yzwwgQFAAOQBgYOT09K/3JUW9j/D2orK3Yl0xBHpVyPPmhjMRtUuN5MpHBIOc57cVlQo727xRsWV 3VxgYZsfxZ7cE1uc09h0MNxZySSxeYWkBjLxZ2yDoR/P86cJJ5UEYnlhPmbnVDh2HPB9B/hVRjcx ezPV/CltFEhe2mX7TdQ+XALlxAFxgvuz9MZr7G+A1y9j4/8ADlu9zGLdNTtJGH2XfJeNHJ5rJFL2 +ZVAHfd1ry+Io3yHFpf8+5fkz2uBpJcZ5ffb20P/AEpH/9P+3z9nWRm+GfhocrGtiqKh/hwDj9MV +bf/AAVu0i1uPhlPPNaSPcRadNcWd2nBiljKyqVPYhljPNftPBVSeG8XaU4OzVZ2+8/GfHCksR4S 4unJXvRX5H8kdk948M8d0PLMY84vMxklmc9cgepzWcl5cWscqSOrzSMVjcRiPAP+zX+u1PaJ/izX 6l6KBktI72SeKWRQUSLjevcllrT0y/1G/lginkiMdvN+5aFRAIlOMkgdxiuk8ab1sauuadHZHzLa 58+N4wZMKsWGGFLEAcggDHeudt7mW2UywYw4MQcdB0zj8x+dbrY5ar3P/9T59jTdvd2ZDJ98FsLn k/nVLyYJr9AJNzRoRGhbZ5hOO3ev98Urux/zhSlfQnurWeWJizeVGp8p8NsdTzgY/A/lV+0uGgt4 0d9wX5WWQbiwAxkn3/pWyVlY53L3rohtGt2gmSBRhpC0ZYFXQZORVqEMCUR8bozGWPfI+7/SqSu7 IgrSWkH2iDBMZiCqSAPnK465B6471ZEaxWl8Y50uJRN+9SZFwFOOY8AdPXtW0VyqxlPex//V+cIo TdeaTIqbBncxwD+VT21raPH5l05mViYyEfaQO+PfnrX/AEAH/NeRyWEVipEBuBbTMXh+0yGQheR1 /DtUyrcQWxnt1WWNm2b+gJHp370CbsriRhX2lwee2eKiudOlM1rMoLpA/nKAeGXDKQe+Ov5UCi7o lEUskTvtAUthVzyPapXhMcJljCgqMeWThmNAOSR//9b5+2wIu4gTOYOCAV8pj298Ypm2NWhHmP5j jL+Y3yg57V/v7yI/5qudmr9nuLaFZwC8Mh2kqQCuTjkf561myx3Ecm6VgI8ZHfd9K05HJbCjLlVh jy+arBH2YXBZcBhVO0ieTzA052q+QQNoGOx5pqD2sZ1JX3NOHMDlEcIZeZePv4qVJIt0oDFpUPzr /dHWn7Nmalyn/9fwATLMSq4YhsHNNuI3ErzEJG/lhG2qF3Y4HA/Ov+gRU+5/zR+08iO2V0Ec0ymF pGzK3Qbex/KnT7BdtPFL5kKnYkmCqnmqUEncOd9CW4LfegOGlG1ipwFyP88VHDFcbBlw7L1IG3dj 2ptJ7k8zLaKZkaJCiuTyzEAgimRKOEk+Z4jwAaZJ/9DxBFh3MThGAyF9RTD5KKrxkHOSC3U96/6C LH/NBd2sQtFPNIBJtMeOwyBT5LdILWFTMzESlH3nezDjH6mgFJrYqfZLUXKyROrskeSOjRDOOh9/ SttmSSNU3DhalxTVg5n3MYW48+Zd6sqsVb+6w/8Ar1owmCZ4bXe4jRRHGRkJCDjIGOgrL2Sk/eQ5 VpRSsz//0fD5I0tJnCBSY2YLIshK85BI5qoUXYFeJdgfzQWXIJ9c1/0BewprZH/M99YqtpczLqXp UoghXawJViMJkYFVWe6N4rOqRxMnzLnO4+1ZOlBvlsdUK1RRb5iJ1SVpPOjBUkbc8gbehxUKxuJp bvaGfOS7kuXxgDr9K6Y04LZHNKpK6TbLMVzP5JZwheWUsygYKjsOnpTY7WaaaW4MYJQblBwAcelE Y8rYpSaif//S8FdIVTajESSN5jpnBB6VNbRuWaAsRkZJJ49OK/6ClFs/5mLsqyRG0ldXaR1kfAAG AfpVkSRl41MeMDkkfd9/1rVJIfNIdEPM3KrqSrdG7j2oCkSMXKquBsDDv3zTHzuxSntoG8q4uJHS 6in3ReQ6pDLkjiRSDuHoOOTWh5ofz/kiRyAUGDHFGcjoAKA53c//0/BrrMq7SUKqwO5Tg8dfwp0c sbFEG5dvVsEg1/0IH/M1GVtwuo97q4GccMR3ojSCWFo1ZjKx2jbxiglu7uS7jbxiNsgA4P1pTO2z eGaF4+kmcMPpQJu25U+0G4jK7vMkVsb8jLe59+lW7VJAxRzwOlBPMrXP/9Txa52OYlgGwxjE0hbO 85PQfTH5UsyrFCsiyLKduXVeo6jB9+K/6ED/AJlFO7sVZJEdYGhGzcPmOOMfSnnKqVifO4c+9A+b Ww6ztI382Ocb3eRSmWKKijhvz4rpdU8PQwCJ7a7sljWHeyx3iTSSf7q5yB256UFHKc72IY7V4C+t L9tmRspHGxjBGHHFAH//1fGFlEgy0e3euGHp/nNQCN45vMjG4uNjOw/h5zj8zX/QfazP+ZmTuWLe ZJZJoUZh5JCsucbyeelK1yysybHTEy/NnBOD2+vIrWMuhzPe5aUvPcguoVWOGz27VQuUaKRwRn5u Md/ei15M1bUbIeFPyB8nC4AU84rIlSdnbKedHnAdcgxZ7GtEraId0j//1vDHlklS3XyxH5ahd27J bHGTUEizFs7iuB8jY6nNf9DB/wAyV3KWhrIxS3B2/MAPMIHGfen7x5fXGR/31QVK/KUWuSoMJhQp ndvA+Y/jSW8KSGKWVpCQ5GxG2gj3oIjoy032ZJS2xsEc4bBPXANUmZ3lUqryDeEVVPPXFBsf/9fw KVZZJnt5CF2oTz1Yjt/KrFpbtCgZ2wu8K56kDPX+df8AQwf8y4+6FtKri3jaTym2rKDt25PUjnqP eoMG0geSZiyY3YxyxoJ5lzco4PbyEXERkwFyqnoPXP41ZSWSZCqDy0c/PnqcetBE3qSxTYVrZwJH UFogTj6/0pdszRjd8oxlouqk0mrqxHqf/9DxW3PlqxK4IPQ96JpVB3NCWeUghkX7oGQc46f/AFq/ 6ED/AJjyBWETF13Ded/TIOMCnSz+ZKC7EMTyuOtAD2KhmUjCt/DnlBV6QrFbIIUcrtGS3DH1oAbH ZyfZ5rpgxRcKGXHDHnn8qoyzFMMD91sNkcH2oA//0fEYlW5JYEBz2xhRULAiTydy5JwB0r/oTbvG x/zHlxrZ4lUK7DeMZycf55qGIyp5kcrAg5A7Y/Wq5vduO72GojiNow+5sfK2MUi2wiGTktjP0ojO 7sIak207AQ2fxrXQR+S7/KJFTgdM0+ZJtMD/0vC7mdCQuMEKQCeBRZiQxMy8AtgjOcfh+Nf9CB/z Hly0VBIyuolwd20jA+lW4ruJS6l4w+/alvg7lHr6Y/GgClNeyJIJIkMiq4DBeByeT+Ap9xcLcOBG jrj5iQfvde1ADT5qR5LbsfmOtNG1wmVbzOz5+U/hQB//0/HFuJYWaJxjHy+5qPyolffORzyqrxuP vX/Qstkf8xrlZ2JIJHZHQKS2DkY4GP8A9VTxmd0juIlYLETEsoXCg9SM+vI/Opv79gUkxZJopo2g GPPBBcH+L/P9Kzg81xcywfZpYYYysanBZGJAzg/XtWg7pEk21DBAqljJE8q4H+rCHbz6dRUIVl+Q liAcnBwaDPnZ/9Txg2MggEwLSBnCRr5geQZ9s59+fSniAoHhIwUb5zgHnv8Ayr/oUn0P+Y5O6uQq JFJCHr8pBFXlt0IRo5yAIj53mRgYfnG3BPHTrWYPoZsj3MEbKpDF2ydoxnrip1e4MSPcKYiOPp/n FBnKV9C8syXMPltjzYztRv4mA7/0qreQeZ5b7EjVECfJ8pcjPJH9aBRbTsf/1fGI7WYMV2sGUZcN 94D3ps0Lqu5OvRvbFf8AQgf8x17OxFFEJEVQxD5xIxHWp9OsZku/s8TwCGRjNJPNnMeB0CjrnFAy WSFAJmDklugHGPw/pVWzhiILBmVw20rgjOKBJpuwycNGHYIWA7dc0ltAWggLKqyuN0iD+Dnp+WKB 9bH/1vHUh8sOQpBfgtjOMClTDF8jDoMbv71f9CB/zHkEk6ZAzyoK8CpI13lcLgk7s+prNRfNqAMH ZpI5PlLfxEVTkjGWRXWQIdpYfdPaoS3AsL9rRDDJ5TxHDowQM6D/AHuopJJowyiQblVc+YR8g9v0 q+RJO4H/1/E5LlZMGKEKG4JAKk44zUdxE5iBzxjGMV/0HRikj/mQTs7jbQQ7AgQhkGdxGQeTirO6 Z97oF3KhJ3ttzgdMn+VNx0si/aeRDaTF5N8q7DjG0HgVbaVlf93kBjz2BrFppDU11EliZh/osbyE fMUjGTx1/Lr+FUp1XMRYDzR9znkcc0iro//Q8JcSMrkojM33mPB9OtW7eUm2aKJVcQgB+MqOwBr/ AKCD/mWuivcRSGNjbokZbnnlff8Az2pYocclhkgfKvGKBg2Uc7XIbpgHrmpILeSaaJMrzzhztLgd gfX/AAqJoBJLhbdZI2QyfMMEjoBxxTXmut0bRbDGCCQyBwBj0NZAf//R8Gmkk3xRxp8jffJ45phU LeqZJCFkwreXHwMDGcfQfpX/AEAH/MuPmjt1cSQ7m7SmXGFPPI9OMVYFx5YVUO9W656UANkQKPOj CFuoToFPrTme4O0MRsI+cAYz/n+tAEsEyQN5kcaSdH2SoCpwf4lIwR7GrB1ctbyWyWdrGryGUP8A ZlEkZxjCtjdt/wBkHFAH/9LwgsY0+b5g3PycAGq6POHZ/LOI+QfWv+gA/wCZcvyslzIHgj+yEqm5 XbeGYAbiPQE547Z70y8hkVkWUAlWB24wAeOaALFwFDpnlVXDMpyfwqh55hfYmd2DgNzxWU3rYCYP I8e9cBweBUcQt90jXcMjsVwphk8py3qTg5//AFc1AH//0/D0gBAMkrTHZtG/JMfoP5VTP2iISRgK yls7T3xnFf78u5/zLkkcjFtjwEKi5LA5z+FNijsGZrl0uVlbPk/vsRY7ZQj68579KQCNOxSRdg+9 w4GWXrxn/PSnW8jBXDHI9+taw2GnyscbSEz28sgcKsm59pw23uPyqzdfYPOcWy5hX5h5pyzd+elJ y3Ropp7n/9TwAHfFwADv4OPmx71aiiZARcIckblycAgjg1/vwtD/AJn99iBmVmRFQsIssCvRe38q rR20jNM8fzJ998n7v0/KgafKydSgVHICuMAYABPXrUs7iTEhhClF2Bh1bpkn3oLc9dB8JRo1jCxl dxZnP3vpVi7eAQRWsW1I1HzInKkg5BoSsrEz30P/1fn63kEF1hnQJjD7hu2qeMkUjyxFpFt5FDAk bgcZ5/z+df772V7n/NCtI3FhtI1tAPN3yyOQykH5efXpRYJ9iluy4XYsDJ80YkUZIGQex6YPamSM lvHUBCMxE7lyOmfSpBiRRKsMbsoPluR9w47H1oAqrJd3SmO42BN+GhYZDEcqf8KnktFg2eZNGxdV YNGT+6J7NkdR3xx70GkJW0Z//9b5/lwsbRusoliKsdykZGARge4x+dReWXYbWVS5wGbgCv8Afg/5 pxxaR547G4OVgjfy55nzFF/sDr19qyhGvls0mfNV8IF5BHPI/T86C1JrQRLhiAkgdgjf6tflZxU0 aB42bbIkUnJjlAV16/5/Gk2luVzq5Tt4IoZGjikMEUkvmGHdgyGtFtsO9SMs46EVm5voWf/X+bYd s58oAqwUnODyfeo5bO7UPbSSqY943lOUkIPymv8AfFtvc/5sE2tiw0ojha3uIjIqnYBzhe2ePSqc 4WMIIW2hRjdnrntSNFNdSRIX8oTDawRsPg/N/nrVxAs1tNJFMouIkyts3yB/+BdKC077FG3lfKqV 3LKPnQ8Nk9hUcRu0M00NrNHEk5ihZ/u5AByD/k8dKBXV7H//0PmiSa6mZZbh5GkjXYmSXFIskzsv mscDhSeM4r/fA/5typdiJH82WUooHyHblQegHH86uWDwy6fcyyQmaZJMRSZ/cH1398glcf5yEy0a I1iuLmOU/KG8otJtO3gDkikRBY6d5nmMziQQIr8s2c0FEFks0skguQCj/dVuNxzVudC8UuxXhZH2 sjDAPv8A59aDaHwn/9H5Vt7y8tJIvs7q374G4hkQPFMoByPrz1q83nArPtwzNu2Yyor/AHwP+cBa MqeWWdF8wwIs4nKgny3K9Nw71cYXkkRlQRqGnKhwMAjqeB6A0G45bdZGaORgSnzFgeOKesFvHK6L Nu4OCvC8Vg9zSHYhupNgYfK0ZiKFj1yehFVIF+ztASAkhj3lScsQSeTWc1obKVlY/9L50is59QtZ ZYDu8v5inUtiv1D/AOCW2j6ncfFWTUivmafdz24hWMqYRIrAEMPvZUxDPYb6/wBkvGCoqXh9mM3/ ACH+J30daEq3illcY9J/oz+w+WCKHQCkoEkUWnjIQ5B/djn8zX8df/BSh3l+OF3bTvFIUurwZLHY MSoeW9QIhge1fwd9GCDl4gzflI/0P+llO3AtNf30fjj8edHm/wCEWM9jdskt7aXSS7IRN9nWMRsr J+I3H6ema/CDx4+nzeJNVuPOfVEa3W1YFxG9u4Tk5x6849c/Sv3/AOlpNw4OoQ7zR+QfRJpv61ip nmtvZIjR5GEjO9ZGb7vWoL4g+aC2VUZjcfxEe1f5tT30P77ir3P/0/44AxHku4aMZ+baOHxkc1YF qJtkjsMsxATqQvauZ7MlK0reRJParbWjGCNy7HClOHB9cVWsI3gnEm+fzjHt3t/AfX61gUXotM2u 1x53mSuT5hkYu4A9fb0FRS3GXaLaYIgMZBzuPv8AzrOfQqK95FCVo1cx/wCsDrwQPmFVpGmjn2Rq rxFMNJ12H0+tZmrV1Y//1P4zTcmOby48sQASWGBVqYKrCcqA8o2565x2rwudgRw7ip3IhUHKZ7VJ MsAVBK6xAcucZH0qDaLuWvLsk2CGRSVXerq25Tnn6d6hlaSWRAdpUfMzk/MfTFBRdPlSRmFRgsuQ GHJrPd4LUtHKFSXbkMTkuKCJRb1R/9X+MK/uIbry4oZoztP7xlbOzPr71s3Ia8sYrEKoht4iqSRr tkbPJJPX9a+ac3fQ0UO5lmG5jEcSKrRof3m7uD61eCW1ras6xbgrblSMcIfX6UQbvYtJLYyZdRik OwkozHBwKtJifLoCdhxkHG6tRld4ZY3JWSRI5m/eRZ+UkdDSytLFHuPzQbgmBw4JOB+tBrBWVz// 1v4yYo7mNEaQthHzGr8ox4OMVbdnukdpGUSKNp3Nhn9lrwFe+h6UVd2ZnkCBCkaMZGbHIzU8UiQq TKxVuck/d6citZL3RxjrZlEzS/O0M7IkoKkKccHgj/61IYp5kknSVFSFNoB4eTHWoV1E0UUti3br buiq8oWbbvYOQGH0FQOLiG5jks9m4uA7N2Hc4qCZRP/X/jTe0NujTQCNTK29hjncepqtcWuoy7bn EDogGfJkBkA9SvWvn7dD1Iw7hpNqt1qAjvHjgtVHmzNI3JUdeBz7U2eCzhYpal2t2YrsBKhhmtOQ zGWFmlsj7jmJMmPzGy3Jzir9uLeVDwPlHyr0AApOLQCApCs6BkdbuMxAj5vKwQcj34pp8i3lEsDM 8KxKHZ23NnHzHHp6VotjaNtbH//Q/i+ur2L7O/2JA8TPhZdvJOTmp9PaVmMkqgjYFwDxmvHPYJr5 ZxJGbfaZGOAWbAHPOfapbdkAZJpHDDIZF7H1FBvHZCG4jAZUXETYjfeT5vpmtC3IsVJjw6kZ2mgY T4uVzINvmDawx8oHtUQijlx9lyJFXy1JBUcdf5GqUrKwmtbn/9H+NRbKZpVjZvlDZZ+pPPQVqHEM jQGJfLwAr7fnbtzXjSdke2leTPpD4CaTZXesLBsMmozzLDawwDDIhkjO5ieucsMDHTNfsj8IvCb3 N74WtLjUDGhvrae3gZjiZkuQoikY9clenuK/tjwAbp8HYxrzf4NH8f8AivD2viJg03p7sfvkj+7D 9inTo7L4SaOLiNI7w6Haw6jDAP3UTQxRxKoPqAv4k1+c/wDwWG1gv8OtQsrFZFt/7NSKf96bVy6k lsv2wuMfjX4XwElX8YVVesfbN/i7H9KeJrlS8NZwW/sUv/JT+OHx5dJo3hOONkE2pjToo/s7AXMS K0W0spGDlTgbuc5JFfjr8VYZ9a8ReKJ5ZoIItFVYjaTnZO7KELbSep+bGPav608f6nsuEEu7SP5M 8CIXzytJ9Ln/0v4c20Vb9XnEOZIWMluBz5hUcgj0qCIyHYjnMm7LIx4HqK3m7NoDqdNgjCNu4MjZ AXrH1/nxWg2miApNK7LGz7oXB+Z8HpXl1XrcunuS2nkz3chB27QMhjjzcYGP8+ldVYyqJI7TBRZD 1QfzrzavU1O6hkCL5UqTTYCrFKrbgBkjGK2JbKWItct5b2sNsJY2QkyZwdy49R7V5k7tGkLpM//T /kT0kXWpx3kFiJUuvJaaFLghFx7j1FXbcG0liF7KbkoMSKvyBWx90eoBr4c7OT3vIu2upo95FA2n QhN2JZ4TsnlBPAJOenbA796u3LQ2JW9+3rEgDNbx5Ejuyk7V46HI7002tjSxL9rj1yWI6mRbTsFn jmRPLhY5+bdjvTbnU4pdWc6fLPaxaeV8u5U7XkIGCx9BnJFDk7WHGPv3Ne2nu4rlWu54Lv7TCSZb kCSVdxyM8fKeD70r3KNDIqRSxuDneiZAHTI4x6Vq5WQSg+Vn/9T+NRLCSXzIxcyCMQeWXGGaVh/G fcY/Wq+nXNzZNNaXVyZViwA0n90ZwT2/CvP5FyMT0RLBNbLdagJ7iGVFYG28lM+YO/8AU5qvNd2i 3g0+1LPIYvtMsrRmNUU9s/XP5VCgramTdxUt5JCEjIAV93TLOPT9Kp6n9rt1lijt8pLtOVhLcL6Y pSgkrownuVI75guxruRFWMRZucohJ/hT39PpTrTyriXdbXH+oYJIHUqAevBP+eazMZpvY//V/i3f Ujpl19tQmQo/71E6SDuPx9fevUrLWINe0iOVbKS2lt8tPakHy4geFKtn0B7+lebB3VjzltqcbeXi 2c7qiLiFixFud5lB5yR6jnj2qKfVhPK9qguFM1uTbyxY85D3JU545rqptaDO40OCzTTBa3L3FxPt WWxkuY1QB/4t4GMEZrzjxXNPBqks97b2zQpGIlkjcPjaOuBx29666UrO6NLe4ea31zY3E9vNCk0B GTdNNIrxTY4VUAX5fXkmvqP9nHXYrXxhobOwiENwsDiPLOsLSLlsD6AV9ZwjVdPPsNJb+0j+aPIz yKnkuIi/5Zfkf//W/OTwTrKDTlvNNtti218pnmkwLe9t9w3o6Hodoav7I/8AgkTPYR/Ceys7bVZ7 gKkH9nRQqZYlQhsgtngcAD/d/L+5vHaMqnh3TqR/u/p+h/PH0eZQXFuOpSetn+tz7i/bj0saj8Ff EhjGGtohtY8mNiefpnp+NfwieNNKuLDUdR0eWRidE1G5sriYNu81Yp38og/7o/Svn/oqVX9WxdH+ tLf5nyv0oaNszpVfK35/5HDzDyPJN1IPt2ogsYgv7+RB/wAtD7VgXcQtiip5krb9rXHCqnYDHXPu OK/tKk9j+MK62ZatNKur/ek0Ty2Mp8oLnPmsegx9f5VJNp0dzqMWlM5sdRsFaZp5iQXjiXc7SDoQ B29a1XxsEmkf/9f87nshIttdafG8s8h2T3SQ7jLhuNi9s9yKr3HiGKHTrmxvClvcyXOIYdpIc8jI PsD0Nf7RQ+I/x/MC207UIVSeKNv7LIMjTKu7DZwRn860NLneCW61G0ZmNtLtjXy8zynJHKdMcHPa qinzXaL5vdsbF9qer30v7q10+0tzE0U/k2oR2Deh9eorkp4YxLLNDbXsfl5jImfdHKR95lUDoe31 rQc2mkSxR3FrJvtpZ7jeUnCuNqQ/u1Dxj2BB/HOKmfVf7TuIbmUuGD+TKrJs8rbwDj04FO9tDM// 0Pzfn1e6tLPUTYuz6ikRltWeYRx5Tk8n2HHvXPWkxvYbeSdJIrydjPKXl3iQnng9Sc7s5PPFf7UH +P8AZHSWEzKIop3QwtNuRSoLBgCODU0+oaFLcPaxrNeylWikEsYtkR+V27gT04rWGxhbWxz9mZrD V51S3b7MVAhhMvmFfXL49O/vXS6xDBDNpdzaXkLbx58hWMs8DkYMbMQMFSvuOeKsLWujJ4EgIfJZ xucHBHPY1rS32paPJZau8UF7azObeJblgzOFAVtw6nAP4kdaBH//0fziW4nH2i7tg9r9qbyRPCSj ovXaDnpzirSzpb2c8WoSzLdGISaS6bJxI5I5cEjA68j0r/bA/wAeXJsv/bLa8t4hdp5d7KAsxhb9 0SRgnbjIyait9GtrCeSKeV2jYlG80ENGpOeuciqUWwc/dszNuILcajHKFcWMEohZo32vOPUZz2Fd LeWGnW9qszS3AuTdAW9uY/uL6s36VqlyqxyylbVlO8t9Vt3V0hDJcoGtZIwWnUYBOMevP4Vh6bFf RPNI0ckoEpeZ7gEs3PIpmNSWmh//0vga5ttJ2WdxpFtc/wBq6nJ5clq2TGoBAJH07VT/ALKuUjZr SdlcThpUjbDBlzgkd8cj2z71/twf4uydkV4LG4c3lmuJ71pGu75ZBiWLIGWx74GKhn09rY2U67mw p3Zj8t1PUoCDzjjP8quMbo5pyadjRtL2G6Q+dCYbiGQxIp58xf74P6YqaC1YTOok8sODlSfnJPNP kV7MzuzLmjFtMY4JZ/KhTfOc4TIPHrwMj9aa0tpcwtILgiIfO90g3hs8ADkDk1aSjsNTZ//T/PnR beSPfN9n+0wohZvOTcvsStNtrBZrm4v2itHZpDHENw3wrj5gFzxn6V/uFFXZ/idOTtcbcPcW00ck qtHbKQihF4GOMD1+lVbkXOpzXFifPYDbPDbRIybtnzLnnk4B/WnJNJIzjK2jIEX7QI4r2W7sZCNj LHIdxJ4AYAj/ACa0/tGkWNq0ERvZ7pn2B5Ywke0DBJ5JzmoNG0lqUrVH1C+iUTGKDaV2FeAeoPXv 0q3qsaW08cP9n3M12sYaG6ikQRBc87gSCP0oMXvc/9T8/wCz87UZLKxguIWgaX52EoKW5PBMh9sc /XirNjb3Wn399ceYlxAsTW8cYRXAPI3qf1Br/cA/xOTuiO+hVUt5UQLKiknPLruxuwfwrM0yy1q8 u7i7s54kexuEh+z30pRWQgb2VTwSuR+JHvRsKXwm7EdTsru6niltZ40YG5ha0V3I4IwT6+2KqBpt Ruria08izM37siNPL2Y67V7Hj+dNNp3M1KzE06JbLUY7e1V7lZUCTOyiMSNkbue3Tr6Vau4GtpLg /wBnSm4uboqk0brJCsanrn6Y6elbilJ2uz//1fiUadcyBYLfTop7dohPazlAbl2AJkWM98YHA/Ku VcTatdwGOAWkFlETeRzQGK6lbcAF5+6RkfXFf7lwdtD/AA7qPoK1q8Ujk5xuyI+yirMiiK18yMvv kQr8q/JH25rU5pvWxraNqBgjXyJLQSW7B/8ATIQ8St0woOc+uD6Vlypa211Lf3Essr3G75VTCI2c 7iMdDz0/+tV097GLkrOx2vhGYMTOi+YdrrGsqn5RjBI/76OPpX1H8GZtVtviH8OpIJbWS2HiGCa8 t5cllRHywBx1wDwcf48Oeq+R4pP+SX/pLPS4Pk4cX4Dl39rT/wDSkf/W/tp/Zl1A3nwz0GaUKhlt UEUca7YogibSo/H9K+If+CqNlc3/AMGdbnjl2x6dpc81wTjMUexGdlX+I7UPA7kV+ycOtUvFuF9v bf8Atx+SeLsJVPCfFcu/sE//ACU/kGtrdP8AQri4mZ7RogyEAeZcAk4ZvT6VJJDbXGoJLEAhV/lI UbR6cH2r/YCiv3aP8Sa0tXcy7yK4h1W7s4jG/nwiNflBGSAxx/8AW96sW2l31hDcXkKos6KAY3Ba KTOAdvfPOa0seROVm7kct3PfQv58hzGQiALjAHbj/PNUUBb5yMKGxuVcLwOcfp+ddFraHHUfQ//X +fJoYnBeJmG9RjccgHuRUIsJESK5dPmBIim9x1wfWv8AfSEep/zezluVZLgzqiysWldyHC54we5/ z0qTCQn94HMfRVyWZa0MSxF+7li5/wBGkkBc8AxjoSOK03gd7qW3gljeKPLJcxyZjYDpzVwXvAQ3 dldoIJJzt+0sVjdpAzfLwe59utQ3QitrV7eOFy8ifv52kLuenK46VqYyd2f/0Pm61jCRKjBguNvJ +ZhT/sqxNGIoSqLyvPA9+TzX/QAf815Y8lNzbpGcP95Cfu8Y4H4VShku47iWzt7eVYN+IppAPKl+ UE4HtnBFBM/hLN20losLlNz5HyIMeZzg/lzWnOjsYJ4HZFU8xK43MGGMUGSdinPvh3iPK8ltudxz 1qmsU6yLJKXOfmILHaAfb6UCP//R8Xsn0qRWiuJBaoy489oTOzMOQBjkZPH41k3UduJhF8pYMNrs uNvcda/6AD/mnJIbtgrWplLK3G3O4KR6VFJCRlmnz5ZBKOcgj0ArdKysBFeyWtoFuJlHl3H8Fv8A J5ZHGW7AdKm8x2iKWfkxBxvMkibxx6c96ZnU6GfdyXUZiYRtIzj93sXGcHv+XerSCadWk2FZXXMo A+b1/nQZn//S+fLO2eOZjKFSFcESZ5Yk4/ljrVq/VpJGMZ3w5CK7cEYHHH4V/wBBB/zQxjcpXMsh WKKON5QuFlI52L6/Tp+dPjuIoUDJFHOyHIiYfKT05oE1Z2E8t59oU4WVc/3efQVdigNgjq6vNcyZ QWzErJAeMHn1z0zQIrR25tyA0eZz8+VOcZ5PFCFS5JO2QnJIoA//0/B2mmuBujEFuYFERcqNzrnr jOST/TpSQW7z7QTvSNs881/0EH/M89i/K8hnjEaIsKx7f3ZwSRVK4JkdFYhAD90jJI/zigy53sM+ wxz3r3ESNGLe2YKTyZwPmJ/8d6fzqVbmOSLYoaKT0K4PFAcztYpbvLWRgpO44Y/1p9hKzT+XEpyF yzEYQD69B/8AWosUrOKTP//U+fLmWQu45YbsYHPFWYWeaL5iwjAwYjX/AEEH/MxHdEChUOGJ2Fsh c4249KllVprgzea3l7FRFcjEYUY6/lUcmtzpUrXiSs0TJCnzF2fACrktT5LhIkMDkLGDnaRyrVZj L40K64WB1RdqNuJxjd9fyqa4y7qWdiCBtVSVIx/SgUndJH//1fCvOgZpYjCruAFDHI2f5xVqa2kC wyLJEWfawWNgx2+hx0Nf9CFraH/MuNm+0PJEgG8RnIU8gZ6/yqK4byCjSxSPETsYwJ5joT0OBzig CklvHHM81r5jO4Dy5BAU/Q/hVy6tTdRRFZCHxl1HBQ+9ADjZbljLqHEagDd1JHOafHCE/eOR8x+5 6UAf/9bweW1Mp2BWKFgSvIPB/wDrVYSS3c/Zljw8J2uyLkKevJr/AKED/mXCZfLQAEc96rRxrHE8 iSqpUgkHktzzQBbjuCY3VkR1kx8zD5lI54qwkEF0vkyIpjBDHd3IwQD+VBlJ6tELW1pDPJMscUOe gjXYDj/9VVJZXLxskjRxhsblXc35UEH/1/EkVPKAyST95iMZpkcUMeUV2LysTtIJHHpX/Qgf8x60 FklRE8tF3yDgKODUawskyM2QCNzAHoR2oHfW5diW2mmHmMyLGd/AzyORxUJli+23EMe51AVIZWUx +YWGSMex4oHzu49o1jG4gCTpwOKkWKJS0jr5x242AlRkj+lBXOf/0PFUVwuQucH06CnZYEo4wp4B Ff8AQgf8yvPEt6dawPOBKxjiRsu6cOwBzx70l1Ey3KyXG8q5+VjwpA4/SrgupiDhMFkYhR0OaqzS GRo42foNqFurd/8AGtbDv0HxyxrKtvKHwUJMiAHHpwfrTCIoQ3fe2cAY3dqAbbP/0fEWt2mGYQQ7 cBByaihMqFo5lK7GwCevFf8AQwf8yCdncfJ5rtuU5HRl6Aj3FEqMAm4kAsMjsBkCgpyurFmfylR4 lG7B/dy4IZh9P1qAAiHbHkYHU9fxoIEi2tjzTknrjjNV7vMKpHCnGcll4oA//9LwKC5aTOFKMh2s zdW+lSPMxRog3+16ZNf9DB/zIcz2uRwRtHAJzne55hJxJ+Iq/K6XMXlMoQgY5oES28aLD5DlYj5Z VJDgdAcfn0/Gq1vBNBFB5vmb5F3kOoVj+FAF+Ta0cbeWsZgJwyr+8kz6nv2rJa7nMjt5bv5XyoAM cHBOKAP/0/HUWCZY5GEi3AjIaMN8nsfepoFeGZFkRNp5/ej5efX25r/oScbH/MeRMqTO8cZRPLJx nheMniq4SN3ViMFeM981IDylt5R8sEyqcyOX3Z9vaqq3F28ZgYP5bNuAAwq44/x/OqatYBYjMFlE bv6umTtOOOlRSx+YFdtwB+Rl/hXPrSatYD//1PG/7OvtOtrcrEpjuIt8D7w+9fqCTVFrcyTJKEyY 2y5PVT7V/wBCLVkf8x5pqIw4SN2n3cmMHLoT2H5VVNuxuCtxItmAfnedWCxjGfmABP6dxVJXjZAP ma3tk8zzo5FVgm+IHY5PGRnB6kdRUluHuJmRLV7hTEwKocP0PP4dacFZ6gZQsfIkBG4Yfjd96tqG FpYXU4SRehZtpIHbFQ3d3A//1fD5YRBJCbiMurSc7RuA/Sn2nNzKI1JhLEqhXDRgetf9CB/zHiFZ BcSNHG5VeWK8+WM9T7cgfjU0VmCzT8kt8oB6jmgCOD97LNb+S8aRNtySAJO+RTUieykA3HD8bmIJ X2oIk2tizPKLRGj2pJJcLvQDnt+nUVmwSSFi7/IFOFX1oKeh/9bxZ5YpUyEkaQd85Gfpils5LdpP IZvMmHzMMfMvODX/AEJ81kvI/wCYuSe5YuZTbu4gT5XG1x7HFQ2zrGSA5RSfuk/Ln2ojrK5mLNCs cpZnAf73H8qekhnjKoGyoJP8JGM8/wA61NLtXKZtcMszuUIO0EnA5NWS0aTBQxePGGfGM0GZ/9fx deJsBioP4A1eRfKPllclhvB+9kc8/ofyr/oYt0P+YlSaVkV5JYlY8r8xwAPvZpd+xQ2GChsHFYSV nYTbbuNjRZPNcthM7QrcPj1qB440YIrNsY/IHO5jSEWIY/mB+6AcZIqzMpNwERiyRHliMB/cUAf/ 0PJL65htp/OjikiluUBmjaUyCQDuPQcfpVWC7t2LK8cm+Vhz1Qdv8K/6ED/mN3aZYuIkiL+Xlin3 GUEbvSqkMT7UkZmDhgzJnBFBRLcTPFcGFhgugZSBkDPrTBEpdAJSCoycYAagxi3zFt2DrsjAOeGJ FB8uK3CKjmcuSZAflC4GAB9c/pQDbuf/0fIvtEk0RhUoCqEDK4JPPX/69FoI49vnjzJYju25+Rvq P/r96/6DpNrY/wCYfYS5WG8uJJA8MDkmR8qQhPJwAAfpTLeN5Jo4oEeZl+Z1jHOF5J/SsrvuVzSL FycS5lTZx8q9WI6VmOjlwoceUpJJC4Zs0i4yvoyVZGR8xPiFk8udHQOW6HIPboOlSH7OVMcag4X5 Qe2Kbbe5Z//S8TiIkiaTnCHbnYeD/kVFK7hQWAEYHzE8AfWv+gqMuU/5jx8UKOwAkIVyGOBgfWpx Aju8TymMAEoQM8+9U56AZ6yJ564jVmibYzdm/wAK0GSTaWAxjnBHWswHpPcRwPAYGtpZfvyNw4XG QMe/B/Kq7wSOYwitLIFx8oyx9cCgD//T8QtoPtCzBSA0a5MT8NIcgYX35z9Aau7IoLZbRYVgmJDO f7475r/oIP8AmPLEKhrcjyxtB/1nX8P0qp5aAOT8pGQDig1g9LFUeVE7icZBXg9GXP8A+qomSNCg kk8uVBvRQ2Gcf1qJ6Iq6vYe0RmLMWCqy/Lxnn3qzbyxxbIAu+TGCOg9wD+P61kM//9TxyS3SJlM0 R3gk4xjFU50i8zeV2uDyMV/0AH/MuUJ5kkBiK7QzA5HG7FWI4kjUbj16DFAEzRwo673O373ynnin edIzKtuy/fDBmGQcf5NAm7IbcxM05aX9wyfIFzkOR7D3qwsiSReU2Mpypx1P1/CgIu6P/9XwdyUb y+ozzx0NIZgjiNwxL9OPpX/QAf8AMuOuBEqQvISn71UU5I+YnCj9aszxSumcMwB5kPNAEaROfkYk KDnJ71Wltrx5i6FDGi4+b/WNjgY/z2rOaV0BMtvOCNw4HPy8Un2OR5pZLhZo7aAjy2C8yPg9fajk S3YH/9bwm5u3d7cSMmZP3a+XGsYwo4zj2HXqaUY3AnJCnoc5r/f2SSif8y4LOrSSvkqVUhU253fT /wCvWdAz3bIXVoiB80ZGCPrWQGklsqllBbcDkoeVPvUJPlzKfLyhOCvY1tD4QJnlTkHIVBjGOTVB 54VdEKFjID04xj1pSSSYH//X+fXd0X90Adw5UrnH0q2rXAtE3RgMRxk/Njtmv9+Va5/zMJtbFaEx mJlA8qRWJZf7+f8AP61JA8RV0Z9m773OKI2vqXB30ZBPdwW0M6C0lurglTbSLMEWIA/OSuDuyPcY 96FkS52GMsPkDN6c0i762LjQpbFXQyYZANjDjJ6ke1USzGRkOQByCeMUDP/Q+fI47SR5BLCqiQhJ bjb8zAdBn2pLuCDa4SNGiVsqzKCxx0PtX+/B/wAz4llcDaVUbgeQe/8AnpS3NyjqYyTgnDqMjOOx oAgaVJTGjjGBhR1PFKXS3iI3FYkfzDgkc96AJDOros6kBcBlPTdTmf7TDLNIoIcbH3dXoA//0fn9 xKkIkkjwFQID1yqjAH5Cq1xFBqVrZlIJLfyJvNL+Yd8rKQRkdsEfrX+/B/zQqTRIzKrCOeIS+aMt KxOYyOh/GrVzNp0pigjbDJAELqm0yMB1P+NBstTKa2MQEgy21gpckA8//qP5U+fdtVE5JXcSOQKz muoFZI7WFBNKj3EjybVUnCRYxyOPrSuWWZXYEo3AYD5UFZlRly6H/9L57ilto1Pl4l3jKzo37oeo x1P/ANaobmSbaFhK5LgsSM/lX++B/wA14k0qGNozInnbc7edx+oqsiRx2cnnhHIwzN39sUANhMSI VOTuOQe30pGinTZcqmLcybW5+ZgOTgZoLjKysGoPFcQwvaFf3JPm7V2MAMYyPzqxZ3LuioThCc7G 4B9/0oIP/9P5mvRJHJIY8txuHTB9hU1vnyIXvkeEzQ+bHGeJVBBxkV/vgf8ANpGXRkLEFXTCyIeQ SASDTLOGRD5SgqJScxBfvt2AH+HrQJyV0XbBTdXKRbBI/J2HKxnHUH/DrUSSLPv82HZskyI2wVjI 7D6EH9KDQZdBS0fX5mGNnGKbeKriONZS3B5R8q4IHDdwQc0GkOx//9T5btkjQMGkXKPsXPUn0rXk hlmt7dVmj4cqY1U+Zj1P6d6/3wP+b8o3Jgs3NvdRu6BtsT5K7yMd/wCntU8UwiiITDBxgJnmh7aF qTSIIkOcBSrH5Qp5xTCsUFvJDtZrreZA4bgjuMfXmuc1g7tMoIly4juJS06FzEIh0j24xke+f0Nb KW730scUFo3nGPDTMp8tewye3/1qzn2Og//V+brWC/0iGZ0lQRofKmaNi2OcED8+9fsV/wAEobJp Piek9t/x5XU6SKEJaKVgTvbHYjv9DX+w3jbNQ8Ocxv8AyP8Ar8D/ABf+jJCVTxSy7l6Sv+S/U/rL 1Rtnhy5aNUVRp+WGMKvyrk49ua/jD/4KIajDf/HW4glvWjMlzcbM/JbhppsNJJwSdojIAH/Pb2xX 8SfRXjzccVJeT/U/vH6XNRx4Mpw/vL9D8qPjrqg0Pwjqen2twbqeWWexiulx9niVY4iQg+9h94Jz 6HnsP5+vGi3Fh4o1eNoIZ7S9X7at1bHL7n4KsvsQa/afpc1X/qthYd5/5n599EmlpiZnLJISDBJw vU4HI/Ws3UsYRYwzYOPRQPWv84z+7orlR//W/jgCCe3eGObdICfmzu2HsP8A61WLKO5hCLO6vIq4 8wDb+IFc0tIsSaehd+ZB5zvvVGxtHb6isW4e8vGuEgJSNcM7ADp6VgMdcXzKGSD/AFyQAEyfKM46 k0lpMbi0hilTN45PmsDlQBnkd+1Zz3sNOzuUWcafJcvEHaSXEZzl9vbgdqvkRxwxknLOoZ16cmsn ojTnR//X/jGjhae5kLMVA6DGAa0bYp5wF4rFLYHymz8p+tfPgW4jARK00fmI6HywjbSCeh/CsG6t XjVnyxTkhWO480Fwvch09okAgmyiZOe4fPatWciMhQdgIwo70Go63vlu5iEjKzwr5YymFfHoa6qO 30DV9NhF3pZ/tW0uA32vzmAYYIKsnTB449hSaA//0P42dS0zTrbKpDFAjMSfJQLuOOM4+nenQFoo UFv+8YrzuOFHtXznIjpSbdkc9qMk7zPsE3kOQJYiflBHpV2wu4pEYsm0oPK2v0ciiMeV6m1kjKvN NU+ZKrmKRiGih2HYRnk5z/jWhY2jxq8nnMwWLIRDje3oRVkWXM7k8U0yHdeKq5TCovKjPfmrMrFI SkJRmkTc6soZgueCPy6ig0Wx/9H+L83DSTWkTlyJdyonTLY6k+2P1rXEK24RHKPKq7xznIrw6Z6K dncq3KN5n2hdwDAZXqoxUcqxXMTeQyMqA+ZFuGQQOTWg1KzuU7WCOeBnjXYsIJKHgtg9qAiGSIxe aB5eSR91TxyR69KDVNNXHfZzM9xdOI99qgBkACZBIH+HFLbyx78yOyccMeFGB0rOUOqM5Svoj//S /jUtZvPQIsZlmwfmz8pHYYqBJJbd40mR0MspQrGC/wAozz7cY/OvDgup6am0rGZq9zC1wJ7CKXdG 3lIGJXzB0O72PXFT27TTIftkSrGgDAg8g+laEF5mjaONWUPlsp2IPT+tZkxaOKRYj+9Byw3c4NFg 8imhZ4VElwo8k7jJGcfgcUlvNPJMsEYwiN+8Zs5kHYYpJWVioy5Wf//T/jPaODYLfyTG+N5ULtUf /rp6W/yvJhFgVOVHykYzk5rxz17oh+1WVw8iRSKbq3QM8Of3gU9Dj04qSBFcNKZDHKv+rGMZoLUm tCFHRgyoWe4hPznbgn2xj+VTKojCON8iSPudFPJ9aDSMr6M1LmOGRUMTMBsDfONuOOmKp2eowyXb W2x0ktYwxcLuifORjd6j096pLRiu3I//1P49RJDIsEkONgciduhT6D8KigVXuQiTi4LFiDIQAnXj H9K8WXwnuQVro+rP2aYlu9c0WSTFvJDcSQXatEVachyI3buCBt4HYV+2XwLt75/jP4E0i0MFxpw1 RbjUPOj3h2EsSwuE/uh25IP8Qr+3vA6KhwBi6i7SP5C8Rl7TxNw8O0of5n90/wCzRayQ/DaC5Nu9 o99tuprcp5ccWFzgL1GQ3SvxT/4LL6zcWHhOaOOa7L+JLnyY7GKISxqysypk9hgnPbmvwjwrXtPE 6PX97b7nv+B/Rni5Nw4CqS29z9D+Vf4labbyeD7fUT9gtmvC8sV1K/kzRm2h8x1XB4yMAL3YKK/C X4nT6ifEGsziee5t5rlrq9+1DEyOwH3vUAAZz0Oa/qL6RtVw4do01/MvyP5e8B6S/tOvUt3/ADP/ 1f4h9D8RJpmpQzRW63IKFHV/lChlIJ/DNZbyQyyrtJAjmbIfmRQSTj8OlVUfvNgdJpskW0iLDNuK BWPPA610d8tvcWMETmSPUCwitlQfum4+Yk+vTivLqvWxdPcxptLnsbqCNpS8pb7ytjYe/Q+9dvBp zrFGyPmTaCH6sTXnVWanVwW729ssslw26Ucx7emP89a2LC7lgsdRu7t1EEChYIY0aS4cEEEhe/Nc L2NoPQ//1v5IINMgtEt9Qtrm8El8AJIXB2p6ZGMqT3+lWTp4iuPNnUuPRjhlB7kV8Q01oegRX2kw ybJ7e9mtHjPmMiY/fjpjJHWpU8Kx39zYtb6k0bmNmmaciO3BGSvB78CkbJxbMvVrnUbWe1t2tpbi HzAk94oO2Er0JwOc47etdjpkQl0+/wBWuNFezht7gxtEz+eHAGEfP+16dRkZxkUNaDSSdytdWy6g HuN8kcM6geUkm3gZxnH+NaEWuyPbLpfkC3+zs1s8oO55sHgn1x/Sql0KaTgz/9f+NG0aOEtp1skh kkBdRyQMk5O48dT0pXS1m36VdSJFc3UUiJOuXDYHQkdPrXDF/u7GkopJsz18MqkcthbXJY2lnHH/ AGlasMo39wntjHJpLpDGvkTDzJWjCLPG+7f2HzDrUnL9kvtM9rYEMoErR+Us4HMPuPestJYWtfK/ tG/EcR3Jc7vMO4kFgP5VM/hMJ7lWaG4mv4TGIby2iPmyNcnD7ux2nOfTrVu5WGKNlBEf8TlRhV+t YkH/0P4tbURy78Ikyt8gI+YFvb1Nd/4c1URLPbW8yJtg23PI3kHtg15dPscCWjZRmsIJpzPbowdG IWRlwyn196r2tv5unyJEIHvIrmWN9WK7buQcDZjhQBjOAOpropvoNR925Z0u41WWC0tLy7N4thLI 0TbfLRQx53Y+mK5vxpYRm3tZb3yVt5HMqCC4Bd8fwkA5A+tdlPZWLt7h5fczacIygQjK529cY9D6 16d8JdTii8V6Tb+ZJbzalCRZOmVdfKdSQG/HB78H0r6Phyp7LOMPJ/zx/M83NI8+V14/3Zfkf//R /Ln4Y3yal8OfDFpdtbQahcWs323ysxNcBpmXzH9yNw+gFf12/wDBGLVkfwHplhpluhggRrchLkXC L5JdeSCc9N3XvX95eMq9r4Ywa2tH8EfzT4C2j4iYyHX3vzP17/ak05r/AOEniY7FkV9Hnkuoyc4Z QPLfH+y1fwdfFpFHxB+INqF32r+Kp41XyDC0O0IWVhxgA5r4T6KdV+3xlG/2b/ijm+lLT5fq9S27 /Rnkkuo232y3S/hFykYFt5sJAnWJf4A3bp79Ky7uXSlN2Umigjs4/tRsbmR5bry8/eBVecc88V/c FE/iWpG0UzLt9bup7m6giVbbT5p1ltI1DfaOBgBvXg/41bhjsNQ1aWa5uktL1bZoFvLibyRKB96N 2PQHnjvXSZtWgj//0vzstPElxb2d2NO1H7Ntb7PFcwBWe3I43KDxzz1GPrVGHS7S8t55NUuZ7y7T MsF1tVJJHY53Nx+eMZr/AGlglY/yBs7EC3l9axpaR3Uv2eNjiMMVC54Ix/nrUdrdSnUHtraLfNIu CD8u/wBDzxmrHKFlc6me/uNJ0+2TU9PSKW1jVbqdkLRzsx4Lcc56D6VkiW9vZWuY7RltUAm2CIqi gkc+3JH50EtWNBZbWJ/9IZLY78PI3EcZPrjJFUrhFtbS9SPTba4VAZzMCROcf3D15yOMUCP/0/zU s44ygF5beZJcQGeGJjsVAOTuz6DsapykRTReUPs8d2VRWmQLGnP8H5dRX+1B/j5zJNpmzFp+oLJB IpjnjsCJXtXX95PnGG3dOR/OufvIFhuJ/Kt3iZ5jNwcsrE5PP+elawVkZp+9dnT6PaxtbXWo3LOV ii8kyoNypIQdgx7kVmXzLNdCGaYWsSAF2ILFeM7io55/rVg9zLa089DAs5cbxsJBTzMHg+3TNdVB YQXFvFbys9w1uoIBfADEc8fnQI//1PzysoNO1KbUdJS/a2Gkac2oSu8EkkW5WCiIv0DNn17Z5rFe xmRYNRmt2NkqA212VKZOThcV/tgf48dDoLPRbF7R72S9ybo5EUTkSRtxht3bnGBV28+xWelW9lCT LNGzPf3d7N5hKHoxJ6Yx+X4VcW9iJfCzj3855Ylge3mBbMRhl8z5ccsew5HT0xWhJrdw4GmapbhE kxHa3EGWnLYwN2fX0FanLNe8jZsb3xDZX9nYRadJeWsVuWe3ZSLu4Mi7UZD2GOpPrWFqWreJIJ7m 0vbc2beYGFpJGqMnplgM9D60ESi7WZ//1fzYl1m/sysMbbmuUCqyYYwg9SD1Hvjnr61v6LqzxXUb 3EEEl2qNE6+WWhcH1x9AevUV/twf4vSj0KupCSC8uprOUvd6gDLdyAFGB5+QHvwB09aqQXrbIVdz jBVweShGf8/nQc0oXZoSxSW8Ed5DIrODmMAg7iD3FaUeqR31jfQXVvtv3txELpVMUdoScllx16Gj bYiULaopWjxW0kEVjE01u8ax3z3r+YygqFkIbHILdB2yB71DeO9ql5ptiwgsjIk5s/LDrlThdpA4 IBJ4x1PXpW0HdCacT//W+ALPU5NNVDguvOIpF+XGOhPce1VF1CFWuNQntIYNz4zZgqi5PA25/wA4 r/cFNrY/xOkrov6ZqyX8p0dFhuHvWBhlnTMluQQcRn1PT8afd2xk1K206dhGycJPNmJRtPRiOeva nzsiMU0mLJcaY7/afMtJrrT4jGEaMxqm3glhgZxjvk+9coqvd3MrwvFIryFmcsI4uc/d9vYVImnz WHWt6xS+aK3kDW0ot5o2Ta6k87l9qvRrqV15c0MYGmlTbXU5yjozHjOex6Y+lBLVnY//1/zzi0u4 0+WaFY0NsjEedH8sbN1G31pLfU54XmJSV4BiOVV646Z/Wv8AcA/xMhsbF1DFMhlgulVUQOBIC2f9 kY9ffFXLdZHiV95EwO9u5brmgmbu7GjDdXCTLP8A2berFatGLqaRAYMu+1CQRjGccGku57WRpJni t7cLLu3xRrE2R7DrmqirsgxzqaLqN0PD06rL9n8qWEx+aI3MYYnDDnOc4+oqvZ6y17ABqa+VqEUQ gLQpst5QPlyUHAJA7DufWtjOb6H/0Pg7Tb5Yo2vLa8uLZ9PvnEQVmVYjgE8ngg56elWU1NdUv5Zp 7iE3Fz8xZf8AWXLd2I7n1Nf7kpe8j/Dubfw9Csun3DeeZ5JJX83CJEuVGfU9uM8VpWsU+m3Jiu1j mQja8BIKY9DW5yzWrRzGpjzb+e1tbUxWmQ4RQW+Y88dzXRXVlqsZso7l4Zbe108yC1EeLpWkwR5g IyMDt61UPiOaztc3PDt3tligjiOAjOzZCmMrzgjvkA/lX0j8FbyRviN4at48lGv47uUHgII5Y03L 75kx9Ca5s4jzZPiY/wByX/pLOvhapycWYBv/AJ/U/wD0pH//0f7Qf2RLhpvhnp8b7mhiiVoX3bgp bG5cdjnn8a8A/wCClqW1n8E/EVzPBDJb3GlXVtcPMDiP9wTxg+gz+FfsWXLk8W4J/wDP7/24/L/E 33/Cmu7X/wBn/wDbUfxowyW19YW0jn7N+5DW0MOWBIbkN7df881fKWts6tJIE8wFoQMncR2r/YOk rU4+iP8ADiv8UvX9TnNQDw3NteCaJJnfIijJ8z5T1NX4tSbUo5kwlvc2N1lFecEyoUBD7Mdjkd62 gtTyZ7jLW2n82V5YhmRThz8sYz3H6/nWUTc2l06xIkkHVlZQ4zzzjpWpyVL6n//S+d0l80NuUlQ2 3jgD1H+fSpQtvLJFbQyyCNZPvXEmQjEDPPp7V/vulZWP+bh7sqXD/Z3kAiR/JfA8rBaQDjIPfpWj K9tNbpMImgeM4KO4YyA9D2pmU209CFiFhZlXKAAMcfd5/wD1U4yzWEDeUAY7iLZIgUMwGQePTp27 VcNJCc30K8n7tY55HYgkBA/OT/nFWM3Mlwg2x7JVJcSNs2gdCO3Y1qQf/9P54uchwiAu+0n5V+UA dahDl3EYlVtoDZXI59P6V/0AH/NeXNsZIdVIl27GdhkN+FTSLPDAAsgZQ4YqBlyemQaDOb6FaSQs Y/MQMy9D/T9KeWBG9DtAblR91fpQZjXuI4laZtzMq5+7uz+FFrM12rFomjUNtO8bWcf4UW6Af//U 8Da3ZQREQvOVLchaq3skTITI5JDAGQZZpDnH86/6A1Bpq5/zTkMSuufLUcD7zHmp5BMjKrpkYBcn rg9K1AlMNtdRyK+SgHyhsY/GrVo1k8cwllSH7MgQRLGwLYGAeB7d8UEyV0Y6yzwG7Z4pWWWYNbSu fkiQKAyoPc8/jW9ZqCjypukXZlht5GeDmgxP/9XwuMMN6OA8ZbKL6Ukjq6mIxlDG2VbPHpg1/wBB B/zR0+pVWFIZWviXZgnlbdxERB9VzjP+NRx2ktxbztZRhLkkNGdoPCnLDB4wRn86CZfEyJZHmKLc kKx+WMxjywnpnH4/nUphEJGbw3FwPnk427T6e9BI44k8pV3hwv70kjaTk9PQYxUU86iWKJIBtDYm n8za7+gAxj1oA//W8Dig3OoQ4/iZn+6B70WU7xXNzGr/ALhpCsJPVUIxgn8/zr/oIP8AmZk3ezJ1 ZoLtNuJUJxhclW9akmZmu9v2d3dRkIqFgBQSUITdCUxqW3bumcDB6j8q0FmtZGuYlQJPARFOpGGj OAcj0zkUAV0KKGWT5o8Zz6VNDDEluWiOCz4wx5oA/9fwGOQK8sJ2u5PTb8y1BL58bEAOoXnphTX/ AEFqD6n/ADLjY2G3eRllPI7VeS1S+tpdsm1c7WMbbWBHJH6UcjvYBUkaKLyowm1DtDBRvGPQ4z+t JJ86EzpucnOepNaJJbAPtInkjkBV2iTDuhH3OcDP5j86tfcQzIh67GJ5UUwP/9DwthkFgoyRkioU U7ML8oJ+UIcFa/6ED/mXLG+5Vdz92xu56elX2ZY4OT8shyxPIyAcUAZhlMbZiOFlXJYHIYen6VA8 siMHCnYcZA46d6AC61JlWFVjkOWwdqkgD1NbtjcW6GGW4RZY1ILRHqw78H+RoA//0fKz5F1cTTQq LaPZ8kBO7JHU8Dj6Vhi7EC3CPGQZJMBlIUAD+Jh/Sv8AoQP+ZcqyXSqmZEJjXADAbt2TUqQtOhbh BjpQS5WbRLZ2x3He+QnCjPBpeUlYo25hx5fagxLXkPclPNj8tMkLIRhSQBke55H5inSW67NqBQY+ oIHNAH//0vILNRPHJaSCKJgS/nScHgdKoC4iHmrEyymFtgZP4j7V/wBCB/zHkZRo7hJkwp67ujfS rEkayPCvmiIlhvLcKfr6CgAnAQ7IyGkx1U5BqtODII12YboWxjNAFyRQkS7T5m0YAA5zTY5WQDeO c5B7CgD/0/IYbpJsxbAi4wSBy1Q3SIRgMVVe/Tmv+hA/5jyRJFa3EagKwGA44ZqyLt5UKK7se0eT mtae1gLEMs4TbIvAHB6CnPOZdjPGqmFdg2qFJ57+/wD9arAqFiTJLuaEqdiqx5kHTIx2+tKpdyo3 bnY/KO/0FAH/1PG8KIFJfEmSHQcMmPU1nNI29otpb5SwP0r/AKGD/mPH28qojghi56YPT8K1Emij hkCFWDoPMWaIM4Of4WOSPqMcCgCKby4jEZZodjoJCyPkIM9G9CMdDSTLCyzXFvcB45JNvAIHygAY HTnGaAKq/cGACxGDntxSpF8x3MMHjB6UAf/V8Yht44sldjBwVYYyVqvJDCX2oCMfeyckGv8AoYP+ Y8kVIjwPvDqfSmyQoCrDk56g9aAEuLN5gjpLtCnlTwDUyzB4sSjdcRgRxSiQ8gf3l6Z47Y6UAMbz zAQQN+c1YR4zgJhDgK7EcN64oA//1vD7gsLgCM4OMAqOfetHazwSOHAZF+UN1c9K/wChWatE/wCY 8yDJOibjGwOckDk/T+dXoYTJ5Lu2xX+Z1x830Pp0qEla4E5MIMsccaKoIwF53cc1Xnu3jXyTEVIA OdpyV68D3rR2a1Ach2wM0YIkcYz6dqpyM6RlGzhuuBx9aLq/KB//1/EbWRre3k8rdNnnDsflPtU8 GCjHJLtyR2r/AKFpr3T/AJjyoSUnDA45+arzOkMm59s2f4S25M/1ppWVgC5mDzR5it443XiNUwM9 iB+BqzEs6sptiUlBzxwQO9FktQKskguZCzHBHU56nvTPN2EuX+WP8KwA/9DxKa6LDePmC/d70y0d lOxsKWJYZ4Jr/oRTs7n/ADHl9ZnSOdIziWVPLfBxuXIJB/IVXN15dvLEzCOVR8pI6884pAR28ibB MJQ4bnIqxc4kUPnnHGe1P7NjOfQiAkQwu6JIAcBm5wPp+VWHVZoQnlgOrkq2MZB7UipNJ2P/0fI7 aaGFwgAaRCG3AZCmnyJFFcGYOvmTAl9i4PPrj1r/AKED/mMk1axCs8MV35d0jhZEzHjjccHH9Khm RN6BULKRhQgOV6gCqjpJGQsNstwyIsyLIzYxJkhOnJ9uT+VJJAn7sxySb42ZZhHxFIOAPf1rYpta 2FQeYGRhuUDjnofpSpBDs3u7KUbJGAQwo8iT/9LyK48vCNw7BcYXgjFVY/MO5huypwM9K/6GD/mH JZ44ZdkkcG6SIdF5Z29qmmSRU8u6iktJ1+WS2mQxSxHgjcD9axl8TAks/sscNyLq3uJ5yn7l4ZAs cYzySmOenrWSInlY3AVgiE+SJF2sB/SpAtG5LIibdrnlyByKAZpmM3IRMRkHAP1/SgD/0/JzCpXO 0MxHBYdKyZIZYfvbWYcghcL+Vf8AQgf8xDbasWoJXcI0pBO3lQOVNEsqqclT0xkDJFA1JooK7SB1 Vsnd8kjDt/kVZjCh0UruK8lsdDQSWTKxEqW6kl2DMB221LBMwIDJhwcHuGFJyS0YH//U8guoWw0s A2DOfXbWasMnmrMWbceCM1/0Fzd3ZH/MOWJEMeCRgt6VYjZ1Dm1ZxLs2zbOCFJ7/AFxUAKsJht5Z 5ZB5rkRRoxJce/p6VmqtzDs80lwe5GM80Fw3J0Y+YU4BK7tp9KfKXtbdnihWSaRCiK/3VJ7/AIUG p//V8VjaeONouCGwx28gnHXFToolBgaMSMVJ8vGdwAyeO9f9BcFd6n/MeRSPGHQNtiKrtSNRjIHH Sk8yJXzyNwwCR3pOLQEC4V2AVcu+R8vNXrkGa1YpNHFdQspCtkmRcjcoA4755qQK0XmshB5Oc5PY VMbqWDbJZjFxCMgyH5GP5fpQB//W8IRrkv5iuE+bLkDJzmtcXhZJHnAuHKeWC4+cYxyD68da/wCg g/5jyrFcSW5kB3IGPKt0NK98Nv7vb5oI2Ky7lJ9xn9KAWgy+vpLlopLqG2SSKPYGtrZLZSB6hQBn 3pWnSeJBKsYYLtDbQD+dYz+Ib3JUjVIO5IPB9AKrW01tI9wVtB5kz4Ey5Eybfl6+hwKkE2mf/9fx prhpk8uZXWWE7S3QEDGKhFzaRpNG9s088+BFKr48gg5JI6HI4r/oAP8AmUlK2xUktopYdsnyN5is JQcFNpz/AJ+lTxw5TcWLY+6SMcfSgpO6uiDZuYs0i/KcCPnd9fTFOkR22+URw2Cycge1BDiywbWW UkyEnjIPc02FdrvlCQqng8c84/pQXFWVj//Q8ViuFUBZI1kldiuTHlE98fhTxHtWSSUoWA6hcbR2 x6dBX/QAf8y5XZ0dNktv9oBcFcP5WzDZznB9PSonu2TEbfKo6kZIH0oArSXXIKZ2g8k1ajvJfMSN 4T5Lx5WUEDPbGKzm9UBPLceRhkGSfljhzgtxUZmvDB5cskuJAXkhySkR/lWYH//R8ESFAAzAHYdy k9BUrSoBuaMgMeGRSQfyr/fpyurH/MpNtaIvLbxDM9szqwGQScMDjmoYolJEjbUOfnJ++T71Ioyb dmWp2VdirhT3fqXqk8UrMGQDylGd+7nPpVKTjoaFbcrDDjqc992PeqhsQ8jyncpUfu8H9P0pNtgf /9L57SO43oPl/dnDAjPTirDSrGfNn3EZCYHOcnAr/fix/wAy5Oz2hfjb5igEL1P41VaNfnyPlOTn pig2grIjjaEJtJUZ+RZCQMZ461tX9nParbWjTW0ogiBBtApjG4bgCw+9973+tBRmod8TIXbzw4C7 uVx7fl+tKEEkq+YcCNdoPGKAP//T+eZi01w0KoQiD04bHpUrHfAY1XG37znr6Yr/AH4P+Z8iH+gQ 7mjIk3LtUrj5Wx8305zQxRzLKYkBfBJC4IxmgAtHYGRltxcpKDECoz5We4+mDSeXBcRTkSjZCxSR h8wjcLu2mtE7R2AZuEtvDErB2UfJhdof/OBWjDC9uRFL5akjkD5ttZgf/9TwsyGQSRnjZwobgN/n 3rMLmKG58ooPsi+bIHPCgkDP6/zr/fg/5nxkVwlykbFoysoDBl5BHtSX0P2dRMqFkyDuQZPJC/zx QawatYGRpeCmIQgOR1J6GgqYVBbOxj8vv/8AqqJuysWU3IVck5XOQMdKdNcKEiGGPmP5YG0nmsgP /9X5pZgD9nRfLZByvT61NHLGInQ589OQc8Z96/3wP+auEujKW83yXMwxG6EIwHyyE98fl29aoxiQ R7ZkkMC/KxJJYemepoNDSTMgQEAKhHQYJAp93dCNkRI2CEcknKLQBBbRmOQ7CjfaOCrHCDPGDV+5 ZYoYoj5MTQIUVYlwRyTyTyaAP//W+ZDKxVeQ7Dr9KiCyXEhaRzwuFOeAB2r/AHwP+bCO4W7MhcYz 84wTzgVYnabzLaWEZktLlbhSDgtt7fr+lArW0NCZSIk84CP+IFRhueaylwDlSPL6sx7+9B0F/wAh dsbCVXikTzI5AOF9jWbCiQSTCVZEMZ3yArhsHsM9M5/WgqOkkf/X+XI2spEkhkjEiFtxDZBHvn/C pJlvIFjhtGkhl+VoW27nKnBGPqOlf74H/N+OlmuNtss8huDbuzbZsMct1P16U5fJW2ijSN2njcuX Yn5h6H3oNoKyCKaSaYpMYoC6s+SdoUKCcDHfjj1JrMZZ7iWIxyGMQKQvmDy5FUnJ9/zrGSszWCTN C2V7SSS4ebzi4BdCgSA++B/nrWq1/fC0eOCRYFmYSHYoA46e/wCGaymtDpgk1c//0PmO2jllvEa6 ulmEjASrGCue2Av86/fD/gknosx1u6mSxeJrXUA0QfCmOKRHc4A5C85/4GK/1z+kBV9l4b4zzsvw Z/j/APRKw/t/FPDv+WEn+MT+mTxU5g8MX0xdVEFoSwztBwv/ANav4of245Uuv2gdatZHP2u9t5JM 48yK3/0qSMBj/DnZkeoav4/+ihC/F1aXk/yZ/Y/0vJ/8YtSh/eX5o/Iv9pf7bp3hy20yV1E9/PPO 8SJkwtGFjDtL1CkKwwP7vNfhbquqR3N5OoAM42Ayo3mA4GOT+H4V+qfS6n/wg4Sn/f8A0Z8v9EqC jg8RL1/Qz2Uq28kFunA4qjcs0p2xhcKMSd6/zykrOx/b3MnE/9H+Nh1SB0kiJU5O5FGPMq1HK7BZ O+8CRTkYHoP0rll8LMebVMvTIZCRGxVWXlT2rDeaaGRreIFWdfmccZGcY/SsS3PTQkaNrpowGGE+ WRSuN340scCW9wjoQzD92DnheemKwaaeo4yTJpbWGSViZ9twQHKHngcfhVBbhXuWiVC6oNodxjn2 9qTWlij/0v41niEsD26u0ExOd4Xlxn9KZPaKjJNPPJFCiBJFzlXOetfP2toAI8iyDywphVcRt69c 5/KorueWR/mXIxsB/hHNBcNyRILdUW4dUaSM/IjnCsfpVe9muJRAZVja4A5aNNqAeg/Cg1JAgLQz xztD5RDF4zsLY7dOM9K07XU8EeVJGBk+fvUsGx0xQB//0/41bi5+3xKylTGkpLrjlj/hVS4vERVt 4HEdzsLJFnL4HfFfPnVGXKRWv277HHJOsJuJCSqbudoPVh1Her8ttATG+1YRtBwnQn3qHKzsbFe7 SWZlfzdxjjCIjdSo7VElysUSyIuZM7TH6VZjJ3ZV1K5hu5I/MLrwPkUYCn3/ACquk7yXSsP3aoPv k8MB2oKjKy1P/9T+MKfzpRJNbxI32ZN+4NhuuCR+f61OsybEkuh+8fCxqAd0h9h+FeAm1sdsZ30Z OwlAkTa6YA2gLk89vaoVjt7GeRJLYi6ZMsjZQ9M/N/OtOddQi7yaK1tdxqFjEaq7SFAFOF6/pV54 jEAyFWLNnb6/SmpxZom1oNluRd3CtNbJHDGFjkijHlrLtHc1n6nbJcbLbGx4nD4XgAEcVEpX0Qj/ 1f4y1tRCUaIFAIgA2/gke3anpqU8TlZoN20ALcKp3rng814cJJKzPQKN3JbGMhWdZN2cMM7s9agS 4FpZTKYxLvOY97n5TnkY7j27VotdgLouoeWEakugVDu+705H5frSPFC3zlR5mzaCW+93oMWnzWKE MZ8oeXbiPc5QgqcHHfmrkUYjLylP3h+XpQVC/M0z/9b+LtbqY3cnnOw4HlHqCMYIP41tRtNEq3LI jKhGIHJCSD3/AE/KvHPQMi8i1Y3kV9NaWJW4YqZrXEcsMa/dDLjp7e9asWZmi3Arg4+UZx7Gg2i/ dRHqdrc2JBXEnmuPniHGD0/+vVSC6ns7i3KmOVQSZEkG4N9f1oLi7M0YJWlV/NLEMxOBxsHtWCsj Q300VqJGVZNq5jK7snqaBqTTuf/X/jOs1uhds7n/AEeRMlgdqhh2x361fnlWxtbqdEJfZ+7aNCzk n0A/CvHse5Dqfbv7L8WpWN1oN1fTwvffbRIEaBZJHysRWMgfLyDjP1+tfuZ+ydpP274x+DGEmLm2 u455kEXmOIjLGw+b3dFHt1r+4vB6P1fwyxVb+7I/kfjGKxPi5Qpf3oL8D+5n4JQSWPw/0+CZWa4E EV5dTE5Ry0K5XHbGD+Vfzj/8Fn9fmm1iy0y1uZLdrnVLfZYtN5c08LyEOsZ7bgx/MV+H+CFKOJ8T m2vdU5P7nc/ffGuTpcBVE3ryr8j+Yv4xlk0czWiGGSOxuptOhmxcNAFiO5WXoQdnP0NfiT8QtauB cTpKLaeOcAzTlCl3I7fMTsPQc469R9K/oP6SVZxybDQ7y/Q/nnwGo3r4if8AW5//0P4ZojHcyKqf 6PIq7sgYzjsTWpZpAkixSQqZ3OADzu9xSm9yYPTU6yzisort7aN8S+WHS42EKpxyFB/r6VrTIYLa FboK7QOWjuhw0hxjOP8AD1rzaq1LjujNih1Ce48xjbBXdVgdm+4Dxk5ruNOYRhvtVykctu4ijXBL THPQHG3jGevauCotzc7hUGpQwxF4ln4/eNiKLjjk0jPHJEbe1dVkTMLLuG4sOCR7VxNWdjWC0P/R /kgtNSjsZTb3EnnyrhJEL/cP/wBanXtjqGq3d1qdvemGOwEcUtmrh1uASRk/oOK+OavoegRW0lze JMJFVJEfyoIyCEULwWJ689avJcTxNDAoPmxne7EfJtGOPb65pWirouG5rNe31/8AuLKK2ayuCLsS bwIIpFG0ANzxjP5VBf6rPLIdMhgMVt5Kec6SlklcfeyOnb9azlbZGmtxLdfs8iiUZgx87g4H4Vcv 9Nj0YRXcMsd4k8oud6uHEW852uexHQg1U7aDd+Vn/9L+Oe3S2ihmllkKHrHtXaIx/EzN6Yz0rFm1 Cx01ZlaIRrcQtHarGhkleU/dI9MnGa8pSvA6qsUo6GLaarqtpa3OlPb2kMWtsJbt0m8y4iCZK8jp 16fSrccNtZIgkaQrGMxIgyfbr2qVJrY4/iWpZe+kkhjGyJ4g+GRuS49xn8PxrJiiW2eQx/LBIPkh I+RW68UXezOaoh1pNcvduXMRMxCHJCsgHU57moZ5bkXgjhha5AmMeNuY7hfTA5wenrSJULq5/9P+ KyK8uLJbW0jt2REu5LlGGI/L3beFxzwR3rsdOhCsJfJ3Sy5/ekgbc9q8qnucsY8p0UEl1ayww+SB bXb+XNe7DILQdQ20Vzmmw3ehC8W6Md0yTyv5xyYVLOSrDHBA468GumCtIaVlY3NIuI2iuc20cyXE L+ZNnlcjGQB6H+VeW+Io5rSOGCe0ae1mUyxzkbggU44Hvmuyl0Kt7jPMb6LbOuxSIxysP90elesf C0qniLSpkVN0Uw2rIBvTcQrbD24OT9K9rKZezzKjJ9JL80edjY8+Cqw8n+R//9T8ifg3cG+8P+Hi yxifToJLS2Zj5sM67nJ81vUbyPpg/X+sX/giZfXeneG4PDwihsDLJNfXaQHzHgdFbALZJwQYiBzw a/vjxSp+28J15Rj+CP5f8D5ey8UsTFPpP8ZH9Anxhggu/h1rEVykbrqGkTxSztz9mBibDAezAGv4 MP2lLQaT8WvHU/2pLWCfxPeNskUyWtyf3bvOMc4G/accV+WfRVk1nWMh/c/9uPS+lTBLA4Z9ed/k fO+pzabeXNv/AGam4ABTcwxFI5CejEH19fase2tWtLy+1TVwZZLm0FvbJGmFiZMFVOeo4ANf3hST 5rn8L1fgsGlwtd39zq9zG1rLM7yImAoBydrjBwAe3pVe40CWV5LieOKaPDPKzyFirEEAD8+3pXSl Z3MH8CP/1fy6g8IRXM9jbWd4+y8RVuXuXEFtbSqxJO4/wjg5P5V1+pTWemaXp9lMYp9StTunFpci d2KtwxOcEdcD2r/aOKZ/kLDYo6fPDf3U4mgiid8yx3csgRmGSdh5x79O9c9fQfbLgJGsqmO4WYNb MySZUnC7hzg9xTUZJhL4WaJvtaad7G5eS8S0hSRrK4XcsKr09+P0xVqy1KeX7XFL5ttBer9lnfJ3 RrlWyg7coD/wGtDNqyTI599vdyWkE/25LVBIsq/fKgZ3SD1wM1o2TtfEXj3LK+3a8CYMZC9OPegk /9b89rt7S+t4J4YYVSyR/Pd+C6jkjHfp+grmp7fS1ubf+zrubVtL2+bF9stxG9oxwfLQZPCkkA81 /tQf48y+JmxLqF5G0VxbBUjMK25dUEeVRQoBA46KOe+OtZ6Ql47uVfNnmkmJd5T8sYxjaorWD0sS TrcW2iNDHBF9lvrqJVntppfPjnkGdzKhGD1xjFV7qC3ttZtbK9stR86SFZb3CeU0O4naG3A44IOM dDVgS3trZxYXEyRngsvO7r90duPU1Bp9/eaeJJLOylY7xFl4fMKAkdyMehz7UAf/1/zpe9vQNslr HG0cgjeMqsbFmIwXfGSPY+lWtSu/t1vFaWunXNoLWPZes1wJrS7l/hZRgFcDPAyOetf7Y30sf47n Pxf6MfLRy7HB2A5VT/8AWrSv7f7VZT280ZMl9F5ciFeJNuCPp0/CqUrdCJ7EGiLF/ZNrI+jPpdzY TvZqk0+434AG1wMcAHcMjPUVrahY3Vp9nvtSs7aZo3Ajs7C5E7kp8x8w9uv6e1arVXOVv3rjYfFb 3S3Gq2gljvFm+zBZFeOa1AGTgNg4AwMis67ujNFPe3byT3l1IFjeUERtgAN8w6sBt496Byaa0P/Q /OPy7WOe3ZLb7TaxASqxHlTMWVTIrMOwIIxn34PNa9xYRm1+36cY4cja8Rmy4yPTrX+3B/jBJq7Z nRiNoZra6R5r6VkS0eJyRGc/Pn8Pyp8yQpFthgfyIkERaX77SfxNnHQmgwfLzaFKKG8ezuC00Fqj yAIjOGlUgg5C9cEcdK17fKWTvJHP5l0xBZ1wkqgjBBPfOf0oJm7aoo6hYvfQRWiJOkfmq4WJihZg eCSKhitb4661nd/aLSyjt0nkmjTzjckD7oY/LyR9RzW0VZGMpX2P/9H8+5LaW2toLnVLkPpr3XkR Juy0fdmwOcc1UfUINPm+xafb2l1b3gIeWeIvFCF74YcH0r/cA/xPNeDRpbc2K2heC8vV+1Wsxbyd yNgxyIe2TnB+lDG4muLT7Shubuzm2kq37yQnqSehPQ0EyfKtCrqVk9xqVwsdm7IbcmVVXC/cG4ke 2C1YemW8rn+z54Y22sHtZBGYyFDfdHbuOtBEXeSOt1S+trSNLF1it/NCjcUA84jgKDjr3yfSqkkP 2i2QvNKYLdfnaM/JgnHHvnAz70CktT//0vz01eWKZoG06+INkFaO2L7yp/vsM57DrXTWkkEkEnmR RtLND8ySKBuOOSK/3AP8S4yUVZnOR3kcEbfZIo3gWUqY2ywDdwec8entWiG1uyi0q4g08ma7uSES fhNqkfNgjBHIoIbu7l6aTU9Kv9Qtb+V3intFM8Uzl1yD5qsvOM8DH1rEF8J/3fkSTbEzG4IypJ6n PX/9VaQi09RFeQadZyyXunQ6jZXUoV3aW4EsZkwFZgAoIBx0yeKfJZ3dpBb3KIzSXCjazrw7Y/hH pzWhL5ftH//T/Pby5Y4JYg4L3J82SEEoHYcZx6gfzrQ0KPTbGeG6uoWeKNikrqoaRAc/dz0wevNf 7lRTbP8ADydrq+xn2ct/FdXDC5l/0qcu5biMru4G3oMD+ta93JJGfKaPP8TSZOenFbHNUtfQyry+ uwLeVLlrYQTKfOWMNKiqwJAz6jNdAdejl1C41CcNIbxAryPhZJsdD9ev51rFcuhg7aov+Hbprq8Z TCYcz+VEHP8ArBxhgfQ5x+FfUfwzBtfGXhzUYI02aYrReRyrSF5oHyD/ALOxjWGYrmyvERf8kvyY 8ifs+J8DJf8AP6n/AOlo/9T+x/8AYtvjN8M7EDBjaCMoemW2oWGPUZrjv+Cidgbz4E69FIu4XGTD hA5iZEbnB/vcj86/ZGvY+Lqb/wCf/wD7cfmXHq9r4TVl3w3/ALafxLzRXw1a9sPsklpNZXe2WN4x HgsochQONvPAHY0lzq0rSrGLWOApB9mkib5ySP4+vXv+Vf6/4V89Gm12X5H+GmJfLOae93+Y3yGM BuZMDbwu8Zz7Cs6ZIsCRRtfOdwHzV2JWPLn0OltdQiXSJ7UQvJc7w9u4x8h4Dbu5GAcD1Nc6880z JsRY2RcTEZO85PJyeOw49Kduhx1ep//V+craC7uWlAkjMUKecVB2scEA8fiKtWseVlhMZMjyB0f0 wCCOnvn8K/34P+bmXxMh8mWGRZJoJEjlBMTyIVSTHXGev4VJcICY3OdhO1eOCQOlBlNaGn9iY2+Y iJFI3SooJMY6ZP6VPdx2IhjjtfPlnVVUhkALHHOBk9+lVH4lYyKiSRxMxYKF2eW5kUMAD1wD0+o5 rNuntftdtIwuJNpMWyE7AqtjLN1HGK2A/9bxGaztUCy2skroY/mMwAI9RxVBYoQWCQhpP4WHHPvX /QAf815YwfMMfyBvRl4FZ9zPNb71CrI33Y+cge+KDKe5VQSpHE1xOrvIu6Qr8uw5Ixj8vzq0Ej+z SSu7SRK4DorbH+gP4GggZFNHJI0awttyDHzudRnv6/pWkLi2SCeZtyGGYQhWXBOQef5VpFNu8gP/ 1/DPtVo9k6+RcfaPMP7/AHgQqvHBXGc9eQax/Ja4ePyQpCOHbePlcZGce9f9BB/zTmrJB5jbIoJZ 5JDt2RLhyfYCs+RneR0LcKAoLfeGBjB+nSgAXKttDAAcZHIp8Zw7LsDox/eOvXH+TQAXEMyyKVw1 v6Z+cfh6e9T3EjlYxAzW6qhWQIcM5PQmgVklqf/Q8CSCcxRMsq3AYFjGpxMrKcYP1Az+NRNLjJkO zPJVjyvrmv8AoIP+aZNbIuyqxhjiEDeUBvnlTDKgyMc/Wse2vJYZnXcyqDgHoT24/Wgzk1cuyJGc NExJ6kMOhqNtzc7BIU5woywx60EDrCK5IkeSNwr/ADJ5qFGRePX/ADzTZrRpCq/Mh38EcZxQB//R +f7nzIiFDFPkCyehOatWdtHKoRXVdwJMjcKlf9BB/wAzsoq1yCyaWJmkPytFJ8nocHgj9K2EuppJ hKW2yA8sOGPrQYlRwY2kZBufOc9S1ZEss+64dkVfOfe4UYLEcDJoAsDcIUIw5K5IXr9PrxSKkjQq zt5e8/Kp4cfUdqAP/9LwcRyRur+SfujMn96nPlzsY7s8AZyfpX/Qgf8AMuItmYSyuuBJ0DDDD3q9 HYyQwbw8O1ycKg2suP73ufagChHCxDsxC7MsB0BqyyssC3RHyMxSPPRiOuPzFAELONnnlyjlgpB4 3/5xSs5J8oHgfMe6nrxQTL4Wf//T8MMbSAgZPcYHHFJBGApZvkfONuc8DvX/AEIH/MsmX3SU27GB BJsQlwzbTj2/Sssz7IgiMLjLYdQ3+rOeR+FBKl71hywZKu3CD/lmOiU9ok3ZDYCj7p+6e1BexGke 5yQu1cnG4YAx3/SlwIgWldeG45xQB//U8YSQqD5eCxXaoPb8KjgtIZEm+1qZXlUn7+EXHpX/AEIH /MrKXKQI0cObaGMbCuADzt6cZNQsZIUKbyNxLFjzj0AFBlfW5paQ5VhK8IuIIuZQ2Ru7cY/zmpBJ bSSmZITGvmHjqwAPT9KBCX1/+/8APsrdY0VdipJ++XOME4P5+xqmbspGSwO48hj2oA//1fGLQMcy jMmVwwNUltitzuVlSHPyxIuBkHmv+hA/5jy1cTBTHHKF2A7o2EahgeOCcZI46Gnk200ZZ5NsisFV Mdc5z9O350AWUtAY2ePkqM8HoP8AP86sRzy26gxpCXAwGkgSUL74IP50AYryurHyiHKt84xwPb+V SuwuFDbSrqMuvY+tAH//1vGQuArIAMDn1p0irOuCwYAE/KOfxr/oQP8AmPK8KhUEjK+ScAMcFR24 qxLGkCJJcx7/ADADGS+MDJFbQXugQy4KfJwF6ZHNHnII/KVAzH7xxyKoBzQFrYssDyOGA3IPlQep qmsZinS42BpI/uHsp459O1AH/9fxOUuybiuCTknpS26Rj947biRjp0r/AKGD/mPK8ls6TLKHGwnO 3HWraKrHaMgsM4xgUART2SEGORs7+cYyB3q0kI2rEsgCfxREdD60AEkSxrncF5AyegqG4KfKqh96 jDc8E/h+FAH/0PFIYXBEpk2oM5j/AM/SlykhduRk5BxgGv8AoYP+Y8pXIliXeI22Ftm4Hj3p8fmn ZGPmyMg9xQBYPnJaS23m4kMokV5BnC+g/CoLcqlykshyFUqFP3WbB25H1xQBcknjiOJivHzEDt9a jVknGciMqcp/dIoA/9HxsCKMP5iiSQAFHVht/GomnHmbFBzjI4IU1/0Ls/5jyaZCv3zlj1VTkfhT o5YjBLFFCzXEcXmDe+BweQD9PX3p2AbCBcJGyp5ckgHyHrmmm5i86WCW2eWWJDGrkfcPQD3xgce1 KWxEp20QJBOiqrAM0ihmIBGCe2Px/SoHVGZoEPzN03HvWUvi0Fzn/9LxGHeBsZVIThiBgGrCYU4U ADqRX/QtJ+7c/wCY1O8bjp7fz13QoFcL8wJ+96n/AOt7VRtbUWwUYYhDhVbkZ57GiPUmMr6MffWg kMcwUNJEeDj7n0/L9KnEv7s722MFwSeCRjpQru6uaFKVgFUoTtHU+tOIZxhRuU8E1m4u9kB//9Px JbNYmXAbDdVLZGfYdvpVlQsiuwwDH2GM1/0I8rP+Y8r/ACRRl2f+LG5u+TxTvL8wZZFIXkHHNFtL gVBEd4VBtTdzx0q+0YmO3J3Kv0U/5xTv7tjGTuyO1MZdi5J8o+WykkEHg/4VeWdUbPlGSNT8yg7e Kkk//9Tx4mBCW8tnLngIOhz3p5SSZh5aliOy8n1ziv8AoQP+YcY0EjE4w5AyOOmKgs0Web7NeTtB C8nzSKu7y/TimtwJMWumyeSt1LNI6tGJXjHGQQM4PcfSpYGMNtl5EkO7aTjDHPtW/kAyJo92QSWb nFMkeRSflwpPU1KST0A//9XxeJJGkDtkZ49se1aPyRo7Bl3gbVU9GPpX/Qwf8w4kfzyYX5Mjn61B P5cUuJTgk8k9D2GaxkrSYFsSBomUL8gGDKBzGOmcVDLcxOApO6NBsXZwD/nNSBUGBncO/Bx1pbdP MuEjlZoI5MkPjdgDPT8qAP/W8el+128RZX4jkCB5VB39T0/A1KAsoVpM4PLEDn8q/wChA/5hxpjj XJT5c/dzVd0L/uSXAfpKq5Ax2oAmjiSJgkwCCNcIduC3Pf8AxpZURlkkt2CuHAVWGcjnOfy/WsW5 LcBfIneVHtYC5IzIqE/KAOW9alggn+0bzdxQkEh45VIZex5/xqQP/9fyzBiWQTOvlF/3bYJCjA/r /SsqR0Z9seWCnoO1f9BB/wAw5O42hGfcC65VWGKIrhomCGMrv6OOBxmgCa9EksKNsDBZFXHTOTwf wxmo185pSk75EfyKSc4A6AUGkF1LxigxdtJNDG1tGFjXaW8/LBOCBxye/XiqUyOkiq6NwBlccEkZ 4/Ag/jQaH//Q8XUvb3ZmG4oVAETrwp9amkk2yCQLhyMHA5r/AKC4ytoz/mPK0sXIuJFUxg8nP7xc +lLJOEaOaGIMI/lRHQYYepFEpX0QCxtG7KSAkgOT2qUwJI53cNjj0NQA3ZcRFB5RXcu4Bv4gM8j8 jQ7IytllU4zk+3agD//R8MiRl+8fkcbk/unPINWERjguc4PIz0r/AKCD/mPGECV3VyzEdGPekWLa 42rnBwc/SgCyyRiTEiq2B91+g/Wqkio2FIIBPy4HBx/+qs5R3YGlBIgh2Fd2wYwOxqvDdLp8q3ML BLzlY1dQ8RyMYIPX6EVmB//S8Ukur25kEl4se8pt2wwiJeM9gKoxh1uSACAeNvXcK/6AD/mPNnyb VoZPOZ0ckGMqAV75B+vH5VVRoY48+bwSVChSc496DaKsh0/2SQWawq4Ywt9rZlwu7e2MH/dK/kae ti1taS3MW37PCwMyqQGTccAkfXjNBRWivUZMvvjYv+6JAIcDvVt7tZo+ItjKcFum+gD/0/Fo0V3H IUZG44zir0rW5gdCWV+hY9GH0r/oAP8AmXOeW4RH2biyg4B7YqcqZtxIyFGQcUAVJpFW2ESxrGd3 Jxgn2qa3hUeT5bDd6MeAfxpNXAuXBdm3vgyqeFQcHH6VEb6+jHlRrGVuCBcFhltoOcA9azcHcD// 1PDZfIlYROGt1U4kYHJHPJ+n+c1e8qCEbFdDCFwrgYBHrX+/B/zKTWhUlk2oht23KTkEdKhlmkKb lXDfx8cUEQ+JC2hMkJjZSGHAz2qHbJCSGLKmTknPJOc1UY3RsPbyZAu0EsvU9c01WkbdGCfcjtiq jBPcD//V8JhT7Oh2s0395mHNRxXccxlikjMZibBL8Zr/AH/sj/mYSu7EUphx/o5AkU7gxXcrEevr Sidrjc042sTliqhR+AHFTyI3tbQozyyyERLGvko4KnaMnnJz3/8A1Vti5h8vCrIJMcrnIH0qXB9A MhZjPMwIxn5cjjbitAxp5I3uwZf4gdu6oA//1vA7J0SWWUiTcBtjz9361VvpN+TGpRSxVtvyg1/v wf8AM+EyWshtoLaSV2Fus02/ohU8j6cD9amDySuXCAqvLSbB5bH0x0oAWGeOG4uJrdVgMoLNHGNq biNpIFVLSAwgqXENrLLvaML95z6/nWijeID5EcTKse0RoMLtXGeetF5cG3kiSV1EzKHC7gSQenFR b3bgf//X8JSSKXYXKxOY8kj+IgfzNZ93A8YllYYhlj2uw6SKDnB/EdK/34P+Z8FW2+zArCpYAGIk bdmPSnE7oU3x+ayMWRscqCPuj8qAWgLNeBBCojFu2WdGiUy5I/vYz26VXuQG8hWzhXznpt9azmjd STJp9PYKskZLIy7ljIBwM9f8+lRkeQ8cckRXKbk3DGP/ANdZjP/Q+ZJUnluWWKJ55tmVjhXc44PJ FW4rG7t7eO6uImMUh2lhzgjqK/3xaa0P+ackkRV3tHhUJ/dbuC31FQ3NvMJBPIAhZzJgDG/OMk+3 1460jaLuhkbxidAQSpPUHC59K1nS1eBln28nAyMjFBRVk/s6JFISbz5coEVgIRgfKRxkY5z61UEM b/PON5A28nDEcUAf/9H5x+x2oiYwOQHBXDNvkUepP4mqE6pDCixOWJB3k9RX++B/zYK19RLFlDFm KkBCEVztDN0/z9Kv3EjpLHHHGgV0LOxbBHTAH5mg0cU9hssRljyshjYLjJGcdqqrvjVTCq3Umdqx HgMc4xigsljaSaNoWYxSLnKg/Kp+lUZYbiKF4Jo8CRlkaYcMwHK8+nFA47o//9L5gt4F3bUUb8c7 iF47/jV1r+GG/t7bIeaa3MbYUPJAqgKrY6jsMjniv98D/m/M+4i5Miy7gGx9K1YLVruMQWxIIAZ5 DxsHclugHvQbQatYzI7ZBNPEzmRmf93JyMAccVfRtIiMkt7bX1yPJ2RpbXCwNuHruRv6fWsprU1g 0tGY8FxIfKjlRniJEYgU8gE8c+ozXVxJFHZiymhZLsMZlLZDeXgcEY/H8ayktDojJRVmf//T+aLW y3amPsqGRtpMbPKYkQjknv0wfy/Cv6FP+CO39oTC71aWJTb3t19rRo3M0kUZSGLEh9QxbA9CK/1q +kTJQ8NsXf8Arc/yH+iCpT8UqPL/ACO/pp+p/Q98S2W28E6pcytmOGxdpger5U4/l0r+If8AbB1o X3x68TDc8WEhUIHxJbgBpcsvXDCZcf7pr+WPoj0facQ4qp/LF/qv1P6n+mRilQyTCUv5pW+6z/Q/ L79q+eS78OWq2qG5WKeVIp7ZvLLec8IYlThsBUlBBB61+FmqW0dnfanEliLeS0vJUQK2d43HBz3z mvtvpdVf9hwVL+9+jOb6JKvk+Iq+ZjNI7J5Sqy87y3Y5rBkuJYnMsUgEIYxuhTlj6g1/Ak46H9oO aP/U/jVDneJ3PmIGxzxitGO4t3WZDtjU4O48MvXpXPKLtY5OdHf32m+GBosF7o2uw6q8gCTRiLyb m1lC5ZSM/dB4zXldyX8/EaASk/M7HhRWDsti7okje5j24XhmweOWrdg/sNZbdLy5a0umLSFWwYpA MYA9/pWc1dAQ3ciebK6KpG3asijtWFaStLcS/KoaNvlYccjtWRpBu9mf/9X+Nq4klSQzrGpZiN4Y 4AHfH60SyC4VpArMgG0xdga8B7sDPd44oysYEcYOSoGDmoJZFlRGjZww52Dv6VUl7qY4uzuWbMJI rNKxL9CvZauTIY0eWHL4jwqnBfnjAqDZNPYyAUKG1niDxSn5mYZQfX2p81orW6i1ZEcPjbH910xg jNAz/9b+MCC1FnAxMmxN3VpM4J9ya0bOzgkvEu5o42kiQqkjjOcjofb/AAr586Cu6xxM6IQZo2JL k/MQT27YqnLd+WpMgJwcgDnJqJQu7o3i7ooSahNcttG8eX/GV29K2dKkW6yUjBm3YPy5zgdasxe4 y5spCzLsVd7ZLYywHP3fSmrYyRW5844BbCocByo70C8j/9f+K+aRrWcQ2iS7JRv8pufxz3qS1ulu LjyikiTL8y4B2rjjg18+dBoWt/MdRmiklmHlKGYbP3bnnByevfp61cu5luZpLxw0s+wLIcZZwBgZ oKh8RUktIo4zMqfeXco96gaS7YJcogMsCBfJVsIFGAfzoNiCS7lubhFto5G3NygHAI6irAu1leJT mR3YqGXkqRn5T+WKAP/Q/jJ82JYxu3FuQyEYIPtWe+uWqQGBYJTNcS/Zk82NkCN35/Pmvnz0Urpi eXb/AGhoCFmeMYLRuHUZ9COKguQG2weUVZWwO+78KpSa0ELFBPMSsVs4Aby94BC59M9KZ5dwbtC6 uDDhBCxIQH1/GqlJ3sFle5Z1PULjfbWySiJ4JOUUDaT6Zq1bm98mR1kaKSIebuCZ8wdCASPr+VXf S7FZJ3P/0f4sX8wESSo22YiOFccufauhKSG32SMQwwQCflPsa8Nzdz0DONzPayt58zMkwA+zrjai jp9exrRt5ooWdxL80rZ2kfc9sVUb3dzW6UUMmaVxsadtol85Sec/7P09qz7iNH2ySBoyGyrKMYPr xTV7aji7o1Y7eVIEdHU4OcjndUAdku2MrxhCoChBk575/SmU2luf/9L+N9GE8bYyiRtjGMVY05p7 i+S2EayQBCWRuC3HrXkWb0Pbg1Zs+8v2bNJurjVby4S+tUNrFDb6ZaIDNNJKItxCrwcgnnBz8gHe v3t/YWdda+NPhkra/Ymk3/bLCSAokio6YSKQ8nBwfyr+5fDeLpeDeJq/3Kn6n8oZy4y8aqMenND8 kf25eCYhpvgaztJZWxb2LLPLCACzbdq8+4Ffykf8Fg9Sk1HxzoWjedbpJZvNJeyzSYuUW3bzF57E 4I+mK/F/o9xVXxA9p195/wBfefsP0gajo8EVY3/lX4/8A/nF/abE9j4Q/tiK6Ecot3gm0yG5Ed8k YjJV1UHIEvzjPr9RX4beI9ZN/LctMjy+ZcMYS6GN0XJwDX7H9Jmry4bCU13Z+N/R/jz0a7P/0/4T bWQiRst87cfTrXTWZDlAJMSRDKs/GCPSspPVouCTep2unm3JiuniEkinBV8iPIGMgg5rYKLdRPLO GMKcrtGcn0rhqbFxSWqIYjFNZTwwKzTW8gkMozhR/dI/Ktu3e6ktY47O1F0X+9kHfF/k1w1NmaJX TO3SCRLNYY4XklRAxUPtAPcE/WjRrZlu5UuPLgQo00cj8spVS2wH3xge9cc1qapWVj//1P5HJrQa jML1dPghmEYBUMc/KANx9ScVbsrcv9oAmWK6ETGMOdqMwB+X/CvjJto9Abp2mXc6SF7xopZHwrgD 5MdSa0rK+1W3nvbNbax8uKFrWae6Kl7xWxkp7jsR6VkbpJbE9xc6Zb2ItLGN4pEj5tY4Qig99uPf 2rCtZjHqEsDtcqbm0jFtGsYaMvv5zxkccflUSk07IbdtzoZXSOBBKFWSOUHaGzvPZa3TLpf9n3Ky rJazXaLFdRrmSOQDkEHPBzV3cmhS0pSP/9X+NTW3nmaF7FGjkdgJLRUzahQAM7uTkn1qq1lcJdo9 xHHJmEF0m/5ZHGAVPWvGi7o3bvp1Fj0nyrwzDTbe5kWEy5nJMM6kZCkggkd8DvVjTEv/ABFqbnUI dL0iN7E+SsLMEBhG3aARxuCj3yaZzQ3aMmS1a2muYYiZhGN25eQBkjmqqTFpNrrmNTsIPHPtQZSW rJJhY2Umm6k1rPcy2NyzyQJEZVnRgByBk569qswTfbL6c21sYRaATMRL80G/hQQO/PfpQI//1v4z /sscRjaVA2eUdzwxp8Es1tdPCzKAi7pIdwbZ3yK8qnuYK1nc7C3u7gwNaQXCrBeQgSb+GIyCMfSs q4jvooria9Wzk02OLbujmDSjB2nenX6V1xXURBoA1KxvLg6Ylg+nahm1lWWPM7IQPmAI4PAweKg8 VSgxxQzwOkVhJl2gjzdMpOCAvfGTgV1UlaxV7QZ4VrmyO/lMEc32UY2SyKA2M8ZAPB6Vd8OyyW+v 6Tc226S5jvIREnmbUQNIoY4+n8q9bCS5MbTku6/M4a6ToTT7H//X/GP4B39hpvgO4H2yW9v7a8hu JfNUwIA8JBYDG35ig6DjHTFf07f8EVvEX2LXL2wkaSKbWL1Z3uQTNZmGSCPLQ+26I49sfh/oPxul W8Iaj/6dI/lLwmk6Xi5VVurP6kPiNClx4D1iRVcNJpL2yRsgZtxTrt/D9a/g5/bdXUIPj/qWlaRp gi+z2jJcRyQnbIR5XnNjHHzKcnrX4f8ARfqpcUV6bf2X+v8AmfVfSppP+ycPUt9s+U2vL6HVYrKG 2QRXMCzSrCgSC3ZMgbuxz6/Wl1ex1LUb1rdtIltX+x/bob62kzFNsJ3DGTu4BPHp+Ff39RkfwXVd 1oc1LYazqqBNEkMd00ixzXcqeYltGrAzMykdCq4/L610msm7t9GsbeFYpI4iVuruNiskxO0ZP05x jHWurmV+XqY/ZP/Q/NzTFW5dNPjuo9Pjlgcm+vHLQWzhS247VJ5xjGDz1I61jzpZWM1tflv7RWQ7 byQhUwij1HrjsOM+1f7SxkrWP8g1GSTKyxwRTGS1W4eGRzOJJHLbA2MJjuPetFNR1S1eSzNjAAJ4 p0kYGN2XIPORnOCfY5q99hz+E3rm0v7ub+1LHVBa3bOVkLQrJNIrg7414+7268bqpXMVvBbvFIBH NBgvlt0kpPfH+HSgUvgQkLSfZrlbaK3luruAwGacZ8lX4LfUDOKoWcMGnRWFtE8onNx9llVULxqh Gd7HOccH9KDPbc//0fziimj82dNyNFCGh2g/I7ZA6e2KzVnQXk0NssQaKPzghIUPjrtr/ag/x3L3 2trixkF+WhhkR0gt7Z0Mm4cqWPUfNgcHp+iRGeOwisrSN7UiSK6vprq4W7MobB2oABtBU+/WtoJW 0A6eaaytYLNbLTY9Sv5X2ie9XK2SlQCY2B4bOME9h9aW4hN+JtVa5V7qGZY7jzZd8pwvAGeSAAPX HFUBzN9qxuEaIQJA+8srYyqnnBx/StwXgi06CJ3juriSIO0kYIOccgg/54oA/9L865XsYEh82GS+ u551zbRoRAqg8u7deOo/nSTNqMsV4um3cM0duTv/AHbYdQcBgO34+tf7a8isf47kemWNhJp9zfya iqXUR/eQSfIiYPJ9uOea0baWC9tpTNeIrIN1vJE3mCTBAwMU1FIxnJ6lye8tLy2t91xJPcaQwkgj kQi3ZSSSuPXJJNNgvLiG3bUPsscv2h2TBl+SPGAc59sD8aq1tEczbbuzM8QyW17dJc2FlZW8UpQ3 Cwp5e9woBYg9+O3YfjUdtBa3LrDcm5itIQZCkbDlsYzgjAJIH4UEyulof//T/PbSYpZreSOW5dYs ku8CjLR5yEz74xVNFa2uLi6kmR7SNS9pp8SlpZjnABPQY5PNf7cH+Lc77GvLZoskWrNbta+bCH+y rzGSVwSM9O/HSq12pkktY3ZoYLjapZV3rGxPXj0oMzOubVdPuooI7lr8iQq7uoVGAP3hjjn0ra1G e+n0+Jo/OnW2lRlhjAcgA4IA+melNK5MldWLUmoG6lhks7Frezt4445pDneXxyzZ4GTnH0rSubqa WCONXheUZePzsLkKDlR+H860SaiY2tof/9T8999xIJTNbwvaowcANuLMSd3Hbt+dVrK1hdrjzNi2 82WLM2Cg5wF9K/2/1P8AE8vwWNjaTaW84vLq5U/8S+ad2+zlBkFAvTgZ59q3NRZ7Zoo7eyS3gmLS boXLlJCc7mY8857elMia0uctLql/Gkdnc6q1pbxTsZpoohJcFX4IZvvEYHTNSQy2km2KzmuN5Vwb u44RxuyhRf4e+eT1oJjp9xq6pDcy6JbiaKGUQSt5Es52+bkg5VsHlT0FM06xiutOu2k1WIMYvsyW 7SEmFgDyFHTGR+VBNz//1fgS0SJZrfSYI4VuXOZ7t0VWm2/3mPHPpx2q/qc9nCVAUz3NqygQxAbZ BjqefWv9wD/EcxpbmKaGSF4FtizbmeJCZWLHjPpj2FOlS4uIkxdXbrbR7LaMuWRDxnj2xTSbJckt CW9i1q4s3vFjVkg2xStLKELA8dOprPFpdSlfscSvIGDugfYMAjP/AOqtzJ1LbsuzXh1q8mVUjTEm WijOfLrStZobSGcYnN9AyrbCV8xqO+FPTtjHvTSu7Gbmrn//1vhWG5is7N5dREKzXspSOWaHe0QI 4K8Ejvz9Kdp8ttE13bXU0f2a8iMUDhPMjVlIY7jjjJxjHSv9z0rKx/hxKSvqYt3qNu+PsqSIIf3E gMZBDA4J981txX+kzabtnknfUGlWCNJIiGCqp5B6Y6VcVuctWfYyYtRiWe6tZEQQQRiXzpUBTPII I/AdasxwJebZSFmjCEqoi8lEHO3jv61sY3Zu6XDN9qtmcSqDGTbsgzwDwF9Of617/wCDr5Y7mwuI pJ5ZmuYook3m3w4cLs/4Fnbn/arLEx58JVh3i1+DMMHVVHOcNVva1SL+6SZ//9f+vr9gi7e9+EOl POrC5+WWQEgvETGhYN9en4Vtft7WzXPwR1qKMt9odWS3ABK4KOHJwPRhX7NmUVS8XHroq6/9KPzL ipyreEU521eF/HlP4fbi31O51nxFMbsyNJ4guGkUOcwmNtirk+iqBisu6s2l1Db5r+akYZ1OASR1 Pr+df6/4CEfqtLl25V+R/hXjZtVqnNvd/mTzBv3cEkwyBxGTgD8Kr3sFvbW8Ja4Q3Pm7WiDBuD93 /PvXY1Y86U2Qo5gBDNs3jgdKuJp11/r4lLjyfOZV7qfX8+laQStc5qj6H//Q+fTo9/D5RjkWFnAm AJB3IeSpHYkAjHbNWyUETPb71O/5lYfdPcKe461/vwf83Et2R3DztEjXtyRDCoRElYkx7uQAD61W kiuFgi2N+73lhu5AzjJA/AflQZz2NK3nt4FW5YXN25Cxpa2ziPziTjkkHgVHbPcwuZRERcBjsQfM U9KcXZ6mRWaw1KNkF4qu8imYhCGO3J6gdDVqGSwF0XnhmZI1VSkOIgegPJBHTP8AjW5hdo//0fny 6nYfIhZUY/Ii8Kg+lQ7nEZXLea/CsvBFf9AB/wA1Lm2Pt9TmlkZJEUrb/uVwmJGZfvZP+frVjeGl +1GMYHBiPK/5/wAauFr6klKW2triZZpFK7PugNtUfhVlLW0kikJlcSq+IoyNsZUjknnrVPlW4CWU DwyednBUEHPXHtT5JYpEZ7uCREdlIaRcHduGCR9asD//0vASrW9zJGvmyQsqth8HGVGeR75qO3eO C5eONZIPLHmKj5CkEdvrX/QQf800nYsi7mkLpEpUnjIGD36VG9pJJG7qwyi/Nz8zewoJ50N+ytFG u+NlcnPJ6imyCOHyYgQkk8mzFA+ZFxIpYZnWSaOWJRhAgyfqTn9KtyQWjlGbmRQQEU4aQ+w6elBl zPY//9PwEqFkT7MkqB2PnRyD5kbkcYpt2I/NVAG3xriRmGNxr/oIP+Z8ZPZyqsV0XlMKjYyqSI8n oCOn51NHJb3Qjt44gJEO4uVwT+NABDPArkEZIbaf8/lVcwqsiyC5YMshcrGdsbjnAP50Aasssrxw lp1AxwM/Ngdvaq7XBwkmDsB53fKfrg0EOaP/1PBJ5PMJD/Lvwwl4PAOSPxqeISW8TMUwJVGwYzxn qPrX/QQf8zTm9h0EakbnJGG3Lk8CnSXCRsTs3kN0B25zQQRpeEPIklqOY8pMXwVOQen0FE6xyxEs rtj5V8s7djZ79ffigBtpm2ZElAzuyMjgemRT76NJyZEPlv5nmNtAC/hTYH//1fFobuJIWtWj3MxD B9uTxkYB7f8A1hWaYTvJUl3ZuB3UV/0HRlfQ/wCZaLuiXEgBSTIMY2oSckU4XMkcLcglflCscBqo SadyKAzyMVfChuw5WmSfa4pPJkVZYkOYHHOM9RjtQUWTEZos4yRztqraR3DvLJIGQR/LsbBz9KBN XVj/1vGAQ8OyErG69c9T61AELoQyjKnAb3r/AKED/mWsloSW8FwjfvjlRxgH5Tz/AJ/OqN5aBJLY W220jikaW7WNBm5J+7k9sd/WgiVlJMSSWV5VhTCxsMyOwJ3en9aumGHygAW3KcBz0NBMpXGPKAuG XG3gHGN3Sm7Irh1227MSBtRjuG4Dk/nn6UApWTR//9fwy0tla6m+1rcoYBtVFk2I3HBxznH0q3cO hQKhI2DGe5r/AKED/mPK0QjELyFXV/MwrHgHHX+Yq55EUkAmZtxU7dgHPPegBsF19ljlthEwEkof zS+VI5yoX64P4VVuJmR90QO0/eJFAD4LqMqrTRb0V8EA4Lc/pSymC4DBVIXOUQ8kDtQB/9DwgW5a QP5km1RhlVyAfw6Z96giup4LuSOGKVowpj3zRfKMjBwT357V/wBCB/zHmsREsEPmSea2GLIqfMrc 7cn06VXbzJodkcexsZYhcscdx+FAGjbTmNGBGU2bBubDZx1piTqke4ltzZ+QjDD/AD/SgCqHtrdZ ZHRlVvmIwTkmrITylDgoyTDK45Kj3oA//9HxeQgkJHk45OKSETBJNigMvLKcdMiv+hA/5jyx0TLc 5HQHkVUmtI4nEizPMsu1yjAhYyO3NbQ+FAOd45Hm+dVMSbypxGv4D19hRbtbIvnDLvIuDzgDg4I/ OqAbNJLFFzIVgZ857A8d/wAvypYxJwyzDbHIHTEYZW9c5HPQDp3oA//S8Yud7OpLBhIxLkDaOfYd PpUgKRx7MLySd3Td/nFf9DB/zHjYZ3lEo8pFEOFQuqsrZz26H8aY7eURlgXPOVXAFApOyJfMDqGf 7wNRSNtcSLyFH7wnjHrQZqb6kUq/aGVDcTxw7xIqRkAEjsfapSvlhskEHjHeguMlI//T8R8x1Tae FJ9O3amKSARn5e3GK/6GD/mPEkmEzrbbwD/tdB2zUJt5w5jRyjY+WRD/ACoAsJG0bBZPnZTgk85p spt5HZVZcqeQhzsOOhoAm+wJNHlm+cdSxHOKUafJFGAQQr8pnoQPSk3ZBtuf/9TxIRPDlj0Jx9Ks jghSFI9a/wChJybP+YznXQmDx4O8DK8LmoI4DNMwJ8sEE5JxxSu7WIlK49YRCz7H4A+8e1behR6F HfQXeqm8vLGEeZdwWzrb3EpA5UMQeD0zjv0ok242RJueJ28Fm4tpvCX26CxuLQPLZXjmee0ny28F z1UjGPTmvPrizVW3xZBzuOeOp5rOn7RQSq/EJXtqf//V8VQH+LjA4x0JoiOJGXgsTwMYxX/QmpWV mf8AMOTs0/msqggIOSO/0qEEtcRmecwxbgjSSAlVAP8AWri9wJJJreG6bMjvbCTG9E3EgHAO2o7g RXuBgqEbKHG1mHPJqrWLjKxBPHEhWPLFSAPu9D6VYjjEQXBCBD0PU0ra3Lb926P/1vHZZbe5il8m QM0B3TKDhogOpPpULXaNAJLeIOjoqqEOM4xlvx5/Ov8AoXaR/wAxy2JFjeW2dZNqR7shwo3j8fzq VikUOd/G3hj1ft/n6VldcthvQjjTERkYDZnLN2WrEVskioyyH96dkO3+JuMD8cj86k5wlt0ikKSf LIp2SdiD05qB5cF4I0ZtoyWCnBHrmgD/1/II3iRQin94xyd3T8KgW42STkNgsQkcifKE7Yx7mv8A oQP+YcuQLKgzKeCcBj0NVJJ0Fw8TQAFW+SbO4Pn0x/nigB4TzZPLWBpmkYKFRN0jHsAPekuYIxgQ MypsGQ/XOBn9c4p3d7gFqBGGyMlerEcU7zkkLxvkLnI46VanrqB//9DyBI2EgK7myMAYyMUCDLOQ Sqx8lGOep5Nf9C3NE/5hJO2iH+RIXQQSLtJBYtxtB6j/AD6U+7tQLhodwlAbaJezY7is5O7FGfck cx26GE8qepHH+f8A61QxpbSJ+7Geykdqk0IFMZkeA5Zo13exHPQ/hTf38s8pliZYVQJalWIEQJLc Zzxkn8+tAH//0fJh5wAjuyjlRgMh+U+h/Ko5WEK5XnP6V/0IH/MOMDI8eZTgjkgDFTMENsio58of OuDx9aAM52aYYJKleOepq3aQzyQy7c71jJLlMrx3Pp1H51nJxYE1vPc24jlibZLsKtt+7yMHj86j Qt9pSO4G1ZjmWcjJHPYd+v6VD30A/9LyUS+VHcRTRybAQsAwCpHduvFVwqiJZY/ulsNX/QQf8w5P uN1/rTuOAq+oAAH9KoSwOJCGmJSNiofpj/OaANMsyxfZpHHykSKOPwOfpVGQb5wz/K0akKwPynPX j8O9BtBe6Ry2YkYO+djrtJzgip45FjHRmx8m9+pxxQUf/9Pxom4kkXG0xI25/l+Yj61aupkdV2xp HuzsHUgD1r/oIP8AmPKAnLKAfm5wRzU7SpDGfMCgAZzjAWgCW2ijnhMiKX3YZnC8ovH5VWkt2jOD JnJwtADJXDj/AFu6WD92T/EgPJH0NNMSgBycgdQO9AH/1PHEsRdL8twkCBxhed6gHPTHT/GmPCBI UO5Qp2s4P3h7Gv8AoIP+Y8fF5MSCLa+YwEDkdQOOveqk7yxXUSwyK0TRlpMLkg5GB+HP6UAACOxT zDvJ4Pr1/wA/hVuTZHGq/K0gXt2qZfCwK4lfZsiVcs+XIHzccdf89KsskUflynazxncAwyM/SsQP /9Xx1pmfLhVPHQDA/D0qW3QMJZPNhhuY4t0CShj5pyAQCAcHGeTX/QAf8x5HLbpGoZmODz8zZANU 8gsocDy05XbjHpk0G0XdF5DHtLAg5GVA/i+hpBYxyiS/UOhYJDJbO+8NtBBYAe/PPr1oKLNjod/q t7BYWEcMmW2xgyrEBxngnH5Vo+JPD9zoNvYIUaV57iVJnOFRVQIMqRw2CW6e1K6T5R8rcXLoj//W 8UWGZFd8BGYZUN0K+o/z2qWEfLJNcMvlJwd2OB0r/oAP+ZcoywozkxrlRyCBjj1NXvsztAot1aSR EMsyqM7FHegChLBDceXKyOrRtja33Gx3IzVa8y0iFFCqJBlY/lAAPJoA18RvNI1jITFysRf/AFmO etZ9uoUM0xYYYgB+p5NTJ2A//9fxNIY2BZguWIBPUEe/4UX0VvOfKh8yJAoVgpwrY649OnSv9+D/ AJlZfCyzd6elrZWskdyjPIFk8uPnYAQSrgjrjI49etVpZUdUYBdzDaAowDigxWmwiN5DRhxtEh6h f8+lUL+5llheCHcqC4Cq0i43cgEj8CaDaMrk9tYtAVCAbWPmTHOSMjqf0q1Huie4EJXEmV8zbzt7 itaexR//0PB4ZmhLxcupfLA85602dIGYkcF/vcYya/3/AG0tz/mXK0kawKQDkLyGA60lqrzRvJ23 Y9qlzRvF3ReWCPGGYb8YBHY+lSqlv5b5fa6ttyBmolK70HsQzwRhWktR86plwf4j6iqtv5sn7q4+ XnIHQ4qQP//R8ButkLLFEr4bo5w2Pakt7W2MM6TyyuzEtjcAFyOMV/vwf8z5X+zqqqqMW2Db5nc/ 5xU8ayQKwPKt8vTI54oAqSaZeDe6vEIzgxlWzKM+q0iTSYNqys8sS/NJjAb8Pz/OndrYCx5hkA2R 4aNcyMOcc4z+oFNliTf5j7ZGZRlsZK+3Sl5Af//S+dXV2w6rx0A9Khczz/uZWJjY/MvTdX+/B/zP k1xKsK7HURKnyDHAz0xUUU80SFVJEbtgjGeaAt0Lkm+Mhpcr8gbjqQQCP0qvJGbkAg7FA49WzSkt LG0Y8o0RzK/2NpfJMcbRpK25vLypxgA+uP8ACqsy3KeQbi5FzKq7C4+XIXgcfhUxitSj/9P5rgu9 1zF5kWYEBVnRvLkHocjrjr+FPjKxrOA5aCM7AzPlueQcE59fyr/fix/zTkMsckkcbQP5kX8R/unt z+FRpJJJ+5O44+Ukjg/jXOAkVrK10MkpFGpJ3DIc9sf571pXUDhI2JI3cAfTH+NBur2RHEshkQw2 z3c6KRDBGpck4+9j1HX04qnOpkcKB8zL8zLwFz2oGf/U+Y1jVWyszLLEpAIJA/L8Klt7SOOD7Re3 G7zSzQxRgSMoBxh+eM4/zxX++B/zXm5La6TqNtB5KmC5CiOZFj2wSAADcAOdx6nPXJpJoLILNaBA 0lm2JbgyNvTb264wTig2he2pgGZnniSLBVjhh149asyRsnKqRs5XaOTigooPL5kTSvuguiwEYPRu T196S2gvp3RmD/MfKXdyjk4xx60Djuj/1flwRvHIQZlyWwvOSfpWhDLFaStMtraS388YhFxJCHmU f7J/L16Cv98D/m/K7xwopjlIjZMyNHyd5B6DHrRBqCyrAIXlh+zSh3gdCqsMn5WHcGgd2tg1C8Mh 85QI7nYsaGJNkcaqMcLSeVM9uLlWykIBkLYy3bp9azqdDSnsZss5keJYd0ZDbyy9Mjv7VZN3fSTi f7VIZlTyhIDhgANuPy4rJq5vF+6z/9b5vhaOB7ZXkARiqyyyEIeTg89B1r+k3/gjn4fuLPR7x3jW W0N5cWyNA4KxRrJtiyRwf9TnI9a/1e+ktVVLw7rx7u34H+SP0Mabq+JnOvswv+J+5fxqEtr8OfEF yjRiG202XeZXABPlNt69cdfwr+G79oiSB/jv49uL5IjqM18ts0fmDzVSOGMK2zsMBRn1U1/On0P4 J5tjZf3f1R/Qn016jjluAX98/Lf9rjX9Mi0jUHhmktE0UFLdLcDdqb4BcO/8KqcgEZzn0r8Xddkk e6lmwE85BKE3mSXcTz15Net9Lqo1UwNHpr+h7n0SaS/1WrVvP/MwYWuLaQJMpIfn5uoB9P8ACo7q 3F48SL8kMLl5WUDPOOn5V/DEviZ/Xx//1/46pYokMVvChkiZsbwvAwDy35Vn6hFHZLFsyS5bHVge 5qJ7HnmWrpc/LFvjUNvmMJMZBPU5H0re3WxhDGGRzGwBwNzfX/PpXG1Z2DyK7pK0ZmtUby45NgEm A7H0ArHu7aTVGt2uBGDYSFoXKbZAc5K569aVuh0LyL9tLI6uGygB2/P0fFa8Bt7loopI47cAgB1G 0ue5z61g1bRl09z/0P49dW0W5WzjnstsybvLfe2wqfWsOO2e3URSkmeRcnYc7f8AOK8VxTArXFs4 2gPHtQ7pQ5wyrUcfluS1uAExiSY9R24FVboA3yI0SOSCRmAPzswwX9SRUVxdSROrNuSLOAV/iFZ8 hcJW0ZA8iuJB5hMcnOwdRxUcUUphBjcoi8MV52gdsVSgral88T//0f4uZww2xhBcIcZLngfUVcUO DEqbyHxuC8qvtXj26G3PEludPlPzIAGPLc4zWO9tMszxsGcryODtHpWDVnYpPsXltmMYa5AQsNgG eWoSFrVopIWliAbDbDjcO4PtSAstd3H2m3eNcwlytwXBKooB5Hv0qxHNHezMxJDHKxqxwgFAH//S /jJ+zpbyhBlpQu1Gc7tmewzVLZLZCWUKXlZ+RGBkA8Z+lfPnQS3Oy0QTTPC8s8YMflPkNkZ2/Ud6 dYyW4mLyXMtv5qBUTGY5CT91j2oA0o9Nur25FqzSxqEMsAhG43BAOAB35z+R+lZl5p+r6befZ9Ts ri2SRBNbvNA8IkGOhyO/5UG6d0MtDFOzRtGkEpkO0IcAD1os4rkXywpY7oQ7Ktwv945xx6mgZ//T /jGubeXy2LBkkEu0FRnaMnk1FvihiKXWx/NBigEg+UOc4I9+P0r589Az5bHyBBKgw2zMgjbgH0rU gZHhileMGdGJjJXJyOMj9aAMtZ9cjuHP2yd7EH5LHd/o6nuwHvWtHHeXGxmh4JALoPuA+tay3REp W0I302GyuQZhv2nzFyMjn3q1PdGW0xalThihTOCuMVZKm+p//9T+LzzszQtJGYwuBn7wUgcn8eTT 1nuruJh5gWOGUgKOC/bP5V49j0Lq1xQIWkuHDMwjTCKwy+fwp01nOLV722jR5imyMPJsAPXO32+n egV0lcfZwzR2zJcObhpEBZyOUb/Z6U1YHmmHmO+IlKiEjAPoTQVGVtUWj50caQxvhFbcy45P41OE iMeQqh8ZUkZJNaRj1Y3K5//V/jUgllW1/ekTsz/M6jZz9K6HTZIrNra5JhlmlJUBjt8vg9Pfj+de eoq6R6cZJJo/QT9n23VbbSn0lbie/wBMj/tVZ5F3zzzSOhbyWAwVAycHoM+tf0Jf8E8PD8uo/F7w 3Jcx/ap7FES3uFBVZp7po8hh32AdPUHrX9z8KpYPwXqOL3pv72v82fyXVlLE+NEL7qf5f8Mf2g6b aRxfD82tw21YdJIldeGLLGCGP4jNfxif8FPdevNR+MdrqMhzbWU902pSyA42ytFGqSE8bjjcPqa/ Ivo00VV4vrVpdL/j/wAMfp30l69SlwvSoQ2lNX9F/wAOfg/+07bWlzpt+sGoxyxO09vFPb5QlAke Dtb/AGZGA/3RX45+LbcfZbOznMCyxl0Se2TMsiZODIfX/PpX6B9JmpephILb3v0Phfo+UrYCvLzR /9b+Fs2CoVkEiFBIUI3ATcYPT056+1bVrpct2ryWsfmOilgrHaCR2rnNorVnY2FvKLe3aZNihwki Z+XP93PrWtHcNC32W0hZ3YExqBleOv4/57VyzXulFqPz5Sk0wiSMEROsQClyP4mFd1pc1r5l1FZw urReU5ViGcLyGc+xOP0rhkt0aQ2dzfEyQWlzPGSzEY2KhkYnOMYFVE1C1Z4IzDMWJ/eSsmyOP6Me tcc11ND/1/5JZr0K8oQbEIRAE7YwM1ktbXcuqPJcXDRW0UBhjiRcskgyVYn39K+NlG56B0Ogyi2R IHwbiNWZxMxdZX3HgH3q9dROYWZ4g91G2WAyOCeB+VZNWdioy5dzFAlivppjA32sII/L3chfT9at anGbdI9QgjP2mFhuBba69eAPXNS4plSkmrIuaddNJLaz31gkhdRPFbvytxjg7h25zV3VIltkRpvM t7We4xHbopeNMgnG48gDHeqhG7Vhcz9m0f/Q/jt1LU7CwtYWtENxNLMLWb90VNsgxiU+v4VFcSW+ pwvDeW6GdogsdyuY22+nBx6V4KlZWBT1ujJt9XGm3SWjW7XEUSlNr7tx4IBDe3Wn3E80GLr7ICMN tfd9zdg4x26VsY3tJ2MhHvLqRZIZBFbtk3CKuXlBHRWq7HbWbpseIRj/AFhRuHVvX60ESejHxPaa bdC6vbi6Fj8paO1i86YdsKB6/pWc9xpMU1++mQzRG7lMk8zLie5B+6XPPQdu1NqzsZxlZWZ//9H+ Lu61SKG1gdk8yNULIwO5kcdQV6//AK6fplok92NSW6htJ5NMayuIrpCoussZB5ZOcNjgdOuK8qmt TnNy2ad/IkaNoCjECMtuJwSAT9cZxUs/mAm+niEYgkJKyYeOQDo2K6ovWwB4eSbUdUFqbz7LFcS7 4Jto3buu1R74puvi8tZLuW+aSeZz5aSTHGzbxn/Oa7KfQN42PGfEDpLC8agmdpBsYHamBnII79qw NLjuWuYXeKWOe3DPa7JTHJ5i58sgjnrjFejQ/wB6j6o56kb0JH//0vw2/Z9afWPBmmGKK+uLuOKz OsGaMtaxlrWHIcrnozPtY9dxr+ln/gjpqJ07x3Hpfmag+kvqf9jWf2/CNaSRiJmWJupjLzsF9AmK /wBDM9gsV4OyT39kn+B/KPh5fD+L0lteUrr/AD/A/r118R3OhXSvINi2zIWHADMu0flmv4df+CkG naxpn7QGp+TNDJqcen3Nxdxq4ik8trmE7845DebjHbI6V/PH0aZRhxvOD35Zf8E+8+lNCT4Ypyjt zK/6H59Jo+tTzy3DXL28kkQKxovm5AwREoHPJA6881SvdSXULe1utMurvT9X0S7e21TTJkkguEbY CgxjaUIfOc88cen+htHRo/z6a/dtjdM1XU3hWOWDy2O5ZZraMjcpJyWx7daSeaLyIVmKTDazW2+c xleCPmTrnGcA966E/euRFe6j/9P80baKFoGuys1iAChi80vvJyDn1B/Lmsyyl1Gwupb2y0+0vktn 2pbXMS3KOG4J8s8Ejkjr0r/aA/yHOms/MntpdsTx3EcfnzxOoQ7QP7vtWKNYhklWe8e8up3k8hZL oEyjnC59AB0BxwKqF76CktGWvtmoWsqanCrSW0EojyoDNhuCdvtzmm6q7tc2hhsby+e+VpV+xQmV giY3Mw7AZAya2JmvdJ2lvLRmiFq0RkiGyC5QrIvcEjgj/DNTNCLLXrQagwS3vNPEjQBN+5gM4iI/ i4/Og5ZvWx//1PzwWBpFt0s9FmvCu+8vnR8SiIBcAp1HOQT/ALVYkEgeO4gtdGSK6mDx2UUrESHq RGrAnpj9Oa/2oP8AHLndzNigjuEtbe6Sa1kjh851Z2Mpb/aJ9CQPwq7NbSW3lTweb5DLtcEY88rj OK1gmtR8/cfHrl0kyzWSOtlcxgPbvljCynoc88+1bX9paY6g37SxS3HDR20Rm+fHAGOfx9qb5ktA c+w+XRrW7ikcNMNiAwuwKHPU7x1PGePWsLUNDm8i1vF1CeCKCXEqKwSGTkABj6H+tUVGV1qf/9X8 8IruOxeXVlgTyYpAptmG8yw9ChP44z2zmsmC21iS71trKQ2thcRq6wxyfIEL5EYB5yuBz39etf7Z czSsf47mxpVto884tr1o4pbyRI7ozR/ugFwAz+3GTVPWUtx4knGlmKMWkgtIHsV8m2kCqoDqo4w2 M+9HPIxaWruM86Geb+x1inF3GA7zRoQXJ6qfUV0V14fhsYfMF0CohAa1lmzKpOTvI7en4DNaxd0c zVnYwLWKS45gty+H8sI3DKegZa2YNMubSVvM5S2lV775POYLnJTHTJ6Uwsz/1vgO012xRb4aZHGk m9o0imj+6pOeFPXiuW3T3E8k0MvltHuyqgbRngkj8TX+3B/jBUir2N6Zb6HRrW0027j1e6nTIj1I ukloScNtZRlhyWxjnGOKLC81C1jt7bVI4rmaF9skccZSPPcA9ccdTQQoJMrSaq8Uc2nJogaMXPnS 6l5vmSQq3CqB97A5z25rYsfFN3p+zTbPS7K5gki2/bJY8TRMRzzn3wDVRdmRNW2Mq5hvNQvbeNLW 4ikuJCJmEu7GznJxjA4rRuWlgUeWIL2WC1ktWlwUghL4ycdSQB19T+exhNdT/9f89LG6vIo2SOz/ AHLI2+faCqEg55/PH0puk2d3e3EqxNEbJTs3TKfKU8ZyOfbpX+4B/ilKKWx1kd67SxabdpEsdqp8 oq4aMDoSvoKuyxReWNlwkyQMWPdXHbHvQQ0upgWVzbtfy3ipCiWuWkaUKY/QEg8VPa3EWqXdzdPa 2zKmCskUYjSUDgdMdaDPS7t2Mi8Zok+yIskiPdF1+cukG7PAXt/SnWdrDZSm9lhzKqlBvBQPnHX8 qDM//9D4GSGSW1uryJl+071WCMqSZc8ED0xikQLbMJpGiM0/7soRhkx9eOc/oa/3EjFNan+IkpaW ReMdpLN5xgjhuXiWMsjHbKVzglCcbuT0pmmvsmvZdUkCRxjFqyxkJIcjKkDvz1/xq0ktEZDVuJb4 TxeWUT747RoB2BrMaQ2U4bbLkxtCWRGdG3ccntVxV2YavU6TQ7S0hNzf7UheaA2yvICxnZvvKq+q g5z2qhGu6QRXC+ZdbyokXA3gn5RgdK1UUmKx/9H4Fv7zzHB1EMiQQlY448EFh90j245+lY0spjki k2s6sCyKrfInUZKj6fpX+6B/hs0ma9tJMbqJHiA3qGjZxtH4DHt+laKQz3V1LdTERuB5EDk5Knsx /Gmkc1SNjJns2tkuJZsoWJieRv8AVyFT2PT0/SmWt7qpKRiRfsxTy0/dASce+K11tqYPRHoXhpbt yN1w1xNBKZI2CKqwrwdp9e/516xoPkLrGnyM32cG6hGUyEaTzE2jH1wKVVN0ZpdmcdOyzCg3tzI/ /9L+tP8A4J53n2v4Z2LtJtuEsoUkWMbY5vkOcjpkV7f+2HDeXHwl12O38rbDavMxeMMwyMfKT07f rX7NxJal4tT7e2X5n5tmydbwlXd4b/20/h28V2tto/jXxfp8EqQlfFF1NeICSIGMxwpP+6Ace9cb eQJ9uubuCdpWJwkhG1io9PyNf66ZDUc8pws+9OD/APJUf4VZ3D2eYYmHapJf+TMqDS47+eLV7iYZ tt0JKAnggYD475FQSRxCd9n71lbOcZBxyOv4V67Z4zv1FjiWe5ie9LNbhgZBEcSFR1A9D/jWjHqi Dzt0skccSKkCsN0jBeAvHHTArWOqMZqzP//T+fQ6TtIQsyKAZP30mQgx24HpUr6n5UNuqJJcQpwI f4ZGOcMcfUc+5r/fg/5uGrMQWy3cu5kKmQ72UMSAfQflV2OSe5A04RmVxIdqogDdMHJ68AUGc9jJ hHm3ezaRHa8RlWxjrkYrTEkyM8ySC3Cfu0kZsGQtxtHucn/OKDnk7KxEf9H+WW58xp8nKknYPQ// AF6jhQEMpk3nPBI9K2i7oyP/1PBoY5YTPcm0+0LEjIcpvVfl6n0x1rNsLoTATvE4h++XK5VRnqPa v+gA/wCac1jKs/kzJEDCyYWYrtJ9AR/npVWRX84RRoSzHoOc1UXZ6ickiFT+/wBptpniwQ06kCKN h2bJz2IwBUoTdJyAiZwGxhRz1qpSTWgNpF1WEZ8ogsNuRIBlR/n+lS2k1uA4n2y7G2lHUOSDkjaO 3TrVJpy0Eppn/9Xwzz1iZmAARjgJ1wPb6Vj3l2sskuwBWjAAwuGbjua/6CD/AJo5tNaF21R5Y0lc 4QrglMZX61LbztYTyrdGO6iyGAi5YDqOc0m0tzMkuJVeUSRZAY5ReuPb8KYJIwGJTLnjJGdvrj0o TT2AaLeF5VYylZdmVG/AOPUUkjFACrFZQwWI7dwU56keg9KYH//W8DE1yk9/Cbi3ulklB82BPukD Bwffmo40EzNhg2zqB1GO1f8AQQf8z49HuHDQFj5AfciHhcgYzimqjqxjMflsTyRxj6UALPbQmNVi LefvwxJABH+NA091cwykrJ12k7dtBnN6WB4Gjt/LdRLOBiKQHlTnnj3xSJbm4TyLgdGVvlPOVII/ kKDM/9f59u1Xd9myWI4J9ParrhLe1sy1yZ38tg8QRh5BU4CsT+fHHPev+gg/5lykZHdFJJXdghD1 HsaUL8+wlhj5iWoAsNIsZE6L5iqNpjJxmlSeOWN18mRZSRtUcBPXI70AWFh3x+UQTLt+ZgeQKSKH yQFJLKi4yxyxwMUESlbQ/9Dw9Qm8EKTtP0qSSNncywgKqsC3r/niv+gjbY/5kLtbD2iS4KpgmYHC lThfxFULhR5n2dBueM4kP8I/Gtoyugi+ViwNx5YPzK+1pCDheP8A69XAkrpM5eORYcfMhwG7DAPN UVGVtyissgkdnUxIg6t0k47c/wA6WO/dk2RRB/MOQ+MHv/jQaN2P/9Hw1InZSW+RlPPariqPLZdy sQOSOlf9CB/zJObEHnPGVQO+3qVGSo6c1VgExmlEwUxYG1ict78fhQS23uOZ12O0UZaNX8reB8qt 6Z/OnKS4Kk4BH3aBCvboVUchlPIPerMUr2wDwIhQHErOMsoPp+NAH//S8YeTeXlXgt1qArwCoJLD JPbNf9CB/wAx48oJFXORj8vyoDOnmoCGTIAIGCBj0oAXy5HAX7yjpkc04xE70VSVC8nHAoEnfQpi EIhBVtiDkjqT2qxGsbWyyDzIpGPClcHbznP+e9Az/9PxML5W05wp6GllleZUUAfICFCjk5r/AKED /mOckiGOVraNlaAtclhw5/dqvfPv0pyGZnLSFSrH5VjGAvtQNaoWdiJVKAlVYAr0xVhngVw8v7uN VySeelAAQ5jeSSIGKZRJDuXB2kcfnTIw8ikJGVQLl/RB05/EigD/1PF47dI35k2L/e6kU4MI/MRW J8zjd0Yiv+hKMW2f8x5Fn7oDZwcYrVuPsscUXkyGQ/xKVI2++f6VtawIyZY0ndleL5WOGYHCyAj0 HTuKSW3JceUoCEYCqORQJu25DCkjMUbeyAfdPQYzV4IY4TlcKRwpGKAckj//1fEo3aZ3iKMgX7jH ofpT4oVBc3cjCJPu+WPm4r/oYP8AmJ5ne4+NYJCDauzKzYbeNjHt07elRXLCMEKjOVOCF+ZvwoE2 3uMkV5FVI8xsSMkj7v4VdlWO2RTySw4B/ioEQrGJGVlDNgZIx0PtSyxNt8xjjHY9RQNOzP/W8bSQ rbsWVSjdygLfgeoqpHdrJI1uISq5GJCvHPv/AEr/AKGD/mObS3Jv3UbFHUDP3XAyTTEYCQnPPQc8 UApJ6In8yNcMw5HJHXP4UjRQtiVYVRn5BC4L47+9AxrkoyRglt6knAwF5xjP5U/zJOAzMjwjKKck 1E9rGU3rY//X8W+0XF06xsoMruAI1TBbnHAFWJF+z8mNmI/gxyK/6ED/AJhyNgJAW27cnIHYVLHO yszNEZBtCgqcEdMe3QUAV78lJj9mLmFlB+f7wJALfrn8KtW6RS233/JbOHdgcH34oAWSBICCsokT pkct9ahMkQO0ltzHCADj8f0/OgD/0PFHMqSNwCqnoOtSRpucyohUkbdxXnj0r/oQP+YckjuGVmbB G3gN60rOGcIBuLDcCBgHGM4+mRWlPqBlXKPvQxAjBy4I+VqntJEYSOCWIcq2f4SOo/lScmpAWQVc E7CAD8zH+lLOqyIJN7F4xtRQev4ZpKTvdmn2D//R8bMUtsvmBRGzriTIwSPcU+2ie4UBCrA42Kg5 PbAr/oScmz/mOjsiGSG7t7qS1nSSLy2xJFKpRhkZ6HkcHvTrtbYxxhnIC/eH3duOg9//AK9SJtao ht/PRXGxmjHfGciknw3llgQUYFB02np/WgxLKdg5Bzzzyae1y0bNHF8gZdpOeSCMH86AP//S8Z2W 6N5k0PmSKCsZ3FSmRgn/AOt7UsL29vOjOnmIWBKP0Jr/AKED/mHLE/nXIGHEaA7gccfT9KLaAOHV iNy/MrHofUUEuSWhYRxZ+a0ZbzZFGxgOUIz0OeM+1UCd6BGYhs5yOooJ9p5FllZEUKA3GTVZgwdT wQwycc7cHHNAe08j/9PyLz3zujyVQcPjAP0pSVmh3lh5oftnpz/9av8AoQP+X8WG4QbrcZJB5kAN PmaOPByTt4B5zQBHFKk1zEHjkaEqQ2GGM9uKmdba1lWMBs43bUHAH8u9BUuiIPIVlaQKwm85WjOR tKjOQR+VOEuG3FZMMwVtzZXgYO0dvpQCdnqf/9Txu4lZXcg+ZGG+UYwwB7ZpJo2lWGTa8XGWjPGc jjNf9CB/zDpp7FqC2L8OwAP3sdhUDszoYYGWP/lmhIyiehx7elAD/K2nZc7ppljWPzExEpKjAOPw FTsXUPAWdcKUcI20Z5796xlG2wEcYS3h/eM2F4BPJP1NSK8cyZIw/RSemP8AGpA//9XykRhgQ2WV OOTkce9RhYwGVTtA52nvX/QQf8w5SyqzFJGaHKfKcZyeoqUqWAt8eZuUu8i9VAwMfrQBXt5II1YE vlT5eHB3cd//AK9STFQQUccYPSg1TtDQsRMWQxyAs/dh8oH+eKRtgLbgSijAx1BoJ52f/9byDeYt sUaFwRknFIiBMy3KAHBXDjhM8Gv+gg/5jou6GwQW5uNo3IjNycfKvuP8KfcwwxtObSdbiMZRDNFj eDkfd7UEuWtkQQxO/lLGWVlbDkfcJPb/AD6U+Vo5BtdHLr9xlOMEUFlKJSlxvflOkkeMF8e/04qY bfLMYygd9x3cnqfXnuaAP//X8YjWZDmMFkXh2x8op6OU81ZBuL85P8P0r/oIP+Y8ha73O0SLnAAB Iwvf/P40nkywtubBPUHqKV10ArSbkk3sPmdsAAdKsTR+VGWIYStghW6EHv8A59axu9gG27qxHzFG B5IODip5IWud8catviO5ZdwVWA65H5UgP//Q8WihuAu3IAxjn1prtc26r9oixIy4Cxktkc4P41/0 AH/MeK8ct3AsbBkjTnHUnHaoZy1s5SaJYonOU2/PtX0zQaU+o52YNlJA6AYXaMDA9KkhmZN7scEr tHfj/IoNClBe3CXEdzbSSho3+Qxk7hg9x+Hetm41e/1HEU1xK6Rk+XFIxKRFvvbQemSMnFAH/9Hx ACVCQxLcnnstVLiVJ4TE4LIeSATg4r/oAP8AmXFjkjl8l2EqBBhQmUDe7Dv+NTm4Zcrkbc5HHJFS /iQDCjOQ/wAwHTHX8acsqQAmW2Z1YtEk2CVYlRj2+UkfnS59rkydkEM62DsEgy8g3KWHAJ4zjvVi 2VGSWOaJJmlA2k53RkHPA/Cok7snn2P/0vDjgHaismw7WB4FSxB18xy6BFXIB+9+Ff78H/MpJ3jd EUl8Mxo6lS/3N/APt9faoEZHWYZGUbaFXkrx/wDqrT7DMhGVliWSSVTltirn58/Sp5Z2hgSKaEth d0cpQBOT0z1rM0p9R1tNMGlilj2Ax5DMccdePXtUdu7h5gI2aFmwNp5TPTPr3rWnsaH/0/Cp49pL 5ClBkg8HFU/NDAuDjaMjPQ1/v7Pax/zLlnyzLAhlAjdx8yYqcRSQwB4YmMSkLIyrkJ7n61kXDexm GR97GNC3Oc//AFqlhM0paJBGkWfMP97J6jNVySLk7Icwe2mGNy7gCVanyCKUyysSsuwAA+wwMelT YmM3fU//1PnyKeNodg3+ajFWZhhenbj61XlDICQWKMMuw/hr/fg/5nxyTCAJuwyt0yetSG6mcgMv yhv3YxwooB6ItieRbmCJIjOZULbU4C4HTH+FVimyWSWTdCScFGGG5NALbUFgPMqEEKwZlPcU+IGV HYIXw2AOnTtQB//V+fF86B3WcKsbYK49+361Xm2mZNmM/wB0nGcd6/34P+Z8uqsBVt8TSMzh42Yg qgGcjGOecH2wao3L+UDGq4HsMkfhQawirXZJLcxSiNvLIPkrGwOSDsULnHbpnFU0mZHck4XPAPRR 7UFpX0Ra8qSSYOGZknUDj7ynnP8AT8qbcQQBfsriWYgnymgfY6t05bByOOn5YoL5Gf/W+a5lazEa BAd/EquCGT0/pUDQJG3mFGZ3+XYW2qQe5r/fg/5qlB9Sy15HFaujrtiXpt4BI4H+fenwI08okVh5 KRgIijAz1PPUmsZKzsW4xsaCS28LEynBIxjrn3qG8t2vVFxBIVWIlfLibc5Xgh2BHHUjipHHYUKR BtUFLgPhZg2F249Ouc1VtzFGG8w/OrnqRgqB1xQM/9f5wurZD5U0Z2qWDkLjEg9PxphE8BngdFhM i7VjuI/mQMAwYZ9iDkV/vgf815YtGt/L8prxd0Y2OYch5vXacHb681WWG6hhuGWVW85sMh+849/y oNofCQ28CY2qrLNyXJPA+gqYXE6zx25jcrI4j8zb8qg9Wz7UFFq5soDPdSQ3KXlvbzfZ7VjE0Tnb jJZT065xVK4R2intz5jB4cI8DFHibg5H6j8aBrc//9D5wvBpVqmjpb2V5NJ9nENy8sgKlwo3tkD5 R6ZyTUccdk0bvJu82P5oCe56EA/TNf74H/N+NNsZIHlj2ARNljIfmYk9B/hVeRXWAzQxI0oHzLId qn2yOnAoAsQ21xdeZshgUiETEsxJQAZYD/JrHLtcO0SCRwhG6JMhn2nJA/Ksp7msNjVsroTWlzCl rGqXACkyIDJGUJxsbt3ye9LDHEsIglRFMZJQgBZCSAOW6kcDj3NZSdlc2h1R/9H5uhtonZI7oCXE iuoIDcA5xjv24r+oz/gkULeTwfbS2EVzaWV3EXdFGNu90IHpxvP+c1/qj9KCVvDybb+1+mh/k79C tJeItWy19mvzP13/AGipRF8JfFUexpd2jXDhi2wrsiJzn/PSv4Sfjjdtr3xu8W6pYPcTu+rtZ3F3 cBYQ4jH8HPI55z71+F/Q8pv65jaluh+3fTZalhcBD+8fmf8Atk6clrpl/Pfwi3juVbyTD+8E7Jgi Q9uQQDjupr8gNUVpJ2uoiJXEqgxEbQBkDAH07VP0uKl81wVLyf6H2P0TafJwTUqP+b/MmvCkcDxz RAuvKy9wOh4rihMyyPGrkxs3BznFfxTUif1Yr30P/9L+N5JXaY2yuyALuZ9uRjp1oeBZPKinnKBn wA4JRc8bqma908yLvYqvp0lpukhaOaMNyEbDEA9cGq80gtJ4jHcyFp0+eMSAhgOMECuOa94sv+W0 MP2w7zCGyiKSx3HrUqiJonCKyvIdwyM5JqTeOxCUhjEZnxmE5LHIyTx/Wpb5l8pI1j2qPnDDk5rO a6lwaT1P/9P+OC01O9ETRsGYfdVZHODjgEUxZi0pWTbFM4yM9vrXjgQXAWLeJwGDrh5B90n2qNXt 4bcxQ7TsAOM8mgCuriRiN23sifwmqN/cFUSDerqr5kjxwhoAmXTp5Y4L2IIsTSFUy+yMkAZDe3NW LRbu186REi8xgUMBbdD6Zz+NAH//1P4vn/fTBHwgBwVU8fhVsM9qnlR4MqHcm48OCc8mvHASW+cS EhghK/KAd6oe9UlnaMuWd5SO5TGDWD3KjJx0LULwSKksjyO6sSFP3farFzcBkUBASnXHGBSNb6XR HaySqWcIJ06mJxkc1JBHBbv5YHzEmTnsTk4oMuZ3uf/V/jIcFpCxG5i2eegq4J4SjCWPBK7WYdxX z50GHqMFvYPBayXNvcpKn2qApMszW27Pytj7p5xjrTIZEUSB9hwMRhhndnuKLdAL7QSP5cjXM4lj Ty41DkRoM56VeudWvb2W3gu7uW5trceTHJMzS4PoM5wOO1NaM1i0oq5zzyBbyWMxlMHCupy3Pf8A z6V01lc+TFIyb/OjUGI5xk+opFn/1v4ubvULuSIxojmUPg7eG571WFzgQRSRPJNG+cuuAc/xc9K+ fPQNSRo3SSM7hIg4A6A0W8rLEyspB+4PU0AKkogch/mTHyjqc+9Os9QW1lu47kM0Tw+ZBiTaxfd9 0e2M/lXRYxkrMtC7e/jQxW7SPnaFYbtvt79KfY6d5CXMl5E9nMQZBFMMcDpkdsgcfhQKzex//9f+ LJr1HKyKmyI9Vce/b/PepRlQ1wpRYU+ZFLY3ZHpXjnXyMZBcBN5Khd3OR0Y1rwXJuldUZY1tk8w7 uBJ22j86aQnFpK5A2oJE0O/ZuIKxgDC59xVy2ZkuDdCSWTzEAYyDHTqR+P8AKkXDYkldQTMq7u7A cA01Z7O8mX7JdR7nIRbdztaMjrk963WmhZ//0P41ri0ntyEZtis2AY13hj6H0z61PYW989/DDHF5 8E8TK8I4cEdxnoCOprigvfSO97M/U39nGRxoNq6aeunwW8ItfNAZHhDFjtOT04GD3Ar+iH/glrpw ufisTC11qCWN8l2CreZG8kaxn5B1wN2T9DX9w4SMsF4FuUtH7NfofyTl1aOJ8br09V7S35n9fWtt /Zvg5FjaeRY9J3SyRx7pJCY+mPrgV/EJ/wAFBfEMt58cPFHhyya5vzqVhb32q2VwwEVt5VxIi+Xn 7ruYlJxyR3xX5r9GOlfiSu7dz9I+k5USyCjF/wA346H4QftPBotG1aOOK4sLiHVoJVaVy6WaL80s Tg4/uqOf7lflb4n1SByJ43WVi5t02fOhAJOR719J9JmT/tHCw8n+h8/4AUXHLK8nt7v/ALd/kf/R /hmSK3mlLqjLMyjcoPBPv6Vv2N99gXyonlVjydiAsp7kflWTjZXOi1nY6e3e3LxSyl5F85ZihOCS PVf6VvxMi39veWbbPJDyeWyjdk9DnP6e9clRboCG2JaXfHGTC0zLKTxg88gd+a6KK1ubhGgsZp1u XIErRP5MhXOQg784xXHNWLi/daO/0K6sE0e41DzpoZoAUe1u4HimZVJUsAwyefzHNOvzFdaYi2Vq 8t0P3kakiOP5yMken4+lcclukaXstT//0v5IZNHNzNH4efUI7W+meO4aQsGBCENtMmMY7HBrfv7K 7nnkm3Jt8tVlijjCq5QBd3rk4yffNfHNpLU9AwZg0PzMCrj7mPlIqlp/iOVlu/PAjuYJdk8kWXVw v3RnucelYt3dxJ3OotBBqFr/AG7bXjzXMihWtZRtCsGIDFuvas+4mvH1kT3MUTWsiLHPGM+T8v8A Eo9f8KQzbuZdPtnDJPIkqhTZbYxgsR82TnjH40jzS6yif2jLKI7fAAUcXDYxnnofpV09JD+xI//T /i6CXMSOk0jSvEASZSPNf3A7/hWtZTLKB5hkzGoxxwR6A9O1fPLW5lT3JJp2im+3vbgQqViJXkle +PQnBq9ealZQW1ups52jupSsTEb4uem4/wAzXSZ/bkV9kVpFAjrFCx+4sXyxhT91cdsCs0J5s0rH jaM8feb2qoq7JnsSeYqSRq6YLHo4yg+tQx/Z79b1IYvKRHMcbhdjhgfm4Pb0NaSV0zI//9T+KTUC Lad4PLOIl2lsghj36cdqfmfUdNS2u98dsZRHHLt2SDbgqA45HTPBry6ZzLVHZWLhl2NMAYUG1GDF pOg6/ryauWNx/aDX1qVjdYYGkXLD5+D8oWuiG5LktUUIraS7ltrsOLCSxuB9naE+T8yrt5X09/Wj xHPPqUF5bXUZvBIg3XYmxLbHIJbHQ/8A6q7Kb2CL930PHNcEdtEiB3Yp/q22cuQOM0aEWea1Jbbc b85J8txyeh7Ejp9a9CneNeMvMiX8GR//1fwA/ZL1PUNV8NzML/VbG5l0uC2ttHWJ2N/cI0ce0leo CDK7uzdu/wDRf/wSe8VXP/Czv+Ea112TUI7+PVNPZXD7VwyEMRxu3JGfxGa/0J5p4nwcfJrL2Sfp ZbH8ncLVIYXxjjz6Rc5J+d7pfof2nQRC48LQJcmNyLMSXag/MCq55/IZr+Ln/grF4dj0X49W/iO0 uCrJeXmnm1kXKhDMBHnPXAA4/wBkfj/NX0eK7oeIig9mpr8Hb8T9U+k7h1PgyUuqlH89T8149b1C ztdQvJUtZbSKySa4lmjHmIGZeY8dCMrgjturJn8r7NcTRFIGvlFzLOwDPcMQNuT1zgD8hX+jFOT5 kj/Ox0/3bKkCvGbV45fLvJ0370cNH5Sttf5R68jn1qpLYwPqVxN9ozYwMs9kXUP5zHAkQn2xkA8Y P4V2HPFbI//W/PmeztFfy47i21CymgHnCLKGIkcgE8gqfT0/CuWtrdbC6eD7Qxt7VT+64cKTjDM3 XIA6ZxzX+z6d1c/yIcXHc2rt545rG4KPdO0g2BVDMRn7rdyOnFStaWMcbzz2n2aYr5ZPmEDO4nlD 0OOOPSri7MlrSxiRSwQXkyrtC+WSqkFlJ46itOz1ybSrqLUNMLNeWlsyWc5PlRRtJjepHOV4wR9f WtU09hSbVmi5fyyTXM+q6hEBqd9b4d0k82IuRgsPzPHuKyZAkdtaOzeZ9iiCJLIu6QYAU4PUZpnF UbbbZ//X/M99Uk05r2O3inN1fW5gLs5UiMndjPuRz+NXtOXUbm1lWG6hs7vTIlvz5kwglALAZjZs ZPB7+9f7VJrqf42OT5rFaWf7Tpd7cyq0l1BKxMsj/vZeA5IJ5I65q9plvcy2kWph0224UhecSH2G Oo71sQ5O5Jpym4uZD9nLkOXZYk3eUM8sQOg5/CtuHT7KG5RzshkmbEcrrlUYD9O355oBzbMSHUdY vGuPIkEey7aCVWKkTYPzcdPX2pi33/HzbtGWAbmN/mjhPt9KDSMrrU//0Pz3ttTMzRW+n6bBHsj+ zTvc/vPtDbcmRQwwOpxjgY9c1O4sLt0E5Iu45BC0du5gaNgFIyF4OQa/2wP8cFJrYtarodtJpi3k ZQTSyeU1oJAbg7Twcdccd65zT32vJBJbkhk2o7cFORyfT0z71SjdXM3O2xsaboUiayj/AGiCG3jQ yTOrh3cbc7VPTngU++sZfN877O6fb3O+VW3LIIvlBPtxitYqyMiK2sJRFqd/5rxW+n2plkt14nuG BAAj/wA8YNVtL1J5YbhIlkIul3ysWIlGcAg/lz70xt3P/9H8+5rG2aeGWzhCl4hAQ0nmODjDMeBx kn8qim0a2ivHiRfIm8gJcSu+5SwzlsAfT1+tf7cpXdj/ABinuWBfT6TbRR2yRzeacGVhmW22D+E+ hz09vasxtRuZZHuZo5Ht4JN0rlNhx0+lX7PzILqzLK7SqDbxohO6Q4Minj8ep49Aalt7YTxy2tjt uHkh82TYcMoJwAT2/wDrVSiomM5K4y3nuLNbq5mlkN9ZwPGAx82NUUYI46ngjP8AhV2yMOoWMUTS vD5/7+VCvlyHPsfbH0zVHM3c/9L4Du7fT7C/eBRNbo8SoI5pWYtwDkL79fpWlBqMEGlXycQMu2C2 iC/NP0+YY6Adfwr/AHAP8TzFeeVoxLNbSxMcxLMyFVlwATg9+o/Oq8Ul86OkZVIQjF5jkHjkDPTn p+VBE20rFKysbsTvdfYGa3lG0mSQETAZBIXcMd+a6XS7NgNk881tbKSbZIUUxStxlSewHHAoMixc 2z2N1LPE/mrdx7mJAZHwcZA7Y29vSqN00ksHmSmNyoAMKjDe5A9KCJ7H/9P8+/tdzGE8u3AhjICq QAp9fxxWq9tZ6nMI7WWW6coreU8Pl/Z5MZYdTwMdSa/3HirKx/h+UrvT7i0kEtwVBgIkjcyDg89v zq3BrMT2LboGO99iPn5Cw7gUwsFydQtbWO5SAX0H2mMX0UDeW1orttDyDt7VWuEvJo5rSARxuf8A SIrh3Dpt+9s+vH6/lrBaGcERTfahbxuq7ZoULFVfnI6/jxWXbTyyC7lWSXz5lVV3r/x7EYzn1Jqy rLnP/9T8+5baa7jVmMW6GL5tzY3c9B+Oa1bLRVkNtvYxMOJDgFGH/wBav90Er6H+HD3JJbw2gSKe KJp4ZGit5ANzLGPutgjvnqKztTuLsWyADG2RZo2J2orKwOWA69OlbRjy7mFbY2pPInhtojNIILoI 0gUbow5UFs+nORzVK8sorS7hmSSQQoMGE42N056ZqjlNrQZZo9SjbTFBWY7Hjl/1JZiMFj7GvcdF sL7Gm3LWqF/LidonYoZ3EyljGfYBjz/dHrQ0nTkn2Zwz9zE0vKSP/9X+qT/gmZfpN8MrS3jR47eD TopIEkwzfOi5BOTyM19iftSws/wh8VkIJEOnujhn2lDgFSo78j9K/aeN4ul4s1P+vy/M/NpP2vhL Sf8A1Df+2s/hP+I1jcR/EXx44TCyeKrqFSUZ5ZjGIyzHA4yXwM/3TXC3ovLOJp3hCrbqJJYydjMr bdoC9ehJr/Wrht3yPBv/AKdQ/wDSUf4YcRK2cYqP/Tyf/pTM2C9uZZpFt0+xRSyYPJeNh6ke349K 1tNMb3KLMuFTm5bHRehP4Z6V7p4c7aIhsYWlnlgskNw6SFUwMeaM+h6U+7shCro0Yjkkfec8lfYf 57VrDY559D//1vn6ykhihHmfvjGWZ3c5BAH3cfgacSLuN3jiSKQkCKOL7oxxtx2zx+Vf78H/ADdT 3FsVWZHjuJTvPACfKU571M8UVu7bZHb5cBh8rH60GUvhZXtc26TmOMuJm4dj8qY7CqbTOzgMpIVt wHuOhoOSe5dlMLxoyj95s2uf4c+1TQQBYNw3ebnjn5QPpVwaWhB//9f5/vFvYAv7qVRKuSR0lAP3 cZ71ckn+02tqEszbWqRLCkOMIu0ZK8fXpX/QAf8ANDP4hVS6vD5MAR5wmYoVxEiKq/l0U8/zqiTK jKxYrMnXHNBJbmYTQnywUJALMBjaaiBKR4fDjOB2HTHNAFmaVI40CIEKrnHWsy0ije5eTa0TyYD5 Jw3YH/PrTTs7gf/Q8PuUiRNx2uycKPT3rKW33BjKUJblWAxiv+gNT6M/5nye2hkjiALEWyHMoXl5 cdB+PFAeMlvs9t5aP87q43Og9Cfyq24tATOkZKuQwMRGOOORxUxhkbbKHRhJycUoLS4FUQnzmOMO nX2qyIiyOeVwMAkcVYH/0fBrW02IVQJEGfe+F++eeT702QNA6PEFZGPJU/N36iv+gg/5m+a0mSSS SyncQF3HsMVXikleVkaGRlB4cjg/TmglS94uSQBgCMq+ct321E8k0hIRi/lja0h9ugoE7X0MyW7a GVTJkDdtyOa3Y/KWBZYw+8jLFjwfTHp3oEf/0vBw6NdieUebISHJblcjofTI/pVu6No2WkkZ53Yu wPOc9yfzr/oIP+ZcpeWNjBgeu9McZx/+qmwgXbPGsiJOxwryHCrzjJoAnktER1RnjtmjUrLJISUY jPzHGfYcCmQWt/brG91A9sJVEyNNEyedGTw656gjoaAL6iNZpZopmMYjwxfCjHf/AA61F8r7sPgr yB60HPa2h//T8JiEpldWU+X2de5pVikWSQhvLGQPm4B7D+lf9BB/zHlwx3UKhkiLZIBOMZz0qWKF DFMXykwXuOuOxreOyAq2ksSqcgByw4YA/wCe1V7qMi5zC7OAh+QArGxOOv0wRTAkiMl1GsF3AsRU HBDZDj60R26W0ibF/dpwAO3vQPmex//U8SuWDeWxyEjPJU/ez6ils5bdIblX3F2cGLJ6DByDX/Qg f8x5HboyCSUyHBOCCcdc0tw6xICAfmIDHONuaAEls1t0geK8aSGRfNlgVCqK5zwc9SPUetQzEQhJ ACXkbYAOo7Z/WgDStRBIWDyM8gOCeijP61Pdw2nmYjlbb5YLI3HI60Af/9XxoNCINrbjGTkqDtdv bPaqUVwWDIVwFOEPXNf9CB/zHlxNkcUpbc7uAEIb5UweSR3/AE61YItnSPyZXklC/vkMRRE9snr+ FADVZR90gkcFe9Nmivf3kMc7Rx3MW/5QABtJ7/hQYPcqwJIHeBpFkCrnPrirCo7YVwFXoD0yOlAc z7n/1vH5fLaF7duVYdQBu/Bu1VmFqgigidzOi5nJXCLnoAe9f9CB/wAxPM9i7a25IeLyxdGdSNoU 7h3GB6is8q0DmPYVO7CnsKC4yVtRbmKUqGiYMR8xXOC1S2lvHeziG9nFrEi7mJXcWxyBj0NA+aKF l+1XB2xIzxW6iKNRyxAzxj86rL5zKM/ujuG5D/8AWoGnc//X8dmdAgU7d2M47mqTzq0UqpEwl3AI 46YAOR+or/oWiuVWP+Y8dalI43EsbGSVhtfJwmPanSiaON5cHy1YLux69OOtUZ85IshCrkdeKtbN oPJDgZweMUENt7lQXDJINgyR98jrVk3AmQxMgAJByRkj6UCP/9DxtwFKlMkJy5H5VbmgW42mNsxK ucEYLHjGfp/Wv+hg/wCYcqr5MSum0+buyGH3cc8fyqNp1zlY8MoxkDGcd+tAE7XMckSqsQ37uZBn J9qrtFObpXkVPIiiOzP3sk85FAD5JWA/ckxOxwGX7wzTxHJ8kDNmUqDlzgn3x70Af//R8ZZZIn8u U5Qf98ioLt40RhEVbbIIyV5GeO/41/0MH/MORoVcNHJnzQmY8dOtIbcoiyb9zDhlB5xQVF2Jbfa8 XnysMhyh42qADgZHrx+ZpHhkD+YrFxzgA/Lj6UFOemhYgR8btynJJXOCRj+VS+W+GONzE8nqRion sZn/0vGYzMj70OxlOFYcEe4/z2rVybsHzWG/bnLDl8f1r/oQP+YcoLt80q+4CNtoUcBvr/n+VEkR Zt8O7g8r2NADVXLvHMMjGR25pWNughWc7LdpMTEYLgfSgTkloy2PJZ28pf3PSJW+8B71FcxYKFBk D0HegZ//0/JN8cRi3W5leRv3sm4jaBzjH+etRXN2CGSL9x83yDGWX0Ga/wChA/5hyOJ2EeTgknkH gGrySgbCqYYRlC33hzkH+f6U47gZt4zK8cQZcv8AdAGC2abIpggbagBB/eDofcmh7sBltf291GYs kNG3locYVxkk/qakSLM4U718s72wSnT/AD+lId3ax//U8pkeKWD5g0jlwpYEbFU5BJ/HH51TNs9u dsDZjJxw3H1Ff9CB/wAxamkh9vBiSQOkhWNMIWJ2ZOeSfb/CmSW+WjAKkBudw7UEX1uaKkLuQKMd +OKqm0acnBT92C3JC5x6UCAW4Cl3OGUYVapMYvMQypI2DgCNtuCOmT6e1BMpcp//1fKbi2VkjYHf M6htwOQuc8H36VlyWUv2hNzZUDOSMEV/0IH/ADAubZpOoMbwR9VXcWPAHX/OKjhjIiEe/wCc9GPQ mgkuIsZjIl5ZflOeKhMMUOzy4/NZcKqlhnHc0AWLmJ4TGwAYSrlsdI6ijlCt+6gTeqlSWG9T15wf 88UAf//W8uMZYMBkbVyQO1U0to1Lr5obJyQvb2r/AKED/l/H58lWjVR8xBPGT9f1oktXlKckgHOF P86AECLbzHk5VeFPShpH80SOwXeuwAHIOeMUAWvIaNVzKH43Lg/dzzj8KjIYggjcCSefX1oA/9fy SMWrFliSU7nC4cYxj72fxqzcwIsO1WJc/LjHI49a/wChA/5hYKyM5C+0orc9CO9RSw+WEWMHC9QP 0oKJxK0ajzAWyuM5IOccGqTLNM3l72Q43DB+ai3QDYtJUaB7eaNXZfusfvrz+tZYuUimJjO/Emza e2ODWbh1A//Q8tR18plDAKSCw9+e/wCNU5JX3rvhRoo+MRjYZByTlvX3r/oKUG1c/wCYcz7azmuL W9vAFWaC5SKKFyVLrg5I7dhV2G4MPzFfm24Jxkj1olHlAinZriRG2jb3IXHvVg2kO+KZpfkRGUxB sMc4wfwx+tSHkVllBZ+X67VYjaQBx0qxtIjcuvy7flZTglh6igD/0fGklWNl3k735UfnWgENwoRW UHODvPFf9BB/zEJ2ZWlh28L1HBx/FQ2EhSRgo5KhAfm49aBEaOPKZwSku7Ear93HqTUJZQH+b94n O3GSaDSMlsyaErMEdlImJy2eQaLiJp5jK4VFBx8gCrnHHAoND//S8ZjWbbcpDKgYLjDsB78A/h71 IkoSLE8ZLhfmIPBr/oHle2h/zHkVrH5mcqCWb92g4bp3NQKLxpiGwFhyGXqM5Hf25rACVvMknZp2 iIIBUIAu0j26dqWSRGOxmJboN3pQAi6fhvMj5IH3h2qdwiF1jaTIj+cnhScHgUAf/9PwiO4nO6LO 1VOEbv6VbV2ziZmPlqCXYcHrwDX/AEAH/MeW4ZfNB2t8o4HHpUTxNORE/RTwTxQVF8rGRiJfMhZA JUXcu1gVx0z/ACp0sK+SGDhWY4AI/OgOZ3ug8hoZGJa3lQoMPCmzBx0IwPz70iEFZAVLbG3GQDiM HAAP1OfzoDmdz//U8ihSIKx3As5wd3Sq0kAby9gXCkh+OvpX/QAf8ynOhTCkqKm3ayE9Oh6f/Xqk EBuJ7eSFoXt8BhINu/IyCvrWM/iJ53axPIwQAAEnoVPenyQzXHlmIqqAlvKGcR9Mk5+n6VIpS5i0 kUE255+sSnLZwT/nFZDzoCixFkJb5HXB/wA//Xot0JP/1fEd7TSLHbxSSSpzJtG4MPXipX2MJo/K aKdQPKLNhGPoRX+/B/zJXXJYRoZIhG0iI427hn5vLOcdKr7Y7NJWSIb5CZGOOGJ7n16Vd/daIKcH mzBi4G5pMRoo5H+PNWnlmkE0FyrR+X+5O7lXGO3p9Kg0h2JGXzUhG4vsACnPPHbrS4a3YA5BfgHB 28etVGXLoaH/1vCLgu0qu7BFI2fdxuqaK1ijtWZdp2yZbcN0jjB6H271/v05XP8AmXKpm82VFRlc KcEDgj2pZpnhuDFn5l+8FOQMjvUgSwtHDL5oXIKlWBPy/MCD/Ol8pIICsB25bKt1PNa86G3d3K8E LpkylpWHBcnPTnimvMrzRqEJ7E/w8VEncR//1/CJktJCZY12PwrAcJx3AqvMWVREvRyMk8gmv9+D /mahuMj0+YI4naJ237kXBygHPPb/APVUZnLSxW6RZ+bbvA/U0GpPL5qNz8jxnqPbvUMcv28yZyxj PMhGQ+DzigCxNcC2gVkjd/Nk8nOz7p6E/hU9lJH5cgRhmNsN6bsZx+ooA//Q8DeQSsUkG7J4JFUL xVXbFkIUO/co+Yfj+Ff78H/NAlpckSMgZidmLJgqOi9e1VpGkgKyTJnB4OM/mKDZbDvOR1CBMEch jxmpmsGeHzADsZtrc8r9R+BoKW+hJJHLBAZxhYo8RrIrne3QHI7dcd+tVWhkaOMRt5agZ3DJcn1o Nz//0fn+KN7lYmmm825UAbpThpMe/rx0rJvEuZbm43MQu3c7H73HXFf78H/NeEcUM1tGqMOFwuDl T7/pS28csPmRyuAm3dFt+Ug9cVnNdRNXVjVsobO7Oy6mjhMi7C8pO0dOCQKjntDZO8FuUcxnAMbb 4yB347VmTFNKxWhN8FkkKoB9wg8jb65PSqbWscrt5p3LJkMobg56gUFn/9L5lSFkuY7aFRHHGAkY LlvoTn/PFXJ7edLmOW7KXLA5XnJHbDV/vgf815nSyww3WyCDyWkIMkhU7QfXP+elX5ku4p03pi2d A6S7SPN55xkdOlBcHZ2I9SElvqFrFakPG6iS4JUjZnP7sevbmrNtI8vmCQPEyEpFu4/r0NBqI7Os JacYmB2qQOSTjjPUioYLht0kTrh1UPuzgkfSgD//0/D7O7s3026hnhQNLxE5UNNAwZeQeu1guD9f wrlLmJ3ZI4wx2MSAP1r/AHwP+byDbWpJYQwi/lWSaQj7CZkyQIllVh8hB65BbH/1qrzTmMeTu3SE knAx+lBZo2lzIUDQthwmxmxwMjByKx9PN1FeX8whby4VMXmhQocNwdo7en4msp7gWbi9Kr9ttYPI jWUBIPvmMYHLA+/rU8QBiNzd/wCo6tJt+dMjPy/rWb2ZpTbvY//U+flgsWs43EjLOZUVYg589kYg bicYA5r+sf8A4JTaI2m+ALQbEihgt1iiigkEiyJufazEcEgIw/Gv9RPpU1FDw95e8v8AI/yo+hJT c+P8TPtTX6n6FftTXl0nwk8TQwkIs+lzIHVcuvyAY/HIr+FX4tzLJ8SPGBd4poI/GN/FHDERE0MM axhd+P4twkz15B9q/IfofQaqY2XkvzP1v6a8/wBzgUv5rfgfml+11d6vdeEmSWU38cGnXcFrY7gT abY4/lAHOTu3D/fr8iisEri5hMil0VTGzkqpA9O1eP8ASzm3xDhIdov/ANtP0j6K1NR4D06v/Mxd TvbqIgAC4UEkgseDVSGLfbKXGx3+ba3Div49qJH9PwWp/9X+NMNNA0pBLOF2oi8Fx6GtK5s9ZkJ+ 26a8MS2CT210jB0YNhVLY+72HP0pzjbQ82KsDW1xFbQJOAJyoMjBvlfI9KzlgVLiKYwI8sblFEi5 BB4rlcU9zWMb6s0mH2UrBJEyuCJWhcfdBwQSPfiratCB5iIFduORwMelRKKS0NUrbEnlWso/fxow YYKsPlY/5FYupsYQm1iY9+AMZ6VjJXRcYN7n/9b+OC6QXCqqBrVyiukijGCPb8OlZUsLSX376V03 gI8x53D2Ga8cCtLJujeBzIpjO0B/4gO9VQjlHRUJYjao7n3oAvxRPDGVYRyy7cjDHKf56VXnTT0C hh5bZ8x1UFy5PUn6/wBKTdlcCrJqTSRCSyLy2ig5jX5d5H8IU96u27SSW2W4jaUuBsG9MgcE9+nr SUvduB//1/4uLtUBXa22QH5DnBpV8wF5n/eO8YjUZOEAzXjrXYCiySFmLEEEhlVRyMVak1PLSoTs uXiARQgAbtn9KxkragFrbzrCwZj+8fexbny/YD/PWrSb94ikRfKKYL9GGOhNOMbjTa0J7RGs5xiS SX7UQqqeYosdD+Iq7c27OytGMspy23gGhwfQR//Q/jONzbJPCs5aFt+1toDD8RRewxiUvE7BW4UP 3/CvDUGmbQd1Y5X+w83Lytb28X2m43O6N88gHTI6it24sY7dI5Cvzwn5BjO44x/jWlle5XkJZXM0 mTMuOMNg+natK4NmP9GcSW8rw+YPLj5YnoQen/66hwSWg79DnYoXgvAP3sqiM5Z/mfPQVtRSiaIh m8tocjJGM1kbRd0f/9H+MWKOGaVYmyo3ZaaNsM3tUF/brGwRSWC87u4r589ArxtEyDLqJ1PGW+Uj 1ras7A3pBjkcgIQAoHLeoH4UAVbu1WyTlpJHz8+5Pu9v8azZommAdBvWEh2LLjOfT860i2wsQ3cl 1vtWiufJWIktCnyiQnpuPtWrHI00v2qSSQzeR5cplkJiZR2xnFaAf//S/ipu5Q8jKAior/KAAAfo Ke/mGAElXA4IPA+hrxz0bNK5pukD2yoqKOBtkUZMeeCAKgc/ZpGjRHdUIDMFIUg1UVqJq+jJXgiu QTCrKy/PFu+Yqe2fzrQnuo4oBPdzwwLDCEkkA8qKMDjnt/8ArpLRjjHoiC3vImn3hA0OwcqC271O O+fatu4tLUOJbSKLLHeuIwpTPX6VvtuDVnY//9P+OK1uZGM0EoO+NgMuuBg9K3dJhZdW0+UGJna8 jhG5ig2s4DH8B/KuKnrNWPRqLlot+TP1q/Zw02DUNFv7mDzLmCGLYY1UMVlji2+WY/7oG9t3bJ5r +jr/AII0afb3mqN4mniCtc6zLpUsTqEuUV8ooCg8BcqCfU1/b3EKnhfAx0+rgl99v+HP5A4D5Mb4 zynfao3913/wD+pD4jXr+H/AV8ybpWtNKdp5UbG4bcAD6Z6n0r+Ef9s7WLvUfjz4zvpfLTzdUmgj urZw13FFEYpYFJ5yvzyqc9Nwr4z6LdFTzbE4jtH9V/wT9B+k9O+WYakusv0Pxa/ay1q4vfDGttZ6 ZLeate6pHLJNJdiO2SBgUkMi9ySSw9hj1r8j9YuFsml0weabhWWVz5e2MZPRfy/Wn9JWrzZ/h6S2 UH+f/AL8CaPsshnJvdr8Ef/U/hks/MbDFSjsMNjg11um2KEPcySASwsuID8vmr0JB9uKmTsjpe5b WzupbxmRhHBJ8wQ8OuPSuo0qK1tGkk1BBIC3yRxybWYgcEn+lcNXS4iza3VxNqlxaJaR29rFCJYZ Gc7GJ7ZNdEGksrjT777PFdCeXbJFFNt8pl7nuAOx+nWuGb1Kj1OsW2jkl+0NKZFcZaN2wI/p9e9M a8vrGaXT1uoRp+pKkkflkGePaTlWPJAyO2K5Jvdouex//9X+RDUbfU7G8S6ggeSaKNTLlSzKvGMe xz+Ga6jQ9Wu9Q3RXlv8AZ5skqCeXUYHp+lfFz7HW78oaw6uDBsDGP51Yetc1p1tiZJY1VdlwGZXU MjnOTkf41mVDY7B9HW106TzrqWzklRriyWK3B8xgehBPQ+tcuPPkg3y3/kypcgLE0QZZY8HIP908 e55qXKzsVJ2RpWky3Fz5TLmNSBlxjZ759Kvxy3MV9PDKd9nbsFjCKGgJPGd/vinTl7w38LR//9b+ NBo5bq6sGt7dZ3aQpJcBgsEIU4IdjwM/XsfSnyS7GaIW4jjQM8stuQ8JKnlQc9fTsa+dimr3Oek7 shnv7S3jWRpkdZcJbQPwdw65qKHUn82Fm8vylY4TGVU+oFdQ2veZW86Sa6RJRNKs0xVJfLyiemT0 FXpbKaOTC7vOHygYOF/D8Ka0ZnPYy9QubXTHtYZbm4mku5SkoMRdIW7fMP61E9zhHAeSHcuSNu12 HrVynpZGR//X/ixjsopUYySNOoiBVw2WT6+/1pfsEamGG1u7qa33B1a7Xy9hONxCgkdsfhXl09zh cn0N+ysmlmW0W5jjnnHlRSyHagODyf0qpYWws9RjmUeZcbDbysX2bOSSRzznFdNPYk6Bvsl1bzpM wOyVWUbsMvPQH8OahkgspvtUKRSKBEeIc4ZiDsHmHjr15NdtNbDTseWa39nCqoZSkb/vmJBdR3Fc za31vDPHdCKWRLeYMPKAM20HqB0JAzwa9CC99eoNfu5H/9D8AP2RdS0W2n09klvoox4akXT7m4/c m9nYIr5jHIGzzPfK9e1fu/8A8E4L5LP49aPp9he6dAbuAzWwT5bktHcQyMkrNznhsew9TX+g+RzV bwin5Uv/AGxH8iUJew8XaK2vV/OSP7mPCt1He+DrXUipeS8sxFcRJkYfYA5+lfyF/wDBZDwtqTfF LSdYs4rdkstYlsLseaRNKJollZwp4+VY3Ugdx9a/mLwLqRwviTTb6tr79F+LP276StF1eCaqj0af 3O/6H466ZDbXFxJprtNJBc2xlm3SbE+QEiME9M8DHvUt9plrfwnQ/Mhg1ARLdxxTyYUqnOM8emAe O1f6R00rpn+cDa5eUzI7GyWH7Kbh1vJAYflTYYwB8wDZrAvYpNLFtpsTkWNpdPIr+Vta4zjIYnt0 PtXWcsN7H//R/OWEx3Mlpabk0+0kcPNcqM+Wo5OB34B9zVW5uFS+1hbFhcXNxctJGJLQwpFGQCrk enQ8Hj14r/aBK2iP8ipvWxNNqNkthGL+2llvI1KsthM1vLuHAw3PHHb1q95q6ldQWauUYxpKqSId 5U8Yz0J7VpGKauyDAu9StrWaWzMCb5ZRHFcplmGAchsD/wDVircOm3M1o8M1reRpFjyLkoRDcM3I RSPYmtDOcrKw+y0VbSGVpjLC+cyxPIWeP6A/Sl0i+a1tJ3vtwsp/3ttGIgbuQAkZkHVe/Hag4pyW tz//0vzbmYjUrs2gilhlgAs5rwYeDIDbkAOARjjr19az7l7hLS2trxvtlwVImuXbeXJOSv8Augng elf7VqDaP8bPd5vMsLND5CK8LN8pDR4/d4p8FxZ3SRwwLcW/y+XDslKKZc8Fh/d7Efj7VolZWREt WaWiWQ0/Ubm+lYQXFxZNp0ss0pSJV3hzgdM5WhJby41Noo4zNZY3QOF+Zm4+8PzpkNpbmTPYu91L cxyXEd052SR+YUgVQeoUcZ960reWJiEv4d8EgCTFP3bNjjJI/wA9aBn/0/zqmu7GwZ0tY/PfzNsB DgIin1+gxSWsCxaiNTlLJNPGGVZBuiIXIGF6dutf7ZqDvqf42RaUdS19s1BpL6cTgxS48hI1DvAR jJHoMjGB2Hua047uOG3dtQtkk8xMGLZtymAM8dzT5HaxkZGkxaRaXd1exTXqQz2oEMTh5SXyMKR2 AyefSreo6oLrSpraxuprW7iJDzGLDxK3B259cH8atKysBV0u5vr+xhtdOjfUZGtzvd/vTADkuen1 JxVzS5x5d6wSG0uNOf7LOiwHE6YG4humfmAyCc0wP//U/Pm2NhFqEbwKEEpCOinYuWP936mrOoxh bp7fzSMr5rlTlwM1/t3BO+p/jFPcrW1u15cW6x3AjjilCv54AQrn68A+tSanNtu5bedkFttW2hJA SJmyDnPf0/GtSBZE8ye0t5PLhZMRpn5YzgHG6poZLmW522tzbwxxjMsCx7ZJ/diByB2z+FBzyV20 yNdVms9Ss7q1s47nTmvPsTqYhNCsuBzKvUDJzjpj6Gq+sNczXUV0wij1O2ulO1oQieSx+cBR0yvS gxlGzP/V/O+7iutTu7SdbIHbIYRPyEU4yeSTk4wMduK6hoLSeysIBbo01vK00lzt/fEHb8hb0yvQ 5r/cA/xQs0EVmdQlW0km8qJstEC6rgDk4zwOlUhDp+n3Vw8M8uq2qOsV5pscoY5IwMY6cjr2oE10 Yml3cdrDcwGFZZrglcPkvEDjCj0PA5FO0OHUHu9XinsJ47i3+RFvCI41ARW3Rp1OQfrn9Lik9znM KS5Swv3iWSWO3ZRDBblcBDk5Cj3ya1JrmAWcM1l891byjz4p037175Hb6GqjFLUiex//1vgzEd+1 ojxslvFKLi7ZSYwqLzgHpnIq3c67C8/2rTbePTts3lLaMuXdBkZJHr/9bFf7kW6H+H+25DfaZPr1 xYMrYjkuf9LETHAxyox6Zxn2xRa2cPzrM5t4Y22sMZIwfTnGcVsoJGPMye80tL6+ku7HUGntbc5n dwY1mwvzLg5yRkGqF/Jss2mt4T/ZzSGJy3zNxkEbhj0J4qiS9b6ppt3brZRWOFuIxGGLlpEOONvG R0qSxFkbS80+ezuILuGQymZ8MjheAvTBx/Wgd2f/1/hO0tna4dAFaErkEDO3sc/571qxtBGzRsXc EeXtXkEegr/dKHxI/wANzE1lD9uivbhPs621p9lgjK7Ighxzt6Zz3pZoylugniEkEmAXJDbSeRxW xjOzdivcr5dl5kEv7tDk84wB1/lToGbVLMSPNFHHajZ5rsQCT0H6UHOo6PyN7w/FNE89vDIGV1Ad s4WQ+3+e1e/eH72CaDQrRVjthZaf5FwG3EFw7Fipz05B49falL4Jeh59b/eaf+JH/9D+nr/gl1Lb D4YaRa2lwslrDZJFAG3M0gUsVbceTkbfyr9B/wBoi0W5+FvihWy+dMc+UFLBtoySfwzX7d4ip0/F Wo/+nq/M/NsAlV8JaLX/AED/APtrP4Vvi3Z/2f8AEvx1dR+bAh8aXkS2jlgORG2QDzjayAnvXnF7 dadCssYiurkswcqVwvPYH8a/1g4Vk3w9gb/8+qf/AKSj/DLiZf8AC5jF/wBPJ/8ApTE+xLd3BTTb JLZnCyIAxB4UAjk+2fXis6W2njny+EkQlZEU/LIP7rY/Cvoj5uUrBbTNbzSeWDG0pJIi4GM5xWw6 QX8KyIsjTcKu5sBT3zW0PhMJydrn/9HxiDS7q20zUtSlsluLeBvsjMh3iGRsFcgd8Aj05rMt7YKF mELoZgGkRmyAfp27V/vwf82791XkRXW0XDzQwrFI6qhWLAACgDP9fxNaEFm98MF0VlXILtt3+woM HJvRkTNYwI1msskkjv0ETCPIHJDdKzJLdoXyvzKerHrQYS+JlyOOIQkcknlgRll57VFHcMRJGiyK U7uhQn8DQSf/0vAore5Xfdo8k0a/6xHYsq5OBj0pDcCUPZq7LvO91BxsPrX+/nPqf80MviNAsLUI obcSvLY6e1SRWCXUTX63lqoQ7fsjki4kPdhxggentWhIrKNhi+TAHQcFqzwI2zE3ygHDD+L60AWo 7U/ZBEvzpC7MJXP735v4T7DH/wBeqwtChlZXVHZfkZhkA9uKAP/T8BW1JAaWcySt8pCkqijtgZP+ NTJAPJMRJeUP8uOMDn/61f8AQAf8z5Xnje3kVS5O0bsevtVy3LiNpZIzHNMmWT1B5H9KBXS0ZH87 uUaMqgXJP0qYlvKYxSDy142gc1tDawyNoGtTHc7nZ7uLJVeYyASAT78U1ZJHSV3LRxIeefleqMpS ex//1PA7e4Z94BPy9scAVYFqH/0hrmNAv/LI53V/0EH/ADLkcsgYBcAc/KwPWp7e4WEFZVGc8SHo vWgC5FfSWy3axJBOsgEcheMOyDhvlJ6Hoc1RWVX3xqvl7+TjjmgTdlcRGiVBbNGpLNl5HXJPpz/n rTnUJJHbxHMLKTIwGFUDsPz/AENAJp7H/9Xw8RwqWUEhAcKSOQPeql3YqZRLbzHywB50cmNzH1H5 f561/wBBB/zLjzZzOp8oOFY8L97aPSn2mkPC0lxLKsaKu35uXkbsB+ufSgBzxSqyv5W+Ldt49fU1 cuWubrnzzL5USwxM/wB1VVdqqB7DFOKu7CutinFHHBEVuF84zjEylcx/hmrKmDZ5kajaDjA4Aoas 7Gc9z//W8VZhGuDkbvmDAflSJFJMQQ3DYzx6Gv8AoIP+Y8W4LmVFVyu3grnrUgEqPh+Cw53Hg1rB 7IDPA/0krgDccDPA+pq1GGO4kqxUk7QB/OrAIlaRpHkcbVPyhRhh9f1qYCJlZcn/AAPvQB//1/D5 Ufcqk/IvRfWmxQwvK0bSpE4QvGGB/eY7DHfnv6V/0IH/ADHl1URI5AqBnHBB4/EVHbraSGMzy7ds u2RCQCRxgD36/lQTKXKabRwMCiJlc/Kp5NUL6yj2K4JDpymOFB9x/Sgd7q6KSzbCWweeDgYz+FXF kDYPl8gc570BfS5//9Dw6YvISFACNwB3FTxRJHCM5aXOGJAxj/Oa/wChA/5iZO4/ymIBToB07UyN mh35JYu2BxytBIr7opsHBzzuHerQuWCxqyhlUYXjkcmgCrJYq0puInZGAJ2lsL9MVNGPlU7yWBwc 8igD/9Hx2PZNOUlcxop5YKTn2FMkEQeURHG04XcMFhmv+hA/5hyxDM6Df91s9R8oqpeI8v75X24O GzyPwoAasJCCQscDnr1NTK6sjTNxKuFQMOvbP4U1owGWckoeUAlShyT0/CkF2JZGQoQwOCMcValF y2Gm1sf/0vEZ/kO/YXfdt7AAZ5q1GkTICXAKH7nb8K/6GD/mLc7qyGSbnZPK4UMAMDqanm3ZSF2W MM2JDJ8qr9fTtQZmfdF0kVIyjRg7Sy8qccZH5VbUxnHztkrjB6k0ATppiKglWXZK7AOHBKhfU/4C pGjixlZVUKPmyv3sDjH6UAf/0/IIowEfJ+Y8fUVI0nlQkKCo24JPr3r/AKGD/mHK9rteSMSypErn G+XIXnpU1xAo3RpuWZTg5XKY9c0ARCJYFAXknk8dTUsvMSgyKFPzOdvzA9APagCtsRXWNJAZVG/B 4BGe1WnRDL9pkJEx7k/eoA//1PIZngMe55PMZicrggr+NU4PspU2yIciTewC9c96/wChg/5hyW4Q QuDsC4GAD2qpCVDO7Fjls7QMlqALabVLw7cCU5PHT3NKTJCrR9YyeQoyfTrRsAyJo94RTiQ/KB6V fEQgTBZjIpIkfP7uT0wMcVlKV9AP/9XyI7SC2Cdpzt6E0ttcB2KybUIHy5GcV/0IH/MOQsWeQj7u 446dautiHKJnKjkng5oJ5tbETxNIokT738X+fwrEvZWhkV5YpDCJFRwimQoCcFiB6e1Bk3d3NSKW NFwqsq7vkc8Fh247U7znRwEVpFY84GQKBqTR/9by6QrOI4o1Afdy23P51jG1cXimd0WKThcAl1+t f9CB/wAw3Mu5pvDCVCqdwT7204yfb9Kov9oWRNrARDjZtyT+NNaMlSvKxamjLBC0YZ8DYR94Gqry hcp/GvyOMZ2n6UPdljrbT4ri4h8lGdiwG1Fy7t6gVoTRiKSa1YeUpYo5PyyqBkFfb3+lID//1/Jn hiOyGyhZIwdkUQYySOTnH1JJ6CqFsl+rLEd07NN5cca8EZOMV/0IH/MObzyT26T2FxGkUiA5LfMW I5wCOPoaySHcrnK9jQANJJFvzkopHHcfWgSB8SISDjlfSgCNGlkLq/B/hFTW8MatmVst0AoMpvWx /9DyxIhETIZWeIjYI1wCp7HOKklZRbGWVtxhwEUj94/XP8ia/wChA/5fx8CRqBO2TuAbae4PSk+y w+b5pdhu+4v8K/T8KAGXcDxFCAUDruXcMbh6j24prW84VJpVI3JuRgMAgHHH5GgTkluVjPMImYkM pkEYz2Jzjj8KfbFly7HJB9OlAJp7H//R8vjuVEjsQDuXaR6jrTJMZLIqqp5JxzX/AEIH/L+QSyrF DuCh2YgDBGRzyf8APpTkvBaIrSKwDjKseh/zzQAMDeISihmfp2L090eJFURK8gGXVuPLx/8AqoAf jf8AMuFx1ANOklkwrR4BQYBxxQB//9Ly1ZJJJRsVTJjcyqvPAznH4Gq80tzK7N5YVV/uD5a/6ED/ AJgE2noVo7IiVrp5mXemBGBkDGavW9tIvzFhtkBxuHytjjj8qC1PXUhmhcSbWXIIwABgU2FQ0mxh hSpG8DJWi6LutgKqrBY8oytzuOS3qf8APrQ8UEgxsAl3ZDAdfXP+fWp5lqM//9PyL7H9ohMXnBDu yVyQSB7jvTmtjErIHLBvu7mDMB71/wBBqmran/MOXECRw+WBx03Zxg/5FRJDBIRGxAJbbvP3V+tT Jp7AQkCMmJVB28Bugb3FUJI51OCGcscKqAk/lUATRRgEb+BjoRyPrVhCW3R44U/L3DUAf//U8l+y b+RjzMUxIWiDkvz1Ff8AQQf8w46JGmBCtnb1pktgVu0ZrlVheHMiMpHlt1U/l/MUAVmCwygg70I4 I71beaNm2QRRpK0YDOy7nKg849Ov60AV45DExBwT0GKTLyu4xKIYl3mTZ+7DenX/ADmg0hJWsz// 1fDZZdzKSeM5Ei8D2rThRpkIZ/3eP4uh4r/oHbsrn/MeRo0sWfLQYBwDjBpybn3iPgqf3mTjFZXW oFaGNgUvNiywO3EmeCQO9XnRJg7BAjSjiQLjb7gVICfavspihgD5X5HZ13rKT7Y6fWmhZZFnCmNZ cEkyEIvv6flQB//W8Ujg3naQC453L3xWj5EHlKbhxtbK+WGw4x0J9q/6AD/mPK8aW8JWCF3LN85Y /dx6U+8b7PHlcdMsTx+dAFOKK3kCzl3J/jRTtLDuA3b9ainuI4/LQo23ks5b5V/z/SgC3uWWFAmC v3uO9VpwmVWNCCTiQ5/KgD//1/FI7WaRAEzlW55xxnHWrqWjqsu+4j2quRjkk+x6V/0AH/MeMtZ2 RZoQqHeNpdlyy4OeD2pJ7cj95LnYBgvuzvxxyaxn8QGcZtxZ4FDBB8q9c/nT42uWOVfYmPmAqoxi 0BPM8cCwRl95mQu4HGzBxg/z/GqjIjsWVDtUds8VpawH/9DwW0kDbpIWYK/ykkkMMcHjtV+GEGRy 78RglWHOTg4/Wv8Af7lif8x4yK7kk8tLgYkA+cdAcVYu2QrtQZBA3DOTx3HpSkkk7AU1jlRop1RU jX5o3DZYMDjOKsNBvRppJAwPzOpPzH3FZDTtsU45dhBQkhePSpLmWXy1feSrNgL6HsaC+fyP/9Hx MpBLb/OW8zaNo4wDnn9KSNTHH5TOSuMHPWv9+D/mTU+5VkghiYTR5Qg4IjOAxzySPp/OhmWSUlYt 244DY+Y0Gl09iORWIePaVPYY7VKs+IY49mWQY45P+eKAGRs025trK2PmGcj/AD/hTYWTEgZTvzhO wH1oA//S8C+YBfN8sBCSCo+9k96jjnLO8TMhVW3L8oDj8a/34P8AmZg7MtrHLM7IpaQ7SWC9QB3o s1jhu1EpKxlgkrD7yrnDdvSg2GXcEtxfRiCSNLcEAyOCVcfj0pLsDTZ1iwhYv8zIRtAwMYHvQJNP YiljFzI83n+WGQBEIzEjeuB6+3pTbfdbopmjMnmO2dnAHHBP6UDP/9P55c3ckgMTRxiH5h5gHzjP Qc0odZpZftAT96ePkwE6dMV/vwf80Kdkyzp97Lpl0zWsMdy3lmODzI1liDdsqwxU/wBmJjjnuJld /L2ThwECybRk46YJzjpjHSg2Il0/ckk6TQlY8bY8kSNn0GMce5oeRrYeXKu0OODjANA1oylLax3U Fw01wyGJc28ERK+Y24fe4xgDd3HaprCGQw5RCWHyB5OEHtzQbn//1PnovKflkj8p42PGePqPqKz5 GMuY5kfcz4EiglQPf9K/34P+a8tz2cum+XH5JOYxJH3jdSOGBHUfSq9w29V3sqOqnG0ZJPNRPYCv bRNcKiTNEpZyCWbAwOea1FSGGXzkmlkldPLiijOI1AOGL9uegFZAhlwsyhY1lDgLu2q3Cg9vrUXl jduQ4dRyB0FAH//V+dYELNvbaJM5BcYqpdu6FZZJtkY+/wADbX++B/zX+RPFNFLt+VGCHcsuCd4+ lWLyB5rq2v4bpZEuYwLmCbK/Zdg2gRjpyAp5x+lAEbKXmeS2WS8kjBMgYbZIwvBPPUe9NldSQwyv HPsaDeLurkU1zugjjCSz5lAXyU3yFicAACn3SJKLSS6tpbW4t0IVgvlSSqRjDDv0oGf/1vm6z3vL JGVLM4/dqP4AOpwPxp0yTxI85mgVYHCNGTiWXdnBT2GOa/3wP+bynsZq5+0bwSUfqD97PfvUzwPH KAAHEoxuxkpnqDSbsizRs9MkcE+ctvEDtmkLYCjvkVn2y3Mv2p/JMVvBP5McpYbbnjO5e+OvWsAF e2ugjTqpxGu5wgyv4/8A16t2tzIsEUs+YYJm27ZEykhGNw9CeefrUT2Lp7n/1/n9ru1t9kyWjzST D7PHFtGWJ4U1/Xd/wStErfCjS3lMVu50u3LxKp3OfJBbHtlj3r/Tr6V8kuAF5TR/lh9CBNcc4m3W n+R9ffthX7aV8J/EV2t28C2unb8KmdpZtufftx71/Ev48t9B1fx14mYQtJ/aOvXYS6TMLXrPO53l egPzAY9q/Ofof0ZLD4uv0tb8T9H+mpXg6mDw32uZP5WZ+UH7X+nT6f8A2lpWnXM8cqSCTS5Lhgkk kbbFkV+xYhSFI46fh+R2rrNpF5DYyyETXZLKjA4bnBOelfIfSxqf8ZTho/3X/wC2n7H9F+kqfAEG vIiHkhv9JOR0Ax396y55HW5wqbgOVAPav5ElK5/ScY8p/9D+N57qK7gjKoEZCRvC4kPqDTEur6xs 720tLyZku0CStKN+MMGHB6AMB+VaVHbQ4Yq7sXY7pXijjlBacIAxHCdO1U53SZXB8xJYQDGIFy0m D/PFcZvGN9EX7TQr540v2u3nWUFPs8nMwI6c/TjFTlVG4TI0bhcBCuCD71E9jRQS3KNuXlLrKDkt siA6cHqKp3DhsiSRnWNtix44jPc/XisJuyLsf//R/jdhvC5ZZGZ9iCJQwztA6YprT7fvwh9pyCVy R/h1rxyre62UbiWC43F0ZWK7VKDBDds1mb3RzEsoLxruK9WAPtQSXrcfaMptfIXIbGDmqUkFykst xHKgdIysZVeDkYOffmpn8IEDXUMMkUMUIURwgyLtxvlPLED05qRrnUIoFgi/dpPKJJYiMjjoP1rK zSuB/9L+KKcSNcrICWAPlvGeAvuK3bhPJii2fM4OAyAlXFeHB2TAbbozyE4CkdiR83tWXemO3uIy IC0+4rExXPIyev4Urp2QCWd7LK4in+Ql/mf/AJZIPX6e1ae5fNIeYSony+Yn3G+ntWoF4XCPIqBT gfKBjAJ7Y/SmnVJbIY2742kMXI+Y0Af/0/4t5E+0NDdSLhN+7CnBOD0FOuLwBbbJKwhjucj977AC vHNYbWLMyw3SW95bKfPjXZOm44YA5BA7U2W5eYOsStM8abzEOM8Zx7UFdS01xBaWJaK3UGbDHzv9 bGcHK+nf9BVTTriEmSW4nklDLmElRhGB+79Ooot0GVrm53XqoWMULn5ZVHPNSS211bnfHcRXcIc+ ZEqnftHvXOawaSsf/9T+LdJFVZcORG+cHGXQn3qWHz5NwyskAUbmY/vD2rwErux6BVNqlzeTW9vi LyIBNIzHO8k42gfh+ta1jfz6FLBc28AkMbco0mOmOSPQ96La2QF7XdZt9XtIGjso7S7LEzC3YvEQ SMcHp0rKFpM8aq8hQgL8p4yP8gVskkBn3FtIGkBkT7wAUD5uO4qwgd4SsTIXjXcUZtpftjNaRhdX A//V/i622cz+VJEn2uFQcKcrhu9XIdOiFqbZEAjkkMjOBlgep5ry+TU9G7tYQokO5AwRduwdsDFP tVIgdZJvPLNlc4GAOBV2QiKK8jtZGiaFmUnLuBgpxj8qp301tIkMYWSRpZgGQYKKD0LfrWdrSNKZ NFdxWAPlBTJja5K7iuf5dKsS3pWN5IWd2kAJU/wcdFFVPYco3lY//9b+N7zYbq1ZZ5XkkkhADcq+ f8iuq8LSR3OoRBTD5kAWQtKOcoQcY9wDXHhferQj5o7sa+XCzkuif5H6ufBPSdesdAvRphjCa3A0 tuZSLfzDHF5UgU5GQCvI9jX9Tv8AwR38J2GnwaLc/Z7ZdQ05bbSboQYxPLDFEcnswLAEtjJIr+2+ Pa8sP4M0oR3cYr8LH8leEGHhiPFjFSnryuTXre/+Z/Qb8fw9v8NdciZljk/se5gwTsMjPCyxgH2b Br+Cv9obVYtT+J/xKuBPao0Os/2e0cOZZ5JIjBufceFDYkGFP/LPB7V899Fek+bGT6WX5s+y+kpL 2kcHHtJ/kfjt+1Lc2Gn6dDDay6iiT6jJYNbNGGEigFlaR+vyDnjivyy8Q3CPqc7pKlzCgCpIgwQR 2r576RVVz4rhG+0Pu96R9B4P0o0uGYtLW7P/1/4Y9Ou4/LlV8l2AMZzgg10dhcSNPGj89FyeCe1T JXRop9zqEkQ38XAMkcXQngDoP8+1a88aXcsVqsW6WVchxwiexNcVVWuaDCpikELKwMfDgNgke1dZ pkkCWUAuFEO1vlkLbyBnADfp+defUVrgdFdPKyFF+VSu3cgwaxDdWaTuxmjF/aoohW5YxwuT0ye/ uK5ZL3WU3eNj/9D+SbV7fXbWKI2lw0i3UKGW3tJlcMG+b5mB6dOKzotZnk8yCK3f+0bZfubTsfty 3TqCK+Mnsd1rxsat55tsIpb2NoftmEi2/vcED5uPz60WyiB5JkDG3hf5iy7JGJzg7c9TisgirDL6 31Ka7F6t3PJc7Atql1IVhhHYewrTEFi7RpCP3hUG7JXIaT+LHt6Gk0nuUXVtdPiuImuZZreAsPtL QIHcD2B79K7/AMP2mg3U08NmLfTkuIwjSaqPnu2GMbQQeW6jHvzUw0bsPl2P/9H+NWK5kS1NpHtt 4J3Mk0ScK7uckn6n+dQ3FwLKKKwjiiieZ9qSKM+WfX2r58zpRtsZP2aMzLZZDOJCsTuBtlb7x2Ut 4sdtZRzmE7VuPIaWEgsrDIJYZ6DaQa6CXF8zSKc2tBbWH7BF9ruZZSiWwyh46HOMc9B9K05db1Cc QRafDLY3sEnl3m/Jmk77CD0xwPfFBEl7rIbeKQXIe7zJIGYkyLlSxznP0zVq80t5gsu+MwnAyZBu PrgUGB//0v4rb82tkrSWlxOyEiIKUwpI65x6VZtmF1ArFXnVyIcZwENeXT6nnmxetZ21nAZIk+3R yHyy7k4GOGA9QenPamrARBA5kBnlz5/y5Mfpg9811U9gM+90+6fy2trhgynayZ2eZn/PSuxXT5v7 G8gThI41EjAR7ldgPunvnmu+luB4lrVjb3F2PLz8pO6NXyp9ePqKyLfSL+JZLi2s5ngtpA0paJmU LnJzXo0lYtK8Gj//0/5l/wBjPUrnWNUH2Sz+0m1h82yvL3fFHpYVk3GVeu0DLcA9RxX76f8ABPo2 On/Hi31ZY4Li8m1J0nuIZmceS8cJ8qBScBvMgTHfG4dzX99cGydfwkqW/wCfcvwR/ImNpxj4yYWH /T2P5n953w3vVu/BWm3sMLxJJYeWsUpBZWQGPJA9QAfxr+ZX/gs7pdvoOuWYe3iu5pdetVglkl8q VZ7hFAdD3A8xuPqK/mPwfUoeJdCH/TxfhJH799I1JcE1pfL8GfgetncvLbanbp5dmZX+0K6Yb5Bz sOexx+YqtNcPf3V7qMttGoMItLcqmJ1RPU++Olf6XUU1Zn+aEo2RzE28iC6s1lVPMKRsW3KxHBx+ fv1qS6XUNbv9I0tIpYvLsZru7uNo8qYxtkLuPTg8/Suyxkklsf/U/NoWs1srGUR3EfmAwtJwYAAM gY/HqKoNpd9rTznT5C+VDOiEhgEAB59MDv61/tAf5FT3KM8V5CgxHNL9h4dFBlYY4xj3rfsrXWLz T4r/AOW1hu5D9njY4lCjAJ29V5zgH0rSF9jKTSVitqPh2Wxne6huPtcblUS3lQLPGcfMdozwTmq8 WqXQfyZLu4jhRRGYXGIoSufmUfj1zWhzydkbkttFYRxRS3KT3OoFbyWSOYu0aY4Q+h6ZHvUl4lpe RhobhUaKHylhZRiUA9M+vJ60HHPc/9X85rHTDLaT3l9IbWHTmCWkESh1udykhnHUAEN+XQ9Kynst VeRZrvTxDpqgyRXAly8xzwCvYEc1/tUpNKyP8aL63Lu1Zo2KQmJpWJ8tVwsYJ6DrxUI0+W1lubWQ wJ9mRbx2kIVyGAwFPfgg1sIstcXhkthDDFKcE/vj5qMvIzjkZ4/SnzXN/calBNcM0cagRiKyhSCL 5Rgbgox0FBjJ3C4vLm8e6+zWrGC0QPLPHH+8xkfLnHPXkk//AFp7XUhLZXimO2FuJA+94t00IUY2 7/ck9h0FBrF3R//W/NV3F0/mwQxwKqYkkA4YdMkfj2rSiSeKygnuAwt1LJBNMCFmweQrd8Z6Cv8A bWMm3Zn+M5Y0mzxDMbB1uJj92O4l8oKT/CGI4H50zUINXIt5JIxLIuIp0Em9Y+xwe+2rAsadfy2U jXEkKzpCwSVCuMdMD+VLDDb6vNds7yWkl0p8t1wxUk9AvTpn8qAF1DT20WCKWDUU8vcYvs7KIpZc 8gnHB/CpTGqWnmyShTcr5iIrA+ccHGPXp+hrSCRMnZH/1/gaysLN9POrLHGY1bbMJFD3EZTq7+mD 39arzXEV359zZedepMi21pdKhjhlYgExgHnK5AI/LNf7gH+L/qNvY3soYLVLeU6mXDXiKhIgXHAb I6knPtSnRzf24aZ/OVX/AH8bt8q55UKOvY/lQY83vXRnamnnC3hkikgFvJ88isySsB29Mf41tWan T42vLO1huJVj2Tea2LlYm+9tP070GcpWMfTptRg1e8OiW7hr1vPmtCDJb5Df6wtjgjnn3966C+0q Z9Wdp5Eee4TedjeZI54zj1AzRYzcm9Gf/9D893tNQX9zbzySQJNtVSeInPqo6GrNuuoad5XnSLPE 7hZ5MBRnuNo5x71/uAf4oN30NK5tkm3mzu0kgAwJIgQYyeoO6s9bDTrPUIoZL7c4VJPtkamCKQkZ KkHuvOaEr6EtpLU1r/SNLuYk8q8WwmmfNxqJLYUZ+UkDn8ueag8mfUNSn1SC5aNLe0jtRdKW23Bj QRs5BxgkLn8a2jHl3MDEktbqSRZJGMsdu+6KV0+ZueoOP88100DW0sUt9ceX/qvLCKmxp3wQCSPc ZppW0E7W1P/R+Co754rN1mjH+kJiNV6Kehx3I61QgigBbzVmuJHGUhtUzNJ7KDxkf0r/AHJW5/h9 N7suSILfR7G+sJdXgvEdkuEvIViYHcQvCk9V5PPerv2d9Qti1jIsVzIoE73DloYz/E38zitzA0Hs vs/hmxuLK6juI0vZ4L50TbJI4Cksq9xnvXHzPfwpFZxw3D292Wa2kaP91E/3ssO+c/WgC1NBE8z3 UbGKZ4ljaCJBFbgqOWAHTPtV3TvLZ1UzFj91uOFPuaAP/9L8/wCXVZrR7m1jtUldZMhwcMRxz0qx ourLc3l1ayR+TNHH56LKCsQGcZ3+2Oa/3RTs7n+GUm02izrF3qceqXWnXcNvdWdssLCe2PmoyvGH +VvQbuenWsW4vXciNVZFLYwf4RW5nLRF6yszcW89tIGNtMDvZVxknHf8K19PtrK3siQv2izDmIqg 2n5OCM+oxQYp20M3w7LPealILZmjjW5MCqVO/Aweex/Cvorw/ZrMbWY3Uf7mULIkYIkUqc7cEYPb pnrih/C0cFZNV4eqP//T/o+/4JS3bW/gyw0+Z5WltrKO3iBXauFJH3e3HH4V+s/xejE3w98S4fy5 f7EnEWU3KWKYwa/c/FaLp+KlV/8ATxfmfmfDcvbeEWGf/UO//SWfwr/H6ONvjF8RZJZbi4W18SPC kSoEhiby0Vwvr8ynmvDXma1fzZI28t3B8sx/MwHQCv8AVXhGfNw1l8v+nNP/ANIR/hvxSuTP8dF/ 8/an/pQ19TkeaO5sm2IsXlRMcBgCcke3P8qTzlME4Zv9JlfzDN1Oec5+v9K+oPlHuxLazmSIXTyR sJN0YAI3ZA5GPowqEeanmKJnijYEPt4I7cVrBq1jKfY//9TxVZ9NggT7OZLrEQM00h+YsByOOD06 mqjCaYCVbhlEjZkjPAYHpX+/B/zbNJqzGT2F0s0ExTy4LgHYcn5iMD5fUVWzPaFkkdupBZh60GPK +wqRXVvdWcovLR7e+LxPbOpM6hNuWGR/tZBHoa0pUWUhUJA3YBHAOP8AJpXRPIm7jJkiRBsLROuR I3978PzqwNJlELSeapiKqyy5AlfcM/d9sU99jOUGtj//1fF44hHEyK/B4b0NV5LVWWR4Y1LxDJk6 Z9s1/vwf800oX3Gifz2ht1VAxGGYjOfc1SlT7LcmNiZIjgPtJAOeoH8q1jJWszOUbbGl5+mEbQk8 bwgMkrNhBxgg8c5+vaq088DlJYwTIGwdq8Ee9WQWSVkgDRSLHKTgxYwarQxTHzDcv+8ViEC5Hyj1 96AP/9bw7euwkRBmBIVl4P1/SmwQAXMLiUn5wzdArH0PtX/QAf8AM+LdRySTtG5Ekrsf3m4Mo/Ec YqoBOsbICd+MDH9M/wBaDKe5qi1Z0BkkxshBlZVO0ORnaDjn61WdIjF5QHB4bJ+8Pp+dG2w1Llii aQMlsioqFduyJSfkH0qCFot/kXMixgLlieV71rGV9GZn/9fxi1tbFGlYzABVykOOH/GqM5jGI1t1 f7TIEkdsnYOnTpiv+gg/5lyEwnzVt2QhFO0hMAjHpU6QFD5UoMgCcseh9sUAWRB5Ue9FG1zyAck+ 9NntxvyiS+XsBZsY574oInsNaEFQUBdlHzY6AVAsNwLlobm3mhi8kvFKv3XPTHt170GabWx//9D5 /HmgldrPtbn161eETzYYZVkXJUcDiv8AoIP+ZNz003JH1iK0haGa1uJnfCpLDIESLnksMEn8MUzz J2WNCGaBhuUvkt+fegTm7EMsssbDYTgHI9KdDOwOecdwOATTTtsQan2SZbcT3TxqHOVXGcL2z74q oywlCyzBY0bD88H2pBY//9HxSSN2EUcZ3iQ4XPGM9KjsEmhurmWadyCoiWA48qLbnkDHX/Cv+gg/ 5jx9woDIyvuYv8wGeBxTpQq8hnfpgHqaadmOz2IXlU5AAGehA6Gqy+fHIVUpscfPkfM2Pf8AAVpz ofKzQRFCt84DYyQeTT0eMEfLnnJ96aknoSf/0vH5grzqUTcrkgRk8j0FMRGyQsIDKdu0gbhj0r/o Q3P+Y9koUYYYwx4wawnsBHOseA0oPmiN+WwOpx7Z/Wgynua1vNMrgMoUq2EAGRj3oumlUsHkAEjf KDgLntQEZJRsypb29xG7favL3rIQPLYOu3sc/wCFWORcMxI8ojoOx70D5ly2P//T8PC2yXDPMZcB WMKxthdxHykjuM4zT45ZwnlMY2Lcs2MAemB+df8AQgf8w5JLcyLEpUZK8EAYyKcjbxG21hu+blSD +NAF1fIZ90qBgEI2528445/z0qsGjC4wSd33egI9jQBI0YZcxlwT1VjnFQOywqhHUsFYduaAP//U 8eeLcqsFAcc5Bx0qH7PIrvPINxxyFH+fev8AoQP+YccZfPVUA2Bhn0NLMI49sYO5VUBg3JPrQBPv hmSNI4xEEQIwLcEjv7fSs9iI8/8ALRA2AV5HcUASq4iVXV9277wPUfWlhVWkLxgE9/QVUV71gP/V 8VuF8ssV+bcwyPTkDinfZ/lLh9ygfKOh/Gv+hhaKx/zDj4bU3LIiSi3VQZGXBJlxjgen+RTZbC3y xnDyqMFdzEAEUARmNZcAAqpOARxtqZbZoyVzkjoaAFmmnRDl8N91c8k1Xt4Z5p1jyx39APWgD//W 8jZktpVVvmXGGboFqWW/t5ZxawIR5UYeXcd2/I7ccdDX/Qwf8wjmloiCRY522hcheMEcCpftOwhr lgqxrsDPwABwKA50RTSh1DWzKZN4AGcHB7/hTmCwAWxdPMI3SM43Y+n/ANaldDjK4xEiTAILzbvl cDKqvcfyq7Pa3TpGqtDcKoZ1iiRvOhHGd5x/I0yj/9fxOSMSTRofkIOcdmxxVvbaW7CRUdZQMMxb 5WH0r/oYP+Ycrzbp2DkHZnAAG5ifQCnuqIQsKb+hDfdK+uR+lTKVnYCSOFrj5snzd20fNjp61MJg qvBPCFYHcsmdxbHGPp1/KplLeIEqxRsizZAYHC4xmo5S9wqCOUgo/MWM7+36VmB//9DyWdJYwWA3 OE+cxjJ+tQRwrDE0sgLNwVXGetf9CB/zAuTUm0K8pYhVUhscHpTTBcEFy5ODk+9ArlqEzYKRsMMP mXOBx/k1CdwlERmihMw2hpeBn0H5CgRLNauiDG1l69uvtSHz4rfdCheIsom2rnbk4B/WgD//0fIG mKuI0YqT1YVIUaS4DzcW4ibdgfOzY4xX/Qgf8v5PFKUiZCAQTkHHTFUDmVmQkqVPBFAbDriWSGDI IZFlWIOOuW4GKrhVSXfK6jzmG9yMAk8UF85ajXyXZo5TuHI28GkETSMJ5Zcq7EeXu/eHHc0Gp//S 8ohhMQ+9w2dmTkgHjJqSOe4s5AlssLxh/MeSSFZG6erAn/8AVX/Qgf8AMOTm2mQ29xPE7w3cTSwu Tw2CVyPYMD+VVJlfc2MDC7sZwOBQA2MwTKURZ3Hl4lLDKo+RyD6cVYjigQAMCcLwenPagTaSuRBV eTao57nFV50IPTBHTsTQYt3dz//T8oilDxbEyJEk2uCOmP8A9YqSeFzcwJMUWFUDOFwxbPI5HT/6 9f8AQgf8v5ZTy03opX2LdscgfjTYxGyfO+5HUr8hxtPI60CbsrkvkKlr8rtPsXaGkfcy0kbw+Sqm fMpbBiK/dH1/pScktDFu7IpLdS4RdvzAkEkKvHueKj2YBPQHjPahNPYqGkj/1PIpY2BCx5LKMt71 NJJI1pHCybCG8xuMM2QAM/TH61/0H3tof8v5D9m3xGQ5ATnbnOfoKa6NPsikUGJem7pT8hOSQ+KG Xz/L3iGIH5X7cDOKvTRxmFiNxlPG4HgCjYiUuiGQw/uuc4IwW6Z60+4AiVISQeA6gN0zgj+lA4yv oz//1fKlj8olyFEjAbioxkdgagLyRiULnbK+9l6gYGBX/Qgf8v4qRxS20zSTkSqwVYQpLHjk56en vVayKwZM7SuN2UGSdv0ouBammWUrhiRjkY5ps7rBGrp83PKg4bmucafK7loyrOgkZY12RgDaNpbH rjv/AIVSOY4/tXl+YI5MJGCA/PU4z6UGzdkf/9byN5SVRkUoX/MfWmLudiASWAwxB6V/0EH/ADCq SehDHbeSw2OzEfJ5e4kc96tQRSLI0Tq6vndub7vsBQUQyh1nIBOQcn0qQ3DMwds7/uggYH6UAVrn dEQSSBjqelKkrrwsgcddw7UAf//X8mVpSq88nv0wKb9rj/eQG2lldl/dTiTYsZzzuXBzkV/0EH/M ORQyCCORVGCcnH94/wCTUUollG0H5HXDKfvA+x/OgCSG1UQ7pSAocKmWxz2H6UsqyxupUHB+TeBg HGMj9R+dAAsMbKJirq0TbQ4JCgn1/wA9qbHObaV189pI5M53gAsD1BHfrUTbWw07O5//0PGvKs5V aFYtilt2A21ffHpS+bLBBIIo9wjHyrnk446/hX/QDdn/ADGOS5bkUN5iMvLGRJn92qnCr2yR+FTQ TtIzB1xuPJAwKRmm1sWJ4Lhniihid1ADMiDLAdQcd/8A69SmSKcGSN5BHCojEbRGNgR1+o96DWMr 6MikO6XaRtyo2/LjGB/9aqx+VmgaPcHHMvpQNtJH/9HyeS1NvD50Es0N15OLV0O2I5IDFsdeM4/H 1qvDazPFJNK4fawXn73Q9PyP6V/0AH/MYpXdindiQSQtaI6wxo32p3HyE5GMHtwen1qYnci+bjY4 yD1DcUFkZ+UFsAAcACoI445JUkZVkEXJik+6w9x+FAm0tzS8yJ7mOZYIoVgjISKNfLiA4JyO/wB0 f563rr+zr22tZ7WKW3mWE/alkYbGbJ5A7cdRSabWhDm76H//0vGomuFkfaHVUT5m/gAPHP8AnvUk TLGyNIhmjEgMkatt3DPPPav9/ZNpaH/MXz+QreU07gbUDfMFHGB6VMbgMhtTyjYUKRnd/nisiYt3 KhVfNSBoTEGUsj7Qobaeee9RmQxIYoUwXBALjoffmg2IZkcQwBlDyxR7HkAwXJ6n86WFZrdN0wVj JllwMjHofetOaySQb7H/0/BYCZHmZYTEC5C9MH3FaVvC0UUzkgiKbymVmG5icnI9Rwa/365pH/Me QTbQhxww746U23BVSzHcDwc8mldgOLkl1jPyA9+tPVlQ+W4Z0K5GOmaQDIrdI2ZXRtrKSMDBBwcf rikQSlTGw+U9MjOKAP/U8D5gc+YSSp+VR3zx0qVR86ynJL/KFB+VR9K/34P+Y8f5CtJ8suxifmDc h8fjUjJtYFSMg/hQVD4gdtxaTAVUGD7+9ZcsNxuFxbyPHskBZxyuB2Hp0oNi5E8Xkb4pxNIzlZFU E7cY5J98/pWPe/aYpPnj8lJiIomVsPMeeAOv5UAf/9X5/gRHiIkLhkQ/Lj5yQOOvv1qipkyoaLaf 4yOQPx/z0r/fg/5ly1IJGZQhwQOxwaFExkzkgL1z3oNINJak8jF/3J3KpH3x/Kqx0+WGEOkXmJAA csc47DP50Dp7FaNrh2JYCMlflUcovtW1A37jynZST8xOOAelBZ//1vBWXc6ZxhOCF43flULQMCR5 ZOW7jpX+/B/zP+RBIwgc72KbgFRcY/KlTY6SxySOyyEAhmO0fT0oNou6Fi8+ITxliFX5QqghkGO/ vVMyy3zLFB5pltplR0Zco6nrg+ooKJY1drqaJ5BEsUhTLLyMAYyKnEk1pNukn862SJiIU+6HPQ5/ Kg0U9NT/1/nWW/e4CRSqkbgl/NQEMR2BPpVa4vVhj8wBHUplcdx0zxX+/B/zXRd1c05Lq6it4EeX zbR4w0UDAO0JPPyt2B9K5yW4PnEugVC4AOc4+tJq6sMux2wklYCdEjYbiznao46D8qkZfJt5Dbyr IS2I9wxk1nKNhJWLSxyymNjCbYbAHXf5hcgctn3PaqE8E1u7NbsWYtvK7sk+3NQM/9D5wtppZJmi v1Fkwj3wxyjDz/TGfU/lVh42HmsAjRKuEEihsn6dK/3wP+a8zQ9y0zuY0VcBQqRCOMcAdBxV/wAm QW7TEs3ljLbAcdPT/PSgDP8AKknY3KsyLuBjx8px3Hv3qFrkKWgnlESTMI42MZkZTnrx2+lBpGSS SLwW2kPlQ3SOY+HVAVcEU+ALPcok03lgIUDyAlU75/TA+tBof//R+bLgx2reYQ1vdFdpcEqs0Z5D EHoecZHUfrTCvNLm6ZlgHzKV6v8AWv8AfA/5vY2toaNnbWtyrxxylJgS24gsjY6BfTpUxiXChZhJ KjESJgjy8HHNTJXRRiXgluJYx5jW+xuZCOGHT8qu+ZKfNiDloEjxbsBgM/ckenFYgUo/tYjeGRn8 orsdNxGfTFa8Nx5lqltfIJI7eLZZPtEZtz6nA+bPOe59azmrI0pfGf/S+cdMm8zULK0mVPOnvIha h0Mg+SZHz7Z24Psxr+zb/gm1pC6f8KtHSaIW9zHo9uJYo0/csyogIU+mAeK/0p+ltV5eDaNG+8vy t/mf5ifQcoc3E+NxFvhilf1/4Y9D/wCCgF08HwV15jNJDBKI4ZcHbx5m84/BcCv4n9Ru38Q2xulW XEst1cCc/JJIokkYsfQkc/jXhfRDpqPDuLm1rzr8j1fpnVZPinCUltyfjc/Jf9uHU4bjV0lt5ZBa TG2tLOWSR1mdxBGcJ9Tu/wC+K/MbVTdK8DuqyMshQSSsXljUf5Ffln0rp34vox7Qf6H9G/Rqp+z8 P6PnYwZ55o42zIDP5n7pQhcEHoT+lOt3unndpVyMBvOI2hPwr+TFJct2f0bCPVn/0/40Hj8t1mEr 7YpN7Ip2iTqOauNdRxu4ePKSAcDov1pTbabOZR7Cgxy/vIcKAMKSetIskdteAXB24hWQMnO4H+o4 rA3jHlRrR6kJLaNIppooVJliMR2yEnuQageV7iYSvO7gjlZOvHc96mSvEoz7i4kxhflbJ2HBHSq8 UTSRlSrFiSfM6qT61iXPc//U/jWsF8x5FwymJsGRhgMfarMsUoLRiQBX5LjnI9K83kiBTntUSMvG wbYct6fWseOK5uXLW7KG6NtUHcB2NTKNtgND7Vdaa7zvab4Io8kk4MjHIxt/+vUaaja3Mcklvany 2TzXUrsKP1OPxrO3QLFZobW5MF0sLRng4Y/vVbvkelXYjPcPPGkLSzIu5CyEo45HJ+tTZKNhpN7H /9X+Lw20gHEalw4EgX7w55/KpwtxEssUxBjQ745O+D/CR7f1rw4LRmih3KCzB3bD4YLhFH9ahurg hMNh5gn7vcuVLe9TytWsPkRLp1sLuFWmWELjZIqLtDHuv6960rjTTHagoLVIIWAkjEgWQqOgC5+l bESjYoXNzIdogUKoUHeoyyn2qt9nureS3Rg0nmqZEJO485yfbvQKzP/W/ixWwl2rFPO67XJiUnhc nIwOlRrazsoimXzDHJkO4AK8145tFWRtxQTWcUr4j2Qwmd/mw55HT/CsO2m8tpGSGTfK5kVlBOc9 jQUR3M0xuI4Jo2dGYDdF823Pcj0Hen3VnND/AKOkDRJF8zEDBbPOaA8iGARSTeXMzbUGI13YJPeu qsDE0bQPiNCNkcg+9np8xrnA/9f+L28sGtJFjjYeXKcAn5jkVPZ28ttJIiqWMoALNysWPSvBitUd KbWiJZRJDdfvBECSAXhIZSO2SOKguRC4lAfL4+9yM/StOX3rm0Xdale2QxwjaA/PDjk8dqimv32O 3lTK8cuCWH3wMfdFURNNtIn+2R3e2NIYo2UZLbTv6euapBHSfKjIY9cn9K2j8KLirLU//9D+LvzI olcpETKWALhdzP2/TP6VetJpLUSxzqXdwflxlF7c15zdj0LDjDvzEWhkt9oZrliROp9AOntVWaGK 0CLYieecu32hB+8iTHTGDQndXAjtxKkxe/XefMxJH93KjjGfpUMOmq1xIYR5Uc0xdRu3BeemT6UN J7msFpcvTW8McrnCjYnzNJ0bFJbWwMjM7qUKh4gvFRyvlZVtbn//0f4zHCM6vD5nn48t1c7UJHTF dh4emvbaCFbdbFNTupVtfK8zc5ZnAAXP8RB4FcuXxviqa/vI6s0tHLqs3/K/yZ+wPwtiKaDBCFv5 L9Sn9mXRYr9lRld5UEf+0zjH+77nP9bP/BIGNNa8NaZqlhAZ5J18tZpLX7LJNIjku69sqB1HpX9o eKq9l4R4ddlH8j+V/At+08TMbJ9eb8z9gv2vNSSy+E3iS8mnEWNNmtLYK+XaURko+P8AZP8AOv4L vitqmm3XiHxdfanatEz+JbuBjYRC0urzDyJHM2c4OQoJwevSsfotU3HB4qp00PoPpFVFKrh6XXmP xq/acvZ7rWND0ibUppJY9OuZjpzISiHzcc/XIbP+1X55a9pRtb9ooQEidd7p1wSf/rV+ceP9Xm41 qxve0Uj7fwnhbhWk+5//0v4VLS3lilzIrLgZUsCFbHpXY2yyvDNcusUZUfu8HYwHsDUydolxXvWZ v6dDGVXzZGkeT7jE7jn6/wCelbkcV7DdwNxGvVQud5HIzmuGrpc1NuK2hZ/N8wOxyG7kEda6XRvs OpWcsUCYlR2hm8xfvkHjbXnVHuAtu00ZkiZ2R4RgxSZPGccVoWulWF0sgurSC4nnIIlnXcFx6Z4F cs3ZWGld2P/T/kfW/ns7j7HHauUEX+tHMeeg/pVG2a+k1DznCAuwBiiwhOP8/jXxc0egbkl7d3t2 sDSRgQ4WWN0BaIdseh4qa90rULpY5rU3Drp5MzLaxrh93HznHPsCazBK+iJ1f7REqTR3AkBGXZTu 3D0PetQWtmIr6S0uE+0w26zG2kdYpZH9EB69+lBryK3mIkEt1pMl2QscssZijhnTbIki/wBMgc1X trDVp57Oe7umZbK3CRAHjufz/lUR+Jlculj/1P43ITbXUEkcUTK8ZwS64ZSO34dayX0hLaK7vZjO 2+XcJ5yVGOgwOgHFeDH4kRTY429naw2lzDcs0lvJ9qeC4ywhY5ywbOMHPTqBgVL4vuQNLVjaGX7Q h2x26bFugTyMjGPw6VsVZJ3C4lsXttMht7aOzuorNI5YI49sYwMqQfU5PWmxb4JZGchp3IYPj943 1oM5RsJPqkmwIEiYKT95chm6HP5VUjLKioN0sryh2WM4VAT79MCgz5Y7WP/V/ix1WxdGZNymITbi Y23JuPGSRwfTNVdO+0adPKt5tSLbvtPLO5mJHU9MZryoPWxxygkro6GKKfULZNRntUjltW5gkZXI 5+UceuB0q02oxzRTPc2CW97bj/Q4lBjDnpgk+vrXZT6GZH9hmJt7y5lMTpJ5qqrYjTg/e7HGf0q/ DrN3Z+ZHbvFcrK2JYpHxHtA5ZeOT7V3UtyYyVjyvVbZ31G6bToZLaAuZEadxtDfxfTmsq28TeJrW SWwXWLryrlvKltt4NvKuR8uPy616UUrK5dObjFs//9b+ZP8AY+nuoNdhlgnfT5PtUcEFxJHugvzK q74sYIZWyUIxjmv3B/ZDuXtfi74U1JVawsdP1tbZ4fLMBubmZo/KkTjLhQHJ/Hqc1/fnhlJVfDCc HtyyP5Bztul4xYSa/wCfkPzR/ev+z3qX9qfDDwtdT3KTT/YNt4oGcOigAN9QP1r8Bv8Agtbp4EGl 6heC2t5Ge0kuLu4tPtMls6S71eNT91gIQARzjNfzJ4Zv6v4r0YLb2rX4n9EfSApurwBWnL+VM/nL 1PVln8yy0/8AeRWUCzqtm+1LhpRubI9QBjb04FczZaoZZWtVna28xWEitwSQhwP6cetf6XUdkf5o 1bKFiK0027sLa0Dahb3ltIrTK0YcRwBsko2R973XIOKz4ZmtLia9vLuSy+0WXlQxzysiqXYEop6A kE5+ldlPc4z/1/zc0b7JNPNby3NqIrvFtbLK7BE7lzj8en5Gtq1ht/DmqTBJZVs0tJftN1YsWglB X7gLDPJx29fav9oY7o/yKnvoc7Br2mT6UJrfT7y1ljiJdr28+0S3ZBOWI28Z7ZJp5k1aG3tJ5obm yhuFF1ClwhRXHUFD0I6cit7djlbu7oil1m7nubZoXSOWGYSTO/JKrzxzwScVJfvDqF407yeXLIjA 3BGFyw5yo/zzQZSi3qjHs7G8ubG4vRI+bO8+yJEXP2mb5Sd2Ou3pWhbLBZbLebLSkeaF6qu7uf1/ EUGMo3P/0PzcXUbmKVEVQ0Mjhbgu/RQOCB044p8d9eajqrK9zLJZmJQkAIwxjG1Bj6Ee/Wv9rYpO J/jU4Poa6T3ekXT3E8MOIEINvcxAqdwwNwP1rnw8gllkvInSSaMP85JGxssMH057VYnBpGtp81xH Ks9ukPliEwyO0anIIxjBH6/rQ8dyXk8pcmQ7UUj17iteVcphKNjJA1CO4fTk2o0h8p1ilDFz/d4O MfnVudH0mNLZ443SQ75Qg5XPr2PNZWtoEE73P//R/NxoXuo4nswM7/Lly2xAvHb1rZS2k+wRWBjI tU3MWdztMmQcqDx0x/3yK/2zgtT/ABnESzW0ilnEsj/IMRsojQ4Hbvz6mtOC6lxG1zD9kjkXd5Uv ARMcMD6cda1ArX1wJnt7KwJa2mbN95I3qWyQjcdhkZz61iNJ9iERDiQRTBXuEUgDJxnHp1NAWNvx baNc3Gnpo6JdQLHGbma5lCb2bBYovt/TvXOajCba5/s2SSFrnSrj7THNHkpHkZKK5AyDjGPXPrTT szKe5//S/Pvw/qDTWMy21xEkF7G0RKfcct97cOx/Wq080UOlRWkUTefazSbIYwI4ZCxHz59eMfQD 61/uAf4uNNyJkuWt9PiubmSOBnl27XcNNOzcAZ69ePzqI2kk9rEl0wE1xc+fHFbOfO2xSBlLY6ZK 9PY0GVraG7qE02tTvebERCpU5HTaNuO3TH61gRXMkMbSSreRyCLyEuEiHkXZxhgh3AgYIHOevegx l8TN2z1JLOxl8sS/6SoilZE2onchj1ycVR0u2vJNUOo29wyXKK0kJLkttQFiB7YHTvQSf//T/Pm3 lvTNLZyXC3EUt99vu34WSYx7iBv68Z59cV00awQIDLJFcfbn/cLI6nacfdHp071/uAf4n2KdtqUG ovPZCFobdYmRDCgjmLcjg/XHNZ/9l3NpNapPvc275aSdd7MM5GfXgd6DKbd7G9qEOn/Y5Rb3Mguf KPM4CRg9vXiq88kg0yOygcl1RWnO3CuParjLuQY66zfxSWumrb28thEjSvIzbJjITwM+mM1Wmnu5 WCuy4Ll38tMKo/u9fwzVw+Eie1j/1Pz7s7OK8vlluL+CxtUhKW010HO8MQSMBTjp/wDXrYnkhiuk g0eWO8ntmD/aIVKjOP7xAr/chaH+HU3rYjki1aMstz5tyJH3zDzMxx5z69+3GaoO91Cj2/8AqVdi QMc88c/4V0GXPE2dPnmghWO2kQeTmUJMA8ee+FOR27imQG91OdhJN55jkJy2EVSewA4H4UEufYhe 0nNzcWrReSsMRmluWIES+2c9+PzqZBHHDFbwKPmcM7rxub1z6c/rQLnkf//V+F2srX7RctDIzXsE f+nW2M5Q9DnGPXof5VTiSe18uSPyikkpJymGiHHUkc9O35ev+6B/he31ZeS+gea1htpI3lu3aKdh lQuOnPcH2rK1GAxXjO8YjG7btPVscZ/HGa6DOb6Fy31zUIQsR8g2MbBvKS2VZzgYxv61fi1aNrL7 MLVIXLtPIi8YVjwxHr/jQZlvR7gWVxE4KLAAXwqjcd3X617v4dS1juIm3Sfa4VW/sopEMZfcFdJG Q9QQRgehpPZnBiXarF+aP//W/og/4JO6/LrPh+2vbiBYswKFCKVFxgj5lU8jnP4g1+0Hj+JZ/B2v xbQXl0aeKHdwquY2AJP51+8eMtP2XijVX99fmflnAtb6z4QYWp3ov/0k/hQ/aau/svxl8caSHt1u 49SeZ0gAFuQTvZ2foSdwx7CvCGtWubRbp18xI3wgDfTPH41/qVwWv+MUy63/AD5p/jFH+H/F7f8A rJjk/wDn7U/CTKiQ2ThpLhQIIIWSOCGXyAG7O/ByB6cVh20F7LPcI6pFBCNySFseaCAcp69R0r64 +OlLoXbe3k3MFBZuWOWwBj6ml88PmMgAE/Ox4xTjuZt23P/X8Vm0tbNVhiRN7Issm1gy5ZQwOenQ imJILaOQzRCQMm1RnGfoa/31lJrRH/NuN003JvbG92zOdPY+QzKLm3QEhvmVgR1GefWotTvLyWZT cpC/2uUszRwJAuBnJUAcfQVm2+oEbRlWgkk2kRgm3UjBUHg4P4Gte3a6t5IJo5PIRJBNMqwpI7r3 HzA/5FTezsUo3TZnkTuTNLtlUSZAAwzj37Vchn8xnkm4UjbGBwiHI4PtVJ2dzGaZ/9DzaHSWuWJ+ 0WltE6gkyylVc9RtGCT+VY/lPFFcQR7xGZA0jEHadoxx+df743d7n/NbJe6U7aFbdpbpSryRr+4R +hPQ8e1R3DRywonlfvRu86XdnOemB2xg/nWyd1c5J3vYhWJFhijbdIAmCx5/EmoWMSArGMAN161a k0QQl5J3xHC8RjxvlZgVk9wO341ZjErSpGr5YjJGMl6pT7gf/9HxG2ndjLGY49qDahC/OPXmmzRE wMgLfNztXjH4/hX+/wCj/mf8iCBPNG0bt0Y4Y+3FTmI5MwYsy4UqePai6AvGSTy2hUhimXdByFGO TWXGIpJJAGOUXPsKZMl7pO0ktxDADny4SQq7dvIPJ+vFOdVZPLkRUbG8FhiQgD+XtQYn/9LxBbQx KkjgASsApJ+YYzx+NWA0CPvkUsy/Ku05UH1P5V/0B87P+Zclt4Hln82MoBGN7mToAO9ZatK0rtLw m/l1OUpc0gJJJ3hBwTtHC8ZqeO5nljCZ3KF+UHg+uBTU31Jkrolj8lZI0Mrx+dHuKhcMv+eKJFl2 lFlJIH3zg1fNpcytuj//0/E0eVN0PlRNwcuf9b7YqnPLLbtA0yn98hJ8olliIOMMfU44r/oHTT2P +ZPk003FaFZyh3EK3JwtXVjWCBUDNkDCBskjHrTIaskVmMjYDLlScE4wBU09q7RTJbOhhBB3khZP Tjv+VAgtlkitWgaeWWLG1BI24qR1ANTWEEbcSx5jBPyAdx0/XrR5GkFrc//U8fuI98mRkFRtAUAA 9v6VVSAxwuzpsctwA24d85P5cV/0EH/Mi272JdmYQuzDHow4JqSFWtZMSLuYDMRIyM446+lZ1Ohc d2Vra3mZEe6WNJuQqQ/MjjJwTnkHoMVO1sfMDFQMdDVrYU9BHVklZNikbA+7IPX2/Go423P8qnnr 8uMUU5XldkOySP/V8elgRyDuYFOgDYqzbgRHfncc45OSK/6ClKzt6H/MZN20JZzFueUnBC5QDue1 ZyGViZZ38xydxYLt/Crc0noZEv2qJznyViITopLZIz3NRfaQ6LDIUAmlCq5QFlPPftVgRnbC/lOS 5JwrA8VJ5UT5TcGbGSlAH//W8TuLb5coD5g+7x0/zimIkKoTLLscdBjqa/6ED/mHLcRjeIvsZnVs EY4A45/z6Vct41bjcnPTJC7aAGTrsJXZvz3XkVRkmGYo0XDKcOxP17UAW1YjgLyOpx1p8oVQJGjD jqY26HFAH//X8fh824LrKPshj+ZGPzq/t/8Ar4q1LN5B2q4O9CuCM5yMV/0IH/MOUBEoAZsjJ4PS q8xg8wRIWkm+/tU5IA6n/PpQBPAsE7GGSTyiYzsHIMhHYUSbbWPZGgaIcYYDdnvTitQB41ZANmN3 OBwcGpY5oLLNusceZ1DKXyZVweQO3PfPpW9gP//Q8gmZJX8yGLYjfJsJLYI6/wCfellgubOTyp4n idlDBJVKHBHBxX/Qwf8AMOJFJKjopjAYE/OnzKR25/KnTgN99vlzk84xSTT2AaZozlYUwq4HHP40 6ORGcFm27eQD3pgPKrcSO8uFCnCqOBjt/KoZA8UimDcGBwNvUVm379jOUt0f/9HxvyJNvm58xi3K k5PXqatRpZsJd6yJckAJImAo9QR3/A1/0LvZn/L+R2rBmlCM0mHIdjzg+lE9ubglcDAPHFZcztYC WG1hRgCN0ig/MRyPWpGty+XY5WMcZ/l/n1qQGKoNuZICROj7nJPAXj5cevWqi3rS+YjBlZGADAYy KtTa3LU2tD//0vKvssU6xyIzrNHy6YGxx9aqXGwHy3jbcVOG6Cv+hPnZ/wAwcZN6MZaKBFI8rBth xGoBLn3/AM+tXPKCqshUAsN3UMevf06dDUvc0K+UjYFNyO/L5HA7DFLM6bQSS83Td6CkKTsit58q sv7k7AOTjhfetD7QYokiCRqpbeG8oCQf8Cxn8M0Ec+nmf//T8r8zIZkPJGDk9RQs8bqI5AoY/wAI 5HH+f1r/AKED/l/I/MW3njWVA8Qk5CdSPrVq6VWIEBOxhuK45Q5PH6frQBSSOdG/dgBR94k4A69K SVPMQysVBQjhuvpxQA4yxoIYpJNxddwwc47c1NdTbbaCGHejeYzXBU/JKuBsz9Dn86AP/9TxuJUc klsMp445ar+5FATOR90k9q/6ED/l/EPlxbo2bcCOCDwKrW08CTSRlSxAwCw4P40AOktyQZGOId2e T8uR0H4ZoIt5QQHRzHyQBkigCu6yr88RxkbWGOtRqrogLuAwOTg4/IUFKTSsj//V8hikHmBJN2Gj LKexOOP1xViGOcSCTcpUfwFcg/Wv+hA/5hm7IQ3Ahl/0gyFUTaoU5Ud+n501pJHjfytskcp+UsoD 4+tBlzMhiDQEpGWVW/1q5zuOf8/lUsqkqo8xlLNzgc4oJHLsidFMgGSMueg+tWJfm2MrRyL95gBy vXA//VQB/9byaRhczLbRBrdWjYzXAXuBximxRSRsqlywAxl+c1/0IH/L9fWxdSHzVcR4yxwx6YxT EUrmHI+RtuVOVOP/ANVJq6sYttsrlRE0hjdkMhywySuenSnQxyyBUfaGRiyuBgkHHX8v51i072EW ZcBFiOTIp4PQU5IvMHznG0jAz3H/AOqqjF3DY//X85upSNpVFyF+baMFsd6oNJu3SMjSsBkRrwfa v+g5rVH/AC8uTasWRIvyvtMaheY255qCVCW8z7qZoa95EjpbqQ2klqiRlXcSeb5Y84bQRgN1A56U WTBTtumYRt1IXJWhr3WgLBZmj8tABHv/ANYBzihLW2eX98ZiijKbG2sT29aiL0aGnZ3P/9DyOZyl w0AfBZS2G9B71oJHH5fzjG4feP5da/6C4ytoz/l/KbKiuY48kHgEDrSpbl1IIGU4Jx1qAHRpFEjq yZkBwDximtb+ejKoJkH3Y/73WgByhYwEdNnAA9DUj26sFeJwSvO09KB30sf/0fLfJZIX3FPPjXey E4G0/dA/z/Km2sEbHBkjikkGQztha/6CD/mBja6I/Ia13JcIxd23xSZB3Dn0+tSxiYfvccLwNwyO /FBrdbEEkQaRiXwX4xnp+FIbRozH8+5HG4YPTHHP5UGbldNBIjMCuNx6AEDioWikXYPIbZg5kHQk dv1/Sg0W9j//0vJfJlSINnKehHIoEitEuEAdF27gOTyTz/ntX/QQf8w5EYC/MZ75I9afBE5ILHYA 2GMgyB1FAEcyuzvHuRljfIK/dOO/6VPZxzTzbVZCYwZD5jqq/L16mgCsyyiVwoLKBlwAdo7Ussay SRL5QwBh3HJX/wDX/SpcktAP/9Pxm4txG+IienHYUyNrpEkLRbk+7leTk8V/0BuSasf8w5E0Eq+S txG1vIOXXIbNWYJCZ1hdQit92VjhV9z+tQAs6PvJSXeMYyuRke35VPBITEeMBeM96A2KrzYIiiTM gf58c7fTNWdpI2ZxKwySf4aAP//U8ltrqSJSs7efiPyV3cBPcDtUauwLEAgZz1r/AKAD/mHGfahD lJYfOif/AFkbcxt9adcQo5gyiwqyhoo1OAoH48UGylEzzA5uC8Z+50jPK9+1LiVpi7KF2tzjC/pQ RN62LKur5RlLAHtwRSS3Dx7II48DHzEcZ9qCLH//1fGAJrpG3BlZRt+oHAzUUK+UrREliW3En+DH Yfzr/oAP+YctSBViJyCQM7s8ioLT50Lsykbtu05Dj3qVBWswWhNMsqyebIS0COI4yOgB68/XPFOn QNgocKvzbj1/GlyIrml3IvMGw4w6qcBh0P8AnFOWG6uFdy0ItgoDKeJAc8Ee3SqcU1YSdj//1vGn jOCEOMDANNjt9q7ZCWIOd4OAcE4Ar/fxw7H/ADHKSZXkAYnj5DxnPpQ0cgKfJiELt2qcMT6mszOU uiFVUXORyPWrUYCBXk2+49KCobCPOrN6DpVKSeVDISw2I37sYJZ/fp7UFn//1/EEn83/AJZjeepZ cn8D+NKy7U3um0n7ue9f78H/ADHlYI8rO7bY44o9wYttZuccfpTt0xkCJtCBc5PLHp/hQOLsx0Tv uZXKjPBB7ipGiSOXaZUdCuRGMhf1xQb7EcEQcyKTHEivhVUgM3uR+dR3DBZYRKrzsG2RsE37Dg4J Pb60AnfY/9DwyAoJ5fORjuGFZTtwfU/rTGhXLruwHPrX+/B/zLkMimGQbVLMDtJHQVPv4aR8emFG BQN7IYYmUF2kj2soZADlxzUE/wBreMiKVRE6YbHJ6/8A1qCoO2gWcQaFxJIpli42jNWJbQxW8Vx5 i7JHZTg/dK4yp9+c4oNT/9HwxYmnhjkieEbjtKM/71fcj0qNf7RN20TTC8QY2pFGMQKoxuJxk9Op r/fg/wCZ8hnEeWa4DtsGVKDcSferirYS28XlAyvIVkVwdqAY5BXGQwIHftSur2KjLlBpVUwRCAD9 7++l5O9eOOv1596eNsVy5iVUj3YRkQLkDvjtRe2hopplGY2MNzctJHI5mhw0y5VS3QflVWKS0YPF bQShYYljDTy7gSBksPr05/WlF3Kunsf/0vme6OCrqACg59fyqa2ntZIHl+yLM7RiNZQn+rA7gV/v wf8ANTGXKzTXHlKZiDtQBVIxwOnFUFto5GkMfIY5ZTyB/h0rKTu7GnNFD0jVrVnUL98oqkYZiOoF O0q5sxKVktN80Y4EqnaM9/rwaltvcd1a5o6jsBg8qRQ0mQ8YyDEQTwfr7VmsUhOZGGR945pAmnsf /9P53vZruO2hms0jkLPsmee3WUIP4cN1GfbFSzMZUVgNgwC69ie+B2r/AHwP+a8Sbz2tUitrnchY eZbAnKnPcdOcdqhjvns42VWUgnEgYBv50AMnv28seVatIxyAykBFz0z/APW9quaZo6X7wpe3dlp8 0rDy1vFfK7wCCGVTx0oAoxNIokt3jhVreQxJPGATcgfxHA71V8tvNecyFiTlkx9znGfxJ/Wg2g7o /9T5jlt5o7yPUVZ5rkRiEQTfvIVXpu2nuB/IVZmjnuryCFlO2WPIYDAO3Axiv98D/m4Ta2Gxia2v ZUjQQmB8FOueKfcZuHYb5FmfjbCdrHrx+PSolLoioPWzL2oRvd2mnCS6hW2trQqgCgbDkkh8DO4k d/Udqy4dscKxI6lUPyAnnn3rI1Lc1tHLsUXKMiKHmMOfMj6HH+NQPHkthmZD93cMGspvWxdPSR// 1fAvC9v5viLSI0hknuZLoWkckf3YVf5XP1xkY61/at/wTy89fgvpMd5FiaFgjsx+bIAVR69Oa/0a +l81/qxhovu/0P8ANT6C0Zf2pmLWzsn8lcof8FG9RS3+CmuQSBZJAFaFSNqofLkJz+BFfxaam1rF JPaQ285t5ryT7NAbpkSFZZHJUAcbSWJx71l9EmH/ABjGJf8AeRl9Mqov9b8JG2vKfjp+11PcwarB FbC3KtqL+al2pklt4kDBRF2B561+fN7MYEmmbOA23JG5eTjmvxj6Vc3/AK6wj2h/kf1P9HekqfAG GXdIwI1LyK+F85n/AHaDkbe5PpV+0USSzR3Tqiu+WVjgAdhX8o3uj+gUrKx//9b+PjVfDtzbWMGp F4lspiVQA7pZNvUgdcD6VxckgbMe7f5uQrY+VB06+tRPaxlBe8XrGMRwohcssfyAn72R6/571aur dp03blWeNdsbtnaB6GsjUyLC6ke5KuQoh4THIlxx+X+NbsccU0sszSOnmKB5O4YUrkZA7Z71nKXR AQ3fmsI0eTzI4R8ueAB6VHabHS4QSCPysPtDfM+TjAFZjd9mf//X/jcSSGOQxRuTJKoOxhynHP5+ 9Vrl5ijxRDc6jkd8c9K88Cl9tn/sx7dIoWeclJZefMUZwAeaZpmLWItKxVgeARii3Q1gtCWbWLaV Wglx877VVk3bsc8flUEBb50X5ecgAdBWUo2KSS2Lb2arJujyCVG854+ooiufKmMXmsAMEkEgn6/S oGf/0P4xHiljumeGaUguXdsfJ07HtVSScRuwldpFY5b6V46SWx1Rjcjhe280ypbkIzeV5ncD1xVq 4Uho4UtLaWAy+bJfSOyXKrg/IB0x36d+tAmrOxV85oDshCGAOXKLxuPTOajieeYyBYcRZI3Hg/lQ Jq6sXrOzmUkMFVgu7JOU9qr2oZ/M2yh5gzEPI21AfTPYdqBNaWR//9H+KtdYM1us8sIE6s0RiJ3G NlOMg+nvTLe5uJZWaYvgqME8A9uB7V450LzOjeJzFw7O7KOFHDVQZ1jkdFkRCifPuYL9QKDK0mmU A73KNcgCDYxj2FvndR/EPr1q/abnO6NncKPlBzzik9iVuVL+O1uLuKeO3SO5RSEKrtSM8Z9snAqK SW4jAaMggEeamc496lQs9Tc//9L+LCG/u5pty27mKNtoMnIY+wrWkutgWIrLvkX5m24APpXjnQc/ dXtxAxjjLGOQfMp55zV7To5p0XzVDEt0HJx2oN47I00CwgxbcRlycDgA1gXNwLm7SLcQsbHaE4De x9aBl1ITABIVOZR/q2HzJ9aV0zbPLKX/ANF+dI413E56gU7tbAf/0/4sIbeU4uVM4hf5035VQR1w P51pW073KSzMTKGO6Ux/MUGcZI9K8lNtq56n2Bt1mC32oy+VKN3m56CodOkexka6jlk/eJ5ZRG2h /TIrSGxCWtjT+efdM4DZyWzxzUIjEQaQFmTsg/hNUb200My2kutQeZIo381ZfLijI3Bz0A/Guils 5zKJLkNbz29qtt5QXaAV9e+aAP/U/jSgHmECVANh5foWHoa9H+HejadqPijSYWt4dsGqQX8uGAkA SQMzYznPBAPY0sqjzZjQh/ej+Zrn8vZ5NXn2hL8j9mfhXbme0s7awkjjvP7SNvCbxSsEcCxRKhLD qPvD/gJr+wv/AIJM+FV0L4aaLDDMkc2nmKWMo+YWaSGIzmM4yQWLnPYGv6/8ZKvsvDDD4d9eX8D+ Y/ACi58d4rEr+/8AifYf7fWrpoHwh1S4ZZZfIiMqhWzHPuIZ92PaPiv4WfF7Br7xvq2qW1xcXOpX Fzq1vZRuZBHNcPuiWPvhQwbHtXqfRjpqPDVeu9+a34Gn0gazfENHDdOVP5pv/M/Hr9pHxBa3Wu6V Hawku0FzBPKf3U9sWnLMEbuMFe/Ue1fCOuu8eovaXM0tyhUeXKw2uynkE4+vWvxbx0qqrxtWa6JH 6t4XwdPhSjFn/9X+GVJ5fISByZViH7lnO50Hfmuqt5Ib6BBLFiUAKQuQGwBzxUT2Lh8Ru2Gm6hbu LiMxiIHbBFIATyOSP88VeOoOk0Sv/rUYq+7oo6V59RmpqWRW5uArGS2j+/5sWDuPcfX/ABrvNOig tJLSXT96TKchXwWlkJPQY5z6V589gKniC1vXvRqz3qy/bk2zW0KiIQshPUADqPT0rXt90NvHIyM6 gAbieFrmmjflS2P/1v5JdNnlhF356CVJ3EiEjc9uq9Ap9+M5pl0bS6YpBOYJQCN8Y/e7scY/z2r4 5q+jPQMv7LdPK7K0kRC/v7oDE0pHQ49q6nSr+5igaBp/PKJmRguwzEew4z7VDh2Gm4m3o+t6Vq10 2lveR2vkW7SyeVH5kgIycH0JPFcjqBZbj+0I1NzJZOwaIqVVR0J/D1qOVmzdlc6S4vo3tbLyyXV1 3Zjb5UDcnPv/AI0601q0gYQX8rW8TOFFwQz+WDgAkDpSUdbId7I//9f+MmfXZLQQSX1kIIr0KiSR tu2OoG4sBzj/ABrcPiO31u0eMyJ5cZXMbWx8oqny4HAHbr714e0zKm07khttPYST26mMXUflxoRw nHoelc3K1nPJDJJePdx2shspIo42PlMp+YDsDVQ1uak5vLe2dI9pl+YMRgZC9h9fap5XmgSQyWMt zc3bL9kkgIVLZDzvkU54wMZHQ0J62In8Jkx2VxHNA7Wyyq7sXUOMRdctVq4ngjl8pSoaVCgyuN/r iqMj/9D+LWXVU06ye0trRrq5kbyhGi7xEpPL+uc9qaLK4uokWeV2CLje6hHA7jtivJh8RztaWO10 WO1mZgXWCSG3URRD5luiDgliT2GTWVq4ury/Z2jVVhUKkYwUbGMN09hxXdSV7HPboIJJiqJeeWYw P3uPu/l74q/JpNxLAuqWtjFJCoPltIwhjfAzt9eenFd9FamThZHnGpyXsUFzvt4numjOYgWjhUnp hz1IrzNYNQg1GznvIlj86VZEjkcIpUEc5P8AWvRCnH3Gj//R/lw/ZJ8QXmj65aOEi1ae0vcw2tw+ ILWOdQjhMDO5Q7Ojc/MQK/cT4GXV1ZeLdDk0WS5mkbxPYSRTNtJsnW8gDEr3BV3BHo1f3x4SN1fD irT7KX5H8hcXRWH8VMHV71I/mj+9D9lK5j1L4X6ReQFdt7bRzzh08tkfoSB2UjkV+UP/AAWh0mWb wl/by6XbarDCIbSOxmiE8VxsuF8yVh/sBwfbiv5a4QawvinQvKyVa1+yva9/Lc/pjxuh9Y8PK7td +zi/yP5b7jTbaK+1Foo0hWR2kiiTlcZ4RT6DOOfSuBvrDz9Ta0is1adLf7YpQkyJsPUj3/pX+nlB aI/y6xM7aI0LG7Nxo6mUytLHOYhZyQlAWyQdpPU8egrlLoahq149tNpweDKQ2VoW82W4YdMAep6C uyC1OZys7H//0vzcuLOy027083tuun3KR5t4kX7zgcZUng5GCOPpVtrlbiBbTUnh8yWc/ZvswIu5 wf4CnI/Sv9oUm3ZH+Q7eupRurWXQ9STGlvPJNGv2WzkiSVJA3y8o3U/rmp7xbr7WdPv7a8jtTEgs 5fLYiIsSSoH8IHXt1rWKauc5mW1hp/8AaDwTXUjziHYJypCH0BX8+a1ra00+IXK3xkHkDMJxtEp7 fhVCbSWomjRXbxyaq9jLFp6Xxs2EOJy4/h+mcg1o3kNvOPKE0ce5xvGzMsY659u3emot7GB//9P8 5LW3toL6SzeZLkY8pZjg20g9eauXnhQRaZZ3lhcs1ybxkSS2PmIu0YKlQffp7V/taoySsj/HF26G a0Fzb7Y/EM4mtyxSaW6j+yglzgZ546jvSak9ndzXTRtcJoli9tbm8B2ngoGUH0OG/A+1WTbQ6m7f So7x4bLyY7BcLH5bmQOMYzk8ke9YLX+nwyI80kqzxoyQhG3PJk5IC5HYD8qd3sc7XRjLG50Ob7Fq NtI++SQzKDGY5gc4JYHqPxrT1vUbMmFjDI8BkClGULI4I7nnHT3xSHGPRH//1Pzttr2z8ud4EW1t raEySM4DBnC/MT+VZuo6ms82im2e7P8Ao8puV8zy7e4yw2sq+y46jqTX+2UXZ6n+NMlZ2Oq8PpE9 g51Cd5REWKFxvJGc4P0H8qra39jUrDaG6l3rthVxkIg6KfxzVRk27MTVtxsOk39nbw3UQurWVuC2 0qeQeB9RVR9FmS0aW4jnizJhXeIojg/3apSvKxVkoEa27316jWFxcp5W2FllYIo2qCzHjAGcnjt3 zzV+8idof7PeG3nuBOZvtSJuunBGNpbqV4zg96o557n/1fz20ya3tcwXihId/WKMBlbke3JOM96u 2b2cd+41GNvKOUh2vt4bnnjrz271/t+ndXR/i6pXbRRLRPcHFkY7OG+U29zekGVNpIyMDBz16elF 5b7tVtHsr4wzxSGWFg+wzKvLEL1xTMnuayXggt7+Pes2psnnW8fmr5TDJDlu+70HGaJJ5E0oXOuO pWzkLWVqkeZtjjJ4HTkHOfUUHPJ3ZXmurR7eW3tJmWynjDx3UZ2yqSMkYPf+HPtTLV55/M8iNJPL TYkjEqFIHTjjnvQEbN6n/9b4CtFfUNStba9It4LeNfPuIIQijGMrwBksc8mrutnTBqBstJmDQQMv loEK4JHIA68Gv9wD/FdpPRjrC+0+1e58seZeQNsdSu3acZ+Y+vTitmO7j1CzuJ76ZYHYkIwyzw4+ 6T659KDmcU9GckFTVJGimkaK3Y+TNKvyuB0JX6VupaabptvFb2+rG7cW73DtcJt+zwx/L8zY6nIG Mc5pxV3ZmLVjLk09SsN7DOk8N2C8UqEFVXOCP0qXTr2w029uJb1JblJbfyraFCE2S7h8xz1GM8fS tYqyE0noz//X+Hr2906dUuJYXZo4yIk8vaiAnJz69PejTmjWxngsky924lM8iYmt/wDZBxn8Pev9 yD/DuorMrR+aWmMtzO0kZ2eWclMDPIqFLRpbm3uLqYxWySFuU3StgenpmtIuy1OeSiloNvD5D/ar ZfNQzCFFJycnA6fjTUYQLK6EoZDmUIdpB/yK0IfkUBNDciXTpBcrth8/zy5SIDPILH7x46e9arGB IofKk/hwgxyQKCW0kf/Q+DdokT+0bFp99yv2a4jKlXIUgdOuCc/lW5ZafBfvZKlzPDcW7GeZWVTb SgDGGBHbrz71/ugf4UNt7kaaBYrczvFLG0auTiFvuP3yO30qtfwRrEkl0hmEbYQryQtWpsG29zLu UgSZY4FmWPy1k8yVNiPkfw+uKhkYQ7HjjeWWbMZKj5UAH8R/HpVKempN7Oxt+GTaQW0RkRpZFbYV m+YRdO/517zptpfA29/NBIYTMsUNxE++N41VQNjew4HsBTk1Zo48VFc0Wf/R/dn/AIJJNd21jbxi 8vLmFHktlhvGUTWab2wgUDJA2k8/3q/evxqgn8JavCEZjLpcoXjBHyN1/wA9a/oDx0tHxPqu321+ Z+P+FTdXwZwet/3P/tqP4f8A9tDwp/Znxn8UQvJGsl/DGxt549gYRO6NIjDkfLsGMdq+TLeKWGAp CJNwTY6qN2F9v8a/0z8OMS8VwXltaX/PuK+S91fgj/FrxGwiy/jHMMMltUk//Avef4som6ggcr5Z Luu0q/zcng8Us0s11JDGiIqwJtQKgQAfh+dfen54WrGFZbgRyM0QKnE2Mxk8fKfzqvJZ3FvO1vc2 Uw/fNH5vWLj+eeORTW5nNvY//9Lwho50mnnjkeCBFVfLlbKcdxV0QyuoFwu5cbldTmNgfQ5r/fSa P+bKG5oWNqVhZEu/siySMEYoxWbgZXjoaq3mnKGhXzjP5a8E4ymSc4HbJJ/OueUtbG9OGmpMbC1k +zxyvIjpICXjG8gY/u9+f8mugu/DdyojDs5tQg8tgNlwzNzgjFYyqJPc7qdBtMmtPDcv2TZcOsbK TjeNhXngH68UW/he+lEsflXEaKTIy+QfLkxkbs9Px96r2yWrZm8NJuyR/9PmtO8JyeXmVZchuIQv 3T7HP0rA1KxvFaUbSFB2sm3aQRxzX+9Ua0ZH/N5Xw0qcfeVjEFsQm10dSOMHvT4IY4Y5gc7nGCuO GGc81vCfY8qpDRNFCbCPJsGE7gchfaqkEayMzHgdVB6GteeJjytbkjrNKGVGWPOFk2IEUL9PXj86 kBEUkbxEr5Q+RyMHIo5lsNQd9T//1PErXMl0EiTJmb532/KO3J/z0rel0y4Qb5YXRQSoJXCsQOcH 8R+df7+xlof8zj+MyZo5YsRwQFxK/wA0gA2x49Sfr0qMRvbuzXSO1u4+aW3G7YewI/z0rFS3uzoc G0miulvAkjB7nYrt/rJCSQD+vftTljijd0jlDBs4YAgSAdxnn0/OqU30JcGjQtiDFIsx2iNCUKx4 EhzgD6+59Kj8iKYxSTFg6ElCeAc8VfOupjKDuf/V8buUaWCO3jMbbJi6yEfOMjG0fl+tLFZP9neR iAQ4R+xzj0/A1/v7zo/5mHFp2LhjEdoY4x+8fgsOWPtWVChLmCYLEAScFsK2M4P/ANalz9gaa0YS KZpQkQVnjjaRV2gZCAsxP4etWNOnMseXiiSU/OkjRhhGfp6e1HOrO40vf5SusbiV2lJllUkoyrsU n6entRPJOyRgKIiV/f4POfb/AD2ra+nKYLdn/9bxYQIircSy7S+ArDpJjtVtlgMMylS6yMuHI5U9 vpX/AEBRlys/5l9iuInXkDCp0GOTUFwZA/2mZzjoWc8CtjPeBajDLjcUdZVym3pyPWsuOIwzXLqJ Fld8SIW3R4UAArQZ2LsMckynccSDDcYRcKM/yFbdubcrjEjvsJRIU3tIelZykoSuzppwvDQ//9fz yz0jVbtv9G0rVLnKjypYNNmcyluiY29fpxzXRW3g7U5oYvt2k6hZpLIWSSeB4fuAlsj09jX++NXO 8rpSdOpiIJrRrmV0/vP+amlkGbV4qdLDVGnqmoSafboQv4UkST7Q6XS6U0W+CRIXmmlZchgNq8AE d+grGvLEhowkVxmRP3MckREzZ/2ep/ClTzPB4lXw1VTS7NP8iK+U4/BS5cZSlTb/AJk4/mjQsfDu pTaJqGrnS7qa20+4MIZYXR8gDd27ZOPofSooPDmpXmmf2zFp2oHTWkMTXRtXaOMj72SB0Hr7VnHP cq5nTeIhzbW5le/pc6pcPZwoKq8NPkaunyytbvexz1xaW6yxNEJlkRNpEm5N3/ATj07816Ro/gHV 9TsGv4NPmmXyiyiDTbiRcKOSXSMrnP41ti82wGW0frOOqKENFd/oc+XZJmWc4j6pllJ1KiTdkr2S 3v27erR//9DzXWtKn0y5e3ube5tp4ofNnSa3khCrwM/MAepH51hRE7dwDYDbcHqfev8AoAw+Io4q CrUJKUGlZp3T3P8AmSxmHq4Wq8PXi4zi2mmrNeTRaChy5kOAq56YIqos/wBh3XXlrcxgHMLA7G4x 2/Oug5C5axrG8sl1GfLMGbcI3Cs3Iz1yAKqyRKpAOCG+dCnOPStoN21Abbss1w0RGWTGcjB56Vcv rPyZIJY2EQ2Zck5LehqgP//R8ZV2l80DcoBwrHgn6VNZNHaMZbjyJQAUY3kazI2RjJGOvfjvX/Qg f8w5DDIpJ8pgyMcAr0NSyWxBVvNKknO2gCwj7y0fmqqovzE9eP8AGqkscfmF/wC7z8vGaAbtuWDM vkYRR5ijPoTjtUMkqzJGofZJtBMZ+8PqKBXR/9LyeHaAEfkgc9DVa7gG8SJJwF4HTnFf9CB/zDlS GdjiOVThTgHrntn9KkWKK2nX955u8swAB3Drxn0oAtyvBsMxhAlhmSOMDgtvO3IqKeRVZkmAj2Nt KscYOcUAXx5YiBCncBy5HUe1UmjYbLnCYD4UnByfaqcveugP/9Px5AkNypZiFlbJZclAT9ahupJb i4QXFzIqK20MfnIA6Cv+hLmaP+YcnjcoGMeSv3fXNSCJGTFwmx3ztKNnPPBI/SiLadgLAjjhhCKV 3Mcg4GfTrUclsF2FtoJIOVIIxWrajuJuyuLNDIs0kex4ygA+YYPTIP61TFyY3KTIxCenU/Ssm05X MXuf/9TyosAweBcIzZKNywqVsySb5FCsBjG0DpxyK/6F3sf8v4gDRFsfIkv3gON1LvhUBSzbsc/L jFYAJCbd33OzMinDrGQrHt15xQXiigwjbVdyqqxy3qKAIICBKd6OUbKrg7cH1NONmPMYkAKvzN24 oA//1fIwZQWWF9yFuD06VNMDMQk+UYRkpKFy2QDgH6nFf9CB/wAv602KkI8qKNGIaZVxIwGFY9zj 86nkkltypKLJCyF2K/MQeMDH50G3Oh+PNWOUIqiZNyKMAjtyPwqubaTazKQCreuCPpQZXZLbPKn3 03qhwwPf/Cku54348lgd3UNkAfz/AP1UCP/W8jiUtt2nAJ6elTzW0ZQsj8jqcV/0IH/L+V2Am8qI Ha0YwrfxH3q0Fkj+V2GNuAR3oAeQkUYjZsFuVyDk5qtFFIJsOFaL0JIzQBbkWzjVFFvmQnLSNyUA 6Af5NQzxI7xLA+5ZAFbeAnlnoefSgD//1/JXjgtM+apEg+Utxx/nFJG8LAx3LhI3OQxHB/8Ar1/0 IH/L+SOsZ2g48vse9QSWgcNLbneYU3Oo4Kjjk0AKrJLZxpKCWEhfZnp06/r9Kls1t0lMSlFaVSW3 gEKPr2oAjmO5ysWDtbGByPSqjJKZGVgDngZ/hoA//9DyBURMIfmZRgn0xV5boeWLaKyLSfe+1+f7 njy/65r/AKED/mBcmyqq7dxlZd5OAGXcijnJNWBGFVfKcSAHGV+6cdTg80EgixeYxdmYkbo/LI+U +jfkfzokEkzASKo2jgqoXigCjcxp8pjVzwFOTnn1qVN0cShjj1yOtAH/0fKI0BR3jmCkqefSrMTw kxx/ecDG44y3vX/Qgf8AL/YtEbDkcKTg1BG32WYugU5lEgDxiRARxyDwRxyDwfeok7Kxg1Zj7kC4 8yZwhnaYsfIhWCAg56IoAHbgDHtVOTz4Yw0ZXmTaQeGx9KyWgiWVXk8s7gDgEnGM4qUyQxsXkYRq uAWPCirU7aMD/9LzKfLcxkY7E/xVXDpEVQMokdvu/wAR/wA/0r/oN50f8u5YuIQ0e12bG4HMbFF4 zj6/jSIDKPJkkyVX5c5zgUSlZoCp9mMT8OW7AZ+X8qsSr8oTqM84HK0nPSyAmQqYBGGKiLg4+83X nFPmdIzA8J3sFBcFeh7gj8KILdAf/9Py+aJHBd2Eak7ix4A9s019rwC3JBizuX/9fofSv+gzlSuf 8vUHrYidViWNlkUL90ryGz2qJWIkzHK3ynJK5ANZmo9mJPU5PIPanLNuVlxtmX5VIHBoAImuZXtd 7KDApV96Blfv36f/AF6SScWN0Pl85P41GVz64oA//9TzNfJMU94xVVuDsWAn94pA4OPT/CqSPGW2 HqOntX/QQf8AL+JEoJlcRvtjfaXIyD34/wA9qsSzbkQ7gFA4A4x2ORQBWYf8tAd4C5IXPH+f61Kp yvnvJGkEUefLziR2yMAfT5qALTKpAkUEBhu96oPcsWREdgiFspyS2eP6UDTa2P/V8wjLND5ZY7ZW 4X6f/rqOSFYcBWL54LY+Unvj6V/0Du/Q/wCYHnkK8MggZ0eNWQD5uuM+1ZriZAFmn3oRwyDAyfWs 5N6DjKysOgJDPCoMjsDsODj8PypI7GfzNxbag688+/8A+qlzSRotUX5HVf3KPgEDcScZI5xUcA8p zuG4O2TzkdxSbu7jP//W8ludpOQMY79xWdBcTxFnXaDyNrqHBz7HNf8AQAf8w5rRRGaDzpWG5D8y t3HPI/Ks97m2uMPas0sR4Vynl9CQeKAEaXYAgQ7pm8tMDhfqaltCYAEmZSGJGw53exzQBcRbaSdS XWIKw3MeFHuTU15HHJdSz20i3MZUYliUhGAHXn60Af/X8gCou4Nncx5B4xUkaQsjCJ2dgfmHYf5x X/QAf8w5GdsfMsTSoCAyKwViPrz/ACNNeRply3YBUAXG0DgUARW4dpflUnjBAFF1avIrj5s5wWQl W6+oNADYd6lY13B8clkJXj3qRo0aUkP8/c9BQN7I/9DxreFYqXyCMEqcAUSGNU+XkgdfWv8AoAP+ YcgO1xtJ+96HpU0dqsKFi+dx4HoKAFjmVZgrBpYQcmCRj5ZbsTTGklErx+XiNhnPb8qAJEjgtytu qEeaDK7Hop/+vSXJi8iCKNHKtL+9PmbGGOQR+VJtJAf/0fIkkhj8y3Klz5Q2u/AU/wCR096pLBIZ CSWYYJGPugCv9+3K6sf8xcWktSLyQqcBv9Zuycnv2q6kgkGHQgrxnHBxUGZDLAZA8isoEYyR0J5p UiaREIw0ZUOD09D/AIUGtPawlwI4D9olhdlVdvyE4PSrCi1uESUkgxDCgn5cH2/z1NBZ/9Lxdpds rIqjaOjdqiePftEudwO4KRwFwMH8c1/vwf8AMeTvHpzxszzuLlQAsAAZJF7554psc1vJucDaF+Tl dtAFJlTzs8kK3BIwTU0sXmMhVCWB/dgfeFN26FcztYpJbz/beQx3fKI+wrSuUNtO0bFfMCjHIZRk AjkfUdKQRdmf/9P55dbz7VuSYqFVkfA+Rs8f4/nVnZMyRgZd1O1j0zgdh/nrX+/Kt1P+Zcng+0rI yTRlD9xgw5xVeUA3DxQypIijDhc5B/H/ADxRZcoE8do3kEmVi4kLENwAvGAPxzTCvyGMEjPGPSkA yGBVcRlirt/Ee9Ur6zBnVBI5jjYO2ximfx9Dg0GkJdGf/9T528wNLi13RgH5cndt+prT8l3dWMmJ JU+eVcKqfUf0Ff78H/M+QSn93tLlip69zUT3A8qKNUEQhXaXUYMhJJyfzx+FFgLiF2i2bgVB5z1F I8oA/dnO3jHXpRYCrKzXhSElIyqkOVTAaq9tYyWxRCu6LzN+5vusQeh9qLDTa2P/1fnfUYGnuTPs WNZGy4RcRjPoKIolUeVC2VHAAGAfw/Cv9+D/AJpVJNFZ1a2u1kd/NRMfu2yyfTFaP2mBnkeG2SAP ztjztHGO5zWDtfQoZBbQ7vtTM4kLYWJz8mTnBA/z1rWhhiuEkaWXyo1U7Si7jk9MD60g8jOktVsL VkbNx58olWV2/eREHJ59D6U9Ibd/Lkl2vlc/J0FBSk0rI//W8EkuikboEDJ/AuOapzPsMS7GVXiy 6tjO7Jxj2r/fA/5rk00VITC1ykZ4dD5qHqeMfn16VG8aLPIqooiGGLDnce/FAyy77RshJEcoG8ns Ac/0qFDN9qurt7qS4tLcCGCAphwgHLL+XfpmgC0biG+s4wlubIRRbonMmFViRzIMEkAAjAx29MUy dIY7Wwunnt766ZN8pt08uGMD5QpHc/Lkk9Sc+9BUXys//9f5/sdaigWbUUt918ZRBBEFCRQqqhS5 45z+uD65qpLeCZo2mYB93y4+Xk8kCv8AfA/5txLa1i04OrBQl5N50c7tls4wVznvjp7CpkeKCb95 GsgcbXyOSPUe9RKK3AV1muo/kt4Y7e2PlQuIlVn4HDY60pjsjDi8jciPLRi2dbZ1fjq205Xj7vvW RtD4UVF8ndm0R4mlUJMJZA4Y5xwcDA6cU9YbpZVGQY0kAkZRuRAf8/pUSj1RrT3P/9DyjwsiS+Jt GtMTgf21b3EElk3kMWEqEgHHdQRiv7ZP2JdMOnfCXQ8sWS7skvMOoWRHO2Mg+42fhX+hv0w52yPB w7t/1+B/nN9A6i3PNKvRNfkv8z51/wCCqF4kHwX1ePzZ45WgkuGEB2Myx2zEfN2z0H+8a/j1Sa3k 023F8k9rfQQRyNOmDI8ilS3ykEZwDxXq/RLp8vCNeT/mR8v9Meanx1hY32j/AJH4z/tkDS9S1mSy 0vVL6JoZ3ng8+MQT3GChXdycA7hnnJyeO1fBNwZMpDcB4InG2VfvggY/PpX8/wD0qpX49UV0h+p/ YP0f48vAGCl3ivyM5IhBd3L23mSwkDDyxeWcj0/+tSxbZJQAA0jnDeaMImDX8twd4n7wf//R/jou Zpp5IY5JJCIU8lUVsQvnGOOnb+dQJp0YYiUZlzvEan5fwrGUrmMHZmJPGYbghWkjTzN7cZIJ7Yq4 Eudkpe6jkw4KqRj5T6mobsjYhJQTrLGgDRKEUDoceoqWeYSPkFRPtyqLwe2cVgC0JLPcVkS5UkP9 3PYimxpBBKXjt8yglSwPJHNA27s//9L+NW3mjt97SptR33SykfP+f9K1mexjh3WytJJKfncjLY9K 88CmbWBhtHlxmU4XJCAk+vp9a5rUEaNxEv7xrdyDh+P8CKT2NYtW1ILBSZHkkWFZUXzFgk+YAngZ 9v8ACr0aSyEIPJS55Z5I3zGR2A/z3pON42LL8MDEJFPI5ERyrZxu9qpwRsupj7bGI7eWQpG0Q3sQ OASPyrNxa3Ha5//T/jW1OERebFbSMFZgAQPmI47VyOqyNC9uYUeZg+x41X5iDxXjnbDSOpq2VmxJ Y7vKBB246/WrFwJJ7p47aaMwQ43xFcSODx3PFBkZd1HcNOIoxEkUa5DiPEhJxkZ7j61NBOIZUyzL uG2VAuevTigBl5f3FswP+vgD43r8pQHpx7VVijnlk52JCAZXO/AJ/ugdyaAP/9T+MiW1tZ7eUw20 UUzwqB1Lqwx8w+uD+dZlvaqqmWe4LlgESPGAu3jn/PavHOg0mYKsUiTvCV6GMfNx2rMvbe1uYvMk 8wMUKyEjPmkk447dqAsJHBHFFHAwwzj93tblQPWmvO8LR/ZiYULhGDjcfc0AWL8DdG8DByyfOu3a Ae3Nc7ILmKYRkuBI21iMnGaAP//V/i9s99sA6HcR0yAa0zBNdQy3UccYWHmVHcRuc/3R1P4V450q LexkJB5k6SSbVKE7UGGI+tbEFlHZWcckNwzStOxlQkZjU4x/UUG6VtDN1C1uiYTCjiA5kk6lpOv3 fx/lWf8AYbGMRukdyGB3AONskT87j9D/AFoF1saMU4aKQzJtWJSXc9gPWs+yvpmNziKORZV8vy26 KvYj3p2drjP/1v4t5AsFvIkTXEzlSUjZs7T6AVQsLl42DkFdoy0Y6/TFebGKielf3bHQT3trItu8 CuYM/JHKmCD3DD6itG6TS7m086SFbJ0USGQSYSdgPu46e9UOL95XHQW/9pwSrYvEsnkl0QuAshUZ wD+FcToGpmZL53mSMx3bW0tu+5nYocbl4xQbdLHRwzRLdQEEwTBvMR4m8sHAPBAqzcXE7yySSSmY O/zMzZf8aqMbiP/X/jStIQWBmm3KsobyM7GI9AfTivTfh9bm08VW+pQO5WXUIbaKGJN7tG0iZiY+ +08+ldGR0282w6/vx/My4qly8PYqS6Ql+TP2q+GuiatNd6bp2mEre6pcxRrA1uJJFDkHYFPOcHHH rX9rv/BNfQZtO+GWgW01vZW39iWKaTHbKNtzKGO55HzycD5fbFf1X49T9lwNgaK62/K36n4D9HKj 7TPcfirbaX9X/wAA1v8AgpVrJsfhLr1mboWDxWcsEEzDEQzFI29mPHynB/Ov4gfGTWx0rWNR0qS+ tYVYRW012WWaV9u0vuJ6cNg+gr6z6NtJx4Srye1/0PD8eKsZ8UUIddf0Pxs+P2o6cup6lpvmGa6t 8hvLBjJEjE+Znt1b8q+O7yGC0nUySNcxrtClvnbHp9BX89eM0+fjXE26WP27w9pKnwzRj5fmf//Q /h0tHgadJI7dSrnA7eWPpXW2ogiYxK2xJCDK5TO0DpgVFXSJdPc0bS+uXMbWqeets+7Eikoceora ght7ryzcQKksjF5XZcEH0P5frXnVOhqaVjp6p8m4kl/vnjvwAK7GHR2uIYxAsxuA48plOSW9gO9c E9rFwWpos3mIkElmJQjbJGP34Tggsc1SS1u1kZY3ieIcskikyEDpt5x6Vzz2NUr6H//R/khhZHiT zoW2Ry5LJwx6Dn247+tJZ3FrPK9xGr24hmaACVNrttO3dj0PY96+PPRas7BcXRSQo8gVg/zdBuHp Uum3EV3DObUFljYl2MZVmIODjj60CIbLUBbjV10+3je/dBM0ckASVwuNoRiO5/ma2Eur3VIryB7d I0mt0+0qVCy254BUY9aLG0vhZGsMdlLbWkhk3SvmCGNGZen09s81sTwaFcSX1uk00EiRLskePOSM FsDkZNFle4pP3D//0v4w9XtI9auNHEK+VcsDbXFpECkRChQH56scHp3FXzHbaWrLFm4EtuINsi7F g29gB/OvEktUcVKWrSJILYXUUZgvr2S4hYsLURqIOf4Rjk9D2rD1FNZigV4ooobeS6xJapKFZsY3 SsvXdznmlBbm13axlGKOMJcw3Ss8bbpLSSMruOex789a6VLu5a1S5iaWI7dsiwkZkX+KMj0PSrtZ 3F5DtNvA15IlxbJBEitJcRJLiaLccIFU8nvz7d6x3u44Z5GlthNMs7R2TSYJZSOwH+eKYH//0/4v dPsmju3vHJQmMoVXAwTzuBqzdTNCjMcBI1zuJwDXlQ3Ocy9Qa4vbWyj0yZNMuIpMyz7POEw/u7Tw PrXXW5Q29rA0jz35XbcTt92Zh0x6fSu+kQ4amLcQm4vH82R47cfJPGvcj5a7O2mMGky6R8scSwH7 PKjbphkcDB+ld1Eya6HkmvNKkfkzsZGOSHXhhtxk4rzqaeO5uQJzJcGMBCshP3RwAPwFehdXsTFc qsf/1P5Mf2UNQuLbxIskRkghaeO3jaICZkWMoWAX05HX25r9vfhHcTaJ4yskOrA/bZBaK2fJLytL G3mgn7pXbkV/engpPn4Br03vaR/I3iTTdLxBwdZae/D80f3y/sRalNc/CjSWnAWSTToLZo4xuizE mwN7E4/WvkT/AIKq6C2o/C+/u2QLFo9reTvck+UOIEkRSO4PlEZ9TX8pZfU9h4mx/wCvv/t1j+p/ E7D/AFngKcWv+Xaf3JP9D+O3UtQurpY2to/sdzZ7ZpFZsrcxMdyNkdVZeRj1rBk1CCXVLh7iOO01 C4iVo2A8pZY0ByAO/XAI/Gv9RsJK9ON+yP8AKbGRs7+Zs2msaPYukuq2rXshDLBCIQBE235WV/4T WULuGW+stSaJrdbWdJ3itWEcileQN3qPXviu9TsrM45Kzsf/1fzxvrjQrxZxc2n2i+luEnW9aUtN CqkttB9Scc+1Z8zaXcJFNBbx/bbeQmK7aU7oMDGMdPWv9ooSSP8AIGW5h3mpm7lS6kaQ/YXWNJyx XLDoV9q1bjUdc1fF2urw4WIRvZyx/vbkL0YN0BH9a2MnJpsjiY/2ml02l5fyljSNmMSSsFAPze5G a17/AFS4t7KO/wBU0KKdIkKWtnA4cSspBIcjnOCSOf6000nqZtt7mRI1suoaNDDZTrHOy3UpjuyB B5mGVSnBwvOQa7LWYHjmZ40USlfLeVDxL1BYnvwfxFaqSexMk7aH/9b89vD1hpC381xrl22VLRxQ xxgxFSRgKR0PH3qsQ6RqlhN51rdi3szPmGQORCvIOR2HbOK/2wP8bzMkWK+vL6PV9VbUbSSEo0Vs ouLcsOiksAfxFC6lpdtb3EJ0cyLLF9lOMywKpUjzSnYqcEEflxQh2ZW8iK00i0ff9qNuR50rReTJ JvYDGOwGV4pqW2iQypfpbzTagrAB5ZS0aoTztQ9CM9fatHKLRHKtUdRZmx103EcVvb28+n4HKBJp kbpg98E49q57U7O5dEMcTYSZof8Aa4HPHt/WsxpJbH//1/zw0qyjtreWKTIMzZkQnKk5/wDrmunt ItPit/m0+KS+Xd9mutxV48jHAr/bKFr6n+Nrjd3MPS7z+zg2nX1qYzcbmiYYGWByQf1qf7OTcwSC RpJJp/LVVX5oQent2/Wrjy30Ca0GzXUkjzbLmaIeYArM2QFU8j2yBzj1p+nRRTy3Ej3hFrcTLHGk su75hn7vbnuPbvV2Rm2uWyOveC1kQXOoxLH5MnlCWFgHmBJIJ+v+NZOpxRJbXl5HJbwK0iRW0sa4 uBk8AfTB5oOSo97H/9D885NEDwSQWuovK8WRPKcbixORjntRcQmEI2pC5fzHDb5VKM20L93p7H8a /wBv1sf4r7DLu5ll32MunXbQ3TJJZS7MbTnqfUEd6leS8a90+NTbs9raNHE4gw0RDbihYjkksfXp 1pmc272Og0/TLKBWubiAxy7lL5U/vycHKkducVrmA6nFLK1jBb24YWkU6y+Z57gEncp+6RwOv5UG EpNaI5G+0++huRFfS2x02NtlutpCIGCnruI6n3NX9MvtN03UrTThFINDLj7ZcD97djfwSPpnP4U7 NK4lPuf/0fga/WFL64FhcNNaBysEzp5LzqOh2+uOce1QqjyRBgUgdZAkd2sQDJyDgt68dSf5V/uA f4oe003Ovg8KztNCsEEd5NdLiS4t5Q6sdu7LnOM4wB+Fcv5kkr3ukrb7FilWPdH88xKNltx7cgUJ X0RhKehblsDBG0KWymHImjeVcSs5A3BiB0yoIHbJqB1ivlkkNvFYSW0XlPklhMRztHcZ9OlPVGfP EpWizbUt9hhjI3RDI8knOMLz7VoXUbedb3EltF5VrguSuxwQenT8setaQelgclbQ/9L4Sub6LUEm jeKe0SEqVBGI37jB7+/1NNtbgQKktq7O+4xyJtwi9NpPrnnp6V/uQf4dVNyJpLyya6jmmG+5/eeX PbhZIe4Cnr6Vdl8+e0gfZJbO1uJJEnXDoxwQPpg9feg5nFozbd76zIaE+fJPcjzI9iukQHGVBz79 PWrctziUym3G5W+dGTaCfYV0EleS9gupUtBbxxLuZ+cJuLdQeen+NF5YT28wuEnjjCW6qsLcxggk Z+p9qDBxaP/T+FpL6GI2F5DOFmtRsmhMWVmZzgZA64PTNQXl1NbvN5HmRySZLiRSoywzx7c9q/3Q P8JZNpaFKz1VrKSC4mRXeOUKRk7GJO0bh6c1rz3st7JK0wjhxJ8ltH/q2HBz+eeKCibUbgXllBG2 nRRLZSEW84fdLcZRBkjtjkY/xrH0+KK4Mey8EkhJEunKCJImB4YnoQeaDOXxo6+zsGEb20VurSuf NfYdz7QcHj2z0r1rwvqF/bWVpBHN59okpC2qqW8zng89+ccHPHT1erMMcuVJn//U/bf/AIJIalLP el5CpvftU0siRFtsIbcdnPcK3bpX9DPiMFvDuoKQCXs5E59wBxX9D/SCp+y8TqjX8y/M/F/BWp7f wXwT6+z/APbUfxTft9WN9D8ffEb4+0QxrLbRNuBcKJcHC/XNfCQkuoZPOUSeUpER29Rnsf8APav9 HvCp83AOWtf8+1+bP8dvGJcniHmke1V/kisIFjle4lBkab7m4/cA9B/nrVqZS6K4IUouABxxX6Ut j8mT95oitbhkcRtL+5Vi2xQOWIxknr26Vrwpdvvgs2g867jZLb7Y5EYIxyD2IpibWiR//9XwiZ7x rsW93HB5Sfu5YojuVmU4JB7j61pNLDBb/ZI2ENurbo1C8MxPc/jX++EpO12f821ON6tkXIQD5cUM iO8mM8gAfrWppmjTXzziHTrm9lA3XIs13XAUcHZ2J9BzXFWrQoxdSq7RWrb0R3UaNWtONKhFuTdk lv8AI7PTPB9+rw3dhp96Gk3KkeqW7QtDsHO4uoXJ7YzX6p/sh/8ABNXxl+0JpEPjbxZrX/CP6Ex4 WRiQWwBhNqEN3ODyMjnPT8e8SfE3KeFeGq2Z4Osp1ForO9m9F+O1/U/oLwb8G84454nWW46lKnRi uaV1bmX+XV/cfoHL/wAEaPAlyLf7X45kuRbgL5UljiFwOmQFH65qxcf8EdPBtwlhEfG8CR2FwZ0a PSiknTCqcEBgPRsj2r+PKn0kc5qNwc5/fp+Z/cFP6K2SYZKcadO66qKv2090/9b+lRv+CN3w6me7 ebx3eqLxEWW3i04C1yv8YQFQCe/0rzf4n/8ABGHQm8OX0vgDxY0usW8BuIIJ4zbXFy6IcRo21gA2 MFSec8c4r+z8k+klmWFzKh7WT9nzR5rv3bNq91fa2/U/gfjL6KeX5hkmLlhIx9sqcnGytLmUXa1k 9brRddmfzv8AxA+HniX4feNNY8Ka6pXWdAmnsryA8iDypNjfL25PfkEGvOpZDA6q0Zcucfd4Ff6H 5TmNHNcvoZjh/gqwjJfNJ2+R/lZmmX4jKMXVy3E6VKcpRfqnb8fyKwhYyyxuGj28yblxxVVrmG0V IjbNKDJnegw47V6R5zuoI0FEMkSliI1kfbuYHK/WmyR21rHvnYywDlto+YelKL10NUm0f//X+hv2 SP2SPE/x58faHYWVjdxaJOcXepxRYtYt0alVG4AB13ZJOQvOeRX7D/FH/gjN4Ssvh/qWpeBfE95q Pi/SdFlvI9Hu42hg1mZIiWRZlcZdiDjcuCeOMiv9QvFfx2nwpxthMiy6o1GL5Z2s1duzclrddFe9 rNqzP8ffDP6M1XiTwkxvFuY0l9YnF1Kd01JRim0o9npd2s3fld7I/m58W6JdeFfE/iXwzd2d7plz ot/9iurS45EcqfLIF9gSRzz+tZMe6GKUxJJLAqfvW2kj/gX/ANev6iwmNpY7BUsdh/gqRjJX3tJX V99bM/jvEYGrgcXPAV/jpycX2vFtO23VGFaNCXnlVRcOX5j2h41XkHPPGOPzq19ma8lxDbkMvzYX A4H8hXYn1RwT+I0oEuArW3lKy7t754AVeuD9BTLmATmJVZYUhRtuBw/XGffjFaqV46nNP4j/0PIV tI2QxlTkHJIypz9RUMsMwf5ZJAqfMVznzPrX++kH7tj/AJnqqSkrGpaXMSLG0SibzI9rvj/VZHp1 BH86oSRRPKwL4zJ988BfrTU09yJW5kiQi5sJI2W0VxcwNGsrDcFRhglfrzUIUQ3CxbHU437tuFUd c/h1qJTdmxxjevFH2j8JP2K/jV8XtNsdX8G+Atd1+zUFneCM23JAYFm2NuBHA471H8Xv2Lvj18K7 OLUvGnw61rQdMhheWe6uNPaKEc/89toDduOehx3Ffmz8XuF6XEj4ar1OWafLzXTXMvJa2buk9emn b9ixfgXxfheEafGChenKKm4WakovXd6XSs2rK2u9tf/R8+aFE05obmFJntpP3DwKFSI5AJLY5Bx0 rGZnjaYABIJWDFAdynGcflk/nX+/cZ3ep/zNSikRtNlmJBJY4BIwMVFcwmQeSqxy9yXbhceg6f5G K3i+W5hytQsNb7V5KMiAso8uNVQYO0DgDpwMVCqyJGskvys43OjffTtg1onokElqkWrWMXRaFXXz HIQQ5O988ZHt9a/Sj9jj9i7Vvi34j02/1e21BfD9nKpke3/cG4LBS4VgMlFTIySPmJxnqPzrxL4r p8H8MYnNJy5ZWajrbvd/L8Ln7f4FeHUvEjjjCZNOF6EXzT0draWi7d9Xruk0f//S/se8N/sR/s96 F4c02DUPDcBltbdZZru9WKOYOVAO7K47dOtWE/ZP/ZQE8c83h/wvLMJC0TTvbb2PcfMpzX9Bf8RL 4wzGtUxWHlJxbb0u7K+x/OUvBngHL3DCVYRi1aOttbLdaef/AA5r6r+xj+zl4h0uWztPBehW0bqf Kn0m2gtwjFSMkxqB3yc1/Pl+11+w/qPwX+KFlq1rpt63gLUbtVmv47dp0s1MhbHOVUMM5PT5TX6h 4OeMGb4biKeW5pUbVWLUb916vfqvR3PxT6QvgFktfhijm+T07SpVE52/lfXRKy6O/Vo/YT9jv4I/ s1+I/h3YrBpGkeINZaINexajBBLIjAAfIuD1xnPU5/CvqXxT+yT8CNb0e9tH8B6RbhoHdfs9lHsy EPHlldpz6EYr4TjLxF4qyjiyvRVRxiqmi1s1fTt036dD9b4d8HeCM74JwlVUruVGK5lvrH5rR7fi fytfHv4F+Efhh+09aeErSCTUdLm1ItZJfRAxW5kbvGuAdvGFIwM/TH9M37On7Mnwf034W+GZZ/Cm m6nPfaZG0/2q1jaKPAGVCgY65NfsvjR4kZ3U4GyfFYapyyqRV2tW3bf1dle9/K1z8A+jL4N8OUs6 4g/tKipulVcI36K709E7tWt53sf/0/3R/wCCtv7M/wAMPh/4RtPiH4Y0Oy0e5vNmlvDaWcYaPzJk O9TjIAKdBzg9a/nSW2ly4yZUtcCSdgI/MJ6Hb7+1f7E/Ru4gxvEfhxSxuPlzTjOUevSz/U/wQ+lH w3geFfFzG5Vl8eWnaMrf4l/wLehJEkpErFRtH3mUZCD3qK7jBhJtU8wxrvcH5V45Nfv5/OxDHdyX ESIyAIV+6F5/P+lWPK8vyyuQM8HHcc/4VrB6WFfWxMjI0jSYHmscs2MFjSNsuN4cnchwA3Q/SrGf /9Tx1kVfk3EAg4Yd8DpVCVHLAOrbQfl3dGHTP6fpX/Qgf8w5atnifhT80Zy46DFWpj5jFUB6cHHA oAjtYEdZRMzAk9FGQw5zznjtQ0txbbriCOKW0K/ZZo3tjPOpfgMvBxjHUcjHUCgUldWIkKySbmUg DjIFPktx9ojMYQbhtaQttC+maDPkaZ//1fIQBGWAO7sGHOaq5kfhj8qnk1/0IH/MOXIkgALNyf4R UUxhBEg6D0oAhQNdJKjo6xhg4fO3lWyKtXNsGg83Ilk6Nxy2fX/69AEbTXCwgKuWCeXnGQq47Cq9 tKsqSLjc8bFSCOF/zxTswP/W8cj81sn5MDgLuGV/Coj5YkiSZjISf3hIAIPPTtX/AEIH/MOaDKsG RCG8t24LDJ+lVpAwfAJI6A461UYt6kuSTsx/3VwxLHqoHWlMnmBFUMDj5lPDCrmtLkSlfYdJJI8j SB3klKBAHOQuBgf59BUL5YoR8zJzIAOnWsiD/9fyVp3lkDvtXIxhVA6cdKspbskZKMSztuy53fWv +hNp8p/y/kDEl8F+fu4PT61TmjlSVX8xfLIx+NQBtJBbmBFMgidRuBC7vNPpVeKJY2YS4dNwYAgZ XGO9AFee9ihnRWjl2ucI6oSox2J7VG84eQMd+3GCFHagD//Q8kLCEDy1wOwAxirkX7/HIBAz83fv 3r/oQP8Al/K67RvUp827bmliCK5R32oTySM0AV58PPiCVniUcMV2Y9eM0RNcxylHwkTfIGdc78+l AGhIqR+XCJNhkbEmc7cepxRLbwRzSRwzCdR8gkxgH8KAP//R8kRvKnltyC2BlXXIBJz/AIVfgG9H ThfLXLBjjPf86/6ED/l/KcrgsAuFCZKlRyT7mnPA80APmmMddwI3DHtQA4RK7RSmRmdDtAI4wO/6 dKfLvSQbWQqDyAcEewoAhuGaYxpGoTLDdIzEgDoelORDC5Z22jZ8qMM7zkDj9TzxxQB//9Lyl0kv HxxiPqW6CkngxCy4ByepH3f881/0IH/L+UZJN8iRcKiIApBJLHvmpYkNvI8kmTvXZt9euKADKo58 xCIyOoODUheDY/lsA2dv+2KAH2kDZJXk7SefYd/ypyjcS8iFSDtAPftQB//T8ekVWb5M+YCc84Bo bzUgIjPl3Egzhh9znp/n1r/oQP8Al/JoYmKhpzyeuOcVXuoJLZCIC4iJLIVGN4zzj/CgC1YxKUDS SCNhyd2fy/z60XdyPMMMO44H38YH1oAUzRxJHIp3/NhiBnBzVaW6LMAibwPTAFBMnZH/1PLUtx5I fBUsOmOBVi1e2SMiaNYLhWPl3O7IxzgY/wA9a/6ED/l7jJt2YFZJURySYU+XfjAY9am3xPDIjD5u Nrjtx6VlKLWpDbe42IKqhCU3bvutIELAZOAT9KhBEm4sgVd3AP8ADzUCHufNhMcUbtcA5jIfapAH TGKoRxXMjMkygfLvKMd249/anyvsB//V8wZmeLYRtKDCgVn7JNwUqN+cbhziv+gmzvY/5dzQWc+W Yckv0Gfuk1ZlkWMWsUCGRjb5nn24j3H+EDrkZ6+3tVSVnZAR+TIoMkqFFB596oPLPCRNFGz7JFwD g7gWHrxwM/lUWtoBqTNDBBkRs1w7YVlwVI+n1H61Ts22CdbgKzTMGjYjBhUdh+VXT3A//9bzme4i kgMAiRtpwJMfMPb3qMFhbSL5KOyLiPjaRj6flzX/AEGN6tH/AC8J2dzNZ12hJMZ/55/xVagtFZfk HLHkdazNya6gEEY3EbgcY7iqlvD5jM/dfwoAvG4t7dDFKn74uPLZpNqsDgEYxnPXv6VXnsVmuo3j RgWGU3fwg4I/pQB//9fyaX7Q87W6ws7RocsF+QbeOv4VKiYUAAbyMGv+gg/5fxskkiZhwUGMsBwr YqopLxvhNzA44P8An0oAtW1tJKJGO6NYiFdMAbuCfypkdtGJ2PJUnO0nigC8zMvTgBcAEfKKrtC5 Xc7xqgOfuAMePWgD/9Dyjy3IG1sBehFMf7SUWKF96q3mFSTt9z+Vf9BB/wAv4hPmnbkhgMN6GkfY E2OMgfdA6D3qJ7ALbQ790qNhoeQM4NPdpwqNGnmZcBxnBUE4JrI3irKxBcwJLIrZKMn3sN1pjCSB 1CEsMcnPApvyGf/R8hZWdM/eZTk8dKlKLJGWmjCsFATACA/Wv+gA/wCYcV7u6jiX7OYUKna2+JZV YY54PFULbfK+9MbEcq4245oA0Y5RHcQpOYY4nc/NJHvAODt/Wq9xazJOZWMTRMqsvlyeao49fr2I FACxRbWZgmUzlt1WI/KR55YC3myEEJ1t4wOPlHbtQB//0vIvOLhgVjZjlWJHT6UtsvkQsiEHc2dx HIJ7V/0AH/MOVBJNE7eYwl3dFHYe9TxXRjVoDGp8w5HyBmH49RQA6E3duzNFtRJF2uGQEt6YPb8K lhExbMmDtbcwHQ896AHXl600wEmxCoClggUEDioLiNY/mY5LDIcDANBTeiP/0/GbaaJFuYXhSbz0 CK7feiIYHI+uMfjTXiSBAu4EementX/QAf8AMOVSMDjjHp0q/ZKrsBNKAhOCx+6vvQA8iJXJiIcB uHU/K3pim+Y+7dhSUOeRkcGocEBcl1GaeFRdRQu0ZzmK3SF1UcBcqB0x3qpJPHMd9uuxRzEJFDnH bPFTNWsB/9TxlFccSqxYjjsfbNRmeaQS2o321xt/dShdw29M8/XFf78H/MOTZ8pUSQ5ZVA3bfvY7 1ekumuMGVI1UqFQJCseMDGeBQBVO1SV2fusH95nv6VUN3cRELHErxD5OuNo5zQXT3LUqRXsCli6m NwfKzjfjPXHbjp70wBRC6xYDIcYz270Gp//V8Aub+SGWKOKDzVZ9szA4Kj1FaiQSzshDYixkBvlK j3Nf78H/ADHkphtxvYbJHbjePakWAHESgknqR+PSgCpJGY50CbmUD5mI+Ve3Jq285Xy3aPyww+7n n/JxQOxLM0bop3gNOhEeBksR/LpWJllnWGdCiIQrP2QetARWuh//1vEAbYr5UZL73DCYc5x059DS zW0luyZvILhnXzPKi3CWHPOHyAM/TPTrX+/B/wAy4yKRpZdsu/BIVyn38VF9meO4K8FVOA/TPWgC ZXCO2/L44VVOKoNJd280qXVqUXP7sklZO/bt+PpQBbgPmqGYYcglVxzgZqFprdD5Th5iThgvBGfe gD//1/EhYW9sqsgQAgMdmMLkVEwhVirS+WkvAkYEiL3IHOPp+tf78H/Mw5NldILB2kMM7zSI+yWa OQm2YgcBUIBHUZJ/KkaSOMrEIFnmLDywz+Up/HFTJ2WhUHbRlowsrNJczxf6QgkdIj+7gbnjOB/k 1REXlEKCN0jZjJ6NWfPI1LkqRwxxlEJuANsrEE5YnHA9OlQvLKpe2f5njXcVBzjg/wCFHO7gf//Q 8LiX7RaSJJLsIU7GAzg+lZ+wW0auZQcME3DuSdoz9SRX++Ld2f8ANAtGJNGLoOr/ACSp8o4G1gKj UKiMrMMAYPOM0jcsvBm0iiXzNwXb5kzlsD19adEZ7OOFHVni8tooZXX90+OWA+mc/iKAM77W7JJH LG8jBsoNwCkegqxCLmdgtokUSohkeKRsHaOw96AP/9H5x8y4V/MMLAZx5f8AEnuaLiUzmNdxyBgj HIP+RX++B/zUJtbGewEcwYeZHLA21+xb1B+taRthcwGWFZEkA3Sb2yHA/ujHHeg0jK7syIyv5KRJ Dy8yRy/L+8KA/NtPbpUUwlhBEblcIyY6Zzwf5n86CyOBbkW8J8o7HkMbMSMZHX+Y/Or80BMSzjy4 13CJ+MAYA5wP59+aAP/S+ZbdJHPmIrLCJTErFcI7LjOD7Aj8xWkdOikiMzlWMUgOwj5ieTkfSv8A fA/5soytox+8hN2w7ByFbkrUJjNxNEkBUyyqWCY+Zcdc/wA6UnZGpK00tkscEiGQSgyIYxlWPTr2 6fpVC4ut8TtJGcp8xReT9KwGnZmha6RPIIZRNCsUoVt7PhYt3OD345z/AFqtFeRRpcqUkSZsoZ43 HlqBxkrjrUydkdEd0f/T80+EHlah410DTAGlie/hdjLJslAWVMuG69zwOtf3C/snQ20Xwu0kIio0 VrCV2tkMrbjnH5H8a/0D+mLO2WYGHr+p/nr9A+mlgc1m1vJfgkfCX/BWzxFb2Pwa8QWlxEz79Fu5 fMifBjRYSiEfmfxr+RTUb1pbaJIZRaxLAHjbdlcbcli56d+a+u+inR9nwVVn3kj83+l/iPa+IdCg lrFW++z/AFPxy/aqh0rTvFmqRWbrdpHcyWcF0D5kMzskUjbWJ6HGVP5V8F388sU6Q3UbByN6dww9 RX8z/SinzeIM12ivzZ/bvgLT9n4f4GP9xfkMilnumz84jQ+WATjAHOBTbt2hEShUVxJhpCcMRjgY r+ZHaMT9uUW9Ef/U/jVjnZ5ArqHCMQXVvunjrV0XLx3Ebq6iQfdYdSPSucygtTLvmlubjfFIY0T/ AFkJjDMx9c9hUbR7reQGJ42Ub96qcSe9TO1jUpW7Sox2kmRztAPTrViQ+Vcx5AaRSVkZT8qZ4rEz lJqRdMTxRnzbhifM3K20AYJ4X+lVxqJtmeN4VDE/KzfeI7HH9KAc+x//1f40ZJo5o1QsoU5MiPg+ aMelVra4VkcQHEUZ2AdH4/8A1V55MZN7mNqN5NvQeSJRu4LkjGDVuxb7WblpEjDLGCgDYc4/n/8A XoKJWWSJomkjQW7Ai5B5ZlI4A7Uyx88Ttm0ijhQZhIf+EdB+OBQaU30LlvcXjSSNcrGsRkIi24OA PeormTfuErmMFsRsp5X6VE9jenuf/9b+MD5oUVlnaRkAKiU7mf6moLuR45GmKKXZF2qCNq15CV7n oW6EiXMlugkJKQS5DsGzgjHA/PmpHkAAaEhmOGLL15pHOSQnerOcK8XLhuCfeq8lvLsku5JA0jKW kkVNvHb6dqAMOZm2eVkt5nTPOPc1e04tDGUvUQKnzRNnO49uKAP/1/4woJVe+heVlQtGVTZyWx2I 7dO9PniDrI8jGIBioCkZYDuK8c6CjLBtthMklwEUjDDlh9eOlVnvvOBBBlK4V0I2P9f5UDTsmiRw Y0Z2xKVxsMZz2p0cLSRLPcJ5cT5RHYjkjqAPxoSvoVFe9YdEitaqT5shWQowKbSozxUMtrLLGWQn KNj5xtZR61p7MrkV/I//0P4vba3mtUcLKtwnlhiQcsOMn8qz77U3t9kkSu2FxNgZA9OK8lxaPQSt oiPSJLq4mWRXUu7EB2O0euDWlNexxPtkYIudsjA5JNXGKtdgXI9SSe32RNnyxtAYYJx6VkzzTed5 mHVOgj6jjvRKMd2Fh0MkUpImz5UgKOgGQ/Hf05p0dt5cUs28rIoxyoWNQOmKzb6Af//R/irhcxym dmJlh+eNh/qx/nFU5pJZL1REiKWG92UjaM9j+lectj0WmtzRiSQBFldQFPJz8oqaO7s7suJUZ4YG 2lVOVnxwQOuO9MRNbNLF5s1sn2e2ZdkKr8zIeaoW+lypLJcTOAd3ypGu0KO1XBam61Rty2qeRDtk hmkk+bEbZkjPQBv8KjaymRzDdSbFVwW8k5bjtWsUkxOVtD//0v4z7eWO88wxoHihO1ZE+8CMj+le +/BnS3u/ENnZREvIb63uJSVLttJbaqgdx5ZPsTXscOUr57hUv54/medxpPk4Xxkv+ncvyZ+13wsk 1ya10aWG0u5NUvry3tdO1BAFe22SiLznfPy4dfvdcgetf24f8E+NEnsPhxpv2sIbm40m3SQg+Ybf 92km9W7h85zX9KfSFko8KYGPXT9D8W+jTByxGOqPv+Vz5n/4K+37x/BrVbVdRnaW/tmsbOCBBIkk hDR8jvnco/Gv44vExvrzSF0e+1CO5W08ttSMEK+Wuw42qBjlSQDj8a/Qvo7w9nwNKTW7f5I+F8ca nPx3Tp32S/Fs/EP43M134n1aUSxyJcSeUQibJsLkbnPYdMfjXzOGZXmjkiLhPkDOOFHav5g8Wp8/ GWL9T+j+BaduHMOv7qP/0/4dII2CgwZUgcs3QH2rTiW9aSJQS7SNtDr8i8dcn2rKs/dsdMYas7+O +/cymOGK0nithDEsCEpcMoALMSeCeTz6Ulrc+Ym2Uky53uew7YFebW0NFBJWZtxLJegR2kpt2TDL If8Alkf7xHfvXZ3DtCLJYZJzNIfLkCfNDwMh89ieetcUxxjyo04IkiiDu8n75sPj5jnOOay9Rjun uIDatJsimAuxtwmzHU/p+dYTWhpD4kf/1P5FmGrQ5topPIsrobbkgLIxAOVOPw4x6Vbs7uK3vbe2 u7SMQow/0rGGuBjksPb2r489KfxFjXdFt7lLrVbWdzdWUJa0hiQy293zjkdQR2//AFVnR38sFtYx 20Lf2lPtEenrGVMjdZPfI9MUEmhdRX94g1KO0gtn+0eXawq6wXc5UDeGHXHf8a3PDd5lNUjl04Ge 4g2CeVik0JjYMzY6EYBHegub6EoTWXRtTsbS2u9O8oCHdLtnlZvlJx2Azwa2Da77JC8Fut60RBRM Hc+DgbjjP1qZS5Q15D//1f4zYDYm+e+u5JBcW0edPs7dAY5JCQCXbPAxz+FOvDHceUoA82YchGG1 Cexrxp/xLHk0ZvmZHomoT22qW9oLZ2glBBu422tDjjP51h6ldalBLFBMkaNJdOscqS7zdZOVLdhx 2x3p2sdSnaPmaX/CPyJbnULi4txEChKeYAwLdQF/D9aS4EltYpG0iR2kt6ds9p891GFwQCPTnPoa Cou61ElhjlimukleS6nIf7a42SMFz8rg84PrS210IrJLd2tTLdsZfM2rLMDxwHIyAMZwCBzRaxR/ /9b+Ma5LrbrFA/mSNhchtvORnmo7m2MFnETCUUEsULb1cd8GvJgveOcfZiCSzjVrSbz5iQrLIFSL n5Swx/XuKsT6feWDFf3alY/O2mVQuOpIJPX2616FICK1vw1oYZbYSXbXJ/e5J2qcY/xzXRW9mWt5 LjzP3rLsjUDK5HY12Ud7CcU9zjNYa4aQte2y2hXEUAZAjy9tx9d3WvNvEFoLW5dkVFYANLJGfvZ9 q7E/eMkvesf/1/5Bv2YdXvRq88FnYQIvlFYXa48ue5kADySsuOyhgPcjHSv218Hat9rk064Nn9ou GtoblDDATKZPJSUhV56E84r+6/Ad+04OxEXsm1+C/wAz+T/GD9xxXhJxXve6/wAf+Af3if8ABOLX 01j4NaDfvLIhu9JhmuYpTiWGUxrhCp5GC5PtxWX/AMFJtDttV+DepQXbTRW0+mXw1GeJwMJ5RRS2 eBjfnJ9a/lrEJYfxR02Vb9T+pOLm8V4bc73dD846n8UOn2sehW8VvqQTUJRbm3J8zIO0lVAIzkKA B9BWFfXf9q6paCZVZLci3stkfzwKcZQd8ZzX+oWBkpUoSWzSP8o8dH2fuy6Owuv2sdtdyWF0UQLb eZvRsyK5GUXGMc5GTnjmsFIYbaybN3DJeP8A6vT3LJPcAccnbjJ9v/rV6Fjz3LXU/9D827O3juXv miLpDbWguJUmjxKuCqnAHux/AVRuUSwaKRpIRDsMo8kBzKxwRnH6g881/s/HZH+QDd2T63L9rsYJ pLBFVgJElUbcjqFx3xjisrTZrSBLQ3hbdd4eNdjMsWexIHat4KyM+X3tToLqyvryxF5YwRFZLv7H ZtJMB86gFiR16Z9qW5TVr6G2t4ZPs88SjzZkGGjwOWX/AD3qjNqxjx6fdJe289zdszudgDtlpNpA Mh/Iit6S6vb4zwNOI47RhCm1i6zr/s8cc5/yaLCP/9H8z9R0/wAq7sVuoL7yreNZ/M3FTdhv4gO4 7dMccU2TVZ5JILI+dHZyFmtg5JhiHRsn8P0Nf7V8ktD/ABznYuzCKwT7Npc0N9ZPKfIuo4fLJJA3 g55OCCPqD60t59qgheG2VftEdssson/dxqWG4DP0PT3rUmLsmbE4DaTYvbuu69UGdHAKWrjquOpx jOfepbnTLe9jsHhvIEuI49s9tBHtG5T1Y993XIoJMaJtS0zX7WKKExJGC73Ij3wjB7np7Yq/ry3O oRpFFJMyi6EzG3JjcksCc45xwOOlOzA//9L89rGby5HjuYQioFSISfK0zY6/XOPxq/Z3Nu+qN9rj eBbEvGbaWTy38zbxu6fLX+2UU3sf43lNtQtpYrh9kUzebmN3Q+bEwPJU+ntVcaqy2xulPJOzcFG0 9jg9ulVBNPUie1isNQeRBaTwQx+c5dLhUbIA/hz05/nXdaXLp1vYhXskR1JkWdoBLJGcdQD1q+tj F7HL6s+pXCQzu9x9gSbbJtjMcLOOQM9ASP0rTtnttXtbttQge1itIGFsbeURxTvsIQupznBAyRjP 50zlntY//9P8/tK0+30/QYtRuNRa6umiEkUezCNN5hAQv7AZ/CrN0FvrRtRnuA12wXMLncnoApx2 /pX+3kZ20Z/iuYDa1LaRR2l08i/a75HhIbcts0asAMY6Nu7enPt0U8j3EDpKlq8ZG2MwxiOfJGWc sMde3pj8tDOa6lWTxJeW32O2mTzoLIhI7d22vIo6qW6kn17Zp2nXA1K5nnhtpbQSHd9mEhcRHn+L 1ODg0HNPcbrGq/bZXggs5IUtQsM2XLKcn5nD9+OePStS306yFrEzFmyg2ybsybumCB/WtU1axB// 1Pz/AL63RWjMtzKVtD5lmgysO5uG3DPYFhW5LZW+vLPZ6XE0dvMyXZjllCurRKM4HTbkMcZ9K/3F UYtOx/iOVLX+2tH0+WOKSfT76+Ronnhk3woQcKwzx0A6dc4rY06CLS9MsILZoJZ45vNvtUYkz3Tu AWDAngAhvXrVJJbGDd2WNUkjdYrqKf7RdyXBMgBAtghxg7fXOe35VmbGe21OKae2VbuPEISAPPGw 7q3Y9OmKLJ7iILKK3ge2gd5R5cQIFyMysQBlsfrU4juobOe/k82bT2nMPm3Byu70H0B4oSSVkB// 1fh/Wdr6dol3bQme1mWVbryZVyzqwAwex2kcGsm7dRBiNzDB5Kx7XIMit0LbsDNf7kJX0R/h7JXR p3sdmLaF5rtFuobaMHc2W5AwfwqjczfaLWO0t53ka4cxG6b5GKj6DjIB/lWsYW3MSQXVnp1vE0rs xiXaI1ThCOtTSSx6vHbXC3MtvLKTvTYDGVAGw+pz+mOlWYyVpMqXFhayT28RTyJYWw10ZCVYHGSw A4H0zxWwNKOoO0u6KaxtpBbRXzqUgL44VSR1P04oIlZLU//W+EPKttEaBJsXd/DJ/pMi8xBs9Fxn getPuLo3JL32QkjbbXjnccAf59q/3Rirux/hLL4SuifYxco1tFcsjZd1bO1eMH2PSmQ3UCTI9zGy FvujbuRTkAb/AOVK1tB3XcvXF61uVQBJFZ/3ZZcoO+Ki0o2drqEc9wQjOp8wxbRKy88GgiXxJnou h6jbW19qItpYJy1ls3ZD3ECyjgjuOmK9O0zW4LLT7SONIZbsQ7gi2fltgEZ+cdSeD1zzRsY45XhE /9f9ev8AgkBqd5ca5e6jcqYLR9SeW3jPULLBGSuep+bfX9LOtwSXXh+6jiBdmtjgDjjILD8s1/SP 0jYKPiTOS7r8z8P8Aeap4L4Hm/lf5Kx/Gj/wUotn0n9ouGx0+0FtfXNnNNLJnzFkVZNzlgTtyTkZ r89oS88n2adpjHI5CpboOHwdpIx06Z9s1/oZ4Qy5vD3LP+vf6s/yC8bI8niRm0f+nr/QrzWUyXCw tg7ODuOOann8m5tS21FmthsAQ4Bxx26mv1BStHU/IFpMzbSCBY3llZvNJyq4+THv6GpLlCyJ8zGJ sqMNjH4/jVpp7EyVnY//0PC4biCN0Ro0d41bbKoy2cYA+nStKxt5dWie0uAoe0G+CQRCMOXYYDHG W54HPBP4V/vbPax/zcYbWsmzrtB8LX2oyW9rpOl319qN1cLYwRW1uZ5ZZW4VQvHGcZOeBzX9J/8A wT6/4J6aJaaLYeNvivoZvIreHzNJ068iIEsko3SDJ52oxPTj361/Nf0iuPlwrww8FhKlsRU0SW/l /m/JXP7Q+iX4Wx4s4hrZ1mtK+GpK0W1o3fVr0skn5tdz9UPEv7J/wE8S6bLp1x8O9Bs3a2a3gvrK zWO7tSRgOpORkYB5FfHfws+OMH7PXxquP2ab9P7d8N3GpbdF1eJ/KnstxIHyAFTxgHn+AD3H8MZJ j8541ynG5Xjqjlyx50/Na+nQ/wBDXkmS8E8QYTEZXSVNVG4O3ol111v+R+qAIIBByCMgjvXnvxS+ I2l/CrwZqfjXWbW4u9P0vZ5sFqcTPvJAAODjp34yRkgc1+UYag8RjY4Vbyly/e7H6xiqjoYeVZvZ X+7U/9H+474K/HPwj8cNBk1rw15trLbttudNupUkuYRkgNkdRx1x/EO/A9pPH54/pX0uZ5bWyrHP B11Zp/fseNTxMMVhXVg7pxT++5/F5+3h4Uuz+2d8ZjMr+ddeJ7g6fBbZ8l4mKMxkPQMu1zj0evi3 U/CGrfbJGs7ZJ7cvth2MScgDfnjAxX+uXhnmmGhwTllKpNKXs1o3ruz/AAh8UeH8ZU4wzDEUaUnH 2m6Tt8EX+ZkQeFdVa/J2yStcYHP+r3Lxt5/zxWhdeFSYjJATNIoxMPssiRRsDhlB244OeenHWvv3 m+DjLk9pH70fm6yPMHDn9jKy8n/kc3qmmTrdQRxQvHG04XyGibdAOxc4+76NzXpPgzwfJqN9AXsI boq4byGUsrbSvA44JOKxxubUcHgquKcl7sW18loexw7w3WzbPMHlri2qlSEHZa2ckn9yP//S/sX/ AGC/hT4X8BfA7w5q2naJa2Ot+IIRe6lOIh5yEogCBuo9z1OfQCvt2Yfu3HH3WHI4+6a/SuPc4r5x xti8fWld+1dvJJ20/P5nxHD2TYbKuC8PlNCCUFRStbvHW5/Dz+1n4P1GL4/fGF7u3WND4xvLiCIw sok/0hwrpjjHPQ8dK+VI7S9kU2ghcRu2X42hcYGT+Vf6weH+bUcZwdl7UryVKCdullZXt5I/w58S chr4DjbHwcHGLqyaunrdpu3zZqaXYXNzHc6TZad5soQGaaO3y9uB0JwM4PNWW8E6jJaQTQ2F9IHY o0scLMYSOGyuMjBHcc19dVznAYX3cRVjH1aX5s+Ghw7mmLXNhaE5r+7Fv8kdNbeAtTeJEGm3uHhG CtvIZSoAyzjbwT2Arndd8E6tptvb3FrpV82nKMS3UkUgbdjLk7lHCnI+mOetZw4jyepJU6eIg5PR JSV2/JX1+Qq3Cee0IOtiMJUjBK7bhJJJd3ayP//T5TTNFuLy4MKxmGEWRufPuImVZyGC7Y2A7Zz9 K6C9+H2t20Fk8emaldXM8vyra6bPcx7Rgg/c5HXPWv8AdLEcQZZgZqljK0YSe13bf57H/ONheFs2 zKk8RgKEqkI7uKva36+S1INO8EX15dzpNY6lbTMTK0LaZMs8x7lE29/p+FdHY/B3xHeRrczeHvEN ssqCe3jn0toknjPcjBYH64IrkxPGGQ4TWtiY67Wd/wAjvy7w94pzSdsJg5u2jbVvzsY/i3wT4g0C KxmvdFurG2eVoBPcfu4Y8DO3B5yfyrhLSOWHXNJnaC4e1g1WAak8CbgsJcCRXHoV3Aj0zXfg81we Z4R4rBVFOGuqPnsyyjG5PnKy3MKbhVTV0/U/si/4J3/Hn4LfEH4SaZ4S8C3FjpHibRpHj1nQXhNr d3MgVcTKx/1nybR1P3TjocfdnjjwT4a+InhfWfB/i3S7bV9C1yxksL20uYw+BIpXfGequuchl5BF f5KeI0864Z8RcTWrzaqRqcy16KW2/wAvM/3i4IwfDnG3hZhaNCnGVCrQUdk9XG19evXyP//U/Q/9 vH9gHxZ+zpqzeItAifV/hvrBeHTJtN3TvaytIGSKSMrlHTJ3chSDkEnOPykm02SOWSF3D+W2xiuS qsBkqc9x3r/aPwd44o8ccGYfMee9aKUZ63d0tG/XbXdxZ/z5+NXAOI8PePMZkkqbjR5m4aNJpvpf 71bo0PWzDoRtJMY3OFGSoHes+WS2VGePc8iH5SOF96/W4O6PyJrSxQi2GcXBkeOUAqoBwnOOcevF X5eIy20MT1JqhP4kS6fbI0/yybLi4IiDquXyT8q57ZP86/sQ/wCCZdlp9v8ABLRJYrOEXsllE9zM YlLqfKiXIbGex/Wv5U+ltOUeA6aX87/Q/wBAfoDUoz40zKdtVTh/7kP/1f7Yv2rtSm0P4N+J9TtZ ZIJbazdhLG5jMWEJDZHORjj61/HXB+0T8VE8e6kLTx1r66TYXsz21u87Ml0d3yeWDyq8888DPSv7 q+i/wrlXEmTZl/aNPm5Nn8j/ADt+lr4gZ5wZxtlNHKqvKppNrpu1fpr0P6pf+Ce/i3VvF/wd0LUt XuL27v5tMimvJLq4a4ZHdY5GGSc8FyPoB6V63+2ZpUGp/ALxok0ZcxWLMmyJZHX5WPGRx939a/A8 7oLKfFb6thPdjCvGKtppeKe3fW/qf1PjMRLO/BmrjMWrynhJzd+6g2vuaVu1j8P/APgl/wCIr5fi x4m0eDU7uTSLK/8AsVuPOJUMCSQBnr0zX9L+R9kBmJUGL94SMEZU5z+de/4+4enQ4toumrXhFv10 PE+jti62M8LKLrSbcZVIq/ZOyXyP5ev2vvBXiHXP2xbW+8P2V3fNFqqCZxamaCBfNUkggEfcGRX9 GPwOtX0/4c+HrGcSJcW9mEmSRSCDgev+eK9XxQzGhiuAMlwtKSc4xTa+R4PgZleKyzPuIateDjCp Xdr31+I//9b+mf8A4K8S2eo/CSKxN1CZrGJrl7YlXYlWG3aD/FlsV/J1tuEkeCe5kmlU75nkGHJb nn9a/wBZvonwq0fDdU5p29o2vmv+GP8ADP6ZNSFXxpxc478sU/kkhkzglWQSIEHz/N8snbkVHDe2 00c0W7ZImCUAyW7c+lf1Efyk3ZXHI8PlBVOAp4ZfbtViO5coqbQyI+SD0Of/ANQrSnvYy5ve5hsc cjXEzsgjhY5iUEkge9TsAnzAEvnn0I4rQrnZ/9fzCe8Etm1v5EXmAgxusQR0A65I5Ofes6GCaRWd mGF+QM4yqnkjj86/6ED/AJg+djre28mJ2mw7bsfIhQfzq8VRYlIXZkHk9x/kGgSm76kUG0CREbBP c9KhDuGdC4EbHDc8UGq1JI4gEby9pj7tjANNdbaWTaJPJZYSfnYurkZ6ADjPHX86AP/Q8d8tk2BW Db+OeMVC1tIgLl+pwAPav+hA/wCYctWoDH9+pCIOo+nGalkmWSF4oYYTMWx5zA4QegUcZpxV3YLo bAjxKN5+Vhz7GpFG0tgnGOBVKLuQ5pDo5G87ZEm7cvKYz0oaFkaWTYu8n5wo/PFXD4Q50f/R8hjh giYNBE0R2/Pk5BJ64/SpJIklAdSC2CWyNu3H1r/oY2P+YTnQRJexxMJPLZJG/dEfeC+/v1/KrOEU ZdwrKBtB5Lf596Sd9jIzZAyy53btx445WpraQJL5jYJHG01E272ArXUTSFhFL5eTuyvfHOP6VHF/ aLGO0hcLBNMv2x9oLsinJAJ9cVmB/9LyKRFRnjAOEb9256ke4qSC6eNCjnI3cZ7Cv+hWzcD/AJfy 2kQkIwOvJPr+P41TuITLIEHy7O+eKyAsKoBQBwSrYGenpVyUnYRsUOR8rmgCi0Ese0PtyQG24yPX /OaIvMtpRczfZ1hT5ljliLLMQR8vp37/AJ0Af//T8nuz5rvPCgjQnhB91c9AKhQTIiOx3OFwSBgf XFf9CB/y/kpL8f7Q5zTGMsaxgx7yzbmc/LtX6UATJbNcSxpbsgd22qrnapP1pPNmAT7ShUxsVEbc lDkg8dqAGhWklMjkFeq+opsl1LnYLV2JbYhhTd/wI0Af/9TyR7nakfy7nZsDA5H+cUTzhoVWJZUl LYc9m6dK/wChA/5fm0txwhdIleQDc4+5/Ev1HaoImkLlOdp+6KBlkTOhaOSNl8o4yeM1C9xA7tIq sGAxgEsKALZD+UkkEErxLHmV8bthz3x0/GqUEz3GW+bAJUhhhlPpQB//1fLVcpG4+VGVwuCeZAf8 /wAqRlkkITcRuYEnHy4/zmv+hA/5fxk9oISM7OGAyGBYU3efOjbarQo22Tc2AnuRz/nFACXH71g0 KrIiNkHHJx0ytIgN9cGSaJbcoBGFRPKTAGM4HX6mgV1exd2+SzCIgnaVBxxzmmjfFlpo1dGU4O7o fp+vNAz/1vId6F8lefb+E81JuLZdU3dtxGMV/wBCB/y/kiyPhlIRT93jnFOW1eQom9jzkZ+6KAJT ZG2kjZ0Loz8g8I2Ov8+3rUwitpnlYRlEDFVA7Z5HP4j8qAK/kRxSpFGhMITLsxGS3fiqpSzaRjI0 kUcA81vLVmZsdsD/ADxQZz7H/9fzaK6tLxXgsTJc7YfO3LGyqi+pyPbFVtkErGNgzknbjqFx61/0 IbH/AC8J2dy1P5iw+XEcooxgHkYrGR5I5AsjYUnHXBzUy+FiNEW0d3JAoCTSBh5ZI/1Z7fSmqSpu FcfdfYo7HA6j86iFroBywyOimIbpAfXipt+zCuf3i8N+Fagf/9DyyZtgVuMNwxxUiIz/ADYAUD5m 9DX/AEHOyaP+XcmjVI/3glWRiOAF4XtTBIULbCCActxnGKG1dJgE915wwDjJ+YAfLiopGD4SPLFR k9v89KmdgLcQ8xF83I8ofKT078VTeRZpCi5bYcsF5Pr/ACop9QP/0fKXuItwMcbAjgoOh96WW9Ea M0eW28OgGT9MV/0GXV2f8u5Fb3Es6hXtYxhiTNtLOwPbNaVoJYriN0kEQLYyw+UZ/wAKzNYPSxFK XmedpAWCOQW5O71NOntobaLz7e6YGfaIIpF+aRsDdt56A56UEubvoSC6aewNle2lpK8c3nfaxAFu GA/g3cnHHr/Ko4fLnulaXdBGRhcZZYx2GM8//WoLjK5//9LzxQqu7ozYxsbHAYc1TEqK7ZBHHyc8 57V/0EH/AC/kW6W4cKQMjJLH0HNROkXnRmLcpVdshB4c5+9jt2H4UAWDeCza4ieJ3/dhopEkwGJH OeO3+TTI5lMVu6xtvlhLyIDzC24jafwwaAGCScq6BWcLlzxyO3NMimeeyPnqGlMpjAHKhBnbnnr0 oA//0/IgXRwM/Lt2+grQgW0LI8/mABsfI20EHr6+3rX/AEDtXVkf8v5Xu5IGmdLJHSNe0hDSHjqS AOvampAAm5W3SNwyyKCij1B7GsWmtxpa2HWzGPcqgY6E+tKiT/awYmV45R5ZQtgqecED8aVjcquE hLtKHnUEh0DbWb8R0pZZMxRt8qh12og4KgcAH396Bdz/1PJYpYYlJlYqcbcYzv8AanGVrgRIp/dI rHBUKR+P4Hiv+gA/5hyDEeG2scjrzVuyfZFMvlglhgkpkqM9Qe1ADWjzJtYb0xhCKHQSReQQY3Rt yMOACPUZ5HtQAovJrZ0FzbJJHNEybwNsaHpuwPxx9O9VwwVRtARc8AcDHpQB/9Xypmto1iklgYxk crE/ls/UZyQcc+3aks2t3t5w6uJlmHlnPyMuOcD6n9DX/QAf8w5WEEQlHmSLErvh3cEqg6Z45/Kr s9vbQbTHdRTXDqGiVEcFwev3gOlAGeDcrIzTEeV1XHUeuas2txAzSYJcFeGBwAaAK8kbyP5ioCqf MxJxxnH+FWXlhvRb24XYYQQT0Lkk/wD1hQNn/9bw9k2yyKr52yBCAOB9f896lurTzV2M5P8Autgj pX/QAf8AMOQxRxxOY3Ys2MBSckjp0q59kcqPLJI74OMUAQLCwIjLHCnqDjpUkspjZcoyxpxJIfur 6k+lAFuF4CdwYOp/iXDKacGSCVZowpZG3qCAygjkcH+VTK2zA//X8lkuDcyTSkiOVgWQlcpuPsMc c9KhMV4PI8opdXUpCOIF5Qc5468Cv9+naysf8w40QXTOI2CP5nzwbc72A6gjsQQePanw3j2X2lp4 onV4vLjSSMbIySPm/DnFSBVN1I0RTZ8pbnHSrenPbO6xy9WYKRjntWkYprUunuVJizT3BijeHYxU BsYfHcAGqccMzKQZDux87Djd60/ZouUrNH//0PEJ1MVuq+WqorYwoA3dcVbs5JJEmDIFVIwVbPXn HIr/AH8UF3P+Y5ST2KjMyfN5eccFVHJqVDO7Rbw8Syr8pI/X+dVyoYscEsSOjsz/ADFiz9+elZVx K+/cMjDCMgjsTiomiouxckdogISev3ZAvA9+lSkKYPt17dW0arKtokDH/SJye+MdPc1Ao7o//9Hx F49k0EVtbCGJlwzmTv2wO1NuVEEhRyDIvIZeVx9a/wB+D/mXI4pQXdlVgrDBfHJ96fEEVsPKZck4 Y9uTQBUkaSKY85BOVwOcVdmYyRrsid5HUKzNzjntQBnF2gkKh9h2lDjtkEGmLFkqATKUGPMA++Rx z70Af//S8KaVJQsbbx228qwqKeDepRzgEc4OM1/vwf8AMuRwkLGUUbf4RxilEimEIwUyR52sB8xp NJ6MCmlzG0pgvBKUYEEqu4EDqKnxDcXDT2+6OEcQw84QAnAHfj+lZyikNNrY0Y5B/wAtJVGRjp93 61WltyhaaR18ovt3Bxuf+vapSu7Gyknoj//T8EN3BGpTO1WOFycn2qtE1oitFCqABsMq4KlvXiv9 8WrOx/zPk13bTLs+Uq3lbiByP8isOKO6WQOVLBG3bmX5Dg9P/rUjWM1azOhNzJJDkDMoX5dwJBPp VqW/jv7W2keFkhtYfLELHAhcjDn8WBP6UFJp7GapikjTbgfP8zYySOB/Q1VkE7M8VpLswdzyld2F BoGf/9T5+lmeKJhGRJJ5e0nsf84rnp/OeWLaWjJlGSvy8571/vgf805rzW6b38yX96B869yamtZl +aAHYMYG75cigCGO2Y3E2+crtG6EIOCfQ0/zvOPlTRKWjXHmovyfifWg6FqitGgthIGlDgZdgSAV HPT0pYJbQxzC5u41jhi8wqwYk9/TtjqaAP/V+b0WIPb3NnOYtuXLSN51qxyCrbAD6Y75zVhLpVs1 eY4LAI7HKbmbgHHb6V/vgf8ANeQCVYIHD3Z2lwnkZzIc9CR0/GorlJpmt1s3MTIhErKnzPknvSau rFxlbRkgu5X226qN0YxuPOapx7zIQ21pAMkD7rH0rFqzsaRd1cnsXurgwwXLTxI2dkAjByxxyO+B j6DJq/c2UUCHeMsT0zzx61EldG8Xax//1uZ/Z7+zJ8QvD0s9qsofX7OxjlWPzpI/NnUZUdsEKSfb 2r+3f9mS1SP4WeG5PI8t10xI5G27S5CLjI/Bq/vj6Y0msNgof11/zP4C+gjD/hFzKdvtP8o/5H5W /wDBXzXItM8BSNdqstsdIubSUXK7bfzWkiWNWHodwHPqa/l51mTT10TxJb2yWyzX2mCS0LAbIdnl giM9gQD+dfpP0XaThwAqnd/kfi/0sqyl4qRpX1XL+KVvyPw8+P8AcHVPF2s2d5Hb7LS+WSMQkKiZ giC5X14/PNfIWtyPFIqSoG2kpESOSBX8kfSYqc/iLWX91fnI/v3wRgocA4H/AAr8kYzO4UPgJ6Ku Mtmiawtb90jvrmW1icgSTbTut/8AawOeK/nGb6H7JzWkz//X/jHhsbaGHdY3bz4lYyebxLIo4DYo McUwCsfLIOVLHGCDXM2luRB3buaSBHjciQtIsWwE98f/AKv1pv8AaN3bhHjRQ2zymRlDIVxg5HSs W7u5ZTnMLQq8ZVGbLP2KGls4bMadNDGkn2lpWledmJDA9hSMpL37EbXzxIIZCjAgKpZeVx71SuNk jgud0sq/K+Ow9D7ZoK5Fc//Q/jA8vyFNxOqP5SbVlxyB7imQSiMrKuYgh3HI4fPrXniSUdhJ4/Md TPsCu2VKjgj1qldXCwSgWUIQgBCw/jxwSfrUv4kMsvc5snFwsjyDGwR4YH61ft7Nhbo7uQpUNEAc nHXmqNKaMyS62FoisrlHJAx198VM4ddjOuUb5gD/AA+5HaonsdFNH//R/i7nV0lEblWYxLIuzoAR nFEjxxhXkjWQEhThiFb0zXkJ2O9u2482luwSFN5gRvNZCTgE5yPpVGfy452EDhFC/dBJx7A1aUdU zK+5PLIIk8zEs2+I7MHHOO/0/pWdZXck2LWSSXyJOSWPUjoPpWZJII1DyFfmaD5ij9AKd/aCKytN FE+3gIy/IR7igV0nY//S/ikxIZ3niPlo6jcAegHZa6C5dRpsl5hpJIgiwW0Q3vLngn8OM/WvIs7X OgxY9VE0TQxhwxGGwMKPQH8qhnby3QeUBMMLuxjdSKiruxp2U9s8UkcibZU5DqflH1FZA865uIxs kk8iTcI0XOwdO3rnH41UPiRrZXudVC/2JBHLHh3PKMOUHrU9wqeUZSHfaOFj5Le1bDP/0/4v94jE lvb5DTgeaHX7vPAB7VQuo5YFICoyk7HkXk4rzpLQ9GzexWgFzGmbNtkytuyyZB+lKbJbiB1ulfz3 uElD5wUC5JH4nH60R2Q1Bs1oLKJUUJMg3NwjHDKPU1XkeMXLwynZ5ZyOM7wDg4qZp6JCtrYrkW8N yxQFIpn3+XnP4DP4VfllWaMRKjCNjtcOBlh0wRWRsopH/9T+LH7IqII0UiIHG3dk4H+RUlvYWpdD btgMdpBOTnuM9q82GyPXaTVh89uxDxum3b1Gchhz0NQxRFLbNvDiBWG9wnIY9j9eaoXKrWNW3uVt isbSbGfHybdwH0rZBtrg5t2VXUHeknCy49PerprUeiRj3cKW0ylEEZY75ABjOe+KimB3R3TTuTOS p5JJx1/lW8fiRjJ3Z//V/jSsHUxzNFAkbkmNFQ43Y43H68Gvov8AZtun/wCEzuZPOuIn0ixhu5mM HmfMsrcYPb7oz0+bnpX0fCMOfiTBx/vx/M8Hj+oo8I43/r2/yP2l+ENtdap4n8HaXYTPGNT1ez1C eOP93EyW8yTSRD6qG/Gv7sP2K9MS0+EHh1iztd6haJbANH5ZhjgjWMDP4V+/fSJrKOSYDCdb3+Vv +Aflf0Z6M1h8bin8O3z1/wA0flp/wWB1cN4cudPTUEsBqQGlaQzSEQrNGcMoI7kgkV/I/wCOQmj6 QsMaQXawWsu+GHzDJas21QzMRggEFiATkDnniv13wHhycARt0uflHjLW5vEZRfWx+IfxEvo7PxB4 p069nklu5b5r1L1SZoJGncsASeQFHAA6YA4FeDm5uUmkjlbzFaQb2x8px3FfyH4mT9pxdjH/AHn+ h/V3CSdPIcMl/Kj/1v4gNLtzdOqeYFwM7AfmYfSukVPKiWP7rQ5eNFAHmHvn2NZVVeJ2Qetjb066 jNtELryY2ml/eQKeMg8HPryaatxZmadYfM2PMY0Vk2hcccHv/wDWrz6qvoX3Ok05yW+ywvEH8vdu kyu7/ZFdfYIyXcQuGKA4J2DcvA64rgmhmwlzt85Mb/3hYbuCT3NYl3rM5+1W01ubOErtkmhlJade oyMcYrGXwmkYu9z/1/5F9OdS8ZzM8YhCfOxO4dvxresxbSzgalCXt0yI2H3l44Ge3OK+PPSl8TJz Zz20iSpKRasCFhVM5z0z7f4UyOyjfUrDUpZpLT+zpjJ5sQzIMjGce3XHtQSUfst/fW894bZLmKK6 ZrfUnm8q4Rt/ykR+hGcnr0q4z3CkICjziIfOx+ReO5FA763Z0Wkm6vdNNuVFpdzEww7JQYd2cZ3d gev41ZurW7tfKBjZ5LUCKfy8urMvBw3fmpqpJI0npE//0P4s5WxcwXNo0sccsiygSqYpIwcEpg8g /WuuTRbLVbWWS3nFvNCDLtVtoB6nj8c/jXi1PjTR5FJWkzE06yNvLMl5c3XnbfKtiygRHBJz7A89 K2Bp9s6o9ykM6xtkPnJQiqNyhqEUupTy+Sypb28YC26gLFJ2LHvke1crfR3tvLZSlWitEkwZh865 yMqy+470GlPsbGorcXkc0mmY8lFyY5SImx0IP+ApdP2AZuIIY40jCAInoMcelBof/9H+Le2nlvBO UgSGCyfMhDfMQxwO/P4ehqxOqywhpbjyYmyqknaCK8umjnNuMRaXoMMhukurx52haBtokiQAFHA6 46j61BdzWWtRw3KThJLdfJns2kH7wnGSB36fhXbT6AQ6np8sEVvPazInmRjMcJBeNQcMCO3Fdl4c s7WaES212ZoBcbRHMMTAgDO5fQkYz7V2UtHoBwnjW8ufEd5LefaHkh0+T7JE2wJ5ZQ+vfkV5ZqMz zS/vQqoAEd+gYjjNdi3M0vfZ/9L+PH9nmGQ+MbeGzskuPJtl1G4LkrOY0fAKt2ABYn8K/eX4TmXw 3b6frN9BB9lk00xWaXEqh2YR7RJG2cjJUdR0PFf214ATc+HMXST1bl/6Sj+W/Gm1HP8AA1papOP4 SP7Xf+CWWrHWvhJoWoXcdu7XunJe/ZLdwTbKzsnzH22Dg9cD1r3X/goR4fXW/gl4jimk8pbu2eNk jwC0axtuBz2JVM/Sv5nzhzw/iSufeNZX+UtT+m88ccX4b+0htKg2vnHQ/hv8UvHa6vrFoj/2cdJu GWyltbcFWUEmPljjae7ckDsa4XTLu1iupC0/n3MR8x5Byp3jquO3J6V/pzkdSVXLsPUlu4R/JH+U mdwVPF1YLZSl+bLmqahZ3TWVqH0ye5LrJLdBz9qKpkmIqe469O/Wt/Rle/eTJ023Jn861vbuJXQF BkozMD1xjGccivdPGfx6n//T/O/VdSuP+EgfV7JCr3NmYNQtIQv2GKUEfcXHKlfX39q5K2ijN4gv o9lvMWafZgBDyePqa/2ejsf4/Sd5p+pAbZpSYrS4MispNulzPtRwBwAWOOwGBW7os0c1rJBLbrbm OT7GyyRBfNI+bchPbJ68ciuiLutRXSbItV8mFoorQ7I4ckIrnZvY/MSP89TWvpF/a2SC41LUQb8T rBHYrG4W4h25yGI257ev5VRlKS6mZ9oVbh55Y2ZFBZUQZ7/dBrq9HTTblZPKNvZSXAJLXQAjjbGQ ScewGRzTTs7mfOuh/9T4MKNqELw6rdpa3EUf2aG7t/nWKJPuhQQR07c9a466i0e4nSTTrmaW1H7u WaeIQl3UkMVXsOK/2uUk3Y/xulKxu6dpqtDHaw3SbjcmaBJwgiG4KCBwD2HUmqlzpsstybcXkcRb DTKy+cny54JB9OB9aozVQmksZT9n8ySNLZYGCpEQGyvGT+X61nTSWsSRi0nYXScs6A/M3cj8qBKX vXZvaZewT29vI00d+85aK5UExCMjjJbpyfTpV7RBZWTPNd3XkC5UxxoW3PG4bGEX0INbQ+EqUmnZ H//V+A71rK61GLT5JAqR3AdbhozGwGQQ5I56DOPrVy+m0cObyIwzXUbIjWsjESXYUjMjg84IB7/4 1/txY/xpcm3cxdN06wvV1OUWd39uOoFcWtzsssMqthI8E8Zx1q1dG2MEVviW2trOTyhbumGznBzw MnNBM5dWL4lsJrQWMdghmt2gN35UTBn3YBUlc9SN35U6fUYjbaWHvI/MuIlkv4baN/OsyesbggDP 0yPpQZOehSvNXvkuL+ytbnzNLnkSKMyIDuAAywXsTzzzWi0WzS7Nl2iS0u2lkjlOLe8QgYTjnI57 85HpQcrbbP/W+E576K/0qOxmsLbS9Mtj9pTyht2MCMkE8nPTAqta6nZ2lu6CS2iW7cWsCTRiV3Z8 hSuQea/28jFNXZ/is2luNfRdSsbWO9S1il82RsXsm2VQB8rqg55HP+NMFq4gWaMSeb96SNiWLDGe B2+laGcpX0JrywtpFivPLIDxbSZDna20ZGfWobLRYljjv/OnjuJnIgiSfbC4HBLp+eKDnnvYkuIZ AYcIF+YpcYG4yc/Kf51IGtU1AWd3O9raxWxcSMp8qWQg7BxkjnHbvVqF9zNtLc//1/z1mle/toba /TasU5eRbaQqrYJAIbryAOD0qe0ttQity9iZo7cymKKbcS4YepPXqK/3HiuVWP8AEPn8jXvL27v9 Kj064mgZ7TPkzZwC2fmGRxjOa56wi1MMxaQNFHwNoIX9aZnsa8du0kMs1zFcGRJFMSQPnIB7geuR x6A0yR/st072dsCYmSK7GOQ7/dJ9+c0BdG9c39lMTbu8UV7Zwj7QE+aRnPJU9hj+lcWl3Pe3TxFZ /ISY+VFJISp9/T2oJ5lex//Q+EbSKa2t8W8YBdistuwBjAJ52/r+VQTpBd3kmlzxIRHbiaQ7+Gyc bevY+lf7lxTTR/hzKV9DWi0qC/idYLUiWO38gwHLrJgYDA/rineH4JrG3mtJbL7LJFLuVLlVd89M 5yePY1qZybS0KGoaHevfWcsqQraedunHmbftYbnai4rTu7eCeee0t400s29qslsrKWSRQAMKR6e+ KDmlJpmNFJNEFliYSMp2tJKuQ2PrUtxqlzPq1rZJbRWenPKsslzFcExRltoYmMj69OwoMj//0fgS 7uIrG+1LT02X85DRWkzqyiMq4w/446e5/G1JOZLIXAh8+a1VFnRGwAxIDEdwO/Pp1r/daKSP8IZS uzQS5srW9dJcItxbASJgeay5HP6cfzqvcw2epz7LZmW1hYNLOCYpECMrAFec5GfyqZ/ESOjeHF5b pukW2VZQZIySQxIUgd/u5x7Us8mmxRieOzeW4Kr9oZhkcegyeKzBK+h0Ng9gZ0ltUitBNbpB8oBn nc9QfQA5x1616Z4Nt9UW7MflRG3WJ3mGN/mhmVdx9MDgAfiKCcWvc0P/0v1c/wCCUur3UPiq80ye 6i3WetKoKQ+WqKU3xx478MoJ9RX9QU0iyaNIfmRZLXBMfJG9ccfnX9M/SUhyeITl/W5+IfR7k5+D uCT/AJf0R/Hx/wAFPj9l+P8ALfEgJY2cmhoowLi7kkuw6uwPO0K7dP8AZr8y1E1ndSsSyMxwkezA T1znmv798GJc3hxln+D9Wf5FeOkP+Nn5vH/p6/wRWnuFkeeWYtJ5efM8pwHb2B6elUbC0jkk2xuy qwLuzngD/Hmv1LyPxmUWpkhKIJIt33vlBxya0oZ9Cj0K7t1tryTXZJl8u5kn/wBEgRTlsJjqc4xn 3yOh1hsRPc//0/EbWO3WMPIoO75gRwwNegeEdHvNbvILTTbea6dnEgWOAzLlcEdscevav95MZXp4 ajOvVdoxV2/JH/OJlGBxOZZjQy/Bx5qtSSjFd22kvxP6Gf8AgnZ+wAL2Oy+L/j+AJb3Vwt7Z2s5x cOV+XZFGPuowAJLc8/l/QRDBDbQxW9vGkMEEYihijXakaqMKoHoAK/yd8d+Nq3F3GVanGT9lSdl2 u+3otF21R/uh4LcB4PgHgXC4ClC1SUU5OyT876LV7vuz82P24f22PC3wi8Jav4P8E+K/L+Ik922m Ty6dEJ5dI2qC6KSMFyWCkr93DfMCK/CX9lz4t6z4/wDj74Qv/EF5f6pqdtrsr6hd39y0k9xmUuAg PRR85IHr+Nfq/hRwLLL/AA6x/EeLjadSD5fS3/B/G3c/GOLvE+hm3jDl3CWCknCnOzafVWf5przS v2P6/wC1YPbW7gYDQIwB7ZUGvLPjb4Dm+Jfw81rwVDL5B1pRbvPjPlqQwJx+PqPqK/kXC1vquZQx H8k0/udz+v8AH0HXwdTDr7UWvvVj/9T+uLTP2P8AVvg1osXin4eeOdRXW/D1qdSvdOZWjttTSIGW ZBtbk8NjI+nOK0fD3/BR/wDZxlgl0vxV4ouNF8U6Rm21jT5LEuhnjby22ODjlh0wAM+lfslPLcb4 g1KuMy+n+8pNX84vronrp6LufkuZcR4LgSNDLs1q+7Vi1HRaOPTVrSzdvyPN/B/7HPwo/aK8YeJ/ j34rkn1C28WarJPpsFuUZmB2lnLMpC8FR0OMnpTvi3/wS5+DHiLRbyXwMdQ0HWVUSeTK0dxbXoUH 5doQAN+HPtX1E/FXPOHcypZdd+zoWi46p6Jf1b8UfBy8FOHOIMklX5V7Sr7ylZW1010f39LvRmh8 If8Agmj8FtB8N6W3jKzudW12BjJI0AjtUiIO0A/Kc9D6delevX//AAT3/ZpvbeeFfClxbvNGUWZJ 4pPLz1+UxYOe4NcuZeNHEVbHSxOFqWhfRa7X9Vuvu21NcD9H3hH6hHB4yiuZJXaS+Ky8n1+8/FH9 sP8A4J76/wDCr4jaZceFoLHVfhp4qvIbWK5W0+yTaZtZV8uUL8oYAeuDjI64H6ifs1f8E7vgNoXg 3SPE2tafPr2uaxaLNcFnjFnalWICIpVv7ozjFfp3FvjTjcX4fYGpg5fvZ+5LXZ2d77dmv6sfmvh7 4A5bk/HGY1MbC6pz5oXja6v7rW/dNeuh/9X+9vw14b0jwlo1joGhWq2Wl6dF5NrbqchAP09OgArd r28VXliMW69R3lJ3+Z5zp8mC9mtlG33Hyp8Rv2L/ANn/AOKFzqWoeJfB0Z1TU5nuZtRs5RBcrI4I Lg4P5HNfyo/tjfs/3P7Pv7Ql58MPCksmsaPd3MmpW096hQ2kO5WZNyrySHAVQOoHqa/sz6NHH+Oq 5hXyLMJv2EIXV3orXt+Ctfsz/Pr6WHhrhaMcBneVU061ao4tLe943fo+a7XRrTsfq3/wT8/YE0vx Polp8R/i7oElqs1sv2XT1g8k3xzxl3XOAOCQPyPT9dIf2Tv2fYLb7Knw08PmMkFzJb+a8hBzli2e T3r8z8WPFrOMw4vxFDKa1qVN8t11a3XXRbd000fvnhl4I8NZTwhhP7Qw6dacVJp6avr0d3vq3vc1 V/Zm+AqI0a/CzwmgZxI2yw2FiOACQRxjtXE+Ov2Lf2dfHeh32jXvw70fS/tVu8MN5pMXkz2jsPlk UHKnBwcEc4r88wniZxPg8XTxLxEpKLTs/Jn2Ob+DfB+bZXWwDw0YOcZRUlq1dNXs3rbf9T//1v2B 0H9gqL4bftN6f4Z+J5+zeApNeay0PVntxb2WoWZdHUq7/uxldgIUnJUjqCB/QjpPwA+Cmn6PaaXZ /DzwrdafFbqkEtzp0d7LKuBh/OIJ5GDlT9K/qfxU8VM2zihluLy+s1GVN3a7x5f89V3P5B8E/BHI +Hcsx2W5vh06qqu6a6O9v+A+x45J+w/8EB4+j8Yw+HYltDiW40RlD2JkUkjYMZCnjjPHOOvH0TD8 KfhnbxxxReAvCaJEnlov9hW7bQPcr/OvybG+I3EePpU6dWs/cVtHv5v8Px9F+15T4XcKZRVm8Lho pTbdrbeS/Hfy7Xfg37QX7GnwW+OngbWvDt74N0XRdbmsZBouu6NYx6bc2VxsIjLBAFZScA7h+PFf yP8A7QX7N/xL/Zx8c6r4d8d6bdabZC6SzsL3y/JtNbtWGyCePC7WJVGyf9g96/q76MvibWxlTEcK ZvUbnLWF+/b876dIn8DfTH8GaWU5ng+O8ipJUXaNRLo0739LWaV/5iD4FfHnxV8BviNoPiXwXOkB tSlve2ohWIXQiZTGd4x+8XHVs5HBr+s/9j79r3wt+0x4OguHubXTvGNoTDf6VIy2813sJUyJHnrw cqv1AwCB1/Sj8PpYrCQ4swcLuPx2Xpf8r/ej7/6HHifQqYOXAOOnapDWF3undq3pe1ummutj/9f+ 8zxp4G8J/EPw/feF/Geh2Ov6HqETRXFlfRbwu4Fd8bfeRxnhlIIPev5Uf2+/2AfF/wCz5431Xx14 HsLrWvhL4huDc2TohmOiSnGYp2UYVucgt975iCcED+vvoveIX+rfFv8Aq5mE7YfELlV9lLpu9NbP yXMfwT9NLwt/1g4ShxlldLmxGHfv2WrjfR6K70utd3yLoflHDeNGWurNZIJLqMwtASRIAeGVh71h vIyyKl1GVUfKAoAIGSTgfia/09pO8Wz/ACPkuV2KSRq8rhcnBLrk44HP8qayyFG3sNm/5Bnpj/8A VWplLdG1oyD7ZakSGOSKZZVdQGJKHI4/AV/Y1/wTOuLWb4Kac1uNy3GnW1wjNFsdEZA+D6ZDLx7V /KX0tteA6T/v/qj/AEK+gErcY5n/ANe4f+3n/9D+2P8Aa2t1u/gZ4zs3gEy3mnvZ7iCTAZEZQ/Ho cH8K/iB8Q3dlpniR7BraUpDqM9iH8vy5y7AkGUZ+XlhX+hf0PZP+y80gv60P8tvpzQX+u2Sz7RS/ GR/Xp/wTeiWL4PWTwxiOGazgwiv5irhE6H8MV9OftRBT8E/G6lQWbSJgrnpGfLfBr+aeMH/xt2ov +oiP5xP7cwsEvA+y2+pT/wDTcj+ev/gmBposvi1qujXl7BLe/wBqi/kaB8bmkRMsD77O/qK/qN8p JrXyT8ymPy+TnPGOte/9ISX/ABlOHl0dOP6Hz/0aYW8LacX0qVP/AEpnzNov7PFjY/Ea+8c6gtrf NdzB/LkjDBApBHBHt/ntofHj4++Afgh4X1W41y+/s27XTm+wR28SoC5UhQgyMtxx2568V+bYOeP4 szXC5NSbbtGnFb2s1d/cr28j9DzjEZZwJwxjc+xCtCHNVk9rtqyXzbSv53P/0fcf2oP2oPGPxh8b 69dy63f6r4Xjv5YbG0lCRRzwB/3a45xxzwevrxXyKJj5Uk7QxNLcJtJcbmjGeo9CBX+5Hh1w5R4W 4XwmU0o2cYR5tLe9108tF8j/AJwPEjiyvxtxljuIK8r885W6+7fTXz1evcoEwmNyylpB9xEGNx96 z7RYFaQNa+S7SHflMOxHHNfoB8K1dWNB0tdoUKcg8qBUyJHEnmkJ5akKEJ+duvP4Y/lVR0ZgMmnj QGbhYQMnsFp5HmR7yQQy7lweRWwH/9LyeIhSVZexxxknimuGijGdyrIcjcMA1/0IH/L+WCxaAglc phcLj5uvP/16ptK7oq5JWM7Tn+HvQBOtpJDuYnG/ogOTj1qKWPKgYOQc896C1OysP3vsESxkAjHA 61T2AFJXmSPc5RY2++2Bk/h/hQLnkf/T8pCh08xVOEHPHHFNtlAlVirPtYSFSeo61/0IH/MC5Nqx NcTWnnFijRRu2WUfMVHt0qvG9moeWMkpk7cjBx7+9NNx2JII72C6+VXZlDZKjK7cHv70+SVVO2MH 09xT5tGgIIrJ5bnzcT8KVVEcqM/Tv0qb7W0EpWSI7SpUu3TuP0qQP//U8o3EEKh3qRuJ28e4/Cnb YcuRn5ufTPFf9CUb6o/5fxVz5ZJkAUHCrjn61GzIG3qROUOB1CsP0NOnvYCtKCX3qhQP0BOStRmN lHPaiWrYC7JCAWB29N2MCrYlMahQVznINTFXdgP/1fKYkRW86UCUFSPKbKjOODkc9f5VTW3+0Pl3 CBAcpnBwBn+lf9C8drH/AC/liK7iC7S+2MfKr+vXFO8tjllfIPf1rFqzsALASrMTgrz9asxy4UKx LEDAzSAVlkkjYyMAwOE55AxVGaWdpIoJd8kaoQpJyiYI4x75oJ5kf//W8tKxC1EpvLfa77BEr5kJ BxjHaoYpmyUEbBV6Buc8V/0IH/L8mnsOLGV2wmMdxwBSSq7Llifl+Xg9qBj7hBbQ26jYNqbxJn5g D61GqI0Rll82fzF/dmIgkk8Ak4PFADEbZEyMG3g5HHar1pOfmcNs4K4HfIwf50Af/9fygLEk7RIQ VYbyAOR64/On2R8mYM585RJuCyAHGO3Sv+hA/wCXmTuyxcTO8++3jiEcx2SsUB4B6LxwaSIqsjLt AIOFPfFAKTWgslpKwklKkwhtjP15OeP51UtbIO/ygkA5I6UCcmydVuY/MgiLxK7FZMN8rc9D7VVu JHtMK4BDH5XQZGfQ+lAXZ//Q82kjQLbOXR3dA7qoyIyegPvxUcknlq+5QNwwG9Pev+hA/wCXqMra FS2snVmkCvKXBYKWLjj2z7H8q0beFJVlfYBGiHzccHJ4X9cUm0tGJybKBg8p8xM209h0qyFJU7zg +oGMUySB2aPaR+Ge9Pt1WXzC7kgr90nIBxjj06UGsZK2p//R8k8ohzhfkz1p0iFFKtmNW5Tdya/6 ED/l8c7bCrbiQkhiMLgAd6vCR1jRN+Ci4UsOQOTQHOiJZ8qA25mVjvcndwenFOa8GwooClT8rdzQ Ln7DraYoGd/nAyCcdc1H50PnrLbAqACjoxDB8jBB/lQQ23uf/9LzeOSOMsUUR8EErxkVHBOI3keN cBj8xK56fWv+g+WiZ/y7ksUgdmKk7yeO2DWRerJbXqxvG0pIMkz9UTuAT6nNJxXKBpQDzXkktEdB FHulBbKgY5OfwpreZPBOsUaFyPmUgbzg54J6dO30rJJ9ACBXiiKyEocZ+n1qPYwRyeWLbg3QnFDd wP/T8vtMXm6G5j8lkkxG8hADcdc0s25EdIyG2/KxHSv+gg/5dwSMLEF+XzTyGDZGD2xUsCta53RE gsc7x9/sfwp3YEjhJ1MihEZeNgXHSq7QIVSZN6SKMMmcrSAcDK8ZUA9eT2FSwRxxQXdtIWinnuFY S45jABVlPGcH0/8ArUAf/9Ty0xpDEu5T5pfGeMEVY+zwuN5iVfkHyqPvnHU+/wDhX/QQf8u4kbmH dGgBDEEjHP8AnrV1tssYGdu3pgAH86BrS5mSXDQhokcKxBXGOealjvbq3+ypcWryR8mNmjxGe/f6 9vWgcl7xbeMyE7I9rFSSAMFu+f8APpVSNZGJSZ9qqTjHJwOwoKhuf//V8olF20rmMKsKqFj2k739 Sf8A61PjtmOPMY7ug9jmv+gg/wCX8GR4naM43Lz+B6UrJJJGXiQfK4Vm7jP/AOo0AOMUQjXJY3Sy fMHUGPb7e+c1F8q3Rm+6vm7/AC14Rf8AZHtQBLPambzXAee1z/pDquxUDHG3I/AfjUXlwDi1zHEO GUnmgD//1vH5CM4y2BxuzzmpoEdm5YtGvVQPmr/oIP8Al/LLMjyMUCDA8t8LyMAfrVW5uFUpBb7l Xy8SNJyxb1HtUyV0BIZF8mOAbV2AtJKoO+Vu2R/h0qFCzkGGTEifMeen4f56UpRVkjoH/v41dUCy GT5XJXPf3oaJogBdJGZvLICq2VjDZx06Ee9ZtWdjNNKTuf/X8hCRrGFYhx1PHKfX+dTQRo5Q+YFj VThfX0r/AKAD/mGTT2HwxSK0gjjVxJ8pyAxUDBz7dP1p8szxNlQcyDySVXCjtQKTaWhW8uYZ29Qc kHn64qZGlYHI+71OOaDLmfcVz+78sENuYH5ueaUxu7w73WK1U7Z9sQZ8nkY/I0GkZX0Z/9DyqSMc sSGSM5VT196ia62FpIolUsvAC4UcdhX/AEAH/MOFqoeLzp2KEtlgRll+napZI1cGcSoEjwse9wsr fQZoAjGZR5Zxu9SeG6U+e0a2VVYJEFG5jgZ555NADVZGQndhWXAI6GqoVUZ5CDsj43dqAP/R8ce5 Z4XhjVRFI6vKwjG9ip4+bGf/ANVXLb7Os0UshZox/rVTAb3xX/QAf8w4t3FE6QypDGFMr7JQQZD9 3IOPoMfWpIj5SOpBNAGXNLE12qr5nkbx8wADkd++M1oRiOKS6ihkuGtWceYtwoDZAHyn261LdkwF nvViEURhs0VSdojgQNIO2SPQYrOO0kOzHAOQq8ViB//S8cCs43RplTyCB0pkkbSTRhZBF0V+SAfc /wCe1f782fU/5hyWR2WZZcljbjbCY8qPTP4+9Wt4mj+5v28tkYGaQFW2kQSTZiQxFCgQ9FzkAj3F VJLdBIjBiADnPQk1rDYadndDzJcrKpt0BdSNrEeYD9VpwldJN0ir8xywUAD3wB0qwbu7n//T8XdB dOxTKqrcL2FOijAk8p94zwuzqx7DFf786o/5iE7O5ZbbHjzlKA8DjGe1SrfC0JWHZJEy7XEkYYsO 2M9O3Sjmfc3K/wBrB3GYjJHyr6VRVQSZiUCZKLHt+ZiMYP8AOl6gVTJPNIYREWUY+fIxH6k/lill gG5vNZfKiI/SgD//1PC7xPOiJjl8qMAZJba4H+RWx/ZqGzt7h5AUnBWIls7ymA30PzDrX+/B/wAy cZ3dmR+THCHjjy0RXK+uccj+dYyziNmjZMHOD9aBuaRenhga2icOTcEkMAPlVR0yabFI8eI1UsWy BIfu+1AnPSxWNmZZwnlyGUP8ipwJCeMY79qvQeXGMMnlMp5U9sUApvqf/9Xwe7y8ouInCFH5GPvd qVw8mXK/MoyVA6V/vwf8yyaewscCSATOGUKpUKnAY/8A66rxx+VKxaGR4pRhXPSNgRQMuiGIKXIX chz8ygj/AD/jTliDq8gXb3BVdo/LtWMm27MCqY0VvPRvmUbTG54J55x+FNdzPbxtM2Z14l2oBHx3 FJO2xpTR/9bwEQRTREDG5eFAqhFAIZyIfvD5myuN2eK/3xbvuf8AM+bZuI5VjQbwyx7X3nPPtVUI QsiPIAmCyIcgg+36UgL1ldWkbw5VfNiw2CuQ2D1P8qpam1q11KEXbBcAM0P3UDH720UFw3K8/lGe NIoxCgjVDsO4dOT/AFxUcUEcK3TPO6xsuCq7i8gJHHHI9fbFHkan/9f56aGSAZ+XG0GMDkgY7+9U BJFcO0flkHG5X6YI/wA/pX++B/zTkyRSW4Z3KTyGIj5wWBJBGfwzkfSqttbiV1N1IfMCHIi42df8 KadmNb6mhLLLZPA8PlujtskVxuZh0P061BLL5crJ8y2rP5gTqR6Z+n9aHub+giWzXiM0MZKcRtIv zMM5x/Wn2lnFbyTKn7yd1+ztJt2tGO4x+JH40gP/0PmpofszuqyLtB2rGRzn2/KkWK/LTXDokluk ajGMbCTtDdfXFf74H/NeULqV5pg8jh5F2q7Y25wAB+gFakRZE57jFAFNllt5PM8ty3+sXaucgVcv bZX02HUEglWWeUByrCPY2AcMvXpjNRdc1mawatYp22oahZSRy+Zs8liiShQ6N/eXPrg/rWvFPDdB jeLIwZCE8tgjE9uSDWb3N77WP//Ri/Zesg3xZ8IW9qsmz+0mkuEI3I+FyCST2APT1r+4f4DWywfD jRITtQxWqJIq/wAJ2Aj9DX92fTFqJ4rBUetv1Z/CX0FKMo8J46tbRzf5I/FP/gsmFbwsLCdbcxSh UdLn545i0xw2PUAE/wDAa/l+8TWsN/oOo/2eJt7xLHYwRws8qIHUs+egGASfofSv2X6MdPl8O4du Zn88fSrnzeLyX+H8Gj8Mv2jbiw/4TS4u01OaFZoyiW8PySSOp2b3A5x8uQD2NfMM9zJLLEZpzcIg 2AvySBX8UfSMk5eJWL8rH+ingyrcB4C38i/JGcZC8+wLtCyZjb+7irnlTs04nbzPtA/dl+qHpmvw Ce5+sH//0v42Da/2b5cjsA2fL3H5sA9/0qvcLH5TSkq38TMMAY9fauWUboxh8RWivUjiKiNZGZs+ ZuIIGDxVqIi7AG8QnsW4VvasTYSaytpGMUyeaNmWAJ8tvyqOR0h8oiJQikhlBxkdP0oMbWlYktjE 1usQlV5d7MVaMN5QJ7n37Zp8qi42IiRwmNChdV446Gg2P//T/i6KXNnEkP2g3bFNrO64Ykdz2/Kr tnbuYit0yOWBzhcY/CvPAqXAjhZVYsxxkD+7ilJhCRkRgvIcAkZIP17VlPewDzHAbd3SRWAJD7W3 KSOCPwxVUaheEQxQx5IbZHHI21HHTk9uKtSTWpvFWVjRWNTKbphFzwyp9wfT8qhu0aOUNHlmkUYZ m+ROegFZylc6IrlVj//U/jBEmWUSDdJtxnrwO1U7s+TJGsgZYmOZQB075NeOdk97GuVinsh9jZWU nLSd/pmubuUWC4QyEtjGVUdKDM0muLeOBXC4iAyWZs4P0rPtrX7UN9sNseS53tgDuepoA2ngF0vz S+UmAkmxcMQPasy+tYMJsGAgwM5BOPUUGDd3c//V/i2hgkaFnVFlcJiNB8qH2PFUmubmxlg3RgbD l4Q2VT6V5F3ax0LUrWTos5uGjEYPAKjnH0/z0ro7eG3vWlR5IlcIZY5JmCOoHJxnucdKQ46MxrOA Xt9JpdhueQK0zPtwBtBOCegOBnHtWtbwT2N0Lq1DG4thlBwA+OuQeD+PFVD4kbkN7dS3sk88/Epb e3ljIyevFOtHuRceQkkzW+wMfkHznuuOtW3aVjRQTR//1v42Y44nYTTo4lZfLjBUbQBxzW5p+k+G tVvNP0q4nFpeKjTzT3LEWxYkhMt0Veg5+tebzLQ9ZJxj5lTxT4fTwZqtqn9p6ZcNcQ+ZFY29wl6n 3vlkLj1x90+1crdTs00kREW4qJPOB2qGbnGK0lHkfLe9uw4vmSdgt/JhYuV87HOfUimXCpOPtBjC uy5A64AqGLl97mKH2KScKzSFpQ2YwBtx7VaDLbxuZmKyMRHGH6Z/xrKNrO5R/9f+LC4URPCYp9zT pmdXbHlH0H5dKit2aKcxKNysufMPRevSvOWx7B0DI5gBkC/KMsQck+9Q2k6uGgXbJB94qOCCO9MB 1xEvLYJdMY4zxVJrnJZvlUxnIjJwWrWnsTL4St9ouLtjJjCxjY3OcgdMVo21yVQQyqsqcsQVy0Y5 rWPxIxP/0P4xrfUraHy5QhMLEhSFIZXzgBh6GvrP4IaVC2taXfvZSLqWohILia2L/ZpItwXDt0U5 ZRz1zxnFfXcE04z4qwcV/Oj5bxIqez4OxjW/Iz9vf2erGSPx58PIbSGJZ7jWYLz+zt/mtbxZ2uxb kgBST78V/dZ+zck9l8LNJlMBt1lhFxYRD7kcO3qPTOa/Z/pGtKOX077Lb+vmfB/Rpv8A6v4yS/m3 +T/4B+GH/BZnWIdR0bU9Jt7S3a5tE/tHSo5AY0ChyZ5FHduGAxX8o3xO19bvRNQmtUvB9ktBNEkU YRSjFQ5kzycZA9Pm61+6+CdF0PD676pv+vmmfhfi1VWI8TIQj0aT+/8AyaPxk+JmoWF9r+otbFJV j+R4XALRt1+bvnp+QrxqPHmhsAordG9c1/FXiBNy4qxr/wCnjP7E4btHJMP/AIV+R//R/iFsIWgu Le7eTDwt5sSxtjnoAw7jB6VuyzSTzpOAmwjDMAAUPfisqu1joTVzctoofsrO0SMJW2xzscSKR6DP 86kkiktfLspbW3aNszLfJITcHcFHlsOgAxnPXOa86q7G61udDasyWpW1tImktwHElxJnf0zz1rct tfeIIt7ZjY8gjE8akEZ4IGTjAzmuCe9jSC1Luq6jYIsKW0nnkP5ny4D9Dx1/rW1pto2t/ZYDbRrN K4jQsfvHPyhuw5rnlK+iNT//0v5K7rT9Q0yZkaK3O59jxiVWlhAOOV6g8fpS2si3JnhRw5h4kQHA XHJya+JlK56UviLpu7qKEyOWKSfu1VMELjpRayR7Xku5GtgeI1lICt+vBqoz6MkWd7xNiW6xzWkm TK8T7niH9519P8a3IdHskSLy7zfLJFm5jLhmJ64A/AU4yvowHvbrDCYUc24J2xEckE96tzX97DBF HalrrEqi5IlH2jP9/Hcf41NV2Rbu43P/0/4s72y1ie7WaZ4p5Nh+TzP3cXOOD7V0+giyNlqYuNRh sbm1iDRpcv5QmbPzAH6eleLNXR5kF79jnvt99qFvNe6eIb2KGXyGaWUxbSvBAP4dhT4ryOBbtVaY ag8KlLZ4m+yZbOcP/gKos3rJ/Kmgl2xuy4MkZzsk9Qfak1KCTc5jVTDLFuOB8ik87QDzxQXT3MKB bhI5o2OFkXGVHK/Steyis4LKWO6llkkcfI7ABkBHIx60GjaW5//U/i3trCa3tZ47S9iz9qM2Lpdz eX/dbnnHIH16VLabbye2tby3hkW2+dbdPuyDJyzH36e1eXTfQ51rsZ91bHT5ZFCFTJJ5h8xyTg9M enHaugtNKjaN5YowsoXe/lr8zYHWu2m9gLNrAGtp3Nx9nd4Gkhecfuvl65/Kn6BHcQK80LSQGRzD NzzMo+6y4PGc1109GNLWxkeIQjKy27/dJDRqMByTyfrXlNz9n3AXALxPJhlH8Pv+ldq3RFrVGj// 1f40Pg5q02neM9Nk0q7kRHCwX275I1iLgEHuRhunev3d0UQv4P8ACDQhtYN1p0F3JkkvKfMY+Wi9 RgrtxX9nfR3mpYHFU30f+R/L3jpF/W8K/n+LP7HP+COniia6+FOl213CiTvpUaXK7dgs2RUHlJjr 15981+jX7Y2n/wBo/B7xajosxOmiK287O1cyRhtuO+Gb9a/BePKUcL4pSS29rH81+h/RWGm8T4T0 5dfq8vvsz+FXx1pdhpHizxLBexnMOv3VoNNErSiPY5LR7up69eK8lNnJperWUtnbwzRiVbmeCXJM MYyxBHQ9MYr/AEg4XmquS4Wp3hF/gf5ecSUXSzKtT7Ta/E6K7v7XUoLrzbWxSGW7MwdYFWWHPZXH KgegxUkVvaRaXLFIz7I1UW7I4aIA9QfqPT3zX0h87KLbbP/W/On+0oYNkenNI0eSLlFUF5jjBAqK 8fTJVMdx/ozt88EpyDMcY8rHYnNf7QJW0P8AHuTalcqy+F7C/jsbi58wHSGK2xicxhS7b8uRxwQO vrU2r6bNpwt4JG8x5j5sYiy29WA5J7H1zW6SWxm31Y5rPTLZ7GIGGO5lk3zBh5gZSOSwGefStqy0 2Oea6gaFJ4NgMczR4a3BIGQc9c4FMwnJ2F1W1s9C1D7PbSLttws8cMsguhE+AxDZGCCe34VjWltY 67JNbXDG0R382Ga2X5I5VO4DAwAMjp244oMXNn//1/zukmvdM0xJbxbe5uWlaIQxs2di9HYkdx29 axLqaCayF1bbI7l59psURj5SnktkcY56V/tQf4znRvpUcOlQ37z2sExKhw5YzzA4Odo9BgZ9qrRm zZVNvOXkZyisoIDY65yPY10EQd7odqbrpUVtJNFPJ9oH2RYyCHj3kHp6HqO/X8ZvDNjBHeDUrqBb 2ztZf39o52OAeBu6/h1GRzQX5FQtY6XPdyRq8EElyxt7bGT+8f5f5itAQDVcGGW3sZ7ONpI5Jj5Z c9dvufQd61grIcnd3P/Q/PRLC6uQk1/d7WQM8zQjDNsGenoemapGSzi1Ozmhs0kXUbmDT0mZCUw7 KGck+gya/wBuD/Gc6fWb5NJvGXRRBCkVxgfu9xJQ4JwDxnHXmsO7vn1C6S53G9vLuYxrbn5CZSM5 bHHvmgTV1Y0PsF/BZytrMm+68w7di7UhXoE98etYepaffWZTULWL7dbxxrLemFDJsRsAdPc896LG DXQikEkUVv8Au44llVpU2EM/J53c8fjV+CeO4isw0xjeKQiYOP3YHbaO/wDSnFXdjntbQ//R/Pm4 0iW9klgjaSdM5hUNjzfoAePpTLW4lijhgvNMtoriyfzI/NgUzBgcru7Ejt7V/t+lZWP8U59BkkUh ghvoZL0ahDcFdizgWTow+UCPrkHPPpXS3EmmWljpWiJ9q0/xDLm+u7ya4VoLxXPVcr0AIG3NMzbS TuS6o1paOsUds2pKtv8AaJZoPuRHHTH49aybS8a2jhjiRmWaLKSzrudFzjj37VUYt77HM9houLjz brc/7twEiYr90k9c/lUc/wBkt2kj1LzheRXca5bK+ejheQcYx8wwR6GtjA//0vga3sboi9LWipCr blLSBXY9AoB5PA7ZrfFwH0CSK9CWnlQsbVI41hwTgfPxznHXvX+5B/h1zs5yJNOj0+CJFma4SbL4 GEYN1bPtzxWhb+dJBcwIEFpCRO+W2SMwyAB6/SgTk3oVY55GEjxscgEMMY8sCqENuVWed553mMq3 KRPylwyEFQ/IwBgdvyoJC+nOo61eXkVklncXrIssMIwjMsYUsPqcnn1NaOkXmnWqO93BJM5crFJG mQh6Dj6/zoA//9P4dkuTHFJcIirtO0RS5VsnjP61Qsv3N1dWN1HE83VLuObeB0JTA7joTk1/ugrW 0P8ADc05dXkaCaKytpbEMv2e4ugTG5xkZQHp+NYc15exQFbfzJNyhGkfktjHU+pot0Mp7mxDcXN0 tgzTJbzQyJMJHIZEK9Qc/iKLzUrttVuEee3uQwAWeAYUZXlemOM9hVW1a7HPPcyJrN5ljMbyKYJN 8zZyDnIA/UVPa2aGRlunIhA3F0GXTsO/rikk3sQf/9T4HcQR306SXIuA0vlpcAb3BwDzzWzA9rZW 0ttDEWklQ+dOw+aXPc//AFq/3YtY/wAHzMMcFwskZDJdRplGZOoA4AP4YqBVurW3E4Vo0mOAW6MA cHIpOKe4G7onlCCeeZXZi219wyiqBx7561YvltlVPJAZZQdzjAAHbipjC241uRaPp32u7NrB/reZ UZh8rEEf0P5CvefDlpfwXFuwuPJurM+YZIicNx90+uahJ2ZnimnDlR//1f1K/wCCa9/Be+ObJsrF eyahbLdNCqiG5OxsOSB1JjbjsMCv6mYoAmnNFuLhIcZXnovAH+e1f1B9JyHLx4mfhn0ddfCPB3f2 T+QP/grXos+n/HnRgjMsl7Ne3LXahXETxvCybgeDjbgA+9fmHMZLmRY0cTui5eaQCMse5I7V/dvg hU9p4aZY1/I1/wCTM/yX8fKXsvFXOI/9PW/vSKkWlzbbie5URW6y+X8jAtPkZyPTuOfSsuOU7dsa mMwFjux2HtX62tT8SqP30IFimje4uJRvBEkIkXaZckLhABjjk8+hrQhSJgeF5596uLsmzKe5/9by aw0x9SuWtUYJuUkEqdgxgYOOmc9a/f8A/wCCcP7BereKrqy+I/xAsri28HW4SK10oXASyvgqRMw/ 1aszZ3dCR+85Pp/rz498aR4S4Mqcr/eVU0u+lvzdvxP8ZvoheHX+uniCs1xEb0MHaW2jk79dtEnd eaZ/SBpOkaXoOnWuk6PY2+m6bZRiG1s7WMRQwqOAAK+F/wBuj9sS3/Zj8B3M2i2tvqvie/t2hjXz lY6Z5gKIxTP3skH5unHBJGP8yuEMmr8X8XUMvlq6tS8n5X1v67eVz/VfxK4ko8GcG4zOb2dODUP8 TVo29N/kfyS/Ev4l+Ivih4q1Hxtrpc3utag7QTSXxdEyoLMRwAWO71Jx17D6F/Y9/wBH+LfhSSJT 9tS/iMrlsiNGkCn88tj8a/02z/K8Pk/h7WyzDq0YUrfctfv3P8ovCPMcRnHjRhM0xEm5TrX1872X y2P7P9JLNpWmM5yzafCWOMZPlrmtCv8AJ2tG2KqR83+p/srV2Xy/NH//1/769SiM+nX8A6zWUsIy M8tGw6fjX8MXxlj1TSPjV8R5bJo4Y7Txjf8Am2sMHmNMyMHVXLYAUs5H1Vulf2J9FilTxGb46hUV 04o/iP6XtSvhsPlmIoOzTf4XP11/4JiftbfE/wD4SjSfhJ4ia11DRdVCzwWCsf8AiVIQFAXPQqQq 8HnjPQV/RrX554+8O4XIeN6rwmkavvNeasvytppt5n7b4C55iuIPDjBYnGO84XjfyTdj5b/a3+M/ iH4DfC+Px34dgsJ7iPxDa6VPFfw+bGyXJMYxyMENg16R8DviHe/FL4a+HvGeoWUdjd6pb7poYTui YgD5l9M56f8A6q/OpZRH/VOGeXtLn5Ld1/SZ+g4HMnW4lxWVPaEVL52j/wDJHoHiLw7o/inSbrRd d0+21Gwu0KNDcwrMI2xlZEz0ZSAQR0Ir+cnXf27vjj+z38YvHvwo8Nywar4W8N+Jbi3sLS/hjnNr Ak7KBGjA9FwpGc/L+f3fg/wxhuM8RjclxusFFTW+klfVW2bWmm60eh+e+K/GFbgnFZZi6C/jTcJd 2m46eibv+O5//9D+4j9nj4nah8Xfhb4e8b6nDBBearAJZEt12xjIBAI7Ecg49K9vY4x7nHpX1PEe AWV5/Xy+Luqc+X7meXha31jLYVV9uF/vVz+d/wDaj/4KbfHXwL8bvH3wu8ExaTpek+GdYm0q3vpr dJrzCY2vjGfXjOffGK+FPg/498UfGP8AaE8PeIvire2+v3t9raxQzXwEkgRn5CR9BnAPtX9zcE8A YDhjgStntD+PWoXv8tf628u3+dme+ImP488VMuybFL/Z6GIsluuj/rqf1+aTb21ppenWtlDHb2kF lFFbQwoI44kCKFCqOgxS6lbXN5ZXFvaXsun3EsZSK8hVXkgYjhgDwcV/BVWcp4udSo7ybbbe7et7 +Z/otUhCnRjCmrJcqSWyWmyPPtJ8FeL7G/iur/4i6vqtshO+xks4oI5PYkdvwr09QQoBO4gYJ9am pKMnpoVFRjFaH//R/s3/AG5dEt7/APZ88Wa2UhW/8J+Xr9neMima3EJzIEYjI3DGfpWD+wP8Qdb8 ffBK1n128mvJtMvWtLJ7ht8yQfNsXPoNvH1r9fhhaOI8NJ4ia96lVXK/VtP8Gz8yweJqUvELE4Vf BOmpfdGmj7frwbxB8ffA2lfETS/hhDq8Mnie7uTBdWw4FqVAJU56nnBxxnjscfBZTlOLzarOhg43 lFOT9F/Vv+AfY47MsLl0qX1mVud8q82+h7wBxg/T61+NP/Ba/SNOuf2bPDWqy2qNqtn47tra0u1T Fykbg70VuuP4sexr9N8Dp1qPinlMaTa5qqT812+9I/EfpO08LU8F86niIpyhBOF+kuZK687N/efy 5ahqkstha20kFsk0SYEltGEdjnqzd+1eyfs+/Gzxx8KfGegX+h6zqKRW2rR3U0PnuNsQbJRH+rYC 8/e4r/VHinJsLnXDmIwWLV4uL/BH+Qvh9xVjuE/EDLcfgJNS54J26qTSa/4Hc//S/tm/Zn+OrfHH wHYa7c6NqOmajFbot3Lc2clva3ZwF3ozDqT1xkHnp0r2fxv4I8M/EXwvq/g3xhpdvrHh7XLVrTUL G4QFXB6Mp/hZTyGHIIr7rM1Phfi2qsFKzo1fda7X0X3aeZ8VjsBhuK+FXgsfFOnXpK911lG9/k9T +OL/AIKKfskaJ+yT8ZpLHwTf3uq+EfE1hBqWmW+oSp9t0eSSSTejuoCuAqD+FTlx1r89Li4inkdQ HeULvCgda/2L8M89rcScDZdnGId6k6a5u91pd36uyb82f4AeIuS0uHeN8zyWirQpVZRSVrJXvZW6 K9kJGtvsLOCJ2OFGOMDPGaakXmxyO6eQUbEaE7t47nPb/wCvX3Z8XYs2FwseoWTqoyt0iGIj5JAW CkHJ6YP4V/Yh/wAExPs8PwZtYoJWcixt02yL90KijGfbGPyr+UvpbK/ANP8Ax/rE/wBCfoBtf65Z n/17j/7ef//T/tt/anspbv4LeMRG5QrZfLgkDPqfp/Wv4e/HZnPxC8RWsXlEnX5IcSIfLCrtVmJ+ or/QT6Hj/wBjzKP9dD/Lz6c+nF2Ty9Pzkf1uf8E0bvf8GdHRHVo30iAARsHjBVE5B9CBmvqz9qFf O+Dviq1ZiiTWbLwcGQ7WAX8c/pX83cZq3i9VX/URH84n9sYBX8D0v+oKf/ptn8+P/BPEWdt+0J4h kiEa79RihtFYbZp18yRcqPQfLX9R1sAsEYU8bAc59ga9/wCkH/yUmFf/AE6j+SPnvo0L/jWUY/8A Typ/6Uxourd5GgWaMygcxhgXH4da/F7/AIKyfAL4gfFLwdZaj4W0i71HT9MdbrUFsJCHMceXbPGA QRjB/wBkjvXxvhPj8NlHiJgMdjUvZxqa321ukte7aR7Pj5lOMz/wdzfLMub9tOjpbV6OMn8lFN+V j//U5bxBpF9YzT6fewSWU+ljy57aRBE5APlgkd+SOR3zXNRSJse3AGWOAxGSvWv98surU8RRhWpO 8ZJNejs0f8xVShUw9SdCsrSi2mvNbkUltaw+cY9USa7hcB47eI/ujjdjcfbFNEscnzvkSE/Mz8lv evWM29GQwRRiaeZ5CpcZG7lFIGOBj2qW3iiufM8wl4xwwDYIznkflQYEiRhofI2Dys42sM5HTBpr LDbvGjnCkYwv8Pp+FbKV1cD/1fKmI2+ZbsRIGAwFycZycHt/9emXUM9woYK4jDYL4wM1/wBCB/y/ jkiKbVPKbfmyfmNKkahbgqdsGP3rHnb+PboKANLT7aSOHzleOSOJMoZJAWOOmB1zxUE6tN++dlRs ZKDHX0oAyp3u1OYmQJ9wxlSH/wB4NV1LeGS0MkgDCP7zAcxE/wCcUAf/1vMZJoVsoTDch42YxGPB VxxzxWdb7U3FWc4ODuOcd6/6ED/l/Ji0UmFdTy3XpUdxAqySQqmwLycEEc8/5+tAEMFpAoeZfk2r yCevbNWYEBUOTuGMhsYBoAsmecKi+arIj/IqDaR7n8qqXlu8zq7ZAPJz0oA//9fytU2RqvICjDEf 5+lDxblUIwwT3HNf9CUep/y/ikxEiNiVVOGdV5Pvg1UWMwhyjNLhvkyAGIJoi7MBTI0g2EEODwMc EVfQebb7kMavE4jKyDOc55weO1Ny1asBFLOtvAYZCvLcqQOT0qrLGw8lymFddyn2yR/Q/lRDRsD/ 0PJ2NvlEV2YlcsCuCp9KAII28zJYgYaMfeNf9CvMraH/AC/miGtolIWGJy0eArKMKT9e/FVIW8uO VZEDK44GPmXntWQEfmPLHjYUB6KRgj60+1gkkk2sUjSMfvHbt1AHFBMvhYkj/MW34wcbTwKdbF1l ld1WRNuEXGMH/PagxP/R8mNkJZC/yxhX3KgHSrEscjSbIsEhsFmOM8+tf9CB/wAvC0YrlY49hX5s 4OO/b/P1qK3miLFJMgAYGOvtQbjrqGMxh2Y4Y7Qo6kVMkiwoqINoThfbHpQJtLcTZIxkJz5cpy2e f1pgt1i2iJywBy+4Y/rQTzo//9LzaGK2hd5cHzXUod3KYII4H49agMUS/NliHb5T2Nf9CDdtz/l4 e4SjadyqBEowMHr6mmPKGIK8Y6kULXYRJmRY2kG8pkAtzgmoYpUkJVWw/RgOooAfZXJtbkxyKblI 2yYyxUHPqfyofLSFWO0E7huGetAH/9PzW1mkZirPDOsXyzoIxGVIHy8Dp/WrDzM28eXEUdPLYOgY rznKnGQeOor/AKED/l3I/MgERhRiHi+WT2Pp+RFU0n2vscDy+5XjdWU/iA0JPINrugcP5i5yOqnp /jVAROluvmy/P0GRgtTp9QElupLmOO1uI41FqCsU8aAGQMSSGPfmpVtSsAYE7VO47Tz61oB//9Tz 2BVmjZc4XOc46YBqs6NMdkxDGIbE7YGeMV/0IH/LuQBJIo32uElVwYXI3KMeoqZGEsOGQvcMPnKr hE+n60AV4oWjcqe/ODT5Fizt2nOcDHagCWBN5MRZY0xgM3IJ5x+fSlWzWIEYHLb3xj+dJuyuB//V 8zuEjBSLeA8ibwAe3+f51BDBKiTRmTAwdjHkLnjj1r/oNk7xP+XcswwMtqrllODsd/us5xycUyQN HCx2+YrMNxyN386fNFgNjSdrSVLe48nzHVpIuR5oXPX8zx71LaxqGxI+MA/KmCzHHA/H/PpTvFAE nmOW3xmMKcFXPI5I5qZbSeVWeON2WNC52rngdTWWl7gf/9bzWMR7MyByzHkngioWdVnWOLawzlgx wrfU/hX/AEFSlc/5dyCWZUdigAG7hVOQv0qeJpiu98mMcAgZ61IDUMjNcRruODiPav3u+atF9tvA i7mYR/vSRg7uhx+QoALYqQUdxGW6Z4p7Rxuxj8zbIq5VmBwaAP/X8tKySPiQkkcDNWS8aLhHLSj5 WA+6PpX/AEEH/LuIpk3pLE22VG3D0OPWppzMvTZ5rDeqkbc/WgCu8JvZo5bny45JHAZYE2RpjAHA x/nNWkjkuN0fPlWucsQSFz/jQAt2A6QIDtMS7SRwz8k5J/H9Kq4CuisSxbgbRnH1oLjK2jP/0OBk tnjEbMUXcMop4OOvNVXmRCd3DAYz6V/0Drqf8v4SpNgSXKFjcKpjONrbAMK36daiACTCKENtboSM fnTAqtHJJKTvxtO0r37/AOFK0e0srMGH3lUjP+e1AGfDC1rIplmLCQZxu4bnB4/pWs8UIOYX3qRk AAr+YoA//9HyoQiZljxhs81pRKtk6yLtfb1VuK/6CD/l/KEKgyzSlFUSMWcKMDOOtU5yPNBVc54A 6UpbAIsO7eVABc/MMcA1IVaIIYCI2jRlmJwwlByPwxn9KieyRam1uWRtt7eCS4Ekc0xLRoVwsijn cKh8ucr9sjxJFPI1t5ajMsTBQckejBsD/dasyD//0vJ4SnlS7kABO0uewB5pBbBniigdQrAbH3bR 9P8APpX/AEAH/MDF8pb+yi3EbNPud0DMQCoHtg0EtIxRCNoG4k9BjvQDk2QxeZGDcM/3X7Dke9T3 ltdW/lbl2LKAwDDBIIyPzFBIscAjcq6bnZPlAboSBg//AFqihG2UefGCqv8AMrSYWVQegHY0Di+V n//T8xY75JMRFYgcoQdxI9Pw4qqixNK6zQSTqq/u4o38rLfw5ODx7frX/QAf8wvOrXEFw8EjMIlC sNqo3zbc1UuYY7l4ZCGWSIEY3fIST1xSbS3Jc9dBZbffFEiswdfvOG6/lVvyy0ASa4UsDhUYnzGH r/k0XRoPS2kCxh0IiPTHAbHBqZrhPO2RRIIQDFJGpOGBBBGck+1DkluTLSLP/9TyVo/J2rBbKBHM ZHDjIZeMDHt/WqytkuU+ZmbJAGAntjtX+/3OrXP+YGMuVWJwh2gk7VBwAe1XoZLdCASZjGnz54Un /DpU8+vkap3VylJbeapcYClvlI65FSsGkgxtxjiRuoJ6Clz7ofkRQq17C9rLbrHIkoW3vABtjDEA mQ4yV44Gcg1VltpLRlDjK52b8ZQ49DShuB//1fJoHjBjj3EcZZRwuPb9KhvI4mlZod2NoyW6k45r /f8AaTVj/mHFhuXeIQlYdqZCsEVZCfc9/wAaWK6lhE0PAyew5PsankQEVpGmyRCQsiZfB4wOSB+l RS5uXK5EbEZBA4XA6/hVpWVgLHCMjI2Cq7R6nHeqMkThyxcsGfPPb2oA/9byB/LjUeU2MICSBjJx yBVQRyoUuBKwl8zCQAHeBx8/p+ua/wB/2l1P+YmK1sy3IwWLdKzPIPuqeTVKC5DyoPsbMImIkaT7 uR7dcfT1qWoWNgkjSWdCkZiJY+a7HKdeMDt+tRukm9ljG7YeWxwtRJJPQC7bpLFvYplFADP2OeKh byiHDMFcthV2lhk9DUgf/9fxX7AqrMwkVyTkrk4ftwO3TpxVMRP5gbYcgYQ5+7X+/B/zHl5XniXy 5ANnX/aqr9j+3XH7ouGAzhFyW/z/AFoAjku47YtbKplfbtIP8JxjmmfbpY4rbbbFJQu2VQQyDPp9 M4oAuC5ZkyxCuv3exFUjOBIBcMRGD8zjk0Af/9DwmFkVnZQ8kLN8pwMD0NWpV3bDCR83BIP3e3Nf 78H/ADIJtbFSIvbFgG3Jkn5vmU1c34i3l1KyDKp/I0GsG2tTFmN3JbzNJFHDMJMxJHKZUdVOVJyB yfStOW8EdtYnzcebEBLG6bGjkY/dHr2osUUpITFcsjPu2pnI5GcZFS+W0cYZyAkmWA/i/KpUEi4O zsf/0fArYyxhyjKCxwAU3AL6nPepnL7sLguAcSABS35V/vpKHVH/ADPlP5YN8jfM4XjnC5+lV1uJ JJGaYE/KSHByfalySAuq0EdvbMZA0s4JZVjICY7ZqZXtJJwmxJliUHey/MpI5wfqOlTytBsSGGyC OkSXHngmdp5pVeLGPuKoUY5FZcOHkLE89OtFna5rBt7n/9L59njlaJmikAZTgk8jHpVWKCEypukK Ln5yADn1r/fA/wCactGKV3cRSQgJwjsPlK++fxqG0lht5ZQypM5jMbKR93dkAj3HUUAJc6dcIiSS 3EbrOm63eJtxQHqrDsRnmljsXcW8CzxrCTtmubknC9eTgE/kPwoNYPSw61c27OIyfJhlCs0eQr49 M+vPUVde+WO6kubTKyMhG5yCemM46dMigs//0/nPejOsjKsrg5wRnOKsW+oapG1+vmxR2l9ELeS1 W1j2BVIYFSQSDlQcjFf74H/NeUfs2lkt9vWV7cOGd4X8qRSCMZPpnGR71eldGaMRw5RuARgBccCg BJ5JYo/NVDN5a4WAuEJB6gE/jUUU0F1sjnbyFblUdsYPcD34rB76lRfKx91/ZctrcWgQCbKvGyEL KmGByOvXFOgiVxGEUsyg7geAAP8A9VI2P//U2P2SNOa6+N/hV3lgEdjI0kEbSslw8kxWIgL0K7N5 5PBTgHPH9vnwdiaDwJpKsgQfZoyQAdxPlJ1/PFf259MOo3m2Dj5I/iP6DFO3AWKqd6kj8B/+CzOr PDZWcb3Fo2+OCF/tJJ2GS4dc4Hf5q/m28TXsun+CZYUvI4bqzu441SNCjTxHPO76gZHQ559/3/6N MOXw5o+rP5d+lJLm8ZOX/D+Z+B37Q9lBpvjTUZIr2E3Fy2Yy4DZHDOV59Tx7E+lfOUEa3TOWkIkD 5IxgH8K/hH6QFRy8TMen3X5I/wBJvB+Hs+BMvT/kRrNbNEhKZZwoLHFVALnzFckkHjax4GOmK/DJ fEfqfLe7P//V/jR1YXMtqE3sGR94HYVk28UzAoHLKw2uB1f2xXLJ2RlBaiz2E6XCOgcDgBHGFArb jjdtuIV2x8p3Gcd/896xNQDHbcurxr5ILzCRwqxL0PP4j86xo7eZpQ8zBopG3Lg/Ky+x/wAKDOS9 9G6tvaWy3RiXyzOR+7ZtxUegY1UD7FaPa2Qcg44anY0P/9b+M0fZTjJAkHJBOMY7VExIfMY+Qjv0 NcFgFjW1mLyNu85F4AJZePas6YmYbYlZATjIGKiUbgW4LKOOBhNhX5KxxnOfcj1rLuUdQJG3LtPy 4HI/ziocLI3W2o6zYwK5UPIjnJj2857tgeta+oEfZFARtxwEOMMtQbxd0f/X/i3tZomeVZH8t4Iw H46ZGRmrLwT3KpK+HQ/IjdSwHAzXjndJJtIYzeQVty7orDLbVwvHQfhxWc9rLcGaQvv8mPO5jgsB 0GP8KBKKWhDa4kCxyAEJxg9D9RWgJYoVaKNAOyjOATQZE1jdhd4dgzq2W3DCL7Co9Q1ITndKkMTl vLVlAHmAcDPvinbS5g9z/9D+MfTL9bA7k8p42Qh45VDqwP8AKs3ULmzvEFwUeN2YxsO2AeD/AJ9a 8c1g2YUNxGlz8+9oUXaI1+Ut9T2q0rwTxPI7j9z975sbcdKCy/bTG0mD2cxga4TZI6DBbdwQfwxS X7CR1RJZXkQDBzsJ7nihaG0XdFSGWMSCKWXy2l+Vz1KnsTV9WZNyZkZ2G2OSP5FOD1/z6027m8Ho f//R/i9lnvbiE28rOCy+WJVOCDjHX8aLO6uWbZM4YRxCDzAMcKMYb8hXjnsLXYpXMKXTwDy3MiMR btFz5gz90n6VRW2meSaUzs7n5Ap5EePSrjKysA2C4uAUglPKyEMYc8D3roUt5ZIWEcbYQZLY6D1N KUr6AUwJmMsCSFJFUbX6Bc+54FQgzbClyyNLATksQ+CCRkHoe5/GpA//0v4rI9OzvuGXKzjdvB+7 6nFKBPC3l28aNGi5zIA2c+1eTGTWh7GwsbyW0Ui3srtIx3RxhdoUHtRp0Zg80szRKuNkfc5rTmV7 Izck1oai30TM4aV1VY8DZHuDn0PP61mRwwNKwEnmSMN4w2fbn0ram9bClJNJG5a20UUbYULu5bHf 1pf9HCNIqFSG2crgn61qtGZp3P/T/jFZWFzbsI8lH3PEYv3bZ+7mvub9l63/ALUu7ezvL/7M0Gtm S5luFKRRLhTFHux0HbHrivufDiHtOMcFD++j4fxWqcnBeL/w/qfut+yhdzaj8Xfh5pFnHpsn+lW+ lX2oNbJH5EDTR4RnxuBwg57gc+tf3FfCRbmy+Ffh231FoBcRWItm8khEjgjURoOOOinnqeK/UfpH P/b8DSW//DHz30bKfLwpip/3mfzH/wDBZvU7i81V7a3mktZdDvLa0jeJil59naRGlTGfmVupHcH8 /wCaX4z6pa/2QJJF8xxp80ZjiXypUXnG/wBRlix74Ff0n4XwjhvDjDpfyN/fdn81cfOdbxUqv/p4 l+SPxN8VNbwajdrbwIJruQzvtcs8hboxPXnGfxrhbW5DSmCSLARvmYnG3H/16/gvjGp7XiDFVe82 z+3Mmh7LKsPTXSK/I//U/h4hleWYLCTtPyq3VQK6LTY4YBO0paV+hYqcoAetc9V3RtBe6b9vp01y RLCQyIplClsYHqK2YHjuLq0OpA2sULCNmXDCUdNx/wA9q4KxvT2Oot7Vby51TT7OGSC3sJQftEo/ 4+I2xtZD0PXH4GrEnhy7vI4zNq7yqspa30pcCC3UDBcnszY6e35+fUvrY2g7OxLp/g52SKa4d4VS dkimRcKT6Y9h+tdJpenyaM9/ClzLlIhfvcyctGPujA7dB+YrmLcrSsf/1f5G5vOa+iuobl3ld/Om llBdpvXdnv0NQxzmwjuM7dkru8s5HzLuPX39Pwr4qas9D0ZuzbNuxv7L7OgluoQ4AUK/7uRm452+ 9cp4kFxLFexulwxkTbZbQViDHjd9OT0qUm9iU7q5p6LfX2j6RE935c0pxbCQSZklIA3bh1x7966g vFA/2myiWOWbDzSkZMnHOPbiqgrsltp2NO1mu7qNnuQkQdysSrzIFHf0wetOjumtpfMSMI0Tbobn bhiR796K8Xyo3pvof//W/jeuZESK3mktfsMCyNDHxuF0FPLfqKgbTbG9mjkeOyura6hOHC72iB6g nscjp9K8ecWlZnm/8vyJtPt7Qx21jGscOeinaFOeT+NJf27CCa7RJLk2irHhQA4GcYXPH60Fvcrw Iz30MERZhcEeT5hEbZxnB54rVju7u4Ei3FvBEkchMW1t0rAcZYds+nNAJ2ZQmtfssqTtLIY5Ccps +UZ5GfYdqrW8sM1xM8ge4WJDwMlUOMDH0yKByd2f/9f+L64s5rZ45/JJgmG/5iVfnjpVY3n2WKS7 HLQ/K2wb2CDsRXkx0kjkgtDSWxgvZY9TuP3yTRI3ks4YDH3Sy9vx9K1ZxdwRJJbgxRThofOjIULx gj8j+tdcHpYsc9nANNgt3dHaL5ZAQeR3bNadpPHax3FusCzhogI51JWOI9QffHTFd0NxrRnA6raX UOoExXCPbTIJZQQwkiY/eUdsVylxp+nzSLDJJ5aTEqk2fuGu2L2Znf8AeM//0P4nvBtg+h63p8v9 rxv9rukjt41iyGVZRv3YzzgHH/6q/fv4RwLN4O8L5u5IL424eC6VcxiMsXKbjxkHcPqfpX9e/R2n L2mLpdLI/mvxzgk8NU/rRn9dH/BIPWLD/hHdOt9LuHn0wwywXjzAL5ku4qCfcsnbtX7X/H/S4dS+ HPiS3aL/AI9vDt1PlTuj8wRErx7Yz+Ffifiu5UvEKpUW/Nf8T+ieGKcKvhxhaT1TpL7mj+Cz48aZ BYfGzxkmoyXURtNaluYoIl8uG9WZ3xMx5ycZXGf4e9eH6hqOnNPOY7hJb1bgRPYxYaaMbQRv54yM YOO/av8ARTgiTqcMYF/9Oof+ko/zB4zh7PPMVD/p5P8A9KZVN9O7NBZRQW8BZWu7doSDJwOd3XJH 4U/U7KeKWKySWO1gkT7QGebaqKVyqgD6/wAuK+zXmfIs/9H847y1s/CekWE08YvP7Sv0jivYiJWW R8jY2Dx64PtWXPPd3CRXUaRgLcCJi6hmUHJztPf3xjiv9nobH+P7XQ6HT9ZvbOyNqt/beXLcee9r Jbo0srYxwSMkAdjwPSuU1CW6uNRRxfmOOSdXd2RWECDAcDj0BNbw2MZX+F9C9bT2CyPdxieaEt5a vcRGOVm6Kcds+natr7clzLCls1zpt1bE7biQlbWUsOMjuB71ZzNW0Zzuo6xK99bxyGK4vHLx3cyR +Y87k8v3A5z0rctLa/ae4W2RxbG1+0yTCERNHjaDle3XFBztWdj/0vzbmurq7f7NKqGC3UYlx8xo htES4WSNjHIybfLYgCfPYZGB/nr0r/ag/wAY5Sd2jR33X2lJNTgkaKVVjZfNDC2QkDfnpxzn+VWb hZF1LU30u3EWnJp8PkidQwzuALJJj7xIU8epraN7ama02H6r4kvtUNvpdzZxyyoiQWtzcgFkJ7hh jAGBy2elU7S0e0lE0ri6huIAb22BIU4bBVT245z79OKod2ncbe3NrdXksNjYypb3TFo/OPmy2oTH O7HTt+XXrUNqyBI/LhlkuZLgC2kcAoWDYBKkcg4rdbGyd1c//9P8/IIX1OOa4v7uSK4muCsMccSW 0EPlnaybVA4JT9TV+yKXluha5srWSznezgsJC0dw+3jfGCMYOSc55/n/ALcH+M5mTabdzW93LaJ9 p+zHE7AjPOcDH/AT+VO0FHt9QsLObSjNPqkL3EVxvCNGACEI/FWGfY/WglyS0L2ozvLcT2IMkEls 4Fyr/MXx6ex6e1ZVtqzWtzLbxSurRMu+JhmNwQCMg8Ec9DWkFuYkRsr+1W6aR7S6j1GbNuhxJewD byuD90ZzjHtSS6J+4DrewWbBVIF5uVOnz8qD0oha7Oc//9T4AsL6aCEC8kheGO3BtbqP7k4GQuPY +p/Grkdwkl5pziwN208uJkWTah6bV3eh6fjX+4B/ilP4huo3UX9p3EL2j24tjsngt13Rwk9s9Cfe s21aLUp7nT2le6ljlWWyzGM2qYO4N3/L/wCuWt9TGextWlpMdQXT1uEg8yMiRnk8vgA5B9qx9Sju bBGLQSyxtdLZGeJxth3HlmH05re1tDK3Q6A3dtBbrpcFv9sSVFMl7ImHXv8AL7+pFZF/HDbyKoD3 AaIfvJhhoj6Aj0xxVRjcwcWtz//V+CLG5u1DLNMdkY/chxkJjt/n0qo63Ny032y9dodzN84yFB6B R7/1r/cpRb2P8OXFp2NTTXtlxbFRKrD+JcSKQKrwG5k3pteAeYd1ucFs5wOR9P1qbWJsWLvZaRLu WUSeWHYEZUNg56f/AF6zopfPUXO1ysWN8QQ7zngHFVGNwt0OptNIsZf3s0K3CLiV5AzRt/ujH+eK SY2LG3iS3hgW3ckCGMKGHOAx6nBx1zStYEraH//W+FX+0300kHlsWZ2kO4Z9xmqtpazQLNJ9nYBJ d0k7j7p6ev8AnFf7nQ+FH+G5YuoVvpYIbJ5JhIuTKBtjyuMn1HJ71LDatHA6Luk8p8TMvK+gzVLQ mSVtRNRshDFGylirLvVVJVkPcGsO0E0vmSQjeFk8mRj/AAEdQfTpQYNK2pZuLq3jka2jnDygYbyj 17/MO340vlStbmb59kMZdh/FJgdB78U0+VmB/9f4Z0+3tp7J3mgSCXmRQSDP6An8qhWOSUognZGR ghMi8Sjp1/LpX+7B/hA9zRt7ggyRXNssrRArC0YAdsDuenWrVjqEC2MZ1SGKCWa4AMbLu8lDgLnt kHGaDJz7HP38N+upz2WnTSzWdpOJbgxQEqyr8x/DBHNRzXGlw3El7MtyJrp0jXyUMhcnjJ7DGB+F Ac+hp6e97b30b20r24ALMRkSqGGBx7jNe9+GdUvrOFL+VIrqSJVK284LNddBj0/P3pPY5683ZH// 0Pvr/gmdq+qn4r2kWoW9rbW6SQXVrHb3B8lwHf74IGGUuw9Olf11aWRLpts8oH722R5B/Ccrz/Wv 6u+lPSVPjWm49Un96P59+jJXniPCWh7RWacl8k2l96SZ/KR/wV40BJPHY1eWRvPHiD/QYSfn8uRo wdh9ORxX47HTTFOJsvexrHuaOB9pzxknP90nmv7P8AKvtfDXBf3br8n+p/lv9Iyg6Hirma/mlf8A F/ojTu3BgUKyIkRAkXO0gkdMe1czcoNzRxPnPDSR5A+lftZ/P8tZIrWEDTpcwIJZDp7YkdwWVQ2D nP41p2MEs8jQQRvI4UttVSzgDqcelUl7rJn0P//R4jwrfJpGtaRfzKhW2vVmnilfy0nRMlo2/wB7 AFf19fsEftj/AAz+KXgrR/h0Hs9A8WaHGtmtjEpS0vdyhgQ+Nu7J25UkHHUYIr/T76VHDGNzrhaj mGETaot3S+b/AB1+4/yv+grxngMnz3H8M4qyqYi0ot9bWi/u069dNj9MpYxKjRksoYbSVOGH0r8J P+Ck37I3jL+y9U+JXhS51vxpo16xXV9AmRr6XTWZSFlRF/hU7SMDHynpX8QeEueUOH+NMNiMVpFt Rv2u1/XrY/uTx94axfE3h7i8Hgm+eC57LrZP8Vv6XP509T0l3LJJAYrrT/lFmwMXAwNoiPQrjv6V 9GfslT3Nt8T/AA3Jfzy2Us3iCK3U3EbLG8asmwBug+ZjgHvX+lfFdWGK4NxNSm7p03Z/I/y98GY1 MN4r5dRqaNVUmnuv61P7bNFO7R9JbIbOmwHcOjfuk5Fcv8SvENz4T8D+JvE1sFZtB0ibVHVlLZWJ Sx4HJ4HQc1/kn7N1s09j/NO33s/2cx9ZYbB1cQ9oxcvuV/0P/9L+nOT/AIK6/CuTRr6wsPD2oXXj C2haKOFmeGwZlG3zc7DkZ5xuHUdK/HzWf2avjN8Z/EHjb4t6d4G1iTRdb1OfXFuIbKeOwaSTEmOF PyndwTxz6DNf3P4V5RR8LZ1czzappWSS6aPZb+b7H8AeMmdYvxTxGHweVUXyUE2+uqvd7abbanef sP6Nqvgv9pDw5p2t2Y03Uhcpa3BnzHPEclgFHXHGSD3xX9Za52jcctjk9MmvzH6ReMpZhxNh8ZRd 4ThdP5RP376O2HlhPD6nhZq0ozkmj4a/4KI6fb3v7M3iVrmAXCWmu6ddqjNt2Mk4KsPowHH1rpP2 FL2a+/Zx8ISzn95HPPAQTkps8sY/r+NfAR/5Nk0+lVfmfoOVpLjrH+dNflS/yPsE9vr/AENfxuft a2D6P+1b8ZLi8kmht38bXEcU4nwyAKjMvHONxbI96/TPoxxvxTjE/wDn3/8AJH4T9KSp7PB5LOO6 rf8At1I//9P+xH/gnhdG6/Zq8JSZYoU3orSeYY9w+YZ9iDX3I/8AD/vj+dfoPH6/4zLMEv8An4/0 Pnsik55BhJvrSj+R/G/+3joOq6b+2N8a5IdMM0GreL5bmBrSJrh4QBHEoYqOM4LHPQZrnf2W4bwf GbwJ9pa3Yxa4rGzuIzHKAWAVlfuRzgV/oVgMXQr+FNKKfvKha3yP8tciwmJyzxipqpF8ssQmm/NL 8z+zfTH8zTdPkxjfYxPjOcZjU1w/xZ+Iln8KPh74o+IF/Yz6lZ+GNNbUZ7O3bZNMq9lODz7e/brX +a2Gw0sXmsMJDec1FfN2P9TM5xkMtymvmVX4aVNzfpBcz/I/H4/8FoNCluXWz+DOoXFpGdouh4hT bMfRf3ef0PSpbr/gshHDucfAu7hhWLzN1z4oCyNkZBC+QOMc1/Rsvo/1adNVK1dptLtb8j+WqP0k 6eIUpYegmk3bST0u97PV6eR//9T9k/j5/wAFN/FHx88Gan4H0nwpa+GdK1W2ltNTt7fUGluZFPyl XJHzZG7pgdOOTX6d/wDBMG8S6+BRO9/M+0IWhkA3RYMykZHHYV/WvHvBtHg3w0eCpO7lNNvv7yP5 N8IOO6vHnHuMzGqrWp2Sta2y0+7uz9Kq/lc/4KHfEjxD8H/20NT8Q+FdRuINRhuW1KMeYwgjlMSN sYLhgCHB4PHWvk/o85ZTzXjKrg6yupUpL8H/AJHq/SY4jxHC3C2CzbDO0qdZP7nFfqz0zw//AMFn Pi7omhJFrXw+8Pa1cRaakg1C5up0CMAAS+yMZ7H5jnPFfFH7XX7enxJ/av0jQtA1j+ydG0m21D7Z Hp2kPI1tEVBX51ZFyTuxuJPQ4r+s+C/AbCcOcWQ4lgklTk5RW/nor6fhZbI/iHxW+kpV414Onwsm 5Oryp6Wta27sr/jfv1PghrIYNqVCSxjcqjjA7V+q/wDwTu/YY8R/GrxBa+N/EJtrLwjpV2l8Dcwi 4WcRkeWSjDk7t+B325yO36x4tcYUeEOC8TjakrTlFxj3ba6fl8z8s8BvD2txz4lYGm43p0XGc9NF bVX+av8AI//V/vY8LeGdK8IaDpvh7RbaO2sNNtlt41jjEZkKqAXYDu2MmvCv2mv2ivCPwA+H+u6z qOv6PaeLG0qU+GdIvLiNri4uCjeVI8JYExhlyfXaQM9K+8yXL8bxdxXTw8FepWqXl83d/mfA8XZv hOEeEa+OnK0KVO0fVKyP43/2lvjt8Rfjj40vPEnj/Vf7YlUmCzUNhY4yVdX2EYTqcKp456V8xOs0 K+fBGQ8hKrjgHHbNf7PcG5NT4f4YwWTU1ZUqcU/W15fi2f8APzxrnEs84szDN27+1qzknbdN6P7r CGVUjRXtwsm0lpQx9e4//VSrM80IkWNmiE3ks4HyrnuTX0x8rzO9zTt7SMtE7IrRtIIHQrkMzcAH HTrX9e//AATHmhi+FNpaxwIqT6VBLEY23rFsX175B/Sv5V+lov8AjX9P/H+sT/Qr9n/Jf67ZpH/p 1D/28//W/uH/AGi2hT4ReLzclhbHTyszIMsoIYZxX8PPxP06ey+KPie5+2WZ02+16SO1E8wWRQZD lVHUZKED1zX9/wD0PpWo5lHy/RH+Yn05qa/1myab6W/Nn9WP/BMdok+EtitvsEDaRbQwKoHO2MMz D0FfbP7Q1vDcfCbxfHNFHIBpUrJvO3awjcgg+2M/hX868baeLlb/ALCIfnE/tHLmpeCUbbfUp/8A puR/N5+wNNKP2i9es7ZI5X0/xK9hBct/CoYkL+ZY5+lf1TW3zWkIyTmFAW7n5Vr6D6QK/wCF/Bt/ 8+o/kj5z6Nsv+NdOEdlWqf8ApTPyH+Mv7V938Cv2jH03UnvZtFu5gqJGTKkQDlcMh+X5sEden51+ n3hHxV4e+Kvg+31S1g+0aRrdgrSQzx4V1kTOAD9e/SvjuIeHqmU5Ll3EVDT2kFt30afrc+14V4iw 3EtfM8gr2k6FSVOz1920k0120t8z/9f9rP8Ago3+whoHw8TVvi14Sj3wX5kujaeWLhYZYyJUVYCv AJDBtpBI9wK/n6WVysUrwNC0qAuGGNr4+cD2znHtX+wv0eOM6/F/A9KpiNZ0bQb7/wDDW08rLof4 G/SX4Aw/h/4lYrA4TSnVbml0V7P8b6+d9SRFeST5FUgj58L8zf5xRHbRXE22SURiNv3i4OSPbH9a /oJSTP50kmmzQkjtbZHdbiGdg3lrGisCoA6nIx+HWs5pGP8ApBjEAA24XjP1+uKZBPaXaPDcsHhL wfw/8tDnpgVAmy5cGRcsD0rWGwH/0PLlyhkCrgo5RkIwVxVqQyCNAFcxsu5zwVQgj8utf9CB/wAv 5U8v5VdnB3NtChvmGMdvf+hp8LvYvO0UjeVOm2WBgGjYepBHUUAEG8gJBtRGb7gOMUy5gDHLHOPQ 4oALZDyDj5uACckVK8E0jyW0ETy7FLt5S7gQO5HpQB//0fKmh2WxjKgPnOO4NV7eSVFkhdUKNjPy jII9DX/Qgf8AL+WV8p08teJFPBPNJdILbGHV94BOM/lQAwiKNElY7gT80XP6/wCe1aP2iN7beYVA A48sbV9AcUAZiGKQ53mIpllABIc+n9fwqWUuQilmbac4z8v+eKAP/9LzFY3khd1YIFPAY8v64qJD udWVt4Cbtqjn3Nf9CN7H/L+OXY4kd1yAMYHB+tQIvmA7CARwc8YpbAR3NrNCzgTRSvHjY8TZjYY9 TQGnk/0SSFoneA3G7mPcoGcqeOvbHpQBVW132+6SbPk4YRz7nmlOcYB55HXk9q0LZozlZQ23aQuA Moe34cUbAf/T8jIjWYOB8uPSrDxxsI5IpA0jHDxhTvH/AOv2r/oRvbQ/5fw372EHlMGQ/Mx4xjtV gIuHaQE4UKg6YPqaQCNHPKoIU/IMYH6VUhR1eQlmLE4I7CgUvhZqRGJCpZB06uoYZ+n+elCW00zM 0e1vm5CLjaPpQYH/1PLnWbdL8hxE+0uOQenPH5fhUomDxs5BUrwTjHJr/oQP+Xcikuo3tSBEBKp4 fpxWeqoR52SuD83UAYoNYvRGncjz443ONyIAiJ6YHJ/+vVLcUO6XIUD6AUGbd2XUu5JEWPdmNBwM YH+eaWM7GMXklXlbd5mchh04Hbp2qedCP//V88doSogK75k+duzAD8f84qVLiC4T7NMmFQcFBtI6 8E+571/0Ett7n/LuVZmj3geVtTOAmc9P8amW2gZRFEnLZZsdR3zQm1ogKt9C6pAFdmSI/wCrXjue vr1pkv7pBLHFl1Gdo4LVXOwEjuEugjvD5M23BBwG9unemNEHbDFsqQxx7Gnzgf/W86SSziHykqZh 0Cbi5A5z+AqB9oLeU4dOp42lPY+4r/oQP+XcpyDdu28d/r2qiZlTEZyWL4JHOPr+VJpPcDSIkVAy Mvl45jA+Yn1qR5vOhEcqZHdsfMMU0ktEAxx5YgVEZsnaAxyW/rV0nyoWR+HbjB7e1AH/1/LAzwoA oILN0HNWADnc/wB7qa/6ED/l3J9hWJlKo4L7xlfnGPfrTBItvx5bFW+8BwRxQBVSeWdZHihZdhKk smSwHcU11ClXJLBjuIX7y/X/AD3oAvwDKhlQpkeYA45IGef51cX5kW5VcI6YU9VbHU4pNXVg2P/Q 81mt0X95wGbhfaoED5VX+bHpxmv+gtxkkf8ALsmnoi9CiyMftLvb28ZyVQBmfA4AHbJ456U6Vlkj XgBVGMAYyKmzBNN2RCYwvIcKhG05/wAap3FtEPJe4Z5IEmWUNE5RiVIIAPr0pDLD3AuImaNHiBHC uQ7r7Ejg0izTv5EUW5CikTuT8rjnnHX0oA//0fPDBtdwZVkjHRwCof6ZGaqXenlQqupVZk3xt93c ORkH8DX/AEEH/LuV100xxqxPyrxjOT/ng1Na3ht1uoZJUihkiCIJEyu4MD/n6e9AFyLz40F1agSu i52rgGTIxTo5lYs/ymQDDqAPlPoRQBEIo9jbw2DwcDke1NFzljFs2naGQkbWI9xQB//S81jDNMkk 0nlKhwOOH4wBUhgjaSRUKjOXVq/6CD/l3KoiHmKNxHOSQelXGKiTc/zlBsRjyQPT9OlAFaOdDM8Z yGUZAIwPwp0/2h3jW2me3jIJuEBBWc5+XI9ufzoAtRpE8U5kmCtDHkYUs0nsBUDRGCFZo5MsylSJ F6H2/SgD/9Py8fbtWliiLLArSCGORyUgkYDgE+vI/OlubaYNteSOZgBGZIx8vy8de/TrX/QKn7zR /wAvKk46IRUS3GF3/Ny29i659h2HtVmPhlbjJ71e+xqndXIbo+WQejMQqjHUnpVJ45LeVRKAXYZY fxL7fpQMqSqJLgOCQu0YQ9BjrU8bHzQ65wBjHT60Af/U8vjYCdWyYjtO1iDtBAyMj8KqSTFwwMv+ kbvmXHBHev8AoIP+X8mtDIS42llUfMSOB71b2xlWKlC7LhSRnb9KT2Ars6W4CkAk/fOOTVCSCR5F ZZN8QzmMrhj0x34/+vUT6AXJmd/L35fy0EaDrsA4wKqQZhu2naOTG3btWQoB1wcdODzWYH//1fKo pVWHDbMqCWZiED//AF6jdVkABUjA5A4xX/QAf8v5NMS1tEu/cY12oD1AHP8AWoYvmQsAwYDBHegA a62KYwp/2sVoyPHPbR/O8s0afKobhAP8mgDKs7tkula6ixg/KpO7b+PuKty/vJZLjaWiT1/gBoA/ /9bzZHjX5FIYFQcgYIyOn4f0qK5UxLtWTapIdjjrj/8AWa/6AD/l/MqPzZ5WUqdgGRISBgjtUiK4 eVGXcCpBzn5fcVjK99QJbeNVha2iYB8743lJIHqOT6dqmlMewSttMw+Uqi7VYAcGpNYbDkeZ4gyM FyDw5wRis9Flt974DBzliByTQOSuj//X8st5GnTLHb14Jx0qkUvIbe9WFbdmecXMe0H5dq7cN+Z/ IV/vwf8AMDyu1y7Aj3MSDHzEZKjqDj/P5VFFBudiqtIYwd+08cdc0GkVaKAOiIiIjxFZPmHBUqPT 9ai1GYuFt7MuskrpklPuAEbvbpmgzl8TFlRrZWhtriXc+C7zL8p9goPTjikVBKhMkgmjRgrjHyq2 Mkc+mKC4zu7M/9Dx+4QKVkiH3eCFOMU4RhkMjup3An/aGK/34P8AmHK/2dSjSQsxdP4S2AT7VHYO 8swMm2IhSJEkwdx9j7c0AaRtgzyyRMFwueT8x5x/Wq0jkRrH5cfmxnPnKMMw75/KmpNALG5kRtwX j7pWmMVWM85IPWrUnZgf/9HyOMwtb+S2Gk3iUOOCuO340TSv5cjySDezbUIX5hxX+/Lbe5/zERdn qUNjvjBLAjIJq7awrdO0TXEdsFXLyucHqBgcHnmkbkV2IobhLfzC6If9Z90uBVzaiktbR5jblgw+ fgd/yoAr3U9vPDNFGSJi3CwnGw56AUWdubeK5SRA8pUFml+/Hgjp/nvQB//S8jkURopByT1wePpV aaOTzYUDoNzqGcHcqg9fyr/fg/5jy1qMfk8Rus8UZw0igruHqBVWwdIpQSxiDfx9WA71LklowG3c MMjSOnDMflfaA5+tUTIu9IcexzwxPtRzRAuC2UcYyMcZ/Kp0tY3h8i6iiQkmQO3DsuDgfjj86jnf QD//0/FYl35iiQRptIC4xjA/+tWe0csCTgyx7tw8mDB3v2PPI/PFf77xdz/mPJ7azaWZYb+5XTlh XzZ2mR2wNuduACecjtURkaaZLcBAo/1RbClwBzTNaewwQSyLJPLKEEcixRwLwzgg5bHsVA/4EKjk mjjaOBpF+Zvk3nkn2oLKxV4bnaGaQMDIS3OTmrEshkjH7slsYCn+A0Af/9TwBDM0W1kG9Rg7Rgke tRW8qpKd7MwQE+X6Eiv9+D/mcipLfYjnzPFJEB945GOSp7UiIyIo53EYPvigslt3lkWWN4WWJH2q 7Lxn2NJcfaLePd5IWEHZ5iD75PPzEd/8KAJraVDCSzkbyUkQnBI/z/Kq62kVshCyyM5PRzuOPXNB UXa9j//V+emubVQlviZJCMl3/wBW3r/SmvCNh8p1cqcBiMbq/wB9ZKKP+acrsLhI3AKq5OFH3lAp ANqKjqBIRkuowX7Z/wA+lZq19QLluquhErumzkLjcG+lTlfKg/dqSN3Ctxmh7lQ+IjZp7gS2yRpH Ii/aJSE2x/L7cev61S8tElLRufnXDbv4aRsf/9b5wkj+yRtOm+5jQgyNGhIjycDP50kN4/msXi/d 4ymfX3Ff74H/ADXJpuxpoftCiL7MrtK2143IVT71nzJLbX725dcRsNpjOEFAyWbejCWfdgdCOhB7 1BdXNorRJ9lWYowcMVxj6HGQfpUtR6gJa/Z5DJK9sYp5p96PuO2NQuNgHfsevarS/ZmvRCsrqzJl QV2AnuB6/wD1qzkknoaLWx//1/Uf2JotPvPjfoFnNaq7wRtJH5vyvvR423KPZd/J6Yr+1fwHG1h4 V0u2eQSOtmkjMRgZ2qB+iiv7T+mA78QYSHkv0P4s+g5G3htWkv55fmz+bf8A4LLz2dze2tsDL9pm 1WwtJUjw4QmRpizeg2wn6E1/O38RrmRfDl/p8Vqky3duZZpIXzPbrDKjB264Bwy9vX6/0n9HGm6f hxRv3f5I/kz6S0oVfGe8e8fwbX5n4IfGiNrvXNcub/7OvlXZgtoyc3CMBkEegwR9K8HjtGtDCwJd yokZXc/MD2Jr/Prx2nz+JWYf4l+SP9OvC6ChwTl6X8iN+S4xA0vGQP8AVoN2K5q8uJg6ES7DKcBU 6oOgzX4u3d3P0hP3Wf/Q/jXN2EiLSKd7Dy3JHytUcFv5eXTaGlO5Hz09q4p72MobkEd75lyIr24Z XOdhI3ZwOBUV7qskYZLTcwxtyF4U+uag0bSVzLtGdobiKePz0u+JFOc+h/rW40gNnHarEFS3QLAq ptMQHPH5UEL3pXZLBJHJGzkNNJGu0qQRjP8A+r9Ka7Hy5ERxHIqZjYjdg07u1jQ//9H+MBLEQxfx zl/mllY/Mx7moWkQQnYxJjbO1vbtXEvhaLcLK4y3uoUniZCyh/8AXMgJEZ+lb1tHbySMWkQR5ypP DN+FQWopFq/sEtwwjZWk2iQEMDnIyBXF3ty28wjzkLjaSw3FW74HpQWotrQngneydS7gSMgQYwVG R3q+15udDLjcpyvy5FZuHYtLlV2f/9L+L63MTyXc0gjcyH95HwC/XqP89aszGXcG+aJDGCqLwmO2 K8hqzsztjH7RXN5a4db9innfJFIOdjDpxTFRpEaNduzHyuh+Y49aVgm7WsZu6BWZEY5zgt64qrLP uLKiqEABQqdxyOpNWoO+pkSXZd7lRbsTCIldmUbVZscj8KlhjF3CrSxiVYW34XqMHGRVyV1YzlHX Q//T/iuv4LeF4hamQxmPc2852k5yo9hVeCzluIPtMY8y1hn8q6t8+XPj1CnkjjqK8pxsjoStoiSe LT7hD9k+0wPvwpliGGUCqEdqttiNVXbM37xz6jsRUAarR+S6KQVdUDFSOORwaikDlt+4K54yOWUe tBsnokVktsZkbax8zKTEcsewJqyt07tDGW2lH3MAMrxxildLQu9j/9T+LS7ut0RjRysYb96yjkY7 Csf7VDYxzy7yiXGC6u2N2O5/KvElK2iPVhtYtyPeiKGaykjaAqJWQt85yB93/PpVi3kaO0lkKKZN w4PQ5qo7A520RC8UqkyqOM72296ZNf3byxjz5IyQVkjUbUYHjmmZ3d7gZd5dz8vlx7CU/ix3p0yJ HF9p/fbTHkxgZzx16ZoNz//V/jEtLi3/ALLt5XlCFiUMDLhwO3HvVFJMBpFifd1yR8uBnFeOetL4 WRLbXmoTTSXL5AA8otneRjoaQq6IqByQDjeep9qcd0ZJXdhtxZFbVJRPJ+/bARI8oR9e3eo2gjsp EaBhIvlqQWGMnuD+P8q6qe45Kzsb8s7wLat+7KTqGGxw4+nHf2NWb5xNsIcJ8oA8qP5QfcAe1amC bUrH/9b+N+KXFzHN5v2hFjRNkqBRlR1yPwH4V9yfs42TS3c97LvvoxP9ttre02xfZWWFMj/aUH5/ +BHnoK/SPCmh7XjbBX/m/Rn5l4x4j2PB2JXey/8AJkfvF+wN4ek1D44eGZJZFSGW3EzyyRiOEEsf L2r/AHyD19jX9vHha1YeAtK8iKNFj0gZDjAiEKYbOO/y596+4+kRJy4swuHWyihfR3pulwJXq95P 8j+RL/grffTax8TT9m1mXc3iOCW9aScC2e2iLx7nTrncyjgZ4r8A/jIuky6bqlzdM9jtCv8A2e6l WWJmRGUHrh8cZ9TX9TcCR9n4b0eZWtTt9yP5b4rareKVRxd71V+aPxM8WSQCWeUQyWt4blvLRhjb FljGhOeoUrXFWbqZGWUHc3zF/wDP+ea/z04gqOrmVab35mf3RgkoYSnFdkf/1/4c9L2B1CvkBvu9 MV2ESvMVgSR4W3AGSNchlzyp+tc09EzWD0sdbbxG0Rn352rtwRgH05rBu7yY3IDIXj4wgHymuCr1 NYfEeiaLN580kktwsAitwCoIUEKMAAd+1dVpMKz3KXQmaMwxMzW7OFhlHqc9+nFefV0udMFqElzI t5LaxzoGjYTLFHKromenTing30lzfT3VyzGezSJ7UEOp2tuGf0/Kuctx6n//0P5IZA21bnCqSoTa noPb8KoCQkMJIyEY5IcY6e1fGySaO+a3LV5rtvHNbWcVjZvJfOubgR/vItgAwG6DqKsa6l5HFCZH aUooKLGwkSNSM544ogrIUPhIprqx1mLS7SztLgXG4rOzoVjkUAfOR2PXA78V09kYbu3u9K01oZza w+bmcqtwghHI6nB9u+KaVrmTd3cLHT7tLQyy4Z5RkCFtwUE4Ax1z61q/Z4xaBp45ZFt0LmNk/wBd j+HP4VVT4EbQlZI//9H+Ni5txeR2kklxN9jtJmJVF3iUMNp+g4H5VHpgjaKSFLd7OC2mbZsyI5Bn IK47HOa8mTXImzz6iSqlk3Mcch82LcB80bL1/GqjXKXk8IQmHY+94+qyEZ4b25qQCeYC5QtHHgLt jkQcg9Me1NnuViidfMVHkGFmVfMEbe/+FAE1neTTwGG4cTjbnfsAJxwfzpmmTDy7kLEbS1L5jheP ZLKwJBJ9qBxV3Y//0v4xry+mMoVUjkgAIfcxUg9sVVhi4KGFcyczFR94Hsf8968haM50raIsR2ix srwv5DsMbt2FAHT2xW1ZxOX+ySGNkXBV1fecnJJPb0rrp9QEkAN0LW1Pmzwk+cM/IR1Az7YOa1tD iS+lhu45Y3sUd1kVpMRMy5BDevQ4HrXXB6Ji62DX7aKQT3cMaQRgbVVOj4wCce9eJa9F5RCQBkj+ 9kjAB716EdkYptO5/9P+ITwrcSWniHw5JskuN2u20EkikEW6SSBGJB6gg4/Gv3y+AUs114eaK51Z nsNHMVtpcM0JCXKhSr7ey4CrkZ71/V/0eK1szxFHul+v6n85+ONNvB4er2v+n/BP6m/+CK/iya+j e1WGCCxttals4oyf3FysZL5IPAI3fjmv6Pfi7HLc/D3XoIxDHNdaHMsxZtgCleQv1GR+VflnjPTV Lj+o/NH71wLUlX8OcK+1O33afofwtftd+Gb+z+N3jCW4ix9keF44Vl8tp0eNXbdn+6wYjHXeea+X bi6s7+5jijt7KxWC2CmeG2WO4mk6Au3fGB1r/QPw9qQq8KYGdPb2cfyP80vECjOjn+Lp1N1OX4u4 t1arZywGd7WVTEQZt2UZh/Fx3J7VQFha6zJBBPfR2czTbRdA7oSp/hI9vUV90ld2PhIu6P/U/Na8 ggea706Cdrm3sdSRSXiIV5IiGyB6jt9TVu6syyxaqkLLa28zW0kJcxxvvxgnuSMcfWv9oLdEf5AS aTZnx6VDLcSyXMcimOMvbIkuyUEkdTjpjP14qpbaYhSZnilEdxIQkZc+bH9SOhNbxVlYwk10Nt47 bTBqC20TXNlJDHL9ku5/Oks5AABIhXAz8xwPpnqartqS3b6PadQbeZ7i6nyiwEHMUfTndnHtj8mY z7F6G6tpLaJVtLeC8inJDBFE2ADz5nfPUA01Df3Ucs7xStbFvKluMFUU9Tj19aaTbscknqf/1fz1 ttNgu5ZbCG4BthEs086ts8w4ztDfn09PxpbjTLzUryOG1RQ8TslorEKz4/2voK/2sjDqz/GOa1uU 7e1u3kvIbwq8MQWO7jUGTKN8ucDsM+3UVfv5r59Pghijjk0yyVbSK6LBLm52Z2u6Y7A446fnWhmN tINJltC8K3suuByWJnL2xix0SP8AvA9x2rO+3TPL9ljUruHJcAKxzjA96ANq0vxBc29sunLGkA3X t0zh41BI+ZhjjsMd81IdReC5eX9xKYHzprLHtMXOcnsSDkit47I3jsj/1vgQSRpbE3Nz+9cmQs/8 BOTjNULrSYLx7PVGEk8VmRNKEJEe3plsdBzj8RX+3B/jLzI6G8htZbQwadFDZWNxCs3+hzHexPUl s5/XvXOS6eulxW3lG5NxCSkc81w0rQocnaAegyc02rGcndlywtbmSH7VNsWUZjIj5Nxncdxz+FId HgMsFz9oKSEs91HcgRq23JVQ46ZGBQk9bEmvavtje+urNGd1KRCEEqpAJA3nk4BzUsV5C+nStcad FcQzS+S5kUnd0O1W4wfXFCT6GD3Z/9f8+bqd7NY3yLjSo5NsGlwW3m/ZBn7gY/nW1bJClrJHJb3d u04Eloy/wj1K+/sfzr/b2CaWp/inNdTOK3No1xcNEJLNJhHJclCodmXODnnPBrBmt0vryVbRjYyT YxdRusGwD/bPAP19aszOjZbxV+2O63M1u3ks5cGaUqPvEjr9alu7+4eBVLKVkAaWAoOWH8sGt1tq ZzGw3llcy/Z57gWYisPOtpQQFMqsu5D7YJ/Gq1/c3s91BbWNql9ISC5X93FsUctkjrgVSbWxhNq1 j//Q+Dl1P7YRDeWzoscQhgKYJVsgDgdau3kOmaNbwXN/LvtBLHG7SsGZGZ1C5Uc4JYc9BX+5Sk1o j/D8hnuBprNqGl2cc2S0KvMomMaMOqDoSOCM9Peq2mi5ub8yRtJJuPmyuQW2f3ifx9epqRWR0V4J Jr6JSoME6bXyAAQB1Axx61ny2k9sjCCeGS4kbY8WxkRkByMnnoB0qlJrQzcHbQm/tMG0nsItvmkb DGoJPbODWYvltHGyMY2jbYVPOMeuaTbe4uSR/9H4tsruO1VpDgzAYYdm9CKzm1G6mVrHCvHcsU44 CknC8etf7lRlZ6n+G5Zu9Ot7CKxiK7J4wxkkUsFmJwTn6elW9J1i1ti8Ny0c6RSiYWMalHvDuA2u 4BwMZ6n1xWqaexlUdiva6XrN75s95NaWxedmtgxbyIYx9wHAJzxz9awdr6Xqc1jJ5QcyBcbsxzAg HcMdeDmmcrd3cnuYNMmu1bZHBdyL5Ut1H8u7bnaWzwfQd+Ks5lmRILNJGVCUdvLzuGMZA/WgiTaW h//S+I5LF7XyJIXhuneHzHjSTJjPYMOx65+gqgztc3McEiJDPs3mMMO2M/lmv9147H+Dk9EacK7L C9JmgQ8IuV3zn/dOOPzHSqczQNFbWzRCXKAK0333IxyxP86ZkadhPNpN811IpjSaLy5JIvnhAY8r jr2/SrEf2Dy7qa3eGWNpS0e5P3nGcYHoc9PagDOsQbG7e6m277xRlshjtUkLxnjvxXt/hqzlkgF0 bgA5WSC2bkBGX73tnj/IoOevpFH/0/t3/gnxNGnxl0lo2c28MAs9T3RYVHMiSoQw74J/Sv7ANGDN pFpG4GRbIoGOCO36V/W/0sIuPF1F+R/OP0WaiqeFdNLu/wA2j+ZD/gr1BEfF2jTxCxit7bX0R/P4 2RLG7uwP94MoA+o44r8NbqziWSFbbUI4YcSMhl3EuSQduQP0I7Cv65+jpLm8NMJ6v8kf5p/Sajy+ LGYrz/zK/wBktvsvmzSyPeeZumdXPkIg4UEdc575xVeXZbT2yyyKBIN6gc49M/z+lfvB/N1R2mNl kCzbEkR9y+Y7RNnJ9D7+tXbdjE0U8MoU7tsoz+8A9qpOyZM3rY//1PJhcLKRFIu9hJlZMYPP/wCq vdfhT8WPFfwp1KDV/DOrDSrmwkE9tLs3AfvI3dWwCxB2cY5U5r/c7iDKaWd5VWyyuvdqRt/kf89f h7xPX4P4lwnEOHvejNNpaXWz/D8T+qD9hP8Abu0T4++HLfRvGGsWFp4kto0tYLm6YWhu5FVd8bMc KxG5cOPQ59v02uLe3vLeW2uoYrm2uIzFNBMglhmUjBVlPBBr/IrxL4SxfBHF+IwTTjDmcoPbS+3q n06K1z/czgHizA+IHBuHzik1JVIJSW61X4pp/mfgb/wUC/4J3W9t/bHxg+F9hs0QSC98Q6Bpduft 2nYLM0sagcxEnBI+7nn1r8g/2ddL1lfihoqT2V4Iodes3toTbPIdrTKXPIBABUZyOOa/sDw447jx R4XYnDYqf7+hTcXrurfpb8Ufw1xD4dy4L8e8BXwdNrD1qqlHTRa33+bXqmf2r+F2dvDXh9pGLSNo 1sXLLtOfJTPFcl8YrS4v/hZ8QbG1jaW4u/CN7BFGqli5aFwRgexr+Dac40s8VR/DGrf5KR/olnlO VfKcTh4fFKnKPzcWj//V/YH9jv8AYe1j4ofEzVNc8TwSWWi6bd+bKHtfKS22uDIuCOdx2jaOuRyM E1/St4Z8MaN4Q0Cw8OaHZw2el6bbC3hgjjCq+BhmYdyxyTX9B+LnGTzmvhcrwkv3dKMb272stvL9 D8I8J+CcPkuVVcwxMP39Vzv6OT0/A/FH9pzQdJ8Kft7eALrw5ZRaX/alrp0t7FaRCKKSaSSUTSbQ MDIbJ/Ov3KgyYYSeSYlyT34FfM+IFapicnyavUd5uk7v5o+p8PcPSwazLB0FaEK8kl21f+R8eft6 xl/2ZvHDhUfyZLaQq/THmFMj3G7P4Vg/8E+Lya5/Z80eKaTf9nvpSo/ubmYfyUD8KIQ/41g5f9PV +Z05VK/iDj4P/n0vypH3Ken4j+dfx0ft7vbaZ+2Z8Wbd7Vpm1PxdJOyq/wAsLeVnO3phvl+mK/TP ovp1OLcVBf8APt/lI/BfpX1Y4fLMnqSf/L7/ANvpH//W/rd/4Jk6ml3+z5Y2bL5E9pcBmtfN8zyg +48/iDg+hr9GiP556elfo3iHTdLjbHwlv7T9EfL8MVFV4Xwc4O6dNfkfDOp/sP8Awu8f/Ebxn8Qf iJpT6tc6/qbyxW5Kr5itjJJ2nA6e/uK5Pxn+wD8GfD/2Pxj8N9Hbw7r3hy4W+VJrtpbWZAfm256M OuGz04wev1GXeKmeYLCU8uptugocjV9+j8vwv5n5xj/Cbh/E46GbcqWIjPnTstP16d/kz738Mzx3 Hh/RnjlSYJp0UDujblLxoEcfUFSDXmf7Q/hC/wDHfwX+I3hTS4XudR1jw1Pb2Vsgy1xIBlU/EgV+ dZdiI4PPaWLmnaFRSff3ZX/Q/Q+JcFUzThzF5bTa5qtKcFfa84uOtvNn8yfgL9gL43TajpuhnwFq sOl/2vm6v9T014GhUMSZOeuO2fSv3n+FX7A3wN8J+FtMt/FHhS08R69JYRrqNxeriONtoJVR1yOh JPJ7V/TviV4vxrZdhsPw/VTqWXNbWyt5PTpvufyv4Q+B0ctp13xJRaV3ypq1/eeuqP/X/qB/bT/Y B+EVx8LtZ8YfDnR08KeJNAiWS3tLGRbe1v1LDcoO0kMADgHIIz0wDXtX/BOP4f8AifwD8GBa+ILK 5s47udXshdpskkVcgEd8Y7+4r+jM942r8SeGjwuZTTrxmreet/8Agn83cB8B4fg3xKxksvT+r1Ka a8tF8t7r/gn6G1/Lz/wV2+DPjjRvjVP8WTpdxJ4J1JIpP7Xih3WsLGGOORZD6r5eeOxPer+jbmWG y3xEpRxMrRqJxV+7TSPlvpgZTicy8MJ4nCK7oyUn6c0G/wAtD8Xr7WXIlthKkpEwdhD/AKtkIzjO e/FZ95IkPlPEA/mhfkQlRGWPQk1/qlCklh0vI/xi9u6lfml0kvzP06/Yi/Yp8S/Hfxxouqalo23w VbpHPqeoGJri1VfvKSxPsOO54r+sT4e/Dvwt8MfDVh4X8KabBYWNjbpC7xxLHLdsqhTJJgdTjoOB X+df0peOZZnn0eGsJP8Ad0dJLz8/n+h/sJ9EXw3XDnBkOJ8bC1fFJST6qL2WquvdS+bZ/9D+279p j9orwz+zb8Pbvxtr0S31wG8nTtMM/wBm+0tyWZmwcKoB+pwMjrX8hv7VX7Rus/tM/Eq78c6tC9nY NbqLO3ju/MgAV32gIG6bcYyBwB+H92/RT8OPr2Mnxfj6d4Qso3+dtPNrXpZeZ/nB9NDxe/syhDgP LKzVWSvK3yvd30tF2XW7elkfIWotZNJI9usu5wDI8jEjIBGFHYdMVQMrx2qbnRkaQsu0/PGeB+Ge Pyr/AEPpRajY/wAs60ueo5FHy5PnLuHjY5XjBHXNW7NYYXWN1Ch5MRso+Xn1H5mtba2Mi3bTpb3B lMbS4k8x1LZWYjp+PFf08f8ABKn45eC4PBGleEdX1nT9M1afS44RZXNwkLRSDnCgnPIUtj0r+b/p O5LjM38PJvCRv7N8z79Hou+h/cP0GuJsvyPxHxGDx0rPEQSj291yTu9vtr/J6n//0f7rviloM3i/ wPrOi2XlXA1OyaIDiRJlIPTrmv5svHn/AASu+MWvePb3XrK0M0LXskotp7QzQyBj8sg+QnK8FcHr k45r+rPAbxHwnh/9ZWLS/eLr+nn/AFqfxt9JLwdzHxOzTBYvASdqNtvm9dNtf+G0P2n/AGI/gjr/ AMDfh9Y+GdfiniurS3FuftCFHIBwuMgdj09Pyrv/ANqn4neDfDXw58QaPqmsabHf39i0FvaSXixT mRsqFHvgk49q/Psxrz4o8Svr+Bg2p1Yz+Sau/TQ/ZcVh4cOeEzyrHSUZRw8qWvWTi4pet2flJ+wt +zD4osPiRqvxIaznTTtV1dtQUiLEJYE5Kv6Ddn8RxX9AcCmO3jXGSqqv1xgf0r1fGzNaWacR06VL elFQfqrHm+BGTVsl8P6dOtvUlKovSTuvuP5a/wDgp3r0+mftDaTE08Vss+pw2rKzkTPm4t1TGDxj zZCc/wB2v31/ZFuHm+EmhJJIGFvboqYcNhSmR/Ovv/EvLVQ8HchxUFvFfhdfp5n5D4B55PHeMHGO X1H8FVtfN/8ABP/S/rZ/4KYG4k/Z+1xbIt58NvLLuAwkYwQWz6jIx9a/jQuhHJdyojyG3QKWnb5z K23LY/Gv9RvofRa4IxS/6eL/ANuP8XPpyS5vFSn/ANe//kRsNyViZBEYwj4WQ/ffoM0kYbe7qxyw 5z3r+v4xtqz+KXsxPMBYB1yEbPXr/n0qxcSCSN1KAxyNzjjb16VZlJWZWhUJIu3b5QGCuMA08uTN 5MKncw3B1GBjPTNaw2JP/9PyaNZ4pJkcZcDccHcD+NWXe5uLaJcskHmZIR8DcBzkD+tf9CB/y/jW geMKTz3U+3rT2Q/x5wy4zjg/5/pQAjRRpGmSdg6sv3zTfNt3EccRfIQCUO27D9+nb60B5FiyjT7W blI/Nkt4yHUAsAo5OV6dutQXc4uZ5ZYYzE5HIjJVcKO9JtLcD//U8qEjzBd2A4XOwNuPv/KomfdJ 2Tn5uMDiv+hA/wCX8fcW3lqs8cySbhz5YPH6U+G3sbpES8F0ziTO+C4MO0D0wOv1OKAGPCysY+u5 TGNy7sAgjP1FX7eyht41Dbjtj2KC3AP0/LigDNglS3kuo5ow/wA3ySupVUB9PWprZ4d26RDKg6KD gN75oJj8KP/V8nmaQRytC5Q7gFjxuJXqfbsB+NNsYDvMsh2uyFd2cHB6j9K/6ED/AJfyVxKd0cS/ MDyB3qZkXbhwID5YypbLbsd6AImRFhb73mDvnjHNZkCbZQV3bjxnOc0AXo3Es7JLtjGecLhR+FS3 iLbykRzJJEQNpVSP50Af/9bysp+4Dlcgd+9RwRku5kdbcBCY2IYlyOwwD+tf9CB/y/gpZD5UJZnc 5BIyc5/+vSst0PmYbcNtO/OXI9BQZyk07ImR51YMGEiAfNtJ+TnHNXWCJhgmHIyfegnmexnGYylS yGJ1O1huyh9xWjC4jXaH2FujD1oJP//X8w8kRGZDcOx34bd/Fzn/AAqvLbAusiuWVAdyj7oPqf8A Pev+hA/5dycmCJTxukdSqRgZ59TWdJtMLRMnLA4CiguMb6ly1eSKERrGR5mN+4cHHT6VfSOGKK5k uovPkaPbbRIcAHn5ifbjjpWUm7slqxHbpA1s0zjZLuVQvQAnPBpJWYugVdpjX+HIzjv/AJ9KgR// 0POYZ49+ZB+9Iw4z8xpDHtkmkU/LJjCEfcx71/0EH/LuZ7TB59gDED14FWPLMuFBdCvO9CVP50AT vKBlSD8vfHpTJJ/NA8qHICYJ3cZ4GfxoApJEyBJpgC68svOM0+aaTGY1CgkA5GQB3q4x5kB//9Hz Jf8AVFtxUjpx1pgUKrgTLIrn5WAxn2r/AKED/l3I0UBP3mNw44HWie0aBUeSIq0oDqSD8wyQD+lZ 1OgFyC3Y2rSINxTBdeuBWejb51QnaN3Q8Dr604XtqBoXXAWRGVTGNy442kelV4XZmX7UGIY7gHBy R1BqwP/S8vmuPOu2ggjKxhtsRJyzcVKkEyISJNw3ZIY5Kc1/0IH/AC7kssVy9uzW5UyJyVPJf1A9 6oxTSoMshkDEIRgZX/OKALkEzwvugRmVgUZD93B4NSPbxfNMpw33Spbpn0H4UrhsRo7qBHIskkJb adrBWQZ6A9upprq0e6KF38pTtjyMKR3/AC4/OmZuS5bH/9PzNnEwWIqwYcB84H5VbhjEUeWKswO3 dwGJ9cV/0IO3U/5b9gnhuBgsAyOuYtnJOOuarqR5Q38c/MDgbaPQCCVGdhHEWIz3NWfJDRLAwyEO 5s888Y/lWMrX0Hdkgi42xgEj9ccVD5my48tm8mZIC7IflIU8En/PepNou6P/1PO5iY3WGTcytHvL RgEDIBH48/oaqIj7oWZ5JBH8iLu+6M1/0EH/AC6T0RcvWgiRAJD5hbLQ4zgepP5cVNbyW+5ysEBE kWxPPj8wRHP3ue/H6mgqOqGGZ4LiVNy+UOjRn5SeelWpZPKiQwtbpJM/715IRIAvT8+vSgZDDqGo WTyW9vLY3EDSrM6taxyyKV+7h2G4degxUV2bi7drmSIEgAM8cYjjXsBxQB//1fK1uiJlgddw67sV rRzLGyo0KvG/VgMOM+9f9BB/y7leaKMJ+7I2Bufmw4z+vanJ5caou3cxGEBGWc+lKV7aAVURzcOj xlXU8lhgj2q9LbCDaFV9z/M+Tu555x2+lZckgM6dtjICrDJ5I4zUyPEzumWdF6KQCw9M0JSuwP/W 8zFuJHHyBEjO+MZ71ceLAgjDAO7lWDfKFGBg5/Ov+gC1tD/l3Mq5tLnz8m4zbwuV2Aj52OO/tVmN HZsBSFA6DNaQv8jaO1hkxCwAKpZxKW3McsMdgKga4O4SON0m7e5Yc5ya0KGyxiY5jQ+ZK+EVV4yT 2FSfZ0yIhMI3iTDlh95u4FAH/9fyxmEB2AF/c4JGOvSq/ll3B2Y3HJOMGv8AoGU0f8v5ejjZSTu2 Iw2YzgEimvGApleQBgQqxquAQByf0H5mpm+gEEirICT/AKvdtWUDvjOMe1KEaMKd+MdCeprMBFkZ DIWbPm8ZIz3qV1JVWkJd9u0E88e1AH//0PIIoEv0nSOVf3MvlTKVO4EDJAz9R+dSuWj5bc5jIRsd PTmv+gA/5gFa+pYSHO2QgEn7pxyoPUD8hUL3Uccxii4YcSDqTxzQDtfQaluZ/MKnGDl8jAFL5Xl7 Rk715GDgcetAiUwtIxkKjco4A4Aqe3tJp45ZQAscQy4LgH8s5P4UAf/R8xubtVtfLhijLcL5oGGx n1/rWYWZwomlCqGDZc8DBr/oAP8Al/LEskiNuwGV/m3IAAaYsuGAK8MPXms59ABmQY67V9Bg1EED OJEYgZ+dW7gelL3dDaLujRuEV1jELMvyYIbqSODVMwyhMMwVivAJ4P0ona+hR//S8fRZMFEdVkQb tp6t9P8APepYDLKhEqGM5wSDlT71/vwf8w9uhZihIfyo5QODiRuF4z/hULSyITFG+S3DleA34fhQ FraCyiVbYEQklHy7nog96ZEbeZY3Mg+0FyDGFwAgxhvxyR+FBjL4mTXiSskLBwVXgArzipLeIrby Sq6NbjDzYPAPIGR7c/nRYUd0f//T8peSBVc+WFkcYLZ7duPxNVRD+537gMt06mv9+oJN6n/MJzJP UrlmgSR3+4vQjJNMjtDeESHcuPmBGVORVqC6g5XaSNJFZUKMdjfxN3NQPGUz5bCQkEE9QBU8qU7F iLGUiVmGxWGFI6enFN8t+BbNGSJQs5mUsqA+w5q1FJWA/9TyLZBHI2xlkOcboyduenA9KkCqVcy/ Myj5ABjNf79SVnZH/MOMaWUIixIoXPUxjj196gjAjdpCElkU58thtX8qkqMmtAS2SVxc3R2eWpwc /KfqPwqaCSR0k8hxtkGExwccfzoNk09jPQmNiyL+8LYyvIzU8qTyxO/mJFJxl5XwGyenrQB//9Xy D7N9lChZFuMHdLtlLp68cZ/OonlikOQjJgnahGD3r/faXws/5jxkl0BFsbIRT35J/wA4pskapGZ4 /wB4QnygnGPb+dZNNbkuVtCKIvIjFidxPygcYx/+qka7MXyiKNpGG07ow236Ht9aRRrp+8iilkUo FwhIGFdvrWRPKRcOjOwPLAtwABxigD//1vCmLyrgMydi4OC3uKnmjEylkYJHHGqsxJ3s3AO307mv 99Ix0P8AmPK8Vrb2vAvTcsreZLFI5eVFPYscdPWrieVOslxAIj5EgQx7syqDnp+X8q0NaexFKVZs owB6shBJP4VXvbe1leFkRBLlcFwMREdSCec8dqLalk00MkTRtIvnKh2bgeDjrg1FN5LozKfKZTkn PQUJWVhrRn//1/DZJoIoLaaN2MrsUG0cYAzuJ9+lUgA6PKhR5Q2PlGFf2/DgV/vwf8zydyyiqo/f FQSMgBcc1V2vKxAwMHjPB4oGITMFyRsiDYRs53dM8fjUhcOPLdie/PAzQBW8tHdF3bAjgtjuB2pj wSrNPMH3xyyjYi/8sgB05oA//9D56kJvdpS28v7I3lSzMwEb55AA68YOaakIFwuxn+VSGwT5Yzjk 1/vi23uf804t2h82BYiWO8hwBnPp/n2p8z7Zo7cwMJUBUykgqMfw/wA6QGnGXgdU+zxSsUJyQGBB BHT1H6VVfzDAfmDBX37I/vHB6GgNiETz2hW9t9qSSxb2iYKzcjBVge/GKpmaFo9iRN9od8lmb5EH cAf56UGnPp5n/9H5whH2KN1IecPcr5kSscFSeTz0x1qQIuRuwNzfLuIUDniv98D/AJqFo7mpcNLE 5iXy5cqrtLGMBcDkD8/0rn51naUSRuGdjtYMMqB3NKTsjWMk1qaCu0EKKW3qv3Q3NLGIpZFmaESI h+ZPuhvxrAoSxR5pGhkjaJlbMZkI2gfhU0vN2kDMizyttikbiMY4yT2FJ6I1gf/S9z/4J+wR3vx1 tLfy5Fv102MzzTRg20qG6iVRE+euC2fUMK/tD8PxtF4bsnckPHZqRkY/hyOK/sr6Xk78VYSP91fo fxx9CCny+FtWX/TyX6n8vf8AwVk1Nrzx/wD2UYE2rqDTz3SLlIhHEhy2fUz4HpX8/XxVkFtoWsDT jcAXsMdrIVP+sYNuKq/YfIOPev6s8BKXsPDbDecb/gl+h/GXj1N4rxnqR7VEv/J2fgD8UrK4j8S6 kt3KZLh9SlLbclEjCoIhnudu3PvmvKJYpmUlEkXa2xSFJAxX+cHjXLn8Rcwl/e/RH+qHhxD2fB2A j/cRn2t7cxDyVQOCxAGMEetWP7PZn+1yjlhjaO1fkFraH3lj/9P+MGSJpb6S3WUTWrwA7JMKyvxk Ad63rWzMSKoiLyHgAHOz3Ncc1qYw+JGFqWnXVrLFdvgq033eh2g8gj6VDctE5Z4U8lG4VM7iKzLU PMSzngiZBKJWG7GI1z+dWdTJXbJG8qIW5KfKRjsT6UFKKjsOgmEsW6NykzjBwODii4uIFngMEgka M7JwvHzHHUe1BS0Z/9T+NhI1jikEZZmmbzHDEkDp90dvoKzRBHFud4sIwJZn4GfX+dcCdrnQZsm0 x+TbiMIzl2KIN351JFPsXHlMFCgKemMetIDUtr6GaGRFSQS52h24Rcdfr9axbj+0TI7pZQyDiMSO DtPucdCP6UDTaViJ4G2r5q4Y/McH9K0YrZHCzTNtIG7yicn2oG5XVj//1f4t5raKNZCLYOZOdwYh uP51R8+QXMaEyqigEI+RjI715U9zujpEdLGzStlfMhB3c/NtJ9KvW11BAxeOKWR4l5hx8khx0BpJ bmcndlS4gVhJ5EZV3jLYPG0kdKih0yVOXIRAnUrkOa2JLTTWwtY7ZEIuBIc4H3gR1J/CmWDq7ukK YVDtyTznvxQB/9b+Le/sZxtAXHzZLHpjqcVDBdRs/wBmRHS4xhWX5lYdya85q6sdBemURbUjxJtG ZG24Yn6ViPPDl7iQFIo32KZVwGPsKwHyvsTq4L4LlmfkM57fWpXWKCUNHKZXlXbtx8rDvx6UF2aa Y598qlRblYrceaFibO7oDx6/41nzRpIbYQ+fbSiYtOr4Kkfw47is5rqaH//X/ikuo7gR71li8qIZ kDDBepbO301LlrzVNLi1NHt/JS2uZHWCFscPhSMkeleA1Z6nqQWjLMEUUSBY1yqfLHGo4A9KI1YP 5SxM6mTc+fuJmtYfCiZKzLUcKidYmBG4fKCcDNWAkMqHkDY+1wwwoAqiTHu457C6aC3gS4S4TJIG 8L3/AJZ4qs1957GBJJVl2bcEcN7denFBtHSKuf/Q/iksoftN1HFNmCRSdonPlrgdW+nFbjyC2Dpb uJmHyEpyo65rxz1G7xYtrK5QhlVmfIYfdFV0dY0mt5typbMSjff8zPJx/L8KqK96zIi7Mnmv5bmD YmPKij8mLCbQo5OPxyT+NZdnLbyBvMxK69ARn26etdNPcqe4rwqzR3ELSRRRy+XNbbdpyeSyg/0r dt7yINcbFdViIUO643ZB6D8q062MEvfP/9H+MicRzWkqb5bWAKRHcK3lyAk9Fz61+mH7K9jocMWi XtwZwLbTopooHBEczlETypx3BG7J+lfrXgzS9rxth/7t3+KPx7xyq+z4Sa/mkl+D/wAj+ib/AIJx 2FrrvxsEjaVFbW1jbefYzECRUiAVnUL6AkAHrzX9gyyXNv4DAtsrJdaCLiWOMCMRs0IyPbIFe/8A SElL/XrDR/ur8z6PwHhCPhu3FbuX6n8Xn/BTi/i1P406xhLWHT21JvIkh/eSRvbsuRz0BIH131+D P7R+tLeeFtctGaaWeaJFd1BN5GkcqhfKHbqD+Ar+seH19W8NaUX/AM+v0Z/JuYUniPE6pJf8/b/c 0fkH4iMchljkaWa48zIFxt81QOBuI4z0rBsrMyW7s4GACWK4Dj2r/OXN582NrS/vP8z+5qHuUKce yR//0v4arZFE0IiyrKcB26YNd7pGm3EJW8WfzLSViPmcOwYdcDqK5JuysVSZp3mo3nmSQTxotooC gxrtbbjq31qRnRrHfhQkZ/dhF3SHt0HP+FefVd3obHXeDrWG8ml+0oGQwESNPmMLjkH3/wDr11lr c6fKtxJcJLCtrI8MTJGWV8HGCB6ge9cNR3Wp0RbWqF1ARfZrW8+zxQPfIVt3gCrLMI2KgyAcg9ev vViyh8pDKy4kkiw2eGYAdKwG22z/0/5GNTfUYbbTnt7ATR3Vw0EssUm0W4UZJK+vQf8AAqpedM53 sGZy4iKMMYA4/pXxF3sd0mkrG4bHRn06dLsMLkN5MSwxELtODvLfTjirk8trpj2Nq8Usr3dkfspx m3ChRyxHQjsO5FXT7GSk0c/NYatFC+q20ZFg9wIkFs++clcZ3Rj5gM55xitax06HT401QMLa4csb sg5E2/t65zjI5zilzcrsI7ARXemNskltnMsiyqkdwrD5gCFbBODjsa6zT9TtFtLuO/snS63+XFAM MCo5JwfatZawsELtH//U/jTu11NtPkhs7j/RwC3ls2OCegH9Pan6ZFLDaQNfPhHba6eaN6HGQAvX HvXi3vA4ay/eIranHHNKjwS4DHhY3wRjj5hn9DSS2ktjbQzy9ZMhmUdR/jyKa2JMm5mntiYY5Dul TfGJFyRn2ogjnlaGCchBM4G4KREOOrGmB0kdg6zIivi1LGKK4UBIZ2GMjnkHv+NWXtQi8uGXGOvI +lBUXZn/1f4xpbUMhm8p/Iil2ybQWZueoAqI3Uaw3H2Z5vKJ+zS74zCyHjj16jqK8c5yfTo7W+mK Xsk4trG3Mt1FAu6ZlbIU5+oP5Gr2k2ssMyRFZ0M4xbLcjZIwz8px71107gNJe3ub8wttuBmKSTb8 yEghsDv1NUPD0cekhrOGbHnXDTgytgSMeo9PpXXTXQLGjrk8ixTLkpLbZjlUP8khYjr7j/GvKdYv HdBGsJnZztxH85PtXp043RjKPKf/1v4g/C5FvqEryCSLyljuRuTf5XltuLKD1IIHFfvB+zTdSap8 NYgVuUf7Pa36xSQgSuxhVJGk9CcqcDg5PpX9PfR9m48TTprZwk/xj/wT8L8asPGXDkaj3U4/lL/g H9MH/BIuZvD+rW+n2pMkF5qEE0khcK1tM5JcFR0yCpOa/qm8c2Z1Lwdf+cjKbm1MMLDG1RtwWA9M dPwr4bx0p+y44lPu/wArH7D4bSjU8OcNFdIH8Sf7eGk3dt+0J4otheTG0/s95IXvIhFbMiysE/e5 5Yj7oP8Aex6V+eWqXekadFaJNby/aGmNvJKs3nJnBYMy9h2z06cda/urwolz8D4CX9w/zp8VKXs+ LsbT/vfoQz3dvqVpFElpJ56E+Td+flFU4yNm3k8dc1V0g3ts2o/aIWktbeUfYEMIWS5YAFmDE8dg BwODX6VHdH5eoqOx/9f88rzVLq51C/FzozaQYpUleNsAyHYAHYA8NjucdagiuVuIRBJIXWObzUUH A4ORxX+0Kdj/AB+qg8866hd3k7C5lv7ZbZOBEtkUZfm2gYOVUrx/e61nyyT+RPYxiHE8vmO+0l4u vCt1H/1hW61MB2n21hYiWGeZT50Xz/MZZn6/LnP86beaZaSmJYJ8pBiUsQQRnnH4c1SaSaZzzb1L kuk6XY3tvfw6pcX8cmneXLA8Ihgt5XPIUdSRgck9+lSRMl0H020knYOjSSvtbyQMHgtjg9vxqrrn RyyWx//Q/OOfUptLgijHlW0cpCoQu6YsSRkjnHTuOgps9wI7eIxXc0z+YSJGOJG5JJ9vav8Aa9O5 /jJPYpWtyULeUXl3Aod2dzk9Qec9f5VqaZbxLpt9PNeTJKh3QRHLIc9gTwAenX0pmRlwy3CqJljk iBOQSpR/wrR0SGLUWuwzhdRt0M9mkzEiYcDJ9MH1oAUaY1ndx317c3M8sMZ822jJEMxHdl7/AEq/ cn7fcw3cVuLO1BEkUMO5lPHfJ7nt2rWDvoarSB//0fz/ALKeWwuluZ41kt5QyXls8YkWRWBAAXoC M1auL22t4nt7e/TToCVYSTD/AI+QGB8kgAj5gMf1Ff7cH+L4KLe1hMlxbfZbC72x6Wq/JAm0gts/ vAdMds+1VLm+SJrryFku7ZoxGQ0W51ORmRfQZ/Sm9TSHYlW+McFqlsCypFskRRudmyTuq0tvd6za yCzeIXFunmvHNIEeQZ5xnpQnYh7lGwstbv7xoLm6t4TbQeQsckgitwoOfl25BPv7nmpL97mOB7eP 7KXZCsMMMpuIUYALuPfJI/8Ar1rDaxjNan//0vhTSrC5sNElS9vls2u5PPNxHEHKSBQApBB4wMY5 61pWQgu2WWXVI4URc3LTxsXwMcrgHn2r/cA/xWkroqWsEN1Y3UTaqdSsr190Ujx+UhB4R1XA5wR2 /OsrVNAhlfTLCDUDbWyahC06rBuEy5wxJHPHHHNVBXZzTdlYbNZf2fEzWklzcH7e8DNKfKhZlxjZ kdMYzjNb17HFC0lkIrabULeD7U/ksG3Dbk4PfHPStjE5TTdKiMV7dTz2tzIPltIfnWe33YycDg4x 9Ola+kadcpHcXYVkt4oywnc7VkO7GxT3PUYq4xTWpi/iP//T+HbO1Tyrm7mjIuUkDQopBXyiB8zL j5Wz7niqmowveS2rxQvdpduIXRh+4O0gj8QfSv8AcpRukf4hTVmLcI0Nu8cc/mfZzmSGMbzDkc8d e1WrGePSNPtjBIbue93y3EIb99EqsQPMGOM4yB6Ck1Z2ILz3c0ojmdQlxjaIYV3YHp+P51jgTvfy TSTyvJcpxbIMRWwHsOATSAm0a3ii1e3jvW8mO6dk+1PIsKR8Hhi3Azn+dW49Gs9Oa7P2qO6jnmMd uqXQl8kggkjB5B9enNAH/9T4cjsP9Ia+SO5dowII/KYlBuYDJXocZz7AVBbxzprLxOquwO8S7wE3 ZyD/APWr/cg/w4e7NaXU5rKPULTU40uftLB4I5BumiI/iD9QDnoOKwNOuI7O4WW5TEj3GYQsW9cE dD+R6+tVD4jKa6nWXWpyXlt9lglWARruidUDSDnJBz1B5Htk1if2Yst1HOkqC5UgRy3HzpGSRk1s cso8rKcn2G4lMMnlSS2kh3yREHB6ZyP881Ykvr6A2NjaWr3CrPkFFxLKHwMD1Ax09zQZzWh//9X4 qFsljdTyvmydF/fRTkp5A6ndnoB71VR9IfWmE8jzRwqrpcxW7+ROTwVVyB07/Sv91YPSx/g3N9Au LUR3Ui2PmzpK/wC5EnGc9FH/ANes29ubg36abLp9xa3cCrHKG+ZXYjqD75FWZ7CJfLHcNayFid4i lklUrEmevJ9M9RW1stY/INhex3UqyN5scMfmW4wcfe6NnnpQZuVrWJGubSK1llubRrmWSQQRlJNv kZIBZh6duK9A8Ll7OJIlilKQnyW37iuGUMCGP3hzwQSMjHag5MTJqJ//1vrb9gi6jsPixo9v5kxi urdL69RT8/mPJCods9goZR+Ff2O+FpTcaBp0+flezj8vDbjtCjB/rX9gfS2h/wAZVh5eS/JH8w/R Jqc/hWl2lL/0qR/OF/wWS05PtejOul2zbtZht/Oc/Z/MaUxRBgf4s7hj8a/B+fQJbZWe6ARQcnb8 /l47gV/VP0bJ83hnhl2b/Q/zv+lLT9n4tY+yte35HL/uMSRzSMVl/dhRkB8nAFT3kEXmRSTLIrQq pSPGEZcd/rxX9BqCcT+YJazIGnsZpFgjRYZTlvl4J9af9mXerrK2UONoHWiC3THNWP/X8YtXtWnk R5tksSiQREHMmSBgfz/CukuMratLCWG1NwK8vj0xX+9U46o/5usPKyaZ1/w7+IeueC9btvEmj6lc adqGl7JbKKKY28Tsj7iGI5y2AM9q/qp/YM/4KEaJ8c7PS/h74wtW0TxPZ2KRW1/fXeReHHyo7N7/ ACqc/wB0c9R/Jf0nvDj+3ck/1jwMG61Hey1dk/m7rTTqkf319DTxVWWY6rwNmdS1KXvU7vRJtX6W Vpa6vXma2R+rV5Z2uoWlzY3sEV3Z3kD21zbTKHhnjdSrIwPBBBIr4F8NfsnfAzwT8eW1ews7S1kn Bu7PRJZUSxikZNywxJxgg8hck4PHWv4R4bzXPsooYvCYBSUKkJJ2vpZPXt5fM/v3iLK+HcyzXA5p jpR9rRmuW9tbtad/NdtT9AURIkSONVSONQiIo2qgAwAB2AApWUMCrAMrDaysMgg9QRXyfscRKvfl d7n21XF4R0rymrevQ//Q/vn0/R9K0kSLpem2OniZy8os7VLbzCTnLbQM1okcEfhX0FShjJy5q0W5 eerPAp4zL4Q5KU4pLoj8D/22/Hnhmy/bR+HOo2+tWWzSreCyv5IbuN44riJ2LRswPXGz5T0r9y/C fiXR/FOhaXq2j6nY6lb3lhFP5lldJcBSUG5Tg8EHIOfSv1HjbIM1fC2TYhUZcsafK9Ho2k/u0evp 3PzngXibJKmY5vSWIgn7eTWq2u/M+Tv29PEfh3T/ANnrxjouqapZW2oapbqbCzkuo47qZoj5gKoT k8heO+eK8D/4JifFzwtrnwpuPCU2vaVHrunXJuDp8t4kN55ZkkVSUJ9xXo5dw1m2L8K66hRlzRnz Wta6UtbfLX8jnwvFuQ4TxIxCqYmFpwUb3Vr8sLfl/Vj9QrzVNMsbSW+vdQs7Syt0M091PcpFBGqj JJYnHav4yP2/fFWk+JP2s/iBrWj30F/ZG/OoJdWZDWjlSFXEgODnIHB/hr9D+i1kmZUeLsTVxFGU Ycm7TW6kup/P30xeJMplkOVU8LiIymqjdk07WdJ9PJP8ex//0f0C/Yw/bU+KvwV8SWmlo6Q+Dr+7 RdS/tFlubeS2DdQGAxgnqOQCcEHmv6ofhx8Y/AXxL8NaT4g0LxLokjahZxzz2P8AaUS3NrIyjcmw sGIznBA5GK/sb6RnhjicvzlcQZXRbjU+LlW/Z6dttm/OyP47+jR4vYHiLhV5TnGJSrUdFzPp1Wvf f/gs9BuNc0W0GbrWNLtgRuBuNQihGB35YV+L/wDwUX/b21r4aT2ngb4ReI/D11FdoINb1S1b+0o4 nLqrBpEBwFPHyn65BBH5j4U+HOZcT8WYfA4yk1RWrbWmn9XfofY+OPi1lnBXBVbHZdWjLENqKSeq 3b22vbl/7e01OL/Yc/4KJbryXwn8ZPE0I064dZLXULmFYY7dpTtBiwdxUEZIx0b1ANftXp/xT+G2 q2cF/YePPCc9pcjMMn9vW0LNxn7jOGH4gV6/ix4V5rw3xPP+zKDdCW3KvtbXt2ej08793p4VeMHD /FvCGHxGOxEY4hRXMpS6er6rbX5eV1PiD4EkClPGXhhgxKgjXbbkr1H36xdV+Mnwp0S3lutT+Ifh G1hgjM0hOuQSuqjqdisWPQ9BX5nT4N4jrSUVRlf0P0irxvwxhqDryxEeVdbn/9L99f2hf2+pdW+O GlaZY62Ln4NWOoxo5htv9GlLHy/MmBAbBDDk9Nx5xjH64+Av2o/2e/E3hzS7rRPiN4YsbQadEVsb 25GmyWahANhVgFyMEYBPSv6X4x8Kc7yzh/Lv7PpuV4vnXeTS139fS9lofy14f+M/D2cZ3mM8xqKD 50oN9IrRLRf1u9TtD8ffgqMg/E/waCoBIOtRA89OM18Zftv/ALR37Muo/Abxz4S13xN4f8ZahrGk yw6LpFmh1AxXaqTDOX27V2Ngna24joK+a4D4H4qwvFWBr+wlFqpH8/I6vGTxA4Qx3h7muAVeMnKj Nej3W67o/jm1K1uLLUroGFIreScNFFEDiIMoIU59KlJCTWqyxieN3DNbl/KM6g8qG7Z6Z7Zr/Xin D91FeR/hs2va38/1P6Xf+Cc37b/7P/w9+FNj8OfG2oyeCNVt7a2vWv8AULdvsN6zpsKF+uVAHQEc mv0Y8T/t7/st+H9GvtUi+Kekaqbe1kkt4tOt55DPIqnCAuir14OTgYNf5leKPhRxJmfiJi61KLdO pU38tn/XY/2k8PvHXg/LfDHBc01z0qC021s3by7Psf/T97/a9/ag8d/tC/E3XNS1Lxjq2qfDl9Rn l8PaRdt5FnbQByIQYlJ4x8+BkDIAyAK+PVvgyNI6MmxgqIrBVdR2HHGf85r/AHF8POFcPwfwlhMl oxs4wTl095pX0u9tI+dr7n/OL4i8ZY3jnjTG8RYyV3Ob5db+6npr56vyvYzpruO5d4I12PLvdCMl UVeWXd0JGR/hUUKrHAIeSB8qFuTn1Nfdw0sfESmuYFhlkJG4KgAwP4ic1ZmSS2CFlJDJuViOo/yK vRzJ50RW15B+8MxeNUU7Tt4zXtPwx8e3fgrXNN8SaXqDz3tjseK3ssxMFVhySMAsPc9vy8XPsto5 vlVfLK692pFr/L8T63gziHEcMcRYTPsK/foT5vls/na9vM//1P3e+E3/AAWY8M+EvDlnoPjzwZqU slgq2UOqFLgfbNqj5x8hBHPfHQV61N/wWu+E8Lhz4XkW38wR/vJZkkOehyFPtwRX98Zt9GTOFmdW rhIP2U5NrZ2u79G7H+duRfTM4dll9Onjpr2kUk3ZrZWvqtXoZGpf8FuvhO3mrp3hNbtEjYidL95d jKOhwmR16Yr8cv2ov2xNS/aB1yTxHprXWmRPffabWwid4orZC2TuJOeNoHr/ADr7bw1+jzW4dz1Z vm8fdUWldrr5a2frt+D/ADjxh+lZg+LMiWS5DU95TTdk1e3eWl0rvbf7mvsz9nL/AIKtzfCDw9aa Pq/h3T9ctIIktzdSzvFPEAoXJReATt9SOOvWvpTWf+C3ujw6a8uk/D62lvnJ8hTcOT1x8yZP1zXl 8VfRqxee5/VzGi3yTlfeK/P08j3eFfpiZXkXDNHKKtvaU4KK92T1t5afn/n+PX7VP7S11+0R4vt/ Hd34ct9Ku0ukmhwxEjtFKsxbJLDGVAB69ODg19o/s6f8FZvE/wAIfC1pour+E7C82RiyigkneVbo RKoSX5FG3cAe5PHvmv1viDwcpZ74fYThCWs8OlbpvrvpqvuP594A8fq3BfidmnGSf7nGt82l/S61 dt9tdj//1f0v/ab/AOCnHiP9oDwdeaBbaFpukWkoMdzZwsXSIspxncQ7dB+PcV+Ps0zG8cyxIsUk gIihAxEG5GPwNf7U+D/h7/xDzIp5XL4pSu1e+i2+er6vS3W5/wA+njt4lx8UeLln1J3goqKdra9d N7aLdLW/SxZZEDCMkbnO1AB16/4U1IQjOkrKPmwMHBH1r9fPw+Ure6QJEJDPHGyt84WP5fmb6Urm 2hCRqJQekhmO4Z74/I0GREiKZfkOUDY6YyKnuRGHc2+UwcKSOo7ZrWnsB//W8sYyeShLAtgltnJz 71XiZiGjEjxnPzEjjB561/0IH/L+Xy7iALnIHGSOuKWOQqoz0Prz+GKBNpMRSJX2vgKWwQ3AFVo1 jW5k2phN23ftxn3pNpbi+2a7oywuIHKCRNrMhwxHcGsoGCMGNzh2bB+Xrn1NRJ3RTaW5/9fyY26R 3FwQ7bI8COJACqjHcj8KFlhYlcAFOSO4r/oLhvY/5fou6uywk6sCpyFBwSw2rzx1q7JaC2TJ5PDD aQRg1qMRFNwu1SA+4Yz8v6mqr3EzSywSIVMLeXuByG9xj8R+FAEuHNrLtRGG8eaz/eQDpj6mqBjJ 4DGPg4wOtAJp7H//0PIomKGRJgfMY4Q9Bj3qZxt25JDE8YNf9CB/y/j/AD2tBkIzPIwVT2HNSyyR uwMi5c/dOOM9s0AMmgnhjMvmRsSwUxdwO/t2NRxQzXEsKWsEjsAZZnjQtFEqkZJPbrgfWgCSWBnl 8tEyxOBgc0SW37pZWwyhtmSRjIxxQB//0fLXVxEqKcKeq0saybsuflVcL9BX/Qgf8v49i4kh+zAG YyAqFXfnn2qK9mn85WbcA53shG0AknPFBlNa3CdkgjMjqxYgBNpwpB65/T9a1oZGMETgL83C8Alc euaCCAMqsx2r7nGTWY8j78gkqrcY7UAf/9LyoXPzHzeFbjJGCTTFnk/fIbeVxjKvGcIADj5v0r/o QP8Al3LttvLi4jCbIVxIrkANkEY568Z4FNujJcyxCO1igjHEk6/u0j9Nwz+HH60G0PhQ/wC3FLcx SGJol6OqAHI4zu61DukBGXKnOY8AjA96iUXqyZ9AeGcKcXbtGSJGj2hQSOgPr171JkyoCGIfPzMO WrNqzsZn/9Pzk6VcXCyX0UNxItqQZrlUJjwfU9u/WmuGIDqDjPBPRsV/0EH/AC7kMi2wZpmZULdg AFB9KswyK0PGF2g/M3JPpQBUd5RGQdzBnwdik5HOOBTQWhHTg9V6GgBc/Jvl4G4DaTyM1bDAny3R Vt403R4G5pG/2vpTi+V3A//U84EMtwW2o3I+VFXOcVXWL5AoCqEbk/xNmv8AoP5lsf8ALuPkCKoI IGOWB56elSxTi5X998zRrtj3fwqOwpS6AVJYnkffFLNFOvyKqkiDAz1XpTGtzEyGclmILAr0+uf6 VQDwN4xKm9FPG4cN/n+lPljCpvIIwOD2AoA//9Xye3bB2spJdvlfByKsyRtGpDSF88HBxX/Qgf8A LuTWkk0MTlXYlTkZOGUd/f8A/XSRopxKJ0PmsR5PO4Y7n6/0NAGgEWHjBYvgtGhwzZ5AB96ilksh G0iRTQxhgpjuJhO4PuQoH6UmtLEy+FlQSO8rYG1ByijnFPjmDSBDhQOpojtqYn//1vN55FVw0QBV eGAH1qWKeASox3OgYbhnB9xX/QbNaH/LeTX08ccgZHwOq7WzgHtUKQidPkViSu4jHI69azu1sBGt u8YXYNgVORu38/5FO/dgI3nK5lX5h2Hb/wCvSAmhtZgxk8zdHn7g4Zaju5JWuzcRCIq1obacOu52 GQep9cfoKBxdnc//1/O45kaPekWwqPLKOv4Z+h/rTbVlkmZCQrJztByB1r/oIP8Alyk7uxZezEs+ UZZGYZkPTb9c96jW3bcYoEaRxncEXdtx1+lBcX7pC0aI7B0kdR02nawOep61EYo50ZVkcmNvk54H qD/hQNNPYltbaCOK5mZts+AEYDhznGD+GfypXmkgVMLK63BKjap2EqMnJ6cZHWgLq9j/0PNdiRYl ALptLTHbjyznimySs3yx/MMZyBjFf9BB/wAu5WHmNFIRGd7DaAw25we35frV9IZEgF1cJLAApS3Z 4zsmYFQQD04yT+FJtLcCGGJlLySSF5GO7BHI78VV+1XoKq8bI2dwbrwDgUuaIGhNczXT/aLnEkzD DNtwBgY4AHH4UboEXbgCRuSQOOnehSTdgP/R83DchJ3yinzEZR8wI5AP5Us7OU3q+985GeSK/wCg VaybR/y7kKJ5mJirKxGGUnPI71ba6MbbIQpkCfeHzYJH8xmrAqYYbVdC0iLvc44Y854/LioJJHWT bJbuqyDKkR/KKC4bhI+CCp8sIuFCjB3Y4/X+dUrWKR9xnyF3ckHH5UGp/9LzNoBIBHE+Ah+UsdzE Z71DeO0C7pHKGHCMrdV7flX/AEC8i1P+X8l+0ols4fYxIAG5N0i85yp7dP1qtbTxXAYMDkHaDjGM cf4Vm1Z2AsKFV1RGQxlvmY52rTJGiupJYwpCgY46AUgE8qNlVOdyt/wHAp7sTtEaElGzknjFAH// 0/KIJJBqV6vlRxw3RSdJWb5g4UIVx74BqaRVPmxE8sCWUHGcf4c1/wBAB/y/lW3u/KjX5wGViFiZ fmX39P8A9VJEZSuy6aFiWLiZIAj9+CeT6cUASiSW3jMYm/dzN+8ZVG5Rn1qdYwZFfzdgCfecZ3e3 40ANExQMMjDHaO2eajl+ZTtz8q8n0oA//9Tx1bhtjWYXazjep74Xj+tSlHlEZIBfGw/w9OMn8q/3 6lfqf8v5elt3SJBKArIBt2ncHFQmKNiNp+6uSAeR/nNSAxYikEhk5Yc7Mc/SoIZH24mXDuMqMY8v Hb3oNINJWZY85XXG4Dy+M9CccVUl/eLl9xI/1JLbef8AOaDQ/9XyK1aKNldmBmKYdWXKp7Amuj0q 80GycTa5NmAyAG1jDiaZcjcVIUjOM49xX+/B/wAw5X1GLSJNSY6PfTXGmowlgnlhNvM6kBjGyn+I ElSRwSuR2rDnRRckoWRl7E/XGaFe2pUuXmfJt0vvYdO1zKgjmOIpF+fZ8u8DjtViEQpb5VBuXgKB 8yjpmg55fEVTvOSWOCcAdxTwwRWjjYt03qeP0oFHdH//1vI2g83AA+6eanuopI7VWgi80qRuQHBA zyfw5P51/vxtsf8AMA3d3KDyKyxxMgDSfMpPI44NaMaN8iRbVUL82ByTxTu+4jPuFYMEeVg28A47 D0/SlQfZrlgkwnDx7QpXCgHr1780Xe5pB6snmLOoG8+XGPkTtn6UQCdJCr/KZMM6twT6cetCk1sa H//X8kltY0le5XdHIyiN/mPlcdDjpnn9aqW0lw73MTxACM7RIrb1+tf78tt7n/MOMk+0xSRCCcuY pPMJC4Dc9T+lTPDI1zJMVKCQ5aPPyqe+B278UgGTRuwaMsR2CZwB+FRrbTwxRGKZM7GRYy2HUDvT vY1jZK462kcDY2xthw2B0P1ongkmdWJJEWNoblVwc9KRUdUf/9DxeR596tEwjlJ5CDAPHYelI6sC jSNwMA9q/wB9Zuysf8x5YS2WUHeo2npn/P0prmKFhbFhv6lVwxA9azbuYSd2ZwlnE84SItH92GMD Lfj71dhtXkXc6qMj7zYGT3x+n50jSF7FmSWaGAxrJnAwFxlVP0rIk8yQxb40dFz5rfdJFBZ//9Hw wLujDR7tq/eUjkCpI3neOWKFUCKN5LEAt2/zj3r/AH2h8KP+Y8sL5ULEyRxyb4/LkBGCR9cfrVe3 lEccttbrHs3ZuGiQO688bj1H6VRrT2JLRNn2yQxQzSOoWFnJDpg5OMcfmDUVwELKzoE298dD7UFk VqrAujO7b2LAE8D6flTzYxSmSNpfJ+QufMz8/Gdv40Af/9L56iD79kYJWM4RemMVM8L2qq6AOsh5 iTrESe+cfpX+/B/zNQ3HPFK8azFCuJNpz0b6VYvLaKMwrBcrK7oJJFRSPLzg4P6/lQahJCscaOJE ZAeEYjzDjuVzxUTPFNJuUDLLhVUbfm7UAZRWVJQSry7X+ZVOCR/n+daUyybVuPLaEZ+VOpP1oA// 0/m8Xl1K80DIyDzNw/6aZA+b+nNaqQJFBgtn5d25TnBPav8AfSUbu5/zR8/kUTbTOFVXKOsgf7xB I7j8qna1udkzJcqLksptlkQEE98nP8/WswU+5sQxsjn7RJFJNGhhmNs4aPcB09u3T1rKks5ojcNC CqnnKj5F6Dp2oLTuio8bwSLbGZLmTYsjmNxIFB5wcdCORinvCgw20iTOR/n8qBn/1Pn6GBrm6W32 4dx8rEYTgf8A1qiuEEc0crxefFDL5cke7AOOvPtX++B/zTlQXkU7tGx8pVJEYGcf7o/z2q/Ymzad 47ktGhiby3A+Uv2B9KTV1YBNsdrE++Lz41XCZc7+hxzn271Hbs7w741KIDh8/wAJ9KwtbQ3vpc07 Vpoop5z9lbDBY1f/AFxB+8R9M0ySGKXMzkqyAkenSk1ozWnqrn//1fo//gmNoLaj8aP7SCmOy0zV I4JtOBy18WeGbzFPbAQjA/vV/ZppSj/hH4leN8Cy8wA8MyhCQDX9e/S0re041w9H+VJffZn8i/Qr o+x8JJVH9ucn9za/Q/kg/wCCq12l/wDGNre5lljheO4t/sML7Ip5UltHid/cCNh75r8L/jOLnT/D c9t5wtYb0tdpO+SVMSspUfXzG/IV/YngtH2fhphP+vZ/Efi7++8aq8f+ny/M/DnxrZ3Gu6xdXiLM 8bXDllVQSApxuHc7sE+wPtXk91qVtHeSabG4jYRfPEB+8UcAsQeRz61/mZ4tzVbj7MJf32f6ucDw 9lwrgoLpBHOs0Sb0hbDBiA2Mbv8A9dNBmW2aVptsf3DGTyD3496/K5r3j7JPQ//W/izjFzPfo0KP KIm3YjPzkDvXUwXbISoZ4p0G9hnDfnXOYw+JDJL97mYrKfMyPvHmqbRQGQrHGd4+Ynr+IrFr3rGx Hb28Su08EnmDJWWMEEH/AOuKSfE25Qu0BfmB9u1OaSdkBTTAMYtWUup2MoPzA/5zUo07M7M4k85T l0+7moGlc//X/jLs5tkoikBcbsRnrt//AFVLeuJozD8uQ2euBXCle5u+hHHb21ooBA+bltpyT9M1 JNNbyRMojWMMP3RBAJx1J/KpGc+jTLOjW0hZRxJblR/30D+Fa63qN+4AJk27zGByoHf6UARJLEyz PdJlvuRBR8if7R75/wATVL7dbyhhFvkkRvLVVXCjHXJoA//Q/ixmuZQBLA5WVAVYMAUweOn6UhHn Rm5k4dRgE8ZryZfEdXM7WJ7e1mkhFwwMURcqjbxlyOuR1qu8txbNuC7EUcyINzjqOlJOxIrXcqkR Inm+ZyWx0A6/yqC8ubpFiDb/ACm+7gHav+FbgNglt4onMyNIZekqEbkOeP61e0+C3jUxhpwZHMnm DkYOO9AH/9H+Ly6ujDOgmd5oVi8sRlsKMnqPes5Db2I+0RFv3nA/iKA+nevPOlbjhexMWmViMJ8y 92PrV1HUwqoSIeYPM2ynge9ZSi76G5TmheVvNBDBVwE+70qnbSXEe55kUbSUix94A8GoA37ezla3 e+hVnt4MLNJ/DGW4AP1qjeQTXSyEyiKU8gj5Qyj+XAqJ3tY0hbW5/9L+J6e+iLG3CMyqApBHWteO FoYLdboqouRugKspyOw49P6V4U9z2FrsPnjRFCwljLtO4r2pLSSUoYWlMe4EAsD+9x6/lU3exlPc qyStNKVkDZgIAZDljj0qe2inmkAiLSCV8YdstKTWsdtSB0l7JZJ5sHzzxvsZccoOhrDuPs8tzb3V i88NxE4kmPAc5PzAD09KoD//0/4xfFFtZQanpl3a6i7PDp6XMmCr+cZVBdGHOcHj8az4j9pWFrOF T58v75yfL8scgnGOemMV5MVd2PQNC/t20wRyTjyoXQSIG+V5B0yBVbek8OYdkscy8Sry8Z/z2Na2 Sdw8jQgtY7WxXe7Tk9GIAOcc8dKwvsbs7+QrCWSQuGPHfPXtWkE73QnJLc0EsblAJ5nO8NuAVgMG r9tp091cpb2VteXczD7QY7WFpW4PoBmqfxXMbu+h/9T+NXS4IbzU7aO+VXtWvhAbVgcK4OMOD0P1 r9N/2cNMs302+XU55YZlVLbSo4hlJQrmIE46ZCg5r9l8C4ufGdN+T/r8D8R8eZpcM04f31+T/wAz +jn/AIJK+HtUt/H19rEqJcR6PfGwaCZvPM0R2MGYnoPmRcc/cPpX9b3iS5Sw8DXYnhKmPRfNfyx8 sZMQO3PYDgfhXT48VlifEWnTX2FFfk/1PufBSisN4YxT6uT/ABa/Q/h1/byl/tb9oLxJplnKdTtT bya9cLKwii054iqExDuCI84zyQSOuK/Cr9qjV00jSr2KZJc3VuLm1EQ8u48wSBFj3f3WGDn1x6V/ XFWbw/hpGa0/c/8Atp/LeBoxq+JM7/8APx/mz8mdZu7i6meQ27WTKTmB23yD6t3z1/Gq0E9y0SxB QqN8pA+81f5xZhLmxFR+b/M/tNRfJH0R/9X+H7SbCCJi03nSW7JkR52yrj0P1rqPD09tBPJDO1wL YHMe9Sdma4Kr3HTVtDr557dY5c4IuysP75AURMjnpxnAqJtORr2AQK8tuUwpjX5Y8DnPse1efU6m kL63PQNCWNFltmVYUaLDSzJgHaR0OM/lQbMRmQQXREMrF50f5t2DkbPT/wCvXJNe6dMfhRbsobUR ts3zMrF/3rbivT7vpU8F1LJeGK4iRbc4EDoSXQAfNuHt7ViJ35kj/9b+Te9l+zxQzRSAogO3jKDO M5H4VzjT3N0v237PwZWXEEWNgXnkfj2r4c6XuazRDyfNRwSw5WRdpFZ1oP7VlGnwyxQaxDhpLW4m CRhCcKY2OM55/StKaDlaVzo/D15eKbi3dBa3MErW6ebHuR+27b3HNRWszTySWuoxDeZmFs6YZJAD kEjsah7sRNeaK1tPb2zRNK15INQ86RsxIyhQpznsFH5VtNFe3eq2c0U8ssu1YWVGDRvgben04rV6 xHFpNn//1/41lH2WwknErSxK3zAfNID6bfaqUwtdW0wKHEjJNxIG8ueNlOc4HTBHWvAu7WOXEJxk YRgubbdK1yZWaTAYcYA6A+/vWsLuTVbI2twSBAfMilt2O9iOCMfhVRk7pHOk73Y++xIbcwky+XEo kWVfmUgetLFqF/bHedOUokwtpPl/d4YFlKMeM8dPY1qUM1O9uDhpLb7PblQMY2RBhxn6nr+NWIZY 2hEhuRJwBDEoIccdGoNIx6n/0P4xby9vma3W2mhtRAN80UDKzXG7OAwOehOeg6Vj6yzXMFvCr3Xm SN/pi20JZG543EZxmvISu7HOdzpepXk3nSLosdtaRafHaC58sj7Syrgkjv6/U1n6ta3U2nWmr6NL DPJKSBbgm2niKngbmHB74rrpq2gGfC1xLbWkOIk1CSYi7mlcqsaNjknuRyeldbb+GNOs7TVJYfEE WszwyJJAwtxEUViAVUeoPf0P59dJMV9bENxpwljluLpHnKxmQxKuWlIXjIryu4kj0yYxiKNPN/eS ARcovOFGeRivUpbGTk2f/9H+JK2khvZmeFW8xkO7YpZIl6MzY+vav2c/Zl1C+fSJLKHWJFtxo0Kp IiBnlMSRFIiuMAkFznoAvvX9J+AVTk4tavvB/mj8Y8ZYc/DOi2kvyZ/SN/wSe1GfTfiDIjeU9lfX lvJcbpGLyTsgO9V98NkL0wK/r7upHfwi7IEu00/SFjIuW2bztAJ+vNeB9IOCjxeprey/r7j9M8Kf e8OMPb+V/mz+ML/gpn4cvbX46aYYxCYrfSp9Q1qODdPBI5nKwLxwCqspx/sk9q/M3WrYyaPPqcem 29usFyIri8lgbzZ8nhVHr8uc+g+lf2f4N1va8BYGXk//AEpn+fXiyuXjXGxe/N+hxUUlxJcbpbgo 0gHlQxQiNIQgwMAevHNarrqbqVgugJY1EkIfJXOeQB61+rLRn5M2uax//9L8+ln0u0gjn1SbUr/U tTnkN4nnKrphF8sAsCMEhie9Q29nYRNd2CgtdPGJEck+bEScgjsemPxr/Z9O+x/j/Ua1MoOVeSKR nm+yDfczLEVCDsD+fJrX1CweDTJJB9ntZ5LMXUbXDAMyvjYcfQhsenNbwd0c5Vj8N2badpd1d6vb Q3t3GxhfDJA7AHALc9SP/r1Utr1baC3n1MJdQuVs5BB+78tmO0P0yR155J71RjNaj5L6yitpWu7Z 2h+aa1ZCqSIBx8w9Ota+mxeRY2uo7NkN+DJA6rxIV6/iOPzq4/EjlP/T/PmO3tJ9UH9qQypFdxs/ 9ouoa0gcH7jIOctkYPTg1EkEdpdXMAgS8s5EMaF0MTequhPI7V/tgf4xzv8AIr2V1c2VveG1jskv Fb7M0V3CZAT1ypxjgHrmr9jqqW6lrmyhlB/dyIU327E/e2+hHUfSgzOjumstUW1n+WH7Km1UCAJt 6gED3rFWeGIvEltbWV5al5ZZZEZHuFbaUQDHoM+nPXigCnHeJJeG+nlmX90YGgQgxsDxnp2wR+NR y6mbFRaWrPe2/wBoaaEzna1srgEqPx4/CtIbjvZWP//U/P6GzvL2NZ1uYPmuc+S7iMooAJ3E8Y5O OetS6hPaG9kitIYp40CoZJgJNzADcyke+cEdq/24P8XOdEqXzXkmnWl7cnUotFuWlgtWgIgsxJgl C2MkEDmshpnttQ1SS48tVvGEWnW1q2LS3A++vPLZBPfsO1Ae01GmS/D6ff6QiRf2XdtLfxFsLdqy 7VjbPocnit22DQXt3qT6ZLO32ILFaRXJVmZlBOFHXkE4Pr1p2b2F7TyItLuoNThgnktpomhRo0Vm ZfKPOV98e9Yax3S6g3l78RzsWJTb5h75yP5VrGNtzKU+p//V/Py7j1G7nlmiiUhIVMEBO5ycYJx3 yfT86usupR6RaQmyxdBibmUgoWyMkAdCBwMCv9wD/FFybViLTL2MpDFH5fmJceVMlxH5NrbIMfMH PGeeBx2FbY1rT7aVJbu2BeEkw5HmpKecZHTjr6cU0m9jOS0I4dVGo+XpvlWvkz3Hm/aJowJkx90K 56c4/wA5rMvNPtpHuJZL5CbN/wB9B92RVPBAbPXjOOcZrcxIxo93FqMf9n3cMltNbRyx2qx7rl9w yQcntxnA9adY2iWE+rfazcF7m2FxanZut1nSRNo29B8m7p3XPpTUmtEYdT//1vgeefUHs764ivnF 9OQotdm1J+dxZ2HTJwMe9bEMd/dxWvL2l1Cgnha2/wCPN5Co3qQR0H04r/cpSa0P8Qp7lZXvoZpt 6wSSXGYm2qCS2ewHGfTFRX1qwFqba08mVYm/tOdrrEtwuchY0xhcfU9aT1IKNlf3mkWc62dmyTXL CKAX4EpijLcuGB646fjxVvWLg6ZKscUqyTzFA8kByDvx1P8ASkDaW4s0BuY/JnYXDSkgho/LAA5w R61Fp1lPDL5UkH2S3yGiYkLuBHXb2/GgnnVz/9f4/wBMkvLb7Sou4JNOdf8AV+WC+713f561Uto7 C4ubu3ulMEqEOs8bbgR1DD8hX+5KR/hw9zKj8yOe7/tCSG5tpZVjtJ5Y/wB/Eq4/iJ45/StOW70o 28xitY5GiULlTlj757dK0grXM57GTZxR3M6J5ohErbd4+7HnqK1rkW8UXkpy6IYVmHPmkE8mrOeb 6HOnT7C2to3KyfanlYz+ZKrq2ehUAZH45qyv2q4CRwbvMhwUKj7gHSgxk9Gf/9D4dn07UtavZp55 THC1sIZUkQlZGUAZz74561qaJocosUhumgkFrI0aMpbzAg6A9v8APWv91oKyP8G572KqrteedGa6 +ci2gdTH5WOBx1rKQzz3cFzqE6QyTTLB5mG2RknA98f4VRzufRF7VNLihjkhBEjhzuZTvSQdj/n1 qTw7DbaVH5j/AGcSEnyoEGFUEd+Bz1oMnK25Zke3mvkAzC8kTIHjXchYngEfXH5V2uhWuo2lnaRm 5W5unlVJi4KrjIGAB049PSg4sQ/dP//R+mP2I51/4WxpNyrhY4rUWWQ+4F1ZW8tu/A5Ff2ZeDXZ/ DWkt5aR50yIbY2DKMIo4/Cv7I+lxC3EeGl5L8kfyn9D6p7TwwlHtN/8ApUj8CP8Ags/ozLpGjXbG Rri21PTtQt9w/dIgu41IOOc/d/767V/PRq15OYpLW/m3zsmGkRfLAIIzwPpiv6V+jFU5/DWku0n+ h/BP0s6fsvFnFvvFHJxRxtmVMPtPBPYipUkW5gnmZnLW7qsqSLhnzx8vrjiv6SirKx/KT3LqWunr 5ywXEHntBnzJEw/HzbV784xnjrWfa+bNM62w3yxr5ixsNrnBx0NMcpXP/9LxmeGdZEd41EqjfKzJ yPr9TVprs+UPKkw0gxsz8rH6V/ve1c/5sKMrJ3JU3s6tOkZEi7n28HPHUfnXfeHPGmoeGbuS90PW dR8KasrLPYahp0jN8yMn7lxgjBCjn/ZPPOa83M8DQzPCVMBio3pzVn6Hp5NneN4fzCnmmXzcasNU /wAHfya/q59e6d/wUj/apttITw5L8StVtNKig+yNLY6g1vezIVwNvynbnGOPfHavI779qT4x6rqj avc+PPENpqRu47gyR6tJKHCEfOTjOSByPbGec1+R4bwT4XwmIqVoR+K/RX1+9P7kfsVf6Q/GOLo0 qVSWtO1rttXXZaW+9nsOlf8ABRP9qbTW+yp8XLpbcSrBbLcB5kjj/vMRzngZABptx/wUU/ay1d3i h+LF/bkPkXSzSeSynhv3ZBxjP8689eAvCrnzNaf4V/men/xMxxnyOknr35n/AJH/0/piT9uP9q1X VJfjNrbWcMQaeS3ie587nlVdJBgn1x+BrnL79uf9pLWbL7Fq/wARPEFw6XrOIrnUicw7cRhiqg5x 6sc1/r5T8C+EYTUuR2Xp/wAE/wALJfSO45lTlBTSb01benp/wTwbxP8AELxB4mvo9T1C+uZNRjuv tf2qaczyBgQcKWGQM5JHPWup0f8AaS+MnhjS5NP0vxp4h0t5nM8ajUZFwjkHbHtIIBA4+YivscV4 e5BjcFSy+vRTpw0X9f8AA/A+JwXivxZluLrY3CYpqVVtyXS/l91t/veo3xP8aPiH4xhguvEvie81 V/IeJEMzvM7uAGDsxLZwF9P5V51pXxM8X6LM11o+qXOn3iRi2WaydrJlC4IO5CCTkA59TXdhOBsg wmAeW08OvZPdd/n/AJaHn4jxN4rrZh/abxclW2TW33bfN3fmelN8e/i1rFpDb6l8RvEd5YpCImt5 NSmV3YcnzCH+YdOoNeO6jfm81G5uZZpr24uJvPlkuZDK8j/X09K3yrg7JeHnKrlVFQlLR+l1oc2d 8e8QcVVKUM6ruooO8Va2tmr/AIn/1OChvoDOI9VEjRMrLFHHKYmiOOo/KvQPB/xL8Z+FjDa6P4o8 SWdhbyHa8OpH7LDGBxEIznLcHk1/ufmnDeW57h/q2ZQ5odO69D/nRybjXO+FsX9ayerySe63T33X 9P8AVb342fEi8v7/AMzxj4iUF98LLfzRzqPRzu2nPHAAFcXq3inWfEd/FqerXUlxc20XkQTSEliC BuLg9ScDr6CsMq4NyHI5qtluHUJpW5uv9egZ34gcS8SxdLOMS5wb5uXZJ+Xp0u2RxapqTvttIiTb R7jIihncZBOG6ryq8j0rp5viV41ENjDbeI9c060giZJbay1WWJWJ5BznIxjse/aurHcNZTmrjLMK KqNbX6HLgONc/wAihKGVYiVNS3t1/Asn4heNruzib/hIfGRiiuGSe4tdSaVYcgESMWBwBznnJz0q DVvG+s6rLZW3/CWeILq0slWO5Rrx1eY8Elwepzg8cGuWnwNw1Rl7SlhIqS9fwO2p4pcZ16P1atjp uHbT7m7XfzP/1ee1LW7y1k2NqF5cpeqdsFyxu2dhz34UfTH6VV0/X9diswz3flXW75hCzQyBOBty pHHt7niv92quQZbiaao4iipRWiTWy8j/AJu8LxbnWAqvEYSvKE27tp7vu1s38i3FrszW81xPd3qz m5EiSJeSF0IwcDJOAeePfrRJ4j8QXcd2f7Tv2sBH5aQTTbvKB4Zlb7wJ6deOlTR4YyTCv2lDDxUl s7ar07DxvGnEWZQdHG4qcovdXsn62tf5mBcJPLZPcRSLJFF81woJ3W/IVWfPGDnAIz/jiTIqRxmS YzFlO0AZVB6CvchH92l5HyMZ/vNe5sWepoYbZ5LcM+nrjMg82MKvTAP5flVuWWOQeRG8wtTmVLc3 DtAjMMsQpOBzmiOBwvtI15U06i2lZXXo9zqq5jjfZvDRqyVN7xTfK/VXsf/W85MscgjRrh7hLdPI Cs5IjUE/KO3/AOus6ZBsZ42CqDgK3LEf5xX+/wBGKSP+YrmtK5QtirFxs+ZG+ViuAc+lT7JXLBsq oPysOhqiL3ZLIxhVJAQwU4bvzSyXTTsi4KhhtOTx6UB5DjAqjyWCSGUeZtGG6HHP59Kjd5Su0qtt bJiIBP3YP49aLFwlo0j/1/LHaaEokTkKnLDOfQZzU/8AaQkfZIPMaIgqxHBIFf8AQKoLZn/MUpSj qmZv2qIG4aTMbTyF18tAAzHk5x681BiaNguxh5g37fUHpUSgawm7pXJoIfLkGW8u1eQeaGUnn2rQ lUys6QGRkHGWHLD/ADipSV7ESn2EP2hd1u3mN5QLeXyVh6ZJH4CnMnneSyyK6WsWWMYwqg9QcjqC 2P8A61Oml7WRUpvkSP/Q89S6ke3NuXVof4X4LAdcA/561nWlvHA8vzZjRTJH5jFmyPc/54r/AKBb JT07H/MRfSweePssNw80ZfLFyhKlTuyuD2wMAfSqywm2i855Gna5kaRt7FmUk+/4dKswl8TLMA8x SISN27OGO39addN9o8iKRVR4kIXb1brkk9+tBJFaK8ch6MmCv5girAjRd4LZPXB69a2h8IH/0fMk iLYwSg7471E0QVnjBAV2yXI+Y9a/6DuZXsf8v+xaWCKMwh5SInb53HzFeeuKqrKjsUwxeI52nuo/ /VUSetjBu7uF6qEKbZmJK/ONu0qeeOtOghnmiCSMIyBgEcAkVAXd7hFLPGwtw27nDk8BffJpXjjM owwJPHJwKAbb3P/S8xS2jjkYodxfkjPH+eKPs8BMrNw8Y3uM43D2r/oJTs7n/Lv5DrZl8h1niUq4 JQcZTrjnv9Kd5khgVVBdwdojA3MB/n+VaxlzFKTWgy1dbqZoN5Rox85MZ2g4zyarXMjCVI4wEVB+ 8ODub/8AXzVBzSG75C2Bwh4OeBU8YYuQwyg6HoaBwlbRn//T8y2icsxjGyAbt7AD9acsazgOPvbe Ae1f9CB/y/cy7lZ5WleNGQYj74471JkSSssQBUNjpyP85oFzxHzyon7qUbpSMhB1UepFT2c8lvDO kchVZOqZxuHp+fNAc0Sr+8ebcrKNx+fd0XtTIVXddx7D8kuYztKo/HLZ96Bc6P/U8tQsZ4gZAoPE gZd2B7c1cfym8wRyhtjbemDge3av+hA/5feaJUhjWBmkilZXQ7x8xyD7U6aSKRNz535xzyfrQRKV 9EV2R7lFCupSJxgMOo5/wqbdMi4jBZV4AUcmggtxFnKyGLKKo8xRkFvXPvVcpGZG8v8AhO7aTk0A f//V8ouSs0TJLAXEjBeONg5B+nWtGzkS1Vw4LW5iMO5s5bIxgH171/0IH/LuZaxlWIRiVLbqvtHP FDsmZXSVfMRdwPy4zzj+tBfN7tjPAC42hUTspGAPwrZNw86o0mGdIhCmFCkKBgdPSpbSRBR2XG/a ELr6AY21EZlRXPIccAAVE7dAP//W8wiuJmj2lnIPWNWwD+H+elPM0gxnJCDCKfugfT8/1r/oIP8A l3JLeP8AfI8qxvAx+YOMqPXinny0NwgCmPziY9uThfY9aAIPtJjlGz5o1GCnr/hToSJWctHheoJP NADZ0CqSufmbkHNRD95wJNrJyFPU0Af/1/OkuPJGzJbd3B6ccj9apCVo7nPlhoShzkkZbGAfw61/ 0Ex3R/y7kxKlDvwxbkMOMVUSKU73G0ADavzAcU5fEBbhkfaMoDjjPTP0qyohdhuVgCed7Zx7UrsC 5JBGioB91xkHtjOP6GqcsqruU7XCjGPTqKOZhsf/0PMGYOoEaDCDLnHPp6Um5iQrcA9K/wCgtTaR /wAufOV5hIJAA2E/iA61cs4UlwM4KnIz2q4yTKjLmLENrML2Qpc5VIyx6FAV6EHt0x+NS/Y1UK0j ZydzY4yaOeIS+Fmeb+OG8kg25ZYGYLjHXK9fbIpqReZGtyDtB6DPLURaZif/0fNBBK64jYBSQxyP SmCKaSfYIwueWcAKn5V/0HS+Fn/LeWFMKyiGUK8kJ3Anp3/w7VPdrPNcJMjLFCYfLaGIbAxBHzcf T9KxAaDLGpKZb+FvTntVIRHzQsreWN24jHJ60AWPtARnhEm1gpZQQfnGccU6JML5jEkMfmzQB//S 85nX/V+W52Yy4245qK3toobl7sBjMYDAOSV2k56euR1r/oIP+W8tW2pz20hms8RzxSEI00IkUMpx kq3BFR3l3dyZAm8m5mffLcRoqoxzzhPu8+nTmgd7aEqy7ZYnYCX5QW2jAfGM1GDIGuZIrRViZgzb DzHnPb07Z5oERxZn37FIXdgA8c1pw3VzEtvGYk+zo7M0U0YJ5G1iD74FA03HY//T4Ga7hiLQfdhk OXz364/mfzqOBY4mLnBTPU9uvWv+gg/5dx80y3RwIsJGuFEfyMQOfzonnsJbaBILa7hnHEpuLlZk 6dgFGD+JrnAhiS3dninvobO4CD7NHOjn7USQMAgEDjnLU/YiTBGZWbkZ/hbGckUAISJC6L5abhgu 33V96etvbSKkkKNFJEmLj7RLv80jjKAKAB7HP1oA/9TzO6n3gQRQoxVtzkg7sYPA/KnWsq5DMDGC MBXH9K/6AU2tj/l3JhMICxWMSBgQd2SPwFUI1lMoZEbzGbKBfvfhVKb6gWkmMUm7IabaSd4yB6g5 4qMu0q5HDg8kEYFVzrqVF2ZUliCxsxf98XyAOnfP8hTCPMVVbgbh2wDyMVPO+hsf/9Xyi4mmgfCg pkDJHH+e1ROskp8zcGB67hk8da/6AuZn/L+TSQ+eUERUIFzJlsFsdh9anNpGLZpLZ/LljXM9vMVE g/3fUVIFC0MskbNtZELchhtyef8AP41agj2Fo0U+bN8u4Ht6UATSqBGpCurg4Ztw2kfTFEXmLhdp yeACOtAH/9by5ot5Eh+/G2dtRM8BuUWUYkYFhHH97juf0/Kv+gA/5fxJY4ZcbVAkHTHeq0sc8e1u NsY/1ZGWagC2ipcjaUZGGGIHAHtVaaZkYoimQbtuwdaAARsSPlIPUdsVIFliDDeArdR0BoA//9fy yOxkR4bgOolkXzFx8wC5OMj8M01mYsTge5Ax+lf7/pp6H/L+WYXVl8tvuqCdx6+tU5NocJChDbju cn8uO1Yta2Gk3ognM5jAHBxy3rWctz82JXAJO1c9zTcWrFqNtyYoCrsD+8/gjzjf/h/9erXlC6ig N1KkCWjLsTb88vtn2wKHFpXND//Q8mngVfmXgZyPWljUyAwgKQcF9yjev0OMiv8Afg/5hyR12KEj j2tGCGb+9z1/XFVipBt3cebLtLHyz8qjOPnHrx0PrQAMJmYKM+Wf8asJHIeY8sVO1yciglpXFOxC +8bj/Dg7QDzVYv8ANleD0OKDPRSP/9HyYNJDNuG4F12ndnkGnS3d3GpW0KpOPutKvmIPXKnrmv8A fg/5fydbNY4YzLJHNcmLMgi+4jeg68dKSB54fNVUZiqguwT7oz69qAK08DXCGUghj8xA+8O/aliE wSCTydiSxsmJExLngZ/nQNO2w5ozlUAKsOeTtGfemRypOvk3EBikgnO+eKbPmrxjBH0P50G10f/S 8yt2jl82ISDDttCSdT/n+tUJ7aS1lZFCoCf4OAfc1/vwf8w4n2dJBjID9Q3vTpVMXlJ52+ZV/fFc CPPbb1oAglx5iNy57mlvNrxRtCuJFbaxPUA46flQBNGUhTc6oWcjcFAUn3/SpY925mZo3hkICpGP 3igdd3b6UDu1sf/T8XlkZbhnRclRt5PGBwKDOrcyDO3k+1f75S+J3P8AmJ5nsaPlG809bu2kH2Vj sW7RTLCj91bHQ+1MtVCGRJraOW6miEJuGT94MMGzntnAH0NSSVZXa33AkLvl3AquOmQBn/PWo1S1 ulkS9eU+WRJaiBigZwRgMQQfU0GkC7uR0mnEcgSFlFwGG7y22jpxyD1rPaEzQm5huYzG8o8pArAs ncn0PtQaH//U8ad44djgkNs2sAMAjFV8R3AaNCB84fO3HIOetf743aP+Y8fNa+SMyId8gyT0b2J/ CnWF3/Zn2lIUzHdqEuBjcHxwM/ShtvcadmQKzCZhu8rzOYgwwCPamuGJEcrfIvJIGMn6/hRd2sbK Sew9dyEMwBRPunviiQxSSI5bO/l9vWi7Gf/V8PkjhV/3eckde9VgZ3lWJiiqBwehPU/nX++N2f8A MuCrcJJJtGVKFWyocAdzz/OiNdhLq3z9A3WqU2tzoWxRuWbzzG5wcAA9myM8VrWuhambWa9RVuog ymOO3UtLbjHJf09vpWjkluBV+yM8qXEspihilEk6K4jeROdwUnp+R+lOluG2sYEd4Ccornc4GeDn jP1pOSQH/9b55aPzy0xWQkL86qMHA9K1tHns4MYjF7bhNxE7MMk+vOfX8ulf75OVz/mfLRto7q4n mt4hbRIm4q02Wbn+Ef56VlTQx3st3FDLOywR7cIvIfaD19Oe1SBDp8c72yiQiGXdkMx25x3P5VdK zz2zFJtoicPKFGGZenPtQVGXLoFr9kQsB5XmykCSQryuO5P+elQurSySbAZFiONyjKjHepcktDY/ /9f58l1C5ghlht2RH3K5kMQdgATkA+4zVEf2kkwNv5H2OeIieJoQzOxIIYE9Dx1HPJr/AHvi7n/N OTQW485BcRiONnCytt5QdyPX8Klmtvnby8PErbY5VBCOR6ZH8/WplK2gE8enXl6pW3jMk4+SOBfv SnHQCiG1uIxLYPFIshfM0YJDI65AGPxNZHQWoUaOGW3ZI2nJwjMcFOen1pJzKttHBcAl8bkIXbuG f5VnKTTsjaktLH//0PtX/glJpsV58UdRkOI1h1OGCL5zlZnQbmb16qePSv680Jt/DoaZipi03DMM At8mB/Sv6t+lPUlLxFjTb0tH8j+V/oe040/BmjJb3n+bP47P+Clt7/aHx51K1niZ5vtUmtiV/wDU 2UcE0cPlKR/eMkbc+n5/kH8bbj7d4bv9Onht3SCK4v45ioT7OiWrv5YOOrE7sZ/hHrX9seEUfZeG 2FX/AE7/AEP4S8SF7fxurRS/5fJf+TH41+H/AIteGvBGo32nax8J7HxxczyCZ9RvrqNBawbQdtvG 4Ksep7Zz14r5z+JWoeCtT8W6rrfgrTbmxstYvvO+y3tsIJ7P5FDRKQSNoYHAycAda/y88S5zqcb4 +fTnl+Z/q9wjTlDIcI09OSOnbQ88vreOOSFV3xqp3E/wk+lOmNsI2LYC7MsDwF461+etan1sWtl0 P//R/jDezMIFxasHkLAoo479qgu5HhcA723DLkA71+tYO19DKCd7jrUTIzNJkRuMIAOnvV8NcWUn nQlG3KRIoOWIIxj8v51hNWZqRTS27xkW0hglRvMaNV25PXBFPsyLq3ZlRkcE5VwUYsOv4VIFa2gl iugY0jV0fcAwwGOa0LrVUiaW4ulaSUtyynliOMZ/z0oN0uVWP//S/i0S5mdvOWM5kfKRr0XJq61n 9oliBKwM7f6QznAxj/61cGx0FONp5RMqYdI8oSh3bQpxnP4VBBC99M0e3iJSRITj7vvSAq20dys7 eW77ycfMcDHpW6kLRtM8waP93jeB83Pf6UFKDauZTpexyx7GWezmIDkNhvxFXbgC2t0McOx2bkgY 3Ci6W4mrOx//0/4pbeGe4nACsqxnLDpnPataWx3gJOXEatuKIdpBFeQ9zoK6y7AsQRmG/ZlDkIPe nzCO3d3WOZy7CJtxJRSBzjPShK7sBfS3kZUNuoIOD8vLZqlqLz2rmC52szJgLjG78K3AxFjW7U20 OIthDSsB90E//WrqYYfstsqxs5ic7U3A4LAc/wBKBxV3Y//U/i0vYVlkSR94CDayIfkP1qNIm8po 4lGMcEjOBXnnZJJSVilHHIkr+aqqQmVXby1dAiW81vFJPbCOaMbom53SH0I7D2oNCvEVlaQIrLKn ytFjg/SmTWMTL58jzxsMFYMAoSDzz71z2toNK4w3csaPbwSkW9wB9oiDlY3KnjcO+P0p/kNKD5jF OOi9h7UGyikrH//V/izFvDKztsjjaM4UsMlsVNNZ2ltbw5m+0StKZvmJPkEZ4X0HtXjOKbueulZW LFoEDsW3bjwMdKi1L95EY4SPNVsqOjcUuWO1jOasyjaNIDGZh5LoNsm4Y3fWobiYwOZbdCFhk8xC DtGSeSP1q4xvoiC2r4trpmmSD7XBwzJv8x8ghR3B7/hWO9mYWAWVXIiD+cq4XOORt9u9WodwP//W /ic1GwEt5HffbEuGNkqxCJDFGowMrg46EVraNcP5KxrGitESC2MPISSeR+QrzlFR2PQC+l+1ybpg SYzsVW7AcYHp0qra3DwNJBFGFiVD5caJgO3fntTCxcgh1BxFuumhDL5rwgKyhu4yRWgL8QqDCUdx JsLSDCpg4NbRVkRKLeqNC5uraRovJ3h2iXzA5+UP3x7VYsPEOp6Ddi60+SW1uAFBubVtkqLkE4OD xx070NJvlZmk72R//9f+R7TvFX/CV6ybe40Wx+3Rol5d3i23krel2x5kg6FiQSSO5r9RfgL9hNlp ksvh+3gEOlmC3FsTFHPMpKK8jHrhmORx0HY1+2+AdG/F9NxWii/l0Pwnx9rxjw9CM37znGy/P+vM /pH/AOCQnhiS01rXLW+lWG8bUEvtYiKeYJHlLSxRA+hOzHsDX9KnxnuL7TfhTql2uzbb6Wx1Ixts YJ5R2r/IfWuDxXq/WfFCaezmrfgv0P1Lw7oSwPhjTT+Lkb9G7v8AU/hN/bB1Ga/+Nfi3ULK1FtcW 3lWEd6bgtNIql3mDR9MNvXqOwr8YP2wooP7MhHiOyYyNNbajp72N5lraFppBghGONzFTtbBCjnrX 9g58lT8L3Gf/AD4f4xP5U4dTreJDcelT9T8w/EEsV7ctPHvClQu2QfvF2gAZrLsIiZY/nHynI9Rj pX+ceLd6s35n9mxVopH/0P4hoppA4DnayrgKBjeB0xXQafE5InlUlCA0cbgqGPbNedU6mtNaHVPB NcKC0RI8rJVBnZ+FTaTFPYXBMl06rOOEZvlTHauCrpcpW6HZG+SSNF3+a5GGYnB+lSXNrEbaC6fd mLmRS+AQcYxXLL4WdEdkbPhXTGtnutU1SC6jkNsG0SPzt2nyZIy8qfxfLkAepq3JDbDMiuqyli+0 HAHPQD0rJ7mcpO5//9H+RjVWe9t0soJzbMzYE/G0HpyDniltdM12OKNdLObjGyUb+cAYZl9cjtXx D3OuGstS3eC/k0WZ7ezaa+047vLkzbSX2SOAOeBz2qOGwgkkTVA00OtfZltru0ntTF9mQcjDk5Iz jsOlOL5UVPYvT39x9v03T3kQzvb/ACXIXykx7tj7wyc56VrQ6bM6fZUgLTwt57XzMdu05G0Y4/yK lvqZ2dtBsYuYH8uXzLi3QZi+fMac8810klos1vp7WNkEkgBMjRyEE56N9ADVOVoWM2pKV0f/0v4y zCYreVUBjSRN8YxgjdyTj3zUMdmI4UVJVimZvmd13KQfbIr58yxKu7o0p7K0gjC2AiuYwpN950pV GIyWKAjOPbr6Vj7reG9NvGIbKznhB/0TL+Uzg5Oc9zj35/CqiveRzxirkcU40jfaTTCa6aIsiOSz 7dww7H8fxqWe6jEKxyOWWRhKIycxM4GFYj1XJx9TWxfIr3LFtJqd9Y3VvdNBdW4j2xrK+FtRkYZM kZP+NX4ra3t0gMcfn5UBn2lA3rmqUb2KP//T/i0lshZ3z3UFrE73SeVI68CIg5Brc+z26W8vn3Jj n8nzdsKbgcDIDHP0rzVFJ3RzmFZa1rEVtb2s00qLNOTgEzW0WCSMjtxXS6houqTaab77SsZmmEtv G37pMt/Eijt9PWt6ewFKDTbxoAsrGOfZ+7kfq3HBP1rSsdGu7K3gLrCzXkwnu1t7sG4RAT8xXOcE gZB5rupbWIm7Kx2MsEq+RJb6kUu7OA+VAJEVWUjI3k8+v5mvBvEcFxA95qF9ObhnlaQnPmSD1AHp XdRfusyeh//U/hn0bxJcaTJ9stVkZFDC7jUYkEZ4O0+vHfvX7Mfsoa1fx6NEYYrdbXVrATWm/ZJP KAFEiu/8LgfKFH+Ff0P4F1HDi6Nv5X+cUfj3i1Hm4Xkn3/Rn9Cv/AATL8Vro/wAcNDtmSRdKl0y4 uo7cvhYZxJbqhIPRgWckDpzX9rvheQal4PtpZo4T9q03zpfNfcDlOCfyz+NY/SQw/s+JadZfaS++ 7PuPBatKvwCqb+y2l6WX6n8jP/BWe2ufDvxba+s0t7OHWL2e2gkgAkMsZlSRcKcgbcsvPvX48pc6 ov2uO8uXvrW4IaGBMIYJBkFsYxnnFf1l4GVFLw6wDfRP82fwN4xuX+vuOS/mEXSo9qPJNGJDywbj y/r/APWrLmgXRhJcW80d3HLKxSR2DIvqBnsPev2U/I5J3dz/1fz0txpl4sRuxHK4Yy/vHwyE55Bz 2zV6WG13RXFoFkkQmKGReGDYx8p749vSv9nae1j/AB7mtjndSdE0ia2u/Mkv2uN5lztSSMk7lf3G R+VWEs5Dptuow9qsPCAZ4x2b0x2rop7WMyt51jcWyWD27DTxEIoxLl2iK/xISAQOOBzWlcwyC136 bDBLZ2UGy4EqAGQtwpXPOR7VZnU6GPYWl1JBA9/Zwxy8s7wSmVJBnjIP3SPSun1a4vILKyltLU3q RSpClv5ogSJTgZVemBxnFVDfQ5XFo//W+A5NQjEcsdxGrO8avDGRmMH2/Kuf1EXF1JC0N46CXCNH GdiQY4+X8+9f7YH+M9uhqxPJBevpqWimxjiBuJd4+0Sy44kIPBzzwKcLJr65aC2KQxQwtM0NxiJG 289fXt+NBi4tOxJGs9rCEdlS4CmYKrbwVz1qCCK6vnkaCzllOQ5meVWZQoO87c524557CgkJbOzi u9S8uVo7Zrg3MSTP/qQQoKA/Xnk+tViiRu1w3ltaK6RMwyBFuPXP0ycexqofETN2R//X/Peawlld I9OSS781j5Ua/fdRnnH05/Cpbaykhiu7l4Gjljl2x2xIYmPAP4+3+7X+3B/is5JOwlrrE9ze3W+0 ttPitIQ8ak4a7wACNv8Ae6fWpLdY5ZWvEtYhHDG8+JV3fZwV+f8AE9B74oMpSbdirPqVnqD6fHFb TWfnxxGQHks2cnn244rqpbtNPuoEspkWYSb7ZpF5bGSOK0g+hJiTzzqUsre0ezvZ03K3mCVQzHPC 468981LJPq8rQNNHAyw4tX8sATOR0JUdyO/04rQTdkf/0Phy20yXTbiN7WG6d7gEPI7BkiBHJPPA 5qzqjqLK90qSR4Lq6txFaagzlY7Bi6lnIwdw2hhgc81/uAf4nKStc4O10S63w3N8tvew+d508Dy7 vMaMhlJB61fzZzQN9tWR7oSkxJGAsaj+HNO9tiHJdDb061sL1ItPnvFS+iYSwSwfLEqsMiNs9SO/ bjjpWMZAl1MkyqGtMtuZCYnII+969PfpW5lJ2RKbjUZpV1KQYSWQQIyD7PHDgA4xjI47e9bk/iCx tLESzRB5lVkWOYCWJ2OQCBjkd+fSgxT1uz//0fgsWM9z9lntruINND+/iADRgt6j+Ejn8617LTY/ MSLUZ5D5LYMcF35TzA/3D249R+Ff7kH+IMt2TxWWm6SLdbV3t5bueT7MlxP9onVgNxLNjj68ZwcV lWi3E9z5Lf6ZO7mN3zmRhnkD246e1aKCa0Oa7JL6JImlklZvk+VY2/5YYGMZ/CsZo5prSb7OqkTs l0+R8zBPlyD24OPwrO1tBt3SNq20bUZLdL+OdJIRksgkEksx4yB1II6nPrW0dPkewiMkzQzeYJAj jcsqZAyw6ggBseuadmRzJaH/0viXUdyWTRxAyecSMRjbkDqCO1Y0d8Y2jihTDjAcE5Y//rr/AHNh FrVn+GXOzdsmtrp57fVQUsXG4tGu+S3I+63vg4zWZHZQW0kSxXX2m2ndsXTADeuTjgcD0q7WInPQ tT2yj5YSqsrgLEPvuCDlh9MfrVi1axiijedrmZTJtKxwFo1BzuO4H2HanFXdjllKxQu4luJppLaO X7PGf3TSLiQr/eIqrbyvA7jz2DyfKnO0H1A79q15FciUk0f/0/imzfUrm2u/LkOYUyYs53KOh/8A 1VWsruWMsDK0Mh+Vl6k/QGv92D/BiTuyS7WazSCaKWRZXZnRt+1pOOceveodJ1KSVIVKiOJ7rdL9 ogXzWIOMAkZGfrQcz0uXNZjltJFgcosjPv8A3comWRSOBkEiqM9sXsXQlxJuwzxja8ftnsaDP4kz Psrh0mCAOTFz5p9a9l8MW1xfCBzcTKoffJFwA6ng7GxxnrznvQcmIXuH/9T3r9i+3sdG+K2jNBJd PbPrW470MnktLGqqJGAAIO3PTgA1/Zx8LnE/gvRrgBVMlmNyqdwyFUE1/av0u6ds5wkrdEfyJ9DG fN4c14dpv82fi/8A8FhtL+3+F9MJuYomgvIGuJFH72KMTKVx267T+FfzRSPaz6hIl4txIzSHYzAb 5ee/ufT3r9++izPm8OowfSZ/EP0vIqPiriP8K/QzLy3gBla0U2sJbanmMHfdjqcAZ/Lis8QyDZD5 sDymMF2B2Rs2Oetf06fyNKVpsZbxssnmGP8AeJlA2OldVHfIWhQxRRTW1uYFnjQKZwxL/P6kZwD7 U0ruxEpqx//V8tRo753juH8toyQXA4I74rIaFBdZVPMSPISUnA+uK/3xas7H/NLGpYe1xKsmwIxy eGxx9Kvi6Tzo4TDJJujJYx4JVgOOfc1DVxud4srxqG813faWB27hu2kdq02t2ZI5IzhVUJcM5zg8 4wKmUexz31sSLaQQotyJ4nxkGCV9sjY7j9eB6VnrLOWllh/dndgBTtUA1SgkZOTZ/9bioNTuNMs5 7FGtpbW7XzZHRfmLEDPzdeOK5v7VNNICWGV+UMePWv8Ae9Kysf8AM2pNyLHnFy/mNkgdemapG+n8 uWEqk5Ri0Mm35ox6E+ntQkk2XKVkieCS4njbglYFMhA4bAxkj8BT0mQRB4sFJGH3kw4wDx/jVJN7 Ec7tdFZvMR9yEopOT71BDe7LhTu2fvNnmn7qt6H606sLxsOlU5J3P//X8ykuI5JfOuoi2cLsh/d8 gYB71JCYFMsimVWKhQu4+SMHuPX3r/fOkrH/ADM4iV9Cjt/flY2V8nBdPu/5FacEa29tcK6tJMeY 1blDzz7j2q5rQxpyd0VmtzITMGMQxgojkY/Cs+KH7TcXFvFLK7RKJZeSAoOcfyNEFZBXnr6GiVMc YEbyKcYcbzsc/SrdhILVsmNWZhkkkAjOe9UcvPI//9DzC4v1+1F4Y9kjDDbcsg7Zz2osZAl2Zb6C aWCNcKsb+X5ueoz25x1Ff78wSvY/5j+a6VyoD5aSHBCySlwCS23JJA/CmLe3ylUXc1uWCumccev4 elOcLISkr6DjMSJoFLskx2vHniTnoR+XFSLC7L5eMMpwEK8pj2qYxdkkZXtK5oh4zC8McZgk2iKR jyJMYORxxyKgVjCPKYn0JPQ4/wAmt47IT3P/0fIC6xmSNGDKW3bl/lViOFJI1LPhP4gOtf8AQAf8 wkpNaIJMCMx27tG8hCzLtBRgCCMelWPJcxbVYKwGTuOM0GWwx4ohZqzzETMcNFs4BHTBzUUKs9vt eIFs7sgcjHvV8jAbukjBEQLZ6gcsB0q+8EkyBGQqMhmRuB04JFS007GkJWbuf//S8xubYou7dtAG OTjOKqRWoKvL5ioE+YA9X57f/Xr/AKBYXWjP+Ya66Dgts8sik4YAMIj1A55/SopnlDARAIjcR7ju JHQ/1/KocXfYuL5XdkkgVQRuaRd2VJ+U/iOacjBjiS4W1y4RWc7d2fwoimmSShBBeTNDcC5Vh+9c 5UEgAYCn8ee9Oit1iMzxBkjl4MZfcAc5P5/l0q1G0nIOZWtc/9Py22D20hBjWVFUjEn3R1A4/H9B ToUCwsHctuJKsRg4JPFf9A9tbn/MJzqxDLbx7FCDlecduKNrzKWmlGYl24bg4GAABTM27u5btbVD FvVZJG3FmEf8Kj1/KleNyCcL8v3ePmP40CIVZ4zG1vgOiHzxINyv1xj07ChUmunEhQBzkhEXA/AU 7tbAf//U8sJnidyATuTgHpg96mgjiktiC8rXKSYIbBTbj885/Sv+gg/5e6nQaqRKRDMzIoXgnLYH 1qV7YNcExbPKaAeWIx0AGCW9yecGgzFltvISN2Uhc7d3XJ+v6UXN1K8USRiJGiUoPk2lyTnLHvQB U8spN9/cjpvkyMYOOg+lTrbtMQ0BUAfM24dR/jQB/9XzXzAZwFh2BU2jHQ+tOnRS6PLCjNHyN6gn P/16/wCgg/5dyg1wZWMaR+UQcKOcfhVqJLiN1xuBAzu6EjBz/n3rSmgLiO6vI1vIqhF5BwGb/Of0 qjILt5jPcRqYQ+0sCMt+FaARTYNlK1pJbySi5QOjttlUbsHb24GSank8yKFSELHHbqaAP//W8q8x zhANity+e5prLIWjGWCqeicbu3Nf9CB/y7llfJ8x4yxBUcMV25qeNoUAQFUcnmTPA+ooAbc2ixS+ cZ4p3I25iBwB+NVWjlZG2sAxGF9KAIoopYDsdw87DCKoLbmOOAKvQ3UsgO6ARh12kGPy8EcfX/8A XQB//9fzAj94rYVSp69R9T/ntQ8G7djaGJyXXv8A5xX/AEIH/LuM2xQj5zvcccU9Yo5VLAlABnkZ BPoKAKlvJDG0zeYc7gix4+U9c8+o4/OriOQQF5J5HtQABpY5DjoTyo6VK8RRJZ9wRxEWw3LuB2X3 OaAP/9Dy6OK7t4o5ruC4tYb1Q8H2iMxiYcEFc9RyOnrSz5PlxfN5KEv1+Vc4ycZ9h+Vf9CB/y7ko RDFlWztHUdapRQW8pLMZSkrfOYn2ScccHnHSgd9LE81rBEQ0bTGHOFM2C3GMgnpmrKtHhdhwMdc4 /SsZLUQ63WX7fFOLkJbxjc8LKCJCM8Z9+lElnHK7mJSo3bgDyT1PWpA//9HzaJQsoU/T0zVue2Kw TXDYCoQPrk8V/wBBB/y7N8pVjbzovJQZY/gQOhqQx7NqbuG+T86DLmkhhtmLMoB+VwqnHD/T86cE dGKdGXhu1AczuROxbchGQONwpUVIFz8peRSMnmg0Urs//9LyxwcN8wZifl46VPBHdMcK0Ji2kukz YVzjAOPbJ/Ov+glbn/LtdFdi64SV1bb8p2jCr7frVq2hEqMRk4PygVU9wbS3LETtHE8cvlHD7xtj AkHtnr+FMmdJIwyAqB1BGKloXMiMeYwUFyR0UYzimTRzL8pO3cducdRSIlK6sj//0/O7a0cywJFt df8Alosh2hj2/D8aj1GJ7CQpdRhRnBY4YKc8frj86/6CD/lvIYYyxBd1VARlmGQPf1qzbSrIJnT5 Wtm8shwUL+4/SrjG+5cHa9xXt4m2zRNJG+/fMPM+SQ/7vbinzThvk3cAc470uVoG7pmPEuJZpvs5 mAJCozFd3Hr/AJ6VpW7eYkMdyRHErZO1d23PX69BSjuiD//U4NWTkQ5IPCnpuqZVZFdHyjKcHPU4 61/0Evm6n/LeRMgCMGQKHAIkYfNgehqHcF+VXzgcZ6UgK5uG3GKGRpHODIsfOzn+KpbkiXY8p2lV Cu/pjv8A59KAFcxyxRGIxv5Y+WRAMuM5qsonndxM4t4okYBcYLN24/DHtmgD/9XzeCF5lEZYmVV2 sQNokPrjtmrCJdLkwIS0YwVVQSAeCcH61/0EH/LeNNlNDI3nvyo3iNsZGcdKiljklcEYMaDG3/69 AFpbmO3Qq8S48plGOoJGAfwOPyrPs5Ji0m+YuM4/3RjGOKAL04CrG8LBSHB64zzzUhufMJWVuozk cYoA/9bh/KjaMMQG28dKzbhsHCBiuMOB2xX/AEDtpbn/AC6x+FCoRbxhmB59eKawZ8KmRubOSMge 1JuJRNFYrBLFPcp9oCSA7XO07eMhT2rUlWFZFIWPZL86DzN+0dgcdPxwalKFtQMkrGpmyxAHI75x 0qFGlDpnDbzt/ugVD3A//9fzFnlVSWiMRjkyWxkuP/1U2SXcWkAwhOIx3wPWv+gA/wCXckaSNbZJ fmR1XDb+EJ/zipraaOYRPhI5YTuMrPsAPsTTiruwEk1vE8j+YyshbBlt23qR3INVYIVgA2Z8osdu 45br3/OqUNdwK6qzXEyuuE3YTnIIrTUQxocgbl6D1qWrOxvF3R//0PLLiX51kmxICfuZ7DPBp29H iYIgUk9u1f8AQAf8v5XRljbcsWCF2kg5Yn/P8quRrJKvnOrNt9DhiPSgBlzczOkMXl7AnyqoUKQM 55I6/jSLFIHXcxAPbPT/ADigC2NRu44P7OSO3ktmuPOZpIgbhSQB8j9QPlGRSz3CFo43URlBtJI5 zn/69AH/0fLp0e3uXljk83b/AHc4bP1qaOdkPm7VWVl252AjkY/rX/QAf8v5G6rAgljAkd8LsPyl Se9SbMSF5MswHzK3NAEZicI0sZx8+Nvp1/wqoIX80OF3A9cdRRsBP+9djsI+QbeeKhnjaRQN2xvu nHasnJ30A//S8vdDamOEmXLxBgQuCdw4wPQjv706GFxNGBFI8RfbNt5dM+36fjX+/B/y/jwY0B8x SQ2du04K+n/6qz0IYyAfLtPRuD6UDT5di624IscjI+1Nw2YyAecGsqa2gk2vtIKtuXHqKd2VzNyR JbhzNKZlHlKo8gj7xPOQ35Ctazj8yRyTEVjQzbZTwcA8fX2puTasan//0/JYg8sr72DLvypwRsH0 pyzCK4uA2FbdsjK/dYADkV/vwf8AMMmnsaNnNHIGSRMknLMeM+3WqTWwieaVN3lF/nxyoJ6D9KBk 4kUS/Z5I3U+WHidPukHHf15q95NrBDDIkxdpiQ55ZUI7f40AZksNvNjf5m5ZMnY5QN7cfjVGaGa1 ZriRCYl5Magl0+o9KCeRH//U8tkGoXlys8q7mkVdoVQo2hcDpx0A/KmzW80Uh81dgZcKcfe+lf78 H/MC4tEcTC2u455cFVRkCyfcfcMZ/Dg/hWnHcK6CIvgv8z4OA6jp/nmgkjS5EPnpGxMLnDZ7gZpm 5H2Dz1ff9wHjyh70AVZH8uSaPHnNgqrqSVz65/Wq1rFNbWkkc2JHkk3B8HeBzgZ/Hmi6W47s/9Xy GKQRSoXiVwTjH905GD+FTXSzyuzk5Mh4xxj6Cv8Afg/5gVNpWI5IpIURZW2sfvAcOv14/wA5p0to FVCsm8ugYv375B/Wgrn7ldIsukZJznoOc1OxEcjl8lSMYx70FX0uVSYSzlN77z2bhCBj/Iq8kZSE bBjHduaTaW4Rd0f/1vHTbsxaTB29HbtSSQi2RZdgkjk4I746Zr/fFu7uf8w5TttMW3jlmsZVgtBJ vktvM65PDY/wrWDMv2d3kjQz/LG8sgG8jjH6UgKtzKA/ksAWPQ/pSPCEjDouCnze1BpT3sRRs6/O NzvI2fLGCAfcH+VTlZJI9qqGKg5wMbe5/kaDQ//X8WleNlVSBkDYfTvzUbRrBE8scqqEAyz/AChy eMD161/vgf8AMeSQ3ThkDBJndeA3zD0/zmoQdk7GVQCx5wOB+FAEspMzxtuxt+XPcU1XFxI6Bdy2 7Ha2NpfHU/TigB6hbjC58v5vnOOMCoZDbqkuxXJD+UHxtI+o9/rQbx2R/9DweMmJcurAA4Dt0f6U 6O1a6uI1+0Ja87vNkUlPofrX++B/zLkjQzSrIuCHA2llJCn6GmxRxBCpbY6jkMc7j60GkW+Vk11H aPFbzrCHuIidxZco/QAj9azluJ2YpIzIikZHRTjkfkcVTd7IqLbWpPdPLIB5Q83KEnIO38aqRG4d E89h5oTZhF2ImBgAD8Kq8Cj/0fAhPPbqzogeZF3IjYAb61nq7RuM/u3fllAwoz2Ff74H/M+a8TXC JmRhhgCgP3sdKmDsscYjVY2xt2ooRSOhzigAnliliEbJgwHfuU7C49AfzrOkuA0ZARkU8dfmGfWj bcCtBaF3f5nVT79q0Hswd0dlJKXKYlDNgH6elYPc1hsf/9L58tZo51lQIUmtvkeNuTkDk/j1/GtE 3SsixzoseATGY1wVJ7NX+9B/zUJN6Iy4FkuEmmYgBbjyQuecYODj8DWg8LF4zb3PnxwfKbeBdytI VG7PGcj0FBSg+olrdFZlni3LJGflyudvXPBqK6umkuS8TNGXYM3A3Oe/PvQbKLZHKVWJW8wbmb5i pyR7VJDJujjhlDLFCdqEjkDrge3tWD3Z0UUf/9P9C/8Agkto8Fx44fVI1ElnP4gkkaRj84lgHk4I 6bcxjH41/Vlre7/hGrhXXasmnKrqeg+Vc1/Tv0nKrq+JvL2sj+ZvonUFhfBXDed39+p/F5/wUcuE 1H9oSXfPK6RRXkkRjG2CPdcIuJPp5YwPevyO+PguLfwPqepTXUT21q8mntGF2ASSxkh9w6ghQOem B61/dXhkvZeG2GX/AE6f5H8BcZSVXxzrR/6fr80fgh43v7ebUhb2kontIYxFG/8AGNiqnJ/CtfwT 8K9S8dWMU9p4k8M6exneOz0++1T/AImUrKQC3lIrEdDgHB4z0wT/AJZ+IM+bizMJ/wDT2X5n+tPC 9OSyXDUlvyR/I8j8QQahpEk+l6gN97Z3UkU7Km1QyOyED1xUNpFJcWi+cxmLKOJBtbB7fhXwr3Po opptM//U/jKk2Qwy/Zf3nkPsZIsMFPpWcsrXD7iTuxg44zWMlZ2RMFZGrbzQ27hZgXG3k90qsZV8 9Csf+s+6T95h2zWM073LSvoi66qE2yeTFM7FOSDkdvxp0FiSoKTMEiUmSTG0DGeBUNNbl011K99C 8P2aSTeIp2KBo/vjA61iz5nLxOjbN+1DjcfYj60jQ//V/jLsNPWOBEWVpJAx4ZMADqOfx/SrtzpK bTdEs8sUZVNxwqZ9B+FeedBhxNHaR7Dttw7HJUcSE8nP1q1DIbaPZF5ciup5b5to7/lzSbsgI1WB z99Y0AzLPjAFW4Y2kuTEZS6bVVWcbY3B6YJ+lTzq2ptD4SNJbeC4lhWPfDnhuDsPeql5lZklUCSP ONjnbs68j9KiTu9BTWlz/9b+L7a0DCQgRiQ5443AelSajekKk7ByNgUZHzMBwK8c6raXMm0uJFFw 0yqivhrc45B7lqurM8se2UgYGXK9GpxdmXGKtdliKWeFI5IWMDEnbyN/B4NQXzS6jLZrMFmmx9mW 4PybecksemT7+lbXQnBJXEeCPS2ZUlt3cnZMp+Zx7CqlzftdrFbRytHHA5fCc5JH/wBamTHR6n// 1/4pvtstqpB3lMnzQBuP5U+K6mKhI49kRyTIxww9v1Needbd5IgEksspeSUMsT/uzEvzL0z9elaF xqnkIHK/a8HBdxtI6449uKDUqf2i8U6SW2NsiZaR+JFbv+FSJPfiGR7xgw3N5aL8yBc8YrGStJgO tI/NVX8smMn5lI+Ye9WpblbUMkyPEWbETMPlYDpUnQf/0P4pY9QiBlLW8sjykIjxnCRc/eIqdY5g HSVFYSIDG4fle+a8c9gzlv5LW5S2hJljbAPcg5xwa6CNhvDyRnqOcZx9aDGXxDdSBaTDFHMgyVA5 /GqsiOYyGKLFGOQB1roSS0RJHDPtaPZEzDO1kl5RvQ+1FysM0pErvDHtPlvBgln7qQeg9+etNK7s iHOztY//0f4u47MzxRJAA7qN2D6DtWRLBc288sipJb7zvWPd8g/KuGKu7HoDZJnMRZlJkL5MgOcD 6e5q3ZI7yxvuCoP73yk/5/rT5HfQPI0bqaLY5VZXcDgoOPSsuBPOKxMSJHlC7WbaOcCpuwL0jJZz CKba/mMY4pEcFWI9PWp5L425W2Vw4lj35cfNwfu0N3dyI21P/9L+O7wTqr3GtxGS2jmniaNQpl2N PFFj5QR/dx09q/XH4EXyQ6RZOmlO7X0rXcEV47oUZ4lIBU8jBAPsR04r9/8Ao90pTz+dZfZS/G5/ Ov0hasY0MDhnvKTf3H9Vv/BILTJtRtbDWtQtnW8u9TQapBMCrXksaW6xOp7qo3jHoa/cv9pu8uNP +F+rKpWJLm2Z9QkyWij8pSypj3P8q+c8SXCXi2qdPZTj+Z+28K+0j4YRlPd0n/6T/TP4Tv2gtVi1 3x/4q1m3gla4utWu4NVDcCMrcN5Twr33KO3YivxW/a11CNFuUjmeFJpGWwabl5nR2RQw9gSQB6V/ X/Gi+r+HE4dqNv8AyU/lDgm1bxBUu83+Z+ad68sVw6+azF+7HOa0LRxDJF5aFzgM7Edfav8AOTEv 9615n9muPKlY/9P+JWOWM+WJowsrYYY757120M8Eu1ZIVRWVViVBlVIHQfzrzqnU1hpFmtDqD2Xm SQqBL5fl7ZFysg6EH61Wt1t791muoHi+cuwA3KmDx+RxivOqip9Tpo9PtLVbVLSCS6aZjNcXJJwu cbQR2xXQ3VnZzWEemXIa1aUuXu8tLjKjaNo9Of8Avquefwm8ZNaFyNm03TrWzE0rRQoIbfzjlwMd SO2cZrP/ANHS5USkmUpuJA+9zxk9KxIP/9T+Se30hL+UtPdQWMIBImmkEasRyFBPGT71t3629kLS x1K6/s2W3I+xuGyt0SOPmXggjJ644r4hqzsdcNGZ1jrkbOsQu45JDdNALiHEixFOOTnHBBB+lVSt 8Y57mWczSSyEG5Y+YGJ6Z/z0pGjV9C7azyIifa4XlZU+aWOHEYI4z7fnXU6PJ5SzSi6+Zo2JtpD8 rDspx0zSezCK5VYxdItdbW016+imW4t4z5z6PLMu/aScmPPbOD7ZrY0K+kmjH2m6W0ZvkEUjgJbJ 0wWHX/8AVUz2M3H3tD//1f42LmCRESK8uDI8PyK4I8tkHTHp9Kxb+ayuJI4NPvJVuINoYsuY8txg jPNfPK93cwrXsdImkSxxEXKgLJGGbacEkj0rmpIpUkeMWyqwJESj5+R93+lUnZ3MYX5ivYQ3eqXz xyotteXWLdnu2CrGq/xMT0HFWLvRJzfG2muHZF2x/aBHst07Aq3Qitk7q5TbUrG5ZaPIY7qGS5t7 X90VhkkJZWYdOB/npVO8ma2gubkySBII8tB94ccHaPeqTaLP/9b+MSCcDT2MKStA0QmmWRCpi9CR 2xn9aihl02awUtHJJKWysMc21htbOH+uOK81Su7I5ZS5SK4tp9Ruhb6dp9zpaXUiJJYCbzZ9/TIb /aP4jNdVLBqaSw2mqrM39loIkguDgKAMgZ/z27VtT6lLYzpru4vLp1kZ1ES4jCnCx7e+fy/KsUS+ Td28bXFy1zcSEbly+8E9SemOa7qRnU6Hb32lixGW8xzc26mKVgVZSBk5HpXk+s+aXktpGUeWNwbs Qf8AP6V3UVuiX8KP/9f+GKx0uKSUWT3LRQ3MyrcybcArnkf5zX61/sa6u2jtpxjNjei2e58izuIF u7OWJViVTyDiQFMgjkGv3fwYm6XGNDzTPyfxShz8L1T99P2D7uz0746+Ff31yBqTm9uLFwFitA5j 8wq3HBKgEH8K/uX8AKLnwRZ7H3M1gu+PO35BEAAvsQK9n6TEGs3oS6Nf5H0PgLNVeBZpbps/mA/4 K36ZY2/jfTtauMIRfLb6Ksit5KNNEPMRlHoI2wf7wNfhjY3lhOEmiuvMuTAJJo1jJhRskFRxnt1P Ff0n4B4l1fDzDLpFtL7k/wA2z+IfGSjGPiBjF3dy3dzWMtuIZIUtLqIM0tzIzZuVbBVQOgx/WuP1 HT7xktbawjWYSEusIG6W49h+Rr9zg7o/I6tNKVj/0Pzd0maxg1KWO+sd5CGKPc5/0ZyB0/wrpb9p LS0hhaCS3gl/fW12yYjUZGQG9+DX+zUHZ6n+QsqavY4/WLrNydPmE+rWzyhw+nIrHoOWc84OT1zz mull1aCPRXksJGj8sC10qC9twXZkJ8xZGXGfX2yMVunynJNWZiyak11bzGSNfte0BlWIFEyedv8A jxW74duY7nT5TdQXWLZSs7CPEaEcKMkdCcfnWyd1cwqdBJLzZNFHb2vmy3J8oRIuck8LgDua2rRL K8m8nV3ubUR/ult7VgZVI6g7unf3rSDszCe1j//R/PG+sBHN/oWJEt/3UiSSbCgHGTmuenimE8jo /lrI2FXO6JcenP8AWv8AbA/xmbsrnR+H/KE0s91bveGOM7I45PLYuAdmfUA84+lLDqlvJq93/bFr K8XkJa3FvHm0+zquEDdOuBg8c0GLbe5a2rJKk1lb3DadCn2TftAt2/iCqOo4x+v4El5YWtzEkP7u 5uCLfy48s6hsj5j2BoMpSadkN1OGFbVeBFIEAHlj92ccYHsOlJpkNpb6NqFvJLJAmoOt08jL5jPL GpVQo7AjPFaQj1MptpXP/9L4LtreSPTkuLWVnfGHdG2tECMFcdvQ59aqQavbNfrbeY8N/b2P2i3i uF2qwGN24+oxwO5xX+3B/ieZ2oFJ7l78STXd7MAszSMQnXPGev8A9apLeHXmtr25I8jTGKRM0bAN LyMKR369qCJNrYm+1Olp9iVLVVumXLTWoN1CVIyVkI3J06A8/nVm5vojHAuyOaW12p5vHmkdCc/S gzV7hZxT3mpSalDcuFU7Io5Bs8ornJB+mPyq6+qHTi7hGZt5Z5I08yQk4UtjvxXQDbvqf//T+Hbz UpTHAEnfzi6I6RLvb5mAUkDoOefoahvbi8t7t7PUbSG7ltmUOCQ0RJwQ35EHFf7gJX0P8RpOyKt4 EN39tt4raCGNWWOESMfmI44z+QFc/JZzXcFyoknjlmBDSxnEq59DWih3M+dm6+lm3ltdUtmzbrZR MIX5kd0VQxPsxDE/71XLK6sJbye/u5IreYL5sUBVVt9y84ZDwc4rQgrwWWpXS28V5KLOK4uptT07 915kF9Eow3I5B+UdqpzWA2mRYD884bc5JRQOCAP89KCU/eaP/9T4Xt7XyYsrdRRtJHvCK4ZhyVw3 oeOnpWReW1yfL+z3CzyGceYhbEiAEZwfxyD7Gv8Acg/w9k7aGncrBMbdLlbn7YvyxFH+Z+OMfrWf bwT2t7FvujGZUk8lVBLOQM4Pp2/Omm1sYtpbmzd3dtZ6Cn2pIrhpZA9w0I3zWhL7CGHUjB/I5Apb 0WVjpAFpMTPJHs/dkNEE4I98cfyppNvUicuXY5/wnfrDNJPA7vE+VlR2YICCckKenetx78+dfQi5 hmaa7W6gy5326quCozjg56fStbJaHNzn/9X4OXVJjI9q8cZluH227ISvpkY9ecVEBbuiEafdWd/b XH7y4muFkjlHfCADHtk/nX+6B/hRzPubMUnkLus3a4Xz1fZMFGem4Y6EcE8561amvdIvJ47Y4tZF gCWyKixK7heQQOBzkUClLqzOhijFys17HPsXdGHhbABAGVBPB6r+Yq7FqdtYwtb7TLFkmIngKD2x /nrWkI9TBu+rKDalIUliijCLdPtaRgAsYyOAew4/nRcaPPbtaT3M8EhdN8SRtkpu7e3HOPetDOe1 j//W+GZFn0i9e0vEu7O3mKiyupgQt2rIJCUHcDI4zxUy29jPFHdRyyyM0jJskHlsjIcE49D/AI1/ uwf4LOSRZ1GR3XTje2kkdrbMTG23y2nX+LY2PQ061uLGO5ikurJjbs4MIIKxj0yaDllJJWK2ptbT axBdeX9os1+WWGJzA0IPAIJByOmatmxMl35NvHJG10yx2ts7l2kLY2gcDJOewoMlK17GcIEt5XiB Hm52svXBHavUvBsz2dunmM8hkY24V8lM5+Tb78/zqpK1jlqu8Wz/1/Rv2SL/AFZPjJotu13KlrK4 KwkgJFIiyY475yc1/a38F7g3Hw98OSPMskhshuAABHC9f8a/uL6XlO2Pwk+6X6n8bfQqquXAmMpv pUf5H5Kf8FiLG3Hw4ivg+y58kXakfxNDIgj/ACYjPqK/lolt76NI4p/MnucAvcAFS74ySO/XJr9n +inJvw8af85/G30w4cvinWf91fkgkuTdRIl66R+W2DMkeGboOR3PH5k1mtY5c3CyuWQEwqeM84Jx X9Tn8gzjq0XLaeSLcHxh0KZIB545pC8uwAHaobeHI5OPeqgveMJR6H//0PD7ifPywII5JGzhQSG9 f5VbR2+zBCip5ZJJH3m/Gv8AfKSaep/zPksNzDLbiQMNgORleTT7WXaz3ESl/LJU9epHH8wakTfK iFjPCyLMMtId8YjGVQdsn1rUWY3j24nYQpBGQzIm0S4B2hgOp7ZoMuazbIbqJDKdhYxbRtY9c45H 51WaZY4MbgV7n07U0m9EZ80T/9Hzi71Gwt9NtbZLRLiWWTf9pEu11BI3ZA7Yzwe9U1hiu7W48iAW /k3A2EyDeVIyAPUcEf4Zr/fPkZ/zKKokyqto7rgygnG4rn5vp+lXriO2ijSWwEm2TERRxmQ9M5x7 in7PzKdVPRjV+zxtFHMwjEzCIsP4CeM1PJYfZ1iyRIjjIlQ/ISOw/GqjFRJ9p0SM65tZHkQJMSiK d8e3nPb+X+cVJHOLVVSARi3Eyy77iCOeXzcAdSvTPReg/WqsLn8j/9Ly4sbiSRpGTfkyY2iJMnkg AYA+g4pIGVV3vEzRucHacAV/vwl2P+Y6VTXUiaSNJSIARzhR1P40SX80UTOwLOjfMAMk4z/hWns+ 5HtPI0IjFJApwyyP8xyePaq5nNqkjLgZ/dnC5L5OAMU/ZoUptog2yLu85thTpHnBbNRBZlYMu7DD JU9ucf5+tHIjLnif/9PycGFWAiiIIGGBO7kelSjUmXfalCMrv6Y4BxX+/wAoJO5/zEKV1ZE1m0M7 pDP+7Eh4ZhlVqMmzaaK3mn+zRmbylk2bgxJwB+JAH402k9GCbWxWQpvYRj99BIUd15GQeuK0YVZJ zKsnmM43OzDv1NMRbuRDMxuFlAz80qkbQp71leRKsksjzRTQk5j8s/MB6EUCbsj/1PJ2t4pF/dbV aRS23GNv1pFiMEccUm/Mr4WUf6sYHI+vIr/oAP8AmAbuy2xiGFhB+QAF2+8/ue1Qz+Y21g2UA6Dm mnZ3EQpI7qUZMY4BxSJJKqhIyQycAnqa1UogWTHFBDHcMs0k7ylG2sPKRcDk++QaRr5sEbWUA8yq cnHuKfMtrgf/1fL7h0eRNsjMiYKyOB8x/wB3n8qV3wC64lCkbggCk5z0X/Cv+gg/5fxbgRNiVYiC yhGfHHfj8KhWA5VEDOwJMYxyAMngUAVj5nmSSMmIw23IPU4/TvV2NlEqOAp8vldyA/pQA6QSyzNN tDuzfMsarGp+gHAqZ1MDckjcPlU0Af/W8lnmHmRp5uwyPtyBmtIvbwMnmFZSuPlTOG9uxr/oIP8A l/KErO1yjoWRM4RQufzqzIlvbuEZw0kwEjKDnPA4/wA+9AEyebbRySwM8aMNp2jkjv8AyqRSuxGc sW6oc4x68UA9EVJLjytyxgbn4OVyce1NiXeDJvk3qP8AVjhR2oJi7n//1/LY4lDSMdzFxg5YnGKh sVjhmlUNICf+emTn6E/54r/oIP8Al5luW3KiVEOXZufbFW45ooyR0boKCSSTU5jGkE0Je0MgxwEb juD681SJWUgbQCPu8YNAE0cH73y2ikm6hliIBX3PsKu2kEMXnYuk2cCKIqRKD35HHH+c0Af/0PPI bZI3k8y4MkavgEEKxznpVWSZLaQrczPLG8u0TSHc53HoBX/QQf8ALuX44LNlMquhIfag6OffH4VB KtwzZDcKQi9uMdP61cZJKzAgaP7MwZztDc8HBNWPNV4/lG5W6NjitOZAVpI7CNR5eYsAeaZHH7xz 1I9vT6VJENzrHMxjhIOJeSAR0GKXNED/0fNH2yHaWzsHQdQO1SwIpZVK4LfkK/6ED/l3GXoAn2NG UfGACuGIHr+n51QFvKZSqo+1+AMdaV13A1FgfyhbCJlnhy0rE52gAYz+RqMRDYBLkMpBG1ioyDRd AV5bcy5nl3BIiNvlkq5/KrhaJBb+bMWjYfOFzvi5Ix6e/wCNO6W4H//S8qmPmzusIKQhsbn4LD1r SW0dIFWE7yw7Hc35V/0G86P+XcZbW1uI5TM0n2jzAqq2NgGDnj64ppMir5cWNofdtxT54gRXCRSR qJowPLPmZVccjuaTKv5UdsrMWGXfbgJRzRAbMJt6QoriSMHzifu5HTB+n8qescswUty6dccf56Uu dAf/0/MLlnKC5vJZHW1j8uCJ2MiouegHbHNR+bDtZnkMeQNqsODk9P8APpX/AEHc8T/l3JrYCIMO Srcg4yKrSedGxIBUSHKMV+UjODT5l3AcYZJH+c4U478USRwbTDbOyOBgu534Pf8A/VUuS2HZrclt d/l+UTvcHjJq03nIWjdSrbfTGKhu4j//1PNtpW2Mrk7kYKG2nJY9OKoyzXtwpW4csikeWiqQcDjm v+gg/wCXOSbeg+F44H3HcHC/dxhSK0UlaRRMYykcpPlsRwcHtQQ1bRlnz4sbN+WUZPGMGqMzIkqt 5ihSfn7EjpQCi3sSMQkihoztZdyZXG4etAgjufkXckhYeWxbagHOdw79v1oHySP/1fPUgtoY3E65 dW+6PvH0OfYgVUU7ruUl9sWz90QpzxngjP61/wBBB/y5KD6l2O0inVwzBSqlhx94gZx+PSq+JIEE qEpGBtY4KgE9s/nQNw7DEhll8xkdY3ZTiSXJUkdh+n51Z+ys0GCyBkXLnoB2zj8RSbS3J5JBHCqR IyOJckqCOc4/z+lU5TJJOokfaiqcYGeccChNPRCcWtz/1vOvJnjiLwk+bsIGWwpPbj8BUrRJDDG0 xMskxBdSCyq/TA9uK/6CD/lvI3ETsqBcHcCFHA/Gn3KTedh2i2n5dyYALcYwRxVKTjsUot7Gf5V4 Lg27lVKth/QDJFXDD5TOnlscj73DBzjtRzMfs2QxzyKuxovKZjwr4BOM9KjRbos4QnaTll2/eAqQ 5Hsf/9fzF7lbYxySrKcEZCZBUemKuTyCfLxF0RpP3CvxLt7BvfHWv+gg/wCXLkZNOZ/JXdluNqKO QBkj/Gs6GKdpVRQOOc5xQHI0a/l29pE0gCrKy7pdi4yf69KrkrcCJo1I3L+9Vh8wPpj8qCBuy3i3 upIdcLFtOFXB70RxebvuJpFDLwEfLCQHPbpQNK7sf//Q4iCOJHe5Scv5qhzgYEZC7QB7YA/M0xJF k3b3wSxw6DBGM8dfz+lf9A0pcp/y6ezQ1X/febJ+8KrsXf8ANgf5/lUIKzbws4i2ZcAj75A6H64q OdhyIrk+efmHLH5towAe9TYWJdirggdfTtU3YciHW8D3Em0yAAfdznk+lNa3jWRhI5yr4x2OKLvu NQSP/9HzsTXDSSxgoIy4ER24wMdOvc5qLDiaZpX3ln3fLjb/AJ6/nX/QC23uf8u5ZlP7nfIoIzlT j7tU1mkDqkZRUP3/AFPpikNK7sWfIubxj+8jhiijaSSaaTZGqj/HtUaRyW9qsspDeY3yFAWDKD1/ Wg0UE0SOtmXYRymVfKBLqNgjfH3SDS20ULLKZrhIUgUsu4EmRs8KMDjPvx70AoRP/9Lzpvtsm+Xy 0a3BWMHAHGP58VBszkEZBPTpiv8AoAP+XzkQ7CxB4ZV3xkH5j8w/CrDRaeqQozxzJND5kkMQ5QZw FOeM8D86A5EQx3psLWSL7NEIrl/JQBctEM5GD2pod5URQjLGTtU7cA/jQHIiaRUjiYoQzLwcY61n rvcEgnPcHigu1tD/0/LH0154wROYW3ZbcgYY9Px6dKigXZvi3AsnQ9c81/v+2luf8v5cVBb7JtvV vkyvykjmrk7Dy0dC8abd8sYOEDc5x7UuZWugKKXUTSiKcfMW+R1z8o+lWJixVnByisE3E9M9B+lS pSsBUuE/1flgkryT34qcIDA03mR+ajDMbZ8zB/i6Yxx65qoyvoB//9TzGaJhEXVgxYAk5wFHf8ua glUpDBLGwl8xd6+gGcdfwr/f9XvZn/L+Cqs5Uh24IDDoFPP+FNecwTssjNI+4qe/OaUm0tAHxSTo 07PtaJ8eVGq7SoA5yc+ufSoRcurkFSpPIGOlZNt7gWLcJKXcyBM/Mc5IJxUbBSSobknGR90UgP/V 8rhVocXLrKzJhQAefqPpVxbozh54m+WcZLsSGOeTmv8Afg/5hIxTWpTbdgqSTj7pHOapiJYRLK7u CgLlgCQOO4oHyREsUmurRJvMV5JMblVdp6ZyB2Bp6xyeeAzFY14JPGKB8qRadFjDzRiRoGO1Xf7p P+eaWAH7K7mLLbvncN95e3FIZ//W8x2wrAjWjzRzurLMCQBgjGFI5wQSDms9oC7KpOZcfKP4q/3y cnsf8w9hrmeKKNR/yzclyB8xB7H8qkiWSadVJkjjGHcjgNz0/wA+tLmfcDTl2AkqPlX19KRruWSA W5CbAd0YVApz9cZ7U+aQ3boUreN33eZuwTxg4Iq0ZwsN1apcMd+0PtUHJU7sEnkY9vWjmYj/1/MR eOsYO9iUURjJ/hHAFQO5lkD+YCpAJVm471/vlzSP+YewyZo7hwVbfHExCkDbnn/63SrW4GExxoFY c+ZjnHpSu+4rLsNX5ISJUAD8qSOvbP8AOqfkF5QEYDPIY520XfcLLsXYUEPzOm4sCp3dD2yD2o2u 7tHIpXYdxHTj/OKQWXY//9Dy5BbvNIVXam75cnJGOP8AP0pZn3ykQ7glu53qR823PBI/Gv8AfA/5 h7FWaOSeQuAzDrjPJqVnbaYxGybMA7uucUBZIhh3+Z2Bz8r+lEr7L/y5pBNEXAEqDaDn689aAJz5 SMEWMDactgYLVNNHKJ0tpUaGOSMSeYcEqp6HHXpQFrH/0fJ5NkXmwozNEjYVxld4HfFK4E1u3dAd pBOT+X4V/vfdI/5i4JPczWiZgYkxgjLr7VKthDJEglUNtIMbEZC47j0rJt33LsuxanstqeazYwuU b1qsgkiRJSXkic7WjK8EHHINT6jGjaGV4W2qjY9DkHB/LFWYZLeSOVVysjOOQOOMg/0/KjbYb6H/ 0vG5IbYRs04JG8oUU7WYex7VKkUM9oFNqn2aFfsxSVstNwSrnnOR2P8Asiv96bvuf8yUNXYqxxRW /liOMvtGAzHLJ7+tWFgjuny0iRyMcHedq/U0cz7l8qvawy2SJvMSRTuU/K4bg9eB/ntSwRRS3MTy NLb25cpIyJtlwOo2nHXpzRzPuOy7Bd2+x5Da7wm8+X5nDYzxmq0lqCVRpctMQdwOMn3/ABou+5S3 P//T8Dlt57lZI1YnyFLErnAA78fWiOdre2E8yPMkMeWXIVzgdzX+9N33P+Z6y7G5B5EthE8LtJdS ysstvjaYFwpTPHfcenpWTNbvHIHnO3c20L0xRd9xmsqLJGihR+7XBO3g9eay5LZIy4IaUKd3y9V5 9fSq52BZhGxGZvkAXI+lZzqJFM0UgKg4LA/KDWid0B//1Pn10TzfP+Z3ChWUnrjpxUkiG8SBJhgQ sSh6EA9v0r/e1KV9Wf8AM+LcgwxuIl8+U4CAvt2cjP6VLE86MpMZKFDljyAfT+f5VVh3I3P2hzCi K2GySDgqf8n9aorDKJZEZgsEKbpFJzIxzgAD8TWUviNYu0bmkuLlpHgjKybfkhBJCge1VLb+0Y75 nRl8nYVlVk3ZB4x7VJR//9X5+is2guXkR2+Y/PGBw3ufp/WpLhFcMq535yfav96D/mrp9jGmmltT sTcXmYBsDK/XFdFZ3l1GtsoijSISeZvEQDNkYJY9TwKDQS4GL+cW0sUieYUaRPkjXP16de9JqaIj wQxbZERSks0bB4/MHUBge/HT0rnNo7FBbYx/OvzEHcN3IBrShjW/bNxcolxJKESNYyNxbjgCone2 h0UfiP/W/V7/AIJD6Fa6dcPbPbk3H/CRzSSxSPv855C5Eq4/hBYcetf0v+KS8HhvUS6hxDbMzAZG AAM49K/o/wCkU5VPFWpGXSS/M/nj6NKp0fBPAqn/AM+k362P4o/25W0zXfjzrdtFJMl/awGMj5lS VZZpiDuzjIbHHvX5F/tOEweCbdIZcWt9ZS2JhgnEwkkimLmSZf4WJVAAedo96/vzgSDpeGuGvv7F /kf515zUjX8fKyht7Y/BjXIWl1fUY28qPM3lxRxrt6AZz9awjYLaXUd7ZB7G+sgJrSWBjEyyDvkY 696/yn42lzcUY9v/AJ+z/Nn+u/DySyrD2/kj+Rk61q91q9wZ7pJkuPNzPLJ8xdv4iDznPerKtbzW olRWimA8t13/ALvH09TXx0/iPfhrK5//1/4zVhazhnEaJHBKDJIVOPMb1P5VkN8kLPAAhQZB7D3N Yz+ICyphu4wfPZZSmbh5BkbhnHTt0rPuBP5Nt5Suz+YVBXg/X8Kym7aG6SRsQWktzF5gieSSDEkm FLBD71S+3XvmG3nV4VV9zQScFx2yP89aiUrgla5ekuWuTFEQ8jdFjHOz6VnwQv8AagY1eRpJMhM8 KR7fhUjP/9D+MS11JxcsjHylU8BF5BFbFxqalWXqpXpXnnQYEsLXMEig7eCULDIBqnp6TbWgkhMC xNgEkEP3z+NZyaewrq9ix+6BaKZtqnkimG/aXbGJF2RHajDqR71mbU9ibAaKNYl2hpNzsBjcfXNR ao5SIO4yxwmAcCgJvSx//9H+KaF9xSKWdyRyqtnEY9q1ZJ8pDZ3A3qIifPKYjbb05rx+p0FKPgCV x5iFcxg/6sjtiq8Lyy4iXmWWUp5aAkrjkfh/hQbQ+EtiG63zPc+YCi7Y9qFskDgdvzqoZZYE8m4f yvOG8N0YDOOD+FVFNvQUpK1h6IJp402NIvJdjy0pxgVXkiginMqNIkpXBTOFOO+K2Mj/0v4rrWFZ UmkmAfdD+7+Yhlf19+lXNPuNPSSS3vFkWMwkRiNQWL44ByemcZPWvPOlaM5k/aY76RJI1tRBL8kS HImB6MR7+n61eUPM7xsUIm5VHwmMehoNyGdYYpGZYwuAEaENkR8feGeualjlLQpCpYR7sY6455rO YGzYGOHUEjFwz2zkKH8rGMcniob6+k1S6XTXtMsszpZTxodki45Bb1z2+tZmykmrs//T/irt7ixs W+zmF7iYuyzxfdK4HT2psL3M8KYhWN2lKsnmf6pOeSf6V456vOitLHFbyeaRkjgFByKmh1B4riSJ iyjyQ4dlzjnGMVpyaGRoF4iAxkBLfP5xTbkentWfCZJhPIu2SFjsgXPzAqeSf/r1oA77RPFJGJ0R ABtwP4az7+QiaRvLdCqCRPlOw+pz74pp2MZK0mf/1P4uLe9tWiiuba3ljV0CSBn3BXAwxHsfT3qG dBcAbWmBDZfn92w9PauKnuegSQDYn7uJX2cSADL4+lXZJCYZYjbhX2hklA3Oox29PetSeX3uYiaS SO3VJIGEpAZHxgMD/Ssf7TKb9EkgSOEJh7lzhV7ZNYytfQiTd7Dza3MF1iWWN4hIZonA3FQ3YVqR qkpjRxwCcuRyPpTmrMdLW5//1f43/A9gINZfdJuuppESziEgjyu8eYVz3xyPpX7S/AWzMuh6fezJ PK3mxwx3tzMDFMrjaVyf4htzkHj8q/pL6OMYvMMR3sj+YvpESksdluul397aP6//APglD4bgsPCO m2SpI91YIJEmMhZ5HYs0il+/CKAOwFfpJ+1/f/2b8MfFsbjzLebSJbpBLJ5YBSNyVU+udoFfnfFM 5YvxaqSvd+1Vj+i8DGOF8NqUNv3P/tp/DH8QptTm8YaperZrPBcXkl1bWMcoSSIEbhG3Gc4wcnrz X4vftMWaRX86XsG7+zXl8vzGLtaFxHu59ua/s3xJtT8O6q/6dfoz+RvDe9TjtSfST/M/PGaJJJUL BXIH3gcqx5q1a2xnZo4lkMwP7uKMbnk9q/ziru9Vs/s+fQ//1v4grbTjEpbMnnEhWDt88Xrx2r0G wvrSNIw0Um5QIx8paMkd89vxrzavY1ivdsX7i8jHkx+XhppAgG3dtz61YiguU+0Wc00aRKpmhlDh ZABzsIHA6fXmuCavcIJq9zf03UrhEVYYRN5yGMlnCBMf/qqv9u1G/uGuI7sW6W4DQxGHJu2Bxy3Y Yz6dOtck+xrBXZtXd1b36Wcd5dNBdrMCjLyA4Hv2Oe9dI1rbNYSpGgNzcFVMsn3lC8gg+9Zk2tof /9f+Qq+EGoaXPpOqibZJJs2oSu/a2VYMOnQGn3Ng99b/ANn3Ikni+zrAswk819m0AYbqDivi5WVz qj8SLlrp8enabb6TDZwQwWm5o5ok2ztuOW3tnn6+1RSxJAy3EBn+fC+X5hMAP99h61mbJWVkdRpP iKbTAiTwJdW7MfOR0Lwz/U+vp+FaYl+1mefTYWt1kXzcbRK0W08/4Ae9TJ2TAalsl1DeTajdSWri Dyo47dPKnlLdDs+g6+4rd0fw6tuonELT2Vxbi3iaUhnikXBLHPPI4/OlN2iRJ2kf/9D+Ml4rm/lO npIJLpFKpk9QoycfgKovNZeHJ9Pvm0/+0LmeXYySAraPt65I54zXgONmyaiVmjVudauJbtLwurJN tH2SIlkQdgQenXH4V1Ut/o93dP8AZbOaI21oikxx5jWQjBKt3wefxqoxu9TG1ji20y83zzRzZwxz M7hZVyTg49R7Z6U9NQuxbC2vZJLs20flrI45YDr04rW3RCsiOC9F07Q26yn58AuDg9vlqxbpC0jx TXA8138keY2EBHUH/ParUHezGf/R/i01CKCdhZSz3UEN2Ps8k9ly2Ac4698dTUzW2l29yh02CdH2 pBKruXeRkH33PbPJx2rzlFJ6HLJaG5cm4uRG68x22dwSMb5M9i3UgenaqkcupXdwEAZbQRZMgfGC p+62fWtafULqKVyW0hFxM8DyRxCQmM+Y+0Dg55/A1kXELwyeXFOZGhO2KR+NnJNdtJ7ESaex3Vjd TPpga4s3uJgQqzG4wkoxggDH1PWvKr+wmM7Q3pWIxTFrSUyEKwOThz6DJGDXdQa1RnNvlP/S/hqD 3RunxanzYpCY41/eCcA8bcetfqH+wzBFbTyRXE0mkQaxq6zXlvdQY8sxxBlTnlRI3Bxjrmv2bwnn y8ZYP1f/AKS0fmHiL7/C2J9F+aP3i/ZO8RW+i/Hbw3pt/Db3Wp6mEvLR1BitrW1fr5bevPev7sfg tcrceBtCu0iykenRQxIp3LIAoJOeh61979JvDuNfC1ns1/ka/R1xUa3CGJoLeM3+Op/Pl/wWp0C5 1CPTY7CcaO1hc2skdylqJnLSSSgnHTrKBn/Gv50NN02awvbKMRmSZU8m/ZmESvtOefQ5r9u+ju/+ NeUl/fk/wR/IXjdHk8RcU35fkaN3Pp81zJcXkiWszI7IDE0jSBOqrge4rk/t9zPNZ6lZRSxxQ3DJ EHP7+AjpkA8Z61+/076H4xiH72h//9P86rvTru4iNzbhntY3E12GZfPWY8ducYqbT9GbVYLqK11B rZ7ScNcaPdOZTeI6HM0X+7gg9/av9l1e2p/kO5a6jbjTJNJV7zTrSa78mNYjIYmjCFsKeT0xyR64 rRu7DToovsllNczqsccry3tuLZFmdBuVOTkA4Gf59T0R2RyVN7hp9tbQrNG8bHUHxEPJTzNx5wMe /FLPcXumwXUdz58O4qkumuu10ckDMgB68itYXOWe5WsPt9sr/ZbREvFXzvtE4Ym3U4AbHoM9qvfZ kW+ggLo/lREzX0JZNu4fejDYO4EEgH0rQ5Xuf//U/O5LJBBqNuby5kmu5i8k0oxPcc/eY9jWraWd kbYrKhndQAsbqGU4/rX+18fhVz/GOp0IBatb65aWUU1tZ2s9qZZ5ZZ1iFu3YHr1HY85pY9HPmyXN 5fvqbMcPMV4lwcYyO2MUzFys7Fu6vIbOO0t4oSkJcmQo2AyjGQPf3PtXPXFpJcXl3qNmCLCSfyoY nj/fQY6ZbvwKDJu7uac8yx6N9ndI31D7WJJBwzmLGPv9Qe+32FSXEiuls09u5htGEkdvCpYMfu52 96uC1MZSvoj/1fgsiOygurlL8Rwbw4tDC/nSqc7SFHAI+vGaisJrbUYLuCzXTRdF9sN5qAWGSLdt OxnOSudvSv8Abg/xNckivo01q11Pb3IbacMQIldFx8rCM/hnrUV1bW16LuxjudQW1iYXEN5C3lDc G+6Qe/Ue3NBlKV9WS6bdWl5dqNQdpRA+LyVhmWQMOrH1PrxUt0IY54p4rJvsiXH7uKZgJLiMNjOR 24P5HpVRV2Jaldry5mkvEYiG2ikOyFI8LASBxnv1HNaHh6FtxlmuI8W6tK7zkESAdFC9ya2E3ZXP /9b4avdHt7/ymivI7MyyvJPdMDgbum7aCcA88A4pWsbSKRrQajBeXtpCLd7m2J+xSYxtO5u+OM8Z 9+3+4B/iG9YXZW05bSTVozdHdFa2kr3VoR/rJDgR4PoDn/vqqkVvIkzLfXUUVtcXgmiiUkNsUDGe ncNwPWtYNtakxdmXLm/+3bIraE2yI3kKMkCTGRu/HPbir9q9jp+PtOj2moSxZO+6TeoyMHg8fpVk mUzyTTx3VmiwXFsx8toiUSFM5KIucDOKk1i7tri4tnsN4UQqjwtJ8/mH72cDHegjmSkf/9f4vSLQ 4La1mmiSRnBLLI5jkWQcBjgfMB1Azxism20lZ768miZ4rdPm8/r5jkD5Qf8APAr/AHJSu7H+HM3q LbwT/aYpmcmWylDIWPzcE5x6d/zrShfTIn866Eizl2wuQygdMqOx61rGNt9zJyXKQSaPdaaGu5ow LG/4tXkjw5TapPB/PI7YrIW2sre0mnhLSXM1yfPR8nKhVCEHoOhGPpVGFR6ajLqwvYrOHUFjja1m V1/cOokGzGVKjkdepqe2FnqdlYG1s/sjx7YpvPc+blfvsfr6ds9aDkk2pM//0Pg9re1xMlyJhBFd 7rc7ti4XlsMOcdM496fqn2maeBkha2gZQRlDslXHUE/ga/3Rirux/hDGVtCW3g8rBmkVYNwOM4Kj uf51uNpui3+lXclnBb3LXOIvP81kuLQxureYjdOQCOPWrUNdRzknojNfbFZAtP50CS+ankNuDnGD j8sfhWWbZbiPeN2Ad5A4YD6VolbRGMpJaGmIHuBDDCqJHGuWlcbSBWpFp2ltYrapdbp4OIiTtLEA kgH29qCJSuf/0fhadI79lmubkv8AZhsg3EuTjjAPsKuC0BszcIWbyhuG0EbR6mv92D/BB7lSFYmM KXYaWPfubnqM8ird9I892yW5RLNJl+xwbckADADZ685oOab3KN1lfMkitpZ3tsQ3CRjf5QZh2/I1 0zySK1lBqF3Z2tpGBIsk0e26kfHRXHPpwfSg5/Izk/subU0m877KVGTDFErecF4HB4zXpvh2aMuI sTS2yNncEVJIx1DDAxkfzqpPRIiS91n/0uj/AGcWeHx94dmsLi5lvLDWVDowAeXzeMZwBgAk1/a/ +zzI0/w08NzO4ZzZJE6hdpXYgUZ+oANf3l9Lymv9jn1sfxJ9CWq5cK5hS6Kb/JH5s/8ABWSxa48A GQQefDHpDiaJl3byJIpAFHr8jHj1r+VR7y0uHnjnW+WSGNIx5g2PHIFUtkkYPfgeo96/TvonVFLg OcE9pf5n8qfTIpTh4nVaklpKKt8krlB7V5dkcSSTSyt8wCgY9/6k1DMHsbjyZo3dVGGZVJCnAOK/ rA/jSo3uiK1Ed5dZbKWiAmV243kdFX361b1CeFZP3MRaEgIIt33fpVQaT1MJN2P/0/ItNt1WUbPK UgFohODg+1QMqRk+blN7FUTaQDjqK/33utj/AJnxBbM1vHJGhWMybX+XlQMZ4rTjuUtrSSzghXfO 26WRlyxHb6GsXvoZzKzRSjynJxGAdpC5BPYE02Ccl/LkQdcEZ69sg1qnG+hjL4WTStIihFCbGcFm I3MoB5xTJAXVmWJSkfzHjg4qjE//1PFksby4XzdyRRxsCd4O0LnrTMFbloklJCAZYZCkc81/vwf8 x5s20UEX2nzJS80+BDLt3LHxzxUNrK6Tm1uYvkWTDujDke34UAOl+zqSIlZwHzH5mS61XjupTK0T b4484wwxu9xVRaT1AuxyqsjlGZZlHDcFMcg1DGMsEYq0OckZ79qvmjcD/9Xx95lF40YRhGYyu085 PHP/ANb3rVsFWNFQldq8qrD5QfSv9/FKK2R/zE8kircbLKe4leF5CUbbGnAQ4OCPX6VUSQzReauC ZVyysPmT6+9XzLYOWSLdv5k0JAlWNo2wjHJ/l9DSqiyXTW3nKzIu/Azg470zOSbVkJPAFLRudzj0 7U9UWO1aSSYR8+WgPJORg0GTi1oz/9byWyDBizq2yNtodud496v3CowMsaZVV3SNt7f5/nX+/wBz RP8AmEhFp6lVASPNQZjxlWHQ596kwkrK20AY78nNPmQnz30JxDCit5eFYZc8cu3+cVJFMUgaXy5N 7AALtwqjvmlzxGlNaGRJI7SAsCqbsEY4NaAKKpVIxu25MgGQ2R3+lHPElxm9z//X8qRJ0zcCNmj3 7dxB8vjqM/jV37REVMs77Yo3GYgCTyeq9vzr/f7nif8AMDySBDBKZDG4XGAExgsD3pdyhWt49rNv G6Rh90c8D8x+VNNPYkZIHhxui+boOP1psFsArzvz3AApitrciE6DzIm+UK2ArDls+lPKiKFwqFnf AXDAAde1AJJbH//Q8rEESx/OWEgOWBHygVXjIVwwOF3cH1r/AKAlJpWP+X80lcuMBspn7ueAahQl pjIp3eTkDY3fuKrn8gJkgmutoCCNydxDdvUGoHt3WSQHhlPzoFxt96XOwHwfaIMlX2nOVYj7uKlt 7lTNsuYpZUkBAeMhQh+po52B/9HzNo0idX2LlGyCwzUkkUboJHBDDpxX/QHzs/5fxYVnYymCNH+T hGHzMfQcfT9aheNXZZWXDqRuA+YoeOKOdgW2vJEjaEKVwpRnUfNzwR/P86zIwss4t2maHYc7mU4x 64HJ/CjnYW6GlcaMu1Lmwv4NT6rPHaxSrNbFR0cMo9+hI461WSMkglth7jGM0c7DlUdj/9LziNI4 2JJO3u3XFMkRcmXtnnuT71/0B87P+X1wTE2MDuiIBAJz1IFVkjJbzi27+7xgj61pF3VzJqzsaUqw rBayJPHI8wYmIffgYMRhh7gA/jVcIwcPJjYOXA4J+n60wEaaXdNNblkj6KhbL456mlhYSxIHU+YT yyHr9f8APegR/9PzkRh4nSeNo2B+633sDp/LNLHB5qbW27CcEuM4weD09u1f9AfM77n/AC7kIHly lUHA6Htnn/61PhR43Z3LyO7AKu4sOuOBmq50BZuLZZnjVwfMRvk5xtPTFROk6+dbyBUEcnQEEHHG Rjj1qk09gGxQggFgpCcjcM5+v5VYMXmwqhGEjffn0/zgUwP/1POQqq7uiK5VNqsf4fw700mVzkqM njKgKFr/AKCD/l3H26nz1e5+6p5PUgAf/Wqe5vEUAxiSNTLtgdl27iP5Hp+dAFef7Q8H7qVkmZwz nrvA55HfNGJdpM3LBeAOBQA6C4CQzRFWkZyNikAAY/z+tRyxgqFjjGRzhuF/OgD/1fM5UnV0IjjC oPmUg/P+tNt7t/NEUqiByWZS0m2PAGep7+g6ntzX/QQf8u5ci2OJGXdK0jhlfd8sYAOePfimLG7M xbAYH5RmgCxG0qgsIkIX5csgZTkHseKhMcyopgIVvM3MhHWgCfdPIxadlLP3CgYqBYZk3FSSOxxi pcktBp2dz//W82+0hCEnBX+EDZu3fhVYRhid0ZyW4PRcc1/0Dpp7H/Ly5XRoQRSldkYVl5wHyFH+ f6VVFvPlEfOQchRllGc9KZJdgh8rzJJAsqxL86O20EHjAPrzn8DVaCCyG3yMyMA32h2fIDZPA+gx QOzsSBI1cqgI2/MXUfKPrTN8rybi3X5QSetAj//X8/eOQskMcUjr1k2rkJ7t6dakaOJWZCAzbSFx gGv+gg/5dnsUIgDLJFMgZACVLDDA+g+lTKsRj2YO1WBUA4Xg0WsYDZTbuwa1lEpUbJY/LK+W+ASO evXqM0xEKkyOMk/KVbnGPSgadndFvessQd3+aE7EUg8jnOPp/WnIvlpJIq7iy4HJG0+uKDRT7n// 0PN0d7iKTeQsiHgBc7h35ps0ZRI1UfOSMkdR68V/0EH/AC7J3Vx438RnK55yDtJ6VZYgBIZG27/m Hocd8fj+tAyvHd2qo8bpJuDH97wsWO/GM/rSyxpI8TBpHVucxyFUxWU97ASmUKcJlBGMAe4FUSVm 8zYfmQ5c9galXT0E1of/0fPrZyYo95Zu+0cYrQWWTyjEoT5uQ7xhmX6f/Wr/AKB4u61P+W8gMcQm TYWz5Z3yEcZ7gVVuPLJRYwzSLKGUsfkQDOePywc//WY02tiYsj/vXVvPGcsOjZ65/wA96jjnZn2N 8gHPmOPlGO3HPb9aDSGwxwoufMnmV0fKRQ7CsynAw2c4weeB6VeQRoHkLCNk+6MYLD2NBZ//0vOr qGeWNZ7XT76+zKfNmtoDNBCFGfnI4Gf6VIgMuGKqHC5KgBQuPav+gg/5dyWJjIjYICrlT6gjtTFR Uz95W5yfU0EzdkQB5WJzCzRZCGUg7AfTPrjtV1rfMJMX3wuWxx05/pQYkEFtG8ZKB2CjMivyQ2ee /r60Mn73y/vYTdtDAjHv+HagadndH//T4OG2ESy5zhzkKT9zp/h+tQQ7AzqQVRXIHGAT7fnX/QLN aH/LstUSyRbnX5SoXk9ifSoTaqZg0afN93gc/hWQy9FZlU2xoSyncwPGAPeoWtmy0mGKs20n+EEU AQzoECiJ2DIQTtO3HbBqvbv9rvDbhcmFfMkMg2xjgnr60Gihof/U4by7eVCJ4meMHDxq3lk46c84 6UqSRTNuhsxCUPl7SSVkA6Hr/Wv9/ZtrY/5fuWPYidGlYRH5dpywqpLbbHLYIQDBx3qVJrdi5VfY lM0XkxpskxcJkK6/JIM9qupDIbeYPJG0RAeK32FWRh8pA49Ofz56Cr54h9khtohFBc29xbRqryR3 MUgw0+VB446A55HqBTkgiKktgKw3FSOTjtipc+wQ+FH/1fP7iWQxed5TxwxMIg3RScHH54NMhKMp lkO0KOew9K/38U3fU/5fyOQ77hUGfs5XJOzPX3poti8xUAKFXIdfut14pqavYCW5nSC1KyoNhkGS yZZSOAc9utQQRXKyGcxB41XEYBJ4I+9j265qroCeLDyLHMxWPdksOOD1/lVRSsdyyu6pGo3KxOd2 M0wP/9bzyS8gBjV22qxxvxx7ZqzNG0WxZYVTegeFtmwsrcg57596/wB/ZOLVrn/L+RRQkBPtE5ML SFlDD92uOo4/zzT7g/NHNAU8tHwUPzZA9Qe1Q0ujAgDotyt2yRoRKAoZAImJPAx09OKVt0csyNtM UjCTYFwNwJwR7c0r2jYCrdWsr/ZrlZm/dFswRn5XB45+lWzbOLcyyMgD/dReWUe/eqhJbCu7bH// 1/LssIo5NwljLGNwRhQBxx/ntUkSoAibV8pF2RqegHSv9/7ruf8AL5zPsMktUKmIZ3M4kIU/MSDk H8KclmWljTaoYDJ3nBIAqJtW0NLPsPlEnmhXAjUHH3QoNJNbZ3OgEm3gYHWsws+xAtsIYt6xSTtO 28xxjLxY9s47VPOqOI44oynQybhh0Pp60BZ9j//Q86hQmF1k3NtJQYbleOM/r+VMtrJYIZvPAIPE Kr8uwcdR+df773R/zCxVokcSGUgxlXVumOehouoC0ZjAwrLtkC8bqLruUMjH2do7eOzezt1jBHmH M0mf4qkuIwXIOADyuTgtSckgs3sSyafqEtnHIkDiyhc+ZIAfLGcD6Z6U37KSipGzJkhXbsPrS50P lfY//9HzbyDCJOGcheCvJ47/AKfrTp4gYleKImZ1wvBDN7Yr/fDbc/5iLPYbFaOfLdiBCeJMDc/t SSWzoS0YO0/L7Clddyowk3sN2SNEVKHchzu6hhxj+tV1Fz5uVRUUjCr3OOuP896LruaOm2OMVwHV RuG452A4LY9KSS3kknvL2KBljmnaTYn3UyemenHT8KOaNiPZy2SP/9LzB7WVGaCaN0YAMVdSpGRk fmMVDb6Q0lyXeZ1TbhImXC57nNf73c8T/mLVOTNd7JVRo/LCKgH7wDGSP/1VGkTAmNlCKeNx4FL2 kO4nTkuhFNZsA0M7MBtxAynhsHnn8+lRLZzjasaM4HAVRlsfT8DS9pAnllskTKjyRTJKdigeZE23 nco4XPvS2UZdGeUghl2g/wCfpUup2J5J9/wP/9PzOezEKZhyTu5PYUxInjIkCjBOWzghz7jvX+9P tH3P+Yfkqf0hIXIlGA2GHGB0pwiLySyNOWJPKNjjHvT9p5k2q9hIzbhWLHJJ/dFSCG9ajZA8iSGI OqPn8jR7TzHy1OxLIWSYzJsAJOQyghc/WpoUUBjI4Mj9Nx+Y/Sl7R9wip/aR/9TzO7ieK2dymFDA txjb6Ent1/Wnw6Y8kS3MYbyWULuzlMjrX+87murP+YyEXtYiktmiV2UjKn5jjgfWlJuLlkUoHkZQ qrFGEAAwBwB7UueJpZ9itJa3X2pbaeJkZTs27htP9Kt+WtwyxRMCLdvKnVcHb7fhmjnihpNPVFHU NMnW4VoJUMCJkhRguD6+4z2pLS3MKSCWL95IMwtnGBnk4/IUc8TRq8bI/9XyYWksyeUsRmZn3xKv 3ifQUhhl2xR9PKY7QD1z1Ff7zc8e5/zKQhJO7Q+GeO1Mo2RO/DOrgMy49fQVnXUlxcSLJ5ATOcCJ AnU9ABxRzxK1uLBFM8jQrHMjnA2lfnBPTj8eK0RCdq7w26MY3Hqx6GjniVZiopZd5LhTwGxgrWYt gzxXAgkknuI2LxCQgbsHkZ/KlzoqMJX2P//W8St4WVvNJm4Xa8KjG/1H9Kns7MpLJcP/AKhSHeKX 5kbB6AHjvX+8qnFn/M/aV7WNPULuIssttZJbhiXlS3hS3hBwBkKoGOB/KqbRC7gz5bvvTKOoyEOe Cf1p88S+SQ+GW8EZtnjjkdYwEKIIVyMjp/k1WsYJbq4CSRPC0jEMu3BB/l2/SjniLkkMutMuJNys sm1JAXBym3B4H6VeaNzk21tFDvCxtBHGWjLYH1OTjPrVqqkrEOm7n//X8hktxdNlIkXy2EMgjAAV vf8AnWM8KpdXMRlH+hy+XMFb923cEH0Nf70qvHd7H/NDGk1ojRitleGWQxM0zMDERlREvcY7596Y bK+aK4liJ/cxhvJ2kl8nGQMfnUuvB7FeymNe3ubZIbqWHcGXa4jTDMygZ4Hc017I3WoWLRxXEEsb h7uBVws6N0HTggD1NQ60L6msaU+W1iaa1S1uAWKRSzu4ijzhgF6/lmpmtbiNETynYTNvgl8r/Wkg ZAPfHH50vbQNY0Js/9DxuKw1Fi8kVvJ0OS67B6Hk9OtEGl3N1+7MkME7S7U8wF1k5+6AASTiv94/ bU+5/wA2lPDSvsW7nQbe2dUv2e0MkYeFpkKi4J6BOO+OKrmylnhT7NDORBKY1kEZMcijrgD0Oah4 iC+Fmv1WfYst4Tubq1/tCOUWsdqpN8ZUfy8OwCE4Bx+NZKacxiaCIIPKkEl1vbZjPRlGOeMHn0rP 6zTa5bnRDCzW63JNSsXsrr+zrV5ZGuIYZnaTCxjKgkgYBA571DHZTmS2jtfmnkk8u3lUZBf7o59j /WolWhayZaoyjKyR/9H9nv8AgkVpEllLA87/AGm8tCEln8sv50nmRbmDHqMyOM+1f0KfEW7Nn4J1 67iZUVdOkkk3naNuCdv49K/o36QMlU8WKjX8y/M/nb6OUHS8EcFf/n3f/wAlR/D7+2Xq8P8Awurx RalAJbuD7XBKOGRWm4/762t+A96/Iv8AaRhfTNBlEoeSOSz86KGOX5Y3lcgMPQ4X+df6B8K/u/Da g30o/of5vyl7Xx4qv/p+z8T/ABMlxLqV1PDFDCEkBIR97EbRkkjoe9cyLzBiU7n8xtiyKNy7hnIJ /DvX+S3GEnLiPGv/AKez/Nn+xfDsf+ErD3/kj+Rl6m91KYjIUWKJj5adF5xk++cCobCSadpIgi+W rAtjnOPevlZuyPcirXP/0v40rtozBIiFmLNjG3t6VWt7P/R2KqZBtzIn8RHpj+lcsnZGkEiL+zri 3jaSJFWMn5hL8rt14H0qxaXcUMYS4kjVmkKLu4yfSsTQfHqDWznyJnFtJJunjjOFkxnr9KTUZ4tS me7A+eOJU3MNpbaMD9AKDHmaldEdnG6q0m4btu5XHDiqUzMpM0fyYJGF+8xoKg+jP//T/irgeITt I24yqDsA6Enjmrbmbap2KCfmKg44rzZOyN27K4i3ZDNGAAqDK5bHPpWl58MqBt8av02g4FZxV2Y3 1uY+rmYRW48pdsshHngEMuO3piq1t9ngQtcAEbgd0YznHqac1Zm8W1qi897HKkYs5S6Llwirxn/I qlcymNEkuQ8z7vliXo3t7VAH/9T+LM3b3GZmhiWKSIL5YQAoR0x+QqJDNLbb5ELB/laKTkAcjA9q 8c6C5cr/AKOjiHHlgIYE6dgMVRt7Z9NuftFw5jTh12nLRd+P8KDaCsjWj1yK5ikDyOqliWLLgn3x WJqssVykRO6UqPLjIH3BnOP1Naw2M5fEyS182QAoGjWEDDdCce/rTHD3LbGQAA4D4w1WSf/V/i0R ltVjtQnmvJ+6jOMc9Rk9qy7iESl/mKsrFGCH5lI64/xrzzoFuLS4kCz58yZgBvJBc7RgVegsmuFS S5RtzR/uUTjLA85/Xigd2Uxp+JgJMl2yVJ747VYaydx+4YJjgqxxuqJRvsVzstwBbYLG0nzHhnAy V9cVcleBbJ4dDuN09uzzSzqhQxtncxQ/3vSsjU//1v4odPj3XrXt0xmMzF5JWOXkbuSfU96uXEcM i3D24liJOGTflCM15PK9ju5lquxVhhXEYLMqx4ODzT5Yp57iRyyAABjI5y7+v5VsZ88indz3EzRQ xRnEbFGKjG7HQmtbTYgsRY5Vhye4U+9ArskXbcSztKkEsITaPMzliP4vwNY01wLcx+dieNso8edp CngfSmk3sD1dz//X/iSsDLAXitZpfskzl54GYsFJzyK6KKNzFhSd/wB0Lnk9ua5Yrl3O9baluCM2 5854CHeBokbOFY+p+hqsbyaP5WAbecMF5JobtcpK7sTz3ZynmmRlVQq8FsDsB6VkzxtNIfOXyomI +RhnI9T9ev41iKUejNaSWLzVR5Ldhb2g2CMjawA6n3pilgqlwSsrhsLgYXsaqTvYKK3P/9D+Rn4a 2sF7r8VrDAGmQIfMlAOA8gXAPYnGOK/YT4U+HHXwlbyx+dZ2EcEemNBbEOInCj96qjpgHHHv7V/T n0b6SU8VW6r/ACP5Y+kLNyzvLqXS6/M/tE/4JYaLpuk/DjQ/sbC6SC0itxcEMz3QkiiG5m7spdsn 3Ne3f8FC9eh0D4VeIrgSSImlaPNLdhVLF1EckmQDwc42496/M8bev4xTi1q6y/M/pKvJQ8NISi/+ XG/pE/iF+KOvRwadqt5NqsMl+JWnJtJCLif7R+8jHH91CR7ALX4k/H/xFqMniK6+134t9LS3S7+y yyCR9QuH+8zN1OAxYZ/vEdRX9keLc3Q8Pq0Y6e4l+Gx/IfhLL23G8m/5pP8AFnyIW3STzkBYdxKk jBFR2QkjujPFM2SflcHBFf5y11+8Z/akvhSP/9H+IezN1DOjqyuVbJ80b1bPYg10dv8AbhiPLSIv zpH91VJrz6qvc2i/d1OkuIJVgWeTaruoKBDuaI+vtS2oSVSjgs8rBZGB2s5IxmvPmrXGmnsbLwtD aspUtbFfLKISJE98jmrywf2VB/aNwZ3tVhEgjMW/aBnOAOv/ANauKe5tBq1iaCOwv9QuCJJCFtUn gJgKIjk8+3GD+VdSbeeZIEW5MYK7XKEovFQS7c+p/9L+RC5tGaDZcyuWSRktfLOS44+9RossVlBL bu7OXl3F2yWQ88A18VNanZG3MaWo3MkMZlsW3SyKE+ZC4YcZ4/pWhoyXbW8l1epGlugDqW+V8DqS tQaGtp81il1a/wChLqGjXUplukjkxEQ2TyevXNSHUEg1eaHSkNpZ+Yw3K+REg52DPXp+lZzTFe17 jjaHVbw3qTTTgMcFn3HIPzMfy/Cut077VDeQmadIUVD5SO7BJMccDuevXipn8NvIwrNxasf/0/4w 72wkt5re6SSRRFPvcxfPOwOQenXqa3NU03TJrC3SO+neV4QkbCMZtZW5GFyc49TXjSSUmjOcr6GI NKu47myt7y4WS4lZUN1G6rCmABlz0HvUun6lqEX221ZUQGRraSe3bdBOiv8ALg554A+YdeaZD3LF tBp1rcXFtPdXckUMYuIgX/cmVzkZY9VHzcc9qhuJo7VVmAS4DSEFInUsv4Zpp2ESNax7oLuxmaye NfOZB0Jxn8KrG1vLtC32eKWKFxO9wzbZMnj5eOarn10C9z//1P40Le1b7PMJFiQ+ZvGMl4lGf5/4 Vk3HkWlqZrV7iS6uz/oyrGGiIHUM3rzxXl85z2H6NdXkDRpOZIo5TtkGd4UH6V19nepG1yiRW8sG zEiyR/eOT0bqOtbU3qZT3KMenC4urSSNFMS3fmx+WdydCCHPpz0p2r6bpFmGaxvTeXTu5mtlRsQO OcZPY5PT0rrg9LC5fduaOlQtP4egnvhLp7LOwjML/O5U4CbT7c/jXnni60llvDcR3VzeWqjaElhW N4OPmPHUHHU13YbcU4+6f//V/h2S/FlcxtknyiCrxnbIhH3cH2r7h/ZI8Xyz63/p95fNcXLyzy6h cQebZRmJwoRsc7irDHB5BPav1nwxrKjxlgm39q34M/OuP6PNwridNeX9Vc/dD9m/7U/xd+GviCW/ mkvptSttEe3kI8j7INzhQe2RFGBjH3vz/vu/Zi1T+1fhF4bkj3x/ZtNV0jz+7AcAIoJ5ONpBr9g+ k/FvCYSXa343PC+jJK+S5hD+9/wD8bv+Cy/hWe78KWuoW1z9kltrP+0LiRSfMV4rpGDPnjAAY89l r+acXqSTW9q1nG8l0iibUixRbfAzvZAD16HA4r9O+jjiI1OAo0FvGT/Hb8j+ZfH7DToeIFar0l+i SObvb6S9aSMRxPb26lLceX5bhgTvLHvmsSGco7iHTTawLIPNmkIQ3LgAHYvUjpkmv6Mpq2h+CVm3 I//W+GrLTBJbzTotwUVXurho0JUMFONx9OAOa4Bb9byO8uZI2lXmC1+yp5EiuhUNG7DuBnJHcj61 /sytz/IGV76nXQa7ejRzYxQ27rEPtMscs+cKFAwM45B+vSs2bVdO1OxQXOPt9tIshhVSDkcj2IGK 3OeTuyppeu2076lEkdzBfQgeVNJA8cZ2nGQ3TIyCOauWsUEqeTJJctc3OWkupmDvKcZLMvrwa2h8 KOZ76mMbS7sk1TUDqUkBhi/dNJmRbr5lBRV55xzj271Pd6hqGoRaV5EPyeTuJEflzvnJ38DJ6dD0 wao52mnZn//X/P2TbLp1lJFPEt1NdlLmQDcUjQplSOzfe59G9qSb/RM3C3FxKi/MUcb2/Dv/APrr /a+OyP8AGKe5n3NlpEd3Dew30lz9ujWW7jkjMQt2wBtBPUVu3E1tZ6bcRR3Nnp8E93CrXwie4uBG OWQEAhd3TIGeevamc1rysc3G0mpTW9u5SNUb/WclmGeuPpj8q68yRaVJLoyi3uLdwJbW9JKPK57M nbgHuaqK95ESVk0c5FZzXF7P9r3xFY2dvLwoRgOpJ7f/AFqsC51SVIo7JFfytsMZ8objk/qT75rY wP/Q/P8AhhiuIrhNRuPKuoBvEfAlbn06HuKyWhkt7yztPOWC1v5xtLoUV3IwrOR2AB65r/bg/wAS Huzo7lba2jIdoUmtpdizQH5ZBnDMPyzSalNM66Vp1vDLdabPbTXUl3aREIkkbRtEZe4Jy3XstAmr qzK+lvGscsUqA28t0txdIDt84Iu0Dd24J/OpEsJ3a6niu02W8SPZKkLPHvJU+WQe6gtnt8p9c1tF JbAVb97hnkjuEysq7bmXZ5cbtxzgVDp4iSTYM7VQrsH/AC0Axxj8qoTV1Y//0fheH7FPZSxwGb7U AcxtLxuBJUKp6A9/rVa40bVBHJJLbC2gKo9x5LEsSm0/MPXpnFf7gH+I9klYWe+t5Qi2UmXlbY5V fmz0OT+fSmGC4nJguVZIoJ8ee8f38AHKtjkfTitKfY5wl025vZGfTbgGO1iCqqr8hlBztbv0x06Z rR1fUrmWzgsyRBFsCXBSJQ+U4A3Yzxj8a0Jl8LHaUNMtifOvEjcMgRpEO6cscemBg+uOtaz6Xpmn Sya1cxSSxF90mxTtJAx8qgdec4HrQYn/0vhmLUkhja4uLG4htLm5P2GW4Qh4o8EncvYHIODzjHrS 23mXryCO8mhsYj5yiM7YJW7E/h/Sv9yofEj/AAzm9bD44fNuXeBzthXEh3b93v8AzptxZfaIZbtm XfCPkyME49K2MzKt5ftDxPcyyB4QY44VYlZM9fyC1ft4be7u5bI7rcmJrhHY/INpxgt68jAoMqjL czNYxT2S/ZblJ4PLllWNt0XT7uQMHgcjNYEFvqVn9kndWhhubnbE54EgB5A9c9PxoOVu7uf/0/h3 VrC4nuFmnCxwGP7Oi2+2JZcADdgc5OM59zT2uruZbe2nkT7NZ2y2dqjRqogRRhQMDsMdc1/unDSR /g45paFW3tDJcANcRrEj+YzSHMThcnGPfHStG1ghmlFrDqdtYeZJuS2YuXcDk4UKQenetRSn0RUv Hmt5EjWxmkt0idLqdIi0CsGG057Zzin2clvdXMNnBHLF8nn3E6r90Aj5fTB75oM27as0tVNzLc4h iiks4rbyibbCNIR0YgDqKxLFJiVmtJlhaNWEkdwo+YNxnkdQM/maDKUr6H//1Ph/VtNFhDa3CspM 8Zfyk5wfX8etV4oLhrN45JWlScKVSM4KbiMjI5r/AHYP8DuhK0BtnjQAuIwML1DY7GmwqDOsr+YU Uhgsb7CpBzk/l0oOad2mdHMLe6uLm9011T7U4UQxJtWJUAABHqCDnr+lY9+LS7lE08vm3loRGibQ UC89umc4oMR1pYfb5pTE0MUzREhp2EaLsXPHv7CvRfBgmtwbXhpIdrSuJd8bbgA2M89f5VclomQ7 tO5//9XT+EWqy6Z468GeUsn+keJ7WPzoshYWZmjCk/7RkHHtX9r/AOzXNDN8NdEaFsxpAkQJJJc7 AxYj8cfhX9/fS8h/smDmfwr9CCp/wj5nRb2kn+CPj7/gp1a2z/CDULhvmmsbK4uA5TaYyIs43eg2 r+Zr+Q6ZLoWyfbIoWvpohL9oik3wXBIyTn1HFfX/AESKjfB2JjfaUfyZ+B/TWw0afG+Hq21lCV/k 0hlrqMVqEiuJQZlUg4wQoznaPTn+dZtzfve6gfOkWKKQCMEL/q1A4z6+v41/X0W9T+GZqK0RhPAy 3DxxP50atndGSEOKtywxRGBo51kkkXMkZByhzjH9aqDutTCa0uf/1vK5oxbRWl1uMsskRYw4w8Xz MmD9dufxqFUuJ5o45F8sO4IbbnYP734V/vgf80kiZnRLdmtpN6CTaS67fMAJGRVLdcxK8pgV4DhP Nb+DP9eKDI0nNxFFBbvHthlbzRuTBYEf3vpiqs7QAJJDCitASg4yffBPrQYuLRJM0hESiMh5Iwyj GN3X/P4VV8+cAREsq5IKgY3Z9fyq5pJ6HNqmf//X8fkSSRlt0bc3TaDjk9M1HaPlXjkKblkKMF56 Gv8AfSC1uf8AMeW7gxJIzSRvHbiMtmMbvLxT4RDIqF2KK2GSVshQPetAHT3NgHheFomUEDdErEhh xzn1/rRIGumZ1VnO7rjnJ9aCoycSEJLm5hWB3miB3hBlhjGT/n1plvYXBtFn8whvMI2Nktx69qCp 9Gf/0PKJAGYYAWRRg56mraMqwujJiZiCrg7duM54/Kv9+D/mPMycXQOxS/zggyL+opsEEp+UHbgF mB4yACaqysgLlqXRZYfkIdg6KfvfKDwD+NXoYGeOfzArRM6yJ5AKXERTk5brjPUdKcZLRWIna2pV MgEkskpYqzbgoGGGBiksr5I3Yi1V3kLIPOjEqHIwG2kEZ9z7Vpd32Mj/0fMWkhtw9uyM1xJztwQs Yzyc+vbFTRyzQI/lSMI2j2SxKMhx7iv9+Xuz/mHEuIpLm1AsI289Vz5R+VWH5cY9KSWEWRtYpTGZ JYVkbymLqrEAlckDkdOnahOyaFdbEbSxu5EbEGAZkG3kZ71pGC5lWYJFcXKxW32oyxxbl2fh3Hp7 9aQzPuotqLhGMi8PGRtZfwNOijmYqQv7i3UzTgELIyKPmAz14zxQJNM//9LzkXKXSMISRaM5liHQ 7T0z74xmog0CMYhlgeTvTHt9K/34P+YZ3toSRIjMyABEC5LdlFTRQLvA34IP3+g61cWluYslv9qw edGxnCgIfL+bGTtx+dRyRSWsSQGOQyMwZu+1WGefzq+eIinPbWzXjrLI0hRDGhhbb5bEAgsCOnTj j2Pq6SF44ogjhxt2hs5PHr/9f1p80e4H/9Py9VAXZI+7HXPWnxrEm9RskVjtVjz36iv+gA/5f35E y7IIwrLhZGwG28fnSxCCN3ihG0u3mMCep9aAGv8AaDl921gxKFOMVLbkCUNKGLPGRIzHO44IBx7c flQA2Ufw9VHb1pbe3uJgxihcwxjfK6qSiDnkntQB/9Tz1rZlI85HMch+Xj09/wAKSd/lXAAVBj0r /oAP+X8tWTPADICfNAJHHyj0qoZpZRIPJWIs+M4B3YPY44zQOzSGxLIJERtoLcDcce3NWiohSeSa NS0MZCvGolD9uCP88UCKFstysjrCfLMvzT5OxSADyf0q6kLPCzSgb+V+XkigEf/V81idJXMUe4pE 3l7iCOR1H1/xq5HHKrq+wSrA4cqybkbBzg+xr/oAP+X8gkkDzRSrHICZ8TQou1HB/hXjgYqWeHcW 2o0UbN90N8w/GtotW1MZRd9COS1jjXz45FVC4VYWOZD79MVa8gyqyKUjATJaQkZIHQEU+aK0uPkk QWFnIy52iRnLJ5W8Z4B5/wA+lPSCaJVFvAu4n5gf4D6Youu5Nn2P/9bhHF3cBSqqM/LLvyxBHGM/ nTZbaeKNYzPHv+/tRCCuccHNf9AF1e1z/l4s+xMtvP8AJ/osoDjIkZcK30/z3qBo3lm8uNGJT7wA 4XnFK67lezn2LzadcQOvnq6SYDBG44Pc1n3cTCUgnaSMgjq1XGcY7kOE7qxLBZlvL8svIpX5h6Hu fp/SodrsTBC2URtrIpztxVe0iPlfY//X4FbRo5JCd2du1cnANW49OXEj2zyTgn94W+ZY3AAYL7Ag 1/0Dc8T/AJeeWXYrS20zAxOrAfdDLkcfWiSOZoEtHRpFR8wlQSEORk/y/Kk5pLQVn2GIkgnFuYpM gfMxXCr9alkQFztXeYuHQc+9Sqseo1CT0GeSVIPln5hyMfMlWPscixhuT+pqvaQ7lezn2P/Q4d4L ghQFLNjCgj7o7k/nVu10R9RjMbW08qBiMpFht4GeGwfav+gT2sD/AJe/ZSKWmafPJNJYQYFzEoMk bAkrngAgc+v5VbutNuLWaKDyZftE5KopQ5kYdVX16jj3o9rAPZT7CwaVftDLcTwzxRWzDzvMieE9 vUY75OfWlt4JbuSWK1heeWBA5SFd7c8DgevvUSrRWiZXsKn9XKt1ZX1qf9JgmtgRuAnjMZA59am8 qdI4SIpAkgykpXEbjrkHpjpz71l7SA/q8z//0eEu2tl6ywl4Rhtrg81RRZJwzqVZVGVER3YHv/nv X+/qrRjqf8v/ANXnsjV01Jrh4ordDPO6klIf3rEr1AAyauFJHcKI3ScgqAVIKY+8CO3/AOuq+sw7 of1Wq3ZJ/cZLo5lvITvuGtceeYo2IhBGQWPQUkdjcRxxyxIv2aQF2csE49eevcUniaa6or6pW5bc orLE5LKzIFYROfLZY1b0LEYp66VcTPGJNsKLKAjZyZFPdRxnjNL63S/mQLBV3oos/9LhLlLewvbq OO83QLumjkmdVcxqcZIB69Pzp8c0C7J7i4gRbhPMiLyBGYHocE5r/fmWOow1lNL7j/mGjluKlpGD fomX1dYC8bW6H7Qo2zvZfazj+8hwcDnqKpSRRQRSxzXFtBnBjuJ2ISQEZyuBk/h6Vm82wK0dWP3r /Mv+wc0escPO3+F/5FW1a3hyiXdreu5zutssnfHHUfjVWeeMXcdq0kaSO+HjLH5QQTn+X51LznLl /wAv4f8AgS/zKXD2bv8A5hqn/gMv8jXkshZ7UupYU3Dcq4YNjGckkD2p1lbTXt4lvp3k3f7wK9u8 mxnGOdvc9O2ah55li1deH/gS/wAyv9Ws7/6Ban/gEv8AI//T4tLNbKdo2iuYWcFdk8LPIGJII+76 5q9JpTyxwXEEV1KZGa3aODT7icpIvZmCbeQc9a/3uef5Ul/vEP8AwKP+Z/zJw4Zz1+79Tqf+AS/y IptMuIo1lurK+haI7C0llNEhJ+q47dastotzcssCRStPHH5ij7FOwGVycMEx9ee1Y/6w5QlriYf+ Bx/zL/1Xz9uywdT/AMAl/kR/8I3NcQQwWcc1zPJK7XL29hczxWsaj77sI+AOQR9OvaxH4burc2du RNfXF0zbBZ2NwEhC8YcNGME9RzUS4iya/wDvVP8A8Dj/AJlf6qcRf9AdX/wCX+RI/hzUS8SnStQa SQEKsGnzSlz6cL1qC00XU5XEceg62gkma3Ly6RPHGrqM7WJXArGXFGRxTbxVP/wOP+ZcOEOJZuyw VX/wCX+R/9TlrfS724khgisL43Us5gNstnI0kO0kEvheBxWvD4O164mlSKwvWkjkMJgW1cyEqM5w Rx3/ACr/AHWlxlkEN8TD7z/mjXAPFFTWGDn9w6XwvrrmGK20HWrjc5jaSLTnZEYdQT0GPy96t/8A CvfFZeNJvDWtWskilk83T3+fuMYz1xxUPjjh2Ojxcfx/yN4eHHFs9sFP7h8HgLxm32xR4R8QzC1A LCPSZZHGTxwBnJ9Kb/wrL4hSGUjwbrAKxi4ghn02eJphkfJjYcMOvOB75rJ8e8Mr/mLj+J0R8M+M 0tMDP8P8y/J8MvGMhiaTQNVhuJcGYXOk3HlWPTklUO4f7tVJfh54y+1CxPh3Vbr5C0kttYTBOO/z KpwevPPtUf8AEQeF1/zFx/H/ACNo+GHGb3wUvw/zP//V0o/hh8TbWGb7F4Q8TCzKA+atgyidOCSq 59uKqx/Cvx08oa18K+I5ZJuqS6VJCsIAOdzHj16Eiv8Acr/iInCsY/73H8f8j/m7XhZxs3/uUv8A yX/5I10+CXxOOmxTQ/DvxdcCWcGWVdJuBFbgt1L+XsI5zw3TFSn4D/FmUXUUfgDxQJLVRKj/ANnM Ybpf7qN1z25H5Vzy8SuEoK/1uL9Ezpp+EfHFR8v1KS9bfo2Uo/gr8XBFJIvw18auiOFmij0aeWNS Op3KpUEZ7kV1Uf7Pvxg+wx3T/DPxbHHMB5Z/sxpCy9ATtyB9M5rCXinwqt6/5f5nZT8FeN57YX8/ 8gg/Z5+Ll754tfht42sI41Aa41Tw/cWsTMc8Kdpzz/PrU9t+y98ZyrOfh54qaSGLzLiP+xZw8vOA Y3VWB7deeayl4r8KR/5fP8P/AJI64+BfHE3ZYdfj/wDIn//W9RX9l343ExPF8OPFUzSRkuP7Luo1 QdQNpiHzfSkT9l741b7SIfCjxzJ9ouMywzaZLCsOw7txbY2enTjrX+10/F3hRf8AL1/h/mf888PA TjqT0oL/AMm/+RND/hmH40XNxKB8NPF1kqBpXlvdGu5ElUYVUiEcB+bqSWIFbVp+yX8XZYiZ/h54 rSTyTJBIbCaNJG5wCvllh6YzWEvF7hNa+1f/AJL/APJHVH6P/HNrugv/ACb/AOQHW/7KnxzEjQH4 b+K3ea3+UWeg3Nzhs8clBkewIqe1/ZD+OglCv8J/Gs9siCQo1hJazM4bByNhwp9M5+tYy8YuFE7e 1f8A5L/8kb0/o+8dPajH/wAm/wDkBuq/sgfHiW+S3sPhN4vMUEBmv5I9HnkhQt9xA3lDkc5PIqt/ wxl+0bBaW5j+E/iGW6uJyJIY7GQTQx/wsfl5/A1g/GThL/n6/wAP/kjsp/R347f/AC6j/wCTf/IH /9f6Psf2Kv2g3sTK3wn8WPPfSfZv3dk0K24B+8QUJJwD0I698VqWP7DP7QCIZD8MPEkcdqWc/aoG QyqvAXAQnJ5+YkCv9lH40cJr/l4/vX+Z/gavo58c/wAi+6X/AMic1f8A7EH7SrpE+j/C/XjM16wn Nypm3oeVWMbV5HTv1rpbX9g79pVvnv8A4Xa7AJYB5AeBiIZOuXG05Htx0rKfjZwpFPlm381/mVD6 OPG8mlKCt6Sf6IrSfsFftMXKNIfhvrkbx/u7ZTpk08U5QclWjBwD1Axn+dT6d+wn+09cwMsvwu1Z mgmMSR21nKssvTLMSvGPQ81zPxx4ZXX/AMmRu/o18Y20j/5KybUP2Bv2ljAZNP8AhV4nS8t2CyWu p2htxNnglJMAfmKv2H7AH7TkxtjffCfW40jdnki43qD0LFUO8Z6DispeOnDK6/8AkyLh9GnjJrSP /krP/9D6zv8A/gn/APtQyzosPwl1i3sFbdc+bOu64UcBo1xlfo2cZ6dqkh/4J0/tPTXBhT4fzmMR 73iMMrugPQH5efcgYr/Xv/iPPDS0v/5Mv8j/AAej9GXjCStZ/wDgL/zNSL/gnX+1DLNGL34ZQxWZ JjR0knhk2jOGPzH26LVe+/4Jw/tTrJNDYfDueXG2SL7NIZ02nGVJYId34f41m/Hzhtf/ALS/yNYf Rf4vl0f/AIA/8y9N/wAE3P2nri0eyi8ByWV1JtkjuLqAz7iOCmAwwM9zU0X/AATO/azjuIp4PCVo kcNv5N3G83mGYEc+WBwDwRyce9RL6QXDaWy/8CX+RtT+izxi3ZX/APAH/wDJGdD/AMEy/wBqOW6k tJPBcBSX/j2lubsRhWP3g2zrj/ZzWraf8Evf2oGtbmO78FaeyY2W6GN2kdgf4STuAz64681m/pC8 NLov/Al/kbf8SscZdE//AAB//JH/0ftzSP8Agl/+0yuYNQ8B2lqvm7Gb7WyxuB0MbDdg9OoIqVP+ CXf7U4i23OgafMySs3lxXLNhc4RFyo7DsT1r/Wt/SI4a7L/wNf8AyJ/hnH6KnGcu/wD4A/8A5IWx /wCCWX7WLTec3hvQvsJYymJr8yzRjH3GHYg//qrSl/4Ja/tPSGCKDw1pgdz++V/OaNAe+7AH061m /pFcNrdL/wAD/wCAaR+ibxhJ63/8Af8A8kWLX/glb+07DLi88O6deCO487YS0ECIuCuDznoMZOa0 7z/glX+0bfXyzDQ7S1It8JBHdAx5x8pbcqr17Z7dRWEvpG8PXukrf4v+AdS+iZxc1Ztv/tz/AIP6 lCz/AOCT37VyuDeaZ4bEXzbrYTyxyLz8pDqrA+4rT/4dO/tOzJCf7H8PJJhhNJNqMrWhU4xhAoYE YPXrmsJfSNyTmvDlt5v/AIY6qX0SOKeVKfNf0t/n+Z//0v0Qm/4JUftZKqQ6TY+FZYBiB02DcnqV Ljcfriqrf8Ekf2q0hmMmk+H1ZYtqSyzHc0pPUbWyAv0OT2r/AFVf0kMmX8v3v/M/xUj9EXiN6NT+ 5f5Go3/BKD9puFBBbab4b+SBVa7mk8ycPgbn+6DgkcDBxxWjN/wSL/aPvTbzL/YkEbDZNm6a3LkL /CfL4571lL6SWVL+T73/AJm8foiZ8t1U/D/IyJv+CQ/7Uhufs8k3hZYZFG7YzzyhSf4X2jaeOuPX muhuv+CRf7Rg3i2j0e3SNERVLCZZCODkhe/qDWT+knlS25Px/wAy4/RDz6Ts1P8AD/IxYf8AgkX+ 048h+0LoibZCY4re9+ynrxlzCxbitiP/AIJEftMzYupYvDM5MgW4DTNF5KqABtACjOAOx5rnf0lc rv8AZ/H/ADOmP0Pc8a+3+H/yJ//T/TT/AIdF/tCbJI9umJ5tx5rXCyEbeANg+Q5HHtWlN/wSE/aI +2W84fQHs0jHno26MyHGPlAUL6cfWv8AUH/iZXLf7n4/5n+Na+h5ndtFU/D/AORHad/wSA/aJRrh VufC8SOzLGslsbuW3HUYzHgZ6cmsyD/gjd+0s8hF3r3hyCMOWfdavLIyk8AYIGfrjHpUv6SuW9o/ j/8AJFR+h1njf2/w/wDkTff/AIJB/HuNI7CW58OIFhZGvlt/NurjdyBuMZIA44DA8VXk/wCCQf7R Vk1pHFfeCpwyiKSQxvczx5JO7Y67emBgKenWueX0l8uWlo/j/md8fobZxKN25/8Akv8A8iEv/BG3 4/zl7WLWbAWyvmUSTmAuWBztIjPA44rStv8Agjn8e47GOG41DQ96jy57a3uJMToDw7Slch/93ip/ 4mXwG6UP/Jv8yv8AiTrNdn7T/wAl/wDkT//U/X//AIc/fGpoFEOqaFYzhBGoisIr1lULw37yLbu4 5Nc7bf8ABHn462qo76pZahKjNGhns44Ao5AbYi4+pPNf6Z/8TMYBdIfj/wDJH+P/APxJvmje9T74 /wDyBcj/AOCP3x8uF8y78SeHLYpHsS0j0wRpKAwbLgxHHTHB9ex5VP8AgjR8Yby3mhuPEuliTzPN MKI8TqpOcZEfT0Gah/SZwXSMfuf+Zqvob5mlrKp+H/yBEP8AgjT8bUWAReIdI3+YyhZoJAoXnBfE Zzjjv+FTx/8ABHD45JKouta8Lt9nAKXos3ZST3VCh55weFHH55/8TNYNaWh9z/8Akhv6HGZtqzqf ev8A5A6BP+CP3xb+yw202r+H7i7kmM0+oPp+1CuBhV2xKVPHOcgkmoLb/gjz8bULLB4g8OWxWfcj f2chiKZyNyGMqT+HNZ/8TNYVX0j+P/yQ39DfM9Fep+H/AMif/9X9jZP+COXxluZd19400B1tyJI0 GlFJrgkYxuEWMdBtJ7VBH/wRl+K8LrLNr+kX0qTiWJVZ4LdV/usoUZ/lX+klX6TNBq0VBeib/wDb mf5G0PobY6DvUc35XX/yI23/AOCOfxmHmR3GuaJtuboscKZo7WMnoCY92cemaRf+CL3xUuL64kuv GlnGsi+ViGyCWyrjClUMb88cngn2rmf0lqb6r7jsX0OMS/sy+9/5Gy3/AARr8e2k9isfiCz1K2t4 Ajrc2Z27gMEgCMADvghvr3qQf8EbviKsMU9r4isIJkdz5NzB55JPAO7yyQB6VEvpKR7r7kaw+htW 6xl97/yIG/4I0+PRbCGTV7O5Y5ncmSWMLIeuwgZA/wBkDFZ9h/wRo+IUX2ZpdegK2shlmsDGxE+S SuXCA49ieayf0k/7y+5G8PobTvrGX3s//9b9k2/4IzfE2ZEli8SaZaxI7S/YhbKsz7m5UsQRgDoD TLv/AIIvfECe7Mw8WRW5g2mIQWgKSHj5XBUqQO+ABX+iS+kmv5l9yP8AKj/iTeW3LL72D/8ABFn4 gShGuvFNg9ys2+N4UliGOuGCoF/nVi//AOCLXja5gUWfiCws7mWTzHmaMyBD0OR5YODzxnv0pP6S VlpJfcif+JNZc1+V29WMt/8AgjH8QoJVjk8S6OtsigGUaUhkkPfBERIB64wKp3H/AARi+IN1cQxp 4qs7S1in3KkNlLDJLk8ln25x7YwKzf0k5XXvL7kU/ocpfYf3ssXH/BFXxr9oluH8W/ao5sRLawxG JIgvGc7R19a27H/gjV40tI4lfxRCbdZG/dJpyS3iA9P3jA5/EVL+kpU6SX3IqP0PIJawl/4FI//X /bJf+COXjVYbl4fFEfl3kTL5GoaXDO64J4cBBwew4oh/4I0+Ozbpu8X6dHD/AKt7OLTBBGExngDP zE/xAZr/AEGf0lKqd+b8Ef5XL6HkGrezf3sjk/4Iq+MJ4Xtp/GmmyxXDbt6Wb288IByqMwAzjpu6 mrV3/wAEXvFAs3hi8Yxo6AENb2caytxgqGWLd+tQ/pJ1+jX/AICv8jaH0PKO0ov/AMCkYU3/AARP 1+Se1YeLdUuBbMJIZbiRlkRj97dwFIHYGr9x/wAEZPF0z3M0fimO1a5CW84WwUiVFGN2E289Pm68 Uv8AiZSvtdf+Ao1X0OqN/gl/4FL/ADHW/wDwRS1u3WLZ4xubgyOUcywDEI7gLJuB9s1dk/4ItawV hMPiyF5lLIN1sqmMHjGNuPwGBwKl/SUxN7XX/gK/yL/4k5oW2f8A4FL/ADP/0P2wtv8Agip4p02c zReMjdJHGRsYxpG+7qB6Yoj/AOCJniG3Ec8Xj/7OqyF/JjthfOM8gFm2nr3Ff39/xMriej/8lX+R /mBH6HOG2cX/AOBS/wAy2n/BFK8urt7uTxFAL25bfd3V5alo7jaMKNisAo49yfXrTpP+CKF3JayJ qPiGBp5Dtik0iFrVrZc5+X5jz7VD+kti19rT/Cv8jVfQ3wr05P8AyaX+ZSsP+CKeswXVxcv46vJ0 MYgSJ7aASgL0ILhgCPUc89avxf8ABERzN5kvjC5MMpNxIHmaaVHIwUGCAASc8elL/iZnGX0l/wCS r/IqP0N8KnrHT/FL/Me3/BEW8uYPsl18QLyO2t7pZ08mFY5ZlAIC71YtgZ4BzVqz/wCCLN3Y20KQ eNZp/IvWuIhdacjTkHsxBBYfVqzf0l8bun/5Kv8AI2j9DfBLeP8A5NL/ADP/0f22tP8Agiffq19c ap4zvTcXF29wtxaJHAkauwwgVi4AA45HTvnmprz/AIIgXs/lwD4h3rWQPnTxI0MplbOVUFVUqOx5 Nf3m/pMZgvhl/wCSx/yP80f+JOcAnaUP/Jpf5k6f8EVr/fbS3Xi+fcQYHS2hgRSoGAXDbskD0FWp f+CKF3cR/Zo/H9/ZWkaHJtraBLqQ9lLY2gfQcVn/AMTNZg+v/kq/yNl9DjLv5P8AyaX+ZFYf8ET7 aAeU/jHWdQmVGSWS9eFJ4g44aN1UZx2zzUtr/wAERls/LMXxA1RNzEyvJGk8xH+27Nj8VGazf0ms y6P/AMlj/kaf8Sb5Z/J/5NL/ADNWH/gihpEGwTeMtT1OW5Y75biRAIRnkAgHp2qA/wDBE+0gmlut J8capZmVDDM+oyJPE4HcRKw59G7c+tZv6TGaXvzP7l/kax+htleyivvf+Z//0v3Vg/4IpWWTBeeO DFHegtdz2TCKXePuvtz1yBzzQn/BEHSTpl5p9/421O9WaYSpLsghuvlOQRMF3noODxX9xv6S2atN cz+5H+c0Pob5ZHaMfvf+ZYi/4IieHmWJY/HuuojPuuUVozt2gADJOSOBxnrT/wDhyfo1rO0lv42u 7gEbN9wAXQDP3VL4/PpWb+klmj05pHRD6HuVxesYlKD/AIIk6Y0wjuPiVqreYSWXZAA2TkBDglSP UEVcb/gifpiM0Vz451mTZ+8F0JoneXb91CpG0r0yOCaxf0js0f25fidC+iFli05Y/caFn/wRe8Hv HHDL4puJ5oFIinntLffAGzlVO3gHjuelR3f/AARa8O3xafV/FV8HS3+y2EFhfLb20W37rYGMHHYD FS/pG5t0nIpfRFytP4I2P//T/ejTP+CLfhqyLQQ+LtX+zzQeVNLJcQ3LRjuF8xWwc9120kf/AARL 8MQ3r3LeP/EluZVaNFDx3EK7upUFwF/ACv7Sl9IzOEvjl97P4Ah9EnKk9acfuRPaf8EVtAjE9pde Mby9tZZF/wBKLQyXKBOFKrLvVSO+0VN/w5Z8MW1olsPHGvSIJfmle7iEpGSdp/hUc9FUVkvpFZz/ ADS+9/5mkvom5PtyR+5F3/hyl4LuLWQP4uv5IptvnwTXMZaXYcqVwuAQee1SQf8ABGLwFYpAY/E1 79thfE89ybYmZCeBiRW3HHGazl9IzOkmueX3v/M3pfRKyZNNwj9y/wAi7ef8EXfh7eMZ/wDhM7yx mnhEci2EdrCrbPu5HlkA+pH5Vnzf8EUPhreRG21DxfqM/lKDao96qw57j5UUZ65yCPY0o/SOzqMX FSk/69TaX0R8jnNSkoqzvt/kv+Af/9T+vL9l/wDYt0D9m5LWx0DUmurS2QAvI4ll+9v2lsDGSB2A r6b+NFzb2Xw48STXEsJii0uaWRDMoyFids9exwfwr9L4nz3E8WcVwzivdylNb3vv/wAE/POFOHqH B3BH9gUUlGlTaVttFb9NfM/hp/aga6v/AI06zfyhXtzPJZwjGSyxBM/hlu/vX5X/ALYOt/ZfCdxe F0vb3QmFrbaNDi2mlSIk7pH/AIgPMfA5+9X+pOVx9h4bU2ltQT/8lP8AI7IJfW/HWfniJL7pM/Dq 2aa2uL27Zpv9MbzpIAfMijJ54/OmNqdvBD5bLsiL7SoXLKWOMgD61/kXxPLnzzFS71Jfmz/Z/JYc mWUY/wB2P5BJpu5PMZ5Z7ZnVVVl3BNxxnjt3/Co4kGnXskdvIRFMBHI2SRtB64+v4183U6HqJ3P/ 1f43GmSViuxFCMQW9BzzUdtcKLhI4njdC3LFvukVyT2Au6tK2+MBlKn723kfnXLXltkn5gYn68Zx nuPesiuZpWHW9tIv+jIIzCF3NMR8x/D1qa4gKRFYyflGcDjdQSNhvXK+U1uI9ibQVORJj1Hao5Sm AVUqrD5sjgeuKAP/1v4oIignwrt5JflSPmH+FbdwtubdGSR2Qx7ZC4Ktk56fpXmTTsU5Nqxz5t28 1YkZip6E/pzXQWenoIpt0wDxoZArg4f/AGRShFp3ZJkT3E7stq8ks0SSGTy8YEPtUE4mFx5MCxyW hRWJYEMG/iX6UpqzudCVtC5aJFFOGVfKZeipwB7CrLsVkEhOPmyARnNQB//X/izBSV90haOMEs4A zu44wO3NQpclUJYlEX58YyFANeOdMVd2Ln2oXCKyjYAAQn8X41Qud1wyIGMnykupHCY9KDcyrezv nlJj8vYx2eTnlfTmrbsbULbyFTKrYb656Ct1a2gpJNCyXU2DEXMYXDBYx0GOT9elW7O7tZ9yMWBU 4Eh4LD1PpTM5RSWh/9D+K+KaF5GgimVtjnc74Bf0x7fWobmMQyTiMlsLu9gfavPOgsWEfnqsauTI 3JkjOdue1PSG7sYmltnLbZSkbk7tpB6mgDNlu7po7eFXEsqzGeRtvTjkDHbitKKZmEchjV9p+Zc4 z6/596AMHVi7Xck1urJCwARN5Z4j3Ga3NM32VmUjdw065lDDADH0rGXxMd3ax//R/iraSNFaNxhi ckJxuPrTIJkaT7O6FV6ZU4d/Y1550Go8NqYW8lmhiZgNrfM4Pck1gagyNKkcMnyRgCXkrkDpzQAq 3YlgYAESREeSFOPMPQVcs/tCJPOEe3d1Blifg8Yzhe/4UAQ6gQ+XR/s8bkFwBg/5NUVs4Lm5fyw8 hkUBiD8oI7n9KuMlFWNIRtqz/9L+LixtmK+fZwZWOXy7hnXy8BcjIHUj/Gm3Li0FzKI285l2r82E Bz1/nXJzo9KMbmGl080j+a80ayQ+XJsckL7r6dauW2yFAqMZcr8pcZ59zUSd2OC1Na3CBW8yQMVX lD1zVC+hk2eYj8DjZ+OBUjmktR8NskdxwkhkiiDOzxny39s9PwrblkSWBJXt1idVCt5bFixHoP8A 61AqKsrM/9P+Sb4OaY1/4stprMNKgiiSRHbymZjMgViD/d+b35r9lfAei6zFpnh+OBJ7d9baKO2i iIkWfy7nyyCB0P7tvwPvX9WfRwglgcZVa2f6H8peP8XV4qwNKL6L8z+3f/gnFov9kfDHw9ALeX7P Do8dv55iJ3XBVCTuHGcMM/SuV/4KheKItC+DniuZpI7j7LpNxHdQsoZpysLsoO4Y4ycD1FfkWBti PGOU1qnXv/5Mf0pnX+y+GUYdVQ/9tP4fvFkFtLCmp60iNbQ20VzdQ2DBFn8yGNFPuR8q9x156V+L v7QMMsfjGYiD7fpgd5hc3MgW7WViuCUGeByPbNf1/wCN1T2fAdRLf3fuP5E8DY+04tnN+f6/qfM1 3PKglh35iz5hyMY9vpWtoUPnCQeaPljWQK3GRkA49+a/zvru9R2P7Vvc/9T+J3S7WGSeQlj5ajJQ nkn2/Kujtb1Ellh2YaHbkkcMDnGD+FedVlZ2H0saM2p2e6SPY/mJEN4ZchiRnirGgyQ3d3L9qtCl uihoZ45AZHb0KdABgHNcM+pVPc6aRliuPLkt5VCkZUodjY7fpWnf39td28EcSTtcIpilVmX7OV4x gdQRiuGa1OmmjBtTd5a0tyA7ttjB6Jntk10WktcS2RtppS9yszK8hHEfPC/gP51BfKr3P//V/kVu 9NMF5bzz3VwY4j8gjU+Vkj5t46Y9M1ZhntbuINaRh1Z2iZtmASpKtx+Br49rod9kiGG6uLO9aEor 2ww0bk5IYdRiupttQtp2hjvkMFpLlLl4zyoORkD8aycLIq1jmNM0nVLe6nKXamwR3RBFLtV493yZ XuRxyK6jS9Ds9UNxC11cQ38AN3CInylyBn92y9eSDWb2JaurF6xkE89vZQK+m3CS+Q8xkEcAJPJ6 /ic1rvot5czQX095fzQW8xt4pVk2Wu4DkDjBOD+tZ1EjGdmkz//W/jfl8kMRI6MyAArG4cL6AYqH TdNtBPqMt80rq4WWNEfy8lflUD0wB274rxp6XOS7X3kuqw2ubOaIzE3DfZ3thlggUZBI9DyM+1Zp FpZJFKY5ZrdLgbYIyQOTgjPbr17ZoV2VrewkktnepIUhjG9yiwF96RnspJ9MjrVS4itBGttFbx2l xA/mySx5AlJAHK5wenUe1MmTa2I7z7X9ivLVCizCzaRWVxg4GeD+HSq+na8IrawtrkziSaEZlZMR IR2PpQKn1P/X/jHu57a7ZTbtHAgi2XU7yAMR6r69Rx6VlapPNBa6UtoysNOd54Y4zxc5xjd+Qrxz nJ9OubhbRJ50ZLm5/eLZlcrEueGJ7Z5wOuB+fVaWYiGEyeVk7iOzeta02Kyvc2ZTbwxSzROEATD4 fpzgcdq5u4+Z1uOS0fKFeD612RdmOxaimnuESRs7Yf3kALYAbHXFcvrVxPteKYENIu8sv+Nehh9y Jq0bH//Q/hZ1Lzo7g4GF6cda+2/2Ob8R+JI9KtbCW+dpHvplvMJFNtKA8Hj5RIzAc/dPXv8Apfh7 OUOMcByq7dRL1vofEcbxvwtik/5H+Gp+2vwP1650LW9AuZpGuvL8SRJaXMkQKWrPIiIoPGVDHHtu Nf37fsa6pcXvwm8OLJbxRQQ2QkjlzzdxsqujD8/1Ffvf0maHNkuDr/1p/wAOfCfRerp0Mzw76NP7 2/8AI+Ef+Ctumalc/C3xXqNpZLfNL4dnURuRGjxboVaNSOQ/3sf71fyZQ3cNk63uBZPexx3WmLMn 2hCZACq4PBC9Djj5a+s+jQ0+FKqX8yv+J+H/AEjFbjPkktldfP8A4YyY9RN5qEyXaJJfRsZbox2q 21uMfxFBgAHGOOp+tY2q37fatOsbYGeE5nZwN5iG75lX6/Lz71/UkFaJ/NNW17n/0fgK61jUkjk0 u1tHnd4DdLbxP5b3iopbGemRjoaW3W0sLD7Tcw20tuyrLfQ7/Ke3eQYPvnIxkV/s1Be8f5ATktzK ur2zljkhttIVF2EFXmb98D0fP07dKn0/R7N7W9S5vbZL9bTzLKKFdoTGMIT0LYrdJt2RyTlZ6FSz jGorKBdzGSzHnOkj7FbYQCSfqQPxrfeN5I7aEraxzLCJt9u4ech+cOfUenbNbRVlY53JRMzVkh1D UrS005At1p9utwbdkaaSaU/eZRgqQRj5fY1Qvm8xdPnRZ7dhA1rcpOphDyCRySinnAXYPzp26GMp dWf/0vz/ANKt9KEUn2hpDKIz5fzAYLYyfTsKtQ3mk/ZL9Lizv57q1nQWkkbKtvOu3JG0gE/mK/2v SaVj/GFu71MPVtNnAW5igaKG+J8pZV4iOMkenGeg/wDr1ftbSFrKK1urqVUfiYIMhsA4GP8APWmc /N73MGqWlp5iJpclxZzxwhjMEDwR7Tg5JHUjqPrTmW3eG8lvbiJ3tRHHDtP7y5JyGZPXBGfoauCd 7kye7ZlxWGoalPhVnWMpkySEgSKeAOufetO8/tK1t7XToI2LWsZijkVjvCks3B9cknJrU5m7I//T /PWKeS5SS41hVbUFVLaIwwiA7EBHzEdSQBz1Jqtdo2DJFAblQcvETgrnjNf7cH+I5Y0y2SVZLO8U w2h/eh1YeY277wUn8PzrWmmvLO3sX0OaFY3Bt4o5v3iyooCsH7jOe9AFOS5S3gRb+0c3KoUaO0dR GCemQeo5PfuPrVCwv9WnjhUwTWdhFcbYRGP3bHpvcjg4zj8K0gmtAOwe5ulntjeix1KDUVT57ONn AbkNG/HDDHPGO+a0LhYbLD2VjDCWVkRFX7nsep6fyrQHoj//1PhmR7a1BctCkkp2FyclWPJI9Kop q8wa+T7W0glZUt02kmYYwSf8+lf7gH+IvN7tzP2rZW0t4lrNtgb50VciLHU8c100Wq3d/PaRJY+d btDvSNgZAF6429Tnk1dPcxLPn3WjSWURNva3FzfGV7ZxtVYzjbnPQ465rM1bUZL+4uUjtlaXzT5R UjEvuPrzWpi27tDRfR2SRTzWkcd5bweXdQXCCaIsRjg9j7+1PuLq7msLWC6MKSsPPWVJC6sGA2gr 2I70GUpWdj//1fitprpfD02n3n72S7CMs20ETbGzux24yKoM1vDBE91bNBIsYWJcFIp+AAevOeDm v9yovlZ/hhNq9yrZsLK5O+ZYY7wKojT5lG45HH41cgknuL68sj5RgSLfE6gqJVzt5B6GrjK+hDkr FO5hGmi5kW4gkjHyy7YxI8LDBwG6gnjpisxIpbuexuJZ/sltfQbmtpUIePBA3yMOgJBwuCeKs55v TU6+yu4ogVmVJJGAUY+bcBwKqW0kX2i9ju7YXiqPLsnaQlbcllYuoHccr+PegwbUT//W+I9Xlkku 7eWEFkKKkqM33MLgkfU81nMv269FuhfOwtsXtgYyfbJFf7qQXU/wXLNtYbbea4kLb4QU8vcXjYg4 O3+efQVX0vCzXEziNGchIZnySgHJA+taCbsrm95x8qSOK6UpKAJoyTsIB7j/APXVGxh1C4naO2JR Ny+YkUW+V4wRuA69u/YUGbldWNC91jQ7F5rmxF5Pb2zLC8dxA0DM33X5I5IPPAI5qmRmOa5t0DyX TCNA5x5QyD09eBQQf//X+L7xtQ+ym21IWtvbrEBDLuzMSB0x7Y5xWfbDyXjQNIUCg8oUZ8jPAPTP av8Adg/wPITcM7yA5RxJtVgdwA9frUOnx5ubg7pNxXeyuSVP8PSgwas7Gqt3LYW7raIhnLhm8wHZ yRkflmqllbrLdvPNtjadsysB8n4D2oOdqzsaKpBDKINhcySYScNtC9sYr0Dwpa3MFy9qsUe5g0kO G29up/XitpfCZN+6z//QyvhBBqdz410KUrK6WGrQXqssP+joyTxSfMw/iGwED61/bb+ytNHN8NNH Cu+9LdN6FNqrhVx/P9a/0G+lyr5bhD+C/oRS/wBhzRL+ZfkjwT/go1pyX3wV1xWALCznaXdyiII/ m3Z7EDH41/HIdQF6lxEyRBLOT7Ihgj8tITGq/KPwIP45r6D6JE0uE8XH+/H8mfjP03ISXGmD86b/ ADOfubJBulkaMW7AbpJTsUZwM5+vpS3emSJc7IoJIrqeGNXV5N8bDaMMo7AjJ71/YKqxtoz+EXh6 jb0L/wDY15YmATIRFNGWjkx/rMfe9+KlfTUhs47xbWS4QTeSr4xGjZGTnpxnNOFSC3ZnPD1drP7j /9Hz+x09795IGXDQgOHU9MH+VWzaLYPNNLJ5pWD90kJBYEcZI9PpX+9vtIdz/mslQmujMhIJZCqj mHBkG75cd+/8qqvHfvcJYNYRXOm3DCTzApmCOv3DKuMKue/PrR7SHc5/YVOxp3VtdwCOC5heIrHg DaTDjsUJHT6etZEVrcDzgZi0QbcY+Ai8dfrxR7SHciVKpyu8S3FCLpJPsshkuIY9/loQWCjOWPoP 8atGOC4xmaJAkS+Y6MGw2OT+dOVWD6nE6NS+qP/S86uLVDCn2KPzGJw02MvIV4P8x+YqomjCciS2 tbgXcWXnBQqjA9GUevX9K/3uVWCejP8AmS9nU25WakdjcCBZ5UfYX+yiN05kduij1P8AiKims9Tv ozZbUggiyyyNaKghCnacuBuIGRxn8KpYim9Lj9lU/lZSGjx20xRLhLnyl3qQmDLgjkA9OtWpLeco 8whdFxuJVcImfWq9vT7mkcPN7ogit2MkZAkllkQ7mhUuh7HkfWnW1tcSSPbQ3IEkd0uLVVMly2cZ GwZPSl9Yp33NvqtVq1j/08FvDTywpK9td7riZo0kaBoxFsAJLD8ffnIrB1DTbixvI4pgq+XhpROD CCD025xkH1r/AHweJpLqf8z/APZ9bsbkfhmS9je8s1dk3gxbInMDrjJwxHODkdOx5rLOiXs1y9gl vJFdFNxLwsojU9HPH3eQaX1un3/E0/suulezIYvD1/YiGOS0uL242fuzBCzmbtuUDtxWrZaPf6hb C3sbW5F0zmRoBCftDAZBULjPbH9aX12glzOSSRhLK8XKShGLbe2j/Ih1HwvqVq4he3uBJLGSAtq5 aJgoJWQEcEZ7+lZJje3WFZreRfKfyFmW0bEj/wB3cByfas3mWEtzOoreov7GzFS5PZSv25Xc/9Tj bLTrrUp1ht7ZZWIL3L9HtQv98dRzx61ei0m9RYjbJbLeyTeUkNwFmiJBwSeoPSv95v7VwK3qx+9f 5n/M6sizT/nxP/wF/wCQo0S9t7hkuFQTBtkohP7sMeoWqb2nm3csaxyt5TCN9yFjEewzjvzz/kS8 4y5b1o/+BL/Mj/V7N3/y4n/4DL/InfR7vZKbe0nmlTbbpHDAVaTJ9eARzyc4wOtPk0/UbJreOZjb xyN5K+Z+7OM4G3GQwJ9Caj+28t/5/wAP/Al/maLh/OP+gaf/AIDL/IszeG71yEiiuRJLOsYcWrzM wOSTx6/jVeXQNTBMQsrqNkOxzc2kttGB3JYr0qXn+Upf7xD/AMCj/mVDhrPH8OEqf+AS/wAj/9Xl oPDOpCEslk7OXK7IAZUCg43AjjH681LZ+FtYvN4k0e9CJAZnc2rlEwcDJx361/u5/rHkqV3iqf8A 4HH/ADP+ahcLZ+9sJU/8Al/kWdL8K6xHewtfabqEOlXAUee1lMyzDdggKFLHHPOMVvw+B72OWZfs mqyrwsT/ANhXiwjcccsYhwPXHPt0rKfFOSU1zSxUP/Ak/wAmbQ4N4jrSUYYKpfzhJfi0QQ+BfF9l fSpJot5cRBA8awafcOJAecgKhPH0qIeB/HmpyG5tvCmu3Sgf6QYNJmQIOFB2soJxjsK5JcacOw3x MTsp+HfFs37mCn93/BBPht47mmWK38E+I7l5ZfnmXS5Iowv98swGfTjJ4rQf4UeNspFB4P8AEbss TXFyYtJlkhhx0ViFwCcE1i+O+GV/zFR/H/I6V4Y8ZS2wMvw/zP/WtQ/CPxsyQXLeFdbja4VoQjaR d70YDLIcR4yR0xke9DfBnxlHZefbeGPEzy7wIIV0G8kwMjIciLavfqfSv9wpeIPC9P8A5io/j/kf 848PCnjWbssFL8P8ws/hN8ULmK5gPgDxcFtcy720G4a2KkYDhwuD0GQORjpXQWnwC+KVw8CP4A8W RKbUTyzLoVxICSegCqT0/HjpXNU8TOF6bt9Yv/Xm0dtHwc42qK7wrXk7/omLc/Az4oCYW9t8OvHT BmEYmk8NXKKx/FQcH39akt/2ePi+9nNNN8PPFNtcxzeV9ll0eeWcqeFdFRDkE9fSuaXirwtH/l9+ X+Z3w8EeNprXD2+//wCRNOD9mH4yKIgvw38Zzu8irPLLo8yxIGxkqAvbritOH9lT45vNdW0HgzxO LaW9Iso7fw5dNdTpwNm0px06kmueXi7wpH/l6/w/+SO2l4Cccz/5cL/yb/5E/9f3nTv2RvjvKMH4 eeJtgc2qJfabNZy7/wC8x2NwO4HNF1+xf8fbi4ijX4aa5dwJKpke0tJyF7k4ZFzgjp3r/Z+fjLwl F2dV/h/8kf8AP9T+jzx3NKSor/yb/wCQLf8AwxV+0JKkU/8AwgepRRXd35UQnsrmOWFF7yKIyMn0 UmtuD9hX4/TWF1NN8PPE8jKrPp0UELQsWHHAMJO1sA8/lXDPxr4WjtP8UenS+jlxvUsnD/yWX+SJ /wDhg/8AaHuLN4U+Gery38UK7i8clrGcjlWbyzg+4FM0n9gf9qaORYpvh60SyACPCTXRtyOzgoN3 bpiuap46cM001zL/AMCR0w+jLxlP7L/8AZp3n/BPT9qe6nur5fh1Ob25/ezy3MklrbMV4+VMHG7k 8eta9l/wTe/acuIZRdeAjYXThZFFvqHmCYnGdqeScAAY5rjn4/cMR7f+BL/I7qf0WuM57J/+C3/m f//Q+z3/AOCaH7Us9yYrHwUi2XyutxPIyzu/8SMAoPY8gfhXUN/wTR/aQktWt18JQWMxwYfLu5H+ bHCktHlhn2r/AFyn9IXhmOiSf/b6/wAj/DCH0UOM5Ss7/wDgD/zIV/4Jf/tWybYE8K2MVxDbhDcC 6OHcnkRgr8oOec9yeasQ/wDBKD9rKQ4Oi6Nb4bO6e5kkc56khVxx7V59X6ReQJvkcfv/AOGPUofR J4pkkpqd/wDDb/P8zWb/AIJLftNTW8IjtdJEhk2S3LT4j684QAsMDj5ita2mf8Eiv2oHP+mw+GpE tHy6xXMkUlwOoDNlgMj+76Vxy+khk8duX8f8z1af0QuIpK0uf8P8jUl/4JHftD3mbeOw0C3iALGR NWJki3E9xGCcY6ZqzY/8Egv2mIZUktL7wsAjidIrgmdNqjDI+V5zjuM89c1yy+kvlUduW3z/AMzo h9DvPZbqf4f/ACJ//9H9Yn/4JI/tEyhi1x4Vtrky+ZtSMiIoR7IOR2zUKf8ABG34+XEvnah4l0Bv MfESKJUEI7bisY/nX+ocvpN5ZHZRv8/8z/G+n9DTOJayc0vl/wDIltf+CNXx3gieF/FumTRSgrK1 tp4WZRnK+W77mXGBk9wK0bT/AIIu/GlZ2lbxno8Uc0So6vEXlBUAAkiID645/HmuWf0oMAtFGH4/ 5nfD6GOZvd1P/Jf/AJE3JP8AgjB8WLlFjm8e6VHdyOPNu1ildFUfwqvlgAfjWhF/wRW+Ice9Z/HO jXAW38rzBbySlyTyYwwBUnArjq/Sgw7+DlXy/wCCz0KX0LsWtZ879X/kkT2P/BF/4k6ZBHbWfxA0 2dpJt8st9ajZ5XaPIQkY9RmpoP8Agin4ua7vrp/HdlaPdYxHBYHyUcdXX2Pp0rgqfSe/lkv/AAFH pUfoYv7UH/4Ez//S/ca1/wCCJOsy3i3d58R7Z3hIe3R7GVYFI/vpu2sCeSCKvP8A8EWfEgkt0n+K Vq8SSGSQWOgGFM8jAAfGOelf6Jy+k/XXwv8A8lj/AJH+WMPoX0X8UP8AyaX+Zs2X/BFa4axNncfE yRXAfNyunJHGcnIAiJJJH97cKs2H/BElLdVM3xcujsk+SKGz8sgd2LFmH4c/WuKf0osbvB/+Sx/y O6n9CnBu3NH75S/+SLUf/BEDw1LcXb3HxO1pVuCG3sTIWbucAjH+eKVP+CHPhG2jZLb4n6qbic7p 7uW3wUx0CAP+Wea5an0oszeif/kqX6HdD6FGWJ3cP/JpP/243h/wRQ8ENaPbt8QdZSTy1i8+NESS XHV9x3Y5HGQevapIP+CI/wAO49zN8TPFkrsgH+kSRyBG9RhRxXFL6TWavRSkejH6F+VJ6wjp6H// 0/6NLb/gif8ADRIpoZ/iNrzR3DFpTHFi4PoA5JwOOg4rRg/4Is/CW2h8s+N/Ek0gZmWaMRRdRt5G M1/clT6S2c9JS+8/zqp/Q3yWNuaEPuX/AAS1a/8ABFn4OQAbvHni7OAjlZ0DTL/tnbkkdua1of8A gjH8B4mh3+KPF1z5ZdC1xcxGTa64OG2ZH/6q5pfSUz3pKf3v/M7IfQ74fW9On/4DH/IRv+CMnwH2 RRpr2vlIpg+2e4WQMq8AECMDJ75rVi/4I4fs720xltrvXI96BZQt4Iy+OvSPAz7VzS+kfxLLVSn/ AOBP/M7Kf0QeFY/HCn/4DH/Iuv8A8Ee/2d5Ipopb/XnVl8oJLcRT7EPYM0eR9RUtv/wR7/ZqtPKk tk1RJYQFiZ7hXXj1wg/KuaX0i+Kpfbn/AOBP/M7ofRH4Nj8VOl/4DH/5E//U/qgj/wCCRn7M7OHu 7O/kkL7yYpIkDHv8vlVb/wCHSX7MRQLJp19KI5POt9rxwIrerAJhvp0r+wKv0geKqqtKU2vOTf6n 8OUPoocG0Zc0YU16Riv0LI/4JO/sw26SKlrq6NcqVkV7yONWY9dpCAj8Kaf+CS37KNzHBFcaJqks UCBAYNZlglyO+9Tn8zXHPx14pl8Kf4npUvov8Hx+Ll+5Is6d/wAEmv2S9KDrH4ZvZmk5kN5rE9w8 3Jxv3McgdMdK6pP+CYn7KixqjeCoVyFWTy5du5V7A8H3rmn418W1NFzL7z0aP0auCaMdeR/c2WD/ AMEzv2UFDxt4LhmWVvmjubyVwCOmF3gdh2q3H/wTe/ZTihQP4KsHWBdisZCqxjpjIYdPeuWp4v8A GMndc34nZT+jvwLSW0fwP//V/sAtv+CdX7JVt5gg+H/h0NIgQt9lieUBec7uv41bm/4J5/sqTBpb nwFoUqyLtLzW0WGxgDnr+tf00/FnjaW3N+J/K0fAHgCKXNy/gWbT9gH9kyxjhUfD3QsW7ERsdqg5 7EknI+hqZv2Df2S/Llgl+H/hl1cmRYn8v5O+QoIz+Oah+KPG8/5vxN4+BXh3Bcvu/gWI/wBhL9kS OCITfDDwlLHFJmBp40RYz6LyOOO+asRfsX/skQ5uIfh14Oh2fI0sMaRdOMHBx+lZvxJ45np733M1 /wCIJeHUNfd/AsL+x7+ydvS4l8AeDJzbjc0t5bQGUqemXIBxSw/sjfsgorunw++HjBZN/mSLayC3 9lLE7ay/4iBx69I8/wCJqvB3w2gvf5V9x//W/tHs/wBlf9lK2JmtvAXgEBhv3JHaBQAOox+PNMtf 2cP2TPPm8jwj8PZneX97AZbR1ZuvK57V/Rj438QJ7Rn+J/NS8KPDCnu4fh/kTn9nn9lCB9x8HfDt GeUjfstPmYDsfanW/wAF/wBlGES+V4Z+HIVnzIzQ2fXpy+P5mo/1r8QJ9J/czVeGvhdReqh96HL8 Hv2TrEyBdA+GMBlTbIg+wAuG/wBn3qS2+GP7KNi4MXh34YRMenmWdgd4HHBK8j6Gl/rD4hT09/7m D4C8KoPaH4E8vgr9lW2ffJpPwvickMgNrYKVx0x8v1p0nhX9lOa0l8zTvhT5G4eZMbewjdD15O0Y /Gj+2PEOfSf3MlcH+FVLS1P8D//X/tSPh39k1Z4x5fwqMzAeWE/s6QcdOACKvJb/ALK1u+0r8KAY mxtltdORARx12AGv6H+u+Ic+lT8T+cVw34VQ/wCff4FOS6/ZQim8lb/4Xo2d/kWstj5Rz6qox+dX hqP7LUMTK1/8MUj8vezSNaJtA77scY+tNf8AEQpdKn4gso8KYbOn96GxeIf2W7h4iuu/DWeTG2Mt eWjlgBkDb36elXZ/GX7MsQaWfWfhrD5SkAPLaxM4GeAO9P6r4hy2U/xOiGE8KYrWUH9xi2nxD/ZU lmkWLXPh15qthoGNq5kxzuCgHcB7cVem+JP7LcETTTa98NI0mQqWf7LC7AcYGQD+Apf2V4iT35y1 DwpgvddP7j//0P7SF+MH7JMUjq3iH4eQmJBGxlhiZAD0A+U1cufjV+yhBEgk8W/DN4cCNFSS1Jwx yAE4b9K/oj+wfEOX8/3n8/fWPCin1p/cV0+Of7LFonkxeI/BaWrNvxDGk0OeByoBx+IqlqH7S37J liyCbxz4GkmEnliGC6hM0ZwRym4EdSOnej/VrxCl/P8AeX/anhRSV26f3GhD+0j+y3EqRf8ACYeD rfjKpLbqOD3DbcY981n3X7U/7KVu7k+NvCEsiEpi3WN2bHYY+lP/AFU8QHpaf3ky4i8KqO7p/cA/ a0/ZX+zvHJ438LrAi75xLbq0cXI++xGOfr2qjffth/sl2sqQ3Hj3wq8km1/LRY5HAP3SVzkj8Kf+ pvH0tGp/eyHxh4VU1e9P7j//0f7L1/bA/ZJiwn/Cd+GInZA8cf2YozKf7uQKzr79uP8AZPspVhk8 a+HmDsEhkEUQWY99vVuPpX9E/wCo3Hk9FzfefzxLj3wspK96f3L/ACI3/bv/AGQ4IWm/4T/w+LdT 5ck32RI4wcZKlmwD+dZ0f7ff7HU5SOHx94YnRmKArFBMB7EDJ/CtI+H/AB69pSX3mE/Evwupe61D 7kaTft5fsixwTy/8LC0BBbjaUazELHPZcgZ/Cufh/wCCiv7Gz3RtIfiJ4fe4+6saQKZHxycDHQcn Nax8N+OJ6ycvx/zOaXit4X0noofcv8ixJ/wUO/ZNWCW4s/G2l3MMMvkS/wCjLab2IJAUybQawYv+ Cln7Hss3zeNNKjmjcod8MbyIVPPzKCB16ZzW3/EL+NpLeX4mL8YfDODtaH3I/9L+u+4/4KVfsk2/ 7seN9NWSdgLNJVS3+3OeiorYJP4Vnt/wU6/Y6hmlhuPGcUN1CoEi/wBmeaNx/gDKD+tf00vCnjV6 Xl+J/L0vGjwzTtaH3IZcf8FOf2P7dkH/AAl9pMDhk8m3iMrZBOFjYq2fw70xf+CnX7Jkj+T/AG/K 05kCeU2mgNtPQnr27c1a8JONHpd/iQ/G7w1TslD7kSXP/BT79lKyGF169dIlyph09QiZBzj5h6dB WPp//BVP9ku4eQNrl7ZFWJUy6TJF5x6DB24yfc/jWn/EIOMvtN/iS/HPw3T2h9yGSf8ABVn9k9Gu g2s6mWtU3TBdOWbIzgchqWL/AIKq/slXBhiXxBMZpuIrY2XmSnHPO0MB34JHSrXg5xhLq/xE/Hfw 4ivs/gf/0/6qm/4K5fsgJNJb/wDCQXzTKxt0iTSiZN44wV9OKVP+CtX7Kws21Ge81mC2D/Z0uW0K 5EMpBxgP5WMV/VK8FeLZPWTP5Sfj54dR0Sh+BXuP+Cu37J1ndwWlxqOrIZYvtCbNLaRimCQwXGex 7UsP/BXf9k24haWz1DXrk+aRI0Xh65McS5+UuVjPJrVeCHFct2/uMX9ITw9i9Ix/Ag/4e+/sruzJ Bea/I8ZCbE0OZghPTcxC7c8nBGfamL/wWE/ZFQOk+t6nb3ET+Xs/smd4gen3xHjr6VpDwL4of2pf iD+kTwFsox/AzJf+Cxn7MDSLHbXGtSOkmxpP7Jmlif08sqM0z/h8T+zTDI324azCpkxAzaPdI5UD knMXXPYVsvAfiR9X9xlL6RvAkX8MfvR//9T+ni//AOCzP7MtltUvq6NM222E+m3CvIeAfkCFj1HQ d6e//BZT9miCGGW6fVbZZASJJtNuoopcf3C0S9+OTX9d/wDEAeI5O/NL7j+Q19JPgdfZj96/yKUn /BZf9nY7I9NsNd1W4liE4Fhp0pDjOD1Un9OKmuv+CyXwEtYGnk8OeKYkjiDyCWxmUqTxjJjA6kdS K1X0f+If5n9xn/xMvwWm7KP3r/IzR/wWa+CDeaD4X1+1+zrvna8jMYRSMhgoyxz6AGnL/wAFoP2c 1LRyxatHPGocwSadchnVuAQTEMDPetP+Je+IH9qX3GL+k7wZZ/CvmjEn/wCC1/wPtp2gm8M6tFtc /vZmKxMnZwVDEg/Srl3/AMFm/gzBGZv7C1OOLCPC72lzi7DDpFmIA/Umtaf0dOI5/CpP0icNX6VP BNB8tSdOPrJI/9X+kay/4LTfBq+86WPw9rYhjkMQT+z53kUj+9tRvSmaz/wWr+DukWkN4nhHxJfq 0RLQJpdzbysxPy7S6Kp4z37V/aC+jjxH1U//AAFn8Qy+lrwRFNqpS/8AA0ZX/D7b4UCFZX8G60OF nkj+zSrcRIwyA3BVT25zVhf+C2nwimfyLfwX4gaeUgQxpaT3DLxktkRgEdelX/xLdxE+k/uMH9Lj grk5lOl/4GjGb/guL8KBOgHgTxJsN0bQRR2UzNKVOCwwhIz2U4PtVq4/4LhfCCKGZ18EeJQ8akJE 2m3PmyMP4csigHtzge9Wvo25/faf3HO/pecH9JU//AkY8X/Bb/wNNPKP+Fb+IIbe2h+0TyTxrDtU dhy2SePu5rRuf+C3/wAMUnSD/hXXii0Elqtwk88XmW4BGc8ANzjjirX0as8X2Z/cyf8Aib/hN/ap /wDgSP/W/oZ03/gtZ4O1qZ203wJrMtnEQryfZmgZf9ptyk49DirOof8ABbLwFppVZ/h1rcaq4hll eVMg9mCsVYg9iqkV/bK+jXnS0cZ/cz+EP+JvuFpK/PT/APAomXp//BbPwfrF1JFaeA9VtFtZWiuX vCrR8DIK7Nxwfz4qzN/wWx8FiI7fA9wn74QQzGcB7tznEccZIYklTzjtVf8AEtebfyz+5mL+mBw0 lpOn/wCBRGRf8FpdAEUD3fgWa2Nw7KikuZV2eqBW/Q/jWFqv/BcXwpFBFc6d8ONbupEJSe1trYu/ BwTliBz/AErSH0bs22cZ/cZy+mBwyo356d/VGfZ/8FzPDUiSvJ8PtUeUsBDbSQm2kJ43LwrdO/P0 pJv+C5nheOdQ/gXVQucvFBp0knlDpy7bc/gK2j9G7Nr6Rl9xg/pg8M8t+aH3o//X/oIX/gtVocmm G+tvBE87GcL5DxTR3IDEBRs2Ec54+asXUv8Agt9okaIYfA89q0R2zRzRF5XIzk4z0Ht+Vf3Qvo2Z o94S+4/z4n9MThuHwzh96IrT/gtzpcgYnwe13I8SzRw2abmAPXOQACO4yT7Usn/BbNCXMfw0nSPz Vij825UySk84WMOJB/vbcdsirX0asz6xkZS+mRw7bSUCT/h99pFtIkdx8MtZi3SCNd8bThzxnkZx j8RWFf8A/BcJI/tE1n8MdXmhtp1jeRWiwN244EZkDsABywXAyK0X0aMxfSRyz+mXkEbe9Flq2/4L k+H44p2vPA2o4BQRois9w7MMkDaCAB05NZf/AA/HSa8a3tfhhqphKNOZmmRDGnZfmcfN7Yz6U19G bMN7S+8h/TNyFfaj+J//0P3Uk/4LiQpa2x/4Vvf/AGmS42CFI/NbYoyWkJwB0x/U1XX/AILjpcmW FPhrc2tyMtG15K6IVHUqqZBx6Hmv72j9GPMZLZ/+BL/M/wA2Kn00ckUrJr/wGX6IuD/gtVrUmmw3 kPw9thumeJXa5+SfaM8EqMdD1rKX/gt7rRuHin+GVvYQiIYvJ9QElvI2fmVSpJz6YXsaa+jFmF7N P/wKP+ZH/E6eTbXX/gMv/kSOX/gt/f3Fv5kXw9wtu5QvazPK1yR0woVePxFNsP8Agtvrd0o+1fDm 7jEqPNb/AGWMMFC8bXYM2CeOG554zT/4lkxy0tr/AIl/maR+mjkvV/8Aksv8h8f/AAXDuLdIzefD 26uHZmi8q0D70GPlL5VQD61RP/BcPUpJnT/hAbi3XDbRJA5+7noyk4/EU19GbHNar/yaP+Y39NLJ F8L/APJZf5H/0f3Eh/4Lb39zZC5i8EWVtGjCDzLq7fzNx4yUIDN+Ax711qf8FffEVzod/q1roGg3 B02zFzcQi++zSSAkBdgJJ74JxxX96Vvo14yhHmlBy1to039y1P8AOLCfTJyfF1HTVSEdG/evFadL tWv2W7PN4f8AguB4i+y3ok+Hqb0x9nl3ynf6qCVX9aqSf8FufGUcMM0nw3CRXLbIZYbwSeWAesqb mKZx3AJ9K6V9GfG9V/5Mv8zmf008l6b/AOGX+RYu/wDguD4t/s93T4ZWkcinyw39oOJZOwcALxz6 /rVOP/gtn4ytbyxEngrSrn7Uq5hOpzAoxBJVgYcdR1FXH6M+JT1X4r/M5qv01Mq2h/6TL/Jk9z/w W88WeRNcD4cJDMg/dWkV7JOspzg/NtXGPes+H/guL43nihY/DFY2kbySJblIHB7MAGOR2ycVovoz V2r2/Ff5nM/pqZb3X/gMv8j/0v2V1D/gtx47FgJNN+G8M96k32WazuL82xUFc+aHI2t2GB6/WqMf /BbXx/DGDdeAbKGZbbzZFfVWjUHIGxVVH3H3GK/0EX0ZK27j+K/zP8xv+J1MAvhl/wCSy/8AkTR1 P/gt140tre1SLwHYXF1eQC4JsruR1tB23ucAE9125qnpn/Bb/wCJM900Vx8ONEjQYYS3Oozwx4HU sEhfH1OK0X0ZqqV+X8V/mZv6aeCvpL/yWX+RnXv/AAW/+Ji3vkw/DmxCoWKSR37TWkp7KGZUbntk YFT2n/BcD4mpdeXcfDHTJlDK0iHW2CoD2yIvz5PSqX0aX1j+K/zM39NLDt3T0/wv/Ioah/wXA+Kg Bl0/4ZaYxF4YriOTV2k8sKB/qxhcjnr7UR/8Ftfic1vMz/D/AEuRvlb7LNqjQXhLHBCFYypHX7zD pWsfo0NfZX3r/Mn/AInQod9P8Mv8j//T/WSX/gtt8Vbia5Ft8OrO2tbYpF9nl1XM83B3OGLbdo6k AE1f03/gtj8SriO5hn8Dadp8lrGJo5I777Usqg4JB8vjnHB554r/AES/4lqivsr71/mf5dr6aFC+ r/8AJX/kV77/AILY/FUSQRDwVYXMUyhzPFcyW20k42NG2Oe+cVbH/BbH4iRyCOfwlawxxxYUx3zK FbsHUQnPrlTihfRphbZfev8AMtfTPovr/wCSv/Iyz/wWr+LkF5GF8D2GoW8oBEsWs/Z0PsQ0eRx6 AVtn/gtP8Qvs0XmeENDgXaWdptUupblX67R5dsARkY6jr1p/8S0019lfev8AMF9Mui3aUv8AyV/5 GNH/AMFnPi3dlpF8NaXGBlrUz6gV8rn+PCOcdfXpU4/4LTfF67sr26i8GaFLPY2xX7O19PbnIzyF MCqWbGQAwBHUirX0a6e3KvvX+Y/+JyqN/i/8lf8A8if/1P0//wCH1Hxqe4Nq3hiwXMHnRTLL5dvK RzsbcrEHp0Fbdv8A8Fnvi5NLBFqGg6dpkIxJc3P2h3hyeFQiKHe2Tge2a/0Z/wCJZ6X8q+9f5n+X T+mVCWnM1/26/wDJmVcf8Fq/jMkqzJ4OtXid2VlgnVJIthwrKXJxuxnBGa1Iv+C1vxklQn/hDbNE WwkMP2y6WRppewbYo2n0y2D/AC2j9GTC2u3H7/6RxT+mZVUnFRl62Vv8zmv+H0nx2hjijj8K20nm OHnZruIvEM8hQQ2ffOMY4zWrqH/BZj4zppon0zw9bGcsQ8d4/mwF/UMAvy960/4lkwd7Xj+P+REf pmYhw5nCd/Rf5mDo/wDwWr+OZuJv7e8IaMbW3lDRSWl00FxK3TujfL+HGO9aV5/wWw+Mc8VyNJ8K 2soA8pCs2/aS3TJRM4HsK0X0ZMAvtR/8m/yOf/ic7GpWdOd/SP8Amf/V/TLT/wDgsl8dZb6S3k8P aWDJAsiC4vd0UvPz8iFtjDjAAPWoNS/4LI/H9JooINA0SMb8TyR6s52J/D8vkqckfy7V/pWvoz4D vH/yb/I/ygj9MrHtfBU+6P8AmZlp/wAFn/2iLC21AXum+GBJFcOLecTy26OCMpkGF8nnn5h34p91 /wAFmv2jSmnTC28HoLqZIpYYo5zIikEsSTGFGenAOOaa+jPl3Vx/H/I0X0y8evsTv6R/zIrf/gsT +0DPBNcz6ZoUU9tO0f2Zr5o1CA/LLG3ktwMj0+lWJf8Agsr8e1mWOaws54MIryW2qYjuG9SXhU8c A8DOOKf/ABLTlveP4kv6ZmPX2an3R/zMix/4LH/tKLqUn23SvDX2BZCI3S6YeShIOSvktubHf17U upf8Fjv2i5zeXMGn6fHFCMWVtFch3uFzjzOIVC5BztJpr6NOWbJx/EcfplY7ZwqfdH/M/9b9BdK/ 4LHftELdNHd2emfYnthKJJLgRyiXj92MQue56jHB5rR1L/grn+0PewJ9lj0aO5iG95J7+V43Q4AA 2wqAegy1f6Xf8S15dHrH8T/Kj/icfGzVnCp/5L/mUo/+CvH7SMMlrClrosDlTFNeuDLYFeu45iLg jjICnPY1Ruf+CxH7RQmMFvrmgRx28fmvcx6bPLbynP3QPLBH0xS/4luy2+8fxJl9MDH7pT+6P+Y9 v+Cu/wC0RcXUCL4g8NRRNhxNLbTIGDY4x9nyCPUml1H/AIKt/tEanNAw1rw7M1thLq4gN4dj9VUI IcE4I9evStI/Rwy2Mre7+JjP6X2YSg9J37afoY3/AA9s/aP0/UCrXFhqdu8Z8yWBysien7uSNevT jFWtS/4K3ftFRhVt7jTv7JjhBcm2eW/hc/eKqr8gZ6A5461t/wAS45TfVx+5nP8A8TeZq4uMYzv/ ANu/5n//1/tCD/grf+1GxuPKutJFoRusBKTBcXgyMBwVfBxzgnHFcJ4y/wCCpP7TPi+zu9I8TmK2 0+83W7vaHak0W3GF2hM5zgkEda/1FwP0dcgo4iOIq8vNFpr3b7er01P8hMz+lvxDiMI8LQjPlaaf vct76dE7/PY+FfE/jDUPF2pXmvapKUl1mQ3axzzec1uTncpONwJZWbDcjdjOMGvza/bkkik0C+1+ 4S00+K0FnplyxkAceYB87oPmYssRyf8AaAr9mzvD08u4OxOEoq0KdOUV6JWPyfwjxtXNfFnC5hXd 5VJ8z9Zf8OfjXdbt/wBptQyW84IMZXaYx23DtXLzxDzpnlmTamMR8lpM/wCFf4157PnzXEP+/L82 f7iZaksFS/wr8ixp2o39tHJDFMxtZFKlZBvEfHbNR29wWLBj5gBJLMQK8SfY77WP/9D+MJlfAki3 qki8xnqv1FUf+PJmlVGPGMDhVJrkntYDVjcTxbHlBmk4EbHlcelUZ3lgygCEIRxnOP8APpWQE8t7 FhDGjQKVBZTk546g/hVyO6DR+ayoYlGDxksPegBtoY5pwke0I7YIbjHpU+raVJDjOSCuF8ttyKT9 KAP/0f4vINJWzgeaXbNMV37VbIH1HbGKIgsiSFj8oXPl4JLdsCvPApySpE6pEgG0fNkcrVUajOk8 ZdNoV8MApwR9KANB7qBwk5CRbnPmuRgKO3FQ201vcFwXijVnwjkfKPx9amUbo6FqhRGBIAoSWYk7 ED4V6mDwRxvHJERMx+T5s47msQP/0v4sFE7t80aqudo29CvvWfcOyCSKIkZbAGOnNeOdK0dzX0/y Y7cmTHmBvMZzwW4AA/T9arQxtLNM8RKqnL4HABOPyoSvobJ3VzQsmhlikaKON1ZtnnKc7WB56fj1 rMmsrZbpXuZHk2tuGPlA9K3SsrETethIohulmRixXKgFfvZGOKp2EChbj5gSrnevRo/Y0zP1P//T /iWjsIxdtMJt6k8r0q1NIsGUQgoSBiRstjuAa886CezkhRsRI4RzgEfKR71p6lrEgtobFkiEWNoe OAK5PTO4c5x60AczZmYztcDcqRSGNcjG8d61jOkW102YZ8FM8rUSk07Iyk3zEMjFrqEJETubLsoy FHc1qXMsKRtaWk0txGmJ2klj2FGI+ZQc+1ZvV3Bykf/U/iclnDnLMqIowWI547VDAHQLKqBtz4+Y 4wPX8q8nmkbKV3Ykv9RCSRwQKxAHzMW5zxmsmHLXaWz8lgQjdcH0NVGTbsyjqlnGk2DuLDTrnztq v5zYkSRG3B1AOQccdMcVZM76lDHfz4SbZuIB+RccY/DFaFwSuZF55l0HRmG2QhVkA5H1qewhlt4k W2MSzxtuLE7SQDyPrQbxV3Y//9X+NcXtqlu0sxMLYUySt8qgng5/GsvUZIXEjO6qFwNhHLZ9B/nr XnnsJWVjOtrKJmkMgRImTEbKMj6ms+9b7NDbvGpEBfywwXPmt7e1AWsOtVm3u8j71QbgvRiT61ai mluW8gxxmUnO0HC8Hhsn6Cgmaujovs17cWZhScxtM/7yV2yVUHJ59Dgj8ao2VleXCXovJIUWGLGl CGQ5ZwernHTGTxQRTWp//9b+Uj4ERXlxqti8kNn9tEyRPLbgxxsUeM5HHJxg89xX7ffDO2urzXvA WnabG6T/AG601GC1unIlW1MieZL6bCZOPUkV/W30eKPs+Hswrvqn+TP5P8bavtePMBQXTl+ep/cZ +w9pkum/DHSVLgQXFruiiiIaMSLuGRj1XB/Gvg7/AILC61LZ/CS6tYrmxU38c0bW843TajMyvEyK oHzbRuOPr6V+K8IxdfxUjdf8vn+bP6Q4+m6PhvUlF2/dL8Ukfxs/EPULLS9KuNMt9Meb7TbRhJZC 0KEMVyFUf7Q/Divxm+McL3upa/qUM8UcLal5kFl5gMse5QGVQTkhSrc/Tua/rPx8qKnwZyd+U/lD wDTnxHWn0Vz51gWOZ2ikXf8AN8w9a2kiEGDDtjP8IA54r/Pyr8Z/Z5//1/4m4p4zbwYUxT52ylRt 3e9aiSxRRI0QJOeQRnn1968yqtS1G6BblTfK0kgke4HziTjHbA/SuptbayntJllX/WSrD8jmMryM HI5646etcU+pokoqx2FrZ3UMcC3D+cocqhlILkAgYOPQYrMvMWtyIlO4SnBUfeTNc0kmtTeKsi8L OWMiSLLBF3sw4YDvVnT7lrN55FiHly5dkYf6xsY3fWhKysUf/9D+TDT9V/tCyMEsCRs2fNjOHY9s A+lUYTDbXKLAkixqxQoowik8kmvkprU9AidwZpfLti5jY5OMZz/dpSssL4mUq6RrKYZRwVbpx71l J2RWnKaFqj3SqolFqFkyRbnaMDnpWq6W9tKJ1l8uU/J5yfKx/H9awezIZr6Xa2s2GAE8tuS7SM2V YnI5A9MmrumT6zBJ9ku5VNqlw01uQfu7jwCvTjA561nPVJGTX7s//9H+NOztrC2dbaxUNLyZd/1O 0bs5xj1qVo7aC733t9P8zrHFDCm5NxODkeg9a8eqrXOR/qRX9hq0lnctaSiGSBzMArbpXjB42+mR VKHzpEeW4aNIViA2Bs7H7n6H+lC8izMeLyr15YkkkhEauwhcET5HP41Jpzy/bpbySKGW0lgaLyLr I8kbCNwIx8wPIz3oAuWi6VHYGz3mRgpkF2Zcgkkn5j0x7VNZ6XFKJp5DG1pbQGaSM/MJgMAADr3p tW0BLsf/0v4uF097eOaBraFoLlALOQsQ0XQkEdPbn16VVjuI7V4oZbdZRGfKc4LkA8D+n5V45MYq xqK48w+XCWAG0qDgD8e1acFxAkp85tqsgXGfukdDWlPqZNWdi1epDcKoiABYAs+c5xyDio7qC8gE BMLyxOcF87SOM5HqK7LCKWmpd3V59mtgkFujgvNIcAgnksKi8R6JqlvJdXVxNaNp8dqJYlhnWWfr tJ2gngnnmu/D3vYie1j/0/4bL+JJXlQBgfL3tITjBHYV9Y/sq3dmdQsbW9ljbUDeG0sBHLiRXaWE xs3fOVHA7CvveD5+z4lwc+04/mfJ8WQ9pw/iY/3H+R+23w9iu49b0fTtTvILmePXLdS0oWKPbHOj eXHgAAllznsWPWv7xf8Agn9rkurfCHQPPRV+yaWsEcfm7iVGB8o9Ac/l7V/Sv0kYuXDGCv8A1ov8 j8p+i5JfW81hHv8AqzyH/gqd4Zk1L4Ha9LBcOkgt5YrOPztqXWYkZlOOQRsOD61/GXb2OmWVytvq GktZQ29oLfTbjzPtdy5YBnyx+78yjp6V6X0X6/Pw5iaPaS/L/gn5T9J3Dew4tp4n+aNvuZnRuYNY aVjEIVG8yXXzpIc/KjDHIPqelUbiWe3WZ7ZlzHLuXyVDFVLDeB7Y4r+s47I/lGrVkf/U/O611WG6 E63ot7IpH5djdGfypGY8lpMj8ABTrTQXvdKutT1K6gKRs8ctkH8yZwCNkn0PGP8A61f7OwjbU/xw nWexcgjhktpPtJigtYQq20pyJZh1I4H4Cs0T2Jea306zuoml3IL69XdbF+mFbjgcD+tdSVlY5ZVd LCR2cM/2pLgizuY449kkTE2904wGG7qMnnP4UkMq6bcRtcSgF28vCnOc8D86pRb2I9p5Ggb5n1a1 jsLbNxORBH9nVmbp3POO9L4gWW5/s2HaZZ7O62xRRR7wC55Vh1OTj6ZrVRSIbb3P/9X8+Vsrjbce ZakS2LrHPbltjKWPQnt0psi3lxGVgs2ke3OZXiceUF7BRjJI5zX+2B/i82kadvNeS20NjNbKkcIa YMw5TP8AE2e/QflWZcbrGRAzOc/vFZhjnnBx07UGBZuDHDbRG6LxvcFRG6DKSZBPOP5fWsme3Q2c 7ROzbQSoKg4bB28/WtofCiJ7HV6bPrNraaQ9yk2npJpvnyQ7AEvCCf3hP06Y6g06w8R6ZLqLRtc2 sd2oLMLmA3Ebov3lCgEg9s47+1Ucs9z/1vz71KV71zNbW7QWUjFrIz5jFzzgkNjpkY9eKtWerwx2 xsBolzb6zdn7DcCSQSWcaADM4OASSQMAdDX+3MVd2P8AEck+yyi5OlTRy28kc+4+eFVvmC8qf7pA BFN1m3e3lL2ci26IFWIofNKYAB3AjHPf61sopbCTutSKbTmMMFxdX6RkrloHgPmXCkcMp6AZ9a2Y 9Su7PS4NMKxPZ3RaKN/KBO1iS2CB1yPwpjL9jcR2sEKW0EduiSnawTa7sMDcffpS6xLd3LwSRGCJ xnfgbRKT3b/61ApaRZ//1/hnWbiGxsLe1WC21K8veVMEpVbNu+8468nj2qWbR0mshFaTxW12kQ8u WKJTKW69SPX17V/uAf4h/YK1romrWjyvPLJchCDc3DDEbsTna+OBkjvTZ726t7kXTIqlG27IuGUD jC1rTWhk3ZXIZbd9TlS4kuGMssmRJKvmpbAEDLHt1/Wrd5o5iRp7l/LSIBI2j+UTHtx9Ks5pPlRH b2wntZLa0VpQls01482N+ASTyT0AxisLYj3lvdMq3Gy0aG3eKUbIwSPvAd/lHvQc8pW0P//Q+I9N tLi9tJXSRhFAwa7nlGUtwx2jGOcdPzqPXbVBbQW0bRzRRTGVbhl+fdxg/TjpX+5B/hTJ3Y2yW3hS 3upVjd2Tcm/5sgZAOD+PWmoGmuSqRMtu/wAolPXg/wCfyrSEWnckSRlsba5eSNPIN4NjSIDHOQuC x9eeB9KzHjuLsiZGRssqbpH2lF9cd+M/pWhlPcvi7ggmlS18trhEIiWZRMhHTeVPbNVrGCdSIIi+ +VjJIwPygk5OB2Ht2oMpRuf/0fh6S3MDAmQkgfvAeSMVposFrHaPcRiG4mlMS3IAVDFJx84xn8c+ vtX+6cH0P8FpXRg3lxLaIttbRRfZo5JPOSMsZcHke3UmtXR7a3e3+zKqCNpTNtVgXDv1wc5wfTti tSJ3I4/Ihfb8pmDmNoyM4x/k1pQPqj3DrojwWdy0ews5yZM8DGeMetBFjJu9KFgvkay6zaiHDOkD h7cnggj6ehq5sjEMJi8x9qszhIyBHjAyW6elAj//0vigW/2uaKW4P2j7JFstlkG94xnJ61FNdXEt xLG8iR7sFX2D5NuAFA6cgAV/uwf4Hly5sCkUc6KsvmIGzEMnPoRjrWPLHsc3Tb4FgUfutpzI390/ rQYzXvHQREXTCI2y/NarKjoCzlyB8pHbGetZNyl1YSRSKsbl3wEbO0YP8XH+cUJX0OWbtcct1MZS ixwrcOweKZ2KxwMD6f56V6h4U1CY30T3YQbEZZTGPlYFSvH6VpPRJHNKTUbH/9ODwB5lrrdlc2c0 0VpJeQLuLeRtf7REQ279D7Gv7PP2Nblrj4V6TI7mSRYFSc53lHGCST6EMv5V/ob9Lem5ZRhZL+tz /Pr6D1ZcuaQb6/pE0/2s/hhqXxR+Hmp+HNMGX1K0ksrg9WAdSBx6c/mK/ngi/wCCUXxnstS1QQ6h bi0mvmubW3mhE5cNwo3soycYznPTivyrwT8UsPwFktbB1rXqNPW/S67o+68ffBbE+Jme0cdRckqa cdLdbPqmXb//AIJVfGu50xLWewsbqc3AEn2mMC22qynCBR7dSa2rn/glb8bSROwtEt441UG3sobi VMLgDLLnC8DHNfssvpHYbpKP9fM/CF9Euuk7wm/V/wDAI3/4JJ/GfV7UW8l5FZ3cVti0vvI/13os i4CjoPu1Np//AASI+MVpazWV5qWkmSfDNNcRCZrQcEiBSrYLED5s5FZ/8TH01pGS+5Gy+iVPeUH9 7P/U/WnR/wDgkr8Y7C32FdJuGkXyY5b4CT5c53ElM7j/AEFa8H/BIT4q3U1zdX97o6vMu23htoSr RqvbjAGT3INf6Jz+khFXcZr7kf5kR+iM2kpU3b/EzTP/AASA8fJpccWn6vEmoLdPNcrdwRX0AVuP lRohgDHqfpT4v+CO3jWdI47/AFcssCYxpMgsJpm/2j5fQelc0vpKVOk19yOmn9EHCbOnK3+JnQ3P /BIHxzqbRMmveTHY7ZEtru3iYzBRgxmTy8nPfp071btP+CNWumGaKXWrS3imiPmD7OhZSeSF/dt9 BjFckvpJ17XVT8Ed0fogZa9HT09WaNl/wR7121ZntPEUNs5xHJPJpNtOjxL/AMsyn2fPPXd1rWH/ AAR41Mq5l8U6af3eYxD4bt4lQHnr5GSfr6muOp9JDFt/G/lf/M66f0QMtSt7KPzS/wDkT//V/eeP /gjrdXyxI/iSG3YHynuBYR28pGeSdka4zWhJ/wAEYJIoZY18eTzb/mTy7j5Yx/d5TIP0r+55/SQx 9rRnL7/+Cf57U/ogZO9ZUofcv8i5af8ABGDSYUtnbxddy3KjDtezCeGHP8SgjqPp2rV/4cy+Fp4n hvPFN67Icm4CRuXJ6iMbeFPpXNL6R2afYqS+9/5nVD6H+Q/bpQ+5f5F2z/4I2eCIVmi/tife0YhS 4eOMB0/iDDBxn05rUuf+CNXgWVGEfiu/hMkAgaOFYvs+BxgqykHI46VzVPpFZ3J+7Un97/zO+l9E bhyCtOlD/wABX+Rd0/8A4I4/De0gntpfEN9FFIiqfs4ijibHtjI/DHWrlt/wRw+FaTxXH/CR6jCU OxpbaKB7ll5B2yMpweetcVX6Qmfz+1Nrzb/zPRofRT4Xox0pwT8or/I//9b+nFP+CQfwr+RJfEup SLb8wvIqu78/8tPlwT9AKvWv/BJD4R26hpdRnupZGYTPNDHLKFPQISvH51/XM/HrPpdZfez+NaX0 ZuGafSOnkv8AIuQ/8ElPgnEtzG73E8FzB9naO8m3rGD94jA4B9jmrh/4JPfAtorC1N6/k2WPsyxw xpMhA+6kmC2PUHOa55+OXEMusvvZ3U/o5cLwVnGH3I24v+CXPwLtyY2Rbn5RuSQRDBXoSuz1qZv+ CWX7PEkdxJJpdrDLJjbcJGoKEdTkAAZPauWXjTxJLVOX3v8AzOyH0fOEo6OMfuRatP8Agl1+zdDG 0pszJelAjzpKqxtjvwM+vrW1D/wTW/Zzt1jWCwVZsg3BleO6jc/7MZGF+tYT8YOKJbN/idcfATgx L3lH7l/kf//X/rqj/wCCc/7N7FVuNB0e9jZ8x77W3BDAYO35Tk/jSR/8E4P2WbYSSL4W0fz2Bj85 0jHkg9doHQ1/S8vFjiuWq5vxP5g/4gXwNDSSj+Bf/wCHdn7LNukar4Y06K3hHm+WfLQFgPv5Uqff kmr6fsCfssLC2/wpom12VzKsECu23G0EkHIOO/PvWL8UOMZfzfibx8EfD+nuo/gaLfsPfsqrFGsn g/w5tV/MRvJhQ88c47fXipx+xH+yoCsMvgvwrNboq7LWWKD92RyChB4+grGXiLxnLZy/E0/4g94d U1qoW+Rci/Y5/ZdtGdIvCnhmEuRgTiEyIo52hm5x9atS/spfsr+ZM914T8IyM0axSGQQcovG3Pcf yrN8ccbT+Fy+5lx8LfDWkvejD8D/0P7NIP2Wf2TrZz9i8EeC7dghX91axq5B65YYJq/J+zt+yvGV j/4RLwXA8qKp2wRLI4X1J5r+hHxXx3UdrzufzivDzwwo/ZppfIsx/Bb9l/S0iJ0bwLDAshjRbpbZ 8HuAzcj+lXJfht+zDaTrLJp3gSN+kcYNosXTPTG0/jUPPOPanSf3M6I8J+F+HXL+7/ArP4A/ZbSS K7OmeBhJO3ljb9ly2M5yOmPpS/8ACL/svWrSKIfBdttA3L59sigEnsaFmHH1TS1T8Sv7E8LaV3el +AkWmfspwl8J8Po3UYLO1sN5HcEfLmrUeqfswWrlIpvAas+EJU2oB9O/PTvQ/wDX2rp+8/EaoeF1 DX91/wCSn//R/tUXxR+zBCskv9p+CITHLhsm1WRTnHQDpTJ/iT+y9DE8l1rHgsRRn5mlFuq8HFf0 Gsv49q/8/PvZ/Pn1/wAK6OjlS+5f5DY/jB+yrDsWLxJ4BRJsE/voVUAdMrnp+lJL8d/2XFnWRfEv gN5cFFkRrdS23sAOvaqXD/H9R68/3sl8Q+FdLROn9y/yKE/7SH7MDNGkniDwnI33EJ8rMeDj6ge9 QP8AtS/srW8qxTeLfBiPDiNPOMUgHsCQa0jwjx5V3U/vM5cZ+F1HROH3f8AqXP7X/wCyZYmU/wDC ceDxMg3SLGI4yAeMk4GPrWdH+2d+yFNkReOPDM3kL9pJt4xJ5Z7nPGPr05rZcA8dVFdxl95lLxH8 NKL5Yzhf0/4B/9L+wjUP2+v2RNNCi/8AG+hRMEzbJJCrs4PccYGfrSRft7/sjbUMfjLQUJ+b54U2 Rkj+JgDjj1r+lV4Z8b1NXzfez+aJeLHhtTlyrkuvJf5GRN/wUT/ZHtZ7hJPFmkB4XVfNjt0kSUnP KcCq5/4KV/shRuoPjGw2lc7orZJXXnGNigmto+E3GsusvxOafjV4d0tFy/dEjuv+Cmf7Jlq2yPxK 90jEFmttNJCg9CwIFY11/wAFSf2T7d/Ln15oGYb7c3NoE3gZycH6dq6YeDvGM92/xOKt49eHtF2S j/5KY4/4KyfsmtDuj153LN5QTyAqls4AI5P04qvc/wDBWr9kPThJ9o1u9huLdgtwI9IZxFu91H88 da6o+CfFktJN3+Zyy+kPwDSV7L8D/9P+pS5/4LBfsoRIHjvdTuLVnKrdLZHyzj1TGfSj/h75+zFv jVbq/YSx7reNbCbzJCBnA+THviv65j4EcTy0k39zP48l9JfgWLtBL8DKvf8AgsR+zxapbsqakzyy lGia1liYYHHDJz+FVB/wWT/Z+b7Mq6Lr5actuMVvLPsC/wARXywQDW0fo/8AEUt5P7jlqfSg4Mp9 F9//AAChb/8ABZb4BTwC5jstfnt5pGjt5otKm8ncmcqX8vB6duaZdf8ABZT4IWUEk0ugeI2liAEt otjMpg54Z38ogZzwDiuuH0eOIJSt733HNL6VvBlNXcoL52/Q564/4LW/CC2tmnj8DeKL/fLsiFtb OjRDBILqygkHHUd6zX/4LXfDVzblfh54pgW5combdtygc52FCT+FehT+jbxC9JKf3M8at9LzguDt GpD/AMCif//U/ogb/gtv8OJY1+yeBtWVxPscXatAxQfePTHI9Kjh/wCC23ge6eWOx+GurXrW74uG S7EKoD0xlcnHev7np/Rpzr7Sl9zP8/a30wuFV/DnD70Y0/8AwWw046iLa3+F98IsZWIXCvdye+CA uPfP4Vlyf8Fw9MjmW3Pwp1BpWd9h88LEwXsW7HAz713w+jFmUn7yl8zyqn0ysginyyiV4P8AgttP OJLiH4ZWn2eRt0MVxfPFMo75BHHt1BrMvf8AguMLa3lW2+Gk098MkQFiw9QQ3AI/lXdT+i3jnq07 f4l/mePP6a+TxuuZeXuy/wAjOj/4Lia7NHC8HwkWeOdgriS+Sze0IOGUszAZPqePesq7/wCC3vxE heWWD4QaN9n3nFvNrcFxOq5wNrRSHJI9Sfwruh9FqsviX/ky/wAzgqfTay7eL/8AJZf5H//V/akf 8FvfHk8mY/hfotpFwRJdar5SjjkEMp7+9Ubr/gtp8SnkkMPw20tUS3Lr9n1WOVZG7Ybbj8ifpX+j tP6Lj05l+KP8t5/Tawq0i/8AyWX+Rkx/8FvPi/8ANu+FOghlARZJ9aVUf1bYFH8xUa/8Ft/i6sBm j+HWhT3SSlGtGv8Ay4yOzAlDx+NdsPovUV8UfxX+Zxz+m3HpL/yV/wCRUm/4LZfG+5SOK2+Hvhu2 kdCGllvRKkbE9SoUEqPbmse8/wCC0H7QkP2dl8LeEFkuJvIn8qZ3a3QAESFWjAGc4G1mIwcr69lH 6L2C+2kvV/8ADnFiPpt1bXpXfpH/ADsUn/4LNfH+a2hlXQ9GiuDdNBNFHOpSNQQBJgwng56ZJ4PH TLtQ/wCCx/7QCQH7Np2gi5X93tjKm2mVh9/HlqQR3B5ruj9F/LI21j/5N/keTP6beYWdoT/8l/zP /9b9Mf8Ah7/+0qqFIoNFkllk2rBCfK2qBkOcxtnJ7DHSucuP+Cvv7WqxJ9lTw8k27BnWUtEo9GiK 4z9DX+psPoyZRHfl/E/x2rfTVzaXwxn90f8AMtp/wVu/aka6uIxrmhRRG2V4i1iYwJSPmXIViAD3 wf8AGO9/4Ku/tV3NjAY9a8OQXS4+0MfPlBBPDD90PujqP8MV0Q+jRk8f5fx/yPPqfTNzuS05/uS/ UxLf/grV+09IMHXNOe/hmaPyn0/9y6gfKxxg4z+NUB/wVW/a6kMhvvE+npDKxZktojGYxztVcjiu qP0bslXxcv3HBV+mLxDL4ef8P8xl1/wVK/aeliimi8VKkiOCsJXdHIADyWBU5rl5P+Cn37YjXRnH ja1eE5cWir5MKt/DyyueM9RjpXZR+jpw9H+Jb/wG/wDkediPpf8AFcv4MX85W/Rn/9f65u/+CmP7 YN1DIkvxDMIuGWOFrZA9xDjknJXoQD2/lUc3/BR/9riF4pbb4t6tMigb4J7SGFjjqm5R39eK/wBe ofR54Xj2/wDAF/mf4bS+l5xo9ov/AMDf/wAiZt1/wUh/a6uWL/8ACyr2FtwEUMkBuI48/e53gn9K V/8AgoZ+109u7/8AC1btL12yJILcQQwKP7iDqfXcTXTHwA4Xjsl/4Cv8zmqfS140ktn/AOBv/wCR MeX/AIKC/tcymN5/jJr0jFNswWKGM5z1U7eBjtzz3pbz9vb9qneu34w+JLi1NuQEdIkuQTjgSKM8 HuMf49NPwI4Xj0X/AICv8zhqfSv42l1f/gf/AACrD+3X+1HNCzSfGfxmLsNlWF9FNax9P+WckbEn ryGH09cKb9tf9qadrhZvjF4odJW2qkLJbsfRmZQPqR04rqh4H8LQ2iv/AAFf5nLL6VHGz0u//A3/ AJH/0PYrX9sj9qNmHn/GLxAkqMBHNaxxwkr3D8ZJP1/Oprz9rj9pHUn2aj8XfGU8UzgeRaXwtAw6 A7QNufwr/aGHgrwsteT7kkf4GVfpQ8cVI2hKz85N/ojNX9qX9oazYeR8XvGKiN2EcT3MZaMcghiU yT057YqlP+1N+0DPLatcfFjxZKkB3usN+IJZGHTDYIHbqCOK6F4O8Ix3pv8AD/I86X0l/EF6e1j9 0v8A5Ibc/tSfH7yUaH4o+OXlYkBbrU4J44ue2Ilbjn+Lrj0554/H741Syt9q+KvxCm3jfhPEBVIy Dk8MrDHsBWkfCHhKL/hP8P8AIiX0juP5r+NH7pf/ACQj/tEfGxmhA+LXjqPZlVWTVkI56AKsarx9 Dmn6d8e/jDFcqj/ErxnqUbqUu4dV1ZbgTggZ8kiMFD1PO7t9TqvCThNaKi/6+RjP6RHH8tPbR+5/ 5n//0du9+N/xeujeRab8SvGNlFcRBEVNbk3x4IJ+cbT2xxjg1VX4x/FSOS2kuPHfiW4kiUfvf7SK 3JYDBJfBLenzAn3r/bdeFPCy2ov8P8j/AJ534/ceSdnWX/k3+ZJ/wuH4s3Hyf8LD8W/ZUlNwbcax LGpwCNrYYZX1HesZviV8SdJt44rXxd4pEV+3mo7ao+04f52Q9hkHge31rSPhbwvH/lz/AF9xhPx4 46k9a6/H/MbefEv4lTNcyH4h+LXeZB5aDWJBGuFxyO+T6/pV+z+KXxTsbJJIvGniBp2j8qKeW63R ZHUdMmtF4acLw09h/X3HLPxw46m7rE2fz/zMW98aePNRvU1C/wDHPiqW5ZcSRprlxFbEj0iDbQB6 CtVfH3i2z0+SC08Ua9bvu86XF88qXDHjkHjA9PauiPh7wxFW+qp/16nFPxh47qS5vr0l936pn//S zF8Xa3cRWc15r2uSzW4YFYtUmjidmOS20kgfgBjFV28TeL7ZpAviXXpgeTbahqMs6gY+XAyMYyOn pX+5i4D4aW2Fj+P+Z/zgT8WeON/r8vuj/wDIkE/iXVb3yw99dr5KbrjzbiQMxA6Ag9/Ws1tfuZM2 0k+pxMcvGo1C4iCA8feD5/XvW0OCeHY6fVY/j/mc/wDxFbjX/oOl9y/+RL8WqanBAsIvD5Af7RvI Ek45Iw0rZYjPqe9VptTuXtB5epX4Nu5t54kupPLbzMtkndnIGMex61suC+Hlthl+P+ZX/EVONGv9 +l/5L/kULG6WKZy8t+0yQFY5VvZQQSeMkk56H396kiu9QjZf9LuJF84uwmnklQr/AHSC1aLg/II7 YaP3P/Mzl4pcaPT69L8P8j//0+c/4SK6S2mtIYYGlkO43EtpFOyjrgFlJx16GsiWSeSFLuW4JlMn kiO3na1Z9ozkohAr/eCPCeRrVYaP9fM/5sp+J/Gc4qMsdKy8or8o/mXrG4uLXTpbBZmjtppWnK4D XQZsZzMcvjjgbsCqcflvJcFnlCu4biV1K44xnOexP41S4WyRPTDx+4xl4j8YSVnjp/f/AMA0Xuro fZ51u0nt4wVjXeXkQg98np145FUbBBZ3QvoJrhZkJKq1zI8RLZ6qWwep61rHhzJqa5fq8H/26n+d zircdcVV3zzxtT5SaX4NIaGKvcQyPPNDcyefIkk7vGr9sKTxV43cjI8crCR7mEW7NOPMMajGNpPK +nFUshyhf8w8P/AY/wCRzPjHiV/8xtX/AMDl/mf/1OclmRrW2tHK3UduTgTDzTD24Y8/hWcTbrcJ LbwxA2j+bC6IFkB5yc+9f71/2HlPTDw/8BR/zLLiziOWrxtT/wADl/mSS3M97DJb3MFs9tO4nIkt ELllYHdvxnOe4OcZHTNTpB/ackNnHBbozMFR0iWFsqODvAz29aFkuVrahD/wFGc+J8+essXU/wDA 5f5lNrgbo2nlkb7MpjTznMiehyDxVqLUPIYyxRWkRKbBIlnEHA44BxwDjoKtZRl0dFRj/wCAoyfE mct+9iqj/wC3n/mRnYbOQPBFID8wXy1ZmOc9T6n+dVIXEYhc2VqRuy8ZtY32e2SP1o/srBLalH7l /kS+IM0e9ef/AIE/8z//1fP5LYOrJEDI4BkY4wV7nHoR7VatLLSpbNIzd2drICHeJ4JWu5cZONwQ jPuT/wDW/wB8o4DDQ+GmvuP+YaWb46s/fqydu7bIoW+0OBLAjygkkugLZ9c/SkkuZLKW3aEeW8eR E4UHtzz+H61f1ShH7K+4n6/if5395kRWhlieOeP5YpSyHJVgSc8fn+lakcl0iJC8RW3CAp5o5f0O D6+tJ4ahf4US8diX9p/eNETwyy/KE80Dz4wu0OByNw/xqWEQtco8Ua200SllkiXyzjoeR60/q1Nr 4UL67if5mf/W4eWEMhWIRgK2RhQSeefzqWW/kkgS1ukiaGMBY1MKhUI+UEcda/31+rwX2T/mB+uY n+ZjGhtFg+YLJI64MhHKjpgHrTIZIrW2MaQIJYyTHLyjIDjOT1I9qXsqf8pP1rEX+JlOG4lid44I wkTESOqACNj/ALvenQpG8+77pDDeAMZo9lT/AJRrFV19pk89vexeSZt3kvKZomB27xz19cc/pUk2 o3rBIhOotQMMjIDJxjGG6ij2VNfZD63W6yf3n//X4O/mFy0LTEPIPljZ+SB6D+dS3UtxcxoZyskd mv7obRtiHAz09hzX++ypQelj/mA+tVVpcpyzTK0CRzKjoPN3BN0bADlCCMenH/66la4uPszK0o8k cmMIBz3Oev51fsID+t1SIFZEi3YbaPkBOSv+cVZgkBJaaKKYoMJ5sYbaRnB/D0NHsKfYaxVZ31IP OjguN+1PPK7GPlrjb6Vb+0TvbNH5+IVb7ncd+D17U3Tpp2ZpGvUatc//0PNdq3Eyxwlmkt3WXByo DDkH0q+83lfLOzmQt0L5C446Gv8AfnlprY/5hpVqidrlG8lLR+WoEhLAlsZwB0x6VNbQXHlPI7jZ xsXdg/SpsuxPtqm1xHyMbSFkZsLk4yTVcG4jZopQyujlXU9jRZdh+10I5PtMcyKsxI3AlcDB9jmr SiVopXjYG4DYSHPMoHXFFl2D2p//0eFstSe2fgLslXZKH+ZV9/61lzbgrPta5TzcggF9xzx19K/3 35V2P+YT2rLrXTx7JY0jWRIyqs0YYrnrjPfjFQW0EeoSRSXLxQiFg0RYEhCO4wDilyRD2si49ysU qKkqlCdrnnIGOo/yaz1u3aNY7l3ANwREqrt68Dkc9u/9aOSIvaTLUkdusFw91OYZreNJLWJULfaG ZlXGRwMKxPPpiqSNOpVJj+6nUtGSAG44xn35/Kjkj2B1J9z/0vPlurgyQWvmLGkkiphzhMnoT9Pp VCc3MfmK5EmHIRgO3pX++3JHsf8AMDzSve5NDL5aB5P3Q2b+eOmT0/CrVvqEEy7JY5fMk/eQ3Ofk wDgfnS9nDsRKpNaXG3N7IzKsXIT5WB53UodGAB6MP3q9Mmj2cFsjP2k+5FJDHFcIkapt8nzXkU/I ON23GOvb04qJ5UZj5SjGNpJ/hOe35f560vZQKVWaP//T8xW5dX8tiD79qt+XF9lmkYt5y4MO3G1j 3Br/AHzVOOuh/wAwCnJoZ/aN6tra2UruLZWaVIwBiFmA3ZPXnaPbiqVz+92q3zqGzhucY9KhxS0a HzyXUsNLgCNW2gjAzUkEbMUVpC3O0hTgH8Klwi90bpvuFqwd5A5MkcUvlylDl1H+OKhnmjdpYrYS BVYiPeP3mBxz70vZwXQLvuf/1PMBI6W8SzxGNJmK25Zf9eV67fp7UnmSRv6OvBzwRz0r/e3kjc/5 hZOSW5KZ5HOwkcngYxSRszOySFjGP4D93PTOKXsolXlfce0/zNHlfKVOCfvE9hiqTC9Y7javLHGP Me4gHmRwgnC727dcUeyj0Jak+pft7lZkkXcJGX5SAeVIxnP+FUrjeZY5QvyRcBR0J9TS9noRaZ// 1fL45opZJfPDbm4Dg8q3b+lWljTYQ5B2DO5jziv97fZo/wCYcrJceUJV2b4yMNIyggc9j26VQa4K 7WwWUycEfdx9azlBIlXu7kt1KsrB4gVRMOo64I5x78in2809yXuGhkWNpGButuITIMfJ9cHP0qOS JpF2Ys4dfnXaWbrg8nHr+lUFk2uPM4Y8YI570ci7GnNE/9byH9y0MhZnWRSDGNuRJz0J7f8A66ta ffWlunlXUfmP525MKASuBwT16j9a/wB5uSJ/zFOb6Ed9JcXV35sJhRp5h8h/dwxLnoo7Y9/xzSwP vd0lALDv2NHJE0jJk0kMUZXDfMxxt9PXFQXMMqXC20c0Y3w+ZvblASMgGjlj2L5pLqUDbzW7F1Mh dvlO1iQR9OlW4mYv5say72XbOhb7yjngdun6UckQ55H/1/FJJWMzMqso6RoeSv4/56U1jKx8x3Y7 eimv96EuyP8AmVhJsSOcyFvMBBY7mVTWn5yNHL5W/wApRgIx+ZPfNDS6o3XNYyIvMtvNmQtKTuOx xvIz2GatCe7+zrkMkUxDFDznqOfep5Il3ktEx0ilPKJx+8YcY7dx+lWr6NWtI3tUaBxL+9tyR86A Y3Z/pT5Utieaof/Q8dSeazh8+2ZI5mXYfPRZNoOM4BB5+lUMSvILneXZjlz16etf7zckT/mh55Fi YgtGGCmNlDMVIZfxqndvHbMojkE0kjHbEgYlAMcnjH61LjZ+6HNIqRlXn3MSzDjZkhR65FaPlLJL 9mAWR9vmCPg557e49qUrroiSqDNbTskyMgY8Kw2kD8a13W2n8ssCHiTChCQrZ6lhnGeKE29kXFu+ p//R8EuGiYTIspjmQjyE253jPP5VLFJLINjn5VHzc4JxX+8L9D/moTa2KKXF/Hf7I22RXT+XKCSQ i4wO/Tpn6VpRC2jaUTjef4Sp4PWkXFyfUHh8yMrFGQ74aLd8px/nFRRXs9nGLSWNQ3mFmJG11PT+ nSgq0k9ytK8n2lWbKGbjzWPytjt9auxSG38/7R+8R1xHsHzJxzn1oLhdaXP/0vDJS8dus1pHHcTW aiSzgupxBGzA9G4Oe/AHeo7q91HVore2vh5dpFIl4ttEQQkqsGYBtuSpIx9CeOa/3eslI/5sfsu4 JeIJ7tprQSRMrNGmdqxEnOBX5wftnXmntps9ndCC6t5L9blzIhkkAXyyi4/iG7IGM/cNfJ8aPk4V x0n/ACT/AFP3TwCip+JGA8rfgj8iNQutz3O7/Q1wTFGw+ZxnA49T6dq5G7hBUOgPnKfu4yWz1r/F 3NZc2ZV3/el+Z/uZg/dwdJLsvyLVjL5CtFNsf5stG47YHFVTHDE5VSqRyyEjLYAJPTmvJk7s64yu rM//0/4uI77ybj92DMsTYZWH7uT8atlvOchlRUkGWVTlQR0rinvYFqS2dim+WRj5k6fNEgPKdcGr F3JYQReVcQM93KoO+3Xdhiejf41m1dWQGZdL9oCnAijVQqp/CtRIXiZY+AqRnjGEkz60wH28kUET GUgNnPHJX06VHPcag0ckaNIiIN5UH749cUFKLeh//9T+LOC5eaN0lH7tVCrsyJM9yaR/OSRWiZQF HGen4154BHGnmK00nzuOC3Ck0kyPGjOoyN21uMcUAOksAY4tjFg/zEYxx7VRW1W3R44kOzeZHVV5 YnvQbxVlYdbvuk8wwskiNsVWBBA9avO26VQse4EYLnqD/n+VZyirXQSV1Y//1f4vTJHBbMCytJnO B+FZLIWfz921c4wfX0ry6a6m6VlYkjlRgFljkJ37coCcemfSrDSxW7eWWVDKvCk4L+1O8U7I0p72 Ire5htcxxMEV33tGgwASeT+v61FeCWVvLTYSz71cnPy1ZBBB9p2eW6lHVyqkDBYCpFtnRHIIVt26 TcPvj0oA/9b+KNISzGTPlFT90jhhVC6sVklQ73IDZZSCMV550Elok6rJgFQrYUZyBirhm/0abIy4 yMkbgKAMy1a7DkzN/o+D5e1dtQ8x3kSyBnMgLKo5Udev5VLim7isr3NNrkRSQHLfuny+w43e1T3F 0hhn8kASABiMgbuRxUSjbVCcU9D/1/4mdOtrnWp0jRUiig+ZyUB7j73t2xXS3umzRokUQiZnOEwQ ik9/pXkcrtc6LHMTQKrASRkzklfl7Y6+1QWunz2ty9wkZmaP54Y3bG4nsWqoLUDYnaKch2so4ZWA 3xlvNVSOuT704gxRbA4jjl52KMq1alwetgtn81ggjCiHhdoxn61KtlHaXi3FxGJTjzkTzMgEjgnB /Sg2T5Xc/9D+LK/t/P8AJumuUMTqQbVTzEQerL6+lZztLcSs08udqCNCerBQAP0Arzz04ztoywyT yweS1w0VtvGdjYOelXpLa3/dWayocJvSKSQDHHLDP0FBstGY/mPDKFKl/OzENvRR0yPbirMmlRoY jLPOhKh1KNsDH39qAe5rNOwtnzcBI1TB5wZAOorY0gW9xaCBWytzGY/NDGNkB4+X0NSndtCtbQ// 0f5dv2d9I07RPEGnpH581pJe7L2SefPkpIqx/J6AFiT1znrX7Z/s/wBq+p+N/AqeTBm1uItPikVi JbqMzRFU68jaoz2GF46k/wBi+BFN0eB8VX6Pn/yP5G8VHHEeKVCh/Lyf5n90X7LGl2+i/DeA2Ksh kSG4sopDu8tZIVY49hur8Yv+CzHiyTR9Dt9MRI7yZNaisbJ3BczPfzqrMpHClA2B/vGvxTw3pfW/ FT/uLL82j+ivFiv9T8MZzXSnH9D+UD4pxXGpTxx7kigRxHbvMf3EJVg4DH0JXn/eNfhv8VY7/SdZ vbS4lgb7beyXEBtrkTlI5DwsvdSAMYPqK/pD6RFSUeGKMF1aP5q+jzCLzXESfmeWWbJbzAyK2wcB xnBNdRZXVm0pO9WGOAfvofpX8JVF7x/Yh//S/igs1RoZPN4Ochiv381atl2ReZepJEpJ+SJfMMSj O1j068d+9cFRWuaRaSSNvQtHm1CKLUpLUm2ErInnJtkBXrkZzjHOfeuqt7KBDJZsnm2kjCQSwDe8 Z7AH2PP1FefU6mhv6bocnmXGoNrElxDaosQ02SMQzNknL56EjAzWNcSzwzyzCwaeSKTCeamxn5HI b0GSfwrlezOg1LfUftLeUVFvIw2lUOSPwrr9Rg0RdBQR3EUWqQy/vIpVPmTKwGNp6dc0LYD/0/5D dJnuI47tLizMTltlvcBw28Z+9weB9ea1WuJEKQxNlmUeY7oGJ9cGvkZfEega4hjVY5wu1SMl16se 4xVq/C6glvJPMHj+yiFVKBZUC9AR179/SsZJ7gZWmx2kUrQyySeTIjpHODmXfg/eHQAYH51ZtbeY faRdGOWzYCKDjMhx1OO1Za3M5voammI+l+UwiaM3Fy4ijB+/Hj7xruNOtlvIpL2G5huESXZJbONr xuOw45H48VlPT7iL/umf/9T+NqwgsGk1CZZjb3YxIiPHhLgf73qK58wzavfGOKNzHby/O4JUg/7P rmvFqs4Oa1jbmlNtIFhLrLKgtz5j5XCg/wD16rS2u9YbWBLcQSy4vsNtJB6kDGOtHMoxRuc+2s2W nSzRQtJNH9qe0AEXQocfL6/hXU2ga9gYEpDA6EgSREckHOeM0009gMiKylvWNpa2sdtBZx+XPtj2 hxknOe5Oa07Gx1BZ7Z7Sa3W1BaO4XzMllXg/TkDOaY11P//V/i71XUb25jksrBDv84jzXA2xgZG5 eev1p1vbSQopdkYDasjng7uef0NeM5KIo7I0I7FYf3ltvVZn3XCjlN3UsfTOO1OtbI3d66Mls0SJ vUvMImO084z1OOgraluZS+JnS39rbGyilt1FowUQby4aVm5O7Ye34YqfT2iOiSwX11m+tVY2UzqC jNnAA9Mg13U9yTn7S3ljjvLqaTeTmSZUbChQAAAPT+prHnU6mrT2isySLt8tSfnC9gDXdh1qY1H2 P//W/hu1yLymdpV8os5SJA4LHHfHWvYP2d5oIPFunQrMjXV1dCdERCJ4jAyPvz9Fx+XvX2nDcuXP cK3/ADx/M+X4hTlkmJj/AHJfkfvF4PW2nvfDErS3Jlu7mC4E0XzmJ2JLqzdQB8wJ7Y696/t2/wCC T+tTX/wZ0Nb/AFR7j7Lo8UVq/lkrcmZBJIP+AMxHPfNf1l9IGjCtwHh6z3XLb5qx+LfRkqSpcTZp hls7/g2e8f8ABQfRor/4MakWha4ht7eUSeWgM0TyI8MSqP8AaeRevpX8R2oXWlNqc8d2buCCONIJ 45oCJ7WZFKy5Xgj51NeP9FqTeAxiv1Wn9f1qfJ/SrSjmeFXL31/T+uxzlw2nSk3twpt4opVSFR8y zhQOSPX2rC1C1NvesbbfEkgE9pCwMf2hW6Y9R1/Kv7Jjsj+LJtq5/9f81Xtnu57p7iLbcgs7RxqG RGGSQBnAAwenpWxbrhQrESrInlJAcqBj++PSv9oYrVI/xmk9GT6qdRv5rREAEcarClvEoCADAVVz 6frmtCe7KLJFcRQKbJQwtZV8pcjAOVHqRW5yyklojm7hprlU+zlfMBLGNm2IuOcZPt0p0aWw1Kyu ZzERYXCyz2u0SLdBh8ygHjA9+ma1prQXPoamhAWEl2bqV7gz3pbSzEfJmhRwAUc+uc4x2x9K0Vhe HUIDErqBKWLs+/eTkcN/sk569qszcrbs/9D8+PEEuo2JtkcK08cplmCx4W83YKFz14B/8ePSq1ld 3ouop4CqXed9xaxybYwD/s9u9f7YH+KnOjZNwdT0i91CYXem3NndiG1EsZW2unBG9Se+0ENj0P0r H1STVdS+xO4tlCILeKOCLbJMcZBx/nNA1NN2NqYNPaRQ34Ec8EALoEwFdUxtxjuePxrlRbXd07iD cqWw82ZQ+2I5IAB9Tz0raHwkzatY0bqe/a5gSSZraRkUQOr4Cdht546dKvoGN/I95bwf2nOot2ng t1Q3AHfA6E8dOp9+aoxlG5//0fz31Se/cm3gWa8tdPQmSDduWFd24gemD9Oc10Wm65FefZrme3U3 VvZfZopZYBviibBKEY6/KOeoxX+3UfiR/iTyu9jG1Bf7UD6hawXBkjnZVkGcHZ97bjvjB4PemSPe xaOYfLihLzCS2kuYC0sceBkHOOM569MCtibGhqNhD9ksJY5ZmuGiWC6HWNARlXUZ9+R7iszU0uLe ytoLS7uZWgxLhlwqt3YDOM/40AWRcx2VxatBLd6hHcrH5hni2mKR8b+B2B7+1dZfywyx3NujwwuL c7Zp8JGWA4Ayc549qDOfY//S+ENE0Zb07r2+tbOP5gshO4zSgZxjrj3q5bxTJEYY0+0Xaz/uGhkL eYBxtx+Ar/cA/wAQL2iGpz6hHA0CtPiWdQ0akqysv94e3PWsq7t7qF7SPZLPNdRGa4lZMR257DPu Oc1cNzGcvd0I7ENELlLhpgZHUgRkeWccZJ/AdK1dQ3XUdrd/bons43+ztDIdrRMD29zgD8K1ORvS 7GWVxfDUoE03dbxWtwEvIpoFlS9RgN65I/u9ByOTUF7Fpmnu8dtFPEhmZiXBZ23N0wOBig5m7M// 0/jf7JZ21u0gumjhMBcLt8wyvjKqMep9cDmuLWa5uPNeSNwqDAQsGIznjr7V/uQf4Ti24nl3KbeZ Cj7QGXn6Dmu10me0jsIrksktzFcFI7eVP3bbCMhs9R7d62i7oycndoqXfmXqyPPAot4nyiIv7uMt 6DtXOzwmGKQwK0snRIgdoJz61RBa0wbLuW3lMUBurNh9qFsty77MSCHOMruKgZHTJrRuBFFdLdLi 3dYzF9miPyuTgBsZP939aAP/1PimzgMkqNKcyTy5VMgu/wCFU9XENxdeXD5krW68hXzGvTJ29OOB mv8AdOFrn+C1VNGdHp94TcTNE7WwUEyKCQnGDk/561LbiW3A8ksMfxjt2xWpNnJWZdhZJA8UKr50 C7pkAzIQ3cfz/OprSWCMpEkohlfKxSGXEmR1Ayf84oHa0bC3EMTuNrNcTkcySZ/dkZGF55HTk/8A 6yHVLy3spbHyFa784hQAS/l54P40GJ//1fiu0vo4dRjRldCsatNtXrnqBnjnFTaraWkER+zSyGab ncQGKjt24r/dg/wPtfYba33lwRWsswbykPmbVyckbhn35/Wrk1ta/ZnnmfYVA3x/eYk8AkU4q7sR NaXKumXVzGrWwgRftUhWO4ZczbemAfw6Ukt/cNttEgildSUkMzAsD0GAe4rWMUjgqlKbSLpJPtTk qqDL7WGBkgdK7HwldTx3oQJDKko8oNINyqDj5iPYim1dWPPqT01P/9bkND1W5028Fvq1yotiRcRS QRoFtimHQNzjkgf4V+5P7Iv/AAVK8K/D3wtZeFfFdkILm0K2zRW8RZ7+NEVFlRSMkkJznn39f9af Gzw+rcd5GqGGV5watbfft/X6n+Of0ePF6j4Z51Up45pUK122/hva1r9Hp+HnZ/Ydz/wWP+DX2h47 bQNTMasI0newuHXcSR82FOO/5VVX/gsx8FI7W+k1DSru3l0/5TCY3lkumBwNibBjn16d6/lOj9Hb iJR5HCTa/utfqf2FifpVcI05c/tKai/76ZjXn/BaT4QR2yXVv4e16aR4i0drbaVMzk8fddl8s8YP 3qhk/wCC0HwnmZY4bC70+TzI4nfVrKWFYmkAIWQKhwfYfnXavo6Z9y+9CX3Hmv6WvCl/dqw/8CX+ RRvf+Cz3gjT7uW1PhTVryRCqO1vbZhjJGQwyocAjnlTVb/h9f4AJFoPB+om+bcG2zDy4ey+YfLwn /AjXRT+jlnS05JfccdX6W/DKv78PvX+R/9f+hFv+C0/hWJHDeD7m4mtGIlhs5ftc754QbI1bOeMY PNULr/gtt4bMjxw/DbXGjgjDzuoMDqeMqWYAKeR1r+34fRvzV6OMj+B6n0vOH47TiQWn/BZ2y1D7 M1r4UniS+kaKGEx/a5LZk6o7KuScc9utc/J/wW3itb+7W/8AAEirbL/o8Ud60D3Lg4Csio4G4c8k V2U/o1ZjNaxf9ev+Z51X6YWSw+GUfub/ACQ2P/gtfd6pL5em/Di7V44HuZYGZ40CoQGCzMoDYyvT P3hxWPcf8Frdc04xPf8AgkWsc822NJSsmARkZbgjNdlP6MmNvZr/AMmX+Z5tX6ZmUwXuy/8AJZf5 GfqX/BbbXY3iWH4fXUryoQnkTrBEvozE9f0rKf8A4Ld+Mlhklk+GpgggdVN1/aSOzlj/AM8l3E4+ uK7IfRjxP2l/5Mv8zza300MCvgf/AJLL/I//0P2au/8Agtf43M8sWn+CftAFubhDcyjT2mUAbggK YyM9yD6CsKP/AILafEy8aWzT4eRWwjcKdQh1XzZC7YIUI0YyFB5PQYr/AEPpfRjf2oq/qv8AM/y+ r/TRpJ+5J29Gv0J9Y/4LKfGBbCWSz8E6RdSQOnkwnUB9suSpw29Qu0Dvjr/KuUh/4LSfGobJIfBW lGSSNzcwT37wRxk9BGQpUkZ4y3OK7af0Zaa1lFfev8zzKn00arl7snb0f+Rnx/8ABZv46P5ry+F9 E03amYTcaqZtx9MrET6nk4qu3/BYf9omRJLtfD/hyeHyM2sTzsk8pJ5/gxxjPJHSvRo/RowaaU1F fM4MR9M/GON4OTfa3+aX5laP/gsV+0E32Vrux8LQK+5PsTpK94pH8bOITH3GAM+9W4v+CtPxumsJ Lh5dCtJG3xwwzySWU2WOC2UhKkegJ9elejD6NWXxX2X9553/ABOVmM5WlGaWvbttpfV7Lzetkf/R /SC8/wCCuHx3hmhtJtWspUuZFgH2aKVY4RjGZJGiJAP+yCawb7/gq3+0jaqzWk0STTER290zCeyT LfekXCkrjB4XNf6m0/o45VH4uX7mf461vpg5vJWjGf3oZL/wVH/actd327XdIumyk22CSS2M6nkq qlTtPPqBxXM33/BUn9p+SaRofEGn2qxziayiaI3LuM4KE8DPueK9Cl9HXIIy/ectvS/+R4+K+lzx NKnaipc3m7L9SI/8FN/2pbieVp/GUFpHjzI8Wih+n3CqgAZ9c8e9VpP+CkX7UsgtZo/GywzDDTxS v5sMvUHaFjBB9jnp1rvh9HzhqOmn/gK/zPDq/Sz4wlsn/wCBv/5EzE/4KMftNytI918SbtYGJRYV j2QsSTkHOWGMYyPrjtWfH+3/APtUzW0Wp/8ACdz2liuofYrnyyZo4lPKkv8AeJxjOB39eK64eAXD Ud0v/AV/medU+lZxo+r/APA3/kf/0vpq4/4KF/tWyyQmD4jz2NrFJ5m20j3EjBHAdeDk5rMuv27/ ANqK6iR7j4taxeL5jPi4t44GbPQAqAQRxX+wNPwJ4ah9lX/wr/M/wiq/Sm4ynom7f43/AJfqUR+3 F+1XDFFKnxT1i0eUlZXgC7JVHRfnBHpnFUW/bc/afMX/ACV7xFBd+cGlulSBofLGflRCmFPv/Ouq Hghw1F/Cv/AV/mcU/pO8ay053b/E/wDIz9U/bF/aH1ELD/wt3xU4TY3mXQiZJiw+ddyKnc4wc9M8 5xVY/tdftDtHY2V98WNZ/wBCkJR7fZHcvnOwMxz046DPFd9LwZ4VhG0qbb8rL9GeXW+kZx5Vm5Rr JLzu/wBV+RX/AOGqfj863dq/xQ8QXAnIME88/nXEJBHXPBBGRgVlyftJ/GW8kxqHxL8b3cCQmGS3 t9ZFhG5PHybU+XHX8K7afhFwpB3jSf4f5HBV8f8AjypvWX3P/M//09yf48fGsSRvbfFbxnsg/wBT FPqjTqPTfnlvxoT42/FS7t2+1/Er4ivqwlDx3FrrsVrayc42iIQkgYzxnqB24r/bOPhXwvHVUdfl /kf88svHXjiV4uuvx/VmfqXxd+KN1PbSx/ETxjaPHKWuYpdYN3FOQRglWXg8HPUYPQc1V1n4sfEe 7lnlfx/4rQuAAkOsyx28ZXjiMELjj0roh4b8L05XeGT9f+BY4KvjNxzVTUcY0/L/AINys3xY+J0d tZ23/Ce+JbuJJC0TwXxif5hzvfGTjHr9Kx28c+NRPeXjeNvE968rC1ngl1eaZoQcH5QxwAOOnTHa uuHh/wALxd44WP4/5nDPxa46mrSx0v8AyX/5Ev3nxB8aXMccFtr+p2caQLE05vJJ5JSBgkgnbknn OOP1qlNrPisi1ceI9blnuAMsL5pFl2HuM4HPat48C8Nx+HCx/H/M46nihxpV+PHS/D/I/9TBk1rV GkHn39wyGHbOPtLs0zA/fPPykYIwMDmsm/1XULiWIrqmoxxwyb2Rb2XyZB3BTdtx/Kv90Y8F8Pwe mGX4/wCZ/wA2UvEXi2W+Nl+H+RLDfXEawhLuYMkhmSWaQyyS+qknkg+nSr413UIrqG/E0nmQE+XE +JIBn0jOV+mBxW8eFcjjtho/cc0+PeKZ74yennb8kY0891cXMtxqMjia4XcCsjRF0PqFIGTmki8q ONI7eaWGJX82KOGZlQsBjOM120+H8pjGyw8P/AV/kcEuLeI5O7xtX/wOX+ZSmgS5uGnniacFgsrz SuwB5wACfrx7VorPqFjKIoorOGKIZZ5reO5luQwXCglcqBg8ZI56VsskytaKhD/wFEf605+98XU/ 8Dl/mf/V4GdYbhhLLBB5qDGREE4PbAwP0q2Lu7gZEFxCYpo/LljWLBVR2bj+X51/vcsoy+Pw0Y/+ Ao/5kJ8TZzLSeJqf+Bv/ADLUN4ls5eCK3DsDGzi3QnnGTkjjoMY6ZPqczDUpYLa6mWGCW8hT/RZ7 m0S7lDE5OGYE9jW9PAYWnrCCXorHPLOcfWXLUqyfq2zOub2W9ulTfbyiS1AvlFrHA2Tg4V/4cbeo 9T68wySJEhskWF/3ZSRFRWeEkAjDnnGPQ9/z1+r0VtEx+u4h7yf3lRY7dYfJkClwmAmMZC45NLJD DPtuPLHmFNsikcNiiOHpp6IX1uv1k/vP/9bhRdtBGsKqqIfmYABc/hVi3127sXLRyOQ4wsTE+Vuw QGx6iv8Af54emuiP+X76xWf2n97H3WtTX0dsZmt7mWCXdKUjKtGfb0PTvVK4uXvHUF5F2NnryQeM E9xwKtUIdUYPE1u4y1iXTUkjtmdVkfeqlyyofb/PerazXbsckshGWcnJY0nQgug1iKj3ZSZzHKbj H71lEJbq20HOPzxVhDLL87rIQCG4JA49atUYLRIJVp23P//X4i6lWUO8cbRLG3yktv4qGOUhSuQS y4OeBX/QL7OKVj/ly9pPuOdWt7vy9ySMqKRcwtmM55AB68VY2GFw/meZ5q528/IfT60vZQGqtRbM jyCxcMy7VKYzhTn2/CmgwsUaX7wyOvJquSKBTm9CQTRKRH/yzGSB0Bb19+1VZg0SPLChZ0Ibyx0x nk07LsD59dT/0OIWYxT5GwxvboyiRA2WYEtweOOPypm6aR8Qx7io3SFBhVAzkn2r/oHsux/y6ybS EndX2yYDMuF2gD6VXt5Zy07bVQKTgHBGKLLsL3nsy5Pe28MMcMUObvKym4VjtIwwZNv1wfwqpKzX YBKkbGDcE5yKLK1iotrqRPv2gN8hBxwfQ4zSQRyFySS6jnOeDTGf/9Hzi4815f3ZK4HLD5QasrYz WbQ2wWTzpF8xkYcDPTAr/oIP+XZtJq4+dG24A+ZeWcA7j+FR2t155CK4+Tn5j1xzjFAnKPctmbyk khNvb5mYMZ2iAlj+jdcH0qtGZZ7eU7PlV9qMxHzAenNFjNvXRlFZC6yRM7BrfiGMr8rZznDVds5Z MKsixOuCSCoYg47N14pcq7ApNH//0uPKDcAmAD14BoSBpp0iRV8zPyg4G/25r/oItbY/5cZPYju0 fzXilRYpAdrZUKOOuBWfKstsyAsWDLlcnG4dM/pQSNd+I/k3Zk2tg4wDxV51CKwUB1XgcZ6UrIDN VxGxKcvI2zYR1zwT+HX8BVoOiAKrb5Bw1LliB//T4t7qO1x5kf7zZgIR1yMZx+VRmeSSJXBBG04w Oe3Sv+gaS0P+W8SG4XyJQSxdVygOTvOQMZ/M/hVOOKRn3IG3u23aD8vp0rJq2gGkwuNj26yoWiJz gh9vqMj6dqppI8IlkIDkKU57E0J2dzSCK8dy4dZDaiXa20qSVBznHSn26ySGR5lEbgkbAfu+1bJt 7lSlyn//1PPchM4I+X0PNRhnYFwWOO4r/oIP+XC7TuPjaQlQGKr/ABZ4zx0qaUyuiLvIVP3cfOAg OeB6ZyaBFOaR7WTbJG5Dr5aEZGDRGJ4vnBZQ4x8x4OPSgDShKSQgFmaUDDN0WrMEVz9neFI/9CI+ d2GWJGeN3/16yklzGsNj/9Xg5DagGFba4Deb8h80BcDGOnPX3qSSO7N000wljVo1WNZFIyFXAx+Q r/oBsj/l0new0XHlyLvtEk3/ACyZYgrnPP4VYNp5yb0jyQ20tjOKcU76GaV3YqSxQKgQuzSFsOGH yIB0/wA+1VYCWZoYvmOc+WowZSen16UNtSdiuRkzQtaTGOTI3H95gfcx2P5UIJJGYKpVcnbnrgVd PYlpo//W4IQPHh2bdvbAGPujFIpWyureSVE+zq2Qrx7kdm4GT9TX/QFytt2P+W8u3UgeT5AoyOAv CisxHaHzgAMSnDggEjp0Pbp2pWsNabkxRggWM7R/d7D8KINwf5unTJPA96RrD4SZo2WRnjZZBncO cqaYXkmdjJw56ADAFBR//9fhRDMBIWUmJfvup+6TnGfyNQwzxeXiIhnVyrA9T7Gv+gA/5dkuVWLi sTboXmJYknyjwsPTgfWobdxJI8cbYjjbA5+ZT7n8qCZpvYWdPNLKMDY3JYct9KjmMMXlpJuK8Fgp 5x7UGVrbkq3kZdFgRo48kETPvkOPTAGafK4+ZgdqdPfNAWP/0OEjeRVYo3zdscHFVIoZo5S+Q245 U46cd6/6ALo/5c4xe5I4eRzEXMbHpIB0+tLKzCGOGeQSMnIZRgfWjbc0SkSRssseQ2XB57k81FcS Xezy55A38MRDZ8tew68UnJIdmTWyKQymQl1jLkn+LaMn+VVfNEzRTpkRnDZxjI/yaSlELPsf/9Hg ZAAd8Tn5uqg1OIZG8tJWiEZTzMkgscDpn+lf7/3R/wAvFmQBil4i+QZ7YISy7trMew4/E/hUUscs sDyldmw7dnXrnH+P4UuaIWfYfaW5SHLPukJ4yPu+gpSka5RnKyqwY46Hknr+HSi8R8suw5kkkcyk lmzgHPygDsB0qvIhHUjLHgHHQUrwe4uV9j//0vO55VdYjLCALZCiMi4Jznn3606Eyur/ACOsHTee jf54r/fyPKnuf8vHK+wSCOGJULBiowTj8KfbKGgzK6YMhREJ+cgc5x6VoPll2IJoYQTKmQVG3AJw KjjlMmHRyVXIbJ4aldLcuMGrokvLZVeCUPw0HmyIwwynJHHtgZ/GnzSxC2ji8oyPI4IkRypQc9R+ FTK17s2jB6H/0/OhcmGQRY8ts4ZiOap3SxSyNNBDcPIT/plyeYgwwF4PtX+/UrX0P+YOUJXK0Fwk 2BGwZR/GTgVqiWMW7wg4kaRXjkBO5MHkDnGD3z6CpFyMmk8qR0kJII7D7oOOv+fWpEeLL+dKmCN2 5+WZucD6k0A6cl0M6bb9phZ0MkAcNMEfY5XPIBwfpSw3KSxyeZAYijlYNjbgyjpkdqBckj//1PK1 ffmM/KpbIOMGrjEgxgMViB2kgZ5OMYr/AH4P+YHkkV5ZGOUZgxBIAHHFPjlEMDK0Zx0VgcBR70By yREj25kQhmJZN210Kkc4q7BIXk+W3E8O0hkHDgjoRx2NAckioYzdOUkP3fmB/u45/pSxRwS+W0Xm gR/e84ckgkHA7CgOSR//1fNry4DXCmxt3BjIJY8hCMcgHqM4qFHjQqt2zkOp3eXywPOP1r/fg/5g GmtGVRIqyABPOhXO4OecdqtmFb62kVPMgMTAQuh2gYO7j2/+vQKUejG2T28dyIblJ5FlGwPEwTy2 9WyORwRgY6jmrF4oRy0YJEY5UNyxFBHJ2BCZoS7AIQcbQctj3qKSHaoIIBkBK/NgEDrUuTTsCpd2 f//W8ilDGNTbDdIvDeZlRnNaFuSwAORx8/OQD9a/30u9U0f8wKpu2hIruoKuVmhd8FRjeAPTvxWd LOqSyIA+UJKZX5iO3FLVdC1T7l0KDCGliXaCNrkYcFuMURLPC26PJCfNk84HrUGnKR2iu17OI5o4 jdtvmeU7YiygAD2zjHFPFyZd95PCsRllMcbKqoh2cE7B0zwfxzQFmf/X8mKxSzpM3zGM/Iew4wat ssblm2kHqT2Nf74H/MQ6baJDGqgO2MMPlIPIxVYpOVaQBiCNyKRyyjOT+h/KocrO1iuR7FKC6uJf MBhYxpKUH7sKcYHOepFasd/PaxW72cptmhZnnP3hMeigqeOMn1puVlsLkZmwTxqgiiXyJZXZ2yME rxzj/PatCbmBUSVWY9SFJZcY68d/b0qVPQOSR//Q8s81/wB2WtzAPKVUDHcZCBgt+JBIHvUqGNyI nyRuw4B5PPNf728/kf8AMTySLIgs3+2WzNPFZ7ghiGPOkXgjngdv06VibYubclo4o0+TC5xgcf0q HJvQOSRNa7ACJCrKDt559s1K0caNthbKt82BwtSPkexA6iKQEyK7N1jVssnbkdqsJDFLlsEnHyk8 YIp3drFql0P/0fJbh0i2JgsAQpAGT789qebQTW0k6mESRMMK0gV2HsPav96D/mO9l0sVJpzBHEzI RvOwMfu5HJH5UzAdfNdgCORjjHvQWodEwa8aaeOOKGR44Igz3qwsbcZ6gsRjcOmPbv1qSF7dy8qz GYxv+7kCEI3rwe3tQWqavZsseezBi2CTk7ugqoRImSsvlrJ8v+9QaeyS7H//0vF5WMCkY+fO0M/b PQmplt5ZIoyzHeciRhGdiDsxx2/wr/elOx/zMqGmhTnt4Le8VIbqR5Ft/NlYxskXOQRyPw/E1DDP HOz7JVIRtjxqfunHf0qnK5ahZWZani8tPMU/Jt5PQA/X8KiLXDW9qpl8xVY7mHy7M5wSB16VBry+ Yqm5dmhMyAZysjR52Y4rRs/Le7soLuQSRtcJCzM3lq4LAHJHQeuOlAreZ//T8t12ytGeNLe6jmjj LYWM5VQTwMnn161gwxbY3jjDMF+eRR93Hqf896/3nu+x/wA0Kin1HvCJNqQEFSu4YGFHHSqcLiKR pGYKy5Ubhk/XFS3JbIfKu5EIBG0rNKrNklZFXap9P8+1QW5junSaVpBNp7usQify25/vEdexwaiT bepNl3LM8krqssis7s3yk85UcEmrFrJtDSswKhdqjqWNCk1saRgk73P/1PBZ5IzKsghQKOGbBLfX NTBY/ndTuTGc4wePUdq/3he5/wA1UYp9RqWxkIfcu1lZjggMAoyf0H8qhs4DLcBnYiJG+U9ePU/r S8jRRSehp6pdvBMs0QiniiPyAnEkvoCAeDWHcTNcfvXRFcsCRGTtiz15PNBajcvSGRViLKsigYVm UZFMBEgMIJHzfeI6fnQawp6n/9XwyfT5lgS4ZWNtDIFacH5dx6DFOhlDF04JK7Qe4Pt/nvX+7r5m 9Ef82vLGKJ7a3sJLpoLs3SwrZzT3LW6eZL+7jZ/lHtgdfQ1+Tn7aviHUL6dpbOxilh+0yabobx2S Ww8m2ijRZLrGN0m053EkjIHTAr4zxBm4cI43/Az98+jrTUvEjBtn5a36JCVlkdZLqQBrhi25I8dh np3rlbm9dJZJISkir8qmM55r/GHHe9iqkvN/mf7gYfShBdkiYTeZF58u6WYrkYXDn2q/JoD/AGeO e9O2RwJYY42yu0j+L39q86UbFwelj//W/i0n3I8duIUjjVsM4yGI9TUMtytvdJbQnzDMQkbqCfmr klG+qMFJo12u54wryFEkTAyq4JA45x396ztQb7YX8iR4mYZ8yP5WU+1ZG5dhillgSOcsJ1XbIxXC gDof0qoYo4ztWcy7Wzk/0oAakJkkOflY8YTkjnjr3q20oldcg7lGw5HJA9qDaMeU/9f+LKe0kWXz 4JWgckKCo4I7jHvVlvJBCqDswCxbucc4/HNeebcqIiWe5MJ2iMYaPj5iRnNQ31wUJhJxuX5Qo4OM ZBoFyISzuQqbm3FY1+QKe/0qZr1EbzXDSOqcRJ94k+1BY+ae2jKSOGDSpv8Au4A9qz7i8YGONFEa Hq3rk9TUyWlgP//Q/ijTMrynY7RRBR5mDgs2cD9DV25jmv7ZUWF4wjeW0gQxhCK8qDsmdAy7uFtb doonZG2qhmVd0jHjAqB5I7llDQsJioyxXAOO4qCoOzCG2MvmKAAyjKr/APX9ahW3kjk3ySGNUPPc 8e1axUupJsWdxbzs7faIY0TKRq3+smI9KWVoWQlpdgZuoXJODVgf/9H+Li7kiKqwZZFKgBh94Y// AFVn3DKYnUzbZJB5cOFyyn29a886CvHBMUKc5U7S3QE01Jl05nhmtykRHmNIoyCPY+2KAJ45POtj cpGJlALIuMdvSsmYC3HnOx3PgkdSue34UAJb28T5iidpt7GaXkll/wAK0V0Fpts1qzL5SlpI3kxk dPlB60Af/9L+JvS/M0+9nlLSHeoQIW2hCpParl9qlyHEssWw5CqseZFXPAY/XvXmy2OhK+gsUc10 IXEOwFyHkY7T0/z+dCrNbvdRDe7xqZIxsJVxz36VENzXkRchh+0WqzMAhbj73zqR1BFRIggixKhl K52N61pdbFKKjsRQrKI5ZIEkXPyOy8DB7U2SymtTJM7l3nVeVcsTjoMdutMZ/9P+JoXrwSqJYfMV uqsCEYDsa6Cz023vrMXoZo9z4jgZSCwHvXnnoDf7F1B5Zle0mjsooBIlySBE/OCF5zxVVrOFUO4D zSNiysMn6fSg3WxGyyy7EKDdFGFRQcsAP6VbTzgqTSwmVFABjYEZHcetBnzNSIrvSklkwGkjtw4m SNX5BJyQTWoCTH9nhDIoUqnkja65GOMc1Ed2aN2P/9T+X79nKDytU0+KWDd5gjinuJMyeeIGRyAT 0J3ceoBr96f2TLSyvfiB8PIL/TzJHb66nnBAYmhAlUqcr3IZevpX9o+DaVHwyxdTspv8D+P+Ov3/ AIy0aa1vKCsf3H/APTm074Z6aZolikZoxAVbekcOxQgHtgDrX8+P/BYHU7W51GFSzvZWniCJUsUj y7sZGljmJ/2GGc9to9K/DvBuLreJPtHvzP772/U/o/xnUI+HdSk1ooL8Ff8AQ/ln+L2uSWvhvUtL tn87MaiS/Qfd8tsliOhO3d83sTX4ZeOJdOu9c1Gewlmngmu2czupUSOvDEZ7ZzX7x9JOfJk+FpPq /wDM/nv6OlJuriaxwjOZC0I3FCeAKuW9pMAtxHnMZwQGw30r+I6jvI/rU//V/ig8PzG4UG6icMuN odcA/hXeWMVnNMq3yNLboSx28YODtJHtxXnVOo47oiEUou0vIriYW9qpSe0jxGs0XA7dcjsKbpF+ LK322Vq0UXmOQsucRhmJ4Hrn+dcFR7m6Ogm8QT3Yh2rJbsgEcgXGZgO9btray3MpjOosbWfD2qXO A0TBTuAUdSeK5nsy4ytoyre2iW13hWYyBAfPjTaV9fyrVtDayxxvchLiBpAq3DJ58kbA4zj0B6n2 pQ+FGp//1v5G9S8qKSKO1ljjtw5+0XAJKKB3A9Ouauxwecf3LpKCuY3i5DjtivkZ/EegTQX8mmRT reWrFYnHlvJG3mAsR91e/Wm3ctxDN9peN/L3qyiMYOMZOR271IFq3tm1C6DWhAMzAqkp2hTjuacl zDbm4ikWTdIwjU7x9njZTzt+tYyVmZTVmaFhcCWZrqSJpnsY/wB5ERyyHgY+p4/Guzi1SGziSKC2 AtZ5g0kaqDKC3U56n6VlUTVhRh+6sf/X/jb8q2dWk+0MxfKDAwF7AA/56VStdEvbS6aUzMkYH2iJ 9/ls2Oen4fWvFlG7seVvY0DazTwWWoCNL+F75opEll2SnbglyBzg5Azx3rIvlurSfBVIhLIygrma BcE4BI/Dv+JpuKasdMH0GRxaXJeNd3p23TRRwWywwg2yuCAxOOmR7da6C81fTReXdguLeLTbdEhl SP8A0ed/4ju7ZwTk+1EVyqxoJ9rkezvRbmOBPswkheL5pJXHGP1z+FZFkvk6eIkmkRufMEvByx3E j6/1qmmtzSC0Z//Q/jU3W7yJDFAzq4zJHESDu9R3JqC50wKJLibfnAFrZMjKpcHOXbt+NeJNN7Al ZWNW0tSFWEkiRo/NkOfkAHastrCE/aImgffCf9EkR9qg+uB6dMV0U99CJRuzTsomeFobu68yaFVJ aRsOSTgAD/PSm6hAGZfKjZItgTAJY5AwT+PXFd1PcyGW9rsZ2u5jDBFCQeN3mn+EY/D9a57V5WFo j6e/lQo7Q70+UK2OgrtoaGMviP/R/hi1m1neeOWXdI6J/rD94V6/8DZIbXxdpV22lywySTNZXeqG 7XZEspVITHF1yp3luehHTFfV5FNxzXDT7Tj/AOlI+azlqWV14/3Zfkfu38O9WurnQPDtxpMVmbvT 9OW01ITKsKXCieRxIB13OoA3LyMHPBr+z7/gkHrUd58NNJsoxPp1pEvnW1vJIJcKY+FLHnqhP0Nf 2J43Q9r4aUZ9ox/JH4X9HGfs+Pcxovrzfm/68j9C/wBsLTBffC7Uo4VkuQR9puRGMjEZVlyPqv61 /DF49sfI+InjWwhht5k/t2405/MlK3DvGQrMY8YUlg569McV8Z9Fmv72MoeV/wAUjzfpYULV8LV/ vW/BnmN3p63AvpomH/ErjBuYpX8kqSwTCZ5PLDp71bkbT5bLTby6h87UVhKAT5ZYh0A28Y9RX9tR +FH8OVVaLXmf/9L837XTdQvL8WmnqZb7zVliVZMRyqW5DdeMZznj+dXf7O1SOa/mu7W4g/s+Vk2R xjyZW6EKQeg9PWv9n4yTP8ZZfCU7nVZZHhgQyo0aDMZG3byc4/P61JrV3BNbabFexWpm8zzURLZD dSYZWy8mN2SUB5PGO1dJxS3dy1f6tp8Lo8VkPJkaOBYkk3bckKQW+p61kww2tnBqG20e61GTCWrv c/uLYZyx4PLdgOnPtitKfYRcNhbXVksRvH+0jbI6q+yUEHOMenGM10yatYi2sYYrc2c0C+XKXk3l yPvOB29e9aGLWtz/0/gG8S+1a9nZLGeaRIU8lnHlRzDGMqTxwMfWqtibaF794kEd26i4nmeNm84g 7NgbpxycH396/wBsD/E3VfeRa7La26W0tg9zcRTSB7qOTCC1JC7nI+uc47Y9K0UYeTbXN1ch7hU+ z2se3K2yjBDH6kduaCjTFyJpVjvI4pbxoxM4hG5JM4yQe/b86qTWloLK7sUll+zajdrLJIr/ALyE 9DGjYyoOMfnVwetgJJTDbTNOtlFOvk+XDa3J83bgDBDevGc+9UYPMnuJo7yCVprxRHBLAMpbNnOP x6e9akyvbQ//1PgiHTdN0+4L3ltql+9xL5UUMN0LVIyo+bcNrE84496lj028tpZTbhgIm33EAxId o/hPrwf1r/bqK1R/icr21J7DWYrW2ZI8x2ttcFooVi3R5f77cD1VRj/CojejVbi3jaXy1aUmL90z RyYBOHIBAGOecfjWxkm9SKW3lWT7GuRuPlrGj/LjPGDnp/LFW5tOu7mVIEZB5S/OGHX8RQZylyiW N5BardWl5ps7z7xHZ3ImEQRj/CV2nOePT/CQM0dpYC/sNjXuovbSy3UgYIgA5CjJwOTnvnjpQYt6 3Z//1firVvC0EFjFeWt07RWV60TtazJ5FyHXCpjtgZPHXisyxZNPjurj7bMqLGQsYQF0cZwPxJFf 7gH+HcpK1kV7eR5LFLt2lM8kp85HbcIzwciuh0+6i1FxZ3SokqJiMs23zsdh6EfXsaa3MpaJlG/t YILprKVXhMkBaORCChIbnB9hTv7JjuZLOKKCVoHIlaEsHKkYyynGOcccccVuYW6E0sd/aXM15byf ZDbqY4YbnByAOSQQR9M9hWcs0N+sVwk0cwYb5G4GGzyB/jQc9j//1viXUbYQWULwOYwwLNDJNuUf Q/0rGsrN/ITVppQ0KzhpLZDgyxgjcN3bOeD7V/uQf4TnVG4sVV/scTmKZi0KuMPGp6Bj6jpWRaxW 6XMi3cymEMPmB2CLdjGT65x0ppPoZyi27o7K30Szgsr8nVI0jIEqRyK7i4I6ndjAwOecVzF1usC1 1YOjRPCU81cSZ3ZBZT9OMittbEW1sYSXMNrdWc91JKkW8u7IPkdQOQx6YOfr+VWd51XE2mSQi6kb fbrIx8pFU/Nl+mQOnPWma8qR/9f4URHe8tI5Qzl5DufdtGB97n3xj61vWmj6Xp4u5pYZ1vZJGLSy XTSRlW6BY+xB7+9f7op2d0f4N1EirDb6nqFjdQ2uqQvGswjeDy/KkCqc478++aYNPnFuJIds6LkO EYNjaSCOO4I6e1bmY9Git3S8gSNLh08uVtmMAcBff/8AXWLKZJ74SsI1cyfulVQijOOg7Z5oA3LX UbGKNWureSKeORoJ1IyI2Vivy+oOOD71clvLCO5e9EfmJDENsgQlowOSPzoMEtbH/9D4oM9lr16N SinkSKcKMlPLDnhemOOnf3q1fWQtYftEbu6SN5YEnz78enp0r/dpRb2P8FYx5SssNtBCbmIIjs2+ YFi0hIUDcfbA4A9K0I7KPUgJEnzO8IkKMNq9P/1VcFa5jVVrlGW0bzBFPcBDBnYwJZUxTLa2dpI7 mE/aBCRL5oPyHHQmrPLrvdMmunmnVy0oBc+W6qcV0+gaVbWL2zQSOjPGkTQszSYORlwvJ6noOaDy a8kf/9HyeVluYo5VckNECoZSj8AdVPIPseafap9neK4kVSig8Z/ej/dH/wCqv934wTk0f85mMqNx XK/6uX7fVJ9PvHktbl47WWMJ5W4+WDnO7bnGeaoPfKrxIwUSszFJBwzDrj27/nW3s4djxa9WpFbm tG6xWbXdvAls/m8b3Lh29Quc9qzrOe1u7qaLVZJGaS3OzYMRo4+6x9B29aPZw7HHHEVY9R8zW8Mi RW7ypPHhZmYloZU/h2nrkfjU8DrDnzHGyQlAUOCB/k/oaqNGPRIh1qm7kz//0vKbPyniu4ZEQs06 sbg5VgVO5QD7cc1JDcOIY0und9zkTonyoAeAFbr07kV/vV7GJ/zOutUvpIfCRbDy7ZPJjU5UKefx 96ltXmt2u79WU+XhHWYBy27gYB9M/hVKlBdDL20ru7Lj3Edzb7CxRowWDRtsYE9eRzjrxWZLBHcJ vmLtceYoXc2UCqNq49COKrkiZyqyezA3eYZ4hIzhJNsCuMOo4zlvrnjtmkjbZEMBnnklG7dLtXHQ 4Hr/AIVrGmkjPmfc/9Pz+QxCT9yWbcoD7m+6cc4/Goo542uWR7+CyMBBSNlPmSN26Zx7k1/vtyRP +YqTd7IhMbNNIvE0u/e0ysWVsHrn0qpNMYmOXIVWywTOKdl2M7Fw+S8KyblcZyMYJH4VPDIExJGz jCGPbuyvzYzx+FFl2HeS6lQq/wAzNIcLwgYfrTmuxHtRvmGPqM00uiFJy+R//9Ty9maYqNoHOSSc DFLdfvPOKyS/Z2b90rOSY1GQAK/34P8AmElK2iKbSPmBNzbQvlqXbcxx7+nXjsKsXOwSpHJnco8s Etk5HTPpQZ3fck3CBDId0kpwhAJbb74/Or0bP9meYktsYJz1Gc4/kaBEYf8AdyiWSFYnjHysuZCd 38J7Hj2781OsUBtgiRbWE5l3HlySMevt+tAmtLH/1eDZGMYUjaF9TgntVN7OGSSB5HmQQS+aVV9q SYHAIx/n+f8Av5BK1z/l3Irq78+QOZWbI2xqJCETn0qxsZLUKSJHLbixHIHYD860AieS5eOKJW2w xMWMRPcjr+n6VA0USzjzi77RvdIiA3HQZ6Cl3NofCPj3MrN86MoySewrSt7iHynEUyw20vFy06bn JA4PA4GQeg9KZWx//9bzNJWV7WaJUmgAJuAZDh8E8D68Cr1neyRztdxAI2/fEmMpHzkDBz+tf9AB /wAvMtx5jad9xZUIb5t56mo/sbkzAYkCZLsvzKQOM/SonsOGjKaTYVYIY2VUfcXMZC47gelWvJaS SaWNt0suXZchVGBk4/LNFNaFOWmxAZWAVJEZkDAERsFc5NX9PnhtZZ1lid7eRCI98h8yM87SPp3+ tWZH/9fg1EVtK80snmJMiqqn7sJyc/z/AJUw/Z1jupRJ5ohk2bUG7d1OR+Q/Ov8AoAP+XcjihEyC UM52HKgjG3r/AI06QmQbNwU4+XtRa4PYsH7Re+VHcHPlII4zgA7RgAVFcBY02KWSeL5YyBwBnnNC VlYCFY9yRhiSxO9gOOQcirflNKfOO4+XwQMn1/z+FAH/0OCmdvNy4G1vmIXrSDc7E4G0D73QL9a/ 6AD/AJc5rqJGSyngEA5Ug/eqd5FXZsDKrDEm85Ofan9mwQVtSuX8p2KttDcsB/FT02sPNRAHfBZj 9449aRoVJkkZyVA2lTuJOCuOePypkMvl2qmF3ljdThT+8ZeTx+lAH//R89msVP76WdzIIAY1yNv+ 7gdO/X0qJnm3DfbrjygEOCD6ZA/Dr7mv+gV2baZ/y7LqWlLRW0qrsXeQ0h2fMQO+f/r0IqBRjqRg noaszlHshZQI4HXGZjzFnofb2p0NzPafZvMXzbaRC08QbBVui8fnSaJWhIrweZI8kTFXyUUMBgn8 KrfaZLdGQq8XmuURy3yuD0FCs9S3Dsf/0uCjyp2vkgDLA8ZoITbtjVlc55Y8e3Ff9BB/y48rGQyX OBC6eaYwWyiZYgdzjnFUZL5ruY+UyiKJyqxhcSKQeQfy6UCS1VzVuIVGn2tyrZeRGlnhQh2hAfYN wB4yR3x1HrUUcSttfPIHy5PAoNrojVXLPkq43EqcYKfj3qcFt4Il+8Np56j0oE7a6n//0+HNvGMs N0h7c8LVfyY389AZdxXO1ScEj1/DPSv+gg/5dJWatcZZrbCbZcPJGjgwxsD8quehb26/lU5KxM0X yMVchtjblkxkZzQCS2uVTCJLomH5AzDKs25VHTrWkXSAzWflxMd+5blWOW9cD8qAjG1yjeo4twkA CvIAGkkAkXg5+UdumOuevPamRyPbwNIEMmzgqOGP0oL2P//U4KKNdRtJtqtCx+YneEkQZx+fSmxJ JA5yXYjhGPJbFf8AQQf8uc7XsWRMELNIhDDrxwwPaqWI0lWWNB13FfWgzLm+OXzDPlhjv3pgaIRK YchSMKvTA+lAFERhpTHz/eLfWpzDFECUlfl8sM8/h/nvQB//1fOjJIHxGXznhW7CmlpjKJ5CVdPl HPFf9BB/y4uw8ylpTK7+ZhcBWPU+tV543crI4bcB8ozjbntQSTxkCMAhl3EDnqDVme4lgjkHlF5I 1wV/vEUARRRmeJQECM+CwYfMvqM1eNotlPCkojkVsMUWUNIoPTJHrQB//9biZ4laaRdhZUfajMOC BTBtOEUBFT5cYwPSv+gi3Q/5bxECxPjAKk8/rSNcpsZ1hk2DK5HyZOKhwuPTqMhZNqPFA0bEk3GX G2TnjAxx+JOfanyQhDvUggncFJDY57/lS9n5lxdlohVlinSd0/1qS+XKmzbgkZyP06VXbJkVI0HA y7FsMa0BtvRo/9fzdVxvLAqC2F5yD2qWOaOMrEWUbh0I5Nf9BB/y4qPkOMckqPDCTGGcOzAZPy/5 xTpTJalYpk6kOpxyuP8AP6UD5X2Ks0st3IreacxvyD/F60SmU581W+U5GPkB/CgXJIdCoUF8PE8j AspORxjHt2qd7yRF2lgsYIUdsnOKlxT3LSkkf//Q83+1ebNtYqFXGxuhJ9P5VoC6IblS4XqM1/0C 8iP+XV81iFrhZZMAFSuCcrgfn+FaUt3DG0Ytw65gAuGYjYX6HAo5Ehrm6mWW82V2J3A8HHOfenxv Cj5+6VGN2On1o5EVZkX2kXKkRgMA/JKc8ZHB61KAWVkJ+cEbSvTH1/KkouIOLW5//9HjZZCIljlw MDCkAKSKibZOmDhkXGQ3I46V/wBAVrK5/wAu1/etYrMrrIHzlQuOB0xxVhTbMp8wqpIyhI+8R2qb DbVytvUPgN8udrZ/z71bLQEYiB3AZO4hhQO9iukRidpMudy/LknZ+VOSdXmWFJEDuOu0kJz/ABfp QF2f/9LkHtrxkFxAomjVsXEYyTGBjLH2OTj6H61SazRppjHttDEvnGJj98ZHAz3r/oAP+Xi7I/NH meXkeYV+XnrUiqYo2CsBJ1OODQFyNA00EQkc+d9obdtO3KjBQn68/lSC03+YJZRE207S3OcA4H40 Gcp9gEKL5T7VLqC4WQbSR04pzxSSwBplaJXJ2AHBOD1z+tAlPuf/0/Pvs5ESyQ+YXD4kOfl46D/P tVlXkl2RkqrIvGEAbA6n37V/v/ZH/Lwm+ho3k1hJbxSQxJbywwLFICWaS4YcF/QZ9BiubkCbkYuW MnAGPu0WXYOZrqXokjiVQyknOSAcEioJFjkLHLFgcr6Y5pOMR80hPmVGHl5ZhgEngfWpmjjkt18p ykoJR0K4QDsRSaimkax1R//U89SJrbcMmTJ4btTTKygq4Ziecg4Ar/f7lif8vqd2yJ5ChiKyAgnM mOq84x/n1qzcSfvE2P8AujgEkdqfKuxld9yN7nExFu4aJfvFlwW+lSApIzOWAG3vwc+lLljsNOXQ crgIwz1OMdT6VVm+6CSSvqByKFFJhzSP/9XzRJjOoKnKIxQepxwaey7eBKxT7xXPC/Sv9/8AlXY/ 5elNp6gHtxuWVDKrIQgBwASOCf8ACmI0iODKu5c4UjIUfSnYcZNuxoBQqSSQ7UAQgRvj5s8Vmm0X ZtZjE56lfvDkHg9s4pWXU0JJFkSRCR5qyD53JzjHY068nHnxsqxqFjUFVXaOABnH4c0yoydz/9bz QNGSJcBsHOTz9atPY3fmQmGSG4t7yDzVS3Zi42jJVwcDK88c9Pz/AN/pLyP+YczvKRgw8sQkfLgc Yxwaito/Ldt2WK/KnrisRJprQ0khIUh2bGCQDxVMoqsEk5GepoGBiCoJBcK7NJjyudwXv7U5iq3C yRIqQvJs8uSXJjB6nPegmTSR/9fy+/heCaSNGEkSP8ksZysnuKtQ3NvEiLcrliQQOg/z0r/fg/5g GVZSpclVBLngAZxSNGzNHAMyO5yFUbsY9aBFs2zN80r7ti9SefpQZbaKEl8qqfxBsD05oArJAxV5 Is4fgEnJxRZgySSR+YCY+WAPQZ9PzoA//9Dz9EtJhP5F9AJYDsaE7/Mkb0BAx+Z7VVjt4Y5XjlcB sGQI5LF+vTrX+/B/y/kEkEXmblXAY/NH0X8KtLMjHyooGhRYwqhSWDEZGc+vtQFrblM2UlyJWtjv mgUyPAv32Ht6VMhQQj5WDjBcFslyP/1UARHfiWWILFJIwUqq5Kjnk/SllhjQo0EjS7iYyTw24cHj PrQB/9HyyISLIEK7i/QkDA+tWZQERl3ru6ZToOtf78H/AC/lez+Qvu+ZgODjjmriuInkuLiDzPOi 8m3kHGxsgZxjkYyPxoNo7aAIklOJXI2HKANgZ/rVad7mMtGo3RuNrH2z/wDWrOdvmUZk8auojlby yrBo2Xse1dBHaWs2nzSyOv2lNgijyI94O4HC9+gz9azA/9LypE2OAUO0enatBriBIGiMe6Vscgfd Ga/3wP8AmHWhkOZGYhXChfmAbvzyBViX7UDFJG7qqLtGM/L7D26/nQaTtcIS8TfMQNx4Xjk1Sulk djHEuOckdBmgqKSWhetZYypWWBA+NjPtBYAY4X0zj9KZA5SWQMMxscLkdKBvY//T8kLETYmWRogx UFTgqex+lSfu4XlaIB3DfO4bKtjjI/Kv97o3Ssz/AJjXZSRYt55bgX32k7RMmEEa4HUf4GoYkmnR 4kh3JGCd+0Z9yT1A478VlJ3Y47FW1s4sXA87aoVgsagszOehznGKsx2jRRwMzhyF/e7eNpzjA/T8 6LaXBbtEZjhiuA7qVWUZj77sHByaoalqE1mYxbR790gBBGNq9zVcjtoNOz0P/9TyG1lnu7SQTGNQ 7fuWii2N05yx5JHShoVig8pZCCoySzZJ+tf70uLW5/zKLV3b6EbTlrPyiT5WQyq3IB9R6Uy2CBkW 4jMluww6htrkdDg+tPldrjSVzZtLqytZVjKO2niTItmf5mA45x1IFUdWvNMkl36VHdrGJRG8Etvt AJxkg9cD1qS4Rexnko7iDzNkzr+7Vzsx2qFrabzEjmcKFfajq4K5HXpQa8sb7H//1fImiEdy0bSC 4XaGl8wZUHHb1A681bS6Mb2sMDhIUUrOHQfMOcBT2xX+9Sk47H/M3BNO5Tuty3rjejlCGJ4cFSAV /QimNFana6tCqyMS6RjbKrDHJGOhz+lDk2rM106EVxswGG7AH3M8NWWTcKxYI0a4zGWHB69qkRKZ J0co0DktHuwBj6U+GaKAwvKrT72KiGObypUI7kkH1P5GgD//1vDt7mSdWRowT+6UnexB9eKWK4kj byowFB4lfklx3B9jX+9B/wAz5YVIcEoWTkkgN1Hp/OqHkQbXl2sUZ9nzvnk+n+FF0twsVnkhRJoZ iUe3mS2WMIy7y2NuG+6eoGc9a0mt4ykzLDAkl1CkczrEqkiMADBHf5Rk9fepbWwGdcQyxwYdyQxw FB5xT7dIUjAjyuRmQE5LHvTTVjWCaVmf/9fwC4OUwijHSq9vPBJOsXmhWhx5o6Iciv8AeaVtLo/5 qYuzLl2APMjgMeVceXIjbkIz83P506CS2gilSOK437dpYyKIvqABn14qJcvY2K9vm4jdsNvhk2sr qcH6dqdeOHhghFuo8ptzvGmJOSMFz3AqegDrYkgrI5kQHhlHDY+tav2qxMNus3kQo+6F4uftEeMf NnoM54xk/KaRtFs//9D56+2TKXsElkkt85Ks24HHQnPf3prM0eHXOxSRu6LkV/vBsf8ANpJ+7csW l5fJFeR2X7u4uMRJdEbjHEwIl+mQcZ7AGvyB/bqSdNY0jSW1O4j0yG9vL22axYJbSxjylUts6hiA ACece1fn/ijVVDgbMKrdrQZ/Q30bKKq+I+Ej/W6X6n5qw3UDTXq3SvNbnKp5ibdo9SPwqWfQIn+y yWTQwee2xI/uxkHua/xpxMk6s/X9T/bOjJqkl5FY+H7lLWO6mu2sDYvIGhCee19gEKDxgDODkeh4 q3anUJIBay+ZJJJmczSJtQKT8o3YwOMfrXHP4Tan1P/R/jD1CWOPEUqoZkOC69BVUxrvSWEKrKOC Rg5rB7mcI9R7CIq0rlmkC8xDlvriqjLJEC4AwvKoPX3rKasbRje5r2krNBmUrtK4ZW+8tZYht5bh xauLgwASseQE9jRCNtSoLqXGRZd10g8gKdpSMkYPsKhunFuqurESL687qa5UmapN7H//0v4uVu7i ZfMZVEKrkIMAE9D/ACrIa8leZFWNfIeXEgB/1Q9fevPOg0yk7OzoBIsahYicA8c0jJJK6JPFtYjk EYyvrQBrJo9oI90ciW6qm8BjkMeOD9ea56/gktbsyIqfKBsc/PHkjqRQBSWW5VPKuCLh2O5cAADr 0q8sNvPADNuEo4EY+6D9aAP/0/4nka6tZ5XMsogIHmQoR5JIPB2+o/rXUveP/ZTqm8i4xIUOUbPY 49q85RS0Og5iIB5wmSWznb1Ga1buycFJFfbKiBysZ/1XpUOGugDLKNkbAwSTk54J9eao6x5sF0I1 T5SonJBypBJGytAEhSFI45g8ALA7YkIMsZHGSvbNRSPu+Qtl/veX0J9zQB//1P4mJN0G1X4BHmMV PrW5C1uHiMWx3jwxcfNsPY1xR2Z0Fa5vlTzI1ILtIXy3rSfbWeA2csUUjSDdLJt3HHop7ClFa2YD bZ0UTgHYYogEAHy4qluhu2wR8w+7kfK5HqKT3AgkhlV3mjRLaOAAyeWQuecdO/bpWraXMy7muT5c SICj/wAUhPQYpAf/1f4rbhx8khj3u3PA4A96ZEJiN7CL+zwP+WmBcq/pjrtx+teTLm6nTHdC3U/l tFJbRyjeNjOzbo4v9rArqbqSOPwncBRGbogOl1HzIvIz17E8YqTc40TzS2bxwASOFxIuduT7kcip 45pGG958RmIRiLaG8thnPNN36ga1lLZtAq3Em1BPjdGfmXHcr1qpcnzrtPs135aQzfuwMfveDj/G haO4H//W/iwkgAkVgEmWNvnTpk+9aK32228tQsQRtrKF5U+wrzou6uegSHVJhbfZbm5N0ApwG+UY PPAHSubl1I/ao44reOVEUr5LE/OMHkkHPHt6CmXGVtDS0mSWa2kSaGGOV5x/pBc+ZEozwBnvx2rd MkEMUcaukj7jk55FBBRkuoSWjGFmPCg8q3+cVWlN0sFssOy0vJJsLIPn80AgkbT14Dfn7Uox1Km+ p//X/m6/ZjsoLu9t3Ee9ruQTQ+Zl0CxxhmRR23Fevua/fb9hDTlvvjfpP25t8Oq6wjGFojt03MY3 Nn0b5f0r+1PDWEqPg7i5dXCf5P8AQ/j/ADyca/jtRXRTh+h/bT8OIJ9O8Bab58aq9zZK0KAbVREB RW2joSBn8q/lt/4K4+IoF+Iel2TTHc149ltVtrSpIZEaSQdMgOCPTaK/FfAKj9Y8QE49HJ/cz+h/ Hqv7Dgav5q33pn81Xx7lt4vDuv2lsqXM0sD21tEsmzYFJbemOuAv61+IniG6Ea+XHEysM/aA8YVh ICQeO3fiv2T6Tc7YbBU/Nn4j9HCn/sWIn5nEW7SeeVZtsbHdgDDcV32naabqwW7tzuuUlKiyZCPN C9Du9K/i2a1uf1TGN9Gf/9D+LbS3SWDzPLCzBfLkD8FWAGRmtGadLEwlH+aQ4aPPLetefUW5ajaS uRXerFvLgsbd/Nln8rMy+UTx/AO/4elbejxxNbNJeCdFOQihMDcpxg57GvPqLc1tYuxxxiR3Rto2 ZUMK195urWF40Ed0qkeaP4H5G4Vz26AZtxDrsVutm322aWHN1PciPO5M/wAua3obiK90+wv7e21K wkCGGa3uoWt1dk+UsEI5z1zyOaiGw7vY/9H+Q9UljATykkifIbJyc+4rf0uay0+08+eVUmEwijt9 pO7PTH5fhXyMviZ1xlZWNC98URamI5n06KeXTYBBcGIESzAZ2kL2IBHzd8VzpvIZY2RnljknLsVd 8zonGCB69ePpUjhLoyee1vna1tNOkuYpQBIZY8B3GO/HeqlrZrLHNp13PPJNFPvMz/M2d27APt09 uKzl8SJk7s6uO1klANhdEeWES5SFgz7S2MP7HFeneHtEtdTjFlLHcZ8wNGQpLFsg8nrj6VniNI3N qelNn//S/jPvobia5tYbCBWgJMmwSCMDaNxI9SeeKsP5mpWs0S+dtii8sNna0Ocgc/XpXl2vNo8n axFb3y6HbFJUe5mkHl20JO3fK2FXPt6mtbVYZ7a2gM6rFKTm9siC4TgYG76k9PSiUUlZG6djmkhS aRBGoRWywVcnbW89lp8NnFCsImkOJrrzxvM5ySDnsMY49qiKuzdaq5lOWltobWxk8lY5z5uyIbyu Tlcn3pl5ot+8Fu0t5LC+87FhHnjAPGcjHI7CqnubxVlY/9P+Mg2k6Sz23mMk0cQmhu3IiViQSO/U dxUq3erW1u51C/m1EJtkChVbPv8AUZxXjjVrMY2ppPNFdR+YkGCs8a4HHuP6V0EC295GWtH2mPBb zPlc59q2pCOi0qXTLGTULfxBpMV7FJbKAQwLofvBk9COOD61iX11bjUUS0jl+yT/AOo3qC0WB0YD p0ruprVmEt2NJd50MtnKYVJjaUjED99ufpXO3uiQPIItPjeWYs9w1qf9WQORj3yDx9K7qUbHPOS3 P//U/h11W5dpnt2j2+WTuBXa2R2rb8DXT2+vaSly7RQf2tatBMiljFJ56hVZR1Vs4NfT5a/Z4ylN PaSf3M+dx0VPBVYPqn+R++XwxvLf+yG8y0li1H7GTcWufLbc2zmMY+UFd2B231/YT/wRx17HgqLT JtPEbW0fkuvneZPA0TEbv+Bqc/Q1/ani9T9v4V059ox/9J/zP5+8Aqv1fxRxmHfVS/M/ZT9ouCNv hR4i4kWGWyBiuFTLZ2MQn5gZr+FX41Muj/GP4k2t9dRTiPxpOD5UW1WPkW8jbmxz9/GSeSDX5h9F iX/ChjvKH/tyNfpZJ82CS6yf5M8CtvsepanJK3nxaUZiROy/LKwPIAzkgGkvtXuZbuSO/S3TT4/l tmjh23DHoCzd84HH86/uek3ax/CeIjukf//V/PywdZXS4gjvYEYKJVtlWSZZedibgfu5GT7VdF3c 21wJ7iNJ0VWMcGSd57F+x57V/s1D4j/GaS91mDfW2ran5Y07T42uI5fOaNFxNsHMgB79OOK2rfTd GmSO6v7qWC4a2dooZofKDyKPlTcehPHp0/GuyDutThas7GTtt7eCe3u9JghR7hJMGbdMkgzjBHH1 xx0pbTSx9ouoQrefH84hDB0JyAfmzj8q1g9bCKl/NJFcxywLDA6qtsY2HzMRwSPrVeC5eymNzeJB cIkqnyZo/wB1Jk4IPPQnjtitTnP/1vge/TVrx4YGuLf7Hc7BZJauY7e0LAZQsehXPPp71nHSykd1 i4fzbcBSI2yrEMM49fqK/wBsD/Ey0l95k+ZIEJCsyAdNvzN/nFXLG3vFAt9TV4LhI/OBmQxmUEbl wPcYweOtBZITMl2Jra5MF1AhEbOwVGGOnPB6dK2tP82CyVZbgeTqbhZX2Bo4NpHf1Gc8fSmrrYBT FNZSlL+N7i3xiC7Q+WGz9wkEHjH54qUajEpWJIx+8GPMxnZ0/WtlsB//1/hmK3WQ3FpJGTM8eY7g TbCqt149/qKg09o9J1L7JdJOpli/ftE2YVTohOeuM/Wv9uY7o/xPHr9mtUjsLVDNYOWkmi2qrhu2 G69PXpms3TLieP7Tbp5UDTny95A4UHOORwTjtzW5PKlqWptP12WVrmzW0gshdx2jX1+7t5KnlpDG ozxycKT+tbV/eTafrNgvh+7tryK3BF7eMMWl8CvGFcBlAJI/Wg55JcurMS1/tmX7WcW58zcyTO+8 xMpJGMHoRxT9Svbm4m0qKQx+bPD593LIghhhI+Xj69aDBpdT/9D4MvpVtpT9gmglUsMyZMkDOOCc Zx7fhTba8tZXKamwmkScCaC1j8rzAT26gH06/pX+4B/h7KKtc6S6g0ttMuJLWSSyj3looS32m4UD +9wM9Pauc0i1t72WULczr5MRkt/Ph8qWZgQOQTx1PTtTjujG3QualcTmzb7ZHtW1BXcOJmHtzz7Y qDTbuzQxSW000brbqVSViWb1/L3rcwas7GlqetRX0kUTxmQqg8yZmxubuNtZosnS4iit7UhGHmoh AiijznDfr2FBk4a6H//R+Jr22tZZNIdtlzd2KiUwjLQJMrHHmKflbvwexFZL31xdTXNvLbeQu/eV KCIHudqjgDjpiv8Acm1lc/wp5XexXu7+WSJVtZ9jJhBIAHAwcYx+BFTnUbW3hMjac15LIqrMVkAd cYywUnBI6itoqysJqzsdPpV0txaRBJVeGOIvdxXPyNjpwO/HpUciR6jNJa2iTW1jDAAshj2o7dwn tTMZJ81kZt9Y2C2trYs7XSknzCV57AfyqKCKDSIBbRrGsHmGSPjEgzjP4cCg0adtD//S+Io4YbyS OaMyp9njO6bsuTnhfT/GrwK3M0BdjPk/u5CcF+OuK/3RS1sf4NVES2Mtms0sLTI1zOS8aodibeR0 7np+VUoBLE91a2cyo0kxYRIdis/OCR61uZpPYz54dSkihkkjUt5h8wFtgYrgvx1q5MLK4gWRUWGS Ph8j5x+NBTTW50enRaYlhNbxC4udQuEy0jW6SAJ1zkjcvIHTrWK1sIYZGgZgiKRcFzsAHcE9KDLl tJJH/9P5Ac2U2hCDyUtrq1g8+CLyxHJc56FWxkqcdDwP1rAhu7q4vLeHUPktkgURqv8AqkwuAAB3 9++a/wB3ofCj/BSLvoy5qfkxxLBYK0rsMSq6/McnotXbZ47S2QwHeTEDcfLh4mxkr+FNbswqO5nL NeNMbpbZFiibcXuEDxzDthe/frUlzdi42ssEUGzgpbp5cR/AfWmeRiJbhHgROoXnO9WxkitfQry/ nvWhlXz44gJw4Cxv8rDKA9sj+tNJvY8XES0sf//U8XE3mqipH5LFcSMpJY+/NXpnZ444fMICIEVz wRiv944xaauf84VaT5bMrLsKPaXD/NGwIZFJkTPHPfH/ANekkhlM7KoV4bY/LPnKt2yPb/GtTya7 eqNhbhLqySJYonkWQOsnJwQMYA/r1rMe3yxfcFG7DkdT7Cg4hLowxPAke7G0A/7PbrU7xPEu98hO x7Gt4qyRMk2rI//V8qha2QxeerlWYhxGccEcc81WnjjEqiNi0ccgcbzgEjkZxX++B/zLlrUL9Gil vLeERrbKC8MKlkIx8zd8YOPzqo07SRR+apMcpyMDBzigykrS1LMYgt7aXbAzTSKFDljxgnqO/FQe Y0kWx8qRypBxjFOzJe5YgeFoirIfN6Fu2aJYGiCszr5hOUjU5YD1P+FbLYW25//W8v8AtUcMflNA XllIYSj/AJZ7Qcg/XP6VnYgN39okUeXvH2hwcOo9cf5xX+/B/wAxD3NzRrid5bgWqpPCYGYIYBIT nAyCfbtVERxMZ5iHYS5R4HHyoOh96LCIYlCK0VtGkUYXDqq/hn6+/Wp1uhAq26p5pX5pNoyVzx8x /kKdmJ23ZoOIpLfIAIwAUbk/hWbLAXuIvmVYY1IkjA+aQnG0hu2OfzpxTZLlE//X8xhlVSIWVt0Y xvbo3WgGBmeORyhK5TC/Kewr/frkkf8AMDK120QyoiRGRsBIj989BTIntplDQP5j5JYOhQoR25o5 JEl6JWaPzZUIjDY3BeGOO1RbGummWHdDCrglS+0vjp/OnyMC+NuV8iLv5b+dhwfUgkY9P8agv5ZY ok8gqrmQZOOQB2H1o5GB/9DzKC6muJY/OLfI3PzY3fWrtw88XnNsh+dtseRuVQcdux6iv9/4qysf 8vLsV1tVnZFji3ylgEGMszHjAHqat3lpLauYbxWgeJQxBOHXvyPy4NMVn2MMGWe6ZIBLKjNsjk2l RIfb36VfSykVwWlCM/ysp+6PcnrQaRulaxMLGd5JU3bw0JGFOM4yePwFZse2GQws2Y+u7H8/89qa Tew/e2sf/9Hz51EMWAimPZnfn156VXMrFFC7Rt/iwBur/oC5JH/L3y36CztdyNFDbTKiykGaHywW mIGFwex5PT1qa2ju0MkTOylDiVSOgB5BH4GpaT0YKLjsTtJEVZYQJSx2Io4LHkVRjie3RB88T7yk u/I2g8Y9aEkth+/2IUt5num+cOkcowFOPl9f0NaF9sjuVRWTy2bs2do54z+VOzW5HLLsf//S86uE TdGScjG4A/dJyev5dKgjiRZHkLyFfKO2NEBUn3/z+Ff9AB/y88suxasppoN4SUpHJGYnQ45B/l0q TEakgHdk9c4oFZ9ibyLiYMYnRGiTf5bth5AMnC+/fFZkbvLy2QQckd8elVGNwcZdDYLp5KOkJjCr sdyS24+vtn0qtbSPazNdeYJo9u1rNxuEnuPQ/jTcH0J5Z/0j/9PzsOk/ntkx+Y27y3OfKwMbR+X5 mtC3kMEMioyETxmMoQGz+Hav+gJxaVz/AJd3GXQzLb7RHKylAsca7VUj5T9PpU1/O1pbiRQLhZCu 4xp8y5IBAz3GecVUIprUFFiyWkU3kyIsyxHDMrN859gcfzFW4rR1i2ryXOBjG6r5V2Gosz5rF7KI xzTu0s+ZWZvlYc4xj04qCyDRxqUTaob+6NrfhRyrsPkkf//U4iNoZS25SHLbZGBznHt/9eqEs7pc w2zXOdn7uEy8mOPcTjHpyenr3r/oIsj/AJeeSRLdzLaNKFIuIt4QSA7T1GCB/T3pbhNhgmD4D8bB 978fSgOSQjrM5BjAR0XeC/yhfQ8/yqIMyEK7eY6jn3oE6baLS4cruYbsZC56duaS7mkVogQrRqpG GTPJ9DQT7E//1fOQzLIN2djdD6VYM0YKcHj5QwGcV/0EH/Lx7ElilKMWj3GQuAhU4OOlU72YxzZ2 IGjfcyqi/MR1Dcc9DQHsCpvk1HUYDEy26hS1xGV2Ww9AOw5x0qZZZGlYSoY9jlQARtbsDxQHsTSa MIsYjUmSVdyR4z5gHBxWbueXOxGQocAGr5Wk7lKj5H//1vO7SWaN5EL5ZuJVYdR2xWigWJWk2gsy kL79R/kV/wBBB/y9KkUkRpY5pG2hYhl8Hnk44qK28mPcfvYU7VzjB9aBqk+g5EIdiGxv5LHtS3CR g4SR3O3Bcjbz7UFey7lNblwTE4JwcLu71dlw8QCsRxluMYoD2T6H/9fzbe8TKiOQrfK204JrYgj8 2RVaREx8mZHxt+v+e1f9BB/y9OkUlctNNHK+DDIUZR8wyCQM1Y+y+WwmyC2flUjj8qB+y0/4A6OP zXMUi7WLYLdAO3SmTRpFKUYMNo+70z6H+VAvZISRJBB5rhQPuqQoBI69ahSIOhcD7vOAKAVE/9Dz rLPOqopznb8o5WrEyrEEEyvLtPzxr8rd+D+n51/0EH/L97F2KS26FgTBKxR/MD7sRjr2rSuBayQ4 LPHNsJ24yJOe3p1oD2LM1rqUiLzdipCmxdsYQvzwT6mnCV5GV942Y+b3+v5UB7EkaYDGxiPXFMYl QbhSrSZ+UkZOB6/rVqF0HsT/0eBgvHu2zuAZuSemPepNyxF1++QMn/P4V/0EH/L97EyYJ7ia5kiM fKKXD5CxMOeMnvxVmW5n8pYZPXlU/wBX+FAexY7z1URrnBbgL03YpIhunkkL43MCVB4GMdB+FA1R Jp3CXZZCB5pMjA8AdzUsaWUsxlR2Wd4trrnMXB6jn3FA/Yo//9Lz5bRpLk+XKJIYwWcLxnHX8uas NFaTEMsYkED5BxkxkHHX8q/6CD/mA9itiZHEA3FSqS5CsVOOP8iqbSb5ckq2OFLAEenQ0D9kRsTE XkxEwTojNt3+uP8APapYrtLlI1aMIV++Vbdu54oD2NmOkVGByQoAx6VSkRPMRN4dQeijgfX8u1BX sfL8D//T4MLCqFAibs7g+Pm6Yxn8KryCWNkDDG9dw9CM8fy/Sv8AoIP+YT2Gmw8oJIjIHRGDBShB 3nI69PapFsJMPuuoJGIz5Klt6g9DnGO5/KgFRt0KTRSwNsiO4Kf4RuJwe1Suwu41mVXQyYZgyeWS fcGpUvesaqgTKz5ihjRNxwg4C7u1VTem3eXdbqjAlArZG1v8jvSk/wAyK1HlpfM//9TzyO4M7BCu +R+ECHcc9MCrTKghKfNDLGP36SMqsGycbR16Y/M1/wBATS7n/L1Gm29ii11P9naG2ILmVPMONzFA csPbIz+lVHfzZUU4CRNk7uOQCKWiiW6M76IvSxMsCSEDD5ZCCCTt61ALm0jW3Mcxd5V3SAjZsPPy +/Spuu4KhU6plyF5L1LqITYaMboUwG2L3b86pSRrarIFnlSYSAEiMHIzyDnpT5lsmP2MuzP/1eDl v2WJEt5mFqz+YY3jCybgAD8w6jpx0qv5huYmkCyFFbbLLg7R7E9q/wB/+ZbXP+Xx0anRE32URsJo SZIgwVJDwxB9Pf8AwpzxSSN+6hnLZ2EBCeR1FNOL0uL2NTsRWs0SPhnDsrYAHXJ4xRMk8xeaOOQx xN+8fyzsj9ie340Xj3JnQqPoRr59xcrGkUspKAgLGTgY6AelSXF3NJPFAVKpHi3jhEZ8xpOmPqfT 3ovHuTGhUT1i/uP/1uFNpqlrbTXzQywWCEea0iFQpYkAnPvgUlxa38TK8UhVo3SMiJCWl81Ttx9f 61/v/ddz/l+jh6j6BHZ6rNE6rpt0ZBMU3fZ3c8dRgVGum3lxc28FvbXUksjbCptXwjjOV4BPAwfx o5o9y1hKr6fgWLi0u4NQk0me3khu4ITcM0sUkQkXaGxhlHQZ68flVO10rWLu5ijttNvrjzDwYLZp ABnqcdPxqPaw7l/Ua9+Tld/T9CxqFlqFhLJbXNpc286EDyZYGEpDcg464/xqE2urxwoy6fchJ8iF /s7ZcqMnHej2sLaGiwVePuOLTXkf/9flLbQtbuLNpYrK6vDEqtKltAzvGWHG4dc/n9ay5LO/E0tn JZXiXEEfmzxC2ZpIVI4LADgHI/Ov9/Paw2uf8w/1LEx95xdntoTNpd5p25J7S4k3IriRIW2YIz6f 5xUSWlxqSsNJtLi8cHa8NuhnmgxwS6jkcjqRSdaC1bKWWV5e6k7+hROn6nBaNeyafeLAql2ZrdlY Lu25IPI5wOafFY31ykbJaTjeR5KGMqZz1+UHGcdfwo9tDuUsurpaRNKTSrlY7eSISTXE0fmNbLCy yRnuMH0x29PxqKOw1e7UPb6ZeyRlvLBgtmlDEHaegPGep6DqaXto91941l+ItpFn/9DzxtPuoiYP srqY2O8KMZPfmrFjaXB8qNLffLcTeVbxh1kmnOOQFzk1/v17aPRo/wCYv+zq9/h/AdcaXO1y9jFD J9sijaW6gWE77facYYdieMfUVXS9sreW1sL22u/OlXZawMDbvO5OAASDwAcn6Ue3h3EsvxCdlBjL uw1JJI1SCRgctlPnRcdQSOOKj/0iIwie3mjM5KxvPGUSQjnqaj2yXUtZdim7coq2+qNOIvKaITIZ ERnCoyjPvViXQr9reTVXRhaxRsrSqRJATkfKSOjemfWr9vBK7ZrHK8W3aMHf/I//0fI7y4k0+Am5 tpYYYyC7SLt27vu8e9bJ0rXo7azZbOWSC8i+124jZXJDAE8A5zjFf78vEU11P+ZZ5Xi7fAzGluiv 7phF5ro0yoJ0LKqHaxPzeuOtaCQX6QSTNbBBEFMheeNWTd93jdnnj9Kh1qTd2xrKsYvsP7iF2vbd 5nmhdIVYKHmZYlXPTJJx2py7bsGIEPIymSExSoySBTyQ27pU+1pX3K/srGfyP7iApCj2sb6npSyX LmOKFr+NXDLj5W5wD7ZrQhsBPAblrqzWBZjbl/PEod17KVyD270nXpR+0JZPjG7Km7+nzP/S85vd NvtOt2kuJradGm/dPBOnlIpwACxbrnAx1yelZW+I6iNPu7m2sLhI/N2XT7JCMZ4Tr+Yr/e947DR0 lNfej/mejw7mk/hoT/8AAWOkvrIfZbkXUE1tdRssM8EgSJzHkEDOMnirenyafeok11rGn6J9oQmy l1O5+yrc+pXg8c9egrN4/DL7cfvRS4ZzZ/8ALif/AIC/8i5PFBbzx2J1rS7y4+z+eYba+WWVlwTl VOC3AzxVYR2gSIT3ccENzIUhe5KxRyY/HrntSePw23tF94v9Xc1WnsJ/+Av07EhubS3jls4bmxnu hH5m9NQjK22P4WUHkkflkVQtL1bgpHbXGnrcpA8zxm5jWUqp+ZmycHHpzxS/tDDXtzr71/mNcNZt /wA+J/8AgL/yP//T8f0zVNAuZ7m2fX9HtLuKMy263N4sK3mecoxwPXk+hrdfUDbaNDdyy6Ze6bI7 SLdQ3EMzHGAQJM5AGOgPev8Aev69h/8An5H7z/mf/wBWs3/6B5/+Av8AyKVpf2F+qSQXen3cM5MU UkN/HbKXA+4fMwdw7gjP86gm1C30V4xPr2gmGW5AigOpx+fESAG3ZOTjHIHAzUvMMLHepH7zV8L5 zN6Yaf8A4C/8hi6l4fMtzJL4l0m3ilL/AGa68/bbXG372xvzprS6eos5bbxBo89k+0yvFdq20HjB Y4A+nU0f2lhFvVj96D/VTO/+gap/4BL/ACNeyn0V77yJPE2gWKXUMv2WW+vlVH2jGMcnPPYVi217 BeRl45Eg+yuEmVlZWkDE/vFHdfcelH9pYJO3tI/ehrhTOuuHn/4BL/I//9TxqXWdEt7+4gk1/SSl rFuVRcASTM33QF6j0/rT31PSEh8+TWdGtY5U80C7vxbZHqueD+BzX+9H9p4H/n7H70f81H+q+d/9 A0//AACX+RHBq+izwtImv6GY0nSBlS/UOwfoy+orRkurNfNSHWNOlsba4FpPOt2HWOQqG2H1bBBw OeaP7UwOyqx+9FR4Wzt74af/AIBL/IrQaroNxqX2JPE2lQiC3NxJJdzG2hBHUbj/AFxTLnxR4cVY Zm8VeH1gkla3kWK+E8iMOhIA+779OazebYG1nWj/AOBL/Mt8JZ6t8LU/8Al/kNbUdGv7MS2mvaPe SCcxG2tbvzbwlCCCqgYK46kkdK2Ijpk9ol/L4i0+NBKV3XEdxGARwST5e3j5s4J6cZqP7Uy9f8vo /ev8zSHB+ey2wtT/AMAl/kf/1fHZfEXh6O4kW28V+HL9EmWBY0vWV5GPVlQqGKj1xUp1fTLqOF49 T0WBJpjbiZtSQw7xnA3ZPXHA61/u881wHSrH71/mf8264Nz1uyws/wDwCX+Q63utCimhOoeI9Dgj nJEAGoqZHK5ySAGIH4UupeJfCloF8nxX4fmia7W3UQ6g88MeR80kjGNduDkYAPHel/a2B/5+x+9f 5jfBufbvC1P/AACX+QkWseGLh5Yz408KWbwfOJ5dSYo467lCoc/n3qkniTwlLLa7PGvhy+M8zR3E llNMwiVcZkIeNT69M9KP7VwP/P2P/gS/zHHg3Pn/AMwtT/wCX+QPq+j28c8q6zpssUbh3mErGNUJ 4OcdxziqieNvCKSX8X9rWVzPatGtt5Vwuy43H5z6/Lnmp/tXALV1o/8AgS/zKlwZn62wlT/wCX+R /9bxuw8W+FNVe908a9o0d2GDWjf6TMDxgozJEVzkcdev41Y1aXSNGs7aebxFozzXIdjAplgICDJO XQV/u1/bOXp29tH71/mf83i4J4iacvqlSy/uS9OxU/trQbW3t5z4s0awu5o47lIbqGa6R45M8jy0 bP5UDxl4Lit5Z7jxj4djAPkBLaeV5LhjxuCMgIXk5PQYpPOMu2daP3r/ADBcFcRS2wlT/wAAl/kU v7d8IxwTNbeOPDEiwyiGJEkuYyQUBTkxbSc7gcHjA61QXxfo9pPcWN/rWmwSRxtMvmTMGkULncvy 9Pr6VH9s5Y9Pbx0/vL/Mt8C8RpcywlTX+5L/AC/r7yzpPiLwxrNzaW3/AAl/h+2by2llM08sn2dR 6hUOCc9P5VoXGv8Agpbi5hvfGfh6COzKww3beaIrnPJ24TdxznIprO8si+VV4f8AgS/zNYcC8QtX eEqX7ckvv+G1vx8j/9fx208ReAp5bizHjvw1GY5ES3naa4kt5FIJc70iZVI44Y9fTrWUureGSv8A yPnhG6bc5Hk30m9wpJIVTGGwPUgfjX+6zzzK3o68P/Al/mf85i4E4hausJUv25J/f8NvxJob/wAP XUeF8WaFEyNtkhkedQp/hXzBGVBb0z+PPGR/wk3h2y1D7Deaxo9rIt0FW8m1RJNOQYZipcd+AMHn 6c1Kz3KUuX6xD/wJf5mi4C4jjq8JU/8AAX/kb1p4t+Hrx3UV34x8L296HKxySXlxNbsuM5iaOIqx /wCBcd65mw8beFbq5t1k8T6HDBLO6NIJXJiVM5ZlKA4OP17Vn/b+T3t9Yj96Nv8AULiNJP6pP/wF jW8Z+CdQltmh8aaHC1xdmIwyrPG9tGGxvY7MDjoCfxqwfEPgcTT5+InhWODz/Lt5LiS4iLIOGc/u iOOeASPfvS/1gyj/AKCIf+BI0/1C4kaX+x1P/AX/AJH/0PnuXX/BFsS0PxG8J6tNt329vp93LNLN xnvGAO/ftSx+LfC9z5aL4o0J4biEmS686TbZOvzeWdqHJIBGPf8AP/cxcS5Kvirx+8/53X4b8TR0 jhZ29P8AOw211rwfNZ5g8aaJ9tvJP9GFxHeWkaKpIZC7Q7dx5IHTOOe9c/c+OPBEc1/BH400TzLF AYJt0s9teEY3qsiKwDDnA6H1FP8A1jyV7V4/eXDw54m/6BZnQt4o8BjTLfUv+FhaAYp/lWN47hJA 44K/cxx9ayW8ceFFWG7uPGGhZJ2RRCZpiqJwCy7cj6EU/wDWLJ/+giP3o3XhxxP0wk/uIbn4h/Dy cXMsfjvTYltolKNNY3KrMx6qhCnp79f1qtd+P/htai3nj8eaRf3MnzwxRWkwZB38wbfkI9Dzx0qf 9Y8l/wCgiJi/DbilSt9Ul+H+Z//R+c9U8d+CreeyC+LdCu5Z0GZrRpn3sQCEEZjXnt179BWLdfEX wTb3bp/bErFIPPvIobAtNbDIB3KWGByOTjqK/wByP9Y8ngv94j95/wA8a8N+KZrTCT/IfcfEn4cW 9ubmDxOTIYFkjs7vTpLeS7JbaVjYErxnPUDjrUOn/EjwTezSWSeLNG09TKGj86CeZQQM7ThDz27i sp8T5Nt9Yiavwz4tW+El+H+Y2Tx/4Lit45X8W6OIbged++V0eVlcorKpXOAc8nB9qz7j4neDEiRJ fFFnvZuTaRPcxMoOOHHf2xWb4oyRf8xESI+GPFl7fU5/h/mWW+I3gmO0e4PjDQ+JQsFveiW2uWUY ySpHBHp096rSfE34aI1v5HjK2nkniO+OCzlkcvz8qDHIHc1L4qyNf8xETePhhxbLbCT/AA/zP//S +TZPij8NF2pF4y0uVILcs222niluZBnMaq4HzKcZ6DjvWMfiN8MGMM0/jWCzkdDJepJp8shhPb7v UHOOK/27/wBbMi/6CIn/AD6R8LuLl/zCS/D/ADJYfiv8OUk2L4iluU8rImhsGEROcbQSepHNVh8U fAkztHY+I0upXkb/AIl7w/ZbsbT03MfLzxxhvwo/1syO3+8R/E2j4V8XSdlg5fh/mbOnfG74eJp9 xZ3OpNbiImV1t7q3vbhsfL8+Nq5B75HBqtZ/FjwDdyw79dW3ee4ZJL24VRZBAuQfLQlznjOPyPWp fF2Q2/3iJ0R8JeL27fVJfh/mbdv8R/ANvDHe3PjDw7NYCUrcxreeVfRqpwcQkbxnHGR36Vz9/wDF b4aDT77VZNSkaRNV8jTrGVRE727BiZSpO7aAMZOOSPesJ8Y5FH/mIR3UfCHi2S1wrXrb/gn/0/kO z+J/gFJrbVm8R+GoxDY8rcXLst8JOFQwxhmVx3zjoPxw9X+Mnwz0k273Hiaxna5bzXsdMIbyVzko 3mMrKcex61/tXPjXIo710f4Nw8GuK6lNy9ha3e/+RPH8YvhbrtnImneKJrEzowazW4himMYHzI77 +ARkHvgng1+UH7VfjDSxrAsNOvbbU7cyGO1iinWSURg7lYsODnknGeor8t8YOOMmqeH2Y0KNb35Q cVqlq00uveyP6E+jz4WZ5kvHmGx+OppQjrpfWzT7Lpds+AHu4lu5VMZ/eMSUA+Veelb1tfmwaDiG ePd5qRSruMeO2Pf+tf5UVpfvJPzP9TaS9xJFW51eWSQkvlCx2wqMqM0/+2p5IzHLIgG3aAo+YKOA Kwk7pI3p9T//1P4x9YsYrmOO8jZ0wmdqDKT89T3B+lZ6iYxCNlMbJgoxHUVzPRCirJEFy0cQE0ga OVRjeD8suOgP51TQzyI2xiPM+d9vIH0rJe9JXNobF5i1yqpbkwy7NshblcjjOP6VNZWYhWbfMyyy R7CyLgOQfrwPatiyZLpIXNu5yEXc/HH+eKo3pWYgkMEIwCeOPaseVu9jWCVrn//V/ivlUWpjVMvb tCNqocqpPY1akh09I49m7NwA77UIKkds/h1968+1tDsS97Qx57lIhI1sJUVXDYZ9zA8D8uKn/tOS dhbyAtIq/wCtQZCg9qLdDO1tC5a3OwqsitKijAUkjPpk00PvVXngMLOxRkV/NHfGTj0oApSiSUot qmZFlEcYQYLE8ANUd2bi2mW1kiJkRiJyrDbER1oFK6Wh/9b+KYbJLffIm4lsK6uRjHfHtirC3ipG LdyWZl/dyH72R2rzzdXtqPtZoLeQzG3+0XJ4RSdsa+pP4Z4rLNwyfaXikaWV5Cwhc/KnsD6UAndX NS0kecbTEYZlUB2AIUfQ/hVbVIrtSZmXzEZQgYL1wAB/KgZjW8T73eeMo4OMdAK1GeOMpMyK5+75 ijqPr7f0oMk7TP/X/iWutsqPuYsQpKKO/H/1qjs5TDEZSAsYTY4B5yDwa4U7XR0C5S8BbKh14DIf nIHTcKtwuqxR28YJff8AOx6N6Yojo9SZSsPUz2ssi3NuUikyFDcM361QhtZPNi3FlRXyT3wTSe5R 0GoLEzI2xB5yhFVTlTtGMkVnwufOSKbbIQ23y2PEeOmKRrBaH//Q/iquJ1Mhi3BCnH09qqXEsbRs qvtMY6d8+4rz7dDsjG0tSrZXMxkZT88QXq3RD7Cuo0W9sp530hx5rO4ZYJAXEpY/dA/pSUVHY0t0 NfVbODSJbmdrf7N8gSa3touWAHGR1zXmsl6qhY7eCRVaQyM2DtUE5x9fr0o5Ux2aNeKWIr5ZBLyL yyj7vsahCrbs80Y3OvQycbTRypdBH//R/ipWQRwtLCocyZdwOgbv/Ks+K9X51nyXblSTgd+1eeeh boNuBHIjkiRfNALuvDHHTmo9N0+S5ZJReC3lTIaQckjpj3zQaxhbc6CfTJLEG6WU+XKAoRnwGPqB 61ltK9vLClwrZlk2sU+ZU9OaCIq7szeijiDee0algMREjn61dgv3aeI3AVoE+VgY8GBScEg04r3k ipRXI/mf/9L+en9lVbW6t2vdPhkhGkThWlmwFMYFtFuVgcEAMQfqa/od/wCCbFhJffGGSx1J4bi+ lng1bTT5O9YLcGNduMckspJ69a/tvg7/AGfwcxDen7uT7fZf6H8b019a8dVr/wAvF59Uf2daWjW/ gmOSZ0W4fRg8ClAkduoh4XA6dM8dM1/HT/wVB1C51j4xxXy2+mW2nzaXcLFIZi95PItyVOIyflbl /wAE6ev5F9Gug6vGVSt2UvxP3b6SeJ9hwi6K+01+B/O18eZrW30nVprq3uRb3MTjS52ykiurhju9 fQj1Ir8d/Ectrf6rdzWcXkRSTFmDcRr2PHbP9a/RPpOVffwdPzZ+dfRypWyitLzOZZLeXGwqGVtm UHXFddpWpXVlADBK8Mka7UuYztkjz3FfxxOW6P6ap7n/0/4mbSWWeGK1tpppNRvLvcruAY1TgsSf rXUGyAuMyR+bMkYQyA4Arz5u6bNmveTIr8CS1tXmtpTd2V15sCqcImARu/zxXT6TcXFwkdqkvnpP hpBcYXDn0/XmuGpa5RvWdsjX7aVLZmWeSEyGYPtigUE/Mx6YOD+VBIiuJIQ8eEO0ojZKj6VygUov Eg0PV7dtQe4k06dzDJGkRbamOpx6cd67iXxINftre2jtLaJbNNtvcrGY5ZEz0POOPpn3rKLtuB// 1P5E7+eKyXZE4mvNoZYT8qKDxlj+f5VGyX0E0ENzBGiygTb0fzAdw+XBr486DTSOO3DzIWF+oxEq /LHMCDkM3btisrRrZ/7Vl1GYLbG2DZikQN54YEMg/MetJ6IDaiuriVmkglZJo5CF2jY230/LitO1 dbZxK0CyS/xI6B1Yn1FZv4xS0RqaFboL2RLSM2D3v7lktYvnnZjxuHfJr1/QJL/Rb2ONIXknEypM 7nBt1yNzFe+Bk/lWWKkvZXLhK0LH/9X+MHTLq6nvLNNSjSFrctcRNC29RwAEY+v/ANeoI7tLbXyf tV5cWsji1ntIwFiiY5bzMhcn0545ryl8Z5dRWJtXhk8+GaFGmt5WKfaJcIsDKMgdfcfnT31OaSCw 0zU7lluwrO80CfaGnUj+JgOg46mqm7KxolbQltWlgkuNsUhtIkwt267Ac8D86z4ra4jlM8Rmit7h jJOWlJ3Y6AKegPPSs0+Vm8Fokb0KveWrx2tusl0XHlOS0RTBGenXjt71cttTeRpba5G0xyARhPTA DEZ70N3dzqSuf//W/jVmt4HeS4aWaeFcg+Yu3fjPJHv6VzbrNeXjrE8sMPl4hyCII8YBFeOUo3RJ bBIw9kVk8wPh52QiHBHBzjGeK04LSa2m3NK0SyYUSg4BwelbUybHTW4fz2WVvNGNzSSNl2HqaUpE 0pnjw0YG5AOua76LtIwmtWhDfXEDSRTsBaGMPHGj8v6nHY9q5PVHubDGqrLNDE77bdS21lAHP48j 8/avQptI45rQ/9f+H/XxHfotw7CJ+GVg+wE98+ua0fB9vctewvC6gwyo7syb02gjn6+hHIIFfSYG SWJp3/mX5nzuJTeFqLy/Q/cr4AzLqvg4uxuvt9pdiK7uXk86WffBGdxYjKgYB5zksT9P60v+CL+u prVqI5r37VqcUslqrogtIZZVQZTjgkLg/hX9t+JD9t4RKS6QX5H86+DFqXjBWpy63/NH9DPxmgS7 +GWuLM6t5OmyPBAw3RmYRtgt9D/Wv4U/2ktGt7D4y+IrbUlilsrnVXm1WJH3S3TYjU7GPCt8obPo RX479FrEOGbYuk+qt+N/0Pd+lfQ5lgZ9pP8AI+aNdvI7q9hsLCzW2tNPlZHnVPJFyOCvA4JHI3Dr +Gaz9cllOl2tskYfbdl4oGGwSFQOd+Md+BX96Udj+DcTHWSXc//Q/PyPS7OxuIb+0vbi3MsEJkgH zxSSgrvDZ45wRwO/WrGr6gLu/nFvEtib2AZigjP2K02/LhQScbsZ9eT6V/szH4kf42zj7tmjlb23 1pbOe1WZ4IZsN9phYM6hWzgHqBwOM1r2OqWMttcLfXE93NFBmzjlUyRyT7lBBOccfMf+A/hXXT3s cMoq9mZdwyanc2tpfNNHbiYNLJbjZKgz69fp6Vua9pEOivZNbT3H2O1uALS5nkEk83y8MXHBB59s VqnZ3MpRtqj0Dwl4NtNWtLvXL2+gRrcFVtnUShyy7g2DyPTIzjPtXLa9FNxp5+zSWQHmxyC2QSws G6bsbug9amFdyrThy6Rsr97q/wCAqtCNLD06nNdy5rrtZ2X36n//0fz5CWqXckeZr1HhWY+aBCkc oQKNoHpir1rbXdwllEYDbak0rYKvujuFxwAD644zz0r/AGvTuf4nmRHc3MWoahZuscmntcbYd6AT AAkEs3YjHbitS4a2vY5ruD5rqY/YXRp2NzaCMDEhHTDDIBH+FMCvd6Yt3Zx319NHaR2QEReMYL8k DcRxk9ST6VXjstjQ22nfapbScZS6HzwCTaC2M0AQ6ml4bh7R1lNxFGmw7SUbaMLj1+6K7uz8JzS/ YrhluEjliDyCS3MW1jyu0emPXnNbR+FAf//S+Fry1S41DUbiK5cvbWq2Sx8KoaMkfd9fX6VUmnuI rdHvDuSRxAJZF6EdFDduo496/wBuD/FHm0sOJ8iWKN4pIxJH5wdhtQrjPH4fhUMiwTFpYllVNrNH sXc7sAcfrj8K6CbdDPkml1GymF3PcJFcoqNG4aINtJ+ZR+PWpbQiyuJbWVSYJ7VIi0qHfGpwwZD1 6AHPcNjmg4p7m9a6ja2VvEFt5likBVWmRo3PbOD1qfU57WaLTxLbNqVpIWeWazIt2tHABQMSpOOm cDqB0zQYz0R//9P4PsdLtbzekNwlv5XzLHMDskJPqB169RUulWY0/VbuGe5ie7ucHc8Y8uBQDgJx k57+9f7gH+Hc30RZvLjTdOhdJQXnudyRiI/NI4HBPt0rEjvTbzRDyDFcDcR5gxwCAePxH5047ozO 33xXNtFKtuXKne/mqGK9MH25/mKxfOjdprdbOJ5LaQeZP5Xz4PzAbvetzKycrGPHb3N9ePOkCRxw uG4YIpweABmta8muLm4w0axbDlFiDZiVRnn6YJzQQf/U+K7Foy0skME1wywAS3pizCVzt3E9Bk8Z OOtRyW0XM8peJ5kIKTgKUJyMZyc8Ywa/3Jd7H+F5l2umLBbSGW3TyFbEZL7NuSec+/P1xUdvCLW9 U3ELTW9zKr7D8oOAF2qfQ8Z+tbrzImtLm3cRafd3El0zLp00SbTaQsYo50jx8oHTccZ5961YNcga K4itNPkeJmX7PdNwseOWQ+p/woMrGTNcE38F3c2yJAFETKg27cDg49aqT3Vr9pZbuze5glG23kjO xoScYJ55HqKAP//V+H8PYyyWVvcxP5kistz5gaKJTgspIHPGRVHUjcgJC0ZYqysBGoTaDj5/cYOa /wB0D/B6qixBYxS3CXbSRzS26BYzH+7IO3jA49Bn3qnA7faXeV3MsbnB6FmBxz+v5Vo56aGcFrc1 TLEscf2mY3JcFSsJ2Sqx7njp9PzqrbW5luSg3lpHAC4JVa0Wpcl7rOre5jS6XzOZ0hW2ZlAA2gDH Sob7VFt0mghtlad1AQug8ge5XHJ4FBif/9b4iWKeQJcbne68o2yjBK7W7AHpjt/9aoFtJLLymvPP ARyxAAYyE9vf6Cv93ofCf4LJbmhJcWuNymeW4LKqxRx/cDHG5jnjFSFnkhlERRH3c5PzYxVHLUVl YqwyTyoLWLLtG2HUDLuewAqG31i1Y3NhPDNHNFh1LRFUkz2BrSmup5GIiaEkU0ixraj95KAVUDOM 9q0tKhms763huY3eR50ykQ+bJYVoeLXif//X8wDWC3M1q8RRYIWiWSMhzNIDgHJ6L/hVCVlmRAYW UxnJcE9fzr/eg/5wqsW1crR2tvHLNcb5TNOArKTlAFG0Y/rU+nwX7TXcaPJ9nEJLFF4RTwdxrSmu p5NeDdyFGETvHuOUJA9Hqc3IkhjHlkK482NiuN1aHHyvsLCpdPNkiV9j5HmAFCV5FWUaSZAh4Zm4 RscjpQZuGp//0PMtQWPyYSsaxeUmJ8ZJdh0I5/Osx4xc20o+0JayIoMRdC4l55Ax7euK/wB8D/ma 5GSLeNbWrLDtiEURWdmA33YZhkj6ccf7Jq/b3b/Z/s5jRYpFDfPCu7HUEEjI/A047ozdPXUdC9uP MS4kKpj5Sq5PsKr28NtIZBNdRQyYJt4n+9cEc4Uewya3I9mxVtcShS6xR7SWZuhxnp+VAgG7erbg rAdcEjvj/PegfsX1/I//0fMLp4V5Cn0yeoqkLfzt2wqq4+bP8X4V/vylrY/5kHQ1H2rzWkhjQmPC 4Vl+XPXgVJamQXKmUNiJtzqflVvY1vaxPsWSQyJF9oBj3ySTB/M6BFGflC+nQ/hWjMsTxNNGI1SQ hj5ShVzjHb6fpQJ0GUrcsGxgqnvzk094UDF/MYHd+8UrgJ7Cgl0NbH//0vNE8osckAZwvPJqvO8k jxqFUJCuzgYJGSc/rX/QAf8AMS6OpdihkSDeypOjNuj3DKEqe49uKozEtNLcPhWZtxCjap/CgXsU XI5phDGJy4tid0SYKgE96pzzxR3KhiU3YGexzQHsTVuG8hUjilWaEoHZ1UgBsdORnis9XEyyl0aT yGEqbTgcetAvY3P/0/PLVxqDhYLYRiMMSVX5mwMnJ7nikH2q7iMFrBNIm0zSEJnytuRn9TX/AEAH /ML7IiuAzxowzGwQKwU4JIHWo3jkjjDPG0ySDLfNuJ6j19qqCTeo/Y2epOEe1jtz5EkKlQ0cTDaV HsKJppCwBUgj5unt3qoxTWpXsUIpvbl1Nisr3MWZESNSzAqOuPalGm3JgWe6jMTuNwI5U9e/4GrV loL2UU7M/9Tz+NjtCPyF+TGMYximzW6uF2EKqkNgHGTX/QLz2lY/5iVRKMj7po/m2eWQR+FasVxt LsPkLjax6hxWajfYr2H9WKl3JFBsjtiJWZwXkIKleuQP0q1Jcl0SK8nBt3bCOyZdCKVhexfYgnlw kcaLs2go5jQB3UnOWPX0/wA5pipCUdXXc3WMt2xTbb3H7A//1fMVldj5UsRUjlcjt2NWpJ47c/Ky nC5cYziv+gJxaVz/AJivYeRXkb7WFkt8MpHI+7k/5BqSKBlQpN03CRo8/MSOmDUgqGlmWWuYVniG GRSPm+XJUd6jg2iSRYlLKp/1hX5TnOP61tH/ACJ9g+W9hkkd/mQuQsCceUTyWPt9BUe6VhCiJgg7 WOcD3qg9jfY//9bgPszsWQKQC25pGG1jx1qB9yts7Dofev8AoIP+Yr2HQneWT7K67dyysFkcoGIx k8N2P0NLBvNrIx+e2tsb0J+ZcnsKNhOjyrVEdveCeUqq7RkiNM7j9Kn8+a3kluYjIwCYkTd8o6jj 60AqGljPM5mJeXntsbnIq758YgjhVsKv3UHAFBXsT//X85NzKzPFFFyo3O20/Ljv/KoRLHdNEJow ZFfY8sa7ZGHTA7V/0EH/ADGKjZmtYnTn8+2QiNITvKXT+ZN8v8W7Az7Y/pUVxeWa4mtZlmx0O35V I6jB+lAKlK9mioLuO5JV8ecOQM43CoXCIod5QkpkMYgIIYYHJPb2xQP2HSwthFIl4GupdsBPDbeS PUCteZAAzyFnilT9yXG0Y/vD1oD2KVkf/9DzhtvKscr0B9KinIt40jwA8gDKD94g8g/iDX/QT0P+ Y/2JLbsh+VjskjGWB4PvUEgkaby/LcluQmPmx64pD9iTmERxkNGwUMHMgBUjB9aiLxmTG9WyvTOA n1JrSy5boToix3sEu2N51JgO1BnkDnOPb/Grl00Fs6yWt/bu2VIjCkuO+eeKSu0xex6WP//R85a6 AXMp+eZyTIBnPPJqeOe2ZX2XKu8fVDwxHqBX/QQf8x3sWUTcW7JOWnWEqwEQdsebwSfyos0hdBcS yosTS+S7gbivGeg9qA9ixWvrd5/KQkRBsKSAHZQeuPpViOaLZNJGd6xShBkdcgn/ANloD2Vt0VTc 20j7pXijlCk+gyO36VdiuIynnkq0edjbjk88Z2j5iPpQN0vI/9LyoahFISnyl1bd8o5Az3/Slku7 TzA0F2shRt2wqUbp7+nPT0r/AKCD/mO9iyzpmqr5skyxKQrlSZUDRSn0/lTRrcUhYIysVYg8jAwe 1Aex62HS6hEDD5cyb3GSu77vOOafcX8bBpPOjkSGX7LN84yH25C9c9KAVLyKP9sRbJYy+9I+Thsq vuafLrSW+mvJBMgWR0DycFYwx6n/AOtQV7FH/9Py/wDtbT48Ml6EnVwQUUrkdyP5VCmvW7S3Kb0b LbzPKcOw9QCe/HrX/QQf8ySopsRNbtpTIkM+9Im+ZhwgOBn+dRTavaoeZFf1ZTla1gvd1K9j5fgM k1vSCYo5biIA9/MAx61TGuWb3W2NHeJSTsjfPA9Gx/SlONloCoaiwa9Z7x9ozEN3I3ZwO1adxrui yW9s9tPueUMHhByyleOD71WqiN0X0P/U8mtfEtgkMEU93p+mrnG+5t8zAdfm2qW9h16U248Q6PF5 xjv4r5FbCyW+UDj1wRkfQgGv+gg/5kvY62syKDWtNdhbzXdvbR3jrHHdS7kEJ69gT69BUEfiLS55 /Jjl84puXcgKoSpx1x39PagfsfL8C9/b2mrbyrLtL42Bwdoi98+p4rI/tq1RfLimLyAjGQTx9TQN Ubf8MOn1+DaEkYNM68Y6qBznjiq9r4kskQsk48zzDEYmQjPbOenegXstT//V8LHiWAM8KZVwd5cH 5HHp9eP1q5H4ttFjlTeIUICtvXlyDxiv+gg/5lFR6Fd/FMG4fPlU5ww+Q49qkg8Qx3TEM8SkH5Vj j8sEUFexI7vxFaJy5ISIkjgsPQjjk06HxTYmWJ1huLe2lj+WWRCYyw4OO/r1oD2Isni2FZmG2Iwh 8lAoZyPTd1qv/wAJZbSq7LG0RVzlWGCMHse9BXsT/9bwuPxhbLC/kQTvM7eXhwAqr3PX2rPvfGlh aPEs7sryMFChS7IT0zjoK/6CD/mbjQ5nyrc0bjxpBcTNcOtvZxmFT5MSiKJdqgE498E/jTj49t1g WKK1LtzvkGCzg91/woHDD2XL2K0XjCS2ljuIoVIjcSBJEV1b1BB4qW48exTy3UUEHlC7kEsUUriR 7XbjdtKqq4JJIHYHHPWoUbMtYbm1M5vGlu0pt51uJSB5Z+zRhTGdvyknv7nk183/AB0/aih+EWie Z/ZrawYbxLZYxbLNLF5ihi7l8H6DLc4+teNxDmayXJ8RmbV/Zpu3fQ+24F4LnxrxHh+Hoy5VUer7 Jb/O2i7O10z/1/xp0L/gprbxSLZXXhWK+FndJcpeS6VZ2zwORlACykkAgHGDzWVL/wAFSr6e+mmu fh81zbW0jCX7DpOnxGQI3GFUgn1OBmv9U6n0jsBCty80LbbS/wAz/Jan9Df/AGVJSqc173vC+1rL TbW+mvnoRw/8FNfFCQDWNG8FW504apm7truwsY7gJ2ESOGPpxnsee4mb/gp5r2vzTxQeGVdYImeK ePR7G3thIDjaU4zjOORg++K4630kcEnfnivRN/5nZh/ogRjBU3CTfVtpN/db8Cnd/wDBUPxHpnm+ Z4Stbi+S3XcsGj2UKyEHDZIIBBx6etcs/wDwVJ12aK8ZPBX2JjIsjfYdI0+OMZGMJuyR74HNcM/p K4WO01/4Cz0YfQ/w2zpP/wAD/wCCTr/wVP1fVra0htvB2oNPp8ZtZDdafZW67CQT0AZhuGRhvw9Y Z/8AgqZ42jhnt4/BrCEXCyACztQzADBUktnGB7nmuZ/SXoX0mv8AwFnYvofYLS9L/wAnf+Z//9D8 KB/wVA8SQm0vYNBvIbaFDLPbXaWspV8/dVeTj0GRWTaf8FLdf1ZtTD+F9YuJJ7tbm4srh106Bg2R iMq+zA4+UL2r/Sp/SYprRVF/4D/wD/Min9DvLH8VL/yd/wCYf8PNPFWl6bd6Q3ha5hnilEtlc3Pk 3sS91RHwNo6cEnqe9ZF9/wAFMvFt0SZ9O1a1ayhW8iNgYltjM3UEKw3Y+nTt2OE/pLKSsqn4Nfoe jh/odZPB83sl85N/g20dBpn/AAUr8XR2iR2HhOW81CQGaa91W9txbliONiBODn1J5rKh/wCCkvxa klkluNOuo7a3jZBZyXcSx3Gc53AHDemWrlrfSVqW92Tfojth9D7Jo6ezh89f8/62MGL/AIKSfEm+ jv5tM0jxAmpKiwon2yG1toirD7rK4wuAeg5qYf8ABSz4ltZSJc6dM17DehTHdTQSsxwMOG244PfJ xxXn1PpJ4i2jn+H+ZvT+iBkt9YU/u/8AtT//0f52p/8Agor8Sr2dLa5tNUEU0weYQ6jhGY9GO1xk D06U67/4KM/FSOaeSw0m7Z4XjjEdzeRvb3ojAAZlJI3f7WDj1r/QH/iZHG/3/wCvmf58r6IeRR+x T/8AAf8A7Uqv/wAFGPjHLKZl0q8tJJBvk8jxH9mVCeoQKD+tQ3P/AAUD+MF5cR/2e80V2zGV5rjU nuCvHKg54J6ZFYv6R2P6uf3/APBD/iUnI0/4dP8A8B/+1JIf2+/jNbXZ1CeG7R7izb7SrakLmV5f u+Wx4TbjkcHFcu//AAUS+OenS23kJaxzFWDwRTTEeWxwYwwYZODzkgc1g/pGZg/tT+9f/JHVD6Jm RR3pUv8AwH/7U0P+HhPxtkjkWRtLsLE7TCNMha2vlHGQzKwP5GrGn/8ABQX40Rq628st3FMW/eX9 +0sUH/AZAzZ46rj8ayl9IvMXtKp9/wDwTsj9FHh61pUaX/gP/wBqf//S/mzv/wBu743XU8uoW1zo SaoxRBFDdzWylVAHzRoig9KZZft3fH0F31DUNETyZvtO+zt3W5m7hGZidwHoePYV/dL+kVmS0U6n 3/8A2x/CkfoqcNp3dCl/4Cv/AJEry/t+/GaeK9a7k8mEyeYEivjI82D/AAwoAo/3c1DP/wAFAfj9 YyxSaZc6YyaghhnSG0+yvFCAPvHOcn27965J/SEzRR93n+//AIJ60PoyZBF6xj93/AMxv27fjuJb u2N9pM1qsayQNN50krknLKW3cYweBx0qeH9vf45abe299qhtdQ0S0kVYUijNwMMPmyj8Zz364rB/ SHzm20v/AAIv/iWPhtPaP/gK/wAylf8A7c3x01y5uLm2n0HT3DAQRR28luY0BJTKxkDoTk+tMf8A bt+OMIj0291Em2iAlL6fbsBESOdrtJu5Pb3qP+Jhs6WqUv8AwIpfRl4bbvJR/wDAUf/T/mNsP25f 2hblFij1fRFtxM0sQ1KCZ7lSeC5YN6fw1XX9tT41287QSa7pPmmVpZbu3s3BIcgBVfduXGOuTX9q /wDEw+dtbP8A8Cf+R/GkfozcLp6pf+A/8EW9/bD+OsNwk2n69YM9yuJLmP7RbzpwPugPyDznJFU5 /wBsz452tza30V/ol5e2bfLJqsM19aZ7YR2PTrg8ZrKX0hs825ZW/wAb/wAjaH0aeFlK7Sv/AIV/ mK/7anx4W2iu11a0N1c3Uh1S202SW1tXDZw6JuAX02jj+VRWn7bnx2JRotaY20cTRGO+LS7HByu0 Enj19s9s1zy+kNnrfLyu3+N/5HVH6N3Ckei/8BX+ZPb/ALY3xpa/Wf8Atm1vL5LMRjz4JvsyjJ3K CGAHU9uPepD+1b8YV+2QP4tjghkhMsMFvZfLayHrhieen8qT+kFnb05X/wCBf8A3h9HfhaGnKv8A wFf5n//U/lnH7X/xs8i5ibxTDvWLbG7pcS/acdBIocLx2xx7VT0z9sj45JNbx3OoJepDO1xIbYC1 ldgDtIYk4AwOMEcdutf2BPx+z3on/wCBP/I/lSP0feFY/YX/AICjoH/a4+Ll5brcLq7w396pgVLy 2My25DZxuDA7eOnGazP+GnfjFc3F7dar4ssGmaFUjt4NLaNJSpAByHznHc5rF+Peet7P/wACf+Q1 4AcLrTkX/gKEH7UHxhKT215r8c7eWGtmIlSID0wG64AFVYv2p/i/MscTa/YWkavtRlsPtpKdwd5y OeeDVPx2z62if/gT/wAjSPgHwvbWC/8AAV/mUrj9qb4y2l5caZDqtpq1jcW3mx300UtpFbTKeMx7 jnI44I6fnpTftS/GS00KCwn1Oyivpbg3DunmTxKGAxg5DLjuMkVzy8ds/wCif/gT/wAil4B8K31g v/AV/mf/1f5UJv2hfjfbDbY+O4Y7W6VJBPBZvN5LcMwCNJg+mf8A9dbN1+0r8V7y/wDtWq+LFuyL RYlkaze2acqADuAlPJ57mv6s/wCI6Z+tNf8AwJn8wQ8B+FtlD/yVGdD+0l8bJPtMFv4le1t7cbdO KtMfs6tkkAb+/ek0/wCOn7Q8kVy2p+O4721ii22NtdWgMcRY5yMEMMccZOah+O/ECdtf/An/AJDf gNwr/Iv/AAFf5lO5/aO+MEZH2jxXDNfxfu40isBDboBwAMHNNX9oH4yJDIJPFLSRufN2mAxrbk9k IbOPrzXPLx24i3X/AKU/8if+IEcLLTkX/gKKk/7QPxZEU8S+JLsNeov7yG6lgMLAg8ck446AiqR/ aQ+MkdxpcEfiGNLkSvHcYllVZEK45YMDz3Gan/iOfETs7/8AkzKj4FcLJ60//JUf/9b+UA/H74ky MDPryW00JMgezSV1LDpjdIc/Q0+2/aJ+K92s7y+J3MRiMcEUcPk+S4438Hk9+a/qR+OPEbjo9fV/ kfzD/wAQM4T5v4enojMP7RPxhhjQt4tb7Uj4CC2MkFz2y+5iQfdcVuyftEfF2S3tZJvEEFo8b85t vtsrgDAyGYAHPNcsvG7il7SX4/5nXT8D+EEtaX5f5GNqf7RPxae3t7ZvEnmGNi7yW9s1tJKWPAH7 wqB7YqVv2g/jDqENlB/wmV1bQWh2zWxt1aOQDjOD3PrmofjXxT/Ovx/+SNf+IJ8IL/lz+X/yJal+ L/xImcS2HirULMHL3PmSNcGQnj5d7HGOwHA9Kgf49fHGSJtOtPG2pT2qTpdbSBHcOExuXeDxkA/S pl41cUvaa/H/ADI/4gpwi/8Alz+X+R//1/5LZ/jv8Ut90w8VapAty4BguX89wEOfvZ4JPXFXrj4+ +O737OG8RalBeSDypntpm8lcDhwjEgdOlf0g/Gjiq+lRfj/8kfzbHwS4Pf8Ay5/L/IpxfHD4qW0i W9v4uu75uQDqjCOIE+nlgfrWH/wub4v2tvOJfFr+be6mZ5GgWRms8Dorb+hxjByB2qv+Iz8U9Zr/ AMm/+SNf+II8HL/lz/6T/ka1r8ZviRJZhdU8Y60oeRkjSzkEUjg5+ZmOf1pbP40/Fa3jaCw8aX3k rxsulE0reu6QYY/jUvxl4pf219z/APkh/wDEFeENvY7en+RIfi38QRaeUnjXXpL0hmlnFxsjBJyE RMkAdR9KgPxu+K8dt5Wn/EPxDaIsnmPYfaR5anADBWILAHqck0l4y8U/8/F+P+ZUfBbhGP8Ay5/L /I//0P5HP+FtfE83kAXxhf3Nk0e24W+kPmTP1GSpHAPpjpQvxh+JZiurL/hMLvY4BEh812BB6Rnz BtzwM81/R8fGTieL+Nfj/mfz5/xBvhFaql+X+RBH8ZPihGJUi8SXUUyWphWeO8mjkQPwdp3Zzg9a fb/Fnxtawsr+JNV3oo/eNdyssh75+frSfjJxPu5r8f8A5ImXg/wnt7L8v8ihP8XfiRPLeSJ4w1S3 E6J9kRHPlW5U/MCCSSG74I61ctfjF8RbKz/sqPxRqSWl6xe4nt7uRZ7cnlljIbhc56+tH/EY+J/5 1+P+YQ8HeE7fwvy/yLM3xM8c2trEmm+MfFDqJRI0suqy3bSAdV+Y8L7CqEHxj+KEmpo9x4mvo9O2 lZbeAi2Z+wyxycmk/GLid/bX4/8AyRvHwg4Vas6X5f5H/9H+SWT4q/ESKNoE8ceJBajLxFrpWMZb +EHGR+Fc/P8AEfxlEkc8/irxLNdGJomFvrFyn2gdFByxAr+h5eMHE9376/H/AOSPwF+D/Ci/5c/l /kaMXxj+JkjwC38XajZwxwATwSL9reVlHyqXY5APfHWmS/GD4szXAFx4skjtmjYNFaIynLDC5LE5 x/Wsn4v8Tv8A5eL8f/ki4+EnCkf+XP5f5Cf8LN8eW2nzmXxfrLXbLtieGcxlCflztB5x1q7YfGb4 hW6eRceLL27m+zCH7TfSTTzHHQ/f9PSofi7xR/z8X4/5lvwm4Vf/AC5/L/IdZ/GP4gSXN4t34jmS 2uIhHbzQMw8gr3IYnr/s4606++IXjLy7q5TxPrrSTQiO2+zag0VvG3TcE5+vWsn4t8UL/l4vx/8A kg/4hLwqv+XP5f5H/9L+RrTviV8RrVNNt18YavLaW7s14rXX76Q7Tj5up59c1QufG/jBmZ7bxRr1 vKjMVuE1ORSilskYBAOff0r95/4izxQ/+Xq/H/M/Do+FHC0Vb2H5f5Dr74l/EGYmFPGWpQW7Rrtj gYxToy4BPmhtzZx0JqG28d+Pr2Waz/4SHUvsklv5YZtQnmnL5+9hmI96cfFfiduzqr7n/mN+FPC3 /Pj8v8i4fiF4/sIrW0ufF2s/6JGQFa5d1kOeOc5IAwMHis9PiV4suLwef4q8RIqnJjTUnjE3qOuc ewI6VX/EVOJXo6q+5/5gvCzhSLv7D8v8iVvG3iqYpDZ+KvEFiRP5qzHVJJX47Lk/p7VUvPiB4wtb KC0XxPq97d21w0zXtzfz5mDE7ldd2CADx6VD8T+Jn/y//A6F4Z8KJWeHR//T/j0HxB8VS6h5v/CU axbW6qohhtb+RYnAAyrnOTzmrcfj7xvbs/8AxWWvvC8plSM3jYQNxtz1OK/dn4ncUbKv+B+LPw04 We2HQ2Xx74ysbiW6k8TarfWVzEqLbS38wEWBzjDcE9+Kzbnx34zv7eKOLxBqVhEk/nJFYXskeSM/ eYk5z1I6Ul4ncUx2rFx8NeFUrfV0Yw8b+O83ljdeMNfkguZAyJ9vdVTocDHI5HUYrprrx54iNotv P4q1O7mKq6+Rqs6ypt6K5J/P60p+J/FLjb29vkbU/DjhZP8A3dWL8PxI8UJocNrBrGtJeNPI03/E 2uIkZW7Mytz2qn/wlHi9LUGz8V+Iba4MBjkaHWZ3VVYc7dzH1rB+JfFNv96f3L/I0fhxwq9sLH8f 8z//1P4/rfxn4ptrezkj8VeI2kiOd63xRlfozFgMnPbJpYvH/jG7acXni7U5kXi3a4vZRdLzn5nD DcfrX7S/Eziu3+8v7l/kfkkPDrhaL1wsfx/zHt4x8Tb7yFvGGuXfmBXiX+0JGFocHheeOe3tUF14 x8YXFtAIvFGsQvacHyb+WJrv1MpLHkdsetc8vErip74p/cv8jb/iH/C3TCx/H/MXSfHPiHS7S4gu 9W1bUDPJlZ77U5L2a2yRwhY4AB5wK6X/AIWRrk4RP7W1J53IgSK1laK3ZexbnOfU9ayfiNxS3riZ fh/kH+oHDHTCx/H/ADOXfVPGllNJO/iPWrrzJWlSZ5y8EG7+HDZ6A4qn/bOtxRQgeJtcmELOxjk1 ORt2/qMZ4A7AVnLxG4oWn1qX4f5DXAXDUdsNH8T/1f47H8V+IjNp3kaxqsUVi53QC8f/AEnPYtnO D3q3f+NPEN7HKW1bV4rjf1hv5UVVH8AXd0r9UfiLxQ/+YqX4f5H5h/qHw3b/AHWP9fMik8T+KHhh MGuatbzqmJZxfS75OOBjdgY9qxrnX/Es9qYdU1bUtRlhVhFKb+eH5WP8WGxketL/AIiJxQ98VL8P 8hw4I4djp9Wj/XzJJtc1SW38231jWbWfyVhaSHU5lkATpj5up9etRHWtb+wxXC+NfEkmpRXDFLd9 SmjCA44LA/MDjHrUvxC4mejxMvw/yOpcF8Px0WGiJD421x7q48zV72GOYArAJfMAlHBbeRnJ6/Wt 2bxd4gvIY7W68Q6nLC4AaOW4Bj+mMVlPj7iV6vEy/Aa4NyCO2Hif/9b+Oldd13THaWLXL4xNIf3S 3kkKQrjA2bTzjtn1rKt7si4kubi91NrRplkWBtYnEasARlVDYGc/Svv6nHfEm/1qX4f10/rU+Chw hkPwvDRt6DXv7+K6u5Ib/UYZJYjCJU1CY7EbnC5bgf4ViG8v/tMfmajNeiNw6m4kaWZABgqWJ/zm vGxvEuc5i1DG15Si2tG9Pu2/A9PDZDlWAXNhKMYtdUtfv3LshRpTcl8iUfvGByQQO1RyXHyyPbxt JIFChn9unHrXzFRbs9qjG2g6VZvJWVQyuR8w2/cPrUNmGVysp3Ac7j1rG1jSmj//1/41buSI2zQh 95EZYeWeRkdRXJ3b3bCCYFwCdjIx2uqqONy9a5ZfCyYPQeLkXwWJrfasL5YscrLj1FXVZd7CFRHn ps+UJ7Cs4L3kaKTSsiCON7MyytIJEU7lwPn+hqS2upLhXYxY/eYVj3+g/Kti4y6MtWMcr3EhURHZ zK0qgg59Km1K1WRmjL79v3vK5C+lQprqbQlbRn//0P4qzfPYlPIjSVUk2yCck7l7itF54ZFiYKAJ OAoGAua4G7u52wdzGm8qGRoWRZFfO7HOBWjBLaR25tldUZwNihQTx70lpsTJe9YvK6yxtbBYRGsf zNGu15CO5quFa1iUwsGZZNzeaNwYZ5GPyoHKKS0IprkEP9mEUdwf3xCKFHB7CoFuobyN4prcRTg+ Y9x3k7YHoP8AGgzP/9H+K27ubZ4oVt1SJYotkhA2ruBOTWDHLLPIYYyrRA5SeT/WnPX8q886B/mt bkOZJFOQhTbkSDuP/wBVSTzW8d9GEzsf/WZGWi9vQ0CWmiNz7WYIkIVQATsUDLSVnXGpLiPEjq7S fNCx/PigZYSaOdGLxM4xh9o5xWVI7tKsRkKW6AskWNoGeOR60GTVpn//0v4mI0ic4YiMgEwyYwkn 41pSWltFB9xfNkX50659Ca886Dl0hliuGljnVIZcxeUCPvD1HYc1u2FxbQSpJKrzBWKMEXcAw9aB NJi3d0ryMr3BmO7ejP8ALsB/h+gqdbvcjskaM+3YrE5AoGRJ5EUb/aZkd252b/mB7YrnIZ7hLwuE 3bpNq+Y3TB4NBtD4Uf/T/ioMEDvvnjBLJknORnrg1WuLeSZzM8UUIPyxqmVUgdM155321IBbSJA4 hIV8/O5Gdv0H51oaXGtverqQJFzaESW0kS4fcB1P0xQXFe8i/PrFxdyyNLI4ldizSN3z/Wqbi1S2 Zk2xKQchjkue5/Og1aurGZBJIs8blQYV6DHP0xUt9L50sk23ejfNKv3BQZuLVkf/1P4p9PktzH5Y A4O5ADkY6YqC/tIZ5GWHKzFM7sYAxnj86889VQs7kdtbXMiq0+WjgXG1j8zewFSLHEGjdleCCM7n iHyvxzxQU9mX5Ct95KqHdYW3wox3J+NR384m3yyQwxTxjaIoFxHxgAge4wTTtrYwCyaWdUWVpI2Q 8g8Ar6j9a6+xjRri3tlbfE7DzXboo7k4/pVqNppFT/gs/9X8Bv2UbC4OnwuthHdEad9p+zW0bW8S KSrI7q3ThVyD3/Kv6T/+CVXh5734x6tJ9mCXkUNi8F9Cp8y2hYJJKnI+XJjIKj0Nf21hpLB+CFer /wBO0v8AyWzP464SpPGePHI/+fkvwbZ/XLryyQfD3UnZs3C6eGtJMbFSMYB3enFfxI/8FC9Sg1/4 2XmlWl1cNqNteS3FkWt9lvHEZTHJtPoxQAHtzX5p9F+m3xLVdt0z9a+k/WjHhtRfdH4NftW69bHw 8loPtHlaU0tykcLBpLlZGCHcB3+XIT0xzX49ajBdeSxlYoZW3Mv8YBORu9+ma+l+k7VX9pYSl2Uv 0PC+jxh3TyGpO29mUbCzfzYpSwRVkwyMf9YMdq7S0js5zDDLKtqjSEM5ycgDPPXFfyDOW5/RaT5n Y//W/ijiSW2nhMcAS32fJcdGY9OPX/8AVXQ2eqW0ZdHkUzIP3nmD5mz6D/CvMqaRNo3tqXljNxMz +YkpbG2LPyAY6VtadbtbQJI9osd4kpKmIl1Iz8oOe9cE27FFy41OYRlwzw3rq0TPGu3bkHBH51m6 QmyO6mmie5dMG5v2QmQnJwMisQOoie1k2zTLGXhGFmmjWSMDGOhBHArZl0+OKFlsLiK6e3tvPklU bRgjd8q9TjOMD0qHBWdgP//X/kIBm1OOK4VY0mcBAWXYrAHGD6dDWzeXM88Wnx3aQ28unLtDQgl5 hzgMfavjzoHSSeZEjQjeWcKWxjb6/Srb+UsQjePzSvInHG0/5/lQHkcrbanHcahPHFbXMbwYK3RI W1Jz90+v/wBauwtrq5vbqNWNtvbAYIvlw5Ue3TOKykrSM2rp+pd00PJMftTMlzHcsYmifaYlzhcG va/Dkd9qNydkhU/ZnhUovmSzMUIAI9uD9RXLjNMM35MtaLU//9D+M+xsLmW91d54bdrIMrJunMUs PygHYAe5571nLeJYSTTR20I+XZcbk80lQex9fevKgr1GebW1dynaadO9pPqV5qwuFluWdbTeENnH nCZj6+gz3qzoEDLq0uo2l6Yk063aYrKB8wYbCCOh+90onvY0iruxvKljc6feWst5PItz+88l18tg 4bKgKOg965wXyWmotY3n2ny0iV4HMZaBs8cnpx3qDeO6Hz30xZ0i1X7Eu8y2hsI/MZCP74P0qa0d 9Rs4WinEl9CCrSSpsMpDEEn60HVDc//R/jY0eK7uI7yG7iYQWkgZm3fu2z0x6irEqWywyxxHZOc7 IzgZGeo9hXjnQcut0UvfstxbyPGejSIFt3x1BbPetzUr4KxguQg81hMkUYzHCABgD6cfnWtPaxE1 pc2LC9E8giSITQugRpWTBJqK7ury2vlsrSxtzaeWTLcPIVdGPQAdPrmu2mzlmtTFPm3EiGZ/nimD OnDBsHp9Kl8Sw/2rYBbrFs7MVhMADngfKcHgdP512wdkmcslZtH/0v4WtYiurbyreYvgrlCx+9jj /P1rs/h5NrF5rGk2WmeV5trKby4WQ7BLDEpL89OMBuf7v4H3MK7VYNd/1PFrwSoTcu36H7ZfAq6u tf0W6l1aWSzaaSC2Gn6LAIre6llXCMxGOpXbwDy35/1E/wDBFXVbTS9ZlsY7S7tYdP11xaW8oKzS B4I8zMT97dlhkcdK/uPjOTreDkpS39mj+avDN/VvGeHLs21+Z/VF4zg8/wAH3trHbeZDe6Y4aCdd znchwPrzX8Of7c+nR+F/i/q8y6dNLJ4iuGt7QyRbIIpYd0T89QQqxnJ6kmvwn6MlV0uJ61K+6/zP vfpS4eNTLKFV7xb/ADij5ESxsrvTxI8LM6bree4hkKBHK5UHI6jnOOuKy9Phs4YIBczJe2+lTtNF DcN5scjk8owBzg45A/rX+g+H+A/z0xaSqNLuf//T+AH1KBopXuIfs8ksjSrbRRMI4kLEqFzk8DHW pdSu7c6THJb2gu5o4BFBBvMUjFnySW9Rknnjiv8AZlaM/wAdZq6OTa9uYUW2kV1Uvho16qDw3WtK 6msYVitrLJWFvMM8kZVps4wuOxBzzXTB2ZwuKvqdPcW1lLBa393YWdm+pwL5Lxuwt4dnDADPU4yQ c9KW/tm1KOC0triGa2tlDJIr4SQ4HC5AOV6GtlqZygktDFsvNs9ZgP2qbymUW7qrnagyPmxnBIro NW0y8u77TZrS8gTS7lzJd3dwfMeWNcbtqjJySD39KaWqOaUbRsf/1Pz1jiQapO0fmzb7pmtLZ02F EHQEDr3NXpJWnljsImaO+uJPIhzn5WYV/tdFWVmf4pOD6EMUMumWz6PdRQXmrS3IjjvpXMJtuctu PQg8DJ9qkt9D1BLqxvYVjuomiknvra1l8x9kedw9R0znHSqWhm0WoE0i+kubt/t3k2mS9i0e+KYZ +XnOPbua07GSRJjcWmkKdLaQDbb/AOji2z0wp+lAp3toGpajI119rjs/sflMIxgGRzjAP0PSrMfi PX3tdTWXVbqKGC8SG0lOJI7tcBtqtkkEEjj681tFLlVyldKyP//V+KNN0TSbW3e9vxc2tze3ckv9 pNcOBeyOMlNpyp/Acelc9pV6IdTe0KR3+j3aTyTQ3Mu0Xs6LmJoS33Np4PruAr/bg/xNvaKYpe+1 e+S41FooBFD9mhtkn3xxKuMAdjwD9Sa6zT5ksRNiGF0MRi3XMYkjOQRx6EY4I5ro9SOdnJ6my3dt Lby292pzhw8RjRMPgEMOxwO/ese0jnLul0g2Bh9lkQksAMcH8qDmn8R0Oqqt3a6WsB82WwV3WJpM KzEfdPoOTSWdxP5CytCtgXXY9nHJ5/lNgAnd+ePrQY1Oh//W+H9PbQbG0uoBfXdzqDMPJja3LMjO Rgk4xtHPPOMdeDUlo4CzzSQC51Fw0YkOGMa4IBB9fav9wD/Dcx5GMluUClpkk2SCSMb4sEHdn/Cr Etlam50+6X/iYPFKEYnPyMww/GTkDn64FVFaoT0TudHdJJb2mNOg815WKrCrfPuPbH1rnEutRtZZ rW5s5xJPAEu4mkMOW52sgxwRnj/IrYyiryCwt72G8igmgngLAFoXBMjA9K6W6sWlLq0Jt5QxiE6S 8yJjByO3Uj8KA5fe5T//1/hux0e9hmaC5lmbQ5igWAZNuWjcOCRnOR2qzrVxZ3uoDENwiwEBoyCL dV/h2j8+/p6V/ubHVWZ/hg1Z2KN9fxRC6hjiu5p5IV+zIYz9nGCCSp6cgYwKnv5Lm5ltEFiyxrZ+ eWSTesRwPkKdQRzkmrJaurEUFrNIoma1d4lTzLjPBjXuTj0ro9P1m3e0ksra1SMs/L44cD7uB2PX JoMCrqcWnx2RW51V4r+6jb7HaR2Mk+9wwABYfKBgg5JAxXPMjiCKKcPJJG4wVyu3P49KCOdH/9D4 kgS1jjYOu+bgowOQvrkUrWStDcXrs/yIN/LDykHHHbHNf7oH+Dzdlc2ILS0ksjBZ+T5yxrK8jv8A PGM5Jz61UhsUjEkl6kckbt+6uIXyxHT8DntQRB9DHma3i1az0yAtO+oFltpRGUKsADhvTPArS0LU f7Jv7kXEKoxtmiIni8wkPlSAOxxnmrTaaTKlJJEU3kvcb7SQpHPlULAsi+revFPVpZp4LVlabEoi DBPnbJA4rUxP/9H4/uIJNP1RVF5EYJbfy4YHj8pomXru/wBr6+tMuZYr+wurJpUWaJzLBeBPMSOV BwuQe/TB45r/AHbg7aH+CnOrlmzm0q6tkW1t7mG+mjJvmuSpXcpKgrjtjB/GoY4dJtFkjkkklkd/ 3r4247YFamFRmBc3Q0++llsEeNy4MMrEF2A6E4q7bw/25eRGFY/tUhaaNXIw5AJPJ6//AF60g+h5 ddas0r1zo9hcPMGN7Ay/LwABnBA9+RSaTcvcXCSushCOJo23bXVuO/pxWh5FaB//0vF7ZRJMzzEx sUMjIG8wA4yMfXFWDdAWLzeX5wjuPs7Qo4SdCR8r7e65zkj096/3oP8AnNrQ0KwJWIbHKztkgkZV fTFSWkh+8bicTE+XcRKNkTDIxwOtaweljy6tK7ZoXFpCtzJHM6W8lugbYD5jTHjgEZHIOfTAqpcT vNJudsoiCKFMACJR2H+euas5fYpou2+y5tlsYVb7UzEyZcbcDpjOMfjUVoYVnMFwS+xvmlU8xgHk EUEexe3U/9Py28uVklka3Mn2ULtIl68df1FZxPm4dQojDYAHYe1f74H/ADV+wdtSzcW2nyFre6u/ K+aL7NcJL5cZfehCNxn5unHrU1zchHjibaj/AOrwT8xP40LQl0SiW8qRmkfJyf3eeRjitGBbaa2a 8i2C7tZVYmQBlVD12jPU8/p1rVSu7E+xGqba5O6G9VhvImjKkNDjGM/X2zU7ssMCuro4bIG3k4Hf /PpVj9ij/9TyEuJGYDMu1dzLHyQKrpeIuJI3zGh5/u+wIr/flaM/5pXSd9DUiu7q/htnvJ7cW1l+ 4iEVvHbvhjnLFQCx4PLZqndMN948lwZ7eKQhZ487cL6EdelaRmnuZ+ySfIl3NGyeBsysybRGOHOC c9GA/wA9aS+1GBwPICJHGFRlUbRkDg4/DNWHstSvbXMLAEv95tqnrg/5xTftUbTtAxzIJPLdFb5n OcYHvQJ0vI//1fKjf2MhJi2iOM+WzE52kAZPH9Kkt7rTzdRK7LdQsuGMUhXGeOv9K/6AD/medF9C nczf2OLmJb+RLl5toTBZoU7gr05HHvzQb+08yNrgt80fmhQoUcjIYj344oEqGtya51SzWOKRZhMr naIl4ePBxz2rPN6pmKzEFwwAP3jQV7A1Lia4tUTz4TGk0Z8jeMbxyM/hUNgpuSNwGzJDFWAVdo3N nJ9OaCfZaXP/1vJ4tUto7SWK3ciB5PmkUkAnJBHXr1qIa1a2SmNLktC4AyxK/MQMg59Dx+Ff9AB/ zO+wS6Elrq+ntKWvJXWAtgyRkFo/fHfntWRNrqQht7FWU7iGGPlPI49x/OmnbYXsXfyJx4jtZ4I7 lJQ4IwpD5JI4PHapU15ShKEeYxx6sB7U1JpWRXsRv9vaYCYbi6hM/l+Y1qk4iuWUdgOo9jinw67b eUqQmVIFI2QzSmSVPTcT1pqbW4Ogz//X8Xutdgs792W6R7dXBEmwlNvUkjv3/LvToPFFjfKVtZxK ykbFG7Jz/Coxxzk/55/6AXuf8z6o9Wgk1bTF2hQxm27mQsAqHNRP4jGUEUfmRI4M69Ni9zntxVQa V7lKkhE8TaVBA05xJKHO2ViyiFR1+Ujk/wCHSq9z4osri4ht7WWK7hmRZnmQFWQYyy7SM8E4P0pS ab0D2N9RP+Ent7e6cJK0kGPLklxwqjHHPPb9Ke3im1NzIEQtBI5EG1vujtk8/pmpF7HU/9DxNvEU ojZCTKy8oRErvCoPTdjgVROuQSoyy8Z5eToif1r/AKB1Z7H/ADQexH2/ii3t48LbynacK6upL8/e Az0x7g0jeM7WXE6s7oH2sWUxs2OD71k9XZC9l5FqLxhp6xMs0KvNLiSKbzcqiA4K7euScUweLo4l VseVFNdGWK2lk3RnYOML19eSSea2t0JVC2jWgSeLZLqeTy1KQSMZ2K4ZQRnav/jxqa08ZackLq8B kly371wxi6DAGMc/pQP2Flyo/9Hwv/hPD9nDzWywvGxBzIWDr2Ht/wDXql/wl/nZmEKBWfKhHJVF 9STzxX/QNL4Wf80PsdBs3jKFcKm9oSBiReVfPtgGoj4x8m4SOG0nMEg33MjSjYQMHAHbPP5U1tqH sOjIx4vF1dGSyt5bIZx5co4X1wfqM/jUlz4wuIUS2Ee878vLnaWBx19cf1piVDWxVvPFt0kcYjSO Q8BVVdrnnqzVQXxJqyRi5W12qbvbKzSb4ymBwBxtP1J7UFqgf//S+drjxpOSLi1iaGN4TDPDtBeQ nHOfz/OorXxlefZ/s8sUMYWVpFRU+fJ4G5upxX/QQf8ANB7FDF8Q3ILXDRGEkFMqRKCDx+GarjxD eSR26u6qyRH7QnlgMzZzncP88+1BXsNGUrfxFdymVoGIIcBjNEVKgdgDg9utNl8W6zcTXCu8S7UE UU4gBcEd+eM9OevvQP2DWjRdk8VarL5TPdCQrbrBnylHC9Men/1+tLZeKdTWR0gG0R/vZbiQidH9 ijZH55oF7HW1j//T+Yf+Ew1Oeaa3unhitpGCvJb2ypMwBzhMcL26Cqk/iC/MoZJSY8hVWQZcKOnI 74H6V/0EH/NGqFtAufEGpXG5pLlzMy7Fkb5nGBgZzUMWvajHHHG08kpTAeRjiRh3APbNA/Y6W/Qf Lq+sSBWt7t7YB92+RwygcjDdM5pf+EovZrc2z/Z2li+SSSJdjHnPXPegPY+Q+3v3ST7QruHYBWQs dvHtUTahq1xNOkCTXKeYqBIEJMeR0B7+tO7WgvYH/9T5WGsatZ7kZ8R7PLVGT5kzweT0z7U+LV7k ETrv3D5flbBcfX/PWv8AoIP+aH2PQzrrV79fLSSVmyxZ2xtKg9B6+n5Vbtb+6ET+VMf3qlcs5Own jcOeCKA9jYIry9inif7XJ5kfDESFgeP88iqjazqVtegQ3U4jhcsgMhCy5OfmXv8ASgapJuw+S/vt QyEmNvIG3s4O0H0AHao5A/8Arrq5YzW5xD+8bvwfb86B+x8vwP/V+U9Nv5fMnH2v7IZozE87scFe uMgGmzTSKhe1f7SVO0ndw3PXNf8AQQf80Ko6ldZLu4mMss80MlkxWSFZDGmGHAZP1/KrEN40TqoL KobJCnG71oLdAsRXs7TXJVZdgf5JGOQPaqlxPILaZt7hXlMsr5yWY8ZJ/AUC9h5GdZxz30TyS3mI o02MmAjSduoqyjBbWO0UP9njbciM2QcEnnn9KB+x7I//1vkeR5iyFnz8u0c8Cq8yFoYwshTy5N2F PDcHiv8AoIP+ab2JbhufLgMIdh8hwAfvH3qjJLdtAlv5xXau0uhwWx6VcZcqsUqPcyLm/aCNwu+W VBzGoyTir8dzIUguopZ7ZvK+aHftPIwwYd+p/OnKSa0K9grXZIZiyZDszM3c5PpTZbqUCK1h3RyO +PODBWjGPf8AChS91pj9hof/1/j+9kuFeMSyfaXCrGbkDG8AAfoB+lUlk+zmRYzuBJbPY571/wBB B/zVOjoXYpfOeB7gllU4Cjt9PSrFxHLhjC3lKT1zhsfWgn2KI0nZVCSOW7Hn9TTWLLIVDEY7A5Bo E6I4XGG2ljkjBPrTdolwBlRnqOMmgFRP/9D4/KNAzsS2c/MQf8+1NjDyMApLlhnp6V/0EH/NR7En EBlVmc48vqM4IAOM0nnLCwWN8+uDz/Ogv2H9WLHlL5YMT5Z2+WEc5zUAkLkJhsBumcKpoD2Pl+BY i0+6uJD5EE1w69UhjMhA+gqpcrPazSQXEbwyqQGikUq69CMjtxQUqFj/0fkCIMgdy54OcDr+FWJY FuIllGH55JGScV/0EH/NeqJWe28wq+0OqYJXHy8eoqJoef3eUI7Lx+VBrGjZsf5s64iMTMpwq45L E8YqC4intXLLE0NygwUlXDofcUXV7G0aGhWMsyW4WQb5X4kKLtLH29K/N/8Abm1C8FjMNNtlWSR7 eSS1uJPOktseWkmDxkjazc/3sV8T4iv/AIw3Hr+4/wBD9p8BKfs/ErATj3l+TP/S/jGlupYmkcyY 34Ejnk8cUyHVzbmSNN7GRMI+MYJPNfr+Kq2qS9T4Oj/DihsupSrGkYZzLgiQfdTnpxVWITWweWFn ieQYbaxG4ZzXnuab1ZrKNrXH2wDF1mk2JIMySHJc+v4VoyW9vEz7DGyFQEZTwQOn+fesKk30NIQ6 mZNcGJmeOMB0XCqDtVscc/Wqz308quXQZYBnRTxHWPPI6ORH/9P+MOyiW6eOJnUMMN8x4HvXUC2a wKENHL5vKyIcqR/9av0CUu58tGCvZGRq6i7AiGOp56sT6fhXNQaW0Kb3Ubi/zFOrAdM/hRGba0Oi NNbI17ebyTKLaUhVjBcS8KG74FXJ7x/K2MC7uPw+tXzsuVOKMwNNCpCqyRk7mxxk0nlySyK0o4Xl e+6k5NmShZn/1P4yt6wuGckDPysBkrip8yzMX3KFHK471+g3fc+fsnuPaQCP5jnnqOckdqhg+0LK Xt9qBVy8hGWXn070OTSvclxidSNTRrcxTwpLlAA/KFCO/wBOvFc3qKhyAEG/GQF6gCsvaW2HZI56 2+0zTyW7bWzkg5xsAGT/ACq+Lp7VY7bGA7ESPnp1xj8cCp55FSjHof/V/jIimW0mjcqskrceaACV XrWhJqMEo8wP+7HyvgdCO1fdc8j57lXYxrZBcCZ4o/IjDnyxJ8qtj0+uKeJ5ELpImBs2qw9elXGd 9xOKtoUSs0ZJJeMOdp3DaTWhIfMtzGJN4UAeyGqbS3MSG0uxbh4iu5y3Mg6mrIuhM0wEYxGm6Rzx x7UXQH//1v4zI0Z/LZGfYOQqjqDSyWpIZpGESkFsnkn0H41+gbbny5Jb3UkMZ2ooC4j3NyV//XU3 lRTqZpiy4U8qMqKxk7sLEEMtrEgzI5GThQPu1k3DyNvaNgu9sqWGVGPasHK0tNhqLZf064kZmwxX B2kEbVc+gpZhczXHlsG4fEgzjaO9PnEf/9f+MlbE7nibKtu/dvjqKmjWIXU6ptVIowDkYZj3xX2j n2PlyT7aIT951QHK5GR9faq099HJ5bIQ8iyEcr1B70KfcvkYyUT4jkkmfbkls9DntTVliR03syAH KEKSrmrVRW3KUFawst4J3a2UOjAbk3qQj/j+FWpmEwhgLH7Q6/KDzjGMioc+w1FI/9D+NhJvsUDL MDIUUiONTwCe9Zv24zGNpEZQT8oI4GK+vbtqfPRhrZHQ6Zqh+0L/AKkqo+ZWH6kVa1i9vHtJ1t7p oQSCVjOGYelZN3dymmnZnP2cL3NykksgJVcHPU1vXqPHA6HKlePQn2qTNxbe5kLa3LIkqAbWOFye mKy5LVkui/Am6gHnafUUB7NH/9H+NeLMUbecEcgclOjE/wAqqMzxliiBYzyAT92vq1LW7PmZRSZW iQgeY7KzbwRn5u/pVqSeUZ2fvZG4iRm2oPqfShzfQkheQrLGl0QsqLuZY/nVM9gabBvhk3tK0u9z hQMADPpQptbgX5LxgTJHvOz5WX0H0qRL2ePHlIGc9W3bWI9AKTk2wslsf//S/jRuYZXHmEkcbij8 YqjHIUGdgDZwW7jHpX07aW58uk9kIp8643R5wpy3PC1dnni/dIjMHZ9r5XI+tWpNGns2OtpTdG8j aORRbuFiYjiTjkitKCya2hWUAgM24l+OT1Aocm9CXForIUjuHX5stgoAPlOewqtNb3JeQhFVw/3s blZfTPripJP/0/4yVRmZYixUIcqDxg1VMxLOnKsp4I6k19TF8rPlyNVllllkXPmbQCB0OK03twYF DSAyAZZBzQ23oxSvbRFR0H7uIOjEDnHGz6mtCG3/ANGOyPam/DSYyCfWkCVkSESQH7PHIXVRlXA+ X8KoSGWR1XdvJOFCjB49f89qDansf//U/jQ3vHENxLsWwq9h2qeO3uGmRPNRjKBtj3AAE9Oa+mct Lo+c0ci3FbLAjJLLF9taYqlsAd20fxE9OvaoLfT5kheS8kQSNIzKgfd34HsMYrJtsfJEjlW3lmCJ lDj5xnPT0qJoEDLIB+8JKruXJAFIiSV0kVJEKKHLEhWI+UYDVPZ6kNgjnY7BnanUJQaWWh//1f40 oZMEywyqYZCcqT0PSpFlW4WSBXQuD86q3OM//Wr6G7Wx880nuUnhkWQIG3H3/gHpiu60Cy0O6tXW TWrWz1ZFdxBdsY0fb0CsARk89fSjmktUHKrWOb1mYzwlstmL5SQNw+oNciIZXRWEpaRed/QjFNSk tmTyIcZLwDd8ylHwsmMAf/XqxLK00ZWUhpAM5IwW96tVZLcXs/M//9b+LWEqMAL1/jPAXFasgaCB LjeZWkIjRF5QHk5NfT+0u7Hzap9zOhlkufOF2joPN8uFVGUwByfbtT4bSSBvKiZmGS6AnnPf8KHN p2HyImtNPfVbxreaaGxzGSt1MfLjQqM4yfXH49K0tQ0y1s3gt4wtwy2+9ruPlZmJJ4+gwPwo5m0j bkSjoWLOGMxPbBv3hXe6d0H+RU7xxwRLlwpA2n347UybK17n/9f+Mv7RKXaE/wCpU/umHDnPXNU/ JDO0cR3/ADZYsc7cV9FL4meAld2K2yWCYyxPLCs+IZdvCkg8Gr9zJJCybpN5VAcDkNn1qTRwVtBR FI4EjtH5Mq7o48fOD/kVf0+5Fsu4na+8rhh0P1oMrW0Ld7r9x5ZhleRrVfm2KPlB6ZxWbFc2EjBd 7/MpcMBubOOAaymtRpa2P//Q/i+e8aK6jMKuHQ/6wnABzxx+XrWnbyTXFzPc3DRjcoCJGu1Qe5/G vYPHtbQfPI/llokd1VgrhQOefX9fwqtP583lxJjDD5gD0+tAlFbWKlyDDGDJkbc4EfO/H8659zM8 JvVDRIrbcSKY2f2UHrQbxiluFjbXEjiVicF958znFbtuUllaA5aQNjGcAY96yk03oPlXY//R/jRv EigiZpV83C7eDlB7muNkm/0iMQRv5cjkfvMhQB1x/hXbU2PNjDXQ6C3nDo/zbtg2n+6D6Vl3avCu 5CoDncx65FY7NM35FZobBj7qsGVhlAx2kev1NXonMRAZjjO4egrnezCMeXctm83gKEIjJJMy4ZDj tVW1aSa6lZOIlXIJ4z9BWUuhdrbH/9L+L/7IYLhJ0eRSrbhzxVLUUkIjKum55MSu/Dkc9MVyy+Fk xVkVEMMLtGju394kfKD3FaFsU3bMYyM/730pRWiKNGDSkEsR8xFWUs2+SQbRwT82enTioIJEdyFM ZSLIIU5yff6U5OyActx8xRQoRupAw341mC+IuSbe7ZLeRSk0ePvHnrWJundH/9P+LGSyIHmfKUxv JY4/Sp4YbUp++kGNnyhGGRnoR79K8+x1RfKUIx5E8Y2l4XOxnKlgB71p3sNsBkRqkka9VGCff+VA ru9zPaWWN7ae22LtGW43+Zz/ABD8K2fPW5tN00MccnmFi8Y2pjB4ApxV3Y0ntY5R4vNmkeB5F2Tb S2CpGOwqaOJlk+bc7k52no3tituVdjI//9T+KaV/OZY5YiqRpufau0HnGPrwaxpLbfcO9sJI4klP lgn5gOo3GuRwTdzoHvbTmRZwdwRv4qmjiQ7mkRFVPnL4+b8faqaT0ZnKVnZFk70aMSSxFWj8xBG4 kAHbp0PtWdOhuGjmjhVtkmJCgy7DI4x+dFlaxaaex1NvFAtv8r7RuChjwFJ7H9aq3ulyG0fU40WS 1t5fIuJAw3R/h17ilyK1hOKvc//V/ik/sHzZ7Z11CSXSxEJoImwkStjLDPUc8e+Ky7q5khYQxbjg 43YySB0H6VxSioo2g7oit444mE7KSWYgBvuLxWu9hFBbvPBcMiNiTy0GQe5zUFGBNBPczDkADq68 AiiITWshjDOyEbmAzsHuaAHKwunTbHhy21nXnIHStQadbqokk3PMoJCMxUH0oNIv3fQ//9b+Ki0y sXmGNUAYDy3GfrgelXrh1eL5VX5BuUEYx+FeeegjHeeSTiNlWM/LIOm496abkQHEXz4GD5fOPegq PxIuCPz4Ai8Fur4+YU2WyUxlcBYLaHdvz85PfIoNiCIeRbS3DbTCME5+8PcCo47Z7ppmUN5G0EyM MIc8gUAf/9f+JtL2z02MkRNLKziIxqvzjtkCrs0c08kM8CZVV3vsHzYx0IrgSb0R7BYRLgRxStHI kUuQGIwFI6g+9DabPqETorsiqp2yAYLEcYNVyMT2ZCsZsxDBO20qoV3A2gkd/wA6cTZNcB7lpRu+ Um3G84AOOM4rRRs7mBE0hHlCF5GiyRlhkp7E112hSyW93p8SOqTXNwsKPIpfd5jYwF7n0FXGL9pE itJqlL0P/9D8TP2b9JlTRLq5nLNYSafFZO4cQ3DMX8yNyvXkhunTHbiv6bf+CSEaS6/qWrJbvBcx 38Fvqc5iCvtjjMduiDp8wbJPcnNf23nFN0/AuUV1gj+QvDiSl45yqvpOX6n9PPxEN5pvw61ALIqN DYEXkknzCONo2Zufrj86/hV/bj1jSNZ+LXij7PNcS6t/aQuorWVDF9itEDr5SEdizs5B6lj6V8J9 FihKpnNWtHotfxPuPpWYmNDKaNGT1lJJH4V/ta3+j2GnW4gtry3vbna7IiM8QYu5DM5OMcJn2J5r 8udUnMscxZcszkc8Y57UvpLV1U4jpUk9o/met4C0XT4ThNr4v0uZumwkuwcszKuYhnABrau7K6R7 fyvMEuRJNII90TDptr+U57n7slqf/9H+K+1ms/s8MBmuCUiBCOmFRzyQnbGaomNhcA7VU7gRI56f U15VV2jY6DtdEsFnD3SuDJ9xVUdOhz/P8q6GNpLTZ5k0oZGyzOAHP4YFcbWjHZ3saUFpb6gjsSQw +cbR86gd8VDJZ5LR2crQwzbUdMkCXB5LD6jPNYA01uaewQQlVVGCDAJw2MeorJl08rcW93BJIkjj a8qORkehA460CP/S/kFgSW0IgR7gxMSSzr5hiJOSy/WtyOC7nsBeR4uoo5PLeRh8x7EYFfIyVnY0 k2nZDNCjjvPt4W4Cwi4YLBnIyOCB9Kmnk+yYjLiS2QkyDq/GeKki7M7T0iuLpbK2gkhl1BvMeO4U osSE/fY9gM/rXW2rWmn3txbC4tp0hTa0tr+8Vvp3z9RUtbsI7pGna2yPeRGJlkWZ9zyJjdGvqw7V 6/8ADW3B8SpbjUHht5IzGyFc7JGZQjA9RkkDA9a8/MW44GbXZm0tIs//0/4/G0uCbTbiK7l8l5YC WWJsCQDoM8Hn1HSuWUWkEoW8iljtgoF0YEDzhB0OD15I/OvJg7VWjhqR92yKcumaHc6kyLc3CR28 Ykk8ogxzI3KhhnAPXp0zWclrBHOBHMfInl8mWDBDyIem0/X+VJu7uOCd7ms9taiUMsMqXaDYshf5 GHbj/PSnX7XI0e4toY4FvrobBdOSWVcjKgeh9aRrboZf2eSCGKO1gg84RiOeRhgyep/nSxtKkc3l xmExfKZox++cHqNuOnUcetB0bH//1P43tOlWW1uA1xHHLP8A6KIfM2OMj7x9Bz19afdQRrLFaRyr 5kaYMv8ArAAowcsK8crmaIHt7aSMpdSELD8wcLnnnH4dKxls7mUTvLIkolfERTrGo6fXpWsFoJtv cu2lwNBsGW+ulea5vStnbj5WU4HfGMYB9+a2bKz1Eg3FwRIkx37ScSAHsK7qa/Awk7ssxR2SG4ke w8l1UBWljMczY5Pf6VU1eS3ltwY7YySYyin5Qvv9a7aa2Rzy+Jn/1f4hfGAtpbq3TaBNHCcqmecY 5PbP+FS+B57awuI7yQ7rq2m3QQruEhVvldcjsQOh9favdoK0oPzPMqK9Kce5+zP7L+rRavpUn2qa ES2mniUr5PlQFEkiEBGON43csf7ua/pg/wCCU+oTRfEXTtLt9TEbxKs62LZ3SIMtK4l9d2ePRfpX 9vZ1KOI8Hm3qlSX5H82cEUfZ+MtOmurf5n9e19E+oeGLpBmSWfTiVO/BBRQdwP4E/jX8Wv8AwUe8 P6ha/Ha1vnlSPT7m41AWdqT5jGQMikEfRSQfr61/PX0cMR7Ljh0X1TX5n6T9JvDe04bjVf2Xc/Ot 3vRNNaJCkTqzSMMgiTHBKjucD8hXIiay1A63aw3P9nywRedaxJHvuXlDD5WB6Kcc5r/RrD/Cf5w4 xfvH6n//1vzykN5LbQG7b7M7Rr5mAGGF9Ce3FTS2V7IY5rR0NkYjuYsMlh3z0Hfmv9mD/HZ7MwIr a51G6lsEhlzHH5qXYBIByRjP61266Rbxx2zX0BeLG1/+WW7AwSTXQcc073MbV9cd/wDiWKytp0ci rFCqKDDjIyrduv6VnRWs9lPBpiSPKkZa8ivFUmJWcBipb1HT8K3jsjKXws6COS3uQkdwkTTbfLaW CLZz+HX8TUFtb26RO1rdyhom8qNJH3bMZ4VfTPatIbmD+E//1/zzWxv/ALP/AGhqDPd+UNkd2FIY ODwuFGBx249au2l60sqzRQywPAAWvJRtcMO4PUV/tgf4rk+sSR65cSXWnXdvJNFFm4lx5RkYAbh7 kcjjrzUNn9hTTVmvWm+0JlUhaFosK2MlW67uPyPWgxl8Q+2vrWGCRltvOVP30iq23fjpuNSTaxaz 28l1CzmXKGzWLDW0JB+YPz82Ocf/AFqCbpbmTBqpkeWVJvtJX5lgZ9olY5BYnOePrTtKsGhucXV0 Wdbtrl5GXdFbgjAQDvjGPxrdaKwH/9D4P1bxN/aVlbvE0U1hblZUuSpCAg7FAUgAbj19eKi0+b7V EyGK2dlBig8xcPbbjuYIeq5r/bg/xKlJPRFySw02yga5a8aOa3mUG32lhcFs8FvbGcU+6gkuBHbK dkd2oZJ43G5M8j+Vbp3RBDbXt1ZWipqBk1G6vE8mOFW81I0UsAz55HTgDua0rVLS8tvID/Y5Yh5h WSLKPk4xu6Z54pmMviZk6tajQ5oNPkl+06lcK90hGI42UEYjUDvyMk0ojmn0z+0TbpZCWXDWwl81 4e3X9aDGp0P/0fhSzs1kR5VRpBGv7yYqNy57ZrPGppp92EW4jjkL/MJiBx25r/cSME1dn+G5uane 2dzYWn2SGOG4usjUdsvmMSpA3dON3UZ9KqadOmnj93l0Ujygei9ic1olbRAX55be2vxqFnLcvcMh MkfmkW6MwwSqdjTEnhRvPvnuHjibdIShlYbuwwM8Zz+FBjF2ItTaRrq0ltL2RLaSPzhPAN1woXgR 4PQnv7GtK+8+C3glF1K8oi3yxMNoHGenr25rSCTWpqvI/9L4el128a2Qb1ZAu1YlADrz1Oe/17Vo WsVzdQPc6iybGXzVyBsKjpn0AFf7oWsf4Yy+JmX5kt7dwyxXESLBuWNWIjjK4PQn1/XNbloqx7mk HlvICzup+/wBz+AH4Cgzk7Iiga9upbiKFdkVvGZHmQgBgTtAI/yKhfw9PoXkyxSyXsYALXDqActz 2+uPwppXdjmm7KxRu7yebzYI5PJuAFeJsZMfI6D35/OorYzC+ifU5mnWWRQ5Zgu0HAxn/PWr5NTn c0tD/9P4l17TUsr0TW8zwW8kQkgEMwlJcjkN3Hf86r2jXWoQvYzyyGJ0ZGaEBJBkEV/ujbWx/gy5 N7liys00ry9PS6a63QB2lf74yT8me+MUrm6k86MW8lrCsxWCNn3CYYH7wD3Ofer9n2JKgt5N6yLv e5iO3YEO9P8ACtHTxHqWowieNop7aVQ5YbPNTrgE8fzp8uoD7rzjqE0cSKNjZVCBtQe3+e9LcX0E cbSFomkVUhlWFcvA3AIOe/f8asmTsj//1Ph2SVWV7pUeTyQdo5Zua19LKvbCGVEjV2851UZLOetf 7so/wObsrmlBZIkc9xHG8gibb8g5TPr+dc9q7w2rwTXEU09ukihjF8m0s2Me/JrcwnLdkVrALu6x CVhh3Fk85stj0+v+Fbmm6XMWS7e5hMVo+WijLGTg9iBj3oOGqV9dW3SWaaJ8wSAP5LSF9p4yFz24 zVTR7u1s9NuZZpLm6u3uQqOzKsaBjjoBwB6VvHY86rG7sf/V+S7fxfqEcS6arQsRj5zApnaNexbq P/rVp2fiYx798eV6FCceZ+Pav96D/nbqUt0iq3i7zCYJIJSyDMcqYSFCD0Jxk/8A16ki8VST3Ekg CqTEqqVPyDaMce/y/rV09zgqUepWTxK66gsyl2m6PgnaF6kkZxUzeLX86U3SFocny/LHlP7Z6jr6 CtTB0LmP/wAJLdGQsvmIGb7pJUgGp7XxXcaXeJHbXLLdXswkjgdTMkxHHKdCMetGwfVm9Ej/1vle 58Z6nJcLbajG7wMS0nkQx2ccZHGNqgDOPWpT4ldfMktSRbrlF5BnA7jPQHHt3r/fA/5wXh1HRGNH rt9dpCZpAUtEPlxzQxmfcWBJLqBnkd84454rWPinUdQF00f2VdTuCn+ki2SSRJFI52ng5HBGB1oI dDqgh168i8/7cBdXlwd88y4iCP3+XH6DiqD6rcDzP3xdywkVQ5XkUCVHeyLFl4j1O2lmlllVxKpW QSRDgH2GOfrSnxDfOEaOaSFYYmtosYACtnIHscn862i9NSXRbP/X+Sm1Ce4ESyXMaRom2YklJJSM YPXHrn8KbeX5EagT5gjIZgkmFcju2Dz9K/34P+bd0tRqeIpJbbEN0hVZN0a+ZuwuAGGPc5qCLV72 d/KE8kNvGxYxRnZG+eoIoB0Gi3N4kmBURM0JB8tmz8rLwAAKjuNYuZ4JYVn8icD5ZAMkfh3qr+7Y l0H8ivPqeq28McQu96PCHdo1G/d0544PXgVVi1G6lDrNLKXJyvzEMT6mtIO61J9h5fgf/9D5Che5 MZdbiaOQEqu1iu/IwQfUc9KW2e4t2ZjOxMvDIGyBjpkV/wBAB/zZ+w8vwMu+1Oc3RSa6YLKfvSNu Zm7cn6VpxzyJFM9xLIRJCNmSSZGzwc/Q9fagt4dxSZUt7q9Vl2zsYejRnluvY9RVmS6khZpo53im b+IHsKBeyE0zVphctFI8knmHBPmkc+vcVYndGJg892RW8wkSEB26/Me/NAnR1P/R+QDPdGO5IuWE YIf7+0sy8DA+mfzqml208O8sWWM/Mc5AP1/Ov+gA/wCbN0B8uoSiPbEWVCPXPNUXubgKIPNG6YZD P3x1A/IUE+x0LkcrhFjYlPUDjJrWspruSYMjBI4UKnn5mz04/OgPYle6aQys/BYfKZ8fO3tn9arS ahOZxHI7yvIuzy40CjA46CgaoXR//9L45kjkRRPC8xjciNvNfdsOOQKIorlriOQMUMZBVt+wNjB6 /wCNf9AB/wA2caPUnuZvMu1liS5jJI8xmn3pJjrjgcdac007Sb14j3bdit9/2NBaoscsBMkgZHi8 w7jkllU4xnH4VRikubCWWNXWYt+7eZYtqlQc8Z5HTtQDpOxaLJcbYXlWESsFZ3O1Ez3NTX7WsLQW du6TwQEbZVBBlI5JGfQigj2P9WP/0/kq3a3klIuJpIgUJiVfmY/5zWRO9z5kyEOlr91G5DyD1Pp+ Ff8AQJFpLU/5tHR/qwi3ey1itQQVgTy0kwPM2+hPeoy6zQyR7HWMqwLqMYOOlKPxJg6N9f0Haagh ijWbpHGEBPU4/wD1Vq6h5NxaWy27yGWOXczFMIB3XNalSpXnzNFu2dIYAFIYMODmsi6m5igiXyo4 3yMH5eetBLo+9ex//9T5AuMbTEGVyOevUHofxpkLPaGTyXjlQqUYMm9eeOM9D79a/wCgix/za+yd iu+DsDsETqOMYqdpnkMYV8BMAbVBBA9aBeyY6ZTAqNE53H+HoaV5XkUBtrORge1AKiTqiRRBnXdI q4GarF9+JCr8NlUzgD6ig09if//V+QGkSSRkI2K3LbRjH0FQp5aZwzPgY+Y8sfev+gg/5t3RJFF/ OrLGG8hB5kgXJ6dz7Co0u0eXbEH8xOfOA+T8/wAKCvYqxLM7zuZXOHHBYKF471XxBKCIZW37jlWX B475oF7FE0MCE4kfkDgVEbRo2mmieQgtyhYkfgKA9kf/1vjIyRmPccqynuOvp/Oo5ZJ40ieJC5dg CeyjFf8AQQf83HsUSrvlYtKCpA4HY0rTBSY9vzkZXjrQHsUIJZmjMciHYw5BFR21vOVeZImNujgS yKpITPTJ6DPvQHsTSDhWAU7s8elWlVra3YxOx3ybigbJzzQHsT//1/j6a6kkV0lDKU+XYRueQe3p VuKVYFSNht3fdVj8xr/oIP8Am39iRXEBd9yoGyOmKW3jSOGVZdwkLDy8cKg70C9iwVQhLL8ypyee tV3ljknH7vBAxzx60B7EUAs2ItyuoySOhxmmWpt2uzHfx3D2rwsWaEDKsPu9fegfsfI//9D4/wDK ikwIHfaw58xdrAfSpbGJFlmjedY1QZQnOGIxwfSv+gg/5t1RKmpHbPujlxK4Bdhz5mMdalS4CwqJ BiQrnpytA/YomsnuiZEjkzDK3IJ4I/zn86W5ZGQwBsxg/OoPBNAexLFvJYi2t47dGWRFKXBJ+UnJ xx9MD8KVDaEG3MgW4Z8ozHCBeaBqij//0fj+YPHOVyJFQ43J0OO9NwJGclyGbopGETGB0/Cv+gg/ 5uvZJEciBosbWcg8GNtrDn69KfFNGCodGUKeAxyTQUqQtxbx3d3d36RW1tE7jy7WPII4AyM9eQfp mnmNHRQxAI/CgfsvUjEcMbjLHavdecfhSz+SV3sVwRmNh1+tA3St0P/S+NbWfzNyGRZlUbSWHQ+9 XF08yKXTnbywHYetf9BB/wA3jprYkASAiE/fPzD1FLMzsqqQwjPBfpQHs0VEWOJzvBdB/D0J/GpY VgKNkkMG4zzt9qCfZIsJaRyXCoxUqYixAzu4H+OKa4EAyBtQHaM9jQNUkj//0/j8zKc+YQA33sDG KSGaOMuULAoN0Yxgvz0Hp/8AWr/oIP8Am85ERyyIS3nhz5gOwZwF/EVFaW6IrNksAflBJb9T9aA5 EIyyzFkZjEuMAA4P4VpWltvVYWnSNgP9bI2F49TQUqaeyKyzXDOymQqv3Sy8ZHSnNjerljJggMGy eBxxQNU/I//U+RgqidpUGIs52n5gvp9agSadWk4Jj3bjgYVe3P51/wBBB/zgqmR3d1GRGI/MWZsj CgmPA7n/AOv+dSRu5XcQSwHAHek0+hrCmm7MZcTNMiRuZFVP9UI22bTnJJ9e/H0pyyA/68O8m7AO clwaiKak7mygluVZiybzgKeSg7qMGvzR/bScTEXEdoNzWaXdofN2xyzcb0Ppkk/hivi/EX/kjsf/ AIH+h+yeBMF/xEfAW/mf/pLP/9X+K3y5bkO00nlTn5pY3b5EY9l9qrwO8YkhLFnDhl9BjvX6tjP4 s/66nxVGK9nE04mhO5bhkMhUhctjZ6E0mJIW2Oc/3T1U/jXCbNLYVLxBIYWh2FhjLDJPriryy28S hCA5AypIyDmspvWw4p3RlkiV3DcDsac9vbr8ygqxTDkHKtjuazujY//W/iztbuP70LI+DsBToMdh WxHLdvBsDAoCdhzhue1fct3Z8wk+g0STeUBGqb4+DnoOetJLJNFGixthBzI2Nxb6U4y5TaLdtSh5 wSUhipMpAU4+Uf71Jc3bqGQuRLGQMbeCK05l3Kd+pLYXxmZorjZtK4AcDmp5f3fzAsIyflYDkUlK K6iP/9f+Lm3uUd5I2fdB1LyHBB9q0Q8TJIyFxs4QAYVvevvlNW1PB5ZLoQpJGzonmt13FcYCmrEV wYnm3/d/vnjcfTFRKbfoHLJdAnlfl3Zo4wM4HUntxVOPUI5nWA5yTgsOWArLmiHJIRoo0lmZDkrn bJ0yB6ioso3E2dueWH3hRzRDkkf/0P4y5Lfz4He22RxRxjlnCuwyB8oPU81VhSGO2WzUqyFjlmx5 jN3JNfbc8TwOV7WLSRCJUQ/PGTxjpn2rVgFqySeb/rx/qsqCqgDrmjniFmcve3iXDGBxsZXwDnO7 HFTAIwCQyBIAQDEByzDuaOeJPKuwXURVfMVNxHdRxWKZbmPMjDZHIdmMcNijniDV1Y//0f4yku5L O3hhEwnAHm/INyR56A0TX0UqST8syjlB0z7CvtudHzqikZcrrcBXPmbSwLAZUqR0z+ValtePGoiX AU5GXUMoHToeKzlPoJRs7kUkLuUhhCmNm35C/OzdMZ9Paqrb4ZRaTh9hbIyuFUmsudF2VrG63lpF GTgpEPlCDAqu0oDRyLwJGwSeAPrT54hZLY//0v43buaIWx2vvkUjaAMYrFjmMm8tlSo5GPvV9bzo +fsTxTxBMOUMinhWGR7ZqIWOZGmKlcHOMYX8KOdFckie6JWFlB3nbwo7VlW8crLExKAeYVZHPLce n+ehp88R8jNBLV5SGbOYzhe3Sr1tBJJM4kVNoT5GB+dTS50XGPLuf//T/jTMbRjYW86RnIYk5I9q pyOIDsEReZn2GMDAT1PtX1UpXPGSS2EZIogjRRy/aJZtu8fdUc9RWlGJzsD/AMI2n/aqLq9iZRb2 OvsNKtVt1kCoJXBK4b5hnuapX1nJGzRXDo8bngDn/wCtS5kjKxzd9cxBV8t2RYnMflqcbtvrWQbq VmS4CFv4QjHAxnFS5oD/1P4y5PMeSM4ZY2xwPusabcv5tw3zJEkahSm7HOPSvpedHzcotvQhilDS 48r7h2nA6+9byR2rJ8yESbcLjvRzoSg2UJEMs6iKNnYDbhU3NxW5FptmtqJQ0wuQ2JEmh8tV4568 0uctRSVilPBEPMMDrIEALFP4/YetZO7yJUl2Nuc7Qu080udhyxR//9X+OGW1mv41w0UZDDK7sFT7 57VRvrZ4ABiDdbH5ysgYPnjAPf8ACvopS5j5+FPsVLa2EmZom8uVjsYEfIc8U1I7yAbb2NBcRtlS D8o/yKfPoXyM34poiqKNkTsAzheVyatXx22x8ws7LHlI1Bz7Yp+08iGnszFhKrGsrIxYHkHjy6nm lwgcswB5VQeT70e08jP2fmf/1v40XIlVRFzOVLKQO/vVW1jmaZ28pTIVw5HCGvpOfufOcjta5PNP Dbl9gKEnDL1574qsbjEu9GQMFwRIcBqfOuhDi1uTQmFd8joGbbwc8GtG31Wzt7ee0llRJJxmFSN2 8nt7fWl7TyGoN7lI6kqypFuUNGu4Z5U47Gq9vM4dpnXZKZGYYHGDkVEqnS5cY8uh/9f+NYSCTI2A kcgfdrPvAI41ZAyyO20nHCgdq93nR83yW2YsVxLHCrkDzk/jPJxUbXRudryEsVblRwPY0c6LSsU2 uZo38yZSjwNuRk5WT0rQgubqdSZVjjm271UHIA6j+lLn8gcbsqXd07xPH5uERtzR/dwajtbdpkSR clXHX9KfOjTkZ//Q/i8voLiOAMissEZwwHAye9WLWIWzqibo5nQNv2k43Dgmvd510PBcWi46bHjC S+dIrbnI4PqQamkgtrkhkSJ5VJHPG096XtPIFFtXRBLLdQSNG5j+zyJtKsMjNQJFFHO6n5iVBXYM j8R2/wDrUe08hWYl1FJJHJGRsVCG2dN3v/OqULKxWNhv/hxjpTU09xH/0f4whaPvHlhHjB5weV/z 7VPcOBD5SrtKZ2KB8ua+gT7Hz5ixXXlsqys7EPlvlwFPQ8fgKurdDzydzF8bYweAfai+txpNuwt1 erEIhgtJu6DonrmrtvfLcwozKVkibA9OKadtTRQHXE7E7oJfKkwBIRgZHpUYuwxAn3u6cISMqf8A Cm5uw1BI/9L+NeVIZYFkjIjI++DyT9KyIraYsJomcKkn7xWBVnwa9xz7HjcquWLuQHZGMFv4lx0q MpGwbMbZA+YscY+lLnYx1vKFVxwBGuV3fyFRMY7o7ZpfLZeVjUYxz1NHOyXFN3LcSeb5kLqfKIGJ Cflb2qv5dpDOBIoxHyfL+UkD39amU9NRKCTP/9P+Lac53XIjdoI/mlEfLgdOn4ioo7hmJ+zs4j+8 Vc/Mo969XnR5ShdXNBLhUhJikbaeHXofypgu7eBGDPKk275cj922fU0ufyKUEii9+IpyZkYogLqP vfjj8KsSSrq6ICHhEeZFLpgc9wKlzbVjZQvuS28sVlCBK/mQBhHJdlQpjz3K/wBKph7eVZHj8wBJ ThmQhpfcD0NYufYr2aP/1P4ubiVWj5llAKbMDkAHrUVx5bxRQxEmJfuOeq5611OTehzRhroU2hnt gWGHQdEBxvPv+VSNIskXksF3suM54WsJSbdjZQXUrLAkQSMTAhRu3jk5z0rVjEHlFGlLMw5jZNuO vQ/0rKTaWhLg76DbZDDC8EYAhDlkP8OT7VJKVtwjZIKD5go/1h9KxIP/1f4uJr0C1S4jL8L5MVuc eX169M8e1U7e9+0vIlxbCTagZXVtuDnpiuWS0sQpLREs0KhsmN0gPI2jJH1rOkk8qUmNmKKMqDwR TirKwTdloXIppSYp5DI0CHGwd89a0PPW53OqpCIlwoVdgYD+ZqJlLYyLqSRfkyqqTudgeQPQ06PT iscVyqZ3HAST7sn+FZnRHZH/1v4srdmVj5rOyldojb5glJcCOKRTkAP8qKBjBrjp9TsgtyjPM6SG IthXX5QOVJ96WP7QGzJIoLL5YLkkCsxxjG1zSbELKI3Vwo2uyjhuxH/1qn+2QwRRRvGu1ZPM8knH mZP581pT6in0Ipd3zumxd/zIpX5V/CspGlSQSvtZ8nABwBWhmf/X/ig81w8iNIWaVs+WV6fQiqU1 w8TLF/Hu3HAxke9c5u3ZXLlq08ke64CKGYgKvPTpT4oxBuCuGMzHd5gzx6UHPKVtzOkheOSO4aIi NZCrRjjaORmr1owifdZgE+Z0blh74oLi+VjL2QTFplGMsN8cZ2qzr/Fj1qvBO0TMRywADqfusPSk 9h87sz//0P4tYrreoACJEExsbkg9zWXIIZmJBAn3FVRRwwHXNcDbe44uzGyiRbM2xBWDzPOCkcbs YyPwqh9r2Q7C+VkPlFTxt96RuQrqUQdYfLVkH7p2xl8VoSFPsSvtkxnbtdeQM4yaAGRRRWsqy7WC gA7V6MelLfvLeqTMpgCMDCYFIIx6+tA02lY//9H+JjTm8wMXnyyEBAxyXH+RWgEnm3s52xK3lM/Q ZIzivPO6MrmNellCpFhYVOCx4Oc96JbRhKGjuUVZIRvjjBOw96DSGkjX0+a1WH7Os0kl2JCGJXbH gDjHv1qjqE7q8gd2CsnlSJ2celBtsR21wBAIZMoFbYoxnK9v8K6AF1t48Jshf5gh7kcbv51cYXV2 LmR//9L+J28tRO4mWNfNCkB84XIHFXUZNMgtTMZjcsVWVohv80tzgD0HPNcySWx63NEu6tqiG1jF mhLGTi3kyAg4Bb8alsNRngtjFcBY5Fc7yrb0APTbirjG4nNWsiteZn2JtMoZs7yoC4+tUP7Okgk/ 0fy5I2+8qEudx64rVRUTJOzJo7dlmljmby0QbivRw3YY/Cu/8Hf6fq9gtypkl/tCKHTWeMBYXUDG PyPX1rSkr1Y+phiJJUZeh//T/HH4EaKmn6BplxPdfarvbGZdPaL9ygVUIZmzycBDgdCTX9T/APwR +8J6YsupalJcSTR6tqD3Fw+zMIaN4zDFH7LwQf8AaI9K/t7i9/VfBHlXWCR/JHhRQWJ8Za07/DNv 8bfqf0E/HK+gs/hfrzTT/ZreTSnW+mkUlY9kbEdO+R079K/gf/aJ1i28V/GPxrfSS3MqT63cw+as QimSGNIBDlTwq5MvHGSSe9fL/ROo3nja7Wiil+P/AAD1fpa171MBh095N/d/w5+Nv7VOu6LPptyt w6xahFfwxJBMwjidVfBQD1UBfWvzK1PypZGWFdyq5clu5J5x7V8j9IqrzcXJL+Rfmz9K8GoKlwZh o9bf5Faymg89ARgb9hGMAkV3q3VmkQEmPmGwDr+Jr+aZvU/XlK7sf//U/i0jiSKIK0aOGO5JAMsM +9RuiyJsRBydvl43N9a8mttY6Dq9Kube0ULbMQVUCRXAUA45xWm7z3Ieacls/c+nSuW3QpStK50c UFnCbaS0uXnWONBg8EnaMqw/Tmp724im3zCGOGVRsWOLPydOnOe1ZyikrhKV9CuFijtYJPNdnkbL wuuBt475781v21zokllHBczJaWy5aa7xuS2H9On61mSf/9X+QWbUhNFJFaXCOC7W6SKwDHsOfcc1 d0aa80qwl0Zbg3DoTdXBklUn5znGencflXyzsnqdBBb6hqYjvbay0yzimuJnEVxLuWRCSPmUDoT6 85rQF5ZvDPpwtYLi7VVV5BOfNtX6nKDrntmsHohNXViW3baloVt5Xuwxjk3D5UQHpu7dOldZpml6 LcX0s0iCwiZhI4iTdJcEdVyfU+vrWPM9SYxstTqF0lYF+2W0MYiumFr5qsFLAHp1yMZ617t8KdPu pfih8NdJis4549U8VWa3flR+cmyCRJivcHdt5zx1ry82rKnltWpLZRb+4qfWK7H/1v49rlvtwUFk tpwoV1mfy0iXsX9utcbelr2VPLgENzbw+QZI5CVuk/vNk9f8K8WL/eNmVSDMuOG5tmaSSOSO3lby ZZ9hMZ7kZ6cdcVpXKr5sGyGZ8w5tbiBN0QbsWbtindXsSot6I0rZS7RCfdJIFCtIpwSwHpRcAPtt povNSSUrub5WiwCcj8sfjTL5VFXJYpLIk20YiR0AbZu+cj2H4VEUgF780wWaUYiRz+5O3sRj9aaV 3Y032P/X/jMv4liFxqMltEzrGPMS3USTHZ93C9fp9as2VxZHT3Mr3n2uf94kTRAKB/dZs7hx/KvL UFcCvfF7uKKK1tZQW+WW68wCCDH95ep9OM1dtbKa2gCQ/vWUZJbjce/0rVaMmTsi8sMV0Y4bhIhI pBRmUMUOccH+tdSoksS1rceTcMoEUbrJvwMDB4+lddNoxMfVPtF5cJFNLM0drD+7+Xaozngt3xWZ DFeyKYlSKSGPO5nGHUf5/KuqnLVIyktz/9D+LPxjpMSGDUUhtra0X/R58zZkeU8ghTzgj046Vx2h 2Nv/AGsLw3ptljQ74CRtuPYD1+le3SesUeZNPkdj9iP2KNTs9Q8KWkdtpUIvAXtJkab7TAI422NI w7dA2D0JFf0Of8E19QbQfjNDa6d9pM81wj3D7828OVj4RcZwVDDA96/t7DuOJ8I3GW3sv0R/NmTO WG8Z6XLvd/kz+1HTLpLjwktxBCv2ebR9kabiFYvFyoPXqa/kG/4Kq6Lqtl8X4byOyuJEs7i83vFh rG1N1Hby7SSQcjAA9j35r+bfo/VI0fERRm7PVL56H679I/DzrcJc0Vond/JH5OXttKlxZ6nHK7XV pCVEMI2qWZgM+4x1zXJbWuNSvb65WG0nnmWOWYx7UUDAbOOvAFf6U4de6f5m41WqteZ//9H8+oZl uo9TeO2lubB5GttPSeIw+cU4JUnqCcfTP0qZotQt7O0MkEFhaQRbZNPkcH7QT+PzDntxX+zXK9D/ AB2ezLdnrmkWV6oZpm/0FpZLeGICKNsHauevp+Zp1xr51CzVREpZo/kgMgUsT/DzXTBXepyzdtDM utJgEZuLy28lmAYwSEq0vbC9eeDz7Vfjkmg0uyg+wMbd5Gb7QiFpo1C8bmPBA9q1MJfCzBlttXtI pFgaaO3kt2nsFOHJ5YDA7EkD0/WtK3sV1CFke/EF88HzlY+YpAMZPt0Oa0hvYwk7I//S+Hm09o9K 0/TbUzRXU1ms+oZkM4uZMspkH1xx6frWFqGkXFnYM9zqN1HIkoQWkEAmikz0DNnI79u1f7XJ6tH+ K5nDTbhJrWzsLq2jv7yMukT52qSM/MPX6d66XWU065s9Jhu5zLPHCsF5JHGYFd14O0Z6Z9ao55q9 0Y0WmT6fqMMPlSpHcqptI/L8wXKOOCfT/wDUe9XZZotGubeOKKCNMncvkAhCcgjaRj3oMZXvZmFq dnpkcEdzazXM12lxn7NFGRwxx94EdO4/wq5O95NHZ2MMaW8lyvkAznalwzD1xxwa1i7qwNStdn// 0/hSXw5fQ6ZDpsU8E1neW6NLaRDb9jniYgbD15wD+PeqmpaZd6PeKLIm4u7eIJexbQBC546ZwSOO fUV/twf4izTtoXl0mSeJZL2MNLaqZZCH+TnPJGcE47VVtTLb+QI2k+yTO/lTHmGIdcAnp2qouzJt LQzhdGK8txGXmV7lYZWVSz24Yhd7Y6DkV0clvHZ3moNfXYmtrZVkSXfuSUnkH6j+ZFbGZXdtMmvL W4lTz5Vib7IZFYRguBnJyD2H5VVlDwQFJpPMiYtKqQEhVYcbST34H50Gc0f/1Ph/RdXvk0mewZFh WWMPNEsSszHt82M8fWoZTDDDcSLZwXCxotwGmjVmdgcbVz3ziv8AcOMuXQ/w3M+8uLSKNb22/cT3 kmLmzRCkcanaAPQH/ZHpT4fszId8skbs2PLxwAe+a0Ula5KTV7EogKJ/ry9x5hIIGEVc8A/41Zvf tGn5lW5iujdqs8kETZjYqoG1l6DHT86Zia0GoW6pKWtVhkkt0NsYX3xhiAW356fQVjTXF0wmiyHE 0qrubBKn6nnb7VrT2sO7R//V+I9U0m0h+zLE6neirdOhA3v/ABbWHUf5FV9dlurGEac853mNYRCr bsRsucZHHpX+6B/heV7TRUn0uG58+d5LW4+zvYupjXAUMoHcj5geOOatWF3bxEwvFIGeUrcAn5VX AAK/r+lBi5NjEivNNmvL6wMlxDM7QrOyEpGnTDr05z+Zq+viJv7Pa0jv1S5j5S0uVytwv8W1gOCP vY46VUF7xhPcwZpd8omlVo2cDcQOOnUfXrViexmms1aJl2STAMJQdxA64+oz+VbHNJWZ/9b4le0k +zxG5n2xKoSOPyQGJ7fNnnj2/Gp9O0+aLzpbV1D8GRZGPPGOPyr/AHWcbO6P8FzMuBdCZZZV2SSN +7YDAAHGR+Van2q68mOB3R9ibTNtxK3Pc+vb8qGveQHR2t3ItoUEqFoowZGYBc8cFjXM+beXN0OI 7cryHBIDdc5+vSmuonJI07iS3vJFYYtbqEKrlD+5kUA7iWJ4PTAqjJpsge4MTrcxsnnTSIu4qvAD N/LNMylK6P/X+MbGKBbI3COdrSGJo3+8pHB4980otLee5t7QTtGJJvlJfygzdQM++K/3YS6H+BMp XYkcV7p804fBTkAI5JXHrxUM8L6jGrPsEdu4lSEHG9x3I/Xmugyk7Kw/7NMtjvRF86Ztq7o9xTB5 IPb/AOvVuxnubFZcP+6uIvKm4zgE/p0oOWa1OfgsjLJcYaQxQMTvk53jPHJ+tal3HY2f2AWty1zL dJvuoBbtHHA3GBk/exzz2rWC0OaUL9D/0PjZYogZrgXKW8jjyyFhJwMYyMf561jyQzQ71NwJwDhJ I1ZUYfiM8e9f70H/AD1zpdCf7XDozLb6hHBqTXMiLELeQgFXxvwc8sobODjlce9XbWW00+Jo7a38 1FP7lZxvKg9ietO7Ryzo6aEM9uEi8y3LJNKhEhJGOv8AD+GPxqxdTWsMUTx5VdiRyNOgfDnA647n v70XdrGXsNyG6hVo5GdQXlCvG6DYqfgOORT7V4Le0824iQ3kc3mWl2j4khUAZBGD6Z7Y460hOjof /9H4lmlcyJMWaSOdsgnnH410MOmKbaORGJimf5ygAC8c5/T9K/3ujK5/zrujroZLeRArqnzEOcMR y3PpSvdQFreVoktFQBZGUH943ADEHuTjp61REqIrSOcbVUKowMdTk5yT361BPv8AKDBVLg5UqKCP Y2JY7GR4knurk848uBT8xx61LLA5UAHaFH3emaBOiuh//9L4wg8pnME7eWCpxIwJwQDjj8KrfZ/n WORyEJ5bbx+Vf77Rd1qf85ro66jl0/eGltrYSxwH55RhfL5x/WmSfaIUaO3t97MwZmDbQo5z+dUH sb7hNbuQjMCN3HToauywRJbKTIBKeN3T9KAdDS1izbKJRGFPmY43Yzup832aJpJXYwvEP3exAfny AAeeBmtKaM3QSP/T+QrJprwSR5QGKMupxh29QD7/ANKqPut5MOSNzYOea/6AD/nLVG3QrRWEd1Lc C+iWe1VvNEZXnA6DP61chtDdSx20JghtiNkSyS7FiIxgHPbnt6Ggbo6W6F+3sYYUkgkIkuBIULqS UGOMg0yfSLy3eJ723IgZs7t3Dr2OR2IoI9kUBBBCxaJWQFsfN1HPrVl7eH5SX2ozY34Ix7mgPYn/ 1PjI/ufNyDJkhNind7f40PA0cRFvFw7AyRjjPbJ+lf8AQAf84zpWJ47JXhJaRUx1DDIzTEgImto5 Ej3f62JmAO4DjI9s0E8iGTpkzSs3Ab5ABhU5q3a+ZblZJCVDpuG7jIPSgOREEjh5DCsp3O/mlOnt nFWIYfNklQyJE6RFg0mcHHYY70ByI//V+PY0kdQCwDoeuMqSO+D9Kas0hyjDftOCQMCv+gA/5xfZ rsWbz7RLaqkaDOQd+MEAcEVn2YWKRMs/L/P6E0GipdzYnSaSZFS5CRYLZOQDxwKqTRyxoSdrFuhF AvZeRYWxBtknvMxQPkRtt/1hHYVASLaUeSFMePlcDJAIwf60C9l0sf/W+QHuYYmJCb+ML8vetG3u 9kbK4XEq7W+QMMemT0r/AKAD/nFdNXsZU8kST/IgIzkHb6UonjupnUx+X5ucBBsjU/StrJS0FyIo 3MDxOiOT5ZPDDpV5Lh4iFAV0C7TgcYxiqHyRGSM4TEScA5AXqabdwiO3QtIDK652/wASHJGD+VAc iuf/1/jizjzB84Al2YYZ3Mfb+dWcQrGv2eIiQr85dvlOPQV/0EH/ADjcq7GdOhY72GQTj2HardvG Y/LZQWVD864+8PSgXJEsXN9HeXaxxW4hKRKoUDr61VbTp7h3IlKmNshVO00AoJDiZQwUfM8ZwwJ6 4/8A1VpGOKJYpZbiNjIMlFzuU5+7QVZLY//Q+QZpoi5dV+7w/GMfWogIPJZ2PzOeAv8APNf9BB/z jWXYhNwcqsLN5ezPmZ4b2xSTR/clhkO6RAHiC7Tn1oCy7F23H2qJYJAsciHAO3aWz60yW2uIZdjR /IhPzADHFA7WE8uJ/Mm8wrsHyxDk8epp9o5u7WSaO5jikRtv2WRGEpAOC3Tb+ueDQKyP/9H45eSW G7CKkM8TKRKGi3c+3p3qyQShig3CBiHKNzhgMcfmfzr/AKCD/nGsiiJH3NvQjY2PTOKUI0gNxEhb a+3njBFAyyyzMV82I9MY9BSyOIUkiSSQRsR+7AO2Q9sgcce/rQBXhYgn1JPHQitKNYGijHmS+bHO ZJRj5WUYwB+Of0oFZdj/0vkX7Rb+c7MrBs4j4+X8adKVdlaXHyj5D1xX/QQf84vJEdNNsMIXOWXg +tUJJXJdSxZ2PKgfdoMmrOxJEWSIkEkk4qo0m6T5YpPk5Z9p2j8aBFhWljdWADQEZV+7ZpGLJI7B yqEZ2BeD9aAP/9P5CgmNx8sSZmJxtFRRrJM7o6FQv3mHQGv+gg/5vxfITegc5AGAx9qtwW8X71pU aXKbFOeVPrQBCIHjXYrMqjgk/eNWtO0281K+j061ijkeYEpK0gjGRkkHPt/KgCa809NCuWtpEV3I zcbGGI2zgr/+qsWIvLcpIsYKg/dYZJIOBQbRiran/9T45umuIrhAseY2UlmX7oxgYP1z+lMMksrx lIZCSdpEYyRX/QQf849ktiwqlTt/i6EdMU2W3MWXGW9gMmgCkqXW47ziP+FcEEe+afbfOzkuzFDs ZSOAev8AWgC2QAcMpO/gHHAwKzZWIYbQSE/dqoGVOeOlAbbn/9X41giJRYogMqN0igYK/U/hT5We Lb8xAXg4Nf8AQQf849iQXok2osYbBwzkZbI9+1XBJHJE8TsEcDKZBIJ9v50ARptRJFmVXJHyMOox VZSER224Zhnb6UE8sSOO6mWRZlUqAe53dP8AP61ZEov5JJJFCgn5AOEB78UCUEnc/9b4+aIyZ3BU jiO1n6D606Xyo2TYAdnOcelf9BB/zj2Ippjfs0rBAqYQRomw8DGcD6UtqijKNlVX86BcqvcnkVWA aLAP8Rx96qzSo6S25bazDBA4fH9KBjRGYQsa8rjjPJ4pxZ0O8gfLxtIzQB//1/jVZXYkk+Wg5Jbg UkD3FwXiR/3EjDKrwzY7/rX/AEEH/OOThUV2RBhY/kAPJ4NPiL+ajfMqoCMAfK31oNKa1FuGSZUE SBZIiRI+M7/w9qgnzGqy2t5byMIwSAhcxnptIOOf8OtBpboPt/NuM7RG935Z8sPhUkOMAcnvX5g/ tr2k1pp9r5yS2t3FJ5VxDEQQGEmBIB6YAHHHy5718T4i6cF5h/g/VH7H4EtrxHy//E//AEln/9D+ M25tIkYu4Mm5M8dSeRWFPH5WCkfLD7wGTxX6hin++l6nyNKPuRYsVmXaOdoVl3EB4mOC4FJPKiuy bWwPlWMHIWuLnZsUm3CVJVdXEZ+XPLL6ir3zSnf/AAqucDkZrKbshpNsj8xTkhThfvHHyirdvbtc bmlb91jIOcZ+lYmySWx//9H+MD7NZwvHsLbGOCFUk571avZUhVfJGFC8D+7X2vOj58oL5koLo4AP VenrUbvKqshyXU/KqnKn8KpNPYuCTepLEkBtmZuZ2HKnrGRWTNHcSTpzlVOWcj5segpltRbszQik tVdiI5SIsbi0ZUn3HatN5A8m0MPIRcgHoaDNaTP/0v4uri1VpA6IDGB88eAB+VW9xMBXasfIA2j5 iK+3TujxyKW3hEg8mVypUHeybOe46noadsJyrjzAmCrN8uazk23YDUUGdGO0btvyhu/0rIOn7Q1x 5ZSUPgSdCB6YrNtLRgXEs41VZGmcFx9zpuxWZeSW0DvEGmkZhuOQPlPcA+lMD//T/i+kjP2aCdJH Hy7jGeAvaq8ahtzNu83GSSOD9K+wPHNCKUxL9/LRKWEb9MnrUHmPNJlWcKV/eN2H+cUk09gKM9qv miVcgoOrHAc1L5TrH53HHO1eKG0tzNw7E8E0rCTdlosAgdhVa9kjlVYIiXVTuZSMFcjn/PtU86F7 Nn//1P4t7ZpWglRFMcW3y3fufb9KrSxpEgYOTj5T7/5xX1rmlseE4NK7HrIyopRGEZPIK8PitiJF ukyAYwq9cd/Ws27u5AkTCM4kO0hvl7KTVa7knkkLXI24+eMr8wcdqlNPYCO2uvttu0SMyMhOcjBq IW95uAlkkliRdqx7cr9amUrbDW+p/9X+M22tz5Sq+7eCTnGQB70piEIcqPNydxTg5r6HmZ4DtfQr m0M21/LZG3fdXkH2rR8i72EH5lU8A8E1XOzci+xXG5XTCqmd4PJ9qiMMQtzLgmYSAhWOFxntVc6A bPPFayR7maRJQADGCdhx3+lXURrVXkDu7XByFYfcHtTUkwP/1v4vw265MDbxzxP90Rn0q+toxaWR pWY4ADZ+avpXNWsjyIq7sT+Z88UKgB2Xkn7q4x1NWlfMSu5UEErhe+OOKzTtsOSsyAatc2xeZ2Cw xjGM42j1zUEmuz3EamL96Ec7xIMErg9P0pGM49UY0mXKtj931ZV5cHvTEl+R1KsFHKCgcUuXU//X /jN0+7iykNyxORjaOCB7e9MZLIzSRFOOSjkcg+9fQHgNWdijO8kEybCfL2hSwI+etH7WFjIyc7Pk OcbT60CKdlqd9bSpcxTGOVW3AqckkH1/Ougm12XU5WMqlGkTMhx1Pep5lexSi3sZ1izZaKMlirEc j7oq8cIS8hViAcHqFqr62K9mf//Q/jMiklieQpK0288hvu/TFTXvkPHFHDsaRGwyqeIz6frXtzfR HjRVlYktAU/dyqpKnI2twakmspzIZD88MnABbDg/T0oU2hmTcwtG8eJDGQwwBzn61uT6o1xGA5Qz BFjyAEXCgL0+go52Jq+jKMwV13Gd44gNzrGu4uQOP1qG1zI5kdlCxLlkkcK2PoatSTWpPIj/0f42 o7q3t1cKgYy5Ctj5uewrO8qfIkhm8r59zx7ciQeme1e+mnseC4tFPKGbMwJ3vypNR3Y5WWWI4b5U SMZZvpTJJ3xFb7442YjA2udnGeajnh3CO4CLsPABIDcUm0twsReVIjC8njjAVtqx7txCj1rQjkWe VZYtzZATy+MCsXuNRbVz/9L+Oi0WzhffeDaEXIUcbzWTfzQSyKkWOAWCn7oHrn8K9g8CKu7GS0Ux LbpiML+6Ur8h571ZgjdwWwq4GMKMA4oNlFIivbOaRBhgvlgtsPSY9ufaobeZ3JEw2yABOe2OMfyo IkrSQyZEMhkX5ieGUjA4roNEEEBke7d5FZcxxgiMR8fSmld2ND//0/4zNXu43BhgiaRR87buMHni s+CTMcpklmWVowIgeV4xx/PpXstWdjx7dyiwmg81/NkXzSMsOq/j+FT2DPkH76KM5zg5pBa2iLU1 w7Bo5RuDA5B6EVJaanLDdQZjVY8COVwPvr2yPy/KgLdDSvbxLoTuI1TaeAvfnr9K58M5c9Su4ZCD 5iKCORXP/9T+McSMh32/Cqvzq4O04/rVY3BcnJDMDlgRivY2PFUUirIZJrhcoqoRtXAxgCmXW2LY qoXIbk9MfSgoYd15IqtGqIBtwMqTjuTWhbhYkaNEBK8kE9aAKszhpnQwsOnLHGPepljlMgWUMsQH DIOPxoN4pcp//9X+MhllZY1iKm3wRJu6n6VcVzHGoViNo28jJavVm7aI81QS3KQxGCJCVDNlWIy3 1/z61LLPuTLKNhIVSoxms7sOWK6EKpEJncAiFIwAfvNu78U9IY13SHc8bDAYjD0JtbEOD3RXW5O5 bY7vLU5LEbSc9KgmZXkm8hG2RNhS33mHHWnKVyLdD//W/jGwotGVAruyfvGBxjjpWMbV7cRzRyLL 5sW59h+VB7+/FegeclZWJIo96s8cpA64YenanJGsZBmRX85sIZPmwQe1BrCPVl2WxjlHnTAxbIyQ QPmcjoMe9Z8lxGh2ljGFXGUHOBWUpX0NLFlXjMEibN8UhDBhyMfT8vyqha30cbTrMrRKrDBxuG0d gKg0jDqz/9f+LTUGaVUEQVQTnCjA9RSISyInlZbOG2nGa6BWSNGS1+UMke7auGBPDH0rNl0yNlWR ppoLgZVo9uVUHv8ApXOMrT2k1iFnWMyxN9zI2k9qvx21veoGIdHjXefm2lT0P1oa0sARrHEixRLL IYTl8neX9gP89aW9j3ukhLKicFcYBz1z71lKFtjGTuz/0P4tlghnCNHN8kJ2+WQB161EkMRuLtY2 wqELvxyeP0rnOfY0gk0ccfm4aEZ3Nx90dzmsuSezlZpbcNMAfkZ0CI2OMYoG23ua8en/ANoRPJBO scqR5FueElA7DjrWCyzWc3lywSbG6h/lVT7VlPcuEujNGG0W4ZCkY2Zw+OTWhLCUjMeRJgERqR09 sVB0QfQ//9H+LWDzbaNWkjR1dyF3549uueKrzO00sUZVACSd2PujvXCnZNHUnZNDoltyQGBfGSr5 4UinMgYGR8sEfdgLgECpNIfChzhZRLL5fl4+YKo2oPTFZmyHDO7O8ituU43c/StINbET3F+0zMSk gYgx5U4xjHas+a+CIFChstgEdVNaEo//0v4oLUR+UpmY+Y74BC5ZR6moJlb7WLaUMsRBxMEyz+mB 2rnN2rqxdsbeTJtAAxA3xTk8t7Y9qZPG0dxF5sob7OCDEuNjE96DnlG+jK05RvMjLSu2AyMBhRk8 g1mo1xb3cccryW6qRJlU+aRT2P1oNILUuqIMqsbhfMkLKnck85NbB09pIo9hWRozlyBnAqWtGaNJ qx//0/4oxbzyv5VsS0iHcny4B9iKbFplxHcR3EiSszHBMa/u0x1wa881UEiae2ulMjvOXgkO1Ijj MftVO9e1WOJFjUyodzKy8benX86DRJt2RkJDA9yPKh+zo3AjVixJ7nJro51iWNI2k8uMgAuBuoEV BLAAI5XIx9xsbtw96fcyNIARlS0QSJCuzjGAaAP/1P4g7VXtbnjBYdO+K60o9wq7pMecfNkC8bj9 PzrzzpTtsZN9GbmEogCxxPtfv5mOM/8A1qtWSxFXkygZYtnXjpzn/Peg1i7oDZQurO8RXHzRvG2w lvf2qv8AK+5Zz85GeeSApoNHJtWZSIF0yi4kaNVyEEY5A7fyrUtZprjbAyTLaW6iJJP+WjDnP4+/ vW0PhJP/1f4qWRQmyZQVU5DE8Y+lQpt8yGZp5Xt5RsjVY93lEHnjr+dc53OSQsq/vpCFMm9QPNC9 vQ+lWIrZgpCEMkgAKtxtPrmqi7Mlz6Iji+1sWjMjtGr8ZHy8cYz+FaaSsABHHHGyAAFD+8cjqaty 0uiFKz0KAiSa6SUGdZZH+Yv8u4g98816R4Mto7XV7O7uJI2SDUIC65Jktt0gjD7f+Bd+mDXXhFfF U15o4cwqcuEq23sz/9b8uPhJYaPonhoXt7ews9s0EOgq0RDaqGBLs5wRkYUfpniv6zf+CRHhow+D rO6R7R5mRLqW6jG+DfKS2xB6j5VPutf234oyeF8F6MdrqK+Wx/K/gdGnU8V8ZNO+kn87n6s/taaq 1p8KPENoksGL/SJJbxZv3WwoDtw3blSa/gw+Nb6gnj7xRqwmVb/WNTdruFAI0SRAIiqL2UhB+JNe d9FKjy4PFzfU4PpX1efNcBB9G/z/AOCfi5+1pNMrXcarYXkcWrGW93Q/vI1LbS0ZHcE5HbBJr89/ Nj+1mJcvHIcJID93PY1+X/SDqN8YyjfaP6s/aPCWny8HYV+S/JHU6VZ6ZBPEbyOSYghRjoCeM/rV fWLKS2uS0c4nhLkRmNduRx/DX86n6pBWuf/X/iZ0q+cWwtQvmFn8tC5xgk9MfjXXxWkcADOdz42u y8gH0FePVVrm6ILC2nF3OJNggLb4mVsFR713cOiX11bx3lik13YLlJJ4ctbxsMZGemeRx19q5xk0 VoYZRFbO0shIH2YDEsjdhjPWtp7Sf7M109s8E0bbJIZQPMyDg5xUTatYDPLma7sbNgIBcko8kyER oAM5NT3VjafY7izWUTkS7ZEjTdE4HJyT/KsiXJJXP//Q/kHis9BnlS2jS6i53sz2bQJuC4J3dD+F VLazsre7lcF1Yvt+SUnzgvAZvy7V8s0up0LXY6OJFKfalLkqduxlwcg4FVbiz8u9XV44CmQqSJbR ebd3hHBBA5x7mud7MT0Rvb/InZYfNG9VzFLHsdSeoP406W7uPNCQwLI8MZIjXjd9fxwM1zvYUZX0 O/0Xd9nt4pYUjYqJDGkmUUty3WvtL9kDRbfxD8ePhjo63Fwj3evjyikfnqBGrb95zlfvKeM5AIr5 7iXXIcTFbuE/yZrTS+tRUtrr8z//0f41LKW/v9P1KbWozp3mwqtqGiJklY/eLg9Bjt7d60B5UFp5 s0VuWt7cZI+R5EXuRnn8K8GD96wpu6dzHuNrQW2yT7TAZftqW0ufK+YZAI4x2/Krkc08wbT4hFbA Q58y3IcQBwPu9RnkdadPcyjLlepLb2aW7whDLNg7XB+857YrO+2Rya2ljFcxqRiVZbgYR2/ijUc5 K988c/WtRzd9EVJ9PttO1KF21KO8uxGzXEapta23scA/h6VrteafGIvKjdrtpvKWd4xLA4ZDwBjI OR3yKqLsxQdmf//S/i5tLG5gmmLny7eUEyTSSbZ5Sp+6Rj245/Cqsl9b2STah5872+0R+UE3mMKS OmOpzz9BXlwd2xNqKOhkkAihuYZJPsZt0ud86eQxJAJUr26nrV60nS6jN5HO8TwMENox+WRCOW/S qTvcmexbadJIt67BuHBdcMO1bOlTWtuZJ5Slwdm0Of4MdcCuiD0MiDUb2TUrqK3sJRFtdPNHlZLK TyBn16Z9qrajJJpdw67iYjHsEbDYM/3iex/wrqpyInsf/9P+KnVbtLzzrXUY4vKx5lvc+YH2uM4+ Xtj1rzmwuHinlkuWWQRjdDleQR/k16lJvRHnNe6z9iP2JbuPSbG3uNGMCm+dkKSlVsbhtuZg248f MARjiv3n/YZ8UyN8e/D8LG70+/SaS/gmsG22kuDEvlzD+6F8wgepFf3NwzGOJ8KJRe3s3+Cv+h/M mInLCeLmHmus0vv0/U/uU+H9xDf+BNDR3Zo5NIiBkbg71HJ/PFfy+/8ABY+wn0rxhpmuGwvRbFsz 2tnxJPI8UixM65wQdqAk+lfy34MT9h4nUl3m1+Z+6/SBpSqcE1JRWqV/w1PwdGs6pC9qNRSCPULZ wLhltylrOoOCgGeoXjOSM9q15WsdRuJIWjW2gkG63aRNkTt12jng+lf6c4b4T/L7FxbnJve5/9T4 DjF7p2oQyi5NxaRTK0FtMd0MYyNy7TxziruoWc13BPftbvhlMVtKzMscZzkqFP0Ff7N32t0P8dY9 TnoodLsNJ1Jbn7a+oXEf+ivbuNgyyl1PGeFBxg9a5R7eNYorC2a9ubOXa8d7cnN0Cx+YEjkgcden tzW8HZmMoq9jYuLy4vHtNJEF4XbEMc0MLvHFj5V3EDC54FdaZNU0XSRY3s9lb3Nncl2+0RNdTX0b bR5ajG1SOW3dPr0rYxcfd1MLS7jULzUPNMSx29wPswNySi2wDZ8wfXGCeeDWo2mw3b6leJO8KW0o V2lAQSqEALL9WyAKadmcjV1Y/9X8+beLUYXt7jSL6ZQABdQEKXZFJJXJzjPqPX2q9e3xuPLtIAym T975RffM7Dg5Ptz+df7VQ+I/xa5GkWLrzYrOzKk291u3iSbCzRAj5huHP0qnePpkmjPPGLyfU4Jw rooMhZcYztA6k+lbHLJa6iac+pNcQ2d7cyWaxw+aZJ03yIgGQqjH0AA6Ul9cSXsFxLPZxtawkRWs wby5kfqWcY5BC9P19Qzcbu5U0+0lmjWS3/eY+8+QQvXr6VsRWU8N4uoanYzNPDYeVYTvMXtY8kgY GcBgM+/PpW0VZF20P//W+Kba/tpLGdJ55IJQQ0ckRAlJBBwMg9azIr+ae8u543PnBM5mTe1w3HqM E9/qDX+3B/iVKNtjOi1bypXWd2kmlJOyTjzDnp+taV1czpbF7q4tYYpGEEdqCA9upXIIX0GDz9KC LdDlbe6muNQ/0eaJre3fyfOgiys4/vds/jzwM10UV5AI7m3uLSLUJBOu2VpCrw5wclc4yAc//rro IcVuS62xsJrSCTyJFvovMiaPh7ULgEAD6jNW0ntY91pDH/aFttTbcSIUw+AWGD6HIoM5pXaP/9f4 gu76GyuY0yGSUAuMfMg9xVi/uNOawtZoZDC8dwxkgmi2JtwMFeMY471/uAf4dTVnoQXMUNwsCrHF dwzIGinjX+PgkH3GP0qvcWmnRzWySX6hpU/eDblAR0UEd+MY+lbRSsiCUmFIZHs4jK0eFlK8vxx0 +v8AOoLu2LyQSxac9sTagGFSf9K7mT5u/wBOAM1Rzmgkmnz2jRmExtCoOxCwYsBgEHP/ANaq9xca fc2yi1gubO/tABJJcyCW2uk4BKBRkEHJ+Y9P10pkOdnY/9D4bMLXgtjDcCXfkqm75Yv9r8f8KsX3 h4WqW17d3AWWfMccGQGkI6Nzz7V/ugf4VSl0RFZXxikmsb+TeQxaLYP3i7hxk9+g61Nd2CwQvNbX 9ldXDJ5kVqu4Tg+hyPw60EPRFq0+3Taak3lzLasximgljaIGRACwyfqKoX9hYgwXCwW4Zv8ASfkX 54i3UZrWMbGDd9xnlx3KtAsrI74WNlUNjHTOfpir1zd7AtvIu1o1AbaP5VZnNpKx/9H4iv2uj9hm S586K0GYkaMKIsnP4/jUolfDXnmhRMuxUj4VsdePwr/dg/wWbSWpFYwS6hdK5m3eVA0EVvnByxBJ /T+frVjdDBNHBdIwCTAMwPy8HBH6UrakuatoXrtJZUvvscRkjjuFjVlUokqBVO/GO2cfgapRQamk oNxHH5AjUQNGpDnPJ3dOnTP607GQmoWpES78Sh2DTRxjJVc857U60iZHKW0plKqPmXO0rwcH6dMe 1BlOV9Ef/9L4w+zwyXS3W6JpFb50ChRweR7ijX7KGYW06rI6TTCX9ySv2Z4yNhDD7vIr/dg/wEc0 tibUbuK+jRBcOuoeUPOnEWUkwcYk6ZOO49e9UY4JohKyPvVWAQAEZraMrkSd3oaEd+9tG0PzPMG+ 71CHIzkfTj8ayru6uBuCjmYnAUbR8vXj8vzqiHsxts0kagSq6eYcqMf6ytxmeK3guhbyS2UIKTyI OUYngevene2hgf/T+O52tvsrGEZabBAdfmj9qz44LsbUiBckZ2kZAFf7w3a2P+fZq6sWLY3k80Wm zWNtbma5EYuJ7dDOSTgBJDkgHjoRWymkWk0IuvtBt7R0MitKQSgQlWJx15U8AZ+tbrVGLg7anPu8 Ty3Xlu8sUY/0VgNgwCBlhk9f6iqM7pJaHe7N+9UsgXcMqRjp70EckTSnF7Fa2s9/bTRLIMWYcbEn jUKN/Tp6f/XqvJIhG6NF6YYEZIFBPsz/1PjmeK1jMUE95DMxiUwJCGPL4+XlRyCecce9Lc6g9pYp pvmEq9wLlRswqsuMHd+A4/Sv97YLS5/zzOK2aKMlrcjyHnhkjWX95FKVKxy4ODtPfB9Kdco08sW5 lzvBO4AKcVZEo21RN50Miuu4KV+8FGKihmcS28dvEs0ckyxSM77BEpOC3vj0oMrIv3kCw3LotxHK 0bbDJHyjY4OP/rVlXtxPFdx7Js2kUe6YPFtkLcYwc9BQFl2P/9X40uoxPLa3AkiaJoVlXaenfB9D SpdQ319cNJAkEUUhQrGQATtBG1ew5I69q/30h1P+ducUtUPhRP38i3EsMccgQ2xBCzf7XpxhagBZ ZGYspDfc46fWtDNeZV/0lp3824DQpjbCo+XP97ryatg2Zd1cMz4GwH7wzQV7ttRWeSHZHbloxuzu X76Y54FTgR3s7ZHlBIt4DciQrjJP1rSD0JP/1vj82/2WRZIpmLPhiiLhI89TnrVOSZpbySHaziMb izKQD756V/0AH/OuKk7Lcjd5gVAUIU4BBxuBq/5lrJGwgAbafmI7YoAjh1CO2SeN4wfMISM43svz KQ3t0x+NWJ9avrjKyStKFjCDI+6oGMAdqCXFWKlhe+e81u0CynZ+5bksh6dB1qKUGYtEZQqupG7+ 6RnA479qDE//1/ivzDEu1XDFZMPkbicckfkf1q8LrK8L+7zk4Pzd+hr/AKAD/nPFRo5AU2kxk5YN yDVmWN2iDb0RETZEi9Quc4x260EXSmVFlBiMHlqVcfMWGSMc5prRbRuZiU6KM8fhQO6bsTLsypQB nUZzilWGaWUg7Y2HJx/hR5GT3P/Q+PXBik2KenGf71GVVgM4LGv9/wBuyP8AnK5vdsi7I7xxbMnL DI3DqKzCSsbOcBg2P9rvzUc5ondXESe5lEYi5EDbpGZOOtXMsSZDuB25244/KtE09hOSRGzxXERV p5N4P3CDhfxP0ojTyYisgeRiP3TBsAfUY/woFzo//9H46XPlfOQz5x0wRV21uIokKvGG56setf8A QAf85MndmZcl2nAVflPTHSmPG0eeMH261cW3JEloIzxRrPIxRfuKSePp6UjRqqgpkgDB7mtQB9pg wm4SDJbnIPpgdqrWoiJJvC4AGEzyD9aAP//S+OPtyRAhFO6RtiADnBqYqDlRzjkle1f9BB/zjli0 iTypGYZVW4BGOappdeVLMruETG5AV7gHAFADIpbrbFcLEiyBy6NjO4Z6e/Sp0vWjuJZ2ZhLIhjaP /lmue+PWgCJSfMZ15Y5z3pFAWeNrlC0OxmTjDbsEKR7A/wAqAP/T+PmckBQu5ZGy7Ef5/wAmrNxJ aJ+7toyEQfLJIPnNf9BB/wA44WVhJdqzxKhVTkgkIBWhd6BcWMSXHmRsJPmR1dZEOOoGD2oAyZYm kAjhYrNjLlTtIHfmke/nlhFtI2WiG0MBgv8AWjyAY8QjQM5CgjJB71Wd4wkT23zhh8+3scnj9KAP /9T45EMsv73mIjgqTz+lP89FxbwnNwwLAZznHWv+gg/5xxiPMsgaRQCp54yufpWkzpJG8FqG80J5 sjOMKpAOcDPTigCOzmR9wuJN+xcEdDx6VpCw89Y7jZEtmsnkyyeescpOCRhTknp16UAZxtra2SSR p1EmcBfWmiSBQjLmOQph1OCCfUf4UAf/1fkCK1ku5MoVUA5JJxj/ADirhsoY5Y38yRmHyTRuw8vA 6Fffr+lf9BB/zjkd8sQljMRIjU5HO7FRTSjcJAF6AE4AJoJcEyKOQPv2kYFW7XUJLIrLEgncqYfI K5EoYbSpHuDQY2toSNGfsqTzGOIy5McCHiNcnj29OazkcFnUD5cYBxQB/9b5BsI3huFkABYvnCjH Tp/SrkrpbvLFIvl7pOM/eJPrX/QQf84Tg0QtCmC7yBSv3Af4vpT7WR0DKpOPegghe8PnY2hwh+fd wCPT9KngmiEq+YzRqWHzLn5R68elAFS/lN4d3mEgsBxwSBx/So1jaIbldi2RhQKmSb2Og//X+PjK 7CSORWHufSpVla3VVhUEspbzc7Sm0d6/6BYKS3P+cczPMkSRZPM3MH3HgHcPQ1qJJ5p37jxztxgA 1YDFnAdlkxvblF74FRXnmCNGRQpc/MVXA4oE3ZEoZPJT5ssOCTS2yKHw6AjscUGTbkf/0PkmQCNW EDMNwO7tVNAW+8oZBySR6V/0EH/OOOeUbTtRRs64HWqy200zDa23ccqx784oAsO3kHkbpE+XB5Aq sWLRl2OWzg4GP0oAbGDjHboB1qWXfEg42BvugDGf880Af//R+Og2+ERsM7/vgirAiTZ5jPgpwsWM 7/f2r/oIP+ccS2MQL+Wh3E5Ppj2FRTCRpVEKN0yxAzwKAGx3kcZ2spDDpuHyn/PpQJTPPLPMqeY5 yNiCJR+A46UAWoZEkfy5OWB+QjrT/ssjylR8xbnYBkj8PwoA/9L45ulMeA6EqTggcirNktvATKZX R9uY0A+X/EGv+gjqf845IbKCW5E8Vy8asv8Aq2OfMbHQD86cWb/VOAjxna4HUGjY0p9St5YUyEyI oQGRsgjd7D/P41BbLBLI8gj2Rs5PkZyjjsc9eOe/eoUrysax3Q8wxpM3msYoA2SF6gemf0r80v2y 71riJVnf+0biO1WC0byifJMUgZQenHLZP+1XxPiK/wDjDMxj/cf5o/ZvAdX8S8Av7z/Jn//T/i/N 2zN5eGY+YfNPVVOecfjmqk7IAyRBo9r89RknkkfnX6biXepL5ny9OC9nGxGj5baSymMZDE9T7VAk LSOV3HcTy1cRp7MvGyEAACbjt53jgmmRTBBsKsrKTkjoaxlqy0rKxLvQxPGB5Ycc8cMKprcC3eIF vvEqI/5f59qxc90hn//U/i1M84bMZwC3IxnaPap5VAz+98zcobrnbX2B8+Wkgga3cCXBEeQoGDu9 KyVMschEYKbUx83V/cfrQVFPoOMTxQCRXJ3HDEjGD1xRHO0hRF2wMflZyKuUrqw7PmVzVhRC4UsM 4wTjG4U+S1EcciLyD0Gfn+tR5ByvnP/V/i8V0RoYsu0keS+5vvD3FajLb3ERkjYhy2wAIflJ/pX2 KbWiPHJYbZwqoygkHceMqcUssKzL5ySxlUfZIS20Ag9P0qHJLQrlaVyTACqzDac7VZfuD/P9Kq3L SCNlVvNYjGRwB71i3rqUoXj5mey3QjQTSbSo4HdBmqBtWLmVS0m7hs8mnd9ylFI//9b+LwXKfZ1t s5kR8Mc8Y7VCzTLIFTBPfjgV9TdnmciLMUJlPzOrluDzgD2rUVIUi3IhVVHzEn72KQOC6GBcbnkU pk5bBA6AVegmSYbVU5iO1l7EYoJcLEUvlQW8uZHR94EcSrlTn19Kzo2eKRiYw0jx7UbHCe+P89aC D//X/i6/eLGFORtHzgjrnFVJsScKrBEG4nHJPevqDxmrqxfG3yRKPMMYXYsbjCj321Utpbj58FjF GRub+Fc9Kyk3exi1Z2NKFFu0ZAd/zcN02mozZzSOA5YpEMFQcD8KgQD7NbOjJCY5OkhL/eHHarLX lsuCZHSRudhBKH6UAf/Q/i5k1GSZzHBnaThl6BgPWpbK/ckmHyZYw+2UnJdMcEfmK+gPnzbg1Avc AQxoqx8jI+9invqyystsAqvHJw+Mbie34UHQttR8jtAoPmh1cZODjB7iudnvAJRGDg5+Qfw/jQBO 8TSNEs0ixyhwcAZGP5VoySJDIqCUlVTB3nJB9BQB/9H+MMlTJKzOZAR8oA27TUVzfvAm1cHK4yfv CvoHojyqe5Utr+RjHAAykN98rknNdCpMUQBZZtxwwYY8npg1nz66jqdDMvJkmP2ZQHdxtdMcEfWq VvaSxTPDl1QEbgT0H0quZNXRmajWkf2mAiVoIfKKyhBvaVux9vwqjLAUuNoDOmPmVTjOO4rNyb0Y Wtof/9L+MuLS2lcysMQqoGRw2PrV0WcLK8ao0aomBKedw6EZP0r3IX+R4MlaTKE1oiiRSN5QDZtb nJ6Gqc9pNCi/KXywGOh5pz2Eld2Kl0ZbSZ4vLBKAEIOQPWrVrM78LCQGPz4521mtzdKysdRZx21s rpv2GX7zNzn2rK1LemYoGO4ybgo53dua1cbu4H//0/4zbeR1gOVVWztORjb/AJxVKaRIEXaAJN+c 92z617L3PJ5fduaaTwLGioP34G5iDkile5eONnmLgqMqF5zSJD/R71Putyu5nHUHtWQYnjZgoLqj bWLcHFAEYN79pZBj7KV6MOQR3BqZktiWEsb/AD/Kz9pPYfhQB//U/jLFvGyoi8Jj9239ynjNsfKe QMg6yN95a9jbY8ciuo7Y/vLf94y4LOx7+wqo1wZccNvjPERXGfcU+ZrqYWaLkbGZGR4+W/hPSmzq LdFaWNWXdkDuppGsF7pn3UwuH+UERbeVxnP+f6VJZyJbZkkWRUByrAHH4UFWVrH/1f41hHLenarZ jPKyEYxUUltGi7Lgx7UO1ivBYds166d1c8Plcb2FmWNDFtj8xUG5hyEx2GRVKeaL544yYmcZCxnl aZa21JImBCvKd5EflfvDx9frVN4gjYcEb2+Vx0NApK7QsiO3+rO7HGB0/Gorp3V1VXK7OoBwDWsN ij//1v4vIYnuA3mB1jc7cr95sVJPFJB5QGAqH5TIMjt1r257niSdmkZNxcuYnRiGLNgxKPfrVzTI pDgS+YsQOCyr09qgtO+xo3lotu6je7BxwjjJ/Osq4R1JcPhUIz2H0oAuW77o5fO2B0j3bV4Zh7j8 Kih8yIiaEMqscl/7o9M/jQFuh//X/jFnv3WLyV8oIW3ErjcW6cmsia68t8MnOOw617B5UI31ZZs1 klgOV2yKSVY5yQadPHI5RGjPl9S2OWqedXshSjystRomZElG3fCPJKDByOo/GoUuI5SokTyGjjCY 2bXIHQketUJK4F/NkIIDAY6jBNW5QZRHDHKiMoy8ZPzN+HWoc0tjdKysf//Q/i7uTLEQkLIwXhux H0q1G0sioXZS4P3QMZ9K9Fu7uzzxZIGkkcylo22bUZRnj0IqGTYI7eMyuWjm3SKBsVlH/wCs0gJI YZA3mh3MLuTGmAy+nXFaLRLDGrGTcxGRECApP+RQBiTyDzPmChmOBg/dqvP5sSLMoXyd5DjeA54z 92gLH//R/ist5Xtt0qwyyx3MfyI3Bzntn6Y9K0GSS4ihCNHEjvsO8YJ9uvtXoHDFJuzGTQNHGEQE LuxkDrTba4MdzEjwrJ5TBlV+APf9alyS0OmCu9TaurltTuJLWGOIXm0eTaQKTLc54Cxj1+tY02ly RKZJVwwBDRn/AFgPcfhWJo2kVISQmYMHaCJYn6N9KrlfOXZKvlSBshUG4UAmnsf/0v4s8mG32ohm wRwo+575p9rerHNEJEGC2SFHJ+lb2964Gsrh3mSORip+cJ0Ix6VVmmS4fy0kKyqvlj5MnPasA2GX jXU0UcdxFtaCHakvCpNjsR2P+NYyzORtVCrbdsi4+99KLGPM73NSwaOGXfK3zADCkZP5Vd1GSF3R DIqxsm8qvUHFOzW5J//T/izisLcJ58N9HLOXz9nTeGTHZzgD8AamWJUbJmjjmnH7yFcgMR6n8qhw T2OckE/2mNoYjn5dpQjI9Kx5RHaSC2ZPs7IN0iEYCjHBxWbTW4E9nqUqsfLI8teVdOFx25rXmni1 AQM6Fnt03MMkpJ9f0rOa6lRi27iJNh2Z0Nsu7Ijh4/Ki7nWLymtmZjuyzFefwFZHTBan/9T+Lm6d JQMtl8dDwRn2qvHCYCd5OCPumvPOixC0MISSWFwrhgkcTchjjn6dBSxzSSgq8iq4wHjAwOPSg0g7 LUurGsoWNpvJ3cEsDt47fjiqEkUMNwu1x5e7azZB/T86CG7sWVYpUCBmTEmxSvG76+1ZV1ZxxoTL 91Ty/RR7n6YrZ3T0Ef/V/iYFsoMPk3JYRgO5A3Kw7AVelaRsyqULqvyhun1rkg29zd6IkhKyWziQ mOVhtIDY+uKxbxhGc72Cx/KQvzDj1NWYElxcJBDCsQLyFRK0vUemKqvcXM7xy3TebIFChm+8qjgD 6UGlPewodiqyRBHJlKEJyVI61vWk80FtHNFcrG8jMkiI+2VQMcke/FFuhof/1v4k7iW4gZ7hLiVI 92fMQfOo6H863U1VzaqscrKUO8rIMjOOuM1550Faa9N1JGwTZGqbpGxhHY5/Uf1rHkkW4nZSWCR5 G5Fy7Y7UF09xjwMjxTW7eY2wh1dNrp9PwqNbcXDGV3lSJPvIv8ZoIHSKgEcqGRlwNysu0pVq4kvb vyZGY4gXFurr8pWgD//X/h9e3lgcSOzMzNl3Awcd61Yprr5J1YFFJCr0Vsdq886CjPqDTtHFGNsp fGM8Y74qbZuCfO8GT8xXgH2NBrT2NO2vxL5VosxMMJ+Z2GGc8Z5qleo6zSNFMvK4TBBOPQigsrxO yoXuiY3CfuSi53kevpVyz1CVUdZGZI3Xj+HditoK0QP/0P4phBG9slxvwEJAhkfDP+HWueY3Ymil jkYPI+xE+7HjOCP1rnO7lRuu5t5VgfcZm5CLyp+hHWpJ9QigibzlUb/lUHJZcdaqCuyJpLYZbalI kM7Ou2BRtiLccnqR+lOsZpmn+1fKI0OWLDOfbFatXItY043a8vOVeR3JEYROc/QV3/w60S6bWrRn tzcm9uvs90Otwse4BSc9FBI6V6WURTzOgmvtR/NHh59JwynEyTs+SX5M/9H8tvhfZS6b4XstQmnh 1N9I3Qw6RLMXZCBkzRjGPLGeueo6Gv7Lv+CS3h+Sy+EWhqV8p7a1iu7lGh8uS581dygeylgefWv7 Z8bZey8JMLT84H8pfR797xHxlTupH2B+3bcRaf8ACrWBO6JjT2mZkP7xmYbUT6ZZT+Ffw6/FO3Sx uPFc9yba61ieSXUJ7qchW3yyBlMJBzgK0fHPGa0+i1S5MlxU3/Wmv6Hk/SnnGWfYOK3uvzZ+EX7V 9/Lp+r6laancJDdXSq1siPiCaNwrqMdSwLkHPpXwZF88oKSENG24Fe9fhvjxU9pxtiNdlb8Wfv3h YlHg7CJ/yr9DutIhM4WWQycHHHCqe1XL2HypV+0NL8zALIiFgv4DtX4NJWdj9LUkz//S/iltiiRx yGNJFhf5HVAHY9/rWj/bIkIiiUhQ/wAxkXAPqK8Wr+pupJ7Gxa2sqlRbBryK5fYTGpkKE9R9K7O1 1HUNDsoooZ7i2tbZfMmtv+WT4HDH0Irlm3sF1ewmn2s95IdRefz2nfzY1kbbKN3I246/X3rauLrE I2NJtjbc+08OazFL4WPh1Ga7utOleKM29qTKkMkQR5WxgCT1HXjNNuBOlyGiQEMu9iqYjPXipk7I xP/T/kXjMsZ8yWRWgkzG8GMGP3pl2mmJDLNA6gwvjzT94sBnbn8a+TSbszWFx+majDMHJ2y7EzsB yvtVhtWu4DG8UKWMkO7dcwSl5OTweeABWE9ipK6sbUs82oKrXJeWbaN027bI/uTWrZ2lpbyRPp6u t8ke15Lki4EmfQY4Hsc1i9mYx3RstaPLdWsa3kizJJiUImzHTBH1/wA5r9Ov+CbvhCfWP2nvh5K8 7R2nhy/fWL2ThSF/c7QR7sO3avnuIJqnlVZv+VnTJXqq29z/1P4/tTeC7s2t2G2dyNmR8pxx1rmt Rs7mW2Aktjs2CBklyiSKOuD3614MVaZzttpoqSm0ur2AKIrGLalsQ0wVEOMADJ9jz70GAWs8kFji Zm5e6DgqD0x+FVFWmyVo7Fqa/utNlhv9wki0lPtNwuzO4DHJA6/T3qCG1006oNU8lYjcxmXEqlY4 lk+8Rnp2z9K0G3ZFbU30+DUpZLdUuXuIRE83llEI6AZ6mtWwAiWFpUsg0QWRVjkDsjEcUBF3Vz// 1f4udekvGulR2UMh3o0Dbh83rg08wSw6fAqQxSTRHzJjLwrjjP4+1eOc5sW9wmuRSWN4ySRCJHZ1 kCBdpB8sDoR249K1lt4AAkMcacCNXQbQwFXB23AbFHFLKbebcoGVQqMEkDiodUurqdbXSobWGB/9 Ra3lvBgznIyJT0yOAD7100+obDWln0+5sNNsRLqWqmUQzuo2JDzknd/IcdqvpHceKrnUbG5insbi xXM0/knc+zkjng9OcetdVJ2MpyVrI//W/iX1zS2sZJGkAfqS/TzQvArkIbZ5C9zHHtVH2jdyAK9K HwL1PNlJctj9J/2PvEP2S1W3v4beWzsJXmW7hk2CN5FIhcDP3Y3CbvxB68/vr+x1rt/Z/GHwLqdq z20NnMBe3cEG83zMF/dKCOQRzgcDg1/c/h21X8LZxl/z7l+R/LfE1SVHxSwji7e/D/0pH94/wTv4 9a+H/hy7CxxCa2CvCowY8AHaffB/SvwJ/wCC0WkWjW6XlyWt5L2e38iRQSluIpfug9MlQSPpX8qe Fl6PipQpp7VP1/U/pHxuXPwJiJSX2L/gfzneKTvlED6QLmEiJrXyMtdtID8zbe4OAf8AJrm9alvp VsLlbdvtOza9nAhUwpFtUSOOmeeTX+ntB2ivkf5W4qV3N+p//9f89ri2u9TgeeO4tYJbVRNgSDzW O4fKqZ5I5P4VHrfjTWJFtLT7FEml2dskP+ixs1xcygbWZj29ce9f7MpXP8cYysy5Jo1slpaT2Wpy 3d1NF508DwmNrVmJJTOeRjPOO1TWehPFJGILlI5hKJ8sdykjnCg4+npW+4nuTnSfEO29vh4hl+xz yCyfRZrpVlBX5zKoHO0nt2yfwoXiPZ+VDcrM8xAO6YHeQfc1utkZz+E3lvZZJdJWSxhWCwtTbqxj xvyWcFvxbp6VzOrXFpKHtrx5FR7ky/6JEyoeSAr47fT0pnJLc//Q/P8A1DURstr2yshBYWlstvPL ag/a7lRw7kdCeT/kVi28MYukks3nvZSrO2VJ8sMTwe/GQK/2pjuj/F83hbXwsvMljEduGAilP7wH afujJzkjI9q32sbm+toNQsGstPcyJ5mnFD9qmXgBV7DOM8mtzinuXNVtrxbhZtRjWKfyViSORNlw hHPze2MVyWoLcrc+VJbGWxfa4NvkBjgg7zjAOf0NBFraFvQLPyY5Z5YZI7qV8CIS5iXHf6kYq49v pWs2t6trczLd2t2LeRlkaNi2CXK54YA4Gf8A9ddBopLlsf/R/PiXTpLW6sI7kSlpp/s9pcSocNnt uHA6dK0LeK7l1A2BaGC3FxtM0a7rhGXjn2J4xmv9uUrux/ic3ZaiObefUYbYbUvIZHhEuMscZIJX 355HQVEbO5W980oLgEFckeYE7FcHtWqSWhMpW0NS1ng0R5NIaa3aGRkmWJLFWht2ZcsWbrkccDHe or21ks9QlFnGpjuJC0d15REEhxw7dxkAcGqOWb1sXp43kghkv7SWRxiC1vBGFtsr97jvnjIzmqUK tbpKryoqjlmiywTHeght2bP/0vhvT9ItZdRbU9QF6YUiVkleX93I2epXuPY46itpm03UJWiNtFJJ Cx8lpFz8vTp0r/cA/wAOG23qQTy3Wl2n2PyoprJpvPjMSqrRSjoS2M44PH8652a/ZL60KWUCkP8A vPkDIQf9k8Z5q4ytoRK6TNaIWVsYJ5JvssV1csknnMI45GPCqM/SreqaLqdoFvrW4SS35M8CqTLG jcDBHrnmtTELLSNQtbeZ7lbcIwWeReN0MDDqc9CMj2yRWLGsVpE53tcCcs0SsQ0jDPQVUPiMG7u5 /9P4ejle3lt7gIsKMRHHbqB8vHf1PvUs4mbUYrjVC2yH96qyRn5lU5RQO2Oeea/3QR/hOR3Gj3LX TXkMkVzDMyPDsGyRVIGd309qvxWMK3VsZnMWJArPjJTPU0GcpdEbOqX11kQQQpLCHDNIqi3DHoTt UY5AGSOuKyr6OHU9RnFnbSQQRohWAy+cSQqhgG6nJz1HetIPoYuSWhj26FVmkQmA7/L2SKQzYPQZ qxqpmSG3uvIV5pE2LEwwsnQZP5iiUmnZGTd3c//U+IIFu4Y20+aNDLI26MyMG2b+cbs9PT0qzLay QzQIWChVGIlXKE9zn/Pev9147H+CU3rYmk2WTrLbOouSP4Okee//ANaqIhmlLvLG8pUkhl6Z9c0z N6I6DS9ZlsUmE8Sz5j2y5+QemT19RVO41iWcstvKIp0I3xeVmIIfQn8s0GN29xbRLi8Z1EiorgCR m/1cYyBkn0qxeaY+mH7RBcQTwtmMNA4YkjgnA7Ggzm2tD//V+IWtJPJjR5sytnbsBVhyetWYIrqJ zbrLkStyjMCuemfbpX+7B/z/AJYeEhWjkCJKH2sf4z2x+lTDzNOVkRhcSy4MSAZX1GR7U72Ar6dH BbySG4Ess1xI01xKzc+wzTo/JkkkcwfMwIQ43smT0B/Dt6VvaxDTuy0b+1Km1Mc3n28QMUhjxESS flz6jvSRRiJ2S8vJrY3EI3QwqJoz0YZ546/5xQZW6H//1vjhrK5w0asJ1jIAcKFd/wAKbaX91b3R heEqsJABmXBlBAxiv94D/n5krOxLf3IkBWVvnDbhg/c78VElxJFb7HkSaInbFBKoMeCSSMdweTj3 rWF7EuyWo6fTWjHngw5aPcYYPlT7vAA6c/561nQNbrgYGW+aSNf+WZ5yP8+tWZtrlsdQZ7K8tIop mmuvs6N5MZkMksIUc9DwOOntXJR3MTz/AGiHcJHVFBCMiDgdAwHTJ/8Ar0GZ/9f4xmileWC/mtzL GhML3alVSLABVcdvXNT3UsGELlcbd+7g8V/vdD4T/npluUruWeKMMI5jbY/dTsv7ts54X8qp2sd1 emXAZDEu87wVP4fmKohtLctwRW5mEKS5mztnzwsZPr+FWlsjaGdZZArK/wC7C9GHr/8AWoMXuSRW G9lAuEGQHHUsO5pi7LnzF5GxzE0si/KccZFAj//Q+N/sqsjwwOrTInClsAdcZ/I/lWesU8RWGJUk kMuZpD92Md/8+9f76wWh/wA7czWnsn+zJeNkKrgSqo+VumD+eKorE1xcGJpQkbANGytyCDyp69ef erMyytnbpdkbsiIl1L8BiOOn9DSupmmMzkGQSbmYLtyc5oAS7vjbyrMkSPLkKAUBT0yQeK1tLnsQ 1yt1GN91AfKlaQRW9uz9SRjJx2AwOKAbtuf/0fkKNzHFPFIcup2oueFAOapT6hKq5EeVi43qnTnv 7fWv9++qP+dcjjkM0PCs0k74DAAKg560gWS2mjsoE82WV9saxLu8xj2H1JrUTdlcmi3rHKbmxlsr yOV0kin4YAcA7e2feoomBbKg8kgjHWgxuyaD91K21doPU96sGMKC/HX8TQI//9L46itYvNmmdA3m HexxypHHFQTCNMCMMQT84Hp7V/0AH/OfsXrFVhlldNjx+SVjW5jEnzEYPHr1waqhZonZLglgzfLk YwPSgwe5bEMG0jA3ZwBjOfWnTImAOqdF45FYuTFsPsreJ5VT7vPLHoOeppksA+13FyqyLGH8tSG+ Vu/9TTjK17gf/9P5FtY0Mrv5Zct69scVVnmBnMXlhdjAhiOelf7+Sd4n/OOSRSKZMysWAOB7U+f7 M27aoBJwfftWZUZco2AXJiMKFlh35LqMbh/d+lX5o0iiBB3Ejp1x7VpT6kmd9mIxL9zd1BFOQb22 HJJHGBzWg9Op/9T4ze3kcyopmVQ/lsGUqyE4/wD11OYWt4NzqzRjCb+uCemTX/QAf844pQpHlWD4 5AHJFSQHcFkZQQOqnvitYxtqBBKVaZELLGGzsXPT2qWOIpIilsgnaxxkCrAtTW6W8skYPmKXwrg/ Iw9qqzw5IC4Hbd2WgD//1fkL7LcIqStNb3TRqFgjEGwLjsx70wSyCU+eixyNzJ5ce2IEdQB2r/oI P+cclaR2BcAYHUDpVCWNJVJbbkHI7EUAXIoUkhiYuVMDBlKn0zx9KdcWz3b+fxuzuYqAoP4DigCC SQQsRCAZMYYEfL/nrSxyiXd5sgDoP3UeCTnPOD29aAP/1vj1p/IRN0fm+ZJswnVPc+1aK2ou4nZF 5QYJUcL9a/6CD/nHJ7RLO2VLWOXzmbDMsLnAfOcHPoewqpczQm6aGJma4TLPFk/J6kigCrteNjIW BcjnB/nVWGKe+nd7eN1+znc6gffAHLH2qJJ8wGrtWcASgAIvOe/4Vnm3I3FUbyw2FPQZHb9acVaI H//X+N2ZwwHzHaMEelWbJBHMZVRXLpsyRyue4/IV/wBBB/zjlh4h5q5yT/cHO40l5MtvbrJ5O0Mf LbH317c4oAoI8CuFjDmPPys67XOfWrj+YAFR+B2B6UAUTkSkSEsc555qZ4943BGIxkEDignmV7H/ 0PjqIyRKHAZRnv1FPM8rNncSp4Jr/oIP+cNS1dy/bPbHfHKchk44z9KR7VJw3zKiDhMHnFBXPEqx WkdtJl5D5WwjA7nsagLRxgMuWAPGepoMnuWo0F7GZHlVfKOBCx+ZvoPaqlw/lMu3AVT85AoEf//R +QBJcbTNA5TYNrEdwfUVLbob3dLdsViR9pcDc3Triv8AoIP+cDmYySEbni3iWJjmGTG1lqORprdB GoL553DnArNzsImTyp4ivIkPLYGMmmeWXKqm1fLXaBjk81UZc2gAlrtGe+c4NG8KwUjDDg47VRqp rqf/0vkORTI5ZR8iLlj/AJ/CqTXDLuRUHI+VSOor/oIP+cW6UrElpaW8u5nZvNLYKdhUgieKTYGA GflB6mgbdhZI0LiRuHj6U2d9yqrMxiPJUcY96DKTux/2Py4Fkc4hn/1THr6Zq7EdkcMO9W8mPy1k I+9yTk/nQSf/0/kPZh3BlVgzct2pbuSKDbGoJIHzEDr71/0EH/OLFpqxVSRWJLKVULt9Cfeq/wAy 4CSsFB+U55HNBRJLukbJceYwA3HjdgCkgUsdvVehzwMjigBGglDMYzgD86linM0iQShSqqQXbtjn j9f0oA//1Pkm3sk8lpJZBEVYhByxl9OKhdG8wLglthYYB6Dqa/6CD/nHIogUb5SOeQfWrDvLCAwb lu47UAUZ0WWLcQGw4O4DkEf/AKqZJCfL81JQXX7y9D6UAMjSVwkkbeXKjbs9A1aButy/6Qod3bmV JNrxMMYBA6g5z+AoA//V+O5Z8/L95W4x3NU5cPILe23MVTL5PK/Wv+gg/wCcctwpi2M1xKsc9uNk CIpLPlupNJaOySs8h82SRssGySx9aC4bltneGQLsU+bwwKghRTbuWKPcYox56jERA2xf8CH5VKja TZrF7MIw13JiSREZlA+Vf3St9D7/AM6/LL9tC/ktrtYVSOGKMmO/mXLKSsmGC+xxivifENW4OzD/ AAP80fs3gI7eJmX/AOJ/kz//1v4t5DIb8m1SMWTt5isOGYE5JI7fmaZeY3MeSd2B71+mYnSpP1Pm qLXIkVLaNyWkZXbaflVv61oqGjEtxCsYkZQPnGdvbgVxmo7zxdSRpI4wFCuVP3cdTiont2EshUHZ 2OOtYPdgTxSoqOsiRmQHbEWwQCO+Krm0kRCxVZnbkEDJHfiud7saTex//9f+LqELs2sGD9G+XBps 9qmG8tpQGAB2f8syfU19geJGKS1IIWmjIUDeAcEk4NXLdd++SeeI4bKrjbJGPQ0FKKjsTXc1uU8t E3ljlFAz+NVre3lufMlCoEjTAjbhs+30oGUnN1FOjb9q7toDDgH0rcaV1CGbarSphXXken4Um7K4 H//Q/i3S2BulkV1ba2MkYJHqKvfaEtpTHEWKOcsz/KAfYf57V9emmrnkJXdgGoyxMwUscKQhPIOR zUFqDMspUqxiO9oy20Mc1i9ze1tC5dXKgJGhdVYfMD0U+1aFgsAXEi5jcYZ/4x7isp9AKNwOdkas /wA+0swwQB3qk0oj3K3ToAlaLUD/0f4vBbxk71+VmGQPWqlwrbwWLxEjYGUcH0r6duyPPG2eIFe2 nMtzcbt8coXZHEvocdTVp5XI8tySp4VOgHvUqa6gXonWAIXVWDcE+lU/OK3MpgChWbhQKq62AWb5 5MHaTgBucZpJrZQ8YywLRhgFIO36/lRdN2IlHS6P/9L+Le4jdGjSVjuIz8p6Dtmo5JRFtXoq859a +oPHHxXLyEIoYqOxHy81eW2UMxJAicZKg4A/CsZfExWWqK3nRwyGKFgEU5ZicA02a/ugENq0f+uH nGQfwjOce9SZ8jHySpdqqsq+YD95R+mazmZo5ChYOE4AI6UbDUNdT//T/izcPBCHtwsMjEqG6HkU RxPbW7J8qzStn5BhW7nNfQHjcsexfsYpnyVkTz3O1EB2quOtVtTgns5RCTFI4w2+Fw4bPOMigZUM 84AVt7Pjp2T2qZgrKszou9eDn7v+eKAEe6M53xpho/l+U8NjuKe5MpSWNJMooXMhyue9AH//1P4u I5LiIksu/wAw7f8AdPrUEysTkIsssZ+aMnCsBX0Fuh5C0dy9CkUxVQBE3Ukc7P8A9VXo7WW33yLM JYmJD4Pzv9RWUY2lZg3fcz0Rg7M7FWkIBOOUA9K12mgYMjOrSom1ZMcn8aaejuIrIFYoFYkxjKn1 rNuGmEitwSH5HTNZgf/V/jv0/fc26wRhDhcsO5z0qaXSpLZpI7iVMNgsiuAsftn1r3obaHiOL5rn NoiQXsrSyEwbiFVyPkHbmqlxdG7ZtpWOHJAcHAGOOKib1sTBPmJ4bUT7HGJiF27jgs2PWn3lnDax xyxtLDK74dAuYgOvWpjujUdNIFjBbICgEE9eaxXupt33cnPyOa3eiA//1v4uZJZnT94drIdxxx5h qGF/MaQzwqU8sqDvIaNuzfhXst3Z5i+AvwoIihjXkx4Bbv71LI5YmOVmKuMEgfd/CkZFuPZHA0EZ 4K554bnrTCdpKnBTaFLY5FAFeVSG5kzGB8i45FNF0JCsAiyVyPnXGOKAP//X/jEgdYuJLgAKxB3/ AC7evFF1Il3G6xoWC4CkZGQK9g8czY5HRwGIjVeDH0zitF5VkiNxAnmzJwqLwTQAltdr5zLOwjcD 5QBn6j602eF7qdVZ32ZwDjhR6mgB6WkiIyySRlAflYdcUPI6RFAiyoOzcAiplogP/9D+L6G4v9ry QuEQEDaVyDjtViO4jd3kkw5kTypcH5gOeMV60NrHjmgYv9HA3OqlPk56jHFc/dpLFNBHFG0k0/yK +OEx3NUBdiinmjCylTInyhh8uT9KkuTLHsgK+Y5UEbRQAun+aJHjj2ybvvRvwq46Go9Ss7j92ZDE gZvnxxnngVtD4UTK6Wh//9H+Lu1u2tHCKTN5Z4jJyv04qK5vrhyfMThT8u4fKOTkYr32k9z58reV JLtuYcRzRHcWxlMD1FWrG9kSYRSODAGDYXu3rWKTexrDYsS3Ukt46tJv3cRbuNg9P51aR44oZ1eM TEpgx7cnPYj05H6UrW0LKsFnPFCbm4G6XbtZiP3m30wO/wBKWSZolwAwhI+4e9D0Vw2P/9L+KiaH exaJTsxuBY9T6VpW1uupBFmby2hj2qAQqNjufevRvpY82Hwl2MqhTLAqPl3DkEDtWneGG4hBiJGF +YqOfypEzWxgSyCNg5OGjOAelEWyffIxIlU5Bx1Haq5naw4LTUe8OVwFk88DfvceWreoody22RIR M4wrhCBIg7n8OtSWf//T/jIjgs413uXclt2DnP0qpemGJopoiyuzdMYVK9A88pTanNI/yZDqNjAD CMB0I/rSwF74xM2Csbfv5AMZ9F/SgDb8zYDHkqmMKAPu1VmfzUWEOuQeTnDDAoAqQ2qsXVf3mznc 3UUnlrKwVwcA7RnigD//1P4xltna3kVUJ8v5lx95RWXA1ynyPFujVtyM6fdPTNd70Rww+JF37VdR QMJ13wfaAI2SPfLlsD8h+lV76wexk837QZEwJpGJzsDANjj0zWB1U0LbNNLJJOoEmxdy7R852+lX P7VvJUQfZ1xFMWi3xgEk46nuOO9ATXUczwy5RraO3lyZH8snLE1Xgil8ufOJcg7EKjI9BntQZn// 1f4qGEtvI0azSwNJ8zgNkLnt9PaoYlkVtm/c0fzhz1PNdAoppWZfjuXILxTNBcRkAMi/N+NMhnnt pmkEhExfzDMR97vmocEZzujVW+W4Lhyt1EP7wzk+tTGS0hQeaqROU3KcDdj/AAqrLYi3Qz7uOGMi 4ife2MhgMDkdMVkh2knJZHYkZB/gpStYrkZ//9b+KSaMjygkU8LFtwkjyq9Dyf8APen2U0sErRy7 JmJKnzBnhu9Bg4tOxox+ZYbZYkKur/u1x261Sa3N9cy3Uxb7TNx82cyYOcY/OonsPkd7CJbRoTGz +TEqEbVXOM0kcT2qyNFJJKAmPLXADc5GPSsrdDVKyshVu5ZXCSEKyccnn6GrF7M6pBsAkAQsCq/6 z8vpXPa2htBaH//X/ichumkcRTHbcL8wbbtUir9rLPeEwMisyMXSZm2s2P4QD9OK886ou1y5BbRy iWSTMbgZjRVzuP8An+VZMqC0lY4MjHDrv4C/X9aBpqzuTXN6xhWVQiRkY54Ioh2zNCFhBG0ky5zk 9eatQb3IC4kPmeXGAVzj5e1OuLOa4tTubAVtjI3G4etXK9tAP//Q/ietbR49wjAZQAM9hj/P6VJe qAiqrlN3yq+MsT9K5Yxcdzd7MqbbqEQkCJ1kbYGY/exjJA/EVdvXtYtMYrHbtLNIC+Dl1xxz7GqM CjYRrOjBmiaJhsZW4yfQVY1LyPM8q1jVyiDc4IGwgcj8OlJuyuXT3KtvfxKGjhtQzRpgI3y5P17V UeF0aOSaMNcF+kb5SPI6Cs3N7Gp//9H+JmSK5a2JZtqY2vwDgVLGsiS7JVhIWJWRwQd+QMfj0rzz oKs7yFHX58sSEVRgL+NWbCw/s+O3AmN1NOm+WMLmRMnv/OguN1ewt0GRkAyuSVAx8+aSKNjGHOQ/ P7ljhW9zQQV4YJldmuHiFqDzGfvhj059KsPPPJceVI24QqqK5XCBccUAf//S/iQYFmkb5pfJbMpA 421XaU8Llghbggc+wrzzoNHToLIjLttl5H7xcBR6g1GmxZJUB81Q+MMPl/Cg0pvoQyKLTaPLYLM3 zEDITPpTo4JDJH5KZRhgtJ95fcUGhZuFhWeKO6yEUfLtXcc+4qNL7dIiQ20DiBiQxGd4PY9u3610 JWVjOUraI//T/iGu7qYqirkAMSSvNNQPcQLCgPmxtuVyMD6A1znXGVr3NWL7YGUtFH50CgB5B97s MCpY7Ga+donRXlflFPAzyT9BWtPaxE5NpsIrL7Wn2Z0ZhaNkiE/KOo6+lW5rNliAt5FidGwUJ+/x 3qzFSaKqieNiss7IEXzDNEdpUj0I9K+gvgXe3+s+MLXR7zS7jc8aw2urx3CQ/a2kdPLHl/e7HJ9S K9nIIc+cYeP9+P5nzfFVT2eQ4qV/sS/Jn//U/M/4Z6Xf6Xp/h2Rr6GS41W5is9NtXIkhZJJBDK8r fwbWQ8dSM+2f7iv+CcGlNb/C7Rrm5t4lvoNEitZp7fckE0pVHJQdwB69K/s/6QdSMPDjBRWjuvyR /J/0aFUqca42b1ik/wA2YP8AwU58RPoHwV8R6iZZkWxtnVnXIuHlaM7An04I7Cv4j/GFu76bdyXV 1eb7SzguZbjVQVM7yrGTDu5+ZS/Tp8nWvpfox0vZ8IV6veX6f8E+a+kzKVbjbDUuiV/x/wCAfhv+ 1ff6jqvjae91GGJ2l/0CeWZR9oheBVVVVegAVQM+9fIcKCOQqBjc3y44DV/NPjbUc+OsXF9/0P6V 8OIqnwhg1H+VHZ6fI8ce9mI6KyKeSfXFdEBOZfLml3rjKMo6D0r8UnuffRd0f//V/inhiaW6t4l3 paBcvIDnDegFS6hYSQ3RW0uFKiPGXjyrEivHrIE+xraJNqCB0sy0UiEHBk8uHI759a7v+17hLS7h eGK4eSI70YbpDxyK5XFMadtjCg1DWryItc2KWK2K4BtTvPldQenp1rt7i4SLwzp1tZW0d5dee9xc SklZSpHCe+cZ9iayaa0ZTk2rFeEanby2Dajo9/p8N8CtuZ7ZlikwhbCydCcc9avi78xGWDerElV3 LwMHH9KynqroINJ6n//W/kiFo01tL5hWFo4y25uDnpxnrXCvILqYac9y0SWkguHh24DEnGeeCpxg 4r5BOxtzI6nQ4haWbRw2kCCZ2W4AG3cFZtu3tjoa3HtN1tNMvyyJHtPybowCfWs57WKNq7n1Kz0P T7jUtHgsrCL9xbXkQCS3in5jIw6n2+lT218UmtF0y1t7/wC0Mga584x+WDgnHrjJyPbjrmueb90x 3mdjdRC21ssi3CJOiEJKoEkLAAEj2J9e2K/Yv/gkr4S/4SD9qPR4nf7YtpoJklt2uBDv+Yu28dwF XP12V8pxZVVLJ6sn2ZpVqKErn//X/jLhvWN7LDdSMht1Z7NlfziWX+8MdOo49RXR2mopfae094jP ffaDFbW6IzR9cCSRf4Rj6814vL73McierOZ1jR/tF1HcRQxxvA4lZXbcA3cgf5xV/RtHu55Zz9rt oraOESYeQRyM3ouT+gqhc+vkU2nia48v72WKhicI231zVtJ9Zu9K1S1hFvaWoQSSahcQq8rbThUR Tz1x+VAc/co28C/ZIFmninuFx5jCPaM49O1WpIrexsY7q3mtGk89nvIZA3mbenBz19PagqHwo//Q /jP0+z33JLEyte/NHCeWX6Dtj0pb6KFJmtjIqLgqDnqR1/nXjnOMtNPtIIFWNEVoMmFlGMEj/wCv W/pUct2zW8i7TGnmIy52r9f8+tAFy+sFSF41nV3zn7VE3zcdQMfiD9K52yvAs8dtLK0ksDGe3tW4 3AYzsPTPA4rrpbEy+FmvpUk1vaa/LNcea11dCf7ZLEiy2IGdiL3wuDz370+F7wxtcRancR3L4Zr6 AbXmDfebPfOf1rrpR97U5p7H/9H+KrxTqGqtaSadPaWTacbgQwaqV23wZhxnsAcE45rjrOCeOT7H FdRlYxkvIwWOQjHUnpnNd9NbHjN2PvH9jlraLUNXtbiyju59Pu01SUE/aLZ8yJ8o7FThOOmRX76f AC51zQ/ix8NLuymjIgvUv1itiEt7RblIxucYwNuUG3scY6V/c3hJat4a1actuWf6o/lzjmcqPiTg akf54fmj+8L9m7U01T4b6Fexvu+123mXIICrHKVQMV9iQ2DX5Df8FiNMV/BWo3U80Cf2fMkkcd9Z GZJlUhBGh6Anerhj/wA8z61/KHBD+p+KtNR+zVt/5Nb8j+oPGOLr+H9d96S/9JP5mGW6027sLW7i jkvYR9sgmc/I4yUI3Z45U8VZe6eDm5bTwnlvHlIFuXQMc8NjOcj88c1/qJh9aaZ/lJXVlI//0vz8 GnNbrcXbzRyfbiYhc4MMsHz5G9exxkf4EVf09LOxk8q+/eRS43tCwZwO5Hrx2r/Zg/xxgk3ZkTav ajVJ7eCGO3jllZbFBxJImOAR2PXisq6L3bO08k9q2SltGiBzIwP8XPAP41vH4UOUWirbLfQT+ZeY leEh4VkHQdAxz3GQRXVDVEuTBFeEzNBDsWYLl1cjd8x9P5dq6ErKxnJXVjRhafU7ZrezRY9QZCYI LpgrzgcArz7dO1cnaww6jNJBd3FzaSxq+2K3thcfaHTgoTngZ4yKZxyXvH//0/gOGG5VI7aSbbZf MoURhZFDDkNnnqenuazNKspop7keXKsKt5RnUEoSecBvw/Sv9qYrVH+Lz2Zat5JYZVDFHUMVlgOd 2Oxz0/n0roM215DPElzsZCFdBLmWPoRW5yTWoxbjz1VdSKGYRGCPbMd2xflQnng9OO9ZV19qikS2 tJmSEOPMJbzUcL15q4xuiVFsuarFeeRa/ZD5kUpRbwBthjU8Fh9M1seVb24iS1gwllCqPNEF8uQk Y5wfX8OetahySP/U+HZ7wXVk9tNA00kT+ZFLGOUI5zj8OfxrlYo74yw3cMrxSXc7AqYwJEKkc496 /wBuYrVH+J7Se50s1o9jdwXtoskkskflSgxbSSww3HPXnmnQf2jBFPbwJCttdHzF3rhoZBkkhsZ6 Hp/jWvKr3ImtDTtLmCzt5Yrqxs7ma5b57maESSxnG3Ib1x/IVeaxtnSG4m1FLaHb5bRth9wxgHb1 4/rVHJJ3ZykhvHaK3TVrmK0tZHlVM4RyfRT0z7c/zqbTHjt/PJj+1NcZYmQlSgA/unvQSf/V+FUj Ez3czysQUEaxvITk9gq/n+Qp1jus/tE0sbgxxFYDsyAxxjJ7Cv8AcA/w7mrC6Nca7Mj6b4gKS6VJ DLd2d7bRqjzspwsTsOVbJwD6djWNLYbXMG64V423RBnaRzk8ZY8mhK+hlboWnhlukSHUpROsQElm jRgLCR/+rrWnHeXmEzcvhCEZHbPmLjAB/T9K3SsrGAx7W7uZCt9HJJHMfJjkhlKsY26Ju6D6e1a0 2nW+m6XpskVrcTywOIZWx5zKvYn8hmtIL3jnP//W+D7q31TUrsRW+LZHfi4kjLR2nTP1/nW1c3V7 cJBBeGS9uIYxDHcsdxcAAcflX+6C0Vj/AAmbsrjYLbVU8uNN0MBB+bO3bjsBU9g9zcNLZ3Vt5nlu GaYkl1AOAM+h4oMNizcf2hBcmCKKOYyqSluow0aKuSeep/LrXOm7u9OmlulVmjddkwiBLx7jj5QO frQc5syW0KwC8FwZCYeLVwCwb+8ccgimxJPq9oJbZ1dLZd/3sMCOwHXsaAP/1/hZDLu/dq0sgP8A q+5IzW3cag0a2Ul7A+0gWiG3TeEIBPJ/Xmv91ofCf4H1eomlQWVybhGkkeUZZmPylB6Dt6VYEEEd tL9muplEZP7uVssCOvPeqMk/dsc7PKJpG8xPkkAQxp/y0I//AFVNHNtWSAoyqiAyfu/mx22sfx4z QQaa/wBjQ2sVtp66hCzLvuJLyZZkzx/qwAML14OfrVK1QsZWSRniOSsjfxYzj88UETWh/9D4xs2a WBpbgOkxHyq2AIxxj9Kv2mnPdBCZo3zkM0Z3bcdvrX+7B/z/AJiXTXNtqSAKp+zSEy+cN+4gjbx0 x9aZJb3VxOLwTGLynwV3BUbd2I/Dt0rSCVrjas7HVm0t3XzJpbSZVUZ+y3AIyBkjAOfY9s1Qs0j8 5jAAYpXKhWJ3REd/cVoIS4FtZ3cqTjzQ0ZMbD5SrY4/LNZTpLJ5kse8BT87Y+QEdMmglqN7s/9H5 BsCi7LzzoxJL+4f5uUxjqvv7elWNTikni+0MAsiDCseN2BX+8UY33P8An4k7s5B5HUgytljw2elX Ddwvp0kAsw10r7obgyEbRxxt6Vta2iM5NWaJor2OXTmt7iCJJI8P5xkZWfbzzzjrjgf3as2FhY3c UbG6it7qZcoWztkIGcYAzkgfpQZFdIltJjGr+U5YhpV4Zs8Hj6ZqtcW2HW20xJpobS1U5k+eQbQN 5OOcZyfxoJcktD//0viDzFkIWVGCOm3AyQQOtPjXys8ebG42qHHKCv8AeunvY/55y2EQ+Un7wIBt AJJjUZ7CtOeXyrWCNkWEwE7J44ghuVIHysR12kdTzya0i7q5nU6GbFse5jYIGVnzMwODWhKwa5eR 42a1HHB2ljjpnmmZlq9k01GtfshZWZAZCpO2LIHHIznrWfshd5IlfKbs5Hy596AP/9P4we7iW8+y xQ3ChYczXTx7Y2fsqnv/AEqFWlilcLIyb1+cA7cj3r/fg/52pvWxrzX881gsKxBYQPKJx/rCOp/k fxqhFEgWFIcRup2sxOQaCCxcQOkgG9d27/WA5XFMPnhwgXep/wCWq8qMetAFi4S1eNY/mM/cBeKg jigZTCSUcdGJ44B4qoxuyZfCf//U+OIyFbkE7fl69QP/ANVa1xfWkem3NubNWmniC2wI24wwzg/h X/QAf86zfu3Mu0gkFt83yY48v0rY02KdPMukigla2G4JNcpBI3f5NxyTxxgE9KDNu6Mi6imltxKW McrybQoXcoA68/l+dOh3BZC6KDEAVBG0tQQSRXEU5BjgeI7cSrI28lu5+h9KgZhM+1W2kHDLQB// 1fkqON0tb2F0DTSOn2aTnlRkk/Q9OlV7lILae3+ZHjMA8xCeQ5HP4V/0AH/ObP4SaJBGklyylosZ BUcA1XQrcmSSSTYo/wBncTjAwPSpk7IxJI4vleZG3KuQgPUjtTPOYLEr7Xjbldv6j8KxAdLDPJHv gGxAdpOOM8/4VF588UaQkF+gPuemaAP/1vkoyGNkkJWPcFXagx7ZNO1W1gg1FBbul5b7cPcRsMFh 1IA6iv8AfjyP+ccI7WJ7gRFljgWNpGmxkjaCeV7k4qhEyNuzEygkgGUYJHrj396ALBvX8tYFICR8 BFUDd2yfWoxOnzeZk54BNbRSSA0bYr5RMh8xAjeWkmdoPPpz1rLs5HS4RpcB1bkKSBj0qgP/1/lW 2kSeWeziTCzXHmIrHMgJGAoP4/rWfJJLaQyWDuZxLJubcMsuM4/LNf8AQAf845nwLbrd/vLxYIxE QwlzyfQVbbC5EJZoyflZhitlJMCEWIaXeJVaRAGRJPlUHvzUkuVaIRsFn3/vVPzJt/pTTT2AGd5m 2sW2IRwvDH8atoY3ZoyCoIJjRj82Bz1pgf/Q+TdOdY7rEqSSxMjqAg3Ybadp/PFZY83znEg3bpPv EV/0EH/OOWFkf9/b4XaFKqRz8w/pVQMiG3guSFbITcoxvPNAndO5NcRT2uRCQ8JbLZ649qnindlV QGwR1A4H+f6UDJZRDGUcFW/vrj5gfes0wSw3Ec8lu4gnVjFIVwrY4OD7GglO8rH/0fj+GFZ2TyXn +07iFSNsKQcY9z3qc2l3CJGjneMSf64byVc+/Nf9BB/zip3bRTSIROSpO4fNx39aZDJC1w20fvZO Hk/i44oG3ZXLE3yExph1JxuHU0sYijw28oWG0nOKAbs7EsazNLKg2NFGgberZ3c4/wAKciM0+9vu Y2rjhfrQM//S+S5/JiyDgyEZzUFvLH5bybwZN2BtACqBxj9K/wCgg/5w5P3kVY5JnuC9wxMW/KCM YKj06/SrUlxPHIShQIVMbJLGJN2ehGehH9aBxlo7jhAfLDsVLEdRxiq0FsQzSRu7RsfmYtlR9P8A 61Ac3ukkxTcCFB4wW7mls5LpvNSS4byAuyOBUCoCD1J6mgyP/9P4/uGjjiKyMcK+AWOCSeAKSIrK FTG04wAByx9q/wCgg/5vwijQecobEsUmx1YncM8/4U4ySA7EG8kc+mO5oAhMTumzJG3gDPNMjWWB fni3sGwBt4x680BYbIzRMTGCWPJAH1qO3mmkcs8eF6gOvJ/OgD//1Pj3cUG/opOCmOlaTalD5dvb w2iwiOMb3HIdvU1/0EH/ADfla7kZEEscec4AC9vemiYGIiQfPjr1xSaugH26hULIUV2+UF2C9ar2 9rPvMsk0YeNs7c8MM84/AVMY2bAuh4neRUdlZhhSfmwcVRmT7MwjndHldQWZT6jj6VYH/9X4+2yB wyZwg3eoNCJ9oYsQgkLhxIRhl9cD3zX/AEEH/OAtGWjCyHKYKgHe69Qapy7ldZJJOQc5JxQOXxFm KETsQ0gIzuyvJpjLAsu2UmJW4XfwT1oJImkaTEDu8qwfKrY+RQSTj0pTb71KFsK3ykg4oA//1vj5 7VY0IiOZPuqrNy2MgUkkUq8Sj5h1DdeK/wCgg/5vyZ42kiiMcQbKZITC7evWse5Hyxxuxj3OEJX7 3JxxQaxvZGi1s8LRiMCSE4AErfvkP0q28M8JHmQbBjI4wTQUncrRRys0jAE9cjrimRQLJv8Am2GM 5P8AtUDP/9f5CSZVVw7Fto2qvQLVcXcokUu7glTCnB4U5yPpyfzr/oIP+cctQwo7rFErM3JPoB1P 8qrSYV3UsQAcAduKAH25Qh4xyNpPPGKR4V8lgGGR1Xu30oALddyrEpyR0PSobm3EEsMbI0Uk0j+c XyNxGzaQPfLflQB//9D5AltxGQu3Lrzjv/nmlMnkoB5K4ZslwuH+ma/6CD/nHK8m5SGTb83QOMip /s26QSRsGcgHaqng+n/6qBp2JJmkU7miPmR8NkYK49apXDiRoZsnEbjdGF3K3IAz+lK6vYqD1sS3 MsghkCBFLHcXA9OBX5b/ALZ6y2l8iizSUXcEk8Ul43l2yrvTMnIzzyAB3zXw/iK/+MMzBf3H+h+0 +Ay/42VgH/ef5M//0f4xruWK0McipE8i42iMZgOO304rOW6+0SSyyIke5shV/wBWmewr9LxP8Sfq fKUn7kWOWbYJcBTsXOWOAf8AOKoQ3T3DhgoCI+dpOAcGuQ6Yu7aLDpiQuPLiWRvlx0H0rThC/Z2d pt0ofBQgjjHBBrCWjZpFe8VILUSmaZEBMAMjtnjGccCprYASJOrmIjoemenauY2tY//S/jBZy0zY bLSPknAGTWg8vlWxUEqJGAkA6EjpmvruZJ2PHMUrK6eao2ruODjjj1NV1ED78zbLkc7cfK4/xrNS d7gXrebaHR4wPLQYl/vZ4P8AKmmcREFN3B3Ejoa1bS3ASNxLJ58sYkiXkKTgEmmXPmEgY2hxgEc7 Kyk7sD//0/4wwsapEF+eRQFCKuSx7mq14glEbXKOdjDaqkr09a+pvpY8l6WaHB2TyzCId0TZAnH7 sj0NRRyAXTMIliYNvKg7kb1pGy1RYkliuH2lgq5xxwq1d+0C1GDvkkRdy4HGPWs5voBYW7SdBKUy 7DkY5IqCSCAxM8aEsxzyfu+1TzPYaV3Y/9T+Mcyx26/vFUttwh6mq+Yd6j96/nfMMrlFI/lX0BwN WdiwpiUmR9gAGxUAwT9KrXMYiSKYuGWY/JjB/PHT8aBGfuYu/myZjJxAo4C+v+fapIP3TtvwBxsb /GgAmSZwM7BvOS4/pVmGB4gPmyNvrz9KqHxEydkf/9X+Mg2LXOFRthCdzjJHrWFd2ksYw7YJbnHz Yx7V9HN6njliylk80xCH9yqZDk4LEVo3xjktIvJfa4Y+YucH8agDEhslctMXd2x5aQgkhjnOcVZe Jwo3oIh6AY6UAPtAGXIKquSOOW+tKTbRFgNvmluW6gipl8LA/9b+Mu3ksZZI45SFwASi/eI9RV7W 59HSKA2cE0eAIpEwZgp6B93YnvXvx2R45k2UIMior4YfOOcO2KsXM0bkqlvvaM/67q1MCSOC2uLf zDmMlcFXG1l7VQtLAyq9pMwkVslVbjd9KAGxWS2U7LLtEeAkKr94+uRVwsUicYHlQuCxHIwelBg2 29T/1/4zpowihmwUIDDy+RyPWsN3CzLlcpK20lR8w96+gPCp72NVLUMwlQFV6ZHTitJAmN/BCcMq Hcfyo2NRktmDMjqVZCuck/NntxVD7K00yxsNqliDjjp1rC9lYCw9r9nicWsas4kXedxyq5wf0qle ogf5XJLYKqRjbgDOf1pJX0A//9D+MG21Oa3mWOHHmA4chsAL71e1DUZ7jyrUh5WllDmVAdgxznIr 6A8co3tq4CtueViMsOcnHrUDK8o8hkVPLTO1OD/nmsZfEwNSwkjtFZoonMzAKD/Dj3NXzcwXHmJP y0fKr3+opLcDEvWJYJERh/lJPOBVuG0Se3SJJFM27Yhk+RS3QD2qpN3sB//R/jXuNGvIT5TQjzFG WIGQPfNZkNk0ed6jLPgqec49q9g82K92xtCPaAwiVmA2tn+lUltvmlEjpGjH5H64oJnHqhqWkjb1 VgWxjI4OKqs32Mssx3qDjpkc0EJXdi5ND5qqylQcche1Z8kjROV2r5h+RXbqSR2oEf/S/i6ntWIW Rl8xh94H/CrZeOOCLyiVdm2PhcBRXsHjlC8EWQsIyVOXkJ4qe3KomYTub+MkbRjvgUAW1sIGCSn5 ZWOD02j3+tSNC0G5EkZz/ERyBntQBRSQs+w52jk54qCTcSi5wrNwT1IpNXVgP//T/jEhItWj3RmW MclQenFJDLHNL9xUOcEAdRzwa9WCs2jxztrbwVqt3La3KSwXdtbR/bGhS43QxjGeSDg4BII6c1i3 emzQ3MkjMki7yyFOiD0xV+QW6nOXUjRyRPEdoeQoYwcEEdz+f6VLGLqEm4MyyBvldc/Mo9AKAI49 S+z3UTQqFRGyWYcZ96W9u3uwz+aCBkuDwB9K0g/sgf/U/iot9pYvGxfbyH6AVpPBJfSO8c6D92Ge JzgyMOOK96UrKx4MlZlczmJDbBAo3Yc5wfQjFMgigZ2aZvLRehHGD2rHbYunsPihDyiZ3XC8IB3r WinhjAWYAzSnCSAZwB60Fk/my7NvmRuM5HGD9DVCVRLkzOMk/LEgwF96zn0A/9X+K+Qr9sSBMLAq bnG4liTWiqoSDFGBGke142J+btn685/CvQPMhsY8128Cm0tpcRK++VcA7fqauWxuXRPJYt824kNy R3/z70FkdxIyqzOo/wBZtZW5yK0bdWunSSF1ZAmXjQY8oDjmgC1dXAa3RQjh8lFOPm44/Wsq2jKS pIhkjlclXST5cr9PzoA//9b+MWVQsiJ5ZMjN8pA4NJewCRQFAMgjwF7Fq9A88z7GwMaGSVkaQAkq TgIenAoitLgpKqXIiBnDgRjGef8AP50Ab0Q8p1ZihkK4AIHOB6fhWVetDbt5jRgsX+by1yR+FAEk UrbDHFgRycs2PnH49arSNDJEIkYmZiUJ+6qDsR79aAP/1/4vBLcQOXMhwigbvUDsfrit6GF5Et7m Q/uJodzwFR8h54z+v413y+FnFBalC5cKfJUhPm4z90D3rGku1P7pjmI8SEDdWB1U9i1Zh/LBRMRk HYy9SRx0qe9RvKDmYiSOL5o1HT8RQTN62INNeON42nR2GMoW4x259a2J5IrdJZIkUgoW2ghefSgg /9D+Kqd4jH57kJKyZeLO4/nVa3O+RFjAUsMbnOB9Se1dBCmral6w3+ZNbkQySckyZC4xzwScVFJB NJNuD7gEI8rjHHJ4qJPlIlK7JLSOSK1aSARp5uVIkXDD3Aq5aWXnzBrl5JMp5SvnO38PwpqSegou zuWpreC3gkhlk3Kpw0pXlBnj8qzbfKTKi7ZCvRsYGB/Kpm+htHVH/9H+K7VJnMyGBidw+eL+7j2q va26f6+WciRmGUAyVH1oCxteeJJWMgLJjYr9x2z+lLOqIPmlKuozG8XLCpkroLGXehWhAjb94G8w s3SQ9gauQPbeRIu9Rd+QG8rO4D1+mOefasQMq5t4y6SfMrFc/Kflc9ORVqzESyIt280LIDsjEeY2 BHBz/n8aiUL7DTa2P//S/irvI4SxyQpC/uyB8xNZoEhjZ4Az+WdsjJ0jPua4ZRsaRn3NawvGiTy3 BkkAyqvwTU17BvHnNhT1Kj5jj1/CmoNPUtNPYyZnhmjeBsNHE4AYL+lTW8hjxbFRF/zzJP3vr6Vq M0bSziYPI7iOVWyVGSHq/I1nNB8koDo+3KnPI4xik7gf/9P+L2XFvauYvs8koXPkSyeVvHQkd/pW BPJ5keY3AdjtRD0965zot0KSfuFjSYZWPLBBlgpPXFMhWG+YrJG0RDHBDcAdqDCzvyl+G1azJhRV cH7rN/P9KpTKylzkRtn5v8/hUyXus1jFRFSS3ETAuqSt83mDAJA9T6VNa3MZl+zsisR/q2zlZO9Y lH//1P4phcxSt5D4SPqy561SvVtnkjKM0Krwu09+x/D0rzzoGri3T5XE5U7yGOW+tRpqs0bme1k8 uYLhm2ZCjuKDVK0C3K0siQXMuR5wzEpHLepp0S/M8pyqR8bnOAxPO0U0ruxkWIAkgl3BGEjBWXsu OlOltZblGW0mUyo4BSQFNq+oNDVnYD//1f4n7JIHmubNJQ6qpMzA5Rj7HpnrTBDCs5iYD5PmVe7C vPsb63IJo4ZGCxuYHkcoMDGPz4ouGjgdYyy5VRvbje9A9ihNfK75dZNvCxIuCB9a1dOvldow656o V6bOo/SgtOTiPuY4hcoXfcN/IPHHYUxYY4X8xFSKLkFcYUCt1sQf/9b+KHyrYyRXFoxlhZdjIoBC t0J/Co4yI7rYrRghtpCgFQe5yK5zqUWzTLxXMloiGNnjlIEgO0+hBPtUcqXFrdmQTRv1jPluAyAg jp71dPcipFpakcP2u22zRAQJKMPEj7lkAyBnFWGP22Jhtj3jLE4w2R70czbsZuDSuFpCJIoXuJY4 IH4lmf5RFg45Pf1r6O+A9lod54sgjtroO8O3ZOrltwEi5JA+h496+k4Vi557ho/9PI/mj4/jaXs+ HcVJ/wAkvyZ//9f8/wD4UW8sd1oLQ6fPd2F2ttBZKU/dLGtzGkkuOpZQGYkcAg561/db+wxpkek/ C7R5beV5kOmR287OmzZM4H3R3wgHPqa/rT6SNfk4ay3CdHb8mfzl9FrCQnUzTHPdSt+R8f8A/BWv xJaWXwr1WxvL829vf2TaS7vHlIpJiI1kH+1gkAV/Gh8VbpDp99bJewTfZ44YBJOfJaSRSpIPYcIS fTFfqX0caPs+BnK27f4H5b9Iao6nH8IX2sfhz8d55m1/W21URSzPclY5jJ5zlmAMmCPfPNfLCzxf akyimGE4KIeT9T61/JPjLUcuO8cn0lY/qbgGChwphEtuVGpZSSXkq20Ssk0j4jKAszeigV11p5xP kTsr8YJzhkIr8hn8R9tDY//Q/iutHSBlCyGZy2NqsCg/H1roIrckvNL5T2xIzgjzE9QRXkVmRBaE sbhoXt1ijjha43qV/wBYygev9K6SzlhmillghzeW8gVG8ss0vT5R9MVzFm5PcHR7ZJ5ovNe+cJKz rtCA/Mc/T0qqt1DcXNnBaCSGa5YvFEyGNCQR0J49PzrGTuwOwt/Hmu3X2nwtfBNRs3QzTvc/vI7N VRlDxP0DDBGAfWuRbU7febeBxshckDGXwegH5VkoQhey3/Mbbe5//9H+RFtRivUMbv5ckXAEh+Zc 9yPerR0+OaCVp41w8G21MkYL49M9cHGcV8q4LoBl2vnoUDysr28pG0cKOvauyj1OGHT7kFtsk+US JTyhwfmI9PpXNNaDu9jmLrT76S4sC95eXNjcS+XJaPN8lpkZZgD2JH8q7OKPS9Ft4I7Ry8tuDKYg xZt2cn5vzrCa90SdpI9AtL66nl0y5vbYhNQVVWNxumhwOHI64OOM1/QH/wAEUPBtjc/F3xPrtxZ+ dfLFbQ2l4GKzW6bk86If3ScY98CvgOP63scgqvu4r/yaIq8HKyXdH//S/jDt4GV1BXdMwCZ4NX9O g1gNebo44hBmUSLMPnA/UH2615DVnY8yNS7ZqSJaLo13q2p3qwGBMGOIB5Xf/cznA9QPSuchSyuL e1nt5bq4ExaUyxxkoi+/ofY0h86LEEECxSlVMjgHyt45z2zSw6o18i6SbVXnVVWCeN9sSyE5Of73 pzjFA07q6J4dP1K1ElvqMcUaGbcpiYSuGAxhmxx+HrWdcWMsV00V7az+WSpVFQ/vVfG1h7cg5pXR tDY//9P+M6O5g0qe6M0bGW2/0czRHNxEM8qe2BzmtDVTbXyxW9uLeYxp5gnCATIrgHDMOSemQc4r xznKdlbTfZUuEdQjz/ZyJG+bCdSF69/1Fai65c2MdxFGUBaIwKSmNoIxuoAoWcTRw+VaXk11JOmZ pZTvALHLADsM5FPu7yLT7m0sUtyb2Vdiz+VmNNwzgn3wP0rrpbEy+FiSQXEkksEo8ucfu7hF4RD3 4/OuqisvL+w2iTiVZQFhiSRWRs8Yx0Bz24rup9Dmnsf/1P4wfF9xYyj7FEkbw2ly0hEcgdmfhW+Y em3p25rxdp5LeWaNwZIpiSuepB7f0r0aK0PDkvesfbX7Kst//bUF/BG0PmXMKXMKHyY5beGSEMo/ 2mXcee+PSv6CPhV4h028+JvhG5tBqmmrd6jBDb27p9rRM7FzJGB8ow3vj1IFf3F4KNVeAa1J72kv zP5h8SY+x47wVb+/H80f3ffsd31nf/CLwxDEy7obBROGByj7B0PfJ59q+GP+CtNpat8K9QN/E8yR W8lteSeVlN0gVYHz0yvmcd6/lDJoez8V403p++f/AKUz+ofFmdvDvEVF0or8kfyATzvrR064uJbm a9sZ0kE28wCXGdwcep6H3zVrVrFvIutShu0t2YJElnbRyOiNnJyTnn3Nf6i4b+Cj/KSqk4SP/9X4 O1doof7Lv43gntokEt3Z7yTvXafn7gdenrWd/pbEl7WGwabE1ujxHBjYZVwDg7TnqDzjrX+y8dkf 45xVptElrd2UsSyw6dJc6nBdNCk7YNsWAx8oxnPUdT1p9/cWy2kd1cQ28rzK0UYt5Sbi0l6AkDtn 1HTNdEdkVPaxiXjQai+iG9S4ea0mG6fzPLeWNSuEOOOfmPPqK3WspJDI4C24kJaKOHoo7da6TmlK 2iF1hktZvD1zcaRZlyjqdTS8YXtqwAWUGLONuGXHrVnUdSEb2/8AwjjyuBEVuJJ4dkqyDq6EevXm rjC+5yTfvH//1vz4uLu7mdBcbTLtLSuuA7H3xxn3rT0y9kuLV0jjIssY+0KwQh1I+Xb9O9f7XKKR /i9J2Rh3EF7DBqFxFCtwm4RB57gB4tx4KqCGxwexHNN0aSGzs7SIQm4nsEJut0jM90ck5b8MD/Gq MBlpLe3UE13FaPeSy2jXFvDMpTyGBGC2OntngVqP5NpDbCVUjuDah7mO2k8yJGbJxk9wCM4q4X1S Gld2LdlcCeCdA6NGU8tVJ+bJzyBUl9pcVmmnLpn2uGO0hD3UcExO9ycsW9VJI61qI//X+DHu5YHj WJdxf7w25XPvV2w+2Rpc6jcWpktXudoSGLKQFQTkHsOf/wBdf7dw3P8AFKduhiapqt1deXaNK9vI 0vmW1xE2CoB5Rsdc+9XZk1f/AEZ0uSNNiVzdIF3SzOdoQKe2MNnn0rUyl8LJr6T7FbWlzcpeRpck rAr2kknmbevIBH51e0u7OmXTy3kNvdI+H8tk5K44H9KDjl8TMG6Zpr6e7SF7e1Zi0MGS6x8njPU/ jVyECUoVuIpPMhMoAYAjA6Y/SghuyP/Q+BWivrUrIXhS1LtMQ0e6bOOm7046V0qxNd6T9ta68yN1 yW2bPM9sV/uAf4byl1ZzdldXsxjtbqeKCy+0BXj2E4XdyxPUHGeldtqGmTR3h1IXWlvpSwJsnWfc zYAUlQAfu4yc+hq4K7uZOd9jnbwvLL/ooF3EeYplUxgg9znoBnvT761W2GnqVNwbyNrmORUAWHYd pUN3HGfzrUylpEt6VeRu37yQ/ZwP3bqdyK3uKkGu3H2i5tIklDP8sIdcJcY6Fex/nVQdnqYtpbn/ 0fjKwM0tjJeSM9u0wZroyknaY+R8vbp265rJnv5Atjc71kiucqGiA/dbe7Dt2/Ov9z0z/Cdq6sal w9zsIs7sTyxNuQhi8Jx09scfrTF1OQQshhBun4LK2MH6YpnPsWpWubayFxexJNP5O7fFJl0Xtn34 6fSufs9XgkVpZoniBcNFKvyvHz/ECDkHjjig5zSgSSczTf6yF3OZduFOT6U+QJYOtvZ745JlImCc JJnuRj8PwoA//9L4ltLmbTpGnEaiTy2SF3G5MnjofSk0+7u9PWR3dLoNJ5zRXPMOSf4Rz07V/upT fQ/wQqrc0Ws7RdJm1e1a4tctungu4vKK84cq2eV5yPbvV2FLKfTrW5iJkR2CeZGMBzgZB9SMitDm OYlh+zXUskZ32gYFF2fNDxgjOeQcHFXJnvtVuIoYLLzTeuFRUXah5A5PTigDWWC0tY2F9Eks8JKG AS4i44wSD/KltNOS+mYteW+nRLCZUifJiYY4GcEjpgU0ruyMp72P/9P4qgeS4DWskiRhz5Ymf5PK ycZJFXryU6XLb6ZBOk6FSZb22UhSfrx71/uxY/5/k7q6JDpEU0gkil81kQyDzTtDH1FVNkMapEzF pluwsqOuYyow3X/PX2raCsinqbkGiW5E9xHKLaGTzJVbZwGwSF/EgDmuftZb62Nvcy2Mn2YBllm8 weVI46DI6c81RN0JqDC+IuJWjEi7WKINitjGOn0p8Mkj3JMasiXCBfJxvVz0J96uC11MnJvQ/9T4 ka2u4lkEaDzY7nyn3Hyli6fMc9ue2elXpLu4hUw37md92fNQ7o+euCOPxr/edJLRH/PrJ2RBetZT SRwwREIqgtIW3M5PpUA8tZjGsZ8sDALcGmYjlhDSgO8cVswIeWVSyLxnsCfyHep0EsMNmzvCPNYy QPETvIBwCc8jjtQZyl0RL9g3zSTyTOIyCYiwJVmGMgf/AF6je1dolET7ZQx/eHqQeooMz//V+NFt JYjBDIm4z8RNjAbnHB+tTXlk1rbyFVaaS3OGWHoeQD7cZ6+9f70rRn/POR/b3ntRYhUYxHfGdv3S c/4n86feWq31pHbSxHPl/vSJDglSGGB1HT1rWHwoym9bCw2V1ZxxCaBohOvmQM67TKvIBHqOKmuP 3CRmQkMDkADj/P8AhVEFOZEdDN5h2gYwFyaj0v7JO84LTrKoBQkYVe2SKLdBN2Vz/9b48ZpVdrES +apIlcRghSR0YiqEsd+LxisMcqynJLPh8Y5/Gv8Afg/51xYVu1iYyoFf7wjJyvPvWjHct9hNilrb KGl87zlhH2gHuN/XHtQBLHBGYT9qEgj4/eq2MEdj9aowjynKs7Kvf0I+lAEvmxiUED5R8pfHIp2o QRGUR20i3BHzlgpTbxkHB/H8q1gtLmU3d2P/1/jlTvj2D/WKcZqaSB3jiaXrCCFXGa/6AD/nP8hL VZUYh5dySNhUIwV/Gona1M5dHLtA2w4JwPwoA1LeW3kWR5MqVX5d3C5qGVoeEcEMed3YjtxQBXhV ElLSZjgBw0235fcfWpzb2wmSe3kWTK5QkY3g+1JySA//0PkwN5WZM/eGAM5xVZ7AXI8yVmRY/wB4 0g6YzjFf7+c+h/zn26FdndIGiV2ETNwvTP4VZtGtlXC/MQMMJBtUmszGUbE0MQyRuO1hkKhwagnl 8kwqEj/c5CjaAp56n1oJt0APM2WEihSctGvTjNJIfLw+0t7Y60Af/9H5BeeExkzLs7hh39sUttDu kBAbcTwD0IPTAr/fg/5xy88X2O4E0seTGNpU9xnkH8qoytJcZMa+Wp56ccda2jFW2AprGD5jMxjb biP/AGiK0LdI57RYrnEU8ZLM4HyyYHygADjPPJqgEaZIIyCcqPu+lVxf2s5VzGySIm3k7g3v/wDW oA//0vj5cmRJUbYc5B6E+lW4bQpG13PKGmZyEz95R9P89K/6AUm9Ef8AOOVlltN/lXMYYHOJQo3g 9vw/xpxfKhYhhV49BVxi1e4Dt6LgOMsBkkCoY7e0Se4lDyyrKMrj5RGcYxjniqjHl3Adv+zJmJfN Y9QRzT7qSN44PLhIlGfMfd159O1UB//T+RLe73skSDy9vyu5BPNQo1zLdzK0LRw2xGH2gxS9857+ lf8AQQf845aUwOZHV1Djqg4/HFUpzHiN1UvIOHx0H0oIk7FmBprpfJ/iA6E7dwxUkZNvu2BTt7E0 Fj5I7WaOC4jEiXB3C5QfNE5B+U/lx+FMcSSKUyAqjAHp9KBJWP/U+RLZHg/eAgMPbJqS3vrbdPHc LKSV/dAH5SxPf9a/6CD/AJxrJO4ojtizPtdpiv7tEGQeehpjyRgMyWymYjaAvyrwMUA1pYoBZFct IpXafmXOBVzyba4ZBI5RNpJIHU46fjQZS+IcrfYJXh3Bt2BuP904I/So0hna5lSEmaJ2zAqLygwO PfoTQK7P/9X45kWd7grJG8flqM7utTrFGNr/AMAPzAd6/wCgg/5vyxJBCsTNCT85yQTnbVTKmEFi pbzlhVTw5Jzg/TI/WgCS6juYI3gVlBJBEo547r171ds53W32NHvRfmPGB/nigDIdZGuGJXET5Kgc ACr1qjF8A5AOcDrQB//W+R9QK5C+Sj5YMPl3YxSQI6ypKVABG5QBx/niv+gg/wCb8lulBZWRP3pH zBf4vc1mKHaX5iUKnJGcUAXIXWSRkciHZ8ySP904q87tcQxlCm0EsHAHzZ9/woKbukZhliilYEBm zycZ21K7KsqSFBJGUyu08KccZxQSf//X+RfPjltJYZIEjZ5NwmHMigZ6duaglZW2RxjdtX6V/wBB B/zhXjqS2585wkqSI6DAzyj/AEq7LapzkHpg44xQ9EQZD28hO4N8sbZAP41YBidTvV12qcMOSTzU xktgGwoqjMasHyNrseMCpmtI7maMtJyrZcg9qoD/0PkIs6SPGv3VOMY6iopNwy6EDjkdK/6CD/m/ FhR40PzHax3ZJzkmiWEyoN8QdBnJ9BQAWlyiMGXBQNtyDnGDipdRWG+vIH8rbHAhjjOcE56se2T/ AEoAsokUcP2eIfIAASeT0qFoEEQ8tpGnR8suf3ZHbA9aAP/R+SPsqyYkebY2AQmSMmq0quZ0TDsr HDP1Ax61/wBBB/zfnTwrHHaoFSNfLyHbPzyZ9if5VhNaQtJJIex3fNRdM1i0kkViCxPGcH5T6Us1 zcHy1kO4AbF9gKCluQNcRFoYFkkhk3FWfOQ2eg/nTZi1oxQkOzfMOfSgZ//S+NlcZDuuCfXgGtqO KF4UkcKpCnn1r/oIP+ccq2qyKzywSkZyAfUelRQxLfXkVq8giZpCMnhWIoAlmjWBpY4VVnUEDHQk DqKyrZpZIo/Nx5pAEhA2qT3oAvwhYpM8cdwKbfQNdMJ5GLsHBiZudhHpQB//0/kK1dnlnkuDIXLf M8hzv4HIouJBtPHmAH5Qvav+gg/5xeaJU37nETK20cgjtVwSqjbUGXb17UFJp7FjchRjdiQyO20q rbXHuTiqssZXCQoAO7EZzUpPmbHF2Y6ezjmtXjeXynVC+4HbvxzjNflj+3klmZ7XfDd6mtoYrS3z PgIsoiYsccbQ5OQc/rXwniMr8G5gv7jP23wC97xIwXq/yP/U/izvnWN2Tyh5a9EHANZmJHeR4IZA hxxyRX6ZiF+8n6s+Uo/w4jbnpGWVwSPuHjp7UlrE6yBTnEhyR/dFcZ12sbd0LRooPKV1uFbbIrNv R/QgdvpRFuCEygL2AFc1TqaU0SEvbxDy1Hlyjls4x+FRRBp2Mm4NHHxt6EfSsDQ//9X+Kue6gW6W 3AkIVt4dlwW5r0e08M2s9ot7c+JtBtg0CzC1mmlaWLvghUIJ9hX1VS6ex4/yMXU72VIFsopraW0M vPkxBVcjgNnGfX865VrZJZx5Cl5C2HQdTjuKk0mupeMLOrQKMM5G5zxtA7CoDCQWXcojUYwDx+dB mQxzhnNugXbH0I6n1rbspbeWV4nQblj2nd6cigD/1v40YgLeWRkIAXiOT+KqMzGRGEnzS7+GU4GK +oPL5bxMiVYwfLkO/eeh6cVoG0LxKU+U44x1qHO2iLirIkg003BVHR40U/Njjfj3rTeJYnKtHygA 5+6RWbbe4zEa/Euo/Y7eI5RMkr0z7VYhuJVlMMoITJb0/wA9qQ07O5//1/4uGiLuxcjZnI3Hmpct EA7454X3r37rY88sBVaJFMAMpJIcAkism9MsaBWZvKVvmRfug89afkBHAITB5p3g5IxIMAe+KUXC t8rjIxtDdMUeQFlDC3lxyOVi3DoRurTt5Vafy8RBVOFIOGcepHrQtNiJ7H//0P42Z5YIITGhHmZ3 ZHJH+cdKxTeRu7MYiP4d5HL+tfQHjl+yjtkYXHEkY5MbZX8Kx9WZr2QxQItqgOCEGCw+tADYftVs kRR1JThtyj58j+daKRS3sL/dDIN3JAzigDF3eXJuRASGwydjirFvAt2fN8oqM/d/umsOgH//0f4y RbwQ4l2rJcBdv+7+NNk4t2WLDbnDy85I9B/n0r6A8exRYCAZkdhubKsvDAe1WFuUHyxKQjAA7jlz 70AVjNK7yKiNwMA9KbDdzROqMjZU8PIMOv8A9agCxNdyys5WBHcgKLkZLqPQ00x3CQJJKkhjlYcl SEYe5oE0nof/0v4xmusx+Ui5b7oicYB/GqdlaPJMwC/vFON3VF9q99q7R4ySWx3UOmeVAIpz5bHH U4BNV7rSxaSzLbGAmIA3CtcKhXPoO59hTt0GYDSXEczvksm3C4GQuKYt2yMseGOfmLsMHJrFxa1A leRICWi3M8nMiAbs+9UXmXzh5ybmc4jjUZJ+tEV7yA//0/4uJYoS4nRGh2ZUqP4ietXrOdAUbd5a RLtERAAY9v8APvXvt2R45qx3lv5LmeII7NtVyfu9elZ0dqY1VGk8xlkOJX4Z0JJA96wAaRcwTSKJ VMEgGxCvzA+uaZKyI4QgGVlwxHLCgpxsrixiGZXPmeW4baoZeH/GtCGySRPLdgAPnDZxgjvQXCNl c//U/jzOrXMUIBuGcxwiBSz/AH16YPtXOXMksl78mFRRufacoT3x+leweeN/tNUkXfwrHYv196mj mYMztEkgySoJytAFmF2aEyPhWJ3kLj5BxxWBLcJ5rR8spctvk4PXpQSopO50MdossBCSgS7Mrt5K nHce1YN6iQGIlmLRnJfHJPtQZyi0f//V/jEldmIdBtZkDiM9wRnP41ly3IXcFRgd3zKeFBr2Dxye 3imkikESlieSB39BVoW0sZMDny2wOOufpQBo/cgAZd7KQQcfdqldXCIJREpG9Blg2WDDG7j88UCk 7IyZJlHlsd4O3kY2s31FWY8vGJX8t2DbUgDYk+pHpSewz//W/jCiSaOJkiCsJCWcsdzp7LVdYPIf exDs/UDrXoptM8c67T/GGraJZ3FvawW8/wBqiaDMzsrwowIYKBkH8elZEF3KxbylZ1RfmjY5A+pr VOO4SlKyj0/4Yy7sBt7sAC/ygdCp9aRPNiVDIiuFADZHDCk5pAQXayXLBQipsH7sIuAR70tvbM+6 GSPahTIbPzZ9MVYH/9f+Lv7NtXykUddgRBhm/AVYsooomTfvjBPlt8vzgg46V7LPDmtTOu7cPfoF LMHOck4BIp0IlfzreWBVRWGxwQaQ6ew6C3EdygyzLkgKBuUHsTTp7URwp/pBlvDKxlwmxEHG3HP1 oLFt7uKKERy4E6Z2qep5qQM6xTyzQ7mC7oFQ5LDGefrUTWlxJp7H/9D+K8BJzJNCojk2ZbcwJ4qe 3upYreQxxCWVFOQw4+tegeVCSWjM62hmljlmaNWLndImdhk56YrUjtH01ZGi+feuFVz93PpQW5JD meMRRGaEyRtKFlcDPl9ulbsUWhyWxW0vrm1uljLSfuMROR0QH36ZoHF3Rz0TzWyyS3Afyo5Cxdss q56c+9StMksyysN5A3L2xmgiUtLI/9H+MGWdn2gK2F5UjgjBrPmlmnuU3MY1R/k8s7T6cn8a9A8l t2SRaMjpDJE68l+GP3xipLV4ol3EcLyxagV2nchlui8qS27xtvyFDHJXHU1f04xyyhZQN7AqGPzd jmg3W2pZ1OyFgoa2eN12A/e5GfWsYLGsSD7Ps3Hd5uMOSfT2oA//0v4vIImkRnLiVWfa8DDAIFdR FdTyp5MMSBIyBsddrY6dfpXoPbU4Y6SRhXlorPOHkYS7vkC8xqPrWelo8QHKGCVSHDJlg2cZH+f/ AK+D30OiMuXQjj86xC2sbF4wufMf5pD9fetBIiYmeRxhh8wJyc0iRXS4njjLFTBEmyPsy89PpWFq SSR2p3byxOV2tjJ9DQB//9P+J23iE1t9okbGRt2Y53DqKWCCd1cxArn5M544roOcsrbFZTGpLHZk TYwuR2NapSKGNXkjcyMu2N4zhdwxnJ9KzmA2Is8L7wqSEbYx1Qn3qtYajewy/Z2SCRxJjYgOQv1z VRjygSXZN0SCzJvfLbOnXuKtRSHTnhfyIp43OXSUZzjHUDnvUTeptD4T/9T+LKdmnUXqQJCZZmiI XgKAen8qay+VbyRnaRcYViVywwc8HtQA4t9lRV3RyKcMQTg/QVL5c0kYlI+f7xUfdjHYn9KAGwqJ B5LRoEVixmB+Z2J9PQVJ5Sp5sK7N/wDFgjJArOUUkJuyuYS3sKtJGzFX8zyody8MT6V1r2LXFmHD qZoohhmPpWdgTuj/1f4pL22aMjaN7FcupPJ+lVl1AW0b2Ct5SzkSMsf3GK5xn9a5wFhlZpFZQxYn ClR93H8ulTPdyQRzsXUNnBVjgP7GgCtYzxSu0eAhmkGTjIjPTitF7RnIWPzGkWTa8pGF+tBop7Jh bXM0c6WkuNu4h52B+6O49f8A69U55xHKzQBnTzOWRcY54P40Gh//1v4qRD9plJuvKSR48ou7DttH QVM9kiQlpIt21f3cbHbmuc3eiKVpANReXhIkjQiQTDaQewX3NV2s0sZ4pCGMbDY0me+e/wClBlF2 d2XUkk3qxAOZdsI9fY+lM120G6S2CQtNJGk29GLLFkbscd+oqJOysaRlzHNWttJMzRyxOSv7tGYE KSOMZrUg0rZEfMbY8b5UZ+bFZFH/1/4lpbSS5XbFIihBgOvLk9waZbwSR/uLtElRYz5BV8OG6AtX nnQtSS3jB/c7Qc8vMRxx2FXLTT7ZnbcCjDjjgn3oL5vdsWpdMLifdJuNku8fNlV9Pzrn11C4uJRZ lk8iFmlGFw7HABA9T8o/KmtyDUWaHyROP9H6D5xtz7EeprY0HxHBpd6zjRYtckuITBBBdbkj35HP HPrx7027u4H/0P42td1zwprjW11pmkWuhXdrAYJrOwVjBK4HzE5PXJIx7DrXm8QcXBkmbzArNibG CoOeD7VyW9w6ZNN3SsI8UzyKVJkCvuVmHbPHSpxBb3VtJJcRnz0k2sq/eUDuTmoS91scFeRnyRxh 3ESOVSQLE7rhX+takEMtus0ckKESYbzIuq+4P+NJK7sa2IoiIWL3Eazq7YTzWw0Qzw2KmnvYphHb wSxK7SAM8inYozzWyVlYOVJ3P//R/ifE42eZBGoCjyn2rsJxxnH5VFbRw+dK/U8D5uOTXOegXLnT 3hgeeOQIwIJRfvfhWEZ28zYJj5iDcz/xnPatKa1InsbehWr3N1fxRoypDaq6RtMHTzOAx56A4J/H 2q7AlssyLeyvbDzCsqxAMy4yP881dle5kX9Rm0W20p5NQ0+4n063lUJfCNpUjZjjDRLnIHX1r6e/ Zd0bR7jXvNQQWbvA99a30NuwmZdisqOhx17dMegr7PgGgsRxVhKb251+B+feJtZ0OEsVNb8rP//S +Nf2d9G11dc8HwWFw8ttPrVnb2iXGJZds1wBKIl7IfmJHTqa/u5/Zc0+Oy+Hdk0TAO8MC28KD5Ts hCs2enPp2r+qvpLtLA5ZBdF/X6n8/fRag44HM29nK/46/oflZ/wWL1KS+8HQ2TrBPbKsKxRXEgtI jP5nDb/4ipwR+Ir+Qb4sR2dho/2l7BVvbOxeHV1LmeG6uZJJAJwucEYaEA8cqfU1+2fR+p8nACfT U/F/Hp+08RoR9P0PwH+MVzf3Hi3WYpbpWtrbVXZ1C7AylF2qn9TXkMKw5CxRgSOxyW5K1/FnivP2 nG2Pl/f/AMj+vODYKlwxhIf3EehaDp9zbT2uoxxIsVpMGaRjguSDwB36c+xrfnlspjNEIYbZ0clX gHDljzuNfl0viPq4fCf/0/4v/wCyrOzSMq4ad0V5JFPXIHB7ZHT8Khe6iSQB0xAPlIDHdn1rxKqs 7CWxs6a8D3caz28slmI9weKQRkkggdj04Ndzpl1DodyoeON4pF86KUsHKk9Pp7isG3ZjNq98RW07 Fb+1S5heLAMSb9gJBygHf/Gq13eWNxGHkVrdIyBaSGLMqr0GVHQ81iBxzXRt7I6fZySSytdvJNO8 W2SSNjkKT1x7VpxxC3MImt40kdFaS4CbGk44QL+uaVtbjtof/9T+Qq2jt7ua4dbXYqqEecxlGBHX r9Ota0FvNI8ckt/PKtvHtiV48iML0AxyfpXy4GTGZZNQ3XNvKLaRHmiuI1yJdrbSNvY57Vpqtvci JEt2BBLL5w2uOe4rlqKysBtpBs8lJ3V/NUiJR1BFW4k023dprsEzS7Yoxt3q3PAP51i1fRhZ3Op0 vULh5JY44mjkjCy2Mx5aVk6xgH5Rnjk1/Vd/wQy0BLyDU9flhlRtZmtoIBIoMqTOxyQf9lUP4ivy zxQlOOSRhHrUgvud/wBDshTU2r+b+5H/1f4yYVkhmbyiEdJSSknKt6Ffate3Mlws6QxlpTmW4ZX5 kwPT6L+lebJJ6s8SmmlqVbYWNtHHeZhuJjlri2u4yPs+SVTd2OfUdKswx6tZzeXFHFbWbJ5k0DDG QBlSvbHpWJZM0tqJERZIrSe6QhfOI/ecckKfb0rkbsSWjXEtqJYnjIdJYI9sZOeduRjtn8aTaibQ VkalvrF7dx29uTdRPdRm2keJd0hDDnIOecfzpsVudNlkR7691R2f90byTfLCoAAX2xisW77nRBe6 f//W/jBvjBcE26RSRSlv3zTZCSKfQ96v2cbWwcCNY1ZdiFfmOBwMf4V4kZX0Zko3jdBY2dvAtxJc y3LTKS1sNgdQT2Azxn1pyNPq3n+bbR2y2/yrEsmZJh0zt7dKsg0tIsmJFtbNGs5RpAjH5gFzk461 Ult3tHinv53kne5+Z/L5bnghewHHPtXVSRE9jTzp8Z1YXMT6qb6AW4VZCsUDE8yAj73BOee9WtJG myrBAphtbewxH8jEmMemOpPFehTWxzzV1c//1/4pfEVlFZ2MtxandCmoSyO8o8uf5ixAKnkgYIz/ AI15kWW5berDBbIx0Ue1enR+E8J/xLH15+yfrFxpXxH0ZGaa4s7fTr69mtjzbXLJ5ZjG0/KSpwfc A1/QD8Pbu1tr7wh4hsL67gsI7iLVPtEtr9nut4XeIpEPPUgEehr+0Po/VJ1OFcZReybt/wCAx/Vv 8T+a/GCHsOJ8uqrvG/8A4E/0R/c1/wAE+dZm8QfB/Q7wSRR217FHcNErBjGZIVdR6jA7V5f/AMFP dDm1P4NajZzW6SxvereG4fO/9yjGJVHQ8pyO+BX8w1H9U8VVNP4a36n9KeIMvr3hhWqRXxUNvkj+ M7VLmy+2tFaNHHcLIyySBVBm2MU3FRxzip/7TE1z9nKvLaiNRdPDGqNg8FQMdc47V/qFgvew8H1s j/KutaPNZn//0PhTW7W0RSbO3n8kTqJyg8x0J+7v9jjmsvV9ZnuJkvJ18z7PbJZRWsUYjAijAVYo x0UAD8znnJr/AGajG/of46/8vGayLaLbWw0hZrF57RG23EyyXFtIyjdhsAHk8HH+Ncwmn3WlX8dn qP7z7XkQAyLIwcHneB06dDW8Y62M5bm8LeyVZLnVkaYOdkUSP9nWMAYB3evpTvOtv9BitJzJNFAZ rqI58wHeVjAP05Oeprc5nuzO1kRSX8lzcbLuQQq8dvF+7VXA6nHGcdvXNLFrS2CkQWQuUdQXVm8s owzgZx7/AK10JW0OapC7P//R/O6yvLu9meW60yG3vLm5aKCK2lMqSgnC4GOpz92tSxuzY299YtYx 2ZknZELpvlR/42IPQ5B688Yr/bA/xZd1oxRBElzFbxv9pN1gzvgsI16EkEdR149KWx03ShLcjT7u 8kKuYri4mhMWHycjGOn0ppX0ROxfawnsrZJtk83mMtuhP7uPbuALEgdBnJIFXr7TdEinjP2+2luG c2F1HbO0wt5AcAliNpzngqSCa1jGwHPr5WkzyS3EbvCJWiRxExDkZC4H1IP41ZMd/qHz22U87hF3 eXwPXv2qjKU+iP/S+ItKtdc2iK4sbJbN3AN5JcjzlK5zgDOeD0P51bhv3hS6SFUf7HcFI4Q2ftK5 xu2n8c1/t1BXZ/ia5Kxyl7Clw7zyeVbbOsoT91ACeWb0x7ela8/m2qWltLci4snkP9n3UbFbW72Y JZHwN3Uda2IlO6sVZUuHLiR5BGjmQIZS0YzjpzjsOnoKS8uLV0S4lm3zKyo0NvHvkmz0wooOVu7u XmSM3NqWEkNsflkj2+YeRwCPris69Wz0u/vLbUbSQR/Z1MUsbETJuIYYA5wRjOezcUGfN71j/9P4 YNzDc24i2ZwcROw2qR6Vea9OnaYts6iVgGkgtmIWNS3UE9ua/wBwD/DWezMvyYrq3eUQTJMyB5tq iS3tx0IYj3IGen51CBd2bRASRz2JXD26nEjew9BitIJpmbjZDo4Lhr67tLaaRleDzVQlVMCMoOC3 TPtXSQiU6bBp0YhhaxTZDcOTLIQOq7egBJJIArQzl8LItJhEjXMd3GFhtwQxxtyxHBFNeG8mspGj k/0WzctAkymN2JPQcZH4+tBjY//U+ELb7RcxXdlc+ekF7b/vlVyiAkgAHv3PTH1qwljFaRQWsEZZ Ufymc8jbjHy/41/uWptWR/hM9tTdhtLGyWZrUyyCY7ZpXYll46AZwPwqg0sUbqNgRt3GeprRO6uc s3pYtXVvGLG4/wBIDO8wikgScCbnn5R6Y9PaqdjpVncvDZG+S3Q/LHNLCZGzjgOBznPGaZi2luSm 8vbSSx0+08u7WK4KTuqlI27cAjJwR39cds0Ob/Vb+4mSErscRyNjakIAFBHProf/1fii5t7eK6hj MpnijlUysu5EYcbuo6dag1i7tCgZUjWNiIo0GAGI+6B79Pyr/daCsj/A2pI07cawLOG/eSPUbCUC 2e1luQzWoUkLlT9OAOvFacmlWtrp++G/jUGD7SsYPyo5bHlnPfH+TVGJylwn7uMs484ktKiMXQ+n OPrUyveRxwIsssUJcmMR5DMeMgH8uKBSdkWpopjaSxwQiW5CGRYpn8gyEDOMnoadpV/qyafNb3rW cVtLiaSJ7GL7VBgKPLE+3fjjpnGSaaV3YwcmtWf/1vjO6uIFixHFCpm6zjHyL3wOgJ55qgLeWN/K knWVJH3wTIuFRSB8v1Bz19a/3d5bpJn/AD9030LczJKBCvmqYcLmUYDe4x/SnRWIDG8KbgXUy46u Bxz+AxVltpbmi+ozIgtI1SaI/P5UvDEZ+7kHp/jVFtLlEbGORIbXe0jWkbFoImYk9ck9z370GLbv crGyWW3l0t4RIkkiyfa1yksO3qisD908E/7vUc5vtb3VgiwoTHH5WIZonHmRcdc/TqK1gtLiP//X +MZIbdUd5J5LjMeAxONz45J/WorfLmOzWQPmNpsOcFAvU8/UV/vQf8+U2m7IdbWatdwKzAfvMYzg YFT3kVub144GZ1DbQzAAk98/rQZSdjPh5mlhVS4VvmbqmAO1T3MIljjufJeSax4hQsURwflPHT1p 9LGI6G5uxCx2lRt/e4GQgOBU9vIMMuXIfpj+GkB//9D48vx51tp8IvC0NpN5qRRriVHyM/N6cdPX NS3bCFXMbO0ksIjZWYgtznkV/vQf88k21oiPTphHG0RijK53OWQM47cGrrrazTeXA0zQOAFkfCOC QM9MgDOfwrWD0sZEN9DZyRx24uriNbdvKk2qJEZQAQAT8wOf7p5zWBAbiSR7dlk2RnEcjglWHbn+ lWBqCKVIWQvF5YOXGMyMfQCoLZRAHmSOWZZVy6RuIXZRyOTx6dqcd0Zz7H//0fjyB0dkBOJ5fvMe o7c1ceGSOZY4mUv5mBJkEdSD+Ff78H/OuQ3hMpmMdxDO9vILeVofuZAHHAHIGKq291IqToLcAJhA 7nluBlh+ZoAsK8U8SrJKgBPyqWALEeg7461XjSOTzvtEhVrbG0Yw0mTgAUeRi27suxWYmUtErA4L ZPRtoyf0FWLW83lzIiu5BQs6fNj0B/Cui1iT/9L45lKWc0SvLGZLkt5cSbjt2kdTjHOeBnNTvHdQ zs0MizxE5bcPlT5cEAfWv+gA/wCc7mSIIY5nEsjN93oCMcVXCEuGDbWDcgDr9aSBNPY2fLWePgKu 3GQeFPtR9rt5LotPAEGwIFjGEXAx6+2aUk2tBlGSCeVhGsrpbGTzRb7tyn0z+lW3t0t5LeYuHTG1 40JDxY9eMc+2axA//9P5IuCjTW7W7b4Sp85SpDK2cAD+f41B5l9JchGhL2yKS0q4EcajAAI9cnkn rmv9+D/nPLD2sZmHlybhIwQA/dBPHFOuNJidlhS4c8q8oUbOV5xQTLYEdbXczghUGMkdKrteR6km 5IBEkXypIuQZsdWPpz/KgxJls3sjFKWDFgs67fnAzyAffjpUN3PPM5efykcLjZEoVcdvxoA//9T4 yhSZ0ZnVSCxKc54Bq9a3EjSyFQZBbrukAGCoGOK/34sf845ZF19vdUVXDH+8ORjtSkxwb1ZsFB9V H+eK6AunsVY4YpUMksp2sflUcED1qSSGFSfs10txGow205dT6GgUnZEEao4w0bhEJ+Vv4/pS/wCh zysywrAkTCPlNm89c+9AofCj/9X5Dv4RILZleSLyD8qJ8iyD/aqxBmbKNIke0ZJf+gr/AKA6e5/z jleWCFicY3DndTAowyO2FPAAOC3+fatQJnVPLGWCsOMY5Iqu5jtkKo2Vb0GaAIEmkilUx8hlKnj1 9vzqRpTJJhs/KP8AgIoE3ZXZ/9b49jMSA/N+8PoMnHrUhcor+SxZnXDZPGfpX/QQf84yaauWUtLR bOOeSTNyE2yDOACQOg9KpSr5arKgLLnDEdqDOb1sVjdsJtgjAjAGJAdpb1yK0fMhuJWURiGInKBT nH1JoCM7aMWCdoxJEBGLWJcqzAb/AH+bqaiSQO+5Tw/HPy0Fxlc//9f5MZUQbt6tgYKg8g/SqKID PKDGSFGSw6c/5/Wv+gg/5xyWJSWZI2CydGZ1yFHrTJYpbcKnmrK6tneilVP4UAWLeeGYMkuPMx86 /wARqtPPbxzCKJW+VNzhl559DQRNX2Id2W8xgSH6HHAxTd8i7RFK0ZJ4dDjaeaDNqzsf/9D4+iaQ s5lk3cYcnq1WEZFiLEARg9DX/QQf835ONr2omgxJGx2ghvl96zdsHmCPy3ADeYXJyhOcjA7YP9KA LrYnUDONvGDQjlGMO0leuR0oAY7AsVwOB8uOtU7NmWWSR3MYUFSrH71AH//R+QhJE0m0Puc/cBOc +lTyGW1MckgOCuQMZzjuP89q/wCgg/5vyKFpbqJry18wKoLMJE2lfwNZgadpDPOec5KjAGKANZ1S e2WVSD8vGDwaS1uPLjMWFEZG3GB8v09KAGG0UxTKxxNuzFInzIykd/QjjiqsEyIrRg7xGxVm7GgD /9L5DQ2zAhnGSPkTGSx9KekRwJWARh8pReoAr/oIP+b8muVljELxYIkzsJ56eoqzbSXN4PsqR+Y4 XJ2j5jjrSaurAZ7szHa0bxgNsO4YPHFTgRgbCAeODURi0wK13A7RRLlwrNkGMlenuO1R2trIk7M0 jKChAHqa0A//0/kCdZY5GVwQ3TkYNQIrzMIXVgByzDI/Wv8AoIP+b80v3IBj+6EGMn+Kl2Kyt82Y zxt6cUAV1tbS3JRRgyAska+tQOqyJ8xZChz1K5waALLyGK2WXYxz1IGarM7iaNId6+cMnvgDqTQB /9T48ZHZ3RZP3iDK7uhxU8YlkjJAPynBPqf85r/oIP8Am/JPNnVtmx9m3lj0FOZ2CBN6q5boRywq eX3eUBTDLIyRQIzu44UDOcdayHDrI8cm5WjcqQRjBBwaoNieBUSX54t8mM88iluoPtNzbzQDBjiZ JFbpyVI/lQbRd1qf/9X5E8pZ2jWd8BQFwmFwB2FNeN0nEAZZbZJd0KsuTzj7x/Dp2/Gv+gg/5xza h0+6WKdre3aWO0YedLGu+JSckDj6GuemSXzftHmxiVmBSMDYB/nFAF24MbO0UjjzAnLJkq/Y7TUZ sokhj8l2ZNvzFuHB7g/lUuSTsZOb6ECYZWMg8nyWOSxyHHqKhtrt70HyAzwh9iO6GMN9M80KSG5X if/W+Sb2A2iojujFxkFGDA57f59KzUWUuQo+XGOa/wCge6P+b8IllViJBzk5bsakSGUlpOhB4NO6 2NKfUmLySZaY8g8samMpdQEAbauA2OBR5GhRBuZj5Crl5G8tSRgAk4Ffll+3Da/8TDUYIbl3WbVR CXBy0bRNDvGOgHHH/wBevgvEdpcG4+38jP2zwBv/AMRHwVu7P//X/i1vFV5jF5hyRliOSADUMbGA kRyyKjja6/wPzxX6XiXarJebPkqLXIl5EMuN4Dkn5upHG31qaFQ0pTcFA4Vs/erkOmMnzalWcyRz IOBtfOT91h/SrbXHmMFbATGOPvCueelzop9Ryea3lI77o4+Bu4LUlwfJ+WAhUU5IUdSfWuc0P//Q /i2KxSokhKlxycDv7Ukf2WPc7AR3MieWzdiM8D+VfWT6HkR3AysB5DOg3D92WPWqos7yONp3lWLJ KJJG3z/XHaszSa0HR3zoUjky5UYaRuGP1qjfXEzNiLAjH3gBjPuaDIjtvtIOVi/et9wngH61tSrc 28nlP5RuQq+aYmDhcjPas5ytogP/0f4uDhgiCUmQ/wAGeBV37GYkySx3DPHINfQ3Z5ikkjDmV2mt 0wCqyFpCV+Y+ldPI6WsNsY9skkkoQjsByTn24pBzotwSx+cWLspK/Km75Bj0FZmp3il9qy7iThh6 e1BPM+a5QaRI5IHjEYZflLquHfJ6MavTtby27YYfaI2+6Blhx3qZK6NT/9L+Ln928YcliynDLn5T TUl3EJjKq3Q9h6V7G2x55eW4ELvv+SMj92WwcCr2n2lvd3G8zo9vPhTG4AQEZyf8+lAGHqtpFDfX KQqVRGMYQNujbBIyKrwW3mwDcNm0/MByxx2p3d7gNmijkkjby8eTwgAIOTwSa0LQRs2wLvkGTuA+ 7j3rZaq5nO1kf//T/jX0uxspTHFqM8qI8xMkiAB1TsAT1P8AhWJOvkySwl2SBHKozqN0g7HGe4r6 A8cgW4Qh13MVRdxIU4IFVLi52mMkSFJX2R7UJ6ev/wBeguMU9yX7Um9VWQNtIDrjO0+9aRuIot3H zOvyFTgfjSbS3H7PsZ86RTrCUVohDne2eHJP+FSQJJEGC3BEYAbdn5s+lYeRSikf/9T+LtppwG2Y YkfMCcZHeo7aeJFl673YEA9/x9q99bHnNJqzNHMEyMWXcqLxkZxWQ0LJKH3MqA5/D0pkez1Lsd4V 8yAp+7YZDbRuB+vas6S4H2lS++TOI2YnOF4/lQOaSia7TWMcUZgM0iZ2yhUPX/Pc11V98R5LvRTo b6HbxQOYobcwRFI4PKGNxPOSR1PqT60pRUtGZpuOx//V/jIgYySI22PAO5i44jH+NdKiW7KXtlUl j8zYwDX0B45UurtmXyCxMg5YA8IO1c5frOFmZ1d8YdZFPJP/ANb+lADLKOVU5lkaP/WNvOSSeoHt U7Wkrq8u8gZyobhuKT2YCLcLBHuKu0oOG7gio9iztFKoMc5Yh3AwsQ7c1itwP//W/jA3shdJmjc4 IjJP3z61StVkM0oliUxhflbPAPrXuT6Hjj7tpZvs4kXb5LlkcHG8YxTVnuGdE3OeyBuAtZjs72RX vLu4iuYo5cMUOQ5PyYPcH+taNinnzrIroY8ZdwckUG1vdsy9cWwQskfzseUA/h+lU7syxLbRymSN h8y87PMOD19R7UDtbQ//1/4unvppUWEqoZBtwvVvc1NBOUGyVfoR1P1r2DzyS8topPmgjyMAFOc5 9aSOJ7eKK1D+WByxJ3ZJOcZoAqvcS/vMBlSJsBs/epgjMrozqSrELjHI9zQBsKhBMpZ42jjIjkj/ AIz6N7VkXVwd6RTE7JOCQOR7/p+lAmtLH//Q/i5eDyEJjdpBtwJD/rCPeoYniZo98bSIn3hjBb61 7B450Vo8ts0UvloqTDcsUg6CrV75cuLnGZEHAT/CgCg9zG9u8YY+cW4BGM881zLjz7mTyY5UaLCt uJIBxyc9OetAmrk1xbsVDGQmYjjvtx7U+1tZYv30qHDjBlHPA7fhms5voM//0f4r0uDHfIi3UaRF TkAZkOPatlofNRp0dNsS7jlhlvwr0Dx7GfNbzyQiTf8Avc4RlH3Qeh/Cu28Lafa34uLbUNUttOSO 28w3U0TlJH4AUBQTzz+RoeiuCSbSZjanZJZ3EkMssEyKcxzQPvjkB6Ef/X5qkZJWdVcLKm3926rw BjofpQFuhSN15cqoyhY1baTj5yPStKKSOSVZVLBoM7Iz8qy5GOa2i7obTW5//9L+MiaXY++JC0pJ ZQnGD161QuXnaXzmDszDlM4NeweM1dEEkE0Uh88soGGGTlhnt/KhVJeZ1mlA25UDgEehoFFcqsX7 G1lMEswmXaT9wsBJ1xkD6mobhPKdwx8qd4wwJXO4HvQEvhZRGlMSly1yJ5GG5lRCioPQ578Vbmub mKIm2G7yYT5h6sARggfgazm+iIp7n//T/ikt3jEn7uJ0EmNxJyc45/WttJIbVGVJspkqX7f59q9A 8czUuXt5hL5YmRmwuP8Aln/tH6Vp+Y905mHl4UZVc/KxHagAl/1M7B03S/PJAOFB9qzbQP5nl4KM 6Eghcqcf5/SguOiZZJnnQwbzjOJIz9w46H3p+lRIJHinKhXOEZug9qCD/9T+QjTvh3r2soZ9GtFv WFqWlgjuEV4lAyrlSQfm6DHWvKtThlsrh4p4sThBiEHgHpnNeh1seKqkJScE9Y7/AJkjhmhhKkqC MSDqSac9ozJGNrMO7g9fY0Gj+J2MaRTFK6BBGwGEIO6ltJbiEKULM0eSM9eaC4yvoyUXs11I6zuy uUwi9tw7Vo2bm5ifzGk+0wMECEgx7Rn/AAoLP//V/izWQrIdhOfM2lcY2mtF7iYqwEpgYDjHfFd8 r2sjzyhb3UksgV2/iI3Nx+JrZgxFAXm/fx7iVUc7awtbQ2jK61MG9ugjswChn4X19uKrW984PlOm 6MNvZs80FG616IlVVjDxyjaHzgR1hTBrl2TLMqtlADkcUAf/1v4qlZgI4hGgVRg8YIoMs1mM/K8c oJRM8r/h0rVu0jBK7sVDdzrErvtEIfDcgOCe2K0hM0ltEUn3xq25ogfuHA5I9/6VnfuW6fYZDfEu 8DRK6uPkfGGQjv8Az/OoLmOGJnmyyyTgDzIz8y7RgVrzqxSjFGh59tHb2jQsyz4y2fusPp155p0k 0kZDYXc6gq33lUGsSrWP/9f+JqWW6SZo8MYXkDMQOF961LeZG3CRkmRCFU90+tAE15aeYm9fKxGQ Tzhxz/DVaaXC+SHk8wDDlc9CO9AEtqShChHliHEshOBHnt+lMuoZYJ/PDbYj/dOcfWspSvoJrSxF p17Z31xcm4ijgWIZtpCu7zGHXjsT/WpjqUgkkgRGYMuPkPIHrUt6WJvyxVj/0P4lJ7uVmYuGyowB nnFV1hh+ZuJGddw5+Ye1c4GxZRRrCWDOhxt981TudMuQHmaN5kb54yDkPQBtQWcENuksieVOFBUA ZD1OtxHGwUk4PQ9Nx9DQBWuHGRgKGXn0JHoKpRTIsq4VUGcuDjj60HQf/9H+MOzhF3J8iQ7gcLNI QGT/AHSelM8QecnkCJEdVTKiNsEkZGD/APXrnOgz7O3aO3+0ygJLJw0QYHbWNqV5MB5EUY8pRueT BJUk9Pb/AOvQTypO5kpdSNLHE8xgDcCRzhfb/PvXU38kDQ2bW8JEsaFb6VnLPL6FR6Ck1dWGklsZ UazXaqm+eNIcuvGARx3/AM9KivpWX5IpHYgfMzHP4GspR5Rn/9L+JmLUJI4IY3toEGzCyqdpdiep qp5u2dWkbec/vY4wcKPWvPOi3Qnnvbb/AFdoWKkgKp4ZfrQ8s0aSMrM0qgYKAfMKB20uS20klnEz CR2+0J8wbJY+ufYelUozZLOvleYWyGJkATLEcgew5oETTxBnkndEOE2xxE/Lmks5Dc8lShi5jK/K VP8AnFAH/9P+Jl7R7iFpbNJpJ7dvNZ4gQF7HPr1rPt7W9eZo3aTL/M8Q5zjuVrjb92x0Gt5MsewZ KKP9ZuHYelRIoMjEOdvrioTsrFw3FluZHaMPH/qmwm2PPmEdOe1WFujDEs83BDFWjB7dv6U4fEjX yC6tkm8xzGYi8YPyjtjj+dc5FbESvuzsB4PTdWwH/9T+J6KSCMDGxS/ynPSrDWiLKkrlljcBhtHz 46HArnPQI4bxLieWJvN8mEYkVkI3H2P+FaUMULxS2htYl3jd9oMI8/1xu61pT7GdR2RC1utu0clv E0URHlvKOfNI68+2f1pHkSRn/co21c5I+ZvrWnkYydkSxtHPphha8eO0hnMs6Mcqx6YIP+eK+8P2 XfD1017pLWi25juJY5Hu74+RGsLsDLu7qOIx06Cv0Hwuh7XjPCxXc/MfFyfJwfiPQ//V8S/ZTuY3 +LPw006ezNxL5kcV3aKmxNPiY4SVGA6MFLZ9XI+v9xX7PdtFZ/DbQY1QosFvuQsuZGXYpya/qD6T N4zy+C2sv1Pwf6LybyfHTa6v9D8DP+Cy+tm5fStLt7gmJddtntbWdQYpoHJZivr8xyfoea/l3/aJ a+h8P3Elu1tDYafaGMsrKjushZmDd2Od2B0AX8T/AEN4I0vYeHNJrqmz8K8Y5rFeJsaa1s1H8T+f L4hzCTU74yhlmkk2LdzHcsuPu/UgV5taoImZn/eMpyGHI474r+E/EmSnxdjn/fZ/Y/DEeTIMLH+4 j0K1uZ30+LzJmkhK5WI8bT3H6fpVjTpYkJXy28ydv9U/3E2559ulfnM0fQr4Gf/W/i+leO5iiIU2 xZP3mwlwjDP3c84OBUUVna26xyag7vb3G6NXXku+DgfnjrXjVlqTD4UaenQ29rbx3l/eXVpnzI0t hEHiAH+rdmzxnH4A981vtALmGAxTrKzpvD78wqD6H14rCxRuW+mCLT9st+qXkjtHboRhV4yCSao+ Tc3Dh47pzNBGFmaUgpKenC/SsGrOxUY3Fls3dzOk/lyxqFKhQYwB3+tXEluLjyvtD+fMi4LsegHH 9KRryq1j/9f+RGMG9EsNtcLC0eHlHmLErgdsng/hzWjZTXULLNIo8pFaIKeQ2Rtz/PFfLPRGjhro VBESxNve3GnC0DzWsifMN5z8p74PNS+HWkSC4vNTuleYSnc0jKox6+2etYS1TLSS2Os1C3juYg9s QrFN0JQhck9SDVKFo5GVfL3Lbr+9kY5VSO+fyrnG421Z3+ixR6iliFnlkghzkxpiZBkmTb7nnFf2 Rf8ABCDwbqUHwutLn7TcJYalriPZLfWuy7t1hVjgN1+bKdO2a/LvE5J5XTp96kfyZp70XE//0P43 7C000i/+3NKt1HiO2dWyjMGwR9MVQtLYQXmpzX87QeZaiCwigkLJINwJLjsxBOCOlebJXR5cIrlL ENuYSLm0VWULsKyZkJ46fXvRfa19pmjs2mmygGP3f+sbAwh74H9Kys1uXZFWC5bz3+2wi486P7Om QA9qAMAoe3QVYkF7NaJpxZnt493kg/wgnJA96iUbjKgeDSLFI9k/2trnInbLCJTn5R3Byep9KjS4 iVbpBArtdhHS4yRJEykE4OejDIIrKzvY2j8KP//R/jMvJ1jtImuoOAR5kgb5oU7sfYf0qzZXNpEx KkSJCwjtpZDh5F7NtrxYxUSY6RNizsJ9buJFtL6yhMLbpUvJBa5JztCg8kcHpn61XtLW5t7p7xAP NJEbDJEY2nB21aV3YxNbyJLKZrkjyrp4vNiEeCxQ8nn0qgY4L+88q5uZy4t2nUz4FugGfkV8YBzj jrXbSiJpPRlZWCeUIgRESSHxhB75rT0+2tolZ9mHdwyMmDv+tehBe6jFq2jP/9L+Nbxpbi0eF7y3 Ki8jLW5lgzFKcdR2NeAXaATlIv3ZVvmUDbj8K9TDu0TxpRtVsfQ37M+o3MPxG04PK1vbLaXNr58o zaqGRCxOOd2AQPUtX9EPww1p20rRobieyugLaOeKdwGYjYE2Y/vfKBg859a/sr6PMk8hxlO+nM// AEmJ/NnjglTzrL6iWzi//Jmf2u/8Ev8AU1vfhFp6xsjeZaW9vxwYpIo8FcfTaD9K9v8A2+NMXWfg nr1vtLXCIsMCSDMCblcPIfcKT+Yr+ZeJIuj4mTX/AE9/U/pjNorFeGMY9HQ/9tP4e9W0HRdD17xF F9gtYb+31p7P/RGa5tzsGA4z0DHn6g1iL9uLk21pbwvC+2GZmz5nOdzg/L7fQV/p7ktVV8vo1e8U /vR/lRmtD6ri6uH/AJZNfc7H/9P4OvGtZYJpcXlnr91f+RNPGAulTnO1WEeM56D0qCKeQuUu7IF7 GZY5IkQKL1QfnOeue34V/s9D4T/HZR966K3iiK2ur5bSGJoI49skapK0dxCOGRSQQcjIzVKHQhDb QNBNIkZld7yae5LPA7E92ORkYPWtINbmc1ZjrvUneMWwRpIbHasjlvNwcD5iR68H8etTWyErdTws 1u0UYlSWQcSg9FX1NbHPKNtSG2dluGmuv3isp8w5JcHPXH51rSxWUlgZ7eRBuOHzw647MOoraMr6 HPPc/9T89xJ/Z/k3CFzcBg1uwGShzwwGe39K0dQuNP0+IyWBnuIZsSzvcZabcQDJwScfNnAzgCv9 sD/FmXxMgVrhZfOS0uLJJbcNa3ZYDzD2Kjr3PPTtVvTrrUdQSXTLu5migspPMUYEbkkc9Rzz+VVF 8rMpKTJ5LjWLezu7FLmRvPtjaCZYVlli3Y+ZQR39sVDp+hGweENcR3i3BWWW4mjWBhIoHLDJHG1e fYVrfUaT5bM07sy3ms6RHEbZVmhNm9u5Dh5QflkjHTHPJ9vygsYbuz1S6gedb2XZJZ+RG+5Y3Y48 wj1ABx9aZzTi3qf/1fiv7FdaVd2xNzGNLCGS6Uhj5jHkxoecMPfiuZm/s2S/e4s9U/c285E9sikf ORnywTzgZAJr/byn1P8AEcS/sZpk8qCdE4Wcq4LxOMZ2OPoSKnksoLjSLHTbe3itlgukmtyuSkbh lMoHs20DA9K0Im7Kx0MGnfaori2eSCMw2zSRBnCCVx0X+v4Vzs2jXVrsuU2SqpBY5wqn0ppN7HPJ 2tY1LG4tLmX+zQ00k0kbStJsHlxsASFDeg/xrQg0G2W909r6IoNQj+zvO0qh5mTIDEnpjgfhWnIr GR//1vh7VLSOK/h0sFlNqd+M/u2JJABYcHp+tWzpEuolIJm8rbIrSSFTuhC8gAd845r/AHHSS2P8 NJSVrGVcSQaZdXmnWV19q8r9xdxCPajsxD5BOc46gg9SfSrYtoPsX2iR1gRQQ7OdrKPbtTCTVrFf RYobAz+a8jJIweNt25pf9o57/wCNadtBatcverOyQkEEykoIznrjpRboc05JaFq+ufssB8gOHByz bM7s8ViR6hdS29xHPIwXfvjiUEIzYwCR0zim1Z2MedWP/9f4Vis7xRBcSrJILsbIUiO8OQxUgD1z xg+1aupWl9b3kSNazpFbBJC4JdV45344745r/clK7SP8IXJs1LOLc7JEVit3QzTT3BEcMhPoT34q tqA02K9t7bekkjhSZfMUxKc9Mjt0+lbJWVjnlrILiKw1NvtZgMUliCjNbDHAGN7ev/16xpJ4RJbX EL7I87/NkVl87uo2nofamczv1Nq0ltN8KRFvtkkwChhtHzehrXt5FF1cW8UjujAPMkS8r2Lfj/Wg R//Q+OL+4ETi3gi3wqComkQGSRv4twrOt9O0mW0ivMSs9rKJ/ss48xZnVu4xwpPav92D/Aqe4BDL GUlLRJ5gkjjhyqDnIX6dq1LZLdoXXV5pFWPcLKOKHCNkDDOw5OD0+tBim+Zpmbbw26XsSXLqsEzb 4M8NKo6+wyQRU6s8d4kqHyJLdgQ+A8ceCe3SgmUk9EI5vLuaSR5vMeRyVCjCgdlH+e9NjD4EMoVF Y7d8nCntVwvcyl8LP//R+Ljoty/mRmeC3iQ+ciAn98SQuF47DnnHC0PHH5CWSyoHhm81bgr0Y4DA 46g4HHtxX+8B/wA/UGk9S8tlJPKI7e4huZZANkShlck8bRkc/h61QgkufNnhYPAVVopY2+8pBwR9 f/r0Ck7shLwIphZSJYyGEzMS+B2PPT/CtbT5I7Gxvzuab7awkeJ5N+TjACA8AcfqaDLmSdjZgtLS aASxytE6KNyEjaAepNZMlwDfiGV0a2UhA4yFwOp/z61tD4UZt3Z//9L42ubS3LyeRIWt927ngfSs 0yuJ98m1VA8hPLHAT/Ir/eg/57m7K45hOkomgZkiQ7FZuxYEf41dgs00w4aYagLpdyuHK+SSASOQ DxyKDFu7M2aeO3vHZPtFvCkeyZwu+Js45wBu456Zq99pc+W4uN8BXYi/dDDqDQIguJzLGYYVyS2G Yduf/rVPEnlxqMsCpAOOM0Af/9P45yiFJVjKqhDHDAlvXtxTbrzrlIrlpkzM3zS/eAUcc49q/wB6 D/nhl8Rfl0qW2tFuldn3rkrtwcHof8+tU4rowqiSIcs207Rkj61pTWpDajuOkYknGSM857VBvcsF C7cH72ODWhPOtCS9jLPFMrpvVBvCfL+H8jSQXUoXLRoUL7T6mnHdESd2f//U+RLmK1ADwDEq8soO 4CqhmjYrGzP5zD5Ap49Dmv8Afg/51m0iFXe1aWHaF8x9zbRgMRxk+9LZ3Md0ZhtdBBJsJxwx+noa CZSVtDSl06K7gM0MaF7dw+F++NvcCq8MkTRq8pVA3XcoDZ4HPegze4JEyStiQsozjHCkfSpDlyzI PLK8AAYFWp23Jex//9X4/meSO1ZGhhlyyvLO6Bnj25xtPO3mpLfUbZ45A/ySBQoVeVbA5Jr/AH8c +x/zkWd7FYzySMWD4RPlSNQF4PX6/jU0Mdokgw8hYjcdyYFF7Q0NYqysTAWVsxaS9bzrgFYrMLuD AfxA9M8/zrKRZGjWOV9zIxDSY2u3JrQou28k9vIZ7eQK6LhA6CQDHsat6e5uIplngmPzEM6sMPxx tHXPWsGrOwH/1vkmJ4/s4MDEyI5D+YmMY/yeKlkKmzBeYCZpMfL8gYNwBiv9+D/nPKcCy29w8M0q SlJcRqp5RvUt7cVbnaVvLYRtFJj94+/crH8gRQZTbvYpSCV1wzbwD8w7N+FIt0EaOFYgqjrtGOv/ AOoUEGpPJ8iRwnc20MR2B9KomxnlTz3RoyMB88kdRQGx/9f4/wBrxYAJYbsYHFWiFAdUQqX6iv8A fpppan/OHze6RWdy1lOQiAF42iO9eTvUrx+BP6U+W2EIEIG1kGwgndyPU/56VsQm1sXIRbOsUV6w j2oE8yGEbEHqwHJP5mqtoLa1juILVV8ma685WZR5nAIwD2B64oES3E8ex2+UFflxjFUEQtJkeXLH ImCrLkq2eD7EYoGnys//0PkmVJJtseACowW7DFCxLbTbJzvOMMUO4V/0AbbH/ODe8rgbaG4WRYnI l27lUnAf2zVSeOQ7UUYeNRz1GRTTa2Lm+iNKPyTA+5AZHQISwB2jIJx6HIHI96pSRJEFYW00qlji QDdEMdQfzFVGVtGRzO9xVRCPO2cdD7d6pyqBL8pyr/3e/wCFahJ3P//R+OYwhbCgkDhuMkVJBvgv GkuV8ywNtIgjj+WQSlSI2z6BsEjviv8AoIP+cKPwtFr7Ohtt43ehLHk+9U2keCI9Ng4APeglkass 2wvFtXHbgk0+UJGoQA7GGDz0oERxW+IIrNXeRd2C8jfPj3P+NTtFIWTZ1j+UcY6d6C6e5//S+QJY /KdBIwbzBkhTyD7/AJVM0xRCfvLjBHTNf9BB/wA4sG2tSrFcGSbaBtQKdz55B7D/AD6VejnVZk/d oyI+XLfxiklZsopp9mF7JIq/uvMO50AViOwqa5dJFSMIF+b5nI5wenP4UwKssiRlbVMug4WTH3sc U8BoA0IVGBw2dvI/zmgiyc3c/9P42WOV2O5cJn0q+EgWNU+d5CTn+4o9DX/QQf8AOA1Z2HJiOPZG cIv8IwAKroM5JG8A4HqDQImWIcg5J606Mi3ctISxYYx6dv8AP0oAqz74X3rnrwTxipRaw3MsTAn7 gEgJxk9+KAP/1Pka5sIFO0AqynDEHBFP23Ji2yyGaKIbYgRjaK/6CD/m/ES4RU8rafm+XavQVNHE tpHJNJardBvlXcSRGf6/jQA15Z7iONZYYYljJ8sW8Kx8HsSACeneqEkHlNlCWjIy6kYKn2oAtXEA W2SWC4VBwrwzZMrk/wB09MfU1ABHsCABWI5PvQB//9X5Ds7aIqzMW88SfJ/cGP8AIrRjUpI4Zcgp 1P3a/wCgg/5vwBwEa6XCKx2BOuM9hVEMWuLhrcuIN58lXXbLtGcbscZ78UAK0lzKyJsXZuyT3FWp kCw7mHyjgkCgCrPe/Z4lgiRmRn/dyvyy8ZP+famxyFY94bLscg56UAf/1vk6BRMhMrM7gks7ck1T S4kjmn2xkBAY1YjIfIxkfniv+gg/5vymXZ8OQQ/pnBrXsreS6jkEYJMUbSv2AVRkn8KmTsgGW0TG VnU+Z5Sl1yAcY61HLE0jk7cqRn0WsrsC5aymJGtXhjlSdNmZBkxHOQy+9TiCH58yeWQu0soywHt7 0gP/1/kiKJROZS+6LaV3Fcuw7d/pThN5B/dD5S2SD35r/oE5z/m/J7m8EihkX5m42gYyfYVk+eJD G01vJ8su1gMIwA68/wD66pSTAsveSoivE7LIgKoUOGAIweapRJNOrqx+Ynec/ePXvVATxwSmMvzg ZXdj0qILcqAQ5jBO0sRnIJ54oA//0PjUxSW9xKpbzIg21ZAeCatQSszMrKVK9M9T9K/6CD/nAu9i No5YmmlRmCSMPOIJ2ZxgZ9/8KaEaRkcgMynA4waBF07EZ3mJ3RLhFxnHtS4WW33RuQ+/JTHHFTKN wGJGZFdGBJPDHtU1tBsfyEwWYcKODWNraAf/0fkWVILePa+9pVcsXdy49e9MiIuHABC7jjpgGv8A oAP+b8sTKbWXEg3qeNoOMVYhaDe6SSIvybow3BOOw/8Ar0bGlPsZN0m6QqjADqMjINWoJHPlwW8B O1SbiRjlR6YFNOzNB9wzxWzhgqylv3bDgxjrX5n/ALZt3pUU6QRWEcv2w+TJeLJ+5kkZEJkC4z95 cYHpXwfiXJrgrHv+4z9x+j3Hm8SMGvX9D//S/ituEjl82WAuGeQpufIB2kjgHpVeC6kgSWMqsmBt k8xM7O+fb61+k4r+LL1Z8hR2XoOlDyKvzbZHQ+SQMr6/5+tMtwxdYZyqAkZkXrXMdEd0PlQi7ht1 KCN5grTSnaiqe59qguY2trwSb0lhVmWTb9xscKV9q5qi3OmHxF+wczxjz2XmX93gEYHbFaVzDAiI Fy0p+Ur2xWBsf//T/ilSQPdMrM8YgyfLxgN9aSQS3M42AbVzwOMV9XPc8haMkFu2NzZABxux92rj M7RHBMmDt5HAGOtQXKSasitaTwurK0eJI3IzIvD4PUe1X51t7mUSugVOCwjGFbA6UnojMpeaWIJX aCcLjjFSLazEGeNXLFtpYDqKxbuwP//U/i8is5Hbcm3ci4bBJz610EF7AlmqTIXMalcAAsGP8xX0 B45z9yUWRXjjJbGQCCSfwqbyyYFVmZsfOc/wn2oAYhMamVg0qDCnb98fhVW/tFecTofLQheGPyZ9 f0oAZBA3nMElVc84blffBpWiZpmaNsyfddiOGHSonexvHY//1f4tFXyAvlgBU+Ur/CKa0ckYZm4O 7IwMZFeweZPaxXli81g05fYcbQD8n0NaSXX2aNljfY4jxE23OCPagzu9ir54ZQ02Sd3Lk/1pIpwL efYw4OI9o3H6miw+aWw61ufOGbiXc7/KCABjAxiugsm0623GUN84+aVOdv4VtBNR1JP/1v4w7+9c Sp5BH2YcpxiT8aqStLdQM8nGDhCF3H0r6A8cW3gSOIAMWkI+cYqK4lZohCh2op3YK4Of84pNpLUc Xysgjs1jgaV3RcMCwb5QO1X3WCV0iLb3EYYsgwAPSspO5rzWjckYW8bwxup8snCrtyM+pNUmVUcx qu5S3DDt6ZqRpp7H/9f+L2NIy+ZSyoq8qB8xrPkRVlAYbUJ/1ncivdjJcup55aWIoDIGIhZtqgn5 zj2rVEkDeXGrDzAMbW6iqTugKFzbtBl3IKOeqjlfqKoXOUTfGrMg5GBkn3pkT2NvRBb2xt/tcbXH 2sMrw9AucgH8OtRalbx25SCGdrmJSSpP/LIk5Kt70GR//9D+LNpHR/KRiGbG5emfetiS7dLJYo7g RSrgZwC5A6gV9AeOZH25gWQOPNf5XkYVotO7W5jUbiEzzwWxQRKTWiKmlvJcyRyyv5IRtskAOfUc 1r3rqjYAOwcnFJ7FRd1coXRSSMCNgGIyV+6c+hptvqEBt47aSBkUrtdsfMTUKDvcZ//R/jFjECbW 8jzQuUQkZ28Y/wA/SrcEMKo+W+Z/4CMAfjXuT3seOZ995RljhGd6rkYHyDpx+lMWS2aOSKYFmWMq uDtYHnBB/nWZuklsVfsyNHFCy+Z5vEbyHOPx/GtSOCCyiyo+aPBZYxhW/CgZSu53Lh03L5fzZHas 6a5e5Kp87kf3uTn2oEmnoj//0v4sorNmXMCyZKgO7EA59vanXMF2iw4OFTh88s3pzXsHnj4Lu8Sb zDslOwJICuF6dR71fjvBHIjyQeYsrZORnbjrUybS0AL9YIk3gHZK3zRxcyJnuBVYK7SDyCSijADj DtTV7agXIZtyPHl2UD5Rjgk+prIuIJnBKYLqcKPT6UwP/9P+Li3iuYgrzE5J8tUYcOPpTrwpaSQy ODHEx27VUtlvpXsHjl9biC4CbtzrD+8iJGCCBwKzH1N1V5SHQqxAj78dPwoAZau9yxlk++x3j1Bq a61DyUSOSONZVygSMfPLk9TUydkBHZK9y8rshUADJPb6VuW9z5X7oR7jH/fHGKxA/9T+L9bC2SO5 uILWItOxR2C4MZyDuH4/1py2ssXzRoGzGDwxKv8Ah+degeXBdSL7RMGK4CRAZZm4AFEd9IM+VnYf lbHG6gUo2ZJGqk3AnmknIAZE2gLDnqDTkudkciJzIhyvY7fTFBaikUHSF8PIe+WQnBzTrWVWl8tl Y8fKR0OPWmnysbSejP/V/jMgZQSr/KzHYj4q4lksamSbaQq5DN1NevdJXPKlFR2OdlWSd53j2hFH RnAZvoKfHOojRNqiUDa65z+lMgZF50cpMQZwTkhe30H+FSajKzbXETMUwGUjmgT2G2t6NwiQhGf5 ctgKufeqxuGXesSlpASqgcbqwJgtD//W/i3m0+SLYhDYdcsUOHGR2/OqoS3t7donhlOZAsRz8w9S R3/+tXoHjj3jiktfJjkZJ1ky4xwykcfyqvYpJbvLCZC5PK54X3oAtXrs5ijiQKQ4MhxguKhdpkkR kL5UYXBwVz/+s0GkVaDJD9rjuI4FiDqy7vMDfeJ7YqaZmjdFyGcf6xlGADQZn//X/i+g13XLB459 N1W/0u5IMDTWdwYS6HIKt6gjt71BeyyXX+kXFx50iDYrAYz716Fjx+W3vWINOkcllmYN85+ijtXX 2c1rFMgaNXidh56McAAcce9AHN65BBBeyTW0Uhtt4IKgyGPPrU5skeKOFI3inuEzDIQcyE9CPagN jBvYo42iESnz48xzksCCwPXH+elOibyNsqebJIzYYAcfWg3Turn/0P4uYpYWZZfMBZnxIv8AFn1x 1qpfXRVg0ZKuGxtC8MvSu2UraI88zpnX5ZA/l7uCEJCn8K67RlD2hSMDapIYkfIfas277gc9fafM 100bqREX8wMeuM5AFP8AsVquZJCylBgjP3vqKW25pT7FG4ldyrw/KIztCtwr+vFVItR2gqqNEd2D n69qzc+iND//0f4vI0t/s6StIGLJk4HKn0P+e9R/ZIJ40MqF9p+QglSvbNBjBpPUyNU0pnCPC4Ec PzejSH0qtBa3nC7HCtgsyglQPeg2NiCFgZIgnzqcGU8LIMDpUNybe0tJo7kOreZvVlG8qPTFArpa FJRIp82VDgoFUtnGD0xVyYGJAzNkMoO3rtoGf//S/iaaYvIY8vJhN48tcrgds+vtU1miQo5ZTJFL 98H7wNAm0tyzDdN5wjlQtEG5XO1mX0/CrU0IkjdrQbcHEhJ5HpRboQpu5i20s9sziRiFdtpXOQcH rW3Nbz3aeQjMi4yzE44rNwSRbdlcwUtJrCd1kjEi4JUg5I7VsRSWsMcJglcXz7vP/g8sHgY7561P L7tzJyukj//T/ifWKKSKeJ0A3niZuZB7iqP2FBcLFFIPlA+Ynj6mue1jO7ikaAmaP9wSZUU/IEAw xPvWhHM5mEZkVWSPiJmwuMdveguLurmdcmQSLc7mMcnyrzwmOMY7Va1NftlrbyxRxo4jWEwodruw 5349+/4UDIAj/wBn+ZctGs6SbEjBJc471nwo8kqM0Y+YnfzjYB3oKjK2jP/U/i7jUG1KxnGAQMd6 5vUbqe3jQEsQW2rgkMPpXOdAWVyY0knmU+ZKQp+bO7HA47Uy4i8yZjGxaFkBeMcg59fzoAludPe4 tgkUKq6gMm4fd6c01Fnjt91w4aTGCwPKgcYP5UASpFK0RuIHZ4lTEi5wyn6VnIYzJtlBRD1JH3qz qdBvc//V/iUuLZCyoh3BF+Udh6fyrKNtPGpCFmnXvn5sV550EttHtWRmjw6kGQlcNmrs3nrBiEAM xG5ujYoKv7tieFpJnQzcOidAuAfc+lRTWsVw6hSybTzIOpoJEDAK8OUYIfkZ+XZhU0O5Y5JCqRKq Fpcc5Pc0Af/W/ihsNUjtnt4rOaQIqlpNw2eYeuCPStW0urB5X1JopI7iRmiZ5AFRtpz8q1550C34 S4hEkUzDfl38xcEYNYMMUkKNPJMD/eUn93joMUDV+gQyXal0DKsTAsFPPHqPerMN1aRpKby1juIg hG2Q8KfXH4VUPiRUE+Y0INSguUG1GXI2OGG0BR0x7f4VRnlhddyxpsVioG3DnHetjU//1/4j0QSB Ng82VpfljQ52/WtiyiD3MVxdSzI8Mm1Njfd4x09q5z0B14rWpwpLhnL5IAZsnp+FWLLVCJtpg3eb GUZX4ZeDgg9u35VdPczqIhY3EsasiFApbcvUDtnFQRRSAZnkCSA7UVDuLdwcfTtWltTJq5ciulvr a7tJ7AxxLtzJDGRcXIXsB71+k/7Khku00zT5bS4gs4HjuHDc3jjeOAx7FecHpzX6b4O03U43w0f6 6H5J4yzVPhCu2f/Q5P8AYn0xrn47+G7S5jiTzIkgeeQ/6ZpqW8sYUyL3Uh3UYxyK/t++GVlLpfw8 0mF0SMNYBVbjcImGA5A6cc1/TH0mZr+28Fhl0jf8T8W+jNSUOEMTWfWT/I/mD/4K8GXxH430+x06 8WLUtNuI7S23ODBa2kf+tlCdS+5YwP8Aro3Sv5e/2j9aul8N3NvqFxcXM7bbae3MXliSIDCnAxjG f169a/pzwni6XhpRbVrQf5XP5y8RIup4sys7p1F+Fl+iPwv8Xa+0+p6naGwhWG3Y2iBiXyQMbiOz DPr2ri9Mimx1AAbLDbyR6V/nvxvU9pxDi5/32f23k0OTK6Ef7qO10hGlmihk3LEG5DHaBn07Cugh sTBduu9ZTGcb15yPY18PPc9ZL3Gf/9H+LaRZA8ZjQAEY2549MkVft7EbPKuVdgZPPhyf3I6dPfIr xqxMPhR0jeUbYrJHvj/1boV3bh05FdAv2S2tobZbWNV8vzoVQCJSV6hf84rAoqxB9REcrwNGTyYp SC0WOgFVNV+2w3dvbW04toVtzNdOqAyjnCqM8YPXIrKe5dPexaPkfY3iW5mZposSuR+9fPb3HH60 0TSSbH+zpCUjWEbONwAxk+571Bqf/9L+QG10mK6d/Nl/cJIHNsnHmZySG9qvXN35dwljD5gjCDCq C3tzXy9uh0Ed01xA8cbwOYy2JHI27famQwQnIiV5pWJH2fYWEgPBU1hKO8UaKHc9GtIY/J+zxwsN sItk85Sht8gZK/Tt1FSW3hi6t5EheWWe1x5oklADSZ6KcYzXNJWdgl8SO30VXtQ0ccK28ORHLLGp M8IbKAxge7A5PpX93n/BFrR44Pgt4NQRXskU+kJcRnUVxKtxBGI22N1ywUn8TX5f4j2eHoRfWa/J k1pcriurZ//T/jpulW9d47G3W3txEJJyWyxfOCOfWuebTryW5lt4XbEOJGlUCQY7r1x2rznoeXF2 gdU2lpLbWkcNzd2Ko/2uVYdu+/k2lRGVI4Xnse3esKwtZbKe51MOJJgxm3T7X4HG1VPWom+g4vRI zJ3SST7SnnPubJXHyqSewrViuhbxx+a4DnoCckZ6VmWV2jne8NrqbyRafIFma4iUMZAQTgDoSP61 HbRQzCIxGRrNZDhJE8stjIUsp5BHp70FwbvY/9T+NmSGIzq/mFUYbDk5QY9qnv7XSbzS2gazD3Nv NvgvLeUwOh75xy3fv3rxzJfC0VrRn+yedb4uNQCfZFlcENEqng8dSMdK0Eurq7eOMvtSFucfIrng HNaRavYgt74YLuL+0JP3R4DRP5jKM8gj3xVyazsZbeVpAGikUkZ4VRg11U3ZAZ18TPDbWNo0T2dr btA0MAG0ByCGPcdSPxqzpbXdpCwsVju7y3iCw28wByMEDBIIGcYzjIrupyTSQuVH/9X+M7xmPF80 UV9qdlZW8EMIlWygvhctaliBnGBgZxx614dcRveTyYEi3QkxIQnAz6j8a9Cg7qx5lSKVRHtvwFg+ xeN7Oa8e6W2CvbrcB0W0ilYDaJEY5YMQi5GcZ6dx+9vgCbSLLwv4P1eKQTB73yNQbzgiSMJI1aGM ZyrIHPX+8K/sf6OclLLcXSvrd/8ApMT+ZvH/APdV8HW9PwbP7Sv+CTniFL74eQXFtbiK1XKmKF/P ijbJjEmR1LYBP1r9C/2rrC31X4V66bqS48iKyklkhgUE5wAD+GTX86cdwlh/Eqbe6qI/p+mo4rw0 oW2lQ/Rn8PPxGhttJ8X+KNEe4R7mLVLmKA+SI9saMfLBbGC2Cp9a8a1W+mjtooy8CzRHO1XG/jqT X+lvDE3VyXC1Hu6cfyR/lTxLD2Wa4mkuk5L8Wf/W/PG38RpqN3FMluWgguDENw2byhKM2enrWkNR iu9auIJrlLWSO28+O1Kkvc54yG/X8K/2fSsrH+O0Zq+hiX5Wy1GCYJJKLiQCANAz75Ac7B13eo9c 12d9bg2k2o6jo1/aanrsq3CmS9V7FXRVV5Db7SVyAON2Ru5zV01ZWMpyRyEukXEMLIswRMiWd1bA uSP73H8/SuhsIoJIXik2SIsSmPy5fMkT24rYwcrqxZudCuiFuNJsLp7iZDEkpXzFtwBubd9R6e1Q RtBdSwWs+hzxmM/6SEXyjckH759Bx3FVD4kc89z/1/h2W40yzvopp/LkEceYrVkEkcR5HOO/t7Vm xmG4uI4oFSVLu58plVN6jcTkLjpiv9sD/FmXxMk1oTaW8DJJ9sgicQ2yE/cA74PbjtXLy3t3dyzA SmIXQ8uWXHCgn8/yoJOqkkstFhtI7bUH1A+ZHbNeeU7xHIwWIxuAU+o6VXkK3s7XcEsgAia2Ahc+ TMQ3+sCHkZwBVwTuJuyuJpto6Ti8miD/AGZtqXTkB4Sc/d+uO3oKYWk+2yfZ3ljWacyvJHjzceme /StTmlKx/9D4Whu5b17w3V75OkWtm00lu8ZZ/MUj59wHHAfg9AT1qnHDazwfbbfT/KMm3YJso8u0 YDN25xnpX+3kNz/EcEN9d+ejRLAtpGJZJUOxJMMBhc9fvDpWybpPsqLBFGs6lAEYFUxkB2z69fxN aGEtyk8RV5pbgzmMXAMUyZjRVAwc/U1G2tlfNt0T90VKIsh3GXjG4D2z+lXCVtGc7bb1I4beSzbI V0llXdFIOAPUfXGakkhhnuoZJy4eZdgaRyCmMbiPTNak3V7H/9H4zttPa+sYbiWCWKOzuwIpg2BJ sA249uuc+tW7jUUtrp7aRohC1t5ss8b5lViOBiv9yD/DCWjdzh453a4jme2kZHuB5QVd00/OOTXS anfRzSLHPD/qhgKw59sigluyuU7cJJ5srRoiWse9GyFQDpge/tUOnJPqcssN1LJaWSkzi3dSqTtx twOnTNNaM5Zs7CfUIfszw20cN1IsRtmhf5o1+Xgn0IzkVx0Md3DG81wUAJ2qrDcnTGOaHuZH/9L4 v0WOdZJA2TD5ZMCDoH9vSpDql4tzNDNiS0IELtGdzgcBiT9c8ewr/clbn+Dz0RJqFzBFpN/BdWss sD2xa1VuHAB+UjHXGM1yiWMklrG1zKi5b5TH8rxKMYz9f6VuYHRNaKsD3Fm/+jrGqTruCueBn5ep yf502W1N0kMDPiOIb0Cr8o6dffigiSXUzZ3cw5R0hubdgkbKP9YFJwT78Cr1jfvYrFqRbLvMYZhL /qpNu04J981UV7yMj//T+LI0uZ5J59yliN79COc9B/hTkmhgWaXf5cWFU+ZjLnjIH41/uwf4GTWh aF6zxhZ4FlWGI7WgiWJwOuSQP1NYonlmQl5Sy5yig7lQA0GQ15vOjgjK5ETEjA5Oeev+etTQLvkk td5MtwuUj6EAY4x9eaDnNCyikXT7oStC4S5VlAH79VUhsjv2/Sp7p45zeRJADZNKkllNICJkwMlc Z7E4/CtIWsZTd9D/1PjVJWdTG7MXGEUt1x6VDNbwJbmSN5zN5214jF8irjG7dn1PTH41/vAf8+/k TrLeWsFnqFsqoYZSqTIB94HIDe/19PaqcVyzvLLJIzyMd0rk5ZiaCJStoifTY7G6vlhu90yYMkkc XyyMozgE9hnAJpn2F8ed92JicRB9xQdh+FBkattZxmJZp1lkQExp5bbSnuf8Kb9h8y7EaQvIwXcu QeBxyf0rdKysZyk02j//1fi9oXYbAS5LfMoOF/KpBbxrKIpscAM38Q9q/wB6D/nobb3JoPs6uq32 Ws3f544xl48fdI/E/pU+oRWVzCssZ+zEMIYwhKyNjkfj79aBCWdmLyVzdMIraJD5SZ+Zzjv/APXr OvBAs0VoIpA8bFxP1jZeBgehBzx3oDY0XisZAkmmw3BMMYFwrjIL/wCz+tTy2s8+nrcKqRENtkiK 4mQA9Txj265oJbsro//W+KoZZobp41xPEi/MAuRg8ZwavRxpGuYxkKN23HH5V/vSld2P+d+Urasi Oo3Vy7byZBjAH90DsPQCnRW07KLh2wkTBmUkE+1bJJbGDd3ctoY5YppgRlpCmOnPsKrBSC5eXZtQ 7Uxw3+c0xDWghaKSRrliXhwAhHyNnk/ln9KY8CRJEsEssgZdzsybRn2wTn9KF5Eylyn/1/jvTVZP tDzhcMm1DJkH61CdsZbhTIp+VxyD9K/34P8AnPJogZVPmruHTd3qZXVFZV2oijDZAG7mgCSN5kil +yyY85dkoH8Q6kU2aGyEayyKisx2mBW5LYznB57HmgCSSVFSIopztDSE9vamCTEqO6bkzkxj5fMH cZ7f/XoA/9D5EuYxIFWNHWN+LhC33h6A/lVS10iFftE0paGCM/NMvO1ee3r1/Kv9+D/nKTSk2PSW zhkAhLvCwGJpE24/DmrMs8Usi7CmMbflUKG7U76JGikmRywxNPGAAJoMgMR8656jP4CpJQrGJZCi +Xx5gHLfWtroHJLcBLbKXxES7qU6kcjOCBVezt7uV44oxJvVi4Qn5h9f89qwJU11P//R+RbrdE0i uBk8N5YA5HrWYzb40jfBjVg2AOmCCPyr/fg/5zJSstDWNvHJJ5kKutu2Cu/Bl6dSf89KbcW8sZcP P5pONpU55PqaDNu+5Isf2aIeYcuxHPXknAFVI9sV0UkRnJXgDoM9DQI0jBKUNxtYIh2ggcA1GLq6 hiMUjBy4wBIMgjOeB2raC90ibsf/0vkhlk2lymxSMgmp4VYwRgnzJOkjMAhzz0Hpx+tf7/SV0f8A N+KQHRxJEsjxfKjn70Pfj9aqoBuzIx+nU1S1AuxwRzbypVSBwXbGPwq01sHit1n2b1HzyQjYPyzz QBk39vLGxDIWty3EpQqrjqMfzoXbHblkH3xlT6fhQB//0/kNJXSP5s5PLHGN1WFVhEZQh/efdLDk 9q/6AD/m/ItrphQCSTyRj5e1TshC46kdCe9AGa3mBiSSB3A6VfRpZ7R44kJ2qSccYx1NVGN9wK8c cscTRtyWHccZpY7eKTA+ZZkyDuPDY9OK2A//1Pk6BEUOr4GM545J7Uzzky0cy8AZQ9xiv+gg/wCb 8YJN+EIJiQ5UDp+NRXFq0lueu8SiRPQAHkGgBYcy/KCEYcc8D8qW5QxjY6ZGeeKAJ4baO4ASOVYS ANzHqBnmpJgkTiJD8nQOTlj+NA4vlZ//1fkD7PLPIVOQVOM/TNJLFslhhkk2xbvnwOBX/QQf84kN iaeNfN2xBdkYwGQY3e5NMS3QMCZeT1jzzQWNWNv9IxEQqnGQOPzpokExjiZVQRrsIA+Yn1zQBaKx W7whwCu/5X2gvz1pLh4jOIoQ7Sld4+XAwPf+lBHMoydz/9b5C850Ikc/KzbNg7YqQyRAFgOW4HFf 9BB/zgPccm2OGQt9VB+9/nio4njVWl3EEthU25V/8DQIkmBicSDcu5Axjbr06j61HBLHO3nRfO8b H7RG6EFACBn6cigCzcEyIVkIZmO5MADaD2/r+NVIY5YtxKSRADKSMuEkHqvrQB//1/j1Lh2L+Y+S TwDxWokzvEEXhBycDGTX/QQf835V2IpYggYPP96rCM4G5P3iDkoe9ADXuNi+b8qljjYBwueAMfjV R5S0bK6lcHO8DhqAESQsgXaGK8gkYqJrlIHJlALdgBQB/9D5Nt2zvLeWIGXehYfvA3satW9xC0TR sShJILtwfTNf9BB/zflafy3MaxszNHkMxb5T+H4U+ytJTI7nBjCEEY9eAaCeaOwYETbMZGTyRzVx hG8IiTknr3qOdBzxM6aLywInUHcOOOBWccpME5A6qT0oU7uzKP/R+VYvNtYjOskOyRdpDKJNpzjn P0qODbIzOyi4REKSJEMfMV+XH44OK/6CD/m/MRMiUo4ZcnhWBBFX5BJCYVEjIMEME43A561EpK1g LFpfPZfaAI4ZBJGUzJHuYZwOPy4+tQi7a6PG2NYjux0zURSbswHpdSJKrxBSVOcuocD8DVkuY4Wc FWY9R6fSqmkloB//0vlSHbJGPkBb+In7tQiGN/Od2IKDC46Gv+gA/wCb8q+bFvVOdyj5T0HtUjOq rtkwzN90gYxVxTsgIWjjaNdpIbd2H6VGMmYugCiMbSFbj/PFagaNofvg/NE3JHPvTZg0t4ltFt2u mY0ZsdCMkn2oA//T+UJbWOF5IpNssY43KcgkdxVR/JQB3lWL94qAkZOCcHpX/QQf834mqW9rcPEs LzfZlk3nY3lvJjpnHr6VFGrIwk4C/wB3v7UAXLm1lEaOyMolGUyMBh04/I1nx+ZFMYWXHOCMYxUu SQGhHO8Ac+Xx90kjO3ioEuUYl1Hzg9RxisQP/9T49w8xYSZ2s2QfT2qxKXtWhkjiQxqMNkHJ7AjH ev8AoAP+b8ikfdJulZvmG5Rgn0pYzE+VkTncNshzlO1ACqjKJ0WaKVPvxOYuQf8Ae649vY05WeLb tdWyuWK8YNNK7sW5O1gBaVGuHCssR+ZX6N+Hevy9/bTmeS8W3s9N+zXMTQoUtxvjV1RPNYDOBnd0 z3r4HxPVuCcw/wADP3j6OmviTg4+v5o//9X+MjULKWKQtPvOTnytuHXHUEevtXS6Fp9nqk1naolo GllX5Lz93EenEnfHY1+jYh3qyPkqSskcnqsE0El3JPHaQRrfPBBBasTGqA4GMkn15HFZQCKsQEWQ Od4JJI9K5ptrRHWopakcrGWfcAoCDCxueg71IyG4cSbVaMfKyBcKayeqZrT3NCIwbyx2qYotiofl Cn2FNkZ5wpyEwcKf71c5qf/W/it8vz8lhtcHb1/nT5Alqwj3bH2BmcfMv0r6yaPHNBJ4JLV8gyLj AA4w3rVGEKhYea+1udp4C1mBTuAokY87exp6tLFCgDbl37uRkn2+lJrSwEluY5Jg0yuq79u3oD9P rW017i2dIUwQ+0x7grAdM1gB/9f+LwzMuBAWRiv7wKetMt5Tkxl/LHPzP0r6A8hK+iKpuYXcqvmO 6vtYspUduR61eSU7Sj9Mfu2z1+tA+SQ+KWSQeUEUdsrzntzUkkDS24gDqzQtvMbMA3PpQJqzsJYm IJLuYIygptK53EVWkkRX3RgPnqBRYR//0P4wkihkGEO1idzKTVwrDgrcMu5uFBPavf5V2PIbb3IW 08yD5GQxZ4BPzDFUHjh3sY1JRGC5P8WPSlyK9xEk0Fo6Hc0kauMBQM4NY0diVlfZM6RbPlRlzuP1 p2XUCeCKKFQWHKt+J96guGcbTGZQisWI6Kxpgf/R/irtluLkq6t85+Vkb7pFa01rPYtCzt8rDLJ2 OfSvoDxxk8JgVZy5TIyIxwMe9UUlM5fOARzuxjisp72AmWRMGF9249yPlIqookhkaRHG0nYxPJA9 qgd3axKZ36NIJEXJjTsD3P6CokBMhRnKF/mDY4WgWx//0v4wzGCizNIzbRsyBnIHGDULMqmBHjVx 5m5cHcVB45/wr2DzyWEQfaRHKCUD5QnICmuoitNMCOZVEjbcjDYdCO4NXTWoGE00WGglhL5Y8H7u KrLbyO7SBQsMIJlAXKj0rUiexDCY4piXd1IUmFlPzKTx09Oaqy3CQsqR/vldiXzw1Bkf/9P+LO6u 2JUxIE/dBCMcj8adZQtcoZHZV8s45OD9a+gPHKt7BiQyIvyKu5mA+Un2/SnRXUkjCJWB3JzgfMce 9BlPctRzx20RlQIAnzc/eyO+KYL+S4dGjcgAbmBUAP8AQ0Dg+haeaFo0V1Te7ZaRjhlHpSx28Tnb ESQuWiZvvUGh/9T+MH7SIAto7HzcGQIowMZxmpm3GPIaNlYfd35lX0OK9qTuzxyusLThVQHzV5LH kH0pr6WAzzvJIhC42gZBP+e1SUpNDJYp2WFBLu8v7iKMFDmnBJcfLN8wcEhuhNAnJvctOUIkgk24 ABfjk+mKpC3nV2YBIrdfm3bf3gA6EUCWmx//1f4xcRvAtwZyZhJsVFXG4D1pQftSLtdWEL7ZFJ6d OK9g8tT7ivJEh2pCAe5UdKntFkaBg4DAMQrAds5oHzroI6QqFuSwWRCULYyT7fpWTJfurt5aLgnG 4dxQWnfY0LQyqqsu2RHyzjGCv0FW3lto4xvUGQklcL0Pv6UAf//W/jK+1ebJGrjayj90H+VPzp8y Q3EG+VkUryrA/KcZr2DzJRvqZNtJvlQqGeMN8zAYBwcYrWvLOymiO47Xb7rocbSKDNqzsYdtiFtq PznafeoptPkuJjNvcy5wpA4ArKb1sI2Utfs8YhZnWQjmRq1YNSjitUsbi2hO1sGdUxMxzxhv89ag pRb0P//X/jpsYVuBLHAB8/yeV/E3tVW8sLjT8edFJAuPlDrtB+legeZGLSZmNa213DIJ7goSflUE I30H+e9ZY/0Hy4cx+YxLAg5bA45oHJbF6GQXnmFGVHBxKqrtFRtAROQMgsRt9OOKCiafT440kuHD SkJyq5wnqcCsSDzJ5o5LYboGjLF8FT7Yo9SJSa0R/9D+N/SVhZbeW4BQA52uMnIPer+q3NrGkmQ2 wg5ZR0HtXrS+E8me9jiIvLZJXQ7lL/LuOJFz7VSjtm+0khygPIbrn9aok0oVktlaV5cxg4wF+b0q SGaOeZ0UblI5BFAW6Fe5014AWToTuA759aoRW1wC0zN8ydI+lQo2i0FraH//0f4uhdKmwOZGdhyz Kdqe2akvWiFq0hw+7AUoN2w+v869A8chhiklEa2y75ZRgORgcdfpVOYjeokYxsjbTxyTQBajWcpv lHzJ/GoyMZ4NNW4t3cx/MWBHzbeho8jaHwlpFmLrcSMI40fAJOCferU0Nuqs8U4aSTJYZGT+FZSk 72JcNdD/0v4q445Gkl3lGRGHlqRjaPf1qFmkLtGqhUQ5JP8AFXdeyuzzeXbyI1donPUBz1xiumSB Y40ZmKkqC2Txmkpoma6kUk5W0u3fMmxQEEZGW/D86xpftLuj291IxjUbIt2BHzn5fTrVkJXdisbS 7j/eKjEM2TkFuepz+tL9ql2ENCVKDC7e/uKiUrLQ3Stoj//T/iwhhjVRNE2CAGLA5wferty0HkyG Zi7BAytGgbBOCM10Hn2RixwtINzoqoxxEDwPrXaaQGjMUGwJFGAZj25/ioAueIbBFghurWXMkEnm TqxASROmB3yK4xrj7QpYqFTPBU5zWMr31Naa0Mq5iQ/ceRj/AA4+6PwqmsQgkUviQ4+Veo/GpLP/ 1P4tlihiEUmcoYg7J02kjkYqdriFoTsbYAdoIODQc5niR5D9kLoFhJYkYcv04BrTGoNHE0JCrEq8 nbgZ6CgBkJcyQgyLJFktgJhjnsatX0dq7b3gIdk2jDfL7EUAZf2ae4Rirg9FQOc7QOw9KglsL42U hR4zIMqyM2GX061MpcqKi2nof//V/io0nS5F2rM5+0PgbM/Ip9KsXscFurhS3mA4dewx6Vn7TyMG 22UmKvCjIW84n5Rtw2fSrD3r6fbtbL5RnljKSFl3mMkcke9W5JK7CO6MKQsRBAW83zV3M4G0g/Tt WzZXV1CfszIZjt/1oPIUDqahyTVkb26DY7xHlmRkD4Ow5JBQ1NdQRoobaokwCCOC3HrU83u8ouVb WP/W/iOiNw0oQkDc+Aw5AHoPSti3WW0uC9xbRyxKA2ZchHGenHfisZJ7hbuW3Rbi6muLREhjX975 APyrnsM1iXk7s7FQFkU5weM4qQS6Iht5Ee3UtcoZBL8yZ5PqT/Kry+Z9nWeIlCsvyb/ukDIP4UFO LRDE3mlhNICsjFg/3lH+6aux2pEBniYyI4IJPD5HHSgk/9f+KqwuzaJNIQznbhITjaGB6/l/Ks25 nF/KkkxJCSZVUT5Y8+ornNYbEVwkFoTGmZPMz+8zlUJqDTJHzcJKGEbJs81T19v60Fmy968oURMx KoIgZDjaBwKooquxnuZhhD5caLgCQ59KG0twJJJJba5RFQfZHjxIQ3zA+hWmTRwzAjOFByu3qprK buB//9D+JtBAoUF5GkGAv/PMgDnJ9avSLEYlkiISWT5TJtyVx6V550GaHxeKCJRASE3hc7uOcjvT 5o0bcFkYFTnOMAigCYSlh9kjU/OgZpCv6A0AR2kbJKOScqD1Y+1AFXyWulM/lxwEHHlKfTofxrPj ebyAGc4Dd/4uT1oA/9H+IRLKRJRvKMoAkjaNw27Pbjp9K1A8ckShg6pghgRtPHpXnnVFXdmTPcy/ ZhbrHGEcbfMkJZ419R+lZ1yUVVgaYzhgFwOGJ9xQapKIrXHlQBIVZ5QwDZHIFKrKpZmwA6/Kko5J Gc7qqOkkMtRlmi3sxLfd3Y+QY7CpRNA8UilXEsONpKYjlHfmtrFxSvZn/9L+KKyW2CyNGFQEZUZ+ Y+vNQ2x/fkMJApbgMDXOegbEq2842szAxjaGYEFeP8/lVdZIpIUnhORbsYWyNvCnGffvWlPqRPax ZivxblPJVJ1biVZFP7seg9c1Ukh8y5N9blYo0+YKikFWrQyNOxug1xbwSARG5LbJCuMlAW/pX6gf sp6dqkel6NqE06mZoEud8UWRCSu5N575DR/TNfq3glTlPjvDOPR/hdH4z44VIQ4NqqXy9bP+vU// 05v+Cc3hTUfEHxtt7/UTNBM1tBF5kQ3AmNi7oNwBG9z0PoOa/td0iL7H4MtxLFIGbSFUwMcOuIx8 vt06V/RP0j6jnxth6b2UV+Z+UfRzpKl4dzqrrJ/kfyPf8FSbnTPEHxZDiS8sPI1B/tItJhBPb28b NlGyeQzqpIHbvX87P7RGo6Zb2+sTCM30UkMlrZzrGS5KLgOFPTA7cV/W/hxF0vC+jKXSl+h/LnGD VbxgdP8A6ef+3P8AQ/CnXNS0u9utUsorJAtpeG5j1Hy/Lu5WbO5G5wRnBOeciuSR2t98u1lEnCED Iz2r/N7iOXPmldvX3n+Z/dWEio4WmkrKx0ejpdSReZIyuwbLJ0KjtXdaVF5xdRsE5X5FcgKPrXyt RM7YtKGp/9T+MBY54CTMImZT99eQPUVa+3xqiB3Chm2x45wa8WtuTD4UaNhOYpFW/klaOTcFdEAI PO3PYdq15IkN1bNLe/LGQsRfmNM8YX+tcbb2KNeKSNroRB/lT70sZHUelD2M0l3HqlyhuILcqJIB kvIiEnH0PoKlvuXDSQy3so9Tu1jhuRbTZMsKLgEDPyoBz0z+lad3YtZuYmYyIgB8xgF3HHOf1pX1 san/1f5IrCKOJxM0ZVZFz5qLkNiqE93Cs26NZYJUm3eesWMYORgkY7V8udiV2jpNNaDxFqE4N/aj 7JB9ovE1GUQednptYn5nJzx7dqrzXEEV5NNYxR2ZhX5UjYyA4GMjPrWMviaNCw+pXE9oFuopLdhc LNFcB8C4A5K46jHcGuu0nVNXvE/0u4iWIAfYDPL80gAxsAxwcg9a56itJCdt2eoeGtK1Ca8sDI8V vJdahbCWKE+bLOgmU7I+PvMOg96/0H/+CWfhxNE+EHhSC1V7i3s7JL2I3UflyxvKiB1UjrjMnPci vyDxGqf7Xg6P95s58RHmnTa6H//W/jg0+WQPfPd2T2XmXjJawtLuZY/9r3JzxU9tNbWc91CZizEq z7IyEYMMgZ9R/SvKbdjzVH3CnqOow3F6hgmnWSxi8+1iiPKsBjJH4msxGklS1nt4X2sSshmkzg/x fr27ZqXuOyRB5UkF2N7NiRvkhVPkz+H41duXtnEkwijSWOEqqsuJEYd8HnkikMrR3E17pYmlmnKW jF4kkQxJu6cA9v8ACjTvtU1vvkiYBx5jhV2qvPUD8qCofEj/1/41niXy/v7lJwCvOCOKrWZ+yyfv XLwkgYY/rXjmF7Kx1dvYOpWVLhY7dEaVY1wfmPILenT171Cdj3UyKsBgeAkyeZtZJARnjpyM1UU7 iMOO3ka9a2jS1Kohlknkl2zFR0UDocfnzXU2cltBZ5upYbhHYxCMLvVckjn6V009wMPyLS11CcQG YxOo2zyvtU+yrVl5J9PliOmAymSbfILmUoEDddp5/Ae9dkNkB//Q/juvb1ZLgTX9uby2lHl3ECt5 asuOR9T614XrEttDcSzWoMImkaNVDZ28nAJ9RyD9K7MPt/Xc4qy/fJHReBdW+xa3oEkoa58vxBZX Eka8vtS4j8wY/iymRg+1f0J/CrTluPC+mLo9oLrSJtRN35kkPmrCzxxSybmPAyG4/wB0nsa/r36O FSKljKb30/Jn8y/SJXLQwUv73+R/XN/wR41AaV4Z03SrC6LW1xHItxAJA9omAyhIz6KUwB2r9rfj xpyXPw08QRXm5zcaRIfKQfKcxsVJPbaQPzr8O8V06XiNVlaz5/1aP6V4ZSqeGGEjulRS/C5/Cf8A G+3nsvjH8U9DaMTvZ+KTeW8QdZHjW4giICsOxABx2yfU18z3NiI7u6MMTLGZOYyTKynock+9f6Nc Gyc+HcDJ/wDPqH/pKP8ALDi9/wDC5i7f8/J/+lM//9H4K0vR/Msd92Y0nSPEs8XEW89CM9u9Edtd 2SNC0mmPfImYLmeIXPmq/wDCyhsg4GccEflX+0Lsf42ptvyOqTWv7K022dbe2+2xLiNzbh1tmHG9 CQefSsp7u51S4a7u3Nx9oGGmcBC746KAMEgdcetVBK9+pE272Mu4sbmKMOhMkW4uytkMi+/+e9VI Ga2lBjYJ5qFxhCVGOxPrzxWpBLbeJNcN7fXOoXUm0xqtjbx4jtf3eACw75Gc/SrN5qz+J2Mkke2a O1Fs4tHKqSpBIIz1OKqG5lPc/9L86GtNQ+0p5VrI8USmSfzAf3KKOjD8q2vD5kGoXN3YxvZSGMSi YAmGF0wAxjOcZHpz0r/bA/xdcUy01zHdRNp08UPkpvkWbkTrLyQQfQ+nTmkQX9u9tFc20Fzay2rR 2z2UK289oQTkyAZMg4Jz2yauMU1qZyVnYjGi3djlBLG9tcn7RDvOJlB6ZX8/yq1ZraIsqmZoZ1cO HkfyocKDnr1zgDitTnk7uxoL4d8/NxJN9mhuG8z7Ry0RJ/wrJvrK70ySJre+tpJo3DJJA29GAPXr wfag55fEz//T+INH/wBLhk0kyxRS3qnLFgHx/Fz/ADqjqN1cSyXVtC8Qk0+5SwubUDEkfG4SAem0 jJ9xX+3sY21P8Q+dple2mie9ZL6B5Fs99vbSQFlhl3xn95nj7rqhwQc0TwS6hPHC8vkNFHstXhAi YY5O49Dn/DrVmTdkbxL3qizhDTx+UsbyTYWKORSMsTzuHHtzWZfwXOn3cEtxDYZgjDWrW6pJDMp4 3N1Gcr0PPFVGNznbtuUItTuftglvXhEAcOq9hk9PT8BTppY5Y2uZY3b7IC0Kj5n2k8nr9K1tpYzu ue5//9T4uX7RLpyNb3a20/kmcQN82/gAcfiOOnIrmja6hc3JtS3mXTpvBb5RL3+n4V/uQf4WTelj f8NxC2+1z3G+G70/NxLFdR70KZVBhSOmW6e/1rLeya7kvdQjmuJZJH2qGObeIcYGB0OMCgyvpYs6 Wtsh8q7H2idW3IkgG0Y6HHQ+30rb1e1nsoLeee3eCPUAfs+4bPlGMsPbkY+tBjJ3ZjQT2lgriCIk suZZCfmZ/wCJvx/pUr3f2mxNtBb+ezviQswBiUEHcP1FBm5KzP/V+KIZLhIAhKQR25LPK0mI1Xj5 mOOPpzVSWeRgJ7UieEzeWZ4xmJyMbsEj6e/Nf7kJX0P8GLsvWFvJ9oimEUk1q06fajdMXijBxuwS MAdSFrT1yBEXdHYNHFKpaBV+USZ9M9RzW6VlYym9dDPuLSdTYxCCSNYkMN2VcBVDnkk9OOlWdTVL Z7eG1Z0RECZJ5kGBg/zpkNt7mfFpcly7LAUIPGXOOT2FQC0kWWXT5JIf9GbzHjaQbVb65xzxVwWt yHJJ2P/W+IbiOVJ444bhowoDM8TfKfY+tX3h0+eMwxzm8kGFeKWMI27g5I6Y7iv92D/AqbT2IXGo QIrxq0cU4e2Zl4OMAMM/Q4/GrGjaQ0djdW4ELJAqSzC4J+1FC6qWVsf7XTNBlJpIu3Wh2VjD9qtL qaSMgERSRZKs3Ubs9M+1ZyIYmiuZQI258mXO1lx1ANBiWoVtZpfMtYfKusK0oRiVlHQtg+uOnSpj Bp015Jtnn8qN8Jltp68jb0/P0pp2MpRtsf/X+RtWtEiaILGI18kMjkj96p6N/OsvS4vPeZZrrahX bgthOPWv9307o/597FZYXto7u03ObGWfzsoOUfBGRn8as7beWMeQBAUj2FmQfPjuw7n3pmMlZj9O hige4u0uHLpalQIcLksQMNnnHXpUoiH2WN47rEsjcxFQVTn1z/TvQZyvui+l88FtJAqpK27GByMC q+nW+o3skv2ZnuJfLZmWHOVXuPoM/Sugybu7n//Q+JpFkVmVQ5ZZcOobBTB5/KrtqZFuZPMeMxtE Q/mjJJ7EE1/vQf8APOQxThpLiOIAssgAc87cDOMdOeK1ZFintzNJsiHn79iD5YmPYDsOaAMd0uIj KfM3Gdxgg8KAfTPXirUdneXO0qudzf66XKpxwecUET2J2iuLQSRNKLdg2HZG+U++RWnZ3X2qZB5h RNnlspOFbjGT9euaDLyP/9H5BvktbK3dYmBuo7xV8zlo7hGYKQPTHJ5/pzIzW6zbkVnRvkH8PXjO K/3pjuf87MviIJrdLJwYAuX+9zkHJzxS74pUy7lTuwY+m7FbmEm72H28UVwmURYHjm/dxD5xKD6D /PWopttyJAkTRshKHeMZxxQCnayKaWyx4jQbcZLA9yc5q9bQtJhHlUKpwGbonP8An862ilZMUndn /9L4+vLZwzJLNFOhTYptWOORzz1/+uKpx2U0MUZXM0MCgSuxy3oM/wAq/wB+D/nPJ45593yRKEz0 PIp0tq80ZC8SO2Ag7n2oAm0uBoEPmhl2ggq/UEdqiuIg08cvykK/TvjPagNhLyaSO5E0Kr/Z5k8t oFXMkYyMHcenp+Bq+p+2Fbe3MaSbdyeYdo4HQc9aDBs//9P5ItpLdZXjv5JURVIcw43K2OCQe2et QSPFFI8BmEsecow4DjtkV/vwf845b22TImxC0hyJEIwgHr/Olu7JYhDPAF+YY8scHgdAKAWmxS3R uCTJsmU7m38Fsc4pHnFyRtiVRgKME8Ed/wDPrVJ73G3fcljkt4dokhLzDjeGwi8elRSzt+8yu0s2 VYZ3Y/z/ACqRH//U+OrQfa/NQXMcbQ4z5xI3cZx+tT20JjjuZHFvJIyGKNXB/d5/iA9Riv8Afg/5 xy/bZMK+dKFCDaWK7VPqf/1UhZWjaX7PKiRTDypWA8u4AHJGD68c+lAeQNPujeQKpQDcXY4RKy45 zK6SuCCwBRj6dqCHO2iNcyzGMbTlR1Uck/h/npWcdsrmQEnb68g1pCX2WZvV3P/V+TVnjnjWJmaN 17YBHXpSKVS4HzZwvyp9O/61/v8ASbS0P+b8bLNK7Dyhtx97j7xqurkT4bLEH5gOR9KIbAWvLQ3G 7DKjH5FBOPpikubh45EQ5A3bR3AqgGzy/aN9uXZjAcDacoadGBEhjkVnGzGOmD6/59aAP//W+TFe SRSojQxq23d6df8ACpBG8WCrB89FBr/oAP8Am/KUgkLLuBQs4XcSQMe9XJ4J2nWAyhQh2ZyTEoz1 B9OpoAcY1i89FEczlfLjZmKqPmGWH4ZqKXzpZLK3V1VLSNhcGNQvnknqSOvFAFicIBuiBZUOTnri nymxmbzbOVDtURmIBxMGCjJORjk56GtedAf/1/k4QvMxWPJkxuCjqcVZjVzbsxiUySJ5aySL8oAO CR+WM1/0D3Wx/wA35UhtEEXmeaDIrlXiHQDjB/z6UshuGdUhC8OA28HG3Iz+maYFK8Pk6k8MShVR gcK+8cjP+fpV0rM53yfMZOBu6DtQBXkhWJxh/n9m6VJ5ZlibDEsv6UAf/9D5JtZCnyE8jqcYqvdJ PLMqsg8kgsr9CT0xX/QQf84CbWxE63KIQidDtBbio1Q43FmEithh0qOf3rFxl0ZpRzsEZQx24y2e d9VVMFxcEnKEJ8ixru3Ecc/XGaOdX8i9BTbOd8snWI8AnJA+lTBF8qFs+ZK+SWQ5OAcAY/CrJlC+ qP/R+RIjauhwrK4JGHGR6U7akRDEAjHp8or/AKCD/m/tbQb+7lkwpPC5wR8pqEP5e9HQMvVcdR9K AGLI00yjJZiPXJUDirEtqtu0bD5mPD44bB/yKAGzJNuUQEqFYFg3OR3H9KsRNJKfKlbYqg+XGxJR foPegD//0vkZtPDPHvOTu58vjFLfw3mlyXFr5qOnmDy22YbaQDiv+gg/5vyotpcs6SSJKiuoZQwK B89/pWzb3MVvMYZIxtKeXKyAO3fp29aAIw1ikLedG7SPJuVwcAAdARVc+bMrs8JSI8ROeA1AEMUT EZxwnJ/Cqclu0ziVACVbjPpnrQB//9P5Re2iEcifao5TDtKsisnmZHOAfSoVtRKjbGAYDPzNjOK/ 6CD/AJvJtrYrxwBXUlm2qfmA71funU28clvI8c6tt2DhCO+eec0GRTxKQZZhh92FC88UlzeLamAE EGU7VJHepcEwJXdXIZ1YyKDls8EU9LcTsJWBIUZAqOR3sXGVtGf/1PkVwsiy28qYiY/KrdODkVft TcWoVbaVGiLCZ4xGCQyjAJJ/+uK/6BHfX+ux/wA33Mk7FWVBLOZHHzZ3DjkmqzvIpYuA2Dx6jFZj L1vcJPGbeVIuuQ/ljzB+PXv3qK4tUt8yLgjuKAGaZAsqyGTcpB+UD7uKW5R1DohI9Dind7Af/9X5 G23E8RhtYJ5FhUG6dQSEycbiew5H50uTHH5bY49epr/oAP8Am/LFuovALcRRpsy4lK7Xb2z/AEqo 9u322OEZ3YOARwQOP6j862jayQE7ReVvU8Ed/SsiOGVHcYO1zlWxwaoC8N0SDBwwPK0qyPHmQjLH 5QR1T2/SgD//1vkhrtVjjiEZLljufOeO38v1qn5TtO3mKdqclcda/wCgg/5vySJijD5SVJ4z0qy6 +fcmbcF2vvaID5QRzgUmk9GAXNw8/wC7MhAU5UA/Kn0FZUyztKXBZtzfO+Tk/j61k4tAXxGuzaC5 zzyxOaSK3MjSom1AqlueC2PT6+lSB//X+RFNyIDCAhkRt6Fl5+h/KtEr9pijWTCuVyd3OD3r/oAP +b8pZijby5+ZDlYkHHNNMUgkIKqoAwUI+bOaBpN7ETxq37vJBBzgHBAp1lElybxUfBg4KsMMcY6f mKL2ZU1YcF822kcfKvMILcbG6c/Tr+Fflp+2VLdr/aRhvIxNDNbxJfgiNUcsmFPsVVlPuK+B8UJf 8YRmD/uM/dvo5prxLwh//9D+MK7v7m6uXa4cyO2d04Odx7nP61QuL42hie3aSOeM7vNV+T2r9ErP 97L1PlaSso/Iga4nvQJZiWSPov1xmr/nQQwnajNHIoXaRkqfWuWbuzqtYzY0trl40OVYsV80nrnt WqIxbLLDgPGf9W6DpWLlaRpTXUyQreZKXY7OqHGCaek7KgJViYmJRG+6DWZof//R/iklMs3zx4Dy fM0QONvtjNOR1cHzEwUGOtfWT6Hjli0ljWQKSFR+Avb603UY/LlYgsOMBRwKhICikrS7UcBMDDjO a1II7QRyo08gZcNGWHC+uaQFmRE2IYn3BRuYL9/8KZuz5oES/cyjl8MCPXtUyjcD/9L+LFZ2jjR8 IHY7Ao5/Gpp0ZtjFcAjORwGr6JxaPJi1HczI3Mk/lrFyrYkBGOPXNdGbWJYoXJAkAO2LPDj3qTRS TdiK1/d7mPytnIA71duxHcETGMLMqgSFAFH4+9A3szJO3ZKikcD7uPmH+cVBbw7YywPzEnIbqffF Bgf/0/4uFPlE+YDkjJIOOKzHug77jncnEee1fQHmKCsi5HeSSoLeLjHLPn5/T/P0qx5Mq4UZ245w e9ApRVroiCsJMO7+WFwQ3P41ajtC8DHexwS8Z4wR6UGZjOsqSrJvKjcMqeQta8IgmikWXMi4LAoP mBA4x+lA+lj/1P4sUH2f94u4YO0DuasNfvcSrEd3lpggt83Ir6A8cqXTPLIzM7kAYxnKgD2qWNFd fmwgdeGxhnxWc11AqOtxJOqRK3lKCXkzkgjp+dWoE8pwXUSpID5iN0BrMuy5AZIW2sFbKsQwIwB6 VGsc8k+wgNvH7o9v88UEH//V/jAmdLWKLazCRV2vCR8g/GqwnEjBggiUcs33j74r2DzU0ojhC8rJ N56LAJdm5mG9j7jrUcxkE52OQAmJG52sO1VF2Y20tBI78bTGNz/3XI9K6LTfGgtorixksbeRHgED MYFGcA9D6+9bGUnd2OaREZnuWyC7EqueB7VTTatw0jNwOhz0PpR5En//1v4vIdPFzEZnlz8+FjXu O/NOMNvp2AS8xf5sZ5X2r6A8ZuxX1G4jmjWKBfKjVcEAc1lwRKB5kMjrLFgbSOGHfNRJtbETta5c AWZhldhd9rbuFz3q08aWob5QWTIGwZzj0/8ArVndkJ22H2KRXpKTxAOF3HqrEehFXm8m3jb7Lksp 27HUqI8emetXFSSNYu6P/9f+MJnjuoNxEYm+6TjBGPeq0cDyuWXeojUBmXkGvYPHNWDUI7EeWI1n diNzMDkY4xTvtk8hYyoqK3RQOlACxC2lJeUmPY2G24GcVmztsd5QN4zkN0GBQAzMlxmaMKNqgbc8 tikVriVXWQlEHGSfvY7UAf/Q/izglZZJEQR7FXO48j8Pc1cSaIbCiBU6lOgY98mvYPHKsTSXVw8g BiydpTdlRirK3DWkjQpISm7dz83PegCOe8luCYAECu2AwHGari1aF9kwKoORJj7x7YoNYPSxZ+0R afaySzvK5B+QQruGTwN3tUj7nVZPvI6ZIHbPvQWf/9H+LGNbiaVY5GAQnbH5j4CgVcZAImG3bsOA 5bhq9g88oLMbRdiSeY5yQPu7AantpGnhMcpYMThWXjHvUydkTKN0QwWdwk+WdGIOeehHQfjW1DtX AQ4C8sw6E1iRyMpXEzuzszO204UjvirEsyyJA/lAhBv2ZyQf/rUm7I1P/9L+Mg6qsMOYZWjuVO4F Rt6ds/561G+pajrEUi3c80roAYlLZZvbP4CupybPPIrlhB5aOQ0gQMRjhT6VmTZMkTEKSe+eQKuD 01FYvWl4lqGjKxqztvMg6n2NWI3nupUufPWOGIEohTPnntzVmcm1J2LkU2oGfzt8aW/8SkZ3Dvn/ AOtWjc6tZJBGv2SOKQfIZIVwrD3FBL1dz//T/jehubWZRmP92h3tjjBHII/Ksq9m819sbv5Ljowx j2r0bu1jxzIFrGkhZN7yhsbeij60y6jO6OQMV8o7mTJA/wDr/T2raPwobVnYum7injSJEbzFQ7gB ndj0pllGYMXOHUnmRCcgex+lPYRPdamtwUiQ4CnczAY3EdAKquzyAMnyBOSTwDWSm1uB/9T+LOVH kRAy4XOWx1OKsW+AksG8R7lLL5g+VsdvrXoHjkVvKhbybt5EhiyVMKZz7Gqckc12w+zRlw0mzc42 lR6/pQBehguVha2maVWWUAk/dxxwDVPiC5libl432gDBH1zWDd2b7LQvXEkpUJtyirukPVRVdGSI pKI1kkQZR35Yeo+lIib2aP/V/i4tbiF1uXktzkfd2kiMdenen2T6XPHvkn2EyFFAG9mZc5XH4V03 PPWqK0t7ZEm3MWCjZLlNuBWhAY5YZURCykYSQtk/l+VIT2ZXNuyjcR94bAPXHrVVrXyblbiF2Vtg WRM/IfXFUpNKxMUrmudU06CNIbpHJdhtMZO5v9k+nTrWJqF3bpO8MSlYgA23dvZAemTSvpYs/9b+ KQzT28NxJB5ZVwESN32u557fhUUE1zO4iIMUbANKgJ2uR0P+ema6DzzoJbWFrWMSuxPVYwcAHpzU KySWkhd2YgKAo6qPrQBdkvnntgQxJXKyhzy+c4x7Adqy7IwKxjCDyix8w7dvPfA+tKyN47ImuFiE higRWjKcHGSDXNyPtn2xgMythweR9axas7DP/9f+KeJZYxLIxyFTJVjke2KljUQQj7XE6PdJuQEY +U9GxQc5nweVFL94pEoJ38t9B+Nan2mB4ohCZZXkyXzHwmOnP+cUAZP2idNR2NM8dq0fRU5yPSrK 3MlxHJF9o2MFJiZzwCKAILW7njKxpJuJHzNjAXHpWskjuXkO8g4MixKWHHGR3rF6q5ULJ6n/0P4v Le+sIpCkyXS3DR77V2X5GboQ3ocZrB1OV5pljRJsyH5pUGFX8a5zB26BA3noFy6CN8KwG08d6sJa pM7MzBvKXcc9ce9BrGPKSQwJNKkMQQKFO6RuGY+mafJOlm4QA+djYGh5K0FGPdwvBM9yylVlUZWM H8yPWrENyJdgZt6D5VLHAXtzQbRSSP/R/ichV4HkLjKiTMQHOcd/p0rVluReKFlAEuQqR42oPx6D p+tYNtnQZqylZWh2HYDhvmxtx/8AqqB7eGeKSS7Z428wrFJF8wx23Z6UgKljZx+YGLK20HDbsA1b fdsZBIfLJwI/4aBSXusnt7cCGCLJZY3LbSOFLelaj28mngKyDJIKoX/1QboT/h70GB//0v4k9Rt5 bc/vJixdiZFQ5QDtjFULG4lBnii+aOUeVJlcnAIP4VzlwaWgy7d8raxkhtwBDDqKtyr5ca+Wzpk8 qp4Wg1LMcIWAxMzmTG8sw25zVBHeOWOBkCqTgSA5H1pNXVgNGSGYPuxujwCzE9T0wKikyj+UkbM8 gBbauQg9TWUo8oH/0/4kJr1LSeKNYfMjjALFjgN7VCt1KyiVnEcZfcsSjIGa886BbqS/mdJbeOMR KR8pO1mHc4plxJJeIIAywBQPu8FiPWgS2LlrNOqJbXEoUoCI/wDa9h+tS3ETXTwBh+6XhpCfmj9y KBllks4FLSn7y4KKxO7FZpa280o8ZMYTfGd/B9jQB//U/iPuklhWO5gizESFXZk4P0p11G7JGxLO zkBo842+teedKdndFsROZBE6AhAArR/Mp+tYkkWb0rFhXUl95PBA7Cg3WqNWGOJg8m13lQYOzlfx qFNPkLNM0UrxTExpkcbuM4PtmrhF3uBoTILe3a2LJhU4BPSsm2MkiPAshlRjx8mNnrzWo07O6P/V /iOgtZ1LGMRskcm0kSDKn3HWtpVuv3nllGkkGFaTGEA9K5z0BNk5bdLKH2qEMfG3PrnrUslrNBbP JPA6WxwyzAFYpM9gfw6VcXZMynuZ+nTRrcG2lLISN8OV/dyZ7ZrajuVgLQrbrKgyWO7kZ7/h6VUp K1iC/pt67yPGluGCKWUeSCcHggHqD/jX6v8A7J+qabNYWVreNew6BZPHO0FsoS+dtkSrHuIPAESk g/wgjvX7V4B0vacc0n2TPwT6QFb2XCDXeSX4Ox//1ve/+CYOiPf/ABiu2M5khlt7S7tfKBleFUmj 3LIf4Thc89Qc1/XPrF29r4RvLrIX/iUm+O/5QgVM/Kfwr+gvpDVFU4+w9NdEvzPzPwApey8MZVH1 bf4H8Wv/AAUvvJNX+NUdyriJb43F60zyESERz7JoY1Gevm5OeP3dfz//ALUsws/Dmp3UM6x6fHeL cLfzk+ZGkZUyIFB7jHTuor+xeEovDeFUILdUWvuTP5Gx0/rvjNOq9vbL9Gfi94kuLJtXvDZiCOwY qQkPAHAJwPqax451R2EcwKcEKxyD7Cv8z84nz46tJ9ZP8z++KK5aUY+R1lnGscSsqYedAWYHGO/F b+nFUkaXeN5Ai2E8gDnNfP1OptfSx//X/jNaxufLLwqkjA75Y3P3V6lsVglRbotqsKKvneZ5pzuy f4efc5rxq29jOErKzOj020uZhsYvPKSWEYYkFR0AHbit6O3huoRezxwAwsxW2jbf5LDIx6/TNcL3 ZoTWksOwh7ZhIrhlKnkDkHivRdK1XwpY6dJBqV/NPezowitVtm2w54DO/Yc9faokm9ioNKWuxz+u DTLTUrG20izSW2itxNdavE+GiZgpMYXOTj+neobPV/ttu9pqXk+c0nyqh3SCMHG49+ehrK7ubH// 0P4/tUae31O3tdFu5EtFfe0M+cXHT5V9O9XLu4nWIWt4Ay+aJSitgqwBAP5E18k5Ox3Rta5rafBY XAUTW8ckKEM6KcsCO+avpa6dbaxDqFxqKRac8L20llInzySZ3RbT+YPWpbu7hGVxL3zNWlkgtBtm VvkZjmOPb0H4gV0mnW81vsDIuxVG5znCH2/WsKnxIipKx778JLWTXPHng+xacS20OuWzXVrCN9zc qHU+Vn+AtgYPtX+jL/wTv0aPRPhbotwJ5R9u8PQXMVldLte3SQJsVV7bRkZr8Y8QZe0zjBx7X/G3 +RDkpSUb63R//9H+OA6hHaGVL8Ns6i4IyAO2T74q/pbw6m8txHBFJDZYk8udtouQOTxxkcdq8l6R SOTl0SZRmFrbT3l3Hb28f2vPmBIvlT0C9xjjFc1BczQz2EQZRazXOyWDedsbEdf881InDsaiyu7t cqsgEEpVZEQjaynBwfYj9Klljt5bhT8sxlXd50vzXLMeWGfTjNBmRXJil2Qs7rGmVMUfSQj/APVU 9tc3l2TeXVvDaPaw+RBCsp2ui4UO/ABJAHHNW4NbDi7M/9L+Neaa7W62eTbvaFBkq3LZHbHHGfrW W1gLrVV0+4mezQBbjf0iIJ4Vz2GDzmvLlBdDmbSVzU1e5u9OlWO0gvLmNoVixaQtcRyAEgnIyB6/ lVK9N5b21rdJZuQxIuXkzFIg6jKke+K0tYzc30K7z21ujX0mZLl4hIturfMgOR835V2Oizrd29vJ 9jRIFOWGP9af731+npWlPqaJ3Vyxe29ta3tnqclol7HHcBvsrsfKVR1Yr61QfUINXleSHYZ2nKJb /cRdvUH0AArrhokM/9P+NzxXp+taXeSWly9tE15bxX2mvYv5sLQOiNz6NkkEHpXjfiKeLKRvbhdv zhhwC3PzGu3Dq60OWql7VMf4Kmez12K4LwmBkHyyDa+Q4O0N74Ffvr+zpHbS+DbDU11OeG6hjtw1 kXIhj3QZkLLn7wBUe2fpX9VfRzqWzOvS7o/mj6RUf9gws+0v8j+rv/gihqTuuqaVdyiK10nxB5Ki NxK/2YxQypID1A3Sdv79f0jfFe2g1HwJq0EjM0cVhKbiPGHmiKnfhvUCvzHxzgqPiLKaW7i/8z+h vDyf1jwuwq7U2vuR/C5+1bocPh79o7xilqVhttdsRrDMOJgYXW1TdnpgKyjHXZXyZqd5p94L23tZ bmFo5hE13bwM8l6Cw3FR/M+1f314eYj61wpgK3/TuK+7T9D/AC+45oPDcRYyi+lSX4u/6n//1PgS ZNPnurezsbqVPKQxym4bJZjz82M84/yag2u9zbR3tjImG8tLuM4Mvb5Qfwr/AGgP8bYKyLepxapp UglvtPuvs24C3tby1b/TOnzKMZOM1nG/hguYEE12LVEDoknyrbOwyxA7YPp1xQn1RnK1y9c61Nc2 32cSCWOb/j4KxYOQeGB6j1/GjR5P7UhutGItkvLJjcLcHMct0pHyxqSeT3xj3roJItLht7i+hlvp IzBb3ASS0kfBuRydvuOOcHvVvV73TdIZja2sFgLicjzAp2En7qn6e9C8jGb1P//V+FNEt1ujHDLq EZu55mkiUkL56DkgKeSR6Y7ipbG5X7de2FumDtIhBUo7Y5O7sOnT2r/a6LutT/F8zw9lA1w8q5kG SccAn1p8sl9tinghkKrEXURKW2LjnOOmR6+tWr9DKoiMQPqdhBqUUd3b+ZmBJWn3QMwILOV9PQDN TRR6pepdx/Ypbr7AfL0+QRBJL4gZKr6jkct3z71ucrVnYpJfXkUQTVxe2JtxxYyrtljB5yVz6YI+ tWoLy1/s77dJb+dCpdY5mUls4ztK+vFBlKPVH//W+ALGW5ikstUtrOOUFvkErYMYIwSMc8Zq6xe6 u7idJViu5mLTSImGmJ4O5hz04/Cv9vYy6M/xClF3bHafcW6zy27GOV4VLkSZihOAer4xz+ftVSS3 j1q1MtmtybqO5AFvbyYSQg/cDdTnOKsxnsa8NyIkSCRJFSQKJ7eQGGZT3GOoNTalapJF5zlh5cQT yGXYCvbj15q4y5dGc1ToY1jYWwiUSI3lI24KRuwM9s1pxac2pSgadLZwoejX12tuAf8AD+Vap32M m7Ox/9f4lgJZo41CSXmnybXEaCRHP90HuMiqc0Sx3MTzSyi4lkadAgYrBg/dLDpz0DV/uQf4TS1T uZWqCS5tboz6l588wED2KjYyxjOCWHTOP0FaWi3MkOn/ANlEInWVCq5Z1wMhj9F4oMbu1hs0pRYY khZd0hJuQSTGOOOT2/rWxdrYPJYW80/nzIBtOTI2WABJUeuM801bqYyk72RJZadYXty6NIY4kk8p gzhfm9/Qf41LdWEek3LMhjng2lUeM5BAPah7kH//0PiC2LahdzsplNkwEE1syiPaQc7hnqKseUId QFna20pjOBt2/uxx1zX+5kF1P8EnN9CzqxubC4a23RTL5AdlhbcmGXocdCKigA+zRTF5Xkkjwyyu WEPXAx61oQUIL621Cxms5nkMzXh27yYt6xn5VVevYE/SrV9JcSRQiW3eH7KnkRsw5nAOQR9M49eK CZOyLuleVJY72MsNzJKVjWQFGOMYIB98/lRDpQnvjJeAK4j8t5AwjaT+7urSn1MT/9H4jjtZ7mb7 JAyiWKTErhS6EA8kMOPx5rUgXT7OEIqRXF82VeUrl4x6A9ug/Kv92D/Acy7k3DmFLR/KMWSySMWM u5gDt9Ov5A10FgtrGqJczHzoYy8pbEcYIzhB+Hr3oMZJp6kdpqTu9zBJLvsZJ/OWIgMoK5VQD1GA T0qheRbIri2u447q3c7oywJ8vnnH4cGgkgW9+zTKbeIJbiERoIlyQAMYrXWJbeRZwscpmiMgjE2Z U/3xj68Zz0oA/9L4stYlkdo/MCrNLtVWf5VPoM/yqV9LWzY/ZJuN26VVXCNx0BzX+7lPqf8APw1Z 2HWrmeaO3CM3mPtcZ4PP6U64sQJHhR2VRwxzitDGe5U+SxUl5HMa8zOE3bR6468VDBKQdwbzIJPn QqNpAPQ0EF5TLEnnRu21iR5g4OO/6GtDTlS1khht5Xge5TymyWUgN/e9QapSaMGrOx//0/jaK3Vr g2zSopeXbISckY6kfrTdR0+ye9e1tjLf+TIht8x/vVfCk4A96/3oP+ecrokiSFdgjyPzpRHIsUyk krI25lzgcUAWYYzPCkssXlNsCld24KR1/Op4L24toXswxMZuPPEbcPnG0j1xgdKCJ7Fd4UlCqZQR I3OW3Y9aekcbBoUl2hWHmeWfnGOQDjkU0rvlZkf/1PjuZo2jWMo2FbG5h+vNKpjjyQSWAxyelf73 KKTuf87MlZl5vsN0baOV54ZLO3L71iJW5Zudr9M4xgHpWXcxbB+8LRySDfCemQDgn6dvxqjGcepN a/ZnR45J3hdU3LIF+Ukdt3Y/WpXuIhmFnAMY3FyuGI9SfwoIt0K6TRSupiYyKV5LLt+tS+VEfMEa ySJs8yVFHPAyT+lbprZFODSZ/9X4zin87y3tXEalyrTOm5SvQgKRkY5yea1LT7VBLO6OtxaGMxTn YTGytx83pz096/34P+c8hluVMfkwlDArbgVA69OvXihIpFBut3mQx4BC/wARYZAH5UATeZCXt4ri aWKCSUSSmPvt5x+P+NSXgtTOotlYbuBlsgUEyWlircJNHFJ8gDA7WBxhh1zUFq/lSpLInm7f4RlP X/P4UGJ//9b4+kitb0OqwJBJk7yCSz5Pfn+WKkhsLbKPcCRooMeeI22SMmRnaex/A1/vwf8AOORh VYzGxLGLcRB5n3yueM44zj0qWeJpBbi6ZkeFhLBl9m7bzkYP6UAStaRXLNJI7B5WzIy9SO+P1pZW tbQlVAMZwu/AUgDjJ/nQAx2sX2xLI26T7r9GNRPY/Z4UE06SMw3KUOXx2yB0NAm0tGf/1/jy2a2j jkkmQxxxcrKyEiVhjgfQHOTWwE0meC3uFcTyHLGONiiDPY9ifzr/AH4P+cTnVileeTNE1uJWjOfu dKtQKsdvKquGXy9nlOMjpjIFBndmXBv8mS2VWMTcSIw4IHtVsol15Mezy2txtTbwv0P+FAiuxgW5 8hpJiNh3qp25z7/lU1laxWsbIm8qWJUMS7cn1JzTjugP/9D5SjCI21E3yMcjNQ3iurRyRxFY3XCO fmyRw2D9RX+/72Z/zfleOXbksQee4xmnwyQ+aXyd55wRxxSh8KAurPFIh6koSQoHSo5IvKMfmqW3 gSkY5UHkZqgCaW3d2+ygIyqA4xgk4HWoIZJ2JuIkjuIwwilYjKKG6ke4GfyoE9Ef/9H5Pkh/exSW 7qsSk+fCBgyZHr25qOK3ktJBLG7keb5gyd2zJzxX/QAf83Sm9mLcO28K3JJyo7mp1imZB1A6Hjmg vmWtiJYG8xlY+WqLnc3f2FMIETEbssw/h70Ec7GPPJGu3nBHP0pNOTJuJ0BLRrlkJwAMgZ/WgOdn /9L5EuflKyOwi8xhGhJ6knpV2KB9scJuW8qIHG4lw341/wBAB/zcubYwRiBnbdkscnng0xJbqaXZ bxEqpBd+gVe5/wA+tNNrYbl7titM2zUWhEaDeAd6tubpU1wsgVIyzFlP3sYzVObHGXRldrNkeN5X BRxn5WyV+vpWgDHboqx5ZG5yOenqacG72ND/0/j1riUTSMIzsYdccVYN0ZoAyo+Y2Gfl5wOa/wCg a924n/N+XI5ZZmSLI2z4EYKgliPeoxGZZZY9yq6Als9sZ/z+NYgUmlBwFXhDyMfeqzcLL58V1AsE COoLIke0A4wRj8P1oNYOydxC0LurBtrRxm3dQflbJzkj16CmiJY1bnZHGMD0Wr3juVdH/9T5GhgS KMK7jEnziWQfN34/H/Cp5HhaLyoueMOxOcmv+gg/5xLLnIo7OSMoTlfM7kYyKtSxQRqyqquzDaCe gJ70ESST0K1rZW9vK0skpDeVhR/CSSCausqFlIIIPJ75x6UElKS5hmlljMcsciEBWx8sh75P51DH IJWdW3K0Z2ggYoA//9X5ORBCGKsxZjvJ3Ekn/Ipsnm38gkuWMmzHU8/LwM/lX/QQf835oM8rfMxy AuwZ+YDtWU3kxNthABAJb3680AQSmWTypMLsjXYSvGTknJ/P9BUuwmP7/bO0HpQBLBJHGjjJUf3W 71HNNtAaMDBHOKAP/9b5Pjnje2hXyESSN2JlwQ757Ht2phQrIrKwLSN0XjaK/wCgg/5vZfCy80Uc S7pJEVBwXJwOeB+dRmK2VJEO7zDzG+cL+IpX0bMSkZ3iG6dWeOFSzMiF9o9SB9attLbzxxuqGRXQ NGXQqRn2PI/Gs+d3AcybMK64YgEoRg4NT2ss1q0rxbdskLwMrLkYdSpI9xnI9wKan3A//9f5OGnC aIlp5XKN5hJOHODnHHbiq0U0nnbII3CFCS3p7V/0Drqf8260JEZdpY7gykhlPUe9RxsEDs+CXyqE /e/Ks5RtqjoGwxCNWkBAZTk84NSSNLJEPkO2Tgnpt96Sg2rgR2w8gbQ7bQcZJ5/GtF5opXRdw3kB Qe1Jxa3A/9D5UDvbJKofZI6mNmjOCwPBH41Sis/tL+c0j/u12rEOF69T/ntX/QAf835ftxHFInny eVHuG0quWUd/r9KtX00MN032Nmngz8k8qeXK/uBnIH154FArrYpTNEw3TnBcgDPrVa6ngjMcAnUz L8zWxRlkVSOGBIwc+xPQ8Vop2WoXV7Dgse1bgNuG3IB/kaqOI5GRmJVt3CIcD6kVfMrXGf/R+SpL VGjLh9rbse/1pIWWEmKRg7EcjqQK/wCgg/5vxzbJGZIzuVcMDjFVGjdxL5bbGHB7ZoAfDbhovnkw U59Cxp8bQDeJRKQqkqIsEk9v8+1ACW0iuhYNwPl5HIq9AUjXziwXYee1YPcD/9L5NkvFkklbLPJI xZpGGC+akgO8hsgYOBu5A+tf9AB/zfjZ3ja4BlkjLK+1pE+6Oeo9qtMEDmYSCQYwHx96gNtjLnjP nKSMNy4wcbsVMlzLC32lY0DN8roEGxu3QcVLXvXKbuUreEySMLiVI4WbLM+QgHocc1+WH7YsemWl /c28kkM67mdHlb/R5QHR94DdlUjBNfn/AIo/8kTj/wDA/wBT95+jj/ycvCt/1qj/0/4wtRhit1Bt /LVXcv8AKeADzgVhOY5JFjlV9v8AeUcCvvq/8aXqfMU1sbFrYnyi0WWhXmR9vIFUb6VvOZkR0jQ7 UyPlIFc8pcp2NXimRIiTyxTowjRVzMV9f8/yrYW4gWMxwsGkZcqHHOaxCnsalhZpdlI5wkkmAoGM Mx9vzqG/0N7ctHcRTQ/Pkbl2yKO2QaTaW5Z//9T+LiPR7oyNLbxyPHGMu+0nb25qGSxVJGIYk/xJ nhfwr6lts8cbJbWkZ3s7Btm6Pb94Ee3bvWd+8G153fyy2PNcEg/T/CkJO+xae2RSPLwd5B35PIq3 JbKYwvHmFMkA9KBkNjI1sUtpskuTtkA5UdhVy6Mccce0AvuwzN0x/nFJySA//9X+Kv7RCZVJUjY3 THytVq6n8xk2n5B0CnkV9G59EeORCeASIpjaOVl43DG7HenBJjOSZixYAbM5AqC4J3uSakJrWKAe XcqLjIW7jTMaEYyM+vNMLRbUgeVi0y7xtbLcf3vToetBo1pYtKpXdIRnZiMsB6dqkidJJGTy84G7 IoMD/9b+LW5QsXeNhgrtGedpHFYojZeGYORyzHAFfQHnpW0C1B+05jIEhBRTI21B+Jq7BqAVT9qP luhKlo8vG3bg0Ey+FkRvHaXysiaMn5WHGB7mtSK7lij8sdG4H+z6cfjQYlGLDF0k3OQ/7wDkithI LVJI2s52cFMSQkco1AH/1/4triCRbhXP3VJ8wMuE5BxipUt/KiWb+F5SqY5Y4x2619AeOUXllXeh XBLZOe4qz5ruIocJtzuTA+bPTrUyaSswHrcRQhREQcko6kZOagWZi5UAHJJV8cD2NYlr4GPG5yy7 gHBwNw+Vq77S/C1rf6fLJ/a1jaXDQ5hEtwqtC4/vA9iM9KUnypshuyuf/9D+Lq4tgxeP7WsgbMTS DrxxuGe3pVFUAYwo5EcRCiTH3/XFeweVJWSFmRIg+x9+MMOen4VJA5ZfLkdQH6gjJX3x1oE2ua5E 0UNvEge6WWVmIG2IxjrxxT4rYqgldgqDJRNuWY+lXz2VkJ7lqKa3licBG2gfNldrA+1Zo0q9gmjd Y3kglclhNkFe4qAs7XP/0f4ytO0m5uAXnmS1iVsxAPljj2rSudAkKmYypLGozvTO6vai7PU8exim 3gmUGIKVDlGYNkZXisCZyLhrdRsI5bA6gHrRJpvQGrqw+WVkcAMBGwGSTjn/ADitJZiApZd+DgHu PeiKuyORW0GGUxv5y5D7vvDvUYklufMEhxzlMDg+1bBCLW5//9L+K2ZGjTy4TnHzNjtV6xuvKs1S R3VkYtJsHL5Jr25qzueONeWEuqoSCBlnfAxn1rRgdZEKArI6NncMdKgDNvrsRSLblQFfhyOCO3NQ rO0jyRRL5oii5QgkD0JoAYkb25J3/MRyF/h9qVpSF27s45C55oA//9P+LFERkwPlZ8DHerEium1S QREu51K42166d1c8chiMocCIfK3IJ/hp96zCMJBEvnNw+z+I5zk0wM9LvYVhCkyHqccLjrWtA7XM LswaR1OxQwwvHegC3FF5dsXmjG0naI3/AIvwqtLNst8RKoQfeA42gegoKcm1Y//U/i2CQXCpLGzF ozwm7aWPcY9uamukUoA5bcqBo4vQ+uK9g8hNrYz4reQW7b03SeZkMB82PSr8cTJtkbA9EHGAO+Kz qdC1PuTyPErhoyWBGJFx90+lZ73QQM0AKqp+ZTzWdi7oQ3ayqsrjykQDcq87sf40y1kDuX3FY3fh Mcik1fQZ/9X+Ky8iTzQASEHO6tGzmgWHZFGRNnJmZ8YHTAH9a7+VdjzXNJ2IZEd3zK439OuSP8/1 rMkgMLvy4JbLM1YuLTsHPESCMCYCY/uzyWwTitqRmIRYWIt4Tu3N8oJ+lbmcnd6FWe5eWJM5aLO4 EHhqguTH9lgZZ2d3cgQqpIix0yff2oJP/9b+LzTZUdFy8iSZMbo6lUbHQipvLdml3njBETdEBr0D xxtu5iMn2ja7k7YyvX8fyqhqUymV/KGG8sZXPyEj3/CtIPoVLcj81VjgaI7ZymJFAwE7YBHWtTT1 DrNG8rYlXLn/AA/Om2lKzJKSRxW8n+p89g/Ac4C+lPuZhz+7ChTuZRwD3rI0hHuf/9f+Le3uI5B8 /Udh6U+7n83y0twm9sIpPrXoHmKC6leFokf7PMwMzDI9DjqK25IV0+JZ2mxFKyhxjiIf3qBKGupV vbmIuBb3KyRMu7zEHB/rWPJJbE+ZskV2AXzGUqWx7Vg1Z2NLdBJJRs8rzcl2zweuPaoPLlJVY3Dg tg5GGH4UhNJ7n//Q/iraXai25jMe1i0hUk+Zx09qwmZY5i8UcpG/93/D3xzXQeeabRRx27SzNucn ecHJx71Np8+1yWZgGT9yucKfrQBpLdYHzMQwznA+VaowSOLiRZpFZOsckh2hc0CSS2IZLcSSON3J zhgMge9UoIQu/wCbzDnZIR97FBSTex//0f4rby0t96XTO8ltFAqbCm1kI74zz/8AWpsdxb3UJu4Z l7RRBvllIHHT0GP5V0HniteFF2k+ZJj5DjAQ0yW7uWRXlZQ21RLGozE2B2oHFczsQH7XJGbqBQib sAAjjGM8URu8g2yzKrEYO0Yx7mg3LyeehECrGzxgEPvwpH1/pVaQQxtJuWNHzkkVg92B/9L+J6W7 iL5RmUKu1gehqpAZrsSNvYiM4HBwM+lBzk6bY42hZSVOdzMefcUQ3E1rcxrA5QgfeTsD/wDq6UAX JbPzIvtrTD9xJ8424JUjrj2qh9nberEgxud0bL/FU83u3Qm0ty19nVJQRgKMFs8BqkjvpIZZlik2 A/eiToR1FRHWLQJprQ//0/4m7q/SZoo4iQznaSg3vnv9K0iFt7dVncSSDhTjBrnOcgtoiYZdwCqz bEIOGFQXZEU3kwm4PlxgzloigO4cDPQ4rZRukWptaMYJZLeNpYl3yRjzViPH1P5fyq5bLHdxeePk aWHzJF5YIQegptXVjUVGkQ4bE46bMfeHpVCeBbeR1hT91LJvaED5UJ7D2rJxaVy1Oysf/9T+KNZl d0idRFJEBtXOVK+gNWr8NHAJINjIOGB4YZ4zWPKzdO6uUo7dGRYd6rcHDEK3ar32GUxtEhjfth/l X3qRlMWDxDhVIU53j5VOKrGCSMmZQflP3BzigmWkR1rdSQtcwy267WUS29wHwE9Qff2p7ebKGkDm TeM9cnj/AD0oMT//1f4jHgkuY2lYOZ1+RIi27aoqrYSRnerMybGKiNRgE55JP58VzgaL2C+a0rsW Ijwik4cn1psEMqDbKzlUO9Ay8D3/AEFAGiyi4tykex5ETe25wjOM44/+tVZ44IyTcJtCRgAjkE+1 BtH4SuNWGDCYQQpzHn7px0Jpsd5cBbiSOZI5SgDLwNw9ATUTWlyj/9b+Hu4eVJUjISR3w2CeufWt kR7rcYizHnbuH8H0+leedBnRySJMZPNeRx+5CtypA6U+J4nn4TaSOT7gUCbSVx80hyJQnmzRA+Wi Anb70iyTXERlD7HQ7nTPJHtQSpXdiaOSW5t5I5U2gZAuMfNz2rOiKpvSRWlU/Jt6P+FBZ//X/icF 2ghhtI4Xt2wTtb5s49T+VRxMsIIYmWR3+Uv/AAA1wKLZ0E8ciK0oe5Cxup3MF6ewNZL+RIY/Kbcc kF16e3NVyNMvnaVkXbKSazMtuyMuV3yMCCjjqM/57U2WWdpopVmZQp+RUPyp7itQ53YJoTd5ETGQ p95mOGPrTIYpLAM5O7PDoPuiguMrn//Q/iRW33STSQSkpIoY7co2fQVcyRsZXKMy7GeQbSpHtXOe gRi7dpxD5CumDiZSSVYd8Vsi5uFsGsJ7p3sZn3mOQB1iOc5Hp3oM5K8khTpLRhDIuYwokVzxvUjg iqcGnyLNeXFrcD7NAgcvcMA8uTjAXPUfyFApRaOq0KSxjnglvFdcyrCNhOZmZgAMD3r9gv2Z9JW2 0myWBz5aBTqBdVtZXeWHb5YBB3BFyM+rHHXNf0F9Hajz8Y8/ZH82/SOrez4XhDo5J/d/w5//0ftH /gkVoJHiXUr6cKZItVhIvQ5aa8g3JHGv0AEy++yv6hPiK0OneA73Y4hhtNMYM0oJ/dlcHP444r9x 8cqqxHib7NP4XFHwPgrSeH8JKMmrXjJ/mfw1/tta39q+PetB3iuJbSxcaPPeTlViKyRySRtF0HmC QnJ/ue9fgn+1rfXsFpczeasGnazeNJDpsB8yK1UKxaMIecY6dT+Vf23Sawfhi3HS1FP/AMl1P4py Go8V4rSc3d+2f4O35I/ITULaBJWRnmkuj885lXHJ5/qOKZDEymMCEfe3ZIyTjvX+X2PnfFVH5s/0 Kp/AjvrO5hWzjWaJnuiTtcDAUHjmtGwgY3isyrtT5mB6e1ePJ3dirH//0v4wZILuRoY4p5IVW48y 4lDEvMn9wenanpKkd4YXt/kPB81dzH3rwqr1Oc6WxazS6DssiskRJliX/VIOpPamaFYWmoO09tqM trZT3LiZ44PNZSpIzsJGea5BptGxY6XDDqF1EuoT3yqNqvcosRHuMeuOmTReWRkXyniVmRsKx+Vi M9M+lButUQwLPaarHZS7obUIHu5DGX2hvulefz+tI1hLLrNpqccsZaBTEGCAKVwMDHQjIzz61zm0 XdH/0/5EDLbRSwmaAxX3mFYZ5V2xuf8AZJ4zXPyWmoyavKWZSJGCgbwy7QMgivkGdcXo0b9mbm2m KZUBRtAC/fPcGtV2gnkV7uzgcxkM0D/vFz6qeoNQ3bQjYsw30l3eWwt44oIxJ/pBgQY2AbevqOPy rppnEdxax/bcQCU+cF5Eoxhee3ODXPNvcVV3R9Y/swaTay/GDwU9oj3d1c+JtORbCNctdETYYP6D aRj/AHRX+kX+yfoUdv4MN9F50a7ILC3jli2RwxxxqAsfsNv65r8T41m58Q4emclNuWNS7L/I/9T+ QdZtFm3290kU6sNhSWImNvrx2rlom8q8lisENxbjeEABEQwcfe7A9vXFeQ5JxRyxeiLt3eReTFbR 2kFu+zy5EjY4k6liST19OnSsiW5t7Qz2yaRp0UTxpcPdopa+llU9ME4GcDJHXj0pEzfQ1rOdb+3R LyZtN02ebdISBKLF2G0DA7HGTz69awbgs1xdQWEiTy2bMkV1GN0L7cqHXHUHrxTWjMyfTPPSNXu4 QlxtKuHXcOcjdjtnGR9aZqM1wWhEasbNPkd8YBJzwPSrc7qyA//V/jXWMXVrsXEcMbDcyviUH27/ AP66gW3lliljYQRkHy8yfOJEPUsP6V5Lk2eedZo+uXKRxadpCxBflSJxlFlkXgAHpjp+VVtW1uKO S6i1FBPc3kJS4Z2zHZsDjcvTPTofyp87A46SGwsZPnVZr2eNZLmdQNgjABTkcZwenat+PUQILZ7U JFZpGdzK2CSD1x06VtTlsbQ+EvW+r2y/vCTNC+A+Bgj3BNGjWunWl/POFOpQ3Dt5UMh8hwT0yw/p XZB9Ctj/1v5A/F9zjRdN+0eXE9nduN7R/M0TBRsL9flOSoP94+tfPmvNYXE8zx+a0XmEQM67XcZ7 gcCu7DbHNNpzTJvDtpDcXiwpLbwSxlJoBNwJtrqSPbgV++X7JkNne+DvstxZ2CzXYWQvcZe4xBbD a6tnAWX5U78p2r+nPo7VFHiCrTfb9Gfzb9ImN8nw8v73+R/TF/wR38UWdl4s1K2sNKOntcStp131 ZbwMY1SUFj1HlFf+A1/VRr6W974XmSfDbbGS3k3/AHZi6MmP/Hq+M+kDRVPjpVH5fmz9z8JKvt/C /DP+6/yP4pv289J03Q/2mPEjzrJfwnRvKtPtqBY7bZPKjIAOoyS+O++vgy5gtFknbTyCYYvMmBAR YzknC+3Sv7a8JpufA+Xt/wAi/Nn+cPirSVHjPH010nb7kj//1/hG01KzF3DFD4eW8lllf7fcxSBZ o8A4KL0I45PJrJvY7nUdTt5ITIphBRA7bViAJJGM44wfzr/aA/xpUmlZGtqDROlsYJLi4uCpjm3t 5gUg4AT29q5qK2dpr5r1HYMoW3jZSrL2LH361cNzKcraI1dOs5FnhSwvRbvqC/2eYpFUlzJgEZ7D /OaxncbprS/RbDyJsG+YsrFRwVyOvTsOtakc7tY6Gwtra+hkURqm4/6Ptc7scYbPr71HAbJbqNtX QXNray75LcgS79pyFP1xz+NXBK5hJvmP/9D4HlFn9rtb6GGCNYp99tcQloXtxjDIuemAcZ71V0vE +opcCX9xFcskqXB8vzv+BHsc5zmv9sD/ABYV29CTxBFJPLHfWNo8Vgs3kzXMQxa7x2/I9ParrXMt 8sIhXyBCgHk22Y42AGMn1/lTjuhyTW5Ys7qK1SeO8t5Egt3Vbd4ELRSFxyu0dCOnfpUuu35XTkis NQ+yhmDSwfZy0snbaD0HXrW5zPcyrdx4n/svT1gJLk21zqU9wYvlHAznpjpx/TnblsXsWu9GuZYG h0qVlgWPb+/UKrs5b+I9QPYUeRL2bP/R+I7S60e6s0mSS5aF0f7M1snkTI68KGR16ZBzn9az9Ivr Ky1eKC7TfBcI+52KpLGABlgOnf8AWv8AbuG5/iLLSLK2n3DRm6SS1+1wS3ck1us6eUjRrgFCwxkj I4zS2MkUPmOqPYooLxLGdojbORWpyTetjRjtXaK11We+ilnknzLFu3OACMHqeuMVD4rvvtcMkFjJ LYyx7FmeNUuYrkfeLBuxGB0oMJomF0lpYIDI11FJHtVmRYTgqAcgdBwT+NSWukxSy6Qz3UFuXlEl tPOvmxqeoyMHJ6cc5rSEraMzatoz/9L401RdTtppMpbSNgp9pRBApBGQQqgH9OKy7WUzRyyTqjzs DFyv+rwMZx0z71/uOmnsf4Uyg0ijcvFqkQnMUdvdAi33RQrEkwTKglR9Oo9as29tbRC2VT9nnEZW 5dpB5QbJwE6cY4pnM01uMvLTVLdf9MJWFn8y2RH3bl6bmHYnJ4ohaS2lhkeMRuRvO8fNyODj9aDF xd2bc8dvDa/a4grG4lAniJxJIcAF84xg/XNU5D5UsS2bCRHj3EN1i9sUGbWlj//T+MPOaKKSJ1gE 7rvEiOGLL6Y7Ec1Zsra71RTPHcxLHApJfft2heCc+tf7nxVkf4HlX7NZqy2zXMkUqSZMp+Yvt5wT 3BxVeac3D+RAMsx5kRAqg+w7UwNe7gs5IrCSKKN7qzO2N1iUSo395uOep6/0rPu59rxRGWO4ZMEl R0PcEe1CV9CZWtqON7LdELNbRW9pags9xjYq8Dqc+wrXfy73TzOTbzw39qrwzspJRQflbHXPy9f8 a3irKxif/9T4vSaSykKWJWQpHsYxqQjr7ggHt39Khs5o4L6G/wD7MtPNlzDNFK7Mq/7QGepPTtX+ 7B/gObmoJA5F06RoWhMW3O1EDHOB75FZcLpaxSGFA0rcKWUSLj8eKCJpWLUF5KUsrO6srW38udpD OluI5JkfGNxHXGM85/wl1KOCSWaK1MsiqAXJH7vJGfl9hx+VBkV4Jo9OgLNZC5nhIaCFTtMpJA5P t1/CoJridrhWjRI45FImibJkU9eDQJtLc//V+PbO1tfMklkxkjEfPGfp6+9aFrZSSySi71G2kiXH lRRRrCtsm0bUJ7nPJJ9a/wB3KfU/59pytqZIMQuDHG6rIik7gPlOAe/vVq2aR/PiuCqF0zu4JwDw fbpWhi3dlVukiKQcnGT6fSpGW1M9vFaTEzPF+/WWMfIQ3IT6jufWgRbuIbi2tZWVSLLdwHTccrzn PY89vWoI/JkMU5PlqvMjqDuwO4A78VqoKyJmro//1vj83cF5p62iWENsr3DSC/dN1zKoAATOMrgg nA67qZodzHY3LFyIHALmfBLDbyAD61/vQf8APTyu1x0l0l0YiqRJCG/duB80gPPJqvLh7kGL50Xr EejGgkaWdMnbna2Nn8IptvOGvlu3iAjUBNjD5dwxk/TigynuaGo2NtZ7jaMSshFy+DuCswBKr7Ck 2iJIZ2SOPMYE2370gzjLe9Um+a5zyk9j/9f5AlmDOFDpLF5W9FQEFCQcZyO3HtVWAhwGUGVmYjcO g6/yxX++B/zrlwXCmRVYhyoC5AzjHFDwi5kkEt0vkW6M0Us5MQ2jLFQOcfT1oJle2hSs3tW3mNg9 ujYZwMgGrlxBJJGXjgG0KC7nhkU9CR+I496CUtEVtPjswlwpBlkdV8q4V8BcZLDHQ5z+lNbA3xIW XP8AEOM+1XFrQt7M/9D5KeS0uNjpAF8qJY5cRiMMyqATgcc4qvpYuZLy5UbTFEDcAqu9Y0GM5U9e fwwa/wB9077H/OeU5sZbgDL9ANoH4VejlWOONHZWUL/CMFfrTAikaMyRxjJ3cn1APQ1d2xJErFGM gfAHG0CgV0nYoz3Ue+YyFkiOFJY8ZxjP51btoraKOCIsXuZJCVVsksvG369TQYt3dz//0fk17cWt wu+MgseVIwaSVrQ3Z2pIUC7AGOOD1zjg1/vwf844sk0NogCQoi7gB1Dc9sdKJ5beZkSVfNWSMhVC 8ocGglySKyyrb/IRnZwAOAP88ULJHJDOqRxvNJICGfJMeCOlBm5NklxbDKTRou5QPl9exqRInckh d2wYYkZVO1BJ/9L5A+w3Vwkdq8pjhiuWm2Kco56Hn6AVYIEdxMGURAfIiKuwJgY6fhX+/B/zflKR UEqSA5ZeverKGY7ljQMxXI3HCjFAEUk94RIkEaxmJh8xXIk9T/n0pUdn3Mu6ORRgEg4zigC1+7Co Z2SSRFyCq7f880iMjfOueOOelOO6A//T+RLp1ATZu3H5TtycfWrwtRZw28aSGZZI/NaPkmMkniv9 /wB7WP8Am/IBFaTXEE0xmVFyBFEo2ynsGz0p/wBnWORflIJbBGOgqYPRIBbdIrK4MSMD5shbdIc8 k1M9w5eVCmc8ex/zirAhntop0idDJBKrHzdvIlHb6UiCGMeRE3lQsQDj5VB9aDKe9j//1PlRo4bd secHD8BlPGaakzxj5yGVfUda/wCgA/5tyNJHuWE3loUU/J2YAdalmvkh8xm/cx9BnlgaBp2K8moC eNHSQ7UBV1wBvHTmnJHbzK80J2RoNyI33+3H4UCGPC8igJycfKD3qCGN0Oxm2XGNsgU/L9BQB//V +TLhZZIrVpkASAmNH28E5zyfXn9aevmAqAchulf9AB/zbkU0TpOgz8ufnU9atSMIIGRFYvIcKY22 Ff8AIoAqwMDKGdBuzgNtwas3KFnG3GCcEdGp7qy3GtGQOY/NdI45VWMbXMuDuOOqnAp9qwUCABSo fcVNaQVjdao//9b5NvXijyAMc4x6VTUyL88TZXo0WOG98V/0BS0kz/m/NOKWMoMxfvFcNFjgJ6/0 qNSLS6+1YSWbJyknMTZ6hhnpxUgUG82Z3ldUiBkJCQ/c69v8KkcTMQ7nIUBVUDG0fSgCusUhdiow zHJOOppIW8qeSO7dhA3+sAGenQ4/z1oA/9f5Hjl+0P5NujyqDlVK5Zseg+maY0bSwzeUypyOhwxP t+df9A62P+b8n3XTRxQzufMiXaCeoA7YqQ4j+8dxI+UY4pgVJysxy3pt2jgdKg8+VHRQR5ca4OeD 6j+tADpro8PEhdiwLADJb3qyGVQJNpDSOFKBTkk8CgD/0PleOKMQytKG80EbOeE65yKz45SjSKpP P3vev+gg/wCb8lM0iJwCcHn0qvK8e9WRDl2CtxQAxrWXziu7ZCeetStAIBvZnKqcrgZ3UAI0aSxP KcgY3Ko6nHtVW3uLe8Rmjhkh2P5JRzuyVABYfU5NApOyP//R+TQBtjMko/dDbwNo6k08qEdgpWTj KyDOK/6CD/m4bbGW80k0v2dgH2t2GfapblgpyATt4AxyKwe7EKuDGDgq5PBPf2FRrK6qYnjO48pJ 0H5UgHxQHzFkmdthPbqKnmcIu0HAz+NAH//S+VVWRfK4Iilfaz9Bjv8Alx+dOuWjspCbXzVtpz5e ZVBbHHcfhX/QDd7H/NuZ9xPFBIzrHJPGGAYRALIy55IH0qrJGjESRluGygfkjr1ou7WOgtWlmFJv Z5PNVjsFvvxg8EEj0PSrEMnzCNlwpbaP4toz2/WtINWsA25+wjzUEkhKyBIjs2iT8Pyqv5YiIkA3 fjilKSasgP/T+SoTub7m99pIU8ke9QNPJBznndggDgV/0AH/ADdufYsTgzDzSMJGgYgc81AqytLG 3m7kK4CnnZii3Qhu7uWbjdEn8GSR8z/XoKhmaWQIJ/maJQvK4OPTP4Vco2Dmd7ltMKsakKY8dMVT mtIgztGzDccrk52e1QVGTvqf/9T5QyiRRPdzRgk7MjjOOmRVWS7gO1YYxI6vtY7Mk56DPWv+gG7P +b8la6WMEGBUYqQAMn86ZaskoVZAsbYLPJ91eM0XYDApL7yw8oHjBzmm71jmIQZQ9fQ0Xa2ASW3g A8y2yhZC0q54ZsnkD6YrPiiaSQo0jbc5POeaQH//1fkIRiNegYr7c1PbzSCKUR7Cz8AMPue4r/oA P+b8oG3WHG9id3O0nIzWzbBJYAjAjHQY60FxinuUp1VGLnOAcA9x/nFXN6QiON4HYTJ5yyn7gHbj 3prcTjZXKysk0gBMaoX2HzDhB25r8oP2zYYLi+eG5jV7j7WUjO3lfLZcoo9OBn2r4DxSV+Csev7j P3j6OT5fEnC/11R//9b+Ku6S6a5m37CElKRiPOwemfertvb+ZhJMJtHUg8mvva/8aXqfMU1pF+Ro CdrKJ415RxtZM8HNZ975cw4LJleF7D1rkk7s7fsGQkgtgVJwhOGzxUuUI8yFRuxhH9DU7bjjsi/b 3F5HHEhlCyfellC8sB0HtVi78QX1w+28u2lwgiQyfNKAOgJrGTuxn//X/jFttavbS1375GV32iOJ cEgdCcfj1rIgka4nkkJ+8SxXPPXpX1B45He20cuZ8mNF+V2B5U07zojbR25Z5jGcBnXarfhQRCNt WXFgLjc+1UC5APBqaO0ER8uSVQ8iB0KtngjP50FlRzBv27d8kZwvOMdufarF6BPZp5e3bxuVf4vf P4Vg79S+VWVz/9D+KyyFqZWhlO3aON3RT6Zp8s0RfaqbTn5MDAOK+gPNirIil81ypRVYgfePDD6V F9oKyFWykmACwGGFBRrS6pPc2qWkskhihO6KNiTEpPBIHY1jJbne+3Akc4ZyecDnildJ2A3oX2W8 inksmEH9w+uaWO5e1QoiRlpk2+Yy/MPx7UxWR//R/i/dgoO9EJ2cgDPUc1g3Lwj5YUywGD83T8K+ gPPIUtJW2OjBVAzIT0HsKa8TIkihNsaNkK3G7PNApK6sWNMtmuzIFCxugB2kdfYVrLp96srN5e4K h3qx2+XjuBQYFaR44ZGkUlVK55GCzY5ptjcKn+kCMxEsfvD73v8AyoA//9L+NGS4s5beIzSAyOcb QDl/Y1Bc3MBRdqqoAKrt42Y9q+gPHOdDNJK+5mYKeMjGasR4wY41CyBs/MOgHX86ynuAtlC0lxKp TaqAuXIxnnGB+tbENrEyeWHVNmZfm5J6cVAeRBfm3UhYwMYABH3ifWs9FYO0hBZ3wOT0A6ce1OzA /9P+LlVfIVE3MWwwAzj1NRzocKAmI1PzvnFeweQ23uRboPtMixqwG0FWfGcVMdkSO8YWSWUbSWXI jwR0P4UCGwhzAZXRfOTk7eRx6VA8crurorMp5HHyqabi0rlKNyxZje8QIZJUcmXA+Ugdj6V1ckst 1EQ25EjXancgCka2VrH/1P40mt3wJIZJGePkDJCH61q6V4gaxvhbyxRyr5e4LMFlh3dMMteweW4a 6FXWWkMv2lI4yjjMhRVhRD7KAAOn6VgZT/W/I6gfvf7zL3ANAnC2xgzAS7iIwsRf5AeTjP8A9YVo 2KZjQ4DJnarBs4xx0/z0qoOzILaXNrFKbeWISZBBPZactq0sTpGmPmOCDyy+lbAf/9X+K64Z7VkU x7W7dwasRCKRcMxEp6ADivcm1seOaE2i3cNst1LAGgccsvzDHuO1V7dZE81o0C24wZGzhhjpWaV9 AK1yqSsJ9m4qchCOGqxaTiE5ddksmQQBtGP85q5RsgIIijvNKFAWNsMrty2OhqBpIbyWJYrQQOow 8iuW3/gT/KoA/9b+L393Fvyh3JjymxyDnnNWJIDfZkDEHYPNxxxXsWseOVomFqGjJ3LjaCeWFVrR PN1CKfe8cS5EuxcsW/hx7DvQBqyw6funbyghK7RKRjBrPgWWBiIpdyDvnKnH6UASXN27zjzCDCi5 OOpNNM9uYRI/y4HKYyDQS5JOx//X/izh8rzo3H7y3+8Chx+VdRHqmmxW7wXNgsjSj91cl8Swkd/c H+teweOZi3dsokjUqGkjJAIDMMeg7VlPcFnRow4criRJOMVnPogIG3wuynLCTnj+GrSvAsDxAQCR jvVpRkt/s/oamS96wFYqbhfLJXZ6L0zntV2CwKQg52leCSMcVNraF87sf//Q/i0+zOFd3OY1G7f1 A+tVWaOPkvukYZUdjXoHjjoXnulRbi2HzShVkgbc+B3wa2ZrJVH71mKbAd3X/JqJ7APtbayYxtcS OkEknlLLs5B+n+etWLyOONIwiebEr4/djl+3T3qxpaNmEtrOVSMwvGjNjyTzJEpPf8OasR6aYZgq CSVFbJ8zogoWuwj/0f4v7iIhSqsFDtk5HWsi4ubuGRrcPvjKkGReRER0Ir0DxxLV5meMPNhIzuY4 5k//AF1pi189D8w3MfvYxijYCiLeGJzG0ik7sZboK6C2tH8qPyyuXPy84BFNu+4FJo3NwbdU+cyb Wzx9T9KoXLpl0RS2G2EsOvbNI1jJWsz/0v4r7e28tk3bdsq5UbhgfX0qCFTJK8QxsWUhJAenNege ePuorWFcSqWlx8pLbSMHqakj1R2iZCVMcibSWOen/wCqk20xpXdiOC0hSX7Qd5kkBXy8ny1HqB0q 0scM7OC4kCAjjnBrAco8pQ+yxF12guY23ZPQGp8w27iXbtx9/JJ3etBJ/9P+MCWWyMQlVMyOvGBy R7msWS1KL5uPMbaZPJQgswHt68Gug88rN+/hfGAuMsmc7B6E1DZFVWRZGyir5ak9V9wexGKAN+zt 4JwI4JXmIG1gw+dsDvUF5ZkRqkpFv8x8sFeG2nkZoAfaSIsJjcIzMcRbR82OlQMlrbSySvvXfgS+ WpkZTwMhahTvozSn1P/U/iuMsDyGIymRFGR23fhVGdYA37gfdHyxpxuPoa6Dge7LMQP7qSSJQCwD qeqjuTXQrHDMsnyR7ZFIjVR8tBpBaXMNQLWR0DgqDhoTwV96uW9talJDtUhuAGUb2z2oLM2WZbSU 7490eeFHBA9KoXsUMjxTR3f7mXl0VDvjOe+cVhJWbA//1f4o7Wya5jMUEMJaR8Ryy8HjuPSolAsA 8TSRq2P3vOORmg5m7Ic1tczgTFkWJYs9QN4PeswRi3lVt7qrHJG3KjH9KDG7OlSVZY3ORIWjP7oY CXB7A+grMaWSLbDNCsR2bY1U5EJ46fSoatCzENguY1+SXM6I3LYwc+g9a2Rp9j5j3cDH97GCY8cI e4qY7MqLa2P/1v4ojFb28ziAL5mcttGTGWpDIJHQugYJwXYfN6VznOttSeB4HLRh5BMk6sgAwgHP J/Sr+panHGhiB+d4wsrOMhgMfl0H5V0AYO9Zl8vfh2ONy/eYHtVieaWyhKW2Qjx+XN5Y6L6H8qDW Er6MW3uZIBuRYpN6gqXOdvfH/wBarOZdQJ2W4gIGdqfNux1NTJ2RZ//X/ioPlW8e+RVIU4LN98n0 FZb3hAmjaJpI5FyG3bfKOeOO/wBKzlJbIaGpO00gnJETRIFBUbfMPPJ960UnlljkKnHlkHP94n1r M0g9LFgz293ZiGQmOQN+8G4jd0xj9azY2m8+QuXKIvlRKFwDg4yfXp1oM22yK5kjiOzAYnjBbABp Y5CNoiDJtXJCZIoEf//Q/ie0W5OnXctzEvmyFiXW4HmqAeDgHp3qO9WJ5BKIY4BMWw0TZBGentXO AkMoCONhM6DagfjcB0OfemtOZfMjkUlwvQHG305oLhbqQQh0mWQE5X5Qeg9KuXCxSwyRyP8Avid3 HMePSgtvlsjAafBUFAcDaT0HtU2yAKTIEbK7jHu+YigSmm7H/9H+IAWsNyy/Zkk3rjaGP3ce/wDj W3a3CxL9lmG3ZxtXnJ9a5JrQ6NjIltJh5pBaMK5MPPzOM8VZt0b7CsnliOcEiUsQcjPGP0qIx5jJ u6shUaFFkCzNHcbduVXIYHtVXLQzyN5amJ1wOcZOMVpyLY0UVHYk+0Tl7e38srG+csvC89SatKkc EhRYvNnkGEYrxHjksPyrJqzsM//S/irXVftkHl3UdtDDaW4ht/slkkU8pGAWkYYLE8cnJ6+tZZjK dQTv4+7kj61zJW0R0JWMSaaIFoMsqxnkDOD9aWzAZ/JbITO4Y4zTA3p4goETPtOMgnjd9aoLcxQr Gsg+82Tg8qOmaAJYntszNbTSFgcgONrLg/1/wq3b+TcyG3uJ2SaSIyKSMK2B0X8qBptbH//T/icj BtpEjZo+TwR1I96pXV7HI6qCyKrnOR9/txXOd8XdGxp0tgsTySlleMZKRr875zg1hQXyq0lqSWE0 hZBLz5eT60Ct71zrrSWQIkVxNFsVDtV3wGA6qKqT7pTLBZbokTEmUTdg5zz2x2pXV7FNaWOi8FR3 13rsPnQO1pbTpGIo4fMdpdylSB3AOPoM+lfuH8B5obnRrJL3TbaKPZvgmt8LcG4S2iKllPGMbfT5 smv6a+jZQcuI51H0X6f8E/lT6TdbkyWhSXV/qj//1P0//wCCQ2j6d5Nnrar9rgTyLK8gjnEzERqz J044klc5H98V+93x3u47P4eatJdSmO3tLGVrqFuQwMTFAfxAH41+zeKz9t4rVYr+dHxfhlaj4RYb t7N/kfwt/tT3+qeJfij4zvIrXTPNg1oxCbAiupYlWMEDPAJCKB64PU1/Ph+2Nq2sWtrLp8uogX1l 4immS5ljw8zTlF8kx/w7VBBH16V/a+fzeF8LJ20tRX/pJ/DvA37/AMVKj/6ev/0pn5ryXMrzubzL ySt8zgYAP07Cuw0xrYwQyTOiqZCgUDL4HtX+YuKd6s2+5/obHSKRs281nbySMo82NpC5LkYjA6Z7 dq0DfwnebYZSQAAkYP8A9b8K817s0cbRuf/V/jNubn7dBG0UqWkohjjk8lAMbFUHA9TjOfeodPcN eyC4TzowgWGZnzIPf9PyNeFUV3Y5zQura2lljieYIEXcxRs5z0yB/Ku60zSbOwtkFq/mROodpAuz LEZb9TjNcg2rJHPaw8lldO0cjxB1EjGMZdsHHH5VqTaxb3FtZw28MzSbN0ski4A7Zz+XFJpvRGyV lYp3kosYYLlriV1v5fslyY/ndEyCN467eBWxDeR2CTtJbvexRL5ensibI5GPK/pk4P8ASsDSG5// 1v5CNWSDWraC2ndITDMLi22SZaOXGO3Ttk+1aEFnFZmOFZWZjEGefYfn45Gfr0r486o72GwSPau8 zsrQA5G5fmX0OauXCRXFq1zbXG07TvO3IJ/z/Osp/ESbVjafYVhiuDG0jQ7i8UeAdwyBx+Gatiwj u5raN1dIYHEkjRsU8wBicHnI7dPSs5JW1JmvdP0z/YA8LQ+If2j/AIZSO8EuivexXDtbYN08qSqy xOOowUzn+Ha3Wv8ARc/Z1sZl8D2UzyrNbvIzqRwEOcKoH+6P1r8L4qnGpxbTpreMdfvZyYdJ42TX RI//1/5B76205L2ZIJLaaQRLkFtsTccjJ7/4cViaJqD2ckiWSRWql5YJbeRMJJjcAw9cde9eC3eK OKHN1ORsrCZLuKy1rUDfPc3heEsgiz824B2HGPriupvrTTLHU7TUbkW81lcfJJDBeJI+6I8Ky5O0 HIGTjOaV3e4pfEzBiuNOuE1Uw2k1ut9qLXJtvNMsMZyUHXJxtxjtjtS2EUulxSxwiBUiHlxpI4WR cnOADyfwp8zvck1cTahA5tJrZLqOIPN50qxiMDGTgn8KyoL52me3uoHxagHdt/dzH1FW5pbAf//Q /jGv7tNMV5hh4JgHxGMuOcYAHP4VN5wljlVmSNriAYEgzI/+z6g/414rkloeeJb317aiyja3isLZ 0NpNK2SyEnKt35PqMUl3pMl5HLDJGbx3j8x0J27wcHkjpVAT6bbW1u8ZNupijURyROSwfH8GeoHF S6lKqvJM0EaWxTy/s8K/uo16Dj6VvS1sjWG1jRuLazXRtLu4xDILmd4ZIF48oLgr9Scj6VL4cSW9 vZLeFhELXMx3MEdAozwO/QcV3QWhM3rY/9H+QPULyNpJLK4to7mWGNpXF0CLSVSOPm4GeOmc9K8C 1kJbNKIQJ4Y5GmGw5WPPUKPbp9BXfhvhsccn79jibK/vI9RtZLOTE7XKIu5Qx5cDAzx7V+437HWv ufD1xa3ub23vtPXTkaSXyHsiZIsPHt5O0b845+cc1/RH0f63LxXKPeP6n4D9ISlzcLwqW2kf01/8 EotbXRvF2naJCBustRa4Mk7MzKrTF4tznqCCT/wGv7DI4hc+HwJI/OeGx8x448CORtm/GfQ8c14v 0i1ycYKT8v0P1rwOqRr+F2FS/lf5s/jc/wCCn+l/Zf2gftx05IIjZ3v2uVWI3u7Qy7Nv+yGXHrv9 q/K2a+hmvLmK2VvLmjWD7KH3IrAfe9Qfb6V/ZHg7Uc+A8v12gvzZ/nl4wx5OO8wil/y8Z//S+D7G C3spTHDK0MwU7nHLqDkEde/PH86bqV3YLIwspWZVQCRSNkjHHI74z2r/AGgWp/jG1JcxU0+4lFtG YLaG3Bu95afdL5cYJGAB1J6/5Nb7X1hcxyLcXNtbiDMbTSDEbntnHr6+1XDczdzj3tp3i+2yoscV rOzQsSQJBj72foa0rCe0bTBe2bteSPJILuWYia0xwoREYcFcnJ5HTHStSW7Iltbu3IiR7aSOaPIK QgvJIOSDge36UqtbCAahCkE5JPmW8jFJZQOx9+cgVrBaXMHL3rH/0/gq2uvPhnilsVEQPmu0ijdE pGD82OO35CsO4Fs0v2JJWksvOivQ8a7ZWaIh9oPsRg9jX+2B/itGV9ULBem83Wmps8diJmaO3Vm8 tsE7eB0JFdZY63DNdQyadYRwxQr9j8uNvNYlRgu2fu9+PagVRu1mRJO2+7mkiV1jkEYXJXDk4U4/ E1FqIMUOmyJbPK9wzC5G3/R4CuTy3oRtwPeugxIYrWUutwkpiEeXaC2PDDuB3zio5LyyQw3VvbXJ cN88csnnSNz3HT8KAP/U+HdRvROIZfsSabC8fkpcKCTcuOrbTxweMD0rntMFvBeL/aIW48xgr3L/ ACsq554H9K/27prU/wAR5q10ams3M900ksFoYrWzCx26RJiNBjpj1OOT3rTgmht7FbueKGWOci2k Vot/kM2ACU/lWpzNJ7mAJLK2MrdXaULHFhgp68qD6YH51qpfR+YIreC0W5kAjMdzIWcKT8zKuDlg OQMc47UESj1RUutO1KOQPJLZy2s0u2FUlCXCepePtWrqO6wmsIftAlgQAeZ9+KArggjHrnt6UGMo 39T/1fh5/EV1e3M1pFbRyBcvG75OV6evrV3SbG6unuRLCysgBTYMiQkE547Cv9xISSVmf4XON0UL qCO3k8zEcjWrFcqMKh7jAqayfTb66tbmPO63VpZ7e4bAmAIBAX8sH61oYSj0Z1upXNpJDG8ITfkK rv0Q+/rXMalbTahczz2riWO1tVkudqbVXGAT+o/Kg5zMeed4URXBjVsbE5bj/JrYt4IwkczwsH+7 GccnOM8/gKDGXxH/1vjO9tbS1lYh1e5IWMxowcfPg4znHpmk1G58u1S1dGhJRULWzG3YgDGCFxnP c1/ufH4Uf4JTVmJbQ2rtHdSI8axIFUSOZGlOOpHp3qOG4t9LuLt45ZGku+VUAGFcDIA9+T+XtTIM wXd4JpmDBXuG+Up/CD1+nemxyPZXrwGFn863y8zrv2EkHj0PHX0qo/EjOb2Q25sN0b/6SZVun3vC juGj6DHIwPwJHWr1vdS2VukF3I8trHKAszKoNnAAF8pdoHA+9zkknrWxk9j/1/jOZ7O2uLkQsixS NvWUnLouON47Yx0okht57RbmBN48vzY50cusmehHpX+7B/gFGVlYz47q9vo7a2ugoSJm2gou45I5 ZsZPQcHpk1oRva3lvNBFPtnhkMM6AFXTuCPr60Et31Y63uHMkVmq+bGp4l8vOAOMFuvb9DV3VL22 tD/oRMh2fvAORn0oMOZ3II7yGWSzm1CLyVVkaeOPKlBxu/Mc/jSmexOqF4Ri0ExMZkHLr1UMP0oF J3Z//9D48KxSC5uvlt4U4Ee7JyTgYHpn+YrH8ozyC1V3MszAgIdrtzwc9u3Wv93KaZ/z6yV0btjZ RWkgkvI8AP5Mr5DZOOp/ycVXm8gXUmPl4/dxliXZeoI9u/41oYleAwuCyF0Icl1cbe9XftEMNzHI lrCGwEE2PmI6EmgDROoQws4uoftKbuYtxjVvYHt9ax7W5Z3K+QELNny1yVX2FbJqyQpOyP/R+QTD J9t8u5SSLCZjDDCYPfFWL7SIYbSGXzd7yMfNUDAx25r/AHoP+ei7tymfHPEjCAW6PbwoVhBzvjJz 39s0ogEUIuXJ8t2wg7n/ADigRW1O+kV4Ht4QEcKgSNtzyPwpLfpWiltb3FltMxiuYHO+Jk/eMSOg /HFBlPcqwQTxRLFNKCVHJPQeg/CrchtvskjTMZHcmJIlU/J0+YnGOp/StEvfZyvc/9L4zijlgCzS t5iltoYkFsValkgVAkS+WGbAwNoYmv8AfA/51yxGr2FuzRhDNcfJuZN7x89R6Z6VaFpZTW+ye4Im f/lmCFD8c8UAVJkt7K12RIrRIC0rKo3E9sirFhcRCJp5oi6TgBId2wy/X06UEtO6sVfK+zXDypHH EhkLR24O5UB5xn2qnFE9/dSvGQVhkw6g7cNwcfqKBy2Z/9P5JkjnhxboYgLnBdeGkAUnOO4NMVZL WZfIGGTqM435yMH2r/fSDSVj/nPK12jBhlQHkG4KO3+f61CozGV4D/dKk81p5ASpEWBYW8iG2TAl GdmD/wDqrTtGSZVTIDAfMXO0H8aDGXxFItEN8UgVyrbuRnkVTNyjzEBsunTPVcf/AKqCT//U+Q7W V72UwF2eSU7YW6/N2H4/4VJbvBDPtuQzmF/38SkLMMZ456H61/vwf84rlZ2K91dF2Plws8ZcMiso LnHQVOrvGElWLy3brG4BMft3oMSR4UlySNrEfMR3q7FFbW9uPkV5M5xnmgDMNwUm2bWVZWwBnofa nSpJu2xuVHfIxke9AH//1fkpru5Gn/ZgAohnM48tR5jnAHXr0X9TULRyzRpK6yZcBiz/AHufWv8A fg/5vxv2JXPBYe5qWWD7LHC/nGQ4IfClTx/n9aAIvPuMq8SHEg+UFcB6t21zGJZEuIAQyENjgxn+ 8PpQBWQbiJWQtHng4wcVckHmLF5URSMNj5RjcfegD//W+R5k8u6MMMkc2w4Z0+Zen+fyrUhgkabD yFfKj3dRsYcd6/39suX5H/N+SXKIOAApY8MOBml+0qkK2Uybbwv56TOuRPHwoCnHrzz2ojF6MCjd I0N1Gtzb7Cqecpcfe4yB689M+9Ns5DJmVo2yOqn+GrAEeZpmmbatqjeWZCflB9KTOZJVdFEZ5Qjq 3+f6UGU1Zn//1/kswsEL4+RWwM/zqYWz/IWYlXPAHJr/AKAD/m3EmknjKrBEoiQ7WbOGPXtVtpE8 mPzRC2c8FAZB9TQBjskc8628abAp3t2DenNbKxw20X3lLgbSo5FAFNpgmyQIWAbBUcDFJcNCnkyw usjzDc4A5ix2NAH/0PlBbuSaJ7UwAJHJvViMlyRz/SpIAEIWQbdp4ya/6AD/AJtx7wmWeSUeWkCs FDM+5zx6VUikHmy5YEKMLnpQA+JlvT5acODtP8O00o8yFY/PKySocMwAGfSqi+VgStIsxZzhFPHl qOD71ARaQSJLcb8BhgK+xj2H862WuxSk0f/R+UEiS7mkeZFSJWwiI27ePU/57UjRxRX2FB+yrGV2 s480scYPTtzX/QHNWdz/AJvYu4Ga3jAX596tgdTmiRoLlAuCjKCWbJ+b0qCiIFFiSIDAjBOT1Y+p P5flUcM23dgFu3IoAlWe4jYyQQqGxtDugdFPbg02O3uJ5Y2e3M7n5pAg27R3P0oA/9L5Sms4hCxi bIZeQvBGeoqh9mO2MIGwpDKNxySORn8q/wCgSD6H/N+Xo4JbiKaST93MC20yn5Hx0PHrVFpgoRJF Ilz8zg/IPb+daATeVGQuz72cs3Y0l5bWx5iaRXMfzg42574oApWweGSJlYx+X8qnpmri31zAJYMC aJpPNDOnzKfY0EuN5Jn/0/kVbx7gxLCGlluTyqgk55/z+NV0lBZ3CkmNihAGASOvWv8AoIP+b8vw zrJkMnKLjjj86rsNuWUZI5C5oAat3LMiq5HyDABABHPQ4qdbttkcPysm7IUr9B+VADbmMyMRDiPP Kp1A9hTdOit1laFw670YvLt3bXwcce5xUSk07Izm+h//1Pku2jheB4rsP5yy/Kc5UqPX3q8IiV8q FDLIQSFQbmwASeB7A/lX/QJzn/NuUrRX87zIz5K78GRgce+Pzq3KIRLKgJl2c7gNoPvUPcCKS5LL GhAxD93jbjPrVm3khIKXAG1xmN8ZZfpSAJ828G/cskchKp03oRg9KpM2UEh5A/DFaRimgP/V+TDM 0sfl524OV5wacJ5nCxSEv5f3A3K9e1f9Ajglsf8ANuPmKSFAqIjbdhIG1T9ajjeJN0LIHJPHHKnp xUuLRtzRKcjS2sr7xIyq2woBypzg8ValeNDHuYrHJ95v7gpcr7FLXYbFahpGKZljAzlh8wHrirzw RG2ZlOPKYcE/MSc9vTj+VID/1vkkks6MCACuG28Djj+lOntjIQVVSh6mv+gA/wCb2SVi19nRh5UZ LBVw3GB/ntUUFuY3ZQudoyc9qDEYwM7OjDLxtuj/ALpxSGdp4yJYysikgDj5vxqnJvQByywtbKQr CRGweflI/wAioDcofl29OOnPFF/dsVFe9Zn/1/kdCJwI5U+QNxkcipfLhV0jiiwV4Z+55PJ/Tp6V /wBAd42SP+b8ldQkhZkVkVPlc88+mPas+2Me6SOd/ldt6uF+71+WmoprQBd0cE5i2vKjLhD/AAqc dTUzJGfmiGZI1yQehFP2aAiWR3DSMg2ZwcLtQU8ogBkj+U9SKmUbbAf/0Pj5XL7jg5zyPWrsMkez yTbFJg5YSMT8wIGBiv8AoAP+b8WaJ3UecnX7pA44pJZ5TC3lLGjRKFAOFY446fhQaU+owAzRBpOC OcetKspdx5iBURcDtkCnHdGhFKkTBXj2tEzbSM/L6V+Z/wC2Zf6Je6l5kMMVpHZme5l8x8ryIFZm bsCWbA/2a/PfFN24Kx3+Fn7r9HWP/GyMM/X80f/R/jBluUtmEhMN1MZTKy/ejcE5GR9MU62ma5aS eTaNzZESjaE+g/T8K+9r/wAaXqfL037sR9w0cuVwcjGDjGKzfImdisa7ixx8x4Ud643udjkuWyK8 2nAHaz7v7yMvFRqoiVoFXb3Ufwg1lPsXHZEEpkJCOzBTgMV68VChia5kkVmlMeEbzBkgelZN23Gf /9L+MRlhkVHaR4FZQRHsw2PUVzNw5hvESEMo80BZidpYH2r6eLurnjnQw24Kp+7bYzfMXHDH0qKa wk8yUygwgMGgUr2x0NO6ArpdhSyXavkJsRgfu46DFVxNIsgaNRIB/e6Cp5ogVSClxJI6MVl52+nr WtaGMgQxsAWGyGJxgVEpXVh36H//0/4oLFfMu5o3UlI5OJWHyue/Nay28SXIeQl1Q5wp6j0r6A8l SaVi7MIjH5sUaxRyFkiOdxQjrk1hqFllAVhI2MO5HPFBqndXQ9isTDchKjj2NLGxdJG2kxq2RJjB Wok7SQx8crEbhllQ4HtWqGtbiDe3OwjCFcEEUua0mmB//9T+La6KLllLJlQTnvVKC0M/70KAAcbi Mbq9tzfQ880rW2kSbyJRtikPOeh960buwgw6EFWC7Q3HHoaqT91NAYEH/EvcLFOxYNlmIGSR3zWl cXk87K7SNkrtY49e5qXPSxg9zn/skiXDyTMz4PybuUYHvV8zvMggI8zaMZHGwVUNhH//1f4qxtBR WypRsA54FX3t4YtjSFijDe7DkfhX0B45mxyKZVVSVLNhSQMD6irKhopHik+Z2OVkxjIFJpPcC2lw uwYkUKh2k55HtUM9yY8PEpkJ4x2b8aSgkA53ETbZVCSEc/MGA9sion5gjUOIG8zc8p5bb6Y6f/rq gP/W/izF19mdvLYyBhszjr7j/PenpJHIrLKpKAZwe9e3NWZ45VUx5+bIduAR0FSSCeBY4YwZYpUM jSoOn+z9agC7Yj922R8xGdrHGamjvNg8ortdDwAMAD3q5STVi4wd9Sv9ojWdECMHdtxbO0N3/pW+ bkNABCrg4+bjOag1P//X/jn8N6dqeq3k0FtNp9vCU3PNqcwggi56nPJ/CpPEHgm68HyyteavpmrS Xsn2xJ9Nl8yFUKjaq5545HP69a9duzSOFRbi5djnUl+1xtHPMIoz82CflOM4zWY3lCcRwyFohxnH DUybdCwkdu5USxRskeQE6GpIrWzghAt2bG8ttbgAk9KDBxaMxocSSNy/zemD+FWEuXjKxA7cj5SW 6U+ZrQR//9D+L2eBREruxllPA7k56YqE20tqEKx5O7Jfrt9q9g8c011ORCBJI7ZTaIx9we2KpEfa HRclI92WI4VfrigCys0NsH3qNqD92/vUBWO53XCshEYy3OG/Km23uNJvRFGZBME+zeXs3bZdp+Yf X/Pet+x0WJbZ5vtSi7C5jXGUPpg0hH//0f4yp7eSARAgyyfdkJA5NQx+eI2dV2tv2FTwBx1r2Dxy ERyCUNOwjMbZZ1P3vapbaOfzJX3COJs+TFjLAepPqaAHTrBPGscmXJOHUjAqCW2LLDaRrFGA3L58 s+wJzjjFAFSYQKxXJCjgrnOaltoxEQ0YRmz8pnGYwPpQYy+Jn//S/jISyB3hOQRvKoMDjnj/AD2q pqIE0aRou1h/e44r1pOx4sHeJn2NoIW3798mSMk5p9xDIZ4l3lGMgLkDkj0rKTuyjQEcQSRATuYY DsM4IrP8qJg0T4Zwco68EH1oTs7sBkuxSkdsp3ghmYnjj0rcWadrR2uXyqREJlcEDFDd2XGN1c// 0/4r4bgtbuh3eVI2GTsR1zWrc2tnPbxNbxfvoI/LdgvL+v5e3pXoHj2toVIt8MawIv2aUOSkoysn NbEEBFu0ZnaSZDuctjkfT/PSs5S2sBkQAi5MfnFoi/MZ+7GfatqNIo3OJflB+ZcZOaqWkWNXsy7M 9oVEkOQ+Njnjc59awQ84d1BPlBvmGazTtFoLaXP/1P4t7mVJZvJUuSi7jjO36Zqm5WNQJEwjNyR9 8ge9d0PhPHGSCMHdH/DggKcg1q20ylQuBhRyAeaoBBHD5m/ZE5U8RuR834VbhmlcpEqxqEPUkhh/ nFAFa8tJX23W45WTDoDgjsM/57U2OOEAGRcAcsvd/YUAf//V/ituzL5SRJHtgmmIwhLPEOwPt71B YwExvDFO6yLIylmHzLj0r0DzIPSw29JupYi6uUh+Q8YZyO7USRRQxrsj+TG7aOoNBZZsZtyF7gny 0GIs9f8A9VXY5I4IdiwxRFyTHNuwZM+o/l9ahwWrAo2UMsAlLvvfODxhWqe6txF/Ejq4DbVbcyZ5 6VElZ2A//9b+KmMPHICp/dKvPmHpT2ubaUlMASLwrq2Bjv8AyroPPKTQC3iJR2McjbJUzgMKYiQ5 KBTtI9O9AFq3xC/mWrNE8fDDPbvSXd5PNE9uj+aFyU8xs7SetTKVtAH2MZWKENGfOU4XyzuA64p8 2nyRIbyNm83eWYOcr9MGsVoa09j/1/4jY3Z7rbuEYnkG+Ug7Y/y7VejIiumSMAANlpiCA2OOM1rz qxwyVpM1LpgER1YbcckcA0Wl8sQaY25YRA+UzN+6HqSvf/61PmVrlwelipJcyXG65l2OWGVMabQR 24qrFdsZwJQ6Y+Zewx2pc6LJrsbgsu4EFwoOfl/H8qhkMUY8uVxhlwCoztrNvUTutj//0P4pdOuf skcnzNM6jERC8AngVRurdrh5Z5In81vnEajcHPfP69KDmaurD/7S3QsiQupiUAqylUGBU8KW1yIk +1qFki3yMycZ7qKTdiYpWJre/g0qUCXT/tmF2xSZIEQPBO3uelUZ5mlid5WO5nxFkbXAJOBisnJt WG0rFmytkCgPtlyMhM9DWqyIjGOElIgg3ljllOBn+tXBK1hU1of/0f4nrufdLH9nbdsbZKwGNw7c /nU0TiK4WQlXCjG0gEZNZuGuhzlpoiDkAReaN0bKud30rDulETHLSMZX2OXOW/GtAJ7fyV+RMRyK uEbHFIiPCzmX96JVKFcZoASWzjjghI3oIWEqruxuPcN60172RQotpJC5XJyuBH+PpUTWly4ya3P/ 0v4kET7VIhnlbYHAcZxlq0ru0TTrSe6Ecl1vcDywchR7flXPa2gehmQTwX7RgJ5SxncFY8kj1qSS KSOZWSSMq3KqrZOOnIoKUmi6tvHEN05KBzy+M7atwtHLItpBIGlYZGcAFR6k8VHNaVnsSUbm1sId wf8AeOj+Z5mSQ3t6cU+CPCbpCsKk4jK9/rVj6H//0/4pxZtJ58sOGKJhyDgsPb169K5qSGcXEhT5 Cq8R9Qf/AK9c4HStaRixt5xLKly6FJRIBxjGMD6fyqrDbwumUdi44kJ7/SgPQX7LFHE6CTLl9yue i+g/SpWgOx0kQBzGPLZOQfrQatPQy0tg0oDIuIRnYo4NUrmANdtIqjYVG7sVwKDI/9T+JCxmEfDq Rg4BUc7aLu/giDt5ahtuAcfNjtXOXG7RJE0eoW8UqB98TYd1YBUHSrXkqQUXmIcue9JJJsuMeUzp I4YpJJGBZQMQ7Tt2kd245qC3la7do9m1UH3mG5T/AJ/pTKNCSx8rZEZjLIyBwydB/h/9apY3RZtx kkcqgTLjkgDp+FTyq9wP/9X+Iqb57g/Z3dRz5iMNqqe3NTWk8ks2JC22MYlPG0444Nc50F6XTdOZ t372Oe8G6ImPfbyBevPYn9cUwWqwhyFDyMNoJ9Pam01uBXaOdl2FWkmAwGxlEA4rPWwLMzPMMJ8z DGNp9qpQbQFlIIgpZ2IRhtJX7zdadCsl9IhJ8oWqCCE7cMuM/wCeatRS0A//1v4nUgcSbA67iu1/ NXDY9qdPHCtv+8SNtoyrbBzWMlZ6HdD4UZ8WMgYYhuFCj5jntU91p8EaPsePz7dQ5jJ/fHP60uV2 uUbenSwuircWkcjBcM0i78fQ9q1AlsqNPGwBVykiKMFBxjj/AD0qeX3rjasdf8Pry4fxLbWiHfGS HhMaYeMKcF89+3X1r9o/ghbzN4Wt4JLaT7Y93Bd2VxNEFiDeWQcHqf8AlmcHqAOMdf6s+jTSf9qY io+i/wAv8z+QvpO1EsJgqXVyX5/8A//X/Zf/AIJBeF7ez8P6fq1tbwKs+kxtdPEAsDlFRVCjoWBR fev1m/ak1W1svhjqlxODskhIuAyblldUchD2wc/gK/Y/ECTxHi/UjHf2iX4nx/BND6n4RUIy/wCf V/vifwt/HDXbe5+IPjma4ZIo7XWLyKS/sRvntp0JmhiZc/cIZF3ZyOT6V+BH7auutqPiiZ5VbztS 1B7tphEF8/MeZJDgYDEg8991f2lx5L6r4V1O/sl+R/EHhn+/8Uq9tvav8Jf8OfngixrOrXDs8Rb7 +Mtj6V00UAgMYVBJDOdrNjPlg/xD3r/Mqt70m/M/0HStoaNpALhHs2XZE8m0yYyeDwa6a00zyt5I aQoMBgP3YHr/APrrglo2aSTSSP/Q/ixkkMEgRMh++BkAdK1EsXh+zR2375JnEskryEOu4/Nj0HPS vCnuYNNOzNHVYYofLt7e2RLiU5mmA4kGOMn/AD1rZtdSv7a2gtfMRIQgP2cvkDAxuHvxXK9wW6Ld 409yqcoJZBsjfaPlx71btNtlFHCpQtInlTmQcDPB5/KkblW9sfPhRI2b91JvJXlH68H/AOtWzHbx XMkVzfO8FtIUhS3tmCWtuYxt3hevQ859K5y4bn//0f5CJPDosr+UwzzXlv57fZ5ooiEkB5yT7ZrX dX8u4iW4ilX7L8ishRg3YA+o4r486NjH05nW7g0+ZDLHIdoVsuWJzge/Ndvp2mW8NpJFM0ZbzWZ7 YqVwMjo3rWEt2BNFLA+o+TcNNBBEFCmPDh0OckA9x/Suj861W8B04S3ERcJukjCSFc9SASARyeD2 rCq+UmXws/Wv/glB4Th1H9pXSNTuLCO9stIZLpYxc/Z1Z543jy65BwPmbPHKCv8AQt+DmnpYeD9M FunlRXMKTSW6jCwEKFwP1Oe+a/Bc5k6nHNRX2jH9TmwVN/XJztvb8Ej/0v4/9Nu/D0ElzqGsx3Mt tbEzM8KB8lc8M3YdjjnBrB1LW/DniC/gHh7Qr7RnsQZ3uZrtnt77zMksisBt4B4PY9O9fPpPkVv6 0OGMr2s7L8zAubuNlYyKSkzmNriL5ynYjI9KBp+jR+F73SNN05JryWMCXUbm5csN7A+aM8buDwP0 oE9w0a3g00S201011OIkPmmMpGzYBAGR1HOauXWnNeyIyRRfbEbzjMR88akEAk/560CMi7hn0m5t b+5haaKVjGZxx55VhlBjr1yfqK09VEq3ERsxuimhEmVG5UyASmfUE/oaBrfU/9P+MaDYQ3mYZ4l3 HeMFSPX06VTsg91dvdwwMJCdsjHPlgLwCD+XSvEilaxwy3N+5Tz4ZIrqVZX2jbGOgA7/AFFVZ4yL fEcsmWUK8gyrYH+GKskopcLB+6WSR5CAyjorH3rQs72KPzVkjaSa8QGaLJkK7R27D+tbUnZ2Lim0 7Gxp1gZ4zLLPHapZXQkhsWOHlLZDMVI7d/wq9q1zp1isdzp0bf2izbXIGzI6ckdq76exLTT1P//U /j2nB1KKJbiNY/N2K0rKXjUZBLfh1xXlVzFp9nLcozPKsl1JETIuNyqSMD0H+IrtwuxwLdHAXbWs 91brbWC200M28NG5YkA/KfrX68fsb38i6LbWN5DKqXelJbz/AGr78MjPEBKp/h55P0NfvXgPLl4x j/hf5o/GPHeiqnB0/KSf4M/pO/4Jna4ugfHTRPCWq6hGYbjR23XOAIpZLVwF2Hrja7gH0HvX9sPh iQXPhXTBG/mJPpy3EMnd18vHP/fNX9JOhycTU6ttJJP9P0Psvo6Yh4jw1hSb1hJr06/qfyif8FXf C9vH8ZdD8STeZLa3dxc2cEMrArC7xsBuUd2MPevxYuItMS7uprK3hhmWZwJ0QbMg4JLd6/qLwGxM sTwLh4vaLcV8kj+GfHahHDceYq28nzP5t/of/9X4Mi8+0ia41J7aVzK2xYWI3J2JyOD1/SubaO5u JJbixURBJgztNGTC+SMkn8/yr/aBK2h/jQ9zr1Yrd3DrEPsthCpuQXBy7D5VGPX+tQadpv2+doo7 a3/fnMcAcmSQHnBB4A+lXBanMLNOLRfsU01vJDbTM8tuPn+0gnaYgw9MDmmLDp2oacdNhP2IoRJY 2kQMcSknc4/Dr/8AqrUmSvE52G2ddTmt45AsscZilkyR8v4c4Oe3rW7p8MVuJIWjWWXzAY3YbtvB 6e3Q/hW0PhMT/9b4Ov57yfTH0mGG1JWV7jULtX2OYsAKv/ASRketZY06KwSztLW5tbrzLdN0iTDc rFfmVs9Dz0Nf7YH+KUHrYjtXiS1nu2mFutrMoxIm4PklTj3NbukrZQXGIdkS+V53nYWJTtGWz2zx +PvVQV3qOe9izqWo2K3EqC3dywWUOoAjfB459RjP5VFrMF7eeH7lND1RbDUrlUOJIfNQxAhz14BO MfnWxk5KLVzL0+xub6Y3tlIIJ7e3Tz4hJtT5AqF19SxOce9WrmKHSpBpsbW9zqNxCL2RyzN5HmdB +HpyKBn/1/g24u720iFpdx/bbOSPzUeMbpLcg87WPQdMisprpEUXKQzyvG4xEkeZQMj5h2//AFV/ t9BWR/iXNdTZuNTMDWr2yi8JnBlhkQkuD2YDoealhtpWsb6/8qUvNIJltZPlt4yhAUhT6Y6/SqOW SS0RoP8A2dd/vLh7eC7gjE7JFhmLMAQCe/5+tZb2LXt201lE6GAA3Miny3Jx6/Qcd+KCSjIZILn7 Rc2s8UfmYNxtzGxHA3evTqa6u103T7qKJRPK+5OEmYCRm6nA9KCJrS5//9D4uWy0yxuFuImbz0zG 6Y+Uj6/lUKHVxeCfTZJ4Ybh/JmuYpAv2ZfcYwM/nX+4Nmj/DWS9037jT9OzL5Lb5XXzJ0TGGIHLu vYmuY8Q2DyW9pd6HpbKIwItSmifa0HQLKfRT6etbpWVjnmtA02ON4zp8s0r3UUIMYkyVlY+rfy61 L/ZWsWnnTfZpzBPGEm+QmLGePag5HBrYtSaDdW1sLuWMRFwJIoj8rY9x/SkF9cQpEJbIqhBWN3Bj ye5HHPUfnRY5pK0mf//R+LdNhge7AMW55G3HcNwUjoT+Qq7rl1vngS4tbaV7eLyVkVQrAdjkdx+f rX+50VaJ/glNaj7K+0uO3m3qDcqR5dqy71IOedx6Vg3fy/aZ1QDK5hhA3LknoD1qjN6InuN0cFux sJklaNNqqpLyE45Hsc5q3BMk7FpI2jlVgk0jLhhnCj6elVFXZgR3NlJEWMeXA5LdgKgWQ2uTJC0q SYDKsuw8H17VrfWwmtLH/9L43ubC1iV9QcSRzai5vWjaQylydoOGPJA4Ht+tZ9ot5JJJHZhVREwY +AoXIH+RX+7B/wA/5u6hYPZQwXEuxdyDywq7fM9SPWq9u4leKUW6GTzAWRRt3jgH9KDOb6I0L+9j tLieOzuPNXYNu1AmxsAshB9DkfUdapahFpYtbF7UXb3bR770y7RbA+kfGeOc59qDMzOS4d2XErfx HO3H69qvGC1xvV0cMcrgY2saaV3ZEuSR/9P4uFpFdXEMEj5KTqCc471oTiC3vo7ZRvWV/JTC5cZ/ liv930klZH/PjJ3ZXiW6t7iaIjdGSUQSA7T7gVWSIWs7O7eazAhWf/ln9KZIiSxtP84Ajztck7Bz x1xV+xS1guI5rxWuI7WHy7WKGRY4Cy4w8owd3A6cZ9qA23IZ9Rup7lPLgtHja53Tb02bVwRkYHbj jgfpiysMrxTiG6tI5ImV2WZtsxXPKoOnIz16YrSMdUYyd2f/1PkG2iiWUSrOCyyYbzm8yMnuBnPF Mur2RIZWlBWFJNq7AXaVfYdua/3oP+ecIpo1e0kECrHHMJphKnzSqcfK/wCXT3NGrXkVxKxiIhgj ICgITHGDgFtvU49PagTdkJZJYlbaewllYo29JbiPa5YHO7b2ye1W5LiWzuxfXlpbajao+5bfzjay 3Xqu5ehB5B6dKaV3YxbvuV5cXxuLqCO4gjnk8y3sZcM1omOVLjlue5HerkcEH9nrPcFEZ7oxJBn5 9oGdw9u1aRWrZzH/1fj68tikaCJ96TPlY/4oscYP5UIFSFVuGQN5g8oEjcSO4Ff74H/O3ydi0yyz sC86DnkuOw7VQmtIomaS4uFVtu6AD7rEdRnscdqDMjgU7933/MG0hj1Gam8+WS4CvJGrRACMqgCL tHy8Ae340APhE0kck9xkN93afmJPTI+uKdBLNbMCRBHAzCZzINhYjhcH1+tAH//W+RIpxHIZWPmv yA7cvyauvHLeTRx2+HkK7tqgKx4yRX++cFc/50Ha+hQuYFSbfck+dGPL25yEHGcUxlt+fIG7y22m Rup9606iNFLa4vLa7WC7tVnt1VxC8mPNBOCBjqRyaqLbtiNw6oyN86AZDe3+fSmYy+JkkUPlXK3c nlmKJgzq65iP+8PTisuZYru5ubpY0UXBJVLYbIk64Cj0/Wgk/9f49tA9kFSNDFMgyrEfMCO9SFJZ H89vnZyWlb+83fP+e9f78H/OFPcnXKxgsmCxxwMgU61kiNzi6dvL6gqMscdqCBl0+Ljy4idjHKg9 QPepLUCcTGNmZrb7wwc46Z/UfnQBEpL3cMao0pkcRqqjc+T2A/z1q9Ndw+VPGN0NxFMItxUA46MP 5D8aAP/Q+Qisp2iJ1I6vuOD+FXHnltY1SWQvH/BnlU6ZFf78H/N+OiYM0ZyMsfl9DmpYHi33SybC wUhVbkE5xgenr+FAFZmYBBI43Ku1fQD2qqiqhdmck+o6GgC9byJ5UnIIVc4PGfoP89KW2mlNurDz BG3zeW/y7fwoA//R+SUeNpJFQYkX5mGP8+lNSYu7xypKV28SrwqYPev9++bSx/zfk0jeYlvJFP5i 8hkGSF56VPNFHEkUst2FuG4itWBZmX1U4wOvQ1qBBK00jec0bv5OFXnKuPQf/XqfzrhUL2uIw6lJ 12fMVI5A9KAKUcODKI0kRJjvaNm3BiP071p25iZxFdKygRk/KPmzj5f1oFJaM//S+UI472aVonuA sJcBEkwkaCrk4iFuwhuWLxnYVjON474Pav8AoAP+bcpwhraBY3Z2Vm3jf1H+cUebHIFMaF3U5ceg oAuxiFcqyjMwwzY5QD0qtH9ikMkO+VjG/wDqyuFPpls5HTpQAkiSJ91cr3BGV/zxUFvHgksioAeO OKAP/9P5VZp4QoSFTyW8ztjjFTQxIYvtFxukC8SJG4Rsn0yD39q/6AD/AJtzKY+W27lYXYkljkt7 GrTwRC1M0W558gCILtAHdsn+VAD7eCOJ1kilyzjPHAJ70XMTliHGD09KAEgVhG8aqpIORlfmzz0N RSaNPdP5srvLIg3+UDwgXnH6VpBPcD//1PkmG4iORE4Lh/LZAfmUj1pZbd/NDuwKr0281/0BS+I/ 5uE2tiOYlCDkBTySew+laVrZ2zo0kMjSiRA7b8LtOBkAdgMGpNIzu7FN4RnejAjJXaOxGQRUCfup G3Y2+nQ0Fld7vLuoVgp4XHTPrV6MStb/ADOWcJgnpmgD/9X5OtplljW3kMcTQgtvyQZRnODnv2qO ZiHWNQwLHCbec1/0ApNvQ/5vy1ky2mYp4t8UuyaNj+9x7Cq9zFGyDjGec9639QIY424G8LGq5BPV jV6NotjMRwv3mI60AUZ2jmcOg3CE4AAx7VbNtNIIWi8qNZSCGc/Jjof60Af/1vlKBY1ld0IjlUkD aNu3rnFU5gxbakZwT98L8or/AKCD/m/Hn9zBJgfMw2lv6VDDHI4y52uvJB6igiUrOw6FVfziqENE O4xu+lIgYuNyFBjK8YJ96BKfcvRxoJ45JAWUA5VW2Hpwf8+lThoEnjJUCPdl2xhu2f5VlPcmTuz/ 1/k5Z4/MbKEgN0P+NNazeZZJyxS3D9UcggnPFf8AQAf825qi2iS0Qq/T5gM85Hr+VVbaWNgwY5Yt gKFwwHvQBHcQxu6BGCgcFR/FQFif+9vhUhQeAaAIY3kypMDPG+Yw7r+7VhgnB9Rkce9JfLIixPCq bQpEqjOV9DQB/9D5Et4Yy29iQ5ORlsIP1wKsrLHctKqMjG3fyzIhDJkdgelf9AB/zbkdxcKPLjKh eeWHc+tOjjjiLPI4bac5T560U1bUCCa5i86QIGkWTlCeq/Wkm8ydQ0gACgABR1x04/CqbVjWOkdR Yy24EHkjHofyq8hI3Z4UjJ96xKukf//R+TVHmYEeCCeSOBV6K28vLeZlVXhTk5Ir/oAP+byUlayI 7aaW1MyS7Ssj71JUbhz0B9OvSopf9YJ0lUeYPmQNk8cYoMhiSqrl5CADwAO2KbKRcfJEeAOT6UAV /s7RxydQP4SRjNMjjPlKjYErH7w4yaAP/9L5QjtfKUmWdXmU4LIfkxT5XSL50dZMJnKfx/Sv+gA/ 5vyjAu4OGZyz84LZAppDLGIfK3MG3B1AX8+56UbAWYJHjiclVw/ygbfn4rPnWZmDKNiDuBhyD1H0 rRT7gXFtCwiiaTy0C7iq8qTg8VFMuCyK2Ao/OiUk0rAf/9P44h80yhHBRVOcAYzWm7ruwRtwOCRz X/QEnsmf8342GVZRKJZSpj/1QyMsT6D061lyiXzSyNubPzgcYFOduhpT6l+y3OsgkyEX+I9jTSss YLNhhnavuKmO6NCKRmit9yKpCEP5ZHydeh/z3r8r/wBtu0eHVrtPs9vbqZngks7cmdH3CBiDnPTf /OvzrxXduCMc/wC6z95+jpHm8R8MvJ/mj//U/iuUeRK6CFDIW8oeaPuKDjI/Cr1vN5N1sgwSzDJc bVz6V93XTlUl6nytLSMTuW8O/aLZb63kEnkKZLtISGCgjgEdeMHp6Vz86RWw8wI+9TXIdRz91dbU M8cSSBnwVLYz659KoNvdRtwGzn3YVlNamsGrJCQllDGQb/m4JHSpPLWRQsICbmzJhQCMdz71hPsW f//V/jLgR7lAWV7krGIBtXlQowDSx28Nnie8t/OQ/P8Ac3bNp7//AFq+g8jxyWfV0nmUJFEkXBVI hgR/h+FRXGpQRD/SBvLkIiEZyTQBiXFs90TIhUYbp3xVeRUs0j83cDN8qkLxQLmV+Uesf7tSn753 bBJPyqPSlvI3h2SGMhSflkX1oGf/1v4nowEdijuwJ3Ed8mr0iORvWUpgbvvbSfpX0B45QFzJzbAM xByOOBn0q1DA0DZbACrvY57e1BtB3ViFrrz9ixDejnO5uGWtG0RjmEx/uyeR6/Wpcbu5RalCRI8M GYWYYfjKyVll7iNWwmxG4IYYLY7gf561EopO4H//1/4ppJZGQM+Nrrt65IxVu3mbyVjLN5SDO0Dm vYPPLD3J2xwu52AhxNn50PpVi61eRlMTIrhE2LKpwx96beiQmrqxlRAKGVQcEkiSU7uT7+lStMUt jG7LhHyZCAPwpGLi4lUzfaRHGpy+8KzM3y4/xrZs7a0imeOWTETcNMvOMVrBaCP/0P4srqJGkfyP uIfkPZvaqyXcsOVuVIUgqsbfwkV9AeOMijmlxcwqQqk7ty4xj0/KpLeaSWR/M+Zk4TIwefagAFuf mXCjJ5B4yTTWRl/dyHHl8/LzmgadhIYzJCjbpDIZCSXXC47AU6VZHyPLJVflbd0xQI//0f4tlitp DuWMRmOMAR7vlbjB/WoVeNZHilYRrIpRHxk5xwK92drXPHGqiRokexy+S3mMMqAPQ/nV+3nhWPbu 5VsgMO1ZFQ+JFWe4ea4XYvlGP7u3gNVmZkniG1FSTpIQeTQbFKa1uA6FV85AoZWVsbe3Oatw3F7a hYc7l3ZAHzEZ6igD/9L+Mf7XHbjLMcuPmCnoO+aJtQN1CIShEY/1blskehFeweeYtzIybFX5snDn HygVcs40kGRhQOcnrSuk7MB89p5sm5XkiKDAAPEmahlniiRIGUg4+diSdx9/SpjK8rCaurFSGcyF S7/6xiI1HBUD1q3eIEVZTAZJR8qJnGc98VZDh2P/0/4tI5JIGEkjjoAyN820egrTudSVIlS3iUrL jczHgdK9g8vSKaI4rU3bKsKgMw5bsK6c+G4rHSPtrXtuFMuzyGciV3bnCg9aCXZ3aRy8wE4CKPkj fDcc1lkmG6csAsJXB4wW9qrlY4bkluLaOUiCMx+a26V+pY1pyzuMJBkbFydoORUkvdn/1P4z7OS4 Z4myHjVSrvJy5ParFxOVDK2DycBR+teweOZD+UJFG4l3+fBParH2mOAoJWHz5CY5JOOBigDLe4lE 29Y/mB+UY4zVm0QtcebcZLSp8yM2B3waALtxbQEIwt8cYPORnnmsyxQS3EsUxYIjFVVs4PPT/wCt QYy+Jn//1f4xXd45PLhdkZcgA/xVlT3JhILqJiQVZehP4ivTnueJT2KyTEKJljIO7C/wqD7Grtq8 rvmSPDLNiRmPJ9qj1LLc+5ZV8koUDEsr8lvYVSmZS2Qo3fxbR0oAqtK8QE6qAFPORyauNqstzEiz IibxtO1eBjocUGsHpY//1v4tdhUIwCvGxwPXAr03w3B4OubUT6zPqlskMhWX7Gsag44yu7rjqc+t d7vbTc8aV7Nx3Ob8UR2dxqItdDuRqOnR5Md9NEbKcqFz9w9xyOvbispY5bZ4Qu4CeLDE/N5mDWcl sxrzIruAJGsxTZKk3mL5ZOXA7Ed6bHOJ2UKuxifmD8D8ac+hpa0GQ3LlG++FC8/Lypp4J8oMwJRx 8zDgisw5LxP/1/4tkikji8/C7SxXdnAwD1NSXMouLZIPJjdEYvHKoCvuIGcsOSOOhrrg7aM8lRbd jB+wXTugjkeP5t0iMu0Y61ckkjWNUjURybvmdf8Alp9fyrTmRSh3Kp83zYndx8rbgM9MVdFwzSbg 3l4PyljtBx3rNyd9CGrOw6a/eQb1IIXhz90P2pZL9jbqYoo2mjP3GJUEHqSapS3Ef//Q/imtLhrl yTuHl9R2OatJA/2gmFWLMucgZA+tegeVT3sW7qNFikZHEDSRiOVCSS5/vD05rLjAEQi3OzYypf7z Ck3ZGpNbRI8nkybh/d46n3q/dw20cH+qM7qQsakZKH+8PpWalo0wMa4uBHCd3mLNvARh/qz7EVPZ MHm8yYARyIEz1Yn0+nWnU6Af/9H+LrUFFqoSONJFaEsMnc4HcYFZVnpP2hGmmkS1kZP3SnJB7gMe 1bt2VzzysYrjc6SxuY0+VREu4tjvWpFDC8ThSVmVcrkDa3t9axu0BWgEQyHaRXfIkJHI+lVRGkbE rGwQ5OeTupz+IC3a3G2RPlKqPuspwRj1qa6uriWKSLyg6tkjD7RipGm47H//0v4qLW2jniExiFv5 QAYEY3dvzqRr23tfMxHHOShTZKmVXPcUHA3d3Kqh7lAsiARYyojGAPQVNDPbCEwXEfmqimMhTtZS c4JH9DQXBW1LSPZCNQNqZGxVHQe+Kp3NpLbqsjuk3qqKflBoNCil9AN1iwRInbJdl+4TzkGkv7Jl jOxTuKgx5/iHqP1oA//T/iZ0+zu4ozKQWkb5I0J4Psf/AK9T3X2sZmt8+aRtkUH5EwMcelD2Ocxr a6up1O9UWZTtaMjg89DV+G12sQ4VEJ3tt421g23uD0Q1LlPtO1G3CMHaCcg4qdpkulDpExeJtrhF J545xSMnK6sSxecrb0jUBeX5wqjOP8/WtXyopE+0TK3l9PLRsM/vVwdnYm7WiP/U/iSghd7mVCss MG4jG3k9s5oiiVZXgldwqncT93Iz60HCptHSKm4pvk2QwRkpgZYcZGPxxWVdIJizPGcbc7ulAOTF gFv9njiKoGVyzS4zNj69+nT3pEt55JHWFuCN8Zk4wB7fhQaRlcrq0mFEmCkucccnHBzVlIrdFePc DuUO2Oi4/lSbS3Gnc//V/iScggyIo8uOQKGHGTWje3I+yFIifKKfOCfvVjL4mYqTRzdsjtMkkJwA MGM8A+5HtWqAY50ZAW3uFZwMlASMn6VJsbF5e28cIh27w3yMGHJOOlcrA2x5YmH/AC0+8j/MB2UH tip5Ve4G813bfY3sDahCMttyDIWOOS3WqN1c7IIxGh+XAZHPaqA//9b+J21vDHBtY+UM7vp61C2p 27XSb03xqMfKMFz6/nXOA6S9RxkAks2xI24K/WoLW/s0nMBuFjnhnHmxAhg6ketBrCNtWdH5NnNa XLhlXLBmkzliewArnY7gxXG2SVimzaFz19CKCyzbSNI58qMqoGd3UD8azLyRjcTSKoK3KBVZRtxj g4A9aDNxXMj/1/4qMWTafbKIzb3fllWcYO/PY/hXIX/lMViZPNEfyhg2A34+1c+x0WsGmi2hu4Uu JZraKRShaIbkTjjcM+tbULTzMLeAr5SSZYv8pegCPVmCGOGNA8vAWNFyxPvT7R2tUjM6eQZH2OmM k49qANVoTsklILKoymOo61itcNG0yrgYTcSeAAKBpN7H/9D+Ie3liuZSyyErEm444Un/AD/Klhm2 3MxZg8Rj2lAM9OAB+tYR3R0WtoW3eOe2XyWKPFykbtgNjsKoNfy7ojDu34+eNx8vpxW4CS39+NjR Fom3FSAMc/jQDK0kSSBg7uC74+X3zQNJvYv3dtDBGjw3EjMDkxsMJn29a17WSKS3hklg+zME3nBG WxnkmgLNaH//0f4qLMvdudsyu4lIBYBGAJ4FPuoIUE0ExKAfPluQx9vxrOp0O+C0SMmwvTHMwVAu 1sBmGWOOlXbsNNcoyQqZJZC9zcscTEHt9BTirwsVbob2m2FzdukdlA87FgpVRyOcVNren3dlJZrF D5cE0jC8nZSEAQDK7umSWAxWcd0ayjoel/CW2Z/EVtPFE5ZZls/lXeku4oxPHTGBX7cfCi2iOnWk 7bYsw24gt0/dxXIWEK0iD0zGM46ZNf139Gineti6i7foj+LfpNTbxmAo9pL82f/S/oJ/4JbaGum/ DPwzAlnFBEkC6jHNCS0TyOsQdVJHKllJ9s19c/tx6z/Znwj8Q26RMwmjLQgDCM/l5fB/3QR+Nfre eVI47xiqOL/5fJfc7HzmAhLB+FNKE91QX/pB/DP8SruzuNR8X65oljJDJ4jupmvYjOtxDcyySJub uF4V+R3Oe3P4EftiTqPE1vcxXkUtrJuQQRS+ayuURWQn0U7unoK/tTxZvhvDGtC+0EvuVj+FvByC reJFWp3m397ufC/mJvEPzjqdwXKD2ro9OmLRNC8rleiAj7nriv8AMubbk0f6Dw3Ooit5IoY5ondk 6PgdCPWt61u2ktRsmZEKZbccK2Dj/CuSfU1P/9P+LpMAkOu8FRuYdRWxbXMKRqsMZLlhsSRtgwCN x+teFP4iJ7FvVJpbkRw6Xp8t4zlQ7vKFkjP8TdhgVQuNNnszJNPOZFigVmER8zymPY/mB7VyBGKs men2uk3H9iRXtyFWR2EVhA4KhhjJfJ7c/rXKX0dxJc+T5LxSRMUmBYMhweoI45oOhQVtTatT9mtw pYlG6nr0rPd7gutuCfJVy6kkZGe1c9raBGNnc//U/kd0zUb22l+y2spaOSJo8k5WPcMN14Gc1M0U EBhRhLKJH/ePHzgkngmvjzrhG7uVlhgiu41ud8Rt5DMHU4MoIxgH8a1rS+KFp2V5QsbwQqfuEsOG b3GKwe7KULO5HYXY1OXdLEkMsbGN41fdtAY4cfWvSdF0uVLcSW96juJvONsQA0oAwF5+o5rnrLS5 HLoz96/+CMngqz1r4v3+o3cGyW6SHS1d1ZILaa3HnO5boeGjXHvX93/w9hu7TwxpYuMHzLJJIlXB KqRkfrn8MV+C4xc/HFe3RJfgThmlNW31/M//1f47UsZorGMGQb5W/fwgfPKc/e2eh5qheWTlAiKN yL8o6Yx2rwdo28zyqc1yIxBpUsUPkvEqTTKWgtbcearP3GBj1PbvTLX7TpwGliCa5/tCfzVCwm42 yKSwQMOR1xgcHFSNT7ll7y4nRxcxRW5+0mOIFRG3HA+hPPFbFgwWO5SEBtVQJthnk8qO4Rs9DjOR zQVzK9ivrGnXliqfbxGJvM862teZ41Ld/T06dcVWt7pZ4vLiVQiJsZhzscdfxHp7UFH/1v42NNkR boLJDHN5h2hpBlDweCas38zwQRW2mLbwQlyZniXLMvdRj1/xrwIuzPPMy3Ng7s8nnC7OIYH2Epyf m3enSrNzcRJepbRkzQRuPNVY9vmfQmtwMO5iJunXywilt8b/AHcAk/IPpxW7oscccsystsJHAxI7 YnXnsPyrSk7MabWx0v2WBF8l5mubjcWaWVlLuevDDA//AFVlusT3IV9obiNYzjcea9Cn2Ef/1/48 7+J7GIpJKXWQjYittEQ/izz/AJzXlviAWtyVubVlbgxsYmyGI6n6134ZWbRwR3R540Esd0jR5wzj DNwnX1r9T/2TLm1ktoLufV4rg6NL/punxy4mmzHH5Em4AgKrBuCRnJ4POP2rwTq+z4zorvdfh/wD 8z8YsP7XgvESteyv+n4Xuf0LfsA+KYdK+NHhkXEGnz3kg+0RuAJbqO3kNtCVfHQEjdwR90jAr+6f 4ZXEd74D0aK3mDsulLFG6txtwScE/Xj6V9R9JnD8mZYXEd4/k2L6MVd1eCcTh39mf6f8BH80X/BZ 7Sxo+oWuq6etxD9rvbY6WUQSoLsSxqWC9xhnyvX5xX8/6adOba2s2aW2ZpDNqPmSH53YknZ6DJzj 61+/fR7qKfAdF9eZ/ofxx4+0pR8Q8XHzX4n/0PhK40K4tYZrm3ie7VQEdJZRg54BGTgf/Wp19p6L 9nsbki2ujGn7hTtAJUMoU9xg1/s7DY/xqmrSOWVobe+kmtPMV3jMEyk/JORwHI9RgYrQ0zULW6eK a7E9m1hO3nXKPsITpu9O+RWidtjGUdNCtc2ANvf3um3b6lDY6n5SPIvkyXglb5RGp7gkdfX2q7FN az6ezXAubW+LGK3RMJLEVwCxbt3xj0rdamRv6FeaS9ndWUqRwzabF9pvtVumDtOrNtAJPIwcD8TV KTUNJN5K1ldSb7K6S2eCW38tbkSKxEiEnJUYAPH8X4VpT7GDVnY//9H4L1C1a2jt54RmbU7lo1Ow tGFHJJPbpiqMltbWo8yS2QM7FGUOQxJB6c5//VX+2B/ije0rohtLaEwKsmoXNuLXdIbV0VoLlyQq 7s8nAzzx+PFaWoW8cawooEayrlpFOVHSrhpITd2Q6Rpm7Vbvz7xrm0kiS3s4ZCd6ybCSVHTbkfpW 3fWlwrK0TRmIQm3lhRgjgjGNvH1BzWplU6HM6dIBdzwGK5toYisSSNN5RkYEEjIOSBiul1K8s4Pv 2AM97Fsa/UZeLZt2rnHfJ/KgqPwo/9L4YjuLFtPe0lm3FAZFkcBCM9RnqfpVi1vLLTdMnuWdXtWi 2xyPCXWRv7o4xlc5GfSv9vYPSx/iXMNMzFeeZpkweSZg6ySoob6kHgfnV+0ltmv5INTuZbdogWYS EiC53cKB2yT2PJqzlmtTn9TlhYTyLaOiRThECod7/N8hx+Rogha3mkuoJbhpLYJJc2rRt82QcEDH PGelBJ0v2+Ga3lS5ih+y3ESsrMpWXOQdoU459abbRPatNNcW3lQD57ZgcuUwMDHqeaqCTepMvhZ/ /9P4qmKXEFzd2sc00kCGeWJEwyoB8zHOBx1PNN0nT4tRjNzJNJG0c6SwIDhMAknd69OBX+40vhZ/ hrL4Wbs3l6FbX1wt9dQNqW2zDR8GXewUqT6dBWLbObkywAtHAymOWfOCndfY1Rg9mJcQyosMUeLg JGIopoTukG3jJPrV65v73ToLCWO6aUz26w3Vo5ITKMct356H8qDnezBtav8AVpY4nQlkPlwqADxg Afy6mqt3d6jLFpthrNwrPp8TRiUuCkS7ssTj/PStYWscUviZ/9T400z7OYZ7g3Lb/KEtusAVWmUD PyZ4yePzrLkMt3ZLdtHPbOw3PFOVMyEnGDgkZ6d+9f7oH+CdToNtYoZJkW4iwcFBNnaEz0J9hx+V bKwRRyYLOhhG7zHGA3utOKu7GUtmOvCWEN7bXJcBg8sTyDfGw9h0zijW5IprS2dCRdyIru6ADPAI 3475HNbJJKyMCjayAeZFdSPEzxcHrgjkZ+uP1psrxKmFbdztfP8AyzP+f507BY//1fjOxlWeF47q KadLKLbbTFuRuOWA9ATyenNX9HFhBdD+0JWjhmYRuQMHaSCQD2PHFf7sH+AU1ZlGaSCZ4o7mW5No kxGN+HVN3b0/+sKnkgRjHdaVdosTuYoVlyzArjcOBz160HNL4mS3FjpttHLcBrqO9jKC6trht+9y PmZMAcH39epqjNexs0FqkQSMn5mznnuT+ZoIktNB6NHY3cwjjW4ABUGWMSxkHIyFPFVRHcwurIRs bkKy7g3/ANf3pq99DA//1vjpmtCrJcW7Ry7snHyyKw6dfp0pNKuIoZWedXWSMkxzgZP4en4V/vAf 895PealHfRR29rKZpbV8R3J+XPc5757H/wCtUGLeSaMW++XYn+lySMPLR+Mge3NADS1nd3XkxbS4 YI6bfkJ4x9adcJ5lwVWEJ5z+UI7cbEBAwMD8qqK1szB3srlz+y4YkWVXCSblWWOU7SCc9F/D9aqT 2MVlqEhOZpDKEmETbopwOOD/AFFbCP/X+PxFFaJGGjaTYxeTnDnJz/I4qWN45CLhrVpbdRsMW7y2 U+vGf8mv96D/AJ5nJIpy3kXluXG07tjFueM8VZNrbm3RpHUeYMDB+Y9e34UGLbb1Kwjto4Vka6aO O3/dIh6sGJyfw5P41TxpxjtPKnuZGj3OQ52LPk9geePf1q4x1uxbF7+0ZPsLWrlzvJVWjO1kTOcA 9f8A9dNWM3EcQk3osRLRrIcshI55960Stc5z/9D5ISaMwrZrGEkgfzmvJZM+YoGdmDxzg+/PFU4b WK/1CCWItIXYJEjOCm4nHGelf74H/OzzM1JoPsc/mbknE2Ve3YfJFgY4IIPv9RWTPCszpbyJlGbK 8E7cc/0oJL01kiwW7I2GdyioP41GOc/jUb2wtzJdpExVVCklSVBAJx9etAbFhY7h4QZ4miLrvUlS iuDyCPaq8uXUw3gWSJSBGSPugdvzoE3ZH//R+PlhWOUFn/d5+Q46VM1m9w5eCXL/AHYpAOG+n5V/ vnB2Z/znhdFIFijuEKyyLgBxtdsdeP8APWiySDy5vOm8sblVY9p+fOcnPbHHX1rTqZSld6E15ZfZ GhS1bEMREjvGdruMZOW6n/8AXVIzxXU8qxMQpO0hTypxTJbvuOjhLMIpWYhDj5uM9uRVlY2ty0KR 7YmxIp29euCPzNAj/9L5MjUmTLnc33iT1qX7StuknmLiN2wPlyAegr/fg/5wp2uMju90samFGjhG ADyX9S1JchPlWBIlYvvZ2zwO4A9f8KCA8uLGDje4+/jmqhaS0lPlZxIux2TuD1oA0beFrd0u4XIA IkE2MhGHOPwPb2p0c0E8rteIsqsSX3fL5h59OetAH//T+RXQxMWQhUflV549KcFU+WZWB4+YdQK/ 34P+b8W4iLgNG21E4B6Y/wA4qO0UIzGQNLlvnCnGQPf14oAL9ISySQtN5ZBBDL1x298e3rT7Zo9o iIyzH5VbqaAJJrZ1jaSFCNnVBxnFW4MNDGVYkuAQMdOlNJvRAf/U+Tph9nSR44yXbhzjOBnrTrHE q+S7CMysBuP3SPev9+XFrc/5vOdCXkDWVxJbLJBOigENb5ZBxnr/APWqunz3KyOwLJGYkLjcqbup x7Vr8KSY1JN2LU5itbCSeS4eZLeTY0lrEzqSCCenIHPf1pY5i8Ek8DFlLK8bgfeUjnPoaoHLlCKc lu+UGQyjkGq5lzI8squu1gC78GTPpQQ56WP/1flcYmmTzd4hZD868leOOP8APSo/KtPKJtXeSSOQ oybdoHqc5/Sv+gB6K5/zbjZFDgGSQmRFwqg8D2/z61BaQbPJlkYpNMpMkAOfL54z2pJ3QFxcibKr uC9Qehp0kOUZojyDuemAlvNK3mLOGEONgI6OccfrRsC/L0Udc+1AH//W+WXmEkSIgbG7ZjHNQ3Ak hhYMj7jgJjoOnJr/AKAD/m3KwULbsl3gjdy4XCj0q0LlHEUEcm/y49p2cMBjGM0AVUiMQCx7iinP XpQzSTbgrMpXkHGRxQBupGqxpK0YjcKNy5yc4wT689fxrLNxJ5srRPj950DHBHTiugD/1/lERhny sab85LFcnPv+VWEQwYR4jJM7dScxgev+fyr/AKA5qzuf825n6jE8c7RtsYkgKEOV6VYtmWJCc4dR wn972xSjHmY07O5WtpxLebZkcB33NsAVV+npV2eyWPzLreWTfhCw49cGhxaZUpXehXEYlbcYhluS QoVevYDpSec8W3yYtzKeAF3Zx7VJpdWuf//Q+PyiveBTEY3xuEYJIA7/AOTWjDvlkkR1MZjYeVJk YYY5/Gv+gWDVrH/N63ZXHSWx37kDJAW+diNpbB5NNvlSTaYyf7iA9Me9XdPYjnY0pElvEm1iyffk zwagkDeYscZ+RwDyfl/OgfOx+UhJikUOAdsoVsEEe/NV7a5e2lUtIZEjk3qsg+QDI4x6UAp9z//R +VLq7ik+dQgZv7vH4VXS7MR2v8okG0Gv+gg/5uW7u4TXIsiYpwUSRd6AplpD2x+Zq5Yxy3wd44Ss aR7ic4PA5+v4UEle7IgjElv+8MmFZAORzzVJ/tCzxuzbcp8sbDGRQBqJidNqqBLnIYkj8P8APpTL gRlthnhh2JuKSHDSkdh71lPcD//S+TAAeAvLDJ2jBA9aSN9u6NS2zONp6E+tf9AB/wA25eTBASR9 mD8uP5VG8apJIsf3m/jx96gCvHGUfc5O4NuHtUoaWSV5IyMkFWPHIPWgCWIxwLLGHdovvDd97NU1 u4TuR1YFmwCOR+NOztcD/9P5OFvZzuHeWZSikJHEQEY/7VKRDEn2W2jC57Ku0k9K/wCgA/5tyCxs bpxOZzHJ5ROzs+OgyPX6VK0XkLsIC7+SDyQPegcd0QoVQqY1UkAhnKhlOaaN43A8jqg6UGk9hka7 pCSWUjpgfL9K0mmhSOOHO+Ryd20D5RQZ9D//1PlBZTGjRwoFHPzYwaY0j28cWAzmYlWY/cGO9f8A QAf825nW11ILoQTRyXRU+V5cX3hnO0DrjrWktqTG7EGJt+0K/wAp/CheYFU2/luA4ZscknmtSwvP MSZRZhYlbZv8o5X8TQBHLIWXyvLYwxt9/bk/U1CVAlVl+6OA5XpQVFXZ/9X5DlzEZAGB8zq2OD/n FQrBcyBfKYEjuelf9AB/zflqOB1BEgZXU53D7p/CrAKgnHzFRgH1oAeFV1BYbX3fL2FQzxsjgbh8 pBwDmgCvJIzMeSOxx1ppt8jLybADu8w9R35oA//W+TJJIpUEiMGdeCeucVTtybid1dCSFwOwHvX/ AEAH/N+PuLUh4yPvoCFxxxUYBAkjUbZHXJkxyuKDSn1GQK0SEud248ntU1yZibUbw0KybRtXkA+v 6daDQsXFlmOXYXkXbkLGMOx7AD1P9a/K/wDbEgvLuO7miQRTWuseVqVqxL3zCUxyNtP+wYsH6+9f nHiu7cC47/Cz99+jer+JGHXk/wA0f//X/i61K0umv2h+yuqj5zP/AAn0988VDHC6TA/e2cY6EnOK +/xCtVdj5Ki/cS8joBd/Zo9sUkkJPzOEbqe+frWRd3UsU6tG5mAw21xlPyrikrSZ1Qd1YzI9reb5 wJ8xi5I42fhU1pbwXIZlly8DAYA+8O/5f1rGp0L2IL61kRg8UmAOw7iqNks7NIEeYdsv0fPv+Fc8 +htf3bn/0P4ztEvJLIqJTv2rnG3ofWl1nVA8ghh27XH7wnhRnsB/nrX0B4sdtTEsjEjb9wYFiDk4 2YqbVLWRIobkyQbZiWgVXBbCnByO3/1qCZtp2RixzzRPlZipIIyD8vPXIqeWOSVS7SGRFQEEjqaC FdvQqRyMmWVyAvBANWraTfvj3vgjcVblD24oNz//0f4qJoxBGrRcySHbtC8Ae5p8CrcSpE7AFF55 4FfQHjnp2ifDyXVUguItY0KxgXLTSX2qRQ7gewGSc+2P8aoeKPDEGiSJayzRyXEtr9pWaCZZrZl5 2kMCRg4zUc9pKGpcLanm8cKowyEKKflC/KQfXFXVuXXzLaLKE4Ifgk07tPyNSzNOfJt0nJVIc/Oq Zcg8mq8ey7JVyy5yE3DHHqaxBO+x/9L+KGGAtJJHgrEgwCOR/nrV+zjBmYOSkca4U44P1r2DzyS8 eEoqQiMkvlmzkkDtikdYJY0ZGAboQRgDFAm7FYSokJiYkljjPUmmyQxonkh2aJyHcP1JIoJntcHj jRVgjibJG7zQD7cU/a6DypWIJTI960hcyP/T/i1SOVE2YbBw65GAc9KT+zpJZczHemNxKnIHtX0C VtDxyU/um2RP8ijBA4H+eKQwOjRgnb5n7wOBwR61LkktALBWJsKPnw3X1qKYCF/KRd3mLmRhztz2 P+e9Q5sCRLF2HM0m1VxDBjKqSckj60StLCJIw3lq8PlykrmoA//U/izW3jhMTlmYOD944AJ6Gs67 huYnKFlZPvqxPzHJ6H0Nex5HjmvDKbq3d3yn2aMQrtHyg/4nmm2tt5kbyPwysAATjPvQC02JicvI 4jwsJ2BSME46kUgcSxn7NGjM3yuTwVoNYSbdmXYkgaJIyxF3CMOS3yP3AI9KzGvStywdNhI2gDsf UGgs/9X+Kea4KyHzYyGPEWOUYds+9XN9u9vmSfyJYx8sCrnzO2B6V66aexxuPu2LllapOvzPnnO0 9xVsWgj3JGyj1Pdayn8RmVJ3uIcpxISAFl6EVSuNOdoj5jqS3zl1OQAe1StAHWlpbooaOQsU+9G4 5PuDVidXkHmGQP8ANzuPIHStudWA/9b+Li4t4pICwYbgOu7GKpW9vJcyiPOVQYVema9bnieVPc6G zf7FKyM3Cj5Du4z6fpWtr/id76wsrBbS1VrJcRzRqRIxJOWY9zj24ptap9gjazucqb0DA8vbz856 GrEZ811ICkgZ2n+Kted9Aha5stYQRsJRAoym53DcL7EVmXM7r5RsSi7nMc+eHQY4P51PM7WJe7P/ 1/429NNuiSRu/mlcFmIxkkH/AArPudsEsjFi6OxKHjCg9se1eweOUlBl3OxTMZxEM4eQH/CoywiW IsiSvDNu3YyAPWgC1FZrfRkLJHFI7ZEpcIExzz/nvVG7itku1ha5yY48pJbyeYpbHAyOKiUla3UD UTfN5aP0GAHJ2j2zUNyywOHGH3fKu3GA3rUOTasYyVpH/9D+MKWQRAMpSW5ZQQ/DLECP51QV4Y2/ eJuHR364r0W29zw6fYnlitLgxRxMVgUkY+6xzwDU9taWsDiJXaaM8yfN8wNI0K88cUgcRuFaOTAB bO0U4ws0YHlLGETJlB5Y5oApz3EMsaW6GMyE4cn7q4qrbhZG2syrjj52wAOlAbH/0f4r1hmWSOOI mRAckg54qW5MwSNSWEKud8YbaH9jXoHjleGaRfLf541DkANzjmujtlZ1LNIrFRgKf4aAM3VHmbb5 a4dBjk4yKpwyqn7uYP5jjBKj6VMo32N0rKxLPHs2q0bOD82c1e0uFpJ2gml+R13BCPu/SsbW0Gf/ 0v407jTfKZ4UytvtzzyD65rlWkEU7QFmBkbyowg5Q+uK6Dyua0jrFsmmt1cTvM6xhTJJwzY4wfyr nZ7cRSEEDCn8vwoDnZDcRwxKJpWTcwwkaHk++KqZglxMHdtqFBG33QfWggmDJKIYY1RVij2kH7uc kmpXihlGY9qOQI2RBg8d8UJX0A//0/4pDBLZxM8TZdvlweOlWLZ2mnyXkijRf3rRHDn1xXobHkxd maBigk8yOW4dl2kxNIC7t6Z9KzDBOkiqxB8s5RzxtH+RWUnd2NjQCQ4aSOZhOhGUK/Iw+ufpxVO8 nnj5BKYIIcDKioAyLidmZIihKq4aQDndnvVlFlV4EtwmXbGJ2wv51pPoB//U/iwWWRQXljVtinew GWIHYUi3sbDzFXKKRlW4Az6itpfCzzy6t1FuKws3zR4YMBnkcge1UJNsONzFWJyB0z71nBXYEYLS yLMqYCZBRuUYetWlibYSLmMI4LbONydcgenSnPcDOcoGeMD5RwD6Uqp5ZUmQYH3VY9fpUAf/1f4p PMm88B2YxNwVQdvpTbyFEG9V6joe1B55HBO0Y2SHykz94DoPWlRLQ3TwRy71CeYTHhyxzzk+9But kLcWaiRVhEi7+rMdy57kf4Vo2dzHBHNHeJ57fcQHJHoDmgZQe3h898QxuzJlUI3AegP0pWuPKCee d7qAOBxx0/lQB//W/ifMztIsjM8SqNypnAb3qe0mjuAY45gZDlvLPJP1oOciSBMyN5QBC9ejLj0r MnaVZJCjExOgCgjkEdealwTM5voUVhIkDxBm+T5nbrnvitfS7trGcSZBtsGOeMjl89h71iTyu1xt 1cJK0kEcxiLD5cDnnsa2IIYkiiQ3TyAwgsE6I3PHNOO6LUVy2P/X/iqciJDCGLOTnJ5JHvVMNFID IAHVjg7154OO/wBDQcnIjZ3RMu93VcplQvJasxJLhpHjc4tnfBRRyw6de1BHKyktqI52G91RGyW2 7sA01FcK7vcyF+fLdeHHXgemKDSMeUT7aFWCFkJVmJ4Tke5qUM06yIkQXeNoy33vqaynvYaVj//Q /ibktdkezJWOE5cE/fJ9P896yp5jKjQ/dDP8hxhBjsT+Fc9raHOaiwi2VHZLZJTEN3ky+ap+h9av RyLPA2ECfLy6jafxoLp7mVLH5i7goEif6vPJbHrWbbRuLhiy7JFO/H8JoNTWMNrDb3VxI1w1/KN9 uoGYl55z36VnLLPLcW+6J2x8uAvCnvmgD//R/icks1vIZYGkEcyNvUFeo7iqFnZ24nXzZFKRn5mJ AA/zxXIprqBq6nZR2TRbkQySIJrcMRyp6HA9ajE2kpcx3kvh3TzIseyRVMmZCB/rGJJOfpx7UufX yOgZJcRoIpbZcW1y5baPuxdeB9OlZTwtO88jjgtiLtkVd0BcsFFt+5llclux6DNF7EFWGOAH90SQ VO3aD1pRlzEv4kf/0v4lY4lWOORJHkYKc+YMDPQioUgX+NIwjcYzlvqa5ZfCzoMi4090lUGQgbt0 ZxgGtUwMZYXMw/d4LbPl6deKIqyAmMwNzCbJFE0Moc3Eh/fN0/LHPT1rU1K2e4W3uIkBkLFXD9ex z+NUBmzzMqyeRJOXdNktqy8Rbc8r9f6VneRJPaQIAvmysyyFmy67Txke9BpT6n//0/4lkjsYLZpY LYeVGojnXlckDGfzzVZLaGD/AEgM/mE/ukUblfPY/hWMdJI7FFNtFWZy03lhSqqdx2jDL7VNOWgj i4D4JZEK5K5rSTsiZR5WMt5VvjtDBJImw6njb6VZul+zFEaQPIPvlecZ7CmmmXT2LCQxzGGCaSON 5cN5znCRr2qheXEkO9EYOsPygg7gw9aZdj//1P4fbZrxisyyiBSc/KcE1v8AnPeYM0gYn5MrwR7/ AM6iSbaR6sFpcmawkwWDCVlb7/Csw7DHtirkQim2htyyg7cjjp61SVlYs1v7Q1nQIpb/AEmQxOB5 QlVBIQxHYd6oXGq6pqGhxafd3F7Le3d0ZEjZdkAPLFiM/eIByf8AGoUbTNZJKOp7V8Apb608SwWU FshG2Vr6Od9whjAA84c+pGCO+K/cX4Y6NapaaNdC71Itd7NM0aFbcSspkUBWKA4AJfp0AzzX9i/R thyYDHVu1/yR/Df0jKyrcS5fhuzjf/wJn//V/px/4Jx6RLo3wr8MWdwqTroegQW7Sx5H2hpvvMx7 4wfoaP8Ago/r1zoHwl1+6t5o2S2UiCJuY3MkMvyE843DcM9q/TsucMZ4sTqdHXv98/8AgniZs3h/ DeMFusOl90D+H7xpf3GkeGNXsb9IILzS2S8tru3uAUSTziPLcY+bKuT14K9Oa/AL9pSMf2rdQzSs 0o1eS4t5ymyORDtb5Bn0bBz3BPev7e8c37Pw3rJdUj+FvAaLq8d1py6NnyrEpmdo42AKdWbgGups YREY9w8wnhjGPlSv80pxTbsf39D4kddaM6oEDsiht2CuQ49K1NStoVs0jjtJIjNFvYxyne5PcdMD iuKUTY//1v4wbB7N7YRyEpNsC7n+YscdvXpWpZ2lqt1IPsTTo1kFW8kkP7qTcN21R6jsa8SpG2oW OosblLOHyVU+Uf8AZwQapTSXELySWywRxT4DxFd7yYwcnPqRWHKtRrfUgu/FGrRySC7LGKBF8qNx i2X+9g9umMdsVoLq1vcSQ3ESeUJXXy42PmKM4/i9KxNzoJJbMsFV0XAy2cAJ3PFZ1wkaTp5LrcLP FvUofcgj9P1qJRu9AP/X/kYtisEinydgZdsiZzt9TmobUNp2pbmnlltr2UuIncyxxnBPH90cV8i4 uJ3Rd7mhf3HnSLsEYQH5ZQQea1NPIEBW4UM0jY2r0kx0Oa5pKzKJFgaPUHW3hia3MK7NgKyRMOTz 0rrtJuUvriQaiF06wsrdGlmj3JKSOBhffGSc+vHauev8BMFeDP6cv+CFvha91yfxNqTxlYIvErzw vcMVlktgED7e/wA2D09K/ts0GJIrCyW3i8q1jtY0hTHO1VAB/HrX4JZT40xk90rL8NTlwS/fVH52 +4//0P43V1LUYLh7j7HPJawL++1CIhoY2J+VMdv5VC2pTXkMxtYmFxIdkQOGZSTwQK8JK8WeRTh7 ti3LKNPRdLu/s95qFpJ551a3lJbbLGm6D0+UghvfI+uSustpHk/ZvNjtluVFusSbltnYhd2ew6Zr O2tylB31NKMwR+al80VwXcyR/wDLXa+fvDHrT4JbLUdSY3m+2ms0jC6gpLDABATaOc4FVaxoopGZ 4ovJp7qz8udhHbsBDIhKNIqdN3bvV+xgSJo5GgkjtZhvYyLgTvjLhD39cihJvY0UG1c//9H+NXUo 9UsvD0d7Bp9vPp9xrL28lzbzr9pgKLuO5c5xg9PXvUt1BZWKWJs5xPbXEKzjDDzI965YOo6ENnj/ ABrxIwtqzjcLIyrRr8fafOWGRjITbz/dLDnAK9BjjmprS+ngv4pLm0iNtFLiRlOTtPcDuaszIdQl ibzriMedBvKLlijIWzg8c5701YLIvbefcB7hxuaCJyJY/wC6W+ta0lqB0yxRbE5YGBdwVj2A70+2 n0mCWOaS0eWW7fyY3t4zIN+CQzHsOMZ967qa1E9Ef//S/kQdIL2y2TQ2AnRHLzTTkGIYOMrn26YO T614vq9tHGI7axtUiSFMSSIuzzmJJJA9On5V3UXZu55kW7XOFaSaO6Nv5YKAYB6r71+kf7FF66Pc W6Wtiz3N21ndRm2WVLnyxE8XOO43jg8EV+ueDlRU+McM/U+J8UKbrcG4mP8AdP3l/ZNWHRfjX4F1 awGl2N614NP1XSVv0juIYHR2RfLY5cF4RjGT8uPp/eD+z3em9+Guk5jIkt7dY2k6q7MBlR7DFfpH 0m4c31SfZfqeB9F1KPDWOgv5/wBLH4lf8FlPDMc2n2l9AI4Y9Iu4b2TzQGUtvUkr6MSg2/T3r+Y+ WK8WWOC4e7uLe0QJLcsv7/b/AH26ZJ61+r/RwxHtOCfZ/wAsvzP5d+kTh3R4+r1Okrfof//T+EyY dWkS6W5uJY4SsTKpKK3l4A6deMVja6IpNRtH81FigQwwoZdxRjjOT6jpzX+ztP4T/Gur8ZTiu7Gz uo98S3rrhzbB9rTrnBGQeOvWs+9t/OjkuY7Xy7WeUSJAJS6AhuFx1IBB4P61duhk2kjrPDVt9ska 1VYo2SITrFNKI1kZeu1T39Kqahc2UmoyWT2moxyblhVzbs8crkfNhx0Gc8/r3roWmhhsc89vbX18 Y41KQ20gtb2F3P8ApBB3fMDz6fl710N9Das0Mcgt45guY/nC3EqKMYVe+PpxWsFoc7avc//U+DNI 1+KzhaxvdObUIYGL28sdz5W0t/eLAnjgED86o6pdWzvZrcbt92fLlW0DTQwsT8uJOh69eOlf7YH+ J5Q1OGaKe2VpZ1cRIQsq/I0fbA9x0IqxN580Bt4go6EtIf3nlgjoPargtQN7SrwwK8tm0cksEX7g SkIGYDHXn9BUWnWOsrK7C0udR8+Y3NxBGSRHvPOG7c/zrUzneyRZa1+zw3Vld6ULa9t5BJCJefkI 4GOgxx71hPqKW1nPbyiaSRyrWwEW8cH5lyen/wCugcH0P//V/P2W5sP7SVEs7oRy26vJMV321twF bJB7kjj371ovYWR3R3Zlm24ltII2KxzEHofpwfwr/bymj/E2S9007GOSG/Fx5E9uQdv2aKMGCRcd M4JBGB0PWmXN3Gk8v2+zjcXbeUTdxEpbqrBlZMdCpAIPYitDnkro17SO0urZrRpQ0UrFZpsjzUxy D9R2rKtmkjv2gsWN1bE7JXnP+kR4Xgnj9PShK+hiN1Fb/U9Qjtn+ZLOIfuoV2ySgHcenPQ8+1Wpr q4fyrdI3ZmG2JC2OcelbKNncmfwn/9b4eu5v7OhRZJWiY24a9jf5HOfXHY46e1b+kGC/sWubRXjj I8srsKKSgBYp68HqK/3Gkm1ZH+Gz2ZS1eW1mSC2juZmEvzQwXyhCpUAFsjvz0PNVrax1Bo4oLJVn YIGu1WT75AILLn3P5U0rKxzSdky3pEjzXEsKQmKe0O6QY+9nge3tirGoaxbyfbNK+yWhubGdImuk YkvldzEdsfNj/gNM5JS+yRaXd2dhLNNO8e+NdxUnIA7nj6VRv53mE88Vra3JvGL2/mOyRQxt16HJ xnIz3xVwvc5pfEz/1/i63mtY4BDcOqmKFfLdIyEQZ+6Djt6U5YbF4ftM5nDK48pVkPkOpyCWT+9n GD25r/dA/wAE59iGQgS+TGVweASOx9aPMItmhMpbycR20LAGOJB/Cp9M5OPegzLNraO9zGiquy6h bzFwcx4wQR+X61NNAllcW3mN5qqQ7h0wqYP19q2i21qYyVnYl1RbeV4pIhG8kozgDBAGMcf56VnR QacsrPcynY0W1ox8y7hnkgd+1UD+FH//0PiydwLO3urBWihuI1YxNyY+OV+oNb2kWdvPZCafc7P/ AM9l8s8HhgP61/utGV9z/AOpohPENnbWEUKpFm4lj83g/KynIyffj9KwLCRtOZbgRSKCm5YtuGjJ 5BA/z1qjjL81y07NOw855SGkZjhv/wBfSsW9aNp4PISUEr8+V4DD3HtQJ7GiovJIA9vCodcqBKdv mbTzWxNYTLYwyzHa2N8wT5mQVrCNlcwP/9H4mZJ2QmGQyxmbcZ5TztJz1q/JBIIYpEyUHVh901/v Af8APeXbdYYYTK8cZ4JX+Fm7cetUftNm8lvHEQPtibpIiNjQsSRj37H8aAeiG21kyXIDQq08DlVO 7AZGwfve+Aa3Z02btQunht/KI2AYUZHCgY9eKqHxI5zJupPMBnMhbdzz93ir1m9oVAvIbqeYtkXC XIjRR0A2lST+dbJmU272P//S+Tbuymh+aL/Sw8QYBeZQT2x68dqivJJbF4rSOEiSS3E13Ef9Zb5+ 6GHYkc+2a/3oP+d8zY7cvzMqyKDkAcbiOhI/Kp3SVvOlKqFXBZVwoHYYFAGaxMkhzFujVhiNTuP4 1qLZQXCziOaG1Aj/AHck6lnByCVGAcZANaQetiZaRZmIH5XA+XgH1NaCMhRLVyXaVfmkXI8rBx17 VoYn/9P5F+xxx5Vpt4CZBx1+tVymFIiyrKDt2j9cV/vgf87fJZE6X+nyrbSGZ4UhURTLKjAl+hJ/ GotRv4oopI7N3R7uVIUkYbggyeSPz/OgzNmWKK3hgWE+a0KCZ5WYZcNhm+nfjtUVxqouHmSPMFnI cpbK2QME7Sx7kZ6mgmSvYsf2ndXcVrpYkaWC2QyHzHwqnB4GfQdBVCdftkLRjYFjzk5Cv16++KCZ R0uf/9T4ulEqFI0kZo0GCrHJ/wA8V0FjdRxQLIjBnhyXVD864r/fOCu7n/ObJ2iNknW53TvEwebD xrMOYflAIA7dP51TjEyuzYBUDaflyBnNamJI88iRMjA7AMB24xSQ2qx+WkZjMhxJLIoxu3AE0AS3 SooU78sflYDhlqza20s8ayPdxQwwt+8kmbOxByRj0+nrQZTbvY//1flhhY3CTz2l15kay7I5FjKL IR1GDUCTyTStbiCNY3IBLHCR8+p/nX+/B/zfkMzW1tM4TqibJPm3At7Y7VXkEjW7zKMRMQHOfmGc 4469qAJ9NijuPLiDjaPlZ+uwVYmga2maPcJYhwHUHH60AVYozDM7IzN5vHls52enA6CkeOWR4gI1 j2nYTk7XyTyT/npQB//W+WWgtZGQEExwcsSeSe/4VSiMNxNLGq5jhG4nIDda/wB+Urux/wA35O2J omRkaJN2MfdzikH2WK0ZYuLrzRu3H5dvejlaAYYVkZAWzxuVT90euKX7P5TswAK5zu7jFIBs10VU B1MbTZSNc/6wLwSBV+BPLjhdQrgnA5GVP07VcNLsLH//1/meOJ7tpPLj/exfeHGSOnAqF7EIWOzY yDO08flX+/6tLU/5uZJJ2RXRoQyzP+8lHyrERlDWRKhTc4dQGcqqbgXOOenX8adhRdncmsTd4e2h nMP2olJIi22OfI2/MDweOmav28UtvaPbw3BZCMTwPGBkr0KtQVJp7EcN1iAiOERPHnOVy/J+8ame B7kKXZZCjBt2M5IPpQQf/9D5gS3EjlE3blA3KOcZzVUQzWzOBjhsA4xX+/kz/m3IhG3nKz5VMEs+ M89quQ+U42s6xSyt8sjqSB+NKnuBUmlRTshcqc7HJ4yR6VNbIxh+zGQmZWy85G1GzyBj/PWtQJ1e KyimSeaDf5oiEUhy7N1G3Hb6HuKpvKu3jJJPJ6AUAf/R+TXmMMkM6DIix8hOAw75FX5r4S20guEZ riYLJZKOFYK3P8v0r/oAP+bclhne4Kaf5cKLOy+fJIAGUA/3j0/+tUHmWenMYYYlhCblkkJDNJnO Tn3zQAAQFRJFKJQ8ZMiqCPLOT8vPXt+dQQ5OTECAeoYYoAJpbvzobfaFW5YRtM7fLHnAHv8Al2pJ LNbeWW1ZwJogRvX5oyRnGPUHH61anZWA/9L5djURQqJGBlK4O0Y/Kq7yNGAASVAxyMkV/wBAUpXP +bcltJraOaS5uInlZYSkCjkeYeATnqKolXkaWfBDIdxXps7VVPqBPtXYsrMiv2GMM1QTxz+YhmVz E6b12k7Cv8q0avoA+S+iCGO1cDHyncORS28iDCxncx65rGSsyr+7Y//T+WXgGd8QIkI2k9yD1x+t VftccMqwkbXjYszHngY5x7c1/wBAB/zct6WLBCu3yTEhm+UOeOTUV0vziJfvofmx0P40Ei2txFcu 1k+2AR4eR5FJ3Yz0wPrVkWp1J3EUa28SzeRCzYQPgABv5/lVwb5gKKQWrNs8071O1h9KkvIbOOFo REzl/uEnlfcmtQP/1Pk+w02OZGIdd0a78M2PwqOWIo5RiDtOVPav+gg/5tzPunkuJEM0X+pBVZd+ 7I4xhe3SrvW3RY5T64zjFAE1mCv+u5CZK8VRu3mutRW4ZsW6psjjAxt9aANRpUgjygy+MADg/jWf PA808DyoXD8l85aMdjWU1qB//9X5QZraHBO6V16HsMdKjFxc3LKwgEq26/8ALOIRsQO7EAZ+pr/o AP8Am3LJVZhv+aL1VzkiiaVEVEDBiBy46n/P9KAGIzNwwyCOGx1FXYbVWt55QdpAwozgn6flQBUt rGeRDHEPMdicA5Y1XMDeVh42R1fMij7w9qd3awH/1vlB2toCr/6vOFGepNU7i6WKdPLPzk4BQZyf rX/QAf8ANuXIbrCyrKWik25V8Z8w8dqjaNSiyzy4JO3B4PtQBXuLi0iEaQGRnAxIGGFBz29qR2yq ZJAYcev4UAOS1mOGWQqueVPO6leJ4m3cFyeOOAKAP//X+Uoi+DlBlhwMdP8AOaWC3dllM5ARGxFz zz7fga/6AD/m3JbOAJfyyOECbNwxwzMF4JP4Cq7PI2YbiQsUf5Cg2gDOcUAWZVZQMjcMY4qMag0K G3jZkgf/AFi5wCfcUDSu7DVmdY3CsfLbl8dD6ZqCfU/MSK3RV3IMAKoDPznJ9aDZRSeh/9D5LulN yEAVVKKFKoMdB1Puf606L/RI0BkBLceUFJkHoemK/wCgA/5vy1PcLLCoOMIMZ2gVShlZI3HysoO4 Hbg+woAjmuA6o5byxu2Lk4DH2p8UQaUOclguN2eOKa8wK9xczw3ACW+92G5UKcSL0JH056elKssk ikSRFc9FI5+lID//0fkNEVEbauO5BHQ1ELgxKHGVdZACAPmIzz/n3r/oAP8Am/LEl2kjrJE24DAY L1U06/u/t0ccQiignVNjTxLtaTHQsPXGPyoNKfUjjt/LAZmLBRtKEfrVtIlZCMjAOR7UFSdkPEr2 8bupLFeWKD5gMjmvzF/a9tINK1bUZZ5X/s+dRcm6kYbpC4jIJ9cMHye+AO1fm3i07cB47/A/yP6B +jVr4kYf/C/zif/S/jun1rTrid7hiZIg3lAIuGCjjj61z9zJZtKGiUxwyMWY/wAQr7/E/wAVnx1H SKOenu2lcBMjnAbqPxqebyo/LBmMhkQGRyuCh7iuWUb6o6Sq+6MyCF96leTs+bAp9s4hU+UfvDaA Fxz9KwnH8DdbD5URQfMkfe3Yt8g+goto3VlAI25znsawaurFJuOx/9P+L26naJFVCuScM33WqjIg uIC2xt8ZG6TPy8/5NfS8isjxo7IjigYqETlsZJ7etQ3bhYVTHmzb8KpOAgHcf571Lg0ZN3dyigWT a0qlAG+6DtJxWxHcvvCqqFVAGFX5fSoBOzuO1C0gaBpYz5Ltj5MY3ZPNZygqyjCgqAoC9cf5FUot rQ1bsf/U/isYoWSIZLn2yBVxIYLWLzHw8jdX5BT6CvoDxzK8oI832aaRY5W5i3ERg9yB71Y8iOaB 7WR54mZQpkjmYtwcgc5wPagcXZkN80okAiSJSAEZwvzEAYp0KxxgOzEvnB9aDS9pWL87xyRrCrEy lgoXbwox1J/pWYHIeSEEKwO1N3DH1xWco21Q42SSP//V/isAnhRo2AcAb18vuTz8xqt9ojlWSN3e Nj8rKvH617B5c30RPHbAxHyHVnVRwx5NNgSVmaGRlWRjlV6HFBF3sILYxM5IMhDffY5VaawkeRMp vUjChOpqkrphd2saKyJF5aMXK9DlfliNRvJEQz3A53bVdfukZwMVcE0hH//W/i9muY/3KKRgKELj gU9bgKsixv8AKGwz9B6V9AeOVbiykMUrrMVDKAVx8x5yeafZXUDuizFkVUEIU8qT0z6//rqHBWsB fmgaNAlsisyZZnx296yLadSJNuN2c5I4aplGyQGlBfGJ1LFd6P8Ae7enFSXMzTI7JGrx/wAbYycV AH//1/4sDN5s8ceB5aDBB4/CrRMf3fLWVGOwnuvPrXsHjlmGKztpWs0JkeWPziudygDnn06jisy5 ukclIG2CMkls4Ln29hQaRh/MV7e5nLSPhyoGOm7NaFhbLC52/Ju+cpuznJ/xoGklKyK+pPfW8zMy BF4Mcichh7+hqKNJbkrNIF3heO2PfH40Fn//0P4oL1i6iJ8jZ0KjH41PaW24Ip3XEgGVz1r0oy5T kb9w2Z0MHktF8jKPuKOp96rC/wB/mMM+YDjgdMUm7u5kWIzHdLj5t8XzZPyhuKq3Fw8LIWAweNme opARmWZcTRKhRvk8oD51+tQRzLMX2qyMG2yFvuk96BN2Vz//0f4tGZE4YAZQY2HOTjrUbxNbxRyr KQ+cuQOF9K9A8mTuxyl5MMzKwbHAPFE0Ui3IZ1VYichFOQK3WxI+W3QK5I3+YpEZHT61LbM0MkJT Y0iD5kbgMB2zTKjo9R9zfzGa4tJSYlljIIhfcpB5xnrWMbxwxhA+78pPsO9Anuz/0v4t7CSSRXxh g/yhkOfwNbVxAvlKHIbBwSOcV7B45jXj/Z0Usirg/JKp5P4fhV5GjS1VsIPMTPbd75oAppHH+8eM n54jGBnJHsB+FUrezVZCrxYVMcnjBz2/KsHux2drmtJcxxMLcZaXbuO48MKoGUSDb9nMITokfKgU iZK6P//T/i0QFI3d05Azg8ECobl4mtAW2IC24lPvemD+VegeLGPKjMeTYybGJUgEbTxV4XLMIVWM LjOHXO9/XdQVYfFBLNk7lQM3J/i49avqtzJEqKwXYMZb+ICgDOj06EtIzOsOfmx/e/GqTJCwlgSI ySBwyuxOFVc5GO/b8qC4K71P/9T+LTTrp4ZRsiJ2jO9h8i/SrTzwyN5bvjc+5mb7qknkgV6B5D3E LRQlY5AGTfgSKPkYetUkuAZrp4S7wq37hC2Qcdc0CGSTXE+37Uq7v+WWwEcds81CDIkpaXgxLkK3 CsOnHrQbOaRs20sLSAysxQqCFYD5c10Sz2dqu6NI2kC7hyC4B61M1oJztsf/1f40D4jmtbuKZbZJ 4i210lUOqjB52njrisu81431+pSzt4XByGihEWMd8Djmumztc8c6O0vhPbmOTbEQeDHxn3rkdZzC 8wWYlcjYwXbx3pAZG5bhk8pH86MDHmcK4PertrEYN/nBRIx+aMkOvPagBRBCrFgHiABZgBnJ7CoG mmEipaReZLIwVV7g1UF7xlNu9j//1v4sPOSGN0lid74MVdG+4OOn1qhbXcsNv9nW1RXlnLO5J8xc +/4dK9A8SDurF0n5WkBlmm4EbLyq445qzNcSmGF540VGIj3DCsSO5FZzWlzVScdireWjAMUciMrx jhvcVHETLGwnGYtgjUZyQAKixpGXM7FZII45CGfCscROxxj2NX50RYo28jEqAhWByDjv9f8AGtJR uO6P/9f+JyKeZtxbKrjDI/UVSlaRZ41jyY34ZRxk1u1dWPPNMA2YedQZHABC53BfUVC+o/2lNgLh 0GMNw2BxioprUCeITq4h8qQpJJuY5wsXHf24q01zAxuYzYrHIyLGlwG28L3AHrz19ac1dAZ7zQgy RsqyZQADkFfrUfkuZm+UlVgDqc7l55AFZAf/0P4lTLOtwh2tHGiYcdSxPepJp1CM43OB/CeSx9qD z7D4rlJbXM0aozLtjQ9VxxzUccJtSGRFweXkQjbQUr3RqxR3kpzCIpkwB/rMbR3P4VFEyiVlaNZF ViGViRkig1V+pZKiMxyLiJgc5Pf6+1VJRFeXDvBt291HI3d8e1Az/9H+JG4Wdi0UqMFTKqh4xVxY GtILeRIhG2wtv7t1GT+RoOcswXQuLdnIG9AQwj/j+gqC1topixLsAOfLxzn3rNyd7Iicb7GvFbWy R4wjzEYGP4fwrCmjw728aKpZ98gx09x6VmUkkrFKKGJgXVJN6ucuy9ccYFXbZ5ZG8uM7WjO87zt3 YHSmtGM//9L+Kuwmgm8yJYTLqDTHyn6qwIwV/Oh5IsLbfZwJGJWVs5Oc9qDnKrXKW8m0ouPuhd3z D3xTIp/s5CyyeazSbsYA2gnNAFm6mjdXWJApJzvByGqrG0W1o5GVWjXLuOd/07celAFGVo45MoGZ wmFJ4U1qRRo1vlGDFhl1ByKVkB//0/4nZZh5TJI2GQYVT1x2qrtWRYgApUZ80EZJ9PypOKZg01uW mWGOLzlUho2+VBkl/es+W6KPiEbxK2DGDt/OsnFoE7DkvGgnWJowQOTuXBOfQ03zTaXUszRic+Xx ETtPPIxU26Gy2IpJbliCqkbcs4P/ACyHt9KtxnayiFmclRiRhtyccjFSk0xn/9T+J5rgys0duiLc YwzsenGKlvNNggsWuZJEDMMJErgtKwOCCucivPtbQSM+KEyW++Z2dusLMcmMY4UVFDNi52TFtoXD cZ3fjQdK8zRAsoIhbojOZG3osZysZJ/zwKmFv5bsDDuKAMu77hzQAkk1nIuBAscsfysR83zDqT/n 0rPmVTGyuH3iZZYpVfEbrzlTTTa2A//V/iVnfylnmUBYkIVIS3Q46D8arJNFKoklhaM5w0RJ+nWu C72OgTUUfUJIUt1EYtvmxu2q3TAFWIZDC7oNrMibHDjKZI6UJtAZcaz/AGiRl2JlDhycJGRzjPrW /FrDbIRGyoUjxNI4HJHcflWydwGTSReapeRv3iebuVcbwfWqxKRhpYU3Sj7uelM0p9T/1v4f4TdR XIjY+WLhidh/1efStqKxuTPGpdViB3FV+bcfSuc6rPm0NB7GO3kYMA0rqHcn+6egp17FYW9tPdEB YIEXZEzb7iRm4wo785/SgqadkzGszEZFeKyUTSnDxSkq7jHHHc9KqXkEjSkfZ7m0JJ2iVCuGHUZ/ pRsKDd7EUM08++GT5Ut0wJmB+YjgAD3pYvtLjypIEKt97ByGX3PatYdTU//X/ikt7Syki8qNl3hM qrdVx2FXNG06Ff8Aj48kb7jAdjkAZxnHUCg9eOyOm1CwtLW4cWt7BOZCViwphUhf4gD61xM9zOri KW3WMC4LGdDuYjpg9u2fxpxTkCkr6HSojiFtsoZAmc/fC8dcVZe8tYjpwkiXfGDGkq/O0G7qx9M5 NOK96zKqPc9g+A9ouqeOZ4RauUu/J0aGWdWV5RJOjSlMHpwPfg+lf0FfCHSoZJfh5a6Vb3GlXlzc W9pLdSwm4sbZo/mV19d4G3B6Fq/sn6PsFR4Zx9e3SX5H8K+N04YnxEwWGl0nBfinr5WbP//Q/rG/ Yrs7a2+G2k3CWyo4totL3wqUSVY4VbeV9eTXx7/wVe1e10f4P+Jre6vpLK3uLB44LlmLQ+bMGghL 46YaQDP+1X6jwhQniPFT2UdX7XT7z5zjavTwfhy603aKpK7+R/HF8YBofhvwx4nhZX1GJNPWzsp4 wJ21S5lHyykgnBXrz6V/Pj+0FqC3fiWa3+yTm5sJGtH3nasP7qMurqT1Jx2zxX9peP8AW5PDyUO6 ivyP4r+j3h0+LMRVTuk3b8dT5stldGIYAbuueOK7fSWidfKZkUcALn5nr/N+ppNo/vGHxI7OW5tg UkiiU7IkiETfdBUAEge+K0mju5zLLBLElu1uExKnzL13c9vTiuN7M1bsf//R/iys4vn8mHYpB/1h 611Gnt9nVUlkd2Q5ZmwN/wCA4ryZrVohztojQNxJeB4LR2t7hU8y3mKfIH7Z9PWpLWWLTreFb9BL qSRkrM+WjmYnDMfT2rltbQIyvozooLXR7pIW1CCK4tZXDXEBOBMByQD+FVra1sW8+7jtVtbNZ3jt IUydigkAc9KznHsa8zSsKsNncWl3dLMizpdrBDaBTl49jF3ZugwQoA/2qr6d9k+3WNzPbTPHbux2 CTyiPlI4/wAmswjKzP/S/kWD+c0rsSN2V2gYBHYUwadPePBDbeZBJHuMmzBaVcH16Y9utfKzXunV B2Y7TLaJkmhMM0bQOd3nKVVueqk8HPtXVWsMaWMk0Us5k8wQC3mg2BMdCp6n/CueUbmnMrXJdMjv 0a4F/BBbbJCsIhcu8i9i2QMH2Ga6+yvp5YNSs5NJgvLU2Pk26l1QzbgS4c/hj6GuHEvlg0Ok7RZ/ Xl/wQt8IW0nh7SLu2judMW7XyvsxjdkuJN6o6M7e6tjHYH0r+umxuMRRReWIjDGsPlqdwTaAvX8K /A8FFvibGVG9XOX4OxzYGMlUqX/mZ//T/jqe0aG3khQGDyJH8yPdujnXJ+9/ntXNWUsNxOYNN8uG 7guPKmK8FC+MAD9Qa8HXlaPOirJFm60xYvOtZndZfvpOjZkDg8hge3tV2YA2CtNAvlWp3yGEcAAd SPfvSSu7DMSKU3V1I0ULLlt+wIVT/gPtitVrG7lZ0g8sDAJO7bu/vfiOf/r1ryq1mBRu4IbmNbV5 ELQjO5G3NycENz7U7RHm0JLawlfUtaMru9m16waztHYnameoQAVSVtDeOyP/1P4v9QmF9Isch+yS iUtc29mS1rKOhAbt2q3P5Eccccdv5MW0bMHOMehryEruyOWTsiS3jM3mRIGiSOPeQ6nfIaq3tnNG mIFmmDYZU27Nx7qCeOv5UrWMS1cWXlQCxbFtOyJcTLImXjPv+HpVfSruLZqVudPivLeeaO0k1JiY r23K7mHknqN2MH8RW9PoBsWlpIkoSXzA6Ao0JYvuXoA36Vs/6GZUSxie0NrhZN0ZiRD/ALI9a7af Umbsj//V/ka0jSNPiju5b6D7VHIpkPnymM5I4AI6gdcd68N1e7+z6pPbyiUAuRlomWJFYnAB+npX ZT6nk/YOIukjW9kaN2dBJhT7V9zfsZa1bW/iBYppnsbSx1QPcAAxxOrtGSc+vynGPev1Hwqk6fFu Ef8AePluP4+04UxMf7rP3v8AhFq+m6D8UfAOoW9tLLPH4nt5BMsazSPE+VwZD2wwPXsK/vW/ZjvY br4caOYLpLtbq3W7jkVPLRVEaZUjpkHIP0r9l+kzRX9m4OuvNfkfG/RdrL+zszwnaaf5/wCR+X3/ AAWF0WDU/hVdyG8/s65nBvC8sBYNJavHKilh2IfvwOa/lnutVt49NjubxA7TMkTsq4Ri7bMn05Nf b/RnqN8Hzj/f/wCB+h+B/SYowjxf7WL1tb7rP9T/1vimTXLCKOZmgjsURvLjd2xHIo4yv4989qzI 9G0mNbq6ubmOeeT99CX+6d2Pl47jOPwNf7Mwk4rQ/wAa6nxaEd1a6fDpvy2ESz5+e6RC90EzkgEn pxVJ/stoLe9t/PuI7SEyiDYHRtwxl4+ckHpmtzCa0uSWv2cwXFxeZtJIP9Ihkz5RAPUE+mOavTiR oFniLJeNH+6cNtJDc7gexweDW6d1c55pvYyNKigguGDwLcsctJO53Mz9Du9SMVeubV7799YwLNPa OWhcR4lt+gkw3UDA5raD0sZNdGf/1/zxaG8Mgs0QRPcApudQq8jnJ9B19qW2zp1q1r5kF2scvMyA 7UAz8oyB39a/2wP8UGmnYWSCAxzatLKfJRFO4EvGvQYx2HNdLpy2+rragRWsV7Y28qNLI4aK6hfa 2MH+IbfyzVRdmI5618yOYBIPKjjnIjA5VwfpXbrFqMGnR3N/dWVtNJGH8qGYy+UoPuB1HQda2Imt DGNwsouBBISZ+PnOZ+mCc/ypLbSjOCZLctAoH7wtliwxnGOf/wBdBEXa5//Q+O7jTtN2NeotvY2S WawSWEjMfOKfM0jux5ORkDjtXKyXNvNJDfQXLSRlt8YX5WTnqK/27g7aM/xK59LMkstY2XcySXch LyeasRAZwcDj8cZz7/jVDUrjV728F2+p5tvN/wBGsJY0aC32jBzxk568n1rUycktC6w1GIzQlIRP C3mEWabFk642gH8qt6ObrRbwXs/lTRXq7Jobg/NGW4B9Qf8AGqjpJGLeupYtP7ROrXuoQ3UdtuBt re2RfnClSrSb+mCOg6iofspmuorOa58uRz5bTh9jRk8bge31rYiex//R+J9TtNKsLyLTBLNq05sx cvO8guY9oZU+dh0Yk9DzxV6+jht5Y0sHELxW4cQK+MBh0/PNf7kH+Gk3ZWMxbea6tmuJA26Jivly /eYZ+8Kz0jc3kAt2MckfDjcUKZ6YHpQcbd3dnR2ckOnnUpZoEDSKEtkQmWMYKtuJPIO4ZH0qjJPD em5udsaPLGoZwm3kDA6dc4wT70HK9mVoDbWkkc4kiku4uRA673I/vEEYx2/CltNQgSa4F5GtxJNJ 5irIxQQt/sgYAz1xit0klockm1I//9L4rXSL2+3CGGVvkEqosfzMDzwO/HP41LqWljTM2rTtLcAR zIrJsMe4KSpHbHNf7oH+CDd2UoNpk2TSrFIePmbAI7kH2oMcNrMqpKl1bxqMeU25CB2FNK7sIv2G oHzWecJCrSbYFU7UhTHAJ9c5rpxNJe2xsFSJd0m+SQxLK/B/vEZAxxit0rKxlPcwbyJZ7iOeM4KA RLsXCEcDp+H61XVrG4N01jcRR3FkfIuo7ld6TNtzlBt6dBz370W6E30sf//T+LkuZHt4baYLJHCC 2IVxsHUgVctdVW5iPm20rRQR/Zow8hGCvGfpwcCv91oxstT/AAAqvoU+JnaFHImjAeSKQ4SMN0IJ 6in3QaEKiulxLH/r/K5WI/XuOe1Ucwy3khdi5CxO3zMBx5mABn9B+Va41P8A0a1ghtoHto5WkvLd lyl4eNrlhggqBjrignm38ipBMrIxJZZIidiE/JjPpW9Lb4sSV1SNp7xPMYRSGR484+RwR6cYFbx1 Rif/1Pj9LYSWSxOYzcI+xbZVISUDnLHsOcetaV/LLJa29jZ20cCxKA6LzuPGRn25+tf7wH/Pcnq0 VJtNkWyVtwe4LbUQNlE5+6ffvUGp2bWZhtnt7U3MA3+fCQ+/dzncKDOTd7EdszLh52EYJwxHJAq3 K1mS8E6S3EDtiGUTjymGOBtxwQeSQf8AGqj8SMpOyKMot4cRgZgI6MAatLJbSQq8QcSRfeGQIwvA FbIybu7n/9X5CiupYLqG+KuGthvjcsRGOhBYdCPrVKWQGe6vH4ubptzMCcvxj8sV/vQf875MkF4Y o5UhZzIcwoud7gHBOPqD+VREyXC7H/dk8DJwM0AAtr6GNGgeOEnIYvjfNjqR/KtXS7OG6hvnknd5 ILUyfZkG0yMCBjd24LH/AIDTjuhO1tTFt49xG0kDHCucsPrViOJbeYuZDscYKgdD61uZxUep/9b5 ICNCiNEv2gzPsCggFfzNXPMksUbykTzusmVDFfUA/jX++B/zuydkUdPvE1BJp72x2OZTbmIAEMoA G8EY/OrH2e0kl8mBVTc22LzSAB6c0GJJb2s88VzGzxwhQREWBy3tWaLKW1XdMrSLux5saHyye4FB Ldiw8g3OsKhA4wAp5ArOeOdIAhY70PDdWf3JosKTVmj/1/ju2snlDyM43BPnPc9uP89qljjFiGYt kZ5b2r/faKsj/nNkrotzzW8tuBGQ0pwyvnBPTgD8+tWtLVYxOrgOGTed5+4RVGJRuBI8rSqV8tW3 Mu0FB+HSrIEa2gKIw+1KCk2SOOMlaAKT26vIspkJKrtAzjOahmuLi0EttMibJCrBmHVeowaCJRuz /9D5TLxrDEBCIjtBbHR/cio7i+Jmg8q3hWHygjquSzOv8R56nrX+/B/zhuHYx5zMbp2aJCJm3jy1 wo9sVoJJHPCYXjYShtp/hUfhQRZrcuxQJaMBZwsDldyPjd2yf61sTSrNuiaGONlGGK9cj8fagRgB WupVSGF3UsRnGG+X73PtVp3V/LtFmiXLbfMf5VjJ4+Y+n500ruwH/9H5UktZo3MCyxTDO0zQMTG/ uCRn9Kie2WCTFuyLKBtPODLX+/6Vj/m/GKJ7iXLK4RG3TBVxtGcZx2H+NEkcMZ3+YCAMkHjFOwDG upo/Ke2kQ/LnGwMCPxH+c1Cs843py3mkZxxs61nKLb0A02uppJbAyRwzPZRGGASQKdqkEYIxzyc5 PemtK0cot8BWR+W7ZpWkkxN2R//S+VYpruwumlhkJd0KsGOVIPt+NOtbq9W7lubqTzIyuEhdcqP8 +lf7+wTsf825QZt0x2Dau7n0HsKuPaWzyRMgzLs+bd696sBuoWUbpDKvyyQnIKkjnpVUoLQM5uDI CAwzwGJwSB9OfyqU7toCaAPKwkjYBmXqOeD1rUVViUbCQ56js1UB/9P5aa4dGBQsvPzEfKfTGatS SPHHDuG7zV3567Bkjn34r/f2ex/zblK4ecptiUOrfePVlqCBJ1AO3zWUenJ9TURk1oA2W5E7xxwo ibBucOMu5z1H+FWZGLKWLqrucYRdir2xgVsBTjtTl5Au4hsnd1Par15BbWtvaXJl3QXgyNqlmgOS MPjp0zz2oA//1PlSe1aULIjpJFsyoQdPTNUoXVGeIlTcRLuQSHoMngH35r/oAP8Am3NCOZpXd5Fi jYIMrHwOB9faqb7Gkyfm3Ho3agCeICJ9iDeW4JUcLTmknRmjijJZc+Zj+ECgDQs1W9eFGlSJt4Xz ZTiOPkDce+B1OPSs66Mm7M7IZwPvQlnjb23ED9QKAP/V+VLUyXGwmPfIr4QkYVcVYkmBklLIu6R8 uAOAfav+gA/5txm6NB8oGc/dxzUNw95FDNCvy210oLL5Slmwcj5sbhyq9CK1ggIIbETRxsJXy/vw BU6y4X7NOzBYiVGRmrArXNvHAocg4JzyMVSSTbMq42k8LjqalxTA/9b5UmuAYhEGZJl4J757VZ06 aZVMJgha4mXYZHiDsQeCBnoDmv8AoF5Ef825VuFS2lCsCH3FSowVBp7K7bRECGzknHzYqOVgRTw3 ClJ5NhUEpuX/AFjDAJz60xowqJOGcNkhV5GB61UYtPUCt5cLCO5Eh3MdrDoAP8/yq7cqHij8uQMR +daFxUep/9f5QZZIljaNGORkuvSqpJnn2s2CwyPfH/66/wCgg/5uJWvoLcPAZEhRlM0QCvjlT3wf pSPKQGQQqTsxnpt9xQIfbOoKmXcUz0HBP0/WkdwXbau0B8AYz+dAFkQPICy8hRyBzirlv5QXYw+Y DnPagD//0PlVzbqJFCYYng4Hze5qqIrlI929Y2J+UIchh2yP89K/6BJpLU/5tyxJNloo2QKdg3ZG AadLaRNGXjk/eEZx2FZgEMVxMGEW0+VFu2ngsR2p0FyzwsGkWJl4WLb8uMdSaALtoXigWUggy5ZW z2BI/pVa4fzCuzdyxyQDz9aAP//R+VLi23BDIgYA/KSOartEVYBVHJ+U7ea/6AD/AJtyTyZI50d1 UrsPJ7H6Uyd8yY25QDIJ6CgCKLThdkzMOI/mO3qB71LcwITH8jYibK4JwetAE0jghQu6ExjMm4fe xngVSRbq8umllkht7aNCUjVGJc9ufWgD/9L5flgMECsQQXXKk9TWJM8qtguQB1xX/QAf824+OWVv mJJUfKW71fjt3ktLibazMoyu0bnz2/DrQAxJENsS7sZQeD0C89MVXmt4p4xKXKkHPpnFA07O4lnc wSK6YdlLeTImCGIBA/pThbW8V1PtxjcRCxGSR2/Gg0U7ux//0/k0MIRJM5Covr1J7Um031qbmMEx IwUzA/KCTwM/hX/QAf8AN+Jnyo1C4YA5JIzk+4p8QjZFMqFJTJuyrhY8ehTHv649qAG3QgRVdACy tlRjKn8Kz4p5Z5WjTBUcOV/gz2xQBbcpC4eUmR0UqobkoM5wPx5pDcKXVkPfjsFoA//U+UpU8uMS gBlYc471iiO4km3Mg8vb93uK/wCgA/5vy3CrRyrGkH3kPI/lVyKKMZdwA4Pyj/P0oDbYsGWEIwkG OOMCqErGOIsgJ57dQKL62HdsYk0rRSJDIYTMvkyttz8pxnFfkp+2XGNQmuE+3XBt5L0W9mshwyQ/ Kypjt1JI9TX5p4u/8kDj7fyP8mf0P9Ghf8bJwy8n+cT/1f4upk8ljBbI83lsEKjlmxxxUstssluG cTpcKxEkDLtCjAx75r9Err95JM+NpK8UjB3G3IWQDYz7FDcMM1ausMgaONS+NrZONwrjtbQ3p7WI oXkDoi/Lu+VmJ6Co2uf3vkBNoQcSAYDH/P8AOsJLVo6YvREkP71WE4LyA4jy2B+P6VvwRRLEoVWV trGVs8D0x6VztWdij//W/iifc7ZGZFWT7zHODVpJAikPny3YKqg/e/D8a+oPFh8JTuJ57YsEdgc+ mCB6VLYpbu7Xd2jys0RWBRJtVD/eI7/T3pNaWMSlcSLI37jPmFtuw9BVm3hniwCd5Ubzjngdawtb QaV3YmuHluVXa5IGMKf4KuLbW/lFpG2zn5Q6kYHtTvbQ15Uj/9f+KqOGWGferyFohvidRyfepI5J JGaOSPbHHyHkOGc+m019AeOVw5F1LCjqz4DFCMBBVg286lc/KzcgnpQAkkLKPmIdzzjqKzJhKflI EZY5B64oAWOcRuUkk6r8pX7y+hNTQ2xuZRsYl1UkTSfxVMvhYH//0P4ppb3a4jYLG6Ha7ZxuxUrW EU0QuI3XbLnIzh1PfivacbI8cqwKbc+Wd0hDYMnQZpzHMwBfdMehUdKkDR+y3bQqS6qScSqe69sV HaSNaI7KnmurY2E4bFaQaVx2aI7q5kdmeNlA2jdHtwPz/wA9KZHJ5scW912c/uwuSSK0Ef/R/ip+ yyOjECQFTlFPCmpo444SpmG5mGSM/dNfQHjlqeSZoom8wCIvjPp+FZJk3znynDSxjfgDIxnrQBuR XbywuF3IdmJSx4OP6VTtYWuGaOGEMyHLbcDArKe9gLckJWJ0MIVl6nGWx3qha3EY3QuXRM4LDnj1 xUAf/9L+KiXyjdMsJdlU5VnGN3uRV1ZGtYXLGPy5Du7b1x/+qvYPJi7MyyWFzJJZOS0iYmkXIwCO n9KtWkUc7eW42DoC3U0Grdlc2oNMghEu+7yIxvVFA/AGoLW7SK/M0tqssEa4AyevTOO9TKXKRF3k aF+6am7SFREPK2rEihI+OmBXNiG6imEeVSMDKvu3HjsRUyfu2ND/0/4qZvMIDS+XH8xBOfvj2py7 oWjkGYtp456ivQOSKTjZlpb2S4aaFFDyKoJkx9zPYe9MZ4rYogXe7n94f7tBkXZruABJjjcqY2gY LH0rGWYzSvK4woOBnkKaAIlebfL5WGV1wxxkrjnj0qyEYxiSDLRHCMONwbHPH4GgTV1Y/9T+Kq2X a7+YpAbocZC1eRY40lWZmeOVOQv3vavVjFWuzyJKzsR2wht1Bk5VxkK3RamivLOdSjkna/yHB+nP tV2toIc86QiIRn96JiBGyho2X61TubhfMVlUK4bae4HvQARpE3mTb9zKMlRy5+lMWMTyKyQKoBzI cY3j3oA//9X+LiLZZzGG3QRJKMbQdscR7mrN3tNsAkrR7GAGOc88/n/WvYPHMoYnHz7pJN/lg4+U fX071ZijA3x7wdp+8eR9KmUrKw1ZPUkihkQMd4DKfkMfP0qOK4uWeQzp8vUHqG9/0rE30sWfKhvW SSMKkiDY0i9WAPIp88TxorD7o+XP8QA60HOf/9b+L0PGY/IDiQv0dh+NVJtIuPIZo2Vod3KA/Ofp XoHjk0ekp9jD8Ryr1UHOR2I96wPJlhuB5jMCPlUjhP8AP+NA+li2ftMThn3LEPvhenPY1r2+ZpVX eIzswhc4Wole6sS3bcyrgTrv3YZmGCqfdyPSpdO+zLLHNPHN5m0qxz8qg8fdpq/M7jTtqj//1/4w ZbN3geewycLnYw24pul2VtdSytcyIiwJlhnlm9AK9A8cS+t4ZrSVRJhFfaFU4kArMhjNnGn2eNWh fOSr7mVuOo96AHyl7eB5SN3n8AEfvIwCOR/n1qtG73LQo482OLIUscE98fpQBZkjk3rJwuTtZegw KWbMMgkH32UL/wDWoA//0P4p5J2KgncFjbkkfLXU6D4avtdS4u9OtJbxYcLKtsu+ZSRwdnXHvjFd r5YR12PH2FuIhYt5EqSLICQw2HK46g+mKwNSsvtChxeZiYh0iVcl8d81m1Z2ArRGFI2YbGVx5ef4 0ZTyK6GDRZrq0MlvbSTsqbvk5Zsdf8mlYDCZJPNaB8bVGGz98Edv5063tRHcwyWZfzVy0pkGVzzj H6VS0kQ4Xdz/0f4qNUtJradJJnASVN7SE8lieAKppcxAiGVyJEACsBnd7GvQuloeMlZWNGG6RUlV WKofvAcjPY1CkoKuswNwu7IDDKj6fpUTelilFvYvCQSRiPfh2PA42j0yaxpvtESyyJGSXG0nd8i4 9vWsjSMXF6jIdv2WS4uWz5XJB4CgY6VrQXMktvG7J5lqwyioRubHv19KvndrGai27H//0v4lLeXz 7gzeW4jic4RxhWwccitdmt/+PkCNSzZ8oYG32ArduyueZFNOzI/tiq5/d+Ukh+ZOSD2oMAMrTxxr uAwDjBNRT6lg12Y5AG37mGGBGV+lKyStvcsqgjcA44UVUmkrAVYzE90waOCeJgB8jYz61bmdIjJ9 lU7AOM8lelYgf//T/igRftUTFdoI/iPBX61FJZTKUMaM3YnGUNBxyasrBPGoWKGXZ5uNysvXB7Gr i+XFCBKV2btpGe/pVxjc0sKAXdmtv3SoQAVJIb1GKdeMv7t41Cyg4Y52gD6VfJESt0M+cSXEUoZn G0cbMkMPpVNEntSpRm2+9ZNWdhn/1P4npbt1jjkKlyeZHfn8BVWWeeYZJLREYC91X6UHOLaQGCZF jmO2SMiUFcAegWn4e0nkmUNIAMD3HesHuwLMVyfMMkCI5cjczZXgf5NNYM4eZQFm8zG1RkkUgGTR zyIrKdoQElAcF2qjbySlpHYYMOBs/iPbFAH/1f4i1meGYyRl0KNnK8FDW3bXFplmliZnlXbG+SDF yOcfhUw+E5zLvo42u0jVNzMOJQ3K45/pTHSCAJHGqtOzDcxclB65qgNH7OPJVdyqLg4HlSAvxjOR 1AqE6VIu8p88LDnn7pHpQBElq6HdOwKdBjkmllhkt40u4Cvlq+wRbvmf3IoKgtT/1v4kpI5JA0sx Ks6ZjPXb35HpWbHPPBb+ZIm5i2Ex/EM4oM6nQ1oFN3ES3yPB8wXOBk5xRbWhDvJMm2RPnKBufaon sZk8FlFfSb5XMLbflBG4L3GfemXNgInAVBl+EZ+pxWRtH4UStaiGISyE5JCyEjI9Oas21oWkdnEa xwjdblTzyMHiglz003P/1/4prO3eEiSaMfM7BXUfgMmqmoK7fI0KFlk3pMHO5hj7uOg/LNcMviZU NWi7YfY4bCfzpHmlZfMCKvyxH0zVOCz+1sShBWM5dScYB4zUmxKbU2khIZQE+aMq2V4q8l1cSIJk XMiv8xC5T1zigCCOexSaRLuJR5ikll+8pPQ7e9Zf2a7maaWMiW0TAKkBDj2HUUAf/9D+JQxrKEUZ EitlFP3eB3pzZnvJZ7lA8dySHwdsULd9vfFeedBTJhj32qKTtcs75OSD0FWUMc8ZzuAiIDN3I6Cg CtNa3LRybCq2kBE0nzBdw6Z/WqnlzMqSW6JLaPwJmOCrf3QO4pptbAWJp5L3zYLh1geOJBE8LAMu CPlA/wA9K04Qpl+zxqH/AHahJGO1c45J+lbmlNH/0f4pXtooppIn2XErfJG/VVI6lfriop5GjKoj PCEGfNUZXjHHNc53pWuE19hVkkk81/ut8hLN2ApLc293DPJOjK5wAB95SDxigiUtLE1oDZ+VcXe1 pklJtbiQh5UA+79MdK3h4l014JBq+mPq7SM7xtHJ9mdHZcB2cAng7TjHagmLs7HAo9xIWhtlR3kk 3EuOgzzWxFpzhfMlMqrj+Ebd/r+VaQ6mx//S/ict1jWQBSFbBJzwQPpVq3vDG5ZoldlB8vuq9uR0 oPTUnGOho6bqBvDJFKsI8vJjadgqKcdjVZbmK5vnsmQK5UyBAh2OB1wauLUdxR+JD5ZvICxhjbpI dsRI5OO2Pwqm1wiQTSszCSF8sgTdlccnP5cUlK0rl1NI3PqX9le0kk1db90uFL6j59tHM2JuJI8t z0GFP51++X7OE+sH4peCtLt5bo6TfalFthuFX7OVSRWDEnuRwAOu6v7U8C4qnwLjKj7S/U/gvxcc p+KuGiv54fkj/9P+vX9laxks/hfp5W3mtpJbWJzD5e2NCsSB2H1PYehr8ov+CxOovceBZbS6uLUW UmnGGGxnlx9oAy6s4HfegIHqPav2Twvgq3i4p7/vn+Z8D4vVHR8Jqt9H7GP5I/kD+IsrW+gR3d2J J2eEF7ZSIBKQFVwCOBnIwccV+CXxS1B9T8aeJp7gSLc3mqyTTXDsXCAYCAnuSoBPHev6u+kdV5OD I0ujkj+W/o4UE81rVnvY8ht7kXcrWqxgiNzul2kbscGuht9Pz88D4eMZAB79q/zvqaSZ/bcFZpHZ aQm5Sl9EyygbgzDbuB6YrrkWQgJEkQgWP5sttZvYiuR7MHuz/9T+L6GaMSiG3tDLcSTbQ653LjOA F9zU1rNeC7ukvrVo0h4iB+Uls9PpxXky+JnObyTQv86MUbA3AHAOOlbs4guEhktg0zGARTySYZSR njb2Arme7LgtSuNPljFk81wClxI4gQEhAUxuGenccCtv7TDbI0JdLlUbbJCG3IjdOo+orOTsamsd KhS3tJE+zRxXLkyJgLIDxgv6Vk3WlzPdxQQy20aRMWbbKM4A4xWRUVdn/9X+QVE+ySn/AE9pwxyY 3wTEwOMjH8q6DSfs91e/Zbm9S3uJkJs1dwrSuOdvPqK+Um7Kx0pN7Dpre7dZLW5ZYCJvLZoWy6AH jn8K03WRI45Ib7zTGSHsiD5rnGA3TjPP5Vi2loykrRZqaWLi/VYJv3Mxb/WgfIq+hHWu/wBFsIII pHvbtmtYEklZrYBZcKDlTz+H41w434G/IcXaLaP7gf8Agi1okP8Awo/wgkNsxuLYQatBc7cXktrO nmRM57ld7D8M1/R1boBGkihlDDPPB/GvwvAQf9uYmUv53+ZqrKbcex//1v5Etcjs7WF2TckjSBvM ERdCzd2HpXK/ZRe3BeCfTzc7AZbiHZbKzIM4OOAfQV4b0fKedFaJFKyvnOqTq0cBZUw8pxN5vY4U gj/9dU5/NmvprW1WVEeHEu5dkLjPIz07Dj6U0rTGFhfwRT3Vq0ZRkIiBEWSAB2Y/zFajzbI5J48N HHF5pJOAwFWBgR6ba3d6ximt7ATp5pkJJJbkjIx39612jMOVU7vLXHzHn8KDaHwo/9f+NFYYFlZl VQZohuwuPn9qdaaPfXmFnjeIM+0FsqijOMhu1eQnZ3OKe5e1BmsFmtgiNNbtsDxMHWTHHUdfrVK5 v5rnw9Fpc9wxuUl+0m5g+WS3IIKhcdBxz64obIM2D55nuZ5/MmeIKZXm3FhnjjPFWrfaV2K8Uk6P krxhyCdrEe1VB62A2rIXUMn2m7RBcxy+aCsp3yAdCc9PpzWtJGdW+1XdxP5cEq+XKkrgu5UZOzjl sc8ntXoUnciex//Q/j80+wutUtJYk1OYSW1ztAjTC+XjhzzgHoMYrz7Xbe9jvLpZXR4REH/f4Msq r8o2+nToPSuilK7dzy7e4eT3F41hcTROp8t2LHzF+bnPIr7J/ZMu0ufEzWslxA9jM0OyJo1EsbrI mRIT0BDY/Gv03w2qez4pwf8AiR8zxnFT4XxS/us/fjwLqLaL4m8ITudNKDUrUQiaZXs5EIEceHB/ hyDn/Zr+7X9imeOT4UaPDDqq3kLWsRs4ghRI8p+9TnkFW4P0r95+kkr8P4R93+h+bfRdmnis2op7 fq3/AJHzZ/wVP8Lvrvwbv4kaBb26NzDavIu5U2wqrD6N0r+QjW7aaCzhhktoorIbUNmwAUSRHGOR 0BXp/jXs/Rer8/Dleg/syv8Amfk30oaHs+JIVe6f6H//0fgjVVv9Ztb1/stq8eiyiGIWI3EK/P3O 2P5EVlWsKQotwVD7GVnMjbhke1f7OU1ZH+M0nfUuX93c3N9HcwT/AGaCW3+zXVnFHg7MDa2e2fTv k1lxGzZxZm7NrciUeUXmKxyr0KlQCSfatUruxlJ6m/8AbdJghjhBGri0nKzgxMUcnHysvBwMHrVP U47yS+ivIrqzktbiKN7fTbDeE0pMbcSZAGSewLEetbpdEYueuhhXOo3FtOsFos8V5LerbyyxkCCF WYAjv3PvXYacmpW8bK19Na4YtcTNGqyyL1OQeMGt4rlVjNySep//0vz11K5uYIY7vRX/ALUs72cR JfSx7VhYYaQA5OOCRj36UTSwR6fLd3WEdAMRRDcOTgkgd+9f7YH+KbackWBe3jWFvpsH2SG1EbM8 SxhJLws25S5746D2AqrZpfvM7RwMhgkWKTy0AbJHGF6nIHb+tOK1QTRr2kd9dzQ20T29vZrISGmI iwT94k4z0A4q5ZSxakJAJVmjjcwMjfNtKkqcfkcfWtzJq6sYWr27aVqDwQzmcShZEkXhYVYAhPXI zXW6TcyWditwG86Fifn2loht7ntyTj3oISST1P/T+E9Yv7q+smkmhaeNpdvlxRBI8EY+bt3rM06w V5rc3kn2G1hhxhELRY4xnvkAdvWv9uUruyP8RzqJG0pZpItPht3vHt2eIsPMeMYKq7HqMHGM1hy6 dczOnnMkYEaNOgO4QvjnOO2ecelbmMtzV8Py29zd3VmdRebU4IhOSFBhiRflCYIyc8cn/A1duovt Um1pIUmjcxxyOgCsw5IU9/8A69Nb6GE9xbe1urORpb2SGNVXdbyMGcXZ4BReOCM9+PesO50wx3n2 k+fHJgSB5HO3HJBA9K2Tb3FLof/U+JLDXo9MjnLaQNT80iG8jiAWaNGZf3gOM5GAam1K8inuN8ER hy26KPO9ii45Nf7kH+Gk1oLLE9x81vKQZl3SNu2ggYIX26VBdTS29lbiSzia7NzlLqBcyxIQeHPp wOvTmg4mraF621GyYx6deCSJpmDlnhPltngEtirN5posi7xCCSGQD5ByV5zkflQc8la6Mq70tzJH OiwxvPHmKR8KcA8g/l/Kqlpa6dFM7XqPOVjYKEfymLkEKc+x5/CtYO6scrStc//V+MLXUtZAX7Lc yQtbQiCWZVBd16DrwO1YVxa3c0tzDeXM8rynLXEjESMD/tevvX+6B/gg92dFpf8AZkMtqt/Zx3tp aRGEuxPmSMVIyzA56kZx2FSWmkwxF/KeIwTSmVFByIlP8P4c9eeaa0dxEbRJb3MqXVt51s6kxFPl UADA/HNVrPU7+1ndPMgjtXYMFW3DTPjPG/rj6VsndXM5ouzRT3CJKrGOJ3ICEbIx64/Sq72scs0U LY8llCSTw4DMBwST3OP5UzM//9b4kjtlguJ7e2ujOYwNkhXyd6HqMfpTjFNbqxJJjl9Pug/5Nf7s LU/5/qrJ0lM0YV1+f7izbcOoA7n2q9JbfYVgmguUl+0RMsuFBYdhkc46UGBK0GjWlvGbovLIY+Ik +UZPGM46Csu3XbHJPCI1sxIIQiuDIhOT93rjGefagTWjLJ5SSRSMxsq+Wc75N2eQPb+tNtZJTdu7 Rqik/cA2gEdCPyFbxtbQwP/X+QhHOJJfKnVVfC7iAWRjwAM+tVs3dr5iNO3nDI3+h9cV/vAf895Y VFitEMUsryE+ZIQeWJ61nySzB3SYBUZQUcNuc9eCO1BnOxLaP5jFJ1KIB98nI/KmXHlpK6RktEpw GUHZx6ULyMJ7FhoE2x4lEqlQ2Bn5fY570QQ2qO8ksgSGJh5isCN+TgAY5reKsrMyP//Q+SIpJ23Q 20BuoSpR2HWNRz09KbPYSTYmTy1VUxsDZZcdsV/vQf8AO+UrWa5BcIxkCIVVs48oHOcfmfzqS2S5 dmN3sCbCYPLThh1yx/P6UAXLa5FyUUpFcQsPKEmcCPBwcH8MUtvJFbalqFra7FDILd5gTII+jHBH pnrTWjM5t2RmzwfZ7oIsiuhO7zFBXd9c1KXQyAMheHcFkxx17ZrclRbVz//R+QpYim2OECNIGzgH Ofx79OtQySSbsAliRj1r/fA/51yK1urm3SWN9iKSS0pTgEjCqPzPetXT9NluLdJHnVp4pDIDJgI6 kD/69AEpuwzRwhgJ3PyhOcYPf/Pert1eahfJFYmSMBZjJ9xY4ySAvOB0GB9OaEr6GD3ZkjSr2F7i eQxTGNcKkLZAA9+malZEltztbE2QTkcYHX8eK2UEndCP/9L5JhHnQShAwaFd7gcHAIH9RVWHfcKy yAbBwDnpX++6uf8AObJO2g4pbQgRrIu8KSo5Ocdqlt1DgzjKB28snPU0zKzLdrI9pKY4/LeOcGKY y4KqrDBI46jrUV5LHJOba1uFngs08qJguwIOT07delAhrWbRA77iGZZIlbKEho2P8O0jtzkjNZck whdEkDStuChcbmUc84oA/9P5Ys0jukdZflbb8gBxwBk1Skhit7iKLJKNlvXIB5/nX+/B/wA45Mkk EZnmQrcMj48teSoHamvFPMZp4/Kjkb54kfO3PoTQRPYgSS4DeZvZ5XT96p/5ZHpgflUMb6g0/wC6 CSyBtzrI2xQo6/jx0oMjYTzBEkWSq7mbC9VLABh+OBWJqFnMHRUAKFsSZJGV5zijYD//1Pkkzy26 x/Z4i6KmNnUenFVmE6ZnnfDE7sZ+79K/37u+bU/5vy0vnt/pIvRi4Ty5I1b7ig9HGPYevSqzhVm2 yHeMcEdDWoGhFa7sJGu5SMkDiqcLpJdRxmSK2dsgLKwUDAP+FAFk3zoXWSNd4GI3Xp7HAploUlTz pZo1zJtXLY3H2/z3pPZmU07n/9X5TlWS5mUREbtuMAYPFOcSJCQcM5+7gZx9a/6AF5H/ADbkNrp8 kKTTzXIa4G1oIFUGIgnn8R6VYQTqqOUIBbaxoAkuEz8ikswG91Xkgep9qj+w2l1Esd1uMaEskXRS Twc/lWLvzOwEMdksE8Xky+VADgjGeOlWZ5o0uCVdjEON5G0/XFNTa3A//9b5euoTHb71YSwls71H ytxnvUEFzHICFdAwXCq/QkV/v5Pof825HbthpYxv80nJBPGOelJMt0xSKCORnY7RGgyz59KzAkj+ xJGDCzSSYxLvTaY27qOexqLymZuM8tweoX3rSAFtka1QkSrJIeVwp49Mg0adqnlTjMcUjLwY5ohN FyMcqa0A/9f5gV0hDJlQu7PAwBmqvmL5+9/LKA4wyZB/ziv+gA/5tyO4QPN+4+4332AwDU88dsIY o44trRpgv1YnuTQBDBNHZyiN3R5ZULxY5wBjP4jIpIYJZGaaOVgkp5zkKaAGTRT2NxteZcZG4Icj nnrViZ0dlQ9uSccGgD//0PlvaxTEJ5PCqO9QBXJwcb1PzHuPrX/QC9z/AJtyOWNBIrTM6xggt5Zw 34VekkJjEiEvGnQMATj3FbR2QGdIZipmXbtduVQYC/hUsasoSQpvTPzEnnFMBXuxLOIfLBXOFRua jkt4mnVlCgxnIweOKAP/0flGWBLksz5R2f8Ah+UVdt7a/t1uJYXhaGBViYMQ0rbweR+Ar/oIP+bc qSW6zBcSfvM5cNwM+1aVxbstqsihi6oEaQdFPQcUAZEkwCrE0u9lXn2+tKzCO1JyHI6Y5o62AzGc t14QjAXHT3qRHSPbGrklj0JJoA//0vklHuokJic5+7hj8jKeoIqUqgVWyAX6+oNf9BB/zblBLYeb K+QXBOw9mx/+qpo2DqdxAZW2sgOTQA9VUYwwKE8AHpUsxcFWQBlZscCgBzb4hvQlJMcqKIrkFSNp 3DqSMEUAf//T+UREsiPIhLNzgetVYY7uVVBjeNy3R+uAa/6BJvWx/wA25JcR3kikSSLI6DbGRxgD gDP4U9LS6j2kkkMvzR/xA+lZgWi0sQ8uKd4VlXY+zhlzwcGqckDwp5IZZAnBl7t75oAtweS0SRyN IMH5Qh5+mO9NgnvIbphH5YjkQwgNGO/BP1oA/9T5RuJ5HzExwAcE5wwwe1OWR9g8sB2Xqe+K/wCg A/5tyO5uDtUYJfp0z7U2CCWYZm+Ueg6CgB2DA+wOcE7FAzg84pblZFVI2aSGa3mEpxwrbecGgBsh e7dXL5ycsB3yetXXH7tDCVi8sYZ5ACO/OPwoA//V+WhcrqRihiu4ZQkeJCowyY45H+HrT5NLKbY0 dZmZS4OR2z+vHSv+gA/5tyjbwiWKQq2za+CrjbyKs26XbJI6SiCJBsnZn2Lt5H1oAiEe6B32kxcY Kjk56H9KjtrZvLK+b5juxKrjGxe1ACrbLGTv+U7ssQOQBVOZ0+0hrcyMhOAJBtbHr/8AWoKgveP/ 1vksQvI2WwV/uY6U6RzGjQjhSchV6V/0AH/N/wCRVCXCGJ1ZCm7Eityx9wKWZTJL5sjbBvxjIXcT noKAIrgsgEaAbCfvEZxUtncLBJIBF5gXljggE8UAEskMjszIWLjAVD9z6+1NCxR4EgYqzYOwYYUA f//X+VFxHbCNmJT+HuapxlobgnczRsuCCMgV/wBAB/zfksriTbsIU7uoHbvSzKxJ8oFVz1Y5oAgL FUSOeJ4mfPlORxLgnkfj/KoRIWkXHymNsDePlY/SstecuCu7Fi8mhgiWQ5jaNN+VGcuOR+HAr8jf 2wr+G31HU3nVb20iu1mhaCPO8tHCcBfXJAr808XXbgPME/5H+TP6H+jTp4mYZeX6xP/Q/ivuJHz5 lvC1om/eyqxJTJzjNXBfzxnz8GYmPa7y/PnjGa/Sa6tKR8ZSfuIhcWcyvI+8sB5sZCg7WHO3Hp1F ZEtzieNjFmIHAUcEmvPlvobQ3LdxsmjAVPKHds4NTxW0l3HFEAZBECqFVAYAnJyawl8TNfIfDplx A4aVCfm4JGFA7Y9ao3091FK0J3DJxhM4APQ1hPc2g7qx/9H+Jqzkkt5vLznefmjPKmtRowXaVSFQ HOwdFPoK+oPCh1RFHZy3UgcgKqsPnbhSfTNJeYsmImXDA7Nicgk98igaitmV7V4xKGMYYsCTJxlP TH51Klws7NjKvkpjp+VRNaDULO4/PldQcDj0rPkuCQCrcBvuDqfeoTSvcs//0v4roXkSFXMjSN1C 44QdhUIvPNdlyuUbk9x7V9AeOWj5Yk3ME3TKGkkUAFsdM4qQzR+XJCki4jO8sTnb14B/woAmtkEg YYBdjwMVQvbaRZ0V1IABJJGFoApQWkZkd2hOGzwewraSVHRLdVWPYpXcBtzzwP8APpSezLjBvc// 0/4nbzTzI+QMkdMnFWokkggfeN5K7UIyAhx1/Cvdk1ZHmTWhnkN5ahSzANlxnJf1q5bNFaTt5i7h INqMRzGfUVM9xqCRea7MhWAl2I4BHG/61kifbITy8qPjDcBh0qBvZmzbRx3sqR5CK3XcPu1beyeB 3BMRSMZg8sYJ9d1XT3sYH//U/i8ZbgwCTbIpDlWUgYOPSs66mDAeWmNqYkJ+8pr253vY8VO90U4Z Gk3xFsoBufJwFxV+FBbIWO3c65Veu4dsmpu7WKNG1miuVmUxKn7sBtg649qpki3k3DdGuM7kPWkA pubi5kKxbpHmTykxy7dqjns/KR3+ZHUc+uR7UAf/1f4oICZWOcBgcKehT61fjtGD7y++HGCD0z71 63MtjyLO1ytI0UMuyF1SWQ5YDo2KrxTy7wXUj5yQFHOM1Rok+SxI16CkrK2DuwN3pRb6gVVPkOS2 DgZBosTGLvqXpL8tjyj27jBqk9xPKTKg2kjBHrj2qZRbVjU//9b+KO6eMx7pASfLwSTmMkegqsLv 7XatGV2vGRsJ6cf/AFq9OMHfU4Yy5S/YW4VS+4hm6vVq6iZ5VEXlF1IMiyNh9ucZA/z0qWrOxJVF srXIjc+YhwwjPAGP/r0t40sCEBURCxZwP8+1IlySMlLpmQmNsIwwQO9aVlIgQq7OCBuQqOp9KqK9 4iUr6I//1/4sVdYo3aXckb87COc+1VI5ROzk71iHyL2zXsHjN2VyedI44CXLBQPkGMk1gIDK5kR3 WILluwxQTGStZnQxWxuECg/MU+R/T0ru7TwKYtGguv7XtLy8a2FxdW0YdmiyCWUsQMkf59aBqV9k cHMhjl/chfLL7WYDORntWoqRJEywAzSOMBR8rL7gUFH/0P4obi4lV2klVypby1+XDEj0q35gmMWG cbMF1x8vHrXrcyvY8cbcTgqVgykrHacLgPRAixgl5ckL+9QtwprJu+5XK0aNpNCrmZ/kjb5UBPX2 qBjNNJviUpGCSYsdqV9bGttLGojIkKvBFjBy6Dgj1rMvr1xsEY3l8gqeNv8An+lBgf/R/ikHmhfN YbfL6j0rYhuJJIsBwqIOoPWu9uyueM9FoPjmDDazEAce9N32+7YyrIqNku3WoUm3YfoNu5LSZI4I pA7PkgEYUY9TT7WCSZWPlkiFOJcfoKHJqRE1poRSxKsZeQSAAEgBfSqkDREDLkEHOMZoT99jirI/ /9L+Lh7y7DAW8wSMJsfsQOlZ322aJ1jBIjQ7m2qB5mffvXoHjivceSGjDmSSYecIm4bB7Z9qkt2k tgjviNcFvLHP0oAsTrJenzJW2Kq5Ugf0rPiJjniSDbIQfnQ/KVHTNAGrdXMQTywhBQ58z+97CqIm ViruVdduApHzIfWgD//T/isa5WdArooUjYAFwOO5rY065k0uUXVrcyQSrHsxHKU49wD+Fd7djxye +1SW7j8uR8lj5kjquZc887vfnisy1ljGwNGXlD/uxMNseO2axe4nJRMe7t5FL3SoUEkhDkL+7B74 rft9X1SyitotP1Oe3soJPPlAQGWc45Xd1Az2oWhKnd2ZjXE7XE8kzMwaX70jnBbPXmrAnntIYzEz F15yVyT9eKRZ/9T+LFlm1OGI3OAVOWkYfyFZ01tFAxiKhpeokI7V0ttu549uhYs7Wd/MOY3SNdwi Vckj1p0s0USMmdkbDChh1b/P8qRulZWIreQPhFbIQHk8Y47mnIzkGcRs6xZAgXgZ6ZNAxsjRCWML HGwfIaB+UbPT8qs27xacRDHHDIyuZDtOVBPb0/KgD//V/illI8qWOMfv5Txt5xmufnR7XbGcmTO8 q3XPatpfCzzzbtYDqSHZuVo8LMV58knpVy+L2QS2tpRM7KPOkdcFe/y/1NRBbgVRFuRSxZp1bJI6 Gg3ZZfIxhnGGYrwuD0H9aUviYFdESNnkjxufC9OmDWiY4xGZBnJ4GRw1SB//1v4lrhbhkRYFKMx+ by8gH2z/AJ6VqQXl5YxmFkPmhPlLjJXjrQcLtymNbyNPMUlA3BjsLDBzWtdQRpa6bJsKzIrrqKK2 6KQliUcE+nAxW0PhRq3ZFT7VFbRblLea3JH8J9K0RbR6isc8U3GBGYduGJ7/AOH4VREOpUuyLOQq WaJlfYkf3sj3NRO0bwtIS2xTyCPmzWM1qaH/1/4nrdI5VZ3PyLjj1z04rOcNDcOG3Kqv+7X/AJ6L /wDqoOc07eTM6yQFGWNdwV04z3Wpby4R4f3cZjlA2upBHNZyj1QFbTVs0IimnbfPGS0xBCW57CtC J44j9pY+ZBCoV2Vc4x/E1ZmvIi5cm22/aogZDIMYXlVHr6VmIVkDyPCYg2YwzDD56A0GbVj/0P4l mtTv3ByW6NgcGjyizKkZLbO54PHWsob2OccoCiUygiQAiNxgkj1ArPkaJ5IEVHV9n74sNuTng1rs Fr7G3aWqZVt5DBdvtit6XNhbqAEkklG3+8FUjGSPWs1PXXYdn0KETx4MRWNnIOQRnaD3FU4k3R3K 3KlAgZYiCDk9jitDaKsj/9H+Jue93IFVQZUGDxgKOmazLyWGCOBFDLKDls/Mo9xQTKNxdPM0j+ap wpbC8fe9f5ValJSV0Us07LuO7sO38v0rnMbdAildFiRWwXyQTwznvUlxLJPJFunKiFduey4oN0rK yH2WoGaJ0fJxx83KsKuSmWL/AEqNj5Sps8kD9cf56UdSZQ7H/9L+KyzvJIklluommFxGqQRD5Ut8 HlvUkjPX2ouZIz5xtrcTxFPkLvtkXuT+HP4Vwy+Jl09zlVQqS0lw8UcjgmNc/Ng9K3VWOHfPFKxN 1GEeAcDA6ZqTUW2UM/79skjCK/3eOgqKa5urVZIrdwAzfvAOU/zzQBm2n2Zi0l25Sd3Ij3Kcvj0+ tX4GEkjyRuyRxjYyA9SPWgD/0/4i7iRUusQyPIhUFty7Sp7gfTpUTuVaFl3vEHwwJwD61550DADJ PI0aTRbjtCuvBHTJppumtjsAjkCt8y87ZPYmqUGwLEN01/BKk8QSAHZIRwhHofpWsq20axxQLG1p EBtUHKnFaKKjsUotsyZLVWLTW/lkNJlg3Bx7GrUd3biWQSskSj92vlnd7ZzVGqXKrH//1P4kZJoy xijWVvKwRJjmpIZJJZhbIm+FiBJvOBn3P1rnPQHRRnzSbyWGOMyFQsXzSBR04PerDqxyI8JFncrH gn2A96CWlZmPJm5vPI8x0UEBFHLE+9agsZLaFmJ39SeOQBQZxsndjbG4giYSiMCbHBPfB71fub0l PNDYxzsXoprSn1Nj/9X+IVIWMjzSsXJ+ZT6+2KtXEd4sPmRsYA42zF/lwprNtqZ6BDb3WyWG2UNP KW2hIhvZj9K7OOI208Qj3R3a5DuDkx8cj8K0HF2dzPv1mF4I3VnxGJUP8BP1pkYe3ikMmz5iWDn/ AFgOO49KhN8zQ6svddj7O/Zit4tYubWZRI96jeW7CMxbciPOB0PYn61/QV+y3pn2/wCI3gu0gWC8 vYtZstQMMrESaZaxSK0iY7DAyOucdeMD+3/B1LD+GmMry00k/lr+h/CPiH/tPjDhaS19+K+f/Dn/ 1v7NfgmIoPBkYt7iVbK4sIprVdpKwgqcrt7bcY/Ov58v+CyfiWG/il0yG6MN3dXVra6bBCm5xCks ZuDjqMhCp9PMNftXgnTdbxLjN6tTf56n534+Pk8N69ODsuRH8vP7RViYPCOo3CXXlTxQsVt/vQJF 5eCTgZD7tuB0+f8AL+frx79oj1G5a4niMtw+4xpAYJegG9wTnJwK/pb6S9X2fDVCl0ckfzv9Gqlz 1K9SxwWm2BYPMZfK4OV/if2ArsNMhsvLeNpJBLj5wBhx9DX+f9fdn9jxVpWNZ70WwImiZycRxSZ3 SccD9BVma+mSximWHdBLuTz3yGDDsB0rmezJe7P/1/4stIvZndBCFhuF+eKXPlvxz1+grqRqCX5e S4JmmWPYz5BOFHfH0ryZfEznMtFWSRJLeYGAtl2mXyio75H17128CRW9pOiEyN9jNxsSUJFKMgH5 v5VzPdjT5Xcy1k+1XMV3Pf3KRWMTRW9mqgW4ZsZJGOuB97nqau2ykaTLf2sYKXt55TzhAssRBxnB /r6VlU6Gy11NfU4J5DF5tw7Rxx5BikxvJA+8OnH9al0uK3ji86aMIbdTumcEu6+gNc821ojansf/ 0P5DYbVHnmlik82GR926SPAjB5AU9yP60RWPn38Ul05VIN4ikSLdhsEKT+mcV8edcWluXdG1GVH+ yXFzDdvA+yW5KhJ5ZB1DL06c8VcvUH2h72xuJhL9yRUHyy8jHbPHt61jJ3Y7+4b1tdx2Vtf6rqup NC6QxJYWi22wu5YK+5hyeOQPau88IJumc29pb3d/rds1uPOkJmA2khVU8c4yQOenWuLHStQm32Yl Z09D/QC/4JI+FNV0b4PfDK2aA2M7+DIHu40h8uS2VYyqq57/AC4Az/e9q/ciNpPKReW4xzzivxHK 3zZhiKi6zka9XY//0f5GtVuZtTiLS26IwISROF3hV2+3p+lcvF4dktNQ1GSw0+3UvZxzQQGYRJcM VBJQ5wSBnI9zXhqz5Tl5bNHPeZZWt+mpsYUupswiOKQeVGVPzKR04IP5Vd0+4jubm4uLm4MOlxzl vPKZkYAAtwPUj3q7a3MnuXLO70vUZpJot9hHc7hbExFGAOQFYE5wR9etYt9aSxi3ht5WghtXJkTA aOcHPytnnHOeKYiB/IU7plUTNhU2LgbR71bm1VIbaSE26SO6ALcEkPDg5yPqOOfWg1g9LH//0v4x 9M8vUrqJXmeAxuGEgXMYwR1PQdf0rqZ9Wuo4L6FCJFjkZS4bzPMUcFxx1OD09q8c4ZfEYCYSISyF wceY0bjcTWbdTNAC0dvK1tcnyJfKGGG4Y/KgkzViis7S10kwGW7e4YLd7yZQnZSuccetaek6HGIo mlv5YZWujGpjYPdSgYJ3Ke3argtSlH3bnRT2F1DfRfvpLiFlKs8p2S47ZHPpW49herYj9039nmYP KmcGXHf2znFd9JW0M5L3T//T/kH8NKbW7ulOIIJBlYoWLr1zh8+n49K4PxnHbDVZHFx5sVsVl8uX C+W2SR0PK9Rz6VpT6nlSTULHj3iNd96biZQZJ28wJjagUk42+gr6Z/ZuuLS38SwC1AMtwPOjt8gP uieLcg9dwyc/7Ir9C4CnycU4H/HH8z5viq8uHMVH+4/yP3k+Gcs3iGz+HdtBpFi2nTMNSmLq0d9d 24mbEjPn5TmMoFH9a/uX/wCCdl+Lv4YaQFuftcUtqDAVkDrHyoZT6MSRx7V/SP0ioc3DGElbp+h+ UfRcnfO82gn/AFdnV/8ABQbRJbz4QahJbQB5oGaGLeu5Vd1YLkjp8xGfrX8YfiAaiwv576ONbi0v biWa027o7XEzkqQfT0P05rD6K84vA4xN66f1+R8P9K2Lhm1BW3T/AFP/1PguwgezuLy4i88XOtXH 2ydhNu88Fdq4QcAYH60l8listva3SNCLphCIcFYTKMYQnsSf1Ff7O07cuh/jA3ZtDLexktdXvoVt ZUs2tw8q3rqHgdQPXGOhx7GsXyrdL6S9h3zrb/vijIN0ZHGB6jjv9K3hb5mMpbpG1caoiwi5isra zvtTgIEUILb16b39CQRnGOtZVhqDWt4y3LI6MQJInUDp2H866KZBZvprG4kuGWwCwnZLJtyWUqwx IfQZwT2rcghM1wl9LcSSQhBFdnf8zxFcFR74/AYrQwbuz//V+JUg0xoRZaVcxxWVs5mSGSFYpZVP yjco/i4FYq2+mJBNOs2+8s5zLHpkgDCfBP3vbPY9q/2wP8TyS6t5NukXK2Ml1e6pN5UlvAFKaejY +bAI6egHpxWrbS/2ZdwXCzBGtblVNsXCTz5yMAHtxgn6VUXZpAV9R06Ni8sdzIJJnM5RmyiE5GMf rj3rFsYYtMspi88dvJ53FyBgcnJyDxg5rYmT90r6jZhmW4R5ZJlbfIw/1Minp/n+VdHc37XHh46a tyyLcMkoiCBWd4+V/I0WMdj/1viCzh1KHQ7Nb25heRp3k+xgjzRuxt3ceg7f1rMnujcSvBcQNBEm be4SVMZ7Hj05r/byna5/iA27sbY3MOlPYTm3Fxc3EH2VJIlOG5ILHtgYJxSTRSQOI4J2la8lL3bO djoeoPoQemB09K0E9rGhp0el6bJdSu5ikulSOe4c4dCPlGD6ZI4//XUGoNZS2LQw75r60uw/zHaJ AQc4PbGR165rSFupg1Z2Z0cltfapDbNHc/akji2wwY2un94Afh+lci18WlZZIrlrW3zF5jHY5IHG OuVzWgj/1/hXTbi8tIZXjWOTzU8qV2QNPKnoM8c10FtHa3Nl81tsWSJhvmIiljODn5s9sHvX+5B/ hpPaxDFbx2miSoh3LHgRXDk7iFOMdcf/AKqZpIupGkaN7d1lUlPta7o1IXHyeh4yPc0HFUdm2ZwW 4voAGL6Xe2c7O7Xce6CcIw4UD6HvzWteWN6YIL22uHupmYJ8ylIcOQWPX0H6UJX0OOo+hWkeWCeJ boNIMjcgbp6gHtV28j0uaTJdoS0YKCNOhA4AA78fpW6XKrHM5O+h/9D5F0y7tLq3kjeOSCeVVjIm t/IlXaMj5eh7cjP1rIupo7YPFMkjI8wRnRcSDnAOPyr/AHQP8DyFUltYZJmKxQ/eTzuGc9gB6n8q ns5DqMrvZKWjtQj3yA4iibAYpn3yOnrQBpW14bm1n89ke3aQlIPuumTjaD1/OpntEh02YvNDLIAP JWRFEkQyMKCB+eOtaU+plN3djOjmc24YyoxL4MI5aPaBhsEY5z29Kdpws/JuIneSJ1zJEQMp6kEe 9aGUtEf/0fiRkQy+cgdpF74wFHqf0q35jSDbKdu7kkDAb8K/3Vimrn/P5PYtLcJEQuxJYvL24Zdu 4kYyO9U1aP7T5CvHHCAFjj27Uiz8oHp/k9asyL95od3PhIYZ5w/3GjjOQD3Ht71TWzMaeSmPkPzF T8ox1z9KAOkQw3dhvlAFxbgQQOqbYVVecMw+vH1/NBbWt7D5wmRZVJSSOIY6AY29v1reO2hm4dUf /9L44ubS4t5VaJnJLrIuRuCFSCP5VLMJrl3mllzI/wA0hPBY96/3gP8AnvKwmWK4RI3Y/Jg712rn uB/jS6iIpriOaF5FMcapKjfKm7HP/wBY+9BnPsP/ALOu7ix32kJupfNAkt1lCzFOhKjrxW9JplzB afNaGOIttR3XaXIGGAPegyktLGPgqrIq4ccKp4xVLdPEjySxboQ2JXxlYyfu5NbR+FGUlZn/0/ka 0+0WkRlV1igYMZH3hXw3GDznBzS7JUSWVWLJIOGU8Adq/wB6D/nfMu2fyZCBskXOWjYZRvY1opq9 ndQ3NvNYtBJEPLhaNtsfUHOPTGeB7UAWLee3a2gt4Qqxh9qxRJ8zFsDjimxXFnptw6w3cVw90B56 Qo+YyR918gdOmRke9NbkTV0VWDz38drBCJFkSScuCcrjBIyfTPT24q4GEdu9g+EhluEumbHzFoww UZ99xGK3FFe4z//U+Qrp5C6x26meWTiOCFfmPYYpnkPGvmSDypgvzRseeO361/vgf865tpZQXFkJ ILkyMYfPuoWh2xxkEgAnOPTk/wB6qTzPaxIFUMFyCAcMKA8gtZUCeZHmCV8pIXHUE4IHoMUy4mlj lcRMOVxHLjPPrVxSTRNot3LX2oxQiMsrB4gsxHDSNjBNVUgLeYVkSMpC026R9qtgEhfqcYHua1Im ktj/1fjy3uHIjmf9xOVDPC2OM9RirEgeWCRrVVEg5KH5d3POPpX+/B/znjYoI/JS6cAushjKlhub jOce1NuFRY1eISAk4kUjCoex/wA+lAEmno+ozpZorRu7Ze6kfZbwqO78ZH+eK0pIJbGBraJoI47i bfJMEVzMY+OvXv8ArQZzSWpm3j+bcgxg7MIPmGMlQBn8xmrLF7uQhUhgkYYeVkyjdugHWgzP/9b5 SFsmVSMh2jOd3QMagYGNyZEI2/dLDA/zxX+/B/zjjbS8ubfUIbqOODyY+Wj8verkY6g/j+dW72a6 kYXLiMRyNuCghWfk847UGMm27MqiR5zMWMcarmYyc+bKwGNv6d6hsLsRZubm1kVyxTao3DGSM5/W gkvqbmRXeLCRE5WRv6UiW810CZJM7eSc4P5UW6Af/9f5V2G3cKmSpGWx0GPWqFwxlkbaQx7jtX+/ TTUj/m+vrYfbRRxpIzAgYPH95u3FKgVSsk0W/ByYgSu/2z/WthlgTT3Nkki25sLlbiRZY4ZDInlD GxgTyD94d+MVTuIInMOBucd8fPnvQBeCLA0UjRq3lDayTDcPTkGoEELNu2Dy0bI4+UY/wpPZkzTa 0P/Q+Q5Z2+1edApXKGP5e+cZ/PFX0Zt8MZ3ZK75Q3JPcbR9MV/v+tj/m3LUDPL+88vGDtAdcMuD/ APWpb65aB/s5I3JjzgOdjelMDKErpOZlbKlNjHuc/wBKuLcRqg83OdwAAGc84pWSdwGSuTKd2RGe gHappbRp5IREygEgfMQA/wCZ9xS5Ygf/0fmAwTW7TWs6ktESPLzkLxz7djVMRQRKCkaoBIXyV5yf fr+Ff7/uKe5/zbl63C3JabPkC24aQj5G46ZqzKokk3rOhEKA/J8p5PY/jWSXvWYFWKC1llEa7jtB d0hADkD88UlvaPDciOW+iUS/NtzkIvoff2962tYAuYH37juVQdqM4xuHYj86jS3EDCTch35Vlxlv r/n0oA//0vmSOJwZGhAJkUqwdA6469/p1FZ9xDLswqgsoJAJx0zX/QAf825p6VbCUL5myONULzlm A6elVLq7tFlc2OZcfLuK5iH0zQBBD5cqA3AQTAHaY0xkEjgDPHb8qkWR5QYFYrCo2xxnK/MPSgDM uEnaYCTJOcFuwxxVyN0DbE5YfKdwwaAP/9P5bSR4mlMICvHF8pxll91HrQggsrflmc3H74yON0jM ev654r/oAP8Am3IniiuDCYWaUgYI5XaT2x36CpLd/ssp80LKinDwE4yOcj2reOyAqQ3BujO9tA8E CyNHEkowSAcZxU3+kLarwpYZDgj60wM5YLkSRvsb963yt2Izzj8qv3EKwlH3EPjLLQB//9T5U87z NuzjjoPWn7p1RhuwGOX9zjvX/QQf825XuLW5SBLhlEfm58vccb8HBpodxFtywx/DQBLFZ2ztEEn3 SSoWkWRNixsOi5yc59ajKNHmDYBuYFsjPrwDRYCytosiscqAvQdSMVlpaJDNLIzg5PCntx/9agD/ 1flBY5Z4nlBURq/lhVOH6dcfnUEkEkUPmBWZWbZuxhR7fWv+gg/5twihmR1WcFQ674iVwGHselLt aJ5GdUO44yPSgCRoJQCUgdiU37lXK49abFFKV5lVHjy43AFcjtj3xQA1WvZmMk3lNIXJYonlx4z6 DjpVq6imeR7qAReWcRssKhVjJHTH5/40Af/W+UoJHjAh2cE8E0+WaUXCMCylU2jB4r/oGlG5/wA2 5FG7KW6kg5I9aT7V5++NmaHAOzrubGcDj1rG1tALEUHnwASNsxyjkYP40SwqGCfM2erDofxoAhkg eIIYw2Q2Q3XFWYkumJEwVmc+ZFIn8PsaAP/X+WZLWZleV8FVfDGPHbrxTzGEbfCxWMRhzuG09sjF f9AB/wA25TOJpmwOOmMYFNmmlhLKigqgxgj5jQAyW2aSCOQTESt8+1eNuc8HNUHSUOI5HdixDMzN kZoA0njeBVAaM4XcrRNuzn/PSq1o1xNIUmBZHb5eMBRQB//Q+XZLZYMraIrM/LhB89UTPMpI+Ybe Melf9AB/zbku5o/LaQbBIcDjkk0XMQuCYfMdfKcrLEhwGwMf5x6UAWY1K2wWL5o4iIcEjJPOB19q ZKothkfKep565oKja+pCLlSrImZJHPyrj5j9KsWbWTXUCSN5e5ts6/ecDuy/4exoEtJaH//R+a9X bTbRIZLCSRyxKOkkY+Xrzuz344x3rnceZIGHPfGK/wCgA/5u03ziM/lMz+UzAH5ccKMU37LJqZWd 4JA8Um6NMFSp9cCg0JPs7FipbOOhzwKSWB7dWDqzPt3bFHzYxxx78UAVY1y2+E7XZeQwyQcU90lM eMb5AeSowCaAP//S+SGEwtgrAhh2qBbqWQ+RDCxJT55AMhcV/wBAB/zfmhaQrgBtol6bm5qtdO9t vEeJip2g5ITP+f5UFKLew9As3lPK254055+UfT9apXWyOZDt+9yo6ZpWV7lxi4vUYzXL28tyoQG1 5mWZ1AUHIBIPY/1r8jv2wLqK11i4zsggurjykhT98AyhCSuODjYMdgBX5f4xWjwDmEv7j/Jn9C/R qjzeJuFX9fFE/9P+NEtpsry4djGyZJK7CW7jH1zWRcW0NvBLtmcxH5sdCD24r9JxHxP1PjqUUrIz djeSSCcgZC4wSKzohI7sJR8gb5c9c157VnY2jGzL87Q25gjll80yruYIDhPbP+etWra92HbEpUDj 3I71zvdmsY8xaTV7m3eaBsywyRjyXkAJgPcA/wCetZN2y71mVt8jdAwzn1qJRujWMeVH/9T+KCJF kDPIgVmOCy1DCJIzKWcuoyIw3Ue/8q+otbQ8OmupPaXDW8Yt2kka3DGQxtkqD6j3rXltLW4t0uWl UBh8sR/1je+KDSxkRRqryLGpBB/d5PapbmFlIcRiOUDI2jBY9yRUy+EDHeW+G/zAzLnavqRSBgqZ 8rb5R+bHJqIqNtQP/9X+KaGYxpg8xlQVVeWOff8AGmSJEh3IoRm5cEYY/U19AeOTwWk19IPs0c+Q pV1VS6L75qdLZ7F0MsW+RHDtFMhCNg9/rQBZiuri2PmR+WS7Z24H5e1SzP8AaizNu3KM4UZAoBaG DeNKvmOjMCFw4XOAKWxDurzSSNsjj6k8A9s5ot0NYy6M/9b+KxBMJVMwBRxmN1PB+tXmuBsNvIFw vI/pXvOKaseXN9DMSJgzu6KArEgLypqOSQXUiRpHtjAwZPQ0SjfUIztoy4gtIBFsldpv4y/Gwjj8 qpC2Qu+2RnLtku2Dt5rK2ly3sdDo0cUFxE0oV3iOQzcgkjAyK05LrT4BL5+fMLFvlXcpPJFVT3MD /9f+Mm61ET7DHsjiMe3yxwBx1FZkyWxVXhJkLL+9YrtCn0/+vX0Fu54UbptGK5EUzBQcDG4Hoaml meRdvl7Ni5BXktWco9kalW0mmjm8xWzEx2yL3rYuHUIHyWZxtVO1Z2ATT2hQqHDRS5yrZxtPbFaF 3M0LNFKNz4wSTx9aAP/Q/iajhd3eWKM4J5foDirX2qeGGW3jG5XIZnYZZSOCBXqqGt2ecrdAtTBI BI4O7bgnHNOhCo4KzP8AM5ypXcFFWMgntY0aRY38xZWy7Y+93/CkbT54w5iuBGvl52sgbnr17UAO slWSQx8O5GN4wBkA5qWO3z5suCF3eWuGw59cCgD/0f4p3hgml8iMOAiA7JPXHJFWIbPajKyRKSfv MegH+f0r2DzyxCHWNhHhk3EK+PlOO4pkkYCFyR5+0oZX4IHXH0pWV7kTdkZ8F8rssUxBkh+VJFXB I9Ca2JoYJbUSPEWU8feO1j65osjIyo7VWIjtYA7McKp4RfUmtaTThaKvmfIz/MFxgj6Ulo7WE3ZX P//S/iwmliBaK7jwsJDK8eWLggYFQGxmdV8niMP5g2nOK9g8OTvHQ05SViSO9QRoo2QFxjGck5NV WjSFlilWIwuc7kwzj8aDMlS4jt3cRsWXcDEGXGMda6GHxRPZpJLFh2EDQtH5YkVQ6lSMHjoe9BrB aHMxlGXI2CJ8gbWGVI68dqfvj2F4S2Y+PMHQkUFn/9P+K6G484+WtukmDtYyDOD6j0q99nFsk0aY cOd5dl+bPsTXqctpW6HjjY441gEhVHkD8g8Djsf896y5HiuWadLMwTKSs8SnMcgB+Vh/PmlKNtja fwj9iStFEynCAOqlehHStwSlbdtm3zCuATzj6j86gz5rRsYrX9zBHJFbuDM/DPtzx34qDz08gSSM plB+VcfNn6UEn//U/iltr6V/OjaBJfOTytm3PFbUiQQWyHaA/wB7YqnOR04rul8LPHKYtrlUFxMS jzDO0HPGapxb5DLLEY5liPzh5NqtzjGKVNaXFHZETCQxvOqlAGxtUHH4f57VdsvEjRWyW0ZyrkQv GEAdDnljTmtBm3/aVjtltpbeZz5eYpVIC7j3P09K5+5imyZ7fYVU5dSM5HSs4/EB/9X+LBbaX7O0 sqnkc44IBrOniuY4khe5LLv3wEr2Pb9K73seOTWYQEyTASMG288kD2qO6vFViGjykZCx45LfX6U1 5gbMkhe2ie1BBjA3nIIY/SqZilbEuUV5JNrbAAx/woAkkhIgKMAzZyJG6j2FUbW3bAg2q8skn3mP 3R70Af/W/iluoJba6EBwVGN7Ic49cVaMUoJkYF1IAUHr6V3yR441PMj2mSQuGfBKrwgPQVqotvPG xaZ1kQhQzr8oHtWLVnYiUb6ozG86WS9tormOdIiF8tDhXA74qlareFykqIkCnbKM5kI9hSFGHVnU pNZQQuy2MVxCkWWSVOTgdM+tX7DUPD0ihdU0653SRmXNtKsT7QOI0yCM+9Bof//X/jfvp/Dhgik0 i3u7OyxuCag4kud3QhmAHfiuevIFuHjnjYMzKQ0eMZAAwRXQeTFe8UtPSaK4lbe0eU2tGBwwzU9x BbXMoZkDooBKEY5Heg2KN1YOq7reMsDiRlBw2P61IzC2tFYpkTts4YblI5Oe4/8Ar0AZdxGZC1zC FXylyRnmrVrA00f2mRdncYOWagD/0P4oZLhVuYwsOEIO+fdjB4wMVbigt768gUxhN0ojWWZsrGCc ZYjsOvQ10NHnnZ3vhmx0Zpmtry1lF2hEV3aOTazuAN2T1Vl3Afl1HNcy8cCyRWzTpcToAGcjbu/z iop6wTsBQuJY4fMhj2lon+Z4jvznsMGnR27WhimIjmKkTAMA6jJyAwqJr3gKUkq+exciNZHONowB n0qa33wjy2HmwkkReYSXB7GpA//R/irtZ2giWJ3DiKZpFDoAOT/9akubxHlE8hURfdOB0/Cg88cs sIWUqseZIxh2TJxkEEGqt3IJ4CBKxCrwiDJbHatIPoO7e5mWomggmVlScycfv0y6DI4X0q7ZzTJK WEaQJu+WJWyoHtyTWg4vleot48uo3AuEjMIjABKgsoYDGT9euKltXQp9mkDs4yxk2bQeayk09jVN PY//0v4kZbmOGQ4JB6KMcNj2qSOG8uJTIQu7G6NzyIse1BznX6bYWK29zc3t1Hvdd1rZ2seGDj7z M3v/AErMu2jMJd4wZFYgFeTMPQjtigCjFapcuYpLZrfOSEB5A+tWEtGtHkjJIidNpOcAgdOKxik3 Zlub6Fy1uVtoSZEWXy8rGmwEDPQt69az45YQpNy0ksrSbgiALEF9Kkg//9P+KMrJGd0YyHOcAZ49 Kzrl3wWjSQ8EOD8v5Vgr9DnGxGL7O0k5ki2nEbBd285wBimHT55XLvK371sAkZYD0rSexukkaUNv eWarIpd4Yv49pKL6AmrElyJ7bBZixON4OCtZIdrFcSoxxBIFmjGCWH3h6VR/tBjNLCUdiwC7mHAN dAH/1P4nIZLNpo0m2LkeWQefNb39BUV9ZwCVY4pHmk25ZpFwIz/dHsBigAi/dPEiqRFGwLOF4J71 sR2YuZZfIKM8IBkJ4OD0Hr3rBrUzSXOZms20scYkjWMGLAU7gDz1qnsX/VumJEiDfJ91jjpSsaEM NtdrCZ1QfZvMKBtv7sHuM+tXop25XeWVByrDn6D/AD3oA//V/iQl1RhC6xo25DyoGQBnqajiuZJk 8sMIwVJdsGuZxT3NYLS45d81pwkcnkvkuAPlz6VLYSSb5GnO5FXgkfdFLkiWdHZrY3IQOCvz4Eg5 YdKbd6dazovkRSRGK6xJOH4uBgcEdOPam4pqwGPPDbyTQspYqrFY8gbfTn9KryQSFm+z/KoO5mzy W9BU+zQH/9b+JO3t/NmTeGViP3nbpUtzFaguEdvKUfMVOQjf561xxjrqdBXRmdikThlQAM68g/U1 DcWiSwPG5WKYPkPH1x6GtCoq7sxJ4UaGOwt53lJjDzrsKAE9j64qaHS0tLcwhpmj6kKcgZ/hB/Og 2KjSSRMBEhSPjKydPSrsthtgYtCioV3q0ONozzz/AJ70Af/X/iMuWkgg8xnAleIeWX6nj0qna3l1 bQmCSDLS4ljdgSSrdx25rnPQNKHYi+a67nAzhu5+lR3ksly4JJQsoCIDgLj0FAmtLFN5XtggUKkn eUjc8Xvmtn7ZJLHBDapd3Mtz+7LrDuVcdSMevSgxs3oZs8c9uzSPE0L+YMoBlxjg8e+KrNeXM25b dAFZ9uXwWI/z6VrBaXNlotT/0P4m7bSp43iYSrOzKNoXPyE9qh1J7q3YwyOsuB88ZGdmOx/z2paL c727K5VsEja5jnhg8icHh1yqjtn2Na8Uk9rcljIWcucFmypB/rTMlJxLdzcySq2445BXb1FPuXi+ xyTtCPNgjZ1ZhkkY9KxT97QmvK0D9Ef2LbRDplj4ilgNzBLIUvIJlxHDLHGoizjkAkNxnnBr+gb9 g6zmvvjz4LlksyyRSlry6SHEdtDI6gBj3XIUAc4JNf3P4dL2Pg5ipdXTn+TP4e4iSxHjbg9tKsfw aP/R/tL8AxR6Z4KggiYh1j3AxpsW3iZQQvpwM1/MR/wWH8TW934htbTTkiS+gvFtYJIdtrdRRKHa 5Yk9d6E5xyflxX7r4A0ZVfEKMl0k2flX0jsXHC+H9aM/tJR+/t+B/ND+0frkw8MxpbSNtlsbgO8T gPKiiCQb4yM7h6nqMV+BviPUP7U8QalO2py6pC0xignmh8goqk8AYHv19K/evpP1rZNh4X+3t8mf jH0aKDjhq07dBdNt7dCDIvmbOUJPH4Vr+TAjLfWzMBIfLljK/K2Pbsf8K/g6qz+u0tWzVEUE2/c2 5xGCBjIHtVjYqNHG0qBLeLzTaMeHY8Z/z6VzzdkYH//S/itR2MhYJtm6j3+hqW105ypujPMrFiI4 4c7WYnHzj06148nuznOt0HQba6e6kvLyeaeW1MZt3Cww2qAkkr6kgd/Sttk0XR7WRDLJcy3ii0gl 3boYAmWBYDoO341ziTuSaKdIkma01MyR28yCRmWLeNpz3HrWre/2fJZRWOkllj+1bmP/ACykGe/0 5rGTuzaGxYeNZFijCLsTg4+81XHe2gsoItVUpbSv5QaIfNCvqT0H4+tc8/iNIuzP/9P+RbT2F3Ze Rp8kIjt2Yj7Q62ryAE42Kcbs9gOTV3THuPs1xDfII75LgxrARsAA/i56ZGD/AIV8edBUgtBNPOzw QwLu3NMnG5v72fWtuH7NLo14Rew2VwZfstpIXUySsADkL19eP8jJr37CeiZJbrcXU8Et5HFei3CA CZcJLtGM4Hc46+9e4/DXQ5dY8T+E5reyEF5JriW+m27EqhdwwAHt8o615uavkw9SXk/yBStA/wBH X/gnTo8+n/DXwvHcxxxXdt4NsILwPKArSm2T5o/UAEfnX6XSeZEqoBuPUe9fiGQNzlVqPrKX5lYe 7orm3P/U/kr1tE8ieNrfzIpYm8vyxjZvzjn6nNeaz3GoXkRglch7VCkW3JCqCe9eHHaJzOS0OYtr GDyL2GZIrjeQ0GVwLX+9tx689fWpXJtLCa2jkdLJZFXygh2sepb+hrQxe5tSLE1pp1pbS2l5Ne5x cktGmnkd2bGCeOgzVW5ll05msLq4e5mlXbbXixl0kYfeLHGB3646UCH3GmvPDFcK8n2ePEJkIAxI QC3/AOqs6/snSHmXbbKPnmAyVB45FBUXys//1f4wtHtbk2jh7q3gt2YmPEgBkA7E46n0961NBe5k vL6CEM8MiARI4XYQDyoPc5ANeOcjlaVmXJYkDfvSIw7EbcgsQMkgD6ZrnoL+aS7c7oorOOPfBE0e 5pB/C5z0IoM3boUCBqMlu++TzrWZt0sieW0x+6W3e/Xj8q31sJ53triO8nspre4GXtwA8g9QT/8A W61rTWhtHZHTec1xfI94J2azbCzSSfJcrtxzzUl5rEckRtYZliXOGA/ebeemK76fUiUUldH/1v5C 7C4S4njgEhXMeJLhYtqDt269K801dmGoX9sYJZbi3jMq3DxfuUXPBb1AzWtJXdjglG8DxLVJNQkk LXvzsGK7kXEYUEgYHYYxXufwFvY7TxBbPDEzX8NzAbQSSiJJlkuYEk+cg7dvJA7kYr7XhCfsuIsH PtOP5o8DP6XPkuJi/wCVr8D+gnwLq81ppmh29lYOEsdXs/7Pjtbj7UUtrR0d0Rx/Czk+o3bq/tP/ AOCTmvT3Xwg0XT2jdmL/AGzy7mMQ3MfzHKMPUcf981/V3j9RVTgihU6q1j8N+jBJw4xzSktrP8z7 M/bPtLm9+EviSK32qZYwX8w58khlO8Af3cE/ga/hr+IOjavo+s+Ip9Q1trg3XiS7iW1DbpTCj5Rp hjCsx+bAJ4Ir5n6KtRezxlJ7/wDBR8/9LGnNZvhZr4eV/PVn/9f4KguRA6XEcPmFt0K7lwSQckKf XgU/+z7wvY384txZTyNMIRceZLayKRgsvb1B69OMV/s/TXupH+MNaNkytdCC91x1tZrm+1AWvmXM cczzRsOzHtn074/Oq0TXNnG4l0y4gjubo2lxfSv5UYQDOAuCeueO4+lbqCRykbaus1zIkkUN0kCL bxlIfs8cYUDbtwATwOSeT3pt0tvOTNY2Ue62IM0rgSCMk4BOfpxW0FrcTvbQvy3M1xa3Qt3VWvbU WzrBAqRjGOwxjlQfwpLTUrHTtJtrO/tWa9eVrUItwzRlVQAOSBjJOTjPQVoYH//Q+BooIbFH+xfZ hduRLFcqxcQsRk4z7cfyqrZw391qluqw24JkM2oXsmVtreDhWkkIHBywAABzniv9sD/FBK7sdLJe RPZR3lrKmLOb5PLlxM/HysgzyOvNY07/AG6cT6ejXuoW+JTA0bF5h3VW6A89TxxTjugas7Ghq1xD amCOXTr1pDgCOGcHzJD1LngAex9OtW7UeF4nuIdelQJNblYl3mRVbs+1QdwH68VuQ46GbPcQ3kaX ryKbVYkjRLWEQBkQYXCgY3YHJPJqk0trdTIsBQTQRkWrzZidQeoP596DE//R+KJptPhht7K5nguZ ppERZwGKqzjhcgYHXr7DBrBu7Mad59sGnCCY+YJJTMwYE8bienJx6V/tyk+h/iA9y1BcmcWahY4Y bU7YVUDCnjJx+A/KjW7eeK4tp3ggksX3RrKzFQ52jIGOvY9fStzJzd9CO2vIgZnksobsNtEIeXy1 hKtndjBB/H0p8tzaS3AJt1gaZ9p2n7xA5z+Ao2M2+rNy1ns4YDFJ5zh3CskTbWKnqQ3bj+dc/Yaf EJ7m3drnyxvuITOTKEGc7d/f8a2g21qS3ZXP/9L46tTYWFsk8+y6SJFZURS5ZHIwDj0JOT2GfSrW owXl81tus00+xmkCh4QZLaVMAhozjOByD7iv9yD/AAwlLqyK4+yhpdKMzTBbYfK0bJbhQcAgkYzm sNp3t7ae0gCR/ZbpLhlQZlKKSGC49u1BxTfQjS+FxO87u8qF9q+chUuvXOD0/wD110epzxXtv59l NJbyQSDbYqDtI6ZU+3vQtDmqIyF3Yfzf3zmJmMZIVgQDj5j6Hms7TXurW2tby4jYtdqytHcxgOxH UY9vUentXQmnsclraH//0/jG2sY5Jo7oySJMp+0Rs3AjxwMfrUV4twZZJ5DHMshLM7vh3OeWUevt X+6B/geaUulm8htpxJJLAIlJEkZR+RxkHofY1nabp0WkXN5b2slyLe8uvtU+99xLFVBVfQDGB9TQ AsskOmSXL28LkSOCEdt3l5/u+vT9arWt80s5nuYgqGJ08uTlclWCsefXBq4NLcwe7FsLKa4kllW4 jjhjJmYtwQox8o9c/p+FbUMthbrOpaSQ3MIV3TBRcZ4A9eetakSV1Y//1Piu3uIJHuAiyfZz8pUD 5vl7evPWrF3HJ+4khgCqwX927BJUB9V68V/uwf8AP5UTSNPVJ9HgitdmZ7gxrCo5AUn73TgbWzVX 7MuyTzoyjoofBX5ucbT+OQaDIzZbW7jhVRcvdTF/Mhj3GLbzxv4x0qWW0leKKCUKbhsODG+Qpz04 9x3oA6WKwuIrPyIJop0kjzPvOxo3wPlC/wBfasND9h3BtsV0X8pZGIwgzgj054raHwoT2Z//1fki 1W5ut0is5EXDSYyhx19qgnimikt5nZHWbLJtwc7Dg7hX+8B/z3k0yPJbif7Iow20PEPMI9MkdPpW ZJZXFwyzlGCQttODjJOeKDKe5qWLyw3SwvFIDLH5cez5XQnGD9ODTbM3bG4tzJL+7lZovNbO3J54 7UGbaTsJayRvNKLm2nZohjz0cCNOQMsuMkfQ1BfrBJcfZ7eWRrF5ULNjBbaQclfrniru4xVgcU9z /9b5RjktbaOZvs638sYUQQvIVjc5Gc4p1hbb2mt7lhbJInmxhVLxAH+AMPTP1r/eaDbWp/zx8iWr Mq4tUtn/AHbDywdoY8lsVRdRLLLGJYkkb51j6FhnoPz/AEqiZNN6Gha2otzguI5IhvQkkZI5AHvV VFSOfc0fz7f3kjDGetBD0TNA+Tbwvcs8pcpmBUT73qCc1WzJIqy4AVvuCT5mX6j8q2jJPQzvaFj/ 1/jy1lETyjzEVimDIw4UZB47g8Dp6Us179kybkpqtzeIRY72Mfkcrkkjg4Gev94elf74H/Os9EXo J4pbNrSS5NmsiESKj+X5jBlZCx74+YfjSgRpGgIaWWRipJb5FHQGgwKr2su1EadwsTZVsg8A7iv8 /wA6lu5rV5ttrEYYcDarHLMRwT+Jqlui4XuKHh+95RY7Nu8LkLz3NRCb5yjY2sMKe+e1bBPc/9D5 HCxKCbtcugGWTgkD05rSt0hdPNTdCpBSJWXBwe7V/vwf855mvYtHMyk4RzlCh3KO2R+tMltLkJFB BcgK8gMnnAuzH/ZH40AXrmWOxBsY4ZFaX91czq2QSp4wB261ReFFVgsuxUXIV23P9M/jQRPYrm5e O0SN4slZm2Sk8sDjt/nrVuN52t1mhkQPuKEDllxxyPfn8jQZH//R+SbWC62ytuLBV3yFeqjIGf1F OaMrHhtzqxwCTk1/vwf845asZbRCba5t3k3H5NkoiZfccEGp9UtbS2thPb3iXNk83k9cywNwQrD1 HI/A0WM5rqVEjtoIEGGeUyZLk/Lt9MYpFmiln8sdlztI+X3oMyWZmMMiIdqxDPA4Azil01P3U8rS DagGFJwxJOOn401owP/S+V5DmQ5Y89U6A1GyW6FpWYowHyoFyH9vav8Afpyu7n/N5dJu4KiEtJ91 GPyKafD94tKcAcc/4VcZ33J52F21oGjTz5QW/ebU+QNtIyM5+nFSGO3SHzUIJL5H95BzVXXcvniZ 94ylky7lp+mc4Y1et0gggVH+WV8717j60XiNySVz/9P5TnihhAaN0ZCuUKjgf5xVYKjuszBzOBtM hc7cemK/6AD/AJuZNN6FqO4nUvEy7YtnmI3QkjjirZjS8iI+XziOWagkZ9hUwtbRsi3O3KszcMR/ kVUgsZY43kmeIskmwRh/n6ckflQBahEVzvjY/OnAwPSo7i2hfykdxtRgyoG25KnI/lQB/9T5LufM hmklJYBzwASVx7VYjE0sPbB/Sv8AoAP+bcsRGO3hKOcF+vYHNZ6ea0pS3dCoYeZvbkA9cUluwLT2 MVtMsytKTNgThTjI9j9KjnWLf+7J2Lwu7lvzpgW1uZJLWO2QblhYyK7cvzgYJ644qLzHldCoyIwS y+uOtAou6P/V+XPtrM2yNjFjjIOM9qZcEvGFB+cD5nB61/0AH/NuPhhSW2lj85I5ShAWYMY26+n8 qYYYFtYUtVZHQYnLEFCQew7CgB0RZGTChQOrnp71Ji0kkVBlysoeNgcDIP8A+ugC1ci3Z2RF+Ydc clW9KybaWJpWZYpC+7b+8XbjBoA//9b5qui8VvJNZR+ZciInyxgEjGD19s9axpYFuY0UTRiVRwzn CepX2PH6V/0AH/NuLG6W8ZfB3xDLKvOfenSlpACMB25GRW62AspBNJEZUZQI8b1BH4cd6YiPJKsc rEQk/PtxnFMCSONUuJIBK7rEf9GZl2+Yvt/h71FcBmlJn5X7uBQTF6tH/9f5QtY9k5+YAfwknFXI UVruf7VcRJDAuQMEl2HGB+Nf9BB/zbkN28cj/f3RIfkZcqp/DjpVaNJXJ+YY7DFAEqXUcL/ZyqyT AZ4PzrVsMZXVZhiM8s6jLigCCScwBtgDJu2Z/iyenFUyA65Jw7H6EUAf/9D5R2RQqjQzMdq4kVxt OT1x7VCFkkym8tA8gd+cBSO4/wA96/6BZ7H/ADbliQKVVImL7BgMf4fYVQggk8+aaS4aRFXy0t8A Rxk4JJ7k8cZ6VaAlSSf52VlxENxUuF3Y9AaQt5hDqjbhyQT8q0AW4923KDeWG0KPX0psNrslaNvN S4J/1fIHPbFJtLcD/9H5MEE2+RZCVVW4z94EcY/StBLc3AVNyrgYDE7Tx6mv+gbnR/zblRba4EjR K6s6MQzDoQPSrK2TxRGRghmYHy8/MAfcf0qJNPYBz7lsyk2HmHPA27sdvxqg085eONoGjDICCQcH 3z7+1QZOTTsWBJIIliMhXDbh6f54xTmnnmk2RKEIHRehoNT/0vlu2Mlqskoy43ZfuOc9aaZp55/u Rhdn3R8oPoMV/wBAB/zbkIlnjVhJAInEhVQvTA9arShZXBJZCD0HVvUUALbykSFVVsBuN/OKrXUk k0swkQLtbCMvRxjnA7d6AIbIr5ssJV8sAVck447YrYiLQkZHH97HNAH/0/luMpE7zh5AzLtADHjr VGW6+wCOZX885JcSRh2JyeMdPTt3r/oAP+bcnXUZXVjNEqh/nC+WAyemPSs7crSSSB3GDgKozyfW gCq4uPNAhSUuvzEITz/+r3qzb3fnExyEZB2sG6igC0IjbXEMoYg7/lwMMuMYNXlNqk08yIGkYEB2 GXxnNAH/1PlGSZJgWcEBT9098UyFEV/tHIgyIixB2IW4Ga/6AD/m5i/eH3ETpK8O8SQltwMZyrEd CD+NQnzRkB2AxtC5xjFBsRRlYdwkLYJyeeTUMswMwkj3qMY5POKALKsiRtLgZYZ3N178VZ02aKfz luI3SPHyzA/6s9s9eDQB/9X5MnkMeUfJAPDd8VAEWBVkU4MgyB61/wBAB/zfliOUgbn4kbjjgVn3 IlYkK3fnvQaU+pJbbCpVz83THZq0JdPSI2s106TKy+ekcD5dBjgNxgH86PI0Mye8PkE3FurxrJul h6rIqk9ce2fzr8gv2xb9ZdaN0bT+yrBL+S6S1dfNeKMrgKp/u/Nkd8HHqK/KvGd28P8AMP8AA/yZ /Q30Z4/8bNwv9dYn/9b+LzUFigljniffDcHzFjIwVz/SqEU8hlPmKJI3kG1Oq4HY/pX6LWf7xnyd ONkLqUssqSNDAkO3keUuwKB2qnaskirlTvc4OB1Oa5JfEzQttb2r3ELzMwSPkgcLXSvF4dNtEmnz LdzT9ZpD5RhIP3VGcHv61zy+Jm8VZWMWVMRSxtEGLcRSbjlP8axJSiyJGxIkHyEgZHvUjP/X/ijR HjbcobyicLu70s0f3wCMkBlA7exr6mSs2eHBWuSQwuQsmwM3RkqBLmUSSoVJCMQqkY2Y/wD1Ui2W VAXddsoBijOAuWc/8B/Cm29wbgiWSUeUDzlfmFZSknohNtSsU70zli6uvkA7Q2MMBUMccwkyD+5d PmG3Jc/55qBu9tD/0P4o/KktfKnhzvjbLIQDgdiB7VE9xNcSOzIuRxhOjD3r6A8WF+XU6jSLtoYp iJXt4jHyiNzIQMjj6/zqnNdtdTETE5C5XPI496Bq9tQTypFARF2kFfM3Z2kdeKh86WBCkEm/58YY cA9KBlVW/fB58DAw8eeH+tby2Mf2djB9nEVzHukV3HlRr1IyfpQNJvRH/9H+K2Nj5yQAowD7ckjC /Q06WMkMFCnkndnrXvSdrI8hprcYNyxJFIPKZm+Q9d/tTfsd5Iu2GLdJuxhTgketUIhaAQKzSJ++ ztGD6VUd/OhaSN/JlD+WwzhTjt7VjfdI0jzNWNSwhkSMtIGDAZznpVS+uHUys4LFgAgPQ9Ac0QaT 1Mz/0v4pISLu4iu2SOMQoESFc7MgBckE8k/1o3Sxm4RgEikHzbsYABzn2r6A8ZRSdzsvD/gy68Sl DarHbWcFqbn7VckrFeEfwK2Oue1cvqGnz29yYXQh1lKIAem04FK+thlO3TfLvCgKM7kI4YjvVth5 rLCwCMrZBHH5UO3UC61pFGii6fy8DckqjP0z9azGmDMWkcsgO1AFycdKykrSYH//0/4sUSO2LiJ2 lhxk/LgfgKiEkTsJPLLA8PGRgt+NeweZBaCwRnLZQRhecdQB71ZniggihlVmYyEru27Rx2oLM6I7 2zjMYfBLcKMVbnWGT9yZMZGcA4oAgtwIppVhj2oV2qR/FnrT7gwRRbEV0lRD5e3J8xs9+eP/AK1A H//U/idS4mRWd0Rp0X5Nx+/6CnW1759vJFPEBKW3OxOVOa9g88vwzzkhd6hIiANg3IRWpdSxSwjc iglNw9TjvQKUbo58QeYS20LxjJ4q1JFPFbrFG7PCD5jAH5Ce/wDKgxas7GlbM9vAjoVRTzsHJHHX P5VZ1DxJLfWcMM0SSC3AghYRATMoPTOAaCJK6sf/1f4qbpi6DbHt3Ab/AMK3tCeKBt9wBNEq/MjH aB1x+teweJytRsUtd2XwZGAEedykc4x0rBi8pY1iLHEXAJPSgmMbvUuuo4Dgn5PkZDgj3q/ptwIL YxSBGQMd7OoDP9aDW1titNaRxXD/AGZMJN+9G3OzJGTgdqVZEjjjAiWJd58xRyZCe5oGld2P/9b+ MK3tYQ4k3Awv0C/I2R1zVTUWkWQhZDw2ERRjH1r2DynG1whMPkyrJJ++Zfkj+783Yk+grHWeVXcQ ELIj4YjqMVMvhZU9rGlA5RA7uHmd8bSOafJKwGDhMHkY5b2rEyM3yYzO0se7YV+YjnB9KkhgmZWi e1jZn6TEHcF4I+lAH//X/i5sQkSybkj3xH73p7VpLOjMGG3zVHIHOBXXN9DxytPJIytJG65yUC9e DweKwvswiTCRqnmNuwpxk1KbjsFraGjCfOtwrRhQh2/KcjNU2sI7eXzjhw38e0Aim5NhaxsWlik/ zrcDbnJLjqfQVFLC8TmMEhN2AccNUrTYD//Q/i2JuIo3UPJIr8Mi5IIzxkVftYoWeFrqMusabCB1 Qew/Ou1TVtTyFFvYxbwGB0ezUsJJdpGOYx61Ve0klweBIQWbc2OnPf6U+eINNaMntmdI3wCOMBRw M1P5XlIrENu6lc521S12ENeSUhI3Y7FbeFLYCZ6n9KtwyQKN6J85+XzP73pj9aAP/9H+LBpXjeQe WfMlXbkHnBx2qS3druRIYo5CEHzu42qSOor0Dxy5LAsEoxgp1KEZwaZOscsJ2EqAeSONtYPcDlWm fT7vzF3LG6bSx6Nzwa3I7mJVd3XJkUZkBztxzwBSAnWb7VZvKjssI+Q4HGf6VjiYmaGNSV3N5auT nrxQB//S/i13zQ7bQ7Z40Y8D5lIPU/pXS293bxqkT2sbME2rLjk/Sug8mOkkZBlWOWWKdJYifmik Zcbs54rKxLC01xHcLcJvwybcNBj19qDYs3OqsTBCoXzTHukdOVwegz6+tZd9G6KLnftQIXIx8rHu BQBFbwC8RFjJQynp0DntmrflzW04hlcsCm0CMZAx60EuVnyn/9P+KSSK3kGIy4ZThgehPt/hVUSG JwsbMZIyNxz930FdC1VzypPWxbnu7tvMPmOscoUiNuiY4yPrVS13JdZlQyI8eQ5bAU+hoNI7IbI4 tJmaDZuP30I3Agn+dWIdQdz5MaYaRN0m4c4HpWMviGQFUSSCQZeIzfvgRu2t2U/WtO5u0KbtgUK5 YMRh+3FUodwP/9T+JxCskiKSXDHJYnt3qaWyMgkwoFuGwEPJYe9VJWZ542R4bZFBhkmwACAdoQDi nOYhDHLGhSNyQj46t15+lSBmSzTpcNG+1mkTg4zt96iVpI7hIdpkVsOJm+Xb6/gKAN+3mtjDIFKo UbLYI2v9PyrIlvLhpJIoFJIXcpXqB3NA02tj/9X+JS1Rp5YHkVGWIZHTKn3/AEreluIYYCTw5+UD HLVEpNOyOaPwq5mXOqfPDZxptuWAZNoOPfcegFW2lYQMHCxyBtyS7vmyPSoV3oMY+qnasjMkku7D OfvDHBP1qL7XJfRMqzr8gJZSwDke1Wo2dwKyvLGrMjnIXYQx+8arWomkbEzmIFyS+zdtH0qOV3sg P//W/ikkumyhVcoF2BAMF8dTUMkM0yExxFv4h/sn60rI5ymluXlkVpCiw4brlS2RnArTWaeR0V2U 7FEaZAXgcAcVM9jVy0K+o3t1CkkAaSO3bCvFghJD1P1/+tVK1kR1lRZGLKAwjI498Gstgg+jJomE ixRhV3CU/wAOGHrk1Xkd4ryQeSU2HadwwRjjP+fStpOy0LP/1/4lwkLSxRr5f735mLce+TVm/mgT b5eSYxyyfMW7YNSn7t2Bb0+0u7qCYxtbF1AMdvcOIWlz/dJHNRTz3elxGSSJBcudpCOGC+gz3rJu 7MdpleR47v5nLZABlyOc+1QFzBGxKNKoGEAGSa0gtDYz7eaW68q1Wd44ldpUt8HYGPU+nQVpTN5e ZJVUBQEUAbQ3GOfypqKQH//Q/iLhuBGJIwp2XPySMq5B5yAfpU0Qls7eWURRyRu3lESKN689VHX8 vWocE9jWG1jPZBBKpiXyy53GDJAX3x2rbhIeDylhQF22P5jfIAeuD60KCsWV1laLUGgQLFEqCPcm fmIFbu24S0dWlIiVy3lrnccjr+lKUUldAcbO7wzSxbmVd26IZ5XPIqzbG7CKpYqsXzdOvvWYH//R /iWxG8ZAmYPz5jngDPvXNPHcwyzRNcZiLYJ6DB9u9YJXdkdB1lpGYdOjSJUSEEksMZY8ck/561SQ KGZwCJAfmLH5fY05R5So6M1bU2o3q4VJNhdpThQwAyeT9OlZp1BApRNwikk8tWx8wJ4FJK7sipO0 kUWS4lkCOejcFhgD/OK04Hld3jkQxrgAxhjtbA4OPwrRQS3ND//S/iKmjNw7F0Z24jG7qig9hV7Z +5Al3+RDHtQAZKgehrNwXQ9AoR2VxcxtcfNi2O4c/M496fFFI4LsP30algp44FZgTxxWxZI7olmu FYttbDKcHAPt0p0GoXuliJbJljEMpLPkhkz6HvQFhrXss26SUlpHbeWdtzEnmo2SGXy7iFCzwvua POEftyPato2UQP/T/ii06/UibKsSh27lGVX3qZ9LiupAY53iLfPMz/OM9vcVg3d3O6S91lC4hlsE liuC6vIcW20DY4/vZ9KpRzPBeQee3nqGG8YwMVpd8lzEvvb3mXnj3NEHLeWo3YFX7OV72AWcP7vf LhzInzREYzkf0rJJuVuhjitKfyP1M/ZBT7NDBpgitprLWdXt5wIgZHIRFidRj1Jfpz0r+jP/AIJ5 adHP8cFiuN88GmWsFrqEEK7RZTNNmOMt6kEGv704Rh7HwZrW/wCfb/Jn8QK1fxtotu/7z8n/AJI/ /9T+2LRoIYvBkDy/6E72Ae6hHDRfugcfjj9a/jw/4KtanB4j+LfkWspMtk9xHfwMSscLSBY4WJ7E 7QPxNf0V9Gul7TjuU12kfg/0rZ8vAsIN29+H4H8+f7ThPhPwRfrrtpbw3sa+dcXKP50lvHIBGoCg 9C3l9RnAr8G9fvpxq10FtIbeI3AMPlrtSVCBh1+tfo/0o8RyrCYZLbmb/Cx8p9GqhbJK1WXkvz/r 5k8k17DEjptDEArtG4L7V1Bv5hawKYEVzGMgfdz3NfxVU6H9Rmnp0pikRpInIm6FuQpHU/StJoXm lMjsoX/Vo56kVz1HaJz2tof/1f4yLO1MMsXleTKyt8zXAGMdwPf0q3Pc7ZmSEMrrH+8jQcOB/wDq rxZfCznsaVoElg837PKiTIVYyffbGQRx+NTR2kEiOrW8ItymxwRnfWI4xvsWnhiZFYHCBfLXaPTg Lj8Kv2kz21u0DxrGFYlMjDHPrXObJW0RO91dqsQFsTE+W85DnGDjken+FTX2pxXmn2lr5MoaO4KP LGm5pScfI5PAAx+tYO99TWEdLn//1v5KYbGKa7i1C11b+zn0y0SSOye2jMFzIhUZJ2k57gdDjms/ WdavdM+2alNBb6i5BkuJZF3ykE5LAA9a+ObsdGyJNAt57u2NzczxxW924lij/jYMA2SvUDmtK706 B3isDYxySNL5aLbjckhySJOO/uKxd76mbb5Drre1j2xxLlWiPlyK/DoRxzX1R+z7o83iP4mfDnT9 PhFybfxrYR3EeRGu1mOW3ew6/WvGz6qqeX1qj0Si/wAiG7Qfkf6LX7FWk2tp4FjhNqtm2nWsNrFG jGXYV/dFQx7AxfrX3coPAJ3Pjrj8K/FeF5e0wftO7Zvh/wCAvQ//1/5KJL4iNrNL6FNWu3e3h0+V AilAMFwx/WuFaxmjtSkE6PeIZI5yWCKR049R1rxYr3V6HJy3ijBuEjtkCKu6dB86RjBf1xS3Cajd OdKlHl2E1qLuzeEKx80gqBKAc54yM9iaoyI/sdvp2k2MX9rC+1gk/b7OK2aJbXafkJY8Enr8tZdz cTGKFJp55ZWuCskUUO6KONu5bqMdKAGGaGyVI4pmjtWmbyVncqrnJPTPU+1WZFa484TXMlrDIAyp GNySEEHB9uPegD//0P4tIGFyUEUmIV+Uqoxkjj+lPu7kQL5VsNr2snmKISd4BHf36145wy+JlxI5 b+1ifz3WOKMvLMoIdN3XOacbGxxBJbTT3aGIKylNuGGQQO+PrQSNvLCOXMkd3JYm0RbhLUKW+1sC P3QAHBOSeeOPWtGK6u5YdM86A2cSwF/I6maQ4BJYjJxjp2IrWnsbx2RfZJLmFQ6Sh5ZdqI2YSfT0 PrT1sbeDzrUtbpeLCZ3aVwGUAfd/z3rug9bDtof/0f47NJumtoxEspPmPuLkbyoJ7Vk6zYI8tz51 +8QnibMuw7GwAVVsdBkA9+nSt6Ds2jntoeOalGYXWKb5oyd3mAZJ6gV2/wAMUtT4m0S1hvobf7Te xhmYZZAkqO5PPAXbn6V9NkdT2WbUJ9pL8zzczpKWXVo/3X+R/QX8JLm506xS80vULS7ufD4ig0nf B/o80JzJKVQ/e3MOnYk8+v8AZB/wST8SDWvCOmyRStatqmnRXTwPEVlhbYHI64GcnOPQ1/Y/jVQ9 v4d0qyd+VJfr+h/OX0a8RGj4gZrhHu02vlKz/M/VX9pSzFz8LfE2Y0ZbnT5Y3fG5o2Cbk+nNfwu/ HDRZLH4teK42s7hHn1W6S7i8kyW8LQNEluxYcAyRHOD/AHfWvgPoqVOXH4yl/d/VEfSzoJvCVeqb P//S+P4rbT7WCVblWWWS48yJyAVjLgKwA98L+tc7ql1pOn6uIbm7ml0y3tt8xgg2Yd1yBz6e3rX+ 0dNan+MtUgSC10a0TVIILmE6hMJVmC7JZAw49DwB6+1YWp30V1b3Anv7xoYb77XbbgI5IVIGQxHX JHfPWtTkSdmhjTpeJPDpCpPa2kSahKski+YccbiB9T+dUn0tLuNb1QkSFwCwn8vzCORkZ6fX0Fbr bQg0bWNoI3jtrqJpYZDuChZIiSOme/Tr0/nWhZLC0Lw3sdvuU5ilZvnMh44FMzcd2f/T+AJ9J8n/ AEhJnWPH+lR3ILhX5wI8cAY29utUrXVXtFuYzZ+cZVHkXBkCfZmDA/MpzuBHGPfrX+2KV3Y/xTg+ hBFNeQxOb5YZ5JctbR2qrbxxIPlUOgGM8H06iodJmn+3TyQyyW7wfNEyE7mJ4K57cE9a2UUthT3s dBCYrq+gt9Wv3W3llBkMbHezH+EN/DnHWt64+yQalaxwwWsklvGbbMkasr7gQOehPI5+npTM3szD RdPt2eW9mvSwcrDaQxKLHtgEjBHesyWaMXL7Ih5QjKpu+/k+lCOeS00P/9T4c0q3WbSojfRxfJPu UFPLZFjIKHPX+nFJdS2tncXNrcRzSwiFZI2iG5HL8gD6fpX+36VlZH+Hk7mbHsjQxjZEkku9NyhX YkY+9/8AXpmsQagrpa3qOYoUD20SgbUEuMybv9oBaZkaC6YIbaAG3besIMZJK56jPv3/ACqO2sPN Lx+YqS7vMUOu4H1APaqjG5lO9zTsrUo1x9pjYzgBbU7tsIB6lvy4rUsL6F9Nu2uZ4kubOQwzovKd B91u/UfnWqSWxN3ax//V+DoVuZbl1tIWtHL7PKuHGxUJGDjvxz+XStSXWdQ0y9S1e7Sa3gVWgjUE xgjg5z27Yr/cg/wrnL7JDqN1ql9LJcwi3iguTtmhA24QcjZ6cgfnUUcNwlvIXtpFkU7ln3YZwe2K DmnuZ1rC7ITcM2UlMhA+XbnPH4CrBgurTy722u3ng1LdMgkkMhj2kLtAxgev41fJJHPN62Lr79qG UtE45k3H71bVnqelR20McsqT3kbGSBJYfNCrkD5GxgHnJyRVxi47nK92f//W+NCxYTySTlLMQMsS 4LMSTuVFx0GSfzqjaW6Xlssk7SQCFtx2n05wT6Hj86/3QP8ABOMdCy3iKa2DwQp56hgrY5x+v41p CG51E/Iqs8cXnZjbDDIyNw9qDMzxA0ixJds7Ss3kIzg/LjnLYGB3qWbTo47Z4iUMzLuIJ2gDtg+9 BjJWkyrDmaCWFVEKxptfIxvIqq6tGuUViqr83GcCtIX+RJ//1/jGG9VHt8+WzIQQAAuOc8469K2L pNPlvUvJ5gubYGGGN8+Y39046dPwr/dWLfM0f4A1I66mHPapqE0m1GtUQ4QLyW+laNho8K6ilvPf vbNd23yyD94SFB+VucVZzyjY09c0WewntltJXMaqGL5VzJwMcj61j7LrSbgzzwiR7gr5MjvuMGOp Cg+g79KBW0uSvIVc3jyM38SiM8GqsEEF/JIbppNmPMEanDHHP51tD4SWrqx//9D4+ttRurazljg3 26yEqY3w0gUHr7E+1VYkKESyq5xnbnJHzf8A6q/3gP8AnvNWJr23SOaFlaNpg7WuQ5YKerJ78io7 25nLHYpSGeQytHgfKT6emKCJptaDrWKC5NxFcSzwutofs0qjdhwVwGz2xu/Ss4vJFN5MbO6hM/aG XarEYGDQYtJmpc2smkafZ3TXTPPqkbOIQ6lNm7GCRz1XOD7VkQSNcwSTRQSIY5jC7OhRCy4J2nHP BHT1q5KyQz//0fjWK48ufdKRHFnDY6+lasmsnyU06KFdqyvMLgY3S7goCnvxtPfHNf7y09j/AJ45 ozjDK5LzkGKNgEUn5gSfSte78Pz2lsmqXlhiOYqbKfcC7LjJO3rjkc9uKsizexnxiO5uY4ZGVcsG DOcbCOlTaxIIGDLIlwmVQNuGQeAcnvQZz2KM7SSqqgqqKoAReT71eRUW3GZVLRqMIfvN7CrhuZ9D /9L40JE0wjXYhOWYudvQZ/yKnkUSKu8cgYXHX8K/3wP+dcqxQW5kjhmEm0H96Xz8yk84P0rUBjhi EMI2gDbGCdzKB0GfYYoMoxXNZlKEXK3bG8JFu0JEbxkn5v8AaH4D86m+zxSHKDzAGyrHqlOO6RUW uZpFy1upYs28ZRU5EqFR84HY98e1V4o2uDcSQxkrbneWUZAweNv+e1bin0P/0/kJ7mO4ZPOtzEY4 wjMjE+YRnJ9u3FaDX2YQfLO5h5OI1ChUAAHTv61/vpKT+E/5zygyssyNayvMETaUZSCM4yCKvGcY laRFGUCKEGWjx/8AXGfwq47ICvBcW5ci6eVSATnbkn86SIWDRzie2mmMx+WeOYwyw7T2GOc9OenG KZMvhY+drB441a3uIxHHt3LIJGDY+8eP0qtaRu263AYludqjBOenHWgxP//U+TGk+zBI8yQSMDHs dsM+OD/SrX9oRW9v5MkInMg2qTwI++4fSv8Afg/5xzLW58mZbyN0doyNqOiuikeoIpsJVo7njiWb 7Q+7pv8AYVba6ET2J7aZH/dOOhxz2/z/AEq6ts/nTNCnmxQ4EsyAmNewBPb8agyIpoYrtJLWNhGC wLuh2uMc9c/pTJERbyOEiNooIvLEqZBc5ySfyH5UAf/V+Vy9rKW2ys88bAOi4wgxxk+vtSSRrKOG +UDknt7V/vwf83vKr3Y1kCiBUVZH3cMW+7niorotjavXOWIHA/CgiULbGcyiXLOwVLfJMpbCrgVb hYyRBkIYN90j7rCggtxSOhSPYh2sCCwB5H/6qbfQzxzmSWMo+d2G75549qC+R2P/1vkV2eFWCsze YQxVuVH0qNrvYCoRt64A4wrfSv8AftTa0P8Am65HYkjlefeHmUeXGTEjtt4GTtHuTnAp8E0g2u2U XvVKaDkd7FgykyCUvyOB7VCXLTF/3jNjJ/uqKpNPYi1tC1AzsJJIoywTliKYIA6l5RIspyVyeBTA /9f5OigeeMiaQfuuArd/pVncsahRkY6t2r/oAP8Am3FNnDcp9oe4QmNgqQ5O8++MYxUflCBt+OD6 ce9JKwFz5poGIcEA4HI3f5/xrMtniFz/AKXGzQ7SuF4IODg/h6UwGSXIt7pvszCSAPyGyuR7+lSl 4PM3wq6rM/yoW8wp3xnFAkktEf/Q+TJLbdIpjuUD7hlGBGK0ZbRVbYrtIU/jXhHr/oAP+bcpTSNC 0aLFIpZdzbh09qnjaQHyUXKP87Dpg/SgBjwXcuIRcCHY/mFRyHUdRj3HFTKnlR79pWRX6k8YoFdb ET3BkdWBBw4ZsdDUsS5n+0nJRpSWiBxxnOAaBn//0fmTZE0kt1A7bY1KmMyZAB7Y79Kpuscke/YF y+AucMT7f571/wBAB/zbiwwKC8hBDYwAeQKgMJUF2kByceXjBA9fStIPoJ7EtkyQybfmwxJBPK/j Vx2iUknHzNk4rQZSkugZNqyKrryqkfO46cfpUiJvjZmcFwchGb5qDCLs7n//0vlS4t0D4aZGTyxI RE2SDjO3NVYB5lwiIMKxxuc4Ar/oIP8Am3WqNCe1iZdjSbQDnPQVktctDqv2K3jkuLeOLBnC4V24 zj2zn8KALs1gslw2pRRCLcPL2glmG0Dv7nmr6z7oEQIUkJ+cOBx+NAEcixwD5irBxkDqc1m/Z/KH mrJuWViVBbJTHbFJuyuB/9P5Y+0wyWSwmKITJIT52MOwIAwfpj9aoOylTAjMvPLJwT9K/wCgKUr6 H/NuXYFihcDLlHTDAgAqcdfzqO7jS3A8nDs/Lg9quD6MCn9nR5VCscNjOBjGetOu4ns1Hzna33T6 1YE8SofIZneLC/Nk8NnvUMkbM/mCUrsbqeN4rGSSdkB//9T5Wt2xhZXDlj8tWpgsm60RljfcC0j8 BSPev+gA/wCbchibykkjXDyM2DKSefpToWnJKSNnglQBjPpQZObasHzS5VhyD+eKWVggigY5GMRn qVH1oII4zFAwDbXXcB85+8arXEJjEkqArGG3FRyecnFBtH4Uf//V+ToCCrTXMhigJCtnkfXFSPHJ I5igJRJBw5bDBeeQa/6AD/m3HTXT/ZPsgjG+KTPmlsu/GOf1qNLaQxq0gIYjcrEYyPWgCFpRCyx5 B3HkjrUEm52CKOGOSe4oA0lax09Q7RNczKAPKX5QexJY0y71NbyFYbe3EZRvncD5zQB//9b5KimW IKGJJ77u9WZ7dZY2eTamCGUD+L6V/wBAB/zbjm8yBoWZkVhGDGhUbiDjaajiCwFvkBJBbp39aAKe 195PTcevTNIqxLLkjY68kkcNQBNcSSErLGRI23AD8LxS27DdLJMSuV+VQOFP+FA0ruyP/9f5FYgy KpOAx/xp3kyQvtUloy24r/CSMgHH4/zr/oAP+bqKtOw5pJUPHzEdBiq7XwWYA4D9HA5C0Go2TfOw YDAU8HpnvSXd7bRJFCRGLiT5MKMvQA2N0Vm+0SloWXOyNNzqat3Rt44Y/sdy8qyqPMRozGyEdMjp 3ot0A//Q+P3jYR7y+cetI0gVI3kIZWJVEU7mXHc/U1/0AtNH/N+OG+ZQ+dm3gKDndTMFldmPI7Dt SNYKyGR7AwJ6Hv0rREcbB41Zi5AZXz8uMdKLFlDYwV2M0sAUMolRA5BwQODxg9D7GvyK/bTxdajD A0skqSTiOK4MWEcLHCD9F6/nX5R40/8AJvcw/wAD/Jn9FfRkX/GzsJ/X2on/0f4tdZ+WXB2vGkYX aBjb14/lVXTGUL5bncSTsY/wjsK/Raq94+ap2Whrm5BVojAjFvlDnkgj0rAMQg851kJTftWMjGwj ggVxA4PoVvMlLEMAUX7wU4NW18pdjtbqIojvRsDKmsZfEamyJWuIA0a7Yx8qkjv3NYVyIoJFWWZZ JFILMq7evapA/9L+J1rqbbIdw5baFK8ADpimxSrKs0g+WSIAtk43Dp+fSvqpfEeBF8rLCXhtsMw5 bsRgke1PDJ+9vGWRieq4+X2P6VI3J3M37XIZPORMAjaNvRfwqCKYR5SX948vLKowqehrKaSGpNtX HS3Gx1jcssUx4UDccD1/z3qOKe5dzsjcqn3FUfM3vUGp/9P+JeK9mPnGQRlyuxFY42+/6VtWtnGL SS7R0f8AhZN3zE9+O2K+gPHMdiVuAyOwjPBQ9j7Vqwo00f3skHB/vAUAQOzw3AbaiwAAh1OCx6Yx Tri2eWVAHeBc72AJAfvzQVFXZQ8p9+5gWQNsyOoq20twscqNMvkjHlRAHPvms5u2iNUktj//1P4l syG7WN1xlQxUcVe8pnlUtKyBAQiDPJr2DzxofbcRtcltsBzFkcZrd/tZI4PMgxG+cH5cg+ta3vFs TSe5jyk3JDEkIRl3xytRQR53wkRvHnBdumfWshmrbLNbghnDxgbNp5YDtzUcqxXGIwgZiTnjkYoM Huf/1f4qVhRCyBvLK/KMDge9Nm8lkaO4Bm3RlDg7QeMZIr2lJp3PHLWnatrWmRGDStRura3ij8uG JH3QxZIyVU8A1Wu7+4uJGM0rytjc7kYZ2PWnJpgRIzrBhI2UyHhm+VkFQXnnKyBPnAX5mHSoGk3s WYyVtejbf493zbc1cs7NbjDYxHjhm4/Srl8KLUHfU//W/jAn026tFBdGCTJvgB/5aD1BrJLCBgXR wT97jkV7B54guHzIgdlV+wH3sHoaoXk5kkgDiVViyVUHEbdulAFiG4SSPy33eWvOwD5h61djj09o HDRyGSU/xOQV+lAEYeKKTy1PMQGwk5J4prmGUOZGO/r8p+76UFxjdXP/1/4mY3t+fMOMD5c8H0qu J1jdoPs5G75vMZshh2xXsHn2toXIpVERiiIRxzx/hU0am4n2l/KIjwjk/Ix9KAC4d4swqdzqcBjV izuGaORZiQkZwWPCk+lBjL4ma3npdbY1WKNI48ZX5VbHrz3rn5nELOXIK5+UjlV9qCT/0P4rTGwh VtylpEBXJ456VNYYR9suwjGMe/vXsHjiXF1byTS26RgbFzt6MxPpWeI4SVhIGGOXZv8AP+c0Aaqx wAqwwXiAR0/hGOmDUqJG06zSRhIwdpTOePWgqKu7M3rgWskYkGxWVQFZQFXArj7hBdPJ5HMETbmY sFJH0oNIpW0P/9H+LJSz7ZEOAvyBUPHHamSPF5uZEkJI5AztNewebJaMjjjM7Hy42z1LYziluIvL CbyY89ZFXLMfSi3QymyNCXcZ4dRleOtWZZoofKaSPdO4ZAsi8D0P+fSsGraMlaooo5R4w527m/eB R8vPetGSaayEpjn8xpU2Hb128EL+g/KkM//S/i3sJZpLK4SdY4lmbIYJubjvzyKrwW5t7lktp2uF fDtIeACQMj8K65/EeIpXuWJrmQEqI1DK2Oeh9azZFh3h2LHJ+ZCccnjj/PaoHH4SzEfsybUZ/lbJ Vz0qCd3vLd0TzAyPgo2Y1bHofSg1la+hsadBPAkeU2hl3ZzkelOurkhLmG4jYhPntmjAXJ7hj+dB KV3Y/9P+LywR54vN+ZQ7GLI5wRj/ABFLdC5hiwGYlRgsv9a6DzylDtW2+1OXLoW+U8BuwAohmSXG +JllZQ+CpKj2z0oImtCdSqu/mtGFHHy8bcVJIjosrrsCOoKseSO/FVGXKZGfujuJ1iYMFBHmsvBw OuPyqzJD5O4WysbdX/dBuXP1ocmy1Bn/1P4vyY7h4ZWC7lQIyD5RkDFXgqoJZVBT5flVeBmupyb0 PKcLIzroPczITceT8mBgbhx61hu13beaiHLhvlUnKP7n61JBbkSXUUgysI8mPEo2hM4GefWq9u8J XyC+FJ2nrlaAJ44/KJgjlAiJy6hvllHXpTYksfMeTzSXR9ixEc5Hsf8APNAH/9X+LuFVdZJIsKQC G3j5hisy4vZoAgLsJEbKTLwFroPHH3F493smld5XdcSMxycjgEVYsbeWCCSUsGW6+QoD/CMdaDSE ujKF35MThFyny4bAzVYRS3cYhBdwD8idc/QUFSdka1nYraRs115ihF2LGAA6N7+mKjmldH3AhlC9 V5aQ+hpNXVjJvW5//9b+Jw3EYMch3gxSbyo4596gkngubi5KRtawzybkkUZcEep/LpW0dIo8cneN tyYZgGXbk8hsdDT3dYbXLkbgfmxweP8AIqjaHwojjWKVWklUorJ97qQe1Vyv2aeO6ZtyRjnAyo9M 1lJe9ZFGjd3kcYaSMKxYCQrt2A561DOpugm3asboGRW4IyO9agnfY//X/iftrNLae28+SSW3d9rG NfnTPTHtWreFIlFsGbzANyk8Fx71u1dWPPOfuJh5gUyBMDGD6+4roLeHRLjTnjuLqe3lW1LbymYz MDxyDkAjAqOSyYO/Q56NGMh3CPDjar5yWAPFX7tAY4kUqGcFSMdQO9ZgYqxzwQvDy2TuXaOBT7C4 bc0DBFSQjfKR+8GB0B/pQNJvRH//0P4ozCkMMcqIwR5Cod+C2OvH5VRa5aTzVdN8acKx4P4CsZfE zmSsrFW4iAaO5s2uHPkAXDPFxE2fu55/Wrc26VoJhJlWi/eREYCN7GqhHqMy5zlmhSNgxblgCVXN LCyQ3HleWwY4BfGc+uK0A0pHcxSERkCP7rDgkVnNfPvWFHIjbG5+rj2pdQP/0f4klQqI7gEzJEeS G+Vc8VdN/eR+XFplrAxAY7ZDiIsx5Z/fn9KDnKtxB5MUayPH9qVzJcyREmMueuPpVi3Rbks0gYRx FWL5wue2PyqZptaFqDauRavOvz7DJOi4VNw54Azn2rMggcv5m4wIANwHysKz5WHLKL0NGWNIrYTC RpJXby8MNoGOQQe561HaXH7weZGJJUO4h/mT8aqUdLouLb0Z/9L+JAywpdRhiDIW5AGRjriluJoU 3TQRFMOcluA30HpWVnygQ2WqSxyDz2LKxLA/3aW3c315LcTlm2L8qZ+VPSoMHuWJLmWAEJGXySfl GV/Gn+diJphIUYrgwsm5c9yKpSa0N1qjMgZ3ucQuqg/ffGTWlPG8sflqxdV544GapT7glfRH/9P+ JO2tcIImkCmUZyOQpGev0q8gSOBxcSAgDy4Wx8zEev5UnoXDSVmZUlury/afvyk/OTwWA7U+S+TY 0EClT0wB933ojsjUSG7VE2yDcFYEy7c7TVyO5muFx9p2APtxgZbPSmBVurQRxSCfktgqyj5s9qYk ktrEYFYSugDOWOcrjgCsGrMD/9T+InzGcbXQqsxC7c4C01tPvJ/keAOhcou04Ix0rKC1udA60MVu JIJ5WUo2fIZsnHTcBVqeGIlTbs5z/ERjP4Vco3QFI75kMcscilDtLYIzj0qzBHDZIskwaSLGHCn5 x7gGs42UkaWvPXoQtew4kRGd3Z8Qlxgj61eWQRi3acgyDhtp4YA9/wBK2ND/1f4t/tGlPb7olKXi kPkL8singj2xxWRdW7Su8cVy72m4SLhdgyQCR+B/lSeiuegTQ30ml2c0bWyXQmIVVUbXA9c/57Vm TOs8nn26yRcFXikXDHtWAGNEy/aZDIxDwYY56nPArWmVHjQO2WJyiLwFPqTQVBJvUyJrbYTEzPl/ u7TzWvYQ74vI8k4I2u+efqadrDmrWP/W/icWAWSMkcpkJ4fYNoHsfpUu9lgXe7I0hIaSNiz4PTd+ X61zne9mZ0v2iVTulaWKAYVpOGPsKfbskk0hmAET25iRQv3T659a1atCxgbVsL6KGFLSRNoYPgsM MB6+/HepvtEVvcLLJNCtzLPuw+P3z5zjb3+gqIK80jnxcrUW/I/Wv9ky3FhpaTJJF9ohXzrY+Xsc D9zKDH6csfwWv6Yv+CV+kadqvxJuNTQfaZL2eEahC2bYTSgpsJZhksApXI4+X8a/u/L6jwXgnUf9 y33n8T8NQWP8clGXSTf3XP/X/tW1lntPCzxlo90lvhmjfe25Y8Ko/Eda/iT/AOCj/iAa18f/ABXo s+oC0Vbr+0taLRs2wicG2jV0BIwISxwOdwyRyR/Tv0W6SlxXWq9ov80fzh9LqpNcLUKcdudX+5n4 GftYazbXWjQLexl7cxNb32ZePNeUbWbJyAEx+P6fjh4n3/aEQssqwsyQc7jsDHH9K+k+lFUTx+Gp rtL9P+CYfRthycMSl5r9R+kSOfMeXYYooQY0c8sc9B712bWtvqENu1hMtu/keZcNdHYhKgswT34w BX8dzWh/SxpxDdZQNsZkj/dxOBjfz606SN54VQSGCaN8hQMIVHck9DXHVe4rK7P/0P4xNOimlgvZ ZNphSICEbsMGBGTn29PartqkcLLIZA56uGPLeteJPawWtsdHa48mSeKTbGx8tol5GD1+lLaLp9ym pQi9kgvIbXzbS08kypcMD93OQVJ9enH587mtkJJLYzDOU1Owgc3tvZyRf6TdeR50NvIOmVyO/en3 l5d27hUK3q7/APXHgHJ4z7YrIuHxI0LJ76a5TMzQRnIMA+YSr3VQOSe/HpW1pk00Md9aXHkzRC9a WGVYikhBGMMD6VE11NOZWZ//0f5DbgETxLEzgyndIVwQi56Y9eDWqLCyg+z2qSCa1nkP7y8YqSXO SpyTkc+uAPavj2ujLc9LGq89ncXSwQxiD7JbiACEbIZiv8QHr05qpYwRSy2dhc372LrdfaDNc7nS OPcSVVl5x/hWMlZkylaJe09J7rUrprOVxbafPl5pZAn20nIURoTlhyCfTH5fe/7EGmPq/wAcfh/o kd/KupXHiq1uhZJAxQIk0bEhh1OB0+tfOcSO2VYj/DL8jOUlDDSk+lz/AEgv2a7CG2+H1tJb21ui 3EqbrlTiechS0mR/vMT9Sa+oYlyo3fKyj86/G+F1y4BI6sN/u6P/0v5JfFmg3ksFtr1mY7yDS5C9 zMihZEyNuxMdeeuK83nvb6O6t5YbVWWRz9oSctG2McYx1/8A1V4sPgRyP4DPutQtbLxJamWymvLW W33zyohRIHCj5D7Zz3529Kr3WopHeHUbbfBbRoI54N37rgklsZPJFUZHRiHTb1biSIvbz+UGidfm dmJHJJH1NZl19l026h02Zoje3YHzKRIrZAI5GRzmgBLjS4S6tIiSFF/doy5VG/vCq1+JRFGhiAYO IgijKqPX2oGld2P/0/4yUs5IreWaLiLIWcoAJF9wPw61UsIxbq7zzwSSyybbd5lC45PDdunc+leM ttTnsT2eu2SzGyeGZ97+W0sHz+UT3I7j+laeLe2naBGla52CT5UO1Qehz+FMhwTMWXVxZ6vbEJ9q nKtLEJE8yF3HGGHfrn8KtReJZJJdOTULRnkWZlEYO5oM54+lawWlyzS1K9ubqeGK0/1yndiYEKPT kentVy60sWyme9gB1OS3VZpYvmkK4zge3tXdBalfZP/U/jntrUm3uJgDH9nj3mVeqr7/AI0+azmu 7BRLJE6SwbkYYcOpzgtj0ropKzOe/Q8Z8Rx/Yy7SYZwpSMA5STBxkUnglYbXxJZXSMDOrRFFnHl2 5YyKSN3blRwOSK9vLmlj6Un3RzYy/wBUqJdmf0HfBLTbTV/AvhO6kvbiOSGWGS8t7WXa0M80azx2 wb7xUHg+uTX9YP8AwRo8Qaz/AGNpkepx3L3t5ePBiNv3NgNyoERBngBGJH+1X9w+JsYV/CdVZb8k fvtr+R/KHgLVlQ8XsVh1tJz/AA/q5/QP8Yrf7V8OPE9tsd4zpbnaybiTjaCfTkg/nX8QP7RMEGkf GX4hafHqBvLqfVRqbxXEeTArRRrt3DIzjY2Og3+3H5L9Feo45xjV05V8tf8AM+j+lnTXJgo9W5fg j//V+Rr+1km3Sq5guEfcmCGjb2K+/wClcZd6Jc3QuI9SjeKdz9qR5AB5vlHzcEHjDbMY9DX+0NB3 R/jdiqdlymWbe/uZEUo22LCQxKd6kdlUZ4HtVieO4sRLbjTvON3D5Eu2AyrGOOpPCnNaqSOJRbK2 h6XBHexQtAsUMobzJ1wEhYcBWHUn29BXQK0ulXd4pjsr20mj8pI57UPHB6MAT1GM1pGTjoYzVtjk Bp0q3DGyQBXfdtJ2tz3rXuLQWL2pvrU3ckLnEEZw4Pp155xWqaexk1pY/9b4plvRqmkXMh0qdoVg R/K2+TLk4IGDjBGOme1chf2ls9ukyi4kEjCMoi7XtmHr6/8A1u9f7YH+KKTT2NW4C2WnW7FIXy6u ZDF+/hAXGCfQk5/CqVhZ6faR3pe5d7m5cz29oihAhOOpPb6VvF3Wom7u5qrpQurK5mt44bZoo97s 0m945Ap2qOf4sEcH0rAgtbyXT4mm8kX4lLLKZCYjjjGByOhP+c0zGUnsa1/AqRW6sFlnjVMG3/1T kjk4p91ZzpH9nvrUW9+FWeO5kby1kBAZRxxwMfng80EH/9f4civ0a03z2amL7P5E+xWlm9MqB0ya ngvdzPHqFhJZxxx7WhZNs0ifw4z+Ff7ewelj/D2aaRUmuIjdiOeO0msYCrW3lj95gjJLHuQSfyqv eXSajOwGRbJGsMMYAyzKwIOeox2AqzEv6jfzs+YnldVjW1iikiCAcdUXrjJPc1BY6VHNE0U920ci KZT5kwTA5OMk8kegrSDWxMvhZq2Nq1xHHqFutzJZs72S6dI++4kdNg37gMAfMGAPUeuKmurOSy82 XUAIUEmEt1w2WA53/wCFaHPKVlbqf//Q+FbaD+1HLXiSFLaU3IubcmHJXlY+DnsB+JqbUWjutkRh jjmDZjUH5lz2zX+5B/hK5pOxa0eCCEF73z8s/lwpKQ8Xyf3RnpyPzqa6vZLy/twVk8iP9y0afxMR hWPsMdPTNBk3d3Cd2TzoJEjaNiCPKjAcYGMHAyaoXBS5tLY27LthJjCqfkX6frmt3JLRnLN3TZaj 06XUYyspcvCOWXnPoD6irlpp0dmpa9t2RQcoCpDSAelPfYyUW3qf/9H4u1CaMQho4zHDJIdw4xGB 0z6dKhjlW7sJYLTy5ZhdIsaK+XUk4wRn09a/3QP8FyTU9NuV2NZQo1y03l3NtChYxhcZbjjHH6Va 066kMkaWkzQS7BFM6/Kswzzu/SgzlCyugjM13PcxOFVUbajh9xJyef0pslvdWt9FbX211aQfZmUs 8cg44JA478H2qo26mDjeRpXFhaWqlkupHlcZMZTbGrdlrBvpkISANiR3ClUHQA/MT9Oa2SSWhm1Z 2P/S+HZLQLJhW3bTwV4z74/CtOSR5Et2Ft9lETF0Jy3njAGRnoMjjrX+69kj/AOp0JoL2WSd3aJk mU4R9irC+e+KspHqIV7u2iSS/iHnWxkXdEWU8A8EEHuCOgpmMrW1JdEuUupjDdzNFJO2zzgpeBSO 7EcgDHWpLyW4t7wCPyru2icxwM0fIJG1yG646EA0BePK7EEGY5SgKgqwZSY1lV8EHDKwIwe4x0NV NO0y7t9UDSzN5EkMt8ZjIr4MePl2dsnt2raHwoytpc//0/kSa0iluIyZk2TNlw58sH160XLSsTFb mOKILscY3K6r0wexyBzX+8B/z5TVmZsMN55v2lpXjiQlAqnG76+3Srl08ItX8yYRFnCxs0gVixzj APXoePegght72Vrct5DoYj5RkI4m9x9avWsTXGzdGxhAzMrDA59KDBqzsO1aKFZIIF3rCFDJER/q wODg/wBKWa5t3tzbQPFGqAeYWB/d5GNxAGfxoEf/1Pi6KKG4hKXKuw3bsq23IBzjNX3gP2cSwxqp jO1BnLZ7e9f7yQ3sf88zSejHQS+SHNwAzyoMg5x64HvU63BJSGGRkEow6O5bH0J6D2FaGLVnYqeU I5werlsdMj60w25ed97holOBg4GfXHWgl7MnW2VFMm1mUZCkDIyBxUTwSNbLcRhxLn94uPlX0Ga2 h8Jl9k//1fjFI2UrvjUzMM7wSfbFdPaH7Fu+1RR71TISaMN94eh9jX++B/zrmPcW8RS4zMVym6Hd zIWyAQMDGACTz+ZqrJuWWIbhtUAH+99aDOLvJtmrHaTh5obqKaRUIKbB5cQyB/y0IIOMcio4Xj/f CAbmify5VVTiI47np3HSqh8SJh8SI7R4IriPz4JLieW4VIY1BKP1yrAc84xmtIPdWUhlt5YLcTbx 9miJfYOh3ZHvVp2hcuSbsf/W+Q3JSG4P2R5ZioEE3mBVB7nHfuO2PepILeWG1iFxNukkIZwq7lT2 z/Ov98W77n/Og1Z2Lsr2kDyRRy+aTysmzZkde/SmxyRPG7RYWdSCFxxIB7+tbpW0EZykT3DedHt2 +2BVx1ClGUbbcZHpvIxwPp3+ooJl8Is3lqUZzs83hET5lBPT361HbwXCPbzBcMz4ljBxKOOOO2eK DE//1/kqcebKWnQo6ltokOXj7HkeuBVf7PHMEkD/ACgYHzdDX+/KV3Y/5xyy1jaiFUDHeCWyOd+f X0poWCIbZOmMYztJp8trmT2fqV/KDSHySQ4wf9kfWtG4H2S3X7HcETXEnmXygEI4AAAHapIKscrr uZIy3Y465qd7bzEbzJGj3DPyn5xQB//Q+V0ht0hZ4iRvAyXADkgYOcVnpJcvvVFG1W+bsMZr/fg/ 5vzRRtseVCMScDn5lx1qaOWN5CTtYBcMGXGaAFiSylV4AFAfKlWHBqCURW0ARYwhT5UxwCO1BEkr KxR33MwjVEI25YjHP1z+FT2880lwpnAuYlj2bZGIxjgY5zxQWf/R+ZLSzhmWUGRUkRTIN5znGOB/ hTJ4YLt40IxKnUqMZwO/5V/vwf8AN+VP7KtbiUq1zBZGOJ5PNmDujFVLBflBILEADjvVCGOW5icK APLHzAnGKACBMx7JDyvpwGq6trOsJuEEjRn5SEXcPT5vSrg9bEyV0Fqbjc4hddif6xPXFWr27gma ExRtDtQJKGYHLDqR7HHStTE//9L5ZzFtLb1bB2sg7cDmkmdJodsSKnljAI6tX/QAf825FAHgKSzj ChehHGOxqWSTziQFKoemTkmgBMG0iMgQNI/8AbnA9fyqeS3WSKK5jGIW6k9j0IPp0PWgCqkNu87F 0Vkx8y5wH/zirNpBaZkD28qRrny3jcBQeMDkH/OKAP/T+VZ7QrcK6q4iLcEHcV+tXFuFV3iVtzjG 0EYY1/0AH/NuRBXeZftDqmXxkjO0ZpbxFgkTyphIDjbtBGPbFAnsTMgS3NwylnBCLjgkkEgf+On8 qrCSSa2cTRmOSNsGMHdIc9AB+H60GMd0VRZyWeV2MEf7vGQB6VdicxhFHyleQfWg2fQ//9T5YtLO aaZ4YwyiQ5Uf3z2A+pqOZWjLRFmSSNioyOVI46V/0AH/ADaT+HUvtcCQwqAFZUxI3P7wgnmnuJX3 SoI5WEZTy9oBbjH50bbEuWlkUYhbWtwqai0lqjnGTC0pBxkAAVpzWtuWzBIZYz9xihQn6itVNW1N L3V0QG2jjBlkTPl8fdyTWTcWrTykqSpY5UNwEpxlfQyirs//1flX+zv3kcMM8cgVC8yDhgevf8au Jp4Tyy3Vn2jtnpxn8RX/AEEH/Nva2hBdQygOsi7dkvlrsO4NjvmoYo4o2AwfM7E9aALMs0kEJVSW QnLJ/dP0rMZzMB8x3t/D0IoAQyTk+SwC7RnMg5f2FSQIruyMCCF3Fj90+1TP4QP/1vlL7JEkis5x k52/3h2rQFrGQ0iptAHU1/0AH/NuRzFY0V2AZf4SB1pss0RETMoyyhWGBkfjQBJF9ljHmLH8sbnl 2yziql1HDKUk8wMXfCxHPy4xj29fyrS+4Dja5Q7skBcjFUnt2IQCUSDdkqoK7Oejfl+tQwP/1/lB VVW+Y4K42AdqnikRftErQtLI0RSPcxRUbHDe+PTpX/QAf829uhHEsu3cVO4jHA4J9qtpb3S7UkUC Rl3B8YABoMeSQ2FJIp3jLb2TOGx96qbXLSgthhtJUhgVYH8aCSCJDM6mRSVDb1HcEdKuXcwSPkER nhhyfag2j8KP/9D5TVVcKHO1CBgdjn2pLlFtZEkWQuzxlQhHCe9f9AB/zblCKK4nlVVGM/ckPCfj WhHczTQrDcqcxqEEiHA4zxQBA0aYOU6H5X6evFRJ5rXEUccErLKdgcL8uRQB0+oaDpY0lbl9dg+3 2zxB9Kt0d7mUSA5yxXgqQM4znnnpnNW3itdqxbtrpy7c5+tJN63Q2rH/0fk64tnuJEYjYqOD8oxn HrVx3gLtCcukfpwOPQ1/0AH/ADcxSb1Mu8Md0V37laP5YznGKQFsbFfEv3QW6UGjinoBW4jjZpZI 5CrbVRB8x9+uKsnyvskc7xLKu7B2kFkPofSglwsJHdpNhML5cfyrhArAdeT3/Go2ZfOIH+rI4FA4 x5Wf/9L5FEKyy5Gd0XQj7taUciJguCQBgAcc1/0AH/N+Ux5kdw8+f3fBRGUMFx1/Os9lgaV2kAZn fdwME0AaMUsboUCYwMDtiqiYieVPIjcOwJmeMFxj+6/UfhQAs0Ued8SbgBk4FVAsbSRzsWVQp2r0 5Oe1AW6I/9P5GSGJ0VHmWTJ3MvRgM8Z/L9KdJZ24Rvs6gEtuKZzzX/QDd2sf84UFfcglC+WiDKzK 2GBOFxSHEZZMFv4XA65pGtraEKiMkIwYJ1LDrVkTxRDyxlsjggcjFADYjcXizWUB+a5RolQrkMSO Bj61+Of7ZUuo291BaXVtPpzJqDxJPLE2Q6so2Mp7ADn03DNflXjQm/DzMLfyP8mf0V9GL/k52F/r 7UT/1P4oNSlLTrGW3yjBl8sZGPWkuA9nax3QQmHeA23lvfiv0CtO02up80ou6sVk1GRCshB8tzuQ 45HpTZLtp5kjcsQxyuOBXOamukMZXaijcOWOOTVG4815BHESFj+aVc4BFYPdjsy4NTS3i8pVJdhh QT8orNhkF1cbHRdpyJZH48v6UjSMbas//9X+KhbOIq6tliFyjp29OKrQ2r3EsUKiMs7+WcsFDehy a+tlFt3R41kXrzT442jJYTuB5Wxfm2+3/wCqoZy626RIMAcSJ0Ydqzaa0Zi9zFMojdolXJA+UGpP KMgGVEbEc9qmSurCHi3CgLy7kdW5x9KvafMtnOGuEZSemVxkVgXzux//1v4vtZuNLvhA0WnQW8sY w0sJ+9kDJx2NUILCOD5XmjeNlLoI2xn8PXrX0B4y21JlgQI77CF/h45aqsN4tveKFQ7SdrbhgZHt /nrQMs3dxbTbkEUb7nDElcbCPSq4uZJvvAxNG+wggHcB6GgqN1qglaSAF8ZibgVSt08zc7hvLJxu Y1nNdSoybdmf/9f+KdoI4laZCHkVflMnp7VVtZZCXd+Tv/dkfeB9a9g82Lu2XZbeK7RpluGeSMbX jZCikmlghRbdRJhXUlhk/KfrTUbhPRFy0liOV2K7Zw0bDMbYqrIY45yCoSMdlGENIULtBLPMm5gq mN12gA4AHaqwkubSaNwhBwG+YZyD7UCcD//Q/itk2PDKQjbpcsGH8J5qpBCHJLPuVsCSTHzLj0r2 1Bs8qMXfVHT6dFbxKXIzHwE3D7/0/Kl1OK2l3bbaON4wGDINp/yanladjSytY5ws5DLhiAcLxjFT iBvkEuYwFxtZcA0hpJbFCRmLPbfMq/3l5U+mamZbi2eJPOkl3r8yD7ifStXH3LAf/9H+KnFzAcLc yh4wDEu7dx6fhmqrXEkoEMwlkl3nbJGvCj/aP4V7B55ZskO9A2VCttL43HHQ4qSSIm5+y4LRK2YW kAUtnoc0FRjzFC7SG0neMnZKOHVfmFOgR5lef955cY+fjgDpmgfIyszxecGBZnHCnsR71uQadFeJ xtTjc53YbgZP8qDRKysf/9L+K6aC0SAMUSRTwJAMnis/y1uVjAGIwSBn7wxXsHFJO5bghiilzLAu zZxIeBj3qxJFZyKCkoYjlQjDb9CaCLFWBVLu74YZ2jnJWrSNby7YSuwLJt2n7r5Pagymuot5ZXUU 0uxlERf92FHRMDg+9c+Vds24yAh+VWXkUEH/0/4p7UMu1ZUD44Azgfzqz08wmIgHqy8lcV7B49ij MbTJxLsuGAVQ/wArv2AHv7VoLYeXCZniJbaByfmNACiN413jmNsExnrTJlkmTcgKbePcigqK95XF UOquzkuxXbtJwo/CojERGHKhS5+cJ0NBqlZWP//U/igSYWsbbg0XzkheSfrU9vctICok3qxwAwwa 9g82Xwse18bVHTy2WYnbHt5DA+1UxczyKVmfaN2CuOfyoMma0axFfMXAdAPvdH+lJeFJoNyr86HL M3G2s59BFO3t3nYJlUOMBm4U49TVeSTyZSob94jY9SMVmB//1f4r0uJZYlRcYH3jjAFWkSGOI+WF BLfOwPOeK6XueJBWuieZIIY45JAHXG4jrk9sVizonm+coKbX3Rhx19KFoWl0RLHDLdszoBmMgnJ7 n/8AVWvfbgY2WAQvtHmFRgNgYyKEruxrKF9iJJnt4wwDOF+YoOp//X/WqV7d/aomYLJbu7Z8ll+Z fxoas7Gcd0f/1v4nNNadroJFL5YVysoc42+pArtGkgSIQlWYk8v1Zveui3Q8yUmnZGPcRR3CvFHu LRuNoBxuz69qkt7hdPne1CJIrgC4lJDheOi02mtGQ5N6D/7OjuHeaJFdJH+eMDGenJFUJo3tfNjk /eKr/IvdB6UiSFP3V1HMsYaKRdjbiQynsQK05LidU8uBUIl+XLLkig3WqP/X/ijDsZlgL4w4HmE7 Qp+tbkMc5xEXyd+XfOeOmcV0HnjHURz7X+Y9sVFeG3MKvDGRMQUcn17H/PpQZuHYyoxcKuzH7t22 uR0b2PNF7b+SiTDarKpKKpGW+tAuV2dzOTzHQPKHC7t29SVPB6VszRxSxWssaATwgncOr+n+FBB/ /9D+J671KdYZFhO13wMsnI9aqO1xeIPMI8lUwAgwxOec10HjjLVJ1J8sM6ONqZH3D04rVn+2WSFA HZmX7p4VPf8A+tQBBFiXYDy54cYzg98d624olYMRIsZtlB3fdIoKb91IqXEhKIUdmbJM7SPu8zJ4 OO1UJoZrlV2SCCJFyrISJWOeeKCT/9H+JhF80FZfmIbBOMZqWaABf3YxFGM7MZ/z0roPHLsN2kEa bo3YOAqOELBO3NU7lopFlYx5ZBnYnWT6Cg2irRRHJI7Kht4zHGFA8mU5PvkipfLQW7tja7cnuBUP 40VboZ8ssLvELknbjDEA5P5VY8weWqW4320YwkjcSDn0/wA9KvYUVZWP/9L+KiOXMaqvyGIA+b6m hZiw2v8AvnDbifT6VtJ8qPPM+9ht/Ne4cYi4DbVLc8DpVSeG4aQC4QLAqfu2xtXA/wAio59PMCMR yB98cimFFzuBzjH9akhnNzMq/OI4YywZuNxPH9P0qANCN0KtNllWPKHKkBuoqt5CTHdCQuDye60F Rdmf/9P+J8KjrGrnzGhy4cEjOeMY6VRa0mimEycoTkRnOG+orFvW5z7Gvp+xnvPnCII1MkDttR+e w7kE1TuUMURkBUIJPlz0UVandpGPPIgmVDsj2MejBkxtkJ759qSGHfMyFCJFXcmeFP41YKTRYJ8y Mxb+VBOAcMwrBiiXzpykLiNFP31wpOB0PT/9dSviZsf/1P4g2YrC2XMaou4IG++fQVa02W4j3j5V fyd8audvPv70HOJcGUSLvQEONzHPGfStOynSG2KSQBwMt5YP3QfWgvnsrFJ3j+dFASBuOvzk+gqO EB4nhkJJc4LseSB0oHz+RSmMkNx5EjmVEUcZ+5x2/Skhk8uYyNkxsdpQHlhQJSabZ//V/iEfbG6y kgiVyI1HzMoB/i9PxqrcRO0udzOoOWUHhaDPn8i5CkLEuBtUEbYyMjPfmtSGJwrL5eyR2CxMg4I7 ZH51lKNtUTFpSuwMcyblmUL5YzlBkH3rP3s7CLIKls5bgn2qLGyd9hLcLb+a0MZ8wsdyv6jptpRe 3Mk3lCPb2ZQCKDdJJWR//9b+JmzgMHmPIrkA5POQfpTpY4ZVBVn25yqerUGraUikIplRQ4wSSN0b fz9KpwWE7PK27iMbtin5sds0Fpp7FxM4kMqBEX5n2giI0W5gnMt0rwQxWa7yJJFQ49QO59qAH7hL I0yzrJbMgZy55Bx2qu0iysSiBQg2hwcFwaxk7sD/1/4ilnBdAMM6nau/5QPT/PtXTyLepYo7KDCJ sGSL5lJI7mop7WOgojTNPmhefzWF0TwGXduPYbv6VQNwII2gCkkHlsenpRN20QFGO8dxuk3KS22M FcZrQG26nhDyLaxAYlkMZcDjsPWsilJp3MeS2ktbkNLFIYjllkKlVI7H+VaVleb0kTy4jGn3JHQM xznOTW0XdWNIy5j/0P4gXkMUwcyFY3yDtyTj0xW9o89vf3EcDz/YoGBVN4LOSOwx3NRPax6A/UbU 20mxZjLEr4zjORzzVSW3e3tzffaA0Ukgh2Ej5eOv+fSsgKV1boYGKqJZGAZDnaVNU7mC9git5Nny ZyH3ZLUGlPqbMKwXECs4DMFBGBh1PpQblba3BBkeYSHEaoMY9OvNU17qCp0P/9H+KK3kDo5kjIEw 6E/MtTnykiRMFZFHz5xh/pXOd72MS8vRGSFj3gjBUnAFVojK+15A25R+7hj5/Otr3jdmB0AljtYg VQx7wNx75p1sr3FxYQW9vHcSi8iZ5rjKjZvG7B7HHYelRTV6iRyY3TDyfkz9tf2atNk0bRrWS4tD YXMrEQosIlFzDIoj2kngBYwMY/vZzxX9RX/BIPS7nV/El21zpEEaaTeeTYEkeZcxLIzI5GfvYb6c Gv7lz9fU/A7V8r5F/X6n8ZeF6+s+OVWW6Tl+Z//S/tG+Ks9tp/w+1m5ZhaIlsBGUUkxkKWyv5flm v4c/21dZtNV+M/jg2bLezXE0Ya4WML/aTRr5jJgkE7TJGPbdX9YfRWoN5tiavZfqfzJ9LqtFZHh8 P3kn91/8z+fz9r9I5fDOsM1u8NzEYPOxOQsKNueTcPUEL0/umvyYv5mN3tjYOm7ar4yoHt+dX9Ju d87oR8m/yR3fR3pOnwm2+6/I2tPkgjQqwLshyN3TNbgucQ78KgXgY4Ar+TpRsrM/olz1NmweYqkz zMQfligXlB7muhieaRfLliBYRl5CF2qVGa4a0dAh1P/T/i6trw27NaJF+5nBjKBdxBPQj8fSt6wg jikaS4CsFXGG52574rxJ7Aakd5BaI8bR4tSDJ50YHU9MmqUEtu8qanaK8VzjarMMbl6cjpXHJWdg GwT6lb3byXcsE0V2PJt7CVcKoY48zOM8dfSuhvbC38y2jt7BpWu08gpG58qNgM7iSeM9B9KQ42vq RC/1Tw8Y5BYAXNqwmsbhXD+Yf7oY8DH6Uyy165+23NxqkEt1LdDzEd1WAoSRkcDBxzzQGtj/1P5D bWWG6zdQuuQ5BjznaB/CaydXuLOZrWS4lNxdxXJnxCf3MCkEYAHfpxXyc9wN22nt7vSrXUbMXRu2 lkjnSSIxiILwpz785rQsxazW8DSJdreNbmGWBpPOjnfPSNsAjjsaycUyJ7G/4cSw1W0sLmKGfTX0 65lsJZJEKGfy3OMdxk4H/ARX6p/8EzNIfXP2sPhpc2S3TXuk6kr3UH2XMRhztRkbvuLHOccA18hx ZNU8kxMn/K/ysY1byws4x3s/yP8ARF+BWmmy8C6LvAjEga7giZCkqxyNkbh25BH0Fe+KRjLDt+Vf lPDUbYCDfkehhlbDpH//1f5I9c10WVudKVd0ZnIKxEbYgTnJA/KubvUs5rb7Yxlb7MgeFFUhpG44 /wA+leCp2Sscd7wKOpx2kVwLaQxSia3SYSKQB8yBtpPqOn4Vzsfh+znCyzXM0MW97gh3Bi2qDhR6 jIIxVKfcztYlQWklu72svySAwuOR0OCBWBfC4tTM1vZLJehVW1upfnilHXbxzkHt71SknoOzSudF b3d1c6fbzX0EVrfKgLxxvu38HH51T09n1S8dXLRMF2szuPLBzgcVRUFqf//W/jF1CHUIZ2to8BC+ GljkBU7T/wDWq7baLFqcFxBHPskig8wmfEaSMOyn+XevHOcF0iz0GTTUW1eWKOH7VcM3yvLIT90n qV46+1WYdU1C384QwItyWWKZ0OZFilBK4H+71qorWzAz7uzXTY7y7a3N1G8YFqYImnuY2LZfIHQH FQWenJdz2TsPswkIaWe7fyEhPUE54GK2A625sl8q4SwvYHidQiX0RWcPtI3FGHQjnnj9a0rHyHuZ pZzE8S22ya5Y7pU4xwvfgevXtXXT3NnZRsf/1/4/g9kbe5gMskgu1a3YY2LIhyORnvVJYLy00949 Ptd9taxHbEg+ZUQZyPbFdEOhhGzlZnj+rWhu4or+eSH7Ndhjb/OA8e3AI2dRzzzWNYlkNqkNoZ5I ruJlkU7dh8xcNn2/pXs4LTEU5dmjDFJOhNeTP3m/ZwF8vhePztlxFcwwanHK0+1iY/3eV55PzgEf T8f6p/8AgjBr9xHq9xbPkQXF/t/tBWP7uYjy9pT+HbsA465Nf3PxzTdbwfkv7i/zP5F8FWoeNlSP nP8AVH9N3jyJrzwdqcbszu9v5M8irtG0/KTj6kcV/FR+2dYab4Q+PHirRLiJbTV7+L7UHMJ+0TLE /kllOMHGFU+uPY1+FfRlxqw3FFfBt61E/wDyX+kfo/0qcBKvlWHxq2puz/7e2/Jn/9D5A1a31LYL XSWe6nZtxnmTY2WyxyAT09a87kvdZuZ5jrzTq0owqR7TJHtGwAlcD+HOB2xX+0GHVon+OGOlafKi azkv9QlcWVy1rIsW6KBsxNMQwA57YyetaY1LXI7qytbJ1mkFyHlAVZjuUHeWHdRj3HH1q1G1mcSn bcguIbbS9SvLu0QtJc3C3V3bGRmsvN2j541PI79/ap4NRivJL1izeTMm6US4XJHXHPGDwMVqc85X 0LMhu1t57m0mis7mG022hliErPxtUoMY6DrXL2F/qUVwks0j3epfMRJKvLsQQTjoO59sVrTtaxmf /9H8/bC81qKS1sdUsZi00+63MJGxjnGFI5Ixjg+tbYE2myf2hu8+c6mkH9mi0LNbBXBaR8gqR2I9 jwOM/wC2B/iuTwNYanez6XqUKwSanfl9P1CYMLa13oAyZUHABG4VzuoXllcqwtYpLW/jcQRm7uF+ z3IQbQw7jdgEL2FdBjL4maOlaXc3Avrua7a1P2UQ/ZiCYm2Alj7EnHShDdGKHTdNisryaSUSXkty TGbWMcuUIBOcDoSKDKUVuFxNFBe21qzxpZsRErxgNMzEheB6dMZ4H61pwzTWMbkJbXOCw/0qFLpV DAAEK4OGGBjHT3pxV3YyP//S+BNKeW3voIPtca+dcbHN7J5ce1m5JIH8Oc9O1b9+WkuwrXi6jepJ JapICZUZGyFCHAyBnjI7fWv9vox5T/EKok2Yw0yPRmuFuomkkUM8Z8zzFVm5JPXI56fSt3QNItJL drq8dYYwweAu4CyHOeAe44PtmqOeULBqNxBZS2jWkIkmjuXE0k8eYyAFKFcjBHODgnrWLBCl5fRx XRMYa4G0iTbG3fnH8ulOKuzKXws67U7WK20WWGCcxgzLIzQSEZUMOBjvnH4EisRXW/eK1v7qeaCN w0awHYZCeMMevStzlnHqf//T+F7NF0ySe0NxPPZeY5jUv+8hY/7XfH9Krx2k4mDwgzSNwpZfNfPQ cV/uQf4QyVpM0/IOn2tzdXmGu3JtYbSRtskTYz5oHfGMfXFZenpNE4vNz3E7SNvhlc+U442Ngdwc 4wfqKCToo7W4iuLVLqCSOacrIFIx5iv0I9verMsFm1jIljbIsa3LM7c7gedw+meePag55R6MztHm AvrmG3uX85R5UkPSGPHI+vX3q6L1yZob0GXy8rHskyYj2H4daBJWuf/U+FprWa80+XTrye5SO4mS VJYhjJVsrx6HOD7Gr9nZrESxdYdgAMYXAm2gDAI7nHU1/ubzWjc/wXNdruzmtNQ2t5LrbNGiMcTb mBXKjOTiqMsKtpemtp0ckSCMLqErvukEmTkN6cCnGVxPYZaMEvIIliBYfeRmIWT0rY1STU4r9Jp4 QlmyCSC3SQO4IABx6fj61RgZ81zJdo8btseEeaqbSCfTJ/lUelqkJupmt0eUrueV3JZcccAnFbQd 0YPdn//V+M0VJJpDkM5G9e2BjpUl21xcWvnLFIyW4WN2VcRxgnCk+nJA/Gv92D/AObT2HiK5eKGO 2RpvvJKQN/lnghR+pP1p8WrXunxPbMqogJVn/wCWnOcig55voTo1q9np4gaCJ0lme6IyZ5QwXYoA HYqTkn+KsmCc+buVpGhLMhBHK44zQZmz5Lqv2iMKQY8tv+WRcHp/WqIu7hblbazeBEezmW5aSMST S52MBGT937pBI65FdC1QH//W+N7EXF/cO1ymPLGDuP3vp71q3mmS23lPbOjQrFkxKcn0wfcV/vAf 8+D3ZThE7nau5YmOZCR0A61m6vbm1uIbq9t5xpk10kdrK0YLS42gmMe2Qc9s1cEndMR0sz22IEZ/ JsYvlE8iZJwByQO/Tp61GZ4b0vbWN6skLR/L5cbREj8QDSa96yM5q2pUkiuICwIa5WMfulkYIMgc gHv0pkUkZffLGjI52lRlQgPHUUSST0Mz/9f5PH2aOWW28uG5S2IObdw3mDqD7f8A1qYZ4xM8n2N7 e3uE/cLvLAFeDz36HP19q/3jhF3uf887aW5He2tpJHE1w6rMHWWCA5DtjkH0x7GqsMbSmSBUMt0p zHHFyXHoPcVqYPclnEtrFOIQkkrQeXl1IEZOMg98jkVSu1liSxuFSQR+eq3UflkrKM8qD2POaCJO ysW2Z5BujlkS3jO6SPoOTxmr8TPeW91HaSmFreFXMbIxE+SARvAwO559KuMuXRmOx//Q+Q4bSWSx +2i4tElivGtjCWLXDgKCW29Mc4znrVy5uJbgCW5cySKgXce4UYAr/fA/51b3iVpZNMiht5g4N3Kr JOsin9wucj2568c8VUZo5Va5iTdHnb5inKk8jr+FBEFqX4bi/FpKkcUksa4I3NhF6c/zp8AErGN5 kt3YbvNcHysjscc0LTYjYoWj3SecJkUBXwtwgxyOVKnqKZMZsqgZiF5z3bPc076WOg//0fkm182N 2jm80wtbMEwvAfHykk1duZGNtawbFV44QBgfNJ6sfrg1/vgf86U9zJk0yW7OVmAXaRIqfePbg9qk ihngTaVAVFCR5+8wHc/lWyetmQWX86dEaRj+6O0cAAjHAqvI7hhu24wVCnkcj+feqInsVoQ7RMk4 2NE37ghvvY6fSnlrq9ZsSP5obe8hb5iQc5JoMj//0vj5reQvvmuDuY9+pqeKx8ktIpYqfmOTuU/h /hX+/MXZ3P8AnHBZisjAjeH/AIuy1LcacwS3uWaZ4zLkJGCwJHZv89qpyWqMGnqNkfdICu2IMwLY GBjPIx9KnuFSTe0LbkjbCHOWIqBFeDzDE7RAmSI72Xuw9q0nngZIjCCJ3B8/c2T6AEfnQB//0/lO OKdoZWZoBIkh2Ru4TcOwpitcqd1zbNbCRPvKwZJAOMjp6V/vwf8AN+VwBjbuKDdlT3rQtfsO947p 2zjakkZwM+/FAELx+RJJuO6MfckXlj9BUrBS8LSOzRMmEDHHPcfmaTaW5E9rE5RlRymAqrliTjgV BbRsxaQRHAyoIGBzQmnsKMujP//U+V4oZ2uli89LcHkSykiJcc4J9+la39nxea8t3eKqjlmgBIPH XPFf78H/ADfmNqPCf6KwILY3noR64pLeFjBIWTbG+VbgZIH8qCZStsTmNYIbKOa1+zeZGRBJgkTK GI3Z/D9KeiyQGVoZ91uzhHRW+WQ9uPYD9aqK95DTTRHKpi4HJYZKqeR161nNE0gCqrbgc8H73pWx gf/V+TwoAG5duBg8feq2LWIxeYsvznjYOK/6AD/m3FhikYskrJ5RHzBxluPQ06dIoZF2HGVxz047 4oAI4GkKbyQpJ5Izn6VJJbxwgi3lkZH5ZXG0qenTtQBmiA+cjpIVZe2flb2Iq0tzcJ5EcZS2ljyZ JPL3qW5xgHI9PyoA/9b5ijkuWRUfb8gyXP8Ay1PqR2/D1pFe4lvIZHghGwbfkXZnHQ8f54r/AKAD /m3K15aXCyK5c7oslGI3bc9v/rVN9pjZY5LoKZdgXdjbuK9/TtQZzfRBKjXcaMJJFhaQNIi5w3XB +vJ/OrltALV0leN9kn3TKpwaDMZfzb5EiSQBd4JGchfwqhdx+VIVSUypnCPjbnHfFButkf/X+VYr yW22vv8AniIIIONpFMuWN0vmIqpM4LttOd5HVjX/AEAH/NrJXRDCJtsSj5pTwWA4PrWqYLuJVkjY LIeSM9B3oM1F3sRQXc5kdZG8w/3mGSKY9xJAD5blsNn/AOtQbWsN+0XsoElwY0zhQrED6E/41PbT xNFd/aZ8Xkcf+jyFPMikPQg9e3Ttx1o2Igmr3P/Q+U7YO0m9FzIeGI6tirImkPzyh1AcqA6lclcZ /p+df9Aim+p/zbjXufM2PghcdDwfxoIbas2w7gcdOPajn8gJp5prlkcxgFlO4427sdzXPTmeMG4W KQpG+1ZFU7CcZxUqTTuBYM109tBPJsKsSigY8wYx1HXvxmtKGSA2sx8qTzQAYzuBU8EHPFXJ+6B/ /9H5FthJNKBtDNG38ePl5rYa6k27ByTwQORX/QAf825VmmlSFonRRt+aNQOgFQQQyX0SmNxvaIyl CeUA6g+h4/UU7O1wJza+RZ+a1yrESFGix8yenP51nhpF2ujghDkDGQfwptO1wLEF5JI27naox657 dKR3l2u0ZE0m7CovBH1NSB//0vlQqqSxCV4xMuPMhHX8+lTSzRqNrukSk4BIyDX/AEAH/NuWHY7k S3mjljEecopUg9e+D61WkubzzY0Uhh0dieQKAC3neK4JmQbez96L4LOVeORBHI3zeVjK89D6fSgl xTYilbYso+dmXapzytVEkkMgjKNs3fMSOBQVax//0/lZ0U5Qnbj5lPTOKrSh5B/eYdOK/wCgA/5t yqJGiymSH/u9KmtpZNxSQYB5HegCdpFznOcdOOKlCh4l8t1Vt2DnjAB5oAjldACYojlPvzHuR2FJ Zu0hmkupnMYQGBFAKhh0B/AmgD//1PldZZ2MoA3LjIwuNoploh2SM4/ds+0MemfT+Vf9AB/zcRdn cfdGyhYADeVXLgcc+1UUjjmZ5ogxUdATyPag2urXQ93QRFwMMnDA84rIt2w0ohXPmSGWUdQxIC5P /fIFBMnZItmWKFdoZS5G4qByKjjDXEjbpRENhKAjuAcfnx+dBSd1c//V+UrRQlsN7jf91ivGfwqN mXenmbtkf7seX1ck8MR7E/lX/QAf835TleT50DAYbqRkEVE0MTFZHJTaMDB4J+lAFizCvIVkbZFg hmxluKa+GT5XYJH90PwzUANS7TzSIgwTaFKv1J7/AK0+4jyqyRoMoD8vUc0G0Fof/9b43hR3DNt2 MOG7ZqxA7pIF3bee/rX/AEAH/OOJfN5uwJtU7uXGct+tNt2SNyXkwrHac85NADLsrD8y5YH24FR2 12pRz5RZsdQeF7Um0twJcmG2a8VXeZZQI4o32OxwehHQjA6V+PP7YEkkviaWW7eRopGkkWOaQzTp KyRlmyepPzZJ9q/LPGb/AJN9j1/cl+TP6M+jCv8AjZ+F/r7UT//X/inlIDmYxYYsULMMMwBx+VJG 8ciiOeRiEfcVAB4OeBX3lVfvZHzyWiIGgt5EeOOIoCcBQeMeo9KgSyktS29SybcxO3Ofb+n4VmWr W1L8ErMx28Ar82F6VaIjEEwEZM0nyxuB19j6Vg92a9TCQ27yvDPuimiGT2BINNeYRrtBGxujKOTS Gf/Q/iYie4dCIwVVeGJOC1S7WWMMUG9funONv+cV9geLL4WTWd88HzNgupyrDouO9Zk1zK9xLKzG Rt+4854zmpmtDEsLEjv5oUAsuQelXUaFUIdEMv3AzHhKxAhaGa2Me4riQ70IkVh9ODx+NJqLSIka zEAyf6tM/OPfFYSVnYcVqf/R/iis322xhkiUuOFcj5gPepFQKSVbJJwATwtfQHjmmpmKeZKzMiDB 2nJUCqNyYFj3w4ff1DD5l98Um0txpXdkVrUwyRsG6mTk98inL9oLSPtRoRL5aDIDgdjikpJuxva2 hqSWrCNFl2MpG9QrhiPris+6KxJEFHyEkYXgL9fzqZvSyMuR9T//0v4p0WS4VUTauDhd3Vvak+wy iSAKQh3njIAzjua9g8yMbbjVvdsUi/LvRiGUDGcVFFcrdxnjZ/CB6002timrqw6VzaqjqCMH5iBk D61YVjeIy7gUI5UjGaQRXKrD1tpJJFjODGFACqMj6Y9qvX1vLb2wnlQ4DBM46ccCldXsVZn/0/4m Gv3k2RLGwYnBQDkV0GlRxu7QSSwoWXOJSACcdBXtKTR55NdzzoSAcLFwABnp6VDbajEyM12jAtgC QDgdqHJsLGhc3tnbWysIUCuQokK/M/PGTVWe6LxgNEjIQGdyMhB7UuZ3uy+RmVLJG7iNAERiN7L9 7FIqtbyM0bmUHhAx4ArZ7MXJI//U/isiuUOVVA0zdd3UeuKm8h4o2lik3mX/AFsY6DnpXsHJGFtW UXYhlQOUQHec9RipUn85FBkBO/CkjaRQXawlxarP5aSSD7WJtoDAeWU9S2e3p+tP1G6hhdrS1fFv 5QjZlyBJwMj8xQBz6WwcxrBuLs5yTwa6qOF42VMlRtAkK9D6ildJ2Cx//9X+LIWrlJghMih8hAM4 FVookjlaWUny+AUJwqe4r2DnJr5WaMRohMZGRgcsKwLeJEdgQXRsoyEkbSe9BnNFiVDHGzQk4Tru PJ7VdtJoIypuD87gMoxlVPFBk1dWNS5uC0eEb534U5z+dUI5EiJW5Urk8uBngUGbg1sf/9b+K0X1 uN8doW2Hks6bWp9o8kvmIrnAyW9SBz/TNewebGNlqa1gLK2E73lmbsv/ABcJJjqNpPQ+9Wftmm3k LQ20NzZSQqG8u5lExkAzuIbA9uKTvbQdveuUrtrcxeZaks+3Z8x+UYrKt5Z4dvmsszEnIOAF9wKa 2GV7l5C29R8hfDBeg/zirXmqYc8L5YBCkZLHOMf59KAP/9f+KR0a6klklkQsIwYoguC4GBioYmMx CRRkSJxjGNtewec1fQ0fs95HI1vdRwmZfuFXDsoI7kH9KrCxbaZHjZVL7C45GRQYtWdiINPE7K3+ qU//AKqlFxLdJLbRog8v5mP8RFZz7CNGxnsraCdZmJlEW5Nx2MjewrHkmgkmLBFDOMLuGGIrMD// 0P4pxIQGVEIGPugUkUU0kZdOIy+Nu7BB+ldUlZnjJWuLczTRqhZd5TAAPAGKgS4+0hgQGCDc46+X UlR3RYt2lgYtFlomHJU421pW97LfStGjoVhQDZt+cnPUf4e1G2xuXE8lkY4ZnDFS2PlBGcisqePd MN23GcY6MKDNRalc/9H+KmSyKuZoWChRklvl6UG6ufscDqmHZ2jLh8lPf+X510HnWXUZY3Aj3glm k/2jwTT22TkyqBvRsOVbOfqKbd2ZS3LKapcQbBbMAocK/wAoNNvLsvMZJoBAGUAyA5E3fJHY9qcV d2ZJox3VjcWAURBJ7ckRybSGuiSOD249R6GooJFu/wB2B5cgHGOhI7VTh2Og/9L+LJdEwJrmeQgm 4EgjLfLgdz+I6Vetm3TEIVVdm1CTw5rvUUlY88jubkWf7trYzTl8q4YEgH1qEBXkUSHBY5GegqOQ hTRHHA4kkBZDGOkPYEd6rG4Tz0SXymMT7/LkG5Wx2rMTmtUVnnt45GDKQrZIjAwv0pzyKIt8AIwO jnigzP/T/ibMbvLHE0YCvy0uPlX6GtqKyS3VI0KOv3pedxGfQ/XFdLVjxr20Eitma7W2t/MVgnmL Mq/ImSR19as6nazWwCyHzm2gmQclz704xuMwMq7RvHmGccB0O1lxURu5jct5JSTZHtK9C57k/r+V PkYFeYSPcxoWaA8OSOA/P8q1LWITuqPOFGSG5xkAZP8AKk4tDSb0R//U/iqe3WFCUJKZwzAZBqZU ihjV3YHPG3oea6DyEruxDbXEYAhOGDMVTK/oaoTLFG/nM/Q4Jz8q/Wg3S6ItW1xEwLhlMajaxI+U /Sq7XPngII/KjZtqju3PWlbW43FpXIhZl5i4UtFCMvkZx2zUNxarzDDJtz82wHaXFEtExH//1f4m LCKdnNvLjcD3bO70FWWXyJCUwJXIQZ5RB64rSfQ5Yx5TZFshgmBcInR5Mf6zPcZqpdJFKtvardFo 4IxnzV2uTjnHP61mZPdmAbdHldYEMaxk5U8bzn0rY0ayeWZHWOKTyyXdZ3CRsF5OckenSgSV9ER3 V0szTTEJFBDJlI412xcHGKrNPbq9yk0UUclzb5txC3yfN2J/OsY817I0grM//9b+JuxG8xeZGn7o ZdM8HbVtrhZZpI4ivmRpv2MQvHqK5zma0sVxG7zFkC7hGfM52qcc8e9NadrqVU8nZAibWi/vY6k+ 5px3RjZlqIJdQTRPH9mEDbbeRerdM5/X8qzWy4Nsp/eo4KyBuBW44xuRrbt9qDl8uOCD09KW6gme dYvMxBwwSM457k0Gx//X/iYi0wHfHOCsB53EfMD6g1sXOm6dDGZVXzECgLEzlmzx1NBzmTcMswKh Fyi/IqnDVHH5VuwV5Azsm1gTwM0AZl0Nkn7tMonU9yTXQ6WIvsMjTxRYWQmORyC544GKAMq8haH/ AEiKNVZuG5BJz7VQiEUKM3zyNjCHGFUmgD//0P4kMQCBHcYl6HHVh/SobPyzJOjQkYGQS2SBQc5Y trMzSlBIyYUsmE7+p/wrdtILi2mT7WwCrn9516dMD3oAp3+piVolWALHuKySj77Zxjj04/WsqZLa YFkbBVtmDwTUqK1NKfYspaSSyx2kgETrIsiyH7wHHX8PWotTeW1vGSFI5AgAypyG+v51idEZW0Z/ /9H+I+31Qm4/s9t8a48xpQu6NT3HrTrppUimEB85iu5JlU5h9SBWfPsNu7uQ2FzHdRSxzGRio/eb RhjjuO1IsvlLMqo0Jz8xJyzjsDQ56aFQlbRlyZ1nsFWLfbvtKyIQGik9DnqM+lYv2BLO2f7QFlWU jzEHJx1GKlybL5oj7SI3E8rWqpHbAALAT8wPuM57Vq3OlvB5E5D7P4kQ8Ln1qQUk9D//0v4h5rds s8a7weIwD8x9QRXVKfN0uCAKlmYiBIiuczZ9R7e1YJtbHQD3kFnbxQLbR4Rj+8kGS+QOvr0rn2vb YkRu3O/G7A2j2obb3Ahu5o5Vji2AMpJ87oR/+qpEMzQxRoVfym4PAz7n1pAT3c88tuun3DgqreYG RRk57Z/pVW2RUt57VHCq53LvYLuOOOauHxAf/9P+IR7WSQRFdjeWcl84PFaNnbQRsLmSQBUb92qn AZu9Yyd3Y6U2tiKaaSZ5RG6lW5TDbsj0OKbFbyXlsBLKsZif/VPlc+9SbRd0Lp8H2m5kSF/tC2mF mjU4256ADv8AhWrOxCRxGEqgJEZkTAbHXaTQbU9jFvpWDRrE3l3AlB3KOgHXNS28oMrSMVcgYJ6k H2FW/gsE7JWZ/9T+Jp0PlgxSfODuCgZ/SqzMz3YSfdyMRlehx2/nWCV3Y9F2ska8VjY3V1DDIkkN qWCzTO+Xb1xxgd6iS3OnPdZ2RBWK26yvl5142498VtbSxjO3QW1ia5gE90hJRztQfcI7fj0re8Ow m+1m30uIPBJcqWjkx+7i2kFm/wCAgE4HpTw8HKvGPmjzszly4Kp6M/b74HmQeDNFsBb6hd6xZyCw hvdwWyMLLG2+QEbt6sWGQcbT0r+tH/gkNohsJpL1YYmvrfUBFsiTm9jMKksSemC5H0zX9x+IMXS8 EacevLH8FY/jfwZTl40Ymbel5f5/mf/V/sj/AGiJJNO+GPia6811itrN41gADiZpYpFX8jzX8JX7 SdzHp/xE8aTyRxXGtWuvP5d1I2ZrdSYXXapyMY3L+Ff2D9FOnevi5rsj+Vvpd3eDwa/vP+vwPwX/ AG07+5trqz0edZonu4JtQ1AL8ySFJV2mY/3SNvHtX5kzh5pyqdmzuAwOteB9JKuqnE0af8sbfk/1 Z9f4DUvZ8G0pd9fzX6I1ba0LypEjNu3AlicKPrXVi2WFxbzGB45UAGfuk+wr+Yah+5xV3YvLDNbu UjEnk4HJ42nHOMVuxxvPEwmldE8sgR54lI6e4rgqao1jHlP/1v4zbWayjghnnt2juVTCLgFvxNOa /j+0b0i4dQhHc14lRWVhpN7F7MU8YgY4iPLREfI2PUVPPpjWdvZ3kU0ckVxK0JgSQGSArzlk64PY 1yzWocr7EUfiyawlFteadA7GcRw3qgyTW0YH3ShGCCcfT1rpdNv5bqRpQdkQk3ElMAZ7YqASvoiS 6gkuJz5mZLfaQI+sYPZvwqhJFcRlDEkbSRuAglGVAzg/pmguMXZpn//X/kUk0y2hQFJl+0M/zxoR tYHrWxNomiQCEQWkEMxiV3eIAhyVySffmvkp7gTW19DHpcumpbrD5ErSRzYGMHrgfUVU0ydXCx21 wJZbY+ZOqphoQ3Ckntk9DWb2ZM1dHbaE0VxHb2sjPG8F008u4Bo5V4wuO3I/lX7h/wDBHPw3FqX7 Sd3cxwNqD2VhbSIsb+TcWoZJVwoHOPmU/UV8Jx1Jx4dxDj2S/FEwSjTvPuf30/DO1uovC2kC7Pzv aK6ZXYdrKCPr1/nXpRXapIbkDGB+NfnXD6UcFBeh3Ulaij//0P5I28LvY2EkElqJL6Qy3Mk05Jeb BJ5YnjGK4HV725NrDCpWB41KOE6qeBjFfLxk7JnDDWLM6Gx1K6itdQ1ODyIk/dxLC+7fsxjd6Zzm prxbuzdEeJXgmj2rEx3FNx7fWtovRXE3exYuGsLMPBDERGIxJEpQ7WJ4ILdj1qrYspRTkTOrk+W5 yEzVx3Hze7yklxq1nbM9pLpMYjaHYt0cu0ZY8kfpWHp6mBpJgwdfMKpIDgsufStyqe9j/9H+NKVT MGkiOWDAspbGBSCaVLiK3bCWrjLTj+HHOCK8c5yxdNeajdQyPPI8EMfkx7TmMgdvw/rW7EIfKmuY rZJrx4lSYDCgrHwn8zVwWoa3KkepvDffZJbOfTTGA5e5PlRShl3Zjc9eD+tc7rE051bT306AX+kX a+RqMU0wG3JIZ0x0/HrgVqK+tjatPDV7otv5NuZ7a0kjLwRPIZBKjHdgHPTrWhpFrNYLJrN3HBc2 ZU2txpU7tHeyKf440HP/AOrpXTS6Db0P/9L+OC5iSRLjUrG123kMZS1glc7wuc4Kjv8A4V1p82HT reZGaIzWxZiAVZSQQwx19RWtN6pHHF3lc+dPEFr5M8nkymaJJTND5gx5RY8qMVB4bZXu0guMeTMx DopxtyDk17eFdqkX5oVbWlJeR+zf7HdvDLoFhcOZNQjs9PSO3hub5lmUFopH2ZycDDkDoDiv6mf+ CSGtRWHjyaC0uLiOymvIpBa3MvniK4kMjO7NwSd7DqBgEccV/dWcXxXg/O+7p/ofx54cTWC8dGtv ekvzP647qKW70O4imEQWazMtxKRlMbNwP0BxX8an/BTPwzNqPx50nXpbyOC50qS+t3UgPJPA825k x65lBGff0r+avo8ziuP4J9FL8v8AM/bvpNU78ISfecPwv/mf/9P5VnmXTZpZJDMcNnCLu+XHUDsc c49a85a5XU9UmuABaLc+ZDbpcgyrbbgf3jp14zkGv9naD9y5/jVjrqvZnRrpZtbazd5zcvFCLf7Q xA8/bkkgY4ySTj3rnruwubi1u3sJzZ314skdk8eYmCudrRoRzyA3OavY4+tjXl0hdOFnD9oF3LHb IquGEjDAAAcDOGyORXPm3jaOWFoH82S58uVIDtQI7Bdy+m3kn2Fbxd0YEdtp50i4YXOpXtzBaxM1 raXIae4uuRhMc4xk96ilmf8AdXqWtxDdlSUjZfLkMcmOMfTn8frVJ22A/9T8/rqW8Ku0hlS7VRJb Ep5ZiPGD2PbPFaunQajJaQslzci+YSC9835YHDAAEE8nPzZz7V/tdGSeh/iuUZ1vrS1aG7uo1vYb jckSkhsMTgqDycDv9KqnS/PiJkjUOCJGlk6DaQxx7/St4S6GMviZ2kTQzWCXSXNuBd5ZljcAQbW2 kMO3Tv2NclqKx291MZJVt0kBUvZSGPI6ZJ69P51ZJQECiQz6d5kgVVX7RcfvJFBHTJ55wcfStewk l1CMPgN8xQKOWfHByPWqi7PUxl8TP//V+GrfSAzQyysQFfLxycMV9KtkWul3Ulwi+d826MMcMg9q /wBv009j/EKa1MjUtRS4vDdZKgoCsXUYXJOfz5/Cm2mp/wBqyyywwbX84xQ25Qpbp/tIM89fpxTM pfCzSvIBcWwjZJre5ghP2l3mSTn+8m0cenJzWHBGR5dvG891tXKKfncnqcGrp7nPL4WaC6bd39s5 N5PbzkB47a5URwIF6rnPU4HBHOTzUum6Nc3MkZZ0SONw7SFzEUweh7YNanNJaPU//9b47urCza3V Q8RVJi/noAGlI4+96VmXtlPp9kLxo8rLMIdofZMgxuV8dR0/Sv8Acg/wge7KPkS6lMJ5pZbidk8p FZs47An/ABqrYC6R389CsaykRyqMoVH9aBG/Pd27o1xK86Cd1svP2s2doyFX0478dBzwKZE6aekk FpclUuZAiSTH5Yt3B69M5pxSvZkTWg86Jd6YDeLCs0krZLw3CqVOOpBIyOKZbpNqNzFaxMFuZ2Mc fRNzHORn39/ekZH/1/juPz7SyuLSSEyyW0h2uw3ShhlSM9/pWLA0sl1EsshhL/KhkX92hPds9Oo6 1/ucknGx/gxtobzabDDCrPBtnJ2NlwzPgnnjsetSagk9ui6clk8fmFZiipgs2MLnueP500ktjKb6 IbFpSwi1MrObyQ/v027RanPGGzzxg54qe/ngYrl1kkgUqAjByBxn+Q/KmYSk1oiHT7yGUwk2xaKR v3y3C7NvYHHtir93HpU00VpbIiXNw5jkeJgEVQOhUfjzWsF7pzzdlY//0PkddCurY6mxa3lhtgoi uw/M+ewXqMc81zt7eXjSpaSBLqJQixLbx+UARzz0zg9z3zya/wB2LWP+f8ltxHBJGU8wfvMsVY5G TzWn5NnHdCW8EjxHmMhvlPrle/b86DGfxDXt7WJsadNJIuN7NIMMhJztB9hjmrcNzbeQrFFQ23zN lcBz3OaaTexzyfvDbu/spraZbbm5nA+cBlAA+vH5VzsFvNG+x0kZxwZNuAPxrZKysarY/9H4uUmG Z/3rCRT+6hBxuBBOfqMD86001G7gT/VRsTkjzQSG+tf7wH/PeRm4uNQl+UokhwDEvyIuOwp1wqyo jLIkksAI+xl98pIx8wHQZPA+lGwEDSNPDA1xDJbNkSpG4wWQ9MqelWYntvNgj0qG6kv4f3kg8rdG w7gAc49abd9yJptaDmnGpJueJFMMpV5kmCqWONqCMenzEnPcU+HSXtRfJdSbkk4RN27YcDBRv89a Fv7xi720P//S+MtPgV7gmVhILdwd548wqeOPyNbfmW63LzSwblNu8Ea5yqF+jYOeh6V/vQlbQ/54 XzW1KPMs294y4QBVYjkY4AH4ColndLlfsy+VInzPMuCQAfT2oJFklmjIVfnDHOegH1pbiS9kgZLk uQCGh2jaOOn8qDGa1JIgJEjupYDIdpjkjDlFJxjkjv0NS2c95bCaKNMwSj94oJGKuMU1qSf/0/jp nmW4mKQeVEjDcgO7eNuc/wCfSnNH9thlJuEhkQqfIyQ23PPP07e9f737aH/OuIdsaD9yrHgbmGDx Uxuo7qAxG38uRcbWif5Dj1GOv4imAv2hkT7MiSbmXG4g7fzqfyreR4LWRmjLRPL5w/hKDODz34FB nb94Yu6RXnAmEo8zAAGAmMDB5rQspizJM6ETQFhGd3y7Tjgj86DQ/9T5Wnu3mHnS4DBNscY4Xis4 zPNNGJCqOzCJCT8wycAD86/3wP8AnUm1t1NC+sXsIGWBmBDH5+27PI/nVA3E1zKkku1FjjCqqcDg dxQZEklxu82GHBdI965OFY5HFR3UUriAR+WsiLubceSa3jsiZfCyYweYF88qmBjcvTNQCC4tf3wj YQFtglJG16Zif//V+UVubeeaJb23kdIodiPE4jx1x2P1/GmWcpi+02hmeZZm3hXALIvsa/34P+cc LG3gikl+2TZQB2Xg5PB2qPxI6nHFaaLK9scSeVGeVDnDMPYUGPM9jPjsnhJaRI5VkJEO49fqM8HN Otrby7dmLIrCUxi3UlnYddw4xjt1zQSQphZdy5WU8FenTNTLHtJmynmDoByo+tAH/9b5GEEpLCWY yZJZTxxntVgxzvEqiSQxQchCxKjtx+lf78H/ADfjdgCruAO5uDnpTptNlmKLboZJS6uF9ACCx/IH 8qAL6PCZBC/zlVHytxmo1W1txNJNezBfMDQWDp5seccsGxxn06is6nQzmupAt4srF5IzLvlHBk8l IlGcgAD6VqoQE3rhUU4OPuj/ADzUK99CEtbM/9f5buHSVCp+XHGQeWqW3SNo/K+ZlZdpViSCMV/v wf8AN+VLgiBsQkKVIKAjcowfTpSSXbPatAIyss0od5F5GB/CB9aDOa1uJcW8AhQx3PmSLECy7SPL P93n09uKhtmO0qM5HJPv64q4LW44x0IpLvLgIrpMqFQ+04cHIP8An6U+zS6kxKkgiKMTunUqMj2P atSZQtqf/9D5aSVJkiim8s3TZMohG2M/7tQNEbcSeWxk5yAB8w9q/wCgA/5tyNpmWBGfid05i5yD 6GrAlBixco7lk2Jt48vjA5oAngR4Utl58uFNincS788ZzTpyywvkHzJHyPUCgCsLeRiiXDiEABon iHzMBzk/jxSEXE4OVG5flRgOePWgD//R+W5LzYY4duZFXDs3GT2wKmjjldWdUZvLQysVHKqBkmv+ gA/5tx/2uOS22AeZ5nIJHIqq9sHg8rhZCcKzct+FBMvhZbu3a1S2SKRBGIMNx+83D1/X9Ky1urqe cxySswb5kzxkn1NBiRNaXSu7hZQVb5pMb42Yds9K0pvPWz8wpvUOpIB5zz0oNk7Ruf/S+Y7m0SNI /Mh8xpY/niwR5Z9G9+hqpLZhURoZWik3AbduVK9x19sfjX/QAf8ANu9EaNrGFzgAN054x2pjAzze Q3mEqf4eh/GgS2IpFSEMUQFhwQeSahNuceZtyD82OoFAzNeBXMjSM0jORkOxIG3oMVE4MOWYcZ2g Drj/ACKAP//T+XJLd7AuBn7RHjBzhQe4NU5Lm4f5N2QSWKsflBIxkD/PSv8AoAP+bcIQxjnlIdhA MlEGST2qWKdmVHODnqpPb3/KqjG7AtkrJKLickWhXyAq/KsbEYXn+h64qpJb+TGSWY22cqmcnpSa s7AVbea2mjdfJkUpJ+5O/GBznIx/h0qcxS5KrJshYDOOv0xTknZAf//U+T2TyiUEmxCQxI+8cf5/ WpYC0LeYgD5BA3jIIPGa/wCgA/5twuULoZjnYow5J4FJHcS2kEj2sKh5Img8x1yMEYNafYQGVEJS SkjjJ+Y7j96rAAtirtD56Z+aPJQMPTNF7wAvWVsJWLxx+WJOfKc52/jVvUtE1LSRBci2MaXZ3/OM Kwx94fpWYH//1fkTyzKzbmxNmrTWhba7tkp37Yr/AKAD/m3ImDb8xnAVdgIyCc/5FIxnaRI4xsOM E5zvoE3ZXNQWm4C2kkQTEZyzYX8T0qP5LYGzVQ2eXkUZQH2oIUtdRYTBJcpbsVUscLI52gUXkpjk 8uBVk2nBBG3p3oND/9b5VE0cjt8u7Bwyjoh9KdJatGYTFJuknOdn3go9P0r/AKAD/m3MueCeW5Vl IwOGPQpjjp+dEySINytnaMN6n6UAMVgq5BLbz0PG2tDy2YIig88nFABeK0ccaRyKVxmRSCWHt+lZ q7o2ZpSFjZgIsE8+x/HNAH//1/kpzhDh9vy9BwTTYXYDcpLhMgoOQK/6ALH/ADblS6Vt7SLlu5Tv U0JZI90aMpYZKnjFBpH4WRjLRTt5bM7HoHwD+dWIlne1SxtLRcAM87quJdoHduvHPf0oG43SKr2Y 3eY0yKiAs2/JLY7D3qM3Ea7Gij3x7vmlB+UA9qCoqysf/9D5J8xn5iXcp+6aS3jbzJDtZpQCSCCQ AM5OPav+gA/5vyMlhIRIokVxlZE+4T6UlxbwyCIuWXy3EgVTjkHIz6j2o2Ae6FyWj+UE5PYVS8xA 7ozHgfgfpQBDCI4lfeWzyyORkk8kD+laVtM0sZJIC/d680G8VaKP/9H48mmCx4jbo5Vhtw1EYjcZ JPofWv8AoAP+ccqXEhieNI08xerSE/dxjHFTzwrKsbIM+igd6AJZEX7IRKNrKOh61Vgji2lRn5h0 6VLWqGldFuO0cvA1q+ySBd0KO4SFiMHDE/T9a/In9taLN+rzsv2htRktl/st0cAKFBZiDkqQOCM9 OvFfl3jKv+Nf4/8AwP8AJn9E/Rif/GzsMvL9Yn//0v4rpbXEshRnIVdsay5GD7mo2sLgSQOyBVYY kwpAb1INfodRWqP1Pn0/dSJJGt7ORYtsh3dG7D8TTHfygzsfkUFgB8y1yDSb0RXF4si+ZGqr2ZUG PxNSxXMf2czLKjMXKeVn51I749P8Kwe7NyhcIm2WaUDc/wAqsfU+9R28KeQS5XZEefmGefQdaQ7M /9P+J0shMRt87lGD2De2KbNMc7CpUMPmI5ANfYHjtX0ZQuB9nUpEQ4cZPPyiltIyxVlcqCvz5GfX pUSatYx5XzWLjJIEQuUKkldrHDH8KRNOlk8sZLdX255IHPFZC5XewjwXGGIU+UmduetOjVpTEzJk r8nmSHlOnT9KynubKKjsf//U/iqjhxvBlVznGR0HvVdiI5DFz6q3Y19AeOSpdNBlCd7Skct9wY7D /PepbmIPuETxiQjBCnO0+1RPY0p9TLsrF45i7MVRCcqDgv8AWrN1cwwsqoCuOuRWRoNW4jDNlpR5 hG9nJ2gf7NW5xGFIALK3EbHgfWgD/9X+KSOby28wpgINqj0q4HMyqxO3ccLk8817B55A2mu6mRSM K3zN0Y1EY1ik/dgl2O7GAqKR1xQAxt7A+afvN82BgAVaREnChVMSoMLIvGccYoAmaZrJUaOTMmTz ww/WiO9m1WRombzWh/eSIemPXFZxVpWHdrQ//9b+K+W3aLzZNqbsYUKOT6CsoLNlWmjC/P8AKw7f X0r2DzzZgJijkLyGQuQFUnO0CjzDC4LRk2333YDp9BQNOzuNW6+2El0jFv8Aciy27d9R2pZ8woFO djdCv3QPTNButVczmjWbKruj3D5XHBq4ljItuiscj+8DlvxrTmXLZAf/1/4rxbrbRSkFd8qBdzD5 o/p+VPhu4YISAA5PAUnBz3Newc4vlxSZZhy3UY/QVnXEaoEcphQ+FA6g9sigCCK7VWaN4zI5baOw /OrTWqqqbYkXL/MhO4L75oAkgt7e1kZ5JGycdQSkY9q6iObTL60X7L5qSR5jdpV2iUjuB6VnL4kM /9D+MoQNp/3xlXTP7vktVW5062ZJFQnypsMMsSwOc49vwr2DnIrm5mi8q0dUbylAWQEcLjgH/wCv VQJbruchWMp+Y7cjIo2M5vojGn+SQv8Awq3AI4NQr5t1ciVMeWrY2njrUxfMZnRS2iIke9gJGI24 b5aawhWMwzklwcgkVQH/0f4n44XE3zkJAW4wORWxOtlBIv2WXzGCZIAxXsHnlOS/kvFUBJFMBKzM BhD0x+XNVxeQecIdrsMYdz8pH0qJSVrIPIuuY4ozDEfNUDfndz9CazIzIs244yTnaOdlEHpYlyii 5JOkpa3dBGyDcWUfe4zzUMibEaZMSKqnqcVZR//S/iesv9L2/vSGDYXjaY/at6HSpQsz/OAiD97t +Rs+teweddN2Q95re3aIPGfMk+QyqhJ46c/n1rMeR3aTfG0Khsx7j1HY/jQDVym0T3AdirBh1O75 WA70WtvPHI3lt80mAxPfHrWU1qZckizdWjuQSu6Q8HHeqVvabpSZQo8s/Lk8kdKgTVnY/9P+Jxpx FdwpEhAE3zszfJ+NaccywNI2A4GSVHT611z3PHIpJoriNnZSDggBuB9aq2awQF8Mu2bh+6tUDW5M 5aNZI4GZUk/dP5ZxwaW3tlQTzwy4lhXGwE729cUG5ZjlMaF2by1++yk9T/jVc3gaWQjBkAzGOgoA /9T+JoT3GDK5Z17QDox+lWlgkldeBCGH+rY4UGug880FhtYrdpAVeRfvx85H0rOEm1ZPIjUvcDay L94epxQZT3KaO0ErB3CKDnr3rRmeS5jVCN0TdXUe+eKuG5A11dbZICpIjfeHXKuMe9RxXLRkSl2E ceQCBzmtTeOyP//V/i2ivY3iieeQbd+PIOSZPapEvbVpNqQpGY23CNR90HpXoHnPYy542WZpY2JE jF9rMTgnrUUKzzswkzuV+o9KDFK7sXjGsSGQSZlxyM/MMetZEQjlkkeTiXORu7YrGSswa1Y2aMzo 5TG2E8ueAcdcVMsim33tHvaPnjkHA9KkR//W/ioQyTQW08y+RBLygc7ZeOPu9f8A9VXVYW+XJ8yM LuIHXFdUnc8exYsNYEJnlVvL8yPymQqCSpIPHHXgdKu3V79qVJEQ7VTamVwzE+opxkktQOfVIrob gAkisVz3B7j9Kz1Cxp8yrFdA7JgOd2DwQauMruw+V2uST38UuyCW0RJY8Kk0ZJds9yPfisqe3KTR 5MjE8h1+VVJyMfWm1dWNorlR/9f+KC3upowbRXfy5UBlY9GwcgU2/laCOK52I0QPlEGQLID67euK 6DzxbPE5WVE3OfuqtVbmISyGPornBQcDNBtBWRGunS2yOkcrMh5EZ4XNaFoMW7h4dzr8qFukZ7kU FNaWJGmNvbTqhHmyDGSMtjPSsu2kdn86QZeNtpHqKiewlFI//9D+K7bEiyO6hWbBDHPyc9RUZe3H lys0UhEvlxqDmQn1I9KuWyOckGqpMJIf4o5PL+YYKlT2rGuN007Nvk3AhQQMbcelQS4Ju5Yt7K4M o2YkjPJcnHtWylxHpk8kblJUKfNtOcd+KBpJbFTUWS9tcWvlwRNJ5hij/wBWfcisuPTmuFjYkROD 3GTj2NFhn//R/iVlsZRGimYozPjevGAD3pHtY0mw+ZMIAs5JDZFYJXdjnJ3e4e2WKGNYTE5fz15Z s8D+XSorK6ix+9Jck4Zwu3eQa05LNWE3ZXL2rTwfZwdyojgKADjJrBtoXU7xleOGzVk09jZkhngc NLCNrRKyMDgjPcj6Yq7bbElcGDflAxnIyp68A/h+tBold2P/0v45tKl8MXWksTeO+pi5Ns1l5I2o o/j3Ht1H1rl/EMlnbystoBLD5YwsB3MGxzkdsGkr63MGrOxzkbYtRKbRf9IYxR3jD5oWGDg/h/Oq lvGodw8cU7K+Ww27zPxpiGzypNKyKghkUZK9Qv41EsZNxCkcvmwqdzgcKD6GgC3eQyXsqRhhH5TE OU5LD0FRIl02Y47fYAuCXTGFB6/XigD/0/4hXeNZmBYk52jd90Vei6BwImlHzZ3bRgdFoMEruw6H XVFzI01sIGyBiNMWwHAJzn2zWnPeWt3ALhJpFMJIkX/nqOQOPSgv2ehglmnG9zsiDEHs2O2P0qi0 EowqOojLeYr5+c44x/WspPVpFRjZWNKK9aAN+9Luw/eSMoZvz/woUJKZ7hj5aeVgMDznpn61Boot ux//1P4i7e2sbZEkeWVi6kq0nLSEdfpz3q4PtEkZFnIEDLho1GPMA/hrnG4tEkFkFjZ1CRluJMfe HtVN4tzyMJBv24UMeHI4oEUTLOisC5JUfdzkGrEBhkhJdQHzxk/eoAltI4GkcqjxXSsGSZW/cuOQ QR69K3mvfKm+zuN6GPawddynIxkVMvhGm1sf/9X+JS9+0W9yv2Jl8tfnV8blz3FWPtxlEr8yzhN2 MYCn3rmWxXNIptPLfwkSqiOjc84OPWqrWNuYFBcGZ5NoXJ3fWmUpNtIqXoZMQ7cMuBjpxVmyW4RE +ZdpfBAOTtoGpa2JpbkNcGFVVmVcgFsMB/nNVJg8axTTMhDsdsatnOPUUFn/1v4dHleeJIYHkV1J 3heNw7VPZ2HmDdMXdYskISdq+pFc50Gtbi3h/wBVyOh4+7VueItb7ol8zPUD73vQXBpPUXTdTOmQ S2r20Sec4YXDRf6SPYH0q5dajHqEMMZDA2wPlOc/ePtQbJ21RzlrGLieVJ90DK+CWGdx9j6VMIoI ppQjCPyuSxGRIc9BWkVdf15jk7s//9f+KyxhinmV1GUj5nC8SAYz0/z3rN1JDcSPHbLst9x+djiU ex/+tUqKjsd8tEWbBDDagXDmXAIKs2W68Ul6ksjQCWMiEpvgLr8hxxkn8KowLQu8wiN18qRV+RIl zFJ+Ndr8P3il8UWMq2wkGm25kvGdyscfmAqW9yFzxXRg43xdNJa8y/M8zOGll9Vv+V/kfuD8HEvZ tF8OHT5ZIlljt4oZCm7BEUbOzpjnk4+or+vf/gkHpxuvCmka5AWMt/AzOzna842Ihcj0ABAx6V/b vim/Y+DVFf3YL71/wD+PvAz974u4t9nL8H/wT//Q/rq/ay1L+zPhVrUz3flRx2DxPH1LnY7Z+oIG PrX8IXxv1S7v/Evip57K4aVdY1C4lluJfMkvR50jebG3/POLoB22HtX9pfRVoqGFxVZrsv6+8/kv 6WtZTngsOn9q/wCa/Q/Bb9r7Vpl8SwRsb/UJLnTSnmlS8ce8QsxU46ZJUDttNfD6QOIgQCroeVbG 5gPWvzn6QVZVeMqsO3/AP07wXoOjwZhvQ0LO+t1Mp8pSXUK7DgqR6V08NvA6pNdlVCMskW/hg2Rg f/rr+dqux+wwTudSVgMR3sUJx05X0plls/efaYH2GJ0hO7GGx8rVwz2NT//R/ixijnjluGEb35+z FYjLIY0hPY57n2roLGxCqks6Yd4RIYt2VUkc5PtXi1exvFcqsW5bu0sT5F1ZTzSXcfl2k8LYjhcn gsMc96vxQ3621osFsHFqNpnnJV5B1yxxgt6cCuOfxDHzRjzHm8sGdx88pHJ+p/GtSx3NEII9zS43 Davyn61IWLM/2tHSNMK+AGQnCZ9SafH5mxmlZFdTyA24HHoaTdlcD//S/kEZ7fzzLFmSfbtRF4IJ 4yf1rQsUEVsbRGlluGcyedLJv4J6e2D2/wD118g3d3NXDqWnc6daAzxmR+kkjR4BHfNbWh2K6aU1 5LH7dZaqBp0bi5WMCMSBi5QEsMc9fWptuKUdDctZJZb+dbKPy7RrkxRSIhaaMAkHd249elf0ef8A BDfwtdXfxO8S+LJYrW0nNrFpNteFtgQQYw7H+84Vhj2FfDcduMeHq1/L80ZVFGGHV+5/cr4REo0n TGkUgjT4sE/dGV42j/PWuwYxhRLyf9kCvz/JoWw0F5I7oq1Ox//T/k48UyXd3dTSWE9zBHE25Y3+ 5K2fmXJ/H0HpXml7HHcAzvGYrhXyVPy7mHHSvlYRappnDF2iylHq81q1jI9m9xa+eUnV22FcDO70 PYfjTbi/k1jUg1raiOGWU4DnH2cDox/Kt4x0VyL7GZKt5A80F3KWjY70A/1bEcD+taOm6WZSbiBg mQTuLhd+3kjn6Vold2GYl68dw8sMU32tBnzkKhFTBxj3qO305kt18gmIzDBRTkRntjP51uNNp6H/ 1P4wlhvtNntxcSLJFO/30cGQqOMsvbk07UZbf+2DY2MQneGNNQ3y3IEKgL849D34HpXjnJzqx0tl Kq2F3JOsSWypuCH5SpPUIO+e9V9I1SNLYstvCmCRBtbICjI29h+GO1OO6KTurkXiGe61SFJdQlS6 mJCwC4/1qoBgKvoAM4+tZFhAbOKOGCMm2gy7AdueefrW5lze9c3LS8eNFuTLNMikxmLzMFQOij0H /wBet6C6S4kSZ487ULKrcYOMD8uPyropdCnNWsf/1f487l3hubQBUtpppj9nuC3lhySM5zxx61r6 pcCKzMLyR3jxW7YWOUMB1JAI4z1rWmrNPzOCMknY8Q1VYZxeyM0cGNrRWxb5yDgHaOp6VyWkRudS tYkRWRrlUfzDjaGOMg+oNe3h1rB+hE3aLXkftF+xpqv9n6JpNxcWNvdWmm239kXUhkNv5sriVS6k AliF9sDYPbP9E3/BL/xQmlfGi/8ADcGm/v8AxGLbVort5GY2wtsecq4453Kx79B9f7ywrWK8IZLb 9yvwiv8AI/jTJKcsJ45x5d/a6fOT/Rn9rWh3BvvC29lR1lsEVl3ZDR+UAfp6fhX8lP8AwVJ0u60z 4l6le6WkK3Mt6sVl9pjDCZW2qy+gO1HPvkV/KvgTUeH8RIR7tr72f0Z9JWj7TgtyXSUfwTZ//9b4 21XVfsvmfa5JI3mQhCI97kjAIA4rG0i20y4kvHvZZ7e7iUeQPJwLhT1BPY9P1r/Zmh8Fj/GzMI/v 7lbxL9oe60LSdPkSO3cGXUbySYLbQhjhV2jnIAGcdKx4L+CC9uAtxftJZsqWE6kLbuMZY7D78Gtz z2rVLDWuSpkeSecTyvvMqtyfTj24x9K0NMspbkwCTUJl828xcPsHnpHwcjjnOWHrxVwWtzNqzsRX DRaJq11Mb2eSaNXtbHzwQJ42bAPPRsc/n7VXtDCvmqjzPL5Pmq9wc8nOQPof0rUXTU//1/g2zEiW rSMEuFMu6TtJHnqMn/69NvL60jF0bO21VYygj8ya5UQmTGQCAvOBngY6da/2qgtT/FfczrWJbuaD UNXlmuZIsksXCzIuMAKcY4wPrzzUF3e3jxXVrY3RtFu5AkM8qrJ5QDDg5GMEcH61utzLl95o3NGs zY2S3n9nWt9J5xj1VpJDFMQvKsAOqnGfbP52YrnSJ7iaMDTbu7urNrm1tJFfPXATdjg5PB6c9a3M 27GJp4az2T34ihDuV2KwMe7nb7Yzj9a3rVxpnm3I8uLzYvLYyx8SliBlOMA8549KDKTu9D//0PjD S7JbnUraS5BklgzLcmeTZEUGCMdMdvzqjr8EcWuR2aTwzrI2+FoVYI4wG2hSO3Iz7Gv9vKa6n+Ik 9ilqK/2KsYhhLzzKcxThSqo52sAT24Jx7fSrNqoVH1NVhHljYI0GNhIxkDpx/WtDnmtCT7TGhiN9 b+VFfH7PHOyMyLuyMsR0GQeaoWlrLZHUbiO5h+zpGPJuBKMyEsAfLB9B6U47oxaurGhf3yz2hW3d CZIgsM3BxJ1+b8adK93Z2sdrcsqyHBmEBJViO/HbmtznkvdZ/9H4ut7KQT2Ya+2rGwutowQueeFY YJ9iMZFZF5qeoy27RahOLq7RivmqNscwBO049cYzX+5B/hE4+9Ys30U9rpttNatJ5t3AMhMoY267 S3TmoLQLDEIVZi7Au6yPvbJ5PP1zQOMerG3cM1lPbzeZc/ZRCxgtZQGt3lbbvb36cDtn6mtO207U NV3XIijsbcLny5lwkwGAPLIyc5B9qDGa906i6At4rPzn84nClGJVCcdSR/IVUOlXWlImsC3iltpi z2spV/KDLgOFI4yu4ZGcjcKDOFr6n//S+NIL3UrszyQ/ZYYmnPytkncR90ZJPHXJPesy+RrmVI4L lZBFI0F2IxuDtwQVPoORx61/uR5H+DD3NaRJtJW1nvRNb/KJLeJ14mUZAdgegyMAd/5zaldzTQwX xuXmluJS1wWGGQj7q/iAa3i7o5Zy5XoVpbq+mWyuLRfIt4flu0kxJJc++SOPoPxpYsfbEKQCdSdw 87CxAjkbuexx+VMwb1uzQeBHtbtpJ2N3kkL91FTjhePr+dYVnay3JaSEmOWH5lJfawI//VVxlbQw k7u5/9P5Da5mj8u0Mw+0ToDMR/qwTxioEjtTIHd1MscoEqbcKB65Ff7sH/P9dbjG8tJnnEarF5hw M8Ac4xVTUNRt2aBZiEJk8qAKPv5I6D8uaDKW4+3X7K8k7o80DP5Rw2Fbjr14q6UgFrIrF13/AHEI wcVtD4TnaXMYXz7xG5ZiFEYxxsArQtpmgdoWUyiQ7EcE/u89zVGy8j//1PjEKGu4F2MJTuEk24BF UYP4dD659qktUvNS1SS0xJMsX+pdfmUIODnHTk9/Wv8AeA/58HuakFo9rdzhkjG35F43ZHGSQRwc 56dqrXtpavel7VVjZowdqOWwRnPWgQ2OASvHG9xHbB/vzTKSFI+nOKCLFEe3WVJpt2JJ4XPlsDjj pn86aV3YTdlcp/ZZIZvIsYXkWQ7xk8Z7kn/PStRA8qyJKVDWUwjaB5QGmyCdy88gdDj2q1G0rMxe 5//V+RI4I1N1LJIkEu7fFAIyFwMAr7Hqeaqx3EbO3nuERZAFG7bv5wRn1571/vQf889u4+4ujHJJ FCAtvJhiWGZFIORg/TIqosUSM05Y73HJ3HH5UGMl7xMkiGPcrhtp+9nK+9Ss8zQyCSVHCfcIH+rH aghpPRkdxcR7bUW6eUyxCGUoSy3D5J3kdjjAwPSklAldbWWRkcQ+a8SnaWB+6T+RrSn2MWraH//W +RrWKIQRkbwNuCZM/OQSM/yrL1C1ljlspLGWNkkd5b6POHCjhQPyJr/fA/51y5HIk8FxHkxjyi0e +MuSw6L7fWrNsptLS3LIplmgV5xgDDkc49qAHjUb11xJCHtrdSqlbYNKuT2cDcRz0qjkzsEfeDG3 7sk7ce1Bg92W10+KGKW6llIDnCJgbQR1/wAfxqCDyJ5/s5uVhdhlc9Wx2HBoG5No/9f5Avba8ju4 oQ24PEHiYtuXZyM8e4PFUbuGQtCqq7MsqmbGONrAj9QK/wB8D/nPOia6e3iggnWWaA4cor7SGPds +g4qrOYJIrpba3OQoJlBJ2DNFrAYtnbOG2JvZ1b5WDEsfaulMQSPN4hhniiDLn5mfPp+Vbx2RMvh ZUSNncfOdjfNhh90YqeVt8QgkkZokbhATgZprVGJ/9D5JupITcLFb/6tEQO7HCjIGQPpV6BPs8z7 CjOATESOJPzr/fg/5xmtCCUM0sjSsu6UglUUKqeoGBTZBOsjhpGe3gASGXGPl9x2oMLW0K00jWsR RMyzyZm3PNuRsjgD06fyrc2JBZ2kxGBNlchwxDqAW9wOeM9qAMuXeknn4JQfKR6Ukt9A4jiEIilC YG0nMhB6n8wOPSgD/9H5MSMsVO5lLdQe1CXSxymBVMkeQrAHLHpn6d6/34P+b8dsuRP5v2dorcuf s/mDKSgY6H26GtBI5A2+Qny/9k8DNADrhrbYVXAaM5MgPOBxioJPKNpG5ZSrtlHIBJx6UWCxQZQ/ yABSx+U/dFT6XtV7yC5vo8oVa3tuRI/ODjtjGTSSS2A//9L5YuVCyCPBUkZTjrUskqhoY4EKsseJ nzneck59vSv9+D/m/KgKSyyBuWVeh4HApYmgQwkeYJY2OGLcLkYH8z19aCZJcuo2SJAxZGBcZLfN gGiAsd7BAFU7S3QE81tFWVhp3I2efIEdus8m8FATsGM4rQFrc6mhSK7t7RlUlklyMEYJC+57VQpf Cz//0/l2O0t7WQwrL50ioNzFSCMjsT+P5U1ICiM7yE5J+Y8E47V/0AH/ADblEyJMF2W0qN5hB8xh ITjoeK3Ykj8oMw3FRk+goAoXEzRJLOpQ/LtijbnafXFRw3EmowwGcKJ7eIwo8YKiQZzlh684+goA IxcRRkvGzzBtqsrDai55PNSQNtk2uxKA7m559xQB/9T5ZlaK5fbCrCTJCg/ewKmglnthJukEYaMx MO7BgQQR7iv+gA/5tr2diKNIrWNJOXMTZ2c8jtz+YpJZ45ZQwO0j59n93k4/lQRN62K8264kDBjt U4x6VajtWAErsincEjQcyS59B7VPMr2MzUVrVkKoHWQAAySt8vvjtisssrzS2kjhwjld8bblbHTB /CqNbe5ZH//V+XlknUuFywAJIY8mmZuJEaaFUaSDny5DhCM+nWv+gA/5tnszQvLtpoHvFiwo2xyH G1dwHT9Kow3kjgeV8smM7B940Ci1ZILtSoglWUGVxmaPHKckYPv3/GrxAcxLAwwYwSpPze+aCiOW ONYmmGxwpwcEE5Ht+FUhZG+CtGpLxAvtztyBjPGaAP/W+XI7iJt0bMHYN87McsTUbNBFKyuAyMPk YHvxX/QAf82447WAWJtgY5ZiM556U5odqk4+91J7007O6AqxRLMXjZmQbgygjjINWJoLlVGQHgRR vIPK9un4VpGSb2Az2hKNm224znHUGn+Y0IVpCXxydo6VTV0B/9f5Nllt7gyTENuYfKVPAOfT/PWn y3KsLaGIN5sEQV2xgEdsD8/zr/oBSvoj/m3LJlgaIxfMrEZG45+v6/lSQPsgWCR2ljwSrk5K8njj /CtrJKwDdOjsXuQb6IqqE/MD85/u47elSOsIdgSWQHAA4z9DUz0jYCr5skQMaHClsjPLfSrMmp3t xBDZSXMjxw5McUjlhH/u56A+ntWQH//Q+VYLUg+YQNo+82Mhf8/0qdA0haPhgT1X2r/oAP8Am3Kk tvsyI+o64qOKJymeQwbn1IFAFtlmAEoHmFeGUffApst6UQkRjftwMrnr3oMLa2RWtoTJtmlkBkU8 gDafrRLOwufNX5guFPy4BxxQbn//0flk3aSFSYIkCAKyxoIwwHc471jF7s3JCEIikvG5OSPSv+gA /wCbcvyTFmMglV5GH7wqMAHv/KmoscqPG5ZZFw0b/wAB55BoAe9rOJH8v7NNCGCwsGKO3HJII9as LI0MipMiq6fKVU5HFACBGmd1Kqd/yqznaE561mGF4fNt7mYPEJt4KAFVxnGDQB//0vka4SPevlEl MALuOTWhawySMVjjyI4i8gA6Ackmv+gA/wCbiKu7AbdZcsCBzgg96rTny85KiMDtQbpW0RVt45HM kgI8snjttFX5IYTEBBdJMWUk+TuXGPqB+lAGXjbEykNJs4Ynk1HDERCWYgxmQOEK4AHBxQB//9P5 OlubdZZWtxsjkJaKLbjb3AAqK0uZWErsjRyo2xCOjqRyf6Yr/oAP+b8UvudIgu1FBLt2z/kVbhkR WbcsUvyFVEnVc8bhSaurAVpX3ttHb5cLwKzL2YJ5QNtGPKHlkQjDOM8k5PX/AAppW0Gk3oiZfIeP LgkAfLgZNRWjIHeEKUA5GRgUG5//1Pjq6hJbdxtHUjvVuFrRYo0t1kLH5pZJW3AkjooHb/Gv+gA/ 5xyi0DNIz4Od20Ln5amMFzuNug3HGVMXzg8diKBpN7CiMvb/ADhiUOHJPpUSAAKyruYngEcCspP3 tDSMWr3GyXEzLcxG1MsUFs80pkBWEgKSQSOf/wBdfjx+2LexS+IQ1uqxJCZNqRRnyY2KxfIGbnuc ewNfl3jM/wDjXuPf9x/kz+hvoxL/AI2bhvT9Yn//1f4uJro3B2sdoTpjgA1Ru9RvT5Furs0UQyob oK/QKr9+Xz/U+ejsihI87DZKSyvyQwyQfY1JDG6qUkYrFjO0+grmei0N4L3Qf7PaqrswVZTiFMcu fYVnSR+VMpHKPg5XgjPY1gUPutxi2tkqxwoHb0/lRbQqEVGQBidxkz82PQ9q5zaC90//1v4nNkcV 5D5Zcx5VWUDk9jirl1ahWkWANI7tmNM5IB7Zr6uLZ5jguhSkt44omiZQGY4Pc5pkIVUFo77TuG1x 95e+KUtzPld7FuWyjWQSCXzApGEYdKkVysqNKTjkJjgLUiK0lyj3Pl78qv8AyzQjrTzKvlmIKN2d w9axl8THZo//1/4r4cJbrIyLubh8dBUEagOxUeZu6g+lfQHkNW0K7xByBAuV3YHqnvTEgEbAcq0b ZwDgtSaurFQetiUeZOF3xbJRKRFk8gdAaSWxly0oIfyx8wYc59RSjFRNG0tzGEU0vmu/meWSFVgP kQjt9avj7UV8pn3wsg2jqeKoycne5//Q/ifEeyBnYOYo15CjLH6CqX2uSJ1yJDD95VYc5HpXtSVn ZHlRk72ZO17eCQTYdFfAEZHEfsamuZi3lPE20gjeAN2R6CpNdiwJI2EhlKqkSZKqefy9fapQ6LFs iY7WxIjjqPagCk+yVZlZCwI4bOMGq8V5Jp82YraOWSQBGOdpA9Sf8aAWp//R/isvL5GlCjaCUUjY 24A4HWmvtdFMxZCMMD/eFeweeQNIpkAViG25XuuKsGe6KRD908m75lPCMPX+VAGerJG+6WHyzIxX g4TPYAVrorTwbWYGIHIjz81BpT7FSVRHt3DayviMDoRW35ZMMYEmSRu46j2oND//0v4qL6WW0cb0 3bmA8t/mJHrVASrJKZSoQqNqjoK9g5y4b5RERGC0hzgAZUe9UheszCIkmRsh0xkKKAJY7cQwGSRu Q/yjPTPSn2yzzBhNJj5uGxwB2oeiAU37Wk4YgumdjMV3Y7V01peWwK7ip39gKybvJBdbH//T/jGv LgsWIbIPB28gAcAVSSVFiZ23liMxKO+D3r2NjjlJ/CQIo1CV7aON5Jtm4xqv3vY/lT/srQxfZ3TY 4OVA5xWDbe5mFzpMi24lDRSMy7jGjBnx9KpR2rwfLsXI+ZuOPxpw3sArO0f+tBKu+Qx6A9sVXnQQ hnm8wFsOpLcKPp71sB//1P4nzMyxhtpkVjjb0IHrUEzxu6xxyNHIRyy5HTtmvVlqtDzbu9jTWZVh jW2idU2EXO5t7uemc+9YAjlaWYuQkZGFx1HPSsjOTuyd0aBInD5JGDg9vepbKXz7oxw7XZ1Oc4CD HbNaU+pI+bcHCS4k3dQoxx6VHPhysWDFEACNrdx2NaGn2D//1f4lYohA/wA/mhPvhkbac11sHim8 kRLNJEitYYWhK7OZMnkn3yeteu2lueVDcqS3Ey7SnlmIN84YZLg989qzvtq3VzLBNuUFQsTgAxjt zUuaWxqWWkiiZoYpDIVTawHIB7kfWp4tkkXlxBQ56MRgmsgGLHcRuzTu2+P7g6BR/k1m3tu6pJJ9 9nGAFOCppcyvYTSe5//W/iQWJ4XjSZiXfDO2d2K022qfL2lg68OOg+tdc9zzrLsJEVkkWFfuoP3r v90elXZdPjt9xiMbx7N7MDhPWoHYS1sHu8mPIKDd8xx7VdCzWm9PIiOVCq69T65oAybpTOHDIPKU ZIzhmIqkgjm2MhIwpxgYKmgD/9f+KSGSOHy0lDSFVLA7eR9an81HHmbgzMSFB52jpj8K6DzupGI5 w/7r5g3VCOT7Yq55cEW2Zg8EydMApniuixnNa3MdbSG5uXRz97kBjjOa7m0sIrDT432YSP8AjbnH oKCbNOxz9zdqRKyuqJL8qFlycn0rOjknmUWrGEQLwrBArMSe5oN0raH/0P4nLlEtn2qRLIPl3jlE qSGFCQ6Mz3GNzEnhhXoHnPZkF4lxvQhwGHQDt6itKNbpYVWEbHkG5yQG9O1AofCVXtGe4D7mVgMS sSQjD6VG0RHOFZV+VGxhj9aynuZPcnXbIhjxtA42kfequENoSyoI4gRFGiHdnvnFQI//0f4qGeCc oJCZBHH8oJ5jPt6UijjcSoRVwz/3vbFdB45AzYVHIAXOFBHJq1NNdmGPySCFU/KOGY/Wg0nFLY5Z Y57S4WVyWlBLcnAjJ61pyK4j84jzJT8xIPSgtKysV1h/fBy5JK7sgZGat7JpRt3lGIwfk+X8Krmd rMpJvY//0v4lY3trct50zNLGoaGLbxI2QME9u9W7tbdlBuVYNIBsAGUQ+56V0HnkmnMYyxtiIgvy 8H5/rU4s8ZlLEyA7sN0NBvHZEUtwzLIwX5lOGONqn1qWK43QJH5XzyNtQ4wpoGV3sRJJmQylVcGX y+Mr6KfwqdIEZ3aONsIcLGVzvX396iewH//T/ituoWitGaRSiBRgPw689K5VopFf7UhZQG/d49QO 1OzW5jGNyW2jllne4JcbmzIW4BP+c1uXKTo1vIixMjcSsHG449R1pBJWdi5DdyKhRApZjhUx17Yr lZ5JJrmSUg5HyOp4BwelBJYsrkW7EZEkbcgMOEreeSEgO0jFSgdtoK4PHyigD//U/ieWaQqyOQI2 bcoYDcO1TJP9naN5YYZ1TnbINye3+fasoL3jnLTBLpgINsSkhnVRhfpir6eF7+7ikvIbZzAMIjuM Iuepz3/+vWomrqxiX3k2EX2eVUlmVtoLLvjyDzzWTOlxNIgWRVQD7qjHT0oCK5VYu3Mnlorh3lMc fkkN0Ye4rPN7dKy+WGWNU2hD0XtkCguHxI//1f4kRcvC8NzE8itEuHA+UMT1JqbidFkx5byNlyvB b3oMp7kkokto5ooxvhljwEdsJuxjd9aoJaPC3lwys8zKGY7SsaZ7A9/rQQJJbG1VJiAVmk8lieuS M4qRX2rII1U4OXWPkr70AEXm3IAh8xJUJ4IwWFaUd28IeG4yJUjJ3KMsAR1oA//W/iC8pZ7gttLq wwzdClTuixKIoFzM/wAu9ztAoMYL3iCYPdCO3eF/Nj+8V+4R6n8qtRW4Qxjdt5+4eOntSTubF2/M bBAu3ds529X9z+VUfJjfy42m/fc+WEONmB3rF7s1prQom3CNIpZiAclgMp6daGEkUbRL5jqWynfb nrSLP//X/h8EfljcQzK3OZThvwFaunXKW0xkeKUxOnlkg7XX3Wuc6BGnumuF8pSIcnK/wt9auSMG TzGSGPaCqw5AckDgik3ZXIcEZ1nC91tNwqwyuW+UMGXjPf8ACobi1W28soTcKrlnUjYAPTIrLmaM 2rOxWS+kjUZhVIgxyUOWA/xq0t1JeTIo3LuBCbvvcZOTWq1WorH/0P4gJvtKOwaRti/Ljs1VprqW ERxqSqSn944HOPSucDW0BYbq7eOeXbELeSRGJxuZVyq/jjH41CJpPNLPamKSNyYo5V+U4PH8qBxd ncime5vWeWaJYHBwfLXAx0HFFsskE0uBLJGsfmfcPzADoB61s43jYL6ihZVke7Ft/rYyELryvpke 3vWeLWd5d5fzgD8yZ4ArKzW5pz6XP//R/h/dRGFEUSow5DqPm98mp7Ka5bgOvlDIYcZJrnNOcmcp B+8c4CZMmeA1FrqDuxaMYVeYwDwRQNTXUsi3kluYLq7mTyDkPERgr2znpVS/vIFmePTt0sEMhxIE xux60GkZ22Ee4e4hgmVNjAlGJGcEdx+VT2gZ5DuSNmXkBvutW0bW0Lc+x//S/imia3mknKn7NcFO ViH3z2T6f4Upggij2pIXDKC28bSp7j8KDqcm9GVgku5vmTKjGFO4e2DULzytO0VzK0nlxhI0JyEH XAoJOit7AXkCRxr5ZiT5mUE5/wAOK9E+DWlj+17iaR5TNcXQQMx3sFjDZUJnuPXsa68oXNmNFP8A mj+Z4nEUnHJ8RJfyS/I/bP4XRpBo+kKkt5bNdpFNNJDCT9nijbfJlTzu4xx6nr2/ta/4JS6Nodl8 O9IuNKkkmt73SQ1kzQ/ZxGhCE/KenK9Pc1/Z3jRVlh/CvCUVtJQ/L/hz+Vvo44eFfxCzPES+KHNb 73f9D//T/qJ/4KC6vc6X8GtYuY/LVJIJZc+YI5XaFflUZ6E9K/iI+LGpXU8dlqMzwh7mK8CfZW3t JHMWcFn+6d3m7T67a/uv6MGHjDhyvWW/N/l/kfxd9Kav7TijCUH2/V/5n4B/tTX1/wD8JDHHbXyF 4rOMXiEF/Jyq7URsbc/Ic+5r48F/MX3xr5jv8rrIcL/Ovwnxyrc/HeKhe6Vj+g/Cely8G4S6t7ps 2tmgRpppSrSMHKKAEjx2Fdl5bzWsRgXznxv5G4YHf/PpX4bW0Wh+nW0LfmTAxKjtPcCLLxEBVyO3 0966GCTdYxz3ii2kC5eDO8p/nrXBPsawjbVn/9T+NGG0VmihjubeWOVFuH8mXAi5OFb0PHSulMkc cAAhjIGYy5zucnpxXh1PM6CgdFuh5V00qMGfaiiQNIO4wK2rf+2Yhc/bXzECfIVZNxlXHGR61yzX vAR/Z5jaZdCpucmFZlKsMdf1pNFSSGzmfz83SscRODG+M9h1PSsedp2A1FuBeEGVQvkplyv3m/Cs GcRRCb7HPJcBpjiLbtEOTzz1PNKb2QH/1f4+ozJaAeWm6V2Acj+HPrVq6bVlgSS2gguNTnmGYd/k wlS3zEfQc4r486G0tzqAbmRRBdNvViDIjNkDAxWmk8Fi8FtbuSrjZtjXakZPQLj0pX1sJtJXOq8N LJHez219IJYJGAhCrs2gj5g3+Ir+q3/ghR4G0k6HqWri+lvJtX8QSmREh3abZSqygDf1JVcntnzK /PPEabWQuC+1KK/FHNiYc9CK80/xP7ItDt44rKBEm8xFt0jXqvCqB0/CtZJCmQV4BwCa+Sy2Kjh4 LyPRskrH/9b+Su/mura8ntbmQI0bsJfm3xsRn7h7ivNdSleN76S8aNrKNQbcZ/fl2PGB3NfK05KV GNjia0aKs9nMlrHLFeB7eY/8ezHLwgAEk/X+lZz3H2FvIjlYzyRl0mRcqg6A56V1XSMZq0bF2Wef ULa082NGeJSpkjTaZufvMPw7VbZJEjQIoMEuUfL+X5Qwefzpp2dwm7Kxh6fp9rbtdBXiZpn+XbJk oRnIXnkV0NskMCbG3TSEZUbcrHjvmtyOZ3P/1/40ri1EBa9vbmIrKxMEKP5kjKOOnbHPFc9cC2hv DZwxXEtrPb7WaSPDHcPmAbn+fSvHPN5la5pDWEuNun28ElvFZwiBxNAUhuOvKEjnFIYpla2htWWQ vcgmNjtiCnG5gfXFXGOty1J2sS3u2ViHQPcQnarg5cAcED2+lPtoxfr9maa700R8RXEMQkid8Hh8 /wAJ5yea1ESafaX8cjxLbGQJl5pduFZV4z/L8K6gRl4FuD8hVcfKcA11Q3QH/9D+OXU4ZJJNOYMZ 1j3DYfnj+bbyD27/AJmtbUdNgfS8WluY3hjAXy+FDEf3vc10Q6HmqL5mzwbWNPurHUIbjVUnknwI J3gPnKoxwxA4x71W0024vIyHlUh8kD/WZHINevh3blM6i1sfqr+x14rbR2sNNvFtb2O71WEWkF0N 2GcLsjJHBLlsGv6MP2DNeXTfj5pt7LaXem3usTGCK2ihMMVqHG+SPnleIwMdgRX92cMP6x4S1Iy1 /dP8j+QX/s/jpRaX24/p/wAOf26eAZZJfBmjxPF5TRabHFK2QRKQMMa/nD/4K3+F7PTda027ggiu JYfEEDPcNJ5YCy/aVP4KyoP+BCv5L8KKkqPiVh1T61Pwuf1D49YWNfgjEup9mLfzsz//0fjXXIRq 2p3cMlvNFbW8y7bjBjlDKMnyz3Xpn1rAt3u2u5LZ4gYot6JdXOYYyQp289z0OB9K/wBlqEvcTP8A GvH3WJaKE+l3sOzVDfOzmF7Z9PSLJdTkblJ4B9+uDXOzxhZA9kJGAbESSfO+R2J79cf0rpi7q55s n7x0txZadAlubtmzIoZ0VzHKSACwBHQjmtaxmsL6G61PT91tFpzrby2txOvn56Bgo+8DjOferg7O xLfVmTfyP4lubOI26RSwSmCJnkHzKOjEetX/AD7/AEeBrK9s9Ka2jujb28zQxSzSbsAtvIzgHoPp 61sYuV7n/9L4wsZbPTdOuNtubq4mUi3Df6pM/eIx1I61xDS3Ekkhu7WWGFbgiNXAEdxgDLKOehbH Nf7Wwelj/FKLs9S7AJTdeTDZ+dHPDsjlYARRluBxnJP071qRWtlewJapHExEjRqd4Ro3H3ic9/8A CtFoxX1ZltdrpkFxaNLeNJM4iCyIvloBx8pHrVlNHRmiudLk2SGNZphMwWWRgvzbD2HfFbmE97Gf JDdwRfZ2ze2tuPNm2KC+WOWQHGSe34Vvh1FigKMtyGDWcEg3yLnld2RwR3zVRtfUjyP/0/hrUdRh 1a2tbfyi19BCY9RlgXbuIb5eB2xjJ+tRWdzqCXtpJcMkjW6SQwMY8squMKc+q5b86/2/TXQ/xEns Ld2p1G4uHa7MlwhUGPG7BIHU9uOa6Cys7mxsHtpba3ktLsYupWYmQccBf6/SmYSXus53VUeL7TaG TzkMSyRqp3KVYAheOhx1qi0umNapYJpt79t+QokpIjC4AkdSo24HJAPPb3prcxLE9rbWk0kNjd/b bfareYiFAhI5Ug9COn4VNaFy/wBsvi7WsC+VDDCAJGZRwTnt29+ea3M5x0uj/9T4VTVPtTRvJCFm S4bLpkBkGdgA7cdapktcXhYIFQyADzDtViSBj61/uXFJ3uf4USSTsdVb4uI7mxubh47iBTKLVjhS AQoqC+0e2+zJ5OpRRXrujiSRjGsWGGRjqwxn8aFC9xbEwMgkk0q7uY7q38wiKfO5Vb+8hPODjpWr bv8AZIJWDkxxJ5exG3J1wOO2Tj86rkVzll8JhXFxfah5UVzbC2kjkMKxl8HJ6Dk+1XWXU00xbSK9 e3tLGdrkwSjKzO4VXABz2UflScOxif/V+JbeYeem4/u0czsqr1P098Cm3l9aLbtNbWjQum6R/LHL 9/udARg9K/3Jaa0Z/gq5JaGtYxab4gsk+1waleX00CTWrNfbbZE4PlmPGSep+8B7VUlE26SwkgFv DaxmZpGYbYMDO0n6E/lWkE0tTlqPXUjZ7gC3ghZCjgSeanzJIvtWjI072xEMJzE+JSq/MeP/ANVW c0pX0RXeU7AJPlf7o9cf5FVPMk3NnheoZV28DjnH0qop3RlLSJ//1vixJlleNWZVcYAkb3PU4q/P B9lU+aUZ5OmzOD7/AMq/3YP+fcpQ3MLXCwX0MnlxkAkDY7K3J2mpFitry7hTyIoILYlYpHPzY+vv gCgiUraFyW1VFkKzxlEbJAfcOPX0pf7RiuoGgMImZF/dTJwUI4/WqUmtDIqW8QU+a0Xmbvly3AU0 5P3UjO0bCNBjA53ewqufyLbklY//1/jjezzMVtpTDGoczsmIj04JpNOjC3EkiP5fmfNIdxVSBX+7 6aa0P+e81ZJLiUPfwYlg2iCGTcPIc8d+eQATT4/sViVliCSXEqbnaUEiN++0Z9hTCxnyhZomuI5o iyuRJAx2lRxyvbHP6UF2upIWFnDCI4hCJIYvLSTHQu3dj6n0px0ZnN9CJzqxW4/s1PmhQmeRkBWB SduT9cj35q46WLx2khheS8jj23UiFlDtngqmfStU05aGZ//Q+NpnmjTYxDMTnd/Ftzxn0oga0ubY QGNVubSX7SZHySeBt9uK/wB6D/nkm7ISYXE9uL9BH5PneUQCFJbrnb6dfan2WTKrvHugY7WbHyr2 oMi/qNrBZRxTsVbLbkiUcAjoxHcD0NV7VRLJFCqSM90CVVVyX2jsPwxQA2JLyAMbmAW6qBLGkvy7 25wNp64qK+ne7uUvbnyopXVYJbhVwFRSccDsM1pT6nOf/9H5InKsfLhkkeCP7jyDaWHY4/Kq1pHb JP8A6QJZQp3sqenT+ZFf71Sbb1P+dcS7Q28zYUqrYYRj5sA4K/oRUMV15koWQkFRgKTwK1WqA1ku ro25t1fzIY2MqoFBK5GCc9e30qAvaCB/tEpt7pHV4XKlo3XJ3q+OQx4wenXNMymtSIaXbXLG6S8n Uyvlo5nZ4I1x1Xr6DjFQW2m3Iz5YJdsspchcDPr+FArq1j//0vjuSOTeJAXzat5UhByoJGQP0NWI 55Y5C3Uv0OORX++ULX1P+dRcvKX7mDzrQzpKDc+asZicYypBy2fbGMY71Wt2Ni33FlyNrK4ypz/n 9K0lG+xkRxSm33NChWRn+Zv4QPQCpJXnuQ1wu5thHmMRkfQ/XFUlbQT2YsrTfKArRgrluMcHpitD T9Lk1GdkjlihjijXa0z7RKT68cHqPSgwP//T+TWtjG87TBVaOQxbQRzjjP6datxkttIH3RgE9q/3 4P8AnHGTxbkMjSLwcEL94U2OGQ5zIWixj0z9RQS4pkAt44LhZmRZ2Xgq4yuOwxUxuYVhZIoxln3m Prs/zn9Krl925motkUUrkuzEeWTgox6UE2g3OVjMicoHXLA+3pUhyO1z/9T5ISVriMKxCSAbSw4F XLb7JZwSSvt+0IvlbUQuZck5cnPGM4wvp+Nf78H/ADfkSX7h/LmI8rlgG5259Pyp51GKGOQTCUR7 SVCRmVuOmQOaAHWsq31t9vt7aVrSNjDJMYiqqw6qc9+Rx70BbVJo7dGZoQNybxyM8kD6cigibtoO d5Y08r7PE4MmfNIxIoweB+lS2drbyurTOIvKfLSFfuKeuKBybTR//9X5hn8md1aPLmDKxN6DNVrS ZIp5PMaeJljyjREKGJ7HPbr+lf78H/N+UHXyk3q5lkklI25ycdql+xzTuolL2gRd7K4w7YzwP/rU ET2MmS2mFwGyxw3BB4IrVtRvfy5GZF9QK6DNOzLtwZIjGzBRAiFSwG1vYn9aoxzFHLKx2sefU0Dc m9Gf/9b5hecCICUqCTlDj5m9qguELRhyzBFIDegzwMj8K/6AD/m3JBFL9kdIjGHl4SR1B2njv2qt bzS24kt5yWYnDEHKtjvQBDICytg/MPuhuhq9iRIo9gjQsuSQMlTnHH5GgC0ZYIo1DTq7snzgLtKn 0NUNk+7zY0EkXdvQUAf/1/lGR/szxYJWaQ5VgMY/GnS2zzCKeSfzGmkZdgPK4x1+uTX/AEAH/NrL SzLMgmgjWMYMRGGVlz9PpUUUaTB2UjzEIDKTyQfSgzk7sc6BZFRcDdgEnpVWcmF0aQkkHA5wKxa9 6yJNG123BkVx+7ZPlUdVOetVzGlvM3yHJbIJpXfcbfQ//9D5XEt3NczyuwMeAAqoI8AADt16VLJJ FjbE2HT7wxgj1Ff783b3P+bHmdrFSVLiS3OGJQyhmC9yM/4mi3vbmBTFaRrBdqT+/wAfvVyMY+lW pJLUketvcgh7tgZANzFRwcjNLsUeZJ8ysV2swPOPQVobQvbUZby7V8qExLCFMn744ZsDoM9T9ato DOpmBK7cqqg4FBR//9H5PFiWnaXDLtXr2NM8h53G2OWQRDLMPuqPU81/0AH/ADbjpT5SrsbJB+7V xLszw+XgBxweMe1ADl3xpm4KZAxGFXaQO31qL7WNsgJzkYK+tAEcQRG84ZBC/KM8KahBEjsI2G5j xxxVylpYD//S+ThZlZBJ/CoGQPWpplE06TAKDHH5eRxux6/p+Vf9AKdtj/m3ASRD5TFuypBJ6D3F VUfY7qVPlZ5NbJp7AWvIhlZpoXPlRJuYyDyySOqjk5qm6XEs6PCCwCEr6BRyf8aUlpYB7R7MMXG8 nBz2+lVkKNOHErIR8gLfKMe9Ygf/0/ku2uAzyRCQ+WG2yejcdRWkFEGHhYMWJRl7qPWv+gA/5ty/ EtrEjTXAaQBchEYIW9Mnms5p4ZJd0SeWueV5K9elAFmK4aCYyRIhVlwyn5h+RqlPFZandNGbl7RI SHklRCVzjJTHX8qCIpqTEV44mMUeSitgMy4Y/Wpmt0eF5ABgfK2Tg5PFBZ//1PlSW02xoY3HC8nr 9ahHDbSAy/xMvH4frX/QAf8ANuJO1qUZLeEowOWdn3Z9cVmx3ZG9nhO1X2gKMkjIAoA03EoKSRbt hOSDxio7qRJMKrkSbQSy8kY7f59TQBSme4Plos7LhssoHLD3q4lwm3bJGZVHysF4ak02tAP/1fky SJVjVo1yo6AdqnMqrEH5R+gA71/v3LmWlz/m3EEsMpAkJVFILMhwxqG8ktiwRA5Qj5SR/OlzSKUm lYS0hR08hZdpZSUDty+BTIV+zoY8qnOAW5C0c0kbFaK9W4E0MXziNx5zbSo4PvV+U293Lb21tOi5 UAtKPJRD/Fk+3rTU31A//9b5BvmmtnW3MShxhQVHyyAn7wPfrS+bLC0SmPEZ++xHev8Af3nVz/m/ A3ESylXyBuxnsabO6ROGBOOwHerGk3sQNOAW8sEFmyCTk0+Jhv3TbXkL4jXHy+g/pQaQVlqW1hgR 5nlYxbUOEHzIWHT/ACKyftE7IzzIqBWI/djHAPB6UFn/1/jEPvAJZip6dqe15bRtHEissar+8kI/ i/wr/oAP+ccUTqcqZMkdNvSnxXLohCMQ27r0ND20NKfUsgsYdsp2+Y2SFOG49asRmJVeNAfKOCF6 vuHAOa5zQjmnEFvOsxcRSxMkmwfMwIIGfXtxX4yftarG2s3kNxFJcQx7vIaMHcSWQfKvXgHdnsCK /LvGT/k3+PT/AJX+TP6E+jD/AMnMw/p+sT//0P4qntHtYSyzM8bOcNKm10Hv61XlYELNt/dqNrSA cV+h1YpVJLzPnYfChJD5hRoZCUVQ4DLtP1qvJM5nBlz8g7cZ9q5DRSa0RZBjv0xx5kbfLgDKe/6U +5dQmGRSExlh1X3rB7mxlXcrxlfKYljw6/wkVVjjuBLHvZtp5GKxsuexak0rH//R/issEjjkMkkZ lfbhVZtqqfWt6FbSdRJnEiSFWZOWT1r6ymecndHK6hsid1Z2wHIjdlw7VThJd0barFDycYc49aJk /bNYPli+xF4wA3pWdc3J/eYz5TLtCgZ2/jWZnG19TOQRoHnTPmx8kc/MOlazW8xXeCG3R5GB868d cVlPc2eiP//S/igtbiUQeXMu88ocDHbGSKieX7Jhckkt8xHQe1fQHkN3dydNRt4AGxw3Hyjv60PP Az5GeVzvPfPpQOPxK41XfeJPN3bOhPoO1XlvzNHgKAz8bsckDiguexFLAVhSONSsbNvKngMe9ZaS pDNjzD97YVPzE+woMj//0/4rGHlQsHkJJGIwPQ+tYtzCYWiZ3fcTuVBz5de1L4meQtGElx5p2qsj hl29AOe//wCuoAJ0DtDyYSA6t1UdPxqSpSvsQQOGnfehYj5SM8H8K1Zg8Yj8pZA7EJhgdq+tAuZk sszW+6HZuZcMxPAb6VlyHzZxszFJIoXH8IoKg7RZ/9T+I2OAxuTLJll6HHWtaaV5o0EqhQyjbxt4 6V7B55DFcRW7hZIhKG4BI+VauKFaRSn1HoKAC8hxt3Dcq/MGx909KqOzW8Qlt/MdgcsAMnn0FK6T sawWhY8/zPJMauiJGPMWX75fuR6DOeK2bGWJCDI3mSN8yrTLP//V/is1C6ivJ2MUYzH8rL1/Ws5o gx/e/Iq84xwRXsHOTWxhEchiQKxUqFxyP8Kqi2cNFNFG3mM22RmOc4P+fyoA04hBI2JSAgIz35qa 7kVG8vbtIVSCqbcg9D+NTLSLAUW6BS42l5F+QHuf84qjJFLEokLKHBw4j+6p9qyjujGTuz//1v4q kugu1DuYKPMfjmoZp5tyGMDEjYXPUD/OK9SfQ88s2sklrPK2NkjLuVh0J9P8+lXJ5JbiVJWHzbhu C8Djg1mBTnupIGZY1Yc5yRkE+1ZL31wzPvyGLDcv3VHoauKaYGrbyRzosUqvIcZUoNxz2FTAwMyC 5lkPBWSMIGDDsK12A//X/i4gtIVkFzs3vn5UflSvpiq9xY7pm+zwCPzzlIxwqewJ7V6N2efYkgtA kYAbLEYcdga56+hlgdjErhVOfLIOAT1NOKT3J5Fe5Fayl1cSruYoUI/unscURqkLbYQq4+ZjkZNS S4WLKXDeYheMg9jj7wqR1j2F+TIzZ+bp9BTuxzSUbH//0P4r0hFzbG3CqHjXzBKrgOgAyR71TSHO xm5aMbd54yBXott7nlU9xl/J5k0dsGCny85i4V//ANWKqzwlYlWLOEAMjj7zHvmkbw+JF2GWJQDE mCyAO5H3iPWtFp40bDIoYLwU5LntgUbA4NFoSu0W+Vf3g4AIwT6ZqONFlXLAEs2Tj2rB7hJWdj// 0f4spEjiaQKgm3HasjDlR7VlsWDmFQ+89HA+X6V0HA01oxZbeWFI03kHPzscCokut8slsFZ4Qu0G TgE/SgReSe7hRRtIb+Arxx6U6C985kWUN87bH3HpQBoLawyKcfwEkP2+laOm6ZZ3hEcOyBxkvLId q+5P/wBagD//0v4vpLVLWScSBJDnZ6hgO4qlbwqWkWJI4xI+Yywxt9cV0HnlgRtBtilYq+7PmIME j2qO5aS5G6aTMigJGr9CB0rZST0AzrSMpdbGVmMZyxxhgO9dZfa1K9ilqsKpEM7dowOgHPvVBY40 sYcrgSr94K3Y1dSxmeF5FCjcN+xT8w9qAP/T/ieuWMZijeP5GyJJO/0qNXW3bznXZEo2RbWyzfUV 6B5sr6pF0ASrGwwz9jjBb602G5lWQtJwRlD6jHagzV2rGtbgXCSl/lO3CA8YrnLx5fMMSgrlvmI7 YrKe4mmtzQs3gikU3O4lh+7XHynFQX/mMS6qPLB3qF7etQI//9T+JqEphguQZIQJUkGCc9xSpKIo /s0pQbsmI4PXtmug8iO6K9us0rRxzbvlfgZzxWmHEc6Bkfy8YDfw0Gk9iO7gjnzMnKKcMAecVTuJ YoI8Iww6ldrdsU0m3ZDjLmGxzhhbywIqIgxIhXeZSCeTn+npUsk8xeNwCCSSxAxj0xQ1Z2NIy5T/ 1f4zvDPhTSNbiuG1DUobW8hmEqJL8u5ME8c8nP8AOsTVtKvo5pIgoktQ/wC4dAS0gGM7voa6baXO J25UZTl7YMhQAyLsUkdfrTZLi4ktYwFJMT7ZHPGTzx/n0pGkXdFiCJbopC8ohjUbpjtySQOKqSzT WqsCQUHAz2z6UPRDNG1uv9GjU55OCOpXJzVuLU4oTsIC87c46msnK8QP/9b+Lm6vYbmCOGcYLk4d xhSKzZLREaKPfGUChxtbIIPOPr6irnujnLXkwRxO0abi+MKTwmO4+tZBt5zcRzeVI67iihMmMZHR vbpUDbu7hdebGsUaxSLMshMkwPylew9jVR5CYnTkBRuDNzk+uaBEFoFvZEjaULITgjbgEDAwPfiu hkt/scbWpSR3Ub1Dr0B6c/0qUnzMD//X/iMlaaKcb0dRgEbhjNTlridOAFCdsYz9fyrBOzuc46OS WwiYjYZpMH5j94jt/Ouos/G2vokVtEEhjtYvKhVVMiknIO9Oh6k1o5RegHLSwzT3aO8/2kPmWWNl C+U/sPQ4qe4kYhDGkcZT5G2jDCrAqz75YmSP727p/eqO2MyuqzqrNwgDHAGPegqHxI//0P4prmCN YHMcaMWXCf7J9T+VZdtcrbhYrltwQ8bV4B9hQYPdl43EMkUkJxI0hOyVuCvsB2rKeW6WWGBG2LG+ SR/EPeklZiGX7vGjG4k3pvCwqhyuf8eDWbBJc2/nNBHnzcKzN97HtTK5ZHRWF0YG89VOFXbIJBtz U4vnuMOEji3kgEDORk9TQWqa6n//0f4m44ks5XdjvBXc+wfJjtVpY4JhuGyVwnmxwq43fjQEY20Q TiJDEY1w23D4Odn1rEispJJ/tTyOURjtD8HHT8KmKtdGvIrWEv5I4mi8l33S5VwRgL6UkFqzlXaQ GQnaoT0PrWT3ZUVZWN/7LbbXtHBjfZnkct75/CqT+famWGKOGUyKB5x+YQ4PUe9IZ//S/iCvI5JL iISYkZBwvY5rVjgn3qkiRruQKndQBn9a5zoJ1QB3VFkGz5ZWK4AI6YzVeZCsW9kWSRfu56n3xWdT oBVh3JGvlxmSa5fy+Rgxd80xFErCFy7LvKSgDr7ZrMyn8RauNO+zxny0BRhhEY5APuaq6cksKSb4 z5oO3JGAB7GrUrWQ6fU//9P+I6S2EsyRM7vuHCgcLnrii5sIFto4GV1kVsRuxz17GuZNPYb3K9pY m3ErkhhHiQqDjbjvUkt3mYruaWJwB5pXlSB2+nSmI0UdhA7rFueFc4B+aXPtVxbKdYmnjlBeRRvQ 4UAegroA5+5urrYIYVDzmXAHTPHH9aitIpYpP36NkH94ewPpWc0B/9T+Iy5tJcGZCrBTujH3SAfa mQwWiFVScrJjdKCCMMf4TXOBYnsbiSD94YHhQl3jyQxHpnHtVa3CpuKLHFbgcLu+bjsKAFh824V1 muI40QbkjZc7vYGs0hJXVY/NVzJtVUHyMelBcH0N6087ZIgtlZIFLy5wob1yTWfJf2jFlsWbzGGJ PlwYT3AOf1qoOzNT/9X+IGGWS0fc25xJwx6sp960CC8X2h3Yxjoi9veg6NiW3tZoJJjGSVKeaqD5 lYnpn/CnBnmy7Ww89W28Hg46E0WIn0NiHULq2hcRyyiWVTC8ES7VKkc5b0r1f4HwarDryajcCdLO wvd8jouftIKHIX0wDg+pI9K9jhyg6uc4an3nH8z5vi2t7HhrF1O0JfkfvB8P7JtObwtFqNwqi7e1 eztzN5pjjuHSR1bA6bXbIHrX9xf/AAT20PS9G+GVjBY2/kJ/YNpLp7hduImjVpuOg+ckY9DX9YfS Gk6HA2WYaOi0/BL9Ln85fRciqvEub4iW/wDm3/wD/9b+iz/gqbqhsfg7rIVZbjdo889vCcAbYraR 5CPc4IH41/FF46v4LnTNNBF7crFBClvbQ3fl24jjKBo9m05JUOu/OQTnBr++/o00+ThGrLuz+G/p Lp1eOcLba1vyPwh/aY1RD461qC1tUtbP+1JC9o1x572y7V8pDnnj+or5ZgjWWR3lBCb8Ls4Ga/mH xkq8/HuOX94/qzw0pKlwfgk19hHcWdkZYBvyItvy/L1rShlls1t4EZktMFXkVd8xJ459uv51+Q4h 2sffpe7Y2LSKJN15GzyykbJdw4C9Rj361owzNcRTXEiKttEyxwsTy7fxcVwzlpc0gk3qf//X/jPs rW0uppI0njtnChpZA2N5HQY9qlkuvN8SJpkJmEKiOGR3XFuSRkuh6HOecGvDqHfyrsdBa2+oWV/I 14zQeTP/AKIfvxlONrEEYPermqfar8XFpZXxgvolMsIjALuecNgjp1rnqdBNKzMVJdbjtl1Ka5fU YdMZba4adwWDtnaqxg99rZwOK2NL1rTbkX+p3tk4YQ/6JGkRdrdwegHXHX1rladzKytcrJfW+qSz /Z7h7SVXVH2R7WRuC2ARggggZHHNaaaGxkaS3WWZZWEcflkDY2RgtweDz3H1pz3Ef//Q/kVvrG60 yaGC9EaSTfvEVXDqwHc49KuyyxzyRXlrDFGkSiOWMtl1YDll+uP1r45uzSNZrQkR1kcys2H7qOno P5Vr6X9lkkKylo5gTtBHUj0rNvUUlaKPTtBjtFiZo7R72+C/uYAA5nPYAepIr+yD/ghF4OktfhPo 06WsdvaXuvNqTW6EBricoDKrZ5woIUY9Metfn/iI08rhT7ziZ1WlThF9ZH9StjgQomxY22j93GMK nYAVflG9Qo7dvSvlcGnGlBHoH//R/lC8S6RaWeoIryL9stHMMto029LgJ8hZvxXP415Pq0mnfbpY ms2E0ardNKBi2VuVAGepxj8q+OwcubDxl5HHHVNFO3i4LNtkVju8lWwoBrK1C5s7Rok2SLPfyG2U CLzFRcBgM/w9Dz/9euttvVmco9GXbMzw6e3lQPJOkmBEww6gnH5d6vSoks507UWksw9uZDJ5RZRx n8j/AFrSPwozna5ylloWoT3UcFkkBiluvKjQzCE468cdfat2Oz1iOS90zSLpJnmaO6drvERjdRh4 lPXaOfqc10x2Rmf/0v4wbjSrpLieC+vEjvbVRNFFE4kWNj9Omefyp0UF1iL7TcNM6uWWSQbUy3JG fyrxzxy9cyxTQWyTyQuwkMcKnlou5bA7HJ/I0SxukTNEpKgYZ1HCe4rSBrDaxmqwj8sHezBQBK/V vcmtrT7m6tJIIbmKO4SaVvNj8zCQrztbHc8AfWtYq7sJO89DpYtQbTldks2m82RYtvbDHBDe2Dz9 KkurZ4ysMq+UhG8pH8yqDziumHxI0P/T/jka4uLq7WC1uJrfTvLK3IEAjkZxnGGyeM/zNaEBvY4Y 47iVyoP+kRowKSAZwR2963p9Dzk9WjzvWrO5ku7u/tCYbYp5F0lxIJEbH8QOOOh/KvLEv5zqZkgM ZjRNpcrtaUjABxXq0XqkTKN5H6V/sYvHf3KtqFhGLm31eEaMXfakd23lyLLKSeigHZjHOOtf0hfs h6jPb/FfwRqF9NPbzyao89zqFzP5hnyuyRCPcscEelf3R4fTdfwrqQ/uS/Jo/kjOqao+NmHn/fj+ h/cl8Hri4uvAmlNNNFcSxWcc8m1xJ5yugaNtw65H86/Br/gs1p7Wemx64tvE0dg1tetC6kmXdewI iLjo2JWIz6V/KXhhKNHxVw8JLT2jX4n9QeOsJT8PcXOL1UEf/9T5akls7jyrm5ultVnO8o0ZbaSM 4xjOf8K5zU54bjzYLCT7RYzOqR+YojdGHDSc9O+Pav8AZDDv92kf45ZjT/2mXqR+IpBb6RbhGhgj EqWzzxgG5wVOXHv8vJ6c1kaFb6bazS28dyLy3BLRzzfJM7AE4TPTqRg11KTWh5NSD5tCpqd0Entr S5towL6TOSpdoiM8hhwOtVILeCO+vrixg2WjFZLlslkgVQF+Zvfnk1svIiUGkXbxbPSrCTWra0+1 Xd1cLGfImHC46KvbHUn0p1tPA6QTsWmuM7ktZ0MrbuvHBUit43tqc7g0f//V+MZtSa4hgtbSG1F5 aDJAQxs6sc5dvUDOPpXEzW0unX00upLM32iUKh88SxDBG7CjPGPSv9qNj/E86wLZW8Mlyk5EMMIn DY8xE6cnHOMntXMxWhsLddQtTI6y3HmmNVZmyzDkg8jOfwFbq9tQJ7b7ZrV+baUwxjPmSxyFYPJT rkA8n6V0S2xsLmOCzeGe72uUnZxKDGwGY8EcEbW+uV44FaQbvYwk9dSGd0jbT40hwbyZkvcNieGT I2EdtvYj1q7qmmKkUjJIslwsXmOA2AgBGS7dOR0rUzfxo//W+DbGzgt/td5kxtcW/kNIpO4j1HYf WqdrbXy2ymTUvM+yTSyxs52GSMjK8/oB6iv9uD/Ec0NFkE0jJArRs8nm3jyYLs33d2fTHQVsxwRX HiK3sJNQWKC/22TSyzbba2JOTIx6ccjitIN7GM0rk1z4fe2s55rV/PntLrc8LkbrmIHG1Ceh7023 kltpDY3QijN0yzIjoHuhgMR83YEN24NaGLilFkkemQwPcup8ye6cvJHsEcaDORjH61hz3M39oQWv nQWjLcIrxyIB5iHrjsBjHPbP1rSEujMnsz//1/i6OwVNQkNwYTHE2WkJGwfl2H9Kpzzw6inkrHAt hJc+cZuTJdFDndk9Oen0r/cg/wAKZfEym5iSRvIO58kqyngKOopgma8bdskUt8iqRyMdRTTa2Jt0 Nmx02ylljn1resFpbvJFGWKOZCNsZx6g4IzVx20tbMRQz3QfJaUMAIXOMLjnsfXPeqU3fU5aisrM pWkZ092tP3tzdLB9oL3riQlj3B4x2wB2NVI7nYs7FnJmk8x0LkxIRwcA9Kbn2Odp62P/0Pjm1ura zu47vToZsGz8u5knCzRB2GHCoRgjk/41VhSBU1C4WIHy186TPEjAkLgKP94ZAr/cpu7uz/BB7jdG 1URyG5s7c2wjY2oyvlom5SMhfpnH0rX1WWwu4jZKI5rieLbdsq7Bz0U9ycfz71stVc4qhjW6QWNw kiLJNJDFshjRisQPb5ehxVvSNSvZjc6imHtGlOJfuorDquO4HvQYTTKUTyzIfMRPNkbc23oh5yB7 f4U0wrbI0RleRpnLHJz5fOdorePwojW2p//R+QNPtLbyZLiVowY1+47iN2wM/L3z9KyLu5i8y2mt LlpZ55mzb3G4tbbNoBZmG0g88D05r/dg/wCfexV33N9KskqqPKXy0KNxgZPT8TWhbK0bu1zE/lKC yL/G/XH4GgTinuPhtDdWupXlvGbVJJPkRmZomkGAVXPbAGfrUMcD20McPkkRNIrSJDwVOefT3oBR SNNR5m6KSYQRE7oxtIPT+L3rNtZmaWS2aR5oYSzp2A7Z/QU2rOxM9j//0vkO3Ms+6GS5ENow5jaT CORwOOn/AOuq1+1skccFtAGTiGZQPkOSAG/DP6V/u7Be6f8APc2luaV/pf8AZtuttBdQzup80m2b zIFGBjH9apWtsbgbXIdyhCj7oGAefarBNMgtibcJbO0EzH5Lj938qEnAx+nNX5WeOS3tJpZUtftA nZIx8hIHU0GUviY2W5ZJ5Rau4gbhw3CvjpkfhVGCW6lvoY7VWaSSQRhlO1UzxyfSmnZ3Isf/0/kK e3kDeWFLT7iHUDcQR1rOuI2spp8yDzLlAJfKwRg44OP88Gv96D/nllG5ftPszRG3dWj8uL5HT5lB J5LCprhriGCK1CyPZRgStdCIJEzHgA989eDQRKNtUU5ZRK+9mMxaPywHJwvHGPpSxb7QCcDMiArG Ou3PpTas7EFRruWaZfNJlYuepyF61tKY51RGtBuWMoTHlt/JO4j1+npWsYpIzlDqj//U+PRHPLK0 vkTwwxsIiJAQrtztI9M4OKW4UrPazQpPHcwK8M6u2IWBIwNvfGO/rX+9zimf865atUhe3ut7SG8Y gxHIaM9iuPX8e1UJrdflwx85h8wUfzqrW0A1YkFrFHvby2ADEhuXGc4P5VQ1ExCaEPJE8l1H5wjB 3Oozjkdv8KAsT5naeBcMEMQhRQuE4HJ4/wA81YFyLaOaFAJJANuWPzdetBlPc//V+SoZEWKQyRhD KwJPXcQMDIqrHKDcAHAA7e9f74H/ADpNrksWpIJGbzTMFDMG+XOFHuKYxS4dPIlEmOMr044p8z2I FCFQQqGTJwzBcrkds1LbSvLDNAF8qPfh1zhmIJwfWtou6IlJWshlyt0I0IJKKcKDycZ7VWt53huA JRKkTYZ1GV3jPbtTMj//1vkpYkuZFZpGK7twDnB+tWVDhWVc4Hyg4r/fg/5xyDHkowAJLHcTjv71 Tea6eRVVnWJGDbUAHTsT1xxQlfQDYRxNvJkSF40ASMqSznufTj+tYuoIbaZZ7fdJ9oc/aGYbUUgA AKvbpn8fbne1lZCSsNtLeSZmLMVABdsn9KsiBZHMaKzySHy0C8vz/dHrWFh7H//X+RJwYUXy0Kje ELMMZOcVbh09zcC4lJ2FBuQHATtk/Xiv9+D/AJvye7tI1AkQq4znjlh+FVBH5hwWX5+GOOKACGGS zDrHlkDmQKORk9SRVeKaUznzYGGw/LKcbD+tBE4tu5updQSzwm8/dRQrtJt0BeX/AHgf6VAJhdXs 6RRCKxLEpk/P6UBJapn/0PlC4WazuRscGMHcCOR+NI9yhZ/MiVzPkM2Coiz6V/vwf83cpSTsR+Uk W2Pa+FA2FhgkcYP8qumJLlHU3aq8cfyKwZi3+yMDjPvgUENtqzH2lvIdlv8AZx5C5/fAcgjtTLn/ AEcyARY7IT0Pv/8ArroEReZffZnbBkRmHyYHQYwM+lRTLHk5Cp5nIVCSIz6DPpQB/9H5Yi+zyJhz mWNdqZFOmCJEDgsD1r/oAP8Am3JovPmtZQkEgSJRm4xmOHJwC341ALZVUyeZuAUksehoApEhxv3E qDjpVpQyBZEBVANoZ/uZoApuolZiuQAcSc5ye+K1SsD2SQqZUIC7tjbTkEHqO3H60Af/0vku5u/M ZIeWEI6n+Ee1aGnw+b5jK3yKhfeRkLgf/qFf9AB/zaT2Ks819NsUgmJBtjl248wD/wDXVHzZYZQA 3BPzknFQ52djN7mzaq0rmUoDF5ZUOT8u6qzwzzsTKvyIfl4wKmNua4iWFnt98i/MANqrjPtTnimd GnfLbBuC+tJqyTA//9P5d+1EojKixYjCttGd5Hf8aFijnhmu2fDKQCuAue2f0/Wv9/PZn/NeOjTF uGSQDfyCD9arwquSY+WztLt95jT5FawE0KStOqyb9hPUDJ/z0qwVhMMqOcYbHIweOKtK2htB3Wpl /ZU3bpEbK8xHtj/IqSSWVI28hSyoPnwOKCj/1PkyDUJ4DvZgrNxtPzYrWumkFxbSRKQLmAHpgknv getf9AB/zbmReRG2llt5QyXEbkMMcg1at5rT7PbgJL9pLHzC3APpgduKAEvFO4q6srIfutkFaWys pJwZNqgDOcnnA70ARSEJvXy23AlVOcKR9PwqGCLZyIzycgD8aAP/1flEXEgLr5fD9O2059Kjumdh hR5atwe2a/6AD/m3LtokMKAzBpO5AOGI9qoXMokmmEIKWrN+7Df6wfXFGwEXn3DeVbqoSKJdoc9X ySTnn3q+jNAAgJAYeuMg1pz6eYEV9Fb+VnDebkMgB/HP8qhiFq9rMJomadl2QtuKKnq3qTU83vcw H//W+QgdohtbeEL5KYklJyzEev4fyrXChbfzXYZB2hVHLfQV/wBAqn3P+bcjcPNjBIXuO1N8hWYK pCkdAD1rN7gTK6QOF2lmxzxkE+lVRI8N0GEIwW2vG3BGeM/h/SkBoSR+Y+WUL8u4kd6pht5VQG4b aF6A9ulAH//X+Vb2K4sQDN8qyNtCE9P1qAqsinyVIIXMh/rX/QBsf824+KKFEy/r3qK5aLYyRxhN 2PmA9KAJk3TwKgcAxjDZOARVB4pjI0drE0pUFl2jcWx2pXQFqyj86H7WwMFysnltazx4J68jPBH+ NI9qVmEm7CAcoB97/P8AWhtID//Q+UxKIgyt91RlOM5Pb+lR5klBZUBUDJwPlr/fuUk0f825Vt4g fMQ/KQ27npUU4M8JSJ/JZW4kZfkOO2PwxmoAR0fyVVmXzVHDoduaBN8io4+ZhsLHuaDdKysWLa3j tvM3g7n4YelUjEyysemDhW6HFAz/0fkQSQr5SS5Zl+73IHvVuSa1mdIZWIhDAu6jLLg9q/34sf8A ODFXdjBvr2y8yWNvNRgcQBYi5f0BNEfmzeSSCqA5dXHIFNNo2L7iHkn5E6c8tUcscMcRKh2Yrlck ZYj3rZO4CyXCS20UbQpHIi4wOSfrUUIZUy5G09qLq9gP/9L4xk3ACWNN6FwhCgcZ9vwpzRiOTe0Y ZcZK7cg1/wBAB/zjkX7hSGxsydoHSrDL5KhgAQeOBQaU+pCJfkdZN+4n5T0xzV+F/LjV2R8EYBx1 rB7sqTs0LPBdy2XnGaO3VZCY2kYcttyBj36enNfjT+2NLLZeJriNkkUtezyXFxHh2jVPLUJgdmZj k/7I9a/KvGfTw9x7/uv/ANJZ/Q30Yf8Ak5mG/rrE/9P+K6/kKzeXPKjF0BVNwKqG5BPv+tVWjHlK qvvjLfcz8ua/Q63xyPnKfwImR4UkVW3YZf3pAyBjoBVbUZLUToLZXcmIBldcYPTj1rkLM+1gljLt vKAn5lHGa0Ftd8m9yyjbkrnGRWD3L5vdsjNktoo5WlEkkkZf92kjZ2/WrcJjaP8AetsIbaAvX8Ky Ws2XF3R//9T+J6e4NvGZF+aPoSeWWo7e/u1WSSJN9qgDOycupPHNfUHkqTSsR3LT3rQSpG0qyApF x0YHn+da9lGZv3IgDTIuXx1XHXNBJVmkSKbawLNu2gAZwfpVK8u1/wBSqqrD+4ucUm1HcBbWBkik uI0EjdChOM/Sr1rBctdGYM2SmNozjHpj/PWspO7NJvoj/9X+K2ZkiOyIxNITmRSeU/8Ar/41iPA8 jb5Qw3HDKG5HvX0B45ZhtNPT95dTrHAEKnd8yqe2f8amltCFiAJkij4VugYdse1AFR7eSNgxJUZz s7VIrvapuVR97JBHykUDbb0ZaVjc7k86Q8btpPEeR2qOKwgYEQndcLneznr9KBH/1v4oyskmIzw8 PO4ng+1QXG1lIQjeOueSDXtyi76HjlO0lUcSf63eQpxt6dsVcyfMaZDHJbeXlxk7y3Tipaa3AqRw PCfO+55n3cjcetbgnRo/NKjES48s9XI7ikBimZrqR4n+UsMqQPuj0zTxbSwOsk2WI6Oep9KAP//X /ibWGScBlCYVvmxWlJbxzRq74jWM8j7v4V6qlrZnmw2MR45GlYR7RHu+Uj72K0UiMcK7pWAU5BA5 FTDWRRdLs8XDB0x8vqTVRZCqMrggKcA461Ul7yKUmtB8saJG22ZZQYg+Y23Bcjofes62QvOgdzFD 3fBOPwo5k3ZGqd9D/9D+KKVZY03KCwPCkDBaltYZLqPMiFCAc7j86Eeor2DmbsrjpIxGgfdsZRsY AcMfXNQxXDRny8l45B8+B09xQ3bchz00FNuqlmVyqsMru6A+lMtXaV5BI52ocFpOp7cVnKStZGfq XpN5y0as7xx/KiDJaoUn5MToylxzkdCKhaMD/9H+JyO4EV38hQ7hsmZh0/z/AFq1MoXJByW6EdF+ lenNp7HnjLdCi7pZWfaflLflVpGLF3hclhwY8YyagCYwusXmOQ4IywxyprLMBllwyjyyMg9Aa3Tu BH5iQKxUzQXUb7VXqjKe+f1qSSVY3Qlw3mcZ7j60wP/S/ii8+7inVSrYIwhz0GODg043cxeJJJWP J+YcY9eleild2PPJTeIvlxMTgNlccbvrReSPPF8rbZnbKvt4wOMY/KtVBJagYgge3YqWCyS8sQc1 oW1uCShVGmdss/VVrEzn2LM9s8jxx79rQH5T0yD1pqwszGNo2cRnOFGXHv8ASghu5//T/ih3m3YL 0EpwSeq/Wq8kjEj96Cu/aqj+Ieor0Dy6a1uasFlDctHcAlT/AKti33Vx3FXbq2it0ZEkRiR94c5o NofEjMtkKqSVWeIsVZkHEXsasN5cY3FFAAwjAbmH41nOX2TYgP22OKWW5V1iicFFzl3B6Fvarbai Lu0S0tIBHPFJgz4K+arY6+v4VmB//9T+LSd3gLjH+oQb2Iyo96qwzZSGfyxKTL+82EZUeuP89a6D maurEt2fMYSY2wk4Abhj+FVIJVSaTciGBj8it1jx15/xoMWmlcvTXkU0aMuPLh+UbFAYc1Qjlt3k KOsgYqTAEHU+9WoNiLatLG8Ue9hFjcOOWPpUkM8pWJ0YEmQkgDCrg9DTdPsB/9X+MLUJbi4gEoig jeA4zuwZc+2c9qw7V2aR2uGOV6Rg4RfoK7PZnDGNx15dO7JkMccDA9KnhfzEbzEJ2c7sYp8tpKwm raMifcshdduwrnd/FVeCSXc8buvlOf3eT8wolKzsIikiuROpkVY4Aww/3iw9TWsbgNbtLAyho22o qn5SBRzroB//1v4mpRJMQEBaQnJ/rTLqCQRbQnAUMwznBFd6d1dHnjPtm0hd+x9o2KF4Bq4mZEQS psJbJfP3vemJJLRFyKG4UblkyobH0qOYqm8oC7KNzt2FS4pg1dWY2Fopo3WQ7DnKHFU3Z7eT95uE ZOArcA+9HLHaxko+9ys//9f+Kaa0muYvtESJI8eAArjOPf6VQkk3MqeWC6rg56Ka65RSWh51kjQs rVpNsoYrKDgJ0C+9aJhbHkkDceTxmlKPKTPaxQkSa1WURRiXncR6AelY/lCeS3u54SY2JRlB+7t/ vCiL5WZE1pMloXV1Ig8zEbMMbPar08phkTBjklkTzIVRg6gYzzj+VJu7ubrY/9D+Ja2iRrlLpbm4 a5eTc8AmIhTb0bGcdzxXZHVnuIVV3JeAbQNoAbHtXQeeYzRx38xaV/3isCoX5c1Nq2jT2cUgDOWc I6gcFcgE0FwetjFlheC3Ry+ySZwg5w7H09qotHJJmNnLMOCPvAH86ibsrGpsWsS6eytdHEcihdzf wfUfjSzKks4jKho2fcjhfmrPpYD/0f4pLiB5HEal5BGfuFcjisxzcBnCoQV4HHSmznH291cW6NKU 3ojANnjGa3FupIYFKsFy4dUY4GTSAy79ppMhQHVuGKHAU1iXC3Uca8GVeFwOqduRQBpW4ggjjLoq SAj94n8X1rca4cqUEp2zYyzAO4x70Cbsrn//0v4tJZUfaZFSWWKMCPIyxwO/vVXejgIEDNI371eF K1i4tM5x91ZJKvmDYhhG4Z5rG0/m4meWeYMedo+4+DwMVrZWsgNIW9yHa4jCpI67VB/qfwqv9n8z 5WY8nDbOrH0FMCCELC7oilmXgBvvDt0qjLb3JvNzOBZkZO3mUGgcXZn/0/4kvNmbEcOURed0o+Yj vxTZo2mw0Y2/N8x7sKDB7lRkZFcAOAP4yMYp8Vldyxltx81lOwk447ZoBaMYpha1WG6ciVJvkUKS nfk+9advAI4wxTKFiqyDkEgDI/DI/Og3KcimeUwfOBJkttHy8etWYY3hKu4JWIbEGOMCgD//1P4n bQpdSTfaDJ9nZf8AVxjDEjkDr0rIuJY1vAlo80IzsG/KMfUfT/Cg2io9DT2AoAsjGdztHG3P1qNW Z1aN1ZdowQrZGfWs+ezZRmvExmhQsJUd/LHHzIavxae0XnRDeh6q5bOPxrMBqSiRSJnB8rKEM3AI qUzJ5KiXdHEDsVVH6/pQB//V/iOed0hBhtIZpd+xTI+1gpx8w+laumTojKHjEhHzFWO4Z7iuc35k jpdR17Qr3TjayabJYX0RD293avvhugMBlkVvu98Y9K5eAwyLLLG5d4lzjqV98VLjfcL+7dGTcy3Z JCHYR0EafM/rS2kSmOYrNKjoN0asMknv9KjkZi3d3NuEvOixO5UNguzDgGq11OIQ0cZHoO5OKlqz sNOyZ//W/iQsZJZWALIriTCuTtGPeoL+S4SSTkuCdgcnKow9PwrkgmtwJLaMgwrO7/viC5xk471F dw3AkaJAPJV/3ewAY9PzqwLyrNbw28gYSyyEq8OcFB2z6V0Bzd20aAJGzIBsY4VSOvP9a3TtG7A5 46fJFdTBWhRlj3MzyBQQPQn+lQwSxKX3yDrg54B+lZud1Y0SvHQ//9f+Iu6vJSzrEgTywCrOOCB7 VlyzPPdq6qsZk/gU9a5wNOW6e3jBcq424aLORj3rNL72jeAIkR6jOQp+lAFl45xMg3Qb3ACEMNrf U9PrVG4a42yRriN1zhlGcHvig2glbQt2V8zW5s9zM+B5kr8PU39npbXCeVLuE0fmBoxwT3B9xj9K Cj//0P4ibuI+QpUnzCMrnjzPWrljcxQwj7VEJIxCQEBIZSR1I9j/ACqYu61Og1LJ0kjDklY9px8v 7w8dMVVtx54eeIeVJ5hLo3UkHGcfgKu+lhSV1YvxySLPHO0IMRZUZEUlc5xn8a+mPgHY3C+I9Oge VrjT7u/la5MwLC3B2bSAPu4LKBn1NfVcE0nW4mwlJdZr8D4jxCq+x4NxtR9IM/cH4Q6GNW8SeCNH aeO3ma6W0ZpSXmjiJY7gTwD8w6dgK/uv/Yx06XS/hN4eJjC239lW8aLJFiZo1QqCG6/NhTX9LfSS fJw1ltHs/wBD8N+ijHnxWa4rv/mf/9H9zv8Agrh4pvtK+Gervpe17rSrWC/jW7BSzW2aRYZY5D2y HGOeS1fx1fF7WJr/AEXU9V0uysrSeSzW+ks7JtsdoC6RtswMAkknjsc1/ob9HiiqPAXtXvJv8D+F /H6s8T4kU8M/hik/v/4ZH8/vx21STUfFeqNFpkNqE1BoZnWQtcybUTaWB54yVwTn2ryHSQjAiUFf mxhuhx2r+O/Fev7XjnHSX85/XvA0XS4WwkL/AGEd3ZahLNK6nb9mgjEQfuhHAA7dP5VN51vayQmN 5JSs+8oV80MT0GPTnpX5jXd0fYJ2hc3Ed7Uv5irskG7kfu/WrN0Wt4ojC0bRXA3C2ztAb/GuGbsr FxfVH//S/jHl0jUIYFvUhjeM43YlCyA9cbetWbSI3Vzbq29csD54GVixzzXhT3sdLk3udL9svmuG jui180aiOEk5QKOBge2Ktbfs2oWuqiSRJIo/JEZXKMDngisKnQOZ2sZ1zNDuVSkcf2u5PC8bjjJJ HrgfpWhbwRJEixKHQnOVHT61nYXkSfYLXZNIqLBNnfvA+ZzRpV3eW86QR3k0cTyEXBU5cqemM+me KiaVrgf/0/5I9RVru8tgG82KKIRR3DjLHPXPpzjP0rnNTe0s5WC3bxXEDeVdxQvuifHQlhwevavj mk2ayacTVtcMm4OuOAFzlh7muss9Oj1KTyrWeKWaGLzJYw2JSMZ4FZSjyibvA9F8KxWcZUS3dzav aKz5gQvPIzqY0VPxdT7Edq/vX/4I4eB7fQ/gn4Ku7WF4HOhqJ2uxgzOFCyuB2JkYce1fnHiBNKNC j3lf7rf5mFWHPyX6O/5o/ee12xuAvLKoBParpliaQ5B9CR2rwqS5acfQ9JXa1P/U/lG+In2fUfFk 9pI8VnPY3kkizWMonhuA2WdCccAEkH3Ge9eU65pl0ssltDJbXbvIu2USCSHHb5xnacevSvicsd8D Tfkca2ZhaRbXMtkEbdFdi5kWTy8umFYgfMe2O1XZtJdrlZZDvWBckYxknofwr1bLYiT0TOe1Ke9j hNvb3MlrPKTFc3Nu+x0XP8Oc9Rxz71YhvJvs8Ud1cPdukYgE00nmSbF6D2+gpx6GM9y2ftdz9nTQ ZbVdRMpAWeQoIQozvH+0McfSq+lPqNpfXD3tyZ7gvw+AJOcZLfU10LyIP//V/jPaaKfUL1p7WQ3M iojXqxlvMznGT6r6/wCFQ3kl+PsVrPcRR2QmZfK/idOzezZ/rXjnjlw2MNtLC0Lxl5OHH3iqn+Kl njlZHjEnliGQFijZRwDyD68VcHZ2Gm1oig9ylwkMC26uEl3JKwww7H6jjipJpm0hmeS0u76NMPmE AyKM5KHJz9PpW8PiQjWgv01C9uL7Trq6j04xCGKzuUVbiKTgkk47cgfhWjPeTWwYahHdBwyxFmG6 QkYBZunt0roh8SOg/9b+Qe1v9Lt2a2KBmvomQjy95IwDuz2PTFaGmQPEsr26/bgIWWJbtd+AMkqA O3Wt6eiR5kX7zR5D4mmeCN4yDEGRpdm0iHP8IH45rxcQMjtcykoHkwijjcB6V6VF6pg3aWp99fsl +Lbi51e50i6t3VJb1L9LnyxJbTNEiqgB/gcEkYPbB7V/Rx8Fdcaz8e/D3WE1IrbadrtlYXflxhI5 YXKRyNj3wT+Jr+6fCN/WPDarCX8sl+Z/InHHNhfFvD1obucHfztE/un/AGaNRil+G2kmFol2Qqgd SX+0KFAXrz8uMV+Wv/BXLw1q958Or6a0ZJPtNqbqK/mhDrB9mlEzrz0IXOM9CRX8i8NVPqfiXTqv pV/9uP668T8N9c4IrUe9Nfkf/9f5A1zTblGAguftk0ESzNEwC7mOctn3IrFudN1RbOe6kBKxRhpJ OiK7ZwoUeuD+Vf7H4bWnH0P8esf71WfqU/s8y6VbpfxxyXNrObyGYqcQAghkKnqMfkc4rBuyfLS6 vLi3ZLyUpawWMWwxHOfmUdOvB46da7IJM8aXxMWS5nvlTfvmS3GNhHzgD0q/9jt2tXtp43itJQGu 4/8AlsBkNyM9sZxmuiC1M5fCzn9XuLGwKG0u/MskjLQw+X5bqo45XpnGOFOK6y1vLa8tLFriNFmj iH2fy12Ssvbd3weP0rUxP//Q+J2FzcRNdWunE3NuCGtYZdgvFXuX7cZP4Vw9y11qlteTxGf7Tp6F haS5kGCQAFbuc+nYfSv9roxsj/FGaszYhsblo9MtvtKNeR2ypdRozKkZY7zuGMHkn6YqvdT30TyW 1w83lQsGlEHyq2w4AB/DH41RNjTmtYdXs4NURkWSMiFSsggJRAAARxnHXn361FYW14ZbuX91eWFk UvrY2sub6ILgOshHBXIBzzxntWkF1MZK0jooLaS8kGpRPapsR38vzPKkGV5BJ9QMY61j3k73UMVs kgjhnJF1HGxPnDPCk916mtDni9Uf/9H4bYok0EO9ooAwhkCpiGSM/KRgjp0/KoBpbCWSOBGOmJ8q ztwi88J+QJHsK/24P8RVJPQ2U0s2ltPc2qeXbSQ/PN5ocSrnG3H15qGGzsp7eN97GYsflBGGHT69 v1NaQj1Im9bFe3v5rR73Trd5vLtcPIjxlpI88r8xHfrjNWrBBeytd3BYYXbHPnG0gcj/AOt71oQ1 dWCxvL+GSbyg0twS9uPPiDoyMMZXPTvz2pLTRtDuzLqepPc6VcWPmXF2z3IkkugAAEjjPTOeBTju c7XRn//S+O1Szvbc3FrBcm0gQyK8n+tnVRknH4GsSa9+3WsFpaWk9rpsuWjkKZDEcZU4479Pev8A cg/wua0ZQSxlSNmtozJFbOIpDI+wngH5eOcA5ra+13FjBHJaQ+ejHAClTJDu4J9v/rUGBiyzT6kz 2jxsOnzlyzHPr3pt5pmqssCojiwBy8qJtkDIQQCfQ0Gc0jdS6eW5e9u8+bJGsCGRRHHKV2p14A4H aq94I2ufItYlO1yZpIssko4yQOwHNBySVnY//9P49gtFtZIGRzILxRDaQs48uVyQOew/+vWbfxyx TklPLmjJjdVA+Xnlf0/Sv9yD/BSUb6okiNvcyxRxgoy4MxUHk4Gc8ADJz0p9zHYx/bJpI/IMsis5 jJDDbwAp7dq1hexyVIINO1QWc8N41r9re3BaRG4Rhgjt9fzq1f6hcCzSNLD7BZTDzoIShTIY7iQM DjNWc0lZ2M4TxTW8b6eskEqHy5xIp+UjGSPUHnGKufY4Gi+0CUyEKC25SpB7/wAquCd/Ilq6sf/U +MpLVpVikliZIt/7h2+Xfx2qC9huPKWQWm6CMmMPs7nvn8a/3YP+fqSSSSJdGaKPzIprcSRSgt5z uVkhP91R36/hSLKLO9a3u7hgLktJakrgiLADD8M/rQQWba52QvDEXeDzjJbxDPzlvb1PFaOnm5lu N8lnIEDbXbcE8ojjv/T1qo/EgIryINcXEdxIdqHajRAMO35//XqOK5somkisrcpJxG3msHkJ4y2c dD6VU+xE9rH/1fkE6R5RgmjVxBKWLEvuVSP5DpxUMjeXb3MUCgTStyzL5gABB49Ogr/d+Pwo/wCe 5xuQ20c7yopPzBCWkMoWHGM4IJ69f5Voo8TP5Q2I5GFUNtUn8aYox5UQacZ7WWc3PleazYKYDbAD wM/hST3bT3DQbJFH+s8wKCg5x17UGcviZPJLaWUsBMvnPMwT7MyZjPB5JqcRTec39n/JIybnUR52 AZPHpwKaaT1JR//W+OZo5PI2xXc0V0s4LtH9148/MN3UGldEWJ5ZhJ5YU7ZNhO89h+fFf7zRlzH/ AD0ySTshdNLwSvJNueG5jMMkAIR5FLK3BIOCCo5welTXlxJFaW9jdO0Jd2mUKcoUBwCwHcfyqkr6 EPZi6dbxSnzsLLEf3UZ3gbmIOPy4NOuIpWjI2jCNyVpvdkK3LqUZ7a1Vo7i3eQSxjDwnhSfX/wDX VqOeTaPKMiSOCpdT93PBGaumYy0if//X+PUurxiLNt5RSGWZm4LDoT7jNX5JhbWq+ePNnGd755ce tf74H/OuZwmRmicIfIlyQynrjgirpRhskjwIsYyfmY0AQshn37+SowG9KqwwusmSwZkUjzHXJiQ8 c+g7UET2sTJNeQ3hiBjZEHyOj71kz6YqBpZFWaV4II5RIEZWLecwyR8oHHHXmgyP/9D5EUSqI3Rc AncpblCR6jvVGaN4pC8swedyXJAA5POMCv8AfA/5zy5p8s1200ISTfFHvdyuEA5B5/D9RU72pt1E 8a7VdtrOB8pb0z603FomWkWXry4MN1DFbQvaubOOGZYVIEpI+83uRjJrPm2rLGTvCoo+0nOGZgck j2xj9a0jHl1MSd5jewyyW7Dy4VwHLAD0wff2qhYw6pcwOboPOkZIE+0tHAo5Cgnp/wDXqlfqB//R +QFClh5b7yp2gjgZrTKNAin5pGcZKr0T61/vwf8AOONDyfvY3iZTgGN+oPrikjjeJPm+VnO75h1F C0Apsr7zIoYuOjDnNXkgku4be6CtHp63AgvGkI8xWCAswX3PT2610CtpoFwbUyMLXdHAzbUL/fP1 rPu7Y2txDILnY0bBwQduxh93BFZ8yasKz5dT/9L5NS8uJknUup3j78wHlKw5BP5dKdZ3EkoCGQTT Mv7x0+6xA5xX+/B/zfiF5Fl2oCRkgjuajshtu51mRsNGSnOFDdsUAXoWncyQqCoKlXbGMD/P8qyi rwzFB8/PrkUBsaCW6sw3uBIRkqegFSRxkM4jYMqZ3MOAaCXK2h//0/lV380CMAEg8t3qpcxsmERN xY4BHXNf78H/ADcyd2XIX8tCtxH88I24kH3u2B/9f0pZLiOFAcKoHzOMfNQSW7a+hkjKxb89mY8f gKYYnuXc3TmRAoVcNyAO1dCAR9UgEElrEgjiB2ybxhsrwpB9uapCzliMSzj5LgiRLgEMACT05xx6 deKAP//U+UZY7eOd/IkaUBtsbkbSwHfGau/JcLEn3dhy/Ymv+gA/5tyDUjEnkiEzcHEgVsK3P8uB TjMXtjFEgzj5voOtAFBUB2FsxDOCOqtVi4WQ7Yydqrzjp+NAE1vEjQuNwG08EdzTVnkEEkexdobl 9vzjHbNAH//V+SY7eRid0WxZASp/vjp/jWhYpd2JkaJ2VZkMZU8oR9Py/Kv9/ZKXQ/5tJxb1Q25d 2BkOEfhSq8KPoKh/s+KdV8yQk43fKSCPas3e+pla2hbJkhhhhiAMQcFlztIHT+lXJLuKaJoYzsXf 8yKfugdMn8aQEBmhTEZTDJwzghlbrUCT28wuLeSV0kKYi2jcGPofSgD/1vlODekrW+0sqrnc33Rn ipUjLTwWzYKSuEkOcKoPHNf79c0j/mvLU1u322ezsFWaysiU+1FwiyKpxlR3pLr7JbxxPDIxkLFW XbwT/TvWkZXQDILpQfOeXYyjYuWwq/0/GomKwsyNIHkdvMzuDKenSqNaexYumCmNhJuV17D7p9Kr oFcOsb/Mq+YykdQOSf50Fn//1/ktYEumc7QVH93nOKYqum92kZFTlQecYziv+gA/5twj+e6a6Zne Sc+YzSHeGOB1z61cFvGH8wSbWK5xjAQ0AJGCqyl8P5knmPIw+YnAHX8BU9te7XMbKQgUlWXAFAEc 0scm+RP4eG4pkNyp2BOFxySKAP/Q+V5CwljupJV8hB5ZQIPmJPHPX1/OklC3LkLwp4HvX/QAf825 GCsTFJt+YzsZB8p9MVHcJAzo0G+OPO4q7bj79qLASKscqOBuDKPlPqaobnARUJLZw2TVONlcC2y7 PL3BlcjgmoJYJsEiVFHVCRkCpA//0fkHLxoXkMZAOCynBP4Vc+0SzooS3aOKEYdy2dxHt781/wBA B/zbjluwIeYpV3/vGkY4VBwANuM9zzmjCOyMrBWHIZjgetAELXEhLcMAv3nQbtmO9TLf2QRZLl2j VHxLJKuzA4GcmgBZb0QRSyE5U8qR2FVBdgxwy8+U6hlYcZz0P8qAP//S+SZZXu1RJiSFYFWzk8Gn vvimCxviLbtcDjP+cV/0AH/NuV5ncMY9wJxkEdKuYja0A3jeE4PUk0AUFeeOIgnLZ7DFX7N2CtsL Bv4+eRUcvKmATypIymRmAQ/KE+UnHrUnmCRGIYHaP4hWVgP/0/k4+VtiDZdc5ds7cewqGCSaCWcN uEW7CA9cV/vwf824MpdmkVyAw5HpUReYEAJ+6Xsf8+1BUVdjSgMkbM5U5wEz1zxV+3svtcvkqNwA MuR/sAt/Sg2MxrmWS4kEkRhLOSEPb0p3mJECZDxWkXG1mFuh/9T41zbRu9yRJK7LsSNRkj8Ksu8e zAiClRgtzuOfWv8AoAsf84sY8pA+35BsDEj7392pS48vZGoaVyFUSPsUk+9JpPcoupFEixfaJIyO rLG4kKkcEVWkZbg+UibU6q7Hay9eKdgKz2gPPmfMOMUu3Yg3OCO3PFZvSYH/1fjpA0qjDx4ViWIG 0CmeZMjsExIhG12U8KDkf4V/v7KVtj/nHLKW8ElpaW10oLQyMRKoAkdScjce5HqaZIgt3li5cEHy HK4Vveoc2zSn1K6IP48SN3wOhq8olZQoGEHUHoKkc3YjuXZIJADCrIhKm5XdD06kc/hX4xftcIqe J5kncy3sk1xI86ZNu+9o2HA+gxX5T40Xfh/j4r+R/kz+ifoxW/4iXh35f+3RP//W/io1CCO425jY uHwRjpThHGmxDgcZKk8r71+hVfikfOw+BEFx+7CsRhRnG3v9aoSSpKYiGCSgge5+lcpQiXEu54wC CrfKT37YqcTSp++nfzZDkGPPCY7Cue1tAKbyRzQtJEnK/wAGc4IqiPP2iVPowxnA+lFtbjTcdj// 1/4lkZPK/wBNSQRYHEI3M3IqDEccj/ZHkjV1+aInAK+lfUWtoeMnfYkhnaORViJicfdb+7nitGQp bmLy3laV/vuBhQfrQMpzCTP2gklojnH97HrVWS6i5zEEMjZIHPPaommA61uWieVADnghPatVbhon EkMjRyKAVPQVkB//0P4ppgZnWcqgdmDShRtB9/0pl0oKtHH88h/iBwVr6A8cbY2McOxrlVuEbJML nC/iatySF0ZYiFUcAEcD6UARQwSynZIx2sMA43YqSWzOPm3bUXKqy/KwFAFVZY41m3IUdl2Iw4Ge mKYkxCOY1xIFxkfxHHBNAH//0f4oI33QsS4M4++OhH0qqFEhVdrCQtgkdDX0B5MEm9S/JpqSxpuA SRW+YjAJHrxSro4QAggKq5DA81E9g5HexRmuVMv2dVPynBZhWp9mjhjBllGdm8onXFZD5GZDyAyK LYAszfxccVPeSzNEjMWOzh+MnAoK5FY//9L+J+3ljigDYIeU4Vf757Yq26faYlR02BDl8969A85K ysVhCFeJYMnYSWY8n8aknI8toycuTwTxirhuMdZrGqSi73RHZiOQHIfn0qGcRxkMrFmJ2gE5B9xS k7sCONxb+YQkalscHqfwqSF/PeS4mjVE4RVU8KPXFTsbpWP/0/4sfPC7d+1oouUIqrJfrHvaGMgu 24nvJnqf6V7ByT2IHuVYurL+6jTe4J+Zu+Khgmzx5WxG5JJ5UVE9jIlu5o41SLaSXICHB/Sp7BbW ESSaiyG3yG2OOSew/OsgNnzI7WWdrdQrPDwzNhlHt7Hp+NY9zNGuxmcM5PO3rnvQB//U/iZAe6l2 28G+QnCog5PvVy4trmNhA2egIBXDE16B5v2xySosChlZZ0lKlWxt4/r1/Omw4XJEjeY7k8dRnmgo 3oUKRhXzIrdwP1p0zWqokIihwpLebn94x/lxVxeuoHPSxCaYeYOhOzsSKrm2RrpE2hh/AZDsVD05 P+etVN20Qm7bn//V/ihhglS5MzvvIGxcnOfatK8ig2RyoiIRgFV/i98V6Md0ebzO10jNIgYpJJnK H5VxjNQTXYTM0W58dI2PA+lbk80mm7DkeOcwSsAgAy4POPStT7TDGm6GKPcRh5MctUNWuZlGO6Vt jsxMrsQExjbjuaWGaKabLySxSk7QUUkSdcDishxV3Y//1v4p5oeCHXzCPlbtxWYbfaVO0KkOSpPb 2r0W77nmQWhoR3ckNu6K4WNhkknG0+xpisWVWJDKf9r5aluyNY6PUuIvkRC3C7BOd4dPuv8A41LI yQRIrRB2Q5PJy3+cVga8y7ljz2u2SOXJEyBME4GB0H+fSrEehXiTh0KxxCIyAMAoPcAH6UDutj// 1/4qdQuZES4hLZWZQs4I3bgCDx+VVLQLBH5oUNuXMZVsj8a6DllJRHTvLLDliygNxgYNH2TzIY2j yHJ+YOeBVQXvGV9OUl2bI2gYLCSMq/YH1/GpFiWxKShzNJtwkmfnya2ETBjIkaSZEw+dh1Ck+9WN KVUm8h0aSJH/AHpHBOfQ0Af/0P4udcuIre4EdshCqQxLEnjsKjaK2maS5jZYAY1YIxOTwAcfrXoH FB2epVLozbI2HHA3fzq7FDMiNtIdHGBngNUuSjoS3d3IXti0WVUmXPOD8uKkjsrOGJnuCWlMZYoD gJj096ybu7iK8jSRRxIrRlbmM+YBiRkUnjI7dKzzHawTLDbu7JLy+3gI3f8ACkB//9H+KxbF4gs0 LZKncS3Q1QnuDJI0UK8scSbTkA+1dcJW0Z55Tnt/I2OzKC3T1zUyXEkq+QNrsRw3oOlUn7zQFpP3 KEMxXbjABwX9qmklQRyFlwzx4+UVYm7K5BYpGY3ZicqfkQDqatIHv90UsCuF4U5ySc//AKqDFu7u f//S/iyuLq3t7b7DEircMfnw2CB7iuak/wBcFYlEHLNjav513tXVjyLu1i1Z39x5rIm1Yx8sch6c A9c1ZjvnmmMfmzRMcjzAM5x/+qpmtLiGi/xK0LvnYcIT0b/PpUbgzrOkTFDIMMP4QayAp71K+XIu 8RphmI+XjjI/z3qowdpUkhYkD7g+oqZS5TeOyP/T/iatYIoEDZ2ynjd3b2FKztE6Sks7L8jIvyBx 7im3dnnlyJ2hIcooDjOT972qS0upMTRy3Mtz5bkhXbd5WeQB+tLYadncckolmkEsSshA8vzOAh9R WZdMtpMvlr5chbe2AMH/AGv0pt3dza6Kct9c3EqOjLKpwjIVwoHc/WrcF08ly8LsISFHkqBzwOSD SHdPY//U/jMsza+X5zBi0CfvCwB/X3rMlKXLPPHB+7OWKhcNx6irt7lznM1rWO4RnUOknWOJk2qf cjrVa7tzcSRvKN5iAzGCQhI4zioAqi0eHzGjdiHJJXOVX2qK2kMwkVtySx5ARxgn0NAEFxuTCBc5 5ck4GfQVoxSEwbiN2DgN6e1BM/hP/9X+J1JJEl3/AHXTlc/4VE05iXfIxklZ8sxGKDihK2hSe8la VolkZd4yqZ+UetLamXzgzrvwcDHFBqal9dyBVMTjeEw0X8I+vvS2jP8AZQJX2nG+E4wUP1oAred9 ndJZgr3BY+ZheJQfQ1oR21zqCTGzQtNj91AF+XHOcn1x/Wpk7ID/1v4nPslyu9XjkklHyBFX759K GglSByVIeIDOOdnTrWanpqc5DalzM8TI0sZj37sDC47Gr7XbvD5YjYqq7AVHyoBVpp7AYV1CDGWJ zs9BzUdnNKskcLSSCA5KpztJI5P1/wAKLq9jWF7HSQGCGORiplZvlTb98H1qaOS3njDHhUByvRlI 46Uyz//X/iWubtreE+SgyG4bpisUzz6hcefJGCIkHzKMMTjH9KBptPQ1fKm8lJAxVkXPIwzVLbMI 0hlO9JEl805Pfpg+1YtatFc7JlnDXBaOJPnOXlUAAetQXWrJaxFBGkiF+Zd2ZPoBUjU+jMa2ZXle UoRE7blz0z6mtTZFI5FxIVGPlUDK9OtA5OzR/9D+ImW5jiCqM7efmccH6VLYHb5siCTDcjcenuK5 xvV3Irl3ZcK29g3THan2t41oJT5KAuu0ueG+lBrD4UNmuI5GikWRo4z/AKzkbjjqBUdyEiuvOsxO bXOFLnr9ccUEuNnckOpSCPg7lA+4o+ZzUEXmKvnSxlSx3IGOetJoIwTR/9H+IFJroSx7IV2ebgqV O5j7Vrz3MP7mG6g2724ZvlKEdx61zlqPvWZnuZmLKkh2q37sgYIFSLDMjeWsoeQ/vFwOuOTnNApK zC4nkjQzTMC5b5lU8nNXrWF7lPMEqptQuIncKxA5OM1bknFIVtLmbfyQuUWaQxMx2BGxhvqaF23M RZo42SI7QYhtGB0zioNIqx//0v4lWjQSQx3MbRG4hAtlC7zJnjkdhwetZ97YNbZnZ4yobYibsSqf TFc4FGOynupkfcGhkO1wOWTHtWs9pa2223VgPl34xjgcUAPiWzkngzh47f53TpkZ5x+VWtTFrcZl sIY4Vx8kAbJwOOc/55oKUmlZGBZRb2f5Ss2QDGB1/Gtx7dLcKU35bq4GAp9BQVzn/9P+JBrd55Xh ljYGGMMRu5KnoR+tVrkmN91rEzjGxQ3TPvUQWhspXV2allBdTFZc/ZXhxLCjN8pI9T0/Co3aeFp5 Qd8pYHYc7Tzz0+tWUb0d/HNi2gh8limWIJdWI5J9v/r19e/sy/ZIry1uhEJzc37Ws0zR+Y0r5iVX Cf7LlR8vp9K+38PIt8W4Nr+dH534ozUeCccn/K/zP3K/Z6sbZ/GPw8hlgSS4XxLbQMb3MUcbFgCp HXewzgHuDX94P7NenPZ/Dfw9BOpTytNjtLlQcxQFEUpt9sNmv3/6TFTly3LaD3/4H/BPyT6KVLlw eZ1bbtH/1P1g/wCCyviCzh8F6rp2panMiaiI7O6ijPMax3cTwKQOfmMb8e4r+TP4u3ZtPA+pXVoL nS1kR9PnQ26ul1b7vMiyeSCTHnjnC1/oz4GU/Y+HNOaVvi/U/hLxgtX8VuR6/Cvx2+R+CvxWhnj8 Q3UyQI0d3N9qikZ8POrfKSR/eyn615hBhANyFZWzuUcqv41/DniPW9pxljpX+2z+zeFocmQYaC6R RraarLyC3lu2XXJ5rpLeG5DPJ9mP2cn5HyN4/Wvz+rK59AdP/rIIreVFjFwNoaQ5THoTViC3tTg3 U8UskDAfZ+oUAcMPyrknvYpSa0R//9X+Ml5j9oaSGd2jddrQs2QuO61s6fMscX7htwXmaKTqp9R6 V4MviY229yzZ3lvLJL5TbzBzKyNkRex/OtRb4MFKI0sbjLIw2tke1ZTWhrDYzRHE6vMFQSmQt85+ 6D1ArctmKWiJHEGkc/ICOGOec1kUNnuUbMTGJTGAGwQXB9KW0SOSbZGFMoX5McM59qGtLGDd2f/W /kQtNVjju30lI5mu3G8SMjG3Vs8rvPGfasldK03T73y7pvJu5JWne3CloCG6EsfftXx4G1HHaW0U tykxZewOMZ6Yx2HNdBpaWEdteXL3DWVw4XcsZKuR3O/sKynuPmtFo9q8LaZq/wDamjalBcaallGH GoCWIh1hIByrdCxOBx1zX+iB/wAExdBOnfA/4bNMGaQeGLaVgxPl3TSrHLvX1yZM4/2DX5bx81LF YSHW7/Q55TbrU4n63x4jXO0A47CoYnRmbPBY46V5ilaEUetHY//X/lH8c2OsaN4jH9oWlnaPePcy LHaDL4Zzt35/iZOo9q4ERwW8N2LdUtzeIJWg2hjA2MZVe3Tt3r4DJqilgKTXY5VrFGVJqbRL9gtL fy7iJg5nul22mGwWJxySag1DVH1BZ9Qt0tlUERXEFivlw2wUBdwTqM4JJ9c17nOiJpHJatYy3EC3 JhHlBw4nD/vAo64HfqPyrPsbKGa3YRzTQyxymZ/NQRJIgA6E9+vH0og9LGbV1Y6PSoGsJZ9SijhY Qxeazy/eRRjn8eB+NZsWoxzXV1qZWNBO24CPOwc5AArpi01Yy5fe5T//0P4voNe1kXMkNlCbxbzM LwNHsBUA5ZcDnaBUMsEkWbi8mF4GISxtA4EoYckDntk1455vJE159SWOBCsCFQVSdS43xDIGQe+K 6K3s7a+EePltYD5reS2TICOQx/E/lTWjFyI569v1tdTSztLGORFwRJKpBk7gAd6ydHgewfxHHqif bbjXSFt5op3iaw2sCmFORkAbeMcemK3i7aoThrYjsT9mvotO1EXdp5rF5ry2TzsAfdz0GTj9a7a5 uxd6rYaU8gMt1bG5imdwXcDAG4epAzXQn1NNj//R/j8sdIjOnrqLTi5le5kt0iJAMITHIPvk8VN9 q1CzSX7HI0ckEeQYmxsyPX+da03dHkpPmPONaLXMJS+ugDK3l7nGdgJycD/CvJp7UPcvCLgyxxSl I327QQDwQO2cV6VGSCXxH2l+yba/2Nf3Iur5LiLUr9byC12rujaF0jLDvwJcH61/QV8L/E0K6rok +nxo90dbs5LozW6p+6aaIMfQZIJz2zX9v+BNb2/AmJot7OUfS+v6n8peLNJ4Pj3AYtLV8r+52/8A bT+7P9jvUIL34VaGHDPJNp0F1byqu5XBXa6/mP1r5e/4KjwNJ8GfEaRQt5C6RcwSbIt5LywMO/fO 0HHQGv5Pw0PZeJyoPf21v/Jj+t+M5+04DnXX/PlP/wAlP//S+W4cy2gS0v0nlkYI8jRgKFJyEHfC 9M+1ZU7Xml69psF1Kl5DGyRz20y/uJ1cp8xA5yByCD3Nf7E4Nv2ML9kf4743/eKi82cx4iubmz1a 9uLWWS80+Sfy7WCH5pHRjjYc9CORj0FNvdMuru0Atngt7i1g82JXjWJnGQTGSPX37ivQT5WeO377 ijEhvkurkRX9sIGciMyRRmNcgYJb646+9bP9k22nvaq0zXcEu6Zoo5dxYEn5Sw7gDp9K6YSJl8Jh /wBlRvfNdfYIriyRme1gnzlBj5VOD6gcdPX0q0tykk0zsLdWl/cu8QCx22G+7gdMc/ga2MT/0/iK 1vr+TS5RbpFtN2LQ3CzeXwDhs8d/6Yqq8LWathgkSP5spDbYyR6n0r/ayDex/is0nozNaWeae7vI WVJLpix8ldqqCc4X0xninwQrNKYZ72S4c8MMBmt+/TNaEOKSdiGTTNXbM1k0MtvFchIxJ8q3AwC+ BnsP1IFW3hOryS2NgILO/tolCyW1sxjlUt911z97P8vpVRbic01qP1KW/tbhoJLZVmuZI7RbW1XA VlQLnaOh+Uk4qutlctIlykU+yCPGF+aJT3OO1a3RzOLR/9T4XeYPayRsjXF3DhpAWCMm48MfQY7C rzzwyWYs57hjEArAIhSLPHJ9x0r/AG4P8PwuLbyhDEt3KbIR/Pbun8ZOQwbPIx7d6zo9OeCRJ9Os 1MizLHJPcXJ8zaW5KDnPrirjO2g3uWbvU7lJbom3BmuJCpmk4ZOT82O+OR+NacNpp6eGyrXjyzTy fajIsmyJCSG2gHnA29Pc1omnsIkuNQlitUu7VBHbMgR7lI/MjDY55x+P41kCRdSmYQyGaO6QNHLI NgkwoyT25weKa02Odvqz/9X4dsn1DT0urebdEJEaFXiOSqEEY9OhqGO5urO3tY47i5Num2OONkG9 VBHHTjPQ8d6/3FU09z/C2TSVi1q2o3NrYG3FjIjXp3GWK3ZuQQc7uik8CpdkdpZ6W0MsRu7y3aaW ISAyRMrsCjDpnAB465q/IwbtuT6dJ5dyjtZphYSv2lDycnOGX15Iz6AfWrp17zomit4tjlyjGVdp XHHQ0GUndlg392NNfTJLS0mjdvNWeS3EkqHj7jHp06VTs7O5lP8Ao0Kl40xGHI8yXj5sn/OK0vGy TOa5/9b43vNOksvKvLgEKsgk2A/JEwwcD8RTreyvroubgW8RncPaQtNtkuARnOTwBX+5toH+C5ir JceZcQxjDQHEqKcINpxknp3xn3rSiguZ7WR5Nnk5xsZh82PrV2sclRlCKa7EgFtahBJmKdA4ZEjA 6nPPJUcDvViUBYyWRslud+TnGBQvM5Z7lrSXu55jFbRxLBEnmymVQFzwBz1/D3rcmltQ+JYSrou9 hECyNjtgf4V0LyIP/9f41137Zq9/YSS3FlDZadbFrG3022Fq5aQD/XAAEsNuBnOO3Wmz3eo3EMSy XSiCDMZiCqmc9yByenU5r/dg/wCfqo23qVNPe3s55rm+aRkkYeUAPkjIwOR6d66O3ihkW8m1h7TE cRNpcqFmaRDjbj0/D07UEDZZ7GCG1kttszeXnzFHl7B24/P8qyxrymWXZKXVzhlUHCt3yPWqjpJC bSJ45xIokdgI5MgA/wCf51Ue1VLkSCbO0h88DIHOD/KqmtTBvuf/0PkKxu2lhWaf9wLlzssVYswI +9zjBA6VRuLmSBj5RZlMm3ay8gE96/3eirI/57VJPYtQPbRQ3dzdSiMswMMajjPAIA7VsaJHY6jb 3TiGN41AhF5uI8hyc8c4J4xiqKKd5b6dbzNHaXovGUBbghCjQPgEqc/Ucj39KhdokjBjRpMKOQvJ z6UGDd2ULmK5j8m+tRG0izDy4nG8Ag5wR3HHSt+1vZrjTLhZZViuZAY5pAojmkJOcAenr9KBH//R +Om8uJCqP82CH9DViC5Els0G3JI2RZ5GTnjFf7xQ+I/55xtvaLZu02osUZl2xRxtl42yeCK27E6e JJBMI5lZcq8yhmX8+nWtjOb6HO6gsNu0osw6Wsku6MDKjtnH45/OqyC4MamOVlJboe/1oMy/Hbjc 80hGFxvUd+3A/wA9addbLVmU5SFk3oyngfWtoLQym+h//9L4tSeSSOWaBwyEcSEfL14P51fuZWn+ dYlCmBFaIH7xVQpI+pGfxr/fA/51yfRUhhhuYri0iCzF2iBGXhJIOQe3K9PT8ailSSKUbZRsLZ25 6CgC3FLFsuZOWAO1VZdv1P8AL161XRizy3MZWWK5tzBLADhGGOAfxwfwFFhON0ZkYaytIl/1DRqY VT77uOcEk56AVNbxXf2SPUCqXluZzCXkbaoIxnAHUjI/OgykrOyP/9P5Ehn3RrC2NyZY5OCR1pJL CSYNOqnBAwcZC+hr/fKCuz/nPIpobjfk3DxPKcyuAB5n1/T8qmZLpLJ4vNZofMDKuc7G+6CPzrVt R3Jl8LJozPGivLcm4mKgSOw56YpxnMirEIVduS8gzn+dMxKYiKCWNWIbO+ODkCQ96vRPcx272Us7 RW0rLNPEvAYocg5/KgD/1PjyJ1Fwptz0fOzA+b1rZmuBEfvrjgc8ZJ4x+df78H/OOVjJclwFUkx/ O4K8ge/6fnVeS4uZbkI0Uku5S5ZVz5eMdfb3oAvWd66JKjRrlvull5Ug5yKz5YbiKSQtJII5XErJ ng9+nv8A1qlJpWAvWRJHyr5h342gZP4VeItzIJJYDI8bcwngtjqPY1Insf/V+VHt0kKGVGSMyZZE O3ODVFoo7Sd5YyyxZIWIH5FFf78H/N+WIrq3aaIgOBGS8mDzJ22+1XY5TJ5oWCNV8zzA+P3p4Ixn 0/woAimuruOa0uLSRGXeVuEliBPA6H1B/kKyxOVmKFQCGyTQYNt7l5Zo5ZXaNTsUhWLHnNWyDHKw IDog/gPBOKBep//W+Vre1IjlJYooUyZ6NwCQB/nvTIfKms2eRm3O+YT/AHVwa/34P+bcdHJGIizB maN/LKkd6liijnkYBo4pGGXdzhBgdDQBUhgcyKkTDLyhB0wTkDFOuLfUbS6ninzGySYC9j9P1raH wgZ80dwJUk8vzWJ+ZRg4+o/CrixeZJsMrA43lCfu/QVQH//X+Ulto7dvMXzppGbKRrgjOOgHvj1q 2Un/AHM0lo8EpGWgYj5R0ycHH5V/0AH/ADbkcwIlVJV2oSGAHXB5p0iwxxmRQ0UW/aGYcc9OaAG/ ZMLDM91AIZdxjAbdIpX+FlHIJ4x9ageJpZprqSeZS0KxRw4DIMABueDzigCKAR/JEiSLhzJOwO4H nrjt/wDXrVFkZYnaJ0WJn4JOTgUAf//Q+XJfIifyoZzM8IG4AEBfanrPH8pdtjYOARwcV/0AH/Nu U5rhJScYypwAKgHnAnadvHPtWUmrmD3ZLarM6liHZA5UFujY61oXCQzxmISCBkAZTGm0kjse5H1q Um9hEQtg0IKsGIbGe/8An/CseS3lW5GXWGQyBQByGGcdaQH/0fmC4T7PGyqAzIdrMe/rzWfFNHOw 4MXkSEo4OHcEY59uvFf78tNaM/5rzRTdFkxv97k46n606SCGOKPCY3MWckcO5OTj8xSAqS2xlRvI QFFP709TnFMjCsnlouNvXdyyn/D2q+d2sdFraDF8x5lgBGxCS2eM1BfAmXy0JTsSvBNaJ3V2B//S +RIro2aSw/Zg6uNokyUdDxyPX8auxFY4cybi7cjPpX+/ykm7I/5txbaISPLIWDfMPLUDAQYAI/Q1 PNbOyHy5QRn5l7iqAFVI0RJyXXIJA6jFRtCNz+UTh8lAT09MmgDNYPAEinlVvNJQhE2hcd6cUit4 Ykj5ReAWOT7c0Af/0/lVI42iG6YBOpBPftSKYWbbA7Fo+uVIwR6etf8AQAf824vlXNzJPdzjezv+ 8YKBye/HHbtUcdlvLMXPB4z0FNO2wEyJLKGh3xwkLhZjkKcDjOPXGPxqG2gijgZpZAblG+ZQMfiD Wy1QErr9ohM0sqAwj92jnBZR6H8uKqyGOR4yVaNAflUnO761LgugH//U+S3lihlYiINE33Qfm29+ Ks+aZYWliTbGjhG44yQcfyP5V/0AH/NuQTuvlKrjBUZzjgiqttHHcMsbuqLvypfgD0oA0900JeCB UIPEhA3BgO/6VTkgNxuWRYpVcgOkiBlwMdvyoA0Y7aInyzCilY9gwOMew7Vl30HSJGG0cBemzHag D//V+Tre2ykfzDC/eB4xjvUV6Y43CmQbz2XnH1r/AKAHof8ANwld2Jbe3jliaQsMqdvzd/pUJxHL syCuMlVORQaqESeRojIhRSQeGB7VZluYo02RAKSOO2aCfZ66GYA0ilpFPmZ9MAfhUazSWcrCRQ0c o2gEH5T61E9hcjP/1vkKNy7sclUV8IWGA34VqXFyLVoTLAzi5yquyHYOPX+Vf78H/Ny4tOwhMUay AIJDKm1Bkr5ZPQ/hWPC95JdLbD50Rvnz91R35/D9KDSKaRZENpJJM3nnzIX2bAuQ3vnPHbj3qF7y 4syz2obYRtKocHng59utBRJOTKiTzeWrH5QowJDwOv51XzG4+fIz8o3DBoKgrs//1/jZpIYX2HGU HB7VWS8eaWSFwMFt4YLt49K/37g9bH/OOSyRyRxqzkAnoAc0zyJpUEsqYQN+74xux1I/GtLq9gJ4 JEtMubcuyyBgBgqOeSQeDSfaBLO7wZy53yjGApPoO1MCTZJI5K5wRhsGmCGMs1vJGxCkMD2z1z+l S2rpAf/Q+NLr/R1KhGCjnainc2fYVUgYtuRRsUncVPBODmv9/pK6P+ccvM7fIM4I4+lTTpII4yzE gHjJ4XP/AOr9KxKjLlM+3nhhmZJ433EgqQMK3v71vB42UtHI2TjC7eP89KAlK5We6gEEouViUchp JF3oF5zxX4+ftf3z6l4puhDDBsy8MtyIhEhCGMRkD8G59hX5X4yr/jAscv7j/Jn9E/Rkf/GycP6f +3RP/9H+Lmd2XLFMODk56fWsNg8s7SMwwwCjH61+hV3acj52HwItShZAI0Iyq4bPTj0FYIeASYA5 ByHIwprlKLzADEjdCRvbHQVZ+yxTAXFuf9HZfm3Nh93fg84rB7sBsFrErjYrI4ycAfK4xjn6ZrLu btbV2WEB3fjGMLSI50f/0v4gYbq7kznaATjIGCo9K0LVo4GaQhpiwK4I5FfXcq1ueAm1sWpRDGIL klMkkGMDLJ7Hj8qA+9f9HJIPzN5nasbW0HzSKRZ53aDeRg8nptqE2LwSIELTPtyfQUm7IFJos2yQ RzR3NyjupbBjjOJGPYVoRQy3U/MRt4gC2ZBjd6AVlJ3Zo5JK5//T/jDFlapZSzNPGrKnEecSZzjg d65mSMgExyEM5w3PWvoDwuZt2Q/y5UyzS+cMhdq9U+v5U6NGibM+AjN+7jz96g1N5ZZ7eKMzWyIJ IfkdMbSD0rKlu+XSSR9m042nle/FAFKEpdbolBAHKnrmmeTPHI/kAxouBIXHD8+tA0rux//U/ian jw+9WYnjcSMYP+FWDeCNsCIMxGNwGNtfQHmxioiW9xGxdVZsM3JJyQe4NTXF5KiRwKrSLISDIoyy +gx6VnNFFMwqSSxIkRdxBX9KeEnkR2chQUKhifnx7VmBWhtmhmR3BKKM5HUitJ5EdP3QyrfK6gde +DWc+wH/1f4lbd4naWViQ8SnykZcbSOlaX2wfZvMcHds+U4wCema9A88zYZpvv8AK7m4YnGRU81x ho08nzJCPmfoEx60AXnlEkCKY0O7AL5+5ikMKBvlChQuQeoB/Gga31My4Sd5V2gNHjJfHy4H+elN kgaSJ5FPlLt+bJwG2jvQbn//1v4koHlmhwhRo1AR8Nh89MYrprPToGh/fFDsIIw3OfQflXqQbehy T2MC/wBiO6tEFZpOgb5SB0/pUlmRKxM4A2/cQnh6c1oZFx5Y9+0lCwGza6ghB7elVVbY7MQsyqMA HkZFZtWAeGmu2ednVFiQ9OXIHbFVljinG5SSynkHqPwpCTuj/9f+I+OcQ3jJETG0ZDEocN9TWws0 t4yyI8aoc+ZI7cjA7fWvQPL/AOXhWkZJgRuIKtgf7VIZULlsqoQYcDvj1oNCaHU5bkOFMihT5akA oGFQRSOJ/LJ4Vizs/OCaALon2E3UskaeQcxqy7hKc/dA/OlN1aXiOWYJvP3OFbPt+VNu+4Wuf//Q /ifig+xyK+7cJHwpLcDNJPOJS6SNhYpOGBwOvrXobHnirsLklwxCABQeAPWnQWiSSPIoBRFwB3z6 4queQFThmeJVGMkH14rStY47m1WEAZDlFk3YLexqQsnuQ+QtsuWi3SiTY2G6j1pLdZluPPiKIImy iAZz6Z+lBC0k0f/R/iptzO25pmBcNk4GARV4tHFB9oljg2klMS9OeBmvQPMi7RRhnLpLE6ALjjjg f5xUDwYVFR180DPlA8D0yKia0LL9vLKoVrtwAo2xx/wR/Sp5p4wjs6Syn+ERjP0rIC1ZxtcIFaEq VwV+bLDHSuvt9cSybybzSZLpUjwqiYxsSRwQe+KAP//S/iovWL3bnywkDt+6Q/Nt9QatHTJp41lS aKCCIcoAFJOfWug88R1tI96LIZiVHUYAOO1UI45I7gs8jeW42qnRBj1rWC0uBoywx3dpslgjk2Sb 43JIfIxx1qjbp+98vZsCrhAfWrA1EcRQPCHVmkbc7lQSMe/aqhufJUiLCfN98UAf/9P+J+6lkmuC GYOioOWPJPp+VPux5uwIwPloHeNTgcf04r0DzxLZllkZFUYk6Ac7cVde5NqhhJZip/4CtYNt7gWL KdZUdkbDJ6ng02Zmmk6rnGGPYD1pDSb2EtIQjM+5WbbtCngMO1N+zNHJM+2Mp/EEI3LnuBQI/9T+ Kt7pkjZM7IgMDPLVVWBYi7qFXI3bi2SfpXSld2OFRbGboZYZlkUTOw2p3xzyVqG2hW1IUMUDnIDD cUzxVrSQ+Rl9YMyFJtrqRuVs7d1PvbVvsyTRr8qNjEfzdPX8qtO5DXRmdbyGVwrYRduDsHJq5JK8 FzbT26NGsXJwx2ZA6kd8/jTMnBrY/9X+JeF4bq4mZ45A+8hpV5wevJpNSt2hjjCfvIY/3ssjfePb nHavQPHsZ/21diblUR4IUKcNx0xTopbtlfYUjDDAJH3c9M0ATXMcVukJcLI64Jw2ACOppZ/PkMcl rOIlVsyKvG4elYNWdgLMbRqmxpFLH/WEjrmqkjKkoiAA4wpXg4/yKymjWMklY//W/iUUNKuAGMn3 EGcAkd810enWNqUT7ZN+8IOTwdv+eKDzVJN2RjapfrEz28CxSYbAb+EL6j3qK0njjRtqhmkOSe+R QUNmczs27IIOR6VTBknkfzzIWjIVcKD5g5GDQBdgsEDhGby1bLiTuhx0xSwFzI8fDBDjcByADQNN p6H/1/4stLtomuJ5Li7dLd1ysWdxdh2H+e1SXM0MblLdsqrYUnjd9RTu7WOPn0K8RaRjI0wBXIwO hq1DDbKrPcOp35EfOCpGecUiG3e5kXF0ltLtQ+YAfmHRQPUmsX7SLmV7gP5fkHhANu705/CguMm3 qSx3VnIAjRl5GYl2Y/IvYACrdurK+xiiRBSyDGNx96CpfCz/0P4h5f3kryeY4AGcpyWI6YqVIZ3i hadSsTS4UHjJoOK6Tt5m/wD2ajGKSV41O3h0AZnGOgrElTyRxJgySeWqrwye9BqVm+1LlZI1Pzck A+Y3ua2XeOSBQ4KLHH3OOgoFdXsZPy3G14Jg6x4BU87fat611GWxjVreJo2jyHmXOHB7fhzWdToM /9H+J+XXi8kiT28r+ZEdjwnZ5TdiT+fH61TjM0iGWKQp5qlZInYseD1Nc5zlm3tQsTSeYfMYc9k9 6mSMQ2cs0lx5abvLOOi56H+daU7/ACGld2MZfJiL4LNj/Wbx97NSCWHCuB+6XgOB849qFfnN0raI trMi+WF3tzuDA9R71PA8M08wKnai78k7dxH0rQD/0v4nJrX7bFKVDRxqwUuo+QH0z+FP0q2trdmS eVpEBwcL8qf40AGp3MEZVI9jM4IXjAbFVYrmOSONCinYPnwM9fWlsAqOGimWDA8oZYEfKRWa1vGB 58sWUL5WMsRt981EY3iAjwbN4hf91IcovUAnsDUcdvPPEyF9joxDE/wik4NAf//T/iDtI3nJgmj8 2CB/nZGwxHtWnM8Uchhh81VaP92CNzHA7/lXOBkq58yVzuRiMBcYz74qBxxtZmmaTpGMll+tBpCS Ssyu0eJUjYFemAOWUfSuhuLbZZN9jb5SgEiOcE46kD1oHzJpo51TJG6nb7fU/Srd5cyt5CBhnALg dRnt/OgcGrJH/9T+H+O8bzdw+Ty/u4Ge1WJrkXMY+1SPKiHK7/lMOeSa5zosXrNxbW7TAq0okHk+ am5CPVhWDLcSfb3uJxuk8wqgjG2JR0OAOBmgiaVjajtbe6JmZlywGEZgCmPQVYmWEeXIpEfkptwO M+pz70Cg0lZmbcYnspJFt455GmCAu+1oh1yB68VFY/aoolS3Q/Mf30fUn0xQW9tD/9X+JGWGVJIL reyyqcNk4KAen0rNu7ee6mMikby27exxmucDb0yNLVPNuWXznOyOMHA+p+vpUt15UyvG4UZ4D9Dj 0oJi3dmHdJ5RSCNSsrEeW6jBIPb/AD61pLaLHAvnrIsvBDsdoB9hQUAITP7nb7xj5n9zVifVJ5Jr eO6RDFCVO1VAZhxjJHfpQFuh/9b+KK9k3K7RDbKTjA9KzoTarNFBcztDEzbpZI08yTceAAKiGxpy tQaLtoJZmuE8xilqx+Zht3LkYI9atLHFvjYzblzgx4zmrLjsdjoVjo1vNey3knkJLAVi88ZKbeSF 9ScV9jfs1eGtMuUjvNK1F55bbWRLbCVl8pWYoxQEY28ovB9a/QfDOHNxdg/8aPy3xdnycD4+38v6 o/ez9lvwvf33xz8I2+paWrWM+vR6zcB5BJA0zCNogh7hQM/VhX9z3wZKW/w10SZ9gae0868jA5R9 oVRj6AV+x/SbxCeLy6hfaP5/8Mj4f6LNB0uG8bWt8UvyX/BP/9f7v/4LE+KbaXVbO1vYFliv/EUF lcI4zJEDFM4O3uMgYPqa/mZ/aE1GDRfCo01r68SeWATfZfs5EUUaCVUZnJwdwk4471/pJ4QRdHw1 pxf8r/I/gvxDq/WfF1O10pLT0lsfgD4715/EWvT3lwdl1ZvJb/ZVP7qEhuRn3wD9TWBYeXcplo18 1G+4Rw3ua/z+42qOrxPjKj6zl+Z/bGRr2eVUYL+VGyoihbySiK7MrKyHAHsP8K1UupYZRAdz7xkL nHQV8hU6HqX0sXxcQy6cVuDKJZwWtYw/+obOCW9AQD+lQWIaTCM2ESIpv6l8ds+tcjfU0U9NT//Q /i7Xy44lMXz+UQJfmy+CeuParL2UFjrV/qFpe3LWF2kUESS/IgO0Z6++R+Hevn5PdkqSehHbWMjz zRWs7xoJN0jxnknP5Gu7uFnjisZWVHMKmJyqfvZs/d3Y645rJzurGsZcuhm3FooH2ydlDxy744D8 oU9M49ea6eymN1ZxzMYo/KJVmQjOfcVKTbK5k00ZaWNrLHcGMPNcKrPu7rk9QfX29qpWz3ETrNFE 4uYTthJJjkJ9cUjI/9H+PWzkvrOdW1SJBPcSiVXlk2Ark9Djk9K1L1Pt1z9qVP3bHAUv9wDjjvXx 4E9jaWts8siDd5uFmXs2OnH412dtZxyjmAvHIm1owuQwNZVVoKWkT6J+E2nR6948+HvhGZbt7PXP E1raP5B87A86MLFs6bSWyT2x3r/R/wD2KfDy6D8PNAsvLmjttK02DSrCNz8hihhWNZPqccgdM1+T ccS5sxwq7OX5IwSviIM/QVEUxLg54qnjMgwAqoeeOTXHFLlSPUgnY//S/mh/aG0qy0v4hxHRRq9y y3d/p+qz3yAxl7efCKUI4x8+CMZzyOlfK+qyLbztsWZJ8lY9y9PZq/NeHXJ5bR5t7HLL3XJdm/zO QudTESuGDyTpkSgoTuJ6Y/xqta6lFZlZLa3AkbDXUIPyTHuG9Qa+iJn0N173S9StWik0i406W2CX KTwTsLV853jYc8L6dORWPr32PUrQTaNA42wCJbhlInfnDuBngnHT2FaU+pmXdMkhjsnt40kJ8tVl a4jKCQY/i/wrOmskeU21tEUFw48sAcbvb6mt4LULH//T/jHsYPLeO5e/uo5tJke3S2jOFxIpVsjr j5j09asyQWouI38m3C2/KYUHryQPTOea8c88ZHplrC0gunZ7S6ky0SYLIp5wPat2w1j+y5zpf9lq 9heYMe1iJpsAgfMBwx/Gmld2AwreWwnF3PFBfWd1uJht7lvNMRU4O5j2wDgCoGkinDtEGaSFszso /wBW2R19Oo/Ot7W0DYfbSQazeSG7NxCkMfkhIlXEzjALsccdD0rrdXsNOa3sZYLUR3tmQkV9uJd0 2kFT2xznit47ITdkf//U/jvUfZYLeOwtpoUjdnmYyef9oZuTgdRySe9aVhJFqMFyjMkEynbMgXa7 +hPt1/KnT6HlxWt2ed+LtMUK88bl1tJAhiHDHeDgj8vwzXjdzcNFclfuKDkr3969Ci7KzJmvePsX 9l5rSHxZYSXEljJaXai0hmnl2yWf2mSPznZQeCPLBGf7lfvh8Mda0qPTdL0xtJlv7hNQt1e6ty8k 96ySxkBz0woCk7TyE9+f7Y+jq+fhbGUX1m//AEmP+R/LnjrH2GfZdiVurfhJv9T+5b/gnp4hs7/4 PeFdKiuPOl0rRo/stz5ZQ3XCSFR7qGH5HHSmf8FDtOh1j4TamlxZNNHcQvHI0ecg9HY+vykf981/ MeZQeH8V25afv7/+TH9T53UjivDN1I6/7P8AlG36H//V+Y7tLPTrlYg80UthJNpMsI27JRGVCydO vGQfVm9axJtP09YrjU55LifU15ed5S9vHEeBhOxyR7V/sPlz58PCa2aR/j3j42xFRdbnHizt76w1 aS4vzZrYKlzEkYJa4lMgAXjkcFiT6fWqaXGqxfabiZTPapEFMoVndewA9en1r01Fs8Jr32WlvY0h trK4hZdwEpDwiSb5urFwOB6KT+dc/rGmxWEMLabqt/M99eGVoJSEt4fuhQnPXluD+ddEIilG6L1i lzYWi2jTO+cA3AJldd3OT3PXpSzWv9nPbRLcpeLe4MyQJhoG+YfNnnAyOR6/jWxmotn/1vhRU0+1 CvNeX8rWuJp7SJFaIlhgPtHzfw9+lSXmsWL6VvfTtRv5451KWNtGGjmDMqAEZ5PJODxx9K/2rgtb n+K5oLZxWO2d9T/seTzELWdxbpsljIy8J3fdY8Va1bTVsLKbWfKkjVAjtbRKI7i+jcYKr65GMdRi tSZL3WcbI81klvJpdvLFZW8q5sZZS8kUbEbiCAM/pV6xuIYrpoBBeReeGxLaTCKSMn7oyQT1oOZx uxtqf7Ple3ead7kkeVNcL5xk3tmQbjyGKg8iuy0rxNpumxypPaAxOdilhiUHnlPr70+VmR//1/hb XtWS6uLY2TXV/ezQuzKtkIS6p91SVHzFQByegqxY7dW0+DEkayJHvKKSy7gcFAcdQc9fSv8AbeKa Vmf4jWS0M+6i1VrpIQbmQRw7IraIFwgycnA7c/rXW+Ftct4Jba1vbeF7m2mKuZFBQc45B6Ee9MXI hmqxwJHcu9vJdaq95mzSKRQsSs2CXJ6jBGAKzLyGLTBdQRQSeReRK0UdzJ5yQNtUMUOBjkMcdgaq C1IlGyKNrdTW0Asbq1uJobyIATQxMYVwMY44XIPB9q2NN0u2gig+zTgywB94llEMcACHaOecjB+p xWyOCZ//0PjiO58+0M+YnUDDyJzGWHB/XNZsniGGytxdXVlFMLXcYoPLyZcAnA9Sfev9wD/Ch7st weJLW/02K9v7c2r+WpWEsGih3AHGeOcnHSmz6dp8djNfhHMwKyxTyP8AJGpPOwe+aDOe1ieyvbf+ z2iXyt8k64c/fweGz7DGR9ao3A05Z/tVwHuLWIFWNsrPE2OMkDnjrVqb6mMk7aG8QXtVltZ4kUQe bAXABRc/xL+f51Ta9WxaINKyujbmaAqwbI6H25rUxSb2P//R+VDqFnqVgbU7HNz8oEowUP8ATmuT trZlunS+nZntSRCGOVQLwFQ+nFf7kH+C4ktpHcyzXe64DIhG9QWUgckbe/PPrzV60nFxbC0uHeOa RAbcMoRFPTa3vjvW0XdHLKN9AsZpFWaz2QPI8u0TId8gC8Fc9uamWyt4rZlnuWaaWYukZUtsHAxn t61Rg4rZhc6csQTynEb4A2htr57HFQWFxHZXMlxctNeeWNrokmWLDoMHIz7VcZNWRlKPKf/S+OJY ReXaa3umtXCsjRHCq69QhTp2Az2z61QhUy3coYpGGYzBsZjz6fhX+7B/z+TWlyS4RDblJEAWQ7N7 L8q+pNJBaRQyL5ZE8FmBJIckrIMjgKe3PINBkPvSt1ERAPIilbMQj/gGeg+lVvMg06EQWlonmzOD LcEBpSeN3J9fT2qofERKN9S0J4xMdq5Y7SIcfKo4BOPbrU4jtZTAxlmiZ5C00YKkOAR8pyCVzjHH Y1sYtaH/0/kW8fyriERJFFDGu6MRncI84z+P41UniMwZo3O5wdxIzt9+a/3gP+ehNrYmsBaDY13s kRcqY5WAMhA6kVO+nWlpY+ZaP9nC3AuYlhk3RyuW+bIP1NA+ZkOn2n+kXU0ph8q5GHlllO5W4ydo 54A5NaM6W4tIZIZFMbfIpC7QQOmPzp2drkkNjCtncW89/by31jvEvl21yLaVcdMkqehHIA/Gq2oy 2N3KqR+dalrnKLGDIyrnODj8BVRhdXA//9T5Akh0+KEfvWMwbDQspBUcYJPqf8iiBdqC4SMkK2E2 nGCK/wB5Yxs9T/nll8JC0UT22I5bi5uhK7zGWUSnnBC4xnI56nv0qxpohlQCeKSKdMo2Tww9T6fT 2qzJ6u4l/LmFItmIYmJUA5Iz1/lVSHcIwUYvtG44HKigRbtpmET3MYWTyyVdHUMD9QaljuWltbdr 8QebnLpHhhGOwx2+lbQ+Exkmmf/V+TI44p0mtx5EcDKZBIw5LKCQo479PxFVrZLeGZRevtj27d5O Ap6bj7Driv8AfA/51zQW1juba8u7a7jaG0O2J0yRP1yQPbH61RsEiuJleVS6xkjnIVqAHXLqlxLD EjCILyCvygn3/Clt4Y4otm5gv8TA/M4/Cqj1E3YqXTQPNHmJvLVtoJ6jsDUTXEzJb2o2okZZlReF UtjJ/HA6+gqTKXxM/9b410+WWYXMcvkwt/C8iMcjOMDGecc/hWjFcS2z7IZvMt1GwcYCY9Pbjgdq /wB8o6M/5zx08hlYNJkBRhW7d6WHzgAwyUXgqfusD7USd3Yme1h8e2dpY1g2hlzvByVx1AFQw7oS 4/5YqCMjk+lXGWmvQxLn2hLaMyjady43SIGKg+mRx/Omv+/jMWQ4kAKsB8xPb3qk09AP/9f5ChsZ IJS7MF29V+lSwK1xJKpUBc4QseOO9f78H/OOPTzIVkZbhEDr5ToVzK3IOR+VW7OVbZJ7tpD5mzyY xtwrBhgkn+XvigCNSsq4QKPLBYsWAz60kUahZHkbejjj/ZPqKAKkE3lO7QuoEbbWGcFf88U+0uWt 73zZCbgsjcMcqzHHzE+op2A//9D5WlkaZ/mPlgDcCuOtH2YXG1WIAByW9RX+/B/zfkUdrDbNOBmT ecxuDwuOwH4VMZfKiHBBPfHFACFonTdERvI+ZTwBiqPlZbdjdj74AzQTKN9ScQkoSg2pnJGOanRj Ghyx46Drmgyaadmf/9H5fW8QpsMeM8E9MVTKKwZYWCpH9xTwW9q/34P+bcnkwYOMLKv3geNxFMeU PF91UI5faMZPfmgC9Au+FDCBJJF83lhfn+v6VWvZDMyzSyZP3TzzmtaewFe2kjLtznaSGJ7U9Akt wSjKu3qx9PSrA//S+YrqBmt2dGdCvKsg6fnVSHUJmiJnJZtvlqQcHpgV/wBAB/zbkTxn5QzkSepO R+dWRabhiWXekgzCGbbEjA96AKTRSJBvyhfzCCg7EY5/z6VZSaONY1uX2MzBBlfvZ9KAB5YLSd13 7o5ztjCr+8A9/wCtWBKEiKI/yngAdBzQB//T+VIfKElzOFMiQrseLdtZmOMEH25OKilmL2kpfCMy /u8IGb2r/oAP+bcZbwIvkvkszKGbcMYPU1qkR7SVZCVba3IzWDi1oZzXUiE7RS7XYSQqMIq9Fz1p lxDI7LPBtLAjKNwGGef61cE09ROD6FmdMRiWMMCo5UHArPAeVCxAZg/LYxtFU4rREWtof//U+XSy CNVky3OCx5AqGW0hR/OjchlTlM/Ifw9a/wB/Zq6P+bBK7sRibyWVievtU731y5YvsMaptVPLA257 is0m9DTk2EspJoC7rg7uHU8q31FRrGy+ZM5CMey9xWrj7tiyONgrBh1J+8atBFkDS/KWX7oJ5b6c VDuopAf/1fki8WTejiMvEHAd1HCE9AfyP5VbkjLoG6ADp2r/AH7huf8ANuSWaMo3oAYyMsRzmrtq IJRKIjkhsOO4PvWoEFzbXNqw821nEG0OJWiPlkHAGG/Kq91mIgw8xuOB0IoAoGCWc8sFAydx6fSr EcCvDGt0i7lPzKjE7ueMUAf/1vkx444SUJDkNzE3IjIPT8Mdasq0KoXVljkB4Ug/Nz0Ff9AB/wA2 5FHFJF58qTSObqYMYy5KR8AfKOg7/nWgPLiWTzG8to0O8npwDTaa0YGVHduJRyPLPCnsQe9SyCIN IwbcW4G3pS8gH24VlKSRrLlSq5JGwnHP/wBbpVqeMeTHGyjcvDkdCQetXzsD/9f5WlsFlUGOUKoA OG5+tPVLXToXjuJ8RzsJeckFgMDA/E/nX/QAf825l3FzI+FWLdGGAyFy2CcVMtsUkR3XA4IU9KAL jJ5zqVdITjBZ32J09TTBCFBk3bgowSh4z65oAQTyqMoPnTjJ9KqyxNMRI7FQDk44zQPS3mf/0Pk2 JWwWMgHYJzzSPawsRJMx2nrt5PFf7+zWh/zdRaTsUpbgKTGuQi9AO9QW8kvml8kAfiTRHZGprCNm iknVTsjALt02ZOKyXklaQEqJIlIIPoe1EpNaASJdO8+GPI6etXNkdzOql1IQfOueV/zis79AP//R +SppI4zs2BlQ/IQMCoLu/k228T73DNiNVBZU9/av9+042sz/AJv7DZVlkxtOMDk9MVYtJEt43Rch 34dicl+c/wCfpSsnKyArT3BMwjjhRAUy7Ac5GBn8alUKYsnGGOBnjOKvkVrAZl2iOEE7sFEilWDF MEHI5/CprhozE+c5GAjsp3pj0o5FY2ikkf/S+LvMt5D7RjqV+Zjx1q1aWzAPcThQjc2+3g45HP61 /v8AKKR/zjj3jaYeYzLgf6tenT1qEXQ2lZ1bO8LGQflx3p2V7gXZY90W5Oij5h61mwGOJmIU+Y/B HUUwLtrOVnyF2gdWPIq6Iv3jTpJEZCCqxnBLdecVk/jA/9P4/MHkMZJ23OT0z0qW3WxcmScbFHy7 h2J4BxX+/wC3ZXP+ccY8dvGwnEgmtw2wGPEhB56flVZ4VvsNmREUkBWymfesXuNJvRFhzAsKwvbq TGflnLHee2D2/wD10qp8mFIGaQrWK08Tm3khSza9lkP7uJFzK7AHAAz905GfpX4xftZTyJ4qKSOg vWW4uLiwth+6ykiRuvpgZyO3Ir8s8ZF/xgGOf91/kz+jPoxL/jZVBeX/ALdE/9T+LHUZioEmwhHY gA8fhVWKPLM2Ds8veCvOz2r9CxC95nz0NIpeQ5LKSSNpoc4VPM3Mduc9sVztxZu04IOQH5ToPpXM 4tbjNPG0JCVaSQ9EVcqfanfv0Tbcfu13YRYzjisJKzB7aF22k8n5Wk3jopODj6ms5bOC4mDcRqJs vj5sDvUnOf/V/iXvbdIAhjAWJnwCo5PvUDRiNJJQHZVAw2RlsnsK+wPnU9kLGhZGLo2HIyM5X2p8 VuEyxdlTdgZ4Fc5RPcIEiZhkxSHy96cE/jTLWGTa8pLuVGF9cContYBAu6UPKvkoMEYO4t/geK24 rq3QSSTszoqbYY8457k1ElZ2NuVaJn//1v4oby8ivY18pGVUbA2nDlhVaHAKs6kvjbyMkV9AePZI vR2ztKvlMS7DbsB+8PT/AD6VlXZkM8cmP9UdqKT3oAtgytCvzuWZsnBJH0IpsdvPdbbdl+8dpOcY oL5GN2jTnUp5hIOwg8oTWo88bQh2VgzEh4zyAO1BUY8u5//X/iia7t1AaVW2N8o+XgEVE5DlQmAr j73c+lfQHAld2Q2GxkV924bGyWK8EVpqAwymUdBjjvRboK1tBBHAPvyMXAORnBcn1qPzEUEbNyg4 +bg/lXOBUuJGMuZHyCAEUdABxiqW+QOkjRlLRpCuEON+PeonsGx//9D+KOKa2upMw25/d4R0YgED 1H/16jvCkjtEw2AY2hT1FegeddFICIALIXQjhWzgH0yP89at2ojkfywP3ife56rQM17qJEtDDFbD cQHibO0cHn65rIlvJGjEIjVWZdoc9OKAJ7YSPFHDtIKfeJ6cmknt9+9ERmbZtYg4H5UHQf/R/iNX TjbOHywLHLYPC1rOzeV5Ydl3+jYYe4NelD4jlkror6lFFLFblcSMv333fPmsmJphIIUBAY4V2bp6 1U+hk4tK5pR7gUjlhJMjFRNu/nVFg0UksSAHa+7rz2rMRo2czSJIqqNxO0nGAg75pGb7O7CFeZcb 2PQ47CgSSWx//9L+JFrSO4nkfbsMgAYjqwHatOOxt0R28zkLvEe7av0r0DyuRp6EUqQDajgCUjKh TyKpCHypt5H7ortcnkmg0V+pseVCkEbQglc5BXgevFR2uBLMTFuyMkvyr9eKBmZqSpNkKdwX+AHa FIqnaQO0vzHI6bfWgD//0/4mpQ2xi7qvlvhVJwRWNerJggnEbMFUr/HkZr0DzyS1iEeGyxf7vfBH pXQQ3kMUbryPl+fggx0AZMLLLIZE3K4O3+6BU9uotC+5mBZ8gYwo+tAEyzrco5k3fK2EZemOlLby 2tuJQ6u0hH7sh8L15yPpVJLlZKWt2f/U/igW/hkGyPA2HLE/eq7dPbXVu0TKwjK9AMkH1FegefYz 4+AY1KkBAFDHLHFRXEpkWMxQeU8b7ZCoKtKB3NFugmndErGKWSSOTK4i3YHIP0qaGTy4SSJFR+FB GM46VhJWdgTNbT5lgjaQ7iScAn+EVLf344xKSy8cjAx9aQz/1f4ppZ2lRJCUCFvkwwJOO/0plxci UrDHIxiB2kDgSY7kV0xSbszzx1jCVmkluBhSpUHOdg/yK0p7e2lgVbaZ9g+YSOuCa3AzGURAssrA DqN3ytTTdxR/MXy4XhcdPfNAGjaWM11bteRH9yg+cdGX8KwpWkTzV3bwGO0sME/hSur2A//W/iZt 4AYGZ5CZWO7ngIPSr0FrFEGIdWSRcNu/iNd7V1ZHnjrEQ5k8oCORDzz94+1Wr5oU+UIQRGPNZv4j jnisAM+yeIyHCMqMhjUIfmHv+lLAzRmQSpGjTnylLHa7DkDJoN0rKxLOZoxGqrmWP5RjjI+tTxxS JE0ykktwUIOVHrQZacx//9f+KxbdJFAJ3p/E2OVNVbmVIpWhfAjjTCt1OfSumO6OczY7gRupkGVB 5Kjp2ro7CF5o5ZFSOTcCU3jcfatLe+BVeyaSSRplKygAKeioB1496aX4+zF5Y4wRu28lh6gVZhJ3 ZRkhjiUiNHjZz1OQAParKQzyCNJ3ZUMeYmGGJ64zQRJ2R//Q/iZeJ4mEcK7UJPnSA4IP9f8A61Vr h2kT7PF5kvmfK5J+bAx/hXoHkN33IktlidHeNdy8Kh6HHt+FPeMwo8hRmQnJjUbs/hUt2VxGfKUu JN4BVmGNjDG3A6VpWdrJ5Rd4mKAZkI58sZwCf896xEr9TSu7SH7NFLbMGJXMyspUx9enr2NZtukU jNv5eNclh0wPepl8Iz//0f4pFWCSJRyFByCpw3FWVjjVC6FQcZEYJJUD1p8rPIW+hy95a4dpIplk SViw2kHac8jiorVhDJ5Jb5lXcPTk9DSt0NzayUAjBSQsvVWBAPpmogHPlyE+QFfDP1B/GrcHfQDU jtVwJzM0m1iDEVwDnv8Ap0qndzQRy5jURqAAxB+8e9JxaVwP/9L+IGa4ma5Uxu5WNgyqjcA+tXHn bau4Hc3L07M4eX3bk9pOyyRF0Jj3fOpOMitm5vLeZXeONFRiUSPdnZ2+tHK7bEnNyWzmFi7SAqeG HR/rTvJgS3IIIDLhscOD64pWNIWKiWUbSRw4cySNlFAxx23ema17qJTCUmUblUIdp5J9jVxinuVJ X0R//9P+K7StK024tY5XkmjuPNaGWE/dC4Uq4/M0l7FaLOIoJZPs8I/dxyDfJKw4Jz2qnFpXOBqz sUxKSCsWdq/wn+A+1UoUTzsvlnDb1D8nNSaRlaPoaMc6bfMESvKGxk89PSsm5nN+ZI1RiwOJFxtH FBEPiRkLvh/dooVWYbueR61uISYJIYZ3AYYYfh2HrUyV0bH/1P4irZp1LKSyqy7QHX5iKVCRIwTi KLg9y2a57dDFNKNjStpLbyrj7TO0awYYLtLM+T0FSebG0cwT/U7NycfN9CK3SsrFUzHcQNKPtDyJ uHyhFzuPQA1FsEbsqklByd3alpzGhZVUjtmkEjEpmQnrgHtip7SRBG0uDJG45I+Vh60J6tA3bc// 1f4jJfNnkPlMy2oTHXB3fSlQOy+UGbcp+YnjPvQAlwihFVxvVTw2eQfWqaRXEUdxJDKUUrgso3Ej uCKynuAtrDOimRfMaFhmVWODJVu5kWONQRuDcMDyCPaiMrKwrlOKVN4WLIxwYz2+la8Qgt12SqUD puXI+X6Z/Cqk7Kwz/9b+ISYyQO7xIUhYgMU5OBxmpnnJBYOBJ5Y2Ecgiuczc9dCqDuuUVzvwAzMB jPGcVrI1svmNE0Udx9zb/G30oLTurlOMiLzftEaNOiFvMVeVFNg1EzbomQ7QBtYDn8afUZKltbuz ySk7Rzkjbg1QFk8t0ZUIa3A2gno5/wA/ypBsf//X/iH+ypbgwyAmSFg43jG76VfP2BNzbN6hd7/x lf8AeHtWCV3YabRUujcSZeEbrIpu81FwFx1FUktU2APIXZ/uoOuKfIxyd2aFvDGItk0TxkD5X3Zz 6Gqk0oVliPJzhiT8uPWpsSSRxwROsksoS3ZgzAc7sdOfQ1uTW9nHLaSWrTWrStneGLqqnBBH0/pQ aQ1TR//Q/if1PS3t5ljNzJMrwLKLgkAEt2HasSaW3t2EEzsMp8r5+6feucLW0L1nNHcRhX+dkOUc j5vY5qvdgDaFZnIySM9evFAE2m3Kvcw3E7eaLc4EUi7s46LitLU9aur1I7e4t4WjLnlIQk6/3RnF AGfY3du2+O7EsLY2QBV3lyDgKfSrlvZt5rTyxExkEJu46UFR3R//0f4m75Y8AGN1KkMsi8K30rNV Q1w4dC29QUI6jHpUQ2NZtrQ0oDcR+YF2ESLggnDD3q1PEkap5cyLLhWK9Sxz2qwp9ULLfBmiWWU+ XGwHI+5zjmv0S/ZOhsLIxJb6XLGqXou5YfKKR38r+UC5J6jvkduOK/UvCaiq/F2G0vZp/kj8X8b8 S8PwXiYp25tPXrb8L/I/og/Yh0i41z4xeC5bsTPp+g6j5k8cLZeJuAkcw7ZzkD29K/tu8FWlta+C 7c2v7yEaOk8Mjnb5rqg5I9zX3f0lK3tOJcFRXSK+/c5Poz0PZcEVqsvtN/5H/9L6W/4KweMINY+K Vno8TR2dxKZ/tc9uPPRJoUAUAnIGdwPr8v41/OV+0lEz6d4ilv5pP7cfQoIY7K5mKruR0UIc9Mph s+/tX+mHh1R+p+G2HT602/zsf598QYpZh4vVWvs1Lfc9fzPwz8Z6bFp/nf6PFFPNcPLIbU74mb+I 7u+c5/OuF0uQxS/vmPlHgyL95M9xX+c3Es3UznEylvzv82f3Vl/uYSnFbJI1Y3IuHEjFxnMbHq1d VpSHVbmGJo1hdf3Qup22KvqT6185PodSdma0Nqouns3kimKuYzMp2xn3Ge1bDw2sdrFaRFSYAWjA 756/yrlkldo150f/0/4sTBLEpuIQDMDuER6SY7N6A1bi0m7vB597dTRWE9ws620bBo7dR/CmeevP J/Gvn2t0c0ZJ7HYQJbW6+TbsCGkwsuAGkxx835VrLcyAcQea0X+qd/lwR3FZuC5dDeLujIis4L3V PP1O5ulF1ujaIkeXBwTuwcdxn8aiMsOkWoiV7m6O7Yu7BL89WIGB/wDWqoqyKNvTNQSzYRmKN5r0 Bo2jlD+VkZA44q1G0ttqUM9wbdlDb1VhuL85wR71k92B/9T+RXVX8Pas86XyRRT3EmYYYwUROckr zkdO1NtLC0jc3R3yyICrhMhEX+HPavjxksEYMsctwzxwyzFE3ADGAcHjseK6vSm1GNLmSG6EcMlq 1sihldlYngkHkdB096zn0FO3sj7P/Y4S51D4s/C9JbWCWefxVD50T2zxTRyx5Vju6kYweOvWv9JX 9mOwFz4K064lKRi3220dqgKLCAgJ+X/e9f7tfi/GMr5/Rg+i/Qxj/GhFdrn1VLiEYUgKoznHWq6L +8D9Swz7Va2R6kU0kj//1f56f2rrG80nx14quba+t30yHWrtr29dWN7C0l07IFjAIKhWxu9Bmvij VDLMySR7Z45W5fGRJ3BB96/NeG7vLabfU8mlN1MOqvc4e+tfKvw95apGzttRI33Iw9Wx7VUv7U2m yytLDT5bySQf8TCOZp2aN+QvXAIz/jX0aV9jplsihqOk3cN+ty+pO1nFZ+RPZhx5cT7hhgf4uMgg Vo6Rd2qqNPLrySFlz8zZ6jFaQVkS01obStaIDGXQorFMFh8x9DWHfXItL+SB4WWERLPFOOUy2flB 9Rj9a3gI/9b+NC0v7XEyvGTO53GR8bGA/vH1HNQWltIXAVFkaSVpMBiYiDznPpXjnC42di59kuy8 6FobhFgzKqHcbXnjce2en41RgtbkSbrozi3t4S9qA4ZpD2x7cf8A6+zWjJtbQW4gvJdPGpRwXJie Zo4DF8qyPGAWVvQ4I6+tZtlbayHkuI4UJvbhbi5sXG09AG2N/EcCtVJMDWAnVNlvtjuFkOVxtyhP Q+pFd7YTWl7p0el38jRKqCBpogF8kE9QfbNbQfQD/9f+Pm28xpDa2Mizm3cxxzK2Im2HAO4/SpZ5 b2OQTPCHuLiVILsMwjBUEAtn2AyB1NRTZ55yHi6FIIy/2gne5Vwq/u1AwQd/58e1eK6mI5nkFtGJ WBCs6j5h9a76T925nUVpWPY/2bbe8PxDs9MZL2Qq6XCWlt8xljMiLJuBz93IOR05Pav6MfgnqtvZ +HdNnu9OaT+z5VU+WNwIhAZwzjvkgE/7Nf2v9Gp82R4yD/mf/pMT+YPpBxtjcvn2a/M/tB/4JV6h aXfwi0CIyT3MiaWNT0+6D7YGt5FAjjUf7K/L/wABr66/bE0Rdd+FOsxl/JtIIZLmeVT+9hRY23qF 7lh096/mvjByw3iZVqT3VX8mf1FRhHFeGtGEFpKhb70f/9D5n8X6YbLxZ4ms7drq4n0/XLmymlvU MblN5YNs6A4f9BXDT2dyZL2aGVp43RYYLdn2RsBy7E9CQc4A4+UZNf6+cOVPa5Nhqr3lTi/vimf5 C8Q0fq2c4rDL7M5L7m0chd+cLq5s2Ty44SpgmVAiXanrkDoQeMGnw3F/qCz6fHcta2qyr5Fxv8mV 2UYKAY5GOfxr6CD6HyspctRos2XlWkdxJLc3F5eSqbSdLlNkcKqcLt55OMc9MgV01okF3p0kklvb GOzAYSSAfMeBgH+ldEGthObvoYEKrHLexvaSWdkqeeLlJPMLTN91fXnA/LirNrYOIZ5RbxNKkLeX cSjaVz3J69QM9a0HT6n/0fgqzjDPf/bdPjgvpZlQzRXolN4uAqtyAeDkY6VfDLYtLDeW89ukI3Qu oAaaRTnafQcDn3r/AGui09j/ABdkk0RIWvEuJNUgE8cv7xIZ03SNnkEZ+tWPNt4orE6el1HLcOLW e3uiZVm5wojQjjGOvpVGJZ0fUI7SW4nUR3UkspjdGQPGm04wAah1eWwif7alxAXt4xcTrESCnP3M Y+8PT2rWLiZSjZ6GTq11qFydPay06ab7WoaLd+5dDxtOP9rJxj0qdbWM+TLPJHNLE3720V87MH+I 9OuenpVnPKNkf//S+ELN7zVNWuL6ynXTrvTNyrDBCI4HRwEdcgcHbx9CetdRpWnW1lbXM6SRJExK gIcsrNlmIHbJOa/24P8AEe1jOD2d1cXenM08bR2f2iTUXcpkqQREMckt+mKoTW8MNqywxIWnmDTy sm5pFH8OPQ4rZRSA19QuIdOt7bUbeFQylLNIuWZ3YHgDt93p2rMvp9Q1O5t45zBDawxtIVb76FsE E/l096o52+paOpOLeO2Qr5yqFIUbQB0JH+FUZrG6uEbymY2xIkn2E+Z8rA4+nHPsKcVd2OOe5//T +GUlljdrdIyEmwiopyHxjnFROLiaKXdEHhhlEQjEZUpjA3HPXnPIr/cXkR/hPLqR+U0kQR0jeMsF Ct90dO1dXemK7sPse0S26QBHUHaqgDG0Ed/1p8iuZz7GXFZQtYpb2VqsKQAbMEtKF9Cep+prU00I NthM/wBnjjj3oPspWDjgDfjb7YzRyx7GZcmgtzFqFnf6fA1rJAInM0e9ZAWBVlHboOnTisGPTZrM +ZNawyxONkcC/dUdto7HpVEKS1uf/9T4m8m0ngeI3EkNyoI+zIjL1xg7sY9eM5q4yGG0tlWKTFrE FdmzIz4GNxPWv9yUm9j/AAXKGp3+oWlnbraSNbJcv5kwMCuzKCMgE5IBxjj0raZ4L6xtJzGsczxg FoxkAetaxjymU9yxpkcUcsMun6XDDGkRiku5PuzHnc+3+HntVHUnltHSVViuAJCHIbKE9sfXn8qo wmluUYZbi5l82VWMjnAxyuegFa91ptza3CjyFvP3KzzJZyrKYwf4SRkZ9RyapRZlJaH/1fjKS4kK KyRv5bKUCSH/AFYOev51atYrawQy3gEszxCS3tw+OT03e3tX+66VlY/5/nszLmuJZnRZgBbE8FON uT6VYhkitvO2SsU8khyT17/N+X60zAW0nF5DK/CQwLvDSDysDjhQcZHOePepIjaIWM8EdyjMGQM5 RkI9CDVQXvCezBS6M8sAt1WUlJFK7pVHBG09h+dHzxgukLOwYKQEL5BOOfT3rY5Zu2h//9b4ujMp Vw3zDdlc8bR6VtWUS3dpI6zCCISGKXr8jL2PSv8AeA/56DKWwSe4jjnkEcOx5kumOIlaNcqpHX5u g/rRZKJp180sIQflVRlWNAiw08cOpqkluogf928cTnYV6ZBJPPOajutSiF2+n3ljILe1JWykgBaR c55wOvWnfSxDnaVi+oti5ks7y4uLcJ5LLNF5LI+AWBHPIyPzqNWjiJm5idTtQ45OeMg9q2jsiuZW uf/X+LtQtpZ0L20ipL5yvI0hH7wZ+YD3xVu3nljt7YtbytFG+4SPkRyup5XHcYIr/eg/54pSvoib 5blmeKJbNmcuqISq5P608LLaO0VxKm/zN0hTDNjAyM9zTW+pm5JbjZ5IDLL+6kFu+TDyNy+marSs I7QiFsGTKsV4bFDVnYlzXQrW6Hy3YiZo0wbpolJKKWABbHbJFbDfZorUQTRYmJ3xTBNm8ejVpDYz bb3P/9D4zkJt0ifdjz3KomTuG3BJPp1qzgyKryfOFxhT39q/3wP+dcvi4mijezSARi5HyLGvf+dM s9QOnq0UixSMikFWRX2MeRn/APX3oFfR2IilzcpLdNNDmZsmGJWUoM9Ocj9aSGR4FEkRDMAQEb5s ccnH40GLbb1M+5mlwjlNrZ+duzVOJYLlVMELI6xhZw397uR7dPyoEf/R+Q7drRV8uQgsD86btpb1 GaZdSWkM0Sxo6wSy4ALbypPY+1f74x3R/wA55MSWLQnaQgASMD7uAaJLl7OBZQjtg42xjn60PdmU ndlGW5dCmxZGErYITrznrWjJDAnkxM7ReY20qzljnPetYxstSB9zhPLiSLzwp5U4walRZ/ta3hjU W0Ns0OxBtjiLjav5dR7iqA//0vklbh1kIIAKkH5+d47VUF0fNEQQ4Zs5UfKtf78H/OOWZEiMiyqG MgGNrHI/D61G+oSXKxafcBY7eKfzD5YAcn1Le3pQAwoUcQxsWBf/AFrdcds1ba4WJNkgLKox8g5+ tAFS4gSWNY42eNJW+aZB8y+5/KpmkSGOG3Cj92u0ykYdznqf89qqLswP/9P4+F0UmUMWeMEBwvX8 Ksf2qQ5t4UVt+BluGGPQ9q/35e5/zgyVmXnn2rC4QfKP3iZzk0xnMsTZX5gcrikSVGmSCKPemxpD uxnDfTrVm2nV59xHkRgZRVyWc9BQASz3EYMaxmTLYzHhev1NSG2nWVVZX+5uLEYVeKDKe5//1PlE xSSuQoyI15ZRwB602XfEgwh39emM1/vwf824RRzXDxko672/iOM84zVy6hEcjqmxAr7ZEL5289FP f/61AFSS4W1mxD5jNJiNUU5bniotsomw/BDbmWQYxjrwa1hsBfmYzrm3tsRD920yphSQO59ax2he FmO7hWzlTkGrA//V+W/9MmtY5HujHCsRCxBwBIOn3ayTIBG6IN/PPYmv+gA/5ty/BKlyiwsuGVeW xgjFQTXSx7o9+REMIcZ/KgCSGSK4SCIllnIzKwGY1IqVoWR9ryK6nHzEZZMcDBoAqTWjM28uGZPu 5GG+g/KrdtbO0bhzg4+UZ5PWgD//1vlcx/LtbairncehbtzVa8VJIFSFN4U+YHU4f6fQ1/0AH/Nu Vo5rnybdpbdrQGPdiVhvkGSMkdulWpri2kbZFF5W5QZNpyrHHXNAmrqwsIBJw33Tg55q9GWLbQRg dx0oGLd3otj9nMZl8xQvmKfliPHJ/CmWkUbb90jZVslAOCD6Ggzmkf/X+YXMQCwQjy1mm2q0nQNz yfzomtmSN0k2u44VoySGH41/0AH/ADbRVkYrkqwjZfuD64rTtPIkl2SjOUOBkj6H+VZxdpO4y/cQ RJBsjB3sOoFYEYkjsplnffL53loqkhsc8nP4VoA2NCIlRlIwvAJ5qxbTTBWTyhiP7uVxmk1dWA// 0PkpW2uDMpCscFAeBWkgVTsVsxY+bvX+/cF7x/zbksCxsPKgcbYEwAzcYAzz71WVZY/tEsAZRj52 ztjzWoE02sale2MFpNdSNZRN5qw5woOMDI/z1qtEPtYcDcAh2xg8bvf/AD6UAULlri1aJFCpG7BG kcnYnTJ4+tIwG1VimMjlz8/QHnigD//R+R2CRKvnZM0jALxx35NSNalQJ2YFQQNueefav+gGK1R/ zbltIisYkZxGqngFvmqKaZiWaLbICNjgjdnIq5rqBTSJ2IEiGIsP3fbcPUfrTDatG7S+YxVFxt7f 54oULxAkgmeKVSHWVH+Y7Qcp7H3rSuGlkVQuUyu5Vxy4pOD6Af/S+TYyXiljViHIxz2/Cpnt557R rh0MotVCH0UHOB7Z5r/oAP8Am3IYrj7U8Yjt0thGm0x+Z5nA/wBo9+P1pLu+kczBY1jjjbagDbu3 r+dAEKutxAcqZAOSi9auGEGOFCXt4uH246igBrPIJNqR741H3senrUkUMx+9hlJ3BWH3R/nNAH// 0/kudJGdowp2YyJVGAvsaqMxwyAkADv0/wA8V/0AW6H/ADcR3RCiAr94Fgcc9adLJHDjERcqMluq /lRY3ITdTXUcqAGNGPKL0I9KsgxxZkZdkRwPLc52+9JxTAfB9n85pgo+YbQxHIqyRbNK5iZg6/KS q/K/vzUezA//1PkEFndo5V2gNhXH8Q/z/KnGGSCYKxEiuQUxyRnHBr/fz2Z/zfizXAkby4OSOCvr Td6qBuXbt4JPXNZgXYdqtvbY4aLcMr0yOnPcVUSRSDDjcM5TH8Nac9o26mkYW1ZYubdYoImAZllH 7zevyqVPb9PzrO3LJhfLUjGM4xjFVF3Rof/V+LZodkyDHyk4JHSrVxNLb+XEwcRP93K4X35r/oAP +ccEVXBaMnAGTk/LULQ+blvvBDnHbOaAFh1GdC0LRpj7p2neDjuD+FPQLv8ANZcgdMcY/wA4oAsu GR0KbdsibuCG46c1UZHjeN1YEiQYB6KAf8M0nFPcD//W+QLi5glYxgrIwGNwBAJqgMEBDgBFOM5x ntmv9/nHR2P+ccgjMkUEcQCjYxZiowJCTnJrQ+2CW3SHyikmPncHIHsKxsaU+o77M7iHzHIiQ4J6 lqWUmOUKpPlN8qjH86AmtS5c/YUsZ2uDP5pjIiMMnllTivxb/a3M1j4juhLp6gE/ZPtDYW5gLjcM ezbee3Ar8u8ZP+TfY/8AwP8A9JZ/RH0Yl/xsvD+n/t0T/9f+KZ+LcpcbnKk43t8wNVrOYzAhW2qp wQeCTX6Jid2v63Pno7Ics10/2iITMCpwm0ZQegxSMGEflyqFmHO4dDxWMvhGFpqMkMU0TQxno8ch H71WHHyn09qcbzzkYTxiRmXG4DDKfX/PrXJPcCvAFRXDBlAycHnmsu3acXckyNsVWxt/hcfSoM3D sf/Q/iUudR8xWi2hmbhWxwh9RVVXKAB3Z2YcKR8mO9fYHzyVhkTGJZDEpKqDuQtkDHoK1bPVoJ7B 7Wa0hccuJNhEsfTnP9DXOMIJYTG8OY5EHIWXjrxgVck1ISFQlrFaBIxF+7BAbHGT9aLFwi73KDQv PGQr79zkngALVZo9uIvMyYz827oazmupqf/R/iat7SW6WF7ZYENu5eRy+3zB3GOn5U+9V40JGEk9 R1/CvoDyVFszoZZZbd13uJAeJBnd+dLc2VxEqEyh4yBjk7yfTFBqlZWNy2MdvEFn+SYYwr8A5p9x HJy0YKbhkKD1oGZtuZxI6OnmF+F3nLA+taTqkcODy4OG3dz6VpCPVjirux//0v4lJoXKudpI6AAc jtVvTraV2jDhmjiP3sdD1ANfSTRxQVpWNa7RVRwMszDIVOM4qBZI1Cqdyy+V9wrnDVmKStJkcFpc u0kkkTNIuZCIxvEajucVUeWOVwE52tzzwfpWMlZkle8R5kGFVfL5B/iOc1VhBWExyMTsbcgzxmoa urGc+x//0/4kV220gkQkvkFwOlQSs5u/tCrlXIBH3to4FegeQk76F58yskdvC8gJJc4/1Q5yx9BT mhNvLuR8B12yYPWg3OksHje2KP8AMVztJ6CufubfzrqM28YQRSZffkq2KASvoXFuZvOKxxoE/uoO Bjio5Jpd5YKyFcqwxndQdB//1P4obgzhFwiOJAGODyvvWaks7zh442eOIeWeMrk/5/SvSh8SOcvX oa1cqYVG6ASMynJUnkCsWJ2aUNu6+o6Vq4p7kyV0byoJot6nOBxzxxVZ7dYwLoqrTAYBJ61i1Z2M RbIKRLvDJ54LMo7EelDKI4irM8jFsJu6p7UgP//V/iWtpJkyrJuHTeeOTVi6SRVjxgZ5ZutegeeU yLm/CzIIopE4QJ90gd/xqWPhPKmZt5OGB7fWgDUivVFv9lEaMkA2gpw/5+1Y81/5czQqWUAZ45yf SgCS2iQ7vNhIEhCq2eCT3x2rVms4NKYW4eOWVlEzFX8wJuGQM9+o6UAf/9b+JO8cSRlvs5ciUb3D 8Y6YxULQmQRrwUj6B+M/jXoHnmjbpEUZJMKD0YHB+oqS6+zeSYNxZmAG5eCMcgk/hQBFp0SSzOrI wgjULvIwjN7+uKmnEjzm3UIY2HEj8L16fpQBGttJDNcoWiVYgAI0bcWJOPlpWthLA4CKJGGASOVp 30sB/9f+JCLThbyASktIeVA5DVow3DCRk2cbSN2M7a9A88yriAo4ljMiyb9vB4I960DOrhY9vzOu 0uRz0xmplpETdkPtcCSSGWSNGCFUkKks49P88VdjUxGDz7ZpbdpQOvLc9cdqxM+dli9kWN1KHy45 Dt2sANvtVSeIeVzl2bjplR9aLGiaa0P/0P4k0hkhkk8xF8qNMJt9T6CoxI4kjKQ7owwywbDH2rqg rs8662Nd4p9oaM4XO4q3XFFzLGVjTzCiSfKYxy6ep/Gth+RLbWsU1rOGKGOFAqgthmzgdPasm5iQ XEcHG5QHEa9GXng/l0pNJgakdzJCPLhV2yMtGuQMDtiq5glcvIyNtlYbU25dfXHtUP4rAf/R/ikW MIqMAdpO1gRtb6Uy6mijbyIiFHVVJyR9a7pOyPPI7eMW++6dySxwqL0H1q4GjnEMzOrRscMueMjs frWIW6FeC1eSZFhVi8km1UiB+b0rX/s+KUxtfxjcjYiE3Ccdc1ajeJu9hZSCE2eWAPlHcj6U25mS FN8ZHK4wTkZx/wDWqbMwP//S/inspTEVcPvy2ZE/h60aqbSb/VRKjMdxLc89jXZBHOYP2e6Vo8o+ xsgsF+Wuv0lpIIlVzgKT7YGau2pnPsac4hZWkYg7wF3ZxxWP9hJme4DskcYGxsZDGmZkFzPvLBis jqdyovAH+FQzo/lpNBG5hVsSt/CnHQH1oImtD//T/igkuI5ECo5Bx91hhvyqWwltF6xOJJAVMhGU UDrj9K7JvoeOPksFuJXnijctHFyxJCj+lOWFntsZy68MCPu1mBzVzaTRShyS6g7j/CRip47iW5jO HaMj5WCnGRQBJFJMj+Xdt+5bhXxgEVeWK0aKQW10FmZhHLCU4Ixng+9S1pYD/9T+JNF3PLFEZI0U 7MOcbselJPNLHsiVWJYhC+OPzrdKyseOlfQzZJBCTDEFTDcgg4yeeavRWKbmd0BmlUDkkAD1pKCR 0GfeWk0cgVFxEDlwrkr9a0jcFbWKEFXDr8mDnGKoDU0y+3I0EnlySBSIzJkDp+HIqhc2U9xCpCYB c7z2WgD/1f4gJlMMyqBghdoKj7zetKfNGyN3ILNnPp9a6LHGpLlsy1J5aPGWdt0IztBwpz7VaSKM 7w52CQb1OMEntQZiSFtiwE7lB3jHtxWbsk855CTtI+56AcVMkrXYeRrLAiCJ3l2gpuwcK35VFdXV u+0Rt7DfkDPvxSp7WNou6uf/1v4jZLuWEBYTKZTwAn3R+H0psFy0sgEzOjHgnGCD61tL4Wcqjq7l 23xHcMs8mR/B6Pn1NY92p/tNCjMGQbchsYB5yB+VYkJaSReuLgRtbrabg8Iy5XO52Bzkjt+HpVSK ZZZA53RMW/eHdjcatxJjuiK3LPNcnyQ0aH92zcpnpj8etbK2E7+WpVrfPzb14De1Ra2huf/X/iWn ikiwHcB8EJu/ix1qt+7AiVQy/N8zAct9awSuc45YyrzLOrbGG1doyR7/AOfSkmdoljeAFo1GGwPT itxp2ZQaTzmLAbWJACMMMvrkU+9MflNbxNt4HmFT85xg8VnZ85tdJXG2zI8XmeXMSo2eWD8rDpyK sGWa3VS8JWBuiqMhRRFWmxT0if/Q/iPtXSeZ1z+7KgRqDtDN1/yK27rTLkxTT2aJEkMQW4+0MAyH gMQPr6UExlfQyJ3hdR5DiU7NpBI5I9qq2M0gdxLGY41bBG3lj2x7VEo31KLb3CI+ZAF3fdB6flVQ TQTmRF/4+SMRBuEwPes0mLQbZ2m4+ZIG3s+0bRgj6VYu2YS+S/mMsfKoBxn3FIZ//9H+I9HWVAhQ gnjYaiMaHMaqEkRdgB6kiucj2auUpUmtxgALcN6DcKrQSQLK8l7IsUkR3GRjtwc9AKC0raI6u6uI RpokWD94xASRuPMXHTHv61z9qTcSOUIhEQ3FMff7Y/nQBoLKvz5cEBclf64qAPGgCW7tzL5xGPu/ T6VcEnuB/9L+IG5nm1G+CpKq5ATzDwoA9Ke1pcKs7RbdkUYFxKHAZhkDG3PvQlZWAhjuLiNGgQny HGGTPytUcZlSXkbVVflz1FAF03UnlrCTv3jAOMHNNeGOE4uUZzs6A8/hUT2ApRI8sNypjAUZEcWf mBzxj6Vc03UpoUdbyPzIrcgBH+VpF7gVkNNrY//T/id1u7+0GBbFX+ypCGJJBz0+UY9MVzjxxXe0 FQrYyz9Tj0xXOBat1uHtTEGIaHPl7Vwcfh9KgMc/lyEuGmiTeyBsNjNAFiKeW2KNHbq24BwQu47u +a0JrgXlw18/kWsCKq+Qh5BVQCSOvJGfxp2YGW7xTO10h2iLoEGX9sD8K1lup2sohv3nzdziZsMc +g+n8qv2fYD/1P4iZ7mVZJI5X8wONsar92PHcYqrMZ5TC0LKs6sEKk7F2jrz64zUwTS1FKVtzanj kTJR4whjyGyTg+lNsUeeQrna4X5ZGXcufSqeiHTnq+x06aPGqJM0iLJG28FlzG57Aj0zX6Nfs3Wt z/ZVjFcXUguiIrSb7OdkUQwhLqewGR1r9l8EKXtuMKa6Wv8Aij8C+kJW5ODnbfnX5Nfqf0wf8ExN ElvfjZpsazC60u0vUivmaATW2oGJEIuN/cguPl749q/sVWFdG8DmC0VplsrPbA052mZWG4Ej2z+l e19IiSlxzhqS/lj99/8AI+g+jtD2fhw5vvL+vvP/1dD/AIKLalZ6h+0NrljqC3TWmjCbV7aG0uBF LdSmWKNnHqqhF4PHOO9fgF+1pr6FNZbTW86bUCsu27GwxqrpgFz6kjocfLiv9NuGm6PhxRlbaivy P86klPxbxCX/AD+f5n5GeLzZ7Z42vHkuVk3iBlGyIY9f6V5/bRJcxMFym3r2z9Pyr/NfPJc2YV5r +Z/mz++cLdUoLyRq20UUSqLgFgrbgF+/iu9jYS2aXcRK2pXK7kzNxwOfTr2rwnsjoavNCNZgRGYA g43Mp4L1NbpLlXQRLKiZVWYLnHUc1hL4maH/1v42IJ7OASXLRfalZTEsKuI5EYj73PUe1SHcVnhe 3ZbeCAO2zBRQcAZ9uR+deDJWkzkgrK4lkPs8ljHHYwC0ILNKr4dCSO30z0rpnYfare108NNcSSgQ qx4Qn+97dcmpt0N6aOeczeIEuYnjl0yUSfZ02Z/eupwWUn+E47VeSyiaBrWUh0KhGVzneB2oNB8O iXA3vB5cJX5omUkFCOB/L9K0IrO81KOCJryK3uraXE01ymHlA6sMDBrB7sZ//9f+PzS9PbMg1MIZ PPcK6fM6jccN+IxxWhDeJp7SJPKz2sb9VXLgDr9eK+PAuxN9rKXMaAWhl/dxlvnAPTj8ua6y2aGy n8u0gMvnfvJI4cytkrwxHbGOntUTso6l1Fy02j9NP+CZugX3in9pT4dx29tBePpGvnVAs4LOgT5G BXoApZTzX+jH8C4YbfwVYMqsJ5JGklYpt3k8cfgAfxNfhHFEnU4v5eigvzkTSh+8hPyPaRKZZDG3 TvjrVpH8tvLVdwHfqK9FLRHetD//0Pw8/bo8NHwx8YvFdhFbQbrCSFdQ07BMDLOZUjeLH3gqxrnr 95uc1+a+tLDH9ngSzeeS1lVYI428pIj0GRkDpX51w9aeXU5LbU8einSwEIy3Wn4laa6jTUbGKTTr eC1afbevJIZZIkxgttI9R+tchame2bU5ZgLhI7+RbExR+WZYhjaCSfvCvoo7ux0yl7sWO1BbXWtG kRIo/KyZBM5Mc0TgkEDnrnjBz0rjdL0q4g/0eISzSxwG4kkk+YxKCeS3+elWlbRCb7nR6LHp9y0c OpTn9/uRCF/cTMM8ZJ46fpWvFqGmGSO7vbOK50m1mbzVbKo3l5HUdsjtVwTuK6vY/9H+MvXLzTrt Fn0mOGxsZrVkmgMLFbgyNnKlvmBA6eorJ0i6ubFWWz2FvL8mON1DEIMdj9O1eOcLk27s6fw41/Y3 mq3LR272+tWIinTdvYur7gSnTjaMc1c1HTtdsr211LUbJbTR57ZbmNOVthFjCmNvVj2PPNBL3KEG o/ZrTy5Y2a2muCy7BiEtwTj0OOtatvaWl051K3baIQY490oEkWeu1c57dRQRLdJGTPIIb0OUMwXl gBhvwraltoEtCiyyqbhjN5kZ+ZSew9v/AK9bwfUs/9L+O2zD6TBcbJHdGAcRcEKRnpx3qy8l5qdm hiURhGWRgx/ebuR/jxWMHqjzzI1OKT7Bf6NqVg6TlVuIrjYSSCBxu7AjJx64rze6toYExFEkaNhQ Av7xio5LH3POO1d9D4WZ1PjPRfgjJp6+P7C8upjb28VtJBdXUcfmSW5EsLR5XI6so78cntX77/A/ V2HgOwtIJ0kSy8TSPLBdW4VbyGSCFvnbnopI7/e5r+y/oy1b4XGUn+Xkv8j+bvpCU/8AZsHW7P8A VH9gH/BH/wATnUPhvpWjIiWEqxhbW2jcyQwwoCwjGenyuQc1+rv7R2ni6+GHiEIsbGaxePyieg28 n34zge9fg3ijR+qeJ1ZLrUX42P6P4WqvE+FmEq9qP5I//9Pyz4/Wcui/EPxlcxygG68QTyylsrL5 b7dgwOxDY59K8Vf7fLaJqOlwpcTWPlCKCT/VsSwViVAwQF3HHTiv9buEpc3DeCf/AE7h/wCko/yS 4whbijHPvUn+MmZ3iSzi3nSY7Z7W4vIvt0OpRKZBbMEBLEHA2szkY65Wqlop0pLPS9QvrPUpryLd DItoT9lmOMszEA/gDjrzX1UW0kz4aov3jZXk0yO8m1MRXKK8SLDcwlx9ogP3lIXsTx7kVnW1vPbw SWNxJKsWA+9BjeUPy5+uAD+NbQbaJK/2i5hYqjFJMbWEibl+X19D6VvrLeJp66oLhLz7QhgaLjED YGQw/Hg10xd0NOz0P//U+Ebi1ubsebFBFLG0KyrJDMZZ4HU8hkxge3PatuWyjZbS6fzZmjUOySgq 2T1LL61/tQf4s8zs0yvr2owS28ouEMlymzyjGQEtgD19iAMY9zXPvq63MVsCAfK5BVfLlb8a1g9L ElrS7IvBcyJOXiRGnkWNir23PG44HU4xg98UxIrRre8i1CyEjTEQFwfLeQN09/WrA07drm90+VY2 zb2MYS2idsTbRxhGPJxj9KzLGylfS7nUERUgEnlx3bNtDMpAKD1Iz096d2jlkro//9X4li19RbSL NIulhLcLL9htQ0mpMuFVGUA5JBbrVl0hsNMjkD3EkF/G07RzYjlDAkAbSMgZJz+lf7bxfMj/ABKl GyItH0d47hZLiWFbe4QbfOJQRcE/MeevAp4voriS4gaDy1gYiKVwAH29dp9OK1U+5BVub8yiNOPJ t5BPAigDzHAIOTVCC1knEs6rNaRsxVBIfNRnGCQGzyOfXoRVRlzaGE42uh5S5tbgzJaR3CkKrsxK LGCQCw9celdEsrvGNuba3gBT9xGv79WIyzsBnrkdelWnZ3OGe5//1viZri1ty7rGtzMOInPAj6jN T2sVxq0629tKiSMMGKRvLVRgk5P4Gv8AcZSTP8JqktLlKGzS5doYM+erbZsvtjABxnH+elXTYXpu DYQyKTEnmEAhUIGOp9frVXWxhJ6XZbVL2wjF0FErMCGb7ycHnJrOea/uzsB85ZJQwhhQq4x/Dkcn v70GF2dDqEWpaxCJbdzHHY25N1bErvdVxjJJHT9eK5v7btS3ELzteTzeXEuwuvyjgZ7H60CP/9f4 x8q5ntXuJ7Oe3fz/ACUmf5hO4AyRj1J6daknN3bW8lvNIUuETBIORyB1/Cv9zIPof4JuTUrGXp9o t8yfbLuZ5Ij5UQZ/3Ld/u/nwMda6CbdYSvG0cgCoFjDACFh2IP6VoYynZmLJqN9AvkRxyyIoMj7D iPPuM/SrUrpcxR2zoyzlBcQuuNrZA3Kx9vQ96DJu+4QXBMX2K1MEVxIy7J5iwSPDDeTgEnjPArWd 30maWMMH+0qJiVYlWJGMjvjjoa3jsjObsrH/0Piqe0uJYZ188xNBF9okDHy3k5BGB9DnHpWloENn qqKLpZpCUxFLHIIvN442kgjiv92D/n+ezMmK2ID2zybikrfOxyw5PH4VoQWNrE7b5su6bjlTtQjO AfUHigwGJG8enX8v2JhGkqhZEy0aAnoR6HPfpVVbSWZEnAfyFIEjopIjz6+la09hPZnQaZZaZaCR JJHlnkYyhyMRRj0Oec1nR3uRPCnmK0ibN0ZAU4IPpVnM4pn/0fka8Nvc29hZ2YS0u4kxPIFzE+Og IP8AKq6W7xTR24WSYKpmnkiU+WoGAcn8etf7wH/PTyskuoIpI33zLCmQsSgnMpJwMVHIs0flxpGQ 8a4O1cFhQJq2hW8zzNihMOr4LsOg/wAitKFJbeVpAY1maJofNdfMChgQe3pmqiruxzvdj7C0mMUk CKGV5vtDyHAkyQF4PpgCor+127YvMLFfzNbCP//S+NpdPxJGbj50i+dYxIdj+h4pUNxIBBFuNtCC /lgkrH6nHbtX+9B/zuydkWLeS2SN5ZyxHSNQPvEdx/jUDT2167TIpgaPAEDtv8zGAcH9eaDEbLKH YKFzjsOg/wA4qwxt1VIJcea+GQdsf5/lQBIpMMkM8aFBA4MirgCde6MDkYNXLtLZoYBvlYzRtMQE DvATkqDyOP5DtWkGkrMD/9P41EMsrLHNzI/CyIm3I6DArX+32UCQ2cEaXHlS7Xu/LKyB8Dhgew6c cV/vbF3bP+dcqTzTCZ5VIIj9TgH8Ovao7y3t72a3NkYS1ztN7GFMK7ujfiMDnvVmbktUizeGK3eS OzZxFnaA5y4+ppsiJthSGMxOsYMjE5LeuPQUGZeiitZIntnmTznAVMcohOD83HX6VUeBbXCKjeYj ESqTgt7AdqA2P//U+QryJ/IZorfE33o16E596ljs7qGOCaW2LQyDBeTgo3Bx/Ov98oWvqf8AOU5t 7Fy8isJ1huY4ntxDiOeSMkEDjr69+arfaJLeRltWEkRjKFXUOSpyCDn2qpNOSIIIrUXe/Yn2ZIsq jOdqMQM7Qf6VWlYb1VwcxnaW9xWgE8t75UeAvmMB1HU1NHBJM0M/nDyWXmHHzq3fJoA//9X5OeCI z/Odg6A55qjHHG0rxF2VY2AMgQk88Cv9+D/nHJJYdhSFGZgAf3ndqpFLWB/NuiwB+T5WwCe2fxoA 1IIVbzSZAY2VfJSPqvqWJ/LA/OiS3giha4R5nlDDepA8kDPYdaALkM1qBKism94wEEgwRyMkD9Px rNZIZXREbdKH2ncMKvTk4q4wvqwP/9b5MuLNopZZUCtGqgHy+Rnpn6VHZxpukja1Eksh/duuNy9s e34V/vy1Z2P+cOa6iXLrbvCYwJBKMNjJ2MOox7Zpys8TICrMsh6gcLSMy0lnZSTebfzPHAkbKvlI GlLEfLjJxjOM0kkUcLW7oyMmdvzLlh70AQvCrySpbtLI6S5Ug5872H1p8V3cXBZijRhkAEWDmPA5 7/5xQZzi29D/1/kuOeWBlVSWAcsWKjoexqxJLLf3bzIEsLZsAwgmUr0zz6HrjHFf78H/ADb2tuW4 kESxPJOjxszRhUbD4XHY896rMbdJZWldtgjYgDO4tg7Rj64/KgCtBbOJop5lZAwEivt2lhnggfnV m/VGZHVt6PhxJn5vxraHwoCe2kcBkBYI2PMAOFYD1FSyR20rmIRiRCdqocguewxVAf/Q+TpFMNzM ksJRoyFKYK+WRwB+VTzFS9tOIk3L8x28I54++O9f9AB/zbjZWR2YxbY5XODs+Uc1ALSEfvZZDvj/ AOWfZyfWgCVE8keYgGWGcL2qG4uWULJJw8kgjTPA5PX8KALaLJ5bHcHKjjb3qSNGWWHMw8yRN+1T ynJGD79PzoA//9H5RupD5jqzlg3X1zTUeWGKIQhTJvJ3EZwOccflX/QAf825G1jPHbIbtknmYZbY flHtir9tFDFayi6VzE8ZZBHgHeAQhJ9j+hoAoRxXkWxrlrYgrvZYeV9uev1+tTxM+1sHbg5oAY5Z VZXTeZDjdjlasweYB/cVF2Z7t70CaT3P/9L5ghv1tbe4je2incsDDK2d8R/kahjlZ3UzSBQFydv3 vyr/AKAD/m3GR+RM9zIuVMbbQrjl8VVt5ZSHCquQ3ynsADzzWU1Z3A0EuZi2AN2ByMdKiMcKu005 bYASFXjnHH61V2oXAFVWHmn7p5APap223K7oZEIK/KsYwSw7Co5pAf/T+W4hGiRShN8qNko4DI31 /WoftEQDokZV84xjgfSv9+4bn/NuQxD7MkhRMGTl8dTUMtzP5IjH3Gfdg8YrUCxG22BsFWI+8o5J qGO4kRmjhxGz9dwyR9PyoAnZzO/kThTCfvFhnJHT/Cmr9nRiETc6OAueF/KtFFaoD//U+Tbq3luL lJWdU2cFCAFYDsKjl2xytGkpkjwDk8BTjkfhX/QJzKOiP+bcjKtMmyQsADlXBxyOxqSB4oopIPJ/ eFwyzKep6YI6Ht+VKTvoBaliltwklwjgyLiJmGAfofxqgRJIrI2VAOSeufY/57UKdlYCWCDgNGwU bu+OcU6e7umuXaHe7ooTLncRxg4/XHpVKae4H//V+RoZvIkVJASXX5n6c/5/lWi0syW8iROQkwEc oU43jPev+geyZ/zblZ7ML9mFoN7NxIATvXH86ha2SRZvMfyz6AZDHpWcopbAR2URh3hAQOScDgDv x+FXPMdNkmDJG/Cn7y/nUASW1wF8zap3A4Yg4AHcY/H9adHN5rlVJCg8560Af//W+V3NxtcdIQfv HgNiqaxW8sFxkt5zuMYUFcDvn8K/3+k2lof83ajszM2QmTbEZhJFnfvXah9MfrVr90YHjX73BYng /SqNCjAksZYJgKT+GM1dufKCx+awwx2rxjk0AVo4pFJ4zGhxgcZFaUahE3qBtI4/woLhuf/X+Rc+ YxyADjg9MU+NhIzRykNt4DDuK/6AD/nBl8RTuLdrWSKW2faXOQB1Bz1pHtHSFklkIlzyS2SOfWs5 Q1uhpWnZDpbhBCoDMzKAnHpUdsG2sQdoAzk9RUuLSualF726l/0dpGMatkcnb+VLby7iQoYlH2sT wGx2oUXugP/Q+PHtUkCmWRkBbdtjbDnGDjPao7n7KkaRs0plDlmLPmPBxgY9eD3r/oAP+ccjVwF2 RHgDFRWyFDL5m5VbjB6d+aC4xvoxIIULskefkGCTzx9aS7ju/sbR2soinSReHX/WoT836cfjQJwk hq20+neUJB/rUDq+cq2afcPKYwQMEelAckj/0fiRImO13YxsrZK4+9Tsnf5a/wCsPSv+gA/5xy/a gyKPMUcHHWklYQsWRfMx8pRev86VkaUyV7oQqEkfcTykY681JG+eXyGxlSf4amUb7EyvezK15I0d nPI8InEKmQbiVjYKCSD78cfUV+NP7Xrx33i2W9t2u1tHkaWWG5lDC3KqgVVPcfL168mvyjxnXL4f Y5v+V/8ApLP6M+jF/wAnKwy8v/bon//S/iu1a186Myw4VhwVJwXGapafaoFUZw/VsjgGv0LE/Gz5 ym7wRoXFibNkcszRyjfkDGKzYrhDK3nl5kGRtxtaueTvZFmeS25iqEJv+UkZxUctz5YIA+YdW9K5 5/EBNbzbYMSlSsnIJ++BVfdbvMWjZl2pgIRUgf/T/iA+VP3gDkpkbSPlHuaZ5sz4wjhpPlUhfk+u a+wPnzRETRxMPusnDfLjcfWpNPhiD5f5VcdhnJ9K5yoxvuS3KRbvIicK4bcQBjHuTUbmNNisWcLj d234oNkraIsNcqY5JIolgGdscedu76VnMkzypkLg9TnBOe1RNaBbof/U/iUhkktw45jTPQ8Yq75Q utjKrN8uD38w19AeelbRFm3svJjMszRAZP7ouPMQZ6ke9WLd4hKyFFlDYZT1C46VUUm9QKWqBpZ1 ZssxbKr1/OsmSa5iXk+UHJWN+qgiq5UtwJbG9eIxztIGljPIPU471YknXzBI3mMS4YxY7etaWtoi ofEj/9X+JMmS4eRxKVZn/dwZ+VQKux3TWyeQHfe3LlThcivpJ9DgfxMh3Svyrypg4B7Z71cW7YRN Cqo8jDazsMsuD1Hvx+prMRfginMbmK6MLeWRKdxVmU8FffPpVOW3t7U7oTuAUMdxBYN349KzqdAK NzMLxmlRhBJnDRouEOBg1XgtZ2jYopYIMlugFZmc2j//1v4pbazElm7yoVdm+YnggDtipraylu/M MVqwSIcMwHz49K9Sa6nkxbTsU2sbmJ/tSTGONCVliAwSDxzUFyjyybx+7iOArDpmszYikuWSJLUe Yjq255EOMjsKIp7uNkAzJH3LkBiPr1raMeVajjui+s32kSvCWi8sbBt4J46Zp0PmrAyylgTn5n4I B+v41Eo21Ruf/9f+KGKPyZme8Ltb+QW/dnG4c44qrBOYXB2ERyHIXHAHrXpw3Ocu3LG4DtGVLbdh DjOB7VkxwxkOkRVmDbMsCAG74rUTWlizZl4nmjU70j+WTPy4PoKuzgSxqixjCc7s8isp/EYDIyGj AC7SufmxgmoFnKuqvC3XAbGQDUAf/9D+JmUSAFkJwT8wPI/CrthLAkqCVlm2rzHMflHY5FegeeWL pRC7TxRwrGyYzGcgDjoPfvVLyI7mWVZpVil8sBAThn7DH0FBKfQsSRR2kYgZQBtyHH3ue5NYiIzz udqNtk28jHy+tBR0SJHabonT7TDJBkMwP7skf0NU50dmRJFART8vHzY9KAP/0f4phDC+COqnAjXo CO5rHvtxDRohIBw5Xjbg16B55Ha2skibZpHKdI8DH51FE08TPHIVRITwrZ3Pz0zQOzNWG4llUpGd kaAssQ+62ep/SrTwT+QJGy5+8FUZwPQmgGmtyvFukPmBfnI2BQct9TUqednZvywb5jxwPSgR/9L+ JueQx7zLhHQ4jlB3bqq2hkSV5w3yyjaqlslvf9K9A896Ir3b3AlDtlYxwVQZNbNvte0V0QeaeELj n/61JpNWZg3dltI7MRw3LRzNOmVuI8hUbH93/wCvWjp7q0b3M4dVZCY0x86+nBpOKYjmXuxendJ9 1Xx5bDGCDWnDcI0LxAA8fMf4lpqKSsO7S8j/0/4mZZDCm0KSWOTnniq6Ao7SxR+YikFCh3MD34rv SS2PLprqaaXM7uwjUySrH+8Q8BOOv4VUZQmx0BkZyQVYZ20xWfMQR6fNHC0kMzeb5hlILY3HPpVu J0LGVc+cRtIkXBU9DQaiyNNEhc5EgHG3r+FTQ30rCNmY7guxQOuen+NTJbFcrtc//9T+LcIiW7CT bISd4XAJU9sVQlhWVVuCkax7grGT5H+nr612z2PPGTIqQOqEYJyo6k1mLa3UQQ5cDG9QM+W4NZqL ZUVdmvpt1d28iSxqY3QnEq43KOnSr6Xr3UrwMHnCry7AlVz6H1rZKysbW6GNLckXAgjwiRsfMJ5Z /YVUuPMcsDnZ/dz1pmFtbH//1f4n41WGJXhG8OvzKSGcfWnQFrxWj8lWCjDF+MZ/lXoJJaI57W0L 52wRIqMHlVghjb5lxVR7+FJ0hbzQB/rTGMqn1FBE9hl3eKxUxbng3EE5wAQOuKmsb24dGWZAYAx2 SK4GB2yKDIyXnmimlMSK29TGMjIGcc1ct5Ge3MUkrKFId8HCk+uKBNaWP//W/ignjEzLgxsSnyy4 CuuB0qSKIwx5YbY1/i9f88V1S+Jnjl83rzW00EX7s7AV3DZv57GsAfaEYrI7q4G47Twfakld2Akj uluHMbjIC4zjGR61I0MMG14QdvRlByTVyhZaAQyJ9qBQh1Qc7uhXFUYGLS+WcDaNyn6VFmB//9f+ JVAzptB4ViT6k/5FPhjnu5PJjXJQhiSudtdB5C0YzVbCRVjIT5y2HJGGNSWq2yG1kneWMD93Kp+Y OBng+g/Kg3KxiDu7KWaJ3IhJztHPSo0sJEO6QnaxxFsB49ee1AE80UFksezCluSS2WBrStLmS5R4 Y0YEDKgjh8Ak80AvM//Q/iiufLaNVKRiRfvYGPxrHURpIvzCVlBVYv4+e5roPPKt59oWQDylBVfm K/dNEDzqEknUsAx8tT1/KgDVUPLhlj2EcletCqLmVkIEPkABj3OfQVlPewFG+t5Ipd6yGYY2iRuD j0xVNRJg+YI3UjoOGBpRlym6VlY//9H+IzTkuSCdh+XJErLxj0FRX8jeZE8eN4yrLjjj3qnJvQ5y W3u90ci3CjKLlXVfmPPSs+6lPmCaJAzEbFkPVfoPWpJ5dS+uILYTkBmb/XZX5xn+lZjbRKIo/nWZ hl/4hnt7VXMyFFqWp0Npf2dmjrPamYIAhiRdzkjgY6/Wtq4vES3My5kJA2x9GHbGPb+lJu7ua2P/ 0v4m2ljuskrhwehHT6Vc0/Tm1CXyVeAHB8syPsTIBOCe3TFc+xzkMk0cQdJk2SplGYHcvHGM1Q+0 wlhApwvUDGBmt1sBl3MahXnuJ9pLbElC85z0PtxU1jAZZlQosg6mQ53Yxxx+FZ81pMd3axtvaRWk LR5ZpppBIHBwFUcYxTJZDLbvbjIbZgsQD+FKL94qUk1Y/9P+Iy1tTGYWcBSzbUfOMkc8e/Gfwren nnkxEgZgeJUPPmjvmgmKW6MZ443uGLWgtFjYunkklST0H/6zVy3jjlmEUg2989M8UNpblGZqUSA/ L8+MhSKrWtqrBi5KyKgdDjh6lNXdgN2MySINoWNoiCkitgg/Sq8zyNqOHy2VGWzy5rJ7gf/U/iMv VkiLeXGyzK2UJ4X9apJNcEmSRQ0inLvwNxHp9K5wHWzTXTSPMTGATsJ+8APasa5gkupFVIwFMuRI VJL846UAdnqMU9vaWccpjPlRjcjSh3jXsMdu+QelYrIc74gBv4O3girULq6AjmjYTEW4eUtHtPGD TlYwrvcgeWuJAwxxVxjZagf/1f4b7bzmnJjwUL4U12CLDcGTzVWIrbCJnHy+aemcUAZi28UPmRST 42jMYb+P0qi0UhMjA78cDHegibSViuC8SbzlmJ2qGPK1OrMxWaX5wh25z0Pv+dJq6sVHZFw3Fqqf wwZOCerE9yaqMkd07+W7k24DvIVwjD2rFxa3Gf/W/iLaNktY2j8/y5H29N2D3NRWMMcdx+9kG0EB VJxj61jGLuBeKT296DE4Ksx2kHnms673yNKsUaRyn5S7nAYinJWdwJdNiJi2n/XLkE5+Vj6CmXcE pONgjCjbIpG0H2xVxXuoBlrJZ2qzfuS7SDYqtn5T/eX/AOvUwCvBIEJLK2/GM4qgP//X/iFsbeLd LLcyPiJDJGgXcZGOBj+v4US2z20gS94GwSIrfK6q3zL+hoMp7l6KeJ2aIJuTaNnPC/WrNnK1vMQy LCoxucuCuP8AP86mTsghpI6y2mjvJoLaYkwSOE/dck54Gfb6V+qv7M+mWVrpslxdx3E8MLwaVZGO L/R3IjhMglbrkBVxj/noc9Of3TwCpe04uV+kT+efpEz5eE1HvI/pz/4JRaFPD45j1OGyhkhulCRr byF3tkJUOSOgJLLj0AFf1UeIbptM+H8ezfI0dr5LjdggOjDr325/lWnjzJVvEajDsoo+08CIuj4Y KVv5j//Q4v8Ab71YXfx18TRW0yyNaWr297dpH5krie7cxhSOgwjbj6ba/Az9tm/Gl+DLib/R5GsR /ZWkJbjN3crNOjMzHPO1icZ6bj71/pjQ/wBm8ME2tqL/AAR/nfgIc/jBVt/z+PyCv7y5vJppblDE WfOwn5jjAwaksZGi+9ja33ePu/Wv81sxfPiKjfdn970FaMUb0cJlmFywcRogjdwuI2aukh1OWMNZ hk8l4NsCAfPu5yT+n5V5DVjpHI9/HfaXPcXEzwWpBmiKAxyqP4SK1Fk0q6vJbr7KLR2JWFY9wQAs Sc5PXoPTFc9TRsqKbZ//0f40IbNQ0khCujKBEVYgKfU1RlhS0muMzTzbv3cojcmHt8o9R7+9fPnM lyqxdS+K28bPC6Kqfu4oUJZx/jWxbTzwSm9INvCYjGUY7pmUjkEj19KSd1cuHxGnMq38ENxaQKyR OVHlHdKr4PzH2wSOPeq8sVzbqsk6f6KFy93kBUPdT9BzTNVe7OitZlkA8m4huIGjUmSJtyKx6Ln1 qtLco17DCc+ZFkKEHBJ4wf8APesHuUld2P/S/katLnTbmO4iCS29/DMRMskRCsOzbj61ifZ/Junh uTHOsgyGV/MzntXyKje67GkY66nQ6dZTTtB9ljeaOKTYViPyg9OfpXZ2UEAW4ikuPsFzKgjEi/NK 2WACgjoec/hWVT4GVUXuH7Zf8EePDMNt+1BYXMrX99LL4aZJoII1IjYuUR1Pr8vPHRie1f3/APwp sza+DdEgmR0mS3y4l+/k4yT9a/CM8/ecWTt0jb8ScPF+0V9v+DY78JGlwy5J3clvSrAkRM7e3HTr XoRelju5Wf/T/LT/AIKbeHb+y+N+salDZGwW5spIdJtZAJZ9RS2ZG2T5/wBW4M6+37zr1r8ctbtG 3F3SO3vlJknMUm9FJ5x6cH+VfAcPU+TLacex5WKj7PDxijkZ7VtQt5LWKQWl/cAxNqnleZLj+Hdn jC84wO5ri7G8kxc2SXMt0+kv5TtIpCk9GOPc4zivoFHS6FKb5ImndXkUVtaJcFJLid2P2eFCvmgY IwvqBnJzWp5EC+XOsYiaSII7qMPjB4Ptyfzqowb3E23uVorO0hhCFd6xuWRDwY85zj8DVRoI0geK 1SOKzDbnhkYLG2485B479K0SS2Ef/9T+M4znWzeWk4W3uNFlVYbVU2wYcZXaemAAORn/ABqR2c9t HcXc0JjkRgkUi/NCeDx+P9DXkJXdjy05NkkNxJ5ccq4hnVNxjzlUPfFWdYuZr46ZFclprSeMQ5S5 JlA7LsB+UdemOtaciHNPoXI4LXzGs58GESD7Qwb/AI9xjGVX1xVXTYNFjManXLmaa1MxFk6LFNN1 8va3IJPfI4569azas7GdnexmRahdQu632nyRPK+xtzCR4OflbIPORiuh+225gCs8isFCQ4AKdeSa 6KUTWV0tD//V/jlt5GmnFsoch+FLH72f5VbstQt9HuLj7fHd/uky8Mce4IAfvH/PSsYL3jzxuujX 9WsNSv4bZbfyYhNbIJg81zAgAVmDY2hsY74614Rrd5fXbedsl09wwJt9waPKjGVIJ4OM130NmRJe /YPATJB4itJru71CGCXVLeO+ezJZ3iaRdygd8/1r+iL9n7UNUPgDSINNBW11W8murVtUgSSadY1j hDg43LtETDgjIzx6f159GGtfE4yh5J/hY/nj6RFHkyXDYhrZ/jdM/ro/4I9a4ttpkkc8Ihmk87TC iDdDHNvUgq2eNwwMH3r92Pi/b2t18N/E32yEuiaO42L95XKkIQfY4/CvxnxijKn4jVZrfn/Jn9Bc B8lXwrwa3Tpa/wDgOp//1ub/AGovDunWvxW8UXz3lw8kl6DLYm4EdihOxVUEg9SX9Oor5+ns7vSL EWunPDPeTo10whO/yNgyY9x4PA56+1f6y8DVHW4VwU3/ACL8FY/yd46pqlxXjYr+dnHXX2l3tbme 4YyyyBLjOGTB/LgYrBvtVhaWGV5VhgM4tLe5ijAigdcKoYD7oOOp7/p9pCN9D4CuvfbKeo6lcw6p dpaWhMimMzy2xV2vMgfvCfQc8nsK6S407VRbTaoifbEFtHctDHKuY0cKMAE9ckZHY1vFW0RgcpFe CO5juo1c2t4pFxFMN7iQAYKnsABgj3q3HdGG83TGK0sLwhEVGycjjJXr/k4HauhK2iI5rSdz/9f4 KuF1WO4txpmBC7OzjzNiNgZHzdOeOtb0un6pZQ2v9uas9veXUqzvLphjljto8ZCgkEHAA6gZz2r/ AGqUb6H+KfOYxsNLso3uL2W91WLUb6R7QvOsE1xMm3l+OQBg7f161sGy0678g+VbWzRwGHzYBlyG YliRnk9B/wABFaxXKrC52YFtO+n6h5MttJNDE/mSwMGjinUH5WfHY5OD/tVYvNTa7mFxDbQJCJ/m s0VpJFAwVG4/U8n0qkr6ITk2XdGs9VSWFFeK3t7xWnt1nIaVQC2dwPQEqRg+hq7H57WUUWpTQQQT XTtstpA6ZDDLBexIAPvV+zMnNLY//9D4Pa90867HFZvJJBB80dzLEUjldRnYPXmr+vXNg2oWUsdx MfMjRZ45VzFBJ/Ftx19fwr/bdJRVkf4lykmrIuDWWEE15Lp/n21kVV4kcCRiSQGAPOO5wOKrXjXW qTWwe0WCGyjM0a2zZMoYbtrgD/PPpVWZDd1YvQwRXiramKK1uJLc3cECMWwFOG5PPB4weay5HNkJ POtZrmVcxWZgfdFI2BuyvqOBmtIRa3MJtXJLu9nks7WK4hNnKIVMzRPu+Yc7T/L8K0rKa6tNNe7N s9zBte3Yv8qgSKV3H1A3fmK0Su7HDNdT/9H4Yg069W3N7brHPbwxGWVTMDIUXhic9/1qzps9hcwu 11JcKkseFaxcJIr5+U59M9RX+4fIz/CaUejNaa7FtNEoiMzqmwkDEij1IHJ65psK2sFhFeWt6bkS SNAWb5ZMr98EH0PWq5NbmcopaohlvPtSIUM7WEQ2OYj+6L4G8Z9R6H1qvEk1qssgdgmdi4JVmU9e f89as53BrYX7Q6QQ6hD5q2Ckq00lwJYrgHgqT1+gPepLS7Szv4rm2thBHKuyGOR9xiZ125/HJPtn HNBB/9L49Oo3lrcsRIsiQTgOgUMhYE/4VFqP2zV7zzdq24kf98hG0AY/l/hX+5B/glNWZmqfsfll t6Qu58thGzqT+H+elaN5eNfRLBK7RtFGXCsCGfjj3H41ur9Tml8TKMWphYGElj/pCKEAIwHUdzjv UlvNC9ulxIHDSOSsQ4ZV9z2pki29sbExXi2s8izv5UMkrAhO/wBe3WpNUjuFdLp4fMt5cRgWsnmy ggcgjHbnpnpWkW9FYzmj/9P440WwW8tuWnVUdgouiWncZzyTzjnirsuywkKMm1IwAsY42gjIx+HN f7sH/P8AlieKxCLKtvtMygqwkw3PJJHSsGS4jhuyDEJ0ZNirv2MvOc5/p70GcopK6H21tfX8y28V zOFZiXg8wJbsoGduCPUHkmn+Q9hMSGZS2U8sN8vy+oppuOxmPAM28Neb5ymLgY2rHnoo/ACpII7O KIoZFkKHcrKNrxkHnJ7jjpTTs7nPa2h//9T4+vybq6imtHWOCGEMFWMBrhh1Gf8APTtVuyUXEUzm aRJJEJEZPlxqmCWyQQfTiv8Ad9NNH/PbJ2ViKLyZZI9PJKE7Y7QhfMeZycBQvvVS5N5FcSwyswlQ mJxICsi44IIPQ8dKZk9SrJNJJHFbyMsRSQurxoFJ6cM3U9P1q8n2gSRFnICOMZAZT9Qe1VF8r1Od 7m/LOFEyXjCS4nkH2eWHbEN3ptAwQRk/hWRdsiRO87eWrfKH3YPHfNbEOSjof//V+PGtvMitWScy wRxAHYSrqPTJHX/Gn2flqtxLbuViik8oiZtzkkZweMd/Sv8Aeg/52ZO7KUyodhmVUIGwbOF5NCLF G5jjCkyLtLOOnIOQex460EXSdiexZtPu/MG2UJwu9BKh4I6HINWJZIhvuJFXYpA3KMnJ6AUDLElw v2ZpE2tIhGyFgQHHOST7cce9ZNtPJNex+aXUMdrsvAUUCbS3P//W+PZLmEzSQxHcY2xk9cU9vs/n LIQdzJt2fwbgMZ/E1/vSnZ3P+dOMkm7lNQySN5p85iu3vt574/z0pbW3NtKZIVLAE5PXr1rRTXUb +Fly4VZygaRoiG3fL/F7GjMrkgEsFGGbqRVmQyOMBsKeQchj1JrSZWdWnurgGdyzHjJ4HH50ET2P /9f5FtrmS6O7fuZPljKn5So4FSySyKixyMYx5hJJfK46civ98D/nHKVzMssapbN5sfmYZsYIxS5E eAMozEKGPOc01uBY3eQpj85yhIcjnbnHJxVQSpJKImXzN+XJAyFAx1/OtmBdSCJ5GcIBb45EjDzM +3H1qWK3cJvABiV8IFbJ4qG2pgf/0PlR4FkizvxNu3bDwVGOKqwMbdmEhwJfkZc/f9Px4r/fg/5x wlTZIQgJdeArdVrPnYuwinjVUU7yWHQj3oAtJOqRIY1yOmVFNkkeSLylLKGOSM9/XFAFtLdSGMUi uYI/MdmIjY9OxPqcVTkuoxJlEHm/dYqMAGt4/CgP/9H4/aKVLq1ebz9ksoCNHnDdCR+oq3JBP5Vx cwZZIGG/c20tuOABX+/L3Z/zj26Fm2eKCRXWEO5TdJHMN4O4EHHpTyFWMCQ8k5X/AGR6UiJJcpFc XdrbqkayJM5QMRsYAH+7z6e3FW7e4gbymmRZB1MbcLj/ACaDIqR3UdneM9snG5jH32g5H9anYCK3 muUnzKzY8tBiQg8HnoPTFAH/0vkMXEbLIpJV0G7GPvf5/pVyB1mQGE5crwBX+/B/zdzRJY2oluil wdskQLLuOF4B4+vFRtZvPeSMD+5b7q54AA7/AI5oMy02xXjVmYiFdgBPAHpioJMTz7EBCRtx23Dg 0/sgTm8MStbiNfnIHmbclcVFMIJGhbEiPEDkq5CP9RVRburgf//T+XJ7uO4hWBYY/wBwpKsihJGO Ry7Yy3AIAJ4zVa4ZIooJY13vICGIbITpwV9eK/6AD/m3INhyHRfmxz9as2MMl686So26JPNYggZX oSP0/OgBsrx27Rq3yIZAu0sNzDuAfWoLuOCXZ5cjNhyVBH3aAJog4QqrYKjj1qrdGUxJJGSkgbaX AzQB/9T5PlHmPBIeAijcWGPOP+P+FSmaOdm6IAeQo2Y+lf8AQAf82466u7d51jt0l2iFVkZh8pIA DY/EGnWzK7eTLIEjboGHB/zzQBJIbOXdAgyUYE5OMY//AFCqU0W1tqEgEfgKAHvHJFDE8ksTqTja pw4/CrQmiaMdemMDtQB//9X5QNu6hpF3Mqvu+bkfSmmIPIWBII6r3r/oAP8Am3Joo3+Ysm1e+Bz+ NNZso6RQsWjO4beABn5iaLdwIEu5BcBAqAEDbzyfWrWx7rzI2PlLG2CTxnoP6miytYCO6DRmO1jP mY4d1Py1TuLGaO28uCUIpYM+B0+np3rJwe6A/9b5OtZZo4lHBC/L8wzu5qditw0rqNhY7jx936V/ vynZn/NuFpFIpkTzJbokbgZtueBz0AGOP1qC8wLiIiPZGyBZcsSMjqQK3Au/6PbxE2saySu2SzZ2 9MdPyqGXY0yzFF8wLjCLgLnr0+lAFS4jlLIFJy7ZQL1NEURTe8jgkA/uwPnUjuT75/Q1UXygf//X +SUJnUO8gBh5x03dP8/hSqIZcgnBb+IdRX/QAf8ANuaa2cT2k6QuCyNgknLZ9qzwiW8fkspaQ4If d90UAWPsyyKkiFztGfmfcCapiaKTcBuEu4qVAOOKAH2wEbneThuCDnAxnnFSyxTW7LLb7SzgtkDO 3r1BoA//0PkaaCXCyM6MzjcpxwD6Ee1XZEgQRmJpC3lgy7j8obvgV/0AptbH/NuOh8skgy+UCCCe uPy/zzUSeSCke/zDDwC38Q9TRd9QKsryeafIITLYZexHcflWhJKsMChgAOyDgDHoKQEUKrMxMaFC 4z0wTgdTTkQxKzfKxz27UAf/0flaaRDEE3Nluf8AdNUVcW5IHPHWv+gCx/zec1ooYsMSsZ2ffvXc OOF9qr5hkmJMmzYmQnOJDxx/P8qCwkEb4QMyN0IpkgQ+RHg7IeGLDJz6mgDUOJ7fy4Au5evRW5rO UTbfKPHOCR2oGnys/9L5Glgl3xooZnceWdvY+hqobKeKRsyESRv8y9iMdPw7/Sv9/wBtLc/5wHq7 klzkRof4lGfX8qqws9wrByTk87uCQKjn18il8ZbeFJGAUcAY44pFgfzTGh3JtIYg8DH+T+VabmpE sCKQoA+/8p9fanag8VqVRomE0jBI44ADkngZoA//0/jaeF7WWPcd0nlgsmclM9v0rPnkcuiIBuZv mLc4Ff8AQAf845Y2iEkscgdCvQ1KWluIWkOAkfyjJwfoBQUpNCwSAgf8s3xgq3U09Z1E7wXCMsg4 j+XIkPYCg0UkytMZwd8yHYpwg7DrUts6SE57chD1oKP/1PjG9jkmKSKyRqjgOAoGR06VVe2JWUwh i7HiRBzx3r/oAP8AnJk7vQvWM8flFU2tJnZJ3qN4ZYrkuMmLHOR8tCaexVPqSFoZJkZ4wDGeHI/z 6UrSPcXZCAuztgAL6/Sk2o7lSjdFS/ubmPTr2FEEXmr9ncTjYWBPYH6dfQ1+Nv7XsSL4hvZrWE3T x3TpEgn2RsNyZkAPBByK/KfGv/k3eP8A8L/Jn9F/Rhg/+ImYdeX/ALdE/9X+KKQzq7SXrKSTkRxH IjH93Peltx5EreX5h84+YC53BOelfoeJTc2kfN09IF+5Mgtj5ruSp3gHJX6VzjzD5pFBMhGNuPTv XPNWsXF3VxtvdGFQGHmhiSUPaqstu8pkZScffAAyMf0xXNL4mMafPxs2B1244+8Kk8hdolU4kUZb cccD0FTsB//W/iJkmimO5ECJsC3K9QcD736ZpYzAxKxSu0cagq5GFyO1fVufRHz5egZJd4OWLLjn 7oqNoJbTdsfJYce34VBUG07GdDIXdmmbY/8Aex8r9q1I0haOUFlcrgbs4weuBQbFZHwyCRVaBW4Y jkGre2BmLLGVQLuU5yM+tTL4WOO6P//X/iJkM07lI2Dqx5bIwuKuRSyQxGNZPmRug6D/AD/WvoDz ytGG86SSRmd3wrhmP4fzrXgeOEkhTuXtyc1cFdlcrSuyeWOZ41vGZUDZVIz99MY5x75/Q1n7WdCj JuiAyoK5BPWq5lexJmsowpICxq3OwYZD64qyoZ90hbYG+6zdcD0ok7WsOLs7n//Q/iUw8bLLtLyE 7UIGAe2ac9nNIfPfOE+YMPu19C3d3Z55NBO7r5Uacj7zEZA96ElhhndD98AZJGCxpBsXWW4fcYnC KE3A9/yrINx5cZZ3Zg52MMYNZ1OhnKfREikAxuMJGAcgryxpsTyEkCUhN5wi8DHbFZmZ/9H+JmSa W2K7ZTIMbmQnkZ9q2bfVXhgjAO0nnaOpz617B5C30Kj3Evls88yGHeWRcbdv1PftVZby3nxuXHlt lEz8r+5rPkszcapN3M6bY4geFJ5IxSnaCEYBjGflbs1aACtGo2opjaQ5Kf3T3pZN8riJHLMBlieF XHrQbp3Vz//S/iamkLiOJgCEwobPH+f8KkKROjxeYu5BnfjkH0FevZJ3OcdZW/mCRAxMkYyhzwe3 NMt7Lynk81huLFlGMEn1xQ9EAyKym+0y7JFIKgkbsO34d60ZFVEKBmSTPQjqOlYGMlZleMlI3hGH cDcjE8A88Gq7SM21chedrd+fagk//9P+Jm4nZEjXccq/THDcd6ULCZPNMSsHTy3/AFrucklc4LO1 xk/mwfJEN0KpjZnOD2xVWNnmmhDRMszcK78Drx1qthGm9z8skci7pD8hz1WkhSJQcoCzcc8fhQWo Nol+2C1O8MNnK7Cc7KzLy9kujHOkzxlflMbAEH0oK9mj/9T+Jq2kkijdygXceS55z3NS2iJBtMz7 t53k4+Y/hXoHEo62Y/zVEu0YKA9ugoubZCquU3LIcFkwdvbJ9KC2veRkTqbWZPs7u0YYbucMfUcV sx3cyRt5JZFdCrKDgkHrQRPcoooVCEzGwJJy3zVat3ijfJVskcyNwoPvQQf/1f4mrk26O27bMh5x /Oo1iRgFB2Mo3IuelegefboZ08hDSrJvWRCBGBg7x7Vp2drIURt7hyQyr2B+lBzl5w6MIiQDkE1d nvEKfZ3BjwmFmDYBz6UAYIt4tzpC/mIvJkPy4bjNVzMkcvkx7i8h2gqM9PWg3SSVj//W/iUzmUK+ 4MV2rkYVzWhaadJaykxDKyJhznpzXoHnpJaIR4xbSOo2iRhyxPWqCsSJmBIdQQgHTNFgJ7bdJEwJ cSJwpI4YkdjUwSeBfOYRlzjJbt9KCoq7sOmkmnBZkjKLgKVbDr65FZEts0GGjkZyGyeeBSavY2P/ 1/4mkuWjkR5FJVQOEOd546U+WSeYqJ0SOCSThSwPPUV3tX0OGUeUuRwbbkFox8hG9j8wYDp7Gup1 y+065itooEET28ax+YkIjRsDoVHQj170yqa6nMSssEWQ+ZGYEKvpSLK8SMUYxh1BKKMbvrQaPRXK scWwNNM3mFm+XjaeTxWjLbwfZgJreRZZeYnLFRj0AoML63P/0P4oIGih2QnIwfTt6U+ISi73QYjt mz5xfhRgZH5+1egcjmlsUXnxdqXyCCSvZT7VNcAPIrKFXeCrDPMg6UEylfRE1nYxAbDOW3ZxG68J 7Z71NeaRAkaIly0A64D5DEdyM0EEdlp8siMHYCQDAIGQ9aFpb2DRMl1DIsnzLIhbGeoHHvQJuyuf /9H+KWZIrYkyrtKj5B6DtTI2lcOXwkapuVH7ntXVL4meQ3fcWRt4EzcYGBHnGD61G8sLhUIKykE+ Z6CtUuVWEZtxBJCgmTHy5GARuf8ACrNpL54RWAUN94ZywpgbEUIIcTxtF5ediqeGGOCay/IAZioU EvjGOtTJe6B//9L+KB4ztZocI8QyVAypPvVnR5J7NC0jqXbJf5cHrx+Wa7+VHkRV3YtXhlnw29Nn 3tzcbsdqwTLGA8W5HL5UE87TWUVd2ZuXbSFoLFQfKZpXYqu8MUwe46j8amRwfLh+Xz3IURId5X3q QIVtYnmMN35ecHZ5nIX3NVWt2t98kUzKV+VE6I3agD//0/4ko54h5i3bqTtwCgyGPpmoZd0UTzxo oOMO6Lkgdq6Dzy4rQvBuMm/y0DMduGbP+FZYnUsQoJAPy5FAF37S6L+7LHbjeAPvZ44qqJQztsLE 7tr5HzLnsamUbgVp5peYRgiNwWKHdu/z/StN7VZPKMa/veOB0b2rE2i7rU//1P4ko7poUliH+sXK mJhgAd6ggEYjLKdz55D8Y/Gg5yn9ojmDIrZcHbvVdq/h9Kls7OVGLcz/ANxTzg0BdXsXbi0nto/n aOW4ZctEWBjGRx0qO2jtp1HyrFMrbXx2IoAia1mt52IAkiLbt7HJ5p95JexbIXt1QOBskVtxUHqe vWgLH//V/iHDoiKokZihyc9T65NTxyND+/gjIPUqDw3vWSg+pzkN0z3odkV4jFyUxwevNMs44ZEZ JWIn3bkJ7Y//AFVqlZWAfcJG1uxI3LC2TkfLkVVs7qWNRIo5UksAOcAdMUuVXAvSX87hWkg2bBkB jhpAen0pbNZJpx5UZMW0tL83+rFZJNSsB//W/irt7i3LpbOhkh68jhSPf1qa8t4yI7iynkSWLJEa sAjg9Mnr9KmSbasYxfK9Tn5L5hCWnRoNmVk3DLk5xSWbT7QEPmmT5xKTlwCOBmonubGrb2saQM05 YyrkofQ//qzWWkyq5t9qxdQJSRt56VAEMPmtEYossy5V/mxt9CDWxEyqnmqY5pYwFlYYzkdqAP/X /iVumnvXiDPHGyMdwU43A9sVDcQ7JlgVGceSZHlQEoMHBBP41zgZ0ojDwskhJd9jR4PyAY5J9+as yTNblJIigKEFD/GhHII/KgCwxtp42nnCtcSp5W6dtrMSc/qecVDLa3FvCrORGM434zxW0PhQFRrq 5jZGt7gDZJkvjDn3/SrEbNdrI8kXmKeA38JPvVCbs0f/0P4gbWI28yQrszIxZlByVHb+VXr54mjW Ibi6sCWzgenFBEpWdkVZIyIyRGXZQMlhkgf/AFqfZxSSI8254obQiSZgm7f7f/qoM27u4zUYbQqv lSN5khMisTj6DFVLC2imt41lY5abdKp4DbT8v8qCo3VuwXaRI7JIuYy20Ov3R/n+lTwYFs6wqzrF IGbcceYB0H/1qDU//9H+Iia7nmQRqhjGP3Sg5VTVe30+5mZ12ybwdxY/dI9RQVGPMW5kvLWN1SB7 iWJd6SqceWAcc+9UkW4mMTumQAd4ztKkjripl8LNIxtuWraby/3Pl7ljk8wy9CCKbql8l1Kyj92p IIWM/Ix9B7UQ+FGVnexGN7cLbgExAAg5x05+tTBhaL5Qb95MFRsrkrnviqBqzsf/0v4m5I7KNWt0 aWTegdpdu1gepx7A1NdWsuoos4UXFw6hD5v3zsAVOnsAKBNamFJYTxLNO4aIqPLljPygY9BUSAyW boNxcfNhh8reg/SonsTFe8ztPCUD3F1bzOlwbi1ZJdicwQAHG4j8a/aL9nvStPt/A+meVFdNqGo3 stzcBpv9HQKkTFtvqS7Ln0XFf0J9HeCnxTN9o/5H84fSO04cpQXWR/UL/wAEedBubm+1nVWgngN9 ex2VmWGy1UgwFvKHU8HJI4zX9H3xhujaeANSSJUTdp8tuHGVcLHCd+0epHNeX4x1FivE9QWtuVfg v+CfpHhFReD8LYOWl4yf4tn/0/n39p3xVd618dPGEem6askWpCbTbUkmLZCkbQpI+epBklI9xzX4 G/tlQXWm6bpqnUHvLEyXIcSt5+x4LiIIqtn7reZEfrmv9Ns9gsF4aNdqK/JH+eHBcv7Q8Tqta29W T/F2PzVvhI9w0k8Yzjcu1do9uKswxRskYk4YncYx0b8a/wAzsXK9WbP78px5YJHTWj+ZDHbnCxsM AD5QuPankG1ZZI8PsbhgMh/UV5bZq42djt47a9uNIi1IQxmIHhi6+d7HZ1/SsaIBs/aAjN5n+sfC MCT3rnqdTSKUVa5//9T+My2nDo1tt2rt+/0BHt/ntTplmtkt4gqyZk/eMfu47Y9/rXz0ldWOcvo8 cyCGWQrIrfJJ1xz90+g/wqpeS3bTi2EUqxqhZZlw0LkHGODn9KIqysxrR3JrK5vIYPLeCRAzH5d2 3Az1x79fxqze3NxNYiCMRXERm2NmXcVP8Xyj8uamTtsbJW3NyytY1sRFEPJUEOqJ8m4r0yP89aLL NxchoNmYH/fMWy6eoPvWRrBdT//V/kNupZUdnh2srLslQjAb61FbRJlZGRCynKqBgR/Svk4O12ze 2x12k30WjwSSWyP5lxPnI4xz8557H2rp7K1+03p1KB5YluYRHbwyKs6xSg8syjHGD046fjWFT4GV UXuJH9Gv/BC/w22qfE7xl4gt7TebQR6Wi3MuLyzcuGMiE5IR2kcKB0HHHAr+5jwtZmy0XT7aWQzX EUAEjj7qnso+gwK/A8deXFeKl0XKvwM8HLmqzT6afr+p0AgG/ljuxmhossAcgd/avQi7M9JH/9b4 q/4K3aDqOk/F3RZbiaO6TUNHvbm8mDh5maWVV8wY5zmBM+i4r+ezxBLPbX15DdwvO8ieWhgJcRvu wGwOSvv9a/P+GantcrhLtp92h5Va88Or/wBalG1uLWx3nUAZUiiOTDKEZeOOcdjXmzm3kklhtvMj e6vWlZ+rtu6lj719NFWWhDV4RHRwvaSW7eWWa1ysLyfvMZ4PJ9a6tLj7HY+bfJCXlAMCrISGB6fj 149qoDloLwz3UyXMkgLS5hVUwwB7U66tpJpxZT8WUwyC7bBk8HJ+n5Um7K40rux//9f+K9bqK2W7 tVmlikgjCvJguzKPu7Seo4rSSe5nMCm5cwKfNMeP3cxAwN35/qa8WMrnnluC70zUZreGaM25ubg2 5eEYWIjPO3sDitK/01IZhbxxCWG2XK35bDegCgfgfwrXnkBjyWckNtK8fmXO8EyODiQ59/60WrJZ w+UkMKyCIKvmKGMQ4yQfXFQBHIZGaRwfOgVl2ybcbieo/A5rfjgijhSO52oXG5dh3KO/Xpn/AOvX TSdwP//Q/jgtrzUYr+NbWxSUNII0nZvLVF7ljjiukl1i1X7cs8Ie41JEgvHLhxES4K8cnHy/rzWc Oh56XQz/ABRJvH2qNiIF09dPly5UquMYRB14H6V4Rqd3bb2hdSyDEaMW+b29a7aGzCa/eDdEjs0v tPlvZru2tIdUguJ3s0LzFUlQnIHJA64HpX9An7Pyafe6PDa2t/f+RFbm58Py7sRXC7cunsHLKAF6 kmv6q+jLWjHOsVT7xX3K/wCtj8E+kZT/AOMRp1l0kl9//DH9R/8AwRm8U621uNL8RSLb6fL4mm1C 2tAE3WxVY4E3kDcclcfN3JPev6efFWnf2p4W1GKVY54jbOJbdyFSX5SFH4k1+eePtFYbj6dWP2mn 89E/yP2TwhnLEeE+B9o7vka+V9PwP//R6b/goBoQ0z4y6zpkMllDIt1LfvpMUavv8q4Eavu9imcH 0r4t1pJvJtFguRLmEXNw1mAJbV84MeGBypAIIPr+Nf6oeFtaVXgbL6kt+Tr6tH+VvihRWG44zCku lR/oczq2m6hPNZtZmK80+5AS5SVxb3FsQg3nav8AtZ54z271hX+n2pePRohbWMO3kqCLeU9n6Hke uK/SYPVM/Na6XM0REyvYSfaLxJdRsLVdPhEEIjku4E+UDK9T/PFWrDUbm00KHbbS+YcqiSKXccnh vYda6Fvc4yMW82oSb0sY5phZXC2sYARWmeNth28AkNgj6YrHjsLm1gtV1sZvki8u6RIyqRMMZIJ6 c5/KtzKfxH//0vz/ADb3epzw6fYXuWluI1RGkMbsu4f5JrprrT9Wu7RYTC91MgZm8vk7YwSxB9gM 1/tVGVtz/E8wbfQ9P1CWCL+0WWWNXkVZwWjQn09ATgZ961F0i5trRHvEC39pMI7eG13F7iOU4R3H t1J9K1TvsBQhg1Zr1Ypg87GE+dOXREaNcfLnp2AAHpToZYrHU4re4G+1uUMe2BN0iuec5PAxzVJ2 dxNXVi2JNRu7e2smVJ7S3aSytZgdl84ZywDDvgueaDYta2q2yIxkjbYpcZ2kdcn8K2TTMLW0P//T +OrOXVRpUKa1FpksUdwTaSW9tFE6cHg4GTkY/KqH9n2Cxfa2iTckhBtjyEGSQ6/4duK/25W+p/iM 720IrFbqe+uZ5EtI7a4hMTvCcvswd2V6BjU90RawoYJ3LIuBwF8xegGPpW0WmtBSdkVbK6aC+ado 7hAsOYQwG6Td1APv/WrUrRJdQarbF8py1m/Rn5JOOx6/pTXmck5W0LCol801/forLcuSIYnwlu2R yeOh5GM9aZfzPb2J095laKZ1eKdThCinOzHrgY/HpWkLXOWUnuz/1PiTTtPhubpLKyJjiup2MSO2 WZj1JHvgcCnahZPbLPb28cI1OwuFtGs408nzMH5m3dMjP45r/cg/wnI0S4t7qW8uUDyNGYpVd+Aw BA6elR/Zp4Utrm5tpTbXAYwSQn922Bzz07jj3oM5vWxe+yRJYuujhoDKCbtUbmZiSTuUccZ6VDb3 cu+O2gDu0EQLO6ZDA5DDnr3GKDO3Q6eSBLXTWs7WG3WI7cphVdiRywUcD3rlZ7W7eKSWIYMAO3cC PmAoOe1tD//V+JbKzudRltbuKbdutA+rpNiNYJi5ClR3AUDPfJrfka1sy8SsJ7hk2nDbkWv9y4JX P8EKjs2UIUlMsYkyqo2+3yP3bkY3DPY8U5w5ma7mCkSEoqE/OT6j/PatTmI/NEM2JIgZY8MVkTKn 6g1VctN/A4RDvkdE2RoM9z/IVUVd2M3PsaVxNBPFaGHzgIU8tfNwC2OM4HbiprHVWs5YlwpCH5SB +8JPX/PtWyVtEQ23uf/W+SrnWh5VzcTWUzwRNuaS1m8u6kzxtGQR+nfrWFcm2uoUmtTP5N2gZ/tE 3mTx9OCQMeucelf7sH/P+JE53JJFNG6RjyhayEkqFHHP+elQwQRyXMF5OkrSLN5fkAnyQCcbjz+N NJvYie1jSF01hfAW3zqknzo6ghvUD6V0OqRQzwpdwwwW7+QkMkIwrOVAG73J70cr7GMnZHNwQQvI ImlyX6qDhuOtWrqxZ5rWAwSWqS7kil8s4uNgyeeh6gfiKRgf/9f4/Sc2vl2turRmMsspkQMCCNuB +H86Ykb3s81usgjIGEaLjaMenrX+7dPc/wCemTuyxKti9hDOfM328+xMIfOLLgMxOOnHH/66qavb Rtax6jpOpQSX8kim4trhGZjjht5/D3rUnYeNPlD2fmuGM4W4McTZETdcZ74qxc7oS6TkmZX3DHHm A+tBzlu4s7q6hgkt0WYFdwCnMiEf5+tYxSJlc747lzhplUZXIxxyOoIx9RW0fhRjJWZ//9D47eGR LSKa3YGOXKyRoctEc9DUilbVY4mRUJ+bbjG4nufWv96D/nXKWoTLEVjYGRpTmLA4UgjrxWpYWEc6 xz3kUrWquBK0JAYfj27UGcl7yH3NtY2Es7QSzXcAjzCCP3m7sDxzUVtDcz7SEMSFDNsdcbgBnBB+ nSrUU1puOe1igblAWwBtXK8jg9qsRQyCOO4wAsuQu0c4FRa2hm23oz//0fk6axgitY7jav7zgyA4 ZDzxiqksaCMNwwXp61/vRY/5zy5pdk97HcGR44ipBjQ8MR6n27fjSO00KbYowF6F8cZ9PrVKLZq1 aFiuBFjL8kjqetKQqQExNy/Xd1NbGRWBZMMRwoznuSDV2VobiK3kgEqXBQpcF+YV5wvHX60A0noz /9L5I8oWZGXQnbyyD5c04Ja3MR3zK0hJ3NnAX2r/AHwP+ch7lCK3+z70VSwc7lYd+alihupicwss cRyzuwHHsM1cFqIsMoCNKy5X7oBGQayowlvP+78wLI2ZFL+YFPoD6e1agWbtmS1muEmxKrqqWuPv rzuIPt/X80s4EO66fOAwdyTwhIOAM/Q1k/jA/9P5BD+bdfbYJHdUPlsrrjp2A9KmcPNIJQNgj+Zl PU1/vwf844+K9iaRfLt5/OLEGQ4KDB6464qbUJheFIIoUVgoaWUngAdTQA8xRoqRAxs6KOUxgjFB szIOCFkbv0//AFUARSWMltBNK80RXbiVshwnPqe/0rOV4j2B5wCByauLd7Cbsrn/1PkGeNJ5Io3Z 0WNtyurFSPXB96vXvkpFGIMhAuC27dvIzya/35asf84fPoRWghCvcyyEF0CsSCDgdKR5UljYJJCy WygxyhmV5t2MjaQDkZI/A80rGYi23nhCRucNlQByfb+VSERzISkbRiIglSckEYzn8RQA+3W3MjNJ HI+V2qEcJg+vQ+/FSukS7bdUZcZMgbOSe1NJvYD/1fk6BEaZrVY4xJ5Tzb3A5VeDnPHfgVNbWq2a AE7nJJJXgAegr/flprRn/N7KVtCxI+FI8sKXOA56gVUmgclDazKrKpXfuyM/T/PSiKu7MybuQRHU HkY3See/CjyYBErYAGcDjtk1dXLRMUQiUcKvqa0atCwisspaRFdcH0x1NWDabEkmklQB2xHEM7yO 59Kb+JAf/9b5PeNEkRUJ3MORjBp8jFVKhMY6gDk+9f8AQAf8242zubmyuROYopF2lBFcQiaM5GM4 PcVVEtwbhmwUOc4+7wfSgC7EbO5mUXkSyRx5wSm4ofUflVebe0w8pVSNeEwMA/WgB+HEm9mBccMF wF/AChplKlVQ5HGG6ZoA/9f5P2ySptZgAmDgCkESg5ck7iM7Rk81/wBAB/zbgYHikbaQ6k8YHIB9 aBcwRuFlQnYc8dTQAXC28kaXsMjRI0hSSNuDH2GfXOKZLvGChBAPfjPtQA4kSxOJFKkjEYBxtNQL BdiMfIyxiQDfjH4fzoA//9D5caU2ay204jmXKtHLG25CNvT65P6VAG80xyxRiJo+dwzlvr2r/oAP +bctrIwEk0pzv5YdRWZPJKrBIlZBMDhsbQ6ng/1qZS5QK8tpdPJHhAQvyptATmrlklwqEXBU2+8r 5gA3KcDj8KlT7gTxsrB4oQrF2B34+cAZ6f57VDdwPGp3tuC8fK2f61SkmB//0fkdCWUL0HYVageN HMZyWI+6O1f79y1lY/5tzQikSFWCKXYttIz9yq9zKjoYjH82QA46j1rUClFF5cjOXOMbdpPA/Cp4 mLgqQRk4G7qfegCW4OIFWFCWhP3s5cdMnNVooZmj3RtzISJd3pxwKAP/0vlr+zkKjy23SbfnReq0 QpBEjR+WN3Tew+YV/wBAB/zbj3mCqEVgFYfNtULjHriqksCsoAc7iOD3IoAgtzJAPKAYKDgZ96hl Atn80gHceRigCR1kLxS42h1DJ3BHrWjI2XiRSZNy8so+RSOxp6WA/9P5Pk3pJ90GMfxehz0x/npU mY2/d4565Ff9AB/zbkEU0AuJITHI+35d6nao/Q+1SCzupJQsSK0ZyzH+JcUAWpLa2W3zJI8c6N8x QjGBWZEjXkh+R/JhbIZhz8vfFAF9p1KkRklkXaBjoKx0u/s6PJNkAscA9D70Af/U+TQYpLdJ0dXE wyoGQU9iMfyrNuA5IVTjJ61/0AH/ADeKN4q5rSW4h0uHeyvPKzANHyoA9R2PtWTMirDHsRVmV928 qSfpjpQWP817lsuqiQ/xKoX8hirjRmSMgBRsHTux96AIBDMdr4jhYnY22UFvrjrV+KAw+fKXQooG CeWyeOlAH//V+RRfFZtiIc5yrPyGNFwJBE/mhvPklDIVOFVcHIP14r/f6SutD/m/FYo8aRyk5RNq Y4x35/WiKFRG25lUr68CsSk/euOeBFh8wSFGxhMcKx96y0d1Z0mEgVlIXyzjcenXtTu1sa3RFDbu XWJ5HEcfzKCT25GfyFTTRrvW4kIIjcFMnqR0/nTUmnqM/9b48Mz3c/muvzyDBJHArPuLWQ3BZGAC 9eeor/f7mif844xyzERSA7c4yDj9aszLCUWO0R3YkcM2dnqT61QFOaB98bkuZI1xjotWI1llMUpP 7yFc5zwMc8GgC15y3CESdScHPr61B5IikUpyxOFHrQVzPY//1/jC5gBDCVXDFgRjoMYq7aTmJGig yWIw3Y+lf7/26H/OOUbd1hNzgxGdlMSq46E98fh+tXpZlXy7dBhokInYtu3HJ/LHA/ChJRVka09i G3ms7hWMMiS7co5B43D8asQhocyW7lHAI3KcEZqKnQsyLy2lu3Q5M0kJ3LvY7Gx13DvX40fteQrL 4oukQXAkEjmNoj5KYJXse3IOO1flHjc+Xw8x3+F/kz+jfowL/jZeH9P/AG6J/9D+Jq/sp/PELrLG yc784BPvSCbysxyuweIBicfer9Erv35HzcF+7LkniWS9tUsjDa7F+Q3QhC3BAxxn8PyqvDEGO9Fy g4G7qTXI23uVD4UUptqiQRpGsu0qEGBj8KZp0gRnhG9XkiKyHOUbPUVzyd2UIx8hzhDn/V4Bzn6V f3Ws64kZFcR7MEgEH2rOexcIp6s//9H+He7E1sV8pQwJ+cZwD9as27Rqg3kKrHOwfw19QeDKNnoX pF8+Ai1+VUbBC8M3HI/WqJmnQ+UJGSTG07+ePTmgcFrcYxdVDv5ZQcBAfnOOM4qCOeSPaxXqxJz3 H+f50rO90ammlxCY1V8mTOdqj5cetW4g8qBQGWMNgjGN4/zmsXJvccd0f//S/iWRBbpPDFEGaVSQ zHhPpTIIsxttVt8eGcH+I19AcEd9RJV892jgwJeC7EYxU6/LI6I/79VAU4yAaC5voV7qeaRY4p3M ZjbDk8Ln1q5aFhb4Zt4Y/K/UD3oMyKe1jCMRICrHDhR0NWmSFUh2bZQE4UDLD3IoG1ZH/9P+J+58 6OJWVBvbBweoGfSmSXc8to0EZVDEQJFUDcc8c19Aec3ZXIbO2vfMcRsiBU35dgmcegPU+1QuRLI0 0imMKdm8e3eh6K4bo3Y7lYlG9iA4AUgY496yZ7WSdndHDLv3KB1WsLvqQ4JLQSZJJWTf5gEcfllO zn1pkoWSSCGJWjKrgGPq31pGZ//U/h5mM0dw7lWAY7ACecj1qeR723iSWXZh+IyrBsgd69g8uCJ7 Z5Lk7TllA5Vj8pqxcROjCJURHYAsTxtH4UGg9SVKxlN3y/JIp71GkU6zRRMRtyWYZ+VKqHxIDoJb aAeW0MqsxGSpHI55ArMuIZYZ/NWMzJL8jgSBDH71U0ty4ysrM//V/il/s9pIBDEGEi5ZZW5/A/41 Us40Ia3lYiViSzd+K9g4nJ30L9hFDayu8jSFYjk7BliPQD/PWnajcLcxPLZkhv4C4AI5HUUW6FqS a1MgXIzGzZWZDywOMmp555lLSNukDjOWycH2rnMm7sLOKR5dwYuky5degTr0p9woQLGqgBJSVOOp 6c/lQONr6n//1v4n23zqUaJWcL+75xUU9nNCuzJ3FQ79lH0rucU1Y5yBGlO1YwGUDLh/v8elbETR XcZLLtkh6seDgcVREkjLuomVle2I5YBy4/lWgY3hizhXZwOMcofUUF2toV0sWliuJXKhtuI1xk5r Hhs5fNUyl/kY4UjbtI9KAP/X/iYWJ4pC2d6scg5yn0pGilMsYcZTdhtpxkd69A5zXkjsN7tbo0KB ioSQ84FZomUTyxRyyGKQYOf4cen5UEylysZZeaXnUwiUZw+Y8+WoPBz2PStm3thcwO5zEVkOMjBI XsKDJu7Me4ZVdwyEbeQw6Eiomt3u1RiWWBBmTbxu9PyoM5Stsf/Q/iLCwIXRS74OQZPvL+VPkQwO JN2XkQBFzzx6CvQPK53YgntVujE+50kQYKgcsfY1s2shMYAc+ZH8rZHQDgUnfoQa6WkcUUl1Mgc+ WRHkE4JHH49K5O9hu5pU8wCSPB2qOAv1pjSu7EllHtRoVZEBJZlJ/P60iIIZQ2zc+fk9R+FFjc// 0f4pLeE3TNNOZl8lMQIFHl5HPfpVhb8bGt1OJU53en1r0DzzLmc3MyR2xkuLqVtpRVJB+lWVslhh MjvmUcSJ/dP0rWC0uBPakFCoBKg54H3abqMflpGbR5XQpmbzVHDe3tWbVnYcXZ3KqmRbdJjHw4Kc HnIx2/EU2xjaaWaIozqEyzfwoT0yfzpGyd1c/9L+KQ2LpgbkK7sDPb602S0csiTbdivvVu2R0r0D gbb3F+2zndbhVWNWwCAN5I4OW649q0I5ljRlZFczJs+YZ9D+FBUXYsw2sCq3yjfsLRs+SHI/hqtP 5bvFJKDGxTY0EYyuQODQJyb3KKyBEzIoD7sICM5x07VDfyXZ8py7F9uyPccogA6D0oJP/9P+JoyN 9mgjkGZI2LySBQGGccZ/CrnlSSRIyOVJ+bbuxke9egeeZV/bmURtE6sYhnAON57j9KS3tklKySu6 SquY4HB4x70AaaK8TxkkF85IUUl8lwrAzrsdPmCjkAHkfpQGxPayXI2yxO0cijcD90DHetDTbePU ry0t7+/W1M94v2i9bgRx7wWbHOcDPTk4pPREyV0f/9T+QLxP4N+Hceh3Gt6Z45TVr2z+W3s/sjRD UMsoKgE/wjPOO1eNzOrqcZCYwB6fWt077nkyjy7MpTtMrIU3SggcE4C+5oZhNIHYexKcKcV0klh7 D7ROs8SMohjxJhjsA4BJ/SoEURTMeVAfKnp+NBSi2a7zyBXlkZpCQCc88elRpLFKVZU+4dzs527B ipknbQTVtD//1f4l727uN220xHn/AFjKu4Ouf88063l3L8zkM5wpb5enWu9KyseXT6i3V8195Vtb soWBtrEdHHtStpShID8ixMxLbDzuH+OayjvoaFXZJb70jUAl9p55cDI4FbFgLeJ/nET3Tt8sobDK uOhz3qQL7zWpJkMMTunG7+JvqetY89rLckyyEIirhY1PyjPegnmV7H//1v4i7uFbORYFKSHdkkjh c4qxI+yBtgAyMEryvpXQeeU7e8EaiGNBId2HLLkn60qIglbMbqqNnf2Oe1AGiY8xGTDOB0IHSslZ trXCuDu6jaOvsaALcUSIgIQbpcMV6sPTPpWlFGJHjKSEMg2uCMY9MVDgiofEf//X/iHu3aGQtIga fzDnByMdiT70jSo4RQDIX4GxcD6Vr7NHNfWx0nh7w1bXG03kqRNPIUS3I+ZewY/nVCa1uNMmlt4C GwxTduyFwexqJKzsJr3kyhJEzLsk8xi77GdTkjPFMnshpt39gLl3TDkxuJH+YZHI+v6UmrFFnzYw i27Zyfl3HgjNXrXTZYxJ57zXGxd0aseVx6Uh36H/0P4lHtIUldmUhHGSe4PcYqUzWSp5YJZccOE2 hT/kUHOUpr+CFFiRSIjw7MMu5/wqgImilF2geSAyBRsBbaT2NAk7uxPO8sm7r5Ib5VZcZ+tVUAgc x8EuATt58selAxxcG4WN8lOBkng+layR7LaaNGQFzy6NhgPSiwH/0f4hVujGwgIOMhXbGQOvepY5 pkkPlCQx9Ag42/4Cg5yf7MSy+aWnEhw6NzkdP60+PTreyMkq3c+7eDHbNhUGOoFTKN0ap2jcd5jX kbxRyMHBztAODUB0+NA6z+Y0uz91821d1Z8khRld6kQh3RGM/uwvzFgeSR61lvc3dsjGIeV5gKvn HzDtSszQ/9L+ITSHkkBaRlM5ztaXsOmcVs3Mc1tZTSK0amRsEI4bcfUDqBya5wOds4LiSR3J3ADg HC/nUDBmzvyGifDA8EGgB6W1zerwuChxGZF4z2rRuV1TEVtLIZlCDfhRlD6Vd5KIFKW3uI4iZEiZ wDgJncAOmamtXYW9x5REayIAY93Pvj8q0i7q4WP/0/4cxM1vslixKRww3ZkXP+elW55CgBWPbkB9 r80GMviZN9uuJE8uJQBIQGwOvqM1nzvKLprOOdvKOFfkouT296CSFSI5sTsT5Z2gMcHjjmtJfJEe 7I2btx20m7K50JW0ITHNMf8AVMYyf3ZI4rafZFbC2e2dJgAYplcBGBznK45/TrUc+gep/9T+IRFZ pV2lmA+R4zx0759atQak1rM6KzM33fLY/e9s0k7q5tFrlIbi9vJCbkRBYWby3tvMxtIzhsdag028 LXTedtRRnkj7vtSl8LHdDXnmhklgt9s+75iCMqB/+qqsET3TsyoCYuWHZecCiHwmSdpXNmSOZQEU GNXj2tJGfnT3ArOazb7QWd3dyApcnJYDpVCbu7n/1f4jorhw8UGwtLyWbjaQPWt4TXNoUv7dUl+y 4domGUb6j0pJ3bQGFdX9xqi5uV27umzC9D+v41djgCwxxpgzMQXH8UYPc/lWc30FZJtnofgOwltd ftz5U0sk+wPGYyySx7xzjp3H557V+1f7POjw2fh2LVtQWW1lOoItoUbz1Nt5becAgBAGdoJ568d6 /pD6OEL8QVp9FE/mf6RkubKcNTXWR/Wd/wAEitGguPDGiXlrZTKLtnvbOaSXDQRibeRj12hc/QV+ y37Ul/bWXw01dophZzXFvIIpvM8owAoQx3dt2eT7GvjONqksV4s1ab1tVS+XMfsPBsFhvCmlb/nz /wC2n//W+SvjSU1f4hfEExajDrE6axeWirDMscFokTBlIP8Ae4ZieOCB9fwB/a8l1b7bYWV8Zhb2 U73EVug3qZHEcZYsP4chT7kCv9N+OX7Lwwqz2/cr/wBJR/n14W0E+PZPd87/ADZ8LK0kE5jlKzOY /md+QMjjHpjimRvcOQGi2NFKTG68iQV/mNiJXlJH97Ri7I6y2uI7glXjEWxVPyg/Q/nXRw28QaIx osis3lhWPKk9zXD0uayjdmjf2t4DZNaTLAsB23CE4W4TPzA9ef8ACi4hW4mChRIkijzJgMCM+h75 /wAK5pPR3EoWZ//X/jSNhHpqRWKStdTSsrxneJBEHGQAw4wKGmeEPNflmhhkETmFPNwAQM8fzr58 57Fr7C7EPbvE6n5/L35kZT79jW9CllZRSwRzB2jhDF7lhuQtgEAnrjP5UDiruzK8wQzINyyRvGAh j5BOOcn8cfhSW1kttKWiiRSzF3WMbWckYLGsp72NxVuJUZ4LgqnzHyzuCDaa1rU21gki29oFeVRI xJwWyM7vfI9azeiNaex//9D+Ri2jE1o88iqMsRgjaeD2qiVYSKISFUMOX4DDPIr486Ds4ZbZ7e3t Z4wJw24Sn5QoxwAPQ+9d34U0mb7WLoOsVqYmlfzpAA+3gbcn2J/CsK0moSRu1dWP6iP+CCvhJ1l8 U+L4ormQ6hrMcMK3HypfwGbKvGpGeGUjIyPkx2r+zbTvLjsrdYX8wEA79u09Oh+lfgTrwxPEWNlH XlaXzV/yOfCU1GrUkur/AEsbQR9yEdu55NJIME7uh6Yr1+XVI9E//9H58/4K/wCkyWuueHdZvILC 21KGZ9PRoLlZ4xBcSOiqDn77SADb2Ffzinw4NTh1DzXuX1hbqV1nceVFJHliAAOBwMD6V+acHOTy qV9uZ2/D9TyIT5qUodm0eLaTeySTagms6PJPYxiS2CSTiN2bdhJFwDlcc8+1QLZp9onuGg+y2a4a 2RX3yyDHVvpxX2MPhCTSii1NPCDGMI4eEtEgYbnCnB/XiqVvp41+SJbuU6d5a+bAZITMkeRwRjv9 OlUJO6OXsZ5X1JXvZz/o8zQxyqwdZgPl3EevFbmqa/p9s4kzLchCEhgKYYt0bj+v0qZJ20GnZn// 0v42F0q3QwateadctHeWbGC1kjZZpM/dwBzjODVKKwkMfmshiiFwsLRgjzULnAwmc446+1eFBPmP PLyaLaWUts96BPLJIzLDEheMxAdXYcA89K17+90ZRbQxXd4l1dKxW3Ft+5UIM7Cx6ZHrg+lagc1q V1ImmQxwM0V0bkMXVcxsucFG7kYNVhFc3t2HuLYWNtBAqSvGCROAPv8AJ69yP5UAaSeWiLDJyinc r9CPeqjQXkj20UPn/ZGuCrHGQR16dhkda6KKLkrJH//T/j/gVoLV4ncDzCGCnsVyB/M/nVPT9DaA 3V7CBB9vmCGZgZGVywy6A8Ej8hWUYvQ8/Y1PGuh6bbvcWthrY1C5aJZQJh9m2nbycHsSCM180XOl 3EUt3PIi7Zp1KSZ3IrDqM9AeP0ruoqw6i98d5stuokW4eyKMrtPGgm2gEEnaa/Z39kvXPtXhnT75 pLy+vLGytruxEMe3ytiRrlweB85UAYxlhX9J/Rwq8nE86d94M/CvpFR/4wuMv7yP6jf+CUHiK3sv HlroMgle41eSK+/fEpAk0jxmRS/fgAgDspr+vW9WK98NSrIGXFmBIqnaRtQE4/EV4n0koez4xpzX ZH6Z4Ezdbwtw0X0TP//U9o/4KK6dBZ/Ha+u4rcG61W7uYnuXBP2eO1kSUqq9i3n4z7GvzPN1K+s3 E3miDdmO3tdm1rrOF2qoHXGTz6V/qJ4SScuA8ubf2F+bP8t/FyK/17zJJf8AL1r8i0NRa3inCRbI mhIE8iktuB+YKPbrWbNY2soEMksqX1wrCaaeEGCFRgpswCQTjk+me2c/qaVkj8trR1ZxT/aEeWOG Py77TZlYyDIiKhsBt2MEE4xj6elbP9sRpLF9rtpJVc5IhfYyvjqRjoSenvW8E0tTiaaNCd1uY4o7 fUJLEW8hku7dbdfMkDLlQj4ypyBzTrjVbo28ZvIxexiI206ynbLgg7WJHv6d61i5XsjGasz/1fhX wxp9re6jfrdXcmkvp0Hm28wiBimbkhUbPUbcfiKqajLc70gubgPFw8MkU204yQd4HrjofWv9qD/F C2lzTTTktrZrsTrCHkCRSNjaO+Me4rSN3LfypLMcFFFvc3RbDBQoCFVxyAByfamm1ohGFfahfW0M TWbxNLbXeyV3iEls0buoTd35JP1z0p/iDUZGvoLiaCCBru1Dwi1gEUTgAqSAOB071rC9tQJLS4hn NtHbTqJGOGVjtKN3GffFa15KNFjEupQyzWF8GjgW2UG5O0fM4zwCCeh9K0gveMHuf//W+JbDV7Fr Xy7tnW1ti0sUjJkk9g47H69Kybm/W4nW7ty8ltJ+5tvk2xO38QUjjHH6V/twf4hyl9kmsjcwNJIh iIYHfGzhWwO/PFZWo38/mWkwhupVe8EBjhiL7BnaWbsqjrk1UXZkSk3E6bzbC3a4Exmnb7OHtSrD MMvBAPYjqOKx7cawNRe7iuIU+2GT7V9oRQnluDuVPQ46Y9a2OGo7aHYW91YWIhsnJLzoZMeUTEB0 zketUdctra/tzHcyRu1pfx3tjJZxlP3aj50bOOSePTj8zY55SurH/9f4pgAKm6jSK28py0cgO2ZM dlPXsOfap9Qilu4BewztLO4MtzK5JlbcRyc8k9c5r/cJyZ/hOXLaDTljNp87GNAsct3KVa4JGc5z 79unSqtnd3kotdOuYli061unkaGE5Mm4gYQ9jgdfetYvmRlNamxfwWekXMxhwsTWSyyTRNvwckbW A6HFVLa4gZPtd0ohjVAY3ZSrTZxgUyDmDc+bfzrFP/qX83ysktyeMf57Vvz6m0u3auw4wUxxgUES jfVH/9D4uFtAzK9kZrZ41M92hl8xZ8nHy/3RyOKsBI45VKybZdu797HuQ+1f7kxdmf4J1I2epetr FkaGV3WS3lYtKVcfucDk49Dis3Ub1JLn92nlxQ4RH6bj6/nitziezLhht9UUfZpWF2IzlJWG47Rk n/69ZsE7yWK2dwgSMz7pGXjzCMADP9Peqi+VmA42OqWsoldVewuU8u2dwPMGDlsD8R+fWtRp7HT1 iee3C3UaloZZVJSY8cAdMjvmtlqrik7I/9H4pvrwrZTy+WQjrukdVxgdcYpmkGW7tY2SNEiYbnH3 mx/nFf7sH/P8pJmjb6XZAzM88kDSf6rABRW989qllS5tIYYLiRJZIBhpI0CByeSRitk1Yzm9bE0V ta+WhyHuLnMg3MQY8dv8+tVhqYd7d5baQFVZJZIyJFlIyV4PT0PWq32OeUr6IoiK7vLn7bMgsdrF kt4wFKg9OnbABrRuJZZvJWOZ28knbuP3M/exzxnFLlRnJXVj/9L5BsljkeUXUshwhMckYBcMOgIP Y4x+NWLYafHJO8Mix3lxKqtIWLPEAMH5fTofwr/eBJLRH/PM9joLzTrW1s447i+tGEiZjngJkjmf OCOATnNYn2TRls0eOdLieJ28y1jDJJHjoxYrtPfgelBik2tDDniluFTDmMMSAx/g9yBzU1tal0yC XMI/efnigVi21zPaRvHbTnzJYWUxBtuAeCD6Z/rSx6dEI4ZE3/JERKQcJk9uvOMdT71tFWiiXFM/ /9P5TggZrS4/0cpa26Z+0woW2sSPvfXNYspjkkXc3meWQdxPUV/vQf8AOw01uS3SRsyOLq1m887Y 4olZGh2gDByAD36Z6HNPT7XHEYfNkjhl+Xap+V8d8dM0CsTXcf2KGIyyKRtDGQ4GeO9NOpDZG6Fw rx7XOOAPUfhQKSuiC4S2NqHiXBkTguck/wC1S2dy9nFHBKysZYzGjNxg9yOeDQRyaH//1PkR5VQB J5T5I5O0ZP5VNBLZ/YpHl3GUzBYQB8rL6k+xHTvmv97YbH/OooLqJHcBZoz8oRhtJPUe3+fSluJn nmEagxwp1BOC2epq7WHJe7YVUt3PljO4fcZmwnvmnCCW4khjS1vZ4YJMXE9patOkAbgFsfQgCgxK 880c9qIYdySRzlkZo9rSrnnI/wAaBNK0fkIg3OR86gblxxQKSdrI/9X4+uS0qywxuCkRCOTgMT9D S21ir25ldJE8g+WgKFRn3r/fA/5x7W0JUiuIsXKDfHGDG2R8i5pqasYdwuIpLosfKEUPyOMkLuzj +HOSPaqgveAtWjo0MsZlHkxHJEpw3Pt64/8A11Wv7jT4IYvIUElS3mJ827/CtH8SCxXjlikEe+Ng 7LubcM7fT+dKohIuESZW8vB2KDzmofxjSu7H/9b4+sY2USvuBUEHys4z15x3x/WrLb3nymcfxkDF f78H/OVKPKLfJJiEoqwJGcM2MNJn3pS6D95CcZTYTnr9aCBmHhK+ZtExGcKcg+lLFdvDO/muXZ12 rHjhAe9AEq+ZC8pDI8NyoWSORRIpwQ2QD0OQOR6VYljtVgwFCsrbkKAAsD1BP4DH40GU3rY//9f5 DuDDhc5iTooJ+Zj6UsRZVKBQ6MRt3Dkfj2r/AH6+x8z/AJvx8RERb7QFYOflVRjZ7fWm/ZLcq0nm bOSQx5U4HAwKL+7YCRZlMCqNxKHPy/eNNglxN5jqdmcsGGQ31qQLrtbBGljGxi+Vx9z6VUeRllRM 7nkGeO3+c1rTWgH/0PlC5iLwuknz+bF5JPIdB7HtVhwYYYI1bL7Agz1AHHP5V/v7NX2P+b5xT3H7 Ea42Nu8oIMO7AZOOadF9lhHyD5Ubr1qYu8jJxaHvqSbFWFArKTmTox9qiSeJ4pGclSikggZya1av oyTPidDKsjtvXcMjpitC48wXClIVaMAhyx/1f0FS90B//9H5Uy8ksbRQTTsjbpmVchVzjOPT3qxI gMhkMZCKvGBzmv8AoAP+bcqXcw/dAjDBufXApHVrh1aNSiAgAscnAoAvvDCF2RbZGK5faMFevXP0 rNyit5Mu5VzksKAJ5Vhi4gk3hhwxGM06BI2VlznvkDkUAf/S+VVltLdZBL5shYfIsOM/8CJ6dvWq lqJGmR2l25ORHxyPev8AoAP+bc0pVSN3DMEBQuG6nIHHHvxWRE0MjszDPmcFvWgC99mgEQCsf9pX HBqaS083aR8qqoKgdTUuSTsAtusDQz7kaYp0Kgl0IOOB/jRNKDGCJlkwuNi8lf8Ae9+lDkk7Af/T +ULRXkmIuGXyS4CFhjaPens6rPPCjhljkMe5TlTg4yP896/3+k7I/wCbclVUeNkeTg8DnFEcaRgN PJI6RjEY+8FHoKxArNMtxIPLEg2nhC2B+NIv7vzN6AF12se1ADIYCGMsG4gDB5JVRSXhkij82NXl wwVwvIUmgD//1PklUfYjgE56ntmrMcBhZpnV/NIBHGOCMg/yP41/vwtD/m3EkmeLa7YI6MFXmngp M3ZQF35JC9O31roAbLxHHOqK0ZHQ8O2PUdv06VYinjvNkaps2rt3YxigCm0ctvI6JKWwxHmdmpFe TmLn5fm3jigD/9X5dgnuI9rJGPLc+W87YCR+5J6U2RGEx+ZZkbkOn3Gz3Ff9AB/zblZYJUmcMAY1 5QHoRipFzF84Tf2wf4fegBLi7jkdYSpSdVznGAR0H8qclh9qOzf87DIU8+tAFiC1sEza3kjK395W 5GOy+lUSZLO6kgiYSWxbMLnlyPcdqAP/1vk8Wc8xmm+0w2wQZEUuS8pzxtA/HrVYuU81WIJxjdiv +gA/5txbNJzulUv5bHaeOJPr9KvW8syO68kYOCM/LQBDLHK25mcYHJU9Tk9qbbkLuKEnIwR0xQA+ 2t2aQsuAoB3DqaheOFy6umVUkKSKAP/X+TR5SqoGAoHPao5FimYbcIVGB/tV/wBAB/zfR2Q4wSRJ FhS/msSir82SDiquWEpVl79COVoGWvKCgMmFB6bu1Z5EpdsSc7ugPWgC4lvngsQ/UnPWk/eM7ImT s5b0oA//0PkNER5BuXaUPenzFxKCp/dKMFWHzZ+tf9AB/wA35NaPZySeXcrKvyGTzVX5FAwME9M1 DcNbXAKQvlU+V1WokrySAqyuzWsFogLBZC4Y8t9M9ajlYwREsMsg9Mnj0qXBrY1WjV+wW0qThGV9 wK84HKn0qeJCC0YKsrH+Jc4/Olyu9iz/0fkoxoi/K4LDqcVRFss4aZNw28PyQGr/AH5aa3P+ccVL QykrnHGAT2qrbA2s8kMg2kNjzDyPrx2pbAWo2Em8EgjON2MflUsduSjhMY6HPetIztowFt9OiC/6 RJgB8kJ98j+X/wCqqwizIRyQGyreg7U1NdS5JK1j/9L5DMpLMHAcqpABGcD2rPhDQyvLHKQCOEA+ b0PP0r/f7mif845BewK4XdbIs8jidXKlZGA4B/8Ar4qSKCSNDKow5wjbz2/zmqNKfUtCOzhhKxxE yMd0j5wD68UyAsqTF2UKTiNP4sY//XSauaFBi91b6ha26SG5Nq5h8s7SSo34z7hSK/GD9rxn/tyI zXU09xPFNLGkMxDQxiRFw304Ptur8n8cI/8AGusd/hf5M/pD6Lyv4mUF5f8At0T/0/4qZo7lNjFZ HU/c68j2qDU0iNmoYIjgEszHbJJnt+H9a/QsR8cvU+dgrQSZh2UUQYAoTtGSw4Wt0oVdSjhItmdo +8a5RxXKrFZrKMks8rRNgukgGSPTNU7eL5WYHaVP38/NIfpXObOCIpGkaUbBiUDAx0PualtLJjI7 SKSQd2f4Sazm1sikklZH/9T+JSe0HmDfvC5+dQORWTLayNOUjj+Qt19AO9fUHjmrb2fmoghZo3K7 VK5LORmn/Ylnnjt2kO4sEYudoPOOT2oA3dY8IaJptnLdWviFL/U0dI5dOgXzrO1XHJWUHDHkc471 xgjZZChUMEPQjBOalNtXsTFt7otSeXbqq+VFuVs5Azn2rcTEsbSqVj2gfuwcAetYlrRn/9X+KC3h 2PK+0MJCPwqzKGjVjCqqJQFcYzx7f5719AeeVba3WK5y7DM2ABj5gRV+X7LYs0k4Mr/fVADk9aAM C7kS8ZmMezJyEwQRU9gJxFLHsyn8I6AAUAXokWOIrJGN27ciAYDDqeabDH88rRna7cDjIUelBcne x//W/ijknYt/pADrEu0OpwCB71XttryyIqIvmnIxyMdua+g9DzJ7HQG1klgNrbQJcXOzcsmSrJj7 3Trx2NZ8VvNbs4mgXyGADq8eZUYHr7dqmXwlR2RBeRK0gUMQOoB/hrOVpYZ8J8wyCFzjd61iJyVm jeWOBk8yQyBuhXAwPpWJJkOTFgNk/KDnAoMT/9f+IO6VnliVFIGcHJxt9TipJI0aIJuJwxA3jhD3 r2DyoPWxEbSZWjt3KqCd6uTtDVd+zMo3D5/lPmHOS3sKDTmSdi3EgmEboPljA3Z+UcdqSUpCzFgD K/QKfkAJqo6MOaPcqss0b/aEmBT72A2duO1WLMyXE4ldRIg6sHwR6cVc11FzR2P/0P4rbzUWtUdL XBGzY2eW54NZdpLAzMLhBnhnbdtcj0FeweY5pbDp53iZXi4jcbVXHTpiqatIkm6QEI3ykd2z3qZO xa1JYNPct5jOSv8ADnkZq8kZMiwF2yvL7h8g+n+FYgWVEdtL8jbwRj/ZJqq0q8xGJWB5J7xn1H+e 9AH/0f4oUu44J4/Mh8xFI6nGfrV/Ur+KTy1RY3wm55kJ2DgfL+HOa9A5ldLUzdOb7RLJmPCH5UkP C/8A161WgijBjXkyfefOFBoFJXVi9FJogto1/ePcI+S8o2KGH90enoay7icb8x8qc4PYUFJWVijH d+QzJgs4O7L8L/nio5LqYxKspDvLKfL2JgqKAP/S/igtYZLW3licFhcSeYV6/jUUUbpyWYqsuTk/ MMc4Negc5JOI7x9iD7vOc1SWIwXYUlWGMqo6rgZyaDGStI0badVyYw7JNJh1Q4A+tS3E0buqozYH 3QDt570EmfLbHd80km0fOc/yNJbTSpdK4kAtYlw0ToHST60GMviP/9P+J1rOCVsZCmZtiuDg81qT aUI7K3Mtza3D2rGCMIcTbck59a9A8cz/AClWVTG2yToqZyeOppZodqsyFVcH723Bcn2oAdDe3K4g mZnSNd0iAYGPUUOwdN4OxW4CkYf2oHFaozDZGDy2llz8xYbeGH1qyFWFoznMsmRGJOF96adk0bn/ 1P4t45E+yk7v3gOCi8Aj1rnZZQqsLUIDnMrkc/hXoHnhazS20oki3RuR95eGOfSrLJctuuSiyHvE DywrSDewGjblbclwFVDH5gTPzb/T6VHczSTCWYlTvUM0UYAQY54qG7u4GO90+4eWg8ojA3dc966D SktGUKZCk80nzQsdpAGP/r0gP//V/i41CWCAGJEDEHOAfmA7Gsg3YngWEyOHWTdgqBx2ANd7utjz yyktrFOHitvMVV5Wbo5xznB9axJr2ZZy5TZtJCoOdvuKYGha6zOiJahtyOTIWkUHyunfrzgCr7ah DceTMyfe+UsqbT8vH9KAJbkfakRLaASTsQI1Q4C+7VnXEksAa3nZCY5NsuQGKEZ6H/CgD//W/iTN 1FHKRKjsjphdrbRntmrsl0vlqqIPlX8fSvQPOuloQ2cMO/zrlljjt1MoUk/vDjheP61cupZL9laF Yk3dAo2lAPQfhQMt/wBmt5RunulVolG5c8tniq1xdQhVHV9uDkcGp5lexM3ZCAN5XmszbQuCF6HN Z8izLKw8oCMj91uJPB9P1pvZjukrn//X/iQjjRpIA7vCIm2AIPlUHg8fhWgkaRGOKR/mlkJhHXfg c/pXXBanmT2LT2pk24JVCMMVGSKxPLcF4VJAiYgZ4z9K1Mhscs0K7GdsykRsAcDGeh9ula6wbywm iKEIAmQeT60GtNaFWee4iaFBEvl9HPODRbuu+SRoSvG0Nn5Dntii3QppPc//0P4oESIE7nC/L908 LVa4guhujWBWyPk4yfwr0DzlFR2KFshtGkEqMkmOVcbSPwrSt1keLiUNsJYKeGFZxS5hkUGonTLi 2e5tVvpTOQ4YExqDnGcfzqzcLBcSvcRKIgxyYgeE9qgmXwsgRUdmLkoc4bB4OKuo8wUlDvCLlCT1 ApGJ/9H+JDzY55wjsiF32s55jU+5ou96QrEFUKJ8synl1FdB5sHdFC0aH7S+xWba25kI4xVprhS8 kkySLalcsiL84weOKCi9NdzRxRPFEBFMu5AwxvXpVG2SKXc0zKjM2Fwfmz7CgDRMU9ra3DxSxzmY qsCNEobjrg/14qFZ/s6SllMbsAJHHPl0Di7O5//S/iHjnhBZpPnj5eST70ntWUL4i4EkQEaBvlhA 4roOS65zcS8mUmSSRkJACMD07YqwZWdgjEl8ZC5yxz3qJRuWZRuriKWUNgRg5G7vitrT5zNb3DSQ IZpyF891wxx02n9KXK3ZMmTs0jN1O1kRmePJkDDvjoPSuitrqWOzQTeUWkQEyo4JTHBBomtCj//T /iQu794Jo8KJISxBxyT6moxMLqRcRLFEVxwMbuf50HOR6jZeYYRbomVXa538j35+v6Vf05DBZvDJ geY33ifTuB+FAW1uQ3TQpHJEAxf7yyAnBqhKkK28BhyJ3OJSw69f0FAGfcLdK0J8pJY1+8yths57 1uWRhYKzRyLG42u8Y3bW96AP/9T+JO3FtEZWWYDflXLY45qosw84qhCxAkByMB6DnLkBaZpBCxLL wM8VUui0UTwyHbIzZ3/fb6Cgt/AMtjNb+USzpGDmRlXLt9K6Rfs0shhjM10gU/vrpRbMOMk4z25H Xmgg56S6jZpMwskKZjjUcM5GRz6etMWBpodko3KRuRwPu/Wg2i7o/9X+H6O18mTcrlg67drcHHtU UkvkwgRjKu5DnJJH+eawe5LklsWYZvIRCzrskbHBAbI68VKbi3lPlyQrsLZMufm470ilqjWiuo7L cYbcTIFyFZ8bD6iqFxczOqFVw8w3+YO2e1W/gQES7tswdRIfs5XJPO7GAKwl3RSqJX2qmcxqcGTP atIqysB//9b+HG0ihaYO6ybWOFUnb1p97G7TAKRiIAOrHDYpJWIcL6ly3u4mMkOfKTb+7cYJDf4V nvFvLt5myZGzgja31piUNddgZRfTxzXUjb9ojLgYDAcAn8utadpCYnTAgmQuUeMtyo6A0mrqxqk2 7I6SxFnK8VvPBPIzSeXmB9rr9Bgg9BVPVobvTLCe+lQzRpcLb21sjb7iPPUsnXA7npxUSiki/Zn/ 1/4g1vJZrd/KiCSleH2/ePtVK0VVuS07ZuCMqH+5moTUYo15NLGvwLV2lVBOQdu1t2OuCR2qrCsM ULrIFkvHXcjg5I+i/Sk3eDGopKyHy4gs3uEgZZ2wCnRz0yfaorOBt+9D5YwHdful89j/AJ7U4NWs YmnfTvG3moVCbAGj5IXjqKzEkEmZpXdFJ2owGFzVgf/Q/iK01IvtUkl07iEDaSmGlce2T7DrVuLU 3jke2QKEYbTlt28Z6H06Ukl0AuiBLnEUARpG+dvMcR+V6gE1WecR5VWTfH8rBDl3A7fhWc1Zk9Ge i+BJRqHiPwpt1W50+5h1JTCkEmDOm0jy5F/uknHPGSO9fu78JbS10jwZY27vFpS+HIGEzy3PmXeq GQtJwhyMgE5APTA61/T/ANG+lbHYus+kf+D+h/Ln0hKt4YKgusn89V+Vz+wH/gknpdivwx0m7uI7 z+1ZLOLUbZREFjtreZcqhUdCQ+T9R6V9v/tualJB8K/ECWm83jaTPPFG+BEiIm0gnt1Y5+tfnGdf v/F+uv8Ap8vwZ+5ZRah4U0bf8+H97i0f/9H8+fiV9pOreJZ44J7H+3tZnkuLyEiVZS0rDah9GVRn HvX4m/tY+I4te1P7LYarHHJZvLCkMqKJZkjZEWNvy6jNf6V+K9RYfwwqxXWmkfwv4NYb2nG9WT6S l+Z8Hzs8MzLKvzEAk9cVt254hYYGGGAF+UfhX+ZtZ6s/uJR5WkzrLS6tHJUxJ8xCuSNoFWJL9bTy /LO1PP8ALJ2Fi+eAK4ea10aON3c05LtR5chVmUDlW/iPp9KsWr3JkuIZobW3hfJEsc28OMZ54xn8 a5pO7EoJM//S/jh8Marp8Cj+0bCNpInKmZyZGRRwAi9D0z+NV2vkuLy4sbPy7e0uJi3zNsVwcn5s 9Pzr5pzfQzcHfQgjs1S+S3s3uEURhmZR8nbd83TB7A+tX9St4oocKGeTO0iMljITxgjpUttjjHlZ ms6aakIW6d5riUQQ2cUe8QHu7nt16D0NdTLa3bL9ssBKpgVYryWVvLEOFOTjHc8Y96RZmXFm88Fv eJIWcvmYEHeF7YHucV0ej2loqCS5nO5jgqz8AdORUy+FmlPsf//T/j6lk1A6jLa2zK8CyGK3hB3R P/tZ6j/61dMrWxsoYri2jF0CQyJJvB9yeDmvj9joNTTrOx8iYSxzG4uIAloPNKrEQc7j+GelekeH 2jbS49Ihja4ZYxEXmky7Fjg8+gP5Vy1n7kn5fobx95H9jP8AwQq8IXY+GnhzVtUuhDePeDzYYEJM 9pBI3ljI4AZSpz7Gv6obJAsSgxlcn5UA+76V/OuSRvnGZTvf99P8JMxwiac231ZtjCKuc78dO1Ry tuGOR9K+oveZ6FvdTP/U4/8A4LE+F9PvfCNje3On2yxaT4ptL+e4tyJbmZWlZjG6dSNpX5fev5lN X1u3vbVLiC0n0l72NmexYEywryM56jIPfqDX5XwXWc8plD+WX6JniYWD5q3+J/kjxU2K2cTwrby3 UzsSilt5xn5VH/16pa0LhrS4is4JrHVPsvlXM8jhUh3LjIUjj5Wwc9c191D4UXNXhYwbbTLC10YT xyC81G1dYVe4uAZpd4O9h3wSo6cdKt2d7eWVrcRrHbPPPENrznakO3qEPbjj8KoSVkY9zYebevHD pdpBapp66h9os7gPhmbGBHk85OTz+FZd1DFa7Ptdt9teUALAG8mVuR91jwCOvNBXK72P/9X+OTRd SneaB3aa1Ns48kXbhnt4wBkKc9MZ/E0Sy2Ouazf3MRFvDI+2K6AJW4deOVz8vNePZI88ff3dzY2y xLsEyHyjIh3oB04NcpcX40zVNNXVTFOJsztZRlob0rwcOcYUMucEc1o0uVDSudZq/wDZENxbXNm1 w1pcKJYYXTzI4WIB8skemeue1QXMj2kV48itcJIoWBQmY0yMbWP93rS5NbXNeRXOXd5pp4BMY18x QXhgcSK47D6+1d3bTPHaW1zM/wBmRYwy+ZHscJggZB6H6+ldVKISV0f/1v4/mSWWAyxPHJF5g/eg 7gAc9K1o9QurO1j2IJRv8uMSxho4s5yxz9OtOK1SOC2hka5FZ39t5rur3yR+V9ogUDOMkIT6ZP6m vENRsryzQwXUywWs10XEaOZIdwzglRzwCe30rupx0sh1NJIo2UP2x1txH5jsTlWO0YA5Oen0r9gP 2RL5X0Iac0VxLc/YA09yhH2iVYREyCQ5xj1I5yi+lfv30faqpcX2fWLR+IfSGg5cDO3SSP6Uf+CZ euXWnfGjSE1XT0uYV0UalbJHMR9lTcsWZMD7x359gK/sz0SaTUPBqPIqPcy2IjYDoVCbVK+uRjmp +kzSUeKqUvJH3f0earq+GVGD6cyP/9f6u/4KteFLzSfjDBdaddNa/ZLmVICkaO14sohZ1KEYJ+R9 x646YIr8g5RBFqkzSNI9zAFZGC4MeRngf4V/pt4JYmOK4CwUY/YXK/k2/wBT/Mbxswk8Hx3jnPRS m5L00X6BJqmlTT/Y0nNwY2XzvJyApPJUg8gjoePX0rQmunvNRVxCGTYBM2042qu0c9ugzX7Ry7H4 5KV7o5nUNQe3il0nSYLWdvOMiobNJbiU5BKrLgt/CAADisnW/slrPbT2yyWt0YY2mt5pQZISVBOQ OhJ6DsO5rSKuzlcrqxb+1K0UN7gSuCTPArbZJWx1/wDrmqt3BeakI43O2WQBklX5Uij6DP0459ve trGE3rY//9D4gtWstPFxZR7bv7O+17kZT7VgD7rHjn2zzWHrFhd6pax31pps1hpm/wCzB4k8xww5 LMw5J5HNf7UH+J52WuR6HBpdnHfC7vpRFBJHb2FwLVy/GQ5KkYHfj1rl7G4kN3KDcJYwxFTMk8bS F4yRlVwOvv7VrBaGTbVzX1qKe7sJbPTruA2LuDIVgAe5C4IKsRuBBAOKx4pruSweT7MZbO1HkzXL KcRNnbgn3Oau1hSbe46OF797CfS0i0+KCQC6Z13FSp5kA7gkdOntUuoQa3qdjdTR3EU1nbzMthdX B2pM3G4oo7E/y/PWCsrmMpPVH//R+K7T+zYUNgFivTHYxXN4yxglCy/MCO2Dmov7V8PyLbuljO8I j2xRQjylhbGAceg/ya/25Suf4eSlbRGfc20LpHJEHaLzVLROSsrJn5unpjtWwupQT3G1P7PiWS3N qheFRIq4CnlhjJwORz71cF1IlJtGPc2cRuBskOy3bkKcq+PX1qQyR3f2ZZInVI5RKqsPLkbB4yO3 HY+taW6HDUbvYv3eo20Ftdww24kupoxHDNKQwtQG3YQHuemT2P1p8ewW3kXEhaa0t1ll6eYS2DgY 6+1WoPqZPZn/0vhe43SbDbSmKPktGw+ZuKt2l19ktmS5/iGIpM7FBz3r/cJxaP8ACVJqxiajqLQ3 VtLe/u4pZxDALdD5Yz03/X/PtuLfzXCGK3TZNHiSEKQpOz5j1+laRjykT3LiXDX7w28s0kMlyS90 TFg46kfr+taGrWMC2Udit2XWYhUKhTKNpBGOuOlUQY6xxxt5KIkc6EYLKFZu3J/xpLuG+0+6je0e CWS4iLRyttuVtG+7+8SgD//T+JRY3kU9qs8kcr5WS6liPlCMdThP6VtGW32x3O5j5Fwp8hkUpIgO TuJ/LGO5r/cqMbn+C1Yhvp7aR42hARZjvtwkgEeQMMCB0+hxWSJUaJ1IF3Dc8rHgHy3Q8EEDPBAN bHBJXuiSK2MZiu8PDNGjKuMgOrYzn8h+Zq3bXCyWk1u8ClPM86J8fcdSM4/z1ppX0Rg01uTWt3mN kug5dJt8MiN8qrj7pH+FNu3+06laSyO00NrbSEwuNse4ldv8j+JP47RVlZmU11P/1PimYIc7nGQ2 doPyFfTFT2s1rY3MYUSTW743QwP5ZYsPuKSDjnA6Gv8Adg/599tixZrJfpdW7r5UsS7niY/vEOTj +VRTyyyxW9pLtaewLSSykiI+WcBd302nk+tBM5aGrfRo9okgaOaNF3AoACQe+R1HNYstwk+1orf7 MibVRQ28NtABP44z+NXGVtGYmrb3RMMokRRPLIuy4JO4KudyDtzkfkKahtGnYs7RtGQWVDgt6VUZ NvUTdlc//9X5AEbq7vBHksmGOOB70Q2tokqSzvIM583yk+Ytg4/pn8fSv94D/nllpElvpA8cUccq Hy2+Vecgd81VjRXa4CAiaPGYhxuJ6Z/CgIfCbF29u9pEEt2tLuBlifen7sADkD1HTn2qkPJt42kh kaRHHlttyNzdxj2NBREohkty06FZA21H9aga4u1NpaxosVlGxEu1f9aCc7ifUdMDt2710HOf/9b4 /aaE3TcsIHYAQRnsMA8VO0VhDcrIkLNFIhDbnwQ3OMV/vQf875Ve2jumVQWSWCTdBGg3NPnjGKZ/ aO3yoirLKASxZQPLxwP601FvYzaXPY0I3e+YtcOJSw+XIAHHGAOn5VHIFjjCsVi2vgKRywq/ZkNW djMe6iSRYbZZpQ7t5s0mBHEMcBV61E8P2htqnzPs5Ej46xc4BPp1HX1qeV3sI//X+OY/JWQo4Ezr 1GcqauS4EPlgBY3wSvTBHSv970rKx/zrlGaOQm2KAMikmU5+ZumAP1q/ebBHHOjtNM8eJYx/yxIJ AUnvwAfxqYNtahboZ+J8B2QxhjnaWydvUcfjWpaanf2sflWzusJnVpos/LcKCMj8RkU4yuYOLQzU GiMr3NvA8BySIicqoPYfTpVSGdwfM6BlxjvVCP/Q+PkWW4lgXy0w1wrZP3mOePbrj8q1GvQ11qFh EzXcdm2bi5tpT9mDMMAYIzkZ69+3rX++B/zlTVncxYzNLJ5FuzZ3FiM8NjJxzU6RsZhNc2phEfy7 Y5MmTrzitYLS5BduIUZGuIY3W3bEaTMhVXbbkjnuM1St7UJHLIixmNBtkTjIyeoH4dquxVrXRNKs ccG3auW/ix8x7dabZlLdJfMEeZh5bll3cZPPrU8qvcnY/9H5MAt0jULnfngjjIoN3FZAyFPOMg27 M7cHsT7Dr+Ff78H/ADjkTXcVwvlzkSb33GNk+RR/ntQ00cCSJFbxNHIuxcDb5R4PGPofzoAZCbTj 53lnUkzRFM+UOCDn3/pU4Mc0rs7R8R5jXbg4AAx9aBSuloP8hJLY7ZRDOjAxIwyrKD2x/WqrsFCK 7FnPQY9KLdDF3vqf/9L5DlQeWk8wTanADfqRT45Nts4TBjkxtO3LEZzkHt07V/v04tI/5vyONGFw HmkzEF+aMjDfhSPNaiGWWJmkk80xywOCDF0ww7YNNQb3AgikXyy0YY4P3R1ar0cgmUwvGVbGeOop qn3ArvKI1aCTciqcDNSxXCRlcx5CjClup981aSWwH//T+TnvMFFdRIbg4jWNdxGDzyOn40siSK8c 7bniZxHtBAYDv+QNf9AB/wA35Z1MRQFEhjl2uBIplYMSDyK59LpmkMeGUhsMCOKlRSd0BpRyxuGJ CblOwqBjGB1ogi3KzMTg8ImfvVRlNW2HvFFbgEghm5IxwMVfNzHcRf6VIY043THO4Aep60EH/9T5 Yt5UlyqyB41f91JGNoYdBn/69XhJ5bYK7w/yqM45r/oAP+bcoX9s0MwNxGyE4bYw2lR9Krz30McJ k8t2VMfLCB0HBJoAktrqMsZYwdrDhT1qGaXdvnmh8gEbAp+cY6Z/HrQBlqmAiKxdAcowJNaI3WwE 0Ug3shQLnO3PtQB//9X45jLZYN1Y5JHarZm2ugBAPQGv+gA/5tzQhdmbcSCwHcbgAPapyLeR2kkM cQC5GF2hyuOOPWgCOW4tXEahlJPCqOrY7+9KkNw9zH5U9vFHtLO0zldvGcZAPNYy+JgRPPFbGRXJ d5Wwhj4X8f8AIpwysC4jVWcgt3I9qTVnYD//1vk64txLGoDPGdwbIbYBg0l3Db+fGbGSRl8pTMrg fex8wBHbPrX+/B/zbiw5lZgy+Wqtgd6dKszb48gKi7ssQvAx6+tAGfBIEMmNwb1IIB9K05ITJDGT 86OMnb94UAI0ywNHDFlUZcOg4HHqf89aJIoi0nklyp6Bzk/4U+gH/9f5Rnm8qFI41aViPuAd844q WGVgVBU7cYdDweK/34P+bcbNe29wPsiWNxbTwj97LJIJbefP3THwMYwcg5rPeQRyIi5Y45I6L7Vc ZW0A0gDJEYyuFbB3dDUdvblmmTzEtVhQyeYxwXIx8oHcmtE7q6Annu4ppESOD5woBij+ZmwAC39T VaeKVG2BlTzR8q9CPr+VMD//0PlOFwbaa0nKSQyL5cmf4T7e9SII4kitbeQbIIvm3/w4zj88V/0A H/NuIZmdlLnpxkd6c8ohXDKxWTgOB0+tAENvNHJKqyR5x0cjlh6VLfO7Sq9oWjWMYXszfWgDJkMm /wDexNvY7lY+o71PZvPHMWlgd12nDt91ew79aaWjYH//0fliJ0uULysfP3n5CMbQOh/HkfhVIqou MtH8icsDwGr/AKAD/m3Ejebc7W5CxMflUfdrVEkSsmzb5gH7ztmgBk0QO6QnII5GOlYu6RZ8Q/cJ yc+3+f1oAtMxgLlAwMnLEZxUAlkdZGCKdxPlqPl2e9AWvsf/0vjh1kM8alXkUcFAxVTUggWB3fMm Hk3JGzb9g9Aa/wCgA/5voqysSSG7RfNLFYQeG6FTVF0uzaTXNtIk10twiQWzHywyHO5i3tj079qB mrbwz3UbxXDxW0qYXl8ozdOD3HB6VVmtmglMbPkoOSpyOKAJbaVZpBHvCuwygbgtj/IqdW3s65VW j4bnBrPlajuB/9P5HZ2gIc7X3g7P9kj1/T86XyZJ1WTIUqfm5wrV/vzd9z/m/J7m6jkUbYIkCKA6 RghHwMZ698VnwyRxhkjRN7DcUPFPmd7sfK+xNLHwpGFB5rMlR2Zhn5emOuavnQ5dB0EUattU7Djn jg+tTq4ikILYx1PaiMruxpG9tT//1Pj66LiNXiBkZiAAv1/+vUVwlzFFiI7d4G7IzX+/0vhZ/wA4 4qO8MaySvgDt3NRiVJpPMIwrDAyMViA6KNZC21mUZ7VbQlVdVkwEHIP8XPagCkjyGQNOkieWT8pO Nw7fgal80iNmXt1+lA229z//1fjm3ZfmkLcspHPaoY0G7MXzbTzz2r/fg/5xzRVI1jYlS8o+5k1V vYUnhjOXV4pFlCB9oJUg/N7U03F6GlPqQRvj53QEHgnsKicB3yCQoPGO9VKWuhoEzLb29xIxYboW SN0+UqWUqCfbmvxf/axWFvF1vbPK1zaSNcozwRldm0RNy3ZWLHHrivy3xrd/D3HL+6/yZ/SP0XFf xNoen/t0T//W/jIvltEiD8q0MZVZWbAX8OnpXCXatfKpDFhv4LHGD0FfouJivaSSPEpxvTOz0Xwf fSaVK2ozaRYurkxPcalHE7qP7qk5J9gOcDBrl753gkaHekhiO1JEzhwO5ri6uPYinZtrt5f1/wAA jiuDIDIwfYgzIMbifYVTkgaW5WWGYG3fhQAd8ZHUGue1tDY0LSzInAd889xzWi8kscohjQbQfmau e1tAP//X/iwzGGkeRzhI/wB5EFyy/h+FZkpLHNvH+4IyG7nNfUHjN2VxsbFBEVkZXByuPlZOe1Na QQFWJaY78lzxjmgiDvuFw7SpwGRXb95tHB+tPgsPtcggHQpnzCwUjHPU0GhHeWQiXayYIGxDncT2 zSxLI6IrMEZY/vMcDgcDNS+WwH//0P4nEuoxafLuZxwcdR1rOivJC4AZiiDK7zlq+gPMTfNZmkY3 nRbjJZw3GOB+daKqGVN3MjDaVYbiO2aCyuLYRyGC4KJJjG912MT1FQLd2wuWtbcuwVAWk8varEdf wzQBR1HU2uHhEIy9udq4GAB9K19On2Ql5V3M3zDH8jWUpdEB/9H+Jt1kklEUA2xFizADI/GrawmI TB4jD5Ue6FuG85vQY6CvdhseVPexdsLuSGETSS+TIpOFQHcR0rUk1SC9jcq6lljHmopAlI9KmUrq yKp7HKXDQ5M671SQ9GO5uKqW0h83zWwFL7c4y+KgyO3a/wBFOnTW1wmy825t5l55H8OK4VSh3s0h 3FsLsPAoA//S/iYAgbYsodZFO6NgMZ96ZOUeaNJB/o7EBzH1OO9eweOOuI/MRCF+SJv3WfvD6UkS PIrs2U8nkep/zmgBsXmK+1tyrI2QTwpp87xMskGwCUn5HPPsRQBjsLi3kRWy0Zb5sdMe9bNvcC3i mCIhaRQsbsTmPnsP8aqUmwP/0/4kmUojyyEuR8xQDOacIwytNHtIKglMYcfU17B45REkof52YIOV GMrmrsfnTRM8jqDnKjHasZfEaQfQtwSzRxyeZPhA3mRxAfKCBgn9KpxXUsshK7sKxDM3G6pNB6yz GdLdAhjySXbjFX3hRAW8wMnQnvnuKBrex//U/iRvZYodm0jDcZPUVLaYnTb/AAocMW+61d8XdanO ac01vAIorfazpyY04C+1JKTcFIo/MjLDc5AyqfWmBnTxlXiinPIOVI6Vce4jijQN8xc7QAufxNBc Y3KWoyJMkUMduDzky9MY7VphLdYYZI1dGWPDIzA/N6j0+lA5JKOh/9X+I6a5k80B5HjVeQQTk+wp 0AuZojcMjRK7GMbupx3r0DnHbntYyRy/UkcmnsyS7ZzlJGTYWA6nGKBNJrUoyZikCxSSRyMMEKcZ 7Zq2LS7hWGSaOQrIcJInP40nJJ2ZgPkuGRnUkl8bfm749aggPlKWZlO7llHO360077GU1Z3P/9b+ JiOVWniDM0Z3Ao4GEJHTJpLnz1vPNkZtoXbEinKk9jivQPHNqxgs1QzXhkN5jfGoOVQe/wDntVtE sJbuGaRp5bCIjzxbgLIT1IXPGeO9A0ruxT1ubR77UJH0NtQt7NEVPLvoPLlBHX5hwwOM/jWIbaSA yTHe2BxgZJ/CheY6Sml7+/W21+tiRCZcMw2kfdQ9T+FT+ZFs8qbDOrbkyOR2wKDY/9f+J1HRIp2J 2qnG0n5tvtTUtzNEZOIRj5CcAADvXoHnlcQvIVkByqj5mT+P6VanuJIhD5AY+YNsrfe2g9vrVw3A sXLRW8Ue995mGMAVlKzLKXRpEjK/dLdP/rGotbQDoYbOzkjtpJ5o0eQkgN904HT68U0RQhpJVdcg 7S56kCgD/9D+KmeZZnwgXIBGT1NUSin7hjDoC7FjtJ+n+Fd7PPI/tIWM7873baABz9aoXFvOziUI fLXksTmmBagt0eIOH9h71JaxSJHPDLIrKrboMnDepBoIc0tDXQQpas0byJPgGVtwCjA7VlCMXDRx Zy8z/ISwG4/U1Kd20Cn3P//R/iZ+xIJolc7ip/eIec+lXZILQBdiuZC4UBfugcY716B5UpXegxYE ieSORQ42kOr9j0/SprH7JbRyQpGwYphZXP8Aq+ecVE3ZWGp3dh85t9uVYklctk5z71kI8cquro29 GwPQCsi3FM17Xzp5BbJ5UaMuVEhwAF//AFfyp1xdmIrAIld4QWDkAgemfaq5nazGf//S/iSilBJe Yguz8qBya0S0c5hUNgpkQkj/AFRPUiuqLszzmrqw+N8ymJ52AVTsCjJJ96klRInQTyRF2TIAYbm/ CtjNQfUy51EofaFBHQjjbiqIvZ4nHmzebGRtBB4A6f5+lBpFcqsbKTI0A3gs4XcF9u1Zcy3ErAQY X/Y5/Som7aIZ/9P+J+106Znhku59p6CELlW+p9a13vkgLAp+8jIMXHBINdjnpoeeVNUvRqlzFcTB EXywkm2MIcjjPFPgs7SAybXR97AqwbKlcZAz7cVmBn6j9nDu0ZBOMCIDAOB3zWWwZMFkkkEmNyIc hB60Ey+EQtgLDErFnOMnnH+f6VJPNOIfKjTIVQCQeVNBif/U/iUhtSTA7BfLcHeEGAPeibZDIGH7 yMfJtY4BPtXQeTD4hlrHBEkrquxU6KeWyf51XKNA5d3JEpPDD5QD2xRY2LkJiEgMimdUXbsJIEYP p6VVdU3h4kCujEgE/M3se1AGl5kQst4ISY5yhOShrKikd3CSj93KCC57/X60Af/V/h9n04iNpoWI EbbWjzlWFZvlNDKCwBYchSOK6Dgi7O5bgnkmCxyhMGTv0HpWvaNbxSzu7k3Bj2xgDIXB5/yKGja6 SuMa3hupC8k7JsGWOzcMDrxWhAtsQ0bTzeVGv7htuCeemKCZatFSaUgvDK5UN92Q8t1/z+dJLIIr UrGY2jQfPvbDncewpNXViz//1v4eI2Z8gKu1ThTnNaaKyooOdgHTsKbVnZnOQ3Zjjt96O3mDgKO3 SsxbwbBK/mibeEzn5CPpSAuSMWi8xdzn+PI4XtxUEKiOSMuSR95sdPoaANUmOWMhUAJbGFORiqC3 U9krJHvUF8HIyvp/SgD/1/4f5YftMSeVEVJHJ/iY89ailhmSKCORyZIz/qm9D70HOSRTTQ5DEwns 46kdq0YbU36CV5wksY3DK53/AP16B30sUZru5tivmEMobgAfzrTsZ5rtSFRd5bCtu2qv1oEU5YJ7 G8MV8Vcl95RcOj56EkdqmvEWCKGUM/lmX/VoTk+x9qmV0h3a2P/Q/iRCG5QgoFki/wBQSNjkHs1V VSS0nVpViZEO7ATeoJ74P1rnOcqrbwlmy5PmTb89QufQVZn0vcXhRpUj2h45+F3UG0HdFUXFzAfJ aIylSFjcZw4pZGaYLNGWBUYCE4APfijyKHIvyBnZk2nlqoTw+fIXjR5IkwHcH5lJPX9K1U1sB//R /iFtVVERXDOiNkHHzLjvVdY3nMpCLM5l2nJ2kKOmfypXQW6DTYLCqNyQTlx2Q+lPaDcDlmMrHjep b8DTKUW3YrwjMrNMmxYz5Qjz1A7/AOFa9rJYWshJtxK4cMEfIjlwehI5xSbSWpqoqOwovJBctdWy /ZyJP3SoSFiPoO/FTXclxdPMXuncvGFkYnLhvXFZOTYz/9L+Iq4uY7TbaQsrbEH70jAJIG4Y/Gqj fZpLmMlH38BmHCtXObt2J444TMEeWWKN22Ssg37B6n/CqE1nBJJJHBczFmfEcjLsbAP6Zqvs2E5q 2hPbkxu0Url0QYRZD83FX7eFfInDMxlf5ox2UD3qTEZMkTpAjLIzqczR78LKB2HfNXVSK7sRHFbx xSjL7HkAIUe3rx+NVzMD/9P+Ii4MBAUHEqR4lI+VZfpWXaR7rnanyNH+8IJzkVipNAdZYwm6kiSD YZGfaochN59OeKJbS3jmaVYx5gG5mP3W9v0qGxPZnrnwRsdE1HxfDe6tbQpLZyE2KtlmMq4e32H0 Lhcjr0571+3ng7R9RHgqyt9YRYL2+SOeeLGUWRo4mjjSTv8AKy56cnp0r+t/o40YrD4ust9fyVv1 P5K8eqvNmeBw7el1+L1/JH9tH/BMfR47H4Q6DPCq2ckWlwf2hE65mR9iBEz1PGa63/goj4tXw/8A Du/hmYyGbSrhbgxdSssbpGvt1r8nhT+t+MdWD61n/wClM/ofFNYDwsp9OWivyVz/1Pzk8bXNxpen ahbXV473OjawCschMrRZJmDLGf4QMD9O9fhF+00tl/wlOpan5MEEZupY9LkGY5XZiHclc4HylOPY 1/oz451PZeG8ox/u/dc/izwEp+24rxNSa1XN990fJgmSflm3OBuBPOcVp6bHLcyuqswRByxHB9ga /wA26r96x/aEl7yOjaJk2ugIKcyZGFAFddpbxXCQhrb7Qigq20EbTg4P4cH8K4iy6iwRTW6FUlLn esbqV6HoV61cNkSZpXkMUS/M0CnCMBnGRXM1pYEr6H//1f4u445FjnnTEtnPlLWRTkI643AeuOOP erenRfaLiMqjs0EQnkIT5WU8fMcdvSvlxtWdjprS4htfNdjiL7xwNx47CrY8i+eBoVVY2lEjTD74 Qj0NAipr1t4dub+0ggu3s57OZJNsScXkh5G9uuOe1dLG91B9pWQi6NxB++iY7Ufb0P196NgMWyv4 yJIp4PsryOY/LfEm0KeCD6HirqPb3EMyRxh5lYiMkbFbA457VjKTeg03HY//1v4/tBt75HEM8NvF HuZpZ5Jik4B7Bunb1Fb15pEkckOqW10ksMD4kti6/MSMDb3Pv/8AXr4qc9NDSMm3Zmrpd/Fc6qNP 12xlsoPJbbsl2vJ8h27W65yQfpmu88L2Gli5uo9Ded3ntRFJbXIdyhBILDv3zx7Vx1p/u5ej/I3g 7XP7zP8AgifoC6V8BPAjXCWemyahoxuSIR51zPEOI2fP3SQgJHofev6DLMYWNyd/y9a/n/Ioyhjc c5butUf3u5dFqSk47alxhjc4+bPABGcVGZF2bWGGHTNfRx/iWOlbI//X9J/4K9+GLGH4e2epT2Xl raaol/q+o2JaWW3UnCeYgyCATuzg4UE9q/kW18XUM9+0+o6f9lkh8qwlX55rlAMkOMYD56gY6V+O 8DyX1Kcb/af6foeNgHKWKrwa00f3/wDDHkd+r3KyW4mdJ7iJjG8IKiELjnP6Y6155Jc3ELyaTcXa T3UC7rlR9+RCeN49x2r9Hi7Kx0OHu2NKeK1byLfSraPLpGJpZybf7NxyqAHaR/njrVbUJY/shtph 5h3mDz43GFzkEN69MVYJWQ3T7T+zZ43sxa3G61RZmkn8siMgEKgPUqT09R171YuNRhW8tlNi8mS4 MmzfHAQvG49s9qBn/9D+MpTCZx5lwFAG/a33+TwCO2P6VaktZrcyByhgVftC+R85kUgEHHr1rxzg W9jNvpmiwgaVopCCFb1x0/TNUDZDV77RZLuEyQ217vurgsVuYowvRT3xgU7u1i42UdTq9SksobrZ Zxt/Z4bMYVsumONxB/zzVtbr7fHM1tK9vaKBZXCKdguCRkFgecHHbj17UJtbGhxgtJ7a8aNIBDFa zmOFl/1a46FCOMdK7CxkkkSSK7+0TzyHIZhvQKeldVKRLasz/9H+PjzXhia1trWIk4JSR/LSQ+nQ 4pl9qNwlrifaqkfMIG3gEcY/D0NKLvqjgb0sZ9tBcTxLtkKxygSncPmYH2rl9U0cvdySTT+bGSPJ DxbFj2j+LnrXo0mkhVJaIwRpHmzRf2bciC6OSgZgInPXkfhiv0r/AGRvtGnPZiSFJ7yeR5LlYbh0 iOIV3KCegGNxHfmv2vwNqcnGFJf1ufj3jlB1+C6kF3/Rn9Gf7BfiS/0342aBeNcCYz2kdleacHVo ZYykpdlYYyFIQdO4r+3zwLLbHwbpgRHLR6VG0Kn5t6ldyn36mvf+k/Rcc7w9ful+B7f0aq3tOApU L35ZP5X/AOGT+Z//0v0d/wCCwNhJD4i8P6lBpzLLD4hhhjIQq9yJzKjfN0z+8Xj61+KN/Dp9q8tw Uid2j+d5VBkjC9SDX+j/ANHuV+BaUr/ab/I/zj+kd7vHVVJbRS+44saf4XS7lke/U3t3F9oSG2jP 2hAM7QRjkdvYVm3Mbz+THZy+XCzYlMrmMMp4ORj9K/f762P5ydTcyrnQriN5oPOXakm6Ca2f5l4H O7rkEVZtdO0iKEPqEUdzKsnmz3MuZJWAxySepGCfxq4vlZi5u2pR36Jdyx3Gmm78gS+VcL5ZRSgP Rd3Oevt71ZvbyyiQ28Lzxwg7eI287afX1q+fUzc+x//T+D4F0Nm8hNS1eZliN1bW81qbFBJ0+bd9 5foc47GtI3UUEMSCT52febZWwR05x71/tIp66n+JfOc/dahbXpiSCK4jumLLKZlwy7WwAox06dau rb3QGI7aW8uDtTyiQvmEnG3J74rVNrYaSkh9xCLPXrhJWfSrKFUjjaZjcRtIEHmKAvbcGAOP5Zq/ faiup6V/Y7XLeXcHzIFt18rzm4ILOOeBzyapTa3FNamdBLPpVo9nEiB8pukmUyOVB5XPXnJ/KtlF GrWRt4VeyiiXCsDlUbHJHHt0+lbxlb0MZrQ//9T4asFZdSFrczxqxtMu6RiL7QF4UFR6+vtnrTLr TpLeRTa+XIJpcbWcRiMHqRmv9uU2tEf4dTVncqXl7cafukdfOa0TaypibYpPt25zUK2UF7arc7RI C3miQ87Cw6D0HXirg+hlLSLOhtQzWQtkighEK7lmcbWfAAAzVa1nj89pb1mVmJB2jeCQCB/KtU7O 6OSfxGdNY3Uzu9vE10vnAnjBiUnq369K1EST5reGJFmlQIJZyY0QjufarU31Mm9Hc//V+HdQsLaw vpIrS7N5K1vHLcS4IhQ7RkAdBg5HvUl7MslkkNsE2FQZehzjGTn0r/cTn18j/CRySWg3SLs3F1Fo s0cWp2V1MimJ0URq6nKSgkZyhzjnua2dTtLSCSS3s7cy3kTeYgjcAKAD8gOcenX860M27mTa3/n6 Wt2tm8d+m6OS3lBDSMCRj2wRj8jSWVx9sWMog0+6t0ea4W6l+VmXnCH19BQJao3dOt5dR0y1uLyf z7yGRmkliiAjlXORtUfh9az7y0jspUMNy1y12DMqhCqw8/dagmTaWh//1vjmJkETO0bG4KYc53AB epP6mq0t3pU8SlTMbmPkRqpKT9AR6fnX+56aex/gtJXVhl1dWdpJ5ltoRvoDGXSLzfs7o3qxHrWt bw2ccOlTpp4tEkj81oxJv8jfgsmMZ6/ypnNKN/UZrNziRYokZwiY+7hEHoKx9PLTzF1iVIo2MZIG FYn72K0g1sc8ldGr/Z7vHfXNpk2VtIqM0rBXVmAwMdTyeop1qF+zyS3hUyvthiZflCAcAYH6mtDG x//X+NptAfz5xLIYGQbtpUtnPTj3rKhhR5S6BzJbPsDPuREIPzNj27V/uwf8/DVjQivTDdpFaQxs ZHzdXcmRI6+lXDY2F1JPI8XmzNgvGE3ecF5APqPY02rGEviIbVEEM08gKxhvLSGP7iDtx6YqXzrd TJDCAyiLZGfLywPr9f8ACrgk1qSRQQyBc3C7JojhgeCp7g+lI5RpAJAuB0IUA/j61pa2iInsf//Q +PfPZp1hidgGQ7QOhx61t6ZpMt3ceXczpa25UFppBlE9cf8A16/3gP8Anjn0Ocni8m7lQskojOFl jferdc/yq/FtjiSaDZiRypbIMhb0x1oJUZW0LbT211ZoJCHvbWeRHndCGQOFOPf3HsKzoonlaC0g BncsFIiTfM5YnkqO/wBPSq5XZFwu42HAtuWBxmMvtJYYK+tO2urrBATchZQfKHV+cYx/X3rVKysT yM//0fkTTrxE1K6mu7VbaRQ8TWjw/KgI+6Afw5q80ukahGkccdxaSICckbQvzfeIycgdMcV/vQf8 79raFWC3tPMFxcMdinbujHLY6Yo1m2s4pITEwLuu4jPQfStofCFimlz5KxRQKm9JQ7ORlvpU92A2 Lm6wjynaiKOuAMZH+elUZSjZ3KDq6keWgG8YDlcgVfu5YobG2gVE+0MpkubgIEaVsnC5HYAd6CD/ 0vjW0tXlZp4wxO3lVGeB3qyzZkSNhgjqD1Nf74H/ADrkpjw6YbPcAGmGMC4kiLeTO7JFBE8TPJdy yMqIiKAct82ecdDzUQWgF24tm04Nb3seyYttkV/vpjg8fhis6GZpLtLWBNwaQKkjYRR6HJP0pxjZ sylLoh7LLdXEsX2pP3DFJowQVDfX8O1MaLyZlVRvjUckcg1RB//T+R/PX72wrHu2odp5PtTGvoVi uIks0S4J4mjOwzfKBlh3PGMnniv98D/nNk1awulBIFnluYQzSfLCUfDow5yfb2qvPcSs5ZcrtOPq K0jK2jIUdUi1b3iOkdtdfabq1Sf5YYpjGid8gHIH5d6pzqJZHeCE2sKMf3YcsT6sSevQflVc6Brc lXy5YtqEyFFyuDnGKitQXRpJHVljOSPT61RB/9T5BZGlIlhDStkbYoxkv6AD1qs0EsjebNDPbSL1 t502OvPcdq/34P8AnHGGMRyBmBx+QGOtXHt4zIZEd2QgERnjBGM8/WgCOLMTzTxp+8KbZDtyWFTp tVNxXlyN7NkMnPAUfzzQBJNtjb5GaRPXHIp1moJeWVP3LHZGzDPzDqB+n51UPiRDhd3P/9X5Ilmt A88EolYhT5TKmY93YHPbjmpLbLKoZMJGu2NcYVQK/wCgA/5wGrOxFIgudnnQCOWOQkYblscD+X61 AFeTejqoycH1+tAiW1gSBJsrn5hsJP3evb3/AKU4TBGMhHIOB6igCtdsZf3rfxN1PrVkQia1wu0s pGWJwR7Y/wA9KAP/1vkq0sg8sccMhjlf5CzyBUycjr2pZwkU5tpJmb7CW/eRHdFKx4OD0I47cV/0 AH/N+LLdubb9+jyuDmJwcFUx90D9aqwblDMYVKzDd+8Ub8A/wnt07UAQC3uTONkbeWckkdBjtV6N 1tozPOH4lWOOIcu+c5YewxzQJq6sWbhonTfnk9z2qrHPtUBsEHjngNQYH//X+TEf7PcZi2vbbVOz aUIOMkfnx+FXHZpQWYeWo5BHQV/0AH/NuRS2sUYLC4M8kwDsoYnZjjGD06frVWOQlmjiAjONpDLn I4zxn2oAe8ltBDkMIwx25xwDnFKnmSLh23xtwMjnFAEojtoGVVAAVcAAcCoXgjkf5EZnyX354UAc 0FKLaP/Q+RUjWeQIgCMTjLHA496nnsVSNWO0nG4HIOa/6AD/AJu+TQmtUDcsCFUfP2Zh35qnMYjI Vjf5c4HoKDMZaSIl0jywpILdiYt65VtwAOfy/SrrEPKXHyh2+4vAFRKK3AlurdUijSSEABg4lGck 8Ec/4VA07MAcE7Pu8fzqJKzA/9H5KN3FINjn5zwR6VLEkUW4AcFeNvGT/k1/vzyu1z/m3GWs8u+R bhVCoT5ajgsOxqa7h+0D7UWk80gBxnEeFACgD6ChqzsBXjgLDZtO4LvyRjjrU9o22KQM0jOj/KgT 92F9c5pARuPmDEcHjA60SzrAA7KRg4XjO/2oC3Q//9L5bmnjnt1/dRpgc+Xwc1lIH3ryxAOTg4zX +/B/zbmilvJKDvzhOQB1IqmscdxOzQq0KI3yCQgv75OKALTXDRnPlNLGgwwi5b0zWXcF5JVnO5Yl bYQB0ya2irRQ2mty3ZSPBK865Ro1O2TocYp6NNzNcPHJvYyw7cZVScAfpVCP/9P5Xa9D20lmYY8X O0+aqgSwsrA5DYz0yMDHWnpDbqCuQWx8xxgtxX/QAf8ANuQSRo33CRt6fhUgninhKSEMqHYYl4YH HWgCpGyB28vOFOFDVXnuShLA/dOCOmKAHJI7NGzoXz91AMk/Stm7vreC2REUoZAGYSYLAjPTFNOy aA//1Pky3m+0W8tzEoHlybNu794T9Dz61XMtwrRXAClt3zxPyAP5H/8AXX/QAf8ANuaEZAj3qmCT u2KMAfT8qDEVkV1UEt6nAoAs/aHZZVkgRMcDa+/dx1/GsOJ2a6kJARAcDBoK5XexqPEzRiQj92W2 59+KxpkeCZ3Rwd67QFbhR9PzoNIx5T//1fkKJHhRdzZBGQW5alEiyyFMFmQZyB8oFf8AQAf84Fm9 h14r/ZxsDO3Vo8ccdDUFu6m3UcCUcMV6f560CtYVpjxGByO5GabOsm6MqDyfmagByJMsyyLCH2qc Mq8YHX+lVZbzzbhYxbmFkkPmyEYLA9z24xQB/9b5EBBlXmGQJC6eYxyOSPuj1469aEE8TYLpsmXa iH8q/wB/XBdD/m/I1iZQyTMArNwAazJ1thcnqsifu1ccDB7VLg+ht9lfIuGcJbEyPgqdq8cim2zQ yRtICXYtg7jwtRYhpuwDahJiBdQ21mPY0TQJKhBz83YcE0bGiVlY/9f49i3QoIlQkqPlyetRi7nu VjEkJQrJiZQBlecdf89a/wB+bs/5xy3KY1jIkQSIMEA81jT5lfMeEBO7Yowo+lICa2lMeVf8COxp yv8AMxGWIOcAccUAKt0bictOCd3DDOGJ/KnqEWUI7MsRPz7eGxQB/9D4ue4g2ypb4fYSrqpyY/rV aOVoXiaLcWYEMpUlD9a/34P+cc0UuZmCYjJl9AMgVYnSVot0jxCRjnanGwehosaU+pW3edB9mUhX i6FVA/A1XUuhCsuWU89uKLGhBdXd2scrWpCRxjLuYBOqdcEgg8c1+Mn7Vc97Frcot7i0ESr9omh4 jeUjCBc9sEdPpX5b42u3h7jf8L/Jn9J/Rb/5OXR9P/bon//R/iz1WXzUUusTL5e14423KuRXM3MK RxR7BLuDbuPlU57Gv0fE/wAZniU3ambNvdQzxRRTITJFgBTzg9iKhvtPERiuGcSCeTaQrAnFcc1q KEktGV3eWJRDbFQm8M+R+FOnyUTb5YZeQF43Z61yvdmhbt2Cxl5FOUXPHXNVbnVUeSGFInDBstKO G+mKwl8TA//S/i0h1GAyytLbpLJcqqSSsPnjAOeP896Sa90/y2WFBlDgnOF/z/jX1B4sldWMK6uA iM6oTIOAwGAKqxysyeXMm4HlivO30NARikawS4MROE2BdmV53DHX60m7YEQMWOOqDBpS0iyiO5nW RUhkLBlPySdHA9P8+lZavcKXgl3yop3I7DB2+nvWAH//0/4iZHllMcduqRRrHgsDgufekt7ZonCM Rzy5PU19AefY1/PkTfHtQRkDYFGFpYWkPm+UESUfcZj1oIlKzSI74yTyndIJWZB5gDZdDUX2aVEK 8Rtjjn5iKTaW5ZUtYY18xn4cPtyfarUd2yO0dvtdcYO4cj6VgB//1P4mokkBMjTCJS37wA8/hV83 MZlVCzlY0+XIyW44zXtJ2i0ec0noUrqYMY2J+Y8FU6cetNsod8jTwAnPDbRzxxg1IRVkP1S6gjji ha2WF1TbuDZWQ+pz0J9Kx7Uylw4YjB9PlrNzaZjJWbLc7MwCkL5iHOQDlh6UW9vErKTtV3YeYTkh RVpp7CP/1f4orhLUzNEHMsaKPLnUbAT34NZxgyJQrHbF82T6V7B5Ci3sVlMrqzrM+FfCR44xzzWq HVYZHLqAMKDnBY/SldD5JGRcXFxLnGF2jAA6Y9R706yMgQDZ5gVi7SMeVpj5GXJW80p5kfzZBQj7 ritqx060khe7uDGqR8CBpNrM3sOvvQQf/9b+K+5Fo7J5QKyFdnlAfIQP61nXSRxfKuFOMECvXbsj xyrAsNvEzOS2STtPNPz5ke8IsKltqYPBH0rHd6gPhbzkeF12orbfMxyCPSmC1xlIGAbdyzdCKtw2 SHdoktVlJRprdlCPt3kdR3P6VLf74RsgUHecqpGRUNWdjWMrrU//1/4jo4FfJv1YEA7QvHParMaG GNmRMR5wFz0r0EraI5IzWzE3hSJSoD5+Q5xz/k1r2SiWNiHGWyG3cbaCrozpI5pWJ2N9nRtqHqQf U1UupPJdYeMbMrI5zz70FXa2LENsI7YTSSeY0gw205GOelWoCX/dsd6qMjszf5xSvrYG29Gf/9D+ Jq8ggaaCaNSEDbWWRslT2/r+lPE1u88duZHSNWy4xlR7ivQOfYhvJY5HO1dkaDZGyHcXPv6UyDJw uwsE5xjr+FTL4TGUrjtsU0yyklXU/wAXAIz0relkFrbSsqpJKiBo1Lcev61iSY8jx3Mr3E9usJYK Y0TJUYHJNVvs5gl+0Km+OfMbJjIH4VrBOxEk3sf/0f4k5ZYLdQNruwbcuf8AlmaWO5kuGRvLAH3U duCK727K55Sg76lhZirhQSZgCgz0x6VJB5i+bIw+dRuMCHGRUc7uXGKRaR7ZoA7earbt+0DgioZN Rg2SBEkZyOdwGBj05q7q1x9SfTLGPUp0uZJ3ghiX98uACcHsD1qHW9Phtr4rBcLPHtDqw4YA9iKY nJJ2P//S/iQ8ucMFOGWZgqd+Txj/AD6VeW1khfbPN+7KbWhZRtOe9egeeadvc2aRmBYPLhjQJuI3 ZPqKwWuniuMqoNuWwy9Sfwpp8oFq5uVkKgRLJxxHkLt/wpqrE8gaUmOMjadntSACPLkVcs0YHyNj gGqbzyO0cYDRvuxIP4SPX6//AF6BXSP/0/4hZQhkVYpmcD753ZwfTNaUcUU0XG9WXow7+9d0nY8t z7ELiELIGYmRVyP9kioPtrFBGxdAxC5UZVh6Gs+a7uyXJtWNm1gXERKtgvswnUZ6HFNvIbcuqMGG 5tjOOgx3rYnYqvIhQrCpKRN5YL/8tAP8arztH5cJypCvgRqfmjPH86BJprQ//9T+KOCWHbG0YDP9 1g4+7jtT57qNsAL+8Z8kIvl+UR9P6V6B410nYqnzJGcNubdy+fT1pAiMhjfIToOeaTV1YZXtBCVm lMjSuq+Wilj8oHpU/lxFY3cPC8g47lfqKz9mzR391IVRJGrReaPOHMbngEHpVGS8kt99rc5FwWwZ M5BH1p+zZof/1f4jbe3nhxM+x1kBAH3jg8VWQ3vnrFsKJvwGYbVH1JrotbQ8+xvxLGg3BcyhcGYj IH0qoI7MvJNcJK9wq4glD4ReeQR710AVHlW4ZVTMKR5EhC4L/WqH2d2WUsd0cIJiUD5270FQ+JEt v9qcD5jHldpZuuPYV0ltbp5tskZAI/iY8n1zWD3Zco31R//W/jSmhtI7AstxD5+7b8xHJHYfSsBV tbjLXBVQhwWGFz+NdB59raFbUYYrg/aLT5YIoxGYxj94em78f61jQQwWyyQmaTdIpeLByockE5JP AxmgClcCYyKYzudQFy3Q1qWOFDCUEEjbg80CkrqxutHp8lvD5Ft9nlgUrLMX3Gf3rJd4yJFEOQOC MffoMD//1/4nopAsQ3DJIxszytNkSBlEp2nyz8qHoxz0NdB5UFrcxLpbmGYGXCrgSqqNuTnkVe2S TWK3TMdokIVQACMe1bxVlY3UW1dDrIArLM0wwB86lcHjvms+aYb5GRQ+BujfOA30rFqzsPkZReWU 2xDtne3zDPzLWlGRFbwMQXR85A+8MdKQezZ//9D+Jq0S28qUyS7YnQkxtywPYCqL2kZkcy5O9cRs D93HQ/lXQcDVnYpNaw2zukUq3RByXVSqLnnv3FT+WNi4YLKoyrHhzQNt2SIYJmhYkSF0c7ZAeQcV LI8jsJGcn5/3cYH5DFBJfXSrmVGur3zVwB5Ue3kD1PtWRqCKSkYJVehIHHFB0H//0f4fxEoRIrcg CM5buWz1NakUJ8iQ5ymcZPRfatpWurnOUJoZJUwMbQcZ68Co2tEW3Z9qyAnHl9zg/wD1qTjEC9GF nt9ke0SkYZW4AxVCdWRcOoTJEbY5Ax7/AIVkBAC0QM0LgLu2YZsFiO2KtiQ3BRGwFYfPx8ykUAf/ 0v4j4Zra3IJlO0ZUZGWyB/n86RYfPVpQA3mAlGb7w5oOczZHjZWifckjcLI3O3HarNr5iApCxJxj OetADPss8shLYdGbLqeoA9K14ZLW0gyIWG5s5H3j26fhQJKzbKvFxFcTrFKWEiqjtxEEzyOnXp+t V5Y55QPLfakZzhuAPai3QZ//0/4k4tWS3kfzLZWLYG452r645/n6U2MLI8iSOSGb06A9qz9noc4y 6eC3liVoZGZflRUTg+lN897gLHNvQBPmXnav0ojDuaQfQsW9o12EcEItuu2NZGEecHg+vesmaCeO YgKCEfLbDxQodzQY4k+fzBlAPlxxge9UoriSJpRCH8tuH2DK8c8ihw10HG19T//U/iLtZZZ4I4mi EYMmFlA/1n19Kr3HmWOoA2w3GMgEr80b8f8A16hw7G6S6ErRpqEchYSwSxOrAI21G5yePwq0LC/l /fmNlh7M67S3bjNWMoS2UcbNJI7iM9WPLZFJD5N2+5CyrbAcYxk+/wCVZz7AWoczlI9qoyy4UngH OOTW9/ZE9i5eeDzfMXO5BvGD6fl+lZgf/9X+IrVLa0NwjxPOgYAyJMmwow6gf/XqextY713jiaNP LiLBpvkDlR90e5xXOaT7EM0UcUYBKwrG3ztnJkPSqcc9vC4kkbiMks5GQRQZiSWa3N0ktspaML5k ru2xR1OKtwXSHjcVEX3SvO/tiiwm7K5JPJb3KByTFJDkIV6NnHX/AD+dZTs5kBinYn7rA5z+FVyO 1xrVH//W/iItXtllCXC+YSNoVwcbvU1p3djFcYmsAUmChZETCg+uKyULpEcyTZmy206Rxja8Igfj JIJPc1sLeQSQpb/uwSm2UN91h3HPWplGzsynsz2z4IWsN74otoikcEKRrcadLB/pEstwk0axqE7Z J684r92/hjAuq2Pw206d5H0611oNqqRKzXGoTRhWj8wnjAKony9l7HNf2D9HaHJk+Mq27/kj+O/H Cbq8UYKj5x/Nn9x37BGjWGj/AAt0hJWMlxfWMU97Iwwok8mNlC+n+sP5V8v/APBVq+mtPhlrdxHc skdtDLHK0LBNpt4mkQH6A4P1r8d4e/feLbk/+fv66H9I8bP6v4Xzt0pforn/1/y4+J2rPeaPFeSt HBNcyCfVruSMfaAWQgbnzyowM8ZPHoK/D79oi8s7vxLqk880F/JbXnnWkUQ/dIXAVn993JGe2K/0 M+kFVVHgL2Ce/Lofxp9HeLnndes9bpu/zPmg28W1TEgVT1Crg/SrGnhoGaUJNFCrlUV+Mkcc+xr/ ADqrRsz+x5fGkdlY30MkQZxtZjsO4fKSew9a6TTmnt3ku9OuprciEpc24G2N+4f1yP61yclkaENs 91NMtxMxEpmOxics/J59Oa6AvbvFdJcs6tDFvRgeJDkfLz14zx9K5ZK0mVFXkf/Q/jNSy+ypLLDL HtaNZI9x+SJjy3y9M84NaIYxiRLd/IaaEFjCcgk87f8A61fMyVpFSVmVrZZpLcLKpJTKqG+VsH1F amlSx4uoXVo2jQC3cMNjsTzn2xkflUkm2tnpTWrXFzaxfaYZlJupTgKMH5T7d6knMtw6yWTi6eKD dJ5LZjCnjBPT/wDXUy+Fgc62nSf26PtT+Qq2xVt5J2k/OM4z1FdTa/2fHFmGeN8JukBOJAeMgDr1 rnlpFiulof/R/kWiiF07qQyWjJtckctmpZ3YSw28Vo6qAFi8vncMYHy18LL4WSpJm1FZyPIl7qUd wGt+HkcYlZTkDA6nj2r0/wAE6ddW+v2/lzRwKIjdRPISly/zKojjGMNkMa4a7tTn/hf5HRRd7n+h r/wS48JjQ/gv4DmnsRb3M3hOwkkR4tlwi7SNm0cDJC5/3q/ZCNV8obFCYI2jsK/DMp5ZVsTUj1qS /M1wceWly+o/dhupXAzUMkhcHCg8/Q17y+M7bW0P/9L7O/4KVeGpdf8Ag14kuLl7SLSb7QptLnhZ 8XMtxtby2UEcDaME56BvWv4j9QvdJkupYVspLyWSzltbXzkYDdExjZ8/3gR+NfhPAVZ+1xFC+zT+ +/8AkefhFyVqkvI8ije5gaS4jngmjW5aNdpDNC2T8pB54x+lcvdaZbx3N3qt1uuL68GyV8ZaYA8M 7euO1frK6FNpQ1ItQnvRYR/2ZHZmdZFcvdhiiIvUYFMmgTVEWZYIrXbKC1qIyPmxkup7gnn15rUk l0yyjsNSW8hgieUwtA4uF81FznlQeM/4VQ1K3urW8kkLtHHNiVWKiNCScKoH9aCZOysf/9P+LG/n hkkebykWeGXy7m6EW07gB8voR83WuospPtUERkMYk2bFKNkIoyOR+Ga8c89akc8ltDILWUGUlCQ6 LuUY7E9uves+0S4eU2yTExoCUIXOATnB9OtAeRWur0pLNbW6JdXEKCWSINjcmcMc/n+VTvc2y2c/ lfaHnVPOa3hhLqF7/N6j0FA9Wa8RN5oGmsl7BIHkkk8hB+/h6ANJx3HQe1ZdrLdwSStHcyMU+VYw /wAhIPat4XSVhH//1P4+10u7vbaF02tOV8x28zaVGMnms+4tFXTZrS2Z1mumwRF8xDAjBK/h+tZ0 +p55PbxIqolxNKl5CdrrtKsm3ocf0rh9c1m8lkubO4MyKTmGdYgUcg45Pb1r0KexMleJ5dc3UsN1 LDNNc744xIktu5B9RtOevH51+l37FWqavPqBubU32rWyxLayad5AV7dZ4lSaUnrkKwOegIr9g8G5 OHGOGa3v95+X+LdNVuDcRFrp93mf0Ifsh3raF8ZvCgjlg2pKLYWdzODeTb5og20gYJVS7dMfLiv7 rPgZfzaj8OfC0t6+Z10wbYhgny9o2qfTHpX6B9KSnH22Dl1t/mcn0WqkpcNYyD2Uj//V/Xv/AILB aaZNCtJ5JY0sbTVorxGu8xoriWPGW6gA55+tfzneJ79dOFzCl1bXEGowL9nMOS8QbBK8/Qjj1r/R T6OlRT4FpxXRn+dX0maUqPHdZvqjjLPU1ijl2abZi6jZY5L7btuXj4/iz056eoqFb3ddPDdRCKLe GikJ2oT1/nX9DqN2kfzC5NXfmPmv003Ufs99HeW9vNCJVuY4DLAFPfrnjH/66qPIsnyRSmVLnmCa dNkcgPQkflWpi5WQw232CZ8Sotv9mZXS3Imlkm42lD0x96tG1uorjTLeS8md5IIjBdXMkAaQsrMy KW6jjA/+sKaTexHPqf/W+DL+a7nmhLxC4jVES2eOPMkaegx7kmq0tnOmsXCXkm+OJ0KtHxJkgcH6 cZPsa/2iUW3qf4jl25guGv0mjMMqrIgJhIeVz9B9K33dZbWeW7P2M6cfPZD+7klwepx+eD6Vta2g 1JpWRhnULS+k8wTBoXQmKKVCpmOegzyfr6VZ1Oy+zW9hcGGWLz5GaK5AK2xKgZC4HbPI5+lNJvYq UrsyElluI/OnicsZ2iV/vK6qBg+1dRprtbwk3Ra1UEt5DEMrjoGA9+K3tbQzlsz/1/kO5eO/s1tA lokkErPHfraqt1JGeilwNxGcnBPfFcVc38y3MYgtvtCLtS3gkyksueNzcjGeuO3vX+26VlY/w8m7 KxunT4xMZQsflylvtEcbZdSRhlJ9qzWuLOG4+yMWBmg8m2C4jRWUjGeOT+vNMwn8JdSaIy2X2y4W K0kQIEMZSVW6YI79KbrFkJHt7fTZUiV3AMhXexH4/rWlPqck9zWhgbTI70wyJdRxQLI7LIGAbABG PQZyfxFY9vN9phd3yTEPMLLySM4PTPrWhjNaXP/Q+IzPbW7m6naP7KhB+dtomyQNufXJqpamVtSe UJa2dr5RSJLjmNmPyhcYxznjjjFf7gH+D4XFvaadcRM8Ze/Ql7ae1yIYwRz2HtUtpcvFdRzO7BZJ P3spziIHqze3+NawvYHojbi1y1u4J51a3SUnYsP2YEpggMyyYGc+/NUHRRcRTTQrNA4y4bKxygjp kEHvVmUZWViey1/VtLuLWLR0gSJCYIohAJ3i3cL5QOe/qD1qOH7Q9zmd5SuPkhK4VT3PrQEpJqyP /9H4t1aOCC8aDdJAzWwYQx7pXkJ7BR1Jz27VNo2nQ2c8N4Js/Zis0aSJtLjGSDnoRjGCK/3IWmx/ guQahqm+G6stPVZZ5pg4uHTGDuyRjqeMiqMeq3tpqcVqkM0tqtsXluZF/wBGVjgBVz3HNbKT6ozn Y14zPrctxHtdJBD8hQemB+VWILI27CKSVYyYvk42gn3FUc09yKSaNoZbTzJWikOTJEeFYHg+44H4 Uy1NutvM7zAzRuE8p+OMHkflTTcTnlFLVH//0vjFb64muZfMv3kh8oG3EcWQCoxtLcH/APV3p1o8 zylWMaKRkM3HPNf7sLVXP+fubWxpHTxJLLcQJ5oiUI0ijIwfUdun6VTljijkZhK9tMIT82Soc4zg H3OPzoOWXxMybT7Q8KqRKVK+Z5YPLD1NaaLsjmwuyZF+64CntwPetINWsSJavPLEYSTEJWG92GCn uauTxlFCCMsIRta4XlJh2Pt/+qtDOb6H/9P42hRzIZoZVjYKVXcAQMgg8fTNThbqW3aI3SLaj95c pcP+ZX/Cv94D/nkmtCk9xCrxrbmOWPIHmxEFHX1pJLgPKkbFkZmOwIMbR7UFmxeK2IZJ4QIWQIZU YLuOPlJ9/wDCsmJJbS5822dnkWTzY2UkEkdBn8K6PQBXv2llMkqeQ8yCQw8fujgZGR/Oq6yFpy4W WIrgLKOrn2xQB//U+LbyU3pykxF7CVLEktJIPVj/AJ6VeSayuIpNyXC3sEaoHbAQ5xuwcdDjp9K/ 3oP+eZpPcYu8xsiHcsY3MByF96bGIZSMn51O1UI+Zqq7SsJwTEjmSK6DeTvx6/dz0/n/ACrWvSZ4 4mmIcFFY+XwNw601J31M5RtuQRX6C3ltwgdUk+bKAuhwO+M9MHFTRWcdy8SXSlElTzoHJAQjJHX8 D+VXf3rGbimtD//V+WbGaTQZJWspwHlje3bPzIVdWU8fQ5qpLva7SbEbn7ssu0OoA9uhr/eyd0f8 7DTWjG3sqNeNMwjK4AH2eEQrwBj5cDnjmsK/jTUJokk+0rtlSVGWQpKrIwYcjnHFKDd7Ca0sa+o6 XNB5OwmSSRQWTOWQ+h/n+NUC/wBmuzbso85QDs6Hn/8AXWpg007M0JZoCdwtljlICtInyg4GOR3P vUEpMPlOiszTOsaKq7mySAOPxoEf/9b5FniuoFlXyWcIcSmMh44TnGcg46+npRaxxI4kl2MojIY/ 3ieh9sf0r/fA/wCcySWrLDsIsm0dNsvDbgDwe49PqKoQqJEl89wkhbagU/KDnj86Co7Iu/ZpdPjh aWJnS7RvKlRfkiZezn19h61SeaURbFVWnz8zkfIefT8DQZy+Jj7ayRgQl7b2XG8pMdu4DqB9aiFn bFp4bbe1q2d6k7d3rkduSfzrSn1IP//X+SXlSNI5LdfsYjZVEeTlcDqDnjpS3c91JMJZHDpJgyFh l2xwOfpX+/B/zjkpmRFMUnl4cfu8qC/4Hr+VUUlIZhwYx6jrQAhuiQfJiMjbxGBGuTycdKUXG7d5 sbxsGMbKylcEHFADZWKxgIMrjCrUNmBCjCVndmcsA/Aj9AKqHxID/9D46mhafd5cywsvIYjIJ5xx VlbqS0sY4Lsp58jfuJd3llsfewvev+gA/wCcKasx9mS1wHeVECAySzXOSiDBIwACTyOgzTrAq8zS 3jPBvJKuQWyOcED0P9azm2tEQEs8flsW3easnzAjPfg1EBE6yurYYKNqMeGP9KtO6AtwIs0bozon lnlGByT/AEpszQeWY4EKSxna57MfamB//9H5EWGfGQVWKRvLmmkDGODOfn45468VWtPPNvIzYPks EZ2IBbOcH9K/6AD/AJvywZ2QDbtZWXDZG4LTZ2byvl3HjBZc/LQBftJNirEWUSMuME/NVS7iYsVk kLiLKoAfl6k/40AQQkuCHBGDgA8ZpJPPeSPcU8lOI0C7Sg+tBlNWZ//S+S1hkkwGZDHn5SvFWXlZ WW0yDGo3bgODj3r/AKAD/m3GgrHKW2ckABgPSoUZ47hp4SoYjbtZQwOeDwaAJvtJeOeB4ImR8bi8 YbBGcFfQ9aypHMYxCWBAwUx/KgCxalrkFMgSjqCduPxqwodPkZxHKhyMEEGg2h8KP//T+R/NInlj ZAxZN6yL8qofTFMgWRYCmD5aNtGeg64H6Gv+gA/5vyxBPLbyCQgNGhz5TJuBx2Pt7VVEkc9xLKIF jjZiyxpkIvPQc0EcivcuARwjJX7/AHxwKXdHEjAAu0jZyTkj2H+e1AvZsGkiWJt0mCrAmNs5b6Ut zMtsFjEBleZckq4Hl56cf0qJrQThZXP/1PjcpsOdp8wnritYQyxRRtIeWG4L0GDX+/0PhP8Am3IS VlmYhiCcLyeBitbzvJiEQCsMY5AJNKa0uBSAmfeZGUEHhF7io1LFJ8TMgOAIwowcHnnr71kBKhjI VFIJx8zdlNXh5M8OW+WS1bhGUFZR3P8An1NA47o//9X5VYrFjegSKQ8ewzimW5hMhVpUjVATubJ6 V/vwf83DtfQBeB1kWKUxycpkZVehB5/z1qrFFJCM8ndyfegI7otxSGCQEZy47c4qquHa5ikVw27K /wB01rCStZmzSe42NpYj0VlxgxsPvdqrxRTh3LgxRou4buAR2AFWRKC3R//W+QnlYtsWIncvDjhV qaCbyUG5d7IejfMPxr/oAP8Am5UW9iUXBjjJkjK788daZG4RHdlAVh8vYmgTi1uVIrnMwAQjac5I +9U11ZxXzzspeITHeV3byp+tAjSjtwFQ5xsGBVG8WKLdLcAyBAWBPQcYoA//1/k60VI1MiMDFJGc ooHU9wfaovsymLylnZX+aQPL97PLbfx6Cv8AoAP+bcYLgpBDs3CR1/eI67WT2oK3KkSPICrgFFH3 l+vNA0ruxNNMX6ARjaAQpOOnPX1qjBayNKSJAIh8zKfvH6UG5pym5uhHawApCH3sx4XI9TWVOAkp ds7I/lYHnJHegD//0PkD7VHOyxkZ2DaFH8NKhlimkQRbVHRs5ZvWv+gA/wCcODSI7m+aILwcnjg9 RUcDxyAk/If4PRjQVK1tSydkK4f5pgewwB1qSOWKQgTMEAXnjjigyVupLIkeF2T7hGdwKEgNx0NZ 1xLMjtGEheOddrl0zIOeNp7Hih6K4O3Q/9H49W1ESqrIyPt4zkZB6f0qC7hujJEHUqiL8nbvnj8z +df7/qSeiP8AnEUETjayr5hYPnp7Ut4ln5EQiTzHEhYy559hj2wfzpllPgoUZNwPPzD5RT1trW0i F2bj5JRuFuq/NkHkf1qZRTAc9xGVJtoyEdgSAOefWr62bC3NyThFYKx/uk9Pz/pUxgtbgf/S+Rlu FLKrpk9CAMFgOpFVrh4U8xASu/oAcMK/36cGj/nHKYl+RtzcdBTGi8xFMbKNoy/YkdsVIFhUhEEc sOWwBncck+pptqxW6Lgj96RGB/CueKAL+oWMEU28fJMg2kK2V+vpzVRYGfDF9q42nHfpQB//0/jZ /Kggmkyv7sdFTlv8+9Q2jwBj5gDHG5R6V/vwf845Ys3kM8lzGQBA2Shz846HFV3lYM5bkFtwXufr Vwtc0p9SqsksZcpCx8+XLsgPycY/KrZtHfEjyFT0rR2vqaCGRNPtpzLIyCSJ1kcNsBG0/wCH61+K 37VdtDcazqhKiNp8xq0i5jAV/kYn6kj8K/JPG9X8O8d/hf5M/pL6Lqf/ABEmi12/9uif/9T+KIaZ c2MbQ3Aj353yGE7o2z0x+GKiumVokUIyDbsfI4HuK/SMQmpnzlNvksQoiqiMrfL9zcD84xSyXETM sLMymN8R7x97PcelcU9yyEoTKCWZFjbcSOknsad8sj7BGcxjzBnhuOwrle7NoXtqT290bgv5cZCL w4xg/lVZmtknIVSWHDkjp9Kwl8TKP//V/iVuWt2KmFmUiMblYYIb256VWigIIKBnU8kDsa+oPHLb IksLNct5YHA4+b0A/SqtpFKu7LL5TLnn7xHtQBuxvFDbhVKkbd21Rzn3qgsjyYxH5cuSMEdaUl7r AtR2KzqZWVpHPAVegx3qg0MnlvJMWtijbUDj5sD2rAD/1v4kFiiikyxyvUleBmpriO0muV8mQgrG A6k4/wA9/wAq+gPLc9dDQvBZxrGIyRsjAfzGABbHO2ssyICr79oc7UzwKTVyG7u5RJlSYojo7OOW Q5VfqfatWHzFCMwaSNQQJAOAahw6mkJdCpcNJMrKjBGH3iq7hVW1a4UBTH9zl3UdazLP/9f+JVFR i29htJGPUdhUibUmYOwVV6k8nFeweXz63My+SaKQMki/vORGv3l+tXrKY2wDEvE0q4lVThW+o/z1 oLTurla8MU+03DyGHd1VQSnvToHjh/douSeRuPzH3+tS4pkTRamUvJFKh2KBiVSKjlMMb/u5A6sd pLHBzTUVHYcXFaH/0P4jTcLGfLRTz0Yjj8DTGllmAhYBSTggH09a9ezuedFprQsrJ5abEiDKEKh2 XAYgfyrNaUiQl1+QnlewxWLvcZoRxmVS4iZY8YR2GEc+gP5VMySJAw4CjkqvBbHrRdrYCfz0uFjW JFCBQqgclOOTn+dI8SLEHieR5ASNzLiMfQ/nT55GMviZ/9H+JSEXJWOQsWKkkr71DJKJCySblkBy Aw+b8q9A8c0Ut45trINsyxlWUn5ceuKgYbcBVyYhkIOPyoWgFWOdml8gfIXO51Ybee/+fatqGZIm EjRrICCrAnCoR3b8q0ctgI9Q1iF5UjjTaNo3sMEY6cVPFGJWWXJbYNygdqhu7uNPldz/0v4k7uV5 LkTRoCqkK6bvlyOM4/z0q+9wscaIoVy4+ZM5Ga9A82MkxlvFay3RmlVtiJs8oNtCn1qRllErNCPJ jXAVVOQ496Ch90G8nhhEzcAg/eNc4sJndJGYsgbGccHFJuyHzPubtvtwECgDPIqDUNsZ82KRkkU4 wFwM+tRC7ldj55H/0/4j1zJCY3csxxJG4PGfSpR5MMSxM292PLsvIPpmvQPP9R0YjLqgQ5YkA7cJ V+3jRWBYbtoPy525NFgHRQW8qGVtjsWIVOhhI/xqvKj7mcNyBt254AFYuNnYBLArcl/MYvt4YdgK 13axjtbiOVl3EAwjGWUg/wANaxVkgP/U/iTVQsksrqzxd1cZ496ssFmgjjtlVXdwyynoq9wBXZPs eeJcKUzs4GNpkxzupLdXsFSaZiwlbDleSoPtWYNpbjr64tXkhjtZpV/d7fJ2YDnqTVQwR25SWSX5 SMsq/MfpigxctboijvPLMxSeUbj+5ix+7z059KS2eR3dnIZM7cZJYmtYu0dRX1uf/9X+Iqe5eBm3 jdsOdinAUjpU9tP9u2rK5Qbs7jkmQen8q7lJPRHlc7JXeSKd4IziEcMXXgj2qqtgZp3kiJG0ZwTk MaoOdl6K3YyIhQJJuCOW6fhU19ZPZPxiRDLtTYwKsaCU2tiXgLIZFclU+XYMgfT3rNPJU5LjOFDf e5oGtmf/1v4mxpyRjcwEO47mB+6KGjW3RjE7FSCEPIAPtXe0nueRZoy4Y5Uly6IULYlaRscGrc1u schdVChTgqvI+tZOLTsIVpZI1AjkIdPmyhx+tNjeVnAkfdu6+oq9VACyyPHO0bRhYSvf+dQ/2erS 7Vy5J3KVP3frUxlrqFrbH//X/iQncQOWjYFlP7xuoJ6f0quLiVy7RuHkI3OMYOPavQPEfxos2sN7 K5dyY4WTg5yx/wA81b1BPKjhMLp5ZXYRnMjMOuaCyjB5cS/OpBzwcYBNXnJEeXbCuMpjk0rp6Dbu RAGaNVGFMWVYk8r9KrTQMGjmdYyVwAHGWcg4zim9Fc3P/9D+Km3ZPLCouBtyT6Gq8iyMyRv8yDjJ 4NdL3PPLO9khNt8giHOQBuHbrWdIbfyAY3L92Y8njt+lCfLsBSZEcL5ivtJyrI+M+mavx2jLHG+9 VzzuAyVHTketUpWd2NOzuVWBEoZDnHIGMZNSxXJ+4ylpGbBOcFfQYqXuU5vof//R/iXv2uIYolTC xhszMxwQD2H1qhDcTTTfZwpaEMN+BwRXQcDfVm02o29sVRo8YG0BVwq+xrIuZVuJf3TKF2/MY+30 oM4yu7D7S1E5VN/I5BPeti50+a2hZyVfysbthyMHpQWVkkWeFQjnaGIxyCppoma1kQPExVVALspy eOooOe1tD//S/iMS6imu3QRtkkgkZAU+uKtR2EgAUHCh9xP3se9dUfiR5sI2VjMlMz3LRTIV7dOw /wD1VOscSyCKV3WNRuXgsp9hWx1JWVi1cwpMvk2rlI8DzHZQWHHTFZVxZFLdUhb9/CScH7jjPak0 nuBUtygjZ5lL56Ljgmr0VxGqw7hnYSpUDjHp/KsAP//T/h7nMiGD5Sd2cbQe3/1qmM6ny5ncruba QTw2OBXQc9ugnLNsG1Y3fcWHAq9PA080eTHiCPYqoApwKibsrCaVrFARCUuE+TyzkoOBioZblFmR oUbeuM91XHeoUnExasd3beJPtEUgu47eRTarEqRgR+VtA5/TnNcpqk0F6xit5EjK4YovJNaKSZcZ dGf/1P4fI/PhhWNUIkH94YVvTmtJbvzbdIXKRSDPmRqeh9a0m9Tl5la5BbO8amMONkshzI3Kr7f5 9ajkaJZWhXd5nVZO35VDbe4KSbsVVby3wjMZC20kfxc1JNJOHCyjKAZKsMbqRQ5LWBylwwBiRsbQ 2HJ+lVp51MokiVo0DEYIwTjigD//1f4e4reSVDIQxRmJTjGcelby26LbwkyOjKuNidz70GCWtjFu fKnDwlcSxqTkDgmoLY3UKRypyzgrg+3r+VBs4p7mxZuHUp5u64ZzvbHyKPrUNyJIJCgxIvQEHlT0 oMWrOx0dpe3NtoiaV/olzH5/nObgj7TBzklceuf0rnrsM7IYS7RmXcSnQeuKC3FKJ//W/iGEkN3M bby5VL/KjhODgf8A1q0rTyYXMM5Ikjbb5jD7+OlBzlea4j3Gdmbrt2jG4EdD9KpC8jSVgz7i6Yxt /WgadndEcai8k8iSaQqeVdDtKAe9Xms3ikM0chuGkToDtAVeBketBpzojvFmhgGI/wDXkqHK4GR1 A+mR+dVdNQWgYykyGRsBXA2jPGaCovmR/9f+IlnVAYVbZj+AjBrOvL17f9xbkb3XDOyBtvPag1g9 Da060lWL95mViu52LcH6VZl1GfcYsNFDs2EnnJ7Y9KCzIlbzy4YkBE+Vj0bHWpbaS0ixHaI0xdQZ ty7eRxj8KmUboBbl/spVmRi0h4A/hFPsr29MoWO4kUFwY0jbBwOxrJprcUtEf//Q/icvoLmaaSW7 OJ/K85JJyEEigHpn6fjWdFNLBHGAmULH7q4fngEGucBrpFdQ+QHYXCMWMbjhh9arCweOTyZ9qgjd wdysOvH+e1aQimrsBGuyzCG2T90D5bBxgHHH+fpVOGGe2lZLeZULNkl1Dr9Bwa0MXJvRj9mdjTSb Sr/Oirw3vV4RW+8zo7G3ix+9Zdh3YzgigqEujP/R/iMiKTRPIEDnoTjDEf5/lTmvNsSJDvhmVwI3 ThlPTFBg9y88ktxAu9gFVsTBl+YY70023mfO7RiFADHIRjFZT3Lc1Y+p/wBmiBJfEs0RsnubeeGK 1s2jQLKLlpl2kMR93pwPU81+7vwT0V08beEPC0lyqxwP51la+ap+3XB8t2UOOoyzk+30r+xvAa9H hPHVfKT/AAP408XZqtx3gqP96P5n9y/7INvbwfCvw+klqEt4tKidXhHMs/lIrLn0HXFfll/wV810 f8K71aweRvs97aT20USHBu7hlZTnB7Befxr8d8P4vE+K6f8A0+f5s/ovxRqfV/CmrfT9yvyR/9L8 gvi9JJL4R1FLS7ja0kljMs6Dy4pXSJ/lA6kq3y8cZAr8EPijqkV3rtxcWU0txaM7JvlXa8j8E5+h 4x221/en0ka3JwxRpPq0j+Qfo3U74jEVPL9EcLp0ssroQzKYh5ic5I+greguUljkilYAjorDrX8E Vlqf12/jRpW1s15NHY+f5GyRZUIbCgjHOa6q0v7mxndkljZmVoizoHzkEE8/U1wvZljF85JEt5vM A/1kb9uckADqPWp9P0/XrqLWZLqQTaXZSJc2drPMoTc2FZh1PJCnn0PtXHPc0p7n/9P+MV4/PWAi Q/KmZoi+2JSTg/UjHX3q/FqGn2v2izimi+1wKGURjeC3AHI4xgfpXzMviZpNDLW+meSVpojIkvyb lUs5YnrgfWtOSGO0hF1M0fkMdrqsymaM/wC0mdw/GpMJuysUjqIun+yo2y2H945aUfT0q9ZyS2bu Mh7Fl5hQ7Mt2JNBHNIsXsht7G5aJ48sQwDkCWQeiE1FawLePbmyhInSANOrvtUKepz+HesJKzsSf /9T+Pq6uLxLWaK1u5JFDiBIrchhEf4iT2xW5pUEmoypcT3TRm3hCzLL8ifKOSO/OP0r4ycU0c52t jDHNNEyt5gPIO7cpC9SK9u+H1gurazo2lQebPeS6tbLGYbfzZCftEYSPf0XLbfqBivKxnu0Kj7Jn TQ0uf6RH7C2l22hfDPw7Ezy3DxeE7CwkedPLlRxEjOFH1BOOw4r9ELeSNo0wuEI/iHNfhHDz5sPK o+sm/wATspWjBKJXnOzLqN3P4cVXzuwejH0GBX0FL3qjOmTaaP/V/Rr9ubSY9U+EniKznQX9va6d czpC0ZWKOVQFhkbvgF8n/dNfwrfEi98PaL4z1Hw1ui0/VU1JxNp4Zn+xs5JlIfGApbJwCfT6fz7w DZ5nW80vwbPJw3N9amuljw/U4II7l5I42UzFmUhNm/HG4/Wsa7YLBKZJljQRFnWRgo4Gepr9ldot WNJ35Dnzd217ZAWdyFe2ctJs+YuR0Uj9eKIpdRtrMajeLdTWiSeU1yyEqueQpboK0uidU1Yt216b mKW+hikSwSTbDcMMruHVc+v+NVddmOopFbyOSFZHEgHzAIwYAfl0pKSbsiNWz//W/jCuo7hfNgeD EczK0kjD5WOAQT79qvW1sYYkZj5can5hGf3kgrxzzkrKwkt/p1la3F2VeXfiNIxGZJTzzx+FQaZr EX9mard2seGvLV7G0bOxo3YrgnPTjP50DItL0EWf7+8lDXyxBcDk4OCVz6dK2IooNJV9VsdXvI72 9DWE+lLGps2jI5Ynrk5PB/woAjsZLC21iSSW1lSP+y9kMsZ3RyMT0ZT05GaqTNaTaxGtmjLGLcyS 2xHE7c56dvWumFtAP//X/jx/t+OCwtkij8i5eQ2ogjUlIwB8vT6fpS6W2tWRtb+5ht5JXlLptAbY QSFYjtjg8+lZ0+p5zdkRztNcXM88js0hJ8yQ8s5zz9a891y4+/bgb2XmRs/MMdMV30+xP2Dym7DS 3KuzNEgbYAhzmvvj9iK6WLxTqNhqN8trHEJL6zf7SCs5SOA7WXtkqAPpX6t4T1VT4ywSk7JysfBe ItL2vCWLildqLf3H9DfwFvLe1+KXw/1rS203TEMwtJpJrozOGmng8tUY87ztZAPVvfNf3afsw3b3 /wANNHnlnczw2cIjeUYaUbPmH1BBH4V+t/SfoxlSwdW2tv8AM+Y+ipVUshx8E9qjP//Q/ef/AIK7 +H7e+8BajeExtaSWzaiUkj8wW6WoaZgR6MVJOP7tfyoMkd5qxivrSyvbG4tGMd5aki7snKZiaNcg YJxwf/r1/oB9Givz8Izo/wAsl+P/AAx/Av0raCpcWU6vWUX+HL/mcrHZSPKyC1uNkV15DSgA7snH QenJOadqkYtzApjS7aMF9jOCG5xg4OQRjpX9PJa2P5Am/d+ZasrmS6tLi71IRRtbp5dlbKzSFFU5 xk8Y68Z61kXl42oXGlRWscskEkbJOjIFeGbPyqOemAfxNaQSb1MHKyKV28iStbJb3NrNb3kZF20o SFlyN5HfH1/Wr2pXVrAJ9OFxLcxsBJJJAh+ybsfN+RJANbEqV3Y//9H4V0PyrCyZ3nac3D/uCH88 jsMjqo+tNltb+S6uprlYINwykrzffI6D9K/2oP8AEVSu7CWEwCy3Kwqsltg3e2Ty3lUsEJXj0P8A 9etO/l0OBkEsl0ttdybUGwzzT+kZPTn+hoKMZtMinKXUdhF5FjP5lvds7byrZBVxnA7dPzq5b3LX epW1uqCW3kk2TxMxxtwf9WP73T61unG2gDtQtZ7YTzWQee3hYiKF2CsoJ+76fjQzSutvL+++2sSG V1DRKgAxhsnp6YpiezP/0vhWC5u1k81Z4Z1PyhVBJ9Of/rU2ysDdRXF3rUy2rveERbJCjxR5Gwvn oT6e4r/bdO6uf4eT2G3lpPpxa4F/J5SybAobcJwxwAw6Ej2plvfSHeZI4CJGAijMfmOmCCGyehz6 elMyH3ET/uDfyi+jubsxWcKJhocBeuOevenzi5une2RhC0LeWohYHcF7buvbBrSn1OSorGxodvJq Wk6xaxwHT9X061edba5kCwal2IjkOADgjg5zz0xgrpekanJbWd9BNbabKGINpIoulkMeA69wR9Rz jpWhlbof/9P4j1u5urT9/rK20cFydkO2JII9yEfMgGAOo7DOaifyUWCORZvMnh3gOmI48/dyfoc1 /uFFXdj/AAjmupDPrVpYNABA9/c2jiSSB8LFKnoD17Ut1KjTyXjgwwyj7RGhXCR7uQuPQVslbRGM loXpJZL6xeZbWPyLNDNctGixDBwOSMfl71kadqpnha0jcvbxZZo5wRMnYlQeea1UI2MTfjMtjYC5 t4II9SkgaW0GoxlopOwZRggFfvA+1T2V7fXWnK0dms8ttKBdXcJGXkYYKqpOcAqTRyITdlc//9T4 xltZL2WXUZ1f7RDDtt5FbcAeD/T+dWLKe3mt44HLfbDuXcv3Hxk8/TGK/wBzlFI/wT532EsbGGC9 e4kWQhUKMpYeWDzyBj+tTX0dzdsuFRYEYCFFO3dVWXUzbe5t+bbWFtHJn7NKkHlNMqDCDHOfWsWw uNPvLmE6nJvtbmLyreUH7jZ+VmA5GTQc48rHCkiwJEIzwsbuGlJHUgdxwf0rDkje4DEIYZVYmSKc eUzKPTPHIHHr6UGcndH/1fiC01FZZp4FspbeGAeUhmh8mWX3wefx6VPAk8bTvLJ5sDNujXG1ox6f z/Ov90U2tj/n5mveLi3FrAkH2SaZbu8yZ4k3CIqpIBbtn/GpLy0aV7WYTnyVbEyvyuBnhfxzW61R yluC1S5leK2lSCaWM/Z/Nk8uLA7Mf89Ka9i1tK8M08bAJuLoS6se4BoAzBBfyO4SKb7IBtluFGIz z90/pW8NYjtbVNOa2V1YLbo2zhc8DOB7VtDYynuf/9b5I1DR5dOghm8+GRblMoY2J2k9mBAwfasR oiY8SOEjZgkrPwuCcY/HOK/3gP8AnnLt7BbxyRJDHDExhVUSLAVtihc/1PuaQoY4vMvE8hvLDYfq owMfnQU4tbi2NwtxH9knknW2JMgAG+QttbYcHtk/gCajNu7rJDGflYbd+drr24P41oppKzJsat/b aNaQWtmAramIBE580yEnruz6n0rMRWCKFT5FO1pCBjPpWi1QH//X+YYtJtLW2W6ks0M81uWYowLs NxwX9DwMY7YrmLrEbgpB5Zd9jR7skHOOtf70H/POPLOltexW7hDIFMkhUEptYH+dUYJIHmSS7Ztv 3Qyjacn5R+uK05VyEyly6FlxJZz3DQSw3UELbGUKHYn/ADirckkgVYdoVmGSinJGee1EY2epnKXM Tw2IEccjTRrGwxNJkYB6c/lUNssNs0siDzZVyiE5Cle20H+daWV7kn//0PkIq3mLIxVgzgeUXw54 zjb16A89K011ZUiaAWcMRdcbkGCPTPH+Ff74H/Ow9yrBLC5MdxFl9wKOGxwOox706aK3N0sxjEcU PCYJY/U5PWi1thD0aa9diGSK2hXmRuXOM4AH4VmxeRJOZ9oeYgokh4YjPcetBlPcnukhcRwmOYPt J+0If3YPHykfy/Gqvmq91HbtN++eEQw28hCA4PLfWgg//9H5QT95F5QRkRRiRhkqO3J96rp5Fs0k 7MJLeGZYmYqWjDEjAIHPNf74H/OdL4WVp5jPcO6xrGJMttjUJGnTCgdv/rVVO9HjLrn5g444yDkc UERnZWZoyXTXMiGUuUj/AIdx2/8A66lijillAklEYxuUYwSAaCG7jL60iRopnC9Q8JBySM4/p0qA W/lMbjlY/MBIDYz7D8quDS3Ef//S+S51WVlPlyRo43RPJwHFUrW7WaR12FoYGMc0h48ogcZr/fZy srn/ADjk8/l7/MjdAqLj5xuUVZFgjRLh0USAM8pYBFB6/wD6utEZJgZTIbCd3SYoy/MrqSMY5BHo arS3DzxmeV7m9ZHEp8uTMsvOT1655qgNBpGuGW6W1e0gIxBFI25x0HzH8KSQvLJGCixNGuyRQuC3 v9aAP//T+PZbZTH8xYYYMMHBODn+lX1WG6tI0lgWSWGUvDK/JjGOg/U/jX+/ilfRn/ONJXViC6Ek UC7l+SQlMd+Mf4/rWbBHm4jAZlYnakZP3ucVUo3MnBo1kiUvMk6sCOCpHORx/Ss8x7WcLuRd2SAc 4/zxTS0FZ7D4pJDE8EYO4vuMvVuBjiryDMbAEq4XB4yaYJN7H//U+S3nuJLcRMUWMALtSFULY4y2 Byfc+tVt6LG0LwuM/dlDbR+Xf9Pxr/oAP+b8QNbiNo1zuxwGPAPqaY12yIFO0rtC8KB045oAntBa CRrhxmQJjJODgdhUkc3nyu7xgBfuD+9QBBIRAXk2mTOcoDgKfSqkdy92yLLGUIIG2MY249fwo2Im tD//1flL9y6uEBjK4GwjAHvTQFRZFZQwaPAPQ/UGv9/YPVn/ADbhcXSiGJkhKMIysgcfK3UZH+eo rPtZJHbaqvI7NhQBk8ngCrGkbMbbd9vJGsbZwxkX5wR/KmRRRRSSyu7cLtRFUfMeepoEQ2sMe64e XaGdwVYHGzjkenNNntvMJ2yiN1B2vgke2aDaHwo//9b5NsokWAC4cS3EYJkaP5RJ9M5warwxXN35 0iQuI4UMjovJRQep/Sv+gA/5vy3Fc2hECzJKFfK3DAgMg7cVXiEUJliWPemcxyPksvOeKV9bATZe 425QIiDB475pZJBGqoqAkHDEHkUwIFkjWR2KZx83zDmi1l8673eQxG0qvzcg4wCPp1/Cpkm1ZEy+ Fn//1/k3yoPMZRL5j9XBGFiOemfpg/jSTqzIFLsVUYXB5Ar/AH/irKx/zcxTuhbWG3GXkLZI/dgc AfU1deOBI5Znu4o40QsFf7xwOgH4UpfCwlHlMTzJHyI5AQV3A9wD0qxbISpDHpyx+lZK3UkesgX5 owCM5BB+8KvJICjPgFjwVxQ7X0A//9D5DvRPIioj5xJ97GcD0pLi1Ijh25Vn+96mv9+D/m3LMJQR JEVUyIpXbt5P1P8AnpVlZG2Qwt825sE4yyj0/Sgcd0FxuhU+WASh+Xd1x/8AqFRQ3hnJBgMe0bS7 EHee5oNx3kNLKjCRc9CM4I7cUuqCdRbRSPuiwfL2gBsZ5B9a2i7iezP/0fk22tDhdzSmIttaQLuK 9yBRbTwxNKiZZd+1XkXDkZ9K/wCgA/5vYfCguGiFwqzSY3pmJGPUAdv0qrJHHcGFQXKwzCX5WwDj sR6e1Ap7Fy4tXmuI5otuG4lZsIM9sdvT9aqQSSI8m5CrLIU256470GRO88iuXydmPmXHSrdvPDcR SRSxqyMMEMOKAP/S+TdwhYIiYQfKABwAKkkdJmi+TiPqQMEiv+gA/wCbcoSOj3czBSsQb90DyVHv Wki/aI9qhQV/iJoNKaIFtwY5RL91Ojr2P+QayJbltkscRaOUDEcoAIXg8kUGhqiSf7FA7XZkPl7C w+QAjrgDp2/OqkaKY1IYu4Yl+4NAH//T+R3lUqu6NEK8ZWMJ+eMZpyBZWjVj8vQsWwTX/QAf84UV 1MrUIyHki28K2FZgBxSWzCKJo9vmHOd3XFBUxbZ7ljJFKFYyzbgVHzIOcDn61rQ27lngwrbufu5I oMivdJHbny9xEoP7xUH3R/nP5VJFHC0izDLLEm4bux4qZK6A/9T5LkuWvrgyXEhLj5QT2A9KBLAX eCTduQB0kP3T1yK/34P+cSMtkVJliY+e275xtRx8qj2xVeT7PHGi7uScYPQ/hVczSsixyxPKwwTt JAGTgYq1LaoiyQQgFCd7hju2npwfx7UrvYCsIUhdAp4IzjGM1dk1G3aCWC4R1CYZAnIkIPcVcHbR gf/V+NpLwllliRUwMAMMkjvSyIsyK4Q+ZnLYHpX+/smuU/5xwEMTDGwk91ximoPLDAJkbsH1FZAL Mvy4TOwjlQcU+0gLqzKCuOhNNppXAAZJrlYGIG75SzNhRVtYZVZLdo+S+IimSZc8Afn6UgP/1vkK RRH5sMkDJKp2ukg2suOoINVI4rfBdcZBwR1wa/34P+ccjd5LcMIxyTxgdqYD9qEbNC8UscvzPuws oxxlccd6DSn1NkJPawSTRr+5dNpA/j7f5+tZVyJXsvO3CCYFWCt8yj+9z7UGhLd2pn0qa5BWSL+z pTcDaGkiJRhkA9xwa/Dj9rSNdS1Ka3kmjMK3SqZnmKeThy3l7R3Yk/ia/KPG6VvDrG/4X+TP6U+i 3/ycil6f+3RP/9f+KGe7kSP7OpKqo2gnkjGO5rMmuUdREzMQD0PyhiOlfpeK0nY+bo/DZiRFo1yC rZyUUnt60yVirAyoGYrnOMfTFcM0aWsVzMxVIw+053H1H410VmPMAfdG5CAP/eJ9q5JfEzeOyKVy 3lTOqfu3kA2+UcM2PWqTQBhjeFlJyT3rnl8TGf/Q/iBkVmkMZcxsvAkA5OO1aSSGOLAdkeMgShhg HPSvqDxyCZZpfnkw0EZ3Dbxu+vNJZzFZHeWEfZycKgfDHFRPRoAfe0peIkIRgBm+6asxSSmaOWWI uYRgjOEc05uyA1DqklpDvRkRm5BQcj2qGysbjWy7tMqBt0heZtinaM//AFqxHZvY/9H+I+VInHlb hHs649u9Sx2wlty+dsqt8rA43getfQHkNNbkV0NluPMUvtbK5ODnpWhDpLPCjTbipHQn7tAjMniS zuPLQBgRjB6n/OK1LXzXMSkhYFHKIcB/85oA1pNGSxhjn3pK15l4ow4LoPQjtViOz0KKxupJ9ReO 7hi8xYkh328x/ubs5BH07Vz+g+up/9L+Ji2AuJ3Mar5Z5G75cAVLdBIpCVQOpGHcd69q9o2PHMaX zFkEh+ZA2FA+Zsd6uW4nmYAQo0Kt88rHDY9AKk1p7EFxA7XEkGxyirvQ7cL7CqLxyRFZZS6MHCDI wVHbIoJnuaFvHdGJgXyC2QWJ5HtVeWDy1EKx5Oc7zyaCD//T/iQhkEtp9naOPzIJdyuBh2yMVdtr S2hV5WYO4P8AFxt9q9g8mN7pC3JRrfzCRle4OMe1Z8FtESJnKyYG4Qk/f9j6Vg9zY3rZZmtpEkRj B/y5xDKrCx6nPQ54FY8+LeRo5y4dc5HJ20hRd0FldG2DSW8cbLhgYpF3eZ2rpbSOzNjHJMSZpMyu ufli/wBkCghr37H/1P4mpb6CDascZADHdzk/Wsi6uN0wkVPnKYViMHHrXo9DypK0rGhFKdm3JLum 1pFPBHcZpm6VcNgkBtmeuB0qob6kEcxMjkvEVkjw0bjgEfWqwme6d4Q20sMZzhfxpztZAJJaTQRu JQu7I2uvzNxXSWku6JPI+7borXKMMMy5AP8AOswP/9X+IzVbmOO8/wBGgaGNxnYTuAPft+P40CEy IJXYqVIMWDkkmu6MbHkLRkEErWtwUeQ/vDllI4Yc9+1dbBcLDGVeNTkZQNzj61RrF3Rnzxifksh8 vlSp+7nGRTJNP8mKJFcxLs3jb82M8nNTJXVgckipJGsNv0fIO0Mpw2fWot32gqGP7vb8zA8t9aIK y1Gmnsf/1v4iWHlEJESMtsTODmmIk4kcXMh2jnhdoFegeePeSclZVH7pWxnOCQKmXzm8wyuVi3Aq yckj6Um0twJkWVS5Utg8psO1vqavSCGWSBFRwoH79mPDH1HHFZSld6ATR6clo7yLKVWUkAA43A9q jksZ7gu8Nu8q24DSgDjHTNHM0rDatof/1/4opIRFKI7hWj4DeWwxuB5HFV7m9e22+RDGF3bcHggd iK6W7s88jhupZw6kt5rDhwvyL71Ze7H2QW5VJbpGyzv8u4ew6UiJ7FCS2nhmW8ZUhKR4XD5xkYP6 Gm5Wd0jC8RAFpPXNBkWpNOiVS5xgr90Dn6+1Q20P2dMELnduAX5mb3Io8gP/0P4h5NgkZmGN0hyS cY9sU5ZliR/LjJUPtRgM/lXStGeOa8ai4tmuJMtKHw/mcN9fU/8A1qlUIFaVDsjUYK9OfWtyoJX1 K0dzJKdrAYD7lXHzcd6q3k8hmR5C65P7sNwox6f1+tAla+pahvCFIDc/w46Gs+Z5Yp4shs535/hb /P8AWgadk0f/0f4lpbyabBlOMsGCAcEf0qa6LMpEEfTB8vPJ+n616B5ztYyWhuwd7RttY/MjjI/E VqCMRxCV5EcMMMFOTn0x14/pQYFMsu8JGnzMc4POaj2XMDtNlZkxyoTBT6fSk1dWAuNcf6uRpCyb eCc4FZS3kiSukUziOSTDDpgZ7VPJZ6Af/9L+IuWBWUDPzMd4x0IqddOKZmBChY8lSdtdyTirHhrW ZMl4ptRHCShXPP33Jyc1mCFYtrtIXkZtyp1br6Unzcupoa8hZbMN5avvYbI2GDu96oXKSRTRIAxd o9zRqMmIn0rNNrYLdC3apLED8u+HG4s33ye4NTXfkSIrq2SPbp7VUpXVkdFraH//0/4nbUPMyRx7 zk7VwpOauFRHlg+5lbYdx4yOMCug88pThdp3BwH+UnoPpWZJGgDRIxUINyuDz70ARA+UyJHmRuue 5rpbYgIhuP3W9CBnlMgd6AKkkLIIrlGR4/MIcZ+ZMd8YrH+3WrXAfaxPm5dVO1m+h96AP//U/iWv dQtZIBBLCJBJIGJY84Hb/PpVfzUjiEdsg3KfvK3QVu9DzJuysU7pHmKgnY55OeA/41ZjhWIsojOQ mB2z70O9tDOL5Waun6RJdyxzJKEjgQzMOV3sOAoPfr09qmvHdFdLtwF3ZDL354yKFfqbmUZPnQW5 A2EMPRvrWrdTfbFjQLIJEQeYD91fQCmRy+87o//V/iKdGguiH5A6sh6fiK1IJSDhFJU/MSOntXSt GcUFrczr9pfMyxJjLfNxytV3tSUSQzMEAyAeSB9K3NS/buCXGGEbAK5Xktjv7VYvrLzzAEmVsDCH 7uM+tAGJdQPA7IxTCLjAPysfaqcUmyRWwQqcnjOPesHuwP/W/iDnlLhHRncMeQByR7VZjtIigL47 SIjfej/Cug43Np2RNG0KK6LDHK0hC7ycFPoKzLhPsZTBI3tggHkCs5oXO7WFjVGdwCY/lDE9fMFW FhgQGXaGD8HaMYxxWZLKK2bb5SrbEk6c4OPpVFLZ7O5WeZ8qr5AXJJ/CqT0sEVfQ/9f+IyWdrVI5 Jdk0Nw2RGx+YfX0qk6WvlSTq4e4lG2KPHyj/AHjVz3OF/Cina7oU2zned2VAOBSSzm3G4pv5655q CfQ3tEsTcrulBQN8yg9gcc5rS1fT0jZMymTaoDGMZCfl+H50HQcyIH3Sv5n3SQqsu3OKZbxGVmSU nKjIwOB9aAP/0P4khIYRbrO5EaZMQPGQetSNPHKG8nOFPU96Dn2NdPC15eRR3UL2qeaQgjkmCSMf U/XpVC5tTazGFgEgDbHP3lXHFB0GDM6xSs8LBYQTGFQcyH1x6U/51RJGyABvVehagxl8TJUkhuEc xriR4/3gDZkHHQVZaKdLZ4YlG/Z90Nl0NAr6WP/R/iJ0wCykzLKzTAZIPVc8ED86sXV5bzMMIMZw D0cEUHOZzoGRyoYA5y3VhVBSkLMZ4wXK4QHufWgCW2uWYhYFSN+jgfxc1opdTJdxLJHGrFRt2PvW P1Zh378UAWrmKCeYXAlklVJNiKDlM/Sqck0DBjGhZ0biNhQa09rH/9L+IATQzMpmUrMfkLjgKKn1 C2iUW0ywp5o+9g5jkC9PxoKi+Vly1vlbEUamMbfmycYPTAqDURttkCyR795LHd+9Ptj0oKc+xlRy s8eGDKVO3CjhxWtp1uLaVLyNiIi2GVgCykeooKjK4XuLjzZVcZUnamMceorCtpjmQpL5TKpw4HzZ 7AVEpR2CbVrH/9P+HrfBfR28U9w5lD7jJcOY4xjpwPofrUkl81yrxWwYmM7W+TBUDuKwdr6AbukL bRvvuFkmEiYVvuyFh2J7A1T1G4hunSGGzmtZIbhsFphMdvYjHYc1rFqxPMjMhjCF45CXkLlgzcZJ rQke1tPv723QhuI8qG7gGm2luYmc727NvikZSRna64z7VLDEs8NwmCzt8zR527gvIxQ2krgf/9T+ IbT4pJLc7n2SA+XGi8ooz3rSFnaRX0MELz3JdFkMjoI44325Zc57HIB9qT0RxOTTaRNdxSXFtMiA RgfujKp2t7n8qqWTTQQHT58XBtx5kMjjKSK3QMfWuaV7odSXKrI+2f2WYJbi4ub6e+t4lsdSgMFv EN7knaNw91x07bq/ef8AZV0Szufi94TupraKf+yNQj8iG7nBlkRgQH8kdeVGT0561/aPg4nh/D3G Vk9eSX6n8aeIUvrHijgqLWiqR+ex/dV+z5pR034baPaxIF8q1S4tVVAsU3mxITj1AwP1r8Df+CxW rfbvI0S2tWydUFqIklVdjzLMZJcZ6BFNfjPg9fEeJVOsv+fjf4s/pHxqcKPhrWoy29mkf//V/HL4 /wAt7o2mLptubOyt7KN7mK5aSPzInVFaMlSfmGc569BX8/fjErFr9+ftC3SfaTKdrZRHdVL4A/2s 8e1f2/8ASYqOOUYanf7X6H8mfRvUVRr1DJ08iDdI2d7qVQdlz0/lWvZWBuwI8MblmzlSeRX8P1j+ rXL3rm1pqT293hhhY225Zfu/X8jXToomMx+zsqZGZOu7HO5cHiuCfU2LTywicoqXHltb7IpTHuUs MZye31rX0iddrW7sw3DawY/fHpXHU6DTaeh//9b+MhLDz7648qSRY7giIWzYEMRXPKn0Pc+1MOlw wzY2p58i7HkA2uwHQV8zL4mNu7NKysZ7VopFb+LO3v7Vet9Gmkurm7uHkkhuW2tbygCIY4+v696k zmtLmXNp0RnMS7Y445fkYHlh2HrWhJZKsUyzOVtgoJIJyvbpQZFh9P8AJnSK58q9stiyWhlTcUBA PPoRWuHhjle6/cwQ7FREh484gbSp/L+dYz+IdtLn/9f+RG1NlcS7Y7aO2VMuyoNokLc7ie9Zrotw 17HGZZRgxmMfxYODgD+VfHPZmDTR2Ph6Oew+zxw7o1VPK8sjBAOc190fsf6D/wAJL8a/h3oKSM7z +LLZbjcyoqlpUkQYP3sbB69RXz+bVPZYDEVO0X+CO7CwjKcVLa6/4J/o5fswaNFpfg23soY0ljtp Ps6s7b7gKq53M3Q5YOOPTFfW8MikhXBULwB9K/FMhX+xr1f5nVZJ8sdiY4JOCRHjoR1qFJAW2gAD oCa96gvfbKm9bH//0P1h/ast9Gm+FPjKe+V0YaLLbWMMbFvtruCqF16gKxznpg1/CN8bdFbWde1q 6vtNsoNQt9euoHWXi7hkE5LnfjcVbG4DpjH1r+e+BIuOZVJX/q55FCqliJU+trnz5qt7HbxpJdmJ byAeS42CMIgwq8d88V5ProjnaeS4IVJcCBf+WKkMCMiv2Vm0vhHPZrcTQ3FvFBaxCFGEtsuz7Qyr tG4fh+tQSzXd3Z3ejvc3cVpdHE9sjEW8pXoxHqPXtirekU0ZvdGnp8K2FlcxXKxm1jiSCa0Y45HS Tr19/f3rMv76A+TLp1mZ3kkEQlaP5FI7H3FTFO+hUGrWP//R/jWlvILy2+zyL5Fw6+W8bOG3EdSD j/8AVmpJIVFmFQbZlAXBbqo714+x54mneG4tWS3ubTVHtNRhuWhNvdx7LNlxyQcHPIFZkP2bSrS5 muSt3HDNLBd28EZJjkVlCnBHOc1MHdagdFMtjeR29z51wJJnWKGNF/ejC8bj7AfpVS+iQSgxRFOP 37qvp0JJ9elUBSa2nuY2lsI55mjUmUxoW8tVzknFFlZq0TT2QeGa4tmhWaTJuIM8v8x5HI6fhWkH 0A//0v487S2jtYrdJNjTbQZJgOXI7mtEysxl8+coI4GaMAcNgcD8fWsad9Dy5oq6dPaGF/NkPnup dIdmcHOCC3Qdq898WXMUKOIbKITPKFSVEJZzgnBI+hruhpYPsHkrsbiTz2jUMrnegHyZr6v/AGOb hoPHF/Z3Nnpmo2hnju5Pt9w1vPGjFUZY2VgRjIbBODjoa/SPDqfs+KsFK321vsfJcZw9rw3i4pte 5LVeSZ/Rb8KNY02x1PQ5/wCyNLnWz1HSyZoWfEX76IARnnLBgSSOu30Jz/c/+xbrrat8KtLtml8x IIo2t5DnIBTLJ+BJ/Ov6B+kzRUsmwmI7f1+p+ZfRPxFqOZYS/wBu/wCf+R//0/6Sf+CpOj2l98I7 v7WJfLFnd26tbqVYCS3ZXDeo+ce3zV/H/PBAjxSDUbPbfR5imXNr5KngBgeM9uPTtX93/Rgmnw1X b/mR/Cn0uIf8ZRh1/df/ALac5ohs5rq5W8+1i7YmNZY3xGwBJycHue45561WuSzar5Vy6wwiXZLc Kg3RRn+LA6nHXvX9Uwnqz+NJ03yFjUNQhuZhpen26QWUUO6wmmC+dOVAMzSOAMA44B6ZP1rm0u4b S+0+eNRMq3O6SKL70WMguPUcke1bQnqu5zSg7M6fVtW0e5kdLRxfRrJi4guIWhZl7EH8f1rnYRpb XBjlubezW9JECvny4AOQpOD6cVrzsUYa6H//1Pz2hla3uDZ2cayNK/lxTdYVYng/T/GuqGn3CTfZ tb1rTY3Fl9o/dyG5KkkYGE3Ef/q5r/aNTZ/iMopO5yFzHcaeZjNcPc2gI3S26sqSLkYOAM9+4ruL M6PcaeDdSSw3cbK9lFLbNiQt8uFPc4J6VcZXKiruxPqdkYtNgtfs9zbGV2OZVKRyDr8v1JNYFtZX avD5tuYLeJcecvEkjZyCD+OPyqjay2LtnLDJNJHdOUZAdglB2P7E+tEMC+c1pPJ8qqfLmLYbc33R j06VpCXRil8J/9X4ZttJlgVTZBZZon2iH7qkdCf5nFRzxXFtcyxyyicyRbXR237CeQSPUY4zX+2K bWx/h/JJXRq2ifabJrC6W3kVG87zQhMszYChFPbHX8KpvpkcYWQLJC4UZQ/MynPc1rF3RztpDL22 Gm25vZlYqmxHl2FmXzGCKQACepGT2pq6Xe6XcXFzCJYLSOESm8OZGw3ynPoSSeeeoqjnk92zZNxF 5EN2l20kqxgSLJEYnlHTJxx744qtcpo2sQWovLdrR7QM6vFdPF8x6kAEA9Bwc1cZW3Oc/9b4n1ht PvoLWGeNJrS1UBVuDuSMqRg89OgOaFmu2eWS6ELx7V8uGOIYZVwAM9a/3AjLrE/wmaurGf8A2fbt d/2mYi22PyjFuJjxnOMevvV66UXnlRsq26zusSzykLbqzEqFJ9enHvxmtoyvuYtWdiRkn0i5vtKF x9psJAkMj+UDFMVIcOv4jtUjwtBMNQurNCE2wxbIwHMeAuWA9ff0zWik1oZyS5SB7qA6mk0rPLbx Li2hBKrFkc8fU/pV23tc5GmTxxPLPmVHk8t4938S+o45x0qlPuZW6H//1/jmaLUtLlxK8Nx5Shna E/uZ/X5c5/z+NUftcWRcW3yXasZANg8tPoPzr/c5Sif4KQjpdjoro7WkMczSpICHDfKM/e3DHIJ6 DtWwurQIYJLiw+1RyyhJoAShA6ZUjp2P4UOSQ3FWbJdXuBcqAvkQwn/lj5eEYAYAXHQjj/PNcVPb vcTW9lbbQ7PnBcJkDk85wKpa7HHJWZ1QhtJzA0jeW2nxBA6HmVgP4vaonSG9njDq/mwvvRsny2I4 BP0zmglpPRn/0Pim9ikuJomtJ3W+iJSSOaNRaSRjnAkJyDweMd+taF3HaPBAluZNxUPKwyiqcfMp Hfn8OK/3Vgk1sf8AP9OPQphDHNFPsd4IbdoB5PyeYxOcseeg4wO1LDqLujrkFVO11xwPw7H/ABqz kcNdBskxMlvJb5cH7xTO9TnjAq2bnIZHilwi7pmKH937n06igqUVYkSS2jjZZ/tshSM+VHbyrEWJ 6Ekg8d6pJNc+YEjQq4YFWbufU/8A162h8JzTV1c//9H5Mt9VmvrWS3uUsRcWFwIiAGYyZGcjIwCK oNL9mlEygNIZAwikUSQ8dPlPFf7wH/PZGKtdlWSdP7QiuJ4YyQp2IF2wrnsAOmP6Vs2g0zUrbUot TO53jAtcLuRmUjj26dT6euKC2rqwaGbKzmmdWLSIm2MI2046Hk5/zmkvFS1VPLdZFdRiXIZmJA3D IHUHrgUExjyjdP8Astv+8ltYpJixMclwBKFBxggEcEc81n3DSRmW3jkDWF0yyNG0Q8zehO1gx5HU jAxW0fhQOCZ//9L5ChvWSffcSyCBIgkcZYlC2cAE/wCelU7tXa/mj3rKsa+dGV5Az1we+Olf70H/ ADzyTjcqW6Q3chRrkxoDmQxkEsRzt9s+9bltpiNtLzQ7eqANyMZ61XNZcpg731K09xFEDDFbIgd9 7S/xP0HNOhvQA0ZhiwyYNyOZ4sdlB455z9KcZW3Jd7aFKdIjhVlkaPeHEZY/KQeuB9KnEuSwjHKA Fcjr2rRNPYm75dT/0/kiSUQkz+eTcTwhPmwSiAYwo7fXr71UtvKlk2tJh8ErkEliBwOPX/OK/wB8 D/nXJLZ4p7TUY54prTUYr5I7Jj8wliAbecdMElcd+Kf55tgsTnzNxxu6nHvQAxZZEaUxSARltoXG Gxnr+lQvmPdN5TSJvHzJwxz3oMZr3iaS6kZQuAibvlPUkUya1M0QlUx+dHzDvHv3NBJ//9T5Jm1K ZUjt4YVaDywLhlwNzAAk/TjtVvSokuopnmAS2L4IcbQzL398V/vgf85sl7rM10Q3EsUTb0ibasgq 2scARXuZANvBbHC0GJQBRJH2dz35U/5xTfMU+ZIxxtO1V6Z9/Tt+tAE8FtHexJKbhI4kP3XbaOP/ AK/arbPbtEsbNuZWPBPGOMf1oA//1fkcicKTPuKysFt2P3Y1A6AfrVVmWFG2Dq3zHpntX++PSx/z kRV3Yqh2lgdd67xIGxt5I54/z61as7nzA8Dsyxqvyxlcq/40huDQ+6uRNcAmCMHYE2om0HAA5H4V WaCW2kKPiLcRIFUHKKecEH8a6CS7cXLvbGKJ8J1wR0I7is+1jkAdjIScE5b1oA//1vkK1kSSOAzl yyoUm6BWcZ6fp+tWLaSIfaPMuP3YdfLgRevXLZ6cdPxr/fjY/wCccfJNZSNJFIzyR7dsT58t8kf0 6Ulwto6x+UjDaoHzHcwPc5q5SvsBSmkWFkUNl34HP41JDgNgyggj5ietVBtqwrK9xcpHK4gJeIL9 7GOe/wDWp7aUDO5QwIIFPnQ7WP/X+SXypIQ7d3TjOKfLcCV0S5UAoAqkALnHAzX/AEAWP+cSUb7F ZHtIbw2t8NiSZcMiZl4HAB+uPzqMQ273jNv2W56RntilbUyL00Fixk2uSVTG1ACrH0I4wDTGkV0R YoRC6oBtHTgYJob0Ajj8qMiNjvkkOWB4NIsMrvMsCJEUAwW+9JjHA/z2qH8Amrqx/9D5MjgaSMT+ bsdZNjW7gh3GDz+lOup4448j7ycHAyPTFf78puL0P+bpQZnvM7hdw+XHAI5FXLZdyiQAoF7jgitY u6NElEnuGd3EjsSxP3yefxpmVaVQ7Fox94rxx7Up7EODvoUoEt0uZYxO5QvuJc5VR/kdqtSL5UrI jpLGQDuU7l+maUG72LSsrH//0fkOVWidZULCNlw47D3/AM+tXY7dVt5737SsYUCJYN2GlB5JI9Bi v+gA/wCb8z54tyQsq/LKxJbPHHepsvCFUHcB39qzStMC0krBc7T5R4J96STCssyKGU/Ky+taANeE H96SAB96Ij5jUdvbyecZI+I1Usyk4AAoBq+jP//S+QL++mWFYbWBHY3ALNghsEgEn6CtDULZra7u LWzn+02yKjLdLjZISo3Y9gciv+gA/wCb8yhNMZMYwo46dPU/yqfbFIpWfkH8qmS0sTJXViSOCNCw i2qgUY6nPt/n0qZNsDNlc7umays1uZNNOzJpIk2RurKGOT5Y7YzxVaUXV1Faon+jrFOS7oAN4PZm HJ9cUioxvuf/0/lCUJC3lk/Mpw56jNMLO5VjyFPBr/fg/wCbxwVtC3b/AGRFnmmdg8KHARN2TjgH njtVS2klgm81AryAfuxIodFPrtIxQZpWaIr5rhd9yu6eVxtEKKAufb0qtBIJbiS1uZXR44QyCOPG xj/Cc9O+fp3oNy6ZIYIpVYuLlADARykg759+hpI2M8sJkJYgbF3nAXP/ANetaewnsz//1PlmaRLe Nkg9MMVOVJ71g28XmTMxZ1534b7pNf8AQAf83cZJKzLU8Fw0gdkH7tTgMvzevB/Crlv9nxxA0ZZA GJfcHI7gf5+tApSvojRUwLCAWIbb8iYz+Zrn5ZnDYdBGxOMdcfjWXNKxA8KygDPmE45HQVJuSCYI n3nUEp6e9XF3A//V+STP+9SNVUA9cjmnTSNEZDEFV2X5VPSv+gA/5tym8cmxHb5Gbr6MakjkeNGQ k5P6UFRdmNW7Co0TbwHO3DAhSe1Iyq0LqFG8D5jjAoNgiSE24WXJVhkbDjB7VBJN9kIeKM7O6nqa mTaWgH//1vkW9uI5oIpoYQkZUKyg5YnuTVZFkuI4zFkAPsYAYbjnj9K/6AD/AJwoNLQJrSWFD5pY LJzHuGCaqxQvCxG4eW/JXPIx3qXJIuWossgCMY9wKMAxHGKme5ubNUeMsXOGBBz780RlzaGJoJM9 0vn3CgSyfNKMZ57/ANali+yRNtkJkjkBDIrbOx5z7cH8KoD/1/j9oWhiZBh+pEg7j0/L+VU41lkI JPzf3e6j3r/fuSW6P+cCK1RfkfdDskRnKDaoU4A/zzUcSROjqUUsg3Zc4K454qDcabpEKRsfKEv3 Nwxn/PNVgzrIWVmfB49DQBqqnnSCYoCREVVc/dOOv8qw5Azyb5PmT+B1HDD1oA//0PjdLZfK8wYd mOVweFFTQsERj1A6mv8Afg/5xyD7RvXcg8t+g4qJJ5FWRWXLN93HegC+kIWMb2AkPJA+YfSpEnjh kDHJToQuNq+9VzO1gIr2IfaElGyNGw2xD+8A4OT9f89akuHEqxRhwIkyXbrL6DFSB//R+LTKB8wd mRuUZuCc+tOZZvscwt2jjlkwRI67un+f0r/fg/5xyS1Dvb+ZMDuB2htuD15qxFPaOZYTI4kiXd8q 5GeCAf8A61BpT6kaTJPKoZmCfd3HO0Y9qdOpdTBszj7pYcGmk27Ggs0IXS71HZVLWEwDM5jVWMbK oH1YgfjX4d/tbQQr4k8q4CreQTstxbKg2CRXG3kdeNpz7n0r8l8cly+HON/wv8mf0t9Fr/k5NL0/ 9uif/9L+Ja6bzGclg3zbSirhlrORYt4WRJCp4VmGa/SMQ7z1PmabtZE0tuYnbCkqEyn+0ae1wgWF pkLSFQNjZ6CuSdtjYeLaCYZQBfM+UjofoKsRlLVhFEQpxtyxOPxrkl8TOheZDeoIHMscnnsIwzYO 3r1x9PSq1sju0b7sAnJyMkVzy1YH/9P+Jm7ML28sYUmQsP3mPmXFRRRRy2kwkJE8LgHJLNKD/hiv qDxyNz5KBQN0Z4bPGKrSkExmZViCucCLJJB6ZrOV3JIBZod2DAxGPvkn5RUsd1seOJw5Xb8xXuaU 3cpLRsniSBxI7IjCQ4w38PuOamkuGhVVgfYoG1gTgVBqlZWR/9T+Jm3tWnJO2MtM/llA+XbHQ1Zh hEbvbXRMHkjcNwILY7Af56V9AeeTX4tLmMC3lWaEIu2XbsyfTHsc/lU9tdAWZiklbcmOo4xj+dJt Lcjk11MCVJJ7h3QM6Jznb1pIy0StcMXUE7ETp068Vk5N6DUUjRa7covLtuGE3D5lHvUeEkjIxlQM seuKkThd3P/V/iaIjRdtuVYsnPFEjZixkFwmQp4yR2r2DzeSJnW6uZAtwNkjniMc5Fd8sGl2OmwP NdQC8MZkNvtKuVLcdsUFWscveXASTfhhldylVyoH1qmJorh0+0NuLnksM5PYUA0noy4LdVxhwiqc BM8k1TdJfNJZPu52joDj3oJ5Ys//1v4i5MmaOEMI5HYO20c8npmpbyWRAtuqgFjyx6D3NeweaopE brIkKLIAdxwMHcKjiQRRFmZ1IkDeYuCDg9DWD3ZR09rqVu6pC8jNDJIDsU/MD05FZ+srFCFlaYR7 ZNsRJ3Mc5wP0pCSsrIywpuhEBCqLFyzxYVmPrWxbSRiIxhuCcMzHDelBFv3h/9f+JeW2t5YzIxCl MglOS+KhgFugLuqvuUryPuivQPKmtRsSQLIrh/LjhBKxr0kzxjFbNsIGDBOWcZww+X8qCCpIPkMR c7lfjYODjtVT7IkBM74jBOQByWo8gJmm8xmJVQgTGD2HemQIqsJYC5Ctll/hceh9qAP/0P4ob5oJ SrvCu5hgLjCx9uKzWZEjGJAFh5616B5Ed0QzHzpoJlZDGI+nBDn1/wA+lX1uHmCoAgVTtYjrn0oN tEMSdfNSCMf6w9T/ABY61faR40dJQc9ImHT8aTdkTJK1zIMWxTMzSz7OsZJzye1aC6dcfZna3j3x ooeXDAMinPNKMuYIJfM//9H+JmCFEjQ5/eA8Fh8o+hpl5cKQ0MuDNjO4Dt2r0DzyukEQtnLySvIc GJBjYPXd3qVWAaFSVDOv3F5GB2I/Csp7gaTCNfnRyD0PHSo1ZyCxJK9BgcfWpsxrfUlaXcoc7iIl xyflNR22pyytKgO0E7MJkBgOefyquR2Ll8R//9L+J9pRPI8l05IjO1SzfNxwB/Kq8sAl/euSiAfK CMg102aPPKlvJHEMMzJhtqn+E+xq+1s5bdsG0oGVt2WIpCavYWV92I8oR5exkbqR0JoRI2RFRMIu FbA5bHTNBEou+gy6uEVSiZ3A9+h4qtbmUiW4eRAPL2ADqKBcjP/T/iMlt/MCGTaDnIZeM/WlhdPN WByFRPuoeAa6Dx7W0Ll08nnfJFliflCjCDtUUcUxUSzAqGO0jp+lXB62Lii4rQxbnKsrbRDGQvv3 /SmvtliCOFfYxPqQfatSCi0Hzp5SbYs4dt2cH8adfwSKUQM26NcANyxyKAP/1P4kLfEiMpbJTgkj gUWs0u8lR5nz+Wg6buvNegecleNjfuYJlsvM2/M/A98dcVyjJcxBlBC7ueecUbGXI72L2nzBlWOV gsiPl5dvzMKtwzxpI0kig2u4o5PBH0pcyZSh7tnuReZpzRNHFvOwkjcvygZrFljaSTdGdsUZ4Yrg e4pkuLR//9X+KbTTaJHK8gSVQMgtyF9cVLezwXJlEUaGPyQmwg8HHJ/z6V6B49jmEtSkcZiOxwSJ EUZA5qWN447hGmXLx9M8UGkIpq7Ld1qUEh2xPsK4ABGcE8cVMS0CK9yrPLIcea33vYf59KXKkVyJ M09NQvDMjiQbsuuRxz71XnhS227tnljkrjn6k1nNJbFH/9b+KKGZhLFscrGCWi2jGSfeopJY7dxH OgV1k85CgyHzXQeeNvL5ZF+TlW+U/LjZiqi2SSLHcF94Y7XjHbB4z9aA2NB7ZTAwCqhRwQ6YDj/6 3FV0d1SWJnMzquY43O1Y/egSknoi3Zo8ymKMrK0g2YHVD/Ssy90G6tpxI8Aj2r8yjhuSRkCgZ//X /h0mUQS+Wy7gpyM84zyKvwy5THlGEMfnJ4Zh7Vu1c8up0FuIiEEil5FJwmTxHW1axvLJDvbkxjd+ XIxTIiruxpXsc1vDItjciFwucZ+dAeuB61gSxzXkMv7zzZTjc7Ebztxye3OKDc29K0aWaIt9nIG3 Jc8nioJra6s2lilR/nIKTeo9CfagD//Q/iDuzKGkRQGTgyP6+wq1CxtYoQzlN+GBAzgdcfy/Oug5 YKyLF0TdrtVgCq7vu434ojszM0ErEooh2bDn5zWsHpYoSMLasZ4WClm2Mj98Z7UsbKRs8zLZJx2F PmVrgZMx8wSiRw7RH93jgkemKjtomnlWKPbGZBiQMcYA5rJ7ik7I/9H+IyKHbKAjhkU7WGOmPSll CxXGT/GMHnriug88fH5KTwswC7iQY87iD2/ClSPzpHMgQspy38QYD0qZK6AjnlRHJESIvTO3GBUa 3MU235wkYJHlhMDPc1iAXX2ZQscbOsi8rnvnrg1QnYtsVcGVDwOnmUegH//S/h3HnTgNPExCNtRN pAU04RO8yjiKBPvnGHz6Y96ue559iY2fDvgOucIN2CG/yKqPEzYWVPlPQdSag1jC2rNCG7nslihT 7obIAO7Kk9CKtyavMivAXVc8sMZJHoaCyKS5Wa3DRnzHT72F5HWqsU7xZmjTfGuPNyMdeOlK6Tsx pNuyP//T/iJDQXIbcSrJjaW4UZ7CorciUFJC6tG5QvGMRkDpQZqFnqb1nf3ixm3ZtyJ8wDDB9OKd HP5syGZdtssn+kZHMi9+e1ZzfQ0OYQM147QQ74fOO1W5+XPBPsf61syzxTyq0kao0a+WEX7mRUqU kYy+JmF9hmhmmn37I92+MLncgq8ty8apNbyCSQnDKw6n3rYk/9T+I6SzlvIvtYYJLGQXCnHWsr7T FFdfOoY8ZPYUHOacpxtlZdsUq5UgcGsKdpZbj7OFSVHbcjtw0fsPaha7B5E62jeaYyuwAfvGB5Hv WnbW8Me4j58DDPigV1sP8tYVePJjUqSnPAJ7isfy7iNtgX945xuXkOO1BcNJH//V/h8Wz80vBcEx 5XLMB0xSzrhoApZbfIjWQc4/D8KLAaM0EflFg7iRCCvZiB2FZnlNOrTAfMoyU6k49aANVEgt4ori RELFcqgYE5A70PfLJGZIYgP+WZTPGR3rN3u0NOzuUVx5Uu5Xy68HslQRpFafv3iEoMRC4baAx6E/ Sk4NIG29z//W/h52w3ASNkjWXb5m+NtwQ9xUtssSty5DA4by+pHSucDV2yF2gVSIY1DeZIMbs9qp T+ZBcGUSAJsCZY4Jz1AoJirXEupf3JESE4Gd237n1rIAur1khjdm2sN+45wO+KCJRs7liSCZ3H7s gIMM23B49a2o5FEOIgomjwvlnj8T9abbasQf/9f+It2aESFR5YkHQDhT3NLaW8k0rTea5ggTzHlb J3Y9TRujge5px3tuc/ZJZbkZ2vHNbGJQe+OefrT1lWIPLLHtWMEuuzcSPpWCXvWCv8F0ffv7HGk6 Pe6fG4giulv9Yu57ljugurRUVCjZPAG4vleuEHtX7xfsU6bb3nx18HXK6c1zFHstZ7h5CjRQecod UXuWA4PbHvX9peGEfZeF+KqPS8J/kz+MuKf9o8YcLS3tUj+h/c38O4rbQPh9oh3tcWtlpojt0L/v HjZd65x0IDfpX8s//BWnW0l8c6XbQXqLb2uuSSP5YaW4uVZSIwRzhRubke1fk30fqLr8eupJaJyf z1P6F+kNP2PAnsodeVfJf0j/0Pw4/aV1PRtO0qeKXSllWW2MaTPO8mfObad3PqnQ+lfiP4k0CWfV tQkK2ttJHIZHiEwHmqGwu0euMce1f2d9JqsnQwtFb3/Q/lz6OdBwymrVezMH7EQYjv8Alj+UlTkH FdVpptNOtWu7u+aG4U/6JCkYcXHbBOeMda/jKsj+m0r6GhCsuoylkxHERvlmAx+FadhNc6Zdw7ZY 5LNCRIJ08yR8jgY6dfUV50+pulY2ooJZr+KNWjMUpD7SQqtnpn0qXUIntnDRogG/a4XjYBXJPYZ/ /9H+MePVY1Cg27rMj5WTdlCPp1//AFVdSSKQ/aJnQF1zFt/nXzdvfC1tzVjaUOJC0bQrGChH385/ LGAKG1M3BePLq8bYRRwTx1puN2JrRorRpFemSzjmijvNv+tZv9TnoT+VWFimFuls84uh/wAtJ8Ab yvUfgR+lTKFldGag2WrdZ4w7s+YSuRGwztxnOKrPK0zRJbx+UqEssgj8whiepWsZxb1RTj7tkf/S /kMtbm1kuRapuMqx7pVK4cqOCSO2ea0rUWVreu+m+bMzgK8M67RG5/u8+4r4+3Qlr3bHW6RY390s c0qwpKJmBw2BtXkn64r9KP8AgnN4YHi39orwRYxRi3ca4gS9kXMgZNiq6e4ZucfwivmuI0qWUYqT 25Jfkzop+6lY/wBFj4MaRDpPhTToLdcFIkj3bNshCLtDOehLHJPvXvECI/L9QOPavx3JI8uAh6HW tGKA3zxNhsnjHAHFVSjKCuORxXt0vjBu7P/T/av4uaDpNx4W1m71GxN9bRW8izQEf6RKWQsqxduq jP4V/BX+1TbjRfiNriKptLddde/EkR3zXVy7MnlsnIA2KCTX878G1HHNOVdV+qPFo07VpVfkfJOo 6hDqi61JeWct5fw7RpX2yFFGoHaDsz2xng89D3ryXU3h0vyJ7++hc3TgPaIrSC2zjCqcYI/Hiv2h ux0TVlY2bWV41e7+yPf2VmqtPBBKsDgPwvzHgc4rEsINSvtW3C7ig3EkRAgW8aE5AbPVsYGfXtTb bVieX3kjpIiFstWs7rTlldmHlzzrgnawyykHofSsh7nEeyzVFEDHzYOqKSO9VGSiEYtO7P/U/jFj tNWvTA0lhZ20IZwlys+xpCOc88eg61o2dvcaxmC3Y2ZtX+zyy3BBO7oWHqpPT2rxzzzoYra500CG 6e3neJ9sc8BG1h0yAOnepNYu5P7BurH7FFKl5KsskyWoe8YDjCsBkjpx7UlFJWQ07HLWkr2at5Mc kiKAADw649v89KjvNQuZoP3lwwLNue36AnpknuaYivZXF1bQ3sllLKZZIsFCxSHnscfSpdb1SS30 9IvD9i8P2bTRc6vdTXCybJGYA7VxkDPb+dXT3A//1f489LvI7qysYZQiSeUpF7jETBsfM57dfyrQ t7+ORvKMDSi3fyw0hXypAPQDt9azpqysec1fQp/2apuZv3bxsRuOWAjbOeFHXNcfr0kdlFPaosyG 4bBeQZB4JCg/n+tdlOzsEl7rZ4nfbrQPszycMTxjntXvv7Ol2bTxTDN5oP2plVYsbHjMckLFiepB HGD6193whLk4gwcl/wA/If8ApSPmuI4XyHFR/wCnc/xiz+jHwB42urbw34Rnurqyit7a407Uri00 rw/Cbm6jTyZkYyhASxBCt83HQ1/bL/wTb8QatrPwa8MyzyJCk+hw38cTr/pUgcK4Lofuk5Oa/qH6 RdKNfgzDV3urW+4/C/orV6lPiXMcCl7rUm/VM//W/qT/AOCgunXuq/DW8EUEJjm06a2jZlLx7xiT 5+MDJCj8K/jKlsJLSyKajBHHFasLZ1mjVgWBIQKe4bgjFf299F6unkWJw6eqkn+Z/En0t6D/ANZc NUa3i/zRzTIbNr57NEuJrdd32VWAlVuyn07CsmKD+3ZBc3Eg0xwUHK+YMjGVP8s+9f1tT6n8Z1Kd oaGOyzTai+n3Vwse+b7JYtAmIwzHCk47Nn9a0bafTIrXThpun7NSsg1nqE91A2+SMEgbMrt+br6d OvJraC1RySgte5QF1sl+zJb2zxzOwZpIlDqTwArdsVQvdCaDNzcOomDfLbhyzheefQZ+tbpN7GfI 72P/1/z9tUvIL4C0l8iKSMqdyB5gSuOT0xz6VYvrVdDTSr1D5lzdh47lHTzFR1zwG9GB6H0Nf7Rq De5/iZyI09Et9R1dGunhRLZZjAHdtrSFcZ+X05rVligGorbS7JIbFFngWN8qH6H8sVcYqJSSWxzV 20lzfy/ZRPBcXUw3+fcGaC3UcbwCcAnk4GO3vXSvNqd5GltAbfyrIoruSPNmBHUr+B6e2aqwykY7 e3uZZbqKeRbeIzXCpF5hQdMlceuKxJdUhlnW5tUhtbRGOxCjI0q9M89D359K0gupE3ZWP//Q+FdK 1IQXUAdpnN1OWS4PzQwKeeQBnH510t1eaRbi/wBQvrOCQ3Nt5Ek6R7JICCu2XCjr8uOf71f7YH+I D1bOUsnur7zEsleIsSYHlGxJBglTn3rYsTqF3bOsku8iXDtgBpMDoK3irKxx1Nia61SZ3fT5VSCK KMq8ZjxOrjpnPOOMYrCuZr9gZWupXjEXkSs0u2IqCCAR35ApmErcupfggaOynvDFJgQhBMy5icE9 Ae2PaoVkaXTvt19GYLW2uVtYEkxHNcFjkCIDJOc9e2aDE//R+MbBIZrqVrqBILFbdFxOMqhOPmYk Yycfzq5f3On2946W/lzxxfu0li+5MMYyP5fh1r/bymup/hOGlws11JowitGlK/a4pJJtkgVuoZWO Dg9AOc1TmtNWg1LULS3lgFqsghAnjEile77MEA9eh49a0XkZTtfQhjSW91BrRg0EcKjDyEFDhcsc j6dKu3MuoakU0u3dplt9zbre3BMUYKjDsBk9QOT3roMZuysZc2jx6XO9vIGSTaJDlNgO4Z4rXtdP hkAvIn2mLa9y0j5Ofpn27UGLdlc//9L5Kv7Z7iB2KEtHETG3RADjqfw4rntLs4J9MuZlmiUI/wBk jEkm258wEZwDz0zzX+5CV9D/AAQUmixBbTQWXnEebucxPGnDADGHx6f4GqumSahBd3drH5041CZZ xHKoI+VdqiPPQYB6dcmm007MG31K15cu0zOqkS8jycY+7wcD8K6izNhNZRXUlrGbiRFDFY9syAKM 89ueozVwdtDnbuzNvbK7eOS5ghYRkgugyREvTLGptPWMIN8u1w5QoEzsXA+Y/rwPStBH/9P4yuGi TOVMwBzwPmbHpTkubiaBWitggL+UF3APt6ZI/Kv90U2mf8/5t2J+yQSJNbNJGriRpCQVjBHOBXP3 FtbW11MLS5+2W8+JhJt2Fc9FYeorcwas7C2sMlvJ50RPmKSVA6DNdJozSWwvbqeJHW4g8mdZRwAp 3fhgigl7MypLizvopRAqi7RHeJvulwgJbb6gd6uLZLDZW93PHKpaEF2IwjbhgEH6mrjK2jMD/9T4 uhgkg8+Qs0pkk8xiv5Z/KrNrFNcu0piEkK4wR179a/3gP+e8mvUiURvDGd0reUAfugk4x+tZG6aI uqDymVsHI+VifT160CuloWo7oRxqUMUbox3oYvnmLY/i/DoafJFwtxJbmKWUAsAfugE49qCedXFa Fr6VZyWDWqlYIgxVQO/GeTTDcK0eWRxyQCRjGOM10JWVgc+x/9X4+s5LFHWC6viPtKZIWEyRxkcq T3z9KW3uYJbiSNGRhEjKHVeXHfPf86/3oP8AnmnLRsrG3tx8yvFDI5JEaggzYxk+nf1qVpoGiS2V lE6qQY0ySMdyfx/Sgxbb3M6NGE0sE2/zIznaeNtXEMCBy0cmNuAFGSTnvQItoIRH5iqfMIwFI/z7 UzzbZLSffaXDXpP7iaO5VLdB3DRbCWPXkOvXp6taCex//9b5AtLci0S4mt2Hmj/WMNwU9wD7elRb V3gwHBXgkdq/3w9T/nXI5MxuPNbbk9zgsfapVtTcy7Im+Yxs6M5+X5RnGfX0HegCOKKQKfMBQZ2n ccdKRorhTsUkoDyCePqKDGfxDfmlme2eKRVhQOGJwD3/AKVeGHUpnG1cAA0En//X+PElezjDx2sl 26uFjhiAycnHOatl7ryyCrQhOWixgIT2xX++B/znlaaWGKGJ42H7wb5GUYx2wfyFKtzDeWYdchTk AsuN+OOM0EqCRnrcTQ5hl8to2PyYT96nblup+lWA+EaJ0+Rz1796B8q7EiyiGPy5o/OhHzRoxwAc jr+VQG+gmbMMDwkny/mOR6ZAoJ5Ef//Q+QlmNhGSs0kryDHlsS/J4AUHgcfSrs0dqkEQlDicAtKu 75DnGAB/Wv8AfA/5z0rKxn2mn+U00uTtmPmAMdwQew7evNTRYkmZdqhF+66D73H/AOugCZ40WRGi BHcueCppbye5uYgJNpiR9ocoAT+PWt4tMiULvQltZ7ZYJ7VraOVWQbJCAJI29d3XHHSs+dJY41aM KAWwc9xz0pmbVtD/0fj5Ildd68MB8yZqkskbu6qMMuVI6Zr/AH4P+ccuxQrOkai3yYR8v8RYjPNP WZnUiKFgwGJAcEr27UAKDbtZlShe6STeZiecY+6BUEcEs8Luu2NUU5LHBNaU+oCRvKqGIRkKo4Yd D9a0biNoo7Y26mcu6oyRrkqzD/IzWYH/0vkgwXMeTLtyc7QOGU+/vUUFvJ5ryXO2RWGEQjG3HfrX +/cW20mf845FPM/KpGrOrbRkjgU9YlYDJHnAbsMdorUia0uS3E2bqMLaNEiwqWZVOxyBg8nueKfF Ikv74TQh4eTFvAkXBwMqfX+lJpPRmRHK4ll851UAH72MZP0q/vDQllwoA4OOaTVo2A//0/kq2uzb zCSXZcENkq65X6EVVVlkuHQjKO33ewyc96/34sf835qRW8bbUZQCDjLHgCrV3FJCpFsY5VB2sU4Q /pWsFoBSTzZIXiVFIcfN8oLLjk47j8KoFJNxiMghUggux2gfU1TV9AKewBGaIiR1O1hnk1eiRvIY bXEikEjHIH/16EktgP/U+TmZZYkUgqFHINNie2lkaGeMmPZtVd+Ocdf/AK3vX/QAf835LM6yoscW RFbYRB0HJ6AVLcyxiGCJIoi8QJldThyOMZHTj+tFgKB+ZSR8q+h6U2OV1jbywGaNshW5BoAnmZmt 8xEedjL54259O9V4/PS1iSZ2kYyZO08Lk0Af/9X5JaP7LI0wQXC7NsvPyRg/xfh2pGvEkTKjaOgX ua/6AD/m/KcKvLKYsCP5SwYn72KmlUQp8ylucfWgC9Yxq0MgdcYGQ2cMDUQk+0M9u33geH9AAec0 WE0nuOkhiMhjt7kXAX5fkOQSOv8Ak1ERcKXRHxt+8OmPc1lNJPQdj//W+QolfdL9olHPzbnPXHbN StchVAGCg6H+9X+/B/zfliO4Xyx5JDRyH96F+7xkc/Tmm+blmaNkdgPmXGNn+etBnJe8hhlkj2+W 2JSd3rtPXiq5Be6lLktMWJmbqQT1zQVze9ylxlQqAcM6jGeKrFpoZYHS1+0x+YFlTds2j1/CtKfY b2Z//9f5UNu0oLfIqrywzjFJcWxURbWQqwyNpGe/Wv8AoAP+btxXLdFa388STPM4dADtU8BRjgVb ilZ1RgvCnHPbn0oMy0iCOJ5nYEccH73J7VmXcCz7libBAznqc1Eoq2gFm0i8q2xMVWUNwMcsvr+n 602V7XflFUyhdrNjmog7MD//0Pk5IY9zTA4dznknAx6elRzGNkKyNhyeo6fSv9/001of825XglJX ZIhIR/lOOlWLiJ22NHtdlHyoBg596YEMZYuEniBKDDDG0g4rWFr5loXKmNEfJKDJI9+KDeOxl+ZF 50iRx4RemTnBxzT5I0nUGRcY4yOM0bDP/9H5EM0aRvEYwsIGAc9aW3dfs7iL90zfdkXkj3r/AKAD /m/2EkLzAF3LiNdu5uCarSsoGz5g7cD2rB7sd2SJDvi8o7QW+9nvSwoROscjb44Y9oGOFGf/AK/6 0hF2cwkOtuSg6c9azXiWNQeSV6c5JNAH/9L5H89TAqyk72O3aF4UepNUhGYZcxnKH8Sa/wB+D/nC gveJpEuNysjKIwCXG35j9DVd1kKMYyCx4PtQaWd7lW3gDyKmoMQqjcu4Zb2xTzE8WWtyHG/KBu3P FAydWu4ly3GTk46Ypkt64VIFRFiz8wZOnB6elAH/0/jlZd0DIvRWwdvY/wCRTRK8cXlCPLbsknkk e9f78H/OODus6kbBE64wVGB71ULeU4Dnr39KAJ7iWQmMBDGoGNxHUUE+RG7BgxcYAPNADIJWnUrI pQqcAnjOKuw20Zm+0MSAiFHBb5W59KAP/9T49Z/MlMMFvvCjcAFzxWbPJ88UUnmJH5oDBOq8gV/v wf8AOOX7jEGYIWd4H+ZGkUAge4FVE8po5G3ASqduMY/Gg0pohWQIy/acEHjavGauNesWVVj9t3oK 0i1ojQqX1xL5fkpEJjLlQjj5ATwN3tk5/CvxN/amg1OXxpq8HmW4NncyREbhL9pIkAfaR0AxgHvi vyXxyV/DnHf4X+TP6Z+ixFPxIo+n/t0T/9X+KK6AiLO+3eSeg5NUomklCAKhySER/wCIjrxX6LXf vs+ZgtSwwFyrhAQU+VsdAfQVUuLA25jnuSGjdeMMC4AJ4x+FcktzplF3shkSGS5xbgsn8C4xt45q xLB5RUMS2fvk8gH0rme7NRzGCYR24UGRvlwDjP1/nU09ottb/NOiFG+5G2ZMdsY4rBxaA//W/iPd XYSbHJ8v5ix4yPeoopnjUtlQD8u4jpX1B5DVhDIwfBO9CMg9gfSrMtrNIkV0qxskilRtIxwcc+9A iGFmiLK+CuPnXuKjY5KOjHcud2BjFJpPRl39yxaijfaAXEaOcn5easSWySRht4eSNgBjqV9TUOHY 1P/X/iksw9lcC+j2Frdg8SMu6MEDqazNQv8AUb25E88yuDkfcwy5Of619C1bQ88kjkJRlmAWMY2l Rg5qJzIZHii3hY1D72GEf2B9f8+lZzTewDYdQkSQjy3gKHaD/ePrWi0NzKpklQ+Wq7xIVxG3vWQF aRxFt8w4UjcuOd1SiIvFOPOW2TZkAj5ZD6UAf//Q/iLhuDA2Mb06KSMH04p7TojDz+GdtyoR0GfX tXsHnmqEIAuAAyqmUbGcGs24mubqRWmYeYzbE4xgdgB2oA1Ut2lRoppQojjJVyMA4HT8axJ0U3CR Rq28Y2443H2oAbHNLJcqrjYy/K3bGK6+e50mHTI4ZW3XgHmG5zlVGPuYHf3oA//R/iMt7gS3UYaL YkhPls5xuPaq2oyzSzkkBSjAPsAwcccV63MkeeOw6OEJLI45XHzKcVo2YjWPy3ACP92N+S5rEBFt kWYyKgQj7oXoavQWE+oMIyEYb+A/IP4fhQBJLbpZu8YARs7WBPQjj8KqMFmSQtAsW19qur5D0Af/ 0v4ixGySxxfOQW/eOOn+eKuTJAsLKYyoxjfnqfavQPPt0MhU2BQDuwcZ7D0raheeNYprfY0kZwwZ dyNxgimrWZm4aaFzcSI8IFDNuIK457/59qZf2UmBKZIjEUHyBxuB+nWkCh3KixxFZFlbY4j+UMOG qG2F0m5IC6w7D0HPv+FApQtqj//T/iVjJLMrknyxyD3pklissX7rGckuh44r0DyI7oSGBX/0MIF2 ncjA+g5pUt47XJ3ZIb5VPc+tBuaDTBViCohk2FlYDLKT/Kp7ZmnjiVl34bc2/gAj2pNJ6MLdCnde bHN0jki6ZHVea7vwP4B1Xx5qsVjD4h0Pw9pkcZk1G41y6+yJJGCuUibu3JPphT3xS0hFtEtKPvI/ /9T+OX4g+CbrwDqr6S9/pOtWLQLd6df6TKJLaWN9wAJycOChBH0PQivFriWWSZCRjbJhwvUD2Ndt OTnBTas30POjflV1Y3IHV3KlSVXCLxwfeo7i3t47nEsjR5TMJj5DHtk9qmXxajJJLlUKRHBBHX3q xFJE/wAqyf8AAQM49q1Ki0k7j5PmTYinarbmycZAqo08Ma702RsrHzCOPpgUBfVs/9X+I+2El/Iz t8kZ4LHhfrirIb5WiWXcifdfHygCu9q6seeU7vaEHlMsuOZCOQD7Uy1ka4XCysjp99gOQOw/SsWm twL0MEi7t7h3YZRSMMB/9eqokmi8xGleEE/c243c9DSFdbCzJEyqZH4bpt6k/wCRTfsdxE4eMNKn Rol44oGf/9b+Jm4tJrURGQI8Uke913bZIc9P8ce9VltEaeKZvnAXgdM+ldB5D1dxy3pVmRwitC2X A9O1WWu4pUjdicKxA2nCn604q7saw+FEqB5YnYBW2n5B0od5beB0mtwr4zHjqc962SsrMzkrOxjG 7aWN4lIDrzsHDE9qtSXLeTHNJHKxI2lyvfHSmSf/1/4fHlkmhV4l8rc5WZQOozz/AJ960NOu/s84 Plo8SnA8wYDmvQPPStobKXz7JUnQ+VuPzBsgVmfaI7iWQIheOJcDHO6gCNpkbBiQeZjCqg5bHrVm JvNDRXMYWIqNpX196zjd9BpX0QrWiWqjb8yTHggZx7Gkt3WVPKdQJFJHlbeMDv8AkK0Bxa3P/9D+ J5IYvsxW3U7VJYogOT/jWXLPLbTLIjNGyEEbTtYY9a7nJI8xwVxGuGmDyrIAWfMrYw5Y+1TC0mm3 NJ8uFBjdhyfrSU0UlZWHweRplzbzhIS8TiQrNGJonII+8pyCParkl098TPOY/wB9KTGqoIlByeAo 4puSQxtvqMloshnkZokfy9gH3BUF5eC+ZUg/1R6Fhtzmsm7sD//R/iVR3tZUjYIY4kySep+lKfOv FScwuI/OKM7AgJjov410Hnl2a3hVfKkeNeNyKjAjPvVK0mkQCCNIpRvO6Qts47UmrqxMvhZZkvoI yYyMsP7tUVlM3nSqN5T5Sc4IH92mYj7G98tma3CI6nEjEfORS3ur3VzcopkIVAI3G0EuKDo8j//S /iBeIXUjCMDduxg9SalhspC7lmDuFxGrnjiug8mTuIblIs2shZpt4I4wijvmp3u2hdjHKC0GGDRH dtPsaBw3Lcl3dajdiQxDc0I85xkFgBjLeh/xrNn8y2nXY2EQEMqnk/Wg1OmsfHeo6XboLa3tGeGI xR/a4VuI+e+0jrWTP4v1LUrtTqMcJRkADRRCNF78KBjHWjzHfSx//9P+KK8vbJ7XatpEsjgIhiJy 5HVj/hWM9zGImQxB2BCq2f8AVDnt+VdBz6JDdPMkjSvIWIgbhcYznp/KtVr3zHVJwsW04XHykj3q 4LRkOatoRPJE5mRkDf8APFxyVNYTia1mWVgzZbaUHUg+gpcoRnfRlgwrKryRxFbgEblbILD6VVl8 yH5uVkxtBHUUSVnYmUr6I//U/iQspoUtUM5AcNvYhfnaqV4yzyNLbLIgA4Mv3vwxXQeeQwTzLcLs CPNsKIGHcjHFaMDi2QIQEmYHJI3HNADbiSP7PJbyRNLM7bvM+6oHpj8qyURYELS/KWOIkHO33JqJ Q6oCmZpS+Bl2ydrHnFakMCvAbhuJYMFcnlzkcURhbVgf/9X+IrzvNVvMDIUTPy9eKgbymdZsOjMo V0YbQ3pkVU/iPPWhOsMshkMw2J5gkTB+6AMcH04zUXlzhfl2OwkPkyI2Qw9PrUm6d0TwW7wGTz40 aXAZNrZJ4rLvLHzZCY2LSt87Ln7tDdtxj4LecF4I34AG7A2nJ7CtCBnsZlheGPMh8phMM45AzXOb Qasf/9b+KC8s4omiWNYW2/vJI0+7IT2J7VmQW+0kKxjfflUb7rA9qmHwoCS4+0IrlSU8thyPlz7Z qz9nle2jn85HjnbyzGZR5gI55TOfxqJ7gVL0lVWVY44GtVERMYCmT0yO9U0unkZHEQBX5yCuA571 BnPc6dtS059NRbvTlS4uAVle3uPlCLwAFxwx6k57/jXPvFbwW01xbFeCPKhf7x57fSrTcVZmZ//X /iChvLaa2b/SXE0j+SFjOFfsQfT/AOvUS2kdvL1zheN43BvTP0rHmdrHLzLUv2/2iaMxeQJvMJRX HCxEd6bLaQhQmWS4i4R9vDmrhtYybux0bxoDDNkyjlnVc5HtQ9xBDbILV2kuJp2VYDGchVA+Yn39 vSrEDwTT+RJMwigEZYluCSOo/Sq3nQw5AcuV+dQ3I9qDoXkf/9D+HCa5ubj54z5SJLlnT+LH8PP8 qtsCVMiSMUMYfGOBjqMeooD1LcQluVSaSfCbfLXe3zccZPoBUhjhgbEU6TbhiQocgevNAE0cUb5+ UuX+UZ6Ctuz8KtcxLL54trdyeX5ZSB1x6HpQNJvY4yUXaStEJQqxsV92wev6VOkcl5E6KQF6FTxk 0A01uf/R/h18gwxKsa+V5chUtjLP64pyuPMj8lgG3hSuOWrGStJgacbSw3RSQs0ZALqx3Ko6cCn6 vbSNIjAoy7Q8Yj6YIBqQIQJoI44XvVjivYMyIoDSAA/dYDnqKjs5Hsru1ulSKWOGTLQzIdjgZ4Iz 3oA6K4nivGdraCK2gKj5EByG7nk5/wD1VnW4SMiYLA8wbDpKSEkx0H5UGc4q10f/0v4nL6GW6bzp DFBAAN0cSbFHbAHSn2bpEsltET9kdMzbjgNjnpWF2jhcWtSt5huJQbUjyduIxtwy4qZBdF4kuohG rOBuVsszZ4yKF8SQVV+5fofo9+yj9qbSL2RbmICOdLOdLeJQ0pAO0E9VJEeWx1r+hD/gmvoVjrPx v037OTJqNmgnnMszrFYmBUcKyH5cN5wPHU1/avBd8N4Q4qov+fcvyZ/GVdLGeNeHh/09ivxX/Dn9 r2kWYsPBELyoiyLo7Bg0gWKIJDjj0yBx9a/jf/4Kd+MSvxxSNYrW5sJlu7WyaO55tnjZF82Re+/M ihf9n6V+Z/RtpupxdUqPaz/U/c/pMVvY8J06a6yS+Wh//9P8Bv2p9XksPBN0sNp/aWsRiS8jsk4V ogVypH/AWI+nvX40eLvEU3iLUo737HFpt08SW88VupUfuwFBbPc85+tf119Jis/rOFpW0118/wCm j+bfo9QUcgqS8/6/UqwyLGm3nA4APR/xreWzWTa0qgAJweu32r+RKruf0XHdGvY3623lQ7kEW7Ds TjipLq+eUefGiqgYg7lwSOxUV583o2bktpdzMGDlvNC5iJbZtPqa6C1M08ZV5PM3HGT29a5Z7WBa H//U/jPTRkuH2iUuxGCpG1QPz4oudBjsobcxm4RUlKSY/eq649e3OetfNtpSdzdNMl+2RxQqiq4R Rt3Ny1T6fM/2K9c+RG0qBIjNFvm5Oc+3Qd6tO6uiJ9B6yskccVvHmd2G6Zk3ALn5uOvPatiOxsXj VhdsHQM/lq/KsM8MP6UzMo6dPHeiSS3k8wJlJCoyo6g5rT8Par4atdUuLfXbyaFIYHlQ26gyO44C 88etYS3dgP/V/j+kETait3YvOftUqotzkB1B5Ac9l/xrtLS0kmluI54o7WfzEkhuIQNzMp53dsH/ ADivlwO5tYxHccuCYnBUxH5GOP1Br9oP+CP/AIIt7349prV95V3e39qiaJY2r+bLp0ked7Mp4G7C EY9K+J44qSpcP4nk3at95qnywuf30fDC2ij8M6VFbTzyW0drErGePym3iNd+R16k/nXqK5WXOMp0 GO/vX5ZlEeXBU15I6lqiWQqpDqeTxjvUDAH5uSTwa9Wl8RUVd2P/1v3T+IVk1xoGoMtzI9w8TRW9 q0WYt8qlBuOeBnjp361/Dj/wUB8J6jpPxp8S2en2Nv8AYLe9kTXrqFwiQyMCsTqvfGQM/wC0K/mz hSfJnFNd/wCvzseU5clSVN9WvwPy/wDHVleyQwldcUDSwkNraxQrCbjzCd5dgM84A/H6VnXmmx/Y YElsbSFGjEkJYky7sA7gM9Djp+nev2xyvozaS95nL3GoqgezCIGAxw2A2AQCRWTplzcaY8U+oASL nc622W8w54AyM1rF3RLWqOu1yC+dkNifKt54Fu1kuQyb2IBKIOhxkjJP86oW1ndXsNtbwxwQXKTl psklr7dwFY89OMY9aoZ//9f+M7xHoes6Uti84tzK0gS9sIrglIoR0IXsenbNJoEy6ebyW7ffBPGF iWNjmIjPX88YrxIbHnkFwbm8sLizt5Y7J7i6Dxsz/wCkKA2fkPYn/Cpp9S1W0fdDdzGSygE9tZTS KnnMo5XeRxu557VYFq51CbV9P029h06PSbpWdr+2gmMpkOOnoeufesOWNp3WCWCdSH8yF5YmjkbI 9Pbmg0gk1qXYLTVEScWRR4BDvkSTIXIOAT6cnr71H9iOnTrfSRG8a9dPtUanzIIkA5yB2/Xmtaex DVnY/9D+PK7s7kQSsiPbQGIStDAhCsv3lAHftiqemyLE0izRSxiRA7SmM7oh2JH4/nWdPqeeadne Ri7ii/fztuBZ3hJwrZC4AFZHjTTELpO+oLKV+ddPtmV0jbszMO+OMZ/CuqmrNBJ2g0eMXsKahLJA B5bDoG6kiux+EOpRaD4+0yKe3e5+0qbBAkojQO7KR+PGfwxX2XDlZUM8wlR9Jxf3NHgZ2vaZRiIL rCS/Cx/Q58F01DSvDtu2pzWyXlhejT3tpG8xoRPBFJBgr1xkAnPYjvX9sP8AwS01w3Pwv0myuJWv dQXRYozeMPLysIACKPXAB/Cv6y8e6cqnAOGl2tf5H4B9GOvCPHOZUeru18z/0f68/wBsCwa6+Fvi SNLETJNpEskktzxBb4Xkg/3jjA781/EN420mK08R+MbO+S4t7fR/Et1HFZs+61tpCiTIUHUIDINo PTNf199Fqt/tONouWnKnb0aX6/ifyL9LnDfvcJieWzTtf73/AF6Hl9nYWq3Goah5ckck7RFfPnAN 6CuS4Gc4AHTFasf2K3UXCxiVmuQYLabIQLnnPfsPzr+14WsfwpWbUbIyPFFvHfCG9NklluuklVLQ bY1MeCo3DtwM565qt/aN9aaXOLeMYkuUe6dsiWVD8pRfrk1vC3zOWV7skttLS+hnini+zqzi5jEn E5Q42jt+nrTLjR7u8aKxsmEiW6vcXJYCJ4SCoVS3UjAPXvmuiMklYn1P/9L4KntprDUba1nKxC4U +ZdEhtirgkAY681dNpc3um+bBfQT20d2EKvIDcKGON6r1KjGPQHiv9qFrsf4nJpuxtQuNP0V0EN/ IwvD5UkZDDLAbgFPUcZxnj0rEuEvbdGuG2bE+eaRSAcH+9zxjigY+W7N9FLqraJs09UjgSe3z5Mr IqjerDjcSM4PXNN0NQ2oC98x2+zAzSwtLgzLjGP8+lXGXKrAbFxqKzLdyJaFLgri3uQwMJPTbIvU gfWpm0W1vbKe5niikkLobQhgwhIHz/LxxngDt61cXcwqdT//0/h7X7K1it9Ou7G4gjacEzLCQZId mARtzxnnmq9ndW9xEkMdyS8sex1njBErHI289K/2xTs7n+HzVyyLTUbNzE8kK/IBCkX+sQdceg/D 3qtHPcRWM05LR26TATSo/lTRkngMeq52kZrda7HLU00KDRpPI15PfyJfXdyHke4YziRQBwD2Oc5J zndmtSxXS7iee1u7mKZ4F32tifl888DcR3wMn8KDjbuxzSwukkBSRLWJ9nlRdWxxxnjtx7U59NZk gaWKSOCJg9q8h3FSnIz7jinG1/eEf//U+MtRk0290sae91FHDLGJXuZCUgcxneoLdASRgD3rKtLO 6lSSCyV7q4lUZEcXnmJFIJYADj3b0r/cC1j/AAim9bGrqMFrPLCk3ki/SFD51upE52DO1j7HOfoa 1rWS1urdsSBDGN0kn3S2D696uHxEHO6ncmC4VlPl23mCMMGCSy5Az7jPIq1HYyT3NzHZOBsYyRur 4VR2+bvWpE1pczZLXUWjl+0yyyLb/KsjOWIAPTd/nrUFnNPBIwYuVkTapLfInPp0oSvoYS+Fn//V +Oor5oYmSfUPMSf5ZIwCiLjGAeg/Ks+fT7WfUlvtgEzxhf3Z2LkDGQOnb0r/AHPUUtj/AAPOjY6f pa7TeC4VgBJuIIRj246d6qX8skk0Uk22NFjUwSwoFcdApGOvT9KHFMmV7aGTEJINRb7RHFeWgQGE sCkmWHOSOfStW0lSGGWEbWjhYllbINuGxyfbmkopGDdhYp4ppHW4mmjs2Hlhrc4PPrx0qK7SBJlV j5SLtEd1H8xdRxhwB/jVGcpX0R//1vkGTSblylzDuktCf3NxCC4LAZZcdmHXBrFug63Fq8E8sKxX G9QrbGnx/Cw6EcZxX+6B/wA/5sy3NtfxzrHNPG23E0Zb7pHf8+1UbGGFIbp7l44D5JFvcPlhIcj5 SvbvgmtoqysYPdl7TbMvdANO8UXDhyMl8YOBn2rSurW/uri8gF5JNZ3CYuAJfKlZBjKqPX6VREtI sy3Km2jtxYQw/ZcwW8gfZNszwH/xqeWdbNEsJ4La5tHZXE0F00jOy8mLGMDGMk85oMT/1/jsSSi4 E0SokcyND5R4TlcevbINNsrm6YtEkIidMk7DtPHGRX+70PhR/wA970Rbg+0SCZliDtEpYxyKGjc9 j9RjIqOC7Cus0cAmWNAJWaPiM5wTx78ZqjnNZdOsrhhdRNuYKZmgK4bjqR+dSXNzatbW22OZL0Mw uLUorW+w42kt13D8uTQBE8NncaZPFGDDcRAYIJJmBP6EVVtNMvJLR7aJoJhcjG1iS0bA8E8cH6et dAH/0PjW00WNriOS4uSiQk72QZQjuMd6qTwv5ha3Dxq+VR8YIHvX+9B/zxSd2S21ldzXFvbRRm6l j+VAOS5PUj8v0qzcxPa3jItmkLFhv2c8gAZJzz096DNtLctf2ZMwErSImwnfIR8rei5GealiB+xX Efkxi4iG6OeRiI27AbaCXNLYZEJp4yi2++RB8xQdunSqLTFlENziBFmP71eSR06fnVRV5Gbk3uf/ 0fkKGK7t/MjN0lxZOd8SrEVxkDn8hSBTGcxoPV2P8P8Aniv98D/nXJDdQSW8ltPaWlz8/mCZ4s3M GMfdbt0/nVVZlOTb5AjGOeMmgTdlcqrO80yCUttZyAOgJFdBbyWUM+XO/byEPIBHrQYt3dzMvN9z K8yybcMS+PlLA5GMVdVbXyk+zQvjYold33ksOpHoD1/CgR//0vkNrjyjtHDE5yOCKuYC200shkLM mY0Az5h46/hmv98D/nPKclk81okohdYSNrkj7p70JayeWqJysEeVXPCgHt7c/rQBCllNNKzyKjvy ypCpwoHr+VSSKGi3McBSPbBHSgDOnuXnhaBRFC8UqMGZSZJV3DcFPTkZ61uNaw3MqfZLVUdVCSSK uIFLe/YcfpQB/9P5NMVxYRvHcxo2/IJwCY27c4zUCfvIX3hZD3yPmjx3Ff74H/OeMLo0czWckimP 5ZEclvPU4GABwCOe/IPtTFgvLcZj8sFkJi8ziNuD1/WgDUvb6AxRJZ2uGFuiXcsjZDyYyxQduRj6 VRiuEYLHK2GX76dMelUk0wHgQhsAnB5x3NPubm2FvFCA8sYJJIOHRsHv6d8f/rrZamMviZ//1Pjy 0leVSCkYcE5EWTgdhzVXZGXZYwI2HA96/wB+D/nHLXmvDH5YfDYwcfjTrdiJAOQWPzEcg0Gigmrl m5mtLWZPJU7WX94COc9z7fSoZ7iSQDy/khBwo27QfWtKfUhqzsU2MsIyZAVccjOSKtWt9HGWMkrx XduFnt0KfK4z1544xSnuI//V+N7i+vFnjnlJmeaXfgfJkE8nj8akke4+dhgBuU74+lf7+KNpI/5x ynEJWu4EwWMr7QozljzgCrtwrmQuoyANrAdFq5OyE9mXlnea2MMELqYIcs5O4McnAHp2rNms5ogs 5idJAQXQjDYPrQtUYBdwTTBBE6jADDsuR61pCJjHGGYHaBu2D5Se9JP3bsD/1vj2RXW42gfIeuRV ma3QRhgMMWB+Xg5Hf9K/38p2+Z/zfjmaVNi5O4jgU4yXKo4ViFI3FQetWlbRAQ2l2Y8lSWJUr97B OQRxVS4McoitXm3bUJb5cygjpn/Peom7aAECBUjGySPcMoWBBYZxn9D+VX9mzhbgQsVOd+dkpx06 VCbTuB//1/kKQXGfLXAZhyeuPeoGja38iaQMHyI92CN5J/TtX+/nP3P+b81wkGwFcqyjcQT94+v+ fSq8KwvOd8bbX4kZeHOKpSuAskLh3VX3xKcRLt2kD0P61IY3tpEcQ+VIyh8Y3IemDz607oDPujcT SFwMEDBbpge3+e1TBkgtY0aQylpC8hZRmPoBz6UwP//Q+Qrlba6iMHnkOpDblJA+hHocVGbdY8GM 7yBzzkZr/oAP+b8M3AxIE2hBhs9DVma7S4hiAiRDGCfMXkvn+99OaAIw06REggA9Dngio7dJXjJl C+YzEZTPI7fypNpbgT6Y9ta3LxNGbdpJNiyiPzC5PYgdPfOK0JQ8QkkchhIdshUdecgVlKVwP//R +PXmgldLZ1wH+VMDk+2K0JIbIJFApb7nzZGAD/hX+/B/zfjUiWBCEZTg/wCrHXFM3B5GZIljJHIU YHFBLWpTZpDIFjRyQd2SCavoeSdmx256Y5oIbtO4QyiFvLljUmRsiUD5l/GpvMWBjlxsY4DnotBT krWR/9L5RjULJcI83mKXO1gcoR049uM1UZGtXYJKXjDHYW5AFf79Q+I/5vfsE0KPM2OQPvHvwKkZ jCgVBkE4YAfe5rYxImMkqEurbVPyLzj/AD/hSqoXBbg5BOD6dKACaf8Ae72B2t0A6Y9KYVypkAI5 5JHQe9LlQH//0/lEvCoCowcr/HjANOUwO4DIJDt5HTmv9/0ktEf825QdJoHcouVBz04+lPglmcmQ 4Uk5wOAv0pgaIVgm9lBck4Y/xGqkk13swCEbcRgYIwD/AJ60r62NofCMtdNke3IW4SARguZJcuGx 29aTbNtAc+Yg6be3rUT6FH//1Pj944YpQ8sbXEDAg25OCDjuafD5ipmONQgO0xH7w+gr/f2Ts0f8 34xWVGBaNshskEkLU5C3pZo4/LSMAMeynp+tZvcBY0CSKsmW2jgjjNUpQz3O9Qw2gjaDw3+cUgGA ygsWBVDwCR0NPfzAdrAlAOGoA//V+QIliZWd3wM4+bv7UgfL4VflBwrN0r/fg/5wYuzFaRgkig52 5JOPSq9jPG/Rwd7YBU5HGaDRST0J9UljlMSkHzIl2qRxkVnRrdIrO8TqhbEbfwvj0oKNMShoNuCs gXncORWddQSXCoEcROh3E7cbh3zQB//W+M4LdgsioPnUbzjo2O9LaRT3MzxtIsZClsYwXIz8oHv0 r/fg/wCccm2qoO1cknAycVAFgc+Y/wA2P4AfSgaTeiI7qVFU+Qsuw9I2bzCnA4B/z1qxp0qLGRPE HyMDfnK+457UBZorXhkkkVLVgixvuJxke4NTyzhISXOAfvdh9aBH/9f4wtpVEy5ZgpGQ3arV5JbI Ym8qUtIfkYrhSB1Pv07V/vwf844rA3KhVB24wD3WqP2RvmU8qjZOe+O9BrT2JJFB2YAO08HHB9qb PcP5pVlwkagJ8oU8etNOzuWUdRnmSzkukEXETBo5DjAIPOAeo4I/rX4sftcynS/FF5eQxb44rt4p cJtaQymP519uV4Pevyfxxf8AxrnG/wCF/wDpLP6d+iur+I9L0/8Abon/0P4mLqYyybQp8th1A5BN V4ILhMSZz5eQoI6g5/xr9BrO0mj52nFKxPH58Y3oUjDMeA350NsmWSOVn81Rlc8rn2rmOoh066a2 Z0wEbdgSuOG+lXLy7W6uDGwjhYgBVi+65xWD3Gk3sZdxDJHzkrMjbVAGGGPWlj81P3kr+dvXkMSW T6VnJpppCP/R/idjWNo2UsfnX7ij9DWWbfdJgq0cY4CEdcd6+oPHGeanmKiIWKHG4cgVoxRKYpTG yoI8sybunvigDP2M4Y9M9CRgmrSRwrGiiQb3bawxzmgBqwyIsm5y+08Ienttp0LbCAAVk3biH4yP Q0G62P/S/icGoI0MgdShUlSgGM/Ss93LOi7D5pQOQRjA7V9LKN9TzySJDIkpdHZAcBRx8wq8iR+Z sOcLHkjrk1kBUudonV5Iy4RgcdMY9a6KXX7iS2msmtrV7aeJQBtAdNvAwO3T+dZzilqBihFeXLrh NuBkfd+lXYrLzV2NIpAbnLYUVmB//9P+Kz7NZNJLNKQuweVBGvzcjvjsKwNWtHlaJo1YhkIIA+5j ng++f0r2Dzy7Ya2yWSafLbrtjbCytFg8DnJ9acFEkiS/IwLcFT07cUATrNIzPECHijbayE4NY9xF PF8+GYBsxyf8tFx0H4UAS2zecQWYFn45GC3uama0gd3Z5QiqvMUn3SR6GldAf//U/iZeBJ1zGoIj /hHXNRfYPs+6SRs4+fHUqfSvRir6HnjliEwMsnyhDvHYtTxcwRRsskJEqnMcnUOppARutwwE8CKI XTG7dlsjrxS2t5NCSjOd3Q54K4qoq7sZ8zSRBNPK7sWUuG5355X601TLtADMF7ehNElZ6Fq92j// 1f4krW0k3s4kyNpbJPf0q1NAk0awlnUdXdh0NegeeVVjt4wYE+XgYZznOO/tV+ytmkRzEyPEncNg hunHr+FALXYnJELbJCDtGQc5XJrNuMTvujVCYerBuRntQBGL0RvGsgjLxsM7xkVenvESQurLmQfM i8D8KAP/1v4jZiZfMmVZBsHzbR8wqVXnSIIgbLqQpYfMD616kI9TzVFLYrRNNahJVKvIG+Y7uQT6 fnWnNH5sx8wGOBVXawGQ7HqfzomtblE48qLBUcJ1LHk1Df3gQRyQuVU/J5cfLN+FZgUzAYnkLEuJ EB2FsNg+lWkvZXSWKKWSCBk2NGspDHjB6etS5JAf/9f+Jq1mQwmGV5njT5YfNlaTy/8AdyTj6VYe ziiRZmWE4XeuXxu+tdnOeeUUkzkKq+a3JVTwPpTYbQT70nJWRBhTnpWYCvZQwOqb13Zw+9uW+lWX S1tdhWVYyfvLncwreOyAmJ80eYnmbduzYeBIDWG8AjnIkU7f4c85pgf/0P4jATGYtjZVXyyg4/Or kezeUCK6Mf3ijoQe1egeeB0yO2fygGUMnmIoOVAPIqCO2a3+dlEZMvCq27zAD39KycZXA3PKjeBm 6Mo3AjkqewrGvfs5YB5My7AZCnTP+RUtNaMiEbK5FArugWJFd0I8ppDhcHqa2LWZLWWSO4dnM6rH EAvJcnA59OTSLP/R/i5vtAvvKW7R2dXwjR9Qh9K5WSaXd9mEQjnjYjdkjIFdB5Uou+ggEcqusojM j8Erwxx3NSxWkR+ZnCRryR2NXT3NErKxYnfyEEcKhQY93mhhg+2KpQ6wJYkilibzoXJec5O9eABj 2wa1M5qzuaVvb28iJcCFS8jkIdvzEdz+dWmhVEkiBfY7DzF/gOOmPzpXV7EH/9L+Ir7GUnKbz5ec 4C5496vGx+2SSR2gGyCIOwkITHOCR68np1r0DzYu6GGzaNXVHZ4xw6tzk02C1ZGKxP8AZ+CGYdee MGgq/Q0TZizVVMaOckeZGmHYGq8m8PiEBsISYyDu47UFQdmRxymbELMyO4I2YyyY64qnDGUuox5r sdx2Zzzj/wDVQXPY/9P+J9p/KhcrIIWXJPHK++Kz5xbyrDLIUaVk2vsP+s5+8R2rtlG+x55btbS2 WfypNoVU8wg/dPoDSXt0i3CwgkqVGwdh2qFFt2ArRwJcNKXOdvAXP3fepbgNIlsVjSJbXo8f3uOh NU4JK6ApKrXiTpE53swaZJOA+DnipEhMUrJt2griPvtb1rMD/9T+JGG2kDO1ywK7srIWw2fpU73Z aNYBI7CFzti+6hz1NdB55E9uIkNyjjZIczK3OwVjJeRG7jVF2xh9r7fm+XuaCJ7GzJaLN88BGcAk ngkVQeKRM4JjZDt9vc4oMh4tvspklZ1YMgOUIOeMmo9gKrdRSq3z7OuHB60Gjja9j//V/iQsvKaR jFIvmDr32n3FW7qWKxkjdP3u8YyRx25x2roPHKV3Es26WTyxJjIWMZ644zUENm0Qcx8OwyVkGGT8 KBx0aNRgLeJmhuCEniCTH7pbGOPzFYgtny4QtkguwY9AKDchh09rh873KAZUsMIOxFaMNjFErecR lRhR6igD/9b+IyeCAxIYiweMkjsM+/tUVpYM48yRwjn5TjndjpXQcal7rTNKziktvMVmHmEclQdo XPT/AD6U2WC0MzvO+/B3J22HGD/X86uLUdzMGsshZYpcRgbjnvj3qjdzJcFUgKtKgyZF5B9qFO2n QCW3DhS4ALYxIGOGGPSs5Y3kml3g4R8sSd2fStPdbA//1/4i5IZpU3oUCoQMd2/z/SmW4ZFlV2Vn PKxtwVHtXS7X0PPKaxSqxmb5SG+91KVDDJLIxSTzDHESySnqPb+VIC8pF0Vjcm33Hb57qSgH4fyr LM4jmK5EpQlfmGVYdKAL0NnEG+0QuXRfvRMvTIxzUNxHM5KI4WOP51Tpu9v/ANdAH//Q/h/t2mJA cgLjDKRlm7UpMYZYWlaUrxGr9UGen4ZqpfEeeaskFysKRxyIFlTeVDA8e/p3rIhtpjIJXYeWhwiH 1z1qTWnsOk1QxytuRS+dpU9TjirVr59xNvSLyQV+V9ucfU1Mk2rIstzRTIkkUCBrssMuwwj/AJVF cqftMKuqs8PzDeM7GxjPvWJcNz//0f4l2SCeJjPdmOaNSREUJjkI6cisy5uZZGjG9cIuBt+89KKs rAaCXZvNsUnkgheRnGfeqiB97bowksT/AHV+6AOlKUbgR3IUlrq4kcqCN0UYJzz0KjpW1aQ2k3ls W3rcjy2V1wiMen9OTRGNlZmMviKV5p08F08MkwChdrJGQxQ91GP881QitGgjR9z7ImOwTDJHPOQa iTu9CHe2h//S/h2ltrNXjVIlhZf3mUOAxJJ3VeVGuUG2Qb1B3HvxXOcKi2WtOv2WYWyp5pHHAIVg OpFaGpXMDCJ7e2jh8lcOwcuZDnknPT8KNibW3MOSVp8SRgF8dFHNTWIlBaVjGMjaQceZ78dq2bdt Coxuxt3O7ozMSYj8ip0/ECqFmYyjGdCqiQDLDBYd+ao6YL3j/9P+Ja5stO3lLJyI2QP9nfkxEjk5 71Ra0dCsSFXUHLjPX2oAjvJYFggjEbxBmKMVX7gFMjtVjjALqyM+RIDwD2FAdbGjv+woLrKyLCCV iz8sh6AGtS88TXuqWdnHaxQWdwzlJUt1OFAGFVVPrUcyTsyoy5TkLmCZZlRXa5mK7pVRDmPrkH/P enxx3Knz4lVI1G1lc439iBVN2VzTmif/1P4g7whQs4SSVAAFiQbyCeuabLZvHHBOkRSQne6kcKO3 PqfSsG7u4FhElU+fcZVGX93g8/j+tWrt3FujROrLtIAH3lzSNIxTWphpPHcKHZDHNbKRJJtJYgdq lt5/s/2a5d4bqOSRnW3KMpQDgBug6nsTQQ1Z2L0wntvJlUsTP/ro+gVTyMCqfmvLNGp+RVc9v1oI l8LP/9X+KJDcXMHlytCFHCyONvmY6cUy5tygUgqAy4YAde1c5zNaD7aWKwhlnmtZd+VW0bG2DJPJ c9hjvWjC0V74hgW5S2tFgdJo1gut8bDaN53Z/qaqK95I56zth2fqx+zL4aOl6ZZXEGnCRlul8RXJ ntNlrcpEEbYwP+sXjafUEj6f0Z/8EstJbxH8Sr/WYLO3iXUdTVrny7byIoGjSMmMIo+Qc4xX9r5Z BYTwYrdL0/zP464cf1jxxp33VR/hf/I/rh8QXCWngVxFFue+0t2kilGEjKoAF/HAr+KX9vJ9Mv8A 41eLZb61vm0241t4Ts2IYIbds7YXOfL3MoAwDklvevg/ox078QV5Lt+p+x/Sbklw7RT/AJv0P//W /m2/at17Vby61i8tL37DeXkCaRblW2JGEQIsYH+2qnd64Nfk1qNjd6dM6XcpluFkO8s+8nnru755 r+ovpJYhyzrD0r6JN/fb/I/n7wEoxp8MOp1b/L/hy1p7rK6AKGAYNhu1dh5sjlbdPKEioZCjsI1K qM4ye+BjHftX8r1H0P3em9EDQRSyRRsqxAnMmDnHvXRW9nA0TnezlGCqCo2j/wCvXFN6WNucvWml IUnjc28t1JGTG0jbVQDkAYPJ9vrW1ft5MVkqpGmIhCJLdNqyMOoOO9ckviNFqf/X/jgtjb6fD9sm kiill+UB2wzt0AP1pJr6eWB7JAWVjvjKEHDHqSfT2r5hu7uNOzMdYbmO9NlccxKizrjkMWAOfyxW obW6mmkEaA2cUavcMo+decYrWHwmk9rFoQuJ2k3uoKqsRbtgYyP0/Krd6ZY1aws7WxaS6jCz3rbj dAtj7ijgnHGfelKTWhkWL2PTtB0fTrKygu5ZJPkl2xbXjd+rPg/dHJJ9+lc3Z6VasZvORWlcklJO UOff1rID/9D+QGzudKtJINOWXzpzCJXhSPAswDgZ9uODXb20s8gHk7ZScLv3YZR7V8q5JX8hO/Q6 7RY3tZyZXM8cxEQim27VJ/un1Nf0If8ABFrwvqeofEa91620aGCXw7eLawsJGFxcxuwWMFe7bn3c cgAZr4fjeS/sKtzMivzOk1E/uV8GxvHpNvb8rugilZGTYwcoocH8RXfKCmFYcAAY64r82y6PLhqa 8kerCN0inKzK+edo4xT0Y7SeB6D1rviuWVi4r3mf/9H96vGUUC6QWBTzlmjJMrlVPPKle4zgV/Fd /wAFP/C9mfjN4jPm6hpNzrupSQ3EVvITa3BTMnlY/wBiNnXPutfzTkC9nm8DycYuXEQkv62PyD13 wwRFPKs8fnxRi3hjcFvOCkleexHofzrirnTJBcS2smoLcsljHPIiS4mt9/yhB3J7/gfSv2iE27M2 buzCvodB08LLcz7Z0UJhoyXY5xjd7DB5rYH9k20LxiQXd69uksQTa8CK3OA3Y9PxBrdNrYCtLf3G oQRW7PKfs3KxNISkeOw56VVs5pI7pEuJmhMjF4n6CIdBg+2O9bgf/9L+NG41u1S4ur+61BbmS0QR ouTIwYnCsx+vr6VlW6XgtriKK5jGmXk4vLlngXzxMCQnlvjhOW4HtXhQetjzzWa3+wspuljmV4Rc W4ABlUc4J+uOBWbK4eTM0LCPO5twIdfrWl1sBow4gWGeAM0ZO/5yMDHp61qQ6/NeXMBmG9bAh0cw ja2442se+MD9KLpOxvFaFtry1Wa6iVVQ3KgTuoCNJjoDjqOnHtWZMy29rKyBiQemMkVcHZiklY// 0/4/rPVI10X/AEn7ZLJcbbaCc/vBERwegOMY+goVhJ5SWzP5jDy2AG6SXtjA61hTkeeQW3lnUYLS ec2rTzi3V5G8o5PGCT0xyfwrgPFsM9jqOo2yXRRraQiVY2W4+1DjDgjoMV2Ut1/XYiovcbPOgbcr PcuZY5gmYkfl5CP0Fb3gMzTeKvDU5FqTD4gt2KXT+SJACSQGz1OOAOpr6TKXy5jRl2kvzPKx6vga kX/Kz+iz4LzQ3fgiTUF0saFBLrEGs2093dC6ltz5S+WATwyEqMe0fqa/sK/4JJ+J5b/whptg/kSX C2Sx2065CScFiFHY8gEeoNf2d4xUVivDClVWlkn+Z/N30e5rDeLGPw991Jfc0j//1P7L/wBohVuv hZ4jt72FpFl01xEoQyRiVo3RSw9AeTX8P/xiudIX4hfEOWG1FvfDxL5N1YXJMgdWiiKTY6Ddu6eg HcV/Vn0WeZ5pjnfRR/Vf8A/ln6XbgqWCotauTf3J/wDBPDbzT7aW7TdcQtJbqIolRAkcIxwo+mao pAttdw2N5qFveM7BmaN2/cRN7AcMMngCv7kpzP4GrRstBPPRrmCFpp4NBVvsMSygebfSJ/rHYn7p 6Y/Ws8JI6XQ3SeUjsE2Lldq99w49K3hLqccodUS6eYbqaH7bI8yW+17eWC8KtIgX5VIHTBz8vIPF Z41RpNf1CG0hms4ZrkRwyyTEmcYGfmOM4ORiuhNNXMrH/9X4p1GAmxvprh0ubu3RUgDnanJGdmOp weT7VyehXMk1wYElW3COGEsy+ZG4ByyBffp6V/tBtsf4ncqO+htbCc+ZcXt7pjQqY1uJXVoFz1ZA B+efWucbw7EIrae0vri6CT4vZy3mwXa7ie/QkZH+TVKTQ0raGl/bVrM/kWDXNvp5lYXWmhVdHKna AueSBgEdK5ue5WS8mNhDMkKkh0CfO35dPwrSMrhsWlurgWaWlrF/o7StM8ki/vkJ6jJ579K09Fk8 qUWih/3mWHJYZ6nNWnyu5zTbabP/1viu+m0y1RLO7szLdtIzK8XMEajpz2zjpWTdafEJIZYYliju GB+QYIIxyf0r/a9O6uf4eydloOtbuDT1ur27kDxR27hC7lnibGFbHXGapxQQ6jCp81xp+osJZbhE 8zDLyoZDjrx+H5VpB62OKq2rnV3NtZRxXBWw2xWiD5FJYHgDcGJJ6n1rmtJs4pbhtTeC0gZZPs+W Ja4ZTkbgce3PPetTmI9Vljtp7gRyoVsLhZmkjciMkEFRnv2yK2dPn13UUmv54pDYD5EdYcRB+D9K AP/X+Lk1eJYoYI7W1YvJ5D2s0YaKZiSFwmetRw6hZpfNFYv5eoQjY62wKSQ+q/jiv9v07q5/hA92 QQNAdUaRwYzMRmTBVcAYYZ6ZOf1rbFm+fs9hGi2YXBkc4Tn09xnPNNabCKK6TLPM1rOEmltZCF3A AMVOM96fBdNpF9KXYbAvlvBt4Zv/ANdaxnfRkz+EvnW7XUHktpraOCNkCt5R7gdcepIrDv7B4HjQ yjy5FV1K8HYw4J96s55L3Wf/0PiSSKU2v2RIUnkgkV4Q4CyygkEHPU461rWbJb+ZFOwe/nw6QEZ8 le5x+X51/uZGbvZn+B5gz2dzLe3I+SGHJaN2fcp69RWl5twiabaXU0k8kWDK5wAVz/B7VTkkJtLc 3dPtGlhlkuGU3AlKWwbkOv8ADn0P0rPjtY4bq5sbqdN8x2RzK2QjDJ2sfwx+FNSTMBj2lxbRm23m NS+S/OxvxpjNHMPssh+YFSr5wQo6jHvxTM5vof/R+NLuIRlU0ye5gAcTTqjHy2YALk/himXSx24R J1DTArJHIBnBxnGP89K/3Rjuj/n+exYW/eUu8qRN9p/dySGAIy5IBbgAkjH41lWq3Mt7Mk6BbNJg IlP+sZRjcfxOcVuYHVS6jpsPneUkwMShYZnjA2N2yM4wKZf3ZsJbBLktNJLGzi5giKQMSM43diPT 2oMpvWxmiSW9Zo5SvmnLqwXDz4x8vp0B/wDr8Vl3l89nEsNjDE0Zn3ETDdImchtrevTPbiqjFPcz bsrn/9L4ph814xJJu5OQp+6p+n+elW7dXW7juEDvBGuJl7EnjrX+76VlZH/PS5N6Fq41CUxyQ2yB ZZXCIc4ABODxVu7jFnGIGjSJ2hAk8iXfGDxkH8RmmQmmZnnG2IuVnJkZDAkfIzkHgfgP0qOO7nKk spDsQqjGSaBmlEbqGLdPG0QuCRFu+XzAO4qGW9uJFaGOTy4CQtwEGDJjpg9q6CJOzR//0/j6CM4d AzxxMSFDtvJ98/nVlIbV4n8y4SIo4Xa52mQHOSrYwMehxmv96D/nfKdgZre6kaKXzIhG8ELE4ZA2 Ruz3OOlRy3sKPLEA7TRELyckHg5oJkrokivr3UGs9MiSJGlusvPIxjUDoAR378/SnGZjMluY3KSA hpAMIhGOG57/ANKDNxaVxZJWS6XymdExsk527v73NWRb2+oRPHOz77WLNuVADykNuy359vamnZkn /9T5L+0TW0MtvPIjm8m+0qBg+VgFVA/ujGeKz8usbYdSTw3sK/3wWquf861tblN54LNRCZo1Z/nw OGGfWrMaWzKSJPNVh8ssR+RDnknjnoeBQTO9i3b3sNtbOg+zXAuTsAMW6a32/wAQbHGc9j2qrp/2 W41CaFJhGrQGfzpELLJjgAYz3wKDIRTuEwUqhHIL8K2KWKb5lbzo0U4XAOF+tAH/1fky3sNPnkuf t2o/ZHgQzCfBktkUd3KgkDOOgPWo55w4CRyLNDGMJLGCEkA6MM4OD7+tf74H/OeakExfTGD+VCqE qxDHzWyeMj9OK5aaWS2lypkl8392iA7VB9z07UBaxJHcXEcm45TjDbTnFWd0DmC3u5GjtbidVaRV LY5xnjmgCGa3ZJ41kwgT50V+SR1XnuKnurhoisEUzj5g0oiOI5MdOnXFAH//1vkCS437GZ2LDl0P zFz605FbyZAXDLI/mK6KUaMYHyn6HNf74H/OeVIbkQrJhVEccyxy3DHATdnaCPwNbHmoxhLDfHjP J47f5/CtVFaMCG9SCa5AsSY49ql1ySAcc1g3skpuA8aS3khkW3mWI7ZFA4yc+n51YF95zGnB2N5e w84OMY6+9U7eWQvsODGzZ9+KDGXxM//X+OLWKb7bvhLQQ4K3BVQcoeDT548NvRd+1uWIwa/34P8A nHKwVGEsu4+YhG1CMhv1qWO6RxJEpxMg5O04BIzQBMhiBjW8lG9gfn2ffYDNU7iQeYFBYBeg7U0+ XYC1c2kxFvK8Yj3oGjBPzOPX8aUztu8u4VJIxH5XI+YChtvcD//Q+K0WKSR2ViHU8JuJAHsK1C4k ijRiE29s8jvX+/UW7o/5xy1bCB5CYmUm1wzbhyKiWGSaUxRSiMM3mMMZwoOTn8M1c1pYT2ZdhuLB mlghmLRpLiWVUwj7e/r+FZVxOZxJ5MhUqCAG744pRUkzAZEx8td2SenuatmSWAhDjLpkjrTjF2aY H//R+Op5xjbuzIOozyKsrFPGYJRKh24k24Eq98BgePwr/f2MXFn/ADfliad1ImYDeDlhjikecOpn VCA3y7RyBVgVCrRyLIAERRyqjOfpVjbA0bShTu6/KMsPwqJxb1QD1E9xCGRS5XEce4bdnOKgijgk SZLi5LyxTbShXacdcg+nasgP/9L5NtowzqIjtDdHYnj05pyxp5GbiYSsJWYr0CEGv9+Umz/m/KxK uxdSSBxx7U+4MpgglRljkj+Vwqhd69s+9WoaASW87yIw27ivf1xTXnuGn3sRsCBfpgYoimnqBGX3 uqKFUdXkY4XtUqxx/ddQcd15WtAP/9P5QazsHGNwhbbl37uRnA/pVR444QdkowiliGP38dhX/QAf 835YsbxJrUwyRssnmF8se2MAY/X8agnUACGKAhmOCvB3ehA/GgCKTMa+SQcgY29/yqnLLMnAVip+ X5eo7VjLVhdXsXbdLmFN4VdpcAtJw69en+e1W7sSMqck+ZyfQVIH/9T5OsWS3dmaFTIq481owxAP 1qFpovNbcu5n+6Bx+Vf78H/N+VleCPIPmGVjlnL5XHpj/wCvVmJotnmA5y2COuaAJt8TPgHY3UY6 iprsNJA85cEwxgyMqhe4Az9TQS4pu5jQ3JkhljdkEmR5RwS9Xj5KxJG0g85yAsZH3uOfyx0p2CUe Y//V+RWkiibbLuXCnDDkH2p8cscqgOPl6KcY3V/v5CLTuf8AN8lpYjge4hJLKyQ79isRw3sPzrQm lLpCsUfzISXY9fy/CtLCcVbYp7ZZGn+0XbxbW3wBFBD8D5W+pB5qNWYModsnuOpoMuV3sWjEZRuU DjgAjOKdFukE0ZwERMkD72fp+VTGV9BqLvY//9b5Ogg2xt5hRN4ynIz1x9RVRCkDSbnJx8oPoa/6 AD/m4as7EvmFkK5JD85PbH+RQ2Ixjox6HoKBqLZNGuApaQgkY68VE5aBZHlJYnhAp+79f1oNYrlV ikb25RSArSQtjKouWFWkM28xW8coYxksvIOMc8VE1pcZ/9f4+JEylmOwj+FutWbKYJcRkMFfd8mc dRz3r/flprRn/N+WrnEe7zQpVjncMDms+ZEhhWSGQMJjyAc9KQEa3Uqwk7RIVcLwMMMkdat7ZgUl a3dVddwJXAI9aAK7ziQKqjem/J9Fz/8AqoluNqhYlBPSQEbsD29KAP/Q+QoAD8m5MMpY7uoI7fji kXaWKtkY79q/33TT2P8Am/Ftds090trcx2zWcQdnuYGkinzxtHUZ571VA8uRQNmc8lFwp9wKY07M tNGj4EjKrdAzcZ9qInkVW3ox8pwseR8pHr7UG5CUZtzngk8KP6USExorMpJb5dvQmgD/0fjpokQZ cvlU3RhTg5HQGqy21vcxG5ubp4ZYZMiGMYWUEHqc9vSv9+D/AJxx8kG6MTrLmInYFBHH9aZbW4Vz EmBgGQ84AA5oNKfUsoWi3jMW11wQVBb86rTQtIpWNgrevQUGlirbMFleKbO5QMyY+Sn3EM0xVo2D QA4Pr+FBjJJPQ//S+NI4JAkcCBSGkGcjDKOmAfxpJbWCwumuG817lYyrQu5KgH0U8A8dRX+/B/zj iJfNIg8uFo3lfbHCfmYfXFPWZkLb+oba+Ox9KDWnsJBII7h3kO5GGETgBD61DeCRnMkbBnZuA/T8 aaRZBqkcLWMv2yPcgi8xkhfbIyr1C9s9+fSvxL/awuFn1bWZ4YZGZbzzraG9fEm1WXHAPooB9S2a /JPHP/k2+N/wv/0ln9RfRVX/ABsan/h/WJ//0/4l/N3Zlx5bEDch45pl1NcRohhKZ6bDwQfevv6/ xnz0HomUiJygHljO/wCd0OMepFaEQdIHPkqWVQFdj8xxWB0kcLJeORJGsZXAHZR25q+1naR27IjB 5FBMcn8YOT3rll8LGm1sZIW5ikDnMqbuTgkn61I+yaZ5FbDqfmRQBHz7ViI//9T+JZJfJEbsEwhw SB1zSzr5mSZMtJyqrxtFfUHjmeGS3HlABSHy+etWImtoSpTnd1J5zQAt2VkkVo22uMZTHyEexrKa YSylUBV4m++DlXoAluZLsyQvGW2hcsE7EdzUsMqn967b5VkHyNks49fp/jQbx1R//9X+JK4h80Ga HCNgsB159KoWs75E+ySVlIjctyF9q+knL7J550Ky7I+iMxPRT8tOtUQrIRmOYSEndnafpWYFk/Y5 IJpZpYy6sI1QDDE9c/T6VzEQ825kEUgVefmY7SAP61lN3dgNhZVRBnaSeME/MazftbeZKhxgDIUH nPtUAf/W/iURZ3ALb1HUyY5HtT42nkkeAksqJvB242j3NeweeP8AJTIVRlD94nt71BFJHAGjiiA2 ylg/Y+9ABHJLLI5XBZssSTgZFFxcsEjWYiNd+1mHSgLdCuBEk3mK7kdAMdT7VZljH7qRic/xL1X8 anlWo2mtz//X/iUS4bfiMoBJ8udwCjt1q8s9s0IUyiRpAR8pyOO/4V6sY8rPPKHkys4cyD7Kp5X7 oNRXEUcoMqkhF+ULUcvvcoGjYzPFGquAynuR1FXr+ytmgS4VihMZLHAGw5PHuOlbAc0JnAKbR0wp /hetSC4PlfZFt4EEpH76QfOvsD2HNTJXQH//0P4l28pMfPtMByxRuGPSp5J51iQxRpOJONoYcdeT 6V6B5z2ILW23TlJQrF1ygPJX/OKuvDLArAAAquI1Q4zjpQKHwoxXnnnLIqZwMvn7xqKO5UyLH5Zi AONq53Ej+9QUPa2k3OZR5m996MF/IGmCGdCrMA6swCEDcV9qAP/R/idixGcNJjcAzLjGDVu5uYor V2CqwI2A7csT6e3SvUg3ex5sY8pz1tHFMxE0vksp3A/3x6Vtz3Mqw+Xb7JV4G1z8gx3pTetiivI4 mjaF9u7GPMQ8KantbS1hKi4k+eQbYI1GfMb39OtZSdkBNLaZ+XZ5pU8kn7g96xr638ko1uhDtwSD uB+tYgf/0v4iLecrKkUsZ8tBl5Pf2rbufskkKuvKv8rLn5wcdcfhXQeeUYiixMAAjxn75+8BWaZB cudu7KNgPnO4jqaALyiK4VLZo2WRSS0rZLE0l/aKYyFy7BNvmJzISK1gtAEtZ5hBb8iTyCEdpBh8 en4dPwqWURSnzZWO0HO1SMmtLMD/0/4jFhRMOSxSQ/IfTFayRpGCApLMmVY8A16B55SkviqLEVAl DfKwOSoHrULfaLnIUKzk/K6nHFAGxGGggCDIJXEhbqxrKfTJpfMuC23H8CjgiolG+wCQSyQtsjty wRdzvnCrz2rZk1GG1CiaGCSSVVkRsbmXHIPtUODQH//U/i2tvFjeX5TTAQB8tG68qelU797e/la6 WEQDZhmUfexxu/GupRb2PPOZAgmmYKWi8kdDwX96XdJlpFZ2jU7DHjI+tVBbgTiGWZG2MqTYyqyA 4H1FPFo0EYS4YDed29Rjd9K0Imm1oSxHYVMcsgVGwEY8qO/51Zu9RtNqrFPK0i/fTy9oU+xzz3rB 7mdmtz//1f4jkmjVXPmOWl4BNOhuIoUSSKZ2uI5NjJt+8uOSa9DY82CaWo17zhiTIPMfKgcAkdav q+2MuylHbGzePlb15qJuyBJ3dy0LmZoPOKiRkYR43AfUj2Fa6TWewNb26vcBNrzsBuORyBURdnYo x9Qs5LQ71BjuXj3Rq3BwRwfpWTHMojaPG6cd8Y2mthtvZn//1v4jmMlzuSWMJtABIyPMpyWMMRZ4 yXUDBP8ACh9K9A880Jmt1SGaEMoEXl3BcbiWyentjFY5VbiRnkby1Q5RytAEYjZJtglZWfABHAk9 K1LvZBhZJCJNvzCJtwf8qCJuyKolWFA+NgzxxgtWtEbSW2CySYLnepC/MD756UnFPcmD1sf/1/4j r6eJpo08wukfzFV4LEetZUj3M83mRuwZmCeUBhFArpas7HnloyXMMjxPgxsux9y5Df55qBYYbWNm OY5y37sKN270pETWht2d7GF2SRM05GNiDG89qo3V3GJtroVdvvL2xTsZFUyBHcSgmBwAjR8g0glg aNVB2GNsrtXkn3rRxikdFuh//9D+JOICK3jT91AwYzM5QBpM+p+lQTuXkMHyu/VMdE6da6TxyxEP KGJmBBX/AFgXHP0qVbRriOOVZm3s5UsW6joAaEtbFRjdleWT7IoW7iK5fy49o3R555J7USbHVlQg yqvzsvQj0pGxTE8qCLcAig4O046DjirjssiqrTKjOP3at1c+lAH/0f4krSKVGi8wpsZsMXPyr6c/ 4024uI/N+VgqqSAIhhSR6fX+tdB59iZrp4YAWRmZjgKB8wHr/n1qiHgvNojJWVDnnhTnqDQUot7D FuGJkty5G1CoXPyEd8VViWezkaVYg0TLwCMg/SgOSQv2uXEwIWOQDJwcbc0yG4kT58EPj73XP1qo fEiT/9L+HSO6uGWQK4RS/wA429AO+avQsjrLJLGzzxj91gn5xjrXQcDTW5VWR2JVw2xzhlB6A8Vf R4LRWGCSvzYkGQR6UCIpHSWF3XESJ8x/u59BWTb20nmiYlTCT1BG5sUWGk2bcjLHskhIRThJUXkc dM+9Ob95BNiEgRjcZGGAP8/4UCP/0/4fbKKVmDSMSeoAPDdqt/ZovMmEjZmKZVoxnYf8auUXe554 6VljhjFurSlRibPB/wA/SoY5w6body4b5lbkfhUGsLWsUAhe+AnBcM2QcbT9K6XzvKi8uEfK44GO cigsrX999nmiZPmbYGIHOPas43Ek808knyyMQUDcY9aycfesVH4kf//U/iGggZoJLmWQsS4RB1XP ekGxCRIgVtm5WA69qAGKlujB8kluy84NWodWijvpIpIPMEcAOV+UnjHPvQBmy3DjMqL5bSORtHIq zBcSmIoo8o435HO40GU1qELXOfO3sJt2SW5JAp10booZ5XysnUE7cY9q5yD/1f4c2invD5kcfl44 +UcYHFPmdoU2gEcYOzjPrWKi2c5etotiRSQuVkccuvyOhPUGo5LR/LMSsS/mfM7tiNs9AKfIwJbC KWCQ5XZIjbS5+7jpxU10wjvNwjBaNBlsYLD1ArVKysNJvRGTqd0JW3ZZQoATaNqnpnPvTLeZFgmZ h5/yAAtwYj9KDWMeU//W/h0tJJ5iRE+Dt5x1A6VqrcCBd0si787AvVj70AU57pTbTL5bPK+VSSQc QHPDgdz1GD6mq2mLshWGaZpoQ5kCY4UngkigCZZYyJY7jzGgUsYQp2kHnbn6cU60OZxIuFwvAzhm ArB7sBkqXVvcNdRlUWRzlc5DA9jV2a6U2pJTIUjkcbf8/wBaRpFJo//X/iAt5PMiHkhSrPubP3hj sa24LwXMSZibKOY9j9wOAa45Np2Q2rOxHPBuZFwEiQErvPJz2x6e9Z09kzAbJG8tW3Ou7FKPNuVG XLoylaalLYX0jW6RSxRr85lgWdR78gjitoSrd+TGYopV83eHRB1PYkdvatSXuM1ZHaWU73kmjCrv z+7XHACe2BVAW7v5aiJhKnzmQDJ59R6UEvZn/9D+JizaKCIxXlwVXOI5SNwznkH0qG7vEaRvspeS JDjLDgj1HNc5z26I2re8lfTZrN9k4d8NHIuFx6fhVex0OHXLqKztmhWZLqMGWZ/LEahhuCn6A1rC D5okYiH+zykfsz+zR/acvhq3tdSlupY7e48jR7q8uGe2WIqA0MeAeN3+ea/pD/4JE+G7m18Y6wV+ 0ymbWVvpm8zEBLMo2w4/2VUEH2r+08RP6v4MzjPrTX/AP434Dp+38ap1YrapL9Uf1B/Fq8XTPh/r E0pa3kGmi9t5cZWExpvww/AD8a/iA/bB1WTV/i742njkiazYPqEcJy/lNEZMpnpuO3cf94V8x9F6 i3mGIqW2X9fl+J+r/Secf7DpxW/Mj//R/l1/a68Spf3moT3MxiuLu8iMJtY/LgQ+UpChccEcc+x6 5zX5qalNJJcukjtK5xhmOcDtX9F/SMrKXFUKfaP6s/CvBCk6XB8F5/oi5EpgFtLB8245c9Rx61qL HdSXP22Es+Pvxk4VR0IxX81zW5+0030OotIv7QkhVUVZ1faEZtvPbrXTaXbziSW0Mcn2xXJjtsZD 47/yrkmtLmhztzdSLqtvIkyW9wjkCSTJhtyONxFdlY6tPaebYXuLmR9ptZ4V/cwyZB8zHuMj8fau WSszZNbI/9L+MS+lne0+zXBgfbc+fvYBZXz0Hvjg4FaMRWGJra3VLsOilHztnJPUAZwBXznIrgOE jy3JzIkV0PKhklMe8RxoAgG0egHWukuLlrVpIRbeS4gUOm3Y9wMAhiO+ev41SSSshtt7kVgbZ5Vu L8r5cXMY/jB7Y/StOWFHjmvbEx29wi4t5i4EgPYjv+IpSSaEYjXF08ItriVJpGfzHkP7x1Y43fN1 qKODzH2KQm0YwTzmsmmnZgf/0/48meCwuI4XEDySusdxcINwYf3c9TjJ/wDr1041S2udn9keZbmD 91MJwUG5PvOvA+XAzXyrWjBay5T03w9Pb3qWUD/Z5Uz9phmcqygj7rBvXPT3PFf1G/8ABBrQNV1d NY1q4ukuIbbxCqSSsfJQSEBdzt3ACtjHevz7xBaWRSXdr8wqLl07n9nGiKDYWc2NrtAqhdu3oMAn 64z+NbTk4B5zn1r4PBK1GCfb9D1afwIhuHG1VUcnvTlQFAAfn7A967Ffndwjuz//1P6BvFGlXFxp t0YbWK+JiYiAttLlBuABzwcgYr+P7/gsJ4bvbTxlH4ji0ee2lW6druHTg8l3aSXW2UsFI5ysTKQO AD9a/mfL37PN6T87ffoeZjYSlUhyrqfg0LiKTTb9rjzYdS8xnitny4VTlhIzZ6n0rhtNOmWd9qFz 590msyorGRot6S7c7QGzxjPTFftFGPuJgvjYRaHp/iKKCKOSJL+O8d766mH+rjK/cRc8tkd/bmse K006wnW2IcTSggMqfvJApxwv9M+tdFuhZVg1OaG2nuRpU8DF3g8u4QLO4XOCF9+o571Ci3M1rDPc 2qBbvMWyOUSzQEYPzY5BwR19a6BpN7H/1f4zDbwWltPLdWKta3EXkJM4woY49uT0GPelnuomsYdG DRwZjEkcajYzheF/LIFeHBa3OHkkV7VEMkdtOfKlhYGYk52DqR/OtfVHggQC2h8wsm2VZBvFwOwx TknzIORpHOWunxyafDO8k6XdvNJIlvNIcxZONoXuMZx1xWjbafPObm7gtbyGKOFftAVW+z56bwT3 J7A96pq7uapWVivcqsSQ31y3qIMcsCOCf5itW1v7aacy2qXt3YlVjuYXhAZMjHXp1qo7oUtIn//W /jy017bTEvbS4lmns7iXzYhKAJbXjhVA7fXNSRww3u54JpIJbdN6vG2w49c+tctL9TzyhJYXFxIl zLE0ttayfu7gku6MQRn274Nc3FCdLuJrSe0gvZL4Nvu5UaaXa+cHIbHH6Yrvov3rGM5Xi0eVa1BJ DcTBCuyORgzN8vAPpVfw/cW0Wu6FNeQtdWsOs27KhcxguZAqt9VLZGeOK9/Bf7xBva6OLEP/AGeS W9mf0WfAWa6vPBcVgYoYLePVbS+jtzL50sSxpIy26qeWXa2ST6iv6sP+CNHi6+ksMalc2slsNRKR Pax+XdWs53blcemew6bq/uHxFgsT4QKTW0Fb7j+W/BaU6HjfVpJ781/PRf8ADn//1/7WvimpvvBG swyq28aXLu2ruzleSR/nrX8On7UOgL4b+OPibTLeyluMzS3ept5ZVi8xieLe2MZTMq49Melf0t9F /E+y4jxWHv8AHF/g/wDOx/NP0vMJKpgMDio/Ym/xsj5s8R2E7xb9PTyNStgt5bw7wyuB2f6gY56Z rnIoIYFuXk86yu32yzXSAyeQ2PlVM8EHv6EfXP8AfNOF0f584iSu0XdUSPUILeWO7t4I+kkzZVF4 HzkAE9uwqlpiTX+m3Jt7sQRogSdVmxNOmSMhe4OD+FbxjynLJqyM+xW3ictavLizmUJKn+rJAJCn 16Hg1Z8+x1C/lub4ERLdi7RFAjMYKhXVeuM49DW8YWWpzSd2f//Q+DXjtFS0hs9RB062t2KGe533 Usu7jehHbDD8uKp6VZMLgiyCyTRlpMyYAAJzjn8K/wBoLH+J5evptVt2t9RvdLjR1Y2+6QCe0l2k lcjlT0z/AE4qe3vZ3tIRN/o9xfQeXcvbxeXYh15wh6Dtk4HWqiuZ2Aj2T2cVxDp8cS3DkRPdTrua PIBZlGcd8VL4fKLLLbxTq5eQPcGV8qxGQCPbk/nWsVyqxlJu9i1aaVcajfvb3Oo29q0900qFT5cb jJ4A+np6VW0yG8a4mFvcRxOrvAzTt5JCjIYnPTpjmtIxvuc830P/0fz3vbgvdw2z3CreojSvF5ga N1HGVOOea623uks9Jt5pkWS6G4yFvnjiXAxt7565/Cv9sUm9j/Dqbd7GILFtRRRpm6SWZOsiEQkH sQeaW30/WYI4ZlhmGnwyhdQlV8QIpwDxnGTwBWqikcVVu9joZ7gurzRxTCzd/LQMpddvbcRx9e1Z NpdSwvPbLDGbRyxZiN3lcj7v15rRRbMR6RWbxmyiaRRPeRXd2J7fzI3EbDcFPupI9e/akeSVZktL S532KSsSXYrz0Bx0B45q1BdQP//S+J1sdIibfd3jFm4ZVQkJ7gjr+FZcEkFhKl7Z3CqWlK7ipW42 gEHH1B61/uBax/g+Q3epSsXaHabUIXVlJ6jr2rWaOeHTPD1zeJN5mraX/akS4xCB5rxcc+secUWA dBLPdNHO6tDBbyYkZeHcZAz6Vv3MGixI1yLs3MhgGY2Q/KTztCkdR69KtQZhN3bscphWeF4Edt5w jAZ3dTV7VILm2Nulxj9/CGU78bfY/StTnu7WP//T+N4y+nWn9pOYzqsDtaRmJhNbeVsj2lWwM/Nu H/ARWdaSPtuZYpVN3IhMkrneoLHO0Hr36V/uQf4HvRFU3EVvdi3Dm682DzJm2nZC3AK+/X+da1gx vZgHmTykxAzsTI0OccADn3xQczdtTYS2uldGunENta/vYHLeXvZQRgepPbNV7O1Bm824hljtdQgW a2+0xESspwS67gCMkEjjoceoo2M3O+g3V9Qe2Z7RbgXNtGmI98ZDAkA5HcY/pVS1V7iCyuZ1igcv sWdVymzdgMy98frW6etiG+rP/9T5KW5tNJhvLQCK4kmbzo74AlywGBGqnopzk8Z4rPO2S3+0T4ka WUo0aocW6gKQ5PTkk4+hr/dDY/5+bl7Tbe0utx85jAq481Au4HHBx+Fc8t/MrmC8dJ5I5GEc8UYj +QH5d2OOc10LVEmtZS28kUkSFZp5gNihMjk46+tZ5F+Xa3mEvlRtjdIfu+4FBjL4mSMgafbbM5WP 7pPDHFTyW0VwqFYWJRsbVGCT6mgym9D/1fjKHekcqkEq3CgjlMelV/tDwliFbBGAOxr/AHeg9D/n mbshdHP2q5jfUWksYpGKecsXnmHGecAjPbp61q6jCJP9Q0htVbCuxAllx3YDpkjpVGKbWxFDamVM A4jH8B6j3q5BZ26NEplAWL5p5JGAZh6A/wCPSgLshe9sZpYrbyTsMhkhLNvdCOCM+/07VR1JRZXb wIQI5Aski5yVyO/pXQJy1sz/1vj62t2CLjfJ5vEIXJJx6CqrW00wIKEoGK4AzX+9B/zv7EKCRS0b IUjQZBB6gd6bZRyXMupT4Z0WVPJkkG3auACT6knv70Ec6sbkLrasZo0DHy/KcsPvA9f5VQvJ2nES AlVX5lSM7S2CeTzzQHMuWxPNCsluj7ZFn+UxLj5NvO4n36Y/Gq08M1rslV2/ephmQ52fh+FBkf/X +LJC29Cssk5dQhYpgZHU+xq1bJHKQshKY7/3q/3sjK2jP+dclt1tl85Z7eGd/MAjdxkgDjH+fSo9 k0cgWIRxQqciMAYPqAK0MpvWxIieW8khjGCMAFeBUq3KvGsYjRFhQovloFbGc8kdfxoIKjPJ5bRp Gr7j6cmqz2kEd1FdtbLEwhEM0e4lZFHXg8An2oA//9D43jtlnjkYKsdmG2Km/LeoDU9vOKhUwEzj PtX++B/znly6i+z2peCVLmTyfNVS3lqSBkrk+nNE21EiSURx+eRiRxwpI4OaAMopOsTOMN82AecM O+Kv2NvPPHLLLtEEKhVZjjaSfuj1654oAszRRuhS5JaRV2jP3sYwBVW10+WSFrzH7pJvs4cnODgH B/AigD//0fkT7JtkB7DrmgA2qTCf5lYnYEwAg9a/3wP+c8zwzh/LjVJIJ/luVkU4PpgeoroIIbVR HAWBkcYVc8rzit47AYt752mb72KOa5ihcKyxKXVQT1I9KV5XVI76R4VW5kaOOKNNk2QASW46fMKG 0twGSxC5MbbhEh4ZmX7xp8tlEkfE7I+35HhAJB7daE09jGV76n//0vjlFu441dZNyn5G4w7YxyR7 5/nSPPcIrx4ABOfu5bA681/vwf8AOOKZUaON44yuPlYk53N3p4gdXD7Qpk6LjBPagCvc296dqlQI Sd+cfPkdMfmaVktxFGyyO12rYZCnyIOx3Z/pQBZVHZ5ZZZGZhHhNvIBGcHFZMZuJZFaTgYxIpHP5 dqAP/9P5FyI7NI444iN+4yCIGYn3brihkhjiW5kCLyIjuIDMSeO9f78LQ/5xyBJpYf8Aj2hVsybm OOSMH86jju7uZAs6opjBUTxwLAHGehx1Iz1NbX2AgRJGdhb8ow+cD681LHbvHJyCc8EkU+pg1Z2L k1ncQxpJEV+VskAZ+gINVPtVzGzSTRxy75PmUYDKPb060y+X3T//1PjuG28++EiSxqskZXZIm4+2 D2/+vRLDfW0g2kGCMfvUABz2GD2xX/QAf835Mv71HJOFfhR3HqKrqZ4w1vGDJvkyihdzZ6ACgCzb iaWYJISpA27ccEe9WFzZs5Vhg8BvSplJLQC7CXuFyHCIOGbHBJrN1CCKGVQsoLkZIH8XrWSdncD/ 1fkhJR5JVWwcYz0xWekTQRfZm3CLeZFPQHPv+Ff79czvqf8AN+S2gEcssYJCE+ZhueT6flVyaZpI iPlyTjJGDjpWqd1cCxA8SwpGEUbSS0g4bnt+lZjebJO8S5w3C8YqZ7ARKLiBHSSPeSfLHG7rxu/D r7YqxGk0UEa7nAVdpVusp9T/AJ70Q2A//9b5HeHzYiFVvMYAKd20Icjr+tMhhkiLRXJSSRTtYj7v Hpz7V/v652dj/m/JYim9kVc7QWIUdhyfyqQFd5lgyGHKFuSv41DkwKU25J45yWLAbWG3cgPGDVmG NQdxPB54FSZN2dx18JdlukbI6mYPJyUkwCD1/CrE5UyPDFKsiRyeWsi/dcDjIoNT/9f5EuTc7hAj qo3BizDII9P50FFyOBvHGR0Ff78H/N+VfLRUaOSTfubd5n8S9ePpVq1Qxy7iA8a9EI4oAaxiluGY PsZTuVe5weg/SopJFaYxkHa/BI6UAQ4iSRA2NwbA47DvWoiQrOsoKPvi2EsufLz6H8KadgP/0PkS 9eCJ/KJ8zdyrY60+G3SSCTdKIzt3QrjLOc9M9sda/wB/Yyvoz/m/GLc3ibvtEqSW6YVIypD8cA+l OSdn3yA8H7uOMe1WBAybtmJGJJ3N6j2qzaqJhJKq48ltm5hgMf8AOfyoAsNLLHtEGMgZYkZAxUNv GsrSSPI4csGJzge4/wA+tRJdUB//0fkO4LlxtbKKw5J28ZqSSI3MogghZn272KruGB3Nf7+OTUT/ AJvXFMkFoybtzDK/Kqd+/NOa22RRpJIsjldx287fari7rUoYqsY5UjI81R+7DjKjtSurlFEpVmCA SFeATjk0LVARxQT25WccKDkZFRtK73Bm8wj+Fj39KYH/0vki6hUPG1vGWjkiHzkhizdDgelZcQjh vEW7mMRZsABSxzngcdK/38n0P+b8290U7eU5+XYxTJxkgEj+VZFtEYgiXcqtIWO1Y+gGazA3LBrR Z5IGYSRNtMqqPmUdcDI69au391LGkaRu5W3Qxopxl0OTg+xzSknbQDmW3TSSPBGsCN83lbs7fXBN SRpJkqqHlcEt3rG8kB//0/kP7ObeNLiQ4EsnlLj1wKdPE6R+ZtyuOcDmv98oOz1P+b8SO1aKHeHA 8xPm/wDr/wCe9SWVpvb52UlRkFiFHFbAF1C0iskCLJLuARR6k9qpSmSMfZnJMgOXx/Big3Wi1LCR gKpzubbgHPT8KZLFKyIpYM0ZLrxjGf8A9VAz/9T4yukvQbeRZIfs7ZWZCpM2R0xz/MVEhjmeSKMh tnDAjGa/34P+ccYtq0HCltmfUnbSwKjzqrsS+flJbaDigqDsya6GCNvLAfdHali3BMYOfXHFBblq rMeYEWF/MwZCcjHamwAo6RswWIn72OBQZH//1fjS4ivQVlXZ9m3FN27EmcZGF/rUUsVzxJcbi7ck ucnHY5+lf78H/OOR7MS/u5eEP+sTPPrSuvlgCJf3TnLluSGPU0GtPYU2N4ix3AMbwlsHY4c/pU7j agZygcj7u7kfhQaJa2MTUrmeO3uJIpNk6W7i3Ii83c5GAuPfOMnpmvxT/as0+6uvEN5qV4I87gk8 KSbZi4l5+TpjKivyPxzf/Gt8av7r/Jn9PfRVdvEanf8Al/8Abon/1v4oLOxee5KFMhpN0eegxn+V WNUhitjIrFXG0ZOMHIr76v8AGfOU/gVzm1uJ52eOzIHlrnaRwccYrTt/N2lrlSrDopPH5Vidd9Ll iGziYPtLAMCSpHynPGKzp9mVRWaMLhQem72rmewGlaz2ixFHZ2nRsEbco4rPna2SWdEj2yum47eg z2rAD//X/iYhRPK3S48oxYwwzuNcs8zw3A3M45wrk5wB2zX1B45c3Nc4O1evzHoTVt4VgQ8Mwxnd nISgBUu7cweUMmQqRI+3oPTNVrW1dJPNbaYcbl5HPbBFJu24GwyxxR+aDgSDkH+QqjDEjESsu1Q3 yqO+PWs3PSyHdo//0P4h5Sy3YaImNscDt9P502A/Z3eR1L+bwyrxz2P8/wA6+gPNjK+48T4IiAYy bs47CtnfG8KQsymUHl1YgN7UFFWf7OihcM2O5PANc+ocy7NpXuZP4a5wNaciK3haWISDdmOUHPtV eJ3nkYRxJkAYcjn6GgD/0f4u4ViFuiFVASMCRye9Zt+1mhwxKEoFKx/KJMev1r2DzzLtpUlJh3eW T/qzu+UfU1ZjEBXbvyvKk9MHkZoAjMEVthYZHlLnow2qnHaufuo5/P8As+x1VW5Dj5fwoDY2bWz8 4pEsyowGfmIAGP5VJeQFYFGWK7ssy859s0FqWjuf/9L+H/bCy+UNy8/g3tUsFukb+WAyjHybeMdq 9g881ooGbIfLJD9xFOd5PtQkcT+bCyugU/MQOBWe0wILjzNhZCzpGdvyDoB0NItwZo/s8/ndN+CD xWgFaR4kESIWLZO4suAo9q0YgtwpjwGc4GwcE1E3ZWA//9P+JMWsJMrBmUKNgjI5OPWszdJCZFRl CscEbsN7Yr0DzzQtLlmxKx2PGdoYHBYDv/OpZblZUb7wkjySenFAEMKONpAPzjg/h3/+vUJjxIZA rAA4Y42lselAF6O43fuSdu4bY1xzj39+KuRzhIzEMZzgMByp6UAf/9T+J0REK5B8x3HDvwVNR+ej xxx7QxU7XUfdY+tenT3PPKDjZNuWIYxtcf3R/kVPJPGFaKLJaTCoQMHPTNKXxMBunM3mPHKigIcE sOG9xXQ/6hYnkhhkTeXhcfM6Y45HasprQBj3jxr5kblFbO7AzkdMGsX7W0pKrgRZwXxyRWQH/9X+ I5Uid/42jzycYz9Pan7Ykdgud6rwT9010HnlO2aSeSWEpIAvBlkG0OPQetWDCA7eVJHGkWMpxkH3 9KBXV7FtoJlcK2A+0MpHIIPIqpJIY5djMSg4Z0OcGt1sMltrVWjXeZSXBZXC5LnnB+lQm0kVGVv3 qk7gDw6npxVXdrAf/9b+JFoTGAXl4b78ePbgCqdzczNhYHl2x/L+A969A4LaXKqJM0bzhj5e4LKc gyHnPHervmNEwaISFFUEsoI2nNAjUe6kkXMjBcLuXuzH1qit/MrCN9wV+H7bvp2oAtPGskbhHYbl wGHasi8hmcJ5Ll3XCAYySBQB/9f+Iy102GIK948iyNglFXP4VpS3VtCmPnOTtj3cAD3r0LW0PPMv ULYMkbxgh2/eK8fUj0NT2dz5MSYjy+7l+/0IoAsr5VzdxuzNEucSuoy2O+0U24CFTuLEA7Y1c7ST 2oKcbEDxnfHtwilQrsTuwaoTxbSwVlcZ5Ze4z2rJRvJ9iT//0P4hfLxa7yjxuzYjJX5SPWrMAiVB IQC6EEnGDJ9a9C3Q88usLZ8O6Dco3hG42jucVHPI8ilI3IhIA2jnpUyjcA8qJYwQwk8vmVlfOzFV ob2O1ncxF2E3zAk/KfoKiEdbsCzPrEl/LuuEkLBAod+wHA/lVVDE3zkjruPq2K1A/9H+Jue5DKkn 2fbCB5a7ARz/AJ5p8McLlI5ZxDDIQ0gb+EnqTXoHnmTeO8ckltbSl44skZ6yVVhnmz+8hJVuBkce mKAFuGl88iRQsRTerL99COMAenH6VowRRTtD9qmMUbRZWX/WNxnGRn19aDKb6E7WLO0PnBkiVt0Z XkSDpmtA6d5UYcj75+TPGRQKC94//9L+Iq4tCtyHCCMjoSciSpoDGXwuYXiG9zIu1W9lrtl2R55b aa3laRpWDOR93bkSVj3JE0ySLD935MdCKhRbVxabM2tJsZp5XwrCXAKEcBefXt/9arF9oUUBfzpN 8qEgPGQwY+uacotKxjezujl2U2/mQlw0g+ZR1C/4UsVyto8UgiDuzfM4GR9MUrNtmnOj/9P+JK4x dxCYOMj5Sp4xVYfZQ6MpIRBscqMkt6E+ldXJI8cuQtDHhpW8yBpNs+SAxT+6h7HpzT7SeG2mjglU mDaRbkcMrcnLe1KzWhSk46INXnjeAqpLAffGPlPpXNR3jRuAp+U8OPUfjSNYu6NCN7dpfnyiHBj3 jJzS3arIyTPKE8s7QNuCPTAoGf/U/iJSUrAomZdkj7V/+vR5WwoyghE+YkjH4iug88p3ty8zZ38B dpAHLip7ZYreNWdWAHzM2Mk0GtPYuWsK38okjRQseWdfuvj3qXUJgIcY2CP5VUjkUFmJbW5afzrm LfC3AY8An0xXS/ZbPyZBFHsZk2+w9auEXe5nGPvNn//V/h/8kxRrb5JjycDru+prRS22RABihePG PvbeOP6V1SjbY57ENrHHGwW4I4PXoKbfBXucyAeSVAQoMHjsMf55qbdBcq7Fa9RVU4XEbDIj5BHv WfaCd3CxIfLPykkZC++a0cfdHboWNkkcnkKwJc4Z34GfWp2kuoozbOAeMMQPvds1mZTjbY//1v4i beRYYgJWAIHy46mmi6SOfzAoHy5bI++K6DzytOxiLz+aTBcOW2KPmXP9KgjlRCvlEvzhYsYyT71l KFtUC02K9w8scsRLZOeQOi+1a9pcRmVJLkP5YkAcJwce3v1qCuaV7k0llFct5sAfmT5IT8zp75xV G6gKTrsYq7/uwSMKMep7UGkZX0P/1/4ifOWJFUx/db5kByDjjIq5DJa3W4PHKWCE7Cu3AHvUPmuj OM+jM9Nof93AUAyd5fO3rxVRJAjTltu89fU/SqV+poEcS3B2AOsqDzJYm+XC8bSPXPpV6O8trR5w 6IXWExLGBuILDGfbH50zKa1IJprlxG6jCKMKQmMj0NQXUNxdyxxn92oQFPmzx1JqFCzIP//Q/h+8 xoYYktySIz820fM/b/HikhimckyAZQ7sEZVvY0WsZwinqzd+zwtCCrbNybip+Q/lWNclhJHEZUMT fKCT+tAnB9CzbRFl2tMWKyfJk4+nNRSvNPJOkqbZIhiORTggDt70FQVkVEVbua1jyxihyXjYfIGI ALn8h+VJdJaR3CwRYYP/AK0x8qP/AK9BZ//R/iH+xRQw5tXILLkFQVce1YYEjSMrnc0Z3AHhuKAL 0Um6GTK5bd0Peh0WMERblkYBlZTmMZ6gj1oAuT2okWOM8AAb2UYbPesmMvaXqxzJ58anMZGVJ9jW D3YFu7huRCjspELzF9vOQfQ0zfJJlIUVY3GH3coAPSkNNrY//9L+GnzpI5DDbn7hwzJ0bpW3aXAi RRIriZm2gtgIOa5mr6ABvL46hcxOttcwInlGXO5VX1X3/wDr1VmlQsf3jmEfK3Bwp+lMCRFtQsgg nZradRHMm3DtjB7+9WrSS3sWMELBEYEqxx+7+poAlhkR3EhmV2L7I1PVj1/oalFxNFKXZysYO2UY HI6YxTSu7Bbof//T/iQkitpIZ5FkAjh/esssnzMScYUd/p6CoUt1R3eaSaO3EP3UQEp9P896lxTV iYws9DU05fOgaWIPLNI4Ebb9pi+o71p+FdNs77xRDYXN7qFinNzcvaREzfJwoAPTe+1d3YHPNbUo 81SK80LFpxwdR9Umfs9+zvpui+HvA2lyWc2oy3MTNFeRajK14lxK+yQTQswyGIK5H+0cACv6q/8A gjlo0dxp9vrsVq5vLfUFGqwTW7RGUswLuoPICqVH/wCqv7D4rf1XwbiltyxTv52X5n8heEVNYrxd xM5LrNr1Wv8AmfvB+0xPHYfC7U52u9ltawOJYVBJu0kU/IT9B/Ov4S/j9rkT/FP4gRXU17ZRy+IZ rpSIXiQ26qIwkTnjnkZHU/rj9FqlFxxVXyR9l9JypL6rhqV9HL9D/9T+Uz9rC4nj1DVItUa3e7cy NEZlWNEKYQOGB54I7DpX59Ol3K0ZYRPk4LAYzX7z9IOrz8bSi+kUvxZ+N+D1L2XB1G39aI2UjaK3 UfIjhvuZ59c1qWSuSHEjK3UwjgNjt+OK/n+fU/VovlZ08L2suJbiOSG5iAEO0cp2OfwrpbadLYpP bXLLclNv2k5MgHcZ6jg4rkl8JopJmC1tZ6pM/kPbyus3lXCIf33zH5ifyrX1NNkEcUPmW8lswV2R NzsAOuea5ZorY//V/jA1Kws9Vj06+spLm4ZLIRhmj8rEh4k4BwRkDk1csre0hjS1urjN8IsyLjZt U+jV8+ZKbWjJ7Zre2vryO0ctayxCKC9c73hcHqV9sfrWlcyXTxLPcTy3c+wRrdzNuchQFBP5dKCn NW0KNlczw+V9rt9xllMcYU78gHqR24q5LqFt9tWBW8qfyy4jbIEgzj5e2aUtmRzO9zas9Nju4HdH YunMmeCTngD6UXOgC2kk1Ga8lUXECxvbswWGHBIDKPU5FYF86sf/1v4+7fRPKMss7QzQx4NsgJL7 s5yfpXSaVpqWV1G3n3Ae4fLRR7fLKMCGJOOOCQPrXystIsyjL37npdjY2iXKQSI+2KFZES2t+iKc BSQMdulf2S/8EGPBsGh/BP8AtW5h3R+LPEsqhiu2SFFUCN8dgW6dvnNfm3iHU5cphHo6kV/X3Fzb lUhba5/UrpC3UNvFFNtHloEGO2BgD9K3ei7nbgHnivkMOuWEUexBWikNYpKQFwOML3JpQ43BepWt o/GxpJbH/9f+hy5+zvZS2l3cNCs8eFlVSxjPrxX8wP8AwWf8P6gLjTNQSeMWt/4kitYNSjuViMyW trLv2r7edHnjk564r+XaEpf2rSUekl+ZxYuap0+d9vzVj+ZPW7WwRLi6dkcRhllaNwVkIzjce2K8 bubuxtr2O5E4F9HIDalyGEhY8DHQ/TFfueH+CxFO1lI0reSTR4mu5LIPNJci5uoy5gMy4AK/7JIq KDxM2uNJqjaNBp93YSm2hjhj/cSIDgMx5wxA69+K6YWvqXNakP2mMLGrp+8Vmk+b5vM3Z4Gewz0q awNgkrlY5lkQ7vK8vEUrHk5J/mM1ut9TW1j/0P47lgsrlYpNRSRI0bz1tY5AUiYAgexxWBa6HFrV /LGly0NxYo9zasy5SfBwIyw+7nI6+nevGTT2Oc0dQ0e5hhEs237Y8pknkVs7zx37n1PvV23ht20p pbhXkv1lIjKZ8sIB1I6f/qpOVnYDAtla71S1tLUb7iYkMvCqpHTJ9a0g+uWX9oR6jqE8kE0n7u1A 8uKALng+p6flRe8rAZF5tvLZvMZIbGByQUOWQYGSffOePp61JFeRaFZyWcO77I6ea16WInkVv7yd OMZGKtaMmfwn/9H+NqFLSBLZi0sguVMkksvzAdxuPbitS5vU0uwuBBYM07yxLDMdwREdwHbAzng/ p1rkpux5kmrWICNUtrx9PuNUuHtJ5kniiiVTFGhUEYxweCTk9M9atau81laP5GwMR8srY3qOuR71 3UNGjF7HgOpsDc7HjlkWctIZipMbYPTNZmnxynU9OVIYZ7Q6nELiF5fLdEWQEsp65GOK9vDTaqRf mjmmrwa8j+g39mXxPcXnhN9K0/SrACe1huV1Zp2lnjWONHbaxHG5gVOMclRzX9PX/BILWbyPxHfz iBYLa7uIzdLGAYrSRBsOV9WKoxbjO6v7o4paxPgvzf8ATtfkfy74WfufH+dNdpP8T//S/t08TB9S 8OaiHCRslo+895BjpntnFfxffts2rW/x/wDGNqNWSSe7u1na2FsTOYo5CrkN0Iy1f0L9G1tcayS2 tI/B/pYJLhmnJ/zI+HbRYLPxBqbXt5JKLhtscsygLbIAOB9Rg4P61Rv4Yrp5D5bSaYVkkjRWWG5u RGpY4JyB0HH1/D/Q6lsf5rYl2bOG8PXDaot6v9h3aQ2TO1w8syKWSRCIn2g5IUjJIGOlbmhSWsNk mgT3FtZ3qxpHDeiI7JVAIbefTpyfU+lbR3OS9l95Wi0hLV2eN0nt5HLKoyizdRuOOfpWe2gsLmeU ecqyJ/o8GdyBgeSzdB36Vuc0n7x//9P4UtvDkUu6XUWihSFPNeOJgZuM457cjNJYWpQPPazjfEOF yBJKPp3+lf7QH+JfN7pKZJtRDWkh3r5myVZkDI3Qj6EH+VW10Swe/g0+7ultrYES2800rIhl7AkH ue1VB2Zad0bF/YadpFpLv2ySTkwHY/mMCO4PQZ7fjXJWemRXSyTrHLZrEojjMTDzpVHBYDk8kdK2 TuZS+Jj9QmuUvoXhV3jsbhVg82Ly5FOBguvXnP61cklGpXdzdeYbRLi3WzmsU+6xGC0gbGRkj/8A XW620OeS94//1PhrVNGtYdLsLmPT3vLuwuCqTnpFE2AxZup/PuKqxJfTaa6pEsYN0TAzqWByACpP oMD86/2zg9bH+HU1Z3OgtJbbTdOjt7pobmVxt+0W0bLCxPJGT0x05o1C40yLRw0jovnNsVAxOw7s ZPp681tFXdmcVUyILuK0STT47+e5UY8zH+pfjt2P1qW5nstI094WgCOyC4WQLuO0/wAGPWt0raGI zSoL6+njuopikLR/u8psYkjoPbHrWNMyi/nitkkdopjFexRrueIk43EdhzyaDOUmtEf/1fiKW1tC ksZlSdNMh8++mWXaYRxnPT+8BU0GkaRdh5Ib+R4UXehdBtUEfwMOCM/Wv9xOVctz/Btyd9CC5sA0 0VkpLK0ey2AULHIAOcHpnHb2q9qGoySabpemDcBo0LafDk72XLEnn3JqoxSVyXJtktrpFrFo6G61 i5IU+dJBtxIzEnCIQAPTn070/S9Og1JbmZo5J4kBVYxndkcknHpVW6GcnZWKd/HJpkLNAN8wZRDb AbdinOSW7Y44qjvXUvKSZy96qbo1ZsgHjIBP0xVuDMT/1viuya0jimjv2lIYBVGMxKew6559qgeC HSoVljimhvNSuTdQ2wkM0UcYCgFM84OM8mv9zFDuf4HmhFYQ3bwxxQxW8s2WkwMMxPXI/CrN1FY6 UkcYS5Sa3mDTNBtj87IUc/h3p8iOZ2tqPurwarEIrq4+y2S8xshBnJA4H19+BS2EkNtOpvpLm7sg nkwmJv36gD5cZyOPSjkXQwI57aG4mmkgjZy+I40fG9AzAb2OMcA84qtBaPbzGz3YSNiXKDfGMdx7 f41diZfCz//X+NrlLOa6t4AXJdd0UnRHdT9zPv71b09ZJLiS38h2Rso6HCquOpbPpiv904wvqz/n 0c7Oxm3yNZS3UNuwaxKBAY0IVW4Zhn2Ixx6GqmnW5ugyy7BIilgc7N4HpmtSXN9De0bT7EZxHGsr zmGBCR5u/lsoOmeCfWrN5bmO5azIkUkgvI4xwfSixlJ6Fa3tYoYmliZy6yCNkk+8Cc4wKlYTadNE rqxaZfPjnDBlIb7oK9QetOzMT//Q+OUkZ5LgiHOEJK/3MdTj8DWXJDLcsksT7YVfa69GPPOPyNf7 uQT3P+eOb6F25Q2sNsrzK32jd5JU/c2kAg9s89KsWm91MRJcKfmZRlVFaGZcihjgknR7jeGb92du Ao9DTBDZQ28jidvOZ8pFjckgHBwe2KAM2JY4ZVlKpt2lFD5AQkYyMEdO1X7hDPcJ5i+aZgse9juG eg3HoOnetou+5jP4j//R+RfPuhLCfLjhksswwRJhUfb36+wqraQXcST2V3NIBO3nsANskef4R6dQ Pwr/AHoP+dlybViCS2+xPiOd5E8ooVf5m5981n3MLPbbYvMDO4GY/lI5xQSa4823P2f7zpGDIN27 tzViFUlMcyH9/Gx3xKABt/8Ar81pHltZgXbm4gu5m+VrfZHtQhf9Zj1PSsVJneK5tgjbxJujlzwq 4ORj3PP4Vdl2E9Ef/9L5AguvsKPaNErxz24/fSxgvuONx9jwMY9TVNCjZdT8nT5a/wB60o3sz/nT mna5ZaKKO2N2sinj7pyGGTj/AOvVMvOjrLIySkKANnCkYHYd+laJJbGZNBNd3biNFU+ewSIAbSOw GakCpbeeHH72GQwSpxlWGc0wKUV9GJNjDbtbcrYyT7VfuA8sRmG1xtJQFuM9qAP/0/jmJBNar5v7 p2b5o4Sd3GDnPv0454PTirAtZOUVXlj27pFUHcq9z7V/vgf855O8FuLa3t98VxbyKGTy8q6buCpJ wcjFR3S20ki2cBfETCJQzFueON3egNitcx3cXl2u1fKjYmQtncDx0/IU1ZWSN4BJkAiTaDlQR/8A qoIU11HSSSzyefITuYc8cDtU8PkbQygqwbnA+8aA50f/1PkGa4eSQpGGHlHIY8Kf8cUsd7bmVIrl yrbdxYpuQ+g9OTgfjX++B/zkuTYxrhIJVJjSRCQypnOR7+lIjN9oSQKC7fKrEgBc8VpT6lxlfRl5 Z5LcSJI4ZGbEyBsgEHiqLwwTF0juEaRmLDOSmcD5VXtVTXullYs4ZY5FIMZxg8VYBjR0QRySmRgF ZekZJ5JHp1qaZnNH/9X5GusqTFG3IbCEDGfeo0QyKBIQ0qnGf71f78H/ADjkh0e3Lz3QbygCkjxl 8EsoCgKPTjn9c1EWnZhMXEsUbhD5jcoOenfj8qAHz3M00qTWl1G9raxeYxlj4PqACeeTioPtFvcw +ZECrt8x3Lt3H6daAIoHntz5p4IfIGNwOParMrQT3KXAR0fyyJVJHlsc5yAPw/WgD//W+RmktyEM YYFB+8UkEZBPT26VlXErXZOzbJG8gKjACLX+/Ki3sf8AOOaUU5jQpJF5bKNuegOOM0xgvkhz8ySf MGU8Vb6L0AdavbqhEauWXgEHNSxvMZTuGADyrDBptvmsTyq9y285Vkxlo2XDgjJB/OsSS3d5JHRi Rv3EHsOBwKsb0TP/1/kf7O0Vul0SQm7bHIOPmxnFQPcSzMBIDtJ2g+tf9AB/zfk72luypFHN+/3B lwdqLjrk/pSLP9kkIfaHKFA+M/XFAElpKYiZxh2B4LjIP1HSopAZHCs/uwrnAmiL25dEclHwGXPH HSq81pI6tdPKmFfasW79506kelAH/9D5B+UIq524OelOmcZEQ+bI4OM4r/fg/wCb8bLFKkYypC8b mHyvg9xmnS+XsVISzKABlh87dv8AP1q4yewE8iz21nFiDaFBLvzvbPTjtUEHmn52jKkjI3cGpbb3 AdCbuaSRsBxB/AeMjOOPzppvC0zROgBTkoeqd60gmkB//9H5UF1bSW8211RgygRjjPXJ/D+tJ5Vi imee4mJZcLFGg2k8/wAXvX+/L3P+b8ptF9pDGHdGdp6DBxg5qOLeiFSxbB27u9IC39rhg2W7RGQT N8y4wzYB79qr20e+W4hmE8LIA8fy4R++OaDGW45Qlwxj+dZIm2gdFx/nFSMiRHZna2cbj0FBstT/ 0vkaS3aaXcjE7eOeA3vTJkIz8xG3qBzX+/B/zfkFqkbudzfu2G5Wbt9atAqXCxSDCnDHtQBHPCkb RSKm7J5dR8pqxLGgj3bQN/yq3UqTQBXurZ7aNGnQncvyHaVz9DUMMiS2zqquzLwFC5Le1AH/0/ka 2WCS3/eo5mB2hXXGzGOc1TupF+1W0aq3mxjYHycEt7fgPyr/AH5i7O5/zfl+6No1ogVwbtZCZE2n gADBz0/CorNUkBDuI1UEkMOTjsK1jK4CiwZjcX0V1DHHEQkVpJnzptxIJXjBxjnJHXintGDB+6fa ygs/OMn2qgGwC4khf5wY5RgHbh1/GoHfyWW2VixXG5j978frRboB/9T5Gv8ADpHDGsaKYge+/d/e z+BqSzuTbxeVv3My8v34r/f9pPRn/N81clQyTcuMDBw45DEf/rqlH5lvKScku+SJDkenFFtLIZNK QJQ64VmOcDpU80e3yyzDey7toP8An/JFCVlYCVneVEBUK2wbkByorLv7URCMxM/zj5g+AM98VDm9 kB//1fkFZfJEERblsZB6gden4VQ1FjFKXgjM+6QKh4QgE9TX+/c2nsf835feCZSivgzJEHIAxgHB piiGRCJW/eA8KOD+dQAwieNzsAWIr97PzE//AKhWmCyxiR3Vgy7QpOSc8UALcW/kjynt5IJEAKsz ACTPOR3xVdpblYi1u6BivluCMnBIzjv+IqZRuB//1vkeUmaBIScsGDBe+RTnLqhgO7zE+8p4Nf75 RV2f834rqskSo+7KkMVDFc4qJf8ATN8SxMqZwmG5HpzRNWegEZt3tIP3ckhud/32bcoHsfXNV7eI xtI11NuDnIY/Lt55z696Sk1safYLMsQSVDuYRdVZchSKjubuONzHA287dpJXGeK0jPozQ//X+MyH 2cdcck8qv4UsIgdZfJ5kUDfgY5xX+/Hkf845XiW4M/l7WdHU4IHQ1IkLwvuGHAbDHoP88UASvEEY SAEsx/eHJKgfT86VmdsRxnHOXUcdKAIUI88biWQH5ueg9qSVo5w0blxBHJ5kbD5WJBBzn8BQB//Q +NWnafYYycKNoAGASOKS7nl8oRlDM7MFCggNgnHr2r/fg/5xxEt/LQ8DPce9RCVo0/en5GYLnHTP FTJ2RrT2L8CPATCmQJDvI6jNQS2VszzSyAG4Z9/mMc7eMYAqU3YtaFKeZbOwuLgowlidWWVQDsUH DdfXIH41+LH7U8aw+J5LSN5CqyTXBS7XdcBS+FXf0yMkn/eFfkXjn/ybjG/4X/6Sz+nfosJ/8REp vy/9uif/0f4q7YPbyCR5Q4DkR7T8wIPpVfV47jb5jws8Eg3eYR81foFde87HzdHWmjGtI9sjeSG6 ZYqPlP1rUkEaeSHkEiTqSW3ZeIg9CK5zW72Ks9w0UqIjyeUEzlB9/wCtVLyWI+RIobK/eD/xH3rn NyxHEiTrK7gQlBKoHGDgHBqnIy3F45V+Hfb5q4wAP/1Vzgf/0v4nhFFGvlTmSRQPlReEPGM1zV1G WeNVj+ZXwFIyPxr6g8Z7FlxIgRDGm/dncn3QPQ1LI8ksIiQ+xwvB9aBQfujUgW0jWbaCW+QqeR9a hjk3qVB+ZSf90VE9iiXJgWNpz5ij/VL/AA5NaSSKiRP5OIXcCVifufT/AD3rID//0/4m54IJyrQ7 so2AxXFVpYJYArRqGJOGJ9PavoDx1psSwgS7SkaCQ/KCwwc9KuS21tGgWZlDq+SU42560FOTZkXR RS8MCl1AysrkA/8A66WBgbcxsBvY7AXGCMD/AOtWXIwUnHREMqOuxXLGAHG0g7PetO3e3Tf5Kqxd AhJH+rIPb/PepUbuxqndH//U/ieufMjX7xG4fKP4SaoG2eTc7SFht5DcAfSvZSb2PPIYFhtJxyZA DvXcML9K2YEhuDwqDznOEB+6fahpp2YElxDAUREZ/MhJEhzhc5rNWQq0zToH2ghcjPbAINICtZxt xPKhKsxAXdjp7VpF/LjMYKlJDna3JX6UAf/V/iUayVrSe4GFlhOUReS47n2/+tWZb+bMTguGHzAj tjr/ACr17Wdzz009jbsi7syohO7Cli20r61pSKsKlejt/rGJ+Vh6VnJPmAp219FFby2cNsCJ3JZn ++RnoD2rKkkl+1xqHZt37p4x1RfT8P6U0mpsC7JbJKNoly0R2R7xg/jVdbYoVVNwlSTLSbsAjpxS kncD/9b+JZY5reTa/wA2/JVyclveoHiS5c5VVO3LSK3WvQtbQ88Zb2UX2iKOJ2kQgmUscjI6dKtL bSLNkrl2O0IO1A4xu7F7z47do4p4P3mSFGTlj6EdqqXFpcYVxgc5YA8CgtwSRCoII/dnevJK8ke9 EZPmlWIyTnNFjM//1/4mroTKDskHzAcY4XFVrPY2Fm4XJ+dVyAa9FO2x55bkgi8t5I2LDOGB+9VN 7TYdq4bcvmbwQSg9KQEFvM8MoLBMIeknR66mO8tZopY5IAryL8sgbCw/7oqJtWsBzV4ZkMcUExbC EsA3BHTn34p9vxCiTqiHoNowWHvWQH//0P4pY44lhVZSAUJ4Aqq8MUkg86SSNBnGxd2a6DzyskJR mAk4DbgpGGxVaCC3mvHkdjAGbBXdkS47+3Smld2Iekrm5tEQdDgoRtilHzY4/pWa32e1VWUBw5KM GGd5PUit7W0FKTWiJFWRUEnnSxxqpWNIuSfbNPkkBiE3KkccfepqLexad1c//9H+IWO53s4mVgCd sRxksc9qm+ziOAr83z8Bm6gV6Sg+p55LFZCBhslwrrtCsRzn1rRe1jhhISXzRjDjbjaT/n9KJKzA y/IPmg+YcgcBuFI9KsfugpYgLIpO3HzA54qQHRPJEpRlURydMj5hTJLuOGMKnyylsINm4MScUAf/ 0v4pDMhG1nHnbQjLt68Z61yt5cbrhlZSVRsH+VegeeaNg67kZmZ42GME5ZR9KZ5qx3JRGkECzZ2O uC/pn86ANI7J8FY2jZehAxis10a4uVJkfEQxtcd880FO9lc0IgF3GVWOCVUA7gQO/wD9akmjtMs0 Cu0QQby64+bHOPxoJP/T/igNrNc2sUSOW2kbCwztU9cCq6WPlRPkl9rcE8MPwr0DzyEwStKCp2lg FbI++vpWnNpUkVtEY3EQZt0pZc5H+FAHPrCdsyMyqA+AucA/WpLi0jRI2jIDKctGOfyNAGtCkVxb IkiCFgCjsv3nGeD+X8qoPbRr+7DZXO1XUdKA2P/U/iol02NbS33XsQ3H5Yo3DNx61nMka7wjq4Xj cxyRj0r0Dzk09jNDASusq7HILBm43Ad6S3uImkCuSBv+UgcH0oGXfs8YuvtE75wpVYycI3Xk1Zhj 37/OiURBcJt4yO1Bg3dmpDFIqBphwmBEMdF7VBLO8Tq5zMoBAQsdij+VA4uzP//V/iWjvUeO5don ZlU+Uqru2ntVC5nkYDCuBtGSy7QD3r0La3PP2GWkMisk4fLRtuRSuQT75rReCVHZrtWSZj5hULgg HkcUGDd2bUGp29lZhY90V3I+1i2CHUdx71nXWrK42NFJIWba0isNqjH86BHMzsXlkESEcY3HlqjT zhDtyPkfIOOaAP/W/iAiffsi2S7QPmcDAz71PBbBndYz8ucsDXoHjhHE63WAoliU7lVxiM49RW3D p63Pm3Fy4QBSRGi7RFx1AosgKD/Z42WDeZPNyjbhjg8cfnXP3FsLaX5wHG8hSDkge4rOcVa6Gnyu 5oWixPIhjKuQmT5gwsVb/wBjjkiKtseRTvViuc1mbn//1/4jI7R7mYQToGMk2FjUYA96tXFtPHvj Ukx7NqK3cdCK64LU88iayEQXzYV+4DjqwBFV5lZQih/3YXdgfeb2Na2NaewtvJNAkpHyidRhBwfr mo2kNxJHHPIMRjJ4GSP8ahQVyy1IQIx5Ee9V4xIOB71ILue4b93CvlBRGdo2tkAZOOlWZK/PY//Q /iKmhMEUrq5kKnIX0qnbyt8/LAFskDnHrXbPY5y8Y0njf7zMWAXIwhHOefyq0tmYIkeR85J8gNyG IHSlTQGTeLcynfgAKeR0A9auaSgt18qcr5RYtzxkf3f51oBJfi3kl2rH8uP3arkkfU1Xh3BwrqCg 4UE8j8aVlsJq6sf/0f4g72Jw0rRqGiXaCOpjz3/OqTELKEDtIqAAsy4z7YrrcGji5HYjDOzPGsZe MHJZl6VqpYpApnYqCU+QE428enrUEGQSYRIrxR3Al+VWdseTyOR71Ok7oVV0DIjAHYdyr6HisXF3 0A17PUcSOV+Ur909B9ammngeKZmw4xnGMOW9RUjjo0f/0v4jrcQzloJD5czx7oht3BiOxPbv+VWz t05GjmdTLPEYwh42A9yaDnOeiuAsi26q8sbyCPfjGfpWiYY7q4jfEaQRfKyJw5I6bh+FBrB6WZZm AsrHz5be4n1BroxI8TKbOOM8KTxuz7Vlm3jkl3MeAP3jbfvHvVcrtcJ2sXxcRB4o1aN1+6y9gPeu huNFV4lmV4xiEyBjIMDjgD3PpUmR/9P+I/MVpHaypEySIxdkdeJcnkn/AD1qpJNslVQxjSU+Zkch qBRXKrGm09vPtd1dXjTIZ12iX1x61RaytZZ45i7OoO5VXt6g02mtGMnv/KSJY41+992VT+lVG+0L BFGroWkHDbslRnv3pFKLZLa2hjYsZAAOqJyzev4VVuVt1ZpokUOjCMIBjNAmrOx//9T+IczvsWRc RmIgurcE89BVmSzhuoprh3iE4w+F4kkPoMUARGaOeB4yYYXjgEEcXlbJDjOST69Oev8AKshXZG2K fkVcZK4O7NBnPoacDyhZBcMzMybkMa/Pj/Cls7aEzDzMqUy+6QH5j6A1jJWZLk2VtQvBdbIQTEEy M9C31FUFe5t5RB+7MTJw/UknvUmkHdWP/9X+H+1EUYlZ4hLIfukfKKHjt5VJkaTEh4YHKj2FcsnZ APithYFn87zLdwCY84b3zUGp3kaOgijIjL98AsB0GP8APSqAoyX4UNLJHsMwITaMDjj6elIizOFk 2fIwxyeT+FAGmqX+nwTGW3VYnRXMkkZV7RCQQzE9AwIwfenz73TyYEyQolkkY5BH+zVQ+JDWzP/W /iRsbFrxJUSJ2WKNXmlC4RecDn1zVm4ieCMpLIZHwMJjJI6daCo6SQ22W4j2hIwixHe2w7WfPbGe a9O8FXvl32oXNxZfaNUdLa00uSVCDAu8c7h6nAwewNdWFSdaK80Y5i7YGr/hf5H7LfADR9T1jwXF BPYXDQ6IipHLHD+5nuZMyFnxySAFUD0Ve1f16/8ABJnSPsPgvS/EGT5ur+Q17FKQnks8MYCquc42 8n3r+svEybw/hNh6XdRT/B/ofyz4C04VvErH1ZLWKk167fkz9Ff209cn0L4Q64sty0No2nS/cZcx vKpihcg9cEtX8NXxV1d/Euo+Jbgawl6dA1S7a8j1NPs81wxkRBHHxhyoO/5j6gdhXtfRew/Jk+Jx FuqX3L/gnR9JXFqeOw+B6p3+T0/NM//X/ka/arWa78XC0uEEumTaUktpPcnfKroymdQ3+/8A+g+x r5Abyn2RxuVMH3I1HGa/aPHepzcd179EvyPyzwup8nCOHS7Fk2szMpdlQ7QQAdw98/4Vu6fZrGs9 wZJJSgBCFMKuOuK/DpvRn6IlfQ37O0eZWnkbcJMCMDqF9asyRxxKYlBQbsbV5auaXwscFdj4LIQT pNFGiuerqArH6mtyS5liVpBCx6JJnktnjiuaa0Nj/9D+NiytI/MW53SLEkZ2xqfk3H2qC9eO1u0v Eso71+BtlJAH1xzXz5zj4JYIzF50UULzOZfIjO/3wT/jXRWklteW7SRqVtVYxkPGU5BwRg+9BpGN 4le6t2uJttt5ZW0QS4Vtryn/AGR3I9BV62gso4UuWtpZb5lZIllt/LEeRgncf/rUmtBcjvY0rG7l tIYojIioGyPkDFT3z6/Sna3GLq2SSOKW+hhAkkEMe9k5wWK+g4+mawLUFazP/9H+R/bcWuly6jHb KunYCQTznMc3GSu7sR6VqaRc/wBtadZaoLVLN7qIQEIMojIAGx69j+NfKVPgZHL757J4ZWPVEa2s GR795RpybzszI+ETBPTlq/ug/wCCOPhG78OfBrwZbatpiiFFEMjnO25lVE+ceylc/h9a/LPEOrGO Gw+GktZST/8AAWv8zpp0rrmfRr8T9/7fO0NwcjcRjAqyPmDAAZI/75r5qk7RVj0Fo+UZFEAGwct0 68j6U3hc5+92rRNrYtb6n//S/oT1O5by4pWjH7lQYvlwkuOu6v54v+CuWgafcaJps8iyz2elXDar PM1qotIBPKFEQLHg/KBx/wA9PTNfyvQmo51Sv3/Q4sZCMsKmz+T4aELy616wghlee61WcR6cD5Ud tGXOxjnPUY/CvNpNOtdVS9ee2tbI6fcC0NqGAlZozgSAdeqg/jX7pQuqaZjSf7qIWflvBevfLJqU EJMLW0rYaTaMYDdfTmubgvdVht7iPT7EP4d1DUyzx7wp0xkBAjBI3OPrzkV0xlfQ2m9EX7WzM83n CFZFtYjPMrtgbRxhRn1P+e1tbaSSVkVJVhdFdplGdoIyuf0reD6FQfQ//9P+Nq4YywXNssuZ7deA yFCMe/0+tRaE9zYTuyiX/SI9jAjjGc5/SvATa2OfY0L+7JkM000oijbayFS+zJxnH5VXs9WlYkW7 +XC3yuuMeYP6ZxSMZSuOCMxlfTxCl/B/pEhP7tUTIG4+49qh1KG61D7OslzLAB8xXPySZ6k+ue1a QeolJopahp76fpjQQQtPvuU+1zyDftDf3R1GAppht4dQu7CNkmUQBI1RX2+eqDnep4IPPFaA3d3P /9T+O1TZajc2M9oJLaOzJgeA48m5KHG5uO+Ogq5qlojLay+YZG83y/K5AXpyO3r19K46fU8h7kMt oY5/sMVvIskah/t0jkEkjPPOMEVl622y1trW5jndxIPOntYzOxzxlhnAA55rvo7oErnjGq325Joo 3eWRZtkUfBWFc9cf561zM0U0bwLDHvnMyKAX2BssAcntXs0PjXyMXG8ZI/cf9kDVbRdLh083flxS 6ZJDchYmcopRGRlA6jcqknjgNX9K/wDwSX8ZXM/jqS0iv7WKWO5FpI5DQxXq25YIXXkFuVz9BX90 Ymn9b8E3GOtqSf3RR/JfB+LeA+kPGUtOeUo/e/8AgH//1f7flZLzwt9plYI11YF5ZNu6NgU5IHvg 1/ID/wAFG9PtLf47apq9hYtZSNDNZWscUeIpI2k85s55ySi/ma/ePo7VnS49aX95fefjH0qKKqcH czX2l+B+Zl8lgXa9uUhiZizXF3FF5tzO+ANpGfmPAH4VjWVqupxyxLHJaW9xcGGKS8LQyKvTcR2B PbnpX+jNJ6H+YOIMe+uoNJZ4E0+P7fbAWTrb5kM6Ftgxj2JrB1Rp55VtILeaC1bY/mSRFXVRwyZ9 +a3Odq8UdIdUlst0Vtp6pZQwLFDPcQ77fDDAVVHTAHXtirOneKrqQjTz5UkV0/kiOZC9rbnoGB6r jPX271pGXRmPK+Zs/9b4ynt9On12xsr64mtUdN+pKkZEJiUg8S4wfYD1rH1GDTHkvptEuZZdN+1M 1rOgIMGOApJ7jGce9f7QH+JjglGy3M2ya5s2ijKtObiTZG4Hzyk9z71fuLovrFsPKEtpaxB7/e/7 yIjqQPz4oCMXHcdrd9HfWkdwjHdbybzEE8oPHwAR6nA/HNdLdLa2mitqdhPFEz3UMFrC2HuY1kcZ 9cAdzW0PhM2rOxS0+O6Mt697FBdT6h873JbDxFduCAeOi4465NYslhfxG7u0hiuG3CFFEoQjJ6gZ 6cda0jzdCJK6P//X+GJbLWHgjSPUpwssJFxYxyts5P3T7cfrVaCfWrSwuYo1byYS8UC+aJIicYbj sckg+lf7Yq99D/D6oklY0o4JrbTtPXYscLWonW1jbzUkfPzSH0KkEfT1rJnVr1nW0RZBFtecA5ji XcqnI9tw/E1ucNW2pZvbFrB7S8guFkZ4jG1ksY+YgYDZ9fzqqza5HcRPqGkmK0u7Lzrfz3FxdKyv txgcDoSB9PUU9TmOmjaaxtd7SxZAEhiZgrJu6ADr+VZE881xqkV9G0Vml4v2TUVtkPnTjCgSEd+n PritYu6Mp2uf/9D4R1DSvsNzcQQ30F5DfxAXRjVkeRe24EZ5xj8KtpZlRZ6NYXSqZfLuQN254Yo2 /eIew3DjHuK/3AP8GHuya61hZ2msJbR4IbS5C2MrMWZW4AkBHPHP+c1JJps6xeYsvmBj5jsGzu9/ c9aabjsIn860ljSEefL5BDZmGzJxg4x+Nb2h2F4Le9NoTALiQSQrM3K98j2Petk76ozm+hkTP9ru RHcbY5GkETlRlUIODx/nvT9MXSFiudOlt4/tv2h5Te7zHMg7IAeP05rTnZmf/9H4LmFys8cUuAHk OWY4LY7KO+OMn/Gun0zT5pJY1RjtZiY5Jx8keOwwP0r/AHMU+5/gZKVtEXEF1cX1zKtm7tbsY5Zl Xy4YWz6epxxSzRW92s0FxcvNeyfcc8eVnIB9MD+lWndXRySd3Yy7zT5rK1tnBWZHkZHc8EBcdvfN XNyW0Fp5iSk3RU2+xPMUqcgsxHTkd6ZjKfREktzFp8sJaVJ5ppPlsoz5dwyDGW54wOe/aq9tqjRH UXuSWa6IjidgIzboOo44OcCgzb6s/9L4w06M2dyfLi86zkk/0aaZvM2NkFtp6AjjPXGat6xqGS9v ZHzJWjG+STEawvnlVIPORX+68dkf8+D3EgTUlsGt0niClRJPA5DBkONxHX8PQ1XjiSR02yLEsHzP yE3Z45/OmIj1Gzilu7Sfy5EewLSWciTFYy7DazjBweMj8/WtGyuLt4r6ea+tTst1ijtrqAzzv8w/ 1bc4x7EH9a0p22E1dWHm0vpjHFtR5GnWZbZflJP8JHfj+dPmsZtPsb+bVNljdLcAWNjcJN9tkXoX zt2bTnjJBwKt9jJxs7H/0/je2l8yWGVlZDtImCkgurDBH4g1MJ7QTW8Z06S4jVJIYzBMIZYmPRmO Dux6frX+8B/zzNJ7j76KK+jtdPSycRREfvGT967jqSPXqPpVueJtMiaMEEFQXYfLuB6cf56UE8iM u6voIZHgikSSJo1Budm3ezAZxu5GCSPwpYG+y2f2OWJJWZQ0bOD5g44IOc+/HWgmUVHYQFZY2SNA zhgjluFjPBpSbpMpvCrkHYh3bsdzWlMzcU9z/9T5CWCC4KPNA6qZEacwtiV9pHRu2QMUlwC9xM6G RE3nyd7ZcL0GT61/vQf87rgmVgVlDqbeSNoyQZnkDLN3BUDp+NSQhSBD5jiP7zoOmR0P4c0Gbi1u TPYiC3nu1kVpJXwRuPnEAdSPT/69UtLuFimc7lZ5E2MrkbQBnn270EmhqUfkxWs4lRo5CQ6o2XVu 2R6EfyrPKu8IcMyKzfejODgVbmwa0sf/1fjGa4M+2LzA8cLFIpSPnYe/+FTo0cDRDZ+7wDt689/6 1/vQf86so3QXhW4Ym2/djr5Q+63sKfZG2iIS42qQp2KxxuI5wB+Fbx2Rk4tC+eFkHlYUOSUGPmBH of8APSmQRpctLDKTHKzFkA+8555J9sCmIYthDHFP5o8yfZiF42wmdwzkY54z6UQyLHAbMQMuBnzW cls5yaV+wH//1vjvy5VG2MqJAv8AF0xU0lxLa7ZElJllXywqA5GeMV/vgf8AOeZsVperJK7TPE2Q iJKcrnrhVP6/jWnFa3VxL5JVric9BGnPTk8elAW6ET3Mql7OS4DwL/qRtBlGBjluvtj6VUt7QxRP 5jGeWQY8x/l289gP60GCV2WVnhtxDDIroGi2OSNyBv4Rn06frVhIgcknYVPyjqKLX2K5Gf/X+T75 LeBYInDGUcybAOCRnGfwrmruTe0EbRHa8ohyFztBPVvav98nFo/5yXFo1rmC1Wcrbq3k5xGrZbAp rROIHedSiscW+Bw4HXn29qIuzNIxsVbb7HFatEpQGZy3mJkmM56nHWq9m0trL5kRBcOGViu4ZHfB +latXVii8JZpZJGmKeZIxbOAM1EJ5xL5ax7jnG4DkUKKjsTJXR//0PkOCNdhaSTfLksfQd8U2aOR E85M5BwMV/vwf844lrdPIyxy5QyHZuc4A7c067hNvJJbZXaGwSrZVvoaAIVs5Lm3ZLchDD++bGM7 V5NQwmWMEy24jiP3JW/ix1wPwoALuRWEUasQZFOAAe3+RSxW0qrFGJQzOOWPBX1B96AP/9H45hjk hkuFUnOCmT3GMGqiTbHa2KhVbneByK/39htY/wCccnkb51iLFoyu05PzU15TFKoHyRxoYggwFxjG Mf561VtbgMtSYn/d7gHOOnvWvNIkQBeVjNI2CTyAKYDHdGCRRybnC5bjBHXn9KoAyQSkBy20dznN AmtLH//S+QPM8+38ticls4HTg8YqJFnumMavGixj5i52s2OgHv8A4V/0AH/N/a2hOoWEgn5n6Nnn H0qK7gEhSZudrcZ7UDsSSXVpFALaLf5znLyFsovoFFKYsbGz8x+6B1NS4pu4gRwhKyKc56Dr9aHB Zjg4RRlhnGB/k0lBdQP/0/jicuSEhZeTyxGeB6VcigmMI3ocH5BIB8w+lf7+On2P+b80bqRXtlWS QNKqiNQOu1VAH8hWORvVOdrRf6s7cHPvSimpagSzXV1JGoklZwD83o1OWaSYEMxCLjbEOGqXuwL1 vLGJNyKUUjBBIPSqV7blZRJGvmPOfljj5djwOnv2qlNpWA//1Pj5rbCeXNE0DZ/ednHbFJNI1soj jAa3/gDjc4A681/vwf8AN+TnUIiEWJDEuzYwBJzxgkn3qa3iG8N5mYyc4PSgB9yyfOcgED5So59s VXW5lfy2bJ8obDxjcBQZSi1qRzSXAkEtrJHHcIwkQSJ5gOOcFc/5zT43uZDNJdBX8xt4CoFCY64x 260FQ7H/1fkZbppDhcKkfynaAMY9alZWji83KurNjBPzflX+/B/zflZoVZXbKoANwUcE9sfr+lNM OFAiBGeaALSRsqYzuPTnsakk3W8CLMAZJGxGhPJ/zxTja+oFG/EjMqzOwwgCc7gB2qTTcWLROZEm bgvsG1VPet7dAP/W+Tbq7iDsI0wDyAByaqtIsqK8UflSqeN+CVIPUV/0AJW0R/zfjrWFlEhlG8nu O1UZ1cTRrCwBDguh7rnkVEnysDRlYmLC4+U4x0NVyG2FgpcKfujqaIaRAvLLKYoVlcQoFyI8DK5H fH/1/rUbQrJIoVlSUffcr98Y4/Kpc7rQD//X+Tkhh+1B5CrLjYTjIBHHNRSw28czeWANzZYZ79K/ 39U11P8Am/LUDRIGOT8rcI3T8KrTASzK/Vf7oPAq077AVpR+8RcYAbKHuKupHIOZnX/Y9cUASl44 xkgnPHH8NZtzseWJZJTkttXnhfaomla4H//Q+PnhW0vXG8O7KYEt2G45ORuB/LpUM1tcN9xWLhuU HUH6V/vwf835Na3F1JIZLkfcARnbsB8oz+QohtPNeecOkieYVRl6AD8etA4q7FdocmIO25OTk5z2 pJt6T2SxuCkhKyJ1dmPChfxo2LUNdSxNLJL8rOfl+VCedoz0p/kmCFZg6uWPKZ5rOUuiJcWkf//R +QZEmug21RG2PkZRjFQ2m6Obbv8ANZWxIf51/vrTWh/zgWZYvbkRnCoWbuVBNAY7P3R56mqaT3LU NBh3ygfNyp5GalV4I0kWdTJuXKEDO081k4tByWjYpQCSeJ41kBWIZwx+YDJpTboYghYCRmwoH3+9 JJvY0P/S+QPLKZUj7owcjFMkJWI+XtBBwQoxj61/vjrFn/OONjLLGzGYBx91QDubPX2qhvGHTqS+ cZ4HNaRk27MDSiwsQMvzE8EdxVYXSpNu8gMF+VVwVDDvk1YDLeNLu4cRlYlJ+VGfofQmn+U5YIcD aecj5TQB/9P4/laGAAKudwydo+6ay5Zgf3ijJzgf7Nf78H/OORiWQjYCWyfvc1q2wUoyOy7cAlWX JbB7elTJXVjSn1JjcbHVUWNz/ES2HHoB+VYkpnaaV3JBZzhc54zxSS9w0E1SX7NotxLcqgihgYGN 8Zl9OPrg57Yr8YP2q1N1rl5C2+OK4TeZlXbjBA+T24P5V+Q+OX/JuMb/AIX/AOks/p36K7S8RYJ/ y/8At0T/1P4kbK2W0vYxJO08puPLiBXAcHPX6CvQpbqxe1mhu4JmUQOitbkbg+CFP0zjNfoVZ6s+ aofwkecQp5IeOSWaNguYmXHzHsGpjvIFTzP4OpXgmuU6pRSRXVndiIyTjgs3ApbyWJgiQjcRzIT/ ABfhXOWJCGuIyxnEKA4KSLycf3TT4ktQ0sSh23rkHkKCKwaadmB//9X+JCOcQxRs0m5t21BnJGKJ VmlH7nbu6ux6r7fzr6g8cg8mWIfPgtjjuKqPI+cKwAI+bYOQaAI1aWfbHKx+X5Rz1xW3awWio0ax fNj5yfvMfr+HSomtAHzW/wAm2VP3Y+7uGKoxEs0kI+eGHAAXnnoP5VkB/9b+JJJJI02L98c49qqy TPMQiljJG33TwVr6A8iztcerTIu0gJMrZEmeB6U5RPLJ85V2f5AG6NQIvXdg52CNgAQN23qDWf5E 8NyqEHIO2TOSv/1qPIDQvWE0KJGB8pwwHXIqrbwGMBxhdv3lPR6iNlJmtPY//9f+Jfz3uv3TlVK/ Nx/DVoRBwpyGUjAAGOle9GV3Y88a9l9pkDblWNBgRqMfWoxphEpeNnilHMeDtVcdaU1eyAlXa6mN jzGfvg48zHXNaV7BaQ2VrdF43+1FlkhRstBt45FKUbLQDmppESYPEWKbenQVUgZ5phvUoFOMnj9K i2lwP//Q/iWmlUq6I8ke2PYGYZFQQKHBCgruXbuHevYPNSs7E0d1DbqLZoitys255FfOUxx+tapm inRzgOqDG4HB6VP2yjJuf3DQTINyKxyM4C9jVSR1MyyIdp6lvWjmS0AvwMkropDCQneWPCtTp5ow 7lGLzI214xgKmB61HNeXkFj/0f4iru9M7+UocuqZXC8U2zt7gvtdTGHXAz3Br0na+h55urbpBHGs MIDbtryFssfQ02WGPBLzbZc8bTg4P41I07O6MRo5orqPzJfMcSbVBOdo9ea6CWWCNRE8jSx+UCZI 1wwbGcYPbNBcpP4TNMpJd8OsbDaWHDGmo8K+bI4KLCoycFmfPHHvTbuZn//S/iWF1GFwQwLr8pK4 Vvam7NkeFP3eSFPTNegeeXo7cSwedmQeXxKMYQDtms2eMxNI9uGkQ/eVjgj8aAGwxR3Em7qVAOTw icd6lW2lkV3QttPCqenFYNasCpPDdxvHuhARRy27Bx61at5VKMsqIFdgBK/BXHpSA//T/ibQMBJI dwCcneMq4A7U83oUKkez98hzISPk9gK6bNaHnlZRK/8ArAqttwCOppIrEs6sRhd3U8c1soqIGles sS/Z1wAAPnU5B9axZ4UO1zcM5A+WMLwv41soLqZzWtxpllfasRbCDBX1NIpkLOkilYlXDNnnNWVD 4Uf/1P4l7O2IAKgsAu4sq7mUGtCeGx8sxtcOs+3KDbuVvr6V7B55myWoMbbmyxXaGB4XFRxSXEaM HDMgG3JPP40pLRgWDlYhkhnbBG7gBasS2oURmFklLKGLRHdsJ7EetYCV7alW7S4t3EdxGfMMG+Ng PkbPQ/596qxCTdFmMMic5YjGaAuk7H//1f4k3y8pJOGEZYt03H0rMtTHKW3QsZHbgsf9X65r0Dzz Rjht4Myu3kon39pyDUs1iZpYcgxxzLlJscZ9P/r0ASzSi3WNFaRWiOZI9gJlx65/pVVXS4ElwxMc jtxGuBj8O1BskuVIXaQYkicKVceYXb7471LBLbiUqshO7KNEw+RselBLh1R//9b+LGzjnS1uWVHe XcEsYIMG4lJ7KCRz/jWzrnhjX9B2PqNiYLSaJJYX2v5pDpuzICoC/UEjjrXc5RjJRb1ey7+h5/kc wl2isVIR2X/VkngEY71onXFeKZJbVHVY9qqjnKkdTVAc1PbiZhLGyFCBI6MdpPt+tOvnIaJwFT9x sZI8bTxxn9aAIorkRxIZXcttw2BgL2zU9vECC6T+bFvLMoXHPtQZSd9D/9f+Ja4LFAqN5cnIywyK kV4QisUBdYtmCNu9hxn8a9A8cy9RjLIpmJV0HC7eme1VI7fcyvvbCL8645/Cg05lym9JFbzWqOG+ 4wIyfm9MGo7Yu10TLL5cSqBGp+439KCLM6e6liNsfnBd027hxtxxVPSNLl1MOrlo0+5G7dGbrigq Cu7n/9D+KcpHaXlzaTK8Jgj/AHZWP5JmzjYemPXNUbtIZR5Jdg2d3HAFegebJXWhDbwmOIMX3FJc FcYAA6U2a9lNzJJOXYAf605YKOmDQYmddTqN8hy4df3bjonfisgXZdvJEjKc7tmcZPrQBLFHcrOJ lnZUJ3Sqo649vetNyGIki/1RGSpXBB+lAH//0f4gASwMoaQbDyE6N6Aik2XEJjuPm2mTBRs4wc16 B4+xsq8SbJCeEO+RH+UHvircGox3D3UlysVtEV/crCMZHoR/WgnmRQvNVtLlLeCO3MckQaN7hsfM CeMenpXOzWjCQ4YhN3B6k0NX0ZRcUeWkcVsiEE4cnhm+tbsM0tp5fPDAKG67cdaWiN47I//S/iTv RIgWa1nkSVW3F8fe9qX7dNLEjKjPtX94OjeldkHqeeWpLWORRIkxTemQGOSpxzxWTLb3SNFE0gxI c7yB0zjn8qrm97lNINWsJKrOSsTb1T5SyDioZYDBtfekhCBgBw59se1UW2luXYBPJbNO3EZO1lPy sPw61NZSxRApv3ZPyIg+ceuaDK9pXP/T/iT23FxPNHAsYBwu1mAKHjrmlYQ28bqkYEqgBmHzDjrX bNaHJzK9kQNPHFbSMxZkh/eMwGFX1AqKa5nuoYYU/wBVH++iJ4ZSQMn+VKn1LLlpe2UkMTNIu9W8 uUtgqxFOms3CcTRmMyFvl5wPStAKhFvApCSMu8cB/vNis2UykDaGXafl3cZoA//U/iTZJJgs8IUk xBJAMIpwMHiqKQRiJjKVEm8k4PQetehsc5V3pjylZmHmbiwXBIqa8DOQfNYrtAjjIwwPfIrnMHuz O8lpEKspUrznn5/84q0oSK0O1gqlgrh+ufpQItfZm2h3wQcDdH0IqGZJN6CHfyQrKozkDoKwe5rG C3P/1f4gmtJ9wmbeobjGOmKq3KyXBAVSWXC7qDnLiTCJFtywjaP94HVc+W3rTbMSPLI7hiNvMm0q pOe9OLSeoGut08cQhMY8tXDhieQT3xTvOjkeZfsyMJh94fKUJPJCj/PNauSsO+ljAPlC7EVvEyhW HmOVwSPWumOpTw2728cCGOOHzAd3zsef5cfWsSobn//W/iBlvZ5hsljViOAcfdHtUtoYi/lTQkgj Ebg7grH/ACaqDswNaR1ltDCwZpIH2IzgjyU5yi+xJzWIisZWghXGTlsElSDWko3GrdSwscobyMEx wsWUY++T71XkBt5gVjceY3z5HIPfFTKNrWN0raI27LT02y7GYlYsg5+/n+Vc/q6fZZleFm2uoHls dxDDqfxpwVjKa6n/1/4grdQ6xG7MiiVhsXblceoPvU0hWGeRRujU8wkjIP1rVwWrAyXW4Wd5p1LE /MuBt6dKmfM20/cXHzMeCprIzqdC087Qxw+TcsRjZkjkgdvp7U53MkEvls3Cj53POT2FFjMzlMME UkrsZpUHMZTIb0qmsks8iSbd0RPO3gispRtqhp2dz//Q/iAtmO5I5Y9u47VbjB+opr2UiKIyxjt4 5SyFP9UCeTj3rnt3FfS49UWVsBmkSPhy67g3pTRpkt07SOrKgHycdOfSgE7q5Zm0yOaIRnc20fIB ygPf+VQpaTwIGeNrllxFAinsPWgZHfmNJIvOMyBwss6sMoqj+H0//VXS3l9ZXc62tpPJeLbafAHu VtRawnC/cXHXbjBPeqh8SA//0f4r7KW9ismS3jeCOWX964TCyqP4fz5rGmkvGm2vCyWwfDSBhI2f p2oJs+c3rGISRuu8O5Xy1kK4cAdP5V6J4BgW41nT7a5mElwt9HcGHfsLJC24k+owPp2ruy2PPjKc O8l+ZxZvV9nldeT6Rb/A/ZD4MkDw4kEU17aOWEiCKZkVAifvGB6ElQACewNf2q/8EwfDlnF8PtAv HhtpYZtCWPT5ozmG7aIKrS56EhVAH+77V/UfjPN0PDvAUejt+SP51+jrTjV4xzGu91/mz0H/AIKR a1Dp/wAJLxbkSXT39lLbafZRoSzPH908e5z7V/EZ8S54tS8PWeoebZTzXMMkl1JYNKhklaQuHnJ4 LAtgleD5Zr7r6M8OThKtUa+0fHfSNruXHVLD305Y/n/wT//S/j9/aJdrvXLmRL37Q+lTyW0lujb1 Usd3yfXcT+NfKcUVysxuPJkTOVDOvA+tfq3jTVeI46xWu1l9yPzvw7pez4Vw0bW92/3mjBLcyXMK hcJjEpbgfWtcXs2n3MWyGaeGc+WY0/ib2H4V+P1FbQ+4irSaOxt4rq682VPJsvItROsEsvlF+g79 ScjAp0guLu706KO3KvI4+1PHzHwOxPviuaabQ4Ky1Nk272/2hHOJFOVGdyp2zW3B9kubbypcF5Ih F5yNho8d8etc89iz/9P+OaSKKwhNvFcSzR78qJAAemOg/wA81jeXl2Hm7m3bvJP3hn/P618+c5v+ TarAnlJHJOvzEMu6Ye/86tTGXy8iMxwpHn7IrcE45P14oNaexDbRzFBehZQijKeXGW24OO1bt1J5 0cO4kDb8w6HPGaCzOkMpUbYo9qttIBxge3vVhJ9Ut4mSzm2xXUZgmRZAnB7H29qynuVFJuzP/9T+ RuWbUNQi07TbmO2g0nToBHbxQkkb2OZJJAepPtWrplpHDZXFzNqslnZWM6pp9kqgI0rcMSOwI718 rP4Wa6e01PWPDf227hiNkyxXkF3bzRzo4iIZZkZSD68ce9f6F3/BMe2ubP4P+CIppzO9zoMRuFSN UXMxMjSgDoWJB/E1+ReIzbxeCh0vL9DS9pcq7n6+Kz7FQAKE4Y9+lSqwLDacg8E+leFCyVjr/wCX g9yYwAvUnFCKw5ODn2qoyvoaH//V/oUWWNrVSytKkP3w6fex7Yx2r8N/+Csvg288Q/CDxukUgsp3 kTV7CK7kCRXFuH2IsbD7rJuD4PXFfyXd/wBqUXH+ZfmjzcwTllzjHc/jvv573w1rl3ZXLzXF1NcP Jd3wUpnPUZHH4DpXAa/DYXDaj5VvJi+UYnzi5jYEHkjqOCMe9fv1B3pRCmrU4sytKsbi7eSSSUJD bwFTDMdiTtxhhjnIwaQo0DXVs0sSkYkVU+ZXGOS3o2c4FdcYpWZpLoULFgW8m4jkj80lUKHBYEkc elWGD2dxJafaGt7NIA8LykySAgdGbHc8CtoRvqEXZn//1v41ote06W1n8tJnvN/luk8ewsoJ+dc8 /n60+01SNW2tC7gqcFMDYe2c9vpXz5xSl0RbMk0Ox57UsZ8qDsJQfU9PzqoLFobkNGQI5BuRAMOh 9+xqoxuZt2VyO9aCz3b455Lm4wuM7FKc5GcetVnuHiiFteo0SxETW6yclgcEAn04BFaRiohzIk1j xTAIdsKP9puv9TYQRsysyAZO7n1J59TWbY3jRTr9rVyy4kLSAhULdg3fHQ46VVuhm5O+h//X/jit LqLUNQh+wRwWVnDn7UC3G4g9B15OTXRm2aOGUvId6n90oOSo/vVx0+p4+xiQaksyX1tefbJJRH5a PKvlBGU/L254HStnXIrfT9Jt7mcGJpYVe5lhkGNmOcg89vyruobhGWrR4Trv2aG8uZNLt1Nncxho pJkBlXOM8j9D6HvXEX0mXCyBtqrucJw7juAfU8ivWpys1YzTXvH7KfsP6lZOlpeztNaINHSZYWhS eUhVSIxlG4/3gfev6MP+CZ2rSaH8V7fUHhVIJrlkaLywttM8hiEc20AY4Vxhe47Zr+9MhUcT4Lyj LrRt/wCSo/jRSlh/H7DTj/z9T+7muf/Q/t/0K5OqeD7F45IFSSwjhCxYXagAxgfSv5Zf+CsNvp+i fEKK8hkSxaB3OnXQgLwwOyRGRD2JZj8o56mv2bwKcqPiLCF9W3+Z+X/SZjCfAlSo+6PxJh+wvp6X aX11c3MEhe5NwFCK4OWYkcVW+13V5drLcTSPHKVlNtKjQO+BlduBwCMda/0spL3dT/K3Eq1zp7KG aCH+0rb7EJ7f9z+/t0uGwScg574yMkVhGdNZ1N7KB0uJEi3skMRSGAEn5RgYGOePatkraGXLaJjX EDRamNP2me1txvnaR/LCkZ3pj2waNNk05iZolVPPvZBDBz+7QY4z36nB71rGFtWc7VnY/9H4I1K4 kie4igkuLqcTBoYXUBQD2z1wP8ea6m5uLeDTU0+eH5ZLUeZIn7h4WblsDrkepr/aHlfY/wAUXFpX MnT2nnvoEikikFsoW2VxwFGBwD1bkn60ss+jafc3lvaW811dzK9xcRsrRuDwpcnH3QSceuKag3uS Zmj3xltr/T9QLXstvOTB51usfkK6hljyB07/AI1rwvKYGgkgjjsjIHDK3zAjgqB7YFdEYt7GDVnY htDvvxcR3kdvBFEfK81ShusfwjtyOxrb1W5ju7NbnTbVIJ1iEM43FYpnDYL+w6GtUuVWM5u2h//S +JI55NM1GH7ZK+/yPnaBhJHCcDII7jn9KjmVNQBmlLRJbyGa3VQIfPLd3HdcAcH2r/bSC6n+Hk9i pDBcxSxT27kFG2uu7CsD1z7Y7e9aJvbNri4uFiAjz5M62cGAp4GOOvIGfoa2jHmOOsjI1mC7tLm2 uBIrxTIZfsbqTcFAM7l78cZ471b07WrV4rV7SFrhJXMhkYEbR2OD+XbFTa2hzGtrGmRXEC6i7Qxx NH529ycMFPGVAJzkcZrJso5YIWv1VDNu2R5wcKPUdjzVwdnYTimf/9P4ejn1Ge6imgsHltoQzXPm RCbaGADM0gAwAQMDtu9s1ovc6bpi25VXfUrgSb4jGSVRdpzu7A57/lX+4B/g84q+pj381rff2ekI ENxPIconD7jwFf8ALP41Cj6hpMphuYpoBDP5beZz5Zb/ABoMpKzsb9rC5jv5YoRPPaRCdU3bYApP zM7c/kOals5Iy9zK1/LbzyRBLcJGS7luGAOflAH58VpC/wAjGa6kkC20k0b27FZLcYuGbkNjjcc9 M5qpfp5V2LpSk7MoLJCw5xxyRWhk9Ef/1Pi/TorvUJRDcW0Ns0wK2MkxVwrMQPvdf4elRX2uR6Ra 2AjvJriYSiCYLDu8piTx09c9uMV/uQf4ENmtLr/yRG1uPPuJl3XJMe1YumBzwap3N3C00Ty3CLey LxL5eyNMjhBgc/lW0FZHJO6RCbbWL2W1VUQW1pA0l6C25bh2K7fLJxgdePatO9u4oZIYfJ3Rww7S 4bAi9R74qjEgnmkedI5EhaOEjyJPLVGKsAck4z37ntVPVFEVxdQReVdor/u2tGzHc47A9OvAppN6 Izm+h//V+NtPi+06Yl3HZrp8chMbWbDZcQSqFLkr6HdgMeuDTDYGeLzAG3qNz54YjOM/XOK/3XSs rH/PePvrG7tLOG4h8wkx/OCpUrnoDn1/rWRbWU808k1zGFiW3wjMCMtuBx06YB/HFMDSKXbATNcJ NEv7uJACvkAdj+OTx60sk1t+6jjVhMEDS5IKg9wMdqAGLqF5BqMVyZpw8WJIZgcJHt4xj068GtG9 1hLuJvN2O00odWaXe/AIPH1/Knd7EyjdH//W+KnN0Rm1CvIrD5CwTI7nn8a21kEdxDOUCSQRb1SN 8DOCCWx1x6H0r/d2Erqx/wA9DTW5JJqsgiEnLPJIXDjs3rmqjX/9o5M0is0PEq4AOfQjt/8AXqxG e0cdzOhigaWNmIaJerYGSB/nvU0gihEMhbc8f3UJyRjsaDOp0LM96z2JVbZbcl97NGn72YngE4/D 8qr6XKrFrdcC4UGXzHG5UAHORWsLWsZn/9f44FzdW+N0gZXbp2yPariXEe4+cAxZcgGv96D/AJ3x zi0jh3K0jGQ/MmN23noPas651OKxiaWGxkuJDJHCzou77Opcb3KdGAUnjtn2oM59ia7u7WBIjYzT XjSuYthi2MFPG5uSBxnjJ+tFvPZRPd2jaUGuZ7MRm4nm/wBUwcPvVcf3crg9m60FQelilJNhnhZg VA2qQflWp1doYY0Q5hWT5xjLDjkH0zmgzkknof/Q+LxbiEh+CHO7A+6KtSC3k2sZArIMHngf5xX+ 9B/zrjbJfNlYpFJKUO1UT70mf7taIhtrtoklCRrFKeSmJOcAjPXtW6VlYBsNoJ554IdixW8TzJLI ckuBnYO/OOBWIZWkVio3bGKlguOelMzmiZPN3R8klRg+4rTSWBILkzqdxXdHJj7hBzg/Ws4PoZn/ 0fkKASTxeZFtZlPzIT82PUUkmnXtvcRyTtGqTRi4gRX3SRjJxnHfjNf74H/OglckW5ivLgpcSbru Ni6Ozcjg1T/teIzSJGkjghkM44QOCRigRVmsWjuEQnfI6q42HONwBA+vNbO1BArNyQcdeTjr/Org tQM954vMDSR+amNpXr2x+lSRyvPnYuEH8q1tbYD/0vkVbxUaSN0EplIO9uXQj3/GsoNKbt4WjYAn KlhtCHjgV/vrPY/5zzWe5uLeNZcW/mwrtBaJeR7jHJ9zzWcLpHVjOw3Z37OiIO+B+FZtWdgJ5IoZ BBJFGqxSKAHU53nuf1FPkayYLFartltRsuTj5GY5IP1x/Kq5nygVZHljuooGWF4Xi80PGf3sZPr6 fT1q6Li4jjnghhiZceaZgoWVccHnrjHb1qoSvowP/9P44hclHcK3+1jsaneW5W2wFJiZwu4LypP/ AOo/lX+/B/zlzRWeF9uGGZM/uwOv/wCvNQpMrsRNv8yNtg56fUUGZoF1ijzEcMRye9RrEDh5WJLc AZ4oAhvby0iaKOFz5iyLFgxYUFu+c9uKhuWAuIpkZg6R4kJPyu2c7sdPSguML6s//9T4yWeeSTzJ TkMcsAMbjVUBprpVWNtzNgBea/3/AIqyP+cuceqLcu2FlLlTztwpy/1NFz5JKlQQOMn1P+RTISvo i4siCJMqBtHyEdqh3NJgNHvU8DP160BZk/2KcmPyV+UsEkc/wj+dQTx5VgSyvFyW9eeRQI//1fj6 CMoiS71IPODwaVwzOZItxAG5io6Cv+gA/wCccBIrgMPmJHHHX/PFPLSeSUK4QcAnrQJJLYzXi2nh fMZjjZ3HvW7AwjjSOSPbJETuDD5h0GCfw/nQLkRjyyym+kZP3hPTJyF/CnSxzgAyj6bT/OgORH// 1vjkLsxgAk9M+tWXmmhA6kY5Cnhfev8AoAP+cGSsyv8AvHLyswx94YHSml5FIkKgqf7o4xmgksqG kY5ZEjCkj5cc+9OhKAusmzevIKnII7VlNa3AkyArug3E8Y6YpkaSmWP+4F7HJQD/APVRyO1wP//X +RsBHbDl0z1LZ/CmTG32nexyRj2Wv9+D/m/IBCgj2qMsx69MCtKOCNLSRsMZEGQo57gUAV0mjDhT HvwMPGetRQ+Y7uiNlR8xQDBwPWmk3sFiaaJDIkwX50TZx1bv/h+VLbvNKks8iLGgPlLF/E3Ubvpx 39apQfUSSWx//9D5Eitn2yMpG1jn0qUvsEasB8h+bI4Ir/fpxaP+b8cbiOSTEcSybuCOQF/Koyty lwgDb4SfljUcj2qbAOeXdMI4yBKx4jz6VNdyRTxwfaYVa4t/9TMvBQ4wfr/9YVTi47gULvzJfKVf nc/KS3b0pVgCIpY4bO3g4GfpVOdloB//0fk90tlSJCGNwSRtK8ADHP8AP8qz5fMkLRCAIUfcjoeX Ff7987P+b8sWV9EYZlLNGoO11ZcZI7j2PrVF4bm5vDPbRIkEcOGYv88hyO3+e1VzpAW7gTMsSNGs YRcMVGSTySTTyVgTbEM7uWz3PrRHWLSAZGJJsuq729M9KrEzC5ViNoUYctxWbi47gf/S+T4LnhgC p3cMCgLfn1H4VGZ7WDUIRJt8t4mkG4ZAK7Qcj8f0r/fg/wCb8dJGLjUL2RJUe1lcSWqImwxjaMg/ jn86cgdIppVjLrGdrNjhM8DNaQdlqBB5NrLGrXEkqsJRIGiPK47Y7/SoEkElymx5HhBwwdCuQDjH tV80e4Fu9jIif7OQNw+UkcrWXDG5jTzRvkB+Z/cd6LxegH//0/i+S3ee6aQsybGAZ353j0X61rRX CwJLlzGQcQE/eY56Z/X8K/36kknZH/OFBa3KLGS5dtxwSdzEcfnWstzbQwMkPyrEgLt/fb+I4qTU pvLDuM1ureXsCS+YoJZsc49vT6VDarMbpJwNjwyCaEkZAKnKnB/rSaurAWpLdk+du549KcIzIFMm EMYwOcbuf8/lWTi4gf/U+SlvBEW8tijBdo98jB/rVaArG8m5gpb5sk8nmv8AfWnsf845XmW485Zo vLeMkq6sA2QRjimh3Tesa4JBBzTckgKFvPPHckTElM8VvRmOSIqiYyc8/WpU9dQKsMbQSTBYhvlY Zc9TjI47YpZVKFnxlgeoH3atNPYD/9X5ESQPHuDB3PXmqD3bQyeVIgIkPO0YC9f8a/33cU3dn/OO SSsoj3pGS2Og6Gsq33iUuUcmVhgYJIpga0jrt2JwwHzA9RUEEoUnz1UQqPv9M0F8jtcZGLJru78m 0mUXMyyQg3BcoQADj247+lT3EnlN8wbb9zPfPegnldrn/9b41wxG4YweMGoprfyymFJ8wjcB/CK/ 34P+ccmjKhHjkgKRxsVWbAAc4HQ9apw3MTPKqEvsbAx1H+eKDSmh0djM80V1sJUggSdMg4OP0FXN iPK27IdOi46+lFrGhieJbaW80q6kMRQW67JpTIAm1iADt+vpX4ofta/b08UwpaZ+yLPKlxukOzy1 YYIHuea/I/HBX8Ocdfs//SWf0t9FxuPiNS81/wC3RP/X/iwS6gIkd7eCJY8CObfuckD5j7ZqCXUn uILjypFREUZTGPMwa/QK/wATPmqH8JGWrpwzr5nmDADjIU9v8+1SEGWOUfZ3+UcSD/Vk+9c5s23u MWEOix24VZF++rD5cexpU05o0lleE7ohu2j+MewrnNyvcW58tZlKq24bYcZJHrU0du5jCRrmRlLM 5+UVnPoJn//Q/iEuLV4ioCsSTlSORnvmljkba2R1cB8cY9v0r6g8cmvQ7QP83yqo2gdT0qOwt0kV 2mlCN5YVVxnzPY+lADmtCRMsR8ucLmPHIGOp/KkF0tsI5VQtOi7JCxyp98UNaWAvu8t+h2uuSoIB PzK3uPSrlvYRQqzmRGnMYWWJTgNjuKycGB//0f4hboTLLsRv3gPCq3zD0BpvmSRTxSCL98mQ5BLF j719C1bRnlW9wus25VZYXcyHDL125plyVSOGOM7HVwSQ3zfSkQaOn3W2UxzZbeRlifuCpb27thOF t4z852kv1bHWsrS5nYAhUQHzlRT827nkN7Yom3Sq8qKse4n5MYA+lQawWh//0v4iGkaM4aEGfouz +Zq+ty9u0DM8crzQ4ZEJxH7H0Ne1HR6nniQfaXOIYnfblmCtjao71durueFUBUAY+ZiMk1sBmqwY B0IHPGTjd6iq91I0rRpEf3inkP8AdH0/KgB8dvNwCFck/Ng8LVp7VMB8srKvIxUSkkrEuSS0P//T /iQhhnlYiRSYm4Unqa0oLYxKURCSONvXFeweTF2ZQey+zM7MNzyNudycke1JJKLeNY9wCn5toPLV k5e9obEMDyP5saW5keQZjRuRx/jTJ7V5ikvlvFtYK0bfLk/4VAFuSB7VC0m4MvzA5yPaqsVsbomc lld2AKxnsOORQaqPu2P/1P4mrDT0e5n83dGxIUBhgEev6CtOWFUvUCSJ+7+QAtwcDHNegckY21Yy 6uEmi8uPKOM72HQEHt+VYclx+8CShSUIIccljQRy68pIIXaZZEUuWOCT/COmadcmOGYJsY8AA9vy oNXFPQvBs2phJBQNvjGOucD+grPS1mBYMAVJ3RK33c0GcopI/9X+JVdkRX7Z++cfgox0AqNZbr7N KFCK8jgtxtO0HIGfTpXoHnl22vpltpYuiSY3qRw201iTXjFigB8vPPYfSgqMbkkFzs4W2klaUbI4 lzknoD+HWtO3ebDJLvjkB24X7ij3qXHsXGNtyJhKWP2hzNFnPXA4pJ1Ev3EDwMowFGSD71Hs2Jxv I//W/ifmmmjgitmiT5CP3gOWxjp6VSms4PJe4VSrp8wwSAfbFdzXvJnDyO9iSEO6xuxyCoODwRVy d5AsMa4CYznuT6j9a0gryJIZ2W4CRohjCKA7OdzOw6n/AD6VnizdJmRtxU/cYfyrYmSujsLHTre3 hD4czsMkuBx7AVkXvlSFgVAOfmA43UBFWuj/1/4jlub2yMhtHeHzVMRCn7w61ThExkBcyGVsuTIP 5f8A1q9g881LJljS589SytgRhiQQRnkfpUVwVmdVaQxx4y6p1bBpS0TAlIkKeZuAhCYVW4kFJY3M Fo2/a0oZDkZwMjp+v8qwE2kiC7vhdNGwkcAjAHUDHYVpwNGY8CJ3ZUwU6M5x2pOSiZXvK5//0P4p n0bUxYC/exuFi27yfLJVB7np6Vz5aMlZCGUKcOoG05NegeeWrRS0zRPFugm5UNz2JzWtMSgjxkqh xn09BQBHeLFLDFJGWkuF5kQr8qge+az828zFwyo6/KU+6SaDoK+VaUeYcjd8h75HekdQkqsYzlTu LfdVqAP/0f45vhp46i8Aa1p3iiLwzpHiy+t5R9ms9Yl22VmwcZmxgglVDYBGMkema9J+OP7SviX4 trbeHpfC2kaHp1uzSy3Vj96clSqBeMnhmzyMZ6HjG1XCxq14V5P4TgkrVFJdL/ij5ahhZOJmUMXI EectRAUScW6oyrk7++7611CHyW6RzfI8g8zhRj5VxjNSnTnZmESsUdAWMvDZ/wBk0LzIckpFS6tJ ng2W0mxkOZVkHzOPRfek0wywK7FWAHyupGB+VXPczZ//0v4k5biPawYsSq5LY+6TxVTO5JQfMbyj vQ46+tegeOWXuRKmUi8wlAsokI3DHcflVEwywyHyCZg/JYDKj60FOzNzT9NubvMZXYAQXIGSM9se vFaFwsUHnWbW3mxSrsiZvkMRGPnz+BGPeg2t0M3cR+7TdIsQxhjtyaqRarqcL+TayeXCJQ7RkbiC OOD2NAkrKx//0/4k9SvL6acyyyeczH97I5zIeMD/ACait5HMqfaINpY/61+EPpXbB3ueeQOwS5eJ pHERbcvJ2gn2q1MnmW+E++vDdlcVZzlCJUPnQTNiJkCgDt9KzLi2gicERs2QUWQcE0m7IC1Ajs1v BEHkklfaqqMkE9B/n1raudNu7XckkYVlO0oD8w9sf4VEZNuwH//U/iFhgcuVA2yY/wBWTyatyXPl 7LUqGkjbLH73P+FegeHK9hmwT75SWKjh1x19cVXmltZSbdcK0aZTsOPWgzMkzeWHaaJ3bzAY9vyx kDqP5VfS635kCYcfcjPIoN4u6Oj020gbkxIZZcMGY4VT6elUZLnyJWSYqgLnyVzkemAe9RJPoUm1 sf/V/iXdGnCKx+VvmGTgVQlikgARMksx+ZeR9P0rrjH3tTyoytuPtr1AWhfG48Enqp9qRjvjDeaf tAfb5eMgjtg1Vnz3NU77FRBcxGaONxEznawH8Q9DWhbW3mzQhyVlzsfzBtC4NWBHeXyKzxp80kZ2 einHes6BzvacKDLgjHRVPrQB/9b+HuyjuryaSQxuZN3ls6HKy/54rbkxY7kmUs0iDIPJUc5/rXe1 ocC0ZRin3m5iWCOW1ZNrrOMrk/7P4VVnuYraOQhpA7IUjQDlT049hUU+psmnsQ2+mbLWJhlTjd5Y GSMnNbjymJI7XYd/khlHHIx6+taDMwpC1xG92JP3ZBQKdvTt/Otgi3uHAjXcka5VduFGev8AKk3Z XE3Y/9f+ItpQ+yKyKn5u5wPenb4Y2EdxERKBlyq5Q9utdTk3ocfMuWxE1sltKHkjcRy/NHgcfSnl 4UDPhd2M5c+lSZhDbveLLKqjGOg7HsR+VZsccd1cvaruV3HJbO0Fev06UAaVzKtqpgtvMYRKEy64 BYDnFQWMskKuZer/ADIW6oajl956FqbWh//Q/iOgZpdxuJZMRc7F5Bz61Kk8dvJKhtldJANkgOCn qQP8aLW3ORSvKxHParv+07Q24cIRgE+pqGa5kiUR+Uo3EAkDv2AptNblmdc6hI8iGaGQkYiUYKbw vGK0nvTERPHC6gLlVHUHjqaQEdpcXYl+1S7CshJIAAP0HfvTp7hp5CxUEouHQHBx6gd6Bx3R/9H+ HUzbX2+Wxdug9PStGyiKbXfc6u2XU9M5/wDrUAdBcxloVfO1duBjnmufe7+wxuhtwk0j/vJd2XX2 ArRT11ArpqKPIqBpDKnzA5wG/WtFLl58mVNzjkYGSarmV7GsHpYi/tWGwWaMtK1xMuY0C/IuOOTU lkEvYpbi7CFox8kecgmmmuhEndn/0v4iZDL5asMFDwg6YApwuI/LDXEeWPyJv4K49K6ALENvLdwe ZNAYlIYxTyHapC9eDXOzz7p1ixgbcEL0f3xWM1ZkSi3sOuYFWNTGxlO8K6quDED/APXrRsreW5YW MQUzzERx+Y4jVD2JJ4496kzas7FOMGK5S2mRHukzHcICHTIPY1Ykt41cEI0DDOFXhW/Ck1dWEf/T /huiuWW6KyE4VgFduV/Gtm7uUMRt/OaSEtuRgMJJ9KycGlcxcvdsNtxIquqKEVV3M54GKttqLMkS gYXhd2duSBjP0qUr6Fw2L1hvCSSqiSKrEOgPK56NiqdzMq3K2atIkjJ9oMi/dx05P9KLFklrZvd2 l41wT5Ct9nS7dx8jNz36jrxWppdhaRQ3ESyNMyDYJAvyTEfyq4LW4H//1P4vJb+8tbaSN41Nvdxe RFHEPkgZf4geoPHf1rmEEVsjxkSM07l0llkLbT3HP4UCbS3N3w/eR7pY7pW81o2W3FvH5iOf4SxP SvWvhHYXX/CfW80Om2t1c3OmXFuxvmKpEoeEBozwAQTn6gcdj7WRQ5s1w0bXvOP5o8Lieap5Bi23 b93PX/t1n7VfC/TGltdEtptTt9P8owQQWQALzQSozyup7gDqoyf3n5f28f8ABOvQIrP4L+Gbq1u4 5be08OwS6Pbww+TFHDP87Nj1wSPxr+lfH1OlwZl1P0/Jfofg/wBGmL/t/H1PX83/AMA8S/4KjeL7 fT/htroSYi5sdMU6TJbkNPG7LI0mYu4Zep7cV/Hn4o1yDw9oEkFvpttc6JJI8osdVhR54B0Ysy/M u4EkYYYPuK/Rfo50pUeCa1R7Nnwn0g6tKp4g4ZL4tn8mt/PY/9X+Mv413tve/EHxVewxwaTYXWq+ clnBIZdhZVO76DOPwrxOa3vPPeOO4aWAANvGfLkXjHX+VfovipU9pxrjGv5mfGcFU/Z8OYVf3I/k X1Bh8veMgAHK8810Gm213cn7TJEViC/uAy7T9QPT3r8zqqx9WdI4mlO+6jUTLEEUhQjFVAxwPYVV s7mee4hezcBEZkkWT5CuM5PP0rnatowsdWow3mM5LSLhlxmqcsTWMks8LOyS48tSMKp71xzWgH// 1v4zJNejtHslfTXuvPyZJZQRDDtGSdw6e2euK0fIgWf7b5e2S4RZW2/3SMjH4V4HK72Ocm/tSS3i uLjTLC1urlwI2adim0Dvx6c1LbXsd7dAy/uLgQ7TGkhMb46/U0NNaMabWxrz6qNMgXyysnmKEVC4 jjHP8VSoLi/WKZ/Kto45N0pLhVK47A8mpbsrlc+plNqDS3jW8VlNNKkgjihiGd+TjOSQOetaOlWE sk56onnkzxsSzQnPOR/QVi3d3NYvZn//1/5H7hprLekkHBykZ2n5h2J/Cn6FpTXkEz3bSSRyzbo4 pSTjBPQenpXyk3aNh816lz6c+EHhzR9W8beHYC8rFdTsdOntjGZoY/PnRUcr04YZB9sV/o4fsLeH 7XR/hp4a0+0iE1tp/h21024ujbG3nuJoUVSwXsBtC59jX5Px+1LH4VPo3+g6c5PEwh01/r8T9A2B wygfLj0xSQRSj/dY8H0r5y+x3ve5J+93AN0BqfcdoPGCeT6UQ+I3P//Q/oclJQFEUbWG0jHANflt /wAFF/DsWufCT4g27WOnXs0fg2+Zba4d9xe3EMsLqR91h8/fnZzxX8mNqGPo1H0a/NHJi4NYW3of xP8AjPStL02Ey6wLiLUHnVY7lZ/OtyjZyuwAkknndnGB+NeB38oTU75rSQ3Fo22NRJbeXsAAO5Se ecfzFfvGDmp0VYyXuxUSKC5Aim8sgOB8qsdq5+tY12jMTBMzLct+/VofnH/AmHHPNemNmdpq3kTN NdyyebJKVgjdg3kAcZUj19PerOqXxmRbYbQ7sFZn+Uk/5Fa09hH/0f4wbL7PJPcT31rL5xjESzwl VjHTqD1GB2xVyGSKdpooRGgt0LeYwEWAD74z17ZrwoJPc883I727g0pdO+0wNvlEvmTjOPXGPb09 BVKKRIb+CK+uTJHcPuilhjYCBcdDn0wfzrW1tDKbvohdZ1HTdNsMXXmXl1cXQS0MEfmHbzxtH8z6 VTNpYXcKtdXFyJmT/RooYA6p7NzmglJvYZp8n9k3KXa2+97X/UeYg3KTxnnvW/rK2r6fFbS2cF5c yzC8sJ7fiYPIoynoVPoeh6U46PUGmtGf/9L+OfR7CytLdBG9vaTznzNrHdLJJ12KP4jxwPat+fT9 Z8QXqW0Vj/Y93HNHOftdwllFeQx43mIkgEsFJA965INWPHtfQjtbmO5numvNLlWeC7bMsiF4JgDy c+uR+vWr2tajo2p31uzWUlsJIVhltJSJYJyg+YxjHAI7c4z1rsw+kkRFWk0zwrxBFHDqBeBsWRPl x2TY/dBeAB6CuBmg828L3BCAybAitnIzgYr06a99GKduY/Tb9i9rd7e2U3skWptfiC4tJp/Ot441 cM+JM8EiNDj/AGq/pY/Yj1yy0b4t+GRFJ59pbajbpdw3QFsIi0cgIhHRywQccn6dv7w4K/2jwdqU 4O79m1+B/H+Pth/HXC1Ki05/00/E/9P+1v4ZXUcvgnSpY1Vnl0+O5iU9QJF3BCP9kED8DX85v/BZ 3wfZy/ZUaG5+z3N7b+dNaEieCSSQhjntkoq46YJr9Z8J6jw3iZh4XtepZ/efBfSDwixnhzjH2hf8 j8CpY47A6allYztfxTjz4Dai6sdsJBQt1yTgZz1rDu9cSae+vAIYrpbnyRAsQtgjLxhUAwMYH/16 /wBPKNuWzP8AJrEq0binUJLdIL1rqN768nAS1B3GY9tyjj6/SopU1WOHVLVrT7H9rXzT9kyJph1x kduwwa6E4pK5nq4IytTOoDSY4TaLBF5Y8+eCYrqbEYOMd84I9unetWPTLG8uPD+oaZfS6ZNbKs+o eYVdIlUEMXjPGSQDitFvqYSTuf/U+B9QtNYvvEMCQtbGzgVhHfJKI5ZuSxd/w6Ken5VYh1ZNQXUY jaXt4IG8iO+nHlB8Zw+Oc9MYJH1r/ag/xRldWuZstrexNG9sjMxbJdW2mEY6+pq9a3tyt7L8ha+W 1EFxcSrndG3ygBvTC449KCTev5tQt7VxHFYzR3Cxqh8pbd1IOD84HOAc47/jWVHPbWcdzEIpROkx d1mUkSSEDcQfTp7cVtD4UYyd2RaWltqOoxXN1DcQ20amGeIBhCcZZflPAJIAz6H2qxrd29rEbWxt 3tFDgu7HMTKSD8n4Vora3MJ7n//V+CWi1BrV70BsqvLMMNg8ZA9DmoG1G2g+xQzGaeSS0HnbWwYp Dk7R6DGO/XNf7bJp3sf4eT2OmF3ERZ+RHmIIRIo+aZjzweeO1VbPdb3kqXETWcN5L5hhVwVDD7o9 8Z61tBpKzOWqromumv7a5AhWOW6EUkdtJNGsjokqlSoyO47e1YXh6O7sbG6lu0kQR3ZihVirRsuC TgDkdBx71Dd2c6hpdlm61iK9msbW1sLsSsredcOA8IIPA6ZH0OaXVBqS2bS20cPnI0cTRE7FmAcE /jhTz60J2dxKLZ//1vjOLTxq0K3d9qJ0uKCWS8SxtysEblgF2vnkjgEDPGKy5ri8NvHZaFJGsts7 v9suIQ5yRhvnPJAHQZwK/wBv009j/COUHfQNLs00eIPczf2lcSN5rv5GzyWGeAT0HNR3WprdMIru waVWky8vmcADG334pmMoXZA00kYaON5khc8A5Kvjg59asQ29zNF9qd0+zREIiL8s2epJ/StofCYy j9lk9/bmxubKW1mhu7WfnUYUZlmjUYwFbG0k/j9Kjfy2knMDTJ9oYi3jLfvVGeB9celWld2MGuh/ /9f4kRZI57crO3mIpKfwnPXj0PFI1ulw4hGN0pJcY+bNf7nRion+BMrX0Gx6Y2nR3FyBdXaeYFmt klQHbxgLkcE4PPTOKW3h867nktpImuNFZJJFuEEhiLlCo2EFWPzqccjGatK7sctSyua8up3e6QHc 8r43PGFjjORz8oAA7dKqS3csctusluXjlby5HIyVyDgkenvWvJE5xLlvtMioGk2IoQpjj8D6URmG yZIUYLKVzGrLuKgY6fSnZLYym9bH/9D5Atbl2tprZFSeYESSu3EirnnGO5qnBMGlIPmiOM5MudoQ j3r/AHYP+e8uyahfPdb5XS9tpVAVcbWTaMDPY9PSpRqW+weFbVZnnnaAErtZNhB3A9uuPegLX2KO m3EcGoCLULV7mxuCI5LRXCc9jnH+c02+t5bQDzoVYFt6x2+DJtbGBu9cY69PzoL5GbmkfZrexRr6 XTJp2ZxBDPbCaZwMcFSpHAPX2rM/sjSIrO6vbW4tkMtwImt55N04cnOYh2HHPI6mglpp2Z//0fje 2tYLm6EMN/aWU0KebLLeMwicAgFV2gncc8Z9KtRixs2WaS0e6keRVnYzFMx9SB6Hiv8AdhabH/Pb KNwvbnTpLl7a1sGgs5s3MM4yFgcBQYhnr97JJ/u+9UGt2iZnaNgkykLIFwZmUAZ/DIrSMm3ZmI+x 0jT7mC4uptW1KzvYFYWqWMaIrBsBiZGB4OMEe3ep47WG9jEUjKTGwAnJwzFeoOK0M5otLcx291JJ bOc2iK0bBcgOADwD2znrXOT3k8msSXfzRtqO+S5kjQ7BkjIA7A7jTTs7ozP/0vii3vJyCZbSQRpK QplTAfHf/PrXQw20F0klz5ir8vAJwseegx2r/ePnZ/zvkZsd/li3lzuO2RshlRvapoLO6tLtHnlj v/Kw0zyR4j+6dqlT16AVSmupE03sN1jVZLryra4itY4gdyLZWkdu56DqAD+BNV4tHihjb7PduWdN 6i6cFlz/AAluw+tUmnsKCaKOmbYLxTdwiZN4Lr1PBzx78d6sXmrLLNPGlusQacsBs2YB6YHp0pin vY//0/ji1Go3EctusdsrEn7KoT55cju3bHHHvWb5U0duIrkJ9oj+WVo87WOea/3oP+dcu2jyRBJY 5TFIpADb9mO1SslxvLiQSAsXcq2Sf8mugAW4nhd9uYi3UsMHFZ1xKWDiOTymJzkDIzWczOaJraOd rd3klSKVfmR8fK4HXHbse9XoFS/hlMh8yFh8rMuQw+lZmZ//1PkezRIoXjj8pDIhiiVyVI6ZIx6V NcNZQXKSxxSNIsCxyeZIWB7nAzwK/wB74u61P+dGLtdGa5gml85LaOOdeDKmd8gzwDzj8hReXX2h Y0kt4o5IAI0aKNY2kHYtjv15PPFMkpfaZpb1HMrCeIAowX5QVwB7enHtWhNbvuibccKC7ZyFb6U0 2tgKE4MS7sbQTwO9W7KUxoRjhuoxWsG2tQP/1fjGTc84NqrSyDLMiAkgLkn8gCfwq013GIBdPIGd XWFI2++ckj8v8a/31nsf855We5u0SXbbq/njymeWIOke7uuRwfQioEAjdo5FV229GHb2pSje7Amt ZRJcfIAsacbB91cVqSkvMrSYaI43JEojbjj0xn8KHC0dAIzDI0MrqhYxKTx9446VXt4ZXhjZgVdh udM7tvtSgncD/9b49Es8KTRLEREz/LxnPSpZLoGAK8SK0cfHlE8nnrnvzX+/B/znNXVmZ41BZFjZ AjFc5dM7wc9PTt2qW5gdES8kAPnr5hAIL56cj8KDNwaKUMm8iQvtVXClG6kf5/nW1cR2uWdfMkjh BMR4RueBkDI9KBcrtcxIV86Z3khwh4UtyQR3FSzxFEaRjvVeTt9BTSu7Gx//1/jRIkngt7hWdEeP ekbEAkHpmluYQscflq6OR989NwPY/lX/AEAJW0P+c8ppEQcuSXxznmleZOQPpQFi3Go8k/PyBkLS rJ5Ua5ztbj0oInsXPPuQm3lfK+YkdQOnP51ILaOWKaeadw/WNONre2OtBkf/0Pjl1VR5TbhuG0HO Cv0qQXMsEkfmncIYvJAVQu5ff16/rX/QAf8AOORymcFJ4lQDOdvcD6UjzXEcsSzJ+6kXzVxzxnHP 40AOu5IXmE0EXls6KroCdvAxmpZCWgi2yESbsOxHUf8A6qT2Aiuba5gjR02+Y670I53A5/wqNLyS RFRiMjKnPYjj+lC21A//0fjoyK1uEdcyA5LDg8dxTI0fcriOR1HB3Nhfy71/v3KTTsf84so32LV0 Lpwv7pY1I2FQNjAAcHHvSxEwIEB6qVJI7HilF2Zja2gLHhwrNlW54GcD3qZ7WNNs3AyOAGGTRJ3Y CJsxtIIV+uOtVbhGT5klKIDzjq31rWOyA//S+SUhRrVuOfvKR8tUkGJIsIHTdh9w4r/f2Ub6o/5v yZph5hSIbtnysRyF/GpoTMPNHmBVK/MDyHxzj+VZAVzKkUvnSOIufvkcL7mprW9jtBLNZpbzLcqY 3lZdwwepX9a0g0tABGeWXzcfKByB2qeKbzILk4VCrmIRsMM3H3hV3SA//9P5Agjn3NhyEPGDSTJ5 OfMZZW+6dvav9/XJbH/N+WII4mtwtt+7lAO5mbIbPTA6/qaYkVwHlSRhbiJgrmVgsjZPRV6881dg EkmtobiKNdzM+BIVAD474qVmVGxkON2TuGQR71Mo3AdcAJhlAw/GAeUrOubmOxSNJnWQyEOoB+7z xn3qJRtsB//U+N4Z7iRY1kYSzg8y42lhnuK03GUKNuZtmAVO1ga/34P+b8pW1qiQBJA+/cSXfliO 3H+etXoQqFWXd8p7cUDs7XJPtM7i7ujZSfZbaTywxIbzMjPy9PcVXKB40uhHJDFOSVWfCsgHUH6f 1rSn1CzehLbTxw7lysgk4jZv4O/H41W1Bnjcq43On31XnaO2cVUlzIVraH//1fj6ycEszYGBwD6V F9+eWQlI8jyoy4D9cHd7dK/38cOx/wA35ZiW4tZVuYm8wovzL1DDvTY7hSsskhKiT5ivTj6Uoxut QJ3MKQpKzAL1wfSnRN9rkj8l0ijb5UYYGc+pqAGX8ogXaH3MuRx0NVYrtTBEUDmY5DxkcDnigLH/ 1vkdbWdQVulVWOJEBGGUduKhmIGEK7j274r/AH4P+cZKysTW0bQkuu070ZWBGevFQpbEQSh1JL5U t0HNAyOeLytMWIR4eKUES5O4gA/Ljv2P4U62klZFChUZQCwY4LD/AGfzoAc+ovM4tJnBSFiIVC42 5wW56npUU7SLKIzypXIOen+eaie1gP/X+OUiDYGQCTktV6K2ETSTSrvjOYkZhwf/AK9f75q/Lp3P +ccotOsUmxQAg4VQMCrDASLmMrHK3977lKXxMBslhJ5jl54NkK58wE7H+mRn9Ki8xl2bXAAbGB1I qQLbFjhlOG6A96rxS+W7rI28McEHHFAJX0P/0PjwJbWMhMYZklQbFAP7pup/CqE6zS5/dFgfm+Xr gda/31U+5/zluHYnS7CjGCcDaM84plrLNDeCQMowQ8bbdwQj1FUmnsJQvYhiu2lv7lp1VpGD732b Y3LBhuUfU5FT24heOWCcblIwikZX9aZqUwssV2kkcoWNMqyFdx9OD2qy6CefeWZt5CsGbKDHcCgD /9H42lEKyeUzkgjAGcEjpmoZGZHEQfJPKuRkYz0r/fg/5yZKzsIk0ZkNvLJ85BeNM/fA64pqTW0T kxx/ODkjHBNKTsi6exvDUTOu1sKFUKigABfoP89axPOZrtjsI2nAbs3vSj8OpZLqDGXTL+RFj3wQ bQjqHBLMEyVOc4BJ/Kvw3/a61FZfE72dxIvm+fK/mR5jRsFQemBzxj2zX5H44/8AJu8avJ/+ks/p f6Liv4i0vT/26J//0v4lLk4jWKIoc8svTApFmt1jlMMaP5YCtg48vmv0Gv8AEz5ukrU0gkuY3SMK QqFgpHG4U5hcjEcDM0Stk/NjGfUd65jQ0ILSdoy8akPH85IGcjvStesd8bEqRwciufY6DLmkYs3K FlXcAeuB1NPtrxEckiRiy7Ni9qiSuiXukf/T/iJuZ5BMzRv+6K4MTDOw88ipYQjpECgDBt3IwXz6 19S01ueOWFZZfMjVGBiPzIVzurKlIjJYjYpbC9ttIduhoTvG8EMltK32lQN5K/KR3zRBZrNuaYou BkIGINBfJoPX7PYufK3NIV+bf0I9vyp9nK11dlw4ij3bWZ+FGeM0E8rTsf/U/iKv4Y4ph5J+VRzI eDI1V4HTyW2g+aGy5Y+vpX0s11POirJFyG5WJBGW3OB98dKiEUspYAbmY8MeorIzmrMnltLizJJZ STECzq27YT2Jo2k+U0xCrGud7cYz1osQWzdQySJaqAWjTcrqRsYYzyakt5PtMvkuVUEhDIeIh75r GStJm8VZI//V/iuewt7YG4iImbbtdmAKnHtXMzoMnbu81Wyfl6gmvYPPLVpKkblJH2Oy8ZOKvT3E MqbPNVio59TXRYzcmpWMqXoMbY441LNjqx9BUiBJ4Y5gBG4645OBxzSexoW0nQYjGMngnPJpZIJd glLlsnbs9qxe5g1Z2P/W/ix061NyrvN+7UAJGFOMn1xU93a3Fi6MxGc/e9B717B45m3LL5aykh8t tI3Dc3TtVKSzjml2eaoUfNuK/MR6Vjyttm8VoXoVSK4jUttA+6QPvD0rVvJLS8tViWMLImcS5xn0 qRmHCvnRPHOocIuTz8rAdqiiZLYtIUdVXpGozig2g7o//9f+Kn7VE7Bz8zBcKx4GPeqV/Mm8BAu9 BksjZznrXoHOQJIzQ+YI2CZK5ZcH0potllVlKHd98ED5h70GF9bmjaMwTYr7hGNjkj5s+lMW33pI 8qtcTg/LGg5x26d6DRS0uyiJZYysEyEF2zH8uCg7Cp5WeFYZZS0iAkHyxkpnp/SgiUmz/9D+JKG0 F0xleUhM7grHOSO1X1trVVJnuikzMSIwAVCjsOc16B55G8sFyVjj/dxQjZ8o6/7X1qmbVCCEYBM4 3EdaDWnsPLJCFijJ3qASwGAKZNE7on2eRt2fnAGQ1BZJHaSoikOGTOSueRVm28uEsE4EgwVzwP8A CgD/0f4plls4jbpNa3EzSSbQ6fdXvubPGB/WnTRyzSTBo7f7LjO1ThwfpXoHOR3Vu9ukEipG8TLk mNw0iAeoHT6GsWa9hDhHeRV6xyL94H0NawVtTB7k8d3FIQBuIVsFz0re002a3Be8dlRQPsxABQv2 3HsKsVuhrXlzFIkao4FwjlkMZBGOmDXK3e5dpaQJli0h27iP/wBdBm24vQ//0v4kDKgCyFd3JEfy 4z2qUTz3CWwaNFktkMaFRgkbi3P4mvYPL5y1NcxLFEssI83cd8g5xWW8QYv5Zw3BLEcD6VMvhYnN 9BZYriUopYMpX5sHGagS2bzPJZWWNiRkdCaxILD27RwlEiKuj8EZJ+tTJcLavtNx5jBBtZhkD2z7 H+VTKN2aQXU//9P+L+Hxpq/9nS2Md3ObYx+RJHuBhZSOQB2riUs5LmV3Qkhn+6DwOa70ktjzzpbS DTkgliu5Jo54sLG8Ue50J6YpJo7bDxpKWVOQ7DaT+FM0hHqzOjSREYqyMrHBPcjpWXLaLCqs0bo5 kJk+bK47YoNB8TecZYkQMwiJVO/Heq9yrpEjTsW2DAUdD9auMb6sD//U/h6tJbpMxpny7g42rzit 9JjLJHavIYSseGuSuY0xx/jXrNKzOGXxMpS58yNQHJUkmbGS49abbvBCZA5kbqycZJrEk09Knjnm jNxHut45QZMnAwDkr6811HijxPoE8UT6RpYtHQ+WUjZvLPbo3QDB+tLW5horpnnxuySZ8FmLAFSf uittLmFdslvbks0eWVzuBYDrj09qYj//1f4jFHmoZjGFHm5Kdmxz0p01wwt5EK+WzHAG3BAr0Dxz HAeNnMTtIgUAswwynuOtatpMyxBEiJU8ls85oA7LSdSjtgkJkddp85pPLy3bgH8OlZerahHelxBM d3zEqy7G56H1oNoyT3ObuLwbYozuWSMbXIP3umD/AJ9asafLtljSVgFJyrNwB+NBR//W/iRu5YZr 4Qq6FcZYoeQeeD/nvVtHhLSQzOuVXcgZcgnqAfSu6MbXPMm7KxBLb27MJpHUyEbVjQ5x6cdqhRZI oN7xH5n2Fcjn6VRkUJo4+W3eWDwue57CrEdt5sCO5bzXUqiMOFwev6frSkrqwDrQR2ix3KJK0scm WPG32x9Kml1K4uXZ1XeVbdu3fOKmMeXcmTsrH//X/iMVtkxlWRQ+3BI52mqSxSvL9oIbar/L5fV+ vJr0Dw27wN6e6Rolhjg8tjGFMgOSx6Et/wDWpmkeHrvUJrtre3MkMIEck0o8sFm6bM9fw4oMzM1K CTT7iaxuraaNoCA4lj24JHaokUCJZImV+CNgH7xaDeKsizaSS+W6+Yyq3ZhgKR2qxGy7412CWRG4 BXIPt+lAz//Q/icniV5W/gdhny2bAOPQVT3O8uwdWGFUd/pXoHjmbdWv74b4yuBuLL3NT2luYyJT Jtiz95vXoBQaw2NElQDK67vKbzGKjLAClu7yG6hD24CTsM5Y7AMdfbpQVfWxgSSQuOIzuHV89D3q f7IHgEkJwCg83PT3P6UDP//R/ig0aBIfLMUpt5j8yyhyASAcVqvpcNxAbp7uKRyDC0QO8g9QT6V6 B5/qcpeR29tGHikbz95jnTgoV4wR+Oc1WtlS5ljaTaqRchjyTSSS2A0pZVtikEOZJLg/LIBlUHpU Uf2eMyGbzBJ/DIw64pc3vWNIN3szOu5o5gCCR5ZwOOf88VRS8nVm8meQDb5bheF57U3szM//0v4e bMywufkyoXJJHQcdKsTaimAwRisbbiuMlu2f1NdB55ce8nuY40eVlto1Pl71wqk84zUFwqG3ErAE qcMOoPoaAJbG5kkhMUbCLDAhk+92qG5BtZdo2xtK27zlH7wE4zQAs8xCqvDbQOcZaQ+tVpcgxygq XVgXiY/0/CjyA//T/iNW4aANLtVFucDb1CY6CpptssbJEQsqgfMozuNdFkccY2dyZrqARSwzyBJE QEO64II+lZttFJc/vJMtCcsHbgcZ5X1/Ck1dWNCKS181Wl87d9mbf5ZIAGeP8Ksq8bqIFf8AfMuW 4+VO9ZuDQAsMs0Ekewu8fKsh2gY7mo206BVTbcytc4zJxhRn0PepSu7Bsf/U/h4kZbaZIpGZtoxu UfOK3pNRgtLY+Su4BRjdzuPfNO2tjBtvcxpNTkOwqZBFJ+82scHPcD2qGRXnVZW3s7sVAKnA46mk boy4oxDOI9+W3/MWO3PPrXbwz2cEKuXSKQ/Kmw5YUFRdjMu7KF386RmMbfKqgckmmJapZOjOzRQu dzIvz4H0rWnsSf/V/iJhkin43lE3nDYzxVkwCSKWJmWZFG9eOI+2f5c10ALE0sERR5RMOwzwo9P0 rOgMNy8jeWsUiHC7VGAOnFZT3Au2likd09uzOxZDKZJMLjqarzSFbhjH8gU8TY+/j2qCJRvsOt2s LO5N5NbykXCuPMiPPmEYUn2zTdQltokid5zI7Nkkrjy8ngZ79qDNJt2P/9b+GaRt8kkgQyKOigYy atFh9m+ViHRgyj+IGi3Qz5CYzm5cKhdxgb16bcVYuJrZI4Ik+VQ2ZTjdJkdqw2NEraIn+3PIHEcX 2P5AEMa8NjAJwfX+tWVigYNO0zOpQKS3En0/P+VLYCRoHkjayaR0t5fnUA8gjocdKtwySWRxC2/I AYuPvYrWMr6MUtIs/9f+JibUpYnZmjDD/WbIySPwHUVqXlhIgE7xNIhRXA2/JgjOPrQZzexmqjWC i5tZJdpPzY+VR6rXvnwOd7jxFaxXN3dPI9zHHdW0Uf7q0tnkil3K5HDfKR9SK9/hiPtM+wtN/wA8 fwdz5TjOq6XDeLn/AHJfkftn8DnK6r4Z05YYVkmn4vdQHn+UJIwiLj0wQQB6H1r+7X9jTR7LSfgz 4OXTI1gWLRoIpAo2hY/JTLFegHXgV/SH0iHycP5dR81+R+UfRsjGOJx9W2v/AAWflp/wWD1+bRPD F7bwPDHcy/vLadFw720h2TIw68oCB74r+T74tfY4vhbqWuX8d/Bd6isY0OGKUSCeMOyylh1PQAdO a/V/AiPJ4cOp/i/D/g3PxHxprTreLn1d7Jxt8/8AgW+4/9D+I34mXUb+JtZu2JDJMtoqFSpby14P v16+1crZSC4t4zJM4H3NijBwOnNfb+ItT2nF+Mb/AJ2fLcLR5Mjw8X0ivyNy30meU2bpKUgMu13+ 9t44JPat/RJQt9LaahfSoVYorHDQxhenPv8AlX5/Ue59FHexvXq4jNzG32hgMR5cbX9s/wCFYtvF czu5hQbsbmEfIH1rBvTU1jZrQ6yxtNnltLcTTASDzVDA7QABgfTHSlvldgY43IJO5CwwK5Z7WFKN 9j//0f4yI2lvLR9L1CEpFHHJ5l1CN3nKR8qdRjnrjpmtjSLC9utP22kEt0bGAIYo1LuVBwBXjaPV GSg3uMh2vi4gX92hMU0eOjdCD9KtQQ28I+0yCPzlbcEHKsPQ+maiZaikrEWqpp2pwTwXlubWGRdy iAn9yw5UgnnqKyrK9uII7VJYJLyK0k3JJuLAg/KNxz6e/esJ7C5Fc2blJXuYosSwOCspaA/OM9j7 YIr0fRTZWnlblZQrAzuVBeT3PvWLRrGN3Y//0v5K9duReSxvNdkRqwjQM2WI/hUZ/pWzo00N15Ud sJIDbY35O4sR1PTofSvkKvwIuMbzZ9f/ALJ2kSa18X/C8VvqUslvp3ijTbrUtOaMGORBcI4AbGfv KvHOMGv9I39mXTzYeC/D13aysIp9BguNpwsKiVchVHqOc1+Q8Z1OfN6dL+VX/I5aEv8AhU9n2X52 PqFg+C+ST3Ve1SW9w6oySDH909K8Q9cUs2QcHJGcdP8APSonJUkEnnoPWrgtToP/0/6GXkeR2jVC MdwK+Dv23/D9zqvwo8X6dpjj7beaNcWTTxOq37C4iELlV6lQspHoM1/JVaN8VSv3RWKivY2XY/hp +P7WvhTxFe+FRMs8uj3Q0633upllKEoSyjoxIPtgj1r53vpPKjCMifNH5kkbAEjPbHrX7hlc3PC0 590jy6ujsY+m6Xb3qzjUY5lsI13GeLu+chWzxjgZp2rrbLbtcWVzHthk8lU4Ex/2mA6e1ezBt6Ez epxV1dy+X5xhlOCItsSF5Dk43DA7Z/St6SK3hliOwXjSWSK00oD7T9OxHrW9PcmLaaP/1P4zbxUc ru3wIrKziLrIB2Pscc1n3Fi93PqN3aSQYZUFpb3AxHFt4xgHJz1/rXz+x5U3rYuWkDu2y6GPKIbI +7kdcVoC4jlTBb50cokXeMf0BzWsZaakF660i4ZbOFY4Y7i6ZXWeV/lt15+Zh6frxVO3SfTZ1dyk qRylt7/OWUZyFxTjK5pTQ6+1Kyv9QW2KyQ2zwrKqsCI8/wAWD7471Dc366vFHpelQlp4Tlrl/wB2 YFHCruzgD689KOZXsOUbs//V/jfNrotqE/tBll1Kxt2lt/KlWcQyMu1pNwPAqTTb3U5tPtru4upd QktWZLN7wssttGM/6sHjByRivPpyPIas7M1z4uk/scad/Z0NrO1ybiW+YsZZBjC9eOmeO1PtBp1x byanqNxGEsYmlR418x5M4DBCOFyO9d1D4iba3PFdat5ImvJAoInkLxbmJKqW4I59sfnXn8qz28x8 1HByJEdgenUGvVpu0jmtuj9Bf2OJdJ0++mhS3WaS+uxd3E7yOWa4Ko3mAZ46quOny/Wv6K/2ZfEN 1D8VfAN5q0EssN/rtuhhhgzayI8beXMJFzghgv5/Wv7v8K4xq+FU6UFq41Pv1f5n8gcZudLxhw1R 9Jw/Gy/I/9b+zT4ATi/+HPh65DTP9psFkikmbcVwOU9sf56V+Mn/AAV60G/vNAvNStLeOeOynj1R 4bqby2nWOdHZF9NqmRua/UOApxwvilRUtFGt+Uj5Txrg6nhzipLrSX42P5ymvrkT+VpTW2n2TjzZ Y5zi/dj95Vf05HHseteb6/Z2c88rNBLNcST75vKbHneyns3HB96/0+w0rx+R/kdi4r2Y7TY7aTTW v4LBmewLw24mA+1o2D0Oe+O3XFW4dU1Oxn05Xt0gnljEz3Fwm6DaeCpx/F1/KujmRml7iZs3Zs71 LtbiIebcR7UntsQ4PTPT09cVkvpunRWE6i3Es1rbF2zKUaTcCAT6+w6ZFbwlfRnO1rY//9f4TgnJ 02wsbeJIUvJEiuLqaHEpVBuI3fw5xg455q/Y2a29veWwuYYVuATHEoJa3xnDH3PH5V/tEpNH+Ksl dGHaItzYQzXd8xji1J7dzH/ro9oGd6en+FSzXECyW5iYNbyf6xwMkJ2I/wDr+laRlzGD0TOmPheP U9PkaHUWaaGMXqWs13gbRz0/hz2FYt0FuHuLVY/Lu47ZdnzBnYgYBAP061vB6WOaTaV0PsBe2Vvb yakslyzsYo7eSb94xGCDtFaV6sMzzRfLeCeBVgDt5bWAIG8KR1PU89z1qzE//9D4Ru5ZrWGGNZri 5jVQk6SP8j7DwPyHfvTDaw3NsJI4IlkaUySybcFCwAC/hj9fy/2yi7M/w8ntYtyWtzYwiaOMN5kR 2sXwcjGQPf8AlSWkAjn0i6upTI167MluF8z7L5YzmU/w59/atjllJPRGrqdxG+pkTq8H7rakqj5J W25Qg+h6cf0qKzs1vporFRKJpW/cRLHuF2f7qn16VnN9EKKvoZGXivrSazsZi5L299bNcAwwFC3K dyeBzReag9qsUuo28nl3TlIEtxl0I6Fh6HnpzVp3VxJXP//R+F5oo7u3USW0sq2f70ICWmOBn1yT 14PrWlq8unxw6XZ2Kl4LiJbq7mKGC6tzjiP6cnOPQV/twj/CmatIin1t7aKGzhshcZIhEkhA3ZOP mPp710up6VFCunwNp+26Td9vMNwHWNuOFPcAZ574JqoytoYzXUxJ3SEy2cXkzAkpE2A+PXHv7/Wo I/syFbdyLiNWDTLGSq5/+t/SuiLszmmne5Jc2sxuFhtF8yNl8xVT5iFxnJrctdCkS1W/uYi32a9j eWeMHECNkKrD3Oa22OVxlqrH/9L5D1CyRR9osoJ5UkYq7BNwh/GixsNJluz5zzKYrcn7TA4jmiO3 J+9x2wf0r/cyD6H+AzvbQrWtvPZ/aGeWG8iwJ22yB3cDJHPr1qKA3F/ealcxWkccc10Jo4YuZ3BU L8x6tjGM+grQ5pK6sW73Tp7dosbWlf7yK6uIxwRyCR+HapbKEXNnePIYHlgUuQ0wjliVSMnaT7/W qUmnqZNNbmWTCJFMchC7uMqAzfWkWGOfUISr5cAgIw4k9h+lbEOKZ//T+QbGKJbm5uHlltY0RlXa u07gcc+x/pVeRYuLYqCr/M/YSf7Rr/dg/wCfPk1t0Ibe7S2kngtijiNTGWYZaAt12+lLY29xM0/m zrHCXDRuBgwDAyW/HP50FKKjsaSwQwszysJEXKCQDJB/vYqgb2W8t4laBl2sxWZgQZl4C4HpwaCi eNvMt5LcpHv++rthZU9dpPqB0rHaylRhILe4EUj7UaQEh/dTQZTWp//U+QV0u3jszHIojnWQ3JlK A5yBgE9Rgj9aoyTAIEILuPlGwFh+P+Nf7sH/AD3jbaXewMoLxrnainAX1/lTn1B40YhxFM7bLWOR NzYXuAfz+hp21sYNNbiXV7qE0MMM6wiWMM4ljgEJuNwGN+OoGOO/JqfTXMUf+kQhLiQbgyAmFscH nHXpW4rdCWUh32RujSTyhFCLh1PoR71TvVW2ba6fvbVh5sUYG9sfwj64oIUF1P/V+Orq6W6sxAtx OEMvmW8f3RGrDoyn+Ievuaha1EAiMLO6lB5pbglsc1/vAf8APHKKSuixatcMXS1RpWGZDGhxLJj+ FR64HSgPJdD9zHeJPJ9+2mH74exx/L2oMx9ukbZF0hFxGSq8ZGOh5/AU2WMgv821TzgH5eOla09g GRCQnKgZAI3HpVf7KZrmMM6+WDtlnc7RGozzj+lWJxT3P//W+Q7aGC4uLe3gl80JIS8/2gWyMOm0 Z7detVbxY98ojeM7Mr8rhlJGR1HBr/eg/wCdcz4Ps7Dy3bzpg3zrjAj9BTyz27kLuAI+Vew610Aa F0Tqf2dreN/tCoIpV3b9+BjgY/SoXtbbatpLFJDPg+e2SXAzjp2I+tZ1OhM/hGWwj8mW2lby4YXw k0/8Kgdc8nHPP0qzYSRRPKhZmikhZIvK6M5xtP061mYn/9f5CilEYCneXQkFSMDj0qzOls17HC9p MfMWKSaeK4BVlxuZR6Hn36/l/vfFWVj/AJ0YK7KyfZkuZcbkiLN5JY7jjJwD71nyPFFLLIVLmQ8M xPy44yKYckiWNFlARlMRmG5JsfKMH1rXeBXjSIXasMb2UH+IDHH60CSb0RkfY7gRTMT9oWN8k4H7 sHOBiobSR3kKvhQrYyw547U02tiuRn//0Pj+8K2kiTQPhipUSxZUjIwy/kSDVCK1TyzKM4jfJjbP PvX++Lbe5/znlyWVJUDojBEwG4OAe2arLtjmMk23a2FQtwwz2pyk3oBfhsUkjkMO2PrMzHC9BUCy +WUQruO7BfsK0g7oBjC4JkYuI4sghVJw1SxPvjZslQvy7s8VQH//0fj+KW6jOyKcPbNkSROm4E+o PbHNSXLQxbAdoYjv1f14r/fg/wCc8z3WOQFU2q2cnjBNT53WfUh0Yoc+lAGU8Rji3lTt3fXn1qxH tmiXEkiZIJz8p4oA1L9La1S2himS6mmTe0lvlo4hgja2QMN7VXZYZI/Jc7W7xkjLDoaAP//S+RUs Y5YWPneUI0+SNVySccD26VkyC5tQGkLywRjcFB3M3bp68V/v0pNH/OeTO0bo00anywRhHwJMH1pp EDq0UYVnyOMfOtXzq4DUCgqhHzL1HSm3aCVFcuwVTwqNgGrJkrokgmxs8p/nX5ZFI6j/ACK2L5rW SG1ESsjov705PzsMc/zoMT//0/juQFvmZ8BTnJPIp80Z2pKVLRHmRweR71/0AbH/ADjkUFu7sXa7 iWMHKI4bJHsQCPzp9xdyc2y2yGILtWYrmRjx0P4UAV4ThH8wmNozgB1+/wDSnNcpcZiCsrouSNvG PXNJtIBi+emxt7sqDAUnI+mKlh2O4kkVYtwAZSepz/n8qYH/1Pj2SFHkzGxIj4yudrfh+FWBMsdu YXYLuPD9Ntf79T+I/wCccljCm3Se6LvAhZVELgSOQOB37kdRTUgZYI5W2sZTu2AgtGOmCPWlFXdj OUXfQhu28r/VsVVepAwGFVld5pAqZCquWzzQ1Z2H7NFuNthZmIJXO0HkH8Kc5jljD4UCTgoTypq1 JIlwZ//V+OBO0FxHbXAmaNR8iQtyoI6t7c9DVoG2yR5rhFb5lAwxr/oAWux/zg8kiBZj5hijAG7o 3SnxXG0eV5ajbnc4JLsc9x/hWMtyRrlWIDgMB2I7fSnSTWqxBI4D5WMMiLnn6Ule+gFrz0t7dxBb uXZ12DPO09f55/CnXcElu2278uHODnPyHIzjPQ/h6VXJID//1vkiRGCJs+bHzDFVUtpZmYnpu+Y9 M/X/AD2r/flqzsf839hEtWaYpGzDby2PaoriTBlIVmkGBEd2FQg87hjnPPp1rTnXU0UNCzbKsiG4 k2iff8yY2/iB0xVmC4WJ5S6Ixk7yDLL7j06VV0h8iIpjE115MjrEZI96bujDAI/mPzqkYYlkSOaE TxOcgnhlI6YNTJq1hSikro//1/kKJ1jlwoUEcFMZIp7XASVsEFyPlVuM+tf7820uf835daRJI1Yb BIRhh35rKuWP3AzIV5JXgNT5bOxvaysQxL5gLyTsrQuCkYJAkBBB9uOODUrmXAIAlC9EYkqR6Vpa 0bDsVo1nnYrcxRoofdGIiTtHbr3rXiiVbeQxjdHvCOXbLk8/iaiV1YVkf//Q+O/Kfc2xcovDEDp9 f0pWtg6BoNx24EgkfPOeSOP05r/fxz7H/ONyrsXY2FtlpH3BVACjkfSo5GjZw6AEN1GOlVD4SXBd CpPuldjJEZLVcHYpwy4/z1pInH2ciLKbztHdkGe3vx+tKUL7C9mVWgklJX5js6lgavx2KiHy0Yx3 DsCkjHAUcgnH+elZDjG25//R+Qo9y7gzs9wrbZ3c7i5BPIPeossZ9xz+HTiv9+D/AJxx08u0iVHw VG0Jng/h+FJIFkEEru+5STtViq/j60AVZDdyCQB90I+ZUxjBqJnlVYJZC5IcI4GSV6Afhz+lYtu7 AuyNDLsKw5kRwfMI24HemTELu3guSMIR2pNt7gf/0vj6y09pFHk+a8jNwhBZmOeAB+VTTwsF86aR kKjyxESefw/z1r/fWnsf85Ci2tDDNzE88ULBT5biRieGIzj+hrUlD3DL9mi37DnA5b/PFEoX1Qiq 11MY3THmKGBC/dJ9efzxS2uzcT8zHJYB+oqORjs72HO7F1LNtjHocAU6RC+PKZdw556EfhUmsY8p /9P41sre6lFzNdyRokUoEEX8bqQcn8Mfr1qFp7iO4eK3jEqyv5SbmIWPdwWJ9gTX++PK0rn/ADnl maK2tLZIZM/bGuXBCnehUAYII991SadHZbZjcXJSYhmiDAsjjA2pgDg9ec4qobgQfuLecSvGJUU5 Kbtu78RVWEtcXJ24iUNnHUAen8q1AsSQEFsgc+vWqSiVconXPy560Af/1Pi/yw4dHXMyDCuuMg5/ +tViG3hYRmRnYoMMnQZ9c1/vwf8AOa4p7hmKCVpQqGQRlFZ0DBQRg9azI8KrSOAR1D/3qLFJW0RO LqAKhkcRK0gjVjwCScAVblRMEqe33qLdAKrBbI297eORa7i25RvLgA8YHqcCvw6/aqhgv/GkDCPK zC4RkZto3q0bKSvpywzX5B45f8m7xvo//SWf039FlJ+ItK/b/wBuif/V/iYvoZYl/exJHMsu35G3 KMZHWqe6KIZ8tcS/fdeBkdq/QMQ7SZ89SV6ZPGLa5WQ+SEjjIJ2jAP0/I0xJ44XbKN5ZI25OXHsa 5VJWLlGxvT67AsMgtYPs+2JRgtubOOfz/rXNu7T/ADhjtb7ynt61yzfQ2FtYzO8kbYAXhJe/tV24 t50iEdtH83EZdRhjn+VZhY//1v4jFh+yXKwy4mR1ALYHBq39h+9IZDuyAI8YAHsa+pu9jxy9NBJB bmeIIXXrGHAdx9OtYFzazOseUZI2beVLbiSfargupVmpJMtW0TRnHyhgu1Y34D57VSaeRJ2jw0LI dp3fdH+NW4p9DWTshpkmSQNIPMKnCt1yKtfZrqdVmRsRE8lSB09vajlj2EtT/9f+Ia4s7mXcDvYR jOMdahisZdnCsGIOcjA/z/jX1Ukk7HnXSRLDCkKSzXMg4YRxx7eSfrVsOdgKN5jk4+QYwPSuUylK 42W7ZtoYMiAYeM8kn1p03kTRYDHsCOm2glK+iM1oJIXUxoDGeDk4z7VtWgaSRY0ABccED7uASf61 jL4mbpWVj//Q/ioaRoEaLcCSMcnP1OKg+ZohshLFjjzMcAV7B55nzW0cMqeapYswy2Pu1FNaojbl cCJTnzSeFH0q1N31MZfEZLhyyuWklg83BAJTcAfSpVnlEjyRxYiHVCcgCk5N6GqvYu+cGmSWNQoj jG5H4Gakivp2D+ZGc7sDbyAPWpMW29z/0f4zPBotLmWcahLHFHEm+ItIIzIeMAZ78/pWh4k1fTrq 2ewtrNBNCxWa537ml9Avbj1r2DyIq8kjzO6gEQWcO3mkbVDcpUdqx3BiS8jDDY6LQblmSKZeMtIW XeG/55io42kSNlLMyrySecCsWvesimrdTRFzG0MSJGq+QvzzIOJAcnn1NZ8r+YzEO7REfdHLcUrN aGsUktD/0v4h4iWaT7yRxjaiH77k1MkAZ0Vx+8znaDnB969A5zVvEkESI42hcYRThSP8iq9pJ9kl uP8ASJEYRfuQRuOT1Gf6UHOSWtx5Mq+WfmeQFyRwSeprr2urC2jCxWwW65eW+R9xyPuqB/WgfSxy 9xcM1xLMNsjMRsXGTnvmkvHgSGKJGDytHm4jGAEJOQP5U0ruwNWP/9P+ItpJ42iAHyBui9fxp128 UkiOhJCfe4wwJ6ivTcLK5546GUSgWtmihgxZpCcMRjmrX2SSOIHbuz82PU/5xUG0PhRQuHmIULtD sdr4HOB6Vcs5jDDsCvuzxvX5F+lA7pOwryHgljtz8yr3PvUrQLt8+MkjqU7rVW924z//1P4nvOYQ bUZnA4bP3lHrVy1e3EbeZhX+7lmxvr0WrHOWojDGNu5Qc8nPHPrWXf6ZbvKHYx+WwyDE2dp9Meua 3OczVshb/ulJYk5ZCO3arSmK2jMczF/7gI+6aAGJDIsnnhtoAyrZwQO/FPkui+RGAWXgh1zu4oIc X0P/1f4iR5qQ7J3BdjlSwC456CrqyiNR5gWPAwT6+mRXrSlynj2toUJVbDBp1l3jLsDke2ahsS0e 9JmR4Q/AbhlFZyk3oBoyNHA3AJjkXIIOWBx2FVoriV2XzCirFyseclj6/XipGlfRGmkoclnYhQu4 kr6VltaxyxnCsCWJJHLN+FBta2x//9b+JG2s3jhChjg5U561u6UILdcStuAYsFHLD6V6B55uCOK/ ia4QrAI28sh8Bj74rh7+4nim2vGGi3lTIv8AEPp2oNou6Io3LNJ5aMxKAJzhUx7VoiZ5bS4EsKb2 i2SSEHEa5ByPft+NBTaW5l2aRf67O4gFEwcGmTmUF41GY3GAGG7bW0VaKB6K5//X/iBgmt7cYYO0 gGPkAKjH1NKJ2upl8kBIxgOrNy3rXsWPPNFzd/NFBArnZtLcYAx0HvWfLa3dk0QnDRmVdyBs/KDW DVnYTdlctW1qywTtCxVm/wBYCdoOKy/OLMEYBtjZ2kZ3Y9RSMBbi52mV/KBduioMbT9K0bWRTbhh vSVhzHINrd+cUAf/0P4gzeMXMMcfmzE7doOADWnNFN5aZRRIq55xkGvQPHMcwyRxPJJ8rSMRz/Ea uRq8UETlwkTHnHzf570AaEeswvbC28qKAxMWE4GZJP8AeP4VjTN9qmhdGJkd9vmJwMe4/rWkYdWN DLjbZ/uNiyzsclwd4H1FOinYhd8aMScFWGCPcUppLY2jsj//0f4grYQrcSMkGJJHy8mcirhtWlfE Yd5QcMwGeO35V6B5zjchVJLcPvy8iudrKOW9sUxL2PZ5YDPcqxc7wcYJ5wPWrmkrWIcNNBGLDb56 x7GYkIRuZfQ00TtPhFLiSIErIowDUGYsk5khWLIV0U7mPyoMGq6l4YWIZNxHPZm+lAmrqx//0v4e 7JHkkIYApIvUnp/9eu00iy4YfKBGDgHPNegeE01GzMLWD9nmc5JLPjbGcbR61NZ+JdSs4jC2oTpE uDFD0C4GB0HsKPIUF7xm6nqF34gu3urqeW4uHbJLMWd8cYrPZbm33rFlJMchRudcdqi6i+XobFpY 5ZlilbzEZeSmcIp55I/z1rRtJgC8rnYiHaPlyGNJz7Af/9P+IGaQXVwWCyGMNhWx39KlmE0DwmPY GAyGVsshHcjtXe2lueOT201x9mljlxckSFxhQr88dfQVBcZKSsF2rbqNq5AJJ44HelzJaG0FZEFh qz2juY4/O+0RmKZJBlGHvVOWOaVJJI3VQrD92vbNVdJXEk+dtk8Nuq/LJlSV3Y6o3tmrr3s0INs8 CLEF+VgvI7Urq1yz/9T+HYXM8ZzuLddqrkKfb/61aWnyyTK0YURFvmdgcZPc16B55WvUKBoxuYMM K5GStVbYSWyh2BKt8o3Hg+5FZubWgDnvJUn3KW29NgGfxpZnupU+QmRc5IUfMB6VmBpoloLVy6bj MgV4yh8yIjB3A9Of8ay1it4El8qRpdx3KrAAQ9iSfWqcmwP/1f4dYbiNTsLSbT8qsOSTVqWNFVpJ H8mJU6ou85xxmug8zn11KkryzW/kSn/R5F5K8BsfyNUZWdgqoH2R/LjnBoBSu7EtvO0MsahAoJ4P pVqRLieXzyxfB8sAn5Tj0oLLiu0T4k2kovQYPPtVU7hNuwSSdxDjrQB//9b+IRW82VPuBchVB6Dt zUixSWdztEiyOrFlUn5ZK6Dii25E4hjSW1uLy2W6i84PPETjPqM/nXSeIPFOmXmmxaZZaJDp11Yp stp49zI6HPyv68nPb9TUuN2nfb8dGtfvv62K1lZ+f/AOIS0uY1kknRN0oDtGD83qMfpUsG9JFmjj V1K7CpPKVRZqw285h3bWCzkgZ4B7HFUNRnl0+NIfL3s2Auxt20E88+2aiMbbgf/X/h2uoA8YlilY suMEjoTjitA2Xm2oMPzyDHmKDlhVS+IyUGylPpM+6Fi5DLgKmQUA60y4vp4UeONVYB8MSuSuODip NTMs3lnkaSS2W5jDkYJ2N+hzWmbF4Myn5kkwWUHLJ6f5NAGxZGIZWeV8RRnyRs3bm5wCKriCaZsS yBvlzgHlfrVwaWjA/9D+IgWUdvDsWR3ZWxyuFAPPFVreRoJcKNwJ2shOFat1JPRARXU7RyIeTF6J yfpirUEsQQyQsYboPnGMoyj+Rz/OspasBst80kZDZWVTkydN1VxdC6tthcKY2yDt+Z/apAUL/oqM 7ygFyG3LgKvqDWWY0kuI4AJPKyAfMbORnr/WgLH/0f4go7aGSMxxzLGYz98DOfY1DsiMbNt8zB2t tOGX0OKAEhIt4mcxHdv2bFGHkHr+tWJohcTALAIsR5K5+ce5pNJoCDf9ndUmmDMVwoK52gVpSNCU 8pGUmROBEuPx9Kxaa3A2fJZIN8oAeO2D72xvPHp61SS8N0FUQxqVG13H3pPc0tiZfCz/0v4pBELS Vbny45ivzCMnAkI7Vp3OuLDaIZgvnSIGWBW3Aeoz7H+VZxb0Ri2rIwI1F3G6TblUtllUlQuew9K+ s/2eLC1fUwLRJjbS83MbHCL9nVWJVu5K5A92r7Dgel7XirBw/vo+E8RavsuEsW/7v6n7i/s66VpN 94++Guj3tvCZLy+t2upLhT5aLEd6j0BZQFye4zX92X7NVlDYfC6ytltYrRbEfY5okbGwbFEaqfQj nNfuf0jq01LLsH9nlv8A+kr+vU+M+jjQisrxeL6t2+67/U/BP/gr94kmk+2W8800j2N+YJ5FhV3e GEO3lIo7MIiC3+1X8qvxtuTF4Sv727uBZXVhpzXcVlcs0NqLduTtzwroSCAff0Of3TwdhGh4Z66X Tf4I/nnxUvPxh0V25R/B2P/T/ht8XXH2vUZrq4MzXs1wZJPMYOjIfuEH6YrDhMwkDIMqONlfVccz 5+KsW/78vzPnsghy5PQX91fkdjphCWrx+ZIqs4doyxAUjp/n3rWs9OsLt7m4uLsxbQG8qJN4ftjO eK+LqntR3RsafMdNgi0f+zbK5shI93bTvMzXJaQYK4BwAPrmo7NxbtKkKtHKxLeZuJx7c9q55Oys XC9zptFVb+BXjmWC7aVke1wN0uMbT+P9KutEQBNIUYI3lOM5UH3rknvY0P/U/i7uxcRM9yJ/LhiY 74VnUblB7A8n8Ktacb7Ure6uNL1C7tbOWRrY3iZhWHaO/txz1zzXgJuLA2Vmis4NLgs7IyxtaOmo F5SGmny2JievzDHT0qsmnXflGd0ZgxJwnzAEds+tIaV7ircFrUYtxcbWKzQtySO3HpVm0NvPp80d rKv2yS48mKDISJSBnDH/ADispSvoD3ZtxKthCWnEjXjkJKV/erhRgbT6da3bYpKqrExBfqrnaT9c 1nJ2VyoPWx//1f5GIvJF9NaXiql3ZqtyEV1nhIP3cN0zjqK7vw9bzJO+trDbPBNI1tLbkjoBnIQf X2FfHVHaGprDSbP0H/4JyWd3qv7Q/hixutFtzoOp63HBdXoBWRRHMnBPbGdob1cV/oy/AzS49N8E 6RaQSiW3S2SONQwbyFTKquB0GO1fjHFLUuIV/h/I8zBy5s6mu0V+Z7xCmzA6c/M3XNRzxRu2VcjB wwrg6XPoJfEWCyhEQHIAwSetK+wDkfjTp6tGx//W/onWOW0EqIY2OSjOMH2ODXyr+0poVnfeAPFU 728r3SaDcJAI9xdmdeXOOcAqgOK/k/FrltKO6ZpXa92LP4LPj3pMU/xH8WSy28Ru7TUZBcO53zM4 dxk5HDAhv09K+TdRubaN5RLIwm8w7Vlb5lHsPSv2jJPfwNL/AAo8mqrbmZczh7IRPIiw3DFLiNn2 swHbHvXMZhiza/aDb23mbo2VdzOxwAP/ANde+lYie50UMGpR3FtbWxP2K/tWV3cCMMwIGMnjHX8q ihMdoH02f/j8tAXmmUmWJkYnaVboTkN0rWmupB//1/41Irjz0BubaONYGMcZjYvJcjcdrv6ZyBx0 AplrHBpszMIpJHu5jJ8+ZFXjnnsOBXz545vXVvbTLFJE4USJ+9SP76Edq5iQ6da3nk+cqTSPvkiZ sTTL3Zfpj9KPIuMLvU9FsbzQ5oLtpmkN0kAa3LPsQ5OMD16j8q5Ara2N0b6YvdeXu+z2ZkPlc5zx +XU0G0Y30RYSHTtXuGjMsdlJb232mWV3BCp124zyfQDnmn+HbQW9nep5Yh+0SkQTxgNvC5xu/PNH oNxa0Z//0P454dCS2huLexjs1ubmTzvOuxuLMDnG7sD3rX1O/tILi10W/lsf7QtLZXsGsilxE7yA M8JkXqVBbr3z9a8un2POcU9yHVNRWWwt7U6XZyJcZtDJLGBPGFGS5Gc9+vQ5rLt7W2s7SHSdMmto nvMqwhO1EyfuuSOOg6eld+HujGSSkee+I7RzE11HL5RZ/sqrJwrOncL3Hrj2rhZI58PFI6SvkGOQ j51H936V6tJ7HMfYH7K2rahY640E8CeZFNEkNz/qcIzqSgI4O4ZDA8/KBX9HvwCu47H4i+Eru1lv NG0GxuBdusu2USgKBGOfm2kt1GT7mv7g8EsT9Y4DxOGa+BSXrdX/AFP5V8TMN9W8RsuxV/jnB/dJ L9H95//R/r1/ZKv7q6+F+hSyyvLBJp0QswZdwi2ArICPUtXwj/wVf0WfUvh3qjIsKRPYTxxIFwzu IkYs3fGRjP1r9LyKUcP4pJr/AJ+v/wBKPA8X6bq+GeJfX2S/JH8mn2O91GzguJCGkitvKaRh5TO6 DaeO33TknrWFPLcWIFvKIppFUO7RndJESM4zX+nmElendH+R+NotU7MybGe+vFeHTWlFpHqqi+Yg gIwUkIBj+IKcnNdXcNaNaRmXzRtnOyS4TYMqSMEdeuOPeuo51StBIwb7W1eCWKK0muPskf8AxMJL fI2Ddjeo64wR+NbVjCRbRySSh4Z0WOCIxGNwuMhSPb0610xvzaHLOnqf/9L4H1V7hlV1kneyhuft NusTeWsjL0A7Z6Crh1ezm+wRSaTqNlFdxiO41ZZfPtrdwBuMkYUOOOcDOM1/tAf4uSjpoWr+y05J 7mTSdTt9Rt4YBKGeFrcXg+VCEUgHOTn5gOFNZWl2dxcabfyWsSSz2NwsV3Dc/uTCGPBXPUY9u4q4 aSsc0oq1y1oK6bBqLnVGuLeC5UpcSwZSVR2wcE4GMcDvV0ax4ehuo7zT7O+u4F3JJb3N9uu129Ge UxA49tufp1rXW5yyjFaFOx8QLfvLc3FndW0q35tYrpsTWEcfQYULkMDjLE9+lVJob4XbtC6iOK2c GVjtabdtwFHrjmt1qjlP/9P4KitLuX7LZiaKeabGcZUJn+8D3p6Xmp6alxY/Yo7oXjCG1G7YEdWy X3eoG7j3r/bFaM/w7qOxHJf/AGGwe/vpniRZRArFd/LcHOOgx3qa3tp7y0caUJBC0nnzTTSEm43d QD3+g46VucY9FuHtvsKrLdTIojso5ZD5Vp8ynCDuPvHB7sfwu2OoeI/DGoxai1u9jJbtshnliV0f H3vlIOB2z1+lZuLvdDTtsLoV1LNfDbY5hkleWS/87ADN83yx9ccnntW1rFiLK2jvXs21LG9RN5Sy Pa7iCCmORnaOnpVpWVioOzsf/9T4rtUeCNbppUaaUsBZZKFsDjd+GSMVBFNpzypHfW8/nXDHy3Ri kcGBk7yRjnoAK/24jHoj/Cypfcnl0hpy8ttPD9kiP75i+9rbpgvgZA59zT45J3sL4f2i13PuaMGU kPyOxxkjqM9eatQfUwl8LMOSzlji0+58x7YpA0Qit5tpfPDiT164xXQ2lla/ZJZEvLZ7x497RB8N FxwpHrwenc1uotmDV1YbevNFY2MljMtvdZ23n8UiAAZUEEd8/lUA8QahMsVg9y7xrMZ1j4Xe5ABJ xyeBwD0ycda2OeUejP/V+PLbV5Xf7NPMY7NPnZVziRgcEHA646ZrQv8A7HeWaXEdzEEQm3jjiQRy npncBye3Jr/cg/wOlC+5BodrZzSfYJNTs9KgEBzPfK5RyCBtBUHnr2xxVV73+yp52smiufLyn2pA RGydCw6dvWqjJp8phKnbczBqMU86zrIQ8y7VO0oD6gD2xVmDThHHLco5HmNh1PJb3+lbGMoaCz2E 6yWcltGHBBe5Ej7fLVRuyB3/APrVYgD/AGYzW80exmZmAGXj/hwWxxnFaw2sYuHY/9b4ommv5ZIY /JZ4HYW5WJ/vBhgsT19asndZsbT7KoeBQChB81t3K/oR+Vf7sH/Pw1Z2J4Y4rCAi4heR726RysUe biTJClUbHYAmppZYrWK8hRJIme9MaWtwpW7Rc/IGH5cepNAiqkkbjBZvNztIx8q/jTrm2kQp9iuB MY49zmaZtucglEXoByaALrRTyQw3QjVnV1jaPIBX8uuK6GW6hubWCC8mFsY5QYQx/dLnAH4+1BnP of/X+XLy4totMnIfMudsgQbmkA6bf5VyURmhCtBGkIllWSZZ03EpnLDvgkcV/uwf894+1s3tJXjk TYCvnopcPkMSQeD3zn6EVHc2TXFwL65BaC2iIjCLl4j32+x71UbcxnJvlGLi5CujuIzgo3Xii6kl jEcaudiOdr9Aen+H61sZN2RfgSKYK1xPb2jdEdz5Qcnv+mfzp8UWnXlrNdPM4EY2wurZFwwI5PfG CaEr6CjK5//Q+LsBWzDsleNfNAHzCpbjVnmimEkEInaXe7IPLKdcgKOMfhX+8Uo8p/zxyl0RHpt/ FvCxKJWlGxSGwUbPb8sYqVpLm2e4MTyAupWTH38Zzg/kKIx5iG7u4ulXL3MU73CLCsf7wMxyZFHR s44+lWryQThJXh22ckeyGWM/LMV4bp+GfrWqXKrCIJbnayLtOSgCDb94AYH8qgW4zcqJoS+f+WRy F/4FTFdI/9H4unVwVEShAz/KBwqj0FOtbaMSTFn3bMEKPU+tf70H/OuXYbazYym6ult5D/q444y8 hGPvH9aLe3N8yqLmK1tYJCguLqJjJP0+UY+nGfU10LUCOQyWt+lnZW091LK4WERrhpMgcj2H9Kt3 F0NPnnS/jxKyfvyBueBhzhvpjms5ikrqxisokjaQMZIpWyQVwoz0H5VowLHCqOCpbbnYP4f8/wBa zMlFn//S+NknM8u1SuGkCktwBzjmrspmju9iquxDtLo29eD2r/fA/wCdWCstRHjjaRdkgEWMt2AJ /wAmq88O4blCPjgZGUagoWK6Eu6NwF8tPK2hcbQOmP8A63rUrRLbx+YNw3j5SSeP84oAbZyvtZAr kseCecmkG+OcyyQb2tTukjkQqHH+f5igD//T+Nb1kmRpEQLjLCMEnHsKqRTym1jlLopdivlNxKmM feHbOf0r/fA/51J7FiGa3nWSGR3hlTDhV4WUg8Co7oSOYnYDbH8oIGKDIatw5Jhldyn3owvBGOxx VhT54d4k3JA4ilx/AxGQD+HNNPl2AtIrzbkmwoXoRweKpypg+XEF2Kcyg8sx7YrZO6uB/9T4z89Y juj2qH5aMA4j56c/h606CeTztwCOVOY0dQ4Pvg+lf78H/OeQ3CSNIJRkN0ZTwDQZNsEkSgZmG3py n0oAY8v2WGCxYZ845LffOB79qZepKUiEAHDBVBONxoAtqCkoVF2Ertn8wcqehI/KmySxxzMGDSlE 2hsEA8cc0Af/1fjkXLSRoynbIvDFcBWA4GRVc3kqkpsWVZCM7hkD6elf78H/ADniyOdpeCNTtGXj fjNWZTbyAXMUfkzFczBVCR56fKKAK8RgkI8yUYZtrMOSKSJBtcIp8vJ4fgiqUmgKrB1kjMMfCZLt nGa1lnWdOg3Lxik5Nu5lJWeh/9b5BW1Ti4mz5SAny84EntURkmmnMcRWSxWINInJKsen6V/v1zO1 j/nMUCO6uI7cKiLgLx04FXYLuGDybpljfyXWVYXG5WKkHn24pykyJKzM1rk312zNjDyF2IHrzx+N XYozDvSPaFdfnJ+8fQVBI0RucRlexcY9B1/kapxzxtO8LIVaI5HmDar++f0o2LcLLQ//1/j+O9ji jkIiA3fJz0zVV5VmfYVCrt+Y4r/fg/5xx+HtoQI1BTO4gnIGfapLaeaQySBVI3fcPyj8B6cUbbAW J1a4dCCoG4Bh0UCnyxyxqsS+WIguAURQ5J9WHJ/HNAFaGJIdwY75CMsScmm2kxuJriH7O4MIyJH4 icY7H2oA/9D47to1imeRo1LsfncndjHappYBKGZCAw529261/v7DY/5xzNgeWTypYocBZNk8c3yu oGQSMfnWkEWG4eQojpJFgDP3SR/Ss3uFk9yp5fmrvKmKZm6EhjjPSrkNiEj80FmyfnXqO1OLSeou Vdg8xhuLKQFHHpUSouoPH9tkubm3tVJjiEhVI8+hwfy962DlSex//9H5FMxZgEwFX5FGMYA4o85b eR2KsyTAAHfgRt7Cv9/7I/5xxkIlWSRS6AkbmywHHsc80y4iZOUTezLvCqfvcVHs9QIopDbQ5nWS WWSTJOR8ueo/CmT7JZBLGWVNuHQ8nNE1ayASMZ2pj91Dnyzt+fnAPPXt0q7DbXDXCDYZIjhlOcZ5 6VmFuh//0vkW4TFw03lhSwAOBgAKMf0/U1GoDzJvQbR0OOa/348j/nFcUyY/ZSzrGWMyyBdu3r6n P5VFewS22yXbvhc4kbrsPb8K3snqUVIEZpGwqlW53Nxt69KsyeYsey0KGVjgBhkZ75pgMlNwuUYL lAN7LypNV4phEPnd2CkkKScZpOKe4H//0/jtdQkT5NiCMkkqq/O2cdW/D9aekhnEjIPK8tsHI/1n TOK/37mktj/nHJ418/crLtxwB/exVn7DiJZpSIIVOHdgTtycc/nVQ+EBfPhSOWBAk+5T5ciA4J7E Zx+tU3hMFsMECRmzsI5dicBVqed2AqTNd2qLNc20sJZ9jIy4ZOf4hSg+Y6BywyOB0FQB/9T4/eMD dICyiJCZOeMcc1UiuyMADKPyjmv9+D/nHGOGeTbs3YbK9x9anjuFaR7dyFdeCpOCD9KAJHzEF5GM 4ZR978qbNLE0PyOODll78UnFMaTexKsiygMThduMhdp/Gn2aQzNKkkhRY4y0ZKFvMYdF/H1pSWha hpqf/9X5Us72XTP39u/k3Kj90+QTHz1HvjI/Gsa6nkuJi5OS33lJyK/30g0tGf8AOeklohBEiKVE CybwQX7p3Bp9vbS/vPLLIoB3lfT3rS6FZXuMS3WJxIf9JgCFm2HAycjB/GoFht5H/wBIadVOflgl 8qSkmmMdDa3H2ZzNH8iyEK6nIAzxk+pp8U8KrtdvmVtvHBHes/dctAP/1vjgy5ZgWO0nGegIqMIY pSSp8tuhHUV/vwf854kdyEkZ3iXhdiFxuHpnFMG50ZvlwSdrAY9aVlawCoEiH+kKWB+6QcYPan+Y qMJEjwo68daErKwEgdLkbiSqg/Q8VXMa+c+QzrjPynHSmB//1/jCOIeYDv2dge1Xtyb8cFmG1QP4 j0Ff78H/ADnkb27MmwKZJj94KCSPaobPR/tchUXEVskUZY+fJsWXHIVR/eoKirsfLp8Nmwhk6SHz It7Bt2P4h+I4+lV40eaRog2BkktnINA+Xcoa15ltp1wWLtBFGSWVPMaIjoR6ZOBn3Nfin+0/9nHi q+jEd2+JfNtHdRFPCCB1IOOcgn1xX4746y5fDrG+j/Jn9M/RZX/GxKT8v/bkf//Q/ixvTC0fzplu hHrWCYl2iNox5LPu45bj3r72vrJr1PnqN/Z6djUIjgtQCirCzZUgfeI7/wAqyZIJJJN0AUgHdyM/ hXEaSd0jOmfe7iVdpA27VHJx61JbrKANqhUkG0hzgJ7/AKVlNWdzU0ktDZToZJIni2CQlGyAT2I9 a1HvNxwnUrgY6VAH/9H+J37KzSRvLgAHLAnrirvnRzAx4VFXgHpX1MVd2PHKRljWSRmkBYDkA5HF M+0RsfMkYqFGAOmfoK3G227mNG8rTMzsz5lxG2flUf0rTnsZG8uRyCBltw/kaBuTe5USMRM3zZO4 k7hwB6CtC0lht1dUOW3bzznAPtQK7P/S/iladZEcbsEANwKrtqMXlGD5cg5EmMHuMZr6ue55V1yW KF1JE8PlICSSJFOO/Q1HauikbQyyEY9RnpmuV7iUbovq0XmxxSt5pReJBEAQ3p/9er09ikAjl8pw Zhk7h8r88ECkVBdSrNDHIrKExtTcoX7xx14p2nyooCxnEu0oR0OPTPvxWM17xof/0/4lZIme4Mg4 5I2yHGav24d4n8rrHwFP3c+leweeV/N85yZ28oEbfJb72RVcxfaFZduIg3ABGTj1FBMrLVldoEL7 FbBVc+VjkD2qWOBV/elQYiNp9/8AOKCh05sXbMMDj92FC5IAIAyf50tvb/aJWEJGY0G5Og596DFx aVz/1P4nnSG2kji8wHeclD8q5HOPrxWx4fstNuJri61KO4gjYMirC48xj2PPGDXsHkwWpS1WysEd JbOe4kt/MwVuAAF9se2KoJYqzO8GFZRzzgMPb9KDYsSLO0BaOaNY0IWQHjd7CsmR2YgRICucyqeA cYrP/l4BIokaFreMeWkpxJtO3gHtTxcwQBIGjEbqNobore9Vy+9zFxly7n//1f4lJj5kW9MIVOVI 70+2t2wZ5H+6u5+vPuK9aUb7HHKWlkS/aWlARgPTJ6D3NVJZldgu1FkQ7Q/Z+wrOS5TMYCYgCCS5 b51A+774pI7i6iA3HfE8m0Dq4+lJJtaFximtTQi3GRDEdrg5XJwVPUYrPmsnjlZyPnd+XJyRzWkY 2d2KSSeh/9b+Jz7NGyJuyJC2PM7H2NNu7MGRI90e8Jud0YbQK9aXws4EruxRtdNMkkvlZcrlgw42 4rdjaSKBcFH8vhkfvWSTexulbRHLXMjGQDIXdkrt4UVq6cH2sjuGA53OTn3oaa3JdlJD543WRRbm N1Y4O3kH3FOWOWPERceZnOwtyc0XdrFH/9f+Ji0hu0mMOEkZ/urn5s+maspYbZmM7gzByDCT9wjg DIr0DnKk1tcx75FO9nbiMNlcCgXbQoqGIsZuVVlyBWsZXdmYNk0Ud28iXscaboP9Z5jhA64xjBPP 4VlzXRMuWTG5/u9fLFNySETTFdpaPc5YAcnAFRhhIqqreVOhy+ej+mKzcru4H//Q/icNpJcRLP5s crA4CqOU464qhNaNE8sLF57kgNG2MQc9QfevQPPsr3C1t5A0kc8SjcwL9sAVHcWql3wVVB6HAIoM 5x6oiaN2fy1YMMffPCqPas6TfDIQuZNpwrg8ZoLSSVkbFvfmWNYGQI8RwTj5pM9qkljlhlWRSyjA yByF+ooGf//R/iaJ8pykUxkL7djldqAnr1ouVe1YmeT95vwJI/mjbHoeleik3scCV3Y0IZ2eH7R5 8bIW2NCDsdcDrj8+azZ0uIYpJ4yjLLlUVjljz2FI2SS2Mm0u23fMqgsdvsKsveRyBhhgF+VscCTH qPSq5HoKUbjIPKQvKf3ajkDHGfWlmkEYZ1Jk8w5yfu4961SsrClF9D//0v4cWglNz5yZWKbKhVOV zxkkVaQfZcqqrI7Hh15K+1eweea9rem3ZgxXcRnrSXLzXR8wLIyxrk7xuPHXHtWU9xNXVi7atGjC O6idIygZ15DkeoqC9h07zGmt7fyicFUXLHjgE+571BhYzjasAZpsKxYFQRknNRakJIJfNG55SozM WyxA7UAf/9P+HyF9kkc0TYfrI+OvqK0rjUGlcb2VhtxiPsO1egeOYU89w1wCVZo88K2dorTSaRrM mQKoTKog7/hVQXvAUIrXzdySHDEZ2k8FauW8ElswdY/ucAE8HtWwF5bVrhiW25bhiB8wqJ9OAcgE 4ROpOCTUTWhvHZH/1P4gIFkBaLbnaf4uGx6YrVnuZjGEVjbhOVaH5HP1NegeeU/NkjZLkkOM7WRv cYzUctup8q4j3NIXO5UU5HpVzetgM9zOSzSKx2nlSOgrVtrWRlSRMKkycZOGWoJcU7kAMMGYJ0DF uxPzZ+tPFtG4XIyc/L3/AArNyaehk04ux//V/iBmP2WbynhMTYyOfvZ747V2unSTQWq3gaKdSm1o gRvUdBkV1OTZ49uhzWsZmkWS2K4blowMsuMdKwGtm3b3c/OM4cfMhqoNuWolFLY0rS1dCtxCTkYy chcY6kCttTbQieVFVjHHvlJ4L/T3qZfEzRQbIbOW1lnUsVaNvmkXb8qj6VJepFLCLe05CSbmdRzj 0xUl8kT/1v4lJWWKB4kjZ5ywEAiXOWJxz6VBd28MU6QYJnjjCXLiXeGfPIGOK6520PNUFsPfMEZe Mgl1CkEYZcdcVSdYpVjj84b2O4nJP51BSVtBz2J5RGTerbPMzhWHrUjabLaWS5RRH5u8svVh0zVN +7YBkMscSMy4lBICxBvnLVu3+kEW586ORDsV0G3bgHnJNXFXhYD/1/4g0sCu0lsqh6dSwragXR7a 0nbNxHqLEPGwkHkBRgY2nnnmvQPPK1usciv5jlg53Rq3QetU54nLvFsOwjKtj5RWD3YGbIjxngiX C4OzuKdp9zJGzQtgeY3A/iUf5zQ1Z2A6abT57i3L22xvJQF0Ugs49R61yMoSCZo2dlLfK0RGAD9a QH//0P4bY1Dvt5BX7oVeDitSBi6/MFMecOrV0Hlcvv2YrrAmbeEN5bDcynPX0z+VFxLDIIk+zrbu FCNsGFYAYz9TTSu7DUbSKPmW6pPuX54/lTEeWY/5706wuS4MOwbiNyg87fetORGg/wAtUy7lmcv5 WByQx74rUCIsSs0gQ7fL3nqKyA//0f4gJols1Rny/fI549arzXaTSxysjusPKsR8wFdBwRdncvC4 M8kKLIdjEbz0jRe5P0q9dDdEfKKDjajYyz46NQaR1ijER57g43NmNtsjAYLY4qxI/koNh2CM5cEf M9JuxZYttRR0JTfnbgBgR09qimkM06usQaMIAA/ILfSmB//S/iFnElwFQpHBjkAfKrHtmkshcKzK HEcj/u94ccj2q57ijsgk8yO4NqG84REM7o2VPqAe9Up0+YqqMpZi3I61Aye1WCNlj2OWXlmXjJ9K 1Wii5MZkLyptb0GOlAFR28oHJyxGOR0pkF2sKyFFBYH5S5+9QB//0/4i2EzxRSyNtw+ZIxxhT3xV RUXzUwuyNZCRI/Idc9DigadtiVfKe5ijHlK88nAb5Uj7Z9hmoDG9jPOLhoZd7lUWNgQPWgRaGmpc kytOsS+XuZMZHTgUxktbd4YI0HmSttjIG7zCBz/KgFoWfLmuIrhHhYND821xt4GPm+nNYTER3CeY wHO0lBkD3oKirn//1P4h/I2GR1KiJhn03GnSJHI8ksTBbjygJucM6jpxQNprcSOITXCFSxXaCAf4 cf8A6qlnVbQSTMTI8nPX5TjjGaBxV2ZZdb2VXeHyE+6vO7f9KsGSSzdArxRg/Ku/kge1YylcTVnY 25/Na3C7y6H/AJbr8ykVHpVumNxfAkfG4nIwOP8AGpM5uysf/9X+J252QiWOPzZ9pLAfeK9zis+0 snuGLliFUY8uYYlTr2rC+q8jnNZLaaOeFHmigjDje8i5iYdyT2r7s/Z58Pi2v8x3Et7p5hTUd1vG HWJW2qQv+ySOh6YPWvvvDin7bi7BrtJH514o1PZ8I4rzR+6X7GOkDxP8YdKt7i2kmsNPtLdbRfLx G8kso8vd7jygo/3jX9wHwljRPhhbyQW5ibUbJ7mcKmxIHVdsarnpjj86/VfpGVHLPcDTWyikeZ9H yh7LhSrV/mb/AAufzIf8FVPEMkfxF8OaMzyN/aLXD61LkbtPlCSrHGVPHKlzz7V/Mb+0/qF9eeC7 /RNS1GaWCeG7trq2hI8yJB5YQpnuBI5OP7vtX9KeHUVh/DKm4dYX/NfkkfzBxqpYnxhbq62n/wAH 8Gf/1v4Y9ViEN3LCUJFsfLjBJLkKAorOt5CJjt3RuhzyMcV7fFdT2mf4mous5fmeRlcPZ5dRh2ij aE100DvmMqkm4hflYA8c1racJYUXAKQ3hw7kfM23qB/nvXzE30PQS1VzcmhiOZbGcy+QoG2QEAN3 A+laumabdy77htj+Yg2RbhlyOuK5pvU2iuVWGJaX+n3kM1xHHDJ5+2MK/Iz0xwOa7WbTUjtXt7k3 EETuZZHGXdiTuLc9c+lckpdWM//X/jMuLHSdRvVzbxyKuFQzjy1kVf73Pf0z3rqWk8qwvdLtoLaC zvLYRyQRHbFGBj7hz1xx+NfPgZsCsViVAwEeEQ9cY4x/Kta7guLTTfKsVzM8u+ZA+CVPU49ck0no jSn1MXTWCs8piaP5jGWPQkVpLp1tauLjZEJi5nO1BnL/AMS/UYrDYfIrk908kUuHbeUw6GP5jGSP bvW75CNaR3Ee7d/Eo6msnJtWCMLO5//Q/kEt4xJdXUMbRSXLxLnav7y27g/pz+NehaFftYL9nuY4 zDbDzXmhcyNMGXuvQYNfEYh2gbQXvs/Z3/gkv4Uj139prSCtsuqaNp/h19ZvrOWQtYw75RubIP3m wrAdyoxX9+HwkghtfDGnqqNayNEoa1C7Ni4BQY9lwPwr8PzypKpxPUjLZRX5/wDDHnYGmv7RqVVv t9x7IhDgYJxnHI6mmyRSKBsAJY5OeeKPsSPce45hgYbGT2HWkeVdrZBGwZAIyD/nFOlujc//0f6G vMBVovLOMnjP3q8U+MVq8/hjXUFtcXLHw/cxW0Fu+JyxUgbPU7iOP51/JuNsouLNMSrSUl0P4UP2 yLWHTvid4hudLsFnbUddbTp58GCMGODzXdxjGQ2QTxuJPpX56eJdOj060ttX1C1tbmW5uHhmjRSz 2aLjbIe/J/kTX7XkP+6QXkeNUnzx5u7/AFMfULWzuLEXVvGtw6YKknhOeCPQ1m2OgXslxL9pMRtn RLuBDIC7gjke3+eK98lrU0tCnntLm+stRuWuoTL/AMSlZflW1D/eXPfB6frVvXYNPS4srV73Ze3h LfZrdd7GNOXYt6jK8VrT2BJvY//S/jMs9Pea5mNtNczW+/ZEphwxCnDcc9cVqS+dqGqXGdtvapCo Rd2Et2X5dg74PUZrwYtLRo8xQtuWbYyQecvlOhRfLSWUAiX3T3rIu/JuBtfarnOGwN2R7/0pyceh ZzcRvZor+FrczvGhWBXcqgA6EEd/zq3opsbpJLBJrhNQhJ+2tcRNsiP8IjJ68df85g1grI37MafZ K9rPCtzdE7jOVKNcjptfBwAOv41fW5e2SK3R1gDS7ljDYVQR90Cqj8SKa2P/0/45Lo3FxHI9uxkW OQjKN8shHYE1Qt/C8tvdQapHDmaQZJJJdAeu3P0xxXmU9rHDJa2Nq3sH1W68kK0fljEs3QRD3qjc aJPb3ywW0v2sRS4fHytOucHyyAQD04NejRilojCas7nnviMvezq6wy/6EpiWPko5JPzkdM8447Cv O5XmS5aIb2kV9u4H5evY16tGN2jnmrM+rPgDfuniQaPPM8YCRXPlzARSxkSKpYHqc8A/Wv6Afgtd avP/AGTq9wYrmQQxGytJWLzw/Z5YgUc99xAwR79c1/aHgDLm4bx1Ls7f+Sp/qfzL4x01T4pyuqt0 1/6Uf//U/qp/YK1GfVfhDpt410nkT28ckVqZd0sDnmTI7DlR+FeZf8FLtEkk+EusXlvFJd3CafM2 GPLBozwv4qRj3r9Jk/qfii77Kt/7ceZ4g03j/Desorehf7oXP4+byaTR57qxvBGIfNZokQNIsSSk yKpOM8bsEn0rh59Ws9Anjl1KOKJJHEi6gn74spOFOOc7cYx2xX+nWXyUsNB36I/yQx8bNxfQ1dIF kr3+o/2rHd29zMs8EECDy2kP8bn6Hp1GTWXqt3v1NZdQZF09TmGC0J2hivDNu77u3oO9enFK2hwp W0KMWpO7TwWsERdtrmV1JEShsfNjoDkfpV4z6vNZM8atLZrcF4ordRM7SKNrbSOcenrW9NKxy1NN D//V+HMf8JJBbWdnDCCY96wTxtavC8RyNytjBBHb0qO5utR0y2awSK3Et1J9mvTMolSDg5kBPzZy ByvrX+0B/i++5zFrJd213c3VvGJktm8ydXUleMHaqn1ArevBdaldxzaa23Cebd25i8l5AFBPQ9Fx k1pBHLO1hltLHJePqOo3S/YLd0hS3jPnNITxtRQCcZ6nnGRUVjZx6pcXeIZbZd4cc7WtgMj5lPUN jPqK1STepxyd2TXCS28YsrK3mnDvuuI4CSzKOrEf7IzSxzwSW73FlOriM/LE5wzKM7iD0yMdK3OU /9b89raa7uNRihiZw87loEiU72CDcc+vQ1oFLx2kQBknEnJkUkrng8V/titz/DmqXLt7W6VLMW8a 28PyXDS5BkwMtketUrC91KCOGUTxnR7SV7eytIgISy9DuIHUHv24rc5S9JLPBpCT+dHcyy3HmLew o0U0BJbMWenHfjqvvzVikmezfzUmkHmANvfe9wTznk/WgDStLkaQt1bTyCG+jzKlk42TRrnAyvUH nn6V0Pg/U7UW91dX0kcq2oPk28suzeOR8nOSRj8OK15Fa3UqDSkmz//X+MdevrfWdfs9V0CL7DHF ZCG7gkkEu14sMHHYE5b9Kx5NM1i4vUWDVLO7juJPMWC8mFvGsmDnJHJ9Mmv9v4pxikz/AAwm05Np WRbsPtkNwkMiLHGLkfbvspEiTY4Zd3Q9Bz7Cta7jhj1R0soGNo7LhJDuZBgbskdxzWsIp6s5pWVz n5/KmlnaN9irIygOpVuDgAKaptAn2hGkc2sj4R5tp+QZ64HXHWtDGTTehryMRHI9uWuTGPlkUY8w 9jz0z71QeGEvauyS/bJY2mjgiT5IwmFJYj6jj3oOaTV7n//Q+LbXTZLq3lWZ5bV5OLZhFu3nvz2x U09q1hYxLKMzROfPuQdqyLgbQE9eDz79K/3JSuf4IN3ZW0rR5tTS8E8ytbrL51uzfu5HQgEKcdSD k/TFXTpcq5gs5LZY1IRkml8pnycfKOc00rMynLSyG38EtiLSztZULSXBW8luJFe2hAGCIwFyGyO7 Yqsslzbf6PeK0fmNlR0GCMq2fQjBz71sZnYi+sLjT5Y2jiW4tbZEjd5xA0hAAJA79Dxz17VzN1MI 4YY7dI4UB2yqv3iB0rSn1MGrOx//0fj+HU4YY3EVs++XAUv/AKpCoxkH+nvWLcXM32gzLHIWDbnS BDIzjoeMV/uwf8/1tbmjFD9okWdJ5U8giRGJKIDwRgHByDT7aZodUkuoHWS9jGJVuY/OVSRuDHIw c5yO/HbFBlJWkyS/gitIYQZSs91GZtrrgsAcZQ9+lTW4S2gcxXEMcXk/62aAyl2cAbMYODk4z+tA na+hmR391bRqlww8sygIVGDyQBx+VWk87WJFsLY+b/pYLNF8z7k+YKtBlM//0vkaOK/iuTFA0cT2 0Th454FnPmYAVSpBHrz1FZ5unCRWc8Ijk+zo/wA8RSbGMnIPTnt9a/3YP+e8itzE8nmnPyLheOWH oKkGrXUatDOsdsJUMapFiTzFPByT0zigmXw2HRbE2RRoFiEeFUis+ZrU6g9o1woYRfaEhYnCqMAg HHqa2i7o55q60L1rLG9/bwNBHcKV2BJFypB4Of8AH29qnlt9LtFj07SbZ0jjd5JZTJvhG45CDPJx 83PvVEU9z//T+MpktldUt43iZYtryF8lyfvfhkcCq0dnbNOsUs7oZMsZFiMi8AkKfqeM+9f7wtt7 n/PA9xkNjbRuTHCsR+0PNDsc7Iw3RQDyMHPU96v2tzOJbgMitIQ0f3chx03fX3q4NWsIdDLE0bPd SlrfyzGiqFXHpk46VFBbW8TmWA/u5Du+9lRxjI/LtWgEtxAFlNyt012CgEYZQghOOV9OuagmJcK5 AWV+r56H1oE1qf/U+KY7m+817aRIJFOFt3gBZz9fftxV1DOqOrsojHJAHJx6mv8Aeix/zvcqVzKm uTDGL3OVA3KO+AM9Kns9VmngJUFYnw+z369O3Wui1tDFqzsWLd5DL57yMrYynPKY9KqRO6O6vH87 yllLHfvHeolHqgasakk6YTyNuwMHMLoJMleq4PHJB+gqK5W6aXzXMcUzgMBFEqRLxwNowo+grK1t xH//1fj63hIjd5mRnByxVdoJ9QO1LGJZzL5E8TbV+SFgfMlI4IX39BX+98VZWZ/zrmLLLPcpbpak RuWJlR/l4xxn3zWpb+cYI1MkCGFsMGzgjnpxTABdW3kMsiL5gYncB88nTjP+RUlq816YLOCLzZZ3 CpEXCkewzQAsjNaS3EMobzowdsIH7zK8Yx9RVN797pF3b0YqC4kyH46A/pQGx//W+J45gJiCrlnb 93GOVHPTB5qwxQysywgj+IHjHvX++B/zoNtjEjSdtgZY5M/ITwBip7yWVbYRuY/tSgKJI4wkTgDA Oz1OOT35ppN7FJJxZQiRvsol3gzFyrbfvL/nNSrN5fzqMOTl8cbz6n34pxW5AovWWRPMBOT8wHHF aJeBzuC+UJDhQzbiPTJ71pFWuB//1/imeCOGVxOrsqv8pQ/K3p+H+FW7eaBUV2ASVXPlv3Pt+lf7 7tpbn/OeSmYvcS/ao2jKRGTYF2b/AJcg49O9UluIl8ljG2JhuX5ScfU0JpgOu/MkETRhP9YASeSF Jwf8+1Muxer5Crb5iVspdE4DY6gCmAt0GuLKSFppIJJiA08Z2yLz1Bx9fzNVjJcS20FrG0ck9uu2 Vyu1pF65OO9AH//Q+JLZGRZUy5kdskZ49OKlKBNxWZFOcGJs+Z9emP61/vwf855eWeERrhdzk4IA +9zT3Ri424EbDDqPxoAosoSYKkeVDgHsOvX8KuRW1zJNcBVJEal3VRwqjqTQAz7RDHJ5UmFwMdOu f/1URNE7SxxMI5CuVz1P4UAf/9H45ZzEuxmLp/ET0P0oiuhbGVIIykV0UaRgfkkKbgv5ZP51/vwf 8548QxXczRznKyRnaOhyAT/hVa8swoWJThj3B4FBMldFNYzAvmKchDyV9qutOCsTICCV/iPWgIr3 bMsW8xEgWVwW2c7euDTQ0c7yJNEsSK+IZScuR7/57UFH/9L4tkaJ8s5IUPgdicHr+lJcGSVR5SkR xnOQvzN0/wAK/wB+D/nMnHqjXxbyR5i3pGqAL5n329SfxzVMokKbt4JJwoUn8jQZAriGGSWQO+08 Rou52+gqxO7i0hnMdxDDNwnnKUbjHX/PegbTW5QubhbREMY+0zTKCAjY8sZ71Ys2lk+Ygpv4PGKB H//T+QGtYbV/3sjyJO6vNsch0HcKTwDipbm0SMST207rZJL5MHmkCeQdVyPXAGa/36UnHRH/ADjl BTKsu6ONnjC4kwMhCTgE/wCe9XYbeRt00rbWziOMfxDn/wCt+dSBVnLpLuwVyPlz0qaK4u4bbzpZ bYySqU8mMEEEHgYPAzj170AWkuopYYUeIJMyguOvPf8AKp7m+hht3jYbQq4IjXG7HTI71am+oH// 1PjZbhB+8x8p4/3TUzbXRZNwyeuelf79ub6H/OOIUjnbYCA5G3Oeoq3PJAhtrWJQBbxCIyof9YRQ p23AzZ4JkCSNIxUNkHrt74NCzJJNgcGQZ24weO+KuSutALVlEzzHGDFGcMT2P+RWul1DBK0fMq7S BscDB/WsQP/V+Qpr0/PBIwjZzvEW7nistLmUO6nKkLuUdd3Nf798jsf845bgkaMJOVBBPOByf881 duJ4pzjLxxsvyJIcnPfn8DVQTT1Aztj52o5znAqdNsWV3fvBzgetWBOpuVgYTxhUkbKrIn7w44+u KoXcscqofLVXhG07RgMB0yPXrQB//9b48t7ON7L7Yk6s93yiq+9YlUspyOxOPyqOdGg8pIGSVMZd 0bkfhX+/s1sf845ZszyJfNB5wqEfNmte9vXn09oWfGxRGY41ALjcOP8APvS5Xy2Ay3j8m3QwKobH ygnAqFr2YJCkoVjHMJTt6gqeMGswJ2uGurmS4nYuZHLlWOetQ3hU3MhTCIoBiRj83TnNAH//1/jI 3VyZC2wbCcMAuBUhs3vSiRyJbhTklzsVR71/vwf8441pmQkRcNGdvmdM4PX9KoJsjlmuJl33E74+ 0SMflz/kUASMsgkV0k8zHBbJAYdOKS4eOWW2WCJ0AUJOC2TI2T8w9O3HtQaQj1L/AJJVAgOT3B4w P8imxTCFiD1BwccUpbMtKx//0PjNW82Z1uZVba2U8tsofQZBqG9kCTJJGDwAu1en1Nf74H/OeWba d8MoHztyc/lTZru5sobgBTM0o8sRD5duSBnr260AVIvtUVrHbxFBF5wmcd+M8fTnvT5v3knnSFYg Dk7eFUUAWFmkRJI1djFJgyKCQr46Eiqa+VI8g+UKBkuThs+1AH//0fiiHAZl3blznntzWqAGQszF ztwoHQfWv981Nrc/5zzLKlt3y5KnO00trcrm4jK78IUMI4xkdKan3AkE8aW/l+XkxqEG7nAGMVC7 SMiOmVTrtA4YcitFrsAhdyVWMlf7wxip4Vlh3Ix3MOSSex7UAf/S+LJXBcY5x6cVVnV3KyIW2qcc dBX+/B/znmrayPEgMMxSYc+YDg+lUZH2qZYboTTpO0dxblsOpIDKR7YP8qTdlc0po04kWSCdJ4Nw MY2zFvnjbPIH5fr7VWjEdrnySx3fxSMW/maG7I0sZWpX10tnefZin7yBrWXzF3hlkBUgDv8A0r8S P2pknsfFU0r3UM6wqGMUOWdm2jc+TzgDAx71+L+PMv8AjXOL9H+TP6Z+ivHm8Q6a8v1if//T/iZe 5ku7tfLJVZgchzhR3z7VsmALZtCYo3lx8tyQcpjuOa+9rfxGeDSVkjHVJJFmt334AHlEr39R+VFt 51lGVuD+8kbCHrtzXEaSV0I0ERXzXCM+SqHOT+IrIWSWOT96nyMxAGMqP84rOp0KNaILMF352EZP GcCpZEijLRWhcoAdjycEfWswP//U/iYilOwiXmQDpu+b8KlW2+0Ws3JjKtw39/2r6mLszxyhb2mx WBkDsD8q45U0tygHkCbByD9w5b06VtdAMtrcRbgzMY/vKvBc/wCeKn+0SsHLK3lLwoI+Ye5rNzb0 QFowCZRtQoFUZJGDUBtk8xGU7Qo2sRwXHvVRkrWA/9X+JlW2LMEQMQuckcVlTP0/dBQTlVA5Jr6l 7s8csyWzW0TGZWFwoBC9Nmen86A6MUjUlXZcvgcZ9K5jaHwk7RyW6+e0mc/dQD5vrUMFxd3kUKie eWNCVVmkP7sDr9KBQWhckE6rvikOSnEuORVS382PcG+dmOd+OTWU1qWf/9b+KK3sJbh9zEyKrbi2 ce/PpWnBEseQjDlsAd2xXsHnmRfNGhaUR7pA23OOmOKLSeOW380qqENtKIMH05rSSskRNNrQh8lp pk3JtIOVZflJHoT6VG4Ta6hjEFl8tQT3HpWZSVlYaxQYQkBiMZ9/WoYPNt5PlYsGPzFRkUDP/9f+ ImWGaaZC7bY1YsWxkirb3DrCFV2jkjztKn7w969g8+xbtp2ngEUqqcHcoJ4bHrVkS/KjSIkO1iFV D8sgFBcI31M64nVt0HyqXYsFUbfyrOd/sxMZyGkXl3GOM9qByhZaGlb3NtMhjCMWSPaky/Kc+4rO mgxBg/O6HapbigzP/9D+IeyimRilxJhFIwpO7H07Vs+fGoIwrRLkBCcZIr2Dh5XsRXElvLHCtvG8 UhXEuTuAOe1SQ29u2wSwglMEE9SR3oshNNbk00VvO6tykg4+UY3getVpI4NodMosT4xySTRawWY+ zt7rzDIFSW335LykLImfQVNeQyAxlVzCZB5hI3Y+lAO/U//R/ihfy53EMTYjDDeT0FQ3VhKDKiuG KYIwfvL35r2Dz0MVpLNC0akM+F3A/KPw/GqV1cTq0UZ4cNuO3jeT2NB0FW6j8x43AKv/ABYOATWx a3sXlJam3gWZcmS5Gd7j09B+FFjKe5KWVAPKXLKeFxgCi3gzKy+W7MzbpJW569hS5Y9hxdos/9L+ Ka/iRFxF+7YHIydxA96zIlkuH35winGSfmcjvivSkrPQ5HL3C/bRTyOrdEUkNnj8v0pl1a3it50g 8xVOyP0A/pSas7GRALrzEGOTA/OM4b2qK+aC5T7VEixTIuxh13YpAZUfnrKjtnY3yhc/L+VaNskL mSSR0RnPlhSw3D1xQB//0/4mYrxdKWUJCkjPgB2JyuPT606O4Fwy3DygRL8zxLje5HavQPPGG6eU TSRoG3grs6EDpisdJBmKO4By7YxnGPTPpQKSurCS20j5ghdsn09KYbeSD5H3HaPv44/GgZPa/vkk VpDGyEGKSNNzrg9PxregvEhSeFo451nUIZJBllwc/wBKBtWP/9T+JCVVaQiNiwyCQhwmPSlviZkV GJEKD93GvPIHc160dtDhh8RHpwjkLxzSMp7L06VdeTLNC0yERHMadOKySu7GxQmsUw0ke4IBu+Ts feqjwFCnzfe6N6mtwLkVlNdo37pxHGMeZ0Vj6D3/AMKbC3kEh4lnUDb5cg49+KAP/9X+IhWSMOUA x/CvUD2qosLS3KJGoUtz5a85NewcdtGDQpDvEyvJlthKZ3Kc4rQtJpoJ2fkxCIIi9C3TrUOFzMmm vAzAHMspOB/sCnNPueRFUkBcmQjGazas7BboZd3dSABiWKJ0DKBg1UNy9x8kpwnUnbnFIz9n5n// 1v4frVo9oSUKY2bbgHYze2e1SR2jwvJsVdxb5cncFFegePY0LfTpbtvIj8p5z94M4QJnoSaqXsDa WI1uYt7LMUKq3ykjuSP0qofEgM93QlZE/duzZyOBWpDK8sMq7VZ1GY2PCk1tfWwEBuJ7QiZ8iQc7 E4Un6VdTVohBmaEtO2SxJxt/Ck1dWNYPSx//1/4gFu4jKs4T5m+Rz0CDsSKJpZWBQfPg/IfUGvRa s7HnkcNrIs6Syh9hOxu4FdhpEME0xtZYZQWYLayIB5QJPJb19Kqas7gd5P8AC/WbmC41LTYlnsLI A38oxKsfOMqc8jOa801L7fp0jWV3aIkquXBQFSyZ+Xg9Mjt71Bc6c4JOS0Zg3Xl3PlTqm0xcNvO0 OPb9a1dPjlMTu0QZMAxt3jwep9B0rKUXfQxmrq5//9D+Ke5Sx2b5E8++ljz5vVIx6c/55rGjuXXK ljvQkNt+4fSuxQ7nlSjZjbSC5kiuboCVWjJj3lcxKGGB+J5plnFFvkDZkmAwHJyB68VailsEFqWY I1lm2ojZXkIp6n6VXvt6ZJQRxyfI21ufxFZzWtzUzoVdZHKj5F/izV1Lo5KQkvJnd0wSew+lRboB /9H+I20vjHhZJGiulkJ85TlVDdgByCOfzqlb6c8V7PN5jzJMoKBhgxt/hiuuas0jzyzfRzRMsc7q rlOFQZyp9DWfDbC3Dqqk+blQWGSp9qgDrPDOmfa3liuJGDQxeaEx8r4P949OnSs3XLh083E/mIG8 tIx8qoM8Voo3jYDEOnajBHa6rH5LwNMIpMTKZVON33Oo+tdc+v3N1BFHdTCMxr5cSucjj1J61aVl YD//0v4iZdQ8tWYRgr3Cjn6is2e2dTDcctFPxG2QSvsR2r0Dzm1Hccu9AYi7FxyuOD64FaBvd0cj SE7Vj2mPHzemaTinuMzljEgklDlF/hUDJx3rPX94+DHIixttZwuMjPBJqZrS4HYWN3c2LQSWiu20 bIyPmY+gqve6c2qeZqvnQxyPnzIJSFuN64ydvoc8fSqsgP/T/hyzcQMrwhS4f7rjcHA68VaaGQR+ cw8sE7/LXuTXdyRPO6lNpZWZXO7J4wB6VMly1u6s8YuGwdqyglE/ChRURjXmzE0IVWeWTeW2fOPb NOjhlt58RRbppFwQQcAVQF6B1UK5jLN5u2TI5ib/ACatzWoaElZDJtO8HAyc9qxkrMD/1P4fpkRV RXd23HoTnb7CpjYyBfPVT5cYwYwN3FdByKFtyaKLyIZLkRgxqoPlMuNxPGMVVe7lQ5lURqemBkL6 DFBK+BixogKzo+STu6YAPrTnk80RtPtbEmSwXO+gSk4qw2OEG4JQhIm53KvA/CrBVoxIYyG2qSHK 9MegoLjK+jP/1f4e/PlfPG9mI3J0yBW3Fb6K8EIkvGXUllbNoEwRHtGGDdOuaue5jGTiZoKxSNIo LhW2up4U9qviGdYYLl2i8h5GVsfPJHjsV681BstSslv9tdhE6wGMhj5Pykj3+tPT7WpMT5VUOFfH LY96AGhWundDgSYx/vfSnQ2Elsx82JZMKSoPJB9qCZOyP//W/iKtL+Sa4aP7KhjWTY5lO0kfTipG jjt5ZxMQAshAgDAhuePpQRCTejKTRoxcyGJZnUiIfxoO2T2FVZYgCiNtbHLMrUFmglz5MTWiRxmG QAMzLl/QjPpTY1Wyi372QI/7nflnz14Pb/61HkBsM1xt895mRmXEp+75qkchvb/CucktzKwmjh8i 3LlUHUNgjOD+I/Og3ikkf//X/iKRQIdskmTn5FA6Y9afAnnsHMsSbm8pmYbcqOufyqZNpaG8ldEU ZuBcSrF5bRHPluTgcDpQWa4Qq2GCAoCOm7vn6VEbu4JKKsZzQCF0WZiSRuTYcYq8bOHUZUZxtkij whzxt65I9agznudDpbPYKbe4JnsSQZo87WYA5wPSsnU76NIPItEMUhnMizt95B/d9MUGFTof/9D+ Ia0nKqVZ3EzkMZNud34V1tpJE0wjwoEsYUyEZ24Hr2/+vWCV9Ec4Qwx3UjWNw/mSNIVQ4GxQem72 r9AP2dYrzSbaxihgkubiNZLdYLYbIJVK7EVj9CSR7V+keFUHLjHC+TPy7xdnycH1z9/v2DdEu5/i tpMNlMskcUUF5eyifHkyqyuIl9dpJP4cdRX9mvh2G/tvhfbyWskayw6F9pt1zxJLt3MT685GK+++ kHVUuKsHS62X6HT4DU5Q4Jc+jv8Amz+Qf/gplrJ8S/E/UJnvZftNlqkGonfcAPM+yVJCo6ldytx6 EV/PT+0xevJbasbuWK0tX83zGaEKu94ohtUnkHkjHvX9T8M2w/hrSUelNfkfytm0PrXi1OU/+fh/ /9H+H7VpYNTkhlgS2iUqUTyz+9bHr+H8q50xSxzLuVWUtscn7+Ogx/8AXrszmcqmY1Zy6t/mcdCH JSjBdjckssJCYAAX+8HJBNbWjCyEzx6hBO5eAxW5gckQSdpMd+/514cru66mlraGwFe2U25ZfKaQ OSQMt25PX8K0ILie3lFwSqwRcqq/cb0NclRtaGkG/hNK/vLjVZo7hl83ZCoTaoG3aMA4A64x+VbV trd5cyWsc1orLDCVeSQ/63HyhueM+3tXLPc0P//S/jdl0t5pleIKVCFnMcm7I9CBwD7UG6RF8lBu WM+W5A5UjtXzsL21AuabcrkCJ1Qw53q6A7QQexq3Nc3cUhkVXmVFLMYlJMi+mP6VMpdEaU+o/wAm PUYDbwx7A/7xgD5R5PIJ7VXnMunyRx3abnEoR/KJcEE4AHHXH5Vm1pY0ItQW90+e6uo40lsbl1kt 3fLSouFB3eh4/SpIdekv1RLZWjit5Al1JCu5Tj+H2+ntXOB//9P+SDSI43mkmZNmSNjcL5vHU13G iaVDJd71ZlM8ZtTGx/dPnuc+mK+GxKvA6o6O5/QN/wAEMfCqp8UPHKLNbzTJ4cihP7plVXt7lH2g nqSp7dj7V/c34VRIbOEmJV3xIyuF+UgqoyPwr8PzjXiKvK3RI8/Lmniq3k/8juGc+Wqjghs+maYD cBxICfTbVq3K0e1Je+h6iQM3mDJ6qen4UihpSUbAHr/kUUjQ/9T+hVzO6I7QGPBI54J56/yrzf4h Kn9iO004iH2vyd23LbWjLAY9NyYPpX8kY5tysb1nFvXsfxF/8FEvD1z4b+JmuM6SWVoviKS48uBM m7VhKryKBk7WaQH8D6V+U2p6m9zcSwwo7opWOXzgcBcg8fhiv2fheqquX05X6Hgqm4UlB9DM1W1l 05sO0cUd1iVIUGxGyM/Q9e3TmqWjmO21BZJAWD8BJGIjXI+vSvplK7saOCaMTVoltzcxfaXa8WY/ ZOj2g3HJ+bOTjsBnp1p1tNKDZXhmE1zaMYbZtgPl7vv5PvwOa1g9bFJW0P/V/jvtbpo7QSsZ0kyy ILY+VJIcc4PpzzTdKg0dYJrOW2v7fUSy3DTT34uUn+Yk/KV+Ug+hr5888tSxI/myCUbQu1H4ZUIz yB0zWdDa2lzaOJo3nkk3CCR28pA46HI9+tAGZaWc2kLZPdyRvNeTOhtocusYA+UE/hVmLX9I1C1S 1htBbPbX0kd9Mi7LhzkZxwD05BoNofCVLzSorRrZbG7nuTITLO88weaNXyUz3wf8KmESSSrEYVlv rU+dDFGWZLgDqGPTn296qKuyj//W/jo0/Tp7iUMlslq87s4gE37qEnP8ROPzNaujalPaW/lXcIvb gSNAwmDIsZBPIx2Ixg+9eZSWpxy+JMt3LNDA8vk7Zrr5iEXCjb/eP5YqKzY24VmDySTEFVA5yRz9 OlenRXUxqK+xx3iC3vLh7sW1i9pGJGLIUKBAOrAdcHrn3rxrV7CS0EZhdp2RS87BNpVskjJ78DOf evWwm5y1dJH0V+zTYnxf43tjq15Hp97Ei2VvqV5MRaNCrxP+8xk5AjKj1zX9E3wtY6XoHhuxikhm aOJrtbiSVY9iFwyRFuuDtyM/89K/sf6PL5smxy7yf/pKP5n8crwzfL6q6NfL3j//1/6PP+CXOopN 8LdNtokYLFbf6U80/wBoEbzlpGVT6BhhfYCvpH9trTI9V+EXiZrjymFlpbxqjx5cM+5R057jn2Nf pXFCdDxNqLr7RfmjlxDji/DuMnt7F/8ApLP4pdcH9gyahZzgw3t1fXNrcxsAzFBcSopOeg2qB61x V1ofmJaALay2sDZubS5/1ckXJZV5HP8AOv8ASzIKnPlWHk+sI/kj/JrPaUKeY14LZTl+ZQubjQrO 0luYrWLTkkm8qG3giKmbGQCF69qq3cNjfWETM3khG37tvzSZxwf6D3r2j59qzsNittLmja1gvTZy 7VE7g+WblO8bZ7dDj2pqfY9JL2NnetC24MqkllhDHA5HryK6IS6nNUjd2R//0PhwqYNQtZomaReV Zox8sGAep+tRu9tqN6s9zdeScG3HmELD975WPqcV/s+mnsf4vT0TQkN1FazSJKYriVjiSOOMKfL7 MQO/vWouq2Zl+0W0Wxo4TAuVCh0PBBHrzVRdnc4qt+hZttBjsbqxu1Kx/aZN8IYhEiIwR9OvSkk1 5L2+u7WK3QTl3M94cBJnGSWyOvQ8+prZNPU5WrrlMGG9hlDlU2XitsgLAqHzkEZ9/wCtZ7xG3mFs 4QSNwsMQAXGM8AdeOa0jK25g01uf/9H4Esw+makNVih1K3itJPKtdUiYpFaB8Bi4HBPbHocc118E 1vdXCytqEhnZyyyykGRx0JGO3681/tcpJ7H+HE03ozk9T824ubnKMUhdoVZMKZlBwHPPU+9araPZ po8Fsk1zHJChu/KXH7xnB+XPOQQQfXitVNmDi0ZMTNa2H9lXETG2L/aIkccwuTuDA/WrdpLEGuJt SuppWnHmLCqEpnGCQw5GODitE09iRL6S0uTHLHuluAuDNKN075wPmbqelFqrxNGTDG8C/NIm/GBn uB0/StlJW1A//9L4tkudH0y3kewhiQzLmZZjuJZh8x9celYaW0capttSVflHOVSLd3B/Gv8AcBba n+Fk2rtIm0u+fTLa702GW6aRLvfcxzyGUDPzdT9eMe9Xvtpl+0XEKyRRxyEAMDuA+v8AMitIPoc8 2rWIrCbTJbyd7i6hhFu4a3bkqz4U7Dn1JJ5qTUZDfTyTbFaHO3fGSwkYdWNaGL2LFhHd2cJmXAhd tmGI+Yn0HXt16VXZ7uyv453gcQvCypInQ7x9z8eDQc7V1Y//0/kbTdQEdu76jcSG3iJ8mMgDYeuB xz9KwNQ1ZJpvOmQmy34Ix80SA8njqcV/uQf4HlmLUIYXijtpZIYS3mKs6+UPLwOg68j19aZez2t/ CJ7a4U+VIGLxnGexH50Gco6XRcsbePUrSWyBj+07/OFxK2xUUDnn1zzzWgXhv2tE1Xy0NrCtkL6P 5UuQgCRgjpuAAGe4x+OkZdGZkOo6dHDGk8cEclnFN5Uc4+ZlcrnBPXOBn8a51Ss8rRxsqjfhjIcA Y7f59a1TcdiZK60P/9T48vFNlHbPeRJb2uqQfabYEjzI1R2QkL1AyrdfSskw3F1FIS7W0cD4DogW ZlblSe5PQ1/uvHbU/wCf+1i6Hktisdx/pDIuFDnAc9cnHWmQG4e48yRMReZyF+7649cUzGa94lIm vLuSB51naNStuoBH2RCSdgyTxnNPRXNubWaZtsMgbaMfNg55oJKUrJPMhkjAEZyB93g9celXLGzM s2xZwmFMjInLE54APrQRNaXP/9X4vaW4spJGgeRjIxiweWbnk4/z3rch1zWZGbSZJbOK1eA/aBNp sJmT5fmAlK7wR7Gv92D/AJ7zHjVfPEYeNVZtkTsdkYOcZOecVTeSSCZrm5t0umhmCqkX7xHGQu7G fx644qnFrciUXbQ0bx30/UYIWCXsb/vZDCpIjQjIDkdOuMg//Wyri0t1nM+wysw2s3faeSvPargr IyL9ybeGWOOIJv8AJRiY/lVARwPr2PvVWGZ/tUVsilmlYLuHRfr6VZMUraH/1vjKY7WZWOMNtLY5 4pJZlSEyRoPJDbTOVxnHYHoP/r1/vAf88bS57D7QQNKzmNsyRbdzNxGQQcgfh+tTwX13Bdi3tYIf s06sstwNskmCMEcjI/A0BOKSuh8qWyI0SoCw5KHGPyqaCxS4tdxdodq4iiVcmU9MCugzsc7M0Mbt taQIP9Ym4jOOpxT/ADt1uZ1VjArBQ2Cx56UAf//X+L7bzFb7TZszSQjzSAwV1x6ZNRzTOjFpCpEn zKqEEc9q/wB6o6SP+d8uWkCXcanyY5Gt8SmJ8OoAI5ZT1HSsyVLkTSJbWZkWJt0phXCIp74rYVkO 85TtRBtJ+9nnHOK0hbtPD+5L+ZCweOVPvccmgHG5VjWX5pDExG7BcjgnvzVwz7ukZLKOc0EciUdT /9D42SdpBgcDOG56VBJCltIyShkMgyCTwevT/Pav98D/AJ1yqJhFKFjQYI4b1p9xc+UjFmEaBSZC enr1oAhVN1vFcQnzROm9GA42mtLT3jjfe6BmUfKzg4iIzyKANGLU2hdpoAqSGNoWYoGYgjDYz0yD 2qjHhpXmaNXVI2VUwAcnPf8AI/hQZyj1R//R+H/I8+9SXBQQuGRQeFI71pzQGKcuqqElUNuH3m+t f74H/Ogk2U7h0h8nyI3lnlO07RhI/cnNaFtaSv5az/PK4wPlwx/CtKfY1UbKxFLF9muGhCSFxgkF CVqlMojJPOeuAORVJq7Rnyu9h+n+RcyOLk7FaVUSRR90dCasXMKLeS26SB4oJiI5M480Kflb8cA1 RtY//9L4w1aaWRLeK0h8pmiYTzswZEYY24XHOec89vxqlcCOC3s2u5EWV1DMFO1AwyCB+Wfoa/30 qdD/AJ1XFNaFua4to44UkdpfO+Ty4cicjHIBx9asSppll5zRC5jhfC2cVxMJ5E7YLBQOeegH9azM SvCpcFug688ACpJH3fui3APynPFUpO+oFe+dHit4zIrbTlgi4K46ZPfp71J5c0bJKsls8TREFc+X KmPX1/DJrYD/0/jLGZB5bBGAypXjNNitPtBbdG+8NtEn8Lf5zX+/B/zngLZoPMiyGdGJ4GSKa1wy EEghscg8ZoAltSlx5jll8yPkx7sH8v8APSi4DS7VUldw+fnDCgCG5htmmxDuVVUBi/UEDk/nmm2h hhe63TrdSxSmLzkUogQDKrj1HrQB/9T49aWK6idNvGMbOpc9qz2e2ghjljZp/nYSW/3fLxjAB/P8 q/34P+c8sRzIzrIv7twhZSR0zwQKpzyzupHmKDvzuK5PuKAHLcRRIsXlPl/vH7y596szfMVkVQF2 gRY4OAOpHY9aAC2ZBKHkXIBwcn0pZ3Ecr7l3LI2QwPA9hQB//9X45/0ZsJ9ndgwK5HAU+pqex8u3 nkVkZ1tVDuvAznoB78V/vwf855mS3Bu5rhyJIFNwXWMjao5zgeoqdEjmmj5wE754HvigBpuPMmxx 5aH5iK0ZC2pWrQvcP5VqhaKFnO0dMhR0GaBNX0ZFaNapYW9pbWiGZpWa7mkG+ZMfd2tk8Hpj2p0U iuXCnO3g+ooMWmtz/9b47nYYwwZjuyvGRmrglFxb28MyxxmBnZWC4Zt2Ov5frX+/B/zjlSMzAzJa 8mT5ZM/cIprm4gSJsksjADI7Z70AVrp5jvlJ81mH7teiA+ntVxSfJjyAWGGIAyAaAJA8riQtsBb7 xMYLevHHH4VA5DxjegYLx9cetAH/1/igWMizsGLSxXAyiRHAi45z39akihVHEHmNnqASW/Cv9+D/ AJyVFsvbwu1dmCvyjj5qhUFZlJPGc0FcheuIhcW8z/afL2Ywiffck+n0BqDTbqawmadba2uI0jaN /Pj8wFWGCfY9Oa0jKysLkd7EQeVt8sHyKDkheMVRhtpmmZopmDPJ5km75iOnAH4YoUruzH7Psf/Q +QptPgUpcyqpl28nGGOKzJ5B5hMPysox0yuDmv8AoAP+chprRhDLc3DCFPnJb5AFCdPQVfuSZUt0 MQRrcFZHD53nPp1HegQseZ3WGJljZiEWTGApPAJqktpLDLLFLIfMikIb5txJBPOaDSMOrJTcTSvG sz7R/q1ds7UHTpVmTTXjwZQULruG4Y3g9CPapcktyGrOx//R+Oo7xbWD7K0QVhKyxhBuyOxPp3qW 3SSSQttARhggdRX+/Tk2z/nIFmT7PIFjUAHgluMUzbJMP3Qc7RhmXk/U1XPp5iLSQZTmQkqvJNY2 0z3HlhwuG5PQce/4VmBccRxlSXO/ttPpSM9vNP5pZ3k2hMscdPagD//S+NftWx/JkhdN7FUJX5Xx 6H8KmdJIjIUO9iNoQHK9+lf78H/ORZ7FW7yqRKJFZ5OWEYI8s+h/KpY7OX7OXkAKRsNzNgde1AJX dhf3Qj28Ag5BHWpBbCVkaMrx68UG9raCXbSRqp2hWHybgP8AWdf1qlliGJi4cc7qibtoB//T+Kz5 KIiRx4IbPy8U9bMvL5qH733gTkce1f74H/OeXorV9+4YRVPUg0/UQkRAPlvMy5G1hIDn3GavlXLc DOt5kZZEkVo9nCHGQ5pp8kAAnKk52tUAWkMY2um08Y2sAcjvVc2vnPmG2ZrVQRdzcqsQ6AZ98gUA f//U+K2iSDldyq33WPRvxpUknjjYD58joO9f74H/ADpKDauRlp2RWUrE7HpIM4+vNMu5rf8AdeUX WbG2XIAVj6j8P5UCUHYjVJEC5+cyN09a09n2NHWZCJMAmNhh0zz0q4y5dC3DTQpC5j3tlMDOFOOh q2Hj2Zdj90gkfpWpHJI//9X4nYCEYCblI+U9MjtU8MjLEyHGx2yB+df78H/OhJWdhiW06KwDqP3m 7aeoH+TSSwqWErKYh1YoOWI//VSaurGlPYVbkPbT7fMeNV+Xb97IqvZFrwsVcGEIW3MdpGO3P+eK GrqxT2Ir8ra212FRnka2k8tlOGjOw/MPpX4g/tPRQ/8ACUXCP5jzWlp5zSZKRzEyfxH26Y/nX4l4 9Jrw7xafb9Gf1B9FFf8AGxaf+H9Uf//W/ijn8kJsjh8mYnPmhiSfw7VJK15NDGI5cvGAvI4IFfeV F7zZ4dNqyRYilupbi0PlmM26FNyRjY5GTmoZ42mkeXzCrRMysWHCnvgVyWd7GhJpOni7lji/dhpJ BHE0ziKE5OMsTwB7mtXxL4dutCu2tbyWyeWONX2WlwtzGQ3QBl4z3xUSjcPI5RF3SsWkkhSJPlVE z5jccE1DctwDGSoB+dx09hWco8oH/9f+IgLHuyJWd85yf+WdSNcXKNHAbiQxqSyITiPLdf5V9QeO WLY7A/mDJ3E7l71aFsgUGQiSR/nUjovsKtfAwKsawrlHJ3nIGD37dafHHKY3DSKrIcYx1/CoAtwT uFIJ3EcKigbT9ajlby5kMtqEVuN27le+celNOzuB/9D+JmKXM1x5bqY2GMKOKZKbcvGm5zIo3QsI 8qWHOCfavqDxwnmu7yZ5bl3Z8AM5X0GB/Ks+TzDNsxs8v5xJ0FTyouMrJoka8kkTaF3yRr95fuqP WiB5re2b7IgeT7+P73rWTVnYuHwo17a4BSNpFKNIMsGHQ1ZhsyziaWZJE3HaiDAX6n86mSuij//R /iknmuIy8tsNsakLIAcbh9KVLr7VGRsKMG3DAwe/Fe1ytbo88oM0s0iIuMb8OCMlhU89uLfDIUII B8tT1q57AQKrkkB2yeVDfw+wq1c2+3y1DBxIMkFMhSPQ1kBH9kV1B4znGTWfEk63MkJbbH/D3Lfj QB//0v4n0G2aPzYztc4XjPNaDWNpLgzHygzBd2On4V7B55kXFqlncfZlzJDLuEMzcbQOx+tQxRNN O0UZd1jixjrtA7igqMnEWa2Qsj5G6Mgc1DewyTRBvL3Mp5J4x9P8KC1Lm0EtyYYvuDcP4iuKf9s2 Osb28cisudrcnpw34UERV3Y//9P+JO5QeVCF3efLk4xkKO341mTzJ5SxSxMkkZ+ZwSHzn07V7Bzm lHGgIuIJD5axjcsg+Y+p9q3I7S1ksIL5Lr55HIaM8SLj1Xrg0AMkCLGrMSSTtUgY/Oo55RDA++JS Nu7cF+dvSgLFOG/dWVpT5UEeHIH3mA9q05boSBfnAjJxtPB+pp2ZDhdn/9T+JGRiJybf7udpIPLH 6eldLaX2y2aR7ZSiny2nI4Ukfdr2DgSu7GVc3Cup8gAHBC7uBWOpYZkY7954Zh0PQ0Gz3Qw3cixi MwJK6SHdIe49Kl+xSGOOZYzggsxHBHtigyl8TJ3eSDYhBXcMjPBNadtckL82UkJ4x0NZufYaa5Wj /9X+J+8uJPNify0cH5ZOcdPaoIpUhkTKFmlbIP8AD9K9Ftt6nC1ZI12uxDIpflTjaFHT60l7fyyW 5aFEREG0nH3z9KG29yTnUnkH7qSNF8s+ZwMM+7HX8v1qy0LmKWSAKu0FyOMv04Ud/oKQFfbJGIZZ IlkYHJiz1+vpSyRQSyHyflKj5h/dJ/yaAP/W/iInLlArgMoUiR+4x0qlb2pJQxNje3zDP869A886 u1ljjiCGKJgVKEgDisVgGuJcoCQxAJHbtQFizBPJZzSF7ffmIqHX5sdMEVVvLmRwsEQ8zzCCzAZP WgDQsbNInwz7OM529aine0jR44juadjuYfw80FS3sf/X/iM3rawPj94zDauBnHvUEJLQ5d8uDwg5 Ir1oqyszzy5bIqFmUMWI28jqay76Rnm3ujI0f7v5V2A49RRGNnc2jK5c0+a42gRuWgdsTR81tC1g cKmd2V3BTjeKoUpW0RTllmsYPLFw/l+aWELN8memceuKxTO87gJgSc7iaBKemp//0P4izGIgpMY8 zYCQeQT3NPhlgLb40xKvys2OnsK9g44PR3FgikeaWUElApkYEZqvPIxcbU2HHU/KD+FBmULeaWBp V2lyf9YxGePXNbyRQeWJPtBXcgKLMu0OeuM9qTjcDPYpJMVzvaf5XjVd0a46EVqHTLZth2uQVC4X hmrLld7Af//R/iZuNMhEWY1zzkoRhhjt7VWsXWFGaQKsZO1EZsuD6V6XJI8mW4+TUvswLjAndgqh F5IHrWdf6h5zlZY1YYDdckH1zVqNrMkzhIkrqOVX024xVxriBUiSKRo5A+WG3gYoafPoBfNwjRln BbC7QWXO7HpWabaS4DuoYMOiAcYq3oOO6P/S/iES1aNDPGiCHYA6S8O/qBVi2hjuThVZVQdQORXo v4jzxPtUgLRIS8S/e3LgirUV8+1o7eXyWyMTOC2w+oq6nQmWiOx0z4reKtIik0u1vopNMucwXMYh CO+eC5Pf6cVwWpXM11e3MpuLi6knbzDJOcspP8I9h2rKyRXtJTjyvZGfdefiKFlctGOhXGaniN4E RVJAb5Ao4CjvmmB//9P+JqO0Itmcy75NuFxz+FYcnmCZVyWReX2jnj1r0DzZK6OqtYS8KbX3KVyV UZA+tZ80Kx3bSMdgxtwRtHHegUI21ZnoL23uFvYiyyhyY5Ic7FHTk9s+lVr/AM67uI2VcP1kVeI0 96ynuWLAkkIZrlfkZ9kWASr4689M1NGsYf7QmVySgYjbilFe8gP/1P4gLbPmshQtubAAXc0hz0rq bnTrqCMtIxt9kIcGUFWBxwAK657nnmFcahK6oGMcjQrhnC9T7VXjuHuJFVNrbeTxyagCzcXl1Ekl vHcPFE2DIsfBbHODUCRW94HQsd2N6g/eBFVFtaIDPWCWORozKxTOdqkgtj2qW5d1h3OjSkvtyF+4 PU/lWwH/1f4c0uPPBEoPlxqMBV5GOM5q7byQxqTtMpz8qnkAV1KTTPLqdBDDM7edFtUqMn/Z+tPj lS4XbIUVl+Vyow3HrWkW2tS2rqxoRwPA2Vtw6SAZdhwg9ao3sqpKyFjtk+V9vPTtn8qJK6GVJpbm CNIvNKo3KBTyRU9rdqd1vKgIdcB92WU+tEXdAf/W/iGEKq6luBH0A+81Nu78EqgUjYMZxkCvQPPI IZlnZYwPmddquVAx9BUclq6TeTtaRgcqxGBj1oAs3Ui2tvCIUSa4BxK+0Bl57fSp4ZB5LNcB45Av mIQOCKAHJOY3ysKSRTrhn27iCe+PXjFSQ4nSe3jZkKqdvmgpu47UnFPcfQ//1/4hooZWdAYQ5LiN vM6nB/QV0scEdqMoXyWySxyo9iK7XBW0OSMruxFeSwziZiEG5eURPkJHcCuSeUyMDtjCKNpL9W/C sgSai0y8l1bQ2iwKCz4LNuTGw+gNVY2kYlX/AHYU71jIx19aA5NLdTYtbmIp5LwbmOVEucdelZL/ AGiCSWOaTfFvwCh+XB7UERXvH//Q/h5V1jkml3BQFwgxQ7yTokruv7rlSqAOwPv3/Gtp/Cc6V9BI rlZUfZI3mo23aVwfr71qQG7ZFBC+UibpJSdqk+grE6ErKwCeG3y8i/Z2JwHXLK+T3AqO4vWaESNI I3En+qC53r65oAfb3scX76OLc6jkE5/KtE3a+YHw376ICNm/5Yt3BFBE9j//0f4iJFSIs8rAydQU PX61X+0LcMsZA86RsCVzhR/nFBgnZjbiFwiNsBYNtZx94/8A1qnTTnkhBVwHXrk4JHpQa8ytcyDB dRzOjM3lg5Eh+6v41v2rNJw+LjAAfcuduPSgIyvozP1DVAs7WyEyRxqFXI2g5/wyKsW+Yo4Musi/ 6zYxyFLdQBQdEPhP/9L+IOSQcrIVjLE4C8EA9zTfPtYojE7sy4wGUYYfSpl8Ju9EXZvKtbKxkjLl ppSqgjMbDGQS3+e1Rl/JjlCmMI8nmvkDdn2ppp6IiMm5ajRBbXGbiWUiVRtigxyeuSasKkCokkbv yMvkY/Ch7MU9xEuoZT5TF1uN37oFsK49D6Ujqs1vMzKu4nAjP8WP7tYGUkmf/9P+IiJZpGRVjCN6 dCBWgl1cQSeV5OWXmXYd6oO2SP61EUk2zGMbvU2NGTztWtt4CBplkyD8u0HLDn24r9Pf2X7iOC1E EizKomuTZ+YcGUSLtaQMP4du0j8q/VvB+jz8ZUGuh+QeNlSNLhGpDuf0H/8ABL7TZLr4x3r3lkt3 BYWMNxYRdBP5r4kkI7hAAM9iK/rq11tQ0D4eXEMUcXnW2ipBbhJNyIzqGLD1wSa9nx5q+049w1K+ iUdPn/wT6LwNi4+HHM1s5a/f/XzP4vv+ChU9tD8XvEkklpBeTxLE1vJG+5Y3+1SJOQBn7qurY6AD FfgH+1tPff8ACPXd3dNDcRQoYrWNyiXBaYCMGTjliF684+Wv6yyyosP4YwqSdkqd/kl/wD+Va1Lm 8XKkFq/aW07v/hz/1P4WWtWtTHCVktri3IKxs+50BGRyPY5/GtC1ZprgRFVkRPmkY8kV049qWJqe rCMWoxXkjfvnaKEP5YaMJhCoO9fpXU6bNbwxRobXY+0eY0seyXpXkz3HKKUiK5kgBYoHlJkP3j0H PpV20LShoFj3QFdxJGWX/wCtXFU6itbY2o7Nre2ZoZA8pBxESAfwqlbS36EW0hmkQBvswUbxbsxy xNYNXVgP/9X+N+zkaKeOz+2Jb2MULSXTrbma4lbjao6YyepNQR+Xq0qRWF9bWyjeJbm4UmJSpwc9 8jB4xXz4GpFZlk82KWOePGxZogRDcYxkjvjofxretnEVnftbQfbriK2LW8KfMcry30yBjmsHvqNN x2MCHUxEbi8Nu9gstsrGORdx3DGcjsQck/iKkur9dZuo54EmhHkxuZpE2hZFUKflPPbvSNk01c2w 15qU62T2ltLp7W+JZjLsbI6rsx39c1M8Gh6fpMejWGmW9hcC4aeS4gLeZc7uPn5x26+wrKaSegNo /9b+RKxs9RWMo0kaDzg0eATJtGCfbJ6V6z4RvEBs7gSxGW2uyzCWITRkJ2I+o5z6dK+HxHwGsm4n 9Sf/AAQw0ew1W81Lxdd2Tx27+Jmiintrf5JBNaIoV/8AZGzj6D3r+xXQrGSKwsxNjesKhUxwFAG3 9MV+G5olHPsR8vyOfK4/vqsn1a/I2nQByWOMHIGelKjyu4KnCjn603sz2H8aGzzsGAycj07U6MyA 5AB75p0tWWf/1/6HbsOhQknzIhtypzH747HpXA+NNNl1HRr3Nq82ArjA/wBWM9Qvev5JxK/eMKr9 3mR/Gr/wVthn8N/Fu60WG1vJZtcgiktbuwAuRbwQs5bep+4QzqD3+YelfjDfWtxFZu0Nu8lwyshw p3Sk5xkdR/Sv1ngu8sni5ef4N/5Hmb3T6O34nmUza1cT6c11iSCP93NA0xxCMjO3vxzW/eaRhp7y a9UW/lRi0tEOLgshyxGOq4A64r7CC1uzZR3ZWsLLT7983LJGLXMsQ4eUuQR8q5575rG0/TIvtMll bzuLu4uvNaCQ+XvOcBgf6Vsr9CbH/9D+OK6t7jSG+eOSfeu+EEiMg55/DqKxdQuDc3lpIpuLdrd1 N0IkydrdSM4zwQRyK+fPPL0amaT7Mt4zQbvOijePYWGDywyeSO3v1rPF/PZwhGuGZPtEgs7eY48s EknH48/jTSu7Aa1szS2E097NI8WD5Q2Bn3noM9hms62srMzlyMPNhS39w5Azj/GtYxUTdW6G9Pp1 lZXBSEPFdyRpa3zkbpZUU7guT09eKddJBaz2xtgP3py5JOUAGDj8ulUl0QN2Vz//0f46NRvoJoZI NPe5Mz2/zjAifPfaScD8cVPa3+noNOt7uS4hkjQR3UzBVZnJO056f3RmuCmrNI4ZO7ua2prcWduS bhbtmmLR+ZIpxnoOPbpWdbamXkiVopI5oJBIdvCOOf8AP5V6NHSJD6IzNcv729fUJ72aaJoovMtG jTbDPnC+U/PYZOR3xxXkF9ekW1xCViV1fLsjeaz+gPbFephNzkr6SVzrvg5rbaF4pt9VkaWSCylW d7OJsGYZCsoHfcCRj1wa/oh+D+q2ur+EtK1m0tBBLqcFk2nWt0wvCTJEssIJ4IwcDBHU1/XX0dcQ /qeOwnmn/wCS2/yP5r8eUlUwNV/zfkz/0v3s/wCCUHipJ/hkLOBBbKtybS7jODmaFvLkCkdt5wPp xX6JftVaNJf/AAt8UPL8jSaXNEyqOGwoK7vTJAXP+1X6n4gQWH8Uqn/X1fmeRw/UeM8KqE3u6H6M /iN+LsL2HjDxYdYgmRo9Ym2CO3ebyFJBiLMBgBi/GeDnvXltp9onW8u71JbOExiO0cw7DcbcADHH vk1/oxww+bJMK/7kfyP8rOKYulneKh2nL8zIOjt4iuYvsNzBKLPc91aMjR3FuvQyDIC/r6VHpIZ3 l0e7dnYTLOpdAXVQ/wB4HtjjB96+lPlHN30IrvTVs57gXDzzXRu/mnKF41iZsLuUcgjIy2cf1Zqt jeaddrNC9rdLKqNbyW0qyouOzL1GOOoraHwo55Sdz//T+GG1i6jz5M1tcG7JF+I4gEOeGTgDBGBy KqxWrRWEc1/p9s1uZ989vJcMXjVuA0bAc9jzj39K/wBmVfof4uVGVLGa4jimFolsJI2yJJGPn+Wc KyhvpzjHXvRYJNBFEeJ3hl2r5su0vz/y0OD79q2V7anJJ3Zs6rdeIbRLZ5WtLnywLqK3jC3CRFsB VOOSOgIPpSaZdw2lqpv7EwavdORPHDEYrW2GMqdvUlgf5etUYTVnc523gmu9Q8mS9+yWck/7wSx5 CZyCcAZ/IZ5xW9pVhPLOi6Lf6fdpEXs2uZVkgSxdMfKEZRkYPbHXjtWkG3e5m0nuf//U+DptF1aW Ww0TVL4XpnuR5aQyPHYyuzH7qnHTJ6gVq28Ok2epXANpKbyzga1MESF5Nwwx+8fbnFf7UbH+H04d GZV9GL6FJLKW4jMkjfaLaRVim9unQD61Ppem6w10YnnaK3t7YrNG4ErPyuw7u34etbxd0Yyi0rFO 8CLePbzXSSSKuSpIHH0rRV7ZYILdGhaSTKhNu5yAD+ArWnvY52mtyva21pFM7XSzRRkFGaY7NpBP zL7fSqmqxRxWq3Fh5kyC/SEFDtLozfMx9gOfxraKbZL2P//V+CbAeZdyRSKJQ+XgjUbhGFAyM9+5 rqo5l1SG+08lRNZRIlpbW1uWnV8Bi0zdge3XGOvav9wUtbH+E5U8K6ayxag99NJLNclDdK5E0SS8 8ISNwHB57Vnz6vaC6kltk+12CjZFHayb4pR/Ft/HcO/StkktjB7mfPaWUcLiwUxtdv8AaStwMMjk YILeh/p7VoaVJff2YS0MVtJatueGM794yRnPQjp/31TIk7IuxJqE0cczq6of9XvXG/6ClhnaC5kW 6+0TISM27HajEdx6Htmg53JRP//W+IS8DkSSrIww2yEyfLGxGATj8KZCuxHI2syckP8AeX0OK/3I P8Dy2ba6uoVuJrdCsY2rKEO5h3yaY9kqzSTRLAYnjG9baPy1DEenHIP9aCXJIs2jmGSS1UND8gaY yjaZCQcBO/QitGw0i/u3uIreGRkiiNwyAclV7hfbNXGKauYvuZ8c13Gh025usedM08MB4zjAyB64 xRbwQg3I8hphKQUuCdsULLgMFx34HB961E2kf//X+LdUmS9js2nLXkluv2TM/wA0UUe7O0E9uvFS SagrsCkEcJ2AMsabIzgYBA9eK/3Vp7H/AD/ksYRPs0tyZGQMWtcnEa7uHbHfoOKdNdJYia4wZInb 947NiKEY4Kj35681ZLimZ8HmzTy3kDmOSRdj7OPMU+uKfDAYo3VZ2kZCeWwGYUByogvLm7jt1tBF bp9ouoWe5kh33Aj3fMsbds57dcVoJG9hHcOtyBIJfKjdSQzDByf0/WgznGzP/9D4flW4MkVxaSDz FkBlVwWLAf3ewrXt7S4vJm2g7Vw0rsemf8mv92D/AJ85R6ogubbfNJbA52Z34BwncfnVcCZojGoK 7PlkK9wDnn8v0rRz08zM0JNTvbmOJCsCCFBEXjt0heQD++QBuPHU81VlyI2kfa2TjaMcfhVRd0YP clitjcIJ2VwB8m7b8rH2NQ4Fnc7jA1wWTA8uXymiJHDdDnHpVC2P/9H4jkukkYI3DStgs44T1JqZ PKFpB5UqXcTsWiKMGGQQDvX39DX+8B/zyP4x7XTS3AiaARu3H7tdkaduAKigujCzKzqhM21SRhhz jHNBZKyGC5kkO6SRhghmJUnntUNrJcNdMqy7Si7wh4XIPUH8q6CeXSw69hdJxdSqRcvnzizbll3E ndg8Z5696apIhkWFW8tsEqemfpQZuLW5/9L4ntRC6SyFGRQghkw/zBiM5HHQ8/TPWkRYY2VEi+0x Rq3yNIQ2SCFOfY8+/Ff70H/O+RW0EtldPcS4aSRCqlPlyvo1W4pp2DxySqnmnzI1Q+W2FyDk55Gf 51am1uBNaQ2N3HK7zxQyKWVFRtxmK9QPfg/SqpuGBdInaBojsznCup6jOfSmp9wJbWQ26XMH2qaF bn51aYmaFWUcBQemT+HNLakyuocOU2kzSoOIh03N14yR+daXTE43Vj//0/iGOYOZIIyWifIZ1JGO 3B696W1gZPPgjtxdtaJvLSyNIxU853E5z/8AWr/fA/52GrOxMkUaKzNGyysMpHk/J3H86o+UJY3+ 0ZZG+V4z3HQigRoWa+ZAYLVhEsSfKGHAA/8A1VWW4aKRYpSFWfIjcDrgGgB3kTb08uUur8gjkCrp E0aojNucr87oMZPenbS4H//U+KVEUKbjI28tlixqb7LNewySrK8YIKRPjMefz9xX++B/zrpJbFaN pIJVtipYqu8y7cqCPf8ApWs8xYhhJiVR8oBweKunuBX86VFkKyEl23sHO7nHXrVdJYXv7eWQBikb QykHEQZsYYj0GBSbs2A24t4pWdJXaCXZui+yjbG5GP0/xqvEEhVpLiVjKhAU4yMdDn07VIH/1fje V4fswlLDkfK+cg/SqMkxx59zH9vVIwsKwxfvORgYHqMj8q/3wP8AnXI7BlmkDRZ3HnbKvllPYZqe 5KvIUfohwMjvQJpPcWKOdh8y4Rm8sSYIQexps6fZsLKCx7EAmgnkRCqRlVWU7VLc/wALH8fwqxcR Wzxoql8OMMDwBj0qofEHIj//1vjSC3+dJMH90NoO7gjjrTpNRjs5NoVn81ioKKSqkep7V/vtF3Wp /wA6nIrEFvI32o7mBR1Jfuc9qnW3LMwncOhbMZxjywe34VRLg+hTto0We42kKyv5avjBkX1+la0C or7vlYhD16dP8/lQP2b6kN00UoQxwiN04lYHiT0qkhjiSVBwHO5lHAJ9f6UENWdj/9f4tlsJBbSS q2xigaFt2OvSoLaMP5UUqKsjKBw2FJHfP1r/AH4P+c8uXam3RAihgg2nb1qmuH2q2UZjxntQBbt0 SNm81gwC5HGc0XDw/uikynfjIXI8snscj+VABd226JRBIQxIZuOeDn9cVajjgSJDdLvkcb0BYfKO RnHagD//0Pi95d8irbiWNR8rs/cg9vbp61ofZY4jCyud7LvmJbhvTp+P51/vwf8AOeVZVUOdoBQ9 vwqCW2hR0nieWKUx+S5WQ4wTzxQA77NbwSeTbTlgIwzmRs7jjJAP1BxV23eOEL1w3DY/KgBm+3t2 dUYIT/q8cZ4zgVFb3K4dowpZT85xz+NAH//R+PzMsqRlNjd8ggioXAEm5GyVxnjI/Kv9+D/nKlG2 pLZB40u5Y4wEeRXkkJwFJG0YGfb9KbNMXUqGBBPDGggltokELRygO+7jHSgSqnmQgrhugx8wx70F xhdFfZLKWX95EY2GQVxuH1PrzSl4hLskjZYtg2hW+8cYJ/OgtRSd0f/S+Mds3muu/MDLmHavzIcd Ce9Qw2NzG6u0g8wHIwcDHNf78H/OeXLmYiRAUQFVAYL0OKiZn27ghG/hOPzoAZLG0LExZLOPmGTg n6UqSSRwuT34dR3FAD49kkKyLkLnI28AirQESqk0CnJ4k4xjFAH/0/jC4uXlmyCxVRjb/DUzRsLV 5FCs5cKsZ/iBByxPoMD86/3/AE7pXP8AnPavoxka7mQA+Uycl8EBffioBK0m9gGIBIZ+2elJySEk krCQtLkunAB49SavW8EsO6S63b5/3is/BI9qadxlO7hknG1HMeOFZeo+laAlSLy0d2YhAMlsjgVn Pcynuf/U+NvLSa58uPcBJyZ2OUTt9aZCzW08qxTicK2yQr91iCQfoa/34P8AnHLc0nnuqlgoAzhu DTwipvMUrR+bHtKBuF+n6UAUVmYyLaxyDeVO3e4UvtHPJNMhjkGJbmL7OSxUDIPc859+D+NACPMi TLGOS4OG6gYp0EdsyZ/0gTrIRK8jDyWHbC4znrnntQVFXZ//1fjO5eTzYPKZTbopDBySQf8AZ9Ks Sv8AugCDns2cfWv9+D/nPsUo1hj3bMsWYu3fk9ahed5ZNpbATgjtQYw+JBPOqGLCNkj5uOK3LFy0 QAQdOD3NBsVLiWeVfJVMNnLnGduM81JFPbuNkk29gfLwEORt9aynuB//1vjBYWZ/MVguxsgMu4cd iKtC6WSaRlRYwFGY0XC+nSv98D/nPJZbwPatbeWmCdxJT5z7fSqFuvmbzMVQJyMjDf5/wp3drARX JQLsj47g9jWdkyukfO5jgHt/nikBoLEEAGT8v6YpZnSRPJEjCFeWjVijMffFBUVdn//X+JZzHIY1 85o0Vc847CoJ70DakJyoAw396v8AfA/51yVHmmAypJPC4GcVNNHDGih0Hmg55+9QBWmO7ycFgynd x0HpmrcMTLK1w4kmM3LnJYuR065oAcwkm3BY1QZ+ZdvIx/Wq8qyIPJWKSQscERrvf8utaQl9lgf/ 0PiUTwSxKkRcuDsaJ0KvHjp1pyyBE2NwwOBkc1/vvfWx/wA6zRIfM8tpUbc68MncigiRoy752kZA 9KUpcooqysNjZYlRomIJyrKyjBzx0NKkbCTcykIVyNvHPammmrlFW5SOaxvJpIJ7yaJf3dlE3lSz gHDBTg9v51+H/wC1Fc3M/j7VHFmFsN7K6NhfKdCoSNh3xnk1+J+PjX/EOsb6foz+o/opWXiJH/D+ qP/R/ilMEgWS4kC5DEhc8KCelVobppLqOFW8qBsCSUrnZzivvau9jwIaWOwlvbG0zFYJNO0CAyXU iDymJ6gCuLuZ3MjeXld7ElR059aysaTdtEQwzXQkaJpn2DqAduM+lPS6mN07TjzIgwXLEnjoMntW DVnYakmS32oKPNlXygzNhIo1AH+RWP5jmB2WUHd/rFJwAe1RNe6Uf//S/iDgR2ZipVpfL4wKupDI qRmVFZtwLE/eA54zX1B45elgyvyH9yF+4nY85pisU3RscIo+Vhwwz2p3drAQeTHPLgSLCkfLSMMk fhRIFWWOKOVTlNoLH5nPH5UgJ4FkhieUAGRGGVPQ81Fd3sksnlz7HbYFynIUUrrYD//T/iREThlg t9qGXHzZ7VZkjkREiLhZQdvmAdfpX1B5CTbsiBhKpyXLljsKg4H1NMVJPKmUgOXGMMOEx3FTzJGi gupWhV7WVOI+B+8HXg1bidftMLIgERb5h0AH0rEpKysWdRcCRDCgKRYLc4zU8epBojHLF5UCjAZf lcf5NAz/1P4nRd2skwhdWMZ4BB+Z8fyrTub7T9kdvb2nlPGmHm/56819AeeZ0yxP5QiVUbJLMp+Y 1T8q5dxAWxht8bnktj1pNXVgNSCymkIeVsurdccUXiNa7WaVW3HAXpUuCtoBFEHyI+ocb1y3Jz/S rstg0SQ3MxjDNwVU4YgdzWaTexSi2ro//9X+J6WXz5N0T5jgOUC+vrV9JoVMMlw7SPEc+WpO38QK 9lpx3OPk08zLvr2AYkKSMDIQvcD04qrZeetw9ws+BOABCBgd81lNPoKMLvUfewmSUFvlL8bRxnHc ipoJJJH8kwu0eQpk6bPf/PrVRvbUuMeUmvoTBJhnX7MYwTs/iPUg1nyIJ5UEKZAX5mXhto9KoyTc Wf/W/irt4onZXHK7diA9Riq+paUSFuEKNzjAHzD0yPSvYORTWxiBJIdxdmbc2FQHjP8AhVyMEKxa XaZBweyY6cUFNpbliJp/KIdt8OM56bsHp7VZQSSRbMHYflXPzYq4LqTzqw+0hitLm5M0STT+UB5U 0eUUHocHvWXcSiSQzSW7Rxq+QqH5WAPUVq1fRlJp7H//1/4g5GkWSV1BTcuUJ6fSprJpZZArufI3 ZdM4H1Fe1JWdjgu73RvxQ28wfyhhFOxdx+Yn1rPmhii3Qygq4O4AH5QKkG29wjCyJ5YCn5clCQDi p1uPICxLkBjgt95Yx60mrqwivcxGeQtMyyWaDCGM8uf/ANeKoF3Qb1Zx5fOO4FYAf//Q/iK08pIJ C7MXaXcTIeMY6D3rWKQAiYb32j7o5C+4r0DzzHmNxJOirkBnyqD8q0JnkjiMJZSxGOBwDQAsemgW DTPOru/LKufNHsKbFOxAjRSuxcDcME49aAIoRPNMV/1RDFd7dKSR47BZVcCaV2/dmPknnHSgmex/ /9H+IlD58EwHyyOc+Ywwi/7IFQw4t3VG5kJ+Vs8Yr0DzY/CgeZ4WVxxGCcqpwSTU1s8LRSyyyP58 rbYQOVBzjB/z6UFE7ySzTXGniGQtb23mSsg6jGTg1nTs6RxtCrIRhUIGelAA15MsZWbJJxzn86rQ vhi6gFT0yelVD4kHqf/S/iAEnnRED5GU5OO9FoofKn92+cqxO1X+leweeXEiuF81IZQzkF1Zzhlr NlfzJEWSbknMuOWbFA1daouWtyYPNkKZhUY4X5yB6Cp4LlnVpFzGZW2rv++o/pQILsBwhI8woMFS cZ7Zqi9nHbuZY5cMwDBW4PvQNI//0/4jkiE0QuBcAyK/lmHBJPHX0qndQzRfvMkIG+bZ/WvYOBOy Zes7+4gidEjiaCf5GaRA0gx3B7d+lUbiRnBCjf8ANg+q+woEQmKaH52UY6MnVh9auTRzrHGjhkUR 7xG6kcY4xQBHaloQJo9vmKfmRhnHt+NSXGr3EKstuDvK5Rz1jPfA9u1AmnayP//U/iF+2X8qCcbi ZF8t1Bzu98Vnz/uk82KQSS5BaKQELGT1xXsHjkaT3G5pJDuboyN1IqQwg5eM793LLjlfagC2LRgk Y4Qg7wGGGFWLe1EvmfKA+Mq5Hy/WgBt1bNG0KGTKk8Seh7jFTRTS2xiK/d34y6/K9RN20BabH//V /iUvcsV3OT82Qo4UVnQ3TQyhVYo4l2n+63SvQPM50al4CYncEKSuSNvJrmYpZiHjBCq7D5sDcPYG gzbbHPFcLMHhxtC5OQMg9+KsRTiSTex2tFjLAZx70FQdrnQTvbzCJ7YNNGIwZZpMKyP3AHpWYJWS aUuj+R0QhcZGOtBqf//W/iOjD7CBKY1UExqp5YH+tQyO0aYC5kMeMnqR6mvQPPLukau9uJIB8hZM CQDnORxWvduk0fmHZJLt+fOC/Pt60AZtkpRfs0rHZcSEIcZ2H0PpUtzbJbQl0G9wxxt43YrGfxDS bVynLq93JZ29nJsFtbO80SCJUJL4ySQMn7o61nQQzXCyMPli3bsMe/tSjuh8vu3P/9f+H5buWzuo mTeHRgyFR90j0rQvNaurpInklmlUORtmJY9811z3PPMyYi8bdCiQKr4MZOAaZFutpv3e1j7cGoA0 LsSBPOKgNNgSRkYIGOv6VVtRFASzFyZASuDwpHrVQXvASFQbRbhoh9qS4Kl1bCspHHFNIncFXhaM tja6/MjZrYD/0P4fZraa3eURttV02SAjGQSMg/kKjgjaD94QW3DCDHBrsgrNnntJ6MatzNl1jUky ckAEbcGrMcJ3RSBcu5AIYYAPvVpJbBbobdpqFwPP0y4RAbhh5ZZABx02senWuWn3ebMiKZSj4UL8 2T7UwNSOwMiRSXaukf3QwO4qf6Uy60r7P5jwsJGByOe3oPekklsB/9H+IOJZHC+YpVmHyk9qi+zv FJeR3CCRZIwYJjldpyOf516B55Ja2u+SNwdpj4B7Nj2ror2/WOK33wxLMqkNJt2+aB0yaAMBlSXy mUJ82WZFIBWo8xhz5x2IRkKTux2oAmgLKgKkeWWwjDpST3DLlyyrEHEWc5fJ6YHWgd9LH//S/iMg F1bXJWYE7F3EO3IB6FaW4u5XV0ywjkbAOcE4Ir0DgTs7oy7qWZGUNuRZQEyvQ1HMqJErcLjgk/eb 3rB7mqkrXCzntpVbzQ7HG0dhntUrnzmYlihX5VPTePeo5lzWKJIBLGPPc7QjbQAc4HHNT3gjmY+S zmNk3ElduG9KoSSP/9P+Iiws7adHimwHYcMxwfwqOe2t7N1szcZL/MrBfmI/+t0rSb6GEd0ZkflG 5co0rEHaCV2h/pWzLqLeXFZtEsc0fAJ4DDjGazNyG2iWRwbjdu34Xf8AcJ/2anvrFRHJKJM9MKw7 d8UAZSxOzAQZK9CXG3FbyKiwoswYK/yCTBwDQZSknoj/1P4fLiCZCUJV0dvlYHLgVl3RaF0jPO0Z DCg5ybT7i5YurMXRuIlY7jjpn2rSeWeLy037WHzHnlh7UAUGnmmhmj3MsQPznP3sdMirGlzSQQsm 9nbnaSvK9aCouzKd5FJsLlcS5ycg5NFiXjWaaWCSUwryF5b0AxQdMHZ2P//V/h/v9PeVUIRl8xA6 l+GWoLW1iLiC8DIoTIuV+fb/AMB7/SonsbvZg90kirp+52WJmNtnIVfVsZ4ziqlu8glMb5YZ2q5O VBrIxTs9C3JC3+s3OJFcKFzjPoa2iEt7JiMG5X5wshJWYnt+lHkIox2rqTI4P2p48qxGRz2FX7fT wBazfaHEi5aaHZkjtx7kUGc3rY//1v4k7WOS3BmupFO+ZlhjDbpQB61ajY7k8qNTHcSeW7ZwQazg 92ZQ3salhBA2rWkLFXaBzIsAm8p5gB8wU9yBzj2r9SvgFFBBp8MjO0c9vFJEXgTepj2qqgDsGL7S fQd6/Z/BKl7TiqMuy/yPw7x3qcvDcafd/of01/8ABIBbbVPFUutRaPbWk8CP4ajtHLSSWtruDy3B J6F2J/75GM5r+m74pXP2b4eakDKkJ+z/AGVA+WDBEZhtPbGzr6VyeMs3U8SoQve3L/n+p+i+D0FD wvpO1vi/DT8kfw7/ALXOqXWtfFjxM0OlxyNps95HeXseoZVo1md9/lnrlVUcf3TivwS/akvIdT0u 40ZrgoI7yTUIJHfEyqXX74B5PCYXoK/rLOpvBeFEk/8Anw/xh/wT+U+GnHMfF2rWW3tvylb8bXP/ 1/4WLu5lleNi3mPHGIjIRgsF4GfoBj8Kt6a5E0JB+e4OzaBkHHc/lWuJd6s35spfZ+R2Di43M6gv hdiH+BWq1Z2t5dKZppZdyMAfmzn2rzZ/EVNq5euYriIJHbxR5bCszrvPPHFaUEWp2K+SpiCyE/aw rq7wbOTn2rjqdTMunV4oBHEYS/2hSpnHSLHf/CtCzlMUYlgkBjjBI/vZ6VgB/9D+LoW8q3DXsLSb ppcXO7JX6gU+dT59v9mZF+dmnO35nBznGDwc818+Zc7NmwkngfaG2ow2+ij0qdbmW2vFl0+V4nVD FM0TlQwPXOO/vUyV0NT7nRW8kVxGRLCkm1NyiXhgR3qoGW5uAi3EUSjP2gtgBB0HesmrOxobipcL DBbad5cs8ikFY1Z2wozu3YxhvY9j7Uy1spUnjmkbdNvAK4Gxfc5rGaSYH//R/klm1S1ikmlnV8Qk pL5C78e4A7Cuu8NbNNaWSyVJIjbS6qZJJQizMzAtGSehwT/3zXxGKi1TCUnbU/sv/wCCFXhGwsfg 5o15eXC2urz6zPdfYophJC6xhTD5ig8EFsf8DHpX9T1k0q28JLbtkYRR3UAYHHtX4VjnzZzipv8A mMMkn7RVZf3mvuuWW+bL55/uk1LFExHJORzgcZrQ9x/GhGxyxUjnuKRQyNvB+Qjp2NTR0dyz/9L+ hkXcE4ERY+ZEgRhjH51zHiG3uBaOLaWTzWQlQsmwlRyec+nbvX8mYhfvbGtWH7vQ/kq/4LFaBoK+ OLDxPZrfrLPZm4fUbcGWMCImPyu6j5jyD159q/AiSK+uZLR5rtJ493nKzAQGTPOHAr9P4Fq8+XSX RSZ40n+9kltc8zu9aill1G2tbdzc2MrWyyNCRGkgCsQpP3sBl6etbGnz3U+l3V9DJbRi1hNu9xfW 4MgfALFI2GOqn06HpX3iS6G6dk0znv7MWA2l0Lzz5yftcLW5CkE5BBXnjnpUZMs08t3BITKpy8p+ 8p9B+XT2q4LUlOzuf//T/jk0qa81QvbzShprQCVGvYWCzIScRo3AJ4PGeKqavpd3NqZniwluYVX7 Gqkyb1ABbd6deMd6+fOB7jrGJrNbwsVRmjwzuu4uB2Xjg9eeKzxeTNYzSzaClw8d4Viv7tTDEVA4 WNOx6/N39q1jFp3YjctDY6hatamW3iVSpAyUWFm7tgcY71jwz21q8qkxyLE+C6PlZAp6qfT3rRJv RG0XdF+PWHv1n1EIJIfMMZbzAzyMOMe3TGarX07lE8q2yifv/NJLlW9P61pGFtWTN9D/1P4uILl7 SNi0l3dNNMXklWPe0e48qAB0X09q9Fg0/T72xja7t4r6NxiSBhtMigcE+hHb0IrjprqeeZ58K311 DO1vcyTsZPMSHOGiiTGB+GMZp8NzFBcx2tyhjm/1bsFHUdiPfFehTS5bGc3ZqxneKYLm4gt4bbi3 mlKlzII4VYDgEnjJ+teESRW4+1G3hELLK0MmGGJdpwSOcdq9HB7s5q7uzb8F+SPEmkyLuVU1CFpS zERIquC24fhX74/s66pJd+H9FTS0hsbi3tYVkvjunBfy8JK6t8oKjC4GP9XnrX9SfR5q8uaYuh/N Ffgz+dPH2i/qODxHSMn+Nj//1f13/wCCOt8mleEhY3d6+q6msouLh5c7GeVkeVkGOAGLEf71fuL8 d4Bf/DfxD8iPu04whmbGA5B3H8ga/XPFlOl4n1Jf31+Z854dt1fCbDRlq1Sa/wDJT+IX9pKUab8Y vFNq07lbS6mhvrZgHtrlttr5flHuF2PgeuTXz/fXljc3b6dJPIInt1lhl8tvKjcj7g9DX+hXBslV 4cwc1/JH8kf5gcaw9nxFjYPpUl+ZkWclhY6zdEqqu0P2aKUsRIzLy8ZyOmf5VFca+iT+RJZIjReY VuYfmlcNgqhH/Ae3rX16grWZ8MpXlYwp7vWElnu/JvCqwFjAkRJYf7XHSobK+ubm3gmkkt0mnuNr RMjI8a5xjnge/vWsIfcYVH0P/9b4P1EadaJti2WcmWS8VJ8GUk43DB4zg9Ku3lzbRaZHHcxsqgCJ EJ3r36mv9oLW2P8AFhsydNt4LiVVJhsrWNSFdM7pcZPA/L0qfT7YWtxPA8gufMn3pK64UryDkevT 8jQlfRHHN20RJb3R0DVPPj/ci4Z45GmiF3GACdpKnI44IHXIrKOp3FxM8ru0sjyb3JzlzW0YpGQy 3nludQd/MjhmiXcI2GC54GMY6/8A167Syjk0h2+WGKSYi7/dEYeQgfM3qcAflVCbsrn/1/hvU763 1Gxk1W5u7vTbuFf3dokQ81HVvmbIOBnHGKpm5tXe3ntryW4vmdAXmOBcKVO8k9Q2en1r/ag/xAbu 7kMmnXpkbzMpA2ZSsY+c56AHsP8A61aHhu3uJ57iJNQmsCkO0Ncq22Uc/KM9MY/Ct1a1kRKN0ZFz YQJeX1leafLessiSTXwuWguWB6ohB5ByOccfnWhpkdpb3S29yJraNnCxTOm5LfHGGb8RzWsNzBq6 sP8AEBxqEEhuBOFQo8Cncsgbo5x61WtzeTWk1tNPbxJG+61hCkgLgYAOPz6VvB2djLldtj//0Pgm LTtUaBbqON7OCKdEuL2WNjbxoThiWA7joOtTTTW2hzLLbyGR7lt93K0pzLH0TaOoz/X2r/cKDSep /hQ1Z2N9WtrmGSTRbqSyLN513ZGTE9yo+8EbbgggkeuD1rAdokuI4dPjjt4gvlw20EABBbAKnHJH HT3NbGEk0y/qd1ZRW8Bgt2MjApNFIpaSFgME7gBwecUk322w0keWZDPeriSIfLGy5DKMHkEdznvQ Y1Ohm2E1xFIu+WTzSQTJ95Y8dAB/npXS3UEk8rXiOSkaL5rEBRFxjH44PX3oOSW5/9H4hljWKH7Q 5zHJIIwY0aQKxwBuIGFznqfWrVgYI/Mhnsytw8nmNMx2kDaAA1f7kH+BcpPYfDesHkSJl8oSmNDI peIEHByB6U57+z0yfBlEwZ1QSwxsY5WJAwMgEYPqKDMZf3Ju5hdrIAWYI6OSWAAAXB/z0qG41W+t o4DBdXEUsIdPMgYpK0ci7WQkdiMjHoa3irKxEZNvUdbCJjBd3u2dA4jYRviWLIBAOehI/lUgt909 wmmCSK1lmaSGOWTIJ756DOKZm3dn/9L48tLeF4TbXccjK0gkk2HYVAIPX3IxVG6S3W6FvC8qiJi6 2knzKwYAbs8eg/Sv91oqyP8An/K8ltaJcRXKS3HnxxmAwtJmzjUlT8qdjx19+laX/Ermj+zN5ryE EtOPmiJ6bMZ/pVAMlsJLMxyRv8h4yh/nV2OCDVA6xvHb3gQ45xGwHU/p0oAsmxs7+wF0ZomktR9n gkUlY53TA2jPUjufasa40q8t47O5u5raW1unYvbwXP8ApsGwqBvXGBuycGgmSvE//9P4yELMuYbr y7uOUeVbpHgsvUksePbHv2xU8ianaK5kdYnldWIQ7mVCwBLH16mv92D/AJ97EkE9rF50MU3mZl3z SsvzMce/1rKv0kN9bz+e0VhEGlkaMmNLgdDuOMcbuh9O9Bg9y5CI5rd3RR5cR89pPM2Fl+XHB75z 69aqRxmec4dRGRyp6L7/AMqqLszKUOqNOG9+xkW6MlwyP85PC47YFZ9y6SXaTRSyrNhiUUY29O9a 8yvYmMeY/9T4mit3nMoYxYI2YYfvHLED5R+Oan0zR7az8i2tZo4rOJ/LeMNvYHcSSGJ6ZJ/xr/eA /wCectalHb299A1pOpABcq2C0gBx0B4HFV7lReStOsEcLjBGxSEB9SM0bARS7XE3O25hjBVcE+bk 447ZHP5VVt2Cxzm4R94wY9pA3+1dC1QBJcTTIokgMQAHyE7xx6HvTYbiR5BEx2oxAwBwvbNBM7WP /9X4sWCGMSRy3sEC7jiaUN5ZHOPugnn6VHE8UjoyFMMoVZU+7J6c1/vTFXdj/ni0UCy80EMjC5ka UqSoAXG0VSZkklFzaFYpYomiCSLvVw/U4PHYf55rTkRBI+Lj7IHSJJrfKiSONYi+fXHU8dTUU7xN lCmQcqxHBPaplCyuh2uWHjjmgt1Yr5VuuEJ7Yz1NV7e6jtlM6SXKwTk2sxUHymG4dQPcD9PwqC2E f//W+K7y2sRdR3FnLMsUMRjcklI58kfMU7EdB7UroJ4rcrME3udxjXqo6ZP+elf74H/O/YlhiWGE R7czJIRK7sWLD19vTHtUNy8WNgicbhxN/Ax7j/PrQS4pioRbRLJAjfMdsu45z649O3FRzTWsiLIV IdGzsPRB7UEODRethcS5NrFGW8s7FI+VRjtmqkEztI0c0yRsuWVQMkHjOT17VatytEH/1/iGRlZt jKSj5zu4AzWpLPFZafDHtmZZpDGscYwifLkMT2xj+Vf74H/OuQRzx3X2d4tpmSLZOqdCQSCcfQda fHgvufC4yN3tVw3AqXd0lvJF5SvLmQKAo3Hr1Ip9tClxDPqETKkUE5ikUjoRj/H9Kl7gTXF3bqQp YeZGoYog3tg+wzUE626yebbl2hYAsJOoPekB/9D40MVtcwJAcJHLhRnoh9fb8Kj2fYJbczQSm0Vw CzKQko74bvX++B/zrlZEkTUJjEgeAN5kWF4Veo578VflWFH3mRWLgNjupPY0AQzM0KrIZAFZgAgO MntipHm85g07Y2ADDD04/pQBlXDSXTudojgimxAQc5GB3/z0rRaEG3jEckTbxlmzlo8HpjseP1q4 bgf/0fjlJCkHlFQAyYZuQw+lZzqHDKhAHbPUmv8AfdH/ADriwK8KTPIhbPyxsD0PHP8AMVJbzNub flgB/jRrzAVjMVmfy42wDnc33SKnjabPmll2M20Lu5Pt+tMCR5GYlWZVVT/D1FQtAn7wxSOybd2D gtnHT8xQJxT3P//S+JLaW7ljMV0jIqDCKTkEGpnGIwuBkHg9xX+/B/zpSi+YkTOVDuNqrzkcmoUh WWafMp2gkxZTn2H4/wBaCWmnZjU2o7eZvZQpyF6g9qgtmjnO9MmLOVJ7f5xQPkkbMUIlBd5dqKvJ 6VQdWjd3XMpxhS3OAP8A9VA+Rn//0/jCFjPnzmEK4xuPCpjjJqZ7psrbhfMiSLYtwD9/GcGv9+D/ AJ01C6I/sYuoAJZH3o4YeWdg46VMLaPyJTJIyugyhLDBOe/60GZYjt3jtUSe3jM+fMSVchtpHH4Y waozyzxOkcVsuGB812fO30IFRDYCMnekSzIrtGxKuqYYZ4+taUMCRKGAzvHPHX61ZDUubQ//1PjP aEu2WFWQAfdwQiD0FNlZmk2LgAnk+tf78H/OY46CtKg3W6sXw2MgEKaVnHERG30PoaDIz0vLzzza +UGC58x4m3oMHH3q1oBCxCf8tFbOc9KDaKtFGle6le+UzT+Sy7RCg8lVl2qMA5A56YyeawyEfDuS FYZ3dCKCj//V+OrZhb+Yu4yIw/dg9eDUdxcSh/MI3IMLheM44r/fg/5zyjtee63KrAxpuwWwCPpW qtyoeIOoYBhwePwoAZfNFLdzyQBo4TKzRwt1jUnKrn2GKYymS1kMMe6UrhFIyM0ARTfubWIF0EnC hEG0/jU+mRmQyK8uF2/JH0Zn+vSgD//W+M4ZkVx5kWGf73OVX2rSeSzNu8ouYRLFKsItBuaSXOcs CBtwMdzX+/N+h/znlF7iG3W3hAeSWWQJLtxnBPJH4ZP4VYuXjUSw6czNbcqxZAksnu2M+nrSApWN nOys4J+VvnJGFAqa7e5mlVJJXkEa+XH8xKqBxxVRfKwIf3wjCSrtIOAxHX3qGSPhUZ8c5LdeM0Sd 2RKN1c//1/je2MYO1d5YEKqqOPqaS8huLVTPaGESPJmRJVyrhj8x+v171/vwf85FmlcoXDGOItNK C+fpgGtGDy5UgBfZwFVz/M0BZ2uWZ1smMLzxKXs2BDRDb5hB4b1zUdw39omT7CrCKLEksTneyDIB x+JqZXtoXye6QNapDKrIpGF+YSc4PtQoYiQEZBPynuKyTadxxjy7n//Q+MI4gkjRSndswxU8lcjI 4qW5hMiqY2OBxjpX++in3P8AnPK6ARq2xRuPy5Iz+OKsfZAsKuxVm4Z9vFTzO9yFG0rmcGV1nSZw qj5rdguWbGMCrGm30nzIOREMFe4FVGTcrFlqZXuYmlhJRwT8o4II7Gs61uBbrMLtV3l/lbug9vrz SnuB/9H4plvmWPMUbMpIUhRlh2zV2yimkjZ/s0roGwZEjOAeuCfy/Ov98D/nPJGZHcKWRUH8R4Of epZktpt0YlSARpl5HOUcjspAPX/JoAzntUaIbXzIp/d8/LjoeKIrVovlbbnHDZwB60FKLZWdSrHL 8Z9al+yxmPzMhZByAe4PP60GkY8p/9L4hOVGZY1bBwAeAfaqNxC4kVUCI0vzxEtlIs9Cec/gea/3 wP8AnXNixknitkEhj8+M7fMQYDEdwPwzVWaQl5WmXc5OS+c7etABBdoyn5MYO3kcmrjXUwhSL5YF iztZeGOeeTQBUhu3tkddyujP5jOQC+eR1645pz6o0bLNEfm+8hj+830/z3o2A//T+Kbcxuhu3jaI qcsrjGf1qGRVnl837qE5UKfSv98U7M/51zVhMaKxDAfLhv14rPknAhZW+T59gA9zgD+VDbe4EcET CVwysNgyARxVr7QQFU9M9KpP3WgC6gjnSOINJA85JEyHBhVVJLD344r8Pf2j0aDxDqs1xFcyJLdT vA9zKD5wJTvnr0r8U8e7f8Q5xa8v0Z/Un0UU34iRt/L/AO3I/9T+K1IQYlWZxCknzqsjcjrnFRNa Q7W8uQEK3DDo1ffVVqfPw6EMs9xbQyRRF/mIyFyc49qwVuHW7XJL7m+YYzWJpKPVF6d4x5iFXE+4 HcWwoHfNNVGiR9kjSW7DzZVIySfp6Vg9xqNndGbsE0h3IwTOUK8tU7WoSKQGMsrA7FQ9zwD+HWsp voWf/9X+Jezt2tbdTIqvIIxvZR970pnns25MBQ3y4/iFfUHjloIYoAqyZcZIz0/GssG6n8wRxp5n RpN3ynFAWLv2cAKJHw5XnbyVNRi3VLlywDoiDJ/i5/z1rObexqoKxddtq7YkJVhj5jiswwZmYBAN xB8xui+tTD4kZtWdj//W/iMnY2+FiZfNQ5z1qPz552QsMyZ3AD7rd8mvppKT2PMp7E8XnLF80ZLh iW74qEyzvG4i3ADggDkVja2he25MqqGUlTI+0GQjkDPY1caGMfPCuCqDCZJ2mgBLCyu2eZ7g5X7y rnceO9U9Qg8yUtE+EKeWYj90H1FAup//1/4j7a1aM5yuUX+I4yPaobpmXdGJQG+8Cxxz6f8A1q+g PPsWLW0eRQ5ZvPwCWB+UirrdxG7/AGgN8xYfIMcYFAGnavNhVcr5ROHYHLj6CsS/TZI8jlmQcReY eWI6YoAjsZys5uJkBIG1OPlGB/8AWrVF4bqQIWDtkrgnIAotY2j8KP/Q/ilWzEUTKCImyzbycF+t ZJMmnSojo7TPiTc5/hIypH869+SujnD7N9qVnlkZnUl1RcLge9SWlhfWlsLiVopVlZnjVSDKoBwA cdOlYAWo1ll2SSBd7chD95frSNehZ0jGxI1QlyAck56fzoARXS6ldGbO1clD6VXlxbzAKBtI5OcE fSgiUL6o/9H+JyyCQkuhO8ncVJyrVZk1QBSJFYKM+Yo4OPavYOHl97lMYbSfNi3MjHcoY5Iq/wDZ 1bypJz5aZ3AAZ/SguewGQWyFCA/mNkD+FR605pxGVAJCSLw3QCnF8rMi1Dax3m6QyTSmZQjgsQSF yAM9RT8GJVVYUCRMdsTHIx7mtrp6IafKf//S/ihV4buIwiOKPk7jjaqY9KqXEEMDRRISzscJ5fcd yT6V7U3qeeQxqkU4ZZXLAkkg/Ifwq4YzcN8xyTwfUCpAz5Yp7eUrHhFU5JP3jUisxSSRJU7LKhPP PtQBPIomiWCE+XjBYqOFqVbeMSKizBsLyGAyw71lJWYH/9P+JiVLSGRNhAUt90epq5p0Us0rqCpj 3EZx1FegeeT3thFZyJdpKSWdY1XphjxVsaJPJHczXG2NkjDQqSA0lU4tLUDmHlkjl+R2RoVJ2Y6/ hQjyPtuHQjngDjNOSSSAtGJNgneYBJD8yj+A+mKomWGMYIXJYslxjO4dMGoA/9T+HuSaVJPkPmwq /mEryOfWrAWOcCVhJ5h4RU5xXoHnlO63QN+7Ds6jOGX+Q9atWVrJLERcOYo1jMyrt5dscDP40AXF mdmY7mLKgRiOMDpyaVZDLvQBNiDHltxn3zQNK+hDJBGysAnzZyCTwfalFkjQ5wsW0gYXuKcXZ3HP 4j//1f4nYtFuTA10iw+QigFRIPNHHXHWueufnk8uBxviOQjcD6g17Cd9jzyxBDMpV4WM8rkIYs88 9gKqShFTLjEquRjbhlx2P60Dv7tgVpLiRQrCIxJuC44c1et5CrfvQJG6KewoEXxb2zrvL/vEHzRF sE+mRWbcOzTGCaNPLQZVgfXse/pQNaH/1v4hIDJYkmELICQ2x+SRVVr2eUmPYSJpDu7FPbFewcCe jRrWsZkynyhYR85J+7/nFUJpIopWkbKgnamBtDHtQIri5a2kcsH+flc87D61cS5kuYJPMMj3DjbG 3aPHQ/8A1qAM5RNC03nkhkXgng0QRyXmWiPC8tn/AD9aAP/X/iNRZY402ZHlfewOPxrGdo5biO4x lRJ84zgEj1r2DyZKzJ7mGPfJOku3kHLfKv0qS13bpJNymTqsartDfSgkJbmaX5nzwNhJB3LjoKdH GTGHllMcWcKO5+got3AjZJfMSaUM1vyIzn09RV8TebEkAPmHfuVerL36fhWc11A//9D+JKbcYHKY aVBloyQHAHfFZsRJeOQLkRnLr0Y/SvQPHLcuqzXMb284BhdvkdIlEq47Z61DNp4ht1ljkOB82G68 0AVRNCyqrsxlLAEk4FSPCIQ7Qx5LAZJ5X60AVNOnlillRYWKv8jtztOfSrFw8mVG99ynBXnZj6UG sZ30Z//R/h3LTkiVS+9eBnlPwq892tynlQQYmOBvP3we4z6V6B55nKLiFpEOxWizlsblb6V3enaa kukxancXVoiyTfZ4YPOH2lyBySnUD3PrQBkzkWlxMlxuTy22oByX9xirFhYPeuQkszxrglWztT39 qiUW2UpNKxHq9i6XMVuY5Tx8siITGePWsBriWANCnzeXklwNo/EVkSf/0v4dPtDTNGEOed/Tkn/6 1As7246hokLcErnNdB5nOrl+C2NvhZFLMDxx8x+tMufKt7iNpE+ST5s55GPb+lA1JMe14LlC8qsF D4UnnOOBWRqFwZFRYFClWzIc8EU4uzKL+mzpPCYpjhT9wZ+YmugeC2QRkysI8biq87T2zWrkkgP/ 0/4jnRZE3btyiT5zJwcDPNMlubVjHCwEax5KhPmMma6ouzuzzymGlhmXDqUK4RsYzn/JqxcFyVZp 1DkY25xitU7iezJwj3USSzEt5AKKxFQO0dqQ/lgsozkDFMI7IS4vriNijIE3IG2keveqzecF8xd0 iHnBbGz6ZoGf/9T+H+K9jkC7mOF4Izk8VJmS8cMJXGwbEUjKgDtXoHn+QtvaSQOZXkdDu+4D8px3 xTry/S5VRIC2Ds+7kqPagCJz5S4hh2Iw2tL1J+lNa2iuZFEbu7Im5geMj3+lAFlbeX92EAESDACj rk88Uy7sLq3kNx9nkVUUNtkGzb6EZ/pWTm+gbbn/1f4fob0JhmYsyqQ/mfePoB/hUttqUGNPe/tw 5F25eND8rJ0G49v/AK9dTk2rM866vYbvkWUSGBLm3Lt5RYZCDsP5U26s3miTCfKcsUU5246VDaQ/ I5y1aVJXCqzRKegXgV0MERn8lmVsFsfKPvVgUpNKxYli+zJIjMcM/DY3ECo3vorlRumZpYVESRmP G4AYBJHpgda0u1AcZW0Z/9b+HuEs9zG5RWkj+ZVZvkyO/wDn0qxdXDSTtNIqFgmxRGvyqRWji3Zn OtDKb7RHmVeVwctjDKatWsJv4WZA7sJCpkcEAkdTn8alwaNVK7siXybqNthjuNkLBVnKExKT6Hp2 rdhkj27GBkbjJIxj6U4pO9ynoirfW7JPGybY7SRifN3BmBHXIHNWLS9iLG3uJleNlKordB6EUpKz sYH/1/4eruWK3kuHWbc6cR8ZA56Cq0IbUd7GPCLHw+PlYjHetYRtqc4wQrZjKltw+WRScbc96044 YhaLMkIlnjmPnSmTepQjgY9j396bimBltEpZpLcyBY25X7ysf8K2NNa3jSVroiSWVcxFG5XnkGsb W0KirsnupraZOANw4Py4xWVHbxsWYzHAO6Rs8kUHTBXZ/9D+Im1Lyb1RpXCHYpc5BHTirkNmsRd5 1MqMdpUZLrz6UNXVjoEvtFuLdzdRWp8lLcyzSyD5Qg6f5+lc0EZY42dSkIPmO+OgPAOK5zLl9+xo 2CQSM3ntIXDgrnHlheevueK1XnRF8mULKhYtBs+8PTJ/z3oJas7FiF0knihmnaODnfJHHvdTjjj8 KsKzWKRXDN87qzQEgNnaxAJ/Ed6bTW5nKLb0P//R/iRgH2iTz5GDs0hG3pGoraSNLfax8tIVbcMn OPesoLRoiEbas19L0ewv9Xi1H7Z5MqypFbwSsFgycglT6nvX6u/ArQQUht2WWa0az8uWYDyPl2rs I6kjK/rX7x4DQcuIZtdj+f8Ax8dspw6f8zP6sf8Agjrox1O1t9YMWmwveTvpltdWow8kVvM0X+ke hPkjHqDX7s/tIXtvp3w51uTe1tbwaHqKyMcLGG+xyKhVv7xz8v0r5fxLm8T4pTh2kl+X9I/YfDuE cL4X4drT3L/hf/hz+D7456nG/jXxlNp9zcrfWzT2F/cX3zQpE7bxgnq79M/7Qr8N/wBqbUQ+uWi2 du9qtwNs9pPkTBxAquFPdWKq4z61/WviFVeG8Mmu9OK+9JH8j+F8Pb+I9ZrpUk/ucj//0v4Vorc3 ayBSqvFzKDxjtXQ6EkOnn7TdxQXVujbTAZds7f7uDkVdXWciW7TVjattXxO/7gJb7jJ5L/NkdgTX R21/b28bMPuyrvC44Ht+lcE4tO5bd3cwoNQurhYriURWcUlw4UlzIiqpPOfXABrThEZuYo2leaOV fPdwxUspPUmuWa1sxbbnTS2dsAm2MNEx++zZMQ7Yqh+9i1FYYlzbvHh1zwT9O1YOD6GPM7to/9P+ NIweUHyWG4cAn5F9jVaKyghka6uLyJQkiqsG/wCaQnjamOtfP2Oc0Lu3W6aO2spFcSIQ+G2+Txzk 9sCrekWFtaabqDwwESQKxRCCZbkjPIbng0mrqwm0ty1omoWVzp87XUU8N2qjyNy7PNP8S4PXA6EU JpdrqVu98LMBBP8AZ8zr5W9uhBHfgZ/KomuoKS6MrrJqdpeaemn3RtLeyuMTxRj5wgUgKPbP6V1k Ny1zcSBGUJEgluSWCnBOPl9655obqWW5/9T+SSy0+3ju1+yTM8E+TcRM/nbxgnr25xXZaHpFjNdy fappobSSHmEBpoy6nMYKD+Fm2hvY+1fG4v8AhP0f5HHVrWgf3Zf8Ebvhb/YvwO+HutXGnadpOp62 rXt7HCd05DbSplz8w2hTgHoGr+he3V0G44AcZGOBz6V/P9SrGtmGJqwd05uz72djfJKPsqUm/tSb +8tr5aISwJJOQccU6CVjuYk4XoBXUe217yI1mjO7JI5zhqJGdxtXnng9MU6O7KP/1f6C41aHzd0Q ikmbLO4y/wBf/rVX1FLeazuUlQzSOFUbThmGeQPr0r+UpxUqtzWUr0bM/mz/AOCt3hLTI/CupXlj axXFlHJPaXNlKxgW2kTY8be4csQxHTaa/lvmi1ZEuJtTi0yKJYQsI0qZ5YlxnPLAcYwBj0PWv0Lg qUIYapCPR/qzyasVGceXqr/izgNZtVk024/s+VoJbyRZzIi7dxUYyc9CQMVLJqlzLpS2TQQ2kciI ZYYP3il1Tbkk9zyTj1r9Bh8KLS3MiBIdPLXVwr/NAQPLXcwC9AB/hW9a29q9pBeAJHFdxNL5DgLc Hv8AMnUGtae4oq7sf//W/jnleG9jht4Q8csMoZXjYjb1+8Paltz/AGbeW0dxcTTrlmledtzDOcD6 ZrwYptnG42iN1LUI4lLW6hppZBDErEIqbv4jnt7dav3Qt7u18kNLKAFGWG07gBnH0PSt0ruxmcnF BLe3cy6WLiKK3XF758PkwS4yCFc9SCOvvWjam1hMMbWVgr2pbarxCYzg/wB9Tx+A9K2SUdhp2ZFD Z26bdOjWO2tp5/NMpPlIjE5PJ6VuynToXfT45vNhjhG24QiXzZP4l3DjAOeaYNt7n//X/jQiVbWR 2KhEiyQkhwQK1RdSNYReXui86YxLPEfM2k44wOmPU+tcdNHlOXvXRYT+0keGG21C8QSqY5GgH7xh 3ycd6uz6MJ3TUPMjzE582J5RGz4Awcd674uyZnKVtWVtQ0w6ho8txcFItLnkBicthd0XzNuHUckf nXz3d2KWVzdwx4+zvMzw7ScAE5H416GFdnY5qsrkXh2ZYdWtkvnkgt2mEck0LbSMsMZav31/ZX1K 7k8MxaCbaCS3m04bLu1gEUt4vyyfaJHPOAG2gA8AHvX9KfR5q24mqQfWL/TX+u5+E+PEHU4WVT+W S/XQ/9D9Ev8AgkD4iXS9T1PSbxfJuNMurdIftBYWtzbPFsARz12Fc/ga/pQ8e2UGp+FtQt5IopYl 0+ZkjbPkygRlhk/hxX7L440nh/EWrU800fN+Eko4nwrwkf7jT+6x/EX+2VpUWi/HjxZpLzGS91O/ N/YWckYT7JGpeEp+BTPPY18ca7Y32nREsMu8mwygfNAeeB+Vf3l4bVnX4Oy+q9+Rfhof5leJkfYc XZjTWlqjMO2mu7/UxPeJFdyKqojiMo4IXZuc55PTnjmrraKTdvIJsTI+53U5LY6AfTHav0E/NIy1 sy1Jq93beZYXlvJNd3EDNZuBgXG0gHc3pzzj8q5XU0l8kRT26JLIN7BTuVSOSB+da09hT3P/0fzg 0WzTUp/3h/eKxjmKk+WNp6kewFddqXkrFptpLM1xHBMXeJSR5sXPQ+2e/rX+0B/is9EU0vLSG1lk SJNQtbV8xWsMhDygnBG4HjH4dKrxLFbyyGOW5UzuZLaF5PMSEHnaD+I/XpTTs7nHNamnHbvcafci ZYXh8wTPPI5LxEHHHPXp9KqpbxWV1YtEci4uFUSSLsPQcAe4yfwqudl2SjYutpFvqGvTzqgS7a3W OzeNDtXau5jjpkkYz6DrTrLWjDo7W2t2LyX6XDxxsrD/AEc5KrsfOSBkHafWqU11MbW3P//S+DDa 39xbG7jjguYjdLBdK0gDQ7sncfUYB6elTfYtLgtbubHlSxOvkiFt4BJ5GMk4AB59q/2oTT2P8RZR ua2o67GlqkcNrI94bTy4pUXKMwGFLdqkt7qDU7NtL1K3MepTRLcHUbViEiKgfuyenfOPanF8rDkV rEupzW1rc2L2+nyTl4vI1DUWlAiTaPlCJjr6+wrFvPOkMvkMzRsgM07r/qAWAyfpkD8a6Iuzucso djMitIdPkVLm5F1cyy71XbsZo/8AZBrWW4ka5nSDT90SYWMTJiUgcjnt16e1bJp7GbWlj//T+JPs 1rqYGpQyXEEZ/wBGliZy8ETJnJK9vrjuKuQ21mHaS9VZZhH5jxyxfupEUcNuBBBB/rX+30XdWP8A C6Ud0YWsebHd2l/BbL9kEixH7Odu1c8kY/zxVzVIoodUhk007oURbqGYNseN8Dgj1Gf0rWMraM5p K6IbN5dS1qae9YwI44hgiCxu3oPy5zmtG60WSW5YXuq3hRw8kYlJMNrhcKMjnsK0TvsctToYtlBq dhbLqFxBEsdrIRHM+GjuACfnAPUeua0mvru5jl+17JFvJBNIEjEUbFTlcKOO9PfY5ZK0j//U+HrZ nll+ytEiW7vyzsQU25wR/Ln1rSmbyw6GOVZlO1pJDuM4PRvbrX+5B/gbJIyZbe8hjafTJ7ZZo5hK bW4iMqXJJwQFHGe/PpTrCS6aGe3u7eGJ1cSgmPLk9+ccdentRboZNWLVvY3Uk022MvJJB5ixOpWP AUkEHseM9e1VzFcq5VkPmKdjr0IB4/rW6VlYmy2Fl07H7mKZpGJw0mOh9femy2xsZEt4bp5gOkjf K2PUjPH0reKsiXBX0P/V+MC91FALqJmmAPltIAVizj7pP5VWl1C3UwFo914QPPKj5UXpgZ/z0r/d g/wC5GJI8fmBI1I3LnJBK/nj9KSIvvljR7cxxJl1wRMCcYx26HPPpQJxaLMWoLaWzQS7pULF9sgB UA9kNN094U1GGSCVkt5H3IScMAeoP54NBIapp01q1zNb5dZGEiRIdqk8Dd6Z6ZPfAqpPJcg2klxJ clIRnyxFuhz23Nj370Af/9b4+t2+yGKW/ktZSY1kVoQdtpuwAHUDPGeeuMVfgiF7vuC7zeWGkbJw koUcBRiv92D/AJ92uhzoLXDysiKnzFQyj5B6Lj2qys8lvbmwCW0iyg/bmnt1kmYErtCMeVGQDxig wkrNmWzi9lls1iaGJGAADkFh19uKnj06KCWWZmkMm0RIFJAAyeSKBAxgLSRTb4pCgMbKfmzxjPsa 1NK1b+z5lEqQTow2TKByynjv3FNLWyC1j//X+OLiJru8mGmQySR+W0gijjJkIHU1j2UqyxrEsckL NIUKuCg64xX+7sFZan/Pbyq9y9cpJCqFpI1x8iIwy5PB4NPknC7cK21gCTjaWx9PpVkSjbVCi62S GeKESKyiNoWUEdskVRkZ5YbkLbrvZv3Sq5Bj75P6jmrU7KzIK1vIiQi3ll3SRcNuOXWrMdvHgzSB 0iDf64LnH0rRNPYyne5//9D4aimRp/OURXUMMm5o5huRsHowB9ulW1vRPdTP5EEUZAe3ggTyoUYf 7PoPb1r/AHo2P+d8TZNt8y6RCwfgrxuHbimNFJcoQg+zSLKpSQAMHQH5sD8xWykmBbeMKDJFG8gR csP4sDqSKSRRJbxyCIrkbjkc/j+Rol8IDEBntpYIyI2ByHZc4/D/AD0p/wA0SfZ0lEkJw7xldoDY 54/z0oilZAf/0fiOWf7MTvXfG3G3kn06VY3xPafu2jgMDeZnIU9RwR/nvX++B/zvlDzruO8W5E8d xa3NsyvAgDbiSNrA/gSPqKnQi/jtsvJZmK43SLMm0FQMYPXqf5CgB9zeC1uJLOSFm3xBxIo/drnp +YqrFcxK/lpE0rbdxlaPKDnp9aANqHUbyyaR4QI/PgMe5UU4U9RjGBwP1rPWO2/1qxhZ85c8AEUz Nwd9D//S+Hb3ULPBjXc0qxl9iL83Hp71PFe3NxphW33yhbhGlikX5oy3GT9AT+Vf74H/ADuezXUY tkEMcsG5HRv3x3YDBjhuPzrWtrVrmSYmSOK1iX75YGRyc4AX8O1NO2w1FJlJYVWcGEFSjfJu5Ix0 q1NcXUdjLaWqxoX+9lAxPfr26duaRMoPdGFYN9iuIpb2ONvPkVbmVVJCL/ERwScDPH0rSvZrQi4S AmW2Z2EEwUxsy8gEA8gkYPtQDh2P/9P4s0+eyYQ2Xm4kitty+aCZZduM8469OuO9KQCuy5uXeLzS w5yqD6e1f74H/O1yblmRFtp0FrN5sIHDbcb8+v8AnvUTNbwM8l9FvLH5BGdjN1wo9aCbPoOgnhQx XEtsZo4JVm+zs20sAc7c/hjNRX15/a3lyRWkVkxdt6BuoP3QBjqKAs9iskSwAW7Ptdpc4c5Df5/r Uqs8D3dvHYtcTENJA0cyqjbV3Hg/Q9cdO9Gw+SR//9T4nRriVy0zIMKP3QYfLVWceUzSjJxwF96/ 32g7o/52eRpXLFncvdBwx2KBjgbthHfFOlYwu7eYMnaq78LI4PRtvocHmqJIrrDpuLbSCOny7vpQ gt3SQ/vQgXjaCWOOhI/woArxJ9oAiO5Y5DjdgqzZ4571uQ29palLe1ibNvAFlaSTzC2eevb6UAf/ 1fi8GQsfMj/dFsIc8n1FWJRDGhIbBxkDHNf78H/OvbUjsvs0o+0SsY9owQ/RceoqWWJRM6wDcgb5 XUHDCgTSasyI4SSRvJCll2sOoPbvUfyrbm3ihjRc5wqAGgZmwSXbGSCaHZGrdAclx+VaiXMkMkEs EUUkYikguo503bdysoZfcZyD2I6UAf/W+Oo4d8UkxVTaDhzJjPpgrnv6UjGPDxxoCExsZcBWBHTF f78H/OrHqTNKEUbYvKAUKygnJPrUWYiznaZ49u0K+QQce3vQYjr66cCLa5ZmiCFf7mPlAP4AVnIZ 8nexc4wvoPaogmBLCUjQZyPLwpLc5FW5b5GVBbKxVBtcsMAt3x7dqsD/1/jaGUyqzSLsY8FcdKi3 FN6gh26jjJr/AH4P+c8q4dwx4Qg9jzViGKScsjfI7fKjH7rfjQLlXYgNvJbs8Bi8l4ztJU5Lnrml WV4wsSJuZTgnHzUDL7GRlDSHnG0Bv4etOtI7V/Na6nXEIDpBg7p+cYBxgevPpQB//9D4zDiMuCjc 9G7VFAyiUqS2HGCG5x71/vwf855JLHN56SRkmNBgtjJNOnhWUBmIjQMMueKB2exXuLKeOfeZVeIK CjKxIOa2beYWpifaD5g+Uf3scUeQcrRTu0WQBiFLlyVA/hpYov3ZZGQSxsGbPU/QUCP/0fidtjs4 iZmLNg57HpxU1tapAhwoyfvcdK/34P8AnPEKsCcDIPGT1FKkiJuQOFYDkn+L2o8gsLbzzjzlWUiO QBPLHAq1FNAVVA251O0nGcUASzfvXaIEExHCup+Vx61BJaTwRK8m1yemz+Hr/hQB/9L45tJURJD9 2QHaAeCarNc3MxktJFGC+SwHIxnAr/fg/wCc9q+jIzbxnasjZ74PfFXCm6OOOLGQ3yseAPrQAhjK L8/J6HPINLCYLVTJaZFxK22cg9V4x/X8qALW4SoxcMWTnnqaiF0sQ2vGcdBxgisGrNgf/9P4tM/7 +U8ZY8g8nHQH9KuPPsjbaoYqM8d/av8AfA/50EtGx0Fkt00cjOIfMIAO/ai5OPmqGFBO+pJDPFL/ AGdOLadEkBJJJGVHcdOfcUAlfRDLlIlWMOqjZwOMdT/9fvSxt5QCBB8xz0pp22HySJp7hlgaGFFB dhk7QWH0+tZ1xZTIYmYBjKu4Y5U4605NN6Caa3P/1Ph3M0Cl2jKspIZAMg47ikhlku4UcpJC45WM nYy/l+Ff74H/ADoJXdiCVpZWW22Z38sznA4x/wDWpx82NoIZS7RuQ7eW2QoHr6dP1p8rtc0UF1NI MPMjYsyxK2Mj+HmnzQPLu3TkqsmY9jFd2M4z/hSLIJ4iVGWxtGB61NF5QVCoJyNrk85IzQB//9X4 naES7lPy7T34xTJLUxSjHzgAfN3r/fA/51xGQZ3bioUdM8VFLDOE3qrvC7bfNKnywfTNAFOSExFF eRFc4IUHqPpUV0TIwjJJTjg9KAtbQdZ2qRbwoYgnOCSQPoO34VqxQRo6s6jB7f3aAP/W+NJLiwkh e2hZ3kBwSV2qPaqQt5IwAo3D+6CM1/vilrY/51xzRzeVt4iDfMxZeQQPzpkckflbZtgCkM7MuBkd 6clZ2Gld2L008IiYQEOxTiRR8prCV5XMgiOQo2ynGWXPpVRV4sRHfw3senSiASTTvEUtApzKSMbh j3XcPxr8Tf2rZxL4qlsoohDZwXj3QdJvNYgBFUH/ADzivxDx+vHw7xS/rZn9UfRPVvEFN/y/qj// 1/4lLpR81yrOqo21VcnDHP8ACKsxzxCMRsRHj97z13V99V/U+eS91DonN3I8QkHCZY/dwBVW4slR WlhzuVsZzg8dTWJak7WMyO3WWZ1MjiUn5w5ypHbFaF0jQBGi/hTay4+9jvXObGWzMqGRW2OW6Dqa 0bGTayCRGYhdzxnnH0/SspqzA//Q/iWkkuHUrGpQyZyCPu9elZpjkTZLtMkitzsyRjpzX1B45eff Iu3gRbcux4B7Yqa3e2t0lVI5DKFyDn5eaDaMbKzE3mXJjZFkQ7mB9KTEt67uishjX95gZP1FZzWl yi/BbrcR5gMh2jjzRtJIqa8sreBY2mmUuQN6Icque31qYfEjKa1P/9H+JG4hiciOKMRjoGU5LEeu a3LfS2ESKkRZ44TK0iDOFxz+NfUHlQTuUpj5R8qNWw3ykA/Mfc/lUcdo8HJJRJHxJxkgVg92KfxE kMBsixnLRNcKQQjdVJ4P4jmqlxJHaSB0kkL/ANzHDL2JpFKempct9YE1ud0flzgFA0fHy9MY9xUH k7IzdXLOnnSBLWMx5809Cc+lA4yvI//S/iciha4O4bWKN86Hgexou7SO4QxeSiTY+8o6c9f0r6A8 8rpHcWahw7FY+PLLYD1qxW32iPzUBLyAEjuvtQBL9mjtUM5mmDKMNDs3R49f8isZBJcSwebHK4aX MQcfMoJ6/lQBZugLZ5IFhViGO5egB+vekh+ytcQbEMcgUB0Xk59KV9bFxlZWZ//T/isv1ijV2mzI duxYwxBA/CsQlJ2VSkqLFgrLJ94+30r3Zu2iOVySVyUNbHzH3OmzKfMNu7txTpLry18uMudvJXnB z6VkQptbkbpJ84kLRsV42nDDPaksrFo3b7SJAucsxXcVHriguMubQ00hjDq6/dYbWONrMPcVn6hH ieN40Vju2jJ+Ue9ASklof//U/icWASKiMwWRDu/dg8/QVAkRmMgdThXKlWH3sGvYOBvW5AqCCX7z hAeBj5fpV9JvL2zhDIgfLB+Yz7UFOSaIZXjfdM0YUSEAc4X2wKijLSymHO5R/GRgLQQSvdLZxkJc t5rHaoQYAHTOfzq5FP8Aao4x0KR8yBSN3+9QtNgP/9X+IpmcTPEuzzA2T6Y/ya27ZUMkKT/LuAUl OducCvYPPLZ021iEsqMJPLby0Q/KWJPXFZ7Trp0gd4lnOMmIkgc/SgCNm+0IJSFXzGKlScstZt1D GVIiyJUGcjo2KAvYSSe6iCwx/K8sIDqox+H6U24guoihk3BmQHHKk5H9azqdCIybbP/W/iGiYODO U3MvyrGOcHvXYWt5aR2ySp8uxcyIBl8jrx716UV7yPOZmaxqInht5YIGcyMAkajc4IHLMO1Zdtca hdTLb3HmHAJDEnC/56VsHUsvbAykFs3CJzn5gw7ZPaoradY5Ck6srA4KH7v4VErOyGEsUlzkqpSK Ns4H3XP/AOqprmzgMaLvRSq5EapkZ6moS96zA//X/iPsovJScNjZKMMmMlwpzxVTyzLO6WbbcfNg 5QAjsK9A88stbDok5luYnzKpHyAEcjNAt5ZvmRyvlcFOgzQA11VJSiBm3Jhtg/UiiOzvGkQshVSc AjGDQNOzuaTQiOQNtQIpwdx4z7VKBa+XM20MMZbDH5Pfr1qoq7sDd3c//9D+IqS+DyGKFpURk2M2 7HT2qtbW32id4pMsCMAp1Poa9dKyseePgSW0kcmRlCN8knIbj+VSzS20nllUWb5s726u3csaYGZM WUyuuPLl+VkHQ/Sr1s6RR5f+EYUKMnp296BN2RVjDTyPKd0TE7d3TIHY0k0bBgkeZCfvN6mgUZJ6 H//R/ie0VUt1kN3aRXBdSFEucR8cHIPv09q5uWZUvXiKqZlfjyzlD9K9g886NLd0haQOPLkQF129 Tx3rPlhSaEs7BWjIWNdvDe9AGPMrAEzEE9AR29KdHIYwioSHAyAerUASSW7Twq8rnz5H+YHuOwFR o0lq6iBQrRsA4PCsM96cVd2DY//S/icvdYW9tIraOCKF/K8pmhiCM4A6se/41zkemupJL5TP3emP evZs72PLlZq6LE8fmoIkZQsfBOPvH3/KnW6SQkIc5Q5jYAZos0Zlu9ZyTPPlwygOcc8DH9BWU7R3 OXRm+UYweAPYCkATtIsabC2z0POT34q1YXq2EXmPbrLM78Ow4K+lDV9GB//T/h3vHadxL86yyHI2 fxA9qsQOioYZGdJ9vyEL0Pv7V63JE8ctWMMZVg7B2QF+e+OTU17cRGIgSDfj/VqfmGPb0qXCyA5o xvIzyMpPzdFHArpbaaE2isVWMK3k7erNx96swKLTR286MQREG7DAbHrUd3eJJJtSM7W5DDoaAP/U /iMtRCsKJdH55W3L/sjt/n3pIZoYbllSPefus68KB616B55YeNI1a3mQYz5sQb5WfI4P0IxWVEZ1 nTIVokbcqt0RvagCxeTM7ROQTLuOMDPT1rcs5tTe3kMUkcEQUPKMmNiAQMn8xQJ7EM2oXKTb5btl zwo67e3FYeqyIWEdsDhgN5P3nPcmixCTcLH/1f4c7RY/MVCoPOAemD7V6BYwy/ZvOUK6Ipwrpv5H YiuuSszyFFvYfbaPqyhdSubB7WIxC6j+04HmKThSF759O1cTq9vEX3hiP3hDrnJBJ7VCaewJNvQg tgC6w5yp4UgZH41HcW0kck0TRgwuvyTL0zz0oNYpxVmPtYkQwxYIbd94LlmrcRURXE8hAUZ+Ycn6 UFH/1v4kJVBgLI6iM/wHgn3rO0yxiee4lDFpI8uIzyMdjmug857EFqZGlfzo2ZS5P90rV23gEjzy Sj7jbEQ5DfUf571cXo0D2ZpJcQ26Fo8gDhoz1+tVoHjmEjlMOW+UsODV3vEmMkojL+IzSCSQ4kCB cAcEDoMVnPcLGBGQ4A+8GGA1KD6FKSex/9f+HKFY5N3lxpGHbI28CtSF1tY22lC2M8n5u1d3Ok7H kt+9c1bmWyNnBLG07yFQsrSR7AD3A55+tY8sccToynH8XC8kVQ3J7G213YNZqr26woB8+073lPbb 6VyEjOJdojcRO21h0cDtms5voQbySyWUdsIgCp5i3fMSMnn9K19V1uS8th5rCXbH8x7nA4BrMD// 0P4h7HTbS70+O8a4AvBKYmtjyq8fe+nSsu9tpYWAfaFQ4GOd1dB45asPMETO4kEQbavHAPerVreS WwaKVS3mHEVwTkqO6ke/rWcot6m61RXmsngYPbMNsvzg4+QjuK2dOvvs8MqxxRrnk5G50HOcccZr O1tBmHfXiXzokO5RncxYBd56VmKPIuFJ3KyPuLg1pzLlsVGLZ//R/hxSJmZp0DMqsWyPlFakU+9E UwH72AAOT710LVHOTWojurmSEKsMiHLAnCt/9euquFtLeJIYSjgIC8kYx83U4+hqZNJWLgtblJbp 40MAkdYH++pORJ9V6dqxQ8Qm3JJnacNGeDU0+prboE5R43VQqqx3yM5J7dF9PwrDhgaWRi25Ikch Zdudp9f8+tKe5n7M/9L+HG6hByI8TIMbnPB9+Kkgt57ffA080MUi+aieUcdOtbpWVjKUbFOCKQyN 525t5wGkzhsVpWt00HnDy/3K/u3XOVb2IpkFsRFbabyZDbtKmNg6FT1G6sSRY4HWK3Ys4XJPvWU1 qbQXulyyQk5mc+VuAkOMsK0b62ijKvbI8LMBGVfkSn6ds1BopOOx/9P+Ja1jvEhhWVIIoUYsAq7Z Sfc9+aRJJXuYZoVKOlwvmKeVcAjIYe4oNFPudh4l8aT6rJf2skSWdgYFijWFUVCoUA5wOoIrhLaa ORhabfOQ8YZMIQelYNKOiHe82d1YeFtMEeozanOYriG12w21u+/LtjAcDgDGTn9a5eXTYbV1WHmJ DjDEswJ9KRM9yKXQtcd2vNLFvLDFzdRyNskx2CD+LoelTjS75YH+1KF8xQ2xDnb61Tk3uQf/1P4l khNsFSP5cnBYjOKlktLlYRvU3kUzDYsYLMnP8YHSs6fUuMU02zr/AAhp7y+KdPspthhnu4fs0Myc Rt0JGffB59K/Zb4O+H7v+yWDSxpqOlW0caxeZjzV2kZVh1wQBx2Nf0T4AUlLNq1Tsl+v+R/Nn0gK j9lhKV9G3+h/WL/wSD8PWUfgKJkhkjTWJo7lkkg+xrphgYhwBj+IhiWPXJI61+kf7dF62n/CPWID qAtI73Sbi6RnP+jwyRRuFQ89/wBSRXxPE8PrXjDKD/5+x/Br/I/aMhf1HwkpNf8APmX4p/5n8Nfx k1eTxDe6/ezeXDNqiFr1bb/UIYX3jb3ywUdegavxg/age/bxqStrPb6ZplqJiXInlDyRp5ag9SAu OnTIFf1R4uWwvh77C+yivusfyd4LN4jjmvXa+1J/fc//1f4XhIwC3cflgyth43+WTjuV9K0tOcTz NJJGgdnwBj5F+np/9atZpXdyJu8kb9zYt5kcbuojHPyfNurcSyjS1VVlVXUElSMgema45rVositG eKMwXQVYmUkKyA7M/wAQz9K1VulbSjb2dskixTjzLvrOQRgJ7DgmuOa0uZzfQtWG5FBuGxGcbFY/ h/hWhaIJrl5lx5EY2MwXgY6jNZGZ/9b+MmOx1BdR1IS3UV5pN3Dm381zDNZMBghdo+YEepzk9KqR aSkN1YybpC0chEcTAuiE5APPsT1rxZrQ5zctHC3E8UiKjpwSo6g+/wCFaMlxcoi2lm523Q8t9v3m GemaxImmS2elwSXUclxuaa1QhN7Yjjz1wPX6+tEljfTzk+eYbfzwypE2Sdp9PfH61E9jI0Wt9Oku DFCcXgwrlVPmD0BNadrpyWZ866CSruw8bMQkg4+Vj159qxkroT2P/9f+RzRhaeF5bm/Nz5Qldrhr aS3+0wNuwCvOSMDp1r2vw1a/b9a06PedOF/LawwAwtiRpZFOAccZwB7Zr4rHNqjL0PHm7Umf6H// AATN8NX+jfBHwHNqlrZpqMfhu3nubi3AZZZZx90LjsoA+hFfq3EGEe2Q7gQNq9CK/nXAw5VKPm/z Z9Hg4KMFbYSdnCIg/hp8IcqB904yeOteudb+JCGDeO5/Sp4rcjgHIHGBWtJLm1KP/9D+hZirMsDY aQj5FLfMw9BWTqUMYtZA6soyD7jn/wCtX8qx6lST9i0fhH/wV30Nr74S3V7FaIbVNZdXlt7lGl1F ZRDuhPIK5C7ck/xdeK/jzv8AU7vzLjT7W2jtLa1vDBPG0nmlYQ2Ac/l3wa+34KatiF5o8ycuarCP ZW/r7zC1y1nSEGHiHIOSOpx0z+dcdFfXEbPHIGEew5kVN3lsOgP19TX6NS+Gxrf4maiQDULa1mWa fzLeQvNGAAgA6Adc5H9Kmu70W1kskFjLLMXAZsM0wHPRa6ae4Uz/0f4ynlmtZ/NhcxyTRjJIwyE9 cj1pttPHNe3DXt2moO21E+bebNkwfxPHfpXiwXunLLSJonT7PWLuFrmQyXUMgy0jBYJVUARgIOhX HLHOc9q3LsTRzx20X2VEgYEvFKCznuEx6dSf8K0h8SMSrdSxW7BYy8rbTuTpES2OT3yMfrWbZeRL fR3VzaJHkGPd0dxyCDWt0gGTR2d9fy6ZPNeW1sMN9qityRz2BPB6YP1NQ31ra6XpNxLZ3UCn7Ylr Fbuwju3Z/wCJV/Dn/Jpc0QP/0v41IdFVrWC6iuVuDcP5d8JpSJYwFPKg9Tkjjp15qzo9qNNS7e6v ZFhaIrzGAr7SSAB268kVwwdmeRa7siWDW1triIwzwW8IlDLPLwGI5xn3rRluVvdGXUAs8V5c3zD7 Ki5VVHGcejdR7V2RldEyjdFiPWbaw0K8h1LQ5NUi8ptg3vhWIwCVXrtJDY9q+ftUSRDKrhQiHcDH kLjtx9OK78PPWxzVY2ic/ZSrLcWsHlRPCL6OWYzcJtV1PX8Pyr95f2RtWm1jRdCvgkEMUekz2tta RTfvAI4QQ7exLt09K/ov6PUpf63SS/kf5xPxbxvgv9T3zdZL8mf/0/qD/glZ4onb4hahCyyTxwpb Wsy3sgNvCjsUDxj727Jk556Cv61dQ+z3Xhe5WZi0VvpjN5icFsR5x6Z7V+8/SHoqjxtGtHqkfH+B c3W8MKMZdL/dt+h/GP8A8FFLO1/4aTn1t7N4riW9lsZ7tICEG5Q9uOOOjgmvzd8Z6jOsl1JDPezQ QTqt6IE81EIwAVH0yT+Nf2j4TScuBsuT/kX5s/zY8XE48c5nb/n6yhHfw5n1JSHN1bxWqQoRCE8s Y8xkHIJB59627e9smsblY47iG7t5EmWQxktMjDJx145H4V+nH5Wm3Kxl67MdUh0lLKaWZrJJI53V NyASNuGCOhznrUdtpumwWDT2326bUYplEZknBj3A/vCyMM8D0P8ASqi7PUqSdrH/1PgOG+hspoWt 7S2jco1s7GPb528tlmGcD73bA+Ueldhbf2LC9jpJksPMhsnZ5ixkZ9qg4Z+nPTj1HFf7PKSZ/iu1 fRmakVhJaXlrbmyaOUBo/IKq9uN27KYPfBz9azL+F4dPsY0nsWgurwQJPGSLzT5QVTJyOc7hxyMj 2qjncFfUyr2Cezlt9PspZLiKW6aKVpW8kyHONyLznPXBx16VbukmtsaeHjk8lizOTumiZR8qjrjI J79hRsPlfYrWZ1JXE8bT2kquQoRypOc4564ra0az1O188ap9ils70vJa295+9nilHUrjOCQOM+lB Linuf//V+KxpltLH9mtUe1eUETLCSVlbPXH0P6VzSQjT7lUljmvovtP2Quh2eUCcbn56qOcd/wA6 /wBoU2mf4luHYt6ncqtzLbaZ9tkutLOy6Z7by1UsAVA7dDzz3FZ8Esttp7WVzcMslxdLdXlyhG9Q oOEB7Lycj/Ctk7ojlZ00Om3624nSSXUxMgkxaAyRnAJQtjPbqfrWfbRNc6TdX0m9JoWIEOfLYMrA YZSO/wAy/jVxbTsZyjdXLOtmA2tu09qtvcBY2tZHG5wXCghTjocn8q2L611G00a1ll1Ozu5p0KRy 2QYmMAYCOW/ix39q6I6M55x6n//W+EdATV7W8lF7iO0uCYRFcRkRS7cEsG9eR9M+9X4LmOLULgz3 BeE5gEf34o0P8I9gCf1r/bg/wyktWNk0q2mNy2l3TMDODGJCTb7QMNtB5Xp09zVPTrLWriWeRrZr UWbiSOa4wUnUMBlR3yenatou6MJQ6o3JpxAlxKoVLuR9smP3TANz8i+xHUVjQ6jd3ZaEtMSrEL5g 3NJ+PWqOScFcuGDWLqGKGG3aRImL+TDlowT1/KrE+rWk9nFbwWiQ3Eca2ztjzMuh+ZiT0yfSqi+V nNOB/9f4utIgxikuI42jMe2ViSkanHUn1+tMD3V6l5Dawl1sXBBgjNxK0YOOo9vX0r/cdNPY/wAE HFrSxUEiw3EQbzI8uFLlTmPvyK2dUuYntLTy4kilRnaWUfeuN23BJ9sdP9o0yHFdRiaxqUBFs91C IbiNI9zQrGQONpZxyce9XxLHZHULDf8Aab6M7ptQmAZLjk4EeP4RgHp0xW0XdEODT0MeOffJHC1u 6tLJj7Sg/d8DlcetVNa06e6Z5be8FhBEFhli2E3V0pwPlboM85J/DmtlO2jJ5WtLH//Q+LLRY5Yj bKkltCkARVjYvuZVA3HPrj8M96whbz20k8l1cLIYyPIh8vyiVzySe5Ff7rc0T/AjlfY1blLZwWgu ZTbOgIjddkiEjnJH5U28u3XTLW3trMysJtkksbCOYK+0FmPUgY6e9VvsDi7aovGGxSwjWR5DMmI1 ilBYgc5+Y/jVUrZpLaRwSNIJFy+1Aq256cn0B/rQZ+zRpak01q8dvFe2uoM0eH+yv5kS54A3cZPr VONb5UcyZkUNtMe7cgx29sUb7GbVnY//0fjGZxIyO9sI2jQBl5/f+hPNILi8YBTtgjA2RmIlSynq Ntf7sJ32P+fqatqT2c0EPm7YijhN53jKjnG7A/D86NSRtUMb2v8Ax8JH87KBGswQDA/IEe+e9Bzz Wpji7H2tVlidJHt/KE0KKUj2lflJPTOO1aE8zXEAlRvKZW8vcqgbsAdacVrYnla6EXkQx232i4uU MvITkO07fhVRIHMqzIyJvIG11zkHsPfmtlFIbi0j/9L40Fy1u8TLw8DEo4OOvBpdUma+LTLJHExh WPfFCqGMjI3HHU9Otf7wH/PeV1iuT/o0kAuA8KtJqNxEqTpjn7w6buufYeuKgCOrMoBYKv3z9w+m DQJq6sRvctGuIhllB3McFW/DtU9hcTsJLjbtiRTHMQOCD2NBha2hHNcQpMF+xtMLjISZBtigxzlv qOlXrotPaJEZNiAfKEwCMHpimtHciUb7H//T+H5FtbeER2Nt5I+9MXfzJZXP3mJwOp7VLasXiQvE quGIUqOW9ifyr/eg/wCeHkdriXM06PHuj3DPOTwn1FNUXTyiVt4SNNsXOEIzkgD/AD1oJJoLqWae S0gkhgkNu3ny3KnyypyCFOOCRTZxdAxxQyB4lON2cJj/AAo8i+RlWKWZY5zuglklnCxhAUe2Axnj OCDn07U/5grs+WK9xWkZJKzDkkf/1Phazmd3uPtIikWIeZApO1m5A2H8e9WrxIrlWBgSJXwWhiY7 OMd/fFf73KaP+eHkkTxlWWNkjVAvygKOmO2KW/Vp4llW3kMUTL5jAYXPbP5U009h8jI5Wa8jDso3 xIEjXGN2Ox/D+VMtlUOBKMYOWRSFPHbNMHB9Au5nWUQxx/JtyZfMBA/2dv8AWlSGQskhU+UTtdhw eOoX/Pegg//V+HpLlGDQLHEFb5fmiXzepPDYyOfQ1Jbr9ntpYAQhkm81mBy5wOOfTnpX++B/zwcr 7E0eWmjhaQBpQdgZtm/Hpn/PNQBm8yfaTtgbEiJ87HHfAoDld7F0JcTR/ao7eT7PGwSSYKQiE9AT 2PsfWppZo4bYWyDdNK/myXD/AHkAyNg+uc/lUc6Bprcp3E7FEjUIUHfYNxPfmokSNUZPLdlY5IJy AfUelLn7A01uf//W+OLAw2JkvZYmCC2mgDZ2Nl42QEH2JB/Csq0hDh5HfEDcIR39MHp6V/vZ7TyP +d+w+5823Efz5UttXHX8qjdftTbpXV2gfcrd88jOKfOgsOe4lVBGkJlYnkIRuAqC3mlml2QIfkcN IDwyAHk1a12Avag8cb7WBcmPchU4YelV7eYyuGjDhlGHyMEfjQB//9f4lnRA++MASYwWP3selQs7 eTIrKPNb/UuR8i8HqO/av98D/nfJYWihjEskoNyEC+RGmBOeMt6D8aX55pluXh2xbQhVzuaPA6Z/ Pimm1sKy6jb+C1uDCzEgxfMhBwgzjt0/OpYILhLgQWQV0kiG92xtAKgv+WD+VPmkFl2JZUwpaNgW RuNozTkaZnnCuBJcw+W5I6+h+vFPnZm462P/0PiExXNlbQxQtJd3KT/vElYYUZGcfrxV+JzHMJb6 B/LlRghAxhscH8yK/wB8+dn/ADsNWdhM2wzk/K3XFMS6xI8aFgQMAAcCqU11EEc+ZBEQ7lxgM3yk H6VMWEMilAJCD0PQ1YC3Eomle4kxEzDHlxrsU8ccVVDyFgFXgnpj71TzxA//0fjSe7UJ5QhaNgMO WGASKYZCo/dqC+3IJHy5HSv99009j/nWSsTyPcXvlRN5cMrkBpsYjT3NZkU88MzxvIkkW/EbIvPv mhuyuY8rvY1IxvNwTtkEZyHUcY4H8zUEsu5kaONvk4YKO3rUQfQVraDQ6PJsONvXGOtI1xIZVjEa xRxYRY8dQDz/AFrQLH//0vjm6n82QOFjiyAojiXCHgD/AD9ahjto0u45JN6GJC0sTkLvyM/rj9a/ 33bS3P8AnQSb0RCG3bwYzH+84yMhhST+Y5jELmJQ3zDG7jHTNCknohWtuItw/J5Lg85746VM91ct L9oYBLjeJY2C46YPI/CmVGNyEJd6hJLO7YJkOVHAOeTgVYNpIqgGPCp95/X2oL5Ef//T+MDN5fyE 9eq1MFjhXznjDSSYEfPQZ9Pf+lf75qXvan/OpNKPuj4Z5AzNgKjt8sR5C57AmnpNEpPnASLu/wBV ngmm37thJe982QXH7xwqJ5aZ+Vc5AFSIY1wSN4iGWx1SoTtsaW6B9oi81CqffBA3D7o96rNKqFhH 8rufvnpj0pqchRXKj//U+L4ztmWQKu1R6Z3n3qSB3CS7ULln3b2zkdsCv99XNdD/AJ1eVFq3ikuI 5cwvhD/rEI2p3IIxWfJp7PL5sTjZtJOf4vSkndO5nJW0ES3Dq0T7hkEHadrdPWqsdpcRMsUefKjG NxOZGxxzUN66CSb2LcRaxnill/eoCHMIOGYA8qfTP9acL/7dPKnzKFy3lgHbH6DP5UczvcR//9X4 tQB9n2lMMrnYR2xwOalwUuWTyniG1SJGIxJn0Nf76Qbb1P8AnPLX2ZnTzWHCnar4/TNIY22fu8gj +E0Sk07IBsivHLC8jM0JgYCIHlXz8v4f41BcQTxQRzGMlJW2kocbaTmwsIJWiMSncM88856VY1Ca JHjCRSuxVWYsm0KT79/51Bag3uf/1vi6O3aeQ+Xjc3947QPanT27iGUAsZY8fLGMqfXP0r/e9M/5 1eVbEFu11KqRIR+7O5tvAGKthTD5kkSAkn97Ig+8ff8AKmNRSdyvLelgpKAkcEHoKZPdPNBI3lmP Z8sbg/ePb6UDGQSzxRwSS4+Zcklcg4//AFVfgDGRZC+U745xQFuh/9f4wnkZpSCmFB+8RgEVAoEE iF1Z0Z/m2DoK/wB8D/nWskOuXhGTEpb5vl4wxFQSeWGDxkksPmTup9BTvpYYyR5fLMUaqAzAsWHI APOP1qRRIxjVXKjIyMcn1pAOunt5gqxmTcjYzjaGxxyP89qWK4htgokXJXkDGc0DSu7H/9D4ruZJ 7o+ZFb7IpBuL4OSfb61SmvZogh2rIIht2/3hziv98D/ndcFbQr/aLi6tUdoPs7lt23dubbmpH+0+ WuJG8hTgLjAzigXIhJLKKYo8ifvkbKt/dFK0KKOSSBjJ7UESVmX4DbheGx9eM4qJ3EsqFFYRr3Jw Cenr9aCT/9H4qmtlRvNDeWsi8YXPPtToYnU/PIfMA4B6tX++Md0f865U1G8vB+6Hkh0ACbVzgHn5 8dT1qviS5gJlVVwdhC4UuMdce/vVSs5GlNaki5SLy0AyP0pIfLty4jjCtMfNlf1YAD+Q/StI2toC jeTuVbhYtUtNRW4nk09LW0lmS5VC+TGmeg555Ffhr+0veWaeMrtD5xu3eSKCVY8Ws0QwTyeh6HHo a/D/AKQS/wCNd4n+ujP6n+imv+NgJ+S/NH//0v4kZkluMPBuyh27Au4fgP8APSq4gYyHG/5V/iGK ++qnhRV6aLNqqNsfIEiyYYHjircqPcuFbMdsvBI4J96xKUNNSmIYUuEQS+ZHGdqu+FY9ePzqLUGL pseV43U/KF43+gNc5ZVtFnY7ljWUAY3dcVbiZreXEsToG+Xe6kYxUTWgH//T/iPmvGjZSD8pP3jx V2waMqdiB0mB4zjbjOf5V9QeQtxrkySvDsG0LkBP4B0rOZZBOImL4K4WNRzx696DctQ2hgheYq5V v73L/Q1KirbvFMlw/nOhVoQcRgehqZr3QNi0uELuvmL8y7V6BQ3qTWUsxeaUMElCkqTncpweorON uZAf/9T+J10UZfIUsc7emz6Cj+3ry0SS2t5EBYDZcDmSMDOVHPevqDzyqjbJpJ5pHkdwrkg5i5HG 3t+Va5uVlg8ry/3mNq7R8zfWsHuYzXvGJOLoOY5Vc7MMhbr9KkLT+ak7xtiZRHuVP8+lIksXMVtb lWQjLDHlqMN9TWhEBcxIrTOypHtiBHyqTzgD8aCofEj/1f4vdP0qC2Xz9SuDErzCOOOEB2k7k/l2 qrJ9h+1v5LsXdisaOOSM8HH5V9AeeT39jBDFDIzB55FO5FbKKPf3rMsJk3lEcwKj7nZev+Tigly0 uiPU9RnnkWOEBVzzsX7+O5pplWQRTCSR5Ix5flY2++MUFC3JLgZh2TKOeQSM1TtFWOUcBJJMsMnJ qVuwP//W/ipnlTHT95tw7gcEVWWORYvNeKT7O/8Aq5dhCNjqAa9ue55/kYUk8892UkA+zBQiALtK 47k1uQxW6x7izSCNcMcZIqAJ2t4lt5Lp5zIjZZAV+cY6D9KzDqcsnnYlXbtCxkgbhgdx+FAFiCWS 7fy4crLs+4DktnutXHsQloGYsZlPJY4P+eKAP//X/idhXyhvd1DkHygT83/6qqtdS+YNzZKtksPY 17B54lxc+dESi5U/KQo5J9cU+O3cWzK0shjbDBHbbgj2oAtwwCa3kFwr5VcxrGMmqEdrcLLKqqXg RR5jj+EHjJ/GgCcwW7wxoyK0iyfLIRgken6Vbts287GQM0bLsC/wNQB//9D+JG6VIrjzUB4b50b7 w9qzrq6klYbQyorbiUP0xmvYPPOjsrhEt0Vi7SFdwV8sapvGk0hlmMil+ZI1OVXHTFAFcPmTCREr u+6DnaKWVXRVYLIAWwMDgUBY0oFi2RyTAGUHCM3f2NZeq35vWLyNkxoUjCfdGO1ZTethJJbH/9H+ HyEvbmPzVZTJztA5IPeuitViSOVgCwZD5ZHY/SvRWjPPMmG9eGcmLfDIcxMynoDwSK3fPtgVjhLs nlASSPHsZmxz+RrVtcoFRbWRMuLgiHducAZcjsAahEdsZNhb7WCdzq427OemayjurgXrm+DxLBEB DFE2AgG1c9D/APrrOLxtEWZx8jcHOSTWijaVwP/S/iGM0p8oK2ZWb915fVj/AJxTI7z5GidWNwsu PugBe2M+tegeeLcGaFlGFWNiJFcHLyH/AGq0vMBsmdnjVh87KjYIz7UAUCxs4XuQZCzLguOm08Uy z1iVHVfmlVgQiyZI5FAEv2iQuolUEBsAk/pVlAt3E4ysas2CsfYjviqhpID/0/4irq1gg27HJUcF iCP8/wD1qSxvhbXCPA8iywscyjlc+leweeSvIl2jCMkncd6sNpB5HNZsIKnb5QIVzkBuOKBPREs+ N21UG1xuUDoD7VXMZUIxZsZ3EemKDFtvc00vbaYOjS7WSMHKIcsegH14qENmWMRq0kY/1jDg/lQV T3P/1P4jtQuCqukZZUfAUN989Ky9MgWS6LuuZFPHBwO3NeweXJtaHc6nB/Z1tC8zANcKJFHHlqp6 c+tcnNfI8qx7co3AYHke9AoyexmSSkMyAiTBxkDg0/yWDh5TmRl+QZyUH07UGl7Oxa2S/uVKs205 EijhfrWdci4RnOQSTgE9K1prQmex/9X+InTcJGGcbd2MjFXLzEBTyk3qx+YscYHtX0Fjx/Iz5rpY lKrCvlN976/WtS1KFVkdQwABwBnbQAt5IjmSRRsAGAqjCnjHT3rl40kTcgi+VXLAj7z57VjJq+gF 2KF1iWWRWaIvhsn7p9KjktppYfOToj/IjHCEDqTUgf/W/h7MBk2sjsjKv3R1BqdEeZJWuBI1xHtR XK4wBjH6V7B45OLYKZFDL5iRbvvAA+1ZH7oSl2LB2XYSBRboBtWFuDhcEByMiTAI+tQ3URiWRwFw JuNvIAzgVhYuMUynLm5eKJgQGYBfl55qSW2aMPHFtd4mG5Rwfy/pTik3Zi5XeyP/1/4k4EQwxs+x ZE6q1UHtxFkiTLSH7442+xr0mktjzxrSLjcrGZgNis3JJFT2V3CiO9yi7wcLH3Pp9KkBqEyzAlNq sxYFTzzVxpZAz2251UgCRemcc80BsYF0wR1dJHkHmbSrc7cdDUsRBBPLlWyxP92gmHwn/9D+HtJA 0qusKqEPyD+BSO5rbh165skR4XRHBxwoZD9Qf881321ueeac3ibVb9YoY32wfZmjZs/MuOQR+vFc nNb3EzLP5bhSxUSMvyOe4H/1vWspKzCxNBEI1Z/9W+djsOQKaWWW88uFllibCSl2wkZPf2xVRjdX AgvblLOZ44m817Y4jmHAPFQrfTzhBcn5XOS5GGAqZKzsB//R/h9UNPJ+7Y+QCFce1bMMQsjNJErG ByAGLYZevUV0HnnPXLMsjyIZo5N5fDcAULftLtd3YTocEbcBsdD+NVHqQ5LldiV7h51WAxhZjIMv nBxV1Ybq0e1inZG+0Z+zhXUk46ggdD9aObTlMi9dTIDHuG90UIUXgnHc1jXMmZN0uMj7iY+UetJb htsf/9L+Hi1kSNXuJEzHGhVVUZXJ46VHHFLOjyFQu35kycZ/Cul7s8hK7sjX0yJpUJmZnVGysT8x qcdlrQlhRlM8xTcq7fs6/ek9Mf8A66uEraMrkkZGolWCraoyEcmMncVI96rNLIu+ZvLkkRQs4Ayw zwDiplqyeV9h5kWKWJxKyOyApuGVjPcAe9NkWadwIEaTzm2sijOcd8VIj//T/h9hiW2uYszlLcN+ +aMkqCRzuHt/StOe7gmiETRebDGxMV0qncfwroeiueOTf2tam1Fr5DGJ4zGu9eAR/FkH73vWEqSB S4feivwr84Hoayc76I11UNDp7DUdMiMK38DzWTA+akB2ypx1U+xrMlWOaUpYgrHOT5btgOV9D9BU Fj1spDCgmtGilTIhJ4EmOOvvWbLFHNBdSTyrA0a/IAp2uwwNooNoL3T/1P4cLK9lTbCQvl9CMcn8 a6K0ijEkreZtIQOqyZCnJxhe2e9O7WhzlG5Z4pZTlVGcgqMGonnuIYvLVyYHG7cOn0z2obu7lxko 7k8t0wEcAUsdo2vnO7PpT7axPn/OCdyghh2/+vTT5SuddDRaCIjypUDf3FyV6eprId2UOoWWIQBg AqfKR7/Whu7uKMm3Y//V/h1sGYS5aRYwW+UnnYfXFbr3l7cboSWlWP5pJ3ACoBxwf6V0Gc30I44w 7ADDLHyS3BP0qL+z3SK7dFXcoDkFuSP8/wAqDMqxpJNA6q7MWO1lP8NZk1ubR943SFR821cn8qia 0NYKyN4Wot4Le4MiSw3UXnEoc7cEjB98ilN2LowGW6MpP7qHeOV2jhfwxWdtLln/1v4rbeffLYrd QRSRWz7XZOPXBPrnpTdSuvLV8RxSEuWHlgLIo/u5oA5+4njWBmSLzWXBdZTwAe1UkvYWby4hIMrk qAML+NZTWtwNqx1NoLeYi6kWcjlnyzT4Pyqe3GeM+lVhqksfmeehaRx8rdMHtUAa1vqFyIEklDqD nY6nKMR7fjWjb6rczRB5o02K21JVHzvz3FAr62P/1/4tLphcTqjeWVYZyo2hD6Ypts+pQrKmnRxz ScITO+2JcnqTjPasE7Fxdos9D8PajNeeINBsZbSOG7hvIrcC1G4uxyNxb1yetfrv8MdYn03w7pqY tXl0d1uTPCuZpFeWMCFyPvhc8cnjvxX9MeANJxrYmr5H8u+PVXnx2Dof1v8Aqf2a/wDBLLSza/Dy zhltFuVNvBqBu1+R5E2IzEj3zz7k+tem/wDBTbXLXRvhfcLd8afqtlJBEdpbdIOfLAHQ/NFyezGv z+r/ALX4wNxW9Vfhb/Kx+6VqkcN4TQc3oqP6H8TvxEtL6107UFgW3juBdX9xezqwNpsRS21H9Co6 deRivxJ+PXiHVb7xTPHL+6tvMFvcYfiQqiBSqnp905/AV/TnjlP2fBkY9+X9D+V/ASKlxLiZ9dT/ 0P4TxJKDdM0RmcEBZMY8tc4Bx+X51vWcUqQrIys2SM7RwAelaVHq2c99ToILiVHhEcRkZyEQv1AH tW5d5hXzQ2EQZctwM+9cctbgVzdLflY5FJwuAw4Ap9sFtJCdzAE/c3ZVwK5JuysBslZbxFliRiwG FUfKPoBV7w9JqDWl1ZSzWkcNvOZfKXBlJbjnvWQH/9H+N8rb2GlT3dxcSXDwShooY4y0r5PXjjj3 rauLuPUtN07UIkS3lkj8tCYxHI4QAEsPU5FeDKV9DnMK1WWS6nbzLcpGCSmQskhxyD/Metan2eWU 26KYYpJFPlOH+RCCcBvTn+dSBHZ3E/2dPtCbp3UrIVOVZh12/X+tbc1pfsLe3H2eB3VZUEzEOVPJ +Ue1ZzfRGbg76HTSeFtd0o2WojRja/2qAulm5lCx3u0LubcegO4EZ7MKpa9c28tgIo4DDfRSGO6g R8qhB549sYrG91dCsuVs/9L+SjRr6S5l017fTIJGt5QtyZ5D5eFGeQeCeB+Yr6i+FFrdeLPFvhHT kkmuC3i2ys3hlyGjDSD5RnooAGCOOK+FzKfJhJzfY8Su1DDTk+lz/Rm/Yj0vT9F+GXhUWbzTPFpK WCxmP5IxGF2ybu+V/nX3sSAjcHcRkAdRX8/Zd79Lm83+Z9FlsufCUp90Vll3qF27mDdW4q3HFJuC sRjplehFemd7+JFvYFOCcKO9RSMUkBQkcYyDwa1pK5R//9P+gZLxpVRkjiDkYPl5PP4kn+ntVi5h a4s5oWmAmZPkZhuUE9M+1fyrDdrzNJW9kz8dP+CjXhKLX/hX46iNjZvd6dp322CM3BhtmeFSpEWT hsq2fXK8dK/ic8ZeH90876fcyWN5e/JM1uA8Cqu3yxz7Dk55Ir67gtyVbER6XR4kZqWL5L7f5L/I 4Hxb/a6eVpUGrXD/AGdUlnggPlxXwXkDdxtYnIJHPNSajoV7aqZYbkreavZRyTaeH8y0tGK/IvqS OCc96/Tab2OyexDov2OLUdRjfUNuoWlokE2nswEHUgyDtk1NcXibikMoFwpykK/6w/SuqnuTDRn/ 1P434rYmF7y/jeCSdSZEmHzDt83oTVLUNLsrHTrW9to4ojLcszXZwrzMwHyn2GOvvXh030OKb1sa +neHrB0imv8AWZbK+lG9oo4g8GwgYIbOccg9Kbd6PY2MKD7XO1xbEfZZzy7g8bm5/iGPrmtCNjJ8 m5ieQzM8i7gXB/h9CPSo7pHmmhlj84xwISyxgsAD7fhQB1EN3Zm2jtPs4ed4yYpWVml4Azx0H1qr f2WlJaiW5sYLq7WRZF81z5q9hgdsevUUAf/V/jDktryHTt01lct5c7TytDJuijQkLGXHbPGP97GK eLpls0hnLzByFi3gjbnpn2ry4PoeaoqJorZounX51CC1FppzpHOka/aCWb5hxg/mOldjZSadb6ZF DblRbSNv80HzbjB7HnIx6dq676CcLmHeXFtLaCaxu2+0OXhe0Rf3gXAAYnoM5P5V41rkHmw5WYLN HJhlkOwSDp+JHpXfh5MxqwsjjI45bUmWIrI6ygsjDMbqDyB9a/Yj9iWELpdi/wDaiW1jdb4LZ3kZ EtCqQkcckDdK5PrkjHFf0J4B11R4yUf5oNf+TR/Q/G/Gulz8GSl2lf8ABn//1u+/4Jm67Z6H8XtL 0qae3a7urdNYupyjebceXdrDsHbadyYA6c1/ZdpL/avCVqBsmWaxjlcugRSABkEeuBjmv6K+klT5 OJ6U+lv8j4H6O9VV/DOMFum1+p/JX/wVe0ezsfHN48Ulzp11qF1dfYL+KLfbo6pb43jjGNoUHrhz 1r8h3nOqxQw2dj9mYwImogz+cZHUDzGTA7kZAOcetf1f4LVZVeA8E59rfcz/AD88b6EKHiBmMIL7 V38/6/Awf7LLWGu3+ky291LFMsD6bOzR6lZIrKvmhcbSpY4OCWyegBBrJ02/1povsVvObu7a5ECR KAvlqcYQgnoM/rX6+fjEF79zqbS/Szur2OTz0uFtwsEFqgdJLqM7cM3QfxE/WobW+1jX721j1m3j hu4rJYtQvFhECIY/9ZJKFHXnsOijrQazj1R//9f4D8RPpyTyQW2bsKBHA0MZhkuQOAQO2fU1Bo19 Fos1zaX1nDcPdrH512oF3JarsBVUPQdedvcV/syf4uciRYvtL0hH0+50+5uZ55GeeNYmEKRYOBGV B56dPem2Opb5s3VujwvgBcf6mRSCrAdOCP60m+4Kld2NC9n1LWJba1uVtFYOWWVEEMK5GN3TjjGT VK10FNKv54YZ4HigT7RcTrIzW5cr9wM2MscdB6UEzio6DbzUHmf7PYzIZchpFK4WLrgsfz71pWsO tXP2641CaO7njkVLWG3ZVkkKEHzMY6cbePrT0S8zN7n/0PhS61KW3u/7QmjVbu6tHsVFuPLt4lwP 4BwG9WqpY2cdlayTW6Pcy3khmuomlJUHJAOMnHX9a/2e5uWKZ/ipypysdG+mxxaO949zCHvbxfNt VkKXZGMdcdto6nnNc9qFjFauBFJ9pjuocIGG9UI+9hh35FbUzOUbbkyNf+GLG1vLG6mtxe3ItG05 2LecoXcX29l4OccimtPdyabNtM0lncXMZe2sk2up3jOXOTgc9P1raK95HM1o0WxpmpX0XlWRlvSj EW0Uzb5gCSQPw9O3NJ+6ur3TvDlxq39n36/vbcshjW4k7xoSMN159MH0roj8SOaWiaP/0fjHWrS6 ElnDbHz/ACEZ70xnd9nwQoz7Me49KxLo21mq3RhMlzFEytaSht0+8DBUDuo5GT3r/bg/w2a0saNh ahrVt+YnAEkaEbJY9wzgj8OlZEmqGC5eJPtk7zfu1eDBjhORy3Xg47fnVwaTszA0riysrtDd6nqV 5FIl1FBBp1r+7vIMEHfK/I2deOvXOKTY9lfSTIxlMbfu2+6XHTmm59jNwe5O+oXt1II0ENlC0hAA Zt7fLyTj1PtWQy3ttFcXCLBafZl3SvfYaOVSwB2c8nnOe2DTjJt6mNSnyx5up//S+IbO8i1O3vLy 0u7gxyKv2iwSHbYgqQAyHOR9PerFja+XlShMMkhd3i/1jk44z7YHBr/cOK36H+DVk5abGRd3VmsJ y09q4ujFtnj2l+SM5/Dv2pL+S3itrKSNpWMjtFPniNSMFSD75x9RQpNblSp22HR6hpcTCTUILnUY 0Tyza2snlzIQONpweRjpj8q2rCz0qLTU1W5u7mSSe2MsNkmDdJlsLGy9zgA/1rVO2qMZUjcjtkkh gls7iGWVULPbMcPCdxAyPcDNWdQj0m0tCl/cPGZ1Be4SPe0Tn7mBnoDjP41tzK1zPkd7H//T+JpH eGTylkwynCzRsTG44w3HOCKoOIp0Es0wkYTYeM5yAOhz+B/Kv9zlK+h/gnKm4q7Ldx5V5HHHA6xx kYYxLtkJGB6Y55/Kr9xGQYQxEaLEqFgMsdoxn9K2krRMySK3+yQWd/fpHfwm7kS2tAxHmbVRlaUY yAN44BxwelMlQG4F3siTMOFiiX9xbk5JQAjkc96xU0xSo2IRa26NAzPLvdT56RIBtbJ249c8fnVa w0+eO5nAmnWJybja+QDx3/KqOeaUZcp//9T42mhvY0RvOUwr8yHb0B6jP+R19ap3M/kQSXbu7GCM vsUZYgdl/Cv90ozsj/AGdNrQgjT7QYPnZDcp5rq42NEvBO70PtW6sMEMayW867dpWNWbDuwxkCtV JPY53Bp2MqdGi2tIqI8mSBnJyOvP41RW+iiMFvclnt7m5WNhF8rxEnGM4OM4xnB61SdncVn2JFhS 1vWSa2WaS5Zo7dIwTEwXnaG/vADrSkpIkSSW7LDEW+5nf69e+K1Uk9CWrqx//9X4Z0qZb5JZbg3c EBQ/ZQ8GxnIbHOTwO/fpWraaReNbO1uXuoWkIkZsArzn8hX+8Hkf8+ihYL2G4YGNZZFjjCiWLOAf QEfypioxt3iVwpXACZwcd/0qb+9YUo22M9UghiuBcSOCSPLkDYX3yO34VLGHAKR+YqSDBb+DjnLC mmnsYTWheWERxuZidgXKKvcnoaY5lkEUUe0JgAuwwB6kkUX1sQ1omf/W+HY7e4g3NcglJGJifoMd OPyq2qrZpFPCRK02WEbruVWBx+I6V/vHF2sf885DdNLdlZnIViPmCLtVe3SoYS7xvid32NhR1RfX FagTQQNIzyRguwHzH6dc01nuEdovkKbAQq9VPvQUoN7j47aGBI5H3kks8r5y3sAB9KjuNS02Jool nV2umKRR7CHPueOOtBXJqf/X+H00xltnvi8YVn8sIzYkPA7enP8AOmXl3aWphkjimaMQAXZZwBuB 52H0PuOK/wB6D/npnHldiKBpppYngwkG0koRnPHFWJLh1kImZgNhXy1OF9j+n86esX5isxsUr28s ccgeIyAPEZBtV8jKkfUdKrXslykouFiJV3w5BxkjGfxq4yVrMRHNLeXVxaQWNrFI8soEzyzeSI0H JPPXvWzezTGSRj5CmNxGPIOUkPQlR6H19+1aHPbof//Q+EoYc3MzNJvkjbLKOQvtWhbQRSu09wzA QIzIisQJDjgEflX++B/zzjYPN1d4/Jt1823Q5MaEmHs2T296iHm2bs42LICRIVO4MPf8B+lTJ20A sKJLhWeGZ4o2Ik2bztcjpx+f5mrTSo6J5q5w373+HcBxjPasSpRtuQJYzr5bTMphdsqIwd0f1/z2 rVWZ4LaSC3Ecis2D5kSttIP97GR+FBlNdj//0fi+/kH2YafKS80uJpLfYTEgB4yffpz6U2KVpV2e UkSoAvkoDsXtxX+8kX7zR/zyyVqY68twsYk5MkY/d56jPpWfZaYIkedriW4aKLzZnb5eSQCMdOCw FW3bcmMW1ZkkYWZjIhPyttZehp14LWG8EdvAq3TAI8zZEzqM/IFzjHP6CtYNWsKUGthAkCStLKCZ SnlkMxAH4e1QedLFcqlu6rE64kGDuJ6AfzrQXJI//9L4kmQxurghmI5GeBT28y4iCqCpRtzf3T2r /fA/537W0MqItHdzM+3ZEPlDA5kPHA/z2rSKzPlxIQJkDvFnKxkZ4/z7VMpcqLhG+rHKqxrgfvAQ N27+H/OK0LCGWdbmS3BQW8fzFvlEgOAdp6E8nj2NEWrJEvcvxacLGxSWJFljfK/Kd5Dddp9+azFh ufLE8sEkOSVBZSvQckVRnZ85/9P4ss4WVZpAxb5yQG7f55qSaSZxiQZVRxnoK/3q52nZH/O44cz0 M4hcqd3ynsKnNjOZY3ikRUzlyzYOK0U0yfZyRcnit08rzyyoQHLxnDEZ/wDrH8qrXMKbvOt3fYpO 0Fuo96tS0smLkkUmu4WaCB4ZjcGQ7Zg+YSuOhXHXjOSenar1xLHGAWYAcbQOtLyDkkf/1Pi2KaKc AXJKxOwVm/iAPU05EFoJIx88e7ELMPn2g8V/vgnZ6H/Oy4tblmKVfKlaSOR84UMrYSPrnIqtClt5 iOiHylPK42j3ocu7ElfREzJH5paOTarc+WOv0qrLKFEjNvWMKQwXgsB2zSUk3oDj3RNbRQXG2W3Z YoCmB8zM6EAYHPJpdsRlkBO6VRy/ZvenGetkJxsmz//V+L4lVpBIGYbCRsI4PvV1w8+D5ZYqOo9B /wDqr/fWex/zpU9yOcQxwrKfnOSvlr8pUjpz/npVcSzS20scCAyhd7bhyi5wT+FZJ9UbSjbRlVJW iRYGjEpc4LgYIPrmrMyPEI/MLOrH5eeg9KfM+4kraIktJRazH5sxyLwh6qfWm3l3K+/ZnywQCqjJ Hvj8RWjd4XKirs//1vjIWEhaB2VpVfHMI8wrnpkDmtqDQJr7y2trmAHzAJIpyYWjVT8xIYDB6/pX +9NXE0KEXOtJRiuraSP+d+OFrYmp7OhFyk+iV3+HoaI0S51EtHplvNeNDcG2nlsrZ7tWfjCpsBJP PpWZeaCNLlWS4klQjCSJPGYmic8EOD05HeuZZrlzxH1RVo+1/lur/d+m51yyTNIYP+0ZYeaoXS5n F8t35/1roZk0Usc6yRN8m3BUjcp+lNVvLik2wIbjzlkR5AHX5exUjB5x19K61UTZ56g2NTzbhZZ5 DCrx8uq4QEE9l/LOKqopeQOynygQMgcCnz+Q3CyP/9f47mihj4jbdGOjdAaq2MpZ7gMV2hsRY6kY HX8c1/vappn/ADtRhfU1tFiuDqtrBFBeXz304gjsbGBrmaTf8vKhTxz1xivaG+B/jySzlvrPwh4m nEfyEx6PctbIAcAECLg9ck+teBm3E+UZFOnSzOryuW22i7vW9vv2Z9Vw/wADZ/xVRr4jJ6XNGlvu rt9I6NXWl7tbo8517wfrfhnU2stYsJrKT7KlxtnhkhcFs/LhlH90/lXMoJMyOoXIOEHXdXrYXG4b G0Y4rCTU6cldNbP+tn1T0Z87iMBicBip4LFwcKsHaUXun/XXZrVaGTNG/mlpGCkH5vp6UqpGiHyw dz9x/WupSTdjkcFHQ//Q+MpZYv3MDDdIRk7e2KuCV0MUfkiS3H395wVPrX++B/zrqKelirI0iPy4 EHmbIRu5PTtSM9xFIIuhflXcYCg4IP0oWuw/ZpK7Q4STSh8kMsJ2NIo+Un8fpSec9xHwrAISMMMZ x3oFaxHAGY8csjd+SK17+W5vIreN2XMShEAXB2j19e9YXk7o3UElc//R+XPBfgzWvG3iO18L6JGs mp3sZ+xwEM5mk/gGBzjOcnsATz0r638e/sKfHrwH4Ig8V674Uaztfsf2+WUbzbNGEDSASY4K8EBh k8cCv9vM/wCOsk4czTD5RjpP2tba1tFe2ut/O1vzP8B8n4G4hzvJ6+e4GlfD03ZvXWy6abdL33v2 Z8NRkq1xEmVkgdopox96NlJBUj8KrWWoLHHdRYV0JZHdgd0Tdz+HvX2EG72Pk5RSWhXjRkBKhpu5 JHJqK6NzcParZSRJH5m65hcHIHoPfHrWhDTW5oS2yqqhXLkYJXHQ96gEjITsDIRwVJ6+9Aj/0vi+ 0+yXTzDU2uGhWAmNbWQRSCQfdBJB4yOaZBIFZgx+RFwoxX++B/zrlO6lB2umBk8YqK2DqzumCznL DHXFAJX0RdkdGXdtZG6SL249KyzNL56LCWJQ43dNo9aCpKzsXD5kbNFt56lyeKp3AZ5IE3ANJJt7 8c0GsVZH/9P4ilUxqqCUhUOCVb5WqHbHIML8zGv98D/nfIJJPLPlAgMoye2M1ALllQiRi+G+QAYV RQBft518ol23SFgEB6Y780ksbRxvHFMrs8m9kJ3lQecA/iR+FBlO97DYYJpZY1j6A4fj+lTiQQvK k6tgJ+5C8Fm44Pp3oCKumkf/1Pie3b7TbT+d5iy78RBeFjX/ABpsTPHNDJJ+8MOGznGQMcfpX++U U7o/51ylD5m25dInkDTNKBIcsTknv256UNJKxDbCjOcEKAFTr/nik92a01oWhBIqqYdrODmUHuO+ KSZfu/JgAfMauD0sWZmo3Trpuow23+u+xOpQRg+cmMyLntlQcfSvxA/aZtZl8RXiwRQXE8aSSWzs 2IWBdQSCMnjH6ivxD6QT/wCNe4lev5M/qf6KS/4zxei/M//V/i5sLaRUTy9sc2//AFm7b19+1Uri BomnE00TuCQRGwcce4/pX39U8WCtFI5sbndhAhVg+3jv71oRyTFPImbZhvmx94isCh6W1sziTYxe NtyB+gx3NUdQg891lZgTuwUUYIHaucpRbCxuG0+5VbVihbmWQjrjnBrYvb37dBtnkU7SWQ9ue+az n0HNWeh//9b+IYQm7njjLfKnACjge5/KtBbURTIkbsURSWSPq2BX1B5MFdlJJX+0eaDJHkbVRuCv sa6C3v4kkUKsM8rjy2ViMrz+mKDYu28KXupeRLdJb20keWwuY0xzx78dKw7zT4I7t4IJnkUOSk8g CZX6dqmSurASCNLaNlj/AHjvwAw4HvVBUlgnCAbHkAZyemPasbdAP//X/iNnkYyEOfMZDtAU4Xj1 qvdQIg3OcxygZ8vnb9a+h12PPLkbrHE8ShTEFCxv1bPqK63wwNNXVLW61BZJ0gTe1tGdn2vH8Oe2 SOo5ApGc0bXic2F3ey6ha2S6UkoBhsBIZ448DkBzzXFXWoSRxbWXPB2KE4B9TQKUbO6OfWQmVycl 2XqeldJpMiWq77kmd2/1MbcRx+/40Ch8SP/Q/iY1C4kafc7uAJN0cafdj9MVJYrKtw08o371zHJ/ Ep+lfQHnliR2urht0jABdoAbhyPQVDHBGQUSTYqnMhPBzQYpNiyXlvbqCVD/ADBNwGSc8Zp9oGuJ JJQgRBwpP8R9QKBt2ihiosUxW4diD1bOWxUZmiViw3FFf5Ny/N17/pQXF3R//9H+Jea5aZSqoVVR u2gcuaRL6RkFvLKwRf8AVoThM4x09eK99pPRnnkxuIXURzKMKm0BQMHHrRCV8o8SLEp+baMk1Eo2 1QFONZpNqxzFo95IDnhaZcW6JJglckZ2jguazAtWsws3E+zMpQxqoGDitGS6Sez3SbtznYyn7tAH /9L+JB5VMu502pHD5cTKT94DHNSQQxyZ2H5xyyseSa9g886S20adbR7qe0mSA58uUpiKYjkhT7ZH 51z0nmh8HIRTnJHFJuyuBNaTTyBNkmB5ojkXHLL3zUUsl19oktot0UbSfvHUZLKDwPSo5ny+YEax PcXLDBgih6eb8nmkdSv+e1MnLh8idnXOEQHhSPanzqwH/9P+IuZppn+Ylnddo2Lye3NT24jtt2Yy 7PHseLO4n8K9dST2PPJ0IJ2RqyvnccjO0elNMU+5zOcxsvCjgj3NF1sBCLdE/fIxA6KM4p0M2WBk 3EjqjHj8KG7AT30LTiFw4RWcEtGc7B6kVk3MaQiaMnzmU/fRMfjisXuB/9T+IKJWjTMmWXZj5uq/ Sr+muzuqw8KGJwxx9a9A88mvrMPcLtClpj0XtjqaFjaKBoI8vIDjDHO36UeQELeZteJHZJhhZEJ4 NXYbaG12clpNm589eexotfYCrqVvcAQCJ0KN8xHG4g+tQzabJHaNMhVgq5MbtsLn2raKa3A//9X+ HBXkecSeWY1hXCqpyQavMjFRKY2Rc5bPVvevRas7HnlaYElI0Dvg78kdB6fT/Clk8ouFUswAzIOg pAacj4t8IdyjG3npSvaSSpFJFs3AZVmOzHHIoAy5pUi2QuW3hy3HStGxt2yJojsEp/eKSSCAcf0/ WixMm0tD/9b+KiWxAs2mWZfNZiAAu4J6VzJ0+RF3q5BB+YY+97160L2PNjLm0JDcxQxSG4A3FAoE a4dvaore5t/IjRoQrkkF88nPTNUU1pYsf6OFUOxTHORyae0KXa/u3PlbevfNBk4WRDt+y74gigkb XG0Z49ferVjYSyl52JhVFyoH8R9/ak3ZXLgrI//X/iAug53rIysS20sOVX6Gkti9mxAfezY4HJxX qRk9meXMt3TyXoiheUuiNkDdkLWdJbNbTeYx+VXwh65H0pSk7kw+JCMRIS8QUY6KPlDGk3SzIXVd rJ8pJ4J9a0WqKk7STLcN2yo0R3DIww6fSqs6O2WBzJjHljtVJuOxMpX0P//Q/h3t1u43YT7/AC1A fbnn6Yp9xP5k0ZeU+WOPLzjgelezd3ueOTKqSAlo/MQMDGjHaPrSzP5fmeSWjESANHk9DQ23uAiv M8Q3PlJVI9NlOJhgEYEu5xyRjikFr7Fee8WeUKQyoEx5a5C57tj3q4kga3MLZVBzv70BY//R/h5i huIgtxHKCnO1W5JA65FaEd1KbSQDEpdgG7EY9K9g8cy4hKsmS3JO7J5IqvcySQy7yMhjknbjBoAS C6nLsQ0hBGSSTtH4VqhJjGrErtYZOTwaTVxxdmLck24inX53yDuU/cI6GnWxW4l82Zwk0nzqQflc +relZxWpXM0z/9L+IyAJPLIuVaZOeDxj1FS3cypG+IFUKPvNwGxxivTjHmR56d9jnbWYCZTINg8w kgcgA98VoxeVcPK5UKQcZUYD+hAqWrOwErLGjCSJpIhEPvP0U+tX4twiN5uEr9eVyjj0I96RnN9D EI82V8wCNpDjYo2rkntSPBJbhcYBwd4JwAKCI6M//9P+Hq3hmlUK0ywxlsANjcfpUz2AEg2usqKc bSea9A88s7EaFo1je3WL5RsbCyZ/z0qK3v7yF1hnZGhjBVEc/ImepAzwTSaT3AjkYyxT+U4VmIyg 68Ulp5TDyVjAmxlx0MuBzzSimlZh5FVbaAy5VXBY42defSn3EaxC3RzumMmHXG1QM8Z+lZyvcD// 1P4ho41iWRQB85yCjcCoXkdJgkk3yEAYLZHFdB5snZC3kYldWXcyRx4ZgMgj/OazbSCN2aKMlygL EscuP8/0osYkr71yCgyr4Uj7xIPer8eHuLKedVMkA+QE5xnrx70DSbdkSXBh864uYlKiIYWLuxJ7 moElhm2GZPMSNt8kSDbI+f4c/hVRsnqaKC6n/9X+Hry/s8Ukg3wrNkeSehGeAar28kk1vIgJUA9V GOK6XuecklsPs5Jz+7ySsfzHPy8Cr32syYDFlkVsKRzx60hktrILW/s7x4nu5La6E7RhiqS+oYd6 s3Eaz3L3YgEdxM+SkaCKJh349BzQBi6mqTTfuMRyKNqx4ODjvmoC9zB5LM5UgbSB+XWs3PsZuHY/ /9b+ICzglukkgjMAUkTtLMcMoHUZ/p7VPMjWpjiR1ljPzDZ9w07u1jyeSQ24k/0dZI4VV3l2Ku7d n3oErxO8csYKFAUZV/DFI1SsrCyRl0AWPCIPmyNuyoo7aeJjPASVQ/L/ABEe+KCkmy4t5cEFbiaS XyyWiRj8qk9cenb8qxpZ3a6dFUSLwWjyMc9zQaw+FH//1/4b2iiiuPMZmHAO1Vzt7HFbdyjmKOJp CiMu6NsbW6cf0oOcimUixS5nEl3ct/okKxx/Kdo4Len1qCITLHFBOh8tzxt+byifUflQBZa08qb5 rhMRIrKf4jkjjFXL2eK1SOFJ0nmni3IkbYxxzz7d6aWjAjsXMtskxYFkYn942CoXt79KkfUJNRt5 beCOGyktQdzjkzggZOT9OnanazSLgnzH/9D+H7T4YhKTOFV88GRfkNX7m3adZIYWfft3l/uopz2P TsK6CZr3SG3BjBaZgrx/JjPI9zV+TUbQWsMJAaQM5aZflMgOMAj2wfzpNpaMzjFszohhXkSRUt3b bkHJyPaiJJYlmu1VJUXIRJDjzD9Ov/66yk7s2M+3NxciRpgtvErFxBFkop64APPNOjkjjZSrYR24 UDnNK+wm0tz/0f4gGnkjb9xLJIzD/j3RjlyORj/PFJYS3JtZp7t1Mk05RIHJFxEBzyMdPegUXdE1 3G5gZMAi4wjNnBTHINUhY+SiLBM0kh+9gY3f/qot0GS2skltNLaXiMXiO8b4dq89Bn1q1PcLL/o8 UbAM22VmXDR/SsnBpC62K088lpmGHLJtBXcd3Uda6HSXmktGbzE2wp5rhuNvOMD86TVophbW5//S /iYMlybmUbsmYcllGOvrVlk2Ssju0UixhtyNw30Nc5cVoz0n4N6ddp4vkkvXWZAbeWFpJP3oBMmM L152/oK/YLwBoM17p+h6cVgggluLeC5n37Ww9whJyOp54z6AV/U/gLTthcXVXn+R/JnjrVvxHg6D 7L82f3F/8E7tHhsPhT4cv4pPKS30hrWKN0KNc7j8r88ldpUfhXg//BVS7H/Cv78JrT2kmkqsk9tO 6ql15qP5nlZ7oACc9j1r8v4eU6nivKbV2qz/APSn+R/QHFTjQ8KoK9l7Bf8ApKP44PiBeTWOj6ja T3sk2n2mpzJJfJGJVlLs5DBQcEMFBHavws+J9xqGoeKNVnuLa4hkhu5Y1aRy6MgbK7T7rg9O9f0j 4/VPZ8LQh3cT+aPo9Uk80r1V5n//0/4RoZE53MwEoCs390132nW1z/ZzRSSfKp3RmNstt9c0VHuY JamoHtbZNzSbJzGGXJyD24rRkiR4cGXzRIochh8r8dK45trQRFEJYjvVYQ0se1wcFUHf6dOophS5 DAG3y4UOpXlWz0rlk7sDorkT2aRQqA8k8asjE4RCcZAqlYtLDd3Mf2dC7w7JGYeuDlT3PHbpzXPK V3oLW/kf/9T+MjVIfN05IBJcWithZBE20yD246dKuyGysrbT5oJ7m9aMrBHZsRGjKMbvmzn1r585 y7Y2lq0t1fPbG2+0jeqohZjg4VWPXgd/aksLTEt7K1w/2aTiKI5JTGen+e1RZ84ESeaxeKz1F7Wz WUNcmaMOrbQchCc4OeOK3ZZ5bWYy6ndw6lf/AGaJrIW8quwixgFwCSOBj8Kze7A1PtUmp2MUUt/q DfMY4oJXZ1s2OCSuTwOBwOOKkNnZ21pcF7x5bjeIQfLIVvUg+nSogrJomXws/9X+TnRtI12ztNI1 Ew2P/CPT3bGW6NyhuyR28oZYDjq2Otfd/wCybo1rqfx9+H+nWl3dJDr+qxQXOnGFJYMW7rKJTKRm PDBASM8Ma/N+Iqjp5TiJR6Rl+R4eNjzYOcF1T/I/0T/2WtCudA+G/h6zkto7OFbQPC0Th/3XROfw P4EV9aIVjBbIcquV9zX4dl6cKEbn0uVw5MBSg+iX5GX5qszu+F+bJAwO9aCSr5eUfJx8vPNeid9h o8znc5JJ784qR8kqidRxuPQVvSQH/9b9+I4zBcsqxuUKZz0wfSrbllQpuOduSMc8iv5UpPr5hJ2p yR+cH7cWirrfwy8TaHdtb21s+j3N8b/UP3HktDh4Qrgj/WMWHHX+f8NHjKXzS6TIkK23+iSPbSfu lNvI0ZCHHOdgP/Aq+r4La+sVU97nzmGqSebVKb/lT/M8wvQt6jBVdRt+WQDDfXNYGks9lJJDPPNd y/aDLF5+ZFAJyVL+3GK/UaVlFHrct7sl/sp5bm4niiVLmRCY/k2hyOmW9BVDUY5T9k8y0iE9t9+W PKOXByGY559O3SumLsyoxVkz/9f+Nm+1eS50yaG4tAX8vyZXyZPOB4JPocHH4Vnxy2uqQW0QkAsL UeT9hLB1idQMkL7kD8q8GL5Wcc0lqjYghu7OyudQvoN9ndo2n2MJwyqy8sfXkEH/ACaybC3njnii UyIpIZRM+5QByAMn8q1UkzM2p9VSSGR+ivugaMkPPKVOGyPQkZBqlpt9qGlIzqUvNzboVuogsKKe inA5Hem2luAxptRltYdSiljtNS+3OgtbQ4jji7vvI44PAqvcX8f9opNE/wC/WBY5lkAIkwc5x9c1 DmugH//Q/jkaCPUoLmN3l825jEbBXIX5SCBj0+ntSokLL5MsTLg+QGdNm4jjivIg9UzzzQjjEdsb d/8ASPNlUyLnapC9CfXAqvqRaygedtO/dSHybTyVKwucAspbsfYH0rpUnswLenyQWMN41tYWam+t htVk82SB8csGJ5OPWvG/FNrFL5zWzK5jAcqflIbOM130JWdiK0HyXOFltZllWyMkfngLKGDgxMSA QC38xX6ofsSz2aTWlnq6GRDdNPLY+aZLRQuDkEcgAjJ9gK/bfBSv7PjfCru7H5L4uU+fgrFN/ZVz /9HO/YDvdWh+Mvg9tJs9NufNuDnUZHRiBuLfZ42znOYlbbjBPTmv7Z/hvJNqfg3TXMyMl/BmMoMe ScbSD+PHNf0t9Jakv7epSW9kfmX0aJTl4dzUtud2/U/m8/4KpeHra68WTajq91aWun2N0NPura7g DLNI6vGrqegwUBPv9K/C8aZpcd3fX+m3HlpaaccpAhe2nLYCYQdCc9R+Rr+ivADFOvwZSh0jZfer n8XfSIwCwnHFeafvT1fom0vyZ57eyLp15tihaOR18yPKGJHJ5xnHPXn61etraJobLXRKi3MlxI1w vAKSDnB9cg7q/eD+eF8ZFdNDpq2V+ph+yarcsLlEP78bQASh6Ang89f1p2m3m60mMLT/AGm6uHhu LuY7SEIG0Adxzyec8UGp/9L4Es4bvTZY2tzFeXBl8u5vLu3WVQmCCFXkdDjNSWy2k17JYpbRWkc0 DSy3lw2Ld3UEn5scHA4Hrj1r/Zg/xhiruxXsNOF8Ibb+0LVY7p2NjeQLgQgZ3BzzyNpzVvS1jsri 801VhvnmYJLOHJeDB424OPmHXIrGc0jpjSfQv6w93pdxYC1gtr1JVAdVLB4sno3A5+hq2JTLFPb3 tuv2ppA6eS2IcY4JHrggVKq2RFSi5OxpaP4dN2k8sVuuGlUKZI8KpUc4b055+ntWuujF3mW1iS2n jzBKwU5dlGCGPWqVZbGEqEo7o//T+G7nw1q0es2Vq0LTO18hvJJI2jsI4eCxVsc4Gc49a373SINA ku55LmylgV8wpZLJhgcluoycEH/69f7JzrL2Z/jDCg+fY5PXb+HWbsW+jqLTymS4s4Z/3sk205Zc E8Fv6Vt2kWdBa7vZLa3mW5ZEtQ4M0WMHOPTntXVTnoZSpO0rnOqbuw1JbuV7i4DxuGZj5y8qygqp 4XGc8ehqPwsuqvZJCbyZZ5b+WME4hViG2jGOMYI/zxXTGS3OCVN3N+2kGnTS2g1HzLyAttcH5M5+ 7x3rTYhHgle3hu3ukG95rRHNs46PE5+ZCPVSPfNdMZdUck4NXuf/1Ph+S/ns9QjhG75xtuJpU++p 6KPcEDn2qC/025vLy4ubd1jjZQUy5YRYGMj36HH/AOuv9s+dn+HTg+hdsbr+zjLDLtvpnhCpeTqW ORgH5TwfSq90Bbwz20FtEp1GEGa4RsSwYbI2jPB4/WtE00RyX92xFLbx39vBY2LG3uxEy3TmMpJc yH7rhjxwuB/wGumsdIMVlbR30nnXUKAXBU/MwA+8fy5pSfKhqknLlM64mS9uIrfTUSfyt1uxQDcg ycjPfnNX7fRJbiAfabf7RCkmwxNndGCeTjpjr+VRGryvcdXDc0Ekf//V+UrLwo6XLQ2NvPHbSxrG i+WTFI3ce9U/7PvdLvvLiin2rJjdICowRzj6ZP5V/tyqyZ/hY8FURTu9PguDOpMd3LM/76KePBtc Ec57/h6VBc2cdssNq0FvNGjLNETHv2spBGAfQjvVwnzRuyMRRcJKK7Ir3E6CWS/i0slo5iJ3e18q 2lYqAAvAUd+fWqU0cl3EIwz28nkqzGLjye52+1aqXKYezdhDIlnKbmIoxubcWjzRP5krDIY8due4 /OtCS1/tDSlvfNknSN/L2Sj7oQ7e/oRWjmkrmcaT57H/1viaGKWLyp2lAkFyuRLH5i+V0YD3AGB9 RW4NBhulEmn+VN50uJIY/kmRjj+E46+1f7iwqpK5/hDWoOXupG6nhhrOIA2NzdXMkGVjijKpb8j5 icfhWFd6bdo4kuopF35ijjADBSP7x7Vs60baMw+qTjbmRWWG7srW5litre6P2lVkVj+/+ZACYweu FUcjgbQMg9b9vMI4mjaNY2kj6yoGyD6ZHH1rljV1sdPsHyN2Jvs8IaCSX/WTRsqIvAkI9O3pVGC5 uzJOsVu7Y/dQwLHheMYH0/wrsjNNHkVKUlK7R//X+OtSE4KMhkEARROuP3EbHsD2IORTLawMUkyX UpaJ2VovlyqKQOvGc5zxX+4yqdEf4Jujq/IfdW8H2iSQkbVRUUKoAbAAJwOnSs+YWT3caWMN0rW8 XmTPcTCYHsWQBRgdu/Uc5rvgtLnkz+MtPNZFWa4djK0W+H5DtHTIPp2qgfsxhd1jDHG5COxz1qVJ p2ZqoNq6EjuzD5cwQh1GVDAMUOOoo0+4u7lpbUAWsAkDfby484D+JVBB7Z7VqZNXVkf/0PjWRoJp fssN0ZorUeUJXj8sydTux059qdBfS6fdRna0ltnAyQEBxzgdD24r/dlSs7n/AD9cjTsxqXMjTTyt sdpFKuH6EH2/KohHdysESMmbYQhUcsoyMmnGactSq9Kwy10S7mnt96CS3lLEyffVtpIIGD1yOhrr ZtFQ6VdG2ikne3wzSRqQYACMgjp0zVRcU2cjg1oc9pwgcSTzATW8HyyRhtpBPHPtWXcSxqWW3R1t pGPlvjDKc9B+dTzpSbRLpvRWP//R+JLhttunmykMCEjWQ469v1qaxtw8gS46H7mDgA/Wv931JN6H /Pi6NpWK9xLqFtcSWnk2zRSkeXKSd0YHLc9OfeiKRHjkVVIB+QN0XcOtaqoupKo6kSD7P5CSTugm lEW1BxIxycfoT+FWfJiF31AnYbI3PBZev9KfOjRU+5FcCTnzlkhAc+Vlcebt6keopitYCMS3TLBO 2EtolGXlbPO78PT2qZT0NIU+x//S+G5UkdTsDlQMyED5UA7n0rodO8F6nfWKC6gKSPdGVGlykphO DH8nPBGcV/u9LFUqEHKvJJLdt2P+fxZficXXVLCwcptaJJt6LXRfebGreDrzRbTedwRkC5I8uSEk cZU4OD2PSuOaxkSDe4imUnyzu++mOhA/SnHE0q3LOjJNNbrYwqYSthpypVlaSdmno18icCIKjyDf 5Yzg84x6fl+lRXEtpdTFIQ0K48zyyd7IPQ/jXStVc45K0mRXylVR4wvmRLsQAbSRn/PNJaXiW1wk 1xC0mRtjGMxxn+8fpVKTRmopH//T+InuEQy/ukwzbi235j2GT+NSaVp93ctNcMf3EAaRoVI3OO2M +g9K/wB7VNdT/nnJYrmCATGMvDMwxmMc+4OPX+lSRW6JIZXTz/MXeI2fuR0P+FZtt7lKLbFmhljk toJsK13kDyjkR45P5cVdutOlijihXKy7AYUdT+9B6HPfPrWDk9TedJ2NLQtI1rX9Zs9C0rS7/VdS uVAgtbC0a4bqBliBhR3Javocfs9fEOw06WLUPBt/BFG5nuJPssw3M3A2t5Zz/IfnXyWe8cZBw5iI 4PM61qstorez6vVJfffyPpsm4Jz/AD7DTxuX0G6Ub3k07adFZO/5eZ//1PlTxDoFxpl9NBdW72t7 BcfZrxJo/LcFQAA3uBgV2Hw/+GWv+NNTeHQNLv8AUZrbZvjtbY3UbmUfIMKGOeQen5V/uPic+wGB y6ecV5r2EUpXXVNK1vW+h/gLhMhzDMcwpZRhKbdeTaSt1V7/AHWbZ654h/ZU+L+l+HtT1C68BeJY zpo8xrufSZorQhjw2/bwvIXJHWvl6fSrixmuLC5DLLDIIrhAChDbVYqQQDkZHBrzeHeNcl4sjUWV VLuDV07X9dG9Py+aPU4k4KzrhCvSp5vC3Orpq9r9tUtfzXzJLq9tTY21pHbQxXdrLIz3EcYWW4D+ XgSHqdmxtvP8Z4rnJL5Jp5jLH5kg/wCWnRoz1r6+m7o+UqpKSHRiEgNvEhxuZADuj5OM/wD1q0Iv shglMckRkLhZIDu8xOMhumMc+ueelW3bUSgmf//V+HH81pVSMMzswVFUZLHPHFKkzrGw3MmzqD91 q/3tjLRJn/PQ4XuiG3uILtpPLQ7o38slkwCRjOOK0l2xRtMyvJGgIkEQ3OPwrObvqXGNrI+kv2f/ ANlv4j/tI6lHp/w30y+1Vm2tFNDYyTxsQ7rNG23kMmzkMvfPav1Atv8AgjX+0SbC2t4tEtreGaxV pXkyl3BLwWwpyO2BkA+1fz14geOeV8GZw8mi4upD4uZvttbTZ3T1d+6P6Q8Pfo9ZxxrkMM+qKShU XuqK2V9Hf3r30aVlZdH017b/AII3/tLTRWfmwadZpAwUxCGAlyvCuw2dT3P614D8cv8Agl7+0F8K NB/t7WNP1G6s4Jbia4kt7eCSwlQIXVTIq5QqQOR13YxXzuRfSUyvNMyo4CsoKE5cul09e15NfLrt dHr8UfRizjI8mrZnR53KEeazs1Zd7RTXr07M/9b5XuYVuLaIxxCAQfuJo1hMZjlGPMUkqGODxk/h WHdW4RfLmf5Au4mPqOM4r/d2lVjVgqkHdPVM/wCeacZU6zpzVmtGjM8lG8rG3GflI6ke9XpomKb1 Vgu7aSn3QR2reMm3ZkytZ9yoY2kYxlX3qo2Aj759KklhvI1aCSLy3kT5FK/MwPcDHfHb0rW+xEdE ytZaZfKru5Rlxg4TJT3zSahYCRIQZf3kUiy7k4BIOcY9OtObV7kpdD//1/jKCeJGcuqtkEEyIGP/ ANY+9WAkM80G5mWLcMleuPSv96YNcx/zvzjaF2T6kYTLPb2ULLC+0RBZQyq3AJY9x97jjGevHMT2 yW6wo2AgGHKc80Sd2Yw+JEcUUUjNtOdvAYdSKUR7WmjmhZAmCokGNwIyD+tC02NWr7jMfZzHKqZj MgGwEDjIrs/DfgyLxVfSW/h4ahf3MjSTXUVvYXF20Rj8rfEuxGUPiZTtYjIyRwDXn18fQwFOpi8V LlpwTbfl/X3vQ9DL8sxWb4qGX4GDlVqNKKtu3+nfsj//0Obn/ZR+NlvbPr8PgHVNP0S2tRNO+pad cpPICCMhTGVBI6+mDXz5f6RfaVfi0kRhdTiVHtIUeU2jQsI5FdtoGd24Y6/KfSv9weH+Nsi4nq1K GU1bzhq07bXtdWb66fM/wJ4l4E4g4Q9m85pcqns1e1+2qX9IwLqxlWbZMzK0bbto4Gfes64iLT/I 2U2fNgbdhz0HtX1NKSbsfKVYqKRUJuIUG9i8anCj0z7dqs6cbq6u4Yn2PE0oyZM7Y17nj862Mre7 ckWRZbi7ZYysUFwyW5YYLoDwcf56Ukd3bs6mU+VEufObHCqOpP0Gfyq5tRpNmuHjzVVE/9H1L9hf 9jbxZ+0P4givZtFubfwjFJHd2t+YC8t/G+0rhSPlwQp3Y6NweuP6bfB3/BNb9mbwxolk3iXRba9v FsUhuXv44oQ77RuLHAzz2r/Qbx+8WMdh+IY5Hkc9Kd7279Xv1ez2su5/nt9HTwKy3GcOR4kzuLUq qvZ6ei1WyW635nvY6DTf2KP2QfDqzWelaH4ajV32yp9uiAG4kkKo4HX9a5X4j/sBfs1eJvCt9puj fDXQpZpRktFCpNx6FWAPzAgEHnBAr8Hj4k8UYTHUcdWnJWafXo+nn21P6Kx3gxwnjMixGVUYKScZ JbbtNWfl3XY/lf8A2u/2RfGX7PniTxBqM+lTaT4X/tTydOUWzPbqZWZlUMxzyCvTjHPtXxT9nupo 2byhHHEoDSKc+YepPtX+kfh9xPT4t4aw+bQ3cUpecktX89/nbzP8k+O+FMRwdxTjMhrq3JKVl5N6 f18yqBa3MRaESBoGKO5HySkdx9OlRxxys7I8+yDHEW3H/wCuvt7rY+Ktbc//0vieQS5WJXJRT16E 1tW9vYx2mdjC9dsKx+VQPX/P51/vPe0rH/PCl7tz9hP+CX3gn4XWviJvFHxDj0nUdRe9jFnZ3oF3 C/llgD5Z4+U7sdjg9ea/rD8KeAvhFrWiWzaZ4Q8OXVkyAEto0KBgVBwRt5HNf53fSZz7PMJxdN0K koU1ZKza+Gy/G2x/rF9FTg/IpeGdLEVqcalSqnKV0rrm1t8r2Pxa/wCCtXwq8CeHPBk9/onhvStG Z7chn0/TorNHY5QLlR1O7j+pr+Wm1jBsbe8nljiEgxHEikgqo6g/l19a/ob6Nmb43N+B5YjGzcpJ pXflc/iv6SuRZfkXifWweAhyxa5mvN2Mq6hjllSdZllgIzhRjdnp1qytr5MRuCGZcYK7cBB6/wCf Wv6MptaH84Tp3k7n/9P4y8kSyRyw/vIy2PMGNmfc/hV9IJzNsdDtB5x0Nf72yem5/wA7sabTuUbg KLsbYtqIx8uOQ7wfx4qzb21xNG0ctyZ5VP8Ao5kwq26Ak7OeMdamEraM1dJuJHDDceW6NaylGkws ir8uR/jxTTFfwR+cLaZUMvkEPGQDzjOCK0uloQqDtsTtHdW8eJ4vJmzuVc8up6GrNnBLey71lXKY BZxtSPsM49z+tcvMk3c6adCUlY//1P2s/wCCT/7A/hA2UHxp8ZSSapr195d5bSCNIo7XCrtjRSCS uBjnmv0q/wCChWmGD4CeLbaCKJbVNMMwdlSN4lgTO0AcEsFI+rV/W/H3GuJ4i8aaU+ZqnSqxjFX8 0vwVlsfyfwZ4cYLhTwDrYOUU6lTDylJ23dnK/Xd3e7P4dNaUxa5qYvbq0tNQt7yTzoyhiecHBVio BGSMc9Otc9IBLuCqBJI+4v8AdQ+9f6X4ecZxjKGqaVj/ACWr0pUZyhNWabX3FKZWXELt94kEqcYp 8dvHDIksYJMa7WcnP+e1dRg0noy4zp95GIL8cdSaz5JbvAhZvNSHlSYxvQE85bGTzmgxkuVn/9X4 Ut5x9obLbS3y4HC/Wrm5hIyKAykHcewr/fA/52Eruwn2SWbhQDtOVHpUMchjneMHayY3NjAB+tBs kkWrgwYjY3Ku8v3kRSPL9myP5ZqpkW1wzPInkIMuw5OPUHNA7J7kscq30JnhmRoiSqEHnFV2Dpgk g7WwT6fSgD//1vg6YS3LNCGMeVLB2JCtgdvft+NOt0mtgihiQvdzuY/nX++B/wA75YlaO4kCuD0w xU7T7UiRW4ngt59whlmAldAC8a9zQBFf2BiE0MUgmj8/MMyAoSinjI9TUMKNEpuMtKw+XaD6/p2N AnG+5cW8mjI8iVoWJB49R0OPbmh1lm8sSyG6mBy8irs3H2ppa2Gf/9f4ftbiTzZoSqxKg4R/v9et Vy8gb5Mu8h8tQMlfrX+/B/zuSSsO3y2wkhZSZRJtYq42rgkH6/8A1qldlwUiZ3UHlmTaW49KynuO KshJpo7ZY0aYCZ/4fTtio55MtB5UyC5B3PA43FkGOQPr/KnAoS5MUNhql5cloIk0qcMUADSuYyEV c+rFenavwq/aL1FoPEsYVfKudRlmt1JHmeSq/MMr/tYP5ivw76QT/wCMAxCXn+R/Vv0T4/8AGd/J fmf/0P4q57qUW/lxMI3J/e/3sDrisSadmYW8ahkcfeXIYHrX3lRvmaPIivcCFJoIT8480E4+XkD3 qKPzJ8hmAkU7iw4/GsxG0d+1EyHwuCdoWslreVzM0EgEijd+8bIY5xx/ntXOdFrEWyZEywBY/eBG A2OoqIRNMIwRsEbZZM570NX0ZlPc/9H+JOAQoWd8RyKdgCZy3pkUivItyoUn1Jxyo+tfWSirXR5d NGpdLbNbpKrBnDbWj247da5NXgS63HeYw3zbOpHtmszQ1TfRYCQnKq3JbhsU2G5BdvP3vCTtEjc4 PYUAXracs7F0DxqMJjhh6VWSeZl3SW/71Jin3uq9iPwosB//0v4kbNImuQnklEkBysmQc1I9mYP3 YAcFsBX/AIhX0co21OBprRjpo4EYIPkHG7jj8Klt7j7NPHIA7RA5Yg4k47LUEyV1YsyarNqrmLdJ EiAuscrZXjjg+pFU7VBdbhluM7SRmgUldWGi38seXJD8p+6+c4HfNRSI8jozMyqhCoF6HtQRGLUj /9P+Jc7mkW3ZjIrLvJPVSOetWIfOe9SCEkRqnzEjAz0Az+Vey9zzyvdQ3CyLKoBEL5IA6GrMMcc6 tkbZCdxIH3j0xWsfhMEn0GtaK+YkC+Z94oTycGptTLW0arYxsmy3UHfltz4+Yj8aobukkzJkSaSM NN8sjKOehP4VES4ZFjyAOrMMnigdPc//1P4l7W1nd/NlbCj7qoMAfWqmoxPkMkcYWI4DJ/F9RX0B 55nQy+YxhZdpZuWz8prqLe3nObdGBjEeSQQcfT86xk7syc29iT7NZq20M0bR4GxuAx7kf571Vkss SGWRNxUExN2/OpLjK5TRGkKSEnJPypjpirAKufLK5ZMkDoPSgo//1f4m3Ty7Y71RH8zKIRnPv9aL BEhmDSgyEndycA59a9g886zVvEetahY2tlLcKtnCixRxRQpFHGqDaoG0D8zyec1y0hysatNuiaTG V6duPY1KhFLlXm/vLgk9y7JEEVWtlVVHDk8fjmqbui7T5hDg55GM1LhpoaWRPc3MflqZEBwv7tQe c1n2tvLdKSU8oM2AQDhazDlXY//W/isuo7axhTymDTbAHJ5DN61zvmlSZwgaeM7GQnGQe9enTWpw NWdi3p1zFveW9mZBGMhUTJlPpitXUL2xuFjjsY5SsMQN1NKNu9yc4HoAMCpvbYRhvOsaA43lmClM 8qPUCmPayiZndS8bLkANjb9KG29wGZKxuYy6qDyBwTWjZxW88EhcNuwAGb71ID//1/4oLuCKG1Tz VcpcNsjkVCeRWVBC0GUKMwz99e+a9A88s/amt2wVw5G2JmPLY6ioReNI7Sqnl9ipOSTTtpcCm19I jNMATOBiMgcJzU8dzNKxmdixVMnjArSnsBdfVFMcOYUDRLt3DrJzVe7nPO8iUygMgVuEHWrA/9D+ H2QLEImUgbz+8Uj7vP8A+uugtDFdQ3UXBIh2qQMg8Hv69K9d26nnnOqbiyuREQ3IKfP1VT2pJreK NTiVhGxHmAclT7Gpik9QIDMCxWMHy0GAWGCau211HGxErFiy/KM4VamUbaoDDvZmnuDKMGNPlAQY JxXSabKfL5jbKrld/wAuc1UI6XE1of/R/iTS6MJaESZZ2MjoegPoKqz6mFjVcI2XwQvB+leweVBa mRcnz9ot0A7kdeauWMSPDiVcTRNyDwD6fyoNRWtVeGQyuFfOF2n7opsSXESAQHKgYJ9PegLdCMxT rcPJLNJI0hBYOd2fetK91Oa3VbOzYiOQBZZc5bHdaLdAP//S/h9jtriUHGfK3bju6ZqzFNbwFl8v M6OMSfeBA616qhZ3PKm9bFe4nSKPzoIP3m87cn5V9TiqqXTyqNylmLcuTn9KHC+wo6SQ97lFxC1u Gbomz5evqaXMkakTBlUHcpXtVJWVhz3L9tp76jIJra5gS3hI80ucH047nHtmlnhaN/MleJ9nGYh0 UcAk9zTIP//T/iHjVr25EcDBFYZkkkIAAFVNe0m40+eJPMhkDxLPE8b5yrfy6H8q9g8cheU20SIX L5XdxwAahtjcXTTSJkDAD553/wCcUFSSSVjRR1IaF4zGR911GAKz7yJ4XG070HIJ5NBVPqQu25g6 L85G0qq8CrttCGVT5kvm52lc4XHpigtWd7H/1P4d7x7mGeMrFiF12A9Bx14q5Z3Edj+8kQEvyo96 9g8h7kEszPcNP5agO27Yg9fSql6fL3mTMhPK7ecDtQFtkiC1Dkq7HywwwUHYe9aG5W2r5hUK2AgH y/WgtR5ZJFqS3MiNcQnfFHgFT3/+tUKWBidZdwjDjLxsc4z6flUuN7kyVmf/1f4fkuFjuEighK4b i4z83pj6Vpaha3JXExDRqoOV4zXrxXKrHl073MU28RG545FVehTqPrVrT7WTzllBHkodzo52jFZz Tvc0Lmo+VLIwAIUkMFU/KR2rUsrmJIyrjPHPHAqDOfQj1Ga1iV2UiWSSPawwBtzwMVh3kcXlxMrO WdBuVjkg4rTk0CC6n//W/hvWK4lyEcBYhkZOG/CtG1uCU2zKOuzcRtJPqa9NwtseeWZZAgj5RjHk qFORzTfLSWIyOFaVyX2oOnWosBnwI0cpZiCrttAPWnujWsqyNIyDf8zrwV+lAE0V9HHPOylCIU3q X+Uv249zzWTc6h9tuVMyrGoGAU6cZ60pK6sB/9f+H+1KiCa4Fwj4wix9fxzULWdxPIZPLbbt3ZI7 e1dLVtGeZNXRbLh4EihbbtUIF+6WxVeDTfJmNwx3yw/MgDbck/z/ABq4x0ZkVLtLyLEsqPHDO5dO PmJB5NRQSl2cMgC7ceYX+Yn2FZmlPqadvI0m63VUOFz83G73Jq5qelXWhyRSagiwvc2kd5AkZDB0 kGUbj1xQaH//0P4fzeJqkcdphhKDtiJGA5/pW1HpkUdlH+6Rbn7t0TJhDgcbR/nrXQefdPYwJ3XY Y4zt2NtH51PZxrjdyztxtPQgetACSSSx3YNuCTH95WA2mrNtLJFIkk/zxs5OD1T2xRYBupC1JaZU IBO4bAByO341VEMlxtULhCoKjPT0rN0+wH//0f4gpI2hRkGAuzbITxu7YqoZQkRQSZwu0AdR2rRQ fU88ZbGZdgh3TYHzhucV08jKtrE3mooT5jDIcFj7GlyO9i4xvuNluGu7Z7pobeMiYrtTCpJgDkqO lULS6cv5SIu/JIVeOKUlZ2NEklYl+ztPPI/3gqZ2r90H3qjJaMrTygJGHXaHA4Yj3qR2sf/S/hwR l3ZlbIxgEDgYq9PfJeSxrMX8qKERKRgEEDsKDFRb2JrWbCypHKwVcMy87Xx6j8asyMWaEwFVcno/ 3DnrmgTVnYlkgSJBLNuLA5bjpVZoodTaMfZ40WAHbKP9bk9/yrSFuViK93AbRCISSCNrAnj61JaC 3S38y4l8tXbYxA3P74A5pXWnc05veP/T/iLksRDbC5juJZIpSHRZFw+04wajWZvPEcMhZSoVlfgD jpXQZykrWLcVhcySytKiNaLGzDyjukkYKdgb0GeprI02xkaKX7ViS5MhKwr9y3XPTd3rOp0CMklZ kOp25WSJLecbNoMiKpQKQMY96bbzEPGhLF1bauenpWZUpcptNbM0bEAJK3ygg8Gsw28lurebCG5B iJPzZJ5oMT//1P4dBC1rL9pyNyneoU42n1zVuSZphHdKQ75+dSCN9BjB2epc8yOOEmdiQwyF6FTj 1pNGRZb6I3zOLOI72aDBZAfTPWgtS963Q6i7WxkeQRlbgdVuMYZh1wR61jT3FpD94byOBjqn+fSg FJORnW7x3ElwzFUECB4y6llkOfu/zP4VZIGmIZyzmS7bY0CriBe4I/WpkvdsX5H/1f4nreV3UCSJ WdejL6VYvS3kRKCiAsSpK/OeejH09qzUbbjjK0We6fB3RtR1XX/tU0VmIRYoLW8RvKuGjjYK3mEn GAWGMetfsl8GbGCbU/C1rcBJtJTXbSzndlJDhWRUlPplinPriv6u8DYezyTF1fX8j+Q/GuXtuNMH T8l+bP7lv2K7GbS/hf4asXgVpdC03+y5JkTzPtYO11kY9B94AY7AV+Yn/BXfxbb6L4a1EXvkXP8A o0lody/vC7sIgSP9lZCx9ga/L+AYLF+KDl3qv8Wz988Tqv1HwrS/lopfcl/kfyTePj9g8GHT7m4g glSyGoJuLyvekSbSQADgKGcncB0r8YfiB4ik1XVdVhSNQi38iJKvKSBSAGQ984PNfv30ialshpQX WS/I/APo50mp1aj7f5H/1v4RLSVI5nVgGOeFIyc5rrrC8nCtEvyr1fPHHSpn8LMYL3jZjtrW/Hky l0njGDtHUH0NdI9ikSW0VtFLKAFi2gFjnuc/1rhBqzsMKLBNPDPCGLsoAbJMIHVdvvx1rblXKKsH yErtY9MD0/SsHuxuD6FNA84aOSXLJjaCc5x6VuxQxNdQSy+Ygij+TAz5hxzuPpWUo9URY//X/jb1 i7TUGw1sIks4hDFP90yDvn8Rik0YaFcpatfeZBcafM8gbO7zlPHA7fj/AEr58xjBs3V1a5WOWK0W OKATF4EfDGUYHUfnWZYy3sdzc3F5Fbq5fctnAS0PH+1+fAoLUNNToH8OJ4t0ya4hi+y2NtKWuhBM sXlMpIYMCcgHmpmsvDtnEJtMt02pAkTysRJJMUAXCt1wOmO1YS0bJ5Hcnja1nh+12fmRTKPKlik+ WPCjqvY59arw6nb6e8Ml05uk80p9lKZB3A9cdPrUQ2FKHuu5/9D+U/Rre/1ZI4HRI7eZQVUYCbOx x64Ffpf/AME79EtNW/aS8GxTs5jih+zQDyczK6PukljPQ5VNpFfl/FVT2eTV5eTPPrU0qDv5H+hz 8GLIWfg/Q0gmeazbSoWt1kXY0aoirgr2ORzXtJk8uEyFWIX25r8XwS/cwPoMKuWhFERhjaMuP4ue nSiGJRja+TjGBXoWOgsYYA84x2+lVJZZAfk+jH0rqpRsgP/R/oMVlLFZS2M8ELktTnjPmO6q5VE+ bHIIPHP+e9fylTaUXcJK8GfEX7blgms/DDUrOe2t0SOzfzgn7yafygJYo2GeA7YBPoK/hg+NVhpW k+M/EOjzWFjpNpbakfs1ukm4xyyO0rHceAGOAFHZfy+l4Nk3mNSPQ+fwtO2bzb/lsfOGrvc6TOXj WJ43fcmGDQj0U+nuDTIb7TXsxOxhNxcsUMMakLC68kdOeOeK/W4R91HsbDEvrqJjKIXjhReMpuVw OuOKyNT161v7c3UNnLAssnkmMId4I+UvyOnU1tHdAf/S/jTsdQuNO8rUoJVazhZ1u13BpZvlx5e3 065ParOkxWg0pGi0yKCe7u2u3mIJfD9iP8/pXz5yTeli1fWRnNmt1NILeCfzY4kfartjofy/QU6+ ijurG8eArFcWqBoTJIFZsYHHv/hQYtpbnJWsMk80E1ussnkRHziVONzEckdh9a6NQ7QvDL8zhDsQ DnI6AUDKs0F1A8EroqWcKDzIYz+8lOckt39uOKpahp8TXqTJIIxIgllVVy0QOcLijYD/0/45dKie Bo0mWQSNGZUkwfL2g46/iPyNT311C9xZlp1ea1uxL9hQ7RIjAgyMe2Mcev4V4UHrY88LHc91L800 qNKRGu0scdcn0ronawYW9rKLi8tzciWSyMhjg3DjOexrqjLowsT6lof2jSH/ALEWO2u7OGSXdv2l fQ5J5PXpz9a+fddkbTgy3C5dyIXk2ZO88gH0zXZQk7lzV6ZxEaJJMWmztZsFv4k//VX6NfsZx3Ta 6w0TUiY7q/BikuysQWMoiuMHqH2nI5HJ69/2Lwem48c4NJ6836H5Z4sRT4Gxrf8AL/kf/9Tyf9jK 7utC+J3he8hmtraObxBbz2UttclbiMqJ96QRn6kt9DX9xHwQuUv/AIe6RNbzyRr/AGepd3UlxJjc xb3OR+Vf1N9Jii1jqNe3Rfkfkf0XcR7XgevRT2k/zZ+If/BYDw+ZdJtree306Uzlrm9lujh2cmQw tx/F0b8a/nGuNEudNk8u1lKny1MnlAmJyB2PoMV+tfRsqyfCc0/5v8z+XPpL0bcZSl5f1+pwmp/a dRJF60xW03PFcMhdVPPyj/D3rIjsU/s5UaaVWa5K4ZCcE9MZ65r+lofCfy2/4p0Qgm0yN4J1iYww g7gwkEZx0PbFVdPlt4Umn1BJ4bRofIiCHBeVmAUhecgc89fpTTudDSUD/9X4dSW0RRpsEWpXFw6F raaNAYJHIOFY9gT/ACFZslzqCWEWhNp1naTamv2ufV5Z1e4jaNh+5gUjA4D5J64/A/7JzlbQ/wAa aEb20Ne0nOni2lljhuLaFhC73EG1FLZGMDr171v+HrKwvF1PU47aBJFvDv8AsFoZmm2hdrMqLkYz jkYGOteXjcVSwtF168uWC3b6HuZdgcRmGMjg8JByqS0SS1/r8kdBo3gfxV4v16Pw/pGkXq6zeTx/ 2bHc2jwJLDJy0y5GRsQMxDAA7evBx+2Xwz/4Ia/Fbxv4W8O+IbzxdY6JDc2y6nBDrMkYubjzQGxL 5cYkK89G4r8X8RvFjA8I4WlLAzjOpP56eWyv6/mfuPhv4MY/iyvVqZrTnTpQ0XS8vPRu3p+R7FZ/ 8EKvH6skd141tFjV1MsdrqYg02Qq2crGp3gHuKfe/wDBDH4jyzyvb+MdGT7ZJ5V7L/abecYVOQEJ zgn+8uGFfj0/pFYtvnjJfKKt+KbP2DDfRyypUXCvBuS68zv+DSt/Vj//1v2Bi/4IafEm0lMkPj/T JbeCYyw2MlyszSKc5jM8gLf99Z+lfkT+1V+y742/Zh8b3HhHxrZwPpuoSSHSNR81HdGVzuhO3g/d YgjGQOmMV/d3h941f6y57DJ8ZO/tFZaW10tsrd9NN/I/hTxL8FqPC+R/2rgYW5Hrq3pq2tXe+m/k fIsegpa3BuG082+797bTtD/x98ffQ9/qK5668PNNHeRyI32eaErjfiRG6gr+WPxNf1NRlorn8rV6 Wkmu5m2lrOyxiNnUQxeWLWbPnH+Ekk8n0qvqKSQTQ6enm6fHcqTFfRQGVbQrjdnA754HX8q7Nlc8 tNN2H20VittNHbLMzI283d2uzzn6NjnPPvU2qXuqWkVpM6g2kaBdyqXUg91I75xXTSd7HDXtGUvI /9f4iedL2yknZMq8YjkyMuo4/LkDmqOhXzw30VspJRyUjR13q2Bnn2wO9f7YPRH+H5sXdrLNJJFF DGhRwVkH3j6gDsDx+QqrHbSwXUcIUSvKp80Tkkx8EAAfQZqIz6MbjaegtzaX6ypHauFu4mD2m5Ak OCTkSP29uuea07rTdQ8lLi9umtLie2KFrcbxIFJyA3I5ORgZ4NKpNJWZrTpy5r26Fjw1ZPhLeziW TU7yTZHbK2ScH5iD6AZJJ9K/b39m7/gkh8VvjR4fsvG154gj0HSJ7MLbwXKi0tpZCxJPJLyAAjlV H61+S+K/HseCMkjiqcrVZPT0/wCD8j978EPDSPHWYVqmMhzUKatrs5N+vRb6PdH/0P2rtv8Aghd4 mFw80nxVhtVkXzGhif7QiuO0ZaLKD868X+Pf/BH34ifCz4e634x0TWrbxfPosE1+YFvhHN8sTMFE eEBHykDJxzjiv7G4d+kNmdfNKeGrTk4zklrZrV27n8g8R/R9ybDZVVxLoQTgm/dunou9lp31Pw18 XeHUs9WmltVeyuI123lldOFkt5EQGTPYEncMfhzXDPdrJAt6wR2hkEbK2EkJ9dvpX9xZfiliMDSx C+1FP71c/gzPMAsJmlbCx2hKUfudi6mpx3yvp88AntJEG1AxRpG44wOnT1pdT01VSW9tItkQjCfZ 2b5l4AIHtXfzJK54fs1bQ5K3sTPdLwFKjCJnCj2HbtXVaXby3bXFiJfKt4YSkkHlgFiTncD7Yx+P tTlNezMacF7dWP/R+VpdOubeATQm3LwZYvcRB4duO4NfpP8AsV/8E9fH/wC1PI+o21pb6b4dsGha PXsyWw6lpZRKSFwSQirtY/IfpX+u/iJxrQ4L4WrZpVlaptH1fX5fnY/yG8LvDnGcf8XUsvpQvQgl Ko7XVlb3X/i9dk+x+vb/APBEm0tyrad8S/JNxGqXh+ffnHIH7rpn0Nfn1+2t/wAEyPF37NnhAeN9 MubTxToEU8kmopaNLIJgxVeEEYKOgJbJ4IznFfytwV4+4mfEFKjjpv2VSSUr9n1eu93p5n9eeKHg XgKnClSpldGKq0I3jyrXS10rLay120V+h+SF9b2scdtceVsDk20A2f6r++MEZ44zXPzaLd6ldQ21 uqTEDGYQTnvjHX8q/tnC4pVIqrF3jo12P4Dr4CVO9Bx97VNdbn2h+xZ+xn4p/ao8c32i6PBdroel wGL+02j22wuMrucuyFdq7WB+bAxnmvsv9rj/AIJNeJP2dvAV58VNP8U2+vwaesT6jpcl0Y4tiY87 y2WFQrBSxGQR8nJ5zX4bn/jrhMo48w3DFFJ0ZSUZu2urto+Zf9u/joz9/wAo+jljcf4f1eKMTJrE 8rnGN7JJK6TXL85dldLVH//S+Shotze2e6WZQzZuI4I3zEO6kEegPFWtMtZEldbyE3jvH5Ua+YQ6 sMfPjvwCMe9f7bxqp8rR/hasLavKD80buheBfFXiOcS6Lol/eW7zqs01npc+pRxqGIZ1CqdwXafQ Eiuz8W+Ab3w9pztJpd7aPbu1o13qemSafcXZkeMpHENnTjcdxwNtec+Mclp5rDJXXXt5O1r7PSy9 X/wD048A59PKKufLDyWHirp23ir3feySvttqeH3NlJdQX0DQyB4pPIeRR/qyPvYI9j+lO+zWtlo8 kNvteXeCJpssQThcD2z29+tfS+0vI+QVGysQwrawwRtdSC5nkXEwCGNIz2qwLVI54mIhijuMxozH AUMME+vf9K6IfEefNWk0f//T+JVgn8uO3BQzQIV3xjdtG7qx78kc++K0TYxRpbx3zE38l0FihCMP s67fvtngbtwx3+U/j/upH42f4ALRnrXwU+CWr/Gfxq3g+wiuBPdNFbm5tLwQvbq7jcwUggkpux9O o61/RJ8N/wDgij4Wg0zRrm/8T6lPK+niO4kuWhE7RFRjeqLw2Rjr2r+cPG7xYrcC1KOXYFtVJaya 0duyfTu/kj+vPo9+B+F8RcPUzvNLOjBtRT1V1o211u7qz2tc7uf/AIIs+AW05rddWdZhHIkVzEjC eAFuP3u0enf9aq6f/wAEV/AMFq0beJboh0aK5lF/OhBPV2KMpY9sHIr+c4/SMzyd2qlRL/E/82f0 9U+i9wo24xw9O9rX5Fp+Cu/u9T89P20v+CX9z8GPDWo+IvAHna5Np8AmOjWEbLFq0S/eZkyfnHUb ecjqe/4pzxx7LkyJNp95pq4ktLyJrZrZwfmjdWHBGD+Vf1r4LeIq4+yCVXFSviKbs72u49PWzVm7 durbP4J8dvDOv4a8WrBUY/7NPWNr2vZP5XvdLpqloj//1PiW3kXUGR5TCIdh2SshwxHp1rTuI0it g8TLJNu4ROgX1zX+7keVJH/P1JPnaMtY2IV5S3zNtDHnJ9KJ7Z41EUYOWbJCjDZocuWWg4wcrIai 3GxbdQ/mSttMQGZM9OO+fpVhjcWsib0Vpo+FLLygNOGq1NpQadrE1zNNdy2jlGuJoB5NuvBjgUnc ePTNCabceZcXOpw7YbNnQLBHvlyo5AA46+lE2krBSpOT0R//1bn7Dn7OVp+0T4yis9UnmstAmjkO pWs9pHLBaxrjDSMQGJ3Lj5TjDjjiv6W/CP8AwSZ/Zqm0azgd7q4vngRriW0WKGyUKoCBMDdkeu7H tX+iH0iPEbNOHs5p5Xgr8sYp7uzvZvrvrY/gf6MXhNlHEXCE88xsV7SpKSu0m0otxS1W2l2r7s+N v25/+CaXwc+HXwyvfFnhK3nsPEWnW0yrqJuzHJfRhSSkuOOQDg/7I9Of5oLiC6sZWtpHgla0k+zX sbtukicAHDD1wR+dfoX0duOcXxdw5WhjPioyVru/xXvby0v5Nvufz/8ASW8PaPA/GUFhWnCvG+it qtNV3177Iy7632O2NyBiGKnIx04FZ9tY39tfR6rbTWstsI3guLSRcyhjja36cY//AF/0inZJH8xu N5tF5YmkVWkB2j7x/u/WoplRHDqT5UGQ6soKHPI/kfzNak8rtc//1vhu4hM65WRXSQ7vLVQcgc59 R07VYt7x7V4JrGU+ZB8pO7cobocjoenQ1/vQf89ThZXH6dEI71bu6Es9suVaCIfvJXJyM8dDWncy whmkto3ij/gRuWH1FZylrZG1uRK56T8Efhv4k+L/AI4t/C/hixbV7uc/Z5RGQXt3bhRgg5B7gdP0 r9x9G/4IcfFPxV4JsrjV9e07R9Wa3judOtW1D7HNaYX5FZAODyT8/TPSv598W/GPDeH+Mo4Cm17R 6vr8rdtrvzR/Ung/4DYvxDyKtneJTVN3UOidtG7973SXzs7q33N/wT4/4Jx6Z8DPFevn4s6Hba9r ukw79Na6kS/sWbzBljydw+fIB49M1+x2pfDD4c6tp0uk3/gbwnPYTReS1udAtVCj/ZITII65HNfw L4keIOa8U8TvNoV5KDtaza/L0tbof6GcB+FvD/CfB9HJXhouVnzcyTbf3f8ABZ//1/cP+Ckfw58M eDP2kvHvh/w3pS2lgkM0apap5MbSROWXcueSEZFB9Fr9x/8Agjv+zZ4F8P8AwStPiJrHh/R77xPr 9tBOWmtI7yNFcBklIYHD4VF9ua/vHj3irNI+BmBqKo+eoopu7v2Vne+idl2Vux/DvhN4fZJU8X8z xborlw7lyqytd73W2rV3pvfuz9lPE3grwv4o0LUdC1jQNHv7C9s2t2t7vTopYl4+UgFeNpwRj0r+ DH9sHwRa+HP2nfiRo2iadFYWB1a4lghiBt7bdFKsIIU+qqBxjgDNfOfRNzrFR4pxmCqzbhKns27K zvp9xj9MPhvBvh/AZjh6ajUjUd2kk3e0de9rnyrq6yrdeTLawxSzyYJt4gkcf+HSsp9JkaaJbS0L Lj9+2C7ufXgcCv8AQ6jV9xM/zkxFBqpyJaoZZ6Hd3l3JBbiEbHKFnfy0fHOASK2Z9L0+wgnZlIkn Xy9i8MrKR82SD6Y/GqnU0tcxhRktbH//0PiyG0kkmZY8qUPHZh7/AKU+SxW2cwu4nTqJsY3Z7Y9a /wB5FL3VY/584U21LyLFvp8cz+THtVc78qnzfh/hXrfgT4IePPH0fleFtHv9RFy/mmSztXuS0YOC yhA2D8pxuwPfvXkZ3nmAyLAyxuPnywX4vsj6Dh7hrNOIsXDC5ZTc5deyXd/1c/ps/wCCVHjT4Z/B Xwvb+AdesbjQvGmpRi0nGqWK2upGUSN52c4OWI3YHUMfSv32ikSaOOaJt8cqCSNwMBlYAg/ka/yZ 8Y61fGcY4jMpzcoVXePp/wAPqf7L+EWGw2E4EweBpQUZUo8sl5r/AIBFPdW9sUE8ix+Y2xNxwCfS sXxV4W0TxroGpeGvENml/pGq27W11A4HIYEZUnoRng1+X0MRWwteniKLalFpp9mmfoOJwWGxuGq4 TEQThNOLXdNWa+5n/9H9Mf8AgpF/wTXn+DUt/wDEX4M6P4h1vw3LN/aGp6THZm+hjR2HnIjRr+7K nLjIwMnt0/DW48PzTNNbG1uLe+BLS2roTPAQcFZE6qR6H61/rR4FeINHjDg2j7ef+0UfcknvZbPX fqlbZJXSur/4u+PHhrieBvELE4WjD/Zqr54NLTXW2mz6vzv2IB4aa3TaZLZXjwJFMwDp6YBqv/YF 9b3BXFw0OVaVoYmuYwT0BYZA+h55r9uji6Tdmz8WeXV43djpI/Da2kMt9JuLw4O6ZAFjbrhlYdcd q5S18P3mpamscaXOxiX83YQuD2B6c1osXT6Mz+oVldNHRyeGtV08TWzwumEBd5QI1YN9w4PJzjtX KTaddKuySARSFtu9uQOvPHbv60vrlKrH93K/oKeX4nDy5a8XF+asf//S+O7XTozefZrpjK7ttEcX LN249a6K80a0soI5WleTfJ5YgiH70jvwMkHj071/utVx1DCpzryUV3ei/E/59HluJxTVPDQcn2Wr +5XL8Pg68RY2eC4HnKrwyeUxjKsMjnHP4HjBp8XhnVCsUcen3N8vmsvmx2zbCwGdhJGM46D61y/6 w5U9sRD/AMCX+Zf+r+bR914ea/7dl/kTy+E7m3iS7h0m/gedg86fYpCkZbPbBA7dPSrN38NPEFxb f2jdyPb2F+pMWpxWly6Bs4KFjHtDc965K/FOTUPdqYiF3p8S/wAzuo8J55W96GGnbf4ZbfcY1zp1 nZv/AGLBaebNZINs9xIZCx2/eLkAnPPTA54Ff0B/8EUfA3wegTVvFPxAi8O3XizVtQLaSb+2X7EZ rfEBVA3ykrsjb5h1POa/MvGTN8TT8OsbiMrl780kmuz10t6I/aPo4ZJg8d4t4PB5rHSCk7NfaSt1 9Wf/0/76ZdP067tHtJbO0ns5YTEYDCjQOjDGAMYwR6V/OJ/wUa/4JnX0MviX4zfDjV4bbTkV7+XR U0zz3gkkkZpFUKOAd2TngYJB6Cv6I8F/EXG8K8Z0quNqN05y5ZXffTd7XTa20dux/NH0gfCnB8Wc GVPqNK1ainJWXZdlvbR9NE0fzc3vh250UXOjyky3VjctbXRnZ5Nj7QSQ5UcZJAx024rkbixjspEM 9yh81AJFRWIickgKTjucdPWv9U8DiqeLoQxNB3hJJp+TV0f5CZhhamFryw1ZWnFuLXmiFYkkJiUG RvumMD5h+FRadAii5kjuBLGpPlbMMAQcEE+xBr1Lq1zh5fd8iECTBaVkVmJ+RWzwK0vCOnrdeKNM Mk+yA3AhuLZioS4SbEJDE9B+8+pJAqMTNww05QV2k9PkdeXUoVMdRpzdouUU32V0mz//1P62v+Cd /hfwz4a+EWly6XZadaXZ06KGeZIlimcbQVKkcYIPbvW/+3JrHi3T/htq134I+3XGqjT38iKyyzEg McAjoc4Nfu2e1amJ8Tqjx+sfa2d+1z8ryujDLfC2l/ZatJULq3fl/wAz+Vz4fftJftJXXxUs/Dev +JNb04XWtiyew1ceXcwASEM5GAQAVbgjpwD3r+xL9ni9Gp/DzSbm/v7W6vFtYnnnedWd/wB2BuI7 ZwDj3r9S8dciyzL8swNbJ0rTS1S8j8y+jtxRm2f4fMFnrtOFRrXt31Pxy/4LN3+h3/gN7Cyu9KM0 l5FAsckyhriRSdhTHJKjd09q/m3+GPwi8feO4rjTfDPhbxBq2sSRJLLDGDHb26yBcBtynaSGyc44 4+n9EeA2aU8i8LYYrMpcsYyb19FsfxN9IHJcRn/jPi8LlkOaU7JW1WyV2fRK/sFftHrLcxaf8Ldd fT7a0UrFFZloHkcjLmdgCCDnjGCM1Mn/AATq/akvRBcXPwz1OHyI38zBkS3+fbtkYhCcKB93PPPI r6yfjbwhTm4Obvf+7/8AJHycfAHjerDnhSVv+3v/AJE//9Xzj4m/sxfFz4RyNd+NvCX2CzhQo13m aHeuCVcRvtGORk8njpXgVzbN5uWuEtwsQdAuXjcMAylSOoIIwehz1r/cHhziLAcSYNY/LpXp3t5p /j+DP8BeIeHMfw1j55XmcLVY29P0/I9f+BvivxjpHjzw3babreqW+mrfwwSyKQtkokmUvhQMliNw HPBfPrX9437Llx9r+Fvh2dpfOla1TzS2d4yp6k9eg/Kv47+l5hqMI4OrCKUnu++5/ol9CbHYutkm Y4KtNypwa5U+itHReR+a3/BYuAXPwl1EIIZSqQlEZCrKy+ZhlbOBhtp5B+727/yF2Y86W9S4kWSD TZ/7OnRG+SOUcFR7cHmv0X6LU2vD+ae3P+rP57+lZSjPxdnbrTX/AKSj3H4G/s9ePPjz4qj8P+Ct IikjS5+zPe3qyCKBgcZQJndjgn0HvxX6X6Z/wRv/AGlp7EZ1Pw1OWUzCBtMJEZIGFEjKT+f5V9lx 74zZRwRjllk5KVa13rt5WVm3a3XQ+S8OvAniDj7CSzShTlGheysrXXe7ukt91r0P/9b79T/gir8a rz+yVaS109YLX7Nci11JRa3LgcMyJbqQQe+cnua8L+Pn/BMX4yfA3wPeeIdW1z7bDZyCZoYdMZpp o1xujSURjGAMktkYDDIzmv8AUPJfpG5ZmWbUcvrKKjN2uk0/xk18uvluf5Q8RfRgznI8jxGa0uZu nG9m09u9opq+1+nns/zWv9BvXvW0mzSJtUt7kW8VpKjJNNI2NseMZyc/Sv1V/Zt/4JH/ABZ+OfhG LxHrmonw2L+ETJHZu0YtlABJyQCTkkf8Br9J8RPErL+CMmjj1NSnO3Kt9H131v06dfX828K/CXNP ELNnhZQcaNO/O7W1XTyt169Fq9PrG1/4IceLbFdOWTx4zra3AAjyESZOh80FSfxyTV3U/wDghn4k uIb6R/H9xDHApksPs6xzpHnkDOQWwfX6V/Pj+kzXVZXatfsj+ln9FTDOnKEINtLfma/U/I79pn9k rxx8BPHR8L382s+Kbe6uI7eDXXsIoLaMsxTYIlYkbcAljwd4HUZr9E/2Wv8AgkDdfFfw9H4u13xn d6XpdzcrOmlp5UM8gG1oxgqxAzz8zema/Q+KvGmhgeCqOe4PWrWWqV/dvp17773S7s/JvDTwSr5v 4h4zh7M1anhZPf7Vpdbb2S1VrP00P//X/tm/Zz+CMHwM8Ead4MtL2S9hsoUt/NkZX4iUIMkAckAU 79of4IwfHLwZqngm7laG01S3a2uJI5vIkKMCGAbtwxFfo1TOp1eKXnsvi5uf7tj5XFZLCfCkcgWi cPZ/Jqz/AAPwO/aK/wCCPfg3wL4X1bxja+I4JL6Czldprq6hyVWNjtO4jngDcOnWv5yvF1nD4d13 VdCtJIrz+yLp7DzbeQSLJ5fHB+lf6W+BXH+N42yiSxkf4SSTtbRWVvP139T/ACL+kH4e4TgHidUM JtUvJrdXbbv5emxwyXbTMqTK0U865igPLnpn8qvxiW1t3Rt7uZOSxyRnPGPT/Cv30/n0WIiWWN5m IMR+UKcAVanvXXcZgNoAQCGP7wHQEAZJ/WgmSTR//9D4Xkh891KR7VYZJA2sOPTrVyKKK3XYpfaC eWbc3rzmv98D/ndjHlRpW8qbGhj2q4BcMeCQO1Y/mwy3EqSo0UgJ2dGEuAORj60FFbYHJDsFUtxx zx/+qkX7PLavbmDIVywlYHzGHQg+o4oAqeXF5QtoXKRYAOw7GQg9vTpV2ZPJSLMgdJFyGHXPTB96 AP/R+FmyzxhDyBnipdxIJaNgoON2OK/3wP8Anh5ZdiKNCGYlCqDlWI61N5fmqxUYJG0MRg/hQLla IWUpC0YlY5Gw4PNQ2a2o/cyeb5aNy2TvY9aBFlreOVmkcfulYGNCOeOc07zlhdAmCCwz2P0FGwH/ 0vh90iaZ12kSTR70LE5Iz1z+I/OoEQ2s8UZcDcwVMnpnjrX++qn3P+d8fNB5Usiu5VgxDjOeQabC s8coZBHJBgHeG+765FRJ3Y0r6Ikuo0lnD5DFsZAAwP8AOKfGIIZWldFZ0jKKSBuwff8AI49qcWkn ccY3Oc8SfY7zQNRa8lImWNvssUSlmbHOCe2en1r8P/2nksbPxhpksYdLwWjWqKHaZQVciQuT/EcH p6ivw36QEf8AjAcT6P8AI/q36KCtx38kf//T/ialhEhMyFhKxI2uMb8VBHMINxKKXHX/AAr72srV HY8aL92xVlaQq0pYqjLnGaTT2bdIF2lGO7JH6VkO1jUvr793BAg2RxkhsKBuJ9T+FVtqsQseFfGR tNYNWdjoHKXdXErB3QHbnCj/ADxVVo5SFdRsZOH2Hgj0pEyimf/U/iPjj2SCYkK0x5+XnjvWtbmF Unkf55mAWEjGw+u7/wCtX172Z5sYuO5gxifzijbvLkc42849cVHeQW0U5jUyOpwVfbs3VgUWobSM ZjReJF5kPJFP8jKNDxtQ8HGTxQBvRNZLbRAKI/LTa7cDzPc+/SspnX7TKflKAALtPB9TQVD4kf/V /igKqvktFtkLElmI+dfb2pjyK0gMkmwqeCeh9q+km+hzNXVmV3lQcMCuScYGdwqsksssyQxKMIeH bgVmRyF6WeKF1tmXls/OoHBxVmyhLKhR/LKtkgDHHNAnCyuR3jKsjRRyFlAwwY8A55ANGDHhBscD A3KwO33oIP/W/iagjVvNMx2fvSIpFOePepIZZEkVFyzb9u/GAfxr3eRHnk95I8G+ITjy5HDXDYwG A5wKjeRTGrW5HmKuVOPlPHFXa2hlC9yS0Cwj7VKRJN93ltygn1q7cXUciguIzK33UXolApO5SdfN kiRlUvsJaRPuKPQ+9MS2jOVI3NvyD0zQOGjP/9f+K17qa2jWFtnkhcKgUd+59/8ACooI7ORHaUl2 GDsyQqg5z/SvdlK2iPPGS6TCm2WGJlRjlgTy3vUluvkhdqk4f5UPtWRlNale9N1dXvmTRxxRA7is Q2qmPSrIuIBGsUkjkF9qDBYEn6cDpQXFWRnyHyZwVmBiZvlT+72Iq0kqSq6tF5ZxgsOx9aCj/9D+ KaZE8hfMdWf7qMpz7U6RHNvGoCvJD0YDaWzXsHnla6W6nSO380IsLFzGn94gDr+FPso0tw0c6pJ5 smEUnLMe+R+FBpA1ZHW6E8TRC2VEwsaH75HGR/n1rDe1igIkn3NhPlGcbT2/nQaC6ZZi8neMguWI CEtt2jPJrYaGTSmuYXliuYVbEXlkEdO5Fc4H/9H+KlEFyhZ06n5geQMdKbfWsQiLBAu5QrSIOnYE 16K6o5Xa6TMM2yhVwcupypIwGpZY3WMBmKoW3vg4zSFKK3JzZ+V5chUMSQEU9Tn2q/KpWEStlCrb Nh/woMihds0sccSJsdz8x6Kc04W80Y8ss6zRgAfLhGHpmgD/0v4nBPc+QYWZniiclQf4SeuPyqHz DLGTEzB+mCvSvQOF2sU47Rry7SCYMzgYUK2N31/Wtf8Asv7Oj7sedglN52KOO9Vf3bEmVJbsyboU Cg/67cRnIOOPanJviCogwWG1sjjHerp7AQ7sGSPyQ5VSenB9qSO2ZIJA8YO8ZTnJHPSrA//T/iFk gEi42FBtxuz0xUVq9xay7Edo4iMbsZJ969g88uTo9y0PnEb/ALjTKmAc96hnsJGTYpXy0bliMNIa SSWwFJIM7gwKlBhRjGfqahkhaNWEiqQ6/K/9yhq4FM2+3YjMfLc5WRe31roIUigZcHzf3ajdu45x x6UJcqsB/9T+IfUVjWTMSYVh8sm7LJWcEEQYfK7OuQzDJr2Dzya3ZYnRmXbtIZ2xTLu9Mzu6IEdz /D/F9aAEQ70KSMUOMnircEslussUkYeF0/dPu6tj2oAtSRwzRRuJH+0xpgheQAPWstYRLNjYTzjg 4zQB/9X+JkQSm2UKxDo/IYYwtZMqRKGKFlk3Ybd0bmvYPOavoVbhhA6O53xBcMV5yT3rNhWSdmwG jDHIbBCmgiMWnqb8FhGgDSOfMPAJ6H6VFeQoYXCvK+3hxgnH09qBTXvWIo4oLeCOWzknWIj51kOH zj5sgds9KryTTStJASGjIDKw4b6UEtWdj//W/h2t0mt3CuGXPzA+xrVu3e+WBFVWuIhtDg87Oynn tXsHjlKUCZ44Et1AjTEh/jfirdu6WpiZYCse7bIrAjjvQU3dFHU5yzHyxIqHldwxgVmRrdTMm19y rwQxwABQK7WxbjuPIuAI/mQrh1xw3rV2IhZUkZSEfoB29/60Bex//9f+HgxFZ5BNLLcDcXRmx8o7 D8KgiEs10odRsVwQGPBGc17B45fkuljaYbR+7O3BGFNUpXJDySMMuMbAO3WmrX1AYvmBd0URwpAG f48+n0qYwTvcrFsfdIpf5B8oA5Of89quS00Li3zK5L9oe3hPlONyPt29Vb1pF82XLyMxLj5VHGAO KzCe5//Q/h6t7ea5RZIZFhRZRHvdgOQRxiuqvpTLOixsiEIsZVRlTtGCSPU9fxr2Dyoy5dDNuivl +Wz4yedoyMisy6uDHEiQnKEhemGbHrUTdlYvniRxxy3TMRkpGoL+iir8kDmN9sqoiRjkn0rLYUpK 1imkRuJgCHQKBGMjqP71Wntc5wTiA7VbHLD1xW8XdBT2sf/R/h3jSTzhgMqMduSMA1oSGFQY5VKF RlWAz+OK9g88yY5AjeSEDFzkOR8xNayAwqdu/c67WXHAHeomtLgU2eAEFt2FOSq/eJFSvNDeAK67 FAxjPIrIB8psri2jtUjijuA5Yy42gjGAprIbTXDNEhG9Rx3B+lAH/9L+Gq3gktEMfLKcl1I/M10t rqR+x+UZPniGQ5X94R0A/pXbJe8jzxLO2N3FkICYpc8Lgtnn/P0rrJNMMlk9wIVae2iJZW4IUetW c5w9w9xeyZdzL5aiOMM2UUDoBUFtYKH/AHrruZ8sNvEY9qwaa0Y4uz0NV9NQrI+wSsqYiZSVCjPX /wCt71m6hPeytGuo3clzsiWGISNuMarwq89h6Ui5vof/0/4hBaxJ5AhUCeL5iwHK/jV2Rbj7Pu3M 2Gw23kr7mug8dabGPPFFFCDkyMzdc7cVWhyjvumaEBQzMp5b2FBundG39ptykeQrZPy4OJD709wk 7wKzqiLn2+g/GgZP/Zcd9D5EMp88ZfbjjiqltbfYpVj80ygnayEcKPp69aAP/9T+JO6gExj2FXVy Q0ZbaVx3rAksXSRgOfmxhTnNdBxRXvWZct1mijlijRs55bpnFQs0l5GHC4aE/vBn7/Pag1HTzlcr bxkJxhG9ferOnWuIbi9aULNIQqx4wxHNZyi27gW5PPgtdkI2XTtx/FgHu1LqjwLpIgiyZvNHm7Bg HjJJ9OazGnZ3P//V/h0toSEVmI2rzhup+lV3juJTuWNQm/DMvVfwoFF3Wh0FpZo0axyS+Up++wTd J044pZdNnlWZoThYYyyPKPKDkEAgZ6n2oM5tN2JXW7On20EiRySISS7E73HGB9BzjvVKKKaJmfBi kWP7oOQ3enqk0QSL83mx3Kt5kiCSLvtx/jWRJsiljkmjfbG24joWHTFID//W/h+trxrwiaST/R4R xFnBAHQEVpQ2tvIzygSRblDJjkc9/atYbHOX7md7G2xbFgWAXepyfrWHFJJbOjsj5um2mQnH4mol 8Qro0GVrq3eaGFJJll8o7QAeBjOO9UIdKlnZYppo7cgEgP8ALzyQPxqRt9zo28NavZW9vcvEZbNg HWSJvNCn0Pp0rDu7W5uH852dfLIUZHypjtinZ9ieeJ//1/4driYQ/utnmDHJYff/AMK0LC3kmAku Ejt9wLQpnCMOgbmnys5VJMq3ClpZQkhkiUbX3DuOwpLQeVsDrw52plsEHt/+qnySKOs/s27fSZtR s42njhmEUoUY5479O/6VDPp0bR+UVDNJGDvXrT5GNaO5naTbyRahDbou6WdvLRXTcnfqCMcVpSaP f3lzcQKsszWAE00LxFEIb+NSeD07eho5GXz6n//Q/iYXzVKpGP3uf9YeVQemK0Xf7Q6xCFGXaFBX OSwq+W0rGMZNxkfR/wACNLubjVFghlNwkZENzaIuWtlLI+BjscZyeymv2X+AWk2fiv4o+AfCkLXe kx65eqs0Fr/x5zG1AkUbjkjlVOBk571/Vfg/L6vwdj8Sl8PM18kfyX4o0frniXl+Cb+LlX3ux/eL +y/o9vZfD/S7i0cQpe6MI8YAAaFVALD1yG/Cv57f+CtHiE6pqi6bfQ/aJ9U8RxaLDvkEcFtGcm4k bp93IIzX514OYf654hTm94yb+6R+5+Oko4Xw8dF7cqX4f5n80Pxs1KCz0LWW0WK3mmutFubNDtLu yLFtd0B+ZQTuB6cE1+KHiBGF7Gssyy4PmboV2xyB+cAe3Sv1z6SVZwwWFpeb/JH419HGkvqVab3/ AOCz/9H+FlrNDK8gXy3jUMCBj6ZrVt4TcbI1kcHy9x+TAJBwQD+VZVHZGVPc39G0meWd5Ll5UQR9 d5jZgMYH0rrLrWWtFhS0UhthhLg/vO4yB1rkNLK5Tt1hVN0rvJMB5ju5y5J9a2ooxeLEIwxWTCsC dpGDya5xkV7YWsOoR3MU9wik7ZLVQDGSoxjd1APFdARMkCbSjSEYQMcAk9j9KmTSVgP/0v4zLqC9 NiiTDzJQSr+WpUDknOOtctYHUor4WaWklxJI37tlQnI/u56fhXz4HX2SzmVVk+a4j4NvnBjJ9fSt y2tZnkY3K/Z9h2sQd69cdahys2i4xvuLLp9rHK8jzzIjEST+XMYklUDo3bHFXWe3m0qK3tYFjcTG SGdT8nlEHK/mc571i9mP2fYq6aZLaPZLJ5hTIky2V47ir93YvfFBbKkblxvJTLMBycfWs4N3sJxX Jqf/0/5NtBujGyWdtcXbPGvlllgaRYz064xxX7Uf8Eh9Kl8SftG2LwWqz3PhWyRNNa5iLRebOwMk jDHX911Pqe1fkfGc+TIazXl+Mkv1MMRG9FxjvdH+gF4AhceH9Gl8jyC1hGJFVdsb8feUe/X8a9EZ wEKnHpjGK/KcLG1OK8j26StTRDIf3Y28rn5sVXjSQLvRsAHlR1xXYulzQtwkSHDM2B1qC68tB8oP Jx0rrp7DSu7H/9T+gpJIriVNqSRSnkwsM7OnerUsM0DBlf5ZBhs/pX8l81rlf8u2fOXx80T+1PAu rvcxWjxLbzW9/JNFgSb4CFJbqAh2EHtX8If7W3ha70z4peI7DUPskNpba3MHQok1xKTHFFFISOSo VFCk+rY717/Bdblz2VLvFfmzzaVG2J9ofK+v+FEi0zybe/uJmuUBmRowjRsOyH0I4z1Ga87ltrq2 it4ba2WKM3BUXDqDGrY788k4HHvX7hGCsb1FZNEfiDXfFNwsEZid9G0uGOyuCluYkQn7rADrnPLH P1rN08vfR3cEtxdF7eP7Rbxtb/uYkJwyo+MZzk45PNaJWCOyP//V/jWMNlPaulk4BRT8k/GJAOcj 3IFEdvq7RLdedai2jtdkkNm++5WTPDbfTAPbuPWvnzjmuppGOS5t4ljdZAH/AHUxyJpTjGCo4ByD wK5m/triO/tQ0ksJt8tPFJkJMHHG4e3YUGMopmpC1jZxalPYXlxvklTNvIoWJiFAxgng5x69TWis 9xDdWF1NaxeZOuVjxuhXaOcjv0/WgaVlYfOJpJJpZmiiUZkRcgKv4Z4psj6fPawahaKk9+zmG/ji bdEqLt2srfUsMe3as5voFtbn/9b+NqLV5WuBb26B2tpA8kcqEoUP3s/4VUv4LZ9WuNRhQWb3VssW FY7VI4+X6nPFeBHRnnnUW1rLaWyzwXCMk37uWcqUeM4ztC+/qKtwadBFalYtRubifBkeWRRkOcnj joOn4V0R3Qy5ojajHBL9rljuTvO0wZZQn8O/PQ8HivOPHhto/LiEKmSe482YMo37lU7WI+hxXdQ3 ZrL4TxVlaa6dFwmHJY5469fxr7a/ZR8Q3Fl41ht7VAYbG1iGyOXEvmSNsBJPA6g49z61+reFdR0e M8DP+9+h+Z+J9Pn4Ixsf7v6o/9f5y/Z7mtfD/j34dte3ESTm3stStdi5MzXwjIAbpw0oBx+Ff3If sy6z/avw20ORY3SK509ReZI2wXEa+Xj8QoOPev6/+kzhpfUsJiejVvwPw76KNSP+rmPoLeMj80v+ Cpnh2LVPB1/qU4l3W1mz3lxJFv8As7pFlHAx0GD+Vfy0zy+ImsbG5muVNvIflMEXkEBgWAbnOcY6 19l9Gipfhmcez/zPwn6TtDl4k9rbdP8AAw1uLq3s7h57a2uzDMwRGOAin7rMv1zyKztMtra7urXz p455bqfy/KSULbR5IPPYHOR7V/UsPhP5AvaVyy9rJZvqEM0rXW2+YrIq5RVwBt34+bB7+9ZesNJG 1isigZQy20WMF415diPYk+tRd85vd7H/0PgqG9udSuILqwmfT57a3e2gikCxwXAU5LgdyMHB6847 1s6NoMeu6hCmq3RjhtQZTcCPzmgkHKsF78+tf7HTdpI/xvwFN1Z+z7ne+FvC138Rtd07wp4OWa81 C51ldJtIbZGMc7q6rJcSgKxCKCc4x0696/rt/YG/4Jc/DD4Y/D208SfFXwsmr+NPEEMV7cR3xIZE dNxDLgEK2/hcA4wTzX8yfSC45qZJl8MlwFS1Wer8v+GS690f2V9HTw+w2PjX4ozOF1F8kLry1afm 3b5PXU9y/aR+B37LvwI8PD4k2vhnQvCniKB47Ky8gS3F5fK7hCqLuZgoBJJ+7xXrP7Hn7VGg/H/w 41tpdqsQ0QGzint3DxyJCRGNy9s8ce/1x/I2Mjm2d5M80xjco03uz+vsio5dQq18uwSUXFczS8v6 /pH28zBFLMcKoJJ9AOTXxXYftpeDL34yN8JZNKurO4jm8l9RuJgEHKgOR0C8556+3WvmMvwEse50 6e6VzvoQdSv7OL1Z/9H+/OOeGZBJDLFMhGVeNxIjfQjiv5bv+C6OjXN14y8HXFpHsR5RdzCVSsTK sZWVg3ZgrM34H0r9R8IbR8QcBf8AnX5o/K/GqEnwLiors/8A0mR/PtoGkX9rcyy2dwbuxCG0tlGZ 2jk653D09vXNSpp2oXOof2SXdtXa1+0GB43CtgZbBC9epx1wK/0z+v4WjJRqTSdurS/U/wA2v7Fx 9aE3Rpykm+kWzHg0a4lmS8eX7Ibb96zMQY5c5VVfP3QSe/5GtC50PVkhkmmtZo5C2+3kWIiNw3Hy npwCfwrqjmOGnFKM1r5r/M8yXD+OpOUqlKStveLX36GRp/gnVr+eTTnuooVeXzN00mUB7gH36V3N r4Nu4oGtdQs7iO1WHdF5kBZQq8+Yvtj+fSumOZ4Wk/Z1aiTXdpb+pzf6t5jiV7bD0ZSi+qi3t6I/ /9L5VtvBl/fJe2umiWSKeVf3LRtbu4GdrBD8xUcnIHU1fj8Iz6fFBYgIb9Zt86+WYfMyANkZI3ZG CcH0HSv9nVmeDk1D20bvZXV36H+MUuG81hSlXlhp+zju+WVl6uxhX9y2k3zpFbNOxYWri4jYeVLu wduOeOOtQwvCzyaheSILpSVW3cbJDtAycVq5Na9zyVSTrOC6Fu4udNubMalFHdRz2677hPMEiHHH ChQQPXrWh4eb+154LO+mdoppFjg85cW9ruY8KcdSW6cnNRWqKlQlWqu0UrvySPTy3CSxmY0sFRV5 zfKl3baSR+k3wb/YJ/aM1vSrD4leGfhxet4YtIxd3d1MsS3t+sYWX91HJsbbuA4wSQcHB4H9Ev7C /wC1xY+MxYfBK/0CXSde8OQC1eKUeQ1uFIQoQMgkH6Z4x3NfxL41cQ4PjanOjgZX+rbpNPvvv5n+ ingXwniOBV/ZuMXvYhc17dbbLbTT7z//0/7+K/GT/grJ+1x4x+C/gy3+Hngm3NlceKLZotV1qQKX 2vs2QxbhxvywyCDwfav0Lw6y2nm3GODwNX4XNX+TPiPEjEzwfCWOrU91CX5O/wCB/I74mkn8Ui+1 Kdngn1cebFGG+QTFg7kH3bP5gdq5efQrJbREefy71CAbZiGYsB1PbGc8V/q5glDD4OnRp/DFJL0S sj/JfNaU62OqVJ/E22/VvUzNG0jULm9CWxVb63zMltIfLwq/xk9hmuxttOvdSuY4zZXvl2StJfOI XGnk44+fGOcHHNdc8VRpvknJJ+Z5FPLMVUpupTg3Hulp9/yf3PsLJ4Ru9ZkGpaRZCC/uLaN4dHQt EkMgADDbt3Ek59Bmte70WbRrKze7sp9N1mBpBrVpfOIn8rCGJkTAOCd3JPIxXPLM8Hz/AFb2kfad rq/3XuXSyHMYweNdGXsv5uV8vbe1vxP/1ND9mX4Mx/G74veDfBNxtGk3eoRX16Mr5d3GJAphPPKn IyO9f3MfB74SeCfgp4F0fwJ4D0W10bR9Nt1DpbphrqXaN8jnvk5wOgHSv7F+lDn+KlmOGyKD/dW5 n+D/ADZ/NH0X+HMLgOBnnqj+9rTkm/8AC+X8kjsdU8RadpF5Z2l9Olv9rIVJJWCRjJIGSenINM8S +FvDfjXSJ9E8TaRYa7o95GVls76FbiCRWBGR+B6iv5OpKpS5K0HZpqz80f0fXp069OVGavFppr1P 45f+Con7Ofh74N/tBBfC1tpWkaPrWlyzWWl25VZX/exgCNccP8g3eqjrX59/DLwNqvin4h+GPDum Jei91nxFaW981sjwm1t3dUkY4HACn6evQ1/phwJxNKp4Y4fM8ZK0lRerfVJpfpY/zQz/AILhS8Wf 7Gwqc4PELS32ea7v8r3P7nv2SfgH4G+Anwi8NaF4R0uC2ur/AEuK71fUdgFzfSPl+T6AsTx1J57Y 8/8A+CiGh3uvfst/EKz04SNe/wBmTiBI08xmJt5scfULX8AVc2q4/jqOZV5X/fr7lNW/A/0PzTLK WD4WrZZho2SoySXnyf5n/9X581Hwvrnh2ZLcaVcm1t9qySzAwRWnHKMOWz1IwDwas+GtLg8S+LPD +mRJLBDe6klj9rkt2Nusrfd+Y4Hykjn2r/ZPAZrSxmVQx2ElzL2d/mo3P8ZMbktbB8VvK8YuS9VR v2Tla/3H9vX7G37M3wM8CfBjwbZab4Z8J+INXGlxvqd3c2tvqUkci8FQhBAA47c1pftXfsS/Dn49 fDXWvD/h/wAL+GvDnix7aR9K1Sy0uGxVpShCiXaFBGQvXHTqK/zUzjjXP8Bx7UzKrVlF06zdrvZS 7X6rr810P9TqfAWQ1+C4ZLRoxcJ0VFaLrE/j1/aV/Zf+Iv7MOqTeD/HdvDpssglntvENhL5kfkhm XymXbhW6klgCVGRnOa+YbPw5BNbmV55Liz8hW85Su+R8ZVyMAYJGePWv9I+BOMMNxhkNHNqElzNL mS6O367/APDH+VviFwNieCuIauU1ovlTfK31V9u2m33M4O7V7a4eBrOUqjkrKV2jaOnH+FUJPtOo So6rKqxvmGMAqVA68enFfolKSdj8mxFL3mz/1vh6aG+tXV7d0O4gXBLZJTg4Xrk5Ap+mz3NxrWo3 2q3cUtvMglQZ2CAqFXaufb+Rr/dFNp3P8AOVux9cfs//ABp1n4R+IIfFemRWcmnwP5Us3li1nI3K WZWYEPtXHJxznmv6+P2Gvjbq/wAavBNtrV5LI9rGUWxeUGN5kC/MCp9CCMe1fxl9Kbh+lPBxz/7S Sj89F+R/o/8AQuzydTCYnIG/gvL5O7/O/wCp9afGvxpJ4K8C61rlpKttJp9g92cg4kEYBIyB71+U f7Lv7Zvjf4xfEfXfD175sdha3sixRyHCvGJZI1IAOMkID9CPw/knhPIqWZZHjcdUWtJaH9gZnnM8 DxJhcrvpVT/X/I/V/wAU+BfD3iHw3M2uabb3s6WKvGZoVlVM7T0Oc1/HF/wUJ8GaX4C+Ns1totpY EalczyyWv9mwiK3zeIqSucHJChlRSMgux5wMfsv0Zs7xOB4ung+dqlJO66denr+Xkfzj9LXhjCZp wpRxypJ14T0dtel19y/Q/9f5wm8ISXkEd68htra4vJLWOFYGkuHZBknaBgLk4/pWdD8O/FM0C29o ZZpmfyTLY6TcXciDPI8tVJJx6/lX+2lTijJ6N41cRFNeaP8ADyPAmfYiadDCTaa7P9SK40S80oWm kalb6jFdSSOkUl5pE9gX2HkkMg+v+FZFjPFJqCwL5lv5d19klaYfMhB2k5wOOa9HCZjh8fS+sYSa lDunoeBmGU18qxSweOg4VE9mmmB0Kee1aUz3D6zDctMsVnEzXTqGJUqozkdBwCeDXUR+APGd8tpd 3+kX8KXQRg5tHWby2xgsgXOSBx/OufG8QZZlaSx9ZQfRN6/dv87HpZdwxm2cSayyhKpbdpaL1e1/ K9zVX4U+L7C5U3Gi6pHb3YP2C6FhNdRy9gXSNWdOfUVUHg34g2k0cZ8N6mthJcmJ5JIC3z9N7J98 Dj0zXBHjDIMTNQpYmN/N2/M78VwPxLltP2mJwslH0v8Alc//0OD+DHxm+Ivwf8X6Tc+H7iXS2WVx qVhHMbaJkTCsJMdQyk8Gv7QP2J/GOr+NPh5puoaxcGS7TT0ZkQ7ky2G4Ptmv7++lJleEng6WbwX7 x6X/AK8j+KPob5xi6mDxeR1ZfuqfvRXa71897/eYX/BQ3Shf/BfUZQN6wWkyTQk4Rt6yBD+YA/Gv 4gZ9A1S41i7sHtvtOtXl45a2IO+5KttO3aDuPGBjriq+iXjqGFyjMfbySScXd9lf/NHwf0x8sxeO 4ny6GEg5ScWrJX1vpovRnS+Ivgz8RrDyZE8CeKJ7MwrJPdwadLJBajaCS3yg98Y56GvKL20vtF1K XTbuxuLeZY1lkhniMMgz6g9+K/sXKOIsozqo6eXV4zlHdLda22evz9O5/EOd8M51w9UX9rUJU+ba 9tfuuULi7eFtpQC3m4kYcOg/z/Kq0rP5hlXd9ndQPL4GQP619Bd86TPASdrn/9H4NSS6W8s7i2ka Eq+JYpIlkj2kYOQcjgZ4rTtmtQrIi+Wig7jjAc5OSBjiv96D/nwSu7FoX91FaSRW6GeN5ARFDCHl ds4HOMivRvBvw/8AFnxA1vRfD/hXTpr7XdS1CCz+wQQvMbdZm2kzYB2jnr+o614ed5rhskyurmmL laEIt+r6L5s+kyDh3GcS55hslwUW51JKO2y6v5K7/A/sl/4J4f8ABPfwv+zx4T0Pxt4y0Swk+Id3 Yx3K232JI00uRkXMrHG9n4+UScjqw3Y2/pf4/wDHnh34b+FtU8WeJr63sdO0y2eUCe4S3a7dVJWG MseWbHvjk9q/yT8Q+JsXx9xrVxUHzKU+WC6Wvut1q+qtpbsf7UcH5DgOAeC8LlVNKEKNNc3yX3/q fIv7If7QKftB6/4+8SRRRw29oRDai3O+3ePzQoAb1UAA+uRX3bXyPEuWyynM/qEt4xj+Op9lhcTH F5dTxNPaSbR//9L7f/4KuWMth+014lkIs4be4l3yQ4xfXJcOjuh7qMLn3Nfu9/wSodU/Zt0SyWTc tpa2yhHXEq/Iev0Ixj1Ff2BxxJ1PA3LG+0f0P5n8L4Ro+KGeQXWT/Nn6bykCN8jPyHg9+DX8unxb /YF+Jv7TX7RvxH13wdZCy0mbWblXvrmVbaOH94RuVnAXjOByPxr8w8HuL4cF5xiM3m7JQa+f9M+r 8XuCFx7gMNlMlfVvy0af6HjPxk/4JA/HD4e6fD4iii0nxFYQxpFqUUOoK9w5GfmRk+YP1OAMcd+l dR8Lf+CP/wAdviR4Wj1d7/w54N024iP2GPUkDahNhsZOOe3JP/6v6Yh9JKjLJ/rSaU1K2zT9Lf8A AP5W/wCJXaqzaVKrGXK1teL0el79/mjt9b/4Ia/E/S9Pm1S18W6Pq2qWCC7ih0y8+yw3LIvKmGRS OT6A9K/Gf48fCDxB8H/FD+C/HMC2uvRNP54tQzQRNEwG0MVC/Nk7emdhwPX7jws8b6XHWcSynENK VtNEu/yd7eb22Pzfxf8AA2p4eZLDM8NFuLervdWt16pq/Wy33P/T+MR5jXCKS8XlqyGZcA4PBB+u B+VT/YnmRSkhdgdnlqu7Jr/d2EoqKk3of4BUqbnGUYrU+iP2evgN49+NfjDR/A3gvR5dT1zXb+OI TPAXsbCFnCl5Dg5I+Y4PZfcZ/tx/ZK/Y98AfsxfDzSvD1npWl6l4mFjEmras1jGwjZUG6KDI4UNn LDqfYAV/D/0pfEGUKlLhnLKjT3k09mnd+fZffqf6NfRO8OKOF4ZnxNm1JOdV+7dfZtZb/OS9T88f 23PDmi+Ev2tvhLrfh+BNOa+kj/te0tyIYncyqfMCD2kcnFfuFo+P7I0rDbh/ZsGG/vDyl5r+UuLa lSvkuW16rvJxab72SP6i4Loww9bMaFJWgqrsui1lp6HzZ+11461P4bfCm78W6QSL7T7xRGeqqGwG JHfGM/nWz+y38UdQ+Lnwk0XxZqg/02aV7eVs5DBOAfXqD19R6V4UcBSqcNyzH7canL8rL/M+mp4m X9qzwdtORS/Fo//U/vc8TWlpf+Hdds76KOa0uNJuI7iKZQ8bKYnzkHj86/kl8D/sK678ff2ofiRp +ix6ho/hb/hJpJ5722xEQm90/wBaB8iYjfkdgK/oXwb4zlwlRzLETqNU1BO3nrfbXoj8H8VfDjCc c5plk61Nc0JSTk9+VWaXyd2fr7pn/BGj9mOO0hGsza5f6i1qkd9cwMsIlkAG9kYksMnPJ5roIP8A gj7+yvDBDb7fFPlQuWCR6gIkYHPUYPPv+la1fHbiSpXlUhJpN6av5XX6fiecvAHhmOjjFrr7q/4J geOv+COv7M+qeFNSsfDNtrljrhQ3NneXF4krPMo+UFtmccfdzg96/HL4Z/8ABOX4ieIv2jLz4beJ bO60jwpaanJp15f+SitqFskn7sRORtUnALMM/LkHmvv+CfHfGvLsfRzmfvqF1rvvey3062fU+E4s +j1lUs8y6vllO9JSs9NrNbtaO/S60sfuxof/AASi/ZI0/Rf7N1PwpqGsXksSC51C4vIy4dVwDGDG SoB7Z/Kv54v+Cnf7Hnhr9k3xxY2/gW1lfRfFtrs0jyLky3CFpd6mWA/KGXLoSmBtI616ngd4u51m /HiyrMJfuaydlrpqkt35rVW697HyH0k/B3JMr8P4Z1lcLV6Eopuy1Vm3ttts79O1z//V+YvD+k3D 39q08Ust1cSR2sH2dMu8kjBePQ9uh61/W7+wR/wTN+D2lfB/w74v+KmiW/jHxD4jszqJiv7dEFsZ fvFuCeQAAoxwBX+nP0k+O8Twrw/RwmAlarWlo+2+v3J99baWP8w/op+G2D4nzLF5zmsOalSXLZ99 H+N18kz9AYv2Ff2UoUiRPg54YAhbchWOSI+hztYCuH+JP/BOv9lzxt4X1LSLL4X6Do2oy27myvrX zQ0cmOC2XPXjmv4bw/ibxRQxEa88Q5JO9nZX69Fc/t/GeEXB2LoTw8MLGLasnq7fJuxR+Av/AAT3 +A/wq8NjT9b8FaH4n1J5XLS6hb+fFGh6Drkn3JOBivcJf2Rf2Z5oBbSfBXwG0Sksm7R1doi3UqST g1ebeJPEOPxcsTSrSguiv2/zOjK/CzhfB4OOFq0Iysmn0+6x/Pn/AMFK/wDgmlq3gvUtX+KfwX0O Ky8F3U327VrHS7cSLp5UfdEXRcgFQTx096/IP4P+PvGHwj8XWM2m6xqNpZadq7FYomLhFO1mSWHP yknJJGSOK/trws4lpeI3hz/ZeO1rRi4S9Vs931X3W7n+fHH/AA3X8JPGp5ngLqhzxqR/wys2tl0f /gSfY//W/qx/Yc/by8L/AB40bSdBub2EzW1sunxX8+YmaSBdjAscAglfqPp0/Tm7s9O1ixls762t NS0+8j2TW9xGl3aXCnsVOVIr9R8QOG8TwjxRWw1nFqTknt12Xp5bHyXDOdYPi7hjDZnTanCpBJ7N bL+te5/PL/wUv/4JmDVXufi18EdHstOs0k+2+JNDtIhDFbkDc8qIgzjKg4wevWv5idRsXi1PV9Lu SqajpVzJb3sMIYi1eOQxEEkD+Jcbuma/0E+jhx7/AK18KLLcTO+IoK3/AG7/AJX/ADP8p/pOeH8e C+NnXwsWsPX95dr3/wAtNOqZyFw1wiP9qt545XyVMqlWlXnn3zTdJuo7WwmsI4UggeXzQEjCsTz1 PXGecV/S8U+Vn81yWjKtw581gHUyKuQhPOO1bumx21mtvfXcKfaPPiuNNeRiYYpopFkR5EAyygry vGcGnUT9my8LFqvB+aP/1/vr9iX9vvXfDt/o3hjxjqi2Hh23YW4urO7cxpFGqBg8LAcAs2ME4HbP T+l/wT488FfFTw5atpN3aaxFqFiJRvjLKQ6DHX2P6V/Y3j9wFU4a4i/tbCR/dTbd+uu1/wAj+Wfo 6+JWG424Ujk+LkvrFJKLXpo/lazR+evxk/4Jx2vxD+IEfjXQ3g0XVbfd5NxbyRQ+Ud5bdyDyM8HG ea+D/wBpbxL+0/8Asi+HrWy8L3uqanbxXDWMs3n7kaPd98svoM47dK8vhvifC8VVsFw/nGtrR1Dj fh/G+H2R5nn+QRsnebUemttvmup+VPh+X45ftdfFbSLDxhres67a3etILS0vtQVrW0QSbmmCcgHk qB6semM1/WP+xj+xD4J/Z98Hw3l5ZpqGu6xL9t1Sa+CXLyNhe+P9kD6AAV9746cRU+E8gwvCOT+7 zR1tppt/X/APzr6NHDH+u1XFceZ7+8kp2XMr6pt9fX+rnsnxO/aJ+HvwnvDp9z4fN04J3RWmnb1Q L0ywUgcev5dayfhn+094J+Jt6+n6P4buLW5xmUy2GxVGcAk7dv4Zr+WfY4p5e8W6vyuf2JhYYOWP eEjSWnWx/9D+wH9p79lrwr8ffCN6PEWm2qhLUlnWJbeV029On/16/i3/AGrfhEnwV+KWu+DLTyZN OtpFFjbxMoaxgRVVMgAAAnHTvX+hX0U+K6+Jq4jh2vJtJcy/F/lf8D/Nr6Y/BeHy/G4TiXCxS9o3 GXTVJLp30363OP8AgrrsVh428NrLLbGJ9VhiEN390yu/lRbcd90gI/3a/vI/ZOnVvhH4TVEH/IJi eSQjB3BRuGPYk1j9L6PLh8FJd/8AM+2+hL72AzOD6W/9tPzd/wCCxd35XwmvFUhCsDKrMMRhicZz 3OWXH0NfycfDHwkfGfi/R/BiwtNN4n1qOG5PNu3ldGlDKQQw3A478V9V9GzF/VfDPFYq3wc0vuu/ 0PyH6SOXrHeNtDB3/ickf/AuVfqf24/sH/sc/Dz4BeANK1Cy0y3m8SXdv51/fT4ubqaSTLM7Sc9c 9uOSBgYr3X42fGLxf8O4dvhXwddeIzGcLDbxOyryeflBJ+gFfxbxbnmI4p40xeOx0t5tLySbt/Xc /wBEeD+HMFwfwjhMpy+GkYJvzbiv8kj/0f62Ph5+0j8avGfiCLSrv4a3ei2BkzcvOk1vtU8ZRpUH PTgE19f+I/ANh488Nz6V4rs/t1nd2hjltJ/nKAjqPQjrX6FjJRy3GU6uEk7xaael7pnhU6FPMcvq UsXBcsk4tdLNa/mfilp37Evwu1b9qcQS2VtPpuiahtSwlt0kVHjm3JKDj+HjB/h3d8ZH7jzWOk/D zwhdL4fto7S00jS9tpZwRrFE3kofuqB6A8V9nx1xfmPESyzCYp+7CKdul31/P7z4DgTgzKuFcLmW IwELOU5LbZLp+X3H4CfHr/gr/wCIvhZ491Lwvb6I9xaWF21tJdeSDhkYg/NtI6e3QdK+1/2Tv24L D496bDdeINatLB5YhKIMCGOAMARvOFyOV5x3PGRX3Ob+EWKwPCdPP6CcnJJ6ea7Hw3DXjXlOd8U1 eH6zUJRbWvk0tzlv26/Gf7Ktt4JutZ1/W/C954osX85Lq21GPzbYop+fYD1BHt0OSK/JLwd/wVI8 U/CtrfQPCcv9p+Ebp/8AiX3UaJug3Nt+8QSc4GOmOwHf7fgDw6zTinhCWGzWDVKN3G+m2q/rpofm fEviJw7wh4nzxOCmvaVGlJx1veye2m9799ep/9L+yT9kb4q+Kfip4H07xB4jk3XN5D57Eepx8p9x kZNaX7Xvxe1z4RfDLXPEWgELf2llLLCZX8uDKJnLnrgFhx3z171+r1sno0+Pf7CX8Pn5Pvdr/qfE ZxnVWhwNLP4L3o03US9Fe36H8jPx+/4KHftE/GGHX/Dt34hutK0WaBIIo7R1a2ZWP7xsHOQVyu3/ AGySTX5lXU0t7NNfXMoeeSZiXDfvJGJyWcepP9a/1N8M+D8FwbkkcFho2nKzl92i+R/jf4s8a43j nP5ZliH7sbxivnq/npbXZCWd5tISZQGjPyyLGM5prSm4ZncNG28gAnryRn8a/TpR5T8mt0JZrdxE JYwW243lfyqos7+dGpxjPBYZzUgf/9P4vnuYYYTIYPMaNSZHQcqOMn6dKxlnaWYKgLI8ZdCBwAK/ 3wP+d8rBJHkkxM5ZuBjAVBjGBircDvEx3BNwXaS4B4/GgCOO5t3lMbKVuPvhD0ZemQKdPJMbhZkc RKV2+WqgbsjGfyz+dTKXKBTMUFmS5RzLLwzMSI1HYgeoyac6rIEkRvMUAYYH5TRFtrUcVd2P/9T4 QhR/ObfKNhUbQBjb68/56VakmeM+V99DyB2+pr/fA/55yKS9cyIhT93j5m9PwqdJ1kUQxOmQ3O87 AAevNAW6GTBcSzzzxpCyIjld7EHzfcYP860VRIkeWQgbRkAqcvzjj/69Bg1Z2GfaHcq20hGHAZef pTpdspUxrsCAEqxyc/8A66C1DQ//1fh+KRDcRsVG9YihkPIUEjP9PyqKRmadHhVGYNlGcbk/Eelf 74H/ADvgd87ujAbyDwOlVXjigj2JLL5rHMinhIxk4xz7UGsFoRrqlvb3CW5LGUgkOq7gMDOf0q7G PNWW5dHMbNtMme/OP5ZoKS5VYx9ZhuU0e7ksXhErDYsRj3zP6lRg4A5JPHTv0r8Sv2i3mk8XzxXk FvtHmPbbANyMPLLE4453Dp61+H+P7twBifR/kf1V9FFf8Z38l+Z//9b+JOWd0+d5BPGshHmLjIJP I/z6VWSWFGkEnzgruAbgn2HvX3tb+Izw4PoPuQkkSvAy5EYIUsPlHcH6elFsqQru35GMYwBg1kat 3F1AbI45M7i3TbyMVnszMY9xKx/dDD7xrB7s25kjXtoNxjjQjf28xtoP1qSOCVfMaVCio3Y5U0ie dH//1/4nrorcRW0VvGisAySyM2MZOc+1Y6eYkpgicsc87clTX2B5sZXRqpukARUCMnBA+8azr2Nz EWbJQP5fyjlDWMo8pRFbySDy4RvCFcGR+CK0C7RReXEBIzgqXK/c59akBLeO4eJ0ePcuMEMcbsnj FCWoRzEqMZBzIRyFHaga0dz/0P4nIJdpZVAyPlOeMYqmtuJZwWkyCD8mMBDX0L3Zyt2jc3okhWLy TGS4GScZyKww7wFmEaEAk7lOAopCU1bUgkJuIkk3AOZe4x07VpQrNGzbdxzECJMHbQVdFO6truUK 6AIFG45+XIGeTViytJEIDEbG+ZnJwO1Bi9z/0f4nJotj+ShHkM+XdecZ7Cti10mWZ4mjuVhskXM7 S4Ln0xX0B55n69YSWM62880bKQHQxyB1cEAgnFVnhW3iWMygoybht46igLWIre2eZWAkYRf3exI7 k0QW6eY0kjqxjY7VRuHAoMpRtqXzOkIkeFhEpGGTqAe9ZEU87Xhc3BdF/g2ALj0oFBe8f//S/isc wGykniiWQFgDLK/7yM9SoGazIQxy7uoXoQBwfavfsux55emvrlpFjUskSjDeWu4ewPtWTFcaijS4 Zdok+Rm++309qzlF30M5ondJJ49nnuH++dvGfb6U+LzLO1ZpIlkiJOJmPQ+n16USjZFrbQRUSZFk cKONw/GtRbcJA8zHIIxj0FHJbcZ//9P+KUW/mozRDaYuR7k5odJvKdoWzIq/vEPavYPPMpZZmk+V DAWUb++SPrWtamSJWLJHJKzDZuXOz39qDWmtCxdOu0uTsmC9EOGqt5Zuok3SJhF3Nk8mgsgSK5ik eaKZY4Vj2AqcMxPBqushCFGkL/MT8341i4tAf//U/igtbwESQoQxXqAMFTUV088AKmUnzAA0ZOQv 0r0LHFPczrh2hXkMxAB29GFSwxfIkskrFQPM8sjOOKCW29zZtFS423Urg+X8yAdPYio7ljLIQMtu XCqBkCgRUkhmETDy3Ow53HjFC3MsqDkL5QxvJzv9qAP/1f4nJJ2i8grH5m5sMzKdi59PehZt8hgL iIuM5K+legeeUVTypopgSZN3BU8tjvVq6uxcMizFvMwQqjjcT3NAFd5SYBEIwohfc7g4f6EfnUDz uJfOUfcjwqk4Ue+K0g7aESlZ2RN9piZtkOZFKB5HZdjL03fUVUvrghohFny0XcCDw3+f61oOLbWp /9b+HX7VczvHbwsql278fma3PNNmghkRZQRiZ9m919SB2FeweeK92I9qQ7HIILB1+UCm3eqMCYYI 0KkASykAhe+BRYCtc+UyxMHz5ybXwMEEVCsHyFWZpVXhj/F+A9qrkdgGR2s0i7Ix8jHofbmnpFLy rQ+UinYm0H5iOpP1p8jA/9f+IxSskKmQAmN/LkHcj1FWpLOMxvdRmEwKgjwSN6nrkCvZ5WjzzJe5 IcrtUxFeQFqlzLMzQrwP4Avp7UrX2AsMWRFaRC7SEYJGClSSptVN5zHn+E4wauCT3Amtr5LVJYo4 wZJlKeYedi9zVWMEv50MmRG3I9PSlKNtgP/Q/iNN5NKhZj5YQZYqetVZW84xsvzBmAdMYAHck17B 55XmjO9ldT5IOG28hR2qDMkZj8nKR79oJGAarll2AmvpbtwFjkyqkDKYyKmtZblF2ybSWG0gkEOD 6ipMp6SK140sUsnlogjZR8o6elZ1vK0c++ROQcqeqigUviZ//9H+IMXkLqR1wuXZh29KrGVH/eQu VjfggjGceleyk3ojy3bkIbUxvOzKz7h90jIB9a3DcsceeP3WNuSMP9cVXIzMjigWdtu7eucgN3FQ rBaRyyxZG7qvOEFLlYGdt8x2UqE+faHxinWsZaRkjdpUj4ZyuFXtxS5X2A//0v4hobKRJBPM4Fuz 7YmP8RHUVFc7EnbyVyerHooNeweOVjOHQ74zuzw3TPsapMm9iXYgdkHetIw01A1rOeHyfKYZ28qo HKn1qYp5zpGkh4ByV5xkVUtI2AnsdHuZTvnjEMR+VHfgHn7xHX/9Vat7p4tZIJo5Ybho4fJGFKrj OcY71iNtvc//0/4kpobMp8kCxSl8kI2EX6Co7eZbdZEVkaSTCMznoPSvYPHMi+nuIZRHH9w8lhhh U6JCfLExJO3I8sZ5NRNXVwLUXmW6ygAiAkEgjDNj1q1aXySzgJFCqIhLvJhQMVkBpyzWuxo4oxNM /Duoxs/3T+dYkM6xyzKhcSAlC0vG0d+K1grLUuDs7H//1P4jZLu2AYsRlVPlxL0Zv6VnB7jIkmiQ Bl+Uexr2Dzm0gt4RDMbmcAqozGByVqS8usKjwFxuOeRjpSaurEKejuVfKkvfMkQjzlXzHVV44xk4 pI0+dWB2eUd0g6FsVk4NDU1bUhK75XkUhiTnHQVuWcygoZkTdjGVGVXtzSs1uTKTb0P/1f4m/s4D nCKdwyrDkHuDWfNGFYJGqKw/1mF2hvau9q55sZJrUv2MlvIjh7lYfKcDYhwzEe1S3l7fIkjrcvcQ 3Eex0OEKgdB69qqzexMrW0MRQFxswqso3/7JPWq8IJuZkeZvLD/JtXAx25qZK6sTCyeptPe3UFo9 tFOEidlWUbQSAO/rVAx2+oSNIWO61UZAH+v5PQVnyMc2j//W/iPZ3haJbJUYk5mV+XBHSq0t9iJn jf8AeM5EwA+T6Cu32fc8XmiItu06bGTaCA/X982OwrEnDRrKJht2HgDkmp9mzSNRWsWIIUx52WMm 3KjGVUd6s7Xf5kzhOpNCpvqXzosQ3ZgcFXkQ4JKkct249q1tBeOU3UlzGjl12Rlm24bOScfT+dWo R2HGavof/9f+J7UYIBKsFlE6lQJJGPO8kc7fas57aQy7XYxAfNGQfm565rvcFscXO7jJbcq8KqxJ WTeSDg8etVpFlgkkljIRZmyQee/ap9mi4y5hjztdKpRcSR/fOMb/AMKngk8z5VIjcDBB6A+opez7 ApJq5ehuZcbflaZBtXPLSVmXFpcyt5iqSqtucD5cZ9qz5Ut0Rzs//9D+JC0gjMMks20eX/qo2P3j 71OHhil2IgCiISbgmFDeh9a25InNGTaKsKXdxNJJbTRblwcE4I9MD0rrbs3t3axOzRtN5KxMirtR doxxTskTNtbHPXfnwSiN1yqLljnGT9aZFeLcMcwoGUbfp7570yLu24l2pS6hl3L5qLgL0Rgex/Ok urX7VYqEkjmmaYr5IiwYhxgqffpSsuwNtdT/0f4iLazEIiSeGKNnyvmbgQwHqKtR3Lu/m7iIo1Me GXYrBeBkV09Dg9RmnWuoapqS2liY7iGANdXa9BFHgnJz0xjvXpWm+ELbWLdIn1DS7ebeSovbxI/K IzgEdc+2KyqNKJUIc8lG9r6Xex50sR0q7vLEzG4dZsmWPHlOSf4Mdu1Ry3kas8bhY7jA8t3G5X78 1mJpWui+vifWTaX8Z2rDwVhhBWFOw2j8vypkd8J4oraXcDN8/mYw24jo3+e9axkkrMk//9L+JGew beGMO8BtiqFy35UkVrLJMkbxHykiYbpW2hFAzge59K0c9bHHTXUsx6fbyxLawxsixNuLr1b2Jqf7 HbrJBGyoWjbcCx+T8T2q07o2iruwyK5nNlPYQylI7qbaWMpWKPDZDY71HcSXVtLzIshXgGPkHtxT E1Z2Kq3t7FLbzGP95520uB0Hofw/lXW3fii+ZJfJSMSC0FugLHzCAMED6/1oGkj/0/4mptXsbW30 +zgguEuJELzSTQkTXBY8qD7dh/jVuW++wI0kkKtEygIkY/esT9O/StpK00jmjNR5kfaH7Nwuzawa vausVzaXSQXMeQt4SWYqSvUrtyCenzD1r9rv2Iv7PvPjd4JhjFrcaro2rJextOCJreLhZDjp8wds A8fIK/q/w1ouj4bY6qvtKf6r9D+VOMqkK3jHl8ZbRlD79/1P7hvhzBLonga1hhijmXUFF3EsR2hI 9o+VQOBwDX8sX/BU/Wo9X+J97JbXV+tmszTmIRALDKskcas/oGwRx/eBr4PwAi58b1qr7SP2f6Q7 UeBpQ7W/Nf5n86v7RTXWmaes89yltDNDNFCID+8VPkyH9NxZhn0Jr8etWFzHqd3NeGVpPMyTnMZB 5Gz2wa+5+krVftcJS9X+R+afR3oWySpV76fmf//U/hYF6Z9rKjBidvzfxjtW3aTtbJG0zFPmIEWP mrCd7sziuV6nYW2oCARSshkgdclyPlHt61Zs9Mvor0anaTQXUbIbiGC/dFgQYIwSensDXK9EOLvJ mXFN59tdTxvHDPDOYZ4ZMhyc8lB3Xjr7iursX+zWvnFZCrAeWTxtPGa5puy0KTT0NdJre5CBBG8n l75ZCwUEjsB+VZf+lXbF45QrQyATxx/NsAPasRn/1f45Y7sPdRw3QbfMhK4TEbcEDJ7f/rrIuHk0 5TcRTMk4fCGE/vM9MjHNfPga2lNcSi5ZmjZwFllndQs7575/wq3c3bw3RhDLPD5KurID9/8AiBPT ArGXxMqMnHQt20LzPiVkELkFmI3Y+lLeMsTLa+dIY0J8ljHhSCelRLYTbe5Oujq5tXKM8O/94gba kmQcD88flWvaXkIvhbr+5lgIV/M+RFz0Of6isYuzG2+Wx//W/lp0UWdrLHZiXFxdzbgmzKTEAk4P ToDX9Df/AARF8LzJ8WNY1CESOj24ub+9vIQqKxcqiM3pjOPqOma/GeN3/wAI0492v/Sk/wBDJyUY y5vT5s/ty8PW9zZ6ZaQCeOVfJXykiO6NABgKv06V0bxncoLYcDLjpivziirU0e1T+BIRVwxBYlS3 3fXmrscSJuYZUH8q3vZIsrRypufHPOMjpxxUdyhMe8NuGefauiErINj/1/6D7eJIpX2s7mN9pZ02 s3v/APqq6r+d5oaP7hyilscdzX8jVFe4070WeHfFzToNR8JeIozfXZkm0+SFLKIALOWBBLewUNX8 R/8AwUF0vTtC+IvjXUbyOPVJYGhs2+zSeRLaiKdhkYHzAj5s8dOtezwfpxJFeX6szilGDfU/N/xL d3msaXCtiZIZQN8c+8w+YmMru9MCvPdTv2CQW75drEbpERiyA4GSa/fI6RMqq3NWwmlv7MyOrXCS R5ZWyEYDgZFVHgcXU0+nstvAsKq9mW4DDrjqSM889K0FHZH/0P414oRNBLIYnicSNmNf9bNjkkD0 /wAKXRbq3t4EW0EpNwGmmd4ykiNk5U/Tp+dfPnOX9Pu7i2s0t4bSa5miv3u7cjg5Ygj8sdq51tSv Xmt5tYsm1NL27lYwRxiO4s5C3yKXGSyj5Tk8jP1oMp7kl1Enm/Y5LVoZlG/eq5hkbPCq3QkY9TU8 Fm06LIddvbGS0QzutxaoyRAfejxyeQOCcGpk2miB2prpLJc3MFzNPCYUKXcim3LNgFgVP8OSfyql oeqaZpxulaH5pI9sjwhdqd1J/wAKzWstQP/R/jEt7uGR5bmJZYZJ3O4P8pYdBxnoeKS8kzzMoC5/ d5PJNeAld2OBHQ+Hbj7Y0tjf6j9ghALWks6l4CQoOB+WK6JbxvsU0ViMzCMwveJkrMc42kdBnBrp irsatZjNI1m/8Pvf6bbpbTPe2mFnurbzfLY84QHjrnr6Vw3ibTrW6tjdXU8q6rEMLIqAJc9gjHPr kjrXbQ3ZtvTueJahDLDby7jskkcrmNuUH1r6U/Zb1CC28bWtvDHG2q6oYluH80hnit5YjGSvc5Lj iv0bw8qOlxZgX/fS/Q+E4/oKtwjjof3JP7lc/9L4t+B8kVv4l0OaK8KWGmywW9g99CZzaSQyRzuq /wC63QL2J9a/uH/Yn1hNd+HujzyXkzQahGl7dLtCiN5FB+726n88V/a30koOeQYWbW3/AAP8j+f/ AKKc+XDZjRv1Tt/XzPnr/gpxZWcnwx1qKcFor2xmN2ImKsYolKqGI+7wxGfev5H9Wi1Kzt57WWON La3gVBbxtkMUztKk9eCOnvXX9Gap/wAIVaHmfln0oIJ57D0f+ZwcsFzdxTXEUW2GKEs6AksSOSfp 1rl5Y2torWTTYo4XluFFzGZBG67urYz1GK/rCEtD+MJ07SaNZ9Xv7OC4R54Zf7OYT3MH3hcKWCLg /dJBI/zmsyyvxqmpWTamrzSxSNtdcoqo3VQo46D9BTWsirWR/9P4Ot7W3s9avb2V7R9Kt4mbT/tB YXKsQflC469O+DivU/BhuPFtzpWl6Bo91e6hqd+bK0FtbsZLpyBhAmM8YwSOmfav9fM4xtPLsFVx tV2jBXP8kuB8pqZ3n+GyqiryqSt8uv4H9Yn/AATC/wCCcWl/DDQ7L4wfFjw5pv8Awl+rQrdaPpbW 5L2YfDtI5YZwSeB3OT6V+xvxR+JnhT4QeCtW8aeK7620/StItGkSOSRYTcsq/LHGPw7dBX+ZPHnE OL4z4vq1ubmXPyR++x/qZkWUYHgzhengKMVGNOHNK3dK7/pn8VP7dX7cvij9rjxrqF1b3uqaL4D0 G4mis7WykltLe6CPEIykews+2MP94g5bJGQMfrj/AMEPPEUcnhrWNJFs8EZuWit3nBMt0oRJBLuP 9/OcHpjHav3ji7hmhw94RrBRVqkbSk+7e/3eWmlz8b8KeIsTm/iXjsRUk3CpCSS6JK9vy/Q/onYB kIbkFeRjIORivyyg/Yp1Tx58Z/EnxL1bWNS8MQNcCK2Fk0cRlQNt2x8E4KqMjjG7qCRj+WcnzD+z alSt3i195/RlKUqWIVRLVM//1P6zPE37R3hX9j+8vPCfj3WbzWobKGSXTpby4YT3SDDjMhG3KKcE E5AXuBX89n/BQf8AbBh/bq8ceHPBHww0+6gtYr9bdbzTkeXULk/cWAZUfu3+bcw6KD15x+8eF/D9 WWbw4vqvloUve+a/4Zn5V4m41ZpgpcO0VerVdvv/AOH6H6dfsjf8EdPh1J4A8OeIPjlprtq9/o6N Jo8CLBdfMqFZZvlwGIzyRuxjgdvtKH/gkz+yFAjxReFL6KKRdkywzQxtKPRm8vd+tcHFXipnWOz7 EV8FO1PmaW/RvbX5eh6mS+GmRZbk9DAVad5RjG+i3sr9Pm+5Hcf8Elv2RZrH+zk8M6hFbA5RC1tL s646w9ua/Gv/AIKGf8E2W+BNvbeKvhHY6/rXh5pGjW2gtjfGINGzbJIRtUgOAMp8w3ZxgGvd8OPF bNqHFOGhms26Unbd21XXXte3Znw/ir4Y4LGcJYj+x4KNVWfm0mttO9r+Vz46/Yw/YZ+In7Tvji00 m90PVNN8HaTdRz69qDR/ZtjK4JSRmBKrjIIGG57HBH9IGif8Egv2RbPTLaHV/DWo3+prbLFd3trq BsopHCgEqqrnGc9evpX1Hi74rYiGfxw+Sy+FK7122XXX8ReGPhZgss4Sw8c0i3Vn7zT6O/mu5//V /rOb/glD+yLI8bz+FtWkMMC20B/tBAYkUYxgxkH64zXm/wAUv+CQf7Lur+EtW/4RPRdY0fX7W1e7 066S+DStKinaNyIpGefzr9gwvizxDTxMKsp3UWnu9r+p+f5h4d5HWy2rhKcFFtOzVt7WvY/lh/ah +AHjv4CeMb/S9c8G6lpmh/2wtrpOqXgae0uyz7PNkmUFkJO0hWH8YBNfKFnpl5cfabm+R9zTMTvJ EynsQMdDyeea/wBDuDuJqHFHD2GzijK/NFc3lJb+nf0aP8wuKuG6nD3EeMymceVwm7el3b7tjTt9 EvILSeQO8SuNjlF35UkYXA67umK/Z/8A4Jd/8E79X+O3iXSPij8QrO5sPhtotxHqcOm31iY47+SP BQJuXD7jyP8AAHPzHjDxnS4Y4Rryi/3tROMdba/8HY/SfAXgSpxDxpQxlZXo0Pel5vW3lpv5NLc/ rr0rw/oPhXw7Foel2Vrp2hadYtALbaFgWJUIYue/A5J7V/P/APs1X9joH/BRTx3ZWMcf9lahN9rs 4IWBhRcwRRMMe/mH6tnmv4O4SniMbRzOrVbblTk2/NqR/oTmEFS4jy6NFWSul6e6f//W/v3Ax+df zuf8FyoLPSdG8J6/q1kuoWF5cwaXHaSJvjleQPFux3KF1I98V+meF8uXj3AW/wCfn6M+D8UpqjwX mFSSulF3XzP5lNWvbDS4LKzsI18qY7bV3LFbMgldj55/P0FPgsbYzxJbebqeuah+7gskBaMPjqTj KqMdT2Hev9R6WIVLBe2rPRK7+R/lvicFPGZn9Ww0bznJRS9WkvxP6A/+Ccv/AASqtfHOkTfFH432 upW1vewRxaTZOqG3uI3CNN5DFQ5+ZOpGAMDJIr9gZv8Agl7+xzdSJNe/Dm4uZlA3t/bU1skxAxud I9qsT/tA9a/gDxT8Xs0x/FlaGUTtSpPkWvZ7Kz6bPzuf6K8DeD2Q5Pwrh8BjqadWUVKTWl5NavW+ rXS+m3QuWv8AwTL/AGPbMzLF8MbXy5ovKIaUecnOciTbu/WvlT9sH/glb8Gtb+GOt6n8IPAkdv4n 0vSJWi021t476/1ExpviETuVO4OgPLKOMEgZNfI5F4p5/hc9wuMxVS8Izjffa/m+m+voelxL4XZF ieGcXl2Ep+/KEktm27aLZb7d10P/1/tz9hP4M/EnwN+0R4d0vWvDGp2eqaPrrrpMdzpj288kckZE asuOikKxxxya/sUtQ62tsso2yLAgkX0baMj86/f/AB1z7C8RcQ0cdhmrci26aI/M/B3IavDvAGHy 2rfmjKW/XX+u58Rftz+GPH+r/Dyw1XwBaajeXejXv2jUU0sv9qjhB4YBeSAWP069q+TtB/4KefDX 4J/DeLSfirFqg8V6JaiJLa4dVvbrbEoCPEQGB3KenY9q+U4Q4Znxfho5Tg3+/Ur7XdvTt/kelxPx LR4VVbMcfpRsrNuyuk+tu/5rufgt+0j8dtY/b0/aH0jVP7L/ALF0mBE07w7GYGSWVLy9iV5pRkgq oaNV6HIznHT+lX9lv/gnV8BfhT4S8O63feG7LXfFtzp0V5c6iyhEhkZBgK4G8lemSeueK/ffFnFY vgHgfL+GcA3quWX3P77Wt+J+IeDeBwnGvEeY8a41LnjU9zvbfS+26/BdD9IrW1t7K3gtLWJYLa2i WCCFBhIkUYVR7DFZPiXwzovi3SLrQ9fsY9Q0y8Qxz20mQrggqR+IJH41/IcKko4lVL+9e/6n9R42 HtKTjPVNa/M//9D+sD9pj9g39lST4YeItYm8L6L4Pu9MtXurfV3k+SRwM7H3Bi2eeBX8a97qlv4V 8SeIdK0TVjfQaV4kuIrTUGIngTypj5ZQ45CAAdjlTwDxX9//AEZuIM4zfLcdhsxk5U4NcrfR227a 6+tvI/z2+k7w9leTcU4HF5fDllUheSWzs2vX/hz9dP2D/wBvLxH8Kdb0+L4g60mq6NGibJbjzLGE RbgjRyOoKg7WUruAzt74r+p74UfFXwz8XfC1n4o8M3EUtrcxLIY47hbjy9wBBDDqPfFfkvj/AMCP KM6lnuDh+5qfcv130+4/pHwG41fFHCkMHi53xNG0X3dtnt1VnppueXftJfss/Dj9orwxf2PiTQtP n8QrYSQaVqs0CSEEqcRyAggqemeoz1r+Ov8AaV/Y7+JX7NPiPU9L8T+H30PwxNrUsfh6/juo20+S FmkMUWN27oqke0g6Yr2fo3cf/wBk5pPhvHz/AHVT4b9H/Wm/XyPz76Tvh5HOMpp8RYGP72l8Vluv +G8unmfBGrST/ayJV2xxk7V2kOw/iBH4GuYub1pXlEA+yKIPLRkU5fORyPXpX+hWHd9Uf5mYmKi3 Hqf/0fi6y1COzSNLqyFzIwwJHyFAYbc7c+vOaz5RGY5UMEeWl4bqCPcdOv8ALrX+5q+No/wKjC6u dZos96lpDZ2ywXsn2xTbWk74tySVG0r3zj6V/Xl/wSl1g6l8PdDgNk9gbWFpXtPOEiEySSI2ccZB VuB61/NH0nqN+B1U/vP9D+5voWVn/rRjaH/TuL/Fn6g/HLQ5PEvw713RYbQ3DXuny25VVDZ3pjoe v3RX49fsl/sqfEz4bfFnXfEOoaRPbaBc3jy2Eg/1Uoacsue/CnHOP8P4e4OzvD5XkmOwtaX8VWR/ dec5RUx3FGDxsFpSvd+p+2+uajp3h3wxdX2uX8NnaQ2xEkszhBwmcc+gH6V/Hp+2nreifFT9qAaH o7Le22paiYF1e9HkWemJ9ocs4ccF+hVT7e9ff+AlCq+Ja+Jpr3YQevmfkn0jq0I8PYTCy3nVivld XP/S/o8/ZG/ZU/ZZ0fwHZ3GvWPhjWtevbBXvdWv7e2n1CSYcOxdjgNhV+7jj2r630z9nP9kieVLe 28M+G7ydJC7vCkX2jcf72Afyziv6C4v4s4o/t7Fcs5RgpNLe1l/mfkvCfBPC0slwkpU4ynKCbvvq lpp2PnD9rT9gPwD8TvAb6f4E0SDStXthNNbXenWMcN1KDG23a/qDj6gnpX8qPxo+APin4TePovC3 itbsGK4M9jdvZNEuqCNgPKPGPMBAyO+c+uP6G+jn4mTxyr8OZtUvUV5Jt/P/AIHql3P5E+lJ4SrK 81w3EmS0v3U2ouy2fb9de77H6t/8E5P2CtX+JniGy+I/i7Rvsuj+d/otrd2gkdII9pBkLDA38Hby SMZr+hlv2fPgF4A0ow6n4Y0dTbQKst7PbQKr9hwVwo7cYH86/KvGzxEzDNONpZdlVR8lLTTy6aff bz9T988C/DHLeHeBaeMzqilUqtSba1V11/L5HNx6H+zDdOLNLDwdcyrgCCN7dZD2wCOD9KyPib+z J8GvH/hK607RfBOhwyXlnIkN5YW8SXW4gbHEirkkEZH0r8thxFxPlmNpYjETkkmnrdXsfq2YcK8I 55l1bC0KcG3Fq6s7XW5//9P1b9qj9kbxR+zh44v9b1FLy48Na5qjiBbmDzptOuG2qNrqMGNwBgcY OOAM1/TP/wAE5byGf4QaRcEMtymnwQSKQVc/u15Ze3IINf2/4xcQU+JvDPBZtTVrpJ+qS/Pc/kj6 O+QPhrjnOMmlb3G9vV6fL8j1D9uDTrjXfhTq+l2aySXdzp0yJCgz5jY/dgehJ4/Gvyv/AGBf+Cfs 2r6zqXxC+JGi6evkzLFYvJb+Y6xqQx8vcON56kdAB9B+QcD8XPhrgbHxoStVqOy/I/UOKOBocT+I uGxuKhzUqMPlrc/Uv9pHVPg78EvhTq+s+ItP0a2stLsHhjVrJVeYEBXXdjJ+8P61/FD+1F4/0Hxp 8V9R8UeA7VbXww0TRWllcRi3g1dmcMZEAyU2ggD157c1/RP0V6Gc5jjMTnWLm3Rjpq9272S/F9tD +Sfpi1Mmy+rhMkwVKKqtX0Wtlb/gfefO08ouZUilXZI7qGhQb1jDHBOfQZ/GmXRaF/s90wUplLdA RvkUfxD2r+2U/euz+Eox91pn/9T4dtraRY3ka4hMbHmPd+8HPAIqyI1wQYiwPyqqcuxPGAK/3nlo mf8APpy2tY7Pwn4R17X77SPDfhu2ivdc1PVYUhtPme8kErgYVACRgd2wox1r+xr/AIJ1f8E7tD+B mk2vxJ8fxT6x411MxanpdtqUKBdNBQOjlMZBUsSqnoTn0r+PfpQcdzynI48PYOdqs7X+f/A28z/Q b6JnhphcdKrxljoXs2o37J2svVp37q2x+sHi/wAXeH/AnhzVvFfijUYNL0PRLN72+vJ3CKioCSBk 8k44H8hk1/JJ/wAFC/8AgoZf/tDeLrnwh4F1WLTvAWlRGyitjMYzdkTjEu48FnAyTgcAD0x/NPgL wd/rDxKs0xML0KGvk5dv+B1T8j+g/HXjCnkOUU8mpTtWxElp1Ub7/f1XVW6n6f8A/BGXU0fwB4is JLuO6nj8yMyxcrKy3G5iT6j5q/cCvivF5ey4+xkI/wAx+scHv2nCOXyb3px/I//V/Rj/AILK2osv 2itPkfTYA15G8EF5v2ORIUkIJ7jcoA9Oa/Xn/gkZeR3nwFMpkn86QRAQP80UaI0gyp75LV/XHFs1 LwKy9f4fzR/OPh7S5PFbOn/XU/WKdDJDKikhmjZRjg5Kkf1r49+EXxb8Lab8QfEPwwlhjttbuNTk mV1j2ySybzwx7/e9a/mjLsPVxlGtTp7pX+SP3bEe7jaFura/Bn15eWNpqVs9pfW8dzbyY3xSruUk H/PNeL/FP45/D/4JHw/pviOZrRtYkFpp1pax7VRQQoIABGB+HWowWFr47EfUqL1d7Lppr+SNsVVp YSP1irsml9+n5nsek6na6zptlqlkxa1vrdbiBiMEq1fmb/wUT/Y/+EPxP+FHjj4jXnh21tfG2jaO 99BqlqohkupIlLLv46nGD0zx6c/T8C5xjeGeMMHi8K7TjUjF/wDgSXn1187dj4fxQ4dwXFHA2Y5d i43XspSXlKMW12818+5//9b5RvvD2s2XiDU7NorN9OfUpo4JluCLi3RJCpDR4PPB74x3r6S+AvwK 1v4u+NtO8H+DNLm1O/uykV1vjaUwbio8zAHc5AwOpH4/7RcTcUUMo4RlnMnb92mvVr9N/kf4oeHf BWKz/jSlkjjePtbS0v7sZa3XZ7P1P7K/2Kf2L/A37LngXTUg0eybxteWiyapqLRCS4tGZcsiuckM cnJ7dK+gvjv8cPB/wC+H2teOvFl5AosLKWTS9KNwkV5rNwqExwRBmH3m2gnoM9a/yozXH4/jzjB1 I3lKrPlj1sr/AH26vsrn+vNHDZfwVwqqSShSoU7vpqo/m3oj+T7Vv2zPGP7Sf7XPg698T2UOlWI8 RfY9Ks4388QqJEK5kUbecLgKcdeuM1/YX4YlE3hzQJNu3do1qSv90+SgI/Ag1+h+OHDVLhXDZVld PdU0362/TY+I8E89nxJlmYZnUd+as7el3r89z5G/4KAEw/s2eLLpRuaC5gTb7SbkJz2x1/CsD/gn RdC4/Z40pUiKRx6jNtc/xZYj+hP41+Y0G1wPW/6+r8on6XT/AOSjqR/6dL/0pn//1/749cXfo2qx 85l0+aIY/wBqNh/WvKvgj8OtB8CeHbq50uxt7fUPEV42p6pcxIA8zMeAT6DJ+vHoMe1CvOlhZ0Y7 Ttf5O5wypRlWjUe8b2+Zt/GX4gv8LPht4q8dpYf2k3h7TXvUtN+wSFQevr06etfjD8JP+CuniX4p fEvTPAdn4X0m1e71M2kgkYCTYpO8htvOFVunOeO9fonA/AceK8qxuZSqOPsFsra6Xe9777aep8Zn 3GNPJeI8FkM4X+sa3+bVvw899tD94dPuHu7Cxu5FCPdWkVw6DkIXRWIH0Jrg/EGk2CeLfD2qJY26 3huQsl2sQEsuP7x6nHHWvzZynCo1H0PuHGLep6OOg+lfzt/8FpvBtz4u8SeBJbG0ubu702wjSG3g Rt82ZH3lcckjcg49K/RfCPMo5Vx/gMXN2ipO/ok3+h+Y+MOS/wBv8A43LlG8mlZed7fk2f/Q7jw3 +z/8RNI8T+F5dV+HXiWz0m31WC/N89mRFMiH5SXAwvXgNjOPav7W/wBn+IQfCHwTBk5i0hI2DdUK 8Y/Div64+kdxVg+J5YOpg5XjB2/Bn8w/Rs4SxPCeSY3C4uNpymn+S/Q9K16/m06xaeFcvuCjPQf5 x+taltI0tvDIwwzxhz36jNfyvJe5/XY/pSP8Sx8Rft3fGHxT8HPhrous+FtQm0651DXlsZ54Ywzb cDHJ6DJ6Hjn1Ar3n9njxTq/jP4ReD/EeuXUl5qWo6eJLi4l2+ZKcDk44656dO3FfTVsvow4VoZil 78puLfkr/wCR5eFxs6mb4nBP4YJNfNI1fjlaQXvwf+JNtcxrJHJ4PvvlZQwDCByp/MCv8+74hXs1 t408VxWVl/o48SyXVxdr8iTzSKgYqvUx/LgHpnPFf1Z9Eq86uYUntdfkj+IvphwjTzDLa6+Lkt+M j//R4/4WfG3xR8K9XsNZ8L6xqOlSw3cbTJYlpLS55x5ckHQj5mO4dz+Nf1//ALA37UF18YvB1loF xYX9/eaZZwvd6l5EixQtKu7BJG3AGTgHiv76+k9wpho4CGex0nf+vwP4m+ijxni8fhK/DFZe5SXM n+mp+j95Z22o2dzY3sCXFpeQNb3MEq7klRxhlI+hr+T7/gsj+zr8Dfg3qA8V/Deaw0nxr4pEh1XR YBBIySNh1ZlUBlyw3fNzwcV+S/RkzjNcF4g0MHgW1SqNRnbblbV0/wCtHZ7pHr/S24eyzMOBHmmK S9vR1h32e39eXVn8++o3l4tuk16s96YCsG23TcXGQpKj2/PFQSXMEQKQxSefI37rdyuB6+9f6oWt of5UtdGNglQySS3UKedjbu27Sta9vJEbZpp7mHekuyK0IbzpB1LDjaAPcg+1E1+6b9TfCr/aIR8z /9L5h8NxXF7cW/l2TTWgnVHdC0bRlmUEqwGcgckDnAr9Pf2a/wDgoJ43/Z302DwbFFda9YBXmsLw S+fPYopwImyDngcZPb61/sn4l8J4PjLKpZZWtzLVf1v0P8W/CDjLH8BZ7HNKLapyaUu39an7Z/sr f8FAIPjVc2tt4kvbDS5ZI9rrK4t5s8FNydASCO46dK+7Pib8M/APxk8H39jfaTZa693ZMsEjFhHu ZPvKw7jIIPTIFf51cZcPYzgHiWHslZRaafez1V/Q/wBTchzbLPEjhCtTm1JVacoy8rx0dtNnrbuj 8Mvhr+x74j/Z6/aSbVJLaWDwZqmsSXOmRLLvm09WkDmMKf4SQCACcAjgV/S14YMVzoGnMpLIbFMF hsPIPGO3/wBatvFjP48SzwOYwd/3ai/VHgeBHCtfg3h/G5LX3VWT+TZ86fErxR8DPDeqSnx1Lowl PDjUIw0Rx94EZ571znh/49/sqeH40n0jUPC2lNuBL2eniJS3bJz0788c18jhMgz7H4HnwdNypPts foUs+yDL8dyYmoo1lv3P/9P+wL4q/t1/s++F/DWqmLxVY6zLHZOwt7aRTG+F/vZx1x9K/jm/bi+L /hr4z/F6Txh4Msokhu/9A1KbG8O8BHyRt90oMdcdc+9f379GDg/N8o4hq5njocsXG1vk1+Nz/Pv6 X3F2U5pkuFyfBzUqkZ81/mtvu/FHz58JdP8AO+JPhfbBAxXUIpW+1PtjUpcQuNg/vfKSPpX98X7J MTwfCjw7b+dHMkWmxHHWQB0V+T+NdP0v1/s2Ct3f6np/QnfJhczj6fkj8+/+CvGmJq/wkutMuI0M Uxkukk5EsbQKrD+VfzE/spQw2n7QPgh50F24mFstwzbFhJIJyh6ngjHrXq/R8k14UZhH+7P8pH5/ 4900vH7LqnedJfjA/vC+C9xJN4D0GaePy5JNOi8xegGE447dc/jXlP7Qv7Tvw6/Z9thqHjK4it9w CRibhnLEdMAkgZr+LaWV1s34qq5bhfjnUkl56s/0PzPNMLkmQxzPGO1OEIt+Wlj/1P6d1/4Kxfs5 Qs9xFdpdz7cx+TcDy41XGWc7TgD0rB8Zf8FhfgzpejSpo2nyahrEsDeXbo0gIVlyso+XkfXAr+l6 fgtxBLEQhWuk2unT7z8NxHjPwzDCyeHkpS1tr1/E8u/YS+Ox/aC+K2veMHtILRZNWYRFbozSyKzF 8sD93+EY/nX7S/Egx/8ACG6xkOW+xyqGj4ZcxyZI/Wvj+P8AKlkvFFLK1/y7UUfV8E5h/a3B9TMW 787k/mz+D79ry4s9N+L/AIut5ru61GSbWrhhCAWMEjTPxjsApHXtgV4ro/xH8faFZpp3h/xJqOjW qlWMFhiGSYKMKpbHp+Nf6S8H5bhMx4MwdHFxvF046H+SPFucZhk/GGKxOXycZxqS1W+pia7rHiXx JZmbWH1S7gjm3ST6peNMkpPylsE4PXHTFUNMea0m0+FI4bv/AEyGSK2kZY0t0WRN7j/dUM2PavrM LgMLhMHLC4VJQSdkttj5almOPxWbwx+Mk3Uck23vuf/V/rP/AOCdoWf4UaNdeaJYrjSILy0kiYNH KHQZORweAKt/8FG7RZPgd4gYwo6TW8kVx5ilg8YTLDH4duwr9yxL5fF67/5/r/0o/J8+Tq+DlXl3 eEf/AKQfw338OqbtTnUy3Vnb3Xzy2sRMcQ4AHH8OAOTxXPXVgkb7xxEwGG6YbHzD881/rbhPZ8kO R9Ef4mYmNZNxqLVN+u7Mv5YziPDNu78025trdoytxKYUJ3OwcozcjgEV63N71uhw2V7l9poy0UFq jiNUwzu2/OOhP4VTmjQyDPVeExwKXu8xEo63R//W+G7d5ld90vyvGYtnUEHrmppEMG0k/K6GNSOD zkV/vgf875REQgZAjFwFAOTlj9aeEa4c71QIhDIT98H1NAWvsWbm9aNUMvkvIi+ShhtkifaeOdo7 D1qM2zSxebBJGZowCpl4VhkZ/Gpkk0PlfYinwpC3Q8xQOidT9KpQzWP2feFk0y2hmbzPtCkIig8Y AGf8jpUwdky4xaep/9f4JW5iIWTOYWG5X6DHXNKjCSWTymaSNGwjBSNw9q/3vi7q5/zzlmORUcSy W7zKoKmLhck8bvw61TlsxJJ59ureYo2nDHaoJ5yKYEtkEt3uI90cjRvh2XOM4zU1xcg/IepO0ADP NAWJ13rCN3zorYBHbP8A+qqEjqJFAON5xnGQD70Af//Q+D45GUsFOT0yB1qe3nktZDO8aybVZRGw ymegJ+nWv98D/njcHe6DRpTHDfzXrATvdhbGPZ8qxbTuLH1yB+dMmVrt5kC5WJgsjJzjPvQVBNLU kiiijMYNvHIIu0gJ3fXmqywT273JknLQTMHtbcYIhUDBBPc5z+dJ3toUWC93bWd3PZzJBJBZyTeZ IqsNoUhl545BI/Gvwk/aZb7T43uLNGnt7u3MlyJli2WypIka7c/xZ4P4V+G/SBf/ABr/ABB/Vn0T 1/xnMn5L82f/0f4hRujUQkltp3M+PlfHepFtt7NJ5iOhHy4PIP8AntX3lX42fPxlsy89vEtkoWNF 2fvGmJ+f3FZ6wSsV25eNxlQvOfeotY0U7uzL8cYjV7ZmUmRcgkbvLOQePypg05kZZw6uYjvEe3I4 5qbK9zQiCtKTK4YSK24gfLmtyC6Z4o7UAeTj5gwzg9CazmrAf//S/iGvna2upbaKRJYo/lBUkE5p 9oWt9kispEhwRgE19geVDckuGmEyvA7KDyGThie4p1xdSiLylUjdzJxw3vUy+Ec5fZKaLK0RMxKR qMmQLnb9fagTHy9wYmOM4Lf36xITs7lu11OUyRlyiQxHc2VyHA7e9b0t808ss9ukcPnLwsYxHjjn H60Gqkmf/9P+JCC3vZbpoApmLvuDABST1+n/AOqtJICzbWQIVbDEdTivoXueeW5riSSOaLPkhRtU jh29656OylWQxANIDGXVmO1aQFgJsKpKqhV6ADIBFTNfzZjijwsQPzhBy/Tj2oAsTyedF+6Dh8fO nbjtTluHSEPOkSbFCkZwG7UAf//U/idjfJaRV/ctyFzkDHvWhY3u9msrpQbSdCDKxKmH8O/0r6A8 8zJGt7ony5PtBL+Qskpx5aqccfjUnkKkJieLziw8tcN0zxkGtPZvqBat7GeCARlsrty3941ztwZE x5YKMGIOOKPZhYltBPcfukQE5zMHOAgHU1q3CoqLFCiIUGdwH+sNTysyjaMrH//V/imsbaVPmeHz Iip+RiQmT6YqsVE0rQLEFKvgw9FzX0B5qkmW5bh44ABCqYG15AvDemagsYYpoi0jbpVJGAeBk9aC JvWxLc2BaHzYpZo44ztdol6/U1nhllilsGMhWQBnHQEjuPeonsVGStYjCfZkW3iDkL8xZ+R+f4Vd W4fY6xSlo2A3xkfc4rNt9Sz/1v4yPD0Fo+yS/mESHgNgkDBxkj86i1VtHU3UmnTmRxdeWSvzCQDg /wCRx1r2DzzlbxXIkeNVLIA7djg+1WtNuN0T8bwX2h2GMHH/AOqg2h8I24llgkeTYrPINgJGQPSo rZmLkuQm378YX5TQUWIIVmdlUZ2Nlmz169qatmvnOzFN8blo4SceYB2oA//X/ikiOxjmHEkzYKhc Hr0/CqmqlopEMq7FAwGUZJ9K9ixwyd2Y9xNdXMvmmMhRGERsc4AwM1fgH2VI5AhlkGN6Oco9ZSi7 3RJKJ3GxCqosrExxxjipoWktJ0m8wOuPmDDBDewpODQF28ubowM0zlt5ISMLwB71lIhSMMMKXO5l Pc/Sk01owP/Q/iha4k2KGiBVFztUYx74qotwXkMzoIgi+UTIMEjtXpRi2eddGa98Undtqq2NkCjo KmmDXDozZ88qAVHQGtFFIhz10E/sa+TzJXZE2kbld8Hr6Uy+G1yYwTAQolY4yOACAPrQoqOxDfVl iC1h+z+Yr8SZjKsMOAf8aqywGIPDsJUpmMkZx3qrdATsf//R/h1EashlRyskDDcQOV561t2E9uST I4bfhFZwck//AF69vkkeU5O9yaeBGJYKoAXBQfK31rFls98mAzBW644HFVGLS1NFJMdc2rhcJuDD Cx45qW2Msaxs0YmeBsuSMB8dRirGWZbh0QPGojYvllJ+6P8AOKdHepIsi/fkj77ccUAf/9L+IhI3 Mysigo4y6Ed/TFWZIJI43yY4Y5m+ZT3x2Ar6Gz7HnlFgQMZESA5JwPzpiAiUeQRIxPzsq/rRytbI V0ty3fWjxFXkwpdcqgYFvxHaqTRO8agRtsUZd88DtxQovog5l3K5t9ikk5JGQOuaqtIIE2ozr5nB xxn6frT5JE86P//T/hzM7FVU48tVGR1Yn1qx56+WAjquOWA4xX0Ch2R5nOhIUmkRwCzea34DGetX UWKOHyJHUtuyoJxz7VXJIXP5Gii6b8khj2TKmDG7fu3b1xWVcyQIzHyNoZt2ST+gpODtqjOUk5GV JckjaEB3HrjnFXLaDztqbAGfhcctgVKikB//1P4fpdPSNZIn3BiOWA+72qVNOPkGM4k2rlQBj6Yr 6JQb2PHb0M37NLayKWLqScqp4xU+6V0fzduScKxOAOafIyXKyuWBFuj8yGYrGow/OOfSs2ST7O+5 zlBwv94nnijkZKn3HRyA/NNujLfMvHBHQVJDMLcyhGYGT73YUcjQc/kf/9X+HzzX2KArEdVBPQ+v 44pwuRJE4kjKFW2hv72PX8q+gPD5yqLsNLKCilSu1OMEe9WtsZiDEFXHG4LzQLnYy0ihglYq0jqU 5ZxgAmiJ7m1uIbiAJcxrN+8DjAI70mrqwc7N3+2Jr2U27jyUK4G0/MMe9ZV/e3PnqiMxbGxcHAx6 1m4NBzvof//W/hyvPMZIBFI8csTb5fmyJTnoRVrftgjlKg5bLLjnP+RXsHgOT3bNOUQCzwqKHlBy 55ZQe2azbQgJm3aNfLPztKwyeccfnWkYJq7F7XzOx021t9VaWCa4ggjMRbzpeAMc8Y6k1yup2FvY zS/ZrmWWEsMb49hHr39fWoaV9CueRPAsKW4lW4aN4TvD4+RvZu4qmkryTPLIQWJyPVquEU1qNTfU /9f+HPyi88kiR71Rf3o7RHOM1LcoJIFG9wYud4Jx9P1r37LseE5voFuwdhBLn5xw47Cm3srK8YgW QRRjy18xcEkcE/jWUkk9Coz01HxGeONI43ihyf38zdxnOP5VXlmkYScZXOAQMe1SS5u1ie3i8qN5 4gjuseFjkIwSabHNcqPuBVDAzBOqjp/n8KT0QuZn/9D+JG0uUlDCN5VWHmMSDhs/yqvO6XG3c+Jt 2AQMA16LPFi7rUp2tq6zNztYNg5HAHrVq7nbyGXdyPlGOjVrHa7CbsinaxyMzyBiU2YMZHetR7SH ZHKruJSOQq/ugfQ+9RO1yYXFubcw27lT5s5XoCPlrBgaS3nRvN2k8gL94EVATfQ//9H+IF5l5lhL pcKfmbGN46UW1nE42klhu3SsfucnnAr0W2fOt2OxbUtJsora2OnRi4MJiW+CNJI2e5fOB7AAdK4z VbUO+5N2134LD1pCU11CGxvLRtsu1AUB5POD04/z1qVJ4YpCkoYQno4GQWxQaxnZaFWdRdTRiD92 wOME7lx7GrgtZ1QcFZFbjacbsdDWkI21ZstUf//S/idsJZHe3tzI2Qcs0oz06j9MVq6lbWEwJ8yM XkSZgjdiA/rwO4r0nzdTz7WM2BZFYrLDGcpgNjBzUGoWhhg+1SR5VTiJfU/T/PSklqXF20MGOVCG dreZpePliXJByOorQnkg05Dm2aV5Y/MeVkZfKPovrVcurJ6EEQmGJWjInGGh3DYUz6/nVv8A0tJ2 aSZnMkYDgD5T/wDqqLCP/9P+JKdBu2RkgJGJGYjKtVBZJJd4AY7jtBxxjpXW4a2Rwc/Kix5LwSr5 UREhAHJ6Z9K2BrCeWturBZEYIAgzvb/Gp5X2JdRS6kU7vmR5o2lVvlI27v0rKDxJGbjy3htUBEb7 DtyP6cU+V2FzxRNB5axma4IuEnXekhO0qSMgilMs1rF9ot7eRrZ0ZPNQZDHHPzdOhqeR30uJ1Ydz /9T+H2yt3uEhd45wRJ8sSnrzxnHauxsryDWJX02ezto1jzvHlbBtA5wx/lnriuxU5NXPJ9vBO1zS uEtdCe6vLGaewmudO/s940gMkVyv8QJx1wSf85rj7a5tnwltKLm4n+eNJ/3RQjsOP6VnKhUk9EQ8 VTS3NuQ2+nwPcXdri6uIvMaRd0iQYwOGHGPrXOzoJmDNa3DsSrKRGWVg3QjHJoWFqvow+t0bbokj s72aGUWMbTDlXKYAXA5QnoG46VetdNvd9uI7K5nuEhEvkbCsiAgct2H410RwlfZRIeNoLeR//9X+ Ma1s4Y4GululuZZZDFAjOAN68Mqe4qxoPhTU9TtdbN+7WFzaSh7eIQGVpoSfvY6j8jmvZpZPja7t Cm36K589PN8FQ1nNL1ZUGheKbcj+z9DvHDAyo09k7mRAcZKAZXPYtgYqO48Ma8zzXEujahcBmVRa QW2XjOPmBUHPX04r0KPDObVNI0Jf+AtfmZz4kymkryrx+9D7HwF4pvpoLePQtVaSbLwRx2RmIyeF JU4BGeh5q8PAni+zuJLa98PakBuMSFYFDKR13qWBX8eK9CHBWdyV1h5W/rzOGpxlkkZWdeN/maWm /Cr4gT206xeBvEOobpl+xXkMUbW2+QkgMwb0Bxit/wD4Ud8Rm0o63ceFb7T3tb4WsgubGYsoUjdu YLt57ck8dK7YeHnEbSn9Wko99P8AM5Hx9w5F8n1mPN8/8j//1v5G7b4E+PxrFhLN4c12CG/8v7Pd 3dgosrsMvHkDO8jpkkY54rRuv2cfG9tDPf8A9h3TRC/MEOoXkJS2sXbso77SOfTHav1eh4W8RYio rUrPpe+v3Jn5VW8Rsho+0bq6Lrp/mj6Y+C/w21/wo0A1C2DSeV/xMJonEDL0ONp55xz161+z/wDw T48O3mo/Hi21K10u3uYfNg8+QRjzYEDAspbrjke2M1/RuByCrwn4bV8HitJKDb9Xf/hrH884HOFx V4rYbG0Fde0Vl5K3/Dn9sdtZyaF8NpZ1iSa40vRP7Rg8t9saIIh8g+gr+PH/AIKS+J49b+K2s6Xp uns1jYavGt1cNdbZklRWkZVA5Zd0gPp8gr8f+jrRdXiyrO+iTf52P6F+kdiI0eD3Sa1lZL8Ln4Af tbT/AGPRma5WS/sIdP8AMi2fuygaQFkJH+1nqc9K/Jy+1VLuVwRNsZ/m80fveOgx7V9B9JSf/Cnh afW1z5D6PtHl4clPpf8AFXP/1/4U7aIO+QxxHyvbFdQ1iUNrc3EhMRALM3Le4xWc1oZSvc7m0uLe 3jcNAsjKoCKVHklDkH6mqzmJkxaTNArZQwgfKQeTXLJWdghuVdK0iYayl7Oxexiw94CNwlUdBitW yj1yRb6adIhA8zvaWsbBl8pSQpI7E46VyTWjRUVbc17TStPe2uZ0lkhllAKLEOFboxOelWdNs1tJ LmaFiPOgCT72wrhTwfr9KwLP/9D+OkWEl29lq0t0trYWTFWtE2+ZcEAg7s8471Xm+yX1wZ7KON4c 5jK8Ie3Ar556K40m3YdCsk9wbVZI4QpBJkcRrin2yXsct6l79na3S4/0SSLq0YHf8awNVBI27GQM JkWJcFCI2c8BuwrLF1eW80L6lbpcD7T5ZiThoYweG9//ANdYylcdkdmk0MNrFKRHsDM0Cudrg8jk df8A9dNkZLqKQRRQ/wBoth42kJMRA6rgfjWXOhON2j//0f5P9NuGg1XQXuwRGbpI2ti5DuDkHZ7/ AEr+tP8A4IY6DNdaF8QdZuLl5YH1tLaztjAIlZRcKoKOeWwEYY7bDX4nxtUistUHu2kc+Ig+Sy/m X5n9eWhFjZ2itCI2it1Qr1C4UdD+FbUnU7Rz3x1r4GmrQSR70UktBsIQzFGB3D1Gc1cbqVLAAdjW /JpYoz3UBmAxjODjgUwHaNjHAzz6GtILZAf/0v6Fy0cIaJm+eQZDE8iqEc7pJIGV2Vh5aOOHPav5 Gq6bDgr0WedePLPZomoSAGaVbaVo7Wc/uXHlsCm4YPJ/ma/jG/4KQaV/ZHxFvWk0ZYdQZFldtOjF 1bXYkcFYwxJ4T5ct/D3r1OE21xFSa2/4cwqO0oq+5+S2qlriExuHh8pzdbFBKg4wRn07fhXAJevA 10YrOKY36+VIrRbpHAIOR3z8or+gUnZGlWKRs219b3WyHw1FDP8AaY0SW1MuwQSL99cjOOQT361Q 1LNlNJKEAZF3yIzBc46j+daGJ//T/jQu9QkmgM2n5tngIKz5IkJI5AxUEEriJnlcLOw5PSvnznNS wv5raeOZl/dgfKS2PMbtgfrUzQxW+oWl7ELgB1Zp4G/1eTkBh6Hmgxl8THxXwcxyyRL5MdwTbiVN shI4yVPI6cVJdLBKktwUBeUZkwNzPj9TSsiTndRtbUPFdM7yQsipJDN8iIBk/d/Hn8KzkfRp7U28 VjFNdS3QeSQZBIXkAjoAMDk80WV7ik7K5//U/jQ22UzeU0ZgiY5MSHd5I9AevFWLnStOv4beCWYz JbEeUxGwnHTNeDD4keXGf8xpXmlwzWdpbxu5e3fz0aFMYyMFPp049qt6RH9htGt2NxBdGUSLAV/d OOzf7wyfzrqpotNM6COOKVxJJKWnjG798gyD64xXnuqS6XMrxapNcxQw3G9pbeLzfu5xg5A68e3P 0rqoL3rGkJLlaPGdVEctxKsMUiKzYVGGSB2P4/1r1/4CsmifEbw9qUZ0v+0Y2e3H268FuAhAcYzg FtyYAHcivvODpez4jwU+1SG+3xI+a4siqnDuMpLrTmtN/haP/9X88vhFdXFvNa+YqzjUF85Ls3Qj h08yMn7zceWK/MB7nriv7c/+Cc+tvdfCzQtOnRGu7fRYHvJW+ZpTHlWYH6kH86/t76Qkfa8IYar1 3P5y+i3U9lmGaYbtb8zU/wCCiGgp4g+DXiy2SzlEtzpsytdRDnDIIyVI5yPlOP8AZFfxya9CLLW7 t9Vee/sdOhuLaxtoYyLlbgMVIlTPABB/zmvN+jFX/wCE/EUb63v+R8X9KWhy5tRq26W/9KPPIr+C 4gktpP8ARDdTFbcqcli2SwYe3HNYOs6DbQ5kOoOLmKQRS6ZFzdbWQssjLnIBwR9a/sKHwo/iSpF8 7GmDSNO0o21wlxeX10o82xjnAyuQRHJnkfTP0q3qVlpNnPaz6HcXPm8SLZTx73jLYHlFh1HJ9DwK cb8/3F2uuU//1vz50yI3l/dpd29zcSRIZo4bePe7PnAjAPHOSPb6Zr+qP/gkX/wTktrWw0v4/wDx Wgaea9s/tHhrw9chCLGOQqVYpjKM23Jxg4OO9f6L/SD4nlw7wY6VN2qV3yr0W/5o/gP6LfDcM346 nmNWKccLDm/7el8P5P7z+jHxX4o0PwB4Yv8AxBq7NbaRotkXaO2iMj7Y0O2ONB7LgfSv5BP+CmP7 a3i747eNl8H6D4kvPD/g+3eUf2Uqy2Mjwq4RYgSACXG4sT1weOgH8geEGT4fN+LKVTFvSHvJPq/6 6eZ/WXjHnFfLeGakKHxVHZvy/rz/AAPylubebTkgSNZJIdu9Cz8uSSDn15zX7z/8EQfE8tv4w1jQ /txNvPqhElpMMyW8kscjqqZ/gO3Ax0wa/qPxepJ8B4qCWyX5n4p4CLm45/7cn+TP6l+3NZ66jZvd SWMUkbXKD541Iyn1FfwI0+R2P69a/eyR/9f9qP8AguBYvpV54P1oJbztd3osLcSMXWMzfeLRA84I Xr3r42/4JaXnwQ8KfEG58R/FS1gsZYo7caS960ctvaSRvJ5jOM5XkrgAZ2yj8P6q4UoYyp4N1ng1 +8bkl+R+O5xUwtLxFoRxT9xcrfre6/Q/r18K+KtB8Y6Pb6z4cvob7TpkHlyQcKnAIGK+Uf2n5P2g PCuiXfjT4YeJkS00zDXGiFAWlQckgEHJ4PA/MV/NFCmqOLVLFrZ2Z+vYyU44eU6T6XPE/wBlr9sX W/FiX9t8Yr9NMuILg20E8lq1vFIw2nOT0OCRjpXrH7QP7XH7OWh+DNW0DxB4p0vWLjWbZ7K1037I 12GkI2qwBGNykjpyOfevdp5FjK+YKnlqbWjuunXe99Dz8RmGFhgVLF/aVmnrfpa3n5non7Jfh/wf p3wutfEHhPTrK0j8V3j6pPPbWot2uFYAxA8Z4Bzz3PtXofx38Y634C+F3ijxR4dVG1fTbJpLPzIj KisFYglfTKjPsT9a8vFe1rZs4Yl3lzJP8jurKOGwS9noowuvuuf/0P1p8K/8Fd/jbd/E238Maw0M unRawbCVh5dn52w5lA4wxVc8DHNfvf4N/a3+COu+FtN1rVvH+gaJeS6ZFd31nqF2sEsTMuTge/XH B9q/cOJvDPF4HA4XF5ZBy54puz7+r+R+fZJx5lWY0q1LF1FGpCTi/Veh+HP/AAVk/a9/Z7+KPhC7 +Hnw5XTPF/iifTLhx4is7AstrLCMBVYqPmDMnUg8ceo/nN0d2u8m6W8hKR+ZcrJFiZFTgkjng468 9a/qvwMynH5BwQ6WZNptuST6L+tPl2sfxL401cDm/iBOtliT5rJ2VrvRfjv8+9z9Qf8Agnz+wVrv 7UvxCs9X8QaPrlp8LtDlj1W41G/LW2n6ku4AJtKhiVZXAAJzntyR/ZP4E8DeGvhr4T0fwb4U0+30 vQtCs1tLW3gjESAKAC5A4ycZ9q/nDx34xln+fRyvDzvSo6Nef9fof1Z4J8GR4W4b+tVo2q1de2lv 6/I/Gr/gpn/wUV0r4b6DrfwY+Eus+b8Qr6Nba8v4Ed4bYNJsYBgpGxcMSTwSmOlfkh/wTV8ceMn/ AGqrG48S3U2t3+ubLvUvEV3u+SbzFCx5AA5C5A9E6YFfXcDcF08B4X4/OsarVa0Xy+SS2+e3k79z z/8AXSeZ+MeCyXByvRpXT83bV/n6q3Y//9H+/ZSSOcZ745HSvwy/4Lb6J9t+EOh6pNam9TSr61lt Iig8uMmd/OOfUqmP+Be1foHh5U9jxvgJ9qi/Ox8d4kUFiOFMfSfWLP5Wrqxs/wC1pI7iBbyMN58S TIYvKX+EkfX+VfZ3/BP7wFoHjT9pfw/o2vWdrcacy/abgSjdMSGQKPxXfj6V/pBxdjquE4LxmIpO 0lTf5H8AeGmT4fH+JWAw2KV4e1vb01X4pH9y+lafYaVpthpml28Vpp2n2kdpZW0CCOKCKNAqKqjg AACuf8XaN4i1m1ig8P8AiGTw/Mjl3njjDmXjABOCRX+V9SpUq151qzbk22+7b/4J/pjJJPljsjH8 K+GfGelXTTeIPGEutwlAqWwi2opB5bJANej/AIUt3dE1OV6W0P/S/stvtR+F3w4+Os2q6zHpOlXl 8v2W1nMSpMs84zuA645xkdM+1fYlrcw3lvDdW8iywTxiSKVfuup6EV7mNo4pUKdevflaSjfyJw8Y rDtw2u/vucd8RvH/AIa+GPg/W/GXiy4MGjaNYyXVyqR+bLOEQsY1XoSQD1461/EF+3b8dvAfxl+M mueNPBukyR2d3esZIRZpbQ3Co7RR7UB4+VN/PUnn2/oX6NmVYivxTPM0/wB3ThZ9rv8AVfqz+Zvp M5xRwfCEcvv+8nK672WvprbX0R4h4F8eyeF9UtfEFjot1b3VhGjWshuFHkner73GOnyjAx6Y6V+j 3gn/AIKvfH7T9T8OeELTxFdT2811b6ZbxJDJHHCjsIwXkGAWJIwOCa/qXxA4DwnFeEqVsZa9KLau r6pP/Nn4D4R+JNXhTEYbLKcLxxFSPM72tdqPz2R/Vj8EvFV/40+GHhPxJqdyLvUNS04SXk2ACZFO 1s475BP41o/FfX9X8L/D7xTr+h7RqOk6VJexM6hgoRSWOD7D9a/zaxtGFDO54daRjNx+Sdj/AESx cpPByqQ35br7rn//0/d/j5+2/wDtB/FvV/E2i+K/G+rQ6bpfiM28Gn2bxva4jf8AeRvuUqwwwyMY /Svzj8QiG31d7WymnvRNcG4e/v1VXeR2MkpITAwWZjwAM+lf6veGHDeAyDhyhDAw5faQUm+7a/4c /wAo/FvinHcR8TzxGMlf2bcF6Jv/AIB11t4iR1gt7K2KpEiW94ZR5kD7CpyAw9QOOfSv1h/Yq/bP 8e/CPWfDHhNJ4n8KQWgLyRXjQtAilUdHj6EZIwRgcduDWHibw3R4g4Tr0KkbuKbX3H0XgxxliOF+ LqFHmfs6zjBro23p/kvU/q6+E3xT0T4qeFtO1/R/NHn2yNOrLuTdtG5lfABBOa4z9ov9mr4cftKe Crzwj490u2uFeImzv3gVprRxyjbuowwByDkYr/NbDV8Tw7n0alCX7ylPp5M/0f4lyqlmuV1suxC9 2cPzV0fw/ftc/BKL4FfHTXfAtjINW0223y6ZeWiPPBFGduU8w5zzkDP908nFfHV9Ek2oxtCQLSCN hOCuC0iv90fhn8hX+vPA+YVM34YwOY11786cb+bSs382r/M/xR48yxZJxVj8sjtCo0tLaPVL5J2+ R//U+ILreZW/s2znu5nyQu7Koiglvl9QAelWrKKa6tL66iZZIrZF+0RPH5cwBxkhWwSASoJHTNf7 oWP8DINctzX0c6RBc2P2dZzeG8SZxJ+9hJDBgcDngr+Vf1X/APBIPXri88GaVbyQwW0qRFgofe0R W4cOh923hse9fzl9Jim5cBTfaX6H9q/QuqpcX4td4Jfifup4l1W10bRbm9uUSSOKImRW4GOp/LFf Bfhn9ubwbq3xduPhVp1nO2orcC0KszNETtVjghfRv884/wA9OHMgr55h60qL0pJyZ/ohmec4bKsy pYev8VWXLE+mPiT4Ib4peC9Q0+7eSKzurUyiLJXqD0wQfyr+W79qf9mNfCnxon0vwY2sa5d+LLtF s7G/hYWOnTBk3NHLj5fLY7wGJOehwBX6Z4K5/DJ87r0a2kJJ3fax+aeNXDUuIctw8aSvOM1Zd/8A gn//1f6T/wBm/wDYT1NPAujf8J74m1o3j2oS4jecmTDLkkkFSBnoOfevrvwJ+yx4E8CeIE1fTvFG qSvFGIfsk9yphfswPOf8/jX7BxVxNHM81xP1aC9m5Oz/AK8z5rhfIpZTgMPTrz96MVp/Xpr6/M+x haW0GneWih444SiDj+7gc+5r+YH/AIKbeGH1j47fDsx2Ucen2+pPb30sajYpM9vKpY+rKs31wa9D wcrSocZKd7e5P8j47xrw9PEcMwU1e1WB+9H7IFto+mfCTRbLT4Le1aC2jjmihjClyRlmJ754HHpX zb/wUr1DV9L+E2rXOkX1xYXS6fNJGbeQgl1iJjLD+7leRXkU71/Eu1XW9f8AU+i4gSoeHk3RdrUL q3+E/k68AftBeOtI8Z2fi7XfF+p3elm88hFF1JNAFBKgsg7ZA4xx6V+zfgP/AIK66b4L8L21vN4f j1UadY+X5bRyC5faMCTphcnGAa/sTjXwkw/ENHDrAw5Ukr206H8V8HeNeJ4dhWeNqc93Le7X4H// 1u7/AGpv23viX+094nsZpNJ0vw7pmn3r3tnbte/aEu/mBiEw6bgFHsMdOa/pF/4Jj6jdz/C6wXUY UW5n0+CZUim8zypGHzqT3AO4/jX9yeMXDlHhbw1w2UU3flav6/0kfyD9HLiKpxNxxm2cT/5eXf4n 6c+JPBWk+LIFt9VgFxATuaN0WSNiCrAkEdiorK1aKy+HfhC/l0e3SL7Lb4ihRQqs2Gx0wB07V/G9 CvU5YYRP3X+dz+vvZRhOtXe/6WR/IF/wUR/a/wDiB8QfHPinwPrlvbR6Lot8dP0/ShO/nXisVMk7 DoIwGU7SDnAOT2/HXVdz3Et0I0T7QwIVThV2gLwM8Y4/Kv8AVvwP4fw2QcEYWWHX8VJt9+n53uf4 5/SD4kxXEvH+I+s/8um4r7r9elrW/MliKqtvMrBmGMMec49atyyLbNL50tvPOZCm8R7/ADEPpngH pz7V+0n4RBXjZn//1/hn7JdtLmGCR43bJZR+7Qe5/pUn2yW2mWKNNtwZBHbsw3AuT8uAPev95Z7H /Pzy2auf0Sf8EZ/hB8IJPFT/ABB+IX9l/wDCVQ3Uk+jJqrxpmaNfL5RzkBSoIx6gGv6tEZHRXjZX jZQUZCGRh2II4xX+WX0lquMq+IddVv4UbqP3u5/s79HnDYPD+FGVvC/HKlTc/XlT/U/Lj/gpb8KP jx8SPhjqw+H3iJLTwza6TNHqejwkK1wGQ5Z14Y7gGXKnPzD6D+QXVNFGlX9/pWu6fHaT2eoPZmAx FoY5VYgIM8nGOSffPt+qfRpzLL45JWwMLKupNy01d9vWyt+XQ/DfpHZRmFbi7B4+bfsLRUeqVt/T VPT59T+kb/gide+d4a15JYorSbZIrQQrtiZt3BUe6qD/APrr9/a/nPxjiv8AX/G/4j+sODLf6oZe l0px/I//0P1E/wCC0GiwS/Hvw5qV/crHaQ2zmKEqZJHnALxhR6HZnn0x3r9Hv+CNd5E3wRvtPhlk ljs1TaZjmRSZGLL9BuUV/V/Er5/ArAPs4/ofz3wOlDxZzhd7/mz9lun8q/Ejw3PPaf8ABQa7hnlZ bN9YaWVYWzhVCxAEH1MY4+nvX4ZwgoqriU/+fUv0P2fHcyx2Ea/nX6n7bAY/OvyJ/wCCnkEiXXws uoSYJ01JnSdv9WQm7I9sHFc/Cjtn9L/t7/0lk59Hmy+cf70f/Skfpv8ACrzD8OfBplKmQ6FCzFDl TkE5Fea/tX28lz8BPiFFEwVv7IJbdjDL/GP++d1Rgnbiim1/z+X/AKWY8Qq3D+Mi/wDnzP8A9JZ/ /9Gp4O+FPin4p/EjU/DHgzRbzXdV1vXpNKspYbd/s9lEZCpldxwSRgj0yK/r5/YZ/YY8F/ss+E7D U57GK78f6jpyf2hezjz5tNLjfIgdud+WYHpt5HPb+3fHfj2pS4awvDeHn704R5vJW1/T8D+Pvo++ H9HC5nieKa9Oz5pct+vvP9T6y+NPxi8H/AvwBrXxA8aX0drpmlWzSRQFws99IASsUY6knjOAcV/F Z+3D+254w/a1+Id7rF1Le2HgbQitroekQzMtsitITuABHUbecZ5684rw/oz+H/8Aa+aT4qx0L0aP wXS1l0f4P7mnuV9J3xE/snL4cK5fP97V1nZ7R00+af4p9Dxn9nzUrex+OnwsaKBS0fiOJXDSbRHn G36nOK/vt8HOZPCfhqRiGMmh2smR0+aFD/Wq+lXSazjBP+60fT/RfqKfBldr+dHzL+3VZm8/Zp8e qAXEEKXLRgZ8zYHwPbkg/hXnn/BN5Hi/Z+tYWkd1TVZHVHGPJLM+5R7cCv58wyvwTWT/AOfq/KJ+ 7xX/ABkU3/06X/pTP//S/vo1XjTrz/r3f/0E1k+El2aNBHnIjJRfYDtXpX92xhFb+h4t+1qxX9n/ AOIoEaymTRnhVG4Vi4Kj+dfx2fsuWOp6R+05oYvrWKGe18RM8MsS/uQJZPn2984bHPSv6c8DbLhT PL/yv/0lH4D4jxv4jZHJ7K3/AKVI/uQ0Zt+j6S/97TYG/OJDXOeJc/2hojg42X4AOQCc4FfzI3ep c/fTtQMAD04r528U/CPwz8QPipYa34t0i21q00CzWfT47yDfFG5UrgH67SR3xW+DxNXCVfrNCVpx vZ+uhjiMPTrpUK6vF7r8f0P/0/7yNV8DeD9Q0qbTrnwxoctqtuYooRpkMfl4XA2ELkY46elM8C2E Wl6GmnwRGGC1uZYoI9u1UQMFUAeny16ssViK8XGtUbV76tvX5+pywwtDDp+wgo+iS/IseMmKaLKR 2ccdM+3+fSt/Tjmwsj62sZ/8dFZ392w1Gzufmr/wVLLw/ArSZY4oX3eJoopJJfvRj5WAT3OD+VfT n7Huf+Gefh3vcvJ/ZK+YSckNhc/4/jX22J/5IWgv+nr/AFPmcv8A+Snxv+GP5I9X+LWz/hWPj4SK zp/wid8GVPvY+zvX+fR8S9Ngn+KHjQQXsk81rqZs57VYDBa2yxs4Ppljnkiv6W+ibJQxOPt5fofx 59MCjKriMtsun4XZ/9Tuv2Sf2SPEX7T/AMQNO8I6DY6pBpX9owrr2ozQ/ZtOhg4eUpKRkHaO4PBP Ff2i/s8/s/8Agz9nb4f6Z4I8J2yFre3RdR1Egma8cDkBj82wHOM8nOTjgD+0vpP8bRxuLp8L4aV1 B3l+f5/kfyN9F3geWR5JV4gxMbVKySV10/rXyueCftz/ALcXgH9kHwFcXOpSz6l431mIWugaHpw3 3aNKdomc4IUDkjPXHWv4nvjb8X/G/wAVPGPiPxv4zv8AVtRn13UGuY4dRl+1/ZI26KoAxu5x8oAH oK/QPom8DLB4OtxbjYe/NWp36J9V8vwZ+IfTE45ljcdh+EsFP3IO87Pez2a9fxi+54XcyGS2e5tA GZWCxwzHy2OenHP8qyLWV1KvcKv2hG3f3kB7Y4r+3U7q5/Cco6egy5WaaVnbC5OV2jaDXQ6BbwX9 2lg0EslybZpFiQgOWXHA7dO3NEn7jT2NML/Hj6n/1f1m/YB/4Ju/Dj4s+BrPxB8Rpb+6jliEi2cU XlS24kAYiQHgMc4x25Oc8V6d+25/wTW+DPws+HOo+IfArazZvaQRfYiHjjkEqsM7iFyw2h+hHXnO K/vLPfGXMl4p/wBm0W1h1UUbXfe223+Z/C2G8CMro+EP9p8qeJjS57tbvdu+rv21028z8B/htrut aR8ZPC+neFNbm0prjxHDa6lbWzbY5jHIpkMi9PuIyk9eR3AI/uG/ZTMlx8KvD01y/mTPbBTuO4ou xCMfqOfSn9KKlho4bAYmklzySbfy6nofRFq4ueDzGjWk3GLsk+noeI/tPyQad8SvCAjUqzXqSyFV 3ZKOnDfXOa+7fCZDeFtN3PszpsbeYBtB+Td+lfyrmkr5HgpPfX8z+ssjSjj8dBdGj+WL/grhr+sW HxI0iOG81SG1ZLu2W4tZClskryRn942epXcAO+Pavyw8PaX4q8W30GkeFTfarqN/dR6U1tLf3UmX KqWYkfL8uQc9sH3r+6/CrA5PR8NcLjcWo6RvJvyVz/P/AMScdnlfxRx+EwkpcqqWS+duz32P/9b7 B1f/AIJnftJa14Y07xLo/h9lmGkJIUm1VjZvIF3OPn2khjwMj061+VvxV8B+OfhZ4hHh7x/ob6Lr KyMz4dZoGXeyLgqeN2Dj1Ff64eF3GGR55mFfAZbZTg+nVL06o/x/8bOFs9yiOHxuap2mla9+vb1G /DJLO/8AHXhaGWdLWe3122u4ZBKEmcpKvyY7huh+tf3qfsjDb8J/DjvbvFKNPjhZg2Y3AHB/ICvx X6XbX1TBrzZ/R/0LIv2GZPyX6Hwl/wAFZ2vYfhNqt3p8Ek9xZ6fLIqSY2NuBXJ/Bc++K/lk/ZmFz L8ePAMpK3Mw1xJLktuQIciSUYPORg/ka7fo+VIPwxzGF9VGf3WkfG+P9GcfG3K6lvddSlr53gf3m fBa4gn8CaLNGHRJ7JHSPH+rG0Aivw+/4LJ6bdTaNZMlhc6lfG6S2sUgjkcxOwY5yPVVP4LX8zeHc 6VHxUpVMQ/dVWV/xP7F8YaNev4V4qnhrubpwtbf7J//X868E+BfFPjfxJaeGfDGiXLalerHaWlqb JjayGRwkhaQKQAnzMxPYGv2i+G//AARZ8S6x4NsvEfiTx3PYai0AuJbeCIiVvlztddv3cngA1/p1 4ieJWWcJRpU8PaU5vZa2P8xfDvwqzvi+nUxNROMKa66Xdv6/4Fj6N/YD+C3/AAoD4q6/4Jnuzdan /aDyedJENgVWKL8wOOQQfxNftv8AE+UnwJr0Nq6if7CVTacs2QQcd+4r+N/EjHSzbi6nmUl/E5Wf 3F4a4X+z+AJYG93T5o/cj+H79rXwZ48uPjj4suIvBGpy2cGpy21reWmkTG2ud21zI8u3b947ePQi von9jL/gnL4n/aI1D/hIvFk+seFdPtnNtaw2Za3WQ4w0jZALZBICg44r+1Z8fZXwv4d0cRTqp1o0 0uVNN3t28u3/AAT+AMt8M804x8SquAr0ZRoOpKTk4tK17/j+W3Q+5P2hv+CQvwl+HfhCXWR4y8Qy Gyssz/a7qBLQsVOzjjB3gcnPX6V/OlrXhqHQfFbaTPfvqEdlfSxFghilQQuyx5ZTzv2j0yD0r0vB fjnG8a5ZiZ4uOsb2f6eZ4XjTwFg+BOKcPg8LL3Xb+vwP/9D+qT/gmbrVhJ8FPCVtFJZwq2kxJbQp ONkYEe0qozxt6Y9MV63+274d1zxz8L9X0Hw6HudQuY3soIYYvtG4upAIXvg+lftmey/s/wAUq+Jq 6KFVy+53PzWlhlmvhdRwNB/xKKgv+3o2Pz0+Cv8AwR2+Eer+EZdU+KsOsSaveE3VxDa3SaZHGSoI zHtwdvUbs1+Sf/BR79j74T/s76taD4VapcXsv2j7PcaVPrMV85DbdzeWoByvzHOOA2OcCv6u8JPF 3OuIuNoZNzOWHdo2buraL5d1b8j+E/HLwSyrhPg2PEFGMYVk22krNvV69/n30PyCSRZZS2CDv5BG 3bg4Oam1Er9nSdxySUjHUSlcHge3Ff2sfxBypysipFdEW6yt8hOAR71cHzQ7WjYz5DK275V7dMf1 oIP/0fhFZAr4YfOq8+5pEL3DlnZg0YIjBPy/lX++B/zzWVrFmGNWhkklGydffKkelS232ZY8M8nn SNmOLaT5n+GPT2oBRUdipcqrSAP8qqckdD9KikuORGoYKpwSOAeuKLdBhKZCN7RkOg3RHuw9v89q jt2W6s54b2JAJk2NE6hyoB9ex+nqaSikrAf/0vg0R20MPzEFANiKMZz2GKW2cRnzVJxuAKHgAZ5r /fC1tEf885PJcK/mHkKPu8Yz/nNMtWhhY3DrM7P8myOTy0wcZJ4NAFdysjvNEvlKGxyRlvenW5Er YkVfLjGSxbDE8UAPBlaRxsaFMnahO4MOxqm42M6nkE885IoA/9P4MgmwoURkx93GAc/WnibcCrDg fgTX++B/zzmgHiktY4REI5N3+twdzdAB6cVnX6i1kiht5jJIyebJsBXaOnP1oGlcnRm8tQTiU/w9 29KrvcbVbzUcSx43J94j1GKCoxumZHiG6mfSLplheNIbdmluVOI0BGFDfU8D61+JH7Rrzy+Jb3UV ljeKK2aKNJTtiY7lUEH0wBx7V+E/SFduAK/9dj+q/oovl41n6L9T/9T+JowqY0j2cup/eAfIuMcG qUUaRsYpFxtOSR93Nff1Ytzdj5aEloy9HMFIAxJCpwUPINJNcv5hmWNYs8bEGEUe1Jr3bG6kirNc fKXijBYn5Wxlc9802O534jExWT7rYG7NYm6mupowwhOFYElM75G49+az5J47aZm3kyI2FiDYV/U1 M4u2w+aJ/9X+I2JYLi5eV48CQ7nAHJIHFQNHKuHKbI0clEZcNivsLW0PHTtqjZsYmlh37VYu5Cev HWq+oxT2ok/dqd+OmGYfSixLmhNLvPLSRbhY38yIxMjqC20jHT+X0qldqkkAt40REQknAwzD0FRK F9hc6K7wMYVDMUWFPljx2rSs4rgQxsGjCSH5FzkgZ/r6Gs2mtxqcT//W/iseRrZBA0QD4Lo+Nrc+ 9UI5nilMhIO0/Mh4zX0jh2PL59CxI6SzNcxvuidQrowwqYqFt1vMVmchTGJNp9DyMUuRgpvqVJZw 7AqnyMduT144q1a/YkiPnowdhwytyMUcjHzrqRmb7PI3lKXXqA57GkmaSZI2iiQ7mIl3n5RgccVS guonPsf/1/4mra6SIPC0QVW4QBcgGqss0r/KQsZWTZHsXII96+oUU2eRKpZWZetLOJIyfLLB+ZJC MAt3qW3hmilaRmBtx9wDlgadmhxn0NeEyzRON25gflwtZb6e0knlSqrOoy2OqZ7UiufsW0t7GHzk 81YpFgHmHBJYelVJXE0saLHBDbRKFiETEvL/ALTe5oMHOzsf/9D+KmTUPsgW0jBYyKZGkK7ljwQM A9ieaypJ1icyKdzuc88V9LyI8RTdzRllW4gWJ2/dj5srwG9qkheCK3l8kCNymF7k4qXB9Byk0Rfa rh0CiVkCpteAcRv0+Yiqtxst9koJMh4wvIOamUbbkc7BZJWLrNGDCygKwHzD1FTW8QikZflEDgY3 deOlTZbGyk90f//R/iqYiVHgLBUxg56OPSqyR7SkSRrGFP3h9017jUUzyuaVrk1wjhSzbVwMHHJY DtRpiI0ReWQBN/yR9CfqKFyM0i20alxbLMpCqQ2MqQMCuTkllSZ4VJDI+CMfeqkoX0He2xu21vL5 DPC4iLDLCQ4RiB6/nWE7zxsrNJ84JZn3ZCn0FHLHsO7P/9L+KSO4+0RRqN/nRHJlXrjHp61fZ4rt FEw3RRKEQuMSHHPIr3ZRSV7Hlyk07IoXV3A260+yInzjFzuy0i46benXvVJ5BK32QIU29JBwDUyS SWhPNIu2sYtVM8fM9s+URlDA478/54p9tJBOC9xHgMerDvUFq/JuOlcTh0UFTnYpxTYUSNXV5EZw NoO0HbjqKTtbUyP/0/4q1MERY7t7Pwu7+CquoeW8bFo97gfK6n09a9j0PG62OWjgSSQ5BB3AqWPA Oa24beQMVx80fzllPzY+laXjbbUyTfNa5ZWZnLQSMCFO/OOfSqFzAshCbyFHzMQMj8qzFJajWiKi Py5BtXpGeo+tacKW88TxyuwlZSMDqp+tawTTdxH/1P4jV0oW7uEnJDjPlMM7x3zVRopC6tFCyRI3 ylhyMd6+gPnx81yY2DEFmxhfapZrhlEMeV82SMPsA5TPrTUWzaHwiOPOhRZpQm4lCFJDt9D2qPzZ 43WEKRbooG/HPp1rTkTNYya0EEieakhXIifILfx1Kqh52Zcr5j5YquFA96FBIpzs7H//1f4j0xBJ Jlyiqh2uO+fb86Y0qSx7s+c6naqMQGX3x6cV9QeeQ3FtceQHGw+b8i7ui1PaWy+WyWsqefFhpA4w JMdhQZT3GXEtwVdlCjC7cN95ccHBq5DfgWElnDApjZPmkkXLqT1IP50EGbGsG0AqxLnaGB4pLjTI wqSBDIg53H7oI9KBWd73P//W/hzWMMxjQjyyc5AzzV+HTHO/MazQuMblOG/LrX1B44jWV7aN5mGW I/KjB/0Iot7UzrPITuKMPLz1J9v0oFfoJdxmJlFyNr7dyZ6mqDM06gHJbOFGM8UGTleVySzt0N1G 0gL24PzLnaWGOgq4HW1ldkDD5yIwOSq565qeRGjkkf/X/iK3zzMiptkVzmQ9No/z61sW7+TJGh2l MA7j1219OlbQ8OUrqyMfV5GlvgIY1MLcDByR+NZ7W6zSbGUxjvj2pkdLFd4GjDrHuEe7BBHPGaQI eHeMMqEFS3QYoENCG5ufkbaAOV25AHrVxtNwUDyHYT97bjA7Ck0mtSFzX1P/0P4gfscvlv8AZ2Le VyR1JHtVJWeZTCIiEVzlmHz5HbNfSKCe58+PtbNo23THdjlfUVtxeVMggY7WXkcZFNwSQbFGSSKC ZVaPev3XAPDD09qieaRgfLhaG2BIUHn9ayFe+w2GdAyuxxs4Ixyfwpz7JiuxSXYnZk4YD1NTzRYz /9H+IBLNkBLI0jNwR3/CoCtzFOUMSlYcGQcFUz0z7+1e20ktD5qbd7Fi4tLkyfZlD7HQOEbIKlue nvwfxqpb2qSG4gbMM0B2uh+8Mf04rRL3bEI1sXcUUcUZEKIOZV6mmRwTXEY8192CQWf+P3FZW96x utjpvDAtre8mglgS5m+zmVIJVyCAQNw7cVp+KGg1BsWFnbWl35YjgDfKgcdcY9fStkuiC6P/0v4i ls2W6uLUBvMSFZLtEG3efb1GRUF5BNEgjjXIYZZQMlfc19EoSZ89dEdvp97KA0CSS3DxsdqjLFUG SQPbn8qsafG8ji1uABOPnxIcMmPapdLyBNdxbyybz5lRWCQpudwNyE1X1G3a0trSWRVzKVUJjDsT 6j8Kl0n0Jc4rqT2Gl3N9cvawWskk6QNclFIDBEUsxA74AJ/Cq5Mc0mYAfLK+WUI+dyBzms5Up7WJ dWK2Z//T/iDkfy4I/KIWIttfplj9a1IrdIImnlTeIl81QRyPTFev7CptY+cjiKa6l+ys31hEv7Ff NDP5MkSc8gdPr2xVPVtLKboFQxSwrukBGGVhnKYrVUaj2Q5YqmlujPtrKYRQzMswV1CqEiZg7HgK SO/bFdDOIrG2ufMZC9vIsVxbRsGnt2YgDeg5B5o+q1H9khYygtHJEFxpF1b23npJbyiWTABl2vGM ZA545/z785DDN/rbqy8plufs7AKDIhB6sOuKFga72izGWOwy+0j/1P4oE0/yL02WpGGI3aZtGZxE 74XODnpTJra0ispXheTzYSU8p0KBznAwcckn0r6ank+Nq/BTk7dkz4mrnGApr36iV+7Rof2TNDY2 95PbyyxzJmBPLbcXGfl29QeO9QvpF/c2UPnoRcyyg2dtMDbomTwrE9/eulcN5rLahP8A8Bf+RxS4 iyiO9eP/AIEv8wj0jxZdme0i8Kz3E0NwLWWUny1dduWMbnhhg/T3qdfAHiCVbk3WnTR+URsSKQTC IY43Y6H2r0KPBueVlzRw8vmrfg7HHU4yySjLlliI/J3/ACIbfwP4nt3RpPDWt5bvFZtMqenI9R69 K6iHwX4pupREdEuY1fCiQr5ckeByTngV6NPgPiCeiw7/AA/zM3x9w9BXeIX4/wCR/9X+Nu4+HHiq 6t1aw0e+SaLduRo9tySOhUZ5JI4x61ow/Crxw7Wbt4Q1uW7uCYBFJAsVxEV+9kE8Gv1+PhrxBPam fkVTxO4fpL+L/XzZ08nwV+JN4tlb6b4G1maa6JS2JVFklYfeCpklsewI96wrP4N+O55rmz1rw7qV jNbz+Ssa7GnaUEjYY2II9MGuqHhVxFJq9PTvr/kcc/Fvh2KbjU17af5mv/wo/wAYLfzW8PhbVI5G hRG8wJG6uDwrDOVzkYOK6m5+APxUmutMS48ILpu2AqsOoYCXWPfGN3OfxrspeD/EdTRQ+5Py/wCG PPreMvDdJa1Pva8/P5kS/sufEG6itRewxJdSSyS3CRQvCI4wTtjVSTu443ErnsD0rRs/2bPiLPKV sdBsbsMVskiunMNxHI+QBg8kH6Dmu+HgfxHNJ8j/APAWeRV8ceHoStzr/wACR//W/k+8Pfst/ELU 9c/sO+fQrFmuHEqx3DzRLHGGJHm/d3fLgKMmteH9lnxNNfQ6cjSRzXE5WPZaNthQEjjI74PJ9K/p Sj4EZ29Kqfyiz+W63jxlG1KSt5y/yOgtv2TvFc7nN5potbaTZObixdvs5BwHOHz+AoP7IVzaxTSy Xmn6pIbjz57jTYXtp4FB4KxE5z1yR9TivapfR+zB6VL/AHx1PHqeP2DT9y1vSRrD9k6R7SOfTNWj hc3YjW5vY2uHlGOd8e4Kqjvxniujn/Y9v7lUtbbUdLur+S28mSOB3HmMR97yydvHJwpPvXp4f6P1 Tm/ePTza/T+vmefX8fouPuLXyT7Pu/6flczrz9ifSpLjS7fUvFNpNLHZ/vjbieIWsmMFFATBIx0J FbU37Kmk2sZ0ez1BrzT1jSMTzQuszk8P8gXg9eM8+te7R+j7g0vfab9ZHkT8fcTJ2ipfdE//1/51 9I/ZI8PTX1leyxTafp0Vy0IuIZI7WKXYoB8yPbjJPUsCcMOuOcW+/Zm8D280oAuprK6ldnjjuXee 2Of7xA4br8pHfgV/eeF8BcopP96l+L/Bn8HYjxyzGqv3Td/kvyOrtP2ffAd6tvZXtp4gaC2tT9je yu13tNgKofch+XHbJPWlX9l/4RSLIupWt5PN5qNb2jToJouf3rSMI+M9guM9zXqx8DeHt5L/AMlR 58vGXOZLRv8A8Cf+Rrzfs+fDizllsrbR7s2a2Y8uO8u9r7DhsBAuCDkEZz9a27H4D/DkaVJZ/wDC O+ZcPL55ln1BkeCIAYSNVUY6e4FenhvBzhzD6Onf0SX+ZxV/FXOsR7ynZ+bb/wAi7Z/CT4eWlvd6 dDoyR2kkhmhgiSFrssQB+8uChZsY9D9e9Uv+FUeB7drpbTRzJcS7fs8k8giNuF5IPlhS/P8AeJr0 aXhZw7Rtak7L0/yOCr4k55V0dRfj/mf/0PxYtvhp4J1G0Nzr/h3R4t9msEMVpYQWcqlCDvJ2nBOO SOTmucbwboVvLb6pa6NZ29w5a1hkhtI54VhT5Aj7lJZh1LH1r/T6nwBw/Td1h1f7vysf5oVOO88q OzrNJen63OkubJLseUsdptnt0s5pF0+C1cxAY2Hag6c1dXwv4Se3cSR3UVzppUWDSJA8Sxjghxs3 HOfXHPNd8OFMopLlVFfdfz/Q4qnFmb15XnWf5eX5FJPDeg6clvKthEJIJHlt3aMJGyt/sD5Tznrn rVO90bQJrO4+x6VBeXkKo0NxDD+8cswZ1bd3UHHTt3rqhw9lkX7tGP8A4CjiqcQZm3rWl/4E/wDM 6DTfD9tZaHK0G9i9yGW2hlCxknA3svbqcH0FQ3mlPp9pcWMqR3S3KrIRKPtEKkEN3yDyK7IZfhac VCMVZdDn/tHEVHzTk7vqf//R/HOALqFhavJcWklraTKILKCMK6yRjbkEDjpjg0uoS2uoT+dcu0DF 8pGil1LY69eCccmv9Z1hKKex/lh9eqP3biaRp8F3dlm85f3m1pm6MT069a/XH/gmPoukz/FU3UFk WuNDC22qzvKywzeaX8vCZwzDOeOnHPp+Y+K9sPwZj6lPT3P80fr3gnThi+PcHCsrpXa9VZ/of1me JtRi0X4e3/NybaTw6Lbcq5JaSMKmB2x/Sv4mf23L0yfG3xFJHegXmgatdw6iqtxPJcCBomYeionB Pqa/nz6NNNyzzE1bdP8AP/NH9F/SWknw7Spt/aX9fgz8If2q/Fdxb6ZqUMd8i2d3dqdQMsW7C7wM jvxk+3zj0r84bsLPdiW3LPGzAqSm3d74qfpG1+fP6FO+0X+LOXwNoKjwxzWtd/oj/9L+HG0aGM+S 0SiTOWG3n860L+MzhY2YxLH86Ffu59MVMvhMt4ts2LO7uPskUV/KjJaqfs6qm35W559TUkcohVpZ VwkhyCR9we9ctToOD6HR2pg+ytEZiwnG5ghyVB//AFVSE3782nmMIm4Z1OCQOgzXFU0uaF1bv7JI DAvm+WwJil+7Ljsann1O2vo5LaJ3tbt2GDCm6CLJ6Bj19MVgB//T/jetJJ4HhjuYzcRrwH4x+IzU t/sHmzWxWELh3jjHAA/hVffrXzsvhOiwsXlT6ekxs3VpP3n2l8iVgpIwB0xxRax3lyjiJD5JGTuB ZkA6n6VzSla8QGxx3p822hmCzAkjHGB2PNaNlc3BWV5VAlhUCaR0yq4IxtY+p9PpWMtIsTaW5o6p Y31uILnVQbeOb/SLZ2b/AF2QSOP6Cm+FLqW3udRkuYLiW3ukUW86L5scDITxjqM+o9axWzFzapI/ /9T+WDwjolvc6nb6vqpk8+2uBcaajwGQqVVh8ozxzjscV/aD/wAEM/CcH/CkfC+qahHKl3PrV00x VcrdGSdrgFx0AG7Htur8I4zalg6eu0l/kS0pzcfM/pysrf8AcJ5I8qJRlUI+bHYVNvKyAtXyVNLk R6t7NFiNf3vmbTyPlI6VHMZY5N+0MHOCDV3NSMxsPnzweoPSmSfO2GAAI+Xiqi7O4H//1f36Rt8w mLbnXO1H521MLvyGJmcRnO6N8fMpr+RKz95F03ak0YPik20+kukztJPc5jgYHZyQzPnPqoav5E/+ CqWk2Nv8Sbp9KtPNjTT7jS/KvWa0ignPlx5jkGTyDuHvXt8KrlzmDPOxcuWpT9T8F9Qu7wLJEAFj tg0LFG3s7JlWAPfoa5x7W2v44tMEesRXc6ho9Wt4dsUYIJYO+MDOMfj2r99hrFHdWVkkYa+Fz4Iv xbaRq0uoapLE169nCMXDBhnjgevUcc11XkH+zXbVYBM0mGxJyYif4Sa0buYONj//1v4urxZJb4W9 vOljaopXaq7oZWx94nk9qsDTpt4tGO9ygdGc7Y5RjruPFeAld2OckazttYuNIntb11On3zi7gClI QUACkHqec9PSug1BL5LeRTKHnU5tdoJi3EgAt3wO/rimo3lYia6jAlsbdhLOJLsOBKif6sAjt+NS SMkSxShQsCDDgEnGMDkUmrOxkQ3CgQz3CwW1zHtB2TSbCoJwdvPvyOaDo+m3dta3Gmxx219Of38a uI4wF7YPP+NIUou1j//X/jLS2NvdX9vNCkc1o6hirtuYMuRkHj15Gen4VTN20I2RqZJC3Hl8qM+t eDD4jylC+51tjdPDbJNNMQVUhogMjNX4NamMqTRwvci2+YKqZdj6Cu2nHZByuxXi1O8W/VtqZd/3 0cwyU7gEc/SsHVN0dtfx3cUaWlyxO1kyYiCSCPQdfwrsoK0rFxVkeW63NA/ktBKzOcDzl7qBjg/l XRfDIsviW2k+wWeoC2nia3W4i82aSUuMbPQjGQfXFfWZHJUc1w030kvzR4+cU3VyyvTju4v8j//Q /MT4NyXfirwZpd6bSXQ7qEwWOoWXmCWaF4iNpAzna4QkHv7V/ZX/AMEqvGS6v8PbK33rPcwWB097 jBU32X27wD0+6uccZr+6vGqm8V4c0a/LqlH8Vsfy19HSq8Jx/jsFKWk+bT0d7/jY+3/2vtHN38J9 euZJW3WttII41PzDKHP4dOvpX8SfjG4vvDvibxIL9zdfZtRuC+owrvN3KbiRZN0Y+ZSpHJI6c+9f FfRfrWq4ui+yt96MPpW0eXE4Wa8/1OD1Ky0+GC11K2ngmuZ4/trbcqttkng578ZIrnHj003Op6mt q8dxqUqfab3zHaScoMBgc9OSPwr+16burM/hitHlmZlppszaq6SpdMqSLP5hAEt0G5CKefmxjBI7 Dr0q/aNbRT3S3VndJOrl7aUP99sj7/rx9KadptGa3R//0fizR/EMNpqOl6taFJEkkxmJQBDgFS2P Uf41/Sb/AME5v+CjmqyXlr8IvEt/babYaJp8b29xqc6Q293AjRxfuTtxjvgsCDkY54/0c8d+E3xP wzCUFeVFuX3/AOVvxP4H+jFxVQ4f4vrYDFO0MTFJPzj/AJ3/AAP6QtJ8Q+CfiFpKNZahpXiCxmRf MginW4jyyHKsAeRyw9Pyr8f/ANvP/gnBpXxHTUPG/wAOfCGhxTWllLPcxQQRC8ReXfytxBB+VcbT jIHrX8McLZriuFOI6daT5eWVpL+v61P7a484fp57klbCSV5Wco+ttD+WLxN4d1jw/r1/4Q1icSX/ AIe1GeySA2j2d0kCzMIpJ42zgkFVO0kZHbpX6p/8EdPE89l+0RrdhCLWNW+y/a1lgImiZT5QaNT0 287uP4u1f2bx5VpZtwFXrU9p0ubTzjc/mbwMlPBcfOjW0aUo6/Nff+p/YJ/Ccc5BPr1r8cP2+v2s /FX7JHiGXVPDWnR311rMqC1WQ7I98wLLu4PAVcADuPev4j4Vyqnm+e0MsqfDUdmf1Rn+PnlmXYjG 0/iim0f/0vdvEfjP9pL/AIKFfFvR9D1LUbnXZ7zVvs9jpem2mLPw/CA2JSBwCSQCxByfTt7J+0Z/ wTg+K/7OngmDxxfSrPoo0pbq+ntF83VdMktwssm6QEDJA5GM/KOew/tnF59kfB31PgvDpKMlZ+vn 5vrfV+Z/NdPJc8zzC4niavdyu7f8DyXlsfY//BOf/goH4h07+zfhZ4og83QrW++xWmsXTHLw+VuD OGAYEeW2fvfXmv6FrHxz4B8U6amdc0S7guYlaW0u7qMH5hwGRjz3r+fPEnIaeX55KrgVeM9Wl0fp /SP3PhTHzzDh7D1cV/EtZ/LY53xH8DfhV4p0a+sZfB2hr9uid4ryytxbzxyMDslV0I5BwRX8zX7d H7EHxM+EniTUPHFnbSal4Nvr5pIZ4JmnuNO3uvKkE/ITgEHBA9s4w8Pc5jl+c+yxj0mmk30dv6+4 5OLcpqYzBQ+r6OEouy6q66H9AH7B1+17+zX4CSS6+1S2dotrKWx5ilYo87vcnP617X8d7Y3fwl8c QYY7tEk4XAY8YIH16fjXy2bJR4iq229p+p9NjYtZfZ7+z/8AbT//0/NvHELaf8QfHVlDvhbTvGF8 Y2ikZLiCNpnQKWGCMhWU4681jaj4g1J0vb+1hLlVS2itj58869isQyWyBnp6V/p5kVPL6vDmEnik v4cN/Q/zZz7GZxRz3F08E5WU5berOVub+aFJbv8Ase80m9niWWK1ktDbGeJD+9eVmAw3AwvUjnsa /QL9hb9jTxB+1n4z062httQ07w1p88V54n1RYVSxmtwxk8oyNzkBVBVR/wAtB161pxln+D4b4QxO PoSWkbRt3fz7I6/CXhvF8a8dUqGYwahBuc7/AMsbeXVtJ+Vz+zb4SfCvwx8HPBGkeB/Cloltp+mQ BGcKA8745Yn09B0A9K/Mf/gpD/wUL0X4H+FfEPw2+GWtNe/EyW2W1vX0u3+2NpgmPllA44UjI3t2 BIByDX8HcG5FjOOuM6WFab5580nvZX6+XfyP7Z8ReJcFwTwpXxiajyx5YLbW3S3Wy08z+T/xP8S/ E/jXxDqfjLxprlzrviLW4IYHmuLVbVbNYt+I0VeDkuSWPLEZNfTv7Cfi240v9pjwBA17Kkd1elmi ztglaNWClj6Ay9vSv734tyajlvAtfLMOrQhTaXyX+evqfxv4N51VzDxGoZliPjnNv77/AKaH/9T+ +vTHMunafI2C0llE7EcjJjUmvyc/4K+aHJqHwATUopXA0m6W7ubcfdnjjkBx/wCPEfjX2nB0vZcW 4SfaovzPmeOoOpw5jYLrH9UfyseCvh94i+KviXRvCXh0NqOs61dJIghtPtCRYwztK69EGV4PXPvm v3l/Z8/4JrfE34J+L/DPxa1a+t0tY4YpLuJIo4Z7RSvKlVYvznIyBg9+9f2b4vcf4PJMijkPNeda OvXS3Q/mLwU8PsZXzz/WqvFqFOXu36vqz+iLSJGl0rTJHyXfT4XfPXcY1J/XNfNf7WPx7vv2e/ht ceM9OsLe/uIXyY7k4TapUYA9Tn/PWv4ZwGF+u5jTwm3PJR+9n9eY/ELCYariX9lN/cj8gIv+C3eo SXNrCnw4t5IrkBVnWGd4d3K+x5I+nNJr/wDwWU+Id5pN+vhr4b2NrqCp5djI9vLNPM+cZ2FWUY9M Gv32p4MYfCUqdfF1mk7PdJPy2/X5n4pLxXli3Wo5fTTlG62bs++/c//V+jLz9qP43/GT9ozwTr/j vW5pQ/iSGa4sI0ZIbGESqzpswMMoHPHUelf2dfD28j1DwR4WvI8lbjRYHywwxOwAk+5OT+Nfv3i5 kuByXLsuw2BXupW/D5n5v4YZ5jc7yjFVsa25qp187+n5HzP+3zaPdfsu/ExYjiVdEmWM4PBaCXnj njH5Zr+Gy/ntYoL1rWJbtLTesg/1LzuPmcLu5PJr9O+i9FtYy380f0P58+lU2oYNPblf/txxV5qU sSpdJNLEtyiQSlnIUdwgXOOPX2re8L6nZ2viLQ9VluL9bWw1eG6nW0xubY37ssPQMQa/s3M6P/Cb iIrrGX5H8f8ADmMUM9y5vpUh/wCln95/7GOprq/7Onw71AAK9zpnmyKDyGYBuR24IOK9e+L9oL74 X+O7U4Hm+GroAnOBiMn+lf5I59TdLifE0+qqyX/kzP8AX+M41srp1ekqcX98T//WteMPh14i1fx1 8SrXQtLlvms/Fl3MFWJ4otplMRIIU9DGa+cfGHgXWNKumnvre8tVhfbdlonaGIqdh2NgYAPXPTr6 1/rJwJxHldbJ8Hl6qr2ypxVr67W07n+UviTwxmmAzXE4+pQfsnVb5rab7+XzKtgLfyrWHzLWKRG2 v9onVSij+IH0PB5r9Yf+Cdv7BviT49eLY/Fl3q+ujwJFcqNQu7srHayxKUkaGLEanGQwJU8g4B6k ed4pcT0OGuE69eq/elFpef5eh9p4HcFPi7iqnXatTw7U5adVt076/kf16eA/Anhv4b+GNL8JeFrC Ow0rSrZYIlUfvJyqgGSQ92PX0GcAYr8q/wDgpb/wUS8Kfs/eEdc+G3gXXftPxPvrY2l8tjgDSklU gR+cQQHbnO3kBSBznH+fvAuQ4vjbjWhgoq7nU5pdkr/l062P7q8S+KsPwlwti85rytywdvW2lvkt PSx/It4w+IPi3xXqI8S+JfEE2ta7eMXvUuCWjs1GNkajaB8uTyOvpXis86m8nWKVJCshmmTOGVn+ bp6cmv8AW7Isuo5TltHLqC92nFR+7d/N3Z/jDxLmlfPM3xGbYn46s3L07LpsrL5H/9f4gtb25tLh rpHjhWMZJ52oMc47+taFxcPd6ff5svMWKATwNbL+8DMyAlyOqkevQkV/usopSP8AAmmnyNE+gm2j ngk35uim0YG9Fc9FP+e9f0uf8EZ7i4h0i6tb+4iSVL1tyW7GaNn8uBgC3bJ21/P30j4qXh7iU/L8 0f2H9DWo4cb1IrrH/M/f34ro8/gTWTGH842ZASNcszHOR7d6/mP+EGoT6P8Atr6veZCxJe5l3jEz SPBAMLnnO5Sc+i1/DvhXCMsJmsVv7L/M/uXxGqTp8R5I09HVf6H9R+iOk3hm2aK43iWyCrI3HO3k n8a/OS58LaRrf7TEVxq1vbXz2FwktvHIok5Ux5IU8Z+Y18PkNSdLEYiVN2ag/wAz9FzilCpiaEai uuZH/9D+6/xjNLa+FdRurIC2aC1zGqDy9i4wa/nuT9oT4iD9rJPBVx4hvItHimaY2akGErgsoZRj 06n/AAr9j8O8sw+a/XliI35KcmvxPi+OMyxOX4zLlhnZTqqL+4/oU8HXJv8Aw3p0olWdZ7VSjnLA 8DrX85n/AAVM/tC2+I+imBWjhn1ERRmJvvSgDDEdeisP+BV1eEytxqovopI8DxojL/VRW/5+Q/U/ Yb9iW+bU/hXoV1c+ZHcC3IkhY5Cj5Ng/AevvXkn/AAU3vrO2+CGuyTSeW8enyx+ftBWANDIAT/wJ xx7V59ONvExKP/P9f+lI9nPZW8M6kpr/AJhv/bD+M250u0s9V8yF0WOV0JtIuLfewA3hB0Y966TR fhb8WPFt/qjeF/CXiDVbW1gDLqVnpjyWqgkAgMcIxXOduecfjX+l0s7weW5asVjmoxSWr9Ef5ZV+ F80x98Pl8XKUpN6ep//R8M174TeLfCUVveeNdA8SWOnxX4S7v7rSHtLd+Cyu4zlVzgcZ6d6/rC/4 JU31o3wxsLEFLkW4hksbjLN8hVhtye446+lf6BePuaYXOOCY4rCSUoc262P4o+ivk+KyTiLGYTGR 5ajgnZ7n64eLPFll4V0K61a8YLFbRb+hI4HOcfSvI/D/AMQNL+Kmj3sUEkZtQximRWHmru3ICVJy O/6V/D+FwVSph5YyK0i0j+3XUhzToPdo/F7/AIKDf8E6/DXi3RNS8aeELHUpvFqn7Qt3pjxQTzoA uYpcIScrHsyexHIwMfzC+PPA2seD/EN14b8R6bdaLqERLeTPK8u9UJVvLkIwRkYPev8ARX6NvHkc 8yL/AFfxUrV6TvHXdX1Su/na3c/yu+lN4eVOGuLVnmGg/q1Zavs7ddOu179jigzWwwpRoIuI0UYx +Pp0qiRcy3qXdx5jQPgPFarvWLnAJJ6dO9f1SfyVBaSP/9L4Xh1C+g+0qGV0Aygb07VYsrh472DU N6pJbuJ4jt3BHQ5HB9xX+8s9j/ACO6PpP4V/HzXvCuu6ZdD7RZwWVy0rSWeoPbGRSB85CgFWGDgZ I5weuR/WJ+wj/wAFBPCvxdttK+H95d7720tLeL7VdzMkkbSqPlJcAg5BO1voM9a/jn6Snhz/AGll X9v4CH7xO7731ffr+H3H9/8A0WvFebxy4KzSeiSVPtyrS3qnbtdNdmfrrdWtlqllNaXcMF9Y3kJi mhkUTW9wjDkEdCK/DD/goj/wTbXxzbah8Qfgvolppt3BnVNY0myiRFuWA/eOP4geODzwce4/jrwz 4rq8IcT0cU5WpSaU+itfr+K8r36H9b+JnCa4nyCpRgr1Ye9HS/rb+r6WW5yX/BIHSbvwT4g8TeCN XiW31fTLieC6VnyZeGx+I2MMewr+gin4tYiGM40xGLpfDNKS9Ge7wbRqYfhXB0K3xRjZ+qP/0/1i /wCC1mizal8XNDWxiuWlW2gnuBDbNM4XOCyHpnDHjvg19/8A/BIOwOlfDzXLMxiKJrOIWyuhjnKr JwXXsSCCR1yK/qTPsTRn4J4PCqS5lZ2vr06H4TwZhKi8Uc3xLi+XXW2m76n7L1+GeqGXTf8Ago0L QkiOe8QgIvEql5Cc/l19q/G+DI82MxC/6dTP1jMXbE4T/r4j9zK/Lf8A4KYaVd6j4e+HDW8AlFvr 33wuXUsr5H4hf0rzOG5xp53SlJ7N/jFo2ztP6nNR7x/Bo+9/gsH/AOFW+CjJne2ixlg3BU8jH4Yx +Fcr+03Yyap8EvHGmRSeXLqGltaRtjPLA4/l+lZ06ip5+qz6Vb/dIWZ0XiMrrUEruUGvvVj/1P6x /wBgb9iLw/8AAHRZ/Hev2dveeNfET/a7IyKZBpMJ3GNgD0kIc/TOeTt2/cfxd+L3gb4I+CdV8eeP 9Xh0nRdLhZxvb9/eyAfLFEvcnueijk1+jZzjsdxpxLClTu5SahFdun9eR8NhaWA4I4WlUq2jTpRc pdLvf89PU/io/bv/AG9PGn7VfxHv57O41Kw+HlkZbfQ9Ka8e2s3hik2ApEhxh8AsX+Zs9sV+eja5 FqUU+nW0kFu86BpEC7SSTkKvvkda/wBRvDrhGhwfwjhsrpRSmopz73t+n56n+TnG/F+L4w4pxWbY qblGUny+UbvZeZ9N/sx2Dz/F/wCHdvb6XBLJZeKYILu0wZb5JJcBHA68Abjn0HtX98/gGO5h8FeF YLxDHcwaDawyoRgrsiVRkfQCv49+lXKKzXCR62Z/oB9FpP8A1JrP++ed/tF+ENQ8e/CnxF4P0xA9 3rqJZgt91FJO4n8KZ+zv8Hbb4JfDbSvCKXL3d8Sb3VJzwnnSEsUQei7iK/l6OYOnkkstj9qXM/kl b8Uf0XHDJY+eMf8ALy/i2f/V/tk/aY/aJ8I/s/8AhCO+191m1TXmaw0nT/MWMtuwjyuSRhV3cepz 6GvT/hRrEHiHwF4f1y3bdFq1mL4chtu8A4z7V9NVyjFUMop5tVjanOXKvO19V8018jx6GaYSvmNX LKU71KcU5Lte2n3NfeYH7QHh7UfFXwh8c+H9K086nqGp6JJb2looJd5MEqVxyCGCnPav5hvgz+wl +0Z4d+PHhrxbqXhXxBBp9rraGS4ubOQQvEZSXLtz1BPX0BJr9b8L+K8s4fyPMsDj58sqyaX3W6+n TX8D824z4azHNeMMrzTDRvSo/E/Rt/Ldb/52/rM0iCW20nTLacYmttPggmGMYZIlVv1Brz/xzqun 2Wr+HLee9t4bk3wn+zvKBKV3BQdvuVOPoa/EuSU6jjTR+tK1z1BWDKGUgqw3KQcgg9DTRFGHMgRR IRgvj5iPrURTUXdf1cqSvNeR/9b+/imqioNqKFA7KMCu6CaVmJ7M81+KfifQvDegRjWL6C1l1G7S 0sYpJAss7nrtXOTjv6ZrvdKO7TNPfs9lE4x7xqa2dGcKaqyVoybt523sYtpyaXQ/N7/gqVHbP8Ad Pkusqtt4qhnjcttTcFZSD+DV9BfsUakNU/Z08BXPlxxH7K0ZWP7vG3BA+mK+4r02+A6Eu1V/qfK5 dNPinGw68sfyie6/E6Pzvh343i4+fwveqc9APIfP6V/EX4F+AXjj9pL9qLxF4D8HaVNOt34wuzrF 4YSlvYQK5h8yV1HHzKzAE8/QEj9o+j3ndPh/Ls3zSq7KEG7/AC/Q/n3x94efEnFWR5aldSkrruk2 /wAdPkf/1/7W/wBln9mLwX+zN8O9M8K6DZWsuvSWyP4i11Y91xfzkDeBIfm2g9+Nx54GAON/bK/b H+H37KPw81vV9Y1a0bxkdHku9B0Msrys2NsbyKeMMxAVTyx9hmv1alSzDxG45UEm5Vqn3Rv87WXy ufnmPxmA8P8AgydabUY0Kel9nK3y6/O3ofxJftAftFfEz9oL4har468d67dXU93M8+mWhuVuYrWO VlcAgjAIAAwDwD9K+bbqS4aczSSv8w27WbKsB6iv9buEcgw3DWQYTJ8NG0acErLvbXbz28rI/wAY ONeI8RxTxNjM5xMnL2k203f4bu2+2mr82zE1WVYbixhM6+fqMTzQqp67GKsMfhn8am+zy2scRnD/ ADKGDMOGB9K+stbQ+RLJkV0QqCXHAzwKu2gitdQgeW+ktLri4iuLU75I8FW7fqKmfws1ofxo+p// 0P6Cv+Ccn7XngJ/A2k+F7O5MmoMEtJ7K/iEV1JglVkG0kAOMFc89jgg1+ofxg+Hdv8dfCK6HcTRR 6bfREQSYKiPep5OOcjNf0P4nZPjOGfESviqsdfaOS+TPyfgbMcv4t8NMNh8NJOnOkou3mrH5geFv +CN/wx8O+LbbxVH4p1hrqHVH1GO1/dPB5rsWzvK7sDPHPH55/X3wtoGh/BrwLBbT38X2HQLEvcTT zJEJPLTPXgEkLjt9K4+OON8y42p4fDYmLbgkl1b6B4dcAZdwBQxUsPJctRuT6JddT8Hf2o/+Cg/g rUvjHBBZXdkth4bvYxdzBm2/NJtO3jLYBIyOOPXp+tH7OX7TPh34veEoE0i/sJRFZoiyLKu/bs2n Azwwxgg9Metevxd4dZlk/B+CzConZK7Vu+v9eh5/BPH+V55xLj8Dh5q/Npr20/E89+Nf7FHwn/aC 1KK88a3DuxcPGjOIYg/8LFs5zj0xnvnipPgx/wAE9/gF8ItUGq6LYadNcxy+cN8iLHI/HzFjznj1 6V5GH454iwmQf2Bhrqla3X8jqqeHOQYnPZ8RVknUk+Z7X+8//9H+uv8AbC/aq8Cfs4fD/UWnvdIu tQXTykFn9tQLCeAAAM5+n8utfxPfH7466h8ePGfiDxtqFmdO+03QttHsNm0rAjN+8bn+Lg9M8DnO a/0b+i1wpi8NSxHEmLTSl7sb9f6/Vbn+bf0u+KcBi8XhOHMHJSlT1lbp/W3yex9b/wDBOf8AZ38I /F/4rabqHjO7T+wNIuLe6ubdlRJJdrKSUZuq7mAOPT8K/tT8Gj4e+BfDem6VpGrafa2FlarCjS3S JkY4yM8HtivhvpW4rMcdxNRymjBulCK2W7kk/wBT9X+h9hcvwHBeJzOpNKpUnK93sou3p0PHvjj4 d+E/j3wtrcnjXVtHvdKNo6m2edLjcvJ+7ng9x/XpX8c3x71f4f8Awj/aVtNV+FLHUrDSJ/tpSNFs 1tw5dBjB64yPw6U/o34XN69fF5PVUo4edKUXdPdprbylb8up839KDF5Rl9bLM/w7jLEQrc++/JZr XzX4an77fsJ/t5xfEy007wpqWpDTRp0KxXIumWB4gwIXcSedpHXjqc89P0c8X2XwO+IqbfE+seHP EcO4CSK6uY7mFimcFhnqOema/KONuDs14U4zrwwUGpXbTV3Z3767n9G8KcZ5JxpwVhsViqqcJxim nZfZ2tof/9L+wPwt8Pf2QvBurW2oaLZ+EbLUoJ/tCzRSQqFbqQB+vPIrzz9r/wDbn+FnwV+FPiKb wp4hsr7XfsclrapDcLiBtpAAAbPUgcd2Ff0Dl+QcT8W55hcLjIyleSWva+vzsfjua8RcJ8EcL43G YGcYqMJOye7tpfXa/nsfzUfCr/goF8QrX4uXniHWLi5WafW1njvoZBDHLHM5ZowGyW2KACT2GM1/ TZ8EP2svhv438DWep+M/GOk2l2wKvDdXUe6RFAyT2IJz1r9p8Z/CyWVYTB43LafNOKSdlr0v62Px DwE8XcNxFRzDL8wnyJNtJvo27el/z9Dq7nxn+yTfSSXuoS+ErtpZGmW4kEEonZvfJP4dBW5D+0z+ y78MfD1xNaeI/D+lWkRLeVprQqbhuoA29TX4a+GuLsdCODnGThora2P6Co55wVgXUzShKKmk22lr +B/OP/wUT/4KIXPxh8S3Pgf4T+Iok0S3leHU5zOJUhQONhKDIL5BwvbAzzgj8V7u4uhfCS7vpNRv kYTXN6R5UtwwwckDgcAcCv8AQfwf4NhwjwhRw1SNq9SPNL57L9fn5H+XnjVxn/rlx5Xx9Fv2EJcs PRfr0+Xmf//T+g/2Kv23Nd8A+IdI0DXLqTT9A06KK2ku1ujsSLeq7sBcA43cA/n1H9HGkft8/suR 6VpU+o/ECznlnhjZDIBDJM3GSA+MkY5xX9z+OnhVjp8VvMMnp3jVTbt53/J/hqfxp9HvxfyzEcD0 8tzyqlWotLV3b5ba/NWfrofOP7VP/BWj4KeEvBevaP4E1tNR8QXent/Z/wBidjNM+MCMkgAFunb6 1/Jz8Tfi545+KHjTVfHHijV7sXOqXrvb6T9pM1rYRkkBVBPU5JJ681+o/Rv8MK/DSrcQ5rD97L3Y X37NrXotNVZ3fWJ+DfSn8U8PxRiqXDWU1L0Yaztqu8Vt1dnvdcq6M8rnjdXlnyh38jAwBwOv61Sj BkYxEFiRkA9BX9cpXdj+MrJO42LD5CspaNuh5Ax1GKtzmWaW3aIt56Z+ReFYD2pWtoZyi76H/9T4 ELSQyebMxaRm3NkZ/D/PpV2B45U80t5eBvYMcEDrzX++B/z0KLexfcRrCskjqY5AcFTudceo96oW t09pI80LHKghWwCynpkelAjOjWWWQrJI0jOS7Su2WY9eavyxxQwojK0kkkg2lei455/z2qZS5UOz I5UmVQWbaY2AZJMhlH0qnLLs3SryOhx0pKXu3YWfY//V/Pxnkt4rSRCsrXFztkUoSsKep9/8Kuyv bxt5f7xhKSoG3bt4PJ9K/wB7oy5j/no5WtLEETrvMZcFI/l65x9adKfLR1hUzOcYUHAH41RqoJKz LiwFLZhJwx5AxVLz0DKjLtb+IDtRdLQiUbbFyW4ZV+QE5wpPoKpeWFmEplJQLgg9DUOaTsUoK2p/ /9b4QQqyKkSBfmLHsOetPZLd2CsShYY3g9/Yf56V/vZz9j/nq5HYqiTUI7S4VY1uvs0oMbKcS7On I9uT+FaQu/tFpFEYUR0YtJLt+d84xz2x6UnNsqnsZlyoSSM7mAyOQeuKkN3aSTSxo26SNAJWI5yR kUKbWhUVyqxz3iMG50q+t5fLS2NnIZN7+Wp2KWH16frX4kftJSLf+JLm1t5lWxiaKT7OPmjbbg8f Uj9K/DfpCSv4e4h+n5o/qf6KytxpP0X6n//X/ijEckSfvMgA7kbpiqs48wsOFZAHweFbPev0Wo9W j4+F7IoCPZKQj4GMMpOQDUzhgqQhy7BiWOcgfU1MmmjSC1AwsttImFQxSjfIGzu9qb9hjnAZMxkf PleORXPGzka3aGkyeW0bgmMMB6EGlFvFK6usaO6DCFieDTqdDWDbWp//0P4jZEms5E8mRMkHzQV3 KM1rrPJe2kdqYYztLETiMK7Zx1PfGK+xe7PnynDBcQTKQ2yGJiWyetR3L/aLrdHL5qIgZwv/ACzJ PApAaMawwq1zJbRTyumxjKD8gx2AIrHcJLMCg244Utwo+lBN5Jkdwk6fKAJN3AwcED3FWLK7FniK RN3OVBHKnOeKwlvqUf/R/iev72W4lido2JEYQLjaeBgf59qqCXjc/wAkoxhSOnqD/ntX1B4nwwsW 0jeXzIUAEYjII246+350xNKkZlk3yNKg2hJDwV7UWM1JrYt3OlP5QeALv3AFM4OfYVBBpd0ruk+c qR823aBQaQd9GWp7ZBIYxklY85HeoI7edQy7Oc9OgI9aaTexT1sf/9L+KWK2WQGKQEMp3l/7v+f6 09YoM7S4Cg4JC8mvrIpqWp4c0kjVRFeKG2to2kI4IGdzH/GmtDGtwIHDx+Z/Cqkx7gO56Cm4Xdxw krWFtzc2s8r26qssQwoxvGR3qmZpoJZZpVDTTj945OWJznn9KagkaNK10ytIUcgbD5h5LH7gFA0+ BH3qjHcMs+4hQfUCnbUxnuf/0/4nri3R4/kLAA7Q3fipYtElvgqqSFhXdJMUOxV6cn+lfVuFj52M 1cufZYYzHAwkaJEx5sQzuxxg/Wq9xZuIFZY2jkVvkAPykdKguUr7kNqu12W5mSOQjJAGdq9s1JNb b5Vi3DeoDsrDBKnoce9RNXRHPEJEfbGyqcKTkf36gjtpVfe+4gtu6cf59qz5X2NYz7n/1P4o2JVJ WbaH34RQfvAVNbK1w4RY3WMruBI+bPQivf8AZXPHdRPS5eaAq6xGLeh6P1UH3NEluhTzXeOJlfYv OFY9MUlSaeqLjOKja5bLTRwyxXDtCCv7lwuWI6kCueEQeX92N5J4Y/epqKiSpO90zXOn3sNuFuGM SEZjZ1+Zgf7tRm3s44PKWPzZBjezLlY/QYqrPYqUuzP/1f4nYy1stwEYW7ygorffyM9vSpbNEuo5 A0x352qV4yRX0Nmtzx2+442pMqrIv7wn5W6rgVFPbYlit4HeS4f5vlGfwGKlxutRXXc1FglEcazo ULr95xsyfessgr5oZwVR/wB3t5Dc8D/PrSdJvVFxmrW6GjHD5qxrKrQq44cDkkCqF7HFayAl9iAd CQCcVDpy2sZucY7s/9b+J5IWulicbQGbjnmQc9PyqQIN9wg2oLfAm8zIC56Y7V7cacn0PnvaruP/ ALNjbc8ewMy5G77vFRLFcKyuv3s4YAfe9q0jT6WJ9rFPcdb2st7K4VFDRt8+3+ADjmpm00rK6iTD KuSoXJNX7Bt6ozliYLdkMem3MsM7xjIYeWP3f3Ae/wClQW9pc2z3ZKSsIsIzNGQcYzkDuPcelaKh NvVCWJpvqf/X/ig2z3FqJbfEibthePicEdVx2q3EHkDxy2k8MqKA1uyYkOelfVqhNfZPlniafdGT NYyPIyeQSnm7Y3HcnjGPY1oHSnto5IfKVJUTfLNLjKKfU9h0qvY1OxpHE0raSRjJYy3Ep+zgXCp9 6WE70XFa76dK0kCR29wyyIAi+Wdpb/e6fh71osNVa+FlrFUtuZDLrTbncbUaXctLGVKGOPcz7uvA 9O+avjw/eYL7THGigzFlKeVnpmk8NW2sP63R6yR//9D+J2XTVEri4mSPZEZAg5Z8dsfWm2GjT3U7 u1sI0WIeTI5wr55AGPpzX2UcHXl9k+f+u0UviL76TeqyQz27x5XcqkZAzUtrYK0vlRoG+znfKY+W 46itPqFb+Vmcsfh1vITUdBmaGK8jBS3uG2hQpLE5649Ky7jQ9aEUohgdo7cbJt48tYlxnPrSWBrt 2s/uMpZjh0vjQWukXMkAZAkq7dg8tw3PqK0rRXt4hDcWd1LbK5iYrAzLx97PHvzW0crxcvhpt/I5 pZxgoN89VK3dn//R/i3utAnXZNaacjJOA0KwFScHpuX+tJZaZdr9n823e3DyPHNCF3yRlcjJA6ZO OvrX36yTMXqqUvuf+R8P/rFlmzrx+9GfdWV49v5txBLDCzOxMw8sKEOCee30rW0qzjFjBcSWckjs 37lbNDONnPzMFHpzz0rVcP5pJe7Ql9z/AMiHxFlV/erx/wDAkN1e3XVdPVrCxtDPATFCjyGK5uPm +ZmLccc4AArIh8Py20sUVzBKkhJbzxE32dh04fGDVLhzNn/y4n/4C/8AIzlxJlEXZ14/+BL/ADNB vCWreRHNDpTOTKymNZP3mAcA7evQZwQK177wdexWsVzFYSzCWEvDAsTM0rJ94A+3H610R4UzmW2H l9zMpcV5JHT28fvR/9L+KCPSPEyyW9u/h7UbNbt93mS2bRqq5wST6Dj866E+DdRhWS2e31C5udwI WG1KiEN0+f7pH41+px4Nz2S/3eR+aT4xyOGjrxKMPgLxlFOoutDnEbhmiKFZ5GAIwcA8H2rR/wCE H16O5jtZ7UxJNIFUhSZlzjhl7fnV/wCpOf8AXDy/A5p8cZAtFiI/iaFr8PtYZ/sdvpeo3d7ISwie 0MG9Rx1bAqRfhh4q1ScofC9zptosOD58UkZlYHB45yT7VtT4H4gb0w8vwOf/AF/4finfER/H/IWH 4S+N45wIvC2pvbBzbGWK23rMSPlCkkE+uDzU8fwu8U+RFFdaLqVnmV4cX1pJFkqOzYxzx0rpXAHE U98O/wAP8zCfiNw5DT6wn9/+R//T/jlh+EPj4W4ksvD1w8kdwqTxhv3S7jgF3ONox3/Suh1P4G+P 4WtXHhe6eO6iwXgdZA8hAI2vwGHP15FftsfDXiGW1L8/8j8QqeKfDlN29r+X+Zlr+z58T7i8lXUP DuopJbxhFNrC26A+kkZ74rTsf2e/HMaqyeH9ZuIZH/0i+EJaBQD82O27nG2t14V8SS05Pz/yOKXi 3w2lb2mny/zLFr+zT8QLrVklt9KVdPkmWCe51GRreOxRvvSkAHJGDhc9fSlP7OfxLknvUs9KW7sI ZxbW88MbSC4JJAIxxzjgfStY+EPEktoL8f8AI5KvjFw3T+0/w/zNSy/ZK+KUtzcQx+Hr2VhHtmku bY2qWbEZViCeh759Khf9kj4pfZ31do44FSIrCYIhJZRtDzLucnnOOmBXVT8GOIpvlcdfJNnn1fG7 IIaqWnm0v8z/1P5Mn/Zh+JUw0m6ttOfyr9BEky2x+ys44Zw2eeeNoPvT4/2VPG1ylxZ7GluL1j5y wotqXli5BGWPQDvX9IU/A3iF7wf/AIAz+V5+OmQL7Uf/AANf5E9z+y78UJxJe2+hSW0scMf2eW/u xC7YYKXIAweAcAc1atf2WfFkV9qd3JBb3Op3lrEz289pJA24EBsOSeuQegJxXoUfAnPX8adv8L/z OOp48ZFDSMot/wCNf5G3afse/EO5W8XUUtNLR7cTWk8dwjLAucMGyep7elXNP/Y91u5MemXOu2Gj yWDt/pVxFJci5QjAB2q2TnnPSvToeAmZSaU1JP0PNrfSAyyF3Bxfzuy5ZfsZeKrC/wDt8upXMHno ttC93aF7ORVySYsc4PByfXvW5on7Huuavpd/qM3iTTWvbKaVk0qWxmNzCFxtlBC7eNx6kDI6ivTo /R8x0vib+fKedV+kTgYfDb7pH//V/mqX9jTX2huJF8U+HppbGSESh7aSJruOTBcIc5O3nOOh6ZqA /sUQ/arlj4ws0t1/epbra3EiuemwOEz1+oxX9q0/o74rbmf3xP4bn9I/DRvaK+6RdX9jNrWd49R8 QQTrNahrRdOgubXUbNnGUAcptYYK/LgD3rPh/Y2hVpI7u81Ha++0fW2skuJYxyyIqkjaSQMkEnHO K9Gn9HmVrSXzv/Wx5tX6Rrb/AHctP8P/AA51Fl+xhYfZ7W6tPELyzW7gappk+lNI9wV4XbL5nf0w Kty/sZ+HZbxrmXxBqkEqLvmS40pFtrRTwFWLLHJOBkjuOa9Kl9HfDJWlJffI82f0jcU/hUvuiXU/ ZN8J2lxZ6qmpQzavDZmE26W7w5QnBU4wv8sZ+lXT+y14WSw3zW8EXmDFuunLISz/APTTdgZX0HWv Qh9HvLY6SUX/AOBHFV+kNj5X5XL7o/5n/9b+d7T/ANkXwXbrIq292UFuXdJlVUnOcuACSQPpzXUX H7I3wdnitryPTtchnitNkqPdqyXb4wQGAGFBzjIJxX+jWH8AckSarRXl7v8Awx/mvX8fs4/5cuXz lb8rjV/Zq8GWFnZ2ceiyWWlSxMyraXAjunkBI3ysBkc9uM9a2LT9lP4XQDddxzajJesrzXFrqssb oAOFlDRkkg+jYxXoU/Ajh6KSlFaf3UedU8d+IWnySd/8TJo/2e/hpoyw3MGlWyXjXnlzqzsZXQD9 2UcgAH65J9Kuv8B/B0V83/EggAuIts9vdxYdnIOJGfg8cHt0r06Hgxw3QdlD7kl+jPIxPjLxJiN6 n3tv9UaDfAv4fJEp1PwtYai0amHzDcvGGI6HAJ6ZHtUNh8DfAgsb+6OiQwz2VmY7AWih0lkdufM3 5JwM4II+6K76fhPw5B6U3+H+R51TxU4km9an5/5n/9f8TIPhH4Pt/wCx7u50TT5VtMsIJLeNnmfo WkbbluegPAxitKT4X+BZbpXs9FtmkeN2uY7u2t/sycZUwoqDbt9Qc1/rBQ8N+HKK5ZUL+v8AwLH+ R9bxC4iryuq7Xkv+Dc0rXwJ4NhgiR9AgmmtImjhMu2e0bOfm8plwCDyMU5vh74JFrpiDw1ZG/gla ea8kiR4rlSxDLsxgDsAOBtrujwJw9DT6uvx/zOOXGufy3xEvw/yLOn+APC9ra6uml2kUU9xeB4rJ rVHikgJYsFJHDDC/UVY1Dwxol5cRXT+HNDs3NuLdQmjxRJLs5yF243cdcdK7aPCmS0Y8kMPG3mk/ xd2ck+KM5qvnlXlfyk1+RPdaTbTo88geI/L9oEDCCNtgwmEAwoxgYHWom0jTJxawXWj2MdkMxIth YxQSrv8AlMm7bkn3Oa64ZBlkdfYx/wDAV/kYPP8ANH/y+l/4Ez//0PyMi0HSNLvobyxh2rbMqRyX Kx3EysvcDbgD2A/Gti406/8AE0zyiwgnubSXzkvLe2WB8HjDBQM9D1/lX+x0MpwNP4KcV6JH+NNT N8wqK06ra822W7nSmtCt7LFbW9/GFZJ42Kz8cAJg4B7nH51zaWlu6anFJZ2wkur9b4XU8YlvZn/i CSHleWJPTOPz1+pYeLtZHP8AXcR/MaMqWl+9z5ohywVmgijEaBwMAkD0H41nT6baWUbTTRiW4ZgY w67vLXHUH3yKp4ago/CgeJxDWrJIba3vmYMpe4wHREGS+OtQS2MEUqSLEIXXksOGPXk96lUqK0sh e3xD1uf/0fyL+0WGxbS0trdJ42Mk1xFEFmfORy3WqwtZCxnDSHyGDRhVO5OeT/Kv9kfY0ex/jJGr Xa3LElvcblaGR1MyBpIoxiM4457f/rNW7W8jijudiWxuWhNpNHsBmAYfeHofes+WmjpjKo1uc8LS 5ilk2IVLndGjqVj68nOK2bYtDIhO6Ji2ElBKsD7VlKMEzWPOWWs7RG86SciWI71Kna/4fpVL7UN7 ArnDGTeRhmJ7k0JJaIuMZX1P/9L8e4mZRKiSy+XI+/bvLKD9O1M+zjcsQVS0pG1iMc/Wv9hJtfM/ x9hCV7FO9SaBkQPNDMj7/wB2SgBH3eR/npVCGRY7qQSyK19InmN5g3HHbJ9Tn9anm7I3tJK1zWjN xcJ59w37wYSabGQijCg47AU+1lEcy2k8i/aFkMkdwFKShGGPLOONpGBz+dZylbU6aala9wlsVeZp LZ9soB/dg7AFAJJBJ788VRsCrytcksyDlCRjyyOKzc29DVc3Ny3P/9P8fkuDdP5UiPtblH/vDvUW nCD/AEuK7ytuiubB4nAUvkY357Hnp6iv9dZS5Wf5KxZXs7W8vpZVWBcQ5YlG4VAcbifxH51n3QPn gpcpvZvKIkPKgY5Pt/hWcm2aRdncr+a15fwWyXReGGMwpasfUgl89fXA9z61as1ltYr7ULWRFgsL 1bCe3JxJN5gYkr7Dbz9aSuOpuaqJE7+bp6sFih81UlbaqjAzxnFRx6pcTxfZWhhuIIsvuIHnI3TG fT2pa3N6bSVz/9T8YYZFJNsI/IfzCyhQQCc1YvLaUT28cMUgWWPErbg4Ujvjt/8AWr/XC2h/lHL4 tDRsI7oSPAjiSPISNwdpX3FfuH/wST0KS98aatdWAkfS9QuU067uNQtl3G/iG0urDovyxDHueK/H vGh8nAOOl5L8/wDM/dfASk58eYeS+ym/6+R/Sj8cNUbRPhi2+JJZLex+wXkhkZbfzghwzEDPABx7 1/D7+1DrA1T4w+K7mOxhXUW1R11C4ZjcL59uViRcYwcBevcD3r8W+jJStXxNe/T+v0P3P6TFZf2b Rp/3l/X5n4Q/taC1gaS0huGe2F+t1Mcht29k3IxPPDdh/dr4h+1LbfvBGZY2G0bh930NfLeP9ZVe KVFfZVvxb/U9rwjoey4UpPvr+CX6H//V/hksZFYiQ7y7jK7u9dTZz27hvtSM/wDCMcBTUT2sZJe4 x2oRXFtew58t4JolkhKtuRh3U+jA8EVpSw3N0jmICO2lkUvEv3FIBxjPPr+dctS6HBdS/YW0ShvK uWa5gYrPC8flhB2ZT/EKhnspzJJcNJGUdso0fA4HeuGexob+k6Rc3EYnlntFQyBAjzBJn+inrmta TSPskrBbGBE8w+TEp5jyeWH86y1A/9b+Nm4voNOKC73pE0gjXCFtzHovHrVmdJHtkmjVUiuHy244 nUDqCvbPvXzc721Ogv20qW0IM23aTiOEDcir6VDb69qou2stEsrdnvY/JEtzJ5ESjI68YFc8ou9y ZOyNDWtO1OwafUY7oS3d3bC3kh2hw2Afun6Z6dhUGmahaRWEVhq8E6vMF853KlGJ9AMEVjJaGTbe 5e13Wftt5Yw6put7dkWDS7QqSmyJMB8nuwGT27Cuj0UwyOkFhmJSwG1hgEgcnH51m1+7bJbs0j// 1/5nfDouLtbW0DQtdWkX2dbuf9wkbSH5VUnrtzmv7pv+CPPhYaB+zp8NriGW0mkvNObULq5CES5b ZGdw9T1BPXaK/n3jWpyQo0u8vyCjJKtrv0P3Vil2IOVHy8Bfu1F56lgrxlmz1HSvm1/DR6Beh+7s U4U8jd1pGO87CSWB6Y4FF/dsbrZEzY8k5HQY9KxpJW81VbhV5z61SleSGf/Q/f8AlKzYdI41k2hG YDbnHGTRDbwMhF0fNcA+UQclT6n/AAr+R6sXctK0GjntdW9eyhiW3gcc75JAoEIAJOSegOAPX0r+ ZH/grR4aihWTXIdssjNLdR2bRho57rCHY5HKqGXOewxXpZJV9hmtLzdjysxi70pLpJH83z2aPf6b pttZRSxsxa8nvXEMVm/JYDvtPTnH8jXNeIZPEemtcQyR/wBmaBDcCcRR3XzxK7EKRGx3Y5z+IOec 1/QNFt002d83omjAgnu7i4I00w311CrBLhfvJGfvEt1A/wAK1NW1lrGxUy2NrqsIZY7iyMoVpsfe wfrWtiXJps//0f44JY7K5tmuEtBbHmQQK+8xqekY9cUWjFbaxh8wyfZQTDHMMkbjzknkjjp2rwLM wvrcgSOySef7MY45E/fO0b4VCck5/Whr28uJsXLRQ+SmUKRlI5hjAwPp1o1v5mcmrWILGBQ9zcMV k2xZtkEmPPYtg4HtWk7eTY3LpE0r/wAKkfIhHXP4VU1rcyRz8S+cv9oA77a4by5bbzD5lpJGOfk7 A/rj2qa8sbmw1CwlhneCG7s/tG2SPZKSrgDGeq9T+VEYN6subR//0v447q8uTazSzot3MYto80kL Jxjr7Dp9K5+3lthwqiOdhsSEAFR7k/l+deOl0R5ykmac7LHbxJCWZwR5jkA/PnkD2xWlBfx2UajD CQ8oUHyp3/PNdlNWQ1rsWNOn+2xm4ubYRfMRG4XDyjPDP7/4VU8bJM2nGQCSRQoO5vlRs8HcT9a6 6K9/USaaueJiFby5jtpWis40XO7javTOa3/h9cw6D4309oZZJxPfrG21y0cYwQGUducH2/CvocBJ xxlGUd7r80cWJipYaontZn//0/yh/Z48U22o+Ahcn7Tp+qR3yCae+nWR7pDbIsc6KO4Ku2Of9YPX Ff1j/wDBHLxj/aHg/TrFsvfaYwXzZU8h7pW++AvuGzz0wa/vvxPpLFeE8aiX2YP/ADP5M8EKjw/j BiKHR86/Jn7WftFadBf/AAy1eFCpaW2kcpIocPiN8KQezdPwr+HP4uWSxfFXxzayQiGT+3Lm+aOB i0ZErebkJ/DsDBSB/dz3r8r+jBL/AIU8Yl0j/wC3I9r6WFJKOCfeT/BM8YuLD+0Etr8T2mo6VcTN aXVrHG0G3ycKCwxgnnr3IrBlku5w0isUtYYxAloFVY4Y04VYlH5nqSWJNf2/D4T+EK1K9WxaurnT 4baN2neEYVpZBlXj7/jxV2S5026gsrfw7bajf3d/KWS5lUiOCILl2kIzjOeFJz29a0h8SMnT1P/U +D1treOGOC3WJrhMx7fMWIqVGWxz14P411XhvXtTtLqCfS9Qk0y/09CWfzeQGIAOT+HrX+wGNw1L F0alCsrxas0f5GZNjq+UY6ljsM7ThJST9Gmfvp/wTy/4KIH4aalpXw68a291fXd9dR2kWr3lyDBf LsU7gQuM8EE4/u9Oa/qO8H+K9G+IPhe01S3mtLi11a0JltYrhZflfOVODnGM1/nl43cGVeGs9WMp x/d1Pu9T/UXw84vwnGvCtHG0pXnGKjJdU1v8/wDh1oz8n/28P+Cdngz4j6PqHi74W+CbCLxpJK+p zNEPJM0sUbFCzdGG45CsTyox04/Mn/gnZ+z38aPBf7VMc2u+HjFc2cH2LU7pTvtpBHIsgk8z7rZE ZJOcj88elwlxyq/AeNyjMql5wi1G/ZqX3X+699uvyuH4GllviJRznARtRnrLyaafp/S3P6zYQ4ij WTG9UCuB0BAAOPxzX5D/APBTD9kf4hftKnw5B4KsjdSWl3DNvRwrJ5SsvXGAAWYnPoK/I+Fcwp5T n2HzCr8MHf8ABo/T84wX1/CVcL/Nof/V/rq/YN/Yh8O/st+Df7R1rT7S8+J2suZNW1f5ZWtE24Ec RHTOW98EdDkD1n9sPwda+PPhtb+FtR503VL9re+bGSEZAD37gmvus3z+tnPE39rTd/fXL5JPQ5qW Bw+Fy6OApRtBK3+b+ZxHwl/YY/Zl8O+ENKjsfBenanfSWwnudYEjRXru6jd8ynj05z0r5G/aL/Y1 +JHh/wAf6Lr/AMBrfX59GtZI57jTI9TeVHUMG2rk8EEMMcDBHpThxBiMTms6mZO8W2tenzJ+oUaF OnTwi5Yxd7LY/QX4AeIfjBNpUOh/ETwTPon9nwJHFfXEqtPJwQVYKT0AXr6j3x7L8RfAvhD4geGN R0PxrY213oz20jTvct5a2o2Hc+7tgDP4V89XrRp451sO9ndHpYlU3V01R4f+zLN4G0jTNc8IeCbu wk0vR7s/Zo7ecMWy7BiMnJ5OPbGK+g/GumTaz4S8Q6Vbwi4nvtKlt4YSQBI5X5R+eKeNdX+0PaYh NSbTdzHFzhiKbdJ3TVj/1v01+Jv/AAS6/aJ8VfEzxZrnh/4fNb6VrmtzXUk8zIsM+52PmxlXBUks W+cfxfhX6w/sif8ABMv4cfCvwkJPi34Z0jxT4lvVSSe1ucXCQsOrSSKRk9gAenXk4H9F534s1KnC 1DJsulaolFNrsrf16n5RknhllWGzPEZpjo88pN2T6Xb28rP1Gftg/sdfsqx6BpEFt4J8K+GfEmv6 pHY2dpbxuh1AMChYKWO0jPUddvsa+4P2avgN4L+APw00Twr4T0ey0+WSyjuNTubaBY5bl2UMFZup Cgj6nJ9Mfn2acZZ1mXD0Mqx1RypuV1frb/J2PpeHuEMlyHNMRmWW0lGUlZ+W235/N/L5V/4KEft2 +H/2XvA97onhrUNK1P4latA1tb6WL1TeaarjaWCDP73BJAPTjuRj+Lv4ifE7U/i9r/inxnqlzev4 n1rWmvI3vZtrQCMoVUxn02dGJ6DPbH9R/Rp4PWEwVXibERtKfuxuunf+ujP4++k7xjHG5lHhnDSv Ckry2+L7u+j10cfM5WG+mmtrb7dAftUciqscJGJ2IxuPYAk9O1fc37Dfw58d+Ofj58OU0DSvOuPD t6ks1zboZYmjuJF/d9M7gqOeeOfSv3LxJxcMNwvjK1T4VFo+L+j9hZ47jbBUobp83yX/AA5//9f+ +fSIJbXStNtpwBNb2EMMwAwAyxqG/UGvj79uj4I+Ivjv8F9Q8GeE7T7Trd1IYoTn5VVyobcPTg/j 3719DlWLjgc6pYx7Qmn8rnLm+DWPwtXBtaSVj5l/4J//APBOTSf2cHvfG/xC06y1Dx5cSgacN6XM VgnHJAyAQVGF9QCScDH6ieM49/hnVfkEmyASbWGRwy5/TP5V73GnElfijOpY+crwSSivLrv5/oTl GUYXJsBTwGDVox/Ed4T1G21DRbNre4imaKERTIjAtEy5GCOo6cfSvm39s74K678dfg9qvgvw5a21 xql0jpD9ofy9hYAAj8QT7HH1r57LaywWZ0sVLaE1J/J3Y8zw7xmCrYWO84uP3qx+C3w5/wCCQn7R jeLLEeMVsdI8NSXaJdXFhqFs91DBGeNoydpIAGQM/wBf30+H/wCxj8A/A/hfS/D9x4F0jxNd2VuF utZ1yE3V7dy4+dwcgLk9Mc+9fsPHvihX4go4fC5VUcYwSu7W2Vrar+rH5nwT4c4Th2jXnj4KVSpJ +ejfl1P/0P3Z/b/+CHwj0n4reAtE+BNlY6d8Qrq/EGs+HfDcJmaDluXcElfm2Fgxwu0++P3f+Fek anoXw+8KaVrEZi1K00eGO8jJy0b7AWB9Dnt2r9V4szPFZhw1l8cdK9XV+bjrZnzXDmWYXLZYxYNe 45/j1XyMH47eB9Q+Ivwv8UeEtLSGS/1OyaO2SdtiO21hjPTJDHrX8PX7Un7KvxT/AGdfGn9j/EG2 0nRdJv8AUpb+x1NZWdpDKfljIxnA+bPHQCv1r6NGeYfB59LJqrtKtqvVW/U/nr6UWSV8Xwss5o7U dH6Wf6N/cfG11dy3VtPp5a1ure3vDLHeQIVM+07RgnkDvgge9b9uLN73SNJ0+G4b7c8ZZxIBGjxg SM0j8fLlccCv77xtPmw06fdM/wA+snxSpY6hWvrGUX9zR/c1/wAE8PHGmeI/2dPBmmtPZw61o+l2 8Oo2kdwpckxBd4XOSCUYZ+lfbPiLTDrGh6ppQx/p9k9oQehDjBB/DI/Gv8leOMHVwPGmMhVVr1W1 6N3/AOB8j/ZnLKkK/D+FlTejpRX/AJKf/9H+1z4Z/sqfCHwJYX3n+C9E1bVtVvpL7UL7U7KO7kdn JOACNuMknp39q/Mn/grF4I/Zf8FfCDWLX+yfC3hn4i67ZSW2mW2m2ASdmkjIgleJcKMuY8HrgZ6A 5/b/AA6zniDMuOMDRwtSXxxVk3ol/wAHqfjfi/k/D1LgrGVMVTjH3dG116/K1/L5n4d/sKfsSeNf 2pviDpGkXek6bF4F8NXSjWtea3/c3yxglgXGGOCOmevHPQf2k/CL4SeC/gn4G0fwD4E0i10nRdJg VCtvCImu5AoDSvjuccDoBwK/RfpI8WzxudUuHMM/cppc3r/w/wCR4/0fOEI8NcIf2nW/jYr335Lo l9333PgX/goz+3bpX7N3gDUPDPgHW7K5+LGpk2sVvCyzyaMmBvyOnmHIGByoz0bp/Hp8Rvib4k+J 2uX/AIp8bazNf69qOpHVNRSSZpEJVWVSB0wN5455JPU1+m/Rf4F+r4WrxRjYe/K3JddP6176rsfz l9KnxChisxp8K4OpeEE+ez63V/PV6dVo7bnhOs6vFeK5WSayt2n8hriKPEzjIHcd81l3dvBJf20e ktLLGLVRcz3KLHNLLk5AwegH9a/tCkuV2P4ZryTZ/9L4ZvLTEUmJcbFPmgNhT7Zqro0lva25tJLj YLmXBMrnzZCeMA/QDp6V/uvbW5/gZTtZo7DQxp0+tJpbqEXzUjspIk3QyuXC7m79SO3f8D/VF/wS W/Z28eeA/CMOs6nZQ2VtrGoTazbukn7qOMhUXk88BBgDjBHfNfzT9JnNMPg+DZYKq/eqbf15n9r/ AELsuliOJ8Xj0vdpqKv681/u0v6n7n+KoJr3w5fWyMqyXEJTfnaASCOPzr8WNJ/YM+IrftCf8LN0 +6sLPS11ITanC7uXuo/ukqSMZ2hen93tmv4I4Lz+lkUMUqu1SLj+f+Z/e/E+QSznM8HiI/8ALiXN /X3H7JCWHwX4TkuNZlS0sdJsw8krj5SFUA4z64r8i7P9pr4UXf7RepCDXLRILfUfsh1BpUZ4HyUC 7Qc8bAD3A9aOEskzHN6+LlgoOVoO/wA9kb8U8QZbk2KwcMdUUZVJ+7fyWr/r/M//0/7dI/HGheP/ AAoy6JcpewXtv5BuI2GxCpw3T6V+VGpfsH+Lj8dl+K1vq9syC4MrLjePLZDGFOMdAe/U+nGP1XhX N58MVsXRxEXzTi4Ndj5fijLFnksJiKDVqc1P16H6oeDvGWk6TBZ+E55VXULWFLdIEYBmdVA4B9cZ 9eelfnX+3Z+yn4j+LP2HxjpF0lv/AGNdi/uTtLrgKASU+9xtJyM9TwaXCGZPIuJI5hOOkn/6Uzj8 QcreecOVKFN2cPf9eRbfM6n9jr46+D/CeiW/w91vVojrOnxizmERPmGTCPtIIx1LHOfX0r6K/aY+ FCftFfDnU/C1nPBZG+gKW1xLGJlbHKlh3wQD1/xrvznD4jJOMo5rVj7rlzrztrYwwFfCcS8E/wBm 0pfZ9lLyfwtn5H6P/wAEbL83w+2eLC9rdym4YQWMa3MbA/8APXblR2xu+lfsB8EP2Z/h78CvB8tg un2F2YYEM9zNbKEXyxgZz16V9hxp4rZhxHl0MtwzcU7XPE4R8M8l4YcsRWgpNK12v6/U/9T9j/8A gor8bPBnxC8T6R8G/BOhWM3iG91lYAbHylVokcLL5g2lQrDfj8fev06/YZ+BV/8AC/4d6Qt3NBb3 NzClxNYwDCI2CSVPYZYge3p0r+o+LamIy7wzwWWY2/tKjvruuup+LeHWGw2J46zLN8Db2KvHTS97 LTy0PqX483FvafDbxDcTvAqw6ZMczuq4ZF4xk+9fgX+y/wDtIa7r/wC0Nd+B9O1xTp9pqLpe26u0 KyRGRdmAeCQGGSOB/L5Xw8yF5nw9mdacbxhHt1se9xlxVRybi7LMsckpVm015N/8Bn9GFtpmnyaC t1JHDJutyzPdyLwNp+9zjGOa/je/4Kxw+Go/jmlnpeopJGXuleDT0U2scu5pX3sBxgSArg4O89e3 330XliY+I8Ur8nLO/b4Zf0vM/Gvpixwn/EPoSf8AE542/wDAo3/Q/HmSRF3xRTpKA5QBD0IP/wCu tK2+0xRqkBKyyR7JcgEfMMMuP0r/AEpP8r1pc//V+CJ0mt7Zrr5V3SeSGbld2M1Ja2ur36iK1spn ieIt50abhgHkg+1f7xzvqj/AONuUstBJGTFMWBA2Zzt3cdq+gPhJ8T/FPwulfUPBd1dW2pTXsd7d T288ap+6jjRf3ZX5iVjxyc/McEZrwc+yyhm2WVMuxCvGasfYcF53X4c4nw+c4d+9Tlf80/wZ/Vt+ wP8A8FBPDHi7w1pPgnxrrNre+IX8pLe6tr3zlVGGMOh5RgQwKt6elftCRaalZFWEd1ZX1vhlI3RT xyL0+hBr/JvxR4Ur8LcXYjDqDUJSbj+p/szwXxNhOL+HKGZ4eSd4q9vQ/On4tW3wd/ZR+IEHxL01 dN0e916RLvVNOWdUnlcERsdgI4de5A6dT1r7n+HnxA0L4k+GrPxP4em86wvEDL84kK5Geo7HtXz2 cYDMsXlWHzzERbXwN+jsj1suxuDlVqZbQkrw1t6s/9b+5nx/8BfhH8Ub6LUvHngfRvEd9DH5Udzf QEyqB05H5fhXR+Bvhj4C+GtnJYeBvC+l+HLab/XJp8PlmXp1JJ9F/wC+R6CvqKmZ5pUwf1CU5Oiu nT/hjy8PgsFh8RLFUopVJbtdTxD9rH9qfwV+zB8NNe8Xa1fWU+vWtkZNJ0Npx9pmdiFV2T0BYYDY BJHOK/nj/ZC/aU8TfHj9r+18aeKRMmpz3QZC5W4jGZ+MyKAOAWHAA9uK/ZfD3gis+DMz4rxKt7nL C+mmzfz+f2bbn5XnHGtKr4l5dwnhXdRvKb/vaNL5fnzJ7I/rFQlkViMEqCR6cVia74Z8PeJYYrfx Do+n6vBbyieGO/t1nSJh0YZ6GvwaipKs3F6n6/iuXVy7miWsNJscs1tp+n2MHLMy21raxoO5OAoA r8hfj7+3HoXif48+FPgp4D1O1vfDmn6nFN4j1iI/ubqcF8pk8eWFBAyM5cHjIr7HhThfMM9xdStC DcKScpPz6L169dtdz5biHinLMkdHD4iolOo7JN9Lb+l1bpfpsz//1/7p9d+K3w58A+CoPFHiPxZo 2n6FaaQtwlwbyNnuEjiBxFGDliQOAPWv47f+CjH7fXiX9pn4heKPCGia1HD8PPDd8kWi6RbNJA1x aiQEvI4ym5wTuzyduMgYA/rL6Onh9iM14uecZjSao4e7V1vJaaX87J6aptX3P5K+k/x/hss4PWR5 bWvVxDV+V7R31t33XZpM/KeN4ZIZ43kjQRsEtY4oiiBMDj8DmpbO2hljheL5r6GXakaIC6KcfMfX 6V/oxTi3SUT/ADajVXPfqfu7/wAEVPht8Prvxbq3jTx3deHEng8RTXmhWuoLGJr0xxpEkrB+VCtC QB06/wB6v6uU8U+Fiq7PEWghR8qgatbqB6DG79K/zc+khRzPMuPqsKUHKnBKKsm7d/0P9XPo71Mu wXhbgn7RKUlzSvZavUYfF/hLdsPifw7uBIKnWrbIx1/j7V83/H39sr4I/AfwlqWtax438PXurQoY NP0iz1BbuSWdvlQSGPOAD2zk4xx1H4tknB2d51j6WAoUZJzaV+V6Jvfpt667LU/T+I+MMj4cyutm eMrR5YJytdau2iW+78tN9j//0O2/aU/bG8d/Hn4l6r4v8ReIYdQsbXV7i30nQ7nKxWtssgeF1IOF 3YTAXgBRxxiv16/4J6/8FGbxLvQfhl4zv5YdCt7OKOzvb6ZLiyYNhXiSTAZSjDvjhu/Wv9D+OPBu i/DmjhMPC1SjFW6tNLR99Ot35dXf/Pvw28b4VvFLEPFz/c4lvXZb3/PVfofvVD8e/g7NCsw+IPh1 Aesb3mJkPoVxn+lQH9oX4KJkSfEjwzGQSMPe4zj04r+NKfBGf3cZUJK3kf21X4nyajFTdaOu2p47 8Yv28f2aPg1oN3quu/EfRb+/js2urLRdNmM15ekDKrnAVc5HU59q/mK+LX/BTj4h/FX4ueIPGXhe 6bT/AA02omDQYpp/KbTlikwMR5OflwBuxnA6Div3Lwg8HsyzCeIzbNKTUVFxins72bfr2W617o/A PFbx1y3hzMsHk+WTUpNqcne3WyXpa+uq1W1mfun+xz/wUI8BeKPh5pNl8WfFFto/iCC1UPdXW7yS FUde/fPAr0X46/8ABUP9mj4QaRctp/iZvFuuy2byabaaVas9oZAPl8x2wcZIzgY96+LzLwfz/EcW 1MswNL9zKekt0k99N972tptqun6RS8XeHVw2s7xVRKoo3cb6t+v9Peyel//R/dj9mz/gqs3ib4r6 vP8AEDxPBF4W1C4U2Fm5CW8MLs24scZVl49uD0r9JvF//BSr9lTwh4fudcm8cf2pJbx5XTdLg+03 ErngJkEgc9+3pX9L8VeB+d4PN6WCyyl7rjFbNa927Pf9Op+BcMeOXDuaZTVxuLqawb2tql5XPwe+ M/8AwUiPxu+Pujay+o/2B4N8GX4e30uaX7Kk0RlUqEfJBfaoJPBJzX7T+FP+CoP7MyeDbXUNe8TN Yz6dpEZnWNROJzEiqcc8Hg9e9fR8Y+CGY4bJ8uw+V025xj7107Pm1b23vrY+c4M8dMpx2KzCeaVE lzvl1Wijpaze3T5H43ft+/8ABUTwr+0paaf8O/hVpWpv4U07UPtVzqDyRrNdukgUSspHAyhG09Af WvtP9jP/AIKSfBj4X/CPQPBHj27SyuNHtdkzWDvMYnVE4XcMOp6ZU9VPXFfQ5r4J5hS4Cw2VUl/t KfO/Nt7Pt2XXrqfOcM+OWU4jjjMMwrySwskorVaWXTvolfpfTQ4f9rX/AILQ/D/UPCGteDPgrYa5 e3t/ayWeq63BaNKLZJAFSLeVCR792C2SRk46GvgX/gnB+2T4N+AXjf4g+MPiRKp13xHepdTS+Sbi 6uI5MswQIAANzMTjpge1fV8LeCGY5T4fY/CVU/rWIW3W1rWtrb5+Z+fcS+O2U5p4mZfjqVvquHfx dO+r03d1ptot7s//0v6JPij/AMFxfgj4e0q5h8FaV/aeum13wSXl2TbxM2VDeVsUkAju1fzRftT/ ALUfxC/ak+Jms+O/Gd8UtZnFla6PHdtcWsUUTloztHyLncfu9lAJ9f8AS/wH8FJ8J5jPiPOYfvEr QTW3nZ323vfdK2zP8y/pHeOFLivL6fDOQz/dt3qNO+2lrq2vS2ujd90fMV1KGV3RjHjG0YwDx2qj mK4SOW+aVVQkAQnaZOuCP8K/rqmlzJo/imo97mTNNZW91bXZt5J/IUx+QrAFgSMgHt0H61syXst9 uIhW3tSAI4C3mvFjtu/wrcxIJT5bpFHGZX2bgV6D2qiZZsiRYJGuIn2Og42KSBnJpPZmlH+LH1P/ 0/EfhF8cfEvwp8Q2GuaJcTW8lrAI5okkURT7QoQkYzkAY64OefWv0d03/grn8bdN0rT4NGa9RYoi 16t3Ou5wvHy9tx54Br/YLj7wjy3jXMI5jUspLe6/FW/Ffjqf5BeG/jtmfAmUvJqilKmvhae3W1m+ j2120srErf8ABXr4+i6Rra7eSJ0BS1SWSCVuM4Z/LZFI9X7eteQ/Fz/gpz8fvifpE/h291UaRBdQ eW7reidIWwRlyFUMR9Of5fKZf9H3IsJjKeLqtNQadrdVb5fP8D7PMfpQZ1i8urYKhBp1E43b0Saa 6a/LT1Pzon1PXNc1KabV9afVNQvdQF5c6rdkCaTa4fCHOAPl4A4r69+Gv7Xvj34R28em+Gr4t505 lkukutrR8HOcHIJJ9DnAr9T4h4PwXEWWQyirFRpxtbS+i0sfkPCHiHj+Ecyq5vSk5zne+trtu99n 5/eehxf8FPv2lI7v7Pca1Le2i3hYwx6zPGYIs8GNWBG7HrxxTdV/4Kf/ALRN4z2lr4tuFsruTyZb WG5ae7s0HDb2BA3e2QPavgafgNw1GS7Lpyr/ADP0qX0muKHhp0FHVvfnf+R//9T5i+J/xg+IvxO1 K9uPG3jG58ULcSM6wXcC+Sp3hoyoJbDIAvzDB615XLLviSPy0WQMP3jEgken5V/ubkWR4LIcHTy3 AU1GlHt+b82f4O8RZ9juIMdUzTMajnVk7v8AyXl/W57D8OPi74u+GUkNz4P1dtMv1fatzKWnt4og B8vlgjknOTnnPNe6Tfty/HZrea2XxzFqvmRFIruISWQsnPBxHt+bHPGeo6+vz2e8AZLxJmP9oY+N 5bPztt/Wp9dw54qZ/wAIZRLJssa5ZPmV76N76Lddd1r32OB8R/tSfGXxNYHStQ+IPiT7JMpS8W0v /s32oHodu0qCOecHrXz7d6neX9613PLNNcyhUmuJ5N88uxQilm78CvRybhDKeG+ZZXS5XJq7677e n9O+h83xBxrnPFkoyzirzciaS6ap3+f9LqekeCvix40+HsoufDmrXFkdxfbbRxCQsyhfvkZwcDIO R7V1Ev7S/wAYkvmlbx5r/wBjMokW2S9+zFdwO7mMKMZ6DHQVjmPA2RZtjnmOPoqVR6O+2m33HZln iVxPkmVrJsuruNFO60V1d3dn5+ae++x//9X5/k/aE+LEkzTWvj/xHFdpcE2xmnaWFlYHfu+b5j0w Wz0rzrxP4i1fxhdm/wDGWq3etXcLCaG81C+lYw4GWRF3bQCQDjHUD0r/AG5wPBWQZbWjisJh4xqR 2fY/wqzHj/iTN8JLAY7FSlSlun1/C5mR38iJFPDIVZGEsDA4GRyDXoQ+KXiu2ayNvrOqW9rbw7TD b3XlIxI2t8oGGHpuzzj0r0sXkWAzWKhj4c6Wy1/Q83KOI8yyFSeU1HTctHazvb1uVLn4n+I2aGWb WdVv4PL2PaXV4VZj6kgY/DGOKzNR+IfifXNNTS7u78mzsrgzWTIB5kQPOA3XdnqSeg6VzUeD8goz UqeGjeOq3/V6/O569TxD4sqUp0JYyXLJWa93Z/LT1Vmcjc6tJKzMpgFwTl5ViWKeYnAyxA5Jx+tU jPLcuFab7NJvxJKeuK9xUVB8sT5r20p2lLuf/9b4eGqm3DW9pcnDbZWT+MEEEH16qCPpU0Wq6hcS NcXN2L2VcqUulFwAG5IAbOPwr/eGeDwle31mmpW7pP8AM/wGp5hjMJ/ulWUP8MmvyKMkmzJ3OGLZ RdxKqD1C+g+lZV60uUcSNmNw/rxnkV0KFOklGmkkuiOOdWpWbnVldvVt6tv1JyLl7qGJNrxNb+e4 zgrgZOfoATV+UQSSFkdIn2ZUquUU44FdClbY5nFp2MWCKSLJkcFs/O4G1T+FaMNyIAHhOJip2yEf cyMf5+lIk//X+CHMUnzNKJOcM3fd06fWohElpIVNwsxmwSqsWWPjG39MnFf74H/PeT3cIQx4d2UD cgDEJz3x0/OmMI1iTYxBJ/eDGTyTigLDJohEyNHcq4PzFYxjA9Gz3FJE8kwcpIpVDtBz8ysOo/z0 rOYDmmd1YS/O5G0seCaWySMx3EErpvUg+WRhjnOKm/u2A//Q/Pq8a5tmEUca7k+cLIPlHcHH0/lU 8F/NMyy3qLJLu/eFU2I47YA+gr/eg/57xJEjUFx8oLdhjOarzSTKUiRSFYH94hGUq4ysrMCxNe+R Hi5LTKY9iyKctnHHasOzDsfMgEkhkbIMpJZT6YPP4VLbb1A3VkIiTz2UTlyrBExGB/8AXqW4e2t5 ikoLYhxtU/KDjg/qKQH/0fgKOXzlXy8e3rin3DR2xha4ZQA4KZbBDdAAPxNf70H/AD3kkmp2w8iW 1WSGdS0Ez7t6vvIC5UDj8c9qkRZIQyu8cm053Lwrj8aAGc3JXbjGecnpSzaeZw7W+RJEPPlCEBpt nJznrx+go8gKF+LiXTJZre3hkkghka6t7gLiaF4ykikHg4BPv83FfiJ8e7VYfE9xHdwosZSR4pdo WNQrAENz1GRX4X9IHml4e1+VdV+aP6m+ixKMeNZpv7K/U//S/isvpJn+zxxxPMm3ZCsKhmYZJJ/D k1mPLBJMIEwGX91Iznbhh1XHr7V+lSw1WUm7HxEcXSjDcf8A2ZckxLHGmya4EBkZvmHuAOeMVY/s 1LIJDcFt8020gDkk8Lj26cmiWEq8uxSxtLuizb6bas81pcSGPzZQqnfkgjnbjtnirFrpkyXYt1xt 8zGM5YL6kVgsHXW8RvHUFuzXutItnjeJHi8zdl+QCuO59K5K7sJbElY0WSOVd8Uygusm37yqR1I9 PetXgcRJfCxxzDDr7R//0/4pE0u6ngdzGUmXE0UTHaZkx0bPKnNbVjZeVKiX8tvZjy12xSyqjgno Ov0xX6XHJMwnrGjJ/JnxLzzLopqVaP3ofdyLbGeRH01hayIpaZ1eP5iBlhz2qudFtBJNc21zbTW0 kYkY2rbt7fxBMdcc9PSrXD+Z/wDPiX/gLMnxBla/5fR/8CX+ZJbWX9ows1mkbQPIIy8n7hwfQBsV QGjX1vNJbXem3MbJP5UbmI+Vhj8pDdDmr/1czZrTDz/8Bf8AkQ+JMoTs68fvX+ZJBoGovfbJYo4Y gzK0006xgFfUE/zrQtPDst/M8cNs94Y38t57ZPMjibp8xHQVn/qxnMnb6vP/AMBl/kT/AKy5NHev D/wKP+Z//9T+MV/DWpvPMgtpd8MvkIvlNhGHZj05/SnN4Wki0959QiNvqNtKTcQq28FScKeRzzjp 61+qR4Mz6SusPL8vwep+cVeMciprl9vH8/yK9lpGsvcwGaxa0sbkFYbqTliy8bSmM89q6BvCmtRW lxdCGe7DP5Frb2VlM144PVwCOce3pWi4G4ie2Hf4HDLjrII74hEEfhLxDL9nzaX9vG/MLNZv5krA 9z0X8ea0ofCfiaYywz6ZqAmlUyZe2b5tpxnP+etbLgDiV7YaX4f5krj7hxb4mP4/5E0vgPxRbW4e XR729mMmWSwsnYW4PTczY6/5FSQ/D7xNLOTLo2sqoQDdb2guACf7yoSeO/piuiHh7xL/ANAz/D/M yqeIvDUFd4iP4/5H/9X+PO68D+LjBcWi+GtUkNtOUE8GmO7yoeVY9xVW2+G3jK4RHt/Dup71n2OL iyaBtoHLBTz6Cv2leHvEr2w7v8v+GPxp+JfDXNZ4hW+f+RLqHwn+INsllfR+H9WYi8UTxWzInmIS QGAzyB3HtW9B8K/G0kGX8P3peOVm3zbYxKvO3aQST+PpW9Pw34lm7Oi1/XkZvxQ4Zg/46f8AXyK9 j8MfG4f97oN7E7uykNGXUY5Ubxxzmta2+A/xWvIbpLfwDrt95kLSrNHBk2pHOSwPA98dK7I+F/Ec lf2f5/5GNTxc4Yg7Or+X+ZUb4FfE+WysoYvCt1/aEXzXsDoY5SuMgjrwev41ci+CXxKmvLKCHwtd LpcuI7rUDHJIscgUb1QbAW5OM4xW0fCjiST/AIa/H/I8+fjBwx/z9/L/ADP/1v5Hrj9nD4m+bdy2 /hLxAtuzJFZ/aIUihuznDvGSc49iM11On/An4kabYXNpfeH7q1tnIJNxuSSVTxnG3kduvev6Lh4Q cSyaTgvx/wAj+c5+MnDUVdVG38v8yjY/s8+PN9zK+lXsNgsuy2D2rSJdgdfKK5I/4Fis67/Zu+IN 3/x52s1rGrxzR215GwnhGRuPX5s88Z79RXYvBjPn/wAM/wDM4p+NmRLr/wCTL/IsTfsyfEVNRkgO lRx2s6qq3EpDTy8dSM4HJ9a17j9mj4jxwpbXllb3d4IzE8dqHjlWM/c2SDIyBjrjpWy8Ec+lt/6S cNTxzyCL1/8ASv8AgGnpf7KnxFi0ue0l057vUHVp7MBd8yAHGGxncFHXFRaX+yp8THZ1uLeaa2nG yHZp8ixMw+8qye3rzj0rsh4DcQzV1F/+AP8AzOaX0guGqbtKUb+c1/kf/9f+UyL9kv4k3P29YdJl ee1zJI9wvlQWQBxyQctkew+lb2ifsu+PryZ7OO1BFrYiaaaO2LMMkKSvOOD2PrX9ZQ8A87+3GX/g J/JE/pE8PJXhOH/ga/4Bow/sifEhklt7iFo7ZJxF58kIgllLc4JLAAAfxVJD+yP8Q7ayluYbSwFs shtJ5muzPKi7vkYjr1//AF10R8AM2e8J/d/wDkn9IzJV8M4f+Bf8EdF+yV4zH2WK717RrqeQvmO6 heDZt5CblBAzx/jUtp+xt4+ab+0rdLSTzka0+wR6fcOyOCCGifO0g4688eldC+j5mezUvu/4Bz/8 TH5RHXmh9/8AwTRP7JPi/UoDbDW9Kt72KAytDeWU0AR0PEKnpvPTk49xV9P2K/Gg0Wa4vL7SLi6v JfsxtNOuMSRIByXychjz69q6I/R6xy3Uvw/yMqn0lsrXuxcPv/4J/9D+ZyP9izxK9zFHDBcL9icP cW7WbzySDbjAwDnPr7cZp9p+xXrkkkyrHqNv8sgjtbTT496PnLO6l9/HuBiv7Wj9HPGSV/e++J/E U/pN5Wnytx+6Rai/Y31SM3kT+IrdbeezWGzMtmxu7aTozOygg/Tj6ntNpP7EXiLR0a4tPGem30UK lVaTSZ7i4G/7rMwX+Enoe+Oa6YfRwxDWrf3x/wAjmf0m8u1St90jTP7DXjnVUi03VLW0uvKlE9ld +eNKup9/3WYM4G1s8DJ7cVBZ/sB3s/n6de6/Y6Bercm3OnXRnkuC46ZcKwAPbBOSe1ddL6Oc1pKL /wDAl+hhP6TeGUXyS/8AJX+qNKL9hOS6OmaXN4qsj9nk3kSXDITIpIxJIR8oOOBnv1rRvf2J72K0 nSLVvDdvds7xS+fGtzenZ9zZggAHHBDHg9q64/R0g9HD/wAm/wCCebV+ktF7VP8AyX/gH//R/nP0 z9iG2i066nWeSW7jTbeSR+ZNDvck/uUHK4744HvU837Gd1caZBFa63bRIcWslw1vsiZyOrK/JKju Md+DX9/0/o50E7OH/kz/AMz/ADzn9JSW8Z/+Sr/Ikl/YZtofLSXxIt2RbiL7TaS7bYPgDdgDcO/U VqJ+xBFpkZnh8TW13Fb2qRGWNRcCR2wCTGybuOeuBXbT+jjgoyu+X75HBW+kripaRUrekP8AMpj9 ji3himW9upgr4aCSBktBIpOWfavJHsKe37F2ilpryOWea0fbCkyTy+ZAcc7wDwDg/eyPau+n9HnL 4bqP4/5Hm1fpG4yezl+H+ZOv7HWjMiWl3qN9p6rEXAWUysuOUwo7HjJPI9K07f8AY38IsYEOtXcF 7Mqw3M80jyWo2nKuMAEAc5GDnPSuuH0f8rW6h93/AADin9IjMPsOX3/8E//S/ATVf2LvDNld3G/V 49TKvEbBNLWVLd248x5OAB6ADqT7U2T9jbwZLfTSSzX2ly7Akc80ry3HGAVkQEYBGcY6V/pZDwCy u+sYfd/wD/MCX0h80aspT+//AIJLcfseeA5D5NxcTbEVEKJalgUHPyuWJG7rn361rN+yF8OLgPLD B9itraAtI11dvLcakwwNgO1iOOzcDFdlPwGySK/eKN/8K/4Bxz+kNny0pSl85Nf5mlp37H/wrFqr afN/ZF27tK1rqupSTRb8cNGqW4UAkdCf8aW1/ZG8FyyrNrlxPJaR79p0e9EN1GwGQdrKOD0HXr1r tpeCOSwVlb5RX+Zyz8fs8qPZ385N/oQn9lLwGssVzaSX0G0CAvdXbT3rJuySXA6exzVuX9l7wHFr F8beA6hpcUsUlz9o1I+debMEBCY1OM8kbDwOeoroj4LZJHXT/wABX+ZlPx2z52v/AOlf8A//0/w7 uf2Y/hrql1b+bpv2W2mmY3IkK3DbsAqIyFGBwM596uJ+x58Mbez2RW2kR3ZuTPK1teTXF3GgwAu1 VCAZ5x1r/ViHg9kUVt+CP8m6njjxC/hf4siT9lT4SqZ7W80S7lXzVlnuH1aSRG90jIyO3GT+FNg/ Zi+FdpBcoLG8Ja4Z4ntmjhE0fRUckEjpknH4VqvCLh1fZ/L/ACOGp41cTz+0vx/zLH/DO/gCYR21 pbyW0AG1IL0rPHAAMnEigHr6irtl+zn8OIY7y8vbMX1/eW/2SGGFmt7OHacAzjgvx/dx3ya1j4Uc Oqy5H+H+RxS8YeJ23ea/H/MsR/s7/DCx0+3t7DQbTSbmKXMkFrbhkuQ/3n3Nk8dhnv360+T4C+Ao pJLWayuJ/KkEkL280dsRx91lMZzznv26VuvC7h2CtGm/w/yOWXi5xNLeovx/zP/U/GpPgN4GslHn aPDPqEjq/nqFiTYcHYQo5PuPWtaL4T+A4vPt4NCEN4LgywfbY4LlY0K4KYMefoea/wBbl4bZBDX2 X5f5H+N78UuJJv8Ai/n/AJlEfCHwXLafZZfDmky3H2gOkr2QaVgDna5JwQemMY61bi+HXhbz1MWg aTBErYmhttGtI4lXI4X93kfUn05rspeH/D1NaUE/X/gET8SuJJbYhr0/4I69+Gfgm5g+x2/h6wtZ Q28XbLvlIBztwBgZNJpvw28N6JOJ59EtL2SZlEsUun2zraBeVKCRGA98Ln610R4GyBaLDr8f8zCX iJxJLfEy/D/I6b/hWHgF7xbiGxiv01W3fybCYQwvb3THDZ2oAF6lRwOR2HOBP8O/CMVtDBb+H9MR UiaOd/s4km3lid6k/dxxwuOnNbQ4JyGOv1dfj/mZy4/4hlo8TL8P8j//1fyGTwtp7aYlna2Nolp5 mPMubOK4uCR12s6kqPZcDpU1v8O/C8sVzFcaZYyXG0MJfJWB4yByuFAzmv8AY7/VDI1/zDr+vmf4 x/68Z8/+YiRo23gnwkRG2o6dDDHZ2ogtYrCyhjkmIPV2IOT1JY5J9atr4Y0S4uktbDRtGlgkbd5u raVay3C4U8mXZnt61pHhnJYPTDx0/upnJU4tzub97ET1/vP/ADLc/hrSdKmsb21srGTUIJHJkbTY VhwRtVVULjAG7IPrWEfCmmWtyt1Np0TDebj7OYwlrI+eCIhhcD0HHFaf6vZR0oR/8BX+RkuJs4f/ ADET/wDAn/mP1PQdEuhaz3Gl2ULW5dlkgt1ttrSY+dtvXbgEU2w0DT2kVL9ba8t7CYyWgNqpS4AO dp3DIDY7+var/sLKltQj/wCAoifEWbP4q0//AAJ/5n//1vyth0/S3uluF0rTxbC5Ny+mQWyxq7Do GbGSO3U9+lb2r3g8Syw3ktlaWF2sI2RW0CIsexcAHHpiv9nI5RgaT5qdNL0Vj/EapneYVY8k6kmv NtmKNS1Ir5UtyrMrfM8UQiMg6YbH3uPUmnT2cElpGTb24SVtyxQwrCYeeu0AY65rdYGin8KOb+0M T/MzMTTrRnlNxbxvubK7FA59SO9aH9haZaSwz2bSvI6+bLGyCNEk7MMckj39K0+p0P5Q+v4lq12W 5jdySpFNcSNbuD9oQjO/Ix/KqTaVb2Fut9mNoow0cEDIHiQY+fKnjkN6VEsLS5rWJ+uVtm9D/9f8 xBE8+mQxQGAWi4eG2mAeGLnLbB253H8agm0k3kix2enRzzSZjiSKH53LccBeSfQc1/tF7Cl2P8Pv rNbuVbzTFs4YWhUvCcJJIq7VhcDJU+4NWbXFpIk8ccHnY4nmjEuARg9ePxpulSvsDxFV6NiMtvdi SSZfL81tjyxIEK4ODgVbu7S1d54rdJvsw2NE9wF86QBe+P8API+tP2UFsjGVarfcq2duZn+yuHkC gvEGkCxrjk9T6A0N9nN1dOn7prrAKRfJGSO2PfGfrWijBK1hqpN9Wf/Q/LJkSJS6ht/Q8cVYtDH5 NzcyWwkeOMrEmRGGkPCnHf8AlX+1kVTP8OJSqdyWSaS6FrLdJJNNBCI5Js5YkZxz+OB9BT5LYzWv lxXEcG0+cUlDFWIHoO56fjVWja4rz7mNMJWCqn7p2wPkBPI/xq6dxikQ8bgFdG747fpWJolLuLZw wWskk7RQEzwfZHkmjD7Ax6qex68jmorm4uAYbWPyxb2IaK3dBy2WJJz369fTFF7IaU+5/9H8qbaI ajJcl5gr6WV85fM2vIkndR0P9Ku3FzYtGttbW0gCuWadpss47DbjA/Wv9pXNLY/xAje5ShMcdvPb uS3myCQl/mPAIwM9Bz2qzYW0L2zXEIMcKH94WO7aSTjH5fzpKfc1s73L0kdjd3sB1dUntEVWma1Q RzTEcgjIxuzgZPp+Jyru5lujIWSVZUmKQNOwZ3iBwh477QKfOjRRb2EVNkQgmOS5yFPLCp8afDlX lMamLKqOSW+n51infVGsYpOyP//S/KfyVnZoiGkXb+7IOGHvVCaH7NL58aSyi3iZCShK/MBkZ9eB X+z0pPmSZ/ivGDS0N+O0szHay/afvQq1zs+T7Pv7EHuBgfXNUr23ttP1OWz028kvYRJstrx1YeYH BOTn0yR+FUPldtSsYJrFUecg/vWVbjG1Hx1APT0/Op77UopvJMzs7IQsCIMrHnjp27EmolJp2RUY KxDBH9vlmtnXzURC88SsI3wMk8/56VUl+WNmJOIztiA5AwcY/nUJy6FuK7H/0/yPZ3kjikAIKP8A Nn7rfUVqQ3E9vHK8Vy0U8ZxGYGx1yD8wP+Oc1/s21Pdn+LN422M99Vk1B7WIQXkc1uhjlluJxMt0 2eCO4+nNPRVumKTztbXkTebE6jKt1DYqDSFmjTc6RBHeRWsc0twyIsVxORHuOPnbaD+X9axwgMMc d2fPO9fmI75wP6VMldWLEeTybpliXaV+RscMPUUv7++WaGJEhZZFjlnn4Cj6fgaxtbQI7o//1PyX 0uytor9o7uaOEhCCSu7djI4/mKWW72R3Mds8kLDdE7p8rSIeDj2Nf7IH+M6Lf2/TrTTrUwzPcTGD M7GPndzlQPYDk+tZc/2Od4r6GN0klQeZI6eWsgHA+XHb1NYu7Oqna1mNvHaCRXBCqqZDMfu/5xVC 5ubmdoXdvMROF2YUJ7kD19azknayNk0i1cm1MVvKsyyMwCNGjbpEb6f1q693p8FvLBcWj3E0A8uK VH2eXIf4ZOOQOuKpJ2NItJs//9X8ebS6tYXuraUSLcRxicEYZMNnj9PwyKLe5jmjd40eZonBUMpQ AkjB59K/2EnHqf5AwaQy4e53K1zdRzRvwE8sIQenXv3qKO300B7hsSTocRPEMh/UMfaoacdzTnib GnraxqL64jE8EUgWW08zymk3A7ffGRWfbpaxXTTvEklzKeN5/h6hR7VEot6HTTkrWJDfwWcd7qF1 GGdI2j8uGEGPnjA7jHHSnW7XL2hitgiYT7RNbEYM3PGPfB6fWs+XS9y7+9dH/9b8cLkXkrP5YwIw FeIjb5We39asTQzpbpLbwGWBTkts4GOv5Zr/AF1kk3qz/JSHM27IgxMIZVUPGAuZFyVOAe/twKzB ZLcDzZJMEtlx9OeKxfKbKM9kjodIshqRnJEVl9lRjDJPtjacKM4UjqT6VnNpNxLOViEcamQyy7v4 +Mfn06+lX+7SFKFW+xGbG+UTyAmCKOMq7fdIX2/Kq9tp0tjZ/a4plRHm3MS+Zm7lmHoazc4Jm9On VejP/9f8hbu1jZIr2VQFUhyQdmPfNRWtvqWp3c92sbWzWzqLWB1CLcw4ALA9Cf58nNf63qrBxuf5 RSpVVOxfnsLzTlEVzbS6eJnFxDctG2XjU5ZlHcdeBX9BX/BJXwxpySK+mzXhOoXR12KKWMqzyj75 CnnaVQH6ivxDx4xXsuAcRydWl+b/AEP6E+j1Sb42i5LaLf4r/M/bX9rvWobf4dazDYzCSLVNLdlU yeRJbyxo26U9uhx9a/hy+Nera6fiB4q1Gxv4Fnm1Se5juL5VLCRCRKrk5VslTjGfvCvzf6MtJLA4 mt1/4H/AP1f6TNS9LDU1/Ov1PxB/aQk/tS9ikkCywveSCR9mxI3wzZ29PvA47cCvlD7PbFHWW4KJ EMoQu7eewx71+WeNOI9txfiU1s0vwTPuvDSj7HhTCrvG5//Q/hdt5WCRxoAxH3WA7dq2tO+1w3BL NvCsC6kdAaynvY5/I6doo5E8xD8gO4K3zHJqWMyQBRFKZtwzJCoI2E8Y59u4rmq6GsFoayWsiJJL bR+ZOkPzFl+fBwMf59Kpu72Fqy38UzjZvXZGW2njOcdjXFPYu19jpdMe2u57aW/jjlQwA2e8BXtS Bnfjswxx3rqbhIgIZJbt0dW3W0sbZLgf3qyGlrZn/9H+Pi0udJ/tCa0vJF1a6W3+2R2Uke2FXHCH cPQ4PXPHpXLzySGdFSRNrSEeX0Jbn5FHt/Svm59ToStodFYzKtlcSXFnIZLdd0USplDjPJ+vH51s aZJbOsN3e2Cq+/zFhb5cDsQRzWZM1oT3NxdTGadGDW4BVLcqGYfj1wK5KS2mnnL3MeY0kDkfdwOo Cn8qwas7Gckk9DYSyvJrbT21W+TUAZpfscCx7fsaggKobvxjj2967vwre2WkXNvaztCkly5BlniD +Vg5yGx8vH8qiUP3bSJsf//S/mk0O0XxTPFbgtcRm/hnjMQ3SK4nRWYdsnPSv9CT/gmX4Pl8PfBv wxoqyW9zZxaHb31vK8flSKnlhXiX1CsMZ+tfzpxy19ZwsfN/kZ04SliozWyv+K/4B+pbwwgja/IG NvYU63AR5FI6r8pxxXgr4Uj1CZIiHdWLDdyCDgD/AD/Sl3+TJycqOM4ywpmyScUmH2lZiwBwvftV N08zJBG1R69aqK95DSsf/9P9/fskjZ8uQKQpb5mAHGSev8qltI2tkUyrheSAxO5jX8m1tJWNWrQs Z+syCexngXKiQ4Yld2F75+vFfzs/8FZdMnj0q2EmlPcGfW7ya9Nv+6AjdY9oY+gGRgdd1XgF/wAK NB/3l+B5OZxaoxl2kvzP5V/E+pWd1rOpQQ3Mjf6UsSpEWUr5YB27h7jn2715zrUd/wCJPEBuLwRS W0dvFb3iy3DKViRQoKjnLEbRgentX9F0f4UfQ6XK+jBrGysNU+0aWixxrZC2W2aZg0qA/Nvc9A36 VOtpavbQzzwfZ7+Sdg9mJvNjVBjBz3yc1q+g3uf/1P449ixpJhHRTnap/ebaxoba6a/sp5o5ZLQx yRRsSVweMkDvXh3VkjnOrttOt7USx2+d0i7sTYIPOTz161T1TT3aWOB49vmQjJz+7G7pz+NJL3zB 7sxbBbuwB82wMahmSCQtuUhTtDDjGOKmJ8Tppkq+dpI0m4ne4efzx/aDgHCoU7AdAa1Id7qxU0KL 57mYh5FhQF7cruU8/ex65x+daHiu0n1C6sNShldks7byBGWwsSn7wHqMgdaAl8LP/9X+MSe5xo8e oXd0kFus/kQ7GDSXTjA2qvJPUdKuS6Tos5tb1Lm5tLuCMT3ZciITAdVK85X9eK8mHxI8i9lY1ZbC SBWntJreS1uLUZhdl8tEJOXHcH/CnBdJMZ0/Ube9kdrDbb3VrL5Manphj689Rj612wsrFRlZWGvf ajpaWOg2UANncRZFxcxi4faAApL4yGyMc0/xLZaounLp+oTmW2lUSBS+5JTjrn29q6abXOCfutHi 14IUU2YtsNA3zyrkuT9e9QaZFqGn61o11AI1tH1WKO4uRgtahjt3tngBQSTng4xmvYw8+XEU32a/ Mwf7ynOPkz//1vxn/Zw1rRrnwjZWiXq3eqHylNtNYiGwuI0iWNHhlHQ8DC459+/9Uv8AwSB1qOyh vdOtkjbULe7+0BtwacRhsKNvumcfSv8AQHjiP1jwgjKDuvZr8j+SfCH/AGfxurU6is3zW/I/og+K 1rFr3gLVYRKIIprMvCSdreZgbQc+uSK/iV/a20DUdP8Aj342j0/UkSxv3WeWxitQk9tkeRuSXGSp EIzk9M8da/Evoy4pUeIsTh5LSUWvndP9D7r6VWXqtluGxcXrCX4bfr+B82teWWmxW8UZ3W6XPlXT bMQN13cj1PU4rKu/9MivILeJLSC3QSpdH/lkGzgY9z6+lf3lD4T/AD+xFlX0Oa1uTUL2PRtP8rRL yR9uLy2VYGiwdpEgHVuP4vY561rWF/Po+qtY293bGaWLMDwBlQMoy3UcgdOmPwq07O5jZc1z/9f8 /W09H1C1nmTfGbkzXhjbZJET97H16Z9+elTSJaWmo3k0Fg95Zu6wGO5keEyoWG5gR0IXJx0r/Yh+ Z/j47tuJuaf4w1DQdWsbjTHudPe1K/2dqEUoZo/mHyLxzwoBIr93P2Bv+CgmofDjW7fw/wDFXxde XGnJOZNLM0TvGYNuXDFcKME5x9e2MflHjBwdS4q4dkqcb1YXa72/4H5XP3/6P3iC+FOIqmX5hUth Ky2eynsvJcy0+UUfsr4//wCCvn7LnhHwhPqmn3WteJtQmsXjtbPSLH7ZbTzbSojaQHAy3HOByeTi vmD9mz/gp5+z7pmqa94y+IUtn4NuNRvZbWW3lgY3dmpO9Sm1cFWDAcZ6Y7V/IOE8J87pZTXqNPnk 0kl136f15H9hV/FDIqGZRwvN7ri25NrT+l/lufb8H/BVz9jy6s3urTx/DOI+kSvEHf0CjdnJ98Vd tP8AgqP+yjexLND4nvQQGaVHt0WSNVOCxAckjNeE/CziWmm6tJpej/VHYvEbhutKLpVk7+a/zP/Q /rgj/wCCpv7HrM6yfEKG32oZB5qou7HUfe4IxX5s/tq/8Fgvhjrmhf8ACJfBuZtRuEmE0mqyAKy5 yqkNyqdM9zxX7lw54T51iM4oRxsHGkpJt97Pbb7/AOmfl/EXihkeX5bUqYealNaW7eelw/YR/wCC n3g/QtKuNK+OfjW3tNUkjJj+2SskO1pC0bBj8p+VgPl9Pwr9KE/4Kl/selUX/hYkcl0ZTE0FvEsp GON/384rTinwrziGc1v7OpOVJ9Um1+F0VknifkWLwNKeMqqNRpXTa7eeppzf8FOf2P4V3j4jxXCk hI1tollmdz/DtLj9DX5p/tn/APBYHwX4g8M+Jvhl8D49RN3dafLZ6rr1zGYiodWVY42RsKTwevfq CKjhfwjznG5zShmFO1FNN32aTWmulns/u63OLjHxSyTKMnqVcBV5qrVlbpo9UlrdJNrz9D8af2Wf 2xvib8LviBphk8QXureHmvhd6xp8dx9nn0+OVv3hV24OOu0dTnGM1/Ud4H/4Kh/sxz+HtHi8QeMU s9WFhG04aSIoQFGWdmcEH1AB71+g+J/hTVniKNTJ4XnZXWu2vr1XU+Q8M/FnA5jlFX+2alpKWjel /Lp3R//R/r0X/gpt+yO1x5S/EGIxCHzzeZi+ylfVSJOfwFcZ8RP+Ctv7HHgDRptSPje41y6EBks9 O0+1XzbtipKKuXzyRjIHr6V+xYbwn4jrYiFKFJ3k+z7+h+Z5j4pcMYDB1cVKqnGKvo1/mfhP41/4 KHz/ALQH7SXhX4ma1JqGk/DjSdZS2XTI4JFh0i1Vj5bMnLEjCM7gEfLk+o/V/wCL3/BZb9n34efD uWLwxqS+JPHI0SO207SLCQS3UkzR+WhVMhg24cbgP61+gZr4N5lVxGBy7DQei9+y16Xf/Beh8VgP G3I4cO4jMq0lztvlu9H23d99LJ3P5Ovjr8bPFXxh+LetfEvxNdxC51S5E6aY0rXUtnI+zYZM/KG2 hRwOCM5wa8f1ae8utTu2O23+zyBLmERiNomACsDj3Ga/tzhXJaOQ5TQyzDxSjCCjpte2v4n+c/FO d4vP8/xeZ4qTlKpNyu97X0v8v6uathdt5iS3EqiyiXaDsLF2HAxX73f8Emv2hvg9+zvp3iHUPifc W8GpahdG+sddntw8kMUqIDFvJwjLuIGcDA9gD8h4v5XiM04JxWBw3xz0Xnoz9z+jjm+HyrjmGLxN uRUpq70tsf/S/sRuf+CjP7KNoiSS/EMFZAuPKtVkILdARvyKf/w8Y/ZLwufiZaBmyNvkhSCP4fmY DPsK/V/+IX8SuetLf1/yPkv9fOHJXmqy3/rqRW//AAUa/ZQntjdf8LCEaCYwYe1X7wOOPn5zXyp+ 0d/wV0/Z58M+BvEGn+BrvU/FGv30E2lwpZxoHtCVILsofg9gSwAz19PUyzwkz7G5hTwtWLjBtJvr by0tfov1PCzrxSyLLMurYulPmnFNpdPnbWy3fp03Pib9jr/gpkmneO70fFHWJ7LQbtFudPtLl0iM ULFgQzq21+CuR2Jzk9v16tv+Ckn7KNwo/wCK/hjYYD5MBjjJ5wWMmM17fFvhLmtLN3/Z1O9OyTsu q06fd8jxeGPFrKMxy+NTMpqNTpsrrdbvtYh/4eYfsfo0iTfE21iMTFG3RIwZh2UhyD+JFfOH7R// AAWF+Anwy8KagPhy91418X3VoyaPEpjgso5GRisj4ZmIXG4ggcDvXnZN4P57jczo4evTapykk3Z7 dTTiDxb4ey/Kq2JoVE5xi7K63779D//T+/P2If2yPCeh/GvVPjX8ctTiN14l1aW5kkulkujYHzSz LFwxA+ZflPQRj2r9+ov+Cm37JJgllufHrWjRxLKsUlrh5g3TYCwJ+uK/qfxO8MszrZpSo5VC9OEF HyTW+19fwP5/8PPFPKKmS3zOpacm5X2bTba3tolYwPEv/BVT9kXw9ps96vjK5v5obfz1tYreOMtn hQT5hIySBnb3r+Zz/gox+20P2w/FNs+i6NY6b4X8LzyTaXqbRmOW9Ksi7FbGX4Qjc34DnNfU+BPh dm+WcVU86zKHLCktPN9N/wCreh+Z/SD8UcizHg6tkeXVOatVe3ktHtfo/vS7n5hWd+i+RZFBD50+ GkKnaM9ScA/XNbFndNaSrLIBOEcxQu2VSAE/eBHcZr+6MRTunE/z9wlZwnGSeqZ+i/7Kv7VvxH8D /ELw7dQ+Mb6z8KafEkeq6PJcM8Uu11QFdq/KreYzZP3dp56Y/pi0z/gqN+zRYaPpf/CSeJfseoS2 UO+KEqSXKAEHzCvOQeQSD2NfxZ43eFWKzXO6OMyWF5NXa6avru+mh/oB4K+NuGfDVTD8S1GpU7RT 9Fo1strX/q//1P6f/iv/AMFiP2d/B/h3VL3wUt14y1iG3ZLK3huY4ofPx8qsFD59gDya/lo/ao/a V+IX7R3xb1Txn48ZdOXUUtr2DQvtIuYbGIRgRICqpkErv3MCTuAzgAD++fAjwoxOQ5rUz3OKfvxV oabPv5/dpofwF9IjxbwmeZVh8iyWreE3edu3RPTTr11u9ND9mP8Agmr+3n8CP2efhLNofj8yaTfT yyNPc2llJfXeoyIyhyGjVhjocHt+VfVH7RH/AAWy+C3g3w/qVj8LrO+8Q+IptMZre6KmQ2byKQmI lHDqTk724x93NfLcW+EWccTeJNatJP2Mpr/wH9E1rf5n6hkvjfkGS+HGHrSmnVp0bNf37bet+nyP 5VPir8SPHfxk8c+Ivij4r1PU47nxDqc1xDaX1x5ksUcuDtBySCcA47dBnGa8auRqD3CKszzFX/ev O5O1Oc81/cfDmTYXIcpoZVhI2hTilp1fV/N6n+bHEWc4vP8AO6+bYyTcqkm9ei6L5LQsTRWV3FFF LcX0e1C6T2TIYJSy8B884Ht696zbd5PJhjuCDLEAjvApUOc4+v4mvoYLqfN1pNy0P//V+G5IIJYG gZsI4LSOx+UEHI/WqsUVmFkYuDcxDfa/LuAYcYPtgmv92D/AWE3sdr4DmsNJ16y8Ra2rSWmm3KXM ixwmXaoYEkKvJwQp6dK/oa+FH/BX/wAJ/DTwj4f0DSdHjvoNG0+CxZSz7jlACXVRlDweG5r8G8Z/ DrGcfUcPSwmvJe+qXe2/q/wP6T+j54rYPw0qYueMdo1GraN3fVaJ9keyy/8ABaTwzqFrBeSWmji3 aVlEU32jykdf4N23Bx37iql5/wAFp9N02SAW+laZqKqUEkmjiWS1PmdFMjDqvcrkCv5vp/RvzSku X2cnful+n9fcf1hV+lBkFSfPGvDbW1/6/wAj4/8A2l/+CuHjj4s6PqnhXw+L/wAMafPmyuL+OOUK hIGfLQpyNrEgn+8DivxusviLrFnr13eW82oXDXOoNqU2q/aSdTRvMDB2JyD9OOtf0B4a+E+A4Pyi th8VBOtUTvs/nfXX+tj+avFjxox3Gee4XG5bNqnRd1bT8HbT/hz/1vu39nv/AIKuw/Cbw/YeHL+f TdUuIpQs1xPBNFct8oADq2ADwBlSQcZ71734t/4LPa1daRc6d4d0qK01VopmhumjVVkAHY5AwMjJ I/Cv9AM2+j1icfnVXHU4pQnK+6/r9fQ/hPL/AKTmW0cjp4LESftYxSekt+1/8tF56HyX4B/4Kb+I dL8U3et+MHgm1WaY6is8V81012obcCRgYYY/hJ4rsP2hv+CyvxS8V6LceGvAWlRQQ6npQt7i8lmF taxrJlX+YHzN2Ow2kAnnmvZ/4l8pSzahXkkqNO33Kz23b00/E8DEfSb/AOMcr4FNyxE1KyfndbvR LW769j4M+E37S3jbw/4vv/Gd5qjazPcILzULC2m+xfYnyojdE+YsigMCSRz71+muhf8ABZzWtCsL Sw061h1qKyjNuwSGa5i8zGCGYLu3ZyME8ele9xf4MUuI6tNUafLCCsm7J6K3fb5Hz/Anj4+F8vq0 cfV5p1Jc1km1q7223XXX0NNP+C1fitLa2mu/DzQTX0/2QWUGorFc2jAn5tnyseACR7ivFfjR/wAF i/it400DVNC8PLNYSvA2nwzzWywgu42l+DlgoJycgnGBjOa+dwH0dqNPGU6tWyhFpu+uzWy6/Nn0 2f8A0n6eKyirhMPd1ZxaVtLNp7t7fJN9rn//1/Nvhv8AHm40H4mt478dRS+J9UF59vi1EmRLpCVK D+8Nq7j8g9q/Uex/4LH/ABC8P2EsGlIgt9IigtLTTxbmCe8BXaqKWibJIwc+1f6k8ZeEEeKJ0MPS SVCCSs3Zrp0+/Tz8j/M3w+8f4cIZTXpYqTeIlJyuldPta99emumq17fNX7QX/BWD49/Frw8fD9hb W+jaXfxuC0kqiW4fIBVtqggY7E/hjNfIXwa+Pmv/AAk8ef8ACfaRFbNqcsKyX8NxK3+lMSpkxJtJ zxxxjoDxX0XC3hJlHDmQVskhFN1U1JrZfq9tW9emh+ecV+NOc8RcaYbipu0aDTjFvVpbp9FfXRaL fU/QD4g/8FffjReeFn0DQVstIN3YfO82omW6AZQGUL5YK7h0YE9MV+WnxC+J998S9UfWvFd218bv EsOyV2ullkA85pXwuTngBQAAPXNdPh94T5fwRjZ5lC3tZN2t0T0/K+hz+K/jNjfEalTwKTVCKXxb t6N6eqXXv5M8nuBbQ7jBABFEMocZOPU1FbXM16DJbb4ccZdSofGelfth/Ph//9D8/pllu7STTJ7g iAyeY0W4h3PTcG7cVQmePT4LW2spZ1t7Cfd5STvIzYyPmOSSRkV/vG03qz/ABX1Ogilvbh0aaMXK zDIaZ9gQDuTn2NX9K1ifTbsRGNgpcsDFiVfQDk9D0rmqx5kd2FqctS63Pov4P/EG48E+ILDxZp91 LYXVlqAvmFm4t3vFXh4GYgjDAD7wOCM1+jV//wAFmv2ivC2mW+jeHDD/AGeIfssZjuRLqFqAuA5Z lxkYAG05/nX4vxv4SZfxrmlPG4tJKNr/ANI/pHw98dMXwJw7VyqkpTqNvl10Stpdu9t2tL2S2Pgr 4l/te/GP4t+JB4k8YeKr3UZTqBu4LO5LzB0KrmK4kIB6g8KSOOD2r6k+FH/BUH4rfBnw5F4f8J+I 4bS7d9/2aSK5a0hQjlVjHHyjjhscfhXLmng3kGOySjklKmlGFruyd++nqtF089xcOeO3EWVZ5i84 xFRyVa9op25XfTW3Z2btrv5H/9H7Wi/4LJ/tIXizTT6+lulqc2sckogSdcYDEFSRntnp61xfib/g sn+1HeWuoW1pq2p6ddtamMSjUQY5HHQJ5bcKw7gA+tf6bQ+jpkXtOWpy8n+H8Lev4fcf5t4j6Tea /UuWip+1f961vO61/D/M+F/if+0d8ZvjP5eq/EfxDJqt7qLApZzkPa2PzK3mP5gLM+AMZ4BHGa+7 v+CWvhrxn4p/aBF3pFvLNb2F3a2jOoBjZyokZm4/h5zjpXt8f5HlfCvhtisuwcFCjGFl66JeS26d jn8Ds+zXizxboZjjanNVk25emt/Pd76u7uf2lwh1ijWTBkWNQ+ORkAA/rmvjr9tvUvivpfwlvbj4 URXM2sAOZY7XAfCgNnPY4Bxk4z71/mrkSpSz2hCv8HOr/ef6J8RVamGynEV6XxRjJ/cv8j+RX4+f tlftXahNf+Bdd+Ies6c9ncPa6rpktvJbziLau35uOPmADKcZBGSRx8leHviT4l8NTte2HiG4XUIZ vOFy0nmS5PLCQ8sQfrxX+qvAXh9w7l/D1OdClF+2inJ91JXsrbW69b316H+SPiB4mcR5vxNWrus4 xpSail/d0u9Nb9tttOp//9LwLxf+0Z8YfH2nvoPizxvrLaHHA9rbaTpl+9tbrGxGVYsCzAgY2jH1 rxO4nebZ5UQtIhIFLR/ekRSOD7nHvX+3GT8M5Xw7h5UMspKClv3b7v8ApI/wyznirN+JK0a2b1ee UU1Hpyrsv6ZLqFzgRLaysQI1eVdmGByQP5VraZeSaU32l1QSzRBkSRcuwPp7V7dNWp2PEUmqiSPV vCHxy+IPhNDb+GdUOmOwYNPbqiTIMqw25Bxgr1BB5r0yf9rL4sT3Ea6r498UWSxW++3j028aITsB jLg/e9a+KzXw54ezvFyzHFwftZb9m++qZ+k5J4x8W8MYSOUYGpH2ENEmndLtdNfjc5eb9qr4zxma 1sviL4kbz1I+03l9JLIR3GzftPUcnkYrzHX/AIo+K/EBe/8AEuv3us3sMxmhtLhd0Uj7cCQ5B4/2 QevauvK+AeHcmqe3wVBe0W0nv/lp6XPJ4g8UeKuKKbw+aV70n9mOif33fyvY/9P4jOp/bLKOaZEh uVkJlhjTCSluc+2PSuq0Hxvrnh5JJtGk8lWcGE7jHPaPhdzRyLyDlQR16V/ubVwdLE0nhq6vB6Ne R/grh8dUweJjjMO2qkdU+zR07fH/AOI1rbR2h8S6jGZx5LXMmoyTXkp3Ej5+O/Y1Sh+JHxBM5nk8 X+JJJZkIkuTqsiSwqeqJ2A/CvGp8FcO05uccLG/nrv6n01fxK4wxEI0amNnyxtazSenp/T6mT4g8 V33iC5CX02pardQ2ao9zf3r3pwjbu/0Of8is/TpLWC3mvGlRZ5pQXtRjLsoBDsPXpz7V61HKMJgq X1bCwUIdkeDiM8xmYYr65jpudXu9X2NC48YavLbvGt9dW58vyI5YJjEQm7OG9fxrOtdVv5pppTqc m6SEwyCS4LLjHYHpxxgY61ccpwVOXtIU1zd7K/3lSz7H1o+xqVZOHRXdvuP/1Pj1fENzpdkdPimu Ioh/qXs7treRc9gy849RnmoNP17etzDBcXguHTy2jmvZJosHOSQTjJ57V/uosDQTu4q5/gv/AGli F7im7dr6f1oS6fqQWfy7iZyu7DBRvyew/PFXtU1SOYtFJeT+arB1iMr+UMYwAvQA4rWGDppbGdTG 15acxWtPFF7p8cLQeVDJFEYtmxZFIyTznr1NEmqjVJG1C9HmSBAilECxqwxgbOnbPPPFVTwtJScr EVcVWdNLmdjObWb9/OiuTBIVl3o0dssDkYUYfaPmxtHJqvq11KdLvL/53VQA8UJJ6nG0+1aRow5t UYSr1FB6n//V+HYLkeRHGJYkzGF+zIu0KPpVS4uHWG4jiAaYAkEDOSBxn9K/3nUElY/5/pSk43Yq 3VxNYwo0DO0SckfdDYywH51lm7kYpDKsg4yFYbSorWCszkmm2RPGW+ZVbYGwSR3q3G80QO0MYxhS xztBPQfofyrQzLF1IGS32SnfIvLR9UwSOT+Gfxq5LJBCVeWYLNMoYIo5fbjP9KLdC6d1JNdD/9b4 Me4SRiEJAx1zitoavEthCiogjjj2OTJknHU+2eT+Nf70H/PpO62KUF1LIP3Mu1ZBtHzdRVaeQsrp KAwxjBHWk1ozWm3dFWGeeUqjthUO1McYA6Crk7yRFI0yr/xt0IFZRtfU6pu0FciWaME7JGaY/KWz 0+pqz9rs7W2lX7OZLqQhzMi4KcEMPfIx9MVscnMz/9f4Ht/LYEsCrcuoPJ9alibehe6hfznztTd9 wepr/eZb6H/P7P4SF/tLiP7MkPlByJy0mHUD0H/6qaZACSANv8W39aIqyM6nvTv/AFsVft9osqxf vYwWCkuh4J/Crq6goaRbQrKQfLO4ct9CabRMUoml5xiZEmVhvGGXoY+M5NY1wJBdbhJuhxgR45HP X6VovgYqkU5aH//Q+EFvPsTRSl0hG4KJWGQu75en41UvNszeVvLxjKtnowNf70PRH/PsopbDm3G2 NtAxRki2RkqSI8dBmpLK4nhjKSgSFEKnI4PuBU024mkrWSRWuroNbwSSL5MhYgoxBPtjFSaWqzTT m8mnjTysQQrEGV2/2myMf54rZzVrEpXdi5cCyVZmFviRwqrOvMiEcdOhBz3rLtkaSUo7YUH7zHA6 1mo3kbydoWR//9H4JktIInaQbS+NpdTnOPcVUknjs1aYMSCMMF5r/eg/5+5rUPPmKrIANuPkz0z6 VFHc3caZdIGDgtL5mC8foE/l+FBGysT2kr3qmOVhZzFGCzcuvcAcevH50S77ORLYgS/u93nIweNu nBPXPt7U02thWIhcGKRJDbi4Xd8yM5VVHqcEVcg2y/KqElzwR/KrjPozBxaP/9L8+0jiAnbLO4ce VFGmd3qSfbFRyLNK8JURLAASzh90uckEEdulf74H/Piot7GhEGV/mlwpGxiw3Ko7nGKoRPcRTz+Y 0FxFJcmKMxHayxgDkg9ec/nUOatoTYmuI4RIscUoVgnmMCchsjP+RQtz5kUdvsW3ZcgyIcljnrWb bY7Ms3KL5KMrEGPhsDLPWFcZZtw3bTwdpKn8xSDlfY//0/z5gjEkaPIcOowvOcj3/KrDyQK3zcHb tGPX/Oa/3oP+fDlfYqQTzNPLBIY/s+0MkvQhsnjH9atCLcPmdSQ2FK9CKC1DuKpMUbRFEZMcFkDY x9azEleK4EKx7VdS2/gAEcf1oE4NbF+KJbiGVvMSOSMgKrt88nuv0qvBZ+SJA0skrEk5mbcVPoPY UE8r7H//1Pz5iYRXCl1IHQkHAX/OKn1aKCeRUQLcRJ+8inC9WAGCAa/3oP8AnyUHYrJcQ2qQwCJV mdsTOefMYnCgfgAKsedK8NyJUSFopQE3yANIvqo/n3GKBKL1BLtI4hEjhZJGAwwGSB1x+FWwQhG9 iFxuFFiorRFXVba4vNKlktVVbU/I92DznIAXr2PJ718v+JP2ZNB8aTz6vrlrdNYRuLSe+VykUJkO 4IVwQ2SM4/8ArV8pxVw7g+JsueVY3Wm3d+q29deh9/wNxhjuCsZPNMv/AIjtHrt1tbZ+evof/9X8 KB+xB8NmLBNSezmgYlS0c0UdwOu2PZkZPvgc/jUkH7FXwtdkWSwkTdebg8UAFxc4xhiSPlOe4/EV /rZT8EOHKCaglr/cS/U/yLn9IbiKq1zp6d5t/wDtp0ekfsbfB03D3Qmvo72L78d9KLaK3bOQRtDA +/yg+1W4P2TvhLFc30t5Z3N7NfyFY7iF/tEVuwwEfDqpwOu1AtVHwU4dg7xS/wDAV/mD8f8AiCcV GV7f4n/kNf8AZM+GNwqO7s93YHekps0ikkHAAVQOWGOrk9+lbP8AwyN8F7uCSa9tZbq/aDNve7/s S7gCQDhevt075raPg5kMV/wF/mc8/HfPJPbbvL/gFSP9mb4QW6W4Xw7dQubc2jBZo1EjY/1m7Z19 iD0re0/9mf4VaUdPig0RZWVHVZpp45jC0nfylQcDPrzzXXR8JuH6fxRv8rf5nHiPG3iCov3bS+bf 5WP/1vySuP2cvhXPB/pWhia+gmD/ANoi2RVKD/lmIuMfXOeKp2n7P3wpllvFn8OwJdRypNpsqQQN BtU4aN1kRznByDngiv8AYuHhfw7HT2f5f5H+M8vGLiZ6+1/P/MS3/Z/+GVh/adqNEtUt55fPhmaz t7t2Y4JWRWTay57EcY61e0r4K+A7B4y2iWOpW6o2yzhsks40c5C9FGAOu1eK6I+G/DsNqX9fcc8v FziWat7Vfj/maEPwS8A3EV6lz4X057o7Jg6WyTRxFO+wggdv8aI/hP8AD9Zlibw9DK6H/SZGjjEW SflKxlSoA67ea2p+H/DtNu9BP+vI5avilxRUty4i3pb9bmzD8IfhlZPHBcaBHfIqmQXMKQRtOTyq tGYyoAPBHXjg1UPwp8BCO8a38JaUlxeXKTM8VqiQR7eOFUADPGfX8K6lwJw8nph1+P8AmcMvEnil v/eZfh/kf//X/L66+FnhPEZfw7pEUFtKRLHBFCkkzkdHdV3leDwD+Naf/CvfhtAscumeErGO4e3+ zzw3yC/s0OPvoGyQfTPSv9qf9ScgX/MPH8f8z/EGXiHxPLR4mX4f5GXfeBPDMFi2iReHtImiMweO 5i0+D7YWLct5pG7GOMA8D1rai8AaBC9pO+jadb2lphrNG0qA5Kgbgz7QWz3ye9N8G5FFK2Hj+P8A mc8+O+ImnfEy/D/Iq3fhPwstxM0GiaeE1BQ1/AbGIQlgxwYwF+Tr2x1p0XhDw/DLMLe2itNN3CSC KO3iFxuA4G8LnGeTntW8eE8lgrLDx+453xvn0nriZff/AF/XoW5NB8Pq2+PR9IvGlVftEl7pEMhV xkfLxjB45NUR4S0KOUm10ezR2kEhe1tltV2jqm1Rjk+3atv9XcoS/wB3h/4CiJcV51LfEz/8Cl/m f//Q/NW38LaGyzPFZfZvPuvN3RzMPLaMnaGQ8EAnrjPHFdPpXhzSjCLqUMJI7vzZiqKytjBLMSM9 unSv9tlkGVrahH/wFf5H+FkuJs4a1xE//Apf5mPDoumXc9xvWOO0vLr7Qbpod0qqCSoU9hyOBxwK lXRtI868hNrpdzC0O1Yrm0jlQlfuOAR14oWS5dF2VKP/AICv8hf6xZs1f287/wCJ/wCZC2nzXcEk dna6VbW1kuJfsunW9tNIfXeFDE9OBSRaRaSJYsYCJbPcskyufNmDMW5z6A4+lVHK8HB3hBL0SRDz nMKqaqVZP1bZcjs7aV0aG2tvtUAZEu2T99jng84BHI6VXvrZrtLe1lRkS3Ux7SxVTuPLH3OetbLB UF9lHM8yxV/iP//R/OFNOtY5LdTFBN9nfEZkQSp9Np4wfpzWjq5gnkf7dbW/liILJb2UKWqMEzty qjr/AIV/uAsJQW0T/BqeYYnrJkELRRyyzwWlrHvKuiPbJKkRQYBVWBA9+OaQxWk8c8k9rDcyXjFZ C0IRYsY2sijG0g56flWn1Wn/ACIxeOxPcgm06whEMkENqHWNk3GAGSLdkEFiOexBzxWsLJItNjST TNP/AH8XlNetaL50iAkcE5wfcYPTnil9WprXlJ+u4jrIzLmLToIbfyIE/dkBZPLCSqTxgHPTvzTr lpZLS3g+8LeQNA2CrQrzkLj6/mKPYU0rWK+s1ZK/Mf/S/PGKxht7O5iBgkN86TlojudSuThvQ5Y8 H2qQFLlp1+xReaEUSXITZI4AAOcdRwOor/cL2FPsf4J+2q/zMq3iC5MNutrHFbqAp2sQARxnr1Oe tTanKllEiyxW1uLS3EKSGFTDMh9fXOaPYU+w/bVO5oSNostlcC20y3869ih8+RYgChXBYQ/3ckck YzVW4eGw+ztaXE1k8WHJL7IlJHUAdP60pUaa2Qva1OsjLdDNM1yx3Slt/wBoCDc7DoT/APXpTZNP CP3sTzNIWuC37oL/ALX456A1l7KPQPaT7n//0/ztguJLa2hZpjjzTDCY2IOR6/y/CpYLhJb6J5pX DM2JJUbEzAZz83rjNf7eKnFbo/wUcqhRe+t7Zrh7KOR7W5drIERhmdWYqN/YHj9K0rWSEW7QLbhZ Au1tvylu/T/PSrSiOLqX1ZSvY7mWBYZDcxyKQYzMxZtvGO/tTbm4edIRMpa4ibLXJyZZO3zHqcYo tE094ZJazP5ctsMmVi7yRxGQoUwWLntx6ntTrmV5p4JJ4oSsMYjD+WE7ADOByfrRZdiW5rqf/9T8 5leJQ0SbiZhs+QlR+OPbPFado8dqtrBcQx3cFncLcC2lxJDMRg4f1HHP1Nf7gXS3P8F4KfVjZLEr a+YrQKC3mB0bcRnnawrIj1EW8xAQESsYJCuABntjoKV13NXDzLl7bC4hhmlljV4UEUMW7BKElun1 Pf1qrPHMiOqlUVlUsUG0EAjjA4//AFCi67mfK+wy6vkWxEOYmVM+UzQr5xJ7buuOuBmn2lpHcxSK wUytGskb7iCmDkjH0/lVRaHyy7H/1fzsjmtYXEFtNcvchc3W6MrFGwPyhGB5/H3qjePukJYmSR+C TzkCv9w043dz/Bm0khbaFDKZbidBEkZUQvEWOQOBmnXBVINkcCOCck5O8c9Bzj86iTSY466XIokR 4gJ02QnlSqgOpGcc/XFUZEZYJ3uLhR5TDy2JwSM8D04x/Kp54mkY9EaNvP5LwXTW0dyI4isUIOwZ wdrP6kHB98U0+V5LyXUqLOxMx2j52BPIOD2p80UWoy6H/9b822SNbdJIDw6Z+Yc49RnkVBpl19jh uH0/yJJb1z9pa4gErYyPuk8jp+HpX+3992f4Q3fcsTQO9j9oUf6fJcsssBb5BHhdrjjv83HsKx54 Xj2xkjPXg8c1k2uiK5r6ERhkRgRzjrk1ZhkjRnEoLb8hVzjBxxj+dSHsydYlVklALso2jd8xqJn3 3JmnfcvmZfH3gKTdg9n3P//X/NDULlWtozH5kkgbEO0YBH17H+VIAlw6XMjb59gTdkFlIxwT+Ff7 cPRH+Efs+5AxkW4XapJ9ccCkZod7pAxMsZxcpjGwnkAfhzWblbY1hC5QIEzMvzI+MIV4K/StG3gl MwikkT5h+8llbilzsv2Y6wFpBNeeXFb/AGqSIhpJhu8sDJyPQnHWorAJcIokljM+4gukZ8tmGTjH Jp87sy+VH//Q/MaZJZ5mklZSR7BeR0wOn5VLbW7z28kriNPsrhZpN33w3AIH51/ttK6Wh/hmoJq5 nKqTz3Bgug1tDkRSyZRZgD/CD656fWrcFubf5riQfOgaIKP/AK/tXPJtK5S5XoWr+/aeGB5UTECi HKIFLdACcdT6k1lLFeXENw8YgUxsDGJ5SGI74H9KUZNsailsTQy3JYvL5RIi8kho1cAYxwCOOO/X 3qDdE0qpGwlBbaxi5Cn0PpRNtaIZ/9H8xxY+WSVQ5cEFcYIOMZqhb6bqX2U36xBrOK4a2uX3lpY2 GNpI/utk8njiv9qHNpan+GzSvcrhbaGXdO+wFuXb7ic4zj/CpHe5vJLoKjS+UQ++NTh16bsY45Bp Rld6C5Y9hltEk4EUTSLd+dlYyu8Sg4G0D1/xrQmeJY441Rt/RpkbHzA9CP07VTbasCjyjHEkoJyO AMY9hT4Ly8WF7aSCB7CTLFpYQ0xccYRsccYzzziocknYo//S/MUWkrQBo0dLfPKj5CO3StmG+gS2 iiigmt7uBgIb1bjawA6nAGfTHIxjvX+0cm9j/DeL96xhmBoZL6KWIXNnISVYSHmQ5wx/LIpjJPKI zuiW3I2umPn4xg1Bv6DNjefbx4/ck7TtQ5bnqT0FdKdFsoLGW+gmlLrj7RamQzKhPAIJPG78hTSb M27SMM6XcXPzRIANvm5eZYgB0PJI9+O9ZCgKZDMnlmOTEO07lcY5J9Op9a0s+Ww7Jyvc/9P8s53M ipGjKrMcgEff9aMXETRq0ZYZO/tt/Cv9qEf4eyV0Vmle3aWVmkVWGTGxLDjPIFbMcbXNrA8ivab4 yBPIMxyNk8gewxke1Um0rEKKauUbxRHd2a6dcG/eOJhdp5WyDJ/unrkYz26mlkIBG/J3H5sHB6+t Q1pY0VnsPjhjklf7USsBUAIF+WP0P+fSiaGJBE9rKtxE6lc4+YEccj9R/wDWoa0sVG19T//U/Kpb dY5Q8e7zG4kPY+1X59LzbLPBPbRyRviW1Jbz3U/xJxjr7/hX+0XK1uf4iRtcyZBcRpvVY5njb54w Mbx3A961Iop7i3aSBUt4YoiTEclpXHp+Z4oUZMq6TsVY0eRGSXm4RN5VRxx1x7daihUSSW/nFleS XygGGG9AB9aTVnY2hbYfqFuba+hKXDSCBT9ohePBX/Z/DH6mphHpl3ZTzG5mW5h2yiPyfkxu4Ut2 OB0xQaxWp//V/KS3kmhLurKrniNT95x3xU/295Y4bW7aGFTKTHtTYZGPY9STX+z9k5XZ/i1BvZEh MRKRSIsW1du8A7pznIzzjjPHTpSQqnmPsu45JY5MiCPAliAA4b61do9GU27WsZo8i5vTY380/wBn VvtGMFlgckDOO4wPrxVlINPd5YVEksin9w4+QAA8sw/AVDUb3YR5rWsK0UtpMViAjjkXMs4+UtkY IJ+nFQyWsoljtYgkqOPMDhwsa8A4yeAfb2NZrkNHGfY//9b8stO0+0uJVj1GWe1sw3+ky20IllQD khQeOcY/Gqkek3cqNJHZzwQM5EMsyGNJwP7pPtj86/2ac4Rdkf4u+zqSM2S2uLaTED7J4uXcDKxg +v4VonT/ACraQTwL5lqq3Qmkk8ssucEDnB659sGspVYXLjh63QVtNecrd2xb54xJGEUkAYzxS2dn cNFKn2ZvncO7MuOQCOD+Pb0rP6xBGrwlZ6jodN89LgixuppJn8mO6jBEcDLy27j04qKXSZ7WL7Yx VYWnFuAzAFnyBjH1OKyliKbY44Sruf/X/Ka/07Uodr3NkyypHvlaCPdGozjdx25HT09qrQ6bFJcP bS3UaX0EQupLZmCyGNhxkfjmv9iHiaa2Z/jbDCVU7MuJo9tKSka3AkWIXDlIGkjiTOCzttwoJ9ai v4fImWSK4guLNEDsjModBjGVAJzk+veo+t011OqnhKhVOlR66JClzZ/Z12pLb3TFcc854ODwfxFF zY2VrKwn89LVyLaCS0spZrfcONoZVPPHSsJ46le1zrjgKjjdK5oN4F1G6uLL+zWtlW52vDHcb4ry TvhYio5PbJqnd+DPEdjI17qljNbx3d2Y8pE95J8vBeRIlcg/QGuKefZbSl7OpWipeqR6FLh/Masf a06MnHyT/wAj/9D8rD4WR7WV5tP1qG4VW2v/AGLcRbxwCS7R4IGOMnHWsGHwr4qtZltdH8HeMr6B 4w8cz6NLIJd45IOPu88HH+Nf60VeI8riuZ4iFv8AFH/M/wAnlw9mKSXsJ3/wy/yO00n4VfEC5tyN Y8B63ZwpbG90ud9PmlLpkL5bIEIUgkn5j06cVZh+CfxH+zytpvgrX9RuftIjSzGlSW0MndismDnA 55HPrXkVeNsghe+KjZb638un6fkepT4NzqduXDyu9tLG5YfAH4wmzneT4da/5s0JaC2+xSSnzVPA LquADxzwa6mz/Zl+MN9E13Z/DHxEHstOd5rm5tHjsWnCj93HIRhsscdjzXmVPEPhmnFy+tR08nd+ S0PTocBcRzmqf1aWvpb8ybS/2RP2j9Wght7v4eQabAk+66e4kdJWSQDkAKeg5wSep4r0OH9h345S 2iXlp4Mu4ZLKbEUzwyzR3iEgFCAmQO+4kdBXlYrxS4bou1Oq5Lulp+LT/A9nAeGPE2MTaoqNujb/ AET7dz//0fmTXP8Agn9+1Lem7htfAksFzatb3Pl+RcRtdwSDPytsIycjqPX0NbOi/wDBMf8Aavuo 4LgaZqVlvbMtinh95QoPRdzrjBB61/ohifGPhmjT56cm38l+Tf5H+emE8JeJ6tVwlS5Y90m/0X5n X2//AASz/aguZTv8LXptRMu6Y6ZKJmXPzbRgLj65rt7H/gkP+0hqLIVsbPTXmgkP+nxpFZoI8mP5 EGUJxgknv0xXhYjxvyOnG9OLf/b3X7me3gvBvPa9V06ycVffl6X9f+GOih/4I2fHi/sLK0N3pKm5 U3V5LoWrBZraRW3MkZlBBJAAxkDPQ1tRf8EW/wBoCSQTN4lsNOe6YW6rK8D/AGSFcFXkjbnzDjBa M55NeNiPHbCRb9jSuvO/6eX4n0tPwJxjh79R82m1rbf5/gdnD/wRQ+Kl9Nv1bxkhtbu2NrMljeWt vHCqAKHYGPjdjsN3PWtmL/giNrMNuBqOu6c0WVja7GtH7U0Y6LJhSOvcDNePV8d689KdOKXo7+mr serhvAiqtZyk/mv0R//S+nrT/giAJrDTbfVvHVrF5c0zC2a/eazmU7TCJP3fQAMMZOcD1wO/H/BF nShNYzv8QvD1ta6U6SvDYWAtRF8u3CheF9fQ1/V9bxyzJyTpx2v0VvzP5eXgLTs1e9+7d/yOvtf+ CNPwbYXD6r8R9am1DcI7W8kDxrEhOWwCcKpBIwuRivuj9nX9kv4e/s7TNZ+HPFMuqyp81le3kscc kaFQrxowwAgwSByck88AV+Z8eeIPEHF2XfUKztSWtkrL5pLXTa+133P1bgTw5yvg3FRx1CN6stG3 rp5Xel9L27LsYv7bnjrwjpvwz1m0uNc061nnsXsILiW4Cx4A8xlAzuLEgYAHPPtX8SnxB8TWt7qP ia+06XzLO7126utNWeNnjeESMN6MeduFJB9K/Z/o4YHFYTJsRWrRtF7X0vo/6+Z+XfSQzDD18zwe DpyvO97dlov1R+Knxz1W5m1aQDUJPssE2DaqwaKUtjBHfj+lfP6FpG2xkSZ69q/A/Fet7Xi/F/4j 9g4DiqfDOFiv5T//0/4WbRrlWRjEsSxnDALgMO1bUc028tCSJZGGCeScdqwk92c52MF9Y2duJbu3 nEcQzOYInucj1IGSO/arVsYpr+CQRG2gmgDwzSoyOcnupGf/ANWK46jZrB9DoJJwLlZWbbkCN2Aw JdowMj3p017G0yQxB2eRcMoQspHofrXJPexpF8rIbWxjubuRVaRoo1HloBtDN3A71ae7yGint7q2 e3JhQSIPKcDoV+tZy5tkDd3c/9T+OPw6t3LHqNy0ILfZjbl48eZGDkK4Yjg84z7mqlxaHSrDT2aV jeq5OJVDSMevmFu+a+cUXrcrmkdT4O1y9tYddt2WKePUIVhR5oR/o2PvKh9+/wBabretS3Oqpp8V tBa2mn6IlxeSvIBOSzFQyj0OCfYVDjYTbZoW9uVs1kDOolUMjkYDr6/pTfMaEh2QSREbGGOnvUOK Yik6S3MUNvCs0Ful20yy5KAZGSq+3I6VeVHjn0+3jV5Z7mRoj5yHYo25zn8+vtUVFaFkGx//1f5r fgFo+qyfEPwpoC3sPl6z4o03zbeYeXhROu7yj1YsBnHHT3r/AEhf2K9DfSfhR4ctLd2RdKsxpIfZ taULhm56Y3M/Ffzjxu19cw8et391jPCVf9olS67/AHXPt5Vd0KsuCvOR1P6UyOZo5E4ygbByM7f8 814CnZWPUNWSUBsg8EfgKoTBmGEb3LDvVc6sXz2ViiJFX925KluMjin7htZI3DN0yDkelbR3RcG2 tT//1v3+imSRf3wChccZwOOhqw1xFcMPMJ3r8isTnj/OK/kipK8l6m8mlEy7mRopZ42gZrdQuJGX hyRk8eg6V+Kn/BVbTXuvhBcy21j/AGpqB12S8mksvnu7PgeWg9VJDE+m3mtMLPlx9H/Ejjxkeahb +tj+Oy+0ezttX8WTaqwigv7mWbR7iO32yWwh2IEkH94lTk+/1rlLNNGsZ3uJfM1f7RaN5kFvKbcQ 4JwTwcsOuD61/RuHd6EH5HOnaSuchc3sjXaFLOSKxmB8lpwVmJB6fUcZp1w8QPnzm4acIPJt4o9z hV6tj8ePWtiudXsf/9f+PBby3jKRQyt57w+Y8Ug2zxK4OCy9s88exrFa+ka9WK4uGnxL5drtwPsw 7jjsevNfPnPfoS3Ul606hFNwqtuk52+WoH+fzq60jC28+V9iltoOd3l9gKadncwe5mX13qFzJaMJ VfTo0EUkDJg7CD8w9OTkjvUpkhFoIo44GtXzCqMmFQDkEL2PGfrWyknsKxFZjyjLcwtL8h8uSJB8 rqf73t0/Kr6X8VzOtlCiyySrxHn5mP8AdUdzTE1dWP/Q/i9S4vf7atrGWyMq2dw00MUllshgJ4PO MFuwPtVvUoVimvZZYbqSSa1IUywt5pkI+XI/ugnrXkLR3PHK2m3P2e3j1TU7cQTRQLavncEByBux 05OK0p7+WJ7e+uxAsN3lIIS4Er7cDKpndjg84rsp7AdK93bT2myyhYqsYErtkFSe6+4/pWVql5d3 NtBFcXKXCwpsgJ4kwf4T9OcVtSfvjtueS6+8VsJlG5JV4LbeOfesHSby6CzQAieN1+eI/wAR7H2r 16OlSD9P0JhG0JX7H//R/A79le6il0rQLOK9RJrbTIhBFctmCF/LX5UyD8yj5ueCRX9Pf/BILXLz T/F+qrdysLq2u4LIXEBWSW+clyJGT+FWDOu3/Zr+/wDOpe18FXO97UY/ior9T+Q+B1Oj48KC6zl+ Db/Q/q+8SpDqnhucyRRi3l07935kYLowTOQvrkdPav43/wBtvTbew+M/im2toNQhmvlCRuEIjAin nLkyH7pIcAAV/P8A9HaThxpKkvM/XvpQ0k+FvaW1T/VHwI6X+kG4sNRW2udInYXkbCRFuYz9SDtJ 6H19K5eJZ7qe4kETx20tsEaOMkiVgcru7EgccV/oLA/zXrTfPcpNYX0sqf2bpdy0OSLm9igLrC6j JDMPu596VbPU4WguJZYILhb4QLOBtEMBPJY9yw4OPWtDLnad2f/S+Arr7Vaa9D9kuIruzjKpqPQ+ bg/8s+oxjuetauq34s7iJ1heGznkLwpNEHSQc9M8EgH3r/Yzl92x/jnztSuc9Zx2Af7KrLECHubN B84bLBio546k47VoXV7LAtlr1rO97PbD7LEJLh44xsyjK0eeR1A+n41hUp8zs0ddOtKCcoC6b4+n l8zTYILxb5ZyzC0jcW8pk5Tbjoc5FZovtZu9chmv7u5i1W13QYSUghcn5GB645688VmsJR5rqOpr Vx+KceVzdvU7Ga8/su108NvuLo3RkmaO3KrK5LHEox8xGe4xkVV1fWGsmZmeV7W9RWeW7JR4cYbY i56dRireEp/ynP8AX8Utps//0/iJr20NnFqtsUiMv7ljknGeOE6bT9PrWLeT6jPL9mIfULIMJDDF CEgYdcMi8cY64r/YH6jRtflP8f4ZjiuZXm7G/J4j3LBay26RG2aNLCJbcFJBjGxccjH8u/FaA8Wa jp0F1c3EcSzvJmzt7b90kKnjbubJGR1x3J6VcMtw7jZwX3GdfNMapcyqPTzfQtQ6nOsWk3Fwq6dc NC73NsW3RWUjfOlwMDJG3+LGeT7Vl6W0d89+11q0upJdytJfhLhvIucHB2HPy/h+XpqsuwyVlTX3 I5f7Vx0pWnVl97K9tcWOlyT3VpC9vYyTFJkuJzcCUISASxxwBnj61UltYP7QF35Pm28tt59jPb3k qRuGyGDRg7D3x1x2rSngaL1cUKePxCXKpux//9T4usTIYA1utxZokZiiLXDtnPXgmqEWs6j/AGpD bakQsdqjf6W8nmRwAAjdgk9enGOoFf7KLBUkrKKP8YauOry0lNs1tB8Y3FxevbaZf3isBumSENF9 pVcgh+OOecVSjuiNRCzOkEj3bzIEj6IQ2VZug6j8vpW0cHS+JR17mf1yq4qDm7LoZerT6fPqDy2e LeG4Kh7gnKbhhc5POOlSw6ZIl7LKSLwS3aLfeXPumvCThnDHqMDlvpXRh6aTt0PNxNTmk2bl+y2M a2tlbgyiQ7ItwGwcmrn9vXUKQq88sD+UJHthNwQOMFc4pVaMazUJq6O7CYyrhMK5UZOMrpXWjtqf /9X4wk8U6reXIfT/ALekonW4SNr1oUR0XB3qDgrweDnrXQy+I5yWvdWmhmmhRCj2k0hsC3QEJuxu UtgtX+zf9lYO+tKP3L+uh/i/HP8AM46KvP8A8Cf+fmyjbXdxqEz29s7LNb3SaheNBMyxyBs7d2Dn H+z2P1pt9qNwLuJDcJF5UreWT0IY8726nsec47VbyrCKz9kvuRnPP8xk3F1pNP8AvP8AzNOw1e7N qZb2W3u3hmYwt9jX5IzghQSCf4eua1bbxDe21omoiXNi8zRx2GwbZTjnI7EdQTQsrwltKa+456md 5jf+K/vZhXHiLVNWtprKKNbWMTESfaEWWWVCOWV+SOcYyeMH2rBS4m0OWKaMLHOsbwq4OZZUbG9W PUg8ZH0rohl2HgrRgvuOGrm2NnJc9Ru3mf/W+Rh4w1l4mhjl+xrKmVmgClyp7fMDg8devNSwa9q2 oa7pk95dKLdIhZT/AGhmmV415DYJwCDk5XHFf7XrLsNONpwT9Vc/w6q5tjozbhUa6aNrz/NFPVdV tdT15r9d0s3ywwuvbyxtOxegOep6+9YWt3d0ZPsiSt5KES5UbQScEjB7+tbxwtKlGMKUbJbWOB47 E1aknVk25b38ynDqxSMQzRM8qECCUjKqMc5P4cVM2vXBUWsbwtAWD3B2/vVxngeme/0rrrLmVmYU J8qUvM2BqO2OJI98DrG0bvHI8blXxnkHPp/Snf2rEixWsMdnIePMa6jN1uAHIIY471nGhG21zmqY itF2TZ//1/im/wBbe2sZLTSnFiPtsMaxxIqxJuceYwGOvHHfmrE9mJbt9ZvZWe9uolilkMheeRY+ AWB4HoO/y/Sv9u/YQi9Ef4PUsRVm+WTOgj12zsJ7FNMv7y0uYA13bukWbVpXUIwkOOeB0PFZMut3 VzNdmXyI2kbdcypCsRunA5kOOSTWtLD017yjrt8jKrjMRUbi5u1726GRPqbzW0UctttaJ3MU+SC4 JA6ZxxjjGOtVbvWdPeO3S2+0u6koWeEKjjHU4PqK7aULvyOSU+rJLPUlktxbXFtFLcpukNwn+jxB DwFK+3161QiCwSGLKlHb74+ZVz3zXWctTVH/0PgdFur90tbUNvaY4jRdzuBnJx9BmiGNbMswYyru KurDMiMf5V/uwf8AP+dM+rxpYutyFfEKwWptYwDIeBtbjnA6muZN29vJ5yERs75CDhmP+NQoq7Om lPlikXrEmPd9oKbEma5SNo/mjduvP+epp82tanqUc+nQ6sbKwuozbeaF2xwAnBO5QWxxjijkVzWn Uaka+nbre3kBnMwtIVUySE7ZMDAbn1xWYNQHl3illhn2EwTKMo7EgbW9uT+VZTpq51xm7aM//9H4 bvYzZPppvZbS4a4jEcyWE0dxMmQPmO0kDr39KggZGe7eJLgadYFY0upBlpAR6+xwOtf7pxppWZ/g k5SvZszBcSCcXCQNKd2zKYyqk+p7e1Xbm5w0aRg5kbB3tjbVOEeWxMr82jLempaadqEOqT+fcNHC 8E9qJ2t4JFb3U5ODzzxx0qSNYY2nexuzbrOfNCggSx7vYd+OvrShCPLaxnOc+Z6mfdSXHnCSe6W6 mXkTY+dc9c+/SmrfQSQvG2HaJvuMOnuKbhGxnzSuf//S+CJbx3jELMsRkUlWIw7DHY9fyos76dIb e0nPmQwgsjudzsQepP4fp0r/AHUpxXLsf4F1G+bcoXVzHLMEaKRtz7lb/lmpHv1FatxOuyGRiVRI wHaP5iMDn8eCaOW00Sm7MpXkOkQ/Z9RJkv7zeglYqclBwF9vcisyO5IfM7BIi2EG3HJ6AV0uK5be n5mMG+a/r+RoSk+Ws0E+6Vm2+WV+VV75/X8qjt5NSdTbggiEHywF2RqMk8+/WrsQ9z//0/z2jJGp NZSzbJXh3lGXGBkjO73+varCW6w3RhtvIkco2YAAWBwcknp7/hX+87Vz/AWC0JGnkhiSVSV/gkQH coJ6ihZJngM9vCpWBgryqDhc8AHt2NYSja6NadlO5NaajrlsHilbbZNIJYiB1YDkj860bW4+0XMJ YHEZLTF24fHQKPX3qEvcKldTsLeGYuJnZ44PM2bDIN+CDj5euPfGKz7aUnzJSVZkbKjPIx0/lWFt Tqg2oo//1Pg6S/eeMNJMA+3bMMYRADyB7Vbtr2NZVnkYuow6beQSMYr/AHVcUon+DXO3JXJ55rjV C/72RIFPzhD8yA9Tj6Zr+r7/AII/al8D/hj8OYr7XtS0Oz8X3u4rqk93GzWkbDau45zl1U/Mc+1f z39IjDY/FcESw+ATvKWtu39XP6v+ipjstwHG1bFY+STVP3b97/8AAR+27ftBfBRZEhb4meExK/3Y zqa7z+FeR/Fz9tj9mf4Y+GNW1LxN8RtDu1is3VNNsm+1T3jFSojXI2ZJ9TX+e+UcB8SYvMaUKeHk ryWvz37n9/5vxlw0sBXf1mLSTuvkfxI/tmfHLwn8a/jNqfjfwFo+rafo48/SzdX0UcCai3mhVKhD kqqxo2Wwcuc8g4+Spbl7d1kDeZxmRVJXPqK/1t4LwNfK+GsFgMT/ABIU0n62v96vZn+NHFtWjX4i xlXDO8HUnZra1+nk+nkf/9X4DnvLe8QTpEqSQSHezqVKgcH2wQP0q2tyPJeIQg3DyDynaXyo0GeQ f8T0r/dyUbxsf4FQai7lSK+SWRoHURSRsQQGDrJjjcrDgj3qO4aW2keW2kMskmCElYmJMccDtSUP dsNT95F271KO2WzuUby55FMIXGA3+PI/Sr/2691P7JeXLCYW0YhVTGq+Uik4U47H1PJzXRTiuTU5 qjvUlJd2Ubm4vbi/Pk2cUUCncWDckYxx7g4/OnMw81VlH19RUyjbQILVM//W+BZGljmPlEoCdq4P JB4qY3lxD5lqMSqpDoQuxjx0/H3r/d1Qsz/AWT0aKl7dxyxhIEge5SUF2++1vjBK4zwTWmNVupLC eFdmZB88oX9+v0bqPwq7GNilCbnBmMo8kRkSMW2ufYc81uWH9mR2b3F5NKiBG2LGm7aB3JJ/zmpn F7GtNDHlWHT3lhVpmEe62jkG1pj2Bz0z+lWJNVs54beyGkHS7qGzU3pacyYnPVV/2e+Tj6VdtBfb P//X+CL6V9qxpEk7xyBmYN8yD1Hbj09e9aFleCMy+VBE3mRbS0wyVIHUEY/Kv95II/wFsua5SspL 23mF6XETq7I9vjzEkB4DHj2z+NT34uI3kbb5sgAlM6OCkuR90H1H9KtKxM9LFMSLdAzN5kSICHRh gqf61rQ3UAsJFSZIgjDCOCC/XLZ7Y96aVkKe6M1r2R50tvJfEpCNcDAXnp70rfaYZJ7MzI0fmYYD IUhfXJ9qVtbkt6WP/9D8/pAWk2Q45+Ut3H0qZFCzNGTghMFyc7iPWv8AetRbdj/n7k7QsEM8lnK4 27o36sG49MYq5cXHnxRxh0ITLINg3pntnrj2zWiSWxmVxLCgSBbiJp2+Z4P4gPXFLuMTLumxC/Mk WMqSPun8ifzpk8qvcSaeEMjZChWwFxw9U76b7TcW7RIR5SEK4OVGcZ/kKCrH/9H4CtrSbbKw2lQP mLHpVacOYzsQhA2MdA1f71yi1qf8+5Lbl85OV28lBnC1KVaXksVlVTtPO1vqKzkrqxUXyvUdvkhe KOCI3DMMzqDgxdfm/ADNSCVZhKJAV2LgsQQOnas/ZvoaOaa5Ssos7eFDCsjPI5YsHzHtxxgdfxzU aXm+SR28yOBMo3yZZ+n59KuK5VZmJ//S+BrN185Zh88ZYFFYY/Srl2ZI7lZJEENvI2whDvkhU8El etf7zpJH/PzKXMQBbO3u7iO3mlmtGP7iScFZmHfIzVdkQS7S4Ck5DdM00r6EjfI853g8yMqGBVxG fmGecE80+S1itnuLaRJkbaPKcnyy2cEEHr/kVqoJPUBs12EHkyYMoAz3OOnWnwbHVpJW2hUyoxyT 1H+fejk6Jgf/0/gRm8+NZGQN5bhtrjcox061JZW0c8htfPWBLqYE3MpLJCcY4POBz9K/3r5Hc/59 9i5HdRmMosiPEhKCXG0sQcZArIlu4337ZB+6bDIv3u/WjktuyotrRE6XMEA8+OBZQp+UXX70DPqK bHfTSSxu0UMW4YYIdoH+enaoFfW5oxzWzQXDtG5kKlI/lBTOMZ+tYH7yOJ1Zwfm3M5Xbgf0FVHR6 jcnsf//U/PU20kZIFwv7whz83mKAcehprtbwQmNsIin5WPQsT0/Emv8AeuTi9j/n4bb3IrXbJL5k 0xSONSQv8Le1aJFncJnDtI0m8pgeSE/n/wDWqW10EJFEwaR1ZWGf3cYGAg9M/n1qKSORZC7Sr8y7 TGfmKn2/+tSAfGFETD7xHyOT/D/n+tBxFFDy7I7ASOnXnjIH+etAH//V/PqBZbP9zbXBa3nDebG5 O9Dnpk9jz371JGkYjKx/Kd25gBjPv9TX+9B/z7JJbFOO5urm+azhtJjAn3pAu6QDHB2/h2qRrYBw Y224H4H8KBglvG0iB2G4/L5i8t9CPyqpEJVmmhdGR0lK4Y8nHGcfn+VAF7zDslzKAEToayCZpkkk t3Xae7H5G59O/SjYD//W/PlU3qqgnJTnbkUwGEB0cElRmNweAc85r/ebmVj/AJ9yvJBcQWpvjGZI 5SxjWPDMdnBAHqfQ4qcTq8EbRpJE/lgtHL99Tjmkpp7gJ9r8tVV3HzHaA3BOeOKiuERmRoZd525d duDGe4569vzpSn/KAnkgwtLMQY1bBUN84wM7sdeMdakSWQMzEgru/dEcZHvUxlZ6gf/X/Ps3EagO QCR1yM+1M+2K4xkRvncm3p16Cv8AefmXc/59wcFGM6IJLmRt6NKN43+uKz2+03UqC6dDcMf3oUbY wSew/Gpc7bAl2LDQrlU2sXVsKwGRn1/nWlAYWUpI5JQ7XK8svTis3N9WOzLL2iX1tJbW6nyhMrEt KI1O07gMZ9qz7u3ZF8t5Clvc8SLHNkBl4GUzx1ODWU2tGjaKfI0f/9D4EMkcQCeaZTAcx7jvUYx0 /KqrXQZo3UNu3bt/Qj39v/r1/uzKV9z/AJ/OSXcdcBG4wnmzncecM2OvH41as4hIvAwqHHOQOO+K FJrY0s72B4YIbl3DwTlhhZEUqMY6c85qO5S0MQ85zFLGQ9tCFJZi3B6cYwaalZWHysrI86FHaGCS AERsZ8gqSeNvPNPRBaXMmZcsGB3B8qg9BUtpLUOWWx//0fgF9QeG8aGMSSLKuXZkARP/AK9ZTRub vcmSg+/8vQ5r/dbmij/ARRfLZsuG3+0TndKpXyRtjYbW46n+QqYxS28LyxxBli5ddwU88DFULkaG RzSsonRmh7vGDhn9jUYmDzSzGEAzxiPyT8qn/a9j3rKUtdOhUU1uJfxmNo/LZW+Tonb2NSWbzx2F 3DFIu6dlzHKu4tg5+Vuox/Wk6lmij//S/Pw2wdCULfMBJOrN/EABwPTjP4mqm9YFfCMSxCoQfu84 JNf7pOUmf4Dk9tEs7qiOFuXQiNjyQO/9KsbzP+7LSHyV2nfnA56iplN21Bq+jIbeNPOba4ZlyJBI oKKCMf1pEt45CYjhVjbCKPu8en6flS9rJEKnqSzfuo3jQIM4++M5+lMtWKc7wqs3zDPp7Co9ozXl 1sf/0/gi6CSvFcx+W0BBDhTlnbI5xn61XW+urDT7pyXgjkl8omPBIRsglvbAGa/3L52f4GOKRGbV o7SH98ksb/MuGyCp79MfhUltYeHkupJrmRnna3KBrd8YcdAw9O1Td3uWlbRDGmXY3kobdQu10DZR vf8A/XUmmTwxLtdRLIJld5G/1e0Zyu334rKUmnZFwetiK38s397GWCuZd9qkY+RUORtP5HFOvi0c htiil1+bfzvGR0NTzyNOVXuf/9T87IAfPJJUADO9s8EfhSbZXuLmaRXYEbi5HyMccGv9xFPuf4JT SWxbsoLy6eFrlLeOAxE+eJFVcL0yPoO/pUK3dpLc/ZLSWKXdIY96tlcjgnPsarniTKNtGNklW2la No/MAbbkn5T75pjSTzAMs3lohy0Q+6w57VDm76C5U+hae6WOFUSKN5H+QF4w4T3GehrNe5nMHksp kYSYBIAbn3/L8qOZ3Y+VRSsf/9X86gXjgCooLqCxbu361Da3l9Lc21jBZtNNeyCEKg3SBjx/XFf7 gH+B5bmjJe5sJj5N9bXHlS5O5IsH+Idf19anvrGC4gEM032l1A3/ACkR4GNuM89qAII/LT5QzZjw VCYwMdc/57VekuIbxFUKjQuAwkMY6gcjJ9D/ACqZOyAo+RBbShBctOSfnUoFEJ/ugjrViZHSCRlX auc9OW9s/wCelZXZUdz/1vzv3eanksm1goPC4HTH9KgghaKRZB8jxOHjkZQwyOenTtX+3L1P8Frp EsjiR2PyrITvEaoEVj6gDgY/rVhIUZg5kEMko8qS4OW2c9eOff8AClYqO6Eu5WV4Ua4aaSFQhfjD Y6YP6/jVCcONykEHAycdv/1UG909ixFO+mxloo7idriLy4l37U54cn26jr6cGiRJbq3nlj2JHBt8 1T945OBj8qcXZ3FJXVj/1/zr01zFL5kUkCODsBuIVnVQ3GdpBH6cduaJ2+zzS2gKNIj75dhDk55B BHY+1f7fXUldH+DSTi99Czp1nc6gJbWCVIwzCVzKT5cYHUn8z+dRo1u9jPbS2VrGBPuaUDdK7LkB y2e/p7VnyyXQ1II7aKaVftEzRQiMj5V3EHHBx9QKuaVE32S4l1H98kM/lLsXyfMjwxUE+vAFHLIz bT2ZTttNttgDxu8auZcNhmQ5J4POMfp/OxbwwSTyqk6W7eUdkTttD89j+fWrimlqNaq1z//Q/OiO 4O9bWRUjPnlTLgEYzgMT7cVFvjt0uVmYOv2geRMUwQnOc8/Sv9wUm9Ef4OWS+Jk96gjSaISq8ICm NoukhI6+xGf0rCn86KW2jZLjy7x/Ktp1jJidxglAcdRms5RbZSaeiNreIpUtp7RmRbcqzO2xVkB7 98/4Vn3X2aUiBhgOvzoPmxz2qeRmkGluRlmiXqzqvA2g7j+FRFIpf38jET27Boo2JVZc8EE/kcU3 F2K5oo//0fzpR7S689ovLSVVyQJB5MXqNvcfj+dZDXcEl8Ws1iNsqIjMnEalUAYjHXkE/jX+3avZ 2P8ACNqK3RYN3vLtCjvldgIOI1I7n2qCWKFIluLiXZK52CMLlc+oNLll2C8eiK9mqMLz7Zfosi4e 2hWE5deR8zZ4x61JLBbKbdnBmZZN6lc7VODwf161m073uHtPIdc6h9miSRLZpA0gjfy+ep4/AVXK JNvaXKQsMuRxtHrmiUblxd0f/9L81Lo6ZHp0ENukrSrMG88SDywmDldvucc57VlxrFG+IBsk3eYA h4bPJJHrX+29nax/hOWBdyh1haMIsvPmNhRx1Gf6UheAB3iHykZZupYgYP8AKo5H3LjJrRIrqk63 EU/kyG0aLfK5iKmPp19D1q3LERulDFjwwJByAO1Q01oy1Jvoc+k9vPe3M0IZHkk+YYKjA4GPbiul S3uY7RbyFY/L87yyMgS5UA8d8c0LzK1P/9P8uZ7yWa5dTzIW+dRw2Tz0p4W4tp7eZlbfFIJBE4yj Dj7ynqPY1/ts7SR/hlzSWlh0ymVWCR4TdncF24/CqP2ORG84XM0+7pvbKgeijtWNk1ZiXMnojQt3 Kg2xI/ec4kxxjnqaQSoqtIzhEHytg4z16UoqKdkym59jPaaZfJEbF0uZSqmRcHGCcKMe1W4v3EUh t4trISzBV27j1/nUy5baivUeh//U/Lp73Uo5/MW9dzcfvJEkAYr2O0+mPyqSPULu1huLKBUK6hKj SswOU2g8jtzX+0zcep/hpy1exde0e7igtRbW6y9ZJpAdrLnPPbP+ArpU0CKOIulwWaFlURxttEmV OWPqBjp70XgDVRbnFOPKvr4wrIJLV97vGu4J9MelTxo0tx5YhkJaI3ExAyCFGWb8gT+FLnggSqPY c0lnMY5IVkEHljYA5UyEYyT9T2pY5J8K2D9nDkhmG1Yyo5I/Sl7SFx8lU//V/OCNL3VIk8mOVt3y +YwCRMAAB7dv898aeK6gfypIX2iUw+aoym4DJG6v9pHUhsz/AA2jSqNlqNZPKZHjJJ6Ljlu1QPZX lyjpZWz3E4jMiQRn52A9P0/Oodalc3jQqNWNHRdPnhi3avIlirqGuLJnH21PbHTjPc1U1qyvbIS3 Vt5p05zgrMfL8zoQM9M4Oar21PuU8LUtqR3cOoaeFlaSCJTEnyAmaOIN13cf5xTBpNzf+b5FzaXF rDIp+1QEiNc44JPOTjHQVLxVFLVlxwVWWx//1vzQTQ763nT+0LS4t7YttjdIDK5wO3bn69Kqfa4Y JWVpiqzZhgka3ZlYjqA4BAPHrxX+z31uj3P8R/qFRLVENnc6HIjTfbYn864NpKskbSSgcfMi4LAD 1Ax7mtnyUtUtbnVLO/fT9zRWsUVvKplHO1844B4PbPNZzzChT+KSXqzall1aorQTduyEn0EaVNBJ 5oJvF8+CG2t5S0asM4diBg89P1plto0i+bfR3cV3CYWmNg9syXcO1vfAyccDqelcss4waT/eR+9H RHJ8Ve3s5fc/8jQi0+/u1vRJpOq20v2QSx250O6aby8febbGQqngfMR+tJD4K8TRRQsdHmke6t1u Le1tEeaba2fmYFRj6Vzy4jyqOjxEP/Ao/wCfkdceG81n8OHn/wCAy9O3mf/X/Nq90LUrUQtbabqB u5g1vcWU2mTiZGGfurs6jocfnWjB4I8Yvb2uox+H9amt47kQyiHRbgs3GSdroDhe+M9O9f7AVuKM npLmnioL/t5f5n+MtLhfOKk+SGGm2t/dl/kMi+FXjozXdxD4Y16SSW6aVY5bN4vNU/daJCMgdOK3 YvhV8SpJbGyg8Jara3F6+1Z9RtJrezgIGSXYIcjH05IrhqcccPU3aWKjp5v8O/yOxcF59Jq2Flr5 f1YzR8NPiOupzR2ngLxTqMtmXgnurHTJWsTk7T+8YAYOOhxxXen4D/Em+t1+x+BfFcGoW8X2yORN Jd4V24PzMOBk9K5qvHvDlK0p4uOuvW/zWtn5PU6qXBefycorDS002/Lv67FO0/Zr+MF1IL8/Drxh PetFvkWS1Ihcs3U4yTz6DjNbVt+yp8dFhneP4fa1aveMsF3DcxGfzRwQ0S4BwMdf8nza/ibwvRk4 /WU2uyf62PYw3h7xJXiprDtJ9z//0PmvS/2Nvj1qEqfZfhpdzXdgFaCSd2g87eCGCIEJOADn09a6 aP8AYy+PGvJ9iuPhFrVhGLsA6lbQss8Mif7LxrvQ88jNf6g1vF3heF7VW2vJW/P9Gf5Z4Xwp4mq2 bpJJ+b/y/Uli/wCCb37TOrXSRjwbqUNobkta6gthcXAfA4jKqMZ+ma6j/h2t+1IyP/Zfw4SOWIgS z3tjdLPMc45ZY/l6Dqeg6V4lbxv4dpPTVf4l818vU9vD+CvEeI+zr/hb/rTobmnf8Esf2o7u7GfC 1pBb7zNdvb2lzM3muOVVmX5gOD2A9uldVY/8Env2krl7bSX0KBbzRpDqM95bWUkV1fJKRiFnZSpB GMqeOmORXk4jx7yWMWqdPXzkv8v1PWoeBGfS+N6f4X/mS/8ADpH9rHV5Hkj8LW9tZwSNHPb3cLQT PGeFkB7477fSu28Pf8EZP2lLWEy3VjowhuJB9iS7uDI0e35izKwOORjk/QV5mJ8fsuhBeyir9bu+ vytoehhfATOalR+1vy+ltPnfU//R9v0z/gjB+0NcypNrGp2NtDdzlks9MhjGFQdDIfu5x0xmuxT/ AII0/G/WLKLSk1mLSbOeZ2mn1K4gjnCrxsUYO0nHBBBr+38T9INOVqMEo/O7P4Twn0fcRyv27lzd NrfMt2v/AAQ5+J1ulm48b6RCLW5Ly299eRTNcICPldipAyBgHB61vt/wQi1jW5kXV/GkAtpkCD7J qRuJI+clRuGNpPYLgV5OI+kDjGv3MdfQ9jD/AEfqMZWq3t6s6S1/4IXPp4kaTx3e2vlBYYre01gY 2AYLDdEcD2FdT/w410q/SO0j+JWq3dhHPFci4muFXYwUrIu9VDEDLcEEHAPBrycR49ZtUtb8Fb8m e5Q8AMFGOkdfN3791oben/8ABEHwrpi21tL8TLmKytrnzLbcyXFvv3Engx8kknIPHJrotP8A+CHf w0TUl1G48ZWd3b72ka0ltmmtPM5y+NwIOfTp6V5dfxtz6p8EpLS2l0epS8BcrVk4x36pM//S/Xux /wCCOPwGjshZa34qGsNHJKLq7t5kg8sMxKxmbO8BemM9O1bGn/8ABIz9k7SFnhvZLWW8lKJdSRTL O6xj/V5Dvn3LcA+lf0XV8W+Lqjap1ZpPzZ/OlPwU4bio+0pQuvJHRn/glv8AsrWrWqv4j2zx/ubi 1S8gO6HHyp5fmHA6csCKn/4dl/sY6REZLqYRS2M32piNRs3hdMg7FQ/yOevSuFeIvGTlKVOc7y31 eu+/fd99zs/4g9wqnH2qjaO22n+WyHap+wL+xZdfbIlk8NWqX8CSIbu5sYLtMY53rhz079Ku6d+y 7+wtoiJp39seD7VvKFssg1m3jSTA2sGJP8WD3z71zPifjOtD2a57fP0O6l4ccH0a3PGcebya9eyL N58E/wBgXRJ7VoJPA1xPFdIQ0WpxSy2bDq5bg47ZHPNOj0H/AIJ7aDeXlx9u8BxyPE8lwLlVmNuX OC+SDtz61jLF8a11zPm10PdpcO8KYNKl7mn9an//0/3mXxR+wdpBhhil+HCxiMQbzpi3MjbgSJNx 4GcHkVnP8ZP+Ce3h4TTm28G6nqFrH5LmHT90caPxvYk7R1PIGea/Z/qPGFVaykr+Z+aLAcGxinOE Xy+X9fiYGoftc/8ABPGzS5SY+B2stMRIJIo9CjvGmDH7ivxghvX061ny/t/f8E9tKhK2ttoVuNP2 zWpj8NQusxI/5Z7ckn1zxXXDhTjKrHeT+bJeYcC4eXK1BNeSMq4/4KPfsZxRtdWFrp0trcSk25tt CjiZ2UZKksAueOlY8/8AwVZ/ZJtNGb+zNKj1IpKY/wCzH0FT5Jzy/Ccc8/1renwHxTXtzKW+u+hc uKeDMPrzQ2021RyV5/wWC/Zl06O61H+xtVFosSxRRLpMdrFcTLwVVnUDKkHqR0rzh/8Agtx8DFa+ eX4f3NtbPH9na5ZkmM7nIjzt+Ug4ySD9M19DhPCHiDEczqcy7abnz2N8WOEcHUjGCjJPfVaH/9T7 uk/4LU/Bq2NrBZ+Gp9Yvxua8s7GC6EpP/LJUyuO4Gd3WsTWP+C5vh7TYGhtPhxqdtLbwtcLbXDtc XEo6ZZSRjHoM96/qyj4KZxUnarovVf5+h+EVPGbhKjTcoK7XaL/y9TzYf8F1rq+uHNr8N1a3VQzz GSfT1kbByNpBBOenauYuf+C3fxAjRV0X4caLLJbztJdW95qHlXEkbg4O1mXfj/Z5yBxXqUfAyu5W qzsu90eNPx1yyML06Wvp/nYwW/4LRfFWTTpru28JaFo72zPKpkmIcls/IigbiAfTn61yUf8AwWj+ PWpXf2SW20zTBJB5lrfRhJXDr1BhaNmIIzwcGuyPgVGN+astPXU82XjxquWi/wANDB1b/grd+05q FyY9L8Q6da2c1st1LPcW8UyW5jyWjUBQQzY6ZA7da86m/wCCtX7VGt203leNINMa9jb7batpSxXd gFO1GjYBh82M8FT7V7OG8E8rio+1frZf5+n4nlYjx1zLX2NPTpe39f8ADH//1fC2/wCCpP7Uw2Kf HVve3Jikt2M8VzBHtK7VYlCvzc+nX865S4/4KA/tQa3b3s3/AAmpt7S5C2d6mn30qXMuxflyDkKO 4PJr++qXg7kVGfPzO3blR/GFbxvz2rH2fs168z/yM2T/AIKB/tTNatpS/ELxBZy20Sf6Ve3AuRdp g7cSAZ4wM55rin/bO/aRFuk978VtcdDdZubbz2jgEbMN5XGORkkYxXs0PC/hynCS9le55tbxj4nr R5XNJL1/O5yfjD4z+LvFUyDxLr2seK43nEplu9Umms1jxx8jE56/qPTFfInjfVb37PqM1vapvMTw WkKjy4YI2LBgqnoPmYfQ19bk+UYbIsFPDYVWik387H59nnEGM4kzSjisY7y0j8ua/X1PyN+L1k51 jUzOIhNBJ5cEEeNkCAjcp9ecn8q8KEBiYNHgAjLY43V/n34kVXV4txkv77X3H94cIQ9lw7ho/wB3 8z//1v4Vk1JF8qG4wrTHYuOVXA6tjp0rpdFE8bLeRrHcGFt0Q2+YjYz0HeuWbsjj5+52+l39rd6T d2MdtcQ3DXDSC8lAViXGNoGOinn8a0DcXMsMCXlw1z9lhFvAJVBESj+7jp3rlqdDVPlKoiaR4t8i mOIkt83PTjNPE0R3Rw5kkT/WCP7w9MVyy+Jm0XdGxpdnDZOkz+cko/egSSEvGx59akvS97OcF9ij cBjJ3e4qRn//1/45dO1aFl8ixJO2PyplClXBB53Z/kacNOGtxm9a8VI7ZmhQyZVmKnBGD6EV8+VG NzYCy6VaRsiW8sQXChZQHY9yR71RGqwyak91KqrEbVYJhJGCrqo4B74HNDV9GW4Load5LdSSWrQ3 YS1KlPmkBCKo3AKh7dfzpt7Jct9lkgUfZeVlgVdvmnsSevY8Vhyu9jPladi7DIZII1lQAqdoUMRx 6V1vh8HVdQjjZPKm2CFDM43NjhVz+AqJK8WhzjywP//Q/Az9kDwpd+Jfjz8MdB1q4trXUh4xintp 4w106Q2ksbhnwMLgZyM8hOtf6O37NlvHY/DnS7RVKGG4kdmKbASThsZ5PK/pX81cbSm8+o0eihf8 Wv0OTAX+vVG9rL82fSyyhiCrH5ht9vSmxoAzBsbSeTXiHuWLDR7UO0ZU1VUbCBGM7jg5H3aBCT2X zCR1BJ/IVFFBEhyuBngjGMVvB2SZrT2P/9H9/wAyuytAsNr5ZO58wjeD7N1HaoRatuVQdqA5yTzX 8i1dDSfYdcyO0Tqy7xGmdyj06f0r8sf27vDF3d/DvxRc2iWFo11YXMM0t9qCW+9PKeVXhjdvmcMC AEySe1aYdc2MovzRjXUnTVtz+Jr4i6Fq1qtra3Ee61klY/2vJc7Ymbcd7SLyc5Oe/WvLrKxsNI81 RPl5nbzNjmRnPQkHpg9q/ozCyXsI+hw/bSfZGLBpVxNqP2m/u7iW1sXeaxDOEyGyVUL0H15/GmPq M0kr7bdpgmY0jHDEDuCMgetdN/e5Q8j/0v40dJNncfbLxi7ahcOF8zaP3hX5SXPUkAYH41ALe402 Wa6jS2lLSiR/PBLc8Ej8P5Cvnzjg97jLK5uLy5RYwkkUUm64ffhwvPAHfnAq5BqGnteTxRQC7TzS L6JrjKDaMLgDOCCM/XtQZmrbQaNLo98fN1B9RBkMEK7ZUkxzhjnPsAPb3qHTLTT5LPyL+S5syjLM JUhDy/7hQkcU07Me7KcrQwTyR2E1y8LymMymPYpX0Kj/ABNWYvN0m7tHiWGO8SXzbZ7kCFJGxuAy foePat1qOUeU/9P+N2S9unfzJgDPK7GS4j/5ZOTnIyPc/lWZe63fm5UyzPJcRgRrMx3EheBj/CvG vrY8zkV9R39pwXMyW063N4k4Et8wtiEBP3lB6HHNWk022nubaVURre2TykaRdzonf1xXXTlpZlRi tkbczzbodOsLWOK1nURrOmTIz55LE8D61k3Oh3GmCT+0LhJb3BW3MePJVeCN2O59RXRD4kJQVmjz a5uz/aEsF1FBLAkLb4Jht84jvuP6AelcKVLXO2O6i0q3LHE4U7seg/p+FetTezQUldM//9T+dD9k Rley0+K8uLZp4oNttdtdql1chrdCpI6ct0HU8etf0s/8EuvEur2HxOhsJpLNbC41GFfPicLdRhCp jMq9Ty0mPYV/fmDj9f8ABh06n/Plf+SpW/I/kHJKk8H48xdHrN39He/9dj+yRWTUvColvngKNprv M0LFUz5ZXj0Of1r+Rn/go1p8Hh/40fZk1K4drpbi8uIWbbHNjLqyjvhTz7mv528BZujx/GlHrf8A A/cfpMwi+Cp1Zb3t82fl7fSWd/qZka28+1ezMW6TMcqPkk55wR0x3/pxFz/aFtJ5tpOYoImK+eVJ WIngbx26HP0r/RGn1P8AMSorS+Zc8L3GuwQ6h9q1S0hkDKpt7O7bGpBs/Mqd9oyDn196h1XUEuRB EtzicXH7xNuY2I6E+o5IrQwd9ux//9X8+tO1BmudrWcM1sqGKeRJvIaAqOGHWtbWZEFoq3No2C2y CXn92RycfUfzFf7GQkkrM/xvOSgvruG4NxpzC2EYCRBohLyMA8H8T+NSR3lxJF5cwjPlnO0LtBJP JxRNaoujNxTUi/pOoabFdm11GRrOPaZRNCm6RsdAPf3roorXToomvrTyXe3cOlxnde3Dn7ijHpgn PbP0qlFR2NKk7xsZ1/rmpTzyNfx3DnmdyFzt4I3HHetJ7a21fSrI39ykNnDP5cEsv+tkYqW2YPzH +ma1UFYxbbd2f//W/PSLKpdWumTLeSWwea5tnYD7LGnLNjOeBnsM1cgtX+xwaha69EBHMDeWryeT LCu3PmAfxLkYOPav9luVJaH+N17FZr0tapeyMl9MZPMsjHNhYFJIJI57HIHGcVopv1eCUSAPthZZ cKXMWACpb+7k4GfetYwOStPQdY3N9pMbxSTbmlt/IS4uD50gXgBcnPHSrM+p2qxwRwQ3UVzkSXqn b+/fHRAOcEHPPPNaKCd7HMptEd1rGnyQSaNK0QKTi4aVYGaWLK8oT6EHnr0rIn1kafZW4R7qaWzu S9rtXMcisQFjCeg5PPXNKCtEc5Xdkf/X+GYtVW5MHE901yrNPEg8pLU87eefrxVItb3LXs8E9sPs fyiK5jMjSSZwRyCpx6H0r/aNRXLc/wAUp7liyiijjeyuVW1vI7ZLsXtu3km56OckHrjsKr2Vzfz3 xFzMkunXkuYQtsFfGMcv1IyP51sopRM+pPrItrXZLLpTTxxxvDDFakq0L8hXdenHB59KuW2qWKww M+LdLGDN7duhIBZmYMvrgEDjP3aunGyuclXWY4fYbuJLjT7o3cco3/aJMpu+gPP5+tRXGlwRWkd9 5gSZJ/KUzuBjdzgDPIwPwzVU4WnZlcz9jy+f+Z//0PhOwVf7VOsRnz7m3jKPEHzBNkFeEHB+uKuJ pM2rWhuLj/QYoHMcO47UcZLDj6k+tf7bpJbH+HUuZdS7Gl3ok6SKyF50EbGL7twqjof51xV9eTX0 wufPaPzw37lVG6Fsn5ce2OlO2ljCTaludyNQtrHRNEMJN1LdWwe7l2ECPdypxjGSMflVB9XSWCZ4 LhElgkETQSod0m7nKj2HeqVMhylZ6kNteSJ9rYiZneBjuhXLwhRnOMdBjNVb68S6sdL1GzJmivIG kW7kUhiDgEYPTPPXnitFTRg5tH//0fgu0LzykwXrwqbeO0hsWVfIkI+8d3UHgYHPU+grX1GS40+G OL7C18xKtOkShniUcllJI7/yr/cOEVZJn+EdR+80Mt73bB50ERguc/uFUDcAwIcZ9eR+dZN9qNvu Wynt7o6vMwkS6nkCW8S44QjuT9eBQ4akR7sV/OjjdCi75F+bGHxjk4P4U2ESMqRKiIXbaJduTk9M 1bjdmesY2Nhbe/vYfs815ZyXNnCDNc48kMOAEA7kZx+HWsm2ska/uv3ro4URk8MVYcE/jzj8OTRF cuhnO0j/0vgafTmtIfsNvK7KCsnn3ADSsQc5P4k/pTmkuknZ7i8ulnmh2pE7/Iw7uB3zX+47Vz/B ePuao0ba6mFmIlukBgJ8lJ4MrJJj7xI6j2+tV/Lvfs81xM8U9xv3u0Q8mI59FySO1bwXumMl7zIZ oY4oEkWSV7xzueEjhQQMBfpj9axkMizyCbCyB/KWJiMPxn/EfgauL5djnl8TLssBgkQXB8wSx5eC 3k3OF9MjOPxpdRktba1Saza4fCsr2kkRSaPaOCD0Ofb0/Gt1qiGk1Zn/0/gbTbq4W1tdR08zwzvD vcKTHcQbgQRkcg4/mRVaB/OtriYQzB5JvNnaXJk3cjnk9cevav8Adg/wCcHfQtW0kqwLHI/7lW3A N82zPBIp+6yV5zFcxaiiIJY3jQqYVJA+YH34/HqaVrM2hHoMaW41GXdYiORIQBcRyyCJycDoSRnn +Yqp9qu4bqZdWSNIrZT5drb26xSqcZAPHPOO1MuMGncm1K+ZLKxW1d5Jr9stbocSQjOBvX8zQmmt FHsv7v7DGWCbZTueV2+6APf1+lTKLextGXKz/9T89bySO2YhD9z5SxOeBT7S5spLS8Sd5pFMBMXk E/K2fX25zX+660Vj/BB7jrVoliSMNKsK4i3IC8gyQM+vHr2rUvLeO6+z29vdW8EoIK3F3nyVx13Y Ge350NaWFtuMuGlcLbvLFMIh5O6AYRgO/v8AWs+Rbi11BTBtnjMTK52EjH07HnP4UJWViGotkD3K SO3lxlGHEgIK7z/n+VMWJXeJmc2653TKFBZz6Zoa0sZrRn//1fzyuD5bkoD0whIzxWZavLb3MsjT +dauMlCcMhPLDJ6Y6elf7sQjZWP8CZNNmy0KLcxqJoy08JmijDZYKPvZ+mR+dTKMM9tDOxW4lVXy MjjA4FVyMSdgdGt/MQbHCEoQyjJz7HnP8qy/OublJ4ZI1ihhnEkQOCZCQBkdxWyXRGTklsPtoLqO R0lTyt5Do7uFVhtHP6Y/Crsl8wiubWJsq8YUyRcSRnv9O1aQj1Mz/9b8+HmeeFFvCm6CLyo2RQsr jJxuI6n6+lZsMVvHbNbO0rvvz55kKykc8Ej8Ofav96D/AAFh8JL9iiaxnGn3whaBwVtLzd5ky5OW 3dCeT3z1qa1k2weVGhjIGGYZKyMTnJFTKN0UX0mlNpHZ3reeol8yNoSYWjOf4uefpTpAVdmhmDQw NgyL8uevUdqxa6M0Uk9xkv2dbqPU3nuHlFpJbNHI2bVd2OducZ4HJ6flWfNcTRZVNhTaHMyfy9qz 5DaMkkf/1/zqjureVG33EEp2kSWqk+avoxOMfzq3ZT7kddzPHD94lSVQH3r/AHYa6M/wYTSaZ0Gi yzR324gPBINpyhUqPf8AIHFerJ408Q2ENvZ6f4n1rRIbKEJbQ6VdtY28i9AGVflOAOM15+NynBZr T+rY+mp097PuezlmdZlk03isqqunU2urXs+mtxuo/GTxBGVtzrviyXUoUjj0/UG1maaG3+Uhi6bg o/ADqa4rVvG2u3uoC81fVdS1eJ7V1hgvbpr6G3lxlJAHJwQf59K8/BcH8P5dV9thcNFTWz3t6Xb1 v1PSxnHHFOYUfq+Kxk3B7pWV/WyWlul7HGxOWR7mWSc4ladkeQ7pXYnc2O5rMuLqYSu6s6qVIU8Y APr+dfSU48qPja9T3j//0PgDSb+Wz0adbgQSzSzCK4kA+UwZDZ2kcHKjn1FLNeaXewGW3jujEiYm +0KF3j1AHQY9zX+8ahdXP8B9iO3jtlhVoAUgjQDDElgB71am+zLGrQu25lyVYYwe+KrkXUyctbop 20EdxbR2lwzSJFcG4iJ+8hz90H09q6FYv7PZJHtJkgmj2pJKpWKfHUrnrjNNRsrIghtZ7tLopaWE mqboifItiPNGehHbA71l3K6gzMdTt2tLnzMvBtw6AHgEfQChxT3Gm0rI/9H8/klQFmZj+7wUwOv1 ojE1zcSXCybVVcqG4VsV/vNyRP8An/L/AJUUkcpd4IZi4+XIDyZHUflT7dVt0YRvFJG48uaNxmQn 1U+n0pciDYzvswjaSUyokcjrCsBJG3OecdOv9KdO0sVvPZGNHRsYRuFXHIpuKbuNNrYEuzMsdgJ4 45WbzDl9roo4PfpSrEqLMY3ExB24Dc5HX+VPlS0C7vc//9L8+9zxpMYyVZuGC87h3z/ntU1iFt7a SS5ummLMXVyFURY/h4/rX+9CSP8AAC7H2churhmDtCCNu+VCIjxwcH+dQsdQiRUaZWWCQliBuSQe g9K2UIhdvcLe+E/mKLeWPy2w29QA+O61o28tnJDfQ3apHM6q9jOzFVjCZLqVHUtx1zinyrsIzYlm JleSTA3gxKgwAAP596q3DM8bfvghdgh3Ehjk9Qf89qLJGbUz/9P894kNu7v5hdUUquPmyR3zSi7j dAixkzMeZBnHHBzX++B/z9csrBdrcotsYRv3S7JkPCquPvZ+vakQyIHZ9pjDbUYHg4xntQHIxNyM 3mp5ayKNm4rliM881YEqPiLO9wM/SldByMjllWJSoXdJnYCV3hc8ZNamn2gnaO3aRfPfhGH7sO3Y DP5UXQ/Z+Z//1Pz9nSeZPs6TCHMoLuvIwDViG7Q3d9YAI8OnKCt6CUivcjJKBsHg4GMV/vZKStZH /Py4NAs15hri0tI7gXEZBjHEYx6nrn0qVVc7HICZGXXOdpxyM1ldLcXK+xEtxPaXTNDADHKPJvkZ gjSo3Uq2DgjjB/mOKjM0Y2IAxbkP0IHuaLruHK+xWmG1QIRwPbj8KniIlhaCLapcYZyOEwfXtS54 hZ3sf//V/PmAyKEjJDbPl3qABn3qzufdKd5aVhkFvmGenT/PSv8Aebnif8/Sg+pS/eq8ZlbehwrB V+YnufanqGmkudkbGCF1ImkGMD+6PzGffp0NHPEfs/MuXksLQRCzj8uYAea7uSXP8WBxgf5zTLm4 gvEV5riR5Yk8tRt3xx7BhVBzx0x7VpGbGoJblAxZGZriByy/KkakOv17UQyFZBA6Owkbasu4bFI9 arnfQbgtj//W/Pp3jik2vI3P7sIv3SfenxLNIXiiRiEG7AXnFf708zvc/wCfzkRVur6K1S3jVGmn luRD5Ua42KSNzsemAM/l71NcgWa75I9mDtbIycmhyb0ZpGHQb9micCS5kPlsMlIuWx9KSM2zSJGW eNDyHdSvH+PtmolKzsV7Nmski6ehIjWSOQEqD/EexzVISxTo4WLy5J+JlYhlHpj8qnn8jPkV7WP/ 1/zznhntCkpjd1Uj5E7jnmo50GoyG08tTCFW6ww2ygpz19Mjp7V/vM20ro/5/wBxVyCSBxIVjUhN 2M56CrSIVMSKSG27PlOS3b/61RzsTinuLbKfPMAMh8yTOWOQme2ewpzsqu3ly7Snz7nPHHP9KOdk 8iIpJTdQhrS8iVv4wyFnPsemD9anS42KkbYkcAbto4pc8g5Ef//Q/PjdKm8+UD5nC5GMe9REzoco wU+/UHtX+8XPI/5/FBLcZNfSXcZtJIZBMuG+1RDy8kHOG9enSnaZI0dwY7oLdRJN5c2G8ohT02n1 6Uc0h8kSzNDBazSOsrtC8v7vf1XJwAcVbj+wkElcyt8hlBAI9B60rvuHLEpx2qWpNrLCI2uJGWXz ZTJt/wBrd6cD/DqKjaa3t2jso1QmJCrbBkHk8ntRd9QcU1ZH/9H89o4vNilYXI8/zcIgTGFHbP4f rUEEWwSxlXdi2VLNnHsBX+77dlc/5/uVdh8aztAyGYxDeDsXkMAemD/nmpXSJyrsSGH3jnlqyUmg suwOVcgx7B5X3NyZJ5+nP41m7kmnuC9xum3eYxUbUJP8IwP0pxbuHKuwQTrFLuIwR8jFxlST04/E VeKKbcySXEYccmJd2f5Y/WtSXBNn/9L85jLbBUDuVY5MisAFwPQ/Srpn02RAbFvtKRMsZES7TnAz jPpmv94D/n/Stoh4lG9lEgPAATHzJ/nio54/KAYKWd2CjGMjPf8AWk1qmBZjSSNfJE6smQfMQnAJ +o69vwq89gBuFtKWi2hmdxgs2PT86mab2EkloinBDFEr+fcENG+7KHaAQehFUriWM3Lu7ACZxtXo ik8AAVk0XF23P//T/P5oreFUMr4cjIA7/Xn9KouspikuFj3KhKqpcIGA6kZNf7rSV0f4BJpMhjZC 8Ny5kSWJgsYUfOu7gmtfzJrS5ME8imJADiPBbB5+meacVZWKdlLmMmSORrhvIdy87/ukbJ5PGAKm aO9j/dOqmQNiRj8xGOuMdKYKUSSbcYANvmlmHyn+HB/+tmrcdokCSXYkT5wI2RwC/Q8gfh255qZR voNyS1P/1Pz6CyT3abfn3Y8yVvlVVxjHPccCtG8gML/ZYTGZJYzNBz/rgO4r/dTkP8BOdGbE9/LJ Gt2IUaNNs3lLlsjpz/j6UpjnkuJSZXlik2pFERxEF4/z9K15Xa6F7TyCYRiTy1fBjIDKRtP41VaZ XkXs/Re2f84rNw1D2nkTysFZNy7iOuOop7wuHhmhm28byiYy/UDJ7etZShZ6jU7ux//V/P1nePdk lTIhQr0OCMH+dVLSKeOG6hnmLQPgxEoGkyoOMn6nr71/uhY/wDcxINOupdQigMkliTAZ4ZWQr5y4 5UHGORirKXWwFJCGKAqrN07/AMqmSug5/IzbeyvzdTXkkTGAAuplmwk+eAyrkH5Tmre1UKvNKojc hkIPAPb+X6UcsUCqajJvMuXjZX3Ih475xxgVoQWoEqPMrp5hAZMEhAe+2s/dNFUbdkz/1vge5t5I 5jDaTosLA7vMUKSBk468Hj9aidZEt0LoWVjsL/w5Ff7lx5ep/gPKctir5PnAw/aPL2KPLTcIwSDy B+GeKqGKI3D29upikYgtIF3AHHUnueM/jUOydiozdjQurbY6m3d3jTaCJUC8gDdwPUg9ahkG6J2R kjy21yuBtP0rKduhcJSbVgt7aZ7m3i43ucCQkKGx/h1qzJbPM0jq/mSFiC/UHtUGvvn/1/zqu7eY SJFDG7H/AFk77cLHg/14rTgg82yDkCaCVCHK89OMH/Pev9xUoWP8DX7VvVFeJUktQ1tG0UJzGqt0 44OO3btSiMRQIYbOPdCjKpVdpfOfT9KFy63LcZ6XGRWZmtB5zSLISZGyBx6KD7VNZ6NJJE22TiNS fn5ZyOccD8KlunsV7OfYuQaVJLZ/alx5a5Bx8xOO/wBKx2hdW3mFzuOFAX5j2zip50r6i5Jdj//Q /PW4g8iESSuULOFRRwW74qwUntxbtYsbW4ldSLlRunUAfMF54yM/hX+4DqUz/BGNOdtijmLzp5Wu ITdSOYZZpuXJ5+Zu578//Wqa1EgJXzWdkXyy3Oxgwx09xUucE9xcstrDbbT7lNShZowlisoW6eRt rShsnCDr2OT0Ga0r6HU3iS0ghBt7b/VRxxYVFzycgfrUurBaF+yn2GaXoam7Z5UkZZU/eJnEYYfx H9B1rSbS7y5mBjt5vIRzEoij81SRjkkfWs5VIboapSuf/9H4MjtJ1laG4heAOhmWVouqrkHb9M1m SWWoyIsaK3liTzYXkG1HzjuO3Ff7bKpGPU/wb9hOXQtXdjPNciWVYkkjiERWAKqgYHYfSqtpbWbf aYVvIl2/6wvJlkdj8qgep7UfWIaxNI4adrEE+n3FrKyywzfumVGLRMFYkA4Hrwc8VXvNL1C4JSx+ RBGs7l2AIUHng/1qPbU+5vHCTWxaXT75LNGuGEKqGkgFwRAJBgbihOM5AHTNQR6TdXe1oh5Sldvm vJiNuM8DPP1A/Gh1qS6h9Tm5H//S+AbHw9fi9VIAk+U8wR4LO2OvA7VnmxSRbi5iDW88MjG/iuIj H5IB2gEnvx0Nf7Z/WKS2Z/hR9SmuhnQLbyTzquoRQsq7Ghkl8rnk855549q09O0+S4tobv7REIWk aG4QqQ6Nxg/Trmn9cprqX9Tm1oi66WqLK13IGeaDMDG3e3toUjKqcvgAN068nnA71BJBHHa2cct0 Us5F+0R5Bf7YV+6wGexGfwpLG0zB4Kr0RSNqJHsBZancW99cXhVfMsLg2PlhBuDsE6jJyoByOmeh j/s29SS0W4024+337kWq48oOAT8wDYIB60PHUY7tGtPBVGtIn//T/PkaUzSskgZXhfY8OD5nB5wP 61bl0N/MWSPTNVFm832WBfs7zmVmHZtuDj1xxX+17zXB0379RL52P8MIZZip/DBv5f8AAKCeGdWt 7eGT+ztSvLWKbypJo7UokZzjDLnPH0xRqdldWgntpftscdkFuE3Wc32UbvmwjFQC3I+7nk9awlnm Xt29tG/+JX/M2WSZgtXRlb/C/wDIj/4R/wAQzW8k50fWLqB18+N47VhJIpAPyKcMSfpzXX/8Ifq+ o2unyDw5d6PblAjT3dlJBeng43xn17nPvWMuIcqjo8RD/wACj/mdVPh7MpaxoTf/AG7IpQeB/EKa hfWMOgalfR2sAuZL6CDZboMZxlsZPbaMk9s1kax4Lv1NnPb2mrSxTuLO8gWwdpbaQ8qWQfMBjrn1 71l/rPk7fKsRC/8AiX+f9fNGz4ZzW13h5/8AgMunyP/U+CdP+GGrIZLiHRtcupLI4upYbGVIHLH5 RggHHTn3rQi+FfimaeaKPQtWSaVTK0MmmSpbQDHQuAcE/wBe1f7IT4xyKn8WJgreZ/iZHhPOdlhp fczLg8DeNzp86Q+APFEtxbXZhLW+lyMroMjKcYI469a1IvhZ41aa2eXwb4mdZ4W2RrphOHC52EE5 3DvgGsHxzkENHi4feXDhDPJrTCz+6wy2+FPi14rv7Z4J8S2NwJljtkvrFraa9LZ+WIEHdj0AOMDp Vz/hT3xEt7eFG8C+KIZ7tilpDLYAwHaMlnfdwPQAE1zz4/4bi9cVH8f8jojwPn8v+YWX4f5kKfBD 4ktbNGnhvxE8zL5ixPpbRxK46gMTz+Wa6a3/AGevilcvamDwN4rnsbqNYrmQadvkjfBziEHdj68V hLxF4Yjvi4/j/kdVPgDiOekMJL8P8z//1fk63/Zh+LF7LDG/gzXra0jV0uBdaVJbMAvCsOoFNf8A ZZ+Lu9Dp2jG4SMERwRWtxPeySKOUcCPYozxndn2r/W2p4ocM03ZVr+lv1aP8caXhnxJNXlh7ev8A wEzXX9k/4z3Fpsufht4ouLq6g3o2nW5lthImTtUMofPHNLo/7Jfx41HzPL+GOuWNrDFkzasy2qK+ cKFVBIzdDkHb9a5anirwxGLbr7eX/BOun4W8TXUfq+/r/kdXpf7KH7QMAm/tH4c6gyK3lXRh3SfK wGxgApOMgdefapLX9jH9oK7sZ57X4T67czxgmW7Qn7NGm/gEbBtOB+tck/Fzhdf8vH9y/wAzrp+E 3FEmlGkvx/8AkRZf2Df2mJrlUl+F2qWUEsQu7XUYUju7RolO3ayg7wcjG7bjIPNdZbfsBftA3kdp p9n4D14XMzCSbUGs3ktpOfmWFAuePfJrkqeMfDEUuWbffZfruehR8G+KKsmpQS7bv9NvxP/W8/P/ AATw/abec2uofDHUIZrdja2GrWWmNC1zuJ2yOrt8xGR2U8VqaR/wTu/afki+0av4E1K5ayElnHpr 2Sx3UzKfkmaRdwww/hHI71/qBU8bOHor3Xf5n+VdPwP4lnK0o2/7dJx/wTa/abuNQgs4fBklit1C Z92o2U/lrkH92dq5XGD8xyK6Mf8ABLz9ozZpNqng25S7t1dp7l7aUWUzSZAIAQOQO2c/WuGfjhkM bcq/8mX+Xp3O6j4EcRO/P8vdfl5+pq6d/wAEsP2j55IhH4WtppPNZJXuLW4hjXjlkYxMR9OfpWh/ w6d/aT1BTJB4XhS4juMx+crWlgwQgAKPKBfI6k7fpXDW8eMmivcjb1af5WO+l4A57L43f0i1/mdE n/BKT9pWO6ja58NxJKs0aXNwIYmsrRAMkou3v0BGcdzWxJ/wSC/aEvXupmkt7iOV2S1+xxwxpArk cv8AucsRgDqBnPPJrya/j9gI/Aou/rp+J6FH6PWay+NST9Fr+B//1/YW/wCCLP7Rcvkf6ZosnlEr IbnT3mW3VxxIzKUHHpyOOlacH/BFL9oIcHU/Dt/LcR4uGtdkKRqnZA2CrN6jn3r+/av0g8IlZU1f 5/5n+dEPo5ZpKVm5W+X+R1h/4Ix/Ga4jmhhFpayXCJCitcsfswUguSc9/cmtbTf+CH/xehklvLnx FYCUPs0+Ozvc+Sw5DzROdrDnHH6c1wVPpDqKajThf/t7/wCSPRh9GnETaUnNd/h/+ROi/wCHKfxV tnkSXxTpsUkm2Se7WxswoZuCA+0kAdf4vrVhv+CGfipbd7WPxoZ7lWCWcqahDCi7+W3bYQWXk4Uk KMCvNrfSFxMn7kYr0Tf5tnpUvoz8u/O/W36IVv8Agg14k/dwXnjC2dYI0ht1XWxA0QJ+cJsjG4n1 bjjvW4//AAQX8mCCCTx9qYlhbfNFJqymO4QnhV+XAI9eK46n0gsf9i3/AICjqX0Zo6uV182f/9D9 L1/4IgPcyWD3PiyKOO0eKG3ihu43EapjdLIFjBdvUkk1s6h/wQ18NSPcrbeMby8inud5iExtcMcb nO1AQPYNj6V/YU/H/N01yPv9lf1/kfxLT+jVhJRfOtdOr6XX+XrvuWpv+CIHgmSG7iv/ABdPY3Et stnGtizICnQ5YD88nnNa+n/8EPfhhpsD/YfEsbXVtYiKCWMzwXEmcZBLuRgcnOOprz6vjzns4uEW 7N3ulZ/el+F7HpUPo45fTmqk0m1prt+L382rnXaV/wAETfgeJkvfFGu3esk26xw29rdvGscoBUNI ARvIyRzjqa6bTv8Agjr+zvZO7MogjSJo5VvX3JK2TtIDMR0/GvHr+NXFNR/uKk0vVn0OD8BuHaCT xFCEpeaVi0P+COH7OAmXzNRV7MkNdQJO9s8a4yQu2QBvYsPwp4/4JAfsqxx2qTa9qEFpaTPIlut8 jz3Ck7gh8x2JA7H8uK4Kvi3xZW1cpN+dzuo+CHDtJ+6oRXZJL+v67n//0f3eh/4JR/slWse9NTWN ZJBPFNPfwSyKBwEMZbaD7Vft/wDgl7+xvp806rqcfllTOkBuLJI7OQ/xbCTke3H1r+gJeJPF1Re7 zfifzovCLhuCtNw+5HRW/wDwTb/Yz0oi6mt7PULa6t/KZrmeyjs0deSVA4Xucd++auL+wJ+wvp2n h5LTSJYI5vndtUsvKBHTcgHRfTpXPLjfjKq7xcl83/VzqoeF/CWHXvKD+7/I1bT9iz9he3nt2mtf CV1f27hlgubm0kEyHBC7T0HTpge1LL+yf+wrpd1JK9r4baW2IhuYxfRC2AY5EfHC+nFQuJONaktJ S/E2Xh9wXTd3yb9Ceb4J/sRafczpPF4O0+M7XWG71ONzdKowFVmbkdeDxVhfA/7EemlVc+AZLV1A itrW5tY2HHR2THT61k8VxpiHdc33M7IZDwZh3yOUE10P/9L+kSO6/YJhljVrj4fWs6/KIo9QhM67 cr2JOT3HWqsviL9gyyjMqD4e20djIWuBcXDbwpOGdhu5HPWv276jxrW+Jy/E/FvqXBNL94+Ufc/F v9g6yd44NP8Ah3NJbOg8v+zoZWYMOH3luQev41Sk/aJ/YW0xXEsfgRZ42LNbt4ejlIA6kbuOB6Vf 9gcZ1NJSn97CNXgim7KMPwIrn9sr/gn9pQ3abL4Fa7mG+URaBBbrcsg4DYzu9Oa5HUP29/8Agn9Z TwHUbTwxLfXOxDBYaHG8DMfu5A4bHHY9q7aXBfGtd2bn+JyYjPuAcHHWEGvLlGah/wAFCf2INGtV u/7R0Y2dz8j2NvpscJgOeFIwWGPT+VZF/wD8FRf2Q7SKxltdKs76GzUsfItYPMtVPy5IC5wOSSfU 10UfDniyvf2jla/mD414IwyUYRj6afcf/9P907r/AIK0fstRSxw6T9m+0QkKbdtOSNZAwPEcqrgE dxXKXf8AwWi/Z0sTLZP4Vurq7tpBGsSXUUqzg9ZEAQnAAP09q/pSl4ScR1vd1PwefinwfQTcuVJe aMPU/wDgtN8EbeSM23g65jsYnEyJJqLQM46ZVAgHWs24/wCC2XgIwo8ngq60axvVdNOfU5Hke7dQ WCxRpudvlGeBkjoK9Ol4J59JL2ilftZ6u3/AMF40cFwi1GpG631TSV0tfv8A0OB1D/gtzoFvG/2L wO97a7fOumAe2SNGyA6hiJB0P3lzXN3P/BdLR/sxiPgays7gERobm/mee7XoCqIrH88fhXoQ8Cc0 la8ZX/r5HlVfHnhqk2oOFl1X9X/Ay7j/AILkaxZOvmfDzRLZAvmR3H9pMFeLu+ckj6HP4Vwk3/Bd rxFeS3ksXw2026S2YfYrxfED2NsqMSBM6vGQQO/I616dHwBx0n723qvyueXiPpD5FCPLTjeXpL87 P/gH/9T6Z1r/AILqfEyC7mj0/wAIWV5cF1jiCu32GAdd0bLGwYnp+dYd7/wW2+Ns1xH53h/Q9Hll h86z+2yeYJ2xkAKBwCOmee+K/uDD+AMEr1bff/kz+O8X9InCc6jhk7en6NHK6/8A8Fq/jzNDDG+h +H7iKPM89xFcjyhgHEbHaMnOOOecZNcSv/BZn9qq5s4HjvdNs5JpfJi0+KRLeeCPLYJZQxHA6A16 lPwDy9R9+av8zxMR9ITFVKidGEkuukf8zn9R/wCCvH7XVzqcs0OqacsltCYYIy+4IrLy8mUGeR9T z0rmE/4KuftVuVFr4skttRRn8+5kvN+m3AbnaIAvGD0P04r0qPgZlMIqMmn3dv6/M8+p495pGTnT i/Rtfp/kc5q3/BTD9rKbT2gt/GbCa2UXJle5eUTuX5UqRgY4wcfj1qhN/wAFAf2sL/zbjVfidceH 7TUrFRb3GCsckoUFig2FvX26HjmvSpeDOQUXff8A7dX+ZwR8dc/lU0SSfVybS8/hv9yfof/V+XdV /bi/aGv7aCY/FzxFeXhjAcWt19ns5CpyDjYAxPPJFc3r/wC2d+0Nqtx5sfj7W4jIYvOtpNSMzSKi 4IeRVXr9OK/0to+FHDlOUZTp3av5f57H+dWM8aOKMVFxjNJaW8vut+nocLrP7VPxokklnk+IHiXT Z7lPJkhtbgTwYzgYYruX68Y9axYf2iPi9b3aTj4i+J74NAVnj1DXLloo5D91lVXXp2Ukge9epR8P OG6OnsE3tr+Z4lbxP4prSTeIsl0V7em97fP0Zg3Pxl+I9/NKut+OPE95cSKwhK6jIYo9/JGGYkD0 warSfFnxi975P/CT+IYLZUQm2+1m4VyuOTKwLDp0z+dejHg7IYKyw0bfP/M4lx3xI3d4qV36f5FT WfGfiUxJPD4l1CQTT/bSVuR50Ui8H5VA698jNcrZeN/E7yXcb6pq88OsEpJcXDgtbc/dUEfdJ9Qc VpT4ayindRoR+6/5jqcYZ9VS5sTL5O35WP/W/JS41nXpby7kvtWvryGRIktrdpzDDEI1xgquAc9S TzWtp/im7vNMl0y/eC0jhuNwSK1SMSqvRy/3s/jX+rbyXAJJKjHTXZLY/wAv4cS5s1eWIm73TvJv R+u3ruVfEHiHT7u3SJbeMPdx+VdLsRfOWPG1jtAwcjr1964ae9T7Xa3VwGY2aBIIgxFsoUYH7sHa eO5Ga2hgqVJctOKXoY1Myr13zVZtvzd2bGnX/wC9knt4IkleU3KSCEHyXxtOByORzWfqOoQTXBn1 KRUubEh7eaOMJtbPBOMDjOeav6tbocbxTbepp3morfaSun3l9LqFu7JIxmk81SyHcMA8Aj2HQ1nT XiSQXDuqyJAqtFbFfnkYEfMvGMjrVqiktiViJueruf/X/F1ZZ/La58+VUlU+XzsYOvKnHsSKz5Ly /wBSeC+vr6a/uIG2vLcSF3Zh1J55r/WuNKKd2f5YzrStbodB/a0L6W8tvMovbYtG8LLgB8ZTA7g9 6IWl1XULLU7u6hg8u3EEkdvEsajgKzMFHOPpR7KCuNVZNbmNf3FxDJcWf2o3tu+6W3nVPL2gk4yB j0qhDe3tqIv43CbRLt/ec8E1HLG9jeNRtanQR6jLBZAPKjH77KAPnJ9ao2t/HbWs32iSR5pozuuY kDODyVUD05xVcsNWiueWx//Q/Fq3SeWNWOCzplC5A5xxk1Wi1HUtNeMxiOfKEXqW5LQucYyO/B6V /rO1HU/y1cp89zo2dprWyM1wyGVN7q/30J6KeayJ7vybh7e6RLi3dTGyxnOAQQGH6GlZWaRbcnoy S3uGsoVLyyPbw25SJOhboFP4elcP8RbtLvRlRJorS4gQskKqA1zj523N/eOMAd81wYz3cNVl/df5 GuXRcsdQj/fX5o/GX4mavHrHjrxXqUL3MYi1aa1txKPLTy8j7qg459a84MjPtDHKquBgV/mnxrXW I4mxtRbe0n+Emj/Rzh6j7LJcPTfSEfyTP//R/hBSM+Z5m0kDjHoK7PR/7Vhxe6QEkNqyOI7l/Ltp GDAlOevHpXLN22OBJtnoOqanHdXxvbKzisITEiyWkOSnmbRvxnnBOcVW/tJ1iWWS3XzVcqYt2VIz wfyrknpZG5ftZ7K+MsUNjcf6MglNyZ/LjuJG5ZAo6hcfqK0Ine4voraK3IBUeYqARsQB0HHtXK3d 3N4rlVjWMMg81ZLaSGSFfvT/ALsSKOmM/wBKtafJawEtPayyyuPkZZdka+nQUhn/0v4zJnNndajc xtIn2zaFjlHAIbcdpA9v0Na+lxfaVvjqNzdSQXUKvZ2tpErR28q8ZJzkbu/XpXz5cZWViPUozBHm 7aXb8qRpyWyTwOKdZKbmRUZNsDQljOBnp/D9aCudW0LNnZ31xMyjY0SY+ybgVlHbawNd3pWm3MUU sGoMHmzlDgKsQ9OPSgzbbeoybTHlkQLsURsD5m7a2a6LTdIX7QkVw8iyyMAJLZ+Y8chgw6VzVGld FS1gf//T/IL/AIJq+DL/AFD9p3wdOIIYrbTpzdS3slwLhpQxRGZvb5TgDJPNf6GPwss1g8HeH0UY BsQ27oJCeWbHbJ5x2zX818ZJPP6Ul0i1+P8AwTHLrOtVtvex63Ash4bCdk55IxUrDLBRz24rw7Hs pe6yeKQxg7zwnGKZuwRJGQcnBB7UE2ZY898Y2hl6HPasw7PP2A843cdK2h8KLg7e6f/U/fJhPGW5 yxOW7AU+O63Bo5RgqM+YDjHtX8iVVqaSXvJEL3QjZfl3Rtw3OCa+F/209Mh1L4a+Irm9tdPntrDS nntxOC01kQGAaMepYoec/wAVbYdpYmnboyKrUabl5n8Nvxo1i3u/EGp2dn9qNqDJPt+zgwStI7EG I9uhO3jGa8Fu7dUt4Ejgm+1PzJv+YJ3B9vSv6Dwb/cRXkeZOTliGzHuHvltvs9w0dzLIpOzeTNaI CQuQOxwcfTtWDcGW3RJbZ/NLKBNGVIUHJyAe/auxv3iPtn//1f4xI7dwDc2iO8uN80MWdsA9cfUj 866BZluNGeS8EMN4JRHbM48qKbGcqT64/rXzcZPZnnlHw/HaPeXlzpoSOGO0V3lmIyk2cOq9iCRk Z5qzb6baRPKIYEhaWQzSlF2mZmPJzVJPnbAfCq6bNn7PGU3ZMpJEnPXI6f8A66Zc3K3N1cmNNtuo +TP3n9f8+1UBgw3c0UroihWL8c7tv/163tZks9Uj064ubeF5dPPmKzMcJJjAbHrg1XM0rID/1v46 bS3a5tBFLIkchfKsMEY7AmuZ1WzmsdTltZJLB0EIaKaK4818nrnHA9OteFB+8eeXEvP7PtooQ4ka 4j3TJETjHRl/Hj862NKktDatLDIEhacxlbg7JZi2QFUHntj8K6obDjozUjmvIJIbaNF2GYFopvlA U8Hnt/8AWp0lrFFNc/aDE4kQABX80R9xtOSBW8H71xHkfiu5sUuxbvGHulTzYZyCItpyCM+3Feez zIs8ZmhRyreYFxuQL64r16LfKRTdrn//1/5nv2MVtdWjmWW+NubaCGbSLU6eTLdqnlsVVh0wvmHL dgK/pD/Yd1Cw0741aBKmn3lg4tGure/tZDFbNmSJYopozyWxnnJPzdOK/vvgWf1rwlal0pyX3XX6 I/j2t/snjpRl3nH8bH9rHgyQ6h4HsPtVq4E+lL5gB3g+YgIf8zur+Xv/AIK5eFbfT/Gmj+IlsVnv YbiPTLZlnENzcASSAsI+/wAokz6hRX83eDc1h/EynS6c7X5o/oT6SGHeI8PatRLWPLL7j8VpL9rh dRaOKe2hhkAtJ2j2m4HGeO3OR3+tZCRz6jbzqUjSMABDGxJuDnJL5PXp7cV/ovGVlc/y4xCtP5mK mirFqCSTrNArr5XmspG4cEgHpVqbTbCHUdPUszXc2+GK180iZsAFXHrkn/x0+oq4y6M52lZvzP/Q /Ns2F5bPcWkcUxnBzJt+fA4PIHpkdfWnWdpqdlo1ybu6W7u7iZpLa2LEGA44Xaei4H86/wBidD/G 5p3uWoGlisvtLraQFgIpY7eXzZFbuxGTj9B7VLIltrMVxAZUg3RKJLjBDKVxjp3OP51pGStYZDNe W9pfQeTbi4jtUSJY5LctFMFVRK2SOecnn17VRvdQt4lu9Y0aOaKxadzbqCGaVgBwFyevA/HvWsUu pE5M39P8VXdnNZX9xpWn6mLoJHdQ3bMrWqDAbAHGfz9u9XNe1zSINUt5IrK61PS2uUksbAHYLSVx gnI5Kj1PPStklsRzO1j/0fz/ANS+xyXN3PYxCxivI1juIEO6dF+XKmTqeR/Sqq2tlDHBGIpPIkQw pMF3kHHf06Dr6V/s2kmmz/GfUfokWnaaLu01B5rq6vZ8WARQqPjOIl9M5yfpx3ra+22Ej32k6ppV /puqAiC0ktrsQRTp1XzV2nJ9CCOo4q4pWucs2+plw2Nzezx211cyTC2BSBYTwqjPDHuRzyfSqL/a dPuNyozTwvhMLnJzwefwraME9TklKSdi9OgWFn1BPL1KF/M3FQBKjKCqkYx3yD6Gq1jqNrL5bmaO JYW84KVUtOVzhVB61XKkxOTejP/S+DdButGuYr+KYz2k8beZHPvHlwLnlnTGSp5GQeMd6rQpHaRa tdX1nLdLbP5sJtzw4b+8v4kn6V/tRY/xMnJ7BPBJrEqS6NaXV1MbJfKtIwZiWA+YjaPu88ccdM1J atqUFpFFlH8l2IiRCphJ6rz/AC9RW6SRndlq1u95l0yaWeMX0a4upI2MkZYZIORkYbjFOLWumxHT 44Y7q3AMl208ZIYqMb8nuefzpnO3dmfKrXWjS6ho9uXtYQsMkYdbfy8ttGFJ6cdQMVkyxSXbeQjv ffufMu2fLJasoxsUE8jG0545/W4x11Fd20P/0/gu11Kz01bG4FtOFWP7PIWt2SN5MkYUj2xycc1Z nvp7mUGQtHGw3iEsQEBwRx9O9f7cH+HDk3uRrqy3N7FpqyswguFeZNu7ZgDnP096S5msobmaeC2i FwJjNFA0e0HPUkHse/0rVQSWpzt3ZYsrqQ2V8IjG9wIgBYswQOo6lRjtzwKwDLcPHDcQJGZFuxFL G2FKrn72O/Q1XKkS1pY2riGafzXgY2oZRFNPASiRhuME9geeD71et0t54LaxWbbb26LEgcjYgHUD 0Gc1rCKerMJc2vc//9T4WuYkhuo2sLcPGQ0xCEO0DIByT6Hk+2KjF/PJC58xZJkOJAzBXU+gB5/w r/ci1j/B8GImjDA4khYAR5x+lNtLDT7pnRp4pruBw7Iw27M8hPyIoA17qBoYbd44bZpEkVZYxIen cKMc/p0qpNeQ28csDsiG1m2kKuVYkA/KfoR+dOKTdmZTTvqYjX1vMJMAKAdxLNnHcEn2rQtruBLZ 7pRbzyYJiuIWLGUjCgED05yT6GqtDZkPbQ//1fgry7rUo8pcRjz1O2YSAiM5wB7VV2MjpbT5u7qw RoBKW3McZGQfrk1/udyRP8FXexLtkeF7LfvvS4lijUAttGT0656flVODWIne2FxCbOYqYUiLlhOy 9T9T6VVrGEk2rDpLwSXSGbd8pwwAAIH+f51cv4tPnaxaCNo/KJknD4DOexDe3qfWtFGPKZqDb1Iv tO2D9yi5k4W4I3Yx2H5ir1vJA0ZeZVI8pxhxgbgrAfrjFaDcOx//1vgNViksw1g8kVxArNKZyRHM 24kFRjI4x+VKltm3MvnFpLqUSXC787hgDKfl+tf7sH+BLi07GRfXTG8eK1tp44UIjiZ2BMgA5Yjt k1e09RPcQbII5AcwyqfkaTk8Z/z0FBUYPqLNaWgv7xLK0uGlnb7OLcTmRbeRBjPTkZz+nPeqQsLi L7K9z8srxkP824Kw6qefpQaGhFBc3MckkAgjuLdR5cjMFOFGc845GOnWoLiWzuYIGnAuZAN7XLvu DN2dR0+hoA//1/zwsrNXnklX96E+fbNzvAI6g5HpxWhGltM5EYjt0EuwoBsUn+6K/wB2D/A6zuyF xG817Gkb2FomY1KNmVmxgMpPUe/sabpNgsxEVzqW0W6486cbjKMkAcH3FHqTKLexKZoYZZiRMjx/ JFNGQVyD97HpUj3kMFuJ0uTNczuY1gVNvAGSWOeMnAxim+XoRySIptOuljttScxjzR5kYWQP0JBD L9QRyKqSSzXd4SYlDmPdthi2JhQBnA4FF0HLLsf/0PzyhYlwztsWM9+tNVLEXd8MFo2nDQPIRsdc DqD34H5V/u9GUT/AnkkW45YHuFnltWuoYoWgiRH8llJ64bHTO049qpLvs2WZMxvu8wLv8xkOc9c+ 1O6ewuVvSxD9qnldpH3Hcd2fWn/bEVofPjaSBplzHHJsafBHyhux6jvVJ8uxn7NLQ0tYuNNdLeCy tr2CV182ZrmXzCg7ICAAeuc1mkQQ2c0kW55o5FaQKMkL/F/MVopq2pShY//R/PTzIJCfL3TRbQQ2 3awyB1HseKrNArsHZjxkKBxx/n1r/eZzSP8AAdK2iERkaMRfZrh5IJyPtIAVCrAYGO+Dn8/atJpF hRBGiheM7hnt2pc6K5JDLRbiWZmt4ReTorSpalgBLtGcdfbpWNONWZbea9sDaxXmZHEQKwocnKD3 GQCP/rVnKS3ZSpsui9byWg8wfZ4ZgqRFDhuCNx+nA/GtO/ijtba3BjEiXSBkZCJEwRzn0x0IPcVD kkrmsYO1kf/S/PW3t7OceStqY5TH5YmV8KxzxwfbjrQb2506KexWKBLcALLI3Eo2np+lf7tSlc/w UULatm8uq2YgtYZpne3dBi6sVLFCwBwehGOhPT371k3Op3hn2ZVrZBtt2LEMVyc7v14oi+VmzTUR kUkLyzeaTL1KTocICM8c9vyqWMwSwi3l3pM0+55o8FtnoAe9Vz6EFSa1hmiXzbm4X7O+23UOUMoB yc4OB64/2qrXTxLbgu7ovmAOyru2gHnNEH0MasFzan//0/z+ktdOl2rZXEps5EGZp0CszY5GASME 8fjTYRDZsVZS0R+8FO3dxxX+8C02P8CpRsiGGOKNTJHcCVJmJVEOViA4x+YPFOjnnnZYpIlSMErG 4x84Hf8A/XWkZ3dmYuKs2MM0McrJubbCvQctkDj8yKgjuZL52h8x7cNgLNMCsYyOv4Yqk7oORGkI 1Vnt1nSSWJCDNGxVJeOoyM84NQzNetNCrFppigEu48RADAGT14AxQ20Pkif/1Pz3dDGZUkQxunLB hzTLW98sOrcIU3gSZxL6KPSv94+dn+AnIhTbrNbwXWGQ+Ydm7OMnr+VTXKmFoPLIkdgCwDfd+o/D pS55ByIjlvbma4ijFuMriPZHF98f3ietWZLW9kglniQBYyFYu20DP9cUrvuJw7FazjtJLqBrqJYZ xEwWYIXJAyQD9TtH496sWwizJGlq1vKZGKlTmNlz94nHU+lPnkZ2tof/1fz4m+2WsLwrCo3Fv3nl BnfeMEA9ce3vTNN0/wA1XSeJWkQ+ZG5bbtxyxxX+862P8AYJN2ZqWQM8k224heFEwPMkVFG3I2qT 1PtWaZmTfDGgWHfkbapX2uXKKtoSQyJBNHNNC00AIaVI3ETSAdQGwQPrg1m6jeuYPtf2dpBGcNHC MvApPU5xntnFWk7asysacJNpCI7lNrPGJYORhlIzioFEd2f31uoKj7vUZqHfqB//1vz3jYl2K/dU HKYznH/6jQjvEpZUUM+VGwDgHgn8ia/3pu1sf4AWfQh+3iDZZz7vLZ/lnkOcljwPWpUcXC+S5WOG EGQleHk6ZA9+OBQ79R8r6FZIla2S4iB8lnZIySWZivXOee4qa0jVC0hvrdJVUrLZMC06nIx244z1 9O1IfIyWW5WNWkeFo4wwAnIwkhI6D/H2omkjlEM7O3DDhTtJ6gCg0tpY/9f897e6VHkO3c2NvPUf hSTGNk+0lkCs/lHbwUPA5/Hiv96D/AFwaLSLc2SuVfLuQ8ERO3jbxn8f5025cvbPDlku4xuZFYgu eOB6dD1qZRTJKWmKYw6yKxaXLkO2dnA7/gKuTRFEAA+Z+SRzkVk007AUWnvVdYo4I5UQF5C0ghdV HJ+p9qtQ3C20F6+HRbqAkADGzpn3HGfehqyTFbW5/9D8+bK0H2WIxyhRJGHwGLY+p/z1qZNkGd2T Jgru7Yr/AHgP8AVFsjcPF5bKyhpX/cs3CZz0/lTfsl+8iRXcYEpzJMlrMHUBSepHQkDoR+FBXs2L dGGGQzLBLBAU4ikmE0gwMEkgDrjPSqjq1xZJ9nC28bTiTf5eDNzz+fP5mtYyVrAqbvqTG1DpsA3M F3Lt+9xz/SltoLwqC0YMaMyhmfGwD/Hj8+9U2luW12R//9H892tY1ZXilEryYfI5ToOM/wCRVuOc wh2BO5o/LwOM561/vDdn+A5QtYEurhoQqGdmCoSwRkJPHOeM+9WLhJYftNjcKXuLaXywNw2hl/MG qTtqNK9yIySxAQyoYnKgEOuGAOP/AK1XGt47hIssFA4J9alu7uIcIwUWH95Iy5WN34iUA9h1HekT 5N8QjAuEHIZePY5pEqNnc//S+Ahc30kc/lwJNLaR71UNjC5xgg+pNUfPknD3JtTHPGu3aECErgZw K/3iUmlY/wABJQvqi2i3MsUb/ZnZTGWY90x6j/PSqUMM0krtyWQ9O/8An/Gk3czaa0ZNIlzJdrCs Zhk3BJTIpRUHrn8qpvG3mPDFGZvLYiSVeUz/ADpCCKAIJYpWEDMNyuRlVIHUj/PapVg8gxuzhmHB ZRtDe+Kzn2HZvY//0/z6muioj3DABznpU7uLp4zHCqLtyWzl3PHOOmK/3dg1bU/wA5X2IwjW4JZQ yk/O/QJjPNWbq1miht5DHEPtY8yMo4Z3HBBIHtjr2puSSuCi9rGMftsU0b+V5ymYbkZSUwOuTWg7 27yO8kE0TxAEeQ+2FmYkKCv6VLqR6Fezn2HSefcMvmDzJAvlorcbB2GarB720uhBPZIUkXZEzKHY k55IoVWPUThNbo//1Pz0mtbiAl1gkkkXJSJOGc46VeWUfZbaa3TfPJgS4wyxt0K574xX+7jqQ2uf 4A8kuw6KJXWQopZ1HzKD90+9ZrpLgNPEYcjDKT0yfXNY80e4ckuxcWK1dFVT+9jGX/2frTLfTYp7 mWKLYjxx+ayswBbJHI+uc0lVgmUqU30EurJoFIeFdpGQWI2k9sGoWtFh+xm6DbrhxGY4gXILdOa0 +sUtrlewqLof/9X4An0rUbVU83TJIoEkJ+0TRBC+4DGM8kcD9aemj3EMyFQm2eMzNEBtMYGMlvTr X+7H1mn3P8Blh5vcy5GtWunSK6tlZW2YMigsfbnn8Kc4ij897y4XYqARLE4baemXx0/+sKiWKprq arDNrY19JsTqCNBmSe2BKRtFbPIHY/wF1BGfrV5LHUEuGGPKjsGEt3HIuJI0HUMp5HbB96iWLovq T9UqGcstnZ3vmXqfZkuJPONvLGzMFfo2BnjHSugeyt1829SKO6Szj+1+S1u/KH7pxj3HeoeKopbj jhKjZ//W/PW7S2n1DZcG4so3w6L5MhjIfoUOMkfSta4t7VtLijsZWzbbE3TxSPJMSwDZAX68nHTr 2r/ct42kt2f4GrA1eiZLJo813AWtrW4hjgIUzmyl8qQjGdrFcHv0NZkemzJIZprDUkEyOn2mXTbh 4AsJJOwqpz9Fz1rCeaYSndzqJerSNFlmLqfBBv5M04tDvr+CG8t9O1WQSM0cQt9OmS7iKhcPt2cA 54PqKmXwzrRll8zT9ThWKTyLg3FpIsyyHBxgjGcHn696wef5XHSVeF/8Uf8AM3jkeZS1jQk1/hf+ RNJo88NugFjqsl09ysMcQ06RVKjO85I5PTgds1oS+C9YuLbz/wCzNVWJM/8ALhNEcdm5UDB/P2rO XEeUxV5YmH/gUf8AM0/sDNZaRw8//AX/AJH/1/jibwN4sgt9PMXh+/uUnhLulpbGeSFR3kIGAfYm qGn+DvGD30F43gnxZeJEzR2a2+jyg7SMHJIwM88D2r/bL/WvI+uKp/8AgcV+p/hCuG87+H6rP/wC T/Q05/hn41kEUuleDvFCJe3BDR3OlTiaAkZO4bfuqc85xgVp2Pwq8bL5Mp8La7NGAVaZbB4oJGHX axH9KwfG/D1Na4uP33/I7IcG59U2ws/usX9Y+EPi910yaLwZ4mNxOh3R/wBjSiWAZADN8oyCScH2 qhN8EPiQI/tFt4M1ma3RsvNcWD2rwuTtweD69siueXHvDi1eKj+P+RvHgXiNu31SX3f8EIPgd8V5 3vPs/gLxBdpaRKZTa2rzvuJwMIBnb1ye1bdv+z/8YPLM0nw08VRwLbb4WOmybp5MqBEnGOhJySOl cdTxD4Xi7Sxcfx/yOun4d8U1NYYKX4f5n//Q+frf9mL40Ty2/wBo+HniCBpozIizWTPJFldw3bM9 Rjt3rZi/ZM+L89p9pn8Ja5YlIi4ik0y4l3/NgbQI85784GK/2HreJ3C1H4cSpen/AAbH+JdLwv4q q6PDOPr/APa3NHT/ANlH4vOgE/hbX71JFYQILGaxuINo6PviK4b+HbWMn7Hnx1lvnii+GfiBNP2/ uri4d5JDnqSCigjOeeorhn4r8MJuLqv8P8zrXhHxVZP2P5/qv69NTYX9jj9o3zSqfDi9mtFZYURZ HkuGB6MAE6H0rQX9h/8Aaev9QtrK1+DuqXil9ylNsC26rxuO7AP0HPNc0/FzhaK1qv7l/wDJHXDw e4rbtGgm/n/kdAv7Bf7SjxGKb4bahb3jZWzieNtkTesjrwR14GaJ/wBhL9qdLmC0T4Z3tzGzojXd paybBkHeMuQeO3ynr3rl/wCIxcJp29o/uX/yR0/8QW4ws37Jemv/AMif/9GnqH/BPL9qC7uobSH4 aanBAqj/AExgVePcB8zy7VyM84xgDvU8H/BNf9p4SNDc+FdwghOXi+1SjeehJWExsPT5h061/qvV 8bOGIW9m2/uVvxZ/jxR8DeLZu84Jff8A5HS6Z/wTU/aaea2s7j4aXd3YyfNJqU1hMkgbHBVdmcdO /c1auP8AgmF+09qFxiDwPNpc0bbrSSOykeKUoSMFVyTkevPSvPqeOnD0W7J/+BI9Cj4C8Uz+yvuY J/wS2/acmRbefRtYM9xK1xdSRaO1vDbrGANiFgSfqTnk8cmt23/4JY/tNETWyeC/KMZS4huJdPuZ JblDjJICBfx61yT8eMh/l/8AJl/kd9P6P3FH9Rf+Z09l/wAEr/2kESW5g8M2puU+UTTaFJcLAp4I Q7PlJPX+dD/8Ei/2pg1xNbaUZYJZFJhexMDoG5LAgdsngDisJePeRr7H/ky/+ROuP0eeJn1/8lf+ Z//S+hZP+CQP7RJa0WHSlnvZGDSCRHTykPJ82PIB9BjB6cdaswf8EhP2rrrdBJYaLDY52WK21ibe 5k5xmRGB4wCMZ9OeK/0mqfSBytX5YL77/wCR/lnR+jln8t7/AHf8P5FWH/gjn+0vZPbmWPTruG0u ips57EWyKvYCQSY46fdrtrD/AII1fG+4imu5v3FxDHuFvE8ctszHjbt2sMDPcZ4rir/SHwMUvYwX ndt6/K1v61Z6eH+jXnMm1XcrdLJJ+mt7+v4Fu2/4IrfGe4hRNWnaMsCVktLxbbzW52qOQF6jg+nF XNG/4Ik/GjTJYI5dVe4SecybDKjiJAMhZWZmU89eORXm1PpGUlooR/8AJv8AM9GH0ZsbJq7qfh/k dXB/wRR+LlyJZjrFhYXLtseG3WG1twi9gijGWwMtTB/wQ/8Ait9pmu4/Eulx3ACbAL5UjjBPz7VO Rk9OnGK4ZfSLaSjGMfx/zO5fRhxU25Ln16aK34I//9P9BJf+CGnxOkWKJPF+hPvnN67XEyXgVh0A UICOOOuKs6f/AMENvicpf+0/F2hOI7jzrBYz9lkiAHK8Ek5/Cv7tn9Iqtqlb7kf53w+i9iOql95o Rf8ABDfxXd3sRn8ZQaUZ5HNxNJeII3TtlSjEYPcYNb0f/BDPXbVYo28e6DOw/dtOsrsxX+FuV2g/ QVzT+kRjG/dt8kjp/wCJXZfav97ILv8A4IaX9xMq3XjZDDAflmN8ojdvUKqfoa6u2/4IZxXFn9n/ AOFjX3KiFp7a9t0dFzuxnyNwAI6A/jXNU+kNmL+G3/gKOmn9F+F/fT+9jIv+CFsMltb2N344g1CC 2ldluJ5TDOD1G5wpY5x0zW1p/wDwRB02KMed40ieS3kZzbWV0Yw4YYC7ygPHua5p/SFzXVJ/+Sr/ ACOqH0XsOtWv/Jmf/9T9iIv+CHHhWeC4W88b6ihSErZ2zXUk0EBbqNy9vbFEf/BDLwIUAvPGGpPF DFxHHqEs4Z2xkBWztFf2RL6QWdS2k/uX6I/hyl9GTApWcfxf6mmf+CInwztkEdpqCK0oCvPK7XF0 CB94E9D6gVbs/wDgiN8KdNht2u9ctrpFuPNaG8tF3jIxkSD5weuOT9a45+POeSWk5fl+R30vo3Zb Bq8I6fM6af8A4I0/C8xP/Y2pRSl3Uta3o8yDAGC8b/eDdfWs+f8A4IpfCACaS68RSWy3KrBd2628 k8ckQ6/PuyPpXJLxy4ieinO/qz0I/R5yb/n3BJeSN+1/4I3/AAHNgLO31tryKJDDBE1uT5Y6YAJO BXSxf8Ecv2ekmt7m5vpJXiWOAByJFh2jqFyFXrwAPxrmn41cUy2nP73/AJnoUvo+8PR0dOH3I//V /ftv+CPH7O5ub1n1RgNQKhpIZUjYmM9B8+VOOuOtdBb/APBHz9mJobpUlkjZihlijlVfM8vBUnDD Jzzmv6dn4w8VzWkp/ez+WoeAfDkFeSh9yEP/AASS/ZgRJzPLFLqV8VErTiFmaMZ3bldmO48fNnPH vT4P+CT37K8NxeA20V0BEhhJjtEMGOpJxk/WuOXipxVU0vL8Tup+BnDUdXyfcjoB/wAEsv2ULW1k tZnZ0ukV2ge5tptjf8DJOD6DFQx/8Exv2RrGe2Y21lGIpVeCL/QYTlRyemc1hLxL4ufWS+81Xgjw mn73Jp5L/I6U/wDBO39kgw2Nv5NhabL2RiwurJZCZAOVbHbGeh6mq7f8E2/2ObHUo7u7sNG1C8ig LJcXF7aXRVV5BUHgH3ArD/X/AIua9zm/E64+DvB0dJcn4H//1v6S2/YG/Yxe8fVJtO0CJbuARWot /svmSbDh9xwSc4xj24rrI/2J/wBjZtPggi0vQGtSu+3iF9awHcDgsARkHtX7/LjLjGqrPn/E/A6X hVwVRd04J/IpQfsefsZ2MjwxaP4fRxJiaEahazxHd3JrYj/ZZ/Y2jtRBdWPhJIxO0KXFzNbDzQOS iuRyB7GspcS8ZVNlL8Tqj4d8FUlpKP4DLr9mv9imIW4kk8MxR2yG4VPtlu4j9CO4xS/8KH/Yvnij hjt/DN4k37tHuJ0JBHJJ7YrP+2uNJ/Zl+JUeCOCKa1lFl2L4PfsSaf5wlh8DRyGH7OiyXixuijqR jGPzFZS/DL9h2O4e6ttC+HlzOGzO80y+cwUY3rg4x781Lx3Gk9UpfiUuFeBYOz5fwP/X/qGfwj+w tFBbxyWfgm1jcnmWVXTIOeXUkjt3q28X7E6tdWwf4e28FyqGQKVFvN5Q4AfPyk/rmv2+UONaj+1+ J+K/2FwHTejiU11n9hp3giMHw3inDGFbWCNRt2/xOejZHfmqsniD9iKzeIeV4Gt13vCcohExORgg nIyOnSl9R42lq+b8Rxy7w/p63jp6GSPij+wrHD9gji8BSywOUS1h0xJpo+eSxzkdPpSxfF/9h+do rO2g8HXrwSEx+VpsTsD0K8/yNWsl4zlu5CivD6CtFRf3Fqb9oD9inTVWGLS/Ce45gkKaRbTPEQMf OvUZ96yoP2pP2KIHtnWTwlpyiTbJP/ZNvFFG4OACQcFiRj14prhrjGesnIpY3gKlpyx/A//Q/pgv v2yv2KlSdrm68JtD5v2e9kfR4HEY6BmPQZOO+fasZf26v2JrVorHStS8HXNtA37hbWxs5YUZjz+6 HIP4V+8Q4O4uqaXlY/GnnvAdHWSjfzsQTft6/sfRpcXCajocSWkv+sS0iAVs4ZSAMj6Vi3n/AAUU /ZH0xY41h8PtFdyMYp2jiikdv7yBlDNjPTtmuiHAPFNR6ykZy4s4Gp/Zj+BVH/BS/wDZF0p443m0 0teW6o3+hxXBds42cA/keaivf+CoX7Kui6fJNLPptjDEGkltrmyME8wHTy7dYyT9a6YeG3FM9+bU wfHnBFLX3FYxU/4Kv/s021ubnSprG9/0MXMaxMjRW0btjY0ZAK5JA578Vgn/AIK1fs+2Mty1xoGr ulnGJWNtb52F/wCFAisRXZHwo4km7Nu/zOOfinwZSScYxa+R/9H93JP+CxX7OF1ZWxa28S2s24gL c2kyRgg4AV2jCnP1rE17/gsZ8BdLY7oYSBGhAuZZfNiVuA0siptAJ4Br+oKfgzxJVlypSd+12fzv W8ZeDMOk5OCfnZFMf8Fi/hU1tfXcei29+ljGrullPJPLsfphgpyPes0/8FqPhXFG0dv4eFsUQYe8 mlYxNjOGG0Y9O1dUPBLiGTa5Jab6PQ5JeN/CMIqXPT121Vnbz6mdB/wWs8ACCO4ttCttQSUtM4tf tDyxCM/MBsVgM9uprnJf+C5fgSZZmtPBdhcKkcjLBe3sou4WTkkoAPy610R8C87l8UJfic1Tx64W p6KcPk0ZK/8ABb/w/NcSBPA1pZbNPE9y0m+BFzkhv3rjccAcLXOT/wDBcOO0SHUrb4Yxy2yMUu5R cLJuQ9GWMNvHrnBArto+AmZylaSfzucVb6QfD9OLlCUdOit0P//S/Shf+C6SXtlc3uneBIYrCJCl xPqDvFGpLYJQFBkDPQ+tc1d/8Ft9VvJr2DT/AANbLZ26LHZT2Jd5buXaPYbRk98iv7Rp/R+x6fv/ AJr/ADP5Cq/SPyO3uv8A8ll/8iRp/wAFsvGCrcwL4Vs47lbRXEUrie8d1GRGq7cc4rjW/wCC5vja GURzeGIImuYPOjjXYtzIPREIyMY+tdkPo/1r++l96OCr9JPAxV4y/wDJX/kYerf8FyvF0SlDZPYw 7FM0mqWc4iAY4x+7iY5B4yM1nyf8FrfirbxSfY9LspIxElzY3BvVj+0lmwVRXTzhtHOJEHB6130v AL+ZL1uv87nmV/pJ0d6cm/Kz/wAiW+/4LHfG6/jjlms4LG6Mn+iRWl55rzDAG1QsWOvdsdOtcBdf 8Fmvjnpd3caPqenapdSyOJmliuUiEDYyFJJyRgjP8q9Sl4BYVXUpR/H/ACPGr/SWrcylGE/Naf5/ 16n/0/XG/wCCxXx0vrW5m0jVZXMV08F/YtqYsZ7AY+VQzQknPqD61y1x/wAFjv2iboM9nfarps72 rW8zX2rJJ8wGA4KqPlGOuATX+hlLwGwEdJuP4n+etT6SeOd3CMvw/wAznZP+Csv7TNz9nstR1aaa 0liJuGi1lwkTgfK6gqcZPPU1h6t/wVR/aOkkiePWblzaSRxqVuDNJMo+8S5Zfl4HYGvUpeBeRprm l/5Kv8+x4lb6RfEEtFD/AMmf5W77akd9/wAFN/2h76K7/s/xRdWd4YRNsku2SJ25DFFUMCF6/ORy RXJL/wAFK/2mLnzIv+Ex1e7R7b7JHvnW3gWbPMykAsR/s/zrupeCGQQjaevnyr/M5a30h+IZv3Y2 X+J/5GTqf7f37Raf2d9k8b6g94GkbUvtMjy+WF2jKtwMkt0PPB7VVj/b0+PNxDC974/1GzubW686 6uoFCzTRk9EYqwGc46Z4rtp+DnD9P7Ovotu2/wCp5/8AxHjiSTeunrrfvt+h/9TwDUP25PjLq7Xz 3XjHVzDZzNcx6fFeC1mdMAK0ki4LE89MVzLftjfHe9+2l/F9/FZStHJp0dhMsVxbqOWEjurBiR34 69a/1MpeFPDtKydNuy8tX3228unc/wAs6/jXxTWk5wmk7u2j26dVr5/gZk/7XPx2lnuEHxC1ltLl YSxQ+Z80bADjgDIOMEjH0qw37SnxJaGRrjx5rbJeKreRFqWyRJcZKo3UrnNd9Pw04bprSj+P/AOK p4v8XVfir/gcJqPxy+IzNbzXPjvxtcs5ZbmKLV9sZLH5SCQSAPy4FVj8dviJdRtbw+KfEtrbWcTe ZZf2rJKmos4wJJpchsqeRggAgcV3x4H4ei1y4aKt6/qzx34j8VSvzYuTv6fhp8vRmDcfEzx1ead5 F/4y8QXUkD/aI1OqyxuWJ+UADqB0yT2rMT4k+NWldn1+7aRZA8bToJ1A6bSW+ZunUnPvXfDhDJI6 LDxt5X/zOKpxxxDN80sTJv5f5H//1fzqn+JeustvOGuxLp863txc2hCi6KnIQg84PPf0qjf/ABC1 jWblrryo7O0uJvPaKJTHcSZA4d9xJ5ycdD3r/YKnwzldN3jRWnlft39Pz7n+PVTi/PK0HCeIlrbr ba60t3v+C7GLJ4z1jYLBtUlls5JcSxXEiguDxw4G75eyg4/nV2HxTc6JbQ3FjNfG8tAxSVp2ucK3 X5WJHfvnpW/9hYBf8uY/+Ar/ACOf/WDNLp+3npt7z/zGxfELWLudbr7VLKwtmt8zafbwQ/OB8wCo CT9ePasGTWriMxNfN9ut4G/0dbhvMmiY/eOT6/l6VrSyrDYZWpQSXkZ183xmLlzYibb8y5LqqXds 813bWy200+622sGZmRQCWXsfpWUuqXkST2lndrbQ3fy3OIlkkkX+6GPKj6VqsJHaxzfXKltz/9b8 sbu/vLgQW1vb209rsEbQR2yi4ZhgAow79vf1qWz1e4s2+ySWkVtAqkbXXZeRNnHNf7K/VYo/xj+u Tv1KlzNcz3k815JFLa/ZlMUFwioIwBkFSepOcj1zVW41aa5NmEkkSK23NZqp2kFhtYgjnkZGPQmm qEVpYl4ituhrSyzySK/2gxyqv2tC5YnZ6elVvtFxe3Y2+YjMdkDTOMnnA5/Cr+rwL9rU7gb2ZPPs b+YM8I8u5VW3g8dOp4NUJjBqFusPlGOMDy4lxgDBAAx6cD8qapQSuNzqs//X/JwM9vHEcj5QBgH0 rJ1K4vFvba5iCShXEm2f5xkdse/8q/2WdOD6H+M0ZVOrNoPbPptzHe2xkWYiWPyz8isDkqwPY/nk Vn+baTNFd24Im2CCaIJsSIp0we/XOe+fxrFRjF2Ormk0LPqVzHOLe1SKO4nj4k8wERrnaSfz6VLY WKra3DRzZuIpMkPzuLZJJOfpx70uVdi1ObdrmLd6pds9zaeXJujC+c0WVVAcDOT9R+NXv7evJbRr WW5mnaGFvs6zEyIhIwdufoOnpWUrbI2Tmf/Q/H7Tria4gg8xzLdRyhEjSPCy9c/qOlOzdadezvd+ XLBcAPborDzIz/Fu/H+df7CyaP8AH/3kZU98t5evERjC/KNuQPxq6626QwRM627yIVvbiUYiT5jt ZfoMenNZtt7lwuUrdLdMqt093cRcea7bvMx3+vSrE92B/rWCTKMFiByvU5qHJLQ7Yp2sSSTWw0y5 vYA8/lKGMkS5xyFIOf0zV+cW8tlbLEXE7QhzcMRtU4Hb/PSsm29zpjB2P//R/Gi7uWIBYmdYwMt0 A29zimtrf2xo0EAG7bEpgQ7cAY55/wA5r/XfRH+UEKehajto7yZo2AREQhpCcbPxrIubR7YBJWeY SEpFJjGeuP6VlK19DojTaVi3pnn2sG0sGnRTGkI4DcjDHjsPSmJPp/2yX+2LUXSuh3QJJ5AwMAn/ AD61OxHs7ysY00kE6+bZQ/Z4AxEYXgbQeD+lSQSTBCZZvvsBGDycDtio50XGiovQ/9L8TbgtI7lg xgVcYHb1xV+yfRrmzWztbae0u7lQlusmMmTIJY59Rnj3r/Wzn02P8rXBaK5jXUMTs0ULbpY22S4O 3kcZPao4JTZiSEQySko0Rm3EJGrDBOOvp+lJzdrGkIxS1IIbxRHF80YggPkF2PBx/hxV6Zc7fs80 JkePdgngD1FZXlfY66ajYliEnlOjQrhSqI2/Pm8Dc3+fSktpRYJ9iNnALGBGdZZHL3BZjk5J7DsM 8UvfK91adT//0/xKma6uUj8hUVVIkjQsVDA+uPbtVxr2ESRQQ6egS1KPcXAmJllJ4fK8AgV/rHJT tqz/AC8XJzE2s6hazwpa2MUUkBk3/bYmPmkkDKY7YOc+/SqFnawhJhPIwaWPbDJ3jPrQoPuNyS0J JEkkEAWVQltCVuVIyJGBGHU/QfrXl/xN1fTFsrG8urUvb6Kkk0s9rFtmmkIOxHP8Snao57E4rz80 9zL68n/LL8jrydc+a4eK/nj+Z+OXja7tNT16+v7ON7SG9uml+yumzyyT3GcjoOvp61hrbLEPNcqI dvJHc1/mJxDXWIzjE4iO0pyf3ts/0gyyl7HA0qT6RS+5WP/U/hX2+RbMGKOXOVKjnb2rpNLTUVs0 Y2lwtso3pIEJTBOM+2cdfpXHU6HMlbRHR28s1usVx5MbhZc7ZV3BsdiPSqsm3zBcXN2LWHzt8yRx htwP8Kg1yVN2bxjZanc6BqVjNOlvaW4jWDlY5U3tKCPvE479aNbs76zt7zUrUhJbeMywhTlzg9AP WuSXNbQuKu7G9HfQ+INL869aSOeyt47mVpjtdyoC/j29elURqlrBtZpUMbERwsSPLY9Ov4VRcodU f//V/jhugk0TxSxxzO4wo7xn1q7bpHY6esVu8r3AlBkcqFTb3wfboBXz5Sg2SnWLO88z7PC01sjk F5ojHKCvBGD9e3tWZaXN5PbTyW+npa2cbB1uJS0RVmP3SCOc8nHWgTVtDft55LUNcOm9nTaMEjym 7N/OtBr+7ELSfup4/s/mlmm27z2XHp9KBGnpzz6vb3LLA0cKQgGbdhQTwyA+3H510ug6ndfbpLGO MOkcKLIzDHJ7hjXFPWbI5vdP/9b4C/4JAeAr/XP2ibbUc3FxY6DYxTPEWxLO7Sedu2H7yAYGR3Ff 3i/DqzuLbRbZZ97Qyn7RbBk2Misq/Ljt06V/M/FlX2mfqn/KvzOfKVJYitJ7No9FKN5yyEsAnyhQ KtooYMyqQw6eleQld2PfezK+WiJEgBLHDc8+lTxqgOAD/KhK7sZp6KJIy9VDYB6j0qg9uUkLqQR1 JrrppWsEtHdH/9f99Z5XgVpHgkMTfKrqu5Sff0qjJNGpmDBhtwSAOTmv5EqrUJv3lclkjRxGI9wd V3gnBRxXyn+054evtZ+Hmv28cBW0FrcXl7Mg3SyLHayqsar3BLcjr09K0oaYiHqYV5fupdz+GL9p bSoNH8Ya/Fo6oqaZrkltdWEMBhuEMa8KqdwQwYn3r571EarZWOk6tqlrawx66ZIrYW86PKNi5O5V +6cdj7/Wv6Ay2aqYWm11SOSmrVXc82j1Ob7beXFlaqZLSJxNDqEQiFygO392SckjOR61SsbtLSKa XUbe8CTwEWW2yaVNzHgkj05r1OX3vIXL79z/0P43dM0zSbey1DULC/vpNSkkDbblB9nJHVU74Gf0 xT72wsdS0h7e+mcSCUXcChthWQddvpXzyikcKi2Ube1t7S5t5LRVt7do8XMZJ/fNtxu/E81rXE2+ ON4c74myiYxux70ylDXUwRqYvpJwBIERihk2ERsy8MB7jHpWzpy2UWnyS3JW2lkuCkKFt5vD14X+ FgOfyp20HKHYgsdLtRqkkDvHC12TLHNNJsVOMk/pgfhUcVnNqN3PpZurCGwifzWuXU/Z708jYXxk EYyQeKRmk3sf/9H+NGxvIjc3FqYnhtrRtm64iMUU+3uhPBAx1/KptWhsj5LLDFuu3yhT5nJX1744 7+lfPrQ88z9K0+4/tFZJZ1nYyg2sPlbQhHIGMnNd4bTTZC4unt7aSDN2IpyIyGXsgP8AEOw6+ldl PqA/7VAlu2xDPJcny5bhV3SxoemFPTGOTXGXt9lvKs0Nz5EpS5WVzbttA6gdz7D863gryHZnk+r6 ut/BLpd5ZxxobkvDfIrC7VcYZB/s98Vgt5MctuqjLhQm5+mBwM+9e1Rj7tzKOkWj/9L+Vf8AY18Q ix16SwtryWC/tpWleCNyLp0cKCsbf882XKn6ke1f0T/sh+IrnSvid4Dh1ZLl7S48QwSz20sTpKqO M2zb/TcwIPTGK/uzwsqfWPDCtQT2jJej3P464ll9T8asJXtvKPzWiP7nfgjqYvPAts0mCot4zL5b mVcbB8in9Pwr+f7/AIK9aVqCvpuvLpMH2f8At6CCOSZcyxxvcNvMR/vYkxx2Br+d/DBKj4p0YSen tLfif034+KU/DjESgr+5+h+Et+NK0cPBfEzJJmS2d3ULIOrLgjJIzjH864CG6062vLSytA1vYyXH 76RQzpErEksep4ya/wBGKaa9D/KjEfHZilLy/KLqcCy6OZWCS2GVkK4GN0hBwRhT+Jx61ka7pX2f VYbwCa6+zRJNG8D5mZQo+TIHHGRitDmk7H//0/zptdTmstMNxbaTcxzqrSTyXTGR2yTtBPQZ4wc9 6q3NxY6jC/iS8Q2upQxKx0y3Rgt0zEBhjPYDJ/8A1Y/2Fh2P8b7l2w/suSGIQwQWscyP5scce3Mh UkYBPJzjAPtXHad/aNtNIClyN0heUOuDkMduVHHT8qsTdkd+txfHS5FWG1vprgh43kjDNH1DRoR0 z0J9qpeHriJHayaxtTcWyF/s9/bfuVJU/LyMcAdvTvWsL2Ic0af9jTi0e61OwivLMsMzWELKIX5w Cfpj/CptOtdOtLC5vFuIgkjiPyZyz3kiZBHlgjAA78g8GuiF2tQvHdo//9T88JWsZL14r9LmKIge TLbnypGjODuIPtnGKdaatYWAurC3s7i7smuDma9kzcMh5+U9AenTiv8AZg/xobVzKt5f36yxRRyL bvuW3lJdV9MnOf1FbiMJWP8AajwW5xvjMLBs7h8oHPXkZ9KuG9jCpa+pp2bxafe2UwnPltC32los SeWzblAPtjGfqakur/T7OW5Fw32q5ZFeFnAKHJ5x2zj24rU5TAuLltQnLm4Bj2LHEu0fulUAbSe+ OeT/AErQtW0KLSb221ezt7oTyFbOdQBdW0m0DdnqV9vWqTdzKTWyR//V+AdOt7WzSJ4oQJo12+ZI d6AA8cdfTjmqf9rahI91JcJDJMWJPkRiFWReFG3p0x0r/ag/xOauU11u0m04/ZreRbuK4I/dM0ax lSNq7Rz1zn8K0davLiOCz2faPKZo5riGJTIElGMNx15yea1htYwNjVlgtbjSXTUmlsp0jSTz4hBN DI4+YBeT1H9Pemif9/G0j77aB8SHaCzrnmrInaxQEWpzW95PaQrDYPII7V5lwZFJG7eo6HGcenFU 7q3FuiQ2sAM0sucIzLK5HQZ9GP48fmbGdmf/1vz2l1S/lMkcjMkaqgfTWxJFZsAAwHHXOeevvVzT JdP1KeePMwZYgp8ptkqEd8HOR16V/tvG1tD/AA8muxp6gkWj2kcakSXMsu9QsYE3YcHr06iobvUr m8tVjFtbNMrAeZ5CRzhR1BfGT+Jq432Rzyj2Kx0po2D3MbPcou4+Sx8yJCMkEepptlOjW8kJtHSY SnyQPndkAJ3MOo6VsCh3M+OSaFrlUkaRZpCTuO5FY8Yx7elTr9qSLyt6vKrLCfLG7c7dMeo+law2 MKis2f/X+FNM0p7O4t72+u59PIV5ZmjmKW90wUgx4OeT09a5q6L6tdzzxwpBJBciZzB+6DBD8hb1 yAPzr/cg/wAJmr7nUWF5axNiTTla5dtz3HmlVVAOVC/gec96zbEIYnmWF0vTdv50YQ4CjaEIboc8 gn2FA7GxbX9vfy2Rme5g+zBomxhY52JwGdSMjHTFXNf1XTb/AEqDTItDsVkW63yajbKxu5s7UG8D 3AOfc0EtKz0Mp4LC0sZbdbKGS9uEHls7GMkgY7euP0qnPFbw28cNoqxH77ps+RG7r+n05oMLLsf/ 0Pz0e5hFvJawRiRlkDPHFwyn73+B/CrUMlxDIbiKAlxD5Tx5J3gjBbr2ya/3IP8AB60bEsU1vb3A vZ4ZPkIBaPCycn1+mauRaloq3z3X2ctbJl4I5lEm98YycfjxVxbOZ8t9TNDf2hfXMxRYkQhvkTy0 Oeyip44zPIIXxGiNl5TgFVH5dq1BJalaCSObUrtJz9l09ZilmxXPmjHBCg9T3qWwZJ2msLhG83cr Rh12rg5Ix27D8qB8qP/R+CZneG4htSq5kYxNIq/KuAMZ7D61LqEqWKRCCPzblFyWHyheeMH8K/3Q P8FHBXM+5kS8a2k+dp7glZGbkggdCe9WNMtXiv4PsSLJ5d0H23HMOc55Geme2elbRvbUaikRalLO NWvTNGsExnbzBCMRFjydhz05p87OEtGMUcoibcGflgMDOfy/Wk7qSuXZpEUM1tHbXq747tL7/lge UhwNvB7d/wA6zxZkRLIkHlAEIB/yzGOgUdsVZKSTuj//0vz1uvNgMaDPn7QzBf4c1VleQnypk2gg EDGCfev91HJ81kf4JwTT1Ipw9xvVmIhChRtJDenJ96ZbQN5qRGUxwjC+YRnyx0z78dvapg/eKktN DRHkpNNbyb7mAvs8+A7Jcf3hnj8DVO3s4o5RIWe5jSXgNhHxnv6f/WrYxsaU13DFfNJHH5mnKAqJ N8ssbd9vbB/pVI391aah/aFtJGA52+QIwI9h6rj3oGlof//T/Om4SO4lubh8RLcS+b5X/LOHkYwP QYpkdpby73uLt+EaKKGPpk4wx9u1f7sH+B9izE01j5BQZtwfKYlck5GBg9KiunRZmRiuI+WOchOO hrdRS2AmZGe2naMIfJgaZsnaAo6n9c1j2TA20Lw7JFcCXEYJVSef0phboaQnuJnaV0LrGBvdwflH Qdasz3p/s/ykhURmRVeTBAGT1/HBqoxuLZH/1PznklWzmCW7w3LBCrjOYvmGAR7jPX1FaAhZLa3n 3QzGc4aNJAZIOTywPbj3r/eJxsf4HWQtzJFZ5VpImfaCrwnKZ9D70xhcy6f5rxhop22gwnMkQH8R PUd6kZnxBhIojZgwP3hx0rZuZxJaWysbgxI7ed5r7gGPcf59KLdCo7lOdkWGOFIY1tEXeHCDzi5x ks/Ug/0qdLmL7NDBHyIAdpzlTnHH+fWixpdJtM//1fz88+KC3tTbRLBLEcuHG4Skk89exxx0rLZo 5WeBoVuJpuZfMJbPuBn6etf7stJbH+C6epZt4J7eCRZb0wWTNt+wxRhmdgOCc9vp7daYlkot2mha a4kSUKyswzhskAdMdKCm76dC1ZwhbqbTp5obHFn9pQTowUt2BwOO/Hf1rRfSlsntJ5LkJEUJa5t2 83yhgbmwDkDnvSIbUdzlJCYblSkz3EN0DPbnadqrnH4Z6itqxRgfNvIC2nyhoZQQAzEjsTwPWmnY Gk0f/9b87ktxHG1taKYYY3xEJPnwM5H8/wBK0LiyuI7Bbny3ulDCMpCBvJJAzz0HPPsK/wB3VNN2 P8EJQ0IZEm0+6nt47ODcsQVI2J8pGcYJJB+8M5x60sFrJJK9p9oh+1xviTy+dg/vY5NWmrmHL0K8 NnfXWpnTmMEsrTrbWgt12GYkhVyfUkjrVrUNMu9MuJLK6+W5gkKyQ+Xh48e/fj8KL2LVNdSjdWxW 7Fzb3P7v7KsRRoyNrnkknPY5GP1qzHJJaiZZJxdvLGAk4UxbDgHge3I5ptt7kNNM/9f88bOS4t5E ef5yoC/vowxf3IIxU90r3czTXDRxKzgL5cQjAHA+6MDself7wH+A5JLIs8VvCybkt33R7TjaQMZ6 1BcuEubG4gMC5uUSeKYkgqoGSRjv2HsaNtwLMt7dQ3r3lkVI3mNo7YiIhc4IBPT8ag1KCe5gSQTu iNJyI5CrBh6469alySE0nuW7RklspoLqJkvoHUW12hCxPHzlSvqPWld7geVHE24KoRZWHAGeRx9T +dO6MuVt2R//0PgJ0u45YGiHnSjO1Wc8epC9z0qE3gMiI6yrMzN5oZME4JGf8+tf7xKokrH+AkIu 7K7QxOQYomiVJM+WnyJkHrirz6dLcRMqM0e8YJXgiqVS+5pZ9iibaRWFuSfLJ2PuyXI6H8a3L2wh cW0dhEdqIIzEqli+B1Pc1XtopcpLpNu5TksLi8URKE2xYLbvlYf7tJFBLauqrGZWGVLfeC8dTU+0 gHsWf//R/PpbPUjLM8tvLC0SFIWH/HvMGJI5BxnHXvzUsNncTQky/urkLgRxgSJn3Nf7ye1gf4Eq nJaJFF7SQsPOt/NMTDawTczt0AUev+NPhtbq+SeWJGt2tsNcqUx9m56MvbrUutBdS1Rm+hNNGfMC r+5i2qHaT5EZiucr9fQVJYaTDdRm5HlwwsziS4GCxZAcZHfJGPxqfrNO9rj9hU6oZNpupmVLWeC5 jiV1laKZMYUjgj8M/nWvDazxwJDbWEV2Q/nOkuM7B1IPtR9ZpdzVYepson//0vgSPSxdRPqdtcR2 0aSeTMlwCgkJ42oD3xnn+dXTYXD2/wBgiSNgziVVKKXLdiD1/DNf7vPFU+5/gi8NN/ZKeo2t4JY7 p5ogQMSKSGb5QM5GeMYqtptub2W6u4pI5Pl3zFmAHHpn6UnjKK6k/VKstLMt2Nt592LaK4Rprs5h hdSp2gcsGxjHB5z1rVfTHktw0NzbtLIfLtlRvPeZg23aFXJ6+tQ8dQ1VwWAqt2syjD4cvb0hQPLl jlMUvnN9nVXHBUlsZ+lRLpOptdjT1jafko6QwtLl1/g3gY/A1yTzTCQfLKolbu0dFPKcVNe7Tbv2 TP/T+HJ9B1i1vPscmk38Sx2n2gTrYSrasvA2K23lh/d68VHLos5keyjS7meGD7dJMdPnwUGMoDsw GGc7Tiv9yXnmWJX9tH/wJf5n+EUcgzN6ewn/AOAv/IrSaPfxiG6uNJ1WaF5F+yQppkwSIdAxJHfr 1zVz/hF/FdwJbqDwpriae0pBuUs2Ebk/3AfmI4rJ8Q5TH4sRD/wKP+ZtHhvNpfDh5v8A7dl/kMtP BuuSSRtLomuWKxxlNkmmTNDeqW+Vwdp5HQYI68g9a6258H6xdp5K6JrEmyERp5entGsTY4UjAIPT t+NYS4pySG+Jh96/zOynwnnclaGGn9zM2f4a+LIW024OieI7EmN1kaLRp7lZEbHzcDnsPlrT0r4a +JTaeddafq8dldSlR9t0W6huHQcHaFjOM44zjr3rmnxpkMVf61F/O50LgnP5Pk+qyXyP/9T5ctPg x4u1B4XsPBviq30y3iNvFfS2MhS4ZQCTtxnDAADjgmmL8Evic9tcXFt4K1Ca5il2w2Moe2nkUrne 25Ao+mc1/tTPxA4ag2nio3+f+R/iLHw94mlq8LL8DUsf2e/irJa3OqT+BdTivBaoWhayuZ4QN2QV kjiYZAznOPxqxN+zv8adY+y3MfgDU4Y1Ahh+y6dcGW5C8DcQuWJ9cdK46niXwvG6+tR006/199vu Oyl4acUSslhZaq/6f1Y15P2V/jdNCHm+G2vFLa4UPIltMZVUA5+ULnafoela9t+yb8Y5rITwfD3x J53mfJFJbGOAgHk5YKTXmz8VuF4/8v8A+vvO2HhVxVN2+rv8f8jUsP2TPjnMdQlT4d61c3UcIaGE 2hngUDg4faNp5z3NIn7E/wC0fd3Go3Fv4F1N4rW3V4kS3BmZn4C7WKn5T1/lXLPxe4Wp71n9y/zO iHg7xZKVvYr8f8j/1ee0/wDYS/aNsBLIvgDU31C+tUgvbA2Us9woIGXB2BVGQOASff1F/wCCf/7U d3MYtN+G1/MNgxcXNvOhYnORsRCRj6V/rnU8auFoXan+X+Z/jrDwS4sdk6f5/wCRp6d/wTx/ahuH ilHhe/tYgczx2+mTNIgU4aNlZeM+uRT7/wD4Jv8A7Tl1fXUFn8PNYgt4pI5WvpknsYVBxnGI3bH1 9a4anjnw1GWj/FG3/ECuKpxu4f8AkrO6X/gmV+05cQRG88MOskeWNzZafdXi3RIG1C7RrkdOQPXi pLT/AIJW/tUTMu3wu1n5cbO6vYTyPdkjPy5VQCPTNcU/H/h6Olv/ACZf5HbT+j7xR1X/AJKzVj/4 JOftOa6r2h8MPbCQ+X9qubJ7SaXj5guMr9DWrL/wSG/adntZGg0sQtZQ4aE6e3nuEwpIyQpP/fOc dDXDW+kHkEXZQv8A9vf/AGp30fo78TTtrb/t1/5n/9b2iz/4I9ftRrBcFotKuo7aIO63sIic7ugR EJOR3+au3s/+COX7TX9nYjs9MWQxYFx5aRKwccYVnyMevNf6b1/pD5RH+HBL5t/lY/yoofRv4inb nb+6353F03/gjB+0lNbvDd6lZ26W8jEP9jtriadmHKk5+6D0471tv/wRX/aEklRbO+02C2gRY1kv Yo2YsF+baF2LjOcADjjmvMq/SPwcZNQhG3z/AMz06X0Z85lHXmv8jrrT/gih8XDm31PXdMET24GY 2W1dHPfzNx5H07Vbi/4IbfGW3GzS/G2lW+GWSWTUbOLUZrhOCEVgRgDnnPevMq/STipWVOFvnf8A P/M9al9GDHSjeUpc3yt+RtS/8EI/ijdvc6lP8QtOjmcRlYbSeKz2/wB7CEP+fbPetWz/AOCGPjAP Le3Xi62lla3FtHHc6rhLdcjc64QHefXNebU+klX2jZfI9Sl9FrESfNPmfzt+h//X/UWL/ghf4llh l2eNtCsWWEC0ubi9a7uo2AIOPk5B77utaOl/8ELdShje3u/G2kyKsQjiFtLHDAy5+cqhhO1j/e4I zwa/vSX0j8e9Itf+Ao/z3j9FiH2k/vZO/wDwQftJbm4e58d6fp6NARbWcN5NhT/fkKKN592zWrZf 8EJfBs88c2qePri5kjs1icRyyCBWTGHVAoySQM7hXLP6RmbW916/4V/kddH6K2Gb9+9u12bkf/BC 3wd5Vy954uj2vFtglgMsUxPYuwAx/wABpY/+CFPwju4zd6h4mulumxCq+fJKpA46ggknH8R71x1f pEZ5NPkf/kqX6HoU/osYBO729X8v+D9x2mm/8EKfgcZYUutT1G5toYjMsU1wzWschAztjAH6k1uJ /wAESPgFaXLFdYidQi/aYSszuSvQFdwBz715VXx74mqfDUlbydj1aX0Zslpq0oq/mj//0P32f/gi 5+zvOsSXF5dSPC4YpmRrdVHQbWc4xV+P/gjR+zmn2yRtSVpTEY1i8uNYIwerFWbrX9dT8ceLJaKr P73+h/G9L6N/DsXf2cPuX63NGx/4I9fsw3FstvexWuoQ2qgx3Umn27yxY4wT3H49q14/+CQH7KGn 2rW9vG0Iun3XIFvaKbjupwegHYc1yVPGni+onD2tRp/3pf5ndT+jnwxTlzSjBNeSLdr/AMEl/wBl 60s2s2vZTYFjPJG/2SJHc8Z4A44HWtFf+CWX7KWlyLFGdPaG6RfN+0LayXM5GM7nzyMdq45+LPFs 00uf73/md9P6P/DEGruP3L/I21/4JqfsoQRXDzJZBZlEDmGaxt1MY6p0/CrN1/wTK/Y+ukhm+zLE bPEtukl3am34XqV/iGB3JrlXiZxa3zRcl951PwJ4WUeWo4/h/kf/0f6c7D/gnp+x3ZtK8NjpP22M KJZJbu1hkYNwBsxnHXpXQ2P7AP7GOnGOQeFfDYd1Ia7e5gW4lIOSc56+wr+k5+IHGNTbmX3n82Uv Bng+mkpcjt5L+v60Gj9i39jWzMhaPSDBcMERJtZt5Ic7s4EdbsX7HP7EiWqtcaL4ZuLa33GOWbWo 0hz/ABAYOB9BWP8ArjxpN+6pI6IeFPBFP45Rf3Elz+z1+xpaw2kT2HhWCK3XbbFdXjj3qBwCe/tW db/s/fsRqygaX4Ffy7gyn7VJFdxhvVuB+dYviDjSevvm/wDxD/gSGknDTzOpX4Y/sbWTpENN8Aos XyrbtcQwhB13KvGM+tUJvCf7FQvDcy2vgXETbUYyLNBGVHACg4/OsnmPG1T4ef53N48IeH9LSfJ+ B//S/rCfQf2KBGbuWy8C4iBJjWBHS4I7LGO9VZJP2NZEtZRp3gQQKuFB02NtoBP3x1zzX7/7Tjmf 834n4TDIPDunvy/gaCan+xHaSLF/Z3w+R4Yi5lbT0iPPOA3fvxms66+IH7EC/Z5DD8OLOMt5QiXS 4VVyvTIzyTg/lT+rcc1NHzfibxyzw5pP7FvkSt8Yf2IrZFka7+HU3lsLb7IdIiklizwBjnj6GmXP xf8A2OHmWY23gCWC2Ihjjg0y1t5Dx/zyLBiPU4xTWUcby19/72dKw/h5DpD7l/kJp37Rf7GVjmG1 HgLTmlkaI28Wk2/2icqehA6/ypt1+1T+xzbQzec3g/yAwKMbG3+zEg4OB0Bp/wCrvGtR6uV/mbfW OAKS5YqFvkf/0/6nm/a8/Y6huFltrjwvcPcYR/J0+FMY6bW59O1Tyftp/sfW0LCS88NcrmSD+zob iaBRnJPy8Cv6E/1O4zna7l+J+QPNeAaS0jD8DlLb9vn9jue9W2s9Q0afajNGsNvaC2RUOCcAkD8c U+//AOCif7HFrPDaXmo6NGyKdpurW2CsT0AbGD2x+FdC4B4xm7Xlf5nNLivgCnC9oW+RTn/4KV/s m6REQuo6Yi5DOtnb2jb1zgDPT8P0rK/4eg/srR3D7r2BfLUv50tgqiAH+8wXA/Orj4b8WTWvN+Jz y444HpvlSj+BVuf+Cq/7L1isUV34kt0QMMLBAcgN0H3cD69BWOv/AAVb/Zl+1tHbXkVwsT4mSJ43 fA/2QMt9BnFbx8LuKJaXl+JH/ESOCafSH4H/1P6OT/wVy/ZsW6aGK4kuLQAkGCzlZlIHKMNuMj0H 5Vgj/gsL+zpPfQWtxYzWVldnyYr51YJGy9MoQvpnFf07Dwk4km9XI/AanizwbT1ioP7h8X/BYj9n AW8xTUJ7j7LIVeS48yx3DkDYjqM/VSR71zV3/wAFpf2fFNzDaW1zcz2w8yGNWJMxPUIwIAHuePeu mHg7xFJ2fMclTxj4NptOLg/Sxlp/wWn+CLrFKmhXNrbzgiDzJpZbm4I/1m0qpXA54zVO4/4Ld/BS ykhjj0jV1vJm2RW1/BLBFOOgEbnA5rqp+CfENT4VJ/JnFV8d+DqH8TkT7Nr8ehXt/wDgtl8PL6S5 RNEt9IitPlkN7Fcz5PqWQMv61Jdf8Fr/AIZxiKI2FqSSBug83zp1OMsqnBwPpXVHwJz/AK05/czl l9IXg3rOmvmj/9X9rpv+C2vw4W68oaIsc0sxS3FyJ7GaRAMg/OOQR396qQf8FwfhubtYH0HyZpgz EuJpY8KTkqyq35jNf2DHwFzp6ypy+5n8tP6RfB0bJVIfejC1L/guT4SnuY4LDwlHcWsyPsuP3hRW UkYcMA3Pasmw/wCC3Ng1wbVPCKWjH5jNfWc1vasg5fDlcAgfXNdkPAHNLe9CX3M5qv0kOGFpCcbd HdCXn/BbqyiQzReDJr5ftGyE/YmtLOVeu9XY9B74rjZf+C5k1hc3DXOhaNp6Bd9rbXE7zPeBj91A qt8w+tddP6PWZS1af3r9WeViPpM8P0/dpyXraX6L8RT/AMFw7iQwJ/wh949zcyh4JbQM6MCMhAhQ Ejiuc1L/AILh64kkb6d4beMTyFZDe6ezG3ZM5AJbByQeAK64/R2xt/eivvX+Z50/pP5Oo+5Jp/4Z f5H/1v0Si/4Lha7d21xqVvpoX7OfKuTa6c4RdvB+bYQACOduTWW//Bb/AMWajYxzwWj2EcNyYknS MXNzK+O8RKnb+Yr+6Y/R3xF/eivvX+Z/EM/pQZc/gm//AAGX+RRH/Ba34hwNqsGLe5aCyW6AaNbm 42lgCSoQ7MZAx156Gsx/+C5PxT1CSyg0vw3Bew7xHLcny9LgbA4DGRVPB68c+tdcPo8y0vFfev8A M4an0oMLy6Sbf+F/5FS7/wCC0nxbs7ieB7NvtFtOJLmztp4JLfDdFR2Vwce2R1rBu/8AgtZ8dYpZ VTTlmslj86N4ZYDJI7HhNpjTp3/Su6j9HqjJL2jil53/AEPPxH0oYxdoRk/RL9bFtv8Ags78aZJ2 8+BQlzapLayW2q+WIWPDJImBg59fTgnrXIT/APBZb9oQSSCO90mxsFmbfcG1+23UYUfKpPy7iTjn 3716FP6PeBj8UotfP/I4K30oK8o8tKnNP5Nfdf8AU//X+gLT/gs98fL2a2MOsBvJ3jVI1t301LtR 93yXyAp9mU/Wsk/8Fff2hvtbNp+qWlnElyS6Tam887K57tgAn3PHtX+j8PAHLI7uP4/5H+cs/pN4 7pGV/kv1ZLq//BWr9o0mW5i8TTREQJGrNKFjtySOoVc/iDXB6h/wV0/anmkRYNWillhdiJ7yc7bg dASwYt0zjIGOK6qfgLk+0mvkjiq/SUzaV3Tg/K7S/K5c07/gq9+03PbQpdapa2dod7zO14084Ykj 5JFUvj2OapXH/BVX473CyyWXjTUrCGNlWdbm7a0lUg4IRgOM8YyDXSvAnIov4r/9u/8ABOOf0kM8 krOlr/i/4BlD/gqH8frO2m2eJLvWJ5JW27NVeO5ReqhXZSo9yAevSqf/AA9G/aGuIjs1nVbW84Eq jUBceWAD1Y4BPfO2uleB2QxS97/yVf5nM/pF5+3/AAv/ACd//In/0MQ/8FHvjxPepZnxxqkrtG1y 1zI+Lcyk/dO0KQQOx64/Ctew/wCCi3x5vZ4Fb4h7YkV3vU8mXzpCgx5Svgpu9CcDjvX+oa8Fchj/ AMMv8z/L5/SF4gkrcv8A5N/9qYr/ALffx5jitrxfiXr11L9pkWSyvIFhmtUYHDblwPTAViPw4rOu P+CgfxzstNhhh+IWsXN79vG6O6YW+6Nj0LKp3deldMPBrIluvw/4JhLx/wCIHdL/ANK/4BV/4b4+ O7Nd+R8QZrKGUDzwImlnRfQDOBmuHt/25Pj4Yma38e3Utws77EladoJGJO0480gYA5GMV10vCHh6 HxQb+SOKfjzxQ/haXzf6WHw/tyftDNcq9/4whW3wYp5khLyZxj5BkBT05z+FZ3iD9sj44yQwRaV4 +1v7TGpkW8uLkfZZFJ5jZEVX6erEDnHv1w8J+GYNWpP8P8v8ziqeOPF9SMoupFeif4+8/wBD/9H5 vsP2vPjusN7JqXjPU3txIo0y3TUJZZYxgeYSzkjBycZGRjrU95+1l8TgJXtvHfie3eYIkUb3zTMu PvDK4POeowR6mv8AWyPhhw3F6UtPl/l6n+RsvGfi5xs6qv8AP9W/Lr+Zw97+0P8AFMaguqx/ELxc nnfuPsUerzy26krtMjpIzZHOevagftI/GuE2kw8bubWzYRXL3fm7XVuN7ASY3decf/X6/wDiHXDq S/cbadDkj4t8WKTf1i93fW7ttotdtPPd9NDVvf2h/H9xYtb23jXUMsojivUuHJZs5bCseRngDgjF cpcfHz4w3CCB/H+sR+WQBcWl1MspA9VMm3PTnGfetqfh7w5DV4e4VPFfiurGyxVvRf53NSP41/EK 4LzX3jvxVeRywCGWObU/KAK4wybVwO/TBJNUY/jj4ltftMFv4z1rUba4BST/AImsglVj1XcDxjpt xXUuB+HlosNH8f8AM5P+IlcWN3eNl+H+R//S+HX+LviLU7CWybW9asRps4lsA9w8iuCMMiYIUAn5 juBHB6cCsSP4n+O4YWW48R6lqDF9zreXchTO7IKMrKy7eMAHHFf7FR4LyGOiw6/H/M/xzfiHxNL4 sXL8P8hLL4k+LBq13PqPiTXriO/iM/2uXVJAbRkXCxoc5AYcevHU1mTeNfFNwXdfEviG4Z5OVl1e V4AM5GEzjIHAJ5rVcJZKndYeJyVeOuI5q0sXOxcsvG3iC0kWaLUplKqVn3OTLMCCOWz261iTeMPE lzNbywa7e2z2js6ywsBOzHuz9Tj0Pr2rSPDWUw0+rw/8BT2/r+rHFPi3Pau+KqfKTX5NdvTfuN/t /WfPeQa/e3N3exg3ET30y+bg5+6GHOe4zWRczW7SRzzS3EMsLmdM3Uky+ZywDKzEMC2Mhs/0N/2F lsfhoQ/8Bj/kYy4jzeStLETf/b0v8z//0/zps/H2u2qq07WbwyJtuoRp8KfaHxjdnaR+BBrEfX1l 33CW8cFwXKh1RVcAMSCAOmD09K/2XhkOXQd1Sjr5Jn+KsuJM2qJRnXlp52/4f5kV94r1W5W3iuLq 6mt4yB5TPiGU/wB50HDEerZqRfFt3E8IWG2ufsTh4ftFuJGyeoLY3BfpjFaRy7D0dKcEvRW/Iwnm mLr+9VqSk/Nt/mT6t4gW6EEkrxmYzJdrbLHugtnQhl8vJJBBGPpnPU0l94nm1K4jur1EdrdVBzF8 gUccflzXRDCUt7EPG139ooaulnLfyXNpBA7XMSx/LEY/KU4JXDdCMdR7c1XbU5luBELpmuoF2q5l LPCMY65rT6tTWyM3iqz6n//U/L+31TWItKEd1dLLDLePHZrIwaZWQqxYL26g1Da+IdTdtUWG4Kwz Q/ZruOUZ84gj7nuM8/jX+07w9NO1tD/EX6xWuveMy1ZIQ3zsk7kO4WRgWx0zzyBUwkMyS728x1wW Mvz7x05/Or9hC2we3q9zVtbq3sbB3tL77BqE7GCK1t1Mc0gwdzrjjHPPrUD6hLEksj3GzeNspc4e Viep9/8AGs5UYXG69R6XKFpfTwtJKksixSP5H70kwSEc7RnjuPzq+JbuQzyz3k0bSAgm3bCNgHC7 c4I7VPsodhe3qdz/1fyqiurpo3iuH83a2QCOvvirNjqF1FPGxvDBGuS+cmNjjjgc/wD66/2l9nBb I/xE9tUas2V3vWur4F5RHvkDSNjk4GO3pU1xEj3HnSAyN5YRWbqFHQA9vwp8kXuhe1mS3V60wto5 EO6OIWlsqdG28/MO55NQJq2oWxk+1qirGPLRHhUOqgYHPU9jml7OG1hc8+5ah1me7MgYCVRHiLLE BD24/wA9ap+Zd3qsFQrJbgFpUUmIE5A5p8kNrE8z7n//1vyxd5VZI1C5aLdJMvy+Y30/z0q5FB5d lJIZoWuLtcPHtDS24VuB074zx2Nf7Tckex/iBdleIy7wmVfahYqp3YAGT+QBqik2JpYmlkZ5csgY 5VQMAhf896iMYqVkh2kxU1Ke12W68hEMRbqxB4PP0pbzVsw2dikaeTbs025fvl3IJJ/IY+nvWtrb Cs+xUj+0yxXSwGcmeVXkJJOwgcY9Bx0HHFaMd1MsS2e63uGuGQSTSIVkiwTkL6Z4z9KWlyqcbH// 1/yjvrC3tru7ljZpGL7JGfA4TjGPzqzvKxxwgsomg8+Mkbd6nHINf7Qvc/xKULle31SCB3imUFtv lwhsDv0we3Wpprm1mkEcaxCXACAR4aPp0PT8vShNrRFKFmI0ixr++fdg9cVnuZGV72KSNYYSBJAx xJOD6fTGefX8aRrySNuf7FPbRGO5+cJvkVB86egI7g+xrnJJp8szbmG7O4jJPvVRdmPkdj//0Pyf tblJEwshK5/ewtxux6/rTrqWFtu0lAP4c4APSv8AaZytsf4qxhIz2jsJIpPMjaS4T7qOpCAf3g2e vtVky+fEqqGCABHJPBx2/lWfM+pqoNllLq3sI2eO3S5WJCqoQWiz7/Sqdwts0AaS4iWWRQ6QI29s Hrn0xQ5NlwgyC0s43V45pJAm0mJkTfyOgPPHOKqSQNbyxyDltxGd3GPpWfPEr2b2P//R/JeK/upQ iCRYTbklJY41iOQc4z1J+v4YqnK7zyM5f97/AHs7sn3r/ZznP8X1BOVmWXHn25jeTa0acbjgEegN ZdvOluW2ESyQnMIJG3I7VF3e5oqaWhdbUJCpkeQxNJw3l8O+eoFZ0PkSy3EEt5cxN5RltJDHn5gR w2Px5+lNybNowQSjISQlQzEI7gAbjwMmoy90jqiuHiTOF6EZ54pOT2L5Io//0vyBtdTtyssV2x3x tvhz0yeOT9BWqiWv2c3F/IUiUgxiNfMkmyOw9Olf7KSkz/HCEImdeXsyxC2jkJtvM84gjaenAqnL cx2wiCsoaRN7qv5c/wCe9YXn1R08sLEfmRM6yNtJYYD4+ZR9a34NUtZLIWtq6rqDuVmRk+VV6K7H 8wPpUyctgilfUzXtE2pLf3iyaggMMssbAQygH5Rj2AqnbpF5lwJJCgVD5bKuQT6e3esJ9joikf/T /IKTWHsTpsVrbQhbcnefKDS3Qzlt7d/THp+JrLkWbWrgmxZke0VppFeItIyKMsoH0z+Vf7AH+Q9r bEaRJahnkYbX+aElec/X04qWX/S7QvLsMJbyxnnkdBSaXUUJ6mQirp6h44+TJh0U7nYE4yFq6kUh klnjSKUSjDpMu7HHGM9KztG9jrU2hlpDZzS6laahcPDJaQCX7Gd0SMGOOvfvQtw0sc4gQ3CWke7y 4uV2jAxn8qlK7sdKm7H/1PxcvCk9uUt0kieM5mh5GQenPcdaq2s8aoILfEcyAHpjH0r/AF4aR/lB CbsjR1GF7C3tmgvFupb2Lzpo4jnyQDwG568HjFY1tJcXFw/nNJsXDwoy4EeBzn+dQ4LobKo7Ns1b m7iaWCRAI50OP9lsVl6pOWureaCOIq/F60rbfLGCSU4Oc4FRKNiVNuQlsDeQyrp8ZuBDE1xLtGRG g6sfQVFAZTHGJ0HyOWRl67T2/Ss5JWNE5X0P/9X8RH1KKEOpbdEp545FR3N5C9lD/Z0LHVRdgxSg kEKRtHHseeOa/wBbeaKWh/lQ23uVXkvXVIzH5d1GAboxkuZTk5Zs++RxVqaZZo982+PzAVKqvAxW TaWh0RTszPhi0+VHichY5Mk+Ypz9cdant4Yp0eUuYYNvkpKh2EADHBqHNI6aKsjagtPMskvYbvzL S1cxOwIwWIwAf0rOurK6srW51G4LtG6LFEkrFiQxJBUe/ahy7Gtr6H//1vxAgvLNbGOQTOLhGwww Ai+gpranYCWdbm0LSOBHHLHLsU5HLcDnn+Vf6yykuU/y8hTlzD1S3hitkfMKM48l0OAOf4vxq/bX lhfw3m+XyLu3VVgQY23QJ+YjnqBShJLQqdN30CNmWDbA4uRKdkarhpWPoB1r5q+Od82k6VNp9xeC 08+ymujFFcAfMqP5YYDIzuXAz6143ENenQybEVZysuV/irHr8NYKrVzvDqEb+/HT0d/0PyV1O7e5 u5T5onZZMSS+X5e8+u3tTXvvMCwbUEAQKyEck+tf5gZhLnxlSTe7Z/o3ho8tCK8j/9f+FKFI2kQH Plu2wDrXcaTp8ud6TTeW6+THydowecDpXJPY57dDp5rIxqID8oRsnK4cnvmtH+ztORIJbiOO4hic TfOvDkdQf1Fcs1qdBZ8uAxQXljKsExuSDb26AI6Y+Uljzwen061r3kF7cad5F1G9u80OcdZGU5ww +vWuWSs7AtNjL0+OKOdIbh2mhCBZo5WAaQAYPSun+x6NqCfZTDbo8bB7QMwTy8Hv6+lI6D//0P43 5Hit9VNlkPJLiOIKwaMEDJyefQ/jVue5FsFz8kKqd7OMbCP5814DSWxvp0IbOR7mTMCQtuRmlRm2 BcD7w+lZscN/c2bW0mpv9jt9QFzLGzDzQeTxHxkcYzSMW7s6K3d137HaS02iImReOe5/LpU1/p8P 2eQW8xiXyg2w8AHt+FZyk1Im6Oj8PahAkVrowee5lRHmwkZEeeSeenHH5V22gQWTm9ub66a2SOMt BLBF5jA5xgj8Sfw6VyVdLsyjq7H/0fKf+CGPg9b7xzrvjCTU0udLjiHh63kZQlykiwpJg9MEsCff Jr+0nwnbSRaTYBy+Dbqx3HJ5Ffyvn1R1OJa/lyr8ETlitzf4n+Z0UbjznTHAHU96k8wBWCPg+mOK xh8SPZeiZSAMn+sy7k4yRjPNaMqsmF6Hb2qo/GzFbmU7SGX7x2gU6WQgKqAnccErzmuiHU0nsf/S /fJJLgh4lchWwJA5+TPqapTNdJuUPB5p+XzfL80MMYxjPp3r+TKkFqZzvzIignWyWM8MWO7A9e+R 2rwf453urL4M1H7BfXNtcm4W4trKJNqzojAyEyduMDaeCC1TCKjVizmrX9lO29j+JH9tPSLrT/ib 4svzAkupXfiiaW/lgI2W4ZUyB/ewFTp03V8I3LfaLHSrlLYfbNO16WWeCaRkfyjEER8dMEtIPxFf vGRtf2fSttZHLgJc1O5xd1ErXvmX8eyeF2NukU5MbBieoBGfxzioPtmqLdyRyWyJbEnyFEhYqvpg 9PpXunU/jP/T/jhGmHdCqvJAqOZkiHEeT3IqjdWxluUa3uIp4EYreAP+8hIzjaBkdR0r585lZ7FS /wDskljcQs95LIOYgijagz0J4PXFbFja3cAQ3A3u0CgwFsmIEZB+vIqoq7GVrmKS0ZVt4HIl3SME TJHqB7/4UunafaalFK95cfYLtEaXTftURa13gcbmByp9/etWrqxPPEsW8U0thb3+rz6Ubu2QwQCz 5lcZxuPcntz6VFdasz29ugskt9sgiK24LSTqeA5H6k1lyyJg+h//1P41k0+6SNPPaNra6JjKSKXV gc/e44x/SrEEAht3S4CzJZtuSdfvYztx/u9Oa8GMbvU44xfNdmNNfhLtGsYJnngn3ojkxr+DD69a s3WlQ6xe2uoarJeIxkDpGHZdrKecDoffPpXXBaC5NbHomnJpimbzrx9K86Axpcwx+Y5YDA4J61xs 2luuprbxJDdKS0q3TMquEwdzZ7HHUV1wXv7FKNkeU+K4pIdTcWcIksIxkythpd4PT6e9c5DLbz7t 21TuwcclT6V7VFXjY5JaNo//1f5Q/wBlq20ybxKsVoLKW+1TTG0ppGYR3luVUvGUPVcyeWMjtxzn j9/v2ZPEV2/iz4c3WsauhutMtdP02WwNusKNs8uBGLdWYcODzyT6V/b/AINS9pwDioLe0/yP468Q JLDeK2X15u0eaH3XP7o/2W9VhvfhjolvIJDdiEXYMi4WSMgKD6dd351+Tn/BWbT7W70O3kuJbqPS bHVVn8jbvVmYZyr9FIIBHv8AWv5/4Jl7DxRg1uqun/gTP6n8Zoqv4d1rbOmvut/kfzW+JLdLrV3s dSsbqazQmOw8pS27I+Zy45BOO9c5aaJcxXe+4+xiwW6EUKLzOExkblxzjvzX+itPEw5dz/K/E4Ju pe2zJrye7/tG9tYTCLK2kQedAhGxGUYZowOOQenam6ZHqN7eNJ+7mhSH5pFmRC+DwoDHPQY4rRYi GzOKeFlzNJH/1vgnWLm11Z7hMSWrylcQbsiLZtGN2Mdq4zUYngaC3eNJTGCjtDIBuyDtb37V/r5G tHoz/HyWFk5NpD9M068u7WZL6IxmVSylcrg5+UjHtU7RXdrZyvLaOZLG4KxvJKV85QuMEDqOeM/4 VSrK+5zzw1RJ3R0en3NxppsJbDShJcRbrpIGuP3cj8EAJg4A5455p+rW9x4iuotR09lgDZ+023lh CXOOhHTBzWscTCPUx+r1bWsVHsL7TrmK0nluSJivmytk2yjPCq2Pxx1qj+9N2lhfLFbWluWlmup5 CgCnp5fPJzWyxKRawsz/1/z8i02M62I9SmujBJCos8wl0SNV+QZ6cjB5P50kmlXKXIUwRzQbyE8n g7f9o1/sasTGx/jj9UqXsRWulteyXU9gsGn26fI1zdhmW4ZTjapH8/aukSz0+IWv+h2886x+Re3R JmVQ3XaOx6dKuOIg+plUwk0cvNIdNvxDZtPbyXDlDCqFra5RuDuJ6j61uP4biuyt3qk0cEdmzf8A HvJvMoxxg42jBz3I5reOIjY5JYWd7RRjiy0qYMbi6axhT545FQpLPsI2gDjhsYLHjHrVJra1F001 kxigkbcYpm80R8YJBxWirRbsc86FSzbR/9D85pXSGdzePdvp9svnTy2IJkYEHG0EdM4zntWja2Oo p9rvY7AyQxPCLP7QwSO6jdlMj552sgzxjk1/s/GrFO1z/FP2VS2iNnULy2GpaTbC0gf7ZhSyWaWy xleokIHsOT1zWzcI9nqb6c8UF5FJH5yTw58u1I25XPGev51t7SHc5XTqp2UTnp9Purq5dpLZ5o1O 6MRoZFBXoc1B9ju418+ZJYEcmFFkQqW29cL+P+cGmqsF1FKhWa2GwTahEVeC7AiVwRBOQYpNvUle mcZ6/StaHT/7UvUunuTDaMgdHtkDKhPRl59fftVqtHqyfZVuXY//0fgPTtIudG1e6mBe+sftRkvP tNvw6Pg7jyRtGB1z061anfSPt7ahoUMEEttA01zKZfkvF3DgKTjjBwB6V/tcqsV1P8QvY1exopef adOW9mti9zITJp0zRhtvOGUjtRNpNxIkbeROon/19yikQxEjJywHFaKtHqyFhaz2RVtY2t4zcaXK 93M8L2tws7AxyDkAqx649f51PY2l/aXDapAi2twYDA2GDF1YFXUexyc/WrVaDWjD6rWvaxo6N4fh aO4kvuTIxNpHHwgzg/OfqTx9K569t7zR9RhaWPyMO3kmRP3Uh7FSepHXHvW8K0X1M6mEqx1sf//S +Aby4W9jl81bmYiRBG8DlooiTgkrg+3TGPetz/hHbZo9Jl3NBcRI5vJEY7b4Nu2+YDwCARyuBxX+ 3/tPM/wudCfRGDPZS2U7W0bzlQSIRuZvlPbJ54zir6393p8MsMfy2rIYpZZQMuDjpzwaaqLoxOhU WyGLbSvZm4z5a+aoJK7twJA4A571at9PuPtBMWWtGyn2iRdipjjJHJx3qlUXVkOlU1VjInjhW5lk 86W8a1k2ySIjGCGQjG1WxzwR9CTVv7ObuF1dJYQ/AZch89iD7/1puqrnP7Kp2P/T+D7PS4tN8y5n smuDeWxjhDF4micY2sfUjJGD60WqyeUEvLaeKSSFnhZFxlgcDr1GePw9q/3E9rE/whdCpa1mUru2 lktFlmhaHzMrGJPlZz6Y/pVNtG1a2SxWK3IgkkLFpjhI+AWGD3+709ar2sbbnO6M7/CbkSreCNIb UWrLB5kruvlq5yME+xBGKqyWBjtvPkkmknlm8mSFOI4AOjZz39hVKtFLcuNGbexXtFgglaOMStew SrervT7RFtB5BRgQRnAx056U+GS41D+0bpZrJZrS6CIrL5Tgtgn5R2Ge3AyKft49zVYaTP/U+CGS 7hlSTUVjz5qo5tP3oVWIw+BycA5OK3L7TX2XQgiS4aJQ0CNJtlA64btk+lf7l+2p2u2f4RvCzvoj ntNhn1BLhLO3mllgkARAhyjfxBfU/wCFW/I160juI7jTL2zjlI/etbsryr3KsOQM9x6VqsRDqx/V 6i2RWsrbyp5bWKCe5EEY/wCPjdOY9wzu3Hk9e/StQ26qfJkQ7iu4HPyuO4FDxEF1QOhN6WMdNIN4 boQowl2FYFtgD5rD+Fff+pqmsIihtJJLiVVJEbwuCskLZxhh6+vpzTVemt2ZPDzXRn//1fgiGxv7 i9iE7CbylUqdmFMeThQByT1696dPp819eM8FrfSQxZWSZrSRII9uMoWI4IzX+5sq1K+jP8Hlh6j6 GYLSG9nlk0svNbJJ5DSKpMZkUDcoPrnt2yKvDRNQMFzN9ml8q2h8+XC7fkzgsPUD2qPb0+41hqre i0K9ppV9axXN5LZ3CWEKCfz3iIQqRkkH0xg/jWnLZiSxlMUAilkjS5ilzy6HPRc+nt6Vf1yl1NPq NV9Dnkj82eNPtEQgTIl3tjy8Akg+n0PrTja21zObeG6tn24z++HGfXv+dS8bBOxosvqdD//W+Bpt EQeXbPdQqRCZ3Z5lRmVRltuTz0x702PRYJYGmt5nK7h5bPGUBwM5YnoCO9f7mLG0u5/hT/ZtZq6Q kPh69keaYFxGQr2pdw1pNyRiNxxkY5qKTRJIJt8sYWLIa5lX5wvQc4zWrzHDRXvSSHDJ8TN2jBv0 RZvtAvp5RH5WzTrpA12lkjyXKJxwQBxnuM1k2VheaPLLI1sbe0jgZE86MxxqpBG7nHbP5Vl/a2D/ AOfkfvX+ZTyLHLalL7mXW0y8nisbiG3mmt71hiSGJniZCcFuO2eMmt668Kz3F9e2sCNb2loqxAXi +RFcYjVi4Y8H72DjIBBFaf2vg6d1KpH710M1kuNkly05P0T6n//X+EJvDN1o8sc8Vtbahb7FLzpE 0tmu4euMEj+lZ15o8VnfQRadFMZ7gFrt7m43W6cbsx8YAHpk1/uXLOcCv+XsfvX+Z/hR/YeYXsqU v/AX/kRLoN88Szyw+aLmQiEWymfAHUsQCPritGw8MX8hjfTZL9JQH+0yhHkhRenC498H1rJ59li/ 5fw/8CX+Za4fzR/8uJ/+Av8AyJLXw7OblrB47ma/EgRWW1eJJW6gLlfz54rQk8G6veeVbNZXyNJc eXsFvIh+T7xY4+6O+KwqcRZWlZ14f+BR/wAzrp8NZtJWjQn/AOAy/wAhsvgXW77zbOFVmgXC3FtB bTvdkg/d5UAAjPetC18BXs729vaWT2sSTmKeOS1uBcBlHzRpHsOT9TXHU4ryek7PER++/wCR20uD s8qK8cNP/wABa/M//9D5DX4f3yEoqSuqAyu82n3K+UCeAw8vjH9Kpah8PtWs4FnsfD+vXJSNbm5u obCaSOVZTtBRio+UenoK/wBqZ8a5FHSWJj+J/ibT4Ez+ausLNlGbwDq8d7uhs7rWoI1LgafbSzzp leQ8QGcgnGBnp2q1H8NvEVuYba00PWp5rlhJLEdMnga2L84Yuo5XvisXx1w/H4sTH+vkdH+oHEU/ hwsv6+ZctPh14laC5XUdA1+S4RDH5Vvo890jBWKgh1Uj5h6kYzU9x8I/FyTxwweF/E0drdW26O6n 0m6tLQDb8yCR0UBjkjA9ahcfcObPFR/H/Ixn4ecSt/7pP8P8ylP8JPiM1xpzP4M1aW3mRbW2jt4H ia35CqzAR7WXGSQCCSevruX3wX+JzW12tn4G1u9SzlWMrHZTBy3B3ldnABH6VlPxC4bh/wAxUf6+ RcPDrieWn1WX4H//0fm+H9nr4nzR26R+C9WaSaJHvInLxrYdNxJEZJB9F5HoelQxfAT40WVxd3Fz 8PtdltrWVFhghgYLeqxxldy5HODgjoa/2QfiXw0rr26/r5n+Li8MuKXp9WZ0h/Zn+Lmr2llqln8N 9Ui+1zt9qtxqJlawaMjaXjEQOPlJI3HqPTB9W0T4H/EHRtJmNr8KtTn1OSCWO4u49Oea4nbZtG7K g49wOPQ15OO8UeH6tJ0aVdxfV6LTtv1PUwPhTxLTrKtPDX0030ffbdfmeWyfsqfF7WdSi1Kz+HHi nTb8uA0ctjN9kjTHsoIOTnOD9elbkn7E3x/fUYopvB+oGGUZjvPPaQoTncGTZyR7nvU1fGHhqno6 j/D/ADZph/BnimsuZUreqf8AkbFn+xT8dpLWaRPCiXjQztbtBcpNZBEH/LVmCOpB9Ac1En7Bnx7u 7q3nn8H3sVsZdqT26y3ViueN2AodsZ6ba4p+NXDsHu/vR3w8DeKJq/KvuZ//0udb9gX9oKUwTr8O 9WMkIeFLiTz7a3uW/hfy2j6Yz3B56mpl/wCCen7RWpTxqvhO72whZZ0gsXkSIk4K7iRz1weK/wBY ZeOXDsU9f/Jv+Af5I0/ALiibtb8GdNaf8E4f2hrgxJB4Ruo9tyzIt5DJFPcR4xhVWM7unXI+hpY/ +CaP7RkupyW3/CH30VpcKduoize5jsZQMj5MbmHbG0/hXHPx74fjolr/AIl/kdkPo88SSSd//JX/ AJnSRf8ABMT4/wBwkijRdThVrUojz6M0MXnLwHYqhYAn1NaOnf8ABKT9puS1iaXSPMW3JuJoINCu GZx6ZZgSMY5A/OuKr9IHIY3tD/yb/gHfS+jfxFL4pf8Akj/zNlf+CUn7QMp81dNuGjkBMAWwkjMX QEPmPoPz4ptt/wAEnv2l0vGjktdOuIUf57eC1njnEbdGUlDkj6Y964ZfSEyqN1Zff/wT0F9GrOtH Fy+7/gH/0/pKx/4JF/HS484pYEzxIXs55lZrq1I/1mf3QGG4GPm+taU//BIT4y3EyZ0zVZGuI0RZ oYUwJD1ySf1OPpX+l0/pF4JfCo/j/mf5nU/oy4/lvL2l/Rf5GhL/AMEX/j1LKoSaOBZWWOSWVo0C KoBODjaG7ZHofpXR2f8AwRd+MtxNbG81e1ttNtMiW3/dS3UpwdpMgIYgHB6dq5Kv0kcOo+5GP4/5 noUfouY2UvflK3/bv+RMv/BEb4qKhjk8UW0uyb7QbttqzSEnKxgA8ADA5962Jf8Agid8RpbiymsP E2kQZlL38bXTG7PHUESALz2C9K4Z/SSX2UkvL+megvor1krXbfr/AMMbg/4IifEHUI44j4rsIVS8 W6uVlnzeOE6Kp7A/XnuK05P+CGviYSyPp/i020xT5nub9ZrQtnI/d7B9ODXBV+kjXv7lvuR20/or aa3+9n//1P0xX/giB4ws5bc33jNZ03+aYYpoxBKSOQzGNsD0ANa1v/wQ6EaXF5beJZLRrhisofWi DJnruj24UHttxX971fpIZg/4bX/gKP4Fp/RZgvjT+9nTWP8AwROEMguE8SFVjVHWKW/861LL1Pl7 Op/vEmiH/giLZ/2jFeweLdIshNM41CwnR7t5ImHzFGIwDnkZBxXnVPpFZu2/efyVj04/RfwiirJJ rvd/18zrf+HHvgpWCzeLrmWDaNp8tESJsfwgRjp6nNbNh/wRG+GNvLBF/a1reRwr5ktzeO089y+Q cOGTp9AK8yp9IDPpfBOS+896h9GfJEvfgn8l/kdBJ/wRh+ElxbeTdXttAVu/PlTEsiy7T8qg7gQv +yOOegrRi/4I4/ByJiW1W1a1eIxeQlu4CEnlQu7BGK4Z+PHEsk7VJ/ez1af0b+GYtOVOKfayP//V /fv/AIc2/AC8jlRtQgSJwj+XFZedIPLx2LYxwK1LL/gkB+zhpswu2u4pdQjYtFc31hFIVXphQSQO M9BxX9dVPGriappzSfzZ/Lkfo88L09Wor5IuWn/BID9l5GnafzpZ590iSMYkZ9xy3ybsEda0bb/g kz+ypZPLCbWCJXtVUE2lvKU5GW2noT/eHPvXFU8XuKJq3vfiddHwD4Vg+b3fuRup/wAEvP2UBElv b28aT2ymBpzNawPEp6jK4OPYnvWhZ/8ABNT9kmzSOeFLWR7EbCTJaT23uMnkN75/CuGfihxZJWXN +J2rwS4SptOTjp6f5Gun/BO/9ki5eI3eiaBdQySb7eOWO03ROOrdsn3NbEH7Bn7I2ns9kmgeH5ov M85vM1K3G0jnjHQiuSXiBxbUVlKX4nZDwk4Og7y5PwP/1v6mrL9i/wDZF0i48ttA0ApI3nCH+0YH jQn+M4ok/ZF/Y60qGRbjQPChZrgTTPHLFdyMD0DdSBX9HT4w4xqarm/E/DYeGnBFK3Ny6enUs2v7 Nf7HlgzRpovhMB1Ct5TJGEXPyqRg4NSQfBL9jWzaWyh0bwPLGreeVluxcxq/djg4yawfEPGlXrM6 P9SOBKNlaOhtw/C/9jmCNHl8O+CzEpEUfmHY4PUFR1x70l14I/Y+06RbmXQPh3BG8odbwxpLv/2W 5OT9ayeZcaVHa8/xOmHDXAVHpAuS2f7H0OHmsfBEVu6/uRJpsa2zYHPl8Vjrqv7Ftnc4isPBD7mU ecLKIRKT3y2Bj17UR/12q7OX4mssr8Pqfxxhf0R//9f+sQ+Nf2PYgmbXwSY4JyhK6VBImfr0IPtw aztS+MH7H1jNHDPB4IWJuEWHQ4YfL7nFf0FHLeNKrtFz+9n49OnwFST5lC3yLCfH79j6C1m3r4Oj gRty+bpUCs6noT2I+pNU7r9p79juytHgiu/DIS2kadoYLC3zDwMurBsAfjW0eHOM6u7l+IljOA6O to2+Rnt+2P8AsmWgie3bSJy68SvZQxRzKO+4ZzVe+/bX/ZciieG1udGzA4kaG2Ft5oLDP3Tz09a6 FwTxdU0k3+JEuIOB6bfIo/gZn/DeH7K1kiXTatpflo6xu6WsWY2P8JIU/wCHHWoH/wCCiX7KrSSm x1XSHvTLt+VLfJ2+qgZGPat4eHfFlTX3vxOafGPBlGzvHX0/ryP/0P6YpP8Agpj+zLbXU73WovLd KglKiSApGg7gj5se2K567/4Kr/s2W0s8kGoW4u1jEkafb4rd/LPGShIb8cV/UEPCviipvzfifgs/ EvgvD3+C69COH/gq38AphC0d1ZymZS0Y86OVpmXkjOefpyaqv/wVt+AT2DX9zc28cTTG3JM4iSHb kEsrEEfiBWkfCHiWTs+b8Tkl4ucHU9lD8DlLf/gst+zvKGt7G4inuonPmZ+0eW2OMghcfiCatv8A 8FgvgkhVpbiB2kYrGhkliMbbeM7sAj8a64eDXEUnbllf0OGXjZwfBc3uL5o5XUP+CzvwjhDQi1to oEPyXAZkWQqcsRIzY49qxL3/AILX/BW23QW0C3Fz5H2iJXuHa4kGOcIAAVz3GelepS8BuI52/dzt 6M8+p4/cE02/3lO/rE//0f2Xl/4LkfC2N4idKMNs6tvRtOnmaQjv5gXH5VpJ/wAFrfh7Jb288fhi a4ju1DW3nu9vkZ+8AUzgfliv7Wh9HvOVa8ZH8ny+kVwjdrnh96/yObuf+C2mlrNcC18HqZIZzBFF aRGSaQDH73Dfw/rxWVD/AMFztIiTU11Dwffu0BEcM66bIkStkfKCFI3DvuI4z7V30/o85nJbSucU vpIcNQlbnhbyZm6h/wAFuYrqK1m0/wAGX80DZYStap1Xrl2wpGegHvXMz/8ABcbX3Nwlt4TRpI7c PZXMm2wt3PAZW+U5wOePSu+l9HPGyu5x+9r/ADPNxH0mMhpSSpSuv8Lf5JmBef8ABb3xnxO/hiBf sbLG32a/TF3u7rgHOOmODVa2/wCC3njMv5l5pX9lIHZljv54gs391ApGSfbNehD6OVZa8q+9f5nn v6UGVrTmf/gMv8j/0vv+D/gtd8SLic/ZLTTpnmeSYR/b0ijtkUHAYiPuBxjI+lcZH/wW++Lks2RY 3I02Fi/2jT7y3mhVt2NhG3zD/wACGK/0Qp/R15X78V96/wAz+Ea/0ocIn7rb/wC3X+qGa5/wWu+L FvJFYx6Tcx3mBKbyXVY0jmSTGzOwHPUZHBFYL/8ABaD47Ry3FrJatvgmRkWO+RYxG2DlWZMnqOAf xrvofR4w60qWX9eR5uI+lHGKvQi36L8dbL9TGk/4LV/tCTS3EMIvIPJv1UBp4prWaE/xKcAgjjII NYcn/BYb41i7vomubxtRKPNYJJfebYzE55wV+X6cdK9Kn9H3L46OUfx/yPKqfShxMtPZSt/27/mO P/BXH9pTid9Ut2hFoHimtr2S1mWTA3RsPLIPoOce9c5B/wAFVv2iNSnMUmrTwWj3AaXUJLxorkjq U+VWJx0zjnNdtPwCyyG7X4nm1vpMY+orQpy+9f5n/9P1d/8AgqH+0HBBKl1rMs6pcvI076kYUjg/ 5ZqV8rcxBA5Ld65Rv+Cn/wC0Rc2RNxr0K3GXYJbXlwI1j/hQZ5yR3HvX+p1HwHyVfxGl6R/zaP8A MTEfSRzqS/dUn85f5JmJB/wUu/aAiuBbDxVqkFjeWo88WNyrWUL5yOZEWQkd+o54rIP/AAUk/aFn u7gL4lvltkdgjzTHexHEZA38+/Aruj4G8Px6/wDkv/2x5c/pFcRPSMP/ACf/AO1uZc3/AAUN/aX1 eGB5/HDRokxeRIx+9REx8pJ7H8T71Ri/4KD/ALQTRStL4m1ifzLvzYoHvEtEaPphWQEn/gVdcPBP h2Csvy/4J5dX6QvE8pNvb/F/wCmn7dPx/nR1l8Q3ljsLuB9uN7ktwAQVBHHoa5yb9s/47zwlIPiR rltdpI0b3CXBMbxnHy7D0I9Qce1dlPwd4cpv343+SX+ZxVfHziuon7N2fq3b8rn/1PE5f2uPj9Je CS3+J+sWsTWUdvIZ2XUHEiNkupbAGfYDFaU/7YfxyjXybz4hajOskySWnk2yIVwCGV2XoG+ma/2A XhRwsrfuX96/yP8AHx+N/Gl3++X3P9Wc1qH7W3x3vDDaf8JrrEKrO0z3MN9wU7Jgjr+Jo1L9o/4r 3Vp9ot/HOu2txewmCSGW8FzbccM+zj5jnrn8K6IeGHDUNI0fy/yOOr4y8Y1HeVVfc/8AM5S4/aO+ MCXVpCfiLrTQxw+bNaRXBtZJHThMEcAdyAOfzrLX41/F7UTHqR+IniCKdZ/Nksprp5UUPy0fODgd Oc+1ehR8OeHKfvPDp+v/AALM86v4q8W148kcS0/Ly9bov3Xx6+Kkd7Ne3nj/AFwWhVIVginKRwjh duVwTzzk88nmsyT42ePXlaK48S65qsByiKdWltolXduycgs34810R4B4bhthY/j/AJnFPxI4wn8W Ml/5L/kf/9X5MuPjN8TGYSW/jDXrG2Ox7W3GpO8FsF+VlReAQcc55rI1b4qeOdQMAuPFGpfZvuTo D5TSEEchgeM4zwB161/tPHgfh6G2Gj+P+Z/iZPxC4rldvFy/D/Iy5PHvidri0u28T+JJ2tJ/Pitb jVpWsht6fus4Pc5PtUeq/EPXNR8hXu7xnjf7QJ31CVHDg5wcNg9SOmMVrHg7I09MPH7v+Cc8uPeJ pfHi5P7v8itp/wAQPHj/ANs3D6zexJqCpArmXzbaDYODGp4DHv61Sl8Y+Kbi982XXtRHmRBZm88q z7fTHABPUAVpHhXJaUvdw8fuMZcccSzVpYqfydvysR/8JZqQWG3ub28uRDcNLE8l5KWQt6Yb9OlX Y/FPiK2gkht9RkNu8xuEDoryxkjBxIRux047Yrf+wMqWiw8P/AUv0Mv9a8/Tv9aqf+By/wAz/9b4 CuNZ1HUpoReaxqMQSRZUSO4aNIyox91euc8nrk9ams/FupW8kxgvW2faBHcQ3ZaaOdB94Lzx+fUd K/26WS5bt7GH/gK/yP8ADKXE+df9BM//AAOX+Y7VvF05hlgtzJCkw8pJdPxbSRBiCTuUBsccgcVj tqV1cSwm8lnuXt7cQ27zzPKyAE/Nkn73v1p/2Nl6Vo0o/wDgKG+Is4l8WIm/+35f5kUmr3NuJVhu bgNMoQhpmkjXHQ7ScdqvJrerapbzWF4YLqzZQih7VBIWwMuCOR1xWkcrwkNYwSfkrGUs4x1ZctWp Jrzk2T3GrXlhpEFrH5x+yoUbeBK21jjnPp6n6VR0zWp7CFY7N3DmRpAzgPLGW6kSH5sdeM8Vp9Sp bWMPrle/xH//1/gSHxJqtrEqwajd24WRmzDMY2bf97LDnHtUKav9tlkTUdalysfmwRXAMiSOnT5V GAeT8xHrk1/t+8JSUr21P8JHjazjyOTt/V/yRHPfMS107qswjxJKmIzIOnI/Kobe9v3iMsUs5lmU KI2O5go4wevp0Oar6tS3aMnia3cztPv7jQ5LmJJGzfyM0iyASbN3zEDP3enbFX7fWmjO9wJpTIWR 5Du2Htj6GlLD07bC+sVe5PfS3t1aPv8ANhVgJboq5ymCMFvxx19q56Kb7Reo0Z865dAqSSNl2PQY J+tL6tHYXtqkpbn/0PzkEuoBg87lri2cgc7+h5HoeOKmjvbmSItFIYt2TGV+Qpjkjmv9wVh4H+EH PUWzHz3FzNAgWbMjEMWX7ylT3/KnTXtxcQDEhkaNSmSx+XIwf8+1P2FPsJzrbXKsd2GtjalnTCiN DGxXaoBBA/DFMWW3hkWSYKyxpshywLKR25zS9jBaRLU6trtki3UIaOR55Y0eUMSuWVOMADH06etQ XTqIzISw3En5sqPrz+NJU43sxOUnuz//0fzUW+e0gTdO62ocFlBO0j3FaE16hGY1Dxg7oyFx9DX+ 33s4J6H+EF33Kwk8/wAyZ5kV+PlOVLnOMCkFw80d1bLMYmCbN6HDISODnse9Pki97Etz6Mq+XILe Gyld7iGSRFuJFcrOV7/N1H4e1a1xIitFZWW/yLcgqk0hkkVOSPm6npTlCIo8+mo5tY2RS2TpEP3i zq3l/wClEKCuM9cHJ49QKot5NzI/zm3EpM7BQTg44GM+wFQ4R5Ta0z//0vzoj08xQCWUbHkXdFuO AR6/T/CscRiF3luts8THaQg2g4PXv0OK/wBvuSK2R/hI1O25Ml0ghcMxljlGY1DZU+h+ntVeacRx RNIfmmyFUZJGKyaSdkSnMbE91sjiik2RSShlPGFI9c9v0qW5uFuAonjU4O2VyoxKcnkjpn/CpsjT UYssUEnmW+4yLg84Q5FT3MskZEqq6mdcmReA3Y8/pTHa+x//0/zAt2cTSmRgIuqYGWzjvTbW2tku r29F5IZDGCbZXJXI44XoD9a/24P8KHGWlzYhYTqwV5Hm27mywUIv+cVnTDyonwxkkUkxO/zYPOMn 2/pQNRbK9tI7yFp1L3E/DbBxI30/Pir0UKWksMg27HBZkAxsOen+fWgahJ6FC+bzZYreWJBbBjcC RW2l2yMAj8CakS4AYqU+RR17cdKCuV9z/9T80I7gXMgjijDDaQFX2HWs5Jilw2EWQjgKwzz0r/bg /wAK3DUkaVXhuJ2jkjaCdYPIkTDncD8w9hgfnRMd1uSjDY/ykZyMgdx+NA1Bpogt3idBEoDyQEsQ B86Z4yf8+tSKyxOxJKtIc98dMf0p8ztY15JFq1l8hpbiSZGC7RFbOpIkPzZP5e/pWILJXvTdJD5A uZSFTHlpuLc98enWktDSMLH/1fzHSa1hW7trmZY7+1mEAtihJkb0DDjgc1mXN+NRcCNVs5kkKSQB dseOgOSePxNf7c3bP8OFFvoV96qxglPnKhwRuyGx71ctIZCp8tgoZjnccAYFIHCWw8yEKVZsM3yl scVniN4i3zkkH7oP3hUNpXHGm7aFqM2zM0mxhOqYSQ/w5+9VN7d5Pml/ejOYwRnp1xWRXs5n/9b8 qX1GcNbhrSJ1WIRmIr5eOMBjjkkZ/PrT9qHMrAjAyQK/2w8j/DpU31KkN6VlDhcNHlIy6hgAeCcG tBLizS3ubY2zfallzFepIPJdccjbj8jWc7bmsIO2hQX7O1xD5jgLtZi3J5HQfjWpC9vJ+73bYpPl Y55GOf8ACqi1si+RkkzXDWAuXaFgk5iCrJ+9C54JHpj+RrOh8sTSXDgNlNnIwPrmjmiHs2f/1/yo sJbdtQjkmd1S3YyQSqN6wNjGSvT6j2pZp7WS4lt4ZHlkJBWSOMqshbk9RnPNf7WSlfY/xDVPuJJJ DGGWZFSQL5W4jay8jj+mKhhji3SPcs0cPl/KUG4McHr6UOT5UHJqLCYXvLaWZytoj/vZEXdKFz/D +X6UiPbTy3IaST5W/dB1yGHpn1rJytoyvZapJlaQMLX7DJL50ZvDc2kKj54yVUH+Q/AUywuZYmmS YloGP7ofxKenNSpX6D9kk0mf/9D8oLdibl2WVVIjZh5v3eATjB6k9MU2VJmXhQCR8xUYFf7SKT9T /EhU4tFYWqP/AMtCkoOd5P6Vq2rCOYJcA3ACEgRvgrgZyT+FPmfYfs4szJ7iRLtmD7VJ3wccjHHW nXUkl7GWaT94FyxJ5Y1ZnyRIdMN/FCLVJIUlmm+aZosMQeNuewxWvZnVNPln8mVhCT5MqgiS3nI9 R0PfrSd7aGnLDqf/0fyk1F7q4ubWRW2/vd/lwAKCQT8m30PoKlkma4lnlmLIZc8KfLVDz0/Gv9pG ptn+JEoxT0KEbXFrEGSNMyFo5GWT5oxjGffOcfnSWm4xvCCyP91J85MYOQfz4/KlyyKXJ2Kq2lzb Ssss3nfvCUkznKnkf5//AFVPcfZ4o9+SHzg+lNqfQfuCxzTyREWpeMMG23J+SNSoyRn1/wAaoI0i KHZ23hsb1bODU8krBFrY/9L8lcuPLjuJWlSUbprkJu25POR+P6Uz7bdTPH5j+bDboLeHgIY4lztX Htk1/tBax/ilFq5WnkjmkgkFvHJ5bZSVhll+lWHt0+2edBNKkZw6o4BLccj25zQW3ZpCXV2Q+35X jwMj+PPfJqqLtGiaJlZPNJxx8ijnipUUtihlgWV2Ubio+TevCj2qe61S9tTGr2sLw20hIM5/dTKe oyO2c/5NVGO0Ru+5/9P8hkVW3TqWj+QSEJnYue2fTtUMrb0CLIWycls4YV/tK4aWR/i1G62Lmy7u IWlVcJGoi8zACjA/+tTbW8htx5cqE5ypJHHTrWbVjZXTsiw2oqkNxFGo/wBIj8ndgBVA64GOvA5q np8lraxOtxCbgKhRG3bXT3B9uKLdR6xVi5b6rJaKwEMbLIhi2uApCngke9VrwF9P8yOMoY286J+Q zbTyBnqOKlxVtgi3fc//1Px6iv7i+kkWLS54okhEsrR8xLgYc9yB06+tXLDeZWjMedy4V26D0r/Z g/xlauwvhLGixMwSMy7XkUAuM/0qO40eG3td8GoQGQskixqGZ3VvvZOMAjjjPegqMXsUYsxSyC5f fs/1OeiD2/GkeZLmGYwHaASnmY6EcHFBtyrRG/ZWk1lZWFxdadNe2OrRuttcQsGETISNxx0GQf0q lujs0lcwPNKx2o5bCJ9R9KUnZGig7n//1fxsitI2m+0SSMC5wE42LnvitGGCNJQyXaB0+aaJ1IKr j5SAeOa/2SlK5/jrCk1sQ3EccxM0txhVOWCLhDk8cDp/LmoNsbMwkCsIlBIH8Q7H+VZuaRt7OXUl hgglnV2Eht1+Z1j+RwPQZGM1XKSKbgQIktzMoWNk+QqqZ4b361lKa0Q1SlcWci8hHlbY5LVR9qDy BcY/i59eelRm6hhhVJpow07LEu07idxwP1xXPKpHubxoztoj/9b8W9UB0+VlZ5QYf3bLknBOM/yp NJ1K3ltNTjjnBngjBCRAiUZIBDY6cE1/r57SGx/kT7Go9kyr5tzFJbLeyObN4vNtkkOBGpJ5Uehx mtSLUYEK2kbLMjOJFVfmAPt/ntUTqwtuVTwtZ/ZIbzVbf+0N0llIZGiKwRxQBFY9MgDsMdqoSTSx EztLJB5rBPIIIDEnAwPUVhKvSjpc9Gng67+yU4bi4kvbgRSNqDyN9kuJok85ZQCPkyBweBWtFOtt CdPsJILea9ufIa0WVTfLsySTH17nr6dKxljaENakkkejQyvEVXy04Nv0uf/X/Fm2vtBjiL3mtGNT cNby5tZbi4BQckqoJ9uazrn7Pd7v7GZ7mDaZPtwge3TH/AwK/wBZZZvgU7OrG/qj/MCnw7mMldUZ fc/8jOuLSDTNHg1mHVY9RWAf6Vlv9Ihl3EFdo5wOOf8ADNY9z4ptoo4Jp9VghNy4glDs0ZDnBRSC Mn8Aa5Z8RZXDR1o6ea/r5noR4QzjlV8PLVXWj/pPy38inc+MdFsrl7SfxDpcV0IVnaCeYguDjADE fKenUjrVVviL4IlWW3ufEVgLiVzFHb2zPORhfvb8YIz/AHcmvPr8X5LRbjUrxO6hwNnNVe7Qf4f5 mfP8W/AHhGwuLWXxfpgutatTZQtBePC0K71LCRWTIJCkHJGAT14q5p/xN+H0cUEcni/SntuVluY5 nfyztztB24JB7g/nXmVeOshheLxEdD0afh3n0rWw7V/Nfef/0P57bX4sfClradbzxppUUNvcFZZY Yri4kBOcZbZjPoOetZ1r8ZPhlbxRainiFLq7jnf7NEBJaLGF+VS+V2/N1xnv0r/R+r4mcN0VzVK1 umtv8z+BqPhVn1SVo0197/yLU/x88LQLOHu47ee9cSlUs/OEK88I3XHOSOTxXFP+0n4JvbK3TT7f Wb64ub90e4SMwWlikXDZR0DDfx9/BHHvXjYjxc4cpfDVT9Gj2qPg/nMkuZW+T/4BgS/tJeGUl/tR 9PmRheCNLBbpFtpoydvAA3Jn1OQO+Kpav+0tZteXOm2+jS29pIqXFmtrci7+z4BDb5CADnnr+fav Dq+N2Rx+FP73/wDInsUvBTMV8U19y/8AkjJb9qmxgls5r/w1qt1bR25sWtrEQW1tM6A7JpyjBiem SBkkVow/tRxzrDbLpz21reJ5l1bb/tdpbsgJTLycg84wPzNcFXx0yuN1CL/H7tkd1PwTxd1z1Fb+ vNn/0f5Sn/aRaO0mgFrtuZrl3jhlnFx9rjUdVUY2Hqep7VBD+07JKkKR6OLWW3V1i+3uAs57Fl3H hevy81/YNbx3gtIUr/L/AO2P5bpeClPeVS3z/wDtRLn9ojW7dXEj6VqMzRbrORbV4lTjud3Y9M5H tXM2v7RviCCENLNC1yGaYxKGeB2xyq5zgkcZPHFeTiPHjGJpUaemvl/n/Xc9TD+CmBck6k/l/VhY v2lPFWoz2y2V+JI7S5Ekts8bKLdSDuTGBnnHI44rxT4jfFXXvF1rLbXLNbNHeussYUBZUJ6qQOhw OpPf618NxN4t5zxDg5YBvkpyWttf0S/Bs+x4e8MMpyDExxcVzTTutP8AO7/FK54Q18nm/MNmP4sZ BNSBYp5AxdkIG7joa/D8XK9aXqfqlJWppH//0v4QrV5PMV5xsjDYUIck46E16lpjMlsCPNESANG6 t91iev8APpXFPexjFXZee8ltnQF2nMkmS7/ej/xrq7RJTHKjvbyFIxNF84aOTdgleOM81zz3NitN HcNG8tlHukQb/KC5SPHWtu1s5JALhryWSRbdWaGZ9qjH3lUZ6/4VzS+JgSSW51KZp47dYZILQhim FZo4hn5vfAzWNpd7p0wuIoismWy7vuMgK5wFPWpNHPSyP//T/jbsdIj860ntygErFhGxw8bZOdwP Q85rW12zmnt2026iy9xhUlUYdgecY7DAzmvAYGY+ba5trSO2t4poYxE88bZVgcYJIzSPOLZprdVB uRIYpZHiLICMHIPG4EHgis57WM3PsbVpqlvJbNBsEpuG23EAXCDbgq4PvyMVYt7555L1bq3RI4sR pG3zZXAIb25z+VZGZZ8N6eTJdgXcsVxJbN5TK23YCTnB+lem+GYZNPszELOa9lY7lLRtKvH949OT 1zXNXdkx0N0f/9To/wDghX4MtZfC3iDxFPNLb3NxqEC3WkGMfZ7W8CLG0y+uFVenXfzX9aWji5Wz gQB0CxKCrDB4Hp2z6e9fyjmdSNXPMRNdHb7nb9BZXF++3/MzYRgXJYbWU4J9auKyjJVQynjOOlOC 2Z6km9inM7xMrKpYK27pU8cssrs8owCvymtErMjYa67UOQDzheKVDtChRg+o6rW8I2Kcm1Y//9X9 +r6eFmYCJwJ+SrdfxrOSWGCVQkRZR98gfdr+VqlNGEpe8ht0ltI6y+XlWB8iTG3cRwa82+J9uJfB 2rxxkQ3EltsW6ePzEtAcguV+hI/4FXNZbv8ArUif8OSP4mP+ChXhS5s/iHJLpMl5GknjE6nJHvCy T28UEaMXz1VmzuGDyR6Cvz7mg0iBXv7tx9rMyxRxzuVSVmzwRnHH9a/bOHqiqZbTfkvyR5uWpqm4 vuzzYQ+frMNzLIsEVveZkjSPekoH8Iz2qDVbwz+I9Rh0y3hni0xoblvNZkt5EkwXAP8AeA3YA74r 6Vao7Xvqf//W/j21Kd7q8gu2jEFpKp3Row2QDJAGM5GfzrLvDFBeWtrYQRLDc5eaWMYUtkk7j618 +lfRHHC97GbrkUUoltoUuIDBEJbm73GO3TrhsjGSPTJrqLFLL7HZagNstxNZIouFG0Oi5Cjrz61u oqI57EsOqzFsw6NbTy2rtCrXTvH524Z3jGcgZ9O1V7W1lk010v8AS47y8G9yLSd4kHXAGfQc80zI w5dBmWCzXyYpbEK0sJ+0q9zDLk5Qjrgc9f61jX15Kt+lksitdeWqmOJfmtlxjLenTrQNNxZ//9f+ OrTrK9uLkW095EyWyCV1MyrCpYD8/SoNVvoppls7eyjtYo12mWHI88A9GGfbNePY5VJW1M+fzdPk ln+zR3Ato9zMhyzn+EKMd66CK7lvYLWV7bYkkatHnmSIkcrjt6fhXTTWxPPqVLjRJNWmjgjeSUyz YW083y1jK4JYdMe5zTLq50yCwCm1u47m1nMNxOCSnlrgDae4J69cV0QfvWKbsjhNYvbK3lAubJ5U eISxtFMq5zjaX6nkduteXXc0i3k1yUWOF2LLGg+VR2Fe1RVonFLdn//Q/jc/Zku0tfGlxq8tqzQ3 1stpYXiXHkvBOj5J29SMFTj2r+hX4UTx6Lc+AfFFzeyX96Gj026sbm3AifLJDFLG2fvEFSrdiSOe tf2r4Dy9rwvjcOt7S/FH8beMieG44y3FS2Uo/hK7/wCCf3SfsTarLqXw20OF5I7z7JoyXMd2kmTJ 5gX92R/eUhwQOhFcV+2b+zjc/Hfw7daBpqrE+owhQLlGaG2cEjdjjrwfbAr+aJ46pk/G9fHQ0cKj fp7z2P7M4gy6HEHCVHAS972lOK8n7q/Bn5Uy/wDBJHxl9nuNPTWBFd3MUf2TVri5SSS2I4ID7MbB j7rc4PWudl/4I/eI/tttJd+JzdXtsvk3EmlXUUIvO+90kQpg4x8vPuK/c6fjrjErX/BH80Vfo84W c7uLt6vvc1bz/gj340NxfhPGiW1qzJGn2GWC2uFicbWiBEbEg5O4dKwf+HKviyxunmi8aaNrEnmA WMd35ayKD0U/KBnnk8VX/EdcZd2/JHPP6O+FUtU7erP/0fsk/wDBGz4gQ3qw3s+kXccjGNrZNUaC AAnJCqpPJHqatXX/AARc8RuxupTDphXFvFZ2OvRbIUXo+5oScn/eNf1xHx0xvSSt6L/I/l//AIl2 wnWD+9/5jLX/AIIsfEHzmuh4pkt1CtHsvNSWSF43+XjYAu4Agg8citgf8EXPiFHb3NtZ+N7CSCB1 mhmluYJrjdj/AJ6FckD0Iq/+I64x/aX3Iyl9HXCX+B/ezk5P+CMvxLgeK6HjDT5ZwxW4R/3rAMwD CJ1AVcgZ5GK6C1/4I0/EPRYrp7HxfbStfH7kjQahJbEk42kDjrzzn8qf/Ed8XtzL7l/kTL6OmEit Iv73/maD/wDBHP4pX9obW417SpCkqx3M1xKro+DxJFGMHOPc96juf+CNvizU7uO51K60S9kts2lo sciWkMZQcyeWc7snkcVrDx4xV7cy+5GT+jvh+V+4/vf+Z//S+4p/+COvxQ1exa1sNR0vQL873N6k 8H2K/wAAAZjKZVsADIYVBpX/AARj+JFlEljd6/pd1PdWzu9/YX22WN1zwd7ldxx3UjJFf2QvHnFc trr7kfyevo7YZ6uD+97lWP8A4IxfFjSrPToND8R2kqPcPc3EGrXEEsyBnPEjEYHc4HqPerP/AA5Y +JstzqQ1DxbbxxXkysv9g3sEaJt4JKlWOCP7hU+tWvHvELqvuRk/o50JK3I/vYp/4IufEDD21v4y nH2eTZb3OoTW7GUHpxs+YDvkg5/iqyf+CLHxdjaeC18ZWL2lxpwgmH2m2jiYpnL4LfKTnoBz68Vs vH2vbdfcjnX0cKLm7Rl/4Eypc/8ABGL4jXGn2q6l4ms55nVo5BZG2e54PBOM7eOw46VQj/4IlfEC 2iu7iDUlYyqVt576/jeWBSMFfK3Bck9wBWi8fa8d2vuQ39G7DPTkf/gTP//T+zbX/gix8W5reDRx 400mGacs093cWqI6pncIlw+B0HKjnuTXTS/8Eb/iqsf9m2muWltYBgY7tViuY5pMYZHXGdnXrjHr X9r/APEfqr3a+5f5H8fP6NtGnpGD+9mNqf8AwRZ+JF1cNaXGr211p1wQPNtnC3Gnsq4bynUhgCcY yDj0NaMP/BGr4z3ZzDrkdjZ2tsbOW2vkt2luDgBZFlJB38KSTnJB45NW/pAYjuvuRg/o10L/AAS+ 9/5i/wDDmD44aPYxwnxppElz5B+zxRwQywqWOQj4Oc478gVpD/gjp8aJ4vKvdV8P2yQQgXFxPHbu shZQHMRXBzlRgHpgcnFJ+P8AXb1kvuX+Q39G6gk0oS+9mW//AARf+JMkZWX+xruxcHcBBHJcvt6s XL4GfQDNa8X/AARZ+JK29v5fiPTdGh8ldlrYeQsBAI2RqjBirDHJzzVf8TA4juvuX+RC+jXh+tOX 3s//1PvVv+CL/wAYUubqaz8T6VDa3BxdS6jcRtLCAcEJDkoQeMY2/Ss4f8ESPi1Le3wttf06QR2Q Sxa3tLS1jXIBIA4ByR/GDjPFf25/xMHiUr3X3I/jlfRpwnWEvvZ0sP8AwRQ+KMum2uj3niHT7OMx iW5X7RCvkMBncki4K8jkYNLbf8EYPi2nm6ZF45dIprcR3ASW2ntZlDfKUdkZg3A5Iz15FL/iYTEP 7S+5FL6NeGjtCX/gTK8X/BEj4oSWczN4xtbbU7IN5DPbwWdvdIvCoI1OCcc7zzS23/BFj4p3EVwl v4r06xmtYw1rczQW8rXDY+eNVOVIP+0OOxrWP0hcUlo19y/yM5/Rrw90/Zv72WrH/gi58UNKdzJ4 x0yNobPznlBEhdpCQwMWSqsO2AAKtf8ADlb4wNLC0XjXS54ZJg8y31vb3M9tgcFQy7ec9hxVf8TC 4nvbpshf8S1UHr7N/ez/1f0P1H/gi18RZVkW78VfaUdWh+y6J9l0y5GOu/ai57fcYdORU2i/8EUP iXB8i+Iori2Nr8ttrN5HcGNweGLH+7j7ucV/ca+kRi0rc3/kqP4tl9GPDylzezf3v8tiyf8Agi98 Ty4huPF2lwSKhaeS3itpo3wcjYC/y56fKBVq5/4IneKp7YRL4wtriGdRcXkBt7a3WFicFMncOwOR 6+xpf8TEYxdV9y/yM/8AiWLDt/BL72YY/wCCHvjuydI4fHENyiBfIja9jH2ZSeASFwzD1PYV1Lf8 EV/F6R3EI8eWVrLFEscZkmilgZh1kChCT+lD+kXjV1V/8K/yOin9F7B/ahK3+J/5lGf/AIIgeP7x 0it/iBplskpE8ogjSK3mcLy29QHAOBlTnrVyT/giR4uaOBNR8e/bpGkLyPaXcEHlOOhDNGx2+q5r GX0i8e/tL/wGP+Q39FvAL7D/APApf5n/1v0+k/4IneJLzSoIbrxOXe3mybm31eCCUL0B2rEAce+T zVeT/giN4vsbH7NpfjHT9Qit5GaBtavTNdBJOW2lVzkZOMnAr+2l9InMekv/ACWP+R/Fr+i7gP5J fex1j/wQ68UkwsfHdlNLaXC6jbJepFcrG+MFGDqQwz0yOKY//BETxhcXd7c6l428PzHVNkTiMi1S y8o53RoPkDNwCQM/L9aT+kTmSd7/AIL/ACF/xK5l+3K/vZnxf8EMdQuWE954z8/Ure737herBa+U h3IoQDAHb8K2pP8AgiJq01757+PtOije7Fy6QzPOqtjoysmCOOQDjpS/4mMzb7Mv/JV/kSvot5en pF/fL/M1of8AgijPJHJaz+LUdAC9lfRyrZyRc/cYpGCRnsc/U1m2v/BDSH7as3/CZK96rs15Jfgt bTH+Ag7ScLj0qH9InNndX/8AJbf1/S2N4/RewEWny/i/6/rvqf/X/VqT/gidi/GpWXiayjvSQlzL Gy2sflhQhKKI1HPqQTWxN/wRc02bdJP4iivJEjEm211FbaR9vZyYsH8a/s6f0hM3fwykfyBT+jJl i+OCI9F/4In2T+XZa14q36Yhl1G3fT9QNu1q7E4jkKRqZMZ7nA5pll/wReEUb2y+MoZYJ7wvFHPc ys1vEp4RSVJHHXB5rN/SCzh/bl+J0R+jNlWl4R/r5F7Vv+CJPhOeeCa38RXK3kzg3Ys7429uAB3B XB/Krlz/AMETvBVxpkNi2v3JuLOUTQ3FtMqzqTw6mRlxg9SMc4+lZS+kDnS0c5fezT/iWbKP5I/1 8iy//BD74Y2wu49H8TC3nuLVUdJYZXZH2/MyPkhCTn5hVuy/4Ip+A7aQf2lrOmXSiJYGukQ/aEUj B3hUXc3+1kk+tZz8fs+t8cvvf6G1P6NGRRdvZx+5H//Q/ZyT/gih8K4beBTrZknWTBCyTIojGRnO cHj15962NP8A+CMvw0S6VtI8YXpWN/LEVxOZMgj5htKHPt1+tf10/HziFqynP72fy5D6NnDkX/Dh f0Q7/hyj8IbaRmOrm0jS6N5KiwvClzK3B3gMBg9yMVpRf8EcPgvaXYhh1JZIr5Cl5ALeS6iRD1RP MLEd+hFYy8eOI5e6qk7er/zOul9HPhik7ulC6/uokuv+CKvwFazZY9auYImi+zvHBZyQtcIWyQ2J McdMDFatp/wRt+AlvLI1pf3M8kkCwLcGBlFoqAAIAzE849a5X41cQz6s9OHgNw3T2jH7jQn/AOCP XwRCxSy6hOs0aeT50Wmx2jbPQ7GAJPqfxp0f/BJH4BTIwhNhJK0fkTST+H4rmYqOCSS3JOPvda55 +MXEMnZ833nXDwT4bhpaP3H/0f37tv8AgkH+z5p0t/dWb2kMt5EiNDd2cJijI6hPmO0HrgAVJF/w SE/Z4824uLq7/wBFkddsVvEsUTNjDDAbkexr+nH4u8Rt6cx+FrwX4bWnufcjVP8AwSQ/ZgE1q87X DW9opiS1mtovLPHBwXwG684zzTj/AMEk/wBlqC6S5KRwhkVbYSpH8pzklRu2598ZqZeK3E7Vlzfi XDwc4XS15L+iOnl/4JX/ALMcMbpbpdW4nt/Laee5hj84HhwMYxn2ORVBf+CU37KLmWW/trnUkZVR vtU9rPbwFOM4cNnH4Vk/FHil6Lm/E1Xg/wAKW1UfwNU/8Ez/ANlu3kjklhRhDgoZRaNblQMACH7m AOwHapH/AOCbv7LXlJPfW+hXjq3+jZ06yto2X0IxjP0rN+JPFktnL8TZeEXCC0ah90fw0P/S/pYs f+CcP7JlrcSTQ6Fo4iuIg25/spjUrzlegwPStk/8E9/2VZZLGe+03R/sschWGOSOyjt7jPGGyOeP Sv6MfiDxdN3Tl+J+PR8KeDY/y/gQ3f7An7IOksYYvD2hW6wtv8i0NsCsb8/Iq9M9c4NTy/sK/shi 1crptnaW7MgkjhNquc9AcpWT454wn1l+JS8MOC4fy/KxeT9jP9kSAmK30Pw35O0OhFxaw3KsnDM2 0cnj0zW5b/sgfskxaZ5MGn6BKBIW3SXUDqC38IHUfz9aylxZxnU/m/E0h4f8FUHo4/gLafst/sgQ zmZfCnh/7TaHdNdxTp5cuBjnb6e9Wov2e/2S9LihdvD/AIOt7iS7a5guJZYYWUtxuJ78evXNZPPu MqmjcjVcJ8E0ekD/0/6nW+D/AOybbXU9rdaV4I1SWZMsYZRLJGpbjds/rW9D8Jf2UIS5ttJ8NzLZ x7nRHEqQjGACcdumOa/eXmPGU/5rejPytZJwPDbl+8pW/gn9j6J3s207wPA8mcPcShGTPJAfrn2p zeDP2QY5REbfwdLGuCqLNypHTBPJ/OpdTjSenvDWC4Dhvy/gSeX+yLJeRWkOm+Cs3B+zOIrJDJCQ MDcTx261Pj9khDsjtfBO7S/3shvbWJmAzjhSeR+FCocaS35vxB0uAIr7P4EEfiH9j+ado49P8BNN Cob7ZdaTGln7fM3yg+govPF37IVqG+1N4IijmbZ5sFnHBA564DAjI46GtFlvGcus/wATJ1eAILaH 3I//1P6pLT4nfsd2j3VxHF4VCyRbZkl0tWRtp4KZOB65HNWk+N/7H5hR/tngLzg+FspIID0+6vzc Kfwr99WR8Zz/AJz8jeYcAU/5PuRnJ+0H+yVZ3EOmW+q+E9OlcG4jtRBAquTywDDg9OlTR/tIfso6 dcyR3E/h21+1W5kMpsrYhiO649cdK1jwrxjPfn/HUzef8B0tFyaegp/a3/ZYS2W7W90eYQ/6LJI9 jFbpEo5XJx9Kwb39tP8AZig1b7OmuaGLtbVbg2ls9vdbVboxUZwDjrXRHgbiyq7e9+JP+uXBNFe7 yr7hYP25v2ZrGdAdT067EluxYWdlC1unqHBXAP1/Ws64/wCCgf7N6E232zTbWCMCZgfs8aFD3Axx +IrWPhxxTP8Am/Exl4hcHU9uX8D/1f6arr/go1+zLZy+dN4g02VxD5lnh1lSXb0UYXGfoay5/wDg px+zwLg241B1dolmkkMBisYozyN7gYH4mv6Xh4VcUVF7yl+J+G1PFTg+jonF/cVl/wCCov7Plyri y1CycW64jlf91FIQcARPjHOD3rP1L/gqn8B7C4t4pbywhDIH8ubVI4DISduEcnk59uK6Y+EHEUnZ qX4nLLxm4RguaLh+Bg3v/BWP4H6fLPCRZwPHKF8u5u2WYA85BOAwI6bcj3qnqH/BXP4N7/NithNb MwtYZ4rk+fG2BkADqPXGa7I+C/EEuj+45p+N/CkL2cdPQxLj/grv8I7ZGupoYJopG8uGMzyxTIQM YI2g/p+NY6/8FjfhFDIwhsIbg58pbgTSJFzzjOOwPPNd9DwLz+rrGEmvJNnFV8fuEqFlOpCL83Y/ /9b95f8Ah8l8N55xBbaBHJEhEcs0V2sqyN1IGGyc+wrKvP8AgsR8PFS7vja21rZW/wC5axLMLiJx 1y2DknsAK/smHgLnSfLOnK/az72P5mf0huGXDnhVhbXqraK/5anOX/8AwWU8Hb4Fj0WWWOaVY7W3 NvK5bI4dmVcY+pz7VzE//BaTwnFLcW0/hmMNGWhUHfC3mr0XG09e2cA+tejT+j/mr92UJHn1fpG8 Nw1jVjb+rGFc/wDBcXwvawwpJosekhGP2uG/t3mckHacFU2gemT/AIHMvv8AgtJZC5igi0NXbUAG sp7W3jePBwfmK8qeRwQD7V6dL6O+YuzktH5r8VfT52/E8Sv9JzIoOShPVWvaL/B2s/lf8GUrr/gt PcGQWo0ry5NNnWG5hRv30mRkMTsACntlgfaufuP+C1GtrqKWyWk6RXJJVEI3Ii9dp2soP+8fx7V3 0vo64nRuH4r/ADPKr/SfyxStCo3btF/5H//X/R26/wCC0/iiPTtRuHtbopax+bZKztcTTl32IAEj YAk44bgVxyf8Fp/iBNJI/wDZmozqsYCwOkcG8/xAPxyOvSv9DKX0dZK/tIr71/mfwrU+k/hdoSk/ +3X/AJFQf8FrPiTfNc250DVNJtYULR3B1SGYEjgbmKqRuPGM4qif+CxHxdt4TLdaPJqbXKGO0Kaj BCbWQfdBO7HPsSK9GH0daUXZ29b/AKHmVPpPxabipaN6W380crF/wWl+MrtDDPpt759tcgS2RuAk PfOZVJGRwcY59qT/AIe5fGhvLn1C70yxkvLlpoSNWnW78tW4jC+WULdeNwPHQCvRh9HnBw15k/LX /I4JfSdqybXJNLvp/m/yOZ1X/grz8b4pJZbMXM2+62owvUaQRcBndMEnqeBjtxVY/wDBWr4zXggS x1PULc29wyXAu0EsW08742Zc49uv1rup/R/wEfilHz3/AMjza30msXK/JTl5ar/M/9D1m5/4Kr/H +G7uJbTX4Fiu1aEOpLXIZRnG0ooVT2IrlLj/AIKcfH5orIar4t1GK6EpllisJsI7MflLu0b9scDp 3Nf6o0PAjJIK9Rq/pfv5ryP8wsb9I/Pan8GL5dftWfTyfn8rEjf8FLP2g9VWO2k8ZXASDMsc0kaL euOQImlVBke/FcdrH/BRr9o+1M9rdePYES7tt1urNL585D/LEDuIBHXsPau6n4IZBDTp/h/4LPHr /SG4lnrHT/t7/gLUy9R/4KTftI3Mdla2+o2r2VoR/aEzzM08xZR0YIp4/wBrPTA9ayrn9vf9oPzr Fm8VrZW8RMzzI8pDk525XPPXrXZDwW4ehuvw/wCCcM/H3ieo7q3/AIE/8ilP+3p8fbmKRZPHdwL2 SNgHt28xYDngkMMncMgjIxWNdftu/G25kEdz4w1hY4YEynmfZWZurAFCPl9zk8ivQo+D/DMPjpt/ cv8AM4qnjpxfUfu1El8/80f/0fINZ/bG+MF1PpsOl+NdfhtzK76i4vneSRcDbFH8q4Ge5z34rIuP 2uPjOrW5uvEviGUxu7ZGsBIpFx8u4bSd3Tvj2r/Yin4T8OU1Z0tfl/k/zP8AISr428W1JPlqq3z/ AM118thyftT/ABiMMjDxdqxivVDlr2+bzbHPVV2KMj6+nesyT9pb4h3ENtaweJNYW2hd5p549TNq 5kOQQVAO8D0LDpXTDww4dg9KP5f5HLU8ZOLJ7119z/zKa/tE/FYyXZj8baxFYyWqW8EYuWHln+Nt 4IJJqoP2hvG8+6yfU9deS2wYLu51Q3NvKSPmYoRnOcjBJ+tdsPDnhyP/AC4Rx1fFriyejxNumi/z uV7v4z/EGa2sfO8UapdzWZYKTeMhw/UKoOAAOPTisiP4w+LJxmTxNrclh5OIbaO7YMjA57Y7+orr jwJw/FWjho/j/mebU8TOLJtuWMl/5L/kf//S+N7/AOLvi9JLab/hK/FF3FADjTbvUR9k3ORyVVQx bBIHzYGayNV+IWv6xeI91c3pjWH7OkP9p3ELIp+986uOT3r/AGxp8F5HS1jh43+f+Z/inU8QuJaq aqYuT+7/ACM638TeIobiC1tPEGsRRyQPAYnvGuE2HJKAtnp27/lWrF4y8RaSnkC7eVGj+y3Rk2yv cxEn5TuyM88NjIxXT/qvlW6oROX/AF3z9K31mWmxBJ4v1R0igt7+8toyDtSHCiHnPULwffrWXceK /ErzRy3WoXV3crIZVuJblyMjhSRn5uOMGuqOQ5ev+XMb/wCFf5HnT4nziejxM/8AwOX+ZNa+J9aa JbMXc8stzMWkVpiIi7d9pOAPanXXinUbo2kUn2VdQ05miQ2tulnGzFdvzlcFuCPvZrVZLgV/y6j9 yOWXEWa6xdaWv95+umuh/9P89S09kzl5t0twfMlxMXIOc4LZz26UybXtRa6UzPb3UZYFp5Yd91GA CNqnpjnv6V/uisBRW0V/X/DH+EE8xxEt5P8Ar/h395KuosJLf7I9wogkPkqpMZ3MeCoB69fzqor3 Nj51wxuFlu5WdhcStcLuzyQGJA9ePWtPqdJdDF4yq3qzXsdYuTHKt7MLnzYWhdSPLznOMY6Y9utU HCPHHDKxligbdGsrmTGOnX0p/VaaQLEVr2ZXmsbW+gmuLoo20gQxfe347bc9Kp2dxcyXSK8gENtl IY4/lZVK4C/Qeg44FDowukV7ap3P/9T85pLzBKyznyo3KhOvzNxz+lWYkMYZZCkcauGHlvhR3Xoc V/uysPBbn+Dntp2tcpXcs6Xlw803nCR0mhaNum1VA5Hf5RVuLUZ2tfsyCQl2L7GfLMxrRUoJWsT7 SfczpjefuZZWDsi42RgqidiMdM8dafHEt063DqFmgBWH5idgPBwPfAp8kew/azLCLGhlEhkJch8F ztBHQ4/DtVeaYOpMhMnOFB529qOSInOTP//V/NhQW3wRO0ClSyuH8vIwSQMeuMY75qfTp71ZwZPK +z8RokYCMVXGc+9f7vOMX0P8GLvuOuzJ5ry3KhiBm3GNrKOx/SstLsvKruWyB8yE4K/4VnOnFLRB d9y2ks87syEquMcdQPWmNKCTN5gwnG8/MMA81nyRK5pWLSQXEvmNazXLxMPMdTIfLQY5OM4HSpba 42PbbrmUIZQ37pixXB6sB2471SSWxLbe5//W/PG6vLnVtRuEgYyn/WrFI6oY1UcnsO2cVnzpdxvC 6zBIuRIoILN2x7V/uyoq10f4ORk3uOjnaaT7NyQ33TzkY6kVWuLnLG1gUhARmRz+8A5A/P8AyapJ c1iXzIs6XFcPd+SSPIMZIcyYDkdFx74plzPGoeOVZYJUl2xRBfmJHvngVpZdjCad9DRtJpxLbATB VZdwWY/uhjruHpVSe1vgDcpFm3PDSqcgNnpgdOneplZK1iFfZH//1/zrtrSVUWR5FlJQybIjv8od MN6H/EVFLfiBJZfKEjW5wY2XIJwD0/EV/uwf4I8r7EKM8vzgElvmRUB2j8arW9ncpc3MiSSkuw3R SyllUngBFP8ASgVmtxY2iS5mWWHfeREZfGQmCePT1qctdO13PJIoQjesSDysdsDHHf8AWqv7tioL UuGF7yC0jFwFtkVn+zABnLnA+Y/hwPeq10EtkQICWI4J4Ujoak1P/9D85A1s1rEwWUzKSQ/mfu1B /wBnGf1pEm8xCkjZVDuC9ifpX+7B/gtbSzM97xxeQ2/zSyzNhUUHKr24/IU91fzJoFVkJfJE5GF4 6DPTp04oF7NEobESRZXMn7tgxIUe/wDOrM9q9mwleaCRNp2mGYS7x0yBnI79cVEnYFTd7Ioxx/bm UqGSRHwGzw/T/wCvVmWa7821sbZFwC8lxcSNwQAMKo9e/PpWRbjJH//R/OLzMSsZQW2jBI65qG5k jlgVYwsexy7vt/eN2xnrjviv90D/AAX5Xe9iCBwNzllG0Y2NznOeQP8APWrr3DOhnDsY4othcZwo APH86V0lcrkkVYLRpxLIjNJhfMKnqg+n+NWnub7RUhmgIhlu4ybaVlDoRkqfXBypHrUc+nmXCm7k Ut3dTJKjytKZAGm+bIc9efpWRHLPHINiFxuwyA7SB3NRzPU0cJWsf//S/OItGybVXtkjPIqgIMvg ZZuy96/3HbS3P8HvZN6FuxtG1AyQb1SONS0pkOEQDuabDqFzazweUphe0YhXxlZBk9e3elzR2F7G WxTumRpSAxkd3LFuSMnr1579KkBmsZYRcGKSBsSRtHh3TPUH346Gm9EKMHzKw7VbgT3NzdAzrbXd 0URwxkmZeMbh2PPbjpz6SQRT5MS2rMqrkyBNskQ9T/8AXzTWpt7Nn//T/OWHUPIXyPKVwjZSYKPN JPGCe446H1qpfwTr5dz5iZlnwLKIYlRSPvY6Y/Gv9yD/AAi5GVIFkZJWjkLx+YV65Ze2DUyvc2zb kK4xypG4Nnjn/Pek3ZD9n5lKAXUkhjSFycF2kRcjH/1qjaFCWWU7mByu7+E+1Y3ZsoJK7ZcSS7sE tQyg2xZnVJBvWTp78dqvX+utrQvRqQlm8yJVgCssaxkYA4x0xkf15pB7OPc//9T8zrWIXBhijt9s cahSASzOcnnn8OlOkzDI0SgFVOAPWv8Ab6Umuh/hSqcVsyJ1QFWkXhWD4PqOQa0jctLDOsNtAokU OWiTMsZHGS3J6YGCcURbe6JlTj0ZnR713u8pCjgrnG6pZb4fuwhAkTDFh97bnv8AyolzbIiMYpq5 DIzz/vkQNtwWkAzx7+1DTgyEzBmDg7mTAOcVm1LZm1odz//V/N2W4KQWiBmZlQiSMtvZeeKzrqaF rciIMZGk+ZWOAi9/8a/26Tktj/Cvlh3K8JVPkGHQDGewqO4AMiRbiwAJAOSB61JcYw3JTFC1sM3M sdxHISsaphHAHGTn9KLS/WCQLNbrOnSRHHBx79vrQU1HoQMd7GYNsw3zdxj0p73UeHjVixzhA3BI 559ulAKyep//1vy9nJV7eKPzC7gs/wAuETBGBn3z+hpQweZVfamMIxVce1f7cLzP8Mrw7FyaAW8m Y5PLkYbQS3DD6fSooC0du6XV2J2L5iRY9mMdC3Y9Tz1palRUbaEEkiiRGhY/ucOGxsKnv+vSkeV5 G3A7vb1PpUqLvdsrmivdFjsJ75JLhFZmjPlyLniH6+mf6U3Yyo0bjDLlTTSad2wupao//9f8s47d 449wyrkF2IPCjPWn2++BvO/1jI25c8gkHvX+3B/hvYuS3TS5keJSZSP3RYgL7++Kyt7teSQiMCEn CLEd3POaVh3LVrBaxSyTtHIZjH5abX2g4PUjv3qOS4jK3LEFiRtMbdtvPy9h/wDXotrcvmS+Et2U tnJbpLLMkck8ZeGB3AlGDg5GeD7f0qibqQ7kwxjSX93vGM47imHO07NH/9D8p7qS5uJ/Mjmi3Fv3 rOuSc8nHoanuLOcXS2yQTXHlxea72cZmZ8DcOnPORz296/24avof4f3tqVY7UpK8k25BLtlEJyrQ 8D5T/n1q5Z3cxmuTFA32eH7znoRnH4c1Kgkxyk2hs8oeNgVUBjnBHSq8bGPdcygvHGOQvJxQ4oE2 tiQyxbJHUlMjchPQ1HDcxwQLJiQ3MUnmBjJuB9gD+FZSjZ2HzSWh/9H8oxcm5eaQYLO5mbdwR6gU C/i+cOUC7tjv91FP9K/2wP8AD8hnt8qJFliXsAD87f8A6v605YZ44BNviZBJ5BwwLKSOpHoecH2p WRScloipLCpmFnCT5gG9ZEG4EnnirCrJbPChQtG3EsrHaEwPSiyQ05XsRX3lKwFtffaoixcwqpSI 9MZJHX6VZZ38qGNigDJlVVtwXPvRyrsan//S/J+CNIkcPIF3P9KnWHYJCnlsSNytn5xjPA/z2r/a 9uKep/iJJSvoUZQ7geaNx3ZJPXNTi6miglgSXbDOFEq4GG2nIH+fWpk42G+boJ5kMsPky7UTbsVg Au454yait7XDTvGCHiXI3L8h5AH86ybSKI723mUW1yZ4pZJFO6KHjySOMYqojGPBO3k4K9wfpUKS VyHGT2Z//9P8kVALl92Ow5q9NqoCxq8SERxeUdg2b8DAJx39/av9p009j/EVRlszIa6uYyJ0j3xo 484Nn5VY4yP0rXaKK4ltBHut7m6j2RSljtnyTx078j8KZootlViziSERhzENueu3B6j/AD3pYI5b hwsNu5kI2EKMjgf/AK6B8kuxQmllLcHai8e9Lp+q3llL5YlcRSnJLHfj86AUH1P/1PyMvpZVlYJI 00ZYsZUHY98Yz+dRXl7FJbqLUzStD8ypKfLJfHPfpX+0zfK0f4nOi+hsJeobaGJoUVp4gM4JKuP4 R/jUEJuUW6txbSsygecyKcwjtu+tPmQlRfUy7Se6uJZLcIZNr4Q8lsVbuFAjDhGunjYK1vERvI/v ckcCom1ayNFRdtEPaVRbQw/boEiJZ/s24hkbjORjkkAdM/hVCJopHMe8BAN3B64pRmktQVGSd7H/ 1fyO+1RssSpKr2iviRkbcOPQ9M9ap20sdtd3c4CP9r+Uc/6pQOOPx/Wv9n7ruf4rwoz6o0I2MUTS +USgbHm7coPx6VahSa+mIihbMcPmsFXhU/vH296j2kO5r7Co+hm6jpks3kWlpdRyTXc+x47U+ZOm CMAkdM5NV9QNrps4tZc27IVila5YKqyHtntUOsluzZYSq3ojOg1N471rGNtwkYq8SN8spXqR2OMd a6SCaSxvLKa9tIBpomQzm/j3W0gzkKe2D3pxxEFq2bLBVnpyn//W/JfxFqdgJZrUpHbwRtkywxNF asGOQN5GMDtk15+NQhjupgkwlhWTbD5Z3+co+8Vx94DuR0zX+zssVStZs/xtWW4m2kTotRvdN0fT Y7uXUoBJdSKFs2m2ysSM5A6cDn/69R6xepbJaowjl+0Qg2skKZ85mXdtUgZYj8ayeLw8d5o6IZVi 2k1B6lFdRRLeCOcIJpkLxRCRTcMV6r5edwIxnBHFR2PiCzYSXPmWwgtblbVvtNxHEru38OC2T+Ga zlmuCpK06kV81/mbwyDMqz/d0pP0TfkULvxDAzulzcWFnNb3awMst9FG22T7pILcAY6j1qSHxloT tew3PiHTraDSZBAj3ExEV1liD5AAO4DBPHHPvXHUz7K4O0q0V81/n5HXR4Uzmabjh5/+Av8Ay8z/ 1/xMl8deDrF2mfX7W/tVlHmR2bvC8gJ7Oy7f/wBXSqt78VvBlnfW0+n6hYyabesTCP7UjvjEUwHW UpyvJ6EZr/XetxTklLevH5O/l0uf5L0eCM+qvTDS+at0v1sU7v4oeDHuNOlm8QaebHU737M9wtwE tYFBAkLMxypTcDjH51lan8V/DdjI9l/bWmXdjD5ixXNjILiN0BISRnAyARj/AAriqcaZJTi37ZO3 9aHo0PD3iGo7LDv8P8zKHxn+HCpFa3vjLSbGUhmzN5rfKBnONvQd65cftCeAprO58nWEvYluDa2Z 0sGaC7K8M/OODivNreInD9GN3WTfZLX8bHsYfwv4jrSs6HKu7en4XZbh/aq8JW//ABTVrrCGKC1W 4W1nH2aSALyVhwCFwSwI7+uOazLz9qDwFqF5q8Wn6jffZPKSSJcR3huJSAJGVlIwFYNwM/WvLreK fD0brn/Lp8/8z26Xg9xDOz5Vb5/5H//Q/nMT9o3wVcm3jgv7+U26bJJxAkNuWBPU5P061FB+054N uJb/AP0fUtRvrMh7i0sLyKKNl/2XdTk4B4Gcetf6U1/GHh2m7e0X/gSP898P4K55KOq/8lZQuP2s PD8ka6dpehXVhOXNw7XR+1ShAD+7MmNmD+dZVv8Atf8AgsXRjg8KXl4nGRaawI4g2MFIyykkgjOD kc8V5VfxryKnG6af/b3/AAD06XgZm1R2nK3/AG5/wRkn7XcDS2v9m6K7m2DSPb30qLJJzwrYC5IH 16VlwftbXg1PXLi28Px2Ed9GFK3CJIuRtLLC5OcnHJU9DXzuI8dMt57UmrejZ7NDwHxKSc5P70jl Lr9rO5j/AOEjv28KzXV4xWWwjk1JILCNg3KqACxAA6E1He/tU+MNW0yXVLfQvDcBGxHgikQS2yrj aAuw7Sf73Q9K8LE+OsbWpR+dvXu/8z6DDeBVBNOtLbo36dl/l5H/0f5TNN/av+Id3qLTayqWtvP/ AKWkkMkV5FFImAi7GQDGOuc59DVuy/ar8c3FxeztY+GliuR9muZbfTUju5ED8uMKFBIHIAAr+uK/ jpmK0pq++9l+SP5kw/gjkejqx+5y/VmaP2gPiL4w1uzt9BvLexs7a5W1uNXvbRVgjiH3goXb0ORz xxxmtfxN8X/E3hG0ijtdb/t7VLm73GaO7VURGbGSB90Lz7mvGq+NWaTpzmpNNbLm36eX9eh9BQ8I cghG/s46d4r8Dnrr44+KNH1F79tZil1MWyzW7qxVckZ2qQxJJBwck1yN3+0X8TNTsZI9StVs7l7g 3C3ZvWZDGfubYyDg985PPTFfPYjxl4imnFT0fe/+f4Hs4bwx4bo6qir+i/yMX/hdmuGFGGp6jauJ Q091YX72szMP4mcHn3AHrVHVvjF4n1DWIVvtR1BbYwKyXUdw5nlYdA+MDHvjPvXgYrxR4gxEXH2t k+356tnp0eBciwz5oUtf6/A//9L+MJvGXjMzXf2TUrlobskss2oTFOeo27sjtyKD448S2tpZo2q6 wWsC4Wy/tmZLd95O7dhvmGckBs4r9Fnx3ns3f6xL5M+Cp8NZTFcqor7jMh8X6+YLuWXxFrNvLIN0 dk1wbi2YZztJYk4Hp3psPiDV762thf6rqtzJbSFkn+2yJJ/s/KCANo6Vwz4tzmbfNXnr/ef+Z6MM ly5WUaUdPJEs+q3suy4vdXuJ5AxhhMspM0YAzjOf/wBdZct3bXEhae2Se/QeXa3cUjQNbDdn7oOP 5VyVs/zDEfxqkperb/U6o5dg6K9yCXorFuXVStqI5baF5UYsk7LmRc9QPrVVNfv0sb6Br6eUiECw jwCls2RxjoOM/QiuR5lidlI6o4Kg9on/0/4rNPvLy4tYoBdM80w+aEPgMx71ky3cccphndpJi5xH I25MjgnnPSvYlj6zdnI8z6rSgtET29zdLcRTT3TtzsgSFjtAOB0zW7o1lqk+sT6faXd5bJqMgAaR Nsc7HAAPp6n+tZfW6r3Zm6EFsihaTNYXczTQwXLjfCPNG5OeNwx+YrIuGuHacq7QR7vJVlkwzA// AF6Uq9RL4i/ZQLLTNtSMS/LnYRtGH7c1O2mXk9p9thmX7FDcCC4y+xo2IyOM5NZ+2k17zHypOyWh /9T+Kl7K1YOYsNcQxkrIoy2PQfWqUcVvcx7polmWNSoAwJ2boMfjXoqba0Z5kEmtjPMkiqwVt204 MY5MY6c0+FYE3XO5X8sASQ5Ads+n1pcz1VzSK10EhCKvmQjyBklsMec9jXJ6zKF3I2WO7IJHBrHm Zs9jiVid7gR4G1m79BV2LPmSKuGwdpfsMelcld3nccVoon//1f4PobZprlVVlj2nOWYAZ7/zr1Xw 7aSJHskkJSQj5c5XI71wTu2JLlVjbvoRJG8ka7mjBwT8m4iqdvezKqJDGCCAJG3fMCeOB6VzDNyz 1O6tEkSFlk8w4kjC8gDrzXX29vutoG+cyTENkDG3IBxisZK0mBl6q89tcLCFZcxFhJG4+fORtx+e frWPpkW1byaO1maWKB2EJi2tu5O4du1SB//W/jWjvZItJNxJbRpdBQ5TkZbIwT7/AOFWYjr15dDU S6T2DWw88StiW2PAUqe4I7Hp69q+fIUm20SRj7I2pXSlFaZRt89dyQBR1z/WrTy2mpWsM0043C3C pPbxELkdeMc9+uaynuZEYt7f7NNPZTSQNkRC4FtlGY8Bmz/KtVzdiG6uJ5Ir+4trRbdrtICI7liM AuO3P6Cs5OyGkTQ6Xrt1pEGoW01pGXlNqXQshhYLk/LknHNe/wDhZRBpVlLJqYuGtLNkuLTy/kfA xl2653ZPHTJz7c2IXuv0f5BTXKz/1/tT/gix4Vh0X9n7w3JeQ276reahPqNxdr+/umRwojUHHOCi jB6c1/RpZOEs4XYkmRAxOOckZr+RNZZhiZv/AJ+T/wDSmdeEp+zlOIBYpmIyQByauwPGqbEy2PxJ x1rvhsjeTuxJ3UgAEAN37ipip8hRH1A5Jq762JM9ZMOUY5A5xVuOVZG2gDAHLZram9bMD//Q/eL7 TNPMqOcyMMYK8L/nircEKiS4iuG2zxgh0DY4BxkkdK/leu2locr+JEaLZpDlnyBJn95IXx3GATxX JeM/K/su7S4ykclo+8iIzjbtLLuT0ztJ+lcv/Lq46i0aP49P+Cmtl4gh+JGoXWo2dnBAvhdtS03U F2JuidyHAVf4w9uCVxwPY1+J99rVtcfZLS7g/wBImIMQkYMytjhvXNfrvB84vKYJdP8AM8/ANSU5 eZDZy2kdxcRNPDdNMyrtTh7Nl+8p9T6/zqK/0O3kkl+wazHo0sytLOzr5xlC87dvJ5I9K+0Wx2TS TP/R/jR1RtU1PTXsY7VbeK3VZriXzBG1y6HCOOeeD2x1/K1oiXZsb+3kSLz7WAXz3FzwqKnOInPG 4n+HrzXh0+xzRSSMi9vzJFIqMXgnQNInUE45BH1z1q3BOba0jlEbf2EIhDBLdAwzecuMqE9Bxg/S tCZ7GvZ3l3b6roV4mpGJbcmZ40CyJMrjiN89MHnHvVa81bVL2/vbN47rTFtpnnU4W3huEIyQjdwR /D17daDIp2V7YWc5nmtobuWBN8Ec5P7o/wB5cHIqa6EF5LNrIhjikntgXMC5dwBkA464oA//0v40 V0C5gaGCbVlsVvwLne5PnqmNyhSOoP8AKt9NJt7RnlF3LqsElmZfPkxbvZvnHCjrjryT/h4555mX 91/Z8TWs1vuWSNLj7XMmfNU8r83TPtjvWtBq1tbxRag+YbCdP+PZVyyED+Edc+tdNNWsBPdzWUOn 6bPogGo3NzdyebfSyGN40bDFNuOfT/8AVXJeI7gXKQ2st3Hp9pMGeeJcuJCAepznjBrqpJXbNWtP keXTLFNJN5LgpGoGS/3/AKVz+qRuyIIT8y9QOjete1Tso6HHJWbP/9P+MD9nvWrKx8bafb3kN3PA yScWduZlilTYwc+hG3H4mv3s+G/ie11fTvB+rWv2h9N0NhczRXEJg3AEumFPQ5ZWwehr+0Po7yjU y/GUVv8A8A/jn6QVGVPMcFjNOVNJ+up+1vwi/wCCofjb4ReEdK8J6ToL3dzo9vvkmS4+yXDJJ88X zNxjg8j8q9tg/wCC03jW4Mt5qmj6gTN+5g0hL1bqRJVXO5mZVxGSOx4zxmvVzLwLoY7MKuOTjzTb fXq/T/MnB/SRxGFw9LBVIytTjGOluit3I4/+C0XjyWSNbbwvCb69jMTQ3uoY0+3K5+4+3IPHPy5r Lt/+CvnxNnguoY9Ggu7u3UG4OlnzsbnIKq7qDxj+AY61yPwFw8VpJP7/API9KH0k5TesJJfLf79j dn/4LG+MbJbaP+wbqK7jKB5A8l/bvvwoDqkLlTngZIHNMT/gr/8AEWe4e1W3tTBC5uPtzRxROgAJ Me3b5meMcKceorJ+BEOiX3nVH6R9KXxXXyP/1PrzUP8Agsp4xje0nOi61fmOITPBGj2auw4IWTbn 3zj8O1JZ/wDBavx1fRXt5Y+Fy726PBNbahqkczR7RnIh8tctwcc8471/bH/EB0l0+8/len9I6hJ6 833Drn/gs/4qv7S6Gk2+qahqFnbJcXWkuRpQhRuHwrR/NjnAXPsans/+CyviCGxMraLqMMkMqCBo pYvNlJXMgeNgSy9vUehpLwI0tZfev8zR/SLwje7+5/5Cwf8ABZ/xMxuE1DSfskF7byXVkkkjEnys HZny/lY+2altP+C2V3/Z9tf6dorCa6TebaHVQvmNkqy7XgJUgqeWx+VC8Beb7K+9f5mFX6RuHt7r f3P/ACLdn/wWe8a6ubdLTRL6yEs5t5na6iu44WA4cyRjB9MKCKsN/wAFivFFvo87avbQ22qJcPBp cFzqC6Tf3TgjJUeQ4K46EkCrl4BOKvFJvyf/AATlh9I+jOVptpeaf6Jn/9X7f0v/AILT+LZozZrp cd81lB9qeWOaG6mt36eVuKxhm65G0j0NZU//AAXB8RNILbUvBl3erLL/AKBcW8yafdFk67lWJgOn Rjz2Ff20vACd9bfefyVL6SGGStr9zOisv+C2viq4sI7i80WewSRvKSz1BreSVuflGNokbI53bR/W r2if8FoPEFzPDCNGij8jzZpPtDmxsJVJ4Bk8tix/3cY9Kb8AJ3vZfev8xL6R2Fdrtr1T/HQLn/gt VqNs0C3WnWqbE+1iOBftjuM4Kh9qg4z39as3f/BZ7xdZ6lcf2n4L1E6F9nhk042EC3Mkxk/iLKu0 ckcck5ql9H+rfb8V/mT/AMTG4bpN/c/8iW6/4LT65bQW93pfgaaVrqQLJbXlj9hmVScbi2089Ogx 6kVdT/gtX4xu45oW8DmIG3KxukEd00jg8AYPGemeateAFZ9F96Kf0jcIlpJr/t1/5H//1vveD/gt 7rl1diwHgjUxqVtCJFLWAtcAcZbKkbSeMnHJreuP+C1upWkdrJqOialo0uoHyo7U+VdR3JUciJFJ ZSSRyQetf3A/o/Vn0/Ff5n8if8THYe/xv7n/AJFw/wDBbphpVxjwrrlhcxr+91FPKvUgJwMqflz9 COKhP/BcHUre8Cv4X1q9uPscUCGa2SZRxj7S6DgZ7genahfR9rdvxX+ZMvpI4WP23/4C/wDIg1L/ AILb63pLI1x4ZvbpoJ8I4sIpBIJAGAKIWYY56100X/Bai5mSG4n8I31xb6vCJLZNNdZfszj+GQZ3 KeDkfWqf0fa1tl96CP0lMFd80np5Mzpf+C2esXFrEYvC1zbh5zC/+kQLEgTj5gw3jI7Efj0rQ0z/ AILUX00tn53hz7HYy7oZPtc0DzoUBy/IBOeMYGPc1L+j1XtZJfev8zWP0lsuejk1/wBus//X/UW7 /wCC0uoW1vBfiw066+0SPbwadeeXF5gQ435VcDp2Jpll/wAFr7t4rm4/s7S4i9u0TSLciSBJEGTE gMSYYDvzzX9xL6PuIt8Onqv8z+T19JXK00p1NfR/nbT9DJu/+C2erR2tiILJJYtVl8lWs2jlvLUD hmkK5GOvUZroIv8AgtVfJFJYw6LLPIYFEDNDH9qkbHVRtTA4681S+j1iGvhX3r/Mzl9JnLL/ABv/ AMBf+QW3/BaTxBc3UFrN4fFooJi8u4uId94QMkgYY/8AfPSmf8Pq30WK8uB4ctJJ7OQM+nzCSeV0 ZgoaNthHJOcNjpxVx+jzX/lX3r/Mxn9JbLWr87/8Bf8AkU9T/wCC2uvx2wupfB+pWtu08UYjYQi0 /euFVspmTbkqOmASM1ctv+C2msyqrLodknkPm6aa8jbyweBvUx8cDgcZrVfR4r78q+9f5mP/ABMv l+3O1/26/wDI/9D9N9Y/4LU6/NfWVro2lfaRMGe4njtljhtl6B2CjO3nHeqenf8ABarXJmhjSHT5 FtLki7mnml8mI8gb38g5QnjBNf3dH6O1e+kF96/zP46n9JrL7W9o/wDwGX+Ra1z/AILTeI7SJr2P wpZXENzIIs2s0dxNDkfejjUbyhxwWA6jkVBb/wDBavxJaRXd63hh7uK0sxLOtvBCVt8/cLR8np1y c+1aR+jzVl9lfNr/ADI/4mXwEd6j76Jv/hvTcgi/4LV6+73U93pNxPAkUc7xpbwwFYm/jjXeGbHf A7fnch/4LSaokUcMXhr7bIkx+y385hW1uw4BVGz82Rzxj8elWvo7Vnqor71/mT/xM5gY6Obf/br/ AMiLUv8AgtL4wtZ4ojolvp/m/wDLpbyRSzAqPujYzEZ46/pVOD/gtN4oMQkk0K2tpRl7iKe4e4uw OgKoI9vPGOe/NXD6OtVrmcfxX+Zz1PpPYaE7Kb+5/wCX9dT/0f0juf8Agtf4rPkW/wDYt7D5QIeO ytITPOpzhssQe3pgVzx/4La+OHmMFr4S18m0V3aQSwiSYdMsMBVAzzlq/v8AX0dJr7K+9f5n8UP6 UND+Z/c/8i7/AMPwvF0j7ovDF/BdWsYaNWCQw3/HK7vmyR36CqNr/wAFn/F0d9BNJZzXsUoa4mhk vo7m0s3zyhYJhmB4wD2rSP0dn1ivvX+Zz1PpP0r6Sf8A4C/8jR1D/gth4utr/TLJ9HigF2HLXckZ jgiOPlSSRVKc/hisa4/4LNfFQ3UltaeHrS8NhH/aCvb6mLSOXnATcYSGHI4J9a0X0doX+FfeYS+k 6n8M393kYv8Aw+1+M5tAsXgyKOdo2jt5X1O2CTSjLEyBmXHTjaAPan3H/BZr46ubd5tFtm8+2Qah YWV5Ct3DuxsYAjv6hsGulfR2oK234mH/ABM7VbduZW8lr6an/9L7vb/gsj8ToLC6e+W5jvbZ1trW 2n8ktKHI+VGU7CVGT8x7Vgp/wWg+KNxqc9mum6jtmiWGxSOGKxNxnAc7jmM/99fSv9FI/R3w7dmo r5s/g+p9JustnJ/Jfd/WnmT3v/BYr4xi4e00S0u4bez/ANH1RdUuYIJZDjOLVkdgR6kjI96wR/wW v+Jtt5l/d6TLHBaymw3y6yHlimIA+WLyfmz2Kk479K0j9HXCfzRv/wBvf5HK/pN4uOrjP/yX/MW5 /wCCy3xlazB0p/t5eWNFh8torqFWzkPM6qhPPUL+Pq27/wCCx3xWSNba1msZLaK526ibfV5ZL+Ft vzR+X5IVTn1Jpr6PWFj8Vt/6e3/B8jOf0mcW1dc239L1/DzMyD/gs38Y7OXT57XTruaKWRknsbq/ jUqORuMiszHOOhTNZmu/8Fl/jF9kvJlsppGtxhbW21MyS3Duw2CPdBnC55GR0rpX0esDHrH8f8jj n9JvHdIz/D/M/9P6bsv+Cwvxt1jT4boXMzXEEa/aNOYrbzWSHONzbsHO04wv41i63/wWG+MtoY10 q91H7fbql3/ZTJEiSljhttwvGU6kNj2zX+k0Po+YFPVx/H/I/wA75/Sax/LpGX4b/eLd/wDBXT44 yG5FnrS6rYahCk0t7e3UxGnOP9ahUphgP9jPWs6H/gr98e444WS6sxskJs4IJo2nZEGN5+QA7+wJ JHcV10vo/wCV3tNpHLV+kpmb+CMn8x9l/wAFaPjTcJa3EOtS2V2N006X83lLAW5KkHgY/Kufk/4K y/H/AFCTW4U8UR3VlHcxZeytUNwi8F3aQ/wqcDj34NdkPADJlo7fd5/1+RxVPpI5zb3U7+b8v8zE vP8AgrJ8dBIlvaazNE8kga2KtNeSzMD1PVQD33DoTTr3/gqh8dYrGK0/4SYi/wBSnkKxNN9hxEmH kAkVCd3+ySQa614A5Elv/wCS/f1ON/SPz1tpxaX+P7un/DH/1Ojn/wCCofx2vFtWttfMUsUrLdWt 5ctJJEij5JAQmGJ+ueapy/8ABT/9oBLacHxLb25ljMdmGeQCFuxZm53H2HGMV/qjDwHyCK1f/kq/ zP8AMKf0iOIJO9v/ACZ//Iif8PNvjzLHp0954mu5b2PFvcfZ1N9lSCAwTepOD6Hv0NSS/wDBTT48 2Vsy2viK2vDcqYymqr5VxNGTw6RKrGM577ua3h4F5CnZfD6a/mYz+kJxA1zL4vXT8vwt8zFuv+Cl P7Qt+ssT+MWtY7VfOgtZLl5ElQcNHGDkoT14PaqJ/wCCjPxzSQQx+MJWlu7UywafNK0d1M+Pu+Yx IPJAGSP0zXTHwQ4fX/DL/M5JfSC4lejf/kz/AMjK1X/goR+0jp6RtL4n1FLlZgs9qJFuJYvVc5xg dMA0N/wUV+Plrdxpd+JdR1VhA8qRxynTYbTOCgBwSxbpwQBjmumPgtw/HS3/AJL/AME55ePvE7d+ bT/F/wAA/9Xz5v8Agob8f4bETya7NqFy0jSSwX7spt0JJVIwHZTtzjoM46VXi/b2/aA1W3nvrvx7 qEtwU8iGzZRbmyTnKrg4JweCQPcV/rsvB7hiKt7N3+X/AMif5MVPHLjKTuqiXyl/8kOg/bX+PVrJ tfxtqIK2vnRTyakhujxwuBlT6YAzxVK8/be+P0mnw28vxG1iO/viHnayjBSGMcFc7shhkYzkVrHw i4ZWqpP8P8jn/wCI48ZW5far7n/mc5H+2d8dPLCr4+1t4LW7OZWdVu5Qc5HmMG755x2+lSj9tf46 XMj2sHja8t5WkASJIIrhJUHTe2zhj3I5roXhTw0v+XL+/wD4Bj/xGjjB/wDL5fd/wTQtP2xPjPFb XFvqfxA1t0mnDSWliYbXYw/hJZDkEEe9YFx+0r8VnuXZ/H/igXcMq3NizalizWByGaNl2kM23djI 4JHuK2j4Y8PQldUdDOfi9xXVXLKt+H9dT//W+cbv9pT4lCTUn0rx1rtrqV8I2Gppqsk7xKn3kEOA q/xAY9aw7/8AaW+Mf7ryfHevzStMEuZRqDwO8PdMg5696/2RpeHeQRd5UP0/r7z/AB/n4ocTSi1D ENf5k+mftDfEiGe3l1Pxn4ou57Od7iy8/WxcWibz8sflyQuDgHjdkZxVdPj/APEzydSOo+JfFEkk ML/2ikuoCGGEO52SIVX5duQBtUYz7V2rgDh/VfVo/jp+JwT8RuJnZfWpfh/kMtfj341itIp7bWNZ tJpIASW1lrpLo9NzKU5bHOcg+9ZX/C7/AIluZ7iXxnq7iSM28cczi7tgnBK7JNwyPbp+NargXh+P /MNH8f8AM5Zcf8TN6YuVvl/kZKfGn4gX0c1hdeM9QawUbJIIIEiweTtBxjr6elSwfFHxetg1u/if X5pYF3Rv/ac0jyqGzjYzFFwPl+UDjvWseCshh8OGj87v82c1XjjiOessXL5WX5JH/9f4Wf4leL9Q 1Ka5v9c1aGGaOOa3s4tVubcRbFwwKK4U7jycg960rb4neJ4LiN7LVbmPzJM3Q+2StKdvTaSxx9O9 f7YrhbJ4w9msNC3ovz3/ABP8T58WZ9KXtZYqd/8AE/wWxhX3jDVdRvLi/vb65kPnebC0V1LFOpHc lWGTwOwrOu/GWsXMkl1HqWqGNAnk2sl9KNhThsEnnPNdEeHcshFRVCOn91fnY5Z8R5xKTlLETbe/ vP8AzNT/AITG7ugv7yaUJIrNvkLvHjjJB+9jPeqWoeKrvbPJavcI8e4meNmF5cqOgJ3H24HSt1ke Xx+GlFfJf5GEs9zaS1rz/wDAn/mVYPGuvWLrLp+oTwRhRLsm/wBIzIR8xZGypxnjisaHXp479tcm vblb4v50s7TSFJGHO4x52/gBj261tTyrB0nzU6aT20Vjlnm2YVlyVakmlrZtv+v+H7n/0Pzug8Ua s4ubl9dupZbxBsm4AhUnOFQjaPy4zWkdf1OQ7J9Qv5RdWvlMZb1zA8foy7toz9BX+5scBho2SgtN vI/wslmGLk23N67+ZlJqTki1i3W8VvOJkMLbH34wSHGGI46E9+lW9R8Qz3Dxxz24uFJAUuoKQhR1 yc8/T/69axwtFu1jCWJr9GVDq0oj8uW+nlyfkV5S2RnPPrj3zSJqLB0kjnIkMoAkiYoS393/ABrX 6rS7GbxVdaNmpPqV9LGkTyRgo+BLMoJ+btvPP61mJqN3GuxzbxBJ2LeS+5HHqR/X9al4ejHZAsRW l1P/0fzwlvNUiiWeG7ZSt0JYtqgRruGDx0Ixnr60k2rNKXaeY7Cm2ZmYImfX86/3YVGkf4PfWK17 NkF1cyosRnmXCJlJd/btk9qli1CWzWGWVfNjuGDiVF2CXGB155xgd8U/q8FokDxFVvcSXVDfpcpd FRFFNsiidQGaMgHJPfBB6+tFprb2k95PbJ9oW8KxiaQlXg2jAYds8fzpKjBNqxUpzelyrFqL3FxP GJg0ofFxmTqTyN35g0phkmuI1+0F2tWZ1WM714B5J7gDNaqnBdCbyaumf//S/OSK9aTHO5TwXBwS tNF6zlvImZoYmKKW++SPU59vev8Ad5UotaI/we/edWVpruW4JjeV1GdpRGwre2Ke1zPbiOFmlUIB sU5+UEAjA+mKqEIt2sJ+03uWJmW3hgjgnfz7py7GNNzo2eMnBGT6VVm/ta+sniSVry2scvIx2rPG WIGVPB/wq1CGtwk5cu5ZCX1qEu5xNbOihFkkBQsGH9QaHlvLRocPuSaPewAOFz05+nPFZ2XYn94f /9P81Li9mDBgxyTxjgip4rmZ0Lq68qVJcbhnpX+7c0lsf4NpSsSHV7rTw8qEAonJkQFSPqQa05j9 utra5umG2T97DNgEPtOOPoeKuKsiHfqZcNykm9XuFiTdhS2cORkDGAakvJ3jiTYomIcdfu9aoViW 5e3BN1iKN5lG2OI42dM4Hp1NZ8TQId88/GdqpI2Tz05P4UWsawd9D//U/POOeKCyfZKgkkONir84 A6Z9vxrFmndyoM4Yqhco/UYzgD8v1r/eA/wZUGyNb26uYWDTBGijKLGx2huegP4/54qzJG9tZRM0 ZFurKGmRd+Wk6LuHX6f/AF6A5ZIszTYtljZtigCKNVwCPQD/AD3oinjtomcvgbdjn+EDH+fyoHyu +pSuboC9lt7S586BUGy9iysUm4HIUHB46ciooLgWyMikO+3aruu4L74oH7M//9X84/tMtqIrqJbe 5uGB2xTJ5keeR8y498jr0FVHuLu6AubhQk5P79EjEaKRxwB24r/eA/wZ5JFiK/8As4yWDk8L/ejP rmpDfoylriXdn5sAfMx9B/n/AAoDkkMj1C4ENwsb+THLiJgvLMuQf5rUaXaIyrOu/ODG7A/JnIyP rQJwdtUPBjFy7ROWkVgpUElV+g7Zp15IxlkjfAmVtj4xkMPpQQ6XY//W/NNJGbdHKWXyjtY45XFW 0hnhlikkiElhMw2Th9srKM5wOn8+1f7uqSvZn+C/sn1J72SGa4xZQPAqnKJuL5A7k+vWs24kuWcF jhFOSvrVOSWjD2XkPW8+cyRxKwVdjAHOCOD365z+dQm8nSaFlKbZDveKQ7tmOMY/DoaTkti1CTdi zLdtIjBGjDCQIRkKVz1IH0/pUaRhfMVZFR9u5HJxz6VDkuhSpPY//9f8yNqzBw5Zihy5XI59avSR KIY4xMJlkjy6spyhGeCDwe3PvX+7qlo2z/Bz2XLuULeHF2HvJ3it0Uh/7igc5x+H61q21xayxrJG GUNKY45SfkccAY/OqTurjVNN2Ay31kIlnQy2zEyz3DL5KdTtA/D8Ky5LpkkkaF5AkzZx1AHA4/Kl zeRSpW0Lks1zKkZyiBU2scYYgdKrYkYxoJOB94+tNO4nTSP/0PzWSNQjT7s+XwQDz9cfhULXQhYP H80cg+bnDJ9B/nrX+8B/g7KEbjJpw8YKsXctgID0HHP+fQ0EoFG8YJwCccn/ADxWc30KUIrUv2cq 2XKKsgA4WYeYpPPUf56UyOSI7TsXIJJBXgn/ACKzLailuTROhkC5+Vm5UHatNZVtZDsiBVgyJIi/ Io74+vFAWgup/9H847C4s4kvE+yvNezIBDIrbQgBycjvVAykuTI/yjIGK/3YP8I0odxizGOKWdV3 pv8AkK4DNj+EZ/zzSLcrcxmUIbeT/ni5zJ+JGR+tCTbsiXy7omt5pQCwO3aPmHTHIH+frTJpUkO/ cGYevWm01uZNRW4pvlSFZZmjC23yNyFc55xnr/kVatZoo7U3Yuiy3SllhDMzEEenYe1Im8Ox/9L8 1I5GVVS2uZYI5FIeCM4VxnIDD2/rVzahhZJk3M2PmPT3yPf+lf7rtH+C4JMsMX7luV42Y5I9qQOb lmkYvaLCvmBX+d5SABgY9c5pgNaaHBBxG2Mh2H3j6E1CZGnibcpKAlWBHBwcf0oLg7OxGk7BVUbU jUHOB8wOOgpN63kbZuPL2A7GbkD6fjSSt1NT/9P8zBeM5tbSFECW0PlzS8ZuG3Md3r3A59BU08nk dFyep7V/uwf4PiyXf2i4yUjO+PbvCBGyBhTxVaZJ4mVXw2erqaTVwJUlwGjIyy8hieP8/wCFWxLG baWP93vkwu4jLpj0PvWcopCV1K4kUAFpIiXDQ3EbK8cgGTwcnP1qKW4clVz8wG1mHBPao6ju2tT/ 1PzghiVYLq7u7iO3tUUJCzcvcOT90AenUnpxVeSzeArIxWSOSPeIwdxAboeD6dq/3QP8GnJp2RHP Bao3mrtjkaIb083cWxnnHapGBEERiUFUwZd7YDcnp+FRJJRsaLbUG1nyEkghSKVHQBpAPnQjsDj8 6yhdSNCLeR3kjknMxDnPlE9x+n+RWRSbWxuR/YbS3yoeW9nZQFADRqgDbi56g8L09TWW8zpmRdok D7RHtyGBzk59v60WKvJq9z//1fzJW6kjbapCs3qM5q5HexAzI1urebDsVixBibIO4H3wRj3r/cdp dT/CC7G2qAK87SBIg+xjyefT9DUl9LI0VtdvMEt7p/s0MTjyzJ5QH3RwO4/X3osuwXl0KDSbWKqm CvHIrRDQypFC5RpjHujjRgZcZI5H4Uws+plBIVi8uH7TbhZcuZpPMcYPOPbr+dbE80Uln5ImLpIV JdSVlBXgAd8c1Si2tBWP/9b8z7S3eTzdqymW2y7DsFAGSTVyMpH5dzPJJBM3z2sueoBKn8Mgj8K/ 3L5bK7P8IVF3sVEaSGWWONEMKqZSQ23d3JxVZ71ZlXYdp6NkYqLdDZLQnW+EbGG3usyqo80RPjAP TOKx7u9tlkSD7JdNcscrdIQbdfXcMZ7frWcUrtMdnY0H1qaa0i0qXYiRuLjOwB3IG0c+gHb3qqWQ LhT82emMVDVnYEm9j//X/MSKS5ggmeB9pT5gyttKk8D3qx9otp7eGaS8ijvImWJoljOZ8n1HGfrj iv8AcB7an+FSg+pW1jzI9QaGO5We0kCrbnbj5McFj646j2qK1u57YTwRnKTMpdjyRt6AegqXJLQO Rk0qvMrcrtZcbc4JNV4ITEFN4IzMmYztBXI546/SnzKxLp2sScx7UjKqinhF4XHpTo5IleXcWOY2 2jPG7B2/rimVyM//0Py/jvRCqtJxNIuyRtobHH/6+artcW+6T98py3lE9j15x/k1/uAf4V+zZHas iJ5KSbUXO38ff8qcsjz3CRRP5fk/M8s67IWHJPzHjtWUtJlqEuWxYjlSaYplB6kN8lRpdQLLIGhl ZR8u7IQZ9RUFKnPcgluEZCgOwZy34Z/+vVafDJiOUI5cCMkdf8+lPoPlkt0f/9H8v7mQyCLyyG8t FDEcAHjOfxNVZ3CXC/uWjJUEnO5TxwR9c1/tvdI/wzjTbVyK4lmury3ttpzGMJKcFVzxt9R60s1x gOskbKYjtdwOB7mi67m0acrWSI7aNL5mtrO8jeSP52O4AyKOSBnv1qmzpHIpFwysucfNtCn1/Slz K9h/V2x0V7FCXUTSeZI4llcOcyHIPJ/AVvzQTsHkkJkRYklnkRt4hDgbdx7dRTuhrDzjsf/S/Khp ILQuiXAkRRgnzC4A9Mn61bgBCxbTlbtDJbMxCpJjOQCeOxFf7cXT2P8AD36vVXQrF0uIBMzBF83y 0Bba24c4x16Y/OqZM0EkkjsFSF/KlXcNwJ6ZGfY0ror6vU7Fy3FxNDPfedbR20B28zBZiT7fQ1Ru bi3s3t7qS5t7oiRJGsVkIeRfRuMYOMdaLruaPDVNrEdvLLq97dLZafLG6ys8dsgMxhUZbA78Ad/S rWnapYSTTwarJIhMOy1KgBhJngEHGAeaTlFbsawtVdD/0/ybuJLZzOkMsRlgIWeJJ0abnp8gOePU etMOrPYbkS6kgkRRHJKrlWj3jgMff3r/AG0dWC1uf4lxwdR6WFOoSXImSR98lpHuuH4VlVepPtTb XxJpw861nIjUx5t5I2BWZu279fyqPbwNVgKr05RkepQ3PmSohlgRvJd0JBifjqPTFINQ020Ejve2 9pFkQOLq5DhGbODtHzY78A9KlYmn1aLWXVpLSP4GemvabcSpZi6iZmy4bDIpVc85IAxx3osby21G SSIXdvaqkL3Cz3D+XEyp1Gex471E8RSvqy45XWa1iz//1PxsbXNPs7qQi6jlhWEyC7jmD20uCN20 jg45HHpWkviDQJolja5UCeP7T5zwPHCoUHcWJHTpz9K/2nli6Ed5L7z/ABfpZHjJvlp0236Mi/4S PQXktoFuId92oEFzJcqtvjJXj05GMGo5NZsbaSeCe/sbVw5jgjmvI0e5YDjbzzn196y/tHBr4qi+ 9G8eGc0esaE//AX/AJGdF4jhieOZb2yS4tkM523ib5ApODw1X4/GWj6rZ22oG/V3urprfy0Blwy4 BLEdOves5ZtgY6e1j96LXC+bt6Yef/gL/wAjM1Dxl4csZFSbUrdEfdGHXLIWUcjIGO+Oefaq7eNv DyJbM+t2SR3C5j3SHzAORnGOBkYyTWLzvLouzrR+9f5nTHhHOn/zDT/8Bl/kf//V/FxfG/hx7CO9 GtabMfPEJtBexpdq2cY2k/rTv+Fh6GgIW6giuLa8ELbphOVPOCUUHgYIJGRzX+yNXiDKYfFWj96f 5H+PtPgjPqsfdw8vmrfnYr3HxU8LrdL5l6t3bCcxTzWcflIhHUAtgZ/CotT+JXgqWe3ks/EmnQ2M pbdDcT7bq32D5g+Bjntz61yz4nyaP/L+J0x8POIZK6w8vw/zMxPir4I1HUPsWl+I9Muoo4d73FxO bWzSQDKxbyvDHjlgB71NH8YPDNtEVTxZ4aRZ9yzxNfeZcuVyPLA29j35B9a558WZHf8AjrQ64eGn Eskv9mf4f5mOfi/4FiuY7W68X6bHqDEO1pGXmESkZUswGOeOmagm+Mng2OYR/wBsaY0UGftN5BqK zpnqP3e0EY79a4qnG2Qw2qpnbS8K+JZrWjb5/wCVz//W/C+X4+/C66sI0s9Vs7e+DPGsn9pi8ivt g/hXYpTJ9ScVj3Xx98DpdwRXIhFu1lueG11VBPMwGBICwJVScdQfxr/WefiFkNLVVPy/zP8AKun4 Q8RPeCX3/wCRz1z+0Z4Via1g1HUIoYp4Gjt/IlBklWIH93kLhm6Z6E8e9Z9v+0z4DR3ucX7WzyBR FbAiazx67h1OCQD+dc8vE3IIaOf5f5noU/BviGUbqMfx/wAhi/tSeA/Kvryz11GQbkhWeVLaeyIb G2dSPvHGMHHOKoXX7U/gibbYQa/CLi6to7i6xKxMAIw5BChc59Pzrzqvizw9S1lNL1aR69LwQzuf TXraLf6m4P2o/hnLb3kNpO15NbWkSbjqKK4ZVCyOI/LHL4JwScE9xisK5/aw8Btd6TaxaZrggV3M okuYbdsAglncpnH0FcNTxl4cptr2kf8AwNHfT8B86krv/wBIf+Z//9f+caX9rPwneSGG10XVtKa3 SQXP2zVId9+p+UNCSAoHU89c9q56b9rLRIZltre3gjtYVBku7mdHnmJ52jbx7YHNf6YV/G7IFrCc fnJM/wA76XgLmW1S79I2/wAzTl/a90u4juI47abZaW8chV7MKFI+b90XUMM46NyfU1Hcftc6Hf3s NrYWuvrcajbpLcg3KRB36bCoQdO2c15tTxzyeCb54/J/8E7oeAeK5l8X4f5GbcftZyWUslhbeHdS uYJS0Q1CO7hS4gY9Q5yCwPIzjj0rHi/bA1DSNQsY4rW9iAzBCGihcN5oKyI7jgjk8N07V5dfx7yx N8jX3SO+l9H+s7czf3xX6F5f2rpZnhttRsLezt7YP5EkNrC08nBKiXHzNz7muKu/2sr6FWs4EuV+ 0TYiVY9zQk9nfA2g9+2DXlVvH3CqPuS1/wAL/U9Oh4A0ou1SF/8At7/I/9D+Vlv2ttUiEklv4fM0 iKVvLclIrWRh08vklRjByO4rLg/bE8brIs9lbaVp5jlEZtru3W6injxy+3ZjPJXqenav7ZrfSAr6 +yi/W0e3+Z/HNHwAy1L95b0vIvWn7XvxB1G61FpriFbZohAkcEUdsnljPzeUq7eOecZ9/TnNQ/ao 8e3cp1e0lSS7iQWZg1OeSwjlhQ4O3y+eeoB/GvJxXj3mE4tQTv01UfvaX+Z62D8CMjpSXNFW67y/ Bsi/4af+JGtOWbUdM0yfTmW40z+yYTDDK54LTgAMzLwA2QRjj3xJ/jz45SZrmfVlmvYsTl5oDO8k mc7izMc5PY15NTx0zeWyf/gbse5Q8FeH6fuxgv8AwBX+/wDroihN+0f4quFhk1O4ubnUGZhJ5bFU CckcbgFA6YFTRftD+JdRikWDVbi3tEiAFu1u0bI69wScY/CuGv415xVvvf8AxM9TD+EGRUbKMVb/ AApH/9H+OzWPj/4+WCLytWur63lZQ9ndXBeKDAwXjUHB+hrDk+Lfi+R3vH1e9ijkcGGEMA6Aj5un rz9K/our4wZ9P4ZJff8A5n4tT8Mcipqzh+X+RS/4Wz4xt5Aw1Ce6CTCaH7VKzALjGG/nVzSPir41 ml2XWvXb28ZcoHmfz4Wc5PknOFA545rhqeKufz2qL8f8zth4dZFFa0/y/wAi3J481iS4aNNbu40V BvDXr+ZMc5O4lu/tisOH4g65Frckjardx2LxFXhkmklAIGMqN3U9a8mv4k8R1JXjXaXkl+t2dVLg TIoLWgn63/QxI/iBqsdxJiS9luiSgv7sm4LIGJU/MTyOlPtPFHiGafzbzV764giDFbeO5eJWL5zk Z6eg6V58+PM/nviJfgd9PhDJYa+wif/S/iyu/Fd8NPRm1G+CgNAtpLdM8cYYYOVzjpwM9MVyUGpX EUkAiupbSKNmIaBzF97hi2OvrX6RV4rziq+aWInf/Ez4ylw5lMNFQj/4Cv8AIv6lb74okjmSW2fM khaUuW9cHPfHNMsNavY7D7G10/2aOQhIhKYyV/hU85wOw6cVyPiDMpO7rS/8Cf8AmdcclwEdFSj9 y/yNSW+863j3s7ooKEFt5GevJrnLiW4WOGOzeWCGFm2RwMYYzu4PA9a55ZpiZ3lKbfzOuOXYaFlG NvkLY3yxs1q0ZChMNG/TaeuW75q/qV3YG2it0h+zpIfLAi/dbPUjHb3rknj6zerZu8LSX2T/0/4e rS4kTzLRHlSIgoSjbfMHTNWI7Oa3eJtPklaRV2PKD5bBR/e56V9G8XVvpI8j6vTS2N57WW3ghvIp 5mRUIuYVUhYySQT7iqdkEgfyYQyXCSC4tpAgMIA5A/Pt796zliqu9yVRhsrGZLcXMF99ody8qyGQ luuT1/PNXftt1PJFK1yUWKXcsZ4VfXHuayVWbV7jcFHSxn38xRS3mloPMLz7fnYZPoKkiY2qlYo3 ZbpR6qHAPAx3xV+1lYXIlrY//9T+JiPWX8qPdBG0FkmWUR8P3IbHJqNLhpEE9o0kRkJbauUPPUD8 6911G0eKo2d0SrfQ2cfkrPepHJxLGrmFwx+8QAePr1qld6xG6IkTytFENuSS0ox6knn865as3zIt K6M/zJ5XWRlkaFmyzk52elWXvp44v3zebCCY4kP+sbHPftz+prFyvG4rW0J9IsYkgjuL2SLd5nmJ ESCVPoR3rSu1M1ykUSqjSY2ZIWPnjr2rO7tYD//V/iqVWsXKMqPMh2SYIdAfYis+eKW7cyxwsXUl VRVyZPp+tdB43KtjMvoJj5ccJ+cYZo1B3p7GnQi+tNs8crwXSuNkar+9b8CPeg0jC+5WaICaR5hN EWy26VTuz61SWcG8jYDllEZYNtBwepq4blSWiR0eoLLdGKGLyxJ5QJ8o7/yqotlCiqEa5eURkzLL H5UOQcEA9/0qp6Is/9b+JGMvEhnhUxSLgF41DMAO/wBKq6bC5eRrkiV5MjfIvzY9F9K6Djm9EJNe 7UeGNeUyqN91gfWuq8O6xfWkMcu93uoPmWV23M57Y/lQZmRf6jCQLgx7JpHIZD8qn3ArmL65M7rB E25GPzODtySf6U3uBs2ciWsI+0KZAGyXI3le1MR4ovtt2ZrgxyYKxyH93Hj+4vr+tTddwP/X/iNs pZYyZBIwMgJV259cAirMV3cqQzpCEXkSxHaWbqTiulPQ4Em9EY8uoPHLN5aYN3kPIfvMfX2qiivh ipKuB94dOO9K6W5tGNlZDlnLkiUJ5aDLqeOneqGo351uWMzBI4bSMQxbEEalVGAT79yfeoc10L5J GC7W8MuwDdzw+KqXCsu5ogFRfmJBwGJ4rkqS11LjG25//9D+Dq2gurqaIxAHYM5B25z2Jr2TT2Nm lnbRpiaRBtiHJ6c4rz5O12BfkkuIRMl3GUMjfJvGJCPp2FUBp5heS4jllzKnKBc4+nfvXOB0Gn6b GbSO93SIjZ+SVTHLx3KH5gK2U1C6tbeKW3T7UyzeWVnyV2nPcenQfSsZfEyXKzsRTwxXcCl5dt7H dCaHc+/J+bfk9sZxjpWhb30cEUg35vB80BIwGI7VI07q6P/R/i61HVLm8imQ7Vn83zGwPlck9OOw ro/DkqsksNzeSsrooe2C4HH8Ofrzzmvn9jFtqTsTr/aAuQqRwCGSUrulbaqqOcZrWmuJHjtriztb aK3LPanIEbbkxuYr15JHPcGudvqySZLe7ubV0vALUXMoP2ZG/dgKflP49fxroo7C7X93bD5JwA9u GysuOmR+f0rOUk1YaXYp2898tyun3LQ6asMhlZUbzI5jyBuGOPw716roL6pcC3/seK080SIs1rKT +9jDKHYL6eoPrWGKa9m79iox0uf/0v1r/wCCU3hxofgl4Cube1tbSK50COe5sYELxWUjZaVQepG8 kD0r9mFby1EJGMLjAFfyTyqOKqpfzs6cBJzp+0fUtRxNs3DByMe1MKFMANsYc8dx0rrhsdLi07Dj GJFQZOc5PbpVly8SbV4A6+tOPxMrk3M9gdwLZA9cdaWKN2cAfL29K0jpJAo3jY//0/3uzGCt7azf NsV3t2TDxsOSOaxRLLdTzXTuXmeVROxOMgnHQfjX8rTd46nMl76NI2jjc2FCkZG7oKwtbDxW11Hb shuriylgjWUhUJZCOp9O34Vz1XaibSinds/k0/4Kx6BbDxZ4RaS5nld45oJHt1JskmVTIFMh4ZX2 sMDrhvSvwKv9Dt59bu7l4bGyeLmL7NL5+XHBAY88Yx/h0r9Q4Kqc2V27M8TL217Zdpsx3sZCkMzR WUU63LGdFYjeAcgn3PH60XWpaaNs9xblzB+5MkcZeY7iAQB3A6/nX3sJ3sj0JSuf/9T+Oe3iiuru KSS6Eds2Elhu42jdVByGwOn0FQSabDqGqXdul1cCws0ElsEQiO8JyrZHUYHr6CvnzjU7KzGQ6Ja2 kTy2kluI5pRHc20ymW6jjIJDIG+6Sw6jngirOpSR6bYpbSWkN0cLJbxOQyKTj5h1GcVtB3WpMndl cRWsy7wBnAcooG9foK1E0/TrwQvqFxPMgAkiWUssgIBwBz+h/KqJOf1HSISJYoE3TkEbHYI/ln3p NJ026Lm1txGsaxABS+I48cYNAH//1f47NW1SK5tLeKSzU3dgot1EOHnk28A59KzZdUtHWFLzekd4 DEIbNGlYEKeCByBkc5rxzgtYzNeg17UG0+TTo2u7JAIr2xnJhaFF+6yt7c5HuK0bOQpJa286LIEf EVs6+bEO546YNbx0SEdI9lolt9lae5VZp2ctawyKHiypUFBng+2O1eXeIdDMWnGf+0vMaWVoo0lY GdSADk4/h5xn1BrpovoaS0SPMRLNbQohAZ0+VmJ4XntT79tsUV1BFKcDDPglAD2NeqpWickt2f/W /im+C+pajpfjXw/eRqFsoro/alRgkk0cn7twfUEOVx71+5/we1N/EHgzR7LzANL1Bvt1tHKgtpbd ioUqz4HZR8p7/r/Yf0ba75sXRk9FZ/f/AMMfyL9IugvqWGr215rf1+J9QfatJ03SbZb8XY1slTbm CeO5tJIVBRS68MGypIB6CsR3Gu6Tbf2pZT217cTNGrx/6JJAAflK45OMZ3En7w4r+vXFdUfxtWSV RpFu1s2sgqS5EmPLSOdP9J29nbjHze36cU+ysn0oXM17qDW1hHC8rBEMksh6/MevOO1LlXYItqO5 z8mqaJrN4Q76vo0H2YXFrq8lufsU3l8lWPBBJzjjPPesa11oeddXERaexjn2NOByOADz0/h/Q1ca aTs0RzPuf//X/OS21VdU3iwlWFHYQb71TAFxjPXt7iop1nsGluTdJHcQsA9tbxJ5MvQAh8YcH1HX 17V/sJGOruf4++0cVZMfpc9zc6ncahK6Pcyx7CzACQKQAQMdvl5+tKtqs2rxQwvJHbXbv5t1IDKk coUkggdMkfhWyULake2lzblaa4igikgk2XFxHMY2mkUxmIAkEKP89K0tDv2ki1HT4ZbVY7O0mkUP Em1kUEtsfGc9SOfTFaKMehLqPqzl7Wy1CCK3a2+3GyuMtDPhkiRW5++MDv29q3LyWR4lY3ywNYRb 53lUzbguCQOvzN05raKgc0p21P/Q/Nezm0+dIrtf3k98yv5RgKIoABWSTt3Hvwazob8/b7OK5wWl mKXRxtSJR0dT9ccYr/ZiMY3SaP8AGiVSVtzSjtL/AFTWLOJb+6FxErokCoJEnTBIVPfAOMf1qJbu 6t7u+0uO7nSCOUs01+hing4zt9Rx2HtWyjFdDH2k+5rWdtYnQ4EXT21W9n1FribUrpjDGFzgxRgZ GADuORnOB0qz56T3drHayC2ii3TSK0jCKTYpOwc47cZ74raKi0ZutJOyH3t9ppjguUJl8s+Yyh2A THrVUQ/aXuNZtzd+TvHMErLHDwBg846Y796vljs0P287bn//0fzvvPEWnxLaxIt084i23DOg/dnO ODnOD7+lZkV+1xOs2UaSOTbDJJGG2rn+H0Jr/amMYJ6o/wAXniKjVrmxLfI8DB8eS/EgU7icHqR+ FV7PUwIbm4tLuTUnjDQkABwEUcKp7EYH8varSpvZGFStNvcjtLfU7OKzbUhteaMXoj5RgkuWXIPf B/SrGrQ3CCxvdJkkW6bcyoA620YDAEbhxk+h9OO+LUUjklOaZVvoYE8++niK6vMY454wwKsFwN4Y H0/pU03m3EIvIJbt4LJRIFeIjyyeCcD600lcXtJ9z//S/Nq1Frc3Qu7gzteDcqSFikaZwAQvYjGK 7jTzZ6ZYXCzTm8Z3+0bnUMImOASf/r1/ttyxP8RnVdtzI3S315LPprKcAPLIo2xgZClmPQDJA5rP vpp9LefU75XmVCIZWL+Z8mcYXnGOD0pqK2sR7Zomu4tN1SWzu7qPdJaIPLUOQ9ujDjbzxkD9K1bW 5tYpIseU8IO62xmSReoO/wDz2+lbqKS2Idd9GW9a1CKCCFbR1uUunBuljBLWjZ4yG6Y45FR2k8T2 U91eSxl4yIh9lUJv252s3bPbnrirjBPoZutU6s//0/zoW4cz8t807CN5lYkCPOcEex5yKvW+n2tn bXNv57vi8MgePmKVQ2QMfgPwr/cX2cF0P8NnXl0Za069ja5lhW5aJXPERIwo9d3Y8cfWo31aCW+l t4ftcUKRBfPlb/WdNwIHXnkCq5Y9jJVajbuzFu0u3uPN0+/lVCpjIjUDcMg5Oexx0rah1XUrWGC2 lhjViBN5yne7D/Z5IHftxWtqaQ/aVO5mp5VhdvJJGtml0fOt5PM2yRBzgB/TJ/Pj8di2t280rbXk K3Vx8ss8rFnhUn7w/wAe1V7hPPKx/9T89VN3ZzzTi9kmvoJzGZ3+ZZQno/Q4GMVTjub6WArcSvHO ZWzPE5DSqWyPpxxX+5/LHsf4Zc89rmgNQmjnMCZkQWpUmQf6rPce+SSPSsV1NsjW8Um6GYlmhTK4 B5b+vT0pqMOonUklubF/Mbi18lnjeGO2QrGZAyZ4OBnqRxx7VnWl+1tCqPJIyhsFckkKONoHoPSn yQasghVnuaUV5JJD5UsYFvKm4GZSZFHUEf41Ut7qe2mkvDdXB3MBGu8qVVeig+mR+tP2SRqq89NT /9X89rnVb++0y3lht912t+XugzAxQwkqFkc+vUYHc0y51CabTTDba15rQPgGOIR/MTz5PGQB35r/ AHR9irH+GjrTuF1rlxHZwv5zBvJEc52gGRumfx9sYyaie4vIrOOWIwr8wlczp5iMc8HHr+dQ6ceq KVZ7NlRtXuYlZfMjKSg/wlCCR2xjGPyrHgAcCHMgiWXzSiyFPNb1Y9z9aXs4LoKVV9zU0+4tNPvb oTokqEGWLGZXWTsQR6cY+hp84hnRhI8qF13h24J5zz9f60OC6GblJ7s//9b81r+202W3XzmKXBQp bqpIE6n7wznJxj36fjVKwlVNqE74oIjAo6SegGfbFf7nckT/AAwuzblk0z7OtrJJNb2X2cx3BUgM jMCAQP7ucZ9ga56zaCzSO1iuluJbY5wW8yTYf4t3v0p2QXZZkv2keTzod8Vy25mfk5A6H8+foKqC 1iuSYYWNsCpG5OAwGcA1afLqS430LcIaCJl8zEka/IvUuB2H4fyppZrtovMQAwndG7DOw+1aKSYn HTlP/9f8vftN1uLuixy5I2g7gccA5+gzV6b7TftGY4zNdIu5beNflcgenrxX+63NE/wtirKxF9ot L2C1ukW5t7xIjFeQSEpEGB42jvj1x1qdcMfMmxvSPy4Wzlsen6dKu+liHFuQSXckckfkrAz8DdMC UODkjqPerTTWF3cvcSWoS6kaMWwLF0g2g72GenOCPTJpGbTuW7rajMWvJbt84EsnG76dP15pkfly hYkG+4GZVUjO5VHIH+f/AK4M/9D807sxwwCZ1x83IxlskgAfmf1qnenU9OtotSit4v7NeTyLt22m 4jLLlWVDyRxyV6V/uwf4WSu1oRi2a/WGeSVmeGQMNpw6KCD/AJ+lacVzd29y8tozxEIUDkBxhgQQ c+1KKsrMzs+xmKHt8PLvkkeTBO7Ckc9qvKFt5I5rWQWrmQbmGWfnOSBTGk7hJcyi4mYobt4J9/nq A8LjONxB9T6+vvVhCPKOPmJ/eMdxYr6j6UGvU//R/MGe/EEUk1vFJNsnSAtGP9WzHuD7A/lV2Jxt Z3Zd+M88E/hX+7B/hhZ2LkV1+/gkt7fezxGLerbjuyOg98VmXq7RNNeswknbY4LEE88Z+pNCCzHr dPHFCFh8ooM72bJb046DtUayksxaQeUV5Xqxb/OKel9RtN9B5vLaK3jhnkiglkufJtQIyryM5/ib 8OPrWpBqljptvOl6lzPIse2AwKPLkkJwMn0+laLksRKN1Y//0vzYuLfWJpzLFZT3qLaLdzT2aebH Zo4BXzCOnX9KxkunhDIqjcH3OzZLjjoK/wB2mlzeR/hY17tjchmW0hieayWebULYsoZmZLQkkKzY PB4yB05GabE9tI9xDc7bd402AspKE+q449Rz70nuHLePmNdEtomMEjFtw2tjAI7/AMqr3kk8UcMt s0bSvgygDf5ag/MCvuB+tIhwkhtp9huEv7y7nLGCIrHbQyCNnkbgZHTA7gc/TrUEkM5ijmlhK2cr eSrmPAB5JyfxoJUHfRH/0/zPght4oUEjkhmJZFX509MduaZC/kxPChZhLKXLsTuUH+EegFf7tX0d z/CV0ttCeJDaZdWdkY4Bk+Yr7ZqCW+SW8jhnNxDZ2tsxupEhyhLNlW45OF9PWiNk7sTpv7KLkx0/ CS2btNAUDRSypsaQYzkr2+hqDzok2rEPKYkksfu59hWjkloQoSZVgkTfJFc3FxLIiFoyHJXcx7jO AOOntU8cRdgvLcfOPvDFZN3LVKTP/9T847m9nmsGsmlSKOzYSWaBAN3QEMRz6/lWVGjtnB3fLkp1 B7/41/u0mkrH+ELpu5J/pF7I8189sECrHFDGoX5UAUZUcdAKtyXElz5XmTB4raPyLaBVCooySeg6 56k8/WnzvoHs3chmg8zccbXHBBB5x2rMhmSWWaII8ZtpTEysu0EgA5HqOaSetzT2asXI0QTGXgOe GbGC2PWpDcCO58y3nnhaAByYOGfIwyemCMg+xrW+trE+z8z/1fzTaaOZ2aGCSJdmdrdRxknA6dM4 9KjtJAzGKWTZDlmBjjBZjg4HXuQOe2elf7wJ6H+Evs0i3GAkW6SKN9zZ8znIHbHPXpVS7k80A25D TAfN5nyp19efSmm1sPkjfUjk+0yQBZnAWPBBjTa2Qe571fsLmC2Vw7zeS8REkUcnltKcYHODjnBo TsS4R6FeJ3jt3llmY2qtsLSzb2XOTjnn/OKjmmd4LFYrucxRO0yI4zHhuwJ5weuO2KQuWK6n/9b8 zWVWdQT8+NwB4zWhI+21W1DqFDGQ7AM5YAH+Qr/dyUW9j/CO0LEkV7axvC0tpHcRxKEeCbLpL2Oe /NVYLaO5u5JElFujvuSAs3kQjHQdfpTtNKxD5ehHPGqhI0ZMmU845/P86sAxLvjuBJ5scZAVcA7h jAIPb9aVp33CyRXsCJ1jmu7WNxFKHaF3xlQeVz7gHpzRfQWd5NN5Fk9vbpOs8CmTzBGFOQM9TyB1 /WqSffUpOOzP/9f80sRyNFEJdryyBFkwWiTB+YtwcY/xpXtlDsofewYgSDowziv94D/CK6WliCYR JE0LwbpNwZZAxHQ8gjpVrTjHehbeXUEs4I2MssMqFnk2g4VfQ9RSSad7hzLsRuZLmUgqyRRSkqrk O59DkfhUryRykRABcDbjqG7ZNDinuPmS2KU5itbKHT4LK3tZUuJLm4njBMswYDA9gMduOeneqhll MMccSpnfkv1OOAc/gD+dJRsrA59j/9D80Plj/jG4cE54/CtGKXyJVjuHAjmGx2jxIqg564PNf7vp cuiP8Iudoyri28m8FlA/nxEbo7pWzGwPPzdwfYip2s3VwUDOAv7xgPkT/PP5Uxc7tYjYTSNHbxJn zG2h8gKD9TVkQeWxjH711Xy5GPVWBGQPy60JWWhEpNIqyXkoeRPJjTysKj7ArSYAzn/H2qpP5c7f vJpInuicvCNzoQOuDx270EKUnsf/0fzTiaYIx2mWOIBZbhs7nY5wW7ZOD+VPa5hlQQlniNvETGq5 Kk8gDHGB1/LpX+7/ACx7H+DvvlGCa6jiM0w2sZGVNnPAPX9RU7St5WWIIBzuIwB7UWRL5kkSzOf7 OjjiSJWeUyGUEGTGAMY7Dv8AjVG1hSSQtNuVkXAbqG/X60cq7Gi21LstpbKuUkkmaNw0bfdwe4YD 64/CnKYQzefjceFIOAvrkCjlXYD/0vzLtIB5l9JPdk2yzeXbxRweXIy7eHOc55HrUqmCOOGRZ2kl VmSVCgVcDbtOffJ9Olf7vpJbH+D68yWQpMiqrxjzRkEngfWs+23xBok5O/CqvO4+wpgWjeXd4oS6 zK4BSQk/cxnHB5xVLdLK6oxjXygSpEe0EDnBx1JxjJoCw6KeSd9pjeFSDtEmCeOOo457VZG2V0t1 ieNyjOLjeFi+Xqp5oK5Wf//T/MhJZIonWKcbnQxyqAQSDj9Pzqxai2bTriCYB7rcrxu6g8A8geh5 B/4DX+8B/hA1qUoUEZdxyw6IWwMirE1zsEcpjVmZ8CMj5Tzz+VJq6sPll2JGntnheUPtdZREyj7q E9AfT6Uy3S4umeKGOSR1GV8tC/A6nisrdLFKCtdgzywowUI5DbOT8wOQM/rRdSTqyhZmZMB2IOM9 Oo6deKTt0H7NtXP/1PzHMcjQTPsdFYAeejhSucj6j9KZbW8kvyBiYwNpdm6emT71/uytHqf4TRhb YWaxeyxv3bVbBUtyf1p9tPFaytOYY5wy7NkwJxn0560KSUri5N0hklxbTvKPOW2kK74oOSZBkA4+ me9NtUjSRkeXeCPk7ZPA5pylfQzdOWzRWlWK4jvbNpYvMc/L8u7aMFTg5x379a1lnCwwKggdbO3W zEiR4Vzg/MQf4uvPtU3XUh0/I//V/MmElZiuQ2CcFeR+FWGmmZJWb/VQkCVzwsfOOfyNf7s3VrdT /Bx05N+6iwUgijUmT5ioZvmGMHkEfnUaXqwSKkDLcSTxsrR+V5u0e2R175FTddxeyqdjNkuYUkzv EqkfdBxtPTB/SrAv7hYooGSOOJ8u/HJz3Bxn0oTT2KhSqJ6olJhjByykbd2Mhjg1TkMKxuzzRwpt 3/O4UsM9hRdI3VGb6H//1vzPbQdYsLA6w9nPHpu1HN68eIcS4CEMfXcMY9ayXlRobiWe4XyoG8lm LglmOSAo79D06V/up7SJ/hQ8LWSTcXrtp0GWt3aPGB5rJKhGwADDD65rRieSeeVIEkIhj85/NHIU DOT9e1HtY9Clg6vYy7jXdKhmjiLys5QiUcKN+WwFPp93rz1piajayqsisyeXnzS7gRg/X/GspVI3 1YfU619mXG8SWLBY8xRLGAjTo5Yv2yecflVh7mx8vzItStLknBVIWLSYzjpis3VprqCwVf8AlZ// 1/y4klgn3JLIzoo/fxIGLRqO7DtW2b/SFt28nWdPhljwtrbTS+VNLgZOAeB6detf7lOvTXU/wr+o V91FmY19p0d1Etw0Iv71FEG+RQ2CTjI689hWldWmrNDHLHbTJbRkpI5ARAc4APPHJ7+1ZvEU7WbR X9n4n+VmTfyDSrJpdSsru2LuFS4dCsCdhu46k+/51RtUv7vfJBaTSCIbiFX5goGdwHU8elY/WaO3 MawyvFb8pIt1cRTIzw3YiKhnlFuxRR9fzwKR9d02F5BLIweNwyQyQsskqk/fwM45/wD11jPH4enr OaS8zpp5Njqz5YU232SZ/9D8otR8VaTaeU8huIXlb91HNbOit/usev5Uv/CRafGEmknSKG5cJayT sIUufXaSe3GRX+2Us3wSdvaR+9H+IseGM0eqoT/8BZd07xFoGoyx2MOu6bG87NuSS6WJY2HQnccH OSPXn8atW2u+EIdQjtNb8Q2Mlpa+YyuLxBHFLggAHPBJ7j05OKj+3MuX/L6P3r/M6FwjnOyw8/8A wCX+Ryw8c+GvtjRvrOnB2lCCOK5WdUXJG8upKDA981uXPiPwNY3cjnxXYyytAFt7uKKUwSgfNgOV 459KHn+VJX9vH70dEeC89k7fVp/+AsxNS8b+EI7i3j/4SnQwJ7b7URBdNO0RX+BgFyGOPpz1qhH8 TPCrG1dL6G1UBvNnlfz4QUGckAcf/XFR/rPk8f8Al/H7zsjwBxA1phpfh/mf/9H8fv8AhY+hRMty viTTPKnjZ/MhuyXI5BDJjdzzwRzUB+KXhpGhBuYJjOuVuftAEMYJwCR1HI/+tX+08uLclX/L9H+M 8fDriKS/3eX4f5k0vxW8IzJJA2vab/aMU5j2vclYSiJ0zsxzgYyazYviZ4We0u7t9RiWWO48hba0 ZZWy6sy/KTu2/LyRnHFYT4vyOK/jr8TeHhxxG9Fh5fh/mP074seBI4BPPfXEFyA9ve3E9uTYRqcj esg+fjjqvWqFx8b/AARbxPDFc2kk0C7Xna8jdSN2QwIPcevNefV42yOn/wAvb/15ndR8MOJKjs6N vV/5XEuf2gPAWu3FnA17oWmG0sRavcW8xknuhGMGZkUYZmOBxj8cCs3VvjV4D0m3juJvEFrFay3K Wkc164t5ZXbsqZJx7muKfH+Rx1dT8v8AM9GPhJxDL/l2vx/yP//S/EvRv2gfhwkrnWdTgliEu1bG C8AkmjB5y6hsEjGPTuKWT46/D2K3xZ6xpunWdxcF5pb/AHTPanJKLvVc5IwOOtf69T8RchjvU/L/ ADP8l4eDvEUnpBL7/wDIyJ/2kPh3DKJrPVIHgSYM0upSKII1QfOCnD4Y9ARwD171UtP2gvCeoRyS JfxW9sVM9rtOY5gSBwxPGBjrnpXNLxLyCP2/y/zOiHgrxHP4oL8f8ixJ+0r8NUhe1stYuJdYhQO7 NGjWjANhipD54z39Kq337SPgK1nsTca/BeQ3MJluEVlt70BeWVMnaT/tc1zT8U8hivi/FHcvA7PX Z/oxk/7Ufw+jW3ltpZLq1Kk2jTXSNI4AJ2OF759Cf6Vkn9pvwePsV35k1nc3Upb7JPcJH9mVTxzz uLds4/GuSfi3kMW7SVl/eR0Q8Dc605n/AOSv/M//0/wH1D9qj4a2+rXSLqNxeIsauYpR9muLaRgC wfggjryKqTftYeD1iLR6fp9/BJlY3W6ZLneRgYwwHA52kV/qu/GDIE/dkv8AwJH+YFPwIzaXxO3/ AG4/8yJ/2sPBENjatJpotw4dbmebVyZkkH3cgR7VH+yc59ann/a08Iy2VpZzzWIMCeaz2N8oeVeT tcEN8x7AflXNV8aMhhe8or/t5f5HZT8As1dlzP8A8Af+ZhyftSeEo9t3HJd2dt9oCK08uDG39w/I CT6dq0bj9rnwvc311BZG6dSkS3M8lmLhhJjBEIRAo/H8xXHU8bshs+Wcb/4k/wDI7aX0f8ycv3ik 1/ga/wAymn7VnhaGTUENnczvbOvkS3dwlk8h7v5RGGXPBGQfrWRL+2FZaZKLwtYhZZGie1FnCy5H 8ADgkf8AAa5peN+TKPuzh9//AATvp/R8xN9VP7v+Af/U/nHt/wBsK0urqBLuxufsTL5itYw29nbr joGHBPYdOneqMf7W2lRS6ibzTZbqyMnmQyWt+IruBevQgg9hjHav9LZ+OeUJ6Th9/wDwT/PKP0e6 y6T/AA/yIz+1vaxxrIq3djYXU+WhvHRpflBwnmADkjPAqO7/AGtbGQxrZxXyvfWmEtVyPMC4JDOe D9Dx71xV/HrLKS+KPyu/yOzD/R6qzf2vwX5oyZv2xdEt72MR2s4ntYdklvZFbOXKj5iZW3KzZGPl xWVe/tfvPbz79Ju7J55xd2TXV1HJJtA+YylR3z93H5150/H7At+619zPRpfR5Ubc8W/Vr9LFjTv2 wb65iu5INN0y2tbhAkDyRKXmIzvwDlgRjIBOD3rMuP2stcjU3unTTTfbsW01rCY4FaNTxuXgDp6V lPx9wzd1P/yVnXD6PuHgrShf/t7/AIKP/9X+XxP2t5biW9ieIabEp2YuUhCDjhd+7BJ65B61i3H7 W2uXdu8bSSLbWWUhWWISwM6njy4wcYOOcdf1r/QL/iP1FOyk/u/4B/EK8AcHFXlT/wDJn/mVdM/a +16zgttWs9PgS9jlbz4p1URM443CA5X3GBTL39rXxfftLLEEYuRPcPCwtZJCMt1254Pauafj89VG /wBy/U6o+AeW9Yr75f5mjL+1RrcNpbWxmaaS6Q3MqvMrAyAA5xjdgemfwrLuf2pPFkbma1g09ZpU ydzK6EgDaSCp24PJArir+P1Zq0VL7onVR8A8rg+blj83J/mZ/wDw1T4xjmuItR1bBvbcF0tc21uZ CMEDHJU+mRWBdftWeLre7WW5t7W50y1tEjtpraITSvKh5Dg4yPXOT7159Tx5xUlpz/h/mdtPwMyq H2Ifd/wD/9b+Se7/AGmtene6uHaKJdQlS53RoIZbcgHKptPC89Oeg5NUYf2pPGpW8tbbVdkUjee0 cw3NdbT8jMx54PI6mv7NreOePabhzf8AgX/Dn8pUvBHJtOeEf/AV/kirdftGePZ7lbuXX2W5uo9t xdqreec8YGGwFx2PpSJ+0143smuI21SK4UQi1haOyK9BjcSDk/XOa82fjfnTurv/AMCf+R6dPwUy CD0hFf8AbqMaP4/+P3sVSfXLxo/PLzx2zhElBP8AcORkDvUcvx/8WXUlwsKKxgjRLeRySrAYDNJy Mn6elcE/GjOJX0/8mZ6FLwkyalolp/hQq/HPxg0xa2viks8IhkM7NLFBjB4XPI45/lWrefFzXbls yavIyvHtuo4UCQlh1Awcge1cdXxkzuWi/NnoU/C3Jadnb8Ef/9f+OAfFnxJp5A07WL2IIzMoyskK huCEXsPQdOax/wDhbPjG4kdptRnfyQ0drgneVP8AfGcf98iv6SqeLfEUvtr8f8z8YpeHGQ096X5f 5CSfFnxutoI01hYzGQIzJEY5057urA+vXNVtT8f+MblI5bvW1+1GPazwx+XGpP8AGBu+9x1riqeK 3ET09ovx/wAzshwBkSf8L8v8hP8Aha3ikWsdpJdTxXkEbxLdq5SKUNjD7Qev4cetQw/EDXLG3jVt X1WVyN0jpqEqRFzyT5e7HWuSr4mcRVXf27Xpb9TqpcCZDD/lyn6lCL4leIJpbpHvb1IGmDw3D3LS bcYyAnatqbxvqQMd1Ff3kzhSjGWd5Ilz32k4rml4hcQPfEP8Df8A1OyNKyoR/E//0P4o4PF+rxMW i1S5XE/nXDPIQJ8k8DnjHtV1PG2pXENzs1CbzmJJa4u5SQDxlQW6j26V+0y49z9/8xEvwPzd8J5O tI0Imf8A8JBeRyW8qanev9nBLJJdyFHZv4yM4J96yrzXtVnuEkudRkuHVzJFGSUWMdgR/F0zz61y z4yzufxYiX3s0p8NZXDahHTy/wAzVs/Ed8zzNDIBNMg88oMRysvAZl6Ej3rDWLRogZZ/NuL8TmZQ bh1ET5zkDOM55riqcTZrU0lWl/4EzqWSYGPw0Y/chb3Xr2SSGYSmOWInFxuJncYwFLE5I9qzLe+Z 7nzHZ/NcMDKrn5s9dw9655Z9mU9JVpP5v/M2hlOCg9KUfuR//9H+Iu21bVLB7YQ3MwhiBWONTleT zgdvwrpLjWZTA8t3GjmS1ZI5UYRSxs3XOBX6BPNMXLSc3958rHAYZfBCxxmm3GppOYF1B3hxmISP l92efmPP61Ymu7iynlm82TzjjcC5ZcjgcZrCWYVraSZtHBUVq4jDeJN88yQvJKdzKYwV4Pf8easr durN5O1WEfyBeCwHYVhLHVW7ORX1amtoopSXhAuDHuhnulBuCBsaQjjr60+41Vo7dY23SscEuzky AelZPGVdlJjWHg90f//S/humuVmLToELvhHeZtxGBwPai1nl252AqjB0+XIQjoa+mliqt/iPnPZQ WljfsLqMoIr+eT/SJD5s6N8+CScnnt6VZ1G505bby7Ge6ldDs/0lfLnBHQ5z+tZrFVGynRilsZVr qtxY2Rhj3xMXLiTJdnLdyT34rNeTVbm7WZbiWeaNt6gsWGT7Vp7eptcj2US3ez3xkN/M+68BywPL LjsPb2qCzvWnmEt4fJLyYLKcLn1I7CpdWfcPZRP/0/4gprtl8wQSBwWwCvAesO7meUp5aOjK2xwO nsK+iVSW6Z86oRWhpwTSQxAqPnkUoWU4K/WomEso2u7OByCBgU+eVrC5ERJPPaTFUDJtHXpnNaP9 oF0AcbnbguxyVpOTe5aSWxmXU0bebt43DaXA5/OrasvlkRNtQKM8d8c0lozdJI//1P4draYibyAo bPKsyZAwa0I5I2leCSLDg8qE6j1FfSOfRHji3TRYYYC7F2AL98D1aoLRo4G3MW8naSe7+5FRdlJx 5bdSok6GclVLR84kbhgM8Zp95J/q9gUvjI9cUiR1vi4AdiqrEdrKfvf/AKqha5uGeSOCNdqyZVoV OWA6ZoGnbY//1f4ZpI55i6up8l2wxfjBrTitI47c+Y+4bdq47V9AeTzNO5k3F1IzLbR+YqhdiEjA HrirSWkrggP5ZWPktkA0F86LVtLJbjajCRM8kjr61bmvE8pUZWXDZIXgqKA57Ow37XC8R2xosjcD zB82PY1WuIrhkV5iJNoCRbRworOcdbopytuf/9b+He3tJ4Q0zsAp5GR82P8ACrsGptDIRCfnAIOO FI7/AIV7FrM8tybTHT6tqEqrHb3EqxJ80sa/6tx3Uj0ojvDISAPKVR8wAwPoKDMTVVVIkcB/NeMS McfdB+7WLazszBZiwB7n/CleKHaRaZkVQYg23diU9CaeHLIQGkZVb5QD92i67j5ZM//X/iVjSN9M SGDe08jN9oB4RRxtwfcVRCXNuCJBInlqAoA+VRjivW54nkWfYJITdrFcC4EjmUmZm64qjd6cxIaJ HjXqWPEbYPXNc1SV5adC4xdmXBD5cKkzM5wACBhMccYqG9uP3cYnWFjGP3YjXa2PU96wc0tBKD6m DBdzGcyMSqKfujqw7D+VbsWuRBf34cMflQoMlfTJqfaeQ/Z+Z//Q/ih027trhnnNyCwQEq646e36 VYv/ABLbxSGO1XyJOGRohhYz3A96vnZ5ns11MBbiTzjNIzEMcvI2S5btmrM1/JJhblFEsZMn2lif M29AD/OjnZdrFC5e4mRGwZIo1KiXqvPPNYyI7TFTGZCrdUUk4pqo0waO2t7h7G2aSMrHMUCBtuWj x09z0p2qavqepxpDLNDKPKCssUSwLGAMdMDmh1G9C4JPc//R/iQt5BDbNErkblKNKDkr1BxVrTls 7ZZHv78KyRExb4iCT0GTSlJ2ucrV0Ur+1jjkW4R0kEvRRyPrj3ot9RKMoZVhXOxSOF9Dke9EXdXM +RkV+onf5fLJUYGDnb9RWJ/Z8gzCdpk++jJyPpTb6s1irI09JjuVt7p1DSGdTa+XKvQqf4Qfcdav Ro0tqtvMvyq+WLDGw+v6VKkm7DP/0v4hrlVUJHBukIG1gBn07fnVc+bbosckcp83iJsHBPfFBgld 2JrO2DsVnXGDnL8Y+nvSagIluIoowqRpGE8tT19ST7mg2jFRRnzW8JIDSBA/IQH5jjsaxdQVYVKs AoUZTb0ek9EDdlc5VpVd22sxG75c9B9KY/mKh3SOVJ4Qnk1yz2FGVz//0/4T9DdoXt5oAhaF9zLK u9GPuO4+tejRXz3M0U1wzLc7wqSogVV9MenpXlz7Aad8huniuDeTSdPtBZcv8v8Ad9q6OzQARh4p dzKWQhcn1GfrWYDLue7toBqQtJrmFZBbrbY8uQFv9nqOMnnjitFZbays/Jt2lnlmQtH8u9IcnJGc dsmsHe+pLim7nPwKEmN4Az7wQoclACOufyqWGx15pYpLuCKJbiL7RbmB/MBiOQC3HHSs23FjSsrI /9T+MtNOjRJftEiLJkm3aOPAB4++Sf5Uttf/AGZm06GSKZ4wtzL+7G/JBXO7rj2zivm5S00Fyou2 bXZuEWUMbbPmZz8hJz+tSz3kEF2L9bcBIcBhISYwRnkjpWMnZE8iuWHury5dZDdPcJPiSJSgUQoQ P4h1roLW7u7aWDzZm8pmAEm47k7dax2GopO6N5bCRtUjA23Oxv3VwvzvMSeFwOvtXtPgW0lXxNol l9jlEl9dx2txcOhhKxs6740P94jPHtXLjJfunfsyZv2dKTfRM//V/dr/AIJ2+Gbnw98H/C0ESOsM OkwTxzQ4KCGWKNokfHGQS4b3Ir9MY1yhLgM56fSv5Fw0ZWlKW92a5Tf6jT5t7E1sdwKAEBep6mnS JvHTlTgNjn/PFd0dIs9G9pWEXCLy3Q844NNkkYKADwT8ueeKKfUoTYDhXHDLwfSq5JBKZOV4U4wT WglqtD//1v3qkhtlwIpWeZRkyAfIM9hVOC3/ANJ2RoVdhycda/lCU7QsYx0lqacglaPbuzsUhkHt XN6pYiaE4ZJ5JY9hilXhc8YrCpJujZm1TRtH82f/AAVQ8H3Mdm32u2jlgtNZkl8OoJA0hlWPM1uT k4VUyQW4Bdq/mj1LwxDHqV5cWdmyXFqXuYNPkm8uDGS23gkAAZwR6V+ncDSjLL5Rj0f6I8mglFSS 3u/zZz/mC6hW5lS3guCSJoIzkD0OT16Y/CuRvYnsZkaX97HK5O2Rxu5J9PT+lfoVJaXNGnZn/9f+ NO9ureGNpnnVnMQaKOJxKxOejc1Fp+pX9rqUVxHZXQvngEMWlQsQtxvClW56ZHO4cYb0xXz555b1 lZYvLvLWSOOd4t1xDGC7sFOQucYOCTUGvqlhNpdujvff2np0V6LvbhIS/LRLyeVPFXBpJ3HZli30 ibzWaC/ktLma3CLI64jiJHAI/Hkn0q3bXMy3FnoUz/2hfw/62eGIBJOcDbjg5PYetUpK2o+R3sVd USddXL3g+zwCyMbQhyku44UHI6HCnj3q2q/2dI0dupE7QqEZny0ikZXJJ5PPf1oU09ynDXQ//9D+ MC6f+0FktxJcWs18pt4bizGXR8/MTntjPT2rW07TzarBazI7fu9izvzvI/i/T868RS96xyOOlkWL u71BpIrWGPiVjBHfOcwIQOS3+fSq32edJotgDtGhd5N/70HOMj9a3g+hkWpdMjuLhp/NG+2RHLMv BY87fr1/KsLW9NmvrCWS3bbHaEvLtIKqOh/yK6aLaZctkeQyQjfKGfMQO0MpyPzqeC5aKFrUlHjY cbucD3r0lqjkP//R/iU8Ez2C+LvDK3LzJpsmtW0V/JGCSIhIrSBQO+Fr90vha+i6xoWlz6HfXcWn XWuyR22lNEYxEEEYMWc53fMFIxn3r+tvo2TX17GU29bR/wDbj+U/pHwtw9hp2+3/AJHu141ok0V1 FLtzP5LW027IK9lz/unjrweDWpHq1msz3d7LceYYhFGWbciAdMZPFf2U720P4nfL7V3KtrfxQaxZ I1xcX8T4e8j8jy2UEnAVhx+OPWtfxPf3Vvchbu0jsNMuoUuIJFfzTKOCBk9DgDr60K6Btcmhxd/q On6jLDpuy6TTrq2G20hJuo3uQQQVzg4JA49Caw2v5pRG1rxa2V3seB7ZrdJSvDKVYAt06nPTrVcz ISVmf//S/MO5vk1C4jEykxugDrCgjUfgBip7u+1C5Nrp88ax2dvGPLlSJVlkUH/V7uvvk5r/AGD5 5H+PLjFx8yzY2rT3UbyO9lAJGCOuJpUUA4zyAcnA/XFLfa1Hot81nbMzpqMiO8gTG140wGx9Aatz SQlTVytul1Viindd3UwQSNwrZIwSf51h6e8dtf3D+VeNGqBLu6tgzQICDlSOhx0OOmOapN7idKKO xtjq11C9rDdkA2wEdrJFstUgQcFR0BAGeOT17mqoggitLmC0m897mIxzOr71YHqAegFaqV9zGVNX sf/T/MK0nitVt1d2VVKxuZDgvg4259xW5e6dpuszG6s1j02WKMvKokLJIiAsSCTnPHQdfSv9k4ya 0P8AG6VKK2ZiRTKs0AS5uPNhlyk6Eh0wflII5GMfnWlcrcXAnmvBczykeZ5simV7nPU55J69/et1 JrQzdKNiva39/p9s1s/72wuS7Wiu2xrU4UHGMZPB6+nQ0yO4+0NEm0JGW8kM2FA56mtU290c7pRu Lpp0pI9Ui2TNOboW6h90dq6quCVU+h4yOuDUkls9iMwSyS24wVQgoSSMsAMn6fgK0UpbEqnDuf/U /NuG1iupommV1NyoVFUbGORhQc9OfWqEcDQySxRxiNLe4YF3w4LA889x29K/2mUns0f4u+zizbi1 CztoVt/skDiXJuWkwN/J5HHHbp1xUGja6zrdXFjpqLFpiNFDHBai2QBuN2xsA8MRk/3cU079DGdN LUiutTk1G6iiluWRdoCvzvOB0/8ArUn9tXelI8MUK3KM4wsmR5ZyAW69h/KtVKSRzuKbsWllgvRN dvNu+QeWE+6W4GDn0/nTotfvbIXLwu0PnW6xSRJhYPlzhiMY+vrV3M5QSvY//9X80baRZIo5nuYS 0kp2KnynjHPpj6HtVmTUklQ20zFEnkCgnKxblOQWx6c8V/tpBvY/xClBW1ZHpZu7X+3gk8cVvOVs 5ImkVlnjOxy8fsWQdOeBW5b6lcL9nMs1o9hD8s8NzbxzJOBkjdn+fbHatDJwTI7uYTmYwoltMwJ/ dqERk9AowACOw9ahURWkJ5UzyxLJG0coZIfbA78dOOtaQelhci7haRefHPcy3ius+Vmgh4ljMYGC QeMHA6Z6VzbraC0uLR4preESM9wVdkMx6h89R0FaJ21J9mtrn//W/N+0trR4NPks7mRriWFxcQyx /cAJ24bvkYP1q1ZCeItK8DzK7eZGHO1QoyCB9SOv1r/cJSkf4bOmk7WKV2tvFctKtvLZGfDxxync D7g9x1xTf3vnQeZtU3DeXEANu4j2qud3EqS3ua5jSxkBZWWUHEis2Y3BxgAdj171DHuM8aI8FvIX 8wTTbnQAc4wM47dvyq72D2cX1Mi5nvLjU5DeRxXChQJHLCRZtvAx2xjH5Vo+e1rPaXMlqYIrqLau wkgBTtPPPfJ/CnfuRydLn//X/ODUri7gupPsd9DNBLCiOFg4AIBb/gQ6Zx2PvWjaXFuk9i8sTvp4 lX7VJKTGeOWAxnrz71/uQf4Zcq7lOXVYHnlDWbx3XLRTRyD7PCN3yjBGWytZc8s+pavDLPdSJcvC yyCGMRqyEKpPlqAOBgcep61Sk0rFezRFawW7m0S68/yLWVViMcnlu6pwR7/jXTXf9n3EqLpllJE4 iyUabzmk2jOeRxwM1Sm9rBCnHTUpJqn2kGaR4GRgUiSBAgXbxzz7Cq09wlxYo5DQTwzvEUZCGlXJ w+emKtTmW6cL6H//0PzWlkhgt0lihvJi6bZGU5t42+mfSo7b7NtSNHkkiii8xtqbJEYkkpz1Ar/c 9Np2R/ho4RTsQ3hM1zawxzyfY1/eXUR+UPICPLwfYbvzrY1GQXjsttI0NoJVMytz5eO2Prmq8hqK RQNlHNbyTyzOhjfCq67RKo6YIPX29+tU44RcZlik8kQkllclUk2g8fX0qXfoJxitxkL+aZLzY2xH K/c2qSM8DtWpcGee2S52ZGQoVmCkjufw5pNyvoCjB7H/0fzCXUVSdEMUg8s5SZ1ygORwM+/4VI1t PdyskAfe3z4iQkjPPAFf7n62P8NeSJdvrm0S0iSNvPu5IhHcSOgzkc8fTgfnWJA0ULGXyl3v8pYL gHHAzTGoQ6kx2TqQwK+WfM3bwq4HtU1tcCBhJwGKFolI+92/nQO0b3MSW6nu2V9ksDqxA6qcng/W tplkRYJhdkypblTFDwpz13e+M/mRVcrSuJqNtT//0vy6XUFjI+0QBnlGzcGzsPQHFLHczRSu1rKY Ljyy8EpcRKGAzyT7A8d/fpX+6B/hqoxsVjcSzTRfaJVEn/LbauA5PU/nWx9klRiGZH2J5ijcPmX2 /POK2963mHJG5Uu7q2j8qZlCGEZYyfdzn39sCtPSb+G5DRypDDGY2khuNmSWVSQmevzEAfjStLZs waXVFV2kkOblQpCkuinGw+mf89KijvY7lFsyw2pmVWtzsuBx/Ew5I4HWq16hZdj/0/zWsZLGe3li 1PUXtY7EF7QSWxnWZjztLA5HIXrnk/WsqW7udQDG5y4LE9coozxgduMV/uu031P8MFZaWLNhbqEu Z5p1trW3AJdm3SOxyFVVzznH4Uv2lEikUtI00jj7PggKB3yPy/Olyu1rjuuxDM08i4TyFdJFdZJi cMAfmUjPekv5Ybe4Ek0yfOnltHFxHASO4xx1HtzTSa3GuW9rFu3ihslmgTUUYPDulaJjItweGCfn j2FUZpY0MfkrL8/+uLHoe+0fl+dO2hokr7H/1PzD0jTSNOuA89vAs+oBGErGSVgN21xxwMHHH69K niS3e6kjDpKsMnkO4zggHkjvjiv917Puf4b6LRFS1v57W8jsnkR/JnaW3ZE2YUkZJP4Ct6e403VL q6MTyRxIdim5TB3ADJ/Oiwk77bFFxDLZCRZhMquURx/y02nBA+mBWVaXESYd4XwxKhHXaw6gZHtT L5vI0XlhlZG2x7ofmT5AcHqKoy3N3cSyxywSRxB/N3EBYuvDAA8VahdGc3ZH/9X8vUjvIo55DOwi mIXy0lKhlGCMjPqM/lUyvEoWQKsjd1PQ/Wv93PZn+F4+C7meJ/tJCJGTwDtBAzg/pSSqXiMr5eAq QG/vjHr/AIUuSzK5naxI0ySW6gMVbaNi9/xp1jEzzpykV0y+TvHVlbIxnrg5/WmopklGaMzzRwok YiWQPKd2wvtOcc+uK0bmVruKfYBb26OZFVnOyMA8Dnr6etP2aI97mP/W/L+3m+0GQEn9wACcEBh/ KgTNJK/HKeg4AH0r/dtKN7H+FbUr6lg+akHmvNF5cjbUUuPN464XrVq0vXiR1jwxnXymTGRKPQim laVrCkny7kW1bYSQybRHboXO45K+qj8+nbFUg8k93DbQhdkiM0e9Pu/U/wBPanKOhBoS21uY7EQl XuY7PZqc0ZJjmlDN8yg9Btx044qC03mVtu7cFKkY4wOprILM/9f8y7guqj5DISOewNVJXnhe2SOK QrIrNLIRtSPGMD3zk+nQ1/uwf4TjbiUEqY90W1MStuyWIzkjjj6VbtWlljBQYCHJYcEcda2io2MW m5FlrqVhEgJaRJ2llmZctIDjgn2I/nUN3exyTOzOGlYckADJ6U0ktjYy/OkLMPMDMTlVHYcf5/Gr q3Ys7Np9zG8LbUiSLzAANpySeOecfSmFuh//0PzDtNQk8m6l8h5WK/KxbYq567v5VBNqG5I2jgEP ygEZyAe/Nf7yQSsf4UOPKacd68tuIAc5+RYjkBc4wR/ntVKCSeFHhnEf7piPlALnHHXrVcqETSXy ARrwqOQo3dyelMnuYonKBVlLr8rgFdmMdBx+tJwQmr6MltLwpaywm3gd5iJN8ibjEVP1x9fXFVbh 57iXc7oIIV+RYxsCckkAdPyrNq2hDWlkf//R/MEPMwMu3cANpkJ5UdAP8+lPglQEtMWVQcO2ev09 K/3gP8I+TTzHRXUDpP8AvXUBgMBMg+uef8arxyXQul+zgeQxwDJwMDOcfhQChrZlyW6iRruKNhcR NKskUygr5eBggd8Hnr3xUL6jbiVBOJJHkX/WoSDkdmJH+cGk3ZjdN20QwXau7LG+cDLDpjtVhk1J FR41uYrViGlkVCUdecAnpg+tMcaT6o//0vzIMwkVjG6QmEHIHBfrk+9Vra4K25mMu8eaUZ3bo3Jw P/rV/vC7WP8ACV0pNuyH/aTmUb1YR8sQwYEdOD+IqI3iXDB7WIBtuGVVO4bRyfx5NRzRGqFTqiO3 1FIt0kkjFs7EGfkPr+PSrJlDyJJEGcmMysEGSijOT9OKOeJf1ef8pa+1xW3kXxs2vYY5As0co2xX C/xIrdjwfoRUV6baFp7nTrdYtPdBPBbNdrcS24YkbWwcjB7EdPzo5o9zR4WT0sf/0/yzN2iwpc3o H2Gab7OG3BctjpmrsN3GWkjKH7FtEdjcqcpI/OVY+wxwM9a/3d549T/C36jU6IlLraQQIrSSXDyE Fzz5p4IAx6c8e9X5dSgMMMb3At4JflupFYO8RTG8ug5+XOeafPFdRfUaz6Mqw31lewzQw3C3DRsy xxAlJXXBzIOeMcH8quaRY3WqXn9n2TxxXMUBnaC4mWKS5ReTsLEZOPfsfeiVSnFXb2D+z6z05TN1 Bbdrk27C6P7pivloVfcoJwMdcdOKxYNQh/dOzMsU5K20hH+tx1x3PvipdamupossxL2R/9T8v11L +0LQiwtboWkLbZ73a32S6dMkkEjg9eDzRaebcwi9thvtzILZZVAkDyN92Pb1yea/3Z+s0e5/hksq xL+ywaDVbfzDf200EUYZ42KF1cDrgD/PFZLeI9LXULaCXcjGASfZWYqbkgHocYG7B6+/tWU8bhYJ OU0l6nXT4fzGrJ04UpNrok218ia81+zt5IJZVNlHdMYoYpZFyX5woBP061mXPjfRLSOVbu6gt5kl 8uOR7yKON+mRgnkj29a555pgov3qsV80dMeFc3lrHDza/wAMv8iSH4hadpT+TI+mOt7CRDeTXcc9 rtI+8CGwp75PtVR/HHhGaBp/7esLEofLd5b4XRnc85REUlVyD19qzec5ctHXj/4Ev8zRcH523php /wDgMv8AI//V/IrTfiD4auEdLrxDYQG3hZszSYNwE5AX3PbNMb4neFVt2ZLu3KO3mQkzp5xAJVlx 39e3Sv8AcGef5XTWteP3o/xUo8EZ9UfLHDT+cWvzLMHxM8CyCWZNcsVjkPlQSTCQpCQQWUsFIB4A 64qT/hbPw3sp2lm1aKVbaIo0UbvE88h4URybdozjPJH41k+J8oita6/r5HfHw74ib0w0vw/zOUuf jB4Ft2+0nVki87fKsf2kXJBGdsbsB944pmn/ABz8DT2kd3Nq1pbBZjBLLtaYNkjbxjAxznn+tZS4 tyaK1rr+vkdEPDLieV2sNL8P8x8nxz+Hr+XDH4r0prszeQtjtZCoJ+9kZ468VmXvxr8AwXpX/hJ7 UQPjaXV4xG2cFQWUbuhORXLPjfI4K/t0zto+FXFE3aWHa9bfpc//1vxJn+Nnw5jVJYfFkMjtMVVv s0nkTLnGUbnJ+oA96o3H7R/gO2+1TnVrGNFZYbeKWb74J2lsjgHjOCQea/2jl4gZFFv97t6H+Q8f B/iWWrppP5/oiw37QHw0C3jJ4ltpJlh32kcbH96wGWByARjpgj8ap237Tnw2ki8vUb6Se4lhC6dJ ZPGio45cEE/MOO1YT8R8gjvU/L/M1j4OcSSXwK/z/wAiOL9pPwKsV5as32i5ws0UxvBBBDyeGTBy cZxg8VlXX7TnhK0Kzx6utrcKpSC2hYBpU/iZ3z3yRkDn0riqeJ/D8V8f5f5nXT8FuIpNKUVb5/5I dp/7TvggpDPZyzXkoX97FcIptS3opB5/HbWZe/tY+BLq7u1W2v7eSCVY5EF3DbWkbcEgEhjyCPpm uCp4r5DDZ/ij0qPghnctJP8A8lZ//9f8Erf9r/wPHFqr3VtfIl1AbGMae8VzBbuhUo7xlM8bRyME 5PSsKT9r3QXsrKBNDvy6s0YmhmWKW5bs7xnIHHuK/wBcp+MmQQb95f8AgSP8uqXgHnU2ld/+AP8A zDU/2xvCU8aTS2T6W1tBHaO0t8GaeYYXcQRjn0H51BdftkeGvsFnAtvZZt2Nvd6pIuYSSxdMhckk D5fT1FcFXxsyBfDOP/gSPSofR4zhyvUcreULfqyjqn7Xfh+3uAJLG0Z4bVXeUM8UdyWOV2Kp9PTH vipIP2ytAiVLO10aG/vL5TNDLJctttyvLq6lAcYzwDj3rzavjpksHZSj97/Q9en9HPGSScub8P8A Ix7v9tiLTWhifRNIUyRN5Hk2jS3BB4LOTnpkgZqFv201kEVpax2NiuA1ygRFuZ/l4w5XGc9gPxri q+PWVRVoyj9zZ6FL6NtSVr8/3x/yP//Q/mzvv20bq40+2jtbedlgumaSOS3t7STI4J8xcNx2HOea pr+2jqEV9PPqWnf2qblEUWsSRxiVQPlPDqFxxk9SD15r/TKt4+4FfDP/AMlZ/AtL6NkIq04N+sv8 rGtqH7d9xqduNMtfDGm28UKBninjh3RPH9xo2JB684JI471hN+2frsy2lu+ii3uLMAE2TQwzTRs3 zN5pBG4ZPyivOq/SDw0VpL/yV/5HbD6N+EWkqf8A5M/8yvN+1nrFpMkhlhMyzNJFbamgWCZjztZg p5PY801P24vF12yXF/o2l2KW0LxT2z28M6zIOgQ7een3uD7VwT+kPGF+Vt/9ur9Tuo/Rwy37VO3/ AG9L9GzOP7YGtQ7ns2gt4JgJypiWadI5OWUKyg8emSOKwT+2RrCHdYwTXFsgdFlniQvcMD91UbcM HqCemK4an0jKsdUpfdH/ADO6H0b8qf2V/wCBTP/R/mD1P9sfXp9PtbE+fJBaQ+etr9riV5SRkKq4 zweAc49K5OT9rjxBcwXEM2nauY0AmjUJE6bum3O7PHtX97VPpE1p9JfgvyZ/HlH6O+UUlZwj87v8 0y5ZftY+L4rCaay0/wAx5T5Yiu7SKNZivIJYktwT2xmsLUf2qviJez/aLyS4tYHQxyW9iojlLAAD 5t2MDHHFcNX6QeOl8HN96/zO6H0fclTvyQ/8B/4AzVv2oPGdzYwyxrFLFHa4tjdwA3zMMcOcZB9/ 1rV1D9onxi+kWRnAlcRo8ieaI5pWYDIyeuOepPSvLq/SAzdyain/AOBO/wCX6nbD6P8Aw/ypOMf/ AAFf5mbH+0X4mhjuYf7aHkwKEhtVnISEtzluTk89q5qL9pPx7DOscGq2cNpcApPLAXklfnAKPkYA x+tckvHzOmrJP/wN/wCR1rwF4ci9YR/8AX+Z/9L+SaP9orxldI66TqE8ZjvPIvLmed41dOpK88+3 as24+O3jlpyv9qRn995puRb/AGh256HLd+5r+uq/jlnVRt2/8m/4B/N1PwU4foq0IL5RSLGqfHTx fNHGY9XdnMytcqVKKkajHy99x+tZMfxa8U+c2qNrmstLKrFYLq4Jtlzxkx9MjHFeVW8aM/n8Dt6t v9UdlHwg4epfFC/yS/Rmfe/Gzx3tnEniHVNQincTKLq9eKC3cDAxGpwR7VjXHxg+IF1JaKdVktki ZHufslzLslTPzADd1PTOa5peMPEUlbnX/k3/AMkdkfCvh2G1L8v8jauvjN4klLpNqWsy2kbRyxWq 6m6xqy91GcAeq9DmoZfir4tgMl1DrE1wLhx5UMzlRanqcYPPoO1ck/FriKT+Nfj/AJmy8MuH18NL 8v8AI//T/jRufir4vNosU+v6qJGvjKFWc/JHn7oOadJ8UvESQyyR32p3kqzLJFB9sZIm4AI9QDzk YxX9ET8UOIZa+0X4/wCZ+L0vDjII7U/y/wAjW0/4o63CEbU7hp/NGYowTM1mxHIY5AbHTOB9KyLv xp4l+0fbBqUzSlQ8VxckgdflCqpAHHeuefiVxFLarb0/4Nzsp8AZFD/l1f1/4FjVm8fa3LHcXceo zxSfZArWs17ILec5GSig9f6Vz0PxC8QSS+dcX0xjCCKOEu0kdvg9evPbmuar4kcSPT6w/uX+R1U+ BcgWnsF+P+Zrx/ErxKTbxXF7NdxbstLEBbNGmMYz6e1Zd14x1NbaW2ttQvYEurgOWW6eQRqDkgZP GcVyT8QuI5KzxD+5f5HUuCsjjtQX4/5n/9T+MO88ZeKZGxaX13c8bUje4kht4vU/LznuaI/EXi1D CbrXLxG8ze6wXDtxjhSSewPav2b/AF84gbu8RL8D84/1PyaOiw6IptQea7F4+p6kL2CUSI7XchS4 yeQ6E4YemRV1fF13BLMv+kxXEpEyzxXLKr4XHAB69eO1c9TjfPanu/WZffYqPCuUQ1WHX3FceJ9b RFjXU7hY58tcRyytLIVOcjJPB96z7XXdR0671B4ryZRe7WkaJyhJA2gH8MVyvinOZb4if/gT/wAz aPDuWR2oR/8AAUZN1d6jdzrK15cxMgwpt52iKZ64IP61o3N7dXa21m9/dbYSskolmafJUfLksSR0 o/1hzKXxV5f+BM0WS4GO1GP3I//V/iqnmZp4o5JGV4FyrwsYnlHpuFJcX5likEjzyxXO0SxGZmQb DwQM8H6V+nyzfFz+Oo382fGRy3CwVo00vkWJNZuppI/smwbUxGX5Kcd/yxVOXxDqRR4PtMiZjMAJ YvEgPXA6dqx/tLEPeTOmOCoLTlHWt71ZHlWXb5MjROUDD6g1BeXkstwrSFWeJPKXzPndR25NTLMK 23NoafVKd9Imgk6XcECMkoktn3RATFYlOOyjvWZdy6tG0j3Gq3Uhkk3pACAYlHAVSORwKxljan8z IWEorZH/1v4mP7QmkZETeqKm12Y/M3uT+FTQT3u6PjIRj+8zhUFffPGVVrznzH1WmtHH8ByzyRST wrMWjkl8353yjNxk4Pv/ACrptF1OxgRpLizMlwrBzJgFcjoAP8ayli6r+0P6tSX2TD8Sa22pSjzY kgDSed5cR3InPGF7Vl6brSI5gSaaKZiSrKeGwOc+/Wo+s1ntIuGHh0RNEq72EfmMxYysZHaRmOc5 LEk9RUMuoQW/mJcwJPNIh8hWO7yCSPnHvxT+sVe5aoU30P/X/iNKx3ktrcLLO06KVRVJVIsnkYB5 zgVtXXlJE64yZV8t4ydrD/PrX2rr1Lbng+wp9jKZoXYiU740XbFFM/yKR1KjPWtLTb+2eeCVcfuv 3AdhggHqorONactLi9hDsNvzbxXMuFBRSWQkD5c8msa6ui+BKGYEbUbO7C+1NTmupl7KAlrchAi5 C7ZflHQ4q3dXbTukcKSp5R3+YF2pIcfrTdea3ZKoxvqf/9D+HK4iW4k8u93FpBuAI4GO5FaVwklv a28DOPJ27kKsG3CvsfrDPmJUYvYyTO8e0IMrnPPetjTbuOF/OmDMucNGvIP+eK0jXYvYpLYryX4u LwkReWVOxPVRnvV+R5ZUzENpiT55P4M46Cm6zZoqUbGRFIn2mP7UQyjvIeBWw00EiTWSqn2RpfPK n7u7BHH51LqS2D2UT//R/h2mNulyUYgImMAL8tU5ZYRLuVQ0fQADYTX2sZtLU+b9mlsWvtcCx/Mr bhkKOq+3NVIZ90hUp8yYdQR1oc10LskTLMIA7FmJZ8bAPlH4VZilZ22QKPn+9ztPPFc7m09C4wUt GSXRW0i8uL76fNNIzZY57Csz+0JZlCRkBVY4A4Yn3pe0lswdNJ6I/9L+Gk3jW0u9g0qFcOij7v0r pLZYmubWYeX5V1GGjG4H8wOh9q+rc30PCjG+5Z8Q6WZI7Wa2hUAFvtDO+BJjoUGOo/rXKtc7wxlc kp8hDdTis1LWyLUEio9wFnUuWaLbwPSr0kaSqty77cLhY84BFWptDslsNGx0UKQA4xwemKSOdoTt llcRk+XtH3WHPOKtzXQdu5//0/4ZnkhEhjRpGRj1xwPaiPY7Ns4MZx9frX1Tk2eNZGpMluDG8Tea x4MZOMEdDQ9sWja5AwwO1hjofpVKZLhd6Fe2NxAkjJLGh8wEKDiR6xpH3XTOEkI3EP6Z781Dbe4e zRsxol3bne2DACQnTaKrwkRsDHCflPLlsYpLTYUI9z//1P4ffN2lCjBgecg8iorm4R4iZOp+RTng fhX1F77njJcqsZyXSxEpHjeBlG7Zp7LIw86WUvKxx5QGAB7ev0qJ3SGNGGbZ8wOMEY+YHpU8Uuz5 G+YA/Ke4rMB90uB9oDBiOseclBUCncWKxZYKCNwyDSA//9X+F42rwsIpImQ7vNOeOD71djkkjhkh iUN5pG7I5UD0Ne3Pc8Xl964nlPKu1CQyjJGelOnaR5A8m6aQKN8mclscVK31KexeSZpYoo3t2WN1 wCRjp3Nalui2ke+FhEcfvGOPmA7ZrVcqVkYtSbHOIrgEjaC7fNJ1z64Nc3eLFGJBCplRX++ozxnH PoP8ad13LUF1P//W/hpgRWTzFfbsHCk96zy0wCyPuCh/pk/5Fe/eKPEUf5ty9E7SAlM8nn3q3E1w qs2C7KNojI+WP3Ipc8Q5FcLqaN0DzbvMAwEQYyRxzVC1cNIQ58tffmlzoFBJmh83mlIggjGDJgcH HeqpdTK8fmfuuoC8c/So5ne5dj//1/4eIQ8MTSY291Yr97v0rRh1CLULaZ4xtnttquZRsZ+3y+or 3Oc8rkZpRy2e5k8peYsv+Xc+lcrfxyCTYp2ooOMcDFHtPIfs/Mji+SAeXkhn8tjjvUzxiMlIyHlz tbHIX1pc7FyMnhiEe5kbcUX95EvLZPrVNWlWTejmKNnwwzgCk5NjUO5//9D+IoyWs0ewxt533dhP y/72ao3A+zCU+eDviBIAG1eOwr2ueR5ns0ZNsyzsnmDJ6pIvGcVsyb4o2Z1TawwOeamU+4+SJnfd RvLLKOpLDqafYbp3cXDNtX5VcrwT6Gp9oPlXYJIHadmQHEZCgAZP1rXa5kaIxxQ42qFkVvm3evFQ 5tjsf//R/h/edpkk3LIk0f7pl27FUY4A9qqxxRDyZCSQHw6/yr0W31PPLVxcyRbli+6w2yMgHK8f LWe1w0UZAzhyOCMkUgLiSpP8rpIQIgHfdtVMD+VZ6YlljiAIySRKDxx0FBUY3LMkKK0MUpmUSMQ5 hXcFA7mmxQSJA+4ttdimFO0n0Oe1BXs+5//S/iE0t5II32SM6I2Hhc/IxHHBPethrl7tow42YXBX +9jpk/hXoHA1Z2MN5EiZobRlbcxR933EOfWrN613BPbWbsuyNB5qhgyMSOx+gFYPdiIkupYfNt3C bZBkAjcU9OfyrHuIyWL5OB/ernatowLNtbRgmeYKMqCi5wpPvSvp8czKFZIlZslhznNS720A/9P+ H77I1sfLizIyjnAxmqk9vsmEkpCyA7grdKmCstThUWzc0mxk1OBsz+WYWJV8jdIQMhcU6VLe0Ys5 +2RXB2yJMM7MdefQ+lUWoLqTQN5gaONFitB8wKtuQ+gH0qvrNxpcaWk2mXFx9sGYr6NohFGuO6nO Tn3xQEo32JdKntbiXzpvMdo4iqp2DDocHrTbyWFoJJ1HlsGwVAwGFA1BJ3P/1P4cBcCRlUusSA5T a3T3PvWo8yyweSHF04XYXK46dDWcznKMaXbbI3TCqeGPGR7U+RH86NZCGjjb94Cu0iqhtYCzParK Xe0JQMBuQng+uKSS2uDEsds0Ec6qAqzShDKfQGm9mONk9TUnmuBbQQXX2azksYsMtsPMkuGJ5Z3G cn9ABVa4uoFEcUbtKjKGkJ6Bu+azimpaiP/V/iF23jQTXdk8QkgA8wSt5SsuR0Pf6CuvSSzums7g 26oIEDvDvJjL7cE89uehoMobmPqURCyXC5ZIznEYzz04rnJIHkInkUgvygJBOBQakCxFzI8p2+Wc DeNowPT2rj9cuGeVogcRBMLg96ibtoFuhmJGIEQzZXIDKCOTnpTynnO7biFOMDtx6VzzWgWP/9b+ Fnw7DGtwIpGADON5K7to7H/9Vdhc28yMmyQLCWwQOMkdDXl1Og1FvY6GNpXhKExiVMBVT7z+/wDn 1rsNMEVqscd3Mbib7PlUibe2SMjkfhmsnoinBpXIlvmuVnaNN01vJtMbnyWznHOfbNXzPbzEWtuk TXNoAZpYmzEA+SAe2Rg9DWBLi1uOudOR48yJDNEG2tEHHz+oIFRyX0EDASf3RHFCj/OMfwiontYu MFa7P//X/jWgL3bxwSGSGyhmM7QlR5pDYBz69B+VSPY2ceoanPZvEpjt0EImI82UbjwAOp5B4r5c 25FY0Ixf3Wn6hJH5Wlwx2qx6eQBKt7ICoYbT0YZJ9PSp/LUaJawpEkl4sDG8e7AMczkna20dR0yB UT2MmrOxtwQsmnxSNZNdKiAyRW67BGpwDj07VAptWVVgidAP+WczB2B/rWL2YrW0Oj0vFkFN1KxA YypITzH3A49O1fYf7Nuh3Xj74o+DrNB/amnSXUX2mSdtoZDIoYK398HHA5615mYVLYeTemhNSm6k HTXXQ//Q/pM/ZH0zT9C+F/hbS7O1k0xv+Ecs/PtkJfLeWGlZiT/E2047DFfX9tHtckyZ3fdU/wAP t/n1r+SKT3ttdndhYKnSUF00LzBLcZyAW9OtQu+3aMfe6E9DXSpWVjptrcbsXcXOAmOc9KrzDkS8 uifdUVVPewywkzSRq+zCD5cY70y6MflbynzgcBerdau60BK2iP/R/eyG2aDeu4OS3HHOKtF9m0D5 mT5t3Rl9q/kSUraEuOpCJZYFedowcjKxt/FWPJcC4Et08SptG14QfQevrRN+6XNe+fhB/wAFN/DV 1J4ckm02e2/fxXFwtw+WkBkyzjB7hM898Gv5NvEMU48SahHZ6rI+6U2QuozlIWBKlG7Y9fQMa/Re AZ3oVI9mebh4J1JrzZ57Fb2ukPdvrN1Ckk10bdGZ9m1lwBzyGU8gAY55qhdWOl7la1+0vbqJABJO ZfKeTJLbjyQDyB6cV+nUZLlKe5//0v40LPwvbR2NvNLfxM8d0ftEFwCBMhJPytnqSentW1qAhkvU lsWl2LEsJkY4lVAMbQR26j6V85z6nJGK3H/atKtU8mdCxtbY3CxSITuzkZyPfNZk+m3RsbLWppbb T1juC9lYyzbprmIHIMakADkk9au+hZlW+ptrE813aXF5uMpUxSwbUcK3JfIyOmOOldmqaOy+dZpN FKy7XMTcQTcnKtzwSO/vQBxN4l7JHJJJmS5gPKuwBkweWB/WqE9xqCyx3ck39oPJgT2xmzNGo4B9 Rx0+lArq9j//0/4x9NsLWK6tft15qMKBnuEdITLFFuBHlH8+vXiuqXUIFt0Xe4t7JTGGdd77euRn 655r5/0OWUraHOW+sW108kMHmNbRvuhYqRJNzzx2q5LHOsl3Kk0ZVYhMiq+2SNSBkE+ufSulOzuY i2fiGzmvE0ZxKTDGJbhljGz5hwC3qcVmeJrWGys4o7a6wbvc89gh3RbD03HPJJ6qfauqldPUd9LH iN5cxQeVZQW6rbecZLiFDtkPsDz70+VIZ3SWzYxKMAW0pDke5bHP5V6UZKyRztWdj//U/h08N208 GqSX7hZdP0lRqFwm4o7FSPuDOSR7V+0H7O2q6fNYaXqiTm6WW1S6iijLRraMyqYznqzKF3Z45Ir+ o/o44mEeIK+GvaUoJrzto/zR/MX0i6N+Eada2iml6X/4Y+zoNYg1ia+nlEaFsi5lu0EMSsf4lA4y c5z6806W1guNOvI4LOae60mWMvcxQM1o8Ex2k7sclTzkcc81/b0naKufwtpOoaNlYQWepvpxljlQ WiG2mQ5kO5A6jH449vWuW1EWjzXVreWrbppQ9zi4dl8yPCDAJ4xtGQMZxSNPZ+5Ys3d9Z28drGkU COqDyPKgCsrAcMSOSeM9e1Y1zFbSGJEvXgLsJ2tXXe8+0gSY+ufwzSbS3FCGmqP/1fzJtJbO0vY7 lARbW8Ja4jnQuDlgAxx0GePxFZX/AAkFxcTSrc+X+5nY2wWPAMZ+7n8BX+vymmf4+SXum+blpdBu 5IWVJo3U/u1yyg5DEN247VSSewELXlx5cs0Vo3kK6eajSYwoYfj+lUZGD4dvHup3lWRg1pIv2lIw Stqxwevp0xW4uqz2jQ2ZQGGzummcwkK0ytgEO2DkenpmrjO2jAtX2uXsjpIWeBZlEEJQbMooC7dw AzxgVWhvrTS7iDyJHLtPlIDF5gyx6sOh5PTpW0ZW2MprU//W/MbV7dpZ0tR5fmSgFVXBIJrMMV/Y b1uiSIU8sTxPujkDA5UAHORjn61/sfCavc/xws+xa0qba0pCH5e6j73sfzrt/D+nyRb9VuNTlghh dnihFwGJTaw2BOoG7t/tV0RknqjOUHucldy2tuk01/50aoC0axJ52XY4AB7Dnr6VEln5EkcjTKYH gE4XcHxkBlPHfGcitudXOaady/8AZ5dQmeGGJt9uisSy7FIOSpBPB6Hp6VR1J52Agin8q6RMI4TK qR1GDx7VpGaRnaXQ/9f82rg28I0yGxv3nuJII5rhrhBGYZdoLqvPQHv9OKyYYbmLVoIb+9ii026k MR8iMzThuPmK5A9q/wBpOc/xbtNFK4tJLW7uWa5d7JZCbd2QKzKP7wycfnWg1rbx21vNN5wMj72V f3bOnGCPY804yu7GMr2NfT4omlivrVYZ1XdGhk2gxsoHUHv0/OqcjNqEZJOyNJyJp1QN5OTxx/jW vM+XlOfllz6lS4gitybKe+FuoQXEUiZZZuhUcZxkHn0qxbM0lmwvHidYj5aqoxuU5x1/Lv1rWOyI mrM//9D8xpLe4WLzYoGFqJNiuV4jPJAz06Vu6BY2aLc3eqv5sAQww27KQFd1IVgepwefwr/bSn2P 8P6rk9EZz2EEdu6T3O9csJI1GZAOSp7Aj8e1U7W1N3DNdqhVNPwrBJC3yngHb/StY2vqc7vfUsu2 yKO8d59k5EduPLLRScHPzdsDH59qSC5F1G9v9l8thITHOWIdhjAG3pjj61rG1rITk0nYs6cl7ZQ3 FzaHylfMV2WQSgKx685C5IHI57Uw21w8cxuPKaNNxncuAynPCkd+p/KqJU/vP//R/NRF2QxGKKUx xKC2w84z2J6fjRJe3UMLQxSKwaQFTt5C9wf1r/cA/wAMudlS9hgmtrUXd+8MtxIUQIcuqr12/wCe 9Ohs9Nt44pDLq32y2l82GWe42wN6HaeuRkdcU1owTlbQsz3sQYPePMY8GXcp3FyAcYzWp4f1q2e9 tJtQMNraxAxGY23n7Ubdh3QDLEbvrwK050CUraGPYzO01w8c6TFoWt/JSMFpWY4wDzg9OParksl7 dRRWssqQrpduSlvcAK6AEZHuckcH0pc/YTT2Z//S/MomcGDe6RxmQM7uhcMo64/yannuF1G8i0+1 1GG3skaTYGTa9ycfKTk8HjHHrX+4ntEf4YOLEtriKK7ENzBO0KfNPLGoLKAegyal1a5trmaO7hmS 1IlMMNtja+xskAEccY9cnNWpKwWb0RURoY4pLSYyKkk5ltZSS85GMMgI4Geo+lO062jsbDUJm1bf JC26DTrlZJdRnB4O2XG3byRgnPFaRmrGsVaJVtnA27IljUD/AFf/ADz/ACq1cXM+7zJniIGAsS4D KoA5IHr61akmUf/T/Ov7daRaZCBAA7jeoPOT0LEfUdPauRii3yysbqWOGRxJgfcjK/QZ7c9epr/c 7mif4bWXYtwyRskvkqGSRgS55+YcZB/DtVeAJNeeXM0kEK8ySjJPT+EfhVKzC1tUi8imVTZPeeRC JC0MsiM+PYgAnnH4ZquNQgTdp7OiSoplIKYdl6ZB9KbVjJ3b1KwupGxbwPI0DtlQQVjJPGdvrTRe wQi6tHvo45YOFhIMjGQnAGB+fJ7UgSknof/U/LJNQv55bZdQmiuxbnJYRLBvX0wB/nFbNvNfL5v2 WaaJrtDu2NsEijqM+nWv91IxTjqf4bK/Ux5yk8jSRIY9iqgQNvDMAAW/E5OPf2pZJGlWGIsEMeGf ZwJCOx9qPZ9hjXR8H927QY/eMOQPamFghhQ7vIVdqsx+4OuP1NQtGXyM0ZDZAPCMtKUDRc7G/wC+ evP9Kh0u/VnEAEdjJHc8Xt6nn2/GCMouSRweD69Kpu8dROMkf//V/Mk2+hpcvIrSXd1PGQyICio4 yN6g9jxjjvVQRxz20sskJi8q48lRKBkkZII/Kv8AdG3Q/wAOFF9jOliuYQsZkiR87wzxbmI6jvn9 auRzGUxfvVeaSTZFCrYd2+n41q5KOg+WXYptc7Wnt762ilbzMGOZTujCngYzj06jtUgutqYVj5an McZ5WL1xWUdGZSptvQa2oEmWSU4G0lyTg5pmnvbI63bqUSbKh0XDMP8A9dbJp7E+zmuh/9b8smu4 XkdXdFto2zG7/wAXrn8qfJdiJYy/7uKTmKQrhZB04Pev92D/AAzVOXVFJrvez5kUopxtU5U4z0q5 FKuIZJXVA0ZeNzk7eWGOPUig1cJKOiK63cBLzSNLiJsiMDIl9fyq5d3Wn6jLuANtJJGEww80zMB3 x9KqKuyFTknoU1W2Sz8mJ/8AiYPPuM7yZVUHG0J+vPoPet8QWturrd3KSBbMSwvGDtdmUMB07EkH 6GrtGO5sqU+x/9f8tYtTtbiKS3tpfLZB5kglBQsQT93PPQ4pLi9EEanyXt88LL/eHc++a/3YbV9z /Dv2NTsLFcWUix3sN1BHJC2Ss7bXBGMEdjk9qoy3jiVtzBWaTDcbTyfSlddyVSl0RpreQ48sS4WA lN4XknBI49/6VTt5jqE8sESESxRNPIqj7ioMsx9P/r0XRaozfQcsmnBQttqMMskjZeESEzbu/HoK iTVbVpDptzdKil9uZX8kbgM9apVUtBywtRrZn//Q/L8LC8Kzx3du0YmFqYfNAcMemB3z7Vnb2tPM kuVeJI3wVZSvJOAfpmv92nVXQ/w7WDq9iS7keJA8k1skjFWS3EyCWQMcAqgOSPpVlrhY4nTUlks5 2CraRvFs+0M3QKvfP86ftV1LWDrdIj4Hsktlu47lZ2hLJdW06eS8TL95QCfmOP7vNYVjew3r3Elp cqbhJ9v2F5GN5g9GA6Y+h49Kn2tN9SvqdfrFmuk3kxLHJp17PdSXSoyiMquzvsOOpPfnp3pmo3kO nWv2bUCbVJpiuZDiRDjpjPvnHtT9tTXUlZdXcrcp/9H8ojqNmtt5sV7FHD5ixAzN5Ly5OAQD296F M0O+6KMYPMEfnCQeSWJwBuzgZNf7s+3op7n+IH9m4n+VkWoanpjQSLJN5c1ldJHOYwXitpA3zR7h kE46/jUy63oUc06PqZka3YLa/Z4Hd7okdh1A4xk8ZqFiqCbbkWspxb05WVV8Wabi8nujOkEEgtlU x+XKXYHB5646ECs+PxHZGSZn1WFhGRstpXWCaLJ6ENjjnp2rnqZjhErOovvN48N5nPahL5J/ojRb xNoNre+TeeIdNtoIYVnu3WbzcbsfIMdW56U+Pxj4fmulS01OGKzMjQnUblzFCjAZKuMZBx2xnmuZ 5tgY6OrG/qv8zo/1Wza2mHnb/C/8j//S/I//AITzw+HPm6zpDQE7Y3/tDZu9yu0sAOpyBW1Z/Evw pDpkoGu6DdXIZoVxeOZmjYbSFBAAUE55Ga/3E/tnLYrWtH/wJH+KceEs5nosNP8A8Bf+Ryc/xC8L rcxwf21p5bLEyLKZYsgcD7uOfr3qwfid4WhMVs2qw2l2UYXCXA2Rc52MjDjaQR15FYy4hyqD1rL7 zsp8CZ/UV1hpfdb8ynB8UfCkupW9g/iPS4JGX96wudyAZwC2B36Com+JHgqxe5OpapFiCYq89uzN Gmw8hvl7+tT/AKzZTDV10dkPD7iCSssM/wAP8zDg+Lvgs3TS2+t2jxZfCyxysyqBwThT6jnNX9R+ N/wut7CWS38QPc3MsCukb25torNtwB3yNwynoCo71nLi7JI711+JrDw34jk9MM/vX+Z//9P8VLb4 5eEfsF7bXes2dr5KfaoImm3LcPjGAyrwcdmI61nQftB/D63spYb3WdKupRIJ2h82RJY2XOyLIXAL Z7+1f7Xz43yOl/y+v/XyP8f6XhZxHPejb1/4FxLb9oL4du6SX+qzWcFyzAJZxGd7YnIVGJKn8agt /wBoPwQzs76ppsdrDK433V04nukTvhQVU47E9a5Z+IWRx/5efl/mdkPCXiFr4F+P+Rlaj+0x8N7X y5H8QItk0hM6wKs7WhJwgLFgDuyORT7b9pfwOs4ia5e4gWPbHcwJHDMT1wys5B7DII49a5p+JWQJ /G/w/wAzaPg9xHLTkX4/5EVz+1H4Ru5Uin1lbSOBNgtwIRv54QeWMk+5qG6/aW8NXU/2TSzYiPas T/6W3mPJ3zuAwfauKp4pZFHSMvyO2l4K57NfvEkvRvX8D//U/At/2pfClvevoiyWD3hUXLhrtpLq AKMbdoAUDOevNWL79pHw7MgnEC2sUkQkhC3qqoA+8xVhnB9jxX+w0vFnI47tfej/ACupeB+ayteX /kv/AAShL+1t4PsVktbK08yR7QpPJfsklsjFTsdSMHg89ecdKx7X9q+1sbJGeOO6t5oRcgSx58xd 2T5TZBAODXDW8Y8gg3FVIprf3l5f180ehR8A82nZyvr2i/Pz/qzM6T9sjw7Dby6qkDW1szyI8VrE 12UzgLG6lTj5ivOAOalm/bK0qG1tgLbSY5riESTwX1mnnRAey4IPvxXn1fGvIV8NSH/gSPVofR5z LR1ea3lG3+Zzl3+2RYXVwzxxx2cUkYjZtNtleMDpg5PAOM561bl/bJszdrBYB4biK3WMWtzd+ZDN GFIZsgYPrtz+fWvNreOWT0k5e0j8rv8AK7PXo/R3rySg+b8F+asf/9X+aBP2sLveuoxX8WnXFqvl rL5fmW8zZOfkfrkHowxxT0/bSvmjlgtb/Tr9d+w2w0q2OWPJdU2jGPWv9PqvjzgbtwqK3blf6o/z /pfRzSiozg358yv+Dt+Boaf+2RJDHPNdaSltdxTBhczW8H2SYD7q+UGxhu/HasnUv2w9ZuZo7ews 3torlzPcrZxQoqMx4ZDuBCnn5c4Arhn4+YdfBP8A8lO+l9HXDR1lD/yZ/wCZh6x+13qdhc/YLOC8 gW/t0P2uYRTTW8gGCSyjCjJ6qCcd6ZpX7XvjGzidJtz28ML2puruZXW8kkA3JGwG8KcjrgA+teVU +kDK/uqX3R/zPUh9HfLuW0kvvkQJ+1p4lidY7fUXimEZUwxlLq2hLgg7g69R6rjrWSv7WPiexvAI 5blrx7fa09rBAtvMQcc7gVz9Rn3rgq/SArS09/5KK/JnbR+j7ldP7Ede7k/zuf/W/lwvf2o/G8th ZQatLBceY7SQRwRR2wiB4ydo69s/lWQ37UXjeynWJLp1tYwrWThxcNHJ1LYwBtHTnmv9AZePuKtp z/h/mfx/S8BcoWns4fd/wDHH7SnxC8y7u7zW1tl81rhnsI3hadQM5f58A/7tZk/7UHiaWEyW+sWU 0sil5XYyxSXLZyc9SoweQOpFcFTx5zB6wcvv/wCCztp+BWSx910of+Ar/Ik/4aB+Il4Y79L3KR2Z RIYJnjRwRwA4wQMH9aoj9onx75X2ebWrcXd3ZNBny3mlsgD8uyRmyCM44x+prgn46ZxNctn/AOBv /I76XgfkdKSkoRuu0F/XUzrb46+P5LVLe78SSyX0MbCya5Zn2464wwxmkvvj34xigsZJtTuU1O2w sP2MMgYZ+bnOOMsRn8645+NGcTWi/wDJmenDwfyWD2X/AICj/9f+RF/j341WN4Ytb1CEzSC7h829 kkRZBjcHXcMA88A0J8Z/GaQrJB4l1K0mglNwv2GTIkJBGNrZxjPGTX9k1vF/O535Xb5tn8/UfCnJ Kb96N/kkcrB8W/Fhcy3fijxKwJdZhJqDQq28ksAARjn09auWvxg8Qx2v2OW+vr5SzNb3VzfNNcW3 cDeTuYe2TivOn4rcQy/5eL8f8z0oeGmQQSXs/wAv8jGs/inrpuJVn1O+e0WZrp3+0u8rux+4DnhR 2A4HpVu6+JviBwq2eqS/ZLiUS3ENwftMmRjKhiTgHHQVyS8TeIZb1df68zph4e5DF/wvyIYPif4h UzL9qlgtxISkAkZ434wOM/L9KxP+FleK9NjKR6hJIS5aIu5UQZbIIA61zVPEXiGasq1vSx2Q4EyC F37FM//Q/i7HjnxJeQPNJqV7duZvPlj8wxhSOwxzjoetNg8Za19pnu31HUEiC7BAt5J5ALcHaucA 9+Olf0xU484gm9cQ/wAP8j8uhwVkcNsOgm8Za5CBH/ad88aofLMd28YbPrg/r1rFm8YeILuKW1hv rtWcfPJJdyzEH/gTfSsnxrnzVvrD+86I8K5ND/lwvuL8GoauPLRtYvJI44drRmTcqk/eI9/c881b Xxnd28awW/7+KGNljjmBwcjBLEHJ9e9cdTi7O6nxYif/AIE/8zso8P5TBaUY/cioviVP7Ne0LC3u fMMqPBlGiycnB655656VW/t+dVjt1u9RlcHeWlunmy3PIyeAPSuGfEubS/5fz/8AAmdKybLltSj/ AOAo/9H+KVbq8lVFGrasxjBJ3XTiNNx6KM4qm8MyKVN3clWO4yeexZfpzwa/dHn+ZNe9Xl/4Ez43 +ycCtqcfuRXur7MawxTzxGMYjlSZhN/31nNUbG/u7G7hvo553ktYzDFuYyRkN14PeuSpmmMnrKbf qXHLsLB2jFL5FyTUbua1ZDJIWdsli5SRRktwQR0NEOo3iRlYbySPd8rs7l2I74znBrD6/iG785f1 Gh2X3FE61qkKj7HqF4IY5GUmJ2jlkJ9xz+XrTpdS1C4tSyTvErnbcZc7Jm4GX9T9aX16tqnIj6lS UtIo/9L+IiF4oo433mK5UZYrkBz7/wD16vS6neQBkEzmaRQd/mZ2jH/1q/W5Yqq38TPlY4amvsoy RfTXKkuod0bdkjcBj61o22pTvBJbyOhDSb14wFNSsTU7s09hTtaxINVnEZJffPEPvyjKN7VENYvl eOVEQSJlkf7rR59KTrzabbKVOCVmhLrVZ78lrmTMmwRhgu3AH0rGLu58reSu7jdWftZmlOnFO1j/ 0/4hreaApIk8jFYgN6tk7/p61NcRq8kE0UjZI3L2K+1fqDrPa54vLFLVF2SWVo0jg+zRz8MzN/rH xx69Krw3c32hDv8AMkjUq4Unametc8qsurIdOHYin1KSOUrd7mOdymT5iT2NVLm9uLmWKXcz7QI0 QdFA7YqFNPciUYp2SI7mV5GjUbxIF2Nu4OPSrEQltovNKKEPy+WfmC9s1DbbC1j/1P4hY44xM0sR 3lsE+3HSrn20rGyrIY5c9CvQCvv009jwFuSWmqy7UgZpNgkLAE/Ip6E/p+lTXepF9mxt6I2G+bPI qb3lZM26FMX+6UqjeYrDG0ngUy4u7mWHYGLGN8ggknA4wazd1oSk0yK1g81XLyET/wASEYwoqqVS Nsxq4jU7QQOppFtJ7n//1f4gILiS0EqNnZLzx61pWlwzBgrtGfRl+/j0NfbSlbQ8GUbFWWU3Ugbe 8YVgGOORj2q89wtuGfMs0aDaC7dDjjFTF6NmM+hVif7ZDvKFWWXHX5B9f0oWRhIIw22NWGUUelLn ZnYnlvbGNigUup4csCGHvVAvEJh5EsksDAM4Zdqhj6fpSc2xpXdj/9b+JBpbe6WJFDNJCxDDbu49 jTAhhaVYuWOCEP3R/nNfY3ex8+lbRE32uNEgXyYxJE2ZjksJenvUtzcSSQrLvEiHgIpwIQO2O309 6un1ArKSSZIwWZEA2sfkI74rOe4YTGNF2Iy7W4wPwpyStqaQtctwXojiDZ3OpxtPepGkcRbkwFlP zJjO0+1ZGh//1/4lba/urcLEGJj37tuPlrWkvFmRlASNyoZSecV9fZHjmdPcrJMqhN0qjDOo4Ap6 Km9Q7Z7ggbiv4VlGykTJaWIrmWQJM8XlyD7hyD5oH0qlNDKYxMs3lSbdrW7nG4cc/XtT53cxJbC4 VIXFwTuVhsIGTye9Q39032jyVAPRWdTz+NVzrqB//9D+JVCkyho5t0yfKyv1XHpSI3mO2HEbKMEd N5r7BVNLI+fG28oXLNhWLHBHAIHeqU0x+VI0CwFyMBcE56mnd9zSmWWE0SeVCu1hjJz/AFpRGfMR mfzJMjzCpz/npQ33NCWOcpKHQ7QjbWBPNSTzow2J805bLluuO1Z86Ik0mf/R/iSRVaORXBjlHYjG 3/8AXVE3U0UjlczWwOzeudgP+Qa+qlK54yd1cmuJyNhjwy7Q7N2+n6VYgnZ8RhyDNyEzxxz/AEqS ZNWaIL6ENLGruFlJwSgJyPU0iWllayRsd5J4Zl4o9SYytoy3BfFZkCeU0CAiRXHEnbnvxWNP/pV2 Wg2FQdgbov8AnrXQVB30P//S/iVs7fyF3QygMG+bPO33q3fWBEhkkn85niG1lPyg45FfXcqueOc2 1vOC77DIkfBCjcyZ4zUeZYVjESMzliZFC5wPWlGPKwt0J43vo95kt90HJPmDHXihpJ2jASJRj1HH 4VZhZ9i/a6bcXrKHQBmTeRGMlMY7V1cumf2LpUdyXgeS6R08mZg80QH8ZH8Psfak1HqFn2P/0/4f IWN7cbTH1BDyjsPWpb5fIjjt1KznGCVBIiH+f5V9XJLofP2MhgR8p69j0xUa+aquqEgt0xxurS8V sJq5Lb7BGSCTL0JbqD3rXe+igtVtoizDG5mZccnqKOZdy+WXYxVBmkQvkKDlT3PtWiZI8hVRgMAE Hg5pc6Dkkf/U/h5uBbjEj4I2jfgY2ms2Zo5YUCgRsuWVh1PpxX1qmranhqHcrwlXys7c46Dp+FXU JQAxJhU4LMAWIo50NQ1IJtrSAAkLjdwMfhULSsZAYyY8EYxxjHeseaK6mnK+w5pvNmdGy24ckdQe maks4EjuGY4GB065pc0RNNbn/9X+Gm5VVcv8rqwyQnQfWmWMptpo5kbH2dt8UZXeoPrg/wAq+lc0 ePGLSsjRbU3vI5IpJ3zuLA9ByelYl2JRzGN2PvY5zS59dh2ZHCy8tP8AfIwsZ4xVhWR4ykylQPuh T8w96PaeRSg2W7BoMuHXZHtxE7tjcfSqd3IRMY2AI/hcfMOKPaeRXs0f/9b+FfdJKqxRx42tl5AP mf2xWjDZkICAyuTz13H8K+k5zy/Z+ZJLE0QyMmXHH0qG1u7lV5GUJKvk9aXOw9n5kXmk3G5einO1 s4IokIhfG3CyZOBSc2Hs/MvRMhWNURgpXc56Mfw/CqUsyb8QlvLDZw1HPIhLWyP/1/4YIVaWXzEl KiPLP2XFTTRq0UkqsXz0U8KPpX0LnKx5igiCwRJZgZFYpGpKqvUGtmzgSWddgLfN8rMMKprN1NB8 sexZvLBY2LqwYscMwPzD8Ky41XzDG+QGXCuR3qeeQ7InWPELbX3SqPLywwZP881LDCYo1nzznEiH +H8Km7DlXY//0P4bdQlkndVLqDjqD0A6VFHIsJy77hjoB1r1JNp2R5nIrk8t5F+7aGIxll2OzNuz 70K2Aq8eVnJOPzqOZ9w5EW0njWaIs58pSN+3k49hTJr7cskaZ8psjHqK0U76MagkVEuzHaTk7z+7 Kxp1BzU0cwjtYRAnlho8zE5JlPXp6c/pTckh2XY//9H+Gm12tksGGTyjfL+lbLw2sdvvkDNJxsjC 5UD1Newefa2xZs7ax2DcQGlGI+dqxn3qWVVsAjypE4cYDRsHfGehH+NArK9zGvls5JzJZ7nEmN0Z XG04HQelUFsxbo81wcAngbvmFTG7vcLLsTx3EcKlQ3yy8ZPU1VlaAMXiJ3DquOhFZXadx2P/0v4Y m1OWZikw25AUbF2jj2qwshhi3chSflOOpr0W2zzyzbzxysfNZh8mFA/i571NLFFOi5uJIHgfIKjc rj0NUptbgRxoQGVEBXduUuNu4+uKjMM1uxlfo3JVTnn3p8+4DfMiQlizb5D97ODjpj9KljRB5srM pQpjax6UnNgf/9P+GxbpSkjBvJMfyqzcGQHjikmiS6SMKSJefl6lx7V6jn2PPJbSPywqomWRiAMd e1FzHJcxmRlH+jv037dxzwMfhUNt7htoQSyyTArjy36jj5M1q2olh/dGVWWdAGULkBux/DmkZyk0 7I2RAkSbwjSdDKw6gDv/AJ9aqNeJNcxMihWibMSgfLkeooCTdlY//9T+Iu8dpZ44xIvnzElwoBz6 gCpH0uK0YSytK9sYFmkeOLcykjLAL3I6V2z2sebF3WpixSxyTvbCXcpO5Q3DD0yP6Uy9EKRI0cgL EkMoHzcUKfcopQmd449wkEbPtJAIDY4/Gt7To7NZPIlnEcjH9zJsyQ3tVpp7F097EMkF3ATvdZN8 hCkDnAPcflUtpazSs32l2iiBIIUfeHtQan//1f4fZNPkt1PBNurFkQNuYD1rQi1CFrRI1XbKp2GV 0I4xXfdLRnFNa3KJhyqzRqXBcho1X5j15OKzJZphdbQm5HOFHJVce9Yvcg2LSCKQ+VIfNkkXJ2/e THp9KZJEu91m/dwkbQccuB61jNagXbO2tZVEBG4HjLEggdsVWvJDZMbURIw3BUkx8y+4qAP/1v4k 4dTitCmUilmC7N7ruXkY/MZrGuwZblfPzy2XJOBg4I/Cg46ZNFKsCCPbsfe3zxNuiZe1JOks8IIy YyxGM4J/zig0EgaRFFsA4XblSuTg+/tUUsURjkkfd5gl2YA7+/tQBLFNJAm1AquBgEfKQKkmmeSx 8q4j+d2O0xcyAds0W6Af/9f+Gqw0syuZHYhEf97u4wK6h7GRIJLiwgjkMCgujNtUrkDOfxFZTVmc 5m213GJ/sl8GFwjbsMPlHcDHpVcz/aHnO1gPPKEquMj8adPqBsFYraCORzLtZcqCMFfc1hXV3HKU CByqHLPt2k1oOKu7GvCYrqNriHKxouw+bwOOoJqS0gViUMBmEgKlYs5X6YpPcbi1of/Q/h/vW8m2 a2zmPduiGfmQ5x/Ss5NQuIYFhZ2OPm+UEcDoDQTFJI6nQLmXVWgsURi8is6QEHLt6fjWDqLNBLKr JJFJHIVZGXBUg1MnZFGbPLPcRpnJUHonBaua1CNfNYhXIA+6w5rJu7AyJjHJGuCdwP3W/kKkiuY2 PlhSDjGewrOewH//0f4UtL+0tKiwoZZGPy4OOnqa9QGiTXVrC9xH5UG/eXBIZiMZxXmTWhpDqPs7 ZIpG8iVpfsSkK0uBIfRSO/X9K1dKu5ba7EsO0SKcszHaU7/5FYvY0Ne1v4tRv7h7m2h8mR8yyL8s kuM8Y9/0rZjt7S0gHlCRY5JCcgdj7/pWAFGKK6R70wW5jhLGSNg28SnHOPQ8CqUVpvJLIslw6mdw x3m32+h6dqiewH//0v4z1ku41zPIpkd8xnGCwHABHtUd5dQC+0thbsLiS48l5LeJpTJkcBgM8ds1 8udB00dsl2l3YvMGeK5+RUbKouBnPvn0qKy0/wAu8kM0mbWxVTbRvOSZG6NuGaiexMldaG3ps98l xMLtms4IJSYXgkEpuFK/L9Bk8j+dOt9OsUurjUnv5bomNhBZNL5aCXP93HIHuaxezM5RaZq6P5Tu 8OsG4Pmqfsi20PDZPT6Cv0a/4J9+FL7xF+098LNCt/Oi0UXpvLiKSF44A0as2WIHPPljHTc3vXz2 eV4Ucsr1ZfZhJ/cm/wAyHJx95H//0/6ef2fLSWx+HujGWzUSyos/2kZBClQqxgdcAL3719GwDztr HKsv4Zr+RcFLnw8anfX7z0qFuS6Ls8RkUfwsO570+G3XbmWTdj7voK6jYLlUKCJG9+KoSK6AKCSv pjkVdPcCSHdGvllSEPzZx1okbbgDbycAHtTf2R20uf/U/faSXYuRs3yDCjPNZzM0txtMgVtoDEDA OK/kB7sb3G3Vw8cZU5O07V75qkpUwScDO0sflyCcdT605/BYUneR+NP/AAUq0a8h8GXs1pdmae7t 5DZQ/Z9kcEmxUKRjG0/u3PTHPY1/IX4l0xLXUNU8xpyn2+QNNFbGGS4y5+ZUHfnr7e1fe8AyXJUg t7nnYR/7TWj5niXiWJNVuyzrPNBYSrEsE0DRyKYySGYe+adcW8RmhubVzFbMAHt1kLRj6jOa/VaK urFP4mf/1f46pdGk1GOHbKgj+0D925wkeOQ6+pqvPb3Vrd6lpds7GOa5W3s7+R1AkAUfMD/CM5zm vmHuzmWxSvbq4Gpw6e8ds0cSCC/ueXd8gjcuOOP1AqvYaDFqF22dW1e4g00MbJZowbVMk4jQkdBk 9zjP1rdKysM3rezudFsNSe1/fXF/MtmVng8wW6yNy4wOFX39etU5dLg8PtcqlyHSZxJOySmSKVuu VOcdz0oAqahpkE1vDctqjQTXgKIkWN0WMYbnuc96ki0WDTvsdxFaBZ5QQ8rku1ygzhmPXseKDG9p Nn//1v41tS1CBoFht5CJo2MnlIRliOMHPHPaqzWt3cWnmIvlsU3vG7BWbjkccV4UFqeeQ6dpU+pR wyxXUGjmQ7I44yrSApgMDnpuweD6mrrx2bytBFL9qlhAhnMLhtpHPIH51qg8i5Dp1hNtdbVI7s7Q ZlOGcL0Deveqeq6VJNFJKTGscXErO22T0GBXXDcDwzVIDb3MsbhfNL5VuqsD0wfpWZJKfs8kasEZ XBZgAHPqAeorti1ozOa6n//X/hf0jVHsJUnaMXSSusM0LPtBTPPt0zX6pfs9/FfwzYaE/wBvtNJC taGyt2ttRWxubHyIw6yMjfK+7lMLzlffFfuHgnntHJOLIVMR8MoyX5P8k2fiPjLw/iOIeDJ4TCq8 4yjL8Wv1PqTTvjR4furKyjeGK5s5Y5la0iuAzzTk4ildQOQmCCueR0x37O3+Pvhjw7pGoJbapHFq DWyh47e63xbGJBSa3KHgLuIye9f2JV8R8nUnScvxX9dz+TcJ4S53ZVkrfJmDZ/tD+EbP7edP1ILN csgs1vUS6uIwRuk8phzGQwLDOeGx2rP1T4+fD2yje/1HVFjljlVWtRL5U98rjDyRkgjIPUf7VT/x ErJV9vT5f5nS/CLOpaNL7mVNL+NnhWS406S+22swvRLLDfXINrcW7Y2tlRlcYb1Bz+Fai/F7w/Br yaqLK11UwJJFao12z21tGx4kYBfmHAPrU/8AES8klKymrrzRp/xB/OYLbT0Z/9D8SH+LXh/Vr+e5 udX0y0kjdYhawzPHGCcYXYRnnBPetfXvjT8P7OWG6lE7W1rpyW7rYxBPtdyOpjyOhzzkZ4r/AExj 4kZI5crmvvX+Z/nTPwbzrkbVvuf+QujfFDw9fWGt3/2uS1iubYQWFqB9qjDA7t0jLwGI4A/w55A/ Hnwjp8sdrquqpaaeJkSaW7t0t2Zgdu0EZbJz+vIroXiHkbfvVLfd/mcdXwizulG6im/n/kdWvxX+ HlgtzqjX88IudQWOK0trSTbdKwJRicduBnn8s4xLv44+GY3nmLSxrPgrCjeZJCqkZ8xccnjgA/iO ldC8QMjbsqn5f5mH/EKM9Vmor8e9u3zL8nx28EzXgniju7rRyZPsEMl0ljcROo4WRTuGMgZ2tn+V YS/HLwvqTS3dxqVuDbqSTaIsKQFSduQcfL1+Zdx4rWPHuSN29rb7v8xy8Js+T5lBP0v332P/0fxa b4zeC9SNhLY3jrLaIr3Wrwyu8jMSPnjTAJC++M46Vp/8Ll8H6fFdNJqa6rLDI4kvHgItZUYYjlYH G055wM9uK/1Nhx/ka19p+X+Z/mzLwkz+2kI3+f8AkSS/G3wgsBuIdT06zkgTfdvbxs9ui4+8/HGR 6ioofjF4LvLtorHxNZP9rttou5y0VpZSKgco525+cg7QoP3hzXVDj/IbaVf6+8leEXETlb2a/H/I juPjNpmhaZcS6olqba/t2t7a7uoSlmp6GTc/Hy5ByO+Ky9L+OfgzTbbT4A9nfuZpoLy4ivDcQlGV TEOnysp38rkdOlax4+yK+tT+vvManhBxClrTX4/5Gi3x50S0t75BqttElmnnszyRtbIrdA8x+7gd iccHpWpP8avhxc2ElzP4m020vDiSS1jtpbiRVOCio4BUFuOS3Qfe5Irqp8dZDJa1Tgn4S8RR1VNN +v8Amj//0vxwtfi98N4pIL7UL+4mjjti0rWSCS4Vjn7itjI6f/Xps3x68B3MUM0InaCOOSKeSdTB escEI/lkYTGVJ65xX+t0eN8gvb2x/lnW8LOI4f8ALn8Slpnxn8OBLexuJZL4xsY57vynEsce3CYG MZ9Sc9B+O/c/HHwc8o0S/vYQ9hYi7srh1bMoYqTCcA8jJPOPu4rWPG2Q3/jI45+F/EjaSoP71/mQ S/Fz4dRzWy2utzWsU43yw22mTOJ3IyWy3P4/zqrF8cfAlhFc2Das9nHdyhDJfxE28m0kgkj5twJ7 A9elbLjfIW/4yJn4V8TRhzexv5X/AKRUtfi94NuVWa11mz1sxwzRSRwyNB9jbAETNvUDGTnOR9K0 f+Fr+FhpLT3OpaG0NpcxtIouvNmkkb7sQZf6gc9DWkeNsh2VdHFLww4mtf6u/vWn4n//0/xsX43a LeKW/tKKCKa52Q6ZHDIJJT1HBGMYOM5zweKdc/G7wrLPBDDfkWUODJASpnZ+jKDwSeOOOK/1/XHG RdKyuf5Jrwq4llK3sbJf1/VyHUfjV4GmubOCz1CXyWIi1F443uJbduPlZcDBA7D8K2LP46fC7SkW 407U5dVWe3eF1EotI53Q4dHBVs9ACP8AIv8A15yL/n6T/wAQo4kbt7Nfe/8AIx1+PHhRrP7M3nSJ NKZ4Ql/HJPDjPymHGeePm4+lX4/jF4Gh0eLVDq1k91dEpDpv22M3kDK+1vNUc8DJxxWsOOMjab9r b+vUxl4UcRp8vsr/AH/ft5fj62Rf2ifhSXaC+uClkuWluNP1lUll2L90Iy9349qWH4weDL2GSe31 ay0lYnV2tNRuJJ7qdfqseOR7fjWi44yJu3ttC14T8RqF/Za9uv5W/E//1Pxy1D9oXwvkNc3MEulW MjP9mtLiPT5Zh0OwleeADyMjJ6Vm2fx9+H32W+nur23sYblFfRptQvBJIQZAD5mAoHBPOAM9K/2L /wBeci2dXQ/yQXhNxF/z717f0jW1n44eBbNZdGWTTLm4EkRj1FbiRiocZKquOcnAyAOhFV/EHxy8 OpY6WtzqWmSLbH7LCLWKRpI1IG1HbAGeO/PNOPGuQtX9skZy8KOJU9KP5W/z/AbbfGjwf/Z8S3Vz HcXDnbHHGUhFoMnPmEtn0IABHXmrX/C6/hg05hOqzJMkwgmayt/tltGMYZmORtx9TTXG+QvR1h/8 Qn4mvpRuVb341fD+2t8Wmo3t9K906QtaaW2zCgY8yTdgEnoOSOazJfjN4GktHvl1E216lx5F2L0k t2+UKq5yM9z+FN8aZF/z+uNeEvErXM6KT2t+unT8T//V/FG3+Ovw/iLXEuvJIkA3W0N1GY471geU VwxH546VUvv2iPAeqarDLqet+H9Js4tkZe1ZkywG5CqgHkAYIJHtxX+xUuNsiW1Vf18z/I+PhLxF ezp/n/kaNv8AtF/D2/09ZrHW4kQxvpVzdbjb2t+5lYxMME5G3apHcxggcmsZvjj4aVrU3NxbTLFd GCBmkO2Vl+bKjHbORk59ql8dZFH/AJenXT8H+IpbwX4/5HQQftG+A7GA2dzLDdTCQy27w3IgnuGw BtJcYwD6Uuq/H3w/eW2mPc2tlpIulMVvOkg/0wKxyzuTyVB5I4pPj7Ilp7T8v8zWPg3xD1ivx/yK X/C5vBYu7O3g1u0vYZpdt7eabdLew2SbTksBj+IYx1APTjmgvx18ARSXt3Y3FxrvlqkIi02+iaYv naX2kY2jk9j6moXiHkcX/E/L/MteDPETduRW+f8Akf/W/E1v2hPAll5sl3e31xCikDTlgRJ4yOoL 7vlOR0Gaoad+054ENoJY4L61t5bprSe6a+hhmUSKR5YVo2OMdTx7Cv8AYP8A4iNkkdef8v8AM/ys j4KZ/JWaX4/5Eh/aL+FunxXr6rc6irQSoLeTS9Tt7pTk8B1Kr2waoN+1f8MbQXFutlqV1OVBjnW/ i8xFJByU2EA/jS/4iZkEH71T8v8AMP8AiCWfrovx/wAi5pX7Tnge9v0j1J5baK2sXktJfsiCK4fk rvK+nGevTtzUepftG/D64M9/c+JtItZFwqyXMvlpuUAAbVVhjjGDg8VnLxSyFOyn+JtHwSzlx1f3 J/5o5x/2lfDF7rNto8niOwv7KNkFxLpQW3hi8zkjcVGSBzwKtT/tJfCjT/tenwajJPfpcl21Dh41 gjHEOxgD5hPViR1pf8RTyNbyX3jj4J5wna7/APAf+Cf/1/wSi/ah8AzWbW8ljIt3KWkt5m1mES4A 4GNuCPbrzVQftN/Dx7CO4vNQvFWKJo/Je+jjimkOSPLwCdgOM7gT6V/r6vFTJNpP8Uf5avwTzi3u v/yV/wCbJrb9rTwlp1p5mkOfMvIFj3XJS5WDb9+SJ8DI4/iUfWs/S/2p/CMV+8t691dWzSM/mQzR 21xcgg4ZNwZcEnnFJ+KuTdH+KLj4J5v3/wDJX/mTr+1T4XkElxb6dN5brvVLnU45FttvBRlVQzMf YY4NQn9rPw1daZK92NMTDiUXFrclltVztHmIFLd++MVjLxYyeO9vv/4BvHwRzZrST/8AAf8AgleT 9qz4e6lMdQtrqe6uolCSvYyq1t+7wHY5XOGHTA4ph/a4+H9rHJcmzM9vJK1xBLPq620zxDjy44gh ywJz1P0rGXi7kUFeTXzkkaw8C83nonr/AIG/1P/Q/niT9sbwkkttPaQSWHlRMC092ktzKZDgE/IN uBxjn607Wf2svCzw3rail/DEsyG3nBJa44BJwBk565Hf1r/Wip4y5BHXnj/4Gj/Myn4C5w3u/wDw B/5lRv2wfCUrWtxHPZRQyRhVD6iscp2g45YEqeOQV9aowfteeDI51uP7Iuklhl3yXEmtRywkn7pC CMHb05BxXNLxsyD+eP8A4Gv8jdeAGc33f/gD/wDkjWtv2u/BttBJfz2Vvck5SN7bVSjByccqQ2QA c49u9Y9v+2X4dUaxZW97YyJMomuLXajSoqnKlJWUlSO+D+FYS8bcj2jUh/4EdVP6PuYuV581v8Nj Ot/2u9PeXZa6LckRNhbu5xewzu33TgBRtGR1GKqy/toRT2W06Tcam9tqbLPb20MWlywbcA5IK/L1 4Ht1rN+OOTR2qQ+//gndH6PeIavLn+5f5H//0f5k7j9sq3tBNPcWOpwwTan9qMUcceoxoB/AwAyR 8xHXt3rRm/a4t9Us7y6tNOisGnCtbG7R3hjRSC/ybuCexwCOa/1P/wCI85Mn8cT/AD1X0esRy2fN +H6r+rmpD+19Z+Qs8Ok6FcI8Y+zhpZIF64YMDIMn6ViN+19eJczImnyiwtbtXZreeEI0bD5vLZyW wOeBn6VzVfH7KI6KUfukdNL6O9WVr833xX6DYv21GjNxDY288uyRo7KVpre8VYmHzIysm1j6Htzg VXl/bS1G/vA76bYadFaWgsrZRY24ikAGNzYUNvJPXnrXPL6QWVx+Fq3pI64/Rye75vvj/Xn/AMAy x+1zqJhN0lhpdtNbXG5ZFu9pUqQRhTlT7qx/CtC9/bi8Syz4kg0+4NymI32Q28EYHQBSp644A9e1 ctT6QmAt7rX3SNo/R1jGyfNb1if/0v5gb39rbV763k1e506ztrSwiZ7lI7RVlmY/KFyAOmMjr1qk P2v9SkZINMls7S+REaFzbrNCyg/dZTlSx5yevPJNf6TT8f8ADtaT/wDJf+Afw0vo+0Fo4f8Ak3/B INT/AGq/FMEMy3n9jsXmFzJLbWqwz57qgUYyetPtP2wfFEEVqILlryGSdbmaO7iiE0O3nPmspbIx 93p14rjl9IGCeknf/Cax+j5g1pyfi/8AMT/hsXxjb3BvEkE8L3T3Up8q2uXB/gYIybcj0H5VzV5+ 2D44N3dTx2ljfvd3AluZJR/Zpuhg4yEHH4ccdK5qn0gZ7Ru/lE66P0e8tTvKKX/b0v8AMrL+1l4y heG8t/s1pOG2zCzt443t0bO7EmAxwOM1DfftQ+LNXnnWG8iNtbRgR3V9F5s1yxOSRL94AHrjk1xV PHys9lL8P8z2aXgNlULXhHTyv+aP/9P+Tef9pjxLalI5RcO6pHFC9rcjALfePRdo78c+5qvP+1P4 v8u5ivLi6e085R5F6zOAEHDA78+vTtX99T8esSr8vP8Af/wT+UYeBmTbOnDT+6v8jNvP2n/Fd9dC wtXt9Ntvse5LtY2ZXcfw5zncRnk45rGl/aK+IEqWX2cPcJsEV3Lc3UhezwflbhsHPNcNXx5zNpqC dv8AE1+jO6l4IZDCSk4RT8oI1Lz9oXxs0LzLfW8NxuUxx20DJGMAZJJc8nnrWZffH3xVeSxxLqEk LTJiWe2dhKpP3j14yMjivOn465vJv3X/AOBP/I7IeDWQwVlBf+Aopy/H3xXo8aG21bVbj7IhghV9 Rl80gnksS3zdzzWhB8dfGF0gd/Et1LFs8zy5MHyH6kjPU4OMVzy8bs3eyf8A4E/8jop+EeSR+yv/ AAFH/9T+Pu8+O3ja6KWw1QtE3yi9lTdex4ORgHgdvw7Vnj4r/EuRLr7X46u3tHYSRwPbrtyOo474 6H681/Y1bxoz6p8Dt6tv/I/AKXhRkMZe/C/yS/zHy/GfxY222iv5BATue5nka62NjAcxE4Y9eTmq 1z8b/GUk0cF9rCCytItkU2nWzafPNjqZWDc+wFcUvF/iKStzr8f8zpj4Y8Px09l+X+RUT4qaxMny 6jq7uwIXbfNwO2CxOPqPWlh+K3ih3lW61iZXMYQbMM4I43FiM5wO2BXPPxX4hl9tfj/mbx8Nshjb 93+X+RI3xB8WX88jyX921uIFUzLdyeY+09CM4GKw9Q8eeKFt/LXXtWtHW9F1FcxahI042n7nJI2n upBFcVXxO4hmmlUt/W+7OleHmRRa/dH/1f4v18d67cW0Xm6hcT3UN0buK5MrB2bsrjOMdsdPatOx 8f6/YyPcX15b3Ep/erDGmxtxHHfse+K/p6XiRxC2n7Y/H4cBZDHT2KMi/wDH3irVFjme4a2uQSm+ C5kjiXPBOxSOv9KkPjLX/JtLSfUL24WAB1ma4YOWX1bOSPqe1csvEHiF74h/cv8AI7IcE5GtqC/E oDxL4ht2uDHqF7Gt1IJJZVuGWZSpyNjZyBx0rCvPGGum63/2vqCmMETxfaGME4bn51zyffqKzlx5 n0t8RL8P8jaPB+TLaghll408RwR3NuNRmCzSF1kPzSBT/CCew9+acPEurTZW71CV4uhDOVG3vkVh U4zzuorPES++35GsOF8qpPSjH7rn/9b+I+HV3gmupUnmnjvNqsGnd1bAwCATgH3qW01KWEzGN5A8 sqyh/MZsFcYB57V+9y4ozWTs68//AAJ/5n56siy9aKlH/wABRbn1bUZZDetql5HLGVIjjuGWKYjg ZGe3pWemvXk0V5Hcj7QbgFA03zlc4O5fQ9qxlxBmU371aX3sr+xMBHSNKP3Ip/2xcQxraI5KOBGV xuCkdDjp71Yurl79HWaQb8L8ykqwK9OlYSzXEz+ObfzZvDLcNDSMEhFe9SRLpZAksa7UdDsIHtjp Wn/wk3yIk80kc8GSJVdi5bs3saweYYjZSZp9RoLZH//X/if0nxC6sJSryTqD/pcjZnbnn5utbU3i HzSDLN5hkQqFyDx6Z7V+xPG17/Ez46ODorRI5W+vpJJWmFzIrqvyBXJUHoMjpVGTUdVC2ynUp3ji bzAjcqG5OFHYZPTpzSeKrPqzaOFpKVrG/YSPc2U8VzuxcEyMFBTzdvI/kOaxfOWf7Qx3MSNheYkv hexz2p/Way3bNHh6drWFGLmLyF2RsoCMgYjeorW+z20JhuEJjmhhCs6nIAHt/Sq9vN6NiWHinsf/ 0P4jp7uR5lmSPdxtzk7QOM8Vno3l3LzoPKZ+GZBgAHiv2T2s9rnzMqUUtEaE87XqLCwMpjdWTnAJ B4NX761mtds6pPBchA0m3KkcA8ikqklrcz9mrbGV+/vpN8krnaCfnOWNEl3KrxF2LJHmNovu596z lUa66jUUiFBPL+8VnO3JYIcFh7/lV1JnX7Od3y5y2RkgdhXPObKjDsj/0f4mr65neNMOAqjCHONt ZUeo3qQmx2oyGUOH2gyg9OG6jPpX6qnK2x8wo62NUtiBo5S0hHBDDhwR+tZ9pGv2mM/YlSOFScjO 5s9z7VTe5TpxWyO7TxFBYwWsNpHslktH8yZ1BSKToFC+4OfqK4GRJUm80kSlj94cHJ74oV76hypI mE5Ujr5ijBZutaUCzPGLif50TgBjjbn0qk7bFxirH//S/iRkmXdI8al2Q8E/w/hUMWpmKRRLGFQt jcG6A+1fram0rHz1kg1UvLtwAUyGDDpiqaAMojQbQTjHqaXPIZO9o9pEFYqqvyyqcsKq2yPEX8uQ r9c8j0pczXUVkMkumXzEyyZPbqcVLDKshVZQzZHysfX3pRqNsbt1P//T/iIYvCrIpJwv8PG72/Sk s42nKwMCm45wx2ge5r9Z5n3PnxbiJbaUR/6wMM7+34VXjiKCR9jmIcs4GEXnpmi7C3QihuGWZW2k KTjbnBIqeaaIny4sqxkyuB8zexpKTlqJJLRELWrZEhIDE8iiXK5aHmSPG71ArObadkM//9T+IiPU nit9mNu4gs2Nze+KY001xbTvaO24gfIeM8/pX6jdnz5mpP8AvV88FQBhvlz9asreR5kjSIlF6NnI ai72CxFHM29WkRgrZCnbgGnvHCDECJCXl6Jzt9z7UgFlREZIY2KqW5fsvtSKDGjQNhoS4cAjJJHe gD//1f4eAS8uMFixxycYx0pjQzSSi3RgMk73J+4K/SueR8+ROx08LGm4l32kj5gc96Iw7LhAzMWy cdTT52BbiKr8k+ShI4HH61PclfkyoRcbE+bHXpUuTtc3ikkRpCyFQ4DBh9709qgRWYTMiKZEbCBz tHuajnWw7H//1v4exG8m1SF3q/zEfgK3EgaVZxu2SRBSmV+V/UZr9H5l3PHM2Z0eYK6hJlG3cvGK RLiG0ZkY7yeGK8/rWADblIbmcJn5SodfQD2pkamKaPy8AI33y23FK67kyV0XxbQiS1YySySsxwSc KvuTWxFFYz/uEQfe/ebmznHWplJWshRjZan/1/4q/wCzIASIQse/oA3H1rNv9Guo4FmiQSbmIOMb wB3r7hPseMoq+iMKLdEkyOjI2MF2OPwxToWXei5xk8KRlX9jSul1NFB9SrcJ5E7OnygnhV42Vajk 8uMJGrEk7pGX75z1ApOauHs2TqDKphBZJAud44yPQ1JGTAoinDrGWyr7ThyPSlzoPZs//9D+Ii48 sr5jQllLhMDhh71nvNMJdluNxHb+7X2Und6HkSg0tSaJ2QpvClnYK5PbkZzRdSDbNGHOxeU2/MCR 2z+dJSsmjF0+xoaWfNtlTkMx+RCNuSM1HOBapLIsTeaw24J4Xnmo54kuDtqikJS0YEgBQL1I9amU W0UbAOCJUxtBwQe2KOaJKSWx/9H+IWC42J9nSJY3PzJOB8zD0Y1LDI0Mjm5+cuNiFemeMV9bzo8D lexZEcDuxQDaoG5D61nXOVuCFQpC64fafkyP89KPaJCt0Ln7xrceXzF91z0JqsLc3MT+WqK0fzfO dpIHpRzroaxjbVleK1jZVZmCsrcMT8re1aVm8QEiyAHaOR2z9alzZZ//0v4rbe3s7uJFlnkgDyqj NFD5jKvrisubS59PmmMnMDMRbv0MqjoxHbNfUupa9zxyOZ4fIzGzRSD5VPR2I/pU1oFZZJiGJgUO 4+6H55C+v0rLn8iuV2uQXN2nmSTQxGEScgY5IHrVaBFuHaeY5AHU0udmfLEjmjZtyWxULjvVOGDz ZthJE6jnuH+lHOw5In//0/4h1tfssEpDMrmTJY9eO1Sxs+DIysz/AHVAXG6vpFUaPF5YizyCx2vc Izj/AJ90H9agTa5DRlzGW3hSMBCfb2p+1Y0ktjbh8qRSjFePvEnkCmrBCplQfIhAKTHv7Ck6kmXy +7cryQxmPO0hA3Mg6iqCgLdt5pbbIBsPTjHWlzsiy6n/1P4kjvWQhQHyvAbk49aJo/PCxJ+5UAM4 UYQ47Y719E5tnj2sZ0ySWzSInzRABiD2p1oQmDuG/PysD0zSuxWRcaK6MpDRrvP/AC0H3WA96rXb M2Yt4G75SxHCYpqTQ7WM6K2mYHa37lf+Wh43evFTyRsIlMSBViOSFGC/1rVO6uOKu7H/1f4hrS4k +R1UBskOD90+lb91LLqGnQpGtsjQTMZSikSyjHc+3GB9a+mUlex5vLHsZcMxSKaOKYAsPLk77+4G aLWNoXzMwcZBzjj6CqHypaFycjyrhFV5A/zx/wCwcjj6e1Z+N1vGTInmAndADiTjocUbGco22Ldp fy25AVjFIOVZTgjFVr25v9VE6zTAi3j8ySRjgyAdgM89egoIP//W/hxgnuImeOJVUMu0EjmpXuZ4 kCMvQZyV5NfSylZ2PHsRtBIVR5SMyHO1Tyo7ZrTgtgixg7XlAKxBj8qk+pqm7K4GHLE8UxBA+ZiD t6Fq047Z2SMTqijPGO+ahz00A2biDTY7CEpF++ikO8+Zw/oAPauSudyljkrzn5T29P5UudhY/9f+ GaUMyLhWeNiAc8Y6VWWAvK0anjoNxx0r6NTaPKhHXUeURQI0z5obYQe2OK0o7abbncSFGCAODScm 9DUgmtJ2LZUx7OhxjefSq5tfJBd5CXB+7jgfWpAZNIINuyMGVl5K8kCnLM/7owqCzH593GAetAH/ 0P4ZmQxliw3AnO1eR+FJLth2PGnBTJHpX0B55HE6cLgbyc8dakSGfbI3lspLYQYwvuaytO4FSby1 kjEwww7gcUuze3mxOCoGGJ4xTm2nZARISsyk5ki6AZ4XPU4qeW3+csz7AnIHUGp5pAf/0f4aoWjj aKQBQWOxiTwfetVxNAn23AaPd5ZORhfQY617qmup55nvdJv3HBk3ZwB0p0ixeWHTblzucY5yahyb YCW9q90u0R+YwPyoo+Y1FLCY5XjbDqnCYGdpx0z7UleTAnAkAR1BJxjKjhv84qtf6Ze2yQ3E0aRR XaeZAY2VwR0+YA/KeOh5raTstDOGsmf/0v4YIAVITHyd/fNXrmEyRIqSeWTwIwn8zXuSfunnlH7L 9kcMJZVYD5inBarX22VmDvwsKfuwvBb/AOuazAcl+6oBNvVnO7Z1Kiobh5JSCjh06gAAMPagCS2v PIISZC5LYXjJGana5Cv86+YZjgx4x5eOn50Af//T/h2mso5YTL9w+gP3azdgZijOpcDO1Rwv+cV6 s9jzxZImZUVVPPy9KtCB1URkgfLwOvNZrfUBWhnzI3lKkWwBTyMnFRx2kzKS0bkEbvlU9B1Jqrq4 DTImDbqMMvXI5NaC2Tjaxl3cAFccLjtSlK4WP//U/hyjgdpn+ZFUPgZOAa0IIGjnaW5aSSIgq0O7 CNxx/SvXjsjzyvCvlqVZ/MkDHywvAxk4/HFDT+UpaSLcSCMPx+NDdkBiSzOCl3F8is+3avBx61ol ZZQjlJHDDA2qWBrJSauBQukySiJyOmeKz40mM0aAEsx24AySakD/1f4ef7PgM0ck0iqu3Dk/KDju adcQwnEQZSg4XngV6B55TayngljULsZvm2uMfL60/wCz3LssYGY2bcSp649aB20LN4wjiDEBZo2C qqn7wqIBrtVKOB2YMcE0CIntY/mD53qMAA9DUKwSMMMSQONo7fWgD//W/hefT2bfJMrJEDtXtmp7 dZIQroGYoAEbqa9A882Izks8koE8vPlhcf5zSTWaq0TjLcZkXOBkdPyoMpO7sVI4Hf7wXcxwFXki oGS6t5QyvnbwFB+7Wc30RBqQyXCkhmlcOvzAHKCke0EayTwM3mnkZPGe9ODurM0km0rH/9f+Gt2l QrJ924jyVkPJGRU+n67qcEP2GWUz2jTNKyyHLKT6H+ldc2nojzYrlVia3MMU73CJGzS5DAqCwz7e 1VJIglwBIuFlfO484qCjYhaWTZBFNm2UFSjL8v1FK9sc7FU4iO5JVGHJ71cZcqsaU0W1JcpHIvls mAXmGAapXt1IIgiSE+U434TAPt0qk2/QcnZo/9D+H1dXkjZWaFQqJtJPeo5GFziN5XhUvvPlL97P pXS3d3OKfxEMMt1bSeRC5Z1yfnPDj3q3bXCM6h1B3NiRDgIT6ikQXZhZxl2iDxzBgRzkr9DVK9hu XaNIg7y+X5hjb+IdfwrOp0Aj02W4uZWgEToYx842bSMd/rV3UY7mZA/yMIV78SnHUmsyoxbP/9H+ Gm3mjdszSxq0bgrAUbM3PPzdP8mtaGwluwksrrDDLOLeJ2OEJ4JBPtkUHLGPKW7m2FiJI0MU3lPw ynIc9OCapFnhhSdXK4OVjb5lJ+lBRsaddGGCa7m2I8sbRgJGHGG4OB26n6VQ3hmiSBDud8sNvzZz QNRb2IntpXZ2bGFOAM4x9afLbzxSoSRsKggj5lHtQNxaP//S/iFaK4uR5UUbHc2NkfVznoRV2BdS tbeaG6LRwt8yoqlZIdvB3ComtLmXI7GVq2pR3k9pPFEEu4YxFJMqbXkC4C7vU8dfatnSY82s326J GM8xfcoxs/u8frSp9RckitqUqreSaYiMZEtg8sgO9FDEgfjx0rJjsgmwTB8Mc5CYVgCenrWhpGPK dbpUcFy0VlbRIbbcFuGkOCobgkep/wAK9E8QW3gzw5aW/wDYmn3rRWrtAb65nxNqLjBOxQSAAT26 Aj61L+Jailz88Uttb/of/9P+IQpA90xVDuOZBuGQBnvWbqDJDJtidWjc4dCMbM/5NAE1jqGp2Bkm s7wRoMRp5MYWdD7N1FaF4xubZru5HnTSnDSlsSZ69Kzm+gHOStJbwFo/lyNvviuWvZnl8raSGU5f /b6VmFuhQWzkvZGdcjylyB0Bx60ixmPayYBPDA+tZT3sSmrtH//U/hv8ET28F3m5iZvLXdGUj35Y 8YPoK9Vnvln2sl0wt4z+6t8Yx659PpXlzfQPI5i6aa+aO6socSrdBXSM4D7eBkdf/wBVa9vPe3Uw hMFujIwWRuAxA4wPWszTn0NmbR7mxjtrgPbbJ7n5mEoZwAMkFAcjt1rVhuYWjlhuSfLVMKuMo45y KyVnJk8ztYZaXk8drc20tyPIZt9oY1+aFjgc/kKytT1CHSIIrqTARm2zHo0rH296lqzsVGTvZn// 1f41l8u+tXujZSxPcQhrFw37sMMZOccjg9PWooFCxxq+5ZFb5i42kEelfNziktDoNvT54xhUASQv h2UYLHjkn/PSrMyQG4YxIDL0mIPyy49fcVhPYCWI7YFt9rkFi7HfgRgn1/kKmjs0u7i3t5GfNrMs 48phltw4Gfx6VzydtAO90n7Rfz2cmqW5tlsUa3sI4EGHjDNhpCB1PJ/Gv2U/4JHaUvib9qDw88N1 c3SaDdG+jtFhDRW8ccWHjY9y7ndzz+7FfE8aOS4fxXI9eW346mcrKSv5/kf/1v6vfhPHFb+FLKKC PcsjtKFkGWjBI+X+deriQJIAUVeMD2NfyHgFbB015L8j0KT5IKIbZi/zEFDxjtzUisIt0RX5dvyt XavM6Co7BCWBy3TBqUTGZA8uflwBx0HarggHyEPgfdYjggYx9aznjy/JLc4AxVtXsO+lj//X/e8f O2GQOV5z1x9KguoIZlMglaORRztIBr+PKrcatiZfCWYYY3sjG7KZJP3aM+Ax+nuMfpVGIxi2nRdj va/8sjhZZF7t+nSm223EGveTPzN/4KEWcF74BFrBpq3FxDbDUrO4mynkn5oZI0xx824Me/yiv4wf ifY3vh7xDe2uo3ax3wZrhbRpVaXd5jEujDs3DDIyM9a+34Cly15xfW/5I4MKksVW+R85ajHc3eqL FHJcma5kB2AsfMYnJJ9e+ayzLai6lto/tC3FrI0N+pGxe33fXPr0+tfr1B2RT3Z//9D+OXSVubZb lRHPdoE8yEuwPk9go/xPr1q/a3ulpPPZazPLHc39mVsvs0YnW1lwCuTxgHGDnmvmHq9DnXmZ01k7 6a13byGeQu1s0kkfll3Xjg9O3aorbVNa0q3uNO1TRZ4VsgJrSS3dJftDuAWQgDPYHPQZNbgdDpvi B5rRp4z9mfWLc2EluY90uAd0iZ5xnA9+DXETvcXbsqqrWkEoVYj/AAquPvCmld2AsG1sL+1u73UI 8f2YhaxgiQyyyEjrj/Zx056UxdYkhtrdLfzLnMaeXNLHg8gZ3Dt+lU4NOyMnG8nY/9H+Maxt9HuL mS5uGmOqRsWltxHttWRgNrKc8tncMY4AH4dNFdW8Bd7hFCsy20W87V3HsB6mvEjG2555yOrQr5wa zAW3aRpDGikKkh6sPrT9GDWUc6SQsbyRN6zEeVk/wsfUYz+dWQ/jRuaRO0WJpyRlzub+FfpUmpOl 5aTW0AkdpA0oflwAOf8AGt6bskyz521K8S7umZflMLFdzZXzMHGQDWVelTFBJsUF2IJDY5GO3vXd T2E1dWP/0v4QLMtNMqufJRG4OOteiadYXAu7aSwurm0lRgXa1kMfnpkbkbHUE4/Ku6lXlRXtKbs0 1seY6cai5JrSx7Hp+rXumyWkFxdX0kl5dk2zJOzyWrMPm2nOQDgdPWr2qzzavKlpqtrBHcLKsz3F tdP9outh/dmVhglhxwemK2qZnipy5qk22+7uQsFQhG0YpLyVi1ZX1xaQ3sduXeaSQt5k8paQMeM8 nsO3tUbu1wk0s95I93kRyyPmWRAvpnpitFmNfq2YywlO+iNmXxB5wSVnllnghECSyAvhRxj2+nvX IzaqbB5Z7W7ui73IkMdm0ghLHA2sFI4/2cevtQ8wrvXmZl9XgtLH/9P+PZL/AE9r5ZlM9uqpmQXD M0fmgEnaD0yf/wBdTDVle3W0gkZY5JGkY85ye6k/jXsf2hiFqpO5806FNq1inD4l1K2uLmK2ml+z FlMjG4dNuwY3KAcA9PripZNXlwjXVwrvcEypFu8wlA3XnoelCzLFJ/EyXh6T6DIPE135rxwX94j2 bG5aJg2JEYEDk/UfSo11e4LzX15qGoXrKrSW9sshlT5uikZ7ZOM89K1/tPFpfGSsJQX2Tm76/ezl S4WS73cnbE0jt8/XKCov+Em1FrWRbaW6upoBlo7t3j84H+DHoAe341H9q4taczKWHoW+FH//1P4y 7DxXrl3OsVvaHfFGDPHKztZ+UMkonoRg9q6LVPFOpLp8dmlqhS6RkaKO48hH2YwCq+/Bz2r6GGb4 1aqb7fofMrD0L6xRWstWvptN+z3dwdLe8lH2sQTsYQBgBeO3A7VXudW1GB4/s906W6Sb5gxyLk4x lj1/Wt45ri0k+Y1VKh2LH/CV3uqyLZXE5u5YwkVnHJM5jjA7Rx52jOeeMmnr4hurQJb2E9vb3Usx iWSVFMYbuuM9eD+VJ5xjJO8pu/8AlsaLD4f+XQupqs1w0dpczwXF1dKI5lVBAkxJ4G3PFR6hqst3 bLp8Es9lGjrvls7hoZJAnAXIx8vt9K6aedY5RSVV6eZP1TCN6wX3H//V/jp87UJTCkuoXXlQyiTy I7l0icL9zcM8+p9TUk+q3Zk8q41q7W2VSJYBKVilz645H4elfcLiTNv+gif/AIEz5ueVYBvWlH7k SQ+LfOePTreG9dJUJY/aJJFfyhu3cnI6Hjnp1rO07UNQu9Svb2TUrm10+KISQRC4aAybRtx1ySD0 q48SZvuq8/8AwJ/5mUsny9P+FH7kVLnWbyKVBb3V9HHjjyr+YO3XnO7rUMM2pvCVur6S5uy7zwvc TGUhSfl6nkgY4rqhxHm1v48//An/AJkzyvA2/hR/8BRT03xHqGnXl359wWllhW2nS0BtUuUXOC6g 8n3NFn4i1C2vr+9tFNtFP5cMmJGa2VgTgFPu59z71a4kzW/8ef8A4E/8znllOAtrSj9yP//W/jEu bvUTdW9yLm6tru23CKaOZoyVfrx0INaM2p6nY2sU8V99rvBdLcLDPMV8vGMAMOQa/TlxHmqd3Xn/ AOBP/M+LWUZfb+FH7kQXnizUYJ7aRPMjtppQ1/i5k81XPVlwcH8aWfxLcxK0NpJK5kkNx5s+ZNhJ zj5uue+ap8SZs/8Al/P/AMCf+ZUcmy5v+FH7kVrrxNr9+nmyXdpaGMplY7IeeccHDgjGe+KrC7ub bUElLuqzrndDclVjIGQVUHgnueDSfEub9K8//An/AJiWR5cnyujH7kPn8QX63U9nGYseSq287HzW XJyxcGq11q2pXjwrJeXIa3lDrNDcPHI+OmTnp7U/9ZM2tb28/wDwJ/5mn9h5be/sY/cv8j//1/4r b3xJqV2r6fe77nT3m3XHnyyPMcDHynPA4BwK3tP1CWKF7yz3MIoNkcbRgrGF+4Np464/Ov1FcS5u 9Pbz/wDAn/mfIrI8t5f4Mb/4Uc/NrmtMfOvdXuJL0uJNuRGFAPACjgfWrp8UxyJIjy3dvLJGA3ly tKZnXGd5yMA4PrirXEWb7OvP/wACf+ZP9iZelpSj/wCAoz9M8SXtreEPcXC2zFf9XKxVgrZ8tgTy DW14g16S3VXtJ722S7lB3RXLQ8HnfgHDdME4701xFmy1Vef/AIE/8xf2NgFvSj9yMC517U38+M3t 39lvYwtxtu5FLY6NGA3ynHcVo6DqQ0Kznto725EN1K02TOxmZyBlmfOc8D68VpHiHNumIn/4E/8A Mn+x8vt/Cj/4Cj//0P4qJtengOnx2zXBS0neVmaZpHnDg53A/Un/AAqUeLWCxxGKO8hLMfKeP98G PfJ9K/WXxFmt3/tE/wDwJ/5nxf8AY+A/59R+5GhPqk9vo8C2l8wQ70ezVyGiYkEEnp0JIx71z8eu 6nbiDztTuLieEHynlbeyE8ZP0HTNEc+zKXxVpfeyllWDjoqUV8l/kNutVnuZbdtblW8WF1niSJmV QR0Ocn8RVLVL6bU3WWZryUIGMbG5kSGEN0CLuwBx09qt57mL0lWl97KhleDi9Ka+5G/oN3eXVrc2 dldXKpDa+ddbJSioiDGc+/T3rW07x7L4fsINH0SwjsliiZPtvmNJM5c5IcZxxngj9an+3MfSkqka j5ujvsbPL8N8HIv+GP/R/iZutUvr+5CG8mR937sLIxAdzycE9STWrrklv9ltY7gXAvrGcXE0Uc5V JnC7VLAY9uvpX6usyxT3k38z5T6lRSskYMmuzWygxqPtU58yZyxcAD/PX2pbHVLlZZLwXshk3/dl lZkz6Fc9OP0pf2hif5geCo22LFzqmpPfNqPnyIka+WUidhaNnknZnGf8KiutWuLiNo5gs1oRlogC Uckckr3/ABqPruI/mJWCpL7KKsEu2VFjieJQgIkjcxqcdMgenrSa7qV5fb0AkWGZEiuWt2YPLtGM sQeM0LHYn+b8ylg6PVH/0v4g9MldmiEM00b2kWyESOSAPTkmtmPXLqwjmhiuFaVs8SR7osE/MOO/ XB61+qLHYi1mz5v6lR6pFO+vftcMXkzmBVO51jJQueQVPPApht5L2KMSTMpiXbDuc4QcdBmmsfiF 9pjWCoLSwwXVzbQtbQXModm/eSRSsHkHoTn/ADmoIfENxpF9DMlt5sSjZNAVPl3APZsfz7VX1+va 3MylhKC2iV01rUtquwitLd3cG3ibDHOTnj+XvWX9saOVZVQbkclCwyFz6elNYyo/tP7zOWFox6H/ 0/4hheeYbd3VXTYPNb+In0z7Uy81m5DCPcWQYMZc5Kjp+NfrLxVV9WfMqhSXQxruQsHmAVJGXG5V wz5NSWuoPbqUGXLIAwYbt2OKl4ir3E6EOiJkbAkkjbyTPjfHnCDH90U+KRQkoEA3H5BKV27sfzFT 7ar3D2ELbaly18Q3+mFHtpZPNjcKQQGjUDkHaeOPpVGTW7qe6vYdzSS3jedJKi+X5ecZBxx27U1X qdWL2EeyP//U/hzutRmgt44OZAWAZsfdA9ah068lkmlhM0wjYZ3HLhPav1SVWXc+XVJJaInliEzl 2IlMP3CV5XB6j0qaW8OOZGO5NhUnBPrxS9pPuaQglq0ZsMj26AxERyFiEVecfh0oW9diY7lfPVz+ 8V8j8qHUmupfKuw/y7NomQxqI2YkoRxzVWd0CQwwqzNE3yO7Z8sDoBWSrSWxTppLVH//1f4dLHUZ ZVksp5GlRz912xGMDHTp/wDrqNJfs9x5qnH8LAcgCv1D28u5857OHYfJfy3SDaWPlyblDHJyO9Nl uzPAyxHEi8yL0yBjp/ntQqzb1D2URn2iT7MANygcHBwKjS7YOTJIdsaDyx1Le1aKqw9nFdCxJd2+ VLswzgvH71PHcpHNiMEQsmQe35Ue0kPkj1R//9b+Ha9vpmVjFg+WB17Vn/br26RvtDBgE2gsBuAH Ar9Tc59z55Riug2QzrEpLY6AcckUyK9uYXZvMkMbDEig8cdKHOT0YWXYf/aEz5XzCULlvmPI9qsR swZZI3O8HPNZylbczcHfQsXbCRPn2GU8ugxWct2UISNiB0wOhpc8Soxtuf/X/h4sWeaUOwCkHATO N31qe+vJdxQAIFx8gOeM1+oRn2PnnFPcrtOVK+XkiRcH/ZNM3pHAROQ7l87SuQabk9zPkZA1w0a5 idV44CCq8eouGOYidgyWByT+FHM3szVK2hvQaldC1LQblVlGUdcEZ7iqMl20rI7rgxjbtY7gaWwm tGf/0P4i7NoYgxkG0uAygjKj6elUr6YtIHUkuRtwPu1+pOTtZHzdrS2HQ3MsKcgcA53LuHNNSZgF kWV3fecqeVx7UtWy3sa6TG6UQAbZCu1WbhF7DJrD1W3W0VNj+bO64k2rhR9KtvlViYXsM0yFm/eu g3KMKmMk/Si+s3VgBGUBPzoTyKSl1bK6n//R/hxtESFSnzBD+OD7Vct72OOJofKJYcs5HLe9fqB8 zyu+xBPPG6qqh8Drg9amhhVQXZ3VVGcMPWjbYag76ldZI4ZG2sGWT5SdvIzWh5Hk+WwjDY+bGcbj W0GrWFJWZJA48qd7gbGVuEByig+9ZVxbwOweMlwfmOe9USf/0v4eoQYomJwgIxj1qssgViqkk5zk 8V+sHzcBsQllYltmByMHggGr5iRlAYgbeRjv7UFpWbZblvnW3S3jMm1l2B1XLReuDURkiV44lBkP l5kK8lccc0229xiJIBOPIjDMEyWZcBan+1YVsHczLhl7URdncD//0/4f1ny21eFxyDx9auXN7Z21 qLeBQ808e2Z5E5XPUD6etfrjnpofPkNldxxLtVNzZxuPUV0yzXF/EyXTs0RQKJcnzFxwF/Ks/IGr 6Mzrq2GnCNS0bDaXMofc7DsDjofauZuJpLh0fA39CVGBx0pc0WzNQal5E5M8cSEsYlztynyl/wAa svFcQQwyspKO37st0f1rObT2ND//1P4gY7tHYxtHghsYwdmf8/yqSQeWyP5Z2BsvtbJA9q/U1O2j PnrW1RpwD7c0bDdshO5ATjP1rejW3V0jZgJCvzJkZx9PwolK70GYGpxmOREiTcFyQc4yKrW8sG4e eSjIQyqOSxFVzoy5GQTTJJNIqJzLyVPbHvQzSJDj7QQrH5lPU47CjnRok0rM/9X+H+K6kt/MwFYS LtG5c5/z7VnzQytt8zcvIKnHWv1XnR4CTexoJKDGsLseOMDvUpBEZChSOqgjDZ9qXtPIOV7WK6X8 vmPHJtdmTGGX7gHpV+Bd0DAxBhIx2SsCCCOu00nPRorkZjO3l7t6EnftTIqx5ixjDJghchc4LVMZ JbESi7WZ/9b+ILeqRxOCcHkjGfL9qiSYl3wHc53BgcDNfqbqHz4txPIR5ssZYoMInZc96mtt9xbm B5CIGOWHRWx6ip9sNJvYiuYhbTKNuPl4bNEMqrtfbsmByjgkH/PFT7WyshEN3LKBt3YwedvU1WL+ dLEIy2zjePuk88g1MqjbA//X/h+uVRLaQhNrIcRLuyW9jVJb4ww7NhTf94ZxX6Xzs+fKm2e9cSMS ka/ID04HT8TWvFGggGAiFD8x7uPelzSKjG7sIH80BQRmM/KBzSyq6MuFYtjJbHFLmfckjWeMyoJP lycEH19aW4YFwiqVdW4bPysvb/PvUudtLlKN3Y//0P4dvJnhYs3XdhQvzZB5zULO1shCMUklk+Yt 2FfoTk2eNypdCzMglTcASyx5zVuCTyxCqLtYoNrKOQfX+tLma6jIpzJljKwOBkMV27vpVQvGwAcZ x9zcMjvSlJ2uwLEFzHho5SxXHyAD5s1IUU7g2FOM7ScEis+fyG01uf/R/h9MbJF5yjbEDgtnGMVY ttQDCaN3OXQBCBivu3NvY8u3uFK5YRKzl98jkfeHIAH/AOqqdu+4OVCk55B6moFBJ7ly3gEboGZ0 kY8ucMgHoKkRXE7IwzGDwx5oJas7Gi0heJYxt3/c3D7uKrRkwPiCRjtO1z0KnvSaurCP/9L+JuK5 +VE3EyE4wOc1a1G5ufs9qA5KxvshiXgsT6//AF6+wPK5ryTMB7O7EkrTKS27Dp1578VXGIyW8t/M XjBGAKDUgYoSzysN/ZOhNXxG0RTzSYAyjjaSTnGKANdFgiQy5ydhUhuAfes9LmeRwiPmJOiydEPr WDvfUD//0/4iJI5BMqE4R2+WQ/cB702e0jRi4kZZFXll+7mvqdWefYBHB9nEm8GR+CnUnGeabbHz G2LEuY+Tu53VXI7GDVnYe8zQFxEg353ZThUpoYXDj7RO6hmG1CpYcdagRJNDEkkKptdW5aPOd3p/ +qqskcWGB2nHK7fvLTsxKKR//9T+HVpRHMCNzblGVHarvmtOyLGR5a4cFhhlI9a+oPGYyS5M0okX AkB+ZhwD/nFRNLKAygM5JznsKDG+txVnuFi2kNGRwwAwG96TdJOVBLhdu0j7u8elBrF3JYX8w+Rj ao+U5PSnK8isUiTeu7AZvuNj3rOb6FH/1f4iort4WVdxDM3IU/pVx765nneW7d5AgGRIxJbHT8K+ gPHK3lmaUlkGz70T5xtpJ7mB7cwISsgbopKgkd80GjkuWyKaiWdtjMxYDCrjAHrmrQWaF1typ2nk 7eV59aTdlczJ5IzbZcRuIcfO7KcLiq5+Ume2RJJCMIj8HHcilL4WB//W/iJF8t1MY5I1iPCiLOVB 6Ekn6Zqys+wyfLuVTsQ9R6GvdhseOI1v9rYlnaTYoJVRkxj60QQLG0sZbEbjCqeWBH8qpNPYClJF JBcCCNiQV3bRyceprRsI7m6aWJyPKQBt8jbQoHpTTT2H0CcyW8ixyPF9mYlhg8nFULnEx3shA2/J tP3hQI//1/4h7BWQu7q+4fIoJzgVLcXwCSIsR81PlLDjbX0B45gT3cwff8+JAFZQMg9uRVyykUF9 qeZKoB+8cJ+FAGxNczRBkAKjy/lJGRyOtZ1u5YFZE34O5pccUAW4do3xOwKk4iCjA9qRwkbCLfgj 5tv94U07GlPc/9D+J0wWW15Ud02xg+XjPoP8arLPFbwSyxkl5DsIJwU4POK+hjujzzDyYQCmNh5A HRPxqKG8IfLElQ3KA8/hW4G5JcvIixRAxNsy2T1/Gs+CdWZo5IwX3BknOd6kcY+lApK6H37mEwFd olb/AOt2q6qtIoLxKN6dQeM0GKTex//R/iAl+zMTGyBLhG+Vlbr7EU+4urZrdS+BMh288A46V9HP c8lRbdjNDeZC8m4+ZuwQOMjFOhEuXVC2NhYgn0pSlfYr2fmMW9heBYJIRujkLeaOX+lacs6SxJGp ZWRNwZh1PoakrkRg3RlVXXJynOc9PpTLe4JQ5QEnoGGcGgo//9L+GuMOY2V2+9zhTwv4UWphjf8A e5dt3HpX0B55ZCW6ytjD55UnqK63w/quj2cjpqFqbiN0Khs7djY+X8M4od7aDVk9S3rEMElsHjjT M5/dLEQdo9T6Vxp0yY+aoDSDGcdTxQIxp7U23mFiBIQAMnOyooJiXWJ48nu4HpQB/9P+HT7MwlRl kUIib9p7+1QrEJWbpu3/AHf4evSvoDzyvM8MM+1IQhU4bHzYI9TUv9o+YCjmTHK7wPl/GgDPcq0y q/zo38bcBPStKa0NlG0WxW3IJPlbcpB5z/KomuoGXhnKPH8uGwQRTbhZZC4IO0DLEfw1kB//1P4X bXyHgWKZ8sD+7A69ec1durgiELGoEXClM5Ix3/SvbjC+p541ovMRZRtyAOAeV+tCyeUrK67wBnkf dqWrOwFiKbyn3xE7WToDwP8AOKPtRKksiAkfLjr+NVBWlYBEvp7eEsqBuD8tM+0TyWm24YKC29R1 /T8TWpEI2P/V/hijEiq0rsAqnCr3OatLIZyVw0bJggj+KvcmrWR54x58hw/JXjBGDVC3m2MrTKNi t9w9Dz0rMDXCJLMsvABGCu3IIx0NMjtvs8mWUyAgjaP4R6/Wg05CKSINKHj6Kck9xU7SLLdRxKga QJxx973qeddSXFpXP//W/h+f5oSjKwH3Q3TmsQxSRuQjgjHAxzXpSd2cLi0rluG92GNDCHdSFYZ5 9M/1p8wnt5llYZU/NjOTUkmlBcSz+XmFXwdw52qnXGT0qxHqDSu+1MbBsLhsbh0xQCV9Cxc6fbJD 9pjhQiYBnkT764yMVkXV1HDH8ijdtwNvag1mtD//1/4bICFRblmLAtkJ/exWjb30cuSyupY4I64F eim1seeU5A7XG+HgKeAOAKcW8xlaZxsU/OB1pATNHAwzkCLy/lRVy59OKpSX15YzWot5pIxKfLGO No/yaAHSI2MTLjByGHO78ansrcwyx3UKKdr8BhlQaAP/0P4g7sEJLJJH+7YYX6nvXNtcxxMEmBZB gqEJyxzwOK9A886SPTb2aD7eY5DbxgMz/wAIUD+I0+V7SRVgiupLS6aP5ZPLzCPct/Si6vYfQo/Z 4Sjrbl7qUDe87nPmEdQB0/CsuZnjAeFnSToy46GgRvW8iSRxxhCZZANxIwS1YN2JopWRW8sM+SVb 7uKAP//R/hqe9FyIomYlz8oUDCnaPSjzEjYqGIULgnHQ16B55TF7KJmMCCY/ddicY56/hWldXIWA EPIxC/OFP3j3FBLimFpfvFmPCRG4URiWU48rkdz0+tTRztZzOZYIrkFTGGJLx5PG5SDzWD3EoJMu C8jWIbEwMHfgfpVL7SJlaHzHhVz9/bwPpS2LP//S/iBdbZ4xEkiNJs2+Yw25/wDr1Rs7S384pLLk ndsVeMkD19K6DzyqIxbyyyDcZJCOM/IuOwqxIxuEjSTawDbk2DEg6DaTSvrYBxuZLWDciBgG8sR7 h5g9eM5rQF7PbtAuBJLKchgN649h0pmsHpY1GvIY9v2hy27oZF4JrIvLi2AYggru+ZP4WpptaBLd H//T/h5iuIJYiZbbKtxuC/KOeK0XCSPGkKgsoDbiMAY5/Kug45K8kilNcb7hkgggkMgxLNnGz1K1 Zms44kKqdyMoIccFT1oKcU0UoIZUiYfNJKz5Qk5wDWpFILaHaTJLKBhZCPlX0GamSujJRbdiDzp7 XFwtzuuJv+WEUZWRvcnp2qe2u1ugWnTypVcoyE/fH+f5VibJWVj/1P4iHsdMmFzHqcccEBUtZtbZ D7lA/wBZ0xnpwa1YNbsbO0WMQ+YkbeZHCV3IzYAyfyFBznJ3F3PO28EOrPuYEAY9sDtWihRowJgr MQGg2/wexoAu29qjfvFMkQ3bnikGA/8AuirUMKJcCSWAqjcpKTtAoN47Iy9Wufsk0oii+WTBTBzn pnA/z1qgk8iRAlg4Y7tmclPrQM//1f4g7e6e0BkkAHnnbGwb5175xU7X945keaeeUShUyecKOgz3 7dfSi3QBXjibN3IghCLnEaZHHfHrSrdzpbKsUpaOV8vHs+bIPBH5frUQVlqA+XWdQFnLYWmLZdQA hvpmgQzSIp3LskI3L8wHQj8aat7cXS7bmZ2gtU8iGPH7tQPT3qk7rQCpFdPbS4hMsJXgBTtLfWrF 1eFrJw6kSs+1Z3dpJEGP4QTgf/WrJXUgP//W/h0inmjWURFmZl2s5GWP406Kz89ftdzxjpxxx3NZ uemhKlcpSRpDI8zF9smAuwYx9au6cr3Ew2EeUhwyP95/XisyiTU7fylE8S4RX59K5W8hjG2R4wof 5gyjGPWplLlJfxW8jMEq4kihypbq3TdVZIN3zyKcxnk9jWT1dyORn//X/hz8LXFrEVkkdo8P5bRp H5hfPQ4z/wDqrs/s5u5XlhKgKNxjc7N/sPrXlT3BKysMgvLq2ljbT4VSdGMjvIm5UAz+dTafLL9o /tGUMyNP8zJxDu6kZqAOgfVLa6iYBGheO4Mh2IWikGOFyfT2q1cFvs8MkURIc5cN8pQe4PPNZJLn 1AhluLa3t2llIVVjPyBfun1qtFeaXqdkkt7ErwLEyWlxcRnbbuehAPvkfjRNWkNaM//Q/jI8zUH0 6CG3uA720oG0Hy0ZM5IHXHFSNb3NxcW2w+WS6ibzm/dp0ya+eaTVmdC1VzWvD9j3zwossUZ+bYcM 7Z7Z/Ct+zt4r2OOWN4w7LmQJghD6E/561zTTSAvtHb+XJZuhLqAQeiseD+P/ANemWdvZjLXEDRzF sMyyEeao6fSuaauhuyVzrvCDapcXFxZR3YntpiUtUmCobRBkmNG755Nf0Mf8ESfA1uvxl8V3rzTW h0eGPUjthV5bkSRxqiM47O+3GemWr4TjSXJkOJv5f+lI48ff2UFH+Zf+lI//0f64PB9tHZ6Lbwxn 5Yx8hCgDBAP8811kahyDLkDoo9TX8i4TSjGPkj0ErKxcPyjGDgevX/PFRySIVAY4PQMa6jSLaRFG FL4Yhjj9KneRIVI8rBYYPHNbQ+EtELSBhgDGFz9P85qt86DIXPckiqGf/9L95pGYeXKisoUHj1A/ /VWS81xe74Y4wkineZc/fHP+Ffx3iP45g23uXt8n2VYyVMqH757HnpTZSVttxEe/G0kIFd+31pJP 2jNV0Pib9sFpF+HV5NY6HDrN/BazQXcN7C721rDKjbJgQPlKsdw91Ffw/ftCaAukeNL+2lbT7vX9 OdQ8LSk3bITKDvPJC7gSPrX2XBE1HHTp9dzhp3jXqPpZHhGlatNpt0l/eadGlzGrRRDPneU+CAeg Argr1JpdRlkFm5numLvcI2WYdfmx35r9joiTbv6n/9P+OK1vZYnjQW9yuxRGJCP9ae49/rWdrUdz az/bIle6EOJP9HhLt82BjA5z/hXy5yqSaKWqm7txFKbjUGt7VRcQ6XGcxeaT97aOe/6VpWHia6hS RNRtzJLNCYiY5QwCPxyfUVtH4UUakduLW3F7pUqs6DzvLnGI92ck+1Zun6pDcG4EcUJE1wzS4i2u jjIIz6e30rSCuxcyRTR3jluo591upJHmhMgLk4xUn22JYPsllFK9xcRNE9yU2xwjjPPqfT61sRzp Nn//1P4xpDdoYUttPjmm2qJpN3l7VX7zH+f4VJdaPc6+WRYpg7zC5t2tp9uHj+b5up28HINeOedL Zl2G31qWDWLu2s7ZLPRrWFruG4cRPIzOEPlEn5iT2/8A1GjqV/bvGkhfYCVjLMuNuSFC/qKCFL3t S3qNjcQeVAwfFrbrPmAkxykrnHH3uD0qFNYmFpHd2abGERRw6YKcFTx2NdBoeEeII7drtWRyyhm3 YXAiYnJAPcVg3CSSNFEMGNTxIevNddPewH//1f4PBHNCwEYL49slgK9H8Mao6bJJAF2HbslH5EUe RwRdmeuWOnXsWuzahKZLnRFtUOkXTfu2WZs+bgd9vAzXVM1u/lmWFHeF/NLniQ8Y60rWZq5JaM5u 71SS9F1Jp8IRopfJf+Fmx1IH+elUbi6gtbGSe2eUX7MBJuYmLaO4HY9a2jsjJu7ILK4klt1ji+0x 3MxMuxlK+ao6n2x/StPTba5gZskDEnmcD5U6Y/GlBvUzmlY//9b+Oy/s7K82SSwA3Nu2YbgsfkDc Px0OeOvpVlRaxvbWn2nT7W2i+aCaUBJZiQPlB65HGByOtdGx4zimF/p72oRY7Ys82JGATmRCD83u D61y9xLdWtwqw2y3NxvyYLnckUKdcZAzUxlfQXJEt2k+o3FtqFxeRWFu6wA7ppvKSRVIQRJkfTj2 qO002ZPPuIpFjjbBcR/MpP0Pbjr9KoyatoLc20cq3LhyC0OzzR95Meg/OqNnp8hghlLBYHZrZJ5G AJYDJ9++Tx3oBRb2P//X/jb01DYxSNbT+XdrG1oIAAGlVvvFm756fjWTr1zptvqen3Gm6XdO08S2 9y7xElJE/wBa3oBnn3rri+h4ip9y5FbHU42CedCA4ZZAuVjIPKkGqXitToUFnBMzPNqMQNssSGRw GOAzAdM4/Wtb2Vi4w190qaRaS294POjkiukgWe0ufLOx8/7XY+1b8IsVsZGvrCC5ullaRJU4lDZO DjPBHtSXmaqCRn39rp0kllJdXE2nkTLLbSxIJpXOB+7bttIz71HYzC6e7BZYGjkMcPzAxvjvk/ni toPoXY//0P40UuREJY1kX7RImF3fMRjgHHpzWaWso5Wa63TTNCAxJ2kuvfHoM17B5k1dFISvcXtu VnK4zFCd20Ip+8P51Zubi4eF7dLUgWzf63By6k9+3+TWlN9DNprRmUl35uWkxEkI2xkNuMr+47f/ AFq3Pt6wWqSPsW4dMFs5RQe+a6obGc1dCXEaJBDPJagvsAec5VpQ/IJ9sGsiylNv9rgRFe3n/eSe bzvYZ4qjFq6sf//R/i1e4+0NGHUpHwgaP/lmB3AzWfNYOhkntLhXYOGkhuJMOAf4lHrxX1in3Pn7 dEUTeDMhcNPu4GDxERx/SrMNw7W8kMRElyqGaIt/CB1H/wBaqc0io3voXmSS4tGk3okUUebiQnbI ueMAdz24rBkumidXhzhSAnmHLMBS510LSfNexpDc5tdQIj8lpRDK4kAZgPvDHX/9dXL9H824lsLa 4NmjqsdzIo8sbx0B/PrT54ln/9L+JC4yJAHdgAP4eSfrSpqD7I7cM4bdu+XgAD19elfXKab0PHKU 8c1zPM5J5x+8J29qf5UNp5ce4SSSHbkDcCfStFJows9R1taXMkbx+TLJLCS7RonCqO5qO+NzdfZr aaV3MAKwxE58lcklR6DOapT7itbceLRUUSHzXnUgJH1RR9KjlgmjmjaVpZLfG5tq/Mr84A9q0T7A f//T/iCOoMsbIYl8wvtUY+dR3/OpHdREZ7eFCVjwu8bdrHsa+4PDgupSW6nieS3lYEsglbPIXPv+ NJ99NyozEcuW+6fpQnZ6GluguSp3yujRhfkHVRV5r9BCiBdwkGwDoqg1Sk73YFK2vrnTUuYo0kSG 6xHcrvKiVAdwH4HmnebFvEsYKI/QMdwBHvWkneIH/9T+HjFxNcRJHLGZ3O8OhwfYZ7dK0byOa3f9 /IskjjLEPvySO59a/QoyaPDlDsY8kJcs4kO/ptUcAfWq8DeRIoIyucuCPvVs9EKSskSyXs2MKJPI aT7hyEbHrUq3SOwRQyoTt2r8xrC77kHS6XbJJcxJeFha5BkMePMx6AVX8QzWmmLLFaOMM21VHMm0 5IOfyzSGrdT/1f4b9NlklLEuwQnIUdSTV27s5rUoxIfzV3IA24HPYkd6/REvcZ4rkkPtkG4NeRhE XnaG25qVYTOz5k2RLl4h79hRT6mfM0rFaGUw3bwsgWXoN5/GoL8Osiyt0mOGUYGMY5A9K0KjLo2R vbxNGoQnI+YDPSnpbb02eWDgZLehpp2dyHuf/9b+F/bPCzYkBRzgrnnH0q5arLKHiZRIV+aFZDg8 deTX6bGV9GfPkFwkxDM0RBU429CKgjulTGI9zg4KgZIpTlbRBYf9okKb5kMSxvuVDzv96spqG4HJ VVbhEPH45qLsCOKdRIAw3qxxuUjj3pLxWiZTZkHzP9ZIeox2raLugP/X/haEsjqzOD8p2uD0bHcU sM3kKzQggsdxyMge1fpc30R8+Ti9lMbhX8p3/udxUsL2+0PMxDKMcc7jTi9NwAyIoDJt65G4ZxTL m5RHjkAXdtznHDkVTatYav0KYd5VLNwN3APFECB7hGLbVzgg8b/asSm3y2sf/9D+F68RoCFVAI2b O8H5s/4VpW0QlWNCyLKeDuOAR6mv0jbc8NW5bFU289o0wLoxZ/lKdgartbzHawOG/vDjFK6G1e5p RlTBJ5pBjT5do+Uluuc1hpuMxViNuc7e4ArWEklZkyTb0J5ESUmUMCg4dB94emKr/aXVtsZ+T7oz 1H0queJFrbn/0f4ZYpmljaIAbh8vPVqaQIflGSAMnPav01SXVnz4pmkkGAVOD3GMfSoWV/LcBgSO QuKrmj3HZ7lJEd5E3h0x8zkDCmtHE8eefkP3TWU5JiJpbMBUMkx85l3IUOVPtmqkUD+XK7AZU4wB k/Wo5l3Gk3sf/9L+GG1MgILscb8YBwasbNszXEvzbRsQMcsBX6OppanhcjFWTcxeLkngp0A96hWO R2ZWcA/wkmk6ibDkY+OHarpKMlBgDHJqJBFECHfDYPA5J9BTjUSH7PzI/tDkAq0gCDa2T2HaoTLN KreSA+1uSThq09qiZQaR/9P+GEXN1lxISCifc69KfaXZkZRy2D93GCDX6Z7TyPn1Hsakk5iTBIKu 2AvfNSwKxBKhSEPz/wCzTjPUGuhr27Iq7mmBdx0HpxWRc3P+kBXUPHGSRxgZ9zWjd9WJLl0Qkd24 kDgCMo2RsOMYq9Pd28tvucne3yg45zUOSRooO9j/1P4eFmj2pCSqAncXbj9fwquhModVOxt+1G6b h61+me08j5+1tBsELmZYjIGVTljjg1au5VZWijfI6nHTj0p866DSb2M2y3EkSBQxbap7D0rRuJLh ITuO4qNqrnkD1ojPuJrozLdyyAZf5+QB0/GtC3UGFiWG6FchSeG7f5+taXfcXKux/9X+HZWWU7XB TjOB0WrCQKsu5oywAwuR8h69a/UbvufP2S2FmEEEISKNFy2fl6rTYrQ3GxwxU5x14FF2bKCRblgS Fp7WVmieMD5gOvQ/4VloZYZTJAxyU8uTA++vcUXfUlw6ouwyGfeh/druwWPUCtBfs9tA2VEpc/61 gQR9BSEoPqf/1v4jGt4ywkbEZGFyOB+VUL2NPNJVQwbhSvIJHt+VfqN2eK4q1hq25WRE3DeuGcKd 2OhxWi19NtVNxVEb5EXgfjSIcLInJO13kUSlk2hW6cisXy3iiYsowPvYHQVHOr2Y4x2Y6eeL5IQ2 9RhwT2qbzy8cKGWRokf5FY5WL6VEpXND/9f+IGWdERgFAcHIYDO760n2pvKjJjClvlwDu3n6V+k3 fc+fLlvKsEBlgUvOTh0YkCMfSqcU0kc00ruA78gt95fYGtrpOwE17NLHH50nzbkGxt3QewrMSaQg TCIFkGVZhjPtTAke5Wdw8ETJKygHnPPQ4qxIi+Wm+Ty2UbgSOjdxig0gk9z/0P4cY52knVJBx0Ru gNbhs2kQM2fLj+6fX2FfqB45jukiO5I5i7dMZ6U37VNmNuGOSMdAMVENhJpuxTe4ZpN+CJRnhR2r QsWcEM7O525jj3Z2568etZDID51xIyMPmXmo3WSSMyfMZI/lX6cUbET2P//R/iAhikmsgm7EkmFH I5+n5VWl+026TWKgq8DgszDJYnrg+1fpB4CdtCpLczRoyKyu7LsbcMlc9wK0LaIRqpSdmDINyMMc 96Coy5VYka0SSUtvJUDhSenrzVCZ1imwMnoMZ6dqCXuaBgtZGAaTZ8m/cTlSQOhqlP8AZ0AaJgGU 9hjNAj//0v4b58uUAdmOMnByuaha3eTYTng4z64r9IPny/tiihYF25ACpjqRTPLm3Imw7WXIHek9 hptO5PBaM8pyronHKjDZ71PdmWMbLa4DLGRmGQZdz6g1jd9xGQd8qsGhCtvyMc7as2aCSM7iWO7a rSN900i4bn//0/4hTFsVgxbIGVccqKzAUuHbzI8YGBz1Pqa+/u+x45aLABFx8icMy/d47Uy4kijQ MhKuTgKT29anml2AQLJOi5PybcZb/PtUmIwqhEDBOC/cmnNaAtCG6WCExuH3OV3bV+6p7fjUCnzB g5YnlyfSs1B7FSd2f//U/h5l3CPbG2+BlC+WetRpBCzoodlwvIAxg9q+5as7HlX9yxYaOPKmbLEn aD16VS+ysJPMiTo3K54xSFGXKTyGa4/chQvlHdhTnPtRG06K28ZUYBH8QoE3fc6aOz8y06KiqRJG S3zbj/8AqrMuWS1jJABd/kd+jfhQI//V/iJsT8yS8NED8zFsFSO1S6heTiTzVkHlKAqIRjbivtuS J45ANQldETcgZ2+Zt3zN6UrRXcjFsgxqvzsFyAPc1ibx1RTkEbMxkj3OF2qV6nHSliuH3FbmV2Yl RGZAGEYHAA9OlAy/eSExRpkbCeSBycVqaFaWhE76q/lWsfzFEy89yBj5UA6Z9TUOCewH/9b+JG7F us5S081bQSl4UkbeyjPGT7UT2t3teVYnMXl7mZlwm31Br66MVE88pLE0UQkcRhJTiAIcvx3I+tJC LiCVhwCPmOecd+fzqhOKe5atrGa9kESnDO5YHdgHufwpk8LW6rsUuQ5G4jKkjqKGrqxnKNgtCSTJ IgDBSqD7pB9aoXDREqUVl3Hax+8WwetCVlYg/9f+IO2iSK5Xdh42jzudOp9KWZYknCRkqCd3yjH4 CvqXa+h45LParbpHPEodTyUHBBqG3dZE5XYDJk+oHpSMZKzsbC26kLIVzngKPbuaqX3kxpA8EYLb 8O5/g4oHB2dhILQswEaF93zM5Xhc0/ULUQLHFDlv4gy8AHuMVnNW1NT/0P4d44riJw5Ks+/o52nO cV2N/BE0EZfY+2EMxjYMGyAdufUV9AeOY0+0xNFtEYEYCANlz2rLFrLKCApjKnALfKaANhAscCxh iz7fnYcljjnNV7aUxz5bLdVCt0+tDV9GBotdCNUW5ZXLNkJnKEe46VWS7txJeeRbxyLOgjSQg7rf aQTsHTnpz61Ml7rA/9H+IH7O0jho02Sqctu+ViK7XQ9EOqAbQsSD5TkgHPTkmvcim0eOaGsWMGhk WtpJDIkhCSPECAG/iHvj1rgX3wXzJv5R9wJ5Ud8A9O9OEWtwCc4uVul3K7MOvBbGB+RxV1ZZizGU lUccIowGx0FKCaH0sZl3KbkHeCvknGQDjP8AkU9ZvPGE5ZF6HABxVpWVgbvY/9L+IRHnlQvGjIoO 05GBVWBuZmY8ZxyPvke/pzX0B45BKrrISFJLdMcBfoKda2ssbG5G5SW5U8A0Adbp/lXHlrcsgQuA 8hIGwE881l6ki6dcXiR7fs8c5jt/KYSCUDvkcc8/lQPSyMW0muJpXaQeZ3iC8BPap7qKTanJEoPL Z5UUAnyu5//T/iHjeOOHzEneWXbiRCvIx0x61lyTG43ciPA+6eM+1fRR0Z510O+wXfloS4iDpu2S cA+hpIrN7eTzi6CUcFQMr9a2FzRHM80rO7sAM4yO/wBKZJKItkBYCVOdx4znkUCk1ayDzAjR+cpm k6/Mev41ba5a4jMCKItpyFzgADtQKn1P/9T+GgxyW8hlYZDHg5yarSpu+dBlS2CM85r6Oe555cRJ EgZAVBY7gX4K+1bOnRS3Fi08sIQAmMFiB5oHXFQBi3NnHbs7Rh9p5O47tvsKFvI+I9xIQZLY60AV 5neUnaCVboTVseTHGiiNTKDktjGPagD/1f4ZbkTxHITbu7r3pskikRbFfcE/eHHANfQHnjFgleTz N5G7oFyMCl+dH+WTcR2x0oA7PRJzPut3jIKxiTzCwKt1yMeordk09mctC6RCVNoIb5Y88Zb055q1 BsDiNYsPIuGgEySuG/eAEHJ9R7Gs23gELLK6B3Ztvljog6c1NraAf//W/h7uJFiVflUxnqVPIPtW WtwUIUjaDn5sYNfQWseeRyoZBujHX7x6FsVWzhViXcELEycAn0oAegWMyxs/mFQCqkY68/5FIJiJ zI8zNuUIYc5UYz0/OhrSwEsqEOVI2q4z8o5FU5DNuMSbzEOrleD9a5wP/9f+FjyjAFZ41ZWPUNgr S7TKTnesde/HZHn31sWlAR1hU/Jt5JNaHlSCHYyDa/CseuKdhN2V2VABCylo3dFblF4LgGnyiOV0 lSJoI5D/AKljl4wDUKLUmzPnZOzxbfubAg2gdA9UJEJYFWwoOWB9KsqGx//Q/hhtXAuH3p9ohA+V AcAn/wCsa054xCEPAJG9mz0HpmvbnueeUZ5DNmOJFYgcOo5P1pLOxdmeNkDjGQWYdagC8kEgRmjZ B5Z+fccYHt+VRK7vJI/m+WFHdc76NioysQmRXIVWIB7qOuKmaW3dreRYBHPbrs3qSC/Xk/hWU7dC nrFI/9H+HB7pblQ0ZdG6FHqKVJIY0kCb5HbGxT83Pf8Az6V6BzNaMjlVUjSYq/mh8yFfT0xVizvY mEsc0bsqcgycN9KDAvB5BEUVUWFhlcnJY1EhYlY4wAyncxTqB05FBrFJM1F1V7S3l07yU8lm8wMQ DISRzz/SudniSWXzFJUjjbnCigJuysf/0v4ZtnllBx14JPC1PsMaeYrc/dcelegeeRR3U0biMbRs beJRyxzjirFzGqohU5Zl3sG4FADjtigR3cGRhlFDZwKdA0LgNIvmSA/u0PHNFugEEt2jfu2iC+W5 yFPFT2k0rr85ZIRnDdFXHtVculxJWP/T/h1uNS2xG3VHk3KVWSTv9Kx7eNpsEIfMRsMQNwb6CvQP PPXNF1HQoNE8nUftUoFq6/ZRtjmeTP3cnjaR3riL2G2Ln7M7pGwBCSkM6j0yKi3vj0sVIVYFIo3M aBsqyDqfc1cubX7Ph5fLlST+PPIPXNWIoQzRCcIsnAPzZGNoqa4W2Y7AmVAyXByWz3oFdH//1P4a IYUJaKIKrfwyNwy/So2026YKgcysp2AfxH6V3cy0ueeTQw+TYKgtRHdJOR5m4kyqemQeMj29aQaf cK6O8mUDBvLUZyfrVAXNQvITElu2lWsblg29Sxk4xjIJx2zQscrpkrtGMKhHArntbQClOk9u0aKu 526qSKClxHIuSioU3MvXn0H5UAf/1f4c4kcsSY1fPKqThfoTVu8tkjYS7VidkB2odyg10HnlOKJp zt3ZMZ+YZq7dWQtollA2kHk5+b8qLa3AxFCm8ZY4JpSU3FjkirUlrOrrKGKGNd4CnDYNA1o7jlvj eR+U6ttQlMMMEnpn9KiMLlfs8a+YG+bPUg+1A5SvY//W/h309buCKWNVDwsQJBJyoqO9S9ixOE2W OPJ3rwC3XBP0roONS5pIIEcMW2lSqbj/AHRVlGuAWkcZhY/Pz096DQ1S0NsGEAWVRhg7HlMjtVKF pN7M7jZu3BHOA30oAnnVY7gkMJHaICML0TPOPwrGR5IZGkXDOsnygng81zkylyn/1/4fbu7a6t5L I2ce+Rg7HHmNx/d+vFQR2NwBBG2xvMfDDdgIB6+9BzkHnG1nP7v5EJRkYbs9ulXIYXkeJUYGORvv f888mgDWN2LUDzH83y/lyeM49qxbjVbu6kk3LMlojAojg7CF9P1ppXdjaHwotwqtwy3MjKQI/kDH Kp7/AOfWobiK1Zomt8lmb95gELTcWij/0P4hvs9oqJ504uX3F9gPzxei/Ss+6+0yzJ5bMq/d2g7U TFFgNjTLW8ZGEkjNDnJ8wcL9DWpLYb7UT24DFZDGApAyR1/nQK6vYx5YJpltrWaMrtkKidc5GTyD 9KqzwvayvBCzSxZ+THqPakrdAckhiIJLkI/mRsMAmRcAH0Nal3bedAzxtGSrbTFH2xxk+/tUu3Mj OTvoj//R/iGitJUQj93tkA8oKR5gI67v/r1C0c8UMokfy0B2ohPys3f86we5zmXMkz23myg7YiAN nzKvoKnscW8T3Qc+YVxFt5AzxzSLU2tzNvL67ZPs8p3qW81OOFzj/CsG9uZJAI2HRdvA+VcVnU6C 5ne5SVQNiB9xbv0xSw73ZoQ27aeeeCM1k3ZXNIyuf//S/hq0C18lvN537hgkZ2fSu9LRSFI1kVJJ CFUev1ryG7sCFy9lPJFI3IXbxgDPp9KuWcH+jSok8lpFdSL5kcfyxOwOMgHjnp+NINjRayUmKC3u TH9mxiHABz6lfw/Sruyd2dpZGaNOMEcZFQotSuzPn0D7HHdysjmWMzx+XGUXcwIB24X6/wA+9QSy yXMJ05VYpYMR5TRhE3cAsTjk5x1pTXUSm+p//9P+MWK1u7dIkVSt1cnZ5TMBCi44YsTx+NdBY6Lq 00Kj7RZvGhJuGecByoz93HU8dRXz5KmrbmjOkIRl8gTSsmxULbFXnqfWi0lNnqZ0eK2kINit99rj 5jJY8p9RXPV6jUl0ZJctdNMgG75WLFwMFce1TpJNLJBBHtkklfYdzbWHoM9vxrnlorGkpLlR6V4Z hOm2scqRPLIlyiyRKAQyGQFwGOexPPbFf1Lf8EMfAZabxh4tlcWsMmp22mTWiMbiOeKFfkUsOhHU D0Jr8548m45LVj3sv/Jkc+K950YP+Zf5/of/1P67dGRY9MtZG+QSRB1XGAAfatzcMxtuBA4VR1+t fyVRVqUV5HpNaItIsrks+cH7tVJoGV/3hOP4cdPxrU162JJP3aqVVd4H3+4pizeafnU5U4z1BrSP whf3rDJWbIZeAT6VGlw7ybQuUAwfWtBn/9X93XdJ2l2SYKxmMc7RtIwcfnVqwWxt4MSszKi4MjHn 0GT+lfx5if46Ocju44UAnjLCBFDbeu3HeotTtZUt4p0ljZJ4g8YRgxB56/pQvjZst0vI+efj6l2P BLxtNLJJqdtJaXdgpCRzIEAQvjtjdwfQntX8Lf7VOgalefHXxx4i09bZYXv2tp1u0a33vH91ISeG Ujbn3HevruCof8KLn5WPOq1/Z1HT7r/gHxrrWu6ta3Vxc6tp89xFKgkb7Egy7A7fu9sDmprO9Wxi t5LW2l1i01RiZdVuAIl08su9YQuQeM45B6D8f2inG1iL2if/1v4ytR1W/ExgklaKZrgx2TKD8yHO 36Dr0rUskurcQw3Uh3xNvcxnCSE/z618xFXdjzIyvoyPUbuENJJZJKrTgQ3MkimPgdeD2zVWa0KC 1i8q3ZV/eTSJJ5rsrcgcEjrW5fkaUFukNndrvZowTPLubnaf4VX26/hVCzsYfMM1tuhjyLh5n/1b r6EdR05PvW8dhpN7Fi9sl1BXM1y1gj2rjaSP3rDow79uB70zSLGJGuIVuDLEsSyFZAY2mPTg9Aet MLO9j//X/jrsYxPPMIG3MT9ne0uE/cTr67hyPQ4p8sdvpVkjW1vFZt5zRN9kyzFiS3I7bc4zgdO9 eOedJaWZzttu8jUprvVp51+1obS1lQAMHzuyR6H1/vVWOpJCrLPaw3UI4MRTjHY49RQZcsjctvEa zS2RihjSFV2NJI+6RWByMjsOQOfSqi2V5Kmpy3VvBHaPI7ILWXewLZIDAj6VpGVlqbHhGtWRhmkh S4Mqtly7KEccnAPb8fauZdpBIqp9wDkiuuEnuB//0P4S7Z2crtwZFOea6y0eONkLweZIp3PE3+rk Hoax5ne5xwSset+HtUluobPz3kUbSIrctuFuQTkD0yR0rub22kGk3WpQRbzaRGYRE7ftJH8IPvx9 KOeRdk+hzbS6eixSgw2k1/H5v2WNtzqx+8G7gg+taf8AY9neaUEiSLzvM3StKSCeccf4U/aSE4Jl C/sDaIj2svnPDCYlbdiRO5UHtmqWh2Piy8Y6zdR2402OUwTWm/ypFC9GIHOTxzxmmqkkzFx6M//R /kA1KGKeCZVKW6zoUdQSUTOOATzXncdmJ5WkvvlECtbQxPgoig/6xc9zjjFZupLY8tw7HZ2h1C1s Imjvp7tzH5ULTSBmEWciMH0HofWoLqSd3RjARKIhGTH8zSn09PbFJTaBQ7le8JGkahFDbRX8wt91 uLwEx2smR8+B6e9chb3F2l1bWk9wWupbcfIrYinKjnA7Y9K1Um9TNq2jNu28qO7nsLm582Zwrfux +5jJH3SfbBHfmrt2iaRZCEstwGLTIFPmNEx4OAOlO77gf//S/jb0KWwFkL2Pbcz8jdLu8y35znB+ hxn0rMutTku7t4XkjNvt32zof3hYjn5fTgcg1pGbvqeVGN7k9pLfAwxC+CwFsSwxMBIw96xNYW9s 9Y0/VRBHrltPJ5Kyfbdr20KNtKsD0Yc8D09K25pDhFp3Z0U2tJMyxtF5YTKRhvm2r1GG71lSTHzG VUchfmPGaOaRoRzXVrdpGPLyEPlo7jLhhx09agW1VTJC0uxBySo3MpI4yK1hN2LcLK5//9P+Le2Z 4ncyKMwJhCwwz+n4Vdu0s71FlbTozdQQnE6u2/k8njt04r0+dnnnPv8AZYJYp2BKxjYE5xGT3HuP 6VFLqdwI3jiuJSHO0443c8CnGo0xNJ7lv+yojDFLecRpiZ2zlwWH9ap3yW25YwG+xgBUPbB45reN R7kOHYs32o+VZ+Tl5oAoA2Lll7AfSs9b4vZwYtQlxAzGXDMWnj7ZX29feq9qzJwT3P/U/ig066nu 4HuEij8mOXyiu7DrjoQOtPvbdHETwiRmkG2d89/Qewr6D2vmeLyxQNYxW9k0kco+0q4Bt5RtEqH7 zBv7wx93HOetYMt5NagtFF+6kICkD5yfQntV87HZJ3JBdbdrFpQr4Z4W5UH1qO+ntEnhmjMrAHA3 JjcR149KOeQxwv4ZAiqqFY2LGMDYBWhYXksheZ5BPCkZS3gbIhQk9/fNHOzSMYtH/9X+JWIQGe6a 5Qmb7PmJlbKxnOcYqIyRl4v3SlVOBIB0z1ya+kVRpnluCSuZd6HdzFHIVDygk9Fx6VcWHCx7Ww0Z 4fPGRWymzMmj1LUbUTT2l9NDdSoYZJLd8M6nggn/AD0rHjkL5kmkc3MbZ3HhifX6VXtO4Do57p7h Pssh35yzNzg9z9K270lI0lWfzj5YyijaqN3zWiqabk8kT//W/hrkmlEpnlfynj6YTIwPStSKczog CN5bYYuRtjOf89K+z52eMopbD3t4pGLx4Kj5ZVI3BgKqtKZJ4PtJGy3k2+XD8iyRg8A/h3qVN3L5 Xa5ni3WS4xJJLHamUu4T52RSSeBmrk7WgWOOyaWS3Q7S0ybJWb6dqvnfUIxuzRtbdrmNvPYbFxhS MPj24rMulSOd/LDCAN8kZ+Zl+tDm+hXs/M//1/4ebBszFowGdBg5525qW8SXcO5Y5avt41G9DyZR sZ8Imkm8vO0bvXH+eBVadCsrEONqnp1/GtfaO1ibJ7kP2mYFbXkxsTjuq59K0UltLXC4LP8AeZz1 BqeeQnFMjGpyZJiMhDnaxHylcHrn/PWo7iQ6kVjkJLIMI4HLfWnzsSikf//Q/hw0mJ4ZfImcRQ+Y Nzkbig6Egf0q9c3KxNMscomto5Cts0qhJHHYlcnHTpnivvfaaWPGsuxneYbgxrLIVXOfX6USTSpC 7mYHbJiNFH3R6miNR7MOVbWMRp5BK0zMxwd2c85qRL9pGDTFmPRfYelacz7i5Y9jQimOQxzszg+q fWta5voU08LAyi7Mm1y3IdCOwoUm9UyJpLY//9H+GWPfHG0xX5wflJ5A59KYs7ibzd2+Tqq9l/Cv 0PnZ4kVG2hHc3d5cr8+FEYwFRcbued1V7eLa/mchuuz/ABpOTYuTWyNG4KMUm2b0UYZM8D8KyJth ORj5j8qjgLUp9EVyRJrZZFfDY2+pPSr73ixhYfLjYhj84zub2P5frVqbQvZo/9L+F6SAjDkj5v4F 6CrVksRDQyIBu5Un19K/Q3Ns8Nw7EF3bRRjeocyBsgL9wfWqkO2XIk3LjnjvU8z7jjBLcbPgyhEc FeNvc1LJ/q1V0DeXyrdTmqc2WVEZlAdwSBwF7VajcPFKPKUv1Qk4P4VAH//T/hUuY7iOBZmLlSAQ pyaq+c+5JVdgQoJ7YPpX3zkloeOXFu3kdPmIXGHJ6mtH+0YQUjKB41O04G0n8aXOgK1xJE07IkZW FW3qjNlvxpks255Gt44xI8W1wQGKAYHGa0jJ9AKCv5IMYBD98ipkgjd0IyrEZweAafNID//U/hcw 0ZIA2kc7hUEkzqrtHli3BJ6iv0JTaep49h6r+5XBYSueOOPxpI7e4L7nbK7scVo5JK4Fy6cqYoAh AAyWx8x/GpEcvuiGG+XGW7Vk23uQ4K5DK7qBG7Y8rkEcH6CmlmaNBHlA5wW6nj1pFKKjsf/V/hlE bwiFXh3+a20Sf3T61NZwCRpPtMqgRSbSHOM+49uP1r9APHIZWxJI0HlvGrchR5ZI+nvTkuvNZQ8S xegzkk+lZSk76AW44UmklkcyQsEwMfdbHasyaKNnI2cgZ3qc7D0waqDbVmBXWEyt5ahw2eccBh71 ajjFqdoLEucH5eRj2qwt0P/W/ho2qmWJ3SP1zwQKbHHGpMicMvX0r9B5n3PFSs2xs8nmfMMh4ufY 1BBezRM2xnRJvlnUclhkHH6VtF3Rk1Zs3YJEnZ/LKqsUe4FnwTjA496RreeeGRoAkgjOZlLhWUeu O/4VTbe4jIGRIBhvL9qty3ab44BHlAp3d2BpHQttT//X/hdi/wBIlXDExq3RuBWg0T4zCw2/kVPp X6QeLyq7ZULXMR4fO8YelTzSR8wQKdrMoySD60FWtoXxbrE+7aWEOGOOQe+aa87eYFkG9mGBxt2C gzmuqGeeoIjdWPlNxgZBHeiQ7mWSFVQDkgnIOK2i7ozP/9D+HOISzMzYKnGCMcYFWHmuIUbeyvbh cIAuHBPrX6gfPleN1dWYrwBkgnr2rRt7pERh5WFUcYOCTQdC1KUl1Izu8h86THygjAXtitFYZVIO 0Rl03AY4GfSgLorSOlq0bRuXlDZcbehB/Wr6x/aVMzNjJztAAXP0oBa7H//R/h3lu2c+TKmGV+x6 DPFWUt2uRvTIdMBcdGr9PvrY8cjm32pBMZjYn94+OWNOixLA0jllkDfK454qZNrQCeOYtndMCVOQ vQippAs0bIG2huvq1ZAZ/wDZ0QcRy+YjpgkEY3A9KAm14rcN+6aTAbqF7daAP//S/iDmtEibEjBg eSM02FLZciQMCOYyOdv0r9IPBcWldkLSvHJJ5eTkcLjqKhZxOEXZhw3JGc1cneV0HKyxJGcNFLhz t/djsPT+VR/ZnACyMRu/hH3a1WpNiBWmtd0cMWZM/f6nH9KR5pJjiVecYb1WjYuG5//T/h1t7XJ2 gSSkHduIyE/wrobaMR2rCUO0okyhL/Iq49K/THNWseOEdranUYFuVMltMA07A8oOn9BVjVYNEt7a FbWJVmjmZWkWYuZgTxkZ4x3pRkoqzIStJs5Yqsk26OP5Y1wWAxuz1zSOViCvCGXack55WoLCFIZV 4kbMpxI+fm/OpLiElvLhJVVACk9WoInsf//U/h3UPGCJU2hRjc5wM1AlyRJ5ZALE4Df41+kHhRjd MbcWbFvODYJOWwMKamhdjGVVeV4LEdKCB4cK5VnJLDhM4qCSB0IkZCGkOFPagBRFnKTPtK9Sp61H JBLI48tQdvQdOBQB/9X+HBpUhiHlgNKTj1Appd9qt91S2XI7tX6QfPilzIy7OSp5XGTW1JdRvBGu FjkU53gZ7dKT0TAls5w4lRZg0qrk7RlQPWs3UWjgaFtytI4y4Tll+v1rABiXlqS+9HyE3Kka8ORj hvTvzUEG6SSS4ZDHFu+6OQPSgqDsz//W/h3urpp4DDHgbDkgDDN9TWeFdvmLMjLwVB4Ir9APHLkc hdPLK5ReMjv9anayjYq2ScjnnOAKAur2LMM8Mmy1jKfICNx5bjmmAKkblRkAnA+lAFJYWlU5BRge Qwxj3pBbrHKoaXBbj5e9AH//1/4fb2BoYo3SWP6BuaisruGBS0qbpicHI4Ir72cb7Hj+RSvXkd4v IyNpMi4Ocd6bb3N0VZiCvP4MfasgJ4vOUM6khwd5PepCsk/zoNm4YcDoT60ATR3M1tMi/N8oAYE8 e1TXBS5djINvy5DdMH2FAH//0P4bIxJZyEqTKgOfm6GrDTLcIQcvJIT8gGFj9K+0c3seOMSCNBtl bLAZIGRVlrq6RTErsLd1G5AeD9azLUrKxIN3lJMu35W65yxFTSRZzKyBvk3KpJVj71MpcpakmriS XDfZIXkhzEHKq465FUpL64kUhHKKOOuKlTu0Rzs//9H+IWzfy5YvM3NGY8sWXcpNbdxrcjWAtpTu jVioTPzEen0r6++lzzIyvo9zEEkUjxiIBUjXCq3GKsWC4nZ5VVkUj9238f8An+tMvYu3Mb2we7SM qGz+7U8Y7Y9KxluLhhL5qsqKuUi64Y96DKUr6IaPOlESygDK5AXg49aLiNLVFCSh22kuMcqe1RN2 ViD/0v4frMNIU3NJtBKhmBYCpp4pVuU8zaVUHaw6mvqDxxk07eUsKON7v8vPyAdOT/npVWCKeJmE jhwGyrJyjUEuNzUNydsarkyN8oGcAVJCjtw7DaTnavzBqCYRaepoS3s9qssUbBI5EAA2jjHv61jL PI8qmRyWhB2JnqfWk0nozQ//0/4g7m8SZdrwqJB8ocMQWphndIkt3RmVW3KNxFfQtWdjxy/bxyOQ 0kYCYzwMsoFLcXEBhYf3WwCOppAZMd3IDteMFSeDzwM81ZjcTTyF2+RRgFhtI/8A1UAK8SNJv3bo 0H3ScFj7UwxtExWGPy2bnjuPpSa0sB//1P4hYVn85WxIwXhmJyxrq9M1FrS2lgjYqssm5gT8zEZy M9fwr3ofCePfWw27vVu/3aqxCjLEg4H41xVzIUuP4niMv3iOR7VQGrbSC4nDXKgxZwgzyMVZee1j njZ5GliBMaLHyQxyBx9aAI7mJoxuAXJGVGPWsmNoTceVKTEjLhZEy2G9CPSgD//V/iKVZ44mALYx tVuwH0qlHHJsKTngsTGMZ5r6Rw08zxzQjtZHZOkkeNqRxDdIT6YrS1CwSC0hmjc7uksUgxt44/Go aa3A5tnkiiRUMmHk2umDtBqS4V5oolQYYDb6g0gI4A0EYCoEnVvmIPDdqR53kdxIFXjbkHp9KAP/ 1v4eoWUcDGV6Z6mrTvbRNCJIEmkZw8gB24X0Jr6A8cq/aJZJ57iYyGLbtgVzkDHAwfbFMuJHaNdu GbIBC/eYVUZWYF3dAYS3lZZT9wDlCPWsKaDczTMdwDZA7rVc7A0Qkc0XzEZCYjKfeP1pITGGKSOq sowWbj/PajnfQ0p9T//X/huaIsWO4yBT8z44xUSRou9gcFTwG7mvoW7u7PPNDYpRS5UluPl5C5pv 2qdIza4xEpyO3XuKQDmUG1KYDFzwxPzGsx7eGLLhC2xcFQepHtQBWUPkhd2f4FPQCrFuHywcCXnB IOdjeh/KgiUW9j//0P4eGWNgWnkbZt28HBHtWWfIjYKGcwFvl3H5j6ZNfQHkapluX5IwIgTn7jdM VDHZuc4JDj72eKuCvqa82qRUhhu/tBAuZUUfKI0Y4kz689K3rrULq3tksy79PmKv8wHpWpRgNM/Q M0kjNuLsSWq3FeBEZiE67CG6n3FJ7MD/0f4XnON0iMHBbccng9ulNNwJHRgFCfxJjBr6OatI88vx 2zSCTyzhsZUegqGJmDFJYt75CLjAK84JNQBXvLYi4coScKGdx0HHPFQNGilHUllJ+Y9TQBdWUb9k isAFzHKe3sRV2VI3hWFCUdiGZgdoqFBXA//S/hiuoSI0CxyghgiSEHYfemxRvaRt5m6TJyc9q+gt bQ8mV+YuWJt7udgy+WrLhXzt5HtVm9uVhMMCkkRnjf2xxQJtvcheWSecszDkDoMAfSkuB58nB2yD CljwTj0oEXZLQCAtNLGpx8nPDn/IrCcTQkO0QMbEoAeVP1/z2oA//9P+GN43jVDbMASnITtnt/n0 pkgmMSozN1wwbg17UndnlQetidbi2gV9vylRzzxVAXM29nTGDyuOhqTU1Le4DbULAyHl1zww75q+ oiZZ9sQQBeNzfePtWc30AykMtu7M8QK5+VSMYz3qo8P2iQs0jBg2QqnAOKzA/9T+GJY5BIZChVEG FDcA+9W5WaYpLHKYzCQWGfv+wFegcUp3VkPRpSwb5SWbGCOWoMZmu1ZyI1+4y/w8e1BBJqZRYlWB 8tGNr7f5VFpjedFMy8OFCOwHzD2/GgCreF4XClyyrznrn2pIUmupBhT5a4LP0GPU0Af/1f4c4o4p pgkhAt0fY0gG45HcVrDTFCyJG3mKybmzydvqPp1r01C+555iyWBtnBXc6dSxGfXr6VSW5+0lQyFt jYYA8EDtVciASdZJp1EShY1Pzc/OATiiaDbOoieQuOV/hqrLYBjoVKIVYM5+b5flGPWrFxJPbqjK 28OBGVYZAHsKyv7rQH//1v4Y2D/JvATuFbp+FaEa7IZGgGNg/eFR8zE9xXoHnlaC5HmMkrM2F4B4 OaddeaQrZG1h8uznFZ39+wFeO7fJgGd7EKjZxg5q+0b7fLllDMh6K278K0MXNsqS29wf3yKiIPl+ bg4HeobWaZJpGRsDYY2LcoaHfoSf/9f+HONlVQVwZxwDUo1I28kcyJueP5XiZQUBIxXWotpWPLjJ 31Eluopni87MQDZXaOmatXOoRW6pGnJI+ZsZ4960SsrM0MszfaryEBdw6u2OAvenXlz9nnaGO4Ji lAJJXlSeoFYtWeo0m9EU5ZH3ELFK5iGQ+372KnjuVmRpHiPmk+WYpCUMX+1SLVPuf//Q/h/Mke37 PFGu8R5D5/1lQ6dIZrgLeIEgjbmVjgpjrn2roPPtbQsSfZ7a4lks184ZyzrypHbmo7y+N1+4ZBGI fneUHLSZHC4z/nNAFWxv/s7SpJCqZOYZi25j7EdBU0rRSASlyXPAPZfagCijBJnfARUYB3xkc8ZF a6m3gLPCN5xkuOcfSgD/0f4cTM7TPs3JE+AQeh9617WRpomhmi823LBdrNhW9Dj29a6Dhh8RLONk eNpB5UKowjj2NUgHSNvNBiRk4hznIz/9ag2t0NG3t7WW2dRJGmVwC7fvSw6YHXis2aJImXa29kbB ycfpQA+8QeVbEP8AvCxZm3fMB2XH9ayzukn8t42AxxsGW474rnIlFvY//9L+G1ZHt5FuVMityjKy 4IxxU0V/MdhaMKCSc4wSQe1BzjktZr258wlU3SiP5ztBHTNadrA8MM0ypIyI7QZY4G4elAFWGB3d UlA2Z3En0qWaa1CNaxgMzAoOM7c8Zpp2dzWnsQyxRwQL858uMBSACM1XkVxGhU4U/NuXggHpTcm9 yz//0/4eYIFjdJZCNo5Z3OGPpmrVw0ZYyQMDEpBx03HvimBtQaooVbabclunzuF6OelI7i1k373W F13RBScN71nKWlkZS0ldEE+o4i/d7zNI21WCYVPfPrVOO3u76SGG1RwIyZ57hu+BkjPTtUKTSsQS au8z5mMTTF3UXEgwoVvX9KitfMkhYIi7E5dXbYW6dKkD/9T+Id7tIJpVMe22Ch45M5dm7rWXd6hL dxeUY1CKxfIXDenJrnOcpQzkWzQoSIly2zOFc88kU2xM0wcFNqKvKgY30AOu4pVjhdYfMTzNr+uD 1/Ksu7tFCkR4Kt0fPI9qzmgOflAhV0HOOppluJi8ZiVjv+RVQZOaykvdZpBaM//V/iK8N2EyW0sl 9twhVEjSQM4yCckde30rdEVurSC3jkkMLblkmTbInbJ7V44rWVixJZ/bInMqAAAMGzyfxq1bidDc RtGrMsai3Zj9xhgg4/Cgxd76k86yhhfO0bagsQVpE7Advxq1a6mqxlZgBzuYN0/zxQS720NS4ktZ 4obuOKQyWqF4I43Kbsggnjrxnr6Vh/Y7BbW2n3ak159pMs0SS7I5FY5AY5zgelZTd3Yxu73P/9b+ Ma+1iV422GATwIEjiYYLjPA46/U1s2CalJaLPHbWljax4Qw2lwZJcnknaTnFfPnMtjTLkNEY1L9m Y/19O9XwPs5czSqkij92yP8AMQff6GuWqykruxuaMuma5fQ2VpKWkKCGe5j+UF89Cx+Xj2rJ1HRJ NOurmG1Id/N2ATEvuY8dR/SueV7aGs37tj03SLK6fSbG3ie0sp5n2TqrsREgO1jntnrn2r+xf/gh N4Uk0v4OWGpvavdWer+IzHdXEZBjuHh/dNvx/siNge+41+Y+ItSUMshCP2pxT9PeCrZzpx80f//X /rws1GxISSoiG1QOQAOMfpW1apHncF3MDgZ5IFfybFWikekuiLdyzKFKkrgc47VmRTTYZXYyHJCt jmqSvoPm1ZbbMkeGBVlHX6VHGyIyE48sNhgOCK3SsrDUrzG3Nwocqqggc7RxmoRJtQuuBk5K4wwq ktbGh//Q/dmWwi+zSCRHW5nbahjfgAdRxyDyKjEUyWos2dyxbzMtyzH3PU1/H2IjeuZxjomTgTbV hUuwb92yAbsj/Ipy2KLGqs7b92QnIVxn1qbe+aWPGvjDor3nhbUbi3Bku7U5tnOSsZMcgIYd196/ iS/b60TUbvx1r+jWdtAg0yaKR7tLhoLkyF1LlcDawwDk57nj0+04MajjmmeJjNK8F3Pzd03SLsfb Iry8V7u5UxiFCWgUZO1mB5OQPbpUcmmyabcwrNIv71gUVWxHJjrgeor9lg7xLmv3aR//0f40Ly7k nvN81vE1pAx/s+ZlCOSOpHcfSrF1qcdy1nNFC/kfI6tC+9gR94H2yDXzEXZ3PFg3YS/1FJGgspbd /tEvKyQrujCHkFj27fmaVBNbGMW9r9oZj869C4Ge/XAxW50p32Fsnur2RdNsoGe6u5mD4yXJP8K+ 2PyxUraRqemCa+jldLYwfYXgZA65Vgx68gj+gp3aNqewr29vc29ldvJ5zNcGKSJW2vHgfe6/pRd3 DQWctrHgQibzvMEKibAGMbuSBz0zii7vcu3Q/9L+NrTLqRSSlwLO6X5oklO2bgnn+talpPFc2w88 sHju2kcqB+8z3Y+5rw1Oy8znlHozM1PcsaiaaMaYk3nqI4QJFZAAylu45FcvJNbTo0lmD5RfarP6 evFEZdGZcjNzT/DJMUV9A7yAncQeIpfXA9q2Zftlva3baSkbTIhnnSXay4jGWY5GDgL09PWrTvsS 01ufOeuaiby8kn2AuznzzCAtuOf4R25zxXPSzKwBjRUwMd/nPvXbTegrW0P/0/4SrCBpQkjAhlYg BT0+taKpcgt5cryFm2YB+dfpXOcdPsekaXa21vNbXkGsawrSJEt7BPbRrDE44YgZOc+vBPtXpN1D 4hlsXimEkUO/zLKOW3aFpUwM7iex68UWNouxQE+mNfpcapaxyPbpHCs1q3lcIAvI24z1ye5q7aCe O9kggknuEwJLODaBkMTj+XrQDTuQ/a7u7iRLizaykaRt0TcMCD1P5Hp61v2Tz+WLSBncXRwzLyHI GelBLV9D/9T+OS705hK9vezvJBMwMQzt2FTnk9euKpvpm+4E0Ugla1J2qx+WbsMqetc5x+z8x2lx 3mzO5ba1t5XkeGRjhnGSUX6n8Ku2V9dXsShbGaKWK5ad5UO9UQEBenOc/wA6BcjvYoxi5lW/Nqsw SWQpLGw2lgvUgehrPktZIXW7lhSBUAVQcK5yOMD34zWkOxm0noyrawtPJfPNEGWeIRwygbXRgc// AFvxqPZcfbE84uIUyHJGQcKQP1FaCUYo/9X+NZ/EWm2djbpLpMl685+xxQ2ERW7nJLHLeu3nk9vW ueuNJc3llc2wEZLmFZm/c+QpxlVY8HtkU47o4VG6ub39n2ttY3dwZWku7K4CBIWD7wQcknPQf1FQ x2cL2sBe6hZZ3Z3ii+9Bz/Gvqc/pW41C6OfuE8h5izs0QwIpP4V5A5NWXcJhIpH8xo13nqpHsaBq DTGvO1kkUKnJmImYleB2601Vmkuluhh8jEpc4DAVpAptWZ//1v4vbyR5IiyKiPImyIuvAwev86xV uBHfxWazOZeDvkQ7SP4sfrXoHnnRXOm2Fr5ZtLoTi5j3TCVAFt5G+8Oc9DzXESxiC5eLf5kSNvEg OBx2FHkBcY3N5Esdu8wMjBFGN+0Z7juOP1qK4t8IYWmclT8qAZ3Y/wA9KabjsBNZQGS2kQ5kmHRJ F2AelTS6fGIYm3zi7ZjllTMRH90kU3Jsxl8TP//X/ihW1uPImfS2jl8pR9oR3CMgJwSq9SfYVq2d 4sdtmSLfb71juDgI276kcHrXqqatqeOY+qS239oNFbTSNCFDKHXDAHnGemR3xTLGKyZD50jyP5pL QONmR2Kt/npWqk0TJ2QsVrb3d45MnlWkRMbow3HA9PWs6+ggfFtaO8ttE5kVpV2S5+n6VSn3KOdk QxnkFcNzjg10UMYMGICYzJguq8bsdMVomnsNNrY//9D+H5ob+1MjOd3mHOep+hqxYPcyF40yqAgO XX5VPqK97mtLlPIu9gu4l+07ssI8AE9OR14pywfarWRLVGO2QAgHlzx/OrTaegjLhlNv5kIDBmO0 kLucdjRd2lzZyCKciNnVZFJGSVYZB/EGqU31KUJMis9R+xyMIAHZsozsuQQeDTrie4ZyjsNjjIMf QDrWid1cTTW5/9H+Gr/SgUa0cB0IYM6BsY69fxreN02oIFby0lVtwCKEGe/HSvqbvY8mMbsqhhBK 0fmEj7zgjaF9qxsmWYuXPlk8Y6/SkbGhLOLVYRGitI5xuIy+Peh4zcuqx53O3RfvU+Z9xWs7kjTs tz9jWbYyx5Y9h+P4VmtIzFjuZ2A5U9T+FUpvqM//0v4bbGdbZxcJHjGS+eQ/4flTv7QkmBDHaZHO 0BcbRX16knsefboSBGjb5lLlxndgjb61nuy+aEVN5ZsSHGAR2rXn0MZKzsaFkIE80MuWRer4x9BW dPAz3EqoQx4zhgUGR69P/wBVVGSaJtYjSKRFjLAOnmbSqtyB3NPDNbyKYVZAp+Vz3/GqA//T/hfe 4f7QkZyd/wDq9vOfXNPlhLvsyQznPPAGK+4PHFKhAAG+ZDt2njNVXQElIyyA/e5yDQA2cwsEiRdp xtY9c+9RMqxRiILn5smRR85HpTbb3AYkU5mfZuKMABu4zV37P5eAWAIG4A80JuL0IkrtI//U/hZj nmeMoUIwep+6cVHDFI7syMBjkkH+VfoC1R49raI0VIZSyKc9D71UlZrIl93meYcsD2pPZis7ksgQ xrJDNgSAFo8/KfX8agjT51ChWDZ5I6YrFO2wyKfIV9hyucEr3qJARCCO/Ck9a1i7oD//1f4arJoz CpnBkVSQWXhs9qp3KlpIzA3LH7oOCMV+gHjkUlzOFEajAU8sRyx+tNRA43M3lnocDANAERiaFg23 PP3s5qrJM53KGJ5zx7UAWofMdCrKAT90ntQHEDFZDnHO4dKAP//W/hhnu/PSNZBhEjCLtHXA61U8 kNKFIVEwCWPXFfdSVmeQrdSK4P2dvLQq6uMpgZHsRUW+R0VXUAoOCBtx9akJWT0GRs7b33GSU8bm yTT1jeCQNjc7j7x6Cmm1sIvi3YRvPM6ZC5Cjlj6U6FDvDhd2E6EfdpAf/9f+FGW43sVVuVbGD2qR vmaNichRhtg7+9feQfRnjjJpg+CHwEOwjoTirMd88qhGVVjjOAR1b61oA2S6WW5Fur7EVNxk2559 KnDoilWDb1+7IvAJqJNq1gIXSWQbjGxZum3mrNuY22FzkJwyHgk1a8wP/9D+G2/u0aNETchXkHHJ 9qx2l+XAJ9WJr76SbjY8ckSBZMNvKFjwRwF+tWLhPKeMSR7lZfkfpgisbW0AuLcqIRl2O0YZj1NV YJm2OsL7Y2cGRcZzitYKyuBZWWNZ12nfjn7uM1ZJRQ7b1DP0BGc59KsD/9H+Gp0LkR4HmsNyAcZF VmbyoioLD59rA/LtI9a/QDxxpibJXzNysOcYwfpUX2cRttRjyec9vatIPoYzXvE6yCMDa6AocEE/ ep5u4iwYFhIflKDgHPBqnJJ2JFhk2ysrABCM+4NJPbxSOx3urgfKRxn6+1Tz6m6d1c//0v4Zre3S 2QNLkkHIA5Bq691FtKkBUcfKV4xX6QeOZTrIxAjJYYwCaldhDbiJGIkc5dyOT7CgDb0u8ijtZPtY L4jMcDDGQ3bNZ8rfaJtuFC4zvXqRQJ7FmKCOIfNhsjC5NV1PkM6uiuxPA/hAprR3MD//0/4gJ76N PLSFEi3qASPmJ7VEzsECqwbPX2r9P5la58+VFijyIix3Z3HFOfcxCxYULyfU4ourXLjLl0InkKkb vvnHbg1fk1ln8qA52wpjBGdufSmS3rcIo41Q3E/mYcZHy5wOmRUkcgHmM8jeWE2qR0WhCP/U/hrN vgm4VmcbuFx8xrX01pFZZWYoqc+X1Ymv1A8RTVtTXuTEY2aYiSOU8BhyD7ViTsEJFuTgL9w/dzWU 9xuVldGQkc7y7mYgjI2qcfhWilysPyOreYOAD0ojC6uNO6uWJtSa65ZRvUBN/wDEwAxz/ntSGdZE RIxwn3SRwD3/AJVU1aKBuyP/1f4fpLlZisTfKVABY96vJZyyMkalGO3KrkAtiv0g8NO6sytJEiM6 zN5TkcZ6e38qo7wmQn+sBILCg0HshRRIJG2suGcoflPpS2+oRhHhkXdIP+Wh7ir5vd5TGXxFV7hx JuXAQ8dM5+lPhVVkd35LD5RUeRdNaH//1v4d4rySDzApba/ykDjdzTxfzKWG5mJXaEPIr9IPHJfN l2klmG4Y2rz1pPsQ2HktLjcATj8qAGlzaxBC5BmIDxr82MdM1Uu5pAEWNcbhhtw5FAESKqBNjfNz vBFNS5k8xQ25wH5Cj5hQB//X/hvmuQ8nlyZcZyMjGKqquJGZOWzkZHFfpB46SWxdnmdiI1A2DGSO xqNC6FkXOTyAaAaT0Y+W2JMcrsEYHPHLfXFTXkjkoAcrGvJb+VBlJW2KzSrsR4yHLNll6FcVZuvM mCSDbhl+bYepoIP/0P4ZFhmjYk4ODnae3SrKl3hYjlVbeR6Gv0g+fI44nlZpElMTYyQBjPSrMxjC xRoxMjKPMLDjPTNTL4QIre7a3MkcEYdypXeMkD/OKgdJ2XeysXdsO5HCViAyCN1barsdxwSOARmu hklhhtzECm4rtI6jNAH/0f4arcMHkySFPXHXFaMEcYLO24qTtVemMV+gHhJz2G4UMAWKb2xtUck9 KurBGEGGdjGMO2fm57UCfNzeZkTx+QTNACGU7c9CM1FJPdhU37k7nA4b60Gy8ya3uZpZDEQNu3Ib OcnpipGgdWZmZd3VfUUCclHc/9L+G+WOQqGmYFT9wg8H8KrRRPI5diMjhQOhFffvY8cslF3hi3ks nAwOG7c0sM0SzEStlCD82OAawtbQBWaVGcxsSDwcLjIrQO2GOMKCCyBm46UE83vcpVnuAXQAKfm5 3jkmnxv50ksc27eBjOMY9P6UA5cp/9P+HvIVVVwnDYG7v9aNyPv8iJfMx8wX+lfYvdnic6sU2jkU 5cElhz7UiyPh4VBOcBcjJ/CpbtuCmupLCrQFVw0hdsMB0THXNXbud3MbrkfL5Y3DG4A1Mo31LGmO 5uIlwpSOPKGPHJz3xVKaxltyodsBj8mOR+NNRSA//9T+HJPtC7FZzhGyAOlavk/a8SJsiQAIy9cE AAk/WvsDx9iOa3ht8qS3nOMRADg46k/pVdIrkYbeQV6HPQUDbbdzZ+2xtaASOcx/ISTgvVZGS5Qq oG4D5zjoO3NAhv2aZCDEhbjGWIBqrLZB3cB9kgxy/Ct7frUTWlwP/9X+Hi3kktn8uTO1X7ciory7 kebaA5UkqvHAr6g8cLWGecOixEurYbjJUeuK1IVuLSKSCSJJEcBvMx+8IGenp/8AWoAptG4y0ZYI /UPxs9qjt5JIZkUMS24D0GPWgDUuxKq7Wl3jILArgLnuD3rMCskpiQs0jDCkDtQB/9b+H02bKyGT LujDKlflf6Grt35aPbqT8yjJVTwM9v0r6KSszxwDXCumyVkTdgqfuYPHNPaKMLtUKVzkt2PrVxgr agVJrYnmN1YZwijr6c/lVJ0chkbfHKhBJA4PtRKKtoBctxvdNxG1BkjOBxUrTOqys3JziNgMEVnZ 2uB//9f+ICZpLeEKsjJLOMmRTu2kYqvbNdKjTvJt8pt2OhfPFfQHi2941YL+XkS7QhGUwMMCfWoz GirvZGfe2Q2PlFBRCkQSF495wXzvY/MP84p0YECecQ+N2xW25/EUAXgrbBCZllO7iVmzwayZEijm YZwVf58c/jQB/9D+IiWZXi/c3G0hgBG/3n+n0qKYja2xi7BMbmGAp9q+oPHFt3mtttzBI3nKuMqc lK0hqLSxKJyJDnPlEY3momtAEmMagu+VbbuKDkrVNpord18rdIoOdrJ+WayG7X0KL7M8McO33umw 1W8iaIyMwBQN1Y5/GgR//9H+HaO2kcLPFIu1Tht3A+gqOV2ClZAqkHh1XLn2r6A8cIrkZSGRWO4Y weg/w/8Ar1WBZX4+Vg3y9ulAFxTMu0oCCx/e55/Gr4itxbtIVJdM7kB+/wDWgLFaKO0IaTLw5x5c anKr9frVuO3spCTKG3dORwfejY2jFrc//9L+ISW1+zJM/mZVuE2fxDsPrVGdAyoRGVCR4YjqPevo DzyG1VgcFsqB8zf41eX55Mkb0QAbWPLgUDSK7lVkZCsgTrgj5R9DWfKY+RFu3Icgt0NAiSD7SVkk WMMVHzcfNj2FW7Bo7eZJJ7V5I5WIYKdpB9aAP//T/hy1CLzWcR7hFne2Oi54zWUtud/lOx+QblHp nv8A59a+kjD+Y87lXYv/AGiL5LYksMZLYyFNKgnQsd2Ufhc8HirSUdEOxAfMjYuh3kNyB0X1qZzu j86U5L/Kqrzt9zTAqvDDExlSQFim0Kev5flVaO3YnfLlox02n7tAH//U/hqFpH9lM0Z3gHG1h3rM VXLj92NgOSBwTj0r6Sa6nnltpRAEliaTzS2TGRggehpYxFM73BLrKwwYg3AP0rMB0kyxfvC5SZlK FT0YdCDWYkclwMwn7rZI9BQBowQ4d47giQY4B4K/SmySAOYsMQBgY5Y/SgD/1f4a0vHmaOJnPkoQ qIwAb8qqXk4R5FJJ5wARzj3r6A8qa1KSxsxUxMy4+Yg/Ln6VatvtV5MLfy/OdTlExlv8aCDWmtXt 4eABOeD/ALHt9apyRyGNAhLSj5ix4Vaz5+4FryTNgyzKNowSWwtU7+Z2cww4eIAbdgySR1xQ59gP /9b+GJN0QRiGUkYINWLiVrhIllY/u/uE8EV7B5dNGe9ixBnIPlltv3vvH6VEvkxoeGzu24H9KTdk aFm1gdW3eU+77/TkCtFBLLMsmA20fd6YxWAEV9JLI24sFOOIwMgY9azXlCxRlFK3Jk2sQeGH0oA/ /9f+GeOWZ41V8OIzl1znP1NQRTrK7koYsttEa8hff8a9A88tktEd0iEsvMXYfWqbyylCzKCxbLEH 8aAM5LiW4mPVdrDjtxWzDJLD5kVu6MkpBLquOR6GgB8ltMxU4Mm4fNxwvvmrLzQ29mkSEqZF2y7e Gc/Wqh8Qm7K7P//Q/hftJjll4XDYGe/4VrGfKxx+Y2UBHynB+hr2DyoN3sZc1xctIyKzqD8rKGPI 6c1Yhto4GgKMztIMyrjG00mrtM1Lk1qiFpY8iXO4jPAH0p/kyFElzk4BMhG1z+FDV1YBZRCInU/M 7KOarOI5IeH3S42qpHI96iUeqA//0f4cUspLjYksh+RdyFeM49/wqxCY4y8ay/KRsOU2n34r0Dzz MvFDTnyFJJwh4wcdzV1rQrZ4RisjYUFl3Y96y5XzGc11JLbS4n5eTJxwFXLfWotiZ8iPJKnAkPet TMhnsb9FJkZ2iY/dDZxipYwGtxBsRSjeYuwD07mk2luB/9L+GSJ9srglsg7QoFW1geQO0nyjPBxx XerW0PKgtSpBEEmJunbYOAANwU9j9KsXsDGLMcY46up3eYD0/wA+9M1KvlXFugkBZElXYcHDMODj Hp0pjkSyoSNhVht3DFRJx2ZrBaXO10rS0ZDcyyJtiUSbWP8Ar+eVH0qHU4bXzEaAKGk+8o4b8KyL P//T/iFgskSKSQttIXq46GsZ5JrsC1hQBQSZMDDP04NdBwyab0LMySW0BDOEURglAAOnOP0rGRzc P5ib1iB+bPy5x2oIbSdi/KBGiIxSQsQwxyAOw+tSW8suJvkUR7djY6D3oGV5riNWMSjLMOnVT9an tZhuCNwu3Ddhn2oA/9T+H1iXgG0/IrYZMYY1sW6wRqZHJ2bflVBndXQcdNFS+uziPep8hDmNWx8m KxEvWvJkZYyw8zYNvQj1FBvBamq0UdvnDgSDDDLc8+lZUzTTynYkxcNhTtPPpmguVluOeKdImdo2 EiDLDr+NXLKWGXBkLRz+V8qBOXIxnn865zE//9X+HeVDeEIsh8xTswRgD6mtTTdKMMMkN9IJkSXz ImbjySeML60HOTam1pFP5Vohbyo1LTEbUZiOcD9KgRkk2rtYyAZYjO0GgnmiRzwtFbtO0jKxk2Rx LyR7n/PasTEi3EbptdGIEmBz9RQWpaaGldeQLlFguEvrcbSwi3BX/vLyM5HINX7a23lYEAW2VvMR GO7aT2/DFBUZW0Z//9b+ITVrWXcJExNG5EeEO7aQeelV4IykWGixt+8P4uKCOdEsS+azrvyoj3Qs y7dhHY+tagY3Vsxd9tzA2yIYzGSOueeO1YyVmRJ3ZjrcXDxSBkCuDjYB1+lVU1O6s5VEefLC5lTk DNSSaC6pFf2awNAsV3LNh8OXAGfl2/WpJlltWIYl4hGAqRr85470Af/X/iAMU00L5if7OPnIYbX4 6VksUiOSCvy7T9PQj8K5jnKKZBVtuU/hx901pwSSQhZ0QbS3lkdF96YFre210zuEmSFHauY1OVUQ KqYkztXBx+dRPYDm5GdDlwOOCp5rX8PvIb+JHIEOSdrcD8Kwl8LN47H/0P4nbBQktw8e+RBGC2xc lQD3/E0y9kdMyLP5rFfMeJT+9I/yK8cDRsJLydYbltoh5X7OThj0wSK6JiiQNdPu8yM5IxhSMetB MopmZesvlK8buFlw4cjjnnFUhCrIyefgsu1dw4JPYVEuYxJ7WxvobiCZb27OLcwLDv2wFTkHA/P9 avtNLApiViowd5zywODis3vqTyxP/9H+LK30y51C7F4tyscUJBaEx/M4HBGf1rqLjWodJMdtbRbx JLvkkaMCaQBeRjOPT8q+fOcuW0st4rTxmKNWOdocAc9qq/2nbyyeS9pObi2mMU3G+Irx0xzz1rkq b6jWjGaabOzurmewju7e3lH+p81hCHzlm2HoT6+1egWV04ms3mkES/eMTIHVyM4yfT2rF7Muo0o3 O701p7i4t2ZxG91Li1eGMLAmSNquo/hY4U/Wv7tv+CNegjRfgp4e0bT4IbCxnm/tQyJbs1tcSOq+ Z5bnggN6dOnbFfk/iLVSpYeg/tT/ACRm5/7TSX9dD//S/sCtYWt7ZYSE5H39o3/n+FWLferkkAKe MjrxX8nJWVj00vhJGkCMQxZwfuj1qvtIy+1lGcgdxWig0y+RDp5C0Y2vtUjqeKWO1Xytyclh1PT/ ADxWo7K9yEqqSIXHP3T7gUkkJctKP3aKeB0zVRXvIZ//0/3dRv8ASEuFbnOTGVyMYxWpIbSQF3ni iCJnzWU4B9MAe9fyPUherqZ35Uin5cqBfsl+i3MkZfMUZO9cHjkd+OmaoLcPbwwxTlpZlT94/wB0 AjqahQtK6LTTdkcP41ktbvQ9XtbK5P2mXSroqJz5W1liZlGc4O7BFfxpf8FJIZbb4ieJp7C1sLO0 n0+zixbRh1SfaqO7Y/voWyf7zGvrOEUvr8rnmY6N8RS+Z+U0On2jWBmkuFsrl0329xH8rx4+5uJ6 D/GvPprezu7lWvIZJ760naSGWadgHXodrDswz1r9ipbJE1Vof//U/jLu1EboIbbybaSXzI0M5udp /iG4/XvV2xmWwkXT7bRLa+hulzvaVrSPTQfvMm0gE852kHJr5c8SnsabQ2ml7nktzKzQlYMku/PG 73xWfb3zTzXCaZP5NzZwb5lb5X2twQD6EEjj1roNYvlYtoNly0lq8treocI4k2zBiOXQ/XOKvx2T QwRxfa7mUrkyCWTzN7McszH1oOiErFZ7J7NHug8c0ZcbbYfKyEdWPsePyqJpLnUJ4ntdNNtGzm3i Dy/PO4HP81/MUGyfVH//1f46P7Nkji03UmsLTUvOme3uIEu/JnVlIBUEcg8ng4zx1rOsJ5oRd2ep Wf2e2W6KyOJit3GoJGM/5Ir58xbb3GiWyv5JbO08yWGE8ren5HUn1z27802+0/TZFiitro6TZxyB 7j7NCsocD7wAOcd+aCfI6ua9t7+1sl026RLO1tDGsMI2HKcFmHYsQfzrC/t3T47TUbCVJcw2nmvJ FCfOR2ztXPcHuPetIdRNI8D1Kyh07SobpEl/s+/v5Y7djGSFZQCyZx/tCuXUEkLGEKE854Kiu6k2 9TFqzP/W/hZsnLBooyFROZH249ajt7jZex7SQyyZ3AZUYrnOOCe56no8TzBZjJvZ5gBDuC7mU5Ul e4FevR3WqNDZSa1ffa98zW8StdCRo1wCM8/KOQPwoNoq5h3NlAt59piaExB9s0TgFWGeqn14rYt7 qAOY4R+9i+aMgY6e9GxtYyNU+2zOk3kSTyTThZGXpH7n8quQlbSSK4kuWt1gXMcUQ3vnGDgDnJqH O2iJcUz/1/46Jkvpr5pPKSVUt2dlmbypUUfNkevGeDTnNlL9nLrLFKjZBjJ2sfcDrXJzqxm4JLcw G1uK6SWO1imdoNRazurd08lxs/jHqGzwfarFrcCFJb1ppreG15a3X5iRnJJ459KOdWMx2sX95ZXY m00+crqJJBIAhZZF5Vc8ZBPU+lNujdIHhurVokURyCR2GXLLk4HbqPzqk7q5g9xsdxbY3ISCnyBD xj8Kluf9DjEs+R5hAX5fM25PsOlVdrQR/9D+NeKezeQXlpFEl5axbRcJ0TP90f3uO3tWTJb/AGt0 jaV2Tf5gRjkK2fvKPwH5UHHFXjZFa9nWyU2hdFlnbKpGDubHUsffFbGiquoQ3P2j7NbG3XfEYwI3 dVAyvPUnFVzMuOyM67Aa2eKCE+ROcOLhdjAA9Sp57VkW58sWqsRPmYo4UfOqj+HPYVrfWwzRmtxc ysnkGOFfuyGT51Geg9auCS1O1lHli2HksF5VgPUZ68ZNVF2ZnNrZH//R/i2ucvGJsYHmCOEqMjd1 wR2/+tUVyqRWkt3LbjzYlEMjKf3sQJAztzzzXdJ2R55VTS7q2Fo95HdKu0TIsrkCVW5BbnOCKpap CsoP2eJVC9CAdv0zWcZNPUDU0TTWvYZ2ZxDHbQ+dOxkEexQQM5PuQB9aa4sobaZI5TdLKd0cpwZI yDwQR/nmtU09hJ62LujywJI7eX5zSQ7Vdznae5xQ180DvYQLBFH5LGKaVhGiN02jPA7857UyJrqf /9L+J7T/ALLbKXjvZ4rxpi77IwQQTn72f6cVbZolgvndvNyPtDq7fNKQRjA9ef0NegeOYWYLx0My vELc7o3jPzfQ0ki/aEDRu0fkk5wuS2f/ANVawd1YTVwtisSIwldZOmGXB69ar3T8PIpZnPCMP1zV jKKWElw+6d5olUB2KjO4e/5UR3Zhmt5DG77JP3QZSoU9MkVcN7Aj/9P+JK71pPsTQSxQSSH5hNGM SRexP9KxodVuUkgIRTEp+YbSC/417dvfsedZFm6gnvWmmhVh5ShzJn5FB4w358VPpNtdPE/lzeX5 fA2SAMxz2GecVqZKPvWYkXlafJcyMDdTkYDzDGzPU8VTMBux5zucOdgLclcdOKDYzVtZBM8KLlA2 POUbh1rVSJPJKyOAImMceRzk1ulZWJlG5//U/h1XznVoQmAhOSnVh61WiEtm/mrMPM3/ACxlcnHc 19QeZBNXuVZJmlklw25y2G3HoaR1kLeVbvGJIcNJnlBQa/Y+Y8XfmXCLNEXfIjG0YGOmf61rz2og JEcoyD8joc4oM27SsV2hkjSJQNznrJ1L1Zg0zMykElxGdyrwCD1JoKP/1f4fxpPkybJ5AYXXcqoc SfSqY08B3JmKqvKuq7guK+oPPDduGBMSIRxn5c/WqSXJeeNHjCuzeWDngfjWvPpcxk7ssXVu0ERc yBg7bDg8qfTFUrW3uCkzIxYSIVAxj8qqMr6oJbJEYV4ztJPyjLCmPJ5i/dcHOFbHyj3q1Nok/9b+ F9baRdmGBkJG0/3fcms+Wa7gu5YHk3NC5UlG8xeP7pHBB9RX2qmup45bneaZEbbiXHJ6fjUSebEu 3H3v4jyata7AQK7SyZfjDbSAMHHfiplVtyou5vmwCe47UAaBk8kbMjI6n0qqHMszFvv4wPYUAf/X /hVmuSmYlxyNvTpUkStDHkn3z3/GvulJrQ8cWWaUJ5gBAxhtv3RVETNcAr99iQq57UOTe4BGohlC Sgsv930qfLxAqi5XP3qkAhaUS7U6HgDtV6RHaNSwU4JJPQDGeKa0dwP/0P4W/NdE+RY/KY4ZQcMP cUy3y8ofaUEXLu3Ax7fnX3kZNvU8csOkbuCPnUHOF5zTWhnV9ki4DYKqemO1UpK9gIZFkhZkYlUY 4YkZH4VSmj2Sp5KM6Z5IHJ9xVAajWjtFHLGDuI+ZTxUE6p5IZ9qyevf6UAf/0f4Uo2cmIbR5a9S3 cUrqzSbTk9hg9B619+1dWPHHm0RMFmzt5UdSKjcyB8pB5qgfMoHGPesbO/KAfu5ZgY4/JBxlV4QG ttktBbzLFC0l2yqqPI+IYvU49eKuUUloBiKh+dXz5mcFt2cVcikBGBn92MB/72O1Zgf/0v4VmhTz PM2KrSHt+tR7fKZ1iY7Q2455r7uC948cYU84ErGSw5PHGPWpWCoqiKPBI+YZJGa1AaVXCMF2y9Gx UxLrEB/Fn8RQAS3DPGBC0yyp12nGfyrKS4aN+SeuTmgPI//T/hhNxFJGrEbzjH+7SWsQui4BRdpy QxxwK/QDyE7O4B0WSRQQy5GTjH5Vddd0ZMjb0XBweq9qya9+wi1FYRyWjzRyKUB6A7snvWdBHhmw D97aqqvStQL8tvHDHuOAx5A9azNzOxLYG4hEyeh/+vQB/9T+HW1dJJm+1bkkt4giIBydvFVborOX 84bcfcVf4u1foB419bEULQAooUl0GFO6kniwGbdhepHc/Sglq8rFGMxI4dk3pu2gOOOa1jYROqGL YXPzAg8igzaadmUlIhmKz4+RuvXpWqwiMbSYRmxuQ7sFh6YprR6myVkf/9X+Gpp2iHmSIApX5Qw4 xVGG3adg0h2RsSc9q/SDxzUSIpHtxuZR+7PTNQTRyFCZUPC4UbcKfcUAU4VmZMFSIS23cegNXool 2GMsdycrxnIoE1pYtPIqIsUsPzAh0k7gdKqt87yyCQiMLt+YYH4UGB//1v4bBcqmwCMEgYLelWpZ ITCcIQ8g5Y8EV+kHz5QjLgYD7tvVu4FXo42nUrGC2OZGwflHqad9LFwjfchlVFzCxDFPukDNUkDl m3KMdvl5NbicWpWNeLPkFtxGONrc5HoKI3ZMqpAjcfMD0qU1YFCTP//X/h589UV3VVbYePf6VU+3 NHh1yHdsggZUV+mKV5eR4qikrCte3E23zjvXOegGPpVgLK43bcqep9BUy+JkzWwtsmJNgXaqNuZj 1PsKmuY4rmQtGrq2Ap3YBP8AnFUr8gKSUSoEitsqwLEDG08U75o7YyBScn7qjJApWk0Q3d3P/9D+ G+3We48xAuw8Nkr2FaypLCI3RtzDgDPIH+TX6S01ueFDexQuXaR2MpKv257VFbwtNI+04dVyD0DY pGo+aaV08tc7k4bI4FYb73uPKIONuWbGA1BjNe8ascbbjjYyiP5FIxirSRQqm9iwlQZx/Cx9DQVB 9D//0f4bzMcHAXd0Ix0pvzbNxOXyMEDkCv0g8cnjuPLb5zhgOF61GLqaYsU3Fo8t7nFACb5AA4HU 4YHqKsrCHV5HJdlTdGqjOfrQATSxtHFiNQwHJPrisgTx+c0iEhVOGIHFAH//0v4bpIU2rJ1V1BDD qarSOh/1e4MuBt9a/SDxyVQYdr5+f7x7/nU6t5xLr68Y9aAJ5drNt3M82B+FZ0jukjGR9yAj5COn HSgzn2I4181pCuFUn5FUYwP8irKziABQuADhjnIPagzP/9P+G+QrKDtXhjzzin7V2oAg8uPogOK/ SD58sRMrRymJAsZXa2Rkj8azWjMMqsp4IJYEbgf8/wBKym9bABmWGIpGuJWORgZzVUPckFfMdi33 oyxwKgCwiyW+2SM7hjBUjvVqNWO2Xy9wY48ojcATUc+tkOO6P//U/hyLLGSjHDofmzwD7Vet7rdA d6RFlbC7ujjP86/QDxyMSxM7btgdRke30qCGeS3kMr8xscvHnlsZxQKyvclNwLrKlVUMchV/hrMe dizQEEgNtAYYNAxx8+CVYlgKjGQfqOuauhgUJZeT8uRzmgzn0P/V/huaNgFWT5QW4zzgVZRU3Lt6 K2Aw/iHrX6BseMh1zF5kiGMIzv8ALgMFAPSqVtbymeZNsRWAkFt2Q2P7tYN3dwbsi5JDcRv5qsdj qBtUfKB6H8ql8yXazPtdVG1kwMrnikZr4yJLdd6s4JJ+YdgKW6wzsQ5Mp+XK8Y9qV1sVKNz/1v4b I7eTnzC5KOAwOSVz0qwhjtGbce+Qw6mvsXqzwVF2uXYVV4ZXfe2RuTaMsves6GaRJXlVQpC42sOR 9fyrKfYk0ba5imnVpoShK7W28ZI6mr2oQp5SOg/dLz6Ov4VbaSubpaFV9QGERScooJfGKd9qS/aC 3LhWR9wyAqk9OtMZ/9f+Hu6jZLwxnorAMV+7+FbEMCyNFbxybQTnA434Hc/h3r7A8czb+FmdWWb5 o3KBFPzIB3/z6UltdSrcMuCVI2yJjt3NAFdoTJK8cW6SKM+Y7YOUHvW3piBp5hEgYCLa247QOev8 6AG6jeCBhDE4Z2XLKP4fTFY26SVcPncW49RUy+FlwWtz/9D+IWKIPHIszBUyCp6MSKbYKjmZ5CAE fYvfI7GvqDzmk1YdEZPPmMe6N1PysPl3itOCaCaEiYMZkJG/PT6ignkREZYEBXbxjnPJNUJvLiRp tpVOqMere1Bla2hPHM0kT+a/7zaDGMcD2qWKP92fLdRkbp+PnUjsDQB//9H+IqW6neSNYMqsI2DI HJ9arywEOG3mWY4JCjOa+mlHmPHNedUTyC6hEMQDRDLsWA6k+/5VmTSh4wY1ARZCCKoCSBgkTNtU upzxnJH0qvIEuFJVpFIOdjjBpPZgRFP3sICOqbdrHtnmrMkUmVycqDlkIwMCs/sWA//S/iKDpJG6 SDam/wDdFh97jkD/AD3pJfKERwFRgMKqrw3ua+gPHIIbbzSUVt7KNxIGFHtVuElpfL2ny0HzMzfJ 9AKALMmnxf68OduduM/dPXkVTgmaQT26gssTnGfuLzycfhQA25u44sKVDHAwU5FTQ28aq1w6/vpC DGm3dQB//9P+Hu7MYVvJUCdWD/7K47VpQyi6EZlCorxn7qgKSvGK+oPHK5ZLcbldgjscH3HbH5Un l3NyyXRw2OUCDAXb7fhSaurAa0EMl0yXEgJAPzqRtyB1H86m1W8sJNnkQrDJCuGCjqB0H+fWsAOX a5jNy0jxiONiNqL936/1pXkZzIHGEDZA/hx2oA//1P4hkRJLY7cx55BQcD3xTrK0jlDrIfMEfIdx tPf8q+gPHHvb2cZYsMsOUZfmDY7VmXFukoSZfklR8tAByQOhzQBJHDdSoWDDaCMAnBqCVZ8OEIJy AwHQ4pN2RdPctQqFQJLGFZ0IBxu2mqqif7REkgkaIHbhf89KiT0Rqf/V/iAknAbyMtgHAVhUd5CY 4t5fCyccdR/n+le9F3R55jRGQK0MbttkOCWHpWhb/uZg88wwBtbnGMd/0qik7Jo1ZTBcpGkJAGMb 24JNZTiO0dWn2lQcMuM5H0oJLs0RhZHXKrjcqkYBBqUM2FIUAA5A7itYJWFdLQ//1v4eLqfyS6xK x8zBfI+97fQVj3gMkolh+VWUK65zz3r6g8znS0H26mJguQSw+Y9cCtGeQR4GdyJgjPGO1AOaKzDZ IWjA2t1PbmpxCXilGMFBk46fhVRaW5Sd1coPEuUYcheGXoTU0X78hIP3S/xhuNpHYj/CpGf/1/4a VviNyJHtEJ2upBAzVcyEB2RRG27cOc5r6Sb6HnkalrjDN95TnPTNSxkIJXIIKDnvWYFKRVnPzPj+ dX7SNIEDqSDnGfWgAuJgp8x8HJ+XHDDFRWTC4nZmViAuBg7dlBPN73Kf/9D+GB8W8qso3FTyccfW q08heYzsPMeTk+9fQHlT3HCf5jztPvztq2fMhvLaazWTcwD7lPKt3pNaWIJ9/wAxSRn3byXDZznv TFmBJGCADgMB0rABkjRO7xCQyIBncOAavabG6yA4Qq6/JuPJx1A/KgD/0f4hvs9i8jvNJIqAb5EU fMMdQPrXNm/t5i3mQMoDlY+/y54Br03KR5lPawjyF0C5YxLzHmohF5hHlKWZecEUpO7LLEl1dp5i wSOm5PLdQNu4f3TT7GdohN5uPOBG9SdpH0qQGSyRliwO5QfmJ96aYkkjYqo4IHuKAP/S/hktrZnW WNA3TfI3TdjjmqzRyi5VVwCw2sDwP88V6B55r3AM8KEja0A2DHO7jBrMjKW+93+Y5+6elAE0bWrI XhiVX35Py4JpYzGkh3sURRvJUdPYUBsXJL2SQxRxptA4bb96Ssu7LZMcEZIB7jkH2rSEerMXJvQ/ /9P+GOO3WCJpLhcP2GckUhYDmIPuK7mJHFeso2bPHCKfHzsApPy4xUtwZYyrRtguOflzg1RunceP tCRCViWkI6HnFW4zc3Mse5whVASB3x2NAx7yWyKZM/OG8tlxkHHeqTbWG+Nj5pGQQOKiUraGkY3W p//U/h4guyYpZMY8tdqDHylunP6VlBpSzlgWYnJ2jha9A43G0RxCwguWfzD1Y1aF4BCqyS79pyuO M59fpQjGSui5bXlvCPMkd1IHQDg1VmvbfzM20JKk8tnjOfSpm7LQxL02rRzbYkVVKqN2ASPTmq8t 3DZmQBY389A4wdxT6ViB/9X+G6O4i2gpDvneTJYjGwe1bsVruHmNKGhVhtTGGfPX6YxXUpNKx5cO oksFu4dFR2YHqqis9oZY8CJHMan5w5wFo5mlY0IZ5dqsXC714B64HsKiMaT2bzFSDuxgcEfSpN4q ysSR6ibdCEkcssW2ONxwhxz+daUEf2uCEhljvGPDMRsGfumgZ//W/iIazv44Ea5kQugw+1xtc98K PpVjTpNJty82XmYL++Xb5bDthSff+VdBwNWdjDumaaWT5tyvnyyRwB6GqL4iU+UV2gEMpH3SOtBn KN2M09pbiaKIoCZHCJuIH61uT2os/PIXapHlzEHoelActpXMddPeZhJG/Cqco3329CP896spD5Ji Mi7Sw5U8/iaCz//X/iFjs3m3NvypG44HFVVZY5CfNdEi6IePM7V0HHT6iySGeMG4xtJIGBnAqURL BbqkSoGEmfMHDYPag2g7SKpgL3EayuGUEMCOdpHrXVWr2sQcS/NHGAQwXBb1/GgJO7C71CxkXbEr Km4ruKhWwPWufgntjMHEbNtYhXHAXPGTWTju0ZSdmkf/0P4gpRbRGeaGQSMV3GNPmY89q0NLvWvL meC7wti8A2ptHmK4zgg+h70HJNtKwXDwTSFYXD4O1mPQY9Ky8yQzDypShVvmKgMDjpQZFm4u4ZI3 WWZ0kPL/AC5LnPf0qra26kiQI7h2PlYXhwKFoUpNKww2T2YLgJHOZSwjXgKp747f/XroLNFmtXyV ilTG1wcAnvmgcZW3P//R/iAcvDOIZGaPzHOFXnA7kelXb5ILOyklNzI5TmMFPnb689qDmTuyLw7e 2E8+NSjnktWRgXtmEcsZwcEZ469q0rMRAPGEATdjLcB/cmomtBlLUQYp5irIHVdgZCCvHHBrLKyb LhLpIwgCtFIpzKxI6EenSsgKEPkWM0VwkvmzsCWRk2pD2HPqetdBJqUU0UcsShH8wRtJnIPvTUW9 gsf/0v4kpb1IjHCBuVo8sc9c1ialbSCATJAFSQnbzgsOmRXOc5j2i+ZbpIfMhQTMjxunTb3HPQ/0 p4lkYnZkw7unQHH/AOqgBTdyQvLPEY9uzY4IztBx09+OKwtQkguAswZl2D5lI64qZr3R9DKEYlUk n5Rzk96vadB5tyC0jIifMCq5JI7Vzy+FmkZK1j//0/4k7C7ktYw0YkYmPYVHy+aDjg1sG0SRfP8A LAbOWXGOPevHAkZlREKtho33BegxXQW129zYpbrarLFLKVuWbbhVA+8pPOOBwPegiUraIW4NpcRA SQ/Jbr5SRofIEpAwvP5c1R0yCRA9wIwTGcwhlEi9+x4496DFuyBGmjvd3mGAKmV3DfHKc/dA5wce uBzU0liZH8/ewDEB8qcCsp2uNan/1P40oblYWkhG0mM7dyHK5HHBrLa+t5tRt4nthcJ522Vmcr8u eg75NfPnObcMcFhmCaORo7iTChI2fyiTxuI6fU1ftbUWkz20UEjyTOG891wR7VyVXd3At3lnFHby BxgSqRKn3WX1PtUdhqKRMtlcxxXdrbKpinExeaNe6t7fU1i9mVL3oWPoTwtb/wBq6/4Wx5tslzf2 bW9pbQZt5FidCm7IONxUBsnnJ/D/AEHP+CXXhaTRfgd4V09MRWek2TS28Ycku0kpaRefRxJ04+av yPxCSnXwdP8Avt/gY04uWNh5X/Q//9X+wKNy2zJJG3jtjFSvIzfIpB2ds/Niv5WUUj1orREeSJec 4Azk9KtBi6jLcBsYx1plFW4Xd8qrn1GO1XRlbYIhA2r+VFgKKiQruPRDwTRK8rKAAAp9a0pxu7gf /9b967GIIDKERsod6scjBBxiqKW7ztIkY84rljGpG4Aen6V/JrX7xsipG0UwiRIpR50r2u1T9nfy iwlOM7c9qqJ5jyPuUt5inDFeAKSjZfMUFZs5fWtJtUtsXlqtxHeu1vvEhXyyykfiOR19a/ky/wCC nvhfT9I8YeLRFFmHUV+028sFkwtrRxkvEsvfZhAAe6H1r1+HqsqeaqKe/wDmiKlKNSak/sq5+IGt W0cWgGRnkuGKCG4uHUQsP9rAx6HpxXD3EZhayn+zq4ijAJJJ3Bufmr9ri/dVjkrpaI//1/40fsPm yuLedUgQmeWDJw7E8bfoSf1rctbm30WTTTc263cUsu+WNXw+3vXy54sFoT+IJLO8n8nSJBbLGm63 u2QtIhIBMSYBwQcDnj3rkZtJulM6JLFZTW1qJo5LjLNfsWACrjuM57dD+NKTWhb3sdDZwrdaaDut 21q3QRSeb+5RlP8AGp6kjnj6VhpPc2kU0jSAliAlu52hm57/AJVTnpobR2RuQwm3gae5ZJXkImeI Pwm7otRNBLqdxarYuyFZg4SNtjZzzzUqTRtT2P/Q/j4ufD1zDb3bIwSeLN1cGGZX8hs4LMQSAcjp XEfbPPWRJnYy+YQXfJ3nPOf/AK9fNqfc5y1YaSU+bdiHcSWGSTk5Oa1pLa0lt4LeOzOGmIuJd5ia RO5A9aIdQsRNcWOhzRWQ0u5ddRci2mtEJNu2Bl5+MbOMetJp8s99cajFFZQNbWqL9vmDAyZYkKrL jtjqfXpW8dExpXdjiPiOY2j2WULx2gt4z9lQAxxSgASMoz325JrxHzFhXBwMHBz1zXfR+EzqLXQ/ /9H+DiK4nZWRPM2u4Uqq8fWuhgsri1gGozxpticPEm4O82CPlK/49q572OdK2h6j4f1e11NrW7vY LaKa0maSGOJRCU3KQoOOwzivQopNO82RZomlM0IkjfcQkJ4ycdPUUm7K5rBaXGJbRPLFDCEEaSea obJB/r3rVsNNjMeoOLl47qFhNHC3AfkDahPY/wCNZSldlllHlktszE2ZaTyZY3IEqkZ+YD096yb7 S2ja3uba5eaS1lE8cr4xKVP3SPQ9KkD/0v48Z9bfWtUnt9QuYdLtpYMvciEuVfGNqgDPOB9KzNQn aDLWRF9HbEbZNhiEo77Qe9eeZSTTG6nq1vaQJNb6TFcXk/lxF3TbLBkjJwOT3+ntU1uscdqLmaJc 3TFjAzcYU4GR1FBBzqpql7rbo0cKW8bK5Vpf3Sof7rHj9fSr17dPAXtpU3i6bZ57qJYrTbghiBz/ AAgZGa0pmUoW2GQyLcgCW0hgk8ost3v+WbbwMnoOlaGpy2uo6XLFDLLb3skQihMWHhYjqWJ57du9 aEH/0/4uYGbTo2smhYhItzTEbQSehPqTVzTbmUSIxjJ+bCPGu91P0rOm+hwLQbJC9vcwXeofZ7uz aV1kt3YpNz93GPr+lU5UNxcW8gKRpbjHlou0gdq0NU2olrfLKoyAqsxQLJx0qB1JmiWZRAryCCBo I928/l1OD1px3RMpNaGjqDRRf6q5t5JIk2zJC+8o3oR2NYBT92jRTfNI3zREYIPrmtzM/9T+KCe9 MSSIxyUb/VDqzDPI7VVSH7dJawvIySSybFSSTAyeOfWultvc88vLeaoJHt7wSTNbk2zzu5+REyqj n0wB+FEZk8gJkNEcqXI+akBds4YTby280yKLkGKWMsUTb1+Y+n+FYV8sVkqrbOLgLJskUDaFX1Ht 9K0u4xJXxNDP7WNsAsIXzNwAwOR7VHdebfYkPmSOWBkCDKIPwo5+w2rqzP/V/iN020LTyqWcENtK EdRxitu+sYwDaGR4bxQHEYXgjrz6V6B5ErX0MqBUkDxEiIRjM7Hh2OccCiKeKHdYxsGDOGM7jLqM 8/z6VpT3sIpXwSKSVhMsjRjCbeQar6dMBu8zcVc5B67fcVoB0huI7eJTHiS6H7uTzl/chMADHqev 5Vzt5JAsx2SCT5suvTb6inHdAf/W/h+msljhE6tH8w81Y2bl1okdDmSFQr7BmFeVXgcV7tnz3PMg 9LFJrLU5Ud0MgjZxvjD7A+MkArnnFbEKDRrRLieL/iZvIH8pm/d+Xxxj1x/OrJbtK6IstMqzMNsc vRW/jxVG5lYfIrhFU52pVQV2arVDreOeIo0U+FPzMN2G5qcrIwEcke6J3zvYYbI5yK2A/9f+IT7b DDMYlRIFICb2JPXgk+1ZDEEtKWEmGKbk5H1FfUHm396xTEUG4xqSXeTLsBkr+FdhY6KPsk8M5WKc R+aWZSshVvuEjrjBz9M0FeRj3NnDA9tFaSCXyUMpuXGzzMgZB+mDVa7juoI4LpCGLzBPLRDLuz7U bGc1qmdLbxQ3OoWenqixhofMmunO2JW6spz+lbSTWGnwyXETR3Upka2+zhvmGB976ZIqIyu7Gh// 0P4c1vbq9uLk3SmEwE7RjCsM/dQ+1Pb7QtlPPbtGI0xuWaQLvycYA6n6D0r6g88yDMZ5BFGuxmIL H+E050SEsyuHYnaOclSKDnILmVx5CuxIB3Nzndmr1vcNBCwV12scop6r9KadncCu0xkL4UFn5BPf FTwrH5aySOu8vhoxjj2HvW61VwP/0f4b5IQY38y4FmjLlH2FmfuF/HpWMVllkdiFJ2BcheuK+wPH H3F7KiRwtEFcR7C+3DsB0qxpZWRCHz5rNhGbovpTTa2AtT21uCIwrGQHmSMdf/rUotPLLsTzGO3Q 1pGV9GNpp2Mps+ZKTGT355qKUsixkL5e/jcB6VV0hH//0v4VVgjnLM0iR7IzJuYn94R2A9TUMk2V G0Fj0296+4PHL9vJ58XkoqjC/MDyT9aijgS3Y7UBcngZ6c0AVZxukzITv6ll521KP9X98uc8qoz9 KCoq7JoxLE4hKAM+Dub+HPrSybrfKSHIb5+OhoNeVdj/0/4UpSjhNh28cAcc06FiQIHcEscDIxn2 r7g81xVrGj/o1tE6Hf5gON4OQvpiqTPPdS4O8NGNydckAUA4pqw66vGeFIHUIF53YGfxNQ2kjCdQ CWG3aoPQYpptbGbi0dtFZyyooMZO9CxI/hwM1zl5YRI+RtbY2WHWtk7ok//U/hbWDfLmZyiD7oAx n2qORfIfIO4rxnuwr79tLc8cHuJChbYB2BA6VDFc3EOWimZCTtOP4vao5lzXAcr7yyYw5bdnHX1+ lMDFCwEjB93JBwMelKUk1ZASblfMWcBuS46t7VAsimQKm9UU/nioA//V/heiVZtsZch1O4HGelRt uXhfmbdj1IxX3MXys8cmtbho2aRwAX4II+U/WmNAJD5qcYOcY2rVuemgGa/mPIAFwc4yO9TAT7wS +ARt56U4yT0AdECsuEk2I33jjNPitYZTI0zBinMZ6bz6H0qzNp85/9b+FNQ8RCDIU8NtGeKvskMP zQhjleSx71+gHjlO3ILnzD8u7Lt3A9hV5mVtwyzRtwuRgt+FZprnARJ3hiMceQjn5sHAqaG6VOoA 3nao9xWgEc8rSB/myB1TsPWqyMrFVI27TuAI/WgD/9f+GCWXMjAAlmXkjqKapcgIck46nnaBX6Ae KviY+3tS2GVsyZIP8q1pLKUxKdwZyvKKCcf5/rQO2tzIlj8iQLMhC9DGw27veldvLWR42+6MBc5C 0A4pmaBOT5kiMxfgE84H0rXtXGxtyhmjHCN0+lAz/9D+GS8unvA7PHsSNQqgIFRccAD8qjimSJPJ cbsKGG3+HI4r9BTs7o8cjS4nDjBy36e2KtNNLOQrysGQYKnhTVOb6APMimMIpHyEkgetPhnEce7G WfIJxnFXFtrUCGWXzWTbOVKtyoTcWx29qmkR5DhFEcRwQCck1Rg9z//R/hmlQL+6IIlYZBC8Jj1q Te7rHHOcsq4yBtziv0g8OCTVmQlUgyyyEDPIY5z9K0rC7jCTRKWBdMEjo2KAimkyN4d+SAVI5JPA aneW5wdoYkYjAGMU7tKwNvnsPigdZMvnAHKDpnioLrY8/lo4UHqueOPSkaH/0v4bZCiqY921iu0D 1HSqBZFRFjckg5JIyB9K/SNjxm7K5KhjeYKWkyACeMK30rbKz2tr5+VC7wrRt12n0qpfEzJyuQoD K6M+2OI9CTyTV7zYw3mk9DtGO3aqT9zQkz7tJJG3nJRTyx4NKJVUrFkbyPl9DVrYD//T/h7nllg6 AYKcbOrH0NUjqFxnCptVxsdcZJFfp8vhZ4EdGV44riSeRzuCqQAW7f5x+lTqFjn4kMfrg/Ln2rA3 Lq5MbnaG+bnJwW96pOymQ7lKFOikYNBlPcuIiygSqdrxj5wRgY7fyqFo2dn3Pkg/Ko6kVEpK2hK0 dz//1P4Z4433tsDsucsT1FT7ZERiDxnrjmv0Lmd7ngylcWNElZM/M5OAeufamPuidljbDZ24Heqc +wk2ti7ZBWkbzVAVRhj1xSXEiC4Uws0aY2EKufxpxnfc0jJvcjuIN8apEdxzyxOKrfYtignBUcHa ODVrUs//1f4a2uEQPGyk7V2EN29xTYzayKV3EOikqw4ya/SDxxkCxuvzO28Had3OfpT5mERjVTtI yVI4DUBYY9424bht4++Bil5mDFl/hzxzmgmUbly0gXYx3BSB3H3vaq5TLmOTlX7AciglQP/W/hvS 1byn2HDhsAE46UyOBudzMcfex0Nfo8nZaHgpLlbNWJ4kjMbhQB/c7/WqWGklLr8oztG4dqwJXmU5 Mq45BZGKg4wV7VGB5pYhiJV4YgYoAtRiYr5JjXDsNr9enpViRprdQgIIQfNgc1CgkzSCs3c//9f+ GWUk7SwOJTgk9atxhYo1j2rvyWDMckiv0A8crZjcF9x4baCOtVWSbJO5mwMIO3+eKALuzbDHknzm X5sdPaqJEiSb5Gyqn5mPagDc2ySRbjxx8o7kfSoISz7sDCq2Du46d6hzXQiaVj//0P4b7gEtsJO4 D6giqq+YnQkN0IJwAK+7crqx4kNixBEGBdpDnOMjuKuRK1vGwRAfm+9/So2KexciM0qNuwiAbVDD G4+1U0leAu8igAfKB1I+tZc7uRFrmF8+SRUY7VOcDsCKjG7zXUbQM7lc9Qag0P/R/h+gF2d5U5LN slXGQQPX2/wqjdPEZjEwWR84jK8AV9geOdPF9gtdMiBl8y9lDb40GFj9Ac1y90k0YeVO5xt/ib6C sprUC5aLEAJLlpBNHjEcajYvrv5zTrp5mZ5YpCwZNgyPu/hVNe4FjLXcgkNwxO9cLtGQcUsTxyoY 4yVlA4IHNUthtNaM/9L+HDdOCNzlmPyvv+8cVpJI+2L5tjg/KScH86+wPHLKXMccg3wRyFSd4c/K fTOOajjkjgeeWTaCyfKF7+1A07O42C5iSCRlfY87CPZj5XU9QT+FadvGlqJpyceamAAePQYoEY7R 4naQIXJ67udoo3Qi4UoCYh9/jJX8KmXwm0PhR//T/iRvTGIEZUUZ+Uucjj6VlLIybyjRAqQdqfcH v+lfUHnmooMuGimHmS/MGYBearDy4pHEynzCMOVOMn1xQBVlgYtJKXwoHGD8p7VEjyERxyHKK2cs O1BEo31RoGOB9giLE5+aTop9Bj8Kikkmt43cqFDts/2u/wDhQTKNkf/U/iAE6kRsCu7GMgY/OrKx S/NKx2qkW/MZ5Zu2K+llK2iPJUbq5bhuBNHvkOX24CY6fWs0hmnCQxBhn5zwFHvVJ3RISRmN3W2m V2XmRcYCZ/nUo8tmKrKQ5X95gYUkelKekQLNsu9wpYbY/mIJ+UkcZq40iMnlNukfsduAB6ZrLpYD /9X+H27WdZI2UHCHHzD5UHritRWhMIaPa77drvjgfQV9AeE5NSLNrELdVkVg0ZjLOuOQfSsW68wR Ryws8UZkJHv24oKlfmSLEN3htrBmyAXPXH1qxLNFFM62qjEqAyjHQ9yDQWZkjRJLG+GwDyPX3rYg dJEDB9qO23DDpQB//9b+IhhbPM5Hy7G6EY8wev8AOiN7cEogIUHKpj5ffFfUHjmZdqs11EYQVjPy tEh3DPrWlCpjwxmOxBjbnp6DFAGlcXP2WKFiX2yZACdRx3+tcybkPcSHDYf+9wRXOBGVeSN8KDht yk9cZq1aEuk0Ukhw4G6LoTjvQB//1/4hF3BdiDbCo2mUdD61djjHlSOJvlAw+4csO1fQHjlGT5UP lys6glo1xyp9P0q9p8YvwskyNbyu2z5xtDkcfhQFhl9EEl8mNgkiNhwjfK1VrkJZKIiGlllO7Crn b/nmi3Q2j1RFawySTI43SAvuK4JPTuK6iG1t4oC0rs2M8v8AL5fP9KzlDTQXOj//0P4fryJBKzRv 5qK3+s6Oap3FxG0KxFnUer4LV7sFoeeQpGQOCzYHJAqs9vK0h2NuB6qRyKsDXQQW9pmaQQtnarHu fSsy5tmuHSVWaVzjA7YFBMrWsye3uLi4ZYHb5FbAk78ds1LLK9uzebuO07YwDnI7ZrSn2JjZteR/ /9H+GEyyzTRq0u4SHaBt+76CpmQgogwNvBDfxV9QeQ1qxYVA3j5XlX+HoacENxIFYFQr/MnrQIuS wiMlXOI8Z9MYojnR4wVCtbj0PzNQXB20KcvlTPsjXbu5U5qa1HleZlAzgfN7e5pSdkan/9L+HGYo S0m1drrhx0OR3qibRyLcxHeZXO/JwPavoDzy+62ybAI/KkUdA2VJHc/571UuZm8uQKoGFJJBxnjB NAGckYkjMhHlgDPT730qUShYmAcFQ3yg/eFBM3ZCQRrI/mvl1HVfb0qUeQrZRXRzwqngH8KDJaO5 /9P+GFIXkVmPCA7TnsarF4oXCIRIW49l+lfQHkNt7kjRRq6lQDKVzsI4PvXT2K7YRICgMi5A/iB7 0CKNyrySbpSHbHDqv86yGinVXY8buQuME/hWU1qBSgZ0V/lJwckng+lbdpbuIjJ8+GYMjrkbDUAf /9T+HW5cl9hdomK8Hb196ytOiE9wUkYx7Wy2V5OCB0r1pK6Z5MPiRpXs9naobXyv3pG4uBzj1FZl lPlCVwAHwOOe3b8qzkrGxpTAxPvmXLsMxODjHPU1k3QxI5L75GO8leTz6mpAktlV5YlmTcu4M8KH 5mA61vSwweWDbIqRHOFPMg+tAH//1f4bYLqSATojnLDBjUfe7darOCHXLBXfpluQa9SCVtTzy0tz 5UfkyqpBOWbbyPcVPPZWzwCaOVJEYDOCAfxFDgkBQWB442cghExggfez/wDrokxKG2qAAAM+ppxh bVky2KCtKJVyDxwavxsGJK5Vs4O4dasxP//W/hluZFOxSSxZhH8oztNOhZozLHG3mHbsZCMnHtXs HjjxEixgna0kZ3FW6Y9Kq287TzN0WHGBu6L2oLi3dIsySMNsYfnOMjo1Kt0vAClZ4yUchuJAPag1 FSeBpCLiMKj8EHtVxPImif7MyoY+nmHGfpWMviZrFpRP/9f+GlJmmDW0bqccgt8u8+3+e1LbTyQe YsiIQp4Y9T+Negct7xuTbFuFaXdGwPyiJvuLkdc+tZslsbd1DtuHUJ1JoMSw8asm/OUHXI24qCNd isUGVIwe+Pes5voc5WaEoF2s6A/NnoTWnp8C3CyMyFmjXIYjj8azA//Q/hvxFEwjRQHY5JI5FTjU TA0kVyN+1R5Sjjfz/SuuKTTR5yikXbLVEZ5BtAJX92By3HrTruVJz990GMyDOMmoNYR6sy47ZSk0 jN8q8AHqeewqz56rG8EkTNuUCJ1YDb6lh/Smld2NCq6rdyE+WNygKWC8nHHNXo0W2CxKQ0rjLN18 sUrW0NHC0fM//9H+HhbtUkMl4HZ4gUt5P7vuRUU00Ubb9u4TnBC/KB6n/wCtXQczimSt5fkKUGwE +uScVmypFJKSDhOpUdP8/wCNBgSKEVVMLbZUboBgjHfNEsjyFo2MmQNzuTu3/SgCxbXqxkDZhE+V S3XHfNbalZHcFYjAVBLuAdg6nn8qAP/S/iPvpTAu22eMRBFUi3O7IPv796yN6XF0indIGiA+ZT8r Y6V0HBHRly1sXiLqX3EtkJIOFqKaRRP5Xy7s4+f7tBvsUg8kRMbMvEm7zVGdw6YrobVhLAGlWSOM SbQwXIbipk7LQDFuY5MydolfCt0LD0pkQJt3SNWEbHrnBB96ybb3Jcbyuf/T/hxa0lRFYZUynaSp yVrUsbWNkmElwxa2i3LuwrTE8BR/nig5ZK6LNnbRRNFJKCqysfMB4YAenasjUI5TKyW9xHHEp8wy J97124P5cUGI5bLeHuZpMD7Mf3fVyezVb0iWJN1q9y/lSglGBKNG3ovpmgdtCCSLzJrqCAsWjiLL O3zAY9as2UUzNBCZASoPmMOBz0NBdNdT/9T+Is2H+kPcNIHkiBTzSflIFVJh9qKLI+9V4UHCqPrQ c9iG3WSG4AWECBeGKLhG/Gte4njEG1OMnBwMGonsFuhkTXiRvbI0Bl3Eli4PlqB61aeT7UPMEYRU O1m65FZGygktSjLpjTTOIEeSJcO5xwKnjgihUxBSO5B6ZFa09rBJXR//1f4fxbBohJI+G34RRxwP U1Uu58qoUHCjavOQtYy+JmSg2iK1tXuIQzu6DccLj5ZAOCKckVosRSRpY1XOXC8j04/z3qSuRHMz WtzEGXH7uQ5jJONwrPlidVKkbieG9amXwshxaM1pJlcxOo2kYXA7V1mgqHm2uqeWq7gW4PWueXws mx//1v4pYZbdoIhsAaMfI+3qRV6O5i8ly6u7jpGvAY9OTXjk6RSuQHDSNnZHGq7nVudwrdsjBDAk qz+ZbzxBkiC4C/Q+9ZSk7tIye5ahtxqOwSiKCFiRGrnYGK8gZ9eK1bCCNYXUPFCVbAt1OWY9yPar jK+grdDHkg8q+Z3iE8cEn2m4CPjcpIyvt16+9VLvUbtfMjTMMUzeZDE4G7Zzt5x6d6zl8TA//9f+ Li2gmYucvlk+RUXcffNWrXRbBU0u/vdXltwNRBeG2QmcYP3X9j3UelfPPZmCTeiO9vow32q30aaV nljUJFORGzcjkgfjj61lz6lfWMDWl9EJbtiqw3XJmRieDnofqa5ZrQrkZv2Ailt0t9QMbyyDbJLN IAz/AFPA/KsbZb299cS2el7bEKEW7QqyyODyMDk9CeaxkvdK5EfVfwNsJfEfijwjpN8rW1xc6orx zK5j8qEMAgb03Bhx9a/0cf2H9D07RvhJ4asIJ2e5tPDlgApjCo7mIGchh1G4g/UmvyTjrleYYeL6 X/r8BYbkeJlF7qx//9D+wGD94yYwoAwR/n8alkj2ShlwM8A/3q/lc9aHwljarAFsc8EipJAkS+Wq 7twyDj7tFuhRQUzIThS+RjPpVgbhweCw5zVcrsAm9I90Z+YDkoo5NV5J1ZwmdqDqD2rWmmB//9H9 61e0isWjty0NxnYIVXKyDuc/0rHg32VwrxSYR0aORNuSCSMHP4HP1r+Tre+TN+5FFkvJf77bIwuH Y7vubTkfqKrTSmzuII0lLQni5WIDK59M+nt61N7pEwTUihq9rFIGU3clvasnmQSSReY6OOckZ+n5 V/MV/wAFV9I0WwePURrWrX8KzXVlfWv9nmKIm4n3I7DJJ8sR9R0JfOeK7smnyZtC3V2+8cnyyTP5 vrzX31KPULRbGB44boxw/vcxXCbRh8445JHf7tc+biZLeNry2EQkRoI4s7ix5Gfw9a/caT9yxxVl dn//0v4vbv7RaPOyvIguFCrGPlCYOevvS291dtGZ7i2Z448pGyIWUH29+elfJKbWjPKhBFjR53mv JTJ5sIi2gxMuCd3Of0611sjKbtS8Uk0EEYZZSA4jPTgdR/8AXrRaopw94ZHJZNd3KRq7vDj7TIsR AiDDI+bGM49PSs3VEiju7ThPKDl/NdcqOmDn8aZvBK5PeW9vJData3imaa4CMkxCQMvAPPUYyfyq ndyjR7l5LBHuZlla2kQSbop0RjgxHOOeobvQaI//0/4x/tUB1O+uTbXsOnXBSeRjOJCrBRkMCQMZ HQf0qjqDG4R5bdQFVsLj77+5FfLmDtfQ2dDuL+DTZ7eYjybsbbbKiQxN13D9eDTZ5p7S1t1jvZ7l 4FOfOKsFOckgD/CrhpIqyvZE9r4ruzpGuWGpQ2zKLRG0u6kjC3ELGRS+xgPTdwT3H41NN06/sdQu /scpgj1mKOK5kkYCOQqN3z+mMfpW8VdNIErTSZx/jL7c9rtCRf6JEUlmhY/IoJJ4+p614nFFG5aR iSpbjcPve+a76JlUdmf/1P4QYJhEVZF53AAAcV0c0kEi27XE7rAAd2xcsDjuvtXM1dnJCX2Tc0yC C9RBb/6I7qIzkYMijufc9a9k0bfNbtBNHF5VuAqZk3O/bP8A9YZoaurGqlyqxJpF+J76ayjtisyX HlQy3MRihlHT5GPHrW3exPG+95dkkEnzIj4KkZGDg8/Ss5RsxKTRQvNQRJVvLwMWEJt4IAOJSRt3 N9Oufasm2uZnilEkj/u+UkZsAjsp7cVBrF3R/9X+MQ/LetJMpmjYbtrHG3PetO7Lwi3SNXZc/ukQ ZVSa88mUU0TXIuUtDd3So06t5iSy/LInoM1hxasl811ZS2uySJVktpY3LebwNwx2waaTexiaNjPa Xls9rbrKbi5LW87OmYozGcqwP19azodOvFdBezPc3vlgedu3QHGdygdPwrSF7WAx54ba9uZ9BOot YLMyz3DkHcqA8BTjABPB9s1O8lxZ3UOnpLFdWVtJlZ7YFn24HCjvj/GrJcEz/9b+M6/e1ubltTv9 RuUzbrDaxyWwAlYAKmU7Nj6jjpXKi+1e1uGXRofMELq5l3bpGyfmKoOc47D0rKnuckYW3LTzS3zG edCYWOVBXY6sOTle1MS+t1NqlyxhZ7gW0Q65yeM1qXa2hvSzWUd3svLgOceTaBI8xggnLfl3NF1c tp0C28iRPET5ls0XzAg9CT/T2px3Qmk9zPhltbmKaXyo4HAyypkmU54Zvc96rzTxyW1vbJBHFtmY G6AImbOOD64xW+pDikz/1/4k5tH1C2vAlyzRqpDFJUwxBGQfUcEGppLR2vI5Xn8s2o/cGI4HIznI /Cug88UTX8t7te7JSeUG4DnCXB5xuP1NaUmp2kaKkkDRXtvMy3CR4EDxDGCB/erSMOrIlJLRGRqe qWsjK1nHIq7jtZ8Ake47VURp51VoIiWkOHyAw9MiraurGd3e5n3MbKGRlAKHO/GHGKlsrq7ghmjh eTDkEx5+U49qLLYG29Gf/9D+I+28xWMqmSNpBhsnAWkleTfPIZpxNGylZUGWb2NegeONinaYzCRW 83ZtRiMHmho0DGESJMPL3eZC+Tn+768f0q6e4GYlvdBmjaCTbjIZ/usfY9KY01vaRsXkxJnYRjp7 VqAq3zXJjgVt+f8AlpkgDHvU32UFnaTBLDHy8DPc/pWkLAf/0f4epJYUaNXBYoNikNwAKqQyGO4k IJfvnGAPbFfQHj7GjNqM0gVVfBUhi3R+KrtPNqMm6TM8keAiscZx0BoA2UIaEQTwhHA/dEDame+P WuXuI5FldApYbsbhyq/jWsE1uaQv8i7bzW2czzqoxsR1IIz0HHpSy3LRzmEyiWJc+U6sTET7VZaa ex//0v4cZXLpiaMf7LEYJFUmZo2QKgWEck+v1r6g81fEx8Sl591vmNsbhMvAY9MD3rvLnXTJaJmO Fb6C3WOaVTjzkRQq5HqOmKUU0tSjiWvpZPMzbgLnCLnDKO+KIL2a3kDF2HlsJIwPuqfWlL4WAv26 XzVkRiDv37jzuJ61dmuotzTxAQsMEw9RITwSKzgtQP/T/hriuPPutzpvVsgIDsJ9zRLZTIJQSWRF 8xevX6V9QeftuYKtKk/JKhuB6mtJ7V4kD4HzcgKeR9aDKdr6FSQgsm5TIgYBiOCBSuqecEXcsJGV 5yVFBBNIi7bdoplVvMKhD1YDqTVC6SZX3ozE7s4FaxT5AP/U/hTku5J4VScsWi5DdW/GrtldJCpI YFmG0yAcj2r69bankJX2C6AkO7aGJ/jxzVNdiSxoHf52wVjHzdaZpCPVnUzz2dtbDYjCdVxOJuH9 sD0rn1vJZd4RS6nnagPFGxYkLSSuy7eDwc84rUutFu44bea4P2K3kBljFyp/fqBj5Mc88c0BY//V /hMbcXHlqVCkrg/xe9VcskmACSTj6V9geTKPKXLaX7PvijQKc/e7575p6TbJZHkk/e4wM52EVbk7 3Qoq7sNLrKd4yGzhx2OasWtwlq7MAQxXacjK1SmnobKKWwvm+c5duFPDYOCabeBHVSZG2KuEz2xS lJp2Gf/W/hGTdIyBVIQjAJHHFPMXlx+YCWkB5GOnpX2sZX0PPJo5PMXEh4zlnPU+38600cPh+UkQ /K44YirAz7hA7YO7k/uxjO4981d0w2glDTnY8Q4DYCt1zQZzfQ0b3XJnYwwyMiqPlx3/ABrGluZJ kVT+7CH5mH8XvTWjuZn/1/4WZt22Ny2cfdxVYO3mjqzt/e6CvuW29zxyzLJHtIwBu6j0qoyiFizD 90+NpznB9qQDwhaVjG24quQVFPNjM0bEMFYnJ9aAI4FSOQeacyD5cLzj3q25jCny0yT3YYNAH//Q /hMSSS3f5GOWPUdRUi+YjMzS8uPlUdRX3B45IshYCMqML/ER/OrP2gDCnBUDaMflQBG8cIlCrIcb M5C4w3pUTRSeckYUsCu7c3FFgGvKsTlfL4QY5HNSbMqkiZEb85H8NXze7YD/0f4WXuI0Kgbm+XGT 1/GojclvkZcDp9a+9hseOTKkbMAp/AdfqakMbRMY2LMCMqenFStJgIH8tPLIUrnAPc+1QySmKNEk VWRTlcfeGa1ArszeWDCCc8/T2qzYzSebEZBGpQ/xrlSB/eFAH//S/hfc8yuSAznAZBx+FSKgjgPz EyyHBIGNor9APGtZ3LFv5MDc7+QAWXuatLcMkudzABcKScHFAzNvrhZnQjLsvqKp4HD8qxPA7UAT xzlmCXIZY1H341+Y+xFOQffZASDnZu+Vj9aS2A//0/4Xk89SsZAdTyyjnH1qedoJUMcYKyAAOTjr 3xX6AeOQIiW6lzIJGI24xytCEK2cbhjc3qBQBbmWJYklT5E6yDBzVdJfNXapVUzgjHP1q4aMCRLV 0SWcBtq4256vUxmR0Q5PHXHY1qZTVnc//9T+Hq13P5x3HZJCVLYxWc8aRywMZH/dnkDq3pmv0g8O n1Ks482XB+XB4z0IpkM/kS7QuU24LY/Wg0NMXYni2RBg5G35hwPXmpLNZln8uRn2Y+UEcfgaBWV7 l+6WS2KMkbGNlyx681hsrPKszJtZXLBeoxQM/9X+GyUfdm2bmXggcnFMhkgQgPCFAGMkfdr9IPHt 0Glo1cYZdueOelPkuJXAXezxpzg52g9Kbd3cxcXET7TuZYmUhieCO/4VbfJAdGICdieM0XdrEiG4 DDyy25zjLHgD2rPnhfztw3AKeCvBq1PQD//W/h+i02cRxNKQgZNwG7P51Vu4lg2rEQX5LHqTX6VJ ts8CLs7kK3Cl8STHexwcqST7fpTLpIpZIiuU2/xZ6/UVJvdWuTFpIoWiC7y5AUg4K89aJbaQFjN5 gZYwyyYyp9Bn6UpaRZjJ3YsU8Hmopbcu0CQdAfaotv70yxOVwTsDdx6GsCT/1/4aDcZRcM0UwfDq BhSB/jUn2+WNQGjAD/LwO1foB8+QIdj+ZGeOwz0+lX1i3bGKYyvUjpQBVd5YmKIPMOc5zxxVqBpJ VY4VSRgnpj6UFw0ZCrkEk9FOBzUqX0kQlsonUxzYZyVzgjpyemPato3sjU//0P4bjbB2Ds+4t8hG OBTV0tkbfn5Adp7EV+kHjma8v2RmjGJGBPbH0qwhN0iNgl1GdvQD6flQA+WIKhUc7gNwx9yrVosl vG6lcblzGxHD0AOjWVG/ffLGwyWUcgewqoJZYZH2gNnhGI6DNBE9j//R/h5S4VVjMik7j8xXt9KY 80aMSEcIxwMDiv0g8G1o3OiOk6c+mrc3MTXCSRh9lvP5cinPIP8AhWpNpVhd6ekml29zHIQMGZt7 DaMFRwPz61ziSu7HAzRyQOyyJuk3fNuXGPaoIMnI2hQ5wcdqDWMbLU3vtUEEEcAVTKgOZMDjmsu7 vA8gZQCXOJMDHP0oKP/S/hwxHKqB/uxNkY4z2p8lo1wURMZAyHJwoFfoB45XWD7ONrgFyfujuKQm QzLtiJQDJGMEUARL+8kcPuj2N8v93Bq3LFbFMGTKgZWBxy5HcmonsBGJJGcAswbZ8kY4Ax6VoRKn lLsiIZEJuWc4DH2/wrIym9bH/9P+HAKxJOW2npuGAPxqu+5jtUjK8NivuDw6ZaZLhFQQLGuEBZmP yjJwePX2qC4Mse1OW4DNx90+9TL4WW9maMUtyE/eqzpGu4Nj7tVZXZhkMWWXO4fxD1rJK7sZQV2U 2Lq0SIzmLPzYHIq4ls7LuRiVB+fPUVXIzY//1P4jYozBG8ZwERfNaQ8Z6VmLHaXSyyqmyeAjy+cB ueeK+wPHJHRwVmdQS68BeQoHGf0qBMtJ3fKEJs5ZW/yKia2AhSSSEMRvDsdp3f59600tLgWZliBk yM+Wx2ls9cGqa0sBWNuBF5fmYlV9wQjdj2qnbRvHcqA22Tf1xjJz2ppW0Lnuf//V/igk0d7+MypE onA3fJhdx75rnLuJI2CtIFdDt2ngg9DX2B44wTx+W++MFQuzLcBjUMkZuECKQoI7c8CgCKGFvMSN eUVu/TtzWxPFcQxs/wA5QkBe4PvQXyapDVkYho5CE3D744NStZ+SSylWKgbiGDDOM5oNbW0P/9b+ IqKcyl4zCrooG4scE9sAd6rXtqiyGBI/IZV8z958vXnvzjmvr2r6M88WISRhHJCbFxlOeaoSyyzz sS2RuA342k9gKzcbICV92dsjEIB09/WtmHS2n8oorOjIPkY4bP8An+dQBW1O3aEQtEDES+0wJkkA d6WWTeokkACgAJGRyD3NJuyuRPY//9f+HtYNz5wSC2SAOo9qFVskFigL7I1bhm619AeXH4WaCwxW i7jKzyyfJ5a9GPaqswktwhTcu8nzGbgg57U7tGY2djNsaKAJLtCuUPMgAxyPWoFfyyIWUh2bG48A E05NsDQjeS3zEwCyPIEPOQPQ1cguIoSzyH5ycBeq8d6kD//Q/ifuSzofnjCOuVUgESGsTY8SvEEZ N5wR6V9AeLyq5cgm2gQybwXGxCOfz/z2rC1JpLeUQqTtHzBM5C55/CgohhmuJXYw7tqJgnHatO1n GCr46Ykf+Ij0oAlNsl0CI5tjYynmL94+nsKksoBG/lzPuk3FZNvK5Hp+VNJt2QH/0f4iry1jXcfO IZOVRVyT/hUKxyxxR7wELcgEcmvqDxylK0kVxFJC2wg5BXg57/596swW/ms8ivl/vFDyGNAFmS68 3yhMpCr8uduMfhWHcSQNc7IwxYEgKvzKalxTdwLrSxxIBGX87HzqQNh9AKTBGJsJGZRtLEdfapdP sB//0v4jLYSiGRDhEUZBIGW+nrVLfcOmBuMe/a+O2OmRX0Uo8p45btClwBC6YKN/rgcY/CtaeUpa 7EXcA2UDdFPdh7nFSVD4kc5JNGZDI+7zAdu36d6hthcyyCWZmMayYBPVwKDTRXLkGom1aR1yjiQl SOqg8YqV71rhDudiQcjsCD7UGJ//0/4dZ5VwkcAzzmQnoajMH2gAqN7KO52gHtX0CVtEectkMile 3WWOSUxysNjJ/CR6e9a1gsLxvIeXH5AUA3ZGdOWuHML7GiDnJC52j2+lJGCsjJby/uVGFYphs0GT lcyXkntpih+UZzuUcZpZ7ueYKhBK9Ca1grIcNz//1P4VYDLbs7nB/uFhjBoiuJmuV8wlgAWY46nt X1B51l0Na0iwk0+V848pzkD8KvW1zGLmCSaMMwwJFHy7hU681jOaSGalcxyXMjGMrExwik7jt96r +ZCsZdFG7oka4CmqHTXUzWacSCTZnbyoUYxV6GVpwsZLQl+JDjtWdToaH//V/hbuS0IRVbfl+n97 2NWVnQQLI5cSByPLxhVHbFfQHnlRrqSWUfuzhm5dj6elVrlsElSWAPIzQFhWeSURq2Qu35e2PpWk ttE8DFFVmRMjcfmkxQJq6sQRPGHXBMbr8pUH5T+FSSQFplkb50jcPleOnNBnyWaTP//W/hrNwrfJ geXnJx3rNu40WVmRdqtyuR1zX0B5jguhoIrCOOVCZ5dgU5+8gx0zU1rcMmzapEYyJGY4KGgjlZF9 sSF3i8wOAc7sZzV1TFdojOuyVSQp/vD3FYNNOzFZ7lS4tfKlRlcCMnbIQPlx3qGfUJYWNvDKUthj PHLUhH//1/4b4ZkuN5lO7ykzk8HFV7S98i58zYkmxs7WXKtjsfbivWk7I8yMbasmvrz+2GLJaw2n lH92oGCc9cnr2rOtPLjEpeNi6NyAOGOaibvYsdd33mF+HztABI6e1JFE9xFHFHGTPJ0IHIHrUAaq WD2gIYxST7ANyPvAz1GRxn1roBpc1tZtcSIHUAblVs4LdKB8rtc//9D+G590VwGWAYcbQOu0+9Q/ ZHlZ5UXcwblP7tegeeIpVgWkyAvBVhggimNIExkZTHIU9qALa6hFcQi3WKRFRQke/wCYv6n8+1Z1 3b3UJjjKELJyrKevb8KuMnewGwUVoIghL+VCqkyqEbIHzVkzS4+WP5mJwSOAtak8kT//0f4X4bJz vZpCABnI5IP+RR5ZhBaN28w/xA4NeweVKNnoQbpmG8/eHUHgGljbqu3aWbHHA5oHBW3LPlmNlBbn d8jHtU8uniXDlgCDv3IcZ+tGxoT3dlb4t3imEu5cycFXjIP3T2/KnRRxxIDEcyfxhh8p/wA81jJp vQD/0v4ZJ7N5NrQpzu+Zs4AFEqkx+SyrwuG5+aQ16B55HzCiL5beXnGAOB9asIzTbSxTCLtBH3lH pQROTWiIEVTKI2LeUJMsAMk/hVnYpdIUcKjnliOn1qXFMyH3FmyE8My4+/0GfanWKNDIHZ5ViC/c UZQk4HP0rEcd0f/T/hpvnc3m4kBkIwwH3vrTbnM7RERsspXbjHytjuDXVGXKeeX4Yo7SD7S7oZQ2 wxgEuffFX4jBcrI6KRcKgYIw+SQdOD61JvG1tClcOYA6iFGTbnH3mX1wBTAq+bE0eXRxlg527aNh nQWiadGsrTB1QplpEAZgc9AD1rN1CK2Z3awuN5Cho2ZdrjI6Edv/AK1BfN7tj//U/huSGQlHnL7l B4PR+vNU51VsYkYnPTHFdBzm3YrEyfNCJECFHicnDHHfH4H8KpPZCMbbc70J+cn7yH+7QYNWdhDb tEp7Z5znrTPtRjkSF4k8o/M86jLY9KAs1uRrdW6yOfLMkbnb5Z+6RW0rxzWqQ2sZ8qUbREzfMM9e fzoEf//V/h/Ef2bcEaVpIx82xMpHj1NWLD92jMsmHd9wDIDx35/Cug88q3d5KWld3Mcgf90yD5XG apGyklVZ1kWVJP8AWY5lRvQ+3vSeiN4u6uMkV4WidsLGr4Jbvj0rZTU7qRY0XAt4VIMajCtnqT71 i23uMo/aXlEglXKI+7YoztHTrTbmaErGocoQCxjxy/TB/wA+tID/1v4e4b69P7pbSKRYV43Db8p4 zu9afdLETIbZpd0aBnIHAbHIFBzlC2mu7m4bdLIqRKIykjYRDnqPrWpNFblF3IQVGFY5Cu3cjtQY NWdjKummtFVQjxnkbgchh3ptu8skZaOAhivyyBfQ9f8A9VBcklGyELXLSooeSAxxncgXDyjHP9fr WpaQg2j3MUkpkzgK6/MfbHtQFPsf/9f+HubUEECRQyM8+ctGiZT0bJ9qFSeXyQ4EG5MplcbiKDnN Le9uqmaGaK3kG1CRxIR14qxdWMsUkYwfLdAwTZhhnBqZq60DYktrW3lvY7G4t5rpZItpCjasJIOP n6A16FB8Lba30w3lh4hSa7O5pdHum3sF25GyTGGOeNuaiEOZ2eh1whzvlvb1OClSfQ7W5tGdneUb 5HePDrgnge3+Fc55DzhbjzHZegHTPvVxjy7kH//Q/huYTzERyyNHBHLmLYfmb61DdyBcqseQox1w TUct5XYEdrqE/lxx7QAjnO4YIFWJ4LloJXDbkdtyxgc59M0ciAw71Lv7P5jEj7OOVzyo9qy4i2Hk Zsnqc+lc89iJvSxTZBcTKY36fxtwCe4rpdJtZWnhQAsCcYXoeK557Gdz/9H+J6AosKIoJeD5i5XL k56Y9OKuyWtxsePe8LMElbcu1gTyOvY5/WvH2MG2xV028EbpLtWYkqvO4OvY109kIHthpk9mFv7M rNIZD/yzIwgx7kH8q5xEtwtutlbSqDHdwzyRtGxzsHy7XUf99Dv0qg86RyGeJd0zRCJ5j8pABzyf xprRgZGpTxMd481y/wAkqxyFGl9gRg1pajYpDNCbFrq6tBaRtHJN8zo5QF0/4CSaG7u5rGKsf//S /iztr+WMLHFdTRXCTfI8KgNg5GCfxxWvFq9haltNlhiLkCVnZdjRMcncOOc9/wDGvnnsJJLY2Z9S maCwvIrN4zJKbaS+H/LUY+T2/L1qxOjpNBPcfcdMRsw+Vz1+U96wsMdcWNm89hcX8khijdjCIJdr uxQjaw54+oNd54VsZprSWOziihsIlwYXw7k5zx6EE9jWVRa2Ban1V+yfpd7efHbwVZahZxzoNQWa 3eIlYFiEiKgmB/iDFcAcHmv9If8AZ403T9N8F+GobVBaeRoVsJPJiKGbeoYkk9gDtx7V+Rcaw/4V aTfZ/mcmDu8xm3ty/qf/0/7BYfLXbt+71z0OKmmiV/3iFmAI2r2Wv5XPXjshbMhVYSIS2flJplxI WnTjGOG9KcVqhk0JdSeFI7Cklxu3OcewrcCtuRHMijczYHPOBSvbQuCD87yHLe3tVw0mgP/U/ejc jQRJCiiRUzvPWsxIriV5ZBGDIOCAwG76An25r+S1L3ncmp8KJ4hJDdeYEhEbwhJo2GXcrnkMD7n/ ABqNvIa4yV2g9DnjPpU3923YryIb+GIYeVklggZXkjddyTYIO1fpj6V/Px/wVP0W3utAiRrS0tbK LxTNdC+mPkXU9vJbyboVHUgFkPoPMFPAOX9p03/eX5mNd2jzPuvzP5W7XTNG0nVdemXbNYzfaIrO xvMxpDcJK2Vjxzs4G3NcJrWv3GLaO9t2VXuWSAxwKwQjqN4GcYA71+90Je6vkY1o2tbsf//V/jF+ 0vc3xF1ax/Z8EJKz4AGOv19q101Kys4BGkcl3ahyskaHb5ZPUr718fsefCDasUp7u6+ztdw2uyEk NG0i7JQueM+31rc1i8stKsre/wDPklkEIE9vCdybjjA4+o57c1vFpoCvoerm1iu1aIGyvgJJxHEZ n3AjpgE//qp82pPc6i0NrFYy2N1bLbW9vdsbc2kuTli2QOevPfNMNthFt7e2Vp9RFpB9j3TMpYLC oUdQx7+1ZWftznVbaRY9OhG0TuMSuGOCqD3P6Cg1hsf/1v45bnTLaWwkhZ8mYq+wnaODxms+MINQ +yXaRWtxcQrHbl1+z2AVFA3FjwCRgn618wk3sc5NZPHE32ZnhCtkqEk3R5HHHOKpX1xFpRxFbRSG 4Zl2TIZFlLAlvp6/hVwVm7jTtsY+mx3KRSW+oOqO0hkRlQSmJHOR83cdK9Jgg3aR9pnvIXdCYGkh YHfsAHTtxXTBaXKTvO55r4whhm0y5khuEjnlAgghxzKRyc9hwO9eD30MqZhUqxj+VgOgPcfhXbRW hjVWp//X/hEtYYo4C8juJV+6qYK5781NDaT3ZdHLKir5iZ4DVznFDc7XTI0kih8q5e2vgfL8pcES 54Gfb+Vegqz2mmJBDLLJfuds8mNkaNxnafT0oNSyoudIt9Dnn1a6vdRluZM2ZtjLCsQ5BZxwvJ5w O1dC+pRSRi6W3j8yeXY6ICylgPvN6dO/pSdragRXJupFhumtY5RbTebGrH7oxjj14rnblr+QXa+U I4Ahk8plJE5IJHArF26FRdj/0P44tOsLeXwzb3rypDcXjtDe2ksRW4tdgG0pkcg5PTniqsbyWTAP I86Ko2O4yzHoBxXnmF3sWbiK51eG5j1F18uVgYYYYtkaAfxD1PFYen6bb6Vem+kvPIVH8uznGVnY dwy9P1qovlepLkloydXTT3+1RAGFH8yVZDtMgJ+Y5+ldPMNL/s1J4L6N7e8kchYZRLcxkYLcDkde PXFaRknoM4Zo2uzdCxt53togXErIGkBAOdxHI6dKj0mNjPvCFZo0ykzDk56jB6djVEyly6H/0f41 Li3eW2dpsM+3GQuW/AVzsS3UTXvkudMWwhS6W+D7XmJOGXPYgZ/+tWMXys4lNrcrx3iWkQa1Rbie R97LL88RBwN2D+P5VNoy2wvIrfVFuQ16Gjsngj84mX7yj0HAPXFbLXYtTVrmfeaXqX2m6IYJqvnE QyzLttYolJwH9OBj61M11dvpkdn9li86Bi7TSuVOP4gOxBxwKunuQ5voZapOJonLSRpL0KHIGOo/ HpW41pIU82K5eaCGPzBbuojWJzjoep6frWpB/9L+KA6jcvKplQTEcOZGO98dMnPtSxRm5iWeJkjA lYPEBvJ9Oa7IRVrs88yrq1mk3rtEUULeY8rSbWYZAAX1P0zUs9rKbOMtbqZEOVkDZcqema0MZRad y5a2ukR6JfxXF5DFqDSKLUMpc7u+W6DtVG3uJLPyklgEsVn+8V0kEXn5zlc/4+tVb3bkgseqapcI 2lafFcxyNtnkaZVS192J64waqXKC3E+JMznAKKAFQjrjH8qkpQbP/9P+IOO4uJbcvuLbPkIYBX47 4q3bW95KjzSSjYihkRI9xf1B/CvRPIaa3KN5cywz+WkLDGAQw2k10VjBbmzW7axVJOR5ijHmbeWx 7804NJ6itYytQuDLbmWANax7yY4TJ8yjOMetY8dkbhFJVDu+8HYA49aqDu9R2drlkWQhZVhCbAn3 +MIa6PTIYtytcPDLAihpo9wVnGeea1jo0I//1P4er3TDbPJcRq00bSlo2VtwQE8D9azVuZHkwihF IwVxgue9fQHjltEADIy89d4++K1tOsiTLs3tsTexA4UZwP50ARX5lQBDKzhBv2kH5SfT8qzPt0QK QsmzeQrhhya6Couz1Mua0PmyCCFmVyfLODhD1+n/AOupIZENu1tOCr5++OSpHY0BHqf/1f4Z7YG5 lVZGkMSJtiJ6HHHT8P0qxIECurfPsG1Rjla+oPLphHFJ5KLFbTDA3mRVLL19aryhpHIbduxjIoND Ru7fyIYZEAZgmGw3P41iygPJCw3qHBLqRilLRMDQsYjMkmUK7Dgbhisu9jmExRGLIOCCOBx2rFPl dwP/1v4YrSMwjzGbcwPy/wCzU9xc3EdwZHfzIZlxImQCvrivp07q55c+hnkqzrc+UHjjbCxOdpPW raytIgVVIDc88/lTMyBhbI6xSzMofkhRkj8asW626b02u7Mcq0oBUj2/KgDPvIkRvlGGP3QOidKh UkeWrbiw+97VulZWA//X/hRcrEkuN7tJgZxxVW3DJMI2GFLguvTcPrX2B5MXZms94sME0XlBmJ+R 84Ke3vWVA0rP5h4fduA6Yx6UGsdkX5jJelpHkeSV+Hd8s3HHP5VWTfbvHGHILdSpwT9aBmsHKo7B CJDyG9feq9sby+lLTTM7Km1Fkf5VA6AelAH/0P4T3j2SMGbMmcBewqEW8oIfBAL4B75619gebP4R GZRvXBMjHqOppkjRjaApJIwc9aCIWuG/EiR4VYwPvD72akyYyCSHDnGR1FOK1RqT+Yoyo4zwSefy qzFbC6Cq+7y1OdwOBgf5/SqmrMD/0f4XPOgiBjhjDLuAXPG31NUJrjDlYwuF+8QOGr7A88f9nMiv ITsUjKY7n0olmdCrHOcYyvHTiqUmmBZCG62nBBVcg56e9RGzMSv5pPmEZQdjT52JxTd2VIw5GGB+ RsEkdKs/aEAYYBPQZ5xWid0ZSjyn/9L+FESNCn3FkVv4W6Y9qhllCjKpgj7ua+4PHsJE7OhMgUk9 AD/n0p6xyTMIXVtm7d9KCoq7LAK2m5A26QnaBjPSrEV2fLfK8MNrHup9RQVKPVGNJvikym7crZJP pVqPzJt7BwFUfNk4/KgzP//T/hIj+87FuUHFWRl44wq4PJZm719weOSsqhFBIGD83NV+BKRGR5Y6 55yafSwDslpWEakjHUjoa0ER1tpDNLtk48oDr155pyab0Aa0UUyOZMxtgbWbgE+1QtBJbIjg5i74 5qQP/9T+E0wzufNHC5wA3GfoKtpHGyneu2RB6/Ka+5i7HjlXz2gbI4x973qd7maRDIW/h2rng4Ao WjAr202A3IZlPIfmneSzyN5zlY/vH1PsK3AYVlV9sWdoGVGODVgCTg7CSw2hl9vWgD//1f4VIJW4 hKKQH+8eufarM3mLngDPG3NfoB45oMyG3Cx/fCYfPrTol+VRLjeq7cnnNAGZPGRIdhAUtgDv9aSW OSBE3KWBPOOT0oAljt5H2srLmQ45OdtW0aNRJGR+8A27iOKAtY//1v4XpG8sOqE8jO8VHb2c8qs5 yuR8jHofwr9APIt1Lo0qeJlzhi4O4ntVeWKSLEa4BPBPtQIeG2fuirOJF2nP3T/nNWYNNW3R2uX8 ptglQDncO1XHSwFjzjIu2NiF6Mp9vWoNkRBbZsUHlV+UE1qRNXR//9f+GrM0KLESDjDqytyM09YW bBYH5uhPWv0g8SCs2iGS3jRlVnyBnPYiquXVkGwOo498UFmxHBGoU5CgDICkVMLny2BcbhuARQMk mgai3sWb25knGFXZGB909fxqkULBIlG0gbmYc7vSguMLq7P/0P4dltSSVZ9jH+PHyjrzVGW1dN5d twHfsfSv0g8qUbbGajFXYMoYA8HtWs0kjiKMKqhPmAwADR5EW6Ef7uYLK4KEHgrwRj0/KpI8s+3c cHrnvQYyVnYm+z7GGcNtO78K0ZZrTbGAnIA8xf4XoJP/0f4dJdUlceWg2RrxgdeKoI0kkm4hlwcZ PWv0l7s+fNf7NEsRlAjCMMOzH52Pbj0qluiHMabj/tDge4FILFnyJVRZDjcV8xRuByDUVxJLKpXz mUbMZH+FTJaMCsloxETRABF6u+Q7H0xSznLbcbMfhisQP//S/hceZQ2EQO4IwW6flT9+7zd8gVlA ZVIOG9hX6AfPjoXwxkK5XH3fT0NXzcStGqR7mIBOMdPxoALaVIiS8ZZsc+o9qjlYbjIpKDdny880 AU5ZiQNoATqfU0QBPNEuCTt+6fWtoyT0RpGWmp//0/4aklck7gV2HtViZ7ho1fcUiThVJzk+tfpB 4yaZnoIHbMqktn1wWoa52yIIsKqnAHQjrQMmhUM7EuSvUj3qxK5KoY925TjBFACXV2I7dYmXc7jB 9V96pxwlWjd2ZI3GfmX170GU97H/1P4bUcxnDjKhuOhzTpbtAzqrhwEwVIAIY+lfo0nZHiW9whhv L0RYkd1hJwEDfIPwrt9H1ZIbcQSTNtUZXnPJ6j2/+tWIQVlcqa0dPkvH+xyTSwmFWMk0YibeR8wH PY1zhhCGTcT5OwlNv3t2OKCyiEKxEuSWP3QaEUGaJCu6SVBx6mgD/9X+G91WH5Y92f4gRkD2pi35 txIijIdduB/CfWv0A8chkkclZnbaqkKwx2q3GxmYlJMhFyMenvQBUdVlnUMWUA5+U4yak8qRriPz VygwFI4JUcVnPoBpywxRkm3YyzBBu38bfYVF9pEhjQrjgBwvfFZmU171j//W/h3uhv3pGSiKNy5+ Xdis6FiMqBgk/e9a+4PGS5VYugRjZsYl2OSpPGa04ZCGeSeNSpIQlRxkDH9KTWjHbodBOthBpjzz SRrJOhiiUSA3Ck99mePxrz9HaGRVic7g3yMRz+VYx3QklE0bazmeQzbsonLrkBXz6Cny3KQERkYT zA2AcBvrWydxn//X/h2a7Zg6Z+V/4e1TQWwd1RCuW5OTtr7FqzseOXgI4S6OzNzgjqFqstvJE4mt ZDGoY85+bGD0pWAfFHFOJIz8uBktjLZz2q8NSt4ovIwxcJtWPp06UAYj7vnuPu5OADzt5qFVeCSG aZGdN4fPYc8GgqSs0j//0P4kP7TupI9lvI0CKQ5kUZYDjiqD6dcTSGWL/SN3zMH4JP419geOVZ9L uJSySZhZPmER4PHoP1p6xizgxI6GRBhF9frQNblBb6SG4MkcbbQw3RDGGHGeT+NdJJqK3kSwW8bC Hrg8lM9qDSTtJIxr9Hh8rc+ATtXnkn0NTRebAGLbmDjA2jIH1oLP/9H+HkwPGo3llBbcCe1KyzXk pb95KVGwMDkgDpX2B55duontoY1x+9KZKY6gd6yEi+YEkCRjnafug56msXJvcDX8ttqeYgcBgGNd RbXsMUPmCPzmUY2R/f6dKkDBvpPPKXbKyIMjy8/Nn0xUELxyrtfam7hUPJP49qia0E2tmf/S/iUb T57lke2cRCL5XTP5fypz2sIi8u73qzOAZlG5kxxkCvoDypNq6MYh1n2FwSj/ALlz0cZ4P16cVJcv cMyNIQ6RuCy+vtQQXreVt+/y490oxFnsAORmsqeUzgxvHGpWQnzAfmX29MU2BLb2OY5JmkUt0iXf 8zf7WPSrcFrklbncqbcxv6n0FID/0/4gnNzAzxcEM+I+eVFWIpyFZJTukzyW5Jr6KMU9zxyrbvO8 pHzZhyyyY6msu6SZpNjZZxJudmPO01fIr6AWYmEMWIIzuY4LDoatR2ZdGf5o9/PPc+1ZtWdgHPBd Dy2UjpsXB+Ydqks7aSLc7yeWSTndx+FaxSS0A//U/iLkQIzECQnqGpss00ojjZCpk4ifrnH8v/r1 9QeOQXsAWNUGFmXq2eB/nis+1eWAh3LRfN97GT160Ab9tid1LqHhLYYnBLfWsC9iistQdYzvAPmL gY4Pb8OlAAsa3CmXdIrls4PYVJe/LIABlFjDiMduxoEmnsf/1f4hYLoT28ayJtVDnzAecDjpWnYT WKvgO3lPId/mYEvvgV9I5roeMmnoiKaNLeSRbcPJ52cccDr0rPhuSgnQvk9kOSqkZqZO+pSdncq3 aiLa7jDyHOFGdmfWrFqwdkgjBklY4jQ96kG7u425iaNWEcSSM58uRs8w468d+lUY1ZQQc+nFUo3E f//W/h7trB2G5D8py0u48qPWop4grbYmUjoMHAWvolF9TyLu1ijeR+ZhnyHHAbufer1lOIomjcAY HLd2okrOw+Z2sZs8kkjkQHamc7jwau2UgRWQhHJOGfOQvuKkkqXC+ZPsRScuAdvIxV1LBGO3cA38 PpW8dkB//9f+Ge6i4ULtZVPJ6ZxUKqqjhQCxwK+oPJUmhqblZo4yzBTlmx8orUhjjI5cuzfIdv60 WE23uMmsyxOOFTjDdcVX+ybMICcIfMOOtBdPqQSTspEZUCF+54cYotpCJCGQNGy/I4+8CP8AGspt PRGh/9D+GgW5luCUbaF5AYZL/hTLy3RCFxIHxnbjj/PFfQHnNpOzKxCgr1IUc4HQ02O2DruJBLtw nQge9Ayx5SkFmITb8ioRVM3BichCSF7YoAkjthIpnLGQ53tt/h+tRTSSxSh0Hysu0gUAf//R/hRt nd5dg+UscZPArYNuoYLKVYEZDHkCvoDzxwZv9XF8qBcEjgmqAVgfLR3wWyxY9aAHtHDG3zlTwGBB zmnfaWUgEHaRjIHSs5rqS2kmi2N8yBUO9SuBjr9azpYFtxulLFmbbtIzj/OKzIi4qx//0v4VPPdv MjQEE8ABetWksLiK2juZcqkjlAWHAIr1pK6PPNCxtjcPs2lSeFIPDVHdRiOZokXaF6995/xrOXQC hLayuQpypJ3FQOfpVhd8IXEhV1G35Thh2waTVhx3RfF0Pk2pgrjfxV59QdoT5YbyQ4Ukn5SfpVKK cWzZ7H//0/4bZrthJCgh24z82OufWtdITDp2+FZWuJmxN2VB246//rr1YJWPPMWVGSN5XiZsfeUD jOcc1nmRcY4UsNuKbgmBp2gVtkSLuZeVGMkH2q6k8skhNym1gdoXb9zHFSoNSGlcrXn7xvKjbBHJ OcYqG1hV0kKoS6fKcDKn/az+VaCP/9T+G+Ldali54YYwOoHqKRU2DzHXepG4Adfxr2Dzmk9ylHG9 2+I1IBJyBwAPc9qYqDzhDsYiM/P2yAexqZOyGajGOSJjOCqR8xJnLgD1P4VUa6UoI4huLjCkdhWV 3sBNarKY2UxvkHBG3lfXNKyTQqsLNvLncMcuOaQm0tD/1f4gbeVZJHhwiM0Rb5uIyVHSsm9X5/NW PoAhI4APPSvQPOTurmat0V8yM5J/h5zz7VbErGKILbqjLwzDO+U+p/woM5/ELDcPHIW8vkd8dKs2 8iNcZkDeWeSdvFBAahIoupGtpJPsjAeWsgwwIHOfx/pVGO+mh3RhspJ1yOR2xWMlysuEb6n/1v4Z w8E7bSdsijgHqamgyC6MXDJzGeoNdB55rZVbdgmPMZOSwyRWeBNGyEyOI5fkWRVzsx7elBrBaXL1 vGWgEk3SNiN46yketRpFHJI8nIXkKnQZ9aCzOlebZ5Ckg7stzhQKsWtvvWR1Y4hXfJjnj3oA/9f+ Hq4udrBnYiMIBgrtK/5/rTJIooxC8aq8cgzkHLAnpmug5xfKmEsawzFFdhnYMmtFYrVbYxKZTcrL l5M43exFAWI5fs5hfecSK20qRy30qpDbLcOSsTeX9xQw5oAdcad5KJIgRF3FcBgWbjnj8apxyywI fLbyyOUO3OTQZzXU/9D+IcXqSx4CvCfKBnKtlJDjDA+x9KrXMRjt8wkjfyyE/PGOvFdBwRV2Zyyv cLFbkr+7OFaT7wyegrStybSPzVRiWbY6HpgEjNTJ2RslbQnaS2urdhKirOp3ouPkGOnvUccBubG5 njiRZbUD92HAEuemB1NYjIYvOgErGJB5kG0qTyCfb8KfYzaHNLbWOpNeWVzK7RrcqFdMFchQpx6H vzmgD//R/h3hWRJGQMzJC5RSeDJgkdKvanuiji8tFjcJukMfVvTd9KDnE0KxtNQjupb+9WN4Y99t CjhJJWBHB9sZrbnC3cSCK2e2t4mC+SWyGIG0t+JBP40EuN3cRLe1cqbhFYwZVDn5AD146VSvJIF8 uS3BSOPI2rjY2PagJK6H2lvbahb287TiO+llk837SwjjtlQfL859ef0pdLWXU1NnAhgcSljMuACA e7H1oFBM/9L+KU6dp+nCcRxqJZRmUEAu57kDtmoReWscaCeIBZBiJ2X54zQc5o2/2S9CwXEwa2gU vEWTeUPoo9zVGG4lNy0L3DXO9tiTTACQKvCqfoAAPoKACW9+zbjCX2BuVH3mb1/z602XxDqB2QLK 5CgOF6DI6ZPtQdBL9pvdck+1ORLewjY4uJB5ckagdR7c1jok6XawzRoLcvg+UcFQfQUEydkf/9P+ IJ0jjuriKNXKxyEL5gwQM96yJ0852VAqkNnHWgmMk9B1rbfbdRhjcrbIXVJW+7GgGOT+X61o6ndp veC2jjjtEwEkBIc7e/44oKOavZ1ji2y5aOXnI6n/ADwa56PYZdqsGR+DubAT61yy+FnONlgkt3Cq Y3jYkqVPzL9a6TRrl7cxNKAAWwHYEqg9a5p7Af/U/iql00SLcC3vxbmS2zaztFnc+AckfjWd5895 cRPe6rPcXbRJbBZcJb/IAoIPUZArxZaRZznVxw3fn2+W3LbxFEkk5Iz6D0NWLW6uLUTpPJDO8khD tEm0jBOF6kjHTrWJOt/Iy729WW5t08wQoHywZv8AWHGAKnEF7qFldRWl3DZxZ3GaaPdG5UfdOPx/ OgaVlqO0HRJdQaMtNAkKK/265fPlxhB1QfXjmusNvHptra2523bPMXjnklCfK3ByB6Y6HtQbxjyn /9X+Od9GsLe7a+sQqbyrCCVvMGQPmK9uTniqt3afaCs9vY27Jv2yPITxng7VOcZOePavnZfCwEdr azD6fvmnVYld7dozDEGYZ2Rk8HHTIrZ0GOO70+canCkcdkhubGDzcmDLKmCT3+bt1zWINaWLSTae 159nMULXKWyi1nSUNHljl89e2OldDotlcWrQNBctaxwXRlePedspOd2fUHNZzTvcErKx+mX/AAT3 8KaV4o/aT8ARzmYz/wBsW1zMLdhLJPFGXO1V7YYqTjrxX+hr8GbCOLwhpEZSQFLCCCNZW/ebUXGS O2ccj1r8e4wq82cxg9kjgy+d8fVXZfqf/9b+v5GXyxuUq6HaAOh7U8O3ygOQBzha/lZNPY9RTsrF 6KckhTGFHfPGffNZ96Hcv5Jx83XP+fSqi7Mand2YsEhTasm4kL19atB4yDuG5sdGOCK2TT2LK7bQ 3ynnHf8AGnRSBc56g4xVR3QH/9f91GupHjjW3Ub2blh94KOwFWVmtZJjGJdhaLa244wccmv5Eckp sm14pFaZghijicsE48wnOSKhlSSZS7bI9oyCOC1VzLYaVm2CMJrYxSSRoQcpJMpYLjPUYP8AKvxm /wCCmfhcTaDDeXkVrcE2kstq3+ttMqmFZePlYbSG9qWEly4+nJfzI58Xf2Dt5fmfx2ePdH1/+3Da rpFrYaNdyvemZLwT3doxZsjb7sCwA9ua4vUH02K3SK4M888M4jjGzbkY+bP19vzr9+ov91Foms31 P//Q/jdkjhutImknitYXhuiLIc+ZNkfKMf7OM56VfibQbbTbC3g066uZ3LTaldFSWdjjhcHAHbJr 485YK0Snda3JLALE2FtBbSsSsq5adgP4W9sY6VlRta3yhfMWQO5hZB0jKnBq4mbWiO2t10uwjksL C2WWdLIXEsisdsQPQH3Jzn/d9q5WGx3XEU86geZKZCkTb1XDHjP1FalqFi7qtlbXcE6X0Ud0LmMp BFOpeOMj7rH6dqr6S1rb26aa3lRhMqY1H7rA/SqjG4qfY//R/jqEEPnss+6S3YYYB9pRe+Kg8SXN tJqCyR2VsumXlvFBar9paWRGjwshI684zk9cn618/GPRHPYivv7P8Nm1ureytL55pFDLcIxt7fHO 2NFPOcd60LmN9WtzNLDDYx3w8+Gx2BZoj64ySqtkYHpWkYdWBUtNMsdPsTp6WkTX00LQQCS4aRY5 GyVO488e9Z9xGbLS7SGwWW5me4Md3bxIFhWTONwbPI/l+ta2925UPiRkax4chQRozPJaarta4Hm7 haTKoyzYOVGRke1eG6koguJ0hKSRxSmMmNvMTIODhh1HFdVLYiotz//S/g2YkBkRiN5yqnpmuk0y 7jUJDMjfNHsLMMn6A+lc5xU9zprHSoI5ILjzJWVGyWiBkdQ348/SvWrCWC+y8oS3sIUBMs6kPGFO MkY+lBqT3/iTUtHvLU2dpZ39tZ2zmB1g81nMmcl1I6gHAB/pzn6PfxalDLPKps7tpi1zbpEAmc9x 2P0FZzA2by4D23krlFGNhHBIHWooH8Opot/quoeJlinkjFtplug8/wA98kMrYAwvXkk/TioQH//T /jOgmu5gkbLGsG0LBIG3O3PLEdOe2K13j+y2uJikkrcLjjHufT6V55zjR9quUQxuY4w2xpF/5Zev 5/1q/d2duftENq63RtEEymWMo04ABPABxj+lBnKPvXMI3djrTG08p0ljQyPCqbYwF+8oPT8KoNbW tuzRwi3t4y3mIkSBMMeD07mtYwtqzWzLFrYLtmIlkRj80cSEnzm755+tSWaRbpGSVFaHiVQRuUns RVmco3P/1P4yr+OQ3C3EEp3pbkSKxwJEXJxUaagyWd1bo8T2uqQJHe27x7mUo24EZGQQfTsa5zkU LblB7TS5njdJZljiIBcrsyMDjHse1V7i6hi8uNXZtrfIo+Vmx6flVQdmTyNFg6vHJahJcna+co+C xHGD6/jTbeO61RkW1sJ7qRU2+WHAMY5966IuzJSb0Rmwxz2bbZIDFEshykjBmTHXGCfyrRXUbU2c 9qI2aW5fdCzjCoM9/wDCti/Z+Z//1f4kpYJI8lxxnLYOcgVftbiFSZFSO0jQZVRl/OI9RXdD4Tgc WtzIvLiXUJ1+7LEHyFI2D6YrXUTSxzJI4SWCLesPd+wA7CqCzsYIlhljWF7fa0VwZHkK43njg/So Zp5XkZdqlZSAgBwqgcVTelhWsdFpOrtpUJs7FLd1lYvKxj4dyMEE8EkeuawVhZGlCKZC8zO/GdpJ OcVIH//W/iDkiNkYpHDkSnlF6HHYiuntr2xEAVJ44SBuKuwRgcZxg/54r0DzmrqzOavbhrm5ErIS uNoYjBwO9aSv+4EazObbaZEUnKqxABz+VBk1y2aMq5iS4wGjJZFwJoiWQ9etLBaTeW7shZIBueTo EGcDJ7ULTYu94uxaS13QmSLJEh+Zl53YrPdLhUlWBGjGcArxnnmt1sZH/9f+HZLm5hDW7Fj5mNyM f3a++PWqQjVrtl3YJwYz0APevejseOX/AJVcu24KTzg5Bx6VrG6hhmhayuJWS4QeaAfLMeOo21QF DUNRhNxFDEz5UlnJTCsccAmsUSCef94quynC46D6V0AdKkyJCsDKp2LvG3gE+9c9NbRLtZcNIX+b OQRQNOx//9D+G+FpFAhZlQlsrn+H1xU9wIog379Zdh+8i5DV9QedFWSLP21Ap+z3TwvtUGyT/Vy9 QS3oB/Oobh4leMIqvLgExhsCM+tAXV7ELM7uIQGjeT5uRlTiqU8kfyDzRI0b4KgYIx1qJuysMV9R iuD5Uam3GzBZOgI/WoDdxxghh5jA8MP4qmEb6sTdkf/R/hiuWdJjJGTFGVB2Y4UY5qhOVmZWgky3 QivqDyG29yw0bmAIQGlXpyMmpbMmKNWkQ/K2Qp7/AFqoxbEJJbxTh3B2zli2MfKAT0p4UpGqM45G HyOv0q1BJgUJwFQMp4BwQep96jiwrJJuJPTb1zVgf//S/hkkWKaNV4Vgc4HUVnmKMbuhcNjk19ge PsTvCjAnGVwAcdvrUEyxW8bM2WKjA2DJoNISfwkNvd7pAq4z02d6ueUJZGZhtAGMd6C009ESvdGJ SoUsVXCHvxWA7yyzqQzIqHOOmTQM/9P+FGJEfyyW2OrZz1yKuyzhU8sjkDCN6Z7ivsDy5voY0MbJ Nl+SWyGNXBEiuXZPlJwM9M0Ga02HyWSKyOwwM8c1XeP5mAIxngjvVQ+JG8XcbCrxBg5DLnDFhzit YKqW6yxOzKeAg4GfQiqqdBn/1P4SNkkcjK6EpLkk9NhqJosMirvJPPQ4P419geeWYrjy1IkLMycI p+6v4VLHIshJePduP3R1oA1LKOFleIuUKHgnvnPH4VFqFwAUQMFMeV6ZJ7UAUEkRsrknH3j3ao0g S4m2xH5c8nOOlAW6H//V/hnNjEywNISm07AAeD7mqkmnsWchgUjBLdulfZxnbRnnpJaIyd8fypGc OG+8emPSr4kKqxVjnHIHUVTmugWS2M6ZiDuUkt6HrUkMsixNHKMbzv47Yp88QLcM0ZSTdEJSw275 P4aIlQYjQAHG5zTTvsYyVnY//9b+FQBV3LHGHbk5xnp/+qrMTxGMBlBfqwxwuO9fcHkNWdjLlYGQ 7FPJwBWilpBFGGlY+YMMsYHBzTSuInYxyoBEqx7ztbt6USbPJVncZUbVwNx4/wD1UNNbkyv0M2Uv IFYlygJCqT0969B8J6BaatbXcmp6nbWNrbQb8Od9xJzjakfUnv7Uij//1/4ZdQhijvHtrdJLmySU rDcsvl5UHgkZODTbqGzYQmGfaRxIoO5WbtmvuDxyL7GHQzFlbZ8pUdVqkUJYpuzg/LnjPtQRGTbs SJGIGzJGMs2BnvUjlXVy20ED5R3roXmWT20Z2bx2HLHnFXIYo2yYZnlYjdPlMKD6UAf/0P4VZWjh lyq5KnO0dBVmVldVKK3zDIJ/h9q/QDxysrSxgo27bJx05FWYFuA2GYlV5UnmgCyRGwJlHznAVwcB aruW5G8sIuVP/wBaga0ZNp8skJLygFcFssOABUUt0JpcqcKeMKvWgb1jc//R/hmjWHEgkYblXcqY ++fT/PpWvazWpSEy8ANgqOw+lfoB5TjaNy7qN/aq37kKAqAxHdv+gNc3IHvCWIVO5Ef+e9BBJbuG m8kRiRol3MGcK3HpmoprjLsWyGY42H7oxwKa0YCRy4UsfXA96sRyLPBIuGUqcbsHBrcmTsj/0v4Y 4WWASG6JLbcRY5Oe2af9qmZkCkHA5BGBX6QeDF+9dmfdeavzFgSzZ47VPEHU85Oem6g2LkcXzMHZ keZvlBPTFWZcgbEJyoxv75oGm1sV83LhxyTjPPRsetaFjKTComDNN02hTlQKDSD0sf/T/iIuLKSM ozb4vOXKiQbQR6isdpBKrxMSig7eeS2K/SDy5voRiC38lzgqqnGRzgmqwEgBRgSg4BA5qGvfMzYt 7SyMEaqZCyje288Z5qhPEUk3K+UPTnBqo9SHG8tRYZJBvjc4ycKSOgrPuVlZhuYhR97aetMainGx /9T+F2GFVkSV5W2bsn19q00WKXcQ5YKP4VIr9IPBtaRTCj7k8jxozAEk9Oa1II7fPmK6NGhxgtj6 ZouipJJFSSVYy5y0jOdoIPyIKqwF0mkyyupPyhegrFybIdr6GttkjQvtBTG5AT39qyZpHffuQA9A QetSI//V/hUW1dkB3lWz/n+VX5bZWi2GNpJAud6nBFfoB8+RW6BQFc49jxitLLW7bU+ZWXAz1GaB NaplSZltFdyfnPqepqvEkl1iTIL5wBjmgZeFixBLAloxyOmakW0OFYnDNk+XjDIPU046NAf/1v4b khikkd3cqE6c8mm3E0aqqKc5bkdhX6QeDG6aK1vbiQtIzHyy3BHanm0zu27QQciRuAwoNOZXsSRL CsDJIxWTfuSRT0rREMK2uMsZCv8ArqdtLi50Y7W4KGR2LbWwCTkse1WXuRcqiysVMSiMDGAoHApG bd2f/9f+GcIj4KyAqPuEGqs1uyuNineTkP2NfozimrHgXdrD5DcABAw5wSmKdCJghwxHPze+Kz5H ew1JrQt5ZxueRyF9+BUgv1LRIUXCjDFuC+O9HLLsHOynPO0srThR5edmAOnalWKYxCaEq7RvlQ3B Ue1Di0aRlfQ//9D+GtLqJQ7XCq0p4VFGVH1FUhIVbeVBMknCgZCj1r9APGbsrk05U4TYWDck54p8 UePkUnGOmaATT2LXkMAWYgrjAyefanRw3LLHGW3IhLRgtjy89effFZ1OgyG7u1lWOJEWB4/3b7Af 3uM/MSe9OtNgDSLklO1ZmT+M/9H+HB2Mu8ITxyM1bt7dILOSWchS2DGB944zX3B45i5LndGjqCfl B6itO1xkI24YOSu7Jz60W6BsOuLaOSYyMXMm3GAeT6Vl3CvHtlhYF1+8DjAH+NZRg7q5KkmaulXU E8LG7klQAYXylByfcVFNGLhgo2nb/ERgYFa2sUf/0v4eLeNCxjOwhRww6KatXVqsM4a2fcEXDSA8 Z9RX2zimeOZt1O8MagE7XOGde31qe3kMCguXdcfJxleeMiocLbASW1xjzVCbGcEby+NufapZIFMk f7sGbYNxzkH3puCSuBHekRYkTBQJtmjUkhfcf57VC9ubiCN4pZtrH5lJ+U+hFZjbb3P/0/4crW68 k+QpLANh93T8K6F9USe/a3ttttHJbpEkajZ5R2hd271yM5r7A8c0bm6tLeSFGYSyxLieXGQDjHWs K9ghvJPNTBjU7sZxnFAbGe8cLKUiTMgPAPyk+2asWTx20gidNm/JL7/ljOP/AK1A7tu4y6MUsyOS ZERuRU0F2AjiQboicOFGNnpQ9Fc1Ukz/1P4hJpt8TFY90edqk8k1ds1iSJZVRxImS4Ddvp7V9cpJ o88LqX7SrMVb92uUY8FB7VmQgFXwisxIPmN94CoXLyu4GxGluwJjd3IQKQw79yKoG4W0Z/JYidOj 5PFQJ7FizSK/RQnmfaC5M393AHb9aYdN8sySOSFVjhv8KDA//9X+Jy3vYYUELcSldxlB5OO22qV5 PcSRmVQr5OETG0qB1OO9fSShZXR5Dd3cynCzLFE7OXckIFTleMnJ/Cr0UMe3ZEu+UHaQ5zjHXIrM Q2MGORlcq6I2QAcBTVZ1aKZwFVkZtxPUc1cY3abA29MtbVvNe+fYRgQiP5lKj09Kt6o0Db0tnUQo gMO7hjj+tE1Z6Af/1v4driWSVxtLCUL8x67qsW8QZo5buZ44c7dyDLtivpKa6njlmIRrP9oilcRD Kor8ZHuPWrM7JJAT5UZdjhnVcMQOnNaAU7WaK2YQmMAKSwb1J9afeX4kVvLzv6Mo7YrB7sBti65a V8YyG2MeMjvUU1xNJKwjUMryDK54AzWlPaw1sz//1/4m7EC7fylIEgXo5Cjj3NZlzI4kjhCFWjky zDsc8Yr6g8c19XudMSwS2htBJeySCSW9yVZAFxs29Of6VzcAFyzwHcAq56elAFuzt5HV4FlEWD94 nG4DpVZ1jFxFDNgAsEMzDpz1oInfoX7+3dY1QH5k534xvWsnyxIsStvkaUlS68mMD1ot0FG8Ytn/ 0P4jbaK3aHy1ZU8ttjHHyovHzN+tUGhs1nkzJuVSSrgnaSOmK+ljFWPBhpInkllWHMRYlWyT3x/h WWu+RiFO15X5zxuJNVyq1jW+tjUjzFFJHIqytsxz97PvWSGeKUOisrA8diD7VPIr3Jk2ti4l2YTl lEkigsY88HPqaqRTZV/NTac4wvJAqkktiOdn/9H+H+2jZ9/lSDyWG1zJlB9P5UrwRwKUJTYrfM5P zH6V9RY8damTevFvVQ5YE9egFTiPIKnO4Ljbj2rKatYCEW4UKr8OTgrn+dSeT5G9FfPBLZGMdOM1 FgIohLkFdi9/m70wSSK8iPkKVxuBxmtYPoVBJuzP/9L+Gm6A8qJoQwKDEoPIb39qq2kguWKP+7EY OM/xYr6VTR5PI72L5T7MgeNgBJ8uMc1HhLPazgvuGVAbDA9jSU9dRNNblpbiSaJpGQbVHXPJNNJj 2ZcsrMuVZemPSiU1ayLp9TCuSRxkSKx4Ixla07SJXiQIrNIRgEZJWszQ/9P+GzyXChw7GRG+8vy4 NZ011cSuVZ13K21j3NfQHlz6E6PHFvBKnA3HnJqGOZjP5qEtuAyCMDjigUHqXLhH2o7gDzFygPfF RpbW5dW3DaRhx1570Go9G2SMsbLHG4KkLzRHp9ykxljkjKqN/wC86Z+mKA2P/9T+GFFjYsS5M+eS Bwa0YgNiGUJgnacjkHtX0B5qkmrsfLE0SiQ7d69l+7g9M1RMRZA8hwfvfJ+OBQRzuxRNqQ5kcBSe QB0Iq/DEREDjMR4JxkH2pStbUgdCwtieApVtyE/dxmormRZ0BcqHLEnA/lWAH//V/hTgDGbEZJIG Dx1omuLpP3TyStFv3GMk7A3rivYPLhfY2tPaQKGEhDt8sYAzj3q1cQtZzQGRBIfM3NK3QH3pNJ7m hUlkeMyyA+Z8xfgfMg6/pTLYQTKbh/kIGdpPymiS0Y4rVD4j5jsW5SQ8Moxtx2xSL5Ycq2eD1XoK yXwtGzWlj//W/hwikVZRK8fmwq2CDw3FWZr2+uZN0JNumcKIV2ggdM+9evH4UeeS2qyOkh8xw4yG yPlzzzVF7CLaHUNMIjvlkUYIGcYApgW4JIraVDb4aPyyHeTAfnnAH4VZvZotkcjMeVyFHU0DWhhQ W7TLI5YKXyAz5yp7VLBP9mb7M5OQOdg+RjQI/9f+GqTM8glUDzIT/q24Vx71ZkuCGlljt8tHBhok B8sfifpXsHFNWLdn/piBobeOziZBFLluCcYY59/aqNyoikaLaoKfu4yn/LQfWs5tbEWKptnjR1wW 3ZYKSSTS2aLlEVVBB9PnxWZMtEdLDNFHHGFbzXLENu+ViM9/p/SqzRvI7P5Q3KcKyjkD0ppXdjOT uz//0P4gpbWFEUyyGJQ2emW/Cs5kQuDPI6WnnBSwOWPuK9JxaPIWhf1U6Ii28lhZJDMkYWRt5cTk fxEHviseKdXywG0ocqoGM+2KkROvkzFHX5SP9cjnbV1mtk+XIKAfMFIO0/8A16LDas7FfykuFcOw URDcgA+97VmNCJDvChQOABweKmSujaKskf/R/hfMKZU+hwX7irslxFDEkYVW2vuaUZLsCBx+FdcY 33PPLUYuZoJJYFVjGu5Y2J+cVuaYIr22jadQslsCGjXlRnr+HFV7NFRk4jp7aGO3SOMqgeRmZQ2W PvjtVOO2a0YM8m8SnKqegHrWbTTszWLuiPU7SIqJYwN+cSKh+99BVIj7C+IlYs6bXz9xvSkM/9L+ HCILcPM+oTTPlMIgXIOBgYqIQyw8RAhcbgzcZFdBzl+wlcO0TOQXU4OMn6/hVuWUKxjjk5C5Lqu5 h/8AXoAxhGXm8tpXUbtzEjkV0ENw8IRTl4FX5cj5zmgCrdPDIyyE7U6YJyFzUTSJdp5MWzCIF3lc scdhQTJXR//T/hzlt5iRBAWWNGGSVIDEdauygggXCbzj7wG2ug5IKyM1rfe/mJneG+4eAQK37dQI VZQXY8DAyR64FRO1izNvLR418xH8vJ+YKcls1kvI8DL5cj5yGCk4wayA63TLHTpx9u1LVGtS6eVH aKvmOW4O7HHFZ+p6bDJIrtKsjQEMmANx9PoaBdbH/9T+I6O1W2tGuVYSsygbT0U9P61swaJPqFnJ cW4jkaOHMgDjzGx1AXOT3oOc4m2itoHnlEWHmfDTK5ypUY24rVtbmRA1xJcBtgIRC+BgdsUAT3Ek vleZAI1BAlkU8PJnFZtowuJJHVd6KpQru+RD3/Gi3QDoPsAn02eQssLQR7wNvDAEDB/OuYsPtVoJ Z43uDbPPlh5jFN2OMjNJK2iA/9X+IR76R5Dli0pPJc8ioI5BeEQNk+XKfmXnOOooOc0rRisiyxuU RH5XPzDBqtdPA14kkRmUMW810k2KG7En0z1FACXN3EkUQjlMsqja54K8cZ//AF1UjWSRi6ODldxB 4Io32Hd3LlvHcW2LgPlS5RgjZI+o6+lRsWR/tjzOrh8HcdqY7YoBtvc//9b+IF73zwwhQSPK2Xn5 JPqKqQw7JZS0YZHHMjcMpFBzmqkOnywJsklW5uJBG0bIBbBFzl92c57Yx2rLvxZx3jW6+Y9oYtqT FPmLAcnHoT0HvQbtaWOR1GJgUAEiqR8qyDBFZKlVfyDhWPO4dq556XMC66BbcxjJmLD5z0Ve+Pf/ AArUsYv3Ox5WRQMgsuSPeuSewH//1/4tNKe3uIYfOfIjhVBKeAcKAB7dKybrS2t9SiklRbiN2M0e xsbevPsT+leJPY5zat9Uvbi6djauosrfEVv5JWKcqMDLdDxUdrJJdSuzwyWE0o+0qEiPkn++GJ6E /mc/jWQGkdC0xJZNQjaOW5aMTNZyvmEMOAy981Ja/wBqGCFP7JIkvX3pAW2QxpkjeDjHalHZAlfQ u3CGO2eyMvkRTcSQJ8m8ehxVP7W0FvDbtD5ojkHlfNuZVHGAaZvJ2R//0P44gLh9NV454Fd7kgRy BTcoOu0dwPeq1pcXRu7YxW8jrbyFrlJkZbdgOOfXn09a+eewF+7NhcXVqbhSyxMZjswxDdsf571z N6ZtQYqgZYjLtCZKMCp4wPXio93kE9Edja6fa6fBasGkkvuZXMyhd3A+T1A/wrqNHlu/tK3F3EH0 +QbBE3DDOeQvU+2eKzt0BNM/Z3/gjX4T0zV/2mLe40m2naPTbBb1ftULzzQvFc4eOMk/KCWXI7bB 2r/QB+HOmxWuiWKRSGRIoV8uU8PKGG/nt3/WvxPixN59JvsjzsqV8wxL81+R/9H+wScKm0AAL1PH Oaq4Afdk8noOpr+Uqe56BdmZfLUIeo+bPBFZ8bbXbDFlU8gn/PvWo47ovCYBjmJdu0BG96ilAL+b kICuG5xjHetaexuNkj2qixhmYtkt6D0pH2rkkgHP3c1otxLY/9L9z2htnmtWV5FjDnhX8vf6g/57 1G0ccUxOM8/Umv47lN8zsCXRFS9u4Ymt4U3LMxL4wdoUFQT+o/OrNnEweeSbcVkORH1UcYznr6Vo tUFraD7qNoYVMHlzySHc0WSAFHYn1r8vv+CgGjXF18JbmaOCO6NvrRtDbBs3sguIZRO/PRYgM479 K0wUebGwT7kTSlHlZ/HH8T2OneINZeFYmtI7dIbPBM7xRx7vnPb249K+f9Uuku0geKyh885DySSl TKp6Y444/Hmv6Bw/+7q/ZHLiL3sf/9P+N+WGO7MNwIhZoqeTFBuMskAGMsD/ALWM5rQs5UsHazka OGC4AkjnnbaGZc5BOMDivjzmjsjB0q5bU21G/u4jC4v5LXTlnhC2U6qMnL9FOMduaa2n30ItZ9FT Tpru7mdLqyEvl29qAOHMh7kg1rBaXM0nZGzY3DSSI32e1tnuDs1eSNWaCKIKQCWHJGT9eTUek2un WlhO4MNlNHdeYtoGYrc7ycvuP0GRnvWiV9EU5Wdine+I4HN+L61e28iZLfTms7cy2l2x27yGBIAG T0zkioorKWWxubi2MaOvzPM6K7kDsmeQfp6GtYx5SIvlP//U/jZdcwQzRzmSRsRSq7jzJCvcirVr YW11Z6jcXdlcPNbhWt5lUlIdpO9QO5bjgc8V4MNzjc1cszabeW1nHqFnNa3ls0YP2S5byL6Fjj5d h5/TtTDImnyTm5N7dTRwi6jBhy+84/dgnsOeetbFc0TG1LxE1jeQzSaVtyEEhMbOjluAX54/Ct7w xYvKP7Q1G92aS07qbeBUeSOV8srbS2cDB56Va+B2Li7Mx/EmoQWq3CRkSxSB4XK/KZgVII/EcfjX zteKtnPJG0CwWsibrfb6ntjtW9PoiZ2sz//V/g3aCQMJM8Z+XHate2lYNGqIr5+9u+9XOcdNHbaR qESB4ml8na4UwlOPwr0y0xfQpau6ptTcqrhQ6jnn1oNDUt5o7TywkJjKYZpCpDMPX1rbnsYJVa6j CCSQCQhVC7s8nPvWU073Aw70AXUO1kV4YMyAYbAbj7tYs/h2aaSaSaexayDpJZiORXMm4fOWTqOc /nUAf//W/jekDWGpWukWiRXVrJCPLuQmCj7VJXA6Y5H4UqyIltcwTFpJluGlSRhnbuP3fbb29q88 xcWh1tIrW5WxvIriZnLzQsf9Wy9z7HP+eKy7y4eO6ZgLqNJItryRs0fXhhgHPciqh8SJB7bSpo4E Ec0bQoXe6hkKPKf4Rj1FY8cqi5VWDFU6eYOT7tWxul7ti752r/2gHtYYYo1GFlMm1osA/MM9/aqm m2ttZ3F273kjSNH9ouftBA5JOcH+In0/Si3Qy5dLo//X/iou2udQvElhuVW3hBit4nlCoSepI6/n xUVoDLPcCVzB9lATzPL8xJGPYc4rCzMeR21LDRSQKsplSVGYsfLGEX04qrGYXlS6n4leTbAxGN/q APwq4Re5I37P/pAi2gRSXBYkDLZPXFa0llJF5UyFxGG2OqE8+n8q6IR6sLFWOK2ufmje5ivI5GSS KTAglHZl759frVK8tLpF8wFUZPmVGGBWgH//0P4krO4aeXdIC7H5ZIwMDFWdQt1kjWS3ICROEdeh B6Z9a7YLQ5J2tqRRQQtIgdBGY1zI8fAc9uKLmfeIYrd3W4lm8tpEX5iOy/oasteRVvFSExaaJFku pCW8kn9+xP8A+rpVW2WNXWN3WLY4Ewk64/pQS4pm1baat2LhoJIhDbDzw4kEbOAegH9KjhjnN8EE QEB5dgpIFBkt9T//0f4rJvs/lXLbv3kEWIo8ZEjZAAPp359q5c2thLcWrSlImZ/9IkzkIfUD+leg efN2u0SXSW3lk29yrqhZSXITeBxwKWxLojyu5S2jTLoiCTf2/DFBziLe3Vk7TwP5VnckwmONgJmH c47V0Ok21leQyoYZngmmJcTH95KR0J9unArRQ7gZ99ePY3q21uTZ2pbdAkahsFcZPPTH9arW2oWp 1C7jDGaxEO2Cdk2Oz92xz7Y+laJdEB//0v4e7popJmZWyBkcDhsVEIYJ7dZASHSXk4xlcd/oa99K yseONe5FuIwAJogxEQJ2gE+v5VU82WSeWRAis5ww27dmPSmNqwkyYOIzk7eWPODUdvHFChlnJD84 YDjPbit47IEm9EaEFyp2KclyfvdiKkuLSa6nDxlYY0YCRm5LDpxSk7Irk0uz/9P+GS7PkyyIcsIj w2MZxUsE8KogPJuMbVPJz0xX0X2/medH4UZ95BJBKZdhUk8sPSoC80kiyxcOvG4/xVq9ELlV7l6a /mVE5IlX5dwHFZ88zJMkpI/eL84z19jWLbe5RZS0WdfNg+TLZKHIAHoKk/s15F3GQRxp8zSY5GPQ VpT2sYy3P//U/hZkMtxKkAwQi4Lt8u/61TwkcjJgRndjc3AGDX1B44qThWCRo7tI+xfarcbybXXd gjgg8nitIS2iBeaH91GVk6R53dGz6GsoXGC8UvB3fL6EVoBJNCs0ShOp4PfFVo1mtxnaD5RwDjr6 0Af/1f4UFYyl334dzyO4xV5bVQEldSWZeAxwD74r7A8cjaSZX/0eMlEH79c43DrgD8KpmaSbDLHj PReuPagqFk9RI4f3izKnlyZweKuFJCzvvIxztxwcVMvhZUX7xWuTEoRo3kZ35lBGFB6cc1WGxgRk k444px2Rof/W/hQgVAuHP046U6ZD5URVsrvww6ucV9geQ3dkj+Q6KFZvMT+EjANWGt5pLTzSVWKM 5BHJznHNAjLlnmZ1VjnBwPQ1B+8Fwp3BNr5wRxRsbQ+EddNMWAYKxdskr6e9WY5jHtEOAEHQnIzT bvqyj//X/hTlmJAL7QCM7sctUTXPkqqkDaehAzjtX1jn2PPFaDe63BQqiLlmx8r54FQSmVJBJGPl YdQelVF3QEwlYFUEgUnnjrn60+WF58B88/xf1qgFW1RU+9gp8pYfx1HFbSWbmdoyAw+Un7p71EpW 0A//0P4Y/NN4Ixu8pE+8x4HH/wCqqs80QLCKRtpXa5Jxv/8ArV9endXPObs7FNIo1UuY+c/Ix6fX FaUMalMDyxK4C7mHy4pjEmsAJTlRJtXJwduagMEZBMn7kAYRuqn8KBSdkRvDEqELJzH94dN/pj1p I2U4jPylxw3TOOxP51pTMD//0f4VI4HeTKPt2nBIGakkgZWAyB6t/WvuDyprUjkgQRs8R81yCFGc BT6mokml2qsjZdV2sW6mqg7MgCnAy+FPXmpFIaPYp3bW2kYq5WabAsrCx2k/KicAdq1rNYRlZnML Oh2sDt3fjWQH/9L+GpopJE/dSfulblhyDWa9ntlLAEg9ADwtfco8VyS0LkDeTHsbjdkBj0f0xVKe MxuAwzn+IHiqgrvUinuV5JmcBXyQvCk9avWVg1whct7KD1JrU1JQNrsiqUY/KUI4FGZrQP5ZOxxt KqOtAH//0/4WZIUKF2JVj0IGT+VadrpzXSl1cbY03FSwUntwO9foB44txamOICQkYOQe341Ek0Yg aOIlz0eTptqlG6uAts0K/K/KdCWOM9qfbx4diwVkD4HcsPepAS8dZIWjjBjjjYjIG3dWXZOiydzt PPYCgabR/9T+GW7mVlYxIrTLjlecVnoJYmJJYSON5yOK/QDy3JOLHRF5A5wZXB/1fc+taVmnl7pU BG35SjnoaDMhnKO42xiObPzMOrelLMoLIrxlVHO8DJNAFFopDI2w7VBwu45DVdW42BId2TnLkDjN dBnPsf/V/hfJSSQqzck4Bxk8VcjiKkH5VVBlnxziv0g+fK/2fzp1bdwXyvy8YonjkjnZQpGwjGf5 0G0XdEypIw8xwSFPU/nVuFPMGWY8n5UzyPrQUTOgj3Dc0ZX2zuz6UulXP2af94MSg53Mo+77UDTc dj//1v4h9Z1me8KJ57SLA2YUc8LnAOPSsGZIjGzsx8zGdg6jmv0g8qTTSZZhKIiDONw5H8qqS3Ej yCERBUBwWHJaggsW0+AYxEwOTGrN91vWtyLSYpbdpHYhif3Z7Co5bS0ArXmnpYyKZLhJgEB2oD19 KzHMMrhArbcZJPAFU3ZpAf/X/hrLRthFQkAYORxU1vcxwiQBAuTxx8ua/SDx7IaYzdSAEZLNhIx+ mKoOpSSWCRCiA85+X86zS9zQym9bFkT28cSxqpeV+PmGV5pEkjtcM0W87stkZArO19iC1PdLMizm Mxgn5VX7vvVeBY7jceflyAKqMXID/9D+FyR3ikCspCoecDk1rwXVs8HybfMb5SWbBU+mK/RPZ6Hz 5lXMih5I8ZIGNwPekt5maMB2ztOAD2FQ4tbgSTRpKPnJIzxUf7yGZPs5VkwMkNgx/wD16QHQ2Nwy fOcu+7A4zjHc1XleXzp9u0mbII9MnoKNjRQutT//0f4Z3tpoF3S9GbK85A+tU5flOGySW4IGK/Ro yvoeMlZWNJMIiwvuXKb1K/dpkpBjAWUDb95MdR65qjOz5ykgbcAx2oThSeprds7WeWJnL7YImCl2 5564A/CqbukiDGmE6SzHOYgTtUdDjjIqONt5XKrswQwbuakD/9L+GK2tWTflsKPugDO6r8iFt24p GAvBJ5FfpB8+QRtFDJtkxKJF27gAxHuPTpVlI1eQLbhmG37h6mgCW4t/s21WXmRcsQchfrWLtJm3 EbwvQZ4wKANFGiMYiA+STO5cfcocR26ts5yNuQeBQ9g2P//T/hks1jefYSHZuWGOB71sjTY42PzA lzlVX5gAf5V+gHhXbjYpP5No8nmIJSRtU5yFqK3ZEbe6uy5yuRzQXFWRduXLxBRb4DjerltrKKbZ G3gVjKHnccBRJs2+n/6qzqdCirdQB/3iKQoOSR3zUdooBkVsrx8ueA3tWZk/jP/U/hq8wIxAzvzy uKjuJpJIshuAQAD0WvuDxxyRyeQJTjaTtCg4P1xXTWFjaCMkOd4TcXzkE0GMpXMzdtuX6YAxn1qj IGZpVwGDtuU4wV9qBJ2d0WGtFtolLkR+YmWGeSfpVeNkZhliERSWOCMig1i7q7P/1f4e7eF47Y3k cTPDJJhT29+akkvN4EcEQJGTIHGGPFfcHhxl0ZluRIpjIx/eHUCr0CedbeXFID5fG0jpQVzK9iL7 NKmFkRixxzjHpWm8JSDJXEhQIDu5GO9Jq6sUZm8x4+TcGXBGec+tXre2lnljUBoYGALqX2p7msLd AP/W/h8vbWGFituQGDfeU7s+1V47hT/rm2ySfutxHOBwP5V9ha2h4kpW0QwgyukckspjLgO46v8A WrxjaGaRQ48ngwLnnb7+9AvaeRnyt5bGbBAzjp3p8W7ERZV3O24B8YI96G0ty001oaU3kIh+VA/Q FehPpVPy5ZInKxiJScMD96T8Kwbb3Gf/1/4gd7W6BJcAFPkJ4INVQPtIWItKihsyhDgsPavqDyLt aEYby3EImkaH0Y5IHpSbHVmZAzqqkjHXj1oN1qh1tNcqS4YKM5ORkVYjdJ7gRs4k3jlwvH0oJkvd ZpSSJZBI4vkkY/Ky8cd+anW6a9eOBk2c7Q+cKc9z6UGJ/9D+HW8jlsp8qryhnwZ1X5Vx2p0t5KzK +diqu3kYP5V9RboeOQmZgRIjFZCeoGCa0LIEu8vneW6jLb+shNYNWYFa4WRHfY4IPLY7VV3SBWIL PxgjHIraKsrAW9PjkWRJAzNu4ZScAjPat/UYUaJCp+ZVztA/z0qZRu0B/9H+Hnfgqsi7GXow7j3q xcmWJIQE85GYMsZHDH0r6dLlVjxwNuzDdtYqD+8QcLGx7fpVyCMDCrJ8pOGjPzYpgMubVssgTc5b crqPlQe9UBaKHZWn25+8wGNlYNajiruxHsVJPLim8+NlBDhNm5u4x7Vfjspxb+c7eU4k+SPH7xgO px6Utjex/9L+IuJZipdD8zc5HBOKZG8hdM7SzybGdhlRj0NfRczPOaT3J5AEW4UyK8rABVPOweuK hhj8uI4A3nliPvNU7CktBih88DBX5tv8X+f8azpLmGSUErvVG4OBlapSaMS6t59oJQg5xhNx6cd6 pmfZKEkzEiDD7BgtQ5N7Af/T/ij0l7GRXjkZVhmXaz+XuZMDuOtYH2ZUulEarKhlyqN9wAHoea+k jNJWZ4MVqR3rSGWYxBEVxnZGflHsKrxSJFHv2szfdORwD7VotdgT98tNAksbO0jQSAbgO8me31qx DbCW3ZniEkoUhEUkliO9K6vYqfQwpIxbzESK5LDPTGznkGrjrHIrx2o8x1ALHbyM9qZFrH//1P4c pba+ht2yfLUkEIOW/KmRlm2i6ztI+4xxj0r6g8WHwod9milUAGPy4juDg/MaHt5hCtwkmCjgBkOS 3saCjVsrRr2OS6kCoV+X5+ox3xVDUQvmsImDZUDavBXHelZbAV47UnDKzbk5bI4+lS3durbGcsG7 Lj5frSjHlNKa6n//1f4YHadgyKR5YOCO5xVmwRQ67l+UjB9e9fRd7HnmoYItzGOUSKBuAxgxn0rJ msHaRGklZlbovce1SJpPcsrCYUmQY2beWPYGolWSSM4UFAAoc9Vx6UBG1tDNkjRW2Nu3HgYrRhm+ x7WLBsjHy9VoGf/W/hpkv4gXkCt8w4UjAcnviqT2jyMkxQRlznAJB/EV9AeVPcfGscLEM2XYbWwM 1CkEkbOobK/eAXrSbsrih8SHi4leVY5UIjA2xk9P/rVo20MduZHlw6lcqO4rLnkbE8cVsgMkqMYz 8xQcMBUE8zSo+wbQV2bV4wBSUmhPZn//1/4UVmSOUMzSLs5+UbjJjt+Nb0UM+oPJJbyRrDbwCaRX Ox+qjjnGeele05NnlRjdEpEqzFDIChXDZPWqbRSwFhtYws3B9T6Cq51Yi1tCGVWYZPY4RSfmFb9k I4LCZ5tj/J8kZ7H3/wDrVDbe4HPzP9rwACcfdCcVDM6QRhG+Zl+8RyRSA//Q/hl0wYZJAy5ZvkPc e1Tah5LGVWQLMxxwuFXpzivXeiPNgvdIrO9ktNqqgcxtkbhlT71pidXi82fM8jNkxtwg545oi7oo zViAYsZD8zZAHYelXJbeFAF/cqyxn73BP0HemNOzuVY5THHFGrrlQd2RgipbYBmfCkr/AOhVlKNn oat+7c//0f4Zp53SV4GCg5yoAxtFaEN1JCPKaMMoQFGUZIPvXrx2R55BLNOQUG6NywLqOGI61O7s bXMW6PjEg7P64pS0QlJPQpRRNIhcHhWw2TjH0qwdnllduUUfL6GsrsY2PAZdp+bHzIalWByXmt1B mDZ3Ou5fwFPmYH//0v4dDGXlUTMEd3EbMi/Ic9auzoId1uqO0aLzKRtST9a9OUro4XJsjdIvssfk sI1Vwyru+Z2PX+tS2lm985jlPlso3QMRwcdagRZn0xfKd3mdZEIWONF3B+fXtWI0sFnLtVN0rfKX xwPWgznsX1FutvuyTcl/MjwuUx3BNXIblUjITYWmG0BuOa0g7aGR/9P+Ha6jvUdpp45ZEjA4xlOn bHHakmELmJrd98Jjy4lTaUc9QB04r1pfCeOZV08Ct5ao7vnB9KkjhnjCTIGQLIPnIwU9KxAla1Mk kjpI082S0m443d6qwMrmR4oyrtw6delWl7rYGjIssOPKO7I6Y+4feqDpIZAWYhg3zEDGfaspaRZa nZWP/9T+GOfKOg2scHEgXkLnuasKbVPlcFkJ5c9666e9jzx4vLi0SSO2dfLmyCzKCwHbHp0ro/B9 zZ2t1JLqJciSCRYlx8hYjofrgD8a1AparqkF3ex3NlYxaWwO14LaRpIiV4DZYk5IHPaiUm4CuHKl eTk9c9aynuXGXLobOhaaNSuUt3aNFdtoklkEaJ6sSfQVta9pmmabETYzf2gnlnc0iCGTIHJUc8VK V3Y20sf/1f4fra0uAYp1ZSfvFByQMcU+9ufNMUYjwyHa4zyfau2cepzlZhIk4MaEYXIGOa2beJEA cKofb5mCuMH0NZAYU3mzXU/DBWfOFXr6mrkc0eArZBjTYCx7DpTTs9QII0a63h0BQHPycCrQtVSZ zbA4CAlEGcYFIiex/9b+I4fLAsrcEk5VxtOayLjUJJQYXRU2t8pXmt3szijLlVi5bWyLbrI8gMsx PkomHII/vDsP8aa11NpxzGgMkbZA/wCWW7/OKwNVqZci3SSoVwonJuJl/gBPPFbKxwSgrOkTOQDF u4K4IPH5UEqS1TH3MdvKizpAhERwxjHMOcD9awmu443J+cM5wobqcdqCFKzP/9f+IKxaa5ZVnlaG 2A8yQ7e3Y4qaWzdN0jzF4mysTxSlWT0yPpQcnOiEaeqW4MUg2E8b+MsepojgtISxeQFkTcwKkq5z 0HvQPmV7Gzqr26CFLYL5f2ZZcsu18lc7TWLptq7SOEYxMTuMH8D0D5la5o3V7K0nlYAX/UyRIMBs cDI/Cn289pBai0uFyUm8zy25ib0BoJU7ux//0P4k50tLmOaZ0jiu8f6OqttRuwDeuBR5aaZOltPH iZ4EnDAhgfMAYDg9cGolzJ3RyqV3YqXV9EgdI4wnOWYr8/YUWstgbNUd8zSbtkOMMMevqP8AGpk3 sUVbHTLp5ZQIVKx4Z3Y/JtJ6A+tTBLeC5ljHyhfvc5XPoDThezAkkmjkvH/dbPOChVjyEYAckDoO /wBar6jPDPA0UYI8uTaVC4DY9foacE1uB//R/hvg3R/ZktQgy7G5kbrjHGKiLXBjkJzwxU7eR9f5 UGMY3NK2Cm2hjl8xJIgdrhflOT1Pes6SSXe8YVzGnzCVloNjFubqW8EqzhmlC4Ug8DHFc68Ll2Xl ZEI5IORWFRbkyjdGkuCitJKTtwoi/iJ7mu902HZaFlijl+1KsYikXIQZByO+70rkmtDG1j//0v4q 0jiVItOjbarOHcsPLZSRjDE9qqzyTR3ywyuAbNhEgDBoiuc8EHBB9a8Zq6sc53UjG2tNqAKCBIUT 592QOQfoaqOLa4sp2mvJYNkXyGFAxYkgbTnpWAGcyyQPbKkXnKQS1yZAPJG3qR3yRjj1rsS2ppBB pt75e+LTFuNMJlAdo3JZQx+p+vNFraAc3fafeFQ08asyJlvn3FQT0rOjfymUDKttwI2U7Rj3oG3f c//T/i/t1e+uBdowgKMFlRMgZXAOM884610a6uthIzwZnuHjCSLcKTGnPJHqT/WvnJuysTD4TFgk jZ5LxYmAa6Z1hJJCknJ257Vas7lNVvIb2yhkso45iv2e4GWDDgnd6ZzWXkS5Jpo7i1iO1p75N2Mi I7cjPbFdRY3GbacrbJNcSxrFbNIrefbncMNGucH0wf0qOa0rEM/oc/4ImeH0h+J95fwX3nzs0dna Xsdh5bZnZwx64LchT2ytf2++B4/J0awghR1WCMRB5BiWUIAuSO33elfh/EU3U4grxfRr8v8AgHPk 6X1yvJd0f//U/sGk2spJOeOeOlV4xyGODnhfQf54r+U4K0mj0pfEyRlD5D5GP7vf61SELxPu6K/Q 9MVoJbl1A2CH28H5T2pJYxKrRsfvDaR2x6f59a1p7WLg22xHYq6qOoXBWovswlYOT8wPIzgU+a0r McHpY//V/dBkVmUSrjbypxwp9qYJoDOoDbtmBg8Cv44e7BNpi31sk1xFLGImXyid+fmGSMj9BU4m W2t2DYOeNx/GtoLRIm/v2ZWiZplcRg5X7xI+XFfBf7Yeg39x4G8T28BMzTaTdPHIF4hLqGyuf4wp x78104FcuKg/Mxqz5acn2P4mfjCLga1HY6dM8Ysi9vfyND5KTqCyORj+IspyPrXg17bQ3WoQwXwl 07S40EK38ce/59u5iV446cj6dq/fsJrQi32JkudcyP/W/j1toordBbRpJ5rjNosu3GxeMjHY4yM+ v4Vkaq1y8USXduJF35jVgHVCvfHbFfIRV9DnMJPMmZrazfbbg+etvM5W0aUjGSo/D3rqNTtksrK2 EccFxqdxEBdfZV8uGIsASIlHX0+v67RVoolK2hHp9mF0WOye1WzkEjymRSRcFXwQH/LpWBqDiApa XMaTR3P7pdw3JJ/nHeriruxk92btoFkijtYLaKO2hUOtsBiCNsAbgvQZx1pI794naPylEcSspeP7 vJ7jpWwj/9f+NN47SK501PJFrHc77+W7KmTlGCqpHQZIOPofwl8Q6p4hvZNLtdJvWstH08NJBFHH 5cszn77zDoeowM9vy8OCd7nn69A1V2n0mzvBLNBdaZdLPf30WZXu+cYCYwuAWJ696guNb8uWW7u5 pZo41VlkcZcgAAVoBk2eo3Gq3d0l/I0xuW82Pjp0wPw/wropll02JRbpKbqPlk2FoZA3QHt61ado tFwWtzl9Qt7ybThL9nhnubdzdrC8hVAgyXU49gf8mvGNevJb+7kuHtorQkbfs8WfLjx1xk5rSm9m aSj0P//Q/hFtInl8mNJoY5i/zm6YR2yKOcls/Wt/WLnRbjZBoEUipHBGLm7usBnmCgS+Xj/lnnO3 PNc113OWMeVai2liJXt1Ep+0uu55pnKhsDr7dK9T0i6MEAcxiaaDBjd0KLMw4I+h9vWp50aRV2dP q097qSw6ktnLFBOy2KWtpG0kasACXPcL7njmq1tqHiK0XUjf2VvFDpkioricN5qcAfifbNRKV9DR QSNJ9Ij1qeC/01gkN7boGuJnG1dpAlXjpjLYB56etaV9pGkT2ENrFY21ubT5YbqWZmnmOSQducAk jnaP0qG0twUUndH/0f42Y4LovC8AKS2jlo33ldxHrWLPNr9ndvqN5paQx6hOYvOiufPgCg53hD+P vXmKV3YDRt9YvZ5zp0L2MMMhEgK6fELvuW2ykbsdOAa3biKO8MEZjVGT5JJEOTIM9x0/GtIuz1Cx l6nYQ/Zb+ztrO7ubyOFLmG4hl8uC1Abq+ASSSBxxXMy2t0GaOWKeKOOEM0pXPmkjPy+vNbJ32DY2 YIJDAlvLJNhUAmI5mYEZH40l9Y2qbIseU0kZTfMpEjbRnJPrWqkraiTuro//0v4pobPyZxdobWaO 3n2y21yrq745AA44Pse9OvoJ9UW9khtxp0S/vFtrEu0Y98k5/M0b7CezH2kJjAikkLAINyHgNWld 6faTxJNcAvDEwmjjt5PLbKn7oPbpTitdTnk7IYrwuhufLNqWfCI53MgPAqhFeah5/ks0H2eOUt50 MmW2joPQ5rczU3fUz9Turg30k8Cr5RZcyAcjgdOw6GpL3U5pMIy712qill259z+NOKu7Mc30R//T /iaCtE7BQjShQ8gjIOPQnHas69ubpS5wVBXqo4xjGa9A89u24abcGGJDNE8izSFA6nfKB3+X/PSr +jXRa7+02RQRmRwUnjBkGMgnaeRjigpSaVilczSiS+n8mC7eMsLS5UbJg3Q8n6frVeOG4iSEXMSL cXcYZ97hyoPPJzwfrzQHM7WIpxcWbtOBuQsEnWBtyEDgGtp9WjaKNEUxlgOOmPrQKKu7H//U/iIu b8KVjULvPVyeGrJlVppUbOGY42j7v1r0Dz5JbMYyATrCVEjA7XA+5+datpJPZi7s4pWlt71RHL5u NsYyGIH4jjvTjozL2bKsojRgqjdFGMKM8R+uKtrcbERmmIjViEEbbWY8Z/nW5LVnYgub/wC1lxJD vaJP3LycnsDUB8xSoBC4TaMDG0elaQj1Yj//1f4Ybn7Q74hdQehwPlxTgEBEbyOpVNzF12oD7HpX 0B5UFrcWJJI2ZLnZ5bN+7z/EK2VjskhDeYpGcFt3I9jQE9zEuzDDcGSK43xZwBj734Ukk0ckQyhY Z7fw+9bx2QU9yqtx5Tj5Qw3dOxHpWxqd1uWIQ5WMgMwHGeKme1jW3Q//1v4VGlMmTuLKv3uOTjtV myj8+dXkk8tUGQCMcjpX0N9bnnR2RclMpT9+dyrJlgefl9akt/skqkxKBjkcYziqlK6sC6kU9rFI pYNh+pQn7uPasbaHLo8eSOn+NQMvfaHjjSKWMkbdqMo27cVGbu4KOqE7QNpUj8quG5jL4mf/1/4V baQtIolUgjqcYxTdSw7KseOOMng19QeOVfKQRqiZOP4j1Bp0biBsklmPB96admBJc30gVrVIinO8 u33iPSoYA0i7mU7s4yw6/Stk09gJg4VtsREZQbmLHrioTLJI+0yfIDknoKbaW4H/0P4TYHXcyxgF icbj2qzcTOhTByxHzZ6LjpivrueJ5CTZXEkiqd2cMeGHU02L92pY5I3fKAeRS5/et0FYupexrtXy 1HPzev1qd7pWAVY1Rg5OVOS46c0TegbGXKrly7fgijg0qG3DqzqcEYdFOD+dOLuhttn/0f4SfLVQ ZEZiofJUnpWrajzQyoi8rls9V7V9geOMvYFj+ZQzMoGSBxWfbvfvDJCrHyWfLKxzwDnNADSAeWww iOCR1OKillM8m/aEBwAKDWnsSHLDAHQYzjpTArBlTGGBye1BZ//S/hRSOO6mhtnYrHHyOcBu5FPn hhjnBU5XdtXPIGK+ucEzzy085ffGCWLR4CYwFrHiUySPGzMhHIHpTS5VYBxjSCUSSsrBBnbnk49a 0ortJVVQUVWXIz97npTAYs22RreSNSpO0sDwavtNutyGQmCI4G4dD9aTV9AP/9P+E15HeXafkjI6 DgEe1XZVhjjDGGPYEATacljX2B5Tkrme7PJsRAcnjaBwtXI5JIYiGCfKMNk8j6UBGVtytJcM8amQ EmM5Crxn2oaR50J2kFBlUzxRboEpX0RXV5JCwYANt4XOMYFXhGRboGTEpOQ1a09iD//U/hX8wwIp VgXH3h2JqRTvQySPtJGR2DV9weOVo42SQtu2Zbp/C1TMIVkV3AI3ZIPegCD/AFhYBdsecgGkt3+z O5yr7vl5/h9ad7aAX45chwQOR8o7UInmEmQnaq4VSeFoiruxEpdEf//V/hshTavlAlUJz14OKiuJ VhlKFS/8OB1bNfeRVpWPnytLIAgBZUZeVVhzVXc8xw3ALcMKqK5VY1p7El1EYki/cybS3M2MAYo+ 3eUyPFuZAu1gBhRVFNpbl8yxzKkhkImIztC8e3NEsgjjJcjcOcAUDP/W/hY8x2KleGboDwKuRzOg 35ClDzz8pNfoUEm9Txxz3qyErMpYnnrhB9KkitHUqwKrDcHco9c1rZWsK618ijeRMC4jwJYztCZ+ /wA4wKfHLKAHP7mUYLRycZ9sVnyOwRd0Wyy3HysAO5HSqF4gT5Yht2DLFejVFraDP//X/hOilKgi IlncYPHStuNElt2+XdMiZ8wsBg+lfoB45m28kqSb0UjgqT0B/wA4p7+Y8pRiQpG9vm+VTQA9IUKZ 81t4Pzsx6+mKlZ3ZdqBpdnB45PrQBNhBDlAdx6se1UUjBkJyCw55rdO6uZTVnc//0P4XzEFIZRls 7t6n7uKfJLL8h3EqOmB1+tfpB8+R/bCjNubBxgDH3cVchvWmK+ZEJPlEZk6HA6GgabWw7d+8KPlI s+nH1prebbswEisSwCYHCrQaxknoWGlkc7ZmBwPvZ5xVK4Z0ljZG3Rg7c4xj2oGmnof/0f4bISGj L3IjUlv3ZHU0C2lEglxmORShbtjtX6QeONEYOI8nAb73SoLsrbuoyeTjPTpQBPZOZFyxISOTk9cD jp/hW7camsIaOFw6ZGwdNtAGRqF60hhICGQrl2zkKPQ1nSSTupdQQrDaGVcUWA//0v4ZLW4ZUZdu WAxubrS3EfnAEEIMYcDpkd6/SDxZJvYSOV4ZoFLH5CMP/EPTNXdRUM5cg5PLsT94+tBja2hRKtFF HKU4HfHSqtzNK+wxgYbjnp+NJJLYCHc4K/eJUdP4fwrRspW2gDju3tTA/9P+HJjBJC2/7w7EVkyw IiI4wAJQ/PfFfpB8+IcSbzgDI4PWki2kpAIy0+/kjOCOMcUW6AaMtvJH8oBBb7vtVSK1mjZvPUqj H5XXkVg1Z2AkVponeIy4H8GByf8ACrtmDuY8Ow6gmkdHof/U/hlubmUzbW5RM8dNtQxyBwQ6dDlX r9A2PHL06FYIghJbHzse/pis4b4t3zAM3HIzW6d1czlJKRceFSkTyBi68HAwKtpcSRxBULAZ3Fex pmZFk5A2Bg3UY6Ux44oUkZlOGB2D7uCKAP/V/hht9SjTKuFIUZK9OnpULX/nsxjXGTwG7Cv0g+fL TXO391bKrfLl3ZclSfQUyOWe2+dXcueOmCD7UAT/AGuRkIkyXcYck5JqnGrI2WLqp4XIway5rTAc fMjOVbKnoMYIq4VOVwGkjxlivaqm7KwH/9b+HJHgtCybBmT7kgHNPN8Y0ZQCQw+YJy31r9APnyk2 E8x3PmCXHXkjFRvqDBBbugKoNsLfdKDPOfWg3jtoSIJQ3O4gAY54OfSpDE0cqEjfuPzbf4awbbeo x9zJmJIoWJdpduwnBAx1qLy3jhCyHlmyhxgjFNr3ROOtz//X/hsRVh2M+GLHB9RTPJDmRlYIo5Kf 3sV9yzxx8RkZgkUJcSDZgnhfQgVNIZERLdHKsvL+o9KRlOKWqFiRpG8tQwZRlnIwDVpQY4iFiG9e S5XLf54oFBalO3ke6ldZyWVRhHYYA+tX3jc4i2pIVGDIBhQvpn2oNWtGf//Q/h7tpZ7TzoWJeDG4 Rq3y++KltoUuGeVFIdf4ccgH3r7Rt8qPnytdRNGX2wjBGMA7jxVzTXiiKNKo2IecA8VovMDR1WdV txInZd4OMY7VgxTiTyZ5DulHygHv26UHQtSS4+/5iKFbG3af54q1G8rQgO2McAqeajkd7mbm07I/ /9H+G6czRyAIzIUYjf8AxfWqsO5lJlYSbpOCRj8q+15PeufPl9mkjATbwxHOAePWi5dJpY1TIYAA tn71ZWtoAT7z8u0FVGCc5FUWaTcIlQ4Ufe7D6Umrqw02tjZs4lEkXnq6bW8xM8j5ef6dK3Y3FzcJ iGJIpMgSPIEUEfXgVi01ozRTT3P/0v4f9Vt0Z2YESKvAwc7cVWVZYVQx5DY3bu+K+oPHEMbxoZfL MmfmziprfEwYuSjMhYIOoA7YoNIS6MmgglRJZiitB/qnyMjJ9qhMbW0vlxJgkZ3Abtn40FSaSsWz ceWsSSjf83zMeSB7fnStPCsN53kAU2h3bPm3DP5DtQYn/9P+IAm4+zK8s6/veY06k4OPwqikM0kw 3Rkgc7yPkzX1B4425Rbcku/mSOSQqfwAdM+9XtNjlkZRwQwwA/G6iwEMxled4o4cYbadvOMep/Cn FTE25yNwG1sHJP1oAswXKkgsgChtqleSoqWS6MUbyMQ2ThFPU/hQB//U/h8ku1lSLzoljCk7nUZL +gNKLxx5cmNyg7Y1HVMdK+oPHLtsEuFnaXzEZf3gA/1b/wD16SSI2xaWE8yJuUE52/5xQA6zunLT NMS7LHlYwuM454/z3rJmYyMZT8vmHBI4z7YqJrS407O4kRFvidDgoflXGRmtaxnkkcTyuHA+QKWy w+v51H2bGyaex//V/iWujkSGNwDj+HtmsV5JbZUt4U3M/IJOT9a+imknoeeLYvK0hjlCHHO4jEn0 q/OJhJ5yjMScbQMYAqSZOyKxtpbxjPbuV2fewcYptvZRARghEZidzn+M8mgxLItokillmVB53yJt +9FjuPriqUmlsP3kc5mjY8PIMSY9xQB//9b+HN3lsSzGUquNmAcK2e2Kks5y/wC6bKkH8ce1fQHz 5da2mEjMqjy9m7JODin+UYYo5ZYsRyNtBP3Se3FO7tYCpqTCMxTSOF3t5Uajqx/yarJeXtrJ5ybs Y2mP7uQeoojuhvU07ycTOvkmPZcQLvLAMwbuM9iMdqgj83T3DRskizJhzjDKRW3cR//X/h7a6ku1 zGCUTqcdcGq8jLLIVYfdXC96+oPFh8KJJLWz8tWhilEsafvN8mQzeoH9KpQSyo+3kx5+eM9P/wBd BRspczskhRFRY+SOhPpWK8hS8SXBVZgRIQOmMd6AJlI84FJm2twQeOKbc37wSbXAZCNobbnFBpT6 n//Q/hft7gKdgQtuOBkc1bxIwIiwhB+Zj2FfTKNrnnliK5WJ9qpzjDHHWpzc+Uwd9uc42Y/Wsk7G c30Ecs+FVCFfnI6fjUbyrGkkaAKoHHFIhO2xnu7IsRjIdjncAvT3qW2jF0WLDai9qC3NW0P/0f4a 5fsscsYjTzdpAwOi++askwgyiOQOcAFifufSvebseOU/KZALiF42dZMMXGVK9xVWRl8x2ZmQvwNn 3V+lRze7YcdGhoYrAA8cjurYWU8gj3qyXKQq2W3scAHt9ag0lK2iIBc3DqUIBLHGR1xTRK8Tghic fKQO1BDk2rH/0v4ZIYIEkErNvU87Tgtk9qe7hnjhtiYVBO/sWz6mvYPLjJJamjbQynLeX5ir8oPb 6VZuXMkEVuVCPvy2TwpHQCghu7uZPkO9wRhN6DYuD8p96hunkTemQZE7A8cUDjFsoQTygllUpLjI 42rV0W6TI5kYB9oLheQaBqL5rM//0/4aLGOPeYXXy8cxyFvT2qW8RQ8TbvOYnBI59K9g89K2iLcM FuFcj5nK/Kh9cU1rMIyNJKhRR5jwq21j7UAQm1DeY4byFJ/dIzYJ+meuKpXIaRokVtzxp+8YEBia AK6xyq+NrN6k81rxLNBFv270A5Kryp9Kzn8SRXM7cp//1P4Zb6CRbiK4ZdqTxhtzfeXHH9Kmiea3 KFTvDjkEdB2r10rKx5z0Q2Jo1kZpZHkmlOQCPlSr03mnaFicxOu3CLkAjq1KXwswWmwlyqxIIrcm VFA3OuMHuatQS/6N5XkKQFJLlPm+g9axKjJp6ka2yCF5WdVlZcJCDlgM9/yqNbh4FaMYLD7u3GQT 60+hXP5H/9X+HeTzY0WGVmLbvNXHKrnr+NVJ2uLqMokjKg+8cfpXou19Dz009hLKPbtLIJWUbUJb ABPetqEzqykkBgeMHApAS7rxLgyByq7STIfuoOhrPkt0jRZOCr5yW56UGU2nojPbt5bsqdCP8K1L eDa5jdd6BA8bZ6+uOaavfQg//9b+I69n8mBEbf5LptRsZJP90/Sufhtw5YZKKeV7CvSk29GeOSJZ S3CSwW8ay3WMo6qXkTHXiraskDNb35kLKmGjYbeQOOPypJXdhxV3YycyBmCfIM4ZjxkelaFr9nRX dlUY/jUcZ+lapPlsbcqGXF1buoaOUrg4YjgmqTuZRviUNtOQMYrFrSwNJ7n/1/4bYSGZiyYJPIbv VW8iO544wV28r2rujHlPPStoLCrvHHHJwynLMfSraRysCiHgHI9DVAJIPKcMQUyQuDwQauSrI0LM oLhQN5X7yn6VEotsBmmSeYsn73a8bbWGcbRjg/59KWbUmV/JmWSZNwiCgY2jNSotM2h8J//Q/h9u Td2+2W2YRRhfmhxgsPY1Fawvcyh1TBY8AnBya9A5zpDZtHED1kAK71AyprESa5UM0w3xuSNx4fPp 7VjL4mTB3QQSiJyQqyrIpGO4qqzBWw6ADOSAeg9Kko1oLqJolRIdkPc9GJ+laukW0X22QNK3kXSg ICA7qQTQZTetj//R/iY1L7C7yqjypEpZYmlXaWK8YxWVFFbFAJACxPIPDEfzraTsjzy5cXOiCzS2 sLGO1uIM+bdpK3mSsTzkE4AHtVC0O5CJEWaGQ7FCncQw7kViVzO1iS5D+YkaL5skg2qP7oHas7Y7 ahDFcs5jZufLxlfpVyWiJNKKMSPLKvmQsV+z5I+VwOMbazZIhaXCSSxJM4IIVxxilKNnYlzSP//S /iHMs12paIKTja0YGMAVGEdhiIkYO0r1xTaa3PM50dM9lHHpoJeOScIGVV+cHP8AIgVyl0kUaOhO ZJDkBeoNDTW5XNHuWLO2nKj7Swl3AKFPzbQOnNXJ1SzaBvMG5yeFPK46Z+tIZMsLzRNO8AVmz5Uo GDxnn/PpVU6fc3MHmPbytGg3STIu4qM8Ggcd0f/T/il0+x0q2eG9vBHc27Zi+yTnO1scHHXIJyPo ao3+nxTkzRSoSmfLjBPmMOTgfSg5kktEZMentcoRGME5HzDJzSajo1xpFtaNKYrqW4Il8y1kDCFT nh+6leAQaNBlqOK/hiNxBKs9t8u9RJtWQN2HuKL63MjSyeVHACi+UiZC5GNxOT1OCfxoAx5nmSaN pk2xjAVU7ds55pXgwJnEpjgX5jIRyRQB/9T+IKOC1Wzady0WxPkAXPmHt+dV7KTy2k8tUKOhA3j5 QT1NBlGVtDobOJJCQ4QBYvvf3D7frWLrH2m22i3Nu9vPC8cjGQb1yMYK/r+FBqeexvMkb+cUWVcr w2QcelRw3cRQRy8sWPzY5rCp1A1LS0tbpjIZQgiG888nHtXoem3MNnLZz2arPGhWdTKeC4A4x/X0 Ncr2Zm4yeh//1f4wzqFtJHc6hf2kcl3fQ4RCu0QscY6Y6dOa43UGF7uSPMUnAMq8BcH/APVXjnOd VY3QjuodLjka4uBaCYZU/Mqgbvbg5Fb0X2KWPZcpsjkU+asYwwHQ/n/WsGrOwFWU3Oorp4hsoLS0 edooY2nVLjapxvmHbOBge/1qrHLqFxqqzvI6y+also2+dmOMbVCfgPyFOKu7AaepXJM7rPIyOTtA YBAx+n9Kw7y5iihIld9w+VRGmW/Kk1Zgf//W/jA02BtqXAVy2TjcdhIPHIrbktU+zTXuGn2SrE6x plVLA4GenY/lXzk1pczg7aCtfWcBitbm2MTXCEQyFOpAOQB9OfwqXSrZUka8jcTWany9yHgtzlce o5rIzsdBN4wWxtZbb+y1vhIBDYhy0WyRiBuGOuAa77wpcySShLxbdljAkgn8oGW2PcZ7qPSuafuz uzXlTVj+rb/gh14fnvdF13W5NPsXbTfFFtp8M8UW2SJmVMoijr2cn2r+unwoohtEQDk/NjuM8kfn n86/Fs9SWdVWutjLKqajWqyXVn//1/7BLkFSI4cFnHPtUKpLHyyZIHJxxX8qL42em9ZiTNIYw6Do cdKf5xk2xPgSlM7QOlWStx0UW4kEglT0Jqd4kHzlgx9B2pptPQun1KfGS+ORxk96YHIyTnI6Y4FD 1dyktWf/0P3evjbqilAzbFztUZZj7VlJZwSNJcLOWIAbyjwYOO9fx1KNncBA6QIwbc3zbt68/hUL 3AmkklkhMMHCQoz5MgwPm9uc1vS6GO0y9BP8u1WjCqh2hCMN35NfKX7Ucc6+A9T1Kwndri3jiudQ tJoR5MoNzDCuD14VjkdDurowemKh6r8zHE/wp+jP4hv2lbWay+LPju0stBl03SLXxxf2kUcUhniG 2Tmbef4ZWJK9sY714DqOj6jdqslrYvcwWxSS4jY7IVVyBuP4fnX77gXzYKnLyRjlsnLAQvukvyR/ /9H+QPVbkW7wSw20Ynt5xCxX522Z5/I9qxNVdYbu0kfUpVhuJVFxBHbb0TIxg8cdexr5BGF9LGJe aaC7jSrxEfzjLH50Z2Pz0x1APWpddg8RS3mirol7b6bfR3cVympXbiOOMoRvJzxjhutbRtZXM5Ss tDUaW8+1zz3OoLqd00uy4uBIJElx6beMelYjxXd/4gtbOfS2gKs0cC874Wb+IA9z+WKuHxGMnbUt s01pdsLu9mZLtltY3mYsEC9B+H9Kz7x5Ir2eztykcBUN5qTCRLgHqTjpyO9bC5o2uf/S/i4mlzJp 8Ed6s0krFDbuTutsOeFGTkHrx6nj12tWgne886z1Lz4TGIpo7bb9mkdOSFXAK4PBNeMtFY81yV7X H2YlSwlkeeWGS5nDXemtwkaqf3bY9+fyp0x0vU4JNNvmW1tZZE+13EUYe7RQeNgzz9M80uZJ2KOH LjTbqZrabdDbsREZUEZKAnDMM/LwBxk16DZardSWuZJC0N1GrII2VlAHc46g/wCFUa02QavBamwk ktJJGuniKeWybYS3oW9CK8D122lMjtKFwjbMocqT1PPetIPSxo3d3P/T/hSgsree1bzcZ4VSxxtx UUkUNrIkcQEhK5coPkFeec50OiTw/a43ljaSPBjVexPQH6ZFenW8/wC7jjmIKLkjauNgPbFBUPiO h0vVNQSJlSeWa2hUrLHGcNIpz8u0elNt9UjvFuBc6aPIlnKjzWYMVU91/wA9KDYTSNUs7GSex0yK 3SF7l5CiPko7E579f8Kld4bPzryW7JeJt4icF2DZyAB6YqJpvYD/1P48rB4kBmuypF5CZIDuBjO7 IP0Yc8e1YM2I7b7JF5phjdjGshLgZPQZryoJ3Ax7QPBcqZLNiGbZBdKPMIJGWz/dHGK6O3+SSR1e TbuDSDO7H09K2Su7ICmt1cS30zaV5lu86NBeRSkwtOqZKttPXOB+QrMuZtYvvslrBHgM52zqwYq3 dCDxt/rWsY8qBrSxrW97LpcFtc3YjmurfHnLJhkcJ7jtwKxdW8RfarpJ3Vmlkm85BJEfszAgkgP3 PTgVQkrKyP/V/i4f7deJBciBXtruRk8xRs8kpzgD8h+NX9NvYLSSeK4NzaXEmI5LeePYjpzgnn/O awTa2CxS1JtKguY75Jribyj5DJHGSjKxGSFHJOafJe2VrBCzRExiYs0TKY2APOcfz+tbnNKN9DE1 BYrm3kuFuniKkMLYrhZ0PTB/p796fbC0jsU+0M9vdyD93AFyMDrnnOa6FtqQoW3IrZZbmeO0VVWB 5wrM5CoScDljxgda0b3TooftBe4hZoZPKIVw0Uhzj5D0OMUbEytfQ//W/iVjuLbF0jgpvT7OJI8B pMHpnr0z+dWr+2jneMWKt9nSMfLJw4GB2/Ou+6tc8+3Qks73RtNubeW4+0y3NpGZAiIUj3fwDPQ9 qg06fRkke8+zS+dMJSNjYeJiDtJ5556ihuyuAlr513AJlEcREpO2dPKXaD8xx9M1VvruG6vpZYbZ LdUwFhRzJECBgkEnv6VnGXLoBUFwrozYZSoKrHjqfenW1jHJCXXMs+CxWQ7FB5wAc1cXdDTs7n// 1/4e3t5GxI0fzI2CnerEVpO0vlGBsldygDnAHP5V3RvbU4HuUbaJVuXiVvLQknDnOevelmmktJQE QzRs2GHTb7mqEJMyXMpWNo4lQbnkkbah9eKbDHuD/PGyLja2Dlgc8it1sZzXUfiNSGWUkD5Sjrya imaZJ4lI3JKuWJ7AdAK3h8Jmf//Q/h8t7i1jWQNDhs/MvG9h7f4VJq1xHf2cFjZxLGol85pWG2Rs DADH0HPFfQHmQ0jqZcaPHtS4XeU4Emd2MVqwWtncrMQpwUzk8DI7kUGbd2Yd5aRpJ5WBhuUIGc+1 VhGUCqDhVOCTVwdtGVDchkiKyE4VuPlAPSopTL5iRklmKgkddopSd2an/9H+GGMW5jECq6FTuL7R yfetC3CtFskIAQ/IdoyP85r6A83mSRni6klWQNtDN8oLcACgwxCAlGMkqfP+7+VaBQe5kTSBw7nc W3bT/eFBmmHlL1I6YHL80Fm6ii5hUTBo2VuPl5pj2wtoQzSGQyybFjK4ZetaQj1MG7s//9L+FoxP HIDtO1uPpVaeNgzbGyR6/wA6+oPHK6Iw2H72DyM4J9q05oRM0beTHbbAMBTknHeguSXKmUHRZJXL vvIOM46Yq3byQqrK3VQecffPpitoL3SCjcoZFLRxgHPaqhSVUAYdOOBWc1qXyaXP/9P+FDTrKQS7 m4RueeKTUFkt7ry9qNFgMxDbnXPY19QefZA0yMPJiBkBYbW27SKrpmOWSORCA3Tn7tBjL4mWpbfy lQ4B3DIfrkU6FFaPER3SZ69xVNWSEld2IxAwDqclvY9PWqn2faWZiff1qoOyY2rSsf/U/hMjQEYj BYNwTjp71oIpgRvJyzvjewOMYr7A8hqzsRGeXnzMkHGQvercrFbdhAsaZ4YkckewoEYyqqEqAzb+ HGeD70gjWKUdWjbgD0/Cg0hsxHDrkhvkJyD0xjtTPtBBbzF+ckD8KTkloNyVnY//1f4T7VTvadFD Ip25boKsOYeQxJfPyADkZr65ySPIUmiATbTycEHHI64rQWaCUpiBYiqnMi8sR06U1JM3M+exklBI xiTv3H1FUkt1gJZfmMfByeuKYD1uGkbaUJGfvKMlcVp3TI0UaxSN+86jOFOPUUGMpXP/1v4R5eCi kEMvGKHYuUBOCo4A619geOWoY1ULI5ZQWwCB0xT5YoZmLEbVHBxxu96AEkhUIMLvJ6Z44FQqCWKp 06kZ5NOKu7AaEVpDJE0v3ZQMEn2qK4BkCIu4hVwsnoR2xW0VyqwH/9f+FSKDaPnyAByT1zSNIBhM ZTOMgV9weOWWlRFZJV3Ig+RujflWbJIJMLGpz/CD0oA2fLjFokkoVHjUBwBtLe9Y8kiZICg7+QR2 oAfGr7HIYjaMA9/wqU3DwogXaeMksOaNjB7n/9D+F62uUKukqyE7coV4ANSs658yQGIoudzHdux6 V92pNPU+fGOLeWMsY2aRsFJM4AA68d6iRo1KKgwwPeri7o0pvoTreyXJkSY7lQbSuNuAMjIH4UyO y85ZVt/3a7M7m+5n3qgkrySJbSIx4tZMPKeFkxwv0ovYA0jwySYkQA9No47UGh//0f4U0k+ZEYbs N8uO9XXgM4IkCoC2VC/d471+gp2Z4rko6EbRgkBhnbxkcdKk86QhIkONh4z0X0rZO6uZNjhudwZc K4bJKnHPqKS6ZLht3KtGMDjlhTHGXLoQW8cgcPvLKp5GMVanePcEGGfjcPQVjJWkbH//0v4ZHghW 2IRdtzI3D542nuKqLDMg8tdzHOc9jX6AeQnZNFqUpHAPMGG9OhJqBI43UhCuG5xnlaBqLexNCoQn zMEKc5zwK2IXtpEDKvlBDj7oAk+lBNraGffTKwZLaIJluTnH+elUrZBtlBOSvV8VrBq1iZfCf//T /hfUvkunzonYDFSmYNvIQozL8oA+VT/n+dfpB8+ItlHIczSbCBlvl3VYg2JkKuBGSAf71S5JbgVL mY5O3sfyqtJLI6r8rYHDbR1ojJPQqOj1NS2jLxAcBu27g02QlSqSAbEfcQRwTTexcd2f/9T+HSG6 gGPNtvtKDhUDBNvbr7VXF1IscsLYIBzGOm32r9Dhe544+Fh8rBeduQuOSay7jfI5ZwWOThcfdrVb agXrGREgfAYsOBGRyPwqULEyE8fOSTjsaBcyKHlo0xVCAijGT3NXUKSJ5IZdy8YHAP0oGf/V/hmS NI58sDnGNv8AD9akLKEx3Vs5x1r9IPHK7TEOcpgsMcdWqZMjeH3OHXYSeqDtQYy+JjZbiJRBBt/d qTnnIY9s1GYmkLIGVccrt4XFBNiZbaPIJ4Kr1P3TU0CoAxbCYGHI7+lAH//W/hm3R70VyShPJTuK iktkbdJl3XnYoPAr9IPnyO3iV1dJN0bAZU9PpU8LC1lWXHmOpwwIwHHbmgF5k8t88gDIu584x2FK 15IyYVP3cf3j2zUTTexrJIpFgxIyzSuRh8cD2pWkuYXWMZIxlmUYIrIbuo6H/9f+F1HTzSZAHQ9d x5b1qSWWBJUVEYIeo/hH0r9APC52tBZ7hy+xVIVV4OOBVqED5JJEWUYxlh+tawvYgsT3OSU2YRcY Vev1qKFhhwxJA5UnsO9WBG1wny+VhhnB29RVJ1NyPmZzGG4zwMigD//Q/hXurOGKNHV8v0YdhUUS KwQglWXrgfer9IPny+pGEEaYlJxt6Fqv7l8orIgE3rngdaBIpwiIviViUD5yPWn3DgYz8wzhQKwe 7GJCRJuUxkueENXxKISsTr5eBh1AG08cZobuB//R/hqPzvtOGAbMQz92ocmOQlMu2drdwPav0A+f J4VHmj+JWP3Bzg0stjtPmSbZMn7o+XAoNoqysxpOZGXO3yo/lUHAwKktssrgHcT2PUdaynuURKB5 ozHtMZyeeTVmcDaN8m5uoVTkJUvsB//S/hq2OUAK7ifunFNe2k4chkB446HFfcHjlh5BB5bRgnA5 boBUUU+9g2M/NgN14oE0mrM0I33y7kYuF4+7gDt0pits37ncBmIIPOAfSgzp7m1Y21rKiKPkUPnG Pmf6/X+lat1Yv9gWXyTDAspxJgLvOOf6cUBKV9Ef/9P+IEqDHOq5VgMpJ2PsaZFcvaRDjLy/IpA5 J96+4Stoj58s2G5nw6spjHzEjP4Vq2S6bBN5V2o+yO+6QIuXA9jRYDM8Q3NnJIY7RSIeCFByoA6A /oawreWKJlaWAvI3EJLYRRnrj8KCopvYvTvFsYsMSNhkx7ccis8SsYSqs3mA5UA+lAmmtz//1P4b 4x565nJEn3Tg0gVYZDGd2zGQcYr7g+fL6g3EOTtGz5ODyR64qpJZ4R0QOzgFsg8sf89qwe7ALKFW jWSeZsHPH8dTny35jVhsIC+p+tICae7jJSMIQVTcjZ+97VBDcSHziI5W8mPzPLUEIM8ZY9qiewH/ 1f4bo5GZWP3Q55HXFaFtdMhVI4xI+whSy5Vs+or6g8ODd7D0ldYXS4yrbuNi7ivbp7VRedFcSbJH ljbHQBSPeg0L1tcSYdFXeszZaA/dAp5uAPKtpGZWLk5CcqPf1xQBnzLvLrlvlc9OCQKdGI3ZEyG2 cLuP86AP/9b+I4RWqwW/yH7QSwlO7cqDPy7R60iz+RH5En3RuddiZZ//AK9fU6cvmeOYpcQbbkF3 kLHAcbmA9/wq1Cs0saFcrsbeij5SPb9KRMepEl1MJGjMZBzlyB1+ppbj5QTKh+cZGOtBQtiIZZVR MqDneMZzjnippbZWcOrsoU5XevBx7GgD/9f+Ho28cm0RTZGcspHFOaVIpmtFIIRdxZRnGexr6g8c 1baWERlmXKhfnZvkANVpWhdJHt5AGU4YP0P0oAgV90sa9FK4Zl6t6g06G1tnvU3uTbh8SbuqjPOK mS0AWSGCGeT7OTMoJ2K69PwqoQIQFUlZZG5UDGO1Y2A//9D+Ie2xAixsWdncltwyBmpY5Y0nDXEW NuVC9u4Br6A82DuiXbbxK8m7JLfJkgFRnpVwXKTRERptZQBg4O4+1BM+hUMhjIjhVoJRxMAAA5Pt VK4uUiVYQpG19wUnoe9BmQTnzIxNHM7KnDx4+6ar29/IZGiYMFjwzKfl3D/OaAP/0f4b9X2TvmM7 o15VBUelyiN13j5ycL33e1fQHz9jakme7aNAm0h9vBwf/rVpvEqQsDuYqMqGOVT6UAVLYWkrr9rH zjlFOMLg9amvWtA2JWiRZPkTJAJx0x7nFOO6A5u4XYQwTdAW+UK3zE+9T2kRdyJ2Ii2Z2k/d9q3A /9L+HW5liiR2hIXjaI4xjPTtS2MX2kA7T8vzM4GMH0NfUHjRVooW9kEMbOpYkHacDJrIhk8x8Ak8 5OepoGackjsN0ROVHzqeM0jskioWO1cYCEcLQaRjdaiBIv3bMm9lPCdFIqKcJLzsxk8g0BBNPU// 0/4bTC0ZVkjGwDnjpUf2llfYADv42+lfUWPKhdyNTbCLdWePbI/DAD/P+TWS2xnfcQCo+UDqfeuc UviZejuEMCrHuP8AfLcFcelQ3bJKh8vIwnLep70ElK33AYUZ4x05qzuuIWCIFBblgBgtSle2gH// 1P4Z7WMuJCR5eCQFYYZzTPKeEjcp2t98A817Uk09Txxty0gixDkRA8oOvUdasPADGgZOCOvcVICp G2XaQgRRjK5H3/8A69QLFNLkKRhznDD7tUkrMBn2aRFYjG8HgA1PbWKXERcn94Dhwx2hakD/1f4V pJ0ilCxjI3YOeQfetGyeKSVlOFyOXP8AhXsHjnWPqVraQFYUR9iYxjCqf/r1zhP2stOzggNkgfLt /CgCw00O0ImPP2ZXavJ+tYk6Rh1DFy5Ofl6Z9DQXGSjozXdoBAkWCriMAhk5PHaqqAQEh3UrJ0GM UBze9c//1v4b7uOFfLa3xLKi/vdrZCiqgAwTvIcc4717B5sZcw5ZWR0bJORwM96tMv2hi867EBBU qSOR/wDqoKL32FLtLm4a4S3S3UGCNzzJk4IHP41cPh9LaLz3bLGNZQv3Wwef/wBVAGDLMqzeWmAR 0xVwXmI1RQBxhkP8XvSsr3A//9f+FiZ7iZi0Yd0VuASQF/wrbhXeoODIwUBx3H+f6V7B5k3ZWM8q 0cxXqu/cCR8yj0/CtFLphGI90gQOWIXvxjrUz+EyIFnCIVXC7mxgdKvR3vlSop+YbPLIAzj6ViBX kcB/LjUs55LEc/T+VV5W2sHiRhIv+tVh8rf55oA//9D+HFGllkEoYSFvvKeicVvWiwGwnYmMu+Ys Bf8AVH1r0Dy6fY5+GGZZPLjKsEfI5+U1qtPHsz5TjGCGB4yKCpfCwjvZrp2tGeBVZPkUjYWx1BNQ 3YUKY/KAMabMoSymmld2MSGyeCOJlmUEodxBHBHoKgluHmnR4MoM7FxwfSt7ItRTi2f/0f4gppGS 28uaXezdFxgD3rNjWdwRDtkkAyseeX9gK9Wex45oZuIZLWW2U2T4HnFWO+QDqD9at3thNNh5EKyq cu2M5B5BzUw3Kg7MDpJgtnefcAeWLja49MCuQkuHjARDtG/ByOv1rU2ENtLMirtA2HO5T96tK2SW 3EbkguGARCPlOPX1rGTTegH/0v4brpXmkk/d+Uhyw8o4wT/SqxTJiO2T5FwWyTke9egeddF6MwyH c7BEThmHOavxLb/KDOIg3zruUlcY71a5eXzGRq9hcN5u6Tzo2KjzuAPQge9PjcFxGu2GOQ4dmPHA qAKsFtN5vmQqCDNlgRxIAeprroIraS3INjE0iSb2uJVw4/2RQVGXKf/T/iQ1S/WVWhKxrOMIjbAQ QKqXUYVVEL7vLUeZLFx2FegcTn0RGl5JjYLhsr8pQ8mRfWqszPD5jFjKhO6IHgD1rKasx09ypFI8 OJ1kUIz7ducmrBDyTRgISpO44+Yt71BoWEsjIy3Inn+zxS7Ai/KCcdD7e1W4kiEpVVe3K/PHJ5h+ cj19KDB6u5//1P4gr+R2Ia5VZgWyhDbQh9SKgaWCSJgDmdCMYGMVUnd2PMm2tisYljAM0D73Ylxk gt+FaFgI4QMxNbR7/vRclfwqRc7sXcGNh5LJd3Tz7Ukc+UQvt+n51j3skkc5cKI8HDAD5lI7e1Na MzOr0u4s7zyDKrRbjsYAcg9Mj+dVbuyiikkluFkyzMFyMhQO5rewH//V/hvl1L7HLi1fJmyr9V2j OP1qSyuWaeIZZVGS2OmcHrW7Se545fk1KaSRILcPGoBV/wDb571UEqGQwzRMTICGLDke4/xptX0Y GtazRwCCOEk+WTuMnOc5FWpZbSKFjdw+a7uDE5OAveslB31LjLl3Nq1vFu4o1kwkMYxwOCD6V1Sa tZW2my2cAd0uIPJmxgHhgwx+QqWrOxtHdH//1v4hr7KXkguN4iUkxlfQ9KtaYYPtwFxcMIY4muFJ ISR/lJCDPcnA/Gg5x0WoX0WorFEIkPMiSAbtgweMdOnrW/Zw2kel3sd7ElxPfSlreUt80POGyPfH egaRXjsbeyjm82QgQRCSBI13xuePlPoQKyr64TghSd/RWXkfhQW4djFlinupTFgKF4K919qnMEkU JEpxGQUQScLkYoB0+x//1/4dVuY5oJUmnAK/IFjAGMdOKdpqxxB1m+bew8vnP6flQZ8h0EFzatcQ 28pa3ic4kn2ZQL3J/CsHVre2ido45fNRpCI5BwpHYj60GlraHAXqMs5jAwiN9/PLVmyEiQBl27Oj AcVz1HuBr6evmSLGpyZDjjgfjXq+hWybdxjDGIDhh93HfFcsvhYH/9D+Le9SO5to44sxTo2ZGk7j 2FYEEX2Rj5qmRWJ80nlR7g145lJas6UXdpdXMEQtYkzAEN3ExEpx0U+n1FdPOkf2cxWCR/aREIwh k2rz1LHk1zkFG4h1iGW1W8sbeOD7MsjSRSAhF6LkD1x+vNTtcukWyNYw2CquB9wH096qOjA5Oa9h FxDDLIVlefy1ZzuXf2GfU4NbX2SC7neeJdpWMR4bhQw/ipzetkB//9H+MmS1vYZ4ltJkcuw3+YC0 O3v0NbF3pGrQafJOZktYZSs8cNvJ5S3YB+UtCTnuTu6cnBr52XwsxirslsbSK4gnvNQunkuBCHg8 wDbB0yDnnpmtaCeK5sY9ir5KlpUlRQFlKcFR65/rWJUYtN3NnSbCx1G0up2WSzkW3WWAuNuMkbsg 9CM9PWu+8GWemRy2EKXF7EGvBFPJdRhXl3cYBPHPbp2rmrq0rBdptH9lP/BCPwsmm/BjUdat1kjm 8SeJ5pNJS5XEqJAiRMd3dyAfpvr+nHRIilshZERo0VSqcLnoa/Fs4lz5vWfZ2+4eW3cJN92f/9L+ wzCud6uA3cDmll+UIvUsPmHQ1/KyWtz0XuZ8vmAuqtwDxjtQYHZ0k3bcL24P50xFdyfN2qTjPzc1 aG/PcL90e9BrT2IstkqV+YHjjgCmTrhkGevp0FOKu7Dj/kf/0/3ChcrKv2qQbX445wPakneAW11s SRlliZCAdkjDBx0r+OpSurFyVmU7OX/Q4nmRo1jX92rZD4PZgefzq5O0csW2KL94MBQxx97HJ/X8 q0pSs7HPPR3KN1ZPZRK0EkjoSGkKjzPnPUL7Z714X8e41bwNqck0WZn0+WyhlkH+jt5vy4I7lM7h 7iujDv8Afo58U/3L9H+p/Ff+1nptxo3xT8UaRDKyaZ4hmNxbRTSebcWVwiJ5rBsY2MQ7AdiTXxhq +p3FlYQxxLcFXlFpeMZCrcMVLYxyPQfjX71l0ubAU7fyr8jmyqV8AvLT7tD/1P47762muo7c2ivF HHJumkMh3Meo57dDxWNqWqPFYXOnz/aVvGkFy0zR5hkBOAquRyepODxmvjo7HLJpJo5PTLi6mupb rULmeKCCUF3gUSSMqj5VCfSuouzf6hcQmGyum0ydNtnqlwQsGc8ow7EDr9a1g+hiQ6FZS2dzes9x u8+dZBDgBRtAHB/WulNznfKG8q8fIilJ2uh55JrVOzuYybb1Odhvbh7Vre+WC5gU7jd7dsqP0yOw zT1tY7eSRTZxn7RCpM5flwe35AVsmmSf/9X+M8+EIrm0W+s5k0uewtpbyVF/eG8KgkIpPTPr7VDo M1pdeXcSybbWJS8oVgt0zdBhCeRnrXgNt7njmy9t9usVMDK84lO2Zxtkwegx7cUqaHbNEZLt4zdx RhIiCEdicZwOuOOaRcea5hvokDyy2pUrcTDco27lkHTBFakFrBbwJauu2RAFVYzwoHA//VW8XdG0 dGg16Syh0/7FNcXVv5m0wJCoMdw4PRmyMcZ6Z614l4rkN5fedHaxWMQRI47aJztbYoUvz3YjJ9zW kDc//9b+E1GEZKSOMt/COi1A9zu2iGLLJIVZz0auCxznT6OIvNtZDuxaybyinbuznIP5mvQ4nHkr cIoEc0hQrICskY7HpSNYq0mbljJNb2v+hRrG6EmModkkxx0z2q3ZLdW486e3ja4CGVbWSX5Vb+63 Y80GqjcqaoPLuoL6LTrXSdTKp5E1oMiOUgbZCpOG7ccCtCZLua2/sm9iW7123U6l9sjVYU1HcuRC 3UDBGfqaB8jP/9f+M7TjOsdulxm1mtLsXTJGiyojD/ln8wIOOn4U67tJbeeOaS6E8Zna4YGTDIrZ O0fT09hXnm3JEvOZ4hJZxubeKeJWEsgCxSll3ABj0PTms3QHvoIHW7nAXzWBcPv85cnBbjirhuNJ LYsXMayXUl4TvES/68NnA/w4H5VVT7TdTW/2R7SWxWI3EzpLtuAc4Py47YFaicU9Bk48q4IRjNAP m/eL8pHcGsHXpry5WyWG28+zgchY4jhoC2AzBffAzWqimkT7M//Q/i10+4Sw0+SK81ExRb/NFkfl eMkbdwHvx+VV45DdSSy3QmnllVfJnlc5RVGAAD1GMfTFFrAXNDm02C+lnure5/0M7oFdNsMj9mB6 kD8s1F4guoLiS2FgIpzI225JXbsz1Un1FXBa3MZL3hr6bEJVt5p0kFtgI6uNkRAHGenHSqJjh+2I 88ayJH8ygPk3CjrkduQRWpjNM1PNvZNOub3TbKwGmwXRjuoVlAe2EmVUIpyxIJ/Mda57T4TcTJae W4gjVjiVjjJ9B7/0oMz/0f4mJrO5trnyhbxkBt3mSD5R6Ee9MmvLmzdDaDy53BSRwcg9uBXavg0P PMqVHkQCTDSpzwPWm2cE0Z3LPGiluVP32NKfQLFu5u7zykjE4TBwqeWCCAenr+tBnt0mUrAsBunG 5cHZGwABy3ocdaUFd6gZU5mXUZYY8MscvyyowaJx3Kt0I681clLfaLeKFwFdwpcPxGxPV/Qe9aRX KrAf/9L+J6VYYL17OOa21FYVDPcW8m+Mtj7uR+NQ3BV7aWS4ZoNhICcY298mvQPOOfFozsJoZf3J G8SD5s1BdLI0LSbh1wzdM49qtQd9RixWiSESK3mYjA2gYycDOf1qOae4gKRoiBg4GG4CitRNXVhu oXAwsuzexOMLgY9zVeSQypFI7jzFOYyHOBjsa1grIxas7H//0/4YELuQjDc27LOD2qzP+6lCneYV QPnoT6/1r6A8+1jWn+zrbQyW4CxyR72DH51PoRVNJN8KR25PmKxZ1I+UjPFBjJWkyqbq4SVvLKg4 wXxgjHpVBvNkV3X5lfI+bg5HegSbWiLltpE0ts108iRKMgbm+ZyOwFQwWVpE6XlxJcLGHKzhOWYZ /hFBbnppuf/U/haa5AM0kcUmzdhZGX5QO344q1BcRSYKZJI/eIflx24r6A8crTIFV2UAsx+Rc4A9 6hsmMUpR3xvPU/dH1oKi7M0HsFmld4dvHLAfdq7BEsMy7Ygs0R2y7lztPcYPSgbldqwgk/0jzFYI Q2Ac4B61NclBHG06qspO5NnzLn1raHwkH//V/hmll3rtjGWAw1QJDHiR7hmT5cKFPf3r6g8qMblO b7OgAiZuOTu6g1aN2Lvyo9iqI12hxxmguS90SK3jTOSCA24k1RkDyS70XCh8AYwGGa0jJJWZjYtw R+cW+XbsGcHgUvlwZ+YnOc4HNN8rvc2t7rR//9b+GAt+7YIX9Vyfw4qhJADtZi7yt1J6D/69fUHn vYmhgTy33YUgZU45yKrNNGZFRwC4+9nuO1Bzl/fJDEiSBHt3z5TrhmPfHX3otkihZsARhv3fA4Wr k9Ehx3RHNBKqSCKRtwP3tuCPwqvuUpt5dzw+RjNR5FyTvc//1/4TLaKQzGNCyKBub+6RVwOnmNFG JNyKC3y5Wvq1No8qa94hlvELtH5ZUqPvD7p4qqLjz1KpwyNgc0OeliXFrce8sYCrCCxH32bgk9xV 2CM+V55KAfd2ZBY/hU3a2LgtGZc7MXKbSq54xwKECuQF5b7uG7n/ADikChpqf//Q/hPiJRSDxt6r jrWqBDDH58XlySzx8Kwz5ee2PWvqDyLWdmYShpHZJISu3uK1Ff7NiQxqU2gANyRTSu7G5C985cMg Xrkr1FRzR+cWMaNtI+Y4wM1uRN20QafZMjuWJb5Mbc5xS3FnKkKXSfIkjlDG3DxEdyPQ0GR//9H+ Eyztmumcbi8wy2AeeKkktBC/mNkEHG08Yr7A8ctx3IQlmAeMDhMfdqm0gL7iAVzkAcCgC203mx7A VVl+92NVVKQSKz9D0xzmmtGAxrl/N2wc5OX3cDFWftHl7SBuLcHsFPrWqknoB//S/hR81lG1SZFb hm6gZqBzGJAA5+UZxX290nY8csTRNNGkgYnjHA/z6VXVGUYXBI7jgjFO6Ak3u0bGQu4AxgnJNRJC GhMuHTBwD2NJyS0IjO7syW1cvlBwVbgnvikuI8zZz8p96Zm01oz/0/4X7Jh5TDHzL0DcVZMUl0yh VBQL846kEV9wfPiOHRQFwUHytx92qM8ZDpgqUxkleoNaQatY1gtLkywht0qoTsTMmeCQOOavQXMU cTLGPmPB3H7tEXeRdhk0rGRDGVVtmUI6is+88wpluf7zDqau2twP/9T+E+FBlWLAYIwT2rcmHlj9 1COFySD978K/QDwnGVzJSVi4Krkg8rVxkUIsiBlmcHzEcYC+hFVGTiQVmPypy24N82KtWcLmYy/e BXbtb7v4VpzoCxM0UbyeURuPyuvRRWWEUGR8gkfM/wA3X6Vk9Xc3Wx//1f4UZf3mHt3dB0AZs7T7 Gui0+NTEgndRkcSepr9AukeOZ8qyGfbIqmF2IjYkZqqSIztVRnOCQOKT0RcW9kWLSAzGRZVyp6An AzUtzE9u0G1iVc7AoOVH400KSaeo1lXfliS3QDtmmq23zEK4B9fWghq6sf/W/hhjZgMEbBnJOOKW NDJKFLAAnJ44Ar9CUmtDwXFo03SOGMhiPMYEKOzDtWYjlAQFyCeT6VJJFNBJMqgBflbLMp6ipwi2 8i4YyDA2qBwuO9XGXKrAaccSTvu3qir8xA4/Si4tDI2xzwDlWHVqtyVhptbH/9f+HKGHy2MbOqhz hBjGTU8mnrBsMpUtMPlRTuKgdz6V+jR+FHixkmRMY7NQ27cFGcgZxWGblppHBB8svw68PjsaoiTu 7GlEwTzGUtsC7Vkx87H3qDzhtKohMWfmOcE4oI2Ik5YkgBWPy4+8PrTrbyo5iDyq8g9MmpafQ6Fq j//Q/hw+zyTAy/cHTpwR7VeSxzF5iqHyNpOcDjvX6NrzWPHM5LYy3SpgF922PJ2DPvWhcWhZvJV0 RwuHJ9fSqFypma1vEj7G2uUPODmmzIyZKoUVl4I/woM3BpaFY+ZIFhcndjII43VUR7gFUUExlsM2 c4xVKLaIP//R/hfigaQ5UhQGIx1zTp4pCciRlEY2iNThSc96/SlG58+Ot7aRuWYgnjntU8tjMzqF YhQvLY4NSAqvDGdgUnAO5yOPfimr5TxFYk2gMW57n3oNJMc1vHElvMs6vMCTPFtI8sZwOfpT7iWO QYVhkrgsBUTirXFKV9Ef/9L+F6O1BGACzKc7uxqKclTnHzg4Ax0r9APnxtvM5do5FLseQxH6fpV2 KSWRdoTYqHBz6irjLl0YFaOYRySsXZm39DyKsPcCZyqqIxtwc8K30q+aIDoLddxQuEBGevB/Gqcw lVzFEzSbW+Xb0NNST2A//9P+GNLeWVSFXDD727pxUKZhdMJnaSJCozn6fSv0g+fFSTLZgALltpZj 8yiidbg/ux97uQevrSbsrhawvksAuOJAuCvb3q1asluoOBId2Tv7Vi/iAsJIjfMkeGB3blOAPaoJ rsOzREAgDl+49qVraAlfQ//U/hhhDyz4UFQo6gckVeihdnAKmNJGO4kdOoyf896++k7LQ8SMLO5E IRZ3EnzSMj8xunKqaSW5aaQBpNuBtye9JTVtSyrIWtmaV083eNqyH7pPpS205Teuz55R+I9qiTuw J7fzHkCsADk7hUwjMLksdysdqg8nP+TUgf/V/hpnuFtmSLzMyM3yogzsz6+lSi6uSmxU8znhSMN+ FfdRjfc8cpTStPiMAptU7weAPWpbVTHtBIwDweoNHLK9hN2VzTjlRWZFYRBjzxnNRSMu/a4OwHjj lq1UUtDOnuaVtcvGHQxpGY/9U+ev1qLUdQvb90hlnKRqoCrGcLn1x05qHDsS1Z2P/9b+HR2cKkLE licAAZ3+lSpvQO0pWNoz8qOcEEe1fdRjdnz4R30hJ8vIZuHfHSiO4k+17UJkwvzZ6N6itZbMaV3Y lu4oVUugO5+WVuNh9qy2VGkxI4XCfIewx0rA3tbQsxqpBZI3n2AK2Tg/UU3yNieeU2oP4U+ZqAP/ 1/4b/kLBwr7ODs6c+ppsznYFPygt98jJ+lfbvRHgPdlm12Rqw83Lfwj+E1at75oLkEQxzkAFo3+4 euKwEVQ32u4kKKImLHagGEX2rbaHR7PTVX7TLJqs5JKFQkMKg+vcmgDGFsEkVwfNducHoPwqyY5k kLOpVJV2uqjCOuen8qia0A//0P4fbvyYUXy1UxjoD98+tZ1rMQZDExEjHI/2PcV9QeFT3NqBhMjR ov77G6WR25JHXHpU1vpsPlGZvMy8hQBxjbjuO9BqUyotrgvkhA/GRtZse3alm82bfKCo2fMD0bHt QBTTbOwcy+WV4YYyTUE9v5ZO2Qsr8kp/DQB//9H+G2OZoSqB2Yk5yc5FXo791uIw06ZQ5jAxvXHo K+oPHJiqPH5xALs+0j+Ij6U63kiV3SZzhuUAXofrQJKwkD2pmlVyVKHEfAAc59ap31wskgR2EaKw UYGFHOBQM3NNt7eNdxJWf/ln8v6k1HNI4V5Jm8wRsQEXGV9qAP/S/iCt7iMQuqwoshbCsR82Kjkj y+/y/L3DDMDgvX1B44kob7KkKsCC3zqpyeOmaq26yeeI/l8vGdvc460AbcKW4iZ4dzynKmB128g9 VPvVW4jcRCNlAf6/Nz2oAdp6yRPslQIvXdnPSnXUMIut0RMkmM7v4VosB//T/iBjuGjeQMoZwRt+ XIJ9DU8kyzllkBLg7xEi4KjHQV9RZHkxfK9SJmwP7oA4WRM4qC0kbzpXKM4A4XJylQ4LoJu7NeSa IeVtYCQjPI59Oap3VoAN+S8j8Dvk1Di0IoWly9tHOq7SXO0hlyUIp85OxJZCDLjOcdqkD//U/h6E Ub4dI95Y4CrnAqzHpqttMClp+GjjxjYRX0B4so3LkFuZjI8wIlL7cBdnI68U6S7iM4t15IG1i4wG 9RQZWd7GXfQyW91A6SIS4DCNTwo9DTrlIrth5gC7T8i/wg47GmtGaqCRmywyKuwvkK3AxT1mYRyR hwNnJGMlvbNbJ3QOCZ//1f4azazF/OQDYQGY/wB09OlbNnDLCxSORgZFyQp++Bk19QeOU5YiHeQk jOciq8UcakeXt87O5s8UDSujSMbSq21FXYuXAGN2PWs4WpdmZ2IHOB15FBulZWLkUMk7jJCmEYDK vBA7Y71Lf6NdxwW8weNvOy5UOFKANj5h2Pt7igjm3uf/1v4f2Iht4kkZWfO3A+8fwrn2hHn7kyVU 4AIwSa+oPITtsWwJp1cAsXjXoe1ZsowodmCupwQeCTXOIlj+0LbmTacbsBcfMR1ziiORpweGwTtC DkZoAsorRZLYAXnA+8B3Nb1hZf2mwChyWXbEVHzk+3rSa0sB/9f+IOSzijdlkJEiHygo45HH9KqR jZLID+9RBznjB/rXuTT3PHKlw0Z83BHl4yQvr6GoIrstGIpIyip0IOS341mArTkSFTzEQCqnqOna mz3AjYeTy+MbAMY/zinZsB3lzTnc58tyv3E+UY9cVD+8+eEEkN8pI470NNaMD//Q/hb+xpGq7jlg clm/iqu8TR/vEPDcKc9K9g8pQbRND5nCZ9296likO/AA2D5ZVBwD25oE4NDozLbs8kJ3SD5Nsg6Z xVUidpm8zKtgHdtwooHGN9WaM2ox/IqEtIo2sxXG098UxJUlKOSrKPvKe2OuKC+RJ3P/0f4Y5isT sbbcof7+DnPpViBMgM0e4kfMRwQK9g8xNJ8pYdbeJY9gJlDHLfwrmke5VIBEFU8/xdWoLIYo5c3E kUKzHygBG8nCZ/yauapqV3NJDKsaKVs47STZkk7BtBPPBoAzwgMYcqGkIw3HIqF7e4wrkFONylv4 h04oA//S/htt4S8LuGCqDjBOC/PIFathAqK824AkbWjI+dB616zdpWPKnvY0BaIWjO6ARSA4WUgM WPTNVt0ULvbrADJ03DAT3BqZvoQVWtI2EjQKqqG+YDnBHYCqX2R928MFk6svQAdue9ZgOm8uCOVi 7LIxARupqBWHmOpc4VMmQrwaAP/T/hrhiZZPLRmKycB1OCPetI3BhVI3Me9GCSoF2hwBjJx9K9C1 9jzILS5UkjLbvs6FRI2T5fIFWY2L2rW6t+9VskEcP+NA5L3WU3xLEFCHJ+RpFXDDHUfhzXS6Xaxy IDKVaKNdq4++2P736VcFrcxMq+tDHdGVXby92djKMNz3qOVE/deXtQl942DPP+FalxejR//U/h8a CS4XBOPLPUjA7Ulni1uIpiVWeGQPCewI6GvTlK+iPHNVZ/OcPcbRKGL+d/e781fhvszRhn2IpBL4 yWHsKgB2sXE96krQSrGEj2ASrtLAED+VcK8TfaTDsDKQCTjHNBpDqXoESNjE5VY24Dn+AjvTzGWi 3mQBVOFfHek9EW1dWP/V/h3a4KoAMO+NqgjrViOOGSHynhkjuGbJbfgY9lx/Ou6LbWp5Si00Z6WM AlkMzSBIxmNFOAx96sXEoMexCDxnaOwqipRuRKsYi5BJJDbumK1bXTzKHuJJg8SLuiQf6wn+VBS0 VmXbS7WC1JlhwUO0MQN789hWobq1ktnULmTYGRQ20k+hoGf/1v4hLvTjLKNod5Nu+NQeD/nFMtre eKAh/Ml3OUZ1Tj/d/CvQPPGokMcwQqdwG0kjn6VFfwXUmwL5AtAdgXftmzyelTJXQ02tgtIrdYZY 5rWN5lX9z82dnPJ+tW/srRt+6mZQFDKVGHx3H04xWIN3dx4kjiR5hKpjkb5o1/gPc4qvBHPqLSR7 oorZAzC4kkCyOQM7dtAj/9f+HSSF2kECO8qrhmYDrj0/OtCNhaoyoil3GCGAJ/yKqXxHmTTdrCO7 pb4dVmkVsmdhhgD29MVR82bzPLDfIRuH938akaj7tmTpCIYJZmDzXO4s0e4KgXjG31PWoH8uUB2+ fzOSoOCp9KaWtjJqzsakUsVqiZP73ZxjpHj+tSs8kyb2u3mDtuCOOvqPYVs2luI//9D+HNYFmuZU mgjtgg/dSKcsPw9at22nNGXkwwKP8hHSUY6/r+lb3R446VYZrh4FOGKlS6jb5n0PtTLlI7RYW5Yx kD5zuZwPU/hTAtWs6TRsRb4LdDjGMdgabq9xO1vEhhhSBIfLJjH7xmz94j19/agLdCCG8W0sYY5X dgi7vLTLMc98Vbi1KdTHMCfJDjZGygY+oP8AWolFtnXBXZ//0f4kLnbcXsctwzRrtyAF/dvnvite bR9JuVsrl5CDA+4yFdg/Gq5JHObtp4dXUmeS3eDzWQCOYSqknHbk9Kydf0a/8MyW63MlvdRXYE8Z jmEgAB55H061NrbmtNaNkEd28yIvyRnO7P32I+lU7hbZyZDKkrk4UqNpXHUN+Rp2ZZnxwMLpp4le FQ+Cr/MCO5HsauzyW9zA8dwsewErE2/AZsHGaVrbgf/S/hju7CS1KlVIyT05Bqex+0RsZWUNtHyq w5P0oA6a9txNp2nrBj7Qlw7TeXlpG3ABVZfQYNc6u6O4hEtu1ysEo8yPlcjPQ+lD0VwMfWISVaYx qvz/ACKpwBnPH+fSspLYzW5kCNkZDblx0rknsBVQG1ljaJirq+VA4PFer+FGudRleFUYKyBpLlgV jgA6gdienFc89gP/0/4odR8xLtLJo5w5bEdwPuyY7g/hXR6Tay3iSrMsMkO7CjALcDksK8WTsrGL vdl2TT7UQH7LsBLlJPLTYwA4wD9c/lTI7eCzVJvMZ3MqrFbMxeeVn4wn/wBfpWJIviO+l0yaSOdh aW17AsMUHMk4YYJz9cD6Vkw3Ucs1uJZREu4BPR26AH/CgaTbsjU0uGxvDq1tqMVoohha6sJY5MSt PGysu7Ixk4IwPSnjUbm9medLYOSf9ILARKx78dOcZoK5Gf/U/jRk0i6juVurS8la3khXdGV2RWRP 3hjuc8enFa1ut7FeWa32+7s3UW11csN88ZJGzag7AZ69PpmvnZfCxKKjsSXMbtLPb+Qibl8qJ+V8 zrgkfT0rYsl0yKzjtM7ZLNB5iRjADFuD7DmsRmisoWOSSSSaG2hyz4G13VQecV6noGjmW2FzbA3K PEk1v5/yukmAylUHPBxjPXiuLFzs2zNr3j+4n/gjv4Wv/DXwK+H4uJ7ZNMuS0scZJe6kldU89ycc Kx49tpr+ga3YG1jESbPl5Ud+K/GswcZ5lWmtuZhlM+fDyn05pfmf/9X+vuEPG29i2O4HIpcyMxd2 Yvj04wOK/luNlI9AYs2AykYJPGR/OrsDvlBIBtP3vb0rMCG48mNgMc7uD0HWoJHO9Vj5yvTtRsaQ 0TCTdHFuXljwwJ6Gogm9dzN9R3pwactA5nGx/9b9vyqzFNyBjCc4AyRjvVaabE8DrG5ViFC4wc/S v47UfdZcnzK464V3nidlJjWQNjBC49CKs+UHnLIy7QucdMfX9KUNzGS1RZnnY23k+Wm4MCGH6/pz XjnxE0+PVtI1i3kzdWlrplxdOH+WKAxwkqVB4J3Ht3rWDtPQwxMeaPKfxs/tnaJJovjrWZtTuQ7x RPd7TGN6iSTI5xkDG3C9eGr80dcubm5IhjgieJsSpceYUeUHOcJjGQO9fvWTTVTAw9EcOSxf9n2l um/zZ//X/jf1Vjp6aeIdReGW6b7RBHIPMS7QEqQPTGCPwqjriai8dpfXUhkhhOFt52wsgwCcDr6d K+PSskjherY21vNJTTb+7a1gZYbczfZWHlyyHptX0Yf0NZ2lXd9b272qwXC27u13BYXEjOPmGdyr n09K0gmtSS3Bq0EaSLcwtCypmKWFSZI291psSyXckBEtwYpFLyGVAOD0OOOevFaGMk0yhfJqFtKL aGO3miMqyHNwQJF/21AOCOePeugtVjvFvLdZVR7AIJEVhuO4ZBTsQOMkeoq4NLcmx//Q/jQW9a2m EM1wI4dvlSSMcYQ8HP1qktvp+oXyXWmIVtNPlMYkCFUl45U9uevHp7V8+eWoJo0n1CSyni8q3bY7 4ZiuY14JyfQU7WTFNPpU5jTz4keeGVZNzr5nysDg+gIpXSdi4rlVi9NHPBBaahGs6SFt8V1yBlew PTseKyNPmuLu/jR7eUmWTykkb7rHsc+hNaQdnYpbkt9bXV+/lyzIsNkzyeVIAEkY4xtY/SvJvEts kk0swaGGSKQILeJjJuXBy+cnngfnW9J3Wpuf/9H+DdG/0oxzHaGOEYHLKKvojRLtRvMKPvU9DnpX JFXjY5rq9i1Hcy26KkTgySMCT93Br17QZL26sY2lAZyu0blyBjjINKMF1NYO71Op09rZX8tSzvDg 3G5dohc9lPQjA603VZru61G3On6bFdCaD7KPKdvtMm0HOFA5bPanyI6IENhY3Ut2YrkzzG2UNHBM hbyznncfbHH0rdkijt7nztRHn/uwxRJtrlOuNwzjvx2rK1tDQ//S/jcsbzTZZrj+z1+02kEhbZIx cjJ43nrVfWreG6aC4icRvMhieNHz5e0/ex2yf5V5iTUjoMnWra9+xRyNJLIiKjB43zIVTHBH0GPp SaTcp5UhmhlQD5U3J+6lyMk1onbYDW+22cVowh83YwP2hViO9R3AHcEVSsrdcyXFsEFsziIOiCKU DGeR/StYu6Aq313DEtraPBdSpPK6rcQIXQYwQJD2BzVF5fs93KbaW5h/0MRjJ/dqxzkrx1+vtWkZ cpnKTTaP/9P+JrUbFry0gmijd7mBA01zcptWY9CuR9OgrrGS3W207dgF4Fi3scEYAyFX0FSpJgYu oILZmmEk8jxEGOCNf3cg9x1z6VXBsZf9MuLmXfNMN1qkAjijGOpbPXPGAK2h2MZfEyQRKGLoS8WQ x7MQeORUE7rFcpJCm9kYbUOHYKevHetDnk23YiltYvPt3tZGg8ucz3Y8zbFP8pChk49T+lTWt4n9 oQ3NteeS8TbljCAjK84GffnvQSf/1P4sdb1KS8SJJJWMyuZHiWMBgG6MT71xcdxNcXyRNlPKJjDP 8ob3Pua7IK6aPNlLlNq7jEG1AivJKoy2egqtcW6RwLGCfMc8sB0x2pzWlyFNiOgZUJbpxt2/dNZd 3ehGNvKjfPlYig3bT70U9i4u6IbUtaO80qmdlHKdCPpU8szadcAxWlrOt4vnS+axLoOmDg8GrKP/ 1f4gdMRMXM0VstqZudsfQn0ArRls5GVob2OTyLi2L7unHQjmvRjujzzLtYIrGL7PaFhbqNqxynLD 1/rVK7kgzsMhJHSPIw2PStwJVnjESPaJ8+cOCfzqvcRmc/vmK5G9mXnZigCHEF3HAiuQw3faOquc HjAqmlksBJk3BQ2Qu7kitofCYy+Jn//W/hraaKRcRRrHFCANwX5mPv8A57U0T7JEbl2CbVyMgg9q +gukeXzsuidRtkkTO7grj5QPpVi2RfncIsZPIHbFSpJ7kN3ZmXMQeF51aELFJyvmDzWB4yB1rNSb LLEAQWOFHaqEbT27J5MZkfbkhfRc9arzFIyYyAwU/LnoMe1AH//X/hluobW6tHVJpLeUEfIg/dSY 555qhpo/fDeAUT5WzwGHvX0B45uXthGXQQdVjzuPC89h7dK5CZ1i8zc2SrYOOQKANGO5kdUSORow yrkr8rZHINdHdXs16BPIkaXHlBJ5VyJLtuf3j5P3jnnGOlA1ozIkyybVRnPcKOR71XjSQxoJTKsZ l4CjcfTpVwdnYaaTvY//0P4XLq3lsHSTfujYdfun6EVVVxKZGfPPp0r6dNtannJp7ESw7iCxBAOB 6molUBiOiq2QBnrRfWwxklzIjBQx2t1z2qzBfRIH80MzbcL6UwtbYmiuRNG204k/hU4BNOtrbLSP K+4quVUHkn0p2aVwP//R/hQVZi5G8/MfujoBV37XEhEboTsGC2K+oPPMprl2coFYITlWximeSZJP /ZsdKDDZ6llo/LbcC7RRYI4wKuR3MEcYXypPPZhIHbHl49Mdc/jQXBWZbe7ixuXhpPlOf4T61z9y JGYqqldp/wBaDjdQaH//0v4TIbhV2xNuVj8uRV51dZE8sBlZcbh1/GvqDzmkzPu2RT5SrxnJOMkH 2NUljUPuVfm/nQKXws0YRDIF/dkOD87djUvzI7FF8xEOGU9KBU9iMqrPIjKS6ASMMfKAfeqU5VSp RcYPTvQVfS5//9P+EqORyjcKSeOnK0TgxIhXzA2flz0Pqa+rjC+rPIbu7l3T7c3BYBgWJBZiRhai vZlSVoG3ERnDMRha0SS2Lg+hThjeeYoMKM4VhzxWm8flBoQ8gAH5/Q0xT3JLBhYXENysazLbOJXt 5z8k4B5U+xqXUdUkvbmeby40Sc/JbogSKEDsAPSgg//U/hMtXEFzG4+STOR/dH1rdv5o7iR4g4K/ wsR94jv7V9geOYiRjbIA4O08EHINQNGcbstxyR3FC1AZg5yzFC3IH96rsNlLJGZGbdt+4i8kfWgC pJA8Uo24LZwTn86umWKNQksSk7efXn1oA//V/hMiBUgKMKxzt9qfJCqytIgBQj58j7tfYHjjt9wA REwCBcBQBUJjdgqp8o/5aOf5CjyAlLSRfI6g84Vl4BHvVpIRJGQxwCdwQcAEd8UGGqIDbHzUwSBn LbaqFRJLuXKoh45rSD6F8l1c/9b+FnYchhzkduKma6ntztgUkkbWx3zX3B4DVnYmRHK+SMh2YFs/ w/WnS2sQSSRZAsqMMrng9ulBrD4UZ5MyuAzKoYc56UzMaRkvkM7EMynjHaqh8SKG2sqQFuDJk8bu wq6JkuCPPAVV+6oOA2O1bAf/1/4WF8l52eSMbAeEHCr/AJxUrztJIVBIQcA1+gHjiQCJN+Wy2c57 5qncTOZtiMxUcZ9aDOaS1L9qhiV3mTO0bhxkHFT+Y2xJASnPClccUCgrsoSvGxZsnzGOMEdaUmEb YxhiVwzDgH8KDU//0P4UkVFkxklRxj1qbzpYV2gEwl+/JWvvJJto8hLRsfIHaWP5t8Wcbc5xnuP8 9qvW8ULxzhgwK/d/un6GrtpY1h8KIVdYvkyTkc5q4vlywqmNoXLbgeQaYpq+qMm4SWKRTuJAGc9M 01ZJbpCApJjPUdaDI//R/hh+YRIjttL+3P4055EiZYAxJA+YgcNX6AeLJNrQZKkjkSBy4xgBv4cd gKaiSv8ANghAcbRxux60CUFbU1fs8a2/n5w6rukQcnH0oto0cmVowGK5RM8H8KCXB9DpNN0iOT98 +Nx5CD7o/CsvVkNnOwDEjfs8ojDIR6D8KCLH/9L+HWSeO4SKIxRJJG5PnKTvfpgenFULy8kk3I+V 2n/Wg4J9q/Q4ytozwOV2uAbzoFBO+MDaT2yex96jtreKAPvJYM2MHgLWiabshFk4ImVSoQYChTkH iqvksil1yc9R0H+eKYCbCw+ZduBz2qxa2m8tvOwN93Ixmg1hK+h//9P+HkTFB5aKZFQYYEcCied4 4QEfqeUGeBX6P9qx45TiuU83JQPldpycbT61VuZp1PLFlPBYHn0pgQBZA4KnJxuz61c+1TsuZ0Aj SPGR1YigCK3l86fc6EIvAPfA44qe7jihTEQYEtu56EVptAxkrSP/1P4bbTayStGvAGdzcDNRSXGV 2SIoOQc96/SU7O6PnzWgjSSEOzCM7eN/yimxOUEhMyyAHBUcgY9KQGdcTeb8iooOc/KMFvrUG1fJ IcGNm+UIOc0DYzcyRNGTkD5eR8wp9vacAs7Bz91f4cVE9hH/1f4doI3AOWVdvABH3vWkexMoMkbb j1Kgc1+gHz5nvGqFieCvTA61Ww0cYYMdzN90nk0AVJShkUr98DDADr/n+laUdk00azId3l8mPOGo AgdG/eMA0bA/dPT8PypIncc7hkDBHcUAf//W/hht5rqWTyUKgt8pOdvH1q+6+RCo2gkcsRyT61+i weh8+ZmFDtNDlC3A4+6e9aFuojRfMG5wcnIok1awDWaMyAt8oD8L/F9KpT4eVokLKjH6YNZ31uaQ j1ZdSymFtlVIUHnn74HWkFpCGL7iAwGY852+vNItJLY//9f+H+C3gUlySuY+O22q7Fk81WLMCMjb 0r72a0PGTuZElyHPlRtKoVgX3Yx+B/CrUMC3F2qxKAkkeXZjwhA//VWbVhjpkWGMW77rlY5S+P7n uKqPB++RhuCbgc4wU9qRDnZ2NaRULmKLHmkZDL9KgnjltcGXCuRwScjn0oKTuro//9D+Ft0zMmGG /O7cDkn61bhmHMbhmkLY3r1Ir7yn1PHL20pAQ0K7HyoYgZxVNcKCG2KudqVoBaggj3q53MB1zyGN OnlkRi0kfJOEOOcUExjyokjgmaJrlpECr1BbkfhTIZFL+ZKNwH3cDigye5//0f4fxdBSJigTynyk w4KntVCQSXE7Zbdlt5YHOc//AK6+9gmtzwOliZ4kt45Y8ZeTBRkP3au2aWUQ82VyzomREvG4kdzS mi4IZPILgL5YGASrEdAfSqBtJQ2CmWJ+U9jWZoXLbdCxYhSQcEA8MPQ1NJErHEMh8huWJUgA98UA f//S/h/8tUEZ++OjkHOAO9PmtraRCoIcgZB+7zX3B4LXvWM42ywoW3EsD9w8Yqublj5kiKAV4+lZ SjbUucb6mhbDy3SRm4Zd+F65IocPNLl04DfLx9yoMjbVrXZ5wj2yRqFZRwnHeon1JbhPJ2gKD1xy BQB//9P+H54I7mTZG5CovDOMfWs82LWszoCshblStfXtJ7nh0+pPESJdqcSKuCM46df5VZkv5dyn cyMBtEYyIxjjpUez1JbakyOaOeb98x9FI7D8KkunJ8tIYtuxAGweX+tDh2LjPoyjMrI+ETaXUEkc CrdugjXEuQsnDPjIHFZ2toUmnsf/1P4f5oS3lKFG3b+74A/E1Db6QrTebLlTE+8Hua+rjG+545fe AKrASiMfeiP8TewqjcQyNseJiVAO5dv70H3qWrOwFO3iV5CsrN14boRV2YwwRmGWKORyd6SHlz6A /lSBK+iJ7W+lAZCoHQkn7oxV0Sx3MpQACVhtyBwfr/8AXq+Rjas7H//V/iFk097V/Lk3A53AjqfT FPV8sUMYZXOxFOcj3r6g8cjkRIm2xgfKfnbrn2psqhUjeNAjFsBu9VFXeoEtvdGNikgzORtRtuD+ FWpLMOVmlacP/GjDAX0AqlDuJ6IbNDtCLG24H7w6NTnjjeOYRxSKdo3EdeO4qeV3sSpe7dn/1v4g bJPLcrMNm4Zy33xjpxU5SNDNsYB34LA4IA9DX1ih3PE511Gm5SZo4ZZPMIIRc/wjoM+1TxGNHKNK iZXDFF3A496Tg1sJz7BPcWkO1BZkzFwfPY4+X1xTrVVdneJ5HYEuQRjZ9KlprRi52Zl5aRrGpQlG LkuAc7s9asGON4o1bb8qrG7d8Dvj1qOVWsHOz//X/iMt/JhUvaNITuKnfgA49KS2nka4aRZHhlgb IXG38c19E4tHic+mhcZpZkVw5EuCHaLhR6GufWJ/PG7kB8FiMM2Dz/KpM7u9y/ORcMjx7SYhuSFh 8xx1461D5wdcNGN+cgAbQtBtfS5Qn3oyGQgqDwMYK/WpliSWNxGqiZiCFGACKFpsM//Q/iAtLWW6 uobFpFtS3yySynEcfuf89607VHtJUVCkj5KAtypA719QeOU7pmjkmdxufd8gUfIPrWciTTySzlFC 5ydowF+mKB3toQreKJo2EvAO0jOM44wa1VUSuCpwOiovKmg1UrxuasUcdtJFIqeYxO0xg5K+5FNv JnuvMQMxjjkwSv8AB6A07MxP/9H+HGZZI2M2ZJBHIVQhMFfpirNtDHKsZkP3mz8x219QeK5WdiW4 WC2O2I7pHIXK9D6Vk3ltHHukZcSKdwX7y5HtUciuNNPYb5rvGWdgZGX7qjAQf/WpoQ26iTBXcMZx ksazcWnYUnZpEZuWjDB0y5XCljhufWrtndzWsfmK8iOOUIbAH0pFH//S/h3tpvNJkmYk5LBietLd T29wkSWp2XKSMkmTjdnGD/OvoDx7X2KRtmhTMih28zLYPAHrUPEYIIJLnIPpSstjWMO45IhJuIBJ HRsfdpqQjzwZnyAcF0wMDp0pkS+JlzcLa82xSbiU+84D7VOQTTE2xSzLJtlUrmF0OGz7iiy6kn// 0/4eYtNuL2OScRFoYo8lfu5PtWNKjq2MFUThkYcV7B5qaSVx8cLbWlBATrn0qJPJILc7gcvkYoBt cpo2cTXEyrtLKedw7fWjUz5LG3ZueihBkkGgIbWMpLGZGCtHlJOTu+Ut6VcbT3tYgwA+ZuV6mmtx OaWh/9T+GP7IzKkkQZmJGdpwB7VpyAwqm7Kv0CCvZas7HkL4isyq0b/wyE7nXsOe35UyK181cl8u D8oIwCKRub9vpxso3eMK0so3Nlsj6UphDDDuio4ywHOMGgRkXSosjLCSBs5z0OO9VYpHchXcuFXY innA9B+ZoMNj/9X+HZVACQRhQB+85PIOOn6U6V9kG/cFcnDYPJ7V6ri3JM8cozveSqFTHzLuDk52 /hV2O5nWGCNyH8ofM4QKzk4zk/hUz3A0LZowmxAEaR8sW4H1pLjFuGW4DMesThcZqAKMRjnnZGXe gXIyMqD7mpH0smIMWdRv+YoMggdqBp2P/9b+HPAMuxVYKuADjk0+5BjH7q2kkJwrSFSS3Y4r0U+X Y8yGxq2UUVtGs0iuN67CPU+wqncQDzmZFMcZG5nP3ck0gm7KwuYSqRDdCv8AE4XIJ+vvT7Zpo2Zr aGRo1Hzkc5PqK0g+hkEkUty+9jKqr94PnaAT+lZph+xzttm3EtlNpyMH2q3swP/X/iEtJ0jSVZcM mN3mDsfSs8bZLraeIwdxbqB6AV6B5Lty2RdmMNoogLyuNxky/LLmqv2hisixRNLvH7tmO0qfXNBJ NHKnyrdTTG6QBo4RGXRx3DNniqrNh43eSMxyMfukF0A7YoLg9bEhWN1c/eTPynuKigPlbg7blBLK D92g1P/Q/h5tjFJLJM4TzHAEYzlflzWuLeVJVlZVZXj3MS2WXsBj/PSvQtbQ8yT1ViD7KRmMoGMh IUjqBTH0U2iM5nD7hu2sMEcdAe9XGNyzFWaYu9mgDqwB3Fc9x0P6VuI0shW3RmtyjKhG3hs1LVnY DQvdJWK3SZLuKV2Q/ut+6SLaejDtnkiuYa4lt3XI3s3XsBSA/9H+JCUCW1zOXKNH8rwuBJGenJ+t YCfabUxBLmQxl92GYlm9zXpppRszzyzb3cR8xHIMrP8AumPLCpNrzSLFtDyBuMHgH3rN7MDRuYo7 RkaWLa6qQ5TkMR71oQzJf6fCIwlvLHIUZjHvfOeST37cf/XrAaTexmyQWkDtBcOyYYBtigsvvt/p WWthLLMzxSZVWwi9Gf6jtQI//9L+Hu5ntY0hMEt5FqULFZozABaMo7F859eMU9UvLqd7oPC+Ixtj ztUkcYAFaSj7x59gulkjAicjfty6r0INU1jnlkYRK2AuAdpwtZgXI7e8NqtvdRAPGd6TZwZVOcY+ nvVVzJENqwgD+FhwR700ruxlNNO5IsL3WCoZsKPMfaQoPoa0ShFt5k0Tp9nG0+UeGA4X6VU3d2IP /9P+ICcBUWQKqCQDe0nLqOvWrVnfKNsgkVraEFHJHzdwMCtIxT3PKhHW5bP2ec2xSMLb7soQoWUk 4x2zWhLpgmWC2UQSSMS8jyvjygAce3OK0Cad7mYDYWQELrc/2m0nzWuz/QwmBh1k7nsR9Ko3e2eX e6bYY2AYAlgKCVoyBBA0rNGsnIwSOW+uKZfwpJEgRWYxyEm63lXbgAKVz0HNB1QaWh//1P4gPPur UQxSbnIjXDSJkAY4/L0qS2mvpLaaQnzbS2fMqlh/F7d/wroOcsaDe6jZlnRlmtXDCO3f7qlv4gRg 8fWrnlgl1uXfY7fIGZn2ZPQZzgegoLg0tzTtIDaSNJGo4XbGzAEEEcjB/KsK6ixcwq5YRbi0mw8E HtQXzxLV3P5tt5SZEkY+TbwrDpg1zrqk1s6OrnYeNvqeKmXwkym76H//1f4h7eOFraNZppDMG8oR BcoV7Ant6UyfyEmSKCXNwTtaNhtijAxjB/P6UGTm2dboVosUqagsV02f3MrTQEWxKHJ2Hv8AWsfx hf2gk8y2RIZLiXEsEUWFKgdR7kjJrOUt4i5nseT3920mMAqm/wC4PXmmm6keFI/MfAG1UU4P0rmm 9bFc5eght3W1hkzHPFN5ssgA3uhxhM/5616xpDyoqpZ3M1pY3DfPaIVKsBnk/WsJtPRFRkmf/9b+ L+7sneEETmcJJviRv9anYiqtglxbTSG3mliUgq7bsHJ6jNeFNq9iG46nVWayxwMGkAcIVdWw0Zzn np/nNVSDZKk+3z2ZiwkzueLHTb+f6VA/dZV1C9g1C+jurkyXwS2SBBLFnyyM7vr2/Ks64tbFU067 jZ0WS7aEwSQGLymTG0rnr3+lARVkXbjQDd5m0e88iRyrTZQMkjjG7I7ZqX7D9mLSSu+y3xMdjFAx Xn5gOwIoKP/X/jiVmuLaGSVmh3neEXgvgntWhbyM1wblj5uyPZBEfljBxgMR37flXzs/hAnjuZ2t NmpRIbi1kd4p0HzyI33QfTHTFYlrBqGoT3tnEvkCcn7PcqwAj6cSbuO1YgdZb22qtc2um37uVRVh urqJFfeAvVu3OMYFe+6FaCwXS7VN8Ym1G3guBLwZFZ1jAc9QPmB49K8/HK0bgf39/wDBNHwxHa/B r4e232OK2j8PaDtaLcGjnDOGQr3x8vfnDV+vEU6fZ8hQrYxgDgnmvw5VvrEpVu7uVl9L2NH2fZn/ 0P7BY9uwFhgkfhSMyoMkAZOOnH+elfyuejeysVRAHYO3C7sj9K12WEIrZCjvzjGKBGLJ5k03HzIX 2qcdKdLCUdQeGT8jSew+hDJHIRuY8dM+v+cVWEgWZIWJJ/ixTproOXQ//9H9yYWhVNgTy5lGZMMW Dc0eQJDGWcLs+6QOUr+QOX3Whr+GR38EkYRo5mlQJhsqBk+pxWNby3nmkGNCC5AHOduOP8+1YxVp WFYvzqsMajLFm4CnnNcJ4ySWTw9qsdtHHiS22XjFgskcbEgsozk9Bnihu1TQwrLQ/k+/4KiWsHh7 4lyW2m6bYSTXOnSXE960oaWeS2MajdFjO/BGccDyx61+L9zHNrK/21blPsdpK0FxasRHPEQASzAc qrHgH9a/c+Fp+1yuEv67HHl0eSnOHmz/0v41mstKW/0144Gu3hvjdyxTSZiSMAnykHYcH6Z9qZrZ W/NvGnmuYnMiIpPloDwQx/LFfI6Jo4W7NmC2nrEGkhuXAEuSjj9247qfoa1iLiWLf5jR3EEPl27q u141weh/E/StbokxoYzI0sU8y28xTIurhgxYKMkkY65GMD1rdhVU2iK/S9fapzHGyRRA87Oefy9a ZE9jRaG1h1NZo3jknuLMQyJKoiRevHPUj1rANpc2N75xXa7r5UrQkuGB5wP8aDI//9P+MOWLTL+2 uI7pDMZVURr5nlzxYYEnb36d615bW8t40gsxHFZx4mu7dn8qYnAVCI+/U5r5i7PNi/duXpIXW32P ECHh+dmXJAIzxXJ2EMIvIUvppbe1lO4SNGzlV7BR1xkY9qRPOdJcadNdWbRTXl6ljHAcW4k2rFkk rJt6gHPqOtc9pt9fWaT6brl28VhHOh0syuI5CrgAsz91PaugcZX0Z2kEdtK0kJ8qZQPLj2tuVfQ/ 4V5L4m0uKw1i7tbiIQTR4kkCncZVYcN+ldFJ2sdCmrXP/9T+D3UbLypVmE2Y2kKb84YY9u1JEQrB Y2YlP9ZjkCuWHwo40/fNS1tZJZyqwtKzDd8oPygDkmvWNBuLyKzS34kjgJeJuhUHgg+3FUaHcRFU iWQKRG4DtgYqtfS6b9v0G7TVdS05BPiI2sYRbeTHJPc7sYycdqDeL0TLDX9/ZXE15Ck99OsZmDvN 5Yk5xtkPbOep9arzlpr/AO2GMJvjFxbxLJvVZerJg9VHP51lNalXZ//V/jYg1uS7urdb7So7ewlD RW8lta/Zrpp1DbvNAG3YcLg9vxrQv4be1tY55I45ZnjbKJJ80ZOQpP8APHtXnlczvcpWpkltlSdl y2duOSB2/Gqk+lLNtZbm4VYWywQ5UjuNtBUZNuzKaokbSRRTO4c85UIwHpTvPWEoYx9ntGbasfVG PO4lvWguTsivPqcNnNZWk8VyYbqcvEI4zLGf9sgcAds0uuQzAbrkPDCqlxLaxBnRcddvTPtW0XdG B//W/i7OoW9xbx2tszPEQp+ddm9cdSvqauvaabczxYw91aKJYAykQRg8Y3dM8dO1c4PRFHyru4u5 ZY5xHcQEgLG48srgqRn0I/rXNyX8UCtLcJazNvNpFYKxIaZsgMMcnaeT245reEtLo5y1psWoyabq F5qYiAtGBkaAlgsbYCdeSRgg49qnnj0ixnjAvnujJZpIs8cYcKzKGKufbpWnOyJpWK9wz3ixvp8M TIq+U0qncS2erDP8vSsyCxtonjSaXz5lyJHjJjCNyMY/Liri7rUyP//X/iLNzcW/2kzTgLL+6ZpM b8A8YPWmrHJI3mKAUCgbjw31rsp9Ty5p7ktnMzzN50ImMTlSu/GQOOoqreXbmdLJXORJvigU8ZPH J/CtPUzNCWSSKPaqAlVzIduVX61iQ2JjeS8RpJY9pjjRxlg3XP19qLW0RcE7kTSxSGRCsqXSDJVl xj8PeljQXCZmIWXGFYnGcetBqf/Q/hyiuTDcQbJiV8zDrj5R2rq5Zmli+dl4ON5PAFeitGeeYF3H BcY8tnDRv8vYN7n2rGW3hmnSQgSSqMKpPFa3TWgFqTy7IbTtBcZAU5ZaWGYTqgijxj5GBPHFUgMq bdDO4VcJuwxHWtOCBLoSSq3MMW6Us3yheBn9RQYNWbP/0f4Zbq1JEUVvLtJO9lHIfvUigAAHIccc 8Y9q9ltvc8ciZzLlGdQFO3B4PFOW4ZVZQfn+6mDx/nrSAoy25TO1irMP4ulOsoA0mZgwxwGBwR70 02tgL0zSxyC3Ry8qDcjDoc9qT7NJOiqzDz2bYd3ygH3p8zvcD//S/hin0+SAGJpA0g/5Zqc81WWC S3YhlYblGF6dq91TTPHHm6A/cszhcbSQMlaqQ6f57sqDLHnHc1a12AuTaXcQfMGSPbHkMeRn39Km guI5otpH7xhhmznBHpQBVW8MAfcpDFtuPQdqmtr1WK5YhhxnsKEr6Af/0/4YbhBMT5h3ocNu3cjF LBBDHC8gO4EgBD0r6i1tDyE7MrtZyHeUUqq/MH6DPoKpSW8q+WAFJkbDAnBWg2vpcintWjG5+Hxw p5Wq05G3aEIxgLgc0BdWuG2Qqj8J/CAD8xP0q/aCRNrOxBZvTPHfNbXSjdi54n//1P4YJTDG5Kup YrzxgnIrMa3eZ2MTF88sGOFTFfUpbnm86JRZnyHkk3AR4A24IJ4qr5hBULhc/wAP8WPekZPc2rSB 7mJUMY2GQHc52jHQ0zVmsIJfLtnkliQAK7JtOe+PagqG5gzMwIKEt3we1X4EedNnBYR5VFIBJ+tB qf/V/hU+wyIYZZ02sw+4eStSPMsabI8eYzYJPX0x/n0r6g88xY0macxFctn5ePvUskc0fQ5OcOO9 BMvhZetI5S3lAlFfLMOpBxVja1mpdWzvO193RqBJ2gZksz72OfmY8n1qcxMVwNp9T6fSgUW+Vo// 1v4TLaFn/dpwwOd2eKnuQVHlk7sD5v8A61fVxlbRnjkKM9mgkt5F2SnEmeoxWffTNMSytknrxWoW H2jsmGIO/oMVuorzKZJGGVH3Mc9uaTkluOzW5HcCM7QThiMF8/dqiimOMktvDMQCP4cUxH//1/4T 5JokQlgpKR43dcfWqPmMw3BiSelfWSl0R44sErmTyhG2B6DNa5hRUIYjfnI+nvUxk4gVHiLGPJUj OPUrXRfYkt4llSVRHImxw52tz1xW25EtGkYUkKpLsSTeQeCpyB+NMuIXDiRfm45De1BZ/9D+E9GI PnIAWA27fSr6vFNDsYKPMG1wOM19geORZEBMaxjAX5Wzx9KrbTlQMgH5vQCgCN5wGVX+YKeOKmV/ OcFN4BxGB60Csi0wmhy5xgDjjnisnf8AMQOkpIPsfUU07O6Gf//R/hKRpYSy5LjoeeR71dhuFAXI 3MDnJ7V9tGV9zxmky7JcKu+RX+bA2rVb57kO+fLYLkAnr71QJWVitKjgKWIYrww9RUcETyuAqbh3 z90CgZbuFj+UQIAyja5xtB+lV54XRk3Pj5cgL0H1p8zvcD//0v4U4dzHYBk5yW6VYn2pGNoG7owP HSvu5SvseORWkILeY/O7oh+7S7Y0lCqhLEkuSMhfpRGTTsyJ7F83Kww+SvXrubHWqxuRKTHvVtq/ fX7ufTNarXYVPqVpYSqk5zx0I/lVSNcfvHDcHCkcYoND/9P+FGOBg6T+aBluBnO7HbFWHBbJEysG ba8bDDR46Gv0A8fyFhi3TJ5mQqDarA8VafbapkuxUn04NBrGStZlWUxMGeRsHb8gXvT7Z3KvglVO NuelApS6InuWDwAo2SBhwy4I+lVYVltJY3QgDBLq3AagzP/U/hdlnd2Zirbs8DHBpETLeZN8pPC5 4r9APHIXlZXCrllzzinNNcjEiMNi8MmcEUAXop/OVBKyox4OzoalXzFkUAMyhsfJ1x06UAaEWoX9 hLG6s+GbjnHT1FVby+W4laaV90kh+Y9WY+tAH//V/hjcCMBlGSTux0anTPFKFaTarMMYPAGK/QDx ysQ8K4hI2gZx2NOXfcoOzDk88GmjGStJjdn2dtpYtvHzAfw05GaOM4LEKN2zOQauMklZkkgVWERL GXd8zEceX7VM7uAiHd97gCk563NoqyP/1v4dIJHgDMFJLcHcPlIqKRw64WRVG7a+eo/Cv0NT967P HIVitlLIJSzqd2RwH+lOigikuD9oLrAo3MIxljj0FarXYBpeGMukQJA4Qn7x/wA4om2RIud2GHzA +9AFUS7nEcWAOoYipGSVnLMzSAjaN3RfpW9lawH/1/4d7WPy7d4QQN/JTHU1TeBoZD+7Z5eo9DX6 dyI8OSSRVmnuHVd2S3T6YpYCkcW0Fi0h3OMYwaxMxrXCRv8AMrZ6KcU+XcNsjEeWRwwoAjZCxEhY FW4B6mp1+YiMnDZ+9mplbl1A/9D+G353Uqsm7a2N3pUb3ht4iFdvNHytjjdX6AfPlFpHcvIeQwyc +tMhVmLPJkqBgDPI96AJ4NLuJ908UUhiQ5Z9vyj8at3MqwyeTChDxoN+Dz0707MCpcSyyrj5AMcD +IGqa/6mVpuqDGEB3c8Zos07Af/R/hWjUxBdrk9we9aQmZgm4b3Ybd/f6mv0WKfK0eBbS4wnyiVc jjoMU6OVt5dAzR4wQR6elZvoCTZEzCf5lVkdW6n7vFTpbs6GQsu8EFlJwSPUetI3SsrFmWZjAkYL Iu7ByetZiM7XODlY0PryTQB//9L+GaaedZvLj/eMeQAOtTyTSRKFlysjJuCYxX6A1fRniRTV7mZh riQIF2nPJ6Zq7HvQMU3hY/ldscD8amUbhK/MiFzNc8xgqsfO8cbqWC4DK8cp4Ubtx4JxWTVnYze7 HQSBh5m/a4ONw4yO1W5pGuF5YMQMc80gTa2P/9P+GWGJY5G8xcuBleOtSN/o8nmrzlMsuOR+FfeU +p4Tm+hbXVEkiigliBVWLFV+8c+p/pVNoxJ5nRFHK7uo/CtBqfcmhkmCRqHJRSSDjqTUl7KoZd+4 kKAWx8oNAc5WglySFPm7jhgOgrU+xytG6R+Um1PMyzAHA7D/AAoMz//U/h18wtELd4cjqwYYB7Zq WJFSFmxsI5CnksBX6AfPlKO4Ej9yG4A/StFIHTCsmGPYrgihq6saU+pNGLIkQys8EURLuYky0jc4 /XvUEkkkTJIZP3iP+7jxlMD1rFxs7GhX+0EyNhAN5y+RjB9qtCY2/wB4fuz229atQXUD/9X+G+GS SeaXYxiiGSqk/e9v8+lWTKC/ls+xsZzjivuWrOx43Kr3EneJozGz5YNkuvJPr/SrdvY2hgdm3CJF 3HHD7vQj3pW6DKM0pyiQoTu4THJFSSNMsD7DiZgACRwDUSinqZSjbYfeLOtuCMt8g83YMMTijToC 8RmkDBMYXPB/Go5dLkH/1v4c3YC4ZWZ/Jj6bRtzmpoJYt7SSKTt4Un+GvsLHhRdk2JCiNcPIc4kG UI68+1OvkjhRAwcyMcBTQQPmd4o4owhD9w33mpx3xRs7kbj8rc5I9qAKnnGTYsp4U4UjqadG8hDo zkpk9BlVqZRuaU97H//X/h1Em0BQSyd37mtO1JmR45GyW+5zhj7V9elbQ8czFnnNwbTyydjE4Y4K EVtR/ucbCPMbgo/9ahxblcDMuowskhhHzRguVA7jt71AV8+GJuDO45QnlcdjTa9+5UPiQ1oGi8uJ jiR+SQflI5q/AkNoS7zPIzr8iDkj61ZU0j//0P4i5Lqe5Do6zeYigeYUyijHHP6Uiqv2fc0pSaP+ BVzu+v1r62Ub6o8cpBn3byc+qdCangc3Mg8mDmM7hGGyz4POP/rU4x5QC4j2SLK6yQ72yu376GrH 25pZJB5zz7R8ol+UuBVCezKMU0jP9oOd7DBXopx6Veiup5VDW5eKdDksvRcelK1mYH//0f4gZVkl mkR5N8u3fvkOGPGarqVZQm9WnPygI2fzr7A+fFNqYVORvlPI2fMfyqC2m5MRPzHnB60AFzDNJIr+ ZIvl8jk7T2ArQsEktszG4Em5fnToI/rSkrqwENzcpJKm0PndgsRhW9xUxMXSMMzhsugGFx9axatc D//S/iF8xdqwqoEjc4U4CVahaCONXuWQyFSqMATke9fUHgJN7FIXyiIx2hkVnkKFmUhMA9c+lQyu VC/MJXB+Ux8lvyrKUNdBEeHaZDHGFuEXAY9fcfpVsyGXdGbcpJ/z0AwpqA8itNECdr/O/QURJF5g i+ZXA2k/3T71cY31Og//0/4hLqB0UyNKWm2ZMi5woHC81li8mHBZjIPu8c5FfUHjksM1xdMwmQRh BiTb1b3Na9nttIJVMu9pMnBXlaAKMWlRvMxkCwxSLvV5MqoI569s0W03lXK52iNW2pH6noKC4tKL TNKS42CQNsinL7kkj4x7mqMF29yggiBOJC00obAc9Bn6VSdk0Qf/1P4gv3tqskQlDLKfnyc49xVe eFF2lGLnZnp19h+lfUHiuKbuZUhlwSSUGMe4pzysywgEuMdW5PHrR5BGKWw62hkZ8qNx5wvAzQ89 wyxofkCSHAbgL70FDZQksgDgt2YjrU/2QyIsADhEGQMfMQKxla+gH//V/hyneOFYYVU5+6uBj86p +THyxUBw3Dg4JNfQHlw7FUXMpldC5VM4+Y5BxVgPEHCu2/I5x/DQaEqzqJPKRvLRRhmx26VKkCSv 5QYli2EI6fU0GMndk/2Vldo5GXONm/oTio1ssOsXmM5bOHxyPQUnsSf/1v4e5Z7vS4zAhdopk2sy 87CO3tUMCDUItyqySxEhxIw2y+mB2/GvYPHI2SS3kKy8Iy4Ma4IFV3RWABXYqnOBzmiw7u1jQt5E 0+WOVW3iUD9z/DRqsi3UiSxxrGdw2k8kEetAtiJpYRKJpy4jiAxt/i9q3IWtpoFl+VYtpJVupHoP enHdAf/X/h7aWCJX2kqu7ARvvD0FPeQ+bFLOimJoh5NwzdT02ke1ey1Zs8ciMatuC4zy24D5R9ao NctEQjDr90r/AJ9qWx0EguroLiKYsqncwzgrmrTXQlWKJY/LO35vVj607sSW5lOsglZjLnbkEDoR Vm3RZHRw4A6EHg/gKRgf/9D+HpFSYzGNWSRBllOccf5FQG1nmKyCMyRR/wCsI6L2r2DxyFo9sxaN mCZwEPYegpxnVd4I2qeABWU9wJLeZ8oFbzP3m4+aM7Oe1WtQu3mcJcSlgB8g2gBKgCGCSOGPyreM bj95zk/Wryzux2xSN5aKN6NwAT14oGlfY//R/iGaLytrBxvK7s4+57GtSyJ+aSQI/kxl2V+N2O31 NegebFWRVl8++mjMbKiqxyrEBceh/Kp2tSomjlUyK8f7vaMxg+/v/hQRN6mTciUypbg52x7tqj5F HTP6Vqw3dultFbpCUuFkJkn3cuCBgEe2P1oIKF1OLWKRpWBMmQnOMn2Fc75N1eMG3KhGSgHU49Kr mezA/9L+GaKG4jWROSkjchu7eoqWzgljUKxxMxyI+rKK9A8ckLPe3QicsGZCplxuxtGOR+FTQs9p IgceZ8pRgRhX9xQBJCtukc7IWMm0tGd+QnPIIrIkiHmpLySOdo+7QBY/fNuUHbFjc230pJESOIOW YH+Ef36AP//T/hmtROGEpQBUOEx1x3JH+eldF9uaKHcIgOAdzH7x+legeUuhJFdTuglSPYGO0gjJ I4OR7Vm3bPcSkGdw7Dy8A/d+lNNrY1IBAloQdzGUkYI5/OrrNcl0u/NeFw+5iRuM3HU5/wAmkAsO pmZZY2IdtxBcjDe2RWbOrMztPvUEAQvjC8f4UAf/1P4e2ZkjQW+HVo9kh6B/eoLmVR5KbfnC4PtX oHnlGG1lurkRxoAA3Lk7Qf8A9ddFY3klhDcwRW8Jubj92TI2Wi2nsfcfzot0AL/VIbpltkV18mNW mLDOGx0z+dVJBKyILSSdiRvaKMnj6gVzm0ba2KsNuocXckkyTTMYzuBYZB610UVmUhEwdt+cgqMA jPpTcWtyZRW5/9X+Hy/0lpLhzFI+1gC288Z7nNXLGBfOjgSVIWbERlb/AFadsn2FdFjzyxc2zyyE Ep5sJMbSJj95jjr/AJ61tWlvIuk3xt77+zzGFaS3ePzDdnOOnQDrUSjpoBzWp3bXMUarKd8XyEIM cdKktLK4fYZ1YgjjIwOnGfyrNLWwmk1ZleK4ayuJIXZm+bDqvKZ7ZFTXDXETbxIXjdssgHvQ9HYE ktj/1v4f55ftREbqCGPzFjjpWairbNhRmNmI2dd1NNrY8+xqq/76ASv5cKHeMcYPau0tLYvEZELZ dSRsG5iAM5x9K1i7oLdCilnNeRre3AyLa48tUcFJhHyMkeh/rWDeIsN2ttbs84nY5kSM7ICeitn8 s1RHJbYp3FrNYyhYLkrI0e+TAxtPTGaqRxEyEs7ybxhlD7dx9aC1of/X/iPYOmmRJdSbp5pNgWNf NnhUEBS3t/8AXqpM9vF5dvCuN7/MzHCyfUe9dBy3925qQ5uHtpbaDy4ILghpY8rbgIMNGPXrVuXU bK6nTbD55E4LeWwRIgO/6UCjK+jLs5u76WWaOQRxW8e1UVQu9BgdAPve9YKW5tZJLi5mJtRkxxKv IbsCfc0FlrTIUkjuRchlnZ/MgAHyBD2J9faqTWC/aHmglOwDa8QI2E561nNvYD//0P4jo4JTfG3M qrbFd02z5X4Hb3qdrLR3s5bSCS6utUIMlttjAEeDz8w68YoOc6nSfFl9Y+GIdOuGu5ZJ2kS1067t W8qNePnL/wAJyDge1cjqc8L/AL+4jA3KcsF+aMjt/hWEtG2B5ZdwtG5aNt+9iwXqxqtGohZJt0iT D5lCnBU1xzdlYTaW5qac4DBpg0zl8ktyQK9U0VoxHJKdwgjhOx4yDIsmOhX0981lsCaex//R/izs 70PGyzPhUXcPl/e/jj6UsV5Fcq0NtIpbGJI1bLEZ4JHUV8+3uznO7sPs50+fzRFIVt/KaN2AKk8A kZ5HB9ayLiaCHEAkSKby8QRnA4HXaKy52BBpE9mHn0+4j4jH2hGA2tlht69+gpsmivqMl3dveyPB p1oZbSyVMh2zl2x1zj+VCk76msH0NCzuALC2aDKC5j3CUrsYevX61l3kkpD2lu8jzSqQVhG6V1zz x71cnYs//9L+NzTILqaznaMeZL5ZRWuCd8QTgAL+FPhivRYjyM3F7EuXRF2q+BkkfrXzc2rWAqpd 6hPbv5ky/M+ViRAHi2+rVWvtVYWsVnHb6hfXMwzMLeF1IJP/AD0U/mSRWYm0lqek6JBqYgsopx5b zBSxRxKYQRkfP3OODnvX0d8PdHn8WeLPCOiSzzWU194itLS2mb54bxzIMK/cDgZNedmMuWk5dkK+ rif6NH7HHhO70H4faJE1na6csXhywtJLW1lE2zZCiliexJBJ+lfc4HlbE2nZs4cDIzX4Th48lPk7 M6cKnGnZu5//0/7A42Vo2BBJA47AVURwSRJ8/wA2NvpX8rnoCqWVmZmJToo/u0TMdoTJwTnPagAW VoVUYBb+Hjj/ADxTomL5aYfMf0osAkrNs2ggc4VTxmqm1UfLgbiMZ6E1UF7yQH//1P2utL+aKVml RpImJyuOSSRz0zx/WtSabftIby4ZWWPIGww5IXj86/j+btcF8KHkQQ7rNrlmySEdRkt1x0qu7vby hYlLq2IWQNsyCQCc+3J/Osr2ncCG+uQlylpcRqY1Y/dILIQRgisTxDObTTpJBYxu5yyzTSHBA6gp 0Ix1/Cs27TTZjVVz+VH/AIKh2v2jxpP4lvNOtikaagwvnYwyhXkUx7V/iD4ZM+oHrX4d2MjPLcXm nRWdvZalAbW/SRhGEXaef+Aj8eBX7fwdplEV2b/M8/BVPaOr3Umj/9X+Om/sfD8MM88NxcTOiyML i2m2QKckdMdiOgrGtB5lvG1s5IWDerzNt87A6kn1r484ZL3mVrqK7MlrG0llJHfRPHfWkUnnPb46 NvHAJIxgHOD2q3eSly08V3G00cSW0tvFmQRhVwrN2HAq72+4k47VrL+1PsE+myQeYuTJJJIY/P6h gOwx/Suh0uOG2tHgWU+eq/MZBhWI7Ifarg21qTJXVgtr6CW6R7mJ5Jo2/dxMOWIOP0610d0sMbWl 1Jd+QnmBow/CbsdD6468elUZWa3P/9b+L+ZbR4jeLL516Z2V3Cbdw3cH25yajvHuIrwam8lzObqM 26yuSfPYbWYd+nH4EV8ueXFPkZu6NqP9qQXc91dQWEunw72sbqba12oOD5XGCw4+X3PWqFtbX1ze xtbGR7dwfsy3IC+UvJz+dBmS3CLBqs76td3KIdPG+2h+ZLtVIAXHWqrCz1C/s0ntmktSu1ZHg3pa xqAfmB5H09a1htYSbHtfGAzxaVMqfvjAs8qjBXoHHp9e3NcXrt1cDe+o7ry+z5Zv3bdLOADgE9CP 8K6YM6E7q5//1/4PryUTuxK554A6CnaerR71UcPywPf/ADiuC7OBaM3bLUXimeK2n8hnQxSODjcD 1B/wrsNJurq3AZLiKSJOBg5kc/xBl9D/AFrSEr6M3PRLHWDcIwa3YRqgxJ/Ah7j+VSoomurZZ4oH jkO+CWRhsBHUEdvxqzaCshmt38UXnRWaQzXKKFYK4ERyfbPufwrBv3mbUdDDzCC2uD5M1xHh44yD wWPY9frWc30KP//Q/jJuZXDFobtppkGwZYvCCD1A9/Uda079vOs7N4bdmaQlLiQuCWcAc49BwK86 6TsBizvcWioysBMr+Yj5OIj6YqXR7fWbGyC6kl+15qEj3EUnlH7O6sSVCeox0x0piUknoZrtdR3c n7sPGVO8niSM56/zp8ckN1G0cjOLXBLKv3cgYoLcmyDVr+FobRbcNG1qvl2rA/MvcjP+e9KmsSQW ZS/aad7mNgCPn8vdwD/9aqjLlZDdkf/R/if0393fM7weYgtzHGC2NxbgMfpU2oTXOn77iMLcoE3G 1PG7n1HP/wCquZO6uZykmrFmwJl1G3mjiaPfCrm3dtivwCw5PfBxWBqRs5LyVtLsvsEKXLNCjMJG JJOWz78/nWtN9DM6DT55LewnWeFJXkUoVZ8rgngkd+nSsGazT5/lVAV+WNDjJ9MVoZzeliCzuP7P cQIu3Lcqg+79RWgESaTMSNvHzY24/Oqi7MzP/9L+JEywmSeK5t43kRsHf84jIPJ+tTQ/6Y5HlmGN cLuXCIQAOa6U7ao8/YjvRHp4kS2jDSOu0yxsWfHqK5lk8llumOPLG4O5ww7c05SuLlSL9jqjrM8c pDxuN0jHrx0pJ53uGFyheHy5MlI2+RhyBkd6uDb3HZLYk/cG5NyrCQyIBJK/DMe+aZc2rrvlQ74U Xcx64PpVgf/T/hkkYrtulVfIz5eSRu3ADORWra3Jmt8zDEK5DHPP4V6B59tSiJZMZST9z1OBycdq rGRI2W4x5Ue4ru6sTjPQVrBaAA8m5BYFuv8Ay06iprSPyC5Ul9x4PQA+tWlbQB7WxMjHBZz8xX2q G6ijMaLCJInXCyJyFb1yKDKas7n/1P4XYfNDhYzuYHKbui1an+0P5RIUMD8/q/0/KvYPKjFNXK0s bQyxSMqZJzhuj49adJIJHklhjWIu/wAka5KxH2zzQS1Z2LP2WZrZPtHBcnEmPyNVTZXCtsMp2bcI 6nhqBrZkIuXjOJAyyRnbyME0vnSqyyn5oy25gT8xoJP/1f4ZrSZZ5/tL+WrRkl0Zvkfg4FNvJZHV X2naGID4wDXsHjleNPMBOYyyqSM/LmrGn3LWTyT7UdzGUjDjIXPf9KuD1sBTuJrq8l3eYQnJkUkL Hgc0kPzD9yBuB4Xux+lagNnTeCzDExHA9ceoqrDbSSJIUDbs/MoGNoHWmtGB/9b+E4xzBtnmlkA5 5IA9aktCwLruJjUkc/zr6g8uMOrNS5vSbZY0ThB1HUkVXtX82JnkALJ82SPuik3ZGhQllN3cgEEx L8uV5C465qeS1hHy795DbU2jg01qrisnoVpLeVJIyYWUZwWzkNVuGZoQcICc8MRyv0p3drESiktD /9f+E+4YTXHmR/KzHD8dT61cmmC2xiSPY5x8y8Zr6g8cpJNceS4BdUIw/wDt1FGFc7guXHB9QKAL Ul3KoISQrgBWXd1A7YqnK7T4aQAbRkLnig0grMRgxVm2bcrtBIyQBVWGSVZlO7aob5ucHjuKDTyP /9D+Fd9QK4RHy+MgsOax5bpxIxkx5rHKsRgZr6g88dG8xkSRmxKBxtq4Zt52sF8zPztjrjtQTP4R kty8chVD83QkdqhkuJJGVSC3tmgyXYkjiTBLnBHQen1qRZgZPJ4Bc/Jnq30oNIJcp//R/hSKTW4L coAc8nO6qUsquSwzlhzntX1B45CwLpgEEL2zVn7L8iMvy5X5gR8pp6ouFrkkYPnxgbdikbj0Bx1r bme1W1doR+86EhjnP0q5Rd2x1OhjyCWSFUGCg5JJwT+NVfPMDCEr8j+gztNWlZWMz//S/g8luVVj GFyp4JI5pyMQuVUHsR0xX1B45dRHXayjGRliKdcS7uEbsMgDmgAhZoiJXGUH8NOu7+WZQFHyjgDn gVcHrZiaTZCgZMDOBkEHFXXfzVw5CbVwCvGcVqM//9P+EqLcGJKj0B9amhfbLHuTKg8DGDjrg19g eOX5HiLBsLk8hd24e1VJGfztzkKAPoBQBHdWpUbwY2XqNpzmp4iFjEkT/MmBJGR19xQBJ9pV22sd qnrmoZrXy2WQY2jpnpQB/9T+FFraR2eTzRsYZBU96iaApH5oIK9MdMV9rBW1PHBpQY+NuQNpNSW6 uj73y5YbVGcYqwLjrGxwGwxG1sHIpf8AjwjRDgvIxfcp7Dpmi1gM6W5d3JAABPOOtTJFLJ8xZmVe WPXAoA//1f4Wflt3LgHyyvbuaY++4UOVCrjGQa+4PHGJdpAhiZSSOAx4Iqzb3EcqsvQ+4/lQTNe6 VblY1BIYscYA7e9PhuIfJdBGgWNQV4wc9801JrYUFZXHg+aiszZ/uqB+VTG1BiLM6gAdu1CbWxZ/ /9b+FGE7CcclD9QfpUnzMNjKAxfdnHWvuuaR45qQSQwoCwXeBjJ6VBcXaSwMjIC4fsfl/CtFJN2A yDiRtv8AD3Gfu1pxgYjiXJQ//qqgJ5ENvEDJtYseMj+lVGmJaOVozLEDj0oJk7I//9f+HCOeFo90 yZjUZjVV5z7fpVCbZOVYBhCp3CPoa/QDxIyvuUROglVFTgH5ge1E5IYsq/Lnp0J/Ck9EWWIZonjQ eWYn3ZcMPmz0rYM0tuokiGwhcLk/f9eKUXdAUIJ3uJGEysSufnLEn8qZ5aBgI8Eq/K9SKoD/0P4Z 7K2lvrkRgfNk4yQFatG70SS3jilfy5BKxDIjhim3HP6/pX6CrJ6njmbOix7ULHGMAYwFqpaoXlKI 5KockgcGn9p/Mxl8TJ5A/mNGEOzHLngnjtVcB1+Xom4jLdTUkixy7Syfwg/LxgCpElfzQZjtjHTH c0HQj//R/huvLtZEW2RggXADr/Hx3NUmjCI2SWYHknjP0r9APHEih584E4b5c9ce2K10SSImN1/e NHujOBnn/PetoKyAy7nylljAQiXb+8BPUjuP0pGxLv8AMJJ27Y16Kp9atJvYCrBFJGsjHIw/lnjJ xx0/Sr9vG24gykow2oO4NbJWVgP/0v4Zobma3nO4bsZVST3HFRfbJVLFy2Q3rz+Ffp72Z4dToUTN I5LDOS33Ku26SOu7HTpgdPrWBmX7g2QtI3DF5SMTq6hVU542nPNZkF0hEkLhWjYAAc5Uiom7aIB6 oM7Tyo6AHgUm5d/lLwf75PSs7t7gf//T/hhspSpKDa2WwST+tRXKhZmSQYOchh0IzX6AfPlpkEkJ WPAIAwaqyRhFwQVkYYK54xQNK7sjeh1qddLi05pWWKMkiJflznuaw7qZHJfBEoXaXA4IHTNXFtaD cGlcz4n+bLZOO56VKiux4zk+3BquV89+hKV9D//U/haVsRnIO/cFB6gVOsqR7VIPynLHp/npX6Re 54qjZWZWnb7ROduQoXIPbPpWnA2LfbhM5wc/erFrRMaSWiIAGeYJFnaDyp4xUk6mMlQxRwM57VIy I3iShVdcOgwCPusfWqjGQOGwzAn5ggzmgD//1f4bVDId+3lFz05qtfXP2lUDja6fKsncD0r9APE5 0OjdCqtt/exjB7bqqT3cpLxthISeUHVj70EylfYeLgRKiqTlhjaOwqvJGzHIUlPUVjL4iCGMFGxv +6fu54NbCHZBM0aRkjDOxYb17cDNPkYH/9b+GlJwXR2UEBfmp0sscr7k+V8cr2r7+MeU+fMwQ3G9 pBgc56YqeQTMR2PGSBwfrTA29L+zPHObpxE8Sbo4iCFl9lPr/hUOr+UbWNiwiO77gHJ9Of6UAUdN Z2UpGFQD8C9dLbW1vLBmW62yrLgp/FgDqBQB/9f+HK6eaPzM4+Q9QewrPlnk2oSXw/GOelfoB8+P tcrIXUKdvzDPb3FbF3fT3UhuS43soV26A4AH9KTdlc3irRRTjkMkwyAoXv2JptwrtIJDyD90qeOO KxbbY/ItxCONC0mDkdCMMPpViaeJykiklQNuwj26ijmYH//Q/hydliZFQbiz7iw4200Qu+cuWOcj IwetfcHi8yTsMmQoUULzjt/OrUpCIq/P5gAOOzfSgohVpEKyA7JAdwx1Q1YiWaWR5Dgk5OB92gie wuZisjOSPKHzIBksB7Ui3KCLYjyKH+YxkbQPTigzSV7M/9H+HcwvLHvKEbejFsb/AGqHy2CNMylc jb5a8jIr7dpPc8bTVFe2mYOMHhTkjODnsMVvSSwyIstywjYD90CMs5HQCs1DWzMBJBbCJZnYmZ+R h8kY9eeOlZBlm87Y0W5DkkMcE8cVokkrARSh/L+XCkHp3Han27ssTRFsOfm3Yyv0rFqzsOOjP//S /h7hSKVQEIGwfP33GopJRGzfeDpwuztz1r7A8RPVtjbeQG4EpB3KBlm4Z/etBr+PDR7I/Of5VfHK j2oKTT2KcVwrB42D+YDt3AckVZgiizNKoCqMKoY/MCepFBS0dyWS1ihRnEu6Mn5Q4wc4qHTZ44bl 5Cquy5B8wZUA8cfnQOTuz//T/ise4gjsW2uh81fm5xnP+FZS28QQMZ48k58vOS57Z9q+wPHMyaB4 yCy7mDcFeRRb3FrAZZJ4nMwQmLyW2NuI4b8P60AWCZryAOysmFy2eWU020VFbLxqRswGIwWI460C a0ZBcB5CkcIjRlOFydqmo7WSa3TZINkhY45BDGgwP//U/iNubZ5rdGKxib/lrIBgt7VzyrDaOZBI xnDEMvUADtX2B8+a9tfPKmRtK5wRjDN15oDwGR8xiOXOMqPvCgChcGWSbC71hP3R6/WrUNux2oCe AWnJPbvxQAy6jkgwiyRywOdyOg64+vIqW2lRyTHtj+URzbupPcmk1dWA/9X+HsRpHLgnIHIZDntx VSaC6lhDecoDOUdA2HA6ggelfUHgx6ojErMvkFtirgDHH51pafDJ53yx78IW56gdyP8APegk0mKR giPBdv4iM4qjIsltICzkxsCSDyy/Sue1tAKijMhlRz5gO5A3QYqaGaJbgbwwmZtznHyMe9bQ+EfM z//W/ievb9GtY4Y44I9oK+YFw0mexrmViQXIYiNnEe/y92ea+oPB5pE8RiVmVzmQAOdo4YVrWgst 8lxcHf8AJmMA8Z46ig2Mi+murgGMcRM/G08D0FVMIAYip3DH7zPIPsKAHXch2Lx8oTZuz8ze5rJh aS3O7dmENuMe7BPagD//1/4aX1NZpVCxIpjGzg8NU/2lcKMbVTrjtX1B4spcoksqPGyrht3GSOvp VC3WRXbzSAUOEVec0rWdzOLaehpw3EcRzJwVOcY5NVrhjcyhjhVLZ2qMAUyoJ7lmERLHIFIaTg56 ke1OW4mhZpfMT5oyMOAQPpmuc0P/0P4cVmj/ANYwVmYbckZ79fao7qLLIYgu0jJI719AeOUmETKY wv7zOM4o8iNPk5MwGDzxzQA+KJHWRW+RkGRkfexVu2d0ACFWYHAJ5K0ANvFZQW81tznJQnO7FW4r p4EimiyhC7Q5HGRwQPpQB//R/hsku90m3fu5yVDZBNQJJMHYLI0WXyBGcZr2mvesjxyxdB2ZGQMc L+8Zj8rHuRVeYjloi5AIBDDoeM/1ra2lgId8s0iqoBwMZPG2pR5kRaOUFnPIbnbUcq5WBMkL/ZS8 pwfMwF6kjsa1rWCa5jhUERxKmQzfLnHSs1owP//S/hxkV7udTLtjjibYW6DI9ajlkSCZ4i4kToB1 Q47ivZe545CLuRAUjONw6YpI4rgfO/zFhkk4bIPoKRvdXsWZbV4YnlfzFBUE/IR+dXbdILm2REwZ 0O7LDa30/nQNu25nG33zvGdyFAWbI6gU1k8rb5ZZ2zwAMGg5z//T/iAiu/s0D+aqibHyjGGP1psT 3E6LcQyGOPBHkkbY2Pcn1r1WvfPHK80+T5ZV/lPzMq4J+lMe3hnUGMmMpnO7q9RJWeoA6LDb78iN Q3PrnpThEJlRpWO9iFUEYyOAKXKwNJYY7VJFbylkC4TzPvE+1RpYXeotbi2h8t3bY8qttWY56GkX T3P/1P4kGsMRHzWBmXgqpztx2rQGjXT6dDqkfneVIWUOoPlSgdVHrXoHnPZmd9ot5I4/KO07sSkq VIIODmtOHX0hW901oIT5Mayrd8sZc5GM/wCFBgY1xfIiZRA7Y3SYHT0rBNxLIuI0kO6T52/h/OgC e4ktZUiE4Z5ImyF6ge9TWZikNxPCzmSFcR7BxEfWgD//1f4fY0afy/ObagfdvICgEeprRRLWIF1k UzZ+9wdw9BXoHkJN6IjjjjjlRwioASzn/lpJn1NS6qIp4YkgRfNzuDZCjp0pJWViuRnMRHAKjKtn BNWfsQQKWaQxyfxffKsT0PtTJaa3Ldr5VsWjyGJ6swyD7VWngmuWLALHuOIweFH0pNPoxWvsf//W /h/s45IYYoZPKeWQ7WboqHPGaS7t/NlLyFtsfygg4U9Ogruimnqeao2sPOoskawxlUP3VJGaxphJ HLhmJJO8MOpqijpdJtftIVEWK4mnbZCJuMOMce31q9dJPbXGb+O1IcBDGr5ijZeOvvQBmxwwLcsV iXDtuZx90YzVS68u5uC53fZ4xwi8cjrgfhQB/9f+HSZmO17dGWGIeWiEDJPqRWXNNMHGUJIP7wfx D6V6B550mlFYkE8sO9Y/mDD77+wFQzMNRuopoE+yyK/3V+6+O5z/AJ4pPRXA1ptCS3SO6adXlmGZ Av3cDgZ9/wD61ZF67WwTyiYxu27o+Hzn1FYq19Rp22LkKqYmjZzvx8ztx+lQi+vBKsVudxiXBjC7 o5FHc1UndNA23uf/0P4kJYpL6PeWMIWPBjTpkf5NUksLiF8ly4mTbkn5hjtXQeeatrFIhiW5iBDZ IeJ/mOPqKjvL6OaCS2RHt5DNtE28EMo6gjvQBnafZPJcScgLEC3mA5z2rbNwsENuGdpN83lNx8x9 /p/hWMlqwMiQ2bXMkSrtkkbLsOcVpRWWGdQrI6qGTd0cEZB//VUgf//R/h/vIt7sluim4UbFAbar Gp7XR7qBba7u4leOdyFCyZf5PvAjqPxoOWCVro7Jvh5r91p8t0LQaYDAbqGXVM26sgG4FM9SR0x6 1g2uoSGYtEr2zQ2P2SYK+5HYDazgdtwz+dawelhTSStYvLcJDG7PMX3w4UDkFu2f1qtaJbXCyulx FHOMsFlcKWx2WrMjCu9OuGNzO86FXI2RgnMg6Y/CsyASRuYnbayDco6EAUAf/9L+INdRVoJIPIQy TYR5snzEAP8AD6ZqveWyxFFkYySBRtYHK46810HBd2sRxXs+4WsbMQv3ERiEB78e9dO/h2xsobfW Yr6dHuYV+02wUeXG6/fX6Y5oEZ/9rXEX2k2kjIpHlqccsDjOR+FPcvDbKb5/NWfDhCQ3PX8MUm7K 5vHZDPtQME8aJIcH5WkO0t64rJkW/lceVBNF5J3AjODnpz0NYt3dxn//0/4nbPSrm9WOVVDSH/WC R9hXA5x7+1bFtaWNucWpRrl1DLIuVaJhnI//AFVLkkc5R1u41KH7FbGaKWMMXdt4c2688eoz6VyV +/mLLt3Sxqv7wMuBu6gD9Oa55vTUDgvOZJd7xgvzgMMhKikbfKjZCg8HHOyuSe4pK6sbmkhC4Vjl Q+WlIwWHoBXqlnaxQ2ly6eTAjKJz82JZugCrnqeenoDWbXQUY8p//9T+K2LShCsd3uZW1D92DI+C QMdPTrW3oGkaDp+j6jqWoXVtHetMwRFmUXUQHRsE/N6AdOTXz7VtGc5p+Gvs18zTuPKLnyVllXhk BJBJ9D1q3q50i51CA6W8V7NZqTcSyIPKA2nlPpjn6Vnyagec3vnw3SlL6GRlb5pFGFiUnO09uBXp ds8loHexkCTPbiETECRJEIw/HcMM/TNRbv0LhdPQw727u2kS1PkI0bELhfkIz2IrV0ZltxPcSiMX cJwkyj94V9m6jB7UN3NVqf/V/jau7y4ju1ngKiN8rKqnaTnr+dTrqF1A6hIntnYcsrfOQRwcj16/ jXy7dtxOSWjM4QTJIdu/c7MSR0Ga6OwlutPtLmK1cwzXUQikZl5HOSB9aylLsQ5LQ3/Dc+tT6pZ6 VplimoebJumluZhBHZqOpz35r7m/ZY0HVbr4veEBcS2t+ya5bLBp8wQfZZhJuXY3YueAeuFP4+Vn E19WfozOUmlNx3SZ/otfs2w6jpvgbTE1BYotQvLC3N9ZxkTfZZRGisA4/h+UED/br6jXKxBSwcnn B5xX4fTndycdrs78Hd4eLe5//9b+v+FtoIcjBHTv9KqxovnOwHBPev5UjJW1PQLFwAu3y+ezDtTZ PKaILhhJ69QfrTU03YCNlkVAF2uQOPXvUkcRDlmwC53PzwDgDj8v0q72VhpXdhlztMnBB28ZqDym mYHGQPTtilTleSBprc//1/2782309ljZGnZespTk564FMur4bGhSKOWCbBbdw8RHII96/jpp6sPI ri2YKLi2YedwQxGcY5A+laNrP9pD+aoS4C75kPIVu+D6damzvYCt9mt3Y3BIDDKpI55Xnn+Vc7eS CeYSxyB1hOGBjEgO09QO+aiSbaYW6H87P/BVvwbp1no+jTZnuksWuGhcqoTy7m6SQecvPKGIEc8b 8Dqa/mw1PT7e01nW7CHzYkv7hI3gnO2BWVFy0R4ADdznrX7nwmksqpLujyMJSVKtUS+07/kv0P/Q /jd1ZGiYaVFpTWcFmDvvlO2K5LYIRV74ycsP1rPiV33xSrF9kKYKc+YB0xivkGrOxxtpSbFt7vTr s32nIpsp0TdFPKRHKmwEkrnqD0/Kk1Rn0zS457Vbe/lvH2/ao5gqW45G2RByev8AkZosZnP77i3t I7S4s7a13SLPEiN5oQvgq+MZXO7OK7P+yra2063uL+4tvLjxJOzYSVM5xtz0OSBnmtKe1gMu4lhh lC28aRpnaJpF2ufcmlvo7vULi1tk2y6fFGDDGozcNMeHJ9sYxViauj//0f4s5YmDJbiLyZkmMU25 ueCRk+namqms6xfLZ2ktnHZ6eGYpd3S2kcD5UMwZiASQAcdeK+Wur2POSsrG7cxpdxRKWtkFpH5Y ltolVpm/id2HLZx1NNNw9lqMdxYXrSqUix5wBjJAG9dvTGcj6UzENWiS8lluvJjmvZc+WxbaLX3Q 54HXg8c1U0mK8hj1C3iuhc3clsVgtpSBI4b7wVsdsVUPiEXDBZzNY29jZ2ontkD6gq3DySXZHDAR 56564965jxAqrbXemak0lvbx5vY3tYxM82wjEQcH5QRwfTmumnvY0i9kf//S/hQlW3do2t4dkDH9 75r/ADrz0Gav6hZ2iRRSWpEQRQMbsk59fevOjsjzr62MOOPywQoG92wG7iut0Z4hf2EM0bAEHe0J yWYA7cj3OK2gupoptHq0MZht5GkUiJcyeXHy79uB6+1b8kXh+2tITqN5dw3F1II7aKzs/tO0kEkO dwwMDr0qzVTstGc9e6Zptrb/AGu2YwNcXW2SEqd7gjPmZJ79Me9SWkyLZvpwsbO98+UTeZc5EiBR 0Q5wPyrOUXuNT7H/0/42INLnW8FmkMP74pFbLG3mAM38OfyHXtUbSm1lTJUw/cCk45J5rzeX3uY5 nJN6sjvI1C3Eg2XNug3SgAs8eQCBjHTr19B1rJt9QkhuA0JlzHjbH5hwnHQelNJIlSu7F6WRtnnv j962zB5Kn0+lZF1cC2K2UVvs+0KZInUbo3buD6E+9M1UmincG2tI4re4Gy+KGWaEIfIj+jfn1ApL YrwSFnjcZVFkBb8euKaV3YJSuz//1P4rAUgUTTslv5kgSMZ9TjB/SrV1BCLzDyxSxrEB8kokil4z /WuZKysjnEvr2xNnlkLTowjCoMmNQMZX39qzbG+0S2fN8jN5iGONJEJJcggE+mPX2rSnuGwxJoLp mWOT5cHa3IIH0NZgLO/2VSwmSXaLiQ8MP4SP89q1MpKySGx7IopLiZy00Mnz7YtzP2rThu0dX8vK uACykYIzmgg//9X+IRI7ZJ3EjOjPISQwLbifep2RWhktZncxOwZolJQPg8VvH4UebzRGlLiO9Zlj RDtUQkPvxkcjHb/69Q3lxYR3LG1UXE4by7qOdPkXA4/nTsUZ72csytPGIk527EIVhj/ZqOKEIqjz AZA2JE6AVpTQEssKrITv27TkqDlTkVCb9obaZCEwkvXdl3B/2f8A61aAf//W/hmgtJbmCSQWsvlb 9zybS8cIJxk46fjWmtiIVKl9sSD5w2cEeor1YJcp5c3Zodb21rcfIJUUwHIhLbRNnpVa/s1t7z7M Sm1owyEfNH8w6fUdOaXMkrItuyuUDbw2sqrMCYghaTB2EnsBV1ZFltIgEaOKMllKrhmPoxq4u6E3 7tyOO7iTMju6vnauFzkeuaZdTzgkxMjZXDHG47fSmZ2drn//1/4ZWaJ4xKFCOqY+TIOfpTYJHkCy MpIj9uleweVFNJ3L6CCYxPJGJDE3mN5mdjegNVpUR5wYPljz8y7cFaCC5b73xDcyMULYQ4ztHpUn 7grLAsmHjfG5hgGgqOlzEnJfMb/M6t8rDuKR4oUgO3cSwyS3rQSf/9D+FG2SM7wjNuXlt3ArXjSe 6KLvy0CZVcBQAOeBXtRfKeORu0PkBWCocnJQfNVK3uk4Qpvw2DzggUQ+JAOIknkdAqpEgJB6ZPp+ lZDNIshTJjIPDA4A981sBdWXk8PPKBgsv3B9K0tPLMZNqtnaWduiqO/+fagD/9H+Fqd4gVMZBJ+8 vpzVUDYGkjfd5hwVP3ga+ijJrQ8yMlazH215CJDlXJ6AHnnPUVprbt5ZVN728pLso7expuV1YfPE pzGKJCERY1bhVXrx61nxSeW45J5z9OaIytoxc6Ox0m2fUpXhjA2yKBmTCheeuT06Vo6n4dFkzxR3 NnclYVm8yKUFXz1Ue49618hSaasj/9L+FuQRI/nIny/d55BI9KpTbhIsoJweqnp9K+oPHLaSmaI5 QKI/bHH9azw6I5I4PTgdaAEmt4pZiVDAlBvXsx9adHDG3B3AqMYzQUpNFtGUxCLYPN7ZHTFUJo0C yE4SVRkAdyPSgTbbuf/T/g6hcSDe52sDjkY6VoC2W4wJCiqozvPBFfUHkKTQCEpGSuNwOM47UyOD LKEbdK54X+LP0oHKV9BfLjUSec6xuvJDHBbnHFNkCnyigK4Gd44Y0EjzEyD5uQRnOeKYsaO+JMHj 5CD8y0FqdlY//9T+Ex7ph/o65YDgF+ciqxOxnZkBXbzX1B45BEFZso3yt+Yrc+0wiJYXGWVNqkDo fWtItWsGxS82KMYIBPrnr7VE8pcKy4VC+G56n6VoO7e5bSVc7OpPCD+E0/7KFK7iCW4XvzQI/9X+ EZoEMmDEGZDgkDINMEQjLKT988A9q+oPHLKeap5X5VXHTg0xHRZG+TJA6EdKuMb6gD3RZ1Hl5AG3 bjAAp6RGQfIVHtnpV8vvcwE/2aVQPMI2qMg9jUKyBiwABPTpVWA//9b+EefJZWyQy/LsA4qe3UlS rEs394jGPavsDxxwiJbbgjZzntTbglU3sN0bHb1oAjjZnjBIwin8xV2GWIoqqgXc20tjr6CgCGVY 0kBJDbTnB6GtVEhuIt7mRwVwIhwM4oA//9f+FbbHGGVAcKMGPOBTXhIgDbsrjdtzxX2cHZ2Z45UV QhAUKxPzAPyBVgoF++4R9u7KnKMD6Vo5JAIoKlQhyGPLGrFwF8lNzZccD3oTTArx24kTPAyavQag bMSRoiTxTRmJkYYKc9QaYNpbn//Q/hikkR03rEViPy+oX8az3+bAiyOc4xX3B45UYs8wSRSCvU44 q3EmHO2Jig6sBxQFugTRxxtmRuCOB/SqbR+W4ZWBDDDL2xQCVtEXIyRFkj5c7VIxkVIjuuApzk7Q rcg/WgD/0f4YIbcRB2kA3HkAdFpsZiWVWfLoSRzwc+lfcHjkU8QJZVUqhbPLZOKhaKKSMRwscI2J HPY+lawjbVgVkX995QGcDl/72K0XfyFTB5I+U9h+NWBILiSeNjcBSFO1T0xTo3CKgKqVJwV9f85o MpSvof/S/himBMf7twgztUHtVVDJGSrPuU+3Sv0A8C9lYsRW6y75QPnWoJImBLSE7s/L7fWhrSxp B30NPTra2ubmJbi4WAd5WHAI6ZrT1b7CXCwZWSFcSbZN6SY7iojFxeo5Oxm+dFGgljCbnAUg+1VH 2xuWUHe3O5ORirIlK+x//9P+G2zuZINs0SgmJ8luhGexqaa9lnZpeIsjDYGA2a/QDxyo5kkICglC Pvbfu/WpI4PKCtGu0DhsdGoMpqzLAAZJCQu4rhecH61SuLeZ4kWUxoASFK/6w/Wgghn8xLSLzII0 Ctt8xWBlfHcjOfxqk7I4QqTwOB1yaCoOzP/U/hch3nZFuUK6k7mGSuKmK7ly0m7Z8oA4r9EjFXZ4 5p6XIsR2yxAxg71fb827tRc30T3LAj5yMbx/COwrQDPuF5DYAdejHr70quvl4AQk9zW8UktBXWxD NlFVRIoXO8qThiaZ5zhVKFc5yPb8KYz/1f4VYpTJKxcl3Bwq/wCNXpYHKqXA9cDqK/UDwpr3ivGw EmG2x4PDEZ/z/wDXq8jO3zkqIy207TgsfesHuNx0KV5ASOCCmcjB4qBIostlfL2rzz1rCXxENNbl 2JfLVWzvR+AOhqrtzIylQjEfJznmpBRb2P/W/hhgtti9CXHLntTnCOSdwZ0PKntX6AeByvsMbYzb A7KCMkDjFSNFBkH5g5X5AT8vFBUFrcpMXlfYSAcYDDqcU8ho4lTaGJOG7mtYLQ0aurFcxHcqAHPc KOK07ZVjII6qf9WfvH6+lWSoWP/X/hleUw+YzLEjjJVSchqqZWRUyQWbqRxX6LHdnjj7Xy4LhWlT dGp+6R8rfUVPOijLxnMb8pt6j2oatCwm7IiEc/kSXiMNsR2Pz8498VGYpJ41czM3HI9u1ZDKUTLv wQzID06GuhtIYpAZdwjjA2jPUH0Ip2eyM5y+yf/Q/hulmSCciRXaNeCU+8eOoqFoVlj83ByGwFIw MetfoTi0rnz5HGiIkhGWkzk55J9hVUyxja7xhmD/AHW6MPepAlugjSCZcJ8o5A4apbadYwXmjynX BHDe1Q4vmuZyl0RHthkLXKosaM5AxyF9qWBU819oyOre9WZn/9H+GmcKxZgMIxxsTp6Uy7to7NhF HL5p2KW+XG0kAkfhmv0A+XGwlRjzi4wfujoRVhmi3jghehJPJoLg7XJQvmqgiXAQ5LN3p11Iiny3 AYHjJ6E0FKd9CvaWjtcoiNgMfl52r+J6Yq09tdtNIrIIkgfaZAwKEdsH+g9KTdlcs//S/hslhnB8 t3Ux9Mg5LfhUZSBAFDHcB0YcH6V9459j580Le1RF82SRFj2cAfyqN1xbP5kW358xkchqbd4lcztY ypZJI5V2OJFkX5gP+WfbBq5HHcujoq5QfMWz8yUoxTV2JOzuF2sqNCGKnKclemf84qxZxMwbc4H9 0HqapQSZpJ+6f//T/hwlIGFVCHU8tjA9Kk8zYm7ljnBHTFfeuCex8+MwVLGSQDdyh6ke1XoZYvMV 5lMmxNq4/hHap5HYrmdrFdnhdpcgxq/Kkc4q3boYo3MD+a2zb0wFzz/SoGl7pCZJIIp24aaRNm4A EKPT9KpxEPtlJy4BB4/Cmot7EH//1P4dIjLKm2Ry0KNvwBitJYDhVjyYpVyGbqMDmvuWmnZngqTV zKuIVR2RMB85yP4jV3fDJCnm8SoMvuI2A+3/ANekSUggleZQQhUbojziSoXLkq7E5DAOyjOAKaTe wErxwksfNKxj/loRg/TFI0QRSpBfccZWolG6A//V/h3tFECsFCnA+Zc/NiiQZUMQqgtgEdWr7Jwa PBUrN3HjE8Gw4DxnAI4ZhjimeUVCGNAXAxkipsaKSvoVmPlSgrxI42tWzaWzMuDIoJTeWc4B56D/ AD2oKK155bMib1fY3OBlQRUZiCxsSMANubb1NUot7Af/1v4fGfeIowQEB3jJwa0SIFVTwWj+ZQeu a+y5ZdjxyKe4kZSskYVQflZP4vrVdoAqLMQ29XBVvSn7NgOa5nJkOXFu5EcjL1FXBDNuRWGyFFwk mMs49T7mn7MT2ZVnDQspEbGOT5RIVP3s9qjvlSOOMx5ldfm3dCKzMD//1/4fkv7lx5aBf3mA24fd x6c06OG0lk3PEPMf5ZBnG6vsD58t/YTHHIyokUafOOcMBnHHr1qosJeRpFAKsQi8gc8daAN77AfI gdVjlDSeW58wKUJHUDrWOZ4oZpE7qCpbP3u2KTdlcBAqywtuVhCvKEDjP1qiIWLsYxhD8rtihO6u iVL3uU//0P4dpo4tgETF5lUlgDgfSqMU0s2NwxtXPlscEYr6uSsz55NPYsJsn+URqrjlucdPStKF zu3I5EagJJHkbiPaoGXJJkEqNbBWCkb2PRaq3joXQuSUckFgMYNZOL5tAM2SMsrdYymTG6g/PTAB hQT84GTu4aqjFoD/0f4d1KyDyw+9mwuWPC1ViRln8oRhpd21STwx7A+1fUHz5r/Z7gSzWvlxNIIt pMbhlGRng+1ULiOWy8tJMEuMjB6UAOivI0KqUG0nD55P1FOuzbt5TW6vGsYzLubeGPqPT6U1FvYC o0iSBAAHBPPOAKFsBIXllbAPCIOAPTNX7Md2tEf/0v4XptOaMrlkAb5htbJrTi0+QkF2RUIAYu2F P+FfUWtoeFLozSews7eFlJUlBy6PkZHpWHbReZPKVDKv95uh9KCY7olksZhIrsQ6KfmApscIO/OV djhCT8oFFtTdaDSiwE+XuIP3nx1NOwJUeQhiFUrsI79M1hbWwH//0/4Z7ceSjRuRtf5hjt7UOk8Z Ei/cPyDI45r6A8cSDTriRHVQdwfcW3AH86lEBtspMGFxuxhhQBp2uk3F0HW3t5LyY5bbACSqjq30 FW/sENpD5mU81jsEROXz7UB5GRPYXjuWWPdnoNwyPaqZmuwi252lF/5YSr8qnuR6Gpk7ID//1P4c LcQxNMq2EFxcTRrHHLJK6+Qc8sACAeOzZFBgtrSQRFt0ynLjO4c+9ez1ueOaDQOyKXARANyhTkv7 09rWIwrHhUMqbg64YjBxk/4VuBReyjsrhHibeoQOSR1PpVt3iuimR+/AJPyhFP0pNWi0AtvAilw7 EyIN8aEY3eoqGe4aSMODsCtgRZ6VhboB/9X+HXcI8J5kbrONzhPmKE8/MOxqqLA3cy+USXR+c/dP 1r2pJpnjmo+kSRMrSIEPl7gcHa46cfkfyq5asto7GW2T5lAB6n6j3qbFc3vcwzU9QvDD9khEf2eU fL8oEnPUMfSsG0ja2dXdZPMkby9wBKD8qLEm99l3b3UAbEyGPQn0qpE0Jm8vaPNZdoX+ZoDY/9b+ H5YEUyNdTxmWEYiST/lpnpk+3B5qezkiidorkskWzLsBwg9RXsHhOb6Fa6TKOlvKTGx3pNjAkA6c elV7Fd5bzHJYHb5e3AHv/n0pWQc7sWksGnDQLKHYfMUY4K574plzYT280UMjqmwAlt4Krj0phzsp 3EJu5EbcSkI+Y5wcdK37TUoUjW2iLRSRAeX2H4H1rKUbK5pGV9Uf/9f+I6K6Tz1DMcZ+cHktXS6p 4yvG0620mwiieC0Q7TJ+6EbMfmwuOf0r0LHkXOXtIYbyN533RsqkeVGMKX6j86tQRW6usE6MLpju jGPlTvhuOmBQIla3S4Yu6wlmlMcywqADg4xgdPpW1d+GdFsbO4ke/eO+Wx+12WnRYmSdmwdjHqCA elBUY8zOP0vSvtkgM4WJRgujHMgB9q73U7TwrpOjX8dhZSrqTSB7WeOQm3fAxtZTzzgngdaTv0Kl Gy0P/9D+HfTL5JInN7sVvMwE6qTnkf8A160pbSN5PMhbAU7tinge1egeZBaXLNvZ+dLMJEaNzEAr k/I1RXkUh2KLfcIYyAYySAR1JoLKGm6RJcOZZQVEX70qx2iQdMDvnJrc+yC0aC4QeaN5Pluu5M+h HegDHvrWSRxOm1dhy0UYChMnvU5aFrRUB3MuCPVT0oA//9H+HiGN47gpLKBuwVAGQxrcYRagIoG+ SO3PmSsGEcj46AHvz2+tegeeZdzpNyZ8hV8jbvjxnfx14/A1bhtrd9uZEAdSP3o+4QDwD70AAiki hF+m+Bbd8Iyna7EDOcelSf2hHcwr56ghh0fncaAKj3MYVhHtH8JCnG2slmlgidtrAL824+n0qZSS QH//0v4dpNQdbLfCA8kihfLAyzk4H+fpTbO2S5uP9NlEGAM7Ru/z9a7Oc882nSOOITQFURX2CINk EDjce/NU/t6QSf6kYYnL45Wocm9xN2VwN48zfu3ZoT13dFPsKcISZFLHMSjcCD1PpUKSbsMjkuNi uSFBDcYOasQhURjHvQN1YjA/A1QH/9P+IxJpIASdzQDjKrkZ+vvTZNSt3ntlmLW7oSQXG1mHfArb mV7HnluPVNPlmWGOf5gdqHlMZxwc1l33mH/SI4QsO/yi2dylh3/Gm2luBU/tBrZdkWQxPzNGc7ge 2K39Ouo7912KS8Y+YOuAuO/6VEpLWIGLq1je6ZcRaiHhuEk3F44jjYckDdVzT3uLlZC0piby9+5u VUe1Zjs1uf/U/hxIlWUlZsTbwYnPGWHSvTvtl3badaXEMFlJdvEjqizCSCGTvvJz7nBxmg4E2tjn NX8U6vq8kp1K6mkaSQBIzLiOMqMYUCsmDzAJAhELSIVJLbm9+fehaaIblKXxD2lD2CQXEKQTRMQB E+4sM8Z7VoWVnZRRqMebMU3lCe9aKfck0rC3ivWz5kaRozI8bDaEI9M/p9ayb3RbhbwxqkixS58u QL5srcnGB+FNzXQhT1sz/9X+Ia4systvBZwytMDtlJT947A9h+FVb+fykFs0eHGNzMPn44/pWntP I88j06yulvEuRtEIi5Rv4s/5/Wta91O8uXi09Lcw2vmEiQ5LScYYdO1PnQEUVgJLi1ikcWqPMEaU nAQZ+9T754VLLbyfaI1bCOV28DPOP89amUr6G8dkWtJsJNQMclxc28duJwrxM2JdvsvXt1rXvVmV 1FrbNLCshiijj+aVgOAdtc0pXYz/1v4p9ITV0vy9xF/osL4COSjOO+cd+1dDcWtvp88t3YWcSG93 TCPPmSROQB1/Cud2RznF/wBn3E0zpePKzPIZCVGCTkkg+wrJ1e5NtbXNqdsauoQ/J94KwI5/AVg3 d3A833LKHkLMVyVBIwOPSq0MZjYFCXDMTg84rCTuzKUr6I6rRYJGkXYodvMBCnpgda9Lt08xSssW RGArDO0/RfepCMraM//X/iYlNn9vijiS6Xy0yfNummiJJIwvofw71p2FpYajO9jPpizpeMYZpPMI aP8AusMHrk9DmvEmtLnOb8kDaVp9tp1vd3DW1uWj8mQjjoPr+Fa+gXVnEJLUW2DBGsol8nEbs5OV z36fyrIDO1Sz0u3muXntGlXUYgsKpHi3tm3ZYnHByMjn+9T7mOJYI51vrhRbxCC3gtVLwtuwAGA5 GM+mBWclZsqDSeo6PSr22gsm1EwfaZ4/MBSTeEUk4ySOCfShLOYSXPlOrpj7xY7TjsorM1TT2P/Q /jQe1fbJlS3HyBmwGPpUcb3Rt8JCvnO4UrI2AvIBx9PT2r5Kb1sZT3Or05VTIukBmhyrKpweOM0x 4ZLqVmQklBkgcYrGbshW92502hXFtDNDPcyCynI8qSRWIU/NgbsevH51+nH7D+iW3iH4ufD7RPsL 3OozeL7fUrjVIsgpDCSiqw6ZBdQPU142fT9ng5S7Izh/FkvL9D/Qo+Cmnz6J4T0W31FN11tkBuXI eS7U7drufw49K93iiBkLr1+vFfiNF3oprqelhVakl5H/0f68ysgl27SwP8famtLtlEUeC4ALew6V /Jy2PQLPmKcpgGZACwxgNnp/KkcgEKybR3p7DSu7DYHy+FHfC+9K7SZYMNuDhucVurSRcI9SIws2 4Lz3zjlhUVvNIDIojdFQ4DONu41nB2kOe6P/0v3AMLMZHbJAX5VJyAfasB7e7t2lmlycLmOIfM8p JGM1/H8vduSm+ZpnRWKGaNHztUjnPHr1pJ5IonCnYjSMUBJA3kAnA9ehNJLVsopPEskihpWEW0r5 ZHDE9KoTQvaWks0SRxyID+9K/Ip9/aom9UgPwP8A+Comm+IrjwSl0mmWN3N/bW/y5JBHLLbI2ycI M4PljLAHsvc4z/Mj4ptrDU9WvbzTbu2ub3w5drfy6dfb7VbmGSH5USTGx2+YNtBPB+tfsvCNR/Ua cH5/oeXhbvEyiz//0/5A57lLm6Gn3CyGaRd8TNxCM54z2xXHS2s1pbzXV08W5p3t1jibfKQp4Ozr 0I5xjrXyenOckoe8WI9L0m6ig1FVE8sOUkBXEkfqD3AP1FU7OysorfV7RF8qLUR5QAG5bVdwbfGT 91uMZ9KvlQRjbV7hJDbx30TRPHIkQQxvncWI/vVe1pY50eSe2tpor3bEsZkyqvGQxYrnp0xkUJKK sjIyNRnsLpGiurpVexiVkgjJM74I+XA5xgk810MElndadYyWbwmVLUyM8Q27BuOFdexGP1oXUD// 1P4y74CwkjuJoo5o50LmQsWd2OQSwHSrP2TSorEyTRiWe5Qh5nYhbbceCqg8ke9fIp2lc85bFOwW ExTRRpzvMaP/AM9B6gdqgj04xySRomDBl2jz6cnFPndzPlvcfaXVs7SMqne6Ydyp+YDpn6ZpZLdr yJbmyaMbFJyjZMw9FPrWiaewlBtGjo2h6vqAub6G1gQ2Fs8k98ZPJuI4weVx15yPr71y2s6rFNHc afez3EDBSCI7YSwsccEtnqcV0U5e99xcYWdz/9X+ELyJWv41JKWqyYkkP8Pvj3ra862k2KBIRyoi 25ZiOleVB62PPKqSCaDydkf2lJiQw4yhHA+o/rXYeFrSCO5t5Vs2nuAS8pbOFUEbue3HNdcPhCx6 XfQW62wuZ9qJKxKeW5OwZxjGc/nW1p/2a/ghQywbLUCHIQb2zz83qcetUVyysRzW1lcyyQkNLbwy GM+cvlquOnFZur2c8NxaHSUtJYZoxFE0sohQnO089OOv4CgIp2dj/9b+M+6uZoIH8P3D2V15YUf2 nb3G66jbHIEqnGB061mXVjJDFmacqlsF8sPOJXmJ985PrmuBrWyPPILfXZE0u5sLJ5GD3hN9MYsj qCqhsc459hj2pyMzxlYbaFribC/bJG2lQOcAdPxos72GnZ3KEl0ytslYtIo2jAxgis2ddQuVnu57 86f9htmezS2QPNOw+4uOxJ6n61ryq1jRTQ6136lbxveySC8kjVminH71s+9LNaNpqtKVeNFADHBA 68frTjFIptLc/9f+JqIJelLe4xIkieaqn58d81fvby3htY7VrBIzAeJ4kJlIIwNxzXOcvPEwZUtg Bdfv3ljjKxI2VhGerAewrQtrKK/iSSZIgQm6ORlIcH2+tVDSREpX0Mp5H0qeRVj8+FjuHaQewqSc yrdNG4MAnRXhR2AJDAYwa1btoRe2jM2SaaEeaXaVI/3cyEY8vHC//rqH7TNcQSxQhi7DcxXgqB6d 6ZEpK1kf/9D+HaG7KtmZTJLtChXPTFPmnJRklYfaQd0XlnO09h7VvFWSPHEge8SZTLnherLjHvj1 q9OlnEYZZYVtxeOQr8jzmHU81XSxrB6WFkje3EbWkavcCTIL/dcHseo4FX7Kyh8qTeqSTSn95Iy/ 6v1AoTa0RZz91D9nMhiRnUNt+f5N30rHlgDyq4YBXUZyflQ9MVan3FrfyP/R/h+thNbQi3S4OyVs TQq5AIHIyOh55pb+4+SOP/WIylX4wD6CvQWux5ko3ZjteuLZFMKK8Lkl0QLI2f8Aa6nGO9RvO90y OzuVzkbuWFF09ix9w6tAFUiRlflXHzD/AOtWvaQ/Z7SKeQ8TZxFj0OM1pT7Ca0sZV6hkVWWNV3uV C5A3VnzSGALDGMbhgv8AexitASsrH//S/hgtot0YkHKknJJ7ipZN6RjyXVFP39nIr2Dzy9DOkJBn /e+Yg8zysFhgYHFMnCxFfLIdXGdw7f8A16DCSs7GdFPP5jMFdkiJAJBMa9uv5VSaW5890cthyXDH gUCJBdNGHJQM4GATz7VYj0+SWFZZZsB13hAwJUH19KAP/9P+FSJUgdY2VnBbI2jBf/OKsvBcSSAt I0cTLhSp2n869g8cihliiYwFBInmY808lRyPyqSWG3DK9vwTkv7/AEqofEgJUtmmjZiRgLkFev0N ZssOUYZDbTtzWwCQsbZHyxG/5dnQcVEJpuRHkoTgjpQB/9T+ENA4l3KMuP4D0xW3bxpOzGUC2Yw5 twf9WX45Y/n+Jr6OMb6nkqDZBDbNLdI0xji/g4O4E9M/Srt5M1kyxwlmjJwxHRu3NOUUloHLIq3B 89QVQKDyi9wfesVy6O27Py8YHJrMVmXvt5WNESSVd6hGKttI/Wr738lrK/3pEeMKhzlfc1tF3QNN bn//1f4STuL7jkIvKDsac4eRkJyY1PLBelfUHjiyShPlRjsBx/8Arp6xAoJgisgfB5yRQAyZpA4O NpBA+Udq0IkQK2Ru3D73Q0AVwxLGKELuzyx4P51HdIitkjLkYwvTPc0Af//W/hPtbFXkLzPHHGF3 fNwAeO39KddW8Y3gPvVTlWXgMK+oPHCFWnAaIr8g2yr6D6UwFI2yGw8Z+Ug4Ye9AFacJNIGcnA5I PVvxqzD8oDYDKflC9zigCC8ScHGVZeGIU52g1EqsqeYGAPQdzQB//9f+EdFDsHfty2OSaS4KS/LC SQeDnjGK+oPHKsS7RsCFSD1q2ykIpxu5xQBUuUY7dg4A+ao0kZgI2UAA4AHH41utVcDWWLyyshxg Jgd+aqG9fDKgLFfxx9KmewH/0P4RrRmUrIDu5yyuDg89KuyQ+azTOqJubCopO0e1fUHjiSebIRGC F2ptB7HHf9Kz5cx7dpBY8HtWkb2AmWTcFURgO3yn6VNFthcLgtg/Mw6LVK/N5AXpw7RK6kiJm2+/ vxWc7BWYRDbgDDEcmqA//9H+E5IictwX3Zyen5VdDxBFCA79/wA57AV9geOW7gxGL90qsCfmJb5/ fFUZYkkUqqMUUc4Pf2oAqyR+WERVPXIzT/NWRYimCsZJK44z607WQE0kcUy7zxMOgX7p46VDFctA dskhjdeVXs3tSA//0v4TGujJMz8YJ5A6se9ThWZMKdyk5weMD6V9pBa3PHJfKVMkjd8uPTbUvlxF AZUYgDauBiia6gVOXxErYVTlcjBwTVsRIzqrglccc8jFQnZ3AilYJtjhRtqkhiRyapMoWQFSeeCC K3Cx/9P+GGCSNYZ43L7owDGByjkmoJ5FRQUUKSAAMZr7dtI8cjtYnmLOT+HrVllmifcG2oRt2heK iM7vUCC9A2J8qk/xHv8AWordIo/3lx8wwcKDtwe1aATARqNxJZWU4XGAPejzoUCbfmKnJBoA/9T+ F03bu2LfCk9WfqKluNOlt7YXDTRuJXwArDepxnO0dK+7glc8cx2eUOrb2kXOOTjP51pGWBS0YiEc R+cnOSW6GtLp7Gbk1JooTqonG3IQj7wGKnKySRmMbfLiO5Qx/lTIbb3ITtZlU7wp6gdM1ppZtG5a RS0TD5XPRT6UCP/V/hhuoY5IFKh12vgODjmq8RDN5W3LYwWIwD7iv0A+fL0Ny0CyxeWpUfKXPaqE 3mTSZTIOPwNA4uzLEa+WY1cHe4OX/hHoKgHmB2DkLjueaCp7gkJkZGLbFB5z0q4lvt+dnRmaTaUH QD2oIP/W/hkXAm4JKA4ZRwDirJjMo2oflB+bI6V+gHjrVXKk88sShY/l3DYT1qKC9kiXbIm7JwNx +X8qBNJqzJTK2fmKhpBnap49qgmuCxRWB8xTwSevpQJQSG+TLNvd/l7Dvmoo4lTCtlWPqvFA+VJ3 P//X/hea3kUI/LLn+GnCIODtyqrwT0LV+gptbHjkqXEtvGY1AdBxuYciqGTM2/YSgbB28k1stiJu 2hbmMawch2foVxkYqFI2jd/mVlVMjnitYOy1MtgbbKB5m3cvQL1qwbeIR+YgGcc84zVppq5vF3Wp /9D+FZVkgkE6IuCSCvetQfabiHckO1ujHcAcduDX6dKSSseJLdFSWKOMKpYu+7ax64OaZtORGpYq h3nH3M4rEskhnQu8TDaOqHPFQ3QQHJkwpGCOgrGa94CaWMrDGFYlU+bIHBzTQ/zD5CTjIf0NSJJL RH//0f4ZoLnb5iF+Dy3HHeqpQGSSWNdu484PB/ziv0A8cXlZAZemzgenpUskiyxoMAGJSBjr+NAE MTeWpDJlw3LZ7cVYlEL7CuUA+8CcZNdFraAMTMUu1c9cg9cUy4Yr+9U5ZjjIoA//0v4TpXMzAAfP wq5OBn61etoS29NgWRB/EcqMV+iRdpNHjjFmKukTqBJuxx0arM6FMSD7ijLJ2qZPoTL4WQG5cxmJ G8tDyyjv9algygBB+X34xUmcW07E0cSyT+Yq7c8EY4NXZ7UxqWjbaWTOw8D8q1p7Cbu7n//T/hXb d5n+sDEdc9BV5b5hC6ModF44HP5V+jtXVj58arttR9uA3Kk0w20tzIhlCx+Y2ULfu4yB71i1Z2Ah lIRvLfJRfkUr0Hv+lW40LqAMFUGORxikYtasimjaEbF/1bjeoIwAT7VQh8xS67tpJ5agk//U/hdS 7TeImO4+wx+lXokjmZiSS6kBc9/SvvXNdD5lQbCWGRQ4O3cBuA65NUZJ0ZkRgVIGGB421Sd1c0jF RNEXKGJY4lBKnlh1IqFx5hXDBsE/KTgimCgk7lyKZolTaCrg9/4hVsxzXm2OTKKW3fLkKuO5qZfC yrH/1f4gGhggYbjvdBhgfmU59qz7uGNVBUgsvITFfcHz5DDm5VVbKKv3lqxJHlAQ7skRIKn7v4UA UZIkQxlASznOOv51ftmlUsHVueD7gVcZWVgJ5LRmBlbOztWZ9p8icYLKAfl4q1JPQ1teB//W/h2N 4J9zttcrxsIwQPaqkryAFo1+UclK/QD5+1tCqZJZAV2hQxGeMlSPStmwguJYWRozgceYO/tQBWnR YyVeQrtP3QuS3tSwXAjAK7gM4IHU1nJXlYuOiZqGdxEsSIpSQ7ycc9MYNZUgXcYkQIWO3A/h+lWl ZWRLjY//1/4egwtmWIA7Qg3NjhvUVBNdyq4CuwUDaAMjaK++cbnz5A3nMAUiwuMmQng/Snx28mGM jBSy8Ant71m42lYBrsseIYvmkUYz/h/ntT4WELJkNlmw69ePUCrg7R1AuXdg/JTaYSfkkU5Bp/lN JEFQkSKMbSMFsVkB/9D+GuJd27azrMCQVI4I+tSlljwpI39s8Cvt768p8+S2rSASSBQHRhtZvuGr F9JI4aWWLy2ABh8o5Xt9761ElZAZJGHMkxZiw6D+E9q3LWeJFSMOW8pcsTyB9PzrMcXysrO6btsU a5WTI47Z6mr9pHHIs4cbgRgnoB9K2gvdNOdWP//R/hwnR/OKqCyqdofGCadEZ1BDcspxkZO0ds19 weIp3djp4TGkYglUTO4BZ1bgDtisuaaWKZoX/wBWD/qz0x/jQWWLKZS7xR8KRu2k5z6mty1lt7rc rnY8HVDx5nbigTWlilqUg2Hbz5eSFI+XOP8A61cyshKmQEkE4KHnBrnMlFt2P//S/h8jVJQp3ICf 4QRuz9K2tOs4Ejee9IQrJtjHc+lfXSly6HhSjZD5bdrxZkEpVVBVGAwV9OKz7e1WWZLaKbMi/LNI xwietEG2tSB9y6xmSNWkUR5TzTwrY6kCsxAC8X7slXOVZhy/1on8IG2ttJLEqKygLJnygePyrJuI 5LaWVDhVY4OGyFxURlZWJ5Ve5//T/h+jtEcxxxEh5GxvLfepJ7SKGQr5bLKuYn7qSO4r6pyufOQV m0UI0/eDDBFVsGQ8g+wqVGmkkKRRhQOTJnGR361JT3RvxrFJaGIoIpipLBWBZz64rPnsLqKGO6kB ayViuccKw7H3oCSI98iRIWUfMflB/hBpJLbDcoHZk3ZByQCP88UDP//U/h9s4bdI7hVjLSs4YSli CnXIx+XPtTzBEVgDtmQuclcZI96+oPny9Yi2WQqqO0yKQrFsKo96paoJLi5kuHjjhBUKkaH5RgYz jOecVqoxaAwFBM6QsCS5CjHaugl01oAESQyRMo+YDbnjnI7VV0gMxY1NwV2/KhABTkEVJL5gcKrg LnODxxU86A//1f4cYngkBliLSyIwj2Yy2ScdKu3G2FljutyNjJHIC19QfPmTdYJ3fvEjP3CRgGpI psL5UeMgcluh96TaW447onE7RRsrqRk4J67qt+WssbMmAyqMg8DntUuTUrG5QlgfeiFgBn5x6fjV 7ChAIdrFvkZQM7ccc1muoH//1v4d5LT5XEahvJTzJJM4C/hTFmUW0asCyiTO4jhQK+gPHL73dvFC z4ZDLwu3kZ7k+lYZuPNdt2WA43HqKATT2NC21C7hC29rdtahjtZ0YqGx2b1HtTLe+Hmo11H9oeCf e6EkJJtbJH6UEvdGnd+ILVZ/OitxGsr/AOqJ+Rc9gfSs64l3WolljVTJOSpj+YDPSpkroo//1/4e LSEqjzPsCH5UlkyFB44X3oitpJrlXZFIUjlhhXFeyk3seOXb1p95LCJI1OxVjPyL9Kv6Hb6fM4N9 JLDAZCrsCBnjrW4GVqjIJFS1C+UZfLVhkEDoM0yAb5imCgjIEshGFb6Gi3QCW6jlDlHKRxxtv88H czKe3+fWssqxd9j74t37vj71KyA//9D+GhREhfCmF3I807fmbFb9rObdDHHkgqGyF6177SejPHNd CXIFzlo2i3Bs/wCrPpWTc3caSbSolVOFkByB74osrWKUfeSZn31wmxduSQMlh39qfFukRQGKr1GO 3finYTVnYswWt5cSXClJFtkxmVxgSH2FXRZ20UW5mH7s/MXIWZMnjbWco7sVuh//0f4iLmO3II/d szcEsecD0qoSsrH5yPLUIm0ZUgdj+teweJyI0bmHzITIqkGMBUQAKG7cVlm5jt3MMcYMrD5pP4s4 9PbmixLhZXJ7W+ks3dgIi88RhaRhukAPoaZcTJMihhuZB1zn9aCCCINJ8scZVm4Zm+6KGsL1MFoT GhBfzDwXx6UG8Vyqx//S/iIt4Y1a3ePDu3+sDfwn3qcmKRpJiqh4WO0L80f/ANevW5UeONUC3iO3 5PP5XJ5B9qqI2xJGMlxJePJmSUtuO3+6KxtbQDct544oLaCK2EDB2kmuuzk4x+PFQm2u7i4ja0jm uy7kSygbinPAHsenFBtFcqsylc3ws3kwpjvIj5ewqQwPTBqW01S6vZpYGhURLEGEjN91vpQNrSx/ /9P+HiSxd5n8tELkl2RDnP096vwwXUUG/btGcDdwT7YrvbS3PNimlZmrb2U1/HlbqS18pd33dxk9 F9hUOoBre2GSVYYVtjdR0/WmUZ6ak1vtiPmJIy/IrjlhjjFQXOrzGQINwdMdBhU96TdkBoq8dxAf MZ3nfDs6fKXOc4aktrWJDLNL8nO1E7Z9az52B//U/iJnspZWM42AIcIFOGYDvWfdO8allULKzgsV P3a6+dnCoNkxurkNBOt2fMjg2jy25QHqrfrWc1xErhJAJ3V/OQTD5M81Dnrqy1BLcguLm9lRd8zD Em7CKApU9RirYuoYURdu5scegpt33E4bsoI7pc7BHujdcls9K0MiRlQ5ZB/e+7ik9FcizR//1f4b FGyUtDGCA3CZyoovt0LBl3FpvuKBkg9605/I4LO1ykrXMcTPIWJPO0nJ46VesL2JAPPi80yHARvu 0nPSwvI29OgK+dHMiFSd0bIcqQaJk2xlAw8xjhVHesee0rBaximOWFXR4mdkk3swJwRWlbzSDLTF fKKYEQ9x6+tVzLe4r62P/9b+Hy3eWZzbs5SMN83PT3qDVYQk0cefMcLuQ9WCjgUk09jzzLgCznmA xyISASu0nHc12GmRWVzAtldzvDKXOUZc5P8ADgZ//VTGldmdfaTc219cWyR7WgbDMF4UYzn8uakt IprdVEe0ea+2STOCo9aDVRtozqItIimtPttxfL5Sz7DaBg7TcenUVPBa2NqJZLSASIF2oJsgMTxn r9amUuUpq2jP/9f+JPU7K0svs084ifzJN0aK/Mvqo78U37QjRukCsqMd5iByax55HOZpW0eOZLiC WTcoa1aOTaY2B5J9fwptnHNPI3yN2VM/KD+NLmaE4pqxYvnis7WSWYFvJl8p2T59rDtml0611S7l eS0LIwALM52qin1/L+VVzswOkhsxlZCHa4ik3SxKdizgY4/Q1vWnigeHo7vXItMmuL+wOLQXClYx lWD7D3IyBjoeaJSurIxcFJuJ/9D+Ji2e+1dX1e5Oy6upGnkZAUKbmJGR2NM/sNUkF1dTBoihOAmX D84HNZc7ueeWrW3/AHojJMikkKBw34VOdMumvILcGZQz/uygy6Z6kD1wKftPIuEeoNosplmt5rkF oVIii2n7UQTg/L3Oaot4cu7S6NpbxTzRvbiQLMmwxnGWGfwP5/hUynobqDauje0TQbu6EktxbC1c IEhY5PT1+tblj4O1a4G68nFhJ5xEc9vKW3KOjEYyAfQiud1NSvZn/9H+Pu30H7Naxwnl0XLBvmd/ 9o/Ws248Oa9qNzbR6Jew2t3CzGOGVRvujjhR6YAPfvXnuemrMOVq5laj4e1PToc3cxXUUb98k0e3 5h1wf8fbrXmushF0/UJLqB5mkiMNsVTcnm5ByW6dN3rUOXu3QrWPOmzcwQqYYoWiXbtjPy/U+9Jb wRoQsg+YAlivIHWsjn2Oo8PXi28gTyk4k/dzY/eRn+WK9QaOTUY5WgjP+j2xnuPI4dVXqwoFezsf /9L+KrGn70lFvIo2KsMkkZVWYcnOenfmur0m60+3sZWgtoRqU05nNxtxggYXH5V4svhZwXexz93N e8llDTSN5h6kg5Pb0rc0q9CqIrq3a0dm8olhhJDj+E/0rEOZrQjuodVkHkzXZe181njhtx5kQXPB c44PFYd7d6rZXaRafHGYQIyVlX5Xwfnye39KzluylN9TbllvdRE0abXEcSuSpysBzyN1LZXcirNb SRyQou1zI33JTjHB6/h9KzN4ysf/0/439Qf7PaxSMjM7NlYo+WfHqP1qa3kii+zyNYkI+6U+WQzW 7c/e+p9ea+ObtqznNC2vLK6CvDhrhZmE6x/NIyjjaT/k0s0xs5luViuY7JBuulKkSSr6Y9qznuaR V4tG7BqujQZvEsbq7uk+YWDR7fKGMq7KeSR1A6HHPpX7Pf8ABIaxbxT8evC8t1YxPbWlqdRuYp3M d8jeb5kIWPP91BjPGQK+a4qrezyqo32ZnTVq9muh/fN8KtNvbXwvpMN5DkxxlraV5vOmKFjnce3O eK9TJYSSRF/KMahiCcEjpx+dfjuFs6auelh1+7R//9T+vveqIE5YMvLn7wqgyQK/AO3OS38TH+df yfa2iPQNAqVjV15wMg+lRy5ljFxJnOdgGOT+FA1oylChMyM3IjbcuR901oT87mkztI64rWFrWNIb WKFvNsLIG5/hHep1lMpCluejVEPiQqnQ/9X9rvMu7Z1jbJQna0mchT/geefpVuS1Z1Dux3Y3KM8c 1/H1SV0FrEUjF4XjWRoTCQ6iPo+CMg+1SJGt2I2cj5QMKRgKR7etLmSVwGalJFF5EeyRj1cqpVVx jqfeobiNHiSNd5IxIyMu6Jh6c9amfQa6n5Af8FNtCivfAr6jpVlHNdabJcS6gl5cCOIRzKCQo7Aq JcH/AGa/ke8V6Gmma/rNstxFa6bb+ZJp1papvazlbcxgBz91TgLnopFfrHCVdPCwprdJ3/C36nDT Shi790f/1v45LtNSeGbU7YNM1u3lSNcjYIDkgE9+2K52S+1DVbuQxWS4trdRLPHwpwcZOelfIX1u c7a5mjQ063uNOsr3VJzJFlfK+yoRIXz0JGeBxwar7bs2bh5TFBIQ5jHO45H9Ktz1FdWuZkcm0TpC T5sBBLOhAwfu8e+DU1ncwXF0liIJJZmVmT5DgFeSc9q0MBmpTCxlW7e3jZoB/pBaPzCV6cjvTJJL 220X+0dPitnOo3fkSh2MTpFnOVHsMe9JdSmko3P/1/4wrOeO4ggtbkbiF+Vd+VhI4GT9PWugtbGC /C2xaxtQEb99dzbElKjd82fSvkZJpnnnOl9U0q4NlH/Zdzb+aGN1b/vdinksHHPHTFSNLdzzCco/ kk7ZWAKqyj09fpSSu7DSvsQ3KxRTP/Z0m60ZzFC6rtecEEEbe3cY9qZpGm3EF5FGtwYorFhOYomB QA9UI6A+o61tCLtYajpdnVyalcR3621ijedfjyjFE5jSWMYLlhnkDrjvWF4ms7K6s/PSxWK68w75 oHIV0VQozF0ByCSQe/TvXVBLmsSf/9D+FyeJYJdof5pZdjqRlAPVj2plwv7oxRqrKrE+dGMlu2M+ nH615Ed0ctk3cpQ2c0xCQDLoC2BweOa7LwzqE1reqp8tWUbCZF/drnglh6YzXQm1sUegWZ89preZ MeTc/vFkBxtOCHUehzWpYafEsmqwi0na3vCjWt8tzsFuY8bsqPX2+taKa6gaGoyxsYLe3mtYx9oE c16yF0XAx8w/xGfrXHTpJpVnFb3Ze+ZrxybmJPKxGSTyvRQKhybCx//R/jB/4RiWwt4Z5IrZodRt ftCyR3QmbDfdBAOcgevSuYuY/mgSV5Ps0EnIQFmfHYVwxdpXZyShfY1tNa3Vfs00jLZySF0RTtMs mDtGPX/69bcNs1vImXjX5SDDKBnnofaqilzNmbVnYywls8yptSS4aUp5WPnJ7Ej0/wAKWDSYWvlk 1CVo45GKxwxkOGI4w4z6gVoIvXmnBtx8uOGcSK9pLHyV2dMD09qx/EKXGoK6SSOkbIqyqQF80jqf x4oG77M//9L+K3RdtqYYkWKAKhjLsnm5yCCec/5FQXCzm6UpdERGQxyoItxI7GsEm9jzyrqtvIUj 2b5Iy+NzLtI9iKrWTalclra0kt4Xg5LXTiJMDjAyRk+gpxV2ZzvsO1Cwz5Bju/PeRP8ASEOBMrjg jHp6Hvmqmt2crWVnFfJJbyPia0dTmY7TjJ7r071o4pu5mJPbCa1TcNpmKpvxgkj1/KrFhaWlnBK3 mB5gdjRlPmOemD0xVAf/0/4gLmAQSPdEIFQAqPvPz3xVEBECzbwXbp7VtH4UeOaNtMxkEihWaFcO HI2NnjpWnaNb/a2E0KXgMZdEus+XCMZPlngAjB96o2grIniCXLzG1ZdluvmTGT5BGucDHryQOKpW t9FHiJ5IojIWc73C4UZzn39B3oLSvoYd5KLiTZ9ob7P5pZhj52GewoNvbxLsQM0Oz5Gfgj60BZ3s f//U/hqS5aJoQiZO/buxkgZ70ihUaQHzHfeSC3Kg56V03drHA007MiuF5BZSGH3eysasRo6w7pET LjCYHI96cXZlKKcWzPMOZZEd9hC7mdj09Ku5u44o4JJ2eOMFodxzgE10QdnqQV5UlaNYt53feGP4 c05LfbCUkBLIuQ5GWJrSUktAP//V/hqtoYhbSICQzHcdp7VnzOYQYi+ELDJbjIr1YybdmeeX4S0M gAVTG6gK/WtqRLexSU3PlTrJFtiWOTlS2CG/D0qzOa6nOMWUzeW58v7wizkE+tZqLcTtzkiPoR0F BmWBExyCBk9+wqVW8gHDDcRsK/wuKAP/1v4YEmUBZJAoKHAx6VFPM1xLv3eXEeoX7o+leyk3seOT Pau0TPEECKu75iFJHSqKQzIfMG4Htjg/QVUFqCV9B8Fw8UhRg4AOJEPX6irk0MMpLwAIrNnYzDf9 cVqaSjaJl3dukQx5yz5IC+WScH0P0pbdBEDE4+Z+Rk/doFGKauz/1/4UJIG3AxjIIwGXrV9Iv3ca uxMinDqf4R2r6JScdEefa2gkscQuR5bZRUwRja2fWq87Rxx7WYtg9Dztocm9GBHbmWV4YEUu0jCO IAcsScAUs9lNbXckEoXdEdrMDuCnoRn26fhUgUJEWNmGQ2TwAeBVjaWVVkDJk4AIq4PWxnU6H//Q /hDmIVlVCx2nG3PHftV3KiPMbspX7ydnr6g8cpfIWkDFvnPAxyKtWDizmLOWljwdsZGFP1oAfLcu 8/nHaEf+Ec4HpVq4uYki2QHcpI3nbsOeM8fWgCpCu8tLvCdueCaikKLI4UksMEZ5zQB//9H+FGBH nUPK3Ctho14IoMBkdl8zy03YGecivqDxxEhaBysb4bbztP3qpzRK3DkqSeq9VNAAVYrsJ3MgwD1O B3qzHFiLeHDFR0B70AVpdyZJJJcfXFMt1Z2BOHjU/Ou7BoA//9L+Ep/KYAJiNVyBjqahhIik3FVb HVWGQ1fUHjlq2Au9zBQgV9h7Ci7heEYGSq/MQOo96LAV2dZo/lADYxtxikSxlCGYqFKLuwxxkVvF WVgLtkN0LtcMhDHC/wCz9KzJ7bypFeNsxsx6DrTt0A//0/4Srf5ztUAE+vFXnJVgjIhReMjtX1ih Z67HjleSeCNvLU7tx+V+m096ga0Yt5h+fHK46VpawDGk2vjZtKjBIp8Cksz7uv8ACe+KANBSCMsM Jn5RnA/Kmpai5LMpII+6F/lQB//U/hVFsY1BZvmZtpQjaV7VJcwLGiwwsDKn+tx2z719ild2PJ5d LldU8tdpYtJnH/1qvQw7WR5BIgBwwwfehqzsSV7lo5GCI6qqkjJ60lo8QOz5PTJ4DUN6JAXpraJL cuHVWzwMdcf/AKqwpz9rYbgVaP5dwHNID//V/hLW0mhUSIPlPAZhVmBwEzEQ7J1J7e2Pzr7WnseO SRKZ/mLMp3YYkYAqxNLKirHv83jagZcbR7VTV1YBsMKAM0mN5+76CoZIpshlYBhx1wazcGgLcH+p V5EJbPORyaqPCUcyBR5bevBrVKysB//W/hcZreSMxRkxuRks3A4561UQyTRtGVBMbcsOvfpX2so3 Z45YgV1JWFgCRkqxwD9KmWaUbl2ZCDD5/hP1rOzvYCtwWLMu5jywHalNq0zAniJF5C/xe1axTSsw LCw4DNs2R/dXPXOKgtoIt0m6PfzwCabdkB//1/4YIWtFlkEiHYsJOc7WVu31x6VJbTxlfJcEq5yM jOTX3B44sljliFK5z8qjgD2qtLa7ZBvzx/AeMGmnZ3IcLu5FL+7VtpUbxg5GT+FQJlgq/ex3rdNP YyLjrHsT5j5meVxgAVYhut5EMh2rnAXsPegD/9D+G1hBuMbNuVTnyyduT7VlyOyzs6REL7c7fev0 A+fLSW6TKFWVsuN7Bu9AnRZPLSPIA2lwMYNDdtwHS27GSPJyMbutRNZs28bguDk+v4Vnz6+QCTtG IY41b6k9Wp8KqNgblFO4E9TWgH//0f4Y9yEExoVAYtIc5LVC80ycQE+S4+8Riv0A8CLsyNpZGYsv zBhgKwyR71bjt0fy1cjMpxjOCfpQbXVrjJrfYflGBGcc9eKqeWC4MmULHrj7ooC6Tsa7N5CKQolX HUD9aqLK0rk7cheoAoGf/9L+G1pmKAKNsa/eLDke2KLiJUhyHUO3Plj7w+tfoFuh45Daxi6DKzrE E+8znANJJ5UTJDGu05+8Bw3rXQlbQym9bCyRHzS0PzqqgNnjBxzxQtr8jSuAEUZfJxVJXiyChGVZ 5CgCNjau88Yqw0wSEcAso2nAytSNO2h//9P+F+L94EbdgDqO5qaebylZ45CueBkdfb+dfpB4Tk2z L3yTSb8hQDk46Z9a0ImIl2ldy8e1BqNuEjR8oM5GQelTW9mJF23Hzlju2nkAfWspq0gJ7hRbrtLq VC9RyAPT61QD5Own5SMjioA//9T+GNFCRuQoKt97jJ4NVJpco6xxlVxj0wB3r9APHEVnkQOF3bVC MSfwzT0d4t+VB3DbuxkAUAK7o6hE4IOS/Y1MLUzIyl8SnGAOPpWkZ9GAAJbHEshYnjaOdv1qe1QO xJQNGxwB60+dAf/V/hpn0iMEFHGDkttbJFMi/wBGZbcEug+87DnvxX6FF2ldnjlKXImDxsuYzlIy oBPrzVkTM0b5GS+Pk7DFJ7gVHt2YeYq7QvGB1NaEckfk+UyckcHvmkYX1uTRMqFVOFIHAHBqK4uf M+RmPBwSOtawVkI//9b+F9oI2TcAVHr60iwhU8z7qZwc9W+gr9IPnzQQRmKJY+U34Oeqgnkin3wt A6FWkYQJgDORn2H+etYytcCnEUm6p14BPJpxcQKUxwfun0qTOTWqIZJHuFEb4IU/KR1q1DaQOBiX cwGCoXik1pYzP//X/hjnsoEO6PdvU7SWp8csm4LlVCnC8YJPua+4sfPlpjJFMDKATs9cjmqRtfMf zSdxLY2bcCtYbAWVjjRHljTbtyrJ0H1FVMLJKh2kLuyGXsasC6JQXwAWCcLnnFWHlulCsCVDDBHY 1E3ZWA//0P4eSz+V5jjg8FuuaqyGPG5uOcAnoa+4PnyKOSHy5ArOsm7IyflNa+n2k05i/eAJy0pA yAPTHc0WtoA68isBsSAzedGxWTeNqvzwQO1ZttcBJ5EbMkWcbgM47cUATyXeT5Me5VRsnd3/AM81 DMsUi+aCN2OmOacd0bR+FH//0f4a/IKbJYQpfqA/Cn2NXYkM4wVCMcbggyqHvX6AeM4pjpIooPMY BmP3MhPlNWLO+a2yu3IYY5oM5Rs9CCd/PnklnjCBhiPauEGP/wBVQ2ojWbmRUjwWJ27mOOwFRf37 Cs0ncvymFE3hhhuQSccVmQmNpSZCwHYjtVkn/9L+H2UqTHGriRz8zDrgdqsGzhlTzZA3K4YA7enp X37aTsfPjbdQwMGwmNBxuHB/GqbbY5nRfmfGNpPA+tTJ2aAZtjXZvVTKOcnjbSQgyXGMZ44xwKjm dmgNCSdIEjjjk3PzuRl+VPTH6/lVyCNJkV3do3j5LL/FUgf/0/4e7uJ2lcRhlYkbpEHykep9Klht 1ykLxrNKvOSu4MK+36nz46do1lWAIIYc4x0VT3/yaieMSPPblwwKjbnjJGDSlsBmCGV5DEqZYfKx 7DHFatgkUTsnU9CW71jYB95GlrNuRSPNXoOnpTrOeXEqsg8oDIPcn0rWD0sB/9T+IERtJMu3BOc4 HbvitdrXy42yoTzcZGOWxX27dkeAtyo3npOECchQoPcVHc2rxzCQq9xMwLsmPl45/l29qhz7G5FD biQrJCfLPckY2GtgmO0jfOx59uRKPmGce1LnYGRd3TzCKJIzgcu+PvE9aq/Z1ThW6jJUr39KgLan /9X+IEae4jEkShWLfeD9CO5Ga1GtZEhFzLLG0QyuwuA2fpX1rjeR4/qUZJJE2bQXc8sq/wAI7Ve0 6CCKR5YUZfPTdcb2yd3fFEFZanOWrq1sxCsrygOz4ijBySR6j86ybnbEYZFkSQnhVXqhHqKU30Ak s7l4ZCHj3k/xj+GqVxbT38reXH9xst8wBck+5/QVmJyS0Z//1v4gJop7VEgA2TseM9R9Kk8jzAEa Vt6L+8Y9FJ6V9QfNwerIGsXESx4yf9Z1+tWFRY32SpiQoNqKflA60Ck/eFaEJKsiFo2xynPHv+NW o7y5EZh2mS28wNLFI37vP97HTOOM00m9EW2rXLXnW32tBLDC8iR5jhZ90T5GcZFVkdGuJQsYSXoU B6A0W1syj//X/iRuIIocBdwdhjKDg+xrHltnWRZd5AD8J03fWvqpJLY+fLbR/Z4xJGzgsSZOe2RU HnWryrLJGzyKpUKxwrEjqfpVxIv79iBmTz0dgFccZHBUVcnlUwoFmYqSVO1sn6H/AAptaNIptLcp xI3IiIAYZfPUYqKYfMgB3vUcjGf/0P4g1s4Yo45UxG7Eb5AMHPuKy7iO6nmlaQvKiucysDz/AJ4r 6g+fHwusjeRcFpUC/JGTlRx0qO4t0k5gVwc424wq0FwdnYrGWRQUlG7a2OBnbjvWlb3HnGKONJCg b96dmTjjnFLlV7mo+9khjWQo2SDwxG01SgldE/dgtjlyeM1HI9RN2P/R/h2eRtzRABFkQB3J6+1L a2YaQQvLiOZggJGVUn+I+1fRuNlc8SUuiH3dulpvt5lWWWOXYSjb4+PQ9D0qKLTzOitGEjjlfarM wA3DqP1qbNbmabiRIFtio2o0scmSGwycevrTZXuLl2nkSGPd8uIEESkDgcD8KRrzLQz3tWcjbnYv 3g/8JrQUEwpbbgXYgKCcAelASlyn/9L+H0TbY44LtkkW3k3EQjK5OBVhZ1jdzvPldVzwVHpXuwVm zxk7q5j3+yVlVGKwr8ygcAk9akWaQWLwfMRuDHcOV9wasY2D96qxZOT8u7uKstbyxI+/cSCCuDwf rQBNLcQTR2yRo4lGRcqw/dgD+In354qGQbVQQhIw0vB6bO2cUAf/0/4epoRHJJIW8zzFALAfcxwc VJtZIw0EmXzlSvJbHYivoDyuR2uWGuwfklQpKwxJtPHA4qjbSLJcvHIqiFFxIwXLY9VFJp2sjS2t x0tuHm32uJrZBkpINrke4q29rL5aTIoVkblFGAR7CmZS+Jl6LUZFe0XmN4n39PlJ7HHtVHUp91xg 5lbHmPngkmk1dWJP/9T+HVoxeyrGkZO05GeDmrtjmOV1kAUYxgDLcV7fIzxyW6mZI0OWRUc4Td80 vofaqNrEl1K0z8SchE29/WtQK82nXcaFhl2MvygDO4ewp0cDPNtXdHvUKQ3QH19qzmkieVJ3Ohs7 SC0IE8qgLg+dO2xJMdh+VbFxeG9spEjaEoqhg5wGUDjC/n09qzNoR6s//9X+IJFZWIY5G3HydTTc GNY2tpHeNc/aYWTBPPGP8969duyPNcEy8YWukWUPsKIWSKYbAm31+uKrQeZL8kMIa5YbW2HIIHf/ AD6VgJQs7lko9rIWuXMsYTKRiT5QwGBxU9jqc0FtcENJA/CxGM7Cc+/tQWY89s8kzStI07bvMmkb lmzzk1qWsLsriGDMsy7Y4wvzygeg/PFA3Fx3P//W/iAhuUSUuyeXNb5wCdpz0INLNfXF1GizMLdI yZMxj95Mf4Rgnp6/WuqXxHCoNluG/nTEUbyKssezK/eLZ6EVNGjuzpcPvVl5VuScVTlayRooJbkF 9bx5RVZfLXlTs+YewPXtWcltvJbcM9gx+Y1lNuzY+VdjqdL092LeTA0kkEX2kbSNso6YHv7e9U7i 3lWUlg7vK/mMijdFGB2rG76hyrsf/9f+JKZ545BG0RVWXMZjOT9Pr7Vl3MTyPt8v73I29c002jnK 1raS+ZIjKQSvyrnH406XTHZ9pQhmGA+OOPejrcCMQTW0yR3CZO3aq4yCPUGugs9HtrjZIVcpGd7o wxuBHAz2ouwMbUdMvYnaSzRTBjHo4HQ1dg09zZMHD7olVtzLiR88EAVc30E1of/Q/iO07TYpGkaN GLKdoSQbdrdCfc100NjYWYEd1M8V1Mf9GENsZ8EdecjHHeg4+V8tjBl0AyySIdyu+X2y/JnJPI4q oNLMO1hbF2gby2BXrUykktDOxcg0q4kZoozLGSu59gzsHsauWujiK8XzJTMVBIV0weQcE8/5xWDk k7EpNNjr+wnJcC3dEHyh9vyvn0/z2qlpmnLqDXFmkUpltJAJC6GNSTyPmPGPpQmnsJN82p//0f4p pfCN/HJMlsyNcyLld74gQdxmrI8O20FhFPqLf6ZKPs7MqExKw5wD+tYLQ88bD4Ya3xNJNEYwDIX4 3gf7tS3Wh214LRbUPFqck6tGkuIzMOMjB6HngVTm+htD4SV/D2oukqRsbeUpsfzSOD09f0pbXw3f bQXEZUfLgA7mI7geho52WkX7Hw6wuAJFOF5MUnCqeeRTbzQ7uOf7NHeKGc7yfLLLbgngMPTA61F9 TZxTP//S/jLh8G6fDN59xqMN6+wSSSAs8ET46BWxjHTFNuPDcCTqtmoRZE2OEJaTnqQPQ1y86Oe1 tDDu/DGoxRQbLJFgtZmQTsxjeUHHJHOcV11ppdomnxI8oe6ZSWDLhYjn+E1HPIT2Zn3ekfZdnmoJ YrlSRIi74mI7fWq9tB5SRyRx+WZCSYyMOcc5xRzyMDWtrFrohbeDzpnG8NGNzADOcj8DSWFrJc3+ 1rea6idTbC0jj8+JJDwshUDPGOvSpdToZ7Nn/9P+O650RtPDm4ARon2smAUQD1H6VXufD0NxBaas LiX7JLGTPCEAjhZWwC3HGRzg46ivN9qedccunWcH+l2uJFPAZgMIR1I9KmsIYJLh7ozKHgXMOGHy MepJ603V8zamtLHQHT7HSrybX7q7trvXdRsYo9NSVfOks9hyWAxwSOpNU7aa41q7uLe62nVjJmNn KxoyqCWyxIHGBgVLqaHXY1UdI7GGdktYZYn8h4Vl3uX5O7aeSPfGKtNrVlDHEvkuLxgfMkZx5UgP TA7YrCUwP//U/kWsfEOn6drFrc6tbCbSNrNdxWzhr6Q7Tt2KSMjOMjPbvXHR+IrbXLXU9cWf7ILL ebNYz5Nw7rJjaFPPKg9PavE59Ng6j9Y8R29/psstuTND9hjM8t2hj8rdt3FWPUg5H4814z4qF3DF ava3Xm6XdRB4okk/cxuRhty9mBGOapXXusyqJnnzhom24YNg5JG0Cog7AbFYsf4j3NVsjlas7Hda bpZhS3lkBZJVDRt91X9fy6V3Np5AS8mcCGVY/LsYFuWRJc4Dbjg547GkNQbR/9X+LBRcMn9mXJHl hhMqMd23I4IPuKtqLOyiVE855E+Z3bkD+teJN2Vjk5ETm5l4m+zJLbwKsqXiZBUnPyt7dOtWZJrj UovtV1biVRKJLdnG0717jPQjP61kJwstDdMjfYJYdOb7JeywBbiGN8RXCHk8k/eyBkViXWnyRw72 f5yu5cjg4+9WMviZCTbsihDcQwOsKzxqrqGZ1bLPnnpWtDPby27Swgna5jkWVMcqe1Q9EbxXQ//W /kAtWiuLeB7iFDKFxJMyj5vcUkunukbrZTcTnAQtlWGea+Mnsc5BbWv2ZJobK0jS7lAkluyfudj7 H+uKbqepebeQWltDNNMsqpLPOdsBbAzuHcc9RWRtTTseiaNp8qyONS/sye8uY9stxb7XEOOFUNz2 zX7zf8EUfAUU/wATNcu4Vng1fRWt7+bVXX5DZByTDFk+pAOP76jnt8ZxxJrI6nL3iv8AyZImLjCs py2R/c74GQwaRpx2tGr2aSGM9fnG/OPfOfxrsXRbifc/IU4Ujj86/LsNFxpRv5HdRdqep//X/r4A U7kDDK8EDrTRDswoG4npkcV/J56ANLKiNG3Udh3pscx2fOo29l44oAjjuA8rIv3ByfwqxcnzI2Xc AMYBPGKNiob2Mq2tR5hfeTtBwT0NMSdUldMNvLcEcACiL95W7jk7s//Q/b7yoGjWNSZMDLFefLqr cTTRKqM4jjUjDeozgCv4+augdk7DwIipaPJkYc5qPzd2YwBG0Y+baeV+tJxurANaNpoQ1y+8oQDG B1x0OKo6jqB+zIVkmFvHJ5TQKvlrL1zubGcccEVTjdagfmf+3nbWlz8NdXilsZGudc06YxXsoK6b p32VsswboTsYqAT0YntX8evxB/4lWtalLHZWF9aykTWqwyv5kgJ5uJW49eMf3e+a/Q+DpNNryf6H BKTWNUeiR//R/j71WL7RFKjTW1taXzZ1GUTbwQD8o46c5zVe2g+yNJaWqxBAoieSJhJHKvXO7v2r 46Cbhc89zvNmU0Mklw8JAlihkzLKx2RoewUfxVbuVZLaQzwRTQeX5iNA4Mgx6L/jVJXdhKSaucxe aaHkiu7GZsXDKLiKJiOgOFZD3HqK0bVXaZdOa6Syicqy3wVRKckbowSM9B9P51s1cUZJ6EuoQyfb 8KiSQkFI5Rz5vbmsnVNK1iK2t7jUNbQwxSeXB4fwVMAPKyKMc5ye+etTDYu7tY//0v4urawjCyqk oRply+H2MpPv7Vehl0qOApq0kAkmifTbJ45DJcNkfM7gYIIJ49cV8pNKx55R0Oy0/S4G0+Pz5ysv mQXdw5bchz8gTpx71ow39wDdwXF2kokk2wwmAJ5SjONh+g5pU9y6a1LselQTeHze6UxtbjT52a2E jFZ5GLEswUnPykHH1rChGpK0kNrHE90SLjVZydsk68csR0PPT1rWLSepo9jrkjXUl0xZkTT5NN3y wXFsv72dipwJCeoJ/L8KztSMiaTMsizQ3Uu6OWSEZiZDkDB67unArph8Rgf/0/4cfFFgkFzAliGt /LhVp/N+Y3ZIJ3kHlc5HA/u1m298wjiW4MSLgRHyo8KB7+p968mHxI4FoW7We08lwP3d0HO1lXap Hrn19jWnZbZ5I/OClw2FCfKWA9frWxpz2dmeiaVaX99FrF7choRNGkMEgkLXCIvy9Pw4rbt7DU2t 7ZbdwljLJs8yZxFKXAAJboQMY5PFFirovSaTPpybbie0uMsZQsLrMDnGMkZGawdVc6nZmxkYRRMP KJgQGVC3HBxmguLSep//1P4yLjUF0iC0gSB7qGBFiRnAO0ovyh17g4wcVlre200CXflJZStKStoM uU55PsPrXAlfRGD3LMl7b2kmnywrbPNJNuk81uUI/i24xg/41uy2X9p293cG5jinaeNreRHxGwBJ Ze5HQdvatIJmcots524ltrNpbm622mrWzRmy+zpvnvfm6sewxWa99M+pfaZtqQySGaQMDlmJz+Ar WMboagka914it727C+QlssMAG6BW8rKjGcknk9TWSJb3UftE8qmezgXLSgnenOMke/rVxhpqDimj /9X+Ju3Mss/7piFXhFPG2pbiG+tg91DMZHmlCCAN+8ZgM5+nNJJRVkcfsylELx2nS7vp4V8zzRG8 fm7WyAUGB06nmjUCn2iMpCJfKIZyOC/Qj8qSjZ3JcGiCNoYLlbxlY6hI26N5X4AA6Kvt61nX13eX 10TOzNtOSGPzfhVGbgmXoLiaYRoxVEjOFVvSnzso3xI6tkbiyn5qCXDsf//W/hs1Ke4ZFmTa6xsI WjLhHZjnnb1xx1FW0tHeENIqoAm99rg44/Sqi2nY8pQfUrwTJE0ija7v8kYPQj/IrXtJhJZ3Nvex uMIRYnzMGJiRlgPQjNbGyV9EReRdMIRZLveND5zs+0tjkY9elZhDXU8jvHGsqjDfwLHjgn9KC4Ra 1GTBLTaySxXwkAy8Kn9xk9D7+4rYjtxdxbopUYIozGx2tj1oKS95s//X/iDFtpyNLA0jmRUEkUgG 0ljj5SM9Bz0qtDEs91HZiRIwzbTIf9Xn3NdaiuW5xT3M+7gljlkRyHMTlEw2QcHGa14o41iMl1GV uDEEjjziPGPvY9cVBKbSsV44hc7gY0BB2ElslQOhJrPF41rKLeaJLoGUiE4wUB4xXQI0ViR1gdmj iMrkLt+Zhg4wR2/+vUE+6OUIu5WPy4ZcbhQB/9D+IG1tYXlCTSCCNk3NKvQcVi3aW99dzQCITwxk eXJHwMjvn616UPiR55ui0srO2jjaQSzTHGCCDFj0Nc5qjAzFIj88a4OGyoxWwpK6sUbKVQxSVuW4 JPatW4FtbtGqS4ygdgo5PWgwKzTMYni8kJFIwIuAP3kY/wDr01o8xtHHh2XlSeSauCu9QP/R/hMm ilLiPBEpGcgcetWrdDNDIp48o/ifwr6C1jxy350RgEQk3un3vVR2FUVuWRlidmYnOwDn8KAJY2iP yhH+07yGLk1YuY0jWNVUefIcPJ/Eo/u0FNvlRJHYoq4O1th3s2fmHpn8qypY4/PbDMc9F6k0En// 0v4VrXCBpMspTOI2O1Tiq0s91K4lRQpY4YjtivoDzIv3SeRTLCkqswnRsMFOOPWmqqS3BMis3mDa qKepHrQLnHzxrAyQkbXP3sHpVy1MQSUMxOFJ/eH5TQRzO9zKlhkYrhVAz95TnNPjMhO2Rydo4c85 +la09gbb3P/T/hESLzJt7HaF6DuxqbaRiT51AfHTrX1B45JFGjFzMSjH/U4XcCc9D7dale2dcswG AM5PGBQBlySL9wZADYLAdKslkRVUkNznd3NS5JOwE0wMkSrbqBj5mIPJNQi3mRPMI3yHnBp8yQH/ 1P4TondWXLAMRllNXLbEs/l4LeYch84VfWvobtO545HfKq3vkxnDAAHHuO1U7iAK7Rq24nG4njpW k79AKbo3PJUgbcjj8K0Y+I4lZVCqud6j5nz61SVlYpxsV2QbmDt8ucqT1PtTDB+7LW3yYPzH1z2p hLc//9X+D9lmTy2ljDYPIBxx9KshoHYlwAWG1R3H4V9Sot7Hjgk0ltnIPlgbQo6HHSpo5xdMEDhS y8mQ7VraKsrAVZY9vIHzo3z7ecj/ACKsq09wyYclWAQg/dUUwJREsRVH+aONsEKccCrVld2zSPBM ioh+4CMhfSgD/9b+Ey5lijlYxRg4YgbeF+ppVV5h5rNhV+VgO+K+w8jxzNmVmzhflVuo6/hV9ZZl iUbWwg7DrQBPEiyptCkuPmY4xTIyIC7S7VHKrxxQBYhhnnVpTjyF7jhVz0rQsrg2kU0JjQeZzHJy ZM/4UFRV2f/X/hfMzsHMiBmB53DrVIzuZWldSqZ5wK+wPPt0LsL27OJyCoiO/wCuOQasy6s97EyY wF/iPDMB0oImtLoxWiVlDlSMkgHOM4qMKGkCk7FX04NBnbQt5EuE3naOApPNMUFQeNoB6dSaBH// 0P4YC0nl7AAQRkKRwKzXUlyquI8csqcc19rT2PHLcN35KlWTI+6pPQ0x5HLKznfIOFKLww/+tVgT 2sUkrgNJ8obkN/D61LcpDFOqhy+OT2AoA1rKWESRxyKsxHzKo5Bra1q1tjELgxxqAvllE+VF49BQ B//R/hbaFdxfHyA/dA4IqzuURFI0H97gc19weOW7dbWVrbKOhKFZSy9SM/8A1qS6ESIyRgBC/X19 qAMpS4DTQpu2jBUjkD3FOfUTIqpF8pTghVCqtADvNCom879x4x1zTYpyrsq5BJwPloaT3A//0v4V xtAl3uC27jK8nnpSK8iyLtKKE7kdK+4PGvZ2L6XKN8zFgQcdOCaayy3Em4vnaMjdwDjpTUWzOTd7 E09tHuRn2AFMEH73viqTwxKA0avGAOGfktWyXLoQQZLMA+QFGAw70+WFlVSudwxjP8VMD//T/hqC 77cEqrSAYHQEHpVLymA3K5aUNynXd7Yr9APnzSsoXud23ZDKkZb944jRsDpk8VBIu1chFRiOSO/0 pNXVgKouAHUMx25wW/u1ZSRZJQpIER+UuOp7VMYWYDJ7eFSB5iTSAbtkZztGeP5VlyyTGRAAeOig 9qsD/9T+F4K6yo6sQHQeYh42+v8AKrTSAwkPwifdOOPpX30r20PnygLkJyVAx7daRbgg5yFy2VJH 3B7U5OyGm7WRd80quHdSpHUj5jULCN4ipfO7lWJ+ZaiM7bgk3sa0MTwW/wBnl8uR5Yt6suGIBHGc fhWfa25G9nkMRQ7mXH3h6CtDc//V/hyLRfK8TA4GWVhjGKzXZTM2WJ3HPPUV+gbHjiMVRvKDEs49 MY9qRoZ8oPmwRneRgr9DWsZX0ZnU6GrBbbY3LHOByc/MTVSaVoQqDmJjhweGrVSsuUhaMjVLeYjJ 8oLySO/4UBLMv5O9mY9CB8pqQbuf/9b+GgW0UUg65zjKnCkVDfGMKoXHXjn+dfpB8+VrWESfMThc 4HYGrc8Xk7CzFE6AqOTQUpNKxBLcR+SFSIsAfmdh8w+lS2l4m14SWXPKt3/zxWc11LjK+jHTzrMP KYAIp5P97FEkS7VcHA2/w9aiztcs/9f+GeMkp0wTwR2FQyjdvjjUhoxlmxgH6V+hxhdXPHH2xiZY 0kIRSMEqM5I9ahlKrKyhm2YwA3Rqlq2jAS2tmTgFcs2Ru7CpWeSMnaAWDfM+eMelICIK0kpkaPhS N27gGtuNhbQYRIzvfqeoB9KuHxAf/9D+HeOPczkOqqrEEKeD9KqtFLM6LD+8ZpNrIPvLnpX6FJWZ 446Syt9rGX5Z4id3bp1FZ7RqJUVJh5bLnOeV9qkCi9xJBvAV2DNtBPb60sUjyyRs2VVQBIcYA96E uhg9y9dbSR5M6lhwG7N9DVBCQcuCWB6HvVKTWgj/0f4ZpUVkXa5Vlw2zvinxmKZVBXKqcE+mPav0 JSa0PnxhhESlkaQ7iQFJ5H0FP8otDvZSVTl2x0HvUkTdlYmzaQIJQTg4JHf8BTJp7S45T7gO0bh8 x/CgyK0tv5aB42GW7GmxTBWUZ25bDYHNAH//0v4cZPKfeIizKOpOA34VLZWaSSRIzA7jn5jgL9a/ QD56OyNI28JnYQfvNnyliPlH0rMnSKJ3WV3zuGAo4T3pxV3YYjAbY1D+YRyWxtH5VGIgTlEJcHhF GVz9KpwaASxO0v5qbSzFcnrxWsk9oEkDKrOnQnk/QVm0nowP/9P+IAKs/wArNtAOUjjHTnv6VTuV DbraMK6btrADJU+or7/lXY+fIo7ARxks4aZScZ+57UWl3LAGibfFI3Qqce3GKUldAJcz71EQGZMF jN0x+PrT7CJl2lV7ZIB6+9Q0lFMC0IJJJmdUV+OVJC/qaqhfm5XDF8YzxiqgtDeOyP/U/h4mDxK6 +UT8mY2PG0+tN0+V459kqMyiMsxA4yeBzX6AeNJ2Whca5MThZTH5bnGOxqKaOOeRFU+Wv8LdQaDN yuyeUB4Y4JD8ifISOvpmq8NrBAuwMWctw2MY9qVle5Tadxk6+bIYQgITAZwePXj/AD2qTyhCgKxs ynk/LwMe9MyP/9X+Ha2RpLx5QoRVPK449MfpWnczeZMkcMbqi4AjK4Yk9a+7krysfPkpAU7XVoiq 5IPG6qkrRA7mUbjwMDGfxpzQEFxakN5zqNgTGN3zf5Gat2tvFGkbyDAdcqR978azASOwTzXcuJYy vVuCKsMIwi2sLfPIcEk4A9s0Af/W/iVjtJjI3lhXUnYUU7sEdqVIbhAkmPK3OY2GMnA96+4Pnyhq MYFwvmxlGYZjz9yX0NZ8aM7sWUqVOBg4P40AbMMG2FiI9sjjaCOp461VjtZIf37JvizsZgcBTSaT 3A0LSH7eyq2GC52knkAdaq39otm5WNtqueOefehJLYD/1/4iYvLSNHjkwwf5jjOfetL7QJIiS3mM BhT/AHa+3aT0Z4C0ZBbvI8zeWgdwmMnv+NSz3UiSCUWrArHtYN2b1HtUOGtkac6JJUVvMkOxI/LV /lOHOeuRWQzQXDMITJ5UQ+dUU5HbNCh3KTujSgsXMAYs3kocq5GASazbiJlfAYls5YsOo9qhqzsM /9D+Jy3tw0HmGZUBIUI3Vj7CoJILMySABnYgKRn5Tj0r7C2p4k21oRyttmiREVPlw4z2HSphPbSB lVgvG3HTmoknZJGRGZFjJQsCQuULD5RVmz0aS+jkuZXhWJB8zI2ACemPc4rIDPu1S2kkjj3SnZtV u4/D8Ki01ZJLrAWQ5j5ZjgLTiruxhJWbP//R/iZuIY0dZjIrSBsbi248dqx5J3dmQkFup7bsV9co JHzCbWxrWjM0ITyFeV8Iz5/1YB7c98Co7q1CsRgrNwwYnn8KFFJ3EQEOx/fMzMo4PbA4rodI0j7b FLLJiO1Hyec52qGppJO5V/dsYV/Z28Ny5WRCtu24EHKkj0P+etQNMcpKoVDn754/Ok43dzSLuj// 0v4hI7h7lmIflWwN3Ct9KrmOacymIK8sQJkJcKgA719dKN7HzjnZ2IoftLo4kY7mQ7V6gVAskkss YfH7lBHGAuN+DnmqtbQzu73LVxZXVzuuI7Z2RWAYouFHr+mahaJWt3CjYqtkc5PoRQaT2KtvM0E2 dokQcNFJnbWnbQpLcrI4CxDnaDzQQpNKx//T/iUuTC0ISKM4j+dsnczH29OKofaFZTAkhSOTBkUd GxX11o38z5yMr6MqXEEdtsaDaxJ3PxzUEc0jP5R3Rq43FsHaaxLJBEhMkeWYM/zNt5Psa2lRbJYZ IioyQJDkZHFBfOzKu4oL+RvKO4AYcH5Q3vUQi8mApgAj5dvfAoHKSasj/9T+Grz40j27M7W++eor U0xw6u88hCLzEmMbz7mvqD58IdSCTOAkRWRzEUkwRzxVlYQEmXhRF8wUHOPXFJq6sBjzyxkM2PnJ xz0FNtMOwcsBtGWVuBisXHlA1WSOeORV6CPcmBjkc9KzFthlnc4kRfkBPyn1zSG3fc//1f4fYobd 1CsxEvUhTx+NJMIoJnhmZGZUVkQtjeCO1fQHhQlbQdtN40ZjtwkcWAkfUn3z+FJtmMzKqeXvXYw6 Bvz70GpA8Qj2LFhJ1bc2fut6fyrSiDXETxyyiGQMCXC7gcUAMewQJIqyFpQpkGBgvjtWWckBcEuB jB6L9KBp22P/1v4c7a6aOYpLG7pt2MmOD9R+FOlnVG/cqU57nOPpX0B50XdXHRP5obYSGQ7i0nGa vI0bOjqu7Iw23oxoGTrHHaSE52tP8xQjIx6Z6Ve8+Bn3b9kYGBH1dse1K67kOF3c5y6ybiWTewjP 3EPG36VJYzxRxubiMSSAhYmP3j70XWxm01oz/9f+I+XiFmjgKuxAQhe/c1iwxzxyGbcVRW+YN0b2 r3uaJ45ry2t3eQJdCFXtUYxeaq4yeuKZBKIDCjtsKycApho/rSc10A6gX1tcRCJYUPlyYMxyvGO1 YUr2i+bHEHa8eX9xjG0KMls/p0rNtvcLdBYlF6P9MB/dYEeeFGOOKriKdpJLWIiOLhTtHT6GolLl N0rKx//Q/iPv9PmtIg0D7pVKmM5wH9cmkjtTJiI7oZ2G7co3Bj3xXott7nn2Lwt3t2jhw05APmRy D5mHvWUYbm3nJjAVyxEcqEqvP8P9KltLcAurKQxxeYQHZsSQq2WHvXTx6ZYQaMjXO57uScfZ0R1O 3B5aQ5yAMjjvzS50aRj3Mi4tr2Gdlhe2mRpQFmtuVKkdDnr6Zq9Zw+XvuZr+7s7yA7YntVAkUEEY ySMf/Xo54luKZ//R/iQi0gbZJS7SSrJu/eMN0+ecmnRWTyT5lQLJ/qYpMbtmewHvXQ5K+pzmk2iH zFK70lUbFCjnP0qRtIu4reVrtxb3RhH2fy/3ke7I+9+HOPWp5ogOs9JmkgSSdoWnI27QxKsR0xxT 7LwvElzI8zu7zuGfcp8uMdABjoKznNFRaW52q+HbZWiLblUEMqRsVH+T6VVWwiilkgZWWHzCJGRd 8iKc9M+1YufYk//S/jO0ew0/Urm7zDeG0gjc2V2YhGhcHGGJyPqBzU6eHYRfLcpGr5+TY+BGvbOO n4mo511MEtbFG/0FEuNiCM44JUjMeev8qv2uhLPZ+WqF5IW82Wbsiil7RFSjayRjXGgpPIEeQBUJ MbdHOcfL+g/Kt6ysLQBLC4PlRiEpJLGf3nAOD169OlPnRBoyWGjRW8VqBGFuH8tJpiIzkAcA5/Hm s1tKgtbp12/JtGZGcFI+4Ix68UvadCml0P/T/jXHhy2upJHkvZYkdg8bxEJIjA5zurSk0Rb2+xbT fZxZIhM6MAG/h3HPqetc7qdGzCxsLpEdxcraokd7NbLukMOJShxyeOmKxtQsktHd5x5dqp/1mOPc fpWftES4p7kN3f6fo2LsrC1hdEI7bh5qqMEYXqf6VQ06Wxv79rudmCTAx29nbYMuRjBOex9u+axl Mz5GdTpXiLw7p11cW1/p8UwjX/Rfts5jaKRe5x1xzwajv/F/h7UJZGtvslrDbx+W6wQrEwOOWPrk 9/aoU5XuNWtyW1P/1P45bfxDpTeVAbizVyx/fSTorEdcAZ56E1aj1nR4l8z7VZSxk4MEwyvPAc5A H49q8xyadjl5FozIj1jSFugjeSHSYbInceXPg/wnOCBXQT6l4Uurx5LiKxW5s5ECp5gicMvdDnvg 8j9aHOVzSK6WIZ/Enhk3sjSWn2WzU/6UVlM2CVwHHfI+X8hWSvjvR5ozELdoUtZC6TyKIZ5xxjAy cDjv61UXLY05UtkY9942sBcQvD/x6yvsDSOGlYjqOOKW58Xw3NxJHBatHayhUMgbfM+O27HAHWrc WtCj/9X+KibXJXnW2SMqk5MJKvuz9a6O71WTTltZ2vibyNVWMbAgZFXaFP4DH4V5rbTsjOUVa6Oe n+JF+YJrW4tbUxm4/dTSbtxwfu5zx7ilvfFM05YpAsLOA2U+6hIywFZ6p7mMmramTbeObyxM9qqx ztKjGOO5TzY4+wdR2NV7/VNZuI4bpY5PPERCRxnyc8cj2z6e9DupamKkiodW1WG2sZLl7vTZQ22c RMWjZB0DuOOa0f8AhJ9dsmeTRpJnurqHMU9u5jQKB6jHr2qXJWEnG5//1v4p9D1PxneWs6OT9lcm 2urqcETSOSCeO4Hrx/OpLmfX9Nh1K2aW7KXciJ9khy6TBSNr7R1yefavEcleyOH3b6EGlQ+M0vDp kttfQw37b4zOhCoqrk4PYY6A9zXq9j4cvW0+RdM0v7ddzSr5scp2PNt7jPXHXGO3WlKXZmsOXoZM +m+OnbVJptJg02w0xUkuNSu2R9yZwQO6kdPX8Kr+GvBvjPxA19cRwvHqNxIr6el3KLZNgwFZdxAG 7OcVHOlF6nX7vL5l6+8DeK21lpNR3rJpatawwqQq3EijDliDjj/Pv1Fp8OdbvrV31DUbOzlitzc4 Lsu8DpGhwfm7DPWsnUVrrUG1t2P/1/43734e6qNrw3EtpOswhjiJ+0SSBvmDFAcgY/i966rTvhDf 6xAR/adlYCDDSoy7/MkY9AvUnqSa+b9qkrsTdjpLn4Bajqkp0S68ZWC6FCxVMW5g4Klvv845HTB7 jPeq2g/s+2dxc79V8RRW+nQxbY9MgiDFjEMiRiy4APBznPtWf13lhfl/4cU02jxfx18O76C0vddg tbu9trK5+zXs0MIEFooG1WyO3AH1I9a8N8sZWS2RWVG+/wBRmu6E+eCZySbUz0PRoH1C0hWWbzZI g2FU8xDJOAtadtaadA3n6teTy2jTLGlhFy8jKepHYdqlStJ3LUk1qf/Q/iz8S3b6zcW194f006aY 0jtY4rhSjTiPC+YxHUnr6VE1xfXDNJdIRMQEc+UIs7QB0AA7dq8GUrnPvsaNs9xFaztK0iQFdvlB c+bg9dv8qZFcyI8fDyW6AsquMCIn/HmsudEyklp1NrT9t3OQFEbM27dkhIvx7VNcNJdpdQLNFJO0 fkwNK+FQZwSo+ntWbd3cyi+VnNT6Li6sYpFiIsj88sfy+fxgZI/zxXQ3lvHZwRxQZk8qTzbiWP7r DH3cVnPY3Ttqj//R/jjjuEu7eOaCc5b9z9nzgqR/s/jVqxkkjQxXLPiMkRruwQT0z7V8ZNHOaFyG tv3oyblYt8KSKfs5Oern29OabpcWo6vdywR2tv5SOrreSSCOSUsDuUewxwDWbjbc3g3ZHsGkeFr0 aUsz6ezu0xjTa2UznAJfoM571/Sb/wAEUvDcZ8SeItYJd4bedLK58ki4jtZBFHG0ePTcwYg9MDvX xPGv/Iin6r80c+Ji1Dm9D+xjwg8n9lWtvM5kaGEReeQf3iqOM/QdvTFdoBEEbLbR0JHANfm9FWpJ Hp01+7P/0v69hGIcyjOGHU85p28nAVsZ5PtX8nndD4UMKpuaTeXIHzdwKbsiABHHmngZ5NBRDO0d su5EzJ0PbioRcCUEhPlA+bNBUdHcmikSVWCqV2HAJG3dURiiMjHqVFOK1sSf/9P9s42hgU7HY8/N nvRJIsj5YZjdPlZh90/Sv5Ab0SHKPvXIIbe4VHaNTM8SlwAPmxWct5LG6yNEzYy0kbAGRj2PHccc UpOyuIkW7MsjzLuCN90EYP0I7UR3ts5NrcRkROCGz0z/AJzQ3p6A9Fc+Q/2uNC0wfDbxmLuO3ktI tLaCG41Jt+n2ayRO3mbOhbLY45ORX8OnxWXUtL8Z6/8Abliht31S4ttKtLRPKto7ZJXQOo67XK5B OeoxX23A83LGVI9Lf5HnVKiePjTXY//U/jvfRku7C9u1MMcdqwkEMj7FZmOAVHfnnmsh9Tgt9Psd KSxurfWri7eB7wEtaEY3o+cYAwCP6enyVJe5ZnmctptEMt3aWETWl3eg3pyWaIeYuOAOfXqefWqE tnBq2kpaW9/Jb3WWMl79p8mRgh3BQeg6fjmtLJCjDuYkdrqwAlgeFxC3+vlm2yqwwAQo5PWun1ey ksdHjnY297K7hoZpJFEu/HOFH19KY4ws7mdb6o8kdtA0kkRVwSyKXdCOcA+nFaXiO6W/8iY8XQGV l4LAnAx9eP1pJbln/9X+L2GC2neSG9uEtb5IR+6VSjyZHGAe3BzTI9HiuY4I7hEj8uTHyH5gFPDK exIxXyk1pc886DxBFoukW9hDBK0eo6lGYYtQRzJAm4EbGXBCsMc5IzXPTtYWL2brNJeSMpj/AHsY XMqgrj8cZz71MNzaCsiW61rVWMTWb2Eflxr9ojlKxRr0B2dAT19fpTNPW8t7u4nldAZZMM8ThxMh AJz265/IVcPhKNhr+0mQrDNJEsQ3K+CMHPQ59/WpNX1PybC0dZS0zNsZHAIJwTnHToK7IKzSM3G7 0P/W/hu1TUH1O8uJ5hKSWwVcbdmOMD29KxZDDujjSFhtYlweVryobnnkjWpZXaPJHGcds1t6LBEC kUolAjfcJA+CK1LkrM9eSxvBYYaS4htbmBo4p4JAJVOBg49OnP8AOtCzN09kto8W+NFUPKZQzOen 9M5o2HGLTuaccFvbEwgicNHnBJAQkc/lWAbuwhty8CGVre4ZppF/iXpt2+xBOfeg2ik3Zn//1/4u dXhTUfsV9HNc20aSt58VugK3JOFUHI/z60ybTLgBImWNZFG4uACrgc7cjv0rhh8SMGrOxmIyySMI drvCNpVvvxnnqO3T9K0LuPUl0yJ7SZYJvtQXZF8zTnGSu3qByMn2+tbCKDm81J2upYms7ixI/eiM jBUD51+uO1OuUlnVxcFXg8vzZe8kpPQ/XP41tD4UGxnFJYlQFWeF4+vXAx0Poafp0k1yi2kV1NaR tuWcQ8NMnJMf0PGaoly0uj//0P4tLCBZbe7iaKFZEjaS2/e7HAjBZ/xwOKpxX9u+Z3uBbvDF5vzn 5JFHp7/5zQckZ30ZcspbS/uJvPc/Z1t1nimUZWZiclc54qnq97o97NcG1ils5Di0UQx8MyrguGPU 8UE87MmGSaeBDL+9MAMEXnIEkUDOSOO5zWc8RMu4kBt23GcEexoIKyjzbt/tAeCOFcgQDeCQMY6/ 5zWdPLLBdsSj7doUrF+83g454oA//9H+He/tdPMFu0jB5XcFWViGQ46EVDFObN2SeOVo2X94CPld e3HemtzzyyiqzIIbZQHO4bvQ9MZ6VClnqFzcSsqPi2Qs0eMEIMdvx/WtxptbGlaTQWt0TK8wt/Kw /wAv7xT9Pz/OozaQXM0jorhHztx1Ye9BrF3RBbLCpmwufLUgr0Jx3/SpYZRbAzpGp80mNIickHuS OtA7+9Y//9L+H65SFY2hOJL1DmVlHCd8Z71maVLKt5HF8oLy/I0mMZ9/yrpu0rHA92at1ZS+ZNOS rys53LHyOPSqU5WO2t5Z7iQymUoYjGSqrxj5qcVdglcfFFbKpkDkeZ+8cK3LY6Aj2xVdVaZkm8tH MaEqGYJ0rpjG+4h1pL8xeaPbtbfFjr1pbq7e5l3BQpRdqIDnb71co3QH/9P+GpBLsbe26IrhhnBY njFRxQzRQ+XGXgUvu3pwTXqwjbVnnkM94tw7wznBwAWXjBHcflVn7FbrG0iFW4AYh9wAqyZfCzCk iL73G0bH2nHtT4IfMLmR/mxhNzYNBiOiJhWeJpZGS4ARwrnt0/UD8qmsw9q5CfvVaPbudstGOv58 U4pt6Af/1P4Y7KMXE0zTMyshDKW6P6im38JSV2iygl4YLwPf+VfQHjlSGONZJI1cSZA3Hbgj2qrM JYZS21SykPHn5geaAt0NiKQXMq3SIiTYy6quADjkYrPupJPN3M2XX170GrXul7T0luncSMseY+Cz bRKR0Wq1zbvDOWnj2OB1U5U8cUGR/9X+FG6BmRCrCMgYZWON30qG3cxgkHleqEZzX0B5lPYuI6vG zk7XyenT6VWkQxgTLLiQfOu3IZaLBGNm7kcNrPK5uZZHO8YO47unt2qSQyfLCqhlP3jn5zVqN1cO RXLlii7ykoYb+AeoAqhNGfPkVdwjDYDHIB/OrirITp9j/9b+EWFZHlLKd5QkcDOPerLmaUiLcDzw MYAr6g8nkkMZGjYCU9Dyc1LNexvuQEmMptBc89O9YybbsJqzsUo02/dwwPXHNEsYyBuLHqRtwqip EaVkI2V/mIZPl56H/OKtSSRPIsKoEKgDK9OByaAP/9f+FZ7ZZGcR/MQu5wOw6Zqo6fZGARm3D5sq eBX0Kt1PHKUkzSs0kYzIDwxP61IsjzAM+55l5LD1rcaV3Y0oLe3LhZZCS+MKBwTx3pl0pjka3XgJ yORjp0oNmrlMqQnznGD+JqIu5LeXkoo544oMpr3j/9D+ESOTecvlpCMKvfFXWhtwIrgj5lGCvQZr 66C908chkCug+vXPWqh8qBoyAflbJyfeqAvNJA7OQBtk5JXovtzV6COIpiA7i4xxyU9aAKj2z+Yy FyoAyT/fNVZ7aaNN4bBBwHxzQB//0f4No4mZ9rOxkbk46VrraPGg2sW2rl+OPTmvsDxx0UaRnc6k 7uh7Cle6jy0aDBAxnHSgCSyc52oSGz87HG088VJdRvJJ5UkafMdylT0xQAlvJtVFZmjiY4YL91sU yW6WOcsMBY+Qp5oLp7n/0v4WDLFJG7DJlZcj+FVohkAidXC52EFW6N9K+wPPI4kDRlJGMYBz6U7y dilV5JHDjinbcTV1YX7Oo+TzMp154571MlmJCzZ+VVypXvQot6ETVrIrLb5cKWWNkbIbPFaH2Vlg eWRkwpywLAMM9Dj/AArT2aMz/9P+FRrh1GyM5GcFm6D2qR4oCVaQlG2gHPVz6ivt0klZHjkNwASB uAAGBjjHFNiaSB48fMCR2ySPSmBsFk2BwTHcO2MBcKB25pjNG67FQvNGuZDj5fwNAFaMm1nWfDFu oVTgr+NWJjLO7vLJKV+9zkj2oA//1P4Zo5YliMZQuG6YHT8fSqrv5bKUQlicL/dAr7g8c0NyiJV3 fOfmIA+7URkkmhKbQNrfKVHJ9c0ACo9mNy7csMyeYeGB6is9pYjKXUIAW+6BgH60AM8mQy/u9mCc 4BwF9am/1ChxJlt+Au3dvNVy6XQH/9X+FKZd85uZZDCSf9WFwn5Uboc53s8meir1HrX3ygluePYk EmJ1UbWjXoCMqfqKtsWTB3bs9FA+UCqSS2M3DXQa0hYlpIWl2LgKrbc0+CM+STJvxKfkEhBMQ9KD MpiVlm2hQFThm6iiV3kcKjZUcn0FAH//1v4YoC3CjJH8RHapJE8srLuwGO1Wx0+tfoB8+MmV2wUk 3KeTtNRtIkgTc5IUbQPSgCsIt8hVQRH/AHm6E1YkgkhQAYYE9qAGBIwUeFmEmMkkdOxFWbaONyZD guAULD+H2oA//9f+GF2SPAKvK+cH+EUkuHRE5RFOQCetfoFj58zmIaUIVJHXI4xWp9iUxqVQBcBg Sdx+ntUyV0XFpRsyrPBMSeDz0AHAqYxfZoA0iqWfAVCfmUetZqLZcXHoTWOW3+ZI0XH3h1IqB5Wk 3xiRlkztR8Yz2rYo/9D+FeMTKCrsMJy2T1p2Vlfc2V4wo6dK/QDxy1FHHMUEpeOaP7r7cjA6Vcnm ihZISxkYp1PQGqgveInsZ63LGVlOV2n5femsztOY5wRuXehUZzWxkNcyNjbGFjHBYHk/hURw7DZg MDgn0xQB/9H+G1bhXgKMvC8Fz7dwaxJV/e7iT5fTk9a/SD58lMhEKjhFzhCON2KPMkePklv4UPUL 70ATYSNAshPTnjBJqk0ahlZC2Ce/GKBrRl0xMUw5Cg/cIqZA8h27slRgkcD0ot0GpNXsf//S/hll imVCIt5A54X061DFI53SP02kbcfer9IPDU+5WgtZA7yZPl5yqnrWj5ZaL7vygjcxHI/rSaT3G5pb CpHJB5gZo33DdHjqB6GplRXiHmja38WzufxrLkd7EubvoV7fbPIkUz+X823J4H41Zt7iMSm3uIll jBKA7iqr71cI23DnZ//T/hyYRRsTE2U+vAqOWQRFZIWETLzvBwT71+jOKbPC52NEpul8t8PISS83 O5s+tQTWi2+AFLOTkYP9KTh2Ju73C5s1kVIg2yZ8EjH6VZbTNkCQnCs3RujP6ikoNPURU+wvGNnQ bxnjJp4hEc58xSVxtHuexpuCA//U/hqZEySULSDAP8ORTI4G2sUOI953Y6iv0NQd9T58ZcS/PHIT kxDCADpWrDc5RJHC4lTBTGQfqKXKzKTukZd+hlJZBhegRRgD8KrQWJYA7uh5x2q3D3fMIpO6ZcnJ VFgIwOobHP4GmQ28TMu3JLcE9vrUqD6k20uf/9X+HNrRYV3B2MjHG0fcA7GrNraybTM25FjO5znG R7V+hckj58rpe3AnbygUwCBj+Ie/1qIzsHXKqN2dzMMkn0zVxjbVh5FqOeJGCsm89G461NdeVCqN A5MjLlkX+AH3q7dAM/zFMZBU7l6nNTWtoHG8MN33iDwBWLi0B//W/h5cm2GYm8xw2WHXiq8LSm4e cEDc2doHI4r9APm3L3rC7Gu5ZFWUoF5PO0fTNQMHKcK0mwnnGSMcVLjqaCxwtOpUEKG+9nr+FaEU iQKsQ4Mfdep/zihxurAJKt2qLMAxRxny1GC34VWg3SIXk/d7m4yORTSsrFKTjoj/1/4hGnzERId2 FCqe57CqsCEznkovlYKHj6V+gHgOTZZbT3fzIiVbcAY2bOVrMb/Rj5cpxKh2BT7UCLFvcTtnMWUg 53OM5Jpz7502bWJkbLFBtIoAs+YlqIoEQMxPJbt+NdRAtn9lgMsgNw8jKluI8gjrkn8+KAP/0P4k 5FS1kkSaNlQLlCo6Emo5biLC+WyLOU/dD+NwK/QLK9z58aZjcoq3ALzt0LH5jjtmq1wsMLrGjnzE w2SMgH0/CixPNG9ildSXCn5nMgY5AxUsDXTyJvxtUjeqnt7VPIrWHzRXUts0qTExpiMH7p5ZhVW4 CidXdWiwvAPA/GpUO5nKTex//9H+JK2vBHGY0G1SCUZThmP+f5VO8s6RKxUtGgLOf4m/CvvuWPY+ bjLoyjHZpPiRmndDnY8h4iPuDU6WkcTAMQ0mODnhj/8AWpOC6GhLMrCBRHJ8ynDNj7h7VWSR5bf7 Hs3Yfcc8EH19vSs2raBfoNQNaAeRv8zOSoGcGqM1zNJMXuwH3nC8YxgdP8+tIiEm9Gf/0v4hxb3E YUKqYd8lCchR7mprdY0uWgkdiZ+Ito2rnuK+4PnHNJ2NS3s7qyM5kDAb8LGQQQPfPNNLpPceWCWA TJHb6UWLKT2jxF2kmFuXBZVcbt2OiiqELi3EkglTzlPCryr84IIoAuafFcXDsJZX2feSItiMdecf jUt2GgnWNoSVT5mJ5Dj2rOfQuMm3Zn//0/4oPOWdQ8ce1YSFLn5dhOcDH4VUVm33DyQ4LHZGyN0P HOK+wPDl8SRUm8525XkLgAD58Vas7OWZSEtxK4I2k8c+maDO1tC9rFjFa3Bs3ZHmj2q5ibfEGwCw 3D0PH4GsuKSa0k2lsRqMKFJK/jSsuom7bluJFYXFy8bSlAWAPyq2c8A1n20s6y5TMQc4yTkAHsad ktjKW5//1P4nbe2jmuhF5cZDZUux2jJ7ipLyytLZA6BS6DD4Oc19gfLlCDzmVCiMEckecnAXHY1J PbXbpEse6Qj70ncegoAhSRhcfYLqR7eOUBXcRnqPWrkt8yRfY1dhDCxIVThZCON2KAMdmlnOXOYm OVYDGajnhzCWWQvHnAVR9zHGKDSn1P/V/h8jSN4iAzfux8qgfOx7iqkMEsty0cPB25ZS2DivsD5c 3jaF1hgVPLwCZJifmI9DVYWsUckRQh8t8rNxjBpNpbgdZHrEUVk0FtHF59upMyD5fNz3Pr3FcpcQ CBvtn2YfZ5HDyRFjjJqZStsW4OxkssKSyzbzsZiwV2B2deKvWSwzQTb5AqZHlyI2SGzx+FZE2a3P /9b+INzcWgdyPMRV+fBzj0NVYZoHy3yxt6E4Br6jbY+agtblciUzMMgoBuJH3QK3vk+zJlQU25jC jlfeg1OenupIZEiiyQX3Zb09K147eae3DyoSrtlVzjA7GgDOgT7PJ5cxkQFv3fG3J9/ao715WuNg j27ujKcr9P8APrQOzP/X/hylWNoVR8CRfuhV4kPQ5NWDLthWFQqBVzgcg/jX07aW54HK7bGILeYT o+ODL9055rq4ba6UrMQojABYs44X6UueIin4hie5lgkSERRjgyxgATADuB0NUbWJRtbcMKdrKwxi olK+iLjDqzUtw+ZXYBYvuxv3+lU7xQRuRTKj/Iygc9etQU4Lof/Q/hyRZFnAiwGQDKt6ehpbqCSZ 0lkyZj8qkcAAV73PE8SMbbnS2CWltHDL9t3SE7Z7coFkGO69vWqtwrSyMzjYhYhDxzmnzLuWZd1a uMBXIMZ+dgcn65os7Wdp8eczRkhc4xj6mlzxA3GjaFzbscsq48wDjFUhYYYFcsxfJA6Dmp59QP/R /iQu9OMUKzRqVYtiQHrj1/8A1Vmw2Us0uPlD43Kr8BhXuOpY8yGxam02eOMu8ZAcbSF5Aqe0t18v ZG+AvLqvXPvWcqiZZalgaSW2WWYiEjYpdcBCTzio5bT7Ld280Lx3MC3HzSMp/eKDzxWbqJAKdKW+ keRmwjuTGYxgoMnjHSrU+kWUQjFt5vyqA7Sj5nP8XA4H/wBal7QLH//S/iekiEZZXlkeHH7sBNrH 0GKjktY5hGAjoq8lexx616bqWR55fs2jWNkB2xI4JjX7pPrilvNN+0yS3FshWIYAZ8DHHfFJVUJx Q+1s0ECwuD58bkllP7krV+ODT7S5eKOK2eQoJDcxv5hiBHKk5wOnIpuoCikW7K10lbK5uJ8zMPlt o4wAhbdyzH2GcY9ay9ShtbhlnsiLcqoDpGNowOOn6mspStqUlfRH/9P+LXyor23jRY5AUO0yvwDj qRU4Njp4BmctFGcG6ZQBHn19Ohrpc3szma0si28Uqie8SeBJINsscUyfvJImH3gM+45/2hWRPPp8 0kZC7AuMqxDZcdSMAdT0rJ1BJyejFFolwz3+E8q3x5mWAA9Kk8zTQ6F5Iy3UK0gEZHfNTzyKNSW9 0KyTZIsVus0HmQTIQxUjPAXPTg1yMupWs7OwI8vpHuIXf7kUnN2A/9T+Jq11rTBeW32gbYA4Ey53 Egd8DtXV3uoeGPsLXMV8lq6XkZQNFhhnncSOw4HPrWUpu+hzN2Qi+JfD8N1ClxqUO15hHJdQIZI1 BIyw4Ge/FUdW8U6M0ssEDPdwRSEQTYEbyAZ2uVPQH0pc0hRlfcoWfijTE0u8N7GhuYn86yaJ8uTn G3B9j/nNXLHxnbSQvGzuMqJBGowZG7Kx9snnmok3Yo138aaNH5L3N60K+XiSGNPMmjcdF6gfrwKx LrxjBNA95bXyRkgxtCn+sYejD6Vjd9QvY//V/ir0Tx00kX9mQiNILhiogeXbCWPG7Bxg1pT/ABAt rN5bJbeOZo8FpA2QCvUBgeh749K4U5PRGC3sYV142trp5buO2jsZQ257aKVmt2BwOCxLZ+uaTS/G kjXCRteyQWTOfNtUQOZsjAGe2CAetF7aM15dLE+reIYo18y2ZHYyAB3bCoO4I65x2rj73xxcASo8 BkmjOIpozhOo6jn/ACaqKvuxRhdWZa03WLzXZFmnjZ2tlIUEEKpXrgHvjmr13r8tqAv21yJmEbLJ JmKHbnkD2pysp2KcLys0f//W/iGu/E97IsNva3bfZYCRHKFAabPc/wD16q23iTUmnf8A0qYlnHmt v2tLjsf0rktHqNQtEp3Wqa5ZPqM0Oq3NtcatKzG4tpWimVWGGjXB4GBg1FZ69qMKvFc3815HGVEc cjb3VvRvqcdaT5bNIzcOxr69q97dtBHOqA21qsjRxRiNVz1yB9Oayo9V1p5PtlssnlQxqodIyqDH A+b+dYT5Vp0M2mrinUb69g8+2imuZRKROXDO6kH51PespPtN27tb/MZCUdFOXQr1GPaphKETFqXM f//X/hit/DN7ql61oIAZbeMSecU3pDnIGT25rYvvDviGO0S2nsLwTNJ9nBtVMscqjjLEdF4715Lr x0Rz7EFh4B8U6j9rllt/LlsIt1vBcvkyP1CegLex6Zrfs/AfiHUrhZptDuoIfsYVZEUvEJRw65PJ xx0pPEx2XQ0U23qaNv4R1gWV9bpDLbvbI0cVxqGYIpSvfuSB9Kks/hl4iu52tkvtMSG6SMW9wqTX ILMBu3YXoDnpSVdbs0Lv/DP/AIh04TSXviWyVYpSWLWbtDITzmN1LDHucV2vhb4J6xd21+LjWrW0 fAa0e4TaHJAAG38+c/XrUyxaeti+Zdj/0P5E7X4deHtDvpU1q6iu7nSbVZHt8GX7Q75HDJxngkHr wRzWzb/CnwfrSG6W51GK5kORLcTF7WE+8Z5AHTj8u1eB7Zv3kGj3MzUPh54KktV0OSxGoXLkRQ3d sjh/NB4I/wBnsT1rStfg34K0+5ZdZs9bVIrMBIxdvHcTyMgzjPGzJYgYJwBzU+1aIlTi1sV7n4Te HdPitprTc8Jj3t5tuYZYWzgBsk7uMc5H0o0TwdaRXN80llb3sYUNbxXEZKQjo5zkf5NS6l9zHkUb pDf+FfWdzltkMdnZubkWAhLLc5I+QEdhwevQGulj+DmrXGnr4nfRLLTNNtLnyAVVVTyuqsYupzxy Mj3rJ1raE+yi9j//0f5TZNI8P28ZtHlt7JZWN3GtrACwdv4Qp5/AmuWuNFdmW+aFyeYLWZ49j7Vz gj2NfKqet2cDjYm0EX1nd/bLiza5uXBt4Zbs+fFECMEA59Ox6ZrZtdfvLLV7djbRrC7OABFiJGTs T78jFLnRdM33vbDWFewd4LNLuTMisAEQjkkg9QO3WtjWNbn1BLWCFrS3i02z+eVIVhuJguFUsR1P yj/Cp59UdTWqDw54x020ljvZlj1vyG8y5trpN5nbnHXufU0ur+MU17z9MfQbezUOJ5migWN40bLL hh2BA/LrSkry5kwtpa3U/9L+U+NbaI3UkCPJIBvilLc7s4APt249qwy3iPS9YeXUmht45VjaK1tz vkXuSw56givk4yvoxWeh1kmv3aK6gNIEXzCT8pLdQKzrTxRfTyeZeeXp/ljEqecNjqeMHv8AlUOl eIybVLTRvEuhSaTY65/YgeQz3JkTfb3uMkIwzwA+D/KvjO88M6nbXlxZ3NrBbbJXkimgObS4XcwB Qj1x0rqoSlG8ZHNVipVNDV0jTZbKVWjDbgf9YMqV7cVtw2FuZpftEKTCf5S7qf3RH8Q9+MZOa28z Fqzsf//T/i9vbgQqYwpxFGEQnnkdDUtpcvdJb2TQubi5fybSRULDccnJOMDp1JxmvnnojihuPumv LS9+zyiNTH8knIlAPTqMilnkdInhhhBUx7wxGFyeprAi1tCqt20UIMQ2lY9rqpJWU+9N0OC7ufNv ri0hS6Eht4S5I8gZzmPnnI4J6UAayy3X7xJ4Q5R8Ky9R2z7inadf2Mz6nbXMpSSABJSZBstwVzvc feAwRj8fSs5v7JrB6H//1P40LKxnfU7KO0hM2jsrma4szmbzBhlfnqMA/pU8tnqH2kRmXcyy+cpk 4OFbKhs8dsV8ec50Y1KPVbBY1lgjaKQxSNu2suOCPpkVPELjSbiyWFmJmTeSDvRl7E46c+vNRPY3 joketaNqGo3A0xZtYvJrJtTVLixjnADlhhMrx/ERz6Zr+tH/AIIfeDLe30TxFfSNGdO1CVZLyS2b c5unbEWCTznygp9dpr4jjFx/shw81+ZniLezipPqf1UaCgjs7f7oaS3RgOv8IGT7+tastu0aFSSI zyc8n8K/N4fCkejTXuWP/9X+vKFncrH0jVOR+mT+VTLBjfhwXxwBX8nnelZWIIsmQxMMHvj8abMk ilQDjY2UxwRQMrBTIW3kkn2wD06VYiMRVo9mzaOABQBm72jllG4nd1XGAMVK8iKgaMHzAvzMRxTj uhqJ/9b9sLmBUtlneRVMB/e45Vl56j2qpazC6dSwzbnIUZ2njviv47m9bIC0yyK5yDtUYREGcg8d BT4Wt5A+F2OvBaUbM+wzz/8ArqpJ8thvco/ZgJgseNrSb3Axx6mopoZbcSyiNZImPl7mUHYT3oSf LZg7cjR8pftXaRJr/wAKfEEUt3HCtvH9okjlTfDdLGpZYio7HYc5GMHn1r+Lz9qWyPiDxbqs9tp0 WiTach0xFCHZOoxiVGPYuW6evFfb8CSX1upC3T/L/I8apHlzKM2/s/qf/9f+Pq80nUlsF062YzLP Aq3Ksu4qy8khvT/A1jtqxs7WCWY2+q3IP2ZwuTsVDhVZQc8A8Y9D06V8lTaULnlxfvNGVe2VtPfC 5dYraKY5ktlRvlJ9ic0gsrOyjYRJNcR5LZjPAHPGR0NVze9YcZK9iPRXWWCaa/tXgjN4yPFH88gi GMbR3OKo3tlZS3KzWj3wsIMyQLNGTMSeuU6/h+lOT5UWXIVFjfSR+Wd4iEsaSLtLA84x1zU08b50 3Uwixy298LqW3DbTKIjwj98HisrsmUraH//Q/jZDaB4lvlutUe9stbYPcq624a2jHAVc9c+3v+NV hY6i98LSG5s9kMRnSGOUNcyqATyPXHYc18g23uefF3RRtLQzNeW8s6p8puEt58uivnhgOx6/l1pD aGZ0S5jj84MFil28KRxnHSqhubJrluF/olhskhwpkYBt+CAWxyaSxh+X7GCF2bQlw7bVLdMD26Vr BWsiefyJbq2uo2ltIoIboSjM06uHWJsg/Lg8k8/SqpmmtYvsU+nLcI4KyTDMkluCDhgc4HPtXVD4 kLnZ/9H+IPVNM2xytbbTJtyV3hTnNYYYRXYsniRHZVjnlxvPQE7fx9K8mOkjgu0SzpNAx8hXjgA2 OWGPMqeyIhLM2QoAdVxncBzxWw3K7uel6AmtajqFvvjcLeRlxayt5Vmsa5wwJxjp0zk111le2+lw 6hpMljbz3FyQYLszNILNd2Ttwcd+lBXOZCzTWFnqFzOvm3QUJZqifIihsAAE/SorNbO3gKvJHdSa h95kGHg7kMv4/jQVGV0f/9L+Ma4vxpLfY0tluFKebG0mREMnjpzmtVdTtktcyGNpSPMU9Uzjp+Fc UFqc5VfS9Nm0K7tdQltzcahIDb3drII7pZHHzJkc4Azx61D5n9hWsbwp500CKlvPdkjBXGTnoSa1 IeskZM2sTXNw5lQQeedzeX90gnOSO3enzWUUwCx5d8b2dG/LAH+ea2h8KKstincF1b7Iy7Tt39MK cZAGfWqGnC4ia7mjgWJraJiZCRwjfKcDuee39KoTirWP/9P+KNbiC8Nv5cDx3kcTQ3Dl8xXYLZ5X t/n3qaPTLeWWWKQQ2rj/AFn2giOIAdh+XSg5FBLco2sttJLcQK6RwwSGNtp2q5x27kVVtLl3tpYV jEosbh2MbfegZj94dyOBz9PagFBJhaXcYiumuF3XEKtIp6A8HkY4/CoYb5n+zz3Fh5guZTEHAwox 0P17U4q7sHIjRW2E0F6Y4ZY1Q4uE24YgEf1qF9MX7P58TSrJCAP3Iz5gPb8Krl96wSguh//U/iHm tVtyI5lU5HmJxuz7fhUUqPO0G4KqDgykfNgdBW/KuxxuHYlmVoI0cOHZztKYxsA6EUswnvEE1rPi eNcXC7xEqKBjls8fjTtfYrkVrFCIs88ov9yFVCiRGBD+nPfoM1Yk1OzsEzCTIxIVhk4A749TQKD9 0q3is00NzYx+bHcAyOZf3Y6ZIA/oarzCWdmORAwOVReQv0qlBspWuf/V/hptIts4kaSU5P77d90k elaJNlFeMhcxuY9ynbgKxHA/z613KKSscc2tkWG1AwWvlbAkm/cJgMu4Prms+a6hmYyKxB2j90Vy rEdeaaio7GexnpNL9oK7AIyuc5wSfYVNdwTKtsvlAK5yQrYYDPpXRFWQF2C32lFDsVIJA6sntTns kjRZSf3oJZj6r6AUwP/W/hjv5/N8pYofKIOMKeD749eK27KWR49iDymGA8sozhsDNeweec/dWkby 8TBmDkO6D7/XiopYJ4o8IPMPQKuTxWqgraiaurDf9TC3mJukboqnhTViysXnJZ48lV3Fc9BS5NTF qzsMubKRSywx8nnaeGHr1psaziMItuSU5Yjrj3q0ktilH3W2f//X/hb89k+UkK3RSOxqvvuP9U8h Yu2UZz/WvoDxzTs9NXMcs0qopf8AesD98f7PrV97O0+0yK4ee2B4mU4IX19PzoLgtTOu7YaXcIbe Uyqw3lBzgHpzUarDfSl8oM9YycMT9KC5NJFkW5Z47dcrtJJYj7lXPs3kyPuVZolG5fMxnHuKDE// 0P4W50gnvo5GQpAp2kLwcZ5wOmfT6UoW0ilmDs4AciF5I9rsueMgZwa+gPJjLl0I42ADvlAEb7jj h19RVaPbJOVB3ux+VegWmnZNFQl3LbBLXarMQVPzR5zk+9V3kiDeaqN5jdSeQAPStYfCiuZbFiKR nkV14GMHPGKSRmvhBaxqxnaYrGpIHmE9MVQcyTsf/9H+FKNltQVXPncq23j2pqGIHdK7IQc/JjLG vqDzHNdCO8bzGIjdSiDOR/FWYi/aPMVUwxHTnArJwa2M5O7uXbNvswxIFRkHpkmppWE6tn5RjKnp mpaa0YiC1MsbPtXKdDu4AxUwViksg/1h6EnA+gp8suwH/9L+FAxPCoRGImlUb0zg4/wqLZJlmYEh RtHGa+iUWzxxtvAhZs4Xuw6VYlijjIjts5PEjdfrWxUPiRBG4QlHJkwfvjpVqYCQRrGuGVclh/FQ atpbmcwkaRlYFSOitxV2CLnb8uCPmzxVqD6mc9z/0/4Rymyb5VG4H5ZFPb0qyXWKH94VJc8BiM8e 1fYJW0PHEaI+WHAByP4TnFQ7YnWUYyOxYYOarll2AWG3U4VV5PH4VpWAWB5nR9nGwFTyBS5X2Apz SnzmG/dipXDeWgY7g/O0+lFmB//U/hMjgVJ2MmEBOABiurN5DFZCCOMKJE8u4KjJkA5H5V9geOcz KryN+7YlBwoPB96gNtHGpByWduTigCaGLy0Y/wAOduO5qw0sPlxqqsHQEMxPJPtQBqWOnfaLSSd2 AigY4RxtzkevauamVXDMowUfJFA4uzP/1f4SbcuzRptyrNtJA6VsSWKbsxNtjiXcS5+Zj3x+dfY8 r7HmOaWw65Zdscawqznrjg4rOaWQttVfkHUnnHtQk3sTKTeiFaQMN2clT931q3BOdvytx/zzatIx aeopSuMdifNMcRbfgZJ4Qj/9VUZ5Ji+58NhQowckVZJ//9b+E+3cDrHvycc/5/zmrTW5aQvJ5h8s ZT0AHavuDxyeNIrghUGZOu0jgAetONvNDcL+7U5TKk9FP0rRxbE3ZXIskyhLhtjE5AA4p8SFpGVJ PljOW45b/ODU8suwlJN2JpmITKYw3BIHPFNaRmhD7/kzsD7cAmlyvsO6Tsf/1/4a5nUWwiVUMj4D Mox0xWaoZXIY7UUcfWvuuSR411exMEmjmDYyAvc44NaMcsSjy0JDN97AGB7ZpNNbhdIjvvJaJl/j K4JByqj1rHW1jSMZbdnqw5Aq4R6sG0txIxsdihUgHgt0qSNT1VwWDbgCM7a0tbQZ/9D+Fu4gmnfc AGRV6Dvj1qF49jebbl48Jscg/NzwQK/QDxrpEMDMX2RoWLNgbhz9a0bhdgwQSV+XC9iKCXNLYgVp mQqqncTtQDrWlb23lQsLksJCCcE52/SgyM9rTLPtbdG4546VLHaNGyxoRtCZZnIB4oA//9H+FeOc oX8vjD4IYdcHtVxrl5AIY0XDJtYN/Ca/QD58jhWbkRruKDDZ5FRLaSkhcfefdkD7ooAu+UVjYErj OMd+O9VNsiSKsjZH8O48CqjHmYFqOISEx5QbxjI4IzUr6eVdEt8xkL+8JbO/3puD6Af/0v4W5HZn EcbBnVsZxxVyby9hWZWZgvVBgZr9Bs9j58pgKSu3G4jaqnjP1qTzLmOI7eAvDADdihprcCRZ2WJX J5HBLDoarrILifL9R8uSOMClYDRKsq4RMpj5WA6077H5sIlCqjoeB3YdKaTeiLUz/9P+HVLI4JkU cqDtI5b2rOvIUj/eYwDwoxwMV+iKHc8NzfQfHIskJYsc4wMjDnFU4086SNSrY34Jxk1Sik7olu5a uLVQ+9zhs7QMc0SRqV86PO+IYfI6Z4zVEkEsyBAI48tjLc8E+tRlY2VTG21ifmyOtAH/1P4Wmkxh U+ZDwR3qGMOryLIDjrGCOFr9IPnySPyZdkJxnf8AfYbduafLA9qWWNw6FuO+KLERlfRkMwbKyM+4 EYHbaakMDME+fJHJ29qtwaVyzat4VMRaXBCDGD8u6rEUVvCQxVcHkjOSKgD/1f4gLmZSqhGVFXgY AArFvJAxG48AAcLjNfpKV3Y+eur8pLCI5RHHGPm6Ag+metXkRbfe8uZMcBCPlBpyjyj23KaKd8ks wGxuQnTH0pjXTI0g8tZI+iMvG0e9SQ522Ka8HdktuboByKS8Xblk6r1HrVRjdgpq2p//1v4XbIiO KYTqWMpG1CMgYz1q1chbmNUhQRspAJyduK/S5Qtqj55NNaEtqkMIfBbAABz1Y1I1yscvnCMzLgDb /Eo9RUDFeaN5yY0Lpt3D+8DRd3MyR226Ihy3EhOVjH+NNRb2AvLDFJF9oEzHPLKPbrSu1rMoiUli nzLJ3HtStbQD/9f+G1wzM5AYbTgHHpVywhnbKIV2Bt8jkfdHfNfpB85N2RX1K0SNla2fzUIxIGXY yn6elU5D5KoyMCoHzBuMGgyGxzylsMoIY8EdR+FXoIWVvLnyoJzvQ9qA2JDZ+acrIWhXIyy5OKks bMZwsi5Odgb5SxHagD//0P4d3ilWdgQ5YjaEP8NX4LKV4H8xugyqlvwPFfpB85zq2pUuVhtyxbKl V+XAyGPcVSQC4C+SjnB3MpGcH1oM7u9zS/dGMqIf9IA2g9FA78VBCuSQ4PXaufX0oLjLoyGXTpCW ycqeRj+GpLC7aFZrV41Zg2N+OQvvSaurMu6sf//R/iEEURV3UZUdT159KrKrPIQhSMhTl8DP4Cv0 OULK58uKA6skYVc9WI/iqZ5YfKIUCOXdggcK4qAK0EkJilOSH5RU/iz61b0+0jBzOj/Kpck5G4f5 /lQA6eV0lVkcsiH5T0wPSqrTIXffESCct2696C1NpWZ//9L+H6GAC5i8yTMZbgMOnoM1ee3dJGZR 5jyHHPGAK/QD5vnJTfxRgRSW5DFdnAyeOmKw/s0tzIZzHuAfHJ5GKC1JM6K1iVrdlkCBtu0Y+neq cSAN85EeGwpwOfagUtEy6kFtcIoLDe8hXHQ8VdC/YYtiY8xedzHdgeuKCIya3P/T/ikdvtciyyHe m35i/oOKx7uxjE0E8KLKWJyoBzGc8fn14r7+6TsfMNtkUkMlrLD1lZWB8sjPPpirbxKUmubtNmT8 qbdoz6YobS3EVCsU6tvXyiGAjJ/lipUhaAq/ysrnAIOSAPWjmXcCzPKkJUqqZYfIzHgEdj6Vi3rx zKQd7Tl8uM4GPQU7p7Af/9T+H2zeKDA3ttAwAwywrpLTy90Vwy8ryEPzCUD1X0r9APly5e3ds0BS AkD777kCup9PpXOiIzzIY3yX4VS2MUm0tzaG2pfjt7lPKRAvLfvQecenNJNKI5NkSBcEmRsZYt35 9PaspO7KsWo/KYjCjzNpLSNyq1z1wjyTeU8agLkxuDgGp23Eklsf/9X+I2J5YUMMiglRuRu7DtV+ yjhJE08Qk3jbbjPzQtkHOK+1c10PnXFM1b6Qm1KuHVmO3cQQRXMW5ZJJWSQuVJIOMVnd3uVa2hYl d7hA0yyeXECU9W/Cora0RlLx7FcZZRM2Cx5xVc7SsBf0+QqrmWLy5CpTOMYPqParkYnuZLeOKEPM QVeSRgI9qjPWs3JLc0jFp3P/1v4o/I2K6RRltpy7Y+UHNXRDbxIPMZTKQCVHOD6CvrFPueNbW5nX BEsgnUBFjOwqONxPrVy11I6YHVfLAkKscAM+c9R6Ue08iZrS5HeqLk7ozkzv5ryY5Y+pNUz5cbyJ 5JMK4Du/Rs+maOfyMjornW7C10g6LBZLcNOftUepm12NGdoURh8/oc1wipJB5MshaX5/3idNw9c+ 1HOZTVnc/9f+KYvZxIrxlm2rvyxG0nHOfpWNvupJPO8tpo2OFCj5Bnua+s5z5izNZZDao0EK7AQD KM/JmrS3H7vfEcFfvr1waPaeQivc211dr9oOHj3/ADnOZCT39aguNPKw787SF+6wxupKb6mkYXWp zs1xLBAbdB5gDEorcYz1x9amW3lSJBHuhVlDumMspPWk6haXLoj/0P4jLGwmWTdIG8l8qJAMnI9q d9nFncNKzKC/yrx+8avp3UXVnzrimWYp3DEMuWYfLu4xVD7NcPv34kmUnygg2omal1ENRSehFBG8 JIlQ+Yx5ar187Pb+XE52lcMDUSqaFuDSuZMVhEYd7MPL27X3NyCf8/rV6HTTZsJAqCGVdpQnk49q y50Sf//R/iMmVTIIYknDyJtmIBaMjsB+tVP7GkZBticSDnavIX619Apt7Hz5fgsCJY4JVQPwucbQ fqTTr1obIhMBmiyp2nKkfWpVRLY0kopWMb7MlzmdCoYnAjI+77ZrorQymFInVQRgBVPIx60/aaGZ b1M2weLzooNwgBATDqOMc+/rWLNaBoUuoyG3MQFA5T0zS9ozdO+x/9L+I+KzgSGR7iXawQ+Wkaby zH+Qqnp+kztJIZXaZ5F8y2SOMmIAc8ntxXuOb3PHJrIyefcR3CR4K7VO3lCM9KtXF/bwKsBjLuFx 8p6/Wp55GaUbsryTxT25iXckxbPlkZ2jjvVeOxmDxRyKD5x3b84Efb5vSjml3NCV7iJf9ElKxmGQ ooU7g/XmrMLRpNmJdojXMjMMKKG5dQP/0/4j/suHNzIB8zZLJ2FXZvstzshRYiYowFkh6t3yffnm vW5rNpnjmVKI4t0yI7Kg2n3NT29/GEQMgkDtkIxyVxTugEurm0jXejIru2DGeuAO9ZkOsBJGQbVR jjIXAJ9TUqWmoFyXUoAYw8v3/lZgN2K0INUsrWCJAjGQkmSRuvtx+H61nd7lKLZ//9T+I+PVYJLg NMGlg3fOittyuecH6VLdXunBIJbZ2jKSFSH5KqOmT69a9DY85Kysi+dYiS1IIDqF++vzbxWfY6nZ h1uYoY9qgpJBK5XdnuOf84rKb6FxjfcfdalbXC4leIyhsiJXG72wOtS2puZIhGkIkSMHyggywB/o Kzcrbl8iuSQTSxSPhXj2ckY5B9qzL/XpdNIUDzxL94tjdEuc8e/GKFUVyHGzsf/V/iAXxjA1tAGt v3sd2dpK8beOT+VV08WJGl1blFczSny3fjYv0rp9ou5wyjyhba5HA8LHBAkDTEnIcA8jFP1HxtPF fOlmfKsJ8hol+6Pr7f4VKkk9GSRHxNcm3I8z92/Em0YLDuM1lReJAhuADIqhMBQcNKPQ/pWkZ2Vh 2ZfTxPPe2scMSAW9opJjiBHmlufnPc+n0qv/AG9c24/fs29hzgZ2jtwaiU+rNIx0P//W/hh/4SLV Y1kMcriAjYQBtVh9KpSa7dzqVmlfyzjMYJ2uR03Dv+NEpq+pjySsXzr9zJA7XMkjMiKkMhchkC4X B9QAMYp8F3PcyqlvNvCxiVtp5XNZuokDi0rmhqF1dadDtM5aPqgH67h+fWuOkvLm5HnGRpCvIIPS pdRBGN2Fy1y0MV5cRylVHlpJgsD7D/PanrPK4QYYY+UAnlfwrP262L9muh//1/4OzK6zEh3ll3iM Rqd2CeOfStqx0uaUyXF5MYY5G2vbyEr52OmB3rh9tEwnDTUauiXk13ttkmeFmIiba3l8cn5umcDt VwafdiItGkjjlTLsJUY4POOnFJ1l0JUUtUUZrDUEYxizu5HiAldIrWSXIbIBOBjBwfyrdtvCHi95 d0WiXK24iE63bnyoJVb+Fc/xdscVEqy6jdkrss2fws8bauzSrYywGW58iI3p8mAHGfmkGQM9v1qm vwv8fSXd5GulJBFYR7pLh7tPJkIOCEbPJ/n2pe3jsyXKKP/Q/h6g+Efj6aGIw6RK1yW89HEga2aM nAIYZIPU8j/GtZvhB49aa4t7fS4JpbDZJdOt9HLuVuTtVctx06V5axUErHNGaWqHz/CXxPI9sWl0 6xBUtPHJKZEHHRiOQ3HTHetOD4U+INPFu1/HYiMp5wkt7gzI5zgAMB19c9MVlLEwvoae1Wx0b/CL VNQubf7E2mhzbbrppbkeU3ygqVyQueoODVbw78MGj1G8+2wpLEwXaynfEwH3gB2PT86h4lJNIPa6 WOy8Q+ALrUZEl0qSHR/P22cNvZWwXzTt2k8A9cc9zmlb4BafqYsdAjv5mvnAnnmuQts8MpBLJ5i5 JHoMde1YfW+WK/rYl1mtj//R/jz/AOFJQabJ9nn+2CK3RrQeao2TMDjfuI6g9x61etfgV4Y0m6dL q91PUZpLeK7hf7YI4rV3GXjcD7wGRgjFfNPGSt7ph7d7Eet/CLRrGSGfTrSWWGGVJHae8M7RO4+d yvYH05rfu/hn4Ajk0rTrLwvbXM2pQwX81/bzyteSXQGXGAdqqTn5SppfWpPZ6hzt9TpT8LNNSMzC wtre5nUpMs0nyxgDCkk8jHuT9KL7wZJBpNrv0i3mNjBgTW9ss0cis3O7Aw4ye4rJ4hydrhqY1jou hWkksh0CytkFyLmZJISqztjDDaegJ7Ut5pXgq2IbT9At9OtZZS803lLJcvnAb5uvqeaXPU6MR//S /k5n8P6DPO2qaRaxWHmQpAFh+VEEY2gnHUnBYnrknrS6TaiSa3XWLpbjTojI6xbSSp5+UfUhepxw a+S53bXc5zasY7i4gufD9hAEtHu1um22qyXFwxGFXfjIAwMAevSmxXEWh3EJuoJXlsLg5tpcrkE8 /L27/jULfTf+kBLea9pF5HNMmn2qQTR5ktJ8TbGHU46/gKz9B1uUC6m0TTrWRolWFri+g2wQRFly 8ORgkEYwO2elaJT6vQ2totT0W+m0i90+eG6v9PeOJFWYrKsSv5oG5Vz6dD6UWGhveXFla2ASGGF1 hZFGTtIwDjrxxyOKLyvZjP/T/lV8R6bDpjX1ut5bzta6wYpF586RN5yd3PboPp9abb3bWEMbRMim ZSijILbSCDkdvxr5mGtNDtrYfFbKJBqEbMlzEpaAQrgFu3A78de1LdeI9R1KfTDqd3JIbCVpYEl5 UFhggnqQOwOaLXvfoU4Jam/qmvXdxptpHiJYxMRK6BQZgB8uVA69ea4+PV477VZLKJJIDDar5j42 JcE9QPX3+lK2lzGUb7G5pV3cwa5aW95bTvYGN/NMI/dbR93En8Lj3/Kuw8e+PfEGqaA2hWUsdjHN bxWaTLhHRYsAEEDk44471lLlIUXa5//U/k3ayieM3b6iHe3jYyhsOuV65b14rTt9b1LxBp2nWBmS WCzjMdpIEA3DJ5Y98dPwr49vSzOKcXe7Jo7G+SX7K8uyMgK7lcJvxwVHQ8Go7mWCxhWK/mhuUtGM 0u51EpI+8QBzkUBB23PONR1i0j1dZrmwvoorLZLHJFC7ERSEgSEqOAema6TVtYsvEUscVqrWdqxE UMNpI6yzMBysjdTnng9aduptzu9iVLma6lSLSNJtY3srdRch5mhMgXI3YIPzZ6DpW2JtW+0xC8sr iAywj7WIrSWeVlPyjIUE446kdqG0la4OTsf/1f5PNS8I61d6gs+mS31pYaXm91KSRHWKOJlI+bjj B9eldHL4B19beG4mg1i/vMLKrWljJdoCFBDOwGCDxgdfavkPbQgrNnOpSS5mOXwJ8SLi3uINR8J6 tpg2C7ivHhEc0iHPljy8g/N6YBqze/s+eN2jh8SS6JqMz29uMKEkFtyMkM2MBsE4XvTliadO2pPt 4Ws2WU+AnxG1S2tr7TdEnH2u7+xRwtbvtc7QRvI5GM5wqt+hx317+xD8ZtC0lZvFtppjWkFkdcgW 3YmazglK5L9cDgAE4qZ4+lTtFvVuxjUmo++5JI+SvEWgWvha71ey1Rjb32lTfPGMOsisfkYN0II6 YzzXAXc5uJAbZ5TBAm+fEe0DOMf59xXbFtx1Khafmf/W/itivoFMUU0M10ZJtolTAjQf7VdDJLb6 aLeSOaa4uriXyvI8rMcYP3QCPx/xr59rQ5lDlRLPZwW9tLezTMs0qbLlHwYVG4EEH196enlC0Tey urKU8vHO3/8AVXOTKF9UV0WzFrcmG3KxeSU35+WFh3/SnwzSxWNtBJA/mWytJFcSLt8xWP3fpnJ/ GgyDSry5W9lgZlSSaLhicCPnt9cdfap5bfTWjuWgtbdL5A639/br/pc4xgK45+6OB+FZT3NYLQ// 1/42LS+k060sh4ZadYkt1a5e5Yx5fJyEIPTj8K1Lq81H7PdaprMsSwNADM0YDFQcAsSPrivjr2dj nLdvpWh/YLeKKOOWa6jP2hLnDA5J2Mc9BjH41p6PYGS4a1hnecqVXy0AdLcD1Ppj3qZ7G8dkej+D NInF/qMcr2sl3bFrqAOQYY0XIjPXBPPzelf2tf8ABFjwKnhz4R6bpt1NZfabnU4r37TFJmC8t0QS xtuxyR523jua+E4wl/wnez7v8jlryUuRP+Y/oysYliSB0ZWCKFI7Y9vQVqXTq8TfNwOnqK/OoL9D 2Kfw2P/Q/rotY/MUHzTsz95Tjp2p3mfMTBJkx5DEHg9e9fyeegPtpXMgJByTgkj9alnmIkKFcnsc cUAU0mRnZBnKn5SPun2qxkIM9ARg4HNBUdJEL7ZCpVBtHPT5qqzxMqKy42McHFXBa3Li9Wj/0f2s kdHPkn955q4IccN+FRxwLbl33KUjTKwomWB/D/PFfx0/jG9xsV1K0qBC3mIS25htkAOPl+nFSyeb IHjHlicjMYYgBjWorW0GWiKx82K4Vs5ilwcZYdQKlvyqWm0jYwbccc7u3NVHqDXu3Pm3412GrXfg PxEllax3sJ0y5W4+YedarJCyM+3qQBu6Z5Nfxv8A7X3h1rPxfrV5eG6Q28ENrsRw8CBAAhCjlTuJ +96j0r7PgZJY2q3vY8nF3+tQktj/0v5C7+7vLizjg0xZJbsnyjIkggG0jDEnHXGTiuUh0yw0ITRo ZTq0q/aXEjfId2cFSen/ANevjYP3bHka82hMdW0mytJje2Ed9fXCBXkud+LT5hypUjdkGmI2kxx3 ttoyPDFNEtyVwywySMOQM+4qgs9jKttXsljS0vbbyDl1nu4CWlB7ApnHHTiszUNUk+ziOznls8Lg XSYWUY7DII7c5FNu5ajJMv6PNJdQSz3ZfUtUhUyC5uXCyXIxhQW49h+VX7e3fVHmtbkrb4+SdowT JB7r64oWrIe5/9P+LWG11DTJr6O6mjubeBSttcq2bhwDnLLjjpT8aelyt5bC9fUIIFl+0XVr9lmG 7sPmPy9MZx9K+XsloebD4UR/6Tb3AvPOiuGuIw0hyQYh0w5x14rVtZp2nS0jtFup7pvNgWWUqC+O MH+QFBXkU9La9CSW2qTvJqwuZPOhmh8lLdd3yqnfAHHPp1qtefbjI9qAEY5YOi/dHYiqh8SA6HRt Wt/DuiXK/ZjM0YwJVHmSuDkvwc/MxwOMcUk2oy3P2a7ht4rcmDcyuuY2J6rICfQ/pXTBa3A//9T+ HnxRdsJVjiEaOzss7RtwcYxx/npXMmK4M9uEKENIpd3fbuHcA+teP6HmuVjo557rU4Zo1WNQAE+U bQm30rMaVbJY3uJT5SHy8dWbHHA7Y9K6DNyd7o9q0XUd1lYx6jcyx5RY7OZslvLx8oHt1wK3YNDl gaadiCbmTzVbJLBQMA47ZoKU+5BqnnMLaPyg6MSjlTkxADqR71hJpxWe2kivJLaVZmPkoozKoHOS fXJziguMux//1f4z2a3ZZkmgAZyYgWO5mAPB9q5fUh5bNp8bfuTHsiljQg+vp1HvXFBa3OFyb3K9 s15HbWRSW31GQXTQztLGytYuOAwKjHQj369K6bUFW5t4rdWMkyN87Sn917FRj61sk3sEXZmG1i8D BXLyPKNqsOeegrT0i80+ws7ye4y10kot3RhkovsPxFbpWVjYZqMcN26S28gLD+JTnPtj2xWTFNtn aMx9MFw4xHN7fpRYD//W/iVnl8ubagKbjh2QYEWehFXZiYkj+0EXTiPKyqdoBx/F9BQc5gbLfUp/ NgvDbHgFYgNzYA5we3FS3cSxXTmCWUXE4VZJCcNJjqD7HHNNK7sNaPUcbZ9mC4C5y4PG/wCp/Cq7 yygos/mRwp8qLH8yx+4FaqKTHK19DY0ubVLPT9QeCWWKO4RokcjLPnqMnjB44rl9HTXbcTI0s0tt C0lyFlJG0t1AX0qiT//X/iEvdQvNSjsB/osUsLHA8nyw6nn5sck57mtJI557ZZHjQy79jLGR+YFd ip9znH3VrBGpLsWVFyE+6xx61yx8p3eFVISU/vEQ4WU+rfhWiSWiJlpES6UrJ5EDhwMAA+pxmj7F DNIsLOqkLncRgA0GJplbohLD95cRhtwdssYQOpUe+KpySo0cuI9s28bGxhQoGD+NNRb2DY//0P4a VzLvjty7XKOM5GEK4yTn1rMNtfJN+9dn+fneRlfoa9RQ7nnXV7GncRSSqHmkLxQ4BK/ebsAaerQr DsUJx8ylh830zT9mhKSbsjOlmO9HDFZOgXGB17VurcrLYhGh23QbPnscso9B9asoBeQ28TozOlzg D7vEn41UkvpETDjzH/vf88wfWiwH/9H+G20jPmCZoi5A3Ix6D0NaD3IYSCEDMY5fpuPfFe0oto88 z4WXzmZ0VsjjIwMmrU4DJthVVc8sfT6VslbQTaTsc/5Lhtp+VRJhpDyK6+3mi02NZY442uHiKrv5 BH50EzSsZE2orO7SsuZsfNJ05FTLqQWwmSGEI8o2yzMMu/PQelAJrkZ//9L+FqS3Z/LKlfvfPx0q e4VIhGJHTzGH7tF5wPevoDxyGSZh5adSDgITwue9aIkkWAjeFQLjyxxn2xQNOzujGluiWDPuARds eeRVZS/nI8bFC3IZeNtAjYN0VilDzbpzglxycisv7TOGkkdnYvwST1FBE3ZWP//T/hT82WRY0ChU Rt24DDZo1CcMInA3OoCZ9cdzX0B4sHdWK8YmmkUux2gAEHqR2qxLAVzJHGVbPykcCtIRT3KIEiaW QpId0jcFs+lTGMQuVZwy7cDPatErKwDo96PmRSqsPlI4H5VqxRRqFmOfNib92Yxgj0NAH//U/hUu gEmbgbic8e9NFtGxfndIACEHbNfUHjkEw+RQEC4GOmM1UjBVsxnae9AD/KfBkc7mPvkgVaji81Fz 8ijgqTjBoF1GtmLKMeCeQOOajTMilT/eyooGf//V/hHlE0cgaQscDAfPYdqkt2eZwivtiJ+Zn6Cv qDxyx5MO+SIyNll++DgelUEPku8e8sv94HO4VSi2GxcMaMisjgDqQetWo5Ni+WccjAPcYqows9R3 b3K0lrLMznBZlXJxwMCp7G2jnnWOR2Vs7dmOT7VoI//W/huu9MSxlYbopHjwzLvEij24P6Vz93Gs smdijHICnivtYJWueOV/MMa7ACGHBz0oiAkEgYbNp4/2verAsRIzSKpJGeARWhcW3kr5COA7qHO0 c0AZyWsscpZ+Ao5z3pslwd4QZLdMelFgP//X/hQgtbi4Mm1CSvAyQKstshj+ZikyD5kPOe3SvtnB M8cZbzI3BGcZOTxTFljLmORtqBs7scAn3rNwaAtKqGJ1RgQDlWJ70aVb2t1PILy4Nv5Iyvy5aQ9A o/xNKzWgHWXWpW40yTToIYVOQBcDJkwOo9Ow9686yzOyD5iWx05p8jA//9D+FJFlt0KqmXIypzgZ 9KtvM7W0QWJ0lAJn8xsq3pt9P1r7g8crrmQhS+G7MxwB+NJ9niichJGlMoy4JyqH0otYB0losXlM JFw2dxU5z7Goo4pIjucg4JKYOARQBfjO51AdUB5IFV3j5bJVdzYUn71NJt2QH//R/hWCi2wryLIr kE7Ryn0qeW/8xWiLHZt27h1avvlBI8fYIzIqKsS7Mc+YRg4qea8JQMshJRdpUj5jVGc272KEgeYB 1RtyDcN3BPSoYpZt5UKcsuHYcYFUotkRTb0LP2gwxbAAXLfxc5FMcvNGIwSO/lg/LnvxScWtwd09 T//S/hXgjlGyNty453E9K0ZVt4o1j+aQn7zA53H2r9AsfPi36MkduxUbWTeH3dAKzvtPBUKFjI6D luPegBqXBzhfmGMMG/iFOjlPzRBeSeFxkAe1BTk2rDJY9o+UHdnkY4qzCUUIFBVjxK3XP/1qaTew RfKf/9P+HG+Aii8mP5Xxw2PvVipDLJlSMBVyT0z9a/QDwpPW6JIZDA2zIGRjdjkVZubrcI5pVUMB sOwcvj+I/pTSu7EDLaSMHfCx3F/mB5KH6VYlnaUjzPlb7u7saGrOwFuxsTeP5Qk2lec4wMD/AD+l VdRKKRFG671O0lT6f5/SkB//1P4Sn80SpyMZya0fPG3CoFlPVjwWxX6Ck3oj58fDcBF3F9p6YUfz q/HdqgyxVTL8is3AH+cVfs9AGyygMWjljdSoLkccjrVJ2aTLuoMa8L6jtVpKOxWnKLCyBy5X5gBt xxgCr0l0kkDbdwk+6Aeppkn/1f4YYRHAR5kfzFs9ORU28ysVdcKBlH6A+gNfpB8+QrFGW8xiQycY J4qUvJHuAwoB+bI+9mgBmGYFdgJ6j0FNjiljdhhZGkwDxyuPSpcUwLIuZY42tsZOSQpHQ/5AqG3m nhLJLwGOAx5C/Smko7Af/9b+HMXcysq7uQPlkPaljCuyvKDIY2wqE4Qn1r9IPnyqViWRxyMHaRjC mokJWVgpKIRgso+ZfpQA1riQzKjcgdGb7xxQ8XJd2YFxgEdDjtQBGEJYkDKheT0HFL9l85TtDAou 4nFAH//X/hV8qVNoQZy2elavlx+Wski7lI+gBr9IPnnohY4beLLzICSR5WOn41PJ5RcDgK33f8Kq L5WYbGPNCRI8aIWP3gp6CrcLNFgSKoJ4OOlac6sawbe4rTMVIJGA/wAi9zVhDkYkQrnrg8kVk9yk f//Q/hffzmc5DJArfu93fnqavMhniVJHUgcZHev0qLsz523vlKPy7Sddjng8DoTWsZ2dAjfdzu9z Tm09htJ6MhMwlYKMAjgdqesQCMp243fNt6Cs3JLcylHlZDHbgu4j+6nO7GTUMqeXG7MNxJ7jkVcJ JCSb2P/R/hYjfdJg5wfug1fWFoyCZdoHJJPGPev0yUlayPnIK25JNbszK0TblZc8d8UwI2A5BUKf oKybS0ZYyJpMvsXaA3HrV+SLzUVJJDlRlweuKuMrbAKoRIWWKQhhx5YGMfjWZDIqlo95/eDaR3Tt 1qHNJgf/0v4cbaQQqUcl2UkNzlQO2DSmWXyXaPK7Dng7Q1fovOj5yabWhIrTSxJPIYxGw24Eg3HH +znPaqziI7omGQx4x2o50ZtNbimz2xmRWC7T6+9PiCbxHNcbQw3Lu6fT9Kq67iNVJMxiGAqsaIWd mAUvjrzWXNcFWUwkHH93jH40010A/9P+IZWhMInLPLcA9CcA1myT3M0kjJmIIMLHznJ96/R7o+Y5 Xa49QZ4mEpwSc7SPvEelRRstuyuC2WJDLnGBRddxDY7wrL+7G9WOG74Ga0JpVMQMCkBG37mxuY1L mhpN7EEVxI5bO8yMxI4+UCnpbsWWQMApb95x+lS6mhah3P/U/iEkuJIm+zIuYyv3QOOe9UC8i+YC h8xTtJ6AV986iPmeR3IiBHE88RY7Mb13ZJP+zQrjAdlO5vu7h92o9qivZ9i5ZQQNL87DKnecjhva tOZ5Jyx8wQiMYVVHDdsUnVRLjyiSqXEUcKKDgbzn757n2p5jiZHXy080cbyAQelRKsJLWx//1f4g Y7WdpHjL7iBlVHtWja/aCZvtKMjW7CN3ZcZB9O1fbKt2PmHboEVms7vh93lnMe771JI3kYhT5w4I 54Kt70/bGkLWXczQk4SWR3YFXyyZxn8KnS9X5FliVlkP3v44/QioVUp2s0WHiMrCOL7sDbhJnby3 fNUZZr95wLmVAwYQJsYYCjjJxTdQiCW5/9b+JeR/s4lgVFlnaMBiCCHX6/jTWmkaVYwwSKNASwXo Rxtr7T2nkfOuCuXDsmIKfLMMMJQMkY9KWXy/KYTOAiguDJ0yKbqdEZW1sZIUgeZMqlV+aPHOR64p ITJPnbwA5+hHap52CS6scttIS8Ua+a0nBRhnd9KpfYkkIWUPC6PtXHV6qM2I/9f+IyKxjJ2ufmTl F253fWtFWHyj7rINuBX2rqM+bjFNXYy6UGLKYMrfKynofyrPjtpbhkWBHDA/Lt7Y9DUe0exodNZx PJCIm+WRm27+pOOprMuLQqypFeG4ZH3z7Y9g+U/d9/8A69ZSqS2YCzLI43ohRG6qgNUJIXuWjAXZ 5bDdx2Hap52B/9D+JprZnlA3BWdcqr9cD09elW4rZFUMGOUfA4+6RX1Dmz58W8vA5Nq7kSSL1PJA 6ZrLmja3j2WwzgYzyS1Sm29QJFlYIEfcu5clWUg4NOieASArtcJ1XPXFJyktACSXcQSVKg5Kjqor t9CiDWkDCPPnudkn8ZAOCMdaynOSNYSvof/R/jH1tkgaQWylSSQ4RfkbGM5/EVzdqVnJ8yRBlwC+ eYfw617/ADJbM8VSu7EMkKvIsssoffLgt03e5/rU72kBkLyFVDcbwcrjscUuddQle1kjotFggWa5 t7y4szAISLefeT0GRx68Y/Guf1G+0wwyPFKxkExgEBjKM20/eHbHFF09EzHbQSz1CyksSbl5kXf5 KRmPcAf7x54GapG7s3fyywdF4BHQH3q02tiZJtWR/9L+IwXMAnWJ3xFuy4AySvpirMmoRxrKlpLG pA8tM/KuPYV9CfPlZp2VVWSdGJwck7TUkFyTJNuwVhUBzGcqPrRfSxnG9y9HrthZLF9pZo0klEZU AsX+lLPqYlUFJ4nhlc7ASGbHpjtSXmaWKoMUaBzj5TwQvLc9BUVxdLC28ghZepPIFDavqUot7H// 0/4nbO/j8sqzbfLBfd/CQOf8a56TWfOuHZYzJED8hPY+v/1q97nieBZp2N7TtS017xGnAZLZFlnj nwmeeQozyOaoz65apLK8MbIyzt9nUY8oqemTnNQ53Vi4xaepkS6xudvMZUd+mB8qVsRqLS3LzmOT fGJkO8YIbGPr9KUpq1jRruY1zcWpTcCFwwYxdRx04p9vrbiRBegtGVAjlzkoBwOKz5omTg+h/9T+ I6wv3vtSt7SyKGUsXO9giKq8k5JxnHvVzVPFdvpvmgLuuAw+6QY2I65r2FJLZnhKD6nOP4rN7O0v lofOJOR8vl59B7VXudbgZQbZXVvuy7wCMjjK0ueNy3BPQgtb1PuiQKD1HQ5q7HqU9li43gxk4Ksc lvp70udLQjkZkN4jM86tMAI0YkrjIOal/wCEg3RmJJGKSP8AcUfKKOdGsY9Ef//V/h7s7z9zd3N3 cQpGhURxbgZjkEYC9xx1rotP8VzQ6XIybbZLJioltVHmTCTj5voOPpXpuquh5Di1ucXd6x++eS3b iQ7shsEevest9Q3sWUsJCeXc/rU+2QrEkerCEbj5kk4PyyelbNnql7cC4FrBLIxjG5mjOxCTgMW6 DnA/Gj2w0m9EcleahcRXMkUqlJ4X2Ng5ViDyRUn9sSyJ+/kk8wYKc8Nij2yCx//W/hdHiJzEsW9l faAQ3Q+v9aE1D7NG8yITG0hJVBz6k4rs9or6HkqDZImrlYZmExlWZQ8UL8Y/zkcVnRasftDNKxR0 XfjACke1S6ttzRQSGtf/AGiV48nzWUun+0KoieZY/tB+SKJ9krnhBj1NZutbdlWWxejmluJDBbxP IyxiXIXK4p7C7ELXEgmMaKdzIC6rjrnGaj6xBPVhY//X/hRt5L+CJswXCpKQY2kt3BIPRlyOh9el WbG3u9RguZLaK6uVicJKIoHdkb6Y/XpRLEwtueeV4YdbSWa0htbszBzEIDC6gnuCcYFXI/Dfi2a4 SyfRL63uHO6EyJsWZD0de5B9hWMsVT6suMlHRl7RvC3iq6ldoNCu55IrhrUJIBBI7DGSu7Hy89el d7c6d4z0FAYtElS5iYKpVkkA4wwJBwCOnNYvF03omJ1NTnru3+JCakZb/wAJa0v2qBSGS1BSRD91 gBxg4GDWzpngDxz4jmUTeD9VgtbmI+VeToqIjDoDg5GfTHGeaj65CKvfQmVSN7tn/9D+JnTfgH8S 9WsJ7y20ZIDaXbRzWd1qMMVz5fO2UR5yQccYFYN18GvHoUzWGktehGP2hhIy+SBxzlAAM5HWvP8A r1NfaPMliIN2bJrb4O/E02kc9x4buLfT7h3WDVHkU2aMvBVnz68Z9fyrWtPgJ8R7+e2gbTYVZIUu 5ngm87zYmP3lHH61Dx8N4vQXt4dzY0r4A+P72e6wtrFp9grTXkk7fZ3jQZHG4gE+wJPoDXTWv7MG tLouq3+o6rFBd3hH9kRR27Tb0PRjjlOMdc59utRUzOMbciuX7dW902PD/wCzL4sSxjig8R2Xk3bZ fTTp0j3t1Iox8oA9zjrzVy9/ZI8SXNxZqPGOjafBLD5lxLcwSSTxHsrpjKt6rj05rJ5rr8LFGs72 aP/R/kAvf2etPs9Ou7Ox1W81bU4WMTXZh+z2swXq0adRjB6gcVzmlfs6Qf2hbyXniWZLJoHe5t4d OTULsSjO1FXKgAnHJPrwK+dWZSad0cjqvZGvffAe1htTaJdu8t5OYUW5h+z3sAIGBs6DPPXJ611N p+zTpunadILnVZItWj2SNptqVe6KdAXkB4Dc8c4qZY1paLUl1pJWG3nwR8Nrc2UE807XkgJvIL19 0VnFgHMZHLlueoHJ712Pg79liw8Q63bvo2gavqlzqMxig07RrN5Y4wqMyszDdtUAZY7cn1rKeNnY zdacVdaC6z8K9F0C61zw74p8NXVpqemzR2wsonNtc7UYbpfLKkgn6ZGCOtV3+DfhNtOtn0nw/ZLd NI1xfXskzy3Yjyfkx93IwM5Gfekq9VvcSrzavFn/0v5SZPhH4MtNSW7tLPTtL0m1thLG9zaeasso TLiTsNzevGP1uR+AdGvpbCFrfTLG0S6aT7VFYRy7QwIA28Z5AwD718upzekjylXqSfvD/wDhFLSx 8zS3jtb+xinMySyWyrvIJxyBkAjHQ9qhutNs1tGtZ9N063smJEJW1UyxM3fcPm9OCad33NFUcnYz FA8PzXVhZx211DeW6i4S4hAzx8oXjtzXc2Mt3NpMdvqEEUcK24UQgB0IyTjGPpTUeZ3ZDmYOrXt3 dQ2Fvp9itjZ2Uhgn80/u7s54ZV+n+ea031GxIk07TtIt71Ustt7c3Vv5f2V3UcoO53HrnA4q3BdS ntqf/9P+UGbQ9ctoA1v5MUgXDokp84xnuw7Z9KktNKu7OY30BMd1JtE0w43heikV8xdJWOBWSL/i KS3k/wBMkgWCNIUM620ZO9hhWYjnk9eKrXup6Td6PElmpmEUTQ+dN0iOCCdg7qfWpduoK3Ud4d0I TaRc7bs3yWkQuJbkLsMceVBDD6nFJdhLGKKKzgghilYlDuwhJ65NKcot2KbjqWdSS6uPDumXUc8E d3Z3DpsjU4k53BScdOevtWfFPqdu1tPHGsbxyh/NiJDH1Absay91RsyG0nyn/9T+VGe71vVZ5mv9 RlW0MQCrO7XBJAJwPTJrJktGijinku7mFpZxHGo4jPbJ9BXyCSWiPObSaRqX1pLCYLP7dFd74w0s 8Um5uez47j2rNt/tenzKVumtAsu9rpP9ZCg5Ix71UIp3LjLlOj1/+2L5InsdQS5t5IfnikGJLvgY 2Ed+Olaela34o0LSLDRBHA0TK12L/wA8SS4b7sRBzwMfdPvRyXVmbRk1qjkZI73W7mV9RkjjeRij sc+WCpwDnHXpVa50KJrS7t3lLyRMVt5YzuRm78/yrSyWhi5t6H//1f5K7K2v7K2uLVrh1MkWzcgy iMBw3PXtVe2WfSbvyNRkluNPZPOklQK8km4HK4A4xxXyjjuckG9jofD/AIi1/wAOXJvdGs4byMyB 7UXkRuF3fwOR7ZPena+2o6jf3Gt+JNdt726u2Ese2FbJRwB5IQcfKKzSSldrVAlJO5jG50qSZkSC WKOGNGuJkG6JGPGSR0yf511GoXFhpNtbJMIFlOCunM3l3VyOu1E6scf/AK6059bGsXZlSXw9Le2E 88UF0+szTNdWmkiEfuoVAKb+6nPGD6Vc0ubx3NeWUUemag7XEIt/NCrBJasBsXleeAPqal1Ei+bW x//W/lPtvC+uRvqJGj3t1PHOVkE0LA3EnALCRuD/AL2ccVpD4c+JZdUeb7PdQwpBH5kboxLMRu2x ADDYB+YjjPGetfI/WI9zN1Ejch8F+KEiVxazA2lyWCxoySiM8Zdce/8AKrUXwe8V3lkdTbTdSuba a4LWSKioVBOCqkYx3ODk460niIJXexLrxitTZk/Z9+ICutnLo2oWc9xDGLQSyMlzMsgBBjJUr0PG D+Ndvdfs5a9o32S81D+z7JLbdFJDFqaXd652cvMo6Dk9CDntWE8dSjZLW/Y55YyCfKS6D8BPFkX2 yW7n1G/tbq6BsYLbT/tD22efmMZbg8cnHSo9R+FsOnO9xq7z2kVmpEFrewp5DyZx85b5gO/4Vn9Z jLRF+3XJc//X/nd8E/ASDxNa3Mb3moyzCRnMOj6LHNp0hk+5F5h6cHk5J5PGOnveg/se7tRtU1KS 70+zfTgbdRAYbRAv3nVkAAk6ce3FfnVTEyT5Yo5OZSjtqbS/syeChEiRWVw82n3bt9qnu5TZ37kl WkKkZyMYwDj8qs/8Mn+CoIbyOTS7KW8v4RLbT2sSL9kZjltxIJBxkYHc5rJ4mt0MlJp2RLq/7PVm l1YxQaHBbF9KgtXMMCz/AGlVTy1+VR1IXPODzWRbfAfwzoy6nNJo6pd20LG3hFmv2mJifmkYYzyA R681Mq9ZKyZqpK2u51OjfDXQ7myskh0uB9SZ1igms7OBoPLxjEqCLf5meCS3NdFfeAfCNlBb3EkE mj6ikj2+p3ltZIYHQbQmI8AqQQc445qvbVXpczlPe5//0Pyo07wfHNqD3WmM14Z/9HvHuLSF7eZM 8GRGBXHyj3zXaaj4bsPDtlcCVo5rq2vI5YLnTbtRpiRuudvlBQcjBBA4GDx6/m2rsmecpe5rscrJ f+GdWur+G51O+vNSiaOVLK8AWEQ4HIJOW59OBXV3eu6R9hvdFllnnguoI5LW5MflbpBgMsqZIIAy ASSeAa0lGTjqc0rNqxhQ6zY+G4bW6soZF1GznMlp5cwiilDKQUI685OTnoa+4/hB8Zvhx4osb3wz faNf634s1DQobdvDFtp5u4o4IgVdTJyAGJXjBzjpinUoc6T7HLmUZTy+pFb/AOR+R/8AwUE+Bfh+ w1GTxV4M8N23g6OdI47+wvLV2htY435iEZ5UlnGCB0YV+VXiSC0sUIgvDA9xGI7qFIjDtC8fQg46 fWvoqMVHDQXVaM04em6mDU5u/b7j/9H+LKCCISxCSRVsUbzpsLlp8dF46Z9a1y0s88UtpEIbR2Jg 3ZkAUfwg9yARzXgyVoomfwlq7uTbkW13FCLS6AVmkILuR1Vf8OtWDCk4k+yjZGvELSc446mocU9z EvSOiaT9nsrS2eS3VnuHlkKicsc8/wD1qybnUobyUwLazLBHYomHbLs4+9tx2znA9Kxas7ESS+Zt nT0XT/ttkRJeWkCyS20zCMjJ28+3P4E0y58lWEaWgtLsBbiVoo8pOT1Dnoc/nzWM9y7W0P/S/jkh jkuIobi5jEdlLdGMRImxQARu46/nV+7aV9mmxeVJaXgMe6QZto8DI8z2r4qe5zNpaMuWemXKx6e9 yqNdTMbZ/swJDID8u30Jx371DY3OtLqIt7CO5srKG9awvjMBBHPngsX9B1H06U6vwG0XaJ7j4Jgs 7fxBeac0bLZhFs4bx0a5W4U5Z2DYwQME81/d7/wSb8OaXofwb8ICWW3ubGXS7e80y8SEyRRQsCoB PUMWCsR2296/N+NKklSpUujbPO5nPFU4dE7/AJn7fKiEKVKBVAwyYVWAHBwKm2GaPfj92Dt6dSK+ Ii9bH0cVaJ//0/69EeLy0hXAKDk4wKrPaqsW+Bgh35dO5yeTX8nnoDrbzI3O/awP3fUfWkvCN2zh jjk9xQBS2iPLRfTGOBVmB0O/fludpDcD60DSb0Q/7ONpVHxnkeuKiktJII0k3eZjo2fTtit4LSxU Nz//1P2fimMcrtdIqgjK7h8y+4pkt9ELndC+9Wj+ZtpBz6V/HTVpm/LrcbIHIe+U+XLIojLEjcQC cH05qdLeI/YZ7qcECQC4UZYMDxg8etamUlaTLUv2WMJ9mihULwoRAuzHTGPwqndzS3ebCExrcPH5 nmOeI1DDLY+naiD95of2Gzyv4oabdXvhjxFZWc32Rv8AhHLkzTlS3mNGAwMeO+Afav40f2+tN1CD xp4t0/TTd3lzqWnWiXs1xILVIcEOqgDqAFYlh179K+y4MnyY6Ue54+K/jU+x/9X+OjVYzoJgjsbq 5ks47USXLoxubiOQjJUDGSP5VlyQpfxCa7MuordQ/vYw3kTlTngOMEHHevjIbHB7P3zJ0i00+yRj PdyGyjkaaOGaQyyqi4/djv8AnV261zT/AC1e1V4ZVlJjBXAQA5BPp+NWPld7GEZl1C4zwPOY4ZSF 3uckknvn0rQNnDDcaZp9xI+pvd3GF03yyiqBhmAfoMgfpQJxa3FtJYYJbycJLZQmX7NbW07f7RGF PGT0/KtzS7qHT5dTubsDy4LPzVYKZJEIBOCg654prcwkrM//1v4u47uXyYr7UIhBFeTnyVuP3TS8 /dCnnuKqaldywx3uofY76TIitAobzIggPB9sDGOnSvlzzYfCihJem7SOGGN0VV3P8uTL9fpWjJp9 9vsdQiuoItPtrcySKWYXxmBQRqgH3f4ySfQDvQUdG1rfa3cPrc86W1tbWwWZ5gRK8irgbs+oX865 XULiS7vtFn057xrss0F4I4t9pjPykkZ4I9fwq4LW4HV30V3aQQXF5aCFJQFVYxiKTtuz0BPWp9bj sdNI0+JGmaaBZzIjiWJAyhh8y8dx3rrirIqMbo//1/4ddVsljvbgrKZ4/JEssckewIfY98VgJMZW CmMFEOUb0ryoLqebKN0bkMtrDiWYGNlwV2N8xPTge9bHhnTNG1681kX84gt4bX7TZwEgb5QygoT7 5LcelbJX2MmrOx3snhrTpJ9KMWq3W23UXDwRBJIQR91Cck44Hoea7iJNb1XV5JoXsLezS3ZrsOPK WKJVOQg6Z9O+a2SSVhHL+RrIN1qkcdu+iWr/AHnu1kusE4AljHzL36dcV0lvpV5q8NnJb2lmJC2y 28+UQySswxtGcY7dTUuCexcN9D//0P4wbizvIrm6imuI4bi3mMYIbzYgQcHnOKlNlbqYhPcBQU/f 5I5OeDk9qwitbI8805RYWE0ljbLCPPCTOkJDqzbR8xYdWrkri/kSJ5RGzILgiWRgUZBk4AHTNbKK jsFiSO8trvT3kuGkhBlCRttJkwTgH2OTWdd24jmkhUtNAWwZShjZsgdRTNIXRrRXFnBDHDCCWjiC YClgT9azmSO4vLfzHMU6ZfaeFZfT8a2UUlYt7H//0f4oxZySzSSSlWgQ/LH90HHvVmWxtb//AEW7 lltbZ4jHK0S5kUYwcZIq1G6ucPNIx7+w0eILJY+bYJZQiCORBueVV6s5OeeO1RXEtneyQysDC0MK hJIVP7/HQtnv9MVUY21Y+dl2RRFD/wAezyQOm53wfl7b8VmTXyIMrEiLEMBW+fzvqO30FaJXdh8/ YmXXr69sns1dfsQ+eGJTgQt0LL74/pVrRnbe4+0FUZRG5P3z68VrGKiJzZ//0v4u/EOm6JbBJP7Q ga9ManyrRDIoyBjMnTOOo9c1x5vY4blHgDRumNsgJBBHf+tegcLldWIbuSW4nV3dnRvmlfruJ965 +7j3Ts8cssKxKQECj96ff2raMUtRNvqWFtZXt4J1eRXMm0kR7hIR1C+h6VLeXosp/La1QzOUChz9 zOP6VMopK6MlPuWdS1S6kaSFvJt2VBCr2yKnAXHbufXrWZayiKIRt80kbZVn5D/59K0tYjmZ/9P+ Ie0nDq8rRwQZXZKdoRj7598VjXdk6x3M0MrygvuRXcF1FeweOVY5pooNoXmQbW3DIwKYsoYxAquV bJJGd3tRYFpsLPbySst00ZSJXAEu3CKasRTJvA3qygADuGP1rVQ7mylcuX8EFxIxiCr5SBipcF29 eKqQqASOCrDBU8niqSS2K8j/1P4fBHIibI3WZUXc4BweT0/DNVzGgnZVy6kDCrywPuK+gPMc7OyM 94JZZvL5jVTkMO9XblvKjQEbXKYk5+bjuKZlsJpNvBdMFnlbyfMwy4/eOBz16Vn3iubhExIkZkKq knyuoB9K0UU9S5u7M8sm/YA67n2qT0x71swjKmFFWXA+4SAT+NPkiQf/1f4aHY2vMwUMeFRfmx9a oSKss4KuD8u7dyMccivpJRtqjxySRPKEcwIaQNtZGXgD1zVWZ/MlLLkJjGOlZgXF057iIcYUKSjd yarPbGFWR32+Wu4ttwVPTAoAhikWFg/yyIfvbxTpjGU8yPgu/CH+lBlO9z//1v4UTIoCIcAjqo60 0mKTKtwynjHavooJN6ngxdiRjtCOOdowSOM4qZL7ePLk5A6KBWxcHdtlZZzBKNy5BODgfMB9aWby VJ+dmGfl4+Y0Fkizh4xuYiRcBFxnj/Iq+L63jtz5mRLwFCD7x75oA//X/hVhCtI7upCucqzdAauw /NMrNEGeEY/dnAkGe/5/pX1B44l7EhTznAjV2wEByaxTDJk7QQm7hsdaAJHilVo8ggKM4HORVm5M DIihXR0+YAjAPbmgSMqTzickZjPyjnJq/bFdu1sHb/31QM//0P4SrxD5ixorONm5hjpzUsQj8vbJ KY+cqoHDHpzX1ygkeOWBD8z5OQEyHHINV444gS52hs8Z71QAuGVlCqfnznvRt8pvnBYHHzqentQB qRypFbzA4jLoCjvw+R2H4VQSQnDRfLIpz5vce4oA/9H+FrznSNyXMjty7Mc5NVoy5RmwDu4HqtfZ Rk46HjjDb+apLZLZxke1TCOFQEMZ80cFumBWwDYYp45GmC7k3YUHkH8KuyNIsrtJHlto2bfup6g0 AQ3N0ZIlRVVSpy5I+Y+2ayGiKYkIO9mzn0oA/9L+FW2lwgwSH+vAqK4tJPMEgkV/NXK7XyeuPmHb pX3B45XEEsbc5GOvoamlVZhHEv7sqDub1NAFdw8ax7hnY2dy9OOKtQyzMo27UGfvEYoAfJOpiOSV cHHHGaz1DFiy7if4mHUdqA32P//T/hSzIUXBztPAP3hT1nIceaWKqMFRwRX3B45Nm33nC7w4GR/G v0FKyxMjtb43KMEEcr7GgzlJp2Q2OynkT52UjqqZwRTCXDKjxkgcADoB9aCeaRZRIiDjCup+Wq08 DzMhwVaM5JHQ1pT7Fc5//9T+Fk27MuRglD06moIrd3mJeP5c464Br9APCc7qxamkkLGNht4xkdKc IY3KLHywXkk45HWtOaPYnVlsxYQsSRx8x9fpURSBGiyp2rwSvc+9WmnsaQTW4ksKb/kB2joxxk1I baO1UzTIw6OcdSD0xUykloKcW3dH/9X+Hq5uNPitohaxSTzSQlLp5Y9qxEngLz6Y59awlUsdoHyx /N16V+hSab0PAs9i4sqyQmI4bBygcdPWs2KIPI0bFY2X7qnoanbcGmtxhjPmqSAqg7cj+I1pxBRH NKFP7vhyoy1F09gaa3KJDSSnYzbQM5Ixu9v8+lIyyxrvOAGOCv8AEuKuMuXQEr6I/9b+F+GQyKWD HevAY80JcoN8YbLN3A4r9Be54jhoOuIVZIzHggDDn+IEVTkyQACFUfeB+9npTi+VkqDJYCIgFVf3 jtkseCakutvHnlkAkCfuxn8TSbu7ktNOxfLSWsRaNjhlAwD8zVkzQM5M0jMW6qBwRSFa2h//1/4T GWZ1yAcJyxHUVahCGcMxDYjwA/rX6Cnys+fLrW8eA4UjJxz0BqKVV3CKTnacq/UKavnGk3sTxwxP Hs+QyA4Ow4BHrVWVTE6qrZVRyo520+dGqikrEbRyQ5kwTu4w3G2mhjC4dznuAOlHOhezR//Q/heF wkjAlfmPtxSXJlhMRIUrJ054Ffoqmup4DVnYgUPuyCGKnlc8Va+15lCPHggADHQ0c6ETSbgN0O0P kbgx4Iz/APrp8a7pQAxEpGOP4R60c6AnuoYrQYtmM7ZBeR+Wz36VR+9zIc55AH+falz9wP/R/hik nKphcNk4Cjqgq2nlpCG80lQMuWHIPpX6Lzo8FRbITIHPP4Z71WYGNml3Ep3Uc9Kl1CnDsSJJG/lu I264O4YrQu1Q2wMRyyfNs78DmpdXzIaa3M6yuV3iaaJvL6GNhtDdQM1Ok7JHIiYCls5I6j0FHtPM Vj//0v4Zk81m3k7Qh6Y+9VxZ45kZcYGMbQOOtfoHtfM+fa01JYmtyrxhlcgbSuPu/wD6qhW3EjPu U/IdyNnrihViFTXUoXLlXVQzje23eoyxpzQzMvyldu7aS331qvalJJbEbweSy8GUqRzgqDWg6Apv JPmKA21eVIFQ6oz/0/4bSXkXzCoKDgg9FqsGJbk/KThFA6V9+q1j58hVA0rYYOyn5NwwAafGzkMr MNynHrRKtoBKIHLKX+UHjdnBFSTRNGnkI+UfDbs4P0NZ+1u9CZcvUt2EiQSwpP8ALDv/AHjKMtim 33luznzM7pDgdPl7U41ug0lHY//U/hyjtoIoy4ZWk6csPl+lVpF3hU3d8t2zX3zrXR8+XI1SKNRv 244G7jFDpNIFjYjyuTtB6Hjn9KzdWw0r6IFjWCSJIkeSRhlt3Coalumikk3TJslACuVON+KFUuU4 NFIeZ8/lriIHAYDLfiapCLdIxL+X/dO3OTUyq62FKPKf/9X+Ge1ChjmTzF6Nkc1sxwRhR5wbY4Pl J0V/r+dfbOo1ofPmS7gHyAAvln7meRUZYvMigBVH3nbtR7WSYWT3L6tEsgR2LxDkr03cdKzZWhkk YsdhRshcHA9BWiqNisuxchczIY920KvQcZFVkMaYTrHnH0p87DlXY//W/h3M7RlfKRHCcqdvSrlu VkCzNGRMW5UDcPY4r7rnkfPhdybGCnaJFY/dGAue9VLmFYXRS29yu9iO2e1HNIVkhkJtFLB3K5YA bRwK1lt7dkMrOqxhdqlzkv7AVjKcth2sNSONQHiwyyEhV71G9z9mgMIjAOTl/wCJumAfpU8zsB// 1/4e7ctMGkL7H7k9wKtXEls8fkHd5rEF5sbQfavr5S1SufPk9rb2VqkUjTF1dsMFXcyY6kis+5lt 5WuHDooL7EXo31x/nrSugKbzQQFI45VdgvOT8xJzzU0dxLCgdsM0hwA3KgCmmnsYyvfUtrdQBXmd tpj+7joO3Sr8N7beSzIvnFyA+eABWcmlck//0P4kLS7s/tZQypGWBMZY43Y5xTpLhbp5gJ2Z2fO0 jg+pzX1ilGyPmLMulNOW32LNMLwuG3RkeSoHUHvkmqUskDs32hSsT8B4ztZCO9PnjewjKuLoM4ji y8X3TIOhx606C1gZiWm+ULuPbkehqYySAmtb2E3AgHzxKcuc7SwFIZrTzTGysvzfKQeRVqcRpPdH /9H+ImfULX7Qrxljsj2ORxn65qYzwGBiW4cZAVstX13PE+ZTl0KNnfJC+yZyTn5OPm+lSXmqROiq ECsr5OTnI9KXtIis+xWOvwhsNCqsYvILAZXHrj/PWrWi3ge5ZIohJEyF3kyNsQXPNDqRQ+V3sWb/ AFq3spo8R7rheSyH5cHtn1rFuNS851uI3VN4JaFhyp7HNEKkdg5JH//S/hrt9TuGmYl2wybFYDhD 60o1CVJQjOZWxy69G9zX10qsVofNqDsKdadJVz8yocEE44q4viSCEJ5SlHQknDZDZ/lWTrItKw1P ETbCEZ8hiUxwQT702316dWffIhYjaMACQDvWLrK5SText2etNIEhbaVzy2MGpLjVNNtHWOSU/a5H /wBVGw4UdzUusUoPqf/T/iIvL9p3SSKVALVNyPjkexqg3iRisRyfkYo6hdu8+te868TwuRkMGqGa 6G8nzZTiMbdxb2FdBdW8tpa+eXZApB5OT83/AOukqyTFyM5S/wDENys8dpdSM0h5WWVQGwO1XbW6 ijgnupZo1RACFLfvJM+g/CpdaPQfIynJqDSSJ9hR5nLBY40Bbfmtmx1++0q6MqyywThDH5Lg7cHI PynoawnWT0TNEklY/9T+Im+8TPOkKRKiuuXuZSWMjAj6461yQ1V5ZpGhbLl9sqA4LfhXo+2S6njl yTUz5qQR7pTgL5KEllOeuKS81i6tTtdzGiAeZv4IH40vbx7gMj1UTwCGOZ2KnzOHy4z7+nWsxrqR ZGEzMG3bjubk+9CxEb7k8qvcvzy3P2R/KEiqAN5JwOe59qqWs7gGNpBvxxtPf/JqliYrS4nDsf/V /hJvbprGRGN0jzn7savl1P0rThSa9tI3jDmWSEzxlVJUhTtPPQc5Fel9aXc8RU0UJby4gkhEheeY qQsaqZGIXqOO4q9DeT2t0yy2+oRp5HmyRm0kU4IzyMdPeksSu5Sp67DJLi51eRIbC3nuJIxuW3SI mU577fWls7DVpUBi0+8LNcNAqrCwcsv3hj2qHioo0VOxYudfvrCFba/t5LOSH5YxNYOjygcAD5et Mim1jWY0hi0rVCz/ADDbp0pHtk4x/wDrqXio9GV7NH//1v4YrvSPE+mWDPd6PrKRbtpjFhJ5hB6H gdOfXvVaHTvEPlRquha35MsR8gR6dKd554Jxxj3roeNjbR6HlWinuRwaT4rvbiKGy8M61cTshYA2 bq7beCMH6VtzeGPGLIhXwrrUby/IEnsJI1d1GSFfG09D3rGWYUo6SkvvNFyLqLb/AAx+ImryQR2X hjU0a4Q7Hu7aSJFK/eHCk8Vqv8NviXBY20S6FqV+yAmRLa0fbbIpwzuxAwozxmspZrhb8vtF95PP C2rRq2PwT+KuowpPb+FLmZ7mYpAhu40eRV/j2feHQ9RVnVvgH8W9JT7PdeEL+K/GxjbJMk4VWGQc qc9653nOEUuXnM5Sp73X3n//1/4vdM/Z3+KY88/2U1veNbgRxzs8CgkZ5Yjr7e1OT9mz4rXk91av o3nyQW6zbYWM05LEDHljk9eMetcf9t4T+f8AA8R1qUXuYEf7O/xcsWQz+C9ZaISNlhbkEgZ7DOMY 5z0roj+zN8WZ9NkvrXQ4pHuFElhbpKzlezeYQpH6gg9ah53ho6cxMsVT2RJF+yp8V4JkGoW0mnS3 GnLewLPbhIi/9wEtuIOCM45/Stlv2V/izqcdrDY6dFKWtTLMG81H3jj5cqAB9SelZyz7D7K5KxEX sRP+xR8cbNBLf6RCEd1aFFl3PMh+8DjO0j3FRj9kD4txKbpYtJsUg+YRT3wlMpzjZ2JYA5wPSs1n lHz+40jiI3tY/9D+Qlf2MPiFei3gfxD4bsbiS2WYymO4uWB4Z1YKu1CBkAFufWt/W/2SNWsNMWzs 9Ye4maENcmLTpdskmcEBACxB4+bI/wAfBqZ6vswduv8Awx4/totGFD+xN8StQhmurO402KzSIKst vLltwXc5dZCCpAPKnBq1pf7EnjDUdFnu7jxNothcW7t5aXL+XPMq4H+rBJ554PPtSedae7B3+4n2 lPqPi/Yp8TTrbRW/iFr2aV1SFLPTZAS7cBTuQbsnpg17J4b/AGQfFmn2V/pQ1DULBb6zSNVu7JIh cMhIk87GAQMng4OO3PEvNpS0cPxBVqaVhkn7A2jQWlreX/i+4n1e5jkiNq9rssYuTgiUMzemMjHP TvXM6d+xB4cYG41LxBrSzwAn7NKQsXynAEZXG7Pqa0/tWvqrIf1hdD//0f5U5f2NfBst3C0N4weN ds8d1JcFLxv4T1OCPYgfXgV0Q/Yl8FrZfZbnVtTZ5Wa7d7WaUJPk8xK2cLgcDI59a8H+063ZHje3 fYqXH7G3giCCUxXV2VIEVtbXJfzoAP4vMDEfjz9BV/S/2UPCdgrG20+3uN0gjmkuLxrmTAH8O5T1 6+ntR/aNZrl0KjVvubtn+y78PrSHULG50aK8NufNttRl8wQQfxYC4G4HoTVpP2bfA9zBbQ/2PpRG 7Y9pDAwS5GcqME9/w/GpeLrX+Kw3VSPS5/2dPAOl6bDFcaHotjFHaPM8N0rTx7sY2lVI5I9/rXMW PwN+FtpHYTp4a09be3Z5nktUNrvU5yMHI9+v4Vh7WrrabI9rd2P/0v53rLwN4UjgittI0PTLt0mI mvb6BblkV87UIxtwPXGa2PD3g7w9pst1LcaHpEcs5EYgGnxm1UKepXHfH496+RtJto8T2rWxT1v4 T+GNWuf7U0jTrG2lMozaxR+XHDIoBd0A4wxxgdq1JPgP4lnfSho3g641HUA6SxSWVj5sjq7K2ZpD kKAOQD/WonFpc0nsQ5y1kum56D4p+C2qfDeCG513TdDtrnUASyRSQT6pkgElkA4X0KkgY5xkV4zf aLojG9gk0q1e2v4xHcC4gDbz6g9snsOOadKN0pR2MlU5ldMwlsbBp2iuLGB5bRBBa3ABWS3VBhVj I4wMV1bW8V5FHc3nkzzPEInVFCgqnyruxjJGOp5rVQuxp36n/9P+dK38N2++eZo12yybVZm2tn0x nn61XGk3Wh3TywRQtayEFWgkEnJ6hwO2fWvmHS0Pm5Qb6iR6W8sjyX1tb3cbB2RCMxJvznAGAPoO OKkTT4mhMSIts5G0OvBI7A+3tU8qWli6dLzNd9Dt4tG+yxwLLPcKyzzN9x9wGBjHbH61zVro93Z2 N0l3OZB5gW3GdxiXkfL9PeomkldHXGlZGis86XlmsFuTDaQAperLiQOCTyvUEdiKqXuqHzpDIXne V/3rEElfX6ms7GkVyrU//9T+ca6jsYYpJZm8uLy927Z83I44+tc7BJYWEfnx6YEu5HaSab+NlGcP t/yea+Osjhi0tzPlS3vrlb6eYws677Zp0P71uw9emfyqNbS4kvW1w3ENtKjCO7Z+ZbmNc4BPTHU0 wlNGwhsLmZ5ri1XMa8NjcZOOoNey/CT9o/xl8CNL8RWnhmx0YHXMyabq2orIb7TJjlQuQcFGDZ2N wNvbJzE6cKicZGM3GUHFnknj3xPr3xB8VyeKPFWoWV9ql5CPtGrR2y29zK7nc6sV4Kj5cDtisi3v zbj7LYRy2rI5Nxe8jzQwxgHGPX860T1M4JU1yx2P/9X+ZpdJOr3EVqYpmhWYScEbJyQc/LyCPqMV 33hqw8KeEbC4W80/+1rtvNVLe6Hm2sIkyd+31U5A9sd+a+Vu4u54ylzaI4K80sJPJqy3G6xa33NZ j5imMksB16dqy7vzpYohplurG5UCKVo8oncZHbNZc0ktDptYhvNNuLhfLu7CGS8XYY7jyxDEiqMY Ax7fpUc0BtpTbXV0I55YFdIUw30A+vTj0ohVewuVdjLFuu63knhuHtUvBE6FDyQwzj0/+vWisEE+ pObZXMLkrIg+VoFB6N+Qq3UbHJReh//W/l9n0iLV4RaW+pSrBFOwF7bybZZnXOIsjr0wfSn+R9nR 7O9Jht5BshuVG9jIMjB9OnXPr6V8a562ZxqKcbnI6poutuxhkmFra3D+U9v5oK3Chjsce5yDg+oq fQfCF55moWt1aBbdI0MMxkyZ2OcjaPbrn1pOatoKMU9zu9L06WxttSt7PTLhfPtvsaCeFhZHbySD jpkY5/XFYKeDdT1KJGbT9xDl/wBw/A28cCo5nvcHG0bkM3gvxgrWtrHZXFtYi5DS29zE2blGBGU2 g8jrjvU934S16xmt7SDSb+ZLjIhYQfulbGSHbPyj61m5RXUy5UnzH//X/lwi8J+Iby5isIrOW3vG cPJaq63GMdQSuevbHJrrL74ea29tELjTzHEqZ/euEcEfeyp5wB3r4Z1VHRs8uXK3uVdN+Fuuzia5 tbJlinlRIZreF7gXEYYBiWUE/LluK7a4+AWuTS2v2S2vJpZJMzebGyyCLGQ/kjOOeMZPWhYmEXaT Gmtooguv2f8Ax3NcQJFO8NnHJ+7t0s3N0SRjGAc/kKuWPwH8XWXm2N5pNw8ckyvD9pla0nmdTyAh G5cY74HNafWKdty0/s3O/vP2bdeFp5U8UFveJArx20U0kjMj4O4OFKnA5yDj61kWn7NeuabBZw6j cwwabHKxuL+4aSQtvyyr8qHJGenB4q44iBHPrax//9D8EtF/Zh1XX2uZ4bxV/s1RPNbKBBNexeyy gA8dMYJ9DW1J+zfoMl29toY1G+1G5IM32yCKCWMIOhClgQDwMYr5CVSHLc8t1ZwV0jA074B2lxPd 2+rjUYDEDEFtvMhkGW43BSCQR3616B4Z/ZQgbdc32lrpOiTOwXUtbkLgLEu+Rog7B24HQDvye9Zx rJvliccsXNaJF/TPhF4G0u/Tdo39p2LXAMlxbt9nfaDjdkZHvz0/Wtq6+Gvhu2muI9G8Kq8t3thg v7q0bUrm1Vm4JmK7QMcEgAgHrXHVqS5tG7GM8ViOjNaw+FHhlLKeRLe+sNemAiaQWayRXIUEYRl2 4GckZBwOOaks/hNHDqNvMYIls4I/MuLsP5VxHggsdhGCRzjB6gVi6stWzSOJrW1ep//R/NKL4Z+E biGwk+1SXunL5kqX9zpCtLEznLgx7huwVHBOB271qW3hLwjHayaP/wAIzJqZhnFzBrV5EIVyW6lF 7YGMA4FfmLk+h837SpJ7le6+E3w7urOSS7k1Ow1Ga6LW0thIZNPuNo3eTJyCg6jIJ6/nu6F4Rinu bjStI06PULWd4Rv8vdNCsa4JKgAKgOOcemTWkHeI+ZtJM6dPh5468W3/AJsdlOdF8PQPbm9mYRGJ lZRtjY8HgjjOantPg7LaaxNDe2F5brGEkMl6hnjuRIOijOFHv78ZrK8L8oo0nzczR6jrPhq+8Ead qGlw22k6da3TQAww4kSCQEFSO4+ueD+dcRq3w91HXr1NU12y0e/s47WOeMaoEniucNtCiLBDHGT8 1VzJxTiz0VrBR6dj/9LwjSrXRdJsv+JZbaNbXEO2NrLS7CGxaIuuBtjUDPA69eahsRBNqxsra787 V408w2OoIIfILA5X58Bq/L0uiOKLe0SzqD26+HGvJvswjtJZIVWYrGiMvzuFz2JPJHr71iadeeDt ZtbO4aCe2lhz/aM1lIJ4QgHB+uQePSm09kDT5kmecXPxC+GNtqdqJPGF7Z/aJfLsnj0uSaUHOAJA pLJ16kAe9WD4w8M2urz3ej3sOv3tnhjb39hLEmpg5BDMR2yTya0nT5FdmUua/uI4T4j/ABT1uxuL C+0HwdZabaajqMMMMkLNG6NGjFgxXghiM4xj5R758ybxlqviC61OTWGVFRg00ePLjjyByB3HvVRU eRO+pzU4VIx95ts//9P8ltTur7StNuNQ0qexv7a1RXkaG/UvD5h43x9fl/8AZa4z/hMNVk05Le+t 53kJJF+baULeA8cnlcDtgV+b6KSVzy405Sp36i6XEupXf2i3tb19VhCReQtm/mOGIVQeOn+Br3DT Php4kumuV1aT7HC1qt3Y7LF7lphwCiSKSmTnIHt0q6k1GJzSjLmUerOls/2ZtR8Upo82la9Pb3Nw ZmSPXreVLeR8lRGhyCG4JA4xjBFfQ/wa/Zb+KPw61iHVdOjsl1+4zYwSrfRLbeUwJZ5JHbduYnGM HAGO/GUsS5p0qe6Ry4z2s8JUhFbGX+09+ynrGqeE9V134j+JtGj1DTbSbVHS31tktJlcBjHLvUYI 2rtYkruPbrX87/xW8M+F21OWw0XWl1aGzuBbNcRIiPwCXSQc52kbc8Z617GWYmdejyz6GXCsK0MJ UpVej0uf/9T+OO70i206ZY2aQwzYFvGse5Vx97J/D9KqXKTRPIsN3ttm2hFMIRUx1CkjqTXhP4EZ S5ramnttZ7iyiuoUvIYyCgn4BbaQCSMdCfWpfLW2tZpXRUikdo4trb1BXg4PX061Bm720OdjsI7i eX7Pc3MzXG23XyyZCrZywYdMdck9hWy9pb2etT2lqXu47S3jebzRlEYqCwB+uffisZr3jKSl1M2R IPtdxcWsFyt20oguFOWWaMAMoQexPXHP4VcuL+C1vVivG8qeSDzSj8sijA5HbrWM0aRvbU//1f49 RPboEg82GW0kjE8c0bZjG8A9exrIS1aK4MdtdSLGXMzI/wA6Enpj0wf518ZK11c4ZX5rHV2l7cRQ M888aNEMiRB5ZjVR1A9eO1XrW0bV5prS3kkFjLb+czuDFM7YyTkH/wCvzSmrp/13NpO1M9i8MyXd na6dZQtJBIdQtbdJAA5MTTxq8ZYj+JSw/Gv7/wD/AIJpeD28O/Bjw1Yu++CXTbdojB+/t4YfLSSF QBwo+Y8e9fmXGru6K83+R5tGS/tOFPq7/hb/AIJ+tcMQSKKFeFA+8Rg4qfcse6EybUI5GcflXxUN z6uKsrH/1v66o1JcbRiMcFh1OKkkmCEhQB8pAJr+Tz0DKjukZpEjcvMDgsfug1LIzsQ+SrfxBjwa cVqBYWaIDy9rZA3M2Mg4qOWWMLnGA/HFVNW1Kh8SC3udqyK6nldqnuPeozJhSm8gdQCeK2hui1dc zP/X/ZqZvttxBEqEIzABjxuJ65pL2B7ecIltG0GMLKkvzEjr8uP5Gv47lF8x0JEGpxLNbRRwmVZk kR8FfkAByf5VJbX0qJNbtaRSFcCNiTvUngnHT88itbMxl8TGPBDDdR3H21miigb7Tbhg6uSQRj3G Onv7Ut/qNiM/ZtPkT93tlcXO5m4wP4QR+dKC99ibSptHF+IJLg+FNYjWK6EX2KQNLGTKY4ypWTcT 2IOOTX8hf/BTbQLXT/EurWVpeXkrW+p2zw3+lSgRFpo3zFvJ+bAPlsvYtnjg19RwzL2eZU49/wDM 8vGK8YSXRo//0P5CptLGm2ELhwztMUUM4dyu3ow/Hj6VyMZlhm83yAkcb4VAeB718NF3ijm5Xz28 iklq9vdJem3jkRixhjuIw8EvPPX0qO2t9H1OFbX7FHFdG4f7TLK4QTAcqBk4xwfetecYy70+2s/M FwIpNNmmR7e0UfcdQcZPYA85/wAKk0i8mM8wmFvDDsMYhdBJcSBWwjLJ2yOcVotURNaXIb23hunM cjZjil89U6qrZ4P14H5VhSTXp1K/e0l8o29tG6pc/LDcjgMFPQt3x7U1ozlnuf/R/i8v7F9ae3vJ bm6jeLHMxEysf4uO3fGO1V52hUXUM8k8iFfLiwdsbgZw2OuelfLrU82Gxy91a3C21tJDqkltdEmV lQBLd0U/cJPJ6DP1r0DR71ItNMtzCXZoS8IjXfHcMBxtP17+1NWvqOTsjNsdR1S/vbSx1FlttNvI SL6cp+4iPb5RyT2rU2adZaYlppFxIGtNSlkuJvKyZlIChATyB1PHrXRBK6SJg29zK1ea91WztIZ3 dLe2k3HbOUZh90ZHce1SizkjtY3jIMZXAJbORXXBK1zWPNtE/9L+JHxHZojNBHcLJM6qyr0JDDOD 9D/KsC8sjoEU8F19luppI1xNFJ5qQllDYBBxkfjXnnnPRXMRGSRVkmZmCnIVew/+tT4dSghMcVsJ oBcyeW0kfMj54JH+fStoKyMD0/w9psOmHURZpPeTzJHdJdNIYyXOAVwSRxzmu61DWbZYJoLGdmZI wLoAZjkGASpYcA5HT2q0rgQaQokjkFvtW61cIzWxk8xY3X5UwueD/P8AGt2C+t59OtLDXEuYpVne 0u5LKAq6MDhHDjoenPGPXmlYunuf/9P+MzULeLSLo2haSaNjuguJlJecZ6k+vrVR7Se9Zkb/AI9t hMzsnyEAZwT/ACFZQWp55BGlvLeW0TxCCGFPnlRiHJB44Pf/AAHFZF3a3Mkc5ihupYROwjwhOW54 PatSoxuRad566O1158EV2boq2lXIZXeNCNsnTaPTAOahkXWTLd6neSs1pdhRFEibLWNlH3VPsPXp QaRi1uUJNRuY1SWJUUthGSD54+nJ+vHNX/OkkMMxjtp3uG/eSTS7WjCjjGOnPr6Vtr0G9mf/1P4m Zr+2solhmZ5ZpCH8xWzFEc9h6Cqd1qbMF2Seexwd3oK0im4WPPK11LcbImYhbWVSyKcFGYHB/L0q pa6jDayg3CGZCpyFO3PHFVFWVmBdjv7goTEsjCdTCwY5XHqB7VUijRWYSKHBO5ywyvFbRi1LUB8U ll5rKAIYGPyiNThTz29zmo7e4bzG+z4wrYlUnoPUGtBN2R//1f4cZs+cBPJI6lt/XnrVyDyZ2Kyq 3lnguv3lHtXrqKR5kpaaD7u1ljy0JZYQuVAbJesua3lQKzs/7xN+WHIqrPoZuTejJ1VobfzY9wWM 7mkz0JxgViSSG4nLzqcseWJyWoaa3EVnMyDZsJRm/dt64rb0pXlEqTxxIoiIjml4AbsQafI7XFdX sf/W/hjurmTzTAZUZWwrOo2qcf0qnvumMhLHauAMN8uBwCK9xQ7njl77VG0Xk+WWKLkufvZ9qW1j a7kVLaIhUBeZ2421XIrWAl1SZYDb2Vu80xc7brdHhVz2xk/5xVe4tY7QQzcsoxiJeA3rzQmloyof EV3kdrjzUTZLKOVA52joD9KtR+bas0hIZmGQsnzZqlqrmx//1/4aj57AtD8jkck/cA+lTC6bZ5MJ Vb0SZMy/eIwAQfavoDyHuyxJcKiwrC6yuQRI+MhCOwqnNcRXcgBIieIBGB4De4rWC93UcY31expx 3ENrEEWBWZ22bguP1rJvZI3G55M3O7YqkZ2D61ZpJK2pmyKMET8MnKYHWoILiUMY0jYux++Ow6UG J//Q/hTZmOY8EnO5/QVUechgEHIOAQMV9O9jxyaKeR9qTNkA9FFSSKEWST5mUdB3rJRbAmsrm6jK kTGND8+GONuKfLdfbJZGuWLkn7wGA3uaTTTszOUneyK89qvk74XBVThs1BEVcRjGXUndnoBSIbb3 P//R/hNMeX2odrHnzAM0sNnLvPONrfO7D71fSQTvc+fLrQsWKqNykYIA5B9agigeyuEkmh8yEHJ9 fT9K0Ki+UjmJMjZVljLbo2xg/SmKFQh2bdz909RVwWtyvaeROxjQ8AHdypx8341ChjWVXkIIDdMZ FJxd9jRaq5//0v4XrgKwDQbVQ8srcZ+lVoLt42kRFBGeM88V9TZ9Dxm0ty/bGK4ZkmQsBzG2SNnr ipZIAJG2nCDGAaLMFJMr3RGC0Bzg7drY3fWs9wztG2Bub5ZC5wq0kr6IZN9ikhty42yxM2FcNnaa zljO5kXIZT1rRU+4H//T/haslDTp5pbCnDFRwfr7VDdQGSaZrdQ0CvtC5AYeuB6V9geOSRRyxxMr BsN8q5HIqiYZFJJ4Gdq5ppXAuxQyW7rvQMWHXqOahud0beVuTdI24qvOz/CkBXKzXD7M5CdyMAU7 zBGGjGCO4HU0Af/U/hJdnVSzfIO2at2jeamCh2p8zBDh5QOwr7OCizxyO0unaR0mVoVdjtjcAFfT moTO6zsMhl+6G69K1A07KTDgkBxnofu8U68vVZiEjKMpweOGoAovcxJGd0QJc53A4K1UllLAMDuQ cY7CiwH/1f4SEDBAVzg84xkip1lCqDs6cMwOOe1fcHjjnYyKoU5K/MeetUXEu8ufujpjpQBoW1nL co8gRjAgG8/wjNJnyiIiMop6jkmgCWe1eZgUjVFAG3JALfhSFUsy5kBErIBsU5A96BJWVj//1v4U kuVCkqi+ZIcMWHK4qVgFGXHA5z3r7uML9TxyKRE2rLCTuHOR1FXbRI0wVzuYfMT3NUoLqc5BJPOL hkQMFIw3HCipPNAidUUs/Tcw6VkBWCzQgMy5DHqeKvtO32b5U5xgc8mtKfUD/9f+FNTKV8wEgk7D 2OKe00yqUVSD696/QD58sGUQxLFMV+bq7cEVTcgjERYY6c43U7DSb0RYjvXMQV8/Kcc/ypLacyTY ckKW2+gWt0rKxrFNblma2+zu5FwWdjgZPyn0qtJJcOcyFimAmN3BxUyjco//0P4ahFJ9nCq2FPK4 GM1CXU7gVCeWoQHP36/Q3Cx4bT5ynIrKyyKMj1ptvEsrPLKGL55I4C1FugTRekUSfLz5a/dI4yaV 3FtB5YLGRiG3jGPxpJJaIhu4yJ2kchYwwA3FlGKSZgXQRKGYDa2f4aYK62P/0f4XHjKKChDSE8j7 qiqixyqzOyiP5sAHv7ivv20tzxeZWuX/ADIljAjzvHDsw6mmeS1wwBDAg5LAZApR1QoNu5FOqKwk ct8jbFxwGPrQrgu44LOMknvVEz3LVu8jzKqkDy0JAP8AFgdqSWRcfMf3hOePugUrrZEH/9L+F2zV VDkuGZsjngA9qrFHSbdKAOe3Svvk7yseFTWpdw8jJFG7kPg4Y4Rafc25iCbpF8xc5gP3sDvVGiuk NAJtw6LJbTBt3TmRfY1DEWQrkhllb5m7igZZmdTlGYFV5DdTj0qtJDCyCUOdpfCJ1OB1zRvsB//T /hYlSKLHL4bhSPWiSaKRUSQ8KMFu9foB4Er31J7ePKsFwQfunHJpihRIB1Ktjj+GgRJJLGjkYJxg 57U+OZd28FgWGD9KACaZIlCIcHaOoyfxqt5uAWI+btzx9aAP/9T+FR54Y9pQl3b7+eAv0q1HJbyx qJGICn73av0A8SnsXH8nYEyuR9zHBI9aI0hSQb54xGrZyO5pXSLIJryBZBtYMOmeiikkuMIskbgy DgKOc+9ZS5ehE1dCNfRywJHLFGpGQShwWPvUa3yQgqQpwPlHelpYmKdz/9X+GCXUIn8sRfISMsxH BqA3axSbQQS3U9q+3ujwpXsky9Ld2SPb+XlJNuLgE53NnqPwxUq3KYdg2AzY5+9j2pc0SCo15FJK qHCqhyOME06W7tNwbcRx8xzwT9Kd13C19hWvYVKyv5gTGAh+UN7ii31CIyMWJaMKccZz7VEqiWiH Z9j/1v4T5NTmZjGWCoDwoAAHPep49Rt98f8ADIBiR2IEY+lfY+18zwLPYsTapZAwpGI/9oBvnc+9 NF/H5pbytq9lBpyqJqwrEjakpb5kPlqMbiKSK8iMrOGLRgYOeg96lVUrpBZPchfUVRwzqGj34ABw cVBd38c2DESrKcAeoqFUWgJdEf/X/hRS8YqrLwy/KVz6Vaed1kR5FH3cjtzX2PtVax4Kg2VH1N55 VVhvwcnHCgCtj+3YFRWZF+UgFWbB49KylVSNIx5SrPrau+62QjAADtxz7VDd6ostttzmQHLsfWqj Wii7PsVLTWZ7cuMZSRcOrfdNPOsGWN0VEB3f6zpx6UnVi2JxbVmj/9D+EVdSKMyQHBx82eTW1Lr1 7cohuSJRHCIofl8sJtGAeK+sdWO54jpmVNqe1mkZPmIwSD0pBqaBGkDHOMhccmj2yZPs30KX9ru5 LfMu304p39qLsJ3h2P3gfvH6VarxSsHIyxbalI2XjDrFt8s7h16VO14qRqquC7nPX0p/WIB7Nn// 0f4WY9RMUYLfcx07mrsOptNFm3UpJ0ZgScnPGK+ueIjrY8P2fmEa3ro9xcs7gN80jfxGsibWnEhj YYMXABIyR2qfrCvoHsyGTU45Y1wGDq2eBjFLLqP7pXSTAU7X54BHUe1ZPER6B7MadYlh2AO+D8y8 khPU/wAqtw6nNeRLhi8cZOZByB+NZvEra4/Zqx//0v4YI5poc8jYyBgeoI/zmqMutrGzSI0ZcEx4 chlOPSveeIR4fs/Mv2Vze6pGTACU+5mIZKn2p1xpk9ou+53KzqSmT196j60l1D2fmc3E1xO80myQ pAQpkVDtyegB/CuisBqV4kiCzuHgVQBIsLu0Y6ZbA45B6+lZ/XEupLjbS5Db22qSRXypaXNx5LER jySrXGDg7AfvY9s0yztdemEwh0693W8ipcWzRmKVM8AhGwT+GayljFqkxWV9T//T/h1tvD2tXepR W0ek3ysqbvtb2z+QD1K7gOMe9dTq2h/2baMbaO9m1V1CwwR2jFZWUfOPUV3/AFzseDLl+yczFp3i qWXbBo9+A6CVibCUmTP3kXA+99arXGieP5L+OAeFdaW1BIFw+nyrAflyQWxgH2zmpeNhH4nYhygu ol7Y63a2+2bTNQt0ilVGaSykjVmc4GDjnpUSeHvGc9wlkfD+usgJkS1TTpfNlHGWVcdOnJ4p/XUl q/6RLnDqb1x4Q8XQ7YdM8PXV1emNZirjYyKTgoy9Qw961o/hn48eIzXGg3kD5RG3sAdzDlR7ilLM KUPikgU4Lqf/1P4nrr4Y+NYoXW10C+vZzniPYq8e5asf/hXvxKt5LVf+EO1ZobhTlo0DvCRyVI9e mOa6nmlBK/OvvR857SHcii+G/wASb2YrB4P1mKSMk7p41hIx0PWrCfCH4vSGU3PgzV1iyo+27f8A RYtxwpkPUA8YOMc1LzbD/wA6+9FKULXuaM3wM+LQt4Ll/DUbRzSGCMpd5cFcZyNue/bNXrb4CfFF T5smmm1toYfPe3gkLXMgxxwQBya5pZ5hEr8/5i9pT7m1N8D/AIg3OmFrfQ5Z7iJF2/aP9Hl+bsQe 4FXG/Zb+KhsZbkGyCoqSbZAS8CvjGQDnuMCsp8RYSk7c135f1+RpF03of//V/jisP2T/AIvgXVxN bWklnZRRO7xLl7nzehRA24/8BBxnnFRH9mL4nG4urf8As4Wc8KhrdpEcQTA9yTyMDrjPPTNcb4kw uur+48a8UrE5/ZX+KVxHJNb2elmOCIGVLieWCTdwCT8mNvPHepNO/ZB8cXp8mFpVughaTaDdJM3U 7RgbVHbOT7VzviShd2v9xLlBaXOytP2RPG1naRQz6dL56IXma6spTJIO8i7QMKB0z+QrlX/ZR8Wx RSyvdebulkeGO1sJUlkUHhWZxjjpxWT4jpXu0/u/4I+aPdHr8P7AvxXtdIg8S32o6XpOi3tkstjp N7MYPEFyNq4mRSu3Y2cgk5I7YxXLyfsd+Ipo3uL/AM+LCi2N7ComETA5Hzr1znOMCofEULNxTuQq 8LtLof/W/k4f9iPxdNaLdaff6iLN4dys9rmSXYcOQfQenXirs37E3ieTR4vKneS584yRXjWoWWMg YYBM428/xA181LiSWicH958/9YiX/D/7FHjLT7eK/hMnia9gRi9tax4vLRWYKXZAuAPc5HPavWrP 9jzV7Yxy6rYOLhlyoubhHE6n+BY1B5HOc461jV4irONqSs/PX+n/AFqNVoyPMtY/Ycv9W1ma6hj1 JZusVsVItrUDvsxuHUZzxUumfsI68okkubi9lRnNoymF4rds/wAXKemen5Vn/rJXiuVwu/X/AIBT qo7nw/8AsNXcEyWFgJUjQgtcTYWZiOWUEjn0GDmsDV/2KdTvZo7ky3TILprZILcKt3tPRiByQMda xXEGKv70dPuJdTzP/9f+Z2D9gexn0ZLe3vddn1GGY3Fy+5UtoYjjIeUgNnPG0ggZ4NR23/BPa10/ UEvLoXmmwSlJGuHke5BHUfJyOcZxxxXw6z7GtWUV+P8AmeB7TzO90r9hjwzcXTX11qmqqIS9vDJD pv2RkfqH8vGSrcinL+wZ4Zvlle6jv77UdWb7GhuAIbC0UMNhK4JOe5G3FNZ1jWtl+P8AmL2ltbg/ /BP3wgq/bpr9rK7sWFlJZ6dFFLAUXP7zbkFzn69BzVmy/wCCffh02txc2lz9oQPiGfUoVjuGLnBD R7jtAHQdOKp5vjHG2iYe2Oi0z/gn/wCD9Tk1GMfab64s7eGO3DyNp1pMgI3tOjMcbc/KFJzVxv2A /AFrplrENPs47i31R7l0E0lwLrIAzkYzj0J5/Sl/aePe0vwQnioxXvI//9D8Kof2IfhlHJ5cGk2s bQoVNw1pGkj7h84AIyfYZrcsP2HvAE1lKAIIJ+DbafdxixtbyAN8wEvK5BHRsA4r4dY7HXu5s+c/ tCKWkSS3/Y1+GOki4u5/CFk0lwxW2kS78x7cqcOUcKBz6YxVxv2XPAktisB8Pxi/RtsV6MqXhznY 4wSMjjjjpxSeKxbd3UZKzKVrpGq/7KPwugsvKg8KaDo11EwvtPvbWNnvS7bVdJJM5wQCRxwfqc9F p3wA+H2mtctc+FtF1VLSAmx8mGSIRSyYy8hzuY8nIz16UlXrt2lNsxlmVR6Jley/Zw8EzJdX99pd iJztENt/Z8cg68sHZSAyjBHFaqfAXwLLb2thHolnBPFIxn1GVCeCeDsTaMgfhx0FVzzejlcyePqP S5//0fyVvvgf4JtQkTaa2o2sWFMc7AQKc8vGuMrn3JIz1pbb4PeCWKyHwpo8aWsbm0hjjdQZWxtk lOfmIx+navh2ny25j4v61PuXZPhj4bltpYH8NaCZ3VIjPBbCxmhUMNzI6YOffv8AjU154B0lZYtI s8w2Wnypc2kUUUcwZiMOplIyQfmBzn+tYypra5DrVGtWxW+HmmC4l3WkaCBg/khtrRE9fLPXnJ/W orPwJ4dgTGl6bLFchnjuLoneLlGPMci42kD0rKUL7C55N2OhtvAPheK3V10HS2llia3W6jgEUlmc cuRnBz9Dz6YrGg8KRapMhtraOxltQI4544VjWQR8ZLfxE49c0nTTL52f/9L8s7HwRotxNfDWIJHn mJdpiPMBkB4LITgjr09agt/BUFje3csMvnRzkLahIvswiHHJIOcjHGPSvzzkSs1ufHwSla46TwzH HM8Ny0j3C5aKQymUDI54zg5zVvQ/Dsdk0UcNtaRoWZPmVYlXPPA/CrjB7pG6jE39XNtqttJp09tp 97JbxCF5bixhmvIgp3BRIVLKOOMEdK88TRzNJLaIxAkxCkO8iIAeg/z0raMPd2NYK1zPm8PTRefD vY26t0kyMY746VaHg60gtoXleNjJcKEg8rLrxy5PT0FKMOVlSvbQ/9P8iDaJplxcRC2DNKhgYyJu 69SK1rLT7+O2jWeGO3YN50ZRdrhTymDjOMY/OviYr3rM+ZUmjOn025nlujLiQzEsS7hN/OcnJrGl s7RUKKibwNrKqgBscdvp1rTliROTWprabdXDRxW5RPslnOs8MTKDFG6HK49Dmqt1HqWoz3bySuI5 587YiQwyc4/n781pGnEy5ne5g3ipbXs0MInCxYWaOck7TjkZP40XdnM5gHluYtglDAgqmccYrTkR qnsf/9T8VjZwtFNGtoyTiX77qRuAA5Ht/hW/ZxGLTv3qLuGdvoa+VUEfNRm9inHpxvNNuJJ44I5C 20MVy6KSQP8APrWdb21vot7dQxJDqSXEH2ZJQW2RHht6qQCCORmhUr7Gp02iS6bHY6hFdxrdNI4D 2k8e6Mqvzblx3zkfjWXrsekNdm6062WztmRNsKAhVcqAwGeeuacqaWganE6vb3VwgEcjyjduFu7/ ACkenPFZl5pF5daaiXQS2hkcDyoZRuIUg4Ptxio5Gtgtd2P/1fwusLBdPLQKsEVo2JiY+TI2O/HX BxViaG2uGLpIGR12kKcbe3WvkLPqfPmPax3en3ypCCbfl2O7eDxXff8ACyPGsVm8Gl6xqWknzdjm 0nMBZUyoORzyKHFNWZhzNJx6M821ufUZbufVtYvbuaS7Pn3F1e3LytOem5ixrEvpVdPmKxRHbsLD cCexH17U4OzsJaKyKn2WJxcC3g+03UqCOHaOVbjn/PrUWm2T5SAbjcAksp+Uk9xit4zSC7SP/9b+ dzV9M1Q3nmSNJHbLHtCRgqI27s3v0rWsrYRJEPtKGGKLdMlwN7S5HOTnjqf/AK1fNucWtT5R1H0L h0+GS18m0nAnkLyOgkH7tOMFRnOPvZ/D3rkYNP1IW01y9zBdJbyEJNFIuwYJwCc4z0rO63ZrTrPY 3p9UitrS0MlxAFMixN+9BGSOcAH2qpPfabGYxLeW2y4Yhf3wY/iATj8cVnOUbWudUcRpZlNxHYPZ awttPNpd5Obd3hV5EGzOcouT29O/0rQitrGW5u7ryLyVGTzlt4NMneK2HqWC8Zz3NZcy7lrELqf/ 1/515LCG9uVH2bU3jVt+VsJikgA5TGytq50mK4W18jSdXuZZE8m2aHRrjBbIGwHb82OK+KdaC6nl RrQl1LF38HPHF/YJqyeH7iVIJxG9qg/02IHgSeWQCB6+lYl98N/GsqrpcPgbXryS+T7OILG2N2r9 AQZFJAJ+vel7eFrmcq9Jq6Z0q/s8/HI6fbaqPhl4n0/Sbe38tJJLLZbtEnDFsc54IHvU1z+zv8b/ ABNpcJ8L+Bbj7RbkSzWtwgmmaPPJdVIwenU8fWoWKp23Mp1YKm5xlsbVh+y/8adTuZtIPwo8QIbG NZTqf2fOnybsAmVhkIAeOpOa6G4/ZR+KhuINPg0fSbdzDtvYdS1JrS2g3Y2FXaMD+9ndjnFS8dSi 7K7ZjHF0uXRn/9D8PE/Y++NayRwT31gsasWLadaS3duMHhEuE3I2cDOOa9G0r9gf45S6dBJa6fI/ 2y5IvbyLQ57lIc9FBMgJ6jJIGM9K+DljqSjc+WqY2nRI9D/Yg+MVzrcGkX0WmWc8blbmOW3nt49p 4V3ZhkdvlA/GvW7r/gntr1lo8N5P4zhutXsZ3t59B0fTyttCTnb5cgjfzMY5Ax/OsZ45uK9ktfMX 9pwTfKi5Y/8ABNfxj4l0cXP/AAmuvyXDWgN3H/YUMcGmDOCjtwRt7n+lNi/4J4CCWyuPEHiW0aDS iIILu30rNzG6jbuk+f5ieo4wDUrGSu1ykvMUrOKNmw/YQ+Go1AvH4i1W+kAeWT7Qs8EAcg7n2KxB 7/KAKu3v7EvwK0/S7+K+sNe17UJovLa9h1Oeyt88MmYwwc46YzyD071Ht8Q9b/18xPH1ZRsmkf/R +DvCv7I/gDVxDpsHhfUZobOP909nZi1uLUgYCxbg2SffkkVctv2OPhtYwawZfD/iK7S1n+1Wlsl/ bm/35w6yqycgn+6oA71+bxqVXq2z5eOPnaxoX/7LngJ7S9bwtod1BqD2qy2lpqV4s8N1LHgGMPgA MRnHTp9BXj+s/s7Q2qpB4g8N6ho7XbpHFH5aSiCQjcM7c7xhTg8AdzQ5VOa6ZpHMYxptzet/vPZP hR+zP4O8ZWltaRyXGiQvDcQS3urQCaNXhcxgjhdm51OAcccc5rLf9jt7TxqukXd1cxaFYmZdRk0X TUuZJFjJ2hJN23LnBDDoCeO1DqTUvZjljJyTsb+u/AbwZ4Xs/wCz9H8FeILq+t3jt4r3Vb64uvtD TOCZZVceWFAJGUxt75xXtOnfs0+GNX8JatBYeD/Da61DF5P+iCQm1ZtqowIc5fPfdz364oqfCp+f 6o5HWrNKXN1P/9L5ui+A2hxRf8ItqHw0sLfxPasPM1S4t2s5VYkDe3IByDlc54wcV3dn+zR8AdIj W28W+BNJ8Ta6X8tp59antCiuN3yRq2CByM4/+v8Anrg501yaHyjVSUbqVmem+E/2dPhp4clTWfC/ hLQfDU+mwyzwwSXZv7qW2aEt80Up24fOFKDkkHHeuesvC2jeFdd1R7Wz0V5ra286LU54VGpwLOo3 Qg+gDY49TSp4d25m9SsPKbi23drTseZa/wDD3wlJ4ni146vp1hp0N0uqCKx053u45FVWZHdlC7Mj sWGB19JDoHw48TxXeq3mrTTXDK3lyRaTEJ7tgdp2svI6Y7dvStVRtc7VXfLGPU5k6R4V0Q2jwWk8 0YuPKVb6cOyoe2TyD+JxgV73YWXgHTvBTa1JqHhHTbV9ssMkkyavd/am+UJJG2SMNkHPAAHXNJU+ WxjWxDjrbqf/0/lD4l+J7zQ7t7B9EbVrjVz5Ud5ptjvt5kQKyKqqg8vLEgnA4HscYvgDRvGl7qt1 Pc+AdGsYV0Mz2t1Hqq3dtHcM3RmOMuFyMcY44PNfCJe5Zs8SMoOkmnr0Rl6T41ubLxJPoWu+DNI1 n7Ewiiv9D0yK3vIJHYbFPAU/NgZ6mup+LOrweJV0nTb3w2NK1WG5RNX+zXRtL+9gdAu1lBKD5T97 ng/hWcFytr+tzidSLbOMPgG90C2WztdtppE4EsOmSXSalcMG+YSPcLwR2A/Su4svGfhi08OQ+H/E cSaRf6PI7R3FraC5F1HklQWyMEkn2/nWdaDqPmk/M2bg5qUymFPi1ILvwy8GgwhxbRveQCEMRgGX aOckYOcHiuuHhay8M3NtJ4lJ1PUVIneOaDzLW7iUZaVdjHcPukDkevpWTXQtRjKLkloj/9T5Avb7 SPFOvX8VhFfWtlZzeY2l6TpUtxcFQAu7Yq4G7GcDJ/ppXsOgiBIdEk1GHVzG0L6Hqtq1hfTgDIKo wB5HbFfmMly6nhQjHsb+h/C17qz8+LRb2+fYJygEnl2zMOhReB1P3vSqXw6+Dl7Jrtz4h06PXZ72 2upYfsYEiW0A3/cEajkdD83r7cZxqXvFC5YXS6n1f4X+CXie6kh/tI30WkX8ssrWlowSVjHGXTer FdhZsLk8+3Fc74s+Dfxe1LTZr3Q/Dx0TS7e583fqWpw2t9JFE+dohJ8wFsYG7kg8Dms1NuTTWxVO rD2jo31/zPK9VtbrT763j8aTxkaxH5xMt2ksaMkZ8t35JXnb1GeRXLahqC2WiW3iO+vbS30W4b7I nm38ccR2MykLk4GMNzxwK2jGcrKKPShSl2P/1fle8j8I61bLLYeM/DOnBH8+71OLxHDGkATGwSSq dueSME1FqN14MMMupjxv4PudRQ/Z1li8RwXMk0Z/iD7uxJ69Rn8fzX2dde646ryM4Q9/5FnStf8A hPYGaTxp8SvCF3aJCQ9rBqAvINpA+/HkZIOc4z0HPaqGl/Fj9l+wv5LCx+Jun6fBe3Je5try0eG1 IH3dhwAqkDjJ/KlCnWmnZHXDCp2unf0JP+Fk/sOaXczXWpeO/DbyojvstNOaKePghDbyrgqQeQWy vbFeVaj8aP2HNCvbk2XxQ8QXs05a7uCrS3vlhj/q1C2/JPYIDjPXpRicNiKcFKKuelTy/CuDvJ39 EvzZU0j9sf8AY10u0OieGdD1rX9WkmZ4l1K1nj+2uTlmM83AOM4UKBwBiuT1r9pz4D66NSn0/wCE UyT2kXl+brN+mlCRj/BEF35XocnAOawoYfE1F76cThqYSnCLUY3/AAP/1vx8vv2svgjb6Vc/Z/gl pF0otnbVbePWo4LiUwEHyiRAC+SuQA1Q6d/wUK8FWVjph0D4DaRDbratCsF7crcyaYY2yDKzwqyg jkck+9fmM8FVlN+8zshSUEly/fr+hk63/wAFIkfXZjYfCzwuNQubVHuZ5LIzNIhAA82UfM2CPwxX KXX/AAUt+Kl9cW2neHrbw74XVIGRbSLRVktQqHAMZl3sOPoOOneuqjgWrOcmzmqU1KopWVk+x5Xr P7df7Qmo6kbPU/GT3OmHc4ltNESzjmBByHdGAG3gDOc1554x/bK/aD1220tIviX4ssTpWYLaXStQ a0e0Vvlz+72sRt4PPSvRoYalTk58u/fUXsYckoNaM8s+Jnxs+Kfj+0tLfxJ408Sa80VhGkd7fa/c tLL5eRsILMpU/TIOOc14WQ9ndRTW37lZo9zwwk+VKw5ZnPdufvGu+jGEIckFbUzpUaNH3KKsmf/X /jlu9RlKK8QEznAKu2FXnnH61Zhm02WC5jnVLiZFCxQuoERcruIOfQHtXhtrksE0kmgTU/KWYXdt bpDFECskS5KtgjIFYUcsbWsohuJHt7d2nZmOQS2SeP8APSszn2L+iz20Qkm05nWebEgk27Qpx1xV q91K309EBC+bcyENMDl5HPQN6dKzmupLkkV/9JgbT7jyibi4lxEz/JHIp4PNWbZLOTVTPqNpBNE5 a2uIkk3hQQRwQckZweKwlFvYd0f/0P49b+w0zS7G1S2iVbeaYwxW4BYAnLcd/WqlvanbI9qC4gXc UP8AD9K+MnFnJePMa1q9ndNbiVjGjZSYonmqpGc5Areh8Q29iv2a3i865jBAMgaJZUPQ4/wqXF8r Lk0oO56v8J7GfU/HtppV7dSSW2ovbXkFkyE2ttLFPATlxz82cY9SK/0bf2GrKztPhb4Raxsjpav4 asvK0yRTDB/qlBK55IwqkE/rX5jxk17SnFrz/E+eoVZPielRWyg39/8Awx9/wTOxaOVcgfxDjFPx GDyu9gcHd6Cvi6dz7k//0f6545YzIY8MoPA2jAH0pJAFV0Ybh2Zupr+Tz0DPRIIy8iL83rirtvAb hCzcHoozyaqHxAMhDeao3KFV8OHHOKnlSLgZGFJI5zVz2Kh8SKkiNIpaMH5fSqx2FWEjEEDjsRWs PiHe1z//0v2YSXGxSPnOAoA5yelTvMVBk2Bio2KDX8izg00daWjQsN7DN8k5EWOCSCxBzg9KU5a4 jkNttCI0Sygg+dzgEAf1qrO1kZNJvUp2aWkl9JMflGfLQH/VKR1NVrpreJ7hFVGeWUs0pGEx3rJK SqWZhPSLZHql5ZDSbiF7Iz2lzayW8sCTGBZQUYEZ9RX8of8AwUm8MWMev3lrLBaeTbSOs8KXHmpe zMu63csDjcAE4HSvSyqrWpZzhlDZv+vzODFSg6UYvdtfmf/T/kYsdDtNNupJ9aa68tna6Fv5ouDP J02sxPCZH/1q85LTi6nhu55kge5ka2iiAkChjkfTgdM9K+DhzciZLpO69ByuhtYrPyppWaczedIT kr0CAduSf8isi68NvGxd/NmtY7kXkaRf69RgAxoB1P3iM+tdMEramfJIt/ZDNJHbRzefJIv+jWcm fOjz0DD1rKaJrd3acsGiJDfw4I4q7Gc4T7GnpsMN1FfNO8oMcfmQiNwrHOMOc5yB6D2rFGkXdvHu mv21B95cyNCIUTdyFPuK0jG25zypSvof/9T+Lf8AteGDy7RmKRM2xZsEoSBzTYnW9+02dyLeKGOM eRqC7jM5O7cu3HH8PNfLnmxg0V7yGGfTjZy2UF+ZIxFbXDyCNLVFPzZA67hxzXI22u6lplwguYZj pqSpb2axRZjtwcLtCjjFBXK3seo+IZLWSGwvbGQ3rRQ7pYY4hCsRPJCjuRk5rmtV1WW1WOCxENwZ IBNdyxnBhLKCEORyy98d+5rppdBqm0X9BknuNLa8v4UQRMURmkV3mAHJKVaN3E+nyRXIlgVgfJlg j3sPT5SR+ldkNjSMbH//1f4htXtWVT5QkmlzuE0xxNgZwF7e+OfrXMxRyarazwxpI9xanaQVO0HP Q/hXnnnSi9mSW1jFFcS6ebgefHGDLtG9V3DJXPt0rWs7e1+0fZXhDSoBHaRIoy7E+/TPPNbRbZk4 tHpWjaJqoun+0RNaW0cCvCD8yXJPcN7eld9c+E9VudCsvENtbxpps1zKt/IAsZRohklk4wOv4/Q0 3WUbXZnJaq5imzhim+2xRxwJb2jSeY8gTG0A5yfX0965mx8UmSeVZLiSe3unAgt4gHhjdeMnHrzy ec0udG0F1P/W/jPvL5NRvmabbGduyGEDK249Fyc46d627m4s9J0WwgGq6dfXNzeN9pihVvtNohA4 cY9OOc1jF8rOSMO5gQWVteXb3FzfW9lZxTnFwTtYJ64qK5sLQ28bQeI7tEu7h0MMBRVMYHLk+4// AF1rF8xaSWxUuH8IWsVqv9tzXEFwypHM1kzz275w2UH3hxngmuM1vVbm6uJbKzuPN0+EbcojR2as MgSc/wATDr6fnWygh6dDH0dZTZ3EBASQTHG05BBx/gabeX0NvMLcBjCoCM4bBZyP8auxEtIn/9f+ F6VpD5bO2Qp4GePYVrWKzpDLKSCZMogXqR3+ldFux55RS13F0jlb7zM0czH5SfTNXkhaSJYXSHzU +RWUYJ5JJJ70bCsbNu5hiW2ZIljQ7muH+UnIHHpVK4WWzifyWSZZMnzFfzCFz3FaKV3sS0+jOYcu z4QsQDlh0yfai4kW2jC+Zgs25l6lvqKttLcjlkf/0P4cofMvbWMW0fmEHEjr1APQCqTXbWsnlSKw CH5SDxkZzn6V6kanc8dpo0bXUVjtdrubqQylwjHaozjis1tSlE7u43SMpAjIDKo9hWyn7tkQ5SWl iKPzm+0SXAL21uomVEYqp5C8j2yPzqlJcrPvZAoCjCLnJH41TkSnK5RWeUBBM5AVuAB0H+RXSHV0 NslmqoIYwTE5QLKxOMk/lWgkpXP/0f4T2kjZj5jFB05HLVVluRGVSHe5I+VAcD/P+FfQHhSTJVuQ UQSL5Vw4xtHQfWuk0zU4bWI2hMaTMD50udzsMjCn0xjNK6BOS3I7y7SKZJRIiOhHz8H6U6G8iuCi SBQIstj+97/59aPdeptdrYfJcQNucQIkmcFs4wB2xVaa7tnAOQHA27T2pLlWzC7P/9L+GhL8Bdiq oDLlywwMCsydw0qmAlS3JIOPrX0UbbM8c0dNhRpooN6oJHw0kjbVX1JqxLa2yzySSlVAOEbdtMnb OKvmSskBSuJZogmJD5cgIBXqKpLE4ilnnG6JW2h5HwSTnGBnnpWi5epTfM7oeVnuQgj2yt91QMd+ mTUSt9n/AHTOGkRiGKEFF/GtLwtYk//T/hPWYC4b7pDDAGcsRURVZJF2RlWPGzPH1zX07aW549uh dhWGJGZCGLcHnIWrSy26xM4Kkrweehpc8RtW0MohjM5JB3dR0AFalnao9u1zljG2UiO35Sw6j9P1 rOTuzJw6ozSCN0JDDf1yKrwolrJuk/fAHoM4/GouluCp9z//1P4UYVIdJQQFznaOtb8iWsYEyTiV doJReDn+n/1q+iU7aI8T2emhUE8kci7SVhL+Y0fqagkv49z7gX5yR1rVO6uiOSRlTXbSk4XCj7qk cinRIAQzHcQMlScCt4tWsHJItwiPDkFVYjCs3zBfpVeKzuFeV22NCDndwTn2FS5lKDWzP//V/hPy XYASqWIOVLcrj2qtJ5sCMAFJcYY98e1fVRly6HiezRNp2oRw7xOU83bsjByQvv8ApWkZg4wxJB5+ Wqc76NDUVErrKqiUlT8rfu2PBPtioyJHi8xsKu7r6/SoTSepSXYf9raRVtl2hYxkhR+pqGXbEBIr b3J57YrTnQWtuf/W/hStJyZAu8KJOpxkCthxDpJiuZ9srSjzIkjdW4P94Z4/GvsFKPU8izexQ+3J dSHDeX5ntnb7YprmPy084gFm2qn8RxVc8UtPzE00RNc7kMAbaQflc9RVaNFll8tpB5rnO9jwtJzi 9AOpilstLs2S5WOa6OenyjB6Anqa46O5h+0szDYhOMkdKSaB+R//1/4TZXt5igzhc8uTxV/zrSGH ybZn+0AEtPwUIIHygdfXn3r7GLs7njpPYzJJ1kXaCN3cngmopSkESHepkc/dznHvWvPErll2JoXA QOkq7u/PT/Co21COSZtzRHAChcDa2OPxo54is07EE8iySlo2ABXDrj5V+lV1ukjOzgqB1HJNHPEL Psf/0P4TftNsyRiMgfIAQex70CaLY0e5eucYxX23PE8exCIA0nnCZkVF5APyn61KJ7eVNm4DJ6k1 HtFzWGk3oi1HqiJCbTcFQcbsY8z61nQySSXaxxYLO4Vd33Rk8ZodWNtBWPoG48DeEvBnheDV/if4 pSz8U6nvk8P6Fogi1aJYQvyS3JVuN3GADwGB5O4DxW7a0mn8yKZZI5FDRH+Ir2yO341hh8TKtObk rQTtHu7b/jsaSUFCNr83Xt5WP//R/hSmktY4wYwPMHrVXzjOGYSjcpAMf/1q+2VW2iPG1J0liRws ZyAMHcOKbDesj7QoYKevoKpVk1uZOLuW0vIQrMxGSdu0jk1DFqUKXHlNjbjKn1NZ+1gKz7E11qFs 0eXBBBwFHWqUl6EBVZA6sAUb0q41ooLPsf/S/hGTUgkZVlGAfm96cdYSaQsR91RHGAOuBjmvufbw PCUHYiabfh58nB79qbNeqVVoWDeXxt6ULEQKhFosrqULwMGXBU5LCo01iEFGZANoxkDaze5rdYiD RpZ9hk2qrMC3y4z8uD0pg1EOSXkwE6Ko+U1MsVBBZ9j/0/4T4vEEYiMbp90Eqy9T7YqgNT+1HZgD 5uMdPxr7x4qDVjyeWXYsxXZXcryfMB8rHpxTY7+PayMcfNkkcE1Drw6ByS7AusQgMu5tq/KB3PvU Y1OHDZZtqcnPf6Csnio33JdLyJl1QRcxkCMjn1NRG/AHnICR/E3QihYmL6j9n5H/1P4Of7UEjDc5 Bz1zT5dUckKT8injHWvsHiFc8n2b7CLqj70C/wB7OGXdmrZ1KVUUByjAkuU4DfX8KFiENU2tinPf k4KEsityp5qub5i+4Ehjx7UPE+YvZt7l+DUXJEQALYwr4wyUSX6I3lu6s4546ipWIsxey12P/9X+ D9b7G988rwFAxmiTUXKhjzxn6V9d9ZV9TyvZtbEUGrmN0ZmyQ3bgVoSaiJW875i6Ek5OWcUfWYh7 NlObWpXCBtyFeI/UA9qrnVWC+UT0O4ZHIqXiUti1S0GJeXDh5txWNRtC/wB+o49VnRWBOVznGOV+ lT9bQOkf/9b+D0asXCgEYxgDpiq+XJZgeDzgmvrFiWup5LpJjjq89sAsbFTjbnqPSoDqs0caquAW fLN3YfWj6y76MTpdLGo2tQvbCNUxIF+dz95zk9PSqy33lqH+ZmPIT0o+svuL2WuxQ/tGSSaRjxvb heuKfLdSh4lZ2Cf3QODR9ZL9kup//9f+C3z5mfgMEJxkintdTKkhViRnGB/DX1LxXmedGlpoiH7T MoLl2JYevSmG/l2HgnaeSP60vrPmN0kt0QxXkrSqG3FW4VecE1o273LO+CxC8HHIT6+lQ8T5i5Ik dxcTcBM4zjKmkWO4PlgeZIH6AgnFL6yLkif/0P4LJDdQBnMcgjjOGbYdg9eabbyS3GZVJZIzz756 V9B9a8zzHBdC9A008qxrbzPO3zRqqFywzjjArevIrqzKWU1tP9pMYkAETZAIyDwKlYol011MeYyK qPKssDl/KUshXeemORU8el3z72SGR1UZJxgdM4z6+woeLGqatoVYzqOos9vEk8xtRt8lImcwDOOc Djn+dRCHVEV4RazR+XLs+aMh2+grJ4vzH7NH/9H+EC30rUJomuHt5QeQu5SGbHXip7Hw9q2ptIlv ZyuISDMQpHlA9C3p+Nes8Wl1PHaSbM19D1kX/wBkSwu2uFk2RJHCZDP7pjqK9MsPBeo3ECxGCazv TGfMhuoCJY2GcAj9al4xbXJcoxNbTvhxruuX8eiQxvJcyW4kle2jGxNo+YYbHoRjqSfz7K9+EV2k UkdncW8EFlb/AOmG8tzbSJJ0C4yep4ya5a2ZRpS5Xq/6/UzlWhGXKeQyeCdedY5Et45IxI0dzLHI TFAQccHHOcHH0plx4E1yEXrm3MiW1uJ43gPmF+nBXqOoH41rHF+ZSnHsf//S/iD0nwBr8lnLdw2U VzLFD5xhEw85hjIwv5dKh1Dwb4lvPLSHSZxebVSWzUgPGT6np3xXofXY3cb6o8iMqezE0/4WeK7u S4itbVHubbP2m2d/JmyOy7sAkf0rLb4e+J1v7jS3sd1xFALpir7oEU87d/TcO49qzeOg243Noyhs adv8HvH8tpLfnTQdPQARGKQyOzHoGAHH4ZrobL4HeIZNPjuZb20EzMd9pHHJNNB6Z6A/hUPMYQ6+ Rd6fcypPhl4piaWzn08MTFhJ1R/KBPRuQPx/GrWkfBXxXqU0VrbQoyq+Ly4ZwqQr1yo6t9O2KJ4+ EVe+hDlE/9P+JZ/gP4naOaewMc8PntALwyAPEVxnMXUr05961U+C+v21qN/n3E/l4SIRqkYOcZ3k 45HP+NX/AGpSetzy3OOqGv8AAfxVJp32t7iyOFd7qK3YSz2wBwDtzyP9r2oi+Cd/HpX2i2NxevAn 72T7PlDnjIA5Izx+NR/a1PZP8CHOFjYtvgHf31vFPDBKhnj8lopQyyqxH3yACVI9CO9aMf7N1zb2 T3LGRnWVYbrz3+aMd9uB39al5wk7K+hi60EjpdT/AGXp4bO0v7XxNaLZyRqh07T0a5uoyRne7SIu D2Kj86xdM/ZokWW5m1C/vZpYo1MFs6i2+0gnDYKkgYH8+lT/AGy+iMpYmMUf/9T+QZf2ZLd5oo5p b37BflVeZpfMjsxxu24Abj+lSL+zZHYBrO11uW5bzSyPHp7rIV3cJznOABzx3+lcrzmd9V/X3HzL xqWyOnb4EWv2I2Znt5PMK5hlSR7lTwG29AD6ZNMi/ZH0uKO/u7+F7qa4jR4IJ73bEqjqBh92cY4z n+VS82rW0WpH12XRFOf9lLSJtQ062tbc2lt5YNxcfa5UtGbqSwHIx0x+prsbj9lLwhFaLCkIuoeG YtKQTIPvMCVBwfqayqZribe6kL67LsMi/ZR8GiBdXNnJGkBFjDYR3LfaJyeS/TAA6ZOetaUX7NGj tcWsdtaWdvpr3It/sjXWJ7YH75dSMEHPUg9D7Vz/ANqYtyvZF/WKj2P/1f5iZ/2V/D9wk1tfyQQW kUp8mC1cSyyiP7uw9ACPU8+lQW37M/gBURZdP37NxRpYlEcTjgfKBk5xycj6V4yx2LlG1/n/AF/k fOqtLqdjJ+zh8PLfTVGjeHBaXNxGkN3d/bCkbkfeOwDgMew6e9MH7PvheGW3i1XSoLmwuVMEgs1E mFA7Nnjkew/lWTxOM/n/AARMqsm7HV2X7PugRxhF0ayj02cqkG6yUSlUOU2kHg8DJ712h+E/hNdO kto7SPTyZy05sYF33AwNqvnsCM855NYSeIneMpuxPNLuc4vwm0OGS0lk0211B7eUupktfKxk4CnY ckf4muvl+C2i38w1e80XTGnVFjit44XskCjrgRkduhz+dJqrFfHsK7P/1vwysPhNoGk27zLbz6dc X0jR25cGS3+zspBiYHrk9zkmpbD4R+GbR/Nls4JpGuBIskVusJA9BkE18naoup8rN20TN26+E/hV Lmymk0WA28jfvIgC9xPg5OSRgHnsPwroG+Feh21vbyWulfZ7a4+QRpJtlUdCPTv0K5o5Z9zBq/UT UPhF4aZYZr+wgvgIRHApXJtAOynaPm9TzWxpfwy8LPLo9lpumaJaX91J9mt5LiwEt6ue5lOWK9Tt AwOeKtK3UTtY7qx+E/hnRdRvk1Cw0ZNYlmQW9xDap9lk2feLbhhM8/dH41zd/wDCXRL64lQQCztZ 7gzXD2kA8rexJJIOc/genale9jBtuN7n/9f8p9O+EPhOzMcRtknliY7ZHgQoc9SRjJq7qPh/SZdP m0e48OaS1vP/AKPaXYtBbTwFDwylSOc885/GvkZWvY/Peed7IvaT8O7MfY7i80uw1C2jURzQXdsv mkIMKRIoDE8Dkn86lvfBVnLrEtzZ6VJDowKyXdpaTESIBxgAg8cdecZ6Vm6beqK9rP4bsjs/AujR TtcWmnRxwXDErFdwLLMyN/C5KjPfqK7LTfB+n2UcsaaDoUiXEYhMs2mxs5XIO3djIHArGdKTL9pP ubk+iaVd2N3Ynw5obQzw+S8NvZiIWxUfK6kHggjjB7VnaR8OdAMQS705bz5fKHnzMvlAfdwQR09K 5pUahoq1S6uf/9D4Al8FaLbxs1tpUd6UlDTF4AwUA4C5GDg+5z05pln4Bs9NuLHUNR0G1/s/Ubjz mhTZJLJGjYZRu3FR1HP69a/Po4ep1PjvaVHHc0H8IQW9xJeaWPLhmfOxolARAcqvvj0x2q/J4Yjc bo4445nJklkNunmSsww2GABA9qp0ZdiL1HrcF8GX263I1G9tXRg5W0w3mqOQjbh0+mCM9aLzwRqE F7BfXdrby/aSfJM6o4bPDEREEA/UDmhUG1sQpTub974RufEJtp703F7Lap5ENu2WIRRjYqjsOvSu eufAGmWVpbsbQF55mWWIYQxYI+9H0HU/N35qVQdyVz395n//0fi8eEFELG2ZIrPbhomkyFyRnbj/ AD71Ybw9FaQm1EMLQzYO4wKZVbjkNjIPSvz6VC+h8HzNSG2Hhe+tIb8xOggvmUT+YObjachSQCcc nrVzUPC+lTWk1wtvb6XNBacxxszxyMpGcbiT6msZYdp2NlUlHUwG0L7Olpd2NuGjukAa734ZSuCc Y/Dj0roo7YvpyaadPjZBdm5mu3XMkpKgZz6D+tJ0GipV5WNODTprm+ssRROtpEBDDFFtddmMDgc/ jms69sJhqLi3eaN5PmD28eJIyPvcj1z0/wAi/q2m4e2bjc//0vkGHw9NNLc3rMoLRiAGaLM8gJO7 DHoOnH1pkukTi5jhmhlkVVXYHUlGyOMdjgenrX57HD2PjI1fdOoi8KWInhudzwRLCVeK3wCW2gA5 69v1rBu9CeOeBXPnO05WNICFZF5wW796fLFIydVp2KF14cs4ZHt42SedoxIzbcPHnsfy96eNFlgt YYkhd5ZZSzbI8k4AAB+gB/Ommolqb6luYJZ2bvJZbJG2QpIgO7IyDkc9evNVrO0iuImlcu6k4j3D bsPer9pFEPU//9P5KXQo45Yru5mVY48l7ZV3yXCkYGG/hxWVqVnZ26wg3CmMAm28x/nHUlcexPav gHWR8Eou9jOEF632VJMeXG5eNDh05x2/AZ+lWp7W5tHQqiyG6DGQkgsvvj64/OqU7rY2hTXQpf2J czym4kiMyDDSMRlEHAGfzA/Gti000206XP2FLiCMZK5wm7GELDuAcHGe1OLbeiQ/ZLmHXmnXty8U OYUKsZJAUA3gjOM54P1rGNpLH9q3wuixqVR1XPmH2qY3UilSjFWP/9T5Y8MaB4dk0z+1tbnN1csj 2qaPC5j8g4GJZSRyOeAD1HXqK5SfRYYjlJI1i80qo2/OV7H0/wD1V8OnY+O9nBJdylDb6THJPDcS wyXEqeVHbu3BLA8n6Y6VlS6YtuY3jSMkvtLA4AUd/wD63vS5l3FyRNCG2EzqvygRJzLjax9qmhi0 y3nR7kzSRSN5Xk2gUzZ9BkYpNqwnCO5Yu3trhJV0rT7Y2duM3v2ibbNCh4U7cd+9Zgk0VoLO406S 0hhlbynhUkEOOpUHt9Kd49wUIn//1fz4e7tBqM63YigS3IQyq6ktu5XIz34qybmwidFZrfc5EIDO FOX4A69TkY/Cvhvce58he2zG3VpbRs13LJpVnDE3kCaa/RLidhyU2E9vauX1C6sJXguEvLWK3jky uLhNsjgYJzn3PFWvZ23Dnt1KF3qen2dutyksBluZAryCRfmGMKxx26jNZgOnTyGR7u1iuYpFnLLc KI9p9Occ5qlOlGL1NKdW17sfJqH2i5njtY1e1iYI07SINxIzxz83A5256UzVtUt2tLC+DqYrf/R7 h4Yj5alRwz45z0+vB5qPbUS/bKzTP//W/KlNY0yIyNeyDbsEkR8ss0oPZQBmrJ1LTHJaC5eSBUBC mCRCxI5VcryR6CviVWpJnzEakYma13Y3Nw63kN5BAQAkptpNknryBU8VtZTmdLTStTvpol3WYg0q ZnuSeAB8v6moliaSZlUrRTuZUNlNFDNby6Vq1teQytJfWSaZcPNagn70h2/KCeK1ILLxDJFaT2fh PxJLaySeUJU0Odkm6/PnHI+np0o+s00rsh4iklzSehRn8N63q2pS2sHhPxXfXUvySJa6JNORgdNq jd2PGM81qnwF8RBDbNP8P/GVolxMbSx+0+HLqDLLjAOUwev3VJNT9doLS6+9EvF0Er8yP//X/Mu0 +DHxu1+3hh034Z+IXuZJfJeS4sJIIUA5yAV35I6Lj867TSv2Yv2h7+1jtrT4MeLdQM0/kjzrCS3e MjuF2kn9K+FePpwjdvT7z5aLbs7fe1+pXu/2T/2qbOSW0n+B/ieOS7l+zWcBidN7EfLglACT1xxT /wDhib9qfTYhczfBPxM91ev5ES7/ADjHIAPmZVBAXnrnseeDWazWlKPNF6ejJWMpRbjzI0r/APYG /bKsZog3w0gtbeeGO5a8F9HOhDDJixuyHB4PHGK39A/4J0/tc+IQssPhjTfIupyqNd3UdottszuL B3BI7ZA69qf9pU7NpnPUzOjFaP7kzsLj/gl7+1t5Oo6pJ4a0JWSMpBptvdrMzjoHWbcFHQHBznOO Ko6H/wAEsP2p9db7Fqk3hjRry2gLQRS3yObt35VGUNuyBjkDAxWEs0vdKLOZ5xFN2i/uP//Q+fLj /gkB+0vbPpFnqXi/QYzeLhfs9mlxHaMT8yszFAeMHOR+Jrfuf+CO/wAZbK4sbeb4ieHsxsYTfQWc MdrMCPlBjV2YtwcDH5GvzR5nUa0gfnzzirflVPT1/wCAXk/4JF+PdJjuofEHxb0a0MlsDp7w6asL GQsCdxO5uFB+UAHnrU2jf8EjPE3iCe4aD4vwYhh2Lay26WFxcgDlx1wM452n3NYSzDENXUBzzFWt Ff19xtn/AII+ahKLZdd+NMUiJF9nS3s9GjuXidOAm84V+BjcQM9zWk//AASP+FEc6f2t8VvEurpb sJXsLK2ESkp1G4fIpz2GPrQsbin9guOPSjZ7mfJ/wSy+AOk20s0PjrxxJqdxdPNEkaMRCOSqkDaO MY6ms7Tv+CaHwD8PXCazrvinxBq13JF5wtdPE1pqLRlTgOXZgDyD+FCr4+TulZGEswnsf//R50/8 E6fgD4guYBA/i3UmS132uh3GpixOoODkRyzKp5APXA6dTxWbq3/BPn9mnSLgHXPAPizw5fTEfY7O 31+WeB9nU7pOobGeK/NFUx2zZ+czxlRq8dDtvDH7Gn7NdxfaR/aPgx7u4tWkt57SaQubq3fhWdvU Z4A969N1D9hr9l+w0tZbX4RaTdTWNwzRrdX9xbRvHIxxvw2HYZAwwOO1bRWMe7dzN4mtNct3p8ih Zfsj/sy6bcRJdfCPw5YFgJD5Vy927gDO0Z4GSMZwTiuzX4Qfs32/2Syi+Dngi0a9YxrELCC6k/dr 8shVo+DnPufWtJU8VNe8yZzr1Uk5PQpeHf2fvgz4OS2mt9G8LeLIL+WR7iFtLt/tulSkfLHJD12A jHbkHI9fQL74deDrXTLEW3gfwzcTSSK9tK2hQQCJFzlF2qD9AeeKzqYSpOfNLXYSlVu3/XY//9L3 7xL8N/D3h7QRqc+m+HtP1S+1HzdKsZNGtWaIbGDOnybuDj72T7815fYeDvEl6mnWWmWmnJPIZLx7 FdNinlJbcxdFEZH94444PFfmlTBTi9rH5rTquF3Iv6t4CuPB/wDwj0mrX2mavqWtztK2mXOkpH9m UYwjK6kvkHHPcHtitfxD4Y8Iy6Dp2ueHNKsNCvrOeYXyaPbR2MchITy9xGG3g5A56HpRDCyjdSFG vKT0Zh2OoajJop065ka41DW0AghkuPMe1YMdpbPToAV4z+NdV4KlHw8ttX1DXvC3hy+1Zpw8d5b3 KxysNoB8wKuORn5cEZGc1UcOovc6fby+FmzP8ZtCgWf+yrTThfy4upLB7dkiwRgZIIBXnHNchYy6 Dc6ivijW/DOj3F7LK00ukqrSWUkLqdrFT0AyCByMjpVrCwu5X1YlGUm2j//T6tNT0G41149Egh0h DM13ptra5Om6e6EblyeAepwfT2rtbb4jT6XqNvfarrxg0jULiK2uryGZQ9u4YR72jXquCMnHGO+T j89lhYS0ep8D7N1FyyPGvjZ8VkXW7nSPA73Z1m61dQNSu45I9B1KOMBixlXAYYySqMeo6EcdUnxW 1e30u/ubmDSlu9aZRcWwtwLewlWNVDRsMMVz0ySSc9KqGEjCMYu3T+vwKlhYx1bOi8E/Fvxfp8Fr Y6d4Iu9fm1S6eC+l0+4a0S6XG0KMluPUngc0/XbHxXaalBN4k8K2dpHqDNNFpdlP50YAP+rDZwSM itFQpxVy5UoumrdzyjxTD4us9OuoPCXh+z0G6a48y3vNelW3hZd2XjWXJ4znjr+tcr4e1rVtRkkX xDpmkXOsW0Yi1C2024YaZO3K+arqfbnHFNxUdLGEk4ztfQ//1MSz1zxdp+p2d3Y+bYadbSsscttG Tpdjx0kBBzgHqwPXvVy7t5tPstVvNd8RWC6zqysLUW2Jr1YnzgvH2U4bP49elfAtRcdj89St1OH0 W81l7uwhHktp64iE00bRMVbjccj5cZzz717jYa7rOq29l4dtYdDMOmzg/abyyiEssMWSYrZyO+Qc 4ycHp2h8kYttGFbmbscP4j8X2fgzSJ9F8H+HrvxLruqXDajqMl5fpZQ6L83yLCTxIHwxyTwc8HFY 938XPF0smmab4j+Gdx4bvrpFLX1jNb+ZfqqEIXAbPzbcDOMkjiny0uW99ex0UXKz5nZna+PvHF+3 ge6t4Bq0dzbx26x2bRR+bGrSp5jS4zkBCeBxznPFcF4X+I/jaC2GkeGHtNOtrrUle9lvLNTJe+Xs yPMAEgC7SOvc1MuSUVF7FqclHlP/1d1v+Ew1q5/tGe5j1VbzUvM1M3DfZmsVIIXysglxgHALe3Ax WB4i0LQbLUE1Oy8+eeVDDHc3duIVeRcDAAY9MqMZyPSvz5VVFKMUfH06rcWVEk8byWb2dhqmkR+K NVtjo2i22uW8qWqZ+VBHIucYGNvvxz35jQPgN8X5bmbWvETjW51iNpeafEwtrJpC/wB5Xzulx13g BeefSp+sTUuVbFUKlSU+WKOo8Xfs2fFLULG+udJsLPTdOubTCxXd8sksTADPOcKCegOSPWuY8JfD Hx9pUFrpUWleHZnixZahPqN1DbmEnAaSNuWJHJ461X1ltWWxs1VjNSkrJHWaz+zaIPt2va/4l8H3 mnrbM/2BpmiW34wWWQ/xjqMY5HpnO74E/Zk8DXd5aX+reKPD13YWYhvdM02O5aBo4zyfMPKsemCV PPPbNTB1Jxcv0L9m5xuz/9az8RNC8D+H72We0+I/g7TUsrmRYbXV9ZtrybSwVCCFdg4BIZyH5G8/ h8uXn/CoPDTx6p4m+L+jxxTzMsaaHqjTWkb9VklVCSV6cYHTr3r4Snh605qnb8DxcLgK04Qja5o6 74w/ZUl0nVG1/wCLnhv/AISfSbaO9lTTZHtYZVby1gDbQv2g5dGLK+QSSeFNedaj8dP2QfDhtL29 8bax4q1t1EDjRbAX6QgqMF1b7oI/2mNdcMtxEpONnchZfVeIdGzv6afezPT9sP8AYwt7C4sjq3jD VTA7PLZf2a0UtmUPOWUDC9uCcYxXnV5+2P8AsXRW97qdx4H8XazYy8Xc0mlyyfd/1Zw04XnjBBzw K0llla3Ly/idcstqKSUlt5/8E8gtP2+/gLZ6vZ3Wi+C9ci0GG9nkE3mXW14iWCQPEdzBhlcFGI9W wM11l1/wVK8ISR3/ANn+D0E88VkIPD7ajPHdFwDzE3Ug8KcfKfU9qr+y3bc0jgKsE1BaM//X/LPT v+CtTaCVv4Pg1oOnNcW6wXEqTob8S+0ZQ7l46Zz/ALVefa7/AMFTNX1O+/tfT/ht4SmvgxtlvdU0 /wAq7tdzdGm3bwo44GK+SllUJJ8z19Dnhg+V/vB0n/BWj42aRbz6XpvhH4dW0Tt5zyw2l1LuZgAW ZlkDE/KOTn7uOa8d1v8A4Ke/tHLYQTR+IrVLiLUWe8n02xhtzCjk+WoQxjcgzgg88dM81FLKadOX NJ3RlUwlGdTmjdHmjf8ABQT9q+8unMvxDubGxJd2SzeUyK0h5m9wMj5TxxVTXf2+P2ntZjhtG+Jl 1qdtbReSwvoXs4blVG0Boo2HPqep71q8vwqlewo5fSi+du7PMG/aL+LU32+71XxPqWo3WoweUFju 3igsuTxGpz8vtnNcPqPxm8fahpkmhapq9zNpO4sLtrllvJTLjzchSAvCque4Uelbwp04/Aj1FjKs Y8l+ltj/0P5KE8f+LoYIYrDWNUGjKDHeW8F8yKQ67QBj7o47GsDUvGN3LpNloy28gsVu2mnKFnmk bORulPzdR09zXzsqcHq9zSGI11MkO1wrSTW+ZXUq2+WQmRewbJzngc+1ZdzfWkS3lrFaPcTNEEZm dnjt/ocnnHpisXRhDVHR9a6WKelQac8d5e6hGslw6LDCdxdV24G3rx9evFd3/advpkelS2jwW+5k 85IYg3ykYHT9TSt3D6zZqx2NpqsTxtezSRvceb+62qMHvnPbFVb7xPqN9f3txAYjPJbJHHDE5LKU BAbb2z+vNZulHoP6ytEf/9H+SPTNDvtVnaxa9uhcqq3FwlrCfNjd+jFfrnII7V71oHwQvdXtr06p ruoWVslsjlgqWxu2bG0MNrEgjn5eAK+H9ledjrljIRVmtTRuPgPZ2Fysk3iW2FzdKsX78vi1hwCG AEYySTnHNec+IPhTJBeTNpupWWoNZQhTNEv2cXRz823PKkeh6laxp4lVG4pWsOFSMrtWOLvrC78M wR6VPNbT2kw+0ACQSzRu2SQfTrjn0rm7jTrd4mmcybecpG2wuD2rritncxTvJo5AFhcJFcARfaSY 4ocZEaqeXJ/Klv4ZIzHDBNFIBLtbIO107lT29q6IKyDk5Xc//9L+NeO1Wa6RC0eIfmEcchOM9iM/ zq7qmnSGeGeGCL/RZPPlxkFcjbxj6187F3Q6sG9jNuL20EE8LjeRywU5JPHBrFisb2wmhtpIXjbU ojfQIv7wPExwD7d8A1RzSpy2NWyibRWJuZI2aVg0aSON6gn7u0c5qXUbZLiNBFJFc7pfMMSqyhFP J5I5I9qylF7sy9nLoWmms5LSC1sXuWlhc+c82SkTHB+Uk5pI5o9MtUklgSaaSUq8qEvJkjAwvWoF ySP/0/43lvL7UoTJYkNY6fmN2mHlzrMzAlQh6gc8+wrRiuZtHtRc3CXE73s4tU+zQmWHOMneQOBy MntkV8jNWZxckr2NGzgRJZfLZbZpVL4YEKzHr09a2NF0gak9uL+4+0m3dy0kY8sooP3OOgPBP1pq N4u5o4OUbH1X+zfolh4i+O/gLS5ruTTLS81SFfttpiWUtFIsipJGeqsY159q/wBGT9lpJofh94cm MtveSnTBCs7xhWKRhUBT2JU4A6Yr8h4zcnmFOKWii/z/AOAeLhsOlxIqq6Q/zPraGUI4DZy43HjG KrtO/wBoYOPlBwpAxivlKV0tT7Sztc//1P64LglY8r8uRzjhjVVJA3lDc25/lO44A7V/KFmegLHB cLcMgCtAp4cHvzn+lSTvNDMBDkpgcAYINXBLcLDAZZJCSMsx5PT8amkBhDMxB479Kt26lKLuJa3H LKjcsvKkZUj2pvkRzSCRsHYc7RwDWlNotw0sj//Z --20cf3071c812c14cf504cfb528de Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-api mailing list Xen-api@lists.xen.org http://lists.xen.org/cgi-bin/mailman/listinfo/xen-api --20cf3071c812c14cf504cfb528de-- From xen-devel-bounces@lists.xen.org Fri Nov 30 15:37:54 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 30 Nov 2012 15:37:54 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TeSex-0002Zo-Od; Fri, 30 Nov 2012 15:37:47 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TeSes-0002Rv-J4 for xen-devel@lists.xen.org; Fri, 30 Nov 2012 15:37:43 +0000 Received: from [85.158.139.211:30871] by server-11.bemta-5.messagelabs.com id 77/46-03409-5C2D8B05; Fri, 30 Nov 2012 15:37:41 +0000 X-Env-Sender: dgdegra@tycho.nsa.gov X-Msg-Ref: server-6.tower-206.messagelabs.com!1354289856!18577856!1 X-Originating-IP: [63.239.67.10] X-SpamReason: No, hits=0.0 required=7.0 tests= X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 11674 invoked from network); 30 Nov 2012 15:37:37 -0000 Received: from emvm-gh1-uea09.nsa.gov (HELO nsa.gov) (63.239.67.10) by server-6.tower-206.messagelabs.com with SMTP; 30 Nov 2012 15:37:37 -0000 X-TM-IMSS-Message-ID: <3392290100027ac6@nsa.gov> Received: from tarius.tycho.ncsc.mil ([144.51.3.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 3392290100027ac6 ; Fri, 30 Nov 2012 10:36:29 -0500 Received: from moss-nexus.epoch.ncsc.mil (moss-nexus [144.51.25.48]) by tarius.tycho.ncsc.mil (8.13.1/8.13.1) with ESMTP id qAUFbSdG017785; Fri, 30 Nov 2012 10:37:35 -0500 From: Daniel De Graaf To: xen-devel@lists.xen.org Date: Fri, 30 Nov 2012 10:37:10 -0500 Message-Id: <1354289830-24642-24-git-send-email-dgdegra@tycho.nsa.gov> X-Mailer: git-send-email 1.7.11.7 In-Reply-To: <1354289830-24642-1-git-send-email-dgdegra@tycho.nsa.gov> References: <1354289830-24642-1-git-send-email-dgdegra@tycho.nsa.gov> Cc: Keir Fraser , Daniel De Graaf , Tim Deegan , Jan Beulich Subject: [Xen-devel] [PATCH 23/23] xen/xsm: Add xsm_default parameter to XSM hooks 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 Include the default XSM hook action as the first argument of the hook to facilitate quick understanding of how the call site is expected to be used (dom0-only, arbitrary guest, or device model). This argument does not solely define how a given hook is interpreted, since any changes to the hook's default action need to be made identically to all callers of a hook (if there are multiple callers; most hooks only have one), and may also require changing the arguments of the hook. Signed-off-by: Daniel De Graaf Cc: Tim Deegan Cc: Jan Beulich Cc: Keir Fraser --- xen/arch/x86/cpu/mcheck/mce.c | 2 +- xen/arch/x86/domctl.c | 10 +- xen/arch/x86/hvm/hvm.c | 26 +- xen/arch/x86/irq.c | 2 +- xen/arch/x86/mm.c | 20 +- xen/arch/x86/mm/mem_event.c | 4 +- xen/arch/x86/mm/mem_sharing.c | 4 +- xen/arch/x86/mm/paging.c | 2 +- xen/arch/x86/msi.c | 2 +- xen/arch/x86/physdev.c | 12 +- xen/arch/x86/platform_hypercall.c | 10 +- xen/arch/x86/sysctl.c | 4 +- xen/arch/x86/traps.c | 2 +- xen/common/domain.c | 2 +- xen/common/domctl.c | 10 +- xen/common/event_channel.c | 12 +- xen/common/grant_table.c | 16 +- xen/common/kexec.c | 2 +- xen/common/memory.c | 8 +- xen/common/schedule.c | 2 +- xen/common/sysctl.c | 8 +- xen/common/xenoprof.c | 2 +- xen/drivers/char/console.c | 2 +- xen/drivers/passthrough/iommu.c | 10 +- xen/drivers/passthrough/pci.c | 4 +- xen/include/xen/tmem_xen.h | 4 +- xen/include/xsm/dummy.h | 507 +++++++++++++++++++++----------------- xen/include/xsm/xsm.h | 155 ++++++------ 28 files changed, 455 insertions(+), 389 deletions(-) diff --git a/xen/arch/x86/cpu/mcheck/mce.c b/xen/arch/x86/cpu/mcheck/mce.c index 658774a..26273f9 100644 --- a/xen/arch/x86/cpu/mcheck/mce.c +++ b/xen/arch/x86/cpu/mcheck/mce.c @@ -1293,7 +1293,7 @@ long do_mca(XEN_GUEST_HANDLE_PARAM(xen_mc_t) u_xen_mc) struct xen_mc_msrinject *mc_msrinject; struct xen_mc_mceinject *mc_mceinject; - ret = xsm_do_mca(); + ret = xsm_do_mca(XSM_PRIV); if ( ret ) return x86_mcerr(NULL, ret); diff --git a/xen/arch/x86/domctl.c b/xen/arch/x86/domctl.c index 2630bdb..0117375 100644 --- a/xen/arch/x86/domctl.c +++ b/xen/arch/x86/domctl.c @@ -76,7 +76,7 @@ long arch_do_domctl( if ( np == 0 ) ret = 0; - else if ( xsm_ioport_permission(d, fp, fp + np - 1, allow) ) + else if ( xsm_ioport_permission(XSM_HOOK, d, fp, fp + np - 1, allow) ) ret = -EPERM; else if ( allow ) ret = ioports_permit_access(d, fp, fp + np - 1); @@ -566,7 +566,7 @@ long arch_do_domctl( if ( !is_hvm_domain(d) ) break; - ret = xsm_bind_pt_irq(d, bind); + ret = xsm_bind_pt_irq(XSM_HOOK, d, bind); if ( ret ) break; @@ -599,7 +599,7 @@ long arch_do_domctl( !irq_access_permitted(current->domain, bind->machine_irq) ) break; - ret = xsm_unbind_pt_irq(d, bind); + ret = xsm_unbind_pt_irq(XSM_HOOK, d, bind); if ( ret ) break; @@ -634,7 +634,7 @@ long arch_do_domctl( !iomem_access_permitted(current->domain, mfn, mfn + nr_mfns - 1) ) break; - ret = xsm_iomem_mapping(d, mfn, mfn + nr_mfns - 1, add); + ret = xsm_iomem_mapping(XSM_HOOK, d, mfn, mfn + nr_mfns - 1, add); if ( ret ) break; @@ -712,7 +712,7 @@ long arch_do_domctl( !ioports_access_permitted(current->domain, fmp, fmp + np - 1) ) break; - ret = xsm_ioport_mapping(d, fmp, fmp + np - 1, add); + ret = xsm_ioport_mapping(XSM_HOOK, d, fmp, fmp + np - 1, add); if ( ret ) break; diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c index 5bdde8d..eda715f 100644 --- a/xen/arch/x86/hvm/hvm.c +++ b/xen/arch/x86/hvm/hvm.c @@ -3400,7 +3400,7 @@ static int hvmop_set_pci_intx_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_intx_level(d); + rc = xsm_hvm_set_pci_intx_level(XSM_DM_PRIV, d); if ( rc ) goto out; @@ -3567,7 +3567,7 @@ static int hvmop_set_isa_irq_level( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_isa_irq_level(d); + rc = xsm_hvm_set_isa_irq_level(XSM_DM_PRIV, d); if ( rc ) goto out; @@ -3611,7 +3611,7 @@ static int hvmop_set_pci_link_route( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_set_pci_link_route(d); + rc = xsm_hvm_set_pci_link_route(XSM_DM_PRIV, d); if ( rc ) goto out; @@ -3641,7 +3641,7 @@ static int hvmop_inject_msi( if ( !is_hvm_domain(d) ) goto out; - rc = xsm_hvm_inject_msi(d); + rc = xsm_hvm_inject_msi(XSM_DM_PRIV, d); if ( rc ) goto out; @@ -3738,7 +3738,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail; @@ -3984,7 +3984,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail2; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail2; @@ -4023,7 +4023,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail3; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail3; @@ -4069,7 +4069,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail_getmemtype; @@ -4124,7 +4124,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail4; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail4; @@ -4203,7 +4203,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail5; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail5; @@ -4238,7 +4238,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail6; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail6; @@ -4274,7 +4274,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) || !paging_mode_shadow(d) ) goto param_fail7; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail7; @@ -4328,7 +4328,7 @@ long do_hvm_op(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( !is_hvm_domain(d) ) goto param_fail8; - rc = xsm_hvm_param(d, op); + rc = xsm_hvm_param(XSM_TARGET, d, op); if ( rc ) goto param_fail8; diff --git a/xen/arch/x86/irq.c b/xen/arch/x86/irq.c index 238600a..095c17d 100644 --- a/xen/arch/x86/irq.c +++ b/xen/arch/x86/irq.c @@ -1874,7 +1874,7 @@ int map_domain_pirq( return 0; } - ret = xsm_map_domain_pirq(d, irq, data); + ret = xsm_map_domain_pirq(XSM_HOOK, d, irq, data); if ( ret ) { dprintk(XENLOG_G_ERR, "dom%d: could not permit access to irq %d mapping to pirq %d\n", diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c index 9a2acca..f2cf7d9 100644 --- a/xen/arch/x86/mm.c +++ b/xen/arch/x86/mm.c @@ -2716,7 +2716,7 @@ long do_mmuext_op( goto out; } - rc = xsm_mmuext_op(d, pg_owner); + rc = xsm_mmuext_op(XSM_TARGET, d, pg_owner); if ( rc ) { rcu_unlock_domain(pg_owner); @@ -2788,7 +2788,7 @@ long do_mmuext_op( break; } - if ( (rc = xsm_memory_pin_page(d, pg_owner, page)) != 0 ) + if ( (rc = xsm_memory_pin_page(XSM_HOOK, d, pg_owner, page)) != 0 ) { put_page_and_type(page); okay = 0; @@ -3245,7 +3245,7 @@ long do_mmu_update( } if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, pt_owner, pg_owner, xsm_needed); + rc = xsm_mmu_update(XSM_TARGET, d, pt_owner, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3364,7 +3364,7 @@ long do_mmu_update( xsm_needed |= XSM_MMU_MACHPHYS_UPDATE; if ( xsm_needed != xsm_checked ) { - rc = xsm_mmu_update(d, NULL, pg_owner, xsm_needed); + rc = xsm_mmu_update(XSM_TARGET, d, NULL, pg_owner, xsm_needed); if ( rc ) break; xsm_checked = xsm_needed; @@ -3932,7 +3932,7 @@ static int __do_update_va_mapping( perfc_incr(calls_to_update_va); - rc = xsm_update_va_mapping(d, pg_owner, val); + rc = xsm_update_va_mapping(XSM_TARGET, d, pg_owner, val); if ( rc ) return rc; @@ -4403,7 +4403,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_add_to_physmap(current->domain, d) ) + if ( xsm_add_to_physmap(XSM_TARGET, current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; @@ -4442,7 +4442,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_domain_memory_map(d); + rc = xsm_domain_memory_map(XSM_TARGET, d); if ( rc ) { rcu_unlock_domain(d); @@ -4517,7 +4517,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) XEN_GUEST_HANDLE_PARAM(e820entry_t) buffer_param; unsigned int i; - rc = xsm_machine_memory_map(); + rc = xsm_machine_memory_map(XSM_PRIV); if ( rc ) return rc; @@ -4601,9 +4601,9 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -ESRCH; if ( op == XENMEM_set_pod_target ) - rc = xsm_set_pod_target(d); + rc = xsm_set_pod_target(XSM_PRIV, d); else - rc = xsm_get_pod_target(d); + rc = xsm_get_pod_target(XSM_PRIV, d); if ( rc != 0 ) goto pod_target_out_unlock; diff --git a/xen/arch/x86/mm/mem_event.c b/xen/arch/x86/mm/mem_event.c index c2b3670..4222248 100644 --- a/xen/arch/x86/mm/mem_event.c +++ b/xen/arch/x86/mm/mem_event.c @@ -449,7 +449,7 @@ int do_mem_event_op(int op, uint32_t domain, void *arg) if ( ret ) return ret; - ret = xsm_mem_event_op(d, op); + ret = xsm_mem_event_op(XSM_TARGET, d, op); if ( ret ) goto out; @@ -502,7 +502,7 @@ int mem_event_domctl(struct domain *d, xen_domctl_mem_event_op_t *mec, { int rc; - rc = xsm_mem_event_control(d, mec->mode, mec->op); + rc = xsm_mem_event_control(XSM_PRIV, d, mec->mode, mec->op); if ( rc ) return rc; diff --git a/xen/arch/x86/mm/mem_sharing.c b/xen/arch/x86/mm/mem_sharing.c index 9229b83..5f3d319 100644 --- a/xen/arch/x86/mm/mem_sharing.c +++ b/xen/arch/x86/mm/mem_sharing.c @@ -1351,7 +1351,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_mem_sharing_op(XSM_TARGET, d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); @@ -1415,7 +1415,7 @@ int mem_sharing_memop(struct domain *d, xen_mem_sharing_op_t *mec) if ( rc ) return rc; - rc = xsm_mem_sharing_op(d, cd, mec->op); + rc = xsm_mem_sharing_op(XSM_TARGET, d, cd, mec->op); if ( rc ) { rcu_unlock_domain(cd); diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c index ea44e39..ff7b0c6 100644 --- a/xen/arch/x86/mm/paging.c +++ b/xen/arch/x86/mm/paging.c @@ -678,7 +678,7 @@ int paging_domctl(struct domain *d, xen_domctl_shadow_op_t *sc, return -EINVAL; } - rc = xsm_shadow_control(d, sc->op); + rc = xsm_shadow_control(XSM_HOOK, d, sc->op); if ( rc ) return rc; diff --git a/xen/arch/x86/msi.c b/xen/arch/x86/msi.c index 62ed290..e3f91c6 100644 --- a/xen/arch/x86/msi.c +++ b/xen/arch/x86/msi.c @@ -1016,7 +1016,7 @@ int pci_restore_msi_state(struct pci_dev *pdev) if (!pdev) return -EINVAL; - ret = xsm_resource_setup_pci((pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); + ret = xsm_resource_setup_pci(XSM_PRIV, (pdev->seg << 16) | (pdev->bus << 8) | pdev->devfn); if ( ret ) return ret; diff --git a/xen/arch/x86/physdev.c b/xen/arch/x86/physdev.c index 9c30245..9be1b47 100644 --- a/xen/arch/x86/physdev.c +++ b/xen/arch/x86/physdev.c @@ -232,7 +232,7 @@ int physdev_unmap_pirq(domid_t domid, int pirq) goto free_domain; } - ret = xsm_unmap_domain_pirq(d, domain_pirq_to_irq(d, pirq)); + ret = xsm_unmap_domain_pirq(XSM_TARGET, d, domain_pirq_to_irq(d, pirq)); if ( ret ) goto free_domain; @@ -423,7 +423,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_apic(XSM_PRIV, v->domain, cmd); if ( ret ) break; ret = ioapic_guest_read(apic.apic_physbase, apic.reg, &apic.value); @@ -437,7 +437,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) ret = -EFAULT; if ( copy_from_guest(&apic, arg, 1) != 0 ) break; - ret = xsm_apic(v->domain, cmd); + ret = xsm_apic(XSM_PRIV, v->domain, cmd); if ( ret ) break; ret = ioapic_guest_write(apic.apic_physbase, apic.reg, apic.value); @@ -453,7 +453,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) /* Use the APIC check since this dummy hypercall should still only * be called by the domain with access to program the ioapic */ - ret = xsm_apic(v->domain, cmd); + ret = xsm_apic(XSM_PRIV, v->domain, cmd); if ( ret ) break; @@ -578,7 +578,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) case PHYSDEVOP_pci_mmcfg_reserved: { struct physdev_pci_mmcfg_reserved info; - ret = xsm_resource_setup_misc(); + ret = xsm_resource_setup_misc(XSM_PRIV); if ( ret ) break; @@ -632,7 +632,7 @@ ret_t do_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( setup_gsi.gsi < 0 || setup_gsi.gsi >= nr_irqs_gsi ) break; - ret = xsm_resource_setup_gsi(setup_gsi.gsi); + ret = xsm_resource_setup_gsi(XSM_PRIV, setup_gsi.gsi); if ( ret ) break; diff --git a/xen/arch/x86/platform_hypercall.c b/xen/arch/x86/platform_hypercall.c index e17d64f..cdbf8e4 100644 --- a/xen/arch/x86/platform_hypercall.c +++ b/xen/arch/x86/platform_hypercall.c @@ -72,7 +72,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) if ( op->interface_version != XENPF_INTERFACE_VERSION ) return -EACCES; - ret = xsm_platform_op(op->cmd); + ret = xsm_platform_op(XSM_PRIV, op->cmd); if ( ret ) return ret; @@ -496,7 +496,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_plug_core(); + ret = xsm_resource_plug_core(XSM_HOOK); if ( ret ) break; @@ -521,7 +521,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) { int cpu = op->u.cpu_ol.cpuid; - ret = xsm_resource_unplug_core(); + ret = xsm_resource_unplug_core(XSM_HOOK); if ( ret ) break; @@ -550,7 +550,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_cpu_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_resource_plug_core(XSM_HOOK); if ( ret ) break; @@ -560,7 +560,7 @@ ret_t do_platform_op(XEN_GUEST_HANDLE_PARAM(xen_platform_op_t) u_xenpf_op) break; case XENPF_mem_hotadd: - ret = xsm_resource_plug_core(); + ret = xsm_resource_plug_core(XSM_HOOK); if ( ret ) break; diff --git a/xen/arch/x86/sysctl.c b/xen/arch/x86/sysctl.c index 5b0c4b7..23d0db1 100644 --- a/xen/arch/x86/sysctl.c +++ b/xen/arch/x86/sysctl.c @@ -184,14 +184,14 @@ long arch_do_sysctl( switch ( sysctl->u.cpu_hotplug.op ) { case XEN_SYSCTL_CPU_HOTPLUG_ONLINE: - ret = xsm_resource_plug_core(); + ret = xsm_resource_plug_core(XSM_HOOK); if ( ret ) break; ret = continue_hypercall_on_cpu( 0, cpu_up_helper, (void *)(unsigned long)cpu); break; case XEN_SYSCTL_CPU_HOTPLUG_OFFLINE: - ret = xsm_resource_unplug_core(); + ret = xsm_resource_unplug_core(XSM_HOOK); if ( ret ) break; ret = continue_hypercall_on_cpu( diff --git a/xen/arch/x86/traps.c b/xen/arch/x86/traps.c index 44a866e..7c180ea 100644 --- a/xen/arch/x86/traps.c +++ b/xen/arch/x86/traps.c @@ -1643,7 +1643,7 @@ static int pci_cfg_ok(struct domain *d, int write, int size) start |= (d->arch.pci_cf8 >> 16) & 0xF00; } end = start + size - 1; - if (xsm_pci_config_permission(d, machine_bdf, start, end, write)) + if (xsm_pci_config_permission(XSM_HOOK, d, machine_bdf, start, end, write)) return 0; return 1; } diff --git a/xen/common/domain.c b/xen/common/domain.c index fcf24e2..3f91f62 100644 --- a/xen/common/domain.c +++ b/xen/common/domain.c @@ -252,7 +252,7 @@ struct domain *domain_create( if ( !is_idle_domain(d) ) { - if ( (err = xsm_domain_create(d, ssidref)) != 0 ) + if ( (err = xsm_domain_create(XSM_HOOK, d, ssidref)) != 0 ) goto fail; d->is_paused_by_controller = 1; diff --git a/xen/common/domctl.c b/xen/common/domctl.c index 6f792e9..69e008a 100644 --- a/xen/common/domctl.c +++ b/xen/common/domctl.c @@ -264,7 +264,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) return -ESRCH; } - ret = xsm_domctl(d, op->cmd); + ret = xsm_domctl(XSM_OTHER, d, op->cmd); if ( ret ) goto domctl_out_unlock; @@ -580,7 +580,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_getdomaininfo(d); + ret = xsm_getdomaininfo(XSM_HOOK, d); if ( ret ) goto getdomaininfo_out; @@ -722,7 +722,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( pirq >= d->nr_pirqs ) ret = -EINVAL; - else if ( xsm_irq_permission(d, pirq, allow) ) + else if ( xsm_irq_permission(XSM_HOOK, d, pirq, allow) ) ret = -EPERM; else if ( allow ) ret = irq_permit_access(d, pirq); @@ -741,7 +741,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) if ( (mfn + nr_mfns - 1) < mfn ) /* wrap? */ break; - if ( xsm_iomem_permission(d, mfn, mfn + nr_mfns - 1, allow) ) + if ( xsm_iomem_permission(XSM_HOOK, d, mfn, mfn + nr_mfns - 1, allow) ) ret = -EPERM; else if ( allow ) ret = iomem_permit_access(d, mfn, mfn + nr_mfns - 1); @@ -773,7 +773,7 @@ long do_domctl(XEN_GUEST_HANDLE_PARAM(xen_domctl_t) u_domctl) break; } - ret = xsm_set_target(d, e); + ret = xsm_set_target(XSM_HOOK, d, e); if ( ret ) { put_domain(e); break; diff --git a/xen/common/event_channel.c b/xen/common/event_channel.c index 37947a9..1dc3d0e 100644 --- a/xen/common/event_channel.c +++ b/xen/common/event_channel.c @@ -175,7 +175,7 @@ static long evtchn_alloc_unbound(evtchn_alloc_unbound_t *alloc) ERROR_EXIT_DOM(port, d); chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, alloc->remote_dom); + rc = xsm_evtchn_unbound(XSM_TARGET, d, chn, alloc->remote_dom); if ( rc ) goto out; @@ -231,7 +231,7 @@ static long evtchn_bind_interdomain(evtchn_bind_interdomain_t *bind) (rchn->u.unbound.remote_domid != ld->domain_id) ) ERROR_EXIT_DOM(-EINVAL, rd); - rc = xsm_evtchn_interdomain(ld, lchn, rd, rchn); + rc = xsm_evtchn_interdomain(XSM_HOOK, ld, lchn, rd, rchn); if ( rc ) goto out; @@ -580,7 +580,7 @@ int evtchn_send(struct domain *d, unsigned int lport) return -EINVAL; } - ret = xsm_evtchn_send(ld, lchn); + ret = xsm_evtchn_send(XSM_HOOK, ld, lchn); if ( ret ) goto out; @@ -812,7 +812,7 @@ static long evtchn_status(evtchn_status_t *status) chn = evtchn_from_port(d, port); - rc = xsm_evtchn_status(d, chn); + rc = xsm_evtchn_status(XSM_TARGET, d, chn); if ( rc ) goto out; @@ -954,7 +954,7 @@ static long evtchn_reset(evtchn_reset_t *r) if ( d == NULL ) return -ESRCH; - rc = xsm_evtchn_reset(current->domain, d); + rc = xsm_evtchn_reset(XSM_TARGET, current->domain, d); if ( rc ) goto out; @@ -1101,7 +1101,7 @@ int alloc_unbound_xen_event_channel( goto out; chn = evtchn_from_port(d, port); - rc = xsm_evtchn_unbound(d, chn, remote_domid); + rc = xsm_evtchn_unbound(XSM_TARGET, d, chn, remote_domid); chn->state = ECS_UNBOUND; chn->xen_consumer = get_xen_consumer(notification_fn); diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c index eae9518..c58ea1b 100644 --- a/xen/common/grant_table.c +++ b/xen/common/grant_table.c @@ -552,7 +552,7 @@ __gnttab_map_grant_ref( return; } - rc = xsm_grant_mapref(ld, rd, op->flags); + rc = xsm_grant_mapref(XSM_HOOK, ld, rd, op->flags); if ( rc ) { rcu_unlock_domain(rd); @@ -872,7 +872,7 @@ __gnttab_unmap_common( return; } - rc = xsm_grant_unmapref(ld, rd); + rc = xsm_grant_unmapref(XSM_HOOK, ld, rd); if ( rc ) { rcu_unlock_domain(rd); @@ -1326,7 +1326,7 @@ gnttab_setup_table( goto out2; } - if ( xsm_grant_setup(current->domain, d) ) + if ( xsm_grant_setup(XSM_TARGET, current->domain, d) ) { op.status = GNTST_permission_denied; goto out2; @@ -1395,7 +1395,7 @@ gnttab_query_size( goto query_out; } - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_grant_query_size(XSM_TARGET, current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; @@ -1571,7 +1571,7 @@ gnttab_transfer( goto copyback; } - if ( xsm_grant_transfer(d, e) ) + if ( xsm_grant_transfer(XSM_HOOK, d, e) ) { put_gfn(d, gop.mfn); gop.status = GNTST_permission_denied; @@ -2010,7 +2010,7 @@ __gnttab_copy( PIN_FAIL(error_out, GNTST_bad_domain, "couldn't find %d\n", op->dest.domid); - rc = xsm_grant_copy(sd, dd); + rc = xsm_grant_copy(XSM_HOOK, sd, dd); if ( rc ) { rc = GNTST_permission_denied; @@ -2267,7 +2267,7 @@ gnttab_get_status_frames(XEN_GUEST_HANDLE_PARAM(gnttab_get_status_frames_t) uop, op.status = GNTST_bad_domain; goto out1; } - rc = xsm_grant_setup(current->domain, d); + rc = xsm_grant_setup(XSM_TARGET, current->domain, d); if ( rc ) { op.status = GNTST_permission_denied; goto out1; @@ -2318,7 +2318,7 @@ gnttab_get_version(XEN_GUEST_HANDLE_PARAM(gnttab_get_version_t uop)) if ( d == NULL ) return -ESRCH; - rc = xsm_grant_query_size(current->domain, d); + rc = xsm_grant_query_size(XSM_TARGET, current->domain, d); if ( rc ) { rcu_unlock_domain(d); diff --git a/xen/common/kexec.c b/xen/common/kexec.c index d4f6332..6dd20c6 100644 --- a/xen/common/kexec.c +++ b/xen/common/kexec.c @@ -852,7 +852,7 @@ static int do_kexec_op_internal(unsigned long op, unsigned long flags; int ret = -EINVAL; - ret = xsm_kexec(); + ret = xsm_kexec(XSM_PRIV); if ( ret ) return ret; diff --git a/xen/common/memory.c b/xen/common/memory.c index 7d3c326..c4d4ba8 100644 --- a/xen/common/memory.c +++ b/xen/common/memory.c @@ -336,7 +336,7 @@ static long memory_exchange(XEN_GUEST_HANDLE_PARAM(xen_memory_exchange_t) arg) goto fail_early; } - rc = xsm_memory_exchange(d); + rc = xsm_memory_exchange(XSM_TARGET, d); if ( rc ) { rcu_unlock_domain(d); @@ -585,7 +585,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) return start_extent; args.domain = d; - rc = xsm_memory_adjust_reservation(current->domain, d); + rc = xsm_memory_adjust_reservation(XSM_TARGET, current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -634,7 +634,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - rc = xsm_memory_stat_reservation(current->domain, d); + rc = xsm_memory_stat_reservation(XSM_TARGET, current->domain, d); if ( rc ) { rcu_unlock_domain(d); @@ -672,7 +672,7 @@ long do_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) return -ESRCH; - if ( xsm_remove_from_physmap(current->domain, d) ) + if ( xsm_remove_from_physmap(XSM_TARGET, current->domain, d) ) { rcu_unlock_domain(d); return -EPERM; diff --git a/xen/common/schedule.c b/xen/common/schedule.c index cfd173d..009ae96 100644 --- a/xen/common/schedule.c +++ b/xen/common/schedule.c @@ -921,7 +921,7 @@ ret_t do_sched_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) if ( d == NULL ) break; - ret = xsm_schedop_shutdown(current->domain, d); + ret = xsm_schedop_shutdown(XSM_DM_PRIV, current->domain, d); if ( ret ) { rcu_unlock_domain(d); diff --git a/xen/common/sysctl.c b/xen/common/sysctl.c index cbefb0e..2a53038 100644 --- a/xen/common/sysctl.c +++ b/xen/common/sysctl.c @@ -39,7 +39,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) if ( op->interface_version != XEN_SYSCTL_INTERFACE_VERSION ) return -EACCES; - ret = xsm_sysctl(op->cmd); + ret = xsm_sysctl(XSM_PRIV, op->cmd); if ( ret ) return ret; @@ -57,7 +57,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) { case XEN_SYSCTL_readconsole: { - ret = xsm_readconsole(op->u.readconsole.clear); + ret = xsm_readconsole(XSM_HOOK, op->u.readconsole.clear); if ( ret ) break; @@ -100,7 +100,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) if ( num_domains == op->u.getdomaininfolist.max_domains ) break; - ret = xsm_getdomaininfo(d); + ret = xsm_getdomaininfo(XSM_HOOK, d); if ( ret ) continue; @@ -231,7 +231,7 @@ long do_sysctl(XEN_GUEST_HANDLE_PARAM(xen_sysctl_t) u_sysctl) uint32_t *status, *ptr; unsigned long pfn; - ret = xsm_page_offline(op->u.page_offline.cmd); + ret = xsm_page_offline(XSM_HOOK, op->u.page_offline.cmd); if ( ret ) break; diff --git a/xen/common/xenoprof.c b/xen/common/xenoprof.c index ae0435b..e834f3d 100644 --- a/xen/common/xenoprof.c +++ b/xen/common/xenoprof.c @@ -680,7 +680,7 @@ ret_t do_xenoprof_op(int op, XEN_GUEST_HANDLE_PARAM(void) arg) return -EPERM; } - ret = xsm_profile(current->domain, op); + ret = xsm_profile(XSM_HOOK, current->domain, op); if ( ret ) return ret; diff --git a/xen/drivers/char/console.c b/xen/drivers/char/console.c index b2c3ee3..e9f696d 100644 --- a/xen/drivers/char/console.c +++ b/xen/drivers/char/console.c @@ -406,7 +406,7 @@ long do_console_io(int cmd, int count, XEN_GUEST_HANDLE_PARAM(char) buffer) long rc; unsigned int idx, len; - rc = xsm_console_io(current->domain, cmd); + rc = xsm_console_io(XSM_OTHER, current->domain, cmd); if ( rc ) return rc; diff --git a/xen/drivers/passthrough/iommu.c b/xen/drivers/passthrough/iommu.c index 9d13185..6a0f8d6 100644 --- a/xen/drivers/passthrough/iommu.c +++ b/xen/drivers/passthrough/iommu.c @@ -452,7 +452,7 @@ static int iommu_get_device_group( ((pdev->bus == bus) && (pdev->devfn == devfn)) ) continue; - if ( xsm_get_device_group((seg << 16) | (pdev->bus << 8) | pdev->devfn) ) + if ( xsm_get_device_group(XSM_HOOK, (seg << 16) | (pdev->bus << 8) | pdev->devfn) ) continue; sdev_id = ops->get_device_group_id(seg, pdev->bus, pdev->devfn); @@ -555,7 +555,7 @@ int iommu_do_domctl( u32 max_sdevs; XEN_GUEST_HANDLE_64(uint32) sdevs; - ret = xsm_get_device_group(domctl->u.get_device_group.machine_sbdf); + ret = xsm_get_device_group(XSM_HOOK, domctl->u.get_device_group.machine_sbdf); if ( ret ) break; @@ -583,7 +583,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_test_assign_device: - ret = xsm_test_assign_device(domctl->u.assign_device.machine_sbdf); + ret = xsm_test_assign_device(XSM_HOOK, domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -607,7 +607,7 @@ int iommu_do_domctl( break; } - ret = xsm_assign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_assign_device(XSM_HOOK, d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; @@ -626,7 +626,7 @@ int iommu_do_domctl( break; case XEN_DOMCTL_deassign_device: - ret = xsm_deassign_device(d, domctl->u.assign_device.machine_sbdf); + ret = xsm_deassign_device(XSM_HOOK, d, domctl->u.assign_device.machine_sbdf); if ( ret ) break; diff --git a/xen/drivers/passthrough/pci.c b/xen/drivers/passthrough/pci.c index a61a9ba..d75b7b7 100644 --- a/xen/drivers/passthrough/pci.c +++ b/xen/drivers/passthrough/pci.c @@ -380,7 +380,7 @@ int pci_add_device(u16 seg, u8 bus, u8 devfn, const struct pci_dev_info *info) pdev_type = "device"; } - ret = xsm_resource_plug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_resource_plug_pci(XSM_PRIV, (seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; @@ -496,7 +496,7 @@ int pci_remove_device(u16 seg, u8 bus, u8 devfn) struct pci_dev *pdev; int ret; - ret = xsm_resource_unplug_pci((seg << 16) | (bus << 8) | devfn); + ret = xsm_resource_unplug_pci(XSM_PRIV, (seg << 16) | (bus << 8) | devfn); if ( ret ) return ret; diff --git a/xen/include/xen/tmem_xen.h b/xen/include/xen/tmem_xen.h index 8dec5aa..ad1ddd5 100644 --- a/xen/include/xen/tmem_xen.h +++ b/xen/include/xen/tmem_xen.h @@ -329,12 +329,12 @@ static inline bool_t tmh_set_client_from_id( static inline bool_t tmh_current_permitted(void) { - return !xsm_tmem_op(); + return !xsm_tmem_op(XSM_HOOK); } static inline bool_t tmh_current_is_privileged(void) { - return !xsm_tmem_control(); + return !xsm_tmem_control(XSM_PRIV); } static inline uint8_t tmh_get_first_byte(pfp_t *pfp) diff --git a/xen/include/xsm/dummy.h b/xen/include/xsm/dummy.h index 019183e..2c750de 100644 --- a/xen/include/xsm/dummy.h +++ b/xen/include/xsm/dummy.h @@ -6,68 +6,132 @@ * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2, * as published by the Free Software Foundation. + * + * + * Each XSM hook implementing an access check should have its first parameter + * preceded by XSM_DEFAULT_ARG (or use XSM_DEFAULT_VOID if it has no + * arguments). The first non-declaration statement shold be XSM_ASSERT_ACTION + * with the expected type of the hook, which will either define or check the + * value of action. */ #include #include +/* Cannot use BUILD_BUG_ON here because the expressions we check are not + * considered constant at compile time. Instead, rely on constant propagation to + * inline out the calls to this invalid function, which will cause linker errors + * if references remain at link time. + */ +#define LINKER_BUG_ON(x) do { if (x) __xsm_action_mismatch_detected(); } while (0) +/* DO NOT implement this function; it is supposed to trigger link errors */ +void __xsm_action_mismatch_detected(void); + +#ifdef XSM_ENABLE + +/* In XSM_ENABLE builds, this header file is included from xsm/dummy.c, and + * contains static (not inline) functions compiled to the dummy XSM module. + * There is no xsm_default_t argument available, so the value from the assertion + * is used to initialize the variable. + */ +#define XSM_INLINE /* */ +#define XSM_DEFAULT_ARG /* */ +#define XSM_DEFAULT_VOID void +#define XSM_ASSERT_ACTION(def) xsm_default_t action = def; (void)action + +#else /* XSM_ENABLE */ + +/* In !XSM_ENABLE builds, this header file is included from xsm/xsm.h, and + * contains inline functions for each XSM hook. These functions also perform + * compile-time checks on the xsm_default_t argument to ensure that the behavior + * of the dummy XSM module is the same as the behavior with XSM disabled. + */ +#define XSM_INLINE inline +#define XSM_DEFAULT_ARG xsm_default_t action, +#define XSM_DEFAULT_VOID xsm_default_t action +#define XSM_ASSERT_ACTION(def) LINKER_BUG_ON(def != action) + +#endif /* XSM_ENABLE */ + +static inline int xsm_default_action(xsm_default_t action, struct domain *src, + struct domain *target) +{ + switch ( action ) { + case XSM_HOOK: + return 0; + case XSM_DM_PRIV: + if ( !IS_PRIV_FOR(src, target) ) + return -EPERM; + return 0; + case XSM_TARGET: + if ( src != target && !IS_PRIV_FOR(src, target) ) + return -EPERM; + return 0; + case XSM_PRIV: + if ( !IS_PRIV(src) ) + return -EPERM; + return 0; + default: + LINKER_BUG_ON(1); + return -EPERM; + } +} + static XSM_INLINE void xsm_security_domaininfo(struct domain *d, struct xen_domctl_getdomaininfo *info) { return; } -static XSM_INLINE int xsm_domain_create(struct domain *d, u32 ssidref) +static XSM_INLINE int xsm_domain_create(XSM_DEFAULT_ARG struct domain *d, u32 ssidref) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_getdomaininfo(struct domain *d) +static XSM_INLINE int xsm_getdomaininfo(XSM_DEFAULT_ARG struct domain *d) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_set_target(struct domain *d, struct domain *e) +static XSM_INLINE int xsm_set_target(XSM_DEFAULT_ARG struct domain *d, struct domain *e) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_domctl(struct domain *d, int cmd) +static XSM_INLINE int xsm_domctl(XSM_DEFAULT_ARG struct domain *d, int cmd) { + XSM_ASSERT_ACTION(XSM_OTHER); switch ( cmd ) { case XEN_DOMCTL_ioport_mapping: case XEN_DOMCTL_memory_mapping: case XEN_DOMCTL_bind_pt_irq: - case XEN_DOMCTL_unbind_pt_irq: { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - break; - } + case XEN_DOMCTL_unbind_pt_irq: + return xsm_default_action(XSM_DM_PRIV, current->domain, d); default: - if ( !IS_PRIV(current->domain) ) - return -EPERM; + return xsm_default_action(XSM_PRIV, current->domain, d); } - return 0; } -static XSM_INLINE int xsm_sysctl(int cmd) +static XSM_INLINE int xsm_sysctl(XSM_DEFAULT_ARG int cmd) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_readconsole(uint32_t clear) +static XSM_INLINE int xsm_readconsole(XSM_DEFAULT_ARG uint32_t clear) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_do_mca(void) +static XSM_INLINE int xsm_do_mca(XSM_DEFAULT_VOID) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } static XSM_INLINE int xsm_alloc_security_domain(struct domain *d) @@ -80,109 +144,109 @@ static XSM_INLINE void xsm_free_security_domain(struct domain *d) return; } -static XSM_INLINE int xsm_grant_mapref(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_grant_mapref(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2, uint32_t flags) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_grant_unmapref(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_grant_unmapref(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_grant_setup(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_grant_setup(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_grant_transfer(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_grant_transfer(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_grant_copy(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_grant_copy(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_grant_query_size(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_grant_query_size(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_memory_exchange(struct domain *d) +static XSM_INLINE int xsm_memory_exchange(XSM_DEFAULT_ARG struct domain *d) { - if ( d != current->domain && !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_memory_adjust_reservation(struct domain *d1, +static XSM_INLINE int xsm_memory_adjust_reservation(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_memory_stat_reservation(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_memory_stat_reservation(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_console_io(struct domain *d, int cmd) +static XSM_INLINE int xsm_console_io(XSM_DEFAULT_ARG struct domain *d, int cmd) { -#ifndef VERBOSE - if ( !IS_PRIV(current->domain) ) - return -EPERM; + XSM_ASSERT_ACTION(XSM_OTHER); +#ifdef VERBOSE + return xsm_default_action(XSM_HOOK, current->domain, NULL); +#else + return xsm_default_action(XSM_PRIV, current->domain, NULL); #endif - return 0; } -static XSM_INLINE int xsm_profile(struct domain *d, int op) +static XSM_INLINE int xsm_profile(XSM_DEFAULT_ARG struct domain *d, int op) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_kexec(void) +static XSM_INLINE int xsm_kexec(XSM_DEFAULT_VOID) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_schedop_shutdown(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_schedop_shutdown(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_DM_PRIV); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static XSM_INLINE int xsm_memory_pin_page(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2, struct page_info *page) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_evtchn_unbound(struct domain *d, struct evtchn *chn, +static XSM_INLINE int xsm_evtchn_unbound(XSM_DEFAULT_ARG struct domain *d, struct evtchn *chn, domid_t id2) { - if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_evtchn_interdomain(struct domain *d1, struct evtchn +static XSM_INLINE int xsm_evtchn_interdomain(XSM_DEFAULT_ARG struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, d1, d2); } static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn) @@ -190,23 +254,22 @@ static XSM_INLINE void xsm_evtchn_close_post(struct evtchn *chn) return; } -static XSM_INLINE int xsm_evtchn_send(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_evtchn_send(XSM_DEFAULT_ARG struct domain *d, struct evtchn *chn) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_evtchn_status(struct domain *d, struct evtchn *chn) +static XSM_INLINE int xsm_evtchn_status(XSM_DEFAULT_ARG struct domain *d, struct evtchn *chn) { - if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_evtchn_reset(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_evtchn_reset(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } static XSM_INLINE int xsm_alloc_security_evtchn(struct evtchn *chn) @@ -224,100 +287,100 @@ static XSM_INLINE char *xsm_show_security_evtchn(struct domain *d, const struct return NULL; } -static XSM_INLINE int xsm_get_pod_target(struct domain *d) +static XSM_INLINE int xsm_get_pod_target(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_set_pod_target(struct domain *d) +static XSM_INLINE int xsm_set_pod_target(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_get_device_group(uint32_t machine_bdf) +static XSM_INLINE int xsm_get_device_group(XSM_DEFAULT_ARG uint32_t machine_bdf) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_test_assign_device(uint32_t machine_bdf) +static XSM_INLINE int xsm_test_assign_device(XSM_DEFAULT_ARG uint32_t machine_bdf) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_assign_device(XSM_DEFAULT_ARG struct domain *d, uint32_t machine_bdf) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static XSM_INLINE int xsm_deassign_device(XSM_DEFAULT_ARG struct domain *d, uint32_t machine_bdf) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_resource_plug_core(void) +static XSM_INLINE int xsm_resource_plug_core(XSM_DEFAULT_VOID) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_unplug_core(void) +static XSM_INLINE int xsm_resource_unplug_core(XSM_DEFAULT_VOID) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_plug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_resource_plug_pci(XSM_DEFAULT_ARG uint32_t machine_bdf) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_unplug_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_resource_unplug_pci(XSM_DEFAULT_ARG uint32_t machine_bdf) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_setup_pci(uint32_t machine_bdf) +static XSM_INLINE int xsm_resource_setup_pci(XSM_DEFAULT_ARG uint32_t machine_bdf) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_setup_gsi(int gsi) +static XSM_INLINE int xsm_resource_setup_gsi(XSM_DEFAULT_ARG int gsi) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_resource_setup_misc(void) +static XSM_INLINE int xsm_resource_setup_misc(XSM_DEFAULT_VOID) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_page_offline(uint32_t cmd) +static XSM_INLINE int xsm_page_offline(XSM_DEFAULT_ARG uint32_t cmd) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_tmem_op(void) +static XSM_INLINE int xsm_tmem_op(XSM_DEFAULT_VOID) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_tmem_control(void) +static XSM_INLINE int xsm_tmem_control(XSM_DEFAULT_VOID) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } static XSM_INLINE long xsm_do_xsm_op(XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) @@ -330,187 +393,179 @@ static XSM_INLINE char *xsm_show_irq_sid(int irq) return NULL; } -static XSM_INLINE int xsm_map_domain_pirq(struct domain *d, int irq, void *data) +static XSM_INLINE int xsm_map_domain_pirq(XSM_DEFAULT_ARG struct domain *d, int irq, void *data) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_unmap_domain_pirq(struct domain *d, int irq) +static XSM_INLINE int xsm_unmap_domain_pirq(XSM_DEFAULT_ARG struct domain *d, int irq) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_irq_permission(struct domain *d, int pirq, uint8_t allow) +static XSM_INLINE int xsm_irq_permission(XSM_DEFAULT_ARG struct domain *d, int pirq, uint8_t allow) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_iomem_permission(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_iomem_permission(XSM_DEFAULT_ARG struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_iomem_mapping(struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static XSM_INLINE int xsm_iomem_mapping(XSM_DEFAULT_ARG struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_pci_config_permission(struct domain *d, uint32_t machine_bdf, +static XSM_INLINE int xsm_pci_config_permission(XSM_DEFAULT_ARG struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } #ifdef CONFIG_X86 -static XSM_INLINE int xsm_shadow_control(struct domain *d, uint32_t op) +static XSM_INLINE int xsm_shadow_control(XSM_DEFAULT_ARG struct domain *d, uint32_t op) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_hvm_param(struct domain *d, unsigned long op) +static XSM_INLINE int xsm_hvm_param(XSM_DEFAULT_ARG struct domain *d, unsigned long op) { - if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_hvm_set_pci_intx_level(struct domain *d) +static XSM_INLINE int xsm_hvm_set_pci_intx_level(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_DM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_hvm_set_isa_irq_level(struct domain *d) +static XSM_INLINE int xsm_hvm_set_isa_irq_level(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_DM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_hvm_set_pci_link_route(struct domain *d) +static XSM_INLINE int xsm_hvm_set_pci_link_route(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_DM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_hvm_inject_msi(struct domain *d) +static XSM_INLINE int xsm_hvm_inject_msi(XSM_DEFAULT_ARG struct domain *d) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_DM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_mem_event_control(struct domain *d, int mode, int op) +static XSM_INLINE int xsm_mem_event_control(XSM_DEFAULT_ARG struct domain *d, int mode, int op) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_mem_event_op(struct domain *d, int op) +static XSM_INLINE int xsm_mem_event_op(XSM_DEFAULT_ARG struct domain *d, int op) { - if ( !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_mem_sharing_op(struct domain *d, struct domain *cd, int op) +static XSM_INLINE int xsm_mem_sharing_op(XSM_DEFAULT_ARG struct domain *d, struct domain *cd, int op) { - if ( !IS_PRIV_FOR(current->domain, cd) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, cd); } -static XSM_INLINE int xsm_apic(struct domain *d, int cmd) +static XSM_INLINE int xsm_apic(XSM_DEFAULT_ARG struct domain *d, int cmd) { - if ( !IS_PRIV(d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, d, NULL); } -static XSM_INLINE int xsm_platform_op(uint32_t op) +static XSM_INLINE int xsm_platform_op(XSM_DEFAULT_ARG uint32_t op) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_machine_memory_map(void) +static XSM_INLINE int xsm_machine_memory_map(XSM_DEFAULT_VOID) { - if ( !IS_PRIV(current->domain) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_PRIV); + return xsm_default_action(action, current->domain, NULL); } -static XSM_INLINE int xsm_domain_memory_map(struct domain *d) +static XSM_INLINE int xsm_domain_memory_map(XSM_DEFAULT_ARG struct domain *d) { - if ( current->domain != d && !IS_PRIV_FOR(current->domain, d) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_mmu_update(struct domain *d, struct domain *t, +static XSM_INLINE int xsm_mmu_update(XSM_DEFAULT_ARG struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { + XSM_ASSERT_ACTION(XSM_TARGET); if ( t && d != t && !IS_PRIV_FOR(d, t) ) return -EPERM; - if ( d != f && !IS_PRIV_FOR(d, f) ) - return -EPERM; - return 0; + return xsm_default_action(action, d, f); } -static XSM_INLINE int xsm_mmuext_op(struct domain *d, struct domain *f) +static XSM_INLINE int xsm_mmuext_op(XSM_DEFAULT_ARG struct domain *d, struct domain *f) { - if ( d != f && !IS_PRIV_FOR(d, f) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d, f); } -static XSM_INLINE int xsm_update_va_mapping(struct domain *d, struct domain *f, +static XSM_INLINE int xsm_update_va_mapping(XSM_DEFAULT_ARG struct domain *d, struct domain *f, l1_pgentry_t pte) { - if ( d != f && !IS_PRIV_FOR(d, f) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d, f); } -static XSM_INLINE int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_add_to_physmap(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static XSM_INLINE int xsm_remove_from_physmap(XSM_DEFAULT_ARG struct domain *d1, struct domain *d2) { - if ( d1 != d2 && !IS_PRIV_FOR(d1, d2) ) - return -EPERM; - return 0; + XSM_ASSERT_ACTION(XSM_TARGET); + return xsm_default_action(action, d1, d2); } -static XSM_INLINE int xsm_bind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_bind_pt_irq(XSM_DEFAULT_ARG struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_unbind_pt_irq(struct domain *d, struct xen_domctl_bind_pt_irq *bind) +static XSM_INLINE int xsm_unbind_pt_irq(XSM_DEFAULT_ARG struct domain *d, struct xen_domctl_bind_pt_irq *bind) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_ioport_permission(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_ioport_permission(XSM_DEFAULT_ARG struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } -static XSM_INLINE int xsm_ioport_mapping(struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static XSM_INLINE int xsm_ioport_mapping(XSM_DEFAULT_ARG struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { - return 0; + XSM_ASSERT_ACTION(XSM_HOOK); + return xsm_default_action(action, current->domain, d); } #endif diff --git a/xen/include/xsm/xsm.h b/xen/include/xsm/xsm.h index 105201e..ce5ede8 100644 --- a/xen/include/xsm/xsm.h +++ b/xen/include/xsm/xsm.h @@ -27,6 +27,18 @@ typedef u32 xsm_magic_t; #define XSM_MAGIC 0x00000000 #endif +/* These annotations are used by callers and in dummy.h to document the + * default actions of XSM hooks. They should be compiled out otherwise. + */ +enum xsm_default { + XSM_HOOK, /* Guests can normally access the hypercall */ + XSM_DM_PRIV, /* Device model can perform on its target domain */ + XSM_TARGET, /* Can perform on self or your target domain */ + XSM_PRIV, /* Privileged - normally restricted to dom0 */ + XSM_OTHER /* Something more complex */ +}; +typedef enum xsm_default xsm_default_t; + extern char *policy_buffer; extern u32 policy_size; @@ -155,48 +167,48 @@ static inline void xsm_security_domaininfo (struct domain *d, xsm_ops->security_domaininfo(d, info); } -static inline int xsm_domain_create (struct domain *d, u32 ssidref) +static inline int xsm_domain_create (xsm_default_t def, struct domain *d, u32 ssidref) { return xsm_ops->domain_create(d, ssidref); } -static inline int xsm_getdomaininfo (struct domain *d) +static inline int xsm_getdomaininfo (xsm_default_t def, struct domain *d) { return xsm_ops->getdomaininfo(d); } -static inline int xsm_set_target (struct domain *d, struct domain *e) +static inline int xsm_set_target (xsm_default_t def, struct domain *d, struct domain *e) { return xsm_ops->set_target(d, e); } -static inline int xsm_domctl (struct domain *d, int cmd) +static inline int xsm_domctl (xsm_default_t def, struct domain *d, int cmd) { return xsm_ops->domctl(d, cmd); } -static inline int xsm_sysctl (int cmd) +static inline int xsm_sysctl (xsm_default_t def, int cmd) { return xsm_ops->sysctl(cmd); } -static inline int xsm_readconsole (uint32_t clear) +static inline int xsm_readconsole (xsm_default_t def, uint32_t clear) { return xsm_ops->readconsole(clear); } -static inline int xsm_do_mca(void) +static inline int xsm_do_mca(xsm_default_t def) { return xsm_ops->do_mca(); } -static inline int xsm_evtchn_unbound (struct domain *d1, struct evtchn *chn, +static inline int xsm_evtchn_unbound (xsm_default_t def, struct domain *d1, struct evtchn *chn, domid_t id2) { return xsm_ops->evtchn_unbound(d1, chn, id2); } -static inline int xsm_evtchn_interdomain (struct domain *d1, +static inline int xsm_evtchn_interdomain (xsm_default_t def, struct domain *d1, struct evtchn *chan1, struct domain *d2, struct evtchn *chan2) { return xsm_ops->evtchn_interdomain(d1, chan1, d2, chan2); @@ -207,48 +219,48 @@ static inline void xsm_evtchn_close_post (struct evtchn *chn) xsm_ops->evtchn_close_post(chn); } -static inline int xsm_evtchn_send (struct domain *d, struct evtchn *chn) +static inline int xsm_evtchn_send (xsm_default_t def, struct domain *d, struct evtchn *chn) { return xsm_ops->evtchn_send(d, chn); } -static inline int xsm_evtchn_status (struct domain *d, struct evtchn *chn) +static inline int xsm_evtchn_status (xsm_default_t def, struct domain *d, struct evtchn *chn) { return xsm_ops->evtchn_status(d, chn); } -static inline int xsm_evtchn_reset (struct domain *d1, struct domain *d2) +static inline int xsm_evtchn_reset (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->evtchn_reset(d1, d2); } -static inline int xsm_grant_mapref (struct domain *d1, struct domain *d2, +static inline int xsm_grant_mapref (xsm_default_t def, struct domain *d1, struct domain *d2, uint32_t flags) { return xsm_ops->grant_mapref(d1, d2, flags); } -static inline int xsm_grant_unmapref (struct domain *d1, struct domain *d2) +static inline int xsm_grant_unmapref (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->grant_unmapref(d1, d2); } -static inline int xsm_grant_setup (struct domain *d1, struct domain *d2) +static inline int xsm_grant_setup (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->grant_setup(d1, d2); } -static inline int xsm_grant_transfer (struct domain *d1, struct domain *d2) +static inline int xsm_grant_transfer (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->grant_transfer(d1, d2); } -static inline int xsm_grant_copy (struct domain *d1, struct domain *d2) +static inline int xsm_grant_copy (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->grant_copy(d1, d2); } -static inline int xsm_grant_query_size (struct domain *d1, struct domain *d2) +static inline int xsm_grant_query_size (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->grant_query_size(d1, d2); } @@ -278,60 +290,60 @@ static inline char *xsm_show_security_evtchn (struct domain *d, const struct evt return xsm_ops->show_security_evtchn(d, chn); } -static inline int xsm_get_pod_target (struct domain *d) +static inline int xsm_get_pod_target (xsm_default_t def, struct domain *d) { return xsm_ops->get_pod_target(d); } -static inline int xsm_set_pod_target (struct domain *d) +static inline int xsm_set_pod_target (xsm_default_t def, struct domain *d) { return xsm_ops->set_pod_target(d); } -static inline int xsm_memory_exchange (struct domain *d) +static inline int xsm_memory_exchange (xsm_default_t def, struct domain *d) { return xsm_ops->memory_exchange(d); } -static inline int xsm_memory_adjust_reservation (struct domain *d1, struct +static inline int xsm_memory_adjust_reservation (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->memory_adjust_reservation(d1, d2); } -static inline int xsm_memory_stat_reservation (struct domain *d1, +static inline int xsm_memory_stat_reservation (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->memory_stat_reservation(d1, d2); } -static inline int xsm_memory_pin_page(struct domain *d1, struct domain *d2, +static inline int xsm_memory_pin_page(xsm_default_t def, struct domain *d1, struct domain *d2, struct page_info *page) { return xsm_ops->memory_pin_page(d1, d2, page); } -static inline int xsm_remove_from_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_remove_from_physmap(xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->remove_from_physmap(d1, d2); } -static inline int xsm_console_io (struct domain *d, int cmd) +static inline int xsm_console_io (xsm_default_t def, struct domain *d, int cmd) { return xsm_ops->console_io(d, cmd); } -static inline int xsm_profile (struct domain *d, int op) +static inline int xsm_profile (xsm_default_t def, struct domain *d, int op) { return xsm_ops->profile(d, op); } -static inline int xsm_kexec (void) +static inline int xsm_kexec (xsm_default_t def) { return xsm_ops->kexec(); } -static inline int xsm_schedop_shutdown (struct domain *d1, struct domain *d2) +static inline int xsm_schedop_shutdown (xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->schedop_shutdown(d1, d2); } @@ -341,102 +353,102 @@ static inline char *xsm_show_irq_sid (int irq) return xsm_ops->show_irq_sid(irq); } -static inline int xsm_map_domain_pirq (struct domain *d, int irq, void *data) +static inline int xsm_map_domain_pirq (xsm_default_t def, struct domain *d, int irq, void *data) { return xsm_ops->map_domain_pirq(d, irq, data); } -static inline int xsm_unmap_domain_pirq (struct domain *d, int irq) +static inline int xsm_unmap_domain_pirq (xsm_default_t def, struct domain *d, int irq) { return xsm_ops->unmap_domain_pirq(d, irq); } -static inline int xsm_irq_permission (struct domain *d, int pirq, uint8_t allow) +static inline int xsm_irq_permission (xsm_default_t def, struct domain *d, int pirq, uint8_t allow) { return xsm_ops->irq_permission(d, pirq, allow); } -static inline int xsm_iomem_permission (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_iomem_permission (xsm_default_t def, struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return xsm_ops->iomem_permission(d, s, e, allow); } -static inline int xsm_iomem_mapping (struct domain *d, uint64_t s, uint64_t e, uint8_t allow) +static inline int xsm_iomem_mapping (xsm_default_t def, struct domain *d, uint64_t s, uint64_t e, uint8_t allow) { return xsm_ops->iomem_mapping(d, s, e, allow); } -static inline int xsm_pci_config_permission (struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) +static inline int xsm_pci_config_permission (xsm_default_t def, struct domain *d, uint32_t machine_bdf, uint16_t start, uint16_t end, uint8_t access) { return xsm_ops->pci_config_permission(d, machine_bdf, start, end, access); } -static inline int xsm_get_device_group(uint32_t machine_bdf) +static inline int xsm_get_device_group(xsm_default_t def, uint32_t machine_bdf) { return xsm_ops->get_device_group(machine_bdf); } -static inline int xsm_test_assign_device(uint32_t machine_bdf) +static inline int xsm_test_assign_device(xsm_default_t def, uint32_t machine_bdf) { return xsm_ops->test_assign_device(machine_bdf); } -static inline int xsm_assign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_assign_device(xsm_default_t def, struct domain *d, uint32_t machine_bdf) { return xsm_ops->assign_device(d, machine_bdf); } -static inline int xsm_deassign_device(struct domain *d, uint32_t machine_bdf) +static inline int xsm_deassign_device(xsm_default_t def, struct domain *d, uint32_t machine_bdf) { return xsm_ops->deassign_device(d, machine_bdf); } -static inline int xsm_resource_plug_pci (uint32_t machine_bdf) +static inline int xsm_resource_plug_pci (xsm_default_t def, uint32_t machine_bdf) { return xsm_ops->resource_plug_pci(machine_bdf); } -static inline int xsm_resource_unplug_pci (uint32_t machine_bdf) +static inline int xsm_resource_unplug_pci (xsm_default_t def, uint32_t machine_bdf) { return xsm_ops->resource_unplug_pci(machine_bdf); } -static inline int xsm_resource_plug_core (void) +static inline int xsm_resource_plug_core (xsm_default_t def) { return xsm_ops->resource_plug_core(); } -static inline int xsm_resource_unplug_core (void) +static inline int xsm_resource_unplug_core (xsm_default_t def) { return xsm_ops->resource_unplug_core(); } -static inline int xsm_resource_setup_pci (uint32_t machine_bdf) +static inline int xsm_resource_setup_pci (xsm_default_t def, uint32_t machine_bdf) { return xsm_ops->resource_setup_pci(machine_bdf); } -static inline int xsm_resource_setup_gsi (int gsi) +static inline int xsm_resource_setup_gsi (xsm_default_t def, int gsi) { return xsm_ops->resource_setup_gsi(gsi); } -static inline int xsm_resource_setup_misc (void) +static inline int xsm_resource_setup_misc (xsm_default_t def) { return xsm_ops->resource_setup_misc(); } -static inline int xsm_page_offline(uint32_t cmd) +static inline int xsm_page_offline(xsm_default_t def, uint32_t cmd) { return xsm_ops->page_offline(cmd); } -static inline int xsm_tmem_op(void) +static inline int xsm_tmem_op(xsm_default_t def) { return xsm_ops->tmem_op(); } -static inline int xsm_tmem_control(void) +static inline int xsm_tmem_control(xsm_default_t def) { return xsm_ops->tmem_control(); } @@ -447,116 +459,116 @@ static inline long xsm_do_xsm_op (XEN_GUEST_HANDLE_PARAM(xsm_op_t) op) } #ifdef CONFIG_X86 -static inline int xsm_shadow_control (struct domain *d, uint32_t op) +static inline int xsm_shadow_control (xsm_default_t def, struct domain *d, uint32_t op) { return xsm_ops->shadow_control(d, op); } -static inline int xsm_hvm_param (struct domain *d, unsigned long op) +static inline int xsm_hvm_param (xsm_default_t def, struct domain *d, unsigned long op) { return xsm_ops->hvm_param(d, op); } -static inline int xsm_hvm_set_pci_intx_level (struct domain *d) +static inline int xsm_hvm_set_pci_intx_level (xsm_default_t def, struct domain *d) { return xsm_ops->hvm_set_pci_intx_level(d); } -static inline int xsm_hvm_set_isa_irq_level (struct domain *d) +static inline int xsm_hvm_set_isa_irq_level (xsm_default_t def, struct domain *d) { return xsm_ops->hvm_set_isa_irq_level(d); } -static inline int xsm_hvm_set_pci_link_route (struct domain *d) +static inline int xsm_hvm_set_pci_link_route (xsm_default_t def, struct domain *d) { return xsm_ops->hvm_set_pci_link_route(d); } -static inline int xsm_hvm_inject_msi (struct domain *d) +static inline int xsm_hvm_inject_msi (xsm_default_t def, struct domain *d) { return xsm_ops->hvm_inject_msi(d); } -static inline int xsm_mem_event_control (struct domain *d, int mode, int op) +static inline int xsm_mem_event_control (xsm_default_t def, struct domain *d, int mode, int op) { return xsm_ops->mem_event_control(d, mode, op); } -static inline int xsm_mem_event_op (struct domain *d, int op) +static inline int xsm_mem_event_op (xsm_default_t def, struct domain *d, int op) { return xsm_ops->mem_event_op(d, op); } -static inline int xsm_mem_sharing_op (struct domain *d, struct domain *cd, int op) +static inline int xsm_mem_sharing_op (xsm_default_t def, struct domain *d, struct domain *cd, int op) { return xsm_ops->mem_sharing_op(d, cd, op); } -static inline int xsm_apic (struct domain *d, int cmd) +static inline int xsm_apic (xsm_default_t def, struct domain *d, int cmd) { return xsm_ops->apic(d, cmd); } -static inline int xsm_memtype (uint32_t access) +static inline int xsm_memtype (xsm_default_t def, uint32_t access) { return xsm_ops->memtype(access); } -static inline int xsm_platform_op (uint32_t op) +static inline int xsm_platform_op (xsm_default_t def, uint32_t op) { return xsm_ops->platform_op(op); } -static inline int xsm_machine_memory_map(void) +static inline int xsm_machine_memory_map(xsm_default_t def) { return xsm_ops->machine_memory_map(); } -static inline int xsm_domain_memory_map(struct domain *d) +static inline int xsm_domain_memory_map(xsm_default_t def, struct domain *d) { return xsm_ops->domain_memory_map(d); } -static inline int xsm_mmu_update (struct domain *d, struct domain *t, +static inline int xsm_mmu_update (xsm_default_t def, struct domain *d, struct domain *t, struct domain *f, uint32_t flags) { return xsm_ops->mmu_update(d, t, f, flags); } -static inline int xsm_mmuext_op (struct domain *d, struct domain *f) +static inline int xsm_mmuext_op (xsm_default_t def, struct domain *d, struct domain *f) { return xsm_ops->mmuext_op(d, f); } -static inline int xsm_update_va_mapping(struct domain *d, struct domain *f, +static inline int xsm_update_va_mapping(xsm_default_t def, struct domain *d, struct domain *f, l1_pgentry_t pte) { return xsm_ops->update_va_mapping(d, f, pte); } -static inline int xsm_add_to_physmap(struct domain *d1, struct domain *d2) +static inline int xsm_add_to_physmap(xsm_default_t def, struct domain *d1, struct domain *d2) { return xsm_ops->add_to_physmap(d1, d2); } -static inline int xsm_bind_pt_irq(struct domain *d, +static inline int xsm_bind_pt_irq(xsm_default_t def, struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return xsm_ops->bind_pt_irq(d, bind); } -static inline int xsm_unbind_pt_irq(struct domain *d, +static inline int xsm_unbind_pt_irq(xsm_default_t def, struct domain *d, struct xen_domctl_bind_pt_irq *bind) { return xsm_ops->unbind_pt_irq(d, bind); } -static inline int xsm_ioport_permission (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_ioport_permission (xsm_default_t def, struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return xsm_ops->ioport_permission(d, s, e, allow); } -static inline int xsm_ioport_mapping (struct domain *d, uint32_t s, uint32_t e, uint8_t allow) +static inline int xsm_ioport_mapping (xsm_default_t def, struct domain *d, uint32_t s, uint32_t e, uint8_t allow) { return xsm_ops->ioport_mapping(d, s, e, allow); } @@ -576,7 +588,6 @@ extern void xsm_fixup_ops(struct xsm_operations *ops); #else /* XSM_ENABLE */ -#define XSM_INLINE inline #include static inline int xsm_init (unsigned long *module_map, -- 1.7.11.7 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Fri Nov 30 21:34:17 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 30 Nov 2012 21:34:17 +0000 Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TeYDf-0007jN-Vo; Fri, 30 Nov 2012 21:33:59 +0000 Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TeYDd-0007jI-H2 for xen-devel@lists.xen.org; Fri, 30 Nov 2012 21:33:58 +0000 Received: from [85.158.139.83:53212] by server-12.bemta-5.messagelabs.com id B9/E2-02886-44629B05; Fri, 30 Nov 2012 21:33:56 +0000 X-Env-Sender: ketuzsezr@gmail.com X-Msg-Ref: server-3.tower-182.messagelabs.com!1354311230!27877415!1 X-Originating-IP: [209.85.213.41] X-SpamReason: No, hits=0.8 required=7.0 tests=BODY_RANDOM_LONG, RCVD_BY_IP X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 12136 invoked from network); 30 Nov 2012 21:33:51 -0000 Received: from mail-yh0-f41.google.com (HELO mail-yh0-f41.google.com) (209.85.213.41) by server-3.tower-182.messagelabs.com with RC4-SHA encrypted SMTP; 30 Nov 2012 21:33:51 -0000 Received: by mail-yh0-f41.google.com with SMTP id 47so168834yhr.28 for ; Fri, 30 Nov 2012 13:33:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:date:from:to:cc:subject:message-id:references:mime-version :content-type:content-disposition:in-reply-to:user-agent; bh=UquN6dEG7CmxfQqy9pmuhjccL4Mvwa+mrBSJnj0G+Do=; b=onxYyTGGaaMXucyCBygl1S9tdHO47gGyQp6mBxzW84r5bJkAfrA4uz89TAjyXBbezi 2h1unTZFcsfCCkhBHILg47jYWqMSjnwZPMjj/AvDckNhSlMmSqnMuZ6AgxFjvS/fniNM a+7mHqBPSGntNurKBWQGkylOe35VGuJJNerP2c+G1pFNg0xbE+o4xYMd854hq+FVKsZ5 qYOrp2TIS2tVtzxPjGMwjUJaHiAez/wHxo9Y+VQD24NmqalZgYfZm4bsOzSR9wkX49UF ZDpxyUgKVue6pAq1CF2SroUgYihCqVXG5Yn6YytIDTjBBMKEK6w5MBeiGtFa1COFtFEd 5Czw== Received: by 10.236.73.70 with SMTP id u46mr3041681yhd.59.1354311230432; Fri, 30 Nov 2012 13:33:50 -0800 (PST) Received: from phenom.dumpdata.com (50-195-21-189-static.hfc.comcastbusiness.net. [50.195.21.189]) by mx.google.com with ESMTPS id v8sm6094483yhi.15.2012.11.30.13.33.49 (version=TLSv1/SSLv3 cipher=OTHER); Fri, 30 Nov 2012 13:33:49 -0800 (PST) Date: Fri, 30 Nov 2012 16:33:47 -0500 From: Konrad Rzeszutek Wilk To: Marek Marczykowski , ben@guthro.net Message-ID: <20121130213345.GA4715@phenom.dumpdata.com> References: <50B7AF8A.5010304@invisiblethingslab.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <50B7AF8A.5010304@invisiblethingslab.com> User-Agent: Mutt/1.5.21 (2010-09-15) Cc: xen-devel Subject: Re: [Xen-devel] Only CPU0 active after ACPI S3, xen 4.1.3 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 Thu, Nov 29, 2012 at 07:55:06PM +0100, Marek Marczykowski wrote: > Hi all, > > After resume from ACPI S3 system has only CPU0 enabled, every vCPU from every > domain works on CPU0 [1]. When trying to pin some vCPU to CPU1 got error: > xl vcpu-pin testvm 1 1 > libxl: error: libxl.c:2565:libxl_set_vcpuaffinity setting vcpu affinity: > Invalid argument > > What went wrong? How can I reenable CPU1-CPU3? I think Ben had found some issues with this in the past? CC-ing him here. > > System info: > xen 4.1.3 > linux 3.4.18 with acpi-s3 patches from Konrad's git > Processor: Intel i5-2520M > > dmesg from dom0 and hypervisor attached. > > BTW Are there any plans to upstream acpi-s3 patches? > > [1] xl vcpu-list: > Name ID VCPU CPU State Time(s) CPU Affinity > dom0 0 0 0 r-- 1347.8 any cpu > dom0 0 1 0 -b- 594.4 any cpu > dom0 0 2 0 -b- 421.1 any cpu > dom0 0 3 0 -b- 432.6 any cpu > netvm 1 0 0 -b- 596.6 any cpu > netvm 1 1 0 -b- 363.7 any cpu > firewallvm 2 0 0 -b- 170.5 any cpu > firewallvm 2 1 0 -b- 122.5 any cpu > devel17 3 0 0 -b- 137.0 any cpu > devel17 3 1 0 -b- 112.9 any cpu > devel17 3 2 0 -b- 97.9 any cpu > devel17 3 3 0 -b- 116.0 any cpu > vm2 4 0 0 -b- 418.6 any cpu > vm2 4 1 0 -b- 390.2 any cpu > private 5 0 0 -b- 175.9 any cpu > private 5 1 0 -b- 161.6 any cpu > mail 6 0 0 -b- 1587.1 any cpu > mail 6 1 0 -b- 1717.5 any cpu > testvm 7 0 0 -b- 73.0 any cpu > testvm 7 1 0 -b- 68.9 any cpu > testvm 7 2 0 -b- 51.4 any cpu > testvm 7 3 0 -b- 67.1 any cpu > disp1 8 0 0 -b- 199.9 any cpu > > > -- > Best Regards / Pozdrawiam, > Marek Marczykowski > Invisible Things Lab > [ 0.000000] Initializing cgroup subsys cpuset > [ 0.000000] Initializing cgroup subsys cpu > [ 0.000000] Linux version 3.4.18-2.pvops.qubes.x86_64 (user@nemezis.marmarek.net) (gcc version 4.4.5 20101112 (Red Hat 4.4.5-2) (GCC) ) #1 SMP Wed Nov 7 22:47:21 EST 2012 > [ 0.000000] Command line: ro root=/dev/mapper/vg_dom0-lv_root rd_LUKS_UUID=luks-400336fa-c7c4-4be3-a244-c909aa16a18c rd_LVM_LV=vg_dom0/lv_root rd_LVM_LV=vg_dom0/lv_swap rd_NO_MD rd_NO_DM LANG=en_US.UTF-8 SYSFONT=latarcyrheb-sun16 KEYTABLE=pl2 rhgb quiet max_loop=255 > [ 0.000000] Freeing 9a-100 pfn range: 102 pages freed > [ 0.000000] 1-1 mapping on 9a->100 > [ 0.000000] Freeing 7eea-7f67 pfn range: 125 pages freed > [ 0.000000] 1-1 mapping on 7eea->7f67 > [ 0.000000] Freeing 7f70-7f76 pfn range: 6 pages freed > [ 0.000000] 1-1 mapping on 7f70->7f76 > [ 0.000000] Freeing 7f78-8000 pfn range: 136 pages freed > [ 0.000000] 1-1 mapping on 7f78->8000 > [ 0.000000] Freeing dffd-e000 pfn range: 3 pages freed > [ 0.000000] 1-1 mapping on dffd->e000 > [ 0.000000] Freeing 20000-20200 pfn range: 512 pages freed > [ 0.000000] 1-1 mapping on 20000->20200 > [ 0.000000] Freeing 40000-40200 pfn range: 512 pages freed > [ 0.000000] 1-1 mapping on 40000->40200 > [ 0.000000] Freeing c83b4-c840a pfn range: 86 pages freed > [ 0.000000] 1-1 mapping on c83b4->c840a > [ 0.000000] Freeing c840e-c840f pfn range: 1 pages freed > [ 0.000000] 1-1 mapping on c840e->c840f > [ 0.000000] Freeing c8411-c8414 pfn range: 3 pages freed > [ 0.000000] 1-1 mapping on c8411->c8414 > [ 0.000000] Freeing c841e-c8428 pfn range: 10 pages freed > [ 0.000000] 1-1 mapping on c841e->c8428 > [ 0.000000] Freeing c8432-c8436 pfn range: 4 pages freed > [ 0.000000] 1-1 mapping on c8432->c8436 > [ 0.000000] Freeing cac00-100000 pfn range: 218112 pages freed > [ 0.000000] 1-1 mapping on cac00->100000 > [ 0.000000] Released 219612 pages of unused memory > [ 0.000000] Set 219612 page(s) to 1-1 mapping > [ 0.000000] BIOS-provided physical RAM map: > [ 0.000000] Xen: 0000000000000000 - 000000000009a000 (usable) > [ 0.000000] Xen: 000000000009a800 - 0000000000100000 (reserved) > [ 0.000000] Xen: 0000000000100000 - 0000000007eea000 (usable) > [ 0.000000] Xen: 0000000007eea000 - 0000000007f67000 (ACPI NVS) > [ 0.000000] Xen: 0000000007f67000 - 0000000007f70000 (usable) > [ 0.000000] Xen: 0000000007f70000 - 0000000007f76000 (ACPI NVS) > [ 0.000000] Xen: 0000000007f76000 - 0000000007f78000 (usable) > [ 0.000000] Xen: 0000000007f78000 - 0000000008000000 (ACPI NVS) > [ 0.000000] Xen: 0000000008000000 - 000000000dffd000 (usable) > [ 0.000000] Xen: 000000000dffd000 - 000000000e000000 (ACPI data) > [ 0.000000] Xen: 000000000e000000 - 0000000020000000 (usable) > [ 0.000000] Xen: 0000000020000000 - 0000000020200000 (reserved) > [ 0.000000] Xen: 0000000020200000 - 0000000040000000 (usable) > [ 0.000000] Xen: 0000000040000000 - 0000000040200000 (reserved) > [ 0.000000] Xen: 0000000040200000 - 00000000c83b4000 (usable) > [ 0.000000] Xen: 00000000c83b4000 - 00000000c840a000 (reserved) > [ 0.000000] Xen: 00000000c840a000 - 00000000c840e000 (usable) > [ 0.000000] Xen: 00000000c840e000 - 00000000c840f000 (reserved) > [ 0.000000] Xen: 00000000c840f000 - 00000000c8411000 (usable) > [ 0.000000] Xen: 00000000c8411000 - 00000000c8414000 (reserved) > [ 0.000000] Xen: 00000000c8414000 - 00000000c841e000 (usable) > [ 0.000000] Xen: 00000000c841e000 - 00000000c8428000 (reserved) > [ 0.000000] Xen: 00000000c8428000 - 00000000c8432000 (usable) > [ 0.000000] Xen: 00000000c8432000 - 00000000c8436000 (reserved) > [ 0.000000] Xen: 00000000c8436000 - 00000000cac00000 (usable) > [ 0.000000] Xen: 00000000cb800000 - 00000000cfa00000 (reserved) > [ 0.000000] Xen: 00000000fec00000 - 00000000fec01000 (reserved) > [ 0.000000] Xen: 00000000fed1c000 - 00000000fed20000 (reserved) > [ 0.000000] Xen: 00000000fee00000 - 00000000fee01000 (reserved) > [ 0.000000] Xen: 00000000ffc00000 - 00000000ffc20000 (reserved) > [ 0.000000] Xen: 0000000100000000 - 000000042e000000 (usable) > [ 0.000000] NX (Execute Disable) protection: active > [ 0.000000] DMI 2.6 present. > [ 0.000000] DMI: Dell Inc. Latitude E6420/0K0DNP, BIOS A13 05/17/2012 > [ 0.000000] e820 update range: 0000000000000000 - 0000000000010000 (usable) ==> (reserved) > [ 0.000000] e820 remove range: 00000000000a0000 - 0000000000100000 (usable) > [ 0.000000] No AGP bridge found > [ 0.000000] last_pfn = 0x42e000 max_arch_pfn = 0x400000000 > [ 0.000000] x2apic enabled by BIOS, switching to x2apic ops > [ 0.000000] last_pfn = 0xcac00 max_arch_pfn = 0x400000000 > [ 0.000000] found SMP MP-table at [ffff8800000f1ad0] f1ad0 > [ 0.000000] initial memory mapped : 0 - 04ade000 > [ 0.000000] Base memory trampoline at [ffff880000095000] 95000 size 20480 > [ 0.000000] init_memory_mapping: 0000000000000000-00000000cac00000 > [ 0.000000] 0000000000 - 00cac00000 page 4k > [ 0.000000] kernel direct mapping tables up to 0xcabfffff @ [mem 0x009a5000-0x00ffffff] > [ 0.000000] xen: setting RW the range fc4000 - 1000000 > [ 0.000000] init_memory_mapping: 0000000100000000-000000042e000000 > [ 0.000000] 0100000000 - 042e000000 page 4k > [ 0.000000] kernel direct mapping tables up to 0x42dffffff @ [mem 0xc9282000-0xcabfffff] > [ 0.000000] xen: setting RW the range cabff000 - cac00000 > [ 0.000000] RAMDISK: 01e13000 - 04ade000 > [ 0.000000] ACPI: RSDP 00000000000fe300 00024 (v02 DELL ) > [ 0.000000] ACPI: XSDT 000000000dffee18 0007C (v01 DELL CBX3 06222004 MSFT 00010013) > [ 0.000000] ACPI: FACP 0000000007f90d98 000F4 (v04 DELL CBX3 06222004 MSFT 00010013) > [ 0.000000] ACPI Warning: 32/64 FACS address mismatch in FADT - two FACS tables! (20120320/tbfadt-378) > [ 0.000000] ACPI Warning: 32/64X FACS address mismatch in FADT - 0x07FEDE40/0x0000000007FEDD40, using 32 (20120320/tbfadt-502) > [ 0.000000] ACPI: DSDT 0000000007f5e018 08834 (v02 INT430 SYSFexxx 00001001 INTL 20090903) > [ 0.000000] ACPI: FACS 0000000007fede40 00040 > [ 0.000000] ACPI: APIC 000000000dffdf18 000CC (v02 DELL CBX3 06222004 MSFT 00010013) > [ 0.000000] ACPI: TCPA 0000000007feed18 00032 (v02 00000000 00000000) > [ 0.000000] ACPI: SSDT 0000000007f91a98 002F9 (v01 DELLTP TPM 00003000 INTL 20090903) > [ 0.000000] ACPI: MCFG 0000000007feec98 0003C (v01 DELL SNDYBRDG 06222004 MSFT 00000097) > [ 0.000000] ACPI: HPET 0000000007feec18 00038 (v01 A M I PCHHPET 06222004 AMI. 00000003) > [ 0.000000] ACPI: BOOT 0000000007feeb98 00028 (v01 DELL CBX3 06222004 AMI 00010013) > [ 0.000000] ACPI: SSDT 0000000007f75018 00804 (v01 PmRef Cpu0Ist 00003000 INTL 20090903) > [ 0.000000] ACPI: SSDT 0000000007f74018 00996 (v01 PmRef CpuPm 00003000 INTL 20090903) > [ 0.000000] ACPI: XMAR 0000000007f90c18 000E8 (v01 INTEL SNB 00000001 INTL 00000001) > [ 0.000000] ACPI: SLIC 0000000007f7ec18 00176 (v03 DELL CBX3 06222004 MSFT 00010013) > [ 0.000000] ACPI: Local APIC address 0xfee00000 > [ 0.000000] Setting APIC routing to cluster x2apic. > [ 0.000000] Zone PFN ranges: > [ 0.000000] DMA 0x00000010 -> 0x00001000 > [ 0.000000] DMA32 0x00001000 -> 0x00100000 > [ 0.000000] Normal 0x00100000 -> 0x0042e000 > [ 0.000000] Movable zone start PFN for each node > [ 0.000000] Early memory PFN ranges > [ 0.000000] 0: 0x00000010 -> 0x0000009a > [ 0.000000] 0: 0x00000100 -> 0x00007eea > [ 0.000000] 0: 0x00007f67 -> 0x00007f70 > [ 0.000000] 0: 0x00007f76 -> 0x00007f78 > [ 0.000000] 0: 0x00008000 -> 0x0000dffd > [ 0.000000] 0: 0x0000e000 -> 0x00020000 > [ 0.000000] 0: 0x00020200 -> 0x00040000 > [ 0.000000] 0: 0x00040200 -> 0x000c83b4 > [ 0.000000] 0: 0x000c840a -> 0x000c840e > [ 0.000000] 0: 0x000c840f -> 0x000c8411 > [ 0.000000] 0: 0x000c8414 -> 0x000c841e > [ 0.000000] 0: 0x000c8428 -> 0x000c8432 > [ 0.000000] 0: 0x000c8436 -> 0x000cac00 > [ 0.000000] 0: 0x00100000 -> 0x0042e000 > [ 0.000000] On node 0 totalpages: 4163092 > [ 0.000000] DMA zone: 56 pages used for memmap > [ 0.000000] DMA zone: 1572 pages reserved > [ 0.000000] DMA zone: 2350 pages, LIFO batch:0 > [ 0.000000] DMA32 zone: 14280 pages used for memmap > [ 0.000000] DMA32 zone: 810690 pages, LIFO batch:31 > [ 0.000000] Normal zone: 45584 pages used for memmap > [ 0.000000] Normal zone: 3288560 pages, LIFO batch:31 > [ 0.000000] ACPI: PM-Timer IO Port: 0x408 > [ 0.000000] ACPI: Local APIC address 0xfee00000 > [ 0.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x00] enabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x03] lapic_id[0x01] enabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x04] lapic_id[0x03] enabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x05] lapic_id[0x04] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x06] lapic_id[0x05] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x07] lapic_id[0x06] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x08] lapic_id[0x07] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x09] lapic_id[0x08] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0a] lapic_id[0x09] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0b] lapic_id[0x0a] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0c] lapic_id[0x0b] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0d] lapic_id[0x0c] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0e] lapic_id[0x0d] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x0f] lapic_id[0x0e] disabled) > [ 0.000000] ACPI: LAPIC (acpi_id[0x10] lapic_id[0x0f] disabled) > [ 0.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0]) > [ 0.000000] IOAPIC[0]: apic_id 2, version 253, address 0xfec00000, GSI 0-253 > [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl) > [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high level) > [ 0.000000] ACPI: IRQ0 used by override. > [ 0.000000] ACPI: IRQ2 used by override. > [ 0.000000] ACPI: IRQ9 used by override. > [ 0.000000] Using ACPI (MADT) for SMP configuration information > [ 0.000000] ACPI: HPET id: 0x8086a701 base: 0xfed00000 > [ 0.000000] SMP: Allowing 16 CPUs, 12 hotplug CPUs > [ 0.000000] nr_irqs_gsi: 270 > [ 0.000000] Allocating PCI resources starting at cfa00000 (gap: cfa00000:2f200000) > [ 0.000000] Booting paravirtualized kernel on Xen > [ 0.000000] Xen version: 4.1.3 (preserve-AD) > [ 0.000000] setup_percpu: NR_CPUS:512 nr_cpumask_bits:512 nr_cpu_ids:16 nr_node_ids:1 > [ 0.000000] PERCPU: Embedded 28 pages/cpu @ffff8803e2800000 s82176 r8192 d24320 u131072 > [ 0.000000] pcpu-alloc: s82176 r8192 d24320 u131072 alloc=1*2097152 > [ 0.000000] pcpu-alloc: [0] 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 > [ 4.119805] Built 1 zonelists in Zone order, mobility grouping on. Total pages: 4101600 > [ 4.119809] Kernel command line: ro root=/dev/mapper/vg_dom0-lv_root rd_LUKS_UUID=luks-400336fa-c7c4-4be3-a244-c909aa16a18c rd_LVM_LV=vg_dom0/lv_root rd_LVM_LV=vg_dom0/lv_swap rd_NO_MD rd_NO_DM LANG=en_US.UTF-8 SYSFONT=latarcyrheb-sun16 KEYTABLE=pl2 rhgb quiet max_loop=255 > [ 4.119915] PID hash table entries: 4096 (order: 3, 32768 bytes) > [ 4.120928] Dentry cache hash table entries: 2097152 (order: 12, 16777216 bytes) > [ 4.124018] Inode-cache hash table entries: 1048576 (order: 11, 8388608 bytes) > [ 4.147064] Placing 64MB software IO TLB between ffff8803ce200000 - ffff8803d2200000 > [ 4.147066] software IO TLB at phys 0x3ce200000 - 0x3d2200000 > [ 4.181675] Memory: 14975940k/17530880k available (4557k kernel code, 878512k absent, 1676428k reserved, 4112k data, 552k init) > [ 4.181730] Hierarchical RCU implementation. > [ 4.181731] RCU dyntick-idle grace-period acceleration is enabled. > [ 4.181738] NR_IRQS:33024 nr_irqs:1024 16 > [ 4.181799] xen: sci override: global_irq=9 trigger=0 polarity=0 > [ 4.181801] xen: registering gsi 9 triggering 0 polarity 0 > [ 4.181809] xen: --> pirq=9 -> irq=9 (gsi=9) > [ 4.181829] xen: acpi sci 9 > [ 4.181831] xen: --> pirq=1 -> irq=1 (gsi=1) > [ 4.181834] xen: --> pirq=2 -> irq=2 (gsi=2) > [ 4.181836] xen: --> pirq=3 -> irq=3 (gsi=3) > [ 4.181838] xen: --> pirq=4 -> irq=4 (gsi=4) > [ 4.181840] xen: --> pirq=5 -> irq=5 (gsi=5) > [ 4.181843] xen: --> pirq=6 -> irq=6 (gsi=6) > [ 4.181845] xen: --> pirq=7 -> irq=7 (gsi=7) > [ 4.181847] xen: --> pirq=8 -> irq=8 (gsi=8) > [ 4.181849] xen: --> pirq=10 -> irq=10 (gsi=10) > [ 4.181851] xen: --> pirq=11 -> irq=11 (gsi=11) > [ 4.181854] xen: --> pirq=12 -> irq=12 (gsi=12) > [ 4.181856] xen: --> pirq=13 -> irq=13 (gsi=13) > [ 4.181858] xen: --> pirq=14 -> irq=14 (gsi=14) > [ 4.181860] xen: --> pirq=15 -> irq=15 (gsi=15) > [ 4.182986] Console: colour VGA+ 80x25 > [ 4.183012] console [tty0] enabled > [ 4.183026] Xen: using vcpuop timer interface > [ 4.183030] installing Xen timer for CPU 0 > [ 4.183048] Detected 2494.416 MHz processor. > [ 4.183052] Calibrating delay loop (skipped), value calculated using timer frequency.. 4988.83 BogoMIPS (lpj=9977664) > [ 4.183054] pid_max: default: 32768 minimum: 301 > [ 4.183090] Mount-cache hash table entries: 256 > [ 4.183222] Initializing cgroup subsys cpuacct > [ 4.183224] Initializing cgroup subsys devices > [ 4.183225] Initializing cgroup subsys freezer > [ 4.183227] Initializing cgroup subsys net_cls > [ 4.183228] Initializing cgroup subsys blkio > [ 4.183280] ENERGY_PERF_BIAS: Set to 'normal', was 'performance' > [ 4.183281] ENERGY_PERF_BIAS: View and update with x86_energy_perf_policy(8) > [ 4.183284] CPU: Physical Processor ID: 0 > [ 4.183285] CPU: Processor Core ID: 0 > [ 4.184454] ACPI: Core revision 20120320 > [ 4.194658] Performance Events: unsupported p6 CPU model 42 no PMU driver, software events only. > [ 4.194796] installing Xen timer for CPU 1 > [ 4.194988] installing Xen timer for CPU 2 > [ 4.195140] installing Xen timer for CPU 3 > [ 4.195232] Brought up 4 CPUs > [ 4.195477] devtmpfs: initialized > [ 4.199046] PM: Registering ACPI NVS region [mem 0x07eea000-0x07f66fff] (512000 bytes) > [ 4.199056] PM: Registering ACPI NVS region [mem 0x07f70000-0x07f75fff] (24576 bytes) > [ 4.199058] PM: Registering ACPI NVS region [mem 0x07f78000-0x07ffffff] (557056 bytes) > [ 4.199069] Dell Latitude E6420 series board detected. Selecting PCI-method for reboots. > [ 4.199104] Grant tables using version 2 layout. > [ 4.199114] Grant table initialized > [ 4.199158] dummy: > [ 4.199205] RTC time: 1:19:35, date: 11/29/12 > [ 4.199256] NET: Registered protocol family 16 > [ 4.199465] ACPI FADT declares the system doesn't support PCIe ASPM, so disable it > [ 4.199467] ACPI: bus type pci registered > [ 4.199548] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem 0xf8000000-0xfbffffff] (base 0xf8000000) > [ 4.199550] PCI: not using MMCONFIG > [ 4.199552] PCI: Using configuration type 1 for base access > [ 4.199559] dmi type 0xB1 record - unknown flag > [ 4.200155] bio: create slab at 0 > [ 4.200279] ACPI: Added _OSI(Module Device) > [ 4.200280] ACPI: Added _OSI(Processor Device) > [ 4.200282] ACPI: Added _OSI(3.0 _SCP Extensions) > [ 4.200283] ACPI: Added _OSI(Processor Aggregator Device) > [ 4.201815] ACPI: EC: Look up EC in DSDT > [ 4.206932] [Firmware Bug]: ACPI: BIOS _OSI(Linux) query ignored > [ 4.219266] ACPI: SSDT 00000000c8412798 00727 (v01 PmRef Cpu0Cst 00003001 INTL 20090903) > [ 4.219654] ACPI: Dynamic OEM Table Load: > [ 4.219657] ACPI: SSDT (null) 00727 (v01 PmRef Cpu0Cst 00003001 INTL 20090903) > [ 4.220118] ACPI: SSDT 00000000c8413a98 00303 (v01 PmRef ApIst 00003000 INTL 20090903) > [ 4.220555] ACPI: Dynamic OEM Table Load: > [ 4.220558] ACPI: SSDT (null) 00303 (v01 PmRef ApIst 00003000 INTL 20090903) > [ 4.220754] ACPI: SSDT 00000000c8411d98 00119 (v01 PmRef ApCst 00003000 INTL 20090903) > [ 4.221136] ACPI: Dynamic OEM Table Load: > [ 4.221138] ACPI: SSDT (null) 00119 (v01 PmRef ApCst 00003000 INTL 20090903) > [ 4.223275] ACPI: Interpreter enabled > [ 4.223278] ACPI: (supports S0 S3 S5) > [ 4.223294] ACPI: Using IOAPIC for interrupt routing > [ 4.223322] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem 0xf8000000-0xfbffffff] (base 0xf8000000) > [ 4.223846] PCI: MMCONFIG at [mem 0xf8000000-0xfbffffff] reserved in ACPI motherboard resources > [ 4.271283] ACPI: EC: GPE = 0x10, I/O: command/status = 0x934, data = 0x930 > [ 4.272424] ACPI: No dock devices found. > [ 4.272428] PCI: Using host bridge windows from ACPI; if necessary, use "pci=nocrs" and report a bug > [ 4.272988] \_SB_.PCI0:_OSC invalid UUID > [ 4.272989] _OSC request data:1 8 1f > [ 4.272992] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-3e]) > [ 4.273994] pci_root PNP0A08:00: host bridge window [io 0x0000-0x0cf7] > [ 4.273996] pci_root PNP0A08:00: host bridge window [io 0x0d00-0xffff] > [ 4.273998] pci_root PNP0A08:00: host bridge window [mem 0x000a0000-0x000bffff] > [ 4.274001] pci_root PNP0A08:00: host bridge window [mem 0xcfa00000-0xfeafffff] > [ 4.274003] pci_root PNP0A08:00: host bridge window [mem 0xfed40000-0xfed44fff] > [ 4.274031] PCI host bridge to bus 0000:00 > [ 4.274033] pci_bus 0000:00: root bus resource [io 0x0000-0x0cf7] > [ 4.274034] pci_bus 0000:00: root bus resource [io 0x0d00-0xffff] > [ 4.274036] pci_bus 0000:00: root bus resource [mem 0x000a0000-0x000bffff] > [ 4.274038] pci_bus 0000:00: root bus resource [mem 0xcfa00000-0xfeafffff] > [ 4.274040] pci_bus 0000:00: root bus resource [mem 0xfed40000-0xfed44fff] > [ 4.274054] pci 0000:00:00.0: [8086:0104] type 00 class 0x060000 > [ 4.274147] pci 0000:00:02.0: [8086:0126] type 00 class 0x030000 > [ 4.274174] pci 0000:00:02.0: reg 10: [mem 0xe1400000-0xe17fffff 64bit] > [ 4.274189] pci 0000:00:02.0: reg 18: [mem 0xd0000000-0xdfffffff 64bit pref] > [ 4.274200] pci 0000:00:02.0: reg 20: [io 0x4000-0x403f] > [ 4.274344] pci 0000:00:16.0: [8086:1c3a] type 00 class 0x078000 > [ 4.274394] pci 0000:00:16.0: reg 10: [mem 0xe2eb0000-0xe2eb000f 64bit] > [ 4.274563] pci 0000:00:16.0: PME# supported from D0 D3hot D3cold > [ 4.274636] pci 0000:00:19.0: [8086:1502] type 00 class 0x020000 > [ 4.274681] pci 0000:00:19.0: reg 10: [mem 0xe2e00000-0xe2e1ffff] > [ 4.274700] pci 0000:00:19.0: reg 14: [mem 0xe2e80000-0xe2e80fff] > [ 4.274719] pci 0000:00:19.0: reg 18: [io 0x4080-0x409f] > [ 4.274883] pci 0000:00:19.0: PME# supported from D0 D3hot D3cold > [ 4.274939] pci 0000:00:1a.0: [8086:1c2d] type 00 class 0x0c0320 > [ 4.274983] pci 0000:00:1a.0: reg 10: [mem 0xe2e70000-0xe2e703ff] > [ 4.275185] pci 0000:00:1a.0: PME# supported from D0 D3hot D3cold > [ 4.275243] pci 0000:00:1b.0: [8086:1c20] type 00 class 0x040300 > [ 4.275278] pci 0000:00:1b.0: reg 10: [mem 0xe2e60000-0xe2e63fff 64bit] > [ 4.275456] pci 0000:00:1b.0: PME# supported from D0 D3hot D3cold > [ 4.275509] pci 0000:00:1c.0: [8086:1c10] type 01 class 0x060400 > [ 4.275702] pci 0000:00:1c.0: PME# supported from D0 D3hot D3cold > [ 4.275760] pci 0000:00:1c.1: [8086:1c12] type 01 class 0x060400 > [ 4.275953] pci 0000:00:1c.1: PME# supported from D0 D3hot D3cold > [ 4.276011] pci 0000:00:1c.2: [8086:1c14] type 01 class 0x060400 > [ 4.276205] pci 0000:00:1c.2: PME# supported from D0 D3hot D3cold > [ 4.276264] pci 0000:00:1c.3: [8086:1c16] type 01 class 0x060400 > [ 4.276458] pci 0000:00:1c.3: PME# supported from D0 D3hot D3cold > [ 4.276520] pci 0000:00:1c.5: [8086:1c1a] type 01 class 0x060400 > [ 4.276711] pci 0000:00:1c.5: PME# supported from D0 D3hot D3cold > [ 4.276779] pci 0000:00:1d.0: [8086:1c26] type 00 class 0x0c0320 > [ 4.276823] pci 0000:00:1d.0: reg 10: [mem 0xe2e50000-0xe2e503ff] > [ 4.277025] pci 0000:00:1d.0: PME# supported from D0 D3hot D3cold > [ 4.277086] pci 0000:00:1f.0: [8086:1c4f] type 00 class 0x060100 > [ 4.277341] pci 0000:00:1f.2: [8086:1c03] type 00 class 0x010601 > [ 4.277391] pci 0000:00:1f.2: reg 10: [io 0x40d0-0x40d7] > [ 4.277410] pci 0000:00:1f.2: reg 14: [io 0x40c0-0x40c3] > [ 4.277429] pci 0000:00:1f.2: reg 18: [io 0x40b0-0x40b7] > [ 4.277449] pci 0000:00:1f.2: reg 1c: [io 0x40a0-0x40a3] > [ 4.277468] pci 0000:00:1f.2: reg 20: [io 0x4060-0x407f] > [ 4.277486] pci 0000:00:1f.2: reg 24: [mem 0xe2e40000-0xe2e407ff] > [ 4.277613] pci 0000:00:1f.2: PME# supported from D3hot > [ 4.277657] pci 0000:00:1f.3: [8086:1c22] type 00 class 0x0c0500 > [ 4.277694] pci 0000:00:1f.3: reg 10: [mem 0xe2e30000-0xe2e300ff 64bit] > [ 4.277749] pci 0000:00:1f.3: reg 20: [io 0x4040-0x405f] > [ 4.277920] pci 0000:00:1c.0: PCI bridge to [bus 01-01] > [ 4.278353] pci 0000:02:00.0: [8086:422b] type 00 class 0x028000 > [ 4.278708] pci 0000:02:00.0: reg 10: [mem 0xe2d00000-0xe2d01fff 64bit] > [ 4.280508] pci 0000:02:00.0: PME# supported from D0 D3hot D3cold > [ 4.285361] pci 0000:00:1c.1: PCI bridge to [bus 02-02] > [ 4.285374] pci 0000:00:1c.1: bridge window [mem 0xe2d00000-0xe2dfffff] > [ 4.285490] pci 0000:00:1c.2: PCI bridge to [bus 03-08] > [ 4.285498] pci 0000:00:1c.2: bridge window [io 0x3000-0x3fff] > [ 4.285505] pci 0000:00:1c.2: bridge window [mem 0xe2200000-0xe2bfffff] > [ 4.285517] pci 0000:00:1c.2: bridge window [mem 0xe0a00000-0xe13fffff 64bit pref] > [ 4.285625] pci 0000:00:1c.3: PCI bridge to [bus 09-09] > [ 4.285632] pci 0000:00:1c.3: bridge window [io 0x2000-0x2fff] > [ 4.285639] pci 0000:00:1c.3: bridge window [mem 0xe1800000-0xe21fffff] > [ 4.285651] pci 0000:00:1c.3: bridge window [mem 0xe0000000-0xe09fffff 64bit pref] > [ 4.285818] pci 0000:0a:00.0: [1217:8221] type 00 class 0x080501 > [ 4.285872] pci 0000:0a:00.0: reg 10: [mem 0xe2c20000-0xe2c201ff] > [ 4.286294] pci 0000:0a:00.0: supports D1 D2 > [ 4.286295] pci 0000:0a:00.0: PME# supported from D0 D1 D2 D3hot D3cold > [ 4.286432] pci 0000:0a:00.1: [1217:8231] type 00 class 0x018000 > [ 4.286486] pci 0000:0a:00.1: reg 10: [mem 0xe2c10000-0xe2c10fff] > [ 4.286563] pci 0000:0a:00.1: reg 18: [mem 0xe2c00000-0xe2c007ff] > [ 4.286908] pci 0000:0a:00.1: supports D1 D2 > [ 4.286909] pci 0000:0a:00.1: PME# supported from D0 D1 D2 D3hot D3cold > [ 4.293400] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a] > [ 4.293412] pci 0000:00:1c.5: bridge window [mem 0xe2c00000-0xe2cfffff] > [ 4.293479] pci_bus 0000:00: on NUMA node 0 > [ 4.293483] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT] > [ 4.293612] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP01._PRT] > [ 4.293647] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP02._PRT] > [ 4.293682] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP04._PRT] > [ 4.293717] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP06._PRT] > [ 4.293762] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP03._PRT] > [ 4.293857] \_SB_.PCI0:_OSC invalid UUID > [ 4.293858] _OSC request data:1 1f 1f > [ 4.293861] pci0000:00: Requesting ACPI _OSC control (0x1d) > [ 4.293906] \_SB_.PCI0:_OSC invalid UUID > [ 4.293907] _OSC request data:1 0 1d > [ 4.293910] pci0000:00: ACPI _OSC request failed (AE_ERROR), returned control mask: 0x1d > [ 4.293911] ACPI _OSC control for PCIe not granted, disabling ASPM > [ 4.297639] ACPI: PCI Interrupt Link [LNKA] (IRQs 1 3 4 5 6 7 10 12 14 15) *11 > [ 4.297702] ACPI: PCI Interrupt Link [LNKB] (IRQs 1 3 4 5 6 7 11 12 14 15) *10 > [ 4.297761] ACPI: PCI Interrupt Link [LNKC] (IRQs 1 3 4 5 6 7 10 12 14 15) *11 > [ 4.297820] ACPI: PCI Interrupt Link [LNKD] (IRQs 1 3 4 5 6 7 11 12 14 15) *10 > [ 4.297878] ACPI: PCI Interrupt Link [LNKE] (IRQs 1 3 4 *5 6 7 10 12 14 15) > [ 4.297937] ACPI: PCI Interrupt Link [LNKF] (IRQs 1 3 4 5 6 7 11 12 14 15) *0, disabled. > [ 4.297996] ACPI: PCI Interrupt Link [LNKG] (IRQs 1 *3 4 5 6 7 10 12 14 15) > [ 4.298054] ACPI: PCI Interrupt Link [LNKH] (IRQs 1 3 4 5 6 7 11 12 14 15) *0, disabled. > [ 4.298087] xen/balloon: Initialising balloon driver. > [ 4.301022] xen-balloon: Initialising balloon driver. > [ 4.301062] xen/balloon: Xen selfballooning driver disabled for domain0. > [ 4.301148] vgaarb: device added: PCI:0000:00:02.0,decodes=io+mem,owns=io+mem,locks=none > [ 4.301157] vgaarb: loaded > [ 4.301157] vgaarb: bridge control possible 0000:00:02.0 > [ 4.301279] PCI: Using ACPI for IRQ routing > [ 4.305930] PCI: pci_cache_line_size set to 64 bytes > [ 4.306106] reserve RAM buffer: 000000000009a000 - 000000000009ffff > [ 4.306108] reserve RAM buffer: 0000000007eea000 - 0000000007ffffff > [ 4.306110] reserve RAM buffer: 0000000007f70000 - 0000000007ffffff > [ 4.306112] reserve RAM buffer: 0000000007f78000 - 0000000007ffffff > [ 4.306113] reserve RAM buffer: 000000000dffd000 - 000000000fffffff > [ 4.306115] reserve RAM buffer: 00000000c83b4000 - 00000000cbffffff > [ 4.306118] reserve RAM buffer: 00000000c840e000 - 00000000cbffffff > [ 4.306121] reserve RAM buffer: 00000000c8411000 - 00000000cbffffff > [ 4.306123] reserve RAM buffer: 00000000c841e000 - 00000000cbffffff > [ 4.306125] reserve RAM buffer: 00000000c8432000 - 00000000cbffffff > [ 4.306127] reserve RAM buffer: 00000000cac00000 - 00000000cbffffff > [ 4.306129] reserve RAM buffer: 000000042e000000 - 000000042fffffff > [ 4.306235] Switching to clocksource xen > [ 4.307726] pnp: PnP ACPI init > [ 4.307738] ACPI: bus type pnp registered > [ 4.308287] pnp 00:00: [bus 00-3e] > [ 4.308289] pnp 00:00: [io 0x0000-0x0cf7 window] > [ 4.308291] pnp 00:00: [io 0x0cf8-0x0cff] > [ 4.308293] pnp 00:00: [io 0x0d00-0xffff window] > [ 4.308295] pnp 00:00: [mem 0x000a0000-0x000bffff window] > [ 4.308296] pnp 00:00: [mem 0x000c0000-0x000c3fff window] > [ 4.308298] pnp 00:00: [mem 0x000c4000-0x000c7fff window] > [ 4.308300] pnp 00:00: [mem 0x000c8000-0x000cbfff window] > [ 4.308301] pnp 00:00: [mem 0x000cc000-0x000cffff window] > [ 4.308303] pnp 00:00: [mem 0x000d0000-0x000d3fff window] > [ 4.308305] pnp 00:00: [mem 0x000d4000-0x000d7fff window] > [ 4.308307] pnp 00:00: [mem 0x000d8000-0x000dbfff window] > [ 4.308309] pnp 00:00: [mem 0x000dc000-0x000dffff window] > [ 4.308310] pnp 00:00: [mem 0x000e0000-0x000e3fff window] > [ 4.308312] pnp 00:00: [mem 0x000e4000-0x000e7fff window] > [ 4.308314] pnp 00:00: [mem 0x000e8000-0x000ebfff window] > [ 4.308315] pnp 00:00: [mem 0x000ec000-0x000effff window] > [ 4.308317] pnp 00:00: [mem 0x000f0000-0x000fffff window] > [ 4.308319] pnp 00:00: [mem 0xcfa00000-0xfeafffff window] > [ 4.308320] pnp 00:00: [mem 0xfed40000-0xfed44fff window] > [ 4.308385] pnp 00:00: Plug and Play ACPI device, IDs PNP0a08 PNP0a03 (active) > [ 4.308398] pnp 00:01: [io 0x0000-0x001f] > [ 4.308400] pnp 00:01: [io 0x0081-0x0091] > [ 4.308401] pnp 00:01: [io 0x0093-0x009f] > [ 4.308403] pnp 00:01: [io 0x00c0-0x00df] > [ 4.308404] pnp 00:01: [dma 4] > [ 4.308422] pnp 00:01: Plug and Play ACPI device, IDs PNP0200 (active) > [ 4.308429] pnp 00:02: [mem 0xff000000-0xffffffff] > [ 4.308445] pnp 00:02: Plug and Play ACPI device, IDs INT0800 (active) > [ 4.308540] pnp 00:03: [mem 0xfed00000-0xfed003ff] > [ 4.308572] system 00:03: [mem 0xfed00000-0xfed003ff] has been reserved > [ 4.308575] system 00:03: Plug and Play ACPI device, IDs PNP0103 PNP0c01 (active) > [ 4.308584] pnp 00:04: [io 0x00f0] > [ 4.308587] xen: registering gsi 13 triggering 1 polarity 0 > [ 4.308609] pnp 00:04: [irq 13] > [ 4.308626] pnp 00:04: Plug and Play ACPI device, IDs PNP0c04 (active) > [ 4.308636] pnp 00:05: [io 0x002e-0x002f] > [ 4.308637] pnp 00:05: [io 0x004e-0x004f] > [ 4.308639] pnp 00:05: [io 0x0061] > [ 4.308640] pnp 00:05: [io 0x0063] > [ 4.308641] pnp 00:05: [io 0x0065] > [ 4.308642] pnp 00:05: [io 0x0067] > [ 4.308644] pnp 00:05: [io 0x0070] > [ 4.308645] pnp 00:05: [io 0x0080] > [ 4.308646] pnp 00:05: [io 0x0092] > [ 4.308648] pnp 00:05: [io 0x00b2-0x00b3] > [ 4.308649] pnp 00:05: [io 0x0680-0x069f] > [ 4.308651] pnp 00:05: [io 0x1000-0x100f] > [ 4.308653] pnp 00:05: [io 0xffff] > [ 4.308654] pnp 00:05: [io 0xffff] > [ 4.308655] pnp 00:05: [io 0x0400-0x047f] > [ 4.308656] pnp 00:05: [io 0x0500-0x057f] > [ 4.308658] pnp 00:05: [io 0x164e-0x164f] > [ 4.308689] system 00:05: [io 0x0680-0x069f] has been reserved > [ 4.308691] system 00:05: [io 0x1000-0x100f] has been reserved > [ 4.308693] system 00:05: [io 0xffff] has been reserved > [ 4.308695] system 00:05: [io 0xffff] has been reserved > [ 4.308697] system 00:05: [io 0x0400-0x047f] has been reserved > [ 4.308700] system 00:05: [io 0x0500-0x057f] has been reserved > [ 4.308701] system 00:05: [io 0x164e-0x164f] has been reserved > [ 4.308704] system 00:05: Plug and Play ACPI device, IDs PNP0c02 (active) > [ 4.308711] pnp 00:06: [io 0x0070-0x0077] > [ 4.308713] xen: registering gsi 8 triggering 1 polarity 0 > [ 4.308730] pnp 00:06: [irq 8] > [ 4.308749] pnp 00:06: Plug and Play ACPI device, IDs PNP0b00 (active) > [ 4.308758] pnp 00:07: [io 0x0060] > [ 4.308759] pnp 00:07: [io 0x0064] > [ 4.308761] xen: registering gsi 1 triggering 1 polarity 0 > [ 4.308777] pnp 00:07: [irq 1] > [ 4.308794] pnp 00:07: Plug and Play ACPI device, IDs PNP0303 (active) > [ 4.309984] pnp 00:08: Plug and Play ACPI device, IDs PNP0401 (disabled) > [ 4.309993] xen: registering gsi 12 triggering 1 polarity 0 > [ 4.310011] pnp 00:09: [irq 12] > [ 4.310030] pnp 00:09: Plug and Play ACPI device, IDs DLL0493 PNP0f13 (active) > [ 4.310065] pnp 00:0a: [mem 0xfed40000-0xfed44fff] > [ 4.310086] pnp 00:0a: Plug and Play ACPI device, IDs BCM0102 PNP0c31 (active) > [ 4.310291] pnp 00:0b: [mem 0xfed1c000-0xfed1ffff] > [ 4.310292] pnp 00:0b: [mem 0xfed10000-0xfed17fff] > [ 4.310294] pnp 00:0b: [mem 0xfed18000-0xfed18fff] > [ 4.310296] pnp 00:0b: [mem 0xfed19000-0xfed19fff] > [ 4.310298] pnp 00:0b: [mem 0xf8000000-0xfbffffff] > [ 4.310309] pnp 00:0b: [mem 0xfed20000-0xfed3ffff] > [ 4.310310] pnp 00:0b: [mem 0xfed90000-0xfed93fff] > [ 4.310312] pnp 00:0b: [mem 0xfed45000-0xfed8ffff] > [ 4.310313] pnp 00:0b: [mem 0xff000000-0xffffffff] > [ 4.310315] pnp 00:0b: [mem 0xfee00000-0xfeefffff] > [ 4.310317] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disabled] > [ 4.310318] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disabled] > [ 4.310359] system 00:0b: [mem 0xfed1c000-0xfed1ffff] has been reserved > [ 4.310361] system 00:0b: [mem 0xfed10000-0xfed17fff] has been reserved > [ 4.310363] system 00:0b: [mem 0xfed18000-0xfed18fff] has been reserved > [ 4.310365] system 00:0b: [mem 0xfed19000-0xfed19fff] has been reserved > [ 4.310367] system 00:0b: [mem 0xf8000000-0xfbffffff] has been reserved > [ 4.310369] system 00:0b: [mem 0xfed20000-0xfed3ffff] has been reserved > [ 4.310371] system 00:0b: [mem 0xfed90000-0xfed93fff] has been reserved > [ 4.310373] system 00:0b: [mem 0xfed45000-0xfed8ffff] has been reserved > [ 4.310375] system 00:0b: [mem 0xff000000-0xffffffff] could not be reserved > [ 4.310377] system 00:0b: [mem 0xfee00000-0xfeefffff] could not be reserved > [ 4.310380] system 00:0b: Plug and Play ACPI device, IDs PNP0c02 (active) > [ 4.310956] xen: registering gsi 23 triggering 1 polarity 0 > [ 4.310967] xen: --> pirq=23 -> irq=23 (gsi=23) > [ 4.310985] pnp 00:0c: [irq 23] > [ 4.311015] pnp 00:0c: Plug and Play ACPI device, IDs SMO8800 (active) > [ 4.315528] pnp 00:0d: [mem 0x20000000-0x201fffff] > [ 4.315531] pnp 00:0d: [mem 0x40000000-0x401fffff] > [ 4.339851] system 00:0d: [mem 0x20000000-0x201fffff] has been reserved > [ 4.339854] system 00:0d: [mem 0x40000000-0x401fffff] has been reserved > [ 4.339857] system 00:0d: Plug and Play ACPI device, IDs PNP0c01 (active) > [ 4.339865] pnp: PnP ACPI: found 14 devices > [ 4.339867] ACPI: ACPI bus type pnp unregistered > [ 4.346178] PM-Timer failed consistency check (0x0xffffff) - aborting. > [ 4.346274] pci 0000:00:1c.0: PCI bridge to [bus 01-01] > [ 4.346306] pci 0000:00:1c.1: PCI bridge to [bus 02-02] > [ 4.346315] pci 0000:00:1c.1: bridge window [mem 0xe2d00000-0xe2dfffff] > [ 4.346332] pci 0000:00:1c.2: PCI bridge to [bus 03-08] > [ 4.346336] pci 0000:00:1c.2: bridge window [io 0x3000-0x3fff] > [ 4.346347] pci 0000:00:1c.2: bridge window [mem 0xe2200000-0xe2bfffff] > [ 4.346354] pci 0000:00:1c.2: bridge window [mem 0xe0a00000-0xe13fffff 64bit pref] > [ 4.346366] pci 0000:00:1c.3: PCI bridge to [bus 09-09] > [ 4.346370] pci 0000:00:1c.3: bridge window [io 0x2000-0x2fff] > [ 4.346379] pci 0000:00:1c.3: bridge window [mem 0xe1800000-0xe21fffff] > [ 4.346386] pci 0000:00:1c.3: bridge window [mem 0xe0000000-0xe09fffff 64bit pref] > [ 4.346399] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a] > [ 4.346408] pci 0000:00:1c.5: bridge window [mem 0xe2c00000-0xe2cfffff] > [ 4.346434] xen: registering gsi 16 triggering 0 polarity 1 > [ 4.346442] xen: --> pirq=16 -> irq=16 (gsi=16) > [ 4.346469] xen: registering gsi 17 triggering 0 polarity 1 > [ 4.346473] xen: --> pirq=17 -> irq=17 (gsi=17) > [ 4.346498] xen: registering gsi 18 triggering 0 polarity 1 > [ 4.346502] xen: --> pirq=18 -> irq=18 (gsi=18) > [ 4.346527] xen: registering gsi 19 triggering 0 polarity 1 > [ 4.346531] xen: --> pirq=19 -> irq=19 (gsi=19) > [ 4.346556] xen: registering gsi 17 triggering 0 polarity 1 > [ 4.346558] Already setup the GSI :17 > [ 4.346563] pci_bus 0000:00: resource 4 [io 0x0000-0x0cf7] > [ 4.346565] pci_bus 0000:00: resource 5 [io 0x0d00-0xffff] > [ 4.346566] pci_bus 0000:00: resource 6 [mem 0x000a0000-0x000bffff] > [ 4.346568] pci_bus 0000:00: resource 7 [mem 0xcfa00000-0xfeafffff] > [ 4.346570] pci_bus 0000:00: resource 8 [mem 0xfed40000-0xfed44fff] > [ 4.346572] pci_bus 0000:02: resource 1 [mem 0xe2d00000-0xe2dfffff] > [ 4.346574] pci_bus 0000:03: resource 0 [io 0x3000-0x3fff] > [ 4.346575] pci_bus 0000:03: resource 1 [mem 0xe2200000-0xe2bfffff] > [ 4.346577] pci_bus 0000:03: resource 2 [mem 0xe0a00000-0xe13fffff 64bit pref] > [ 4.346579] pci_bus 0000:09: resource 0 [io 0x2000-0x2fff] > [ 4.346581] pci_bus 0000:09: resource 1 [mem 0xe1800000-0xe21fffff] > [ 4.346582] pci_bus 0000:09: resource 2 [mem 0xe0000000-0xe09fffff 64bit pref] > [ 4.346584] pci_bus 0000:0a: resource 1 [mem 0xe2c00000-0xe2cfffff] > [ 4.346672] NET: Registered protocol family 2 > [ 4.346732] IP route cache hash table entries: 524288 (order: 10, 4194304 bytes) > [ 4.347207] TCP established hash table entries: 262144 (order: 10, 4194304 bytes) > [ 4.347753] TCP bind hash table entries: 65536 (order: 8, 1048576 bytes) > [ 4.347872] TCP: Hash tables configured (established 262144 bind 65536) > [ 4.347874] TCP: reno registered > [ 4.347877] UDP hash table entries: 8192 (order: 6, 262144 bytes) > [ 4.347921] UDP-Lite hash table entries: 8192 (order: 6, 262144 bytes) > [ 4.348067] NET: Registered protocol family 1 > [ 4.348085] pci 0000:00:02.0: Boot video device > [ 4.348108] xen: registering gsi 16 triggering 0 polarity 1 > [ 4.348112] Already setup the GSI :16 > [ 4.348203] xen: registering gsi 17 triggering 0 polarity 1 > [ 4.348205] Already setup the GSI :17 > [ 4.348298] PCI: CLS 64 bytes, default 64 > [ 4.348333] Unpacking initramfs... > [ 4.384265] Freeing initrd memory: 45868k freed > [ 4.392440] Simple Boot Flag at 0xf3 set to 0x1 > [ 4.392900] audit: initializing netlink socket (disabled) > [ 4.392911] type=2000 audit(1354151975.383:1): initialized > [ 4.411688] VFS: Disk quotas dquot_6.5.2 > [ 4.411715] Dquot-cache hash table entries: 512 (order 0, 4096 bytes) > [ 4.411870] msgmni has been set to 29339 > [ 4.412010] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 253) > [ 4.412013] io scheduler noop registered > [ 4.412015] io scheduler deadline registered > [ 4.412036] io scheduler cfq registered (default) > [ 4.412666] intel_idle: does not run on family 6 model 42 > [ 4.412741] ACPI: Requesting acpi_cpufreq > [ 4.459643] Non-volatile memory driver v1.3 > [ 4.459654] ramoops: platform device not found, using module parameters > [ 4.459670] ramoops: The memory size and the record size must be non-zero > [ 4.459703] ramoops: probe of ramoops failed with error -22 > [ 4.474892] loop: module loaded > [ 4.474922] Fixed MDIO Bus: probed > [ 4.474965] i8042: PNP: PS/2 Controller [PNP0303:PS2K,PNP0f13:PS2M] at 0x60,0x64 irq 1,12 > [ 4.475166] i8042: Warning: Keylock active > [ 4.476434] serio: i8042 KBD port at 0x60,0x64 irq 1 > [ 4.476439] serio: i8042 AUX port at 0x60,0x64 irq 12 > [ 4.476551] mousedev: PS/2 mouse device common for all mice > [ 4.476707] rtc_cmos 00:06: RTC can wake from S4 > [ 4.476940] rtc_cmos 00:06: rtc core: registered rtc_cmos as rtc0 > [ 4.476998] rtc0: alarms up to one year, y3k, 242 bytes nvram > [ 4.477084] device-mapper: uevent: version 1.0.3 > [ 4.477193] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) initialised: dm-devel@redhat.com > [ 4.477281] TCP: cubic registered > [ 4.477381] input: AT Translated Set 2 keyboard as /devices/platform/i8042/serio0/input/input0 > [ 4.477402] NET: Registered protocol family 10 > [ 4.477644] Registering the dns_resolver key type > [ 4.477791] registered taskstats version 1 > [ 4.478330] Magic number: 4:584:307 > [ 4.478403] tty tty36: hash matches > [ 4.478496] rtc_cmos 00:06: setting system clock to 2012-11-29 01:19:35 UTC (1354151975) > [ 4.478801] Freeing unused kernel memory: 552k freed > [ 4.478847] Write protecting the kernel read-only data: 8192k > [ 4.481908] Freeing unused kernel memory: 1568k freed > [ 4.482112] Freeing unused kernel memory: 24k freed > [ 4.524129] dracut: dracut-005-3.fc13 > [ 4.552311] pciback 0000:00:19.0: seizing device > [ 4.552403] pciback 0000:02:00.0: seizing device > [ 4.552941] xen: registering gsi 17 triggering 0 polarity 1 > [ 4.552952] Already setup the GSI :17 > [ 4.553934] xen: registering gsi 20 triggering 0 polarity 1 > [ 4.553964] xen: --> pirq=20 -> irq=20 (gsi=20) > [ 4.554574] xen-pciback: backend is vpci > [ 4.617471] udev: starting version 151 > [ 4.617770] udevd (80): /proc/80/oom_adj is deprecated, please use /proc/80/oom_score_adj instead. > [ 4.654916] Linux agpgart interface v0.103 > [ 4.655397] input: Lid Switch as /devices/LNXSYSTM:00/device:00/PNP0C0D:00/input/input1 > [ 5.051184] ACPI: Lid Switch [LID] > [ 5.051436] input: Power Button as /devices/LNXSYSTM:00/device:00/PNP0C0C:00/input/input2 > [ 5.051547] ACPI: Power Button [PBTN] > [ 5.051682] input: Sleep Button as /devices/LNXSYSTM:00/device:00/PNP0C0E:00/input/input3 > [ 5.051760] ACPI: Sleep Button [SBTN] > [ 5.054141] input: Power Button as /devices/LNXSYSTM:00/LNXPWRBN:00/input/input4 > [ 5.054421] ACPI: Power Button [PWRF] > [ 5.056887] agpgart-intel 0000:00:00.0: Intel Sandybridge Chipset > [ 5.058118] agpgart-intel 0000:00:00.0: detected gtt size: 2097152K total, 262144K mappable > [ 5.064439] agpgart-intel 0000:00:00.0: detected 65536K stolen memory > [ 5.064916] agpgart-intel 0000:00:00.0: AGP aperture is 256M @ 0xd0000000 > [ 5.070296] [drm] Initialized drm 1.1.0 20060810 > [ 5.080002] xen: registering gsi 16 triggering 0 polarity 1 > [ 5.080015] Already setup the GSI :16 > [ 5.080364] i915 0000:00:02.0: setting latency timer to 64 > [ 5.190295] [drm] MTRR allocation failed. Graphics performance may suffer. > [ 5.190491] [drm] Supports vblank timestamp caching Rev 1 (10.10.2010). > [ 5.190493] [drm] Driver supports precise vblank timestamp query. > [ 5.190554] vgaarb: device changed decodes: PCI:0000:00:02.0,olddecodes=io+mem,decodes=io+mem:owns=io+mem > [ 5.548301] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp off > [ 5.591093] input: DualPoint Stick as /devices/platform/i8042/serio1/input/input5 > [ 5.606212] input: AlpsPS/2 ALPS DualPoint TouchPad as /devices/platform/i8042/serio1/input/input6 > [ 5.806814] fbcon: inteldrmfb (fb0) is primary device > [ 6.095967] Console: switching to colour frame buffer device 200x56 > [ 6.101477] fb0: inteldrmfb frame buffer device > [ 6.101478] drm: registered panic notifier > [ 6.130833] acpi device:38: registered as cooling_device4 > [ 6.133713] input: Video Bus as /devices/LNXSYSTM:00/device:00/PNP0A08:00/LNXVIDEO:00/input/input7 > [ 6.133915] ACPI: Video Device [VID] (multi-head: yes rom: no post: no) > [ 6.135082] [drm] Initialized i915 1.6.0 20080730 for 0000:00:02.0 on minor 0 > [ 6.185946] dracut: Starting plymouth daemon > [ 6.479391] dracut: rd_NO_DM: removing DM RAID activation > [ 6.489309] dracut: rd_NO_MD: removing MD RAID activation > [ 6.542596] wmi: Mapper loaded > [ 6.564439] usbcore: registered new interface driver usbfs > [ 6.564463] usbcore: registered new interface driver hub > [ 6.568901] SCSI subsystem initialized > [ 6.569574] usbcore: registered new device driver usb > [ 6.570692] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver > [ 6.570723] xen: registering gsi 16 triggering 0 polarity 1 > [ 6.570728] Already setup the GSI :16 > [ 6.570776] ehci_hcd 0000:00:1a.0: setting latency timer to 64 > [ 6.570782] ehci_hcd 0000:00:1a.0: EHCI Host Controller > [ 6.570814] ehci_hcd 0000:00:1a.0: new USB bus registered, assigned bus number 1 > [ 6.570879] ehci_hcd 0000:00:1a.0: debug port 2 > [ 6.573720] libata version 3.00 loaded. > [ 6.574777] ehci_hcd 0000:00:1a.0: cache line size of 64 is not supported > [ 6.574832] ehci_hcd 0000:00:1a.0: irq 16, io mem 0xe2e70000 > [ 6.586344] ehci_hcd 0000:00:1a.0: USB 2.0 started, EHCI 1.00 > [ 6.586369] usb usb1: New USB device found, idVendor=1d6b, idProduct=0002 > [ 6.586372] usb usb1: New USB device strings: Mfr=3, Product=2, SerialNumber=1 > [ 6.586375] usb usb1: Product: EHCI Host Controller > [ 6.586376] usb usb1: Manufacturer: Linux 3.4.18-2.pvops.qubes.x86_64 ehci_hcd > [ 6.586378] usb usb1: SerialNumber: 0000:00:1a.0 > [ 6.586506] hub 1-0:1.0: USB hub found > [ 6.586511] hub 1-0:1.0: 2 ports detected > [ 6.586604] xen: registering gsi 17 triggering 0 polarity 1 > [ 6.586609] Already setup the GSI :17 > [ 6.586663] ehci_hcd 0000:00:1d.0: setting latency timer to 64 > [ 6.586668] ehci_hcd 0000:00:1d.0: EHCI Host Controller > [ 6.586678] ehci_hcd 0000:00:1d.0: new USB bus registered, assigned bus number 2 > [ 6.586734] ehci_hcd 0000:00:1d.0: debug port 2 > [ 6.590650] ehci_hcd 0000:00:1d.0: cache line size of 64 is not supported > [ 6.590709] ehci_hcd 0000:00:1d.0: irq 17, io mem 0xe2e50000 > [ 6.606335] ehci_hcd 0000:00:1d.0: USB 2.0 started, EHCI 1.00 > [ 6.606364] usb usb2: New USB device found, idVendor=1d6b, idProduct=0002 > [ 6.606367] usb usb2: New USB device strings: Mfr=3, Product=2, SerialNumber=1 > [ 6.606370] usb usb2: Product: EHCI Host Controller > [ 6.606371] usb usb2: Manufacturer: Linux 3.4.18-2.pvops.qubes.x86_64 ehci_hcd > [ 6.606373] usb usb2: SerialNumber: 0000:00:1d.0 > [ 6.606519] hub 2-0:1.0: USB hub found > [ 6.606524] hub 2-0:1.0: 2 ports detected > [ 6.606620] ahci 0000:00:1f.2: version 3.0 > [ 6.606641] xen: registering gsi 18 triggering 0 polarity 1 > [ 6.606647] Already setup the GSI :18 > [ 6.606896] ahci: SSS flag set, parallel bus scan disabled > [ 6.626400] ahci 0000:00:1f.2: AHCI 0001.0300 32 slots 6 ports 6 Gbps 0x3b impl SATA mode > [ 6.626405] ahci 0000:00:1f.2: flags: 64bit ncq sntf stag pm led clo pio slum part ems sxs apst > [ 6.626414] ahci 0000:00:1f.2: setting latency timer to 64 > [ 6.673732] scsi0 : ahci > [ 6.683363] scsi1 : ahci > [ 6.697268] scsi2 : ahci > [ 6.711526] scsi3 : ahci > [ 6.733931] scsi4 : ahci > [ 6.739603] scsi5 : ahci > [ 6.842106] ata1: SATA max UDMA/133 abar m2048@0xe2e40000 port 0xe2e40100 irq 293 > [ 6.842118] ata2: SATA max UDMA/133 abar m2048@0xe2e40000 port 0xe2e40180 irq 293 > [ 6.842124] ata3: DUMMY > [ 6.842129] ata4: SATA max UDMA/133 abar m2048@0xe2e40000 port 0xe2e40280 irq 293 > [ 6.842136] ata5: SATA max UDMA/133 abar m2048@0xe2e40000 port 0xe2e40300 irq 293 > [ 6.842143] ata6: SATA max UDMA/133 abar m2048@0xe2e40000 port 0xe2e40380 irq 293 > [ 6.898480] usb 1-1: new high-speed USB device number 2 using ehci_hcd > [ 7.031312] usb 1-1: New USB device found, idVendor=8087, idProduct=0024 > [ 7.031323] usb 1-1: New USB device strings: Mfr=0, Product=0, SerialNumber=0 > [ 7.032072] hub 1-1:1.0: USB hub found > [ 7.032344] hub 1-1:1.0: 6 ports detected > [ 7.142515] usb 2-1: new high-speed USB device number 2 using ehci_hcd > [ 7.162484] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) > [ 7.268594] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by device (Stat=0x51 Err=0x04) > [ 7.268770] ata1.00: ATA-9: KINGSTON SV200S3256G, E111008a, max UDMA/100 > [ 7.268778] ata1.00: 500118192 sectors, multi 16: LBA48 NCQ (depth 31/32), AA > [ 7.272554] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by device (Stat=0x51 Err=0x04) > [ 7.272758] ata1.00: configured for UDMA/100 > [ 7.273314] scsi 0:0:0:0: Direct-Access ATA KINGSTON SV200S3 E111 PQ: 0 ANSI: 5 > [ 7.274861] usb 2-1: New USB device found, idVendor=8087, idProduct=0024 > [ 7.274870] usb 2-1: New USB device strings: Mfr=0, Product=0, SerialNumber=0 > [ 7.275358] hub 2-1:1.0: USB hub found > [ 7.275521] hub 2-1:1.0: 8 ports detected > [ 7.346717] usb 1-1.4: new full-speed USB device number 3 using ehci_hcd > [ 7.443529] usb 1-1.4: New USB device found, idVendor=413c, idProduct=8187 > [ 7.443539] usb 1-1.4: New USB device strings: Mfr=1, Product=2, SerialNumber=3 > [ 7.443546] usb 1-1.4: Product: DW375 Bluetooth Module > [ 7.443550] usb 1-1.4: Manufacturer: Dell Computer Corp > [ 7.443555] usb 1-1.4: SerialNumber: D0DF9A40FE60 > [ 7.514736] usb 1-1.5: new high-speed USB device number 4 using ehci_hcd > [ 7.590440] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 300) > [ 7.593835] ata2.00: ATAPI: HL-DT-ST DVD+/-RW GU60N, A103, max UDMA/133 > [ 7.604147] ata2.00: configured for UDMA/133 > [ 7.614746] usb 1-1.5: New USB device found, idVendor=05ca, idProduct=181c > [ 7.614757] usb 1-1.5: New USB device strings: Mfr=1, Product=2, SerialNumber=0 > [ 7.614763] usb 1-1.5: Product: Laptop_Integrated_Webcam_FHD > [ 7.614768] usb 1-1.5: Manufacturer: CN0CJ3P27248717F040SA01 > [ 7.618662] scsi 1:0:0:0: CD-ROM HL-DT-ST DVD+-RW GU60N A103 PQ: 0 ANSI: 5 > [ 7.686581] usb 2-1.6: new high-speed USB device number 3 using ehci_hcd > [ 7.795399] usb 2-1.6: New USB device found, idVendor=413c, idProduct=818d > [ 7.795410] usb 2-1.6: New USB device strings: Mfr=1, Product=2, SerialNumber=3 > [ 7.795416] usb 2-1.6: Product: DW5550 > [ 7.795420] usb 2-1.6: Manufacturer: Dell > [ 7.795425] usb 2-1.6: SerialNumber: 88FA653FDF944970 > [ 7.902770] usb 2-1.8: new full-speed USB device number 4 using ehci_hcd > [ 7.938478] ata4: SATA link down (SStatus 0 SControl 300) > [ 8.017319] usb 2-1.8: New USB device found, idVendor=0a5c, idProduct=5801 > [ 8.017330] usb 2-1.8: New USB device strings: Mfr=1, Product=2, SerialNumber=3 > [ 8.017336] usb 2-1.8: Product: 5880 > [ 8.017340] usb 2-1.8: Manufacturer: Broadcom Corp > [ 8.017344] usb 2-1.8: SerialNumber: 0123456789ABCD > [ 8.017794] usb 2-1.8: config 0 descriptor?? > [ 8.258411] ata5: SATA link down (SStatus 0 SControl 300) > [ 8.578480] ata6: SATA link down (SStatus 0 SControl 300) > [ 8.588630] sd 0:0:0:0: [sda] 500118192 512-byte logical blocks: (256 GB/238 GiB) > [ 8.588846] sd 0:0:0:0: [sda] Write Protect is off > [ 8.588861] sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00 > [ 8.588967] sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA > [ 8.590122] sda: sda1 sda2 > [ 8.591059] sd 0:0:0:0: [sda] Attached SCSI disk > [ 8.609438] sr0: scsi3-mmc drive: 24x/8x writer dvd-ram cd/rw xa/form2 cdda tray > [ 8.609451] cdrom: Uniform CD-ROM driver Revision: 3.20 > [ 8.609737] sr 1:0:0:0: Attached scsi CD-ROM sr0 > [ 8.714515] dracut: luksOpen /dev/sda2 luks-400336fa-c7c4-4be3-a244-c909aa16a18c > [ 13.862564] dracut: Scanning devices dm-0 for LVM logical volumes vg_dom0/lv_root vg_dom0/lv_swap > [ 13.907639] dracut: inactive '/dev/vg_dom0/lv_root' [221.62 GiB] inherit > [ 13.907708] dracut: inactive '/dev/vg_dom0/lv_swap' [16.34 GiB] inherit > [ 14.162684] EXT4-fs (dm-1): INFO: recovery required on readonly filesystem > [ 14.162693] EXT4-fs (dm-1): write access will be enabled during recovery > [ 14.775779] EXT4-fs (dm-1): orphan cleanup on readonly fs > [ 14.775800] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767209 > [ 14.775909] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767207 > [ 14.776007] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767205 > [ 14.776035] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767206 > [ 14.776062] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767204 > [ 14.776088] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767202 > [ 14.776117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767198 > [ 14.776146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767196 > [ 14.776172] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767191 > [ 14.776198] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767189 > [ 14.776227] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767188 > [ 14.776274] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767187 > [ 14.777018] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767186 > [ 14.777060] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767184 > [ 14.777089] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767183 > [ 14.777117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767171 > [ 14.777146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unreferenced inode 5767170 > [ 14.777172] EXT4-fs (dm-1): 17 orphan inodes deleted > [ 14.777177] EXT4-fs (dm-1): recovery complete > [ 14.797124] EXT4-fs (dm-1): mounted filesystem with ordered data mode. Opts: (null) > [ 14.806762] dracut: Mounted root filesystem /dev/mapper/vg_dom0-lv_root > [ 14.957211] dracut: Switching root > [ 15.599261] udev: starting version 151 > [ 15.673674] iTCO_vendor_support: vendor-support=0 > [ 15.676374] mei: module is from the staging directory, the quality is unknown, you have been warned. > [ 15.676488] iTCO_wdt: Intel TCO WatchDog Timer Driver v1.07 > [ 15.676679] iTCO_wdt: Found a Cougar Point TCO device (Version=2, TCOBASE=0x0460) > [ 15.676711] xen: registering gsi 16 triggering 0 polarity 1 > [ 15.676716] Already setup the GSI :16 > [ 15.676725] mei 0000:00:16.0: setting latency timer to 64 > [ 15.676754] iTCO_wdt: initialized. heartbeat=30 sec (nowayout=0) > [ 15.712582] sd 0:0:0:0: Attached scsi generic sg0 type 0 > [ 15.712620] sr 1:0:0:0: Attached scsi generic sg1 type 5 > [ 15.730448] input: PC Speaker as /devices/platform/pcspkr/input/input8 > [ 15.734494] xen: registering gsi 18 triggering 0 polarity 1 > [ 15.734500] Already setup the GSI :18 > [ 15.734506] ACPI Warning: 0x0000000000004040-0x000000000000405f SystemIO conflicts with Region \_SB_.PCI0.SBUS.SMBI 1 (20120320/utaddress-251) > [ 15.734512] ACPI: If an ACPI driver is available for this device, you should use it instead of the native driver > [ 15.737002] microcode: CPU0 sig=0x206a7, pf=0x10, revision=0x23 > [ 15.741412] watchdog: INTCAMT: cannot register miscdev on minor=130 (err=-16) > [ 15.741418] watchdog: error registering /dev/watchdog (err=-16) > [ 15.741422] mei 0000:00:16.0: unable to register watchdog device. > [ 15.790637] thermal LNXTHERM:00: registered as thermal_zone0 > [ 15.790641] ACPI: Thermal Zone [THM] (25 C) > [ 15.814551] ACPI: Deprecated procfs I/F for battery is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared > [ 15.814559] ACPI: Battery Slot [BAT0] (battery present) > [ 15.815037] ACPI: Deprecated procfs I/F for AC is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared > [ 15.815521] ACPI: AC Adapter [AC] (on-line) > [ 15.867835] usbcore: registered new interface driver usbback > [ 15.975826] ACPI: Deprecated procfs I/F for battery is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared > [ 15.975836] ACPI: Battery Slot [BAT1] (battery absent) > [ 16.102871] ACPI: Deprecated procfs I/F for battery is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared > [ 16.102882] ACPI: Battery Slot [BAT2] (battery absent) > [ 16.106793] sdhci: Secure Digital Host Controller Interface driver > [ 16.106797] sdhci: Copyright(c) Pierre Ossman > [ 16.107131] parport_pc 00:08: [io 0x0378-0x037b] > [ 16.107296] parport_pc 00:08: [irq 5] > [ 16.107709] sdhci-pci 0000:0a:00.0: SDHCI controller found [1217:8221] (rev 5) > [ 16.159148] xen: registering gsi 17 triggering 0 polarity 1 > [ 16.159156] Already setup the GSI :17 > [ 16.159241] sdhci-pci 0000:0a:00.0: Invalid iomem size. You may experience problems. > [ 16.159319] 0000:0a:00.0 supply vmmc not found, using dummy regulator > [ 16.159384] Registered led device: mmc0:: > [ 16.160442] mmc0: SDHCI controller on PCI [0000:0a:00.0] using DMA > [ 16.160928] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 16.171737] Linux video capture interface: v2.00 > [ 16.192158] cdc_wdm 2-1.6:1.5: cdc-wdm0: USB WDM device > [ 16.192211] cdc_wdm 2-1.6:1.8: cdc-wdm1: USB WDM device > [ 16.192234] usbcore: registered new interface driver cdc_wdm > [ 16.195744] cdc_acm 2-1.6:1.1: ttyACM0: USB ACM device > [ 16.198739] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 16.220532] cdc_acm 2-1.6:1.3: ttyACM1: USB ACM device > [ 16.223728] cdc_acm 2-1.6:1.9: ttyACM2: USB ACM device > [ 16.235089] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 16.235234] usbcore: registered new interface driver cdc_acm > [ 16.235236] cdc_acm: USB Abstract Control Model driver for USB modems and ISDN adapters > [ 16.240235] uvcvideo: Found UVC 1.00 device Laptop_Integrated_Webcam_FHD (05ca:181c) > [ 16.269474] input: Laptop_Integrated_Webcam_FHD as /devices/pci0000:00/0000:00:1a.0/usb1/1-1/1-1.5/1-1.5:1.0/input/input9 > [ 16.269579] usbcore: registered new interface driver uvcvideo > [ 16.269581] USB Video Class driver (1.1.1) > [ 16.277415] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 16.296646] usb 2-1.6: MAC-Address: 02:80:37:ec:02:00 > [ 16.296810] cdc_ncm 2-1.6:1.6: usb0: register 'cdc_ncm' at usb-0000:00:1d.0-1.6, CDC NCM, 02:80:37:ec:02:00 > [ 16.296847] usbcore: registered new interface driver cdc_ncm > [ 16.310604] parport_pc 00:08: activated > [ 16.310611] parport_pc 00:08: reported by Plug and Play ACPI > [ 16.310781] parport_pc 00:08: disabled > [ 16.311583] tpm_tis 00:0a: 1.2 TPM (device-id 0x2001, rev-id 32) > [ 16.399296] Bluetooth: Core ver 2.16 > [ 16.399312] NET: Registered protocol family 31 > [ 16.399314] Bluetooth: HCI device and connection manager initialized > [ 16.399317] Bluetooth: HCI socket layer initialized > [ 16.399318] Bluetooth: L2CAP socket layer initialized > [ 16.399325] Bluetooth: SCO socket layer initialized > [ 16.450583] xen: registering gsi 22 triggering 0 polarity 1 > [ 16.450600] xen: --> pirq=22 -> irq=22 (gsi=22) > [ 16.567577] usbcore: registered new interface driver btusb > [ 16.739259] dcdbas dcdbas: Dell Systems Management Base Driver (version 5.6.0-3.2) > [ 16.819125] input: Dell WMI hotkeys as /devices/virtual/input/input10 > [ 16.925000] microcode: CPU1 sig=0x206a7, pf=0x10, revision=0x23 > [ 16.929246] ppdev: user-space parallel port driver > [ 16.954783] microcode: CPU2 sig=0x206a7, pf=0x10, revision=0x23 > [ 16.975176] microcode: CPU3 sig=0x206a7, pf=0x10, revision=0x23 > [ 17.004696] microcode: Microcode Update Driver: v2.00 , Peter Oruba > [ 17.067123] ALSA hda_codec.c:5101 autoconfig: line_outs=1 (0xe/0x0/0x0/0x0/0x0) type:line > [ 17.067127] ALSA hda_codec.c:5105 speaker_outs=1 (0xd/0x0/0x0/0x0/0x0) > [ 17.067129] ALSA hda_codec.c:5109 hp_outs=1 (0xb/0x0/0x0/0x0/0x0) > [ 17.067131] ALSA hda_codec.c:5110 mono: mono_out=0x0 > [ 17.067133] ALSA hda_codec.c:5114 inputs: > [ 17.067135] ALSA hda_codec.c:5118 Mic=0xa > [ 17.067137] ALSA hda_codec.c:5118 Dock Mic=0xf > [ 17.067139] ALSA hda_codec.c:5120 > [ 17.067637] ALSA patch_sigmatel.c:3117 stac92xx: dac_nids=1 (0x13/0x0/0x0/0x0/0x0) > [ 17.081104] input: HDA Intel PCH HDMI/DP,pcm=8 as /devices/pci0000:00/0000:00:1b.0/sound/card0/input11 > [ 17.081194] input: HDA Intel PCH HDMI/DP,pcm=7 as /devices/pci0000:00/0000:00:1b.0/sound/card0/input12 > [ 17.081250] input: HDA Intel PCH HDMI/DP,pcm=3 as /devices/pci0000:00/0000:00:1b.0/sound/card0/input13 > [ 17.081342] input: HDA Intel PCH Dock Mic as /devices/pci0000:00/0000:00:1b.0/sound/card0/input14 > [ 17.081432] input: HDA Intel PCH Mic as /devices/pci0000:00/0000:00:1b.0/sound/card0/input15 > [ 17.081522] input: HDA Intel PCH Headphone as /devices/pci0000:00/0000:00:1b.0/sound/card0/input16 > [ 17.081610] input: HDA Intel PCH Dock Line Out as /devices/pci0000:00/0000:00:1b.0/sound/card0/input17 > [ 17.265462] Event-channel device installed. > [ 17.661764] EXT4-fs (dm-1): re-mounted. Opts: (null) > [ 17.802446] EXT4-fs (sda1): mounted filesystem with ordered data mode. Opts: (null) > [ 19.361631] Adding 17137660k swap on /dev/mapper/vg_dom0-lv_swap. Priority:-1 extents:1 across:17137660k SS > [ 22.602549] ehci_hcd 0000:00:1a.0: remove, state 1 > [ 22.602568] usb usb1: USB disconnect, device number 1 > [ 22.602573] usb 1-1: USB disconnect, device number 2 > [ 22.602578] usb 1-1.4: USB disconnect, device number 3 > [ 22.605235] usb 1-1.5: USB disconnect, device number 4 > [ 22.636910] ehci_hcd 0000:00:1a.0: USB bus 1 deregistered > [ 22.637183] pciback 0000:00:1a.0: seizing device > [ 22.637235] xen: registering gsi 16 triggering 0 polarity 1 > [ 22.637241] Already setup the GSI :16 > [ 22.662363] ehci_hcd 0000:00:1d.0: remove, state 1 > [ 22.662371] usb usb2: USB disconnect, device number 1 > [ 22.662373] usb 2-1: USB disconnect, device number 2 > [ 22.662376] usb 2-1.6: USB disconnect, device number 3 > [ 22.668531] cdc_ncm 2-1.6:1.6: usb0: unregister 'cdc_ncm' usb-0000:00:1d.0-1.6, CDC NCM > [ 22.694795] usb 2-1.8: USB disconnect, device number 4 > [ 22.699298] ehci_hcd 0000:00:1d.0: USB bus 2 deregistered > [ 22.699577] pciback 0000:00:1d.0: seizing device > [ 22.699632] xen: registering gsi 17 triggering 0 polarity 1 > [ 22.699637] Already setup the GSI :17 > [ 23.684708] xen-pciback: vpci: 0000:00:19.0: assign to virtual slot 0 > [ 23.685240] xen-pciback: vpci: 0000:00:1a.0: assign to virtual slot 1 > [ 23.685722] xen-pciback: vpci: 0000:00:1d.0: assign to virtual slot 2 > [ 23.686764] xen-pciback: vpci: 0000:02:00.0: assign to virtual slot 3 > [ 23.909636] pciback 0000:00:19.0: Driver tried to write to a read-only configuration space field at offset 0xd2, size 2. This may be harmless, but if you have problems with your device: > [ 23.909638] 1) see permissive attribute in sysfs > [ 23.909638] 2) report problems to the xen-devel mailing list along with details of your device obtained from lspci. > [ 23.917523] pciback 0000:02:00.0: Driver tried to write to a read-only configuration space field at offset 0xd2, size 2. This may be harmless, but if you have problems with your device: > [ 23.917526] 1) see permissive attribute in sysfs > [ 23.917526] 2) report problems to the xen-devel mailing list along with details of your device obtained from lspci. > [ 24.123663] xen-blkback:ring-ref 9, event-channel 14, protocol 1 (x86_64-abi) > [ 24.140460] xen-blkback:ring-ref 10, event-channel 15, protocol 1 (x86_64-abi) > [ 24.151420] xen-blkback:ring-ref 11, event-channel 16, protocol 1 (x86_64-abi) > [ 24.158428] xen-blkback:ring-ref 12, event-channel 17, protocol 1 (x86_64-abi) > [ 28.697615] pciback 0000:00:1a.0: enabling device (0000 -> 0002) > [ 28.697628] xen: registering gsi 16 triggering 0 polarity 1 > [ 28.697634] Already setup the GSI :16 > [ 28.697805] pciback 0000:00:1a.0: setting latency timer to 64 > [ 28.713578] pciback 0000:00:19.0: enabling device (0000 -> 0003) > [ 28.713591] xen: registering gsi 20 triggering 0 polarity 1 > [ 28.713598] Already setup the GSI :20 > [ 28.713858] pciback 0000:00:19.0: setting latency timer to 64 > [ 29.021371] pciback 0000:00:1d.0: enabling device (0000 -> 0002) > [ 29.021389] xen: registering gsi 17 triggering 0 polarity 1 > [ 29.021400] Already setup the GSI :17 > [ 29.021805] pciback 0000:00:1d.0: setting latency timer to 64 > [ 29.150053] pciback 0000:02:00.0: enabling device (0000 -> 0002) > [ 29.150122] xen: registering gsi 17 triggering 0 polarity 1 > [ 29.150150] Already setup the GSI :17 > [ 33.635416] xen-blkback:ring-ref 9, event-channel 14, protocol 1 (x86_64-abi) > [ 33.643330] xen-blkback:ring-ref 10, event-channel 15, protocol 1 (x86_64-abi) > [ 33.651561] xen-blkback:ring-ref 11, event-channel 16, protocol 1 (x86_64-abi) > [ 33.672105] xen-blkback:ring-ref 12, event-channel 17, protocol 1 (x86_64-abi) > [ 104.230911] xen-blkback:ring-ref 9, event-channel 24, protocol 1 (x86_64-abi) > [ 104.252421] xen-blkback:ring-ref 10, event-channel 25, protocol 1 (x86_64-abi) > [ 104.253177] xen-blkback:ring-ref 11, event-channel 26, protocol 1 (x86_64-abi) > [ 104.254220] xen-blkback:ring-ref 12, event-channel 27, protocol 1 (x86_64-abi) > [ 105.086732] xen-blkback:ring-ref 9, event-channel 14, protocol 1 (x86_64-abi) > [ 105.105505] xen-blkback:ring-ref 10, event-channel 15, protocol 1 (x86_64-abi) > [ 105.115951] xen-blkback:ring-ref 11, event-channel 16, protocol 1 (x86_64-abi) > [ 105.127384] xen-blkback:ring-ref 12, event-channel 17, protocol 1 (x86_64-abi) > [ 105.929760] xen-blkback:ring-ref 9, event-channel 14, protocol 1 (x86_64-abi) > [ 105.934841] xen-blkback:ring-ref 10, event-channel 15, protocol 1 (x86_64-abi) > [ 105.973920] xen-blkback:ring-ref 11, event-channel 16, protocol 1 (x86_64-abi) > [ 105.975320] xen-blkback:ring-ref 12, event-channel 17, protocol 1 (x86_64-abi) > [ 107.191781] xen-blkback:ring-ref 9, event-channel 14, protocol 1 (x86_64-abi) > [ 107.203711] xen-blkback:ring-ref 10, event-channel 15, protocol 1 (x86_64-abi) > [ 107.208481] xen-blkback:ring-ref 11, event-channel 16, protocol 1 (x86_64-abi) > [ 107.212081] xen-blkback:ring-ref 12, event-channel 17, protocol 1 (x86_64-abi) > [ 733.434608] PM: Syncing filesystems ... done. > [ 733.436228] PM: Preparing system for mem sleep > [ 733.514803] Freezing user space processes ... (elapsed 0.01 seconds) done. > [ 733.530594] Freezing remaining freezable tasks ... (elapsed 0.01 seconds) done. > [ 733.546589] PM: Entering mem sleep > [ 733.546741] Suspending console(s) (use no_console_suspend to debug) > [ 733.547431] sd 0:0:0:0: [sda] Synchronizing SCSI cache > [ 733.558336] sd 0:0:0:0: [sda] Stopping disk > [ 734.194656] PM: suspend of devices complete after 647.504 msecs > [ 734.195026] PM: late suspend of devices complete after 0.359 msecs > [ 734.210655] PM: noirq suspend of devices complete after 15.614 msecs > [ 734.211326] ACPI: Preparing to enter system sleep state S3 > [ 734.235008] PM: Saving platform NVS memory > [ 734.328066] Disabling non-boot CPUs ... > [ 735.945491] ACPI: Low-level resume complete > [ 735.945579] PM: Restoring platform NVS memory > [ 736.000094] Enabling non-boot CPUs ... > [ 736.000256] installing Xen timer for CPU 1 > [ 736.004594] CPU1 is up > [ 736.004819] installing Xen timer for CPU 2 > [ 736.067516] CPU2 is up > [ 736.067770] installing Xen timer for CPU 3 > [ 736.101535] CPU3 is up > [ 736.102470] ACPI: Waking up from system sleep state S3 > [ 736.555932] PM: noirq resume of devices complete after 7.970 msecs > [ 736.556506] PM: early resume of devices complete after 0.387 msecs > [ 736.660336] i915 0000:00:02.0: setting latency timer to 64 > [ 736.660404] pciback 0000:00:19.0: setting latency timer to 64 > [ 736.660453] xen: registering gsi 16 triggering 0 polarity 1 > [ 736.660460] Already setup the GSI :16 > [ 736.660490] pciback 0000:00:1a.0: setting latency timer to 64 > [ 736.660605] xen: registering gsi 17 triggering 0 polarity 1 > [ 736.660610] Already setup the GSI :17 > [ 736.660641] pciback 0000:00:1d.0: setting latency timer to 64 > [ 736.660696] xen: registering gsi 22 triggering 0 polarity 1 > [ 736.660701] Already setup the GSI :22 > [ 736.661221] ahci 0000:00:1f.2: setting latency timer to 64 > [ 736.689606] xen: registering gsi 18 triggering 0 polarity 1 > [ 736.689608] Already setup the GSI :18 > [ 736.689704] xen: registering gsi 17 triggering 0 polarity 1 > [ 736.689706] Already setup the GSI :17 > [ 736.711623] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp off > [ 736.802676] watchdog: INTCAMT: cannot register miscdev on minor=130 (err=-16) > [ 736.802678] watchdog: error registering /dev/watchdog (err=-16) > [ 736.802680] mei 0000:00:16.0: unable to register watchdog device. > [ 737.060106] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 300) > [ 737.060330] ata4: SATA link down (SStatus 0 SControl 300) > [ 737.060372] ata5: SATA link down (SStatus 0 SControl 300) > [ 737.074123] ata2.00: configured for UDMA/133 > [ 737.117629] ata6: SATA link down (SStatus 0 SControl 300) > [ 738.619036] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) > [ 738.743565] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by device (Stat=0x51 Err=0x04) > [ 738.901088] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by device (Stat=0x51 Err=0x04) > [ 738.903441] ata1.00: configured for UDMA/100 > [ 738.903843] sd 0:0:0:0: [sda] Starting disk > [ 738.905367] PM: resume of devices complete after 2348.851 msecs > [ 738.905922] PM: Finishing wakeup. > [ 738.905926] Restarting tasks ... done. > [ 738.911334] video LNXVIDEO:00: Restoring backlight state > [ 739.836250] dell_wmi: Received unknown WMI event (0x0) > [ 740.184759] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 740.239730] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 740.327711] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 740.373931] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > [ 742.542022] hrtimer: interrupt took 102980031 ns > [ 757.609031] [sched_delayed] sched: RT throttling activated > [ 760.164427] hda-intel: IRQ timing workaround is activated for card #0. Suggest a bigger bdl_pos_adj. > (XEN) Xen version 4.1.3 (user@marmarek.net) (gcc version 4.4.5 20101112 (Red Hat 4.4.5-2) (GCC) ) Mon Nov 26 15:25:32 EST 2012 > (XEN) Latest ChangeSet: unavailable > (XEN) Bootloader: GNU GRUB 0.97 > (XEN) Command line: console=none cpufreq=verbose=1 > (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 1 MBR signatures > (XEN) Found 1 EDD information structures > (XEN) Xen-e820 RAM map: > (XEN) 0000000000000000 - 000000000009a800 (usable) > (XEN) 000000000009a800 - 00000000000a0000 (reserved) > (XEN) 00000000000e0000 - 0000000000100000 (reserved) > (XEN) 0000000000100000 - 0000000007eea000 (usable) > (XEN) 0000000007eea000 - 0000000007f67000 (ACPI NVS) > (XEN) 0000000007f67000 - 0000000007f70000 (usable) > (XEN) 0000000007f70000 - 0000000007f76000 (ACPI NVS) > (XEN) 0000000007f76000 - 0000000007f78000 (usable) > (XEN) 0000000007f78000 - 0000000008000000 (ACPI NVS) > (XEN) 0000000008000000 - 000000000dffd000 (usable) > (XEN) 000000000dffd000 - 000000000e000000 (ACPI data) > (XEN) 000000000e000000 - 0000000020000000 (usable) > (XEN) 0000000020000000 - 0000000020200000 (reserved) > (XEN) 0000000020200000 - 0000000040000000 (usable) > (XEN) 0000000040000000 - 0000000040200000 (reserved) > (XEN) 0000000040200000 - 00000000c83b4000 (usable) > (XEN) 00000000c83b4000 - 00000000c840a000 (reserved) > (XEN) 00000000c840a000 - 00000000c840e000 (usable) > (XEN) 00000000c840e000 - 00000000c840f000 (reserved) > (XEN) 00000000c840f000 - 00000000c8411000 (usable) > (XEN) 00000000c8411000 - 00000000c8414000 (reserved) > (XEN) 00000000c8414000 - 00000000c841e000 (usable) > (XEN) 00000000c841e000 - 00000000c8428000 (reserved) > (XEN) 00000000c8428000 - 00000000c8432000 (usable) > (XEN) 00000000c8432000 - 00000000c8436000 (reserved) > (XEN) 00000000c8436000 - 00000000cac00000 (usable) > (XEN) 00000000cb800000 - 00000000cfa00000 (reserved) > (XEN) 00000000fed1c000 - 00000000fed20000 (reserved) > (XEN) 00000000ffc00000 - 00000000ffc20000 (reserved) > (XEN) 0000000100000000 - 000000042e000000 (usable) > (XEN) ACPI: RSDP 000FE300, 0024 (r2 DELL ) > (XEN) ACPI: XSDT 0DFFEE18, 007C (r1 DELL CBX3 6222004 MSFT 10013) > (XEN) ACPI: FACP 07F90D98, 00F4 (r4 DELL CBX3 6222004 MSFT 10013) > (XEN) ACPI: DSDT 07F5E018, 8834 (r2 INT430 SYSFexxx 1001 INTL 20090903) > (XEN) ACPI: FACS 07FEDD40, 0040 > (XEN) ACPI: APIC 0DFFDF18, 00CC (r2 DELL CBX3 6222004 MSFT 10013) > (XEN) ACPI: TCPA 07FEED18, 0032 (r2 0 0) > (XEN) ACPI: SSDT 07F91A98, 02F9 (r1 DELLTP TPM 3000 INTL 20090903) > (XEN) ACPI: MCFG 07FEEC98, 003C (r1 DELL SNDYBRDG 6222004 MSFT 97) > (XEN) ACPI: HPET 07FEEC18, 0038 (r1 A M I PCHHPET 6222004 AMI. 3) > (XEN) ACPI: BOOT 07FEEB98, 0028 (r1 DELL CBX3 6222004 AMI 10013) > (XEN) ACPI: SSDT 07F75018, 0804 (r1 PmRef Cpu0Ist 3000 INTL 20090903) > (XEN) ACPI: SSDT 07F74018, 0996 (r1 PmRef CpuPm 3000 INTL 20090903) > (XEN) ACPI: DMAR 07F90C18, 00E8 (r1 INTEL SNB 1 INTL 1) > (XEN) ACPI: SLIC 07F7EC18, 0176 (r3 DELL CBX3 6222004 MSFT 10013) > (XEN) System RAM: 16262MB (16652432kB) > (XEN) Domain heap initialised > (XEN) ACPI: 32/64X FACS address mismatch in FADT - 07fede40/0000000007fedd40, using 32 > (XEN) Processor #0 6:10 APIC version 21 > (XEN) Processor #2 6:10 APIC version 21 > (XEN) Processor #1 6:10 APIC version 21 > (XEN) Processor #3 6:10 APIC version 21 > (XEN) IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23 > (XEN) Enabling APIC mode: Flat. Using 1 I/O APICs > (XEN) Table is not found! > (XEN) Switched to APIC driver x2apic_cluster. > (XEN) Using scheduler: SMP Credit Scheduler (credit) > (XEN) Detected 2494.416 MHz processor. > (XEN) Initing memory sharing. > (XEN) Intel VT-d supported page sizes: 4kB. > (XEN) Intel VT-d supported page sizes: 4kB. > (XEN) Intel VT-d Snoop Control not 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 not enabled. > (XEN) I/O virtualisation enabled > (XEN) - Dom0 mode: Relaxed > (XEN) Enabled directed EOI with ioapic_ack_old on! > (XEN) ENABLING IO-APIC IRQs > (XEN) -> Using old ACK method > (XEN) Platform timer appears to have unexpectedly wrapped 1 times. > (XEN) Platform timer is 14.318MHz HPET > (XEN) Allocated console ring of 16 KiB. > (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) HVM: ASIDs enabled. > (XEN) HVM: VMX enabled > (XEN) HVM: Hardware Assisted Paging (HAP) detected > (XEN) HVM: HAP page sizes: 4kB, 2MB > (XEN) Brought up 4 CPUs > (XEN) *** LOADING DOMAIN 0 *** > (XEN) Xen kernel: 64-bit, lsb, compat32 > (XEN) Dom0 kernel: 64-bit, PAE, lsb, paddr 0x1000000 -> 0x1e13000 > (XEN) PHYSICAL MEMORY ARRANGEMENT: > (XEN) Dom0 alloc.: 0000000418000000->000000041c000000 (4046567 pages to be allocated) > (XEN) Init. ramdisk: 000000042b335000->000000042dfffc00 > (XEN) VIRTUAL MEMORY ARRANGEMENT: > (XEN) Loaded kernel: ffffffff81000000->ffffffff81e13000 > (XEN) Init. ramdisk: ffffffff81e13000->ffffffff84addc00 > (XEN) Phys-Mach map: ffffffff84ade000->ffffffff869f3d90 > (XEN) Start info: ffffffff869f4000->ffffffff869f44b4 > (XEN) Page tables: ffffffff869f5000->ffffffff86a2e000 > (XEN) Boot stack: ffffffff86a2e000->ffffffff86a2f000 > (XEN) TOTAL: ffffffff80000000->ffffffff86c00000 > (XEN) ENTRY ADDRESS: ffffffff8188e200 > (XEN) Dom0 has maximum 4 VCPUs > (XEN) Scrubbing Free RAM: .done. > (XEN) Xen trace buffers: disabled > (XEN) Std. Loglevel: Errors and warnings > (XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings) > (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch input to Xen) > (XEN) Freed 216kB init memory. > (XEN) no cpu_id for acpi_id 5 > (XEN) no cpu_id for acpi_id 6 > (XEN) no cpu_id for acpi_id 7 > (XEN) no cpu_id for acpi_id 8 > (XEN) physdev.c:171: dom0: wrong map_pirq type 3 > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc9000057b030. > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000718030. > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004f2030. > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004fa030. > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000251030. > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000263030. > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc9000026b030. > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000273030. > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004f2030. > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000015030. > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004f2030. > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000015030. > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004f2030. > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc900004fa030. > (XEN) Disabling non-boot CPUs ... > (XEN) Broke affinity for irq 1 > (XEN) Broke affinity for irq 8 > (XEN) Broke affinity for irq 9 > (XEN) Broke affinity for irq 12 > (XEN) Broke affinity for irq 17 > (XEN) Broke affinity for irq 31 > (XEN) Broke affinity for irq 16 > (XEN) Broke affinity for irq 20 > (XEN) Entering ACPI S3 state. > (XEN) mce_intel.c:1162: MCA Capability: BCAST 1 SER 0 CMCI 1 firstbank 0 extended MCE MSR 0 > (XEN) CPU0 CMCI LVT vector (0xf7) already installed > (XEN) CPU0: Thermal LVT vector (0xfa) already installed > (XEN) Finishing wakeup from ACPI S3 state. > (XEN) Enabling non-boot CPUs ... > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000524030. > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc9000052c030. > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc90000015030. > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0000000000000000 to 0xffffc9000001d030. > (XEN) Dumping timer queues: > (XEN) CPU00: > (XEN) ex= 126us timer=ffff8300c83b0060 cb=ffff82c48011e420(ffff8300c83b0000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 1778us timer=ffff8304222f9de8 cb=ffff82c480118250(0000000000000000) csched_tick+0x0/0x2e0 > (XEN) ex= 126us timer=ffff8300c81fc060 cb=ffff82c48011e420(ffff8300c81fc000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 17227us timer=ffff82c4802bb980 cb=ffff82c480138ff0(ffff82c4802bb940) do_dbs_timer+0x0/0x250 > (XEN) ex= 20744us timer=ffff830030094060 cb=ffff82c48011e420(ffff830030094000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 27945us timer=ffff8304222fdde0 cb=ffff82c480116f20(ffff8304222fddc0) csched_acct+0x0/0x460 > (XEN) ex= 29949us timer=ffff82c4802bb760 cb=ffff82c48011ded0(0000000000000000) s_timer_fn+0x0/0x20 > (XEN) ex= 87774us timer=ffff83008db6a060 cb=ffff82c48011e420(ffff83008db6a000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 79252us timer=ffff82c4802b3880 cb=ffff82c480177160(0000000000000000) time_calibration+0x0/0x60 > (XEN) ex= 703146us timer=ffff8300a6b9c060 cb=ffff82c48011e420(ffff8300a6b9c000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 35612us timer=ffff8300330dc060 cb=ffff82c48011e420(ffff8300330dc000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 97688us timer=ffff8300a6b98060 cb=ffff82c48011e420(ffff8300a6b98000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 30003us timer=ffff8300b129a060 cb=ffff82c48011e420(ffff8300b129a000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 92679us timer=ffff8300c94a6060 cb=ffff82c48011e420(ffff8300c94a6000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 4135118us timer=ffff8300bdca6060 cb=ffff82c48011e420(ffff8300bdca6000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 96411us timer=ffff8300b128e060 cb=ffff82c48011e420(ffff8300b128e000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 1337866us timer=ffff8300a6b94060 cb=ffff82c48011e420(ffff8300a6b94000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 91194us timer=ffff830034b98060 cb=ffff82c48011e420(ffff830034b98000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 97955us timer=ffff83007d948060 cb=ffff82c48011e420(ffff83007d948000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 4135163us timer=ffff8300c5336060 cb=ffff82c48011e420(ffff8300c5336000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex=123464409us timer=ffff82c4802b3980 cb=ffff82c480176ef0(0000000000000000) plt_overflow+0x0/0x190 > (XEN) ex= 95968us timer=ffff8300a6b96060 cb=ffff82c48011e420(ffff8300a6b96000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex=12401701us timer=ffff82c4802b65a0 cb=ffff82c48019eb10(0000000000000000) mce_work_fn+0x0/0xd0 > (XEN) ex= 97804us timer=ffff8300301a8060 cb=ffff82c48011e420(ffff8300301a8000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 97841us timer=ffff8300bd810060 cb=ffff82c48011e420(ffff8300bd810000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 98039us timer=ffff83007d94c060 cb=ffff82c48011e420(ffff83007d94c000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 94727us timer=ffff83008db6e060 cb=ffff82c48011e420(ffff83008db6e000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) ex= 319927us timer=ffff8300c840c060 cb=ffff82c48011e420(ffff8300c840c000) vcpu_singleshot_timer_fn+0x0/0x10 > (XEN) CPU01: > (XEN) CPU02: > (XEN) CPU03: > (XEN) 'c' pressed -> printing ACPI Cx structures > (XEN) ==cpu0== > (XEN) active state: C3 > (XEN) max_cstate: C7 > (XEN) states: > (XEN) C1: type[C1] latency[000] usage[00254665] method[ HALT] duration[62720099833] > (XEN) C2: type[C2] latency[080] usage[00069505] method[SYSIO] duration[36499255195] > (XEN) *C3: type[C3] latency[109] usage[01828952] method[SYSIO] duration[5562126933174] > (XEN) C0: usage[02153122] duration[2042526389598] > (XEN) PC3[0] PC6[0] PC7[0] > (XEN) CC3[0] CC6[0] > (XEN) ==cpu1== > (XEN) active state: C1 > (XEN) max_cstate: C7 > (XEN) states: > (XEN) *C1: type[C1] latency[000] usage[00808027] method[ HALT] duration[6978799306750] > (XEN) C0: usage[00808027] duration[725073398104] > (XEN) PC3[0] PC6[0] PC7[0] > (XEN) CC3[0] CC6[0] > (XEN) ==cpu2== > (XEN) active state: C1 > (XEN) max_cstate: C7 > (XEN) states: > (XEN) *C1: type[C1] latency[000] usage[00825022] method[ HALT] duration[6981527416097] > (XEN) C0: usage[00825022] duration[722345319882] > (XEN) PC3[0] PC6[0] PC7[0] > (XEN) CC3[0] CC6[0] > (XEN) ==cpu3== > (XEN) active state: C1 > (XEN) max_cstate: C7 > (XEN) states: > (XEN) *C1: type[C1] latency[000] usage[00810292] method[ HALT] duration[6980835907857] > (XEN) C0: usage[00810292] duration[723036844779] > (XEN) PC3[0] PC6[0] PC7[0] > (XEN) CC3[0] CC6[0] > _______________________________________________ > Xen-devel mailing list > Xen-devel@lists.xen.org > http://lists.xen.org/xen-devel _______________________________________________ Xen-devel mailing list Xen-devel@lists.xen.org http://lists.xen.org/xen-devel From xen-devel-bounces@lists.xen.org Fri Nov 30 22:13:09 2012 Return-path: Envelope-to: archives@lists.xen.org Delivery-date: Fri, 30 Nov 2012 22:13: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 1TeYpF-00013T-2q; Fri, 30 Nov 2012 22:12:49 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1TeYpB-00013M-TJ for xen-devel@lists.xen.org; Fri, 30 Nov 2012 22:12:46 +0000 Received: from [85.158.143.35:6637] by server-1.bemta-4.messagelabs.com id D6/3C-27934-D5F29B05; Fri, 30 Nov 2012 22:12:45 +0000 X-Env-Sender: ben.guthro@gmail.com X-Msg-Ref: server-4.tower-21.messagelabs.com!1354313554!5291115!1 X-Originating-IP: [209.85.210.169] X-SpamReason: No, hits=1.7 required=7.0 tests=BODY_RANDOM_LONG, HTML_10_20,HTML_MESSAGE,RCVD_BY_IP X-StarScan-Received: X-StarScan-Version: 6.6.1.8; banners=-,-,- X-VirusChecked: Checked Received: (qmail 11830 invoked from network); 30 Nov 2012 22:12:36 -0000 Received: from mail-ia0-f169.google.com (HELO mail-ia0-f169.google.com) (209.85.210.169) by server-4.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 30 Nov 2012 22:12:36 -0000 Received: by mail-ia0-f169.google.com with SMTP id r4so690537iaj.28 for ; Fri, 30 Nov 2012 14:12:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:sender:in-reply-to:references:date :x-google-sender-auth:message-id:subject:from:to:cc:content-type; bh=hMY2ti0Zwbiv55FxQkZZqfX5utBgmYbszxzrTlemIkk=; b=OH8ZzKpgTbrIyEA9HHtJNAh+69ce3aSBZ/yBnPO5s+nZnRgC/RSccEGYVhEzukyJZ6 JZTlFpMI3vMFukcIRFilttOdBl6hqkzc18ZTtpp4cd5hi6phVVRAHDm4GIKTLavT/yJR Y7z3Xlrwb3wZcPDhh/lE1VYaTqNYKKTHqviQ2bCOf8/hXF8DosEMSOwFhOGPOW4fuioF 6cM9MQU9z9ArZqBiYeXM4csWFtbR1JJe9/fuyjzvbaPB67Aesbe6hdqTToK6NkZvhMAN vHEtLyBQu03axpdQ2t8+s/AbZHNGakjn7JvnAVAlFpnUtNtaaFqG+IXZdOMbD2Jo5njh eKew== MIME-Version: 1.0 Received: by 10.50.91.168 with SMTP id cf8mr13823igb.20.1354313553844; Fri, 30 Nov 2012 14:12:33 -0800 (PST) Received: by 10.231.17.13 with HTTP; Fri, 30 Nov 2012 14:12:33 -0800 (PST) In-Reply-To: <20121130213345.GA4715@phenom.dumpdata.com> References: <50B7AF8A.5010304@invisiblethingslab.com> <20121130213345.GA4715@phenom.dumpdata.com> Date: Fri, 30 Nov 2012 17:12:33 -0500 X-Google-Sender-Auth: zGxg0Q97PiVhb149uShtEAzEvw0 Message-ID: From: Ben Guthro To: Konrad Rzeszutek Wilk Cc: Marek Marczykowski , xen-devel Subject: Re: [Xen-devel] Only CPU0 active after ACPI S3, xen 4.1.3 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: multipart/mixed; boundary="===============3744638461939860863==" Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org --===============3744638461939860863== Content-Type: multipart/alternative; boundary=e89a8f3b9d3d4a9abe04cfbdb242 --e89a8f3b9d3d4a9abe04cfbdb242 Content-Type: text/plain; charset=ISO-8859-1 I had similar, but (I think) different issues. See the following thread: http://markmail.org/search/?q=e4a31205766d518276d0fbc1780bcd63db1a502d#query:e4a31205766d518276d0fbc1780bcd63db1a502d+page:1+mid:udkd2qcvtyqj75re+state:results I still have a patch reverting part of this changeset to get S3 working with pinning CPU affinity... the affinity doesn't get restored on resume, however. I don't have much experience with this on Xen 4.1, as I ran into the issue when bringing up Xen-4.2, from Xen 4.0 However, I could see how this could be related, since it is in the scheduler... On Fri, Nov 30, 2012 at 4:33 PM, Konrad Rzeszutek Wilk wrote: > On Thu, Nov 29, 2012 at 07:55:06PM +0100, Marek Marczykowski wrote: > > Hi all, > > > > After resume from ACPI S3 system has only CPU0 enabled, every vCPU from > every > > domain works on CPU0 [1]. When trying to pin some vCPU to CPU1 got > error: > > xl vcpu-pin testvm 1 1 > > libxl: error: libxl.c:2565:libxl_set_vcpuaffinity setting vcpu affinity: > > Invalid argument > > > > What went wrong? How can I reenable CPU1-CPU3? > > I think Ben had found some issues with this in the past? CC-ing him > here. > > > > System info: > > xen 4.1.3 > > linux 3.4.18 with acpi-s3 patches from Konrad's git > > Processor: Intel i5-2520M > > > > dmesg from dom0 and hypervisor attached. > > > > BTW Are there any plans to upstream acpi-s3 patches? > > > > [1] xl vcpu-list: > > Name ID VCPU CPU State Time(s) CPU > Affinity > > dom0 0 0 0 r-- 1347.8 any > cpu > > dom0 0 1 0 -b- 594.4 any > cpu > > dom0 0 2 0 -b- 421.1 any > cpu > > dom0 0 3 0 -b- 432.6 any > cpu > > netvm 1 0 0 -b- 596.6 any > cpu > > netvm 1 1 0 -b- 363.7 any > cpu > > firewallvm 2 0 0 -b- 170.5 any > cpu > > firewallvm 2 1 0 -b- 122.5 any > cpu > > devel17 3 0 0 -b- 137.0 any > cpu > > devel17 3 1 0 -b- 112.9 any > cpu > > devel17 3 2 0 -b- 97.9 any > cpu > > devel17 3 3 0 -b- 116.0 any > cpu > > vm2 4 0 0 -b- 418.6 any > cpu > > vm2 4 1 0 -b- 390.2 any > cpu > > private 5 0 0 -b- 175.9 any > cpu > > private 5 1 0 -b- 161.6 any > cpu > > mail 6 0 0 -b- 1587.1 any > cpu > > mail 6 1 0 -b- 1717.5 any > cpu > > testvm 7 0 0 -b- 73.0 any > cpu > > testvm 7 1 0 -b- 68.9 any > cpu > > testvm 7 2 0 -b- 51.4 any > cpu > > testvm 7 3 0 -b- 67.1 any > cpu > > disp1 8 0 0 -b- 199.9 any > cpu > > > > > > -- > > Best Regards / Pozdrawiam, > > Marek Marczykowski > > Invisible Things Lab > > > [ 0.000000] Initializing cgroup subsys cpuset > > [ 0.000000] Initializing cgroup subsys cpu > > [ 0.000000] Linux version 3.4.18-2.pvops.qubes.x86_64 ( > user@nemezis.marmarek.net) (gcc version 4.4.5 20101112 (Red Hat 4.4.5-2) > (GCC) ) #1 SMP Wed Nov 7 22:47:21 EST 2012 > > [ 0.000000] Command line: ro root=/dev/mapper/vg_dom0-lv_root > rd_LUKS_UUID=luks-400336fa-c7c4-4be3-a244-c909aa16a18c > rd_LVM_LV=vg_dom0/lv_root rd_LVM_LV=vg_dom0/lv_swap rd_NO_MD rd_NO_DM > LANG=en_US.UTF-8 SYSFONT=latarcyrheb-sun16 KEYTABLE=pl2 rhgb quiet > max_loop=255 > > [ 0.000000] Freeing 9a-100 pfn range: 102 pages freed > > [ 0.000000] 1-1 mapping on 9a->100 > > [ 0.000000] Freeing 7eea-7f67 pfn range: 125 pages freed > > [ 0.000000] 1-1 mapping on 7eea->7f67 > > [ 0.000000] Freeing 7f70-7f76 pfn range: 6 pages freed > > [ 0.000000] 1-1 mapping on 7f70->7f76 > > [ 0.000000] Freeing 7f78-8000 pfn range: 136 pages freed > > [ 0.000000] 1-1 mapping on 7f78->8000 > > [ 0.000000] Freeing dffd-e000 pfn range: 3 pages freed > > [ 0.000000] 1-1 mapping on dffd->e000 > > [ 0.000000] Freeing 20000-20200 pfn range: 512 pages freed > > [ 0.000000] 1-1 mapping on 20000->20200 > > [ 0.000000] Freeing 40000-40200 pfn range: 512 pages freed > > [ 0.000000] 1-1 mapping on 40000->40200 > > [ 0.000000] Freeing c83b4-c840a pfn range: 86 pages freed > > [ 0.000000] 1-1 mapping on c83b4->c840a > > [ 0.000000] Freeing c840e-c840f pfn range: 1 pages freed > > [ 0.000000] 1-1 mapping on c840e->c840f > > [ 0.000000] Freeing c8411-c8414 pfn range: 3 pages freed > > [ 0.000000] 1-1 mapping on c8411->c8414 > > [ 0.000000] Freeing c841e-c8428 pfn range: 10 pages freed > > [ 0.000000] 1-1 mapping on c841e->c8428 > > [ 0.000000] Freeing c8432-c8436 pfn range: 4 pages freed > > [ 0.000000] 1-1 mapping on c8432->c8436 > > [ 0.000000] Freeing cac00-100000 pfn range: 218112 pages freed > > [ 0.000000] 1-1 mapping on cac00->100000 > > [ 0.000000] Released 219612 pages of unused memory > > [ 0.000000] Set 219612 page(s) to 1-1 mapping > > [ 0.000000] BIOS-provided physical RAM map: > > [ 0.000000] Xen: 0000000000000000 - 000000000009a000 (usable) > > [ 0.000000] Xen: 000000000009a800 - 0000000000100000 (reserved) > > [ 0.000000] Xen: 0000000000100000 - 0000000007eea000 (usable) > > [ 0.000000] Xen: 0000000007eea000 - 0000000007f67000 (ACPI NVS) > > [ 0.000000] Xen: 0000000007f67000 - 0000000007f70000 (usable) > > [ 0.000000] Xen: 0000000007f70000 - 0000000007f76000 (ACPI NVS) > > [ 0.000000] Xen: 0000000007f76000 - 0000000007f78000 (usable) > > [ 0.000000] Xen: 0000000007f78000 - 0000000008000000 (ACPI NVS) > > [ 0.000000] Xen: 0000000008000000 - 000000000dffd000 (usable) > > [ 0.000000] Xen: 000000000dffd000 - 000000000e000000 (ACPI data) > > [ 0.000000] Xen: 000000000e000000 - 0000000020000000 (usable) > > [ 0.000000] Xen: 0000000020000000 - 0000000020200000 (reserved) > > [ 0.000000] Xen: 0000000020200000 - 0000000040000000 (usable) > > [ 0.000000] Xen: 0000000040000000 - 0000000040200000 (reserved) > > [ 0.000000] Xen: 0000000040200000 - 00000000c83b4000 (usable) > > [ 0.000000] Xen: 00000000c83b4000 - 00000000c840a000 (reserved) > > [ 0.000000] Xen: 00000000c840a000 - 00000000c840e000 (usable) > > [ 0.000000] Xen: 00000000c840e000 - 00000000c840f000 (reserved) > > [ 0.000000] Xen: 00000000c840f000 - 00000000c8411000 (usable) > > [ 0.000000] Xen: 00000000c8411000 - 00000000c8414000 (reserved) > > [ 0.000000] Xen: 00000000c8414000 - 00000000c841e000 (usable) > > [ 0.000000] Xen: 00000000c841e000 - 00000000c8428000 (reserved) > > [ 0.000000] Xen: 00000000c8428000 - 00000000c8432000 (usable) > > [ 0.000000] Xen: 00000000c8432000 - 00000000c8436000 (reserved) > > [ 0.000000] Xen: 00000000c8436000 - 00000000cac00000 (usable) > > [ 0.000000] Xen: 00000000cb800000 - 00000000cfa00000 (reserved) > > [ 0.000000] Xen: 00000000fec00000 - 00000000fec01000 (reserved) > > [ 0.000000] Xen: 00000000fed1c000 - 00000000fed20000 (reserved) > > [ 0.000000] Xen: 00000000fee00000 - 00000000fee01000 (reserved) > > [ 0.000000] Xen: 00000000ffc00000 - 00000000ffc20000 (reserved) > > [ 0.000000] Xen: 0000000100000000 - 000000042e000000 (usable) > > [ 0.000000] NX (Execute Disable) protection: active > > [ 0.000000] DMI 2.6 present. > > [ 0.000000] DMI: Dell Inc. Latitude E6420/0K0DNP, BIOS A13 05/17/2012 > > [ 0.000000] e820 update range: 0000000000000000 - 0000000000010000 > (usable) ==> (reserved) > > [ 0.000000] e820 remove range: 00000000000a0000 - 0000000000100000 > (usable) > > [ 0.000000] No AGP bridge found > > [ 0.000000] last_pfn = 0x42e000 max_arch_pfn = 0x400000000 > > [ 0.000000] x2apic enabled by BIOS, switching to x2apic ops > > [ 0.000000] last_pfn = 0xcac00 max_arch_pfn = 0x400000000 > > [ 0.000000] found SMP MP-table at [ffff8800000f1ad0] f1ad0 > > [ 0.000000] initial memory mapped : 0 - 04ade000 > > [ 0.000000] Base memory trampoline at [ffff880000095000] 95000 size > 20480 > > [ 0.000000] init_memory_mapping: 0000000000000000-00000000cac00000 > > [ 0.000000] 0000000000 - 00cac00000 page 4k > > [ 0.000000] kernel direct mapping tables up to 0xcabfffff @ [mem > 0x009a5000-0x00ffffff] > > [ 0.000000] xen: setting RW the range fc4000 - 1000000 > > [ 0.000000] init_memory_mapping: 0000000100000000-000000042e000000 > > [ 0.000000] 0100000000 - 042e000000 page 4k > > [ 0.000000] kernel direct mapping tables up to 0x42dffffff @ [mem > 0xc9282000-0xcabfffff] > > [ 0.000000] xen: setting RW the range cabff000 - cac00000 > > [ 0.000000] RAMDISK: 01e13000 - 04ade000 > > [ 0.000000] ACPI: RSDP 00000000000fe300 00024 (v02 DELL ) > > [ 0.000000] ACPI: XSDT 000000000dffee18 0007C (v01 DELL CBX3 > 06222004 MSFT 00010013) > > [ 0.000000] ACPI: FACP 0000000007f90d98 000F4 (v04 DELL CBX3 > 06222004 MSFT 00010013) > > [ 0.000000] ACPI Warning: 32/64 FACS address mismatch in FADT - two > FACS tables! (20120320/tbfadt-378) > > [ 0.000000] ACPI Warning: 32/64X FACS address mismatch in FADT - > 0x07FEDE40/0x0000000007FEDD40, using 32 (20120320/tbfadt-502) > > [ 0.000000] ACPI: DSDT 0000000007f5e018 08834 (v02 INT430 SYSFexxx > 00001001 INTL 20090903) > > [ 0.000000] ACPI: FACS 0000000007fede40 00040 > > [ 0.000000] ACPI: APIC 000000000dffdf18 000CC (v02 DELL CBX3 > 06222004 MSFT 00010013) > > [ 0.000000] ACPI: TCPA 0000000007feed18 00032 (v02 > 00000000 00000000) > > [ 0.000000] ACPI: SSDT 0000000007f91a98 002F9 (v01 DELLTP TPM > 00003000 INTL 20090903) > > [ 0.000000] ACPI: MCFG 0000000007feec98 0003C (v01 DELL SNDYBRDG > 06222004 MSFT 00000097) > > [ 0.000000] ACPI: HPET 0000000007feec18 00038 (v01 A M I PCHHPET > 06222004 AMI. 00000003) > > [ 0.000000] ACPI: BOOT 0000000007feeb98 00028 (v01 DELL CBX3 > 06222004 AMI 00010013) > > [ 0.000000] ACPI: SSDT 0000000007f75018 00804 (v01 PmRef Cpu0Ist > 00003000 INTL 20090903) > > [ 0.000000] ACPI: SSDT 0000000007f74018 00996 (v01 PmRef CpuPm > 00003000 INTL 20090903) > > [ 0.000000] ACPI: XMAR 0000000007f90c18 000E8 (v01 INTEL SNB > 00000001 INTL 00000001) > > [ 0.000000] ACPI: SLIC 0000000007f7ec18 00176 (v03 DELL CBX3 > 06222004 MSFT 00010013) > > [ 0.000000] ACPI: Local APIC address 0xfee00000 > > [ 0.000000] Setting APIC routing to cluster x2apic. > > [ 0.000000] Zone PFN ranges: > > [ 0.000000] DMA 0x00000010 -> 0x00001000 > > [ 0.000000] DMA32 0x00001000 -> 0x00100000 > > [ 0.000000] Normal 0x00100000 -> 0x0042e000 > > [ 0.000000] Movable zone start PFN for each node > > [ 0.000000] Early memory PFN ranges > > [ 0.000000] 0: 0x00000010 -> 0x0000009a > > [ 0.000000] 0: 0x00000100 -> 0x00007eea > > [ 0.000000] 0: 0x00007f67 -> 0x00007f70 > > [ 0.000000] 0: 0x00007f76 -> 0x00007f78 > > [ 0.000000] 0: 0x00008000 -> 0x0000dffd > > [ 0.000000] 0: 0x0000e000 -> 0x00020000 > > [ 0.000000] 0: 0x00020200 -> 0x00040000 > > [ 0.000000] 0: 0x00040200 -> 0x000c83b4 > > [ 0.000000] 0: 0x000c840a -> 0x000c840e > > [ 0.000000] 0: 0x000c840f -> 0x000c8411 > > [ 0.000000] 0: 0x000c8414 -> 0x000c841e > > [ 0.000000] 0: 0x000c8428 -> 0x000c8432 > > [ 0.000000] 0: 0x000c8436 -> 0x000cac00 > > [ 0.000000] 0: 0x00100000 -> 0x0042e000 > > [ 0.000000] On node 0 totalpages: 4163092 > > [ 0.000000] DMA zone: 56 pages used for memmap > > [ 0.000000] DMA zone: 1572 pages reserved > > [ 0.000000] DMA zone: 2350 pages, LIFO batch:0 > > [ 0.000000] DMA32 zone: 14280 pages used for memmap > > [ 0.000000] DMA32 zone: 810690 pages, LIFO batch:31 > > [ 0.000000] Normal zone: 45584 pages used for memmap > > [ 0.000000] Normal zone: 3288560 pages, LIFO batch:31 > > [ 0.000000] ACPI: PM-Timer IO Port: 0x408 > > [ 0.000000] ACPI: Local APIC address 0xfee00000 > > [ 0.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x00] enabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x03] lapic_id[0x01] enabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x04] lapic_id[0x03] enabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x05] lapic_id[0x04] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x06] lapic_id[0x05] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x07] lapic_id[0x06] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x08] lapic_id[0x07] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x09] lapic_id[0x08] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0a] lapic_id[0x09] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0b] lapic_id[0x0a] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0c] lapic_id[0x0b] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0d] lapic_id[0x0c] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0e] lapic_id[0x0d] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x0f] lapic_id[0x0e] disabled) > > [ 0.000000] ACPI: LAPIC (acpi_id[0x10] lapic_id[0x0f] disabled) > > [ 0.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0]) > > [ 0.000000] IOAPIC[0]: apic_id 2, version 253, address 0xfec00000, > GSI 0-253 > > [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl dfl) > > [ 0.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 high > level) > > [ 0.000000] ACPI: IRQ0 used by override. > > [ 0.000000] ACPI: IRQ2 used by override. > > [ 0.000000] ACPI: IRQ9 used by override. > > [ 0.000000] Using ACPI (MADT) for SMP configuration information > > [ 0.000000] ACPI: HPET id: 0x8086a701 base: 0xfed00000 > > [ 0.000000] SMP: Allowing 16 CPUs, 12 hotplug CPUs > > [ 0.000000] nr_irqs_gsi: 270 > > [ 0.000000] Allocating PCI resources starting at cfa00000 (gap: > cfa00000:2f200000) > > [ 0.000000] Booting paravirtualized kernel on Xen > > [ 0.000000] Xen version: 4.1.3 (preserve-AD) > > [ 0.000000] setup_percpu: NR_CPUS:512 nr_cpumask_bits:512 > nr_cpu_ids:16 nr_node_ids:1 > > [ 0.000000] PERCPU: Embedded 28 pages/cpu @ffff8803e2800000 s82176 > r8192 d24320 u131072 > > [ 0.000000] pcpu-alloc: s82176 r8192 d24320 u131072 alloc=1*2097152 > > [ 0.000000] pcpu-alloc: [0] 00 01 02 03 04 05 06 07 08 09 10 11 12 13 > 14 15 > > [ 4.119805] Built 1 zonelists in Zone order, mobility grouping on. > Total pages: 4101600 > > [ 4.119809] Kernel command line: ro root=/dev/mapper/vg_dom0-lv_root > rd_LUKS_UUID=luks-400336fa-c7c4-4be3-a244-c909aa16a18c > rd_LVM_LV=vg_dom0/lv_root rd_LVM_LV=vg_dom0/lv_swap rd_NO_MD rd_NO_DM > LANG=en_US.UTF-8 SYSFONT=latarcyrheb-sun16 KEYTABLE=pl2 rhgb quiet > max_loop=255 > > [ 4.119915] PID hash table entries: 4096 (order: 3, 32768 bytes) > > [ 4.120928] Dentry cache hash table entries: 2097152 (order: 12, > 16777216 bytes) > > [ 4.124018] Inode-cache hash table entries: 1048576 (order: 11, > 8388608 bytes) > > [ 4.147064] Placing 64MB software IO TLB between ffff8803ce200000 - > ffff8803d2200000 > > [ 4.147066] software IO TLB at phys 0x3ce200000 - 0x3d2200000 > > [ 4.181675] Memory: 14975940k/17530880k available (4557k kernel code, > 878512k absent, 1676428k reserved, 4112k data, 552k init) > > [ 4.181730] Hierarchical RCU implementation. > > [ 4.181731] RCU dyntick-idle grace-period acceleration is > enabled. > > [ 4.181738] NR_IRQS:33024 nr_irqs:1024 16 > > [ 4.181799] xen: sci override: global_irq=9 trigger=0 polarity=0 > > [ 4.181801] xen: registering gsi 9 triggering 0 polarity 0 > > [ 4.181809] xen: --> pirq=9 -> irq=9 (gsi=9) > > [ 4.181829] xen: acpi sci 9 > > [ 4.181831] xen: --> pirq=1 -> irq=1 (gsi=1) > > [ 4.181834] xen: --> pirq=2 -> irq=2 (gsi=2) > > [ 4.181836] xen: --> pirq=3 -> irq=3 (gsi=3) > > [ 4.181838] xen: --> pirq=4 -> irq=4 (gsi=4) > > [ 4.181840] xen: --> pirq=5 -> irq=5 (gsi=5) > > [ 4.181843] xen: --> pirq=6 -> irq=6 (gsi=6) > > [ 4.181845] xen: --> pirq=7 -> irq=7 (gsi=7) > > [ 4.181847] xen: --> pirq=8 -> irq=8 (gsi=8) > > [ 4.181849] xen: --> pirq=10 -> irq=10 (gsi=10) > > [ 4.181851] xen: --> pirq=11 -> irq=11 (gsi=11) > > [ 4.181854] xen: --> pirq=12 -> irq=12 (gsi=12) > > [ 4.181856] xen: --> pirq=13 -> irq=13 (gsi=13) > > [ 4.181858] xen: --> pirq=14 -> irq=14 (gsi=14) > > [ 4.181860] xen: --> pirq=15 -> irq=15 (gsi=15) > > [ 4.182986] Console: colour VGA+ 80x25 > > [ 4.183012] console [tty0] enabled > > [ 4.183026] Xen: using vcpuop timer interface > > [ 4.183030] installing Xen timer for CPU 0 > > [ 4.183048] Detected 2494.416 MHz processor. > > [ 4.183052] Calibrating delay loop (skipped), value calculated using > timer frequency.. 4988.83 BogoMIPS (lpj=9977664) > > [ 4.183054] pid_max: default: 32768 minimum: 301 > > [ 4.183090] Mount-cache hash table entries: 256 > > [ 4.183222] Initializing cgroup subsys cpuacct > > [ 4.183224] Initializing cgroup subsys devices > > [ 4.183225] Initializing cgroup subsys freezer > > [ 4.183227] Initializing cgroup subsys net_cls > > [ 4.183228] Initializing cgroup subsys blkio > > [ 4.183280] ENERGY_PERF_BIAS: Set to 'normal', was 'performance' > > [ 4.183281] ENERGY_PERF_BIAS: View and update with > x86_energy_perf_policy(8) > > [ 4.183284] CPU: Physical Processor ID: 0 > > [ 4.183285] CPU: Processor Core ID: 0 > > [ 4.184454] ACPI: Core revision 20120320 > > [ 4.194658] Performance Events: unsupported p6 CPU model 42 no PMU > driver, software events only. > > [ 4.194796] installing Xen timer for CPU 1 > > [ 4.194988] installing Xen timer for CPU 2 > > [ 4.195140] installing Xen timer for CPU 3 > > [ 4.195232] Brought up 4 CPUs > > [ 4.195477] devtmpfs: initialized > > [ 4.199046] PM: Registering ACPI NVS region [mem > 0x07eea000-0x07f66fff] (512000 bytes) > > [ 4.199056] PM: Registering ACPI NVS region [mem > 0x07f70000-0x07f75fff] (24576 bytes) > > [ 4.199058] PM: Registering ACPI NVS region [mem > 0x07f78000-0x07ffffff] (557056 bytes) > > [ 4.199069] Dell Latitude E6420 series board detected. Selecting > PCI-method for reboots. > > [ 4.199104] Grant tables using version 2 layout. > > [ 4.199114] Grant table initialized > > [ 4.199158] dummy: > > [ 4.199205] RTC time: 1:19:35, date: 11/29/12 > > [ 4.199256] NET: Registered protocol family 16 > > [ 4.199465] ACPI FADT declares the system doesn't support PCIe ASPM, > so disable it > > [ 4.199467] ACPI: bus type pci registered > > [ 4.199548] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem > 0xf8000000-0xfbffffff] (base 0xf8000000) > > [ 4.199550] PCI: not using MMCONFIG > > [ 4.199552] PCI: Using configuration type 1 for base access > > [ 4.199559] dmi type 0xB1 record - unknown flag > > [ 4.200155] bio: create slab at 0 > > [ 4.200279] ACPI: Added _OSI(Module Device) > > [ 4.200280] ACPI: Added _OSI(Processor Device) > > [ 4.200282] ACPI: Added _OSI(3.0 _SCP Extensions) > > [ 4.200283] ACPI: Added _OSI(Processor Aggregator Device) > > [ 4.201815] ACPI: EC: Look up EC in DSDT > > [ 4.206932] [Firmware Bug]: ACPI: BIOS _OSI(Linux) query ignored > > [ 4.219266] ACPI: SSDT 00000000c8412798 00727 (v01 PmRef Cpu0Cst > 00003001 INTL 20090903) > > [ 4.219654] ACPI: Dynamic OEM Table Load: > > [ 4.219657] ACPI: SSDT (null) 00727 (v01 PmRef Cpu0Cst > 00003001 INTL 20090903) > > [ 4.220118] ACPI: SSDT 00000000c8413a98 00303 (v01 PmRef ApIst > 00003000 INTL 20090903) > > [ 4.220555] ACPI: Dynamic OEM Table Load: > > [ 4.220558] ACPI: SSDT (null) 00303 (v01 PmRef ApIst > 00003000 INTL 20090903) > > [ 4.220754] ACPI: SSDT 00000000c8411d98 00119 (v01 PmRef ApCst > 00003000 INTL 20090903) > > [ 4.221136] ACPI: Dynamic OEM Table Load: > > [ 4.221138] ACPI: SSDT (null) 00119 (v01 PmRef ApCst > 00003000 INTL 20090903) > > [ 4.223275] ACPI: Interpreter enabled > > [ 4.223278] ACPI: (supports S0 S3 S5) > > [ 4.223294] ACPI: Using IOAPIC for interrupt routing > > [ 4.223322] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem > 0xf8000000-0xfbffffff] (base 0xf8000000) > > [ 4.223846] PCI: MMCONFIG at [mem 0xf8000000-0xfbffffff] reserved in > ACPI motherboard resources > > [ 4.271283] ACPI: EC: GPE = 0x10, I/O: command/status = 0x934, data = > 0x930 > > [ 4.272424] ACPI: No dock devices found. > > [ 4.272428] PCI: Using host bridge windows from ACPI; if necessary, > use "pci=nocrs" and report a bug > > [ 4.272988] \_SB_.PCI0:_OSC invalid UUID > > [ 4.272989] _OSC request data:1 8 1f > > [ 4.272992] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-3e]) > > [ 4.273994] pci_root PNP0A08:00: host bridge window [io > 0x0000-0x0cf7] > > [ 4.273996] pci_root PNP0A08:00: host bridge window [io > 0x0d00-0xffff] > > [ 4.273998] pci_root PNP0A08:00: host bridge window [mem > 0x000a0000-0x000bffff] > > [ 4.274001] pci_root PNP0A08:00: host bridge window [mem > 0xcfa00000-0xfeafffff] > > [ 4.274003] pci_root PNP0A08:00: host bridge window [mem > 0xfed40000-0xfed44fff] > > [ 4.274031] PCI host bridge to bus 0000:00 > > [ 4.274033] pci_bus 0000:00: root bus resource [io 0x0000-0x0cf7] > > [ 4.274034] pci_bus 0000:00: root bus resource [io 0x0d00-0xffff] > > [ 4.274036] pci_bus 0000:00: root bus resource [mem > 0x000a0000-0x000bffff] > > [ 4.274038] pci_bus 0000:00: root bus resource [mem > 0xcfa00000-0xfeafffff] > > [ 4.274040] pci_bus 0000:00: root bus resource [mem > 0xfed40000-0xfed44fff] > > [ 4.274054] pci 0000:00:00.0: [8086:0104] type 00 class 0x060000 > > [ 4.274147] pci 0000:00:02.0: [8086:0126] type 00 class 0x030000 > > [ 4.274174] pci 0000:00:02.0: reg 10: [mem 0xe1400000-0xe17fffff > 64bit] > > [ 4.274189] pci 0000:00:02.0: reg 18: [mem 0xd0000000-0xdfffffff > 64bit pref] > > [ 4.274200] pci 0000:00:02.0: reg 20: [io 0x4000-0x403f] > > [ 4.274344] pci 0000:00:16.0: [8086:1c3a] type 00 class 0x078000 > > [ 4.274394] pci 0000:00:16.0: reg 10: [mem 0xe2eb0000-0xe2eb000f > 64bit] > > [ 4.274563] pci 0000:00:16.0: PME# supported from D0 D3hot D3cold > > [ 4.274636] pci 0000:00:19.0: [8086:1502] type 00 class 0x020000 > > [ 4.274681] pci 0000:00:19.0: reg 10: [mem 0xe2e00000-0xe2e1ffff] > > [ 4.274700] pci 0000:00:19.0: reg 14: [mem 0xe2e80000-0xe2e80fff] > > [ 4.274719] pci 0000:00:19.0: reg 18: [io 0x4080-0x409f] > > [ 4.274883] pci 0000:00:19.0: PME# supported from D0 D3hot D3cold > > [ 4.274939] pci 0000:00:1a.0: [8086:1c2d] type 00 class 0x0c0320 > > [ 4.274983] pci 0000:00:1a.0: reg 10: [mem 0xe2e70000-0xe2e703ff] > > [ 4.275185] pci 0000:00:1a.0: PME# supported from D0 D3hot D3cold > > [ 4.275243] pci 0000:00:1b.0: [8086:1c20] type 00 class 0x040300 > > [ 4.275278] pci 0000:00:1b.0: reg 10: [mem 0xe2e60000-0xe2e63fff > 64bit] > > [ 4.275456] pci 0000:00:1b.0: PME# supported from D0 D3hot D3cold > > [ 4.275509] pci 0000:00:1c.0: [8086:1c10] type 01 class 0x060400 > > [ 4.275702] pci 0000:00:1c.0: PME# supported from D0 D3hot D3cold > > [ 4.275760] pci 0000:00:1c.1: [8086:1c12] type 01 class 0x060400 > > [ 4.275953] pci 0000:00:1c.1: PME# supported from D0 D3hot D3cold > > [ 4.276011] pci 0000:00:1c.2: [8086:1c14] type 01 class 0x060400 > > [ 4.276205] pci 0000:00:1c.2: PME# supported from D0 D3hot D3cold > > [ 4.276264] pci 0000:00:1c.3: [8086:1c16] type 01 class 0x060400 > > [ 4.276458] pci 0000:00:1c.3: PME# supported from D0 D3hot D3cold > > [ 4.276520] pci 0000:00:1c.5: [8086:1c1a] type 01 class 0x060400 > > [ 4.276711] pci 0000:00:1c.5: PME# supported from D0 D3hot D3cold > > [ 4.276779] pci 0000:00:1d.0: [8086:1c26] type 00 class 0x0c0320 > > [ 4.276823] pci 0000:00:1d.0: reg 10: [mem 0xe2e50000-0xe2e503ff] > > [ 4.277025] pci 0000:00:1d.0: PME# supported from D0 D3hot D3cold > > [ 4.277086] pci 0000:00:1f.0: [8086:1c4f] type 00 class 0x060100 > > [ 4.277341] pci 0000:00:1f.2: [8086:1c03] type 00 class 0x010601 > > [ 4.277391] pci 0000:00:1f.2: reg 10: [io 0x40d0-0x40d7] > > [ 4.277410] pci 0000:00:1f.2: reg 14: [io 0x40c0-0x40c3] > > [ 4.277429] pci 0000:00:1f.2: reg 18: [io 0x40b0-0x40b7] > > [ 4.277449] pci 0000:00:1f.2: reg 1c: [io 0x40a0-0x40a3] > > [ 4.277468] pci 0000:00:1f.2: reg 20: [io 0x4060-0x407f] > > [ 4.277486] pci 0000:00:1f.2: reg 24: [mem 0xe2e40000-0xe2e407ff] > > [ 4.277613] pci 0000:00:1f.2: PME# supported from D3hot > > [ 4.277657] pci 0000:00:1f.3: [8086:1c22] type 00 class 0x0c0500 > > [ 4.277694] pci 0000:00:1f.3: reg 10: [mem 0xe2e30000-0xe2e300ff > 64bit] > > [ 4.277749] pci 0000:00:1f.3: reg 20: [io 0x4040-0x405f] > > [ 4.277920] pci 0000:00:1c.0: PCI bridge to [bus 01-01] > > [ 4.278353] pci 0000:02:00.0: [8086:422b] type 00 class 0x028000 > > [ 4.278708] pci 0000:02:00.0: reg 10: [mem 0xe2d00000-0xe2d01fff > 64bit] > > [ 4.280508] pci 0000:02:00.0: PME# supported from D0 D3hot D3cold > > [ 4.285361] pci 0000:00:1c.1: PCI bridge to [bus 02-02] > > [ 4.285374] pci 0000:00:1c.1: bridge window [mem > 0xe2d00000-0xe2dfffff] > > [ 4.285490] pci 0000:00:1c.2: PCI bridge to [bus 03-08] > > [ 4.285498] pci 0000:00:1c.2: bridge window [io 0x3000-0x3fff] > > [ 4.285505] pci 0000:00:1c.2: bridge window [mem > 0xe2200000-0xe2bfffff] > > [ 4.285517] pci 0000:00:1c.2: bridge window [mem > 0xe0a00000-0xe13fffff 64bit pref] > > [ 4.285625] pci 0000:00:1c.3: PCI bridge to [bus 09-09] > > [ 4.285632] pci 0000:00:1c.3: bridge window [io 0x2000-0x2fff] > > [ 4.285639] pci 0000:00:1c.3: bridge window [mem > 0xe1800000-0xe21fffff] > > [ 4.285651] pci 0000:00:1c.3: bridge window [mem > 0xe0000000-0xe09fffff 64bit pref] > > [ 4.285818] pci 0000:0a:00.0: [1217:8221] type 00 class 0x080501 > > [ 4.285872] pci 0000:0a:00.0: reg 10: [mem 0xe2c20000-0xe2c201ff] > > [ 4.286294] pci 0000:0a:00.0: supports D1 D2 > > [ 4.286295] pci 0000:0a:00.0: PME# supported from D0 D1 D2 D3hot > D3cold > > [ 4.286432] pci 0000:0a:00.1: [1217:8231] type 00 class 0x018000 > > [ 4.286486] pci 0000:0a:00.1: reg 10: [mem 0xe2c10000-0xe2c10fff] > > [ 4.286563] pci 0000:0a:00.1: reg 18: [mem 0xe2c00000-0xe2c007ff] > > [ 4.286908] pci 0000:0a:00.1: supports D1 D2 > > [ 4.286909] pci 0000:0a:00.1: PME# supported from D0 D1 D2 D3hot > D3cold > > [ 4.293400] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a] > > [ 4.293412] pci 0000:00:1c.5: bridge window [mem > 0xe2c00000-0xe2cfffff] > > [ 4.293479] pci_bus 0000:00: on NUMA node 0 > > [ 4.293483] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT] > > [ 4.293612] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP01._PRT] > > [ 4.293647] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP02._PRT] > > [ 4.293682] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP04._PRT] > > [ 4.293717] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP06._PRT] > > [ 4.293762] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP03._PRT] > > [ 4.293857] \_SB_.PCI0:_OSC invalid UUID > > [ 4.293858] _OSC request data:1 1f 1f > > [ 4.293861] pci0000:00: Requesting ACPI _OSC control (0x1d) > > [ 4.293906] \_SB_.PCI0:_OSC invalid UUID > > [ 4.293907] _OSC request data:1 0 1d > > [ 4.293910] pci0000:00: ACPI _OSC request failed (AE_ERROR), > returned control mask: 0x1d > > [ 4.293911] ACPI _OSC control for PCIe not granted, disabling ASPM > > [ 4.297639] ACPI: PCI Interrupt Link [LNKA] (IRQs 1 3 4 5 6 7 10 12 > 14 15) *11 > > [ 4.297702] ACPI: PCI Interrupt Link [LNKB] (IRQs 1 3 4 5 6 7 11 12 > 14 15) *10 > > [ 4.297761] ACPI: PCI Interrupt Link [LNKC] (IRQs 1 3 4 5 6 7 10 12 > 14 15) *11 > > [ 4.297820] ACPI: PCI Interrupt Link [LNKD] (IRQs 1 3 4 5 6 7 11 12 > 14 15) *10 > > [ 4.297878] ACPI: PCI Interrupt Link [LNKE] (IRQs 1 3 4 *5 6 7 10 12 > 14 15) > > [ 4.297937] ACPI: PCI Interrupt Link [LNKF] (IRQs 1 3 4 5 6 7 11 12 > 14 15) *0, disabled. > > [ 4.297996] ACPI: PCI Interrupt Link [LNKG] (IRQs 1 *3 4 5 6 7 10 12 > 14 15) > > [ 4.298054] ACPI: PCI Interrupt Link [LNKH] (IRQs 1 3 4 5 6 7 11 12 > 14 15) *0, disabled. > > [ 4.298087] xen/balloon: Initialising balloon driver. > > [ 4.301022] xen-balloon: Initialising balloon driver. > > [ 4.301062] xen/balloon: Xen selfballooning driver disabled for > domain0. > > [ 4.301148] vgaarb: device added: > PCI:0000:00:02.0,decodes=io+mem,owns=io+mem,locks=none > > [ 4.301157] vgaarb: loaded > > [ 4.301157] vgaarb: bridge control possible 0000:00:02.0 > > [ 4.301279] PCI: Using ACPI for IRQ routing > > [ 4.305930] PCI: pci_cache_line_size set to 64 bytes > > [ 4.306106] reserve RAM buffer: 000000000009a000 - 000000000009ffff > > [ 4.306108] reserve RAM buffer: 0000000007eea000 - 0000000007ffffff > > [ 4.306110] reserve RAM buffer: 0000000007f70000 - 0000000007ffffff > > [ 4.306112] reserve RAM buffer: 0000000007f78000 - 0000000007ffffff > > [ 4.306113] reserve RAM buffer: 000000000dffd000 - 000000000fffffff > > [ 4.306115] reserve RAM buffer: 00000000c83b4000 - 00000000cbffffff > > [ 4.306118] reserve RAM buffer: 00000000c840e000 - 00000000cbffffff > > [ 4.306121] reserve RAM buffer: 00000000c8411000 - 00000000cbffffff > > [ 4.306123] reserve RAM buffer: 00000000c841e000 - 00000000cbffffff > > [ 4.306125] reserve RAM buffer: 00000000c8432000 - 00000000cbffffff > > [ 4.306127] reserve RAM buffer: 00000000cac00000 - 00000000cbffffff > > [ 4.306129] reserve RAM buffer: 000000042e000000 - 000000042fffffff > > [ 4.306235] Switching to clocksource xen > > [ 4.307726] pnp: PnP ACPI init > > [ 4.307738] ACPI: bus type pnp registered > > [ 4.308287] pnp 00:00: [bus 00-3e] > > [ 4.308289] pnp 00:00: [io 0x0000-0x0cf7 window] > > [ 4.308291] pnp 00:00: [io 0x0cf8-0x0cff] > > [ 4.308293] pnp 00:00: [io 0x0d00-0xffff window] > > [ 4.308295] pnp 00:00: [mem 0x000a0000-0x000bffff window] > > [ 4.308296] pnp 00:00: [mem 0x000c0000-0x000c3fff window] > > [ 4.308298] pnp 00:00: [mem 0x000c4000-0x000c7fff window] > > [ 4.308300] pnp 00:00: [mem 0x000c8000-0x000cbfff window] > > [ 4.308301] pnp 00:00: [mem 0x000cc000-0x000cffff window] > > [ 4.308303] pnp 00:00: [mem 0x000d0000-0x000d3fff window] > > [ 4.308305] pnp 00:00: [mem 0x000d4000-0x000d7fff window] > > [ 4.308307] pnp 00:00: [mem 0x000d8000-0x000dbfff window] > > [ 4.308309] pnp 00:00: [mem 0x000dc000-0x000dffff window] > > [ 4.308310] pnp 00:00: [mem 0x000e0000-0x000e3fff window] > > [ 4.308312] pnp 00:00: [mem 0x000e4000-0x000e7fff window] > > [ 4.308314] pnp 00:00: [mem 0x000e8000-0x000ebfff window] > > [ 4.308315] pnp 00:00: [mem 0x000ec000-0x000effff window] > > [ 4.308317] pnp 00:00: [mem 0x000f0000-0x000fffff window] > > [ 4.308319] pnp 00:00: [mem 0xcfa00000-0xfeafffff window] > > [ 4.308320] pnp 00:00: [mem 0xfed40000-0xfed44fff window] > > [ 4.308385] pnp 00:00: Plug and Play ACPI device, IDs PNP0a08 PNP0a03 > (active) > > [ 4.308398] pnp 00:01: [io 0x0000-0x001f] > > [ 4.308400] pnp 00:01: [io 0x0081-0x0091] > > [ 4.308401] pnp 00:01: [io 0x0093-0x009f] > > [ 4.308403] pnp 00:01: [io 0x00c0-0x00df] > > [ 4.308404] pnp 00:01: [dma 4] > > [ 4.308422] pnp 00:01: Plug and Play ACPI device, IDs PNP0200 (active) > > [ 4.308429] pnp 00:02: [mem 0xff000000-0xffffffff] > > [ 4.308445] pnp 00:02: Plug and Play ACPI device, IDs INT0800 (active) > > [ 4.308540] pnp 00:03: [mem 0xfed00000-0xfed003ff] > > [ 4.308572] system 00:03: [mem 0xfed00000-0xfed003ff] has been > reserved > > [ 4.308575] system 00:03: Plug and Play ACPI device, IDs PNP0103 > PNP0c01 (active) > > [ 4.308584] pnp 00:04: [io 0x00f0] > > [ 4.308587] xen: registering gsi 13 triggering 1 polarity 0 > > [ 4.308609] pnp 00:04: [irq 13] > > [ 4.308626] pnp 00:04: Plug and Play ACPI device, IDs PNP0c04 (active) > > [ 4.308636] pnp 00:05: [io 0x002e-0x002f] > > [ 4.308637] pnp 00:05: [io 0x004e-0x004f] > > [ 4.308639] pnp 00:05: [io 0x0061] > > [ 4.308640] pnp 00:05: [io 0x0063] > > [ 4.308641] pnp 00:05: [io 0x0065] > > [ 4.308642] pnp 00:05: [io 0x0067] > > [ 4.308644] pnp 00:05: [io 0x0070] > > [ 4.308645] pnp 00:05: [io 0x0080] > > [ 4.308646] pnp 00:05: [io 0x0092] > > [ 4.308648] pnp 00:05: [io 0x00b2-0x00b3] > > [ 4.308649] pnp 00:05: [io 0x0680-0x069f] > > [ 4.308651] pnp 00:05: [io 0x1000-0x100f] > > [ 4.308653] pnp 00:05: [io 0xffff] > > [ 4.308654] pnp 00:05: [io 0xffff] > > [ 4.308655] pnp 00:05: [io 0x0400-0x047f] > > [ 4.308656] pnp 00:05: [io 0x0500-0x057f] > > [ 4.308658] pnp 00:05: [io 0x164e-0x164f] > > [ 4.308689] system 00:05: [io 0x0680-0x069f] has been reserved > > [ 4.308691] system 00:05: [io 0x1000-0x100f] has been reserved > > [ 4.308693] system 00:05: [io 0xffff] has been reserved > > [ 4.308695] system 00:05: [io 0xffff] has been reserved > > [ 4.308697] system 00:05: [io 0x0400-0x047f] has been reserved > > [ 4.308700] system 00:05: [io 0x0500-0x057f] has been reserved > > [ 4.308701] system 00:05: [io 0x164e-0x164f] has been reserved > > [ 4.308704] system 00:05: Plug and Play ACPI device, IDs PNP0c02 > (active) > > [ 4.308711] pnp 00:06: [io 0x0070-0x0077] > > [ 4.308713] xen: registering gsi 8 triggering 1 polarity 0 > > [ 4.308730] pnp 00:06: [irq 8] > > [ 4.308749] pnp 00:06: Plug and Play ACPI device, IDs PNP0b00 (active) > > [ 4.308758] pnp 00:07: [io 0x0060] > > [ 4.308759] pnp 00:07: [io 0x0064] > > [ 4.308761] xen: registering gsi 1 triggering 1 polarity 0 > > [ 4.308777] pnp 00:07: [irq 1] > > [ 4.308794] pnp 00:07: Plug and Play ACPI device, IDs PNP0303 (active) > > [ 4.309984] pnp 00:08: Plug and Play ACPI device, IDs PNP0401 > (disabled) > > [ 4.309993] xen: registering gsi 12 triggering 1 polarity 0 > > [ 4.310011] pnp 00:09: [irq 12] > > [ 4.310030] pnp 00:09: Plug and Play ACPI device, IDs DLL0493 PNP0f13 > (active) > > [ 4.310065] pnp 00:0a: [mem 0xfed40000-0xfed44fff] > > [ 4.310086] pnp 00:0a: Plug and Play ACPI device, IDs BCM0102 PNP0c31 > (active) > > [ 4.310291] pnp 00:0b: [mem 0xfed1c000-0xfed1ffff] > > [ 4.310292] pnp 00:0b: [mem 0xfed10000-0xfed17fff] > > [ 4.310294] pnp 00:0b: [mem 0xfed18000-0xfed18fff] > > [ 4.310296] pnp 00:0b: [mem 0xfed19000-0xfed19fff] > > [ 4.310298] pnp 00:0b: [mem 0xf8000000-0xfbffffff] > > [ 4.310309] pnp 00:0b: [mem 0xfed20000-0xfed3ffff] > > [ 4.310310] pnp 00:0b: [mem 0xfed90000-0xfed93fff] > > [ 4.310312] pnp 00:0b: [mem 0xfed45000-0xfed8ffff] > > [ 4.310313] pnp 00:0b: [mem 0xff000000-0xffffffff] > > [ 4.310315] pnp 00:0b: [mem 0xfee00000-0xfeefffff] > > [ 4.310317] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disabled] > > [ 4.310318] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disabled] > > [ 4.310359] system 00:0b: [mem 0xfed1c000-0xfed1ffff] has been > reserved > > [ 4.310361] system 00:0b: [mem 0xfed10000-0xfed17fff] has been > reserved > > [ 4.310363] system 00:0b: [mem 0xfed18000-0xfed18fff] has been > reserved > > [ 4.310365] system 00:0b: [mem 0xfed19000-0xfed19fff] has been > reserved > > [ 4.310367] system 00:0b: [mem 0xf8000000-0xfbffffff] has been > reserved > > [ 4.310369] system 00:0b: [mem 0xfed20000-0xfed3ffff] has been > reserved > > [ 4.310371] system 00:0b: [mem 0xfed90000-0xfed93fff] has been > reserved > > [ 4.310373] system 00:0b: [mem 0xfed45000-0xfed8ffff] has been > reserved > > [ 4.310375] system 00:0b: [mem 0xff000000-0xffffffff] could not be > reserved > > [ 4.310377] system 00:0b: [mem 0xfee00000-0xfeefffff] could not be > reserved > > [ 4.310380] system 00:0b: Plug and Play ACPI device, IDs PNP0c02 > (active) > > [ 4.310956] xen: registering gsi 23 triggering 1 polarity 0 > > [ 4.310967] xen: --> pirq=23 -> irq=23 (gsi=23) > > [ 4.310985] pnp 00:0c: [irq 23] > > [ 4.311015] pnp 00:0c: Plug and Play ACPI device, IDs SMO8800 (active) > > [ 4.315528] pnp 00:0d: [mem 0x20000000-0x201fffff] > > [ 4.315531] pnp 00:0d: [mem 0x40000000-0x401fffff] > > [ 4.339851] system 00:0d: [mem 0x20000000-0x201fffff] has been > reserved > > [ 4.339854] system 00:0d: [mem 0x40000000-0x401fffff] has been > reserved > > [ 4.339857] system 00:0d: Plug and Play ACPI device, IDs PNP0c01 > (active) > > [ 4.339865] pnp: PnP ACPI: found 14 devices > > [ 4.339867] ACPI: ACPI bus type pnp unregistered > > [ 4.346178] PM-Timer failed consistency check (0x0xffffff) - > aborting. > > [ 4.346274] pci 0000:00:1c.0: PCI bridge to [bus 01-01] > > [ 4.346306] pci 0000:00:1c.1: PCI bridge to [bus 02-02] > > [ 4.346315] pci 0000:00:1c.1: bridge window [mem > 0xe2d00000-0xe2dfffff] > > [ 4.346332] pci 0000:00:1c.2: PCI bridge to [bus 03-08] > > [ 4.346336] pci 0000:00:1c.2: bridge window [io 0x3000-0x3fff] > > [ 4.346347] pci 0000:00:1c.2: bridge window [mem > 0xe2200000-0xe2bfffff] > > [ 4.346354] pci 0000:00:1c.2: bridge window [mem > 0xe0a00000-0xe13fffff 64bit pref] > > [ 4.346366] pci 0000:00:1c.3: PCI bridge to [bus 09-09] > > [ 4.346370] pci 0000:00:1c.3: bridge window [io 0x2000-0x2fff] > > [ 4.346379] pci 0000:00:1c.3: bridge window [mem > 0xe1800000-0xe21fffff] > > [ 4.346386] pci 0000:00:1c.3: bridge window [mem > 0xe0000000-0xe09fffff 64bit pref] > > [ 4.346399] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a] > > [ 4.346408] pci 0000:00:1c.5: bridge window [mem > 0xe2c00000-0xe2cfffff] > > [ 4.346434] xen: registering gsi 16 triggering 0 polarity 1 > > [ 4.346442] xen: --> pirq=16 -> irq=16 (gsi=16) > > [ 4.346469] xen: registering gsi 17 triggering 0 polarity 1 > > [ 4.346473] xen: --> pirq=17 -> irq=17 (gsi=17) > > [ 4.346498] xen: registering gsi 18 triggering 0 polarity 1 > > [ 4.346502] xen: --> pirq=18 -> irq=18 (gsi=18) > > [ 4.346527] xen: registering gsi 19 triggering 0 polarity 1 > > [ 4.346531] xen: --> pirq=19 -> irq=19 (gsi=19) > > [ 4.346556] xen: registering gsi 17 triggering 0 polarity 1 > > [ 4.346558] Already setup the GSI :17 > > [ 4.346563] pci_bus 0000:00: resource 4 [io 0x0000-0x0cf7] > > [ 4.346565] pci_bus 0000:00: resource 5 [io 0x0d00-0xffff] > > [ 4.346566] pci_bus 0000:00: resource 6 [mem 0x000a0000-0x000bffff] > > [ 4.346568] pci_bus 0000:00: resource 7 [mem 0xcfa00000-0xfeafffff] > > [ 4.346570] pci_bus 0000:00: resource 8 [mem 0xfed40000-0xfed44fff] > > [ 4.346572] pci_bus 0000:02: resource 1 [mem 0xe2d00000-0xe2dfffff] > > [ 4.346574] pci_bus 0000:03: resource 0 [io 0x3000-0x3fff] > > [ 4.346575] pci_bus 0000:03: resource 1 [mem 0xe2200000-0xe2bfffff] > > [ 4.346577] pci_bus 0000:03: resource 2 [mem 0xe0a00000-0xe13fffff > 64bit pref] > > [ 4.346579] pci_bus 0000:09: resource 0 [io 0x2000-0x2fff] > > [ 4.346581] pci_bus 0000:09: resource 1 [mem 0xe1800000-0xe21fffff] > > [ 4.346582] pci_bus 0000:09: resource 2 [mem 0xe0000000-0xe09fffff > 64bit pref] > > [ 4.346584] pci_bus 0000:0a: resource 1 [mem 0xe2c00000-0xe2cfffff] > > [ 4.346672] NET: Registered protocol family 2 > > [ 4.346732] IP route cache hash table entries: 524288 (order: 10, > 4194304 bytes) > > [ 4.347207] TCP established hash table entries: 262144 (order: 10, > 4194304 bytes) > > [ 4.347753] TCP bind hash table entries: 65536 (order: 8, 1048576 > bytes) > > [ 4.347872] TCP: Hash tables configured (established 262144 bind > 65536) > > [ 4.347874] TCP: reno registered > > [ 4.347877] UDP hash table entries: 8192 (order: 6, 262144 bytes) > > [ 4.347921] UDP-Lite hash table entries: 8192 (order: 6, 262144 bytes) > > [ 4.348067] NET: Registered protocol family 1 > > [ 4.348085] pci 0000:00:02.0: Boot video device > > [ 4.348108] xen: registering gsi 16 triggering 0 polarity 1 > > [ 4.348112] Already setup the GSI :16 > > [ 4.348203] xen: registering gsi 17 triggering 0 polarity 1 > > [ 4.348205] Already setup the GSI :17 > > [ 4.348298] PCI: CLS 64 bytes, default 64 > > [ 4.348333] Unpacking initramfs... > > [ 4.384265] Freeing initrd memory: 45868k freed > > [ 4.392440] Simple Boot Flag at 0xf3 set to 0x1 > > [ 4.392900] audit: initializing netlink socket (disabled) > > [ 4.392911] type=2000 audit(1354151975.383:1): initialized > > [ 4.411688] VFS: Disk quotas dquot_6.5.2 > > [ 4.411715] Dquot-cache hash table entries: 512 (order 0, 4096 bytes) > > [ 4.411870] msgmni has been set to 29339 > > [ 4.412010] Block layer SCSI generic (bsg) driver version 0.4 loaded > (major 253) > > [ 4.412013] io scheduler noop registered > > [ 4.412015] io scheduler deadline registered > > [ 4.412036] io scheduler cfq registered (default) > > [ 4.412666] intel_idle: does not run on family 6 model 42 > > [ 4.412741] ACPI: Requesting acpi_cpufreq > > [ 4.459643] Non-volatile memory driver v1.3 > > [ 4.459654] ramoops: platform device not found, using module > parameters > > [ 4.459670] ramoops: The memory size and the record size must be > non-zero > > [ 4.459703] ramoops: probe of ramoops failed with error -22 > > [ 4.474892] loop: module loaded > > [ 4.474922] Fixed MDIO Bus: probed > > [ 4.474965] i8042: PNP: PS/2 Controller [PNP0303:PS2K,PNP0f13:PS2M] > at 0x60,0x64 irq 1,12 > > [ 4.475166] i8042: Warning: Keylock active > > [ 4.476434] serio: i8042 KBD port at 0x60,0x64 irq 1 > > [ 4.476439] serio: i8042 AUX port at 0x60,0x64 irq 12 > > [ 4.476551] mousedev: PS/2 mouse device common for all mice > > [ 4.476707] rtc_cmos 00:06: RTC can wake from S4 > > [ 4.476940] rtc_cmos 00:06: rtc core: registered rtc_cmos as rtc0 > > [ 4.476998] rtc0: alarms up to one year, y3k, 242 bytes nvram > > [ 4.477084] device-mapper: uevent: version 1.0.3 > > [ 4.477193] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) > initialised: dm-devel@redhat.com > > [ 4.477281] TCP: cubic registered > > [ 4.477381] input: AT Translated Set 2 keyboard as > /devices/platform/i8042/serio0/input/input0 > > [ 4.477402] NET: Registered protocol family 10 > > [ 4.477644] Registering the dns_resolver key type > > [ 4.477791] registered taskstats version 1 > > [ 4.478330] Magic number: 4:584:307 > > [ 4.478403] tty tty36: hash matches > > [ 4.478496] rtc_cmos 00:06: setting system clock to 2012-11-29 > 01:19:35 UTC (1354151975) > > [ 4.478801] Freeing unused kernel memory: 552k freed > > [ 4.478847] Write protecting the kernel read-only data: 8192k > > [ 4.481908] Freeing unused kernel memory: 1568k freed > > [ 4.482112] Freeing unused kernel memory: 24k freed > > [ 4.524129] dracut: dracut-005-3.fc13 > > [ 4.552311] pciback 0000:00:19.0: seizing device > > [ 4.552403] pciback 0000:02:00.0: seizing device > > [ 4.552941] xen: registering gsi 17 triggering 0 polarity 1 > > [ 4.552952] Already setup the GSI :17 > > [ 4.553934] xen: registering gsi 20 triggering 0 polarity 1 > > [ 4.553964] xen: --> pirq=20 -> irq=20 (gsi=20) > > [ 4.554574] xen-pciback: backend is vpci > > [ 4.617471] udev: starting version 151 > > [ 4.617770] udevd (80): /proc/80/oom_adj is deprecated, please use > /proc/80/oom_score_adj instead. > > [ 4.654916] Linux agpgart interface v0.103 > > [ 4.655397] input: Lid Switch as > /devices/LNXSYSTM:00/device:00/PNP0C0D:00/input/input1 > > [ 5.051184] ACPI: Lid Switch [LID] > > [ 5.051436] input: Power Button as > /devices/LNXSYSTM:00/device:00/PNP0C0C:00/input/input2 > > [ 5.051547] ACPI: Power Button [PBTN] > > [ 5.051682] input: Sleep Button as > /devices/LNXSYSTM:00/device:00/PNP0C0E:00/input/input3 > > [ 5.051760] ACPI: Sleep Button [SBTN] > > [ 5.054141] input: Power Button as > /devices/LNXSYSTM:00/LNXPWRBN:00/input/input4 > > [ 5.054421] ACPI: Power Button [PWRF] > > [ 5.056887] agpgart-intel 0000:00:00.0: Intel Sandybridge Chipset > > [ 5.058118] agpgart-intel 0000:00:00.0: detected gtt size: 2097152K > total, 262144K mappable > > [ 5.064439] agpgart-intel 0000:00:00.0: detected 65536K stolen memory > > [ 5.064916] agpgart-intel 0000:00:00.0: AGP aperture is 256M @ > 0xd0000000 > > [ 5.070296] [drm] Initialized drm 1.1.0 20060810 > > [ 5.080002] xen: registering gsi 16 triggering 0 polarity 1 > > [ 5.080015] Already setup the GSI :16 > > [ 5.080364] i915 0000:00:02.0: setting latency timer to 64 > > [ 5.190295] [drm] MTRR allocation failed. Graphics performance may > suffer. > > [ 5.190491] [drm] Supports vblank timestamp caching Rev 1 > (10.10.2010). > > [ 5.190493] [drm] Driver supports precise vblank timestamp query. > > [ 5.190554] vgaarb: device changed decodes: > PCI:0000:00:02.0,olddecodes=io+mem,decodes=io+mem:owns=io+mem > > [ 5.548301] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp off > > [ 5.591093] input: DualPoint Stick as > /devices/platform/i8042/serio1/input/input5 > > [ 5.606212] input: AlpsPS/2 ALPS DualPoint TouchPad as > /devices/platform/i8042/serio1/input/input6 > > [ 5.806814] fbcon: inteldrmfb (fb0) is primary device > > [ 6.095967] Console: switching to colour frame buffer device 200x56 > > [ 6.101477] fb0: inteldrmfb frame buffer device > > [ 6.101478] drm: registered panic notifier > > [ 6.130833] acpi device:38: registered as cooling_device4 > > [ 6.133713] input: Video Bus as > /devices/LNXSYSTM:00/device:00/PNP0A08:00/LNXVIDEO:00/input/input7 > > [ 6.133915] ACPI: Video Device [VID] (multi-head: yes rom: no post: > no) > > [ 6.135082] [drm] Initialized i915 1.6.0 20080730 for 0000:00:02.0 on > minor 0 > > [ 6.185946] dracut: Starting plymouth daemon > > [ 6.479391] dracut: rd_NO_DM: removing DM RAID activation > > [ 6.489309] dracut: rd_NO_MD: removing MD RAID activation > > [ 6.542596] wmi: Mapper loaded > > [ 6.564439] usbcore: registered new interface driver usbfs > > [ 6.564463] usbcore: registered new interface driver hub > > [ 6.568901] SCSI subsystem initialized > > [ 6.569574] usbcore: registered new device driver usb > > [ 6.570692] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver > > [ 6.570723] xen: registering gsi 16 triggering 0 polarity 1 > > [ 6.570728] Already setup the GSI :16 > > [ 6.570776] ehci_hcd 0000:00:1a.0: setting latency timer to 64 > > [ 6.570782] ehci_hcd 0000:00:1a.0: EHCI Host Controller > > [ 6.570814] ehci_hcd 0000:00:1a.0: new USB bus registered, assigned > bus number 1 > > [ 6.570879] ehci_hcd 0000:00:1a.0: debug port 2 > > [ 6.573720] libata version 3.00 loaded. > > [ 6.574777] ehci_hcd 0000:00:1a.0: cache line size of 64 is not > supported > > [ 6.574832] ehci_hcd 0000:00:1a.0: irq 16, io mem 0xe2e70000 > > [ 6.586344] ehci_hcd 0000:00:1a.0: USB 2.0 started, EHCI 1.00 > > [ 6.586369] usb usb1: New USB device found, idVendor=1d6b, > idProduct=0002 > > [ 6.586372] usb usb1: New USB device strings: Mfr=3, Product=2, > SerialNumber=1 > > [ 6.586375] usb usb1: Product: EHCI Host Controller > > [ 6.586376] usb usb1: Manufacturer: Linux 3.4.18-2.pvops.qubes.x86_64 > ehci_hcd > > [ 6.586378] usb usb1: SerialNumber: 0000:00:1a.0 > > [ 6.586506] hub 1-0:1.0: USB hub found > > [ 6.586511] hub 1-0:1.0: 2 ports detected > > [ 6.586604] xen: registering gsi 17 triggering 0 polarity 1 > > [ 6.586609] Already setup the GSI :17 > > [ 6.586663] ehci_hcd 0000:00:1d.0: setting latency timer to 64 > > [ 6.586668] ehci_hcd 0000:00:1d.0: EHCI Host Controller > > [ 6.586678] ehci_hcd 0000:00:1d.0: new USB bus registered, assigned > bus number 2 > > [ 6.586734] ehci_hcd 0000:00:1d.0: debug port 2 > > [ 6.590650] ehci_hcd 0000:00:1d.0: cache line size of 64 is not > supported > > [ 6.590709] ehci_hcd 0000:00:1d.0: irq 17, io mem 0xe2e50000 > > [ 6.606335] ehci_hcd 0000:00:1d.0: USB 2.0 started, EHCI 1.00 > > [ 6.606364] usb usb2: New USB device found, idVendor=1d6b, > idProduct=0002 > > [ 6.606367] usb usb2: New USB device strings: Mfr=3, Product=2, > SerialNumber=1 > > [ 6.606370] usb usb2: Product: EHCI Host Controller > > [ 6.606371] usb usb2: Manufacturer: Linux 3.4.18-2.pvops.qubes.x86_64 > ehci_hcd > > [ 6.606373] usb usb2: SerialNumber: 0000:00:1d.0 > > [ 6.606519] hub 2-0:1.0: USB hub found > > [ 6.606524] hub 2-0:1.0: 2 ports detected > > [ 6.606620] ahci 0000:00:1f.2: version 3.0 > > [ 6.606641] xen: registering gsi 18 triggering 0 polarity 1 > > [ 6.606647] Already setup the GSI :18 > > [ 6.606896] ahci: SSS flag set, parallel bus scan disabled > > [ 6.626400] ahci 0000:00:1f.2: AHCI 0001.0300 32 slots 6 ports 6 Gbps > 0x3b impl SATA mode > > [ 6.626405] ahci 0000:00:1f.2: flags: 64bit ncq sntf stag pm led clo > pio slum part ems sxs apst > > [ 6.626414] ahci 0000:00:1f.2: setting latency timer to 64 > > [ 6.673732] scsi0 : ahci > > [ 6.683363] scsi1 : ahci > > [ 6.697268] scsi2 : ahci > > [ 6.711526] scsi3 : ahci > > [ 6.733931] scsi4 : ahci > > [ 6.739603] scsi5 : ahci > > [ 6.842106] ata1: SATA max UDMA/133 abar m2048@0xe2e40000 port > 0xe2e40100 irq 293 > > [ 6.842118] ata2: SATA max UDMA/133 abar m2048@0xe2e40000 port > 0xe2e40180 irq 293 > > [ 6.842124] ata3: DUMMY > > [ 6.842129] ata4: SATA max UDMA/133 abar m2048@0xe2e40000 port > 0xe2e40280 irq 293 > > [ 6.842136] ata5: SATA max UDMA/133 abar m2048@0xe2e40000 port > 0xe2e40300 irq 293 > > [ 6.842143] ata6: SATA max UDMA/133 abar m2048@0xe2e40000 port > 0xe2e40380 irq 293 > > [ 6.898480] usb 1-1: new high-speed USB device number 2 using ehci_hcd > > [ 7.031312] usb 1-1: New USB device found, idVendor=8087, > idProduct=0024 > > [ 7.031323] usb 1-1: New USB device strings: Mfr=0, Product=0, > SerialNumber=0 > > [ 7.032072] hub 1-1:1.0: USB hub found > > [ 7.032344] hub 1-1:1.0: 6 ports detected > > [ 7.142515] usb 2-1: new high-speed USB device number 2 using ehci_hcd > > [ 7.162484] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) > > [ 7.268594] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by > device (Stat=0x51 Err=0x04) > > [ 7.268770] ata1.00: ATA-9: KINGSTON SV200S3256G, E111008a, max > UDMA/100 > > [ 7.268778] ata1.00: 500118192 sectors, multi 16: LBA48 NCQ (depth > 31/32), AA > > [ 7.272554] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by > device (Stat=0x51 Err=0x04) > > [ 7.272758] ata1.00: configured for UDMA/100 > > [ 7.273314] scsi 0:0:0:0: Direct-Access ATA KINGSTON SV200S3 > E111 PQ: 0 ANSI: 5 > > [ 7.274861] usb 2-1: New USB device found, idVendor=8087, > idProduct=0024 > > [ 7.274870] usb 2-1: New USB device strings: Mfr=0, Product=0, > SerialNumber=0 > > [ 7.275358] hub 2-1:1.0: USB hub found > > [ 7.275521] hub 2-1:1.0: 8 ports detected > > [ 7.346717] usb 1-1.4: new full-speed USB device number 3 using > ehci_hcd > > [ 7.443529] usb 1-1.4: New USB device found, idVendor=413c, > idProduct=8187 > > [ 7.443539] usb 1-1.4: New USB device strings: Mfr=1, Product=2, > SerialNumber=3 > > [ 7.443546] usb 1-1.4: Product: DW375 Bluetooth Module > > [ 7.443550] usb 1-1.4: Manufacturer: Dell Computer Corp > > [ 7.443555] usb 1-1.4: SerialNumber: D0DF9A40FE60 > > [ 7.514736] usb 1-1.5: new high-speed USB device number 4 using > ehci_hcd > > [ 7.590440] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 300) > > [ 7.593835] ata2.00: ATAPI: HL-DT-ST DVD+/-RW GU60N, A103, max > UDMA/133 > > [ 7.604147] ata2.00: configured for UDMA/133 > > [ 7.614746] usb 1-1.5: New USB device found, idVendor=05ca, > idProduct=181c > > [ 7.614757] usb 1-1.5: New USB device strings: Mfr=1, Product=2, > SerialNumber=0 > > [ 7.614763] usb 1-1.5: Product: Laptop_Integrated_Webcam_FHD > > [ 7.614768] usb 1-1.5: Manufacturer: CN0CJ3P27248717F040SA01 > > [ 7.618662] scsi 1:0:0:0: CD-ROM HL-DT-ST DVD+-RW GU60N > A103 PQ: 0 ANSI: 5 > > [ 7.686581] usb 2-1.6: new high-speed USB device number 3 using > ehci_hcd > > [ 7.795399] usb 2-1.6: New USB device found, idVendor=413c, > idProduct=818d > > [ 7.795410] usb 2-1.6: New USB device strings: Mfr=1, Product=2, > SerialNumber=3 > > [ 7.795416] usb 2-1.6: Product: DW5550 > > [ 7.795420] usb 2-1.6: Manufacturer: Dell > > [ 7.795425] usb 2-1.6: SerialNumber: 88FA653FDF944970 > > [ 7.902770] usb 2-1.8: new full-speed USB device number 4 using > ehci_hcd > > [ 7.938478] ata4: SATA link down (SStatus 0 SControl 300) > > [ 8.017319] usb 2-1.8: New USB device found, idVendor=0a5c, > idProduct=5801 > > [ 8.017330] usb 2-1.8: New USB device strings: Mfr=1, Product=2, > SerialNumber=3 > > [ 8.017336] usb 2-1.8: Product: 5880 > > [ 8.017340] usb 2-1.8: Manufacturer: Broadcom Corp > > [ 8.017344] usb 2-1.8: SerialNumber: 0123456789ABCD > > [ 8.017794] usb 2-1.8: config 0 descriptor?? > > [ 8.258411] ata5: SATA link down (SStatus 0 SControl 300) > > [ 8.578480] ata6: SATA link down (SStatus 0 SControl 300) > > [ 8.588630] sd 0:0:0:0: [sda] 500118192 512-byte logical blocks: (256 > GB/238 GiB) > > [ 8.588846] sd 0:0:0:0: [sda] Write Protect is off > > [ 8.588861] sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00 > > [ 8.588967] sd 0:0:0:0: [sda] Write cache: enabled, read cache: > enabled, doesn't support DPO or FUA > > [ 8.590122] sda: sda1 sda2 > > [ 8.591059] sd 0:0:0:0: [sda] Attached SCSI disk > > [ 8.609438] sr0: scsi3-mmc drive: 24x/8x writer dvd-ram cd/rw > xa/form2 cdda tray > > [ 8.609451] cdrom: Uniform CD-ROM driver Revision: 3.20 > > [ 8.609737] sr 1:0:0:0: Attached scsi CD-ROM sr0 > > [ 8.714515] dracut: luksOpen /dev/sda2 > luks-400336fa-c7c4-4be3-a244-c909aa16a18c > > [ 13.862564] dracut: Scanning devices dm-0 for LVM logical volumes > vg_dom0/lv_root vg_dom0/lv_swap > > [ 13.907639] dracut: inactive '/dev/vg_dom0/lv_root' [221.62 GiB] > inherit > > [ 13.907708] dracut: inactive '/dev/vg_dom0/lv_swap' [16.34 GiB] > inherit > > [ 14.162684] EXT4-fs (dm-1): INFO: recovery required on readonly > filesystem > > [ 14.162693] EXT4-fs (dm-1): write access will be enabled during > recovery > > [ 14.775779] EXT4-fs (dm-1): orphan cleanup on readonly fs > > [ 14.775800] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767209 > > [ 14.775909] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767207 > > [ 14.776007] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767205 > > [ 14.776035] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767206 > > [ 14.776062] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767204 > > [ 14.776088] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767202 > > [ 14.776117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767198 > > [ 14.776146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767196 > > [ 14.776172] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767191 > > [ 14.776198] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767189 > > [ 14.776227] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767188 > > [ 14.776274] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767187 > > [ 14.777018] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767186 > > [ 14.777060] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767184 > > [ 14.777089] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767183 > > [ 14.777117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767171 > > [ 14.777146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting > unreferenced inode 5767170 > > [ 14.777172] EXT4-fs (dm-1): 17 orphan inodes deleted > > [ 14.777177] EXT4-fs (dm-1): recovery complete > > [ 14.797124] EXT4-fs (dm-1): mounted filesystem with ordered data > mode. Opts: (null) > > [ 14.806762] dracut: Mounted root filesystem > /dev/mapper/vg_dom0-lv_root > > [ 14.957211] dracut: Switching root > > [ 15.599261] udev: starting version 151 > > [ 15.673674] iTCO_vendor_support: vendor-support=0 > > [ 15.676374] mei: module is from the staging directory, the quality is > unknown, you have been warned. > > [ 15.676488] iTCO_wdt: Intel TCO WatchDog Timer Driver v1.07 > > [ 15.676679] iTCO_wdt: Found a Cougar Point TCO device (Version=2, > TCOBASE=0x0460) > > [ 15.676711] xen: registering gsi 16 triggering 0 polarity 1 > > [ 15.676716] Already setup the GSI :16 > > [ 15.676725] mei 0000:00:16.0: setting latency timer to 64 > > [ 15.676754] iTCO_wdt: initialized. heartbeat=30 sec (nowayout=0) > > [ 15.712582] sd 0:0:0:0: Attached scsi generic sg0 type 0 > > [ 15.712620] sr 1:0:0:0: Attached scsi generic sg1 type 5 > > [ 15.730448] input: PC Speaker as /devices/platform/pcspkr/input/input8 > > [ 15.734494] xen: registering gsi 18 triggering 0 polarity 1 > > [ 15.734500] Already setup the GSI :18 > > [ 15.734506] ACPI Warning: 0x0000000000004040-0x000000000000405f > SystemIO conflicts with Region \_SB_.PCI0.SBUS.SMBI 1 > (20120320/utaddress-251) > > [ 15.734512] ACPI: If an ACPI driver is available for this device, you > should use it instead of the native driver > > [ 15.737002] microcode: CPU0 sig=0x206a7, pf=0x10, revision=0x23 > > [ 15.741412] watchdog: INTCAMT: cannot register miscdev on minor=130 > (err=-16) > > [ 15.741418] watchdog: error registering /dev/watchdog (err=-16) > > [ 15.741422] mei 0000:00:16.0: unable to register watchdog device. > > [ 15.790637] thermal LNXTHERM:00: registered as thermal_zone0 > > [ 15.790641] ACPI: Thermal Zone [THM] (25 C) > > [ 15.814551] ACPI: Deprecated procfs I/F for battery is loaded, please > retry with CONFIG_ACPI_PROCFS_POWER cleared > > [ 15.814559] ACPI: Battery Slot [BAT0] (battery present) > > [ 15.815037] ACPI: Deprecated procfs I/F for AC is loaded, please > retry with CONFIG_ACPI_PROCFS_POWER cleared > > [ 15.815521] ACPI: AC Adapter [AC] (on-line) > > [ 15.867835] usbcore: registered new interface driver usbback > > [ 15.975826] ACPI: Deprecated procfs I/F for battery is loaded, please > retry with CONFIG_ACPI_PROCFS_POWER cleared > > [ 15.975836] ACPI: Battery Slot [BAT1] (battery absent) > > [ 16.102871] ACPI: Deprecated procfs I/F for battery is loaded, please > retry with CONFIG_ACPI_PROCFS_POWER cleared > > [ 16.102882] ACPI: Battery Slot [BAT2] (battery absent) > > [ 16.106793] sdhci: Secure Digital Host Controller Interface driver > > [ 16.106797] sdhci: Copyright(c) Pierre Ossman > > [ 16.107131] parport_pc 00:08: [io 0x0378-0x037b] > > [ 16.107296] parport_pc 00:08: [irq 5] > > [ 16.107709] sdhci-pci 0000:0a:00.0: SDHCI controller found > [1217:8221] (rev 5) > > [ 16.159148] xen: registering gsi 17 triggering 0 polarity 1 > > [ 16.159156] Already setup the GSI :17 > > [ 16.159241] sdhci-pci 0000:0a:00.0: Invalid iomem size. You may > experience problems. > > [ 16.159319] 0000:0a:00.0 supply vmmc not found, using dummy regulator > > [ 16.159384] Registered led device: mmc0:: > > [ 16.160442] mmc0: SDHCI controller on PCI [0000:0a:00.0] using DMA > > [ 16.160928] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 16.171737] Linux video capture interface: v2.00 > > [ 16.192158] cdc_wdm 2-1.6:1.5: cdc-wdm0: USB WDM device > > [ 16.192211] cdc_wdm 2-1.6:1.8: cdc-wdm1: USB WDM device > > [ 16.192234] usbcore: registered new interface driver cdc_wdm > > [ 16.195744] cdc_acm 2-1.6:1.1: ttyACM0: USB ACM device > > [ 16.198739] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 16.220532] cdc_acm 2-1.6:1.3: ttyACM1: USB ACM device > > [ 16.223728] cdc_acm 2-1.6:1.9: ttyACM2: USB ACM device > > [ 16.235089] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 16.235234] usbcore: registered new interface driver cdc_acm > > [ 16.235236] cdc_acm: USB Abstract Control Model driver for USB modems > and ISDN adapters > > [ 16.240235] uvcvideo: Found UVC 1.00 device > Laptop_Integrated_Webcam_FHD (05ca:181c) > > [ 16.269474] input: Laptop_Integrated_Webcam_FHD as > /devices/pci0000:00/0000:00:1a.0/usb1/1-1/1-1.5/1-1.5:1.0/input/input9 > > [ 16.269579] usbcore: registered new interface driver uvcvideo > > [ 16.269581] USB Video Class driver (1.1.1) > > [ 16.277415] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 16.296646] usb 2-1.6: MAC-Address: 02:80:37:ec:02:00 > > [ 16.296810] cdc_ncm 2-1.6:1.6: usb0: register 'cdc_ncm' at > usb-0000:00:1d.0-1.6, CDC NCM, 02:80:37:ec:02:00 > > [ 16.296847] usbcore: registered new interface driver cdc_ncm > > [ 16.310604] parport_pc 00:08: activated > > [ 16.310611] parport_pc 00:08: reported by Plug and Play ACPI > > [ 16.310781] parport_pc 00:08: disabled > > [ 16.311583] tpm_tis 00:0a: 1.2 TPM (device-id 0x2001, rev-id 32) > > [ 16.399296] Bluetooth: Core ver 2.16 > > [ 16.399312] NET: Registered protocol family 31 > > [ 16.399314] Bluetooth: HCI device and connection manager initialized > > [ 16.399317] Bluetooth: HCI socket layer initialized > > [ 16.399318] Bluetooth: L2CAP socket layer initialized > > [ 16.399325] Bluetooth: SCO socket layer initialized > > [ 16.450583] xen: registering gsi 22 triggering 0 polarity 1 > > [ 16.450600] xen: --> pirq=22 -> irq=22 (gsi=22) > > [ 16.567577] usbcore: registered new interface driver btusb > > [ 16.739259] dcdbas dcdbas: Dell Systems Management Base Driver > (version 5.6.0-3.2) > > [ 16.819125] input: Dell WMI hotkeys as /devices/virtual/input/input10 > > [ 16.925000] microcode: CPU1 sig=0x206a7, pf=0x10, revision=0x23 > > [ 16.929246] ppdev: user-space parallel port driver > > [ 16.954783] microcode: CPU2 sig=0x206a7, pf=0x10, revision=0x23 > > [ 16.975176] microcode: CPU3 sig=0x206a7, pf=0x10, revision=0x23 > > [ 17.004696] microcode: Microcode Update Driver: v2.00 < > tigran@aivazian.fsnet.co.uk>, Peter Oruba > > [ 17.067123] ALSA hda_codec.c:5101 autoconfig: line_outs=1 > (0xe/0x0/0x0/0x0/0x0) type:line > > [ 17.067127] ALSA hda_codec.c:5105 speaker_outs=1 > (0xd/0x0/0x0/0x0/0x0) > > [ 17.067129] ALSA hda_codec.c:5109 hp_outs=1 (0xb/0x0/0x0/0x0/0x0) > > [ 17.067131] ALSA hda_codec.c:5110 mono: mono_out=0x0 > > [ 17.067133] ALSA hda_codec.c:5114 inputs: > > [ 17.067135] ALSA hda_codec.c:5118 Mic=0xa > > [ 17.067137] ALSA hda_codec.c:5118 Dock Mic=0xf > > [ 17.067139] ALSA hda_codec.c:5120 > > [ 17.067637] ALSA patch_sigmatel.c:3117 stac92xx: dac_nids=1 > (0x13/0x0/0x0/0x0/0x0) > > [ 17.081104] input: HDA Intel PCH HDMI/DP,pcm=8 as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input11 > > [ 17.081194] input: HDA Intel PCH HDMI/DP,pcm=7 as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input12 > > [ 17.081250] input: HDA Intel PCH HDMI/DP,pcm=3 as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input13 > > [ 17.081342] input: HDA Intel PCH Dock Mic as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input14 > > [ 17.081432] input: HDA Intel PCH Mic as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input15 > > [ 17.081522] input: HDA Intel PCH Headphone as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input16 > > [ 17.081610] input: HDA Intel PCH Dock Line Out as > /devices/pci0000:00/0000:00:1b.0/sound/card0/input17 > > [ 17.265462] Event-channel device installed. > > [ 17.661764] EXT4-fs (dm-1): re-mounted. Opts: (null) > > [ 17.802446] EXT4-fs (sda1): mounted filesystem with ordered data > mode. Opts: (null) > > [ 19.361631] Adding 17137660k swap on /dev/mapper/vg_dom0-lv_swap. > Priority:-1 extents:1 across:17137660k SS > > [ 22.602549] ehci_hcd 0000:00:1a.0: remove, state 1 > > [ 22.602568] usb usb1: USB disconnect, device number 1 > > [ 22.602573] usb 1-1: USB disconnect, device number 2 > > [ 22.602578] usb 1-1.4: USB disconnect, device number 3 > > [ 22.605235] usb 1-1.5: USB disconnect, device number 4 > > [ 22.636910] ehci_hcd 0000:00:1a.0: USB bus 1 deregistered > > [ 22.637183] pciback 0000:00:1a.0: seizing device > > [ 22.637235] xen: registering gsi 16 triggering 0 polarity 1 > > [ 22.637241] Already setup the GSI :16 > > [ 22.662363] ehci_hcd 0000:00:1d.0: remove, state 1 > > [ 22.662371] usb usb2: USB disconnect, device number 1 > > [ 22.662373] usb 2-1: USB disconnect, device number 2 > > [ 22.662376] usb 2-1.6: USB disconnect, device number 3 > > [ 22.668531] cdc_ncm 2-1.6:1.6: usb0: unregister 'cdc_ncm' > usb-0000:00:1d.0-1.6, CDC NCM > > [ 22.694795] usb 2-1.8: USB disconnect, device number 4 > > [ 22.699298] ehci_hcd 0000:00:1d.0: USB bus 2 deregistered > > [ 22.699577] pciback 0000:00:1d.0: seizing device > > [ 22.699632] xen: registering gsi 17 triggering 0 polarity 1 > > [ 22.699637] Already setup the GSI :17 > > [ 23.684708] xen-pciback: vpci: 0000:00:19.0: assign to virtual slot 0 > > [ 23.685240] xen-pciback: vpci: 0000:00:1a.0: assign to virtual slot 1 > > [ 23.685722] xen-pciback: vpci: 0000:00:1d.0: assign to virtual slot 2 > > [ 23.686764] xen-pciback: vpci: 0000:02:00.0: assign to virtual slot 3 > > [ 23.909636] pciback 0000:00:19.0: Driver tried to write to a > read-only configuration space field at offset 0xd2, size 2. This may be > harmless, but if you have problems with your device: > > [ 23.909638] 1) see permissive attribute in sysfs > > [ 23.909638] 2) report problems to the xen-devel mailing list along > with details of your device obtained from lspci. > > [ 23.917523] pciback 0000:02:00.0: Driver tried to write to a > read-only configuration space field at offset 0xd2, size 2. This may be > harmless, but if you have problems with your device: > > [ 23.917526] 1) see permissive attribute in sysfs > > [ 23.917526] 2) report problems to the xen-devel mailing list along > with details of your device obtained from lspci. > > [ 24.123663] xen-blkback:ring-ref 9, event-channel 14, protocol 1 > (x86_64-abi) > > [ 24.140460] xen-blkback:ring-ref 10, event-channel 15, protocol 1 > (x86_64-abi) > > [ 24.151420] xen-blkback:ring-ref 11, event-channel 16, protocol 1 > (x86_64-abi) > > [ 24.158428] xen-blkback:ring-ref 12, event-channel 17, protocol 1 > (x86_64-abi) > > [ 28.697615] pciback 0000:00:1a.0: enabling device (0000 -> 0002) > > [ 28.697628] xen: registering gsi 16 triggering 0 polarity 1 > > [ 28.697634] Already setup the GSI :16 > > [ 28.697805] pciback 0000:00:1a.0: setting latency timer to 64 > > [ 28.713578] pciback 0000:00:19.0: enabling device (0000 -> 0003) > > [ 28.713591] xen: registering gsi 20 triggering 0 polarity 1 > > [ 28.713598] Already setup the GSI :20 > > [ 28.713858] pciback 0000:00:19.0: setting latency timer to 64 > > [ 29.021371] pciback 0000:00:1d.0: enabling device (0000 -> 0002) > > [ 29.021389] xen: registering gsi 17 triggering 0 polarity 1 > > [ 29.021400] Already setup the GSI :17 > > [ 29.021805] pciback 0000:00:1d.0: setting latency timer to 64 > > [ 29.150053] pciback 0000:02:00.0: enabling device (0000 -> 0002) > > [ 29.150122] xen: registering gsi 17 triggering 0 polarity 1 > > [ 29.150150] Already setup the GSI :17 > > [ 33.635416] xen-blkback:ring-ref 9, event-channel 14, protocol 1 > (x86_64-abi) > > [ 33.643330] xen-blkback:ring-ref 10, event-channel 15, protocol 1 > (x86_64-abi) > > [ 33.651561] xen-blkback:ring-ref 11, event-channel 16, protocol 1 > (x86_64-abi) > > [ 33.672105] xen-blkback:ring-ref 12, event-channel 17, protocol 1 > (x86_64-abi) > > [ 104.230911] xen-blkback:ring-ref 9, event-channel 24, protocol 1 > (x86_64-abi) > > [ 104.252421] xen-blkback:ring-ref 10, event-channel 25, protocol 1 > (x86_64-abi) > > [ 104.253177] xen-blkback:ring-ref 11, event-channel 26, protocol 1 > (x86_64-abi) > > [ 104.254220] xen-blkback:ring-ref 12, event-channel 27, protocol 1 > (x86_64-abi) > > [ 105.086732] xen-blkback:ring-ref 9, event-channel 14, protocol 1 > (x86_64-abi) > > [ 105.105505] xen-blkback:ring-ref 10, event-channel 15, protocol 1 > (x86_64-abi) > > [ 105.115951] xen-blkback:ring-ref 11, event-channel 16, protocol 1 > (x86_64-abi) > > [ 105.127384] xen-blkback:ring-ref 12, event-channel 17, protocol 1 > (x86_64-abi) > > [ 105.929760] xen-blkback:ring-ref 9, event-channel 14, protocol 1 > (x86_64-abi) > > [ 105.934841] xen-blkback:ring-ref 10, event-channel 15, protocol 1 > (x86_64-abi) > > [ 105.973920] xen-blkback:ring-ref 11, event-channel 16, protocol 1 > (x86_64-abi) > > [ 105.975320] xen-blkback:ring-ref 12, event-channel 17, protocol 1 > (x86_64-abi) > > [ 107.191781] xen-blkback:ring-ref 9, event-channel 14, protocol 1 > (x86_64-abi) > > [ 107.203711] xen-blkback:ring-ref 10, event-channel 15, protocol 1 > (x86_64-abi) > > [ 107.208481] xen-blkback:ring-ref 11, event-channel 16, protocol 1 > (x86_64-abi) > > [ 107.212081] xen-blkback:ring-ref 12, event-channel 17, protocol 1 > (x86_64-abi) > > [ 733.434608] PM: Syncing filesystems ... done. > > [ 733.436228] PM: Preparing system for mem sleep > > [ 733.514803] Freezing user space processes ... (elapsed 0.01 seconds) > done. > > [ 733.530594] Freezing remaining freezable tasks ... (elapsed 0.01 > seconds) done. > > [ 733.546589] PM: Entering mem sleep > > [ 733.546741] Suspending console(s) (use no_console_suspend to debug) > > [ 733.547431] sd 0:0:0:0: [sda] Synchronizing SCSI cache > > [ 733.558336] sd 0:0:0:0: [sda] Stopping disk > > [ 734.194656] PM: suspend of devices complete after 647.504 msecs > > [ 734.195026] PM: late suspend of devices complete after 0.359 msecs > > [ 734.210655] PM: noirq suspend of devices complete after 15.614 msecs > > [ 734.211326] ACPI: Preparing to enter system sleep state S3 > > [ 734.235008] PM: Saving platform NVS memory > > [ 734.328066] Disabling non-boot CPUs ... > > [ 735.945491] ACPI: Low-level resume complete > > [ 735.945579] PM: Restoring platform NVS memory > > [ 736.000094] Enabling non-boot CPUs ... > > [ 736.000256] installing Xen timer for CPU 1 > > [ 736.004594] CPU1 is up > > [ 736.004819] installing Xen timer for CPU 2 > > [ 736.067516] CPU2 is up > > [ 736.067770] installing Xen timer for CPU 3 > > [ 736.101535] CPU3 is up > > [ 736.102470] ACPI: Waking up from system sleep state S3 > > [ 736.555932] PM: noirq resume of devices complete after 7.970 msecs > > [ 736.556506] PM: early resume of devices complete after 0.387 msecs > > [ 736.660336] i915 0000:00:02.0: setting latency timer to 64 > > [ 736.660404] pciback 0000:00:19.0: setting latency timer to 64 > > [ 736.660453] xen: registering gsi 16 triggering 0 polarity 1 > > [ 736.660460] Already setup the GSI :16 > > [ 736.660490] pciback 0000:00:1a.0: setting latency timer to 64 > > [ 736.660605] xen: registering gsi 17 triggering 0 polarity 1 > > [ 736.660610] Already setup the GSI :17 > > [ 736.660641] pciback 0000:00:1d.0: setting latency timer to 64 > > [ 736.660696] xen: registering gsi 22 triggering 0 polarity 1 > > [ 736.660701] Already setup the GSI :22 > > [ 736.661221] ahci 0000:00:1f.2: setting latency timer to 64 > > [ 736.689606] xen: registering gsi 18 triggering 0 polarity 1 > > [ 736.689608] Already setup the GSI :18 > > [ 736.689704] xen: registering gsi 17 triggering 0 polarity 1 > > [ 736.689706] Already setup the GSI :17 > > [ 736.711623] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp off > > [ 736.802676] watchdog: INTCAMT: cannot register miscdev on minor=130 > (err=-16) > > [ 736.802678] watchdog: error registering /dev/watchdog (err=-16) > > [ 736.802680] mei 0000:00:16.0: unable to register watchdog device. > > [ 737.060106] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 300) > > [ 737.060330] ata4: SATA link down (SStatus 0 SControl 300) > > [ 737.060372] ata5: SATA link down (SStatus 0 SControl 300) > > [ 737.074123] ata2.00: configured for UDMA/133 > > [ 737.117629] ata6: SATA link down (SStatus 0 SControl 300) > > [ 738.619036] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) > > [ 738.743565] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by > device (Stat=0x51 Err=0x04) > > [ 738.901088] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected by > device (Stat=0x51 Err=0x04) > > [ 738.903441] ata1.00: configured for UDMA/100 > > [ 738.903843] sd 0:0:0:0: [sda] Starting disk > > [ 738.905367] PM: resume of devices complete after 2348.851 msecs > > [ 738.905922] PM: Finishing wakeup. > > [ 738.905926] Restarting tasks ... done. > > [ 738.911334] video LNXVIDEO:00: Restoring backlight state > > [ 739.836250] dell_wmi: Received unknown WMI event (0x0) > > [ 740.184759] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 740.239730] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 740.327711] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 740.373931] sdhci-pci 0000:0a:00.0: could not set regulator OCR (-22) > > [ 742.542022] hrtimer: interrupt took 102980031 ns > > [ 757.609031] [sched_delayed] sched: RT throttling activated > > [ 760.164427] hda-intel: IRQ timing workaround is activated for card > #0. Suggest a bigger bdl_pos_adj. > > > (XEN) Xen version 4.1.3 (user@marmarek.net) (gcc version 4.4.5 20101112 > (Red Hat 4.4.5-2) (GCC) ) Mon Nov 26 15:25:32 EST 2012 > > (XEN) Latest ChangeSet: unavailable > > (XEN) Bootloader: GNU GRUB 0.97 > > (XEN) Command line: console=none cpufreq=verbose=1 > > (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 1 MBR signatures > > (XEN) Found 1 EDD information structures > > (XEN) Xen-e820 RAM map: > > (XEN) 0000000000000000 - 000000000009a800 (usable) > > (XEN) 000000000009a800 - 00000000000a0000 (reserved) > > (XEN) 00000000000e0000 - 0000000000100000 (reserved) > > (XEN) 0000000000100000 - 0000000007eea000 (usable) > > (XEN) 0000000007eea000 - 0000000007f67000 (ACPI NVS) > > (XEN) 0000000007f67000 - 0000000007f70000 (usable) > > (XEN) 0000000007f70000 - 0000000007f76000 (ACPI NVS) > > (XEN) 0000000007f76000 - 0000000007f78000 (usable) > > (XEN) 0000000007f78000 - 0000000008000000 (ACPI NVS) > > (XEN) 0000000008000000 - 000000000dffd000 (usable) > > (XEN) 000000000dffd000 - 000000000e000000 (ACPI data) > > (XEN) 000000000e000000 - 0000000020000000 (usable) > > (XEN) 0000000020000000 - 0000000020200000 (reserved) > > (XEN) 0000000020200000 - 0000000040000000 (usable) > > (XEN) 0000000040000000 - 0000000040200000 (reserved) > > (XEN) 0000000040200000 - 00000000c83b4000 (usable) > > (XEN) 00000000c83b4000 - 00000000c840a000 (reserved) > > (XEN) 00000000c840a000 - 00000000c840e000 (usable) > > (XEN) 00000000c840e000 - 00000000c840f000 (reserved) > > (XEN) 00000000c840f000 - 00000000c8411000 (usable) > > (XEN) 00000000c8411000 - 00000000c8414000 (reserved) > > (XEN) 00000000c8414000 - 00000000c841e000 (usable) > > (XEN) 00000000c841e000 - 00000000c8428000 (reserved) > > (XEN) 00000000c8428000 - 00000000c8432000 (usable) > > (XEN) 00000000c8432000 - 00000000c8436000 (reserved) > > (XEN) 00000000c8436000 - 00000000cac00000 (usable) > > (XEN) 00000000cb800000 - 00000000cfa00000 (reserved) > > (XEN) 00000000fed1c000 - 00000000fed20000 (reserved) > > (XEN) 00000000ffc00000 - 00000000ffc20000 (reserved) > > (XEN) 0000000100000000 - 000000042e000000 (usable) > > (XEN) ACPI: RSDP 000FE300, 0024 (r2 DELL ) > > (XEN) ACPI: XSDT 0DFFEE18, 007C (r1 DELL CBX3 6222004 MSFT > 10013) > > (XEN) ACPI: FACP 07F90D98, 00F4 (r4 DELL CBX3 6222004 MSFT > 10013) > > (XEN) ACPI: DSDT 07F5E018, 8834 (r2 INT430 SYSFexxx 1001 INTL > 20090903) > > (XEN) ACPI: FACS 07FEDD40, 0040 > > (XEN) ACPI: APIC 0DFFDF18, 00CC (r2 DELL CBX3 6222004 MSFT > 10013) > > (XEN) ACPI: TCPA 07FEED18, 0032 (r2 0 > 0) > > (XEN) ACPI: SSDT 07F91A98, 02F9 (r1 DELLTP TPM 3000 INTL > 20090903) > > (XEN) ACPI: MCFG 07FEEC98, 003C (r1 DELL SNDYBRDG 6222004 MSFT > 97) > > (XEN) ACPI: HPET 07FEEC18, 0038 (r1 A M I PCHHPET 6222004 AMI. > 3) > > (XEN) ACPI: BOOT 07FEEB98, 0028 (r1 DELL CBX3 6222004 AMI > 10013) > > (XEN) ACPI: SSDT 07F75018, 0804 (r1 PmRef Cpu0Ist 3000 INTL > 20090903) > > (XEN) ACPI: SSDT 07F74018, 0996 (r1 PmRef CpuPm 3000 INTL > 20090903) > > (XEN) ACPI: DMAR 07F90C18, 00E8 (r1 INTEL SNB 1 INTL > 1) > > (XEN) ACPI: SLIC 07F7EC18, 0176 (r3 DELL CBX3 6222004 MSFT > 10013) > > (XEN) System RAM: 16262MB (16652432kB) > > (XEN) Domain heap initialised > > (XEN) ACPI: 32/64X FACS address mismatch in FADT - > 07fede40/0000000007fedd40, using 32 > > (XEN) Processor #0 6:10 APIC version 21 > > (XEN) Processor #2 6:10 APIC version 21 > > (XEN) Processor #1 6:10 APIC version 21 > > (XEN) Processor #3 6:10 APIC version 21 > > (XEN) IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23 > > (XEN) Enabling APIC mode: Flat. Using 1 I/O APICs > > (XEN) Table is not found! > > (XEN) Switched to APIC driver x2apic_cluster. > > (XEN) Using scheduler: SMP Credit Scheduler (credit) > > (XEN) Detected 2494.416 MHz processor. > > (XEN) Initing memory sharing. > > (XEN) Intel VT-d supported page sizes: 4kB. > > (XEN) Intel VT-d supported page sizes: 4kB. > > (XEN) Intel VT-d Snoop Control not 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 not enabled. > > (XEN) I/O virtualisation enabled > > (XEN) - Dom0 mode: Relaxed > > (XEN) Enabled directed EOI with ioapic_ack_old on! > > (XEN) ENABLING IO-APIC IRQs > > (XEN) -> Using old ACK method > > (XEN) Platform timer appears to have unexpectedly wrapped 1 times. > > (XEN) Platform timer is 14.318MHz HPET > > (XEN) Allocated console ring of 16 KiB. > > (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) HVM: ASIDs enabled. > > (XEN) HVM: VMX enabled > > (XEN) HVM: Hardware Assisted Paging (HAP) detected > > (XEN) HVM: HAP page sizes: 4kB, 2MB > > (XEN) Brought up 4 CPUs > > (XEN) *** LOADING DOMAIN 0 *** > > (XEN) Xen kernel: 64-bit, lsb, compat32 > > (XEN) Dom0 kernel: 64-bit, PAE, lsb, paddr 0x1000000 -> 0x1e13000 > > (XEN) PHYSICAL MEMORY ARRANGEMENT: > > (XEN) Dom0 alloc.: 0000000418000000->000000041c000000 (4046567 pages > to be allocated) > > (XEN) Init. ramdisk: 000000042b335000->000000042dfffc00 > > (XEN) VIRTUAL MEMORY ARRANGEMENT: > > (XEN) Loaded kernel: ffffffff81000000->ffffffff81e13000 > > (XEN) Init. ramdisk: ffffffff81e13000->ffffffff84addc00 > > (XEN) Phys-Mach map: ffffffff84ade000->ffffffff869f3d90 > > (XEN) Start info: ffffffff869f4000->ffffffff869f44b4 > > (XEN) Page tables: ffffffff869f5000->ffffffff86a2e000 > > (XEN) Boot stack: ffffffff86a2e000->ffffffff86a2f000 > > (XEN) TOTAL: ffffffff80000000->ffffffff86c00000 > > (XEN) ENTRY ADDRESS: ffffffff8188e200 > > (XEN) Dom0 has maximum 4 VCPUs > > (XEN) Scrubbing Free RAM: .done. > > (XEN) Xen trace buffers: disabled > > (XEN) Std. Loglevel: Errors and warnings > > (XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings) > > (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times to switch > input to Xen) > > (XEN) Freed 216kB init memory. > > (XEN) no cpu_id for acpi_id 5 > > (XEN) no cpu_id for acpi_id 6 > > (XEN) no cpu_id for acpi_id 7 > > (XEN) no cpu_id for acpi_id 8 > > (XEN) physdev.c:171: dom0: wrong map_pirq type 3 > > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc9000057b030. > > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000718030. > > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004f2030. > > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004fa030. > > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000251030. > > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000263030. > > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc9000026b030. > > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000273030. > > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004f2030. > > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000015030. > > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004f2030. > > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000015030. > > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004f2030. > > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc900004fa030. > > (XEN) Disabling non-boot CPUs ... > > (XEN) Broke affinity for irq 1 > > (XEN) Broke affinity for irq 8 > > (XEN) Broke affinity for irq 9 > > (XEN) Broke affinity for irq 12 > > (XEN) Broke affinity for irq 17 > > (XEN) Broke affinity for irq 31 > > (XEN) Broke affinity for irq 16 > > (XEN) Broke affinity for irq 20 > > (XEN) Entering ACPI S3 state. > > (XEN) mce_intel.c:1162: MCA Capability: BCAST 1 SER 0 CMCI 1 firstbank 0 > extended MCE MSR 0 > > (XEN) CPU0 CMCI LVT vector (0xf7) already installed > > (XEN) CPU0: Thermal LVT vector (0xfa) already installed > > (XEN) Finishing wakeup from ACPI S3 state. > > (XEN) Enabling non-boot CPUs ... > > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000524030. > > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc9000052c030. > > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc90000015030. > > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from > 0x0000000000000000 to 0xffffc9000001d030. > > (XEN) Dumping timer queues: > > (XEN) CPU00: > > (XEN) ex= 126us timer=ffff8300c83b0060 > cb=ffff82c48011e420(ffff8300c83b0000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 1778us timer=ffff8304222f9de8 > cb=ffff82c480118250(0000000000000000) csched_tick+0x0/0x2e0 > > (XEN) ex= 126us timer=ffff8300c81fc060 > cb=ffff82c48011e420(ffff8300c81fc000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 17227us timer=ffff82c4802bb980 > cb=ffff82c480138ff0(ffff82c4802bb940) do_dbs_timer+0x0/0x250 > > (XEN) ex= 20744us timer=ffff830030094060 > cb=ffff82c48011e420(ffff830030094000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 27945us timer=ffff8304222fdde0 > cb=ffff82c480116f20(ffff8304222fddc0) csched_acct+0x0/0x460 > > (XEN) ex= 29949us timer=ffff82c4802bb760 > cb=ffff82c48011ded0(0000000000000000) s_timer_fn+0x0/0x20 > > (XEN) ex= 87774us timer=ffff83008db6a060 > cb=ffff82c48011e420(ffff83008db6a000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 79252us timer=ffff82c4802b3880 > cb=ffff82c480177160(0000000000000000) time_calibration+0x0/0x60 > > (XEN) ex= 703146us timer=ffff8300a6b9c060 > cb=ffff82c48011e420(ffff8300a6b9c000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 35612us timer=ffff8300330dc060 > cb=ffff82c48011e420(ffff8300330dc000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 97688us timer=ffff8300a6b98060 > cb=ffff82c48011e420(ffff8300a6b98000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 30003us timer=ffff8300b129a060 > cb=ffff82c48011e420(ffff8300b129a000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 92679us timer=ffff8300c94a6060 > cb=ffff82c48011e420(ffff8300c94a6000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 4135118us timer=ffff8300bdca6060 > cb=ffff82c48011e420(ffff8300bdca6000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 96411us timer=ffff8300b128e060 > cb=ffff82c48011e420(ffff8300b128e000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 1337866us timer=ffff8300a6b94060 > cb=ffff82c48011e420(ffff8300a6b94000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 91194us timer=ffff830034b98060 > cb=ffff82c48011e420(ffff830034b98000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 97955us timer=ffff83007d948060 > cb=ffff82c48011e420(ffff83007d948000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 4135163us timer=ffff8300c5336060 > cb=ffff82c48011e420(ffff8300c5336000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex=123464409us timer=ffff82c4802b3980 > cb=ffff82c480176ef0(0000000000000000) plt_overflow+0x0/0x190 > > (XEN) ex= 95968us timer=ffff8300a6b96060 > cb=ffff82c48011e420(ffff8300a6b96000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex=12401701us timer=ffff82c4802b65a0 > cb=ffff82c48019eb10(0000000000000000) mce_work_fn+0x0/0xd0 > > (XEN) ex= 97804us timer=ffff8300301a8060 > cb=ffff82c48011e420(ffff8300301a8000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 97841us timer=ffff8300bd810060 > cb=ffff82c48011e420(ffff8300bd810000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 98039us timer=ffff83007d94c060 > cb=ffff82c48011e420(ffff83007d94c000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 94727us timer=ffff83008db6e060 > cb=ffff82c48011e420(ffff83008db6e000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) ex= 319927us timer=ffff8300c840c060 > cb=ffff82c48011e420(ffff8300c840c000) vcpu_singleshot_timer_fn+0x0/0x10 > > (XEN) CPU01: > > (XEN) CPU02: > > (XEN) CPU03: > > (XEN) 'c' pressed -> printing ACPI Cx structures > > (XEN) ==cpu0== > > (XEN) active state: C3 > > (XEN) max_cstate: C7 > > (XEN) states: > > (XEN) C1: type[C1] latency[000] usage[00254665] method[ HALT] > duration[62720099833] > > (XEN) C2: type[C2] latency[080] usage[00069505] method[SYSIO] > duration[36499255195] > > (XEN) *C3: type[C3] latency[109] usage[01828952] method[SYSIO] > duration[5562126933174] > > (XEN) C0: usage[02153122] duration[2042526389598] > > (XEN) PC3[0] PC6[0] PC7[0] > > (XEN) CC3[0] CC6[0] > > (XEN) ==cpu1== > > (XEN) active state: C1 > > (XEN) max_cstate: C7 > > (XEN) states: > > (XEN) *C1: type[C1] latency[000] usage[00808027] method[ HALT] > duration[6978799306750] > > (XEN) C0: usage[00808027] duration[725073398104] > > (XEN) PC3[0] PC6[0] PC7[0] > > (XEN) CC3[0] CC6[0] > > (XEN) ==cpu2== > > (XEN) active state: C1 > > (XEN) max_cstate: C7 > > (XEN) states: > > (XEN) *C1: type[C1] latency[000] usage[00825022] method[ HALT] > duration[6981527416097] > > (XEN) C0: usage[00825022] duration[722345319882] > > (XEN) PC3[0] PC6[0] PC7[0] > > (XEN) CC3[0] CC6[0] > > (XEN) ==cpu3== > > (XEN) active state: C1 > > (XEN) max_cstate: C7 > > (XEN) states: > > (XEN) *C1: type[C1] latency[000] usage[00810292] method[ HALT] > duration[6980835907857] > > (XEN) C0: usage[00810292] duration[723036844779] > > (XEN) PC3[0] PC6[0] PC7[0] > > (XEN) CC3[0] CC6[0] > > > > > > _______________________________________________ > > Xen-devel mailing list > > Xen-devel@lists.xen.org > > http://lists.xen.org/xen-devel > > --e89a8f3b9d3d4a9abe04cfbdb242 Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable I had similar, but (I think) different issues.

    See the f= ollowing thread:

    I still have a patch reverting part of this changeset t= o get S3 working with pinning CPU affinity... the affinity doesn't get = restored on resume, however.

    I don't have much= experience with this on Xen 4.1, as I ran into the issue when bringing up = Xen-4.2, from Xen 4.0

    However, I could see how this could be related, since i= t is in the scheduler...

    On Fri, Nov 30, = 2012 at 4:33 PM, Konrad Rzeszutek Wilk <konrad@kernel.org> w= rote:
    On Thu, Nov 29, 2012 at 07= :55:06PM +0100, Marek Marczykowski wrote:
    > Hi all,
    >
    > After resume from ACPI S3 system has only CPU0 enabled, every vCPU fro= m every
    > domain works on CPU0 [1]. =A0When trying to pin some vCPU to CPU1 got = error:
    > xl vcpu-pin testvm 1 1
    > libxl: error: libxl.c:2565:libxl_set_vcpuaffinity setting vcpu affinit= y:
    > Invalid argument
    >
    > What went wrong? How can I reenable CPU1-CPU3?

    I think Ben had found some issues with this in the past? CC-ing him here.
    >
    > System info:
    > xen 4.1.3
    > linux 3.4.18 with acpi-s3 patches from Konrad's git
    > Processor: Intel i5-2520M
    >
    > dmesg from dom0 and hypervisor attached.
    >
    > BTW Are there any plans to upstream acpi-s3 patches?
    >
    > [1] xl vcpu-list:
    > Name =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0ID= =A0VCPU =A0 CPU State =A0 Time(s) CPU Affinity
    > dom0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 0= =A0 =A0 0 =A0 =A00 =A0 r-- =A0 =A01347.8 =A0any cpu
    > dom0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 0= =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 594.4 =A0any cpu
    > dom0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 0= =A0 =A0 2 =A0 =A00 =A0 -b- =A0 =A0 421.1 =A0any cpu
    > dom0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 0= =A0 =A0 3 =A0 =A00 =A0 -b- =A0 =A0 432.6 =A0any cpu
    > netvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A01= =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 596.6 =A0any cpu
    > netvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A01= =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 363.7 =A0any cpu
    > firewallvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 2 =A0 = =A0 0 =A0 =A00 =A0 -b- =A0 =A0 170.5 =A0any cpu
    > firewallvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 2 =A0 = =A0 1 =A0 =A00 =A0 -b- =A0 =A0 122.5 =A0any cpu
    > devel17 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A03 = =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 137.0 =A0any cpu
    > devel17 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A03 = =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 112.9 =A0any cpu
    > devel17 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A03 = =A0 =A0 2 =A0 =A00 =A0 -b- =A0 =A0 =A097.9 =A0any cpu
    > devel17 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A03 = =A0 =A0 3 =A0 =A00 =A0 -b- =A0 =A0 116.0 =A0any cpu
    > vm2 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A04 =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 418.6 =A0any cpu
    > vm2 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A04 =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 390.2 =A0any cpu
    > private =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A05 = =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 175.9 =A0any cpu
    > private =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A05 = =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 161.6 =A0any cpu
    > mail =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 6= =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A01587.1 =A0any cpu
    > mail =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 6= =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A01717.5 =A0any cpu
    > testvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 7 = =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 =A073.0 =A0any cpu
    > testvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 7 = =A0 =A0 1 =A0 =A00 =A0 -b- =A0 =A0 =A068.9 =A0any cpu
    > testvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 7 = =A0 =A0 2 =A0 =A00 =A0 -b- =A0 =A0 =A051.4 =A0any cpu
    > testvm =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 7 = =A0 =A0 3 =A0 =A00 =A0 -b- =A0 =A0 =A067.1 =A0any cpu
    > disp1 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A08= =A0 =A0 0 =A0 =A00 =A0 -b- =A0 =A0 199.9 =A0any cpu
    >
    >
    > --
    > Best Regards / Pozdrawiam,
    > Marek Marczykowski
    > Invisible Things Lab

    > [ =A0 =A00.000000] Initializing cgroup subsys cpuset
    > [ =A0 =A00.000000] Initializing cgroup subsys cpu
    > [ =A0 =A00.000000] Linux version 3.4.18-2.pvops.qubes.x86_64 (user@nemezis.marmarek.net) (gcc v= ersion 4.4.5 20101112 (Red Hat 4.4.5-2) (GCC) ) #1 SMP Wed Nov 7 22:47:21 E= ST 2012
    > [ =A0 =A00.000000] Command line: ro root=3D/dev/mapper/vg_dom0-lv_root= rd_LUKS_UUID=3Dluks-400336fa-c7c4-4be3-a244-c909aa16a18c rd_LVM_LV=3Dvg_do= m0/lv_root rd_LVM_LV=3Dvg_dom0/lv_swap rd_NO_MD rd_NO_DM LANG=3Den_US.UTF-8= SYSFONT=3Dlatarcyrheb-sun16 KEYTABLE=3Dpl2 rhgb quiet max_loop=3D255
    > [ =A0 =A00.000000] Freeing =A09a-100 pfn range: 102 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on 9a->100
    > [ =A0 =A00.000000] Freeing =A07eea-7f67 pfn range: 125 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on 7eea->7f67
    > [ =A0 =A00.000000] Freeing =A07f70-7f76 pfn range: 6 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on 7f70->7f76
    > [ =A0 =A00.000000] Freeing =A07f78-8000 pfn range: 136 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on 7f78->8000
    > [ =A0 =A00.000000] Freeing =A0dffd-e000 pfn range: 3 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on dffd->e000
    > [ =A0 =A00.000000] Freeing =A020000-20200 pfn range: 512 pages freed > [ =A0 =A00.000000] 1-1 mapping on 20000->20200
    > [ =A0 =A00.000000] Freeing =A040000-40200 pfn range: 512 pages freed > [ =A0 =A00.000000] 1-1 mapping on 40000->40200
    > [ =A0 =A00.000000] Freeing =A0c83b4-c840a pfn range: 86 pages freed > [ =A0 =A00.000000] 1-1 mapping on c83b4->c840a
    > [ =A0 =A00.000000] Freeing =A0c840e-c840f pfn range: 1 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on c840e->c840f
    > [ =A0 =A00.000000] Freeing =A0c8411-c8414 pfn range: 3 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on c8411->c8414
    > [ =A0 =A00.000000] Freeing =A0c841e-c8428 pfn range: 10 pages freed > [ =A0 =A00.000000] 1-1 mapping on c841e->c8428
    > [ =A0 =A00.000000] Freeing =A0c8432-c8436 pfn range: 4 pages freed
    > [ =A0 =A00.000000] 1-1 mapping on c8432->c8436
    > [ =A0 =A00.000000] Freeing =A0cac00-100000 pfn range: 218112 pages fre= ed
    > [ =A0 =A00.000000] 1-1 mapping on cac00->100000
    > [ =A0 =A00.000000] Released 219612 pages of unused memory
    > [ =A0 =A00.000000] Set 219612 page(s) to 1-1 mapping
    > [ =A0 =A00.000000] BIOS-provided physical RAM map:
    > [ =A0 =A00.000000] =A0Xen: 0000000000000000 - 000000000009a000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 000000000009a800 - 0000000000100000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 0000000000100000 - 0000000007eea000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 0000000007eea000 - 0000000007f67000 (ACPI N= VS)
    > [ =A0 =A00.000000] =A0Xen: 0000000007f67000 - 0000000007f70000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 0000000007f70000 - 0000000007f76000 (ACPI N= VS)
    > [ =A0 =A00.000000] =A0Xen: 0000000007f76000 - 0000000007f78000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 0000000007f78000 - 0000000008000000 (ACPI N= VS)
    > [ =A0 =A00.000000] =A0Xen: 0000000008000000 - 000000000dffd000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 000000000dffd000 - 000000000e000000 (ACPI d= ata)
    > [ =A0 =A00.000000] =A0Xen: 000000000e000000 - 0000000020000000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 0000000020000000 - 0000000020200000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 0000000020200000 - 0000000040000000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 0000000040000000 - 0000000040200000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 0000000040200000 - 00000000c83b4000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000c83b4000 - 00000000c840a000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000c840a000 - 00000000c840e000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000c840e000 - 00000000c840f000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000c840f000 - 00000000c8411000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000c8411000 - 00000000c8414000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000c8414000 - 00000000c841e000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000c841e000 - 00000000c8428000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000c8428000 - 00000000c8432000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000c8432000 - 00000000c8436000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000c8436000 - 00000000cac00000 (usable= )
    > [ =A0 =A00.000000] =A0Xen: 00000000cb800000 - 00000000cfa00000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000fec00000 - 00000000fec01000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000fed1c000 - 00000000fed20000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000fee00000 - 00000000fee01000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 00000000ffc00000 - 00000000ffc20000 (reserv= ed)
    > [ =A0 =A00.000000] =A0Xen: 0000000100000000 - 000000042e000000 (usable= )
    > [ =A0 =A00.000000] NX (Execute Disable) protection: active
    > [ =A0 =A00.000000] DMI 2.6 present.
    > [ =A0 =A00.000000] DMI: Dell Inc. Latitude E6420/0K0DNP, BIOS A13 05/1= 7/2012
    > [ =A0 =A00.000000] e820 update range: 0000000000000000 - 0000000000010= 000 (usable) =3D=3D> (reserved)
    > [ =A0 =A00.000000] e820 remove range: 00000000000a0000 - 0000000000100= 000 (usable)
    > [ =A0 =A00.000000] No AGP bridge found
    > [ =A0 =A00.000000] last_pfn =3D 0x42e000 max_arch_pfn =3D 0x400000000<= br> > [ =A0 =A00.000000] x2apic enabled by BIOS, switching to x2apic ops
    > [ =A0 =A00.000000] last_pfn =3D 0xcac00 max_arch_pfn =3D 0x400000000 > [ =A0 =A00.000000] found SMP MP-table at [ffff8800000f1ad0] f1ad0
    > [ =A0 =A00.000000] initial memory mapped : 0 - 04ade000
    > [ =A0 =A00.000000] Base memory trampoline at [ffff880000095000] 95000 = size 20480
    > [ =A0 =A00.000000] init_memory_mapping: 0000000000000000-00000000cac00= 000
    > [ =A0 =A00.000000] =A00000000000 - 00cac00000 page 4k
    > [ =A0 =A00.000000] kernel direct mapping tables up to 0xcabfffff @ [me= m 0x009a5000-0x00ffffff]
    > [ =A0 =A00.000000] xen: setting RW the range fc4000 - 1000000
    > [ =A0 =A00.000000] init_memory_mapping: 0000000100000000-000000042e000= 000
    > [ =A0 =A00.000000] =A00100000000 - 042e000000 page 4k
    > [ =A0 =A00.000000] kernel direct mapping tables up to 0x42dffffff @ [m= em 0xc9282000-0xcabfffff]
    > [ =A0 =A00.000000] xen: setting RW the range cabff000 - cac00000
    > [ =A0 =A00.000000] RAMDISK: 01e13000 - 04ade000
    > [ =A0 =A00.000000] ACPI: RSDP 00000000000fe300 00024 (v02 DELL =A0) > [ =A0 =A00.000000] ACPI: XSDT 000000000dffee18 0007C (v01 DELL =A0 =A0= CBX3 =A0 =A006222004 MSFT 00010013)
    > [ =A0 =A00.000000] ACPI: FACP 0000000007f90d98 000F4 (v04 DELL =A0 =A0= CBX3 =A0 =A006222004 MSFT 00010013)
    > [ =A0 =A00.000000] ACPI Warning: 32/64 FACS address mismatch in FADT -= two FACS tables! (20120320/tbfadt-378)
    > [ =A0 =A00.000000] ACPI Warning: 32/64X FACS address mismatch in FADT = - 0x07FEDE40/0x0000000007FEDD40, using 32 (20120320/tbfadt-502)
    > [ =A0 =A00.000000] ACPI: DSDT 0000000007f5e018 08834 (v02 INT430 SYSFe= xxx 00001001 INTL 20090903)
    > [ =A0 =A00.000000] ACPI: FACS 0000000007fede40 00040
    > [ =A0 =A00.000000] ACPI: APIC 000000000dffdf18 000CC (v02 DELL =A0 =A0= CBX3 =A0 =A006222004 MSFT 00010013)
    > [ =A0 =A00.000000] ACPI: TCPA 0000000007feed18 00032 (v02 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 00000000 =A0 =A0 =A000000000)
    > [ =A0 =A00.000000] ACPI: SSDT 0000000007f91a98 002F9 (v01 DELLTP =A0 = =A0 =A0TPM 00003000 INTL 20090903)
    > [ =A0 =A00.000000] ACPI: MCFG 0000000007feec98 0003C (v01 DELL =A0 SND= YBRDG 06222004 MSFT 00000097)
    > [ =A0 =A00.000000] ACPI: HPET 0000000007feec18 00038 (v01 A M I =A0 PC= HHPET 06222004 AMI. 00000003)
    > [ =A0 =A00.000000] ACPI: BOOT 0000000007feeb98 00028 (v01 DELL =A0 CBX= 3 =A0 =A0 06222004 AMI =A000010013)
    > [ =A0 =A00.000000] ACPI: SSDT 0000000007f75018 00804 (v01 =A0PmRef =A0= Cpu0Ist 00003000 INTL 20090903)
    > [ =A0 =A00.000000] ACPI: SSDT 0000000007f74018 00996 (v01 =A0PmRef =A0= =A0CpuPm 00003000 INTL 20090903)
    > [ =A0 =A00.000000] ACPI: XMAR 0000000007f90c18 000E8 (v01 INTEL =A0 = =A0 =A0SNB =A000000001 INTL 00000001)
    > [ =A0 =A00.000000] ACPI: SLIC 0000000007f7ec18 00176 (v03 DELL =A0 =A0= CBX3 =A0 =A006222004 MSFT 00010013)
    > [ =A0 =A00.000000] ACPI: Local APIC address 0xfee00000
    > [ =A0 =A00.000000] Setting APIC routing to cluster x2apic.
    > [ =A0 =A00.000000] Zone PFN ranges:
    > [ =A0 =A00.000000] =A0 DMA =A0 =A0 =A00x00000010 -> 0x00001000
    > [ =A0 =A00.000000] =A0 DMA32 =A0 =A00x00001000 -> 0x00100000
    > [ =A0 =A00.000000] =A0 Normal =A0 0x00100000 -> 0x0042e000
    > [ =A0 =A00.000000] Movable zone start PFN for each node
    > [ =A0 =A00.000000] Early memory PFN ranges
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00000010 -> 0x0000009a
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00000100 -> 0x00007eea
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00007f67 -> 0x00007f70
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00007f76 -> 0x00007f78
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00008000 -> 0x0000dffd
    > [ =A0 =A00.000000] =A0 =A0 0: 0x0000e000 -> 0x00020000
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00020200 -> 0x00040000
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00040200 -> 0x000c83b4
    > [ =A0 =A00.000000] =A0 =A0 0: 0x000c840a -> 0x000c840e
    > [ =A0 =A00.000000] =A0 =A0 0: 0x000c840f -> 0x000c8411
    > [ =A0 =A00.000000] =A0 =A0 0: 0x000c8414 -> 0x000c841e
    > [ =A0 =A00.000000] =A0 =A0 0: 0x000c8428 -> 0x000c8432
    > [ =A0 =A00.000000] =A0 =A0 0: 0x000c8436 -> 0x000cac00
    > [ =A0 =A00.000000] =A0 =A0 0: 0x00100000 -> 0x0042e000
    > [ =A0 =A00.000000] On node 0 totalpages: 4163092
    > [ =A0 =A00.000000] =A0 DMA zone: 56 pages used for memmap
    > [ =A0 =A00.000000] =A0 DMA zone: 1572 pages reserved
    > [ =A0 =A00.000000] =A0 DMA zone: 2350 pages, LIFO batch:0
    > [ =A0 =A00.000000] =A0 DMA32 zone: 14280 pages used for memmap
    > [ =A0 =A00.000000] =A0 DMA32 zone: 810690 pages, LIFO batch:31
    > [ =A0 =A00.000000] =A0 Normal zone: 45584 pages used for memmap
    > [ =A0 =A00.000000] =A0 Normal zone: 3288560 pages, LIFO batch:31
    > [ =A0 =A00.000000] ACPI: PM-Timer IO Port: 0x408
    > [ =A0 =A00.000000] ACPI: Local APIC address 0xfee00000
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x01] lapic_id[0x00] enabled)<= br> > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x02] lapic_id[0x02] enabled)<= br> > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x03] lapic_id[0x01] enabled)<= br> > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x04] lapic_id[0x03] enabled)<= br> > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x05] lapic_id[0x04] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x06] lapic_id[0x05] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x07] lapic_id[0x06] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x08] lapic_id[0x07] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x09] lapic_id[0x08] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0a] lapic_id[0x09] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0b] lapic_id[0x0a] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0c] lapic_id[0x0b] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0d] lapic_id[0x0c] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0e] lapic_id[0x0d] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x0f] lapic_id[0x0e] disabled)=
    > [ =A0 =A00.000000] ACPI: LAPIC (acpi_id[0x10] lapic_id[0x0f] disabled)=
    > [ =A0 =A00.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base= [0])
    > [ =A0 =A00.000000] IOAPIC[0]: apic_id 2, version 253, address 0xfec000= 00, GSI 0-253
    > [ =A0 =A00.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 0 global_irq 2 dfl= dfl)
    > [ =A0 =A00.000000] ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 hig= h level)
    > [ =A0 =A00.000000] ACPI: IRQ0 used by override.
    > [ =A0 =A00.000000] ACPI: IRQ2 used by override.
    > [ =A0 =A00.000000] ACPI: IRQ9 used by override.
    > [ =A0 =A00.000000] Using ACPI (MADT) for SMP configuration information=
    > [ =A0 =A00.000000] ACPI: HPET id: 0x8086a701 base: 0xfed00000
    > [ =A0 =A00.000000] SMP: Allowing 16 CPUs, 12 hotplug CPUs
    > [ =A0 =A00.000000] nr_irqs_gsi: 270
    > [ =A0 =A00.000000] Allocating PCI resources starting at cfa00000 (gap:= cfa00000:2f200000)
    > [ =A0 =A00.000000] Booting paravirtualized kernel on Xen
    > [ =A0 =A00.000000] Xen version: 4.1.3 (preserve-AD)
    > [ =A0 =A00.000000] setup_percpu: NR_CPUS:512 nr_cpumask_bits:512 nr_cp= u_ids:16 nr_node_ids:1
    > [ =A0 =A00.000000] PERCPU: Embedded 28 pages/cpu @ffff8803e2800000 s82= 176 r8192 d24320 u131072
    > [ =A0 =A00.000000] pcpu-alloc: s82176 r8192 d24320 u131072 alloc=3D1*2= 097152
    > [ =A0 =A00.000000] pcpu-alloc: [0] 00 01 02 03 04 05 06 07 08 09 10 11= 12 13 14 15
    > [ =A0 =A04.119805] Built 1 zonelists in Zone order, mobility grouping = on. =A0Total pages: 4101600
    > [ =A0 =A04.119809] Kernel command line: ro root=3D/dev/mapper/vg_dom0-= lv_root rd_LUKS_UUID=3Dluks-400336fa-c7c4-4be3-a244-c909aa16a18c rd_LVM_LV= =3Dvg_dom0/lv_root rd_LVM_LV=3Dvg_dom0/lv_swap rd_NO_MD rd_NO_DM LANG=3Den_= US.UTF-8 SYSFONT=3Dlatarcyrheb-sun16 KEYTABLE=3Dpl2 rhgb quiet max_loop=3D2= 55
    > [ =A0 =A04.119915] PID hash table entries: 4096 (order: 3, 32768 bytes= )
    > [ =A0 =A04.120928] Dentry cache hash table entries: 2097152 (order: 12= , 16777216 bytes)
    > [ =A0 =A04.124018] Inode-cache hash table entries: 1048576 (order: 11,= 8388608 bytes)
    > [ =A0 =A04.147064] Placing 64MB software IO TLB between ffff8803ce2000= 00 - ffff8803d2200000
    > [ =A0 =A04.147066] software IO TLB at phys 0x3ce200000 - 0x3d2200000 > [ =A0 =A04.181675] Memory: 14975940k/17530880k available (4557k kernel= code, 878512k absent, 1676428k reserved, 4112k data, 552k init)
    > [ =A0 =A04.181730] Hierarchical RCU implementation.
    > [ =A0 =A04.181731] =A0 =A0 =A0 =A0RCU dyntick-idle grace-period accele= ration is enabled.
    > [ =A0 =A04.181738] NR_IRQS:33024 nr_irqs:1024 16
    > [ =A0 =A04.181799] xen: sci override: global_irq=3D9 trigger=3D0 polar= ity=3D0
    > [ =A0 =A04.181801] xen: registering gsi 9 triggering 0 polarity 0
    > [ =A0 =A04.181809] xen: --> pirq=3D9 -> irq=3D9 (gsi=3D9)
    > [ =A0 =A04.181829] xen: acpi sci 9
    > [ =A0 =A04.181831] xen: --> pirq=3D1 -> irq=3D1 (gsi=3D1)
    > [ =A0 =A04.181834] xen: --> pirq=3D2 -> irq=3D2 (gsi=3D2)
    > [ =A0 =A04.181836] xen: --> pirq=3D3 -> irq=3D3 (gsi=3D3)
    > [ =A0 =A04.181838] xen: --> pirq=3D4 -> irq=3D4 (gsi=3D4)
    > [ =A0 =A04.181840] xen: --> pirq=3D5 -> irq=3D5 (gsi=3D5)
    > [ =A0 =A04.181843] xen: --> pirq=3D6 -> irq=3D6 (gsi=3D6)
    > [ =A0 =A04.181845] xen: --> pirq=3D7 -> irq=3D7 (gsi=3D7)
    > [ =A0 =A04.181847] xen: --> pirq=3D8 -> irq=3D8 (gsi=3D8)
    > [ =A0 =A04.181849] xen: --> pirq=3D10 -> irq=3D10 (gsi=3D10)
    > [ =A0 =A04.181851] xen: --> pirq=3D11 -> irq=3D11 (gsi=3D11)
    > [ =A0 =A04.181854] xen: --> pirq=3D12 -> irq=3D12 (gsi=3D12)
    > [ =A0 =A04.181856] xen: --> pirq=3D13 -> irq=3D13 (gsi=3D13)
    > [ =A0 =A04.181858] xen: --> pirq=3D14 -> irq=3D14 (gsi=3D14)
    > [ =A0 =A04.181860] xen: --> pirq=3D15 -> irq=3D15 (gsi=3D15)
    > [ =A0 =A04.182986] Console: colour VGA+ 80x25
    > [ =A0 =A04.183012] console [tty0] enabled
    > [ =A0 =A04.183026] Xen: using vcpuop timer interface
    > [ =A0 =A04.183030] installing Xen timer for CPU 0
    > [ =A0 =A04.183048] Detected 2494.416 MHz processor.
    > [ =A0 =A04.183052] Calibrating delay loop (skipped), value calculated = using timer frequency.. 4988.83 BogoMIPS (lpj=3D9977664)
    > [ =A0 =A04.183054] pid_max: default: 32768 minimum: 301
    > [ =A0 =A04.183090] Mount-cache hash table entries: 256
    > [ =A0 =A04.183222] Initializing cgroup subsys cpuacct
    > [ =A0 =A04.183224] Initializing cgroup subsys devices
    > [ =A0 =A04.183225] Initializing cgroup subsys freezer
    > [ =A0 =A04.183227] Initializing cgroup subsys net_cls
    > [ =A0 =A04.183228] Initializing cgroup subsys blkio
    > [ =A0 =A04.183280] ENERGY_PERF_BIAS: Set to 'normal', was '= ;performance'
    > [ =A0 =A04.183281] ENERGY_PERF_BIAS: View and update with x86_energy_p= erf_policy(8)
    > [ =A0 =A04.183284] CPU: Physical Processor ID: 0
    > [ =A0 =A04.183285] CPU: Processor Core ID: 0
    > [ =A0 =A04.184454] ACPI: Core revision 20120320
    > [ =A0 =A04.194658] Performance Events: unsupported p6 CPU model 42 no = PMU driver, software events only.
    > [ =A0 =A04.194796] installing Xen timer for CPU 1
    > [ =A0 =A04.194988] installing Xen timer for CPU 2
    > [ =A0 =A04.195140] installing Xen timer for CPU 3
    > [ =A0 =A04.195232] Brought up 4 CPUs
    > [ =A0 =A04.195477] devtmpfs: initialized
    > [ =A0 =A04.199046] PM: Registering ACPI NVS region [mem 0x07eea000-0x0= 7f66fff] (512000 bytes)
    > [ =A0 =A04.199056] PM: Registering ACPI NVS region [mem 0x07f70000-0x0= 7f75fff] (24576 bytes)
    > [ =A0 =A04.199058] PM: Registering ACPI NVS region [mem 0x07f78000-0x0= 7ffffff] (557056 bytes)
    > [ =A0 =A04.199069] Dell Latitude E6420 series board detected. Selectin= g PCI-method for reboots.
    > [ =A0 =A04.199104] Grant tables using version 2 layout.
    > [ =A0 =A04.199114] Grant table initialized
    > [ =A0 =A04.199158] dummy:
    > [ =A0 =A04.199205] RTC time: =A01:19:35, date: 11/29/12
    > [ =A0 =A04.199256] NET: Registered protocol family 16
    > [ =A0 =A04.199465] ACPI FADT declares the system doesn't support P= CIe ASPM, so disable it
    > [ =A0 =A04.199467] ACPI: bus type pci registered
    > [ =A0 =A04.199548] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem 0= xf8000000-0xfbffffff] (base 0xf8000000)
    > [ =A0 =A04.199550] PCI: not using MMCONFIG
    > [ =A0 =A04.199552] PCI: Using configuration type 1 for base access
    > [ =A0 =A04.199559] dmi type 0xB1 record - unknown flag
    > [ =A0 =A04.200155] bio: create slab <bio-0> at 0
    > [ =A0 =A04.200279] ACPI: Added _OSI(Module Device)
    > [ =A0 =A04.200280] ACPI: Added _OSI(Processor Device)
    > [ =A0 =A04.200282] ACPI: Added _OSI(3.0 _SCP Extensions)
    > [ =A0 =A04.200283] ACPI: Added _OSI(Processor Aggregator Device)
    > [ =A0 =A04.201815] ACPI: EC: Look up EC in DSDT
    > [ =A0 =A04.206932] [Firmware Bug]: ACPI: BIOS _OSI(Linux) query ignore= d
    > [ =A0 =A04.219266] ACPI: SSDT 00000000c8412798 00727 (v01 =A0PmRef =A0= Cpu0Cst 00003001 INTL 20090903)
    > [ =A0 =A04.219654] ACPI: Dynamic OEM Table Load:
    > [ =A0 =A04.219657] ACPI: SSDT =A0 =A0 =A0 =A0 =A0 (null) 00727 (v01 = =A0PmRef =A0Cpu0Cst 00003001 INTL 20090903)
    > [ =A0 =A04.220118] ACPI: SSDT 00000000c8413a98 00303 (v01 =A0PmRef =A0= =A0ApIst 00003000 INTL 20090903)
    > [ =A0 =A04.220555] ACPI: Dynamic OEM Table Load:
    > [ =A0 =A04.220558] ACPI: SSDT =A0 =A0 =A0 =A0 =A0 (null) 00303 (v01 = =A0PmRef =A0 =A0ApIst 00003000 INTL 20090903)
    > [ =A0 =A04.220754] ACPI: SSDT 00000000c8411d98 00119 (v01 =A0PmRef =A0= =A0ApCst 00003000 INTL 20090903)
    > [ =A0 =A04.221136] ACPI: Dynamic OEM Table Load:
    > [ =A0 =A04.221138] ACPI: SSDT =A0 =A0 =A0 =A0 =A0 (null) 00119 (v01 = =A0PmRef =A0 =A0ApCst 00003000 INTL 20090903)
    > [ =A0 =A04.223275] ACPI: Interpreter enabled
    > [ =A0 =A04.223278] ACPI: (supports S0 S3 S5)
    > [ =A0 =A04.223294] ACPI: Using IOAPIC for interrupt routing
    > [ =A0 =A04.223322] PCI: MMCONFIG for domain 0000 [bus 00-3f] at [mem 0= xf8000000-0xfbffffff] (base 0xf8000000)
    > [ =A0 =A04.223846] PCI: MMCONFIG at [mem 0xf8000000-0xfbffffff] reserv= ed in ACPI motherboard resources
    > [ =A0 =A04.271283] ACPI: EC: GPE =3D 0x10, I/O: command/status =3D 0x9= 34, data =3D 0x930
    > [ =A0 =A04.272424] ACPI: No dock devices found.
    > [ =A0 =A04.272428] PCI: Using host bridge windows from ACPI; if necess= ary, use "pci=3Dnocrs" and report a bug
    > [ =A0 =A04.272988] \_SB_.PCI0:_OSC invalid UUID
    > [ =A0 =A04.272989] _OSC request data:1 8 1f
    > [ =A0 =A04.272992] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-3= e])
    > [ =A0 =A04.273994] pci_root PNP0A08:00: host bridge window [io =A00x00= 00-0x0cf7]
    > [ =A0 =A04.273996] pci_root PNP0A08:00: host bridge window [io =A00x0d= 00-0xffff]
    > [ =A0 =A04.273998] pci_root PNP0A08:00: host bridge window [mem 0x000a= 0000-0x000bffff]
    > [ =A0 =A04.274001] pci_root PNP0A08:00: host bridge window [mem 0xcfa0= 0000-0xfeafffff]
    > [ =A0 =A04.274003] pci_root PNP0A08:00: host bridge window [mem 0xfed4= 0000-0xfed44fff]
    > [ =A0 =A04.274031] PCI host bridge to bus 0000:00
    > [ =A0 =A04.274033] pci_bus 0000:00: root bus resource [io =A00x0000-0x= 0cf7]
    > [ =A0 =A04.274034] pci_bus 0000:00: root bus resource [io =A00x0d00-0x= ffff]
    > [ =A0 =A04.274036] pci_bus 0000:00: root bus resource [mem 0x000a0000-= 0x000bffff]
    > [ =A0 =A04.274038] pci_bus 0000:00: root bus resource [mem 0xcfa00000-= 0xfeafffff]
    > [ =A0 =A04.274040] pci_bus 0000:00: root bus resource [mem 0xfed40000-= 0xfed44fff]
    > [ =A0 =A04.274054] pci 0000:00:00.0: [8086:0104] type 00 class 0x06000= 0
    > [ =A0 =A04.274147] pci 0000:00:02.0: [8086:0126] type 00 class 0x03000= 0
    > [ =A0 =A04.274174] pci 0000:00:02.0: reg 10: [mem 0xe1400000-0xe17ffff= f 64bit]
    > [ =A0 =A04.274189] pci 0000:00:02.0: reg 18: [mem 0xd0000000-0xdffffff= f 64bit pref]
    > [ =A0 =A04.274200] pci 0000:00:02.0: reg 20: [io =A00x4000-0x403f]
    > [ =A0 =A04.274344] pci 0000:00:16.0: [8086:1c3a] type 00 class 0x07800= 0
    > [ =A0 =A04.274394] pci 0000:00:16.0: reg 10: [mem 0xe2eb0000-0xe2eb000= f 64bit]
    > [ =A0 =A04.274563] pci 0000:00:16.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.274636] pci 0000:00:19.0: [8086:1502] type 00 class 0x02000= 0
    > [ =A0 =A04.274681] pci 0000:00:19.0: reg 10: [mem 0xe2e00000-0xe2e1fff= f]
    > [ =A0 =A04.274700] pci 0000:00:19.0: reg 14: [mem 0xe2e80000-0xe2e80ff= f]
    > [ =A0 =A04.274719] pci 0000:00:19.0: reg 18: [io =A00x4080-0x409f]
    > [ =A0 =A04.274883] pci 0000:00:19.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.274939] pci 0000:00:1a.0: [8086:1c2d] type 00 class 0x0c032= 0
    > [ =A0 =A04.274983] pci 0000:00:1a.0: reg 10: [mem 0xe2e70000-0xe2e703f= f]
    > [ =A0 =A04.275185] pci 0000:00:1a.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.275243] pci 0000:00:1b.0: [8086:1c20] type 00 class 0x04030= 0
    > [ =A0 =A04.275278] pci 0000:00:1b.0: reg 10: [mem 0xe2e60000-0xe2e63ff= f 64bit]
    > [ =A0 =A04.275456] pci 0000:00:1b.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.275509] pci 0000:00:1c.0: [8086:1c10] type 01 class 0x06040= 0
    > [ =A0 =A04.275702] pci 0000:00:1c.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.275760] pci 0000:00:1c.1: [8086:1c12] type 01 class 0x06040= 0
    > [ =A0 =A04.275953] pci 0000:00:1c.1: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.276011] pci 0000:00:1c.2: [8086:1c14] type 01 class 0x06040= 0
    > [ =A0 =A04.276205] pci 0000:00:1c.2: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.276264] pci 0000:00:1c.3: [8086:1c16] type 01 class 0x06040= 0
    > [ =A0 =A04.276458] pci 0000:00:1c.3: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.276520] pci 0000:00:1c.5: [8086:1c1a] type 01 class 0x06040= 0
    > [ =A0 =A04.276711] pci 0000:00:1c.5: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.276779] pci 0000:00:1d.0: [8086:1c26] type 00 class 0x0c032= 0
    > [ =A0 =A04.276823] pci 0000:00:1d.0: reg 10: [mem 0xe2e50000-0xe2e503f= f]
    > [ =A0 =A04.277025] pci 0000:00:1d.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.277086] pci 0000:00:1f.0: [8086:1c4f] type 00 class 0x06010= 0
    > [ =A0 =A04.277341] pci 0000:00:1f.2: [8086:1c03] type 00 class 0x01060= 1
    > [ =A0 =A04.277391] pci 0000:00:1f.2: reg 10: [io =A00x40d0-0x40d7]
    > [ =A0 =A04.277410] pci 0000:00:1f.2: reg 14: [io =A00x40c0-0x40c3]
    > [ =A0 =A04.277429] pci 0000:00:1f.2: reg 18: [io =A00x40b0-0x40b7]
    > [ =A0 =A04.277449] pci 0000:00:1f.2: reg 1c: [io =A00x40a0-0x40a3]
    > [ =A0 =A04.277468] pci 0000:00:1f.2: reg 20: [io =A00x4060-0x407f]
    > [ =A0 =A04.277486] pci 0000:00:1f.2: reg 24: [mem 0xe2e40000-0xe2e407f= f]
    > [ =A0 =A04.277613] pci 0000:00:1f.2: PME# supported from D3hot
    > [ =A0 =A04.277657] pci 0000:00:1f.3: [8086:1c22] type 00 class 0x0c050= 0
    > [ =A0 =A04.277694] pci 0000:00:1f.3: reg 10: [mem 0xe2e30000-0xe2e300f= f 64bit]
    > [ =A0 =A04.277749] pci 0000:00:1f.3: reg 20: [io =A00x4040-0x405f]
    > [ =A0 =A04.277920] pci 0000:00:1c.0: PCI bridge to [bus 01-01]
    > [ =A0 =A04.278353] pci 0000:02:00.0: [8086:422b] type 00 class 0x02800= 0
    > [ =A0 =A04.278708] pci 0000:02:00.0: reg 10: [mem 0xe2d00000-0xe2d01ff= f 64bit]
    > [ =A0 =A04.280508] pci 0000:02:00.0: PME# supported from D0 D3hot D3co= ld
    > [ =A0 =A04.285361] pci 0000:00:1c.1: PCI bridge to [bus 02-02]
    > [ =A0 =A04.285374] pci 0000:00:1c.1: =A0 bridge window [mem 0xe2d00000= -0xe2dfffff]
    > [ =A0 =A04.285490] pci 0000:00:1c.2: PCI bridge to [bus 03-08]
    > [ =A0 =A04.285498] pci 0000:00:1c.2: =A0 bridge window [io =A00x3000-0= x3fff]
    > [ =A0 =A04.285505] pci 0000:00:1c.2: =A0 bridge window [mem 0xe2200000= -0xe2bfffff]
    > [ =A0 =A04.285517] pci 0000:00:1c.2: =A0 bridge window [mem 0xe0a00000= -0xe13fffff 64bit pref]
    > [ =A0 =A04.285625] pci 0000:00:1c.3: PCI bridge to [bus 09-09]
    > [ =A0 =A04.285632] pci 0000:00:1c.3: =A0 bridge window [io =A00x2000-0= x2fff]
    > [ =A0 =A04.285639] pci 0000:00:1c.3: =A0 bridge window [mem 0xe1800000= -0xe21fffff]
    > [ =A0 =A04.285651] pci 0000:00:1c.3: =A0 bridge window [mem 0xe0000000= -0xe09fffff 64bit pref]
    > [ =A0 =A04.285818] pci 0000:0a:00.0: [1217:8221] type 00 class 0x08050= 1
    > [ =A0 =A04.285872] pci 0000:0a:00.0: reg 10: [mem 0xe2c20000-0xe2c201f= f]
    > [ =A0 =A04.286294] pci 0000:0a:00.0: supports D1 D2
    > [ =A0 =A04.286295] pci 0000:0a:00.0: PME# supported from D0 D1 D2 D3ho= t D3cold
    > [ =A0 =A04.286432] pci 0000:0a:00.1: [1217:8231] type 00 class 0x01800= 0
    > [ =A0 =A04.286486] pci 0000:0a:00.1: reg 10: [mem 0xe2c10000-0xe2c10ff= f]
    > [ =A0 =A04.286563] pci 0000:0a:00.1: reg 18: [mem 0xe2c00000-0xe2c007f= f]
    > [ =A0 =A04.286908] pci 0000:0a:00.1: supports D1 D2
    > [ =A0 =A04.286909] pci 0000:0a:00.1: PME# supported from D0 D1 D2 D3ho= t D3cold
    > [ =A0 =A04.293400] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a]
    > [ =A0 =A04.293412] pci 0000:00:1c.5: =A0 bridge window [mem 0xe2c00000= -0xe2cfffff]
    > [ =A0 =A04.293479] pci_bus 0000:00: on NUMA node 0
    > [ =A0 =A04.293483] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0._PRT]=
    > [ =A0 =A04.293612] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP01.= _PRT]
    > [ =A0 =A04.293647] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP02.= _PRT]
    > [ =A0 =A04.293682] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP04.= _PRT]
    > [ =A0 =A04.293717] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP06.= _PRT]
    > [ =A0 =A04.293762] ACPI: PCI Interrupt Routing Table [\_SB_.PCI0.RP03.= _PRT]
    > [ =A0 =A04.293857] \_SB_.PCI0:_OSC invalid UUID
    > [ =A0 =A04.293858] _OSC request data:1 1f 1f
    > [ =A0 =A04.293861] =A0pci0000:00: Requesting ACPI _OSC control (0x1d)<= br> > [ =A0 =A04.293906] \_SB_.PCI0:_OSC invalid UUID
    > [ =A0 =A04.293907] _OSC request data:1 0 1d
    > [ =A0 =A04.293910] =A0pci0000:00: ACPI _OSC request failed (AE_ERROR),= returned control mask: 0x1d
    > [ =A0 =A04.293911] ACPI _OSC control for PCIe not granted, disabling A= SPM
    > [ =A0 =A04.297639] ACPI: PCI Interrupt Link [LNKA] (IRQs 1 3 4 5 6 7 1= 0 12 14 15) *11
    > [ =A0 =A04.297702] ACPI: PCI Interrupt Link [LNKB] (IRQs 1 3 4 5 6 7 1= 1 12 14 15) *10
    > [ =A0 =A04.297761] ACPI: PCI Interrupt Link [LNKC] (IRQs 1 3 4 5 6 7 1= 0 12 14 15) *11
    > [ =A0 =A04.297820] ACPI: PCI Interrupt Link [LNKD] (IRQs 1 3 4 5 6 7 1= 1 12 14 15) *10
    > [ =A0 =A04.297878] ACPI: PCI Interrupt Link [LNKE] (IRQs 1 3 4 *5 6 7 = 10 12 14 15)
    > [ =A0 =A04.297937] ACPI: PCI Interrupt Link [LNKF] (IRQs 1 3 4 5 6 7 1= 1 12 14 15) *0, disabled.
    > [ =A0 =A04.297996] ACPI: PCI Interrupt Link [LNKG] (IRQs 1 *3 4 5 6 7 = 10 12 14 15)
    > [ =A0 =A04.298054] ACPI: PCI Interrupt Link [LNKH] (IRQs 1 3 4 5 6 7 1= 1 12 14 15) *0, disabled.
    > [ =A0 =A04.298087] xen/balloon: Initialising balloon driver.
    > [ =A0 =A04.301022] xen-balloon: Initialising balloon driver.
    > [ =A0 =A04.301062] xen/balloon: Xen selfballooning driver disabled for= domain0.
    > [ =A0 =A04.301148] vgaarb: device added: PCI:0000:00:02.0,decodes=3Dio= +mem,owns=3Dio+mem,locks=3Dnone
    > [ =A0 =A04.301157] vgaarb: loaded
    > [ =A0 =A04.301157] vgaarb: bridge control possible 0000:00:02.0
    > [ =A0 =A04.301279] PCI: Using ACPI for IRQ routing
    > [ =A0 =A04.305930] PCI: pci_cache_line_size set to 64 bytes
    > [ =A0 =A04.306106] reserve RAM buffer: 000000000009a000 - 000000000009= ffff
    > [ =A0 =A04.306108] reserve RAM buffer: 0000000007eea000 - 0000000007ff= ffff
    > [ =A0 =A04.306110] reserve RAM buffer: 0000000007f70000 - 0000000007ff= ffff
    > [ =A0 =A04.306112] reserve RAM buffer: 0000000007f78000 - 0000000007ff= ffff
    > [ =A0 =A04.306113] reserve RAM buffer: 000000000dffd000 - 000000000fff= ffff
    > [ =A0 =A04.306115] reserve RAM buffer: 00000000c83b4000 - 00000000cbff= ffff
    > [ =A0 =A04.306118] reserve RAM buffer: 00000000c840e000 - 00000000cbff= ffff
    > [ =A0 =A04.306121] reserve RAM buffer: 00000000c8411000 - 00000000cbff= ffff
    > [ =A0 =A04.306123] reserve RAM buffer: 00000000c841e000 - 00000000cbff= ffff
    > [ =A0 =A04.306125] reserve RAM buffer: 00000000c8432000 - 00000000cbff= ffff
    > [ =A0 =A04.306127] reserve RAM buffer: 00000000cac00000 - 00000000cbff= ffff
    > [ =A0 =A04.306129] reserve RAM buffer: 000000042e000000 - 000000042fff= ffff
    > [ =A0 =A04.306235] Switching to clocksource xen
    > [ =A0 =A04.307726] pnp: PnP ACPI init
    > [ =A0 =A04.307738] ACPI: bus type pnp registered
    > [ =A0 =A04.308287] pnp 00:00: [bus 00-3e]
    > [ =A0 =A04.308289] pnp 00:00: [io =A00x0000-0x0cf7 window]
    > [ =A0 =A04.308291] pnp 00:00: [io =A00x0cf8-0x0cff]
    > [ =A0 =A04.308293] pnp 00:00: [io =A00x0d00-0xffff window]
    > [ =A0 =A04.308295] pnp 00:00: [mem 0x000a0000-0x000bffff window]
    > [ =A0 =A04.308296] pnp 00:00: [mem 0x000c0000-0x000c3fff window]
    > [ =A0 =A04.308298] pnp 00:00: [mem 0x000c4000-0x000c7fff window]
    > [ =A0 =A04.308300] pnp 00:00: [mem 0x000c8000-0x000cbfff window]
    > [ =A0 =A04.308301] pnp 00:00: [mem 0x000cc000-0x000cffff window]
    > [ =A0 =A04.308303] pnp 00:00: [mem 0x000d0000-0x000d3fff window]
    > [ =A0 =A04.308305] pnp 00:00: [mem 0x000d4000-0x000d7fff window]
    > [ =A0 =A04.308307] pnp 00:00: [mem 0x000d8000-0x000dbfff window]
    > [ =A0 =A04.308309] pnp 00:00: [mem 0x000dc000-0x000dffff window]
    > [ =A0 =A04.308310] pnp 00:00: [mem 0x000e0000-0x000e3fff window]
    > [ =A0 =A04.308312] pnp 00:00: [mem 0x000e4000-0x000e7fff window]
    > [ =A0 =A04.308314] pnp 00:00: [mem 0x000e8000-0x000ebfff window]
    > [ =A0 =A04.308315] pnp 00:00: [mem 0x000ec000-0x000effff window]
    > [ =A0 =A04.308317] pnp 00:00: [mem 0x000f0000-0x000fffff window]
    > [ =A0 =A04.308319] pnp 00:00: [mem 0xcfa00000-0xfeafffff window]
    > [ =A0 =A04.308320] pnp 00:00: [mem 0xfed40000-0xfed44fff window]
    > [ =A0 =A04.308385] pnp 00:00: Plug and Play ACPI device, IDs PNP0a08 P= NP0a03 (active)
    > [ =A0 =A04.308398] pnp 00:01: [io =A00x0000-0x001f]
    > [ =A0 =A04.308400] pnp 00:01: [io =A00x0081-0x0091]
    > [ =A0 =A04.308401] pnp 00:01: [io =A00x0093-0x009f]
    > [ =A0 =A04.308403] pnp 00:01: [io =A00x00c0-0x00df]
    > [ =A0 =A04.308404] pnp 00:01: [dma 4]
    > [ =A0 =A04.308422] pnp 00:01: Plug and Play ACPI device, IDs PNP0200 (= active)
    > [ =A0 =A04.308429] pnp 00:02: [mem 0xff000000-0xffffffff]
    > [ =A0 =A04.308445] pnp 00:02: Plug and Play ACPI device, IDs INT0800 (= active)
    > [ =A0 =A04.308540] pnp 00:03: [mem 0xfed00000-0xfed003ff]
    > [ =A0 =A04.308572] system 00:03: [mem 0xfed00000-0xfed003ff] has been = reserved
    > [ =A0 =A04.308575] system 00:03: Plug and Play ACPI device, IDs PNP010= 3 PNP0c01 (active)
    > [ =A0 =A04.308584] pnp 00:04: [io =A00x00f0]
    > [ =A0 =A04.308587] xen: registering gsi 13 triggering 1 polarity 0
    > [ =A0 =A04.308609] pnp 00:04: [irq 13]
    > [ =A0 =A04.308626] pnp 00:04: Plug and Play ACPI device, IDs PNP0c04 (= active)
    > [ =A0 =A04.308636] pnp 00:05: [io =A00x002e-0x002f]
    > [ =A0 =A04.308637] pnp 00:05: [io =A00x004e-0x004f]
    > [ =A0 =A04.308639] pnp 00:05: [io =A00x0061]
    > [ =A0 =A04.308640] pnp 00:05: [io =A00x0063]
    > [ =A0 =A04.308641] pnp 00:05: [io =A00x0065]
    > [ =A0 =A04.308642] pnp 00:05: [io =A00x0067]
    > [ =A0 =A04.308644] pnp 00:05: [io =A00x0070]
    > [ =A0 =A04.308645] pnp 00:05: [io =A00x0080]
    > [ =A0 =A04.308646] pnp 00:05: [io =A00x0092]
    > [ =A0 =A04.308648] pnp 00:05: [io =A00x00b2-0x00b3]
    > [ =A0 =A04.308649] pnp 00:05: [io =A00x0680-0x069f]
    > [ =A0 =A04.308651] pnp 00:05: [io =A00x1000-0x100f]
    > [ =A0 =A04.308653] pnp 00:05: [io =A00xffff]
    > [ =A0 =A04.308654] pnp 00:05: [io =A00xffff]
    > [ =A0 =A04.308655] pnp 00:05: [io =A00x0400-0x047f]
    > [ =A0 =A04.308656] pnp 00:05: [io =A00x0500-0x057f]
    > [ =A0 =A04.308658] pnp 00:05: [io =A00x164e-0x164f]
    > [ =A0 =A04.308689] system 00:05: [io =A00x0680-0x069f] has been reserv= ed
    > [ =A0 =A04.308691] system 00:05: [io =A00x1000-0x100f] has been reserv= ed
    > [ =A0 =A04.308693] system 00:05: [io =A00xffff] has been reserved
    > [ =A0 =A04.308695] system 00:05: [io =A00xffff] has been reserved
    > [ =A0 =A04.308697] system 00:05: [io =A00x0400-0x047f] has been reserv= ed
    > [ =A0 =A04.308700] system 00:05: [io =A00x0500-0x057f] has been reserv= ed
    > [ =A0 =A04.308701] system 00:05: [io =A00x164e-0x164f] has been reserv= ed
    > [ =A0 =A04.308704] system 00:05: Plug and Play ACPI device, IDs PNP0c0= 2 (active)
    > [ =A0 =A04.308711] pnp 00:06: [io =A00x0070-0x0077]
    > [ =A0 =A04.308713] xen: registering gsi 8 triggering 1 polarity 0
    > [ =A0 =A04.308730] pnp 00:06: [irq 8]
    > [ =A0 =A04.308749] pnp 00:06: Plug and Play ACPI device, IDs PNP0b00 (= active)
    > [ =A0 =A04.308758] pnp 00:07: [io =A00x0060]
    > [ =A0 =A04.308759] pnp 00:07: [io =A00x0064]
    > [ =A0 =A04.308761] xen: registering gsi 1 triggering 1 polarity 0
    > [ =A0 =A04.308777] pnp 00:07: [irq 1]
    > [ =A0 =A04.308794] pnp 00:07: Plug and Play ACPI device, IDs PNP0303 (= active)
    > [ =A0 =A04.309984] pnp 00:08: Plug and Play ACPI device, IDs PNP0401 (= disabled)
    > [ =A0 =A04.309993] xen: registering gsi 12 triggering 1 polarity 0
    > [ =A0 =A04.310011] pnp 00:09: [irq 12]
    > [ =A0 =A04.310030] pnp 00:09: Plug and Play ACPI device, IDs DLL0493 P= NP0f13 (active)
    > [ =A0 =A04.310065] pnp 00:0a: [mem 0xfed40000-0xfed44fff]
    > [ =A0 =A04.310086] pnp 00:0a: Plug and Play ACPI device, IDs BCM0102 P= NP0c31 (active)
    > [ =A0 =A04.310291] pnp 00:0b: [mem 0xfed1c000-0xfed1ffff]
    > [ =A0 =A04.310292] pnp 00:0b: [mem 0xfed10000-0xfed17fff]
    > [ =A0 =A04.310294] pnp 00:0b: [mem 0xfed18000-0xfed18fff]
    > [ =A0 =A04.310296] pnp 00:0b: [mem 0xfed19000-0xfed19fff]
    > [ =A0 =A04.310298] pnp 00:0b: [mem 0xf8000000-0xfbffffff]
    > [ =A0 =A04.310309] pnp 00:0b: [mem 0xfed20000-0xfed3ffff]
    > [ =A0 =A04.310310] pnp 00:0b: [mem 0xfed90000-0xfed93fff]
    > [ =A0 =A04.310312] pnp 00:0b: [mem 0xfed45000-0xfed8ffff]
    > [ =A0 =A04.310313] pnp 00:0b: [mem 0xff000000-0xffffffff]
    > [ =A0 =A04.310315] pnp 00:0b: [mem 0xfee00000-0xfeefffff]
    > [ =A0 =A04.310317] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disab= led]
    > [ =A0 =A04.310318] pnp 00:0b: [mem 0x00000000-0xffffffffffffffff disab= led]
    > [ =A0 =A04.310359] system 00:0b: [mem 0xfed1c000-0xfed1ffff] has been = reserved
    > [ =A0 =A04.310361] system 00:0b: [mem 0xfed10000-0xfed17fff] has been = reserved
    > [ =A0 =A04.310363] system 00:0b: [mem 0xfed18000-0xfed18fff] has been = reserved
    > [ =A0 =A04.310365] system 00:0b: [mem 0xfed19000-0xfed19fff] has been = reserved
    > [ =A0 =A04.310367] system 00:0b: [mem 0xf8000000-0xfbffffff] has been = reserved
    > [ =A0 =A04.310369] system 00:0b: [mem 0xfed20000-0xfed3ffff] has been = reserved
    > [ =A0 =A04.310371] system 00:0b: [mem 0xfed90000-0xfed93fff] has been = reserved
    > [ =A0 =A04.310373] system 00:0b: [mem 0xfed45000-0xfed8ffff] has been = reserved
    > [ =A0 =A04.310375] system 00:0b: [mem 0xff000000-0xffffffff] could not= be reserved
    > [ =A0 =A04.310377] system 00:0b: [mem 0xfee00000-0xfeefffff] could not= be reserved
    > [ =A0 =A04.310380] system 00:0b: Plug and Play ACPI device, IDs PNP0c0= 2 (active)
    > [ =A0 =A04.310956] xen: registering gsi 23 triggering 1 polarity 0
    > [ =A0 =A04.310967] xen: --> pirq=3D23 -> irq=3D23 (gsi=3D23)
    > [ =A0 =A04.310985] pnp 00:0c: [irq 23]
    > [ =A0 =A04.311015] pnp 00:0c: Plug and Play ACPI device, IDs SMO8800 (= active)
    > [ =A0 =A04.315528] pnp 00:0d: [mem 0x20000000-0x201fffff]
    > [ =A0 =A04.315531] pnp 00:0d: [mem 0x40000000-0x401fffff]
    > [ =A0 =A04.339851] system 00:0d: [mem 0x20000000-0x201fffff] has been = reserved
    > [ =A0 =A04.339854] system 00:0d: [mem 0x40000000-0x401fffff] has been = reserved
    > [ =A0 =A04.339857] system 00:0d: Plug and Play ACPI device, IDs PNP0c0= 1 (active)
    > [ =A0 =A04.339865] pnp: PnP ACPI: found 14 devices
    > [ =A0 =A04.339867] ACPI: ACPI bus type pnp unregistered
    > [ =A0 =A04.346178] PM-Timer failed consistency check =A0(0x0xffffff) -= aborting.
    > [ =A0 =A04.346274] pci 0000:00:1c.0: PCI bridge to [bus 01-01]
    > [ =A0 =A04.346306] pci 0000:00:1c.1: PCI bridge to [bus 02-02]
    > [ =A0 =A04.346315] pci 0000:00:1c.1: =A0 bridge window [mem 0xe2d00000= -0xe2dfffff]
    > [ =A0 =A04.346332] pci 0000:00:1c.2: PCI bridge to [bus 03-08]
    > [ =A0 =A04.346336] pci 0000:00:1c.2: =A0 bridge window [io =A00x3000-0= x3fff]
    > [ =A0 =A04.346347] pci 0000:00:1c.2: =A0 bridge window [mem 0xe2200000= -0xe2bfffff]
    > [ =A0 =A04.346354] pci 0000:00:1c.2: =A0 bridge window [mem 0xe0a00000= -0xe13fffff 64bit pref]
    > [ =A0 =A04.346366] pci 0000:00:1c.3: PCI bridge to [bus 09-09]
    > [ =A0 =A04.346370] pci 0000:00:1c.3: =A0 bridge window [io =A00x2000-0= x2fff]
    > [ =A0 =A04.346379] pci 0000:00:1c.3: =A0 bridge window [mem 0xe1800000= -0xe21fffff]
    > [ =A0 =A04.346386] pci 0000:00:1c.3: =A0 bridge window [mem 0xe0000000= -0xe09fffff 64bit pref]
    > [ =A0 =A04.346399] pci 0000:00:1c.5: PCI bridge to [bus 0a-0a]
    > [ =A0 =A04.346408] pci 0000:00:1c.5: =A0 bridge window [mem 0xe2c00000= -0xe2cfffff]
    > [ =A0 =A04.346434] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 =A04.346442] xen: --> pirq=3D16 -> irq=3D16 (gsi=3D16)
    > [ =A0 =A04.346469] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 =A04.346473] xen: --> pirq=3D17 -> irq=3D17 (gsi=3D17)
    > [ =A0 =A04.346498] xen: registering gsi 18 triggering 0 polarity 1
    > [ =A0 =A04.346502] xen: --> pirq=3D18 -> irq=3D18 (gsi=3D18)
    > [ =A0 =A04.346527] xen: registering gsi 19 triggering 0 polarity 1
    > [ =A0 =A04.346531] xen: --> pirq=3D19 -> irq=3D19 (gsi=3D19)
    > [ =A0 =A04.346556] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 =A04.346558] Already setup the GSI :17
    > [ =A0 =A04.346563] pci_bus 0000:00: resource 4 [io =A00x0000-0x0cf7] > [ =A0 =A04.346565] pci_bus 0000:00: resource 5 [io =A00x0d00-0xffff] > [ =A0 =A04.346566] pci_bus 0000:00: resource 6 [mem 0x000a0000-0x000bf= fff]
    > [ =A0 =A04.346568] pci_bus 0000:00: resource 7 [mem 0xcfa00000-0xfeaff= fff]
    > [ =A0 =A04.346570] pci_bus 0000:00: resource 8 [mem 0xfed40000-0xfed44= fff]
    > [ =A0 =A04.346572] pci_bus 0000:02: resource 1 [mem 0xe2d00000-0xe2dff= fff]
    > [ =A0 =A04.346574] pci_bus 0000:03: resource 0 [io =A00x3000-0x3fff] > [ =A0 =A04.346575] pci_bus 0000:03: resource 1 [mem 0xe2200000-0xe2bff= fff]
    > [ =A0 =A04.346577] pci_bus 0000:03: resource 2 [mem 0xe0a00000-0xe13ff= fff 64bit pref]
    > [ =A0 =A04.346579] pci_bus 0000:09: resource 0 [io =A00x2000-0x2fff] > [ =A0 =A04.346581] pci_bus 0000:09: resource 1 [mem 0xe1800000-0xe21ff= fff]
    > [ =A0 =A04.346582] pci_bus 0000:09: resource 2 [mem 0xe0000000-0xe09ff= fff 64bit pref]
    > [ =A0 =A04.346584] pci_bus 0000:0a: resource 1 [mem 0xe2c00000-0xe2cff= fff]
    > [ =A0 =A04.346672] NET: Registered protocol family 2
    > [ =A0 =A04.346732] IP route cache hash table entries: 524288 (order: 1= 0, 4194304 bytes)
    > [ =A0 =A04.347207] TCP established hash table entries: 262144 (order: = 10, 4194304 bytes)
    > [ =A0 =A04.347753] TCP bind hash table entries: 65536 (order: 8, 10485= 76 bytes)
    > [ =A0 =A04.347872] TCP: Hash tables configured (established 262144 bin= d 65536)
    > [ =A0 =A04.347874] TCP: reno registered
    > [ =A0 =A04.347877] UDP hash table entries: 8192 (order: 6, 262144 byte= s)
    > [ =A0 =A04.347921] UDP-Lite hash table entries: 8192 (order: 6, 262144= bytes)
    > [ =A0 =A04.348067] NET: Registered protocol family 1
    > [ =A0 =A04.348085] pci 0000:00:02.0: Boot video device
    > [ =A0 =A04.348108] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 =A04.348112] Already setup the GSI :16
    > [ =A0 =A04.348203] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 =A04.348205] Already setup the GSI :17
    > [ =A0 =A04.348298] PCI: CLS 64 bytes, default 64
    > [ =A0 =A04.348333] Unpacking initramfs...
    > [ =A0 =A04.384265] Freeing initrd memory: 45868k freed
    > [ =A0 =A04.392440] Simple Boot Flag at 0xf3 set to 0x1
    > [ =A0 =A04.392900] audit: initializing netlink socket (disabled)
    > [ =A0 =A04.392911] type=3D2000 audit(1354151975.383:1): initialized > [ =A0 =A04.411688] VFS: Disk quotas dquot_6.5.2
    > [ =A0 =A04.411715] Dquot-cache hash table entries: 512 (order 0, 4096 = bytes)
    > [ =A0 =A04.411870] msgmni has been set to 29339
    > [ =A0 =A04.412010] Block layer SCSI generic (bsg) driver version 0.4 l= oaded (major 253)
    > [ =A0 =A04.412013] io scheduler noop registered
    > [ =A0 =A04.412015] io scheduler deadline registered
    > [ =A0 =A04.412036] io scheduler cfq registered (default)
    > [ =A0 =A04.412666] intel_idle: does not run on family 6 model 42
    > [ =A0 =A04.412741] ACPI: Requesting acpi_cpufreq
    > [ =A0 =A04.459643] Non-volatile memory driver v1.3
    > [ =A0 =A04.459654] ramoops: platform device not found, using module pa= rameters
    > [ =A0 =A04.459670] ramoops: The memory size and the record size must b= e non-zero
    > [ =A0 =A04.459703] ramoops: probe of ramoops failed with error -22
    > [ =A0 =A04.474892] loop: module loaded
    > [ =A0 =A04.474922] Fixed MDIO Bus: probed
    > [ =A0 =A04.474965] i8042: PNP: PS/2 Controller [PNP0303:PS2K,PNP0f13:P= S2M] at 0x60,0x64 irq 1,12
    > [ =A0 =A04.475166] i8042: Warning: Keylock active
    > [ =A0 =A04.476434] serio: i8042 KBD port at 0x60,0x64 irq 1
    > [ =A0 =A04.476439] serio: i8042 AUX port at 0x60,0x64 irq 12
    > [ =A0 =A04.476551] mousedev: PS/2 mouse device common for all mice
    > [ =A0 =A04.476707] rtc_cmos 00:06: RTC can wake from S4
    > [ =A0 =A04.476940] rtc_cmos 00:06: rtc core: registered rtc_cmos as rt= c0
    > [ =A0 =A04.476998] rtc0: alarms up to one year, y3k, 242 bytes nvram > [ =A0 =A04.477084] device-mapper: uevent: version 1.0.3
    > [ =A0 =A04.477193] device-mapper: ioctl: 4.22.0-ioctl (2011-10-19) ini= tialised: dm-devel@redhat.com > [ =A0 =A04.477281] TCP: cubic registered
    > [ =A0 =A04.477381] input: AT Translated Set 2 keyboard as /devices/pla= tform/i8042/serio0/input/input0
    > [ =A0 =A04.477402] NET: Registered protocol family 10
    > [ =A0 =A04.477644] Registering the dns_resolver key type
    > [ =A0 =A04.477791] registered taskstats version 1
    > [ =A0 =A04.478330] =A0 Magic number: 4:584:307
    > [ =A0 =A04.478403] tty tty36: hash matches
    > [ =A0 =A04.478496] rtc_cmos 00:06: setting system clock to 2012-11-29 = 01:19:35 UTC (1354151975)
    > [ =A0 =A04.478801] Freeing unused kernel memory: 552k freed
    > [ =A0 =A04.478847] Write protecting the kernel read-only data: 8192k > [ =A0 =A04.481908] Freeing unused kernel memory: 1568k freed
    > [ =A0 =A04.482112] Freeing unused kernel memory: 24k freed
    > [ =A0 =A04.524129] dracut: dracut-005-3.fc13
    > [ =A0 =A04.552311] pciback 0000:00:19.0: seizing device
    > [ =A0 =A04.552403] pciback 0000:02:00.0: seizing device
    > [ =A0 =A04.552941] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 =A04.552952] Already setup the GSI :17
    > [ =A0 =A04.553934] xen: registering gsi 20 triggering 0 polarity 1
    > [ =A0 =A04.553964] xen: --> pirq=3D20 -> irq=3D20 (gsi=3D20)
    > [ =A0 =A04.554574] xen-pciback: backend is vpci
    > [ =A0 =A04.617471] udev: starting version 151
    > [ =A0 =A04.617770] udevd (80): /proc/80/oom_adj is deprecated, please = use /proc/80/oom_score_adj instead.
    > [ =A0 =A04.654916] Linux agpgart interface v0.103
    > [ =A0 =A04.655397] input: Lid Switch as /devices/LNXSYSTM:00/device:00= /PNP0C0D:00/input/input1
    > [ =A0 =A05.051184] ACPI: Lid Switch [LID]
    > [ =A0 =A05.051436] input: Power Button as /devices/LNXSYSTM:00/device:= 00/PNP0C0C:00/input/input2
    > [ =A0 =A05.051547] ACPI: Power Button [PBTN]
    > [ =A0 =A05.051682] input: Sleep Button as /devices/LNXSYSTM:00/device:= 00/PNP0C0E:00/input/input3
    > [ =A0 =A05.051760] ACPI: Sleep Button [SBTN]
    > [ =A0 =A05.054141] input: Power Button as /devices/LNXSYSTM:00/LNXPWRB= N:00/input/input4
    > [ =A0 =A05.054421] ACPI: Power Button [PWRF]
    > [ =A0 =A05.056887] agpgart-intel 0000:00:00.0: Intel Sandybridge Chips= et
    > [ =A0 =A05.058118] agpgart-intel 0000:00:00.0: detected gtt size: 2097= 152K total, 262144K mappable
    > [ =A0 =A05.064439] agpgart-intel 0000:00:00.0: detected 65536K stolen = memory
    > [ =A0 =A05.064916] agpgart-intel 0000:00:00.0: AGP aperture is 256M @ = 0xd0000000
    > [ =A0 =A05.070296] [drm] Initialized drm 1.1.0 20060810
    > [ =A0 =A05.080002] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 =A05.080015] Already setup the GSI :16
    > [ =A0 =A05.080364] i915 0000:00:02.0: setting latency timer to 64
    > [ =A0 =A05.190295] [drm] MTRR allocation failed. =A0Graphics performan= ce may suffer.
    > [ =A0 =A05.190491] [drm] Supports vblank timestamp caching Rev 1 (10.1= 0.2010).
    > [ =A0 =A05.190493] [drm] Driver supports precise vblank timestamp quer= y.
    > [ =A0 =A05.190554] vgaarb: device changed decodes: PCI:0000:00:02.0,ol= ddecodes=3Dio+mem,decodes=3Dio+mem:owns=3Dio+mem
    > [ =A0 =A05.548301] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp = off
    > [ =A0 =A05.591093] input: DualPoint Stick as /devices/platform/i8042/s= erio1/input/input5
    > [ =A0 =A05.606212] input: AlpsPS/2 ALPS DualPoint TouchPad as /devices= /platform/i8042/serio1/input/input6
    > [ =A0 =A05.806814] fbcon: inteldrmfb (fb0) is primary device
    > [ =A0 =A06.095967] Console: switching to colour frame buffer device 20= 0x56
    > [ =A0 =A06.101477] fb0: inteldrmfb frame buffer device
    > [ =A0 =A06.101478] drm: registered panic notifier
    > [ =A0 =A06.130833] acpi device:38: registered as cooling_device4
    > [ =A0 =A06.133713] input: Video Bus as /devices/LNXSYSTM:00/device:00/= PNP0A08:00/LNXVIDEO:00/input/input7
    > [ =A0 =A06.133915] ACPI: Video Device [VID] (multi-head: yes =A0rom: n= o =A0post: no)
    > [ =A0 =A06.135082] [drm] Initialized i915 1.6.0 20080730 for 0000:00:0= 2.0 on minor 0
    > [ =A0 =A06.185946] dracut: Starting plymouth daemon
    > [ =A0 =A06.479391] dracut: rd_NO_DM: removing DM RAID activation
    > [ =A0 =A06.489309] dracut: rd_NO_MD: removing MD RAID activation
    > [ =A0 =A06.542596] wmi: Mapper loaded
    > [ =A0 =A06.564439] usbcore: registered new interface driver usbfs
    > [ =A0 =A06.564463] usbcore: registered new interface driver hub
    > [ =A0 =A06.568901] SCSI subsystem initialized
    > [ =A0 =A06.569574] usbcore: registered new device driver usb
    > [ =A0 =A06.570692] ehci_hcd: USB 2.0 'Enhanced' Host Controlle= r (EHCI) Driver
    > [ =A0 =A06.570723] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 =A06.570728] Already setup the GSI :16
    > [ =A0 =A06.570776] ehci_hcd 0000:00:1a.0: setting latency timer to 64<= br> > [ =A0 =A06.570782] ehci_hcd 0000:00:1a.0: EHCI Host Controller
    > [ =A0 =A06.570814] ehci_hcd 0000:00:1a.0: new USB bus registered, assi= gned bus number 1
    > [ =A0 =A06.570879] ehci_hcd 0000:00:1a.0: debug port 2
    > [ =A0 =A06.573720] libata version 3.00 loaded.
    > [ =A0 =A06.574777] ehci_hcd 0000:00:1a.0: cache line size of 64 is not= supported
    > [ =A0 =A06.574832] ehci_hcd 0000:00:1a.0: irq 16, io mem 0xe2e70000 > [ =A0 =A06.586344] ehci_hcd 0000:00:1a.0: USB 2.0 started, EHCI 1.00 > [ =A0 =A06.586369] usb usb1: New USB device found, idVendor=3D1d6b, id= Product=3D0002
    > [ =A0 =A06.586372] usb usb1: New USB device strings: Mfr=3D3, Product= =3D2, SerialNumber=3D1
    > [ =A0 =A06.586375] usb usb1: Product: EHCI Host Controller
    > [ =A0 =A06.586376] usb usb1: Manufacturer: Linux 3.4.18-2.pvops.qubes.= x86_64 ehci_hcd
    > [ =A0 =A06.586378] usb usb1: SerialNumber: 0000:00:1a.0
    > [ =A0 =A06.586506] hub 1-0:1.0: USB hub found
    > [ =A0 =A06.586511] hub 1-0:1.0: 2 ports detected
    > [ =A0 =A06.586604] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 =A06.586609] Already setup the GSI :17
    > [ =A0 =A06.586663] ehci_hcd 0000:00:1d.0: setting latency timer to 64<= br> > [ =A0 =A06.586668] ehci_hcd 0000:00:1d.0: EHCI Host Controller
    > [ =A0 =A06.586678] ehci_hcd 0000:00:1d.0: new USB bus registered, assi= gned bus number 2
    > [ =A0 =A06.586734] ehci_hcd 0000:00:1d.0: debug port 2
    > [ =A0 =A06.590650] ehci_hcd 0000:00:1d.0: cache line size of 64 is not= supported
    > [ =A0 =A06.590709] ehci_hcd 0000:00:1d.0: irq 17, io mem 0xe2e50000 > [ =A0 =A06.606335] ehci_hcd 0000:00:1d.0: USB 2.0 started, EHCI 1.00 > [ =A0 =A06.606364] usb usb2: New USB device found, idVendor=3D1d6b, id= Product=3D0002
    > [ =A0 =A06.606367] usb usb2: New USB device strings: Mfr=3D3, Product= =3D2, SerialNumber=3D1
    > [ =A0 =A06.606370] usb usb2: Product: EHCI Host Controller
    > [ =A0 =A06.606371] usb usb2: Manufacturer: Linux 3.4.18-2.pvops.qubes.= x86_64 ehci_hcd
    > [ =A0 =A06.606373] usb usb2: SerialNumber: 0000:00:1d.0
    > [ =A0 =A06.606519] hub 2-0:1.0: USB hub found
    > [ =A0 =A06.606524] hub 2-0:1.0: 2 ports detected
    > [ =A0 =A06.606620] ahci 0000:00:1f.2: version 3.0
    > [ =A0 =A06.606641] xen: registering gsi 18 triggering 0 polarity 1
    > [ =A0 =A06.606647] Already setup the GSI :18
    > [ =A0 =A06.606896] ahci: SSS flag set, parallel bus scan disabled
    > [ =A0 =A06.626400] ahci 0000:00:1f.2: AHCI 0001.0300 32 slots 6 ports = 6 Gbps 0x3b impl SATA mode
    > [ =A0 =A06.626405] ahci 0000:00:1f.2: flags: 64bit ncq sntf stag pm le= d clo pio slum part ems sxs apst
    > [ =A0 =A06.626414] ahci 0000:00:1f.2: setting latency timer to 64
    > [ =A0 =A06.673732] scsi0 : ahci
    > [ =A0 =A06.683363] scsi1 : ahci
    > [ =A0 =A06.697268] scsi2 : ahci
    > [ =A0 =A06.711526] scsi3 : ahci
    > [ =A0 =A06.733931] scsi4 : ahci
    > [ =A0 =A06.739603] scsi5 : ahci
    > [ =A0 =A06.842106] ata1: SATA max UDMA/133 abar m2048@0xe2e40000 port = 0xe2e40100 irq 293
    > [ =A0 =A06.842118] ata2: SATA max UDMA/133 abar m2048@0xe2e40000 port = 0xe2e40180 irq 293
    > [ =A0 =A06.842124] ata3: DUMMY
    > [ =A0 =A06.842129] ata4: SATA max UDMA/133 abar m2048@0xe2e40000 port = 0xe2e40280 irq 293
    > [ =A0 =A06.842136] ata5: SATA max UDMA/133 abar m2048@0xe2e40000 port = 0xe2e40300 irq 293
    > [ =A0 =A06.842143] ata6: SATA max UDMA/133 abar m2048@0xe2e40000 port = 0xe2e40380 irq 293
    > [ =A0 =A06.898480] usb 1-1: new high-speed USB device number 2 using e= hci_hcd
    > [ =A0 =A07.031312] usb 1-1: New USB device found, idVendor=3D8087, idP= roduct=3D0024
    > [ =A0 =A07.031323] usb 1-1: New USB device strings: Mfr=3D0, Product= =3D0, SerialNumber=3D0
    > [ =A0 =A07.032072] hub 1-1:1.0: USB hub found
    > [ =A0 =A07.032344] hub 1-1:1.0: 6 ports detected
    > [ =A0 =A07.142515] usb 2-1: new high-speed USB device number 2 using e= hci_hcd
    > [ =A0 =A07.162484] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 3= 00)
    > [ =A0 =A07.268594] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) reject= ed by device (Stat=3D0x51 Err=3D0x04)
    > [ =A0 =A07.268770] ata1.00: ATA-9: KINGSTON SV200S3256G, E111008a, max= UDMA/100
    > [ =A0 =A07.268778] ata1.00: 500118192 sectors, multi 16: LBA48 NCQ (de= pth 31/32), AA
    > [ =A0 =A07.272554] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) reject= ed by device (Stat=3D0x51 Err=3D0x04)
    > [ =A0 =A07.272758] ata1.00: configured for UDMA/100
    > [ =A0 =A07.273314] scsi 0:0:0:0: Direct-Access =A0 =A0 ATA =A0 =A0 =A0= KINGSTON SV200S3 E111 PQ: 0 ANSI: 5
    > [ =A0 =A07.274861] usb 2-1: New USB device found, idVendor=3D8087, idP= roduct=3D0024
    > [ =A0 =A07.274870] usb 2-1: New USB device strings: Mfr=3D0, Product= =3D0, SerialNumber=3D0
    > [ =A0 =A07.275358] hub 2-1:1.0: USB hub found
    > [ =A0 =A07.275521] hub 2-1:1.0: 8 ports detected
    > [ =A0 =A07.346717] usb 1-1.4: new full-speed USB device number 3 using= ehci_hcd
    > [ =A0 =A07.443529] usb 1-1.4: New USB device found, idVendor=3D413c, i= dProduct=3D8187
    > [ =A0 =A07.443539] usb 1-1.4: New USB device strings: Mfr=3D1, Product= =3D2, SerialNumber=3D3
    > [ =A0 =A07.443546] usb 1-1.4: Product: DW375 Bluetooth Module
    > [ =A0 =A07.443550] usb 1-1.4: Manufacturer: Dell Computer Corp
    > [ =A0 =A07.443555] usb 1-1.4: SerialNumber: D0DF9A40FE60
    > [ =A0 =A07.514736] usb 1-1.5: new high-speed USB device number 4 using= ehci_hcd
    > [ =A0 =A07.590440] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 3= 00)
    > [ =A0 =A07.593835] ata2.00: ATAPI: HL-DT-ST DVD+/-RW GU60N, A103, max = UDMA/133
    > [ =A0 =A07.604147] ata2.00: configured for UDMA/133
    > [ =A0 =A07.614746] usb 1-1.5: New USB device found, idVendor=3D05ca, i= dProduct=3D181c
    > [ =A0 =A07.614757] usb 1-1.5: New USB device strings: Mfr=3D1, Product= =3D2, SerialNumber=3D0
    > [ =A0 =A07.614763] usb 1-1.5: Product: Laptop_Integrated_Webcam_FHD > [ =A0 =A07.614768] usb 1-1.5: Manufacturer: CN0CJ3P27248717F040SA01 > [ =A0 =A07.618662] scsi 1:0:0:0: CD-ROM =A0 =A0 =A0 =A0 =A0 =A0HL-DT-S= T DVD+-RW GU60N =A0 =A0A103 PQ: 0 ANSI: 5
    > [ =A0 =A07.686581] usb 2-1.6: new high-speed USB device number 3 using= ehci_hcd
    > [ =A0 =A07.795399] usb 2-1.6: New USB device found, idVendor=3D413c, i= dProduct=3D818d
    > [ =A0 =A07.795410] usb 2-1.6: New USB device strings: Mfr=3D1, Product= =3D2, SerialNumber=3D3
    > [ =A0 =A07.795416] usb 2-1.6: Product: DW5550
    > [ =A0 =A07.795420] usb 2-1.6: Manufacturer: Dell
    > [ =A0 =A07.795425] usb 2-1.6: SerialNumber: 88FA653FDF944970
    > [ =A0 =A07.902770] usb 2-1.8: new full-speed USB device number 4 using= ehci_hcd
    > [ =A0 =A07.938478] ata4: SATA link down (SStatus 0 SControl 300)
    > [ =A0 =A08.017319] usb 2-1.8: New USB device found, idVendor=3D0a5c, i= dProduct=3D5801
    > [ =A0 =A08.017330] usb 2-1.8: New USB device strings: Mfr=3D1, Product= =3D2, SerialNumber=3D3
    > [ =A0 =A08.017336] usb 2-1.8: Product: 5880
    > [ =A0 =A08.017340] usb 2-1.8: Manufacturer: Broadcom Corp
    > [ =A0 =A08.017344] usb 2-1.8: SerialNumber: 0123456789ABCD
    > [ =A0 =A08.017794] usb 2-1.8: config 0 descriptor??
    > [ =A0 =A08.258411] ata5: SATA link down (SStatus 0 SControl 300)
    > [ =A0 =A08.578480] ata6: SATA link down (SStatus 0 SControl 300)
    > [ =A0 =A08.588630] sd 0:0:0:0: [sda] 500118192 512-byte logical blocks= : (256 GB/238 GiB)
    > [ =A0 =A08.588846] sd 0:0:0:0: [sda] Write Protect is off
    > [ =A0 =A08.588861] sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
    > [ =A0 =A08.588967] sd 0:0:0:0: [sda] Write cache: enabled, read cache:= enabled, doesn't support DPO or FUA
    > [ =A0 =A08.590122] =A0sda: sda1 sda2
    > [ =A0 =A08.591059] sd 0:0:0:0: [sda] Attached SCSI disk
    > [ =A0 =A08.609438] sr0: scsi3-mmc drive: 24x/8x writer dvd-ram cd/rw x= a/form2 cdda tray
    > [ =A0 =A08.609451] cdrom: Uniform CD-ROM driver Revision: 3.20
    > [ =A0 =A08.609737] sr 1:0:0:0: Attached scsi CD-ROM sr0
    > [ =A0 =A08.714515] dracut: luksOpen /dev/sda2 luks-400336fa-c7c4-4be3-= a244-c909aa16a18c
    > [ =A0 13.862564] dracut: Scanning devices dm-0 =A0for LVM logical volu= mes vg_dom0/lv_root vg_dom0/lv_swap
    > [ =A0 13.907639] dracut: inactive '/dev/vg_dom0/lv_root' [221.= 62 GiB] inherit
    > [ =A0 13.907708] dracut: inactive '/dev/vg_dom0/lv_swap' [16.3= 4 GiB] inherit
    > [ =A0 14.162684] EXT4-fs (dm-1): INFO: recovery required on readonly f= ilesystem
    > [ =A0 14.162693] EXT4-fs (dm-1): write access will be enabled during r= ecovery
    > [ =A0 14.775779] EXT4-fs (dm-1): orphan cleanup on readonly fs
    > [ =A0 14.775800] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767209
    > [ =A0 14.775909] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767207
    > [ =A0 14.776007] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767205
    > [ =A0 14.776035] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767206
    > [ =A0 14.776062] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767204
    > [ =A0 14.776088] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767202
    > [ =A0 14.776117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767198
    > [ =A0 14.776146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767196
    > [ =A0 14.776172] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767191
    > [ =A0 14.776198] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767189
    > [ =A0 14.776227] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767188
    > [ =A0 14.776274] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767187
    > [ =A0 14.777018] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767186
    > [ =A0 14.777060] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767184
    > [ =A0 14.777089] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767183
    > [ =A0 14.777117] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767171
    > [ =A0 14.777146] EXT4-fs (dm-1): ext4_orphan_cleanup: deleting unrefer= enced inode 5767170
    > [ =A0 14.777172] EXT4-fs (dm-1): 17 orphan inodes deleted
    > [ =A0 14.777177] EXT4-fs (dm-1): recovery complete
    > [ =A0 14.797124] EXT4-fs (dm-1): mounted filesystem with ordered data = mode. Opts: (null)
    > [ =A0 14.806762] dracut: Mounted root filesystem /dev/mapper/vg_dom0-l= v_root
    > [ =A0 14.957211] dracut: Switching root
    > [ =A0 15.599261] udev: starting version 151
    > [ =A0 15.673674] iTCO_vendor_support: vendor-support=3D0
    > [ =A0 15.676374] mei: module is from the staging directory, the qualit= y is unknown, you have been warned.
    > [ =A0 15.676488] iTCO_wdt: Intel TCO WatchDog Timer Driver v1.07
    > [ =A0 15.676679] iTCO_wdt: Found a Cougar Point TCO device (Version=3D= 2, TCOBASE=3D0x0460)
    > [ =A0 15.676711] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 15.676716] Already setup the GSI :16
    > [ =A0 15.676725] mei 0000:00:16.0: setting latency timer to 64
    > [ =A0 15.676754] iTCO_wdt: initialized. heartbeat=3D30 sec (nowayout= =3D0)
    > [ =A0 15.712582] sd 0:0:0:0: Attached scsi generic sg0 type 0
    > [ =A0 15.712620] sr 1:0:0:0: Attached scsi generic sg1 type 5
    > [ =A0 15.730448] input: PC Speaker as /devices/platform/pcspkr/input/i= nput8
    > [ =A0 15.734494] xen: registering gsi 18 triggering 0 polarity 1
    > [ =A0 15.734500] Already setup the GSI :18
    > [ =A0 15.734506] ACPI Warning: 0x0000000000004040-0x000000000000405f S= ystemIO conflicts with Region \_SB_.PCI0.SBUS.SMBI 1 (20120320/utaddress-25= 1)
    > [ =A0 15.734512] ACPI: If an ACPI driver is available for this device,= you should use it instead of the native driver
    > [ =A0 15.737002] microcode: CPU0 sig=3D0x206a7, pf=3D0x10, revision=3D= 0x23
    > [ =A0 15.741412] watchdog: INTCAMT: cannot register miscdev on minor= =3D130 (err=3D-16)
    > [ =A0 15.741418] watchdog: error registering /dev/watchdog (err=3D-16)=
    > [ =A0 15.741422] mei 0000:00:16.0: unable to register watchdog device.=
    > [ =A0 15.790637] thermal LNXTHERM:00: registered as thermal_zone0
    > [ =A0 15.790641] ACPI: Thermal Zone [THM] (25 C)
    > [ =A0 15.814551] ACPI: Deprecated procfs I/F for battery is loaded, pl= ease retry with CONFIG_ACPI_PROCFS_POWER cleared
    > [ =A0 15.814559] ACPI: Battery Slot [BAT0] (battery present)
    > [ =A0 15.815037] ACPI: Deprecated procfs I/F for AC is loaded, please = retry with CONFIG_ACPI_PROCFS_POWER cleared
    > [ =A0 15.815521] ACPI: AC Adapter [AC] (on-line)
    > [ =A0 15.867835] usbcore: registered new interface driver usbback
    > [ =A0 15.975826] ACPI: Deprecated procfs I/F for battery is loaded, pl= ease retry with CONFIG_ACPI_PROCFS_POWER cleared
    > [ =A0 15.975836] ACPI: Battery Slot [BAT1] (battery absent)
    > [ =A0 16.102871] ACPI: Deprecated procfs I/F for battery is loaded, pl= ease retry with CONFIG_ACPI_PROCFS_POWER cleared
    > [ =A0 16.102882] ACPI: Battery Slot [BAT2] (battery absent)
    > [ =A0 16.106793] sdhci: Secure Digital Host Controller Interface drive= r
    > [ =A0 16.106797] sdhci: Copyright(c) Pierre Ossman
    > [ =A0 16.107131] parport_pc 00:08: [io =A00x0378-0x037b]
    > [ =A0 16.107296] parport_pc 00:08: [irq 5]
    > [ =A0 16.107709] sdhci-pci 0000:0a:00.0: SDHCI controller found [1217:= 8221] (rev 5)
    > [ =A0 16.159148] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 16.159156] Already setup the GSI :17
    > [ =A0 16.159241] sdhci-pci 0000:0a:00.0: Invalid iomem size. You may e= xperience problems.
    > [ =A0 16.159319] 0000:0a:00.0 supply vmmc not found, using dummy regul= ator
    > [ =A0 16.159384] Registered led device: mmc0::
    > [ =A0 16.160442] mmc0: SDHCI controller on PCI [0000:0a:00.0] using DM= A
    > [ =A0 16.160928] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0 16.171737] Linux video capture interface: v2.00
    > [ =A0 16.192158] cdc_wdm 2-1.6:1.5: cdc-wdm0: USB WDM device
    > [ =A0 16.192211] cdc_wdm 2-1.6:1.8: cdc-wdm1: USB WDM device
    > [ =A0 16.192234] usbcore: registered new interface driver cdc_wdm
    > [ =A0 16.195744] cdc_acm 2-1.6:1.1: ttyACM0: USB ACM device
    > [ =A0 16.198739] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0 16.220532] cdc_acm 2-1.6:1.3: ttyACM1: USB ACM device
    > [ =A0 16.223728] cdc_acm 2-1.6:1.9: ttyACM2: USB ACM device
    > [ =A0 16.235089] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0 16.235234] usbcore: registered new interface driver cdc_acm
    > [ =A0 16.235236] cdc_acm: USB Abstract Control Model driver for USB mo= dems and ISDN adapters
    > [ =A0 16.240235] uvcvideo: Found UVC 1.00 device Laptop_Integrated_Web= cam_FHD (05ca:181c)
    > [ =A0 16.269474] input: Laptop_Integrated_Webcam_FHD as /devices/pci00= 00:00/0000:00:1a.0/usb1/1-1/1-1.5/1-1.5:1.0/input/input9
    > [ =A0 16.269579] usbcore: registered new interface driver uvcvideo
    > [ =A0 16.269581] USB Video Class driver (1.1.1)
    > [ =A0 16.277415] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0 16.296646] usb 2-1.6: MAC-Address: 02:80:37:ec:02:00
    > [ =A0 16.296810] cdc_ncm 2-1.6:1.6: usb0: register 'cdc_ncm' a= t usb-0000:00:1d.0-1.6, CDC NCM, 02:80:37:ec:02:00
    > [ =A0 16.296847] usbcore: registered new interface driver cdc_ncm
    > [ =A0 16.310604] parport_pc 00:08: activated
    > [ =A0 16.310611] parport_pc 00:08: reported by Plug and Play ACPI
    > [ =A0 16.310781] parport_pc 00:08: disabled
    > [ =A0 16.311583] tpm_tis 00:0a: 1.2 TPM (device-id 0x2001, rev-id 32)<= br> > [ =A0 16.399296] Bluetooth: Core ver 2.16
    > [ =A0 16.399312] NET: Registered protocol family 31
    > [ =A0 16.399314] Bluetooth: HCI device and connection manager initiali= zed
    > [ =A0 16.399317] Bluetooth: HCI socket layer initialized
    > [ =A0 16.399318] Bluetooth: L2CAP socket layer initialized
    > [ =A0 16.399325] Bluetooth: SCO socket layer initialized
    > [ =A0 16.450583] xen: registering gsi 22 triggering 0 polarity 1
    > [ =A0 16.450600] xen: --> pirq=3D22 -> irq=3D22 (gsi=3D22)
    > [ =A0 16.567577] usbcore: registered new interface driver btusb
    > [ =A0 16.739259] dcdbas dcdbas: Dell Systems Management Base Driver (v= ersion 5.6.0-3.2)
    > [ =A0 16.819125] input: Dell WMI hotkeys as /devices/virtual/input/inp= ut10
    > [ =A0 16.925000] microcode: CPU1 sig=3D0x206a7, pf=3D0x10, revision=3D= 0x23
    > [ =A0 16.929246] ppdev: user-space parallel port driver
    > [ =A0 16.954783] microcode: CPU2 sig=3D0x206a7, pf=3D0x10, revision=3D= 0x23
    > [ =A0 16.975176] microcode: CPU3 sig=3D0x206a7, pf=3D0x10, revision=3D= 0x23
    > [ =A0 17.004696] microcode: Microcode Update Driver: v2.00 <tigran@aivazian.fsnet.co.uk>= , Peter Oruba
    > [ =A0 17.067123] ALSA hda_codec.c:5101 autoconfig: line_outs=3D1 (0xe/= 0x0/0x0/0x0/0x0) type:line
    > [ =A0 17.067127] ALSA hda_codec.c:5105 =A0 =A0speaker_outs=3D1 (0xd/0x= 0/0x0/0x0/0x0)
    > [ =A0 17.067129] ALSA hda_codec.c:5109 =A0 =A0hp_outs=3D1 (0xb/0x0/0x0= /0x0/0x0)
    > [ =A0 17.067131] ALSA hda_codec.c:5110 =A0 =A0mono: mono_out=3D0x0
    > [ =A0 17.067133] ALSA hda_codec.c:5114 =A0 =A0inputs:
    > [ =A0 17.067135] ALSA hda_codec.c:5118 =A0Mic=3D0xa
    > [ =A0 17.067137] ALSA hda_codec.c:5118 =A0Dock Mic=3D0xf
    > [ =A0 17.067139] ALSA hda_codec.c:5120
    > [ =A0 17.067637] ALSA patch_sigmatel.c:3117 stac92xx: dac_nids=3D1 (0x= 13/0x0/0x0/0x0/0x0)
    > [ =A0 17.081104] input: HDA Intel PCH HDMI/DP,pcm=3D8 as /devices/pci0= 000:00/0000:00:1b.0/sound/card0/input11
    > [ =A0 17.081194] input: HDA Intel PCH HDMI/DP,pcm=3D7 as /devices/pci0= 000:00/0000:00:1b.0/sound/card0/input12
    > [ =A0 17.081250] input: HDA Intel PCH HDMI/DP,pcm=3D3 as /devices/pci0= 000:00/0000:00:1b.0/sound/card0/input13
    > [ =A0 17.081342] input: HDA Intel PCH Dock Mic as /devices/pci0000:00/= 0000:00:1b.0/sound/card0/input14
    > [ =A0 17.081432] input: HDA Intel PCH Mic as /devices/pci0000:00/0000:= 00:1b.0/sound/card0/input15
    > [ =A0 17.081522] input: HDA Intel PCH Headphone as /devices/pci0000:00= /0000:00:1b.0/sound/card0/input16
    > [ =A0 17.081610] input: HDA Intel PCH Dock Line Out as /devices/pci000= 0:00/0000:00:1b.0/sound/card0/input17
    > [ =A0 17.265462] Event-channel device installed.
    > [ =A0 17.661764] EXT4-fs (dm-1): re-mounted. Opts: (null)
    > [ =A0 17.802446] EXT4-fs (sda1): mounted filesystem with ordered data = mode. Opts: (null)
    > [ =A0 19.361631] Adding 17137660k swap on /dev/mapper/vg_dom0-lv_swap.= =A0Priority:-1 extents:1 across:17137660k SS
    > [ =A0 22.602549] ehci_hcd 0000:00:1a.0: remove, state 1
    > [ =A0 22.602568] usb usb1: USB disconnect, device number 1
    > [ =A0 22.602573] usb 1-1: USB disconnect, device number 2
    > [ =A0 22.602578] usb 1-1.4: USB disconnect, device number 3
    > [ =A0 22.605235] usb 1-1.5: USB disconnect, device number 4
    > [ =A0 22.636910] ehci_hcd 0000:00:1a.0: USB bus 1 deregistered
    > [ =A0 22.637183] pciback 0000:00:1a.0: seizing device
    > [ =A0 22.637235] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 22.637241] Already setup the GSI :16
    > [ =A0 22.662363] ehci_hcd 0000:00:1d.0: remove, state 1
    > [ =A0 22.662371] usb usb2: USB disconnect, device number 1
    > [ =A0 22.662373] usb 2-1: USB disconnect, device number 2
    > [ =A0 22.662376] usb 2-1.6: USB disconnect, device number 3
    > [ =A0 22.668531] cdc_ncm 2-1.6:1.6: usb0: unregister 'cdc_ncm'= usb-0000:00:1d.0-1.6, CDC NCM
    > [ =A0 22.694795] usb 2-1.8: USB disconnect, device number 4
    > [ =A0 22.699298] ehci_hcd 0000:00:1d.0: USB bus 2 deregistered
    > [ =A0 22.699577] pciback 0000:00:1d.0: seizing device
    > [ =A0 22.699632] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 22.699637] Already setup the GSI :17
    > [ =A0 23.684708] xen-pciback: vpci: 0000:00:19.0: assign to virtual sl= ot 0
    > [ =A0 23.685240] xen-pciback: vpci: 0000:00:1a.0: assign to virtual sl= ot 1
    > [ =A0 23.685722] xen-pciback: vpci: 0000:00:1d.0: assign to virtual sl= ot 2
    > [ =A0 23.686764] xen-pciback: vpci: 0000:02:00.0: assign to virtual sl= ot 3
    > [ =A0 23.909636] pciback 0000:00:19.0: Driver tried to write to a read= -only configuration space field at offset 0xd2, size 2. This may be harmles= s, but if you have problems with your device:
    > [ =A0 23.909638] 1) see permissive attribute in sysfs
    > [ =A0 23.909638] 2) report problems to the xen-devel mailing list alon= g with details of your device obtained from lspci.
    > [ =A0 23.917523] pciback 0000:02:00.0: Driver tried to write to a read= -only configuration space field at offset 0xd2, size 2. This may be harmles= s, but if you have problems with your device:
    > [ =A0 23.917526] 1) see permissive attribute in sysfs
    > [ =A0 23.917526] 2) report problems to the xen-devel mailing list alon= g with details of your device obtained from lspci.
    > [ =A0 24.123663] xen-blkback:ring-ref 9, event-channel 14, protocol 1 = (x86_64-abi)
    > [ =A0 24.140460] xen-blkback:ring-ref 10, event-channel 15, protocol 1= (x86_64-abi)
    > [ =A0 24.151420] xen-blkback:ring-ref 11, event-channel 16, protocol 1= (x86_64-abi)
    > [ =A0 24.158428] xen-blkback:ring-ref 12, event-channel 17, protocol 1= (x86_64-abi)
    > [ =A0 28.697615] pciback 0000:00:1a.0: enabling device (0000 -> 000= 2)
    > [ =A0 28.697628] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0 28.697634] Already setup the GSI :16
    > [ =A0 28.697805] pciback 0000:00:1a.0: setting latency timer to 64
    > [ =A0 28.713578] pciback 0000:00:19.0: enabling device (0000 -> 000= 3)
    > [ =A0 28.713591] xen: registering gsi 20 triggering 0 polarity 1
    > [ =A0 28.713598] Already setup the GSI :20
    > [ =A0 28.713858] pciback 0000:00:19.0: setting latency timer to 64
    > [ =A0 29.021371] pciback 0000:00:1d.0: enabling device (0000 -> 000= 2)
    > [ =A0 29.021389] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 29.021400] Already setup the GSI :17
    > [ =A0 29.021805] pciback 0000:00:1d.0: setting latency timer to 64
    > [ =A0 29.150053] pciback 0000:02:00.0: enabling device (0000 -> 000= 2)
    > [ =A0 29.150122] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0 29.150150] Already setup the GSI :17
    > [ =A0 33.635416] xen-blkback:ring-ref 9, event-channel 14, protocol 1 = (x86_64-abi)
    > [ =A0 33.643330] xen-blkback:ring-ref 10, event-channel 15, protocol 1= (x86_64-abi)
    > [ =A0 33.651561] xen-blkback:ring-ref 11, event-channel 16, protocol 1= (x86_64-abi)
    > [ =A0 33.672105] xen-blkback:ring-ref 12, event-channel 17, protocol 1= (x86_64-abi)
    > [ =A0104.230911] xen-blkback:ring-ref 9, event-channel 24, protocol 1 = (x86_64-abi)
    > [ =A0104.252421] xen-blkback:ring-ref 10, event-channel 25, protocol 1= (x86_64-abi)
    > [ =A0104.253177] xen-blkback:ring-ref 11, event-channel 26, protocol 1= (x86_64-abi)
    > [ =A0104.254220] xen-blkback:ring-ref 12, event-channel 27, protocol 1= (x86_64-abi)
    > [ =A0105.086732] xen-blkback:ring-ref 9, event-channel 14, protocol 1 = (x86_64-abi)
    > [ =A0105.105505] xen-blkback:ring-ref 10, event-channel 15, protocol 1= (x86_64-abi)
    > [ =A0105.115951] xen-blkback:ring-ref 11, event-channel 16, protocol 1= (x86_64-abi)
    > [ =A0105.127384] xen-blkback:ring-ref 12, event-channel 17, protocol 1= (x86_64-abi)
    > [ =A0105.929760] xen-blkback:ring-ref 9, event-channel 14, protocol 1 = (x86_64-abi)
    > [ =A0105.934841] xen-blkback:ring-ref 10, event-channel 15, protocol 1= (x86_64-abi)
    > [ =A0105.973920] xen-blkback:ring-ref 11, event-channel 16, protocol 1= (x86_64-abi)
    > [ =A0105.975320] xen-blkback:ring-ref 12, event-channel 17, protocol 1= (x86_64-abi)
    > [ =A0107.191781] xen-blkback:ring-ref 9, event-channel 14, protocol 1 = (x86_64-abi)
    > [ =A0107.203711] xen-blkback:ring-ref 10, event-channel 15, protocol 1= (x86_64-abi)
    > [ =A0107.208481] xen-blkback:ring-ref 11, event-channel 16, protocol 1= (x86_64-abi)
    > [ =A0107.212081] xen-blkback:ring-ref 12, event-channel 17, protocol 1= (x86_64-abi)
    > [ =A0733.434608] PM: Syncing filesystems ... done.
    > [ =A0733.436228] PM: Preparing system for mem sleep
    > [ =A0733.514803] Freezing user space processes ... (elapsed 0.01 secon= ds) done.
    > [ =A0733.530594] Freezing remaining freezable tasks ... (elapsed 0.01 = seconds) done.
    > [ =A0733.546589] PM: Entering mem sleep
    > [ =A0733.546741] Suspending console(s) (use no_console_suspend to debu= g)
    > [ =A0733.547431] sd 0:0:0:0: [sda] Synchronizing SCSI cache
    > [ =A0733.558336] sd 0:0:0:0: [sda] Stopping disk
    > [ =A0734.194656] PM: suspend of devices complete after 647.504 msecs > [ =A0734.195026] PM: late suspend of devices complete after 0.359 msec= s
    > [ =A0734.210655] PM: noirq suspend of devices complete after 15.614 ms= ecs
    > [ =A0734.211326] ACPI: Preparing to enter system sleep state S3
    > [ =A0734.235008] PM: Saving platform NVS memory
    > [ =A0734.328066] Disabling non-boot CPUs ...
    > [ =A0735.945491] ACPI: Low-level resume complete
    > [ =A0735.945579] PM: Restoring platform NVS memory
    > [ =A0736.000094] Enabling non-boot CPUs ...
    > [ =A0736.000256] installing Xen timer for CPU 1
    > [ =A0736.004594] CPU1 is up
    > [ =A0736.004819] installing Xen timer for CPU 2
    > [ =A0736.067516] CPU2 is up
    > [ =A0736.067770] installing Xen timer for CPU 3
    > [ =A0736.101535] CPU3 is up
    > [ =A0736.102470] ACPI: Waking up from system sleep state S3
    > [ =A0736.555932] PM: noirq resume of devices complete after 7.970 msec= s
    > [ =A0736.556506] PM: early resume of devices complete after 0.387 msec= s
    > [ =A0736.660336] i915 0000:00:02.0: setting latency timer to 64
    > [ =A0736.660404] pciback 0000:00:19.0: setting latency timer to 64
    > [ =A0736.660453] xen: registering gsi 16 triggering 0 polarity 1
    > [ =A0736.660460] Already setup the GSI :16
    > [ =A0736.660490] pciback 0000:00:1a.0: setting latency timer to 64
    > [ =A0736.660605] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0736.660610] Already setup the GSI :17
    > [ =A0736.660641] pciback 0000:00:1d.0: setting latency timer to 64
    > [ =A0736.660696] xen: registering gsi 22 triggering 0 polarity 1
    > [ =A0736.660701] Already setup the GSI :22
    > [ =A0736.661221] ahci 0000:00:1f.2: setting latency timer to 64
    > [ =A0736.689606] xen: registering gsi 18 triggering 0 polarity 1
    > [ =A0736.689608] Already setup the GSI :18
    > [ =A0736.689704] xen: registering gsi 17 triggering 0 polarity 1
    > [ =A0736.689706] Already setup the GSI :17
    > [ =A0736.711623] [drm] Enabling RC6 states: RC6 on, RC6p off, RC6pp of= f
    > [ =A0736.802676] watchdog: INTCAMT: cannot register miscdev on minor= =3D130 (err=3D-16)
    > [ =A0736.802678] watchdog: error registering /dev/watchdog (err=3D-16)=
    > [ =A0736.802680] mei 0000:00:16.0: unable to register watchdog device.=
    > [ =A0737.060106] ata2: SATA link up 1.5 Gbps (SStatus 113 SControl 300= )
    > [ =A0737.060330] ata4: SATA link down (SStatus 0 SControl 300)
    > [ =A0737.060372] ata5: SATA link down (SStatus 0 SControl 300)
    > [ =A0737.074123] ata2.00: configured for UDMA/133
    > [ =A0737.117629] ata6: SATA link down (SStatus 0 SControl 300)
    > [ =A0738.619036] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300= )
    > [ =A0738.743565] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected= by device (Stat=3D0x51 Err=3D0x04)
    > [ =A0738.901088] ata1.00: ACPI cmd 00/00:00:00:00:00:a0 (NOP) rejected= by device (Stat=3D0x51 Err=3D0x04)
    > [ =A0738.903441] ata1.00: configured for UDMA/100
    > [ =A0738.903843] sd 0:0:0:0: [sda] Starting disk
    > [ =A0738.905367] PM: resume of devices complete after 2348.851 msecs > [ =A0738.905922] PM: Finishing wakeup.
    > [ =A0738.905926] Restarting tasks ... done.
    > [ =A0738.911334] video LNXVIDEO:00: Restoring backlight state
    > [ =A0739.836250] dell_wmi: Received unknown WMI event (0x0)
    > [ =A0740.184759] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0740.239730] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0740.327711] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0740.373931] sdhci-pci 0000:0a:00.0: could not set regulator OCR (= -22)
    > [ =A0742.542022] hrtimer: interrupt took 102980031 ns
    > [ =A0757.609031] [sched_delayed] sched: RT throttling activated
    > [ =A0760.164427] hda-intel: IRQ timing workaround is activated for car= d #0. Suggest a bigger bdl_pos_adj.

    > (XEN) Xen version 4.1.3 (user@mar= marek.net) (gcc version 4.4.5 20101112 (Red Hat 4.4.5-2) (GCC) ) Mon No= v 26 15:25:32 EST 2012
    > (XEN) Latest ChangeSet: unavailable
    > (XEN) Bootloader: GNU GRUB 0.97
    > (XEN) Command line: console=3Dnone cpufreq=3Dverbose=3D1
    > (XEN) Video information:
    > (XEN) =A0VGA is text mode 80x25, font 8x16
    > (XEN) =A0VBE/DDC methods: V2; EDID transfer time: 1 seconds
    > (XEN) Disc information:
    > (XEN) =A0Found 1 MBR signatures
    > (XEN) =A0Found 1 EDD information structures
    > (XEN) Xen-e820 RAM map:
    > (XEN) =A00000000000000000 - 000000000009a800 (usable)
    > (XEN) =A0000000000009a800 - 00000000000a0000 (reserved)
    > (XEN) =A000000000000e0000 - 0000000000100000 (reserved)
    > (XEN) =A00000000000100000 - 0000000007eea000 (usable)
    > (XEN) =A00000000007eea000 - 0000000007f67000 (ACPI NVS)
    > (XEN) =A00000000007f67000 - 0000000007f70000 (usable)
    > (XEN) =A00000000007f70000 - 0000000007f76000 (ACPI NVS)
    > (XEN) =A00000000007f76000 - 0000000007f78000 (usable)
    > (XEN) =A00000000007f78000 - 0000000008000000 (ACPI NVS)
    > (XEN) =A00000000008000000 - 000000000dffd000 (usable)
    > (XEN) =A0000000000dffd000 - 000000000e000000 (ACPI data)
    > (XEN) =A0000000000e000000 - 0000000020000000 (usable)
    > (XEN) =A00000000020000000 - 0000000020200000 (reserved)
    > (XEN) =A00000000020200000 - 0000000040000000 (usable)
    > (XEN) =A00000000040000000 - 0000000040200000 (reserved)
    > (XEN) =A00000000040200000 - 00000000c83b4000 (usable)
    > (XEN) =A000000000c83b4000 - 00000000c840a000 (reserved)
    > (XEN) =A000000000c840a000 - 00000000c840e000 (usable)
    > (XEN) =A000000000c840e000 - 00000000c840f000 (reserved)
    > (XEN) =A000000000c840f000 - 00000000c8411000 (usable)
    > (XEN) =A000000000c8411000 - 00000000c8414000 (reserved)
    > (XEN) =A000000000c8414000 - 00000000c841e000 (usable)
    > (XEN) =A000000000c841e000 - 00000000c8428000 (reserved)
    > (XEN) =A000000000c8428000 - 00000000c8432000 (usable)
    > (XEN) =A000000000c8432000 - 00000000c8436000 (reserved)
    > (XEN) =A000000000c8436000 - 00000000cac00000 (usable)
    > (XEN) =A000000000cb800000 - 00000000cfa00000 (reserved)
    > (XEN) =A000000000fed1c000 - 00000000fed20000 (reserved)
    > (XEN) =A000000000ffc00000 - 00000000ffc20000 (reserved)
    > (XEN) =A00000000100000000 - 000000042e000000 (usable)
    > (XEN) ACPI: RSDP 000FE300, 0024 (r2 DELL =A0)
    > (XEN) ACPI: XSDT 0DFFEE18, 007C (r1 DELL =A0 =A0CBX3 =A0 =A0 6222004 M= SFT =A0 =A010013)
    > (XEN) ACPI: FACP 07F90D98, 00F4 (r4 DELL =A0 =A0CBX3 =A0 =A0 6222004 M= SFT =A0 =A010013)
    > (XEN) ACPI: DSDT 07F5E018, 8834 (r2 INT430 SYSFexxx =A0 =A0 1001 INTL = 20090903)
    > (XEN) ACPI: FACS 07FEDD40, 0040
    > (XEN) ACPI: APIC 0DFFDF18, 00CC (r2 DELL =A0 =A0CBX3 =A0 =A0 6222004 M= SFT =A0 =A010013)
    > (XEN) ACPI: TCPA 07FEED18, 0032 (r2 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A00 =A0 =A0 =A0 =A0 =A0 =A0 0)
    > (XEN) ACPI: SSDT 07F91A98, 02F9 (r1 DELLTP =A0 =A0 =A0TPM =A0 =A0 3000= INTL 20090903)
    > (XEN) ACPI: MCFG 07FEEC98, 003C (r1 DELL =A0 SNDYBRDG =A06222004 MSFT = =A0 =A0 =A0 97)
    > (XEN) ACPI: HPET 07FEEC18, 0038 (r1 A M I =A0 PCHHPET =A06222004 AMI. = =A0 =A0 =A0 =A03)
    > (XEN) ACPI: BOOT 07FEEB98, 0028 (r1 DELL =A0 CBX3 =A0 =A0 =A06222004 A= MI =A0 =A0 10013)
    > (XEN) ACPI: SSDT 07F75018, 0804 (r1 =A0PmRef =A0Cpu0Ist =A0 =A0 3000 I= NTL 20090903)
    > (XEN) ACPI: SSDT 07F74018, 0996 (r1 =A0PmRef =A0 =A0CpuPm =A0 =A0 3000= INTL 20090903)
    > (XEN) ACPI: DMAR 07F90C18, 00E8 (r1 INTEL =A0 =A0 =A0SNB =A0 =A0 =A0 = =A0 1 INTL =A0 =A0 =A0 =A01)
    > (XEN) ACPI: SLIC 07F7EC18, 0176 (r3 DELL =A0 =A0CBX3 =A0 =A0 6222004 M= SFT =A0 =A010013)
    > (XEN) System RAM: 16262MB (16652432kB)
    > (XEN) Domain heap initialised
    > (XEN) ACPI: 32/64X FACS address mismatch in FADT - 07fede40/0000000007= fedd40, using 32
    > (XEN) Processor #0 6:10 APIC version 21
    > (XEN) Processor #2 6:10 APIC version 21
    > (XEN) Processor #1 6:10 APIC version 21
    > (XEN) Processor #3 6:10 APIC version 21
    > (XEN) IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23 > (XEN) Enabling APIC mode: =A0Flat. =A0Using 1 I/O APICs
    > (XEN) Table is not found!
    > (XEN) Switched to APIC driver x2apic_cluster.
    > (XEN) Using scheduler: SMP Credit Scheduler (credit)
    > (XEN) Detected 2494.416 MHz processor.
    > (XEN) Initing memory sharing.
    > (XEN) Intel VT-d supported page sizes: 4kB.
    > (XEN) Intel VT-d supported page sizes: 4kB.
    > (XEN) Intel VT-d Snoop Control not 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 not enabled.
    > (XEN) I/O virtualisation enabled
    > (XEN) =A0- Dom0 mode: Relaxed
    > (XEN) Enabled directed EOI with ioapic_ack_old on!
    > (XEN) ENABLING IO-APIC IRQs
    > (XEN) =A0-> Using old ACK method
    > (XEN) Platform timer appears to have unexpectedly wrapped 1 times.
    > (XEN) Platform timer is 14.318MHz HPET
    > (XEN) Allocated console ring of 16 KiB.
    > (XEN) VMX: Supported advanced features:
    > (XEN) =A0- APIC MMIO access virtualisation
    > (XEN) =A0- APIC TPR shadow
    > (XEN) =A0- Extended Page Tables (EPT)
    > (XEN) =A0- Virtual-Processor Identifiers (VPID)
    > (XEN) =A0- Virtual NMI
    > (XEN) =A0- MSR direct-access bitmap
    > (XEN) =A0- Unrestricted Guest
    > (XEN) HVM: ASIDs enabled.
    > (XEN) HVM: VMX enabled
    > (XEN) HVM: Hardware Assisted Paging (HAP) detected
    > (XEN) HVM: HAP page sizes: 4kB, 2MB
    > (XEN) Brought up 4 CPUs
    > (XEN) *** LOADING DOMAIN 0 ***
    > (XEN) =A0Xen =A0kernel: 64-bit, lsb, compat32
    > (XEN) =A0Dom0 kernel: 64-bit, PAE, lsb, paddr 0x1000000 -> 0x1e1300= 0
    > (XEN) PHYSICAL MEMORY ARRANGEMENT:
    > (XEN) =A0Dom0 alloc.: =A0 0000000418000000->000000041c000000 (40465= 67 pages to be allocated)
    > (XEN) =A0Init. ramdisk: 000000042b335000->000000042dfffc00
    > (XEN) VIRTUAL MEMORY ARRANGEMENT:
    > (XEN) =A0Loaded kernel: ffffffff81000000->ffffffff81e13000
    > (XEN) =A0Init. ramdisk: ffffffff81e13000->ffffffff84addc00
    > (XEN) =A0Phys-Mach map: ffffffff84ade000->ffffffff869f3d90
    > (XEN) =A0Start info: =A0 =A0ffffffff869f4000->ffffffff869f44b4
    > (XEN) =A0Page tables: =A0 ffffffff869f5000->ffffffff86a2e000
    > (XEN) =A0Boot stack: =A0 =A0ffffffff86a2e000->ffffffff86a2f000
    > (XEN) =A0TOTAL: =A0 =A0 =A0 =A0 ffffffff80000000->ffffffff86c00000<= br> > (XEN) =A0ENTRY ADDRESS: ffffffff8188e200
    > (XEN) Dom0 has maximum 4 VCPUs
    > (XEN) Scrubbing Free RAM: .done.
    > (XEN) Xen trace buffers: disabled
    > (XEN) Std. Loglevel: Errors and warnings
    > (XEN) Guest Loglevel: Nothing (Rate-limited: Errors and warnings)
    > (XEN) *** Serial input -> DOM0 (type 'CTRL-a' three times t= o switch input to Xen)
    > (XEN) Freed 216kB init memory.
    > (XEN) no cpu_id for acpi_id 5
    > (XEN) no cpu_id for acpi_id 6
    > (XEN) no cpu_id for acpi_id 7
    > (XEN) no cpu_id for acpi_id 8
    > (XEN) physdev.c:171: dom0: wrong map_pirq type 3
    > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc9000057b030.
    > (XEN) traps.c:2488:d1 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000718030.
    > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004f2030.
    > (XEN) traps.c:2488:d2 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004fa030.
    > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000251030.
    > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000263030.
    > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc9000026b030.
    > (XEN) traps.c:2488:d3 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000273030.
    > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004f2030.
    > (XEN) traps.c:2488:d4 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000015030.
    > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004f2030.
    > (XEN) traps.c:2488:d5 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000015030.
    > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004f2030.
    > (XEN) traps.c:2488:d6 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc900004fa030.
    > (XEN) Disabling non-boot CPUs ...
    > (XEN) Broke affinity for irq 1
    > (XEN) Broke affinity for irq 8
    > (XEN) Broke affinity for irq 9
    > (XEN) Broke affinity for irq 12
    > (XEN) Broke affinity for irq 17
    > (XEN) Broke affinity for irq 31
    > (XEN) Broke affinity for irq 16
    > (XEN) Broke affinity for irq 20
    > (XEN) Entering ACPI S3 state.
    > (XEN) mce_intel.c:1162: MCA Capability: BCAST 1 SER 0 CMCI 1 firstbank= 0 extended MCE MSR 0
    > (XEN) CPU0 CMCI LVT vector (0xf7) already installed
    > (XEN) CPU0: Thermal LVT vector (0xfa) already installed
    > (XEN) Finishing wakeup from ACPI S3 state.
    > (XEN) Enabling non-boot CPUs =A0...
    > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000524030.
    > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc9000052c030.
    > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc90000015030.
    > (XEN) traps.c:2488:d7 Domain attempted WRMSR 0000000000000079 from 0x0= 000000000000000 to 0xffffc9000001d030.
    > (XEN) Dumping timer queues:
    > (XEN) CPU00:
    > (XEN) =A0 ex=3D =A0 =A0 126us timer=3Dffff8300c83b0060 cb=3Dffff82c480= 11e420(ffff8300c83b0000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 =A01778us timer=3Dffff8304222f9de8 cb=3Dffff82c480= 118250(0000000000000000) csched_tick+0x0/0x2e0
    > (XEN) =A0 ex=3D =A0 =A0 126us timer=3Dffff8300c81fc060 cb=3Dffff82c480= 11e420(ffff8300c81fc000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 17227us timer=3Dffff82c4802bb980 cb=3Dffff82c48013= 8ff0(ffff82c4802bb940) do_dbs_timer+0x0/0x250
    > (XEN) =A0 ex=3D =A0 20744us timer=3Dffff830030094060 cb=3Dffff82c48011= e420(ffff830030094000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 27945us timer=3Dffff8304222fdde0 cb=3Dffff82c48011= 6f20(ffff8304222fddc0) csched_acct+0x0/0x460
    > (XEN) =A0 ex=3D =A0 29949us timer=3Dffff82c4802bb760 cb=3Dffff82c48011= ded0(0000000000000000) s_timer_fn+0x0/0x20
    > (XEN) =A0 ex=3D =A0 87774us timer=3Dffff83008db6a060 cb=3Dffff82c48011= e420(ffff83008db6a000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 79252us timer=3Dffff82c4802b3880 cb=3Dffff82c48017= 7160(0000000000000000) time_calibration+0x0/0x60
    > (XEN) =A0 ex=3D =A0703146us timer=3Dffff8300a6b9c060 cb=3Dffff82c48011= e420(ffff8300a6b9c000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 35612us timer=3Dffff8300330dc060 cb=3Dffff82c48011= e420(ffff8300330dc000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 97688us timer=3Dffff8300a6b98060 cb=3Dffff82c48011= e420(ffff8300a6b98000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 30003us timer=3Dffff8300b129a060 cb=3Dffff82c48011= e420(ffff8300b129a000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 92679us timer=3Dffff8300c94a6060 cb=3Dffff82c48011= e420(ffff8300c94a6000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D 4135118us timer=3Dffff8300bdca6060 cb=3Dffff82c48011e4= 20(ffff8300bdca6000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 96411us timer=3Dffff8300b128e060 cb=3Dffff82c48011= e420(ffff8300b128e000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D 1337866us timer=3Dffff8300a6b94060 cb=3Dffff82c48011e4= 20(ffff8300a6b94000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 91194us timer=3Dffff830034b98060 cb=3Dffff82c48011= e420(ffff830034b98000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 97955us timer=3Dffff83007d948060 cb=3Dffff82c48011= e420(ffff83007d948000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D 4135163us timer=3Dffff8300c5336060 cb=3Dffff82c48011e4= 20(ffff8300c5336000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D123464409us timer=3Dffff82c4802b3980 cb=3Dffff82c480176= ef0(0000000000000000) plt_overflow+0x0/0x190
    > (XEN) =A0 ex=3D =A0 95968us timer=3Dffff8300a6b96060 cb=3Dffff82c48011= e420(ffff8300a6b96000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D12401701us timer=3Dffff82c4802b65a0 cb=3Dffff82c48019eb= 10(0000000000000000) mce_work_fn+0x0/0xd0
    > (XEN) =A0 ex=3D =A0 97804us timer=3Dffff8300301a8060 cb=3Dffff82c48011= e420(ffff8300301a8000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 97841us timer=3Dffff8300bd810060 cb=3Dffff82c48011= e420(ffff8300bd810000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 98039us timer=3Dffff83007d94c060 cb=3Dffff82c48011= e420(ffff83007d94c000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0 94727us timer=3Dffff83008db6e060 cb=3Dffff82c48011= e420(ffff83008db6e000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) =A0 ex=3D =A0319927us timer=3Dffff8300c840c060 cb=3Dffff82c48011= e420(ffff8300c840c000) vcpu_singleshot_timer_fn+0x0/0x10
    > (XEN) CPU01:
    > (XEN) CPU02:
    > (XEN) CPU03:
    > (XEN) 'c' pressed -> printing ACPI Cx structures
    > (XEN) =3D=3Dcpu0=3D=3D
    > (XEN) active state: =A0 =A0 =A0 =A0 =A0 C3
    > (XEN) max_cstate: =A0 =A0 =A0 =A0 =A0 =A0 C7
    > (XEN) states:
    > (XEN) =A0 =A0 C1: type[C1] latency[000] usage[00254665] method[ HALT] = duration[62720099833]
    > (XEN) =A0 =A0 C2: type[C2] latency[080] usage[00069505] method[SYSIO] = duration[36499255195]
    > (XEN) =A0 =A0*C3: type[C3] latency[109] usage[01828952] method[SYSIO] = duration[5562126933174]
    > (XEN) =A0 =A0 C0: usage[02153122] duration[2042526389598]
    > (XEN) PC3[0] PC6[0] PC7[0]
    > (XEN) CC3[0] CC6[0]
    > (XEN) =3D=3Dcpu1=3D=3D
    > (XEN) active state: =A0 =A0 =A0 =A0 =A0 C1
    > (XEN) max_cstate: =A0 =A0 =A0 =A0 =A0 =A0 C7
    > (XEN) states:
    > (XEN) =A0 =A0*C1: type[C1] latency[000] usage[00808027] method[ HALT] = duration[6978799306750]
    > (XEN) =A0 =A0 C0: usage[00808027] duration[725073398104]
    > (XEN) PC3[0] PC6[0] PC7[0]
    > (XEN) CC3[0] CC6[0]
    > (XEN) =3D=3Dcpu2=3D=3D
    > (XEN) active state: =A0 =A0 =A0 =A0 =A0 C1
    > (XEN) max_cstate: =A0 =A0 =A0 =A0 =A0 =A0 C7
    > (XEN) states:
    > (XEN) =A0 =A0*C1: type[C1] latency[000] usage[00825022] method[ HALT] = duration[6981527416097]
    > (XEN) =A0 =A0 C0: usage[00825022] duration[722345319882]
    > (XEN) PC3[0] PC6[0] PC7[0]
    > (XEN) CC3[0] CC6[0]
    > (XEN) =3D=3Dcpu3=3D=3D
    > (XEN) active state: =A0 =A0 =A0 =A0 =A0 C1
    > (XEN) max_cstate: =A0 =A0 =A0 =A0 =A0 =A0 C7
    > (XEN) states:
    > (XEN) =A0 =A0*C1: type[C1] latency[000] usage[00810292] method[ HALT] = duration[6980835907857]
    > (XEN) =A0 =A0 C0: usage[00810292] duration[723036844779]
    > (XEN) PC3[0] PC6[0] PC7[0]
    > (XEN) CC3[0] CC6[0]




    > _______________________________________________
    > Xen-devel mailing list
    > Xen-devel@lists.xen.org=
    > http://li= sts.xen.org/xen-devel


    --e89a8f3b9d3d4a9abe04cfbdb242-- --===============3744638461939860863== 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 --===============3744638461939860863==--